diff --git a/.github/workflows/install-and-test.yml b/.github/workflows/install-and-test.yml
index 0ea43dc85..d3caa71c1 100644
--- a/.github/workflows/install-and-test.yml
+++ b/.github/workflows/install-and-test.yml
@@ -75,9 +75,12 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-meps-reduced-example-data-v0.3.0
 
-      - name: Run tests
+      - name: Run tests (excluding notebooks)
         run: |
-          pytest -vv -s --doctest-modules
+          pytest -vv -s --doctest-modules --ignore=docs/notebooks
+
+      # Notebooks run in their own path-filtered, CPU-only workflow
+      # (.github/workflows/notebook-tests.yml).
 
       - name: Upload test figures
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/notebook-tests.yml b/.github/workflows/notebook-tests.yml
new file mode 100644
index 000000000..790525d85
--- /dev/null
+++ b/.github/workflows/notebook-tests.yml
@@ -0,0 +1,42 @@
+# Runs the docs/notebooks/ tutorials end-to-end with nbmake so that API drift
+# in neural_lam breaks the notebook loudly instead of letting it rot. CPU-only.
+# Scoped to PRs that touch code the notebooks depend on (plus every push to
+# main and manual dispatch), so unrelated PRs don't pay the ~3 min cost.
+name: Notebook tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - "neural_lam/**"
+      - "docs/notebooks/**"
+      - "tests/datastore_examples/**"
+      - "pyproject.toml"
+      - "uv.lock"
+      - ".github/workflows/notebook-tests.yml"
+  workflow_dispatch:
+
+jobs:
+  notebooks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python 3.13
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.13
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Install with uv
+        run: |
+          uv sync --extra cpu --group dev --locked
+          echo "$PWD/.venv/bin" >> $GITHUB_PATH
+
+      - name: Run notebook tests
+        run: |
+          pytest -vv -s --nbmake --nbmake-timeout=600 docs/notebooks/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 229326ea0..eb1168eaa 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,6 +17,12 @@ repos:
     hooks:
       - id: codespell
         description: Check for spelling errors
+        # codespell reads [tool.codespell] from pyproject.toml via tomllib,
+        # which is unavailable on Python <3.11 unless `tomli` is installed;
+        # on such runners the config silently fails to load. Pass --skip
+        # explicitly so it doesn't depend on that.
+        args:
+          - --skip=requirements/*,docs/notebooks/hello_world_danra.ipynb
 
   - repo: https://github.com/psf/black
     rev: 25.11.0
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 62dcb7640..5a255b66f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [unreleased](https://github.com/mllam/neural-lam/compare/v0.6.0...HEAD)
 
 ### Added
+- Add `hello_world_danra.ipynb` end-to-end tutorial notebook for training on DANRA, with a dedicated path-filtered CI workflow that runs it end-to-end via `nbmake` [\#577](https://github.com/mllam/neural-lam/pull/577) @Sharkyii
+
 - Add `--num_sanity_val_steps` CLI argument to control sanity validation steps before training (#694)
 
 - Add `--train_steps_to_log` CLI option to log training loss for individual unroll steps, and deduplicate common prediction and loss computation steps across loops [\#674](https://github.com/mllam/neural-lam/issues/674) @GiGiKoneti
@@ -48,6 +50,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- `train_model.main` now re-raises on error (`@logger.catch(reraise=True)`) instead of logging and exiting 0, so training/eval failures surface to callers and CI (e.g. the notebook `nbmake` run) rather than passing silently [\#577](https://github.com/mllam/neural-lam/pull/577)
+
+- Allow `graph_lam` training and checkpoint reloads to accept the full set of
+  GNN type CLI options without passing hierarchical-only options to unsupported
+  constructors via a shared `build_predictor` helper ([#686](https://github.com/mllam/neural-lam/issues/686)).
+
 - Fix `RuntimeError` in `HiLAMParallel` forward pass on hierarchical graphs by offsetting edge indices into the global mesh node index space ([#679](https://github.com/mllam/neural-lam/issues/679))
 
 - Fix `IndexError` in HiLAM forward pass by offsetting grid nodes in `zero_index_g2m`/`zero_index_m2g` by the total mesh-node count across all levels ([#642](https://github.com/mllam/neural-lam/issues/642)) @Sir-Sloth-The-Lazy
diff --git a/docs/notebooks/conftest.py b/docs/notebooks/conftest.py
new file mode 100644
index 000000000..6a248848e
--- /dev/null
+++ b/docs/notebooks/conftest.py
@@ -0,0 +1,23 @@
+# Standard library
+import subprocess
+import sys
+from pathlib import Path
+
+# Third-party
+import pytest
+
+
+@pytest.fixture(scope="session", autouse=True)
+def setup_danra_datastore():
+    """Create the DANRA zarr datastore required by hello_world_danra.ipynb."""
+    datastore_config = Path(
+        "tests/datastore_examples/mdp/danra_100m_winds/danra.datastore.yaml"
+    )
+    zarr_output = datastore_config.parent / "danra.datastore.zarr"
+
+    # Only create if it doesn't exist
+    if not zarr_output.exists():
+        subprocess.run(
+            [sys.executable, "-m", "mllam_data_prep", str(datastore_config)],
+            check=True,
+        )
diff --git a/docs/notebooks/create_reduced_meps_dataset.ipynb b/docs/notebooks/create_reduced_meps_dataset.ipynb
index daba23c44..0bcdd94e3 100644
--- a/docs/notebooks/create_reduced_meps_dataset.ipynb
+++ b/docs/notebooks/create_reduced_meps_dataset.ipynb
@@ -13,7 +13,11 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "skip-execution"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Standard library\n",
@@ -36,7 +40,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "skip-execution"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Load existing grid\n",
@@ -61,7 +69,11 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "skip-execution"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Outer 10 grid points are border\n",
@@ -91,7 +103,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "skip-execution"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Load surface_geopotential.npy, index only values from the reduced grid, and save to new file\n",
@@ -124,7 +140,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "skip-execution"
+    ]
+   },
    "outputs": [],
    "source": [
     "num_vars = 8\n",
@@ -162,7 +182,11 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "skip-execution"
+    ]
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -188,7 +212,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "skip-execution"
+    ]
+   },
    "outputs": [],
    "source": [
     "for sample in ['train', 'test', 'val']:\n",
diff --git a/docs/notebooks/hello_world_danra.ipynb b/docs/notebooks/hello_world_danra.ipynb
new file mode 100644
index 000000000..d8ac52b46
--- /dev/null
+++ b/docs/notebooks/hello_world_danra.ipynb
@@ -0,0 +1,1093 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Hello World: Training `neural-lam` on DANRA\n",
+    "\n",
+    "This notebook provides a **beginner-friendly, end-to-end walkthrough** for running a minimal model training pipeline in `neural-lam` using a small, public DANRA dataset.\n",
+    "\n",
+    "It covers:\n",
+    "1. Environment setup (CPU-safe)\n",
+    "2. Data preprocessing with `mllam-data-prep`\n",
+    "3. Graph generation (single-level, for speed)\n",
+    "4. Training for 1 epoch on CPU\n",
+    "5. Evaluation and example predictions\n",
+    "6. Scaling tips for bigger runs\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### Prerequisites and Context\n",
+    "\n",
+    "> **Important:** This notebook is designed to be run from inside a **local clone** of [`mllam/neural-lam`](https://github.com/mllam/neural-lam). All paths are relative to the repository root.\n",
+    "> \n",
+    "> **Paper Reference:** For an in-depth context on the models used here, please refer to the paper \\\n",
+    "    \"Building Machine Learning Limited Area Models: Kilometer-Scale Weather Forecasting in Realistic Settings\" \\\n",
+    "    (Adamov et al., 2025) available at [arXiv:2504.09340](https://arxiv.org/abs/2504.09340).\n",
+    ">\n",
+    "> **Python Version:** Make sure you are using a Python version supported by the project (e.g. 3.10-3.14) with `ipykernel` installed.\n",
+    "> \n",
+    "> **Note on Future Graph Updates:** The graph generation step currently uses `create_graph.py`, but it will be migrated to use the upcoming `weather-model-graphs` package in the near future.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import glob\n",
+    "import os\n",
+    "import subprocess\n",
+    "import sys\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import xarray as xr\n",
+    "from IPython.display import Image, display\n",
+    "\n",
+    "import neural_lam\n",
+    "from neural_lam.config import load_config_and_datastore\n",
+    "from neural_lam import utils\n",
+    "from neural_lam.plot_graph import plot_graph as _plot_graph\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Current directory: /home/simac/neural-lam\n",
+      "Repo contents: ['LICENSE.txt', 'pyproject.toml', 'tests', 'docs', 'uv.lock', 'neural_lam', 'figures', 'CHANGELOG.md', 'README.md', 'AGENTS.md']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Verify we are at the repo root (should see neural_lam/, docs/, tests/, etc.)\n",
+    "print(\"Current directory:\", os.getcwd())\n",
+    "print(\"Repo contents:\", [f for f in os.listdir(\".\") if not f.startswith(\".\")])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Current working directory: /home/simac/neural-lam\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The notebook is typically located in docs/notebooks/.\n",
+    "# Change the working directory to the repository root so that paths like 'tests/...' resolve correctly.\n",
+    "if os.getcwd().endswith(\"notebooks\"):\n",
+    "    os.chdir(\"../../\")\n",
+    "print(\"Current working directory:\", os.getcwd())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Environment Setup\n",
+    "\n",
+    "Set up the environment with [`uv`](https://docs.astral.sh/uv/) from the repository root (see the [README](https://github.com/mllam/neural-lam#installation)):\n",
+    "\n",
+    "```bash\n",
+    "uv sync --extra cpu --group dev\n",
+    "```\n",
+    "\n",
+    "This creates a `.venv` with the CPU build of PyTorch plus the development dependencies. For GPU runs swap `--extra cpu` for `--extra gpu` (CUDA 13.0) or `--extra gpu-cu128` (CUDA 12.8).\n",
+    "\n",
+    "Run the rest of this notebook on that environment's kernel (Python >=3.10 with `ipykernel` installed)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "neural-lam version: 0.6.1.dev69+g96d574feb.d20260715\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Verify the install\n",
+    "print(\"neural-lam version:\", neural_lam.__version__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Data Configuration & Preprocessing\n",
+    "\n",
+    "We use the **DANRA 100m winds example** already in this repo at:\n",
+    "```\n",
+    "tests/datastore_examples/mdp/danra_100m_winds/\n",
+    "  ├── config.yaml          ← neural-lam configuration\n",
+    "  └── danra.datastore.yaml ← mllam-data-prep datastore config\n",
+    "```\n",
+    "\n",
+    "This example uses a **cropped DANRA dataset** (~100×100 grid points, ~10 days in April 2022) served from a public ECMWF object store — no local data download is required.\n",
+    "\n",
+    "The `mllam-data-prep` command reads the datastore config, fetches the data, and writes a processed `.zarr` archive to disk.\n",
+    "\n",
+    "> **Version requirement:** This notebook requires `mllam-data-prep >= 0.6.0`. Check with `python -m mllam_data_prep --version` or upgrade with `uv pip install --upgrade mllam-data-prep`.\\n\n",
+    ">\\n\n",
+    "> **Note:** This will download and process approximately 60–120 MB of data. It may take a few minutes on the first run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2026-07-15 22:15:50.243\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset_zarr\u001b[0m:\u001b[36m420\u001b[0m - \u001b[1mRemoving existing dataset at tests/datastore_examples/mdp/danra_100m_winds/danra.datastore.zarr\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:50.265\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m169\u001b[0m - \u001b[1mLoading dataset danra_height_levels from https://object-store.os-api.cci1.ecmwf.int/mllam-testdata/danra_cropped/v0.2.0/height_levels.zarr\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:51.206\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m183\u001b[0m - \u001b[1mExtracting selected variables from dataset danra_height_levels\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:51.267\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m229\u001b[0m - \u001b[1mMapping dimensions and variables for dataset danra_height_levels to state\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:51.288\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m169\u001b[0m - \u001b[1mLoading dataset danra_surface_forcing from https://object-store.os-api.cci1.ecmwf.int/mllam-testdata/danra_cropped/v0.2.0/single_levels.zarr\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:51.692\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m183\u001b[0m - \u001b[1mExtracting selected variables from dataset danra_surface_forcing\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:51.693\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m229\u001b[0m - \u001b[1mMapping dimensions and variables for dataset danra_surface_forcing to forcing\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:51.717\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m169\u001b[0m - \u001b[1mLoading dataset danra_surface from https://object-store.os-api.cci1.ecmwf.int/mllam-testdata/danra_cropped/v0.2.0/single_levels.zarr\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.103\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m183\u001b[0m - \u001b[1mExtracting selected variables from dataset danra_surface\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.104\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m229\u001b[0m - \u001b[1mMapping dimensions and variables for dataset danra_surface to state\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.126\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m169\u001b[0m - \u001b[1mLoading dataset danra_static from https://object-store.os-api.cci1.ecmwf.int/mllam-testdata/danra_cropped/v0.2.0/single_levels.zarr\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.510\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m183\u001b[0m - \u001b[1mExtracting selected variables from dataset danra_static\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.511\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m229\u001b[0m - \u001b[1mMapping dimensions and variables for dataset danra_static to static\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.527\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36m_merge_dataarrays_by_target\u001b[0m:\u001b[36m72\u001b[0m - \u001b[1mMerging dataarrays for target variable `state`\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.773\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36m_merge_dataarrays_by_target\u001b[0m:\u001b[36m72\u001b[0m - \u001b[1mMerging dataarrays for target variable `forcing`\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:52.777\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36m_merge_dataarrays_by_target\u001b[0m:\u001b[36m72\u001b[0m - \u001b[1mMerging dataarrays for target variable `static`\u001b[0m\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/mllam_data_prep/create_dataset.py:105: FutureWarning: In a future version of xarray the default value for compat will change from compat='no_conflicts' to compat='override'. This is likely to lead to different results when combining overlapping variables with the same name. To opt in to new defaults and get rid of these warnings now use `set_options(use_new_combine_kwarg_defaults=True) or set compat explicitly.\n",
+      "  ds = xr.merge(dataarrays, join=\"exact\")\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/mllam_data_prep/create_dataset.py:105: FutureWarning: In a future version of xarray the default value for compat will change from compat='no_conflicts' to compat='override'. This is likely to lead to different results when combining overlapping variables with the same name. To opt in to new defaults and get rid of these warnings now use `set_options(use_new_combine_kwarg_defaults=True) or set compat explicitly.\n",
+      "  ds = xr.merge(dataarrays, join=\"exact\")\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/mllam_data_prep/create_dataset.py:105: FutureWarning: In a future version of xarray the default value for compat will change from compat='no_conflicts' to compat='override'. This is likely to lead to different results when combining overlapping variables with the same name. To opt in to new defaults and get rid of these warnings now use `set_options(use_new_combine_kwarg_defaults=True) or set compat explicitly.\n",
+      "  ds = xr.merge(dataarrays, join=\"exact\")\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/mllam_data_prep/create_dataset.py:105: FutureWarning: In a future version of xarray the default value for compat will change from compat='no_conflicts' to compat='override'. This is likely to lead to different results when combining overlapping variables with the same name. To opt in to new defaults and get rid of these warnings now use `set_options(use_new_combine_kwarg_defaults=True) or set compat explicitly.\n",
+      "  ds = xr.merge(dataarrays, join=\"exact\")\n",
+      "\u001b[32m2026-07-15 22:15:53.304\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m262\u001b[0m - \u001b[1mChunking dataset with {'time': 1}\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:53.316\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m270\u001b[0m - \u001b[1mSetting splitting information to define `['train', 'val', 'test']` splits along dimension `time`\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:53.319\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset\u001b[0m:\u001b[36m280\u001b[0m - \u001b[1mComputing statistics for split train\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:15:53.383\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset_zarr\u001b[0m:\u001b[36m429\u001b[0m - \u001b[1mWriting dataset to zarr\u001b[0m\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=26, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=5, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=10, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=25, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=7, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=16, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=9, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=19, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=21, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/core/dtype/npy/string.py:249: UnstableSpecificationWarning: The data type (FixedLengthUTF32(length=12, endianness='little')) does not have a Zarr V3 specification. That means that the representation of arrays saved with this data type may change without warning in a future version of Zarr Python. Arrays stored with this data type may be unreadable by other Zarr libraries. Use this data type at your own risk! Check https://github.com/zarr-developers/zarr-extensions/tree/main/data-types for the status of data type specifications for Zarr V3.\n",
+      "  v3_unstable_dtype_warning(self)\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/zarr/api/asynchronous.py:247: ZarrUserWarning: Consolidated metadata is currently not part in the Zarr format 3 specification. It may not be supported by other zarr implementations and may change in the future.\n",
+      "  warnings.warn(\n",
+      "\u001b[32m2026-07-15 22:16:00.758\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset_zarr\u001b[0m:\u001b[36m442\u001b[0m - \u001b[1mWrote training-ready dataset to tests/datastore_examples/mdp/danra_100m_winds/danra.datastore.zarr\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:00.758\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmllam_data_prep.create_dataset\u001b[0m:\u001b[36mcreate_dataset_zarr\u001b[0m:\u001b[36m444\u001b[0m - \u001b[1m<xarray.Dataset> Size: 23MB\n",
+      "Dimensions:                         (grid_index: 7680, time: 73,\n",
+      "                                     state_feature: 4, forcing_feature: 1,\n",
+      "                                     static_feature: 2, split_name: 3,\n",
+      "                                     split_part: 2)\n",
+      "Coordinates: (12/20)\n",
+      "  * grid_index                      (grid_index) int64 61kB 0 1 2 ... 7678 7679\n",
+      "    lat                             (grid_index) float64 61kB dask.array<chunksize=(7680,), meta=np.ndarray>\n",
+      "    lon                             (grid_index) float64 61kB dask.array<chunksize=(7680,), meta=np.ndarray>\n",
+      "    x                               (grid_index) float64 61kB dask.array<chunksize=(7680,), meta=np.ndarray>\n",
+      "    y                               (grid_index) float64 61kB dask.array<chunksize=(7680,), meta=np.ndarray>\n",
+      "  * time                            (time) datetime64[ns] 584B 2022-04-01 ......\n",
+      "    ...                              ...\n",
+      "  * static_feature                  (static_feature) <U9 72B 'lsm' 'orography'\n",
+      "    static_feature_units            (static_feature) <U10 80B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "    static_feature_long_name        (static_feature) <U26 208B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "    static_feature_source_dataset   (static_feature) <U12 96B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "  * split_name                      (split_name) <U5 60B 'train' 'val' 'test'\n",
+      "  * split_part                      (split_part) <U5 40B 'start' 'end'\n",
+      "Data variables: (12/14)\n",
+      "    state                           (time, state_feature, grid_index) float64 18MB dask.array<chunksize=(1, 4, 7680), meta=np.ndarray>\n",
+      "    forcing                         (forcing_feature, time, grid_index) float64 4MB dask.array<chunksize=(1, 1, 7680), meta=np.ndarray>\n",
+      "    static                          (static_feature, grid_index) float64 123kB dask.array<chunksize=(2, 7680), meta=np.ndarray>\n",
+      "    state__train__mean              (state_feature) float64 32B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "    forcing__train__mean            (forcing_feature) float64 8B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    static__train__mean             (static_feature) float64 16B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "    ...                              ...\n",
+      "    static__train__std              (static_feature) float64 16B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "    state__train__diff_mean         (state_feature) float64 32B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "    forcing__train__diff_mean       (forcing_feature) float64 8B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    state__train__diff_std          (state_feature) float64 32B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "    forcing__train__diff_std        (forcing_feature) float64 8B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    splits                          (split_name, split_part) <U16 384B '2022-...\n",
+      "Attributes:\n",
+      "    schema_version:   v0.5.0\n",
+      "    dataset_version:  v0.1.0\n",
+      "    created_on:       2026-07-15T22:15:53\n",
+      "    created_with:     mllam-data-prep (https://github.com/mllam/mllam-data-prep)\n",
+      "    mdp_version:      v0.7.0\n",
+      "    creation_config:  dataset-version: v0.1.0\\nextra:\\n  projection:\\n    cla...\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run mllam-data-prep to create the processed DANRA .zarr dataset\n",
+    "# Output will appear next to danra.datastore.yaml as danra.datastore.zarr\n",
+    "!{sys.executable} -m mllam_data_prep \\\n",
+    "    tests/datastore_examples/mdp/danra_100m_winds/danra.datastore.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Zarr dataset at: tests/datastore_examples/mdp/danra_100m_winds/danra.datastore.zarr\n"
+     ]
+    }
+   ],
+   "source": [
+    "zarr_path = \"tests/datastore_examples/mdp/danra_100m_winds/danra.datastore.zarr\"\n",
+    "if os.path.exists(zarr_path):\n",
+    "    print(\"Zarr dataset at:\", zarr_path)\n",
+    "else:\n",
+    "    print(\"zarr dataset not found — check the output above for errors.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.Dataset> Size: 23MB\n",
+      "Dimensions:                         (forcing_feature: 1, time: 73,\n",
+      "                                     grid_index: 7680, split_name: 3,\n",
+      "                                     split_part: 2, state_feature: 4,\n",
+      "                                     static_feature: 2)\n",
+      "Coordinates: (12/20)\n",
+      "  * forcing_feature                 (forcing_feature) <U7 28B 'swavr0m'\n",
+      "    forcing_feature_long_name       (forcing_feature) <U25 100B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    forcing_feature_source_dataset  (forcing_feature) <U21 84B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    forcing_feature_units           (forcing_feature) <U7 28B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "  * time                            (time) datetime64[ns] 584B 2022-04-01 ......\n",
+      "  * grid_index                      (grid_index) int64 61kB 0 1 2 ... 7678 7679\n",
+      "    ...                              ...\n",
+      "    state_feature_source_dataset    (state_feature) <U19 304B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "    state_feature_units             (state_feature) <U7 112B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "  * static_feature                  (static_feature) <U9 72B 'lsm' 'orography'\n",
+      "    static_feature_long_name        (static_feature) <U26 208B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "    static_feature_source_dataset   (static_feature) <U12 96B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "    static_feature_units            (static_feature) <U10 80B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "Data variables: (12/14)\n",
+      "    forcing                         (forcing_feature, time, grid_index) float64 4MB dask.array<chunksize=(1, 1, 7680), meta=np.ndarray>\n",
+      "    forcing__train__diff_mean       (forcing_feature) float64 8B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    forcing__train__diff_std        (forcing_feature) float64 8B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    forcing__train__mean            (forcing_feature) float64 8B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    forcing__train__std             (forcing_feature) float64 8B dask.array<chunksize=(1,), meta=np.ndarray>\n",
+      "    splits                          (split_name, split_part) <U16 384B dask.array<chunksize=(3, 2), meta=np.ndarray>\n",
+      "    ...                              ...\n",
+      "    state__train__diff_std          (state_feature) float64 32B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "    state__train__mean              (state_feature) float64 32B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "    state__train__std               (state_feature) float64 32B dask.array<chunksize=(4,), meta=np.ndarray>\n",
+      "    static                          (static_feature, grid_index) float64 123kB dask.array<chunksize=(2, 7680), meta=np.ndarray>\n",
+      "    static__train__mean             (static_feature) float64 16B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "    static__train__std              (static_feature) float64 16B dask.array<chunksize=(2,), meta=np.ndarray>\n",
+      "Attributes:\n",
+      "    schema_version:   v0.5.0\n",
+      "    dataset_version:  v0.1.0\n",
+      "    created_on:       2026-07-15T22:15:53\n",
+      "    created_with:     mllam-data-prep (https://github.com/mllam/mllam-data-prep)\n",
+      "    mdp_version:      v0.7.0\n",
+      "    creation_config:  dataset-version: v0.1.0\\nextra:\\n  projection:\\n    cla...\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "ds = xr.open_zarr(\"tests/datastore_examples/mdp/danra_100m_winds/danra.datastore.zarr\")\n",
+    "print(ds)\n",
+    "\n",
+    "if \"state\" in ds:\n",
+    "    # First state feature (u100m) at the first timestep\n",
+    "    da = ds[\"state\"].isel(time=0, state_feature=0)\n",
+    "    values = da.values\n",
+    "\n",
+    "    x = ds.coords[\"x\"].values if \"x\" in ds.coords else None\n",
+    "    y = ds.coords[\"y\"].values if \"y\" in ds.coords else None\n",
+    "\n",
+    "    fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "\n",
+    "    if x is not None and y is not None:\n",
+    "        x_unique = np.sort(np.unique(x))\n",
+    "        y_unique = np.sort(np.unique(y))\n",
+    "        xi = np.searchsorted(x_unique, x)\n",
+    "        yi = np.searchsorted(y_unique, y)\n",
+    "        grid = np.full((len(y_unique), len(x_unique)), np.nan)\n",
+    "        grid[yi, xi] = values\n",
+    "        pcm = ax.pcolormesh(x_unique, y_unique, grid, cmap=\"RdBu_r\", shading=\"auto\")\n",
+    "        x_units = ds.coords[\"x\"].attrs.get(\"units\", \"\")\n",
+    "        y_units = ds.coords[\"y\"].attrs.get(\"units\", \"\")\n",
+    "        ax.set_xlabel(\"x (m)\")\n",
+    "        ax.set_ylabel(\"y (m)\")\n",
+    "    else:\n",
+    "        # Fallback: approximate square reshape if no grid coords\n",
+    "        n = len(values)\n",
+    "        ny = int(np.sqrt(n))\n",
+    "        nx = n // ny\n",
+    "        grid = values[: ny * nx].reshape(ny, nx)\n",
+    "        pcm = ax.pcolormesh(grid, cmap=\"RdBu_r\", shading=\"auto\")\n",
+    "\n",
+    "    feature_names = list(ds[\"state_feature\"].values) if \"state_feature\" in ds.coords else [\"feature_0\"]\n",
+    "    ax.set_title(f\"2D state field: {feature_names[0]} at t=0\")\n",
+    "    plt.colorbar(pcm, ax=ax)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Graph Generation\n",
+    "\n",
+    "`neural-lam` uses a **graph** to define the message-passing structure of the GNN. Different graph types exist:\n",
+    "\n",
+    "| Graph type  | Command flag                    | Use case               |\n",
+    "|-------------|----------------------------------|------------------------|\n",
+    "| L1-LAM      | `--name 1level --levels 1`       | Quick demo (this notebook) |\n",
+    "| GC-LAM      | `--name multiscale`              | Standard multi-scale model |\n",
+    "| Hi-LAM      | `--name hierarchical --hierarchical` | Hierarchical model (production) |\n",
+    "\n",
+    "For this Hello World example we use the **L1 (single-level) graph** — the lightest option, ideal for CPU."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2026-07-15 22:16:09.989\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1mThe loaded datastore contains the following features:\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:09.989\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m state   : u100m v100m r2m t2m\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:09.989\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m forcing : swavr0m\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:09.990\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m static  : lsm orography\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:09.990\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1mWith the following splits (over time):\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:10.000\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m train   : 2022-04-01T00:00 to 2022-04-04T00:00\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:10.010\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m val     : 2022-04-04T00:00 to 2022-04-07T00:00\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:10.020\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m test    : 2022-04-07T00:00 to 2022-04-10T00:00\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:16:10.038\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcreate_graph\u001b[0m:\u001b[36m432\u001b[0m - \u001b[1mWriting graph components to tests/datastore_examples/mdp/danra_100m_winds/graph/1level\u001b[0m\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/torch_geometric/utils/convert.py:249: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /pytorch/torch/csrc/utils/tensor_new.cpp:253.)\n",
+      "  data[key] = torch.tensor(value)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Generate the single-level graph for fast CPU execution\n",
+    "# Graph files are stored in tests/datastore_examples/mdp/danra_100m_winds/graphs/1level/\n",
+    "!{sys.executable} -m neural_lam.create_graph \\\n",
+    "    --config_path tests/datastore_examples/mdp/danra_100m_winds/config.yaml \\\n",
+    "    --name 1level \\\n",
+    "    --levels 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Graph files created (9): ['tests/datastore_examples/mdp/danra_100m_winds/graph/1level/', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2m_edge_index.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2g_edge_index.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/g2m_edge_index.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2g_features.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2m_features.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/metainfo.yaml', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/g2m_features.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/mesh_features.pt']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Confirm the graph was created\n",
+    "graph_files = glob.glob(\n",
+    "    \"tests/datastore_examples/mdp/danra_100m_winds/graph/1level/**\", recursive=True\n",
+    ")\n",
+    "print(f\"Graph files created ({len(graph_files)}):\", graph_files)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Graph created with 7 tensor file(s):\n",
+      "  g2m_edge_index.pt                        200.3 KB\n",
+      "  g2m_features.pt                          150.6 KB\n",
+      "  m2g_edge_index.pt                        481.6 KB\n",
+      "  m2g_features.pt                          361.6 KB\n",
+      "  m2m_edge_index.pt                        87.7 KB\n",
+      "  m2m_features.pt                          66.1 KB\n",
+      "  mesh_features.pt                         7.3 KB\n"
+     ]
+    }
+   ],
+   "source": [
+    "graph_dir = \"tests/datastore_examples/mdp/danra_100m_winds/graph/1level\"\n",
+    "graph_files = glob.glob(os.path.join(graph_dir, \"**\", \"*.pt\"), recursive=True)\n",
+    "\n",
+    "if graph_files:\n",
+    "    print(f\"✅ Graph created with {len(graph_files)} tensor file(s):\")\n",
+    "    for f in sorted(graph_files):\n",
+    "        size_kb = os.path.getsize(f) / 1024\n",
+    "        print(f\"  {os.path.basename(f):40s} {size_kb:.1f} KB\")\n",
+    "else:\n",
+    "    print(\"❌ No graph .pt files found — check the create_graph output above.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2026-07-15 22:23:37.457\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1mThe loaded datastore contains the following features:\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:23:37.458\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m state   : u100m v100m r2m t2m\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:23:37.459\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m forcing : swavr0m\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:23:37.460\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m static  : lsm orography\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:23:37.461\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1mWith the following splits (over time):\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:23:37.475\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m train   : 2022-04-01T00:00 to 2022-04-04T00:00\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:23:37.486\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m val     : 2022-04-04T00:00 to 2022-04-07T00:00\u001b[0m\n",
+      "\u001b[32m2026-07-15 22:23:37.498\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m686\u001b[0m - \u001b[1m test    : 2022-04-07T00:00 to 2022-04-10T00:00\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Full interactive 3D graph saved to graph_viz.html - open it in a browser.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from IPython.display import HTML, display\n",
+    "\n",
+    "config_path = \"tests/datastore_examples/mdp/danra_100m_winds/config.yaml\"\n",
+    "_, datastore = load_config_and_datastore(config_path=config_path)\n",
+    "xy = datastore.get_xy(\"state\", stacked=True)\n",
+    "grid_xy_max_span = np.max(np.abs(xy))\n",
+    "grid_pos = xy / grid_xy_max_span\n",
+    "\n",
+    "graph_dir = os.path.join(datastore.root_path, \"graph\", \"1level\")\n",
+    "hierarchical, graph_ldict = utils.load_graph(\n",
+    "    graph_dir_path=graph_dir,\n",
+    "    mesh_node_features_scaling=grid_xy_max_span,\n",
+    ")\n",
+    "\n",
+    "fig = _plot_graph(grid_pos=grid_pos, hierarchical=hierarchical, graph_ldict=graph_ldict)\n",
+    "# Full interactive 3D graph (plotly/WebGL) -> written to disk for the browser.\n",
+    "fig.write_html(\"graph_viz.html\", include_plotlyjs=\"cdn\")\n",
+    "print(\"Full interactive 3D graph saved to graph_viz.html - open it in a browser.\")\n",
+    "\n",
+    "traces = {t.name: t for t in fig.data}\n",
+    "\n",
+    "\n",
+    "def edge_xyz(name, keep=None):\n",
+    "    \"\"\"x, y, z of an edge trace (None-separated segments), optionally thinned.\"\"\"\n",
+    "    t = traces[name]\n",
+    "    x = np.asarray(t.x, float)\n",
+    "    y = np.asarray(t.y, float)\n",
+    "    z = np.asarray(t.z, float)\n",
+    "    n_edges = x.size // 3\n",
+    "    if keep is not None and n_edges > keep:\n",
+    "        sel = np.zeros(x.size, dtype=bool)\n",
+    "        for i in range(0, n_edges, max(1, n_edges // keep)):\n",
+    "            sel[3 * i : 3 * i + 3] = True\n",
+    "        x, y, z = x[sel], y[sel], z[sel]\n",
+    "    return x, y, z\n",
+    "\n",
+    "\n",
+    "grid_x = np.asarray(traces[\"Grid nodes\"].x, dtype=float)\n",
+    "grid_y = np.asarray(traces[\"Grid nodes\"].y, dtype=float)\n",
+    "mesh_x = np.asarray(traces[\"Mesh nodes\"].x, dtype=float)\n",
+    "mesh_y = np.asarray(traces[\"Mesh nodes\"].y, dtype=float)\n",
+    "mesh_z = np.asarray(traces[\"Mesh nodes\"].z, dtype=float)\n",
+    "stride = max(1, grid_x.size // 20000)  # cap scatter density\n",
+    "\n",
+    "# Static matplotlib 3D preview (no WebGL -> renders inline in any environment).\n",
+    "fig3d = plt.figure(figsize=(8, 6))\n",
+    "ax3d = fig3d.add_subplot(111, projection=\"3d\")\n",
+    "ax3d.plot(*edge_xyz(\"G2M\", keep=400), color=\"0.7\", lw=0.2, alpha=0.4)\n",
+    "ax3d.plot(*edge_xyz(\"M2M\"), color=\"tab:blue\", lw=0.4, alpha=0.6, label=\"M2M edges\")\n",
+    "ax3d.scatter(grid_x[::stride], grid_y[::stride], np.zeros(grid_x[::stride].size),\n",
+    "             s=1, color=\"lightgray\", label=\"grid nodes\")\n",
+    "ax3d.scatter(mesh_x, mesh_y, mesh_z, s=10, color=\"tab:red\", label=\"mesh nodes\")\n",
+    "ax3d.set_title(\"Graph structure (3D: grid + mesh layers)\")\n",
+    "ax3d.set_zticks([])\n",
+    "ax3d.legend(loc=\"upper right\", markerscale=3)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Training on CPU\n",
+    "\n",
+    "We train the `graph_lam` model for **1 epoch** using the L1 graph. Key flags used here:\n",
+    "\n",
+    "| Flag | Value | Why |\n",
+    "|------|-------|-----|\n",
+    "| `--model` | `graph_lam` | Simplest model — compatible with non-hierarchical graphs |\n",
+    "| `--graph` | `1level` | Must match the graph name used in the previous step |\n",
+    "| `--epochs` | `1` | Minimal run — just to verify the pipeline works end-to-end |\n",
+    "| `--processor_layers` | `2` | Reduced from default (4) for CPU |\n",
+    "| `--ar_steps_train` | `1` | Unroll 1 time-step during training — reduces memory and compute |\n",
+    "| `--ar_steps_eval` | `1` | Also 1 step for the val pass within this demo run |\n",
+    "\n",
+    "**About logging:** By default, `neural-lam` logs via [Weights & Biases](https://wandb.ai). To suppress W&B upload during this demo, we set `WANDB_MODE=offline` so metrics are saved locally without requiring a W&B account or login."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Seed set to 42\n",
+      "2026-07-15 22:16:23.300 | INFO     | neural_lam.utils:log_on_rank_zero:686 - The loaded datastore contains the following features:\n",
+      "2026-07-15 22:16:23.301 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  state   : u100m v100m r2m t2m\n",
+      "2026-07-15 22:16:23.301 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  forcing : swavr0m\n",
+      "2026-07-15 22:16:23.301 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  static  : lsm orography\n",
+      "2026-07-15 22:16:23.301 | INFO     | neural_lam.utils:log_on_rank_zero:686 - With the following splits (over time):\n",
+      "2026-07-15 22:16:23.313 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  train   : 2022-04-01T00:00 to 2022-04-04T00:00\n",
+      "2026-07-15 22:16:23.320 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  val     : 2022-04-04T00:00 to 2022-04-07T00:00\n",
+      "2026-07-15 22:16:23.327 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  test    : 2022-04-07T00:00 to 2022-04-10T00:00\n",
+      "2026-07-15 22:16:23.562 | INFO     | neural_lam.utils:log_on_rank_zero:686 - Loaded graph with 8409 nodes (7680 grid, 729 mesh)\n",
+      "2026-07-15 22:16:23.571 | INFO     | neural_lam.utils:log_on_rank_zero:686 - Edges in subgraphs: m2m=5512, g2m=12716, m2g=30720\n",
+      "2026-07-15 22:16:23.716 | INFO     | neural_lam.utils:setup_training_logger:762 - Wandb resume mode: None (id: None)\n",
+      "GPU available: False, used: False\n",
+      "TPU available: False, using: 0 TPU cores\n",
+      "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n",
+      "wandb: WARNING The anonymous setting has no effect and will be removed in a future version.\n",
+      "wandb: Tracking run with wandb version 0.25.1\n",
+      "wandb: W&B syncing is set to `offline` in this directory. Run `wandb online` or set WANDB_MODE=online to enable cloud syncing.\n",
+      "wandb: Run data is saved locally in runs/train-graph_lam-2x64-07_15_22-6143/wandb/offline-run-20260715_221624-3m5zu3sd\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "┏━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n",
+      "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName      \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType        \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mFLOPs\u001b[0m\u001b[1;35m \u001b[0m┃\n",
+      "┡━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n",
+      "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ forecaster │ ARForecaster │  152 K │ train │     0 │\n",
+      "└───┴────────────┴──────────────┴────────┴───────┴───────┘\n",
+      "\u001b[1mTrainable params\u001b[0m: 152 K                                                         \n",
+      "\u001b[1mNon-trainable params\u001b[0m: 0                                                         \n",
+      "\u001b[1mTotal params\u001b[0m: 152 K                                                             \n",
+      "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 0                                       \n",
+      "\u001b[1mModules in train mode\u001b[0m: 89                                                       \n",
+      "\u001b[1mModules in eval mode\u001b[0m: 0                                                         \n",
+      "\u001b[1mTotal FLOPs\u001b[0m: 0                                                                  \n",
+      "\u001b[2K/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/util\n",
+      "ities/_pytree.py:21: `isinstance(treespec, LeafSpec)` is deprecated, use \n",
+      "`isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n",
+      "\u001b[2K/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/trai\n",
+      "ner/connectors/data_connector.py:434: The 'val_dataloader' does not have many \n",
+      "workers which may be a bottleneck. Consider increasing the value of the \n",
+      "`num_workers` argument` to `num_workers=7` in the `DataLoader` to improve \n",
+      "performance.\n",
+      "\u001b[2K/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/trai\n",
+      "ner/connectors/data_connector.py:378: You have overridden \n",
+      "`on_after_batch_transfer` in `LightningModule` but have passed in a \n",
+      "`LightningDataModule`. It will use the implementation from `LightningModule` \n",
+      "instance.\n",
+      "\u001b[2K/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/util00\u001b[0m \u001b[2;4m2.00it/s\u001b[0m [2;4m0.00it/s\u001b[0m \n",
+      "ities/_pytree.py:21: `isinstance(treespec, LeafSpec)` is deprecated, use \n",
+      "`isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n",
+      "\u001b[2K/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/trai0m \u001b[2;4m2.00it/s\u001b[0m \n",
+      "ner/connectors/data_connector.py:434: The 'train_dataloader' does not have many \n",
+      "workers which may be a bottleneck. Consider increasing the value of the \n",
+      "`num_workers` argument` to `num_workers=7` in the `DataLoader` to improve \n",
+      "performance.\n",
+      "\u001b[2KEpoch 0/0  \u001b[35m━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━\u001b[0m 1/6 \u001b[2m0:00:01 • -:--:--\u001b[0m \u001b[2;4m0.00it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━\u001b[0m 2/6 \u001b[2m0:00:01 • 0:00:04\u001b[0m \u001b[2;4m1.14it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━\u001b[0m 3/6 \u001b[2m0:00:02 • 0:00:03\u001b[0m \u001b[2;4m1.15it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━\u001b[0m 4/6 \u001b[2m0:00:03 • 0:00:02\u001b[0m \u001b[2;4m1.14it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━\u001b[0m 5/6 \u001b[2m0:00:04 • 0:00:01\u001b[0m \u001b[2;4m1.14it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "                                                             \u001b[3m3.581              \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "                                                             \u001b[3m3.581              \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "                                                             \u001b[3m3.581              \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "                                                             \u001b[3m3.581              \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "                                                             \u001b[3m3.581              \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "                                                             \u001b[3m3.581              \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_epoch:  \u001b[0m\n",
+      "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0  \u001b[35m━━━━━━━━━━━━━━━━━━\u001b[0m 6/6 \u001b[2m0:00:05 • 0:00:00\u001b[0m \u001b[2;4m1.26it/s\u001b[0m \u001b[3mv_num: u3sd        \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_step:   \u001b[0m\n",
+      "                                                             \u001b[3m3.581              \u001b[0m\n",
+      "                                                             \u001b[3mtrain_loss_epoch:  \u001b[0m\n",
+      "                                                             \u001b[3m3.225              \u001b[0m\n",
+      "\u001b[?25h\u001b[1;34mwandb\u001b[0m: \n",
+      "\u001b[1;34mwandb\u001b[0m: You can sync this run to the cloud by running:\n",
+      "\u001b[1;34mwandb\u001b[0m: \u001b[1mwandb sync runs/train-graph_lam-2x64-07_15_22-6143/wandb/offline-run-20260715_221624-3m5zu3sd\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`Trainer.fit` stopped: `max_epochs=1` reached.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CompletedProcess(args=['/home/simac/neural-lam/.venv/bin/python', '-m', 'neural_lam.train_model', '--config_path', 'tests/datastore_examples/mdp/danra_100m_winds/config.yaml', '--model', 'graph_lam', '--graph', '1level', '--epochs', '1', '--processor_layers', '2', '--ar_steps_train', '1', '--ar_steps_eval', '1', '--num_workers', '0', '--val_steps_to_log', '1'], returncode=0)"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.environ[\"WANDB_MODE\"] = \"offline\"\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n",
+    "# Force a non-interactive matplotlib backend in the subprocess:\n",
+    "# the default TkAgg backend aborts (Tcl threading) when plotting\n",
+    "# from Lightning callback threads.\n",
+    "os.environ[\"MPLBACKEND\"] = \"Agg\"\n",
+    "\n",
+    "subprocess.run(\n",
+    "    [\n",
+    "        sys.executable, \"-m\", \"neural_lam.train_model\",\n",
+    "        \"--config_path\", \"tests/datastore_examples/mdp/danra_100m_winds/config.yaml\",\n",
+    "        \"--model\", \"graph_lam\",\n",
+    "        \"--graph\", \"1level\",\n",
+    "        \"--epochs\", \"1\",\n",
+    "        \"--processor_layers\", \"2\",\n",
+    "        \"--ar_steps_train\", \"1\",\n",
+    "        \"--ar_steps_eval\", \"1\",\n",
+    "        \"--num_workers\", \"0\",\n",
+    "        \"--val_steps_to_log\", \"1\",\n",
+    "    ],\n",
+    "    check=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Checkpoints found: ['runs/train-graph_lam-2x64-07_15_22-6143/checkpoints/min_val_loss.ckpt', 'runs/train-graph_lam-2x64-07_15_22-6143/checkpoints/last.ckpt']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Find the checkpoint saved during training\n",
+    "ckpts = glob.glob(\"runs/**/*.ckpt\", recursive=True)\n",
+    "print(\"Checkpoints found:\", ckpts)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Evaluation & Visualization\n",
+    "\n",
+    "Evaluation reuses the same `train_model` command with `--eval test` and the `--load` flag pointing to the checkpoint from training.\n",
+    "\n",
+    "Example predictions are plotted automatically and saved by the logger. Set `--n_example_pred` to control how many prediction plots to produce."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Using checkpoint: runs/train-graph_lam-2x64-07_15_22-6143/checkpoints/last.ckpt\n"
+     ]
+    }
+   ],
+   "source": [
+    "ckpts = glob.glob(\"runs/**/*.ckpt\", recursive=True)\n",
+    "\n",
+    "if not ckpts:\n",
+    "    raise FileNotFoundError(\n",
+    "        \"No checkpoint found under runs/ - the training cell above did not complete.\"\n",
+    "    )\n",
+    "else:\n",
+    "    ckpt_path = max(ckpts, key=os.path.getmtime)\n",
+    "    print(f\"✅ Using checkpoint: {ckpt_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import argparse\n",
+    "import torch\n",
+    "from neural_lam.config import (\n",
+    "    DatastoreSelection, ManualStateFeatureWeighting, NeuralLAMConfig,\n",
+    "    OutputClamping, TrainingConfig, UniformFeatureWeighting,\n",
+    ")\n",
+    "\n",
+    "torch.serialization.add_safe_globals([\n",
+    "    argparse.Namespace, DatastoreSelection, ManualStateFeatureWeighting,\n",
+    "    NeuralLAMConfig, OutputClamping, TrainingConfig, UniformFeatureWeighting,\n",
+    "])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Seed set to 42\n",
+      "2026-07-15 22:16:46.926 | INFO     | neural_lam.utils:log_on_rank_zero:686 - The loaded datastore contains the following features:\n",
+      "2026-07-15 22:16:46.926 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  state   : u100m v100m r2m t2m\n",
+      "2026-07-15 22:16:46.926 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  forcing : swavr0m\n",
+      "2026-07-15 22:16:46.926 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  static  : lsm orography\n",
+      "2026-07-15 22:16:46.927 | INFO     | neural_lam.utils:log_on_rank_zero:686 - With the following splits (over time):\n",
+      "2026-07-15 22:16:46.937 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  train   : 2022-04-01T00:00 to 2022-04-04T00:00\n",
+      "2026-07-15 22:16:46.945 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  val     : 2022-04-04T00:00 to 2022-04-07T00:00\n",
+      "2026-07-15 22:16:46.952 | INFO     | neural_lam.utils:log_on_rank_zero:686 -  test    : 2022-04-07T00:00 to 2022-04-10T00:00\n",
+      "2026-07-15 22:16:47.204 | INFO     | neural_lam.utils:log_on_rank_zero:686 - Loaded graph with 8409 nodes (7680 grid, 729 mesh)\n",
+      "2026-07-15 22:16:47.211 | INFO     | neural_lam.utils:log_on_rank_zero:686 - Edges in subgraphs: m2m=5512, g2m=12716, m2g=30720\n",
+      "2026-07-15 22:16:47.384 | INFO     | neural_lam.utils:setup_training_logger:762 - Wandb resume mode: None (id: None)\n",
+      "GPU available: False, used: False\n",
+      "TPU available: False, using: 0 TPU cores\n",
+      "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n",
+      "wandb: WARNING The anonymous setting has no effect and will be removed in a future version.\n",
+      "wandb: Tracking run with wandb version 0.25.1\n",
+      "wandb: W&B syncing is set to `offline` in this directory. Run `wandb online` or set WANDB_MODE=online to enable cloud syncing.\n",
+      "wandb: Run data is saved locally in runs/eval-test-graph_lam-2x64-07_15_22-2169/wandb/offline-run-20260715_221648-p4309ofs\n",
+      "Restoring states from the checkpoint path at runs/train-graph_lam-2x64-07_15_22-6143/checkpoints/last.ckpt\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:566: The dirpath has changed from '/home/simac/neural-lam/runs/train-graph_lam-2x64-07_15_22-6143/checkpoints' to '/home/simac/neural-lam/runs/eval-test-graph_lam-2x64-07_15_22-2169/checkpoints', therefore `best_model_score`, `kth_best_model_path`, `kth_value`, `last_model_path` and `best_k_models` won't be reloaded. Only `best_model_path` will be reloaded.\n",
+      "Loaded model weights from the checkpoint at runs/train-graph_lam-2x64-07_15_22-6143/checkpoints/last.ckpt\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/utilities/_pytree.py:21: `isinstance(treespec, LeafSpec)` is deprecated, use `isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n",
+      "/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:434: The 'test_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=7` in the `DataLoader` to improve performance.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[2K/home/simac/neural-lam/.venv/lib/python3.13/site-packages/pytorch_lightning/trai\n",
+      "ner/connectors/data_connector.py:378: You have overridden \n",
+      "`on_after_batch_transfer` in `LightningModule` but have passed in a \n",
+      "`LightningDataModule`. It will use the implementation from `LightningModule` \n",
+      "instance.\n",
+      "\u001b[2K┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓5/5 \u001b[2m0:01:08 • 0:00:00\u001b[0m \u001b[2;4m0.72it/s\u001b[0m [2;4m0.67it/s\u001b[0m \n",
+      "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
+      "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+      "│\u001b[36m \u001b[0m\u001b[36m    test_loss_unroll1    \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m    2.311244249343872    \u001b[0m\u001b[35m \u001b[0m│\n",
+      "│\u001b[36m \u001b[0m\u001b[36m     test_mean_loss      \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m    4.623441219329834    \u001b[0m\u001b[35m \u001b[0m│\n",
+      "└───────────────────────────┴───────────────────────────┘\n",
+      "\u001b[2KTesting \u001b[35m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m 5/5 \u001b[2m0:01:08 • 0:00:00\u001b[0m \u001b[2;4m0.72it/s\u001b[0m \n",
+      "\u001b[?25h\u001b[1;34mwandb\u001b[0m: \n",
+      "\u001b[1;34mwandb\u001b[0m: You can sync this run to the cloud by running:\n",
+      "\u001b[1;34mwandb\u001b[0m: \u001b[1mwandb sync runs/eval-test-graph_lam-2x64-07_15_22-2169/wandb/offline-run-20260715_221648-p4309ofs\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CompletedProcess(args=['/home/simac/neural-lam/.venv/bin/python', '-m', 'neural_lam.train_model', '--config_path', 'tests/datastore_examples/mdp/danra_100m_winds/config.yaml', '--model', 'graph_lam', '--graph', '1level', '--eval', 'test', '--load', 'runs/train-graph_lam-2x64-07_15_22-6143/checkpoints/last.ckpt', '--processor_layers', '2', '--n_example_pred', '2', '--ar_steps_eval', '4', '--num_workers', '0', '--val_steps_to_log', '1'], returncode=0)"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.environ[\"WANDB_MODE\"] = \"offline\"\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n",
+    "os.environ[\"MPLBACKEND\"] = \"Agg\"\n",
+    "\n",
+    "subprocess.run(\n",
+    "    [\n",
+    "        sys.executable, \"-m\", \"neural_lam.train_model\",\n",
+    "        \"--config_path\", \"tests/datastore_examples/mdp/danra_100m_winds/config.yaml\",\n",
+    "        \"--model\", \"graph_lam\",\n",
+    "        \"--graph\", \"1level\",\n",
+    "        \"--eval\", \"test\",\n",
+    "        \"--load\", ckpt_path,\n",
+    "        \"--processor_layers\", \"2\",\n",
+    "        \"--n_example_pred\", \"2\",\n",
+    "        \"--ar_steps_eval\", \"4\",\n",
+    "        \"--num_workers\", \"0\",\n",
+    "        \"--val_steps_to_log\", \"1\",\n",
+    "    ],\n",
+    "    check=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RMSE scorecard: runs/eval-test-graph_lam-2x64-07_15_22-2169/wandb/latest-run/files/media/images/test_rmse_32_f49da8ba79c339e14cbf.png\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Showing 2 of 64 prediction plot(s):\n",
+      "  runs/eval-test-graph_lam-2x64-07_15_22-2169/wandb/offline-run-20260715_221648-p4309ofs/files/media/images/t2m_example_2_31_0941591302c7b821d34c.png\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRQAAAJYCAYAAAAT22pxAAEAAElEQVR4nOydd3gc1bn/vzOzO7NFZdVsNRckim0MwYXiAqZYchKScMm1A0lIbsrFCtwUQhL7knbvL43YN4XkpmEgCeSGBOz0kAR3gwvFNgGDDS6SbMuSbPU6beec3x+zu5Jsld3VnK3n8zx6DLs7Z87OzJ555y3fV6CUUnA4HA6Hw+FwOBwOh8PhcDgcThSIyZ4Ah8PhcDgcDofD4XA4HA6Hw0kfuEORw+FwOBwOh8PhcDgcDofD4UQNdyhyOBwOh8PhOEx9fT0OHjwY9/Zbt251cDapxWSPTbqSyeeUw+FwOBxO9sEdihwOh8PhcDgO0t3djVWrViEQCERe27RpEwRBQHd39wWfr6+vR0FBAVatWjXi9ZqaGsYzTTyjHRunqKurS/ljlurz43A4HA6Hw4kW7lDkcDgcDoeTkaxduxYFBQUoKChATU0N6uvrE7LfW265BXV1daiqqprws93d3aipqcHChQuxcePGyOvLly9HIBBAXV0dy6nGTdhBunbt2pi2G+/YHDx4EDU1NWNm8iXrfDpFqp9TDofD4XA4nFjgDkUOh8PhcDhpzaZNmy54ra6uDgcPHsS2bduwbds2AEB1dTVzJ9TWrVvR3d2N1atXR/X5W265BYFAAFu2bLngvXXr1mHDhg2jZjVGy2jHxgnWrl0blcN0OGMdmw0bNkAQBNx9991jOhOTdT6dxolzyuFwOBwOh5MKcIcih8PhcDictKW+vv6CUuHu7m48/fTT2LJlC+bPn4/58+djy5YtqKqqwrp165jOZ+3atVi5cmVUn62pqUF3d3fEQXY+VVVVWL58OR588MG45jLasXGC9evXY/78+TGXLY91bFavXg1K6ZjHIZnn02kme045HA6Hw+FwUgXuUORwOBwOh5NRBAKBUR1Ny5cvZ9oYo7u7GwcPHsQdd9wx4WdXrVqF/fv348CBA+M65latWsUsyzAeuru7sXbtWjzwwAMxbxftsTmfZJ1PVqTaOeVwOBwOh8OJB+5Q5HA4HA6Hk5asWrUK1dXVAABBEEZo+o1WclxfXz/CeVdXV4e6ujps2LAhos0XzugbrtcXrebd/v37AQDz588f8zOdnZ2oq6vDpk2bIpp647Fw4ULU19fHXCI73rGZDGvXrsXy5cvH/Y6jEc2xGY9ozmeYDRs2YMGCBaM2uhn+viAIqKmpuaDj9GjNXRYsWDDiOli7dm2kDHvBggWR/WzYsAHV1dUQBGHMayfec8rhcDgcDoeTSriSPQEOh8PhcDiceNi4cSO2bt2KmpoadHV1jeuc6+7uxtatW0c0PgFsB9CaNWtw4MABHDx4MOKIq6urw4EDB7Bp0yasXbsWq1atwvLly8edz8GDByd0EIY19FavXo0NGzZg69at444b1incv3//hPsfznjHpq6uDp2dnVGNc8cdd0TKlOvr67FhwwacOHEi6nmEiebYxMJY53Pr1q2YP38+Nm7cGDmf4eMN2I7ATZs24eGHH0ZVVRW2bt2KBQsWYMuWLTEd3/D+n376aTzwwANYuXIlDh48iLq6OmzZsiXiNBwtgzLec8rhcDgcDoeTSnCHIofD4XA4nLSlsLAQACZ0Vq1atQqrV68eVcMvXE5bVVWFqqoqdHZ2Ys2aNQCANWvW4MEHH8TBgwcndP50dHRE5jMWGzZsiDiv6uvrUVdXN66DLvy94slmG+vYPPzwwzGPBdiOyJUrV8bcjAWI7tjEQizn88CBAwBsh+j69etx4MCBSKbk6tWr0d3dPeF5GI36+voRjshNmzYhEAhg4cKFCAQCEb3H85nMOeVwOBwOh8NJFXjJM4fD4XA4nIxm1apVqKqqGtWRdr7DJ9w0YzjROsK6u7sndGw+/PDDkfEffvhh1NfXR1WKHG1GISu2bt2KrVu3XqCdGK1TLJpjEy2xnM/h+wyXNp//mbBzN1YH3/nXysqVK1FYWIiCggIsWLAA69evH3f7ZJ9TDofD4XA4nMnAHYocDofD4XAylvGcT8DozsJ4M+micZi9733vi/x3uEvx+vXrUV9fP+52Tmb3xcOWLVsAIKI9KAgCDh48iA0bNkAQhAmboyTCmQiMf5wmcuDF6uAbLVPzxIkTkazFBx98MKJjORrJPqccDofD4XA4k4GXPHM4HA6Hw0l7RsuAq6mpQU1NTaR8mTVFRUUxZ7mtWbMGDz/8MFatWhUpzR1O2NE4GYfc+ccmHg3FdevWXdBpubq6OvLeRMRzbM5nsucznE14vm7lU089hUAgMG4pdyxzX758OZYvX45169ZFHK/DsyKdOKccDofD4XA4yYY7FDkcDofD4aQtYSfQhg0bsHz5cuzfvx+rV69GTU0NqqqqIs0yhhNvp+GJmD9//oSZhqPx8MMPo6amZkTzkDBhR9bChQsjr9XX12PTpk1YvXr1uE6psY5NvBqKkyGaYzOek9OJ81lVVYU1a9Zg1apVeOSRRzB//nxs2rQJ69evH9Hcpbq6Gk8//XTk2D/44INRnddNmzZhy5YtqKurQyAQiGRtnu+oHO2ccjgcDofD4aQbvOSZw+FwOBxO2hIIBLBy5UqsXbsWd999N4ChDrwbNmxAdXU1FixYEPm75ZZbmM0l7CA63+E1EcuXL8fq1auxdu3aCzLhtm7diqqqqhGOw7Du4kRZhqMdm2Qx3rHZtGkTBEGIlAfX1NRAEISIBqGT5zOcabl27VpUV1fjqaeewpYtW0Y0dzlfC7G6uhqrV68et3wZsB2bnZ2dkU7h69atw8aNGy9w+o52TjkcDofD4XDSDYFSSpM9CQ6Hw+FwOJxMYMGCBZFyVycIZ+adn1VYUFCArq4uR/aRKJw+NunKWOeUw+FwOBwOJ53gDkUOh8PhcDgch9i0aRPuvvtuR5x93d3dEcfh+RmKdXV1kUYp6YKTxyZdGeuccjgcDofD4aQb3KHI4XA4HA6H4yALFixAXV3dBXqIsVJXVwcAF2SydXd3o76+npkWJEucOjbpyljnlMPhcDgcDifd4E1ZOBwOh8PhcBxk27ZtkfLe8ToHj8fWrVtRX18/ahZiIBBIS2ci4MyxSVfGO6ccDofD4XA46QZvysLhcFKGDRs2YMGCBRAEISKGv379+guaFKQiNTU1kcyT0di0aRMKCgqi+gt3BnWauro61NTUMBmbw+EMEQgEsGXLlrg6Pofp7u4e0Xk4U3Di2KQrmXpOOZxUJdzwafhfQUEBampqmK5BE9mEHA6HkynwDEUOh5MSrFq1Cps2bcKaNWvwyCOPALCzOR588EHMnz8fy5cvT/IMJ8fy5cuxbdu2Ea+tWrUKgUAg8n3DZFvWDoeTiVRVVU3qtzy863CmMdljk65k8jnlcFKZEydORNac+vp6rFu3DtXV1Thw4EBCsr3DDswTJ06kxDgcDofjFNyhyOFwkk5dXR22bt16gWE3f/58rFmzJokzc47RShQDgQAKCwuZGLObNm3iD68cDofD4XCynsLCwsh/hzusd3Z2YtWqVQlxzq1atSrmapvR7Lh4xuFwOByWcIcih8NJKvX19diwYQMefvjhtNUESzXq6+uxatUq8J5bHA6Hw+FwOBdyxx13YNOmTeju7mbecT3WJlRj2XHZ2syKw+GkLlxDkcPhJJVwp0tuJHE4HA6Hw+FwOBwOh5MecIcih8NJKgcPHoxJS2vt2rWoq6vDwYMHsWDBAqxatSry3vCmLjU1NTh48OCIbUdrSrJgwYIRwtl1dXWoq6vDhg0bUF1djYKCghH7GP65goICVFdXY/369ejs7Iz6O0zme070HVatWoXq6moAiAiQr127dsTnw8dprO/G4XA4HA6Hk8k89dRTqKqqimQnjmdfrl+/foRNeH7Z8UQ24Wi226ZNm0Y0IgzbauPZcaONE43tG41dy+FwOPHAHYocDiepdHZ2xuRQ7O7uxtatW3HLLbfgjjvuwLp16wDYhuC6deuwbt06nDhxAqtWrcKCBQvi6pi8YcMGnDhxAlu2bMEjjzyCTZs2YcOGDZH3V61ahaeffhqPPPIItmzZgkAgcIEBN1nG+p4TsXHjRmzZsgUA0NXVBUrpiG23bt2KEydOYOPGjaN+Nw6Hw+FwOJxMYriDr76+HnV1ddi0adOIruvj2ZcPP/wwNm7cGGmud/fdd0e2i8cmXL9+PVatWoW6urqITRbuOj2RHTecaG3fiexaDofDiReuocjhcJJKVVXVBYZPfX19JDoLAGvWrBlhTNXX12PLli2Rzs/19fVYv379iKYuq1evRnd3d8RYi5Xw/sLdSA8cOADANjjDRmhYLHv16tWR0m0nOf97RktYfHwsTaCxvhuHw+FwOBxOpjHcpgwEAli4cOGIzs9hzre7uru7sX79emzZsiViX27cuBEFBQWRLMVYbcLu7m6sXbt2xDZVVVUjbL2J7LjwXGOxfbntx+FwWMAzFDkcTlK5+uqr0d3dHYnMArax09XVha6urlGzF883vMKR4PObuixfvhz19fUxd8QbrRtzmP3790fGZs3539MJxvtuHA6Hw+FwOJnGiRMnQCkFpRRdXV3YsmVLVPZlOOBdU1MTKT8WBAHd3d3Yv39/XDZheJvzOzjHSiy2L7f9OBwOK7hDkcPhJJVwM5bzo7mBQGBMg+d8I3Ai/cJY9Q3DkeHxSIQxFkspeLRE8904HA6Hw+Fwso3R7K5AIBBxRg7/G+5ETIaDLhbbl9t+HA6HFdyhyOFwkkogEMC6deuwfv36uPQOgaHI8PnbP/XUUwgEAuM65mLNXly4cCEAu8QlVRjrO8T63TgcDofD4XA4NsuXL0d3d/eYmojx2ISxbDOeHTcZ25fD4XCcgjsUORxO0lmzZg3WrFmDmpoarF+/HvX19Th48CA2bNgQVXZhVVUV1qxZg1WrVmHTpk0RXZn169fjkUceiXyuuroa+/fvR3d3d0TDZnipdTQEAgGsXLkSd999N7Zu3Yr6+nqsXbvW8aYsYxHNdwgbkRs2bIgcRw6Hw+FwOBxO9AQCAaxZswa33HILtm7dGmncUlNTg/r6+rhswnAg/e67747YrFu3bsWqVasi20Vjx0Vr+3I4HA5LuEORw+GkBOvWrcPGjRvx1FNPobq6GrfccgsefvhhrF69GnV1dVFtv27dOqxduxbV1dV46qmnsGXLlhEaNStXrkRhYSEKCgqwYMECVFdXY/Xq1SPEuqNh48aNWL58OVatWoWamhpUV1dj5cqVMY8TD9F8h7CBu3bt2hGdCDkcDofD4XA40TPcviwoKEBdXR1WrVoVcfrFYxOGmw0++OCDqK6uRl1dHa6++uqI1mG0dlw0ti+Hw+GwRKCU0mRPgsPhcDgcDofD4XA4HA6Hw+GkBzxDkcPhcDgcDofD4XA4HA6Hw+FEDXcocjgcDofD4XA4HA6Hw+FwOJyo4Q5FDofD4XA4HA6Hw+FwOBwOhxM13KHI4XA4HA6Hw+FwOBwOh8PhcKKGOxQ5HA6Hw+FwOBwOh8PhcDgcTtRwhyKHw+FwOBwOh8PhcDgcDofDiRpXsicwWTRNg2EYyZ4Gh8PhcDgcTkogyzI8Hk+yp5FScHuRw+FwOBwOZwgn7MW0dihqmoaKadPR2d6W7KlwOBwOh8PhpASlpaVoaGjgTsUQ3F7kcDgcDofDGYkT9mJaOxQNw0Bnexue3rwb/pycqLc7fbIB93zgvai7fy3evfJOhjMcBr3wJbXzLEAJvEVlY28Wb1G6EN9mE+3vm1+4H8ePHMbPNv0JikcZ2h2Jb3/xzjMaKCXoO/EW/NOrIcnyJAeLc7N4v1+KiBFQSkHNICxdBdE1EE2DZeigQROC2w1AgCiKcBeWQFI8EFwuCMLEXzre6yXe3wOV4tsubuK8Xs4nODAA/Wwz/FWXjP/BeH/vUuwT/eZ9n0V3RwfW//rxmLcVrNgm+rkP3oWSslKs/d53Yt4XAAgTfD1qWRh88yh8sy6DIA27uOJdz+Il3nWC4fo5KjFeLpRQDL75JnxVl0B0u2PenRiMeZO41xYS5xqR8LVl+L4tgoHjb8JXfRlE19BEBvv7ceeypTAMgzsUQ8RrL1JK8emPvB8+vx/f/smjUd3fHOG831pQUzF47hRyp1067hxSyWbc9ezf8Z0vP4Bv/ewRXLHg6pG7S0GbcbDlNESPF56C4skPlkibMUXsRQAglmXbiboGqmu27WgYgChBdLlATAPKlDJIiheiLHN7EXDMXqSUYuD4W/BWzoDk9Y79wQTai7v+9nd874Ev4pEtf0dJ6dSYto3VXvz9Lx/Hkz/5CX71/E54xvv+Y+0viq+nNZyEFMiDu6Bg6EVuL45OHNe1droJkscHubAo5m3jsReB7LIZ1dMnIeXmQg4URl5zyl5Ma4diGH9ODvw5uVF/ftblV2L5rbdh069+gdvf/2EoijLxRpNllB8W7W2DO6cQyjhzTyXjEADuXftFfPTdb8c//rAJH7j7E0O7S0Hj0NJUWDl+5BYUTv4hIEsdimNBgkEQXYPa0gTB5QLUfpCeDkCUIHg8trGoeCB5vBBl5YLjn3ADMdErnUMGhqFrkAuK4J1ofYvbcI79wr7x1lux/vNfgDo4iOKpbA3EZe98B379ox/D5XZDieNGN5GBGOzvh5CfD38gf+Qb3EAcnRgvF0tVgZwc5AQK4lqDuUNxfKzBASA3DzmBQPImkWbEai8CwMc/+Vl86TN1OHr4dcy/djGjmZ3Heb81nRiQCoqQk5s3/mYpZDO+472r8Nenf4tf/PAh/HTjHyGKQx9ORZuRuCR4Covh9sd2fYxKljoUAQDn3U4pISCGDr2jDZY6CNE0YPX3goBClBVIHi8kxQNRsf8VpJGLKrcXoxzGNEA9HuQUFUMQx/nyCbQXb3jHO/DDr/4X/rlnL/7lIx+OadtY7cWb3/0uPP7QQzh88BVc//YVMW0LRBGAphRUkuAtLoHkG+aw5Pbi6MSzBkoSPIVFcMV4jwa4QzGqfYfucS6f3/GxU+02lDA+XPdJdLa34a+bfpOU/VNKETRUSErsUZRkUjnzItz2/rvw5MM/RXdnR7KnMy6Wbh/fhGUUZBGiywXJ5wclFrxTK5Bz0aXIveRy+Cpnwp0bAKUEZncnBk6eQN+xN9DfeAxqaxOMrnYEBwdALSvZXyEtsDQNYoplGF13802QXC7s3byV+b6W1tZCU1UceO55JuMTVYPoTa3jm0mQ0PXL12A2WLqecutDJrL4xltw6Zy5+MVPfgBKHUonipGwPZNOCIKAe9Z8EccOv4Ftf/1zsqczLtSyQEwj7Y5xOiCIIiSPF4Iowp0XgH9GNXIvmYOcmZdAKZoCQXIhONAPtfkU+o4fRl/9Wxg8cxJ6xzmY/b0gppm03106QTTNDuCP50xMMDl5uZi3ZDF2/2Mz831VzJyJiy67DHv+8SyT8akZBCwLoicBSUhZCCUE1DAgKtymYQG1LNBgEBKj45s6q06CmTbzItS86zb8+tGfQde0hO+fBE2AUEhy+i1MH7rnkxAlEY//6IfJnsq4WLrG7IfDAahpX8NiKMNXEEVIXh/kQCG8UysiRqN/hNHYB7X5FHrrD6Ov8S0MtJyE1nE2ZDQa3Gg8D6KnnkNRVhTkFxTg2KHXme9rWlUVpl9cjd2btzAZn6SgwzaTIBp3eLGE6PYDJIctgiDgo/9xHw4d3I8DL+xNyhwsXYUkp5+z64oFC3F9zQo89tB3kmJrR4ulaxAkF0RXRhRupSSWpkLy2NewIAgQZQXu3Hx4Skrhq5yJ3ItnI6d6NrxTyyF5fbB0DXpbK/oa30Rf/RH0N9VDbWuB0dtll1Rze3EElqam5P22pKwUx15nby8CwNLaGrywfQdMBs23iKZBUOSUcthmEkTTAEmyq944jmPpmi1LJrFJkczqX8WH6j6J7q5O/PnpJxO+b9s4VCAI6XcK8gsKcNcn/gN/efo3OHnieLKnMyaWln4R/XTC0lWIyvjXsCAIkEYYjRch9+LZyL1oFjwl5XApPhBTh9bRir7Gt7jROAxKCIiupdw1/OP/9zUM9PXhX//9YwnZ39KaWrywbTusYJz1DONANA1SChrgmYJ9fLnDixWpGHDIVK67/kbMvuJt+MWPv5/wexKlBJahp9y9IFpWf24NOtrasOnxnyd7KmNi6UPOLo7zUEpBDH3CIL/ocsHlz4VSWAJf+XTkXHQp8qovh69iJuTcAEAJjJ5O9J8+gd4Tb6Dv1DEMnm2C3t2OoJrd1S/2/SC1ruGXdu3C337zFD74qf9IyP6W1NZioK8Pr77wouNjc3uRLUTTIfGKFmYQXWOa/Zl+3iwHqZw+EyvefTue/PnD0FQ1ofu20rDceTj/8sEPYWpZOTZ8d32ypzIqlFI7Q5Ev/sywtPidXaLLDXfYaCydjtwZ0RmN2VQyTQwdEMVQ85vUYNsf/4S/P70Rn/zaf2HmpRM0inGIpStWoK+7G6+99LKj41JK7Qw6XvLMDJ4ByhbCs/AThiAI+Mg9n8Ybr76Cl/eykWAYC8vQAVGA6Eqde0EsVMyYaUvlbPgZOtvbkz2dUbFLyvlviRVE1wAIENyxN0gURBEujw9yfiG8UyqQM60aedVzkDP9EigFJRBDJdODLcOqX5pPQm/PruoX2yZPnWu4vbUV6z73eVxz0zKsvPvjCdln9ezZKJ02DXsYVLVwe4Yt9vHlAWhWcIciYz60+j/Q29ONPz3964TuNx31cIYjywruvv8L2LdjG155cV+yp3MBxDQAUIgyX/xZQRwurxjPaPQUTIkYjWpLWGfnTVtnJ0ONRhIyDlMlWne6vh7f//JXsPxfbsOKVf+asP1eMvdyTCkvx26HdXGorgMAhMl2gOeMCg0GQYNBboAzggRNUMuKSE5w2HPN0mWYc+W8hGspWroKl5zeetAfvvdTkFwSHv/RD5I9lVGZTICUMzFhCSKnruFw9YucG4CnuBT+ipnIq5qN3Itm29UvXh+IYUBva0V//VvoO34EA6froZ1rhtHTBUtTQWmiu2mwgxIL1DRS5n5rBYP41n2fhVuWsea760c0ZGKJIAhYUluDvZu3gBBnzy/X3GYLd9iyhTAOOGS9Q7F82nS8/bb34jc/fxjq4GBC9mlnz6WnHs5wlr39nZjztnn46boHHV+4J4ulqZDk1HHGZCJWAspxR5RMF4d0dqrDOjuVts6OoQ8zGg9j4FRmGI2Wnjp6OLqm4euf/DRKSkvxma9/LaG/K0EQsLi2Bnu3OGsgWrxhCFOIpkNwu5nptWQ7RA8dX5Ef30Rhayl+Bkde+yde2r0rYftN94oWAMgLBPChez6JZzb+Fo3HjyV7OiOwuxBrvOSZIU4HoMdCdLns6peCEnjLp0UaBvqnhRsGUrth4Kl69B09bDcMbGmC3tWO4GB/2la/EC2sAZoaWcy/+t8f4fUDB/Glhx5CfmFhQve9dEUtOtvacOSVfzo2pi1BxDWhWcIdiuyw/U46z1BkzV13/wf6envxx9/+KiH7o5YJSixIaZ49JwgCPrH2ARw/8ga2/OWPyZ7OCFLJGZOJkGAQNGgmrbzC1tnJGaGzYxuNVXDnBUApYPZ0YuC0bTQOnDgG9cxpGO3tCA70gzLQ43MaomkQU+Qh8qff+BaaGhrwlf/9Ibx+f8L3v3RFDdpbz+Loa4ccG5NHm9li8fIVprAuX+GMzsJFSzH3qvn4+Y8fSliWYrpXtIS57QN3YWpFJTZ8Z12ypzICYugQRAlCijhjMpFEBKDHwu4yfWHDwJyLQg0D3S5YA/1QW5rQd/ww+o++CfXUSejnzsLs7QExUr/6xUohPd0Du/fg1z/6MT5y32dwxTVXJ3z/s+fPQ6CoCHueda6zNNFTT4IokyBmkFdcMIQGgwBhe3wzopWOQO2/WBj+8bLySrzzX1bit798FLfdcRd8vnEemONNZhm2nWXYnRkFKQp/rgP7Y8nceQuw7O3vxKM/+C5uWPEOeLwxGgzxznOC823pGtw5eRd8LNbrZNIw+n6O7y9GiK5NLvuIwTxto9E7IsuAUgpqmggGVRBNgzXYD6OzHdQ0IbjdED0eSB5v6F8PBLc8MmMtzvMQ73VGhaF5W7oGJUoDkYrsLuydzzyDvz75JO775jdQNXsWAEAIJjarb+7VC5FXUIA9mzdj1ry3Rb/hOIeFaDqk3JxR34t/nYjzuKT2s8owop8oDZfsJzhBWLDiO5gSie/ckXh/63EunTRkNpCwRvBo0+ZJt2MSj70IDF35AgR85N778PnVH8a+XTuweNnNE+ww9n0N345SCssIlSpFM1YK24xhqZyvffZTOPDCHsxftCT2QRjYVEFdtZ3zgpCeNmOK24uUUliaCk9JWXwDsLAXBQGCrEQ6TYchVhCWqdn2oqYi2Ndrd58VRUgeD8SIvei1mxIOL+VNkr0IhAPQybcXO9va8O37P4f5Sxbjzns+ASDx9qLkkrC4djn2bN6Mu7+4NvoqlPHsxVAAerSxuL04FjHYi6r9TCkKUsK/XzbYjMTQIMjy6H4nh36ePEMxxF13/wcG+vrwh9+wz1IMZkC583Duvv8L6O7owMbHH0v2VACEmi3oaspkd2Ui6dJBWxAEiLIMd14+lClT4Z0+EzmXzkLOrDnwVFTC5c8BMU0YbecwcPwY+t88jMGGE9Caz8Do7ISlDoImoZyfBk3AspKegXSmsRHfe+CLuPFdt+LWO+9I2jwklwuLa27B7mc3O5YpwAWg2WLF8IDDiR2LZygmjQXXLsaV86/GL3/KXkuRGDoAAaI7M9aqZSvegTlXzcNP1z8IK0XKSy2Nd3hmCQ2aACEQ5dS/hkXJBVdODuTiYngrp8FffQlyZl8O38wquAvs0t1gTzcGTzag/8gbGDh+FGrTKRjtbQj294EkqfrF7lKe3PuBZVl48L77IQgC/vO7302YbuJoLF1Ri+aTp9Dw5luOjMc7PLOFH1+2JKKBH3cohphaVo5b3/s+PPXLRzDQ38d0X5auwpUGzphoKZ82Hbd/8MP4zSMPo7OtLdnTsZsBWFZKdTvLNEiad9AWJAkufw7komJ4KyqHjMaLqm2jURQR7O2GeqoR/W8OGY16xGg0mc6PaKEs5iQaZIau4xuf/gwKiorx2W9+I+lag0tW1KKpvgGnjh+f9Fg0aIGaJn+IZIQd1OF6Q6yIHF9+j0sKgiDgo/d+BkcPv469O7cx3Zetn5g5Wq+CIOCeNV/EibeOYMuf/5Ds6QBAKADNf0ussFLAnpkMgihC8nrhDhTAU1YO38wq5Fw2G/5LL4MypRSirMBSB6G1NGPg6BH0Hz2CwZMN0M+2wuzphqVrTAMPlFIQTU96EsVvfvJTvPrii/jiQ99DQUlxUudy1eJF8OXmOFb2zPX92JJKJfuZiKWxtxfTc3VnxAf//R6og4P4/ZNPMN1PpujhDOeuT/wHZFnGL3/0ULKnYusnprHxkg5YWuZlgAqCAMnjsY3G0jL4ZlbBf+ls+C+ZBWVqKUTFA6Kp0FqbMXD0TfS/ZRuN2tkWmD1dsDTnjMZUuLlu+PY6NB49ii//7w/gz81N6lwAYP6SJfD6/dj97JZJj0W0UMm+ize0YAE1wxkpvIM2CyLHV+HHN1nMu2YR3rbwWvyCcZZiMAPtxcvnzceNb38nHvvB9xLWDHEswvIimXaMUwmiZ14GqCAIEN0yXHl5dvXLtBnIueQy5Fw2B57K6XDl5oFaQRgd7RisP24HpuuPQ2tugtHZgeDggGMNYKhpAKBJ1Z979cUX8cQPfoi7PvVJXLVoUdLmEcYty7j2ppscsReBkEORa24zI5aSfU7s2JrbbNcH7nEZxpTSMtz6r3fg6SceQ38fmyxFEjRBrWDGZc/l5ufjQ/d+En/73dNoOOZMinm8kAw0wFMJuyOintYZitFiG41uuHLzoJRMgbdyOnIuvgw5s+bAO802GkEIjM4ODDaEjcZQ18DO9riNxmTfXJ//x7P44+NPoO6LD+CSuXOTNo/hyB4FV994gyMRZ4tHm5lilzvzoA4rwsahIPDjm0w+eu9ncPzNw9i93Tnx//OxdBWuDJLICXP3/WvQ29WFjb9MrlSOXVKOtCjHTVey6X4rSBJcPj/kwiJ4yivhr7oYObMuh6/qYshFxRAkF4J9vdCaTqH/rcPoP/YWBptOQm8/C7OvF8SMvQFM5H6bpCzmrvYOfOszn8WV116DD37yP5Iyh9FYsqIG9UeOoOXUqUmNQ0wTNMgbhrAiXHGRDc+UycA+vuzXYG6NnscHP/4JaJqK3z/5SybjW7oG0a1AEDMvM+Y9d3wQZZXT8HCSO/hx7S62EF3L+o6IgihBChuNZRXwX2Qbjf6qSyAXT4HgCnUNbD6NvmOH0Xf8TQw2NUJrOwuzrwfE0Mc1Gq0kRvRbTp/Gd9b+J5auWIHbPvShpMxhLJauWIFjh17H2aYzkxqH6yeyJRHGSzbD9RNTg6sWXov51yzCL3/6QxAGWruZnD1XVjkN//LBD+G3j21AR9u5pM0jrC2VKSXlqUi6aG6zQhAESIoH7vwAlKml8M24CDmXzob/0tnwlJVD8vpADAN6Wyv6T7yFvmOHMXCyHtrZZhjdnbA0dVwtb5LEiiFCCL79uc/Bsiw88P3vQYq3USMDrrlxGdyyjN2TDEITLdzQInW+WyZBDQMAIPCKFibYGczsg2bcoXgeJVNL8Z6V78dTTzyGvt5ex8cP6+FkIm5Zxt2fW4uXnt+F/Xt3J20eyXTGZAPhclxugI9EEASIigJ3Xj48JaXwTZuJ3ItnIeeS2fCWVULy5YCaBvT2c+ivPxYyGk9AbT1jG42hBjCUEFDDSIrDwDQMfPPT9yE3EMDn1z2Ycuf4mpuWwS27sWfz5MpY7I59fI1gRbIzbDMdfnxTh4/cex9OHH0Tz2191vGxSbiUMUOz5+6qs6VyfvG/30/aHCzewI8p1LJAgyYPMI2C6HLBlZMLpagE3vJpyKm6FLmXXg7/9Cq48wMAALOnGwOn6tF39A301x/FYPMp6B1tCA4MaXlbSdQ0f+rhDTi4ew8e+N53UTRlSlLmMBZevx8LbliKPZMseyYa14NmSbIzbDOdiIYt4+PLHYqj8IGPfwKmYWDT//3C8bEzUT9xONcvr8UV8xfiZ+u/lZQOftQKggbNjHXapgLZHm2OFVFyweXPgVJYbBuNF12C3Mvm2EZjoBCCIMLs7cZgUyP633oDAyeOAoIAs7sTwb5eu9yCcSfRMI/9z3dw/PBhfPmHP0BOXl5C9hkL/txcXLV48aTKnm0Bcw0Sz1BkBtF4+QpLeMOb1OHK+Qux4LolePxnzmcpWroKSc7c4F1YKucfv9+E+qPJkcrJdJs82ViaCsHlhii5kj2VtEAQRUgeL+RAITxTy+GfUYXcS+Ygp/oyKCWlkEINYNTWZgwcexP9R4/AGuiHNTiYkAYwwzn08n784nvfx/vvvQcLrl+akH3GypLaWhw+cBBdbe1xj0FUXtHCEl7RwpZEHV/uUByFopIpeM+qD2DT//0cfb09jo4d1FVIGaiHE0YQBHzo3k+h/uhbOHli8t1YY8XSNQguNwRuvDCDL/6TRxBCRmN+ATxTy+CfXoWci2fDf/EsSDm5EFxuEF2Hfq4VA8ffxMCxIxgMlcCY3V12CQx19uF137Zt2PTYz/Hva76AWW+70tGxnWTpihq8/vJ+dHd0xLV9pLyC6+EwIayxyvWG2BDRG+LHN2X46L2fQcPxo9i15e+OjpsNzq733PFB5OYHsOvZvyV830PBJW7PsCKZ2XOZQrgBjDs3D0rxVPgqZyC3+jLkXDoHnvIKgFJAFGB0ttta3m+9gYGGY1Cbm2B0tiM40O9YA5gwPV1d+NZ99+Hy+fPxb5/5tKNjO8mi5TdDEATs3bI17jGIpkHiFS3MIJrGk4AYQvTE2OPcoTgG7/9YHYLBIDb+6ueOjUki2XOZvTBVzpgJAEnRxbE0Xu7MEkopLE3jx5gB4QYwAgBXbh68ldPhr74UOZddDu+0mXDlBQBKYXZ3YvBk/VADmDOnYbS1I9jfDxoMxrXvs2easf7za7Bo+S3414991NHv5TSLampAKcW+rdvi2j4cbc7UrJ9kQ3QdEEUI7uzVWGUJ0XVAAAQ31xtKFeZetQBXL74ej//sfx2tzLAlcjL7XuuWZZRWVCTFXqRBE5RYEGX+MMuKZOr7ZTqCJAGCCMHlhrd8mq3lfdnl8F90CeSiKRBdLgQH+qE1N6H/6GH0H3sTg6cbobeeRbCnB0QfX8t7LAghWP/5NdA1HV986HuQXKmbwJFfWIgrr70Gu/8RnyQFJYRXBDDG4seXKYly2KbuKpBkiopLcNv7PohN//dLrLzro8gL6VlMBkvXILrcEDNc2LWwuAQA0JkMh6KeuRqVqUCmazqlApauQS4ojPy/IIqQvD5IXl/kNUopqGnC0lQQXYM1OACzowPUNCG4XBA9HoheD0SPB5LHA2EcfZKgaeJb990Hr9+PL6xfl/KOtoLiIsy9eiH2PLsF77jjfTFvn00dJ5MBCWWkpPp1lK6QUEMWfnxTi4/eex/uvetfsfPZZ3DLO98z6fHshiwqPEVlDswutSksmYLOtraE79fSVVtbinejZ4ala1ByU08+JVM4v2JIEAQIimJnJOXlR16nwSAsXbPtRUOFca4vFJyytb9Fr20rih6vHXAd5zn1dz//OV7csQPf+vljKClL/fVpyYpaPPzNBzHQ2wd/Xm5M2xLdAAQBgswDpCyglhXSjOfPlCwYqhjiJc9J5f0fXQ3TMPC3P2x0ZLxsKF8BAFlRkJuXj872+DUr4sV+2Mr8Y5ws7Ggzf5hlhV3OOPE1LAgCRFmGOy8fSslUeGfMgH/WZfDPmQ3P9GmQ8nJBgxbM9g4MHj+BgTcOY/D4cWhNTTDaO2D1D0RKYH7xve/jyD9fxZd/+BDyAoEEfMvJs6S2Bgd378Zgf3/M2xLuUGSKxRuGMIXwEsKUZM6VV+Hqxddj0//90pHxSNAEJRRSFgTviopL0NmeBIeilpkdtFMFO7uLH2OWWFFmHwkuW8tbLiyGp7ISvksuhv/yOfBWV8FdVARBlBDs7YV26iQGDh/BwFtHoZ48BePsOQR7e0EMA5RSHH7lFTy6/ju4Y/VqXHPjsgR8w8mzuHY5gqaJF3fsiHlb217kFS2sILoOQZIgpHCWazpDjMRVDPEzOA6WZcE0jUjG3aTHy4LylTCFxSUJL2EJe+Kz5RgnA0vnWhcsoaYBEBp3tE6QJEh+PyS/f2hMSkENA5aqgWgarP5+mO1toGYQhmWhuqgY637wEC6tqrZv7rKc8sbTkhW1+Nk3voWXd+7CsnfdGtO2RNXgLi5iNDMO0XS4YswC4EQP0XVIPv/EH+QkHE1VnbMXdRWSrEAQMj/ub9uLiXcoEl2F5MtJ+H6zhUQ+zGYrRFPhKo6vu7IgCJBCVSwjxjRNEE2L/EXKowUBesNJfH7NGlz/nnfDGhyE6PGkfIbvlPJyXHrlFdj97GbcfFts2eM8AM0WK5Rhm+rPHOlKWD8xEceXOxTH4YXndkAURVy71JkojKWrkHMLHBkr1SksKUFXgiPOlq7xSAdjiKbClcOdBayws7ucXfxHlMBgqASmvbkZ31+7FguvuRaL5s6Fca7NLoEBRpRLh/97vBKYRFM6rRIXXz4Hu/+xOSaHIrUsUNPkGV4MsTNsnXGqcC7E0jS4h0kicFKDnu4uvPHqQdz/lW84Ml62VLQAdslzV0c7CCEQE+icsOVFihO2v2zD0mwJIu4sYAOl1E6icNieEd1uiG43kDtk6xPLwk/+679g9Pbho5/6JGhfP9S2dsCyICgKJI8SshW9tr3odqXUeV+6ohZP/ugn0DUNSgzHi6gaXPn8mYcVREtMOW62ksgkoIzwvFDB/nOavbu2Y+5VC5AfGHIC0jhtHWpZIKYB0eONe4yY9pfgDYXzGs4WFU/BubMtF7x+wXbx7W7U80002wAXIYz9PRJ9f0ud+6kjWLoGuWgoGkrj9TE526B4QoQ4dfLjXVfi3Y4YGkSvh7kYhRUM4pv3fw7Np05hzQ9+AG+h7aAId5Almgaiagj29oGcawMNBiG43SMdjR5P7NmM8a4vo/SaWVpTi6cfeQTmgA55rIzO86ZGVA2Cy2V3gR9nLvGePyHehTfR28XN+AeGBIOgwSAk2QuQyS9+8ZwHKsa3X9GK72CKwfj2F88SSAkBNQ3bAB9vugm/LtIHVvbii8/vBCEEi264aeT+4lzLLUOFy5+XEHsRSK7NWFRcAmJZ6O3oREHR+A4+p2zGcJNEl+wdf93mNmPc2PIMQ05xbi86ux0xbA1EQZGZXzd/+tX/4Y+/+S2+9vDPUHDJJQBC1S/BIIiqgWgqiKrD7OoB1XVAkiJ2YkTTW4lRr9RJe3F5LX7+P9/FwZ27sXj58jE2vPAlomkQp5RwezEuJj4wRNPgyg8kzV4EMttmJLoGKScnIfZiRjgUWaBrGg68uAcfveczjoxn6SoElxtilmTPFRYX483XX03oPrMpop8MSNC0nQU8msQMoiWmBOuJH/4v3jhwAN/59f8hv3BYA5jhJTCBYfMKBiNORqJpMHqHCXp7RjoZJxL0dooltbX45UMP4ZV9+3DtjTdGtQ0vX2EL0TUILndKZbNmEpYRysKXssOOSCf27tqOWXOvRFFJfOWHwwk3ZFEKpzows9QnXCbe0dY2oUPRKSxNheiW+VrFEEvT4HagoSVndBKlaf7Wa4fw8Le/jfd+9CMjnHGCINiBZrcbGCZzQgkZUTJtdneBtGgAIXYDmGGVL6LHYwd5GX+H6dXVmF5djT1btoztUDwPGgqQcpuRDWHNeP5MyQ5L1+BO0D2VW6VjcODFvdA1DYuW3ezIeNmmPVdUMiXhTVmIrsHFy1eYQXSNG+CMsTQN7kK21/CBPXvw5E9+go989rO48pprotpGdLkg5uQAOUPOTltw3bAj05qGYG8PyLmzoEELgiyPdDJ6PRDcbggOhtFnXnIJKmbMwO7Nm6N2KPIOz2w5v+Mkx1l4h+fUxDQNvLTnOdzxb//uyHjUCoJaVtbYjGEnbGdHG4DZCdln+LfEYUOkS7kn9bsApyuWxr5BV39fH77xmU+jevZs3L1mTVTbCKIIyeeD5PNFXqOUgg7TZrQGVZidXaCGMTKbMexoVJzXj11SU4O//va3sIJBSFEk91iaZtut/JmHCTRo3+f4OswGSizQoJmw48sdimOw77ntKJ82HdMvqnZkvGzLnisoLsHgQD/UwUF4h91UWEEphWXwbnIs4c4YtiRC36/j3Dk8+Nn7MX/JYrz/nk9MaixBFCF5PZC85wt6ByNOxoijUbPF2S/IZlTiz2YUBAFLV6zAs5s2wfr61yFFMQ7RNLgLeUMWVvBoM1ssg+sNpSKvHXgZgwP9WOxUAFpTIcoxlgemMQVF9prcmcBGftlmkycaapqTajDHmRiiaXDl5TEbn1KK7z3wAHq7urH+iSfgluW4xxIEwQ40yzIwbM4jshlVDWZnF4h2Xjajx5lsxqUrVuA3P/sZXnv5ZcxbtGjCz/OKFrYQXYPglrPmPpdoLF2HILkSVhnLHYqjQCnFvl07cGPtOxzLBLB0Fe6c/Ik/mCEUldglLJ3tbaiYPoP5/oihARAguuO/4XHGhxvgbLE01TaWGC3+lmXh2/d/DqIo4j+/+11m4vei2wXRnTtC0NvOZtQjJdPBnh6Qs2dBrVGyGT2hbMYo1t4lNTV4asMGvHHgwITZlpRSWwDayw1EVliaBplxhm02QwwNEsMHSE587N21HSVTS3HxrDmOjJdt91pZVpCXH0hoVYulq3DnZUeTxGRg6SqTLDOOjW3PqJCmTF5iYSz+8uSTeO7v/8BXf/wjlE2bxmQf42YzhuxFS1Vhdo2SzTg8MB2FPXvp3LkoKSvD7s2bo3cocnuRGbbGKj++rCCGBlFOXECHOxRH4diRN9B+rtWxaDMlJNSJK3sMxKLiUAlLghyK4ZJyXgrGDqJpcOcFkj2NjMUuF2W3Rjz5k5/gny+8gPVPPIGC4sQ6fexsRu9IgfawoPcwrZ1gT4+tzRhlNuOst70NRVOmYPfmzRM7FA0DoDxjghXhhj48g44dlq7BrbB7gOTEjh2A3o5FN9zsaADa5WWvpZtKFJaUoCNBGYqU2E0SeTY1OyyNZ6uzhHW56PHDh/HTb3wTt33oLtzw9rcz2cdYRLIZ3edlM1rWUNNATYPZFVs2oyAIWFJTgz2bN+OTX/3qhOs1UTXIubzDMyssLjvBFLtqM3HHlzsUR2Hvru3w5+biyvlXOzKepasQJFdWCakPiWwnxkDMtoh+ook4xfkxZgZhqIfzzxdewK9++L+461OfxLzFE0dmE8EIQe/Rshm16LIZFy9fjj1btuCeL31pXAORaHooY4IHHVhATe6wZQmxgqAWb4qVapysP47mplNYfKMzAWjAtmeUghLHxksHCotL0NHelpB9WboWKgVzJ2R/2QjRE9NgLlshugZBZqNpPtjfj69/6tOYccnFqHvgAcfHjxdBkibWZpwgm/H6mhr88Ykn8NahQ5h15ZVj7isSIOUZdMwgmgZXDq+4YIWla5BzAwnbX/Z4uGJg765tuGbJDXC5nTE2bGdXdmXP5eTlwS3L6EyUgaipkHn5CjNsA1xiVo7LCS/+zmcOdrV34MHP3o8rr7kGd33yk46P7zSRbEbvSOc1CQZBVDXibAz29oLoOj66ahWWXHklzr3xBgrLyoai0+cZ2pamcuOQIZamcYctQ4ih8w7aKcjeXdvh8Xgx75rFjoxHgiZoMAhJzq61qqh4Cs62nEnIvsI2OYcdlqZB5k0SmcGqIQulFN//8lfQ1d6Gbz32J8gpHiCMSptxWDZjdW4ufvTjH8NqbYUx3F48L5uR6ro9/iR0IzljQykNJanwdZgVxNAhJtCO4N6B82g/dxZHD7+OlXd91LEx7XLc7MrsEgTBjji3sXcoRhqyZFFJeaIhmgpR8XJnASPsaKjz1zAhBN/+/OdgBYN44Pvfi6pxSaoiulwQcy/UZjQHBrBzwwbc6PEgLycHpK0NNBi0sx+9Q2XT1sAgpByeMcEK3jWVLZauQUqgHg4nOvbu2oYF1y2B4tCDt6VrEN1sMo9SmcLiYhx+7ZWE7CsbbfJEQqwgaNDkNjlDiK4ykcj521NPYcdf/oIvPfQQKmbOdHz8RDGeNuNrO3bAUlVUz5o1ZjYjCZoQeICUGcTgDluWkGC4okUBTdA+uUPxPPY9tx2iKOLapcscG9PSVLgLs0/3qKhkCjrb2Zc8E9Owu8nxhy1mWFw8lymsbq6/ffhhHNy9Bw/+4ucoYijenSwEUYScm4ugouBnP/4xHv373wGEshmHRaeN3j77vwcHYfX2DukzekfPZuTEjq0B6pv4g5y4IAZ32KYa3V2dOPzqK7j/K99wbMxslW8pLJmSkAA0EGrIUpB598NUgWgaz6ZmDNE0uAMBR8esf+st/PhrX8etd96Jm979LkfHTgXC2YzT5szBV+rqsPi978WMSy+9UGanuxvW4CBAKQaOHr2gbDrapoGcsQkHoPlxZAMxQmuwKHGHYrLYt2sH5l61APkBZ8pnbe257MyeKyouSUjJs70w8W5yLCGaystXGEI052+uh/bvxy+//xDe/4lPYOH11zs2biqytLYWW//4RzQ1NKDyoovsbMacHCDXzkikloWBw0fgmTkTNGjr7Vh9fTDb20DNUDbjMINR8nhsfSJu7ESNpWtwO3Tf5FyIpWuQ8wuTPQ3OMF7avQuEECy64SbHxrR0Fa4sdMwXlZRAUwehDg7A6/Mz2w+lhDePYoylq1n5zJMowprmTkq4qAMD+ManPo3Kiy7CvV/5smPjpiILli6Fx+fDns2bMePii4dkdnxD1+xgQwMknx+Sz2s7GlUNwe6RTQMlj8euglFGbxrIGZvwMw+HDYluyAJwh+IIdE3DgRf34KP3fMaxMS1DgyBKELJQ/LmguARv/PMg8/1ka0Q/UVBK7TIsnqHIDOKwAd7T2YlvfuYzmDNvHv7tPufWs1Rl4fXXQ/F4sHvzZtxZV3fB+0TTIbgkuHIufFC1O03rsMJaO+3t0DUNAC7oHCiFtHY4I6GEgBoGRL4OMyEi65Flunqpzt5d2zFr7pUoKnEu283SVCj5RY6Nly4Mb+RXOeMiZvuxHQKC3UGWwwSWDeY4dhIFHH6u/OF//TfOtbTgJ3/8A5QMP3eyouCaZcuwe/NmfODee0f9DNV1uKZMgeT3T9w0UB3ZNFBUlEhWIw9Mjw7RdUgMA0fZji2Rwx2KSePAi3uhaxoW3XiLY2Nmc1pvUUliMhQtXYXLnzvxBzlxES7H5SXl7LAc7HZGCMG6L6yBoRv40kPfh5QFDjCP14urb7hhHIfi2A5xweWClOOCNMzZSAkFNQw7k1HTYA0MwOzoADVNCC7XkJMx7HBUFAhi9mZIh6P23NnKBhoMAoRAlBOnh8MZH9M08NKe53DnR/7dsTGpZYEGzazM3Cgqtp2yne3tTB2K4QB0NtrkicLSVbhy85M9jYwlLEHk1DX87KbfYcsf/oC13/kfTK+udmTMVGdpbS2+9dnP4mxzM6aWl494jwaDoGZwVJtx1KaBdBSZnb4+2y4ShBGB6YijMcuzGS1dhbsw+wJniYIYGlwJDkxy638Y+3ZtQ8X0GZg+s8qxMS0te1P/C4tL0N3ZASsYZObUCGfPKVmoUZkostkpniiIpkEqduYa3vTYz/HSzp345qOPoqSszJEx04ElNTVY94UvoL21FcWlpSPeG8+hOBqCIEBQFIiKAlf+0IMRtSzbYNTtjMZw50AQMsy56B0yGs/rHJipkFDX1Gz4rsnAMkKNOkSROxRThFcPvIzBgX4sWuZcANrSVQguN0Qp+0zz4RmKLLEbsmSfwzZRhDO4eIYiO2K1Z8bj5LFj+N///m+sWLkSNbff7siY6cA1N94Il9uNvVu24PZ/+7cR7xFNt3USY3D6RWR2hjX+s5stDmUzWn19MIc3DVSGHIyRsukssKEosUBNE2KKdxBPV2y/SOI7aGeG1SKE/mKAnvd5Sin2PbcDN779VkASxjTaaYxJKEFDhVJQHPN2kybRa9IoB6yoZAoopejq6kDxlKmjbzbJpyNqhTsZRffDOf+8cybG0sbRAE300y2Jc7sU/v2RoAlqjR4NjZrQeTj8yit47DvfwfvuvhvX3njjxOcn0b8Hhvu77pabIblc2LNtK267664R71maBndh9Pp+whjHTRAliD4/MKxUI9w5kGgaLF0H0VQEu7vszF5JgqSMLJkWFc+F2YwJPg9CvL+jMY5LRAN0rHHj/X5xbEfjDPzTOG8OAolvERSs6PdHNLt8RbAAMYrNRCuuKWUHcdiLwIW2w95d21AytRTVs2ePa1fEYvsFDTsAnXB7EUi6zejPy4WsKOhoPzfuXCZrM1q6GpMWKbcZY4MY4Wz1Ucpxub04OjFeY0RX4Q5MQk83dB40VcXXP/VpTK2owCe/+tWsshdz8nIxb9Ei7N68Gbd/ZKRD0Yo1AD2WvQjBzjZXPMCwhF0aDMLSNRDNdjYaHe12YBpDMju23ei1bcfzE3LS3F60VB2C5IIkukf/jSbQXgQyz2akpglQAklSorIZnbIXM8Oh6ABHD7+O9nNnsWiZc+LadnRCg5itGYoldsS5s71tTIfiZLF0FaJbgSBmd/o4SyxdhduhclzOhRBNg+CWJ10C0dvdjW985jO4dO5cfOz++x2aXfqQm5+Pq667Fruf3TzCoUgpdTSifz7hzoGiLMM1zKKxMzW0iDZjsKcb+lkNCGnthJ2LtqPRm9adAy1dhzuXrxGssDMUecZPqkApxb5d27Fo2c2O/mazuaJFEAQUlUxBV3s7s32EK1q45jY7wtdwut7LUh1KKSxNg+JA9tGPv/Y1tJw+jR///vfw+rKvEdTSFbX4wVe+iu6ODgSKhspDWdqLgC2z43LlAMOkuii1ZXYsTbPtxsFBGJ2doKZhy+woI4PS6SyzE26kymGDbS8mvlEtdyiG2LdzO/y5ubhy/tWOjUl0DUD2ij8PlbCw01Hk5StsiThjHCrH5VyIEwLmlFL8z9q1UAcG8OUf/AAud/Y1gQKAJbW1+NH/+xp6u7uRFwgACEXrQiXJicTW2vFB8g4Z6pTSUBMYLWI4Bnt77ayOkNaO5PGOMB7TQWuH6HyNYAkxNLh93GGbKjSeOIaWptNYdOPNjo5LNBXuvOztlF5YXMy05JmYBgDK9aAZYmncJmeJU/bMtj/9CX/fuBGfe/BBzLz0Uodml14sXr4cD335K9i3fTvesWpV5HWiaXAXFyd0LsNldoanM1LLGhGYNrs6YQ2X2TnP0ZgOgWn+3M4Wy0xOAz/uUAyxd9c2XLPkBkcfxJ0Wzk03CouKIQgC08YslqbC5cm+yFqiiLWknBM7TnTQ/sPjj2Pftm34fz/9KaZWVDg0s/Rj8fLl+OFX/wsvbN+B2vfaekB2OW5qRHMFQbC1c9xuuM7vHGgYIJpqZzP294K0n0sLrR0SDK0RvAMxEyilsEwdEneCpAz7dm6Hx+vF/GsXOzYmtSwQ08hq7bnC4ils7UVdtaUDUmTtzEQmXY7LGRdLn7w909TQgO9/5StYftttePvKlQ7OLr0oKC7G5QsWYM/mzRGHYjiJQvKkxv1WkCRIPv+IjsgRmZ3zKmDCzfFGVr+EHI0pFJgmugZ3fiDZ08hYLCM59iJ3KAJoO9uKY4ffwKoPf9zRcUkWl68AgORyIVBYiE6GEedY9XA4sWFpGkSZl5SzxM5Kib8j4puvvYYN69bhvR/5CJbU1Dg4s/SjeOpUzJ53FfZs3jzSoZjiD+lCyAg835kwpLWjja61o3iGNBqV5DSBIboWs4A5J3rsrCpAdKfGAw4H2LdrOxYsWgLZwaxnS9fs0rbRtOeyhKKSKXjtwMvMxg93eOawIVxS7uEBaGYQTZ2UjJah6/j6pz+NktJSfOZrX8t65/rS2ho89p3vYrC/H76cHFDDvt8KKVySO0JmZ5jUTLghUtjRGOzthdE2FJgebiuKHo/9bJfg88/XCPZYhga3P/EVLdyhCOCF53ZAlCRce/0yR8e1dBXuLHd2FRSVMCt5ppYFGjSz2mnLGqKrtqgwhwlhAyDeY9zf24tvfObTqJo1C3evWePw7NKTpbUr8PhDD0EdHITX5ws5FNNzjRjS2hnZOZAaRsTRaKmDMLo7QQ0DgiQNGYvKOE1gHMTSk1NekS1YhgbJnToZqdlOT1cnDr/6Cu7/r286Oi53dtklz53tDEueNQ0urgfNDGoaAKVcH40hRNNGyKjEyk+++Q2cOnHC1k30+yfeIMNZUluLn33rQby0axduvPXWoYqWNLzf2jI7XkheL4aHpUhIZsduHKgh2N8ekmQbFpge7mhkGNSiwSBALIjcZmQCpRTE0HnJc7LYt3M75s5bgDwHU3DDwrmeqdluIJYwMxAtXYXgckOU+GXMCssBfT/O2IRLFIQ4pBYopfjOFx9Ab3cX1j3xONxydmq1ns/S2ho8sm4d9j//PK5fsQKWpsFVkDm6ZCO0dnKHae0MbwKj2yUwxjkNNNwEZpij0SV77EZADhjNxNB40IEhxNS48Z1CvPDcThBCHG3gB0w+8ygTKCwuQU9XF4Km6bgOsJ0Zo0IpZtMgkDOsoiXBzQCyCUvT4C6IL1Fl59+ewV9+8yTu+/rXUTVrlsMzS0/Kpk1D9ZzZ2LN5C2689VZYqgbRm1n3W9HlgpgzQWB6eBMYSRoRlJbczgWmiaFBdMspIUGUiRBTBwRAdCX+eTDrPTGaquLAC3vwsU9+1tFxiaEj28WfKaVoOtmAa6+/kcn4dkQ/sxb+VIPoKuT8zHHGpBpEj78j4q6//w3PP/sPfPWHP0L59OkMZpeeVMyciZmXXoo9mzdjaU0NqG6kfMmzE4zbBEYfFp3u64Wm6wAwVDI97F/RFZtZYOkalILECphnE5ahQVK4TnCqsG/Xdsy64m2RpnNOYWkqlJz4pS8ygdONDQgUFkJkIJ9AgyYosXg2NUMsPbtlnlhDLQvUNOIKPPT19OB7X/oibrz1Vtx6550MZpe+LK2txcZHH4Wh63YGaE7mZ26OCEznnd8ERo84Gs3ubmiaFsoqlC+wGWMNTNsaoHwNZoVl6JDcydEJznqH4sEX98LQdSxa5nC3vpCzKx3Tpp2i8fhRtJ5pwmKHOyGGsTtFceOFFZRYIEZ2OGOShRWnvh+lFL95+GEsWLIUy97xDlBQBrNLX5bW1uKPTzwBo68fkCQIMTrJMoXhTWCQM9QEBpZdFkF028loDfTD6GwHDZq2jtv5jkZ5dBF4Sqnd4ZkbiMywDB1yLg/qpAKmaeDlPc/jjo/+u6Pj2k2Z9KyvBti3azuuveEmiAyyVyxdG3Md4zgD0TS4hmVBcZxlSGc1dnvmL795EoZh4D++/NWsfi4djSW1tXj8oR/gn/tewOWlpXAXFyV7SknDbgLjg+QbFsS06JCed+jP7Ou1K6wEAdJwPe9wJcwYlYOEd3hmimUkT4IoO5+yhrF35zZUTJ+BaRdVOTqulca6XU6xd+d2eH1+XHXtdUzGt3QV7iyP6LPE0jQIUnaLxLOGaPF1O3tl314cP/wG1v3icecnlQEsXVGL//vRj3DqzSOoLJnCDejzEAQBUsgAHP7rppYVMRotXYPZ3QlN1wBCIMojjUZJ9oBQAgBZnYnPEkoIiJkcPRzOhbz68ksYHOjH4htvcXRcS9cgSBKELL7XNp1swKn6E7j7vs8zGZ9rVLLH0lXIRc5m7nKGsPX9Yr8XGLqOPzzxOGpvvx2FxcU8AH0eF116KSpmzMCL27djzqpVWR/YOZ+xAtOUEhDDGKp+GeiHNTwwLV8YmLZ0rmPLEmJokDzJqWjJaociIQQv7NqBm97xLscfOC1NhTsv4OiY6cbeHduwcPFSyAweNiMRfR7pYAbRU787bjpj66yqUKaWxbzt0489iupZs7FgyRIGM0t/qmfPRmllJTrPNGP6NF4OHi2CJMHl8wO+oZIfu2zaHNLa0TWYvd22rEfovqmdbR5ZBsM7PjuCZeqAIEKQstfRlErs3bkNU0rLUH3ZbEfHJZoKUYlP+iJT2LtjO9yyjAWLljIZ39I1uCbRzIIzPiQYBA0GuU3OEKJpcZWUb/vzn9HZ1oaVH/04g1mlP4IgYEltLRpeew1wubK2oiVWBEEcPzAdthd7hgLTAGD0dIEY+pC96HJn9b3PSSxTg5yXnGbAWf2rOXbkDXS0nXO8JDcs/uzxxO4oyBQ629tx5LV/Ys031jEZ3zI0CGJ2R/RZY2k8os8SGjTtzK8YOyLWv/UWXn7uOfznd77Lb8JjYBuINZAIgaDwZjWTwY5OyxDdMuAfiixTQqCeawHVNQiSiOBAL6zOtgvLpuVQB0FebhgzJFS+wn/nyYdSihee24Hrlt3sfACaa89h385tmH/dYnh9bJx+lq5CCWRvKSNriK7aemo8mMQMS1MhF8WmV0wIwdOPPYrFtyzH9OpqRjNLf5bW1qCvqQmDug5etD85IoFp78jAdHCwH2pTIySPd2RgWhQhycMyGT08MB0PdkWLwUuek8G+ndvhz83FFfMWOjouNQ2A0JgdBZnEC8/tAABcd8ONTMYPl6/wBy12WLoGpZA3W2CFXb4Su5Pl6ccewZSyMtz0zlsZzSwzWFpbi2IziFOnTuHiIv4g6TSCKAJWEK7cPCiFQ2Vuo5ZNG2OUTSseCG4enR4Ly+DlzqlC44ljaGk6zUQT2tJUKEVTHB83Xejr6cFrB/fjM1/6bybjEysIGjR5gJQhlqbxUlGGRPSKYzzGL+7ciVMnjuP+b3yT0cwyg1lXXYX62bNRX1+PKVe9LdnTyTgEQQAsC6LHC0/x1Mjr4WpDS9dADG3swPQEet4cu6JFECUIY+hXsobJXnt6evDrX/8aiqJg8eLFmD3b2fIQp9i7axuuXboMLrezWW6WptqOAiF7L/p9O7dhztvmIVDI5kGexNnMghMdQ80WuAHOCisOPZy2lhZs/8tfcPcX1ji+bmUas6+4AoNvHcUz//gHLp43L9nTyUiIrkEOjCyvGLVsGhTUNEc6GodHpyMGozKsbDqr450A7Ex8ty+z8yXSxV7ct3M7PF4v5l2zyNFxKSEgup7Vzq4Xn98FYllYtOwmJuMTXbPL6njGCzO4RiVbqGEAiF2veONjj2L2VfMwd8ECFtPKGERRxJzL5+DPf/4Lrr39X3iQkwHWKA1ZBFGE5PGOzNAXYtTzDgemkd3njBgaxCRWtDCx2JuamnDffffZwu+SBMuyUFhYiLq6Otx3330IBAKO7o9K9l8stJ1txbHDb2DVv30ciMXvF8V5svSQzsWwz9JEn99E72+Yxq+h69i/dzc+dM+nQCc4tkKc2sBBQ4VSWBzzeU8bkqyZTHQdAOwyx3HmIpL4xhfi3C5e4j6cccYEJrruAbtESPT4zvutjj/T3z/xODweD965atWIz8b7O0r4ZZbIdckw0dPXh+f+8Q98fM0XYrzJZrZhEu/9aPhm4fIKUfFMeLgEOqxsOmdk2fSI6HR/H6yOMUS9ZbbR6bjv0SK7a8UyNSjyeVni0fxo00hzPx3sRcAOQC9YtASyN8bKkwkuD2LqgChAkN1ZazPu3bkVl8y5HMXlZRNeuvHc6yzDLinn9iI7iKbBnRvg9mI8+4tiO0tXISoeCCPuN+PP9M3XXsOrL72I//rfH4Xkju3Pc3vxQiilKC4swmuvvILjhw/jkssvj2Frbi+OxvmbEUOD5MuZ+HBRQBAluLwXlk1H9LzPD0wL4lBAOlQ+LSpjd5t2glSzGe0Oz6PYJxP9cB36YTM50g0NDaCUYs+ePSgtLcWxY8dw4MAB+Hw+iMMeBt566y389a9/hSzLuOmmmzB37lwW0xmVfTu3Q5QkXHv9MsfHtjQV7tzs7WJ08IW90FQVi25yvjQIGJ49xzMUWUF01Y768CgdMyxNg7sgevHcgb4+PPPb3+Bd7/8A/Lm5E2+Q5YSzmJtPnULD0aOouuyyZE8poyB6WMc2fjNi1Og0oiiblj0jjEfBLWfcWkWJZZdpZnjJczrYi92dHTj8z1fwua99y/GxLc12dmXa9RstpmHgpd3P4V8//FFm+7A1KjP7d5RMhpok8gxFVpA4SsqffvQRVMyYgSU1NYxmlTlQw4AoCOjp68OezVtidChyosHSNcgF8ctojdDzHh6YpnaWv20v6ggO9sPqCgWmpfP0vDO4bNoyNLj9yfM9MXEoHjp0CDk5Obj66qsBANOmTcPNN490Lj3zzDNYvXo1KioqoGkavv3tb+Pb3/42PvShD0U+Y5omAMDNoLRv387tmDtvAfKcjn5TamcelUyd+MMZyr4d21A+fTpmVF/MZHxihLLnGHSP5tjY5bjcOGQFtSzbgInBKf7MU09B13W899/+jeHMMgeiaSgsL4cvx489mzdzh6LDWKGgDgtHyFii3pHotBFyNPb1RrpNi4oCSbYdjGHjUUzjbo2WodnGcIaXfqeDvfjCcztBKcWiG5wvyQ07FLOVQwdexkBfHxbfdAuzfVi6Bld+gNn42Q7RNQjS5IJLnPGxNA2unOjlL5pPncLzzz6LT331vyDxUv8JCQegr152A3Zv3oyPfPa+ZE8po6CWBWqaTBKBBCEUmFa8F3abNoZnMw4rm3Yrts0YqX7xQEzzwLRlaPAUJE+L2XEXrWmaeOutt2CaJnbt2oWzZ89G3iOhluENDQ245557MH/+fPz+97/Hrl278OEPfxj33HMPTp06Ffn8d7/7XUybNg1NTU2OzlFTVRx8YS8TcW0aNEEt6wKdgGyBUop9O3dg0Y23MPthhjsipvMPP9Wxy/az8xpOBLYB7oIY5cOvaRj43S9/gVve/R4UT83eYEUsEE2DO8ePa2+6Gbuf3Zzs6WQcic4SFwQBoluGOycPSuEU+MqmI2fmJci95HL4p1dDCRRDcLkQVPsxeLYJfQ1H0Ft/BP1N9VDbmmH0dCKoDYKSBNfPxUk2NGRJB3sRsAPQs654GwpLSib+cIxku0Nx747tKJ5aikvmsMkI4tlz7LFCetvcJmcH0VSIMawTv/vlL5Cbn4/a976X4awyByvkUFxauwKNR4+iqaEx2VPKKKzwM08Cgw6CZJdNy4EieKdWwD+tGrnVc5Bz0WVQSkoheXwghgGt4xz6Tx1D74k30H/qOAbPNkHvakdwsB8kaILSFNCUmABiWaBWEKI7eTaj4w7F/v5+5OfnY9asWfjYxz6GyspK3HnnnTh9+nSkfOWJJ56AZVl48MEHUVlZiYKCAtx7770oLi7G73//ewDAzp078cc//hF///vfUVlZ6egcD+zbA0PXsYhBRNRuyOLJyHTaaDh2+A20n21lVu4MDB1jDhvCWbbcAGeHFWNToZ1/ewbtZ89i1cc/znBWmUO40YFtINbgxJEjaDl9OtnTyihSJeggCAIkxQN3XgCe4lL4y2ci76JZyKuaA1/ZdMghXS+jrxuDZxrRe+IN9DW+hYHmk9A6WmH0dcMytJQzGsfUw8kg0sFeNAwdL+9+HosZ2DTZ3vyMUop9O7Zh0Y03Mw1AC5KLZ88xxApJ5HDYQINB0GAw6vttT1cX/rFpE2676y54vNm5tsQK0Wx7ceEN10PxeLBnMw9CO0mqyJSNDEyXwFs2DbkzLkFe9eXImXYx5IJiiJILQXUA6rkz6Gt4E30NocD0uVBgWh0EJVayv8oISKSiJXnZyI7fYfPy8vDZz34Wn/vc56AoCv7+97/j85//PL761a9iw4YN6Orqwp///GfU1tZi7ty5oJTaJ1gUUVxcjKNHjwKwDc0vfvGLmDdvXuQzTrFv13ZUzpiJ6RdVOTZmGEvL7hvr3h3b4M/NxZULrma2D0vX4OblK8ygwSCoZaXE4p+pxNKlnFKKpx59FNcsW4aLLr2U8cwyA6Lb3YMFtxvXLFsGtyxjz+bNWMkdso6RKgbiWISj0xeUTVvBYWXTOoID7bAMDaC2jEakbDr034LkTkrmDTE0uHMCCd9vIkkHe/G1/S9DHRzAohudD0ATPVSuL8uOj50ONB4/hpam02wD0KHOojx7jh1E0yDHoAfNiQ1L0+wutlE6C/7y5JMghOC2D97FeGaZA9FUuAsLIXu9WHj99di9ZTPuqFud7GllDKN1eE4lwoFpSfEAwyTqKbFgGSF9RkOD0Wc3gaFWEKLLbesyDvsT3UpS7jWWqSW9osVxh6IkSZg5c2bk/z/ykY+gsbER3/72t/GlL30JqqriyJEj+NznPjdiO4/Hg97eXpSESkre9a53Rd5z8uQQQvDCzh24+Z3vdmzMEeNrGiR/9DoXmca+HdtwzfXL4GKgYwTYD4SWrsLjKWMyPifUTS5DRWtTBUtTIRcWRfXZ/bufR8Nbb+E/vvxlxrPKHIimQfTaD5Fevx8Lli7B7s1buEPRIUhY2iPNMugEQYDgckN0uQH/kNVIKQXVDVtvx9Bg6YMw+rpCHXhFSO7zjEbZwzQSTCm19XAyvOQ51e1FwA6STiktQ/VlsxwdFxjK7MpWZ9e+ndvh8Xox/7rFzPZhB/l5lhYrbJs8e7NsE4HdkCW642voOv7wqyfw9n/9VwSKorMxsx1b09yMBPmX1NZi/Re+gPazZ7nEkEMQXYM7P/2CDoIoweXxAR7fiNdJMAiihexFQ4Pe0w7L0AFK7cC0WxlpL7rYBqbtipbk2ouOewwIIbAsyzbQQyVEN910EwzDQG9vLxoaGqBpGhYsWABgyPjTdR1nz57FjBkzAIBZ+dGxw6+jo+0cFt3ovLg2kN16OG2tLTh2+A0svpmduDYNmpFOnxw2pHrmUbpjl7npUevhPP3oY7h07lxcde11jGeWORB1ZDR06YoVeOPAAXS1tydxVpkD0fWYMiZSHUEQILkVyP58eAqmwj91BvKmXYr8mZcjp6wKSl4hBFGEOdiLgXOn0HvyMHpOHkF/SwMGO1ug93UhqKuO6TNSKwhKrKQbiKxJdXvR1oTejusYleSSLLYXAWDv9q1YsHgpZIWdPUf02ORFOLFBTAMA5TY5Qyxdjfoa3vyHP6CnsxMrP/YxxrPKHIimQ5AkiG47x+q6m2+C5HJhz5YtSZ5ZZhAOOqSCRI5TiC4X3N4cKPnF8JVUIrfiYuTPnIPcaZfCWzAVkuyBZWhQO1vRd/ot9DQeRt+Z4xhsa4LW0w5T7Qexgo7NJxUcio5nKIqjZDWdOXMGfr8flmWhu7sbXq8XU6aM7ETT0NCA/v5+zJplR4FZeXL37tgOf24urpi/0PGx7ayN6HUuMo19O3dAlCRcs3QZs31ku0ZlIrCd4r6JP8iJC2oYdhQrioeoY2+8gYN79+BL338oa7NY4oFoGlyB/Mj/L7rZdgjs2bIV73r/nUmcWWZgZYnGqiCKcCle4LzvSizLjkybdgdBo68TlqmBEgLRLY/MaHTH3j3QMnSILjnj73Opbi82Hj+K1jNNTBr4Afa91h1Iv6wNJ+jqaMeRV/+Jz3/j28z2Ec70zYa1KlmQsE3O7RNmEE2DKzdv4s8Rgo0/fwxLa2pRMWMm+4llCOGKljB5gQDedu212LN5C267i5eNTxYaDGZFIpAdmJYhuWW4/UO/V0rtxmCWqcMyNATVfui97SBBE4LkCtmLygibMRbbj1IKYugQMylD8eDBg/jSl76EU6dOwTRNAMCRI0fwgx/8AJdddhmuvvpq9Pf3Iy8vD6qqRrYLBoPYtWsXiouLcdlllzk5pQvYt3M7rmVUkmtp4VLRzMjaiJW927fiyoVXIzc/f+IPx0m2PMgmk0yLJKUalqZBVKLT2dj42GMorazEsre/PQEzywwopRc0vckvLMQVV1/NhbYdguh6VA7xTEUM6TMqeUXwFVcgt7wa+dPnIH/aLPgKy+Hy+ECCBrTuc+htPobuk2+g98wxDLSdhtbdBnOwb9zugZapZbzxnQ724t4d2+Hx+jDv2kWOjx1ep7LVnnlh104AwHXLbmS2D2JotkalOzs1KhNBqmujpTvhBnPR2OT7tm9DU0MD3vfv/56AmWUOo2maL6mtwasvvoi+np4kzSpzsHQtq2W0BEGEpHgh5wTgLSxFTulM5E+bhcCMOciZMh2y3/aZGP3d6G9tRPfJN9Bz+i30nz0JtbMVRv/4jQMjFS3u5NqMjmYotrS04KmnnsLWrVsxb948eDwebNq0CZZl4Uc/+hEAWzPH7XajubkZ5eXlAIDTp0/jL3/5C5YuXYqioiLHRbXDtLW24NiRN/C+j7JZbIkWfVp6pqEODOCVF/fh3z/7Bab7sXQNLl/2alSyhloWqGlwPRyG2OvExMf37Jkz2PG3Z3DPA1+ExDtURg0NBgHLumAtXlpbi4e//W309/UhJzd3jK050WDpGhR/cbKnkVIM12d0Y6Q+Iwna+oyWoSGoD0LvH0ufUYEoe0BSoHyFNaluLwLAvp3bsHDxEiYlucTQAUSXqZ6J7NuxDbOvvAoFRezWEdtha2fPpVYP98zB0tUR2TgcZyGG3bhJiMIp/vSjj2LuwoWYM29eAmaWOViaBndhwYjXlixfjv/9r//GC9u3o+b225M0s8zAltHKzvvceNj6jH64PKM0DgxlM1qGBrN3mD6jW75Az9syNLsKJskOW0f3XltbiyeffBK33norTpw4gRdffBF33nknnn32Wbz3ve8FAKxYsQKEEGzYsAH9/f3o6+vDN77xDbS3t+PjIcF8EqMOUVCNTrsoXJJ77fVsSnKzOdq8f+9umIaBxQy79QFcYJs1lq5BcLkgcgcWMywtugzQ3z3+S/hzcvCOlSsTMKvMgWgaBPnCm+vi2hoETRMv7diZnIllCLYGKNdZjZbh+ozegqnImToD+ZVj6TM2offkERh9XTAHeqF2tEDv60RQG3RMnzFVSJa9aA5Ep13U1dGOw6/+k0l3ZyDUaCFLS0UNXcf+Pc8z1dsGeEVLIhgtu4vjHCRkL060TrzxykG8fuAA7uDZiTFBKR31Gi4uLcWsq96GPZu5juJkITyLOWoEQbCD0t4cePKL4S+pRF75xQjMCOkzFpZeoM84ePYUqGUN6TMO9o9bAcMKR70Gbrcb11xzDa655prIa4SQETo5M2fOxP/8z//gy1/+MpYtWwaPxxMpc1mxYgUAOyodC2rLKaDrrN2+2+O1W397vJAU74iHyn27tuOK+QuZleRamgq5IDu7au3buR0zqi9mqtsR0ajkCxMzCDfAmUN0DWLx+FkZ/b29+NvTT+P2D38YXr9/3M9yRjLWA87U8nJcesUV2L35Wdz8nncnYWaZATEMAMj4klzWjK3PGETvyTfh9ueDEgtGXzeIoYESC6JLhqiEMhmVcIQ6OvmEVCNZ9qLe3oq+nnYILjckxQvJ4wn967W7f4d48fldAIDrljFq4KdHl6meibzywj5oqopFjLQpw1i6CjkvOzUqEwG3ydljS+RMfHw3PvoYplVV4TrGSR2ZBjVDjT5HyaC7vnYFnvjhD6GpKjze7FyrncDSo9MA5YzNePqMA62nAQEQJBeCaj+Mng6QoAFBlGwbUfFAUmxbUZI9zJopMk9DGk10+84778SsWbOwefNm9PT04Cc/+Qne9ra3xb2PnIsuhc/jgaWpsHQVwYE+6J1toFbQPoCKF0RyYbC7Eze8412T+TpjQoJB0KCZlR37LMvCCzu34+23s82ksvRQWq8k8fIVRlg884gpNBgENc0JDfC//OZJBA0Dt3/owwmaWeZAxskAXVpbgyd/+jPomgaFZ1XEBQnr4aShEysdsDMRKTwFJRAE236KlMEYOqxgqHS6a1gZjCwPGY6yB8R0rntgIkmIvTjjYvi8Pli6GrEZzd4eEFO3BdJDweizjSdwzZLrUVDEJkhsaSrceQEmY6c6L+zYjrLKaZh5yaXM9pGJnUVTDRK2ybNUNz4REE2Fa4J1oqmxEbu3bMZnv/71UddQztiQsKb5KMdtSW0tHlm/Hvufex5LV9QmYXbpj13RovOgAyMEQQS1TCiBEsg5Q8lylFi2vWhosIIazP4eWLoGagXtYOqwoLRlOGMvJqWuURAEzJs3D/Mc0nmgLgHwyJA8MiTYB5RSChoMgmi20djVdBqf+fSnUVhUhN7Gt2yj0eOFGPo3ao/tGGu1paq2xoU8lrMrPhcYjfOZTYjb4xb7Dt889Cq6OzvjKl+J5fuFI/rxHpNY9zecuI9ngreb7CO+panwFE6J/vvGOc94D0vCz0O8VYZjLCeWrkFwuyGMUVJOBbsc7PePP47lt9+OgiklUU1diPPCjn+dSOx6FsvuiKrBlZc/6jZLamrx8+9+Dwd378GiWxiU2yU60pGEyEoiRfjjulziXlzi28zpU0AMDaJbiTgTgZH6jC5xSEPYtnNM22jU7Y7TZl8P+ru7HJ5V8nDaXiQSQGUJopwDMTcH4ZxEaln2MdRUmAP9WHDFXNz2jrejr/5NiB7PSHvR7Y7eoT6KzWg3ZFGhlJaBjml6ZqbNSCnFvu3bcH3NiriCEtF+P8s0AEohKJ7MtxmTaC9Kipfbi2EcthfD5bjSlNHvt+Frc+Mvfo78wkIsv/32qK5Xbi8OQdRQRcso21TOnImZl1yC3Zs3Y2ktA4diFtiLsWiATpa417M0thkppbBMDdJ5FUO2PqMPLo8PdJgNQqwgiKHB0nUQQ4PR04mB7k5H5pKxQmmCIEBwuyG63XDl5uG3P3gIr778En75zD9CTkYNljoIo6sD1DQhuGVIHk/EYBQ93ph05CxVg+TNTg/8vu3bkV9QiNlvYysEbGlqVmaAJopI63keSWJGNHpD2//yF3S2tWHlxz6WoFllDuGOiGMd4xkXX4xpVVXYvWULG4diFkB0DZLXl+xpZCxWDA1ZhJChLp5XBiMU9LKaXsYiSBJcPj/g8+O1w0ew9lOfwoY//gUzK6fD0mxHo9F+DkTXAFGyS6W9w52MctQOMmqadmZpFgrVHz98GG2trVh8E9v1l2gqz6RmDNfSZQsNBkFHaTA3nO6ODmz+3e/wgXvvZdI8KtOxNA3SOOXMS2pr8adf/QpB04TL7R7zc5zRsfUT+TrMChI0AAqIUXZ4FiUXRG8OXN5hzW3zSxyZS8Y6FM9n/+7ncf2Kd0B0uSHmuOHKGVaDHgzapS+aCqJpMLu7QE3DTgv1eEdEp0Vl9AUl2s6tmci+bVtx3bIbY9YyihVL1yAHuB4OK+yukwLEBESSspVw18mxIIRg46OPYtHNN2PGxRcncGaZATEMQBQhjGP4La2txTNPPQUrGOTds+PA0jXIBXwdZkUsDsWx4Mb75Hh59/MoKS1F1azZtnaRb1gXRkJAdC1iLxod7baTURAutBdlBcIoaQyWqo5ZZpfp7Nu+Df6cHFyx4Gqm+7HLnbPTJk8UlqbBnRtI9jQyFqKpozaYG86f/u//IIoi3v2BDyRwZpkD0TS4CwrGfH9pbS1+/eMf49UXX8SCpUsTOLPMIFoNUE58WMbkJYicshez4mlqsL8f51pacMmcy0d9X3C54MrJhSsnN/IatayQwWg7GoO9PSCGbnfA9XhDkWlPpPzF0lS4A2MvSplK86lTaDx2DB/55H1M90MtC9Q0IPKGIcywOyJmZ9fJREE0Fa7iKWO+39nWhpPHj+Pf7rsvcZPKIIiqQpygI+KS2lr85mc/w6GXX8ZVixYlcHbpDyUktA5zA5EVlqFBzgkkexpZzcnjx3DJnLmjriOCKELy+kZk6YY7n4ftRaOrA0TTACBiL0oeL0SvrXNJsrjaYt/2bbh62TK4ZbaBS0tT4c7hjQBYQQkBMfWsvY4TgaVN7BQ/uHcvrrv5ZuSP4xTjjA4lBNQwxs0AvXjOHEytqMDuzZu5QzEOiK5B8udM/EFOXBAHAtBOkRUOxTOnTgKw9RCiRZAkuPw5wLAfgi1yqYGoYSdjrx2ZliTAshDs7wMlBJLXE1P5Szqzb/s2uN0yFi5hu9BaumY7c3lGETMSqY2WjUTEiccreaa2ugbvKBcf45U7h7nsiitQUlqK3Vu2cIdijFi6BkGSIEh8HWYBpfZDupgiBmK2cuZkI5Ysr4n680IoO1HyeIc0GUMSIkRXYakqzO4uWK2qvcYLAkTFA6OzE1LIyZgN2Yptra04+vrr+NePsJXzCDt4xXGCd5zJwe8F7IlGIgeUQuH2YlwQzX5+H0vTHLDX9iU1Ndj1t7/hU//937zpTYxYuga5sDjZ08hYLEOHlCKJVllxJ2hqbAAAVMyYOalxBHFIYycMJQRmdxf0s60AISGNHX2o/MXrtbUZvZ6M1HN5Ycd2XHXdtfAxjkDY2XOp8aPJVCxNhZylXScTQXhdEBhnZmQzRNPgyhs/K0UQBCyuqcGezZvxH1/5SsatySwJa2bxY8YGYhqAIEJ0ca2mZGEaBlqbmlA586JJjSMIAiTFA8nriVSvhINKg/XHIcoygr3d0M9pQEgnzdZj9EQqYDLNyfjCju0QJQnXLFvGdD/UCoJaQR4gZUjYJuf3AnYQTYM7EEj2NDIWotld4Ce6hpfW1uL3v/wl3nz1VcxxqDlYNkAtCzRoTuwU58SNZWiQU0R2IiscimcaG5EXKEAeg4VZEEWAULj8fngqKgEMNQawNBVEVWF0nl/+4hlR/pKuN+T+vj68+tJLuPdLX2a+r2zWqEwE4Yg+d9qyg2hq1L93SpPQji0DIJoGccrEWSnXh4S23zp0CLOuvDIBM8sMCM9iZoqtn5h5gcd0orWpCYSQSQegR0MQBAiSCFAKT3kFBFG0O3WbZsReDPb3wWhrA7WCEBVlSJMxZDcKjLWqWbJv2zZcsWChbYsH2e3HCjdkEdP3WKU6vCELWyghdpPEaJ57uL0YF1FlgAK4fMECBAoLsXvzZu5QjIFIZSHPYmZCuKKFlzwnkKbGBlReNJPZ+NZ5zi5bY8fWzUFI1oJS28lINBWWqoXKX7RQpz87ih2OTqdLZPrl53bBCgax6Gb23VItXYPC9XCYQYMmKLEgyrxLHCusUDR0XLgjIW5IMAgaDEbVOfWKq69GXkEB9mzezB2KMWDpGtw8i5kZTjRk4UyO06GKlsqLJpehOBaWqo1oyCKEstZFWQby8gHYASUaNCP2ojU4AKOzA9Q0IchyyE70RuzGdJCCUQcHcXDfXnzs/s8x31c4eMdhh6WrkAO8lJEV0ZTjAuA24ySwJmjIEkaSJCxavhx7Nm/G3WvW8IBflPCgA1uIoQOCCEFKjYqW1LdCHKDp5MmY9BNjhWgq3Pn5437G1tjxQPJ44A7Yr1FKQQ0DlmaLeQd7e6CfO2uXvygKRO+wkmmPJ+Ui0/u2b0f1rNmYWl7ONNoc7qrIxZ/ZYemhTlFp4MhOV6Ipx+XED9E0CG53VOuk5HJh0c03Y8+WLfj45z+fgNmlPxFdMm4gMsMydLg8/ok/yGHGmZON8Hi9KJ4ylcn40VRbCIIAwe2G6HbDlTt0zyDBYMTJSDQVZlen7WR0uyNORtHrgej1QnC5UurB9+DePTANA4tvSUwAenjTHI6zUEq55jZjrCjLcTnxEZafiLYcd2ltLf7+9NNoPHYMF116KePZZQZ8jWBLqlW0ZIdDsbEBi268icnY4fLmeMpxBUGAoCh2Rk3+sMi0aUacjFZ/P8y2NtBg0I5Mh7R1wo7GCaNXjLCCQby0ayduu+tDzPdFDB0QJQhcV4oZXKOSLZRSu7NnlA+pvOQ5dqItXwmzpKYGz/7udzh5/DhmXHwxw5llBrYumQUpigxQTnwQQ4OUV5TsaWQ1TQ0NqJgxk5mRbqkqXDnxaU6LLhfEnFy4cnIjr1HLsu3FSLPAHhBdhyBJI4PSXq8dcEnSw8febdswrapq0tqU0WBnz/HfESuIoQMAr2hhCNHVqO0Zbi/GDg0GI8k70TBv0SL4/H7s2byZOxSjhOga3IHCZE8jY7FSqNwZyAKHYk9XF/q6u5no4QB2tFlwuRxz7I0sf8kDDdl+xDRBwkajqsLsHIpMDzcYRY8Hopu94+31AwfQ19OTmHJnTeWROsZYmgYXj+gzgwZtZ8xExgu/xuMnVofigqVL4fH5sGfzZu5QjAI7A1TmumSMoISABA1I/CE9qZw52cjMXgRCGYrFJY6NJ0gSXH4/4LczW6kQupY0DZYa0vHu6xtqFnh+UFphn+FACMELO7aj9vb3Mt0PEGoEYJo8k5oh4cwjbq+wg2ga3AUTO2P4OYgPomn22hdlVZasKLj2ppvw/LPP4q5PfpLx7NKfcBazh6/DzLAMDW4v24a4sZDxDsUzJxsBsNTDsaNIrBd1MVT+gtxhkelgMJTJaDsaze5uUMOwRVDPF/J2ODK9d/s2FJaU4NK5cx0bcyx49hx7LF2FUsAj+qwgmgZBllNOtiCTIJoGedj6OBGKx4NrbrgBu7dswQfuvZfhzDID3pCFLZahQRAlCFzAPKk0NTag5l9uZzI2MU3QYHBiLd1JIogiJJ8Pkm8oSBiupiGqCqJpMDs6oEeaBQ51lpY83hEaj07w5quvorujI0F62yoElzstdCXTFW6Ts4VSCkvToPD7LTNINJrm57GkpgY7/vpXtJw+jbJp0xjNLDOgQRMghGcxM8QyNCj5qaNjm/F33DONjQCAiukzmIxv61wk58YquFx26cyw8hlqWSEHo2aXv7T1RcR9LxDyluW4nIyUUuzbthWLbr4ZYgI094imQubOLmZQywIN8og+S6JqyMKJm1j1cMIsqa3Fg/ffj3PNzZhSXs5odpmBxfUTmWKZGkSZZ/0kE01V0dbayrCiJXmBpRHNAkOE102iqiCqhmB3N3StNdQsUBkRlJ5Ms8B9O7Yhr6AAlyegQ6pd0cKdXSwhugYXb5LIDGqGnDFcXoQZRNNiPr7XLFsGtyxjz5YtWPmxjzGaWWZANK7LzxJK7Od2XvKcQJoaG1A0ZSq8fjZC50RT4SqZwmTseBAkCZLfD5dv6PuGI9NWKDJtdHTYTkZBiHSYDhuMojKx0Xi6vh5nTp7EJx74EuuvE0mbFnk0lBmRiD7PjGGGrYcz8TUccSZwTZyYILqt6STIckzbXXvTTXC53dizdStu//CHWUwtYyCaBncRf4hkBTF0Xu6cZM6cPAkAmMZI58/S1BEOvWQzvFmgELBfs3W8jUjjl2BvH4xz5yKSHRdUv0RhN+zbtg3XLlsGKQFZgzyTmi22Ta5CKWLTtIhjrxPRPIuF4RqKsWNpGlwTNFM9H19ODuYvWcIdilHAA9BssQwdguRKqef21JnJZBBCf6PQ1NiAyotmjvl+7Awt3GGdGjvzaPwF/e4//imuvYnB+CYuGhO8D6DE40aFVwn9ySjzKnALAlo1A82qjjOD9r8tqgFz2A2rc892CC43njjVif/7tf29BCuuaU502DDF48YnZ1fggU3PTvTRqCBxyktKenzbxXtc4t6OxL7Nooo8VAW8+PWOOK7ReE9KnNuJcR6XeM87jXPdCJ4Xv7h/ViX+1tyJN3sHx91ON3sBAD/e/SJ+2dEf9f7inSfE+E5E/PuLb7OJfg/zcnNwfSAfP/zDn0e8TqK4w7mrq/HYr3+NvwWGjMt4f3+iGed6HYxvf4lCBPD1uTOxbvsetOlmzNvHsy4B8R0XMc61WprgnjkWP/z32+Lb8LxLxTI0uP15DtoqnFEZz1482QAgJJHDwGYkqgrJ50U0N8B/f+mpuPZGgvFmhIz/hfMFFyolD6ZJCiokD6ZJHhSIbnRQA01ExRlq/zURDf0Y+uGa57pw6uhRDN46D6sPPhl5PajH+fgxwc3nP3Muwl+1NrxeP/L+KbriW9RdcnzbGYOJayIoyfEtsPH4ofIEF/7Lcynuef0ZmLEacnH+piR34r4fAFhqfNemkh/fzUdxj7zR3UzLUAAZvzu8d9ztPG4TjepZtPRq+M+jj0W9v/bO6KVhhkNJfCeQmvGtSS5ffIYRaR8/MOeCgPWVVfjPF55DtzW0D6pMfJ31TytGx6924iN/fBxSXug4euJ9AE4w8T6vxXHaP+Qtx1lLx+amF2LeVnTF+XuP9/qM+0Evvuv68YUr49vfsGlapt3hOZXsxcxwKI5D08mTuIyRzh/R7VJiIQFNUJyGADirmTirmTjYZRteAoAitwvlXgUVPhlz8n2oKS2AzyWiTTNxRtXRrBp4hRjAnCvtxjGMKfcpaFUNR5yJnNEp8ytoHYjzaZozIS5BQLHHjRY1Tk8HZ0LKFRktRnzXsO+KuejY9DtY/f2Q4uy+mukUK25QAO1xOBM50WEZGjwFqVPtkI2caWxETl4e8goKmIxvaSrchenZ9bKHBtET7McbwSFHnV+QMMPjQoXoQYXgxUKxAFPcCnqoiTNExRmq4WhzK7TSUviuZN/4yg0BU0UZTZbGfF/ZSoXgQRsxYncmcqKmFF6cRPQBZU5slLplaJSMcCZGi/dts4FfAYOvHkbu9dcymF1mUC4qeMXoTfY0MhbLsCVyUomMdihSStHU2IBb3v1uJuNbqpZR3YcpgA4jiA4jiEM9A5HX89wSKrwKyr0yZnpcuOaOlZgyZQo6dBPNqoEzqo6Wfh3Ngwb6gs5Gasp9MpoHubOLJWU5Mt48NTDxBzlxMdXjhm4R9JhpEsVMQ8oUGUcGxs/+HAv/XNuhOHj4MHKvucbhmWUGpR4Z5zT+CMkKYgVBrWDKGYjZRlNjAypnXsTEpqPBIKhpplTJ82QZoBaOUg1HrSHnhwIR5YIHFaIXFYIHt06fg7of3wxDpDhDNZwhKpqoilOiiXPE2WBxuaRgkFropime8p3GVIge7rBlTCm8eBFt0W/Ab8wxUS7LaI4zAC3l5kC55CIMvvI6dyiOgQRgqqig2eJJFKwghgZ3TiDZ0xhBRjsUO9vaoA0OMhTYzg7x517TQq85iCO9g+h5dT9a//Akrlj7dUwvKUaFT0a5V8H8ghwUK270By00DxpoHtQj/3Ya8Rt35T4Fr3XySB0rJAEo8clo4RmKzCj3KmhRoz2+mRGcSDRlsoLtnd1xbSvl5kKZOQODhw5xh+IYlHpktGh8jWAFMXQIkhsi7wKfVM40NqJi5kwmY1uaBsHtTkpDlkSig6CBDqLBGoQ1qKHxk99G6UduxWUrrkeF4EWl6MX1YjHK/B5QAM2WhiaiocnS0WRpaCE6rDg9JJWSB2f4QyxTKkQPTpn8GLNCoSIKoaAFanQbcJMxZsrdCponcQ375s1F1++eARlUIfoy3wcQK1NEBSYIuiivaGGFZejwpFgAOqMdik2NIT0cVgLbqga5OHVadieC/rfegKd8GgyvH8f7VRzvt296ggXIooAyr4xyn4Jyn4ybywKY4pFhEoIW1cCZYU7GNs1ENCoJ5T4Z/2jiD7KsKPHJCBKKLo1H9FlR5pVjcChyYsUnigi4XWjW4z/G/iuuRNff/mZ3puPduC+gzCOjfoBnpbDCMjTekCUFaGpswIKl1zMZO9UasiQC9dVjgGVBnncJmqiGJqrhRdIFACC6CyWijGmSB5WiBwvcebjNMwUKRLQQHWcsDactDWeIhjOWDj0Ki7FCVHCa8HWKJRWiB3tJT7KnkbGUwoteGBgUuE3OinK3jIOD8Seq+K66HF1P/Rnq62/Cfw37zvXpRrmooMXSeeIsI0jQrmhJNZsxwx2KjRBFEWXTpzk+NqXU7iaXJQ+fJBhE53Nb0H/kEIpvfseonzEIxckBHScHhiI/kgBM9Qw5Ga8tyUOZV4YoAC2qgeaBUDajaqB10EBwmIpyQHZBkUS0cmcMM8pyZLT082gzS8q8MvZ39sW2Ee/aFzVlioxO04RG4uz8AVtHsfPPf4b65lvwX/U2B2eXGZR6ZOzp4Ho4rLAM3pk22fT39qK7sxOVM2cwGZ+o2RWsGDj4Ftqf+Afki8rhLglc8D4BcJYYOEsM7MfQ2lIouFEpeVApeTDblYMaqQi5ggvtxEDTMEdjk6VjgI6UEamUPNhhdDL+ZtmLAhElooJmXvLMjFL4os9ODMG7PMdGuVvBM2ZH3Nu7igogz6jA4CtvcIfiKJRLCloIf65khWVoEF1uCGJqVTtkuEOxAVPLKyAz8OISXQMEAUICGpMkG7XpJFr/9BSMjnMoWlaDwkXLot7WokCzaqBZNYDQ+i3AFvkv99mOxisK/VjhK4RHspu/NA/YDka3KKBNHelk5DhLmV/h5c6MKY0lQ5GXr8RMuaKgdRLZiQDgLiqCXF6OgUOHuEPxPBRRQJHiRisveWaGZWhQ8tKzWUem0NTYCIBhRYumwh0IMBk7lbD6B9H+y7+h//lX4X3bxZiy+l9i2r6TmugMmngtOBSEyxUk28ko2o7G69wBlEgyuokZKZU+Y2kokxRe8syQclFBLzXRR7keNCvK4EVrjA5FTvTkiRJ8oogWc3L2jO+quej5xw5Q04Tgia/bb6ZSJnpwJMilylhBUrAhC5DhDkWWejgkwxqyjAYxDbTveBZd+3ZCKa3AjNX3w1NaPulxKYA23USbbuLVzqFmIPmyhAqfgnKfgqpcD6pyvfBIIr4wd1okizGszdjHG1w4QlmOjFfO8oWfFQWhLNuz3BnDjDJFnlS5cxjfFXPRs+s50GAQgpDRt8aYmOqR0WcG0e9wwy2ODaU0JTv2ZRtnTjYCABObkVoWqGFAzPCS5/4X30D7Y38FDQZRcu97kXvDVY7YyH3UwpHgAI5gAKD2eB6IqJCUSDbjfHcu3BBwn39GSJPRLpVusjScI/z+6wTlohdNvKScKaXwYg/ORb9BBj+DsqBcVtAeNGFMMlHFO28uuv/0LNQjx+C75jKHZpcZlEsKthnxZ4ByxseWyEk9ezGjn5qaGhsx77rrmIxtaSrEDG7IMniqAa1/+i2C3Z0ovvmdKFx8I3Mx8R7DQo8xiMPddrfWD188Faf7NZweNOxsRq+CeYU5KPa4MTBa8xc9yDUbYqQsR8HfTvCFnxVlXrs7rhXjhcmv4+gpU2S8NdA96XH8V1yJ7mc3Qz12DP5LZ09+YhlCqUfm2YkMoVYQIASSO7X0cLKNpoYGFBQXw5+T6/jYlqZBcLkgujLT5A729KP9F89gYN/r8C2chZKPvxuuwjym+9RAcMJSccKys7kWuvOwVA7g99o5VIi2o/EGuQDlkgIKoIXYzV/OELvTdAvRwS3G2KgUPTjDHYrMECkwFV60YDDZU8lYyt0ymieZnQgA7rIpcE0tweDB17lDcRheiCgQ3WjhsgjMsAwNSn7q9e/ITOsGgGVZaD55Eu+6804246sa5MICJmMnE2LoaN/2N3S9uBueyumouPNjUEqmJmUu5T4Fz7f2oKFfw/HeoRIAWRRQGmr+UuGTsaw0gFKvjCClaBnmYGweNHBWM0C4zTgqBR4XXKKAc4PcWcAKuyFL9CVYAq95jgkBQJkso8WBDEV3WSlcRUUYPPQ6dygOw3Yo8m59rLB0DaJbgSDysqlk0tTYgIoZM5mMTTK0IQulFH17XkP7L54BAEz59CrkLL4iKZU7lZIHpy0dpywNpywNMO3GISJgN39xy6iUPJjnysO7xCnwQMJZamsyniEamoiKM0SDFlW7wOykQvBgm9We7GlkLEWwO593gJfts2KyHZ7DCIIA37y56H/+RVDrX5gn3KQLZZKCbmJikK+jTLArWvSUa8gCZLBDsa2lBaZpMNHDoZSCaCpEz+TLf1OJwYZjOPunpxHs60FJ7btRcN0NSXvI8btEBGQXmkdxxhiE4tSAjlPnNX+Z4pEjuowLi3NR7lMgCQJaVQMtgzrODBo4Y+ho0QwY3MuIUr+MtkHDzp7jfiwmlHkVnOLdcZlR7HYDANrNyTu8BEGA/4or0Ld/P4pv/1fu4AlR5pFxoIvLIrCCd3hODc40NuKiWbOYjG2pWsZVtAS7e9H5+B+hHjwM/3WXo/hj74IrPydp86mUPNhvXNh9ONz8pc1ScdAaer9AcKNCtHUZL5Z8uNFdhIDoRgcxQpmMtoOxFQPoBe+4KwIoFRWeociQUnhxDmq4qj8qeMVzbJS7ZfxzEh2eh+Obdzl6/7ED+tGT8MyucmTMdKdc9KCZN2RhBgmaACUQU9BmzFiHYlNjAwA2AttEt38sopJ6JzQeLE1D+5a/omf/XnhnVKHyrtWQi0qSOqdyn4J2zYQeZa2oRe2u0S2qgQMd9s1CAFCouCIdpmcHfLjFF4DfJaFdN0PNYnScCf07YGVXRKU8R0FLP89OZEm5V8aL7bw7LivKFBmthuFYLNR3xVz07NwJ/WQjPBdxAxHgJc+sSVU9nGyCUoqmxgZc//Z3MBmfaCrceWxLgBMFpRQDew6i69d/AVwuTL3/TuRce3myp4UKScEfYiiz66ImuiwTr1tDzV/8kGwno+RBhejFAlcAJYKMAQTRTDWcoSrOUBXNVEUHjKwqmJ4iKCCg6KAGbPcix2lKeUMWpkgAprplRzIUAUCeUQkpkI/BA29wh2KIcklBC2+MxQxihCpahNRbgzPYodgIl9uNqeXOZxESTYOYIQ1ZBo6/ibN/fhqWOogp73wvAgsXp0RmTrlPRvPg5BYlCqBDD6JDD+JQl938hbiBXJeECq+tyVjpU3BtUR6KFDe6jSBatCEH4xnVQJeRuZHp0hwZDd082swKOdQdd7Qs2zEJLym8s3lUlCuKIw1ZwigzZkDKzcXAoUPcoQggzyXBy5sKMYUYGtz+zHA2pSvdnR0Y6O9HJYOSZ0oIiK5nREOWYEc3On7xe2iHjsK/eB4KPvguKMVysqeFIsENGSJaJ9l8ZQAWjpIBHCVDzQK9MkG54EW54EWF4MGNQgnKBA+CoGgJORmbQ47Gs9BhZaibsSKUeZSZ3y41KIUXRxFHAJrbi1Ex1S3DpBSdljPPdYIowjfvcgzufwMFH3xXRvgEJkuZqGCP2ZXsaWQsqRyAzmCHYgPKp02HxEAE28oAPRxLHUTbs39G7ysvwVd1Kaa+531wFxRCSJH7UrlPQTMjbb++oIU3+1S82TcUCfSIAsq9CspDjsY5eT5M9cjQLYIWzUBLv4HmAR3NgzraNDMjdBnL/Ar2Nl1YIsRxhjKvjF4ziIFgdmW+JpJyRcaxQeci+oIownfFXAy8/joK3/2erDcQSz0yOgwTJn9gYQKlFJapp6yBmC00NTQCACovmun42ETTIEgShDRuyEIpRf/Ol9D1279B9Cgo+ey/wXdVWGc2+fqqlZIHrYSNM88ExUk6iJN0qFGGCGAqPBEn4wKxAO8WyuGGgHPQcYaqOCUbkU7TegboiVXwhizMKYMXz6E1xq2y20aJBaf0E4fjnTcXfTv2wmg4A6Wq0tGx05FySUGzxjMUWWEZGiQlNe3F9LVwhiEQ+284ZxobUTFj5gWvh4lFo+L8DYmqwZ0fAEj0g0hGfDsU47TVxHF8cf0njqDlmadATAOl73wfAm+71n5w1gHBim9/NM6kRjqGjm25T8aB9r7R3wTivodKYxwXExQnNQ0nu4YMJkkApoaav5R7ZFxTkocyvwxRAM4OmmgZ0NEyYDsaWwdG12Uc6/qbcJ7x2uhR7s/rEhHwuHC224AYRPw2SZz2e7zHhbgTu50Up/3s7gcqcxW09hlwxyDXEgz9jkQTkGK4J1txJonQOE+8IMZ54uNcX8Zaa8sUGbs6e8Z8f7x1cCxyZl2Jvr37oJ9rhlJZEdO2NMHrJ2tKfTJaNCMyv3jvD/GuL/H+buMizjlO5txZoW6TgixHb5NE8zn+jDkmo9qLIYdiReUMx21Ga9DWTxSoGNP90iXH92OzpDjX5jG+YLCjG+d++jtob9Qj96YFKPzgOyD5vQgv5pYZZzOCeG0H6cITVOmWcYaoo74X2S7O32lwjO93GiZOwwSGZZQVCW6Uix5Uil7Mcvtxi2LrMrYRPdRdeuivl46RJZXA3y6N4RmmQvDiYLAHlAgQ4rzGhDgzFmic9qLoim9Db1F8XZaDVnwXWdAS4YeEPFFGE9ERjLKkXPZaEAQKUaCQXdGvF/Hab/Gev3jd6ZYe59oyxvVZpshoDuqgY12/RuznzzOjGmKOF/qrh5B7eWwNTE09PhdMLL/b4cR73kVXdNsVCG64IaJd0iBJFMSKb55xf7841yVqxve7jTfOPimb0dDhzsmPzR6Z6LMO3XMywqE4Gk2NDVhyS43j41JKYWkqlKlljo+dCLRzzTi98efwz7wYZe+8A+68QLKndAGRUtEkdx+2KEIdow0IIQefAKDQ40a5X0aZX8asAh9urgzA55bQoZkRB2Nzv90IZlBPzch0aa6MLtWExrPnmFHml9E6EO81zDPCJsIjCih0u9HqYMkzAHirqiF6PBg8dChmh2KmUcb1E5kypIfDPYDJpKmxAVPKy6F4nI/8E02FlKYNWWjQQut3fw2rpx+lD3wUvisvTvaURqVC9OBNK/mNozqoiQ7LxCGrL3ILz4GEipAmY4XowdWuAIoFGQOw0GSpI5yM7TR1dRkrJAV/MXiGIivK4EUHzYxs1lSl3CXjkDYw8QdjQJAk+BdchoGXjqD4A8sdHTvdKBMUnKOZK/uQbCilIIYOMUUrWjLSoWgaBlrPnGGjh2MaAKUQUzTldDyoZaHlr7+FXFiMypUfh5iiJThlPhn9poX+YLzpMOygADo0Ex2aiUMdQzemXLeEMr+Mcr+CyhwFV0/JQ5HXjV49aDsZ++1sxpYBHZ1a8nUZy3IUtPRxRwFLSv0y9jXHVlLOHQvRU6Yo6DGDjjdTElwueOdejoHXDqHgHW93dOx0o0yR8XqvswY4Z4hULl/JJs6cbGRiLwK2RI5cPIXJ2Kzp/vNzME62ovxrdfBUp245X6XowVajPdnTGJV+WHjLGsBb1tA6KkNEuahEnIw3u4tRJiqwQNFMdDSRIUdjSwo8oAcEFzyQ0Mq7tzKjDF608IYsTKlwK/hHX6fj4+ZcOwd9u/4J40wb5IrkNjRNJuWiBy18jWAGMXVAAER38nWLRyM1PUqTpKWpCcSymHR4tjQVopKeDVna922DdrYZM//t0ynrTASAci87/URW9JkW+rpVHO0eMggUSUCZV7GzGXMUXFbowxSfjCChQ+XS/Xa59LlBA1E2tHaE0lwZZ3mHZ2YIAKZOKkORMxHliuxoQ5bh+K+Yi4H9B2C2tcNdUsxkH6mOCGCKwjMUWWLpGlweX7KnkfU0NTZg7oKFjo9rN2TR0jJDUT/Ziq7f70DgPdentDMxV5CQL7rRnEYPsgYIGomKRjJkL4oApgpKKJvRgwWuAN4jeqBAxFlql0wPdzRqCcxkqxA9OEd0mDzziBllghctNHaHYho+iiaFXFFCnuRCS9D5dcJ3ZTUERUb/S0dQeHv2OhTLBA+aKc9iZoWl2w1ZUtX/lLpepUlw5mQjAKBy5kzHxyZaehqH2tkzaN+9GUWLboa3fHqypzMuFX5l0h2eUwHdojjZq+Fk70hdxik+u1y6LEfBgqm5KPMrcIkCzg0adhZjv46zPQZa+3XojLyMpTkyDp/jmUesKPK6IQhA+2CcYpjcbp+QMkVGCyOHonfWZRDcLgwcOoTAzTcx2UeqU6y4QUDRkcGd7pMNMXSIeYXJnkZWQwjBmVMnseK9K50fW9cBUYLgTqQY6OShQQttP90Ed3kxCt57c7KnMy6VohfnSPqXihIALVRHi6VjvzVU2VAguFEp2k7Gi0U/bnQVoUCU0UGMiHOxOdRtunssXcZJwhuysKcMXryOOJsk8qZpE1LmktEeNKAzOFai4ob/qovR/+IRFN5+g+PjpwtlooIDZneyp5GxpHK5M5ChDsWmxgZ4vF4UTYlNIDUaLE2FKzfP8XFZQq0gmv/6WyhFU1C8tDbZ05mQcp+MN7vjE0VOdSyKUOmzAZyzNX8EAAHFhfIcBWV+GRcXeHF9RQD5Hhc6VRMtfTpa++1O0y19OvqMyZWCu0QBJX4ZLTxDkRmlfhnnBsw0f8RJbco9Mp7vYtOlXFQUeC+7DIOvZa9DMayfyB9V2EAJATF1SLKS7KlkNe1nW6FrGqYxqmiRPKmbUTAW3X/cCeP0WVR8/RMQ3Kn9mFAhenDGylxnVxc10RXWZQzhg4SKkJOxQvTgKjEPUwQFGqyRTkai4RydvKu1QvKg0eLluKyQIGAKPLzkmSF2h2d2zzz+a2fj7A9/B7O9B+7ifGb7SVUkCCgRFLTQ9E8GSlUsI7UrWlLbUoiTpsYGlE+fAVF0tnVmpCFLifOOSpa079kK/VwLZn70vpQudQZCGXweOSMyFKOFAujSg+jSg3gjpMsomYDfLaI0R0FZrozSHAVXTs1Bkc8N1SRo7dcjDsbWfgMdqolRmkyPSonfDcMi6EkBLcdMpcwvo2Uge67hRCMAKFXsDsSs8F15Jdqf/A2CPT1w5WefgVimyI43vOEMQUwdEEUIrvTKXss0mhobAAAVDDQUiaZCTLOKFr2xGV1/3InAbTdAqUr9plSVkgens8zZNQgLx8gAjhHbXhQEwA0BpcKQLuMSqRBlggci7MzH5lDJdDPV0Ex0GDG4GStED/aYXYy+DWcKPDBB0IU47rdpFqxIFhVuBc0Myp3D+OdfCkgSBl4+gsA7rmO2n1RlqqDAAEEXjbMqizMhxNAg5qduRUtqe5fipOlkIxP9RBo0ActKq4YsWmsT2vduRfHiW+AtTV0dnDBTPTJMQtDJy+wwYBKc6FJxomvIWHaLAqbmyCjNsUumr6vMx9QcW6D13ICBlr6Qk7HPwNl+A+YoXsayHAWtPDuRKaU5Co51TSbLlueFjUeh2wUJAs4Z7IwX3+VzAFHE4KE3kLd0MbP9pCqlHhnHB7LrQT2RpLoeTrbQdPIkRElCWaXz9pGlqZAL00eDlQaDaPvp7yBXTEHBe9MjM7tC9OAF7uyCCYrTVMNpSwNCRSwCgGJBtjMZBQ/mSrlYIU6BHxLaqYEzloamYV2m++iF1S9eiCgW5YzOAk02ZZPMTuQVzxNT7pZxSGPXCV7ye+GbexH6X8xOh2KZqPCmTQyxK1oMSLzkObE0NTag9rbbHR/XUkMNWRzOfGSFXer8GyjFU1G8tCbZ04mKcr+CFpU7u8bCJBRNvTqaenUAdgmMAKDI50ZZjoxSv4I5JX7cXFUIn1tEx6CJlj5bj7G1zy6bLs2VeYdnxpT6ZTx/ujv2DblzISrKFRlnjVhyLGJH8vvgubgaA4cOZaVDscwjY3cHm5JyTqjDcwobh9lCU0MDyiunweWwziGlNO0asnT9YSeMM+dQ8fV7IKR4NQsAeCCiRJTRxPX9RoUCaKMG2iwD/0Rv5PVcuFAhelAODypFD651B1AsyOijQTQTPeJgPGNpyBVc6CYmBjA5qR3O2JQLvMMzS0QApS4ZLQxLngEg59rZOPfoM7D6BiHlpm5pKgvKBA9aeEMWZliGBkGUIEipe19O3ZnFiaaqaGtt5eUrANp3b4HefhYXffSzKX0RDqfcJ6ddh+dkQ2E3/2gfNHGIDDVayZEllOXamYzluQrml+eiONRlun3AwPLqAtvZ2GegU+P9+5zC6xKRr7h4h2eGlHsUZh2eh+O/Yi46/vAnWIODkHzZYyAqooBC2c20pDzbIYYOly8n2dPIeppONqKCRQM/XQMEAYIsOz42C/SGM+j+4y4Ebr8RykXlyZ5OVFSIHnQTE/2jZNZxxqYPQbxJ+nHYGrIXZQgoD+sySh7c6C5CmaJABGCAYqVSijOW7Whs4R2fHaUMXvyT8ixbVkx1ybAo0G6xLcf1L5wFPPJXDOx/C3k3zWO6r1SjTFTwxjCdV46zhBuypHJFS3p4mWLgzKmTAMCk5NnSNLhy0uMBQG05jfa921C8tAaeqamvgxOm3KfgpbbeiT/ImZB+w8KxDhXHOoYin4ok4PNLZ+BoxyB8bglLZ+Rjil8GocDZgSFNxpY+A+cGDASjFWbkRCjNkdGlmdCsSeTP8cM+LmWKjAaVfTTUd8UV6PjdHzD4xmHkXr2Q+f5ShVJFRp8ZxMBkrmHOuFiGBqUgfcphM5WmxgZcu+xGx8clmgZJSe0HgDDUDJU6T5uKgn9ZluzpRE2l5OHZiQ5hgKKRqGgkKhBSHBIBfESpAAQBBiW4ypWHW6Up8EHCOWqgydJGZDPyLMb4KIUXLWiexAjcYByPcreClqDO/Ci5CnLhuXQa+l88nHUOxXLRg63B9mRPI2OxDA2SktoN/DLPodjYCACoZBFx1lRIxSWOj+s0JBhEy19/A2VKGYoXL0/2dKJGAFDmlXEmixqyJBqfLEESBeyo74IVuruKAlDkd6Ms1ABm7hQ/llcVwusW0T5goqXfdjLaJdM6Bk3uZBiPshxlEh20U//hMxUoU2Ts7WIfeHAF8qHMmI7BQ69nlUOxzCOjhTdkYQYlFmjQhMhLnpOKFQyipek0KhlUtFhpVNHS9fsdMJrbUPHNe9Oi1DlMhejBGe5QZAYBUCDK2GK047Vh2Uf5givSYXqm5MVidwFKRBndxBzhYDxDdHRQg7u7xiEfbnghoRX8OmZFuUvGGcblzmFyrp2Njt9sA1F1iN7UdgA5hQ8S8gU3WvlazAxiaHD585I9jXFJH8shSpoaG5CTl4f8Amc74RDTBLWCaWEgduzaDL2jDRd97LMQJCnZ04maIsUNUQDaVN4lihVluQrO9RsRZyIAEAq0DZhoGzDx2tmh1/MUKdJlujJPwdUVeSj0utGrByPOxdZQE5guNciNxhClOTIvd2aIIgoolt1o1hMTePBdcQW6n90MYhgQ06R8cbKUedh20M52LF2DILkgpokUSabSeqYJVjDIpKKFaCrcgdTtyBhGP3EG3X96HgX/ehOUGWXJnk5MVIoeHDJ4mR0rJABlozhte2gQPVY/Dlv9QMhcVyCiXFRQIdmOxuVyMUpFBQSIOBibqYYzREUrL5mOUA4P2qCDW9DsKHcreEMbmPiDDpBzzWy0P/EsBv55HLmLLk/IPpNNmaigixhQmaqaZzeWrkEpmJLsaYxLxlmzTScbUTFjpuNlJkRTIcpKyjdkUc+cQufu7Si5fgU8U9JDBydMuU9Gq8q20UK2U5YjR93huVe30KsP4mjHULdiRQp3mbYdjUtnBDDF77ZLpvuHOxmzt2S6NEfGkc7EGC/ZSKksoy8YRH+CynH9V16Brr8+A/XNt+C/8oqE7DPZlHpkvNzFH9RZQQydN2RJAZpONgKA45rblFJYmgolxQPQ1Azi3E9/B3lGKQLvSZ9SZwBwQcBUUeEZigyZKioIgqCTThzk10HQQFQ0kCGJHRHAFFGJZDPOc+XhXeIUeCHhHB1q/tIccjj2Z2HJdNlkG7KkgaRCsil3K9ja35mQfbmnFkKeMRUDLx3JHoei4EEL5ZWFrCBWENQKprzNmHkOxcYGTGOinxgqX4l37Y7XrxLDMzMJmmj942+glJaj+OqbIQRj350Y5/2cxJsIOcw/W+FT0DxgQIjiWNE4z0O82yHBiZ4kTr/1RJuV5so43qle8EEhyvNuEIrTXTpOd9k3D4HYJdPFfjdKcxWU5sq4YoofNdWF8LhFdAyYaO0z0Nqnh/41MGBYCMa5LtI4j0s8vwUAsGJMSJMEoMQno1k3QOJoGiqG7HbBopH/jgYr0ZUVcf+Q4mTY7so89vGNZi0W4vQ5UnFoEXKVFsNdNhUDhw7Bd9Xc6Cca0/7i2oxZhXypR0azaYCet+7FfTzjnUgc3y/e30K897Dzj1E0BE0NoqJMvGCPusM4tuGMSlNjA9yyjCllzmbmEcO+P4qKEv9vNM7tRDH6C6Tjd9thtnRg2rpPgMIFGsd9kib6XhD6emWiAg0EnSS6G6VlxLfIur3xGQ80zt9pPMeTkngN4vHfrhA8OGPpF36XKHdHALQSHa1ExwH0QJTsgQKCC+WCB+WiBzMkLxa7ClAsKuihpu1cJBrOUNvR2E4NBPX4FmeXEt8DjToQXyVCTm7szu1KoqAZg3CJsd9cSehaoWTov6NB8cRXBaarcRi1AIRoHupGgcbpLKXy0LH0CxICkgtnBG3E66Mh6PGtEeS835//6jnoeWYvLMMaX0Ii3nt5nNuJ7jg3nOD8lYmK3eH5vM8J8dq1CbZxBCne5IT4vmCsNqOl6xBcbgjueI3U+DaLlYxzKJ452YgFi5c6Pi7RtJTv8tmx61kYHe2Yufr+tCp1DlPuk/F6F8/sYklpjoLdp3ocHZNQ4Fy/iXP9Jl5rGXo9T5FQmqegNEdGeZ6C+RV5KPK70acH0TIQymYcMNDSb6BDzYwCmBKvDItSdOlxejA5E1KuJF7fz3flFeh7bg+oZaXl2hoL+S4JHlHEWZ1LT7CC6BrkvECyp5H1NDWeRMWMGRAdrjwhmgoxxRuyaMeb0PWn51F4x81QppcimGYJJhWSB2csnp3Ikor/z95/x0lylff++PtU7jA5dfWsco4oS0hCQiQRZLKJzubaxthgG19sbGyCudgXc53Ahuvw/dkX2wRHTLCQQASJKATKWdpd7e50T87dlc/vj+4JK22YqemaTvV+veY10mx1ndPV1VVPfc7zPB/V4lC0g+y5o7AgAxbkCg9GK+t/q5VMW4zXhcYb1GFsUSuZntDdWk/GsPa7FLp0SmfGAlnuYney57qRomYwG/pU5e7VvuWuOJf5f/0a1fv3kr3ojF0bt1nYisUdwWyzp9GxRG59AbrF6ShBcWVpifnZ2UQMWUKnij441PD9Norqwf3MfftrDN/wEsxRm3bs72tnTW49NN/saXQsWV2hz9Ior+zOk8OSG7I0XeHR6Y2SaUMVjPUYjA7UhMZrxvsYyxlIai7T5brQWFrxmFz18NqsZLqQMyitdkqo25oUTZPvLO6uE3z2wvNZ/PJXqD7yGNlzz97VsXcb2zSY8XyCuCk2KcdESknkOakhSwtwcN/eRPonho6DmmndcufI85n8y3/HPMVm4BXPafZ0YrFHSR2ek2ZcsfiB39gF6KNRK5musJcKa5XPCjAiTOwwy7hq8iy9h5daw+SEynTkrQuMa7+XZHuVTOtSYRCT8o5Knhs3n06kqJpM7PJqiXHiGNrYACvfvb/jBUUBFEQ9QzElEULPaflyZ+gwQXGtH06jHfuiIEAGPmqL9sOJAp/yf30Ky97D4NU3NHs6segzVLKaQrmaGgEkhZ03mav6uGHzhAIvlBxYcNnrbNzgFWAoo2PXezOeO5zjeScNkNVV5qo+pVWP8opHadWlVPFY8lo3aLRzBuXVBgQvqZZzRAQ1wWtilzMUjT3jGHvGWbz5VjLnnNXSmUc7JXV4ThYZBsgwRG2DFedO5+C+vdzw0pc1fL+RU0Xr62/4fhvF3Gdvw5+c44T//da2zbjeo1rc7qWZXUkyrlp8zp08/oYJEQGT0mXCD7hrU8J8r9AYV03GVZM9qsUVRh8jisGqDA8TGadYZhq3Zfuyj5GhSsAyaTVAUoxrFhPh7gqKQgh6n3cZc5+9jYFXXY8+1vrmXHEZEDo6ClMyjRmTInId9L7WP4c6SlA8tG8fAOMNXnGOnCpCN1o28Jr52s3487Oc9AvvRCitOcfjUcyaTDs+fptlpLUThbxBabn1LvoRNWfv6arPvdMbJe95XcXOGzWhMWdy0VieoYxONYhq4uKKVxMbV12mqz6tcOrYWYP7ZndQtt/BQlUjGNA1dEUw5e3ueSyEYOAVL2PyL/+ayn0PkLvweL0U25eCaVBOBcXEiFy3Fk+06b26U/Bcl6nSRMMzFNcNWUZb0zHZefQAC5//FkNvfAHmCWPNnk4sBLUyuzRDMTkGhY6JQilqvVr4JRmwFAQ8FGzEWgYCuy4wjqsmzzEHGFcLCKBMzWF6QlYpySolHJwWkBkLZGrZiWnYlxhF1eQhb/dbafW95CoWb/4uc5/5KmNv//FdH3+3sIXFlHQJ0yyIRJBSEroOlplmKO4qB/btZWBoiHxPT0P3GzrVls1OrB7Yx/x3vs7w81+KOVJo9nRiU8waTFRaL3DpJAp5Y9fKnRvBih/y2HyVx+Y3ykE0TTCWNbBzBoWcwZV2L4WcgSoEUxVvvTdjqV4+7eySE/Aads7klqfSsv2ksE2DKc+nGUm2mbPOxDrrTBY+/yWy553TsgtMO8U2De5dSnvZJkXoOml2Ygtw6Kn9SCkb7/DsexBJFKv1PuPI85n8q3/HPG2c/h+7ptnTic2oYiCA6Shd+EiKcdViMmofocBDsj902L+pr6aZ9xjGxBYWRZHhbNHD85RR+oTOrHQ3REYcDskqC7ucKViQmZ2VO6ccEwUoaAaHdjlDEUAxDQZ//HlM//Xn6L/pGsxTi7s+h92g5vCcLuwkhQwCiCIUo/XiiafTUYLiof37EumHEzkOitV66nDke5T+61NY4ycw+OznNns6O8LOmuxbTi9KSWL3mNw31d5CgR9JDq64HNwkjApg0NIo5EzsnMHpAxmuHe+n39KYd/xaX8ZVbz2rccENEgmRe3SVjKYwWWnEQ057BPG7TdE0mHCbJ4oPvPxllP74T1n53p30XH1V0+aRFAowmmYoJkraP7E1OFRvkXNCg2PG0HFQLBMR2+IyOeY+81WC6YW2LnWGWm+/iagVcsw6l/EOyACVwDQu09LlXrnRCzKHSlFksKkJjReKPkaxcAlr4qLhciiquUyXI5dkIsaaIcudYnqHexHxLcU7nGG15tY9HTYnnul57sUsfOFbzH7qFoq/+zNNmUPS2Eoyxk0pNSLPQdENhKK0/GNhRwmKB/ft5dSzGt8wP3Sq6P0DDd/vTpn71m0EC/OM/+LPtX35VDFr8O3J3Wn+3I3oimA4q7dVhuJWkcCsEzDrBDywqdw4oyn1TMaa0HjOYJaRrEEQScr1UulSXWycrHgEO6yZtnMGs9V62X7rPUt2BLZpcMBp3jlsnjBO7tKLWfjSLeQuvbgtnNe2w6ipE0rJnJ+6lCdF6DqYA8PNnkbXc3DfXrK5PAPDjf0sohataHGfKrPwhW8z9KYXYuwZbfZ0dsQeNcPB1OE5UcYVi8fD9l6APhqrhDwmV3iMlfWHdBVBAQtbWBTIcrnWz7hiYaAwJTcExkNh7fcKO+vlLeSmkueURBhXTUqB2zQdRqgqQ296IeWPfIrKvY+TvfD0Js0kOWxh8gOZVmUlReg6KG1Q7gwdJChKKTm4fx/PedGLG7vfMET6HkqLBYhhZZX5736D/suvxRxuzz44a2RVhQFTZ6IhmV0pR2I0Z1D1I5bc1jU0aTTVIOLJRYcnFzcePFQBI9laubSdM7hwJM+NJxtYmsJM3QCmtOLWBUePpXDrx8vOmZTSczhRiqbB9xaWmzqH/ptezKEPfpilb9xB/4ue39S5NJq1/oktvhDatkgpiVy3bQLETubg/n2Mn3RSww2WQqeK1tPb0H02grnP3IY22k//y65u9lR2zB7F4odBugCdJOOqyTf82WZPY9cIkRyiyiFZJfCW1v8+IHTGFYuiYnGSkuVqbZBhxWAx8tdFxonI4VDkUJUOcouXk34MVAQzpMJ4UhQ1c9cNWZ5O9rJzsM48kdl/uoXM+afWMs06BA3BiDBbss9qpxClguLuszA3y+rycsNLnkOnitB0FK21DtXct29DAoPXPK/ZU9kxds5kzvV3vd9dN9Fu/ROTIpSsi4V3b/p7r6Fi5wzsnMl43uTSsR6GMjoVP6RU8dZ7MpYqRzeAsXMGpdXGCIppBcszMYRgSNd33eH56ehDQ/RcezWLX/kaPVdfhZrPNXU+jcQ2DUpOKoonhfR9kBGKYTR7Kl3Pwb2Nb5EjpaxlKI601iKv8/hBVu98iNFfeQ1Ca+9qFqj19/t8E92HO50sCoOKwUSaBcq89JkPfe4PNxYyTRSKdZFxXLG4Xh/CViyQMCWrlKlQFlVKVJikiiue+Wxjk2Uah1BItqxCHglBy5dCNouiavKI39wsWyEEg29+ERPv/VtWvnM/Pddc2NT5NJIxYeIR7Xrv0W4idF3MfOstUB6J1lLJdsBaP5w9DW6w3YrlK8HKEvPfv4PBZz8XLZdv9nR2TM2QJX2ITRK7x6C8kh7jo7HkhSx5VR7ZZABjKILRvLEuNF5Z2DCAmax4lCu1vow1odGjkDX40fTOsucanS3TSRRMg2oYsbyNrNGk6H/R81n57vdZvOUrDL76Fc2eTsOwTYNHV9MSrKQIPQfFqPfXSx8Cm8qh/ft41hVXNHSfMvCRYdhyGQVzn/kq+vgwPde2/8PsgNCxWtR9uFMoqhZzkUcl7VJ5RFwi9kYV9kaV9b8pwEn5WhlzQWY4U/ZxHQV6MZiTbk1kpEpZVChRpSAzlKgcfZCUHTOumXzdmWv2NMicfRLZy85m7tNfIX/FuQi9M6SX1JAlWaSU9Z7b7dFaqTPOauDA3n0AjJ90UkP3G7agIcvsHV9FaBoDbW7EskYxazKxmgaHSVLIm3z/0NLxN0xZx4skB1ZcDqy4QE0oXDOAsXMmhazBaX0Zri32029qSCm5xu7jxLxFqVrLZpxzkmrn3X3YptH07MQ11J48fS+4gYWbb6Xn+mvRh4aaPaWGYFsG35hLSwmTop3KVzqZysoKs9NTiVS0KKbVUmVt1Yf2UbnncQq//vqWmldc9tTdh9M7a3KMK1ZTnHHbmQiYFg7TONwnNnrK5aRWExnJUpAZzpX9jFBLUlnE42XRCZSoUqbKJFUCkZ7XjSAjFAZVnUNBa5zHQ298IQd+82MsfuVO+l/y7GZPpyHYikWpzY2bWpnIrz3vpILiLnNw315GbRuzweJf5FTRe/saus+d4C/Os3jXtxm67kUtlzkZl2LW4O7Z5vZF62QEtZLn0nJr3Fjbmc0GMPdvMoA5tc/iJ84a4+H5CnbO5MzBLGMZg1BKJitevWzapVSpGcB4OzSA6UaKLSQoAvQ+9zks3/4tFr74ZUZ+6k3Nns6OsRTBgK5TaqFj3GmEroOaCopN52BiFS2ttQAtpWT201/FOKlA7spzmz2dhtAJ7sOtzrhqcSg9xg1hVQQ8wTJPsFwLxgFVCn5Dns/9zKGh8CwGuZEMFiozm7IZ14TGZfz11z6dtKrlyNiqyULoU5GtkWVr7Bml57mXMP9vX6f3+otRsq1zn4iLLUzuj9Jn96SI3LWKlvb4jneMoHhofwL9cKKQyHNbypBl9vZbUUyLgSue0+ypNARdEQxbqSFLkgxmdAQwW037XCTFoKlzaMXj26V6FqgCioARS6eQrblMnzeY4wV7BsjqKnNOQLlSExhLlVp/xgVvs7NuKjg+Hds0uHOxdYIXxTTpf8mLmP3sv9P7vOsx94w3e0o7omAaLPoBlbSXbWJEroPe29/saXQ9ay1yxhssKIZOtaXa0FTvexLnoX3Y73pzR2QnQi1D8dGgM92HW4VxxeK+oHXutZ2GjkIvBneISaoiREoBEnrRsevZjDZZLmaIIUwqBJRlTVxcExo3m7mk0eIzGdfMlsuyHfzxG1i54x4WPn8Hg69/QbOns2NsxeKWYLrZ0+hYItdBNdpHeO4IQVEqcGD/Xs6/5FJkA/tNh46D0DQUU9/44y4/a23u5evNzbB49/cZfd5NqLp1zLnEzZqP2xs47nG3swarQciyv82+aHHfX8wzXsRs2xZ3vLimHOERXjfWbzBZ8fCPMZddf9bY5QgojLsmsMV5FnoNJhyXqO61IEIIgbLjU3Z87t7UxiWvq9hZY/3ngqE8IxkdL4worTo8+Ja3sNBXYCFjMFnxCbZwMhyh5/fWiPu57/LnJ5V4Jc9xr2f68tYOzMB5V7E09E0W/+NLjP/ML8YbjNr7i0OkNe6DKGQNSp53nH3GO6Bxz8+d9KrfLnEXgbf62UkZ1RcoTeQOWihu5d7eyDio01iLF3sHBugZ6m/opSxyqijDI4dfV2Oe+2EQ76Kg6bVgRUrJ3Ge+gnXGHvJXnIE4zpcwtuAY8wAqarwX7lEtvh7OoGzz2hf68b7guWw8UWJlNV6Zmqpu/4QJophf+CMcEhVBQTFrGYpHy4pTdjcAsHrifQbVhXgP40OFeO2B1C3e6E6IMiwFLpHuYgJR/UA7BOylyl42AkZdKozKDGMyy5jMcoUcYkxm0RDMOFUe/zGNA7OTyKCPSaVCVQRHGXUDz4v3YCJifmejMN61RQYxb8pik8PzdnYRM56Kylt7wFDI0Hv9dSx84XbyF12POhDvwUQdbr5QmkOlT+iUj9FDUYlxLdsJMmbAGD/2iycMbDVmDD0XxbLWt08qZmxUvNgRgmIkIyb27+fFr3ltY/dbrbZUduLM7begZfP0X3p1s6fSMIpZk1KanZgojXQfTjkydsbgzpmtreiv+CGPLVZ5bHHD/EITgtGMTsFUsKTkitNPZM/IEJaqMO346w7TaxmN2xbg25x+TcVSFCa91sqyFarK8IteRumf/57KE4+SPe3MZk8pNrZRExRTkiHyPBAKQk8dnptNraLl5IbuM/J9ZBCgtkjJ8+oPHsV57CDjv/9TbVMydTxyqPQLPS3HTZCCUnNunZOtda/tJEZllkmxNUMWX0QcEqscYlNWroR+TMaxUBbmOGP8ZE4NTmVAWizjMaVUmBKrTCkVJkWFOVHd1cW5VmBcNfmGM3/8DXeZvuffwPK3v8PCzbcw9MbGaha7ia1YzEkPJzVuSozIddD7+ps9jS3TEYLi7NQUruMkUL7itExw6E6XWbrvLsZe/GqUDnogqTk8N3+1pZOxcyYPz6duckkhADtjUqrMxt5HICUTFY+DCy6P/N3fUZx26DvvUvoMFTtbM4Ap5kwuHelhyNKpBNFhJdOH8Jh0vSNmqHYCtmky5W0tW3O3yZ17AdYJJzFz8xc44a2/1ralhbZp8N3F1LgpKSLHQTHbpx9OJ3Nw7z72nNrYFjmRU631O1Kbnx4qo4jZT99G5ryTyV54arOn0zDGFYuZyMVNH2ITY4+S9k9MmsI2BMUjImABl1WlyiO334LQFc78/ddgSpURmWUsyjIqs1we2IzIDCCYEZW60FjhURExIR2qHfo9EoDdgiXPAGo2Q/8Ln8/c579E7/OuQx8bbfaUYmELMzVkSRAZrVW0tIYGtRU6QlAsPfUUAHtOaXCAWK2ijbbGl33mm19G6+un76Irmz2VhlLMmnyjtNDsaXQ0dt7gawdab6WuUxgwNHRFMOU0ILvraWLDohey6FV4eGEj+NQVQSFjUMga2DmDK0Z7KWSN2hxcjwnHo1T/mXA8VsL2z2YsmkbLmoUIIRi+8SYO/u1fsnL/PfRceHGzpxSLNEMxWaLUkKVlOLh/H89+3vMaus/QcVAyrfH5rnz3Idx9ZU744M91lIC9R8lw8Bgldik7Z1wxORimxzhJRmWWJ9RSw/fripCDYpmDyka1jJAwIC1GZZbRKMcpUR+XGXkGhM6c9ChFDhPSYaL+e0Z6bd+TcVjRUYGpsDXjmZ7nXMPiN+9g/gv/zejP/3SzpxMLW1iUZOsJtp1C5LmgKAhNP/7GLUJHCIqH9u1HUVXsPXsatk8ZRbUHgBYoeXbKh1h+6B4KN70eReuIjwyomVaMZdIMxSTJ6yo5XaWclpUnhp01mHJ2LzvQjyQHVl0OrLpQ74cc5qFf1yhaBkXL4KSsxVUDvQybOst+QGmT0DjhuEy5flutTdstLCgCZE45jdxZ5zJ765fIn3sBos2u0/2ahtGCJeWdROS6qNlcs6fR9SwtLLC8sJDIArSazTZ0n3GQYS07MXvx6WTOOanZ02ko4yLNnkuacdXiu/5Cs6fRsQi5vZLnnSIFzAmHORweVmu9GacX8mRRsRWLoqj9nK31UBAmEVCuC4wl6XCo/rudSluLmkkp9Fp2xoquM/DSFzPzT5/G2bsf65T2u07bisU3g/hVWSnHJnIdFNNqqwXB9nrqOQoTB57C3rMHTW+ckhs5DqgqooH7jMvMN25GHxyh78LLmj2VhjKaMQikZM49fhPhlHgUcgZzjo/XqbWwLYCdRB/QbX5cEpj3A+b9gAeWNwJVUxEUTAPbMihaJs8e7MU2DVRRz2as/5QcjwnXZbVFHX5t0+CupdZ2nRy68WU89dGPsHjnd+h/9nOaPZ1tYRsGM35rlpR3CqHroA8MNnsaXc9EvaIlCYdnfXCoofuMw/Lt9+EdmqHw9lc3eyoNZ1yxuDMVuxJDUDvGqWibHEMyQ4RkngYdY0Est4YKIU9EqzyxqTejAowIsyYyKhbnKD08XxuhT+jMRh4leXg242yLZjMWVZOJoLUTVfKXXcLi177B/Oe+QOEdv9xWwpEACsKilGaLJ0bkuqhmPGOvZtERguKh/fvZc3JjV5tDp4pqNV8drh7cx8pjD1B85U8glOb35mkk41mDUsVtyRtSp2DnDEorrZvZ1QnYGYN9K615Y3Ujyf6qy/6qC9QEOQEM6hq2ZWBnTE7NWlwz0MuQobNYz2ZcExhLrtf0bEZNCEYNvaUzFAHMMZveiy9n7mu30nvJ5ShtVN7ayiXlnYCMIqTvtVU/nE5l4qn9AIyf1LisEBkESN9HzTS3okUGIbOf/Rq5K87GOn28qXNpNCYKw8JIxa4EGRQ6GgqTUWuLMe3MmMwy1aImKREwKV0mpcuPosX1v+dQKdazGW3F4tx6NmOIpCTddYFxLaux2T1Oi5rJk371+Bs2EaEoDLz8pUx94u+oPvAQ2fPPbfaUtsyQMGol5WnJc2KEroOWyzd7GtuiIwTF0oGnuPL65zZ0n5FTbYly5+lv3Iw5UqDnvIuaPZWGU8yZTKSluIli503KqcNzohSyBt+Zah8zCwnM+gGzfsB9qxvZjFY9m7FomdimwbWDfdimgYKg7K2JjB4lx2XC9ajsUjbjmKnjRBELQev3ghx8/o0s3/tD5m//OkMveHGzp7NlbNNgwk2Dw6SIXAehqgi1I0KutmbiqacYGhsjk2tc+XnoOAhdb7ohy/LXf4g/tUDxt97Y1HkkQVGxWCFgmbSiJSnGFYty5ND6d9r2pSYorh5/wxZilZDHolUeY5W1k0MBRjdlM56v9PAibYTeejbjxKZsxoPCY1b6u5Y8Mq6a3O4s7NJo8cmcezbWGacx/19fInPu2W1j6GcLkynZbNm4s4lcB2VwuNnT2BYdEd261Sr3/eBOZiYnGR4ba8g+w6qDMdzcD7Py5ONU9j7K+Gt/BiHa40KzHeyswQ9mWruMsd0p5gzunkqPcVKYqmDI1ClVGy3G7H7erhNJ9lVd9m16LwIY0jVsy6RoGpyWtXjOQC+Dm7IZJxyPkusy4XhMe43PZiyaBhNtkj2n9w/Q/+znMP+tr9N35dVoPb3NntKWsA2DHy2vNHsaHUs79sPpVFzHYXV5me9/8xtccd31Ddln6FSbnp0YeT7z//41eq4+D/OkxsTBrcS4sDiYZicmyrialjsnzZjM8qjSQJNEAbIJrUpqvRZdytLlh5uyGfObezMqFudrPYzpFgERpdBlInI5FDpMRC4TYeMd2y2hMKwaLV/yDDVDv4FXvIzSR/6Cle/fRc9Vlzd7SlsiNWRJFhmGSN9vqyon6BBB8bf/+P/wR//zN3nrq17B+z72l5x3yaU72l8rGLJIKZn96n9jFvaQP+uCps0jKQT1DMWn0qauSaErgqGMnpY8J4idMVn0AlaDBgVFLSY4SGDGD5jxA+5b3lhV30o2Y01srJVN76Q3o22abVWOO3D981m887vM3XYLo694bbOnc1xUYNRIS56TJKwLiinN5w3/4xcoHzzI77zl5/n5d/4mb/iFX9yx0BtVqyhNrmhZ/uoPCOeXGXrDDU2dR1Kkvf2SZ1yxeDRsr+y5dmNMZrldHGr2NBJj5QjZjNJTGVNMiorJuGpxgd7DjcoIfYrGTOQxEdbLpsOa2LiTbEZbNViMAlZke+TZmiedSPbiC1n44s3kLrkIxWi+b8PxKCgWB6PWLilvZ2oVLVrbmfC212yPwpnnn8/H/+M/ef/bf4Xf+Ik386u//15uekP8ko/IdUEIhGE0cJbbo/L4Izj797LnDf+jI7MaBk2tZgzhpA+xSVHIGVT8kGW/PW6s7YidMShVu+8c3ko249F7M9YyGrfam9G22it7Ts1kGXzu85m55Uv0X3MdxvBos6d0TEYNA19K5oO0lDApItdtm2zVTifX08MH/+9f8w9//mf87Uf+mMcffIDf/MP/TWYHDs2hU0UfGGjgLLdH5Hgs/Oc3yF9/MUaxvcqktsq4YvGQP93saXQ044rFbV66yJ8UOamRx2BqlxyeW4UIKEUupcjlrmCjPVBeqBQVk6JqMa6YnG/2UFAMQmAidJgIPCYCl0NhLZvRkcePGNvBkOXpDNz0Eg79rz9m+Zt30PeC1l8QKgqL78sGZtmmHEbouihtZsgCHSIoAgyOjPCRf/gkf/Wh/8Wf/t57ePT++/mV3/t9jBgfylr/xGYJeVJKZr/y31gnnkLutLObMoekKeZMyhWPKHVkSQw7Z1BK+ycmil03FkrZejbjNQO92FbNaXrS3ZTNWP/vlfBwAbxoGnxxpr3O476rnsPCd+5g9tb/xn7jTzd7OsfENg3Kbmu6NXYKkeugtLiw3E0oisLP/vpvcPq55/FH7/pNfvV1r+UDf/UJiieeuO19yTBEel5TMxSXbvke4UqVgVe3/sNoHFQEtrA4mLqKJkYOlQFFZyLNAk2MMZljDgdPpN3nAFZkyKNhhUfDDYFVgfVsxqKwOM/I8UJtkH5FZzasZTMeCtz13zPR4dmMRc1kImyvmFwfHaHnmqtYvOU28ldfibqDxa2k0REMC4NSep1IjKhNK1o6RlAE0A2Dd7zv/Zxx3nn8xXvfy95HH+F9H/srhka3F8iHTrWpboyrD92Pe+gA4z/XXlby26GYM5hIhZhEsXNmKigmjJ01uL28ePwNt0sHqTtHy2Zcc5oumiYnZyyePdDLsKGzHAT1voweC35ARlWY8drrPFZ0naEXvJjJf/s0zoH9WCc0zlG20diGQanNjm87IYMAGQSobRggdjrPufFG9pxyMr//1l/il1/9St7zp3/OZc95zrb2ETpVhNa88qSo4rDwX9+k93mXoo8OQAdaahSEiUfEnPSbPZWOpahazEQeTmq1kBhjMstkw7MTRUfFi5uzGX/gb1Sm5IVKUTUpaiZF1eQ8I09BNZBAaZPIeJqW5fZq+2XP9b/4hax87wcs3nIbg6+8qdnTOSpjwsQhYjE1x0qMyHXQ+vqbPY1t01GC4hov/fHXcfLpZ/C+X31bva/iX3HuxRdv+fVh1cEYHExwhkdHRhGzX/1vMqeeQfbU06FDFwGKWZOH5rsr7X+3sfMG3zqUgNiVAtRXUq1Glzx35gLC09nsNH3/8sZ1wFzLZjQNCqbBVf21MtH3n34yU55fM39ZN4LxWApb9+G556LLmL/j68x8+QuM/3zrLg7ZpsHDq+m1OClC10FozXcATjkyp5x5Fn/17//J//qNX+Pdb/k53vKb/5PXvWXrrWaiqtNUQ5bFL30b6fr0v+q5TZtD0uxJ+ycmTnqMk2dMZplS0nttHFZkyKNBhUeDw7MZR1SDcbUmMp6j57BVg9f3FHhhOFTrzbiWzRi6TIdey8rlam8Pvc+/nsVbv0bv9deiDfQ3e0pHxFYsSmmmeKJErtOWC9AdISiKCMTTnivPu/BiPvEv/8n73vE2fuPNb+Ltv/8+Xvbjrz/uvqSUtZJnI/OMfe4EZYuaw9L99+BNljnxZ1+H4j3zfSWNjPvMs81nZTtn8NWJeWTMZ2wRc0VOxNR+4n4Ou13ZsDZPBShkDcpL3pbmLmOaiEcx+weLmItbcT/3uO/vWK8bNnUQMBX6yKcdByWudrR2vij1n1YloRVxN5Tsr7jsr2cvP3eojxMyJl+YnMM2DYqWwQmWyRW9PQwbOtUw2nCadmpi46TrE+zU9TDu93bT5y6EwvCLbmLik39L5dGHyZ15zlFfFvf8jPt92EzRMPna3MKW9hX3ei3jRhpx3mDsm0q8lx3vexp5Tq3i4enbxb2WbWGecc+nbuBI8WJvvo8Pffxv+f/9+Z/y1x/+3zx2/wP85gf/cEt9FaNqFdVsbLwIILZw7ofLFRa/+C16X3QF+lAPIGOfxoYV76YcBPFONkXd+hdgj2IyQQVVD9G1eAfaIV5PdD+IFxQryu6ljYmYY23WzPeoJhPS2dLnohnxzhXLiJdhqsZ8fzk7XhWUpcV7f3547HNlVGZ5UJl9hveesssuzVu5thwJGcUNpOO97HjntQSmpMtU4PKjAAZ9nffop/Le6ccZ1WrZjOOayQ1WDlszEEB5rS9jUBcbA5fVtd6MMWOHSIv5/QsPH6/vhutZvv3bLHzxywy/+Rh6RczPL+41afPnUFRMylRRteMHyVEY73jGXXtXY94bojDeeR37a3uM4aIgQIYhimXuWszYqHixIwTFozE0Osqf/MM/8bEP/QH/5/d+h8cefIC3vfs96McwW4m82g1IMXa/IaaMQma+cTO5M84lc8LJuz7+btGjq+Q0lVIlLbNLiqGsXssCq6YlQklhZwzKTjK95+QuB5itim0aTDge837AvB/w4MrG6rQhBGOmgW0Z2KbBZf092JaBpShMe/6GAUxdbFwIdj+bMXvmOWROPpWZL3+B7OlnIZTWUnoyikK/rqUOzwkSuS5qGzbY7jZUVeUtv/GbnH7uuXz43e/i7W96HR/42Mex95xwzNeFThWtt2+XZnk4C5+/AxlJ+l+xvTLtdmNcZPhOlJqFJElRsfiRn1a0JIUqBcMyw2SjMxQFO1A2OouiajIZuizLiGW/yhP+hhOxAIZVfV1kPMPIcn12gCFVZzEMauKi764bwUwG3q43j1Asi/4Xv5C5f/scvTdch1G0d3kGx8fG4j6ZXieSInIchN6eFS0dLShCra/ir7/vDzjj3PP4iz94H08+8jDv+/O/ZHBk5Ijbh000ZFm69y782WmKr/7JXR97NylmDWYcHz+SrZ2F1cbYOYPJ1dRoIUnshpc7x1+Z61SKlsk9S6tH/DdPSg44Lgecw7MQ+jR1XWQsWiaX9uUZNnS8KFo3gFn7XXY93ASdoYQQDN14Ewf/71+wfM9d9F58eWJjxaFgGiwGAdWoVQuB2p/IddAHmtNCJWX7PPfFL+XEU07j937ll3jra17J7/3pX3Dp1dcccVsZRUSei2rufslzsLDC4s3fpe+lz0bry+/6+LuFoPYQe0hWj7ttSjx0BKOilqGYkgwjMoNLyBLp4l1SjKtHN2SRwHToMx363ONu9Ga0hIKtGeu9Ga/J9lHUTHQhmFzPZvTqYqPLUpSszNhz9VUsff125j//JcZ+8ecTHSsOtrC4JZps9jQ6lnY1ZIEuEBTXuOl1b6j1VXzH2/il176S93/0rzjnwmc9Y7vIqTblw5RhwOw3byF/zrOw7D27Pv5uUsyZTKTZiYli95iUVtJjnCTFjMlDS2k/nKRQBYya+raz5xaDkMWVKg+vbDyAakIwauoU6xmNF/TmeJE1QK+mMVPPZtwQGl3mqkHDxPjMCSeTP+9CZr9yM/nzL0LRY/YJSICiYaTZiQkipSR0HMw2DRC7lVPPOouP/8t/8MF3/hq/9Zaf4Rd+87f48Z/9+WcsNIdOFaFqiCYYsiz85zcRqkr/Tdfu+ti7yTAmCoJpUhO/pCgIE4eQBZkaLSTFqMwyJSrd0ia7KRRVk/3B9kRxR0bs9R32+g5EtQ9HAAOqVhMZNZMTdZOrMr2MqDoVGa2LixN1obEcefgNyhIVmsbATS9h+u//EefxJ7BOP60h+20EOVR6hE65U80dWoDIcVCbaAq8E7pGUAQ4/5JL+cS/fo73vf1t/Nqb38Cvve8PeMlrXnvYNqHjoDfBXWfhR9/DX5hn/I1v2fWxd5ti1uSplfSClCR2zuDBmSNndqU0BjtjcNtU+7nJtQujhoEXSeb9nT/kBFIy4dR6LbKpWiOvbmQz2pbBufksBdMgQlJ21sqlN36qYbxMvqEXvJT9H/0wi9/7FgPXPnfH76dRFEyDkps+qCeFDHyIIpS05Lnt6O3v5w//+u/4uz/7P3ziw3/IYw8+wDv/4ENYmwxYIreKalm7XtESzCyyeOv3GXj19aj55hnC7AbjIkMp9R5OlHElw0RqyJIoSRmyCCGQCVZZtBNF1eI77s7LcSUwFwbMhQH3uxvPUYYQFFSDom5S1Awut3oo9gyTEQrTgV8vm65nM/ou82G8hensRRdinLiHuc99Efs3frVlDP0KwmJOerjp1TgxQtfByA83exqx6CpBEWB4bIw/+eQ/8dE/eD9//Lu/xaMP3M/b3v27aLpeyyZwq1jW7vYtiHyPudtvpfeCSzBHCrs6djMo5gy+O7XU7Gl0NIW8yVf2pWJXUuRUhT5da3jJc7p8vYFtJS92rYQhj61WeWx1I5tRAUY1nYJVExnPzGe4frifAUNjwQ9q4mK11pex5HhMu/5xwytjZJTeS69k7hu30nvplU11hd2MbRp8ZyG9FidF5LgohtlyvTNTtoaqqvzCO9/FGeecyx//7m+z/4nH+cDHPkFhfByoLUAr1u5/l+f/4xsoGZP+l16962PvNuPCYiItd06UYurwnDhjUY771JlmT6NjMRAMKzoTYXLnsSclTwUuTwVPa7MjVYq6ia2bjOsGF2fyjGkGvow2BMbAo+TXBEdHHjtiFIrCwMtfxuTH/i+Ve+8n96wLEntP28Emkzo8J4iUksh105LndsIwTN75Bx/izPPO56P/6wM8+ejDvPfPPkZfbw9Iuesf5sJd3yFYWWHo+hft6rjNwFIVBk2dUiXNikmKHkMlqytMrqaljElhZ0xmXT/R/nvdTtEyKDm7fw5HwKTrM+n63LO4sTqdUZSayJipZTReO9xHwTRQhWBqU1/GkuNRdjyWnmYCM/S8G1m++y7mv/lVhm+8aZff1ZGxDZOSl14nkiJynZpbX0pbc8NLb+LEU0/j9972S/zSa17B7//ZX3DJVVcTOlXM4dFdnYs/OcfS1+5i6I0vRMl0/rlVJJOaACTMuLD4djTX7Gl0LrJW8jwp0qqhpCioJhUZsiRDdrs5/2IUsuhWeMjdyEBVgTGtns2oG1xg5bixZ5A+VWM28JnwXUqeR8n3mPBcpoPDF6YzZ56BdfZZzH/+S2TPP7clTDpsYVEiXdxJCunXK1qOYRzcynSloLjGj73hTZxy5pm89+1v462vfQX/+2MfZzif3dX04shzmbvjq/RddDnG4JGNYjqJYtZgwQ2oBGnKdFLYeYOZSt30JiURipmExa7UtQ/bNLjvKIYszaAaReytOOytbKzQCmDQ0ChYBkXL4MSMyZUDPQwZOtUw2iiXdj1KGZPq9c9n8uu30nfVtU1prbGZAU1DVwSTqaCYGKHTvg22Uw7ntLPP4eP/+p988J3v4F0//zP88m/9Di+44tJdN2SZ/7evo/Zk6X3RFbs6brMYFxlujsrNnkbHIoCiYjLhp5lHSdGLgYnKtEhIjEnDRcZVk0NHMWRpBiHUHaM9NmtwOUXB1kzG9Vp/xrOsLLZuIASUfY+S59WyGj0X87Wv5JH/9WFWvvt9eq55dtPeyxoFYfFotNzsaXQsNUOW9q1o6WpBEeD8Sy7jE//2Od77q7/M7V/8L6667nrOOPn0XRt//vu3E7lVhq7r/OxEWDNkaZ2Lfidi503KaXZioiTh8AykFc+bKFoGt0y3dtm+BGa9gFkv4IGljYbruhCM1UumbdPgkr489phB5m2/QPk1L+fgwiILg/3rYuOMbJwJzFaxTYNpzydMH0YSI3IdtN7eZk8jpUH0DQzwR3/9//E3f/LH3PzZT3Hts87HCEN2SzL2Dk2z/M27Gf6Zl6KY7ZnFsB360MmgpiYACTIkDBQEkzKNy5NiLMoyK6qEIoGbbRozArX+iUdzeG4lVqOIx70qj3tVRLhhAjOs6RR1g6JhcpppcW2+j+GxcRY/+Un27dvHXE8/pShkwvOYxsXf5YhRAAWstOQ5Qdp9AbrrBUWAkbECf/bJT/H4t7/Bv33qn8nf9jV+6V3vRkvYjTN0qsx9+2v0Xfps9L6BRMdqFYpZI3V4Thg7bzCx3Po31nbGzhjcv9g62XOdRl5V6dE0ym3qQOxLycGqy8Hq4d/DXk2lZ+8j9E+VOO/Gl3D+6ACjpkGIpOzWMxldj4n672qUXCa3nRqyJMpaPxy1jQPElGeiahq/9K53c+9VV/HYo4/y/97/AT7wsU8wViwmPvbcv9yGNtRL7/MvS3ysVmBcZJhqwsNzNzEuLMoytVlIklq5c+MNWVI2KKom3/PaszWCBKYDn+nA557qxnOFKQTDFYfcHXdw5nOu4YrTTqc4YGCJPUxLl5J0mYgcSrL2My+Tu1IOYaAAM6QxY1LUWuS0b7yYCop1dMNgz/gernjeC/jD9/wOTzz8MO/984/SPziU2Jjz3/k6MggYuuYFiY3RahSzJvfNpUJMkhRyJj8opWnpSaEKGLOMmmNwSiLYlsGM13k9KpeCkAX7ZO747Ke59aFHKf7Ez6MAwzm95jRtGpyVy/DcwX4G9LoJzJrQ6NV+T3leQ7IKbcNI+ycmiKwfW9Gm/XBSjs0ZZ57JwsgISwuf4K2vfQXv/bOP8awrrkxsPHdfidXv3M/IL74SoXdH6D6OxaHUkCVRxlNDlsQZkzkmxEqzp9HRFFWTQwkasjQDV0oOZUzmnAq3fuCD7Pn9d6P25BkYDSgqFrawsBWLi0Ufo8LEJ6IkXcqRw4R0KNXFxmoDlgsKwmIq9XdOlMhx0Xr7mj2N2HRHVLIFas0wQ254+asY3nMi73/H2/il17yCD3z045x5fuMdloLKCnPf+yb9l1+L1tMdJVG6IhjJ6GnJc4IYqmA4q1NaSYWCpBg1DbxIMu8FCew9rV8BKJrNMWTZDRRNY/gFL6X8L/9Idd+TZE4+lbLnU/Z8frT8NBOYushomwZX9/diGwa6Ipjy/LrQ6K4LjQvB9s5H2zT54XL6kJMU4Vo/nF3syZyye4ROleHxPXzi3/6TD/z623nnz/4kv/xbv8OrfvKnE/nM5/7lNvTCID3XXdTwfbcqRZFhr0wXoJNkXLF4KEzvA0kyJrPcrU4ltHeB7PIM3gGhYQqFybAzY8a+Fz2f5e9+n4VbvsLQa17JIgGL0QoPsVJr1gioCEaFgS0siorFuUoPz9dG6Bc689KnFDmUqa5nM05Lj3Ab542dljsnipSSyHNR0wzF9id0qyimhVAULrzscj7+r//Je3/1l3n7m1/Pb3zgf/GiV7yqoePNfetrtYb+19zQ0P22MoWMQTWIWPTC42+cEotCzmDZDVj102OcFMWMQbmaiuJJYlsGpTYtd94K+Qsuwrzja8x8+Qvs+YVf5UhCcjWK2Ft12Fs9PIgb1DVsw6BgGoxbJpf29jBi6HhRdFgmY8n1KHsezhHKplUBI4be0ce42URt3g8n5ejUytkdFCtDn2Hy4b/9e/76Ix/mYx/6Ax578AF+/f0fxDAb58DsPH6Qyg8eZvRXXovQmu/2uVuMiwx3yJlmT6OjKSoWXwnSY5wUulQYkGZa8pwgRc1kKvLY/U7Uu4Oaz9H3ghtY+O9b6L3+OZijuWdsEyIp1cugfxhtlH5nUbGFia1Y2IrJNcowBWGiIZiSLmXprouMJemwiH/EOdgiw36ZnsNJEdXbDwm9fStaUkGxTuhUUa0Nt75Ru8if/9Nn+NP3/R5/9Fu/yWMPPsAv/c/fRtV2fsiC5SUW7ryDwatvQMvmd7y/dsHOGml2YsLYeZNSasiSKHYmLXdOGtsyuH+5czNThKIwdONNTPz9/2X1ofvJPmvrWfBzfsCcH/DAagXqTd41IRgzdGzTxDYMLsjneOHQAH2axpzvHyYwTrguuhB4UcT8NrMaU7ZO5DoomWyzp5GSAJHrgBAo9eBf1TTe+tu/wxnnncdH3vNu9j3+GO//6F8xajemr+LcZ76KvmeE/DWNr5ZpVbKoDAiDiTQrJjHyqPQJnYm05DkxRmWWVQJWxZGFmpSd0y6GLDuh97nPYfmb32Lhizczdu5rtvy6CiFPyApPhBUUWYsXBTCAji0y2MJij7C4TO1nBBOHiHJdXFz/TZWCsPienE3o3aXUHJ6ttq5o6QhBUYS1n+296PD/japVtFwPYlMyh6mb/NYH/zdnnXs+H/ujD/Lkww/z+3/yF/QNDG57jsqme8ncN7+C0DSGLr3+sL8fcZoxGxbImK7jsV+3hUXzYt5kouodtm3s8eK9DDXmPSeuOdu2z8sdjmfnDcrL7rZfv9vHM+54UdykjwZeo23L5J6FY5cIRTGvrGvfh0iVhNtYqJIx31/c18X+PmzhdQowZhiUHW9j+7gnTNzjsgtJQNkzzyJz+pnM3PpFTjz3XIS6/UGlUnuDgYRDjs8h5/AbSk5VKBgbZdPP6e+jYBpoQhBIyZtGR2tCo+tRcjwWg+NcsOIeTyXeBxjr/hDz5JQNbg4UOS56/9FjhbjHRETtG3C2ArHiRTjs3I+qVVQzgyLFYdemF77sFZx0ymn8/q++lbe+9pW8908/xoWXXRFrntlMbdFq9f79VO99nBN/+7XkcsdfAPCD3c1g1LR4XxzfP/Y8C0qW2chjJZDU7go1ojDe+a+o8eapxLyeiJjf7zioMR8UipHFdOTibvMLocU8lnGflTUl3niWHk/EC6N4DyZHOlcKMsOUsnrM8yjaaYC6S6da3O9e3EBTbnG8omJyyHfXt2+XO6RUt/7BiYxO300vYu6f/xXniWdjnjK+7fHEpu/tPB7zeDwoF2vnTwQagjEsCqLWn/ECpZcXilF6hY6UkucwwsnkN5VNH7unYtzve9xrZ9zPXY15PWvk1y5y3eMasrR6zNgRguJOkVISug7m0Ogz/k0Iwave/FOccuZZvP/Xf4Vf+vFX8oG/+DhnnHterLH8xXkW7v4Ow9feeFhGZDdQzBrcMdmeLlztgp03ueOphWZPo6MpZgz+u5RmKCbFiKkTSslcIj0qW4uhG2/i4F/+CUt3fZ++K57d8P2vhhFPVB2e2FQ2LYDXjAwzoGvMeD4nZkyu6O9h2NBxooiSsyEwromNnWaOkzQyiog8F8VqXNlrSusQus5R3bvPPPd8PvEv/8kH3vl23vlzP8nbfvs9vOKNPxEr80BKSfkfv451aoHeZ5+902m3FXtEJjVkSZg9wkozQBNmVOaYSrLcuV3UswQpqibfd5aaPY3EyV91GUtf/SZzn74F+90/2/D9B0gOUa1ddzeFfKfLPD+ln8RDchlbWJyhDFMQFiowWS+ZLktn3XF6ic6P3RtN5Dio2fauaEkFRUCGATIMUM2jC3wXXX4ln/js5/j9d7yVt//E63jH772fF778VajbzCqZ+dYtKGaGwcues9NptxUKtR6KhyqpEJMUioDRXGrIkiR9ukpGVSinJc+JUbRMyq7Xod1wDsca30P+wouZ+8qX6bnoUpRdcASWwICh8eByhW/PbwThmhCMmXW3acvgwt4cL7IG6NU05rxNZdN1sXHa81PHv6MQuS4oCkLTmz2VlAQInSrGMbJP+weH+OO/+Qc+8ZE/4i8++D4ee/AB3vqu3yHfuz0DvpW7n6Ty4FOc9PtvaOtSqDiMKxYH01LcRCmmDs+JMxZluUsrN3saHYuOYFQ1Or7kGUCoKgOveAnTf/0PVO97nMwFp+/KuP3C4JCscnu4UfIsgEEMbMWiKCxOEFmu0AYZFgYOYV1k3OjPWJZO6hF9DELXQR/cfvVrK5EKitSCQ8UwEcqx09zHikX+/JOf4U/f/x4+/Lu/xd9/7M+56cffwEtf8zoGR0aOO443N83CvXcy+rwfQzG6K3NhxNKJJMy6aR+RpBjO1o7xXDU9xklhWwbTrk8gk5G7ZFgvPTrOtaiTsa3OdXg+EkMvein7//SPWPjWNxm84QW7MqZtGnx1ZuGwvwVScsjxOOR4sCmRPK8qFKxayXTBMjgzVyubVhBMeYeLjCV3C2XTXUAn9MNJOTK1ipbqMRegodZX8W2//R5OP/c8/uS9v8ttX/o8N7zkJn7s9W/i7AsuPO65IaVk8h+/TvbsPfRcujsPjq3EuLC4Sy40exodTXqME0bCiMwmasgigxChdO99pqAaVGXEQtQdWXGZC8/DPPNE5j51M8Xzfvm4ukUjKAiL0tMWHiQwi8ds5HE/GwvTOoKxesm0rVhcqPTyonrZ9Jz01vsyromMU8cpm+4GZBQhPa/tTfxSQRG2FByuYVoWv/2HH+FVb/4pPv+ZT/FPf/1X/MNf/QXXPO+FvPwNb+LiK5991EBx+o5b0HJ5Bi5ufGlbqzOeNSlVuyPrqFnYeZPJlfQYJ0kxUzuPk8KfnQLAGBxObIxWxzYNHlzuHjc5fXCIviuvZuEbt9F3xVWouWSNujKKQp+ubTnLdiWMeHzV4fFVZ728SlB3m64LjSdYJpf3bZRNrwmM5XpWYyk4stt0pxI5Dupx+uGktCeRV8uE2eqi8Ite/ioue/a1/Pe//wtf+JdPc/N//CtnnHseP/b6N/H8l/4YmdwzHTsBlr//KNXHJjjlD+KVS7czBoIRYabZcwmi149xasiSHAPSQkEwJ5I7xs7BOfovPy2x/bc6Rc3siuzENYQQDL7hRkof+BtWv3sf+auflfiYtmJxd7iwpW19JAdllYOyelg76xwqttjoz3hdvWxaAaY2lU2XpEuZ6lHdpjuRyHVAVRENMP1tJu09+wYROg7aNmvXzzr/Qs46/0J+6X++m1v+6z/4/Gc+xW/+3E+y5+RT+LHXvZEXvfLV9PUPrG/vzpRZeuCHFG58zbozYDdRzJqpw3PCFPIGpZX0GCeJnTGYSFBQdKdqpTHGSCGxMVod2zK47WnZc53O4A0vZOmu7zP3ta8wctMrEx3LNg0W/IDqDgQ+Ccz6AbN+wP2bxN/DyqZNg/N7crxwpF427fs1gdHbEBqnPI9OzGcMXQct39PsaaQkQG0BenvZp4MjI7z5F3+ZN7zlF7nzjm/yX5/5Z/70fe/h//7xH/KCl7+KH3vdGzn1zLPWt4+iiMl/+jq5C08m/6xTkngbLY0tLFYJ015cCVLAokLIYnqME2NUZpkRVaK4LnbHIfICnNICmZOOXyHXqRQ1k4mgu557rLNPJnvp2cx/5lZyl5+H0JOVcmxh8t877LW6SsjjcpXH5er639bLpusi4x4ly+VigGFMHELKuJRllfKa2IiD04H5jJHjbjumaEVSQZFagGgODMV6bb63l1f/xE/zqjf/FPfd9QP+6zP/xN/8yR/zt3/2EW54ycv4sde/iXOfdTHT37wZvW+A/mfFc/xrd4pZgx/OHtsZN2Vn2HmD+6dWj79hSmyKlsFdc8uJ7d+bmkTr7UPNdJdh0xpZtZY9V3K6K0BU83kGrnsec7fdQv/Vz0EfjHc/2gq2mVxJ+WFl05vI6oKCaWCbJrZpcO0mt+kpz6fsupTq5dMl12M+aO+H3Mh1UYa79yGvk6kZssS7PquqylXX38BV199A+dAhvvRvn+FL//pZPvfPn+T8Sy7lx173Jq6/8SV867ZbcfZNcer//pnGTr5NGFcyHIpSQ5YkGReZNAM0YcaiLFNKcjF59cAsRJLMSd1b0TKumtzlJheTtyoDr7+RQ7/1Fyx99fv0vfjqxMbJo9EjdMqy8TH5etm09LhfLrGmFeoKh7lNnyf6eL4yRp/QWZBeLZsRZ718egqXsI1r80LXQTHbvw3ergiKH/7wh7nrrrt497vfzUUXXbQbQ26ZKAiQgR87QFxDCMGFl13OhZddzvxvz/Dl//w3Pv/ZT3PL5/6Dk08/g+XHH8N+2RsQandquHbGSDMUE6aQN7n1yflmT6Nj0RXBkKknnKFY6vrsxDnPx+lCV+H+a69j8bt3MHfrzYy9/s2JjWObBiV3d3tUrkZHdpse0LRab0bTwDYMLunpYcTQ8SNJ2fMoeXWhsS42VtqgbFqGIdL3j+oCnHJ8WjlmDJ0qRm//jvdTGB/n597+G/zUW3+Vb932FT7/mX/mD3/7nfzlH30QTdPouex0cuecsPMJtyF7hMWh1H04UYoiFW2TZlRm2ack5z5c3TcNQOak5BYgW52iZvJflZlmT2PXMfaMkr/+Ehb+42v0XHcJSjaZeMMWFjPSxdvFzMCjuU1nUSkIiwI1ofHZyhAFLHQUpnGZlFVKOEzWBcd52qMFWOQ4aNs0bGtFElO3pJQIIfjYxz7GRz7yEWZmZnjZy152WHA4PT3NnXfeycjICBdffDFaE+rHQ7eKohuIbbo1H4uBoWHe8PO/yOt+9n9w17fv4L8+/U9MBdB3/qUNG6OdGDQ0DFVhsouMFnabXlPF0hQmV9NjnBQFy6ASRiwlaDrhTZfJn3V+YvtvdZLMnmt1FMNk8Pk3Mv25f6P/Oc/FLI4nMo5tGnxrJbmHnK0igbkgYC4IeGB1o2xaFTCqb5jAnJ3NckN/PwO6zlIQbGQy1oXGSc/DT8gkKQ6R6yA0re374ew27RAzbhiy2A3bp6brXH/jS7j+xpdwYN9evvDZT/G9b34d4ydvaNgY7ca4kuG2YLrZ0+hoisLi9miu2dPoaEajHN9Xk3N4ruyfwRjpRct15+JVr6KSFSqlLit5XmPgtc9n9Vv3sPiF2xl43QsTGaMgLMotkslcIeRJucqTrB4mNA6gr2czFrB4ltLPKBYBEZP1TMZJnPXMxtUWa/NQM/EbbfY0dkxi0ZgQgltvvZXf/d3f5Vd+5Vf4P//n/3DBBRes//tdd93F2972Nubn55mammJwcJC/+Zu/4XnPe15SUzoi2zFk2S6KonD5tddx+bXX8bZPfi6RMdqBYtZksuoRts4zX8dh501mKj5BF2Z27RZFy6BUTS5wiTwPf34OY7SbMxTNXc+eayV6L7uShTu+wezNX6D4c7/Y8P0LoGAalNzWDcBDybpYuKndDpaiUDBqmYy2YXBFbw+2YWApCjO+X89o3PiZ8f2mrE6HjtP2bn3NoB1ixsj3QMrEypNOOPkU3vqu3+Gt7/od3vH43ycyRqujUOvZlWYoJocAbDLpMU4QS6r0YSZb8rx/psvLnS2mQ5/m3OmbjzbYR+9Lrmbxv79FzwuvRBtofJabLSxKUevGiwDz+MxLn0fW3KYlqAiGMdczGk8Tea4RwwwKk2XpU96UyViSVSZx8ZvQn1EGATIIOsLELzFB8Utf+hLvec97eO9730tvby/ZbBbbrq3qTkxM8HM/93MoisI//uM/Mjg4yPvf/37e8pa3cOeddzI0VEvf/n//7//xR3/0R9x2220UCsk8ZIdOFdXqzn5lu0UxazBR6V6RYDew8wbl1JAlUZI2ZPFmJkHKLhcUDR6Z6R6H56cjVJWhG19K+Z/+gcrjj5I9/cyG7n9A19CFYNptPwc9J4rY5zjscw5/CO5T1Vo2o2FgGybn5XKM6ToAk75fz2h01wXHxTBZG5jIdVGs9u+Hs9u0Q8wYulUUw0QIpeH7TqlREBYBklmZxoxJMYyJAKYT6IuWUmM0yrGIiyOSu99U908zcM1Zx9+wQxnXTCbC7hbF+37sOpZvu5OFf/8awz//iobvv4DFQ7L9SspDJJN10fAeWM9oNFHW+zMWsLhYDPASYZNBZR5vvTdj7XeVGdxEZcbQdWsVLQ2skm0WDRUUoyhCURRuvfVWPvjBD3LjjTfyG7/xG/zET/wEZ5555nrQ98lPfpJSqcTnP/95Lr/8cgDe9a538eUvf5mbb76ZN7/5zfzoRz/iox/9KO9///sTExOhlmpq9A0mtv+UWobio4vdKxLsBoW8yYGl7r6xJk0xY/Ld2eRKRb26w7M5MpbYGK2MAhRMvWtLntfInXch5gknMnvzF8j88q8hlMaJF7ZpMOX5HeWsvBiGLFaqPFyp9wMTtQycYV1fz2Y82bK4qreXYV3HiaKa0/SmbMay5+3I9XozkeOg9/c3ZF+dTrvFjJHjpAvQCTOu1PondmfO0e5QFBbljvRLbR3GZLKGLKHj4ZYXyXZxhmJRNTnUpeXOa6i5DP2veC5zn/oyvS+5GqPYODM4QW2Bp9RBmcwuEU9R4SlZ1yTqN5o8GjYWY8KiQIYzRQ9jwkIBpnDXy6bLskoZhwUasygfuQ5KB2QnQoMFRUVRePTRR3nHO97BTTfdxHve8x6q1So/+tGPuO6669B1ndnZWf7jP/6DF7zgBVx22WXrr+3p6cG2bX7wgx/w5je/mXvvvZdf+IVf4Md//McbOcXDkGFI5HtpgJgwxazB10qpWUiS2HmD7080vy9apyKoZc8la8hSRusf6NpyySFDRwIzXvtlzzUSIQTDL76JQ3/zV6zcfw89F17csH3bxu4bsjQDCUz7PtO+z72rGw91uhCM6nrNbdowOD+X44UDA/RpGgt+sCE01l2npzx/W/0ZpZQdFSAmTbvFjKFbRcu3f/P0VmZPahaSOEWRqRkepCTGqMwyJZJLpHCemgUgc1LjBKR2o6iZ/NBLn3t6Xngli1/+DvOfvZWxX3tTw/Y7TK3SYqYLMplXCHiMFR6TK7U/yNpz3yAGY3UTmCIZLlEGGMbEJ1ovm64ZwdQMYSrbXK6POqhFTkMFRcdxePOb38xLXvISPvzhDwPwyCOPcODAAS6+uPZQtH//fh544AHe+ta3oqrqeiPubDbL6uoqfX19APz0T/90I6d2REK3itB0lC51Xt4N8ppKXlMpJSjEdDumKhjM6GnJc4IMGBqqEEwnKMZ405OYXezwXLQMyk57uLIlTebU08medS5zt9zcWEHRNDjUwv0Tk8aXkkOexyHv8O9xVlEY02pGMLZhcFVfL7ZhYNb7M5bcTRmNrsesf+RuOzIMkGHYMQFi0rRTzCilJHSqmEPdmUG+W4wrFt8L0wXoJBknwwMyFWKSZDTK8bi2kNj+q/vrDs8ndqfDs4ZgTDW6PkMRQDF0Bl77AmY+8a+4+yYwTy42ZL8FYTGZcMlvKyOBWTxm8XhQHt6fcRRzPZvxLNHD9WKEAWGwLP3DnKbL9f6MR3PJjlwHfaAzqmQbqqR94Qtf4K677uL666/n5ptv5pJLLmFycpLV1VWuu+46AA4cOMDq6ipXXHEFUMvGAPB9n+npaU488cTtDywhzlNo6NQNWbbx2vp0t40SM+lGxPwmy7jl+DGf5o/WJmRPxmDW8QmqkiMV7sWeZ0yUmHqQaGGVo5A3WXQDKn4Ue54i5vkZ6TFfF/PKE3e8uHfEtVZZRctg0vGIotqq1XGHi/H+3KkS+YsuIszE+BCjmBem3eYYb23d4bmR37W4+2qBw9lz8aVMfvqThNUqaubIWfTKNs3qbNPgrvnl2HOSMY9L3Ou83KVWdatEPBk4PBk4sKlKrU9V62XTtYzG8/LP7M/ozkyhWBaKadb64eg6qAJ5nJNPxD2YHURTYsaY8aIMfGQUohrWrsSMYpeDDkWJN57nxfty9/UcIUNOwnhgsWgs0CeOnEG3UonZnzTm56Cq8YIHJYx38YpiXBdUZXtzLAqLr1JC1eK9Nz+I95nnzHgBeM6IJxrJmNdYJ9zZg4kiBcMyQ5nKlj7P7X5+AM5T05iFPsy8CtvMipLR7vaAlX688UR49GNX0Aw8GbHgRYinP13u8rXzWPM89gvjvUweYbzclc9i5v/+G+4TExgnjB/xdcE2A7ExPcOEdGKfL6oRz005zvcBINql8zpEUsKhTJV7mN/ozyjr/RnJUBAWl9BPQdjkhMasdGsl01TxFudRLAthGISui2GZyC2cs60eMzZUUDzttNP4mZ/5Gb7yla/wiU98gkqlQj6fR1EUPv7xj/NTP/VTTE9Pk81mKRYPV9APHDjA8vIyp59+eiOndExqDs9pJkGSFHMmpdU0OzFJUkOW5ClmzER7+0WuS7AwjzHWvRmKtmXw6EpahrXG2qplMD+HmjlygLgdNCEYNnTKXVDy3CgWw5DFapWHqxvnpQIM6Tq2XstmDKtV/Pl5pOfV1CNFwTl0CMWyUOtCo9DSKogj0U4xY82QxWpoT9OUwxnEREUwTef07Go1etDIoVFOj3FiDEmLCMm8SC4ur+6fIXtyF/dP1EwmgjSWWUNoKupgH8F047K7bcVib5j6H2yV9f6MVA5bdMxLjUJdaBwTFv7sLJHjQL2djjc9XYsV6z9C19cXTtuJhka5F110ER//+MdxHIeFhQUee+wxfu/3fo/HHnuMb3zjG5x22mkMDg6Sz+fxfX+9dCWKIr71rW/R39/PmWc21tXyWISOg97Tv2vjdSPFvMHBVOxKlELepLSS3liTxM4YPLmSXADuTdcMWYyx7i2nsy2Db8wuNnsaLYNWFxT9+TnM4s4FxVFTx4skC37YEhmY7UrEpv6MlVVe+5xaJp2MIpwDB4CaW3e4vIw/M4P0fYSmoZjmesComCaqYXWEs99OaKeYMV2ATp6CzDJFlaiVS0LaHJsMs+sleKk4ngRja/0TE7zPVvbPMHLD2ckN0OKM6yYTfvpsuRltuL/BgqLJt4O5hu2vW1kh4HFWeJwVkHDDadcjpcSfn8ebmkK1rFpSyeIikeuCotTixafFjIra2kJjQwVFIQSmaWKaJn19fQwMDBBFEa9+9av58Ic/TH9/Px/96EcxTZPp6WmGh2urKxMTE3zxi1/kyiuvTNTReTMyCol8t1bynJIYds7k++X4JXYpx8fOGzy6P11FShI7Y/Ct6eTELneyDEKgj3anoJhRFAaM1OF5M2o+j9A0gvnGBHS2WetRmZIMQlGQQYA+NHSYy7MMQyLXJXIcIschWFggdBwIQ4Su17MY14JGC8UwuiYLrp1ixtBx0HL5XRmrW7FljnKCRhYpUCTDBGklQJIkbcgSrLp4U0vd7fCsmfzISZ8tN6ONDBBMzjZkXwaCIWFQitx0AToBhBAQRajZLMbo6PrfZRQReV4tXnRdwtVV/Lk5pOchVLUeK5q132atCqZVFqYTjVpnZ2e58847Ofvss+mvB9jXX389q6urfOpTn0LW0z3/7u/+jkcffXS9qXYYbq8fRBxC10GoGooWtylbyvEwVcGQpVNaTVeRkkIVMJozKKVZoIlhqQqDhp6osZA3VUYfGEQxjMTGaGUKlsGCH1ANu7X98zMRQqANDOI3SlC0DEpdbMiSNDWHZ/cZDs9CVVGzWfTBQcxikcwpp5A7+2xyZ52NVdyDmssjgwBvdobK3idYeegBVh9/lOqBp3Cnp/CXaqvWchtu0+1Ka8eM1XQBOmEKMpsKigljiwwTqcNzooxFOSaV5M7j6lMzAGRP6WZB0UhLnp+GNjxAMLPQkH0VFIsKIUsyXh/ElONTc3g+vCewUBRUy0Lv78ccGyNz0knkzjyT3Lnnkjnp5NpitRAES0s4B59i5eEHWXnkYSr79+KUS/gL84TVKjLa/WepRBv7nHzyyXznO985rGn2hRdeyDvf+U7+/u//nn379hGGIZ/5zGf40Ic+xMtf/nIA1G2qrZXyAdTBIVQzg2pmtiQSpsFh8hRzJgtuwGqQigRJMZI1CCLJgpNe9JPCtgwWvIBKgmKXN1XGGO3u/olpduIz0QcGCRYaU8JSsAweWFo9/oYpsZC+D1JuaVFACIHQdJS8DvmNrDcpJdL3iVyH0HGIXIegLigC9VVpE3VTRqPQtJYug9kOuxEzrk7sQxkcRjWtWryom8c9flHgI8MgLXlOEgm2zPIN5VCzZ9LRFMlwF2kZY5KMyizfFAcT2391/wwogswJneEOu116FJUeVaOUOjwfhjYyQDi/hPQDhL4zecdWTEpR2mc1SSLHwejp2dK2QlFQMlnUTJbNCpcMAkLXJXJrFTD+/FytAiaKEIZRixXNjYxGxTx+vBOXRAVFIQRXXnnlM/7+q7/6qxQKBT7/+c8jpeTzn/88L3zhC9FiNi5XrSyR5+IvLxL5LkLV1sXF2o+F0A6vPQ+dKqqVCopJYueMNDsxYQp1Q5bOz11pHnbGoFRN9jz2Jsv0XHRZomO0MkXLYMJJrxVPRxsYxNm/tyH7KpgGX3Eb118n5XAix9lxubIQAmEYKIaB1tO7/ncpJZHnEjm10umwWsFbqJXBoCibBMZa4BgFyWfsJcFuxIx6Tx/ICG9hltCrPTA9PV5UDOvweNGt1oRHpTVKizqRHnSyaEwexd05ZecYKAxhpiXPCZKTOjm0REueK/tmsAr9qGZ3VtgVNZPpwMPrgqz97aAN9wMQzCyg2zvLXi0qVq3cOSUR1itanpahuF2EptXioFzusH3LIFgXGUPHJViZIXIdkGz0Z6yXTEe+v9O3AyQsKB6NfD7Pz/7sz/KzP/uzDdmf2T9ENl9TeWUUEroOoVsldKv4q0tEnoNQ1I2A0coQOBWs3NaU4ZR4FHMmE6nDc6LYeZNyasiSKMWMkWi5c1itEiwtdr3D8+2pIcsz0AcGWbn7h+tmFHHJqgp9ukbZaUzgkPJMIsd5RrlzoxBC1DPqLOjtW/+7jKJaf0a3ns24skI0O0NlsbO+S42MGY2eATJr8WJdqF2LF72lOULXASSqYa3HjIFbQTF2FvinHJuCzDKDgy/SipakKGCxSsAKaUVLUozJLHMi2fO4un+GTFf3T0zLnY+ENlLLWA1m5ncsKNqKyV1BZ8URrYT0auev2KGgeCSEEAhdR9F1yPesO07XKmC8Wm/G9QqYBSrzCw0ZtymCYpIIRUXL5NAym9TaKCL0NomMc1NI36M6eQhvcW6T0GhtqfwlZWvYOYMH5tISuyQp5A3umVxp9jQ6Gjtj8ujyQmL7X3N4Nru05FlQK8edSEuen4E2MFhfZayiZrKx92ObBvOej9OEvirdQiNWm7eLUBTUTAY187Rqiw4TFJPiMKGWAaAuMvrehsi4skBYrcUxy089dlgmo2pmusZAJ2nstH9i4qSGLMkzFiVryAI1h+fRF12Q6BitTFE3mUjLnZ+BNtgLitIQp2dbsShFUw2YVcqRWIsXd1NvqlXAmCiGeXgFzPJSQ/bfcYLikRCKgmZl0azaA1ngVFid2Etu/JRaryK3irc4QzjlAGI9UFStI5e/pBwfTQhGswalNEMxUey8wc1PpDfWpFCAMUtnIklDljWH5+HR42/cgQwZGgKYcdPsuaejD9REjmB+bkeCYsEyKLnptThJIsdB6+s7/oa7gFBTkSsuQghUw0Q1TOjpB2Bx70NkhgsIoRC6VYLVJdy5SWQYohjmM0XGFnFdbCcKMsdBkS6OJoktUkExaUZllskkHZ6XHfzZlS7PUDS5z0mvFU9HqCrqYC/BzM4ExR6hkUWlnJY8J8aRDFmaRaP0ra4QFJ9O6FY3BEZr4yHtGeUvi0cof7EyKJaFaljpyvQxGMvquEHEgpuWViRFn6lhqArTlVSISYphU0dKmE1Q7PKmyuhDIyi6TtSF3TBty2TS9Ulz556JNlArYfHn5zCLe2LvJzW9SZa10uOkSp5TmkcUBhAG6LlehKrWejBSLx8KA0KnFi8G1RXchRlk4KPoxoZJoGXV4ka1K8PtLVOQWe5U0oyYJCmS4XY53expdDRjMsuDymxi+6/srzk8d6ugqAAFzeBQWvJ8RGpOzzsTFIuKyaz08NKoPDEix0F5emVJm9OVEc7RHJ63Wv4SzTjIKKw1tFxbla5nM6ZNu2vYOTPNTkwYO28wXfEIou4ToXaLYsag7HiJynzuZBljdCzBEVqbVOw6Omouj9ANgvmdBYgF0+COlbQMNimiujmK0LuzSX4nE7pVFM14RtbhZqduPb9RPhQFwXq8GLgVoqU5It9DaPp6a531xWktPV8ALKkygElZpC1ykkIBCmnJc6JoUjAkM0wqyWUorjs87+lOh+cxzSCUkrkwTaQ4EtrwAEF5Zkf7sEVqyJI0oeui1SuQOoWuFRS1gZEtbfuM8hex5qDjb6xMry7jzk0jw6Be/rK5ZLo7y1+KeYOJ1OE5Ueye1JAlaeyMmaghC9QyFPsuuyrRMVoZ2zJ4ctVp9jRaEiEE+sAA/lz8jAdBTVBMS56TY618JW2N0nlEroNibj3zVNE0FK0Hfc30T4AMw5rIWI8Z/eVFIs9FqNqmBelazCg0vevOo4LMsoBLVbSnO3k7MIyJRDJLGpcnxYjM4hKyRHL32sq+aazxARRDgy7MICtqtf6JaRrFkdFG+nHue2xH+7AVk1KUxuRJIaMI2YSe20nTdYKilLXSpCNlKG6VmoOOgaIb6+UvANFmkbFawV2YRQY+Qtd549mjTKx4TKy4TKx6rPqdHTgVcybfKTWm0WfKkbHzBvsW0ot+ktgZgwcXk1ttDiurhCvLGGN2YmO0OrZl8K3U4fmoaAOD+AvxMxQHdQ1VCKbTHpWJkZY7dy5Hq2jZDkJV0bJ5tGx+/W8yCgldpx4zOvirU0Sug1BUFNPiRdEeSlSYEKvM4SI7WGNMDVmSp0iWEk4qxCTIev/EBL+r1f0zZLu03BlSh+fjoY8MEi4uE3k+ihEvA95WLB700x6VSRG5bkdWtHSEoChk7WcrhK4LikDRDGLdWY/xGkXRUbI6enZT+UsYELkOEw+WsXtNLhnNM5w1WHICSssuE8sepWWX0rLLovtMkXGr7+vphDHPUxGzLaTYtFAmgELWYHLRRT3OM6yM2WJRNmCe23pdTP037ucnt5DUWsgZfPfAYuwxGkHc4yJjPntHMa9YcedZzBh8tTS/7YXgrc7Tmak5POvFApEGoRXvw1RiJh2IMF7k26hzzlQEQ4Z+/JLnuOO1yUO4OMZ1UO8bpLr/yWNucywKpsGU63GYwXPcpHkl3gcRVwyR6vbH2/XroahlKKr53LbONxnzpBadrCztAtuJFwFCp4rRMxD/GnSU1wlUNDOHZuY2No0iQs8hch3UVY0rxRg2GSIkEzhMyAqHqHJIVpnCOeJtSdfi3ezivk5T470u2nQej8kcJVE57G9HQ1XjBXF92XiLr04QL+gwjXgXbBnjPIui4wfE49KiTAVN2Th+IubFMu65Ehe5y9c8JeZxGYlqwni4zfnq2xivun+GsZsuQhGSHiNe4DcR8zlIBvEevGLfk48QbxR1kwe8lWPHIjHj2rgJn3GfR2MfGP/oAZw6MARAUF5Gt59WiWkc/3urAAXFZCJ01793mt4eXghGzHnGvQ76QbxAurYAbSKU7Z2nrR4zdoSguB1Ct4pmZHatpERRNZRsnjue2sjAMVVBocfE7jGw8ybnjGQZyRk4QUT5MJHRY77it92K4nC2pmbOpGYhiWFpCgMZPS15TpC8ptKja4mWPHtTZVAU9KHuXHG2LYNFP2A17L7Sna2iDwywfM8cUspY9y3bqvUBTUmOyHXQh4eaPY2UBhOFIVHg7ThDcasIRVk3C/zP8iGQtQe8ESzGRYZxMlwmBnm5yKAiKOMwIat1kbFCmfasWLBllgfEXLOn0dHYZLifnfXiTTk2BZnlbmVn/euOhb9QwV+okD25O+NFqJU831pJzvSm3dGGan35gtm5ZwqKW2BYGEhgWqYxY1JErtORFS1dKSjuVnB4NNxQsn/BYf+mclVNEYzljZrI2GNyzUl9jOYMQgnlurhYWnYpLbnMVHxa2YfDzpuUV5M1suh27LzBguNTDVIhJinsjMGM4+Ml+GXzymX0kVGE1nWXYiAVu7aC1j9E5LpE1QpqNnf8FzyNgmVwsJL2zUoKGYZIz99Wn72U9iD0qjXjFVVrWjwTAZM4TEqHHzIPspYIO4RBUWQpkuF80ceNooCFyrR0aqXSVChRpUQFN25pxi6gS4VhLEppyXNyyJqgeCsTzZ5J5yJrDs+TCZ7Haw7P3VrynBMK/aqWljwfA3WgFxQlttOzrZiUo7RHZZJEjouazx9/wzaj655iQ7eK2dd6mQRBJDm05HJoyQWWAVAEjGY3RMZLiz0UzhpGETC54lHelMk4udI6br/FvEFpOX2ATZJC3qS0nN5Uk8TOGMkbskyWMcYKiY7RytimmTo8Hwd9oObm6M/PxRIUbdPgB/PLjZ5WSp3IdUFVEVr3ma91OqFbRTVaTyiWwAweM9LjXhbWy6r70TlBNSmS5VR6uJYx+jCYkc66uDhBhQmqVOL2UGgwo2SoErBEWtGSFL3oZNCYSh2eE6NPmhioTIvkjnFl/wxCU7DGO8sddqsUNZPZ0MeRrbtA0myEqqIO9hFMxxMUi6qVGrIkTOR0ZkVLVwmKUkpCz2l6huJWiWRNOJxc8bi7VGuQKoDBrL4uMp47muN5pw1iaQozFZ/SUq0f46GqR2nFxQ13X2S08yb3TqUNXZOkkDeYXE2FmCQpZg1K1eSEcSkl3mSZvtNOT2yMVse2DL4zn5o3HQu9v/bw4C/MYY2fsK3XakIwbOqJC+PdTOS4qJbVdc683UDoOmhtEi8CLOCzKhweZqPFTk5q2GQokqVIlksZYgiLRemtZzFOUGFartTcaXf5NLZltpadmH59EsMmwwwOfjMbbnc4ozLLjKgSJniMK/tmyOwZROnSxas1h+eUY6MNDxDMxmshUVRMHg/TbPGkMFGQvo+aljy3N5HnAgJFb1+rbgnMVnxmKz73T66u/73PVCn0mhR7TE4ZzHBNbz+9plYTGVdcSisuEys1kXHVT3Z1x84bfPnJ9KKfJHaPwcMzq8ffMCU2dsbknvnkjnG4skJUWe3aDEVBrRw3FbuOjZLNIQyDIIbT85ip40QRi8HuNtHvJiLHQbHaN6ZIOTqhW8XI9zV7GjtiVQQ8zjKPs5GlbEoFm+y60Hgu/YwGFg4BJVGhLCqURIVS3WE6SbHPllnKpA+wSWKTpZRmJybK6C44lVf3zZDp0nJnqAmKh1JB8bhow4P4E5OxXmsrFrf7aa/VpBjDQmhaR7a56rx3dAxCr4pq1jIJOm2dbtENWZyu8Mh07YYW6pDTFey8STFfM3+5pNDLcFZn0Q1qAuOyVxcaj+wwHYd+U8NQFaZW0/KVpFAFjGQNSqkhS2JoQjBiJZvZ5U3WHJ6Ngp3YGK3MgK6hCcGUl57Hx0IIgd4/iD+//RVnOxVsEydyHbS+9hadUp6JjCIi322bipbt4IqIfaywj41KkowqGZMZCjKLTZZnRwXGZIYQSXldZFylLCpM4xA1KBPLllm+rZQbsq+UI1Mgw0HSBegkGY2yHBDJHWMpJZX9M9iXnJzYGK3OuGbyYCU9j4+HNjxA9d6Ht/06A8GwYjCRljwnxhgZFLMzF6C7SlAMWsCQZTdZ9SMen6/y+PzGyqSpCuy8iZ03KOZNzh2uOUy7QbSRxbha+z1b3b7DtJ03mK54BLLTJNvWYSRn4IURC05r9EDqREYtHTeMWPCSO8b+ZBlUFX2w83ppbAXbMphyPZrQlaHt0AcGCRa2LygWLIOymwqKSRI5Lspo55WvdDuhV0WoGoqmN3squ0IgIg6JVQ5tEp4UKRjGwpZZCjLLxdEIBZlFRTAlqpSpcIhaNuMkVfxtmr8oUjBKJjVkSRibDHeSnPtwCozJHD9QphPbvz+/SrDsdK3DswIUNCMted4C2tAA0dIKkeejGFu/f9mKxXIUsCLTipakGMPqSIdn6DJBMXSrGD2DzZ5GU3FDyb5Fh32LT3OYzhm1TMYek2cX+yjkjJq74KrHxIpLaaX2e6pybAGg2GMykWbOJYqdNyinxzhRihmDcuKGLCWMkVGE2p39cGzLoJSKXVtC6x+kuvfxbb/OtgzuW0pX9JMiqyjIIEhLnjuQsMsWoI9EJCRTVJkSVe5htvZHCQOY2DKLLXOcHfVzgyySRWMGp1YqXRcZS1RwxNEfToexiJC1suqURDClwhAW5bTkOTEMqTIgrWQdnvfVHZ67VFAcUY2aGVWYVr8dD2241nc7nJlDKY5t+XW2YlKK0mtxkhTIdGy82DWCopSy1mB7uDOV4Z0QRJJDyy6Hll2YrDtMA8NZnWLexM4ZPGs0z4tPHURXFKYqHqV6JmNpxaW06uHXHabtvHFYRmRK4ynkzVRQTBg7azKRuKA42bXlzgBFy2R/NS2t2Ar6wCBLP5pDSrkt8w/bMrhlKu2HkxS2biB0vWsXBTqZ0HVa0uG56QiYx2VeuDzIPKEQIKEHvdaXUWY5Uea5Uo4ygMk87obAWBcZl/FB1MqdJ6kiU0OWxCiQYQmP1RZx9e5ERmSGlYSPcWX/DEJXsez+xMZoZYqaSSnwOq5dWRKsCYrBzDz6NgTFomKmDs8Jk2YodgCR7wESJQ0Qt0QETFV8pio+d2/6+4ClYedqfRnPGMhy/Qn95HSVuapPacXjpD6LJxccsrpCJWHzl27F7jH4UWn5+BumxMbOGPxwLjmn8jWH5+zZ5yQ2RqtTsAy+mzo8bwmtfwDpeUSVVdRcfkuvyakKPbpG2UkXH5LCNsyOXW3udgK3ijUw2uxptAcClvFZZpFHxYbDdEaqFMhSlFkKZLkgGmQYiwoBZVkhIzUq+AxJkzncVFhMgNSQJXnGohxTyi4YspwwhFCVRMdpVcbTcuctow70gaoQzG5vMbmoWtzpLx5/w5RY5NDICz3todjuhG4V1bC2ld2R8kzmnYB5J+DB2Y0yuryuUswZnNRrYWl5rir28pLThtbNX0orHqXl2u8FN10l3QmCWoZiaWW22VPpaOyMQamSXPASLi0SOVWM0e50eDYUwZChUUrFri2h99dadfgL81sWFAuWwZzn40bpmn5S2LrRsavN3YyMIiLPQevykuedUhUhe1lmr9hYANWlQoEMNlmulzZZNH45PK9m/rIpk3HN/CVskPlLt2KTSQXFhBmV2UTLnaGWodit5c5Qy1B8yEt7rW4FoShog/0EM9sTFG3FTA1ZEqSAxZx0yXdoRUv3CIpe2g8nKVb8kMfmqkgJ51d9/uz7Bw4zf7HzJucMbZi/lFe8dQOYiVWXmcr2zV+6lX5LQ1ME06upEJMU/bqKqSpMOsn1avEmJwEwCt0pKI6ZBpUwYjlImz9vBX2gLijOz2GNn7Cl19iWkQq2CVPQDRQzFRQ7jdBzEIqK6BJDlt3EFxEHqJm/vIBx/lF9hCkcRurmL7bMcnE0TIEsGoIpqnWH6QolUeUpPDzS6petUiDLo6Qu2kkyGmX5gZbcMZZSUtk3w8CVpyc2RqtT1Ey+Wknbt2wVbXhgW4Jir9DIoFJOeygmxhgZyjic2OyJJET3CIpuFT3f3+xpdDR23qC0UrsYHdH8RQhGc/q60HjleC+FnAGsmb946xmNk6upU/SRKOQNpldTZ9wksbMmM46f6PnnTZYRuo420J0mUUXLoOSkgctWUTJZFNMkWNh6ZrJtGWm5c8LYhpGWPHcga4YsaUVLcvRjoqEwjUMkJJNUmRRV7q6bv4i6+UuhLjKeKfu5LiqSExqzuExQZUJWa7+psEq6OPV0FFnr2ZUasiSHkDCScIaiN7NCWPHInjyU2BitTFYoDKg6pbTkecuoQwP4h7YuchcVkxnpkab3JMcYFpMdfC3uCkFxzZDFGtzIJIhdRRHzdeouP9eJmAu4MmZ7DinAzpmUFz2O1pc4RFJa8CgtbBwMqcNwRl/PZLxgJMeLThnE1BSmK/5GyXTd/MUJ6m8sZpx/DMPBRIh7PI+2AG/nTUrL3lH/Xcb8RsedZ2jEHG+3n9O28f7srMFE1QUFopgJKmH22F9Ad7aEPjZKlIfNH6bMxzxB3fa6lG87ey7u+bLLr4t73T3e/Ugg0PoH8efnt3zvKlgGj00vHnn7mPcxGfOLK+KK8y0c2/arGoZQdr8fTqpxJU5NUDw883S3Y0ZFiXcxETEnGoTxggBFiTeeHWWPWdIsBczhMlc3f1ljVJeMRTlGoxynRnmuigYZkBbLwmVSrDKlrDJZ/1kS7vr3RVfi3Vu9MF55WtzPIQ7hUa4JYzJDGEoW1SrqEbZRYsZ9GT1e6yJNjfcZ+FG8z8CP+dmF27jPDUkLBcGkdNHVeN9ZQz328Vw5UKto6Tt14LjbboW493GiXX5dHVu3mA99KqFkSzfAuMPFjW9ix33xxpOrxz+v9b4hqnc/hNi8rX70758tLEqhe+T7VVzdI+b3Ie46XuzzOibaNt+fHVl8R0wlNJtjsEuHpb2eQmMSBT4yCp8RIKY0FrvH4O5tmoVIYLrqM131uXd6oy9jn6li502KeZOT+yyuHu+l39KZd/xaJuNqTWCcWHVZ8rpnZdrOGzyRumgnip0xOJhg/0QAr1RGL3ZnuTPUBMU751Njoe2g9w8SzM9taVtBTVBMS56To6AbzAQ+fXGfylNaltBzMPu7t1/ZbmDLLKUYWV2rwudJdYEn1YX1vxlSZTTKrQuNp/uDDMkMHiFTSoUpZZVZdZkpZYU5pdI15i+F1EU7ccaiLFMi2WO8uncGxdKwCn3JDdLCFHWDCT+NZbaDNjhItLJK5LpbWvQsqmn/xCQREkbJMJVmKLY3G4YsaeCfFIYqGMzoTCw35qK/6IYsuhUent0IODOasp7JaPcYXDiSZzijUw0iJuoZjKVVl4lVj9lqZyZuF3pM7ngqdeFKkmLG5M7Z5MQuKSV+eZLcsy5IbIxWx7YMJlKxa1vo/QNUnnxsS9sOGhoKghk3uT6g3U7RMCh5Hqc1eyIpDWWtoiXtuZ0sBbI8LhoTy3gi5KC6xEF1af1vqhQMy+y6yHihbzMS5RAIZpRVppUVptRVppQVZpRVgrhpRi1MQWZiibYpW2dsFwxZVvfPkj1xCKF0pzJc1MzU4XmbaIMDAARz8xj28ZMXbMXkviBd5E+KPgw0FGbo3PO4ewTFNDhM+QeJaQABAABJREFUlELeYMULWU0wW7AaRDy54PDkgoOsZ3HriqCQNWpCY87kmmIfY1kDCZQ3CYylVZfJVR/ZxjJjVlfoszTKy517QWo2hiIYNDQmqsmJXeH8AtJ10e2xxMZoZfp1DUNRmErFrm2h9w/iL8wjpTxubzfbMphyU+uCJCnoBmU/vRZ3GpHngCJQtJj9PFK2hC0z3K6UEtt/KCSTolb6DLWSZyGhX2YYCfO1TMZgiGeHJ2GhMS+qTKsrTCkrTCurTKkrOEfr39MmFMhyn9haVntKPMZklieUZBf5V/fNkuvS/okA45rJ11JDlm2hDdX6s29FUFSAgmIyEabxTFKMkWHmGC0+OoGuERT1XG+zp9HR2D0m5QZlJ24HP5IcWHE5sOICtdUVhbW+jCbFnMGFw3lefPIghqows+pTWnYpLXuUV2q/1/sytjiFvMFc1cdNHVkSo2AZrAYhKwm6D3ulWqPkrawadiK2ZTDtJmt604loA4NI3yOsrKLl8sfcNi13Th5bN7ivsnr8DVPaisCtohqpIUuS5KVGDp0yu5s9JwXMiyrzSpVHma7/EXLSYDSqiYx22MuzfJs+mWFZuExQoSwq607Ti3jt0cdU1kqeb1UONnsmHU1BZvm2SE4Yl5Fkdd8sI9edkdgYrYygdq9NS563h9rXC6pKMHv8BYURxSACZmV6jJNirMPLnaELBEUpJaHnYA2ONnsqHY3dY1Jqkcy5CJiq+kxVfe6Z3vh7v6kxrhvYPSanDFg8+8Q++i2N+ap/mMBYWnZZcluvL2OzRNtuws4YlBLMTgTwy2WEaaIODCQ6TquybUOWFAD0uiO4Pz+7JUHxQLU1rsediAKMGQbl9CGn4whdBy3tt50oBZllDhevFcqMBawKj73KHHvZePg2pcpImKfX66cgs5wdDTBCBpeQsqgwWRcYy6LCTN2pupXow8BE7fiH2GaSkRq9GImWPDtTS0SO37UZisOqjgJMh+m9djsIRUEb6CeYO76gWFQsSpHbxvV7rc+YzDApOvta3PmCYhggwwDVSEuek8TuMXh0prV7tSy4AcuLAQ9vmmdWVyjkayJjIW9w/mie4ZxO1Y/WBcbycs1lerbiEzXxilvIG5RXUpEgSYoZM3GxyytNohdGuzYDxraMREvKOxW9v17CsjAPe0465rZ2xuD7c2k/nKQY0nSkhJkgLdvvNEK3itk32OxpdDQ28QxZdhNXhBzUFlnaVAaoSsEoGQoyS0FmuTQaoSCzKAimRJUyG5mMU8oqfhMF04KsldgFLSZ0dhJjMsMCLq5ILgGhsm8WgNzJ3WkSVdRMSkHaviUO2uAgwezxS8VtxaQUpoYsSTKKxX10dvuJjhcUQ7eKopuI1IkxMVQBozmDiRbJUNwOFT/iyXmHJ+c3Lqa6IhjNG9g9BoW8yZUn9DKWr/VTmlrxKK3UshjLyx6TKx7+LqmMhR6T+6fSErsksTMG355ZOv6GO8AvlTGKdqJjtDK2aXBX6vC8bRQrg2Ja+MdxetaFYMjQKadZoIlhGwaTvpeu6HcYtYqWtOd20tgyy0SLC4pHIhSSEpXDxVAJg5jYMkdBZjlT9nNdVCQXasziMKlslEyXxSqru9SXsUCWchse43aiIHPJG7LsnUHN6JijPYmO06qkDs/x0YYG8A5NHHe7omrxWJA+WyaFImEYi8kOzxbvCkExDQ6TZTRv4IURC057N7Bew48kh5ZcDi1t9GUUwFBWx+6pZTOeO5Lj+acOktEVZiv1kulld11srPiNXU/TFMFwVk8NWRJEUO89l2CpqIwi/MlJcpdenNgYrYwmBCOmnjo8x0AIgdY/gL9wbEFxzNKphhFLCfYB7XZsPS137kSiusmOoptNnklnY8ssd4mZZk+jMQiYw2VOuDywKQOlB209k7Egs1wUjjCExTIek2KTyKisMofb8L6MtszylFhp7E5TDmPXHJ5PHuraipZxzeRxr7OFmKTQBgep3PfAcbezFZNvRJ2dPddMhrCIkCzQ2TFjxwuKgVtFyxy731TKzrB7TMornf1FkcBMxWem4nPf5MZKTo+pYudN7B6D8T6Ty8Z7GczqLDkBpRWX8opX68u44rJQDWJntIzmdNwwYrEFezt2CoOGhioE005yZYzB3DzS87vWkKVgpmLXTlAMk8g79rW2YBlpdmLC2LrJfi8tEeo0wtSQJXFMqTKI1fIlzztlRfg8LhZ5nA0HYEMqjNUFxjGZ5erIZjTMECLXRcbJeibjlKjuyBG0ILN8T0w14q2kHIUxmeERNVn34dV9s+RPG0l0jFamqJl8s7LQ7Gm0JcI0iJxjJ0iYKAwpBqUojWeSombI4iA7PKzoeEExdB2s/u7sPbFb2D1Gyxiy7DbLbsiyW+HR2Y3g2FQFhR5zvWT6zJOzjOQMgkhSXnHXezKWlj2mVz22YtpcSA1ZEqeYMSk7yfZq8esOz3phLMFRWhfbSr5HZSfjL8yRPe3MY25jW2YqKCZMwTD47kqyrRFSdp9aRUtqyJIkBTIs4lHZpdLfVsITEQfECgfYyBxUpGBYWvVMxhwXREO8QJ6AgcKMcNZLpdcER2cL/fosqTKAmZY8J4giBSMyk2iGogwjKvtnGXvBOYmN0cpYQmFI0zmUVgPEIpidQx86dj9gWzFZigJWZLrInxRjsvMdnqHDBcUoCJChnxqyJEyhx+TOQ+nD1RpuKNm/4LB/wVkvY1EFDOcM7LoBzMWFHl58uoGuKkyvepRXNkqmyyseztNKpu1894q2u8VuODx7pTIiY6H29yU6TquSOjzHJ/I8wuUl9IFjuz0WLJ17F9N+OEmhIRjRdEp+ej3uNALXwejpb/Y0Ohpbtr4hy24SCcmUqDJFlXupGXAgay7NYzKLHeU4OerlSlmgH5MF3I1MRmWVsqgwJ4PDSqbHqJmFVBM0C+l2hqVFgGSe5O4D1fIikRd2rcOzrRkshgGrqdgVi2B2Fu04gmJRNdPsxIQZxWJ/F7Sf6GhBMfSqKLqBUNVmT6VjEUChizMUt0ooYXKlZuJyd3njwtJvadh5g0KPyckDGZ59Yj/9lsZ8td6XsZ7RuKfX5LsHU9E2SeyMwePLya4i+eVJjEKha0vqbMvgh4udf2NNgrXeiccXFA2+PJlsGVY3M6bruDJiMUwfcjqJNUMWzexew6zdwJZZyqSC4jERsIjHovB4VFlY/7Ml1fVy6YLMcXY4wIjM4BLWMhmpUhIVRmXnGwA0mzGZZUpUGt77cjPrDs8ndaegWNRMJoL02TIuwcwc1llnHHMbW7EoRekxTpIxMnyf6WZPI3E6W1BMDVkSZyirI6j1F0zZPgtOwIIT8NDMRoCd0RQK9UzGQt7gvNE8ozmdl501xMV2D+V6uXR5pVYyvUsm0x1PMWNy+/Ti8TfcAV6pjHnSCYmO0crYlkGpnAYvcfDnaw8XxuDRHy7ymkqPrjGZZoEmhm2YlI7TxzKl/YgCDyKJYqQlz0lSkFke2iSSpWwdR4TsE8vsq5sFAqhSMBTlsGWWgsxwaTTMHnIIBL8YnENZVDcMYKjiplmLDaEgk3fRXt03i5Y3MYa70wdgXDeZSCsBYiGlrGcoXnnM7WzF5Pv+wu5MqgvRpcIAZlcs8HSBoJg98j/GFGF20CN5V4kbM2z3dcWswdSyh3AhTh6oEreNTtxVwZifn1Rivi7GQakGEXsXHfYu1tLQBzMav3LFCfy/e0qM5kzsvMFl470U8gaqIpiql0yXll0OBh6lqou7lcaMm4j07c8TIDLivS42MRscHu9oZFSFfkPjkOsRbfrMIj3eCXOk64SMIoLJKXquvPyo1xHpxjvRRLS7GY9xmgv3aioZVaHs+dv+/sZuZrzbiaAxz8+ttBMLZmYRmoaW6VnfPnqaGW0hazDr+ThCHvOCHMVM2pdavO9D3OsnMc7ruK3ZRLi1sey8Sbnqo1Rrb2q3v3uxnb1Sjsla/8SjZo/vcsxo6PGCOD+I9+VWlXgXL7mN96dJwQgZJqhs63WbqfrxghVHxHvcES0e9IdCMqstM8sy99f/9hb3fH6oTlERAWMyyxmyh2vDAr0YzOMwqVSYFKssGYtMqyusiO25TIdRvAt6FPOGHMYMANyY3wW5hfFGoxz3i/nDvm+6Ee87FB7lBrmyd5bsScNEqEe8/ix78dzoZRjv84v7nRUx46KiZnD76uL2r70xb8lxv+oiiDdg7EvLFuKwcHEZ6Qfog0Mbx1955uts1aTkO4gj/Nv6PI/xb8ecphrvg497zd3K97aRbGWeo5g4MmRV+KyFFp0aM3a8oGj0dmeq+G5R6DUpLaXZGkli502mVj0OLtV+1hDAQEbDztcyGU8fzHBtbz99hsas41OqeJQqLhP134teujJ9NIqWwbwXUI2Ss2QJZmaRQYBR6E6H56JlMO35BHGj0i7Hm59F7x9CiKM/DBTSHpWJY5sGD62kJZudRug6aUVLwoxSK89dJL1GJYUiBcNkeFJdZEG4PMzc+r9lpcaozFKIcozKLOe7gwxEWVwRMKOsMK2u1H+vMq9UiFpcTG0asmYu9BUOJTpMZf8sPed0ZwsGAdhpyXNsgplaRcuxTFn6hEYGlcm05Dkx1g1ZuqDLVccKilEYEgV+6tiXMHavwYPl1AAgSY7moi2BuWrAXDXggenaZ+DnIKcpFLImxaxBMWtwwWCekYyOG0ZMrNbExVLFY6LiMu34ack0a2Yhyd5UvTWHZ7tLHZ7NVOzaCf787PH7J5oGZTc9xklSMA1um11o9jRSGkzoVtFzvc2eRkdjyywlku071+2MyAw+EQtHMAupiIB9Yol9Sq0fd4/poEqFoSjLSJhnJMxzvl9k2MmhojCrrDKtrgmNq8yoK3hpyTQ96GTQmCQ5MwsZRlQOzDH2kgsSG6OVGVQ1NCGYCtJ4Jg7+bE1Q1IaPHjPaisWM9PDTsofEGCXDpOj8cmfoYEExdKsomo6iduxbbAkKvSZffTQ1AEiSQt7ksdmtZ8SsBhFPLFV5YmnjIqYJwVhWx64LjVeO9lLIGqhCMFn1mHBqmYwTVY9y1cXpMpWxaJlMJCx2eeUySi6L2tOT6Ditim2ZlFNBMTb+wizZU8485ja2ZfDITJo9lxSWIhjQtVS07TCklIRuFWuwOxd7dgub1OE5abZrFhKKiCl1hSl1k1mahD5prYuMJwWDXBaeSF6aLIoqU2tCo7LKlLLCivC6SiQukGEOFz9uLe8WqB6aR/ohuZOHExujlSnqJpOBRypfxyOYnUXt7UExjt6XqqiYTKQOz4kyJjM8KBaaPY1doWPVttBLDVmSptdSsTSFqeX04SpJCnmDb+7fmWgbSMmhVY9Dq4eXTA+aGnbWpNBjcGZvhueO1UumXZ9S1WOiWi+Zrros+J17a7czBg9NJfug45e62+G5aBrcvZA6PMdBygh/fhbjkqOvNgugYOppFmiCFEyDRT+gkmBrhJTdRwY+MgpRU0OWRLFllu+KqWZPo6MZk1kmlR3GMgIWhcOi4vC4PrP+50ykMxzlGQryjER5zgxGGIyyeARMqatMKzWRcVpZYU6pdmzJtE090zZB1hyesyd3Z9uucc3kUGrIEptgdg5t6NjnTurwnDyjZPi6KDV7GrtC5wqKqcNz4ti9JjOrPkGXZbPtJjldpdfUmFxpvEgggVk3YNYNuHdlo2w9qyrYGYNi1qSYMbigP8+oVSuZromMNaGxVPUoRx7b9H9pORRqQkHiJc/lMtappyQ6RquiChgxdUppZlcswpVlZBCg9x89QBwyamYFs56/W9PqOgqmQTl1eO44AreKYlgIJa57UMrxEBLGyKQZigkzFuW4V51OZN9VxeeAMs8+ZXH9b2su0yNRjpEozwV+geEoh4bCrFJZFxmn1FWmlNWOcJkuyAzlhMsYV/fPoPVm0PuPYiza4RR1k71+d5SKJoE/M4t2jP6JALawuCda2qUZdR8ZqdKLUeuh2AV0tKBo5AeaPY2OpmbIkq5uJEkhbzBb8bft2rwTKmHEEysOT6xspMJrQjBm6diZmsh4+VAPxYxZ63Hiekw4HhNuPaPR9aiG7ZPBM2LqhFIy68W1HD8+Mgzxp6bpvebZiY3RyowZBl4UseAnd4w7GW++3mD7GD0UbdNg0vXjGk2nbAE77VHZkYReFS1dgE6UYWrZn7MJ9p3remQ9Q3EXRdtQyE0l05Pr8+iTVk1kDPOcEPZziT9Or7RYFE69VHqVabVWMr20TZfpZlMgw93MJjpGZe8MuZOHureiRTf4VmXx+BumHJFgdpbMWWcc9d8VYEwxKKUlz4kxSoZFPJwOWETZCh0pKMooJPK91JAlYQq9Bvvn0otRktg9BqWV5ou2gZQcqnocqh7+MN2X0xi3DIqWyWlZi2sHexk0dOa9oNaX0fEoObUejXN+0JKtf8czJmXXS3Ru/vQ0hCG63Z0Oz3bqPrwj/HVB8egrzrZlpD0qE6ZgGNy1lJbtdxqh66Bn882eRkdjyyxlqsju1Ed2hT5MdBRmmm0CsLlkWtsQ3gypMxLmGK1nNJ7uDTEUZQiI1rMY1/oyzioVwhYsmdalYAiLcsJZR5X9s/Q964REx2hVDCEYUvXU4TkmkecRLi0fs+R5VJiESOZkWtGSFKNrDs9dQkcKiqHrIFQNRdObPZWOxu41+d6+dAUpSQp5M5Fy50Yx7wfM+wH3L2+siGcUBdsyKFoG45bJuT1ZxkyDQMp1cbGWzehRdj0C2dyg0bYMJqrJHmN3734AjEJ3CopFy0jLnXeAPz+Lmu9F0Y/eYLtgGeyrpAs8SWKb6XnciYRuFWtgpNnT6GhSQ5bkKURZZkS1JYU4AEcEHNAWOcDhJdODUXZdZDzXH+X66BQMVOaUClPKKpOi9ntKWaUqmlvlMEqGKiFLJCfE+IsVqgfnsV9+UWJjtDK2ZrIahSxH3ZHZ1WiC2TkA9GMIirZiUo7clkzy6BTGusjhGTpWUEz7JyZNRlfoy2iUl9KHqyQp5A3unVxu9jS2RTWKeLLi8OQmcUMVMGrUREbbMrioN89LRw0yqsK069cERsetC44ey8HuBRJFy+C+pdXjbxgTf3aOuc99geyF56Pmc4mN08rYpsE9CR7jTsefn8U4Rrkz1Pr7fXcu7YeTFD2qSkZVmEwFxY4iCnxkGKAaacyYJLbMcq+Ya/Y0OprdLnduBKGQTKu18ud1JPRIc11kLIY9XBQUGJAWK8JjUqyul01PKRXmxe5lvhbIUmbrLtrbRUaSR/7wS6h5k+Frj16y2skUdYOJIL3PxiWYrWUFa8PHqGhRLCZSQ5ZEGZMZfiBmjr9hh9CRgmKQCoqJU+g1ma/4OEHasSspdEUwnNUpdYCLdiih5Hq17J5NSa19mlrPZjTZY5lc0d/DiGmwHATr5dKH6kLjdEL94WzL4JapnbloHw0ZBEz9/SdRMhbDb3xdImO0A0XL5ObpZI5xN+DNz2IMDh/133UhGDK0NHsuQWzTYM4P8JqcUZ3SWEK3iqKbqSFLkshahuKXxcFmz6SjGZM59okOWFQSsCxclhWXJ5gjjGrfTUOqjNSzGUejHJcHRYajmmnJdD2bcaqezTijJLOAWZCZRMudD3z6e8zftY/z//C1GEPd2YahqJtMpA7PsfFn5hC6htrTc9RtiorFI2HaviUxZC2beSrNUGxvQq+Kke9r9jQ6GrvXoJRmJybKWN6g6kcse52b9r8YhCyuVHl4ZeOiayqCglnLZixaJtcO9mFbBgIoO/5GJmPVo+S4ODtwGe/RVHKamlh/v7nPfQHv0ATFd7wNNdudbn09qkpWVdL+fjvAX5gld+qZR/33gmVQDaNdzeztNgqpIUtHkla0JE8/BgZKV/WTagZjUZbv6aVmTyMxPBFySF3mkLpRtSMkDMrMush4ejjA1f4e8hjM4lCmQllUKYsKZaos4u0ou7BAhrsSyjpauPsp9v/9tzjhTVcxcNnJiYzRDoxrJt9JDVliE8zOog0NHXORzFZMvu53T/bcbtOLjonKdBfd8zpOUJRRROS5qSFLwhR6Tcqpw3OiFPIG5RYwZNlt3Eiyv+qyv+oCtcBRAMOGTtGslUyflc/y3JF++nWNWc+nVK07TTsuE1WP+S26CRctg1nPx9uBKHk0Vu++l6Vv3sHQa16JedKJW3pNMDuHOtDfUdkytmUw69Uyu9J+/Nsn8j3CleVjOjwX0t5+iVMw9fQYdyCB66BlunOxZ7ewyTKN07K9/TqBjNTow2SqzUqed4oUMCuqzCpVHmJDIMlJnR63j4LMMkaGC6JBhrBwCZmkQklU62JjZevnplwreW68SODNr/Lwh75I34V7OOmnrt7ya1RLR80cvbdyO1LUjTRDcQf4M7NoQ0cvd7ZQGFQMSmnJc2KMkmEOl6CL7nkdJyiGnoNQVISaGrIkSaHX4L6J9urt124U8ialFjZk2U0kMO35TDs+9yxulLJkVaWWyZgxKVoG5/dmGbMMvEhSqouLa30Zy84zDWBsy2Aigcw5f2aG6U99ltxFF9LznGu29JrF277O3Oe+gJLNYJ15GtbZZ2CddTra2AhCtK8Ulxqy7IwNh+ejlzynLtrJY5sGj66mWROdRuhVMfuP3Z80ZWfYMjVkSZpRmWUBF0ekWeoAq8JnUizx+KYScE0KRshgyywFMlwihynIDDoK0zi1TEYqlKhSpkrlaQYw/Rjr2zYSGUY8/KEvgpSc/Ts3IdTjLyiv7p3m7rf/M9IL6TnHpu+iE+m7+CR6zimi6GpD57ebDKoahlAoB35ifSo7nWB2lsxZR69osRWTxchnlfRakRRjMsNkF2UnQicKivXyleM9gMcWjWP2TxIxm7/FbjQc83VyC4lRuioYzumUVrz17ePGMEpMwzYRM6NMKvEOjIx5f4528DnYeYPvHVxiOzZcaswFp6187kckblPDuMflaZ/DKhGPOQ6POYcbwIxtMoC5eCDPS826AYznr2cyllyPE3MWBx039ud7JCLfZ/rvPomWyzP6itejVo+/89VHHmLuv75Iz9XPRu3pofrYY8x99nMQRah9fWTOOJ3MeeeSu+hZR7y2hZl4H4RaifnBb+Pzsy2DkuuC2MH1LC4xr/Oxr0sxr4PHuh/5czVB0ewfesZ2a+MVDIN7Fle2PL404h2YSG/91VbFi3dOa8eI/QS1Yzy95KE97Vky7me+2/f2lGcShQEy8NG2YMiy2zFjXCwjnvusEvNiGW3hhCxGWZ5UFtHUjftUEMb7nkYxvzgybjAWE1PbvYf1IFIYCXOURYUg2vpxXXLiVXJlYp5jfhgv0Kp48RJEnh4qhULWshLZJG7LmlA4JrPYZDhR5rlCjjCIxbL0KIsKk/WS6SwqM7KK0MIjPjx7Md/f/n/6Pov3HOCMD74RPz+Af5y1wWC5ysO/9zksu5/Cy57F4t1PUfrcjzjwj99BsXR6zx+n7+KTKLzsWWg58xmvN3LxFh+9uXjnizS2Hp/ahs5U6BEYYex7nXDiXVtEuLvXCKnFfI49xjRlFBHMzaENDz1ju6haO2vHrCwTgUdY3ZoE1NsXTxhTYt40417js0a881rGHG/ZeeZ3a40RspRxCI5wTejUmLFjBcWU5Cj0GKx6IctuurqRFIJaD8XScpqSvl1CSc01+ggGMEWrlsm4ZgAzbOicnrM4LWvVnaZrGY2TrhdbK539/OfwpibZ89Z3oFrHvxZ501NMfvqTZM88h6HXvhqhKAy85EYi18V54kmqjz2G88hjrPzgLtRs9pgrj62IbRrcmzo8x8ZfmEVoGmr+6A227YzBzeU0QzEpBgwNRQhm3HgP0imtSc2QxUCo7ZvR0w4UZJZvi87t7dcKFGSWcpoFun0ELOCxIDweYQGoCSGGVBiT2VrJtMzwbDlGQeYQwFuCc5mkwqSorAuObkyVYOlHeyl/6g7sN19Hz0UnH3d7GUbs/cP/IKy4XPDHr8Mq9GG//GJkGLH65DQLP9rP4o/289Tf34EzMc/pv3ZjrHk1i6JqcihIn3viEi4tI/0AbfjoWfdF1WQiPcaJMkaGh+kAg6xt0JGCojkw2uxpdDSFHpNyBzgPtzJDWR0BzFbTB9hGUTOAqfDQSi3o1oTgQ2efzKcPTdGjaRQtg6sHerEtA1UIJh2PCc9dFycnXJdKdGyZcflHP2Tpu99h5FU/jlkcP+6cIseh9Mn/D7Wnl7E3vBk29U5UTJPsueeQPfccpJQceP8fUHnwobYSFFVgNO3vtyP8+Vn0/qGjZt3ntdT0JmkKGYNp1yds/QTNlG0QulXULWQnpsQnKzV6MSiLdFEpSQoyy0PKfLOn0TF4IuKAWOEAG064r/NPZ1ZUKStVCjLL6bKPayKbXgzmcZkUayJjLaNxAfeY2UH+7DL7//g/6bnoFAqv31rfxEN/dxvL9+7njA+9CauwYT4qVIX8GWPkzxhjz+uuYO8nbmPmG48gpWyrljnjmsmBVOyKTTBbq2g5Vg/FombybSdt35IUAhjFSkue2xkpI0LPTTMUE6bm8Jxe8JOkkDeYXPVIwCskpU7B1HGiiAdWDr/oC2BQ1yha/3/2/jtOkvu878Tflas6Te40u4sM7AKLHAkQIEiAOZMSZZISJZmSLOkn6WSf7nT2S2fp5zufbVk+3+ns89k8WclUoBhEkSIYQRAAkeNiF7vAApuwMz15emY6VfzeHz07swvs7EzXTE38vl+vfi3QU+Hb1dVVT32+z/N8LEopg8tSDnf3dNFrGFT9gGG3LTJW5v8d930E4I2NMf6VL5O54UZyt96x7P5FFDHy1/+NcG6WXb/6m2i2Q7hE2ZmiKKT27aN5+DB8/KNr8OnXhwHLIIjEik1yJG/Fm57EXKZ/4pQX4K9zaeVOomCbjErBdtvRrmiRhixJUhJppmjhxe37I1kWTSj0Y8sMxYQp4vC0OsZxdZZDTC28nxI6BeFQECkKIsVVUQ8D2ASIc0TGURqMKU18JUKEESd+/29RdJWL/4ePrKhv4uT3DzD2t0+x+1feQ/a6i4ClEw56br2U4a88S+PEBOlLBtbi468LZc3iidbOyuxaS4KJ5QXFkmZRkaJtYvRitROC2FnHeFsJiqHngqqg6tKQJUmKWYtHj1c3ehjbmpLMAk2csm2d15BFAJN+wKQfcKC5KNI4qkrJMilbFmXL5Kp0N0XTRACVlstrYxVOfPxjNG57G6OBoLWMGjz1/W/TeOUwpZ/9BcyB5bOqnb1XMff4E/iTkxh9W8NEoGRZjLhe3FaGEtoZiunLrlry79KQJXmKjslIUx7j7UbotjBzSz94SVaPLMVNnjwOHhEzyGtUUlhCoweb0fOcyw0l4Lgyx3EWjSpVoTCAvVA2fU3Uw7vEICl0Jmlx4uRJjuy7He+XL2a2K82s8C6YzVg/MsSpP3yAvvfeQP+Hbl52vLlrd6HaBtNPHdsygqKBwoBmMhzuLCFmLfEnp9ByOVTz/M7f3aqOraiMhPJakRRFbMZoxW6btVXZXoKi20Q3lzdkkcRHVSCfNRmRvf0SpZgxeWVCBuFJUrI6c3huRhHHmi2ONRddGVRgwDRIP/8cJQXueO972ZXL0aXrTHo+lfm+jMOuS6XlMeUHCGDuwAtM//D79L3vQ6Sv2rei/TtXXQmqSvPwEYy3r8w5eqMpy3LnVSFEhF+dwuhZWkAu2qYsd06Yom3ywlRt+QUlW4YoDIkCT1a0JExRpBhRZblzkiyItvLRJzEKwmEO7y3Oz0sRKYJRmowqTQ7QzhpDQAaD7KtV7EdPse9dt3Pxrj30+TYu4Vk9GRuMKe1sxlAReJNzHPtfv0LqihK7f/U9K3rGVU2drut3M/30cXb91O2r+ejrRkm3aIqImUhWtMQlmJhctn/iWOgRyGn+xCjgMLrGTvBbgW0nKMrgMFkGMiZhJJhuyAt+kpSyJg8dl/1wkqRsmzxTnVt+wQsQAUcfe4zxL/0VA5/6KX48MQ0T02TQ2pmMtknJMtmfTZG3TIJIMDw3xyun0lQ+/wvU9t/AiOvjraBcVbVt7EsuoXn4CLktIiiWbJNDc/JhMi7B3CwiDDC7lw4QS47J4Tk5+ZAUmgIDtiFLnrcZoddE0Q1UbVuFwZuOYpTmBX1io4exrZFZoMlTWItjrMDU+CSP/d7/S/rKMscu2ouiHsQABubNXwoixQ1RPwWRwkRjgiZHXzvE3g98iPBDe5nUBTXhr0g87rn1Eo7/px8SNDz01Pkz1jYTbUOWnSfErCXBxCR6fukWOWXdkhmgCVPAZoiddz3eVpFU6Daxupb+IUlWTylrMjLryrmNBMmYGilDY7QuH2CTpGybbSfoVeCNjDDxta+QveVWcrfctvB+PYw42mhytLHYn1ED+sIA+7GHuOTSy7jr3rcz6NikNJVJP6DScjkdzhvB+B7TwVtFe2ffXqrf/R4iCFD0zX/5Llkm35+Qwnhc/Ol2ZsNSGYoqkLcMKrIcNzH6z/QB9eQk2nYidJvocgI6UUyh0octDVkSpiBSPKeOb/QwtjVFkWJUWZ3JgghCTvzrr6JaBhf99x9BUduqYKAIKkqdCmf9TgTkhIHyt4for2lc9+F7GLT76PUtGgSMKg0moxrjap0xtc6k2iRSzn0y67ntUo79hx8w8/xJ+u66YlVjXw+k2LV6/MkpnH1Lt8iRDs/JU8Dh2bN6rO4UNv8T6QoRQhB6LZmhmDClnEVF9vZLlGLWZKrh40lL0cToMXRMVWXUje+iHbkuI//tzzD6+uj/2CeWXT4IQ577o/8Hf3yM16+9mR+dHgUgq2mUbJOyZVJKm9yYzpA3DDwRMex58y+XYc8juuZqpr/597ReP7bp3Z7TmkqXocuS51XgVecFxe7z93nrs4x2z09PusEnRXHekEVejbcXbYdne6OHsa0pihRzeNRXWCYqiYGQGYrrQQGHx5XRVW1j+E8fon60wpX/5mfQc8uYQSnw2td/zOn/9/tc/D98hNd7hoAhDKGSn89kHMTmuqDIQJRCR2VSbTKu1BnX2iLjeNHAHuxh+uljW0JQHNQsnnal+3BcItclmptDv0CP9bJu8by3usosydLoKPRh7TiHZ9hGgmLkuYCCamz+tO6tTDFn8txpeTFKklLWolKTIkySlC2TMdcniOmMK4Rg/GtfIahOs+s3fnPJBshnM/HNv6V16iSDv/ArGN09C+/PhSFz9Sav1puE8yYwuqJQMAzKpsWg0RYZP9hjkSoNUvlP/4nTc3NMdHVT8TyGPI9psfkEpZJlMun5uNKqPDb+9CR6Nrfkfa1om4y1fCl2JUjRkQ7P25HQbWFmujd6GNuaokhLoStherDQUJjYgT271gtFQF44qzqXZ554lbGvPsHgL9xPet+uZZefff44p//fH5D/5B30vnP/wvu+EjGk1BmizmFjPu4T0CUsBqI0+ShNOcxxvV+kRzj89B9czYljx3HdHsa1BuNqnUkUwk0YNZR1i6GGzJ6LSzDZzopbqoeiBhQ0U2YoJsgANj4RMxdwYN+ubBtBsd0/0ZaGLAmi0HZ4Hpmd3OihbGuKGZMRKSgmStk2GW7Fu6mKMGT6wR9Qe+5Z8p/+LGa+sOw6M089zswTP2bg4z+Jc/Glyy4fCMHQvFj49Fnvd2ka6cefpGwY7Hv3u7k5nSVvGDSjiIrvMey7DM2XTI/4Hn5MwXQtKNmWzE5cJf70JMaF+idKh+fEKdgmx2o7b7Z5OyOikMh3ZUVLwrQz52S5c5IUojTjvLXcVbJ29NLOZJ6KKdrWDp7i5P/+DbruuJKBj9227PJuZZrj/+pr5G68hMGfu3f5HSgwo7jMqC6vnVVqaQgN+3gV8fBxbr30fdyQLjIQpVE1hTFcKqLFsGhSof1vnTDW51sLulUdR1EZCWQ8E5dFQfH8FS0FzcIXgqlo54ld60UBe0dmJ8I2EhQDTxqyJE1PSkdTYFz29kuUYtbk+RGZBZokZdviZLPz4LB5/BgTX/sq3ugIPffdT/bGm5Zf58Qxxv/uq3TdcRddt70tznAXmAlDhk2DH//Jn7H74j3oPT0YikLeNBg0TcqGxS3pLGXDwlFVxgN/QWA805uxGq5P+VnZkmLXavGrUxi9S/cFLtomx+syMyVJio7JYxOzGz0MyRoSui0UTUfVjY0eyramKFK8qlU3ehjbmjUxC5FckKJIMaY0ER3mq/jTNYb+64NMP/gS6X272PObH1o26SVsuLz+L/4GPZfi4t/+GIqmxh63r4S0rrB56rd/wCsXuQz+5K0gIJzto6TYlBSHS5Q0dyp99CkWs8Jvi4w0F8TGcVyi2CNYOWfch2W9RXz8iUkUw0DLZs/797JuUgmlB0KS7FSHZ9hGgmLoNrGy51flJWtDKWsxVvORFYzJYWoKvSlDljwnTMk2eXx65SJBUJtj6lt/z9wzT2Pt3sOuX//vsHbtXnY9vzrNyBf/BHvPxfR/6GOrGPEi9pVXgqrSePkIubvehi8Ep32X074LLArRXZrGoGFRNi3Khsmt6SwD+mI245DvMmL4DLsuI6so/16Kkm1yuCYfdFaDNz1B+rKlG2yXbJPHJqXYlRSGqtBnGYxI05ttRSgnoBNHEwoDwpEZiglTFCmOKvIekCRFkWKkA9dWEUZMPPAclT97CDSVPb/xQXrfff2CCcuS60WCE//uG3jjc+z99z+Lnll9j1fNMui6fjfTTx9rC4oKTOIxKTwOisXzxkKlRFtkLCs2d6l9FLHRUBjFpSKavOEEDAceQ4FLXaxtNqM0ZFk9weQken/vkqJ1SZPHOGkK2BxlZ16Pt4WgKIQgdFto/TJATJK2IYu8GCVJIWNS90Jq3saVHmx3LFWh3zQYXkH2nIgiZp98gqlvfwuAgU/8BNnbbkdRl581jjyPkT//YxTdoPSZn0XRtFWPHUBLOVgXX0Tz8GFydy2d8TgThsyEDV5uLQbChqJQNEzKhknZtLi5K8OHrV5sVWXc86m4HsOux3DLo+K6VIN456EKFM3Vu2jvZCLPJazXlix5Ns+IXTILNDEKtknND6nF/B1INiehKw38kiYvHDwiqsjrU5IUojSPaCMbPYxtTUE4HFVWZhZSPzLEG//3t2m+PkLfe2+g/HPvXN6AZZ7KXzzCzBOvctk//0ns3UtXJnRK962XcOILPyJsemjO+fsxu0ScoMEJ0eBMCpsC9GJSns9mvMxMc3eqm37NZCYMGA7chddQ4DIWerGLpqX78OoJJibR+5Y+b8q6xcuenOBJkgI2jzC20cPYELaHoOj6gEDTLZSV5mbHTLOL26ZE9WOaP8TUICJ97XtJFnMmr4wtMUsXMys/ijlMpdPagzPE/P6imL+UTr+/Qs5ipOYRxvQWCjLx1ov7+eKut97tfpSzopyybTLrB9T9kAudRa2hNxj7+pdxh98gd9Nt9L/7Q+jpDCt5PooUwdhX/hpvfIzdv/Tr6E6GlURaKzXDTF21l+qDD0IrQNF1WGHlXiAEp12X0247m1Fttn+4XbpGyTIpWxZl2+SmXIYB08CNIiqu1xYaW22xcdT1CJZxIB+wDCIEUy3/nGMc92e74uv6Bq8X9/pyvuuEWx0HwOjrO+/fCymTWhAyJ8J2t+0OCFPrUcS0iBLG++JVv/P1Yn935+GMw/MFiXuOxb2FreReK6sIlkSJIGw1sXuynZ0r6x0zxlxRjfnlxz0ftSX2VybFqNJAU5cYjxbvhyNi3kSUpcaR0P7ifn+dkBI6WUyqxhyW0rmUY2jx5B8/jPdgEoTxy3fjELfoInzTd14QKX6kjBBe4IElmGsy8qc/ZOq7z2FfUuSy3/95Unvb5ivLzUcpimDmx4cZ+YtHKX7unaRvuWrZdQA8ZWUBeOamKxD+g0w8O0TPHVcgVvjgJYAJfCbwOcAcftUCwFJUyrpJWbcY1C3e7nRT0i10RWF0PoPxbLGx7ixfAjpomrzgTaM5ZwXBMa9JUdOKuWK81eKOc0X38vOtZ5z/xPbHJ3Cu3Ycwz//3kmbxg3Cq4/E6Rryei3Gvga0g3oNlGMU7oEHM9d78+Syh0oPFOM0Lf/bNFjOu0a1qWwiKod9EM6UhS9KUshYPvTa90cPY1pSyJpWanKVLkpJtXbC3X9hsMPm9bzHz9OOY+SK7f+HXcfZc0tE+ph76HrUDz1P8B5/DKg2udshvIbV3L9MPPEDrxAmcyy9f9fZmgpCZoMmR+mIzYV1RKJgGZdukZFncmMvwQcvE0VQmPJ9Ky2PkTDZjy2PaXwwEy5bJSMuTusYqaBw7iqLrS54/RWnIkjhFR5Y7bzdEFBH6LTRTZigmSSFKM6rKbJgkyUdpppUWbgwxUbIyUkInh8noEiXPIhJM/+BFKn/yICIIKf3i++h7/80d9T5sHB3mjf/j7+i6+2oGfuLOtRr6AvZgL1apm5lnXqfnjitWvT1XRBz3Wxz3F4VCBejVDAZ1i7Jucolhc5fTxYBuMicChqPWOa/RyFtwmtZQyCsWQ5F89olLMDVNMD6BddnF5/27o6j0aoYseU6QPA5z+DRWmhmyzdgWgmLgtbAcGRwmSdbScEyV0Tn5cJUkxYzJY2+srLRCEo+2w/Nbz2MhBHPPP8PEd76BCHz63/9Rem69q6NSZRFFjH/761SfeIS++95Pdv8NazjyRczyIFo2S+PI4TURFM9HIARDrseQ6wG1hfdzusagYVKyTUqWyXW5DHnLwIsElZbLiOvRa+jMBSGmquDJpquxqL92hNTFl6Ma509XLjqmdNFOmKJtcqAqRZHtROi7KKomDVkSpihSPKuObvQwtjUFkWJU9qhMlCIOU7i450lnbh4fZeg/PUDj8Gm6791P8effjdHTWZnQ7DNHeeP3v4J9UZ7dv/HhxBJjum65jOpTryHWuFf2GQQwGfpMhj4HztKsLEWhnNUoqzZl1eZteg9l1cZAZVS4DEct6iIkICKSU9CxaR56BVQVZ9/5BeOSblINfRpifatTdhI72eEZtomgGLlNtG5pyJIkpZzFZN3Hl+JAYqgKFNImFSnaJkrJNnl08lzR1h0ZZuwbX6F18jiZ625k4H0fQc91dVQSF/keI1/5IrXDBxn48Cfpvv2uNR75Ioqi4Fx1FY0jR+j70IcT28/5mA1Cam6TV2qLN05NgYLVFhhLtskux8ZQFP7lvkuYcNu9GSstj2HXpdLymPIDGTpegMh1aZ46xsC7l/5ui47JszO1Jf8uWT0Fx2SkIrPytxOh18QwHVnRkiCKgLx0H06cdhaoPMZJcj5DlrDhMvrFHzHxzaexBvu49H/7aTLXXtxxefzUd55j6D99i9ytV7Dntz6Oaic3ydF1y6WMfeNZWqenoDud2H7ejCsEJ6MmJ6NzhZZexaCs2pRUm/1aBgWF33WupEHIcNSiErkL2YwjwkVGjBemefAI1qUXoabOn1wlTW+Sp+3wLAXFLY0sX0meUs6kMisvRknS5xgIYKrpr7gnnqQzFNqC4pkMxchtMfngd6g+/ghGbz+DP/8rpC7rvCQkrNcY+ov/ijsyRPnTP0/66v1rPPK3ktq7l9ozzxBUp9EGuhPf34UIBe0eiy0PZuD6rgx//sYoY65PyTbbZdO2yTW5FAXLJBSCSstbFBrnMxtbcsICgMbxo4gwJH3FviWXKdomlVE5+ZAUKU0lZ+jL91CUbClCr4Wd7droYWxreoWNgsKksnMfrtaDvEjxsjKx0cPY1hRJMTp/HgshqD58iMoffZ+w4VL82Xcx8JHbUPTOekoKIRj94kOMf+lRej9wC4O/9J6OSqTjkL3uIhRDY+aZ17Hu353ovlbClPCZCn0OhnM4isrJqMk3vVGK85mMJdXiVr2bsmpjozImXIYjl8qZsmnhUhXxevttN0QQ0DryGl3ve+eSy5QNi+FQxjJJUsDhBaY2ehgbxrYQFEUk0MyYTVglK6KYtXijunxjXUl8Stm2IYuUVJKj3zRQgKFTJ2mcOsnkg98hajXpu+999Nx1b9vgpEO8qQmG/vwLRK0mu37+V3F2XbQu36Fz5VWgKDSOvEJ24PZ12OPKcDSVbkOn0vJoRhFH602OzvdmFErbvylvGZTmDWCuzqa4r7+bLkNnylvMZjxjBDPp+TvuN1F/7QhGTx9m38B5/57VNRxNZVSWPCdG0TGpegGuFLm3FaHXRDcLGz2MbU1BpBlTGrFNuCTLowuFPuHIDMWEKQqHA7OnmT16lImvP0ntwAm67txL6RfejTnQ+cRE5IcM/YdvUP3hSxR/7j76P/42lHXwqtFsg+y1e5h5+nXy99+b/A47YFC1eSGYxUNwKmpy6kw24/z1o1vR207T82LjzXoXA4qFSzSfzdhiOHIZFi1GIped9qTqvn4C4bo41+xdcpmSbvJjt7p+g9ppiHbJ85jMUNzaaKaJsh5X5B1MKWfy1CnZ2y9JihmTEWnIsmZEnoc/MYY3Otp+jY1Q2rObk+p9nPi//gCA9L79DHzgYxg98VomNE+fZPiLf4RqO+z+xd/A7O1fy49wQbRUCuuii2i8coTs3ZtHUCxZJtNeQDM6f714BIy4PiOuz/Ozi++nNHWhZLpkmVyV6aZotVN1R9y2CUyl5c7/69EIt2cvGCEE9deOXDA7seSYTHkBfkL9kCRQsE0q0pBl2xF6HpolK1qSpCh7+yXOgEjRImAOL67JrOQsRBjhjVVx35igdWqC1qlxwuEq/f/y3/Pob/1HxsbGMEs9XPJ7nyZ782Wx9hHWW5z811+mcegUu3/r43Tfc6aSZX3u4123XMrp//oQ/S0P1T5/b+aNoKza/H00tuTfqyKgKmq8HC22eNFRKCrWvMhocaOe44NqnhQakwWfYd9j2HcZ9j2GfJepcPsWTTcPvYKay2DsKi25TEk3GW7I58ukSKOTxmBsx8nZi2wPQdGQwWGS2LpKt2MwInv7JUopY3JoXAbhnRK5Lt74GN7YCN7YaPs1OkIwPQXzgoue68bMF7jihhsYiRR2/dKvYw4U0JxU7P3Wjhyi8jd/hlUcZPAz/xAt3Vkz7rUgddVeqj96CBGGHZnHJEnJNhmJkTnXCCNeb7R4vXGuc2C/aVA220Lj5WmHu/u66DUNZvyAkXlx8cxrzPMIt3jU6E2M4Venli93lmJXohSdtlO5ZJuhKKj65nmY3o4UojRHtJ1b+rUeFKI0Y2oDqSZ2hggjvJFpWqcmcN8Yp/VGWzx0T08ivLY7q5qysHf3c/lN+/FFSPpX72Pv7n6MgVzs3qv+xCwn/v9/iTcxy8X/4rNk9l+0lh9rRXTdchlv/Jcf0Hz5OOmbrlr3/Z+PrKKTQmOkQ4fnAMFp0eJ02IKzTM6z6BTrGcqGRdkwudbJUDTabXbOiIyVs8TG5jYwKWkeOoJz9VUo6vkTq3o1HVNRGZUlz4lRmDdv8jppvL/N2BaComrZGz2EbU0pZ1Jt+jT9nftDWQ+KGYvvH5MGAEsRua35TMPRc8TDYHrxwUXv7sHMF8hccy1mvoCZL2DkC+jzkw6X7Snwaq2Js+eSVY2l+tSPGfv7r5LZt5/iJz+7pBNv0qT27mX6O9+mdfwEzuXxZs3XmnaPyrWZCRXAuOcz0fI5MLsottuqQtE+k81o8bbeHEXbxFAVxlx/IZNxpOlRaXrMBuHSO9lk1F87gqLppC5e2r1bil3JU7RNnpiYXX5ByZZCN21pyJIkop2h+CPljY0eybZGOjxfGBGEuJVp3FPzouEb47inJnCHJhF+Ox7Q0jbWnn5SV5Tpedd12Lv7sS8aQO/NoigKN0R9jAkvdkbiGZrHRznxL/4SRVW57N/8HPae87cySRp7Vy9moYvG80c3jaBYVi0mhYfH2jxfzhEw4zZ5xV0sPVWBgm5SNkzKhsXVdor7st306AbTwWI2Y6XpM+y5jPv+Go0meYLpKv7QCF3vv2/JZUq6xVjgSWObBNnpDs+wTQRFXWYoJkoxazEyKx9ekyRrajiGylhdHuew2cQbG8UfG8Edbf/rjY0SzFQXltF7ejHzRTLXXo+ZL86Lh/mlJxfm9aSyY/HQRPzSfRFFTHz/W0w/+iDdd9zNwPs+uuSs4HpglssABJNTsFkERcvk4Vqy7RFakeBEw+VEwwXmgHaiRreht0VG22SXY3Frd5Z+y6AZRovZjE2PkVb7tRlLhuuvHcG5+DJUc2mRumibvDwje2cliRRttyeqNPBLlBwmNjpj0uE5UfJRmuf00Y0exoYT+SHe8BStN8bbmYanJmi9MYE3PIkI2rKQlnWw9/ST2reL3vfciLWnH3t3P3pP5oKTC0VSjKzSWKj24nFO/qu/wSx0c/E//zRGX3ZV21sNiqKQurSAN7Z5sofLqs1wh9mJnRIBlcCjEng821wsm04pKqV5kbFsmLyjK0XRNNEUhRHPo+J5DHsuw57HsOdRCzffxHTz0CugKNj7rlxymbJuUglkLJMkbYfnnVvuDNtEUJSGLMlSyplU5mTvhSQpZU0mGj7+DjIACBv1c0qUz2QehrPzWUGKgtHb1844vOGmtnBYKGIODKDG+M2nzjILiUMUBIx+7S+ZO/gCA+/7KD13viPWdtaUM2LmEv0K1xuF+XLcDRBiBDDtB0z7AS/PtR9mlQgMRaFgG5Rsi6JtcmNPhpJt4mgqk56/IDCeKZueni972ggiz6N54nX67//gksuoQN42qDTlNTkpugwNQ1UYb0kXye2GZsl4MUmKUZoJpUmg7JxYZr1RRNvheSdlKEZegDs0Od/jcHyhZNkdnoL5uFnvTmPt7iezfw/WB27G3tOPvXsArSsVKyu5KBxeUuKLb9M/PMDpP/wGmesuYc9vfxIttfHXHkVVEJskXoQzguLGCDENEfG61+J1r71/1VNQgD7doGyZlEyTS2ybO3NdDBgGc0GwIC5WPI+K5zLi+xua+dc69ArWJXvQ0ku3byrpFsOBjBeTpIDD6yzdB3QnsC0ExY3MENoJFHMWh0Z2TuCyEZQybYfn7Yo7MkzrxHG80VH8eQExrLUzy1AUjL5+zHyB3M23zWcbFjEGBta0lLhkm0x5Pq0YwVTYbDL8l/+V1umTlD71ObLXXL9m41oNiqKAoiA2SaZd37yL9oS3eYQYXwhONz1Ov6nnYFbX2tmMjknRNtnflSZvtXvtjJwpl57/d6Tl0VwHE5jGidcQYUD68qXd+votAwFMeQEYiQ9pR1J0TCZdn2CT/K4ka4esaEmWgkgxsoOEro2gR9ioKEyuMntus+LPNJh97jjNU22DlMbJCbyR6UXhsCeDvbufzA2X0v+R27B2t4VDvSt+T+y3INoZit9VTne+qhCM/82jjP63h+h59w0M/soHUPTN0eMaTYVo88RnZdXmxWDztBYRwETgMxH4HKgvXscsRaFompRNi5Jpcls2S9nsw1JVJnx/Xmic78/oeUwHyU9MizCkefgouXffc8HlyrrJs625xMezU1EE5He4wzNsE0FRkhyGqtCfNmSGYsIUMyZD2+wY+9Vpai88R+35Z/FGR0BVMfoH2sLhbXfMZxwWMPvzKHryl6KybcXKnPOr0wz9+X8hqM2x62d/GeeiSxMY3SpQFNgkpRhl22TU3Rr9Z+aCkLlak1dr5/baGbDas9NFx2RvLsW9+W66TZ2qN28Cc6Zkuuky7vpragJTP3oYo7sXsz+/5DJFx2S05cluOAlStE1GpOnNtmSj+t3uFIoizUll8wgE25GCSDOuNBDbqBVo2PKoPn6UqYcOMfPsMYgERl8WZ08fuVsub4uGewawdvejZ5OfFMhhYKN1LBKIMGLoP32L6e8+T/4z7yD/U3dvqp6tiqosCLMbjYZCQbGobFCGYie4QnDSdTnpnvuc1q1plK22yFg2TW7KZMkbBp6IGDkrm/HMv601NIFxj51EtFo4+5eegNZQyOsmlcBtB7iSNacbEx2VCbbXM3ynSEFRckEKWZOmHzHb2hyCxXalmLF4ZnjrzyCFjTr1lw4w98KztI4fQ9F10lfvp/e9HyR15VULwuFGVEOVbZPhDgXFVmWIof/2BRRNZ88v/sYFhZ6NQlHVTZOhWNqgcue1IgJGXZ+xpg/VxdlpR1Mp2m2RsWSb3NnfNoHRFIVx9yyRsdHOaJzx410v668dIX353gv3dbJNRpqbJ8NgO1KYF20l24/N9HC/HSlEKZ40Khs9jG1NPkoxqm79LFARRsw+f5zJHx6i+virRC2f9L5B9vyjd9Nz916M7jQAXrj+2X1FUkzS6qh0P2x6nPr9r1B74Ri7/ruP0HPf5qhkOZvNVPKcV0x8IqbE1o1nqmFItdng5eZiz1gNKJhmuz+jaXJNKs393T106zpTgb8gMA4H7YzGsSCeJU3z4BHUbAZz9+CSyxR0A19ETIWBFBQTIo/DOC3CHd7mY3sIimL+1QGxQ8qYK8Y9z6J1Dn7fPM5S1mRk1l1+/HF/RzE/XuyZ2ZgX1Lj7C1bQMsXSFPpSBkO+t7B8GLNyI1rnEkjNg8j3qL/yMrMHnqN+9DBEEalLr6D4iU+T2XftolFKBKzyGT1w4p1ouqdQtk1enqmjrFDrqb92hOG//lPMvgF2feYX0DO5BXOX5YhiXlmVOFGFoqL4AsXv/CSNtT9Y8vdeskxeqzeX/Hvcn23sca4RzTDieL3F8friTLoC9Jh6223aMdmVsrilt20C0wqjdrn0fF/GMyYw3hKZAZEO3sQ4/vQkzr59hBdIoiqm28c4NCGM+XuI/UVE8VZUwpg7jPG9x71Wn/2bLTomB+fqK/sdx40JYp7TK4klVDn/tzQx4kVY/5gxLqGIF+RoMfPKNXXxYDpCpwuLcbWOusyJGncOzI/5+YyYPzhNi7deFPNClDKWD5JKvsNxbQpbbwsxhhbvBz86F88gpNmKl+XrN3WEEHjHTlN//AXqTx4gmq2hlwbIfuAdpO+4AaPQB0DVB8bnV4z5G7LS8QJOIRT6lAxDikszWNlnDabnqPyr/4ZXmWT373yGzA2XEazwa7HNeOWxTa/zgD9EhyiKdV77Me//Yon1yrpDJXKJlvj7UustR9x7q9DXRhAKgKHQZSh0OdunI6WqCwYwJdPkHaluSrqJpsBI4DPsuwsi43DgMhstcQJZ7febLx/BufYKFEew1MNJ2TTapjdWiO7EO8+Wu5ZvFtwg3sRDFK1OaS12Wu68yWLGtYoXt4egKEmMYk46PCdNMWUy6wXUYmY1bQQiimgef42555+j9vIBIreFVd7NwLs/RPbaG9GzuY0e4jloCuQtk+EVljHOPP8Uo3/3JdKX7aX8Ez8TywRm3dhEM84l2+SRyWQdnjcLZ/oYTnkBL8+2Z6eFCvqCCUy7N+P1XWneV+wlo2tMuv5bhMYJt/1Q2Hj1MGgazqWXX3C/JcvkkamdcYw3AhXIWwYj0pBFIumIQpRiWmnhrnTWThKLfJThSfPURg+jI7zKJDM/fIn64y8QjE6idWVJv+160m+7EfPi8qbLHC4rDkNiZSKBNzTO0L/8cwhCLvqXP499STHh0a0CVdk0Jn5lzWI43PzlzmtFI4p4zW3ymts+r4Qh2iYwmkHZMCnrFpcYDnemuujXDBoiYth3qQQuw/Mi40jg4QHB9Cz+GxW63n9hc8iyZlEJd3YpbtLkpcMzIAVFyTIUcyaPH5cPr0lSTltU6ptftBVC4FaGmHvxOeZefI5wbhajp4/uO+4md/3Nm7Ic+AwD82Ybyzn4CiGYfOg7TD30XbpueRuF938CRd0kzbSXQFFVWMO+LHGxVYVe09jSJc9rQSAEQ02PoTeJ15l5E5ji/GtvNkXBbmcYjLg+x+r7OTnQS7O3m0rLo3aevpjW/DEe2eHHOEn6zPZ3MrmJjIUkkq1AQaR3lPPwRpCKDFLCYEJtLL/wBhNUa9Qee4m5Rw/gvnYaxbZI3XINvZ/7KPbVl21qQ82S4vC0mF52uebLJxj+/b9E78my519+BqO/ax1GFx9FVRGbpIdiWbV5Kdj6rZ5WgwAmQp+J0OcAi9dOU1Eo6m2RsWSY3Oxk+bDeR0rVmIx8TrVGOPrpT1O79RZGVJiI/PMm3pc0i0N+bd0+z06kgMNLLH+t2O5IQVGyJKoChYxJRWYoJkopbTJc37wzSP7U5IKI6I2PoqUzZK69gez1N+GUL9p0M8vno+y0+ydeKIwSYcjoN/6G2eefov++D9Bz930oW6HruaJsigCxaJvM+AGNdXBD3orUgpCjtSZH32QC02cZ5C0V58Rxrr3lNnaX+uk3DeaCoJ3F6PpUWi4V18NSVeaCgJo8xolRnDcW2vhflESytShGaUa3gNC1lRmI0lSVJv4mzQKNWi71pw4z9+gBGgdeBwVSN1xB4Tc/hXnNflRznfvyxMBAoR+TyjIZinOPHWT0D7+CvXcPpf/hH2DkNr/hk7KJMhRLqsV3ovHlF9yBeEJwync55bucXU2bVTXKKZ3coUPsvvRiLu0ZpKiZCGAkdBmef1Xm/y1rFt9vTW7Y59juqAL6sRjd4Q7PIAVFyQXoT5uEAqYaMlMjSUppi6ND1Y0exjmEjTpzL73A3IvP0Tp5HMUwyVy9n/73f5jU5VehaO2svU0a076Fsm1SaS4t2oatFpUv/SmNE69R/MRnyF1/S/sPW0BV2CwZiiXbkplzHRIB467PscOHqXzxi+zpH8RshliqQsEyKVltE5hburMULZOUpuILwed25am0PIZE2zlwMpAC2FpRtE15HkskMSiINAeViY0exrYmH2UY32SGLCIIaRx4nblHXqD+zBGE62PvvYiBf/hBMm/bj5ZtNwX3m1vjkbOITYOQWc5f0SKEoPqNx5j4s++Qvfs68r/6MVRDZ8VNtjcSVUWEGx8tZBSNLtVgWJbjdsRcFHLEbXL6v/4p2Xe/ne7Lu1CBAdWkrFmUNIsr9BT3WD30a22B+/12P6dDlxGtQSVqMSpcZMS4NvRjEyGortYgYBuwNa7ukg2hlDMZnZM/kiRRFSikNkeGYuR51I8cYu7F56i/ehiA1OVXUvjJz5LZtx/V2sR9BJeh5JgcqJ4/CA9mZxj64hfwp6fY9dO/ROrSK9Z5dKtEUTfFjHMphou2pE3jlSPoXd0Y+QIAbiQ41XQ59SYR/KdK/ViayqmmS8ky2e+kKZjtcv4Rvy0unv2qLdXUW7IkRdvgVGPjr8cSyVbCECq9wt4W7sObmYEow5i28cdYCIF79DRzj7zI3GMvEc01MHcN0POJd5C96zqMfM9GDzE2g4qzZHaiCCPG/+QBZh54kp6P303fp+/b1KXbb2azZCiWVZuJyMONaQa1k3GPvUHUaOFceyXQnpgejTxGI4/n/cUS8r16is+myzzrzVLWbG7TeijpFjYaE8KjIlpUohYV4VIRLSbFhau4JG8lj8MYrfhGsdsIKShKlqRtyCIfrJIk77TFgKlWPPet1SLCkMax15h78Vlqh15CeC727j0MfOCjZK69AT0TzwVws1FyLL49cv4eF9NPPoI7MsxFv/pbWIXyOo9s9Sja5uiJU7ZNfjw5u9HD2JI0Xj1C6sq9y7YP6DMNnq7O8fRMuydO6Ij27LRhUDJNyqbFFbbDPbku+gyD2SCg8iahccT3kFf1pSnaJk9N7ey+ThJJp+RFigY+NWRFS5IMhGle1kc3bP/u6Qkmf3CY2qMH8Een0Hpz5O69kezd12NeVNwSLXCWo6TYDC9hsuC+PsTMA08y8Isfpvu9t67zyNYATYXNEC+qFpUdZMiyljQPvIKaSWFesuuCyw1oJqfDFo97M8AM2nzGbRc6JdWmpNiUVJtrlRwFxSIERkWLStQWGM8IjpKlKWLLcud5pKAoWZJizuTFIdnMNUlKaZOR+vrOCgkhcIdOM/fis8wdeJ6wNofRN0DP3feSvf4mzL6BdRxN8uQ0jZSmLlnG6A6fJr13/5YUE4F2huIGlzwrQNEyGW5JqapTvKkJ/Mlx+t7/oWWXLdomw+6553EEjPo+o77PC/XFzBVLUSiaJmXTpGRY3JrJUjJNHFVlIvSpzLsGVnyPYd9lIpRFMLqi0G8ajLgy01Yi6YTCmf6JW19P2rQYQqVHOIyr6xuX+9M1Zh4+RPVHL9F8rYLqWKTvuIaBf/RRnKsv3lIZeiuhrDg8Hp2/75x7si3mdt1/03oOac1QVAWxGTIUNZvhSMaLcWi99Cr2/iuX/d2VNOu8JeUzBMxENY5QW6jSV4EBxaKkWJRUm8vVNHcrffSpJvWGx7jaYEJtMK42GFfa/x0oG38ebTR5HE4idRKQgqLkAhSzFt+Zlc1ck2Q9DVm8yYkFcxV/YgwtkyV73Q1kr78Za3D3tphZPh9ly2LC9fGXmJXVc114k1u4MfQmCBB7TR1NURh3ZXZKpzSOHgFVJXXZhUvtu3QNW1UZXeExdoXgpOty0nWBxYy7Lk2jkDYo622h8Vo7TVE3iQSMBB6VoC0wnvl3bgeVTectAzeKmPF3zmeWSNaCokgzIh2eE6U/StNQfOpK8vfZsOEy+/gRqj86SO3AcRRVJXvL5Qz8xF3o+6/eEuYqcVBoZx1VxPkzs/TedtVOWK2j9+XWcWRrhLo5MhRLqsXBHe7wHIdwZhbv5BDZ97x92WXLms2j7srchyNgVLiMCpcXosVKIwuVa7oCBkSa/ijFNcEAA1EKG52q0loQGNuCY51pZWeV/xaweYot/Py4hkhBUXJeehwdQ1MYq8lMjSQppS1eHE92dmPuwPNUH3uY1hsnUUyLzNXXMvChj5O69PIFc5XtzKBlUrlAbz8910Xj+NF1HNHaoigbHyCWLJMx15PdcGJQP3oE56JLUC37gsuVbJMJzycQq/uuZ8KQadfniLvoxqoCA7pBSbcoGyaXmQ53p7vo101qYcBw4FHxXYY9n8p8VqO3ynFsRkr2ha8VEonk/BSiNI/rQxs9jG3NQJRhQq0nmgXaOjXG2F8/wuyTryK8gPT+ixj8lQ/Qddc+tIwDQLO1PcVEgF5MdBTGlmgMovd1ARBMzmxJQXEzZCiqtAXFijRk6Zjm4VcBcPZfeAJaAUqauWrTG5eIYa3G8NlZeAIywqBfpBmIUgxEKS73e+gTKQSCSaV5VkZjnXG1QR1/22WvG0KlB4sRWfIMSEFRsgTFnMXYnLfROsW2p5Qy+XZCGYpREDD+za8y+/QTpK64iuJP/QzpvdegmmYi+9uslC2T4QsI43q2i2BuFhFFW7N0ZxO4PJccSwoxMYh8n8bxo/Te995lly1ZJpWESnEjYDTwGQ18XjgrMcNUFErzmYwl3eTmVIaS0UtW05kI/HYmo+8x7LcFx/HA39KictE2GW3JLFuJpBNUoTAgHEZlhmKiDIRpxhIsd64+cojTf/gNjN4shU/fQ9c9+zEHuhLb32akhMMoLuESDUDOZCgGW7XP7ibIUMyr7X59E0LGjJ3SPPQK5sW70HKZCy7XoxoYqIwmIdoqUFN8alQ5oVUX3xbQI5wFkXEwynJDUKBb2DQJFkum1ToT82XT3hYumx7ApkVIbQk3+J2GFBQl56WUMxmZk7NHSdJlali6ymhj7R9g/Zkqlb/4E7zKEPmPfYquW+9Y831sFcqWxfMXyALVc10QRYT1Gnp2q844b3yG4omGbN7cKc2TxxC+T+rKvcsuW7TMJfuAJoUnBCd9l5P+/L0gak8xZ1WNkmFSNtpi4z47RVE3URWl7Tbtu22R8UzZtL81gsaCbXJktrH8ghKJZIF+4RAQMa3ImDFJBqI0zxvDa75dEUaM/OkPmPjbJ+i65xp2/dqHUO2dNfF8hrJiL+nwDKBmUyiGTjC1NQ3oNkOGYlm1qEStHd+zuVNEFNE6/CrZ+5Z/nitrFqORy3o2bxEKTClNptQmr7DYLs0QKn1RigHRFhr3Bv0MRCnSmFSVVltoVBazGSsiIFI2/9mxYMiyzTIv4yIFRcl5KeYsjo7LB6skKaUtxhurL2F8M41jrzHyV3+Gouvs+qVfx961Z023v5UwFIUBw1i25BkgmJvZkoIiigobHCCWbJPHt2iAvZHUjx5Bz3VhFkrLLluyTV6a2xwZQHNRyJzb5FV38cFLAfp1g5LeFhr3mDZ3pHMM6AatKGLE9xg+4zTteVR8j+YmaA5/NiXL5Iet6kYPQyLZUhSiNKOKNGRJEkW0BcVxbW0zFINqnVP/9ivUD52i9Pn30PeR27ZtP+2VUFIcXo+Wvs8qioLWk92yguJmyFAsq/aqS3F3It6JU0T1Bs61Vy27bFnbPCXlvhIxotUYeZN5SUoY9M9nMw5EKS4KyvRHKTQUJpQWY0qDMaU5/2owg7ep7jF5HOnwfBZSUJScl1LO5JHXV9bMVRKPctqksoblzkIIph/9ERPf+SbOxZdR/Ac/g56+cFr8dqdomjSXMVnQc90ABLMzUN69TiNbQ1QVsYElz6aq0G9dWLSVnJ/G0cOkrti77AOcCuSX6QW60QhgPPAZD3wOtBYfyAwUSopJcd5ten8qzbu7e+jWdapBQMXzqHjt0umK5zHqr/0ky0qwVZVuU2dUOjxLJB1RFGlG1c0x2bFd6REOAphW1u4BtvHKEKf+zZcRfsgl/+vPkNl/0Zpte6tSwuERJi64jN6XI5jcmoLiZshQLGkWhwPpjNspzUOvoKYczEuXf04paRZDweauGmooPqe0GU5pM4tvCnCCNHnhkBcpiiLFdWE/fdj4RG8RGceUJk1lY0qOCzi8THVD9r0ZSURQrNVqfP/73ycIAq655hr27duXxG4WEGr71dlKMWXumM85oRFvfx1/rtUiIGNppE2NkVlv5Z93nZ//Yh+XuF97zF9KdIGqkWLW4mStdd5log69UiLXZfRv/5rawRfoefs76bv/A23DlRXGDVsguxwAvdnZF7jbsag0LywQaKk0aFpbUHwzMc8XJWadgVA736GiKCBErLGqa3AfLtkmtSCk7ofJTR7GPT/j/t5jXl9EB79bf3oKb2KM3ne/H7904XO0qJqECEb7G+ceCjXmgXHjmTEprc4PaIBgyPcYanlw1gx1SlXbIuP8685MjqJpYqkq477fzmR0PSpuW2ic9P0VnQZCi3dM8o7BjB9QU6O2grtC4p4rsVsHrWS9zZX4eUG2RLwI6x4zKjFvyqa2vg7lYaRSiNK8oI0RdXCMwpg/nLifz4i5Xief6WyyZrzJYls7/015l9fDlFYjZb71XnF8qrfj/Ux/91lGvvAA5kVl8r/2WaLeLmZXmEOgxLzvxF1PhPHOFXfO6mh5R1Hp7TI52QjxxNLGM2pXF95EDa/xpmVScUYJtWZMc8QYhzMUOiIStGqdl7Qrfszn2Nq5x2kwZfODehXhJWPuE/d5JnbcZ8W84Zqdrdc8fAR7/xV055evHtwdGrxsj9KVXYy5itl4fT+DKN6BmXMvbDS4FLXIZxyfQ8y2Y3gNdKHQh01BOBSEw2VRN2+jSDcWc3iM0mRcbQuNozQYV1oEKwyyNDXevaHg2/wwRobiposZ1yheTERQPHToEH/0R3/Eq6++yvDwMOl0ms997nP87u/+Lul0OoldStaQYs5ksu7jh1tEZdqilFMmT4ytfpbTmxyn8hd/jF+dovhTnyO7/4bVD26bULJNhpsXDuwVVUXP5M4vKG4F1I0teV7JMZa8lfqrR0BVSV1+5bJ9bkrz5Svb6YrciCKOtVoca507i96t6wsiY8kwuS6TJm+YRAhG50umz4iMI67HbLg2AkrRMhnxZHbieiPjxS2OgLxIMSINWRKlL8gwtQblzpEXMPKFbzHz/efJvOt2ej/zIRRDFqtBu7ffdOTTEBe+p+g9XXjHt6ijuapsaLyYUlS6NYNhX95rOyGcreGdGCJ739uWXVYXCr1n+vttEwJFMEqT0TdlaNtCI49DXjiUsLkh6icvHGw0pnDPyWQcU5pM0oo9N3g2jtDIYTLG5s4CXU8SuYtcdtll/M7v/A7d3d0APPTQQ/ze7/0elmXxe7/3e2haezZmaGiIr371q/i+zz333MNNN92EuhVdVrcZpZzVzk6UJIatqfRaxqqFmNqRQ4x++YtomSy7/9FvYuWLazTC7UHZMXlqBW58eq6LYG5rCoqKom5oCUvJ3tyluJuVxquHcfZcjGY7hFz4+A1uon44SVMNAqpBwOFGY2HmVAX6DYOS1RYaL3Fs7uzK0WcYNKOIijvfl3FebBzxPFod/iaSdNGWLI2MF7c2vcJe6HklSY7+MMtxc3xV2/DHZzj9+1/CPTlK6dc/innLzjXrOx+D2sp6+2k9OcLpWYQQW6/f5Ab3UCwbFlOBT3MD2/RsRZoHj4IQONdeueyy/dh4hO2eg9uclhJyihqnlBramQxoARkMCsJZKJ2+QnQzIBwUYJy2uDiutAXKMaXJbIf9GQeEQxWPVtxytG1IIoJif38//f39C/9/6aWXcujQIf7Lf/kv/O7v/i4ATz/9NJ/61KfI5XKoqsof/MEf8E/+yT/ht37rt87ZVq1WI5PZ2X3g1ptizmR4Zmc8vG4UJcek6gU0gng3VRFFTP3wu0w99F3Se/dT+OSn0WxnjUe59SnaFsPNyWWX03NdBLPV5AeUBBs841xyLJ7cov2ENoooCGgcO0rvve9e0fIlzeaVYOdmAEXAmO8z5vu8yFn9GRWFgmkuCI3XpdO8t7eHnK4z7fttkdFdFBrHLtCfsWiZPDMTryRIEh8ZL25tCiLFuNLYEq6cWxYBfWGWZ7RjsTdRP3CcoX/3ZVTL4KJ/9Q9xLivTkLftcxjULIbC5YVxrbcL4flEjRZaemvF3Yq6sRPQZd1kOJDPl53SPPAK5kWDaF1Z4MKZygWRYmwnuw8rUMOnpvi8zuJFThHQg0VepNoZjSLNDVE/vfMC7EJvRhZ7NDaXEAwLIrWtMkDXgkQExSiKzpk51nWdYrGI53nous6pU6f41V/9VfL5PH/1V39Ff38/X/jCF/in//Sfcu+993LLLbcA8Bd/8Rd8/vOf59lnn+Xqq69OYqiS81DMWTz7hnywSpJyyqTSiHdTDZsNRr78RRpHj9B3/wfouftdKDJT4y30GDqmqjC2gqwjPdtFY7SyDqNKAJmhuOVonTyG8DzSV+xd0fIlzeKH7lTCo9p6+EJw2nU57Z57LU2rKsV5kbFombytK0fp7P6M81mMZwTHCd+nZJqMuP4GfZKdi4wXtzZFkWZEWb6nlyQ+KWFiCyNWybMQgqmvP87Yn3+f9LWXUP4nn0TPxWz2t80paxaH3eUn7rSeHADh9MyWExTbE9AbJ/4PGhbDgYwXO0FEEa2Dr5K59/YVLV/EeUtpsKTdBnkKlynF5QiLDWM1oTDAmWxGhytEF3dFRbrm+zMumsC0xcZxpUkeR5Y7v4k1FxTPBIePPPIIk5OT3HjjjXzjG9/gP/7H/8hP/uRPAvD1r3+dY8eO8aUvfYlLLrkEgM997nN88Ytf5M/+7M+45ZZbeOKJJ/jjP/5jvv71r8vgcB2xdIXelMHIrJxBSpJSymK40flN1a0MUfnLPyFsNSn/zC+uWJDYiZQdk7GWx0pagW7pkmdVbZuybAA9ho6xQtFWskj91SNo2RxmqbzsshYqfZqxY0qe14J6FPF6s8XrzTf3Z9QomRZFq+06vT+dpmC2G8PrisI9PTmG3HZvxhHXoxrIcpYkkfHi1qcQpTiqrdDNQxKLvjDLjNpYscnAGcKmS+U//B1zj71M3yffzsCn34miycnn86Ey74y7ggxF/YygODULu7ZWmyFlg3tul3WLI3V5vegE78QQUa2Bc91VK1q+IBwOK9VkB7WNCBXBCI23TIxZQlsQGfM4XB/1kRcpHDQCBGO0uF+UGKXFKE0maBHt1KxQEhAUz8w0P/zww/zbf/tvmZ2d5dJLL+Vf/+t/zSc+8QkAvva1r3HnnXcuzCwLIUilUvT39zM6Ogq0S1d++qd/mve85z1rPUTJBSjmLGaaAQ1P9rdIknLK5HC1sxLG2RefZezrX8LsyzP487+M0dOX0Oi2ByXbZHiFmXN6rovIdQlbLTQ7njPZhqEqG5ahWHJMxl1/RaKtZJHGq0dIX7F3Rf2XyprFTBRQX6ZRvGR5qkFINWi0+zPOowK35LJ8oLeXcT/gIsfm9q4s/aaBG0WMuPMZjfOO0yOuR2MDH8i2EzJe3OKIdobiw8oWNajYIvQHWSY7zE50hyY4/W++RDA+w+D/+Clyb0vWPX2rM6CaRMBE5LdvChdA684CEE5vwZpxtR1ziCha98omBSgasuS5U5oHXkFN2ViX7V7R8nkcHlK2aMXVJsJVQt5Qarxxdom5gIww+PXwWo4zRxaDy8mRx0ZFYUK4jNLOZDwjNFbx1sQIZrOTmLXXP/tn/4xf/uVf5sknn+Q3f/M3eeqpp/iZn/kZhoeHOXjwIL/9279NV1fXwvKpVIrJyUkuvfRSAO6///6khia5AG1DFnmxTxJNgbxtUllhhqIIQya+/XdUn3iE7PW3kP/IT6CaZsKj3PqUHYsT9ZWlpOu5bgCCuZktJygqysbNOJdsk4p0eO4IvzqNNzZC77tWJn6UNYvhFWRNSOIRAbaqcqrl8t2JxcwJXVEomEa7dNoy2ZdJ8c6+bnoMnRk/aJdMux5+dQrVslEtW7aeiImMF7cmGUwcdMZkyXOi9IUZxvWVtyGae/IIw//n19B7c1z8+7+AtXsgwdFtD3ZpNpXQZSVzo4quo3ZlCKa3XlXLwj0qEssKp2vNgNauBhgPZGuRTmgeeAX7mitQ5g3KLkRK6PPuw7LkORGUtjCuo/J9hgnmewe3+zOa5HEo4lDA4Tp66ccmIGJMtBijyQhNgnoN1bJQNH3rmTpdgERKnhVFQVEU+vr6+MAHPkAYhvzkT/4kv/Ebv0GtVmNycpLrr7/+LeuePHmSj370owRBgK4npnVKLkAxZ0qH54TJ2yZBJJj2gmWXDeZmqfz1n9F64wQDH/oEXbfdta0uQElSsk0eW6FZiJ5tP6wGszNYA4Ukh7X2bGDJc8k2OS0FxY5ovHoEFIXU5cu79UFbUJTlzslSMt/q8BwIwZDrMfSm921VpWgtCo3+TJXIbSHCEMUw0SxrQWBsv8y26C95CzJe3NoUohSTSqvjUlxJZ/SFWY5Yw8suJ8KI8b96iMkvP0L29r2UfuNjaClrHUa49SmvsNz5DPq80/OWYz5DsT0JvbxAtZaUDYsR30NeLVZOWKvjHT9N9t7bVrR8AYcqrnQfTpCCSDFFa0FMhDP9GT2m8DjC4kSDJhT6sCjMi4yXkKVVGUL4HoqmzceIizGjZtkrEo43I4mVPJ/N7t278TyPY8eO4TgOqqqSz+cX/q4oCqdOnWJycpIrr7xSBocbSDFncXhk57qJrgflVDurazkJqHnqOJW/+lMAdv3D/x/ORZckP7htgq0q9FnGirPn9Gy7J85W7KOoKApRtDHBQ8kxeXpaGjh1Qv3oEew9F6M5K2uMX9IsHveqyQ5qh1OyTF6trey334oiTjRdTsxfW95/59sRQiDCgMh1idwWkdvCm5og8lyIIlTTOidw1GwbRTF3/OSQjBe3NoUozagi48UkMYRGV5RatuQ5mG0w/H98lfqLxxj4mfvo+7icfO6EQc3iJX/lZeVaTxfh1NaLF5m/5goh1t0EuKxbsty5Q1oHj4IQ2NeurH9iXjjSfThh8sJhbIWmN6HS7rU4RouX5o1g/s/L70ZE0UKsGLouwdws0cQYIghQdGMxVjwrblz3lOIOWdNI7MUXX+QrX/kKP/dzP8fu3bsxDAMhBF/+8pfp6+vjiiuu4NChQziOg++3U56FECiKwg9/+EMymQz79sk+HxuFrioMpA2ZoZgwyxmyCCGoPvkY4w/8LfauPZR+6mcXBC/JyijaFjN+QD1c2VyoahioqTTB7BYNEIP1n/M1FIU+06DSlNeLlSKCgObrr9Jz97tWvE5JsxiWGYqJoQCF82QodrQNRWkHgboB6czC+0IIROATtdpBY+S22oGj1/4+VdNCM+eDRtNGMy0U3dgRQoCMF7c+hSjNG0rnzsOSldMbZmgoLk116etT61iF0//mS0RNl93/82fJ3HDZOo5we1DWbL7dmlzx8lpPDve1UwmOKBmUczIU15eyYXLUlWJXJzQPvIKxu7RgBLQcBenwnDgDZwTFVRSGKaqK5qTQnBTGWe+LMFiIFSO3hV+dInRdiEJUw1yIE1XLRjNtVHPzVMCsqaA4OzvLt771Lb7zne9w0003cckll/C9732PH/zgB/zO7/wOl156Ka+88gq5XG6hmbaiKExPT/OlL32JW2+9leuuu24thyTpgHzWxA0iZlrLl+JK4lNOmTw3cf4gPPI9Rh74CrMHnqb7jrvpf99Htmz680ZSdsyOhS4j10UwW01mQEmyQSXPRdukGUbMSifcFdM8dYLIdUlduTIhpEfRsRSV0VCKtknRa+hoisK4t/Z9nRRFQTFMVMNEzy6+L4SApts2gvJaBK0G0cw0ke+CqrZFRrM9M90OGm3UbZaJJ+PFrU9BpHlGG9voYWxr+oIsE9rSVQBD3znCiT/4IdauAS76X34WI9+9foPbJmQVjS5V76i1iN7bRWNLljzPZyhG6x8zDuoWP6pX132/WxURRTRfepXMPbeueJ2CcHhCkdfkJCkIh1fV6qoExaVQNB09pUMqvfBee2I6QDRaRN58zDg9Qei5IASqac7Hi/Nio2mjGutfAbOmEeqdd97JF77wBR544AEeeeQRnn/+efbv3883v/lN3vWudkbG3XffTVdXF//5P/9nbrvtNtLpNL//+7/PCy+8wB/8wR8A7b465yuFWYrQcxEisyNm9ZOklDOpyOzExCk5JsONtwYuXnWKoS//Md7EGIVPfobcDbdswOi2B22H586yuvRs15bLUPQnJ/DHRlEz6eUXXmNKjkllhS7akjaNVw+jpTNYpfKKli9pFuORR5BE5CIBoGiajHnr29dJUZT5mWYbg0WzERFFRL5L6LYDx6BRw52eQAQ+iqYvZjSa9sJ/b9UJp42KF4NmA5FKoahb87htFmyh0y1sRmTJc6L0hRkm9bdOQEd+yOH/+Cgnv3aArnfdQPGXPoBqGefZgmQ5yprFeOjhdnAX0HpyRHN1hB+gGFtjsidyPZqHjrf/Z50noR1FpVc3GPJltcVK8U4NE83Vca5dWb9tRbQdnkelSVZiKAIGWHnJ85rsU1FQDAM1bUB6cWb6TAVM6LYIvRaR18Kfm2lPTMM5ceJ6VMCs6VVQ0zRuvPFGbrzxxoX33hzsZTIZ/vAP/5Bf+7Vf453vfCeFQoFnnnmG3/md3+HjH/84cP6+OheiVjlONDMyXzrkoJnO/L/WpkkF3QoUpcNz4vSYOqaqMvomIab++isM/e2fo1k2F/38b2DsGdygEW4PSo7JI+OdiYN6rotW5XRCI1pbgrk5ph/8HrNPPoaWydL7kQ+v+xiKdudZoDud+tEjpK7cu2I3YGnIkjwl02TE2xznsaKq7djFcs55X0QhoefO99tp4ddmCL0WImz32zkzK30mgBQb5PreCRsVLzYmTiPmxlANczFWtJz2sdO2hjCwGShEKWaUlmz+nzB9YZYDxslz3mtN1Hj+d79N9cgo1/yTewnffo9MqFgFg5rdcVsRbb4ENajOYgz0JjGsNUOEIbMPPs/k3/yQcLZB7kP3omVW1sN5rSjpJtXQpyE2/71ps9A88AqKY2FdftGKlu/GQkNhAhkzJkUPbZOrKVqst6nRmzm7AsZgsSReCEHkv6kCZvbcCpizJ6ejNaoySzx6Ol+wd9999/HVr36V73znOwwPD/PP//k/55577om9j9xFV+FYZluldZt4tSrhVAUigWZaiwHjfNCoqGr8fI+Y92yxznGqiKGjFrtMnjw5g1jH30iccQKxxxjF3J+fXX6Z8+7vTQZ7xazJqOfh2e3/F0Iw/fAPmPzeA6Quv4ripz6LlkoTN11GkYlMqJzJUDxLJFjB71bPdRG8cuicZeMezriml9oyukbktpj68UNMP/YQiqrRf9/76b79blTThBiJIrGfBUXbyOK5yTmUTjokrPczT8z9+dl437zQl14vqM7gjVToeu+7CDJvOkG881+YSrbNsOct+fe4109lie0tu164zl9gnN11+NUVrfn+iXE/WtyYoJOvQNXQ9BRaKoV51qkThUFbZPRcIq+FNztF5LnUa1vTKGld4sU9V+LYNqHbJPRahG4Dd3YSEfiounFWrOi0e1vq7ayv9Y4ZDTXeTUSIeDtUOgwe2oYsDdSYQYepxbv5dDrOM2gxj6cZ82aeM+M91J+eXcxYVoVCb5jhVS9iym/3Zp079AbH/revgapw1e//NM7eQSan4zk5K+r6Boxxz83YgW24sovsoGozFLgQtccn/OXX09I9AASjNfTcQPu/tZi/2SjecRG1C2ekCiFovnCQ6a8/QDA6Tvq2G+n60Hsxe/ohTrV23K/PVxi02rGM4icfQ8Q9zYQW7zzrKsUrfbf0C18DJ4+8TPdNF1MYPDdD2dTPH3RfHKSZ9pqknfO7lbtBPCEiivnFhzG/iLjXiRW2zF/V/vpFmnFa+HHFBFiHmFFB1WxU20ana+F59C0VMM0abnWC+hpV5m3YdOy+ffvWrKG2oigLSivZbmBeoQ38dtDoNvHrs7SmRhFRiGosioz6fNC408tfVAUKGZPK3ObI1NiulG1rQegKWy1Gv/wX1A8fpPed76b3Xe9dceaSZGn6LQMBTLid9UTTc12E9RoiDDddGaEIAqrPPM7Uj75H5Lbovv1ueu9+V1t83iBKMfpU7mSah4+AouBctTK3Pmi7Ij7vbk1xaKtQMi2en9uaxhKqpqOmMuipc41glJnqxg0qAdYyXgRQ5w10jPTirH4UBguT0qHXxJubJvI9FE1fEBh1az5e1HaGcc6FKIg0o6osd06SPmETIZimhRCCsW88y+kv/ID0vkEu+6cfx+jZuPv/dqKsWTzvdXaf1brb145wenO2yWm9+jrTX/sW3olT2FdfycDnP4u5e77yaQPa5JcNsz05KlkRwVyT2pFhLv719614nYEoxbgqy52TpMDWddFeqgJG3eqCYtIoioJmmGiGCZn2jJ8QYt5Bpy0ynlFnReifW/4yXzq9k8pf+lJtEWayvvaN6SWLlG2T1xstvLFRhr/4x4Rzs5R++vNk9l2z0UPbNpRsk5GW13FGiZ7rAiEI5mYxunsSGVuniChi7uALTP7gAfzqFLkbb6Xvne/F6NrY8XUZGramMtqS14uV0jh8BOuiPWjplZUaaUBeN6kEMghPCg3Im8aqHJ43G4qibDsDl/XgjDhrnC3ORuGCyBi4TZr1dn8iRdXOk8m4/k3QN5JClOawsXJXXEnnFESKMaVB4Pqc+g/fZvLBgxQ+diuD//CdqPrmmvTcqmgoFDST4fD8WV1LoTg2imUSVjeXoOidHqb69QdoHjyCedEu8v/dP8LZe/lGD4uyafHwXHWjh7FlmHnuOESCrpsvXfE6/VGaUXVrTo5uFfLCYWib9Q1eq0SmHRV1KoqCcmZmOvXmmenm/KvRLhsKvPneRA66ZS+IjYqmb8ugsZSzGJ3rXISRdEbZNvnOM89x6v/5DxjdPez+1X+M2T+w0cPaVsTNnNNz7YmHYHZmUwiK9ddeYeJ738StDJHeew3lz34eK1/c6GEB7WM84foEG+AuvRURYUjzlaN0vXPlpZp53SQUgqlQirZJMWCaBEIwHQSsfz2+ZLOjqBq6k0Z30ljzlzoRRe1Saa8dM7rVcUKvBYrSrno5K15UDWtbxou6UOkVjsxQTJiCSDPUnObIP/sz3KFpLvkfP0LfvXLyeS0paSauiJiKOkvbUxQFraeLcJM4PQeTU1S/8R3qTz2P3t9H/y/8NKmbrtsU1x8FKBkmw/72mbhLmtlnj+FcPIA5kFt+4XkGohQHdenwnCQFbJ5jYqOHsSnZUYLiUrRnprMYqcVGeVEYLgSModfEq83PTGv6W8xf1ARdc9aLYtakIg1ZEsVB0GMaPPtH/w/pq/ZR+PhPoVrxet9IlqZsWxye6zztX8/OC4pzGzvj3Bp6g4nvfZPGsaPYuy9m9+d/Deeilc9SrgdFx6LSkMHhSnFPnES0WqT27V3xOmXdYjhw5SRPgpRMkxG3PZG2te/gkvVCUVV0O4VuL2YaCxEReu5CvOjOThF67bKo7WgWmBcpmgTM4SF/OcnRP6Pwgy99h6jpsfd//xypS/IbPaRtx6BmdWzIcgatu2vDMxTDWp2Zb/+AuR89hppy6P2pj5F5++2bqm1Pn26gKQpjUlBcESISzDxzjL779q94HV2o9AiHCTnJkxi6UOjF3rIlz0kjBcUlUDUN1clgOGeXv0TzImN7dtqtjhF6LqjKfC/Gs8qlt9jMdCln8VJFpkonRVivYT77GGMDWZx77qP7rndsqfNjK1FyTB4cm+54PdVJoeg6wQb1H/Mmx5l88AHmDr6AOVCg/Jl/SPqqazbleSL7J3ZG4+UjqJk05u5dK16nrFtUAjnJkyRFy6Qi+zpJVomiqOhWu8fiGc44LbaNX5r4tSqtqQoiiuZ7frdLpc+IjVupf3Ihmu+fqLAKtxrJUohIUPnrxyi8Zx8jSp19/8fPoWed5VeUdExZtxiKLSjmCMY3puw/annMPvAwM999CBB0vf9+cu+6G9XefEkKZcNkxPfiek3uOBrHRvGn63TdctmK1+mNHDxC5hQZzyRFPzY+EbPIqqHzIQXFDmjPTKfR7cVGyBeemZ4PGE2HYs5kfM4j3KTBVzFr8t1X5MNrErROv0HlL/+E6+6/n0ok6Hn7vRs9pG1LWlPpMnQqrc5vqoqioOe61z1DMZibZfJH32Pm2cfRMzkKH/spctffsqlmmN9MyTF5fkpOQKyU5uEjOHuv6kg0KOkmh13ZYDtJSqbJa0052yxZe84xC8x0A28yC/Sa+I05WtVxRBjMmwUulkvbQqOlxHNCTpoFQVGy5gT1Fif+3TfRX5sm84kM1i++jXDzhgJbnkHN5hk3Xtmy3tOFe/T4Go/owoggpPbwM1S/+iBhrUH2HXfS9b53oWUzy6+8QZRNi2FPPl+ulJlnjqE6JpmrVz4B3TZkqcuE8QRZMGSRx/i8SEFxlVxwZtptEnot/FqVn721hKGpjM15jMy5VGY9KrMuo3Me/garjN22jqmpjEtDljXHn5rk9Bf+L8ximWve8z5GUQEZiCdFybGYdH3cKN5vSs91EayR49VyhK0W04/9kOnHf4SiavTf9wG673g7qmGuy/7joisKA7ZBpSkDxJUQTE3jDQ3T9a57O1qvrFs8WO8801ayckqWySObrKm+ZPtyjlkgXQvvR4G/WP3SauDOTvKPg1upKi1GlDqjaoNRpc6IWqeubHycVojSPKkPb/Qwth1CCF77vb+heWKcD/6LX2ZSbUkxMWHKmsXpDg1ZzqD1dBFWZxFRlHiGsRCCxtMHmf6b7xKMTpG+83q63vd+jP7eRPe7FpQMk+NuvGO8E6k+cZTcDRejGiv/8Q9EaSakw3OiFMTWdXheD6SgmADnzEzP8z//31+n29Ep5SxKOZMrBlLcc1k3aVNjou5TmXUZmfUYmXWpzHm0/PVLDi/mTMbrHkFMEUayNNUnHkUxLXZ9/lfYlctyaGxqo4e0rSnbZqzsxDPoua7ES56jIGDmmceY+tH3iDyX7jvuofft70JzUlti5itvG7TCiBl/c2bPbDZqzz6HYhik9l+94nUcRaVHMxiWJc+JYSoKfYYhS54lG456HrPA3x36rxSjNAWRphCl2S/66RU2dXxG1fo5QmNVcdft3qEKhQGRkhmKCTB9aJTaodNc/rs/waVXXs6okAJBkvSoOraiMhrGuwdo3TkIQ6JaAy2XXIZg8+XXmf7r7+AdO41z3ZXkf+0zmBeVEDUjsX2uJYOGxY9rcuJuJbSGpqi/Msyl/9NHO1pvIErxqi6fL5Mkj8NRRZ7HSyEFxXWk2gyoNgMOjy4GYhlLo5QzKeUsdvfY3HZRjm7HoNr0qZwRGOf/nXOTeYAvZS1GZuVD1VoTuS1mn3mSrjvuwrRs8pbB0CrELsnylByT4VVkzunZLlpvnFzDES0iooi5g88z8YMHCGamyd14G333vhejqzuR/SVFyTEZkf0TV4QQgtrTz5K67lpU215+hXlKukU1DGgI2XUoKYqmSS0IqYVSGJdsPlpKyAltlhMslmMaQiUvUgtC42VBDwPCwSNiTK0zqjQYUeuMKnUmlSYiAZGxTziECKYVmXG01rz+Nwewyj103Xo5xTDNaXVuo4e0rSlrFmOhhx+zEajW3c4yDqeriQiK3skK01/6Ds0Dr2JeuovCP/sFnH2by6BvOSxFod8wGJYTdyti8sGDaCmLnjuu6Gi9fpHmx+obCY1KAu2S50cZ2ehhbFqkoLjB1NyQo+NNjo4vptHahkopa1LMWZRyFvtLGfrTBnUvbGcxzrlUZjwqcy7TjWDVYyjmTI5NyjTetWbmxaeJfI+u2+6kYBm4UUTVX/33JVmakm1ycCZ+5oTe1UUwN4MQYs3MUIQQNF47wsT3/x53ZJj03v0M/vQvYg0U1mT7603JsaQhywrx3jiNPzpG78c7m20u66bMTkyYkjRkkWwxfCViSKkxpC72r9WEQr9wFkTGm4MCeZECFMbeVC49rjQIldVVohSiNGOyV9ea0xyrMfzQ6+z6xftRVIVCkOJZZXSjh7WtWY3DM7R7KAIE1VnMi9ZqVOCPTVH9yvepP/4ieqGPgd/4DKlbNqdB33KUDIvZMKAWyYm75RBCMPngIXru3otqrTz71BE6GWHKkucEsYRKNyZjsuR5SaSguAlp+RHHp1ocn1qcATY0hULWXCiZfvul3eSzJn4oGJk7q1x61mW83tl8Wylr8ePjMo13LREiYvrpR8lccx1Gdw9l22JYZicmiqZAwTYZXoXYpWe7EEFA1GygpdLLr7AMraFTjH/vmzSPv4az5xJ2f/7XcfZcsurtbiQlx+QFaciyImpPP4uWy+JceXlH60mH5+QpmiYjslG8ZIsTKoJRpcGo2gDGAVAE9Aqb4ny59L6oj3uDPZioTCpNRpQGo2q9/VIaeB2YvxSiNGOKLHdea45/7SCabdB//7VYQqMHm1FFCgRJUtZtTgXxM23VXAZUlXB6bZ6fwtka1b97iLnvP4mWSdH3cx8lc8/NKPrWbaRZNkyZnbhCaodO445Uufgff7Cj9QaiNDNKq6PruKQz8jjM4dOQx3hJpKC4RfBDwemqy+nq4gOQqkA+cyaT0eSm3TmKWRNVgdGa1y6Vnmv3ZByb8/DP0yMxbarkbJ3ROflgtZbUX3sFf3Kcwif/AdDu7ScFxWTJWyZeJJheRRaonpufcZ6dWZWg6E2MMfGDB6i9/CJmvkj5M58nfeXVW3KG+c2UHJMHZIbisogwpPbc82Ruubljx+6SbvHjZjWZgUkAKFomL85JYVyy/RAKTCotJmlxSJucfxO6hEVBpChEaS6JurgjKJPFZEppzouL9QWhsaGc/z5aEGkOamPr+Gm2P6EbcOLvXuaiD+5FS1kUohSzeEt+B5K1YVCzeMKtxl5fUVW0rixhNZ5L9Bmilsvst3/MzN8/Agp0f+I+cu+5E9Xe3AZ9K6FsWgz78vlyJUw+eBAznyO7f3dH67UdnuXkQ5IUcGR24jJIQXELEwkYmfMYmfN4YWjx/d6UQanbpJi12JdP867Le7ENlYm6v2D6Upl1GZnzKGYtJus+7gY7TW83pp96GKu0C3vPxUBbUHxqWvbDSZKyYzLSWl3gckZQ9GerWMVyx+sHc7NMPvRdZp57Aj2bo/Cxf0Du+lsSdwBcL7K6hqOpjEpxfFmaR14hqtXJ3HZLx+uWZMlz4pRMk2/LzAnJTkGBGcVlBpdXtUX3+JTQKURpiiJFQaS5zs/TKxzm8BazGOfFxhlc8lGKUUNmKK4lb3zvVbzZFpd+8lqmgYJIMSqzQBPFRKFfNRha5X1W6+6KnaEogpC5Hz7N9Nd+SFRvkrv/Dro+ci9advXVMZuFsmHyeG11gutOIPICph45Qv5DN6GonSUe9EdpxqVJVqJIh+fl2RaColDouPn0eucJhes40TQe+IxP+ByYWLzA5CyNUtailDHZ02tz+0VddNs6TT/ECwV3X95NZT6bcc6LkdIb84DGbRouYlYA+DHv01EHZmre+CiN11+h8MnPoKCgCNolz81JYvZ+lqyA9jFenUCgZ3KgKASz8wHiCs/PsNVi+sc/ZPqxH6HoGv33f4ju2+5CNTpz4VPienDEXK/T/ZXSJpOuT+gL4kikSZgEXIhOfrdno/irH2jtyWcxSyXswiAsk2iiNhYvaD26jqmojM+GqFz4Qie09b2gxD4/Yw4z1v5WcJKlNZWcrjPa8lGi+eXX+9q89ZOVtyRx4kVY/6/L1v1Y6ykd9kgUeIzQ4Li/GKRaQiM/n8lYjNJcEfbQL1J4hFhoXBPk6Zt3mp7Va7GOpx7zYuJH8YI/Q41XqtZtxSuJfW2qb0XLCSE4+lcvk731CkZTl1Cfs+jRc5wQPtOt1Iq2ocS9D8SNv8N4K3Z6bi7sL4HAoaxb1EXInHjreaF08Pn0eUFRCRWiuZU96AkhaDx7gOrXv00wMUn6tpvo/tB70ft62n9fYe6BEsQ7LmId57fLhsXpwI21z7jxhtBj/h4y8TKCgzDeNUnXFj/g9JOvEdZa9LzrWsJlzncvOFe66Q/TvKbNvuX9t+4w3ucLo3gnjBozqFLVeOuFYcxxqsufaAVsXlAmz7mGxb2exWaTx4zbQlCULM+sGzLrNnhlYjEtOmWofGp/gSASDKRNritk6EsZNPywncU4LzBWai7TzUBqYSuk+sSjaJksmf03ANBr6uiKwpjMhkmUkmPyQnV1JYyKpqFlsriVIUQYLluqGgUBM0/9mMmHv4/wPbrvuJvet9+HZjurGsdmpZQyqTTkebwcUbNJ49Ahet73vo7XLRsm476P7NSSHEXTZMr3cc/TBkQi2em4SsgbyhxvnOUyrAmFW4MiN4VFdJRF8xcPxtUGY2qNUbXOmFpnXK2v2vxlp1A/eJLWiTFKv/DuhffKisPLkSwrT5JBzWJoFYYsZ9C6u/BeGiKsN9DSywvAzSOvUf3a3+OdPI1z7T4G/tHPYJY7r4bZCvRqOoaiMOrLmHE5ph48SOrKEvaulU1EnEER0C8cxhWZPZcYot1DcUyJ3291JyAFxR1Mw4/IWRrfenWS16baFyNTUyikzXY2Y9bk7ou6yWdMgkgwUnMXhMaRmsd43UNWSp9L2Gwy+8LT9Nx1L6re/nmVbYsRVx6rpCnZJt9ag95+mSuvZubpx6gdOUjXjbeRu+k2zN7+c5YRUcTcgeeYePABgpkqXTfdTu8734OR655fYNXD2JSUHJMR2T9xWWoHDiDCkMxNN3W8bsk0GZZmIYlStExGXHkeSyQrJVQEFjontBm+Y5wA2g+zedUkH2UohGn2Bv3cE12Ehc6k0mBMq8+LjDXG1DqubGj/Fib+7mmsPQNkrrsYAA2FomIxHMmH1yQpa/aqy50B7KuvZO5Hj3H6t/8XUjfuJ3PX7dhXXvqWNjfeqSGm//ZbtF5+FfOSPRT+yS9jX3lZ+49xM/83OWXDZDTw5OToMgQzDWaefp1dv3hfx+t2CwsVhSkpdiVGGp00huyhuAxSUNzBWJpCf8qkMrf4YOWFgjdmXd6YXbzRagr0p01KmbbQeFM5SzFjoasKY/X5TMaax0itLTR6O1g5m33uSUQY0nXrnQvvSUOW5Oky2r39RtbgOBc++im6br2TmWefoPrUo0w9/H2cSy6n66bbyVx9Lc3jrzP+vW/ijVbIXH0t/T/zS5gDhTX4FJufomPy0rTs1bIctWefxbn8cvSuro7XLZkmFZnNnCgly2TEjVdSKpHsVAoizevqYv9FocCk2mRSbXJYH59/E3LCIh+1Hab3hF3c4pfJCYuq0lrIZJzU5hhT69QVb9OXciWFNzLN7FOvMvgr718wbMsrFgGCKeQ9IEkGNYtH3OnlF1yG1LX72PWvf4faE89S+/FTjD39n9H7e0nfeSuZt92CCEKqf/cdGk8/j14YYOAffQ7nhv3bwqBvOcqGxbDMTlyW6YdfBqDnHVd3vG5epJhQmkQyIzwxCjhM0cKP3fNnZyAFxR1MMWMx6wbU/QvPH4Wi7Ro9WvN4YaRdUqoAPY5OKdPOZLyqL8U7LuombWpMNf2FUukz/zb87f9DFFFE9YlHye6/ET2bW3i/bJu8WpMzG0lSsk3GXZ9ArM1N1S7vwi7/BAPv/Qi1lw8w8+wTjHzliyhf1xFBgHPRpez+xd/A2X3xmuxvK6ApkLdNRmTJ8wXxp6Zovf46A5/+dKz1S6bFczXpPpwkRcvksVU6c0okO41ClOLH+ukLL6TArOIyq7q8xtTC247Q2yJjmCEfpbk6GKBXODQUn/H5DMZxtcaYVqOqtHaEyDjx98+ipSx67r124b2yYjMsWtu1yGFToNDuoTjcWJtKAC2Xpes995J79ztwXz9B7dEnmX3gQWa+8V1QFLRsht7P/gSZO29Zto3OdqJsWLzhy8y55Zj8wUG6brkMo6vzJv95kWJMkQ7PSSINWVaGFBR3MMWsSWUu3g1VAFPNgKlmwKHx+kLwlzG1hUzGctbi5lKOvpTBTCtol0zXFjMaq614DWI3K/UjhwiqU3T/g5895/2yY/HQRDwXOMnKKDsWlQSyQFXTJHfDLeRuuAVvYoy5Qy9ilQZJX7FvR8wwn03eNvGFYNrbXr/btab23HMopkn62muXX/hNaEDeMOSsfsIUTZOKLHmWSFZMWhjtsq+YD69NJeCkNsNJrR0L6UqELlQGojQDUYZ8mOYWfxd9bpqIiHG1zpg2LzKqNSbVxrbKwgmbHlPfe56+992Eai+6hw0qDsNCPrwmSb9qoAGj4dreAxRFwb78EuzLLyH6qY9Sf+ZFRBCQues2VHMdnTk3CWXD5Im6nLi7EK3TkzReHeaSf/rxWOsPiBTDipyATpJ2/0R5TV4OKSjuYEpZ65xy57Wg5oUcnWpydGrxx2dpCsX5TMZixuKqvhT5tIkXRozUvcVsxprLeMNnq/bJrz7xCPaei7EHdy+8l9ZUug2dSkv2REuSkm0y1Ez2GJv9efre8e7lF9ymFJ12dqJgRySPxEIIQe2ZZ0hfey2qZXW8fsGcF20DKdomRbeuYarSJEsi6YRilGZKWduyr0CJqGhzVLQ5mNfUVKHQEznkowz5KMM+P8890aUYqEyqDUaVBqNqjTG1wZhax9uifRmrP3yJqOnR94Fbznl/ULV5NqxuzKB2CGXNohJ6ibYuVB2H7N13JLiHzY2pKAzoBsO+fPa5EFMPHkRLW3TdfkWs9fPC4QVNGjglSV44vK5IYXw5pKC4gyllTF6ZSL4fmhsKTs60ODmzmPquKZBPmxTnzV9uKecoZkxUBcbq/kIWY6XmMlrf/H0Z3ZFhmsdfo/ipz53zftm2mPR8WltVJd0ilB2TZ6bnll9QEptiyqSSsGi71XHfeAN/fJy+j8ebbS4ZJhVpyJIoRctk3POlSZZE0gEFkWJUST5ejBTBpNZgUmtwmPkHZQFdwmYgStMXZLkk7Ob2YJCssJhWmgvu0mNq2wSmjr+pZ71EJJj4xlN0vW0vZv6sPrui7fD8d6KycYPbAQzqa+PwLFmaom7SiCJmo60p+K8HIhJM/fAg3W/fh2p2LsfoQqVX2LLkOUEUITMUV4oUFHcoZwS9tc5QXCmhgErNY7juwUj7PQXodYyFkum9/SneeXE3KUNjsukzMl8uPVzzqDRd6puoL2P1iUfQc11krj63zLFsmwxLV9xEMRSFPtOgIo9zopQck0NVachyIWrPPIOWy+FcEW+2uSwNWRKnZJmMymMskXREIUozrG5QaZ0CM0qLGbXFYbW68HZKGOSj9IIBzP4gT4+waeC/RWRsis0jMtZeOIZ7epJdv/bBc97vwsRCZVRIsStJBjWbV30ZyyRJ25BFnscXonboDbzRGfru2x9r/QHh0CSghjSYS4ouTHQUJpHn8nJIQXGHks+0S443Ux9DAUw2fSabPgfHF2/22TN9GTPzfRnLOfocg1k3YLjmMlL3GK55jNRdpjbg84T1GnMvPkvvve95S8PlsmMyLMudE6XkmDTCiNlAzoQmSSll8v3h1bsibldEGFJ74QWyt96KoqqxtlEyLQ415INOksj+iRJJ5xREmueVzVVa11B8TmhVTmjVhfeM+b6MhXmh8bZgkP4oRdQSTGg1xtUa41r7NaXWCTegL+PE3z2FfWmR1NW7z3m/RIpR0SKQliyJMqhZ/LA1tfyCktgMmqbsBb0MUw8exCx0kX7TdWCl5EWKcaW5aSZKtiMFHCZwN+Q+sdWQguIOpZSxqNS2xsV+zguZm2ry6ll9GU1ToZi22kJj2uLePSnyKZMgElTqi+XSlbrHeMNLtLxt5pknAOi65a39Usq2xQszUiBIkpItS3GTJqNrZA2dEZkFuiSNV44Q1etkbr459jZKpsn3Z6RomyQly+SlmrwmSyQrxRIaPcJmVN38vxtfiRjW5hjWFlugqEKhpBoMhGkGoix7/QJvb12Kgca02mgLjGcJjUn2ZXSHJpl79nV2/eaH32LsVhIphoV0xU0SR1Hp0QyGZclzopQNi6ekIcuSRF5A9dHDDHz4FhQ1niI4IBxZ7pwwBeEwKo/xipCC4g6ltAqH582AGwpOzrY4OXtuX8aBlEl5XmS8uZilmLbQVYWxhkel5nHadxlutEum3TXoayjCkJmnfkz2+pvR0plz/qYrCnnLYFiKXYlSss1EHJ4lixQdk8mWjyd7gS7J3PPPYJZKWOVyrPVTqkq3rsuS5wRRgbxpMCIzFCWSFVOI0szg0lQ2T0VLJ7T7MtaZ1OocOasvY1ZYDIQZBsIMu8JubvR2kRU2M0qTca3GhFanwRRT+hwNtbUmmUAT33warStF993XvOVvReHwqnR4TpRBzWI69GmIzdMyaTtSNkyGZIbiktSefoWw7tL7rnjlzgD5KMXL2uQajkryZvI4jCEneVaCFBR3KKWsxVOnt9fsUShgpO4xUveAdq8fBeixdYppi3LG5Mouh3sL3XSZOhMtn0rTZajpUWm4DDc9Zv3OZqZrLx8gmJ2h+4673/K3om3SDCNmZCluopQdiycmt9e5vNkopUyZnXgBwmaTxuFD9LzvfbG3UTJNpoOAZiQfdJKi32xbyU76W1MYkUg2goJIbYnsxI5QYE5xmVNdjhmLD+V2pNMftUXGgSjD3vqV5MI0nuIzrc8xpc8yNf/vrNZAdFAKF9ZbTP/gAP0fue28JgxFUvwwkhnqSTKo2ZyW2YmJ0q3p2IrKiBQUl6T60AFSV5axd/XF3kZepHhIOb2Go5K8mYJwOKjKa/JKkILiDkQBihmTSm3731QFMNUKmGoFvDxZx0+330/rKmXHopwyKTkWN/ZkGLANGkHEcLMtLg43XCpNj/HW0g1vq088gnPJ5VjFt2YllW3ZPzFpFNoZisMyQzFRio4pTW8uQP2lFxBhSOamm2JvQzo8J0/RNBnxfNmhTCLpgEKU3jFlXy014LRa5bReBaDbaqEJle4gQ2+QozfIclVzNz1BFgWFql47R2Ss6jWCJUqmp77/IpEX0PeBt7bFcIRGD5YseU6YQd1iOJTHOEkGDZOxwJe9QJcgmKlTe+41dv/S/bG3kRY6aQwmdsh1eSPQhEI/NqPIrPGVsC0ERYVt3JM05gcTF/AE6HMMFGCi5SO0pZdbDy40zgsRmvHWi+bXmyPiFbfJK24T5icfDEWhZJuUbZOyY3FXoYuS3V6h0vSotDyG5sXGkZbH3OlTtE6doPzpn+d8k9SDZxyeY9xTY/d/3WH3715TR1MUxlvLHOe4F4iYxzP29xczOU2NmQS70lZRJcfkyFQD9UxiV9zjEvd6FnO9mK1pOqb27LOkLr0Sy+iGGPFdZAnKuslIy0PtwLBPRDE/4DonQSoxx6nEGecFzs2S2T7GCbZIS56VHMptGxCtnq0SL0YxR6nFvDg7xtITRiUvxXFj7LzLhDGDuLifz9bjOZqmYq6nKxEoETNmlRmzyvH59xUBmTBNb5CjO8iyxxvg+vpl2MJkVqtzMvSo0KRCgwpNapHHxDefoeuuq9G6u3hzInpepKni4ut+xw9mQRAzkI65mqLGO8fi3q9EFHegbx1nWbM45NcuGKQJLd7nU/y49+OYx8VY34BfCVY2zrLedng+c4jjHk+xzgqFbsWrXAjDzs7P6sOHAHDedj0tz+h4f4YesivKMIVLLVKAlT3Iq+tsLOJH8QQGEXOYhr62gd2AsAgjwazaQjvPqR/Gjb/Xm+WGuUYfY1sIipLOKGVMRureej9Tbnp8ITjVdDnVdGG63dBbBfotg0HLpGxbXNuV5r3FXlKaSqWY5XjP/8TMnssZbvkMN13q4eJRLTsWj0/JUtwkKTkWY26ypjs7HVWBvGMy0pDZc+fDn56iefIYxU98ZlXbKVkWP67OrNGoJOejaJmcasrsFIlkpWhCpTdKMa7VNnoomwqhwJxeZ06vc5LK/JtgRxY9QZZgpkyZFDfTRz82M0GT137x15i+JMeE0KjQZAp3YbKsRIqKzIRJFBUoaabMUEyYsmkyLHtBL8nsjw6QuekK9Fwq9jYKpHZM1vhG0XbRXpveuTsBKSjuQMrZrePwvNFEwJjrM970eYHFHkJpt4n63b/l2vvfx2Vph9v7uui3DGb8gOFm2/Rl0DapByEKOy5xcN0on8kClSRGv20QCcFUS/adOx+zB55FMU0y+66NvQ2FtthVkWYhiVK0DJ6clpM8EslK6Y/SuATMKXJCaVkUaGkuFc3lZWUxO8cUKuLPHmZPf5Frb34X+0hRwCZEMCKaVGhSxmGUFjqKLBVNiIJqEQITUbxsVcnKKBsWz9Tnll9wB+KeHqf12hDl3/rUqrZTEA5jcgIiUfLCYSxOydEORQqKO5BSxuTg+DZrsL3OnPzxj5h+8UWq93+Mx06OAmCp8yXTjsWlaRtNVfi5i4oEQlBpeQy35nsztlxGWj5B3LxuyQIlx+RYTc42J0kxZTLS8OQjznkQQjD74jNk912Halqxj1GPrmMoCmNyVj8xdEWh3zSkaCuRdEA+zLSzE2WWRmxmT43w2jcfZPy//wSvK6cAUAX0Y1MiRQmHwvzrJrWPcVoMixYVmgyLJsM0abCV+zRsDtr9E10ZyySIoSjkdYNhachyXmZ/9CJq2iZ985Wr2k5eOBxVZUVLkuSFw0lFCuMrRQqKO5BSxuJ7x6VrUVyiIGDm6cfI3XArmuMsvO9GghMNlxMNl3oQ0mPq/IfXh8lbRtsAxja5oTvDB+1eLE1l3G2XSQ+3PIabHkMtl0YoC9E7oeSYPDohb6pJUkpZjDRkcHg+WkOn8CfHyX/wk6vaTskyGfM8+ciYIAXLoBVFzAbyKEskK2UgSjOmynLn1TD5zafQe7N03blv4b1IgTFajNHioFB4G3n+PYfwIpUyDmXFZo+S4g6ljz7FYkZ4DNNiWDSpzIuMU8iJvk4oaxZDstw5UQq6SUtEVENZ0fJmRBQx+/ABsndeg2oaxG1mrQjI4zCqyAzFJMkLh6fVsY0expZBCoo7jC5Lw9JVRutSIIhL7eALhPUaPbe/fcllSk67FDcCRlyfEdfnubP+3m3o8+YvJhelbN7Wl6PPNKj6AcPNtrv08LwJzLQnC2DOh62q9JqGdB9OmGLK5JWqTPs/H7MvPoOWzZG65PJVbUeWOydP0TIZdWWpm0TSCfkww/Pm0EYPY8sSzDaoPnSAgZ+8G0U/v0lBHhuPkCoePhoz+BwWswu9cmxUSjiUFIcyDnvV7ELJ9DAthvQWw1GTIdFkRLiyZHoJBjWbA57MOEoS2T9xaZqHTxFMzJB7x/Wr2k4vFgBTSHE8KQyh0oPFmBRtV4wUFHcYpYzFRMMniGTAEQchBNNPPEzq8qswBwpLLle2LQ7PLS3CVP2Aqh/w8lnL2KpKyTYZdNoGMHtzKQqWOV8yPV8uPV8yPSpLpik5JlUvkFmdCVNMmfxouLrRw9h0iCBg7uALdN14G4oa04VynrJlMdSSPcqSpGiZVFryQUciWSmKgD6Zobgqpr/3PAhB73tvWnKZEilGaC5ZVt4i4jh1jov5VkUCNBQGsCgrDkWR4katmw8pRSw0xoTLkGgyLNpC47BoUZf57wxqFg+E4xs9jG1N2Wg7PEveyuyPXsTI9+Ds3bOq7RREinGacc3BJStgQDg0CakhJ6FXihQUdxiljEVlTl7s49I6dQJ3+DSDP/2LF1yu7Jj8YKyzsvJWFHG80eJ4o4UyrxVqCgxY5kI24w3dGT7ovKlkej6bsdJ0qQc7R1wrOyYVKcIkiqOrdFk6Fenw/Bbqrx0hatTJXX/zqrdVNE2emZWZE0lStEwO12SmrUSyUnqitgtpVZVZGnEQYcTUt56m655r0bvSSy5XwunY4TlEMEKLEdEiCGc4oxd2YzCo2pQVh4uVFHcavfQrFlXhz2cxtsumh6IWk/g7Jpcxq2ikFY3hUMYySVI2TJ5ryAmINxO5PnOPH6LnA3egKKtTAgvCkZlzCZPHYUxpyN7BHSAFxR1GKWNyvCrTpOMy/eQjGH0DpC6/asllMrpGRtcYWYNsmFDASMtjpOXxXHXx/S5Do2xb7ZLp9HzJtGVQ9YK2Acy80Fhpekx62zNoLEmH58QppkymXR833I5n0OqYffEZrOIgVqG8qu3oisKANAtJnJJt8sPJ6kYPQyLZMuSjDONqDSEfqmIx+8QR/IlZ+j502wWXK+HwLJNrss8qPtXI5xCLE1Q2KiXFZlBxKKs2+9Q8Rd0iQFARLYaitgnMUNQWKLdjxDio2UxGvuw6mTBlw+Kb/tqcy9uJ2jOvEDXcVZc7Q1vsekORom2S5KVo2zFSUNxhlDIWj52WJhZx8Gemqb18gIH3f/SCJY5l22TS83EjkdjsxowfMuM3zimrtlWF4rzIWLZN3pnvpmibhGdcps/qzTjS9PC3eMl02bF4aKy60cPY1pRSJiOy3+pbCJsN6q8cov/+D656W3nLwIsiqoFsYp4UtqrSbeiMSNFWIlkxA2GGca2+0cPYskx+80lS1+zBubS45DKKgCIpKpxObBwtIo6LBsdFY8EHQqXdu7GsOAyqNjeoXXxQL+DMl0wPnyM0Nqlt8ZLpQWnIkjg5VSOlqoxIh+e3MPujF7Gv3IVZ7lv1tgrC4RlFlu4nSV44HFakeW0nSEFxB5HSVbptnZGavNjHofrUj1ENk64bbr3gcmVnYzLnWpHgRL3Fifpi0KQCA7axkM14XXea9zm9OPMl05X5noxn+jPWtogDqgoUbENmKCZMMWVKh+fzMHfoRUQUkb126b5YK6Vkm4zIJuaJUrQMZnzZb1Ui6YR8lOGILl0u49B8vULj5TfY/T/95AWX68ZER2F8nQ0WIqAiXCrC5dmzLovdGJRVu+0yrTrcofQwoFrMCv+cTMZh0WRcbJ18v0HdYkiWOydK2bSYCHy8LZ6ssNYEMzXqz79G/vPvX/W2DNpmIdLhOVnywuFH6vBGD2NLIQXFHUQpazHV9GnJh6qOiXyPmWeeIHfT7aiWfcFly461aZr/R8Boy2e05fN8dfH9nK5RdkxKjsWgY3Frb5Y+06AehAy3vPly6bbQOOH6bLYzpt8yEAImPdkwN0mKKZOjVZnR/GZmX3yG1GVXomdzq95W0ZYOz0lTtEyZnSiRdIKAgTDNI5YsrYvD5Defwsh3kbtt6fY40DZkGadFqGwOEeZMyfTLzC30ZbRQKSv2gtB4r95HSbERQEW0GI5a7d6MUZNh4eJtuogRyprNs9LhOVHKhsmwzE58C3OPvASqQu6u/aveVgGbJoE0C0kQR2hkMWXJc4dIQXEHUcqYVGpyhi4OcweeI2o16b797csuW7ZNnpve3IHLbBAyO9fkyNziBdNUFYq2yaBjUXJM7urvouSYKLT7OJ7pyTjcapdOuxvoFN42ZNk6s+NbEQUoyAzFt+BNTdI6dZziJz+7Jtsr2SYvNWRZYZKUbCkoSiSdkBM2BhqTqrw2dUprqsHMwwfJf/adKNrS7XEgniHLeuOeKZkOF1vsqMCAYlFWbAZVm/1qlvfqedJoTApvXmBcLJmeYeNaehgo5FWT4UCWPCdJ2bCoSIfntzDz8AEyN12Blk2telsF7LbQJfvaJkZepJjBxVW2RsXeZkEKijuIUsaiIsudO0YIwfTjD5O+6mrM3gv3vzAUhX5ra5biepHgVMPl1FmOvgrtbMCyY1KyTfbmUryr0E3O0Jl0/bbIeFbJdNVfn6CxtImyQLcr/bYBwGRLzoSezdyBZ1BMi8zea9dke0Xb5HvTsldLkhQtk2eqm3uSRyLZTAyEaabUxqbJnNtKvP63h0FT6X3PjcsuWyLF68yuw6jWlggYFS6jwuX5aLGKIYtOWbUZnM9ovEnpIq9YNAnbpdJRu2R6KGoxJjzCdZgWLmoWroiYFrJPcZKUDZMXpMPzObinx3FfH6bvE3evyfaKOIxu8gmIrY40ZInH9hAUxfxLckFKGZMXRi/8ULXehzGue2BkxdxhjP01j72GNzZC/gMfX3bZkmPSCCNm53sRxo7FY66XROw/0fKZaPkcYDFTIa2rlO12JmPJMbm2K0PeNnDDiEqrncl4pmR6tOWx1ibBZdvk5ZnGyj9v3AqcuN9DzP3FnRCLvd4Fxlm0TUbrHiJ4689mvZ8xxYWTPJYkirneUsdFCMHsi8+S3Xcdmm7GP6/mSWkqXYbO2KyPFnV+cYp7XIQWb73Yv4cEzs8l1znPGIuWyWjNQ7vAHETce1Hc33pcVvIVyHDoAmyReFGLeWKJNbJkHgizjKm1ZbenxjyYhhbvoqDGvPnYWjwxSVc7G2foh7z+tUP0vPM6tIyz7PIlHB5ldOH/VbXz712L+SQnYtxzAKILrFfD51Xh86qYW7g/GigUFZuS4jCo2LzN6KGs2OgojAr3nGzG4ahF400GMKoe71yJvPaNrm3Isg6ZczHvx7EvSOsehy29Qw2FgmEyFLbeulzccV5gfxdCaPHWU+Pu7wJ/m/3Ri6gZh9TNV75luQv9jpaiqDi8yDR+0HkQF4bxTlBNi3svirVa7HtY3KK5N4+zXziM0iJc5vvRYx6XzRYzrtVlZHsIipJlMVWFPseQGYoxqD7+CGa+iHPJ5csuW7ZNhpvbP+W/HkQcrTU5WlucxdEVhbxtUJ4vmb65N8uHHBNTVRlr+VTOuEzPi431VfTyLDkmPxiVWV1JUpQOz2+hNXQSf2qCwgd/Yk22V7RNpr2AVrT5ek5tF7K6hqOpjLky01YiWSn5KM1JrbrRw9hynPrBcVqTTXZ98LZll00JjS5MRrZ5xpGP4A3R5FS0WHKsAD2KwaDiUFZtLlfT3KP20auYTAt/vh/jmWxGl8lVGMCUpcNz4hR0A19ETIUyC/QMIoqYffgA2TuvQTXWRm4p4DCCNAtJEumiHQ8pKO4QChmTuh9S82RPgE7wpyapHzlE/sM/gaIsP2tSdiyGtmC581oQCLFQ+nw2PaZOyTYpOyYXpW3u6M/RZxnM+sGCuFiZ78847vrLBo0ZXSNn6FR26HFeL0oZk9eq2/tBp1NmX3wGPdtF6uLlJxdWQtExGZGl+4lStE2mvAB/A3u+SiRbjXyU4Rnz9EYPY0shhOCVLx2ieNsg9p6BZZcvkmIal9YO7NUlgCnhMyV8XooWS74dVMqq0+7NqNjs07MUDYsQwXDktjMZ50umK1GLlciMg5rNU540l0uSsmFJQ5Y30Tx0kmBihtw7rl+T7WXQSaExus6O8DsKAXkc6aIdAyko7hDKsn9iLKpPPIpqO+Suu3lFy5cdk0cnZOByNtNewLQX8PLsYkNvW1Uozmcylh2Tuwe6KDomAhhtelTOcpp+swFMyTGZdH08KRAkSiFl8uiQPJfPIMKA2UMv0H3THShq7NqmcyjZJpUdkNG8kRQdkxE5+SCRrJhUZJARFuPSkKUjJg6OMfXyOO/4d+9hcgXLbwVDlvWmScTrUZ3Xz2qxo4QKBcViUGv3ZbxOz/E+tW0AMyG8BYHxjNhYfVOvRJmhmDyDhsWwNGQ5h9mHX8Qo9GBftXtNtlfEZgoPfxO6qG8XchhYaExI0bZjpKC4Q5AOz50TuS6zzzxJ1+13oprmssurtAWCrWjIst60IsGJeosT9cWLtkrbAKbdl9Fi35sMYM70ZewxdcZl+WKi2JpKj23IkuezqB09TNRskLvuljXbZtE2+bGcgEiUgm0yKrNAJZIVMxBlmFaaeDswc241vPqlQ2R25Si/bTeTK6iYK5GiQmP5BXc4EVARLpXABRbvlzll3gBGbQuNN+uLBjDDUYshzaMaBViKyngo7wFJUjZMDjTlBMQZItej9vjLdH/4bSuqblsJJWnIkjgFHCZpEUgzso6RguIOoZSxePhUdaOHsaWYff5pIt+j6/a7VrR8v2UgQIpdMYmAMddnzPV5sbq0Acy+XApLU/m9ay9aKJVu92Z0GW35BHE7AUsWKKZNZtyAZiBnQs8we+AZrOIgVr64JttTaAuK0q08WYq2watz8qFdIlkp+SjNuCbdWjuhMVbn1IPHuek3bkdRVyYglHA4iOwFHZdZETAb1jgSLp6rBgpF1aKs2pRJcYfVhQL8q+4rGQ1dTocuw6HLUNhiKHSpCymarwVlw+KBuamNHsamofb0K0RNl9w9163ZNouKw4jMnEuUvHAYk6JtLKSguAPQFMinZYZiJ4goovr4I2SuvhajuwdWEHOU5/uhSTlrbXmzAcw/vmoX3zs1zpQftEVG2+KGngzvL/fiaCrjZ2UznjGBmfNl0NgJxbQ0ZDmbsFmn9srLDNz/oTXbZo+poykK4y0/lvu8ZHkU2hmKsuRZIlk5+SjDmCoFxU44+pWX0SydSz905YqW14VCP7bMUFxjfARvRC3eiFpE3hzvFX3kVZO/b00wqFkMahaX6A5vt7rp10xmIp+h0GUoaIuMw6HLGIEsKu2ArKqR03QqsuR5gdmHXsS+ajdmqW/NtlnA5rCYkfFighRk/8TYSEFxBzCQMgkiwXRLum+tlLBWw58Yp+fud614nZJtyXLnhNEVhQHbYKjlMe0F88d78cGny9AWRMayY3FLb5Y+y6ARRFRa7jkZjWMtj1Cqv+elLSjK4PAMc4deBCHIXXvjmm2zZJuMu558cEmQHlNHVRQmZNa4RLJiBsIMB/WRjR7GlmLshREGritgpJdvjwPtxv8uITPIa1OSDGo2J4ImU5HPVOTzkr8YL1qoDGoWZb3dn/Feo5eyZgFQCTyGgzNCo8tw4NIU8m59PkqGyUTg4crqIACCao3Gi6+T/4UPrNk2FdqCosxQTJa8cDiiyjZEcZCC4g7gTP9EealfOXouh737ImovPU/XLbevaJ1Bx+TgjOwhkiR528CLIqa984vjM37IjN/kyOziDJOhKhQtc6Fk+ra+HCXHRFcUxlzvHJGx0nSpyzJfCimTxyvypnqGmQPPkL7sSvRMbs22WbSlw3PSFKVoK5F0hCk0eoTDmDRk6Yhd77iYF//vp2lNNbF7nWWXL+EwQlNmGyXMoGbxY/f8ZeUuEcfCJsfCxXhRAfqFxaBuUdYs9pop7td76NYMpkK/LTAGbYFxKHSZCP0d/2w1KB2ez2Hu0ZdQVIXsndes2Tb7aAvdU8iJ/qRQBAzgMCqzxmMhBcUdQEk6PMei6/a7GP3yX+BNjGH15JddvuxYfHdU9sNJkrJjUukwC9SPBG80XN5oLN6Ilf+PvfsOc6O6+gD8my5t780N925cMdjYJpjeiwtgqhsQSkJ1qKGHTgIJfDTTCbapoYWShI4xYHrHBZf19r6rKZq53x8jaVf2yqvValTP+zx+MPKsdFc7Ozpz7r3nwF695G8As0emC/sU5aBQkdBieANbpXd02Ksa69T06avGgbY8d6U31EHduhnlx50c1ectc8vY3kHBoZOowzMhvVNsZaKN0+DhaeVcbww5fDi+vv8zbPjXTxh7+sQejy9HBirpxtVRCngUCTIqzfA/ZxmAGtNAjWngiy67XzI4Hv1EJfBnnJyJMlGGCQRWMlbqOrZ77eYx6bRar0JSsJ22Owe0vPsVMqeMgJCdEbXnLIcL1VBhwW5gSaKvgJK2fUIJxTRQka3gsx0t8R5G0skatyfqXnsJzZ98hJJDjtntsTmigAyB73Wyi/ROuVuJynvMADToXjToXnzX3BnUu3gOZb4kY7lbxr4luShzy+AAVHuMQF1G/x+PmXppxgKXb5uoh24oAbsZCy8ryBo1LqrPW+aS8XlDa1SfkwQrc8lUhoKQXig2qX5iJJRcFwYdNBS/vPADRp/ScyOGcrjxKepiMLL0VSEoaLa8aI1C45UOZuEXw4NfjM7VjDyAUkEOJBnHuzJxiFiAHEFErVdHpVfHdqNzRWODmZplpypEGd946JoBANqWGmgbd6Bg3pyoPq/dkIVq+zmpFG7UwgNGq8YjQgnFFOdfbUQNWXqPlyTkTJ2O5nUfoWj/Q8HLSshjK9wy6jQDRhrNSsZDuVvGFw3OBS6qxbC5XcNmf/1AZv8OFSpSYMv0sBw3ZpfmIU8W0aR7UenRsKNDR5VvVWN9ktdrK8tUUNOhw6JTGYwxtHz9ObLGTAAvhVcbKxwix6FYkajDs8NKXTK+aKQbHULCVWJl0nbnCI04fgw2vvwzKj/cCozsH/I4jgFlcFNDFof1ExVUms7VnLMA7DB17DB1fKa1gjPtTEQ2L6BCVFAhyugnKZjoykKpKENnViDJWOlLMlYaOpJ50zQPoEySacuzT8u7X4HPciNz8vCoPm8ZXNjE6LrspBLmRg01ZIkYJRRTXIFbAs8DtR3JneSIl9y9ZqDx/f+h9ZsvkDtl75DHlbsUVFJywHHlLhmvemKbHGcA6jQDdZqBb5o6P9DdAh9IMpa7FYzMyUCpWwJjQJVvBWNVR2dtRi1JOsDQdudOWnUljMZ6lB4xP6rPW+qSoJoWmqn7uGMEDih2SVSnkpBeKLaysEHeEu9hJKWCUUUoHFuMn5/7HkWX7xP6OCgQwKGWGiw4qkJQsL0X252jpdUy8ZPegZ/0zoSxAA5lomQ3gJEUTHZl4wipCBkcj1rTQKWh2YlGw24G05gkqxlLRRkmA+pNuscEgLZPfkD2PmPAS9FNr5TBjY9pRbOjSpkb2zma5IkUJRRTXHmWjOo2Wm0UKSm/AJkjRqPpkw+RM3k6OK77tdAVbhnbY5zoSjd5kgCXwKNaTYzAxWNa2NimYmNb500BD6DIJaFckVGeIWNkXgb2K89DriyiQTM6E4wddpKxQfMm3Nx0WaaMzc10owMAeq3d6dTVb2BUn5casjivWJHgtRiaQjRwIoQEExiHQisDtbTlOWLDjx+Dtde9i+zKeigVhd0eUwa3XQ+NttY5qp/gwntqYtQ1N8Gw3atju1fHp2pnqZMcXkA/wU4yVogKprizUSLKUJmFSkOz//hWNVYl4GrGCklBpZeafgKApRswqhrgOnbfqD6vDB6FnIIqRnG5k0rgxnquPt7DSFqUUEx0kV6lfV9X4W/IEubzhMiXhftyvRfh63ER3iMKESwIyp88E9v++SC0Lb/BPWCPbo+pcMn4rL4VXOqV1Nu9GEYR5S4FtaoBbwQr/bgIxxnJz7Ou3UBdq4Fv0LmaMUPkUZYhozxDQVmGjFHlGSh1yzAZQ7VHx452e8t0dYuGqg6916sZuUgXunXzMmUZMj7Z3rLb50z5+yDfN6jX1UDMzoHgcoX1ZSzMatllbhlVmh44PpbnZ1++LmKRfn8RnNf+97JMllHt0QEzvPM14nO6j5/RhHSHj/CiwPOR/XIbpoBCKxMGTLRw4U+OSpEEVQDECMfptSJrSaCakd3u9Pbr8meNhpT7CRr//Rkqlh7Y7TH9LDeq0N7tz8q0hF6PURQiey+tSAP+SNtCRHhOm6z37wkHoFxQsJ2pMetiwYTef3/N8KLFMPGD0bkySgSHMt926QpRxlR3No7KKYKb41HjW81Y6W8CY2hosnp5QxTp+9HNt1chy9jh1Xf/nDEOGLkIfg4AYJqRvTGKaC9yMKrrAMbgGlAIIYzrmySGd+3szzLRZhnQRRUyB3jN3v8+AIAZ4QxGJNckIPLrEouwiKEVYVwrCpY9mQYX6vgOCJEG5OFK0ZiREooprjxLxvd1VHehLzKHjoSUX4imTz/sNqEo8xwKFYmK/zus3J28DRY6vBY2tqjY2NJlNaNvS2YgyZiXgd9V5CFHFtGgGqhut1cyVrXrqGrX0KA6v5pRETgUuCVUUc1VAIBWVwO5qDTqz1vukvFNC12XnUQdngnpnRIrEzVCexrMGDlHUEQMPGwMNv/rK5SdvB94l7TLMWUsAz9zTbEfXBop4mTwAGqs5PsM8IJhm1fDNm9wHJbLi+gnyfa2aVHBVJe9mtETWM1ob5eO5WrGClHBdxrFMgCgb7O3JMshViZHqoS5UQMPXZcdVAQXdJhoQfJdLxIFJRRTXHmWgv9sTowl/8mK43jkTZ2Buv++huKDjoKYlR307+VuGW1eE21eqofmpHK3jG0dqZPospjdObraYwC+Vfa817eaMVNGeaYv0ZifgZIMGRZjqAokGO0kYySrGXenJFNGq+5Fu5FuS227p9dVI2PQ0Kg/b5lLxps1dF12UqlbxoZWKrBNSLiKrSza7hwFg44ehw3PrEfTe9+i4KBJu/x7Gdx4j9sRh5GljwrehR2mhlSKZJotL5o1L77XfKsZLUACh1LJ7jRdIe20mtFr+Bq/dNZn7PVqxh5USAreamuI6nMmK21bHYScDIg5GVF93jK4UU3NQhxVwjLshiyUtI0YJRRTWI4iwC3xqG6jjHtf5U7aC3X/ex3NX6xD4ay5Qf9W4Vawg1bCOK7CreDT+taeD0xyHV4LG5tVbGwOXs1Y5JbsbdOZCkYVZGC/AZ2rGavadHtFY7uO6rbIVzOWZcqoousFAIBZFoz6WshTQhfXj0SmwCNHEqmGosNK3TI+rGmO9zAISRolZha+kirjPYykl1GRg+wpw1D36ufIP3BiUO3tTCYiBzKqqcOzo/pxLlRaqTMBHYoBhm2Ghm2GBnTJOQVWM0p2fcap7hyUiJK9mtG7U21Gb2SrGTM5HnmCiEovxTIAoG+vg9y/KOrPW8rc+JJq+zmKOjz3HSUUU1h5loK6DgMGdWTpMyEjE9njJqHps49QMPN34PjOWhvUkMV5Ms+hQBGxoyM9AxeLATUdBmo6DHxdt1Ntxky7y3RZpoyRhZ2rGavbu6xm9CUcVXP38/XU4bmT0dQAZpqQi0qi+rxlLhkNugGNrsuO8ZehqPYkRgMnQhIdx4BiKxO1PG1fjIbCw6di87XPoOOn7cgc1T/weBkyUA8VWtoV3I6tCt6FH/T0TdruspoRXVYzyr7ajK5sHJVtr2asNQ17FaPXTjRWGhoae1jNWC4pqPcaUBmdywCgba+De2hFdJ+U2c1CaIWis0qYGxs4moDuC0ooprDyLBk7qBZa1ORP2xctX36K9l9+QNbIsYHHy90y3qOVMI4qc8no8FpopW3lQfyrGTc1dLOaMVNGWaaCEQUZmD0gD7mKiCbVsFcx+pKMVW066j2dc9NlWQo+rWyJzzeTYPS6GgCIeg3Fcurw7LhSl4w2g8pQEBKufOYGADTw6ZuEiabsyUMhl+ah/rXPgxKK5SwDVbQ60XEVvAtvm7QVt6vAakazm9qMor2asUJUMMVXm1FjViC56F/VuMOrQ2d2xNhPtDs8E4BZDPr2euTOmRDV582GBDdE1II6PDuphLnxEV8V72EkNUooprDyLAW/NdNFKFpc/QbAVTEAjes+CCQUedjJrmRtFpIs7IYsFLiEI2g1Y23nahO3bzVjWaaMsiwZwwfkoSRDAgNQ40syVmTJ4HkObpGHx5ves856bTU4SYaYkxvV5y13ydhBCUVHlbp9HZ4JIWEpNrNQx7cjwgabZCccz6HgsCmofuIdeJccADE3E4BdD20HrTZyVAYE5HESKk2KGcPRbHnRrHvxvR7cabpUlANNYCa5snFEViEyeAF1vk7ThYKEOlNHgSCi0XS+aWAi89a3gGkGlH7R3fJcCjcaoMGgFc2OUZiAPCi05bmPKKGYwsqzZazdTivnoilv2kxUvfQM9PpayIXFKHZJsBhQr9HWOieVU53KPvN4LWxqVrGpa21GBhRmSCjNlLFHrgsiz2H/QXk4bmQxmjVvYKt0VbuGqjYddR4D6bJTV6+rgVxUElT/KhrKXDJ+rqPrspPK3LQKlJDeKLGyUEPbnaOqYO6eqH7yHTS89RVK5s0AYK9Q/JqnlXNOquBdaLB0eFKqJUtsecGw3athu1cD4KtdzoAcXvCtZJQxXM5AJi/gyuI9YAStZuz8r5Ym26G17b4Oz1GuoVjK3KgGJbqcVMzcaIUODxfdhkXphhKKKcot8sh3SdRgIcqyx01EzZv/QtNnH6Pk4KNQ4VZQpeppPTMXCxVuGR/X0VbcaLMA1HYYqO0w4LUY9sh14e+fb4dL4FGaJQdWNO7TLxelmTJ4jgusZqwKbJ3WUrIrtD+hGE0c7IQiJbucVeqW8HUjJUcICVeJlYmfxbp4DyOliLkZyJs1FvWvf47iY/eGzIsohAs7aMuzoyo4FyoZ7c5yQotlokXrwM9aBw7NLsRfa7ej3jRQGtgyLWO8komDswqQK4io83ea9tpdpiu9GurMSFrAJDZ9ay04WYRUFN0dLSWgZiFOK6WGLFFBCcUUVZ4lo1E10n7bYrTxkozcSXuhef0nKPrdIXZDlg7aVuEkDvaKI9ry7KyuDVlU08JvzWpQyQQOQL5LRFmW3Wl6UI4L0ytyUOCW0Kp7Ud3WNcmoo7ZDh5nEUaNeV4PMYaOi+pyFsggeHGppRbOjytwy3qpsjPcwCEkOzO7w/IG8Od4jSTmFh09B43+/RuvnGzBm2kR44EUr6PrvpH68C9stSig6qUiQAAC1vuRgpVffpdtzFi+gwp9olBSMVTJRJsqwGLDDqwclGnd4NXQk8WpGbXsd5IpCcALf88G9UMYy8BPfFNXnJMFK4EYtJRT7jBKKKao8W8GOVloF44S8qTPQ+NG7aP3uS5SPPgpfN9FKGCcVKCIEjkOtSkG4k8qyZGxrCZ20ZQAaVC8aVC9+qOtcYSELHEozZZT6VjNOLc9BaaYMSeBQ12H4Eo2anWxs09GiJ36jDG97G0xPuyMdnms0nTZiOShT5JEtiVRDkZAwZTMFMkTUUUOWqMsY0Q/uYeWof+0zlE3dB1Xw2LNzxDEVvIJvDdrR4qQKSUGVsfvdWW2WiZ91D342OpM1PIBiQUaFJKOfqGC0nIm5mfnIFyQ0mkZgFWOlV0OlqaHGTI54Sd9eDznK9RN5BhTBRVueHVbM3Piar4/3MJIeJRRTFHV4do5cUITMYSPRuO4DVJwyH/+mlTCOqnArqFaTI6hIZmWZMj7f0drrr9NNhq0tGrbulIzMVezVjGWZMsqzFEwqy0ahW4LqtQKrGP1bp2vadRgJVJyxs8NzdBOK1JDFeaUuGY2aAS2BzidCElmRmY0GvgMmFf53ROHhU7Dt7ldQ3C5gRyYlbZ0kgEMpp9CWZ4f1kyLr8GwBqDZ1VJs6vkBb4HE3x3euZhQVzMnIQ7mkQABQFVjN2JlsbGWJNTGtba9D/piBUX3OArjAwNAAupd3DPNteaakbZ9RQjFFlWcp+KaGVs45JW+vfaG9+SLcAk/10BxW7papIYvDJJ5DgVvCjvbovc/NmhfNmhc/1XfpHMhzKPE1gSnLUjC+JAsHZslwizwaPEZnbUbf9ukmNT6dA/W6aoDjIBUWR/V5y1wytlKJBEeVuWVU0fWCkLAVm1mo4dt6PpBEJG/WWOx4+G2UtPNYTwlFR5VwMrxgaGAGACHew0lZFaKMn7ToncseZmGDoWKD0aXMDs9QKEioEO0k42DJhZnuXBSLMlotb+dKRl+iscqrIx4Ro9muwmxsg9w/yvEic6MWKhitaHZMFkRkQKItz1FACcUUJPEcijIkWqHooMxhozCgcjwqa+vgZbQSxknlbhkbWuli76SSTBkew0Kbw9uRvRZDZZuOyjYdqO68gc2Whc5t01kyxhZloihDhskYqrs0gfHXaFRNZ1fS6HU1kPILwYvR/Ygsc8lY19D7VaAkfKVuGdVUHoGQsBWbWfiNp87zTuEVCQUHTkL/nCK8YvwAKPEeUerqx7uww9JSrulHoqkQFfyvvcnR12AA6kwDdaaBr7XOeFHhOJQJSiDRON2VgwpRgcLxqDV1VFr2dmn7j4pG5mz3Xt3X4VmJdodnuFFNiS5HlcCNBqgwaHV+n6VvQjHGGX8W3Tqtu1WSYycHWrTeJwci/hCO8PuL9H3hIs17RDrOnc4XDjxG7T0TG378EV4+F2JGVvdfmOIzS7G4Ble4FXxQ1Wy/VoQnaKTjjPjrIjw/I/66SH9xfV9Xnimjql0L+3kifb1QM62tmolWzYNfGzqDJ4EDinyrGUuzFYwoyMDsAXnIVUQ0qV5UtWt2orHDTjLWeQzsvMuVizCO9Hd47vX1aTe/7xLHoUiWsEPTdzku4s+HSM/PGN9tRfx6EVw/y9wy1ta09P5aEem1OtJrkoM/g1j/fNNCjD/L+Qh/iDLf+w+RYjML37p+Q6bU+5W93lgGtwBcQmQXdSvCZT5WhD/4bFfwhH7psXsBALavXYfig8eG/Lo2rffZRtOM7GfAC5GdY5IYWaDijXCclhn+z6CCV1AJDzjeAsdH+EsrR/ZlzIjw9SL8MiZHORDrAee1v87N8SgQJVQaYS5a4SMcp9x9gKMB+A0d+M3qAHTYfwDkcSL6CQrKRQUVggtT5ByU8DJ0WKg0NewwNVRaGrb7/q7tFECZWmQpEXOHXSInc0Ae+F78bnA9/BhK4cYmrnWX4yL9bEiW+9FIr9WS0PuAuMxyRbzdmUW6dDTBYsZoPW/6JhRTWEWWQqsTY2DIsOFY/+pLaG7RUThz/3gPJyW5BR55skhbnh1Wlimjqi2x3mOTAdXtBqrbDbD6zvINbpEPNIApy5AxoyIXpZkyeI5DTUfnasbqdh07NB2tRu9vfvS6GmSNGR/NbweligTVtNDiTazaP6mmlLY8ExI2xZKQxVyoE2nltJMGFldg+6YqVP5r/W4TiqRvKng3vjKb4j2MlFYhyWgyjYTrytzEvGjyevGd2RkvCuBQxsuoEBRUCArGi1k4WClCLi+i3tI7VzL6VjXWWb2v165trYdUkgveJUX1+ylhGVjL1UT1OUmwUuZGDa0CjQpKKKag8izZ3lJIHNUvOwOvQ0Dz5x+hYJ/9wPGxnalPB+VuGU26Fx6Ht7imu9IsGV9UJccNpcdrYXOzis3NXWrtAMh3iXaSMVPBwBwXppXnoMAlwuO1UNVhr2Ss8q1orPGEbgJjeQ0YTQ2OdHjeodF12Ul5kgCJp47whISryMxGC98BI+JtHyQcJVYm6pQOtP1chdafdiB7ZHm8h5SSKjgXXqeGLI6qEBVUGskRy5hg2G5p2G5pQJewIJMTUMErgUTjaDETZYK9Orja0lFpqkHJxrbdNIHRttVB6V8Y1XHLjEcBFEp2OayEubGRp47w0UAJxRRUnq3ggy1N8R5GSnMJPAoVCc2lg2A0NaB9w4/IGj4m3sNKOeUZMnZQEwvHlWUl3grF3mAAGlQvGlQvvu/SBEaQOZRm2CsZyzJkTCrOQlmGDJfIo141UO1PNPqSjY2aF3pDLcAY5KLSqI6ROjw7r9Qto141qK4tIWEqMrNQJ1BDFqeVWJn4pVSFUpqDqn99iexLKKEYbTkQkQEBVZRQdFSFpGB7BB2eE0k7M/GL2YFfzM54kQNQzMuo4BWUCwqGiRmYpeSjiPc1gemykrHSVFFt6TDAoG2rR/aUoVEdXwncaIWB9kjr9pAecQwoBq1QjBZKKKYYngNKM2XsSOLkQDIod8to1r3wFpdDKe+Ppk8/pISiA8rdCipp+6KjchUBssCjtiP1VnUZFsO2Ng3bdioBkS0JgS3TZRkyxhZkothtN4GprM/DL+7fo334aFRbQJWqoyMKK2TLXTK+am7v+UASsTIXbXcmpDcKvdmoF5JjdXoyK7Ey8ZGyFWVHTMTWJz7CHmfuBynHHe9hpZQK3o06pkOnliyOqhBlvOtwQ5Z4YABqLB01lo4vvZ3XRAU8ygUZ5bxdm3G6nIsKoQQu8Ki1dPy6aDEaSmS0sjxUowNN0PvcmZm24jovFzJEcKgHTUBEAyUUU0xxhgzTYmjwpF5yIJGUu2VUejRwHIf8qTNR9fJq6I31kPOju+w93ZVnyPhxR0fPB5KIlWYpqO8w4A2xBTgVtRomWps8+KWpM2DjOaDIJSFz248otFSMLszFfi4F+bKIZsOLHR4dVar9Z4eqo0bTYfbiLStzyXijutGB74b4lbllVFNCkZCwFZnZ+EWpivcwUlqmJSGDSajl21F6yHhsefxD1LzxDfrN3yveQ0spFZwLlYySME7iAJSLCiq96fM5q8HCZlPFZlMFjObA47mciNImD7J++RXjxv4O/awiFMMFLxhq4EEV50E1OlDDeVANDzy9KCtRyjJQDbr3cVIpc6MOKizqYhcVlFBMMeVZMna0aTQ/57AKt4LKDvsDNXvcJNS89S80ffYRSg48Ms4jSx08gFKXjB2e5N5akegSsSFLPFgMqPEY2PbhRzA6mjFgj3EAABfPo8wlodytoMwlY+/CHJS5ZLtWn2bYCUZfsrFS19Fk7LpFJUsQkC2KqKIaio4qdcn4roFWgRISDpEJyLUyUEcrFB1VYmWikVNhcBakvAwUzR6Jqpe/RMXx0yLvREx2YScUabWRk4oECQIH1KRRQjGUZubFjl9/Ru0LL+DHYwdBEmogMA6FcKGMuVEKN0awPMxi5ciFjGbovkRjB6rhQQ3vQR1UmN0ktEqZG1/wdXH4rtJHCdyo4eh6ES2UUEwx5dkKbXeOgYoMGT9V2bNHvCQjd8+90PzlJyja72Dwkhzn0aWGYpcEkzE0aFRDxEnJXj8x2vSGGij9BwT+X7UsbO7QsHmnWp75kogyl4wyl4xyt4xJ+VkoViToFkO1bxXjDk3HDlVDpiCgXjegpdEq0FjjAZS4JNryTEiYCs0seDgdHp5+Z5xUYmWihu+c6Cg7aiJq//M9mj7bhPy9hsRxZKmlgnPhc6sp3sNIaRWSgh3e3ndCTlVGZQ2ETBfEvEwAgMnZqxN33q7sYgJK4UapL9G4FytBqemGCA510FDN2SsZq+BBDTwogRvVtOXZUSW0rTyqKKGYYsqTqFtrshI4eyXM9i4JhrypM9D4ybto/f4r5O45LY6jSx3lGQqqPFQNx2llmTK+pGsGAIAxC1pDLbInTunx2EbDi0bDix9aO7el8AJQqviSjIqMsdkZmFuch1xJhG5ZOGNgKao0O9lYpeqo1Y1ebZsmoRUqEgDQBAQhYSryZtPqxBgosbJQw3c2vskeXYHMYSXY8a8vKKEYJSI4FHMKKi1KEDipQpSTpsNzLBg7aqH0LwTH7X6lscqZ+A1t+I3rvA7wsOv42UnGDJSxDExghSiCCxyAw8wBqOLs5GS1b9u01ott02T3Spkb33IN8R5GyqCEYgrhAJRnKXitrT7eQ0lpJS4ZXsbQqHfeuMqFxcgYMhJNn35ICcUoKXfL2EGrjRwl8hwKMyRUtdP7DABGSxOYoUMqLono600GVKo6Knfq5nxi/2IwBmz1aCh3ydi3MBdligyB41Cr+xKMWud/mwwKGnurzC2jWjVoAoKQMBWa2agXKaHotBIrE9+I1YH/5zgOZUdOwoa/vgF1RxNc5XnxG1yKKOdc8MBEM2hCyUkVkoINOiVt/YwdtcgcHFntfMYBTdDRxOn4CZ21GUeYuTiMDcRnfB1KmRujWB5mW+XIgYwmaKiCimp4An/qoHW7bZqEJjAORXDRCsUoooRiCslziRB5DrWUHHCUnejatU5l/rSZ2L5qJdTKrXBVDOj2a0n4yjNkfNdI9dCcVJIhQfVaaNEogQUAen0NAEAuKo3q8xbLEt6pa8bXLZ3nMwd723S5b8t0P5eCKXnZKJYlaJaFKtUIJBl3aBqqVAOqRRuNQqEOz4T0TpGZhS8kmoB2ksR45DMXavngWKZ4/9HY/MA7qHrlK+yxbE6cRpc6qH5ibFSICt5PwQ7PkWCMwdhRA2XW8Kg+bzHnRiXa8RUffG12MwGlLAPFVgbK4MY+KEEJXBDAoY5pgQRjle+/zTDsQJPsogAKvGBogk5vUZRQQjGFVGQrqGnvXedR0ntdG7J0lTl8DMTcfDR+9iHKjzohDiNLLRVuBW9XUldcJ5VlKaimCYgAraEGnCBCysuP2nNysEsk7NyQhQFoMLxoMLz4rq1z27TIcShRJJQrMspdMsbmZGCuYm+bbtS9wUnGDto27VfqlrGlnW4oCQkHzzjkm1m05dlhxVYmOjgD7bwR9LjgklBy8DhU//sbDDxtJniZbsf6ooJ3odKi67+TFI5HkShhOzVkAQCYza1gHg1K/8hWKIZSyrqvn+jhTGzmWrGBdZmYZkAeZJTBrs1YjgxMRCGKoECDiRqmBhKM9h8VKm2bRglzoxYqGEc512ihT7AU4u/wTJxVkSHji4a2XR7neB55U/ZB/XtvouTAIyG4M+MwutSQLQrIEHlaceSwUmrIEkSvr4FcUAyO56P2nIWyBA5AnWb0eCwAeBnr3DbduQsGGQKPMl+SsUyRsW9BLkrL7W7TNb5u01VqZ33Gxm66TaeyMpeEdXUt8R4GIUkh38yECQutPG35ctLODVm6Kj9yInY8/znq3v0JJQeOjfHIUksF58YnFtVDc1KFKKPZ9KLdooQUAHh31AIAlP5FUX3eUubG91x4iykYBzRCRyN0/NAlYBQZh2K47EYwcGMUcrEfyuxt00wP2jJdDRW1IbpNp6pS5kYN19HzgSRslFBMIeVZCn6qp18Qp5W7ZbzS0X3iNnfSdNS98waav/wUBfvsF9uBpZDyDBkNmhc6dcV1VFmmjK+qd02OpyutoRpKYXS3O5e7ZNRoRp+7InaYFjZ2qNjY0bkKg7OAPN+26TKXnWyclGd3mzYs1plk1DqTjR4z9bZNixyHQkVCtUrJcULCUWRmo05speUZDiuxMlEdIqHo7l+AvMmDsONfX1BCsY/Kacuz4yokBZUGLVrxMyprAUGAUpYXtefko1Tbz8sx7IAHOxD8PG5/t2m4UQYXpqMYJXBDAo86pgYSjP5kYxN0sBT8jCiBO6hBDuk7jjGWtHfsLS0tyM3Nxatrv0RmVnavvjZZvune/B43b/oBmWUDIbozI//+Yn3hiPHr9fXCaBk62jb+hOzhY0OuYrrxkgvww9dfYuW//g3ZpfTtBXsrWU7sHmj1tTDVDmT0GxT8DxF+fxH/2GP9fsbw+2OMoWXTD8gs3wOiKyOyF+6tCH8QEf/e9vLrjps1HUcuOBGn/fGPUXs9raYalqHD3c+BuqohzhdmWbB0DZamwtJUmKoKS9PAvAY4UQSvuCAors7/ykpUV2XGmql60L5lI7KHjwEX8w+VyL7MycUA7W2tOGL6RDQ3NyMnJ8e5F0oifYkXgeT5aA337O+orQQHwF1cAaAP3x/FjLvV9tuvUPKLIOXkdfvvH7z9Jq4+72zc8/QajJ00ObbfX7Kc1D2wdB1tm35G9ogx4Lgun2MUL3Yr0u+vo2Y7OJ6Hu7A8wmfopQSPF+++8Vqs//gjrHz9jai9nqmq6Nj0K7JGje2xc3SvhYoXGQMzDDtW9MWM9h8N4HkIsgK+a7youMCLyb0erXXDT3CX9YOYmZU8v7cOjTNa8WJynxEkwPIaYKYXguKK91BSmqmq4GXXbm++55++GOeduAC/X3AsLr/tLgwZOTKGI0wNpuaB4HLHexgpjZleMMuEINM1AwDaWlrQWF+HgUOGRPV5LU2F4I5RwtaH43kILvcuv0PMNGFqKphqB45GUwNUTQUsC7ysgFeUzoBRcYGX5OgHtQ4wNRWC4rLHmiI3yYQ4ydQ8UHIK4j2MlMYYg6Wp4HcTy+yz3/4YPHwELl16Os694mocctzxSXHNTSSm5gGvKMHJRBJ1pq7SNaOLrZs2OhIv8v5YJkY4jgMny+BlGWJ2Z0LJPzFtx4sazPY26A119sS0sNPEtCt5JqaZZYEZOnglxgt+UhwlFFOEqXnASwo4Xoj3UFKapXkguHafgBkxdjzuXfMCbrrkApw97xgsvegSHH/q6eCT4EKbKCxNDTmjT6LD1FQ7YUTnJQDguScfAy8IGDV+z6g+r6mpkPITIwjnBAFiRia4LvVdGWNgXgOm1rmi0WhtgaXbW5t2Wc2oKOAEMaFuev1BOCGkZ4wxXxKeJu2cFLiGSnLIYwRRxD3/XIO/33Q9brtiBda+819ceN2NyM2PXmOwVOefUCLOCVwzaAIaAPDrjz/gy3WfYOkfL4rq81qq2uM9Zqz4J6Y5xQ2py+P+iWn/ikajuRFqjQpYJnhJ3nU1o5xYE9OWpoITBHACpcCiid7NFEEfqLFhhrnaaOjIUbhvzYt48K7bcN/NN2Lde+9ixV9uRVFpdOuzpSL/rBidz84ydQoO/X75/js88X9/x6LlZ6PfwEF9rnfoxywLTNcTOtnFcRw4SbZvertsBWWMBbZNm5oKs6MdemM9mKGDE4TggFFRIMgucEJ8JrRMTYWURVt7CQmHZegAGHiZVmg4yeq6cno3MjKzcOmNt2D67P1w55+vwNKjD8efbr4NU2bMjNFIk1s8dgGkG8trAIyuGQBg6DpuvuwSDBwyBMeefGpUn9vUVHsbbgLzT0wjY+eJaW/QtmmtrcvEtKzsNDHtAifGZ2LajMMq0HRACcUUYW8RpQ9Up5mqB3JeYVjHyoqCcy67EnvNmoNbL7sUS486DBdefxNmH3Sww6NMbpauArwATpR6PphEzNQ8lFCELzi8/BLsMXQ4TjnznKg+d2AmNAnrzXAcB8EX/AXNTltm8GrGlia7PqPpBSdJEGQXeJe/NqMLvCI7vhXN0jTwhXQuExIO/7WfbqicZaoe8L1YBTrn4EMxZtIk3PKnS3DJ4lMx77TFWHrhxZBpa95umVr4cTmJjKl57C2ttK0cT95/LzZv+AX3PfM8ZFmJ2gQ04NttURjdrtGxYE9MS+AlCWK3E9OaPTHt6YDR1GBPavFCYNdL12Sj0xPTlmaXLiPRlXx3OaRbpuaBnJsY2+pSFTNNMK/R6+Xo0/adhYf+9SruuPoKXHP+73Ho8fNx7uVXwZ2Z2fMXpyFTDW9Wn/SNqauQs/LiPYy4e/y+e/Dbxg34v9UvQpJDb02LhKmm3kwoxwsQ3RnATitCrJ1mp/X2OpiaBjALvKKAl4O3TnOSFJX3JXBdpptuQsJiah7aARADpqZCys7t1dcUl5bh1ocfw3OPPYKH7rwd6z/+EFfcfhcGj6Ba3N1hpglmGAm9CyAVWLSjBQDw03ff4MkH7sWpZ52L4WOi25k9Fc/l4Inpzmuhfyea3TBQhdHWAqu+BszrBSdKEJSdGsFEsT6jqWmQsmlHS7RRQjEFWKYJy2tQPRyHmZoHnChFVHchN78A1959L15/zq6V89Wnn+CK2+7C6D0nRn+gSc7SEqeGSKpizP4wT/dZuh+/+RpPP3Q/Tvv9eRg2anTUn98uyJ8e7zEviuDFrKDtOv7ugUH1dlqboto90NRUe+sM1cMhJCxUIsB5dkMWD4Si3pe54Xke889Ygsn7zMCNl1yAs+Ydg+UXX4pjTz6NanHvxH/9T/aus4nOLquV3rvgdF3DzZddgqEjRmHR8rOj/vzpdC6Hahxomd7A7hdT07ppHOgKSjZG0jjQ0lXwSkk0vx0ChxKKra2tWLt2LTweD4YPH47Ro6N/o0Y6+RNdPN1QOcrsY7FcjuNw2LwFmDB1Gm669CKcd9ICnPr787DozLMhpMEHSLhMTYWUmxfvYaQ0U7cTOnwabyvXNTs4HDZqNE5aepYjr2GpKsQ0Ppe7dg9E1+6BzIKl613qM7ZBb6wDM4xu6jO6IMhKyG0w1JAluVG8GFt2cwUPXIVUz9lJzOsFM80+XZuGjhpt1+K+8zb846Yb8Mm7di3uwhK6GfazaLVtTJi6CjnNOzw/9ve7sW3zZtz/7EsQpejHzpZKsQwviOAzsoCMnSamvf6Jaa37xoGBZOPu6zNaphfM66VrhgMcyWL8/e9/x6pVq2BZFrZu3Yrc3FxceeWVWLp0qRMvl/ZMnRqyxIKl9a4eTij99xiMu59ahSfv+wce/8fd+PSD93DZrXegYsDAKIwyuQVudpTyeA8lpVm+bn2ptBW3tx75+19RuXUL7n/2RUeCQ3uFCl2bu8NxfPf1GU0Tpt5DfcYu3aZ5RaHOk0mO4sXYYqYXzDLpd8ZhgZpzfVxRqLhcOPfyqzB91hzccvmlWHLUYbj4hpuw7wEHRWmkyc1usEC7s5zELAuWoaf1NeP7r77AMysfwBnnXYAhDpUfoMnR7gU3Dux8vOf6jMFJRkFx2XXNRSluDQRTmSMJxWnTpmH8+PEYPHgwRFHEM888gxUrViAvLw/z5s0LHPfNN9/gxRdfhCzLmDt3LiZPnkzL+SNgF9imD1SnmZoKJUrbhERJwunn/xFT952Fv1x6EZYfcyTOu/JqHHTMcWmd5GFeI7C0nTgn3Ts8f/fleqx+5CEs+cNFGDzcmeCQmb4VKmmy5TkaOCHM+oyNdfYqW8sCOA684oJWV9PZbTqCbTAkPihejK1oJbrI7kU7OTBt1mw8/K/XcPtVl+Pqc8/GYfMX4Jw/XZn2tbhNTYWSn3xNLJKJqavgeCFty4poqoqbL78UI8aOw4lLljv2OpaqQspP71WgvdFjfUZt1/qM4HlwHAe1ZkdnslGiz8No4BhjzOkX6ejowEEHHQRBEPDuu+8CAJ577jmcddZZGDFiBDRNQ3V1NW688UacempnC3ZVVaFpGnJzuy9q3NLSgtzcXLy69ktkdukqFA7Hv+koCeeWqGXLz3AXlAXVxIn4+4v1PViMX49F+HrMstD6y3fIGjzS3r4XrjBer72tFfdcfy3efOkFzDnkMFxwzfXIycuLcKCRfVmiMFpboNVVIWvwiO4PiPD7i/g0i/X7GaPvr237JkhZOVByYtwZMdLfv0h/gN18nerxYNlxRyA7Nw/3PLmq23IDVqSTl11ez9vWCnVHJbIcSlgCiPx8SfLrBOCbnTZ0tG/61S6RYFmBLTHg/NtggjsIckL322D6NpDIvszJn0F7WyuOmD4Rzc3NyMlJrlp5iRgvAsnz0drT2a02VMPUdWSWDQh6nGLG7kX62dOx/TcIrgwohcW9+8IeXo8xhteeXY1/3HQ9CktKcPltd2H0hD0jG2SynNQhMMbQ+st3yBw0rPudABQvdqu335/W3ACjrQlZFUMie8FIJUC8CAD33nITXvznE3jwuZcxaOiwXf49GvEiYwxtP32PjEFDILgdWiCUgLFKLDHTi44d2wKLVvyT1LAs8JK8SxMYu6u5Ax84CfZziFa86FhKljEGy7ICfx82bBi2b98OAPj2229x3nnnYf/998cLL7yA//73vzj55JPx+9//Hlu3bg08xw033ICRI0eiurraqWEmPX8mnrbVOcvy1ZzjHNgamZmVjT/dcjuuvuturP/4Qyw9+nCsX/tR1F8nGdj1cGi1rdPsMgnp+T4//Lc7UFO1A3+66VZHa5dScyFncRxnzyozC66ScrgrBiBr8HBkjxiLzEHDoBQUg5MkmJ4OqNWVaNvwI1p//QHtWzbAU70demM9vB3tYKY33t9K2qN4MXZMKsMQE6ZD13+O43D4/IV44IWXkZWTi/NOnI8n7r0Hpjf9rmOBGmq0o8VR6byj5ZvPP8Ozj6/EkvMv7DaZGC2B3VkKnctO4QQRME1Iuflwl/VD5qChyB4+BllDRsFVWgHBnQFmGNDqa9H+269o/eU7tG3+BR2VW6DV19grHQ0dMViHl5QcSyh2zep+8803+PDDDzFr1iwAwKOPPgpZlnHdddehpKQEOTk5OPPMM1FUVITnn38eAPDaa6/h3XffxQcffIDSUioeHUpgKXoaN1eIBdOX6HJyG91+hx6Oh156FQMGD8bFp5+C+265CbovYEoXZhp1xY0Xy2uAmV4IaRiEf/XZOjz3xKNY8oeLMHDIUEdfy6QC246zNNXu8tdlu4p/G4yUnQtXUSky+g1C1pCRyB4+FpkDBkPKLQDH8TDaW+DZsQWtv/6A1g0/oH3rJqg1O6A3N8BUO8B8CS7iPIoXY8dLk3aOY6YJZuiO1vbrv8dg3PP0apy0/Cw89ve7ccGpJ2HHtq09f2EK8W8rp/IWzrInIdLvmuHp6MDNl1+CMRMnYd5pix19LUtVqRSFw+wa/cETahzHgZckiJnZUAqK4S7vj6w9hiF7+Fhk7TEcSmEJBMUFU1Oh1VahbeNPaP3le7T/9is8VdugNdbB295m31eleaLRseUZpmlCEARUVlbi0ksvhSiKOO+886CqKl5//XUccsghGDlyJBhj4DgOoigiPz8fmzZtAgAIgoCrr74aw4YNCxxDdmX6OpzR++Msq48dnsNVXFaO21Y+jjWPPIyH/3oH1n/8ES6/7U4MHh5iC3CKMTUVch7VEHGSqfuTMELSb3nqDU97O269YgXGTpqM40853fHXszQVYnZybTdNNmYv6pRxPA/B5YbgCr4xYqZpb5XW7e0vRnMTNE0Fs0xwkmwX9pa7dJ2WZXAcBf3RRPFibNgdLg1aoegwU1PBiSJ4B1fAA3Yt7sV/uBDT9p2Nv1x6EZYdfQTOv+rPOPDoY9Pid4BW2zqPMQZT94BPw0aJD951G+pra3Dz/SshONzEgxZTOK83Nfo5jgPn2/Yc9By+BkX+7dJmexv0xnowQwcnCOADjQM748Z0aQDjyKedPzj8+uuvccIJJ6C1tRXPPPMMJk+ejHXr1mHjxo247rrrgr7G5XKhubkZJSUlAICDDz448G89fTAyRHBfnCSftT0lvP0dznY5LMXr2sSaqXkg5eb3/gsjSNjwHI8TzliGqXvPxA2XXICz5x2Dsy7+E4456ZSwfhciEuufXzcDDczqy+6Q30iq17aJhaCuuLGuRxVpHibC97Pr693vCw5veegR8JKw+6fs4/tid3jWwt++ksDnS1z18L5Yqu897sP7xwkCxIxMIKOzuQFjDMz0BroHWroKrbHOrs/I7IC0a60dQYmgEQz9zAEkSbwIJE2Ms7uY0Qx0uBQpZnSQ5Zvoj0gEJ+eESVPx4POv4O4br8HNf7oEa9/5Hy788w3IDlFPtA8vZUuAeBEALNUDMSuH4kUH+ZMwgqSkVbz4xdqP8cJTj+Ocy69E/yGDHY0XAd8KRYoX+6anfImq+eoi8pHXMeT5Lo1gury0Zdrxou5rBNPaAkurATO94EQp0DCwa9zY69WoCf5zdyShKAgCHn74Yfzxj3/ExIkT8eabb6J///4AgK1bt0LTNEycOBFAZ/Dn8XhQU1ODgQMHAgDNMofJ1DyQ86jDmZP8y6RdMV7yP2z0GNz/7Eu4/45bcPeN12Ltu//DihtvRUFxL4t8JwlTV8EJzs/qpzu7fmJ6zYSu//hDvPT0Ezj3iqvRb9Aejr8e1XaKDVNXoWRG//OP4zg7CBQliJlZgccZY2BeI9A90NI0GK3NXX7evplpxRX4OydKFMvsBsWLsWPSdueY8E/0x1JWdjYuv/kO7D3nd7jr2quw5NjDcNlfbsek6fvEdByxZGoq5MKSeA8jpdk7WtJrK25HWxtuu+JPmDB1Lxx78mkxeU1L0yDm5sXktdKVpamOxeQcL0BwZ0BwZwS/pm9i2tJUmLoKo7kBqqYBltmlEUxnsjGZd8BE/c69pqYGl1xyCZ599lksX74cd911F4DOWejGxkZkZWWhqCj4JmDjxo3weDwYPnw4gJ5nmYl/KXr6JQdijRkGYLG4FMtVXC6cf8WfMX3WHNxyxQosPuYwXHL9XzBz/wNiPhanWb3YvkgiZ2oqpMz02Yrb3taKW6/4EybuNR3HLDolJq/pX51In2POsVeBxvaawXEcOEkGL8lAVufvEGMMlq7B0u0VjaanA0ZzY6CZl7/bdGfnaRcEniZOKF6MLbMvK+dI2EzVAyVOia79Dz0C4yZOxl8uuxgXLT4FC85YisXnXwA5xSa3LK/XVwuazmcnpeO28vtvuxlNjQ24/dEnwMcgkcqYZTfxS7P3OdYsPfb3mLwggs8QQ+yAUX07YDRo7WHsgEnwZf1RjWg3b96Mk046CfX19XjggQewaNGiwL/56w+0t7cjJycH7e3tyPUtxzcMA++88w5KS0sxcuTIaA4ppQVWRUipFSgkGlPz+JID8Zs1mD57P6x86TXcdtXluPLcM3HE/BPw+xVXwJ2R0fMXJ4l0DFxizZ/4SKf3+f9u+Qtam5pxyeNPxyQ4BPzbV2glkJOYoQMsMVaB+hvB+JvB+DHLCiQZLV3z1dupAzOMQL0df7JR8P09XertULwYe6amQsrOi/cwUloifMaWlFfgjpVPYvUjD+Hhv92Jzz/6EFfceif2GDY8bmOKNktTwUlS2lwv4yXdFq18+sH7eHnVP/GHP1+HigEDY/KalqYDHA9OouaqTjI1FUpW/BdTBO+AyQ48zhgDM4zAtmlTU3faAeOLE/2JRtmVUDtgoppQXL16NdauXYvS0lJ8+umnMAwD48aNQ79+/VBYWAhZlpGZmQlBELB9+3ZUVFQAAH777Te8+uqrmDNnDvLy8mj7SphM3fnOwyRxtgnlFRTihr//H15e/U/ce8uN+OrTT3DFrXdi5LgJ8R5aVFi0fd9xlq4BHAdelOM9lJj49P338OqaVbjgmutR3n9AzF7X0lQIKZTsT0Sm5q+Hk7iffyEbwVgmLLVzG4y3rQVaoN6OaCcZZRcEuXNVY6ptOaN4MbbsYvJaQsQyqcy++bNXMscTz/M4YclyTNlnJm689EKcOf/osGtxJwNT80CQ6Vx2mqmpkNNkEqKttRW3X/knTN5nBo5ceGLMXtfSVPCuxI5lkp1/oicRJqBDsRvByODl7nfAMNWu0ehVO2A1N8Iy/DtglMDkdKA+oyDG/HyKaoR67rnn4v3338fy5cvxxRdf4OKLL8Y+++yDfv36Ye3atQDs4tmWZeH+++9HS0sLGhsbcc0116C5uRmLF9tt2S3LiuawUhat6IoNS02c7lscx+GohSfhgedeRkZWFs45aT6evP9emKYZ76H1ib9OJW15dpY9CZEeXeHbWlpw25WXYcqMfXFEDINDADBVOpedZm9fSdzgcHc4XoDoyoCcWwB3cQUy+w1GzpDRyB4yGhllAyFm5gDMgt7ahI7tm9Gy4Tu0bv4J7ZWbodZVQW9pgql5wJI4VqJ4MbbsGsUCOIG22jvJVD0QXInzGTt8zFj835oXcdjxC3D3jdfisrOWoKG2Nt7D6jNLUyEkSFyeqtJtEuK+m29Ee2sbLr7h5pjtZgHse0y6l3eWZegAEmNHS2/5d8BI2blwFZYis3wQsvcYgZyhY5HVfwjk3ELwggivpw0d1dvQuulHtG78AW3bNsJTsx1aUz28nnZYptfRcUY1ssjIyMDMmTMxc+bMwGMdHR347LPPMH78eADAgAEDcMcdd+Cyyy7DjBkzkJGRgd9++w1333035s6dCwC9bs/eUbUVQkERBMUNQXGnTVMHU/NAzsqL9zBSnqmpkAsSa+XcwMFD8Pen1uDRf/wNK+++E+vefxeX33IHSvv1j/fQIpLMF/tkEtThOcX945Yb4GlvwyU3/iWmN3fM8nUrp5sdR6XihBoviODdIkR3N/V2/PUZdRXe5nqYugpYFnhJCdoyzSsK2O5a/SaIeMWL7ZWbwXeNF3vbnTtJ+XdapMP3Gk+W5km4ySSX240/XHkNps+ag1uvXIElxx6GS66/Gfv8bm68hxYxU1MhZsd/+2IqM3UVHJ8ekxAfv/s/vP7cGlx0/U0o69cvpq9tairErKyeDyQR8zdkSaXPP7vjtHuXhD+zTJi6fweMBm97C7TGWjCvAU4Qg7ZM87IrahPTjl8lMjIyMHv27KDHFixYgHHjxuE///kPGhsbMW/ePIwZMybi1xBcGbB0FUZrIyxD971h9pssuNwJt888GuwVXR4IheXxHkpKs7xeMK+RkDN0oiRh6R8vxl77zsFNf7oIS489HH+46joccOTR8R5ar1maB7ycOLP6qcrU06Mhy8fv/Bf/fvE5XHLjzSgpr4jpa1uqZtfHE6kejpMsTYWUkxfvYTguqN5ORjcdp3UNlm7X2/G2t8LUVXS0d8RxxJGLRbwoZuUAlgW9qc5OysJf/9LdmWRMsRsPgLaIxkoi16nce87v8PCLr+G2qy7DFecsx5ELTsRZl16edLW47dq0akLG5anEXz8x1a6FO2ttbsYdf74ce82ajcPmLYj561uqCr4wsRatpJp0anrj3wEDV/B1nZmmXZ/RNzmttzbB0jW0t7ZE5XXjNu0wZsyYPgWFXSl5hcjIsgtb2m+Yx57J1zww6u2ClhwvdAaLiguCK7lnppnXsFcnJOmWr2SRDIWfJ0ydhodeeBV/u/7PuGnFhVj73v/wx6uuQ1ZO8iSOUnG1USIyNRWu/Ph0n4yVlqYm3P7nyzF99n445Lh5MX992rrvPMasuDc+iLegjtM7FfbmGhviOLLoi2q8mFMAtz9eZCyQjDU1D/SWBpiaCoD56hF1iRmV5K5jaWkqRKpR7CjGGExVhas4cRNd+YVFuPEfD+DlVf/EvbfeiC/WrcWVt92FEWPHx3toYbN0u3YYR5N2jjI1FXwa7Gi55y/XQVU9uOj6m2KeE2Cm6Vu0kvrvczyZmgrBnVwTJ9HGCYK9+6XLDhgA4JqaovL8KbeO2X7DsiC6u8zkWxZM3Q4YTc0Dr39mmuN8AaMr6WamzcCKruQNcJNBojRk6UlWdjauuPVOTJ+zH/563dVYeuzhuOzm27HntOnxHlpY7CYWtOTfSZbpBTO9Kb/l+e6broWua7j42tgHh4C/wHZqv8fxZum+roh0Q7kLjuMgyOnRdKmvuEAM6AaQD8CXZDT0QLxotDXDrK8Cs0y78LlvQtofO3J84k42+vlrFCdDLJPM7Il+M+FLt3Ach6NOOAl77jUdN156Ac45cR7OOPePWLhkea9LCMSDfwI6Ge7VkpmlJ+5q22j54D9v4q2XX8SfbroNxWWx3/Fnqio4UQSXJqXa4sXSNUi5BfEeRkLixehc89PiDOZ4HqIrw14C6sNgr3AwVXs1o97czcy0y52wHRaTJdGV7JJtmfTcw4/CuElTcfNlF+PC0xfhhCVn4vRz/wApwW8wTU2FnF8c72GkNFNTwYuJvdq2r9576w3859V/4fKb70BRSSniUUnOUlVIuXlxeOX0YV+Xk2PyjyQXOyGrQJAVwHczbdexNHxJRhXe9jZoDbVgphe8JO+6+yXBao5Zvgl0Ps6dh1Od6a/TlWD3C6EMHDIUf3/6WTz2j7vx8N/uwCfvv4vLbr4j5jXkestfIoc4xz8J4SpM3fe5ubEBd157JWbsNxcHHXVsXMZg0Y4Wx9klEjQItKPTUYkV9cQQx+1azHLnmWm9tQlWnRo8M+2vyxjnmWlTU4PqKRFnmKoHYlZuvIfRK6UVFbh95RNY/chDWHn3ndj0y0+46b6H4j2skCzTS0v+Y8DUU3v7SlNDPe667krM3P8AHHBEfOqI+oNwhVYoOoq2lZNY6rq9XOoSD1heI7Bd2qt1wGppsOt4i9Iuu184UYxbApxWdMWGpSbfRL8ky1h6wcWYNms2/rLiIiw77nA88vIbKCopjffQQkrkOpWpgpleMMtM6R0tf7vxGpheExddcyM4jovPBDTtaHEclUiIjbRNKHYn5My0t8vMdEeb3S2nu5npGHaYNjUPFFrR5ajArEYSXuwFQcCJS89ER1sr/v3Cc/Eezm5Zmmo3TUrhlXOJINlW2/bWX2+4BpbFcOGfb4zbjTPzegHTpGSXwyxNhZBJE2okvnhfsxypaw1L0wxMSpuaCqPNV8dbEHaNF2NUx5t2tMRGMtfp2nPqXrjh7/dj+fFHomrb1oRNKDLG7Ot/EX3GOsnUVPBS8qy27a133ngN/3v9VVx5610oKI7fvbSlqpDyaSuuk2hCLTYoodiDyGamu3YMjH6Hactr2LXQ6KbVUZauArzQp1kNLtIprwi/rruzTJLlyMfRg0iftus4/YmusH5D4jGFmCJM3QMlMzoNWViEl7OIf3w95Jr/99orePeN13DVnX9DfmlR4HUiHWekLFUFJ8t2bVs6Vx1j6irk/BANJpLlfY/03EyW7y9NcYIAMSMruCO3ZQUSjKbmgdFYa6+a4Di7xE6Xmox2bezoXrhMzQM5Jz+qz0l2ZWoeyHmFfXqOiGK1KMWL/teWJWdixmjEi8zrWzkXTsxI18qImbonaveYiRYvNtTV4a7rrsbsgw7B7448MjC+WMeLzPLtaFFcdK46yOppd1ayvPcJHjNSQjFCvZqZ9nWY5l1dmr/0YWbanjmSk6IYeDIzVRWCK7lnNQxdT4L6ibR6wmmMMZi6lpLbVxpqa/G3a/+MOYccht8ddkRcx5Lqq0ATAbNMMMOgVaAkaXA8D9GdaXdY9PF3Kg9Vx5vvWmKnD3W8qSFLbDAz+a9LuqEDAKQEbipjN6RM3ZVzicLU1JSMFxlj+Ou1V4HnOfzxmuvien9nN3GyEr6JU7KzNBVil1wNcQYlFKMo5My0rsJUPbA0FXqjr8M0uC4rGX2FvGUlrK7NlICJjVR4nw3DgCQldt0IU1MhZebEexgpzTI0AEi5ovyMMdx1zZXgBR5/uPqaeA+HavvFgKnZ20djVV6EECeEU8fb294CraEazLQ7B+9SlzGMMiGWoQOMpXT93ERgah5wopTU1yWvYQAAxASOGU2atIsJU1chp2Cdyv++8jI+eOtNXPO3fyCvoG+rifvKUpOriVOyMjUNcgGViHNa8n7yJYluO0wzZs9Md2n+Ytbt8AV9StB2aUF273KxsXS6aY0FS1Uh5SV3bQtD1yElcBKJMQuWptH57DD/bHMyr7btztsvv4QP//M2rr3n3rgHh4B9zRCzKDnuJOqKSFLV7ut4+0rseDqgNdWDeY3O5i+uzkQjLwQng+x4kTqiOy0VEl2Gbq9QlBN4Vws1sXCef/V0qq1QrKuuxt03XIP9Dz8Ssw8+JN7DsSeg6Vx2FDNNMK9BE2oxQAnFOOA4/+pEFwC7ro1/ZtryB43tLdAaanzNX5SgWWmv2gF3NtXDcZJ/m5DLldwrFL2GkdCzzf46Uqm2ci7RmHry3+zsrLa6CvfccC3mHnEUZh14cLyHE5goSrX3OdFYempuxSKkO8F1vDsnKyzTG4gXTdUDo6UJlqGBE8TgeLGjjW6mYsBSkz85YPi2PCdyzGhqHkg5efEeRkozU7ArLmMMd/75SkiyjPOu/HO8hwOAJkdjwdRVcIKY1CvHkwW9wwmi68y0lG03f7Fnpr2dHabVDmjN9sy0p2YbdFdGZ+AoR7/5SzqzDB0AS/raFrquJ/RsM3Xfig1TUyFlpE5XXMYY7rz6CsiKkjjBoW5vK+cS+PctFZiaCikFt2IR0hu8IILfpcSOCVNVO+t4d9TA0lSA49BmGEFldpxo/pLOTM0DJSs6Tc/ixb9CMVHrbjPLgmXoEJJ8oj/RWSm4o+WNF57D2nf+i+vvvR+5+YmxIMfSVEqOO4yStrFDCcUExnGcryaLFKgx5/W0o33Hb8goHWAHjXo3zV8Cxbxd4CXa6hIJS/PVtkjy9y7RVyimwjahZGDqKlyhuuImoX8//yw+efcd3Hjfg8jJy4v3cAD4VqhQctxxlqaBL0ruiR5CnMDxQlDzF8YYWjb9AFdhGTjO/rzVW0I0f/H9l+p59Z6/dEsq1NwGkLB1t01NBScI4AS6dXVSqu1oqa3agX/cdD0OOvpYzNz/gHgPB4AvOU7lnhxnahoEheLFWKCrcpIxNY9dkzFU8xfN1/ylyd/8BbsU8qYisD0zVU9KzILaXZ4T92Jqah5IWbnxHkZKs1Kshkh1ZSXu/csNOPjY47HP7/aP93ACaCbUeZbXC2Z6acszIWFgphewTMjZeUExX9fmL5amwtvWpfmLv8SOyx2YoOYpgbNblqYBPAcuQRNx4QqsUEzQEjT+z1iatHOWqakpE5czxnDbFZfBlZGJc6+4Ot7DCbD828qT/JqR6CxNhZSbF+9hpAWKEpJMqM7DuzR/4XZu/qJ2Nn+xLPCyK7jLdJgdA9OFpXlSos28YRjIzErMra6MMXtrRWFZvIeS0izd130yBW4KGWO4/crL4M7MwjmXXRnv4QSxVBVCCm0rT0SWrtqlPeizipAemZrH3qWy0wRycPMX+zEGBmZ6Yaqe0M1fusSMVGKnU6qUbkn0Ls+h7n9I9DDGYOoeuJTSeA8lKl5dswqfffg+bn5wJbJyEqdhHu1ocZ6dA6Ga27GS/HeYacbU1MD2554EN3+xdXYM9NVl9LRBa6oF83rBS/Iu21/4FCrK2xumqkIuSO56OIBdZDth6+GYXjDTTKmtFYnI3+E5Fbyy6p/4/KMPcMuDjyRUcAj4rs0FqbOtPBFZVCKBkLD1pqRIoMROlhTU/IWZpi9e9NVl7FJiZ5d4MQXKxETC0jzgUyDRpes6JElO2J+hqamQ8wriPYyUFojLE3hnU7iqtm3DfTffhMPmL8Bes+bEezhBqNyT8/znMu0cig1KKCYRxiw7296HwCW4Y2DnknbL1/zF3zWwu46B/uCRT+CAIxosr2Fvq0uBi5Ch6wk826za5xJtv3dUqtTD2bFtK+679S84fP5CTJs1O97DCcJME8wwKHBxmEnbygkJm79ETl9wgtBziZ3mel9dRgSX11FcdnOHFP+MN9XU2FaXyPGivXIuNWKZRGbq/rg8uXcBWJaFW69Ygey8XJy94vJ4D2cXlqpCzEqsSfFUY2kaOLrHjBlKKCYRS7NnhTkHVg3yoghezAa6bPNllglTU31/PPA2+uoychwEeaeZaZcCjkuNX1pLU+2LUApsqzOMxO3yTNtXYsPUVCh5yb1yzrIs3Hb5CuTm5SdmcKip4AQRvEgfqU6yNA1yfma8h0FIUjA1D5Tcwqg/7y4ldtB9iR2rTgWzTPCyskstb05M/vgK8CW6NA9cSnm8h9JnXsNI2B0tlqEDFgOfAivnElmq7Gj51z+fwpefrMVtKx9HZlbila+yNBV8UfLvgktktAo0tujuJ4mYmiemNRd27hgIdNYk8CcZO+syMvDKzkGjKymTcqaaOhehRJ5xpiYWzkuVWf0Xn3oCX677BLc/+gQyErAmqKlp4F3J/R4nOv+5nCrNhQhxEvM344rRtX/3JXbU0HUZXcldl5F5DV9d8uRPdBmGnrAdnu14MXUWLiSqVIgXt/+2GQ/cfguOOnERpsyYGe/h7IKZXjBvauyCS2SWrqbEdTlZUEIxiSTCii47aHT7xpEPYOe6jB54O9qgNdSCmd3UZXS5wQliQgeNppYaHZ4B34xzgnbsMzUVUnZevIeR0izD7trIS8n7obr9t8148I5bcfRJp2Dy3jPiPZxu2QW2k/c9TgapdONOiNNMLf7NuIJL7HRu77NMrz0xrfrqMrZ2qcvo6lzFKCiuhK/LaKq+if4U2FaXyDW3abVRbPSmTn8isiwLt16+AvmFRTjz4hXxHk63TJWay8WCqalQ8pN7d1YySd+EIovsy2Id1nQdpql5IOdFf/tKX/WpLqMrtnUZuTB+7pamQs7OC+vYHkX6HNF4bdgrFCVJitrz7SzSHxmzLFi6RgFilIT68Zr+GTqOi+4pEOHPPZIve+COW6BrGmbsP7fX53HEV5Revo6lqpBy86NzzegFFunvX4w/yCJ+X7qM038uc0Ly37gDcOyaTBySZDFjIq804gURvDsLons3dRmb6jrrMsrB8aIQwwReT9cuS7W3iEbt2h/J80QrXtQSM14E7OSAmEHlLqIh1I/XrtOvgVdcSRsvvvP6K/jm889wzKJTIIhir87lWMWLTFUhKArFiyFEI15kjMHy7xxK3Pmo3knwmDF9E4pJpnPrYvKsnOu+LqMVqLFjah54G3x1GdG5XUZwxa+Yd2eiK3ne590xErQmjqmrjtUDJZ1MzQNBTu5z+dDjF+C3jRuwYunpGDtpMhYuXoYZ+x8APkFWhNg1tFS4aMuzoyxNoxIJhIQp2a79IesyGlpnvNjWAq2+2u7cKSvBDWBcrrisxjQ1T1DDmmRmJPSOFg+U/MRbUJFKLF0HOA68mJjnQDjGT56KmXMPwItPPYH333wDx51yOo5ceCKychJn1aWpaSnRFT6RMcMAGAOfgPe/qYoSiknCMjQAyb11EfAFjV3rMnLdFPNuaYKl7VTM27+SUXE2aDQ1FZwggEuR5gr2CsXEu6D66ycm8lamVGDqatAqkGS0z5zfYa/Zc7D23f9h1cMP4OrzzsaAwUMw//QlOOjoYyHHeasx83oB37WKOMfS7Fl9QkjPTM0TtGMkGXH+BoCyC/CVR2FgYL7dL6bmgVftgNZcD2b46zLuVGLH4bqMqbStzjASs+Z2rOuBpitT99irf5M4Li8pr8D1f78fWzZuwOpHHsKj9/wVT91/Lw5fsBDzTj0DxWXxb55kaSrkvIJ4DyOlmZoKXpGp5moMpUbWJA34O28l84U+lLCKeXd0QGvcqZi3L2CMZjFvf53KVHmfE3aFoupJ2O1YqcTUVCi5yX+zw/M8ZvxuLmb8bi6++2I9Vq18EHddcyUeuecuHHfyaTjqhEXIzo3PzbOpqeBlOSVqaCUyU1MhZifOKgNCElVgp0UKNjCyS+xI4CUpqC4jM82g3S9GWwssXQV4PrhZoMtfl7Hv12vL9IJ5jZTZ0ZKoXZ5NTY17PdB0kCodngFg4JChuPj6v+CM8y7AC089jpf++SSef+IxzD38SCxcvAyDR4yMy7j8O1ooOe4sS6MGfrFGV+ckkQgNWWJpt8W8fQGjqaow2roU8+6yZVpQ3BEV8061zsOJOuNs6irkHJqhc1KqzuqPnTQZ191zH7Zu2oQ1jz6Ex++9B089cB8On7cQ805bjNKKipiOJ9WuGYnIv4qd3mdCepaOJUU4QYCYkRW0/difWO3c/dIAs1b1bYVTghONiqvXTRIsLbWaK+h6YnZ5tu9/6NrvNEtXISZxQ5buFJaUYOkFF+Ok5Wfh1TWr8OxjK/HmSy9gr1lzcMLS5dhz2vSYLiBhhq+5HO22cFQi1xBOVZRQTBKm5oGclRfvYcQdL4jguwkaTV21E42qB3pTg6+Y905Bo381Ix86+EvUxjeRsCwLptebcFue/TN0dLF3lqmr4AQxZWf1BwwejAuvvRGnn3cBXnjyMfzrmafwwlOPY//DjsTCJcswdOSomIzDonPZcZbuL/mRWNcyQhJRqu20iBTH83bc5+qcjLfrMuqBiWlvRxu0hlow0wtekn0T052JRk4UQ76PqTbRn8grFOkz1nn29v2SeA/DERmZWZh/+hIcu+hU/Pe1V7B65YO48LRFGDl+AhYuXoZZBx4MQXR+YsBenRidFdIkNEtTIfnKZJDYSM07zRRjdytSwRfSB2p3/MW84coAfLse/UGjv2Ogt701dNDocoPzJV3swCU1AkSvYQBAws04M69vho5qzjkqXWboCoqKsOSPF+GkZWfhtedWY82jK/H2yy9i2r6zsHDJMkzae4bjNbRoK66z/A1Z0j1BQkg4aNV0aHZdRgWCrEDK7iyTYfnqMvoTjUZrk737RRAC9bv9MaN/94upqhBSqBlXItfcFjOTv3RLIrNML5jpTZktz6GIkoSDjj4WBx51DD794D2sWvkgrrvgPFQMHIj5py/BwcceD5fbuXtAujY7jzELlqalxf1PIqGEYhJgXgPMMlP+Qh9NXYNGdDaZhuWry9hd0MhLCsAYTNUDABFtmU4khqEDQMLNOJuaB3wcOninm3SrIeLOzMTxp56Bo088Ge++8TqeefgBXHzGqRg+ZiwWLlmGOQcfCiHKzZbsyR4KXJxm13aiCQhCwmHvtKAETG/woghezAYyOwNGZlmBmoyWpkJvqvPtfgEE2QXT0CHxufB62nvc/ZIMDMNAZlZiNXFjjPkmR1Njoj9Rpdr2/Z5wHIe9Zs3BXrPm4OfvvsGqhx/EPTdci0fv+RuOWXQKjll0MnLzo1+WydRSaxIiEdndynlwCbaYJtVRQjEJUAImenhRAi9K3QaNenMDLF2D3lwPs8YXNCquLrPTvi0wSfJzMHRfQjHBLqqmmh4r5+LN1FXIuelXp1KUJMw94ijsf/iR+PzjD7Hq4Qdww0V/xEN33o55py/GocfPhzsjIyqvZekawAFcAq7qSCWWpkJwR+dnRkgq60zA0GdsX3E8D9GdAbHLtcfe/aLB9Hjgqd4GS1fRUbklsPtFUNzgXV1WMyZRHUtDT7ya21TuIjbS+ZoxYux4XHXn3ViybQuefXQlnnnofjzz0P045Lj5mH/GYlQMGBi117I0FVJuXtSej+zKCmwrT94FQcmIEopJgOqHOMsfNHrbWiBm5yCjtH9n0Kjaqxm9bS3Q6mt8QaNidwpUEjtoNPxbnhNuhaIaFKCT6AvUqZTTd1af4zhMnbkvps7cF798/x1WPfwg7r35Rjz+97tx9KKTccyiU5Bf2LdVPP7tKxS4OMvSVch56ZccJ6S3OhMwtKLXCfbuFxdgMYDnkdl/CDiOC+x+8a9mNJobYRk6OEEMnph2ucBLiXmz6zUSb8uz//4nEd+vVJJKHZ4jVTFgIM6/6hqcdu75eOnpp/DCk4/j5WeewuyDD8HCxcswcvyEPj2/v0kU3c87i3Im8UEJxSRgap6gJiTEGabmgejrKO0PGnf+gA0KGtUwgkbELwgKrFBMtISi7oGSIo1vEhXzGr5Olon1s4+X4WPG4so7/oqlF1yMZx9biTWPPIxVDz+Ig489HgvOWIJ+g/aI6HkpcHGeHYTrVHeIkDBQQ5bY2Pl99u9+kYJ2v5i+eFHddct00O4Xf8PA+O5+0Q0dcoLFDKnW+CZRmboHUmZqNmTprdz8Apx6znlYsHgp3njxeaxe+RDOnn8sJk7fGycsXY5p+86O6Ppq6RrA8+AScAFKKrE0FQLlTGKOEopJwNQ8UPKpHo7TTE2FUrj7D9SIgka565bp2NXZ6WzKkjgBIjNNMMOg5IDD7DIJ1EluZ2X9++PcK67GKb8/z+4K/cRjeGXVPzHrwIOxcOlyjJ6wZ6+ez1JVCJkUuDipMwincIWQntgJGPp8dVo4k0kcL0B0Z0J0ZwYeY4zB0rXAxLS9+6UazDTt3S9K8O4XTgjdZTravIaReFueNTUw0U+c4T8n06nmdjhcbjeOPnERjlhwAj5460088/AD+NOyxRgyYiQWLFmG/Q87ole/L7TaNjZMTYNMOZOYowg9wXV23qIZOidZXsN+nyMIxMMKGttboDX4g0Z517qMDgSNeqCGYuIkFE1dBSeI4Ck54Kh0rocTjtz8fJxy9rlYcMZSvPni81jzyMM4Z8FxmDB1L5ywdDn2mj0HfBirRUxNhVxAgYuTKAgnJHymrkLOyov3MFKeqXkg5/S+DAPHcYHJZSAPgB0vMtNrx4uqb8t0S/Dul0CSUXY51jDQ0PXE29ESxkQ/6RvLoDqVuyMIAuYccihmH3wIvlr3CVatfBA3r7gYD991O+adthiHz1+IjDCaGVGHZ+cxywIzdPAKlfyINbqrT3Cm5gEvymnTeSteTE0FL8lRWz0YCBplF5CdB2CnoNFfZ6elCZZhd5kOJBllX13GPtbZ8a9QTKQZZ9oiGhumpkJ0UZ3KniguF4484SQcNn8hPvzP21j18AO4/KylGDRsOBYuXoq5RxwV8gaLmSaYl1bbOo2CcELCY9fO9UAoLI/3UFJaoEZxlLq1chwHzr/7JSP8LtNdk4zR2P1iGEZCNfHry0Q/CZ+/fiJN2u0ex3GYOH1vTJy+Nzb9/BNWr3wID955Gx6/9x4cdcIiHHfKaSgsCZ38NjUVEq22dZSlqeAEAZxA6a1YS9t3nGMRfmGkXxchy786o7dfGONxxvjlos5UfXVaov2NdHk+Dhw4QQKf0U3QqO8UNOqdQaPQJcnYm6DRMOwVirIs93j+xOrnF3ifU12c4zJLV8HnFjg3Dsuh5w3B6bdThIA5+x+M2b87CN+s/wyrHn0Qt16+Aiv/eieOP+V0HLHgRGRlZwd9janaq20FXgy8HyzSgSZJHB/x52Yf9DoIj/S9TPYPMeKoZIgZLcMALAuColDM6CBL1+0axZLibMzI8RBdGUGTg4GGgb4SO/bul5rOLtNy53bp3u5+MXQ9seLFKE/0J6xEiBcVF8WLvTBkyEj86YbbsOTcC/HcU4/ipaefxLOPrsSBRx2DhWcsxcAhQ3f5GktVIRSUgKN40TFmJI0SKWaMirRNKCYLKkgcG/FcBcPxuwaNYAyWocPUPDA1FUZHC9TGEEGj7AInSrtcQL2Gf8tzAs04aypEqm3hKGaZsAydZvUjwHEcJkyZhgnTpmHzr79g1SMP4eG/3Ykn7/8HjlhwIo4/5XQUl5YBoNW2sWJpGvhCep8J6Ympe8DLLqqd6zBLU+NWozioYaBvjotDl4aBvslpvdW3+4UXAsnFQE3vEFum7RqKibPtlVanx4apqRCpFnREisvKcdYll+Hks87Fy6ufxnOPP4rXnluNGb87ACcsWYbxk6cC6Fq+jM5nJ9nXZnqP44ESignO1DyQs/PjPYyUZ2oeSDmJ8z7bQaMCQVYCQSMAWF4vTN0T2AajtzXB0rsEjV0SjYnW5ZkxRrX9YsDU7C30PHWS65M9hg3HihtvwZI/XIjnn3wM/3rmKTz3+KM44IijsOCMpSjLyaSbHYf5t5ULVA+HkB6ZmgciTUA7ztQ8CVfXvPuGgf7dLypM3QOtucHeMs0YBEUJ2vnCy27oCVZDkSbtYsPUVWr82UdZ2dk4ccmZOP6U0/GfV17GqkcewvknL8TYiZNwwuLl2GvvfeyFH1S+zFGmpkHKyY33MNISJRQTGK00io1kep95UQQvZne/ZdoXOGotdtA4vKwAd911FyStDWpTXWD7NB+n2hKW7iv8LFNywEmWribczU4yKyopxfILL8Wi5Wfj1TWrsObxR/DvF5/DPf/4B1wFxRhaVEa1hxxiaio4UaR6OISEwdRUSLTSyHHJsqKru90vzL/7xbeS0eiw40PmNXD33/4KXlLgqa8OrGrku9n9Eium5oGUTckBJ1mm1zdpRzFjNMiygkOPm4eDjzkOn7z3Dp55+AFcdf7ZWHTKqdj/wAPh6qdBpglSx9grFKmJUzxQlJ7AOjvi0kojJ5lacr/PoYLGj/7zBl5etQqXX/8XeD1t0HxBIydKnbUZfQW9OVl2PGikws+xYWoeWjnngMysbCw4YymOXXQq/vPayygqKMAVV/wJcmY2TliyHPvOPRC8SLPP0URb3ggJn6l74CoojvcwUp6pe6Ak6fsctPslqzNZ5zV0XHXVVTo0o6MAADpuSURBVFh81rmwvDqM9hZYugrwfOfOF/+ktOICxzu73ZtZFixdS4qJ/mRmaSqtnHMAz/PYZ7/9sc9+++P7r75A/caf8c5bb+KVCy7AcSefhqNPWISsPEqWR5Pl9VITpziihGICs+sn0i+G01JxWwXHcWj3qFi7di2UglIovhkxyzTt5i/+1YwdNTA1DfB3pfbPSvtrM0YxaKTkQGyYmgo5tyDew0hZkizjoMOPROumn7D8ksvxzCMP4po/noN+Awdh/hlLcfAxx0GJUvfPdJeK12ZCnEAdcWPD8nrBvKlXC81iDN988w1qm1sxqXQAAIAxC6auwfKV2DHamqDWq2CWCV5WOmsy+rdNR3FS3tI1gOfBJelEf7IwdTXlzuVEM2bPSWjLz8bwCZPQpHnx+H334KkH7sPh8xdi3mmLUVpREe8hpgRKjscXJRQTmH0zRcvQnZaqjW8CNRS7NGXhBQF8RhaQ0bldhzEG09A6G8C0NsOsrwIzTfCSEpiRjqRrYFem5oGYmd3zgSRiVKcyNkxfUf7pc36H6XN+hx+/+RrPrHwQd1//Zzx6z104dtGpOOrEk5Gbnzh1WZORpWmQcvPiPQxCEp6pp0lH3Diz/O9zit20dldzm+N4uyan4gZgf5YxxmCZnQ1gvFoHrJYGWIYOThC7xIv2isZQDWB64o/LaUeLs2jSznmMMZiahuKBQ3HhNTfg9HP/iBeffhwv/vNJvPDU49j/sCOwcPEyDB01Ot5DTWqWrlK97TiihGICM3UPlCyqBeC0VO087DUMCKIIvodVhlyX1Yl+jDEw0xto/mJpKowWX9dAQQDv3wLj8hf07rnjoampUArofHYS8xqAZYGX6EPVSTvP6o8aPwHX3HUPtm39Dc8+uhJPPXAf/vnQ/Tj0+PmYd9pilPcfEMfRJifGGCy62SEkLInYKCQVmZonJbuIGoYBABCl3a8I5DgOvCSDl2RIyAk8zizTFy+qsDQVelOd3QAGsBOLXSalBcXVY0KWEl2xkar3P4mEGQbAWKB+fEFRERaffyFOWHomXn9+DdY8uhJvv/wSps6chYWLl2HyPjMokR4BU9NoF1wcUUIxQfm3GtAHqrNSeUWXbuiQpMg69nEcB243XQP9W2D0ps6ugbyiBAWMfJcGMFTbIjb8K+ecrm+U7uzt+7smbfsNHIQ/XH0tTjv3fLz49JN48akn8NLTT2LOIYdh4eJlGDF2XBxGm5yY12tvraNrBiE9MvXU3GmRaEzNA8GVeu+zf4WiHGGXZ44XILozIbozA48FGsD4JqW9HW3QGmvBvF67lrfS2WVaUNzgpM4GMKamQs7J6/P3RUJL5fufRGLqnm5X6rozM3HcKafj6BNPxjtvvIZVDz+ES5acimGjx+KEJcsw5+BDIYiUpgmXpamQ8qjcU7zQmZqgTF0DeA68GNmHOwlPoPNwCq7oMnQ9aLtzNPgbwMDfAIbrDBot3+y0HTR2aQDjL+AtCLBML3iep9k3h1A9nNgwNXW33SfzCgpx+rl/wAlLluPfzz+LNY8+jLPmHY3Je8/AwiXLMHXmLPod6EFgayElxwnpkampkLPpZspppqZCysqL9zCizp9Q7GmFYm8ENYDJBuD7yLNMb2BS2tRUGG0tvpqJnG/Hiwum2gHk5INZFn0GOMQy7J95Kt7/JBJ7tW3o91gQRcw9/Cjsf9iRWP/xR3jm4Qdww8V/xEN33Y55p52BQ49fAHdGRsivJ/5t5SpclByPG0ooJij/9hW66XSWv/FNKr7PXkMPqofjlK5BY9ckC/M1gDF926XBGNp++wUAgpu/+P5Q7ae+o8Y3zmPM130yjO2FLrcbxyw6BUcuPBHvv/UGnnn4AaxYdgaGjhqNhYuXYb9DDovqDVwqMelcJiQszDJheXVaoeiwzs7Dqfc++7c8S7LzySVeEMFnZEEMquVtv7f2pHQ7wBjU2h3wVG/rvpa3GFktb9LJ8u9ooffRUZamgQ+jUR/HcZgyYyamzJiJX3/4HqsfeQj33nITHv/HPTj6pJNxzKJTkF9I29O7Eyj3FIPrF+keJRQTlKmrEGmlkeNSufGN7sAKxd7gBAGiL2g0Vbshi1JYEggaTc0Db1sLtPoaMNNr1+XZuc6OKFGw0wumpkLKoUYgTrJ0HeB4cL343RJEEfsdejjmHHIYvly3FqsefgA3XXqhbwZ6MQ6fvwDuzMyenyiNWFQPh5CwmJoKThADJUaIM0xdBccL4FJwG2J3TfxiieN4X9znBscLMNUOZA0aDub12hPTugpL7VLLmxc640WXO+xa3qQTlUmIDTsuz+vV1wwbPQaX33onFv/hIjz72EqseWwlVq18EAcfczwWLF6CfoP2cGSsycrUNCr3FGep96mYIkzNAyWHtq84zdJUiNk5PR+YhLyGEZMViuGwtwnl7NQAJi/w75bXCBTz9neatrfA8EF1dnjZBUF20YdGN5hlwTKo7qrT/NtXIkl0cxyHSdP3waTp+2DDTz9i9coHcf/tN+Pxe+/G0ScuwrEnn4aC4mIHRp18TE2FkpnV84GEpDlKDMSGfwdAKk5yev0rFCOsux1N/oYsHMeBkyTwkrRTAxirS7zogd7sq+Vt2Y0vutZl5GUX+BRMAEeDqakQ3fQZ66S+xuVl/frh3Muvwqm/Pw//euYpvPDkY3hl9T8x68CDsXDJMozec2J0B5ykQtU1J7FDV9kE1FkolwJEJ9nvsweKUhrvoTjC0PWE2E5pb2VRd1vInPc1gMFODWC6rmbUW5pgaardqEFWunQO9HcNTO8tMIHVE7RKxVH2NqG+J22HjhyFy265A0v+eBGee/xRPP/E41i98mEcdMyxmH/GUgwcMiQKo01O/g7PtEKRkJ55qcNzTNglclLzfdaN+K5Q7MrUPHat7hA4nofozgDcnccwxsC8RqDMjlftgNZUb9fyFsTgMjuyi7b6wjdpl0dbaJ3kXxjBiX37vcrJy8PJZ52DBWcsxZsvPY/VjzyMcxYejwlT98LCJcswfc5+4NN4oYVFXeHjLiXuPDlm/+nV11gRvpbVyxfyYb344LIMHWAMgqAAkb0cWISfk5F+vEb8sRzp9xfp63UZKDO9YKYZXhOLCF8w1u9LV4ZhQJbkqDxXSGF8g5a26wdqWEPiefAuN3iXGxJ823gZ69wC45uhDmyBEQR7BWNQp+k+boFx8r2LslRePRExB94KU1eDaj/1VUl5Bc667HKcfM65ePmZp/H844/itWdXY8bcA7BwyTKMnTwl9BfH+Ecd6a9Dbz+fWddi8Yn+Oxjr8YXzM6dLQEiRxItAgseMmgrZnQPOijz2o5gxhC4DNTUVcm6YO4diGTNG4RrkDWx5djBmDPObszQVfJf3OazhcBw4SYYoyRCzcgMvx0wTpq52ltlpqrNXMwJdJqW71GYU+lDLO9E/q7pgpgnmNWjSrisn4sUuq22jQVYUHH7CiThk/gJ8/N+38cxDD+KKs5dh0LDhWLB4KfY/8kjIoeoIpmi8CPhW22blJMfvYKLFjFE6L1IioZhq7IYs9gUoGX43kpWpelK65oK9QjGxtq/0VdAWmKzdbIFp8W+BsbokGTuDR76Ps4WJyF7VTMGh00xNhZIf/Vn9rJwcnLj8LBx/+hl4+6WXsPrhB3H+iQswbvIULFiyDPvsPzdtZqBNKhZPSFiYZcE0VFqh6DB/F9FUXaHoRJfnSDDLhGXoUYtlOEGA6M6E6O6sUcwYg2XoMDUPLE2Ft6MNWmOdvZpRlIK3TCsu8JKccp9Fpk51V2PB1NXwFq30kiAI2PfAgzHzgIPw7eefY/XDD+K2y1dg5V/vxHGnnoYjTjgJWdnZPT9RCmCMwdKp5na80ZUkAXl12r4SC05d6BOFkSA1FP0JcieFuwXGam6AZeiBLTB8UK2d5E5gmJoKOTsv3sNIabGY1ZdlBYfNX4BDjp+Htf/7L1Y99ACuPucsDBg8BAuWLMMBRx8degY6RdgNWVL7eyQkGkzDLnWRipNkicQydAAsZbuI+rs8y3GOGQMNhhw8nzmOgyArEGQF6JJzsUxvoI63qakw2mvsLatAl3jRDcE3Sd2n1YxxZtIW0Ziw/CvnHMJxHMZPnYrxU6fitw2/Ys3Kh/Ho3/6Kp+67F0csPAHHnX4GikvLHHv9RGAFdrTE/343nVFCMQGZugo5IzUbhSQSU/NAVELXaUl2Rpy7PPvFK9HF+bbA8JIMybcFBrBnwP0Bo6Wp0Jt8qxkZA690U9A7CWZwAzXniihAdFIsZ/V5nseMuQdgxtwD8N36z7Hq4Qdx51WX45G/3YljTzkNR55wErLzcnt+oiRkaioEF53LhPTEPzGazJNhyaDrzqFU1LlCMf4JxXglunhBBJ+RFVTSxL/6yR8vettaoGk1YKbXt5oxuGlgsqxmpBrFsWFqKpTCkpi81qChw3DxjX/BGX+4AC888Rj+9c+n8PwTj2H/I47EgsVLMXjkyJiMI9YslXa0JILEv1NOM/5GIUJ+ajYKSSSWpoJP4U7aidDlORETXRwfeguMf3ba29EBrbGbgt6yP3BMrA8v5vWCWWHWAyURi9fNztjJU3Dd5CnYunEj1jzyEB7/+914+v/uw2ELFuL4089AaUVFzMfkJEtTIeXmxXsYhCQ8k3a0xESqJ2D8KxTjHTMm2vvMcVwgYdiV5fXC0tXADhijvcWuF85xEBQFguwOqs/I8Ym1mtHUPZBzC+M9jJRmeb1gpjfmcXlhSQmWXnQJTjzzLLy2ZjWee3Ql3nzheUyfsx8WLluOCdP2Sqj7l76yqNxTQqCEYoJhpmEnBiT65XASM6NbpyUR6YYGd0Zmzwc6KJDoSvD3uesWGCm7y2pG704FvZs7C3rbnaa7zE4r8VvNaOoe8FLq1gNNFPG+2RkwZAguvP4mnH7+BXjhycfwr6efwotPPo79Dz8C85csw9BRo+I2tmjxd3en5DghPfPqHijZlBhwmql5IGam7s4hI0G6PJuaB3Je4p/PvCiCF3dazWj5VzN6YOoqvO0t0Brs1Yy8JAfX847jaka7HqiWsvVAE4Wlq+BEKW5b4zOzsjH/jCU4ZtEpeOe1V7Hq4Qdw4cknYeT4CVi4bDn2PfAgCEm8bd/P3tGSursNkwUlFBOMV1cpMRADga2LKVx3yGsYkOL8/Zlacje+2V1Bb0tTYeoeeD1t0Jrqdl3NqLjsLoIxWM1I9XBiw9RUyHnxX9VcUFyMJRdcjBOXn4XXn12DZx9dibdeehHTZs3GwqXLMHHvfZJ2BtrSfV3hE6BcAyGJzN7RokKkFYqOMzUVSkFsti7Gg9cwIIhiXBt/JXuiK/RqRsPeMu2bnDbaWuzPuS7Hd002Or2a0TJ0u8RPitYDTRSJEpdLsowDjzkWBxxzDNa99y5WP/wgrjv/XFQMHIj5i5fi4OOOh5LEJWYsTYOUG/+4PN1RQjHBmLqHgsMYMDVP0gYt4TJ0Pe7bVxLlAzWaglYzostqRtO/mtHXBKaxDqYem9WM8V45lw78N++JtHIuIysLx59+Bo5edDLeef01rH7oQVx82ikYMW4cFixZhtkHHwJBTK6PeUvTIPiT8CzeoyEkcVmG3TCClygx4CTLa9hbF1P4M1bXdUhxrp+Yqo1veFGyFy9kdnaAYcwK1GY0tdiuZrR0qjkXC4l2/8NxHKbP2Q/T5+yHn775GqsfehD3XHcNHrv7rzj65FNx9KKTkZufH+9h9kpgR0sCvc/pKrnuNNKAqakQaemu4xLtQu8EwzDivn3F0lTwSTzz1RvxXM1o6iok6vDsKOY1AMtKyJsdUZJwwFFHY+6RR+HzDz/AqocexA0X/AHl/Qdg3hmLcfDx8+DOSI7PFVOn5Dgh4fDqHghS6jYKSRSmptoJnQSrgxdNXiP+TfwsLX0SXRzH+xq6BC9ssLxG57bp7lYzyq7O2oxyZJ2m0+H+JxFYugoxoyjew+jWyPETcNXf7kHlli149pGVeOaB/8OqB+/HIcfPw7wzlqB8wIB4DzEsgR0tSTZxnopS4ifQ3tbW66/hrMhei7MiWzLBwvyAbG2qh7tQgdnWan9dhPELi/DzOFk+xiNeuOL7Btsb6iHlFwbeZ6deMOL3MworczSPB+CA9jC+x0jPF/SwO6atsR5KUdku73Ok317Mz89orZDieEDJBJRMCACYacHUVWi6CtbSAlOvhqn7ZucluTNolH2z02LoCwGzLLQ1NQI5RdDDPZ/7KllWjkV6wnTzdUZbKzSvF2JHe8gvi/T3iEW6y6yb1xs9cSKu+fs/8OsPP+DFxx/D32+8Ho/e/TcctmAhjjhhIXLz+7A1JNLrYC++ztNQDz4jE1Zba3KcZ7H+bAhDRwQxUbqIJF4EEjNm7GisB5gV9BlPMWP3+hIzao31ML0m+N58vsbyuhCF62R7WytEUYxrvKg21IF5rV3e57SLFwFAcgGSC3wWwDEGS9dh6B5oqgdWcyNMXevsNB2IFxXfakZpt0nZjoZ6CO4MMIoXg0UxXmSMobWxAZmZeTBCvM+JEC/mFuRjyUUXYf7ixXh19Sq88swzeOmpJzHzgANx3GmnY9iYMRG+GGISL+rNTfB6TQjtbclzniVYzBiteJFjjCXLj2AXqqpi8ODBqKqqivdQCCGEEEISQllZGTZt2gRXmqwQ7wnFi4QQQgghwaIRLyZ1QhGwg0Rd1+M9DEIIIYSQhCDLMiUTd0LxIiGEEEJIp2jEi0mfUCSEEEIIIYQQQgghhMROpDvxCSGEEEIIIYQQQgghaYgSioQQQgghhBBCCCGEkLBRQpEQQgghhBBCCCGEEBI2SigSQgghhBBCCCGEEELCRglFQghJYF6vFwBA/bOcxxij95kQQgghSYlixtigeJGQTpRQJCmptbUVAH2gOsk0TVRXVwMALMuK82hS0+bNmzF+/Hg0NzeD47h4DyflcRxH77PDTNMM/J2uz4SQREAxo7MoXowNihljh+JF51G8mDwooRhDX3/9NT755JN4DyPl/fjjj9hzzz3R2NhIF3sHffzxx5gwYQK2bdsGnqdLiRNyc3Mxbdo0LF68GF9++WW8h5PynnzySTQ0NIR1LN0UReb222/H2WefDQB0fSZkNyhmjA2KGZ1H8WJsUMwYOxQvOo/ixeRBV/UYuv766/H8888HPVZZWYmmpqb4DChFlZWVYe7cuTj55JPx+eefx3s4KWvSpElYunQpzjvvPKxduzbew0lJ+fn5uPfee3HwwQejsbERAAUmTqmpqcEll1wSdD22LAsffPABdF3f5Xi6KYrMjBkz8M033+Daa6+lzz5CdoNixtigmNF5FC/GBsWMsUHxYmxQvJg86AyPoffffx/9+vUD0HmBX7BgAdasWRN0nNfrxRNPPIENGzbEfIypIC8vD/fffz8WLVoEwzAA0AeqEzIzM3H11Vdj/vz5EEUx3sNJWVlZWVi6dCn23ntvAJ2BiWmaME2Tzu0o+fTTT+HxeJCbmxt47PPPP8fixYvR3t6+y7FXX311rIeYEmbOnIkHHngAgiBA07R4D4eQhEUxY2xQzOg8ihdjh2JG51G8GBsULyYPSijGCGMMdXV1mDx5MoDOC/y6detQXFwcdGxNTQ1WrFgRqOlCeo/neZxwwgm7vN+macLr9dIHapQoioKTTjoJU6dOBbBrEE7vc99s3LgRhmGA53m43e6gfxMEAYIg0MxnlHzyyScYM2YMsrOzA7Va1q5dC9M0d3nv//3vf+Pll1+OxzCTHs/zGDNmDM477zyUlpYGHmeMBW54qFYOSXcUM8YWxYzOo3jReRQzxgbFi7FB8WLyoGmiGPnqq68gSRL69esH0zQhCAK2bdsGy7IwduzYoGO3bNmCqqqqXR4n4fnqq68wZswYSJIEWZaD/k0QhDiNKjWtW7cOa9asQUdHB3JyclBRUYEhQ4Zg1KhRGDp0KAUufdDW1oZRo0bhyy+/xJgxYwAAhmHgww8/xBNPPIG6ujqMHTsWRxxxBPbZZx+qL9JHn3zyCcaOHQtJkmBZFgRBwCeffIIpU6bA5XIFjmOMYf369Rg3blwcR5ucdF1Hc3MzioqKgmb2Abs+Dl2fCbFRzBg7FDPGBsWLzqKYMXYoXnQexYvJha7eMfL+++9j1KhRGDx4cOCX4JNPPkFxcTEKCgqCsuzffvstSkpKIElSPIeclDZv3oxJkyZh69atgcc6Ojrw0ksvYeHChTjkkEOwYsUKfPzxx3EcZfJrb2/Hddddh/322w9vvPEGPvvsM6xZswYrVqzAkUceiRkzZmDevHl444034PV64z3cpPTVV19BlmXk5eUBsM/j22+/Hfvvvz/efPNN1NfX48knn8SiRYvw6quvxnewKeD777/H7NmzgwKV9evXY8KECQA6O8x5PB58//33mDlzZtzGmqz++c9/4tBDD4XH4wk81tjYiNWrV2P+/PlYuHAh7rzzTvzyyy9xHCUh8UcxY2xQzOg8ihdjg2LG2KF40XkULyYXSijGyLfffouvvvoK559/Ph5//HE0NTXhgw8+wMSJE1FYWAhBEAKzRevWrcP48ePjPOLk9Nlnn6GioiLwgdrQ0IArr7wSxx57LNavXw9d1/H000/j1FNPxVtvvRXfwSax1157DY899hiuv/56vPHGG/jf//6HX3/9FU1NTfjyyy/xpz/9CVVVVTjzzDOxatWqeA83KX300UcYOnQoMjMzAQBvvfUW7rjjDlxyySX49ddf8dRTT+Hxxx9HeXk5zj77bNTU1MR5xMlt+/btuO+++3DDDTfgtddeQ21tLbZs2YIZM2YA6Oww19jYiK1bt2KvvfaK53CT0rp165CbmxuoobVlyxaceeaZOOGEE/Dtt99iy5YtuPHGG7Fs2TL8+OOPcR4tIfFDMWNsUMzoPIoXY4NixtiheNF5FC8mGUZi4q9//Ss7+OCD2bhx41heXh4TRZEJgsDy8/PZGWecwe677z72xRdfsNbWVjZr1ix21VVXxXvISem8885jc+fOZe3t7Ywxxu677z5WVFTE7rzzTsYYY1u3bmXvvPMOmzhxIhs9ejRrbGyM42iT1/Lly9mRRx7JDMNgjDFmWRazLCvomMrKSnbSSSexQYMGsW+//TYew0xqxx13HDvttNMC//+HP/yBzZ07l9XW1gYdt27dOta/f3/20EMPxXiEqaO5uZmdeeaZbO7cuax///5MkiTGcRzjOI6NHj2aLV68mP3jH/9gH330EXvzzTeZIAiBc5+Eb/r06eyiiy5iqqoyxuzrdUVFBXvmmWdYa2sr+/nnn9nq1atZdnY2W7hwIfN6vXEeMSHxQTFjbFDM6DyKF2ODYsbYoHgxNiheTC5UQzFGfv/73+OEE05ATU0NduzYgS1btmDTpk349ddf8cUXX+Dll19GS0sL3G43WlpacP3118d7yElp3bp1mDNnDjIyMgAAb7/9Ng488EAsXboUANC/f3/0798ft956K04//XT85z//wfHHHx/PISclWZbR0dEBr9cLURR3qcXCGEN5eTnuuOMOHHTQQfjggw+ovlMvbdiwAV6vF1dffTX23ntv/Oc//8FRRx2FwsJCAAjU1Ro0aBByc3Oh63qcR5y8cnJycOutt6KjowONjY2ora3Ftm3bsGXLFnz99df48ssv8dJLL6GpqQmWZaGoqIg6VUbg559/xqWXXgpFUQAAr7/+Os466ywcd9xxkCQJw4cPx/Dhw7F161bcc889+P7772nlFUlLFDPGBsWMzqN4MTYoZowNihdjg+LF5EJneIxIkoTS0lKUlpYGTnjLstDc3Iza2lpUVlZi69at2LRpEzZs2IDp06fHecTJacuWLXjrrbdgGAamTp2KtWvX4tJLL0V2djYA+z3neR6jRo2CKIpUBDpCZ5xxBmbNmoXFixfj0ksvxciRI4M6m/kDRlVVUVNTg4EDB8ZrqElryJAh2LhxI1atWoWnn34aNTU1EAQBXq8XkiQF6ra0tbWhsrIyULuFRCYnJwc5OTkoKyvD6NGjAdgFzT0eD1pbW1FfX4/q6mr89NNPgQCdhM8wDDQ1NWHNmjXYtm0bRowYgZqaGuy1116B2m/+6/Ps2bNxzTXXICcnJ86jJiQ+KGaMDYoZnUfxYmxQzBg7FC86i+LF5EMJxRhhjOHHH39Ee3s7Jk6cGAhM8vPzkZ+fjxEjRgSObW1tDeoSRcJjGAZmzJiBqqoqvP7663jxxRfR0dERNAvnDwYbGxtRU1ODiRMnxmm0yW3y5Ml47LHHsGLFChx33HHYf//9MXPmTIwZMwY5OTno6OjA9u3b8fe//x1lZWXYe++94z3kpPP888+joaEBGzduxE8//YQNGzagoKAg8GHqn21evXo1FEXBpEmT4jzi5FZTU4Mvv/wSAwYMCASIkiRBkiTk5OSgX79+AIADDzyQCsdHoLq6GqNGjcJ3332HTz/9FIZhBFZX+fmvzzU1NfB6vRg0aFC8hktIXFHM6DyKGWOD4sXYoJgxdihedBbFi8mHEoox8Nlnn+Haa6+FZVkoKCjAoYceipNOOgmMMXAcF+gG5Z+l88+Mkt6RJAnPPvssNE3D5s2b8fPPP+Pnn39GaWkpAATeb13X8dRTT6GsrAyDBw+O86iT1zHHHIOBAwdi9erVePPNN/HMM8/A4/FAlmW43W5kZGSgtLQUDz74IPLz8+M93KRUUFCAgoICTJ06dZd/EwQBzc3NWLt2LY488sjAli3Se4888ggeeeQRjBw5Eh6PBytWrMD48eMD14yd0faV3uvfvz+++OILbN++Hb/++it+/vlnbN26NRAU+m92amtrsWrVKuy5555xHjEh8UExY2xQzBg7FC/GBsWMzqN40XkULyYfjvkjE+KY2bNnY/jw4Tj55JPx008/4dZbb8VTTz2FffbZJ+QFiPQeYwyMsR63pGzevBnnnHMOJkyYgL/85S8xGl1qM00Tv/32GyorK9He3o6Wlhbk5ORg9uzZQVtbSHi+//57NDU1YeDAgcjLy4PL5QpsV+E4Dm+99Ra2bduGBQsWoKamBvn5+YEulaR3PB4P9thjD6xYsQJz5szB448/jv/973/44osvAu85cZ7/s/CTTz7BZZddhmOOOQbnn39+vIdFSMxRzBgbFDPGB8WL0UcxY2xQvJgYKF5MPJRQjIFx48bh/PPPx/LlywHYBYpfeuklHHrooXEeWWpijMHr9QbqK+xcBLqjowNVVVUoLi6mmf0IGIaBm266CY8//jg4jsNpp52GK664AjzPY+PGjdi6dSuGDx+OioqKeA81af3ud7/Du+++i5KSEhQVFWH8+PGYNGkSxowZg+nTp+Oss86C1+vF888/T0FMH3333XfYf//98d///hdjx47F+vXrsffee6OhoQFZWVnxHl5K8V+b/WGHIAi7nL9NTU1obGxEaWkpraAgaYlixtiimNE5FC/GBsWMsUHxYuxQvJhcaB1uDFxxxRU4//zz8cMPP6C+vh5lZWXYZ5994j2slPPrr7+iX79+cLvdgZohXfk7zGmaho8//hhz5syh4DACV111FR566CEcddRRcLvduOeeezB9+nS88MILePTRR6HrOsrLy3HhhRfi/PPPp+X+ESgpKYEkSTjttNPA8zzef/99/Pe//0VDQ0PgRqdfv364+OKLMWzYMJx00km0TShCI0aMwKJFi7Bo0SIcfvjhWLduHQ488EBkZWXRaqAo0jQNiqJ0e21mjME0TYiiCMMw8OGHH+Kwww6jAJGkJYoZY4NiRudRvBgbFDPGBsWLsUHxYvKhFYoxwBjDv//9b7zzzjuor6/H8uXLsddee9HFJ4oYY8jPz0dJSQn69++PkSNHYsKECRg/fjxGjx4d1GXrm2++wZ577onPP/+cihL3ktfrxcCBA3HllVdiyZIlAIAbb7wRa9asgWEYuOOOO1BQUIDVq1fjH//4Bz744APMmDEjzqNOThdccAGee+453HnnnZg3bx5qamqwdetWbNiwAaeccgomTZqEjo4OfPvtt9i0aRMVJO6Duro6PPXUU3j//fcxYcIEnH322SguLqZrdJS0tbVh9OjRGDZsGAYPHozRo0dj7NixGDVqFAYNGhQ06/zee+9hv/32Q2VlJcrKyuI4akLig2JG51HM6DyKF2OLYsbYoHjRWRQvJidKKMYQXWyc8+OPP2LMmDGYPXs2MjMzUVlZiebmZui6DkVRUFxcjGHDhmHcuHFoaWnBbbfdBlVVael/L33++eeYO3cu1q9fjyFDhgAAvv32W0yYMAGvvfYaDjnkEACAqqo44IADMHnyZNx9993xHHLSMgwD//d//4d//vOfWL58OU4++WSIooiff/4Zo0ePxocffoiRI0eioaEBQ4cOjfdwCQnp008/xfTp0zFlyhTwPI/6+nqoqgqe55GTk4OKigqMGDECo0aNwubNm3H//fejtbU13sMmJK4oZnQOxYzOo3gxtihmJKmA4sXkRGvLY4gCQ+dUVVWhoqICCxYswFlnnYVvv/0WW7ZswcaNG7Fx40Zs2bIFGzZswKeffopNmzZh8ODBFBhG4IcffkD//v2D3ruvv/4axcXF2HvvvQOPybKMAw44AO+8804cRpkaJEnC2WefDdM08de//hXt7e0455xz8OWXXyI/Px977LEH8vPzaduKg0zTBM/zYRXuJ6FVVVWhvLwcy5Ytw5FHHolvv/0WW7duxW+//YatW7di27Zt+Oijj/Dvf/8bGzdu7LZDJSHphmJG51DM6DyKF2OLYsb4ongxOiheTE6UUIyBxsZG/Oc//4FpmpgyZQqGDRsW7yGlnJycHBQUFAQu5BMmTMCECRMC/97e3o66ujp89913WLFiBYYPHx7H0Sa3fv36ob6+PrBdIicnB8uWLQvqGOf1evHbb79R4NJHoijij3/8I/Lz83HZZZehtbUVO3bswPDhw6kAdBR9+OGH+OqrrzBy5EjMmTMnUMepa5dEErnMzExYlgVJklBeXo7y8vKgf6+trQ26Po8ZMyZOIyUk/ihmdB7FjLFB8WJsUczoPIoXnUXxYnKihKLD3n33XcybNw+qqqKoqAgDBgzArbfeir333jtoO4tpmjT72QcTJkzAU089hdLSUgD2++l/b3meR2ZmJjIzM5GXl4fW1laMGzcunsNNWocccgjy8/PRv39/AIBlWTjiiCNwxBFHAOjcorV161Z8/fXXOOmkk+I53KTnfz9PO+00jBkzBqeddhp+/PFHLFu2DLIsx3t4Sa+1tRV33XUXbrvtNhQUFCAjIwNXXHEFFi5ciJUrV+KZZ57B0KFDcfzxx2Pu3Ln0nkdo+vTpeOCBBzBx4kQA9g0kz/PgOA4cx6G4uBjFxcUoKyuDx+OhAJGkLYoZY4NiRudRvBh7FDM6h+LF2KB4MTnRmlwHffXVVzjnnHMwc+ZMvP7667jiiivQ0dGBww47DO+99x44joNlWQCAjz/+GAcddFCcR5y8RFHE+PHjUVJSAsCeKeJ5fpdl5y0tLRgyZAgOPPDAeAwz6RUVFeHwww8PvM88zwfOYcAOZgDgscceA8dx9D73kf8Gx7IsTJs2De+88w4efPBBLF26tNvuZ6R3nn32WTz99NM477zzsGrVKsyYMQP33nsvLrroIlxyySVwuVxYt24dTjzxRDz11FMAOs9xEr7MzEwceeSRGDBgAAD7eu0PELtqbm7G4MGDMXv27HgMk5C4opgxdihmdB7Fi7FHMaNzKF6MDYoXkxM1ZXHQzTffjFdeeQVPP/00Bg4cCMAOTo4++mhs2rQJb731FoYPHw7GGG655RasXLkSP//8c5xHTUjfffbZZ2hra8OsWbNoFQVJWEcffTTy8/Nx//33Q1EUAMC+++6L+vp63H777dh///1RX1+PM888E42NjXj55ZeDun+S6KNGFCRdUcxI0hHFiyQZULyYeCheTBy0QtFBn332GcaMGRPY/6/rOnJycrBq1SoUFBRg+fLlUFUVHMfhs88+w5QpU+I8YkKiY+rUqdhvv/0oOCQJ7ccff8TEiRMhSRJ0XQcA1NTU4LjjjsPhhx8Ot9uN/v3749JLL0VLSwu+/vrrOI849VFwSNIVxYwkHVG8SJIBxYuJh+LFxEEJRQe5XC5omha48MiyDNM0UVJSgvvvvx/ffvst/vznP0NVVXzzzTeYNWtWnEdMCCHpQ1EUyLIMnucD9W46OjowY8aMoOOKi4tRX18fqLdFCCHRRjEjIYQkJooXCQmNmrI4aPr06fjLX/4SVJPFPwM3bdo03HDDDbjwwgsxaNAgbN++HTNnzozXUAkhJK20trZi+vTp2Lx5c+Axy7LwyiuvYMSIEUHH7tixA83NzRg5cmSMR0kISRcUMxJCSOKheJGQ3aMaig7SNA2//vorRo8evUuhZwAwDAPLly/HY489BgBBxYoJIYQ4r6mpCXl5eSH/vaGhAStWrMC3336Ljz/+OHYDI4SkFYoZCSEkcVG8SEj3aIWigxRFwdixY0P+uyRJuOmmm/DFF19Qe3lCCImD3QWHAPDbb7+hsrISZ5xxRmwGRAhJSxQzEkJI4qJ4kZDu0QpFB+zcdciyrMBj3c06Nzc3o7q6epdl04QQQpxlmiYAu7iz/09Xqqqivb0dOTk5kCQpHkMkhKQwihkJISTxUbxISPeoKYsDOI7Dd999h6amJgAAz/MQBCEoMPR6vQCA2tpavPLKK4EW9IQQQpzX0tICwK5R5r8++4NDxljgGt3a2orXXnsNzc3NcRsrISR1UcxICCGJi+JFQnaPVig6JDc3FwUFBaioqMCIESMwYcIE7LnnnhgzZgzKysoCx/34448YM2YMPvjgg106RRFCCIk+j8eDIUOGYPDgwRg0aBDGjBmDsWPHYsyYMRg8eHDQzfrHH3+MmTNnYtOmTRg0aFAcR00ISVUUMxJCSOKheJGQnlENRQf88ssvaG1txZQpU5Cbm4tvv/0W7733HjRNgyRJKCoqwrBhwzBu3Dh4PB7wPI8pU6bEe9iEEJIWfvjhB1RXV2PQoEHYunUr1q9fj46ODgBAVlYWysvLMWLECIwePRrbt2+Hy+Wi4JAQ4giKGQkhJDFRvEhIzyih6ICqqipUVFTguOOOw7nnnosffvgBW7ZswcaNG7Fx40Zs3rwZW7ZswRdffIFNmzZh4MCBtH2FEEJipKqqCuXl5Vi8eDGOP/54fPPNN9i6dWvg2rxt2zZ8+umnePvtt7Fp0yZMmDAh3kMmhKQoihkJISQxUbxISM8ooeiAnJwclJeXB/5/9OjRGD16dOD/PR4P6urq8N1332HFihXYY4894jBKQghJT1lZWYE6ZYWFhdhvv/2C/r2hoQG1tbX4/vvvsWLFCowbNy4+AyWEpDyKGQkhJDFRvEhIzyih6IBx48bhySefRGFhIQC7K5S/eCvP83C73RgwYAByc3PR0tKC8ePHx3O4hBCSVqZNm4ZHHnkkcNPu9XoDRbY5jkNBQQEKCgpQUlKCjo4OjB07Ns4jJoSkKooZCSEkMVG8SEjPKKHoAEEQMHLkyKD/705LSwuGDRuGAw88MFZDI4SQtOd2u3HAAQcE/l8Uu/8obGlpweDBgzFnzpxYDY0QkmYoZiSEkMRE8SIhPaMuz4QQQkgIjLHAaiFCCCGEEEJ2RvEiSVeUUCSEEEIIIYQQQgghhISNj/cACCGEEEIIIYQQQgghyYMSioQQQgghhBBCCCGEkLBRQpEQQgghhBBCCCGEEBI2SigSQgghhBBCCCGEEELCRglFQgghhBBCCCGEEEJI2CihSAghhBBCCCGEEEIICRslFAkhhBBCCCGEEEIIIWGjhCIhhBBCCCGEEEIIISRslFAkhBBCCCGEEEIIIYSEjRKKhBBCCCGEEEIIIYSQsInxHgAhJD2pqgpd1+M9DEIIIYQQQkiEZFmGy+WK9zAIIXFACUVCSMypqopcdz50qPEeCiGEEEIIISRCZWVl2LRpEyUVCUlDlFAkhMScruvQoWJfHAYREsB1Vl/geA5d/ifE413+HuJxjudDHB/icd/fuS6vGeq5w3s+dP94yOcM43XRu/eABR0TYjwh/h742pBfh12P3enxkGMJdUyI12Kh3stQY+BDPB50fIjXQtfH/c8XaixhPF+0judDPB7qvekq5PG9eDyMn3eo54jK6+8snK8NcXxfxuP/uxPfa1d9OqYPYwPHwjimN6/f5fkQQshxsW6PCee1evucXG9fF7sew3Hdf4dcL1+TC/p7z+MKOj7E64b8+Ar5ut1/bajjed/7Efr1uxwbxuM8wjgmjL93HU9vv7brGIKPsUK8Fuvm6zqPFUI+d9fn6xyvEPQedP+awc8Z4phQj3d5Tg7dPx40/s6h7fR4iO/F97qhxhL0OqFev+vYu7x+8Pdkdft4qPcm9PN3P4ag7y+MY7huvl8hxLnU9fHgY9D596DX7yQEnStciGO6Pt7z34OP50Mcs+vjLa0WBk3ZDF3XKaFISBqihCIhJG5ESBC5nRKKIZJsoR4PdafEhTwmVKKR2/Xr+pRQDHkH1/O4wnnduCcUe/c6SZNQ7C6BkIQJxT4l7rp7PNR73YskXDTHlZIJxXCOQRjH9GkMDiYUQ3wfKZlQDHru6CQUw3n+4MtB5AnCiBOK4Rwbw4Ri6KRg9BOK/uNDHRteQjFUgsnZhGLIhF4YicPQj0c3oSgEPU/nicZ3Oem6Ph783nR9vPvjg8fQ9ZhQiUl0f0zQOHv6954TioIDCcXg47t/b8JLKFIrBkIINWUhhBBCCCGEEEIIIYT0AiUUCSGEEEIIIYQQQgghYaOEIiGEEEIIIYQQQgghJGyUUCSEEEIIIYQQQgghhISNEoqEEEIIIYQQQgghhJCwUUKREEIIIYQQQgghhBASNkooEkIIIYQQQgghhBBCwkYJRUIIIYQQQgghhBBCSNgooUgIIYQQQgghhBBCCAkbJRQJIYQQQgghhBBCCCFho4QiIYQQQgghhBBCCCEkbJRQJIQQQgghhBBCCCGEhI0SioQQQgghhBBCCCGEkLBRQpEQQgghhBBCCCGEEBI2SigSQgghhBBCCCGEEELCRglFQgghhBBCCCGEEEJI2CihSAghhBBCCCGEEEIICRslFAkhhBBCCCGEEEIIIWGjhCIhhBBCCCGEEEIIISRslFAkhBBCCCGEEEIIIYSEjRKKhBBCCCGEEEIIIYSQsFFCkRBCCCGEEEIIIYQQEjZKKBJCCCGEEEIIIYQQQsJGCUVCCCGEEEIIIYQQQkjYKKFICCGEEEIIIYQQQggJGyUUCSGEEEIIIYQQQgghYaOEIiGEEEIIIYQQQgghJGyUUCSEEEIIIYQQQgghhISNEoqEEEIIIYQQQgghhJCwUUKREEIIIYQQQgghhBASNkooEkIIIYQQQgghhBBCwkYJRUIIIYQQQgghhBBCSNgooUgIIYQQQgghhBBCCAkbJRQJIYQQQgghhBBCCCFhE+M9AEJI+vLCABjQdW6DY1yXI0I93uXvIR7nGN/t4wj1uGX/neNC/DsX4u9d52WCjkH3j4d8zjBeN9TjrPvHWdAxIcYT4u+Brw35ddj1WACwuj+ehfHeBP9oun5tL8fAh3g85GnT5bXQ9XH/84UaSxjPF63jQ53OIc+zcI7vxeOh3uswniMqr7+zcL42xPF9GY//7058r1316Zg+jA0cC+OY3rx+l+dDCCHHxbo9JpzX6u1zcr19Xex6DMd1/x1yvXxNLujvPY8r6PgQrxvqks9Cvm73XxvqeOZ7P7q+vhXiWD6Mx3mEcUwYfw/6pO7t8yDUMVa3j3O+44O/rvNYIeRzd32+zvEKQe9B968Z/Jwhjgn1eJfn5ND940Hj7xzaTo+H+F58rxtqLEGvE+r1u469y+sHf09Wt4+Hem9CP3/3Ywj6/sI4huvm+xVCnEtdHw8+Bp1/D3r9TkLQucKFOKbr4z3/Pfh4hDhm17G1tHYN/Agh6YYSioSQmGOMISsrCx+0veZ7oMs/mnEZEiGEEEIIIaSXsrKywFjIaSNCSAqjhCIhJOY4jkNbWxu2bt2KnJyceA+HpJCWlhYMGDCAzi3iCDq/iFPo3CJOoXOLOMl/fnGhdkkQQlIaJRQJIXGTk5NDwS1xBJ1bxEl0fhGn0LlFnELnFiGEkGijpiyEEEIIIYQQQgghhJCwUUKREEIIIYQQQgghhBASNkooEkJiTlEU/PnPf4aiKPEeCkkxdG4RJ9H5RZxC5xZxCp1bxEl0fhGS3jhGLZkIIYQQQgghhBBCCCFhohWKhBBCCCGEEEIIIYSQsFFCkRBCCCGEEEIIIYQQEjZKKBJCCCGEEEIIIYQQQsImxnsAhJDUdOutt2LIkCHYuHEjhgwZgnnz5kX1eJLeenO+NDU14YEHHgAAvPXWWzjzzDPp/CIhRXot2rhxI+6//37ccsstDo+QJKvenlv+c2ratGkAgAMOOAB5eXkxGClJRpHEXXl5eWhqaqK4i4Tkvw4NHToUy5cv7/F4iucJSS+UUCSERN2ZZ56J+fPn44ADDgAAzJ8/H0OGDMHkyZOjcjxJb709X1asWIH7778fALB8+XLk5+fj888/p/OL7KIv16IzzzwTQ4YMcXqIJEn19tzauHEj5s+fj88//zxw/MaNG3HppZfGbMwkefT2/Lr11luDzqVbb70V69evp89FEuTtt99GU1MT1q9fj8LCwh6Pp3iekPRDXZ4JIVHHcRy6XloeeOABfP7554GkTl+PJ+mtN+fLxo0bceaZZ2LNmjWBlT0HHngg8vLysGbNmlgNmSSJSK9Fb7/9duB8ousW6U5vz6358+fjwAMPDKwIWr9+PYYMGUIrFEm3Ijm/un4Grl+/Hm+//TYlrEm35s+fj2nTpvV4flA8T0j6oRqKhJCoevvtt7u94Xn77bejcjxJb5GcL5999hkaGhoC/+/fikNIV325Fm3cuBFDhw51YFQkFURybj377LOBVT4AMHnyZEomkm5Fcn6tX78+UAoEsD8naRUZ6QuK5wlJT5RQJIREVVNT0y6PFRQUBCV0+nI8SW+9PV+GDBmCxsbGoK2ob/9/e3d40zgMhnH8uQ1C2SAdgbJBskGlTADdIBYTVM0GmAmKskHSDcAbkA2oskHvA2rUtL1enQZO1/x/Eh+ojOQPj4x58WuXpSaTyXdNEf+prmuRtfase6UwXL7Zcs5J+ipU53kua22r+APs6rJ2GWOa9lTnnOq6bhWwAV/s54Fh4g5FAL1ar9cajUatz7aXfvcxHsN2aV6cc1qv1zycgQNdsrV9zAA4xTdb2xPUdV03DxrEcazRaMQDBzjQZe16fHzU+/u7rLUqy1Kr1eqbZ4lrx34eGCZOKALo1f5mQvr6o+hPrVq+4zFsl+bl4eFBq9WKfOFAl2y9vr5yqgd/1XXd2m1BjeNY8/m876nhCnTJl7VWcRzr4+NDk8lEd3d3tKbiIuzngWGioAigV0EQHLQ3HPuvZdfxGLZL8mKM0cvLC/dE4SjfbJVlSTERZ/HN1vbU6/7pV+5+xTG++aqqSkVRaDqdKgxDFUWhxWIhY8xPTBdXiv08MEwUFAH0Koqig/aGU3fz+I7HsHXNi7VWSZI0xUROYmBfl2zlea4sy5RlmZbLpd7e3pRlGS1eaPHN1nad2i0gfn5+0l6Po3zz5ZzT/f196zNed8al2M8Dw0RBEUDvptNpq2BTFIVms1nzvXNOeZ6fPR7Y5Zuv7dggCFRVlZxzzaMHwC6fbEVRpDRNm68oihSGodI0pcULB3zXrTRNW+Odc3p6evqZyeK/47t2FUXR+vmqqpQkyc9MFleD/TyAX5vNZvOvJwHg+hhjNB6Pm0cLdi+SN8bIOdfa0J4aD+w7N191Xevm5ubg5xeLBScycJTv2iVJWZbp+flZkjSbzcgWjurye1GSbm9vFQQBr4njJJ98Oee0XC41Ho+bMeQL+8qylHNO8/lcYRgqSZKmVV5iPw+AgiIAAAAAAAAAD7Q8AwAAAAAAADgbBUUAAAAAAAAAZ/sNAqMzOXMNERAAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  runs/eval-test-graph_lam-2x64-07_15_22-2169/wandb/latest-run/files/media/images/t2m_example_2_31_0941591302c7b821d34c.png\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rmse_plots = sorted(\n",
+    "    glob.glob(\"runs/**/test_rmse_*.png\", recursive=True), key=os.path.getmtime\n",
+    ")\n",
+    "if rmse_plots:\n",
+    "    print(\"RMSE scorecard:\", rmse_plots[-1])\n",
+    "    display(Image(filename=rmse_plots[-1]))\n",
+    "else:\n",
+    "    print(\"test_rmse plot not found - check eval output above.\")\n",
+    "\n",
+    "example_plots = sorted(\n",
+    "    glob.glob(\"runs/**/*_example_*.png\", recursive=True), key=os.path.getmtime\n",
+    ")\n",
+    "if example_plots:\n",
+    "    n_show = min(2, len(example_plots))\n",
+    "    print(f\"Showing {n_show} of {len(example_plots)} prediction plot(s):\")\n",
+    "    for path in example_plots[-n_show:]:\n",
+    "        print(\" \", path)\n",
+    "        display(Image(filename=path))\n",
+    "else:\n",
+    "    print(\"No prediction plots found - check eval output above.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Scaling Tips & Next Steps\n",
+    "\n",
+    "### 🔁 Use a larger / hierarchical graph\n",
+    "\n",
+    "For a production-quality run, switch to the hierarchical Hi-LAM graph:\n",
+    "\n",
+    "```bash\n",
+    "python -m neural_lam.create_graph \\\n",
+    "    --config_path <your_config.yaml> \\\n",
+    "    --name hierarchical \\\n",
+    "    --hierarchical\n",
+    "\n",
+    "python -m neural_lam.train_model \\\n",
+    "    --config_path <your_config.yaml> \\\n",
+    "    --model hi_lam \\\n",
+    "    --graph hierarchical \\\n",
+    "    --epochs 200\n",
+    "```\n",
+    "\n",
+    "### ⚡ Enable GPU training\n",
+    "\n",
+    "Re-create the environment with a CUDA build of PyTorch and `--devices` will auto-detect your GPU:\n",
+    "```bash\n",
+    "uv sync --extra gpu        # CUDA 13.0\n",
+    "# or: uv sync --extra gpu-cu128   # CUDA 12.8\n",
+    "```\n",
+    "\n",
+    "### 📦 Use larger / full DANRA data\n",
+    "\n",
+    "Modify `danra.datastore.yaml` to extend the `coord_ranges.time` window, or point `inputs[*].path` at a larger dataset. See the [mllam-data-prep README](https://github.com/mllam/mllam-data-prep) for full configuration options.\n",
+    "\n",
+    "For large datasets (≥10 GB), use parallel preprocessing:\n",
+    "```bash\n",
+    "python -m mllam_data_prep \\\n",
+    "    <your_datastore.yaml> \\\n",
+    "    --dask-distributed-local-core-fraction 0.5\n",
+    "```\n",
+    "\n",
+    "### 📊 Enable cloud logging with W&B\n",
+    "\n",
+    "Remove the `WANDB_MODE=offline` line (or set it to `online`) and optionally set `--logger wandb --logger-project <your-project-name>`.\n",
+    "\n",
+    "### 🔗 Further reading\n",
+    "\n",
+    "- [neural-lam README](https://github.com/mllam/neural-lam)\n",
+    "- [mllam-data-prep](https://github.com/mllam/mllam-data-prep)\n",
+    "- [Graph-based Neural Weather Prediction (NeurIPS 2023)](https://arxiv.org/abs/2309.17370)\n",
+    "- [Probabilistic Weather Forecasting with Hierarchical GNNs (NeurIPS 2024)](https://arxiv.org/abs/2406.04759)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.13.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/neural_lam/train_model.py b/neural_lam/train_model.py
index 2a9775c98..46dc32f8a 100644
--- a/neural_lam/train_model.py
+++ b/neural_lam/train_model.py
@@ -1,6 +1,7 @@
 """CLI entry point for training Neural-LAM models."""
 
 # Standard library
+import argparse
 import json
 import os
 import random
@@ -17,11 +18,60 @@
 
 # Local
 from . import utils
-from .config import load_config_and_datastore
+from .config import (
+    DatastoreSelection,
+    ManualStateFeatureWeighting,
+    NeuralLAMConfig,
+    OutputClamping,
+    TrainingConfig,
+    UniformFeatureWeighting,
+    load_config_and_datastore,
+)
 from .gnn_layers import GNN_TYPES
 from .models import MODELS, ARForecaster, ForecasterModule
 from .weather_dataset import WeatherDataModule
 
+torch.serialization.add_safe_globals(
+    [
+        argparse.Namespace,
+        DatastoreSelection,
+        ManualStateFeatureWeighting,
+        NeuralLAMConfig,
+        OutputClamping,
+        TrainingConfig,
+        UniformFeatureWeighting,
+    ]
+)
+
+
+def build_predictor(predictor_class, args, config, datastore):
+    """
+    Instantiate a step predictor with explicit GNN kwargs for its model family.
+    """
+    kwargs = dict(
+        datastore=datastore,
+        graph_name=args.graph,
+        hidden_dim=args.hidden_dim,
+        hidden_layers=args.hidden_layers,
+        processor_layers=args.processor_layers,
+        mesh_aggr=args.mesh_aggr,
+        num_past_forcing_steps=args.num_past_forcing_steps,
+        num_future_forcing_steps=args.num_future_forcing_steps,
+        output_std=args.output_std,
+        output_clamping_lower=config.training.output_clamping.lower,
+        output_clamping_upper=config.training.output_clamping.upper,
+        g2m_gnn_type=getattr(args, "g2m_gnn_type", "InteractionNet"),
+        m2g_gnn_type=getattr(args, "m2g_gnn_type", "InteractionNet"),
+    )
+    if getattr(args, "model", None) in ("hi_lam", "hi_lam_parallel"):
+        kwargs["mesh_up_gnn_type"] = getattr(
+            args, "mesh_up_gnn_type", "InteractionNet"
+        )
+        kwargs["mesh_down_gnn_type"] = getattr(
+            args, "mesh_down_gnn_type", "InteractionNet"
+        )
+    return predictor_class(**kwargs)
+
 
 class AdaptiveHelpFormatter(ArgumentDefaultsHelpFormatter):
     """``--help`` formatter that scales the column width to the terminal."""
@@ -50,19 +100,7 @@ def load_forecaster_module_from_checkpoint(ckpt_path, config, datastore):
     ckpt = torch.load(ckpt_path, weights_only=False)
     args = ckpt["hyper_parameters"]["args"]
     predictor_class = MODELS[args.model]
-    predictor = predictor_class(
-        datastore=datastore,
-        graph_name=args.graph,
-        hidden_dim=args.hidden_dim,
-        hidden_layers=args.hidden_layers,
-        processor_layers=args.processor_layers,
-        mesh_aggr=args.mesh_aggr,
-        num_past_forcing_steps=args.num_past_forcing_steps,
-        num_future_forcing_steps=args.num_future_forcing_steps,
-        output_std=args.output_std,
-        output_clamping_lower=config.training.output_clamping.lower,
-        output_clamping_upper=config.training.output_clamping.upper,
-    )
+    predictor = build_predictor(predictor_class, args, config, datastore)
     forecaster = ARForecaster(predictor, datastore)
     return ForecasterModule.load_from_checkpoint(
         ckpt_path,
@@ -72,7 +110,7 @@ def load_forecaster_module_from_checkpoint(ckpt_path, config, datastore):
     )
 
 
-@logger.catch
+@logger.catch(reraise=True)
 def main(input_args=None):
     """Main function for training and evaluating models."""
     parser = ArgumentParser(
@@ -457,23 +495,7 @@ def main(input_args=None):
     # Build predictor and forecaster externally, then inject into
     # ForecasterModule
     predictor_class = MODELS[args.model]
-    predictor = predictor_class(
-        datastore=datastore,
-        graph_name=args.graph,
-        hidden_dim=args.hidden_dim,
-        hidden_layers=args.hidden_layers,
-        processor_layers=args.processor_layers,
-        mesh_aggr=args.mesh_aggr,
-        num_past_forcing_steps=args.num_past_forcing_steps,
-        num_future_forcing_steps=args.num_future_forcing_steps,
-        output_std=args.output_std,
-        output_clamping_lower=config.training.output_clamping.lower,
-        output_clamping_upper=config.training.output_clamping.upper,
-        g2m_gnn_type=args.g2m_gnn_type,
-        m2g_gnn_type=args.m2g_gnn_type,
-        mesh_up_gnn_type=args.mesh_up_gnn_type,
-        mesh_down_gnn_type=args.mesh_down_gnn_type,
-    )
+    predictor = build_predictor(predictor_class, args, config, datastore)
     forecaster = ARForecaster(predictor, datastore)
 
     model = ForecasterModule(
diff --git a/pyproject.toml b/pyproject.toml
index 113329e13..f730c182c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -51,7 +51,7 @@ gpu = ["torch>=2.12,<2.13"]        # CUDA 13.0, default GPU build
 gpu-cu128 = ["torch>=2.11,<2.12"]  # CUDA 12.8, last torch series with cu128 wheels
 
 [dependency-groups]
-dev = ["pre-commit>=3.8.0", "pytest>=8.3.2", "pooch>=1.8.2"]
+dev = ["pre-commit>=3.8.0", "pytest>=8.3.2", "pooch>=1.8.2", "nbmake>=1.5.0", "ipykernel>=6.0.0"]
 
 [tool.uv]
 # uv-specific configuration for PyTorch CPU/GPU variant selection.
@@ -119,7 +119,7 @@ per-file-ignores = [
 ]
 
 [tool.codespell]
-skip = "requirements/*"
+skip = "requirements/*,docs/notebooks/hello_world_danra.ipynb"
 
 # Pylint config
 [tool.pylint]
@@ -158,11 +158,6 @@ ignore-nested-functions = false
 ignore-property-decorators = false
 exclude = ["tests", "docs", "build"]
 
-[tool.pytest.ini_options]
-markers = [
-    "slow: marks tests as slow (deselected by default, run with -m slow)",
-]
-
 [build-system]
 requires = ["hatchling>=1.27.0", "hatch-vcs"]
 build-backend = "hatchling.build"
@@ -174,6 +169,13 @@ core-metadata-version = "2.4"
 source = "vcs"
 fallback-version = "0.0.0"
 
+[tool.pytest.ini_options]
+markers = [
+    "slow: marks tests as slow (deselected by default, run with -m slow)",
+]
+testpaths = ["neural_lam", "tests"]
+addopts = "--doctest-modules -vv -s"
+
 [tool.hatch.build.targets.sdist]
 exclude = [
   ".venv/",
diff --git a/tests/test_train_model_warnings.py b/tests/test_train_model_warnings.py
index eb4c2bc02..87be7beae 100644
--- a/tests/test_train_model_warnings.py
+++ b/tests/test_train_model_warnings.py
@@ -1,4 +1,5 @@
 # Standard library
+from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
 
 # Third-party
@@ -6,10 +7,16 @@
 import pytest
 
 # Mock loguru.logger.catch before importing train_model
-loguru.logger.catch = lambda f: f
+loguru.logger.catch = lambda *args, **kwargs: (
+    args[0] if args and callable(args[0]) else (lambda f: f)
+)
 
 # First-party
-from neural_lam.train_model import main  # noqa: E402
+from neural_lam.train_model import (  # noqa: E402
+    build_predictor,
+    load_forecaster_module_from_checkpoint,
+    main,
+)
 
 
 @pytest.mark.parametrize(
@@ -130,3 +137,92 @@ def test_steps_to_log_validation(train_steps, val_steps, match_err):
         ):
             with pytest.raises(ValueError, match=match_err):
                 getattr(main, "__wrapped__", main)()
+
+
+def test_checkpoint_loader_restores_gnn_type_kwargs():
+    """Checkpoint reload must preserve custom GNN choices from saved args."""
+    args = SimpleNamespace(
+        model="hi_lam",
+        graph="hierarchical",
+        hidden_dim=4,
+        hidden_layers=1,
+        processor_layers=1,
+        mesh_aggr="sum",
+        num_past_forcing_steps=1,
+        num_future_forcing_steps=1,
+        output_std=False,
+        g2m_gnn_type="PropagationNet",
+        m2g_gnn_type="PropagationNet",
+        mesh_up_gnn_type="PropagationNet",
+        mesh_down_gnn_type="InteractionNet",
+    )
+    config = SimpleNamespace(
+        training=SimpleNamespace(
+            output_clamping=SimpleNamespace(lower={}, upper={})
+        )
+    )
+    datastore = MagicMock()
+    captured_kwargs = {}
+
+    class DummyPredictor:
+        def __init__(self, **kwargs):
+            captured_kwargs.update(kwargs)
+
+    loaded_module = MagicMock()
+
+    with (
+        patch(
+            "neural_lam.train_model.torch.load",
+            return_value={"hyper_parameters": {"args": args}},
+        ),
+        patch("neural_lam.train_model.MODELS", {"hi_lam": DummyPredictor}),
+        patch("neural_lam.train_model.ARForecaster"),
+        patch(
+            "neural_lam.train_model.ForecasterModule.load_from_checkpoint",
+            return_value=loaded_module,
+        ),
+    ):
+        result = load_forecaster_module_from_checkpoint(
+            "model.ckpt", config, datastore
+        )
+
+    assert result is loaded_module
+    assert captured_kwargs["g2m_gnn_type"] == "PropagationNet"
+    assert captured_kwargs["m2g_gnn_type"] == "PropagationNet"
+    assert captured_kwargs["mesh_up_gnn_type"] == "PropagationNet"
+    assert captured_kwargs["mesh_down_gnn_type"] == "InteractionNet"
+
+
+def test_build_predictor_omits_hierarchical_gnn_kwargs_for_graph_lam():
+    """GraphLAM must not receive hierarchical-only GNN constructor kwargs."""
+    args = SimpleNamespace(
+        model="graph_lam",
+        graph="multiscale",
+        hidden_dim=4,
+        hidden_layers=1,
+        processor_layers=1,
+        mesh_aggr="sum",
+        num_past_forcing_steps=1,
+        num_future_forcing_steps=1,
+        output_std=False,
+        g2m_gnn_type="PropagationNet",
+        m2g_gnn_type="InteractionNet",
+        mesh_up_gnn_type="PropagationNet",
+        mesh_down_gnn_type="PropagationNet",
+    )
+    config = SimpleNamespace(
+        training=SimpleNamespace(
+            output_clamping=SimpleNamespace(lower={}, upper={})
+        )
+    )
+    captured_kwargs = {}
+
+    class DummyGraphLAM:
+        def __init__(self, **kwargs):
+            captured_kwargs.update(kwargs)
+
+    build_predictor(DummyGraphLAM, args, config, MagicMock())
+
+    assert "mesh_up_gnn_type" not in captured_kwargs
+    assert "mesh_down_gnn_type" not in captured_kwargs
+    assert captured_kwargs["g2m_gnn_type"] == "PropagationNet"
diff --git a/uv.lock b/uv.lock
index b9d5a7ed5..8f49dd4c6 100644
--- a/uv.lock
+++ b/uv.lock
@@ -223,6 +223,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
 ]
 
+[[package]]
+name = "appnope"
+version = "0.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" },
+]
+
 [[package]]
 name = "asciitree"
 version = "0.3.3"
@@ -281,6 +290,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fb/2b/a88e0bca1a46a902854122e008d2f5fa67e42e011f5ed36a040587cc1c9d/astropy_iers_data-0.2026.3.30.0.54.34-py3-none-any.whl", hash = "sha256:b6784cbd4d1f28f5767af03702af4db33480ce4d159d64e0c65d33183b192973", size = 1985859, upload-time = "2026-03-30T00:55:13.807Z" },
 ]
 
+[[package]]
+name = "asttokens"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" },
+]
+
 [[package]]
 name = "async-timeout"
 version = "5.0.1"
@@ -614,6 +632,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
+[[package]]
+name = "comm"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" },
+]
+
 [[package]]
 name = "contourpy"
 version = "1.3.2"
@@ -1084,6 +1111,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/21/c4/1698067427e6fd5bff407cafe5ba1b3cf109b92e2b064d2e4b4f73379bc3/dataclass_wizard-0.30.1-py2.py3-none-any.whl", hash = "sha256:bf4af012d4fc04511efcc2be52024589faec150795bec5517b56d4ab131e2d1d", size = 114331, upload-time = "2024-11-26T03:33:06.79Z" },
 ]
 
+[[package]]
+name = "debugpy"
+version = "1.8.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/f3/6b1d4c71f4cbb5360009f928934a03b42906f28fc7b3f7f35f04e58acead/debugpy-1.8.21-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:8eeab7b5462f683452c57c0126aaa5ec4e974ddb705f39ba87dff8818c8e08f9", size = 2113873, upload-time = "2026-06-01T19:30:37.148Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/f2/17c3bf91cebc173bfbf5734cd2669723d0a35c0cf9d2fd2124546efeae83/debugpy-1.8.21-cp310-cp310-manylinux_2_34_x86_64.whl", hash = "sha256:0fddfdc130ac6d8bfc0415b0409822fa901c8f310e5c945ac5653a0352532344", size = 3004715, upload-time = "2026-06-01T19:30:38.888Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/22/1f8efd80c7b5909e760f9cfd0c9e8681d2d35d532f7c0a40760cd4da4a19/debugpy-1.8.21-cp310-cp310-win32.whl", hash = "sha256:72b5d676c4cbfac3bac5bb01c138a4656e843f93f03ce2a5f4e394ad49fbee73", size = 5303455, upload-time = "2026-06-01T19:30:40.52Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ce/54c79abd6cccef92fa7b43d97e3acafedf4d645557267ece05e948b5e4b8/debugpy-1.8.21-cp310-cp310-win_amd64.whl", hash = "sha256:a7fe47fd23da57b9e0bec3f4a8ee65a2dc55782455ed7f2141d75ab5d2eaeef5", size = 5331751, upload-time = "2026-06-01T19:30:42.146Z" },
+    { url = "https://files.pythonhosted.org/packages/89/fb/cbf306d6e07a313a91e7171a98669054502840931432c227cfd505ee367f/debugpy-1.8.21-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:da456226c7b4c69e35dbe35dcee6623d912000a77816db7856a41af1c72a0264", size = 2203120, upload-time = "2026-06-01T19:30:43.964Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/57/aa739bd4ad2cbf96aeb1b20b56918ddd5ae4c28b68709bfcd327f02123ee/debugpy-1.8.21-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:f68b891688e61bdc08b8d364d919ff0051e0b94657b39dcd027bc3173edb7cdc", size = 3059958, upload-time = "2026-06-01T19:30:45.622Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/31/453d2c9a23d133fe2c8ec7ca1d816ded52a913487fe3ffef7c01b4b706af/debugpy-1.8.21-cp311-cp311-win32.whl", hash = "sha256:f843a8b08c2edeaf9b1582eed4f25441af21a297c22ff16bf76a662557aa9c9e", size = 5236515, upload-time = "2026-06-01T19:30:47.461Z" },
+    { url = "https://files.pythonhosted.org/packages/60/94/6660de2f2d7bf388f229335ba4637646eebabdbf38564cb439a95a9193c9/debugpy-1.8.21-cp311-cp311-win_amd64.whl", hash = "sha256:84c564d8cc701d41843b29a92814c1f1bef6798724ca9d675c284ad9f6a547d7", size = 5256138, upload-time = "2026-06-01T19:30:49.113Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/df/bf625547431a9cadc9f4cbfeda38866e2b17f6aed147b625377e87834449/debugpy-1.8.21-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:9f96713896f39c3dff0ee841f47320c3f2983d33c341e009361bb0ebc79adc4e", size = 2483609, upload-time = "2026-06-01T19:30:50.794Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/09/59324b903599031ff9faaec1758292409f6561a0ec2492fe4b703327705a/debugpy-1.8.21-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:c193d474f0a211191f2b4449d2d06157c689013035bd952f3b617e0ef422b176", size = 3968900, upload-time = "2026-06-01T19:30:52.341Z" },
+    { url = "https://files.pythonhosted.org/packages/14/cd/27f65b805d7fe005c44e1a36b9183ecdfbcdbf9d3e721a5115d461ecc7ee/debugpy-1.8.21-cp312-cp312-win32.whl", hash = "sha256:4743373c1cac7f9e74a1b9915bf1dbe0e900eca657ffb170ae07ac8363205ae9", size = 5336340, upload-time = "2026-06-01T19:30:54.047Z" },
+    { url = "https://files.pythonhosted.org/packages/77/1d/c84e30c0c674184948b66f076ab271c01d940618a2824c23cd035a27bc20/debugpy-1.8.21-cp312-cp312-win_amd64.whl", hash = "sha256:bd7ba9dd3daa7c2f942c6ca8d4695a16bf9ac16b63615261c7982bc74f7ed20c", size = 5374751, upload-time = "2026-06-01T19:30:55.891Z" },
+    { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" },
+    { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" },
+    { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" },
+    { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" },
+]
+
 [[package]]
 name = "decorator"
 version = "5.2.1"
@@ -1152,6 +1208,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
 ]
 
+[[package]]
+name = "executing"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
+]
+
 [[package]]
 name = "fastapi"
 version = "0.135.2"
@@ -1177,6 +1242,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/ac/e5d886f892666d2d1e5cb8c1a41146e1d79ae8896477b1153a21711d3b44/fasteners-0.20-py3-none-any.whl", hash = "sha256:9422c40d1e350e4259f509fb2e608d6bc43c0136f79a00db1b49046029d0b3b7", size = 18702, upload-time = "2025-08-11T10:19:35.716Z" },
 ]
 
+[[package]]
+name = "fastjsonschema"
+version = "2.21.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" },
+]
+
 [[package]]
 name = "filelock"
 version = "3.25.2"
@@ -1864,6 +1938,117 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
 ]
 
+[[package]]
+name = "ipykernel"
+version = "7.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "appnope", marker = "sys_platform == 'darwin' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "comm" },
+    { name = "debugpy" },
+    { name = "ipython", version = "8.39.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "ipython", version = "9.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "matplotlib-inline" },
+    { name = "nest-asyncio2" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyzmq" },
+    { name = "tornado" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/c4/e4a38f579de4225a561305666f7541cdabb30075def2aa1ac17bd73c1fb5/ipykernel-7.3.0.tar.gz", hash = "sha256:9acaaaf97d16355166e4085afe9d225bfbdf2b7ef520f9df3be8f2b248275e09", size = 184899, upload-time = "2026-06-10T08:41:25.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/02/77b271f5dc58bfbc0b577c877b2365d1ffea2afe66a80c13f2312820348c/ipykernel-7.3.0-py3-none-any.whl", hash = "sha256:897eb64da762549ef610698fca5e9675195ec6ac8ec7f19d81ce1ca20c876057", size = 120583, upload-time = "2026-06-10T08:41:23.648Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "8.39.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+]
+dependencies = [
+    { name = "colorama", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or (python_full_version >= '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (python_full_version >= '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (python_full_version >= '3.11' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform != 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform != 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform != 'win32' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "decorator", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "jedi", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "matplotlib-inline", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "pexpect", marker = "(python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version >= '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (python_full_version >= '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (python_full_version >= '3.11' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform == 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'win32' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "prompt-toolkit", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "pygments", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "stack-data", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "traitlets", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/18/f8598d287006885e7136451fdea0755af4ebcbfe342836f24deefaed1164/ipython-8.39.0.tar.gz", hash = "sha256:4110ae96012c379b8b6db898a07e186c40a2a1ef5d57a7fa83166047d9da7624", size = 5513971, upload-time = "2026-03-27T10:02:13.94Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/56/4cc7fc9e9e3f38fd324f24f8afe0ad8bb5fa41283f37f1aaf9de0612c968/ipython-8.39.0-py3-none-any.whl", hash = "sha256:bb3c51c4fa8148ab1dea07a79584d1c854e234ea44aa1283bcb37bc75054651f", size = 831849, upload-time = "2026-03-27T10:02:07.846Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "9.15.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+]
+dependencies = [
+    { name = "colorama", marker = "(python_full_version >= '3.11' and sys_platform == 'win32') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform != 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform != 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform != 'win32' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "decorator", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "jedi", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "matplotlib-inline", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "pexpect", marker = "(python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform == 'win32' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'win32' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "prompt-toolkit", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "psutil", marker = "(python_full_version >= '3.11' and sys_platform != 'cygwin' and sys_platform != 'emscripten') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (python_full_version < '3.11' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'cygwin' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform == 'cygwin' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'cygwin' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (sys_platform == 'emscripten' and extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "pygments", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "stack-data", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "traitlets", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "typing-extensions", marker = "python_full_version == '3.11.*' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/53/59/165d3b4d75cc34add3122c4417ecb229085140ac573103c223cd01dde96f/ipython-9.15.0.tar.gz", hash = "sha256:da2819ce2aa83135257df830660b1176d986c3d2876db24df01974fa955b2756", size = 4442580, upload-time = "2026-06-26T11:03:35.913Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/3a/948263ca3b9d65bb2b1b0c521b3a49fad5d59ada58724bd87d2bd5ff3f36/ipython-9.15.0-py3-none-any.whl", hash = "sha256:515ad9c3cdf0c932a5a9f6245419e8aba706b7bd03c3e1d3a1c83d9351d6aa6e", size = 630895, upload-time = "2026-06-26T11:03:33.809Z" },
+]
+
+[[package]]
+name = "ipython-pygments-lexers"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pygments", marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" },
+]
+
 [[package]]
 name = "isodate"
 version = "0.7.2"
@@ -1882,6 +2067,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" },
 ]
 
+[[package]]
+name = "jedi"
+version = "0.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "parso" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" },
+]
+
 [[package]]
 name = "jinja2"
 version = "3.1.6"
@@ -1912,6 +2109,64 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
 ]
 
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "rpds-py", version = "2026.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "jupyter-client"
+version = "8.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-core" },
+    { name = "python-dateutil" },
+    { name = "pyzmq" },
+    { name = "tornado" },
+    { name = "traitlets" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/dc/5512503b088997c2250b8bf18258fba9d9ce5ead641183700960d3c9d342/jupyter_client-8.9.1.tar.gz", hash = "sha256:a58f730dd9e728ba16ba1d62ebccf7ffe1ebbdbce4e95cfae941b7321ae1f4fa", size = 359256, upload-time = "2026-06-09T13:15:01.033Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/6f/56d39bf385c5c27988aebaf0c18a2a17e960575740100973511018bd904e/jupyter_client-8.9.1-py3-none-any.whl", hash = "sha256:0b7a295bc46e8751e9adae84781f726c851c1d911bd793edc4a3bde942e3da81", size = 109828, upload-time = "2026-06-09T13:14:58.835Z" },
+]
+
+[[package]]
+name = "jupyter-core"
+version = "5.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "platformdirs" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" },
+]
+
 [[package]]
 name = "kiwisolver"
 version = "1.5.0"
@@ -2255,6 +2510,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" },
 ]
 
+[[package]]
+name = "matplotlib-inline"
+version = "0.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" },
+]
+
 [[package]]
 name = "mdurl"
 version = "0.1.2"
@@ -2533,6 +2800,61 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3f/c3/06490e98393dcb4d6ce2bf331a39335375c300afaef526897881fbeae6ab/narwhals-2.18.1-py3-none-any.whl", hash = "sha256:a0a8bb80205323851338888ba3a12b4f65d352362c8a94be591244faf36504ad", size = 444952, upload-time = "2026-03-24T15:11:23.801Z" },
 ]
 
+[[package]]
+name = "nbclient"
+version = "0.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "nbformat" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", hash = "sha256:ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895", size = 25288, upload-time = "2026-06-05T07:52:40.115Z" },
+]
+
+[[package]]
+name = "nbformat"
+version = "5.10.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastjsonschema" },
+    { name = "jsonschema" },
+    { name = "jupyter-core" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" },
+]
+
+[[package]]
+name = "nbmake"
+version = "1.5.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ipykernel" },
+    { name = "nbclient" },
+    { name = "nbformat" },
+    { name = "pygments" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/9a/aae201cee5639e1d562b3843af8fd9f8d018bb323e776a2b973bdd5fc64b/nbmake-1.5.5.tar.gz", hash = "sha256:239dc868ea13a7c049746e2aba2c229bd0f6cdbc6bfa1d22f4c88638aa4c5f5c", size = 85929, upload-time = "2024-12-23T18:33:46.774Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/be/b257e12f9710819fde40adc972578bee6b72c5992da1bc8369bef2597756/nbmake-1.5.5-py3-none-any.whl", hash = "sha256:c6fbe6e48b60cacac14af40b38bf338a3b88f47f085c54ac5b8639ff0babaf4b", size = 12818, upload-time = "2024-12-23T18:33:44.566Z" },
+]
+
+[[package]]
+name = "nest-asyncio2"
+version = "1.7.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b4/73/731debf26e27e0a0323d7bda270dc2f634b398e38f040a09da1f4351d0aa/nest_asyncio2-1.7.2.tar.gz", hash = "sha256:1921d70b92cc4612c374928d081552efb59b83d91b2b789d935c665fa01729a8", size = 14743, upload-time = "2026-02-13T00:34:04.386Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/3c/3179b85b0e1c3659f0369940200cd6d0fa900e6cefcc7ea0bc6dd0e29ffb/nest_asyncio2-1.7.2-py3-none-any.whl", hash = "sha256:f5dfa702f3f81f6a03857e9a19e2ba578c0946a4ad417b4c50a24d7ba641fe01", size = 7843, upload-time = "2026-02-13T00:34:02.691Z" },
+]
+
 [[package]]
 name = "networkx"
 version = "3.4.2"
@@ -2628,6 +2950,8 @@ gpu-cu128 = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "ipykernel" },
+    { name = "nbmake" },
     { name = "pooch" },
     { name = "pre-commit" },
     { name = "pytest" },
@@ -2663,6 +2987,8 @@ provides-extras = ["cpu", "gpu", "gpu-cu128"]
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "ipykernel", specifier = ">=6.0.0" },
+    { name = "nbmake", specifier = ">=1.5.0" },
     { name = "pooch", specifier = ">=1.8.2" },
     { name = "pre-commit", specifier = ">=3.8.0" },
     { name = "pytest", specifier = ">=8.3.2" },
@@ -3419,6 +3745,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c3/13/114daf766c33aec6c5a3954e7ea653f8a7ade9602c5c5a2228281698c490/parse-1.21.1-py2.py3-none-any.whl", hash = "sha256:55339ca698019815df3b8e8b550e5933933527e623b0cdf1ca2f404da35ffb47", size = 19693, upload-time = "2026-02-19T02:20:06.575Z" },
 ]
 
+[[package]]
+name = "parso"
+version = "0.8.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" },
+]
+
 [[package]]
 name = "partd"
 version = "1.4.2"
@@ -3432,6 +3767,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl", hash = "sha256:978e4ac767ec4ba5b86c6eaa52e5a2a3bc748a2ca839e8cc798f1cc6ce6efb0f", size = 18905, upload-time = "2024-05-06T19:51:39.271Z" },
 ]
 
+[[package]]
+name = "pexpect"
+version = "4.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ptyprocess" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
+]
+
 [[package]]
 name = "pillow"
 version = "12.1.1"
@@ -3603,6 +3950,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ee/8c/83087ebc47ab0396ce092363001fa37c17153119ee282700c0713a195853/prettytable-3.17.0-py3-none-any.whl", hash = "sha256:aad69b294ddbe3e1f95ef8886a060ed1666a0b83018bbf56295f6f226c43d287", size = 34433, upload-time = "2025-11-14T17:33:19.093Z" },
 ]
 
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
 [[package]]
 name = "propcache"
 version = "0.4.1"
@@ -3772,6 +4131,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
 ]
 
+[[package]]
+name = "ptyprocess"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
+]
+
+[[package]]
+name = "pure-eval"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
+]
+
 [[package]]
 name = "pyarrow"
 version = "23.0.1"
@@ -4344,6 +4721,94 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
+[[package]]
+name = "pyzmq"
+version = "27.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "implementation_name == 'pypy' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/b9/52aa9ec2867528b54f1e60846728d8b4d84726630874fee3a91e66c7df81/pyzmq-27.1.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:508e23ec9bc44c0005c4946ea013d9317ae00ac67778bd47519fdf5a0e930ff4", size = 1329850, upload-time = "2025-09-08T23:07:26.274Z" },
+    { url = "https://files.pythonhosted.org/packages/99/64/5653e7b7425b169f994835a2b2abf9486264401fdef18df91ddae47ce2cc/pyzmq-27.1.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:507b6f430bdcf0ee48c0d30e734ea89ce5567fd7b8a0f0044a369c176aa44556", size = 906380, upload-time = "2025-09-08T23:07:29.78Z" },
+    { url = "https://files.pythonhosted.org/packages/73/78/7d713284dbe022f6440e391bd1f3c48d9185673878034cfb3939cdf333b2/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf7b38f9fd7b81cb6d9391b2946382c8237fd814075c6aa9c3b746d53076023b", size = 666421, upload-time = "2025-09-08T23:07:31.263Z" },
+    { url = "https://files.pythonhosted.org/packages/30/76/8f099f9d6482450428b17c4d6b241281af7ce6a9de8149ca8c1c649f6792/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03ff0b279b40d687691a6217c12242ee71f0fba28bf8626ff50e3ef0f4410e1e", size = 854149, upload-time = "2025-09-08T23:07:33.17Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f0/37fbfff06c68016019043897e4c969ceab18bde46cd2aca89821fcf4fb2e/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:677e744fee605753eac48198b15a2124016c009a11056f93807000ab11ce6526", size = 1655070, upload-time = "2025-09-08T23:07:35.205Z" },
+    { url = "https://files.pythonhosted.org/packages/47/14/7254be73f7a8edc3587609554fcaa7bfd30649bf89cd260e4487ca70fdaa/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd2fec2b13137416a1c5648b7009499bcc8fea78154cd888855fa32514f3dad1", size = 2033441, upload-time = "2025-09-08T23:07:37.432Z" },
+    { url = "https://files.pythonhosted.org/packages/22/dc/49f2be26c6f86f347e796a4d99b19167fc94503f0af3fd010ad262158822/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:08e90bb4b57603b84eab1d0ca05b3bbb10f60c1839dc471fc1c9e1507bef3386", size = 1891529, upload-time = "2025-09-08T23:07:39.047Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/3e/154fb963ae25be70c0064ce97776c937ecc7d8b0259f22858154a9999769/pyzmq-27.1.0-cp310-cp310-win32.whl", hash = "sha256:a5b42d7a0658b515319148875fcb782bbf118dd41c671b62dae33666c2213bda", size = 567276, upload-time = "2025-09-08T23:07:40.695Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/f4ab56c8c595abcb26b2be5fd9fa9e6899c1e5ad54964e93ae8bb35482be/pyzmq-27.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:c0bb87227430ee3aefcc0ade2088100e528d5d3298a0a715a64f3d04c60ba02f", size = 632208, upload-time = "2025-09-08T23:07:42.298Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/e3/be2cc7ab8332bdac0522fdb64c17b1b6241a795bee02e0196636ec5beb79/pyzmq-27.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:9a916f76c2ab8d045b19f2286851a38e9ac94ea91faf65bd64735924522a8b32", size = 559766, upload-time = "2025-09-08T23:07:43.869Z" },
+    { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" },
+    { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" },
+    { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" },
+    { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" },
+    { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" },
+    { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" },
+    { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" },
+    { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" },
+    { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" },
+    { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" },
+    { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" },
+    { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" },
+    { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/81/a65e71c1552f74dec9dff91d95bafb6e0d33338a8dfefbc88aa562a20c92/pyzmq-27.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c17e03cbc9312bee223864f1a2b13a99522e0dc9f7c5df0177cd45210ac286e6", size = 836266, upload-time = "2025-09-08T23:09:40.048Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ed/0202ca350f4f2b69faa95c6d931e3c05c3a397c184cacb84cb4f8f42f287/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f328d01128373cb6763823b2b4e7f73bdf767834268c565151eacb3b7a392f90", size = 800206, upload-time = "2025-09-08T23:09:41.902Z" },
+    { url = "https://files.pythonhosted.org/packages/47/42/1ff831fa87fe8f0a840ddb399054ca0009605d820e2b44ea43114f5459f4/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c1790386614232e1b3a40a958454bdd42c6d1811837b15ddbb052a032a43f62", size = 567747, upload-time = "2025-09-08T23:09:43.741Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/db/5c4d6807434751e3f21231bee98109aa57b9b9b55e058e450d0aef59b70f/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:448f9cb54eb0cee4732b46584f2710c8bc178b0e5371d9e4fc8125201e413a74", size = 747371, upload-time = "2025-09-08T23:09:45.575Z" },
+    { url = "https://files.pythonhosted.org/packages/26/af/78ce193dbf03567eb8c0dc30e3df2b9e56f12a670bf7eb20f9fb532c7e8a/pyzmq-27.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:05b12f2d32112bf8c95ef2e74ec4f1d4beb01f8b5e703b38537f8849f92cb9ba", size = 544862, upload-time = "2025-09-08T23:09:47.448Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" },
+    { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" },
+    { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "rpds-py", version = "2026.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu') or (extra == 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu-cu128') or (extra == 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
 [[package]]
 name = "requests"
 version = "2.33.0"
@@ -4385,6 +4850,280 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
 ]
 
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version < '3.11' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" },
+    { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" },
+    { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" },
+    { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" },
+    { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" },
+    { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" },
+    { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" },
+    { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" },
+    { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" },
+    { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" },
+    { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" },
+    { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" },
+    { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" },
+    { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" },
+    { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" },
+    { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" },
+    { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" },
+    { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" },
+    { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" },
+    { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" },
+    { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" },
+    { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" },
+    { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" },
+    { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" },
+    { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" },
+    { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" },
+    { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" },
+    { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" },
+    { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" },
+    { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" },
+    { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "2026.6.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra == 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and extra != 'extra-10-neural-lam-cpu' and extra == 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version >= '3.14' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.13.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.12.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+    "python_full_version == '3.11.*' and extra != 'extra-10-neural-lam-cpu' and extra != 'extra-10-neural-lam-gpu' and extra != 'extra-10-neural-lam-gpu-cu128'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/1f/a2dca5ffdbf1d475ffc4e80e4d5d720ff3a00f691795910116960ee12511/rpds_py-2026.6.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7b689145a1485c335569bd056464f3243a29af7ed3871c7be31ad624ba239bc7", size = 342174, upload-time = "2026-06-30T07:14:54.821Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/dc/323d08583c0832911768663d1944f0107fcd4088704858d84b5e06d105a0/rpds_py-2026.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:db08f45aecde626498fb3df07bcf6d2ec040af42e859a4f5040d79c200342911", size = 345513, upload-time = "2026-06-30T07:14:56.515Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/2a/e31989834d18d2f26ec1d2774c5b1eb3331df4ea8ada525175294c94b48a/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:acc992ab27b15f852c76755eb2ab7dce86585ddadba6fa5946e58556088845b4", size = 373783, upload-time = "2026-06-30T07:14:57.736Z" },
+    { url = "https://files.pythonhosted.org/packages/87/fe/e80107ee3639585c9941c17d6a42cd65325022f656c023191fce78c324c8/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f88d653e7b3b779d71ae7454e20dcc9b6bae903f33c269db9f2be41bda3f261", size = 378316, upload-time = "2026-06-30T07:14:59.077Z" },
+    { url = "https://files.pythonhosted.org/packages/22/6f/81e3adf81acfb6fa694de2a6e4e7d8863121e3e0799e0a7725e6cf5679c4/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e52655eaf81e32593abedaa4bfe33170c8cfedf3365ed9be6e11e07f148f0278", size = 499423, upload-time = "2026-06-30T07:15:00.488Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/9a/41263969df0ce3d9af2a96d5005a288200af1989aed3354bfceb5fc0b21f/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dfcc8b909769d19db55c7cc9541eb64b9b774b1057ffffb4f1048070475bb9f9", size = 386077, upload-time = "2026-06-30T07:15:01.911Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/19/7e98f468bd50346faff5b10e5297374b443bfdddacc8e9fbc65984539597/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c1255b302953c86a486b81d330d5ee1d5bd937691ce271b6be0ef0e299eaab7", size = 371315, upload-time = "2026-06-30T07:15:03.317Z" },
+    { url = "https://files.pythonhosted.org/packages/99/3c/2b973b4d371906a134b03decfea7f5d9835a2c6d263454392e15b64b5b18/rpds_py-2026.6.3-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:8d2294a31386bfa251d8c8a39472beee17db67d4f1a6eabea665d35c9a4461c3", size = 383502, upload-time = "2026-06-30T07:15:04.627Z" },
+    { url = "https://files.pythonhosted.org/packages/98/2a/12e2799500af0a307bca76b63361c51f9fe479223561489c29eea1f2ee41/rpds_py-2026.6.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8f23ead891a3b762f35ab3b04623da7056545b48aa60d59957e6789914545da", size = 402673, upload-time = "2026-06-30T07:15:05.856Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/e3/21e5872d165fe08be4f229e3d5ee9d90019c0bf0e5538de60dbd54009450/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:421aba32367055614287a4292b6a17f1939c9452299f7a0209c117e990b646d4", size = 549964, upload-time = "2026-06-30T07:15:07.159Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d0/5ee0fe36844297de8123bee27bc12078c1a7416ad9f1b8a8ca18d6b0c0ac/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1e5822dfc2f0d4ab7e745eaa6d85945069329beeccef965af3f3bb26058fcab6", size = 615446, upload-time = "2026-06-30T07:15:08.531Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/80/1ea5873cb683f2fbe5f21b23ea1f6d179ead19f3c5b249b7eb5dca568ef2/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:83e35b57523816c8613fd0776b40cd8bb9f596b37ddd2692eb4a6bb5ab2f8c93", size = 576975, upload-time = "2026-06-30T07:15:09.97Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e1/90ef639217a5ddb15b7f4f61b1c33911fd044ad03c311bafdd2bcab85582/rpds_py-2026.6.3-cp311-cp311-win32.whl", hash = "sha256:de3eceba0b683bcbb1ab93da016d0270df1f9ae7be716b40214c5dafac6ea45a", size = 204453, upload-time = "2026-06-30T07:15:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/b7/b7a1695d7af36f521fb11e80d6d3adbd744f73b921859bd3c2a2c0dc706f/rpds_py-2026.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:2c54a076ca4d370980ab57bc0e31df57bbe8d41340436a90ef8b1219a3cbb127", size = 223219, upload-time = "2026-06-30T07:15:12.476Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a2/145afacf796e4506062825941176ad9445c2dcf2b3b6a1f13d3030a15e19/rpds_py-2026.6.3-cp311-cp311-win_arm64.whl", hash = "sha256:168c733a7112e071bb7a66460e667edfcff06c017a3c523f7a8a8e08d0140804", size = 219137, upload-time = "2026-06-30T07:15:13.631Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" },
+    { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" },
+    { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" },
+    { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" },
+    { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" },
+    { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" },
+    { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" },
+    { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" },
+    { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" },
+    { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" },
+    { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" },
+    { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" },
+    { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" },
+    { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" },
+    { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" },
+    { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" },
+    { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" },
+    { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" },
+    { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" },
+    { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" },
+    { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" },
+    { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" },
+    { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" },
+    { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/9c/f0d19ac587fd0e4ab6b72cda355e9c5a6166b01ef7e064e437aef8eb9fef/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4cf2d36a2357e4d07bb5a4f98801265327b48256867816cfd2ceb001e9754a8f", size = 349791, upload-time = "2026-06-30T07:17:33.315Z" },
+    { url = "https://files.pythonhosted.org/packages/38/c7/1d49d204c9fd2ee6c537601dc4c1ba921e03363ca576bfab94a00254ac9a/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:30c6dc199b24a5e3e81d50da0f00858c5bbdb2617a750395687f4339c5818171", size = 352842, upload-time = "2026-06-30T07:17:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e5/c0b5dc93cd0d4c06ce1f438907649514e2ea077bcd911e3154a51e96c38e/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9891e594296ab9dada6551c8e7b387b2721f27a67eecd528412e8906247a7b90", size = 382094, upload-time = "2026-06-30T07:17:36.514Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/54/ec0e907b4ca8d541112db352409bd15f871c9b243e0c92c9b5a46ae96f01/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5c2dc92304aa48a4a60443b548bb12f12e119d4b72f314015e67b9e1be97fca", size = 388662, upload-time = "2026-06-30T07:17:38.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f4/921c22a4fd0f1c1ac13a3996ffbf0aa67951e2c8ad0d1d9574938a2932e8/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:127e08c0642d880cf32ca47ec2a4a77b901f7e2dd1ad9762adb13955d72ffcc9", size = 504896, upload-time = "2026-06-30T07:17:39.689Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1b/a114b972cefa1ab1cdb3c7bb177cd3844a12826c507c722d3a73516dbbaf/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8bb68f03f395eb793220b45c097bd4d8c32944393da0fad8b999efac0868fc8c", size = 391545, upload-time = "2026-06-30T07:17:41.336Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/98/af9b3db77d47fcbe6c8c1f36e2c2147ec70292819e99c325f871584a1c11/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3450b693fde92133e9f51060568a4c31fcca76d5e53bbd611e689ca446517e9", size = 380059, upload-time = "2026-06-30T07:17:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ba/0efd8668b97c1d26a61566386c636a7a7a09829e474fdf807caa15a2c844/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:5e8d07bddee435a2ff6f1920e18feff28d0bc4533e42f4bf6927fbd073312c41", size = 393235, upload-time = "2026-06-30T07:17:44.637Z" },
+    { url = "https://files.pythonhosted.org/packages/62/90/8c139ee9690f73b0829f32647de6f40d826f8f443af6fa72644f96351aac/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3a83ae6c67b7676b9878378547ca8e93ed77a580037bcbcd1d32f739e1e6089c", size = 413008, upload-time = "2026-06-30T07:17:46.225Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/97/0043896fdd7828ce09a1d9a8b06433714d0960fc4ff3fc4aa72b666b764e/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2bfd04c19ddbd6640de0b51894d764bd2758854d5b75bd102d2ef10cb9c293a9", size = 558118, upload-time = "2026-06-30T07:17:47.759Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/02355f0e134f783a8f9814c4680a1bd311d37671577a5964ea838573ff37/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:ca6546b66be9dc4738b1b043d5ebd5488c66c578c5ff0fd0e8065313fe3afb76", size = 623138, upload-time = "2026-06-30T07:17:49.355Z" },
+    { url = "https://files.pythonhosted.org/packages/10/85/48f0abdcef5cce4e034c7a5b0ceeceba0b01bf0d942824f4bb720afe2dec/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8e65860d238379ed982fd9ba690579b5e95af2f4840f99c772816dbe573cb826", size = 586486, upload-time = "2026-06-30T07:17:51.141Z" },
+]
+
 [[package]]
 name = "s3transfer"
 version = "0.16.0"
@@ -4981,6 +5720,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
 ]
 
+[[package]]
+name = "stack-data"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "asttokens" },
+    { name = "executing" },
+    { name = "pure-eval" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
+]
+
 [[package]]
 name = "starlette"
 version = "1.0.0"
@@ -5368,6 +6121,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c3/a2/c7f6ebf546f8f644edf0f999aa98ece106986a77a7b922316bf6414ff825/torchmetrics-1.9.0-py3-none-any.whl", hash = "sha256:bfdcbff3dd1d96b3374bb2496eb39f23c4b28b8a845b6a18c313688e0d2d9ca1", size = 983384, upload-time = "2026-03-09T17:41:19.756Z" },
 ]
 
+[[package]]
+name = "tornado"
+version = "6.5.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/24/95ec527ad67b76d59299e5465b3935d05e4294b7e0290a3924b7487df30b/tornado-6.5.7.tar.gz", hash = "sha256:66c513a76cda70d53907bc27cf1447557699c2e95aa48ba27a442ff61c3ddfc2", size = 519252, upload-time = "2026-06-08T17:34:51.232Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/dc/c7043cab6fed8ae159fc1923ce829ada35c4dbd797d408a43858ffaf9639/tornado-6.5.7-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:148b2eb15c2c765a50796172c1e499649b35f30d2e3c3d3e15913cfa56bfb163", size = 448543, upload-time = "2026-06-08T17:34:38.052Z" },
+    { url = "https://files.pythonhosted.org/packages/92/4f/090b1431e5a43df696feceffc268c5383cc079ecb5f08ce58f917109aafe/tornado-6.5.7-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9da38de27f1da3b78a966f0dae12b5a1ea9afe72ca805d84ff06508272ddf100", size = 446707, upload-time = "2026-06-08T17:34:39.594Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d8/ef374952fd5da67d4463122c2b8e5a96536ec10b4b339254c6dcde81d01c/tornado-6.5.7-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8d759e71906ee783f8867b93bf26a265743da4c1e2f4a018464c1ba019862972", size = 449774, upload-time = "2026-06-08T17:34:41.204Z" },
+    { url = "https://files.pythonhosted.org/packages/35/37/d434c73f4c6e014b745b9b37085f34f40c022f007efff3d7fe65991899f3/tornado-6.5.7-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a46347a18f23fb92b396beebe0fb78f61dda0cc302445202c16203d8a18848b", size = 450745, upload-time = "2026-06-08T17:34:42.531Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2b/56b9aff361d7f1ab728a805ec7d7ea835f8807afa9f5cc690ea0e630efb9/tornado-6.5.7-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7778b30bef919231265e91c69963ce0f49a1e9c07ac900bbe75b19ce2575ba92", size = 450578, upload-time = "2026-06-08T17:34:43.787Z" },
+    { url = "https://files.pythonhosted.org/packages/02/30/a7444fb23aa76860a14198fab96ac79f1866b0a6e19e26c4381b0938e50f/tornado-6.5.7-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e726f0c75da7726eec023aa62751ff8878bd2737e34fbdd33b1ae5897d2200f5", size = 449985, upload-time = "2026-06-08T17:34:45.326Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/42/5f0e56c01e8d9d36f4e23f367b85ae6cae0c1ecddd5e6977d8388ad27488/tornado-6.5.7-cp39-abi3-win32.whl", hash = "sha256:f8de3bf12d3efdd0cbe7c8887868198f8a91415e3f29fcf258d9b8eb7b1d9ae4", size = 451047, upload-time = "2026-06-08T17:34:46.784Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/a4/b393076ffb21b469eec5b328a0534cf03a3b90bfc6b1f09507cdd075d938/tornado-6.5.7-cp39-abi3-win_amd64.whl", hash = "sha256:de942f843533a039ef9fa3d9c88c7cd8a7c94553fb5ad0154270989b3d99a2c4", size = 451485, upload-time = "2026-06-08T17:34:48.248Z" },
+    { url = "https://files.pythonhosted.org/packages/71/2e/7b1c769803121b809112cf9a00681c472eae1d80e32d7ec0e0bd61d0d0e1/tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796", size = 450506, upload-time = "2026-06-08T17:34:49.702Z" },
+]
+
 [[package]]
 name = "tqdm"
 version = "4.67.3"
@@ -5380,6 +6150,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },
 ]
 
+[[package]]
+name = "traitlets"
+version = "5.15.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/a9/a2584b8313b89f94869ddb3c4074617a691de1812a614d2d50e32ca5a7a6/traitlets-5.15.1.tar.gz", hash = "sha256:7b1c07854fe25acb39e009bae49f11b79ff6cbb2f27999104e9110e7a6b53722", size = 163344, upload-time = "2026-06-03T12:26:06.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/8d/1080ee4c231f361b6ce4470d556c8c435b67c7e0753aaa641497ee92f88b/traitlets-5.15.1-py3-none-any.whl", hash = "sha256:770a53705f84b81ac107e83a1b3328ff2dae16094d8fc3cfc004e4b22dfd8e92", size = 85858, upload-time = "2026-06-03T12:26:04.395Z" },
+]
+
 [[package]]
 name = "triton"
 version = "3.6.0"