From 52cf5c689f6216eed8a196c33f7a307f73e90976 Mon Sep 17 00:00:00 2001 From: GiGiKoneti Date: Wed, 15 Jul 2026 17:11:07 +0530 Subject: [PATCH] Add DANRA tutorial notebook and notebook CI --- .github/workflows/install-and-test.yml | 17 +- .pre-commit-config.yaml | 6 + CHANGELOG.md | 2 + docs/notebooks/conftest.py | 23 + .../create_reduced_meps_dataset.ipynb | 42 +- docs/notebooks/hello_world_danra.ipynb | 1076 +++++++++++++++++ neural_lam/train_model.py | 37 +- pyproject.toml | 18 +- uv.lock | 779 ++++++++++++ 9 files changed, 1979 insertions(+), 21 deletions(-) create mode 100644 docs/notebooks/conftest.py create mode 100644 docs/notebooks/hello_world_danra.ipynb diff --git a/.github/workflows/install-and-test.yml b/.github/workflows/install-and-test.yml index 0ea43dc85..0a23e6c69 100644 --- a/.github/workflows/install-and-test.yml +++ b/.github/workflows/install-and-test.yml @@ -75,9 +75,24 @@ jobs: restore-keys: | ${{ runner.os }}-meps-reduced-example-data-v0.3.0 + - name: Run smoke test + if: matrix.package_manager != 'uv' + run: | + python -c "import neural_lam; print('neural-lam imported successfully')" + + - name: Run tests (excluding notebooks) + if: matrix.package_manager == 'uv' - name: Run tests run: | - pytest -vv -s --doctest-modules + pytest -vv -s --doctest-modules --ignore=docs/notebooks + + - name: Run notebook tests + if: | + matrix.package_manager == 'uv' && + (github.event_name == 'push' || + contains(github.event.pull_request.labels.*.name, 'run-notebooks')) + run: | + pytest -vv -s --nbmake --nbmake-timeout=600 docs/notebooks/ - name: Upload test figures uses: actions/upload-artifact@v4 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 659de97a2..997939a80 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 notebook CI via `nbmake` (runs on push to main or `run-notebooks` label) [\#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 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..840574b6a --- /dev/null +++ b/docs/notebooks/hello_world_danra.ipynb @@ -0,0 +1,1076 @@ +{ + "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\u20133.12) 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": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sharkyi/myenv/lib/python3.12/site-packages/torch/cuda/__init__.py:180: UserWarning: CUDA initialization: CUDA unknown error - this may be due to an incorrectly set up environment, e.g. changing env variable CUDA_VISIBLE_DEVICES after program start. Setting the available devices to be zero. (Triggered internally at /pytorch/c10/cuda/CUDAFunctions.cpp:119.)\n", + " return torch._C._cuda_getDeviceCount() > 0\n", + "/home/sharkyi/myenv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import glob\n", + "import os\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": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current directory: /home/sharkyi/Desktop/1/neural-lam/docs/notebooks\n", + "Repo contents: ['create_reduced_meps_dataset.ipynb', 'hello_world_danra.ipynb', '__pycache__', 'conftest.py']\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": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current working directory: /home/sharkyi/Desktop/1/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", + "You have two options for installation:\n", + "\n", + "**Option A (recommended): `uv`** \u2014 if you followed the README setup:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [ + "skip-execution" + ] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "bash: line 1: uv: command not found\n", + "bash: line 2: uv: command not found\n", + "bash: line 3: uv: command not found\n" + ] + }, + { + "ename": "CalledProcessError", + "evalue": "Command 'b'uv venv --no-project\\nuv pip install torch --index-url https://download.pytorch.org/whl/cpu\\nuv pip install .\\n'' returned non-zero exit status 127.", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mCalledProcessError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m get_ipython().run_cell_magic(\u001b[33m'bash'\u001b[39m, \u001b[33m''\u001b[39m, \u001b[33m'uv venv --no-project\\nuv pip install torch --index-url https://download.pytorch.org/whl/cpu\\nuv pip install .\\n'\u001b[39m)\n", + "\u001b[31mCalledProcessError\u001b[39m: Command 'b'uv venv --no-project\\nuv pip install torch --index-url https://download.pytorch.org/whl/cpu\\nuv pip install .\\n'' returned non-zero exit status 127." + ] + } + ], + "source": [ + "%%bash\n", + "uv venv --no-project\n", + "uv pip install torch --index-url https://download.pytorch.org/whl/cpu\n", + "uv pip install ." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Option B: `pip`** \u2014 run the cell below if you haven't installed yet:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "tags": [ + "skip-execution" + ] + }, + "outputs": [], + "source": [ + "# CPU-safe torch install (skip if you already have torch installed)\n", + "# sys.executable ensures we use the same Python as this notebook's kernel\n", + "!{sys.executable} -m pip install torch --index-url https://download.pytorch.org/whl/cpu --quiet\n", + "\n", + "# Install neural-lam and mllam-data-prep from the repo root\n", + "!{sys.executable} -m pip install -e . --quiet\n", + "!{sys.executable} -m pip install mllam-data-prep xarray matplotlib networkx --quiet\n", + "\n", + "# Note: Once released, `weather-model-graphs` can also be installed here.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "neural-lam version: 0.0.1.dev125+gcbc118aad.d20260425\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", + " \u251c\u2500\u2500 config.yaml \u2190 neural-lam configuration\n", + " \u2514\u2500\u2500 danra.datastore.yaml \u2190 mllam-data-prep datastore config\n", + "```\n", + "\n", + "This example uses a **cropped DANRA dataset** (~100\u00d7100 grid points, ~10 days in April 2022) served from a public ECMWF object store \u2014 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 `pip install --upgrade mllam-data-prep`.\\n\n", + ">\\n\n", + "> **Note:** This will download and process approximately 60\u2013120 MB of data. It may take a few minutes on the first run." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32m2026-04-25 12:35:48.860\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-04-25 12:35:48.872\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-04-25 12:35:52.083\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-04-25 12:35:52.085\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-04-25 12:35:52.094\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-04-25 12:35:54.093\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-04-25 12:35:54.093\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-04-25 12:35:54.101\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-04-25 12:35:56.125\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-04-25 12:35:56.126\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-04-25 12:35:56.134\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-04-25 12:35:58.167\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-04-25 12:35:58.168\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-04-25 12:35:58.175\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-04-25 12:36:00.057\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-04-25 12:36:00.059\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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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-04-25 12:36:01.684\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-04-25 12:36:01.689\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-04-25 12:36:01.690\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-04-25 12:36:01.721\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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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/sharkyi/myenv/lib/python3.12/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-04-25 12:36:08.400\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-04-25 12:36:08.400\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 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\n", + " lon (grid_index) float64 61kB dask.array\n", + " x (grid_index) float64 61kB dask.array\n", + " y (grid_index) float64 61kB dask.array\n", + " * time (time) datetime64[ns] 584B 2022-04-01 ......\n", + " ... ...\n", + " * static_feature (static_feature) \n", + " static_feature_long_name (static_feature) \n", + " static_feature_source_dataset (static_feature) \n", + " * split_name (split_name) \n", + " forcing (forcing_feature, time, grid_index) float64 4MB dask.array\n", + " static (static_feature, grid_index) float64 123kB dask.array\n", + " state__train__mean (state_feature) float64 32B dask.array\n", + " forcing__train__mean (forcing_feature) float64 8B dask.array\n", + " static__train__mean (static_feature) float64 16B dask.array\n", + " ... ...\n", + " static__train__std (static_feature) float64 16B dask.array\n", + " state__train__diff_mean (state_feature) float64 32B dask.array\n", + " forcing__train__diff_mean (forcing_feature) float64 8B dask.array\n", + " state__train__diff_std (state_feature) float64 32B dask.array\n", + " forcing__train__diff_std (forcing_feature) float64 8B dask.array\n", + " splits (split_name, split_part) 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) \n", + " forcing_feature_source_dataset (forcing_feature) \n", + " forcing_feature_units (forcing_feature) \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) \n", + " state_feature_units (state_feature) \n", + " * static_feature (static_feature) \n", + " static_feature_source_dataset (static_feature) \n", + " static_feature_units (static_feature) \n", + "Data variables: (12/14)\n", + " forcing (forcing_feature, time, grid_index) float64 4MB dask.array\n", + " forcing__train__diff_mean (forcing_feature) float64 8B dask.array\n", + " forcing__train__diff_std (forcing_feature) float64 8B dask.array\n", + " forcing__train__mean (forcing_feature) float64 8B dask.array\n", + " forcing__train__std (forcing_feature) float64 8B dask.array\n", + " splits (split_name, split_part) \n", + " ... ...\n", + " state__train__diff_std (state_feature) float64 32B dask.array\n", + " state__train__mean (state_feature) float64 32B dask.array\n", + " state__train__std (state_feature) float64 32B dask.array\n", + " static (static_feature, grid_index) float64 123kB dask.array\n", + " static__train__mean (static_feature) float64 16B dask.array\n", + " static__train__std (static_feature) float64 16B dask.array\n", + "Attributes:\n", + " schema_version: v0.5.0\n", + " dataset_version: v0.1.0\n", + " created_on: 2026-04-25T12:36:01\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": "iVBORw0KGgoAAAANSUhEUgAAAvAAAAJOCAYAAADRZjN/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAtHxJREFUeJzs3Xl8VNX9P/7XvbNlIwlLIFAQQa2KCygWDNIqysdYqS2/Ur9K1QZFqBS0GFqFloJLLVXqvlHrgnWplH4stWBRBKxa4obSCojWFgSBAArZk1nv7w8+GRnv+x3nkJkwE17PxyOP1pPDueeuc3Pm3Ne1HMdxQEREREREWcE+1B0gIiIiIqLk8QaeiIiIiCiL8AaeiIiIiCiL8AaeiIiIiCiL8AaeiIiIiCiL8AaeiIiIiCiL8AaeiIiIiCiL8AaeiIiIiCiL8AaeiIiIiCiL8AaeiChJ//73v3HuueeiqKgIlmVhyZIlWLhwISzLwpYtW4zbu+GGG2BZVlJ1LcvCDTfcYLwMIiLqfHgDT3SYeuuttzBt2jSccMIJyM/PxxFHHIH/9//+Hz788ENX3bPOOguWZcGyLNi2jcLCQhx77LG47LLLsGLFipT261e/+hWWLFly0P9+48aNuOGGGw7qhvrLVFRU4L333sMtt9yCJ554AqeddlrKl3Govfjii5g4cSJOPPFEeDweHHnkkWrdWCyG2267DQMGDEBOTg5OPvlk/OEPfxDrvv/++zjvvPNQUFCAbt264bLLLsOePXvStBYH5+mnn8Zdd92VdP32HquSmpoaTJ48GSUlJcjPz8eoUaPwzjvvpHQZRNQJOER0WBo3bpxTWlrqXH311c7vfvc75+abb3Z69erl5OfnO++9915C3TPPPNPp27ev88QTTzhPPPGEs2DBAucnP/mJM3DgQAeA8//+3/9zQqFQSvqVn5/vVFRUHPS/X7x4sQPAWb16dUr606qpqckB4Pz85z9PKI9EIk5zc7MTi8WM25w7d66T7GUYgDN37lzjZZiqqKhwcnJynBEjRjh9+/Z1+vfvr9adOXOmA8CZNGmS89BDDzljxoxxADh/+MMfEupt27bN6dGjh3PUUUc5d999t3PLLbc4Xbt2dQYPHuwEg8E0r1HyxowZ0+b6flF7j9UvikajzogRI5z8/HznhhtucO677z5n0KBBTpcuXZwPP/wwZcshouzHG3iiw9Q//vEP183Thx9+6AQCAeeSSy5JKD/zzDOdE044wdVGJBJxfvSjHzkAnOuuuy4l/crUG/iPP/7YAeDMnz8/ZW1m4g389u3b43+MtXVD+8knnzg+n8+ZOnVqvCwWizlf//rXnb59+zqRSCRePmXKFCc3N9f5+OOP42UrVqxwADi//e1v07MiB+FQ38AvWrTIAeAsXrw4XrZ7926nuLjYGT9+fMqWQ0TZjzfwRJTg1FNPdU499dSEMu0G3nH238QPGjTIycvLc2pqatps+8MPP3S++93vOr169XICgYDzla98xbnooovi/w6A66f1BmnLli3OlClTnK9+9atOTk6O061bN+d73/ues3nz5nj7jz32mNjGgTfzzz//vDNy5EgnLy/PKSgocM4//3xn/fr1bfa79Ub7wJ/WG73WZR7Yj2SXI93At7S0ONOnT3d69OjhFBQUOBdccIGzbds28Qb+/fffT7gp1lRUVIg3pl/2B0RbN7T333+/A8DZsGFDQvnTTz/tAHBeffXVeFnPnj2dCy+80NXGV7/6Veecc86J/3frtnz11Vedq6++2unRo4dTVFTkTJ482QkGg86+ffucyy67zCkuLnaKi4udn/70p0l987FkyRLn/PPPd3r37u34/X5n4MCBzk033ZTwR8aZZ56p7mNJW8fqwbrwwgudXr16OdFoNKF88uTJTl5entPS0tKu9omo8/CmZ2IOEWUjx3Gwa9cunHDCCUn/G4/Hg/Hjx+MXv/gFXnvtNYwZM0asFwqFUF5ejmAwiKuvvhqlpaXYvn07li5dipqaGhQVFeGJJ57AlVdeiWHDhmHy5MkAgKOOOgrA/jn7a9aswcUXX4y+fftiy5YtePDBB3HWWWdh48aNyMvLwze+8Q1cc801uOeee/Czn/0Mxx9/PADE//eJJ55ARUUFysvLceutt6KpqQkPPvggRo4ciXfffVed7/3d734XxcXFuPbaazF+/Hicf/75KCgoULfJwS4HAK688ko8+eST+P73v48RI0Zg1apV6jY9/vjjceaZZ+Lll19W20uXd999F/n5+fFt22rYsGHx348cORLbt2/H7t27xecFhg0bhueff95V3np83HjjjXj99dfx0EMPobi4GGvWrMERRxyBX/3qV3j++ecxf/58nHjiifjBD37QZl8XLlyIgoICVFZWoqCgAKtWrcKcOXNQV1eH+fPnAwB+/vOfo7a2Fp988gnuvPNOAPjSfawdq+FwGLW1tW32qVW3bt1g2/sfR3v33Xdx6qmnxv/7wO300EMP4cMPP8RJJ52UVLtE1Mkd6r8giChzPPHEEw4A55FHHkkob2sE3nEc589//rMDwLn77rvVOu+++65reoBEm5bQ1NTkKquqqnIAOL///e/jZdoUmvr6eqe4uNiZNGlSQnl1dbVTVFTkKv+izZs3i1NovjgCb7KcL46Ar1u3zgHg/OhHP0r4t9///vfFEXgAzplnntlmvx0nPSPwY8aMcQYOHOgqb2xsdAA4M2fOdBzHcd566y3XPmr105/+1AEQH1lu3Zbl5eUJI+tlZWWOZVnOVVddFS+LRCJO3759k1p/6dj54Q9/6BrVTtUUmtWrV4sj9NLPgd/c5OfnO1dccYWrvWXLljkAnOXLlyfdNyLq3DgCT0QAgE2bNmHq1KkoKytDRUWF0b9tHamsr69X6xQVFQEAXnjhBZx//vnIy8szWkZubm78/4fDYdTV1eHoo49GcXEx3nnnHVx22WVt/vsVK1agpqYG48ePx6effhov93g8GD58OFavXm3Un3Qsp3U0+pprrkkonz59Op5++mlXfcdxUtLng9Hc3IxAIOAqz8nJif/+wP/9sroH/n7ixIkJ8ZrDhw9HVVUVJk6cGC/zeDw47bTTsHbt2i/t64HHTn19PYLBIL7+9a/jt7/9LTZt2oTBgwd/aRsmBg8enHQ6U2lpafz/J7tNiYh4A09EqK6uxpgxY1BUVIQ//elP8Hg8Rv++oaEBANClSxe1zoABA1BZWYk77rgDTz31FL7+9a/j29/+Ni699NL4zX1bmpubMW/ePDz22GPYvn17ws1rMtMV/v3vfwMAzj77bPH3hYWFX9pGMtqznI8//hi2bcenYrQ69thjU9K3VMrNzUUwGHSVt7S0xH9/4P8mU7fVEUcckfDfrcdHv379XOX79u370r5u2LABs2fPxqpVq1BXV5fwu2Snupjo2rUrRo8ebfzvkt2mRES8gSc6zNXW1uKb3/wmampq8Oqrr6JPnz7Gbaxfvx4AcPTRR7dZ7/bbb8eECRPwl7/8BS+++CKuueYazJs3D6+//jr69u3b5r+9+uqr8dhjj2H69OkoKyuLv0zp4osvRiwW+9I+ttZ54oknEkY9W3m9qbkcdtRyTGgvi4pGowfdZu/evbF69Wo4jpPQ/s6dOwEgfhz17t07ofxAO3fuRLdu3VyjztofkFL5l30LUVNTgzPPPBOFhYW46aabcNRRRyEnJwfvvPMOrr/++qSOHVOhUAh79+5Nqm5JSUl8vXr37q1uJwAHdW4SUefEG3iiw1hLSwsuuOACfPjhh3jppZcwaNAg4zai0Siefvpp5OXlYeTIkV9a/6STTsJJJ52E2bNnY82aNTjjjDOwYMEC/PKXvwSg32z+6U9/QkVFBW6//faE/tfU1CTU0/5966h2z549D2p0NFntWU7//v0Ri8Xwn//8J2HU/YMPPmhXn7p27eraTsD+Ef+DNWTIEDz88MN4//33E46bN954I/57APjKV76CkpISvP3226423nzzzXi9dHn55Zfx2Wef4dlnn8U3vvGNePnmzZtddZN9K+6X1V+zZg1GjRqVVBubN2+OP9Q8ZMgQvPrqq4jFYgkPsr7xxhvIy8vDV7/6VaP+EVHnxTexEh2motEoLrroIlRVVWHx4sUoKys7qDauueYavP/++7jmmmvanB5SV1eHSCSSUHbSSSfBtu2EaQP5+fnizabH43GNtt57772uUeT8/HwAcLVRXl6OwsJC/OpXv0I4HHa1n6q3grZnOd/85jcBAPfcc09CufZ20E2bNmHr1q1f2qejjjoKtbW1+Ne//hUv27lzJ/785z9/6b/VfOc734HP58MDDzwQL3McBwsWLMBXvvIVjBgxIl4+btw4LF26FNu2bYuXrVy5Eh9++CEuvPDCg+5DMlpHtw88dkKhUEK/W+Xn5xtNqdGO1dY58Mn8HPgtzfe+9z3s2rULzz77bLzs008/xeLFi3HBBReI8+OJ6PDEEXiiw9SMGTPw3HPP4YILLsDevXvx5JNPJvz+0ksvTfjv2traeJ2mpiZ89NFHePbZZ/Gf//wHF198MW6++eY2l7dq1SpMmzYNF154Ib761a8iEongiSeegMfjwbhx4+L1hg4dipdeegl33HEH+vTpgwEDBmD48OH41re+hSeeeAJFRUUYNGgQqqqq8NJLL6F79+4JyxkyZAg8Hg9uvfVW1NbWIhAI4Oyzz0bPnj3x4IMP4rLLLsOpp56Kiy++GCUlJdi6dSuWLVuGM844A/fdd197NimA/XPcD3Y5Q4YMwfjx4/HAAw+gtrYWI0aMwMqVK/HRRx+J9ZONkbz44otx/fXX4//7//4/XHPNNfFYy69+9at45513Eur+61//wnPPPQcA+Oijj1BbWxv/dmTw4MG44IILAAB9+/bF9OnTMX/+fITDYXzta1/DkiVL8Oqrr+Kpp55KmO7ys5/9DIsXL8aoUaPw4x//GA0NDZg/fz5OOukkXH755Ult14M1YsQIdO3aFRUVFbjmmmtgWRaeeOIJcerN0KFDsWjRIlRWVuJrX/saCgoK4usr0Y7Vg50D/73vfQ+nn346Lr/8cmzcuBE9evTAAw88gGg0ihtvvNG4PSLqxA5dAA4RHUrSi2sO/GmrbkFBgXPMMcc4l156qfPiiy8mtbz//ve/zhVXXOEcddRR8RcxjRo1ynnppZcS6m3atMn5xje+4eTm5ia8HGffvn3O5ZdfHn/BUXl5ubNp0yanf//+rii/3/3ud87AgQMdj8fjipRcvXq1U15e7hQVFTk5OTnOUUcd5UyYMMF5++232+x/sjGSJsuRYhybm5uda665xunevbuTn5/f5ouckGSMpOM4zosvvuiceOKJjt/vd4499ljnySefFJevvQzrwH3RKhqNOr/61a+c/v37O36/3znhhBOcJ598Ulz++vXrnXPPPdfJy8tziouLnUsuucSprq4Wl/3WW28llLf2c8+ePQnlFRUVTn5+/peu+z/+8Q/n9NNPd3Jzc50+ffo41113nfPCCy+4jo2Ghgbn+9//vlNcXPylL3JyHP1YbY+9e/c6EydOdLp37+7k5eU5Z555pmt7EBFZjnMIc8iIiIiIiMgI58ATEREREWUR3sATEREREWUR3sATEREREWUR3sATEREREWUR3sATEREREWUR3sATEREREWURvsgpg8ViMezYsQNdunQxfsU3ERERUbIcx0F9fT369OkD2z6047stLS0IhUJpXYbf70dOTk5al5FOvIHPYDt27EC/fv0OdTeIiIjoMLFt2zb07dv3kC2/paUF3XML0IRoWpdTWlqKzZs3Z+1NPG/gM1iXLl0AAFuqXkBhQX683PH6k27DikXkX8RiYrHUtuMNyG3YHrHYsYS/3G3lUFPKHaFtx+MT60aEmWChqPx+Mq08JhRr7ziTtxwQFepHlcpaP8LCfgkrdSUBrzxqEvDK3+DkeNz1831yGzlK255Ii6vMCjWKde1Qk1zeXOsqi+6tFutGqj92lTV9sl2sW/ORXL7vv5+5yuo/aRDr1n4m97ku4v5wCSn7OywdYFCOGWV3S20HlfO4WT2+3OUhw3f55djuY6nYJ18LuvrlY8YvtKHxCFU9yjeSUt8AIN/r7p9H6ZveEXd9b8DsI9SWVkZhCXWlMgBwlP0dFQ6aaFi+KXKU8pYW5TNEWp5yKEnHuXpOqG0nf64YbGaVXzjGpOslYHY8S+uxv9ysfjo0x6KYuu8/8XuPQyUUCqEJUVyCr8CfppneIcTwVPV2hEIh3sBT6rVOmyksyEdhl4J4ecffwCsHt8kNvMf0Bt5dbnIDHzwUN/BCI5EMv4HPFeprN/BSXQDwRNzHjBWU69ohpdzr/tiOBvPEupE89/HoyZH/yIz65WMm7HUfXzGPfDyHleM8LN5YilXhsbSbFeGmRG4CttSGsryYsjxLKje8QQhINzbSOQ8g15K3nXRzpDG5gc9VbqTyhH3oMZwiYAn1vcoxo2n/DbzcZ0e5KkWFNrRBhZhy4Nl28seHyU1oSDj222zD4FxJyQ28cCzlKsdMZ7mBb5UpU3ZzYcOvXFvay9PxmzXl+BArEREREVEW4Qg8EREREWUUj2Wp37a1u21YUL4EyhocgSciIiIiyiIcgSciIiKijGJbqXmeQWwbyPoReN7AZwHH6094uNTxyA+xqg+sdjDLcT8l5QhlbZEeWJUeVgXkB0L1h0STP2O1Z4e0h4qkttUHxrQHuAw2ky18tehVHqbS0hOkB1MDyhXTEwuL5VbUndVrRYJiXbulXiyPfrrDVRbe+qFYt37zNlfZvg/dZQCw9997xfK6T9z9qK2X+7xXiZYJGRxLGvnrYbldk4c5tYAV6djVPiD1NBz3L1rUlB25DZN1Sfbfp4r2oKiUWqMl2WhtSA+xepQEHy1xxqSulE4TUVJlQg3K+a2si7w8+VwJB92Pm6oPdqsPeaZnp2vLyxXWW3tY1aM84C/WVcq1JCFJLAUPtkqfH5bZxzQdYryBJyIiIqKMkvY58FmOc+CJiIiIiLIIR+CJiIiIKKN40jgH3uwNDpmJI/BERERERFmEI/BERERElFE4B75tneoG/oYbbsCNN96YUHbsscdi06ZNAICWlhbMmDEDzzzzDILBIMrLy/HAAw+gV69e8fpbt27FlClTsHr1ahQUFKCiogLz5s2D94BXr7/88suorKzEhg0b0K9fP8yePRsTJkxIWO7999+P+fPno7q6GoMHD8a9996LYcOGHdyKWfb+n9b/1NJmpPQX7TXEWrKAyWuLlWQZxxYOK6lMqwvAEV59HgrLywsKT+9raTPaw/vSU/3ac/5a21IAg5pko7Rhki7g9wqvtBfKAMCvfA8phSpI6QQAgIicUmE317rKrNpqsW74k4/E8paP/+Mq05Jlaj5yt13zcZ1Yt2FHg1i+L+Q+hxoi8rZPRdqMpr1pLKZMkjxMXu2ubaOGiHzO5nrc57eWnCNtD+1rdZNX2mu0RBfLdndQTazxaSk07nJbWXGP372NbGX9tH5oqTAmtKQdiZZwI7arHGBaGks41r510ROR5G3qE/a3ti1sYV9pTNJm9Dbav1+lPnujnJSRTTrd3jrhhBOwc+fO+M9rr70W/921116Lv/71r1i8eDH+/ve/Y8eOHfjud78b/300GsWYMWMQCoWwZs0aPP7441i4cCHmzJkTr7N582aMGTMGo0aNwrp16zB9+nRceeWVeOGFF+J1Fi1ahMrKSsydOxfvvPMOBg8ejPLycuzevbtjNgIRERFRFmudA5+un2zX6W7gvV4vSktL4z89evQAANTW1uKRRx7BHXfcgbPPPhtDhw7FY489hjVr1uD1118HALz44ovYuHEjnnzySQwZMgTf/OY3cfPNN+P+++9HKLQ/63rBggUYMGAAbr/9dhx//PGYNm0avve97+HOO++M9+GOO+7ApEmTcPnll2PQoEFYsGAB8vLy8Oijj3b8BiEiIiKitNuyZQsmTpyIAQMGIDc3F0cddRTmzp0bv4dMpU53A//vf/8bffr0wcCBA3HJJZdg69atAIC1a9ciHA5j9OjR8brHHXccjjjiCFRVVQEAqqqqcNJJJyVMqSkvL0ddXR02bNgQr3NgG611WtsIhUJYu3ZtQh3btjF69Oh4HU0wGERdXV3CDxEREdHhpnUOfLp+0mHTpk2IxWL47W9/iw0bNuDOO+/EggUL8LOf/Szly+pUc+CHDx+OhQsX4thjj8XOnTtx44034utf/zrWr1+P6upq+P1+FBcXJ/ybXr16obp6/5za6urqhJv31t+3/q6tOnV1dWhubsa+ffsQjUbFOq1z8TXz5s1zzeEnIiIiosx33nnn4bzzzov/98CBA/HBBx/gwQcfxG9+85uULqtT3cB/85vfjP//k08+GcOHD0f//v3xxz/+Ebm5uYewZ8mZNWsWKisr4/9dV1eHfv36HcIeEREREXU8C+mbJtKRU+Bra2vRrVu3lLfbqW7gv6i4uBhf/epX8dFHH+F//ud/EAqFUFNTkzAKv2vXLpSWlgIASktL8eabbya0sWvXrvjvWv+3tezAOoWFhcjNzYXH44HH4xHrtLahCQQCCAQC7l/EIvt/DoZJqkzrsr7YhFLV8Qp9BQDh6X2V8jWWlNIipc0AQEgoN0lzAeSEAiltA9CTZSQxJcvGJEQg4JW3p88gcUMLUpEe5PEG5albnn2fiOWRzetdZS2bPxTr1n60XSyv2+p+wLvuk3qxbv1Od7JMfW1QXl44KpaHhO2v7W9NKh6CMvkaV1qeQUDI/xGSNSzlGFW2h8m2a1GSQxoiUrKMvDK5wopr2y2dCT621A+DtBlATrjR6kqJM95c+SPbJIUmqqR5aekoHl/yCStaP6QEH01UOWc9IblcEhPWRVs/LXVISgHSUmhM1g++5KtqHINEHq1v0rqED8MUmi9OVVbvww7SRx99hHvvvTflo+9AJ5wDf6CGhgb85z//Qe/evTF06FD4fD6sXLky/vsPPvgAW7duRVlZGQCgrKwM7733XkJazIoVK1BYWIhBgwbF6xzYRmud1jb8fj+GDh2aUCcWi2HlypXxOkRERESk64g58P369UNRUVH8Z968eWJfZs6cCcuy2vz54jTp7du347zzzsOFF16ISZMmpXz7dKoR+J/85Ce44IIL0L9/f+zYsQNz586Fx+PB+PHjUVRUhIkTJ6KyshLdunVDYWEhrr76apSVleH0008HAJx77rkYNGgQLrvsMtx2222orq7G7NmzMXXq1PhfZFdddRXuu+8+XHfddbjiiiuwatUq/PGPf8SyZcvi/aisrERFRQVOO+00DBs2DHfddRcaGxtx+eWXH5LtQkRERESJtm3bhsLCwvh/a6PvM2bMcL3v54sGDhwY//87duzAqFGjMGLECDz00EMp6esXdaob+E8++QTjx4/HZ599hpKSEowcORKvv/46SkpKAAB33nknbNvGuHHjEl7k1Mrj8WDp0qWYMmUKysrKkJ+fj4qKCtx0003xOgMGDMCyZctw7bXX4u6770bfvn3x8MMPo7y8PF7noosuwp49ezBnzhxUV1djyJAhWL58uevBViIiIiJyS2dee+sEqcLCwoQbeE1JSUn8XvLLbN++HaNGjYrHldsmU6wMWI5jOPGTOkxdXR2Kiorw2cbXUdil4OAaMZ0DL71dVXtbqjIH3vH6291G2Ha3US9NvkXmzIGX5pmr84iVt35K/dbmwEtvV9XeuBpQ5qbm+9z18yLy20sP1znw+hsc5XITJnO2pbed6vPUtTnpyb9F1bRtSYFy7HYV5lUXKfPJc4VjV3vjqlYuvV3Y9K2avhz3NcyXL09oNpkDL821BuT59amYAx+sk/OoI80H+ZzVAcLKm1hN2tbmwMc6yxz4FEjXHPjGaBQXvLcWtbW1Sd3Upkvrvc/c3IHIMb2HSVKLE8ONzf9N+bpu374dZ511Fvr374/HH38cngPeOv1lz0Ga6lQj8ERERESU/faPwKdnCD75R7PNrFixAh999BE++ugj9O3bN+F3qR4v79QPsRIRERERdYQJEybAcRzxJ9U4Ap8FrGgEVvTzryAdj7LbpGkq2tdPBxtLmdCG/JWmFXZPZ3CUrx5jyhSaZmGOgzRVBgDCwlf6WsKiFt9oEiGozSCQ2pDiMNviM4jMM2k61yu3kd/knrri/GetWLf+Pbl834fbXGUN2z8T6zbsahTLmz9tdpfta5HbCLqP3Wbl2NCmv5gwmSpjOlpk0rY0PUSf3qM17D4BtFGcmBIg67dNpuHIbTdE3P3Q+iwtz3Q7S1PTLKVz2vbQplqY1JXK9brunmhTZaSISwCISbGhylSlWAoiBH3KLYXWP0k0JPcjahBnKU0xkabVAHrfzOIzk9+H6SRNmdKmaHmFKWGRSAruC1KoI+bAZzOOwBMRERERZRGOwBMRERFRRjkwrz3lbXfou1jTgyPwRERERERZhCPwRERERJRR7DTOge8Mo9edYR2IiIiIiA4bHIHPRiYvRVJTaJQXghik01hR+YUgUv9iHuHlTgAalJczNYXd5VLaDCC/WCmcgpcwaUk2GpOUKCltRqMl5EipJMUB+dn6wtrNYnnojb+5yna/+Z5Yt+ajarFcejFMqEE+NsKNYbkfQnlIeaGLyUu3UiEVczC13W2WcOMuizpyA1oqjPRSJI/V/m1n+hKs9rahtWvy8qlcpa7Jy5K0FzZppPq2cqGRXrSjJaZY2guspLpKn7W0EhMmL7DSaOkvUb/7eqAly0hpLNqLnLQXd2lpPe1lesy0e3lKApz0YrJQOLPmhXMOfNs4Ak9ERERElEU4Ak9EREREGYU58G3jCDwRERERURbhCDwRERERZRSOwLeNI/BERERERFmEI/BZwPH64Xg/T3FxlEQXx5fjLlPqWqEmuVxKodHSZpSEm5gv11XW4nGXAUBDs5x6E5HDaURS8oQSwqGSQhy0NkwSTzxKOoTWRFhISvB75TZ65rlP3+I9G8W69auXiOU7XvuXu+7OBrFuNCSnwkjpDo6y8aJasozQtmnSSCZITdqMkkoiptCYLU8KfTId4ZL6Z9qG1O9UbDstfadZSCXREnxy1OPc3UZMKAMA22BsTEuFkcrVtBmljRjc/ZPSbUxJ22J/R5SUHIOdqKfFuPsdU1LMtP0i0dJ3UtFnkzZSkeAj0VJ9pOPAm2F3hEyhaRtH4ImIiIiIskiG/b1FRERERIc7D9I4Bz5zv8hNGkfgiYiIiIiyCEfgiYiIiCij2GmcA2+nqd2OxBF4IiIiIqIswhH4LOD48+D48z//b6+SQuN1p9BoxLQZAFawUSiU/1KN5XUVyyP5PVxltUrajJYaIdGCBaRUEu2vdiUkQUycMU07kZaptRFUYnZ8woS/PgU+sW7xLneCzN7nF4t1d1a9L5Y3fdrsKtNSD7S0hnBD2FUW0fa3UBcAmoXkD+3YkMr1xBq5vKOZJMuY1NUo4RxGSTYav3ASSWVtlZuMqkkjZdoxmqOsjMl21lJhJNGwvKG1FCYpSSWdpGQTb478sW95lHURLrxO1Gz0UrpyxLQDT77cySlAfrkNKRWmvWkuqWJr50QK0nCM2hX64c2wieFpzYHPjMOhXTgCT0RERESURTgCT0REREQZJa058JwDT0REREREHYkj8ERERESUUTgHvm0cgSciIiIiyiIcgSciIiKijMI58G3jDXwWcLw5cHwHRERayhcnjjtmy4q0iFWtkBAXCTleMpZbJNaNFpSI5fta3JGAwYgcT6VFQ0rpizG0P+JKS62U4h5tKDFzynkfERpvCMlxij5b3odf6eKOCO26812x7p4lz7jKdr7xoVg3WBcSy00iyqS4SABo3uc+xsKN8vJCYfexAcjRkCYRoxpt9aQEu1TEN2p1tXIpZjEV/dDIyX1mDecKHdGOZ2+u/BGjRRlKbGF52nGrRUDmaxcagzakfmhRiFq5FG8oxSOq5T65bybnsccjxwpKkZMAEJNiJJVzU19vdxumX/9bfvcxI23PTCLtF+348ij71oS0D03OFa98aFCG4g08EREREWUU27LS9sZUvomViIiIiIg6FEfgiYiIiCijWB5LfGNsStrmCDwREREREXUkjsATERERUUaxPRbsNI3Ad4Y58LyBz0ZC2gwAWFF38ofdUi/XDQflpn0BV1ksr6tYty4k96Mp7C4PKWkBUvqLRjvfpLQYrV1tcVLyhxIWgLCSwLCv2Z3S4lMSAPoVudNmAKB7tTtxZtf/Pi3WrX7j366yUKOcFKMlHMSEdQnWyseGlmQjJc5ElWNDS5YxOQ5SITXJMlKCjFxXSpvRyrUUGpMPHI/V/u2spuF43ceSxy/HV3j8SuKGUK4l00ht+/N9Yl0t9UaiJZhoSSpRIUEpGpJTlUzSUaRzUKOlv2hsn8H28GifK+7jQFs/j7xbxG2nbWeNSUqLyXYy6YeURNQWafqHdq5o6TRmy3O3oaULScvzpOlm+aB5bHGdUkK5RmYTTqEhIiIiIsoiHIEnIiIiooxi2ZbROw6M2jZ8/0Um4gg8EREREVEW4Qg8EREREWUU22MZP3eQdNscgSciIiIioo7EEfhs4MQSk2cs5anyULO7LNwit2nLT8JHc92JM02ePLFuXbOcwNASdacZRJVUAJNkDS1AI6yk8ki0p+ylB/W15JxPm+Q0Fim1Y2DXHLFuyc53xPKdi550l73xkVg33BJxlfmUJA8t6UJKnAkrSTZSkgQgpziEY/I+0QIfTAIpTNJfNKlIY5ETZOQ2tBQan5CwoM35lEaitOQKRzgHAcBW0oEkWj+kFA01bcanpdNIbch1pcSZHOW88uW7U7QAOYkjpmyjaIt8/Evnm7adtZQWKbVGOzelNrTEFG15do6QSuJXrhEh9/oBQBRSefLHEQB4Pe5lagk+empKx46YmiQJaX0Tk16UZCBtv5gwSWyxPMI5mGHRipadvhQaq4OTz9KBI/BERERERFmEI/BERERElFE4B75tHIEnIiIiIsoiHIEnIiIiooxieZgD3xaOwBMRERERZRGOwBMRERFRRtk/Ap+mFBrDJKVMxBv4LKRFQ9ot9e66UTnyMJrfXSwP5bnL9zbJ8WJNYfkEiAnxTCZxkVobYYNYrxyfEmun9KMl4l6XXQ3ytvMpX+kd2yPXVdZjyz/Eutuf+YNYXv3ux64yLW5Nit2LKvskpKxLRIjGM42qiwrbziQWEjCPgWwvOYrSrBNSNKQWF6kd/1L8ovaBpUU1SmLR5GPt1MhJJdZRiyo1acMStpP2Vbk31708LS7Sly/HS9p+dxSltt6xXDlG0m5UInkFWtvS+aad36kg7W/b594WpmJ2+29+0nVjBpjFKaoMNpMWfSlFQ2rbX9sedppiFCUeJf6XMhNv4ImIiIgoozCFpm2cA09ERERElEU4Ak9EREREGcWyLHG6XUrajnEEnoiIiIiIOhBH4ImIiIgoo9geW31AuN1tO9k/ft2pbuDnzZuHZ599Fps2bUJubi5GjBiBW2+9Fccee2y8zllnnYW///3vCf/uhz/8IRYsWBD/761bt2LKlClYvXo1CgoKUFFRgXnz5sHr/Xxzvfzyy6isrMSGDRvQr18/zJ49GxMmTEho9/7778f8+fNRXV2NwYMH495778WwYcOM18uKtMAKf/7kut1UI1cUyp28YrFqtLBULN8jJM40hJJPmwEAj/CVl1IVQSHBBADCwtPwWpJHns+ddKE9oFIXlBN1Pm1yJ0/kKUk2g3vli+WFm15ylW19+hmx7q5/bhfLJVLaDCCnwpikzWhtOEoSgZaWEdV2rkBLaTFJrZHqmj7nZJI4o7UtJtl4lSQJpREppUWrKyVraHU9SoKGlDCk7W+vkjYjHY9acpFG+lBOxQe15ZHPFSnJw5MnJ9Zo28OT406+ibYEDXoH+PKFxKaQfG7Gwu5yLQnKkyPvcNvn3odqypFHTvaRUlNiYTmpx4SW1KOVS9KZZGOyPC31Rko/8gj7pK22pX2oMdl2EvnsoUyV/X+CHODvf/87pk6ditdffx0rVqxAOBzGueeei8bGxoR6kyZNws6dO+M/t912W/x30WgUY8aMQSgUwpo1a/D4449j4cKFmDNnTrzO5s2bMWbMGIwaNQrr1q3D9OnTceWVV+KFF16I11m0aBEqKysxd+5cvPPOOxg8eDDKy8uxe/fu9G8IIiIioizW+ibWdP1ku041Ar98+fKE/164cCF69uyJtWvX4hvf+Ea8PC8vD6Wl8gj0iy++iI0bN+Kll15Cr169MGTIENx88824/vrrccMNN8Dv92PBggUYMGAAbr/9dgDA8ccfj9deew133nknysvLAQB33HEHJk2ahMsvvxwAsGDBAixbtgyPPvooZs6cmY7VJyIiIqLDQKcagf+i2tpaAEC3bt0Syp966in06NEDJ554ImbNmoWmpqb476qqqnDSSSehV69e8bLy8nLU1dVhw4YN8TqjR49OaLO8vBxVVVUAgFAohLVr1ybUsW0bo0ePjteRBINB1NXVJfwQERERHW44At+2TjUCf6BYLIbp06fjjDPOwIknnhgv//73v4/+/fujT58++Ne//oXrr78eH3zwAZ599lkAQHV1dcLNO4D4f1dXV7dZp66uDs3Nzdi3bx+i0ahYZ9OmTWqf582bhxtvvPHgV5qIiIiIOr1OewM/depUrF+/Hq+99lpC+eTJk+P//6STTkLv3r1xzjnn4D//+Q+OOuqoju5mglmzZqGysjL+33V1dejXr98h7BERERFRx2MKTds65Q38tGnTsHTpUrzyyivo27dvm3WHDx8OAPjoo49w1FFHobS0FG+++WZCnV27dgFAfN58aWlpvOzAOoWFhcjNzYXH44HH4xHraHPvASAQCCAQcCcB2E21sD0HJIC01MsN5Ba6iiLdjxSr7mqW0wzqhcQZk7QZAIjG3PWbwnKCSVhJVQgIaR5S2ozWv0+b5DSWfc1yekKPPL+r7NTectqM//XFYvmWxc+5yvZslB9a1r6+8wnJH9GwnCwgJc5odU1EldQhjU9K+FCOGT2xpn2pMKlIodFSjrR9JSXAqCkVBm14lONcakNNrlCWJ6bQKMkVWgqNN9ddHmlWUo6Ea4HG5CttLSnGicrXGRiksfjy5XQaKQ0koqSPRIUEGQCwctz1vfJlRtwv2vpp6TvSOkqJPFpdAIAQcOMoySgxZb+IdUPytdjxGKTQKOtiQjuWpLa17awly9h+d7mWKuPNcX8G7V+m1A95veVjRjlXhPX2Zv+sksNK9v8JcgDHcTBt2jT8+c9/xqpVqzBgwIAv/Tfr1q0DAPTu3RsAUFZWhvfeey8hLWbFihUoLCzEoEGD4nVWrlyZ0M6KFStQVlYGAPD7/Rg6dGhCnVgshpUrV8brEBEREZEinfPfOQc+s0ydOhVPP/00/vKXv6BLly7xOetFRUXIzc3Ff/7zHzz99NM4//zz0b17d/zrX//Ctddei2984xs4+eSTAQDnnnsuBg0ahMsuuwy33XYbqqurMXv2bEydOjU+On7VVVfhvvvuw3XXXYcrrrgCq1atwh//+EcsW7Ys3pfKykpUVFTgtNNOw7Bhw3DXXXehsbExnkpDRERERHQwOtUN/IMPPghg/8uaDvTYY49hwoQJ8Pv9eOmll+I30/369cO4ceMwe/bseF2Px4OlS5diypQpKCsrQ35+PioqKnDTTTfF6wwYMADLli3Dtddei7vvvht9+/bFww8/HI+QBICLLroIe/bswZw5c1BdXY0hQ4Zg+fLlrgdbiYiIiCiRbVmwlam6qWg723WqG3jnS94I2a9fP9dbWCX9+/fH888/32ads846C++++26bdaZNm4Zp06Z96fKIiIiIiJLVqW7giYiIiCj7WR5bf7i6vW3Hsv8R0OxfAyIiIiKiwwhH4LOAFW6CFfp8vpYjxEUCQKTHQFfZjma5zdqgHHMm0eaKtSiRhVpkpESKiwSAHKFca/fTJnccWUNIXr8ji3PF8lO6u+PBYi/9Tqz73z+/JJbXfFzrKpMi9wA9KjDS4u63FBcJyBF9anyg8rd6VNhOWpyfxy/3WYwpU6IotRhJORpSiV40mLtoEk2obTuTaEhtv2ptJ9uu1g+PT4uRVPpsCzFzhvtbK5fElOPA9kvrkvzyUhEfqNH2txTzp0X06ceMEOuoxAqajDyqUYFSrKBBbGKq+hETYjW1uhopwjEVfTNZnklcJCDvWy0u0qOV+4UcT4W0jjElelQ6DjxIPva1I9gey+jaadR2LPvnwHMEnoiIiIgoi3AEnoiIiIgySjyzPR1tcwSeiIiIiIg6EkfgiYiIiCijMIWmbdm/BkREREREhxGOwGeBWG4RYnkF8f+OdHenzQDAJw3uJ/0bQvIT6NoD+dIfu1r6SzCS/FP9eUrChEZKlvm0SU5jkVJJTu7VRax7jPWZWN68+DFX2ccvvi3X3dcilucUBlxl2vy9UKN7/QAg0uzeh1qiCIRNGtPSKJTjQH7CX95XUShpBkKxtt5+IdlB70fyTJJiNGoKjZLOIdU3SZAx74e7XE2b0ZJlhO3vRJVkICVtRnwzolZX6Z+UnmOS2OTRUj+UxA5p+5uO7ElJI35PnljXNPEkWaZ9ltJftGuEnlxkkPSiJNxImWAeLbFG6YfdzuQhbY+YbFOtrpogI6TQaIk13lz35wdgmLgkHP62sk+kY9STWSE0sD3t/2xQ207PKdqhOAJPRERERJRFOAJPRERERBnFsi3xm8dUtZ3tOAJPRERERJRFeANPRERERBnFtm3YnjT9pPFtzq2CwSCGDBkCy7Kwbt26lLfPG3giIiIiohS67rrr0KdPn7S1zznwWSBa1AfRwsL4f+9olJ7pB2pb5JQQE1LiTFhJqZDSXwDAJzw13qIk1mjJMlJ6TtdcOWFiaO8CV1mvT9+Tl7fkD2L5rrX/dpVFleSWgp75YrmU7tCiJNZobUvpIVqiiJgeohwCWqKISd+0hAkpgcRSjpl0vVUvUxJkpHSV/ctLU5axljZjsL9TQUymAQCl3FfgTu3w58vnt1dI+LCFdI/9/dBSedzlpkkxHp+7f54ucvqIdsxEW9zXu0hLUKwbC7mv81qfTdJRTI+MVKTQmLRhCck5qeAxPAelbaodd1LaDCAnzkjHUZttB+R0GokTc1+7tX0ip9BkVgxNWt/EmqZ2W/3tb3/Diy++iP/93//F3/72t7QsgzfwRERERHTYqaurS/jvQCCAgMEfTZJdu3Zh0qRJWLJkCfLy5KjZVOAUGiIiIiLKKK1vYk3XDwD069cPRUVF8Z958+a1q8+O42DChAm46qqrcNppp6ViM6g4Ak9EREREh51t27ah8IApytro+8yZM3Hrrbe22db777+PF198EfX19Zg1a1ZK+ynhDTwRERERZRTLts3eRGvYNgAUFhYm3MBrZsyYgQkTJrRZZ+DAgVi1ahWqqqpcfwicdtppuOSSS/D4448fdJ+/iDfwRERERESKkpISlJSUfGm9e+65B7/85S/j/71jxw6Ul5dj0aJFGD58eEr7xBt4IiIiIsoorZnt6Wo7HY444oiE/y4o2J+Sd9RRR6Fv374pXRZv4LNAXdQLJ/r5rmoWoh4BIGYQARVWoqWkyEgtLlI7/vc1h11lnza5y9pyTHf3k9tDSuS5adabS1xlO1a/LNat37pLLPd3yXGVeYQIMAAIN8rRkMF97oi4cIsciaZdPCy/e1trsY4S0/hAKYoypkRAenxy2x45FU2ktS1RoyHFCEizi7HUtrZ+JnFjprGO8vY3izc06Yca92jUthCvZ7CvADluU43RE6IQvTnytUCK7dPa1o4Zk6hGb16uWBde+aSwPE1JL88k5tJke2hTEkziBk1FDaZBaNdXNcY2Sdp6e3OVKFChvnbMqMeu330cmLZhBdyfTaqo+7PCisifvY7trmunKcKT0oM38ERERESUWQ5Ii0lH2x3hyCOPhJOmfH3GSBIRERERZRGOwBMRERFRRrHs9I3ApyvdpiNl/xoQERERER1GOAJPRERERBmlI3Lgsxlv4LNAc9SBN/L5QxAxJP9AREtEfnJfS6yREme0xJpPm+Qn1ve1uJ96LwrIh9opvbuI5UeEq11lob/9Raz72bvvu8rCjc1i3fzS7mK59DVdsKZerBusC4rlESFxRksf0RJPxMQHg2QZLWUkFpP3d6RZ6LOQEALoSSNGyTJauZQsY5CYoqb6GKTCpCK5RU2YSMG2iyrpU+LylD5L/TNJXQEAj99drh3n2j6U9pe+D91ta2kz/i7u9Cqtvmm6irg9bGW9fXKyiS1cS735cj9MEmS07SEmqSh91kSD7uud6bbTElYkkRZ3mlcqmKa/SMk+WhsmbattaPtFKLeUlCNIn9XC+QMACLs/py1v+xOHqOPwBp6IiIiIMorlscU/4FPTdvIDIpkq+79DICIiIiI6jHAEnoiIiIgyipXGHPi05ct3oOxfAyIiIiKiwwhH4ImIiIgoo9i2DTtNaTHparcj8QY+C7REYvAekCajvZU3KvxCS5vRNAlJF1KqDAAElYSbI4pyXWWnlOaLdbvufFcsb3x9hausfususa4nx534ECguEOtGw3JyTvPufa6yUJ2cZKMJFLr74SgpI1r6iPS1nj83+eQDLR1CSpsBzNJYtHXRyiVa21K5lkpi0q6W9iMlqaSC6deylrC/tO1pe9yXa5MUm/1tuLdTTPkiVk+ncffDly+nrphEtZlsO9M0Fl+++5qkrV80JF/vUkLot5aCIiaYeOXtLLULyAk+WnKOxiPUj4VajNoQ2w3LSSpe4XoO6NfuZOkpR8mXq/vKJAVI2YeWT94eUuKM5c+R6wplTkg7v4WHODvBTe3hhDfwRERERJRROAe+bbyBJyIiIqKMwhv4tmX/GhARERERHUY4Ak9EREREGcWybKPnaEzbznbZvwZERERERIcRjsBngXDMQTj2edqESbKMlEwDAE1hOYGhTkic0YIujumeJ5ZLiTO+D14R6zZvfFMsD9U1uspyuxfJHZH+fb373wNAy2d1YnmwpiHptgOFAbFcSg8Jt8jJCdpfzh6f+zdSUozp8rQ2TJJsosoxExPqa4kP0vpp/ZASU/bXdZdr8xm15aWLSXIOAESF1CctWUbaLx5lG5l1QklKiiV/ndGSQ7xC+gsAxISkFycmH1/iv1cSSdTkHGEUT0qvAvSkEbEfShqLyVFgaakwQrmWVKImy0htKAkmJqxISCzX9otR28o5ZMfal1Kkps1oiUbCcaAdM+o+lOpqaTM5clKbuL+05cWkZBnt2i8lkJklFKUb58C3LfvXgIiIiIjoMMIReCIiIiLKKByBb1v2rwERERER0WGEI/BERERElFFsj238XJFJ29ku+9eAiIiIiOgwwhF4IiIiIsoolm2lLwfeTkGC1yHGG/gs4LEseKwDDjaD41mLi9zX7I5x278sd9lJvQrEuscXy5FTnvdfdpWFP35frKvFb+WWdHOVRZqaxbqN1Z+5ypp37xPrhhvl2DfpgRbLOFHLva39+XJkmBZV5/Enf0pGQ+7INluJi4wo+1uKhow0K1GUSj+8Oe4+axGQWv+kuEftK06pDe0ibxJNqEUQasRjRouk09ZFiN3T9pWTgshIOaJSXm8ppnR/uRBnmSNHqwaK5WuH1EaovinpulElrjDSIscb5gjb31PUXayrHeexevc1Jaz02RbOTUCOIdRjJIVjRosE9Crxkl5heVpdhSNFUQrtAoClnG9RYb9EhSjRtphEQ0rXV1uJSFTjJaXzW1lvcV8BgMH1R9svlk9Ypna9Ezapur+F2EorykkZ2YQ38ERERESUUZhC07bsXwMiIiIiosMIR+CJiIiIKKNwBL5t2b8GRERERESHEY7AExEREVFGsSw7fSk0VvaPX/MGPs3uv/9+zJ8/H9XV1Rg8eDDuvfdeDBs2zKgNn23Bd0DkUUhJlqltcScf1LXIT/r7lESLE3q6UyO+2kXul3fzm2J5eNdWV5nlz1EakZ/qdxrrXGXBmnp5eXXuJIiYklKhpYFIW1RLMNHSSqTkA1++vN62X04GkNp2olGxrpb8IbHsRvkXjUF33zxmKRXy8uTjy6Ok0HildA5lX0nbyPTrUHEfKqttklKhsX1y4x5h31q2nJQUVc5lE5YtpQ7JdaMh+bgLNbr7oR2jOcXyxUPadloCU0g4v7VzMKakv0jsgmK5PF/uc1RI8wjXbxHrtnxWK5ZLKTT+QncaCAB4pPQQLbFGS4UxaSMiJ/iIN1DK8YyQfOxGmt3XmUiTXDem7FvpGqGnebn7p57HKbhBFJNiACAmnBfa9tcI+9DWPk+FYkfqAyAm5Hj8cqoSZabs/xMkgy1atAiVlZWYO3cu3nnnHQwePBjl5eXYvXv3oe4aERERUcayPB7YafqxlFjRbMIb+DS64447MGnSJFx++eUYNGgQFixYgLy8PDz66KOHumtERERElKU4hSZNQqEQ1q5di1mzZsXLbNvG6NGjUVVVJf6bYDCIYPDzrxrr6tzTSIiIiIg6O6bQtC371yBDffrpp4hGo+jVq1dCea9evVBdXS3+m3nz5qGoqCj+069fv47oKhERERFlEd7AZ5BZs2ahtrY2/rNt27ZD3SUiIiKiDtc6Ap+un2zHKTRp0qNHD3g8HuzatSuhfNeuXSgtLRX/TSAQQCDgThYJxxyEY078vz9tktMo9gkpFV7lID2hxJ02AwBHF7ifTPduXSfWjXwqf5OgJs4InIYasTzc4E5NUdNfhPQKLaEl2uJOQ9j/C7ltiZSGAADe/Fx3P5SUBJWQiGApy5MSGLT0HW29paQd01QGLa1Hom07aX9pySYxuNdRuxhr6S9a22IbSmKQbbCdpPQRQN52avpRCvYVhGuErSRSaaR0Gq3P2np7CwuTriuVhxvlBBMTVkC+Tnm6yddn6boWaJHTnUJ1cnnznhpXWbRFTn/J7eku8yppJ+pxYJJ4YpBwox0xdlBJlhGuS82fmU0RjeW5t7+/ME/uh/CAommalJhwoya6KOUG2187h2whhcbKlZOLJJbWN2lZTvbf1B5OuLfSxO/3Y+jQoVi5cmW8LBaLYeXKlSgrKzuEPSMiIiLKbJZtp/Un23EEPo0qKytRUVGB0047DcOGDcNdd92FxsZGXH755Ye6a0RERESUpXgDn0YXXXQR9uzZgzlz5qC6uhpDhgzB8uXLXQ+2EhEREdHnmELTNt7Ap9m0adMwbdq0Q90NIiIiIuokeANPRERERBnFsq30jcDbZg/vZ6Ls/w6BiIiIiOgwwhH4LNAYisI6ILqtVoiCA4A8nzuy6qvd5ZitAbly3KB3+wZXWXTfbrGupUT0Ae7yWH2NWNNpluPWJFJcJCDHfZn+1e7NdUelaRGEWhSiCZPoMq2uGKspHxpqrKa0PJNYSMAsytAS4t0AOW4zpq230D/TfSVtu5iy3nr0ZfLHgUmcaCwkn5tSn02P86hw7YhFHaEmYCnxkh5/8tF46nEuxOBZSkSiJ9d9DYuF5LhCLWrWk++OzbWEeD4AcDxKVGOx+9kl71fkfuQr17Xwh+53e7QocYrScd5FiBkGAOR1EYu1qEyREjcoteGE5QuNpZ5Dta4yLYY13NQslkvnkLa/o0r/xL4J8ZSAEoesRbwqsbSWQYykdh0V20hFPKjEm/x26wjpTIvpDCk02b8GRERERESHEY7AExEREVFGsWyP0bcYpm1nO47AExERERFlEY7AExEREVFmsT1mc/hN285yHIEnIiIiIsoiHIHPAs3hGOzw50+5F+XI6QlHFrufmj/CpzzRv+MDsVxMnFH+UtXmkMUa3akKToucyhCLyE+9iykhSjpHLCyXS/xd3OkXgJxwIyW0AG0kaxgkgpg8Aa+lwkSFbaT12a+UR1tCrrJIS1CsqyXI+PKTT7rQUiOkbaptIS29Qqyrpb8Ip5A2HiMlFAFyCo22X21l28WE9Aqvsj21lByxbkhJCRGSZWwlbcaXI2+7QJE7CUU7rzxKaoqU8GHlyG0gz72NPIajZ1KSiuVV0mZiynXGn+vuR/c+Yl1fS5NYnl/vLq/fukusG6pz1w3V1ot1c4q6i+W2kLSjrbcJR0kB0pJsAj17CFXluiFhGwHydUY77qTrmpZMo31+eHOFYyzgPgbaIl4PtM9TIZkJUI5dkwQVj5IWZ7nbsHzyPjlkbHv/T7raznLZvwZERERERIcRjsATERERUUaxPB71m99UtJ3tOAJPRERERJRFOAJPRERERJmFKTRt4gg8EREREVEW4Qh8Fsj12cjzff7XYs98+any3naDq8xT/W+xbqz2M7HcElILoKRfSGkzABBrqHGXNcspNJFGOc0gVOeuH1bqSskmvjw5yUNKmwHkBBktwcSbIydrSOkhWmKNlJIAAOFGd2qQltwiiRnU1agpO9r2UFJaJFElScikHxKTdBsA8EoJMsbr7T4OtHQIrW0pAUM7NqS6WjKTo8zvlPrhU64ngUL5OA90dadl5HQvlJeXr5QLiRtqOoqwTdW3KErXLwCWT2hba0NJobGExCzHlo8NT9cSsTzQ5yuuMumcB4Bgjft6rtUNKGleEinVpC1OWD4eTdjCcZDbW66b20s5l6VjRkgzAoCYkKbWuENIWAMQrJGTfaRzxaOl/eTkieUQjmlt7rWdp5wr0joajB5rx6jUhqMl1hwqtp3GEfjsH7/O/jUgIiIiIjqMcASeiIiIiDKKZdtmmfeGbWe77F8DIiIiIqLDCEfgiYiIiCizWGlMobGYQkNERERERB2II/BERERElFmYA98m3sBngd4FfnTp8nkcVQnk2Cvv3q2uslhQjh3T4reciDsyTIuAjDXJ/XCE+iaxiQAQEeo7SpylR4gE9ChxkdqDK1K8pC8/V6zrK3DHmQFyzJmuRiyV4hC1iMSYEG8YaZKjNrX4RikqzascGx4lTlGL5hSXZ/DgkLa/Y2KsoNyudhzIx4wcoabFSErrbSsxhhoxqk7oGwDYwjmhxkhGo2K5tA+1/ar1I1DcJakyQI/Xs3OESEDDeEOREkVp+eRITCOOQUSrcnMgxRDm95HjeKVjQz1/YvL+TgkpPjOkRPoaxFnaXbqK5WKUMZQIR6VuVNhO/gb5c0yKLAaAcF2Tq8xWro1QjnPpmNbWz/IZXDu0/W1yU+o4yZVRxuINPBERERFlFKbQtC3714CIiIiI6DDCEXgiIiIiyiycA98mjsATEREREWURjsATERERUWax7TSOwGf/+DVv4LNAD7sFhfbnT6h7anbJFYWUBDu/UK6qpQgI5Vpdk+QDLVFEI6ZzeJR0DqGulhyiJst0cacIaEk9lk/uh3ihUbaRmoYj9NvKkevGwu4EEqlsfzfk7W+y7bRyb27yCR9OjtyPaMidXqGti8lFS0tSkRJntPXT2tCODxPSntW2p5QwFG2Rjw3Lo6SgCOtiK+k7fuGcAIBAcYGrzFsoX2e0ZCapXN2ewjlkknaistr/AW4pyTRaloe0jraUrgIgx2Ad1WuVyc2Pcq1ypO2vpByphH5offZ0KZabkLaTrVwNhM+bgPI5Zvvkz1MpOS3a7E6mAQArVy73SMe5bXbdMPnslPa30TFqkrREhxxv4ImIiIgoo1gejzoYkYq2s132f4dARERERHQY4Qg8EREREWUW207fXPVOMAc++9eAiIiIiOgwwht4IiIiIsosrTnw6fpJo2XLlmH48OHIzc1F165dMXbs2JQvg1NosoDd+ClsW0mCOYDjcyesWFElyUBLHIi4n7w3JaUWaNRkE6ldJUlFSqzxF8rpFz6DtAwtKcYoUUe5SFheJVHH725b64e03j6DbaS1LSW0AG0kuuQKaSXatlOSICwhYSWmPGQUVdZF7JtPXhfpuPPmyQlFVkBJjZD2ocGxD8hJECYJRWpCjsk2Utrw5cvrHejaxd23Ll3Funaecr4F3MeMo6RMSckYarqK4fY3IqTWaGkz+nnvPh7VNJZ893bW2rW15Bap3KukRsXk1CfxSFKugTFt+wvl2nmlJRc5XqG+co2wC7u5yrxa35Rrsaf2M3cftM9H7fM0LHz+GoZXidcD7fiXkpW0ZJkUpDCR7H//938xadIk/OpXv8LZZ5+NSCSC9evXp3w5vIEnIiIiooxi2R6zKFTDttMhEongxz/+MebPn4+JEyfGywcNGpTyZfFPMCIiIiKidnrnnXewfft22LaNU045Bb1798Y3v/nNtIzA8waeiIiIiDKLZX+eRJPqn/+bQlRXV5fwEwwG29Xl//73vwCAG264AbNnz8bSpUvRtWtXnHXWWdi7d2+7N8mBeANPRERERIedfv36oaioKP4zb948sd7MmTNhWVabP5s2bULs/54P+fnPf45x48Zh6NCheOyxx2BZFhYvXpzSvnMOPBERERFllI6YA79t2zYUHhBuEQjID3nPmDEDEyZMaLPNgQMHYufOnQAS57wHAgEMHDgQW7dubWevE/EGPhtYdsIT445PeXo/LCR8ROSvg5ygkmojpQsoT947zY1ieURKFAnJCQcakxQNb477hPPmKdtISSUxedLfJAFDS6zR+mHylZjUZ7+QcgEAXiVRROyD0oaWDqGlaEi0/B7pQhS1k09EikXlFAgtYcVbUOAqU9dP2R4yua4TkdOgpNd5234lmUk4zrUUp1hYPt+kJCdtG2lJTlI6inYMaMe5Ywv9tiyxrnhWaAkaKfhO2TFJ51DqWj4l6UVIXtGOO1tKNtFSaHKU5BYhmczxy2lLGktIf7ENb6qk9CnTGzNLSMlxlGNGSjSyi7qLdb1KP6LCMe001bXVRTfxM0G+Vqnbw+M+h8TzZ38j7jIthUZaXpqjFY3Zdvr69H+fn4WFhQk38JqSkhKUlJR8ab2hQ4ciEAjggw8+wMiRIwEA4XAYW7ZsQf/+/dvX5y/gDTwRERERUTsVFhbiqquuwty5c9GvXz/0798f8+fPBwBceOGFKV0Wb+CJiIiIKLO0PnCarrbTZP78+fB6vbjsssvQ3NyM4cOHY9WqVejaVX5fxsHiDTwRERERUQr4fD785je/wW9+85u0Loc38ERERESUUSyPR3xOKFVtZzvGSBIRERERZRGOwBMRERFRZrE9aUyhyf4ReN7AZwHH64fj/TyWzAo3i/WsqDuqTorvAvQoKyfobjvWWC/WDTcoMZLN7XuTGSBH5mnRklIMnkm0oUaND1ROfHFbK/GB8MrRfbbUb4MLjRZX6FGiQOVOKPGZWrykQcyirUTmSUFn2lpL0Zy2cinz5smReVJ0n+n+FqNHDUnnoXgMAPAJSWdSLCQARFuU6FehvhYx6i0sEsstIbJQ+zraUeI9bSHaznGS355ajJ4UNbj/F+62jeIiTWnxksK+tfPcsZwA4EjHoxJLq3Yj6j4OHCgxkso2dbzuZVq5cuyeFi8pfa6YckLuNiw7+c8a00hfjxA7GdNiUbVYZmF7qHGRWrl0LCnXKjVeUlyeu67jNzu+6NDiDTwRERERZRaOwLeJc+CJiIiIiLIIR+CJiIiIKKNYtp2SqYpa29ku+9eAiIiIiOgwwhF4IiIiIsosVhrnwFvZPwe+09zAb9myBTfffDNWrVqF6upq9OnTB5deeil+/vOfw+/3x+sMGDDA9W+rqqpw+umnx/978eLF+MUvfoEtW7bgmGOOwa233orzzz8//nvHcTB37lz87ne/Q01NDc444ww8+OCDOOaYY+J19u7di6uvvhp//etfYds2xo0bh7vvvhsFBQXmK+c4+3/i/608KS6Va6kASlqJlKQS05JslAQMEx6//DS9lIyhpXOIKQJKyov6tZlQX0oqaYuYQqNsfzsnTyy3AkpChLQ8IeHD0tKFtDQcIZ1GS2tQSUkLPnn7q4ku0jK1RB0hdcjWEnKUfSilgRh/pWrywWIrCRgGCT4e4TjXUl4sT5NYLp2znlzlWBTSZgAl4UnbdtqxJKXFaKkwUrlS1yiFQ2Fp11eTPpssTztXBE6Lsl+163mLOynM8srXUcdvsC7acestFoutHHfSjpoYpJRL19do/b6k62os7bNCWMdUpJuplGu3uD0iSsqRcJ1xPMo5IbWr7RPKSJ1mCs2mTZsQi8Xw29/+Fhs2bMCdd96JBQsW4Gc/+5mr7ksvvYSdO3fGf4YOHRr/3Zo1azB+/HhMnDgR7777LsaOHYuxY8di/fr18Tq33XYb7rnnHixYsABvvPEG8vPzUV5ejpaWzy8al1xyCTZs2IAVK1Zg6dKleOWVVzB58uT0bgQiIiKizsCy9v+RnJYf61CvXbt1mhH48847D+edd178vwcOHIgPPvgADz74IH7zm98k1O3evTtKS0vFdu6++26cd955+OlPfwoAuPnmm7FixQrcd999WLBgARzHwV133YXZs2fjO9/5DgDg97//PXr16oUlS5bg4osvxvvvv4/ly5fjrbfewmmnnQYAuPfee3H++efjN7/5Dfr06ZOOTUBEREREh4FOMwIvqa2tRbdu3Vzl3/72t9GzZ0+MHDkSzz33XMLvqqqqMHr06ISy8vJyVFVVAQA2b96M6urqhDpFRUUYPnx4vE5VVRWKi4vjN+8AMHr0aNi2jTfeeEPtbzAYRF1dXcIPERER0WEnbaPvdkqmvx1q2b8Gio8++gj33nsvfvjDH8bLCgoKcPvtt2Px4sVYtmwZRo4cibFjxybcxFdXV6NXr14JbfXq1QvV1dXx37eWtVWnZ8+eCb/3er3o1q1bvI5k3rx5KCoqiv/069fvINaciIiIiDqzjL+BnzlzJizLavNn06ZNCf9m+/btOO+883DhhRdi0qRJ8fIePXqgsrISw4cPx9e+9jX8+te/xqWXXor58+d39GqJZs2ahdra2vjPtm3bDnWXiIiIiDqcY9lp/cl2GT8HfsaMGZgwYUKbdQYOHBj//zt27MCoUaMwYsQIPPTQQ1/a/vDhw7FixYr4f5eWlmLXrl0JdXbt2hWfM9/6v7t27ULv3r0T6gwZMiReZ/fu3QltRCIR7N27V517DwCBQACBQMBVbsWi+hP7CRXdB6QTdqeMAIATVJJltLSSdrI9cmKHlCgCyCktWkKLmBZgkO6xf4EmiSJKkoqQ2mEJKS+AWTqKnuQhpNBoqUNaOk2zO6VCS3/RtqkVSEEyg9Q/NcFH2N/asaElF0mpKWl8tbaacCMmuiSfHGXZ8n41+Wgy3nYm+9sgFclSEmQcqdDww1dNlpGo6SjCungMrzPJtgvo573AUa4z0nXezpXrIqocd8J+cTzyddvRtofj3otWVLk2auVSs7WfiXVjQrmaTKOk0NgFxe4yw2QyaR/GhGQgAIDSP/HzTbtWGX2OCedQg9I3ykgZfwNfUlKCkpKSpOpu374do0aNwtChQ/HYY4/BTiIWbt26dQk34mVlZVi5ciWmT58eL1uxYgXKysoAAAMGDEBpaSlWrlwZv2Gvq6vDG2+8gSlTpsTbqKmpwdq1a+MJN6tWrUIsFsPw4cOTWhciIiKiw1Y656pzBD5zbN++HWeddRb69++P3/zmN9izZ0/8d62j3o8//jj8fj9OOeUUAMCzzz6LRx99FA8//HC87o9//GOceeaZuP322zFmzBg888wzePvtt+Oj+ZZlYfr06fjlL3+JY445BgMGDMAvfvEL9OnTB2PHjgUAHH/88TjvvPMwadIkLFiwAOFwGNOmTcPFF1/MBBoiIiIiapdOcwO/YsUKfPTRR/joo4/Qt2/fhN85B3x9d/PNN+Pjjz+G1+vFcccdh0WLFuF73/te/PcjRozA008/jdmzZ+NnP/sZjjnmGCxZsgQnnnhivM51112HxsZGTJ48GTU1NRg5ciSWL1+OnJzPv1p+6qmnMG3aNJxzzjnxFzndc889adwCRERERJ2EZaUvr70T5MBbjiNMTqOMUFdXh6KiInz2wTso7HLAG1yVOYJ2qNlVFqvfK9aN7tsjlsfq3HMHo/U1Yt1IozxnLxpyz2/V5sBLb1wFAE+++421HT0HXp3rq81Rlp4rSOMceGleeyrmwGvPQaRiDrz27EWsoSbputLczUyfA6/Ocxaob9WUyrX9qjz7ItG2nZ3nfnvm/vrJ729be5trfqG7zC/3Q3zYTPv6W5nrnjFz4KPufajNzXbCBnWV64y0/e1ieUqqo21/6dkE7XmFdM6BD7qvVZE928W6sX27XWXpnAOvbX/x2q1N7dWererAOfB1DY3oPvK7qK2tRWGh+xztKK33Pnvfey3x3ieVy6hvQLeTRh7ydW2PTjMCT0RERESdhG3rf/Ckou0sl/1rQERERER0GOEIfBZwLCvha2R15pbw1a/6taH6lV/yX/VrpOkyWlykJ9cdFwnIX1Vq0yGkr0Atn+FX29JXncrUFUv5yhXS1AJl6pD+danQtjJSYDKDz9Km4Qhfz6pTaAy+nlVj7bTjUZoOpOxDMa5Tm6qhbH9xikkKjn11vyrTVJyosEw1PlDYL4bLk6YOqdOMtGle0lQqg2lewP5o3KSJU2i0o99gao3JtBqN1oY2xUfaX8r1RDzftFHDkFwubX+nuV5entJnJyDESHrdcccA4PiUa7S0nSLK9UTbdsK54ulSLC9OmH6nTk0LuqeeAoC4Z7XjVrs2SvUNrzOO9Pmmfa6YEI6lWGNT+9tNoXTmtXeGHPjsXwMiIiIiosMIR+CJiIiIKLMwB75N2b8GRERERESHEY7AExEREVFm4Qh8m7J/DYiIiIiIDiMcgc8GX/gr1IrKLxpxWoSX8qgv/lCeyBee9BdfegM9WUasG5BTC9SXwkhP3ivJGkjFi5wMaCk0Yi6Gljig9E98UYhBwoGjJpjIrIiQQiO8QKZNUj+0F1hp+0VKQtFesJLvfsGQ9sIgTUw4L9QXRynEJAjDbGHxmNHaENNfDJNzDM4rW019Sv7c0tIypOQb7SVAjsf9MaW+mElLwxFG2/Q22p9GJL78CJBH/XzKdU3658p7F23l5UfiC9Kk5CMAlvYCq1Sk9QjrraaAaNtOeNGUVdRTrOrLdV8jYjXFYt3IZ9ViucnnqS28mAzQk5zkRpS0MeFcMXmpobo9Bd76hqTrdgiOwLcp+9eAiIiIiOgwwhF4IiIiIsooX3wHTqrbznYcgSciIiIiyiIcgSciIiKizMI58G3K/jUgIiIiIjqMcAQ+C1jRMKwDUgascLNYL9osPDWvJGtoT9NDSaeRaMkyYiqMT0luUZIu5Kfplaf0tZQWsV2lH0IajpqYoi1P+ote+Stfm9cnlispEJblTo2wkt8U+5uW2tXqaukVPvd2spVtFFPKpbQG9dgwSGXQeIT97fjNUmgkjpJgoqZBhd3pIVpClBFtO0vnpmHajJy+k3zaDAA4QvKKo5yb4r9Xyi2kIDHF4HqiJnwobTg+4bgzSazRrgVKgozlEbap0kbMJ1/PHV+e3D+xESXJxoS27Sx3/xyv8hnkL3AVWQE5EcanJMhEP9updNDNzpPbsLsUu8ocaZ8A+noL50VMa0NIcpJSnDQRuz7puh3Csvb/pKvtLMcReCIiIiKiLMIReCIiIiLKLJwD36bsXwMiIiIiosMIR+CJiIiIKKM4lp3GHPjsH7/O/jUgIiIiIjqMcASeiIiIiDKLZavpcylpO8vxBj4LWKFmWKHPI6acFndcJCBH1amRdErcnRRlpcUpatGQUht2jhJFpsU6CtGERvFuCrFdAFaOO3bMESK52iRcaEy/prOiUgybEjmpRahJlP1t2e7jw1EjCJV9JR0fXvm4s7UoUCGa0MqRY9/EGDZlO2vxemLUqRZ5GFOiCSPuCEhosa1yC/J+0aIoDeIlLb+yD6W4VOXcVM9vqX/aualEJIrRdlqcohR7qEQhmnzYq1GUqYhC1EjHqRYfqG0PqS60OEXhHFJiBdV4Q6HP6jaKCucEAEjnkLKvHCsFtyXC8aFdz21lvT1C7KQW4QzlWhzzS3GpSmyryXGgRUO296bU4JijQ497i4iIiIgyC1No2mR0A19TU4M///nPePXVV/Hxxx+jqakJJSUlOOWUU1BeXo4RI0akq59ERERERIQkH2LdsWMHrrzySvTu3Ru//OUv0dzcjCFDhuCcc85B3759sXr1avzP//wPBg0ahEWLFqW7z0RERETUmbWOwKfrJ8slNQJ/yimnoKKiAmvXrsWgQYPEOs3NzViyZAnuuusubNu2DT/5yU9S2lEiIiIiIkryBn7jxo3o3r17m3Vyc3Mxfvx4jB8/Hp999llKOkdEREREhyHOgW9TUjfwX3bz3t761DYrEoQV+XxXxbSkC6lcSsoA1CferVz3E/mWluygppUICR/5hXITSvKHxNGSVIR0FCltA5DTZgA5LQBaKoOSwGCSXmEZpGioSTZSudKu5SiZG0Iyg6Wl7xhc8LQgCe1Ycnzu7S/uE0BOSlDW29H2lZT2o2wjS0nWEGuHlaQYNaXFXa6m3mjJUQbLk88VeTtr6VNG/VBI219LXZHKLeVY1PY3LPc2VY9FrQmTNBztWhURksK05A9hX0nnCQDElHNWOqRjynGupvJIXVNSVw78nEooN7g2miR3qddRqVxpNqama7nXUU2h0a4/wmeImh6mJcu0NxlG20aU9Q7qyNixYwdee+017N69G7EvfNhcc801KekYERERER2eHMtK45tYpT9Ns4vxDfzChQvxwx/+EH6/H927d4d1wEawLIs38EREREREaWR8A/+LX/wCc+bMwaxZs9SXshARERERHTTOgW+T8Ro0NTXh4osv5s07EREREdEhYHwXPnHiRCxevDgdfSEiIiIiAiwrvT9ZzngKzbx58/Ctb30Ly5cvx0knnQSfL/Hp9zvuuCNlnaP9nGAjnAM2cywkp9CIyQfKE/Zq+ouWlmFCaENLtNDSYsS6WrmwLmpag09OAHC8Qj+0bZGCr97U5Il2N6wkDnjkdXEsJRHBaJlCfoW2jXxKP3zCPtTSGky2v5aY4hFSMbSkDGXbSekQ6jeTSnlM6J8V0ZJshDa0tBnl/JbK1ZQpbTt7kk8/UhOb5Noy4dgwPgeF+urDcX4lDcfouEs+dcUkwaQxJu/vpmDyy/N65K3vs+Vyr1BuKzc/tnbOKv1uLyeNCSti+pGSFCOmWkE5ZpQ2pP29v3GD466dN6WON9iuf08d66Bu4F944QUce+yxAOB6iJWIiIiIqF04B75Nxjfwt99+Ox599FFMmDAhDd0hIiIiIqK2GN/ABwIBnHHGGenoCxERERERHMtOYw589o/AG6/Bj3/8Y9x7773p6AsREREREX0J4xH4N998E6tWrcLSpUtxwgknuB5iffbZZ1PWOSIiIiI6DHEOfJuMb+CLi4vx3e9+Nx19ISIiIiKiL2F8A//YY4+lox/UBicchhNWouUOYOXmu8tSEQuZAmo/tBi8QJ7UiFjX8bgjKqVYwv115aguqQ2NpfVDWhfTv/KlWDQlCtGS6mrr194+AHokoFhfiYtU4jPF/WKw7bT5jFoTUvyclqGlty2soxKjZ8uppnK7SvSrEwkl34YWI+kTjnPTuNRURPdF3HF1lha9KMSUOkosrdH5ph6LctviNUVbnnauhJqT6hoAWFH3/vYoMbiacMy97bS0OJ9JSqYUHQvAUqIoxWu0clFKRZid1rbJ8iypEe1ciSqfz9K5oh0zaYotNpnrnbZ444PkWBacNKUbpqvdjpRZe4uIiIiIDnuOY/bHmGnb2S6pP83OO+88vP76619ar76+Hrfeeivuv//+dneMiIiIiIjckhqBv/DCCzFu3DgUFRXhggsuwGmnnYY+ffogJycH+/btw8aNG/Haa6/h+eefx5gxYzB//vx095uIiIiIOqmY46jTtVLRdrZL6gZ+4sSJuPTSS7F48WIsWrQIDz30EGprawHsn083aNAglJeX46233sLxxx+f1g4TERERER3Okp4DHwgEcOmll+LSSy8FANTW1qK5uRndu3d3RUkSERERER0sB4YBDIZtZ7uDfoi1qKgIRUVFqewLJcnOcafN7P+F+5EGy9PxKTRO1J2aovXDyikQy2N+IbZDS40Qyh0lDQRKwodR4omWwmGSFqC1IZUrdcULUMwsIURMkFFSb7TtLyZuaIkiGnG9k08JsLSkHiHJAwCscItQV0mS0NZF204CR9kvVsB9nEtlAAAhhUY614A2znvp+NdSlbTjOQX5yZYlbFNl+4v7UFm/lPTZJH3HcHnSdUlL35GO0VylXY/ymdAcERJ8DKcOiPUNEzzERBelDZPuRZXKQviOSgnOgUfon22a0mJwjVCPmY5MhukE2eiHE6bQEBEREVFGiTlmf4yZtp3t+OcWEREREVEW4Qg8EREREWUUx3GMp3yZtJ3tOAJPRERERJRFjG/gKyoq8Morr6SjL0RERERE8Tnw6frJdsZTaGprazF69Gj0798fl19+OSoqKvCVr3wlHX0zduSRR+Ljjz9OKJs3bx5mzpwZ/+9//etfmDp1Kt566y2UlJTg6quvxnXXXZfwbxYvXoxf/OIX2LJlC4455hjceuutOP/88+O/dxwHc+fOxe9+9zvU1NTgjDPOwIMPPohjjjkmXmfv3r24+uqr8de//hW2bWPcuHG4++67UVAgp660xQrkwArkfF5gK4kuXiHO0/Sp8hQkqUjJJo5HTn8R02YAOD53ufo0vkdIoVGWp207oxQak+QJbRuZpLRoX/UJbYupMm30Q2zZsA0pHcWKpuC4U9Zb3HZqkkdQLheSTRylrpokYZIwoR13Qrl4HgOAUK6l72i0NByRepybJZCI/ZCaNeiHeg4aJHao1xPtnBWOc0BOOXKUtCvHn+cuU9ZFTN9RUpX8Sp+9fnc6TUQZtzO5n9Hqapcq6bpkK8eitl9iwhGiHTNasoxEbcNgi+ifN+0/36T1TtdLiITQIjoIH374IX7605/iH//4B0KhEE4++WTcfPPNGDVqVEqXYzwCv2TJEmzfvh1TpkzBokWLcOSRR+Kb3/wm/vSnPyEcVmLYOtBNN92EnTt3xn+uvvrq+O/q6upw7rnnon///li7di3mz5+PG264AQ899FC8zpo1azB+/HhMnDgR7777LsaOHYuxY8di/fr18Tq33XYb7rnnHixYsABvvPEG8vPzUV5ejpaWz2O/LrnkEmzYsAErVqzA0qVL8corr2Dy5MkdsxGIiIiIspyTpp90+ta3voVIJIJVq1Zh7dq1GDx4ML71rW+huro6pcuxnHbO5H/nnXfw2GOP4eGHH0ZBQQEuvfRS/OhHP0oYje4oRx55JKZPn47p06eLv3/wwQfx85//HNXV1fD79//FPHPmTCxZsgSbNm0CAFx00UVobGzE0qVL4//u9NNPx5AhQ7BgwQI4joM+ffpgxowZ+MlPfgJg/7cSvXr1wsKFC3HxxRfj/fffx6BBg/DWW2/htNNOAwAsX74c559/Pj755BP06dMnqfWpq6tDUVER9r6xFIUFB4ykZPgIvFSujVA4HIFPYoHpG4E3qmswMqlmqmuLNBg5PWxH4NvbB8gj8JZPfmeCeg6lYARe6rd6TgjnlfbNHbQ+C9RjLhXfMGgj8N4cd6HJCLy2jbRR6zSNwGuk7HQAsB1hf2vfChqMwGsj0Sbrou1tr/QL03eAmFx3M2AEvq6uDl/pXYra2loUFhamZRnJ9qOoqAibP9mJLmnqR31dHQb07Z3ydf30009RUlKCV155BV//+tf3L6u+HoWFhVixYgVGjx6dsmW16yHWnTt3YsWKFVixYgU8Hg/OP/98vPfeexg0aBDuvPPOVPXRyK9//Wt0794dp5xyCubPn49I5PMLXlVVFb7xjW/Eb94BoLy8HB988AH27dsXr/PFDVxeXo6qqioAwObNm1FdXZ1Qp6ioCMOHD4/XqaqqQnFxcfzmHQBGjx4N27bxxhtvqH0PBoOoq6tL+CEiIiI63GTjHPju3bvj2GOPxe9//3s0NjYiEongt7/9LXr27ImhQ4emdFnGc+DD4TCee+45PPbYY3jxxRdx8sknY/r06fj+978f/yvmz3/+M6644gpce+21Ke3sl7nmmmtw6qmnolu3blizZg1mzZqFnTt34o477gAAVFdXY8CAAQn/plevXvHfde3aFdXV1fGyA+u0fvXR+r9fVqdnz54Jv/d6vejWrVubX6HMmzcPN954o+lqExEREZGhLw6UBgIBBALKm9yTYFkWXnrpJYwdOxZdunSBbdvo2bMnli9fjq5du7a3uwmMR+B79+6NSZMmoX///njzzTfx9ttv46qrrkr4CmLUqFEoLi5OSQdnzpwJy7La/Gmd/lJZWYmzzjoLJ598Mq666ircfvvtuPfeexEMKl+NZ5hZs2ahtrY2/rNt27ZD3SUiIiKiDteaA5+uHwDo168fioqK4j/z5s0T+5LsvajjOJg6dSp69uyJV199FW+++SbGjh2LCy64ADt37kzp9jEegb/zzjtx4YUXIidHmMv3f4qLi7F58+Z2dazVjBkzMGHChDbrDBw4UCwfPnw4IpEItmzZgmOPPRalpaXYtWtXQp3W/y4tLY3/r1TnwN+3lvXu3TuhzpAhQ+J1du/endBGJBLB3r174/9eov3lZwXyYeV8nl6jzRF0hPmHjjA/3JQ6rzqqzL+V+iGkLwBALOCeowlAnMtqNGdVmU+ozl+X6irzliPKd2/RqLvcY8vL83jkv/Cl5AN1brC0WwznlZrM/df6IW1TbQ6wCSuqLE+a+6+04WjzyT3CvvUajrqYzOM2eSZAO3alfeht/9xb9ZyQtpFSX71GaITzwolpzwkI/VOvgQbPp2hz3VPxPIz2zI9wjMUseb1tj/vYtVtqxbpWsFFuQ3g+xe+TP7vVa4RwHYwJfQP0x3VMng9Sn7UR+mErZ774kWA6b1x6lkv5TIgqnwmOMEaqPmGhPepkMKPfZFqI9Pij9tnWmW3bti1hAFobfU/2XnTVqlVYunQp9u3bF2/3gQcewIoVK/D4448npCK2l/Hd3WWXXZayhSejpKQEJSUlB/Vv161bF//6AgDKysrw85//HOFwGD7f/gvQihUrcOyxx8a/2igrK8PKlSsTHoRdsWIFysrKAAADBgxAaWkpVq5cGb9hr6urwxtvvIEpU6bE26ipqcHatWvjc55WrVqFWCyG4cOHH9S6EBERER0uYpDHqVLVNgAUFhYm9RBrsveiTU1NAAD7CwMPtm0jZhLjm4RO8ybWqqoq3HXXXfjnP/+J//73v3jqqadw7bXX4tJLL43fnH//+9+H3+/HxIkTsWHDBixatAh33303Kisr4+38+Mc/xvLly3H77bdj06ZNuOGGG/D2229j2rRpAPbPb5o+fTp++ctf4rnnnsN7772HH/zgB+jTpw/Gjh0LADj++ONx3nnnYdKkSXjzzTfxj3/8A9OmTcPFF1+cdAINEREREWWPsrIydO3aFRUVFfjnP/8Zz4TfvHkzxowZk9JltX9+RYYIBAJ45plncMMNNyAYDGLAgAG49tprE27Oi4qK8OKLL2Lq1KkYOnQoevTogTlz5iTks48YMQJPP/00Zs+ejZ/97Gc45phjsGTJEpx44onxOtdddx0aGxsxefJk1NTUYOTIkVi+fHnCtKKnnnoK06ZNwznnnBN/kdM999zTMRuDiIiIKIs5ThvTslLQdjr06NEDy5cvx89//nOcffbZCIfDOOGEE/CXv/wFgwcPTumy2p0DT+nTmoW6b91qFHb58jnw4txzzoFPbCOdc+CFco/ySkA1L9loDnzyc7CN5gYr9H4I5aZzoqXlKXPgpfnkYmZ2G/0Qj2nTrzfTNQdem18sHf9pzJ9O6xx4ibb9pfny2hxzk2c90jkHXplnHhPeb6HOgRey09U58Mo7DBzpWDoEc+BNrmvaNpWux+qbXzNmDrzQD7NeGGXat3cOfF1dHfp/JfXZ6KZa730++HhHWnPgj+3f55Cva3t0mhF4IiIiIuoc0pnX3hme1+00c+CJiIiIiA4HHIHPArFAfuJUEy1CTfyK3fALO+FrNSm2DwCgvfFdihXUXtcuvOobaOM17lLdVLz6XPhrPCzEQgJmX5eqf+ZrfzoL62Ir+1t807fSrBEtitIkMk+dsqPsK2kHeJKfsuM47qkJbfajvXWVflhCbN/+cuVdFCZTT4TjwHhqlMm5ok05kKYWaG2Y9MNkioPJcaRR518o1aV1UeJSpbhIQJ6CEVOuEeKWM5wyZYfc8ZKONp1LmRYjTWGyvco0HGGKkEqb3iZMTQMMp2mZxKiqn6fufRUy/EyQKLMqU0LqRrqm4HSEA/Pa09F2tuMIPBERERFRFuEIPBERERFllI7Igc9mHIEnIiIiIsoiHIEnIiIiooziII058OlptkNxBJ6IiIiIKItwBD4LOB5fYiqL9hIN6aVNpska0tP7WhsmaTjKCzBMXwgitiE8Oq++bElpN11P32uBA/LWAGLSiiuJG5aw7SxlX6kvGBKXZ5hgIqUOaf1Q0yGEZBMtFUMqV5anHV9SmoSWSmAp6+0RirUXd9la8odRsoYUMWE4k1PaTmoaiHbMSPtKSY1SzntpXUyWJ748DG28/MuA+vI76eVyyvGlHXdSWol26YkI42veQBexrq2ds6EmpfX2UfeVlrYknUNa2oz6wjjhOqO9fEqiHIvay5mka4T2uaKRrhHa9URLstE+syTSNczkChHOsBiamOPIn4kpajvbcQSeiIiIiCiLcASeiIiIiDKKg/TNVc/+8XeOwBMRERERZRWOwBMRERFRRok56Xs+LcOm+x8UjsATEREREWURjsBnIS3hwyQlwSjmRXlKP2rLbZs8yW4b1NWqSskAUoIAYNY3j5a6ohADSJRUEi1aQE4xUepK/VOODaO0BtPkIqkJk0QRjXaMCuutrV9zWF5eUNj+2qFhW1o6jVBXbgIe5RyyhDwiNclGaFw7RtXAICH5Q9tX6nVGWBftWqAlPUjrKPVN7Z8jp944XoPjS0slURJ1IlIIkNJ0TDm/taQRsR9CWVDJtfL75XQavzfgKrPCzcoClW0nnVspSKrSThZ1C0lpV1qKmbBvtcuJmv5isK/UtDHt+i8tTymXkmVMkmm01ZDajZg03BGc9OXAd4ZJ8ByBJyIiIiLKIhyBJyIiIqKMEoODWJqGytPVbkfiCDwRERERURbhCDwRERERZRQnjXPgO8GLWDkCT0RERESUTTgCT0REREQZhTnwbeMNfDawPYmRZ14tQs0dGRbTYrYMDt6oUjkUkWPHpAhHLV1Mi8GT0re0CEgp+kqrq6222AvD76ekzaQnUcq/cIR+OwZplraywKiyMtJmUqMQTSILtdhKgxhJS6krxRtKEX+AHDEKmMWJ6mmW7hXXouC0B6bEbaodu1JV5djQ0us8ljtez/LKcYoaMbZVuRZom9kjRHN6pJxMAA6Ea5iaVpj89USLCQyHlVhB4UDQzhXp2DBlEh+oxebm+dyfFTkeJa4z0pJ835TPlZjwGQTI21q7rqnppdL5ppycUoyntD1TRWtZWm/TY0M6s7RjV6pr9FmffFXKALyBJyIiIqKMwjnwbeMceCIiIiKiLMIReCIiIiLKKMyBbxtH4ImIiIiIsghH4ImIiIgoo3AOfNt4A58FYjlFiOUWxv9bTQAQEibCWmyBwiT5oEWJ/ghFk08a8WipEUKZ1mrGnOAG4QJaIoIUgKEmm4hNmKXvSLTViArJIYBZqoKtREyILSh1peNRS+HQyrV0GhOWsFW141mLi3GEbRo1SmyS10PrhtRnUybbX0sJkfasdhxJ54p2LUhFKox2biZ/VQM8RslRydfVDlvteI4JSU6+nDyxrjcWSbofjpIypfVDOj60ddETlJI/dk1O71R8fGjLk9NitHMl+TZMUta0vkmHuen9Ah1avIEnIiIioowScxzE0jRCl652OxLnwBMRERERZRGOwBMRERFRRonG9v+kq+1sxxF4IiIiIqIswhF4IiIiIsoonAPfNt7AZ4EWOwC/HYj/t6M8Vh6Oub8T0lIgTGhfNWmJAxGhvtYPS2nDFnJJPMr3RVJoga2kTmj9kJ/eb38MjaVsO8cgeUJLoYmmINnBIJyjDe6Fal/taSktJt2QVlHbr9q3pNJ2Mk1SkVJhPHbydQGzBBKpDW3/mWx/0zakbaptI22bStUtg5SRVFzXUkG6TgFm66KnriS/r7TtIV0jGkJyG4WBLmK5FQnK/8CAdL7paT9pukZoST1KG9Lxr6ZMKcRzRVmgtg+lz1mtDenlRNqpIm0OLd2GMhNv4ImIiIgoo8QcJ21/rHeGEXjOgSciIiIiyiIcgSciIiKijBJz0jdS3hlmC3EEnoiIiIgoi3AEnoiIiIgyCnPg28YReCIiIiKiLMIR+CzQEonBd0A2Y0SNu5PK0jfRS5tDJi3TNJ5K+stSO1iluDVHDBLT+yzH2ikLVEjrrc3f0+LITP6ilva3tjwtVtOTghhJS9r+SrsxNTa0fbTDXI1TFPqnxZRGlRzPkDSEo9TVt3/yUYFSRKUWY6iti0fYTtoxIO1XQI7/0yNllWuVsOm09Zb2rRobqsUpGoy2qdtOOGf1uM7kl6etd0wo9xnGsEpbQ4v2bIrI5bm+HKV1oR/K/paOMcfwAitH/cp1pePDdMRVvIalceK0SdyjGhsqrKMULaktTztfDxXmwLeNI/BERERERFmEI/BERERElFGiacyBz5SXwbUHR+CJiIiIiLIIR+CJiIiIKKPEkL7HDjpBCA1v4ImIiIgos0RjDqJpuoNPV7sdiTfwWaA5EoM3fEAKjfKno5yCItfVpn9JwQBK8IFKSpzRThYtncMSJndpfZaKlaAFlfikfgrOb0eJY9Hm35mkwpikMmipPFJ+hRYOoc23k1JJwobbrr1z+bTRFD0lxL2SfsNlNgsbuymsxNAofLa7hz7lILCFWBLLkje0TznupKb1MBAt7Sr5hA89LSP5NsIx9y/Cyglukixhsp0BOTFIayOmpQNJG1tLUBIOXtOUKam+lgjWEJZ3gJRM4lfWW0suSgWTNBYpqU27RqRiKrRJgpK2D7VuSNtf24chIUnI5JwIajcXlJF4A09EREREGcVJY4ykNPCUbfgQKxERERFRFuEIPBERERFllKhjPh3WpO1sxxF4IiIiIqIswhF4IiIiIsoosTTOgU9Xux2p09zAv/zyyxg1apT4uzfffBNf+9rXsGXLFgwYMMD1+6qqKpx++unx/168eDF+8YtfYMuWLTjmmGNw66234vzzz4//3nEczJ07F7/73e9QU1ODM844Aw8++CCOOeaYeJ29e/fi6quvxl//+lfYto1x48bh7rvvRkFBgfG6NYcdeA6I9ZBSGQA9xaG9PMr3NFoShNY/ScDjkZcpPdavPOkvJcjYWmUDpue31GUx3QZQIwek1Bpt+0u0xCBta4ihGErfQmqiyJf3q5VXWRdb6LiWaGHy8JFJ8oT2laqajiL8A+2c0NIyWoQeisc+5KSRHGWDOkq5lFqjbU6TDzhtG2ltSNcIkxQaLS1DS+eQaMktPuUkkpKLtLoBZftL+0tqFwBsMWZKS3/R0mmEJpRNFBESTAAlMciR18+j9EM6LUxT/KTzXjtnpePA9HquXrvbST/f5HIphUY7/lsMUmSkc7NZSSKizNRpptCMGDECO3fuTPi58sorMWDAAJx22mkJdV966aWEekOHDo3/bs2aNRg/fjwmTpyId999F2PHjsXYsWOxfv36eJ3bbrsN99xzDxYsWIA33ngD+fn5KC8vR0tLS7zOJZdcgg0bNmDFihVYunQpXnnlFUyePDn9G4KIiIgoy7XmwKfrJ9t1mht4v9+P0tLS+E/37t3xl7/8BZdffrlrJK979+4JdX0+X/x3d999N8477zz89Kc/xfHHH4+bb74Zp556Ku677z4A+0cB7rrrLsyePRvf+c53cPLJJ+P3v/89duzYgSVLlgAA3n//fSxfvhwPP/wwhg8fjpEjR+Lee+/FM888gx07dnTYNiEiIiKizqfT3MB/0XPPPYfPPvsMl19+uet33/72t9GzZ0+MHDkSzz33XMLvqqqqMHr06ISy8vJyVFVVAQA2b96M6urqhDpFRUUYPnx4vE5VVRWKi4sTRv5Hjx4N27bxxhtvqH0OBoOoq6tL+CEiIiI63LTOgU/XT7brtDfwjzzyCMrLy9G3b994WUFBAW6//XYsXrwYy5Ytw8iRIzF27NiEm/jq6mr06tUroa1evXqhuro6/vvWsrbq9OzZM+H3Xq8X3bp1i9eRzJs3D0VFRfGffv36HcSaExEREVFnlvE38DNnzoRlWW3+bNq0KeHffPLJJ3jhhRcwceLEhPIePXqgsrISw4cPx9e+9jX8+te/xqWXXor58+d35CqpZs2ahdra2vjPtm3bDnWXiIiIiDpcaw58un6yXcan0MyYMQMTJkxos87AgQMT/vuxxx5D9+7d8e1vf/tL2x8+fDhWrFgR/+/S0lLs2rUroc6uXbtQWloa/31rWe/evRPqDBkyJF5n9+7dCW1EIhHs3bs3/u8lgUAAgUDAVd4UjsIOR+P/raW8aAkYJnweIbYg6i4C9CfeTfrR4pHbCEbdf1tqiTV+r5DcosSuqCktUuhN+4NsjEnL1FJJTL4C1BI3pL/gld2tJ40IaQ1an7XEDa1cXp67rq1sCy1TQUqFCSnHbUhZcen419JmtHOivfvQJOXFtA2TZBltvVORFiM9bKb22SBRxzSFxifEQdm+9I2BSZtIu66ZtKHWVVJXokIylnbt17apdHxofdMuBVJ9KaEFMDu+NFKSmfaZkJI+G6S6mZxXJg9rtqQryo7SIuNv4EtKSlBSUpJ0fcdx8Nhjj+EHP/hBwsOpmnXr1iXciJeVlWHlypWYPn16vGzFihUoKysDAAwYMAClpaVYuXJl/Ia9rq4Ob7zxBqZMmRJvo6amBmvXro0n3KxatQqxWAzDhw9Pel2IiIiIDkfMgW9bxt/Am1q1ahU2b96MK6+80vW7xx9/HH6/H6eccgoA4Nlnn8Wjjz6Khx9+OF7nxz/+Mc4880zcfvvtGDNmDJ555hm8/fbbeOihhwDsz6aePn06fvnLX+KYY47BgAED8Itf/AJ9+vTB2LFjAQDHH388zjvvPEyaNAkLFixAOBzGtGnTcPHFF6NPnz7p3whERERE1Gl1uhv4Rx55BCNGjMBxxx0n/v7mm2/Gxx9/DK/Xi+OOOw6LFi3C9773vfjvR4wYgaeffhqzZ8/Gz372MxxzzDFYsmQJTjzxxHid6667Do2NjZg8eTJqamowcuRILF++HDk5OfE6Tz31FKZNm4Zzzjkn/iKne+65J30rTkRERNRJxGIOYmnKa09Xux3Jckxea0gdqq6uDkVFRVi1fgsKuhTGyzt8DrwiFXPgteVJbyw0mwOvvc1S7sehmO8ukfqtzclNxRx48ZEH7U2s2jxugznwfmV/a+soLk/ohnYZ02Z0SvNQW5Q3UWpz4OuD7qcFTM/N9u5D7U2s2nnFOfCfS8Uc+DxlDnyeT75WmbyJ1eRakIrrl7YPpX7ozxhxDvyBsm0OfGNDPcaddjRqa2tRWFj45f8gTVrvfX73ykbkFXRJyzKaGuox6RuDDvm6tkenG4EnIiIiouwWS2NaTCcYgM/8GEkiIiIiIvocR+CzgM9jJXwl7lOmkoRt95+UTWE5FFD7ulTKENS+FtVIXwlrX+NpfwVr03OUJQp9UL4ONvi62mBWh9qG6VeuUrHWhrQ8bbdqX3mL20PZKcIMgv3l0lfNclX1ODD5mtfkeDSZHqJtO5PpL6ZTRkymh0jrHVTmuZhOD5GYTFMJK/3Q+qdtp2Rp62Fr01+EcnUbKQe6NP3FZ5uNgUnHkjZVSZqFox2jJpdorQ0tRlJaQ+1aAKUNiTbNTr14ZAD1GqFeZ5L/TDaZkqpdT0ym5El9a1b6dqgwhaZtHIEnIiIiIsoiHIEnIiIioowSdRx9tkAK2s52HIEnIiIiIsoiHIEnIiIioozCHPi2cQSeiIiIiCiLcAQ+C+R4bfWFLQeSkle0F8tElZfWSPPC9EQLuU9SQoFpko3UtvZyGqlpbXqbHr4jvZxGrqulJ0jd09IytFQYS3ppirLrUzGFT0oiaFFWXHsBiURNmNDqC+tosp016ot9xP0tV9bSIepD7sQGLWFCS3fQ0lvaS0tjMXk5kGnbEm2US7oeaNcquWG5WAmfEvvhVaNU5Mal1Art2FDPezENR+6FSepNSpKZDF7kFFA+j0wSs5L4SPtSqUjo0tJ3pONR299aqpJUX0tm0q4FJjno7U1W0fp2qESRvhz4zMrbOTgcgSciIiIiyiK8gSciIiKijNKaA5+un3S55ZZbMGLECOTl5aG4uFiss3XrVowZMwZ5eXno2bMnfvrTnyISiRgth1NoiIiIiIhSIBQK4cILL0RZWRkeeeQR1++j0SjGjBmD0tJSrFmzBjt37sQPfvAD+Hw+/OpXv0p6ObyBJyIiIqKMkq058DfeeCMAYOHCheLvX3zxRWzcuBEvvfQSevXqhSFDhuDmm2/G9ddfjxtuuAF+vz+p5XAKDREREREddurq6hJ+gsFg2pdZVVWFk046Cb169YqXlZeXo66uDhs2bEi6HY7AZ4GYs/+nlfaXY6OYimH2xLtPSGbQ5oppyQdSuZYooiXLSGkNWhsmIRqpiH7Vlid1T0tJ8CrrbZIIIiXIaE/sS3UBOXGmWUlU0NrwC8dMnk9ej1wlesIvbA9tU4TFPivJGkqfG4LuddzXEhbr1irlDcL5pp1XYaUfIaF+yHD7mxDPK4PEFADI8XpcZep5bJCOotWVtmlQS9cyGFXTEl20dckRjnMtjQXCNtLazvPJdaVybRuZhD6ZDjyaJERp/UjFNVratybroqUcmSTLSMlTgJ4+JbVhlLYE80Sv9tCuPYdKLOak5LqntQ0A/fr1SyifO3cubrjhhrQss1V1dXXCzTuA+H9XV1cn3Q5H4ImIiIjosLNt2zbU1tbGf2bNmiXWmzlzJizLavNn06ZNHdp3jsATERERUUaJpnEEvrXdwsJCFBYWfmn9GTNmYMKECW3WGThwYFLLLi0txZtvvplQtmvXrvjvksUbeCIiIiIiRUlJCUpKSlLSVllZGW655Rbs3r0bPXv2BACsWLEChYWFGDRoUNLt8AaeiIiIiDJKR4zAp8PWrVuxd+9ebN26FdFoFOvWrQMAHH300SgoKMC5556LQYMG4bLLLsNtt92G6upqzJ49G1OnTkUgEEh6ObyBJyIiIiJKgTlz5uDxxx+P//cpp5wCAFi9ejXOOusseDweLF26FFOmTEFZWRny8/NRUVGBm266yWg5vIEnIiIioowSjaVvpFwJDEuJhQsXqhnwrfr374/nn3++XcvhDXwWaAxFYR0QX1Ufkl+3K0VGarF2WkScbSV/smh1Y467bS2aLSrUBeSINyVtTYzZkqLP9rerRea5y7TwLi0+U6ybdE2dtjRL6oeSqybWBeCTOqhF4ymkaMgCvxLRp2x/KapUi0CtC7nLa1vkGLdPm0JiuRQZ2RCUz6sW5RySIte080pj8uFk0rbWrhg9qtTVlifV9yvHjElUox41m/y1QIuRlNrWIiC1WMcCv7vcJAISALzCNjW5JqUzUlBr2uT6aiKiZN6GtGNXKNZOH+kw0G7YpKhHQI6GbFA+e02vHRI9JrnjYiRN+kuHHm/giYiIiCijZOsc+I7CHHgiIiIioizCEXgiIiIiyigcgW8bR+CJiIiIiLIIR+CJiIiIKKPE0jgCH+sEI/C8gc8CdaEoogc85V6vPPEeNHiC3Kekv0gni55YI5fnGKSYaGkSUiqJdr5J3bCU9VPCcMSkFy0dwqs1ItC2hJYKIzUtJVcA8vaXthsAaJeqsBDtoKVAhLTUCOG429MkH4vNSuLDnkZ3Wkx1fVCsu1dIkKltcpcBQHNITqeREmRMSeeFdq5o5VJ6i0kbJu2qbRimX0jHqK30Q0uhkRJgtOtGQEyhMVueVN+kLiBfZ2w1I0oWEc4t6fxJJ22/piKFRtseJkEqWpKQdP3Rbu6k61o4Jm/nsNJGi3CNkJJpAKBRKU9FUpVp/fYIRuT1oMzEG3giIiIiyihRJ41z4JU/FLMJ58ATEREREWURjsATERERUUZhCk3bOAJPRERERJRFOAJPRERERBmFI/Bt4w18FtjXHEbQ83nKRrPyxHtYSDPQ0iG05AmJnsZi8AWOkjChJSL42vndkPbgvrbaUj+0p/+17eEX0iu0BBmNJTxYY0XdCS37y93JK443INZtduS4n4aw+5ipD8ppDbsa5VSY3UKCzK4Gue72vc1yG0LiTHNITluSkjxMt7NJsoOeCtO+BBkA8AvnkJYgIyW3aHW18ly/+zjQ6mrnpnRNMUmb2V/f3Ya2PBNaClOTcJzHnOSvo4CcSqIlf0kpKICchKLF2SlNiAyCsdTPBL3t5PeV1g/ps0K7jmrninTDpSXISLRjQ9tXUuJMo3JNamiRyyWm14j21jWRinQu6ji8gSciIiKijBKJOfCkaaRcGgjKNpwDT0RERESURTgCT0REREQZhXPg28YReCIiIiKiLMIReCIiIiLKKLE0jsBrD49nE47AExERERFlEY7AZ4HGUASxA+KrpHgrQImGNPwrU4oHiyrZYD6laSmuKxiR28jzyfGG4Zj7b0utrlYu0dK3pFXUItHUqDQpGk+IegQAx5L/do5Z7nWJ2X6xbtRyl9cH5WPj02Y5inJrbYu7bpNc9zMhLhIA9tS5IyC1up8p8ZIm8WVS7KE2SmMyemM60iNFuZlGxJnEX0rrLUVZanUBObZS65sWASm1rS0vFZF5JkyOA+2Y08qDQrm6PCWy0CS+V/z3adpupm2nIrbVdF2k+ibnrEk8pWnbWt1UXCPaW9dESyizYiSjjqOeS6loO9txBJ6IiIiIKItwBJ6IiIiIMgpTaNrGEXgiIiIioizCEXgiIiIiyigcgW8bR+CJiIiIiLIIR+CzQEMogkjw8xQak8QO0yfs05UWkKskxWhJFzlCWobWhpRC0yUg1y3wy4e8X4iWCcTk9ZYScgAgFJUSYOS6UeWP/5aIO7UmpOyrYMRdXtsSEWoCO5X0l33N7uW1RJSUI+U46FbgTsPRUkm0fbi30d2/emVdmkPu/qnHucG5Yso2OC+sFCRMdHRKRSakYmjSOXqWisSg1OzDzBhfy+TjIJ3Ez0IlRchkf6ciwScVdSXhaIal0HAEvk2ZcYUgIiIiIqKkcASeiIiIiDJK1IkhGkvPtwJRJ7O+bTgYvIEnIiIioowSS+MUmhin0BARERERUUfiCDwRERERZZRozIHNh1hVWXMDf8stt2DZsmVYt24d/H4/ampqXHW2bt2KKVOmYPXq1SgoKEBFRQXmzZsHr/fz1Xz55ZdRWVmJDRs2oF+/fpg9ezYmTJiQ0M7999+P+fPno7q6GoMHD8a9996LYcOGxX/f0tKCGTNm4JlnnkEwGER5eTkeeOAB9OrVy6gvydqxrwWB4Of/Lqgka0gHZEh5qryjUxy09BHtqXkpnSbXL7chJZ4U5MjbuYuSQlMYcJcXKW0UBXxKP9zrYkNev6gjb/+msDthRSoDAGkXaiEEXZRtJ2kOy1/MtajHnTvJRm9bXpeaJncbjY0hsW5Hf/Wppc04jkHig7zasIRUC0dZnpzJYyYVaTip0N62U5GMZSoiHHdaooh2jTbjPmhME0wkHZ1QtL9+8l/2p+u4M21X/IxUViOqxIp5hCQz+aqWmuSi9goKCV+UubJmCk0oFMKFF16IKVOmiL+PRqMYM2YMQqEQ1qxZg8cffxwLFy7EnDlz4nU2b96MMWPGYNSoUVi3bh2mT5+OK6+8Ei+88EK8zqJFi1BZWYm5c+finXfeweDBg1FeXo7du3fH61x77bX461//isWLF+Pvf/87duzYge9+97tGfSEiIiIiWSS2/w/n9Pwc6rVrP8txlKHADLVw4UJMnz7dNQL/t7/9Dd/61rewY8eO+Ej4ggULcP3112PPnj3w+/24/vrrsWzZMqxfvz7+7y6++GLU1NRg+fLlAIDhw4fja1/7Gu677z4AQCwWQ79+/XD11Vdj5syZqK2tRUlJCZ5++ml873vfAwBs2rQJxx9/PKqqqnD66acn1Zdk1NXVoaioCNc88zoCeQXxco7AJ+II/AHLUwZrtGOmXhhx0UbJtRH4uhb36HmtMKIOADtrW+TymmZXWaaPwJuMZmukEXiTfHnj5XEEPqV1tRFxabQ+FTgCf/AOyXorufEmbXfoCHxTAx74fhlqa2tRWFjYYcv9otZ7nwvuWwlfbn5alhFubsRfp51zyNe1PbJmBP7LVFVV4aSTTkqYxlJeXo66ujps2LAhXmf06NEJ/668vBxVVVUA9o/yr127NqGObdsYPXp0vM7atWsRDocT6hx33HE44ogj4nWS6QsRERERyVpf5JSun2yXNXPgv0x1dXXCDTOA+H9XV1e3Waeurg7Nzc3Yt28fotGoWGfTpk3xNvx+P4qLi111vmw5B/ZFEgwGEQx+/kbKurq6NteZiIiIiA4/h3QEfubMmbAsq82f1hvnw8G8efNQVFQU/+nXr9+h7hIRERFRh+MIfNsO6Qj8jBkzXAkwXzRw4MCk2iotLcWbb76ZULZr167471r/t7XswDqFhYXIzc2Fx+OBx+MR6xzYRigUQk1NTcIo/BfrfFlfJLNmzUJlZWX8v+vq6ngTT0REREQJDukNfElJCUpKSlLSVllZGW655Rbs3r0bPXv2BACsWLEChYWFGDRoULzO888/n/DvVqxYgbKyMgCA3+/H0KFDsXLlSowdOxbA/odYV65ciWnTpgEAhg4dCp/Ph5UrV2LcuHEAgA8++ABbt26Nt5NMXySBQACBQMBVvqc+CH/08wcntVcLp+svSq3dVDyopbUtPbgjPdgKALnCg6kFwkOpANCz0L19AaBbvvvBYu1hzrASGSY99JqnPLyrPdvkEx72yvEmv51tpWHtYSqTh2arlQdQP2twP2y6tzEo1JTrAkCT8MBqJCwf59JDntLDoKmiHaOW7S5PxQOvJg/pmj7w6ghta30zuZ5kwgN4bTFZF5O6zSm4Bppso+gheBBTenDW9LPGI5wret10PcSavgkHKXlIWklw7MhzKKRc+w8V5sC3LWvmwG/duhV79+7F1q1bEY1GsW7dOgDA0UcfjYKCApx77rkYNGgQLrvsMtx2222orq7G7NmzMXXq1PhN8VVXXYX77rsP1113Ha644gqsWrUKf/zjH7Fs2bL4ciorK1FRUYHTTjsNw4YNw1133YXGxkZcfvnlAICioiJMnDgRlZWV6NatGwoLC3H11VejrKwMp59+OgAk1RciIiIiooORNTfwc+bMweOPPx7/71NOOQUAsHr1apx11lnweDxYunQppkyZgrKyMuTn56OiogI33XRT/N8MGDAAy5Ytw7XXXou7774bffv2xcMPP4zy8vJ4nYsuugh79uzBnDlzUF1djSFDhmD58uUJD6XeeeedsG0b48aNS3iRU6tk+kJEREREslga56p3dBxxOmRdDvzhpDULdfzv/g7/ATnwnEKTKF1TaIqUNrrnyTn+qZhCE4q4t0cwmvzXmtoUGi0H/tMm99SV3Ur++uE6hUZjCYej6RSa9vY7FZnxqciz7+gpNNk4NUeTroz6VLXR0dnzh+0UmhTVb49QUwMerRh5yLPRW+99zv7NC/CmKQc+0tyIVT8pP+Tr2h5ZMwJPRERERIeHaMyBxTnwqk7zIiciIiIiosMBR+CzQEHAC/8B0zn8ylQSaYqJVtco+UD5SzWkTMtoCrmnfGiJLiZTaLRpMV2EqSsFQllbbUhTXbTpCWGDv9y1r5/9Hrk8V+he1JH3YUhIw5Gm4ABAkyNvf2lqTW1zWKyrTX9pCEZcZSb7FQC8ylQjiTS1JhYxS09IxbQRqQ2PR95XUmINYDYFRlqeMpvOjLKvTPqmTadLRWpKRzsU01SSlemjhtr1Ll0pQGbMTpZ0TYvJlKk8Eu0z/VBxHEdMzkpV29mOI/BERERERFmEI/BERERElFFiMSdtaTGdIYWGI/BERERERFmEI/BERERElFEcx0nbXHXOgSciIiIiog7FEfgscEzvAuTmd4n/d46SdBHwupM8tJcfKSEoIiHsBAAQicpPrEspLS3K0+1hJUbDI7zgRlsXn8FT/TGDv7q1lx/FYnJKi9S21kaB8PIpAMj1udfFpybZiMWivJhcWUrl0RJ8pLQfQE4+yFU6Z5KS0KTsq3DQnTgTEpJwAH2URUqLsZXjS3s5liSqJF3YjtyGI1SXXhAFyKMtDuT1S0XKjpZwY5JOY5IgkYo+m0jnC3JMUpg6+mVQ2Zpk09HS92JEOTErNcdj+8ZkM+3YcGJpTKHJsHU9GByBJyIiIiLKIhyBJyIiIqKMwhSatnEEnoiIiIgoi3AEnoiIiIgyihOTnxNKVdvZjiPwRERERERZhCPwWaBfYS7yCnLj/x1QUmh8QrSMlOYCmCVraEkxYSWeRkqhCUbkJ+8bQnJ5U9hdXq8kjUialXZDSiqM9PS9lgrgV9JKpPSWPJ+cxmJSXqAlupikoxik72ipPlo6jbQ90rn9pQQZr7I9w8oxExUSlCJKn7XUFSm1xqOMiWiDPeKmjsnLM0mIsGy5rlGCjJJw4wiJOpbBsajp6NGkSArmwJom55jsw1Qky0htmKadpCuZROtHKvaLiVSk3phsf1Me4SJh0q72eeUXrqNBx5d8xzoAc+DbxhF4IiIiIqIswhF4IiIiIsooTKFpG0fgiYiIiIiyCEfgiYiIiCij8E2sbeMIPBERERFRFuEIPBERERFlljSOwKMTjMDzBj4L9C4IoKBLTvy/lRRJkZCW1yYpMjKstBFUGm8QovvqlYi+TxuCYvnOmhZXWW1zSKyrRRNK9GhIdwxhrhLf2CUgnzZS2znKzpJiMgGgtsW97bQYT5PoRa0fUqxgixL5qbUtbSc1ukwpj3YJJL08ab3rhe0GAHvq3ccRAOwWjq/mBvn40qIoY8Jxp33YSNGXAOAYxMGZRBbaQtQjkJqXl2gRlWI/DPockw+7tDGNgBTbUCI/TWjbKBVxilGDdTSJJjQ5N7X6pvGUqYhkbC8tclKNvBVjPOVrgUlssRQBCQB5wrW4KE+Ohuya53eVNTce+m1MyeMNPBERERFllJjjwEpTXnuMOfBERERERNSROAJPRERERBnFcdKYQsMReCIiIiIi6kgcgSciIiKijMIc+LbxBj4L5Pps5Pq+/MuSkJAKoyWYhKPywSsly9QrKRwNSrJMbTDsrqukhGjl0ro0KctrVsolXXLkQ1560l9Lm+lW4H56HwC657vLC/xyGxElwScmRHE0Kik7JusNJYkgR/gSLkdI5AFSkwLRo8CdNgMAPo+Q1mDJywsL265RSfXpWSgvr+SAVKdWO2ubxbqf7pPLm4TUGimZBgCiUOJfDHahlJpiK9soXek2gJxwYyn9MEkasTr6+2ClbybJOQ7afxNgkr5jnJwjtK3uK4NmtW2UimQfk0QX0zbSJRV90xK6pM8hLVlGur52zZXrFgntNnrlz2PKTLyBJyIiIqKMEosBVppGypWxzazCOfBERERERFmEN/BERERElFEcx0nrT7rccsstGDFiBPLy8lBcXOz6/T//+U+MHz8e/fr1Q25uLo4//njcfffdxsvhFBoiIiIiohQIhUK48MILUVZWhkceecT1+7Vr16Jnz5548skn0a9fP6xZswaTJ0+Gx+PBtGnTkl4Ob+CJiIiIKKM4sf0/6Wo7XW688UYAwMKFC8XfX3HFFQn/PXDgQFRVVeHZZ5/lDXxnE4rGElJZlAATNAlJHA0h+anysPJgiJTwodXV5HjcM7M8ypPwuX458aRESA+pbXInhwBATZM79UZKsQGAXJ+8vN7F7ralVBlAfnofAAJCeov2uuYWsRTIS7JdAIjludvWUkkKlO3sE/ZVMCLnUWipQ9Jxp21/j6WkH0Xc5c1KsoyUvqMl8mgpKFIakd+bL9bVVIfd69gScSfTAGaRZTGDdBQ1bcYgUsQjHANtMUm40YhpJSYxKFnKJOHGhJYsk4pkH6nPWnKOSQqNaRqO1A9teVLSi5b+ol0jtFQYszbc112t3WLlM1JKPdM+m7rmuNsoUpLX8oTPQm9Y/pyg9KutrUW3bt2M/g1v4ImIiIgoo8RiThpTaPa3W1dXl1AeCAQQCMjxw+myZs0aLFq0CMuWLTP6d3yIlYiIiIgOO/369UNRUVH8Z968eWK9mTNnwrKsNn82bdpkvPz169fjO9/5DubOnYtzzz3X6N9yBJ6IiIiIMkpHvIl127ZtKCwsjJdro+8zZszAhAkT2mxz4MCBRn3YuHEjzjnnHEyePBmzZ882+rcAb+CJiIiI6DBUWFiYcAOvKSkpQUlJScqWu2HDBpx99tmoqKjALbfcclBt8AaeiIiIiDJKR4zAp8PWrVuxd+9ebN26FdFoFOvWrQMAHH300SgoKMD69etx9tlno7y8HJWVlaiurgYAeDweoz8SeANPRERERJQCc+bMweOPPx7/71NOOQUAsHr1apx11ln405/+hD179uDJJ5/Ek08+Ga/Xv39/bNmyJenlWE46X0dF7VJXV4eioiI8985/kN+lS7xc+8PRJAJSi72SaFGImqhQXWtDi8zzGkTbRQzW26dEiRVK8VtKXGSOEgMWjrn7Udsix3hK0YtA+7edFlMnRYZptL5p67KvyR2dWCtEewJATbNcvrch6Cr7tM5dBgARpX8SLWYuIOxbLdK0tkGOhqzf1+wqCwflvmlxfiZZxKmIBJSi+1IRbWgSH5hOHd0PLbY1FdK1Llq7KTkODOIsTZcn9VtbnknkpBbrKMVO5inXCK2NAuFzxSQuEgC6CvWlMgAoEpaX55P75rPd5Q31dTj7xCNRW1ub1LSSdGm99zlmyh/gCUjhyu0XDTbh3w+OP+Tr2h5MoSEiIiIiyiKcQkNEREREGSVb58B3FI7AExERERFlEY7AExEREVFGcZw0jsB3gsc/OQJPRERERJRFOAKfBeqCEUR8nyeAmKTC+JQ0F608FTwpCE8ICE/1a0kqUipMKtIhtCa0zR8Nu38hrQcgp80AcgJMMCJHlUh1mw0SWgAgJLTdoKTN1CjJMnsb3WkxnynJLQ1KskxDTYurrKlerhsTUoe0hAktpcIj7BevcnxpI0BSGo7ajxQkfEjHtGm70nrHtINRIabhKIedtv07i1Qkt2g6OoVGY3ItNTn+tW2nn7NS59SeaL9ImpQsY5I2A8iJM0V5cl0pCU0rL/DLt25S4kzAI1/XpFsAXyo+vFPIiTlqUl0q2s52HIEnIiIiIsoiHIEnIiIiooziOE7a5qpzDjwREREREXUojsATERERUUZhDnzbeANPRERERBklFnOANN1op+vh2I6UNTfwt9xyC5YtW4Z169bB7/ejpqYm4ff//Oc/8etf/xqvvfYaPv30Uxx55JG46qqr8OMf/zhe5+WXX8aoUaNcbe/cuROlpaXx/77//vsxf/58VFdXY/Dgwbj33nsxbNiw+O9bWlowY8YMPPPMMwgGgygvL8cDDzyAXr16xets3boVU6ZMwerVq1FQUICKigrMmzcPXq/5Jm8OR2ElkS7iFR4rl59r10mJLj4lLUB7Yl1KLfDZZrO1xCfklTb8Qj9Mwy+iwny4kJLOIaW/aOVagkxYSFLR6mvLq212p8LsVdJfPmtUyhvcSS/1StpMi1YutN3SKNcNtsjloaZGV1k02CzWlVi2nLRgQmvDUlIcpPpef0Cpa5DkoRy8UmqHaaJIVDnuxOUp/ciUdJTOziThRkwG0uoaXhzN+mGQQmN4fDmOkDZmkJriScGMYY/yGZSrJFjl+t3lBTlagkzyKWvaZ6+UOOP3KtcTIanH9HOaDq2suYEPhUK48MILUVZWhkceecT1+7Vr16Jnz5548skn0a9fP6xZswaTJ0+Gx+PBtGnTEup+8MEHKCwsjP93z5494/9/0aJFqKysxIIFCzB8+HDcddddKC8vxwcffBCvd+2112LZsmVYvHgxioqKMG3aNHz3u9/FP/7xDwBANBrFmDFjUFpaijVr1mDnzp34wQ9+AJ/Ph1/96lfp2DxEREREnYYTi8KJmUUjm7Sd7bLmBv7GG28EACxcuFD8/RVXXJHw3wMHDkRVVRWeffZZ1w18z549UVxcLLZzxx13YNKkSbj88ssBAAsWLMCyZcvw6KOPYubMmaitrcUjjzyCp59+GmeffTYA4LHHHsPxxx+P119/HaeffjpefPFFbNy4ES+99BJ69eqFIUOG4Oabb8b111+PG264AX6/vx1bgoiIiIgOZ536+5La2lp069bNVT5kyBD07t0b//M//xMfNQf2j/KvXbsWo0ePjpfZto3Ro0ejqqoKwP6R/nA4nFDnuOOOwxFHHBGvU1VVhZNOOilhSk15eTnq6uqwYcOGlK8nERERUWfSOgKfrp9slzUj8KbWrFmDRYsWYdmyZfGy3r17Y8GCBTjttNMQDAbx8MMP46yzzsIbb7yBU089FZ9++imi0WjCjTcA9OrVC5s2bQIAVFdXw+/3u0bwe/Xqherq6ngdqY3W32mCwSCCwc/nJNfV1ZmvOBERERF1aod0BH7mzJmwLKvNn9YbZxPr16/Hd77zHcydOxfnnntuvPzYY4/FD3/4QwwdOhQjRozAo48+ihEjRuDOO+9M5WodtHnz5qGoqCj+069fv0PdJSIiIqIO58RiaRyBT/6B/kx1SEfgZ8yYgQkTJrRZZ+DAgUZtbty4Eeeccw4mT56M2bNnf2n9YcOG4bXXXgMA9OjRAx6PB7t27Uqos2vXrnhKTWlpKUKhEGpqahJG4b9Y580333S10fo7zaxZs1BZWRn/77q6Ot7EExEREVGCQ3oDX1JSgpKSkpS1t2HDBpx99tmoqKjALbfcktS/WbduHXr37g0A8Pv9GDp0KFauXImxY8cCAGKxGFauXBl/EHbo0KHw+XxYuXIlxo0bB2B/qs3WrVtRVlYGACgrK8Mtt9yC3bt3x5NrVqxYgcLCQgwaNEjtSyAQQCDgjqELeG0EDoiS8kkZi5DjHrWoLo8WDSmUa/FWASHeCjCLcDR5m7EU9QgALUrcowmpaZO4SABoCLnLTduQyhtaIvLyhPIaIVoSkOMiAaCm3l0eDip9E+oCQENNi6usuWavWDcaSj4a0kRaYyRjycdIynvKbJkeJWrWcYQTy3AapxQhqMUEOlp8YPZPHQWQ3thK7bprIhXjg0bxpUrdVMRZmhx3tvK5Ir14R68rFCrZEaFI8p+RUWXUNqTEBUeFPktlABBTPt+k+lqEudSGeN0AEIXQN5MP5A7gRKNwomlKoUlTux0pa+bAb926FXv37sXWrVsRjUaxbt06AMDRRx+NgoICrF+/HmeffTbKy8tRWVkZn2vu8XjifyTcddddGDBgAE444QS0tLTg4YcfxqpVq/Diiy/Gl1NZWYmKigqcdtppGDZsGO666y40NjbGU2mKioowceJEVFZWolu3bigsLMTVV1+NsrIynH766QCAc889F4MGDcJll12G2267DdXV1Zg9ezamTp0q3qATERERESUra27g58yZg8cffzz+36eccgoAYPXq1TjrrLPwpz/9CXv27MGTTz6JJ598Ml6vf//+2LJlC4D9KTMzZszA9u3bkZeXh5NPPhkvvfRSwsudLrroIuzZswdz5sxBdXU1hgwZguXLlyc8lHrnnXfCtm2MGzcu4UVOrTweD5YuXYopU6agrKwM+fn5qKiowE033ZSuzUNERETUaThOGnPgnewfgbccJ8O+M6G4uro6FBUV4fdrNiGvoEu8/HCdQqNJwbfVnWYKzW5lmsvuOvc0F4BTaJJpw6Tc9pm948FkCk0qpnyYTGXo7G9GzfQpNKnQmabQSNtUq+sRPiO9frmu1+AtqsV58rvNi3Ll8757gbu8m1AGAMU5ctuFAff1oItQBgBFQrn2OS1pqK/DGccdgdra2oSXXXa01nuf3hfeC9uXm5ZlxMLN2Ln46kO+ru2RNSPwRERERHR44JtY29apX+RERERERNTZcAQ+C/g8dsK0mYAyhUaaFpOKb4nDypP30bA8/8Vj8PWx9tS71Ib2tbT05L3WblhJrAlG3esYFsoAIKxEALQISQRBJZ1A60ezMA1nb0NIrPtZo7u8pkmuq03DkZIdNGpaibT9laky4ZYGsby9U2BM/70t1E/FFBrTUR25jeSn4Wh906bhSEM2ahyycmyYTKnQSNM1TI7FVDBdnsl0FCnhIxXtGhOuM9p1VNseahqRQJ+GI7SrXKNjSj88wlQQLbnFZN+a1PUr01H8Xvm8l67n2rXYr3yut3c6ViCi3S+4yxqF/h5KHIFvG0fgiYiIiIiyCEfgiYiIiCijcAS+bRyBJyIiIiLKIhyBJyIiIqKM4sRiaRyBT8W7jg8tjsATEREREWURjsBngaZwFDjgBT9R5an5HOEJee0lDiZJMVK6Sltt+Dzucp8UQ2DYDy1xQEqc0dJfTF6g1BSW2zDph5Y2o7UREvotpc0AwCd7m1xlLc1hsW5EWZegUL+lUW6juUF+kVNL7WeuMi1tJhaW10VikixjecxSaByDFBopsUarb5pkI9G2kck6xmLKughljpKYoiWKpGTgqoMTZySmaTrpSsnR2k3FS5gk2rXHJJ1GW562LtIhY0Pps61cX4Vro5RMAwBRcYka5VzxuNuQUmUAIOCVk2Xqhf5pL1HUEm6k/SJ8xKrCBu1mWgpNLBYF0jQCH+MceCIiIiIi6kgcgSciIiKijMIUmrZxBJ6IiIiIKItwBJ6IiIiIMgpH4NvGEXgiIiIioizCEXgiIiIiyizRKBw7TSPl0ewfgecNfBYIRWLwHBCh5TOIDNNiGrV4SYkWhaiR4qm0iDIt0iwsZNVpcZZSZGRYiTMzi5GU62pRYlIEpFZXiwKVIiN31jSLdetqWtzL06IelWjIpto6dxv7qsW64cZasTwWkduW6DGLyR+PYnyjEpuoLc8xuHjHlPhGqW2P12/UD5MoShty25JYRI6iNIrP1BpPwfe26Ypk1Eixh1HD65plEHmrMYmuTNc2UuNBlWuxxFZSGk3iJbWgR5N4SSlaEpDjJR1LiaeMym1YwmUtqKxfvVIuRUb6PfIJ5G+RoyilNrQYSZPjyyf0I5IB8a6UPN7AExEREVFGcZz05cA7TvaPwHMOPBERERFRFuEIPBERERFlFCcWS98IfEpeKX1ocQSeiIiIiCiLcASeiIiIiDKKE0vjHPhOkAPPG/gsEI7G4D3gSflgpP1pCFElcUBKrdESXbRUGImWnCM9YQ/IKS1aP4IR94koJdMAerJMo1Be2ySnq9Qo5Q1Bd4pAQ4tct15JHGgSypsa5ESRpjp34kzd3iaxbvNn28Xylto9rrJQozuZBtAveLbPnY5ia+kvBhdNLR0FcG/TdKXbAGYJN9r6maTQmGw7NUFGScOR9pUmBsN0mg4UM0zLSEWfHbiXqaWuaNL2rb2yPaRUEtN0G2kdY9oGNUj2sWNKYo2yTaV+aKe39ICitt6WkkLjCOd9TFk/LclGSiZrUpLJGoLyuSl9VhTn+cS6BTnuW7p8v3yblyMk9TQ3yZ81lJl4A09EREREGWX/HPj0/NXLOfBERERERNShOAJPRERERBmFc+DbxhF4IiIiIqIswhF4IiIiIsooHIFvG2/gs8BnTWHkWJ8/HZ7rl9Mhcrzu8hyvfJDm+uQ28oRyj2HoTUxIuNGCDzyQG/cJC5XaBQBbSM7RaEk2zUIyQIOSFFPbrKTQCIkzWuJAfaP8tH9zvbu8UUib2V/e4i7bs1Ws27Jvl1gebm4QyyVa4okTda9jVCgDUpVCI9T1JF8XADxCSotlaw81yfvb9rqTIEwSawC5345SNyZsO9O0H6lcS6bR+ixtJZN9pfUjnVLxuJrpOqajXSlVpi0mm1lN1DFpw+BabLouUv+0PkufCRHl/NbaCAeFc0X5MPQ0y5MZmj3u8joh/QUAdvvkco9QPxCQb92ke4MuQjLN/rru8lBT8p8HdOjxBp6IiIiIMkosFoXFEXgV58ATEREREWURjsATERERUUZxojHAStMIvPLyrWzCEXgiIiIioizCEXgiIiIiyiiOk8YUGif758DzBj4LRGMOolqMywFyhKfVC5TEGiltRisPKE/Na6kw4ai7XEt/aYnIX2M1hNwJMJ82yckttU3ulBAtQSaoLK857D6ZpWSa/eVy2/XCMpuVfrQ0Kkk2Ne5kmfq9NWLdps+2u5enpM1ElLSZTH6QxyiFxjAhJBZ2H0umbUgJMlK6TVtti0k2WmKNUB5T0ndsZb/aEfd62xG5z7ayLqmQCced8f5OUwqNUR8M05bENtK4HpnStpRwo6bsaMsTkmw6OjnHuA2xrtw3j5CQEw02ypUpI/EGnoiIiIgyihOLpm8OfAYMIrQX58ATEREREWURjsATERERUUbhCHzbOAJPRERERJRFOAJPRERERBmFI/Bt4w18BnP+L+Ul2JSYIOKNyk/jN0fciRa2kkIDJYXG8brLI175iXctGEdMoVESa7RUmCYh6aW5WU6haWly1w0GzVJoQkIKTUhJoQmH5bbDLe76EaUfkRZ5XaJBdwpNLNQs1o2F3XWdSFCs60Tl5WX0RcwxSLQwqavVj5m24f4C04FyUigJGg6E49FWvhi13G04Wp8d5SUlUj+0OLU0xqxlwnFnnEIjbP+OlpoUmvR98Z4pKTRIUwqNk4I2tH44KUihkfqnpdDA464bDTbtb0f5vO5w0bB2RU1J29mON/AZrL6+HgAwf/yZh7gnREREdDior69HUVHRIVu+3+9HaWkpqjf+Ma3LKS0thd+fvrjcdLOcjPlTi74oFothx44d6NKli/iXPB0adXV16NevH7Zt24bCwsJD3R06CNyH2Y/7MLtx/2Uex3FQX1+PPn36wE7jNzXJaGlpQSgkf3OcKn6/Hzk5OWldRjpxBD6D2baNvn37HupukKKwsJAfPFmO+zD7cR9mN+6/zHIoR94PlJOTk9U31x2BKTRERERERFmEN/BERERERFmEN/BEhgKBAObOnYtAIHCou0IHifsw+3EfZjfuP6L24UOsRERERERZhCPwRERERERZhDfwRERERERZhDfwRERERERZhDfwdFj48MMP8Z3vfAc9evRAYWEhRo4cidWrVyfUsSzL9fPMM88k1Hn55Zdx6qmnIhAI4Oijj8bChQtdy7r//vtx5JFHIicnB8OHD8ebb76Z8PuWlhZMnToV3bt3R0FBAcaNG4ddu3Yl1Nm6dSvGjBmDvLw89OzZEz/96U8RiURSszGyVDL7MJntxn14aLz88sviOWZZFt566y0AwJYtW8Tfv/766wltLV68GMcddxxycnJw0kkn4fnnn0/4veM4mDNnDnr37o3c3FyMHj0a//73vxPq7N27F5dccgkKCwtRXFyMiRMnoqGhIaHOv/71L3z9619HTk4O+vXrh9tuuy0NWyZ7JLMPgeS2G/chUTs5RIeBY445xjn//POdf/7zn86HH37o/OhHP3Ly8vKcnTt3xusAcB577DFn586d8Z/m5ub47//73/86eXl5TmVlpbNx40bn3nvvdTwej7N8+fJ4nWeeecbx+/3Oo48+6mzYsMGZNGmSU1xc7OzatSte56qrrnL69evnrFy50nn77bed008/3RkxYkT895FIxDnxxBOd0aNHO++++67z/PPPOz169HBmzZqV5q2U2b5sHyaz3bgPD51gMJhwbu3cudO58sornQEDBjixWMxxHMfZvHmzA8B56aWXEuqFQqF4O//4xz8cj8fj3Hbbbc7GjRud2bNnOz6fz3nvvffidX796187RUVFzpIlS5x//vOfzre//W1nwIABCefzeeed5wwePNh5/fXXnVdffdU5+uijnfHjx8d/X1tb6/Tq1cu55JJLnPXr1zt/+MMfnNzcXOe3v/1tB2ytzJTMPkxmu3EfErUfb+Cp09uzZ48DwHnllVfiZXV1dQ4AZ8WKFfEyAM6f//xntZ3rrrvOOeGEExLKLrroIqe8vDz+38OGDXOmTp0a/+9oNOr06fP/t3fvMW1WbxzAvy20lcq6ltKLcyEZiQPHjCBI1zD9wxGI0U1c4gWzGXDGLcPsj11kxswZFucSpjEamUa56KIuotERZVMuWwBFZM2qTDpi1MXMibvQjik4Ln1+fxje8Mpl/dniKPt+Ev7oOc973vOeZ5cnJ28PC+SFF14QEZFAICA6nU5qa2uVGJ/PJwCkvb1dRETq6+tFq9VKb2+vErNv3z4xmUxy+fLl//Pp54ZQchjKujGHs8fQ0JDYbDYpKytT2sYK+OPHj0953YMPPij33HOPqs3lcsn69etFRCQYDIrT6ZTy8nKlPxAIiMFgkPfff19ERLq7uwWAdHZ2KjGHDh0SjUYjv/76q4iIVFRUiMViUeWrtLRUUlJS/v1DzzGT5TCUdWMOicLHV2hozrNarUhJScE777yDP//8EyMjI3jjjTdgt9uRmZmpii0pKUFiYiKys7NRVVUFGXfKant7O3Jzc1Xx+fn5aG9vBwAMDQ3B4/GoYrRaLXJzc5UYj8eD4eFhVUxqaiqSkpKUmPb2dtxyyy1wOByq+/T39+P777+P0KpEl1ByGMq6MYezR11dHS5cuIDi4uIJfatWrYLdbsfy5ctRV1en6rtSDn/++Wf09vaqYubPnw+Xy6XKj9lsRlZWlhKTm5sLrVaLjo4OJebOO++EXq9X3aenpwd+vz/Mp58bJsthKOvGHBKFL/ZqT4Bopmk0GjQ2NqKgoADz5s2DVquF3W7H4cOHYbFYlLiysjLcddddMBqN+OKLL7Bx40b88ccf2LRpEwCgt7dXVZABgMPhQH9/PwYHB+H3+zE6OjppzMmTJ5Ux9Ho9zGbzhJje3t5p7zPWdy0KJYehrBtzOHtUVlYiPz8fCxcuVNri4+Px4osvIicnB1qtFh999BEKCgrwySefYNWqVQCmXtvxaz/WNl2M3W5X9cfGxiIhIUEVs2jRogljjPWN/7fjWjVZDkNZN+aQKHzcgaeotX379im/UDX2c/LkSYgISkpKYLfb0draim+++QYFBQVYuXIlfvvtN2W8HTt2ICcnBxkZGSgtLcVTTz2F8vLyq/iEc1+kc0j/vVBzON7p06fx+eefY926dar2xMREbN68GS6XC7fffjv27NmDNWvW8O/hDItkDonov8EdeIpaW7ZsQVFR0bQxycnJaG5uxqeffgq/3w+TyQQAqKioQENDA95++21s37590mtdLhd27dqFy5cvw2AwwOl0Tjhp5Pfff4fJZEJcXBxiYmIQExMzaYzT6QQAOJ1ODA0NIRAIqHZw/xnzz1NPxsYci5krIpnDUNaNOYy8UHM4XnV1NaxWq7KrPh2Xy4WGhgbl81Q5HL/2Y2033HCDKiY9PV2JOXv2rGqMkZER9PX1XfHPyvh7zBWRzGEo68YcEoWPO/AUtWw2G1JTU6f90ev1GBgYAPD3u8zjabVaBIPBKcf3er2wWCwwGAwAALfbjaamJlVMQ0MD3G43AECv1yMzM1MVEwwG0dTUpMRkZmZCp9OpYnp6evDLL78oMW63G11dXar/nBoaGmAymbBkyZL/e51ms0jmMJR1Yw4jL9QcjhERVFdX49FHH4VOp7vi+F6vV1XEXSmHixYtgtPpVMX09/ejo6NDlZ9AIACPx6PENDc3IxgMwuVyKTEtLS0YHh5W3SclJWXOvXoRyRyGsm7MIVEEXNWv0BL9B86dOydWq1VWr14tXq9Xenp6ZOvWraLT6cTr9YqISF1dnbz55pvS1dUlP/zwg1RUVIjRaJRnn31WGWfsCMJt27aJz+eT1157bdIjCA0Gg9TU1Eh3d7c88cQTYjabVaeRbNiwQZKSkqS5uVmOHTsmbrdb3G630j92BGFeXp54vV45fPiw2Gy2a/oIwlByGMq6MYdXX2NjowAQn883oa+mpkbee+898fl84vP55PnnnxetVitVVVVKzJdffimxsbGyd+9e8fl8snPnzkmPIDSbzXLw4EH57rvv5L777pv0CMKMjAzp6OiQtrY2uemmm1RHEAYCAXE4HLJ27Vo5ceKEHDhwQIxGI48glOlzGMq6MYdE4WMBT9eEzs5OycvLk4SEBJk3b54sW7ZM6uvrlf5Dhw5Jenq6xMfHy/XXXy+33nqrvP766zI6Oqoa58iRI5Keni56vV6Sk5Olurp6wr1effVVSUpKEr1eL9nZ2fL111+r+gcHB2Xjxo1isVjEaDTK/fffrzqPXkTk1KlTcvfdd0tcXJwkJibKli1bZHh4OHILEoWulEOR0NaNOby6CgsLVWfmj1dTUyM333yzGI1GMZlMkp2drTquc8wHH3wgixcvFr1eL2lpafLZZ5+p+oPBoOzYsUMcDocYDAZZsWKF9PT0qGIuXLgghYWFEh8fLyaTSYqLi+XSpUuqmG+//VaWL18uBoNBbrzxRtmzZ0+YTz83TJdDkdDWjTkkCo9GZNw5eURERERENKvxHXgiIiIioijCAp6IiIiIKIqwgCciIiIiiiIs4ImIiIiIoggLeCIiIiKiKMICnoiIiIgoirCAJyIiIiKKIizgiYiIiIiiCAt4IqI5oLKyEnl5eWGNcf78edjtdpw+fTpCsyIiopnA38RKRBTl/vrrLyQnJ6O2thY5OTlhjbV161b4/X5UVlZGaHZERBRp3IEnIopyH374IUwmU9jFOwAUFxfj3XffRV9fXwRmRkREM4EFPBHRLHHu3Dk4nU7s3r1bafvqq6+g1+vR1NQ05XUHDhzAypUrVW1FRUUoKCjA7t274XA4YDabUVZWhpGREWzbtg0JCQlYuHAhqqurVdelpaVhwYIF+PjjjyP7cEREFDEs4ImIZgmbzYaqqio899xzOHbsGC5duoS1a9fiySefxIoVK6a8rq2tDVlZWRPam5ubcebMGbS0tOCll17Czp07ce+998JisaCjowMbNmzA+vXrJ7zznp2djdbW1og/HxERRQbfgScimmVKSkrQ2NiIrKwsdHV1obOzEwaDYdLYQCAAi8WClpYW3HHHHUp7UVERjh49ip9++gla7d97NampqbDb7WhpaQEAjI6OYv78+Xjrrbfw8MMPK9du3rwZx48fx5EjR2bwKYmI6N+KvdoTICIitb1792Lp0qWora2Fx+OZsngHgMHBQQDAddddN6EvLS1NKd4BwOFwYOnSpcrnmJgYWK1WnD17VnVdXFwcBgYGwn0MIiKaIXyFhoholvnxxx9x5swZBINBnDp1atpYq9UKjUYDv98/oU+n06k+azSaSduCwaCqra+vDzab7d9NnoiIZhwLeCKiWWRoaAhr1qzBQw89hF27duHxxx+fsEM+nl6vx5IlS9Dd3R2xOZw4cQIZGRkRG4+IiCKLBTwR0SzyzDPP4OLFi3jllVdQWlqKxYsX47HHHpv2mvz8fLS1tUXk/gMDA/B4PGH/UigiIpo5LOCJiGaJo0eP4uWXX8b+/fthMpmg1Wqxf/9+tLa2Yt++fVNet27dOtTX1+PixYthz+HgwYNISkpSfSGWiIhmF55CQ0Q0BzzwwAO47bbb8PTTT4c1zrJly7Bp0yY88sgjEZoZERFFGnfgiYjmgPLycsTHx4c1xvnz57F69WoUFhZGaFZERDQTuANPRERERBRFuANPRERERBRFWMATEREREUURFvBERERERFGEBTwRERERURRhAU9EREREFEVYwBMRERERRREW8EREREREUYQFPBERERFRFGEBT0REREQURVjAExERERFFkf8BDZH15Oc76lIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "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** \u2014 the lightest option, ideal for CPU." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32m2026-04-25 12:36:15.361\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mThe loaded datastore contains the following features:\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.361\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m state : u100m v100m r2m t2m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.361\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m forcing : swavr0m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.361\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m static : lsm orography\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.361\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mWith the following splits (over time):\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.367\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m train : 2022-04-01T00:00 to 2022-04-04T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.370\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m val : 2022-04-04T00:00 to 2022-04-07T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.373\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m test : 2022-04-07T00:00 to 2022-04-10T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:15.381\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcreate_graph\u001b[0m:\u001b[36m234\u001b[0m - \u001b[1mWriting graph components to tests/datastore_examples/mdp/danra_100m_winds/graph/1level\u001b[0m\n", + "/home/sharkyi/myenv/lib/python3.12/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": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph files created (8): ['tests/datastore_examples/mdp/danra_100m_winds/graph/1level/', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2g_features.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2g_edge_index.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/g2m_features.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2m_features.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/mesh_features.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/g2m_edge_index.pt', 'tests/datastore_examples/mdp/danra_100m_winds/graph/1level/m2m_edge_index.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": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u2705 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\"\u2705 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(\"\u274c No graph .pt files found \u2014 check the create_graph output above.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2026-04-25 12:36:17.560\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mThe loaded datastore contains the following features:\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:17.561\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m state : u100m v100m r2m t2m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:17.561\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m forcing : swavr0m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:17.561\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m static : lsm orography\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:17.562\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mWith the following splits (over time):\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:17.568\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m train : 2022-04-01T00:00 to 2022-04-04T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:17.571\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m val : 2022-04-04T00:00 to 2022-04-07T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:17.575\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\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 graph saved to graph_viz.html \u2014 open in a browser.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import HTML\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_extent = datastore.get_xy_extent(category=\"state\")\n", + "grid_xy_max_span = max(\n", + " grid_xy_extent[1] - grid_xy_extent[0],\n", + " grid_xy_extent[3] - grid_xy_extent[2],\n", + ")\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", + "fig.write_html(\"graph_viz.html\", include_plotlyjs=\"cdn\")\n", + "print(\"Full interactive graph saved to graph_viz.html \u2014 open in a browser.\")\n", + "fig.data = tuple(t for t in fig.data if t.name in {\"M2M\", \"Mesh nodes\"})\n", + "display(HTML(fig.to_html(include_plotlyjs=\"cdn\", full_html=False)))" + ] + }, + { + "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 \u2014 compatible with non-hierarchical graphs |\n", + "| `--graph` | `1level` | Must match the graph name used in the previous step |\n", + "| `--epochs` | `1` | Minimal run \u2014 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 \u2014 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": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Seed set to 42\n", + "\u001b[32m2026-04-25 12:36:21.693\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mThe loaded datastore contains the following features:\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.693\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m state : u100m v100m r2m t2m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.693\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m forcing : swavr0m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.693\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m static : lsm orography\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.693\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mWith the following splits (over time):\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.700\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m train : 2022-04-01T00:00 to 2022-04-04T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.703\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m val : 2022-04-04T00:00 to 2022-04-07T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.706\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m test : 2022-04-07T00:00 to 2022-04-10T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.768\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mLoaded graph with 8409 nodes (7680 grid, 729 mesh)\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.771\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mEdges in subgraphs: m2m=5512, g2m=12716, m2g=30720\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:21.776\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36msetup_training_logger\u001b[0m:\u001b[36m514\u001b[0m - \u001b[1mWandb resume mode: None (id: None)\u001b[0m\n", + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "\ud83d\udca1 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", + "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[33mWARNING\u001b[0m The anonymous setting has no effect and will be removed in a future version.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.26.1\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: W&B syncing is set to \u001b[1m`offline`\u001b[0m in this directory. Run \u001b[1m`wandb online`\u001b[0m or set \u001b[1mWANDB_MODE=online\u001b[0m to enable cloud syncing.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1mwandb/offline-run-20260425_123622-6cu1lx7j\u001b[0m\n", + "\u250f\u2501\u2501\u2501\u2533\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2533\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2533\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2533\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2533\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2513\n", + "\u2503\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u2503\u001b[1;35m \u001b[0m\u001b[1;35mName \u001b[0m\u001b[1;35m \u001b[0m\u2503\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m\u2503\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m\u2503\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m\u2503\u001b[1;35m \u001b[0m\u001b[1;35mFLOPs\u001b[0m\u001b[1;35m \u001b[0m\u2503\n", + "\u2521\u2501\u2501\u2501\u2547\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2547\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2547\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2547\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2547\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2529\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m\u2502 grid_embedder \u2502 Sequential \u2502 5.2 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m1\u001b[0m\u001b[2m \u001b[0m\u2502 g2m_embedder \u2502 Sequential \u2502 4.5 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m2\u001b[0m\u001b[2m \u001b[0m\u2502 m2g_embedder \u2502 Sequential \u2502 4.5 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m3\u001b[0m\u001b[2m \u001b[0m\u2502 g2m_gnn \u2502 InteractionNet \u2502 29.2 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m4\u001b[0m\u001b[2m \u001b[0m\u2502 encoding_grid_mlp \u2502 Sequential \u2502 8.4 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m5\u001b[0m\u001b[2m \u001b[0m\u2502 m2g_gnn \u2502 InteractionNet \u2502 29.2 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m6\u001b[0m\u001b[2m \u001b[0m\u2502 output_map \u2502 Sequential \u2502 4.4 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m7\u001b[0m\u001b[2m \u001b[0m\u2502 mesh_embedder \u2502 Sequential \u2502 4.5 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m8\u001b[0m\u001b[2m \u001b[0m\u2502 m2m_embedder \u2502 Sequential \u2502 4.5 K \u2502 train \u2502 0 \u2502\n", + "\u2502\u001b[2m \u001b[0m\u001b[2m9\u001b[0m\u001b[2m \u001b[0m\u2502 processor \u2502 Sequential_43c83b \u2502 58.4 K \u2502 train \u2502 0 \u2502\n", + "\u2514\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\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: 83 \n", + "\u001b[1mModules in eval mode\u001b[0m: 0 \n", + "\u001b[1mTotal FLOPs\u001b[0m: 0 \n", + "\u001b[2K/home/sharkyi/myenv/lib/python3.12/site-packages/pytorch_lightning/utilities/_py\n", + "tree.py:21: `isinstance(treespec, LeafSpec)` is deprecated, use \n", + "`isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n", + "\u001b[2K/home/sharkyi/myenv/lib/python3.12/site-packages/pytorch_lightning/trainer/conne\n", + "ctors/data_connector.py:434: The 'val_dataloader' does not have many workers \n", + "which may be a bottleneck. Consider increasing the value of the `num_workers` \n", + "argument` to `num_workers=15` in the `DataLoader` to improve performance.\n", + "\u001b[2K/home/sharkyi/myenv/lib/python3.12/site-packages/pytorch_lightning/utilities/_py00\u001b[0m \u001b[2;4m1.81it/s\u001b[0m [2;4m0.00it/s\u001b[0m \n", + "tree.py:21: `isinstance(treespec, LeafSpec)` is deprecated, use \n", + "`isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n", + "\u001b[2K/home/sharkyi/myenv/lib/python3.12/site-packages/pytorch_lightning/trainer/conne0m \u001b[2;4m1.81it/s\u001b[0m \n", + "ctors/data_connector.py:434: The 'train_dataloader' does not have many workers \n", + "which may be a bottleneck. Consider increasing the value of the `num_workers` \n", + "argument` to `num_workers=15` in the `DataLoader` to improve performance.\n", + "\u001b[2K/home/sharkyi/myenv/lib/python3.12/site-packages/torch/autograd/graph.py:869: [2;4m0.00it/s\u001b[0m \u001b[3mv_num: lx7j\u001b[0m\n", + "UserWarning: CUDA initialization: CUDA unknown error - this may be due to an \n", + "incorrectly set up environment, e.g. changing env variable CUDA_VISIBLE_DEVICES \n", + "after program start. Setting the available devices to be zero. (Triggered \n", + "internally at /pytorch/c10/cuda/CUDAFunctions.cpp:119.)\n", + " return Variable._execution_engine.run_backward( # Calls into the C++ engine \n", + "to run the backward pass\n", + "\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u001b[0m\u001b[90m\u257a\u001b[0m\u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 1/6 \u001b[2m0:00:00 \u2022 -:--:--\u001b[0m \u001b[2;4m0.00it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[90m\u257a\u001b[0m\u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 2/6 \u001b[2m0:00:01 \u2022 0:00:03\u001b[0m \u001b[2;4m1.71it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[90m\u257a\u001b[0m\u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 3/6 \u001b[2m0:00:02 \u2022 0:00:02\u001b[0m \u001b[2;4m1.65it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[90m\u257a\u001b[0m\u001b[90m\u2501\u2501\u2501\u2501\u2501\u001b[0m 4/6 \u001b[2m0:00:02 \u2022 0:00:02\u001b[0m \u001b[2;4m1.59it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[90m\u257a\u001b[0m\u001b[90m\u2501\u2501\u001b[0m 5/6 \u001b[2m0:00:03 \u2022 0:00:01\u001b[0m \u001b[2;4m1.56it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + " \u001b[3m1.659 \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + " \u001b[3m1.659 \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + " \u001b[3m1.659 \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + " \u001b[3m1.659 \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + " \u001b[3m1.659 \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + " \u001b[3m1.659 \u001b[0m\n", + " \u001b[3mtrain_loss_epoch: \u001b[0m\n", + " \u001b[3m2.989 \u001b[0m`Trainer.fit` stopped: `max_epochs=1` reached.\n", + "\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2K\u001b[1A\u001b[2KEpoch 0/0 \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 6/6 \u001b[2m0:00:03 \u2022 0:00:00\u001b[0m \u001b[2;4m1.89it/s\u001b[0m \u001b[3mv_num: lx7j \u001b[0m\n", + " \u001b[3mtrain_loss_step: \u001b[0m\n", + " \u001b[3m1.659 \u001b[0m\n", + " \u001b[3mtrain_loss_epoch: \u001b[0m\n", + " \u001b[3m2.989 \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 wandb/offline-run-20260425_123622-6cu1lx7j\u001b[0m\n" + ] + } + ], + "source": [ + "os.environ[\"WANDB_MODE\"] = \"offline\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\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 1 \\\n", + " --val_steps_to_log 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Checkpoints found: ['saved_models/train-graph_lam-2x64-04_25_11-0791/min_val_loss.ckpt', 'saved_models/train-graph_lam-2x64-04_25_11-0791/last.ckpt', 'saved_models/train-graph_lam-2x64-04_03_18-7348/min_val_loss.ckpt', 'saved_models/train-graph_lam-2x64-04_03_18-7348/last.ckpt', 'saved_models/train-graph_lam-2x64-04_25_11-7489/min_val_loss.ckpt', 'saved_models/train-graph_lam-2x64-04_25_11-7489/last.ckpt', 'saved_models/train-graph_lam-2x64-04_25_12-5124/min_val_loss.ckpt', 'saved_models/train-graph_lam-2x64-04_25_12-5124/last.ckpt', 'saved_models/train-graph_lam-2x64-04_25_11-8610/min_val_loss.ckpt', 'saved_models/train-graph_lam-2x64-04_25_11-8610/last.ckpt']\n" + ] + } + ], + "source": [ + "# Find the checkpoint saved during training\n", + "ckpts = glob.glob(\"saved_models/**/*.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": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u2705 Using checkpoint: saved_models/train-graph_lam-2x64-04_25_12-5124/last.ckpt\n" + ] + } + ], + "source": [ + "ckpts = glob.glob(\"saved_models/**/*.ckpt\", recursive=True)\n", + "\n", + "if not ckpts:\n", + " print(\"\u274c No checkpoint found \u2014 make sure the training cell above completed without errors.\")\n", + " ckpt_path = None\n", + "else:\n", + " ckpt_path = max(ckpts, key=os.path.getmtime)\n", + " print(f\"\u2705 Using checkpoint: {ckpt_path}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Seed set to 42\n", + "\u001b[32m2026-04-25 12:36:46.405\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mThe loaded datastore contains the following features:\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.405\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m state : u100m v100m r2m t2m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.406\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m forcing : swavr0m\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.406\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m static : lsm orography\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.406\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mWith the following splits (over time):\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.413\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m train : 2022-04-01T00:00 to 2022-04-04T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.416\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m val : 2022-04-04T00:00 to 2022-04-07T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.418\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1m test : 2022-04-07T00:00 to 2022-04-10T00:00\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.482\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mLoaded graph with 8409 nodes (7680 grid, 729 mesh)\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.484\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36mlog_on_rank_zero\u001b[0m:\u001b[36m457\u001b[0m - \u001b[1mEdges in subgraphs: m2m=5512, g2m=12716, m2g=30720\u001b[0m\n", + "\u001b[32m2026-04-25 12:36:46.490\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mneural_lam.utils\u001b[0m:\u001b[36msetup_training_logger\u001b[0m:\u001b[36m514\u001b[0m - \u001b[1mWandb resume mode: None (id: None)\u001b[0m\n", + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "\ud83d\udca1 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", + "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[33mWARNING\u001b[0m The anonymous setting has no effect and will be removed in a future version.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.26.1\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: W&B syncing is set to \u001b[1m`offline`\u001b[0m in this directory. Run \u001b[1m`wandb online`\u001b[0m or set \u001b[1mWANDB_MODE=online\u001b[0m to enable cloud syncing.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1mwandb/offline-run-20260425_123647-3nwq2t87\u001b[0m\n", + "Restoring states from the checkpoint path at saved_models/train-graph_lam-2x64-04_25_12-5124/last.ckpt\n", + "/home/sharkyi/myenv/lib/python3.12/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:566: The dirpath has changed from '/home/sharkyi/Desktop/1/neural-lam/saved_models/train-graph_lam-2x64-04_25_12-5124' to '/home/sharkyi/Desktop/1/neural-lam/saved_models/eval-test-graph_lam-2x64-04_25_12-0939', 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 saved_models/train-graph_lam-2x64-04_25_12-5124/last.ckpt\n", + "/home/sharkyi/myenv/lib/python3.12/site-packages/pytorch_lightning/utilities/_pytree.py:21: `isinstance(treespec, LeafSpec)` is deprecated, use `isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n", + "/home/sharkyi/myenv/lib/python3.12/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=15` in the `DataLoader` to improve performance.\n", + "\u001b[2K\u250f\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2533\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u25135/5 \u001b[2m0:00:22 \u2022 0:00:00\u001b[0m \u001b[2;4m1.92it/s\u001b[0m [2;4m1.69it/s\u001b[0m \n", + "\u2503\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m\u2503\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m\u2503\n", + "\u2521\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2547\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2529\n", + "\u2502\u001b[36m \u001b[0m\u001b[36m test_loss_unroll1 \u001b[0m\u001b[36m \u001b[0m\u2502\u001b[35m \u001b[0m\u001b[35m 2.47532057762146 \u001b[0m\u001b[35m \u001b[0m\u2502\n", + "\u2502\u001b[36m \u001b[0m\u001b[36m test_mean_loss \u001b[0m\u001b[36m \u001b[0m\u2502\u001b[35m \u001b[0m\u001b[35m 5.073057174682617 \u001b[0m\u001b[35m \u001b[0m\u2502\n", + "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n", + "\u001b[2KTesting \u001b[35m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m 5/5 \u001b[2m0:00:22 \u2022 0:00:00\u001b[0m \u001b[2;4m1.92it/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 wandb/offline-run-20260425_123647-3nwq2t87\u001b[0m\n" + ] + } + ], + "source": [ + "os.environ[\"WANDB_MODE\"] = \"offline\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\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 1 \\\n", + " --val_steps_to_log 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMSE scorecard: wandb/latest-run/files/media/images/test_rmse_32_f471271df024429b645d.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Showing 2 of 32 prediction plot(s):\n", + " wandb/latest-run/files/media/images/r2m_example_1_10_9ad68b084d5b87e844ce.png\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABRQAAAJYCAYAAAAT22pxAAEAAElEQVR4nOzdd5xU1fk/8M8t02d7Xzqo9CCiVGnSNALfaNQYW6whlkSNhWjsiS3G/GLvLVGjSTRRNAooRRAUVLAhCNLLdrbce+f28/tjdmZ3YdndmbmzuzP7vF+vfSmzc889c3fKM+ec5zkcY4yBEEIIIYQQQgghhBBCOoDv6g4QQgghhBBCCCGEEEJSBw0oEkIIIYQQQgghhBBCOowGFAkhhBBCSELq6+u7ugvdgmVZUBSlq7tBCCGEEJJ0NKBICCGEkB7pm2++wZVXXolBgwYhLy8Pubm5OPnkk7F8+fKu7lpSVVZW4q9//StmzZqF/v37o6CgAEcffTSuuuoqHDhwIOb2HnvsMfz85z9vcZuu6/jDH/6AoUOHIicnB4WFhTj//POxd+/eFve77LLLUFBQAI7jcMcddyTysLoFTdMwZswYrF69uqu7QgghhBCSVDSgSAghhJAep6KiAiNHjsQXX3yBJUuWoLq6Glu2bIHH48GMGTPwr3/9q6u7iBdffBEcx2HFihWOtvvuu+/i2muvxdSpU7FlyxZUVlbiH//4B9566y2MHTsWtbW1HW7rgQcewEMPPYRnn302eptlWTj11FPx4IMP4qGHHkJNTQ02bNiAH374ARMnTkR5eXn0vs888wzWr1/v5MPrUn6/H08++STmzZuHNWvWdHV3CCGEEEKShgYUCSGEENLj2LYNIDxoN2jQIABAQUEBXnzxRfj9flx77bVgjHVlF5Nq7NixuOWWW+DxeAAAxx9/PH7/+99j7969+Pe//92hNr766ivcdNNNePjhh1FSUhK9/R//+Ac++OADXHvttZg9ezY4jkOvXr3w7LPPYs+ePbjtttuS8pi6i6lTp+Liiy/GeeedB1VVu7o7hBBCCCFJQQOKhBBCCOlxgsEg7rrrLgwePLjF7Tk5ORg8eDD27dsXV/pvKvjxj3+Ml19++bDb+/TpAwCoq6vrUDt33303hg4dipNPPrnF7f/73/8AANOnT29x+7Bhw1BaWop//OMf0DQtnq6njOuvvx47d+7E3//+967uCiGEEEJIUtCAIiGEEELSygcffIDi4mK43W70798f3377LWbOnImioiJwHIcLL7wQwWAQt956a6vH67oOjuOQlZXVantff/01pk6dipycHAwfPhzvvvsuAOCVV17BiBEjkJ2djdNOOw2VlZVxP4aTTz4ZV199NQDg9NNPR3FxMYqLix2p71hYWIijjz76sNu/+OILAMCJJ57YbhuhUAhvvfUWZsyYcdjvIo87Pz+/1XM3NDTg22+/bbXdxx9/HMOGDUNWVhYmTZqEDRs2HHYfxhgee+wx/OhHP0JRURGKi4tx1lln4fvvv4/e55133kFxcTEEQcC0adOit7/wwgsoLi6OPg8OvT1y/1WrVmHixInIy8trUd/xo48+wowZM9C7d2+UlJTguOOOw6233op9+/a16GNJSQmGDx+OV1999YjXkBBCCCEkldGAIiGEEELSysyZM1FWVoaJEydCkiTcdNNNePHFF1FWVoZzzz23zWPr6uqwdetWzJkzB4FAoNX2/vSnP+Htt99GRUUFhg4dip/+9Kd46aWXIMsyvvrqK6xbtw4rV66MDgjG4/3338dDDz0EAHjzzTdRVlaGsrKy6Kq/NWvWRAcZO/LT3mN+6aWXcP/99+OOO+7AuHHj2u3f+vXroWkahgwZctjvIgOJFRUVh/2uuroaALBr167Dfvfvf/8boVAIX331FXbt2gXLsnDyyScftprx8ssvxw033IA//elPKC8vx5YtW2CaJsaOHRsdqJw7dy7Kysqiqy4jLrroIpSVlR127sjtffr0we7du/HII4/gnXfeQVlZGaZOnQoA2Lx5M+bMmYMzzjgDu3fvxoEDB3DnnXfiT3/6E5YuXXpYm0OHDsXatWthmmar15AQQgghJJWJXd0BQgghhJBkqa6uxi233ILevXsDABYuXNhmKvOzzz4Ly7Jw9913H7G9hQsXRlcvXnXVVXjjjTfw+OOP49NPPwUAHHPMMZg7dy7++c9/gjEGjuMcflTAxIkTWx0Yi9WUKVOwevVqeL1e/PGPf8Svf/3rDh0XWQ3Y2mDl7Nmz8dprr2HJkiUtVgd+//330V2eZVk+7DhRFHHdddcBALKzs/HLX/4Sl1xyCdasWRMdSF29ejWeeuopXHnlldFU66ysLDz++OPo06cPrrzyyoQ3sdmzZw9WrVqF3NxcAOHUbkEQsHjxYqiqivPOOw88H56TnzdvHi666KLo86G5kpISaJqG3bt3Y+DAgQn1iRBCCCGku6EVioQQQghJW16vF2PHjo3+e+TIkZg9e3ar9922bRvuuOMO3HPPPTjuuONavY/f78eIESOi/y4tLQUAjBkzpsX9evfuDU3TEkp77gwfffQRZFnGf/7zHzzyyCM48cQTO9TnyErDyCrO5s477zxMmDABDz/8MN58800YhoHt27fjoosuiq5e9Pv9hx03ceLEFv+ODALv378/etvrr78OILwCsbni4mKccMIJWLlyZasrI2MxaNAg9OrVK/rvSZMmYfz48SgsLAQALFiwADt37oz+/sknn8Rpp512WDuRa1NVVZVQfwghhBBCuiMaUCSEEEJI2iooKOjQ/WpqanDqqafi3HPPxQ033HDE++Xl5bX4t9vtBnB4vcDI7YqixNLdLuHz+TBnzhy89NJLWLduHW688cZ2j9F1HUB4VeGhXC4XlixZgiuvvBK/+93vUFpaip/+9Ke44IILcN555wEAioqKDjvuSNfQMIzobdu2bQOAFrtKR0QGdyP3iVdk4PBQZ511Fi655BK89tprGDhwIMaPH4+//vWvqK2tbfX+kWsTuVaEEEIIIemEBhQJIYQQkrYiqaltqa+vx8knn4wxY8bg8ccfj6u9jpzHSU7WUIyYPHkyfD5fdJfmtkRWGDYf7GsuGAzi/vvvx/fff4/Kykps2LABCxYswIEDB8DzfItVnhGddQ1t227z90fqhyAIePbZZ7Ft2zbceeedqKmpwbXXXothw4Zh06ZNh90/MpDY2mpMQgghhJBURwOKhBBCCOmxFEXB3Llz0bt3b/ztb3+LDiZt2bIFDQ0NXdy7I4vUUOzoT3PPPfdcix2RIziOg8fjwcGDB9s9f2Q1YEfu29wXX3yBqVOntlpzsCMiu1M3T4OOiNx21FFHRW8TRfGwTVHiTYm2bRu2bWPgwIG49dZb8f333+OFF17AgQMHcO+99x52/8i1aZ4+TQghhBCSLmhAkRBCCCE9kqZp+MlPfoJgMIjXXnutRfruggUL8Pnnn3dh75pq8EUGxN5++208+eSTCbf797//HW+99dZht3/11Veora3F6NGj220jssIwsslKc6FQCD/60Y9QX1/f4vbVq1fj+++/x8KFC+PseTjtGADefffdFreXlZVh/fr1mDZtWouU5V69emHPnj0t7rt27dq4zn3XXXcdtmnNhRdeiLy8vFbTnvfu3Yv8/PxW07sJIYQQQlIdDSgSQgghpMcxTRNnnXUWVq5ciZEjR+Kee+7BHXfcEf1pvumGk8477zxwHNehlX1Dhw4FAGzatAm2beORRx7Bli1bHOnH3XffjbfeeguWZQEANmzYgHPPPRdutxv33Xdfu8ePGDECRUVF+PLLLw/7nWVZ+Prrr3HjjTdCVVUA4UG88847D9dddx3mzJkTd79PPPFELFiwAM8//zwWL14MAKirq8MVV1yBQCCARx99tMX9582bh927d+O1114DAOzYsSP6//F45ZVX8PHHHwMAGGN4+eWXUV1djbPPPvuw+27cuBGzZs2K+1yEEEIIId0aI4QQQghJIxs3bmRFRUXM5XIxnudZUVERO++881rcZ8OGDQxAmz/Lly8/YnsfffQRu++++1h+fj4DwAKBABs9ejRjjLHRo0ezQCDAALD8/Hx20003Rc87ZcoUVlhY2OHHcscdd7CSkhJWVFTE5syZw8rKyhK+Pps2bWILFy5kxx57LCsuLmbZ2dmstLSU/exnP2NffPFFh9u56aabWEFBAVMUpcXtuq6zX/7yl2zo0KHRtidNmsRee+21Vttofg2HDRvGGGNswYIFLCcnhwFgmZmZbMaMGdFjbNtmjzzyCBsxYgQrKChghYWF7IwzzmCbN28+rH1d19nChQtZ7969WWFhIZs/fz7bu3cvA8C8Xi8rKipiW7duZYsWLWJFRUWM53nmcrlYUVFRi78bY4xt27aNXXfddWzEiBGsuLiYFRcXswkTJrB//etfh513zZo1DAD78MMPO3w9CSGEEEJSCccYY10xkEkIIYQQ0pPs2bMHgwYNwvXXX4977rmnq7uTsNraWgwZMgTXXXddmztj90Qnn3wyBEE4LDWbEEIIISRd0IAiIYQQQkiSKYqCk08+GbquY8WKFfB6vV3dJUd8+umnmDdvHp577jnMmzevq7vTLSxcuBDvvvsuVq5ciby8vK7uDiGEEEJIUlANRUIIIYSQJPN6vTj77LOxfPnytBlMBIBx48Zh1apV+PDDD7u6K91CfX09Dh48iDVr1tBgIiGEEELSGq1QJIQQQgghhBBCCCGEdBitUCSEEEIIIYQQQgghhHQYDSgSQgghhBBCCCGEEEI6jAYUCSGEEEIIIYQQQgghHUYDioQQQgghhBBCCCGEkA6jAUVCCCGEEEIIIYQQQkiH0YAiIYQQQgghhBBCCCGkw2hAkRBCCCGEEEIIIYQQ0mE0oEgIIYQQQgghhBBCCOkwGlAkhBBCCCGEEEIIIYR0GA0oEkIc9eabb2L+/Pno3bs3CgsLkZWVhdGjR2PBggV46623oGlaV3fRMVdddRUKCgrAcRzuuOOONu97xx13wOfzobi4OPoTDAbBcRxyc3Nb3M5xHHbu3NkpjyHihRdeQHFxMQRBwLRp0zr13IQQQggh7VEUBcXFxcjKygLHccjKykJxcTEKCwvh9/sxatQoPPHEE2CMdUp/7r///mjcduGFF7b43eLFi5GdnY3Fixc7ft6ysjKUlpbi9ttvd7xtQgiJBQ0oEkIcIcsy5s+fj6uvvhoXXHABfvjhB1RUVKC8vBy33norFi9ejJ/85Cd45plnurqrjnn00Uexfv36Dt//Zz/7GcrKyqI/119/PYDwIGzz25PpxRdfBMdxWLFiRYvbL7roIpSVlaFPnz5JPT8hhBBCSDz8fj/Kysrw0EMPAQAeeughlJWVoaKiAmVlZRg3bhyuuOIK/Pa3v+2U/ixcuPCIcVt9fX30Jx4rVqwAx3F48cUXD/udpmmoq6tDdXV1XG0TQohTxK7uACEkPVx00UVYtmwZNm7ciKOOOip6u9frxemnn45hw4Zh1KhRXdhDQgghhBCSjjIzM/HYY4/h/fffx8MPP4xrrrkG/fr167L+nHnmmfjxj3+MQCDgeNv9+vVDZWUlfD6f420TQkgsaECREJKwDz/8EP/6179w7bXXthhMbG7IkCGYO3cuRLFnvu1cddVVMAyjQ/f97rvv0KtXryT3iBBCCCEkfbhcLhx33HHYs2cP1q1b16UDigCSMpgY4ff7k9Y2IYR0FKU8E0IS9vzzzwMA5s2b1+b93njjDfzqV78C0FQHJ1JHcOPGjbjooovQr18/cByH/v37R4/bunUrzj77bJSUlKCwsBAjRozAww8/3KJGzrRp06I1dZqn8w4fPjx6juZ1CYcPHx69//vvv4/f/OY36NevH/Ly8nDmmWeiqqrqsP5v27YNc+fORUZGBvr27Yvzzz+/w+km+fn5KCkp6dB9hwwZAsMw2r0+N998c6s1HC+77DLk5uYelipz8skn4+qrrwYAnH766dGajcuXLz+sDytWrMC4ceOQk5ODoUOH4tVXX+1Q3wkhhBBCuopt29H/FhcXw+12o3///vj2228xc+ZMFBUVHVbzcMmSJZgyZQpycnKQk5ODSZMm4a233jqs7YqKCpx77rnIzs5Gr169MH/+fOzateuw+y1cuPCItRUB4IMPPsD06dNRUFCAkpISHHvssbj22mvxww8/AAjHcaeffjoA4Oqrr47Ga3/729/w1ltvtXhch+pIzHzZZZe1iB8ff/xxDBs2DFlZWZg0aRI2bNgQyyUnhPRkjBBCEtS/f38GgJWXl8d87O23384AsGnTprHVq1czxhh76qmnWL9+/RhjjG3atInl5OSwn/zkJ6y2tpYxxth7773HfD4fu/TSS1u09cILLzAAbPny5a2eY8eOHa3ef9y4cWzp0qWMMca+/vprlp2dzebPn9/ivpWVlaykpISNGDGC7dq1i9m2zZYtW8bGjx/PALDbb7897sd+aH9bu8+Rrs+OHTtaPf/y5csZAPbCCy+0+piPdM5+/fqxAQMGsAsuuIDV19czwzDYFVdcwTiOY59//nnMj5EQQgghxEmRWObQGEdVVVZaWsoEQWB79uxhjDE2depUlpeXx+bNm8f27NnDbNtm5557LvvFL37BGGPslVdeYRzHsbvvvptpmsY0TWP33nsvA8Cee+65Fm2PHDmSlZaWsq+//poxxtjGjRvZ7NmzGYBoe821dvsrr7zCeJ5nd955J9N1ndm2zd58803mcrnY1VdfHb3fkeK4iKlTp0ZjwYhYYuZI/Dh8+HD25z//mRmGwWpqatgJJ5zACgsLmaqqrZ6XEEKaoxWKhJCERQpS5+TkxN3GKaecgkmTJgEI15257bbbAAC//vWv0dDQgCeeeAJZWVkAwivtLr74Yjz77LOHbS4Sj/Hjx2PmzJkAgBEjRmDu3Ll47733oOt69D73338/Dhw4gD/+8Y/o27cvOI7D9OnTceqppyZ8/o440vVJhr179+KBBx5ARkYGRFHEddddB8ZYq7P1hBBCCCFdraysDJdddhn279+PhQsXonfv3tHfVVdX45ZbbkHv3r3BcRwWLlyIc845B5Ik4corr8SECRNw8803w+12w+1243e/+x1OOOEELFy4EJqmAQCeffZZfP3117jxxhsxYsQIAMCoUaNw/vnnd7iPDQ0NuPLKK3Hcccfhtttug8vlAsdxOO2001pdyRireGLmSJwniiJycnKwYMECVFRUYM2aNQn3hxCS/mhAkRDiGNYsnSLinXfeiaZqZGZmYvjw4a0eO2XKlOj/5+Tk4OKLL0ZVVRWWLVuGMWPGoLi4uMX958+fDwD45z//mXC/J06c2OLfffr0gWEYqKysbPE4gHBg1tz06dMTPn9HtHZ9kuWoo45CYWFh9N+RoHz//v1JOychhBBCSCwi6cBFRUUYPnw4tm3bhpdeegl33313i/t5vV6MHTs2+u+RI0di9uzZWLx4MWprazF79uzD2j7hhBNQVVWFzz//HIAzceCSJUtQW1t7WBsAcOutt0bLAsUj3pi5tRgYoJiPENIxPXN3BEKIo4qLi7Fz507U1NQcFsTMnTs3uoKxf//+kGW51TaaD2BF/PDDD2CMtVp7sLS0FEC4rmGi8vPzW/zb7XYDQItNVHbs2IHs7Gx4PJ4W9z308SZLa9cnWTpyPQghhBBCutJDDz3UoZV9BQUFrd4eiSH/8pe/4IknnmjxO13XEQgEcODAAQDhOBA4PO6LJQ6MnC8SwzYXGciLV7wxM8V8hJBE0IAiISRhEydOxM6dO/HNN9/EPcDG88lbMB0p0N0V53ZKrH1s7zE7eS5CCCGEkO6qvbjmzjvvxDXXXNM5nQFalNTpahTzEUISQe8ghJCEXXTRRQCA//znP462O2jQIHAc12raReS2o48+OnqbKIbnSEzTbHHfioqKhPsyYMAA1NbWQlXVFrdHVl92lWQ+ZkIIIYSQdHXMMccAAPbt23fY73RdxwcffICGhgYA4TgQODzuiyUOjMSskVWPzUmShPLy8g63dahYY2ZCCHECDSgSQhI2c+ZM/PSnP8Vzzz2Hb7/91rF28/PzcdJJJ+GLL744LGB7++23AQBnnXVW9LZevXoBAPbs2dPivmvXrk24L/PmzQMALF68uMXtTmwKk4jCwkKIotjhxxwIBAA0DUC+/fbbePLJJ5PbSUIIIYSQbmbWrFnIycnBf//738PqgP/3v//F2WefHS11E4kD33///Rb3iyUOnD17NrKzs/Huu+8e9rsFCxbgt7/9bfTfh8ZrH3/88WG1IZuLNWYmhBAn0IAiIcQRL774IqZPn44ZM2bg1Vdfja7kMwwDy5cvx/z587Fr1y4MHjw4pnYfeeQRBINBXHHFFairqwMQHtR7/vnncemll2Lq1KnR+06YMAH5+fl4+umnUVtbC9M08eCDD7a6WUysbrzxRpSUlODWW2+NDt6tXLkSr7zySsJtJ8LtdmPOnDl45513ooO5H374IdavX9/q/YcOHQoA2LRpE2zbxiOPPIItW7Z0Wn8JIYQQQrqDYDCIJ598Etu3b8eNN96IUCgEIDwpe/XVV+Oee+6J1hS85JJLMGLECDzwwAPReOurr77CI488EtP5HnvsMWzatAn33HMPDMMAYwwvv/wyFi1ahIULF0bvO2jQILjdbmzatAkA8Pzzz+Ozzz5rs/1YYmZCCHEEI4QQh9i2zV577TV28skns+LiYlZUVMTy8vLYyJEj2WWXXcY++OCDFvcfOHAgCwQCDADLz89nAwcObLXd77//np111lmsqKiIFRQUsGHDhrG//vWvzLbtw+772WefsQkTJrDMzEw2bNgw9tRTT7Hbb789eo4FCxYwxhibOnUqy8zMZABYTk4Ou/TSSxljjI0cObJFn2699dZo29u2bWOnnnoqy8jIYL169WKnnXYa++ijjxgAFggEWFFREZNlud3r9M0337CioqLoeXJyctjxxx9/2P06en3Ky8vZGWecwXJzc1nfvn3ZNddcw95//30GgGVmZrKRI0e2uP8dd9zBSkpKWFFREZszZw4rKytjixYtYkVFRYzneeZyuVhRURHbvHkze+mll1hRUREDwLxeLysqKmJ1dXXtPkZCCCGEECfJssyKioqi8VtmZiYrKipiL7300mH33bhxIysqKmIul4vxPM+KiorYeeed12q7H374IZs+fTrLzc1lvXr1YuPGjWP//Oc/D7tfeXk5O+ecc1hWVhYrKSlhM2fOZF9//XWLGGnz5s3sxhtvPCx22rp1a7SdJUuWsKlTp7L8/PxoO2vXrj3sfE899RTr06cPKywsZBMnTmSbN29m//3vfw97XM0ff0di5ptuuonl5+dH49dhw4YxxhhbsGABy8nJiV7bGTNmdPyPQwjpkTjGHFi6QwghhBBCCCGEEEII6REo5ZkQQgghhBBCCCGEENJhNKBICCGEEEIIIYQQQgjpMBpQJIQQQgghhBBCCCGEdBgNKBJCCCGEEEIIIYQQQjqMBhQJIYQQQgghhBBCCCEdRgOKhBBCCCGEEEIIIYSQDhO7ugNdTVVV6Lre1d0ghBBCSA/hdrvh9Xq7uhskRhQzEkIIIaSzpEK82KMHFFVVRa9+fVBTUdXVXSGEEEJID1FcXIwdO3Z0+yCRNKGYkRBCCCGdKRXixR49oKjrOmoqqvDGhmUIZAQ7fNyy/76HP11/O/7fv1/E4FHDO35CLvY+MrvlQWaDAmV7GTJHDTziMRaL/UQ8x2I+xiVYR/zdineW4t6rb8H9Lz+GYyccH71d5O2Yz6NbQszHGGb7xyjf7oC7dz7ErIyY24/g4rhu8eDjeO7wcVzrtp4HtmnBlDVYig5TCf/XCoVXagguHr48H9xBN1x+N9x+EVwbnfbyRsx9s1jsFRrqTF/Mx8TzWvDF8Xh8QstjDpYpqC/X0G9UzhGPEbjY/6YNZmwfQBs+3YBfn/UbPPP2kxh+7NCYz9cR33yxCb/8yeV44l8PYfS4UTEd6+HNNn9fX6miareCgWNyo7fF83zjEPvzIJ7nqMFi/xi24/kwiVFteQhSmYyhxwViOs7Ddc5rW2OumI+RLE/Mx6h27Odp/hyt2tEAy7BRdExWUz8aZEwfNg+6rnfrAJG0FE/MWFdTi19M+z/MPfcMXHzjbzp+MgfiRcYYGr7cDv9RJRCD/laP6Q7xYv3BOlx40k8xbe4s/OYPC6O3d6d4Ud9fBVs34O1fEnP7zfWUmJHZDFZIh6noMGUNtqLBVHQwK3wOf6Ef7oALbr8brqAIQWz7b0AxY8uY0TJtbF1TiaMmFEB0HflxJjtmtGwLPznhNMw5fRZ+c8uVMZ+rIxhjOG3CmZgyazKu/0MM76GN2ooZmc2w5eNKDDw+F25fUyxGMWNsLJNh65oKjJoYhNsT22OimLHpOapKBvZ9XYOB4wvBceG/WarEiz16QDEikBGMaUDxx+ecjteeegmvP/E87n/lqY6fyIEAUZN1CAU5bfa3OwSIPz77J3jrb//Ec/c/imeX/hM8H37xxxMgupIQIDLLhi2ICBTmg3fH/uKP6CnBYdQhY13MZmj4ZhdcATd4kYcu6ZDKJDCbweV3wR10wx1s/G/ADaEx8Oms4NA0Oic49AvxBIct0+YayizkFXsQzDzyAI4YR3DIYgyQJ540ETl52Vi7bC3GTTkh5vN1xNgpx6OgOB9rln2CybMmxXRse88dpYohr0hERrPrmG7BodUJ5Y+lchsFxTwyMmN7/ng7KThU4wgOYcUejIkJDijWchqyij0IZnY8xiDdWywxYyAjiDMuuwD/fvpvOO83C5BTkNexkzgQL9q6AdPtQWZhPjih9ddYd4gXAxlBXPjbX+HJP/wFP7/iQvQ/ZhCA7hMvAgDHHYRYkAl3DN8VWm+nB8WMWS3/yRiDsrcGZk0D/Hk+6JKB0H4VkmZB8Agt48WgG6JHiH6pppixZcwo1+rIzA4iO6/tBRGdETOedOpJWLX4Y9x0/43Rv5fTZs49CR++uwK3//WmmM/R1nNHlQwEggHkFma2aJdixtgodToysoLIK4h9gQ7FjE0xoyUryCnIQkYCC526Cm3KEgdBEPCL316BTz78CJu++LJTz23KKoRA9x2hjuA4Dr++80Z8//V3WPyvRV3dncPYigpOFMC5aEw9IRxgqiYye2Ug76gclBxbhL6TeqPX2FJk98+C6BGg1mqo2lyNPWv2Ys8n+1D+TSUqdzSgoVKFHjLBWOcE2N2d1mDAG+z656MgCJh2ylR8+M6KpJ2D53lMP3UaPnxnheN/f1Uyu8V1THWaZMAfpBAhUZpswhOIf9KKpL6f/epC8AKP1x5/vlPPa8kaeK/7iIOJ3clPLzkHRb1L8fhdD3Z1V1plKyr4FIi9uzOO42DrJny5PuT0z0bRiAL0Gd8LfSb2Qv7gPHizPDBVC7U767Bv3X7s/ngvDmwsR/W2g6g9oEBtMMBsiheBxngxo3t8rpw0dzr27dqH77/ZmtRzlO8rxzcbNjnariqZ8ATEpA2E9hQaxd2O0GQDnkBqXsfuH2V0U9Pnn4x+Rw/CCw882qnntWQVoj81gpqRY0dj2rzZePqeh6Aqoa7uTguWooL3e+lDJEG2ZsK2GFzNvjBzHAeXV0Qg34+cAa0EjdkeGCELVTsasP3TSmxdXY5dG6pRvrWuxwaNjDGosglPsOsDREVSsHHdl8jISu6KqpnzTsL+PQew+astjrZLA4rOUGUT/mDsq31IE8u0YaoW3CkaIBJnZOZk44zLzsd/XnwV1RWVnXZeK0UmoAHA7XHjV7deizVLVuLzVZ90dXdasA0TzDAh+GNPfyMtWbJ2WJwjuAT4crzI6pOJgiF56HV8Cfqd2AfFo4oQLA4AYKg7EMLuDdXY8lEZdqyvxP7valGzR4J8UINlxL4KL9WpkglPN4lzPlnxCUSXCF8g9tWdHXXcxNHIzs3CB4uWO9ouxYvOUGWjW3x/SXW6bMKdoteRBhTjJAgCLrz+SqxbvhrffLahU87JLBt2SE+ZABEALr/lWhysqsbrT/2tq7vSgq2kTqDdnZmKBpffBb4D+TXRoLF3JkqHZWPA2AIcM7kYfY/NQ1ZxOBBpETSu6zlBo6FasC3WLWam7rnhXpTtK8fdT96V1POMmXQcMrMzHV0JaZk2DNWCN0U/kLsLU7dg6TZ8NKCYEF02Ibh5iG66jj3dWQsuhCiK+Mdjz3XaOVMloyVi+rzZGHH8sXj09gdg293n895WVHAeFziBXseJYIzBVHS4g+5278vxHDwZbmQUB5F3VC76HZeHoycXYeC4AuT3z4DLK0A5qOPAd3XYuroc29ZWYO/XNT0m+0WVukdGy8r3VuLvj72Ma++8Gn0H9knaeURRxLRTpmLZOzSg2B1pjSs9SWJohWIPNW3eHAwYcnSnrVK0FC2cputOnSdbrwF98dOLz8HLDz+L6vLOm5lvj6Vo4FNkpWd3Zska3Amk8/ECB2+GC9klfhQdndUyaBzQGDTWhoPG7R8fwI61Zdj/dTWqd9RDqgzBSJOgUZNMePxihwZmk+mtV9/GO6+9g1v/cjMGHN0/qedyuVyYOudEfPDOMsfaVCUTopuH6KaPtkSokgmXV4Ao0gruRKRycEiclZGdhTN/+Qu89dJrqC6v6JRzWooKMYUGFDmOw1V33oCt32zG4n++3dXdibIUFQLFiwmLbOIn+uJ7T+Q4Dm6fiIwCLwoGZKD3j3Jx1MRCHH1iEUqGZMGf7YahNmW/bF99AHs3VKJyay3qDshQG3TYaZD9wmwGTTa7fOL0wJ4DuPWK2zDtlKk47/KfJ/18J82djh1bd+GHLTsca5MGFBPHGOs2A9ypzDJsmJqdsiVy6FtXAniex4XXXYnPVq7BV59+nvTzWY2r6lItTfcXv10A0SXiuT891tVdARD+MLZDGgWIDjBlrUOzzbE4LGgcGQ4aB04qQdGQHPiyPTBUCzW7GrBzXTm2rz6APRsqUdE8aLRSK2jsDkHND5t/wL033Iv/O/f/MPdnP+6Uc86YOx3bvtuOXT/sdqS97nAd04Emd590qlRG9RNJc2f88gK43W68+uizST+XbZhgeuql6Y444Vic9H8n4+l7H+42pXJsWaUJaAeYsgbR73H8O4zg4hHI8SC3TxClQxuzX6YUo/ex+cgsDu9u3lCuYN+XVfhh1X7sWl+Osu9qcHBPA5SDKizjyBsGdUd6KNxft7/rVswahoGFl/wOgaAfdz52Z6d8L50wfRx8AR8+dGiVoqnbMHWbYsYEmboN22QU6yRIkw2Ibj66eWmqSc1edyNTTp2FQcMGd8oqxVSqh9NcZk42Lvztr/DOK29g++ZtXd0d2KoGcBw4D735JSoZA4pHIrh4+HM8yOkTRPHQHPQ9vhBHTS5F79EFyCrxg+MODxrrvy+Dsu8g9FoFdjcOGlXJgKcLC2yHlBBuvGghSvuW4nf3L+y0806aMQFen8exAJEGFJ2hSQa8tLIuYbpkUP1EEpWRlYkzF/wCb//tdVQeKE/quSxZBe9xgRNTL013we+vQW11DV59onuUyrEULSVj7+7GkjWIgc4Z4OYbU6YzSwIoODobvY8twMBJJeg/rgh5AzLh8okI1eko31KL7R+XYcfaMuz7qgryrmpoVRLMkN5ts1/UhnC9uq5cXPL43Y9j04ZNuO+5+5CVk9X+AQ7weD2YMmuSY3UUw5kYPASRhkISoUkG3H4BvJBai526G102E8r462oU6QIQeBsCH1u9FsOI/NF5XHDdr3H7JVfhizWfY9T4ExzuXdMHmimr8JTmobus2Dftjr8Jz7/wXLzx/Gt4+Pa/4M//eDKm89gxnCeCsSO/sVlyJN2ZR/N4geO6yYVtBcfH3jc+jscTyzWwTQu2ZsKbIcZ1rljZaOVvynNwBd1wBd2IbCHCGIOpWdAlA1KDDbMhBLWsDpZqgncLcAXcEIMeuAJuuAJuCL6WgVk8oYXIxT5YabGmM6kNJrJKAy1ua41qx/5h4+pA3/7wu/uxb9devL7sb8gMutH8fSeZfH4vJs2YiA/fWYGLr/5Fh45p6zmqyQZye/kPu4+ATqrHxcVzHjPmIzxJfr3pso7cPG+7z8dWxfElxx3HdRM4LeZjWGvvIe2w43hHEBr/PppsojAoRv996O9Jaoo1ZmyKF4HTLrkQ/37m73j54Wfxm7tvdbhnzeNFDXzAm5LxYlHffjjt4vPw94eew6nnnIG8ooIOH+t0vMgsC0zTwfl8Le7XneNFoHvGjKaswZMf7JR4EWglZuQ4CF4efq8L/vymmy3Dhi4b0CQdSoMJZZ8MU9bB8RxEvxuuxnhRbIwZD901vbNjxpBkwRNwdejzORkx46qlH+OFh17EdXf9BsePGwGg8ybrZ8ydhhsvvQUH9pShpE9xh4450nNUk8Npuq39nmLGjquTVQSCPPy8RjEj4o8Z9cbnY6rGizQs74ATT56Jo4YPxUt/fjhp52C2ndJpui63GwtuuQ6ffLgK61es6dK+2FQPxxGmrIF3ixBc3WsFRNMu0z5k9M1BzrBiFJ7QF0UT+iNnSCE8uX7YugV5by0qv9iH8jU7UbVxH+q2VkLeXw+tXoVtdV5B+MhGIl21Q9o7/3wPb/z9LdzywEIcNXRQp59/xtxp+HL91yjfn1hdsXAdF4tWKCYoch1pQ5bEmLoFy7BppSdpIZiZgTMXXIR3X3kdlfvLknYeS07tOOf8axbA5XHj2T91To3yI7EVFZxLBO+i13EiGGPhlOdOWqEYC8HFw5ftQXbvDGQfU4CC0b1RPHEA8kaVwl+SCY7nEKqSUfNtGcrW7ETFZ3tw8LtySHtqodYosPTOreWtSV23o275/grc9KvbMWX2JFx41Xmdfv7Js06E6BLx4bsrEm6LMlqcEZIs+Og6JixcFzV1ryMNKDqA4zj84rqrsHHNOmz4+JOknMMO6QDPp3Sa7pRTZ2Hk2NF49I4HYFldl35qKVQPxwmmrEMMdE66sxN4kYc7y4dAaRayjylA/ujeKJ7UH3nH9kKgNBOcyEOtllGzqRwH1uxE2Wd7UP1dORp2H0SoWoalJSdo1CSjy3aC3bF1J+649h7MO+sU/OTceZ1+fgCYevJkiKKA5f9bmVA7hmqD2QyeAA2EJUIL2WAM8HRhfaZ0oDVubMNTOhU5xGkXnw9fIIBXHoktWyMWkZrbqSojOwsXXnc53n3lTWz/bmuX9YPiRWfYugVm2hD9qREzcjwHV8ADf1EGMgfmIW9kCYrG90Ph2L7IHJgHV8ANQ9JQv70aZZ/uRtmnu1D19QHUba+GUtEAQ9bBkrQ8WJWMLqlxbJombrjk93B73LjniTvB853/2ZaRFcT4qWMdKZMTkkwaCHNAiCagExbZ2CaVN/GjSNchE+fMwNEjh+PFPz+SlEGHyGxzqm3I0lx4B78b8cOm7/He6291SR8YY7ApQHREd51tjgXHcXAF3PAVZiBzQDhoLBnfD8Xj+iJ7YB7cQQ8MRUf9jhqUrduNA5/sQtVX+1G7vRpKeQMMSUs4aOyq3frUkIrfXngTiksLcetfbuqy95as7EycMPl4fJBggBhqMOEJdP1O2akuJFnwBgS6jglSaWMbcgSBjCDO+tXF+N+r/0b53v2Ot89MC0wzwKfYhiyHOu3Cn6G0X288duefu6wPFC86w5S1cHkZIXW/dnIcB8EjwpvrR7BvDnKGFqHw+D4omdgfecOK4csPgFk25P31qNy4D/vX7EDFhr04+H0FpH110GpDsM3EFlOYugVLt7tkheLj9z2Djeu+wgPP3o2cvOxOP3/EzHnT8fmaDaipOhh3G9GdsjPoMzoRts2gyjSgmKh02Ngmdd/ZuxmO43Dh9b/G159+hg2rnV+lmOqzzRHDx/wIM047Bc/c+zAUSe708zNNBxgD703tQLs7MCUNYjA9r6PgDgeNGX2ykTukCEWNQWP+iGL4CoKAzSCXNaDyq/3Yv2YHdq2vaNw1UIJyUItp18CuSl/50+//H3b9sBsPvnAfAkF/p5+/uRlzp+Oz1Z+j7mBd3G2E01coqElUSLLgp+uYMC3FZ5tJcv3konMRyAji1SSsUrQUFZw79dN0XW43Lr/tOny6bDXWLf+4S/pAJXKckQ4T0EfCCzzcmV4ESjKRfXQBCo7thZKJ/VE0pg8yemeDd4tQa0M4uKUCB9buQtm63dj/dTWqd9RDqgzBCHU8+yWy8r2zNxJZu+JTPP3g87jq5gUYM3F0p577UNNOmQLGGFa891HcbWiRnbJ9FOskQlNscBzg8dFwUiI0yYTbl9ob29AzwEHjZ07D4GNH4sU/P+z4KsXwCsX0+DBecPM1qD9Yi9eeeKnTz20pKnifBxytvkkIsxmskJ62AWJreIGHO6MxaDwqHwWjSlEyIRw05vXPgMsrIlSroXzzwRa7BlZtr0NDhQJdMVp9X9AaOj995f3/LMXrz7+B3913HQaPOLpTz92ak348FaZpYcX7q+JuIzygmLqze92F0mDCl0FBdqI02YQ3hWebSXL5g0H87PJL8N5rb6Jsz15H27bk9JiABoApP56BUePH4LE7/tzppXKYbcNWNVqh6IB0HlBsDcdxEH0u+AqCyOqfi/zhxSge1w/F4/sh55gC+LLdMFQT1TsbsHNdObavPoA9X1Si4vta1O2Xodbrrdby7ooJ6MqyKiy87FZMmDYWl157YaeeuzX5hXkYPX4UPnxnRdxtROonpnLWX3cQapzIp+uYGE1O/QloGlB0ULiW4q/xzfov8NlK52ZTw2m64R370kFpv94487Lz8Opjz6OqLLGNGGJF6SvOMBUdHM+D96T2G2CiIkFjsMCHvAGZKB2ZhwETijFwUgmKhuYgkOuFpds4uFvC7vUV+GHVAez5vALlWw7i4D4ZSq3WWA+n8wLEXdv34Lbf/BGnnD4LZ/7itE47b1sKSwow6oSRDgSINBCWqBClrySMsXA6FaU8k7b830XnIpiZgZcfcnaVoqWk7gZ+hwqXyrkBP3z3Pd577b+dem47pIVrl7tpYiBRqVZzO1kElwBPtg85fTJQPDQX/U4oxFGTS9F7dAGySgPgeKChIoR9X1Xjh1UHsPPTchz4tgY1uxogVasI1elwd+LAg2VZuPGyW8DxHO596q4uqZvYmhmnTsPaFZ9Cbogv001tSO0NMLoLhTJaHKFKZpdttOSU7vHOkEbGnTQFQ48bhZcedK6Woh3SAA7gvenzYXz+Nb+Ex+vBS//vqU49L6WvOMOSNYgBN81KHYHg4uHP9iC7dxBFQ3LQ9/hCDJpcij5jCpDVOwhB5CFVqtj3dQ3AgH1f1WDfNzWo2tEAqUqFoSZnAxhd03H9RTchryAXd/z1993q7zdj3nSsWbYWIUWN+VjLtKGHaIfnRFkWg6bYVKg8QYZqwbYZPH66juTIfH4/zr7yMiz+539wYPcex9q1ZTVtJqABYOjokZh1+ql45t6HYZpmp503Ei92p8/JVGSbNmzV6FErFGPB8Rw8QRcyi/0oOCobvY/Nx8BJxeg/vhgFR2XBE3RBkwxUbK2DVKWidq+MPRurULGtDnVlClTJSNoGME/9+Xl89vEX+NMzdyO/MC8p54jHjLnToWs6Vn2wJq7jaYdnZ9AOz87QZJNWKJKWIrUUN32+EetXxJ++15wla2kX1GRkZWLSnOnY/OW3nXZO2pDFOT0tfcUJHM/BE3Ahs8iP/EFZ6HNsHooGZ8MTEFF0TBa8GS7oIROV2+ux/ZMKbFtdht1fVKH8+zrUtpECE4s/3/oQtn73A/7ywr0IZgYdemTOmDl3OtSQho8/XBvzsZpsQXRxcHlopjQRqmxBcHFwudPns6YraLIJj1+k0hqkXfMv+Dkyc7Lx8l+fcKQ9ZtmwVT3tJk7nnDUP1RVVnZrVQvGiM0xZA+8SwLtT+wtzZ+I4Di6vgECeF7n9MlAyPBf9xxYCAIqGZCOj0AdmM9TtV7Dniyp8/9EB7FxXgQObDqJmtwS5RoOpJ1YiYN2qz/DE/c/g8hsvxbgpxzvxsBzTu38vDBl5TNy7PdOAojNoh+fEhTNajJR/PqZ277up46eeiGFjRuOFBx7GCdMmJzwQaKfJhiyHyisqwOernN/A5kiYYYKZFnhf+l3LzmbKGryFmV3djZSnSQa8mW4E8rwI5DU9L22LQVcMaJIJTTJQXx5C5Q/1sE0Gl1+EO+iGJ+iCO+CCO+iG4ObbfZ9Z+vYyvPL06/j9Azdi6KghyX5oMes7sA+OHjYIHyxahpnzpsd0rCrRbn1OCDWE01fSafKqK2hS6s82k87h9ftw9pWX4ak//Ann/HoBeg3ol1B7lqKCc4lpN3iTV1gAAKipqEJx79JOOaelqHAV5nTKudKZJafvBn6dSZdN8AKHjIKWC0wYYzBUC5pkQJMMhOp01O6TYagWBLcAd9DVGC+64Q664PK3XzuwurIGN152C46fdBwW3HBJsh9aXGbMnY4XH30ZuqbD7el4Bp9l2DA0ysRIlGUy6KpNA4oJMkIWGAPcvtR+PtIKxSSIrFLcsvFrrFse/y5UEZacnrOk+UX5qKmoSkpqZ2tsRQXndYMT6GmfCMYYrVB0yJE2ZOEFDt4MN7JK/Cg8Ogt9R+fjqBOL0Xd8CXIHZsPtF6E16KjeVovda/dj15r9OPBlBaq31aKhTIYm6S1SYPbu3Idbr7oLs+afhJ9femZnPsSYzDh1Oj5avBqGEVtaW4hmmx2hSCYFhw5Q06DANuk8888/G9l5uXjl4cRrKabTBn7N5ReFBxSry6s65XyMMdih9Iy9OxvFi86IbMhy6GAgx3Fw+0RkFPiQPyATvUbmYuCEIhx1YjEKh+XBn+uFZdio21uPfZ+XY+eqfdj3eRkqN9egbm8DQrUqLKMp+8W2bfxuwW2wLRt/euaPEITuGRPMmDsdcoOMTz9aH9NxqmTC5eEhuOi7YCJCkgmXm4PLTdcxEbpspEVGC0W8STJszCjwgoCy3Ynt3scYg6Vo8Kbhh3FuYT4M3UD9wTpk5WYn/XxUP9EZtmaC2QyCP31qenYVTTaQ269jqcccx0H0ChC9IgL5vujttmlDl43wj6Sjfr8EXQ7X1HH7XXD5Bbz5yrsYO24s7vhL96qbeKiZ86bjyQeexfrVn2Hi9PEdPk6VTOSW0Gs7USHZQm4Rva4TpckmMgt97d+REAAenxfH/Gi4I7s920p61U+MyMrLgSAIqC6v7JTzMVUHGMB70y/27mymrMOX4+/qbqS8WHd4Flw8fNku+LKbnsPMZjBCJnTJgC7rUGpU1O5ugKVbED3h1YybvtkEFuLwp6fvRn5R96mbeKijhw1C34F98MGi5Zg8a1KHj6MJaGdQurMzNLn1hSWpJvUfQTf12UdrYFsWTpg+JaF2bFUHGAPvS7+gJpLCUl1R1SkDipaiQgjSl7xEmbIGwe9O+dmUrmbqFkzNTnhnL17k4c3ywJvVLGhkDKZqQZd0rHj7I+Rl52POVSej8psG1LhleIIueAKNadNBF9y+7jE7NnjkMejVtxQfvrOiwwOKjDFKeXZISLLgG0TXMRHMDu/w7KUViqSDtJCKjR9/ivOvvSLhtixZgycnw4FedS88zyOnIA/VFZ2zQtFSVPA+T7eegEsFzGYwFVqh6ARNMpBRlNh3GI7nwqVyAi4ATYO8lm5Blw1s/2YHdmzehV9d+Stk81n4YfV+eAKuaImdcOzoAi92/ao0juMwY+40vPXqO7jt/93U4ZWUVD/RGQptyOIITTbhT/EdngEaUAQAcBwDx8WWdtve/T9Zugz9jjkKvfr3BhC+r2XG/gZsSjp4nwfMFtDRHnJ87CnEDLEHTYkmKudFU1gqMXDIUY6ep7W/j62ocBflxPy3bktcYzBxnJ+L4yrE8zg78nBMSYMr4Inet0GPfTWEW4i9WLSLj/0Yn2DEfIzNYv+j2nG8fjTJhOgVwIsdf23zHb0nBwg+AWtXrMdN1/0eN9xzHY6a2g+2aUOTwisZddmAsje8mhGMwdVYj7GpNqMLgqvjs48iF/uGMR7u8NTm2fOm4N03PsAfHrwWPH/4e+ahx2iqBdtiyAwAfCvtdaYO/32aH8PF/ryO57XN2nleG5oNU2cIBjgICP8trTiqougs9hlrXxx/N1cc19rH6TEfY7XyHGxLSDHBcYDPD3BH+NsKcbxWSPcRa8zY3n03rv0EaiiEibOnR+8bT7zIbAY7pIHz+mFbHTs+VeJFIJzV0t4KRcfixVAIQsDraLwI9LyY0QrpjdkVLooZmx8T42soPHFqIH9QVkyvv47GJLybh9QQwjULfote/XrhF7eeA4EXYCjhuoy6bECqCqFmZz0sw4boFZvVZgzHjqI3tvrLTsSMp8ybjBce/js2rf8CJ0w8tkPH6JKBnL7eVuPPzpbKMaMqmSgo9UTjRYBiRiD2mNGUdfiL3RBTPF6kAcUksCwLn3ywEqf8/KcJt2UrIfCB9FxVl1eYDyBcZDvZmGmB6QalPDvAlDW4syl9JVGxpq/E6sCeMtx8+R2YdspUnHf5zwGEVzP6sj0tU2BYsxQYyUDooIraPQ2wNAuCR4CncXDRHXTDHehYQe9EzJ43FS889ho2rv8Wx40b2e79Q5IFr18AL9BKkkQokgWPj4cg0nVMhCpb8AaS+xoh6WXtkuUo7dcH/Y4ZlFA7dkgDBAGcKz1D+/yiAtRUds4KRVvRIKbhSs/OZjTWT6T3w8RYmgXbZI0rC51n2zZuvvx2aKqG+569G6IYfg9xB91wB1uWQTF1qzFeDE9My5Uh6IoRXf3oCYY3f4lMTPNJrFt/7AnDUVicjyWLVh5xQLE5xlhjqm56vkd2FsYYFMmGP9j1K1VTmW0zqIqVFitmU/8RdEObN3yF2uoaTJgV206lrbEVFWJulgO96n68fh8CGcFOqYljKSo4twucSPUeEmXKOvy9aOfDRIXrZiQnODQMEzdcejMCQT/+8PjtbQbzHMfB7XfB7XcBhU23W4YNXdajA411e+qhy+FZQXdAjO4Y6G7cPVB0qPTeceNGIq8gB0vfWdmhAUVFCu9MTBITvo4UHCaK6jORWDDGsPaDFZjy49kJD7rYSmRVXXoO3uQV5WPbt1uSfh7GGCxZhadXQdLPle5MWad0ZwdokgG3X0zaxOlLj72CVUs+xhP/egjFvYravK/oFiDmCvDnNi3QYDZrUctbrlBQIxuwDRsunxgdXIxMTIteoWMpUe3geR4zT52CJYtW4OZ7ftPue58WssEAeP0U6yRC1xgsk8EXoNg7EZpsgecBlzf1n48U9SbBmiXLkZWbg2FjRiXUTnhDFhXudt7cU1lHUlicEN6QhYKaRNmGBVs3IQZo44ZEaZLZYnMVJz169xP45vNv8eL/nkFWTnwTEuGC3l74slsGjUbIjAaNSk3TakbRI4Tr6wTFaJ2deFYzCoLQGCCuxI13Xdnu8SHJgj+DgppEhSSbCmw7QJUt+LPp/ZF0zLZvvkPl/jJMmJ34BHS47l/6ZmHkFuajetnHST8P003AssBTzJgwU9bgze/YxnPkyPQkTkB/uf5rPHTno7j46gswedYkxJNgyfEcPBlueDLcAAIAGr/D6nZ0JaMuGZAqQzBkA5zAwds4IR2JFz1BMa7VjLPnTcWrz72JTV99j+GjBrd5X6XBgi8gdIua4aksnBnEU2ZQgkKN9bbTYRKQBhSTYO3S5Rg3Y0qHC8QeCdMNwLbTckOWiLyiAlR3QgqLJavgKd05YaasgfeI4GmlZ0LCGzckJ0BctfRjPPfXl/Dbu36DY8f+KK7g8EhaFPQubFbQ27BgyTo0yYAmG5B3N9ZmBAd3oHGAMRo0uiC42g4aZ8+ditdffAvfb/oBg4cfub4qAIQaTOSX0ABOohTJQkl++n7WdBZVMpHbi0pCkI5Zs3Q5AhlB/GjcmITbshUV7uJ8B3rVPeUVhlOebdtutb6uU6IbsiTxHD0BYwymrEHs1313Ck4VmmTAl+F8vFh3sA7XX3QThh83HL++JfFNoZrjOA6iR4Do8cGf1zR5HlnNaMoaNMlAQ3kI1XK4NqPLJzTFi40/oqft2ozjJh+HzOwMLF20st0BxZBk0sSpAygzyBlqGu2UTQOKDivbsxc7Nm/FBb+9MuG2bEUF7/WmdVCTV9R5KxRdeZlJP0+6M2Xarc8JumKA5zm4vM5+kJTvr8DNv7odk2dPwoVXnedo220RXAI8OR74c5rVZrQZ9JDZuAmMAaVaxcHdDTA1O7qa0R8U4A2K8AZFuP1NQeP4qWMQyPBjyaKVbQ4o2haDqthUDydBjDEoMgWIibIsBi1kw0vXkXTQ2iXLcfy0E+FyJzYpEtmQJZ0nTvMK82EaJuoP1iE7L3llV2xFpdWJDrB1E8y0Ifppwi9RumQgu8TZiSrGGG654k7IkoI/P3cPXJ1UezWymjGQ2XS+yGpGTTKiE9MNFSHoigme58KbvwRdCAR5eIMueINN6d8ul4jpcyZhyTsrcc0tv2zz3CHJQjA79XfU7WpKGg2EdaWQbCEjJz2ej/QtzGFrl66A6HLhhGknJtyWpYTSOjgEwgHitm+SWxOHWTZsVU/7a9kZDFmHiwYUE6ZLBtxBl6PL3E3TxI2X/B5ujxv3PHFnUldwdATHc+EViQEX0Kxqg2VY0CQTmmzAkDRIuzWojbUZvQERnqAIX9CFcy44E6s+XIdf/+6SI54jJFsQXBxcntRPF+hKqhJex+r1pe/kVWfQZBOCyEF003Uk7asur8CWL7/B6Zecn3BbtqoCPAfOnR5fTlqTVxSuaVhTUZX0AUUhg1YZJ8qUdAh+N7gkbsrRE9iWDSNkOp7R8vKTr2H5ex/hkVcfREmfYkfbjlXTakYBgbym72p242rG8E7TJuoqNJRvl2AZDG5f04T0/512KtYu/wI7tu7BgKP7HPE8SoOFwj70XTBRimQhtzB9P2s6iyqZafN8pAFFh61ZshyjJpyAQEbiNUNsRYWYld67zOUVFiR9haId0sCJ6bvzYWcyZQ3evEBXdyPlJWOH5yfuewYb132F5xc9iZy8bEfbdpLgEuDPEeDP8cDNhT9Iw6sZLaiSCVUyIdVomDPjVJw66zR8u7IMgWxPY+DoQlZGuKA2x3MINYRX1aVD/ZGupEhUV8gJocZZe3o+ko745IOV4Hke42ZMSbgtW1Eh+NJ3QxagaUCxurwSA4cenbTzWIoKV1Fu0trvKSijxRm6ZIB38RAcnKj6+otv8eBtD+GCK87B9B9Pdaxdp/E8B2+GG96M8CpXN2eGU+l1OxovqpKJ4tx+ePzxx1G3E9heXxMdaPQGRbgyAEHkYJo2dJVqRSfKthlU2aaMlgRZjc9HbyA9xibS41F0E4ok4cu167Dg1hsSbosxFk67KEnvXebyigog1TdAC6nwJKmYuKWE6yemc6DdGZhtw1J0iEEKEBOlSwYyipzbkGXtik/x9IPP49e3XI4xE0c71m5nCa9mFOEJiMhqXM2YL3kwbcQZuOG2X2PGrKlQJRPVe2Tsl0wwAL6AANtiEN0c6msM+IICXLQyLC4h2uHZEaps0Q7PpMPWLF2O4cePRlZu4qvtbCX960TnFobrQ1YlcRLaNkww3YSQ5teyM5iyBlcmXcdEReptO/Udpr62ATdcdDOGjDwG197xa0fa7Ewcx8HlEeDyCMjIa/o+cuV5NwOWgD/+5WZojasZK3bIMHUbHh8Pl4cHzwNSbbiOosfH0/fCOKiKDY4DPJTRkhBVtiC6OLg8PKyu7owDKPJ10PoVH8PQDUycfVLCbTHDBDOttA8Q8xoDxOqKKpT2652Uc4R3eE7v69gZTFkHJ/Lg3fS2kQjGGDTJQP4gZ2p6VpVXYeFlt2L8tLG49NoLHWmzOwgE/Th27DC8+fpbOOviU6K3ezgdmmJDkSzs3SrDMjns3CRDV2243Bx8GSJ8QQH+oABfhgCvXwBlXLVNkWxkZNNsc6JCkonsAqoXRtqnhVR8vnINfnH9VY60ZykqXAXpvarO4/UgmJWJmorkbeRnKyo4jwscbTyXMEPW4CvJ6upupDxdMsIb4TmAMYY7rv4j6g7W4dm3HocrjUokzPzxibjhV3/AbX/5DYqPalqMIxgaQpKFir0qBBeH/dtDUGULHB+emPZliOF4sTFmFEUKGNuiUCaGI0JSek1Ap88j6QbWLl2O/oOPRknfxAfGwhuypP8uc81TWJI1oGjJKtzF6R1od4ZI+gp9iCTG0m3Ypg2PA8vcLcvCwstuBc9zuPepu7q8bqLT5syfhpuuvAdVFTXILwy/hjmOgzcgwOPnsWszMOhHAQQyRZimjZBkhX8aLFTs1RCSTDAb8AX46CCjPyP8X5ebo+dyI0WyUNibBsISpcoWvAMorCLt++LjT6CpKibOmp5wW5GMlp4wcZpXmI/qiuStULQUrUdcx2SzTQu2ZlLKswM0yUBWqTOlhl5/7t9Y8taH+H8v3Y/e/Xs50mZ3Mf3kSRBFAUvf+QjnXfbT6O0uT3h14sEKHbnFHvQ52g/bZtAUC0pjvFhbZeDAzhAMjcHt5eEP8i3iRa+fVjNG0A7PzlBlE75A+lxHinwdYlkWPvlgJU495wxn2usBG7IALYtsJ0Nk50MhkP7XMtlMWYcYoEGHRGmSDpdPBO/Asrmn//w81q/+HM/+93HkF+Y50Lvu5aRTTgTHcfjgf6tw9oX/1+J3hsZgGSz6gSyKPDKyeWQ028GPMQY9ZEOVDCiSDanOQsU+HVrIhujiosFiJHj0BYTozoE9hWWGdyamADExpmHD0Gx40yhAJMmzdslylPbvi75HD0y4LVvVAA7gvOn/+ZxXlI/qJK9Q7Amxd7KZsg7eLYJ30fthIhhj0U38EvXdl5tx/81/wc8vOxOz/m+GA73rXrJzszBu8nFY+s7KFgOKEeGJ0/AAN89z8AVF+IIi0Gw/GkMPT0xrkglFsnBglwZFCiek+gORzJfGwcYeWmYnJFnIyk2fla1dJSRZyClKnwkXGlB0yOYNX6Gu5iDGOzDbDER2mUv/zS8yc7IgusSk1cQJB9ocOE/6B9rJZsoavMXOpOn2ZE4Fh+tWfYYn7n8Gv7rxUoydcrwDPet+cvOyccKkY7F00crDBhQVyYTXz7c5AMhxHDx+AX4/h9zCptstkyEkW1AawjPUlft1KJINy2Tw+vlmA43hH7c3fVczhiJ1XNzp+fg6iypZcHl4iK70qIdDkocxhrUfrMDUU+c48r5iKyr4NN+QJSK3MB9VZUmsoaiocOVRmm6iwhktFHcnygxZYIzB7U8sZpTqJVx30U04ashAXP+Ha5zpXDc0a+5U/HHh/0PdwXpk5TR9X2GMISSZ8LWze7vLzcOVy0PIbRoIZ4xBbSyzo0gW6mtMlO/WoTWW2Tk0XvQGePBpvMGdIlko6Zs+A2FdRZVM+Aa1/XxMJTSgCIBr/ImFKNgt/v3JB8uQlZeDH40dCeGQ30VYVsdnMmxFhbs4vhVHjMXzRsbiOCb285j24dcgt7AAleVVrf4OAAS+9evZFssKP7UtWQPv9wDgwdp5iBwfxzXgYj+Gj+MYLo5j4uEWzFZvZ4zBVDT4MsTD7mPasc9AW3E8R71cZ31Nj71vItfx56gh6/AFXRAQ+/PabHzLrq6swcLLbsHxJ47BZTdcCruNPttxXOu4QqE4DurIa2HOvCm49/ePQqpvQGZWEHzjdVMlE/6gEP13W8RDnjuiC/Bkc8jOFhH5GGSMQdcY5IZw4Cg1WKgu0xFSbAgCojV2mgeOgph40BjPa5uP4/2aHeE8IcmEP8hD4BkO/Rzg4jhPW8/FI4nnlc3iOE88fy031/p74qEMWYc/yMPNmVBZ21/+4rmupPuINWY8NF78/utNqDpQjhNPnnrY7yJijRfjTdNNuXixoBBbvtyUlHiRWTZsVQfn87Z7XeKKF4EeEzNKigpPhqvV31PM2PGYMSRr8AREuAQW1+e+CTFcN/Hae1FdWYPH//0IXF5vm1FTKseMs+dOxh3X/RkrFq/GaT8P197mYUMNWWA24PdzsceMHOAKAhlBAUDTc9c0GBTZaowZbZTvDa9qZDbgDfAtYkV/UIDL48zEdFfGjKbBoKsMgQwOfCvPYYoZOxYzGroN02DICAJiOzFjqsSLNKDokDVLVmDCjCkQhMSX99uGCWaYPSbtIrcgP2kpzz2lrlCymaoJZjO4EpwlJYAmmcgsin9WyrZt/H7BrbAsG/c+/QdH3nO6s9nzpuKuG/+KFUvWYP6Zs6O3Kw0W/BnOPXaO4+DxcvB4eeQWiDBZuG3balzNKIUHGmsqDOzbrsLQGTy+plo7kcHGVKu1o0iU7uwERaa6QqRjPl68AoGMIEaNH+NIe5aiwpWf7Uhb3V1uUUHy4sWQCk4UwKfRRhVdxZA0eHOzu7obKU+Twjs8J+KNv/0H77+xGPc/dw/6DuzjUM+6p+LSAow+YTgWv70yOqAIhFfVOb1yUHRxyMwWkZkd/rfJhPCmi6oNpXFiWq4PZ8CoSrjMjq9ZiZ1I3CikUJkdRbbgcnM9MtXbSYpkwe3lIDqwKKG7oAFFBxzYvQ/bv9uKC6+/wpH2bCUEzuMGJwjxTQSnmLyiAtQkKeU5HGhT+kqiDEmHK+AGl8bL+DuDbdnQFROejPgDxOf/+iLWLv8UT775KAqKC9o/IMWV9i7CyOOGYMmij1oMKIYkC3nFyU+p4gUOgUwRgUOy/Q2tKQVGkSwcrDIRki1wQIuVjL7G4LG7BmCKZCG/hL5AJyokWSgopTQg0r41S1Zg3EknwuVO/P0rsiFLj5mALsyH3CBBVULw+n2Otm31oOuYTMxmMBQD7iClPCdKk034suO/jt9/sxX3L/wzzrjwdJzy0zkO9qz7mj1vKh669zmEFBW+xtdzqJMmTjmOg9cnwOsTkFvYFFdZVssyO9VlBvZIKkwjXGanKWYMx4seX/ecmFYabPgzumcsm0o66/nYmWhA0QEfL1kO0SVi7LRJjrRny2qP2kQkt6gAWzZ+7Xi7jDHYIRW8v8jxtnuayIAiSYwmmxBcPMQ4B5e+WLsBj939JC697mJMmD7e4d51X7PnTsUTD/4NmqrB6+PCqwaVrv1Adnl4ZHl4ZOU12wTGZlBDdjRorKsxcGC3BV1lh9Xa8QUF+AI8unKBKWOMVig6oOk6UqBN2lZVVoHNG7/BGZed50h7TNMBxsB7e8ZgdnQjv8oqlPZzdrVVTxqYTSZD0cHxHAQvfcVMlCoZyOkdXz19WVJw/UUL0W9QX9x473UO96z7mj1vKu6/7XF89MGnmDN/KoBwRkswu+viHEHgEMwUEcxsek0wxmDoLDwp3RgzHqzQEZJtcDxaxIqRwUbR1bUxBu3w7AxFtuBLs+tI7/YOWLN4BUZPHItARtCR9ixFhRB0dua1O8styEd1ElYoMt0AbBu8lwLERBmyDm9Oz3lOJosmGfAExMaZx9iWH9dU1+LGS27GqLE/wuW/+2VyOthNzZk3FQ/e9RRWL1uPU08di5BsQRAAt7d7zeByPAdfILxbdPMKuKZhIyTb0cCxfK/WVGsnuglMUxpMZ20CY+gMpsFoICxBhsZgmU07jhNyJGuWrgTP8xg/Y4oj7VmKCt7nCWcP9ICMltyCfABAdXllUgYU3cX5jrbZE0UzWrrhCqtUYhk2TNWKO+X5rusfQPn+Cry24mV4fT3ne9CAo/rgmKEDsOSdlU0DipKFwt7da1EEx3Fwezi4PTyym01M23azTWAaLNRWGTiwU4WuMbg9zSem+U7fBEaRbBT1ooyWRIUkC0W902sSkAYUEyQ3SNiwZh2uvPNGx9q0FRWuwhzH2uvu8ooKcLCyGpZlOVoPzpZV8F4vpek6QJd0ZPSh1PFExVsPx7Zt3HT5XdBVDfc/dw9EsWe9dR81pD8GHdMPixetxKmnjoUi2fAFhZT5wiK6eGRk88jIbjk7ravhoDEkhQt7Vx4woMo2BLFpdtqf0VSj0el6K4pkw+PjUqqGT3ekSFa7O44TAoTTnUeOHY0sh+rL2bIKPtBzJvsiKxSdnoRmNoMd0miFogMMWYeL0p0TpkkGRA8PIY5VaW++8g7++4//4Z6n/oABR/d3vnPd3Jz50/DSU/+GYZhw8QxayE6ZFWE8z0XjPxQ33W4a4c1fQlJ485eyPU2bwPgim8BkhMvsBBzcBCYinIlhwR+k98hERK5jqjwfO6pnfStNgvUr1sA0TEycNc2R9phpgukGBIdrw3RnmdlZsG0bDbX1yM5zbiDVUlTwPSh1PFks3YKtW5Ty7ABNMpFVGvuGLC88+ipWLP4Yj/3rYRSVFiahZ93f7HlT8doLb8E0r02LtAuO4+DxhTdxQbNaO+FNYJrqM9aUm9j7gxbeBMYbnp0ORFcz8vD5+bgnTZQGCwEHN7bpqUKyRasTSbu0kIrPPlqLi66/0rE2bUWFmJvZ/h3TRCAzAzzPo7aq2tF2bVUDOA6ch1bfJEqXdASKnMnY6sk0Ob4J6G2bt+Ou6x/A6efNxdyf/TgJPev+Zs+bgkfufwGfrPoCE44fAdEdXgmYykQXj8wcHlm5TbEGYwxaiEXjRanORMU+G6piQxC56IR0MNi0gaAQ58S0rjJYVnjwksRP1xhsO/2uIw0oJujjJSswYMhRKO3X25H2LEUF53aBE3vOl5NNn3+J/OJCZOY4uwLOVlQI2RTUJMqQdAheEbyYXm9+nY0xFtcKxerKGjx099O46KpzMHmWM3VaU9HseVPwxIN/w7o1XyM3eHSLgtfpJLwJjIBAZsvPAENv2jkwJFk4WK0hJNlgAPyBpgHGQGP6tMvd/uw01f1zRniAm64jadvnqz+FFlIxac40R9pjjMFSQnD37jmTTJs3fg3btjFw2GBH243UT0yVVe/dFWMsnPI8iCagE6VJZlwDivfe/BCKexXh1j9dn4RepYZhPzoGvfoWY8milRg1eGjKT0AfCcdx8Po5eP384ZvASBYUKRwzVpUbkLfZMA0Gj49DIJIy3ThB7fW3vwmMIlnwUSZGwqIZLWmWPUkDigmwLAtrP1iJuef+1LE2w+krPWdVHWMMHy9ZhgmzpoHnnf1CZodUuEuoHk6iDFmn3focYKgWbJvB44/tbfflp/8FQeDxq+suTE7HUsSPjhuKkl6F+N/bq3D6vIHoPajnvE8CgMvNIyuPR1aeCL6xWBpj4Vo7cmPQ2FBroXyvDjXEILo4BDL4FrV2fEG+RXqzIlnIKUivOi5dQZFsZOen5wA3cc6axcvRq38f9Dt6oCPtRetE+3rOa3jtkhXIzM3G8OOPdbRdW1EhULpzwizVBLMZXH6KGROlSgby+sa2KGLzN1ux+sNP8MAzd8If8EHrAXVVW8NxHGbPm4p33/gQVyy4NG0HFI9EEDgEs0QEG9fpRGJGXbOjg4yyZONglYaQbANoTJtulgHjC/ItVnXSBLQzQpIFfxpmtNCAYgI2ff4V6qoPYtLs6Y612dOCmt3bdmDfjt248s7fOdqurRtghkn1cBygS1QPxwmaZMDjF2NKTw0pKl595t/46fnzkJ2b1WODQyASIE7BmpUbMf9k2gADCF+TyCYwKGo2O20yKLIFpSE82Fh5wIAiaTANFt4EJsjDF+AhSzYEITwwSStz4sMYQ0hO/RR8klyMMaxZuhLT5s9x7LVmK5E60T3nS97Hi5dhwoypjtbbBgBLCcGV33NqlyeLIetw+V1UuzxBzGbQ40h5fuHRV1HSuwinnDYzST1LHXPmTcULj72OyjIJAwbTaxsA3B6+cROYZvW8bYZQqHGgscFC/UELB/bo0EIMLjcXnZCurzURzBBgWYzqbicgHesnAjSgmJCPlyxHVl4Oho35kWNtWooKMb/nbH6xdslyeHxejJk8wdF2bUUF53GDE3pOoJ0shqzDXxjo6m6kvHjSnd98ZREa6mVceMXPk9Sr1DJ73lR8+ck2gDfjrgPTEwgih4wsERnNPkpsxmBoLDo7XV9rAQzYvDEEjgN8jUFjtD5jBg/RnX5Bj9O0UHh23+ujzxpyZN9//R0qD5Rj0uxpjrVpNabp9hQHdu3Fjs1b8YvrnKtBCYQHe22FNmRxgt64wzNJjB4yAXBw+Tr+GVy2rxzv/Gsxrr/zKrhc9PV+zPiRyMvPhqFxtLKuDRzPwR8Qwqvmmk1Mm2akNmOk1I6NkGyjfJ8RnZhuyoAJp02DJqbbFZKstCzZ1C3fcerq6vDKK6/A4/Fg4sSJGDp0aFd3qVVrlqzAhJnOzZQyywLTdPA9aEOWj5csx/FTJsLjczaQsxUVQg9KHU8W27JhKgatUHSAJpnwZXX8OlqWhRce/QdO/slJ6N2vNIk9Sx0nTByFocOGoKKiDACVM4gFx3Fwezm4vTyy80W4ywzoqo0RYwNQlaY0mLoaCwd269DUyOy0EB1s9Ad5+IICzU43E64rJNCKnC6UCjHjmsXLEczMwKjxYxxr05ZDELIzHGuvu1uzdDlElwsnTHO2ljDTdIAx8N6ekzqeLIasw5NFsXeiwhPQYkyrmV964nX4Aj6c+Yv/S2LPUocgCJh/xingOQHeNNsAozMIIoeMbBEZ2YBtM5TvNTBqQgA8z0XjRUWyUVNhICTbjRPTQrOBxvDEtMtN1z6C2eFNF9Mxo6VbDiju3bsX11xzDTiOgyAIsCwLubm5WLBgAa655hpkZ2d3dRexf9de7Ni8DRffcJVjbdqKCs4lgu8hM0u11Qfx7foNuO7PdzrethVSe9RO2cliygZ4Fw+BViolTJMMZPfq+ErPpYtWYM/Offjri3cnr1MpRhRFjB13HDZ88RXmnj2iq7uT0hTJgj9DAM9z0eAPOHR2ummgsfKAjpBkt0ybjgSNHSzqnY5Ckg0frX7oUqkQM368ZAXGnnQiRJczKxPCq+pUuEsLHGkvFaxZshyjJ41FIMPZzfYsRQXv89CkgAMMSUewV8/ZdTxZYt2QpaFOwusv/gfnXHIGghmUURQxfdZk7N27Fzmb6zBkuDO1a3uikGyD48OZGBzHwePlkZPfNFZh2031vEOSjfqDJsp2a9GJaV/zQcYePDGthsIDr540zGjpliNXO3bsCG/W8fHHKC4uxtatW/H555/D7/e32Lhjy5YteOedd+B2uzF9+nSMGBHfF0zDEmBYsQ2YrF26AqJLxNhpE8ChY4XNOK7t+0VW1TW/H2Od84KL6zxx1HOz0PT3W/vBKti2jbEnTYdlH/nFxQtWzOexFRXuwmxwfMc72d7fpzV8HMfEcx4hrmPsmI859HnQlL7Cgx2hC35Rj/k8AT72Y+J5PCE79i9v8Vxri7X94WCZNgzVgivgjt7XwJFfc4wxPPPwKzhh8vE4+tiR0dqJZhuvEyfF9byO4w2Bj+OYvn364rVX38DWLZNw9OB+HTomnnfRuF4/cZwnnmsQz+M59O+jShaycgSIaP1xiiLgy+aQly0ACH8+MsagawyyZDf+WNhfaUCRwkGSP8DDn8FHdxAMdHC3aZPFPmERz/ONxXHl2nu/VmQLgQyhxf3ae/n0vDA6ubp7zFhdXo4tX36Ls355vmPxIjMMMNOC4PdE75vO8aJU34CNa9bjijtucjxeZKHG2DvJ8SKQ3jGjbViwNAsuv6fN5wjFjO3HjGqDgUC+r8X92ooZX33pbWiqjp8tOAcaa/pq39NjxkEDBuCtT5dh76LqmAYUKWZs+ffRJDMcz3EMrfaaB9xBDlnBSLwYfh1FJqYjMWP1AQ27JRumAXh9TRsHRjeC8bcfLwKpGzOGZAu+gIBwWNKxmDFV4sVuOaD49ddfIxgM4oQTTgAA9OnTByeddFKL+7z77rv45S9/iV69ekFVVdx333247777cP7550fvYxgGAMDl0Ixwcx8vXoHRE52dKe1p9XDWLl2GoceNQm6hszPstmmBaUaPupbJYkg6XEFKA0qULhkQ3EKHV3p+vmYDvvn8Wzz2r4eT3LPUYtsMouBFefkBvL9odYcHFMnhZMlGSZ/YPhvDM9Ph2encZhnnts0QUhhkyYIsMdQ1FvWO7jbdWGMn0GywMV1mp0OShYKS9KuHk0q6e8y4ZulK8DyP8TMmO9ZmeEOWnlMn+rMVq2CZJiY4uAlihCWrEHN6Tup4shiyDsEjgndRRkuiNNlATv+OrfQ0dAMvP/EPnHrmKSgs6TkrljvCUAG3F/jPfz/Ctb+7oKu7k7JkyUYgjkwMUeSQmS0gM7vpPeHQiWlJslFTaUKRbXAI7zYdCPIIZMQ2MZ0KwhuypOdndrd7VIZhYMuWLTAMAytXrkR5eXn0d7YdHv3fsWMHLr/8chx33HF48803sXLlSlxwwQW4/PLLsXv37uj9H3zwQfTp0wd79+51tI9yg4QNa9Zh0pxpjrbbk3Z41jUd65evwoRZyQgONXDunpM6nky6TAW2nRDrhiwvPvw3HDVsEE6cOTGJvUo9mmKB44ERxw7Ae4tWdXV3UpZlMqghhkCGMyEAz4cHDQuLXeh3lAfDjvXh+BODmDA9iOGjfSgoDr8XVx4w8e2GENYuk/DZagmbNoawa5uGyjIDimSB2am1jXl4IDU96+GkilSIGT9esgIjx45GVm62Y21acs+agF6zZBkGDhuMot69HG03kjpONbcTp0s61dt2gKlbsHQbnkDHYsb33liMiv0V+MWvz2//zj1MSDIxcHAxvv1qG3bvPNDV3UlZckN8A4qtiaRM5+aL6NPfjcEjfBg9PoCJ04M4drwffQa44fHyqDto4YfvVKz7SManK2V8/ZmCHzarKNuro77WgmmmVrwINJYaStN4sdsNKEqShKysLAwZMgQXX3wxevfujbPPPht79uyJpq787W9/g2VZuPfee9G7d2/k5OTgiiuuQH5+Pt58800AwIoVK/Df//4X7733Hnr37u1oH9et+BimYTq6Wx+zbNghDXwPCWq+WrsOIVnB+GQMKNJufY5gjMGkAUVH6HLHBxS3b9mBjxavwi+uPC8tZuScFJJM+IMCTp4/GRs/34x9eyu6ukspSZZsuNwc3Ekulh3ebVpAcW83Bg3xYuTxfoybGsDYKQEMGupFVo4ATbOxb6eOjZ8qWLNMwoa1MrZ8E8LenRpqqkxoqg12pHoLXSwk2xB4wO2l12lX6e4xoxZS8dlHnzgaLwLhjJaeMghmmSbWLfsIE2ef1P6dY8R0E8y0wPsoEyNRBsWLjtAlAy6vAF5s//OZMYaXHvk7Js+ehKOGDuqE3qUO22LQFAvjThwCj8eF999Z3dVdSlmylPyJ08hu0/lFh0xMn9Q4MV0iguOAynIT320M4ZPlEtavkrBpg4KdjRPTsmTB7sYT0yHJTtsdx7vdEq7MzExce+21uO666+DxePDee+/h+uuvx2233Yann34aBw8exNtvv43Zs2djxIgRYIyB4zjwPI/8/Hx8//33AMJB5s0334zRo0dH7+OUNUtWYODQo1HS17mZUjukgRMFcD1kVd2aJctQ1LsXBg4d7Hjbpqz1mJWeyWSGDDAAop/S+RKlSTqy+3QspeqlR/+OwpIC/PjMU5Lcq9SjNpjwBQXMnDMeLpeI9xetxiWXn97V3Uo58aavOIHjOLg9HNweHjl5TbczxqBG06ZtNNTZKN9nIKQwCCJa1GX0B3kEgzxEV9cO5IUkC76gQAP/Xai7x4yfrfoEWkh1PqNFVsEX5TraZnf1zfov0FBbhwmznB9QNBWtR6WOJ5MhafDl+bu6GylPkwy4O7jSc82ytdi6aRt+d/8NSe5V6lFlE4LIITvXj8nTx+C9t1fhl1ed2dXdSjmGEU5RdiqjJVaCEJ6YzshqOaCpa3a0PqMi2dhXrUORbDDWlDYdjhkbNw70oktjNdsKb1yTrisUu93olSAI6N+/f/TfF154IXbu3In77rsPv//97xEKhfDdd9/huuuua3Gc1+tFfX09CgrC9SPmzp0b/Z2TTyDLsrD2w48w/7wzHGsTACw5BD7g7RFfTBhjWLt0OSbOPikpj9eSVbhol7mEGbIOl9/VI56TycRsFl6h2IH0lcqySrzz+v9w5e8vh8tNA7mHCkkmcgtFZGb5ceK04/D+olU0oBgHuRvOknIcB1+Agy/AI7+o6XbLYgjJkaDRQnWliT07bOgag9sTTrVuXqPRH+DBd9JurUo3vI49TXePGdcsWY7eA/qi71EDHGvTNkwww+wxE6drlyxHbmEBjhkV3yY6bbHknpMZlEzMtmGGDEp5dkAsJXJefPjvGHbsUBx/4pgk9yr1hCQTvgwRHMfhlPlTcP2VD6CyvAYFPWQiximKZMPt4eDq4gncQ7k9PNweHtmHTkyHGJTGiWm5wUbFARMhxYYgAIEA32xiWkAgg++0x6XINgQRcHm613V0SrcbULTtcHpTJFWF4zhMnz4dd911F+rr67F3716oqooxY8ZEfw8AmqahvLwc/fqFi/Q7vSox4tvPv0Rd9UHH01d6Uv3E7d9tQcW+/ZiQjPQV24al6PD2kGuZTLQhizOMkAmAg8vf/tvtP575J9weN868kAbJWhOSLPgHhp+Tp8ybjJuu/X+orqpFXn5213YsxSiShcIU2UhEEDgEMwUEM5t2DgQA04jMTluQG2yU7TMgSzYsC/D5OQSiOweGg0evjwMcjgkUyUJ2XrcLo3qU7hwzMsawZulKzPi/kx1t21ZUcB4XODE9Vzocau3SZRg/c1qLHbudYsoahACtqkuUIRvgBB6Ch94PE6VLOjIKfe3e77svN+PTlevwp+fvpYn/VoQaLHiD4efj7FMmguM4LPnfGpx70dx2jiTNyZLVZRktseI4Dj4/B5+fR15h0+22xRBSrOiKxppqC3t3GdBUBrebgz+DbzE57Q84v3FgqLF+Yrq+VrvdO39rAcO+ffsQCARgWRZqa2vh8/lQWFjY4j47duyAJEkYMmQIgOQta12zZAWy8nIw9LiRjrZrKSrcJfnt3zENrF2yDP5gAKMmnOB425aigxN4cO5u99ROOYasw5tLgXaiNMmAOyC2+56kSAr++dy/8dMLfoKMLNpx8lCmbsPUbfga0wXmnDoJC6/+C5a+txZnn0/p4R3FGOvSlGenuFwcsnIEZOW03D1QU1k0aJQlG1XljbsHcggHis1SYBLdPVCRLJT0o0mXrtSdY8bvv/4OVWUVmDh7qqPtWnLPmYDes2079m7fiQW33piU9i1ZhVhAK5YSFamfmK5fljuLbTHoigl3B1YovvTo31HatxQz5zu/OCMdhCQTuSXhz+e8gmyMmzgS7y1aRQOKMXJyQ5auwgscghkCghktJ+FMg0VTpmUpPDGtSDZMMzwx7T+k1I7Px4OLMwMmnTdkAbrZgOIXX3yBN954AwsWLEBJSQlcLhe+++47PPTQQxg8eDBOOOEErF+/HpmZmQiFQsjJyQEAmKaJlStXIj8/H4MHO1+Tr7k1S1ZgwsypEATnnhTMDm/I0lMKbK9duhwnTJ8Ml9v51AhTViEEe0bqeLIZko6Mvtld3Y2UF05faf+5/ubf/wtFknHe5ed0Qq9ST0gy4fbyEMXwa7ugKBfHjx+O9xatogHFGOgag2kgLVN1OY6D18fB6+ORW9B0u22H6zNKjYFj3UELB/boUEMMootrETAGgjz8AaHd+oymyaCrLC2vY6ro7jHjmiXLEczMwKjxzqYj2oraY9J01y5dDrfXg+MmT3S8bduwYGtmj4m9k8mQaEMWJ+iKAV7kIHra/o65f/cBLH5zKW6457cQxW71Vb5bYIxBlUz4goHobafMm4w/3voU6uskZGYFu7B3qUWRbJT0SY2MlliJR5iY1rXwxLQkhdOnaypNhGQbDID/0LTpIA+3p/2JaUWykVOQvq/VbvXIDhw4gNdffx0ffPABRo8eDa/Xi3//+9+wLAuPPvoogHC9HJfLhf3796O0tBQAsGfPHixatAgnnngi8vLykpbuvH/XXuzYsg0X33iVo+3aIQ3geXA9oGZadXkFNm/4Cj+56NyktG/JGkQ/rRhJlKWbsA0LLj8FiInSZR3+vLbTV0zTxMuPv4qTT5+D4t7FndSz1BKSzGj6SsSP50/BfXc8A1lSEAjSatqOkCUbPj/neDpHd8bzHPxBLrq6NcKywkFjJHW6utzEnh9s6DqDx8vBH+DhzRDgDwjwBwX4Ajz4xusWkiy43BxcSd4pmxxZd48ZP16yAmOnnwjR5WxsZykqXAU5jrbZXa1ZsgzHnTgRXn/7KaCxshQNvEfsManjyWTIGvzFlFmRKF0y4A60X7v85SdeRSAjgJ+cO7+TepZaDM2GZTJ4AyIAEwBw8vzJuG3ho/hw8ac47awZXdvBFBHJaOlJE6ccx8Hj5eDx8sjOb3odNt84UIlsHLg/PNAY3TgwwMMbbIwXg3yL+DAkWeg1IH3HJ7rVM2T27Nl49dVXceqpp+KHH37Ap59+irPPPhuLFy/G6aeHa4rNmTMHtm3j6aefhiRJaGhowB//+EdUVVXhkksuARCuqRMLxjq2xfiaJcvhcrswdtqk2B5YOyxFhdBDNmT55IOV4HkeY09yNgUoIlwPJ31fsJ3FkHQIPhG82K3eIlKSJrW/IcvStz7E/j0H8Itfn99JvUo94dnmlgOKp8ybDE0zsHzpui7qVeqhjUSaRHYPLOrlwsDBXowY48fYqUGMmxrEMcO9yCkQYRlA+V4dmz6XsG5ZPTZ+3IDvv5Sxb4cG0c0hJFsdjiGIs7oqZuyIqrIKbPnyW8frbTPTAtOMHhHn1NUcxLfrv8DEOclJ6TRlFQJNQCeMMQZD1uGmmtsJ60hGS31tPd7423/ws0vPhJ8mUlulSiY8fiE6AQgAvfsU4Uejj8H7i1Z1Yc9Si6YyWHZ4VV5PF944kEd+kQt9B3kwdJQPYyYGMPGkIEYe70dxbxcEF4faKhPbvlXw+coGfL6yHt99LmPHdyHoGgOzGSwrPePFbrVC0eVyYezYsRg7dmz0Ntu2W9TI6d+/Px544AHccsstmDp1KrxebzTFZc6cOQAQczpy7YadsAtzIAa8EAIeiAFveNbykAG+j5eswLETx8IfDABw7glhyyr4HlIPZ+2SDzH8hOOQlev87DpjDJaiQQx44PzXg57FkHW4e8AXlmQzdQuWbre5Yx9jDC8+/DdMmD4Og0ce04m9Sy0hyUJmXsvnZN/+JRg2chDeW7Qac0+b1iX9SjXpUD8x2VxuDlm5IrJyAbNx3rUpDcZCSLJRsU+HaTB89YkEAPAF+MZ6OwJEP4M3KMLl4XvERGFX6aqYsf7bPWCFuRADXohBDwSf57C6SmuWrIAgCBg/Y3ICj/BwlqKCc7vA9YA0x3XLVsK2bYyfOS0p7VuyBpHSnRNmqSaYzSD60j/LKtk0SUdmcaDN+/zrhTdgmRbO+eXPOqlXqSckWYdNQAPhSehH//IqVFWD10vfcdojSzb8fh58nHUDe4JD6zNGYkbTYAjJFhTJQm21CY4Dtn4dgmkweHyNm780rmQU/Hx4ADyFr3O3j0haK7h99tlnY8iQIViyZAnq6urw+OOPY9SoUXGfI3h0Mdy8C6akQj8owwpp4AS+xQCjDgsb167HVXcuTOThtMpSVLh7wDb2aiiEL1atxS+u/3VS2rdCOgCA97mRhAUHPQrVw3GGLhkQvUKbKz3XfbQe3325GU/957FO7FlqYTaDKpvwBgUcOplzyrzJePrRf0HXDbh7QNmIRMmSjbwCem3HqnkaTE4+UFtloLS/BwUlLqihcNp0SLIg1ZmQ9xnQFAu8yMEXEOANivAGRHiDQqtfcohzOiNm9BRlg+N4aFX1UHZpYDaD4HdHBxjFgBeffLgKI8aORmZONpyegO4pG7KsXbocg48dibyiwvbvHAdL1uDOozTdRBmSDpffHfdmBSSMMQZdNtrckEXXdLzy5D8w7+xTkVeY14m9Sy3hEjmHTxSdMm8y7r/rOaxa/jlmneJ8XdZ0kw4bsnQV0cUhI1tERrYIxgDbAoaM9sPQGUKSDUVqGmwMSSEwBnj8kXgxHCt6g2LKZMCkZGTLcRxGjx6N0aNHO9Ie8wfBZwThLgDcaNwkRdFgKSosWYW+7yBMOYSXXnwJ3pxM1O+oguj3gA94wXs7vquZbR/+omSMwVY0cD5/q7+PKw6N4xiOj/0gjovtmA2r10BTVUyaMx18jMd2RKR+IsdxcAlW7Me3dv3bEU/4JMTx2N187I9H4GMfVWUs/IgMWUOwONChvgpxPOEUO/aBnwxBi/kYNxf7dUMcf586o/W0E6XBgivggW4f/lYbOcuLj7yMY0YcgzFTJsKw235GWSz25yjPxf484OP4m7p5M+ZjxA7+fUIhCxyAQODw19yp86fgwXtexMcrv8BJs8a1erwQxzVAHNc6nvPE8x5is9iPssGB2awx5VkA69CZ4/hccHDwpC0d639LVhzHmKz11WuKZMMdcMHiRLj8QJYfyGoc9zCYANti0BQLIcmEKpuor9ZRscuEodnQTTXmfpD4OR0zcjnZcGUE4UI4hmOaAUtWYSsq1CoZ1q4qXH3p5VB0DfVbyyEEvOD9Xgh+DzihY+8rrcaDCJd14f2+tI8XDV3H+uWr8LPLL0lKvMgsG1ZIhxjwgO+keBFIz5jRlDW4g+4O95NixtZjRlM1YZsMnM8LvbXviwAW/XMxqsqr8fPLL4Bht7+yuqfGjKpkIr/YBZFr+al/zJB+GHR0H7z39irMbmNAkWLGcMwoSzYCGXwM8RbFjK3FjLIUrudpQQTvBgK54Z8I3eahqzbUxnhRlSzUlmvhGDKkxNyHrpCSA4rJxvE8hKAPQrCpCPSfrr0JcmUNfv+X+2ArGvTyg7AUDeAAwe9tChgDHvA+T4cHGVlIAzgOnCf9V4x88sFy9B7YD32PGpiU9i2qn+gI27Jhhky4aYViwnRZh7uNejjbNm3Dxx98jD88eTelRrYhJJnwBYXGa9Qy+BgyfAD6DyzFe2+vPuKAIgkLKTY4DvD66bmWCEOzYRoMvsCRv9DxAgdfhghfRsswyzJtVB2oT3YXSSfhOA6c1w3e6wbyMgGEV9Y9fMNt+Msrz4NziTBqJdj7qsBMC7zPDcHvBR/wNsaOHnAxpFzbSghiXlayHk638eUn66FIctLqJ1qKBk4UwLnpa1CidFmHL8f5TXN6Gl3W4fK7wLWyyhoIl3P4+6N/w9RTpmHAMQM6uXepw7YYVMWCL+Pw91WO43DK/Ml45YV3YJom7ZDdDkWyUVBCmT+JCkkW8kuPPD7BcRw8PgEen4Csgqb72TZDTXlqxIv0SuoAxhg+/WAFTjnnTLgLw7X/OLDw6sKQDktRYcsqjMpaqLtUgAFC4wrG6GCjr/UnkqWEwPvTf0MW27axdulyzDx9btLOYcoq3PmZSWu/pzAkHbyLB++mnQ8TZcg6/PlHLpr998deQlGvYsw6bXYn9ir1KEeohwM0BojzJuPf/1iC+/56Tcz10HqSyG596f55k2wh2YLby0MQY7+OgsjDn0UBejpbt2wlXAEfiocdFR5wbIwXmWHCksOZL1a9DP1ADZhhgve6wfs9EALheFHwewHu8PcxZllgmg4hCTsedzdrlyxDYWkJBg0bnJT2Ixv40Xth4gxJR2af9B/kTrb2Sg19/MFqbN+yHTf/v1s7sVepR5UtCAIHt6f1gdkfz5uMRx98FevWfI2JU5xZtZ6ObJtBUSjlOVGMhWsp+lpJwW8Pz3PwBFJjqC41etnFDlZVo7a6BkOOHdnido7jIPg94V3i8sMfpowx2KoOW1ZhKRqM6nqoeyoA2wbvC69i5P2+8H99XthKz9iQ5fuvvkFNRSUmzJqelPYZY+GU5360QjFRkVV1FGgnhtkMhmK0udJz9ZLV+OmFZ8DlogGGtoQaLGTmHfkanTJvMp546HV89um3GDfxR53Ys9SiSDYCcQQ1pKVwwXe6jqR1OzZvxeBRI1t8hnIcB87tAu92wZXTVLfP1s3wpLSiwpJC0MsPgulm+L6RWNHvg+D3wlY1cC4RnCu9Q3fGGNYuXY6Jc6YnLQ4Jb8hC8WKiLN2CpVuU0eIAXdbhyTjyc3L1klXod3R/HDvu2M7rVApSGj+fj/TeMeq4wSgpzcf/Fq2mAcU2KLINgQc8XvoumAhDZ7AMBm8bGS3pIL2jEofs3b4TANB7YP9278txHARfeNe/yNffSI0dQ9LDQWNtPfR9FYBlARwH3u+DUVEdHWSMJf0lVaxduhwZ2VkYOfa4pLRvayaYbUPwU1CTKJ02ZHGEoejgeA6C98hvs8y2Ecg48gpGEqZIFor7H3niZczYYSgsysV7i1bTgGIb5AYLWXn0sZ8oGlAkbdm7fSdGTxrfofvybhG8OwhkB6O32YYFU9JhKSHYigqzuhZM0wGBBzgO+v6K6GAj5xLTbvJvx+bvUb53X9ImoIFwRou3NCdp7fcUhqxD9IptbjxHOsaQdASLj7xJELMZAkF/2r3enRYpkXMkPM/jlHmT8d6iVfjDn66i63kESgNltDghJFnw+HgIQnpfR/pm0QH7tu8Ex3Eo7dc3ruMjNXZElw/IabaSUTegfrsNvM8Dq16CUVYFZpjgPO7ojHR4kNEHTkztLy9rlyzD2JOmQEhSvQpLViH43EesPUI6zpB1ZPSi1PFE6ZIOd4BWeibKNGwYmt1ugHjy3BPx3qJVuP2ey+maH4Es2SjtR++RiQpJJgr7pn9mAYmd3CDhYGUVeg3sF3cbvEuAkBmEkNk0yMgsC9oPe8AA2JoO82A9mKoBogAhmvXSOMjodqX0e+DaJcvgC/hx7MTk1MRlNoOl6BAD9BpOlC7pcLVRJ5p0jG3ZMFWzzZrbpGMUyUJuUdvX8ZR5k/H8U//Blxu24NjjhnRSz1KLLFmU0eKA9ga40wUNKHbA3u07UdirFG6vc+kRHMeBa9wK3N23JBr82YYBO5L+IiswKmvAdKNl+ovPC8HvS5m0l/J9+/HDps34+VULknaOcD0cCg4TxRiDIRsU1DjAkI0OBdqsczY4S1khyYLbw0N0tT0Qdsr8yfjbc29j0zc/YPjIozqpd6nDNBk0lVE9nAQlUg+HpL99O3YC6FhGSyw4QYBtmHD3KoSYHZ7wY5YNO6TCblzJaNRVwg6pgCCENwn0NZXY4TypM7m1dulyHD91MtxJ2qzQCukAB/BeKjWSqMjEKUmMIYdrlwvt1C6neLFtjDGEGiz4BrX9/Xj8iT9CTm4m3nt7NQ0oHoEi2cgpSI1xhu6sp2S00DOlA/bt2OV4cAiEd+s7dEMW3uUCn+UCshqXvTOAmWZ4gFFRYYdC0fQXziWGg8VmtRm7Y/rL2qXLIYgiTpg+OWnnsGQNrmxKHU2UqRgAANFHgXaidElHoDDQ9p262Wu1O1IaWt+t71ATJx+LzKwA/vfWKhpQbIUi2XC5ObjcNKCYCF21wWzA60//AJHEbu/2XQCA3gP6O9ous20wVQPfbEMWTuAhBP0Qgo2xDwvfz1a1pkHGiurwICPHtYgVBb8XnLf7bUpSU1GJ7zZ8iRsv+HnSzmEp4fqJ3e2xpyJD1uFvL84h7dIlvf2JfHq+tsvUGUyDtTuAI4oiZp0yAe8tWoWb7ri0k3qXWmTJRu8BFC8mKiRbyMpP/+/UNKDYAXu378TIccc73q7VwQ1ZOFFsNf0lvJIxBDukQq9tlv7SbFaa9/u6PP3lk6XLMGr8CQhmZgBIzvSaKavw9qJ6OInS5XD9RAq0ExNe6anDFaTnZKI6Orvndrsw65SJeG/RKtxwy0Wd0LPUEk5foeAwUSHJgscvgOfpPZIcbu/2HcjOy0Uwy9myIXZIBUSh3cwUjuch+H0tdoJmjIGpWuPmLyGYVQehh1SAsWaDjI0p0z5Pl5aO+eTDFeB5HuNmTE3aOUxZpYwWB9iWHd54jjJaEmbIVLvcCYpkwePvWL26H8+fgn++shhbt+zC0YPjL1GRjgyDQdcYpTwniDEGVbLgC6b/cFv6P8IE2baNfTt34ZRzznC+bUWFmBNf0MkJAoSMAISMpplBZkfSX8JBo1FWBVvVGjd+aZyVbgweO2tmWpEkbFzzKS77/Q1JO4etm2CGBdFPO/YlKjxLmv4zKclmaRZs04bL3/61ZJTD0iZFMlHcwXp1p8ybjDdeW4qd2/eh/8BeSe5ZaokU2CaJ6SnpKyQ++3bsQq8Bzn85tRU1vKowjriN4zhwvnC5HORlA4hsFqhH40XzYD3sxs0Co4OMkclpn6fTNgtcu2QZho05Ftl5uUjWBLQlafAUUp3oRBmyAV5sP02XtE+XDGSUHnlDlgiKF9sWajDh6+BuulNOOh7+gBfvLVpNA4qHkBtsuD0cRBdNnCZCC9lgDPD40j/2pgHFdlTuL4Ouas6nrzAWTnnuXeRYmxzPQwj4IQSaUn+b0l9U2CEVRlUNbEUFgBYBoxDwJGVm+rOVH8PQDUyYdZKj7TZnyhp4ryvlN67pDgxJhy+f0lcSZcg6RL8LvND264lWgrYtOruX0bGPqukzT4DX68Z7i1bh8qvPTnLvUoss2SjqRZMFiQrJVoe/sJCeZ+/2neh3tPMlF2w51CLdOVHhzQI94L0eILdps0CmG9G6jNHNAs1DNgsMeMJ1vB2OubSQis8/WoMLrrvK0XabY4zBUjQIAZqATpQuhzdkoTgmMU0ZLW2vUKTL3D5FsuDvYLzo83kwfeZYvLdoFX5z/blJ7llqkSULgYz0HwRLtpBkwRvoGRktNKDYjn07GuvhOFxDkekGYLNwMJdER05/0WGHQrAUFWZNLfR9KmDb4L1e8IHw7LTQOODItTMo0pY1S5ah/+CjUdqvjxMPp1WRejgkMYwx6LKOrP6UppsoXaZC5U7QFBsMgLeDs3v+gA9TZ56A/71NA4rNMcYaU57pfTJRIclCTiG9tsnhGGPYu30nJp080/G2bUWFqyTf8Xab4zguPHDocQPZTSv4WmwWKB26WWBjrBj5ccc/afHF6rXQVDWpE9C2ZoDZNgQfvRcmqkN1/0i7zJAJxliHMlpI22L9fD5l/mRcdcnd2Le3Ar16FyaxZ6lFlmxKd3ZAT8pooQHFduzdvgOCKKK4j7Ppc7YS6rJaNeH0l/CKRDE3cqMdnpmWw5u/WLUNMPZXgpkWOK+7MWD0RYPHjsxMW5aFTz9cgVPP/VlSH49F9XAcYekWbMOGK0BBTaIMqf3ZZtI+RQqvBuNimN378fwpuPqX96K8rBpFxXlJ7F3q0DUGywR8AZpxToRtM6i0wzM5gvqag5Dq6h1PeY5kmji5QjEWh24WyPEMzDQbazKGf4yaOjA1slmgt8VAY7iOd/vnWbt0OXr174e+Rw1M2mOxZA2CzxPTZwppnSEZCJa0n6ZL2mZQ7XJHRD6f/TF8Ps+cMx4ul4j3F63GJZefnsTepRZZslHSh4aIEhWK8fmYyujZAoBr/GnN3u07UdK3N0Sx5aViRzyiDc1KX9iyGq5n0045jEuXvxHzaXiXFfMxgYB2+I0MyIALJaoPpaofpTV+lMCHHHhQAw3lnIwyXkYZJ6OMUyBzRovDG77dg/qDtdgwQMHCL18EALjF2Ptm2W1/CV6gjcLS+p3YXlEXvU0UYj9PyIh9IK00WB/zMX7RaP9Ohyj0NMR8jEcwY7p/jlKK/uJxeG73g7Gdh4/tPADg4mL/+wz374v5GNmOfRVCtqDEfMynDS2/AI2r/TG2chtQs/PAEY/ZH8qGYoWwovwTlH2nd+g8khn7IGU8z7cib+zP61GBPTEfkytKbf5eKJ8GCBlYU7ao6TbYbR6TdZwJXgAef/VqzDknvKKnWKxr85jWuLi2z9OaABf7tY6HzGJ7r1LrhoL3nI4t1dfFdJyB2AMhi8U+aBngW/n8aUc8r+2RhU/GfAzf7PmmKRY4DvD5AK6N56HQTnzQ3nOYdG9Hihn3bt8JAOgzsH+L3yccL4Y0gOfAuVxtxox3bHk65tPwXOw12bLc6uE3+gHRJyDPDCLPyERedQbyKzKQYwWgcxbqXHU4KNbjoFiHg656NAgSWLPLwmyGDxcvQr+ZA/HsnnAMIsbxHmy28/4zUhoMn+3Buu1vRm/T7di/CpXJ8Q2klQZi/2yNh8jHHmPFgmPA6Q1z8A9uOWqr5KSeCwB0O/bPomJf7Nd6Z0Nu+3c6RKY79s+vvQ1Z0f+fbvZCEG4s+mR12307sB1Kw0FcuLrj3wtluXMWW/BC7K/VnIzYY21ZO3IMXAwvfoljMH/NihZvk+19H/SM7It7//4W/jmkaVV2aWbszx1vjN+5gPjef+MR03spA86sn4V/H1iOuqrYvnu64/g+GM93yAJ3298dWhPP985fDogtZgZaxoyqZCK/2NXitta0FTOmSrxIA4rt2Ldjl+PpzkB4haKQ3c2LQnNAAww0wMD3aHpz9TEBpfCjD+9BCfNjpJWPPHghwUAZJ6OcU3CAl7Hxmy8gZvsROKY0aV10Mx65zIcyPvYPJtJSUM9Bg6u2q7uR8nhbgN/MgOQ62O59aT66bZxaBDuwM6ZjMrJFDB8XxKdL6qIDij2doZZA8B55cJt0jNKYvkIrSUhrIiVyevV3doWirYQnoLv7887kLJS76lDuaprA4RmHHCuIXsyHHDMLR4f6I7s+EwBDrasBNWIdal312LlnJ8xaHaWTk7s5Qo6RiQOeyqSeoycIWgHwjENdHBOwpKUiFsB2vgOTnt389d/ViuFDOUIxb+WUNX4w9j35Psx6BWKmv/0D0lzA9kFgPBramfAnbbNthpBi0wpFErZ3+06MnznN0TYZY7BCKlylqVmvIcRZ+AEN2CfURG9zMR5FzI9iFkAx82Oy1Qunzb8M2ikXotLWcYApKOdkVPMNqOFCLWamE1HIAmiADqWTVgals6Cegxp3bVd3I+UFjWwYvAZdaGUVB4kJpxaB5X0a83HjZmXhhbv3QaozEcyijzkz1AsiDSgmjDZkIW3Zu30nCkqK4XU4NdlWnN2QpTPZHEO12ADNVQUgvIqdYxwyrAByjCzkmJnoF+qFkf5jcPprP0a9R0ZtXT1qXHVocNWiVqyH5eBquxwzE5sC2xxrr6fKNjNRKzaAddIKq3RWxHxYy9Hnc6KK4UMZQjEflzl+MPY98R7q121F7sxRSehZask2M1AvyLDptZ0QVbbB84Db2zMmAuibVhtMw8CB3Xudr4djmIBphVOe04TB2djLSdiL8IyGur8Gm3/1HCbddSGOHjkMxSyA4+0iFKkDwABU8goqeBnlvIRyXkYVp8CK482r2A6gnE9+ukVPENBzsDPG1WDkcEE9G5K7tsPLDxl9ZrfO8oAzssG8FTEfOnZWFp69cx8+X16PqT+JPYUp3RihEnizvu7qbqS8kGQjmE0DiqR1e3fsRK+Bzq+wsxUVrsL0eR9jHEO9KKFelLAL4VIm71/zJgb8aCBmXHUycswslGqFyJWPgsf2oEGQUOsKr2SsFetQ66qDzsc+iey1PPDaHtSKnZN2nM5yjEzUuug6JsrLBGTBg3Kugys9KWA8omL48B3iKG+TE4R/SG/Urd1MA4oIDyjWirGX2SItKXLPymihAcU2lO3ZB8s00WfgAEfbtZUQOG/XbMjSWWo/3QaLY6gfnIWNQiWAcIqJR7CQy3wosgMotAMYahZgmt0fLvCo4kItBhkreRl6O3Ufipgf5RwNKCZKsEX4zAxKeXZA0MiG1NHr2EM+aOLBqYVgYgMgxp5SlVfsxtGj/Ph0aV2PH1BkjIepFVHKswMUyUJhb9psibRu7w87MWyMs19IGWOwQ2rKrlDsCLlcQu3WanjPH4W93jLsRRmAcN0vr+VBtpGFbDMLuXoOBin9EbD8kHklPMDYuIqx1lWHEN92VkCOmYkGQYaZ5PqCPUG2mYn9ntgn+0hLxcyPWmhQ46jvRloqhg/LGt87YpU1YQjK/r4cVkiH4OvZn/HZZgYO0qRLwkKSBX8PymihAcU27G2sh+N0DUVbUSH402d1YnPMZqh8bwP2v7wKWccPOuyNmXFANRdCNR/CJlQ13ghkMg+K7ACK7AAGWNkYb/ZGgLlwkFNRxiko52WUczLKeRkK11TAtcgOYKvYfq060raAngNNUKALsReXJi0F9Wzsz/ihq7uR8ji1CMxbHvfx42Zn4V+PlkML2UAP3ojSVIvAcRZ4d037dyZHZFkMWsimHZ5Jqxhj2LdjF2ad8X/OtqtqAMeB86Tnl9zqTZVYd/dKiD4RJeN7H/Z7VdBQJlSgDE2DVy7bhWwjE9lmFrKNLPRWeyHTDELndNS4mjZ+qRXr0SDI0WyBHCOLvig7JMfMxLeUOp6w8KIIqkOZqABEZMKF8jhSngEgc8JgHHj+AzR88QOyJw11uHepJdvMwA5v7JtgkpZCkoXM3Ng3e01VNKDYhr3bd8Dt9SC/pMjRdm0lBCEz6Gib3YF64CB2PfQ/NHy1G/mnHIveF0/v2IEcUM9pqOc1bEXTl14/c6HIDqDACqLYDuBYVogc5kUDdJTxMio5GfnMBwVmeOdDWuwVt4CeA5nqJyaOhVcoNnRgQ5YWB5HDcGphXOnOEeNmZ+HlBw5g4+p69Dul5745GKESiN4D4KgeTkJCsgXBxcHl7rnPJXJkVWUVUEMhxyegrRTZkCVWlmbim+e+wOZXvkL2UbmY8dR8uDM6tnO7wRuo9FSj0lMdvU1gArKMDGQa2cgxszBUHogsMwM2x1Ar1uOgWI98IxuVrhrwjKP6YAnwWG54bQ/qxHogjt2XSRMaUHRGMbyogQYtzh1xPcU58PYvRP3azT16QJFnPDIsP6U8O0CRbBT3Td9M1EPRgGIb9m3fhd4D+oF3ODXZDqlwFafP7qPMslGx6HPse2klxGw/jrnn58g8tn/C7SqcgR1CLbZxTTPKHiagkPlRbAfQ384CBw7nGsOgwWqxirGKc3bzl3QXrvtHK5gS5TOD4BkPxdXBD2N6fh4RpxbDzlsX9/GlA7zoc7QX65bU4f9OyXauYynGVEvh8u3v6m6kvHD6Cp92AzvEGft27AQA9Ha45nZ4Q5b0ymip+qocn969EvKBBoy4bAyGnjcKvJhYnG1xFmrctahoVtePYxwyzSByzEzkGFnIMjOQaWbgqFA/1IlSeKDRVYcKQcZBsQEmpZ12SIvUcRpQTEgR82OrUNuh+9Jnz5HFuyFLc1kTh6Dyv5/CNnru+0CWGYTJWVB4lQaIEmCZDLraszJa6PnShr3bd6LXgP6OtmkbBphhps2GLKE91dj513chf7cPhfPHoNcvpiW1/oTGWdjDNWAP3wDdtOACj9ddm1HA/CiywztMjzGLUWgMBBDZ/CVck7GisS5jPJu/pLuAnoODWZu6uhspL2hkQ3bVg7VT+5O0gwGcltgKRSC8SvH9l6tgGlkQXT0zGDdCpfBkbO7qbqS8kNSzgkMSm73bd4LneZT06+Nou7aiQszPcbTNrmKqJr56cj2+/+c3yBtWiBPvm4WsAcl7bIxjqHM1oM7VgH2ecgwODcCb+UvgZq7oIGOJVohhRha8zI16QUaN2IAasT76Xy2OzV/SXXiHZ0odTxTPOBQwH8pohWLCiuHDgQQHFDPHD0b5qx9B/monML3AmY6lmOiGLD0zXHZMSLYgujm43LRCkSBcQ/Gkn5zqaJu2ooLzuMEJqf3FhFk2Dvx3Lfa/vArugkwM/tN5yBjhbCDdniIWQHnj7tBlnIwyXsaXjb9z8RZyopu/BDHEzMcUux88EFHNKagQ5MZBRgkVvAytB89Mc4xDILIzMUlIkK6jM/QcgAlgnqqEmhk3Kwv/fqwcG9epOH5S+m5q0BYzVIJg4TJKrE+QIlnIKew59XBIbPZu34miPr3gcjs3oRrZkCUdam6Xf7Ef6+9ZhVCljGOvGodjfjYCvNB5X7ZyzEwofAi6YECHAUlUsMcb3sBBt0X4LDdyzUzkmpnIN7JwTKgPMmw/ZD7UOLgYGWish9zO5i/pLsfIoh2eHZDPvLDAcBBUuzxRxfBhcxw7PDfn7V8Id3E26tZu7sEDikFKd3aAIlnw9aANWQAaUDwiXdVQsW9/EtJX1JRPX1F3VeD/s3feYZKlVf3/3HwrV3UOE3dnc2Ajy+7CLizJBUSioIQlKEpSAUHiDzEAEkQEBAmCIKCCgoCSFBQkLivssnl3Ys90DpXr5vf3R/V09+zOTHdV3eqq6r6f5+mnZ6rrvvfUrRvOe95zzvfYX3+F2oEphp/6UMae8wgUc/MnWsNBgp+rJxdtEBIsSjUW5Rp3rRF/SQmd4SDJUJBgp5/mCneMtDDISxZTVJmWq/XgpFSlhLstVmlibhohBVhqCYJowtwKSTdLvgHlQ0mSohaKJ0GyhhHGHLSY6bn3ghiD4xr/843KtgwoBr6J7/ahxqaI8mxao1bxGU/29rM7on0cPXCInSH3TxS2A0IgmRvrLdiNeFWHuz7yQw5/+XYGLxnh+vf9CqmdmU23I7uOIEtNcTimzHNszSKWFqj0eanlQGOKXfYQGT+BK/lMS1Vm5QozyxUw26nFTs5Lcyh2tNNm9DzDIs6sVN34PEMCROQwPhAZGMZkmtYC/ZIkkX7YueT/+5cI/1qkTVzw6BayfooJPVJvb5Va2See3F7nTxRQPAXHDh9BCNEGhecaSjIe6pibhfB85v7lB8z98/fQR/o49z3PI3nueEdskQQMiTjTUqWBjaAkOZTkRe5fI/4SEypDQYKcm2ZEJLjQ72cAkyoe01I9wDglVZmRqyxgbbkgY/K4IMsW+1ydIOXkOJq6t9Nm9DyyNYxoIDB7KiRJ4qrHZvne1xd51dsEsry9TnK3NoqsFlDUCm4QPe6bxXMDXFsQS2wvBzFi4xw7eJjLHnFNqGMGPS7IMvfTI9z27u/iFC0ue/U1nPX085E6dA/OeWmWtMYymFzZY0ZfYkZfFVmThUzOS6JUBxkKElzqjTAYJJA43mKnwuxyL+85uYq3xdqfKEIh5SeikucQiARZwmEAkwDBYgiZnplrzmH+yz8mf8c0uYvHQrCut8h4KW6P7++0GT1PrRzQN7K9EnSiGcYpOHrgEADjYQcUaxbaUF+oY24Gtf1THPvAV7AOzzL49GsZfNZ1xOOdWynLCRMJiQWptZ4ZADXJ47BS4O5g9cGuCZkhEWNE1PsyXh2MMOzHCRDMSFWmlgONvidYUso9rRiYcHKU9UZUiSNOhhpomH6CkpbvtCk9j2QPEcTDyYB46OMyfO1Tc9x1q80Fl26vDDOvFgmyhEG1HKAbEqoWBRQjHozv+xw7dIQn3/SboY7bq4Isbsnmzg/9LxP/cRcDl+/g6tc+laHdnc2yzHlpjhrTLY8TSAELWpFpddXnkwRrWuwkOMvv5+HuLkxUFqXaSg/vGbmCHNRwergvY9ZNYUsONTkq022VYRHnLjkSQ2yVuiCLFUqxT/ycHai5JDPf37/tAopGoBEPzKjkOQSqFZ8d26yiJQooAobmYmgnPuCnD+0nkUoyMppGkh788A+CxicWluMjHBclYSLJG7v1pbKNr14lDKfhbfpjJ8/08x2f+z/9Uw587haSe/u5/G+fRebsQaBEUmt8P/NW49mZtv/g03RMxJiTKyjqyXsfanLjPREziRPT5X0KHAOOLf9fEhLZIM6Al6LfT3G5n2WotANFqJTVIgW9QFHLU9QKFLUC3imcxpjS+HHbYy40vM1G6XdTlNP3Mq4vUQ0a7/+UUxvIEl1mRM03vE0paLxk9ZjdeMP3wUTjK+9nxWYwquN4aom9yYkNbVPzdSQEpuyS0zd2nTtNKCrKTbhZShPbWKLx1Tj9VL1LrWHkvp/CSf4u01jGx0VXmKT7VL76dUhcuPG+OGfpJ2+ncDq0JhYWLNH4syTYYG2dUxtDMacIhITSRKaM1UQLhHzQ+D2+KhoPNvhN1Bf6NH6sFQJqZZ9YUtlwEre2Tk/e9f4e0d080Gc8dmwCz3XZe/aOB/mS0Jy/aAcSQa2G2pfZsL84HC83vB9d9hreJqOdeiH38PeP8v23/wS36nHdm67i3KfsQ5ICaEIwwW4iqzoIHnyVKkIm7SUp6Hnkk9yjN3o/XcvQg451mQXmWADuAhAQD4x6ubSf4gwvxRXuMKmFC6jIVfJacUVlOq8Vqcq1UKtEUmrj5Z+eWN+/GLbjlPQ8iWX/32vCJ1Gb8M+zTWwzbyUb3map1vjzq5m50FiiyFg+xu2JOcY2mO05IQtAoJ1i3nMymqmQFie5htbfT+P3uMVi48daUR/sxwxJMaaw8E5hg+83ZlviynOZ/N799N/0+Iayw4cSjd9/mzl3mrl+NnKfH7BTVJUqml5BA7RNyq4Omjh33A3cqx5ISmn8ntiMzxg4Hp4jiCXC8Rl7xV+MAoqnYOLAYXacsSvUUhO/aiEZGpLaG406hRD84m3fYPbHh9h300M58zcvR9a6w/bhIMms3HggqxWEJFhSKiwpFe6jvtI9HisQ8+Ok3SwZN8OAPcQZ5bOI+XGqSoWCll8JMhb0PHa3NfMWoNsD2MYPO21Jz6PZA7gNioj0aCVbe/F1cPrAbDygdzIUReKyR+e4+VuLPOsPd/Rs+WAzeNYo8f4fd9qMnqfeD6c7nn0R3cfRA0cA2HlGeD23hRD4VQt9x3BoY7ab+75xkO+8+QfsvGaM6954FcmRRKdNAiDtpXAlj+pm+l8SVBWbqjLHUeZWXs7IgqybJuelyboZxu0R0l4SV/KWg4wFlpZ/l9QKosuqX9JOlkKDpeMRDyYmdEyhsaQ0HoSKOJExKcbdIrwS/NRDz6PwrZ9ROzhL/Izeuf+2StpNU4xaGbRMteyjmxKqun3mGhAFFE/JxP7D7DpzT6hjBpXeEmSZ/PY9zPzvAS770xsZuW5fp805gWE/wT1qawqwoSBBTa1SU6vMrCkt1H2dtJsl7WZIu1nGaztJeCkc2aasL1HW8pT0Jcr6ElW1XK+Z6QCKl0QOdFw9KrtoFc0exDXm1n9jxOmxhkAtgxbegsGVj8vx31+Y49j9NXac1Zs9bBtFiHrJs2pGJc+tUqv4DI71rjBGRHs5sv8Qmq4xvGM0tDGF40IQIMd647yrzFf5wbtuZt/j93DDn13bVQs3dVXiQlf0iXZllzljgTljteqknkGZIudmyLpp9lV3k/XSICQKWom8Ws9iXFILFNQSfhMZSmGRcTMcSEY91lql30tR3II9NjvBCCbfEeEJicQv3IOSMFj64T3bK6DopSlG6u0tUysH23IBOgoonoKjBw5z+SMeGuqYQdVCifeG0qg1X+aO93+Pscec3XXBRAQMBgm+Jx/utCWnxFEc5pVZ5s3Vh5wSKKS8NP1ekpSbY1fpHBJuXe1wNcCYp6QtUdEKBJvgNBr2AK6eR3TQQd0q6NYAxb4mzslIte9ErJHQshOPc8HVacyEzM3fWto2AcXAzSICHTXkY7ndEEJQLQfbTrEvYuMcPXCY8T07UZTwJhFBZVmQRe7+804Iwff//CfImsy1r72yq4KJAFk3fVqF507jSwFLWuEE0RhJQNJPkHUz5Lw049YIF7hnowudslJeDjAWyS+XTNty46WTDSOOBx2iDMVW6fOTLDSTnRi5iycQRyEr6Uw30VLhVEiaSuah+8j/8F7Gn3tdaON2O2k3zf5EtFjQKtVKvUXOdiMKKJ6ESqnMwuw8O0IsX4F6ybM6kA11zHYghOD293wXRVc4//e672aaEjomKnObXPLcKr7sk9eXsGOrE3xJSMTdFEk3R8rJMVTZyZnuxaiBRkUrUdaWKOlLmMERHGOOQAm3EXa93DnKqmsZIaE5/bhmg8eyu+Zd3YE1DGbrzfPXohkylzwyy8++vcRTX94ZZfrNxq2NoRhzSE30SItYxbUFvlfvhxMRcTIm9h9mZ8gVLX4PCbLc9+8HOfz9Yzz+PddjZrsvozLnZbgvfrDTZjSEkKCkViipFSZYzjIXEAtMsm6arJemz81yZm0XST9BVbbqwUW1SF4r4pqzVJVKqD5G0ksBUI5EG1qm30+x2Ohx7LJAfTcwgsmScLAa7K29Hrmrz2bxu3dgTS1hjjbei73nEFGGYljUyj7DO7rvOdhuooDiSTjeD2fXmeEFFAPPR9hOTziIx755N7M/OsTlb38ieqb7MiqHgyQLUhW/y3rLNIOQBBW9SEUvMpNYzm4TYPhxUk6WpJsjaw+SLZ+J5qXx1BK2MY9jzGMbczjmPJ5aatppNOwBrJCDN9sR1ckhEHjRyn3rWMPQd0vow17x2Bwf/IP9zB2zGRzf+g97zxpFi0112oyep1r2MeMyshJN5iJOzsTBw1z/xMeEOmZQtVCzqVDHbAeV2So/eO/POOsJe9nzyJ2dNudBSEIi46ZZ2goTZQlqikVNsZhitfpFC1QyXpqcmybrZRgtD5HJX4ov+ZS0PEW93su7pBUoaYWm+zKm3Uy9x1p0K2yZPi/J/Xrke7fKqBRjKsTsxOOkrzgDSVfJ//BeRp5+VejjdxtxP44sZMpq1NOzFeoVLVGGYsQyEwcOAYSaoehXbCRNRda6+5Bbc2Xu/MD3GH/cOQxfe0anzTkpQ0GCWaW3shMbQgJbrWKrVeaXV6b3mAvIvoFu96PbAxj2IPHyXnQnRyB7OMY8jjFXDzaa8zj6EmygN4tuD1DI3t7uT7Tl0e3BuiBLE45674fFQ0SwnKEYfpnuJddnUTWJn31riRtfOBL6+N2GZ41G/RNDoFbxo+zEiFPiOi7TRyZD7bkthCCoWshjG1el7wRCCL735z9GNRSu/cMrOm3OSUl5CZAE5S0sfuHKHvP6IvNremGnFZukm17u5Z1lR2UPKTeLIhTKWnFZLDBPaTnY6G0gkz3jZqJy5xBQhEwmSLCoNJPpGXmMaxnFZEqEL7akmDqZy/ay9MN7tkVAMeNmKKmlrhOB6jUcKyAIIJbo/lYlYdPd0a0OMXHgCNmBPlKZdGhjehW767MThRD88t3fQTG0rix1Ps5QkGBC2QKrzQ0SKDZWfBIrvhokkAIFzclh2IPo9gCp4vkYcwNIQsHRF1czGY15bGMeobgr28q+juZmcBpUJo54MM0oPANd12uq47hZCDRoQxl+LKlw4bVpfvbtbRJQrI1hZn/RaTN6nmrZj/onRpySycMTBEHAjjN2hTZm4HgIz0eOdbfPeO/XDnDkB5P8yvseiZHuzqzvrJchrxYR2+xRKyRBSS9Q0gscY7X6JeYn6mKBTpZ+e4i95bOJ+XGqSpmCVqSg5SlqBQpaAUupnZCNmHYzTMeiRapWyfkJHMmjIjfWwihyFx/MqBTj3hAFWdaSveZsDv3lv+MsltH7km3ZR7cQlTuHQ+14RYu8/S7WKKB4Eib2H2Ln3vCcQwCvYqEkuq98eC1Hv34Xcz85zBXvfBJaqnsd2eEgyS1a5NQACNmvZySaa4JZAlQ3jWEPoNuDxKq7yC5ehuoncbXCSpBREOApFQI5/NW97YZmDWIlD3TajN7HGgZjHtokEnTl4/r4+JsPUlxwSfdrbdlHNyACBc8eijIUQ6BaDsgObN1zJaI1juyvB2vC7KHoV2xk00BSujeQXZ6p8MP3/Iyzn3QGux+xo9PmnJKcmyYfTZTrSFBTK9TUCjNrAoOar5N2syScHBk3w1htBykvhSu5FPTlAKNaIOtkuS95Twc/wNag30vVsxO3X8whVCTqPRSn25ChCJC96iyQJfI/upehJ17Wln10C2k3TV7Ld9qMnqdW8Ylv04qWKKB4EiYOHGHPWeGW+/oVGy2bDXXMMKnNlrjrg99n/FfOY+jqvZ0255TEhEpaGMz2mCDLpiKBpxfx9CKV1GqQS/bMlSCjbg8Qq+5A8WPs3v8ibLPel1HT81j6Araeb6p8d7ui2wMUB37SaTN6n1r4Cs9rueyGLAD/9508j3xmd5cTtoJnDyFJHoq+1GlTehohRN1B3Ib9cCI2xtEDh4nFYwwMh3c/8SoWcqJ7F3Xrpc4/QY2rXPOa7ix1Pk7Wy3DEPNZpM7oaV3FYUGaZMRZWXpOFTMpNk3GzpN0MZ1TORBM6D1u4lpJWpKAVKGoFJqUaeaWE26ZFwK1In59icQuX4G8WA9SzoucJV6zyOGoqRuqiXdsjoOilORI/0mkzep5aefv6i1FA8SRM7D/Ewx//yNDGE36AX3MwurTk+XipsxrXOP8Vj+i0OadlKEiQlyxsKXJeGiVQLWrqUWqJowAMTt+Ap1SpJg+g2wPo9gD9hfMx7T5AwtKXsIwFLH2h/ttYJJDd0+9kO+IlUPxEUyXPAIgocLuCNQzx9mXVpfs1zr0ixc3fXNzaAcXaGKo5jRQtCrSEXa33oTVj3ZspFtFZJvYfZscZu0NtX+FVbORk95bY3fNv+5n44SQ3vv9RGCm90+acGlHPULwtdVenLek5AimgoOcp6HkAhqxhzs9fxM39PybtZsi4GYasYc50s8QDk5JcYVEtsaQWWVJLLKpFarIdZeGdhD4/yb1GM36OFLVQXMMIJjOh6zufSO6ac5j46H/ilWqoqe6uMmwWWcgkvSSFqD9qy9TKPv1D2zO0tj0/9WkoLOYp5YuhNtj2qjaSpiB1qSDL3DduY/6nR7jiL34VLdWdfXCOM+wnmZWjlb0w0O0Bqn0/w47NYsfqPUiqgQ5CQnfTmHY/MaePVHUng0uXoPkJbK2wEmCsGfXfKJVt7TRKtWFcLY+Igq2tYw1D3/+1dRdXPDbH5981QbXkE09tzZVEzxpFjXpdtUyt4hOLK0jbsB9OxMaYOHCYnSEK+EG9osUYGgh1zLCoTJf54ftu4Zwnn8mua8c7bc5pSfgxVKFSUJsRv4hYS9rNUNTzVLQyFa3MFPWsz4ITwwx0cl6anJci56XYY4+R9hM4kntCgHFJLVHcyoKKG0HUA4pRhmLrjEmxtgiyrCV79dkc+fC3KNy8n/4bLmzrvjpFyq23N7Ci9lctEQQCaxtXtHRnhKuDTOw/BMDOM8NzEL2yhRo3ulKAwZ4tcPhj/8WOJ5zP0MP2dNqcdRkKEsxE5c6tI2R0uw/7ZFl1ksDRCzh6gSKrJdOKFyNm92M6fZh2P5nSPgw3Q6BYuMYcrjm38tvTl7ZNybRkDeO0QURk2xFo4PS1teQZ4PLH5vjMnx/h1u/lufqJ/W3dV6fwrFH0KCunZWqRIEvEOkzsP8xFV14S2niB6xE4XleK+Akh+Ok7voee1Lj61Zd32px1yXoZimqZQGpnDtP2IONmTtljzZIdpvR5pvRVf1IRMlkvRZ+XJuulOKe2i5yXQkIir5bIa0WW1CL55R9vm5RMJwMTTSgsRQHFlhmVTO4T7T2O+kCKxNmjLP3w3i0bUMx4mbogS/eFKHoKuxYgSWBs04qWKKAI+IGMH9RPgEP313sIjO7es/LaqbbZKG7FQd5EQRZT3VimlBCCe9//H2gJnQtecS1ygwEguQknLb5B207FsEhwnzqNoXinfZ8qN25bM9sETdyB7aDxy64aNF5WFJedU/5Nd3II2cd7QLPyXfppynZ1ID6x8l8HcAKVQS9OUBtD1EYJCucTTI8CErI5g2ROIccm6z/mNJJS73Vy2G08+8IXjd+kc1rjwefvFc5t6P0XlM4mr1S5p9TYIsSwUUKWBKbs0qdvzM4lJ97QPoCGr2sAtQnn3pQav7Y1afU6DuwRfMVC1ZZOq2bYzH4ssSqqMbZDYe8FMf7v24tc96TMKbdR2lpIs0rQhPyoI06/AurWxtEH/3vd961HM/e3oInrNB80nhnvNvHZGr2HVMs+ibSKT7gOYtjjRWwux33GWqXK3NQMY3tD9BdLDrKpISmNn9+O3/g2agN+3P4v38nMT4/xqx94JMmUCm2+RzYTCPTW1IT2uWnyagF5nTrRqte46JLeZACs6jXuy3kNnD+tcLpnUdLJcq8xSeUB9sfVU/uZNc3iGHOsdLAUkPQTpJ0sWS/NDnuICyr7iAUmZaVCXi2Q14oUln/XZGslyHHP0lDDn2ezWn4cKWQ3/N5zRZY5LA42sM1xfCEhBLjexq9z4Tf+DBdN+CTNHOtm9iOC1W1G5BjfC+bXHacZhXfLXb0nJK86j9l//j7VMsjGqe8VzfhLzcyjE8qpr7lmyLopyloB7QG2NDMPUJqoyW/mGHhN+H9W0Ph9vhGfsVJyMRIqgRRuhmKv+ItRQPEBHD1wmMGxEcx4eAFAv2KhjXdf+crUv/+SpVsOc9E7no6W7O5SZwBNyOSCGLPRyl7L6NZgPTux1RUp2UOJT6CsCTQKISGcfoLaKEFtDL90Dt7soxBeGklfQDaniOt5PHMWz5wjUHtb7S7lZjhsTjW3cQ9/7tCpjSCZU6cNJobFVY/P8uW/ncGxA3SjNx7WGyXwYgRuFqXZczJihVrZZ2Csi3vERXSUY4fqC9A7z9gT2ph+xULpwuzEylSJWz/4Y/b+6rnsvmas0+ZsiKyXYUaPqgdaRQ0UUn6CJbXFHmsSlNUKRaXKUVZbchi+TtbLkHHTZL0Mu2rjpPwkjuRS0Ark1SKGL5iRKixIFkEPV7+MiBhTUq2pbaXIYVzBRKZP0tte8gyQvvo8Zj7zHco/30/6YY0lHPQCKS/NdNQip2Wsskdsm5Y7QxRQfBBHDxxix97wyp1FEBDUbJSE0VW9dK3pAgf+9r8ZfcJF9F25B9qkkhUmA36SquRSPU3mXcTGMOwBnGZFRNZBkgSSMY9szEP2lyuvCzdJYI0S1EZRqnsxiueiOH0I2cYz5+oBRqMeZPSNBeiBMiVZyMTdNIVWHe0IhDWMFJvelH099LFZ/vEvp/jlD0pcfsOpsxR7Ed8aQdLyyGpzk5aIOoEvsGv+tnYQI07PaoucPaGN6Vcs1GR3Nf8XQnDzO/4HPWVwye9dTS/4iwBZN809ifs7bUbPk/XSWLKNHXJm1HFsxWFGmWNmTesYRSik3RRZL03GS3OpN8CQiCMjMS/VmJErzErVld+9ItQ4IuJMSFFSRKuMSiYF4VKl/d+7Md6PsXOQ4o/u3poBRTfDfVGLnJapVXwSme0bVtu+n/wUHD1wmPMuuzi08fyqjSTLSLqG6JL4iAgE97z3W6gpkzN+5/pOm7NhBoMkc5EgSyjo9gCl9N2buk9JK6No96Gk7qPk3ll/MVBR7X5UawjVHiKWvxjFHkQKVDxjHn8l0DhHYMwjlO6ayCTcNL7kUVNaCN5EKs8ACGsUOddeQZbjjO8z2XtBjH/76DSXPSrdlf1tm8W3xlCj7MSWsao+sixtuQzWiPA4euAwqWyaTF82tDH9qo0xnAttvDDY/+W7mP3ZMa77qyeiJXR6IaBo+DqxIEZeLa7/5ojTkvXSLG3ycfQlnyU9z9KyyvR9wWBdtVsYDIkEw0GcvUGGq7xR0hjkJYsZqXpCkLG4pmS6Wxghxs1SC1mzkb8IwKgUY1Js3qJp9pEXMfv5/2HoNx+JPpzdtP22G93XMQOTkhbdJ1vFKnsMjHdfdcFmEQUU1yCE4OiBwzz2Gb8a2phB1UZOmF01YZ362q3kf36Ei//iGaiJ7i91Ps6gn2ROidT6WkbUA4rtylBsCNnDi83gxdYIcQiQ3Uw9yGgNoVV2EVu4gqyXxleLuOYsnjG//HsOXyt0zGlMOlnKer7p/XfTfaGTCAHCGkEyNydDUZIkfuM147z9Rfdzy3cKXPHo7KbsdzPwrRGUTTqOW5nj5SvRNRpxKuoKz3tCGy/wfITtIifMrqloKU8Wue2DP+KMp5zHyEN3dNqcDZP1MpSUMp58+n7bEeuT89LdEZiVYEmyWcLmHmVx5eWYUBkK4gyLBENBnHO8HAMijoPPrFxlVqowK1eYkavMS1X8DpVMG0KmD5Npqs0NED2KVhjF3JRy5+P0P+mhLHztp8x87rvsfNVTN22/7SblZagqleg+2SL1ipZgW1e0RAHFNSzMzFGr1sLvh5Ponoh1barA/o9+j9EnXUzu8vBKuzeDQT/Jz4wjnTaj51G9FHKg4uiL67+5E0gQLKtMO+n7Vl4OvDiaNYhqD6JZgxjlM1DtfoTs4RlzuMY8njmLa8zhGQuwCQ/IlJuldArlw4gGcDPgG2DObtouH/KIFBddk+Jz757k0uszKOrW8Nb92ihG/486bUbPU6v4mInIRYo4NUcPHGbHGeH5UUHFQjI0ZFXB74IKThEIfvb2/0HPmDzk5Q/rtDkNkXUz5KOsm1DIumnuThzotBmnpCZ5HFaKHGb1+1aExCCxeqAxSHChP8gNbgIdhXmpxqxcYVaqBxln5Qo1qf3+4jBxSjhUJK85pZCIFUYlkx8EC5u2P9nUGXr29Ux+5N8Z+LWriZ0xsmn7bicpNx1lJ4aAVfFRVAlVl6FrlgM3l8hbXsPxfjhhOoh+xUIf7QttvFYQgeCe93wTLRPjjJf0TqkzgCwk+oMEc5EgS8vo1gCOvgRNqFp3EqFYOIkJnMTEmhdlVLsP1R5CswYxi+eSsh6BFBh4+iIJYxHbWMA25rGNefyQ+8ql3CxT8cMtjRFVsNSzEzHmkTZxlVSSJJ7zunFe/5S7+Z8vLXDDM7tPOKtRhADPGiUeNdhuGavske6PBFkiTs3EgUNcdcPDQxuvLsjSPVUj93/pDmb/b5Lr//p4qXPvkPUy5KPexi0jCYmsl+qODMUG8KW6iMuMXOGXLJcYC8gIgyERZyhIMB6kuNQfISdMSjjMyhWOCYtpqcq0VGURO9S434iIMU2LPmjkLyKx+SXPALnHXML8v/2YmU//F3v++Dmbuu92kXYzFLXoPtkqtYqHuVLRsj0v0iiguIajBw4jyzJju8Mp6xCBwK/aXZOhOPvduyncOsHF73oGary3nMO+II5HQEHavBT3rYphD+KYXVDuHAZSgGfO45nzWMe1NQTIXhLNHsSvjWFYg6QL56G7WTyluhJcdJYDjY6eh2ZKYES95LmUvbUF+5vfdCshrOFNK3deyxkXxrnmSTn++a+mePiv9qGbvd0vL3BzEGgoxuZlem5VahWfod3bt3wl4vSU8gUKC0uhivj51e6paLELFr/88E8586nnM3xF75Q6HyfrpjkUiypaWiXlJwgkQVmpdNqU1pGgINkUsLlPWVp5WRcKQ0GcIZGg30tybTDCEDEEgllqTEu1lSDjDDWcJgUDR4gzLTVZ7gwQtd8AoA8dGZjb5F6ukqow/PwbmHjnFyjfeoDkQ87Y1P23g5SbZs6YWf+NEafFKvvEtnlFy/b+9A9g4sAhRnaOo+nhBNsCywZJQja0UMZryRbP5/Cnf0j/1WeQu6y3Sp2hXu48r5SjAEwI6PYAVvxYp81oHxIEWhlbK1OKr4pTSIGGYfcv/wyQyV+EYfcDEo6+msmYxaWsF/Bk97S7Mfw4ilCpaAUIoltpK4ja6KYpPD+QZ79qjFc9/g7+4+9necrv9HYZi18bRTFnkeQuqJfsYXwvwLWCbe8gRpyaiQP1zPQdoSo822gD3aE6f/c//AKAC37ris4a0gRqoJLyk1GGYgjk3AwFtbSlK3QdyeeoUuIoJWqiPl+TBfRjMiLijIgY54gs1wdjpNBYoJ7FOCPVmKbKFDUKOOvOT0ZEjB9J0WJfq4xKJjPYdKLGKv2wc4mdPc703/8XZ75nL5LcwxeGgJQXlTyHQa3skRnsrUStsIm85TUcPXCYnWeGW+6sJIyuaOo+8+07qR3Lc/5bwhOc2UwGgySzUblzKOj2AIVcC1l1PYqQXazYNNbawJWQ0NwMhj2AYfeTqO7iQmsQ049TUyqU9DxlLU9Jy1PW89SUyorTmHKzVNUSQZOr1RGrCGsEOfeLjux7ZLfBY39jkC9/ZIbHPGuAZLZ3H4u+NRoJsoSAVfFR9eP9cKLrO+LBHF0OKO4MqUWO8H0Cy0GJdz5DsbZQ5f4v3sHZv3ExZi7WaXMaJuulqck1bMXptCk9T64DCs/dQCDBHBZzksUv17yeFCrDIs4I9UDjhaKPfkwcfKZZzmSkyrRUY44a3nL1iyRgiFhrGYoRAIxJMaY2udz5OJIkMfKCx3DwjX9P8Qd3knnEBR2xIwzifgKEREWN5tatYlV8Rvb07twhDLb3p38AEwcOccV114Q2nl/pjnLnwPE4/JkfMXjd2ST3DXXanKYY9FPcqU2t/8aI0yL7BpqX6g6F525AErh6HlfPU07dD8Dh2gCar5N0s6TcLEkny2BtnISbIpCCeoBRL2B4MSylihxEZZGtIAIV7IGOlDwf5+mvGOG//3WBL31kmue9vvfK+45TDyhG98lWqZV9YsnIPYo4NUcPHKJvaIB4MhHKeH7FRtJUZL3z593dn/45si5zzm9c3GlTmiISZAmPrJdmwoh68h6nLHmUpSL71wrABHUBmBERY5Q4l4oBhkWsLgCznM1YwkVGwhJeS5VWYpv2Z1vLqGRyUHSuBD9xwW5SV57FzD98h9TDzkXWenMOkHYzlLUSokOq51sFzw1w7QBzGys8QxRQXMH3fSYPTbDjBSELsgxlQxuvWaa+/kvs+TK7bwovWLqpCBj0E8ya0SpKq+j2AK5aJFA2t/dIr+EqDkvKLEtrVIclIZNwUytBxozTjypUHnXsqZTVCgW1QEErUNSKFLQClmyt6zh2Pne5C7CGQLGhg42hM/0aT/6tYb704WlufP4QA2O9WbrgWyPo2f/rtBk9j1X2MBPb2zmMOD0T+8NVeK5XtHR+Abo6U2b/l+/k/Bdejp7qHoGYRsh66ajcOQwE5Nw0tyXv7rQlXY0nCaaoMiVV+TnLysMCMuiMLmcyni3qrQxeKy6h5Lv1LMaVjMYa81gEkUO4IUYlkx9uosLzyRh+3qO5//c/wtK3bqH/iQ/tqC3NknIzlKL7ZMtYFR/NkFG13u7B3ipRQHGZmaNTuI7LzpD64QghuqLBtm+5HPnsTxi+4TwSu/s7akuzZIMYMjJLclQq0CqGPRBlJzaJkALKeoGyXoDEYQatMe7I/ISKXkS1B8i4GTJuhl21XSS9JI7sUFTrwcXjgcaiWoxWAx+AsEaQzOmO9xt/0ouG+OZn5/inv5rk5e/a01ljmkAECr41hBKLMhRbpVbx6RvpzWBKxOZw9OBh9l1wbmjj1f3Fzp9zd37q/9ASOmc988JOm9I0WTfDZDISGmiVWGCiCY2CWuq0Kb2HBAUcCjjcLeVRA5kZanxDmmCYeL1sWsR4mBhmmBgSMCtqy0HG2krA0ZKifshrMZDpl4xNV3h+IObuIbKPegiz//Q9so96CEq88/fuRkm5afL6YqfN6Hlq0QI0EAUUAXA9hUP31dXgRnbtxfVaPzH82nLvFsMgWF52UpXGezEpTWzTH1sNvN335V/gFmo85LcvIRk7dUBOl72G9+M1UerpNLHNGcRYUsqY2sb74chNBG28oPHVBbmJ8oOK1/iDZ95NNrzNkP7gkp8+a4iqsYglTn7p6004L5ZoXHRIa2I/c16q4W1+UdjV8DZld/3sNFUoPNpLcocnUwviDJhzTBlzK39XhELaTZHx0mTcDLsre8h4aRShUFLLFLQCRuIoF553IWnDIqNuLFiuNiG2EYjGz2ujiftBXG4861UhILCGkc0plA32qjOl04vlnIwztbn135SFl/5Bir94yyIvfYmGe24zvcMaP26VJq6fk11zgTUKsoujlpFO8neXxu+9laDxe1Uz21SDxjNC3VPcw06HJzZ2DGplDy2ewhMKQRN5xO46+6kFjZ/DEd2D48pM7D/EI574K6H4i1AveVaz6Zb8xZLT+LWX1Vcn5qWjRQ5+7W4uffmVJFIyp7qfyZvUN7jiN35fkIVM2kuxpBY3fO0GTSiOLNnN9ZbMGY0HQuZrjZfVN+NrP9BvTjv95OUKC+6pz6u4ujn3soTeuH+xVIs3vI3jNjGvcdZ/Fg2oCe4JyiwGGou43K+tBnIkoB+DUWKMSiZniDTXMkxW0lkKHKaoMUWNe3efw10HlpAEGxbJEX4TWVNNLO4GTexHbqI/8aAUoyhcih6wQZ9GbuJeupH7et+zHk3h+3cw+6WfMPCsRzFTbnyOMjTQeOVdzQ9H6DXpZrg/NnHK8YwmToRmYgk0MUfxReNz72b8zI34jNVygJHQVt4bts/YK/5iFFBc5tjBw2i6xtD4WCjjBVULOWZ2VJDFrTjc8w8/Z/eTziW5ozuUA5uh30+xEK2QhoJp91NKHuy0GT1Pn5+gJrnU5JMHuX3JZ0nPs6TnV18UEPfjZJeDjNnaCDf9xosZGhjGPVDBNhaxjAUsfaGuOK3n6528tzjCGkHOdIdI0FOeneCzHy/xgb8o8N5P9pYYQWCNIJszHc/07HVcx8d3BUa04hxxCvILi1TLFXaesTeU8YQfENRs5A4Lstz2iZ9j5mKc/bTzOmpHK2S8FJ7kUVE6m8G0FRjwUyxEgg2hMC7H+K5/8oVNAcxjM4/NL9e4fHGhMEJsJdD4hIsexm9d+0QCITOzks1YZYb6v51tIBA4JplMBd3RskkbyJB9wlUsfuWHZB93BYz2TpaiIhSSfoLCNhRcChu74pEb7a35QjuIAorLHD1wiNHdu1CUsFabO1/uvP8Lv8SrOJx70+UdtaNV+r0Uh/UNZBhFnBYpkDGcLFZU8twy/X6KRaXBILcEVbVKVa0yaU4jklO8+4X/zZVP3suNL7oK0+7HtPvpz1+I4fQBEra+hGUsYOsLWMYCeqDhyL2xWrURhICgNoo68q1OmwKApkm8/HUZXv+yBW75UY3Lr+4dJ6EeUIzKnVvFLntopoKibu9+OBGnZvJQXeF5fG84PRSDmoWkKkgdFGTJH1zi4Dfu58rXXI1q9u7UIOum64Is0cJKywz4SWaigEPLJFDISBqTwmpouyo+ByhzgDIImP/3b1L56f1c86E/WFGZPk9keRRjpNBYFPaKwvQ0VaaosdW+vTHZZCpo7Di2k/6nPpzCf97Cwhf/h/QrH9dpczZM2kviSC5WE5VFEasIIZZ7bvfuMzMsoiOwzNGDh9hxxp7QxguqFlp/57ICnaLNfZ//BXufcgHx4cbLZbsGUQ/e3KLu77QlPY/h9BHIHm604twy/V6SBSWc42i7FrXYNLXYGpVjIaG7aYzlIGOitoP+/MXs8VJU5RpLapG8ViKvFsmrRcpKZcMlMF2FlwI/1lGF5wfymCfEuOASnQ+9c4lPfLmzWeaNEFgjKKm7Om1Gz2NV/G2v1hdxeiYPH0GSJMZ2N95S42T4FQs53tl7zW0f/zmJ4ST7nnxOx2wIg5yXYSkSGgiFfj/FHcaxTpvR84xJJovCwWqixPeB+L7PrGQxi8Vta24XCaEyQmwl0Hg+WQaJ4WQCJn2bY77NpG8x6dtM+jZuj6pFj0oGPw6WOm3GCkoqTv/THsHc5/4L62lXYI73ddqkDZFx0xTVaOGlVTwnwPcERhRQjAKKxzl64BCPuPGxoYx1XJDF2DkcynjNcN8//oLACzjneZd1zIYwSAgdQ2gshhS82c6Ydn89OzF6gLRM3dGeaHmcU84fJYGjF3D0AqXUgZWX787vJeulyHppsm6aUfsMMl4KgaCglk4IMubVEm4z/Uw2kcAaRdIXkboo61KSJH7v9Rl+59lzfPfrVW54QuP9qzqBsEaQB/+702b0PFbZxUyE06MoYmsyeegIg2OjGLFwqlCCDgv4Ld4zz5H/OsjD3vQIFL23g+lZN8398cOdNqPn0YVCJoiFtnC6nRmVY0wGrZfgn27BoSJ57KfEfkorPr4iJOKlHGOywbhicpmW5kmmQVxSmAucNYHGerBxSXS3vwj1DMVJt3syFAGyN17F0n/8hKlP/zd73/C0TpuzITLeciZ3REtYZQ89piAr0cQ6CigCruMwM3GMHWH1w7FdCALkWGf6KdhLNe7/59s48xkXYfY33pS4mxjwUxTkCv426A3Sbgy7H8tY6LQZvY+o91DsRG8hR3aZ1ReZXaPMJgmJlJ8g66bJeilG7SHOq+wjHpiU5Sp5tcSSWloJMpaUatcElUVtBKkLVYmvuNrkmkfF+PC7l7jusXFUrUsO2CkQXgzhZpC7KNOzV7EqPgO5xpt3R2wfJg9NhFrR4lct9NGB0MZrlFs/+n+kdqY548Z9HbMhDCQBWS9NPspQbJl+L0VZsrC6aLGvVxmTzIbLncPAlwTHloOGN7urwaOMpDKuGIwpBmOKyRV6miFZpyYCJoPVTMZjgc10F2Uz9kkaGjIzYuMCnZuBbGgMPPsGpj/0ZSr3HCNxzninTVqXtJfiqDnZaTN6HqsSlTsfJzoKwMzRYwRBEJqD6B8XZJE7Mwm95x9+jiRJnPWbl3Rk/2Ey4CcjQZaQMO0B8pm7O21Gz5MOYsjI5OWNKTOvS4u+mpAERbVMUS1zZM3reqCtCMDkvBTj1UEyXopACigox4OMpXr5tFrG60A2Y73vX3cGwV76uhzPf8Ik//aPJZ7+vHSnzTktgTWCpOWR1EiIoBWEENgVDzMZuUYRp2by0GEecs1VoYwlgrogi9IhQZa522c59oMJrv2TRyL3eN/QpJ8AIVFSK502pefp95ORIEtIjEkmdwQhZYM1oW77QArCo+B53OmtXicaEsOKzrhiMqYYXKGnebJsEpNkZo9nMwbWSlZjoQPZjGOyyYyw8bskwLmW9PUPIf+1HzD5ye+y7x3P6fpWORkvzR1qNB9sFbsc+YvHiY4CcOxQfRoeWoPtDgqyuPNFDvzr7Zz93EsxMp0VhQmDQT/FnNo9/TJ6FgGm0x8JsoRAv59iSSkjQlFgbp/TUc9mXGBaW71+JCGR9hNkvRQ5L824M8QF1TNXshmPZzLqxKjqeSy11NZsRmGNIGVub98OWuCs83RufGqCT7w/z41PSxJPdO9kO7BGuqoPZa/iWgFBINDjkWsUcWomj0zwxOf8eihjBTUbZBnJ6EyZ/a1/ewvZM3PsecwZHdl/mGTdDAWtGNKzeXsz4IfXJ3o7oyAxLBlMdpGQyMlwERz1bY769gk+3/FsxnHFZFw2uVLLrMlmtFZKpo8FFjNBe7MZR7tMkGUtkiIz9oJHceBt/0zxlv1krujebG/D1zEDg2KUrNMyVsUj2d876t7tJPKagVi8Xhb80T9/N69+159ixlpT9vSrFmouFYZpDTPzhR+gGCpnPevijuw/bAa8JHeZR9Z/Y8Rp0dw0klCw9XynTel5+nvY0RaSoKCWKahlDrNaamwE+nKQMUXWSzGcv5iYk0FIAVU9T0Vforryk8cPowxKyAhrqCtLno/zktfk+M+vVfj8x4u8+PeznTbnlIguzvTsJayKhxFXkDtUXRDRGyRTKf7t7z/P5dc/nD1ntzZx9KsWSocEWfK/mGD65kmue+ejO1ZREyY5N0M+UiUOhX4/xRHtUKfN6HmGJAMPwSLdVaa7UU6VzTiiGIzL9bLpK/UMv6YMEWM5m/F4oDGwOeZboWUzjskGE6J7qzDSV+4jeeEuJj/5XdKXnoGkdOcidMZLU1YqeLLfaVN6GiFEveQ5ylAEooAiABc/7Ere9Dd/yXte/UYO37ufP/nEBxne0VwPBCFEvcH2+GDIVq6PM5Nn8Zs/5/zffihasvcj5kagkhYxFpVoFaVVTLsfW1+EqBdly/T7SY5tsaxZW3aY0ReY0es9Nvcm5pGEhOlmSDhZ4k6OvuoOduQvQvfjWGqJqp6nqi+tBBsxaSibUbYHQHaRtHxbPlMYjIyrPOOmNJ/9aIGnPidF30B3ChYE1ghq/486bUbPY5WjfjgR6/POz36cd/ze63jFk57J6//63Tz8Vx7T9FhBxULuQEWLEIKDn/xf+s7pZ+f14VTndJqcl2bC7N4Fql5BFhJ9foL5Hl047SbGJJMpYXVhkW7zuAgmfIsJ34Lja8uSWM5mNJdFYIw12Yz+cm9GeyXYOB3YNBrOGpNNfurmQ/404SFJEmMvvIF7X/MpFv/7dvof3Z2JPRkvTSHKTmwZp+aDACPWnfOCzSbynJe54deeyK4zz+Ctv/VyXnrj03nLR/6KS699WMPjCMdDeD5yfPMDejP/+H2UZIwzn37hpu+7HQz4SYpSDbvLlWp7gXq5cyTIEgb9XorbjPCyZkNoidMWhCSo6Xlqeh44tPK66hvEnRwJJ0fcyZGr7iDmZJCkJ+CbcwTGLL45u/x7DhT7pOMr1hCSOY3U5eVpN70sw1f+scQnP5jnNX/c32lzHoQQUlf3ouwlogbbERthdPcuPvCVf+Rdr3oDb33xy3neq17O81/9CmS58YwUv2qhD/e1wcrTs3TzIYp3TPKov3xc1/f72hCiXvL8y+Q9nbak58n6cXwCinL3ZoP1Cp0SZOkE9WzGMneyGojWkBheDjCOySZXaBmebJrEkJkT9WzG1R+bvDh59YuOxICkc6xLS56Pkzh3nMw15zD1mf8h94jzkfXu8ycyXopilMndMlbFw0ioWyK7Pwy670zvIPsuPI+/+Y8v8mcvfTWv+40X8bv/74942ouf35CzVRdkMZCacCxbwT62wOJ/3cbYix+LGutML56wGfBTzEdNoUPBtAeoxI922oyexwhUksIMreS5F+dxnmJTjE1TjK0GsCQhcaFcQ7aHUKwh1PI+lPlrkL0UgZbHN+YIzFl8Y5bAnCXQl5DtQeRY9wfBMjmF578sy0f/colnvTDNjt3ddX8VbhYCFcmY67QpPY9d9sgO9X52f0T7iSeTvPWjf83n/vojfPLd7+f+2+/k9X/9bpLpjbe7qVe02MibLMgihODgp35A+oIxxq7esan7bhfxwEQTKgUtmii3yoCfqguy9KB/0m2MyTFu9fPhDNaDDqOL4GhgcTSwgFX19YykskPTGZNNxmSTy9UMg5KBQ3BCgHEysJgOLEZkkyo+Jbo/wWTspkdx10v/lvl/v4Whp4Yj3hUmaTfNdGK202b0PFFFy4lER+IBZPr6eOdnP87H3v5e/uatb+e+X97Jq975NozYxhy+oNqZ8pXpz30PrS9J/42Xsfam3csM+smo5CIkTLufheytnTaj5+nzU5QlCyfKmj0BIQkCc57AnMfL3LnyuuTFkO1BFGsI2R7CKJ9RL3UGkHwCcwZv/hokcwrZnO5aleJff2GKL/x9kb99T54//cDmt7M4HUFtBMmcQ4r64bSECAR2tb7iHBGxESRJ4jm//1LOvOA83v7KP+QVT3omf/J3H2LXvjM3tH1Qs0GSkE29zZaeyMIP76d87wwPec+vb43sROrZiSW1jB+1dWmZXu4T3W2MSyZf3yYZio1QEB4l3+Euf/U8U5EYkQ1G5XrZ9KVqmifKQ8RRKIu6tvPj1EGOBRZTwmLxFNmMncbc0U//4y9h+p9+QN9jH4Ka7CKBVFHPUCxoUclzq9gVDzPZXQkGnSTynAFVCVCVYM3/ZV7xttdyzkPO412vfjNH7r2PP/vkBxgaH115j66ePKBg16rEcnHixoMb8GpNTPiGk+tf9KUD8+S/dwfnv/oGRvtqxJXGm/8aSuMBEttv/PSxGthmMEhy0JgmEI07vKrcuFOZNRoPZmS1asPb7I41vh9NavzcGVjukSF5MTQvSTpxkNQ658aCn2x4P7dVdza8jSsa7znRzDaLduMCSzXv1A+IfW6WablKwTnRQUhqjV9zgahnMQux+u92IDcxwYrLjX+etHISp1mxwFiC9L2rrwkZ7D7Y/1uoxiyifCbe3MMRbg5Jy6OYUyixqZXfsjGHtOYzaE18nma2WXu+mabMb78qy9v/aIHf/O0051188iy2UtD4PbEZ29YirNENlTu7onHbqkHj2XrVoPHgiCUad8rsoPFtvNNcZ3bVXQ7uaHhrnjlBE/cdsU5qz+nsiOh+HugzPvzx1/HRb/wzb7zpFbz8ic/kzX/zbq593KNW/n4qf7GWL6MldRLmgyfGzfiLiQ08h0QgOPypH9B/+Q7Grxwm0UQ/YLmJNhV2E/dGpwF/Me3kWFBKFJ3GJ+9e0Pj1mNJP3spjPdJ648GlZrZp5jgc95uHgiQHjCnMDcwL5mqJxm2zGrdNVxq/HprZpuw1/szzrJM/izKSSkxXmKj5eJz4HtHEOSdJAoRAlhu4/oLG50/NtOGRmmgjF3DiMXCAI77DkQcI2KQllWcaIyRkmQFJ52ItzbBk4K5kM9pMLWc1TgU2Nif6VEETiyaq2vhBWDtXHf6N61j6zu3MfOFHjL7ghlNu08z51swc/7jPkfLq12teriHW80OamOM3g9xEh1G3CR+qmVjC6Xy1WtknNRx/0HvC9hl7xV+MAoqn4bFPexK79+3lzS98Jb/9uGfwto+9j0uueehpt/EqNomd2c0xcJn9n/wxsdEMYzeev6n7bSeKkMn4CRaixrEto9pD+Foe0cRDKOJEBoMEs3Jl/TdulC2SHdIQUgBKDYIY8fF/Q1rusRj4JkFtFN8axa+NYs8/HN8aBSGjGDPIseVAY+wIamwSRdvcDIonPD3J5z9e5EPvXOIDnx3umsyewBpG7mKl7F7BLi/3w+mS7zWit9hxxh4+8vV/4s9f+Ue88fkv44WvfQXPf9VLT9tX0S07qInNLbGf+s59lA8ucNEfPmNT99tu+rw001rUJ7plBPR5KW5ORL0oW2VcMZgLHNywJFm26bOpKDxissxP3AI3B/UFEAWJIWm1ZPoiJc3jtUHSssZCcGJvxinJYkE4myqMo/WlGHjKVcx96cf0P+kK9IH0Ju791GS8FAW1jOjy3uXdThAInFqk8LyW6Eisw9kXX8BHv/lF/vh3Xs2rf/3FvOJtr+epL/rNk77XdzwCx99UB7F4zwyz39/PhW94HLK6dZSG+vwktuRSlWyiRi6toVhDeGbULyMMhoIEB7StpfDcEexh0BdXgokAsmIhJw+iJg+uvCaEROD049dG6oHGyh7y8w/DdwaR1SJabBI1NolmTtb/bU63rfRXVSVe+rocr/vtWX76fYurrms8+7UdBNYoau7/Om1Gz3O8wXZERLPEkwn+9BN/zWf+6iP83bs+wH2338Ub//qd6LmTZ2R5FZvY8OZNNAMv4N5P/oTBq/eQu3B0/Q16iJyX4q7YoU6b0fMkAhNNKBSUEBdOtyljisExv7lM1ogTGVNMjlmzK9NBH8GUsJnybW7xV9t8JVGWS6ZNRmWD87UUI7JBAEwLq57JuPx7SthUG9aa3jhDT7+aha/fwsznvsfO33tS2/bTCFkvRSESZGkZp+ohyxKqsXXiLq0Sec8bIDvQx3v+6eN85E/ezfvf9Gfcc9sdvP69b8IwTwwcemUbJaYhK5uXnnrfJ35EYleO0cecs2n73AwGvBQLSqn+8IgWUlpCtYbwjSig2CqykOgP4uFmKNK9Ks9tpTYM5sy6b5MkgWLMoxjzwO1AvRw78A08axS3NopbG6e6cDVubQwR6Kjm7HJwsR5k1GLHEPpCKIv7j3hMjIuvMPjQO5e48uEmcofV3USgIux+pEjhuWXsiks8s7m97CK2HrIsc9OrX8a+C8/jz1/+On73Cc/i3Z95P7v27TnhfUIIvIqNmty8c+7Yt+6mejTPpW/9lU3b52ZgBBqJIMaiWoz8xRbp81LklUrUizIExmWTySDsgOL2O8GzkkoMmenAhnXiN2V87gsq3Bes+umKIhiUDEalen/Gc+Qkj1QH6JN08sI9Icg4KSxmRTjfmRI3GH7WI5j8xLcZfMpVmLs6338746WZ1xY7bUbPY1eiipYHEgUUN4iqqrziT97AWRedz3te+1YO33sf7/z79zE0NrLyHrdsoyU3Lztx6bZjLPz0MBe/9UakTQxibgb9fioqdw4JxRrCTt/daTN6nj4RI0CQl8JrsL1tn0XWyIYCiqdCVmz0xCH0xKGV14QA383h1cZXAo21xSvx7CFkpYYeO4Yem1z9bU4iN9gGQJIkXvGGHC95+jTf+kqFX3lK4z1Hw0TYQyA7SNrWEOLqJHbFIzfeeD+wiIiTce3jHsVHvv7PvOmFr+BFj/0N3va3f8G1j7tu5e9+zUUIUOObE1AMXJ/7//6njFy/j8zZnZ/YhknOS1OSq7iyt2l9v7Yq/V6apcj3DoVxxeBmN8Rn8zb1F8cUk9nAwUPQzEw3AGaEzYyw+UWwmp0XQ2ZUMusZjZLJI9R+RiQTBZjFYhqLKVGr/6ZGuQmF6f4nXMb8V37K1N9/l71v+fUmrA+XrJdif+xwp83oeeyyG1W0PIDoaDTI45/5a+w5ex9vedEreMGjn8U7Pvk+HvKwywDwyg5aenPUnIQQ3P+JH5E6c4Dh68/alH1uJv1eil+aRzptRu8TqChOH35U8twyQ0GCObmybZ26ULGGIeQgtySBqi+h6kuYmdtXXheBhmwPYFd34FhjlJeuwJkcI/ASqMY8euwYRmwS3awHGlVjvt78/BRcfLnJ9Y+L87fvyXPDjQl0o3MnRGCN1NWxo3OyJQI/wK35kYMYESq79u3lI//xT7zjla/ltc95Bb/9+pdz06t+G1mWcSs2WkLftAyHia/dQW2mxBV/8eRN2d9m0uel69mJES3T56eYjtq6tIyGxKCsRyXPITAmG0wG4Stl1wg4IKoc8FfFNSWgX9LZqWmMYLJbSnAVA/ShU8VjCosZakwJi2lqzGDhnSZrVNZURp73SI6858uU7zhC8oJdoX+OjaIIhaQfJx8tGLSMXfFI9G1u/+NuJ/Kem+Cch1zA3/3nP/LmF/8hL3/Ki3nV2/+Ip73wWbgVm/hYZlNsWPy/CZZuPcYlb/9VpA6X3YWNJCT6/BTz0U2vZRR7AKFYBNGxbJnB4wHFsNluFSxCBnuwpQzFRpBkFyM+gRGfWDVBgO+lcWpjOLUdOLUxKvmH4FjDSFKAbk4hm1P1/oyxSVRzCllddTpf+rosv/m4Sf71H4o8+8Wbc88/GUFtBDkWlTu3il3xUDQJVd9amf4RnSeRSvLOT7+fT77nb/noOz7Ivb+8mzd/4M8Iyvam9dv2bY/7P/Mzxh5zDqk9fZuyz82kz0uzFAUUQ6HPS3FntJjfMqOKQVX4FETjWW2nYzu2yNnMXpQCmBcORarcQWHFP9eRGcZklBgjksnlUh8jmJgozGMzTY25oMoMVWakGnmcleSD7HUXMPelHzP1qe+w7103daxMNuMlsSUHS46C3K1iVzz6dkYVLWuJAopN0jfYz1//y0f5wFvfy3te9+ccuusAz/21Z21KP5zj2Ynp84YZvHpv2/e32eT8BD4BRbm6/psjTotqDeEZc1FWXQgM+XHuVUPuPbIdvxe7HwhA71wWhCSBqhVRtSLxNZmSQsi41nA9wFjdhVM6l8rsDQRuDllbWgkuDvdP8vyX3MmnP3yAJz0zRTLdmUBUYI2gZO7oyL63EnbFw4hrUT+ciLYgyzIvft1LOevCc3jby97Ib//Kc3jv+/6SzK6BTdn/4S//Eidf5awXPHRT9rfZ5LwUB4xjnTaj59EDlWQQi0qeQ2BcNtrQP3F7Pp/GZZOfuZ1dMHAImKDKBNUTkgDS1DMZR4kxLkwuFDkGMHERzFJjRqoHGAdf9uv86C0fp/jje8lc3RnNg6yXpqCWtutpFBq+F+BaUUXLA4mORguomsar3v56zr74PL7+qS+xeN0i0lySodHhtu53/seHKNw5zeXvecqWnAD1+ykW1XJ00wsB1R6Kyp1DYjBI8AN5Yv03Rpwea1mQ5TRlxZ1CkgL02BR6bAo5e9vK64EXWxaBGcOzxqjOXcdTbnwWT3qMzLFbpxneNYNqTmHGjqLFjqFohU0pQxbWCPLwf7V/R1scu+JhJCN3KKK9XPeEG/jEtz7HHz3v96ktlZksz3L5yMPauk+v6nDgsz9jx43nk9iRbeu+OoEqFNJ+IgqChUCfl6Is17Blt9Om9DxjihmVO4eAisSQrDPph1/yHAZFXIq43EsJQ6lnoypCYgCTYRFjRMQ5R2S57syH88rP3cDc4gKLnsyMZDEjVdE9i6JSRWyCP5xxU1G5cwg4FQ9Fk1H1SOF5LZEHHQJPfPavcd7ec7j7J7fx2j96HX/+yb/kIVdd2pZ9iaCenZh7yDh9l3euF0M76T+u8BzRMoo1hJX7RafN6HkSgUYcrT0lz9uNFgVZOoGs1tCTB9CTB1ZeE0Li0x9SuO3H/bzujy9CBDuxFh+KZw8iK7UVhWnNnFr53agIzOkQXhzhpZEjheeWscsuqcHN6X8csb3Zc/YZfOxrn6F85yyvevYL+K3Xv4zn/d6L27Y4fOhfbsWrOux7/pVtGb/TZL0UluRQU6LgTav0+SkWo4BDKIwrBj9y8p02o+cZkQ0sAvIhl463E18SzFBjRqpxG2uqmg4s4H/0+zzkeU/gjHPP4upgmOGl3cjIFNQyS0qJJbXMkloir5SoyU6oiTVZL8Xh2GR4A25TrGWF54gTiY5ISPRlslz5uGvY+a1/5xVPeRGvfscbeOoLwld0mvne/ZTun+PKv37GlsxOhHqG4r1GdNNrGSGhWoP4RpSh2CqDQYIlycKVgtDHFtutKU5tGNL3ddqKlpEkwdOf7/DZj9/M333iDt7wjgE0yScINDxrBKc2hlsbp7p0Ge7Ukwi8FKo+txxonEQz678lY+G0IjCnIrBGkLQlpGgi3TJ2xWNgj9ZpMyK2CbqkYqRjPPf3XsSH//T93HPbXbzp/X9KPBkPdT9uyebAP/6cnb96IbHhVKhjdwuRIEt49HlpFqPF/JaRqAcU25KhuM38xTHF6NrsxIY5o5+j/YK7/+LDnPfRlyGbGvuyCyT9ODk/Sc5LMehmOdvaQcqPY0tuPbi4JthYUMvN7VvUS55vVcMVQ9yO2BU3qmg5CdERCQmv7JA+c4APfOnjvP8t7+Zdf/in3HPrnbz6nW9EN8Lpqyj8gP2f/DH9V+4md/F4KGN2HWI5QzEeOTWtIjtZQMY3FjptSs8z1CZBlq25JLAO1ggMfb/TVoRCMi3zwldk+MDbl/iNF6c56ywFWXbR4xPoDxCBCbwUbm0MpzaOa41RK1yIa40gIVDN6WUBmKnlPo2TKNrpHcfAGkGKshNbxnMDPCeIVpwjNg23bKMmDV7yhldw9sXn8acveyO/feNz+ItP/zU79u4MbT8H//nnBK7Pmc+9IrQxu41IkCU8+rwUR+LRAnSr9EkaKjIzIfdQ3KI5JKdlXN48QZbNYOR5j+Se3/0wc1/5KcO/fi1CgpJapaRWObIm+UMVChkvSc5LkvNTnGGPkask0YVGWalQUEsU1SJ5rUhRLVFWKqedUJiBgS605gOSESvYZY/0cKzTZnQdkQcdAoHn41suWtJA1hRe8843cs7F5/GuP/xT9t99P2//u79kcHSo5f1M/de9VA4vcuEbHhuC1d1JOoihIJNXotLSVlHtIXxjrit71fUag0GC2ajcuXW8OHhp2EJ9PZ/+vDT/9MkiH353nr/8aP9J3yNJoGglFO0ezPQ9K68LIWPbw3i1en9Gp7yPytx1+E4/slpEjU2tZDKqsUk0cwZpub9VYI1E5c4h4FRcVENG0SKF54jNwSvbGH11hchHPvHR7P7W53jdc3+PFz322fzJR9/Fw264tuV92PkaB7/wC/Y89WLM/q2rRtnnpbg9PtdpM3oeWUhk/URU8hwC44rBTGDjd9qQLcCYYnJLhwVZwsQYydF/4+XMfvGH9D/+Usid/H2e5LOgFVjQCqsvCogFBiPCJOOlyLhpRu0R0l4SIQmKaomCWqKgFus/WglHrrfZyXopykoVX4rOylaxKx5mtAD9IKIjAhiqi6k11oRYWVP6aFVrKLqCYQDLj5CnPvfJnHXuXl5706t50WOfzbs+9R4uu+qihm3L6vVU78Dz+eHf/4ixR+xh98VZ4NQp4E7Q+NfazDaBaHy5zAlO38Q042ZYVCpYQl5R0rK9xm2rNNFT2kw0vpErNqcpa0ZpXPFa1EaxjAWqwcYzZO+pjja8n6LXeO+xRbvx0q4lu/EVIc9v/Psx1QefB8Mizn3KLOopSp4tv/FzdNrO4AmFimcwbWc2tE0gGg966HLjvWfiTZTRmtL6/QF9eweutoS5nFFiSo1fcwqNl503c6/SNuh4aSa8/A8zvOVVi9x1S5xLr2ggI13yqeoLSPoCeuZ2jm8pfAPPGsG3RvFqo9gLD8O3RhG+iWzMo5hTBNXdaJlbUZwssr64btl0KWj8GDRzf7NE46XDdtD4NlYT25zsCFllDyOhnfRvABW/8QoDXT79ueM1cR1HdA+N+oxr/UUhBF7FJrMng7Z8npx93h4+851/4E2//QZe8+yX8fL/90pe9HvPb7itzXh8dfL5k4/9DFmGa1+8D3PN6w/6LE08H+wm/EVvHd/vZJS90197spDIeCmOYq28t+Y2cf9p4vltqs31dHOa2Je6zv3kZMRP4secjpybxpN8ipIFDTwvK07j98dmjp3VzDygajS8jWc34dM/4OExflyQ5TSPZN9p/BnguCoikBr6XKKZLj1N+EtNldtsINlhTDb4qm+tHssm9iPL3ZVUMfzsh7P4n7cy888/4JzXXbbxDSWoKTbH5ArH9NXKM0lIpPwEGS9F1kszaA9yVuUMEkGcmmxRUEvIQsaVXPq8FEW1TLCB9k1BEwfbbeI+3wxaE/fEJqYOD7qEPcfHdwO0hLppPmOv+ItRQDEE3LKDlnrwCXThFRfxme98nj96wR/ykl99MW98zxt42vOf2tQ+Dv77vZQni1zzzse1am5XM+CnmI96uISCZg9iJQ522oyeRxEyuSDeHkGWbVbCIrZoVt2vPCXOZz5W4i/fUeTTX+xvub+tpNhoicNoicMrrwkBws3gWaN4tXHcwoV4xfNwFq4FyUcxZ1DMKRRzCjk2Xf+tNr4Qsd2wowbbEZuIb/sEboCeONFnTGXSvO/zf81H3vE3fOCP38+9t97FH3/grcQSjS+kVeer3PGFe3jI8y7AzG5dsaGcn8AjoCjXOm1Kz5PzUiwq5W3nk7SDMcXggNeGc3KbfTdpSSUuKUxvoZJnADWTYOhpVzPzT/9L5Xn7SIymWxqvnp1YpqiWmWBqdT+BuhxkTHFOdQ+KUHjk4sNQj5dNa0UKaom8Wv9dUarb7hxrFLvioZkKitobQb7NJPKiQ8AtO+jJk68YDQwP8JF/+xjvfeO7+JPf/1Pu+sVdvO6dr0XTN76K6tsed37yFnY++kyyZ568pG6rMOAnOaxFPf/CQLcGKPb9tNNm9DwDQRwHj5K0tZyaTiBqo0ixqfXf2GPIssQrX5/hlc+f57//0+ZRjw1/Ei9JIOkFdL2AZCxgzTyO1LnvBSCwBvGtUXxrBLd8Nv7c9Qg3h6QW60HG2DSSvogwZ8GYgyaykrYqdsUlOxauGEZExKlwyw5qXENSHjwhURSFl7/5lZx78Xn88cvfwk2PfwHv++xfMr67sZ7ZP/+7X6IaChf+5vlhmd2VDPgpFtRSNAkOgZyXrh/LiJYZlw2+7y912oyeZ0wxmAscnNOlevYoA0+9ivl//xl3fuxmrvx/j27LPjzZY0FfYkFfYl9tF7en7uWoMUUsMMl4abJuioyXYoc1SspLEkjBCWXTebVEQSviyE2U/G1R7IqHHi1An5ToqISAU3aIDZ66R42ma7z+PW/i/Iecyzte+06+983v87SbnspTnvsUhsfW76144Ct3Y81XueDFW7ex9nEG/SS3mIc6bUbPI3txZD+Ba8532pSeZyBIMLdOw+NmaaocpYcJrBHU1L2dNqMtXH2dyVXX6LzvnUUe8SgDVW3fLNe3RpCNOaTlshUlNoMSmznhPcI38a0R/Fq9dFpaugzJGoZAB30RzBmEOYswZ8CYBX1p2/VbFUIsZyhGCs8Rm4NTttGTpy+JevSTH8OZZ+3iVc99NU972DN47FMey6+/6BlcdMVF62Y/l6bK3P2l+7j8JQ/BOEnlzFZiwE8yr0QiA2GQ89LcrU922oyex0SmX9HbIyQSbK/n85hsMBmysE23oJg6w795HRMf/jpnPfshZM8eaNu+JCGR9pIU1OJy2bRFTbGYXiMCIwmJlJdcyWgcdgY5+wFl04XlTMaCVqKolvA3UDa91bDLblTRcgqio9IigR/gVd11HUSApz3/qVx8xUV87qOf55Pv/xQffdfHuP7G63jmi57JVdc/FFl+8Iq1Z7nc9ff/x+5fOYv07mwbPkH3EA90YkJnPhJkaRnVGsTT8ohoZallBtuk8Bz4AaXpCsmR7ZEdJYSMsIaRzK2XoQggSRKvfkOaZ/3qPF/5lxpPe1b7vtfAGkVZ5zhKioWaOISaOARAzU/UG8K4abCHkawhsIaRi+eBPQj4YM4hjBlYDjRKWgWxhcumPTsg8AR6PHKFIjYHt+xg5NYvY953/j4++93P8i+f/Be++Kl/4Wv/+DXOvvBsnvnCZ/CEZ95IInXyReyff+I2jLTOBc86N2zTu44BL8VdRhQEaxlRDyguxu9Z/70Rp2VMMcgHLhURvviFO7uEOrCxfttbgXHFZHKLlTuvpf9xl1D46g+5429/zLXvfVLb9pP04wioK0GfAiEJilqJolZiYs3rWqCSXg4yZrw0e2s7yZRSq2XTy1mMheXMRmuLZ4zbFY/c+NYVOWuFyItuEbfsIGsyirGxQ7nv/H38v796C6962x/wH1/4Ol/4uy/y0qe9jJ17d/D0FzydX3vOk8n1r8o+3f8vd+AU7W2RnTjgJ8nLVbxIhaplNHsI14yUD8Ng0E9yhxZ+37/isTK+7dN3xvZwEIVdb9cgGVu3pcGFD9G58VdNPvjeIjc+2SQWa0+fFb82ghI/2viGEqAXQS8iUvcBy02nhQx2fz2D0R5CquxFWriKATdHoFTwjHk8cw7fmK//25jfEmXTdsVFjyvIyhb2gCO6CqfskNq5sXt+OpPihX/wAm76vefz4+/+mH/+uy/yjte+k/e99a944jOfwDNe+AzOuejslfcXjhS592v7uer3LkeLb/GsWwH9fpL5qEy3ZRJBDFnI5KPF/JYZV4y2BcGciVnMfTvaMnY3MqYY/HwLKTw/EElVuOB3ruInb/4Ws7ccZejy9ny3WS9FUS01pbXjrimbXkGwXDZdV5rOeCnGrVW16dJycLGoFiloRYpqCbsJocduQwiBU/EwklHo7GT0zFF517vexS233MIb3vAGLrnkkk6bs4JbdtBTjSuJpTIpnvVbv86vv/iZ/OInt/LFT36RD/353/ChP/8bHvtrj+GZL3wGZ11wFnd/5hfs/dVzSYym2mB9dzHop6LylZBQrUFsIyp3bhmxXPLchgzFxf115c3+M7Ohj92NCGsEyZxZV42413nla9M8+YZZPvvJCr/1svbct31rFL3vZ+ENKAX17MTlRYjj39CS04di96Pag6j2AEbhAhL2AJJv4mv5eoDRnMcz6sFGX++tvlFRufPWpFv9Rd/xCBwfLdFYKbIsy1zz6Gu45tHXMHNshn/9zJf4109/iS988otcfOVFPOOFz+BxT3kst3z0VuL9Mc57+jlt+gTdQyaIISORl7duBvVmkXPTy8qvW/vZvBmMHVd4DhkRBLiT86Qf1YAqcA+jIDEsty842y2MPfIMcucPcfuHfsyjPv50JDn8xc2sl6aghbjwckLZ9GriiiQksn6MtJcm46UZcPo5o7qXpJ/Akm2Kaj24WNSKFJb/7Tej1twhPNsnCKKKllPR1UdFCIEkSXzwgx/kPe95D/Pz8zzxiU88wUGcm5vj5ptvZnBwkEsvvRRV3dyP5JQdtA2UO58KSZK49GGXcOnDLuEP3/4avvK5r/LFT36R//jC18n2ZfEsj/NesD0eIAN+kplI4TkUNHuQcjoqX2mVtDDQkFlsw6Rl8UABI60TH9i6KpxrCawR5C1a7ryW3XtUfv25CT7+N2We8ZsJstlwsxRFoBLYA+uWPIeyL8XBi0/hxdfsS4DsJVDsgZVAo17ei2r3AxIpfQlHX8Q2FnCMBWx9EV9tTw/SVokabG8desVfVGMqcgsKkcPjw7z09b/Lb73mxXz/m9/nC5/8Iv/vZW/lPW98L8VCkWv/6CpUQwnR6u5kwE+xqFSiIFgI9HlpFtWtmwm2mexQDL5jL4Y+rje7gHA99J3r993fCgzLOi4Bi2Jrt22SJIkLX3Y133/Fv3HsO/vZ8Zh9oe8j46WY19tfGSQkQUkrU9LKHGO1FYUSKKSXS6bTbpodtXEu8M7DCAzKSqUeaNRKy0HGImW1gujC+7pd9tBjKnIbgr5bga72pCVJ4tvf/jZvetObeMUrXsF73/teLrroopW/33LLLbz85S9naWmJ2dlZ+vr6+NjHPsYNN9ywaTa6ZZtYfzaUsXL9OW565fN53sufy0+/dzP/+ul/ZWZnmfhpBF+2EgN+ijuiptAtIwUqitOHE5U8t8xAkGBJruG34eG2sL9A3xmZdZvsbxVEbRQ5dX+nzdgUfvf3knz5C1U+9sESr31zuCXtvjWMpFhIWiHUcTeMBIFWIdAquMnDq68LCcXJYtfG0e1+YtYwmcL5aG6GQLbrAUZ9EcdYXPl3oDid+QzL2GWXZH/jFQYR3Udv+IsOWjKc803TNG540g3c8KQbOHLgCP/yqX/lf27/b855cvgT0m5kwEsxHy1Ah0LOSzOtRxUtrSIDI4rRlgxF92hddG27BBS3ev/EtQxeOsbINbu546M/Yez6vchauAtCWS/F/vihUMdsBF/2WdLzLOn51RcFGIGxHGRMkfbSDNuDpNwUEhIltXxiNqNWpCZbHV2YtqNy59PS1UfmP/7jP3jzm9/MW9/6VtLpNPF4nNHRUQAmJyd50YtehCzL/MM//AN9fX287W1v47d+67e4+eab6e+v9+v69Kc/zTvf+U6+853vMDIyEqp9IghwK25oDuJxZFnmYY+8ioc98ireftffhjp2t6IHKpkgFpU8h4BqDxIoNYKoH07LDAZJ5uT2nJOL+wuMPqR9ym7dRmCNoAx+v9NmbAr9AwovfEmSj36oxHNekGBsR3iPWt8aQzan6Lo4tCTwjSXKqg2pA6svByq6k0O3+zCcfhLlvfQtXIHqJ3DVEo6xSFXLYxmL2Poitp5HbIJ6oBACpxqVPG8Vut1fhOZb5KzHrjN28ao/+QP07bFeA9QXoA/q0aJpGGS9FHfFD3bajJ5nUK5Xq80F4S+UOcdmkFNxlEwy9LG7kTHF4JhvddqMTeOC372K/7rpnzn4lbs48+kXhjauGigk/QT5bstAlsBWbGaVOWbXlE0jIOEnyHgp0m6arJthV3UnKT+JK3kr2YwVLU9RK1LSiribJD5qVyKF59PRdUcmCAJkWebb3/42f/Znf8bjH/94Xv3qV/Pc5z6Xs88+e8Xx+8xnPsPU1BRf/epXufLKKwF43etexze/+U2+8Y1v8JznPIef//znfOADH+Btb3tbe5zDioukyijboLyk3Qz4ScqShRWpEreMag3imbNdWWLYawz6CaaU8B/EgeezdLjIBU87M/SxuxHhm+DmkM2ZTpuyadz0kgT/+JkKH3hviXe8L7f+BhvEt0ZQzPBFgtqFkD1scw7bnGNtPpHsGxh2P7rdh2oP0lc4D9PuQxYqtlbANhax9CUsfRHbWMQJWT3QrdV79+ix6Pndq/SSvwjglOxt0Q+77Yi6z3izcmD990acFj3QSAQxltTiavPciKY4LsjSjsPoHptF3zG0bSpaxmSDW73tk4GcObOfXTeew91/dzO7fuXshvvsnnJcL4Ul2dgdrgbZMBJU1AoVtcLkGj9XFjIpL0nGTdezGa0R9pXPJubHqck1Slo9i7GkFilpBUpaiSDkhWm77JEajIU65lai6wKKsixz77338vu///s86UlP4s1vfjO1Wo2f//znXHfddWiaxsLCAl/60pd4zGMewxVXrKofp1IpRkdH+dnPfsZznvMcbrvtNl7ykpfwzGc+sy22OiUHPalvmxt8Oxnwk8xF2YmhoNmDuEa0ch8Gg0GC27Twe9VVjhYI3IC+M7Khj92NCGsEtAKSun0a6CcSMi/9gxR//pYCL3hJknPOCycTzquNomVvD2WsThIoNrX4JLX4JHawfGwEaF4Sw8lhOn2Ydh/p8l4MJwtSgKUvYetLWMYiJbVIVc/jKbWmAo11hWe1LU3QIzaHXvIXfdfHt330FnpuR9RJCANDaCxGPmPL5Lw0ZbmKK3vgd92UsKdoZ5mue3SG2AW72zJ2NzKmmHzd3l5l+Oe/+EqO/uf93PePt3L+i68MZcyMlwpXkKVDBFJAQaurRgNoy2IuWqCRctOklgONu6q7SbtpVKFRUcuUlsulS1qRqrZEtcn+jCI4XtES3SNPRdcdGcuyeM5znsONN97Iu971LgDuueceJiYmuPTSSwE4fPgwd9xxBy996UtRFGWlGXc8HqdSqZDJ1HtW3XTTTW211S3bLQmyRKxSV3ju/ZteN6BaQ1T7/q/TZvQ8ulDIilhbFJ5LB+tNu/v3hdtfr1sJattDkOWBPOM34nz642X+6i+KfPhT/aGM6VujmOa3Qxmr65DA1cq4WplyYmL1dSFhONmVQGOiNkrOvgDTS+PKFjV9iZqeX/5d/3ewTra7XY7KnXud3vIXHRRTDb0/1nZkwEuSlyt4m9AaYauT81IsaV1WDtmjjCkGd7jhB7mF5+NOz5P9lXCCTN1OSlJIyypT26SH4nHiIynOfPqF3Pf5X3DGUy/A7Iu3PGbWS3VfuXOIuLLLorHAorFGdEaAGZj1IKObIeWmGbFGSbr16oCyVqSsLWcyqkXKWgFrnYVpp+aBBFpU0XJKui6g+LWvfY1bbrmF66+/nm984xtcdtllzMzMUKlUuO666wCYmJigUqnw0Ic+FGAlQ9B1Xebm5ti1a1dD+zRlD1P2GtpGkgRu2Sa7K42+QdnzQDSeCdFvNP5wcoLGv9aa3/jEatFu/GZ3ZurkK05jlRiV1H7OjD3473NW4yVCi3bjacmm0ni5tbJJSlSL/gaFeYTEkD3AvFZmyh5seD95t/Hjdn+h8T6AZavxPlKe37gyZtJs3CFR5PokZchLUpFsHNVmvUeIEzT2kMkfzKNnY8wZo9BA0p4qNz6BSimN3dsA4nLj5RGmdOr9VK1hlNjkg95zum1OhdzENdfMvdeUNnZfPx2aJvE7r0zxptfkmZ/zGRh88HmSljd+jvpukkUvjW/MEYjGzjlXNP5cyPuN3+PdBu0CqPrrL8xV1QqoFYgfXdmPHKjE3QxxJ0vCyZIt72XMuRQ9iGEpZap6nqqWp6oXqOhLeIG0otBnVTzMlE7A6e8r8SaeC9I6RW9aCOdWRGf8RWjcZ5QkQbViYSa1tvqLCXWTJuBNuD0LTuPigiOxk0+E93ijVIylk/59mnTD+/FE477FRr/HBxI0kU7djE+/0fMn42aYV8o4gdLUs3VXOt/wNgfzfQ1vU7Mbn6N4ThOT/yYS1iWl7peNKwbfdudW/n86RLDxHbkz8+D7yMOjuFZj54LUwH5aQTRxT5Dlk280phjMBQ6O7D/o65A3cGwfiNLENqey7XRoTdwT1Acsipx/0yXs/+Ivmfru/Zz1jJP3Umzk3pPzUxyJTTT1PGkGK2j8OlWbOG7rzQdr+CxpS6AtrbymIUj4cdJuui4GYw8wXj6DpJ/AldxlEZgSRfW4EExpxT+0Kj56QkNIyrqPv7B9xl7xF7suoHjmmWfyghe8gP/8z//kIx/5CNVqlWQyiSzLfPjDH+b5z38+c3NzxONxxsbGTth2YmKCUqnEvn3tV7kTgcCpuBjJKMOhVeRAJuGmKK258COaQ3fr2RaOVgBvezRvbhcDQbIt2YkApQMLpPY27lT3Kr41ijHwv502oyOcd2H9GXH0yMkDio3gWGMo+gKSsr1W7k9FIHuUjQXKa1enAdU36kFGN0vcyTJSOou4k+X+qUn0mIqe0KjlHbS4ilP10GJK1LqkB+kVfxHALjnoqaiiJQwyboZFfbHTZmwJ+rw0h/Tt09u4XSQkhYystaXk+bjCszY+HPrY3ciYbDC5jQRZ1mKkTRKjKSrHQsgqFJB20xRTUfUfgJAEZbVCWa0wyWrFlCxk0l5qRW16xB7m7PJZxIMY+5emMBIagRcgSRJW0UFPqMhK44tQW52uCyhecsklfPjDH8ayLPL5PPfddx9vectbuO+++/if//kfzjzzTPr6+kgmk7iuu1K+EgQBP/jBD8hms5x99tltt9OpuEiyhBrrukPYc6TcDJ7s1lOOI1rCtPux9UXYpMzJrcygn2ib6nj50AJDl+9oy9jdhhBSXUgktv1KngHGxutBxGNHPS65vLWAglMbQzcnwzBrS+MpNsXYDMXYmomygOeOvQa74mGXHMpzNSpzFvmJ+jWuxzWMpIaeUDESGnpCQzXkKNDYxfSKvwhgl11SI41n6UU8mKyb5UAiEmRpFUXIZPw4i2oUcGiVcdlkPnCwCb8M3z02g5xOoqS2x/1jXDGZCrbvoml8JEVluvVr0gwMdKFR1EqR4NJpCKSAvFYgrxVOeF0LVF429nzsisfSkfr3cfTWeQJPoMUU9ISGkdAwkvVFaj22vXtyd100TJIkDMPAMAwymQy5XI4gCHja057Gu971LrLZLB/4wAcwDIO5uTkGBurllpOTk/z7v/87V111VdsU+tZilx2MSJAlFFJujpKWj1SJQ8C0B7AekK0T0RwDfpJfGEdDHzdwPKpHC6SecXHoY3cjgdMHQkHepkJBqbRMOiMxOdF62YJbG0OPTdJ4QUUEEmimWv8xFJaOlNn90CEQ4Na8eqCx4mIVHQqTVdyah6xKK8FFI1F3Go2kihL1wesKesVfDLwAr+ZFGYohoAUacT9O4QGTv4jGyXpJXMmnIm/PbLAwaWdWXV3heXtkJwKMySa/3EYKzw8kMZpi8a7W/eW0l6asVPAlH5poRbPdcWWPWNYgljVYmigxdHaWeM7AdwLsiotTdrErHpVFC6fiIYRAj68uSBvJ+r9Vc3tUwHR9zubCwgI333wz5557LtlsFoDrr7+eSqXC5z//ecRy44ZPfOIT3HvvvSuNtX2/vTXnTsnFSEXlzmGQdrIU9ajcOQxMux/L2F7KaO1AEtAfJJhvQ8lzZSKP8INtU/Ls10ZRzGmkbdxAf3ynyrGjrT+THGsMLRZlKLaKXXbRExqSJCHJEnpCIzUUY2BvmrEL+9n7sGH2XTfGjksGyIwlkBWJ8oLF9F1L7P/fafb/YIqjv5hn9r48hakKtaJD4G3f87tb6FZ/0S47KLqCqkeTulbJuBmqShV3HdGliPXp81P17MStP9dtO+OKybGgPQFF59gM2vhQW8buNmRgeBuXPEM9oFidaj2gmnHTFCPBpZYJ/AC35mMs+4yqoZDoM8ntSjFyXo7dVwyx77pR9lw1zMDeNHpCw6m4zB8ocvAnM9z//SmO/GyW6buXWJooU1m08Gx/xR/ZKnRdhuID2bNnDz/60Y9OaJx98cUX85rXvIZPfepTHDp0CN/3+ad/+ife/va38+QnPxkARdm44zZzxxzOsIeR0tGT+oaiyXbZIT0W9agLg5Sb5XDyvk6b0fuIeobiXN/POm1Jz5MJYkhILMkNKKZskPKheu+nbRNQtMaQzelOm9FRxncoLQcUhZBwrVF081gjOj4RJ8GuuBjJ07s/siJhpnTMB2SV+V6AU6mvTDtll+J0FbviEbgBmqmsZDOulMHE1RUhmIj2shn+IsDC/iXECOhJvR6YXuf7jRagwyPrZslr+U6bsSXo81IsKFHAIQzGZZPb2pBVJ1wPb2YB7fHXhj52NzIkG/gIFsT2XTBIjKRwSjZO2UZPNi5geZy0l6awhRWeNwunWq9WUfRT5+BJklTvzx1TSa7RQxWBwKnWq1+cikc1b5M/Wsa1fGRNXql8MRPqSrsdRev6XL+T0vUBRUmSuOqqqx70+itf+UpGRkb46le/ihCCr371qzz2sY9FVRv/SPG+GL7rkz9SwKm4yIqEntQxkjr6cpBRi6krQUYhBE7ZxYjKV1pGEhIpN0tJz3falJ5H9eMovollRM3KW2UwSLIgl2mHMFr50AJGfwI9bYY/eBcS1EZRkgc7bUZHGduh8L3vtLbi7jn9CCGjmbMQNK6+HLGKU3GJ9zV3/SmqTCxjEMusOvpCCHw3WCmBcSouS0cr2BUPEQj0mHpCybQb9IZqX6+xGf4igCxLlGcrOPuXCAJRDxyv9RkT2glN2+2yg56M/MUwyLiZqNw5JPq8FPeY4bd12W4oSAzLBsfakFXnTs1BEGwrQZapwNrWLf/io/Vkpep0GX1f8wHFjJtmytjei/lhYJfdlezERpFkCSOpPUjAN/ADnMpqoLE0Z2EfcvGdANWQVxemExpu0BvB9a4PKJ6KZDLJC1/4Ql74whe2PFZqNEkyXb+Aj6s32yUHp+xQPFrCKTsgrwYZFU1GCIEai8pXWiXhphAIKlFT6JYx7X4cLY+QvU6b0vMM+EnmlfYoPJcPLpLcsz2yE6Gu8KwP/LDTZnSUHTvrGYpBIJrOVnNq42jmzLYuHQ8Lu+yR2xlexpgkSai6gtqnEO8DaXk6JITAs33s8qrjWJ6vkZ+PsgY2kzD9RYDc3izJdLL+/Vo+TtnBLjlUF2osHSoQeAFaQqsHGJMatbxN3xnbYwGp3WTcDMdixzptRu8j6iXPS5Hv3TIjso5DwGIbsurcY3VhMX3bBBTNtihl9xKJsTQAlckS2X39TY0hCYmUl6QQlTy3jFPx0JPhVhjIioyZ1jHT9YXG4z6j79b7Mx5fmC5MVVma640FtJ4NKLYLSZYwUvoJ2YciELhVF7vs4JQcSjMVEHD4fyfrUeTU8up0amPlLxGrpNxsJMgSEnVBlig7MQwGggSH1fYcy9LBBQav3tOWsbsN4RsETj/KNu/7N7ZDxXVgfjZgaKS5hSi3NoZuRhPpVvG9AM/2MRLtd38kSVoRgkkOrAaUSvlY2/cd0X4kSUKLqWgxlcRgPWtYCIFv+yv+Ym3Rwrd95u5aJH+oiJ7S6xkLy9UvvVre1AmUQCHlpaKS5xBIBXFkIZNv08LpdmK8jUEw59gMSjaNnNgez4wxxeBOr9xpMzqK2RdD0RUqLfRRTHqJerJOdH23jF1xT/Df2omiycSzBvHsamZqrtB8lupmEgUUN4C0nJ2oJ3UYAe5fQgQBmR2p5ZVpl/JslcX9+ZXyFyN1vPxFe1D5S8QqaScXlTuHhBEJsoTGoJ/kFn0i9HF926M6Wdg2GYq+NYKkFpHV7e3UjO+sBxGPHfWbDig61hhG/FCIVm1PnIqLossoHRTIiBYdty6SJKGaKqqpkhiIYxVsnLLD2OXDuMvVL1bRoXisjGf7qKayUip9PNDYyXOzm0l7aRzZwYpUiVumz0uxpJQR0nYuLg2HsTYKsrjHZtG2mcLzfwYLnTajo0iSRHwkRWW6+YBi2ktT0iLBpTCwyy59u1Md23+vKERHAcUmcMoOyZF4vW9OQiO5fK8/Xv5yvFy6Ml9j8eBq+Uu9ZFpbCU7KahRkTLtZJuNHOm3GlsC0+8mn7+m0GT2PGagkhcG8Ev4qaeXIEgSC5J7myhh6jbrC81Snzeg4Y+PHA4oel17RXC81pzZOsn97l46HgV3xMBKRQEbE5uCUHfSUvpKpGu9fzTTyXR+75K6UTJemK3g1D0VXlvt3ayvBRkVfXyxwq5NxM/XsxO19GEKhz0uxGAk2hMKYbPJ/XnvKEt1jM8QuObctY3cbCUkhK2vbWuH5OInRZEtKzxk3EmQJA98N8J0g8hk3QBRQbBAhBHbZoT+ZfdDf1pa/MPTA8hcXq+RQW7IoTJTwHR81pj5A/EVD0bbRyrSAlJOllL2105b0PHKgobuZKEMxBAaCJAWphiOFL5xQPlhfed0+Cs+jKLEooJhMyWSyEpNNKj0HgYZnD6Bv89LxMHDKLvomlDtHREBdkMU4hSCLoinE+5QTBIICL8AuO1jLgcbqXA236iJr8oP8RdVUt1WQMetmI0GWkOjzUhzTI38xDMYVg6/a4QfBAtvBm13cNoIso7LBYuBgEfWJjo+mWLxjtuntM16a2Wg+2DL28YqWqDXJukRedYN4tWXVxg1Gq9eWv8T6V5U5fWe1x45dsilNlfAsH8VQTlCX1n0TR9maqzUxP44iVEpR09iWMew+PKWKr9Y6bUrPM9hGQZbSoQXMoSRqwgC2vtKrXxvF6P9xp83oCnbsVDk20dx37tZGkZUaihpNplvFrrikRyKV7IjNwSk5xPekN/x+WZWJZU2MzGomY10Rsh5gdEoOhSMFnIq7rCC57CumdOJOmqpWgi1axppxM9yfvL/TZmwJ+vwUv1QPdtqMnicjqcRQmA7C76HoTs2BENtGkGVcNplsw3HsRRKjaSb+a3/T26e9NPcnDoRo0fbEqbgPUmiOODlRQBFQpABlg8qZ1YqNkdQQkoxo2GdbXUlWdJV4n0q8b02Q0a2rBTplF6dsU5mt8Mjqk3Bki5K+RFlforT8YymVU5d9NBFIL7mNNxxNqk7D28xYq471LnuIvFJm2k6edhvLa/w0NZXGlY6NJtSRDalxVTdXNJ6FWnBPf4zGquOUtCKzzurxnaxlG95P2W28HHMg1njwrVhr/Hzzg8ZPbEVufGI1HMQoqEXi6sa/W8vf2DlaOrhEYk8/XiDjNfF5+ozGA8YptfEFiaxSbXgb8wHXghASBWuUWPwI2imuE60JxWKFxr9Tv4ksHrMJ27TT7GbXTpnpox4p+cRx88H6trnWGHrs2Mr5HDRR81cJGm/s3Myxnvc2J1hnB40/F7ygXvKsxnV80b7MrvWu7KCN+45oPxv1GQNf4FRdtKTRxHe++n5ZUTDTCmZ69bkpArEaZCw7lCbLXF56PCCo6UtUjQWq+iIVYwFLzyNOYW8z/kjNb3yCldMbf6bYa56rkpBIu2kWlBJecGqb5SbuWQmtcV9Wl5tbHFKb3C5MjEAnEZjU9CXMJvzetahNPCcvGJhueJs75kca3sZzGz+35QZ9xl1SnFlhE+gejezNs9Z/fh1XeNbGh+ov+E08N5pZW2hiN5LS+I5k9cRtxlSDKWE96PUTtmlmP3ITfmYT28T0xueD8imun9RYArfk4JVr6KkTfbf1niVqoJLw4yyppZX3nu6eeSqa8TObuR9YTTxP9CbuW1bQ+H6ssocW19rqL8LpfcZe8RejgGKD2KVTl6+0iqIpxHIxYrnVlem/3/9eEm6GtNNH0smxpzBGws3gyy4lLU9JX6Ss139X1XJPrUz3eWkW1eZ7RESsknRylPSlTpuxJej3UxzR59oyduXgPEPXndWWsbsN38khAg3VaL5sYyuxc6fCt77Z3Oq7Y41F5c4h4LsBgRugxyPXJ6L9OBUXWZFQjfBb2UiyVBf/S636o1888ieYbpq43U/c6aOvfAY7Fq5EFgo1Pb8cZFygaixS0xcJuiC4tVHSXpJACihHqqUtk3PTlJQKbovBxAgYk0ymRJsEWY7OoPRnkWObozDbacZkk7vdqEwXIDFaFwGpTJUfFFBcj4yXwpItHLnxhZKIE3EqLqnRRKfN6Akir7pB7LJLcjC2/htDwpc9isYCRWNV9UoSMkk3Q8rJkXRy7CidRdLNIhCUtTwFPU9Jy1PUlyhrxa5VcevzUkxq21vNKyySTo6J9N2dNqPnkYVE1k+w0AZBFr/mUpsqktgmCs+eNYZqziD10KS1nezYoXDsmE8QCOQGVX7d2hiJ3C1tsmz74FRcVFOJBNEiNoXj/RM3rc+hJLD0ApZeYJHlcjcBhpcibvcRd/rJVncxtnQJamBgaQXK+hIVY5GKXv/xlcazbDaDrJepiwz0RrJGV5P10uQjwYZQGJNMjrYroHhsZjU7cYsjAyOSwWSbjmWvkRitV6VVpkrkzm5MxDHtpSlEyTqtI5ZLniNBlg0RBRQbQAiBXXLp35vprB1SkXbESQABAABJREFUsFL6fBxJSMTdFCm3j7jdx1h1D+fkL0ERMiWtSElforgcZCxpha5Yme7z0twei3q4tIokJJJOlnKUodgyAyKGT0BJDr8XZeXIIgCJbaLw7NXGUaOsuhV27FRwXZidCRgZbSxjya6Nkxv7apss2z7UBVki5zBic7BLLkaqw+ebBLZWwtZKLHG4/poAzY8Tt/sw7QHS1jCjhXMx/CSWWqoHF48HGY1F3C7o4511MyxFgiyhkPPSLEUBxVAYlWP81GuP7+0cmyXx0IvaMna3MSDVM63nRZRVB2DkYii6QqUJpeeMl4oUnkMgFhgEnkCLKlo2RHSUGsCzfQIvQE9oXadBJSRBRS9S0Yu48YnlFyHuJUi5OdJOliFrjH3FC9ACnYpapKgfDzDmKQp3U8sfzEAnHpgsRasoLRNzUwgpoKaGn1W33RgScZbUcluyIMoH66Ucyd3bI6Do1kbR4kc6bUbXsHNHPYg4cdRvKKDouSkCL4VuRmrZreJUooBixOZhlx2yO1KdNuPBSOCqVQpqlfn46n1F9Q0STh8JO0fC6WewdCYxL42jVE8IMtpylZpS3dRswayb4VBsYvN2uIXJuhkOm9FiX6voSAygcyxog8KzZePPL22bDMVR2WRa2E21fNyKSJJEYjRFZarxeV3GTXMoFvnerZL1UmgxFVmJKlo2QhRQbAC7VJ+MyIpE0At3PQmqWoWqVmEmfrT+mgDDj5F2s6SdHDl7kN2ls7nSj1OWqyxqRZbU+s+iWsBS2rNa1OelKSoV3C7IlOx1kk6Oslboqf6Z3cpQEGehTUHuyqFFYqNplNj2CGh41hjxSOF5hR07lwOKR3yuvHLj2zm1MVR9HlmJ1A9bxal4ZHLbox9VRGcRgcApd0GGYgN4ik0hNkUhthpkVAKNuJMjYfeRcPrIVXZylpvBk7z6orS2tPw7T0UttSfIKJbLdKMMxZZRhELaT0QZiiEwIplU8SkRfjKGe6zee1rbJgrPY5LJZBsCs71MYizVeIaiWM5Q1KJknVbJ+En0RBQm2yjRkWoAu+T0lHN4UiSw1Rpzao25NU5juZYj56XJuRn6vBR7rTHSfpKabLG4EmAssqQVqci1lp3GPi8VCbKERMrNReXOITEkEhxV2rNyXz60sG3KnQNfx7cHopLnNSQSMn19EkePNraI4tTqCs8RLSKiDMWIzcOpuiBLaDGVXl429WWXkjlLyVwV1yo6CVJuhrSTJe1m2VM6i5SbQUiCklY4IchY0got9/FO+HEUoVCMfMaWyXgpbMmhJkfBm1YZk2JMivDb48CywrMkoY1tjwzFMdnkXj+qslpLYjTJ/G0zDW0TC0w0oUX3yhDIeqnIX2yAKKDYAHbZJd63NbMbbNllWl9gWl8VSVEDpR5kXP65qDpExkviST6LxwOMy7+LSoVGlM3rCs/RCmkYJJ0cs1FpaesIGA7i3NamB3H54AIjjz6nLWN3G541iqRUkaNr/AR27FQ4OtFoQHE8UngOAdNPIISIFJ4jNgW75GIktbogyxYrHgikgIK+ROEBfbwTXmo5yJhjrLKbc92LUYRKWSuQ1woUtAIFLU9RK+A3UJ1SF2Qpda3AYC+Rc9PktUjcJgzGJLNtIiLOsRnUgRyyoa//5i3AmGTw3yJSeF5LYjTF4W/ejxBiw8JeGa+u4B5I3daYrffIRAHFhog86w1SF2RxyO3uwn44bcKTfeb0JebWOI2ykMl4Sfq8NFk3zdm13eS8+jFZUksnBBnzavmUN7U+L8X95tFN+RxbGlEPKB7I3tppS3qeJBomKottUHj2Kjb2bInk3u2RoehZo2ixY2yWuGmvsGOHwkSjGYrWGPHMnW2yaPuQcDJoMRWpQYXtiIhmsMsuRnJ7BAOg3se7rBUpa0UmWV7gFBDzE2ScLEmnjyFrmLNK52AEBhW1TEHLrwQZC1oB9xQtdnJuJip3DolsJMgSGmOSyQ+DxbaMXVd43h7lzjFkcrLOVBC1dVlLYiSJW3FxSw562tjQNmk3RTG6vltGEpDxklFAsQGigOIG8Z0A3w22vXx4IAUsafXS58CsT8wkASk/QZ+Xps9Ls9se5dLK2WhCpaCUWVwTaDzeny7tJ6KS5xAw/BhqoFGJnO2WGQ4SLEkWfhtW9iqHt6PCcyQi8kB27lC44/aNO81CSLi1UXQzKnlulaSbxUhu7+d3xOZhlxzSY4lOm9FZJKipFWpqBS82vfKy4Rtk3CwZN0PWybG7speEn6CmVNcEGPPMKWVqskXWzTBlNFb6F3Fycl6a+2KHOm1GzyNR76HYvpLnWRLXXNqWsbuNUdkkL1yqPd0cInwSo/VkncpUacMBxYyXpqBFAcVWSfpxJOotSyI2RnSkNohdctDiKrIaqf08ECFBUa1QVCscYjmIICARmPQtl0uPuv2cX9tLIjCpyBYePvtq4yxq9WCjJbdH/GWrk3RyVLUSQSRu0zJDIs6MVG3L2OWDCyBLJHb1tWX8bsOtjRHr+0mnzeg6du5SmZys4vsCRVk/U861BwEJzZxrv3FbnISbQe+LAooR7UcIse0yFBvBVmxmlRlmzdUgoRpoZNwMGaceaBytjXOll8KRXFSh4MgOTs0hrxUpKeWoZLcJJAFZN8VSOgo4tEofOioSsyL8rLqgUsNfLGwbhedIkOXkJMZWA4q5cwY2tE3GS3HMjBbzWyXjpyiq5aiipQGigOIGiZzDBpGgolhUFIsJY7WZtx4YXFw+k1Gvjz4/xT57nLSfoCpbK5mMx3+XQxB/2erUFZ4jQZYwGArizMqVtoxdPrRAfCyDYmz9W64Q4NXG0KK+fw9ixw4F14WZmYCxMWXd9zu1cTRzCinqh9MySTcTla9EbAputa76GvXr3Die7LJgzLNgrPZRcz2dIbufa/NX4RNwVvUMMm4aIQnyapG8ViCvFshrRYpqKeobtg5JPwFIlJT2+DnbiTHJZEbYtOOMcybrcyZ9m5Q8j8oGU1FA8UEYWRPFVClvUOlZEhJpL0UhKnlumayXJK9EVZSNEHk7G8QuOZjZjaUcR5waS3ZQUThszPCLxP1AXfylz08tl0yn2FEdJOMl8SWfRbXEnFxmXikxr5bIy9WoMfcakm6Ooh41Mg6DIZHgdqk9x7KynRSe3Swi0FHN6fXfvM3YsbMeRJyY8DcYUByLBFlCQBIScTdqsB2xOdhlFz2pRdkNLRJIAUj1ANgty32iJSGR8pJkvQxZN80uawcXlzKoyyrQM3KFeaXEglJmQS3hSlH1xnGyXjoStwmJMbl9giwrCs+jg20Zv9sYk02+5y2s/8ZthiRJJEaTVKY21tc95SUIpICK0p5Kq+1ExktFwrENEgUUAUUKUNZZ2bTLLn07Eyvva+ZxrDTxEI8pbuM7asJ/yumNr1h6Yv0J8QOp+RoDfoo7YlOYxz+b4lLULIrMcWj5fbKQSXtJcm6GuN3H+c44fdUkEhJLy47iwrLTuKiW8B7w/Xmi8dL0pNp42XU1aDxrteI0HpgueSff5gq7j9v1SWas9IP+tmjHGt5P1W3881he47eRuN74sfa1xr9TU93Y9aMKmT5hUtAKlJv4fubKydP+vXhgieyjL2GykFl5zfUav352797f8DY5tXHnwpSab0Hg1sZQzVkk2Vv3vX4TKchaE/dRuYk7djO2yeL0+xkdr5/DRyZ8rnho/TVLnPr6sWrj6ImDD3qPz+a03mjmGChN5Gw0cx8NGrjHJ5azmmRDIxCbEORZx58IotT7nmY9n9Ep28RS6qb7iyml8QBHyTcb3qYZX8kNmrtnDXgpSvoShrL6PLHVJWZYYqVgWkDMj5Nxs8jVIXZ4/Vxi7SEhDApylXlldVF6XilTe0CLnYLVuK80Emsue8UJGn/uN0NGe3Bvv5FqnIqxeNK/QXM+fclt/PyZt+INbxPTGp8LOUbjn8ff4Hk6JpscEGVkJcCpNbFQVT31c989NIc6OIDkxWCNGyV5jT83gljjE0JJbcLH0hvfj6LVPYxRyWRarqJsoHWTqjSxH3lzAuhlu/G5w6x8+rmDNpRj6WiN2drq+7LGye/zQ04fS0r5pP5UMz6wukkZ383YZvmNX3OOv/H7QdpNc5c605Cf2RKnOda94i9GAcUN4Dk+nu1jpKLshlY5HijMq6cXEQmkgLxWXC5lqfcPkwSkgzj9Xop+P8VuZ4jL/DMxhEZRrjJ/PMiolpiRy9gbCGj0MlqgkvQT5KMGvC3TH8Sx8Si3EEg7FX65hrdYwti1PfrheNYYatTD5aTE4zL9/TJHJzbmFLvWGPGBH7TZqq1P0s1Q1gpIkex4xCZglVzSw40HqSIeTMbNsKSv09ZFgppapaZWOSZWF8djQX0Bu99PMeAlOccZJRvEqUg2C0qJebUeaNwfeOQle8u32Ek7WWajjPdQGCXG/4r2VLS4k9NoY9uj3LkfHRmYJ1J4PhnmSJr8LzcmypfzUuTVjWUzRpwaWUhkghiLUWuIhogCihvALrtoMQUlEmRpmYyXwpM8KkrjymhCgoJSpaBUOXB8bVpAXBgrQcZhL8P59g5SQYySZC0HGZdXp5UyZdnaMk5j1ktRky3sSNCmZQaDJHNKpS3nhn2kHhA3dm6P8pW6wnOkSnwqxncoHDu6fkAx8HV8ux8tUstumeMBxYiIdiOEwC65mPsy6785Yl3SbpZDiYNNbVuTXSbkRSa0xZXXNKHQ7ycZ8FIM+EkudffwaD+BS8CsVGVGrjCz/HteqhFsofLgtJvl/vSdnTaj54mh0CfpTNEmheepGZLXPrQtY3cbo5LJNO3pRbkVMIfTWN++CyHEuguiWT/JlBaVjrdK1k/gEdTjBREbJgoobgCr5GJG2YmhkHXTLGnF8AI3ElQlm6puM8HqaqHs6wz4yeXV6SR7nUFyQRxH8lf668wvr1D3al/GrJdhKerxEAqDQYI5uT0re/bELMgS+vj26KHo1sYwczd32oyuZedOhaMbCCh61giyWkWOrvGWSbgZ8kaklB3RflzLJwgERiJyr1tFDTQSfoJCiIsBruQzrRaYXlMlU6gmGBAxhoMEIyLOxf4gw95uFGTmpCqzcpUZqcK0XGFWquL2oPiL7hvogUEpWlhpmVFM8sKh2kx/qXXwyxX8YgltbCT0sbuRUSnGtGhPYHYrEBtN41cdvJKNlj59e4Gcl+LO2OFNsmzr0ucnWFTKWyb5aLOIPJ4NYJfcqNw5JHJuZt1y5zBwZI9JOc+kll95TREyfX6CgeXylwvsHfRXk0jAglImcGcp60tUjCUqWp5gA/08OknOTbMUOYehMOgnuF1rj4iIdXgWfawfWdv6t1sRaPj2IFqUoXhKduxUuO229ftBudYYqjlJVKXbOkk3zdHkfZ02I2IbYJVcjEQkyBIGGTdDTaniKu2twggkwexy4PCXx18UkBMGwyLBcJDgzCDHNd44CTSWJIvq0iJ5rUBhWWXaVrq7ZDPtZqmoZfwu92t7gVEpxhRtEmSZqldfaaPbJKCIyUERlZaeCnOk3h+/Nl04bUBRC1SSQYy8GikTt0ouSLIUlTs3zNaf4YaAVXbJjDXeRDjiwWS9DPfHD3Vk374UMKeWmFNLsNw7VxKQCeIM+CnOkSUGqjvZk78YNdCpaSXK+lI9yKgvUtbzeF3kNGa9NJPGbKfN6H0EDAQJ5uT2PEDsiblt1D9xGEmpIUeB7lOyY4fC1KSP5wlU9dRBB682FpU7h4AcKMS8JOWo12zEJmBHFS2hkXGyoWYnNoQES5LNEjZ3K6sl0wmhMRzEuUATZN0Me6q7SPpJarJFQSuQVwv131qRSpvaqDRD2slSWrPAHtE8o5hMtimrzp2cBllGGx5oy/jdxqhk8gMRlemeCnOk3jrDmi6SPvvUfTVzfpKqbGPLTQi5RpxAn5/gmLpO396IBxEFFNfBdwPcmo+RjBzElhH1vn+bkaG4UYQEeaVKXqliZJYz1ATofoykkyPh9JG2+xktnUXMS2IrFcr6/2fvvcMkya467Td8RPrMyvLte7z3oxmNZuQlJGAkQIIFCbOwLEbL4j5YgTDLLouR8FYIFrcIJBAg5BDyXuP99Jj2przJShv+fn9kdXX3TLnMyqrMqr7v89RTM5ERmbeyw5z7u+ecX2lRYJynbJRw9a0PGhWhkA1TlGQ55IbJChsdlVm1dTfk9eCdnCb/+ls25b17jabD87jMqluFXbs1whAmJ2NGR1d2nQsawzj5h7ZwZDuTVJAhUH182Q9HsgW4lYBUf+vOt5IXkw2yLPSYCFZTAo5qCxipc4u5eqyRDbNkgyy5IMNQ9VIyYYZIiVjQy81MRmOBkrHArNog7kLJdCbIUZYLfR1hRHH4XLw5i/nB+CTGYD+KvvOn5xYqfYrFuCx5XhEjY6PZBu7E6nO9XJimpMnsxE5QiFI8YZ3q9jC2HTv/jrVBvGqAbmno5vrtxiXLkwrTIBQqeo+nEivg6w3m9AZziXOOeFpkkAryJL08KT9Pob6LRJAlVkKq5jwVc56qWaJqzlM3Fja1L2MmTBErgqq2OSLYxUQxTjKn1jel+Xq4UCNaqGHvvVgyFEcwpIvkquza1XyWnD4VrSgoCnH2u/zIVg5tR5IMstSMhZ7JFJLsXIQQeNWA4oF0t4eyI8gEOca2QfuMUI2YNeeYNc9lMipCIROml0TGPY3dXFe+BlVolPUK83qZklFu/tbLBGq4qWNMBzlOJ2R/tY2iAoPYm2bI4o9NYAxfHA7PQ9iURUBtE3pR7hQURcEeyqwpKObDFPOy3HnDGEIjHTvNHoqSlpCC4hpIQ5bO0VxtLm9LAxSASAtY0KZYsM+tTIpYI+FnSQVNkXG4eoCUn0cVKjVzoVkybcwvlk6XiDoUNObDTDM7UU6SN0x/tInlzhedw/MItsyqW5UlQfF0xO0r7BOHaeIwgW5vTl/Piwnp8CzZKkIvIgpjrKSMGTeKGmukwlT3Sp43iFAEC0aZBaPMyaWNYAZpcmGGfJhh0CtyRe0AidihqtWY18vnCY0LNFSvIzGeFmskwxQVs7TxN7vI6cdCIJhlc/p6BuOT2Jcd3JT37jVGFJtxISsH1sIeytCYWP0+mAvTPO+c3qIR7VzyUZK64uPK0vGWkYLiGrhVacjSKTJBbseV6MZKTNWap2qd129BgBOmSPmLmYzuMHvKV2FFCep6hZKxQNlYoGyUKBsLeKrbctCYCzPS4blD9MdJzmib8116p6ZAVzGHC5vy/r2EEM2S5/SIzKpbDVUDVQXfX3lhJWiMoJmzqJtsRnAxkAqyTCVkoC3ZfNxKgJnQUTW50rdRkkGWUA1wtR1UDqlAVa9T1euc5txikRWb5IKmyJgLM+x1R0hHKXzFvyCLcd4oU9GqiBZPr3SQxVe9Zqwp2RBnDVk2Iy0iKleJq7WLyuF5szI9dxKqoRHWV4kFRbOHoix53jj5KCWzE9tECopr4FUCMgNOt4exI8gGWU5YF0HGjQINo0rDqDKdPNeHwYhsUn4O0+0nE2TZVd9DMkzhq94FAuOCUaKmr25Znw8ynJClpR2hP07yqLE55hfeySms0SKKvvNbJsRhBhHJrLq1GDsTEcewZ8/K54Q0ZOkcqSDLUePpbg9DchEgDVk6R9rPN7MTLwJt1lN9Jq0ZJq2ZpW2aUMmGafJBllyY4dLGPnLlpuPrwqK4WFrKaKwQKSuXjTb7J5Yuiu9ysxnG2bSsOn+sGTuZF42gaPO1WBqyrEVjfIHMlSufE4nYRhcapV5vJ7YNKETS4bldpKC4CnEY49dDGSB2AtF07JtPPdvtkXSNQHOZdyaoGeeyGbVYIx1kyQY50kGWfdVLyARZhCKo6AuUzWY247haY0GvECnxorlNhkf1Z7r41+wMTKGRFQ7Tm7Qi5Z28iByeG6No1gyKLBVYlZMnmxO/1QTFwB1GlwsGG8aITKzYafZQlEg2GbcakMxb3R7GjiAd5HvOkGUriZSYOWOBufPuXYqAVJQkH2TJhxlGvSGuqV6GJUzKWo2SvrAkNEbqFL7mAc3+iWVZ7twRRhSHp8XmPE+C8QnQNfT+vk15/15CodlDUZY8r44Qgsb4AoOvvHzFffJhirJW74rZ006jECU5bE52exjbEikoroJbDdBMFd3a+dlFm40TOehCZ0E2jb2ASI0oWXOUrAubeSfDFJkgSybIMdQY4TI/jyEMKlqVil7DEDp2ZGFpJp4qyyLbpT9OUlU8XKXzDdGFEHinpknecHH0wwkaIxjboIF+tzl1MkLTYHhk9QxFO/PUFo5qZ5IMsrhanVCK3JItwK0EFPakuj2MHUHKzzORPNrtYfQUQoGKXqOi1zjJ4oKTADu2yC/2ZSwEOQ429pAuJXHVBmWzRMbPMeGcJhGkqK9R/SJZnRFsPi02pwpjyeFZ2/lzzoJioKMwhdftofQ0Ydklqvk4w9kV98lHaUpybt0RmiXPR7o9jG2JFBSBWCjEyzQlcSshVspY9jV1UzpovJhQbM2DxWhjZSMW6rr3zQVZqnoFR299NaqQ3BonY32VkpGV8KLWsxGmvfVMOARopeaPDfXAIClMilGaS/wBAmJuqFxDNnaoKR4zWpUZrbL4u8qC2uDETOt9+0SrzXmAwG39NmLYrQt4+XTr54Glr/45Q5HDrFa9YD8/av2ayzgvPq/92SpRpUH+0tzyr7fxOUWz9UzKtNb6NWe0cS1E7jCGM4a6TU2XXojWxj3eW8f1c/RExMioRqSpRAKOBy/IRhAKhjvMpNGAF762SCVqvQ1HJbZbPqYatX5M0MYzy2rDrEpbx3mWi1LUzRKW1nx/pY1zc7nn/9rHrP5sbOXZKek9losZQy8i8mPMpPmi17YqXqy0cb1qbcR+7cRKutbCMUIhHWQRziQ5o8Uea4nWdgdI6a0vyib19oSQZBvH+PFaMZZP2apQ5gxnfZyNWCMTZMgGOYruIH3eILtrBxCKuKDFTtlYoGIsECsxz5Rar6aI4tbvZQv11s/TuI3PUdXWz+3V4pcUOmnFYFJpbPiaFuaLxxaMT2DsGlr2NQDRRrGcard+rap6G/cEo7XP2U2CacVFN4KWhIh2nuHt0M5cKIxaP0fnG6vfsGrHmhVtQWFwad8gvjDGcrwcp9UG042V7y5Zs/V5gK21HpfFbaxWuGHrc0g/bj3ObISrX0AJYZAQJieiiGAxXu6FmHG7xItSUFyFpsOz2e1h7AiWerhI2kOBmuJTU2fpj9IcZ4bPJA9hCI2+KEVx8edGbw99UYqImDHNY0w0OCNcxmgwIVzCLZrYbBeKUYqZTSp3bpxo9kNy9hY35f17jaAxipN/pNvD6HlOnYzYvUq5M36Bph3o3Mr7SNZFMshRk88dyRbgVQMMR0fVt0fw38s4QRYBNAyZddMukRoyb80RqAFCifniwKdRUEiGabJBlkyQZaSxiysWrsYQJlW9wn7hMaXWmNKqTKk1GptQubGdGcZhRnj4dL60VAiBPzZJ5tqVS1t3EsOKw6Q0ZFkTf6IEgDmUX3GfYpzkWX1mxdcl66MYJygpLkEbC2YSKSiuilf1SRUz3R7GjiAb5Jixpro9jB1BMUwxrjd7uARKxIS+wIR+rqeLKhRycQIxP8SI4nCDmuUNyhA2GtM0RcYx4S7+blDj4r159kUpHrNOrb1jG9RPzKCYOvZQblPev5cQsUboDqDbsu/fWpw+GXLdDSsvVCnuAMKabjbMkmyIhJ9lIi3LVySbj1vxsWS/7Y6Q9PLUzTl5D+wAmSBLWS+DAgJB1ShTNcqcYTHuEWDHDhk/i1sZZSROcUM4SE44VJRFgfG8n5LiXrQl08PYTGySCBaVKoh6A2NkcFPev9cYUmzGkG66a+FNlNDSDnpq+axeVSgUYocZVRqJbJRinGBG3ZqKyJ2IFBRXII4Efi2UAWKHyARZjqae7/YwdgTFKMUT1sq96mJFMKfVOCZKPCxKS9uzGIwoNqOKw14lwR1qgT7FYkEES+LimdhlTLjM4u/4XEZFNBvwblqG4vFpnD19KNpFkLHi9aOoPprMqlsVIQSnTka88ZtXzlBU3UGELRdfNoyApC8zFCVbg1cNcDKyoqUTJP0CNXN+7R0la5JZy5BFAVdr4DoNnvbORX2m0OiPkwws/twe5CnGCWIE0+cJjONKnRmlQXgRGEIMKw7jYnMExeBMsy+jMXpxCIrDODzMdLeH0fP4E/NYqyQlFGKHCMGCIntRbpSmoCiF2XaRguIK+LUAVZeGLJ3AiEycKCFLnjuAFetkhMOM1nop0AIBCyLgkDh3rI3KsOIwotiMKA6v0NIMKzYRgnHRFBfPLGY0TgiXYAfJjLm42Y9kYZNWpOonZkhcJOXOuEMYzhjKRZq5sF5K84JqRbBrlZJnxR0gTp5Y8XXJ+jAjB03oNIxyt4ciuQjwKgG5UWnI0gmSfoGZ1LFuD2NHkAmyTDitVw74SsQZrcwZ7dz9UxUKfcKhP2qKjFeERe6Ok1jozCkNJtU6U0qNyUWxsb7DSqaHcXiC0qa8dzA2iWLo6P2t9z7fbhio9GFuWrbnTsIbL2GuIigW42RTBJOx94bpjxM8bIx3exjbFikorkCzf6KBImfIGyYb5KhpVcI2Gu9LLqQvSlFRXLwOfZcuMcdEjWOiuSojhIIKDCgWI4tC4/VqjjcoNs5iyfSZ2GX8bG9G4bJd8wj6ohRzWo02+ueuiRCCxokZ8ndc2vk370GEO4jexqTlYuPUyeZ1u3vPyo9exR1A9D2wVUPasST9HA29SqxevC0dJFtD5EeEXoSVkhUtG0ZA0s9zwnyo2yPZ/ohmhuJzmac78naxIphW6kyrdZ5ezC6LIpU0JoNxkoE4wXCc4oZokLywqeAvZjLWmVSaIuO80ro5RC+go9CPzdgmiWDB2CT68ACKuvMrWoawqRNSRc4J18KbmCd5xeiKr/fLMt3OIJri7LT8LttGCoor4FVlP5xOkQmylI2FtXeUrMlmmoicJQYmhMeE8Hj4vO1Z9CWRcZea4DalQL9iUdZDzsQuZyKX05HHWOwyFfd+yfRmfpf+dIWo7l9cGYp5OQFci1Mnm+LWnr0rZChGJkpQkCXPHSAR5KivVuonkXQItxpg2BqasfPFgM3GClOosbF47coF/Y1gxTZmbDZ7KG4WClTwqWg+h7Vzy8um0BiIEwyIptB4ezRCv2iWTE/gMk6DMeqM02ACl2ATjE46yQA2PhElgk15/+DMBMbo0Ka8d68xrNiMc/H24lwvcRARzJQxh3Mr7lOMkxzXtmtaR++QERYaCnOKzJptFykoroBXCcjvkeUrnWDNHi6SddMUwbrjfLhAyIKoNEumF2M/C5X+IMmoajOqWbzCKjCsWgCMxR5jkcuZyON07DIeeXg9FDT2RSlOGLOb8t5LDs/7LiJB0Vm5r6ekyamTEdmcQjqzvPCgeP0IrQq67OOyUZJ+lppcyJJsAV41kNmJHSLp52mYJYQSg5AthzZCNshR0ytdydL2lYjTWoXTnItXFQF9wiHl5hjB4RpyvIZhEujM4jFO44Kf8iaJd+0wjNMUwTYBIQTB2BSJG6/ZlPfvNYZxGBfbM1N1K/GnFkCAtarDc4IHDBl7b5RinGBecYmlEVjbSEFxGUQs8GsBVlo22O4E2SDHmcTJbg9jR1CM0hw3Zro9jCU8Yo5FDY5FDc7GfirQr5pLIuM1RorXqUUyqs505DdLppU648LljHBZ6FLQWIxSPGRvTq+68pOnUW0DayC7Ke/fS4ggCWEK3Za9R9bi9Mlw7XJnmZ3YEZJBjrmEDLQlm49XkfFip2gaskhzr06Q8XurOkgoMKM0OILgsfOa5aTRGSbBMA4jONxIgSIWdcIlcXFMcRkXLlO4XVmWHlYcxjer3PnUOML1Lh5DFsXmQSGv8bXwJ5rXyEo9FC2hkRE2M5pcgN4o0uF540hBcRn8WoCiKhi2XB3dKFqskQxTPRXUbFdUoZCPE0xvcsnzRomBydhnMvZ5+LwWKWlFY1S1GdEsdhs2N2k5+rFoEC2Ji2d7M04Jj2gTi6bt2CApLGY34busHDrD+D/ex9Cbb0FRL4KaDncIzFlUze/2SHqekycidq9qyCIdnjuCUEj4WWoyM16yBXhVn8xwotvD2BEkvQIlRy5OdYJMkKO0DdyyK4RUKPMc50qzDVSGsBnGYRiHO5QiQ4qNhsIkzf7d4zQYE03BcbNlxhEcHt4EESz2fGbf9w/owwNYVxzs+Pv3IjJDcX144/OgqZjFzLKvF+MkFcXD3WHmR92gP04yLR2eN4QUFJfBrQZY0pClI2SCLJ7q4Wny4bFRClGSkJiKuj2/y4qIeCaq8UxUw1BDiJqNrocVm2HFZlRxuE0tMKLY6ChMCm9RaGwwLlzqwqfRoQdnMUqxoDYIlM6WAgXlBs//6odJXjbE7u+7u6Pv3bO4Q2BPdHsU24LTJyNuuGnl0kjFHSDOP76FI9qZOGGzXUlD7+3FF8n2JwpjgoY0ZOkUSb/AmdxT3R7GjiATZDmZ3J5u2QExp6hzimbWUByrKEABkxEchhWHS5QUdyv95BSTOeE3sxnFWZHRpdTBEuVh7E3JUJz/u38lnJlj8F3vQLV2fpZzDgMTlUlcZMfZ1fEnSliDWRRt+W9KZtV1jqJI8KzaO9V/2xEpKC6DVwmwUjv/xr4VZIIcZaPU7WHsCJZMRHaQzh0iOCUanBINWCyBUYA8BiOKw6hqc1BNcbdSJO8foIzHpFpnUjn7U2Ne8Vr+TvqiVMezE0UsOPLujxJ7IZf+3L2o+sWR4SzcIRR7stvD6Hl8XzA+Fq1c8ixA8QYQ8rvcMAk/R91caDbtkkg2Ea8aoFsaunlx3O83EyOyMaME9W2QVdfr6LFOMtpZ1UECmMVnFp8nRLO/HEACrVkurTQzGq9SswxiExAvmr40GFv8PUGDsMXqlywGJhqTHe6hWP3yA9S+8hCF//xWzIvFkAWHaTxCBHKWvTreRAlztf6JUZIZmVW3YVShUIgdKc5uECkoLoNX9cmOSEOWTpCVgmLH6KYhy1YigDkC5kTAk9G5EpjhlMeASDAYJxgUCS6JRygKhxjB1KLAOKXWmVDqTCt1AmXlEpjNcHge+8f7KN1/lMv/97dhDSxfonAWEQsm/+V+9JRN+oZ9mP2r79/TuIOQebrbo+h5xs5ECMHKJc9hCiIHYU1v7cB2IMlAGrJItobmArTMTuwESa9AQy8Tqb1jxrFdSQdZXLWBr3ndHsqmUyfiCFWOiMWYToCGwpBqLpVM30CeYUaw0ZjGZQKXMepMLPZorLBy9csIDtO4LQuRq+GfnmD+7z5M8q5bSL305jX3bzz1HMGpcezLD2LsGUFRt2d+37BiMyGkk+568CfmSV65a8XX++MEjxmyOmij5IWNQLCgbM/qv15BCoqAQEEspjiJWOBVQ6y0ubRtObRVxIqVUNt4GA210QNqym9dnKhGVsvHxOtIC8sEOZ5PP7u0b7KN4MbRWg8ujTZKWb249cuhHNotH+NGrX+OF+oUwgxPGZN44fqOL6RbX21pBK2PLTRbL0POJVoPKBzTo0KFCnB4cZsqFHJxgmKUoi9KcU2U5Z5wFEcYLKgN5kWZOa3KnF5hTqtQU5vZjP1xklP2BLb24rEvt20tCsce576//iI3f99V3PENJnBq1f3v/7MnOPO+J5qZlQKSu7L037KL/ptGKd40ipVzlj0u3UbrgKzW+nmQW+dKnYg15r1+MonjJJWtmQRqbdxHjTayel3R+kE1sfL18/zx5vfTt9u6YL9YNCcGamMIYc4RKzGI1ScLrmhdwJgJ0i0f08498Uitv+Vj9Daep1enx1Z8LRukqVvTZLQL7zPtPBcCWs88C+LVjwnX+PeV9Dbnx4zuoiFLL8SLg22I6AtR670fI6X187cRr52P5Hh9VM15wkV351Qbz7u83nrGjpFo/b4QtVkq4sWt37vXup8sR787SsOao2Cu//u4sdC6idWY27rxnKG18X3HrZ9zpVCnRJlDZzcIyGAyKBIMCoc9IsFtcR8FLGqETCp1xoS7KDLWmcElVmBU2EzSQFeXv44Nu7WYMW54zL/vbzGH8+z9sdegWqv/GzUOj3HqD/8aEUQgBGrSwbl6H4lrD5C49gDGSHHFFl2atjUWNtY65wG7IosJpYajBth667G2u875z/mINnRgpY3qhna6pK30OUIIvIkShVdc86J9gkgDAX1xkgnc5v9vAu3MVf027lUTlTZiU7/1+6htLT9H2RtnmcKl4r9YB+mFmHG7xItSUHwBfqN5gzMS8qvZKIpQSAcZFmSmyMYRZ5vGyp5g5xMrgjmtxpxWAxZLRQUkhElflGJIJCiEKQ74Q2SjJL4SMK9VyUcpMqFDQU1T0qrEGyiN9OYbfOadX2H4+n5u/6Hr1tz/yGdPcf97n+DKH7iN/W++hulHzjDz4GmmHzrD8X99ChQYunMft//6N/R8H9fI6wclRJWunGty+mSIpsPA8PKBg+INICxpyNIJbD/PXPq5bg9DchHgVX3SA8svAElaI+kXqMpnSUdIeHnplv1CFCjjU1Z8nqe0tNkQKgPCYVAk6I9S3E6RQRw0FKaEi4PGBA32i1TTAGYDvbeFEEy99yMEM2UO/tYPoFqrCyPBfJUT/+eD2HsHGH7X9+KfmKD+xFHqTxxl+q8+AVGM3p9j9F3fjTlSbHtcW8WgcHhUme32MHqesFwnbvgrOjxnhImJxqwisz03yoBwmJTf44aRqtkL8Co+VkoasnSCdJAhUiLq0tJ+w2SEhY7KrOzxsDYK1BWfujrHtHZOoNGESj5KsdsvMhBm2RMMcIN7AF1olLQac1qFOb26+LuCu46yKxELHv5fnyIOY177f+5E1VdfSZp5vsSnf/FrHHzVbi77nptRFIXRlx9k9OVNd7/GVJWT//4sh/7sPsqHZ8le2tsBYuSOoNsTba3mXmycORkxsktH15d/tqjuAMKW5c4bRYk1rCCDa8k+bJLNJY5ignqzokWycVJ+non0kW4PY0fQNLd5stvD2BYESswZpcYZavjxYi9vAQUshnC4lz0k0flW9pLDoiT8xX6MdcZpcHKxr+N6oqDypx+i8uXH2fVT34K1a/X4Lg5CTv36ByGO2fPOtxInbJwr9+FcuY++t76SuOHReOYkE7//T5S/8CjF//TqDnwbm4cuFPqwmVTkPGYt/PESANbw8j0U+0WCWaVBJGPvDTOIwwlFJutsFCkovgBv0eFZsnGa/RMXdpSJSLcYiFPMqvUNZdJd7ERKzIxeJhcmmdbLfDz7IAhIxTaFKE0hTDMQZrnC3UUmTlBXvKVS6bNC44JWR5z3b/D83z7E9IOnuPePXkmqf/XSsUbJ4+M/9QUyu1K86pdfwtQyixbOQIpLvuMGnvvbh5i872TvC4qNYTRn5dJTyTnOnAwZXcmQhWaGYpSRWXUbxQqyxGpIIBeyJJuMVw3QDBXN3B4lSb2MFhs4YVpm1XUARSgkgpw0t9kAQoFZPCoiwEbj/RylqoQ4QmMIZ+nnUrIMaDYCFl2mXcaEy/ii07THuZJj79g40//342Rfeyu5u69Z/fOFYPy9n6BxeJz9v/rdGH0ZPP/CfVTHInnjpSSuv4T6o4ehxwXFARxcIsrIHqlr4U2UALCGlm8pMBAnmZYJJh1hQDg8oMjF/I0iBcUX4FV8MkPJbg9jR5ANsixIQ5aO0B+lZLlzhyhEaebOmtsoUNVcqprLSfPcA8WINfJRaklovMrdTSFs9vkoaTXm9Aqnxk9z9L4a1/+Xl7H79tUd+uIw5pPv/DJ+NeRNf/oqzIQBK2TYa6ZG/027mPz6SS57200d+Zs3i8gdxpCGLOvi9MmQ625eIZNJKCheUZY8dwDbz+Oa83IhS7LpeJXmArSsaNk4ST+Hp9UJLgITkc3GDrIIYlx955v4bTaDONQJqSrNdlgNJeIYVY5xLh4PQp1+LEaUptP01UqG16gDpBWDGeExLlzO+BUe+/Tnia+9HOt7X7/m58594kHmP/UIo//tm0lcsXvVfZM3XsrkV54gLFXRc71rKDoonGZ2orxdrok3Po+WcdCSy/fp7xcJpmWm54YxhEoeiylZ8rxhpKB4HkIImaHYQbJBjhOJ490exo6gP05ySit1exg7gkKY5qi1ujNaoEZMqQtMndf/UxGQjhP0hWkyVYvcKYOf+OmfpC9bwB2rUTEWqJolKkaJqlGirleXAqev/N4jnHloinv/+JVk1uEgP/iSPTz+u18mqPkYyd4tpwsbI9gDn+n2MHoeIQRnToa84U3LZ7EqfgEQCJlRsmEcv0BDZjlJtgCv6mOlevf+vJ1I+QWq8v7XERJeoZmdKIWbDTOMw8RKq7+LxMAkHpPC45HziohS6IwoNsPY5I/M8B1vfBO7du/CRzApmuXSE4s/kzQIF6tfqk8cZ/zPP0nfN91O/tU3rDnGxA2XAFB/7DCZe9bev1sMigSTa3yXkib+RAlrhf6J0HR4ftqY2boB7VCK2LhEVGTW7IaRguJ5BI0QYtHMHpJsDAGZIMNCGy7VkhfTHyd5yGzdgU/yAgQUohQPtrFyLxQoa3UWqPK1X/k3Ksfnuecvv51MLsOVOqSCHOkgR19jiGSQBUVQNRY4NXaSkfl5rvyfVzJ4U4aItZ3tBm7fg4hiph88xcg9B9v5SzedOEwiwiyaM97tofQ8pbmYek2wa+/yj1zFHURY003VWrIhbD9PObG6y7pE0gm8SkBynzRk6QQpaSLSMRJ+gZoUZzvCEA7jbYpgVUKeE1Xu/8RnmP6LjzH0099ObuQaBrHYo5sM4XAdeV7HKDZaM5vRXeDJQ88z+ubXE3/n7VREtKYwrGdTWAdHqD3yfE8LikM4PCYNWdaFN1FasX+iJhQKwpYZih1gUDhM0ZCLLx1ACorn4VUCzJSBosoza6MkwxSKUKnKkosNY8U6GWEzI0ueN0witjCFwbzW/nf57F8+wMyjY9z5u/diFxL4hMzb88yfZ6ihCIVEmCY6ojH95Sqv+MZ72Lt7L9YZh7pWpWqWKLLYo1GvUFUvfKAlRzKk9uSY/PrJnhUUo8YwqjmLqrndHkrPc/pkU0ReqYei6g4Q27LcuRPYfp6p3OPdHoZkhxNHAr8eYKXkAnQnSPp5ZhOnuz2MHUHCLzCTOt7tYewIhnC4j/b7q7mHzzD91/9O7g0vIf2Sq4kQjOEye74JhIA0BoOBgfXpQ+zbt4/X3HQtRbXZc3BCNBinzmnFZ1y4TOASvcACJnnDpZQ+eT8iilG0HuzpKhYzFFV5ja8Hb6JE8qpdy77WJxxCYhYU2R5io0iH584hBcXzkOUrnSMbZKkY5QsMLCTtUYzSLCgunhJ1eyjbnr4ozYJWI1LitXdehqn7T/Lc3zzIFT9wO8UbR1fcTyiCydIEH/zvnyQ7miLxQy4njccxIot0kCXl50i5A+yp95ONUkRKzLxWYX7R/GVer7D7rks4/ulDCCF6skdX5A6j2TI7cT2cWRQUR3avkKHoDRAnj2/hiHYmamRghqlmD0WJZBPxawGqpqLbWreHsu1RhEoiyMqS504gmuLsCfPhbo9k26OIZg/FdjMUo2qD8d/+ANa+IYpvf+0qHwRl4fPU77yf6sOHOfAb/xlbfwZDKAycZwBzi5pnRHEwUZnGY0w0TWDGRYOjt17D3Ie+gHvkDM5lq/dc7AZpDGw0ppEL0GsRByHBTHnFkuf+ONE0ZOm9acG2YwCHZ5RSt4exI5CC4nl4lYDUgCxf6QSZICcNWTpEnzRk6RiFMN12dmJjusrDv/IpBm7bw6Vvu3nVfUMv4hM/9SVUTeEb3n0XmtGcdAaax5w2xZw9xWmjmZGmCoVslCQfpilEafb5g9xYv4Q3vOU2xu8apz4RUsn6zGkVjGCW4LzejN0kbIxIQXGdnD4Rks2rpDPLZw4o7gCicP8Wj2rnYQd5Aq1OJI0dJJtMcwFaGrJ0gqSfJVIDPF06s28UM0qixSaN8/o/S9qjgIWKwkwbIpgQgsk/+hfimsuuX/4+FGP16fb0P36Z8lcPsed/vBV73yAAgSI4Q50zNEtbvaj5HjkMhhWbEcVhl+Jwm1qg7/L9VP76Ns7UF5hWnabLtHCZofGibMZuMCQSzOIStLmYfzHhTy6AYGVBURqydIxB4fBFVc5jOoEUFBdpGrL49B1Y3qJd0hq5IMu4M9btYewIilGaaVUG2p2gEKWYbaMMv3xklod/9dOopsaN73r1qm0RhBB87lfvZ+ZwiW/581eT6Ft9kSJWBPN6lXm9ylHOPdjMhsqRv/oat37bXVx67eXs8wbJVa4nVkNccw7Xmj3v9zxCXbs3YyeJ3GHMzKEt/cztypmT0Yr9E4lM1CAnS547gO3lZXaiZEs46/As2TjJsz3/pDa7YRJegYaxQKzKipaNMoTDFC5xi+dlVHOZ+X//Qe2BZxj+2e/EGFi+F95Zyvc9y9TffY6B/3QPmTuuWPP9SwSURMAhcS6WNVAw/u0rjNoZrvmW13Kb2sewYmOiMoXLBI2myIjLOA2q6+jl3UkGcaST7jrxxksAK/ZQ7I8THNFknLNRHKGRwWz2UJRsGCkoLhK6EXEkMJMyQNwwopmh+IwUGzpCX5jikCkbGXeCQpjmeWv9QndY93nmL+7n2IceJ7krx+2//kas3OoC4WPvf5ZnP3aM1/zvOxm8qq/tsfpOzGltmhP/8E/cdee9ANyaPYXl57G9ArZfIFs9wODsLWixjW+Ucc1ZXGtuSWgM9M3JbBVCJXKH0OSiwbo4cypk1wr9ExVvAKFXQZcrzhvF8aWgKNkavKpPbne628PYEaT8vCx37hAJP09dmtt0hKbD8/qfy0IIKl9+gpm//ndi16f/v3wjqVtXFwjdk1Oc/u1/IfOSK+h/691tjzVAMDvk8Ngf/yOHXrEfPZsEoKjpDOMwjM1uJcltFClgUidk/AVC49QyvRk7xaBwmJCC4rrwJ+ZRdBWjb/nnS3+c4Gu6NOncKP04LODjynZiHUEKiot41QAzYaBqcol0o9ixjRmbVPRyt4ey7dGESj5OyAzFDqALlUycWFeGohCCsc8e5qk//ApB1eOK//ISDr71elRj9X5ZJ78+zld+9xFu+p4rufwb9m14zIMv2csTf/AVgrqPkTARStzMSLTOE5gF6JGD7fVh+wVsr49s9QCWnyNWQ2JrisieJlz6PQNqsKFxxV4/IFCl0L0uTp8Muf7m5fvzqu4AsSWzEzuB7eeZTx/u9jAkOxwRC7yqNGTpFCm/wFj6uW4PY0eQ8AtUZbZ7RxgiwRHWN4/xT08z9ecfpfHkMVIvuZri970eo2/1irew0uDkr34AYzDH6H+/d8OGoInrLwEhqD9+mMzLrgdgHp95fJ6mWUYLYKIyiN0UGhWb25Q+hnAwUJlezGAcF83fEzSodCCbcVAkeFKRQvd68CZKmAO5Zc11bKGRwWr2UJRsiEEhs2Y7iRQUAQWBW/Gx0wbKOldn9Db6QJhK6zflkTb6EGptrDCd9Aod+5yiV6SmlzH1zjTfLYd2y8dUgtaPiduot5lqpFo+5mwflPUwECXxiBgLAMVq6XNKC8kWRwaK2vp5nXD8lo/JWK2fGwWr9QfoqF1a+u+UWyRQPfZkTq1aWuWfmuajv/oUR74+w1WvGuQN/+N2csMOcGrFYyw1YOZEnU+98+tcdmeBb//pXajazKpj8+K1zwPr7iKP/06M//hhRu7Zg7WSEKgFBGaZgGOclUuVWMXw8+yLdYQ7BJVLYPouiBww58GeQLEnwJkAewKMEmfbgY2u0cuq5BfwnTF2GecyINvxFayL1o/aKv/Cety62cKp8MX30cCLmRo/hbMru+zr1foehFFh2i+u+3Oeqo60PDarjZL4Qav1RaH9ydZF5nIb9+t6/AKBVoDlFygZ1Re/tkg7z+12iNfoq6fJPlLbmqARoqoKpqOtK2bcqnixv412HkYb2RlzUeuxxYqfIxSSfhaccTLahZO7rbpOKlHr959Em31a61Hrxo+t/Bsl/AJTmWfWFV+8kOcq/S0fU/Vbi0sBYtF6rK22YfBotBHPppPnYp+RmsXj9jx92srxUNQIOP2hr3Dyg4/gDKW56TffRPG2vUAIrPIsjCIe+l8fRtQbvOR3vpnESAPWKL2cqa1x3SV1Jg8OEjzxDNnXXwZAsEIcM4XPFGUeO7tBQA6TQZFgUCTYKxxup0Aeizohk4vi4oRSZ4IG07hE5/2b9CdXroZRhUJ/2SZIztCvnrtu2vk39Wutz7namdsZbbQMaKedrljmK/DH57GGs6jLPFuGRDOrrhwptCLhjFUzLY9tuc9fC1Nv/XvT1K3p8RlFF84e+kWi6ZgerTyr6IWYcbvEi1JQXMSr+iQLrQcVkheT9vNUzFK3h7EjGIhTTGs12VuoAySDPPVV+jQFjZCv//kzPPDXz5IZcnj7H9/K5XcPrOu93VrIX73jEZJ5k+96z3Udy3TO7EqT2Z3m1FfH2HfPnpaOFWqMb8+iWONLf7IQQJgCdwjcoabQWL4a3H5QA4Q9CfYEs6nD2M5pbGcMbZmJk9sYxXZOb/wPvAg4/qyLELDrwPLPF8svsJB+dotHtfMwIhsjtqlLMwLJJuNVfUxpyNIRrCCDgoInr9sNo0UGdphuxjmSDWEJnYywmVmhOkgIwexXDnP4jz5HsFDnwPfcxr5vvxnNWt+0+rk/+wpzj5zmlne/icRI53r3Z245yMwnHkHEorWMRwVK+JQUn0PxwlKcbAr1nNO0cLhZFBkigYHKjHCZoM6k0sANDGa1KjXFf1GMXYiTBERUFGmWthZCCOpHp8jdcemyrw+IBFPSkKUjDGLz0Gqiv6QlpKDIoiFLJaCwV/bD6QTpIEfJXD07S7I+BuIkU7LcuSMk/Vyz8fsyHP78GJ/5jUepzbrc/V8u4e7vP4hhry9DrV7yef+PPczCpMd/+4fbcTKdLYPbfecoJ75wCrHcUmaLKApgVME4DOnD54TGWAOvH9xBhDtEef5Gpsa+iTDMYFpT2M6ZxZ/T2InTNOqjpDPPbHg8FwMPf6FCIqVy6fWJF78owPIKeEUZ1GyURJDD1SvEW2xOJLn48KoBqXTrWXqSF+N4RRrmHLSRrSS5kIRfwNNqhJoHK2RpS9ZHf5SkrLh4y2QKN8ZKHP7DzzJ3/zEKtx/gqv9+97pFQSEER/7q6xz/wCNc8d/upu/m3R0dd/aWA0x84KvUnh8ndXnrlQwvxFdiTlPjNOclNixmMw7hMIjDiEgy6hbIxQ6uEjKjVpnVqsxqNWa0KsUwxaxMjFgX7uk5/KkFMjftX/b1pqAoy3Q3jGgaBU1KQ5aOIQVFIAoEURDLfjgdIu3nOZWSfaw6wUCU5DFjgk3qk3xRkfTzTKSfv2Bb6UyNz/7Goxz54jj7XzrIW997N/sOrL/Ude5Unb/5kftplHx+4H03MXCg85PM3XeM8tQHnqF0fAGu6fjbA6CoUbP02ZlA4TH2m9MABEEat7ELt74LtzFKuXQDnjuEEBqBX8Rzh5pCY+I0CecMmtaZNgc7iYe/UOa6l6bRjWWi6TCDGpv4MqNkwzh+jrrMjJdsAV41pG9YCjadwPH6aFhyQaUTJPwCdUv2qesE/XHyRb3LYz/k5D/cz8m/vx8zn+Dq/3kvfXcexDbWV+YZBxFPv+czjH3yEJf+lzvY+63Xd3zcqStG0ZIW5YeOdkRQXJaz2Yz4PEMzm3EwXUEXKoUoSTFO0RclucIfoi9KYqHjEfLa+lXMqueExrrqSpHxBSw8eATF0Ehfu3fZ1weEw/2q7JG6UdIYWGhMIecsnUIKioBb8TETOuoyDVAlrWFEJk6UpNJG70fJCxDnBTXShGpjiKageDZDMfQjHvjr5/j6nx/CyVnc+1t3cOkrRxZL2Na3YnX6iRJ/+6MPYCV13vH+2ynuXSYDrQMM3zyIZmmc+uoYt1/Teq/TjWAYFQzjEOnzHNvDIMWhx99D38Bn8b1+ygvXMjXxDYRBDsOcxXFOYzuncRLNrEbLmkK5SLNPKqWQ5x+r88P/e9fyO7gDBEYZ0Ua/HsmFJPwcdfnckWwBfi3ASssF6E7g+H2UUke7PYwdQcIvSIfnDvFCQXH2/mMc/sPP4k2V2fWWW9j7nS9Bc9Z/DwhrHo/+4seYf+wM1/786xh97eWbMWwUTSVz434WHjzCyHfetSmfsRKhEjOlV5jivF6uAt5cu2GpHLovTnF5MEguTuArIbNqbTGbsfkzp9UIt0nPuM2g/OAR0tfuQbOXObdEs+/fpMxQ3DCD2MzhEV6kc5PNQAqKnA0OW28sLHkxqSBHQ6sSaq0bdUguJCdsVFTm1AZEcvKyEewwhSJUyuEcJ74+yefe8xgLYzVuedul3PGDV2EmWrsVPvP5ST7w/z3C4KVp3v6Ht1Aobt5ihG7rDN84yOmvnoEf3FpBcTk8dwjDmKOv/8sXbI/DJG5jlEZ9F43GKJWJa3AbI4DAdsZwFsumncRpbOcM+hrGLzuBR79UIY7hxrtXaKfhDuLJ7JyOkAjyjDuH1t5RIukArT4zJMsgmhmK44UHuj2SHUHCz1NKrGweJ1k//XGKo/oJaidmOf6XX2Hmy8+Tu3EP1/7vN5HY09fSe7nTVR7+Hx/GnShz87vfROHG3Wxm2VH2lgMc/72PE5brkOpyKy8F8nGCr9pHmdTPmbxpQqUvduiLUvTFKS4NBnmJewBbGCyojaWS6dnF8unyRZDNGLk+lSdOses/v3zZ13NY6CjMyKy6DdMsd5bfYyeRERHNfjjp0dadoyQvRhqydI7+OMmsWieWKygtE9QDyidKzJ86w+zRMiPaJRRvPM3vvPmfQcDum4u86bfvoHhJ682w7//gCT7yv5/kipcP8pbfuBHT0YAV3Jc7xO47R7nvDx7Cq12JlezubbvR2IXtnHnRdl2vkUo/Ryr93NI2IVQ8rx93UWSsVi5neupVBH4fulHCdM5gOWfO/bYmm+XXO4SHv1Bh7+U2xZXKI91BPJlRsnEEJPysLHmWbAlmUpeGLB3ACFNosYErWz5sGEWoi20f5POkVUQU446XaJyYJjg9hXdqnvwPvYRP/OifMHbqNGZfkit//o30v/zylq/7ytEZHv7ZD6MocOsfvIX0geIm/RXnyNx8AAQsPHyMzN3XbfrnrUYiNkkIk7kXOGVHSsyMXmVGP88dWkBCmE2RMUrSF6U44PeTjxNExMxpNU4Lj8lFI5gppYHXhkt9r1J57AQijMjecnDZ1wdEglnFlXPCDjCIw5Tsn9hRpKAI+NUQKy374XSCdJCT5c4dYiBKMqVW197xIiao+SwcK7FwvET52Dylo/OUj5WoTZz73jLDCW5++z0sRNO8/pdupngwy9A1+ZYDQyEEn/q9Z/ninx/hJd+5lzf87NUdc3Nei113jvK1336AI/fPcdUr1uc8vVm4jV3YiRcLisuhKDG2PYltT5LjoaXtUejQcEco13fjNUZZmL4HrzGCEDqmPYH1AqFR08tst/l7HAse+VKFl785v/JO7iBe/tEtG9NOxVrMQHaN8to7SyQbxErKioFO4Ph9uGZJtnzoAI6fRSgRni5jxpWIwwhvbJ7GyRkaJ2apn5yhcWIG98wcImieg3rK4rLbriUSMYlvvIRr995O9uoRNKf1OeLcI6d49F0fxR7KcNOv34vdvzWJK2ZfGufAAOUHj3ZdUOyLkpTUBsF6hD8F6opPXZ3jlHFOGFeFQi5O0BelSLh5LhM5XhaPkMGkhMek0hQYz/6ew0Vss3gRYOGho5iDWazR5SuRBoQjHZ47xCA2z7LQ7WHsKKSgSLOfmjRk6QwZP89k4mS3h7EjGIhTHNPkyj1AUPGYfnaShWPzLBwrUT5eYuHYPPXJc6ueyZE02f059rz6ANn9ObL781xxOZhJgysnr2fBnuDa7PLOaWsRBjH/8q7HeOxjY7z+p67gpd97YEszVLJ70qRHUzzz5dnuC4r1UYqDn9nQe2h6g1TqCGry2NI2IRQCvw+/MYrXGMGt7WNh5qUEXj+aXlsSF9PO6UXH6XFUdXMzQzfCsacblGZCbr4ns/wOQgWvKDMUO0DCz+EaZcRF3HtJsnXI/omdwfEKNEzZ8qETJPxCs0f0NhRSOk0cRLhn5qken6VxYobGyVkaJxeFw7D5jNAzDs7eIumrdzHwDdfj7Cni7CmSHjC5MhxgLvAY/dab2x7D+Kee4cnf+BSFG3Zx/f98A3pya9tqZW8+wMx/PM5oLFDU7p0UxTjF7AYTI2JFMKfVmNNqTAfnYn5H6AwKh0GRYFA4HBTDDAgHgGmlwSR1ppQG4zSYVBrUl3Hs7hWEEJQfPEr2lpXnFs3+iVJQ3CiKgH4cacjSYaSgCBi2hqZLQ5aNosYaiTAtMxQ7RH+c5H7zdLeHsaX4ZZfa8Tmqx+eoHp9t/j4xhzezGEQokBrNkN2fY9/rLyG7rykcZvZm0ZdpkG3aJaApOIxl2uuv5lYC3v/jD3Hi4Xm+/d03cu03bJJz3iooikLfpQXmTnW376AQCq47smzJ80ZRFIFpzWBaM6Ryjy1tjyMT3x3Ba4zgNUaZm70DtzFKFDlY1hR24syiEUyzR6NpzvZENuPDX6hgJ1WuuHkFsx6vD4gJZFbdhkkE0uFZsnXIDMXO4Hh9VJ3xbg9jR3AxOjzHfkjj9Fwz2/DEDPWTiwLimXmIm2Whei7RFAqv3cPgN96Es6cPZ28RPZtYVrhRlID+OPUih+f1IoTg2Psf5PD7vsrI667kqv/vVai6tqG/sx0SBwYJF+rEXtBWdmWn6IuSzGibkzXbUEKOKxWOn2cCowgoYC8JjXtFmlvFIAUsKvjNTMZFgXFSqTONS9QDJcTemTm8idKK5c4AA3GCJ/SZLRzVzqSAhQrMSkGxo0hBETBldmJHSAc5AtXD02Rfgo3ixAZpYbUd1PQ6fqlxTjBcFA2rx+fw55qrb4qmkBjNkdpbYPQbriK1r8DoZQnSu7Podmu3LS0ysaPUksNzK5TGG/ztjzzAwmSD733fbey/pbVm3J1E0RTiLnsd+V4/CBXLntyyz1Q1Hzt5HDt5HICEEiMEhEGORmMXbmOERmMXpblbcN0hVNVfNIE5je2MYSdOk3LOoOlbGzw8/IUy19+ZwjBXWKxyB8GekhklHSDhS0FRsnVIQ5bO4Hh9TOee7PYwdgQJv8BM6ki3h7EpxF5A/XRTLGyKhk0B0R0vLQmHRiFJYm+R7E37GH7zzST2FjF39WNkV1jQW4X+OMnhNoSbOIx55vc/z+l/e4ID33MbB7/3Jd3rtXo2KzHubtZ+MUpx1Ng6EUwoTaFoVnF5mmbMHwsFS6gMkFgUGh1ujosM4mCgMYPL1GK59ARNobEhoi2NzRYePIqia6Sv27vs65pQ6MOWJc8dYACbaVxiGXt3FBkVIVebO0XazzUNWeRFumEG4iTzSgN/BzQcFmFE5dGjVB48jHdyGvfUNNHCWeFQJbk7R3Jvgd3fdA2pfQVS+/pI7sqimhfenvJWew/SZJDD02otO4+PP1Pmb3/0AVRN4Qf/9k4GDnbXLU9RFUTU3ZVUt7ELyxlD6XJpqaKAYZYwzBKZ7LkJaRxreO7QotA4SnnhOiYnvoEwyGGas02XaecMTqL527YnN+VvqS6EPPtInf/6P3etvJM7CFsozO5kEn6OmUXBWSLZbLpZQrhT0CILM0rJkudOIBYzFM2d4ZZdPz7N7BefoX5kivqJGbyJ0pIpsllMk9jbR/62AyT2FnH29pHYU0RP2y96nyhur/KsGCf5qnqipWPCRsDjv/IJZu87zlX/36vY9cZr2vrsTqGozb9dxN2LGVWhkI8Tm5ah2AqeEnOKKqeUC01gspgMCYdBEgyKBNeJPorY+FG0KDLWm+XTSp1ppY6/SbHvwkNHSV2ze8Vs0qJw8Iko4wOyonIjDMpy501BCorIDMVOkQ7yVAzZ868TDMTJbZ2dKISg8ewZSl94ktKXnyJaqGMOF3AuGaLvun2MXJ4gta9AYldu08tBkn6eWovZS4e/Os3f/8TD9O1N8PY/upV0/4uD1a1GURXiLgaHAG5jFNsZ6+oYVkNVo6ZY+ALTGBEmaTRGaTR20WiMMDXxahruCAgF2x5fEhjPio26vrEy5Me+UiWO4aaXryJCu4OQOrqhz5E03U3tQDo8SyTbCcfrw9PLxFrv9sHdLphhCjXWaWzje6A3XWb284eY+ezT1I9OoaUsUleMULjzUpy9RZJ7+3D29G16L8JEbJAQBrMtxN/eXI1H3vlv1E7Oc+OvfTPF2/dt3gDXSw9kKJ51Zy4rPSreKLCAz4LiX2DQoQuFIcVkUCQYEAmuiAvcLUZJYTK/mM04pTSYUpuC4/wGTWBiL6DyxElGv/vuFfcZEAmmlUYzYaf7FdrbmkEcxpGZnp1GCopAIq2jtbjqoG5Rhk4lal3IiNpIETTayIQLuVAISvs5jmeeWfWYWtR6MFALW+//UW/jGD9uXdgK21gBna0m19wnS5YTuEv7um7roreqtX6OppOtP/iHU+fEl+rJecY+9Sxjn3mO+pkFrGKSPd9wOaOvvpz0JcWl8o/dybPC8/pdtow2rrk91iz5KEHsnGGPtb5MiMMfeZ6//bnT3PDSFD/zB7twklNrHnPIHW15bLvs1sT3lBngioDdRmt9kvraWB1OrFCmEzRGyaSeX/b1du6IQRuRUTuf42oNSB3GSR3GWdwmhELgFfEao/iNUUqVS5iavpvAK6LpNWJ7CsWeQLEnwJ5EsadQ1jCBOe4XAfjC56YYOpikVhyhtkJi7K7GMDO5p5gJWnd+dFrMtoX2rp9Wn4sAahv/QiOLvU5bIRLNe68dpBFKRGwsYKzx6BNtPBvNNp6Npr5G83fda/k9Jb2DpsQtXRtbFS8abZgO2G0YW9lxG+YGLwiVUn4ez57BUFd+r1hsTSZOO9+B1uasPm+0vlD8THV41ddH3CHKeoVTXnZp24y7dpz5Qryw9Smhrbf+3amLPeuCqsvUFw4z8elnmH/sNKqhUbzjAJd83+0Ub9v7oiqVJut/9jXC1uPmS3SLilYnl6isvTNQOVHiq//fR4nckDf/+avpvyIFrF3ie6aea3lsGXv98blvN6+rjNHAtFu7jspe6/POxDLnwXBkM69XSRjLnyPtzJ/aiUlaLTsXwCR1Jl8gOiWEzoBILAmNB6Ms/aJZUj+9mMF4VmicUurrMoHxI43yo8cQfkjixkvxo+XnoX1xknEa+JGG67cxH2yjT6TSxjFe2Pq/j2hDjU06rcdQ2uLfM+TbPK1N4axjMasnYsZtEi9KQRHQ15qFSNZEEQqpICsNWTrEMA6Psj2yPb3ZGmOffZ6xTz3LwrNT6EmToXsu4ZqffgV914+iaN1NzzfdIuXC2uUrQgg++Scn+NgfnOa1b83zw/9rFE3vnXuDoirEXS55rtd3MTjw+a6OoVMoisC0pzHtacg/urQ9jix8d5ix6qUId4h4/kaEOwSRDeYsijO5KDQ2f2POXxB4CSF45kuz3PyNQyt/dmSihxl8cxYiZ8X9JGvj+PlmZk7vXKoSiWQNbK+Ia0mDgU6QDbIsbBNzr9gPmbnvGOOffobZrx8jDiMKN+7mqp95DQMvu2TL3ZBfSD5MM6+tT0yceXycr/7sv5Pss7j3va8jPdz64uBmcbYtg+hihmIhTDPfA+XOnaKuhBxXyhzn3LV21gTmrNC4V2S4JRgkj00Vf0lgbIqNdWaUBuELhLrKQ0cw+jNYu4srfvagcHhGKW3Wn3bRoAmFPmEzpcoMxU4jBUVJR0gGGWIlpqHvnIdHtzBQKGIzTu+a20R1j9JXn2X+809Seew4iqow8JJ9HPjOmxm4Yx+a1SO3FqFg+H0E9vSqu0VBzAd+5Tm+9k/jfNdPDPLWH+3vXjPtFVA1hbiLLTXD0MbziyQ2weG5l1A1Dzt5HNU6lz0rBBBmEO4gojHUFBoXrgavH5QIxZoCZ4K0Xmd88jTCtbjirpUNfEyvj1CrEuuuFBQ3iOPnaLRhuCSRSLqH7RVZyDzX7WHsCLJBhpke7kUpYkHp8dNMfPoZpr/wPGHNI31pPwd/4KUMvfIyrGLvCHH5MM38OlqenP7cUe7/lc9QuGqAb/6dl2JluiuEvoizPRS7uAhdiFKcNFePvbc755vAPKOcqx4yhUr/YibjQJzg+riffpHAQmNOcZcExjPCY+5EGW46uOqcYxCHLyjjW/En7Wj6hE1AvNiLUtJJemTWL9nupINcMzuxtzSYbckgDg0iyvRWb6E4iKg8fIS5zz/Fwn3PIbyQ1DV7uOYnX87wyy/BWKYpdrfR/TwCQWisXFrt1UL+4iee4tmvzfO2X7uSt761N2+LitrdBtuNxgiGUcIwLr5FA0UBjDKKUYb080vbhVDBKy6JjE5tL/u86/jbv/0uQq1KcGoW35rFt2YIrFl8cw7UGNPvI1hnCb5kdRw/T9We6PYwJBLJOlFiHTPI0pAZih0hF2Y5nOy9frzVI9NMfPoQk599Fm+6ij2UYfRN1zPymitI7i10e3jLkg/THLdWF26e/8DjPPYHX2XXKw9y67teiZXpvWwnRTubodhFQTFM86jTe+flVuArMWeUKmeostQdTEAak4HYaQqNIsFlfo63/tKvEiqC6chbdJpulk5P0qChRDhCI4PJVA8nmWwX+kWCaaUutYpNoDdnzpJtR9rPNx2eJRtmGKdnshOFENQOnWb+c08y/+VDROUG9r4Bhv/Ty8jfczXmQPaCHoq9hun1E1gzzbqEZShPe/zpDz3O9IkGP/yn13HFSwusp/9NN2hmKHYvOKw3du347MRWUZQY7CkUewp4nClviD9450Pk+tL8wP+5B9MrYnh9pEvXYPp9KLFBYM6jCI1Iq+NU92ER4uk1GeC0iePnmM4c6vYwJBLJOrG9IqFWJ9J7I87ZzhixQSJK9EzJsztZZuIzzzD5mWeoHZvFyNgMvPwyhl59JZmrh1EUpa1+bluBLlQyUZJ5ffmSZxELHvuDr3L4g09w2XfdwLU/dHvPOr4rXTZlsWKDhLCY17avuWTHUaCCT0XzObLYP/7Mxx5m+q8/x8v+5p2M6FkGcbhM5HiZGCaLyQI+FXxcQi4TWSZpcJqISDqztEX/WXMbSceRgqKkI6SDPGOJY90exo5gBIexLjtQNU5ON0XELzyFP7mAUUzT95obKLziapz9g10dWysYbrEpKC7DxJEaf/KDjxNHgh//u5sYvbx3ym6Wo+ny3L3PrzdGSSROd28A24BGJeTYIwt8y88P4iXG8RLnZToI0MI0ptdHYfIeQCU/fSf9fp5YCambC9SNEjVznrpZomaUiNowX7mYUGMdO8xIh2eJZBthe324MkO7I2SDDDWtTtCGsUynCMouU198jolPPcPCE2dQLZ3inQc5+AN3UbhlL6rRuuFhN+iLEwRKSF19sflJ5IXc/78+y5kvHOOGn7yLS771mi6McP2c66HYHeGpEKWoqA2CVUyXJM3+ieZlw8w4ETNcaLhoC41BHG6PB0hhcJsYYEA4GKrKNB4TosEELuPCZYIG8z1W1daLDAiHo8r6zUAl60cKipKNI5oOz5Wc7GPVCYZJ8DW2vu9IOFdm8pMPM//5J2kcmURL2uTuuoL8K64hdfWenl2JXQ3D68dNvbjkIvRj3veOJ4hjwU/+w03kh3qvXPuFdD1DsT7K4MAXuvb524HnvjZHHAmufNky/RMViIwKDb2CFr+W6cGP4dszjLl9OEGGpJ8n4efIN0bZtXA1VpTE02pL4mLdbIqNjR7JROkFbD9LoLqEmlxxlki2C9KQpXPkgiwL+tZPkCMvYO7rR5n67CFm7zuGiAWFm/Zw5f94Hf13XYKeMLd8TBtlIE40sxOXCXUP/9OTnPncUe789dcx8rL9Wz+4FlHO9lDslqAYpplbp7nNxUrsh1QfP87gd9697OuuEnGCKtcrfTzOHJ9Wz4AAJ0gwhMOQYjOMzQ1qjn6avQEncJlYFBibQqNLgy42X+8x+uME9xmyRc5mIAVFyYZxwhSqUKnJie6GUYChLTRkieoutfuepvKlx2g8dQxFU8nefilD33EXmVsvQTW29y3C9IqU++570fb6QsDU8QZv+7Urt4WYCN3NUBRCaWYoypLnVTn0pVkG9ifo27Wy0YoWppZKnwGEElM3Sy/KstMik2SQJeHnSfo5hiqXkvBzaEKnqleoGGWqxgIVY4GKUaahXXxl046fx5UOzxLJtsL2iszkH+72MHYE2XDrHJ5FFFN67BRTnznE9JeeJ6r7pC8f5JL/+jIGXnE5ViG5JePYLPrjJPPG8iLY2JePU7xxeFuIiQCc7aEYdSdozEcp5qRJ56pUnjiJ8EPSN1+y6n6DwuHrylTzfxSYJ2CegENi8boXoKHQj8WwYjOEwxVKhpcrA+QUk5LwmaQpMk4Il0lcpnAJL7KyaVOo5LCaPRQlHWd7qwWSniAd5KgaC4ge7YuynShioaAww4tLLjqFCEJqjzxH5cuPU3/oWUQY4Vy1j4H/ei+DrziIntoeAttamJGFFiUJ7BdnQqT6TFRdwatvn5U7VVOIwu5cY57XhxA6tjS/WBEhBIe+NMsNrxtYdT/T6yMwSwh19XMv0nzK2jTl8x3KBVhREhoDpIMM6SDLcH03yTBNrERUjDIVY6EpNOrN/w52cNm0E+Slw7NEsp0QKraXlyXPHSIXZBmzN8/9VQhB9fAUU585xNTnnsWfrWIPZ9n1rTcx8MorSe/NbdpnbzUDcZJT+vLnpdOfxJvbPpnwSyXPXRIUC2Ga047MQl6NhQePYvSlsff2r7iPImAAh8k1RLAIsZSdCCXOaoUOGoPYjCgWQ4rD7UofQzgYqMzgMUGDycVMxmbZtL9jZcaiSFAloK7IMvzNQAqKkg0jDVk6xzAOkzTYjBAgqjaY/YdPU/3KE8S1BubeIQrf/irSL70WvS8LgJ7cPCFzq0kFOQKjhFimt5CqKmT7TRamvC6MrD2aGYrdedTXG6M49gSq2sUmjj3OiWc9FiY9rrx7mXLn8zC9YvsOzwp4eo2yM860c24SqQiFZJgmHWRJB1mK7hD7g8txogSu2qBqlKkZJapmU2ys6WXiNQTN7YDj55hPnuj2MCQSyTqxvTyxGhLIipYNowqVdJjalJJnIQTjH32cM//yMPWTcxg5h/57LmfwVVeSvrJprtJkh8QEopmh+Li2/HnpDKQoPbd9BLKzJc90IWZUhEIuSsoMxTVYePAI6ZsPnnctvZgcFhoKM7Q3V2kQcZwaJ6lyvlKYxWAIh2FshhSH62iWTYfETOKey2ikwSQuNba/CDcgHJmduIlIQVGyYdJBjplNXCG9mBgmwdgmlDt7JyaYeM/fE1XrZF9zG6mXXYe1e/uYq7RD2s+taMgCkBu0KE1sH0FRVRXiLmlA9cYuaciyBg99sYphqxy8JbfqfobXh9/h/mFCEVSNMlWjzDinlrbrsbGUyZgJMozU9pPys+hCp65XqS5mM579aei1FR3RexHHzzOef6zbw5BIJOuk2T9xVrYp6ACZME2ohNQ73EM2avg8+1v/wfTnn6X/nss48EMvJ3/THlR9e5irtENGWBioLKwggjnFBI2pGkKIVQWgXqGbpizZKIEAKqoUb1bCmyjhnp5j8O2vXHW/QRxmcIk7HJctELBAwLOUl4RGDYUiFkOLIuMlpLmLfvKKRUUES+LiWaFxCpdgG+Uz9osE0/Kc3DSkoCjZGKKZoXgs83S3R7IjGMbhEJ1dba58+TGm/vTDGMMFdv/8D2MMFTr6/r1KKsgROGMrvp4dtChNbiNBUe9ihmJ9lPQy5jaSczz4hSqX3pbHsFafdJleH7X081syplANmLdmmbdmMZTFTBIBVuSQCrJLPwONUZJBBqEIanqzN2PVXEB1JmiY803Tkx6bQ2mRhRklaBilbg9FIpGsE2nI0jmywWL/xA7em+un53nqlz+MO1Hmql/4Rvrvubxzb97DDMRJ5pTGisKN058k8kKCio+ZsbZ4dK2jaGdNWbY+gzQfpSjpVUSPxQy9xMKDR1E0ldT1+1bdb1A4TCpb1FMfsZSd+JgooSxeC5ZQGcRpCo043ESBIRxsNObwmMBlkqbj9IyoMYdH3IP/9v2xw9OabLWxWUhBUbIhzNjGjC0qclLXEYZx+Cyd6VMnwoiZ//dJFj7+NVJ3XcfAf70X1dp+znvtkg6yNFbJXsoNWIw/X9vCEW0MRe2ey3O9Mcpg/xe78tnbgXo14ukH69z7s6Or7yhUDD/ffslzJ1DA0xt4eoNZ59y9RhEKiTBNMsiQCnLkvH6y1QOYYZpI9WiY8zSsOVxznoY5j2vOE6vdK4Nx/ByeViXawT0iJZKdhu31MZ891O1h7AhyQYaS0bkF6JmvHeGZX/s4ZiHJTX/0XST3rt6+YyfRHyeZVleOB53+puFMY6a2LQRFupihWIikw/NaLDx4hNSVo2jJ1XvWD+IwRnez6jxiTlLjJBdeHxkMhrCXxMYryDIgmn/PtGiKjJNKo/mbBhWCri5MD4gEn1dOrb2jpC16UlCsVqt8+tOfJgxDrr76aq688spuD+lFREJt+ZhQtF4uMBe17ppmKK3XRaptpFN7sU7WK1LTKzRQIF77dGpERsufUw9bF8HqYeufE7exnOZHrV9CUbT8uZNCJ6nqnIk9Ii7cR9NaW2UM5ytM/t4HqD1zmuEffB19b7yVZpXG6pPvvNP6gytntb565mgv7mu4Fll9/Z+jxBrJIEPVnl7x3M4PmSxMei963WyjYe8lVusicCVe2Ql4OQpmHREJjBbHl1ZbF1zOL2OIIgvPG8BInO54eUPrVykEbUQks1Fr3zXAdJhZ974PfWmOMBC419/I10srH5cN0owqgi/XilAvAnBsofVJ22i69UnkweT0mvvEukfFnuHsVCCrN1BiHdvPY/l5bK9Aobof278JPUrg6xVccw7XmsMz53HNOWK91rJB16yfavnv2eP1N8u8o/VP7sI2ntvt5He08wyWtE+vx4xbFS/W4taFDrWNMzyhtp7ZH8UKiGaGYmhPresa0dp4FgdtfG9u3PqTqN1rvN7C/eosK923MkGWo4lTy77eSkwvopjn/uoBnv/rBxi8az/XvfM1GCmLteJFgLjXUtfPI22u/zwd8W0mzfKKf489kAagPl0jfeDCZ7bWRlyUM1uPm1uZowizeX76vorb4nzI1Fo/t6fq557hSS/HMa10wbblMNr4HE1t/btup1q4nTmxH63v3hMHIeXHTjD47XdRra4em/ZbSb4WVKieN1+IvNbvcarR+netW6sfM0fMHHWePk/wNPWIPiyGcBjEZpdIcQtFCli4REyKxgUZjZM08Np4BtXd1nSBJDpJ1eBM5OPH6//+ZMy4fnpSUHzqqaf4i7/4C5577jnGxsZIJpN893d/N7/0S79EMtm6wCbZPDJ+loUOrpBezIzgMIuPv8Em141nTzL+Wx9AQXDgV99O8qo9HRrh9sEOckRqQKSvvEqaG7RwaxGNaoiT6slb4QWomkIXqldwGyPoehnDkCvOK/HEl0oM7rNJ71pdhMyFaRb0Ss+VD6+GUEMa9jQN+0JBUgttbL+wKDYWSJVGsfw8ilBxjXIzo3Hpp4SvVzv6d6f8LDVTPnskMmbcLhhBDlDwpTP7xhGQCzMs6Bszt/HLLo/8r08xff8JLvuBl3Dwu25Z6r93MdEXpXnaWrlFjt2XAKAxtT2qWs6asnQjQ3FAJLhPWfm7vNipPXWK2A3I3HKQ1VIrDBT6FZOxePuYZQpgBo8ZPJ48b7uBwsBiNuMgDleT45U4ZDAo4S/1ZzwrNE7jEnUwgWEIm3k8fGWHmEj1ID05iz548CDvete7yOVyAHz+85/nl3/5l7Esi1/+5V9G05rq8pkzZ/jnf/5ngiDg7rvv5qabbkJVW1eTJe2TCXKUzLluD2NHMKI4jIn2e2UIIVj41INM/9+PY18ywr7/8a0YfekOjnD74HgFGubcqgJGdrCZKbAw6W0fQbELJc+NxiiOc2bLP3e7IITgiS/Oc+Or1u5Nmj0rKO4AIt2lpo9RS5w3cRAQ+3kcP09i8Xdf9QBWkEUoEQ2z9CKhMdTaC5aTQY6x1OEO/TWS7YyMGbcHllvEN2e3lfFTr5KMEqhCo7yB50n58AwP/vzHCWoet737myjeuq9zA9xGGEIjGzvMapUVQ0bV0LDyDo3pbSIoat0pebaFTkZYTK1SPn6xU37wCHohhbN/gGCVy3dAsXCJWdgBDssBgjM0OPMC09EE2lLJ9CAOt1NkEAcDlVm8xXJpd0lwnMNrS2YcwmZyEwxPJefoyVl0sVikWCwu/f+BAwd46qmn+LM/+zN+6Zd+CYAHHniAt771rWQyGVRV5T3veQ8/+ZM/yU//9E9f8F7VapVUqvVyKsn6yAY5TiSlWUMnGMFp2+E59gKm/+KjlD/3CNnX3Ub/97weI3XxBu2OX6BhrS505xYFxdKkx9DB3s9iUVW6kqFYr+/CkQ7PKzJ2pMHsmM91d+dYa00+F2YYt9YuPd62KOAbVXyjykLyXK8aRajYQQZnUWTMNIYZXLgKK0wTaA0qZ41gFn9qRplotf6MApIyQ1GyiIwZtweWV8SzpSFLJ8iHWcp6pW3319P/8SyPv/tzpPbkeMnvvInESIYueb51nb4oRU3xaKgBiVX2cwaSNGa2iVB2Nst0i4PG/jjBguLh7YASzs2i/NARMjcfWNMtfES1Gd9G2YntUCfiGFWOcaG7ehbjAqHxKrIMYBMDU7hMKA0mhcvEothYWUN0HVQcprbI3OZipScFxTiOL1g11nWdoaEhfN9H13VOnjzJj/zIjzAwMMA//MM/UCwWed/73sc73/lOXv7yl3PLLbcA8P73v5/v//7v56GHHuKqq67q1p+zY9Fjg0SUpCxLnjvCiGLzUNx6tmcwXWL83X+Pf3qawXd8C5l7bjj7SkfHt51wvAJz6cOr3uCyA80eHKXJ7WHq0M0MxWLxy1v+uduFx79QwrAUrrg9w9gac41smOZQ8sjWDKyHEEq8mJ1YAo4tbVdjHcfPIxoDpIIsQ/U9pIIsZmzT0KqLAmOZqlGiapSpGxWEEmNFDprQqctnjwQZM24XLK+fWkouQHeCpiFL6+XOcRjx9B99heMfepxdr7uca3/6FWhWT04Ft4y+MMWsVl1zP7uYxN0uGYpdMmUZEAmmle6aiPQy/tQC7skZhr7z7jX3HVYsxsXOFhRXYoGABQKe49w9TgX6sJbKpvcqSW6nSAGTBtG5TMZFoXESF5emsD2EzX3IeHEz6bmnyNnA8Etf+hKzs7PceOONfOQjH+GP/uiPeMtb3gLAhz/8YY4ePcoHP/hB9u/fD8B3f/d383d/93f8zd/8Dbfccgtf//rX+cu//Es+/OEPy8Bwk8gGWepanUC6bG4YE5U+rJYzFGuPHWbi9/4J1TbZ9av/BXv/8CaNcBshzmUorlbwbdoayZxOabL1BvPdQFG3voeiENBo7MJJyJLnlXjySyWuuC2LaWuwylzDiHWSsbNjSp47QayG1OxpStqFX5wRWaSC7NLPnuplJIMMqtCo6xUC1SNQffKNYWrGAm6H+zNKtg8yZtwmCLDdIrN993V7JDuCXJhh0mwt292drfHwL/07809Ncs1P3MPeN12zZpbUxUBftD5B0elPMvfk5BaMaOMo2tkeilufoSjLnVem/NARUBXSN+5fc99h1ebxaGM9UncSMTCNxzQej4tz4uDZ/oxDOAwpNlcrWV7JIFnFpCR8JnEZwSGHybBIME2DULbd6Dg9JyieXWX+4he/yLvf/W7K5TIHDhzg13/91/mWb/kWAP7lX/6FO++8c2lVWQhBIpGgWCwyOdm82VerVd72trfx2te+tjt/yEVAxs9RNkrdHsaOYAibGuGaadtnEUIw/69fYvbvP0PiuoMM/fdvQ0uvVqxx8WCESbTYwDVKqwqK0Cx73i6Coqqx5RmKvl8gjk1su3UX64sBtxbx7ANl3voze9fcNxemqasuvnrxZg6vl0DzmNemmLenzm0UYEcJUkGWXZVLiJWI/aVrSQQZhCKoGQvNH7O0+N8lfM2VQuMOR8aM2wM9TKHGFv4arUgk6yMXZHi2hWz3uSfGeegXPwHAHb//ZgrXysXns/RFKZ6w127r4vSnaMxsjwzbJWOdLY4ZB+IkD+jSkGUlyg8dIXnFKHrKXnPfYdXik+HFmaHYChf0ZzzvdHeExhA2+0lxqZLmMpHlLjGEhcbcYn/GKaXBpNJgigZzuMQyXmybnhMUz/JzP/dz/NAP/RD33XcfP/7jP87999/P29/+dsbGxnjyySf52Z/9WbLZ7NL+iUSC2dlZDhw4AMCrX/3qbg39oiETSEGxU4wo6++fGNVdJv/4X6nd9zT5b7mbvre+cmk1UtLMTnSNBYS6dg+X7HYSFBczFIUQW5ZV0GiMYtsTqKv1s7uIOXTfAmEguO7u3Jr7ZjvgyHlRo4Cr13H1OoP13YzbRzmRexJFKDhBmmSQJRnkyLr9jFQuxQlThKq/JC7WzAXqJQ8raaAZ8n6505AxY29jeUV8s4SQz5INY8UmidihtI7niRCCE//6JE/9wZfIXzXITf/z9dh9vd8zeqtQBBSiFLPa2pUDTn8Sv+QS+RGaqW3B6NqnGyXPioB+4TClypLn5YiDiMqjxxn8tjvW3DeJRkYxGI+3x/ykF2kQcYwaFhpTuPyF9iwISC/2ZxwUDgM4XBZnGcBBAaZxmVoUGCeVBoEboluazOReBz0nKMZxjKIoKIpCX18fb3jDG4iiiLe85S382I/9GNVqldnZWa6//voXHXvixAnuvfdewjBE13vuT9txZIMs49L9tSOM4DC2jl4Z/plpxt7990RzFYZ/5j+RuvXKLRjd9mI9hixnyQ1anH56e5SgqouufXEM2hbFso36LunwvApPfLFE/26LwX1rrzZnwzQlWe7cEZJBltlE0/RFKIK6WaZulpnmnBGMGmuLImPzp1jfxfhTc0R+jG6pmEkDK2lgJvWl36pcmNl2yJhxe2B5RTxLGrJ0gmyQoarVCNYQZyMv5In3fI7Tn3yWfd96HVf96EtR9d4WwraaTJxAAUrq2gv6dn9TiHVnaiRHMps8so2hdMGUJS9sFBTmpPnFstSePkXc8MnccnDNfYdVm7nYx6MLTow7jEFsJlmcXytQIaBCwGHl3IKMIiB/tj+jcBgWCa4XfRz7+iSqqmAm9aWY0UrqmCkDvccXFbaanougzm+sfZbdu3fj+z5Hjx7FcRxUVWVgYGDpdUVROHnyJLOzs1x22WUyMNwC1FgjGaZlhmKHGFEcviRW74dTve9pJv7wnzGKWXb/2n/FHC2uuv/FiuMVqK9z4pIbtHjy87ObPKLOcPbWGEcCTduqDMVdJBIntuSzthtCCB7/Yonr78mta/UyF6Y54pzcgpHtbBShkAwy1NdweI7ViIo1R+W8xYUfPPDTREGMVwvwawFeLaQ8XserBcShwHC0FwWNtqOem5xJeg4ZM24PLLdIwxnv9jB2BPkws2Z2Yn2szIO/8AmqJ+e54V2vYddrL9+i0W0vilGKOa2GWEdPNWdRUGxMVXtfUFzqobh1GYr9i4YsQj4ul6X80FH0XBLnwNCa+w4r1rqSTCRrM6TYTK7xXQoF5vCYw+OQUlra/v67vpmgHjZjxmpAfd5j/nSV0I3QDPXcgnRqMWZMGqgXaTjRU3/2Y489xoc+9CG+93u/l927d2MYBkII/umf/om+vj4uvfRSnnrqKRzHIQiafajOlv997nOfI5VKceWVMmNrK0gEOUIlwNXkStRGUWn2UBwTy3+XIoqZef9nmf/XL5F6ydUM/sibUB1rawe5jXD8ArOZ59a1b27QpDLjEwVxz5dBnp+huFU0GqP0Fb+6dR+4jZg45jJz2uPau/Nr7yxkhmKncMIUAA197Sb6y6EZKomcRSJ37h4qhCDyzwqNzeCxNufi10NELLAS+mLgqC+JjYYjy2C6jYwZtw+W108p/3i3h7EjyAXZVR2ex+87zZd/4XMYKYu7/uTbyFwiF59XYr2GLHCeoDjT+6Yj50qety5gHIiTTMty5xUpP3SEzM0H1rVAOaLasty5Qwzh8ESbDs+qqmClDKyUAYPntsdhjFcPmwvT1YDqVIPZWrBUAXM2TrRSi4JjQl+aw+1UekpQLJfLfPzjH+eTn/wkN910E/v37+dTn/oUn/nMZ3jXu97FgQMHePbZZ8lkMkuNtBVFYX5+ng9+8IPceuutXHfddV3+Ky4OEl6BBbMkG953gCIWApjhxQ+PsFxj/Hc/RP3xoxTf/lpy3/RSOYldBTXWsYIMDXP9Jc9CwMK0T2Fk7bLVbrIkKG5Rk+04MvDcAVnyvAKPf7GEbihcefvamQqJ2EEXGuU2RTDJOVJBhppRXldGyXpRFAXd0tAtjWTh3HYhBJHbzGQ8KzRWpppCIwrnlUyfExt1q7cXJnYSMmbcHiiRjRGm8aztUQ3Q6+TCDKfsFxtfiFjw9N88xmPvfZD+2/Zy4y++BjPd23FNt+mLUpzS1xcv6kkT3TFwp7ePoMgWZigOxAlOarJP9HL4M2Xc41MMvfXOde0/rFo8G8p4caOoQD8WE+v0KFj3++oqTsbEyZgXbI+CiKDm49VCvGpIaayOVwuXKmCWFqVTzZjRdPQdUwHTU4LinXfeyfve9z4+8YlP8KUvfYlHHnmEa665ho9+9KO88pWvBOBlL3sZ2WyW9773vdx2220kk0l+8zd/k0cffZT3vOc9QLOnznJlMCsxfaxCPKRhpw2ZdbBOkn6BstGe4i+5kBHFYYIGL3zsu0fHOPObH0B4PqO/8D0krj3QlfFtJ2w/T6i5hPr6Hh65wWaWUmnS62lB8fRzdb7wwUl0Q0HdoodPwx1B0+oYsq3BsjzxxXkuvy2DlVi7j0ouTFPRasSK7IezUZJBltoWPXsURcF0mkEf5yX5iFjgN8Jm0FgLaZQDFsbq+I0IVVewkzp2UsNK6c3/TunophQaO023YsbSeB0NEytp7Pisg05guP0EeplYkxk3G0UTKukwxfwL7oFBzedrv/IFTn/hBNd8/43sffudO2aiupn0hSketdbXikRRFOz+JI0eFxSDqseRv38YAMXYumn+gEjwoCLbGixH+aEjoCqkb1p7HqcAg4rMUOwERSxiYB4fYws+TzM0jGUqYEI/bi5KV5sL1LU5D68WIkSzAsZOadiLGY12UsPchlpUTwmKmqZx4403cuONNy5te2Ggl0ql+P3f/33e8Y538IpXvILBwUEefPBB3vWud/HmN78ZWL6nzmqEgWD2VA2/GqCoSrNvUsrASptYqWaq6gsfzL7YmsnBbJBu+Ri1jSau1ai1ElrHK3LMOU4tMtfe+TzqYWv7A/hx7zY+na207pYXRReeO0NagtPCvWB7+fMPM/2+j2DuGWTop76f5EgKWNu1+HxyidZXZHJW6z07zDZcG+M2mqxE67jmbK9I3Zxb2rcer36+Wf3N62tqImJocV9Dae17BhjVSy0f44q1g9LJMwH/93dm+Y9/rjC8x+BX/7DIgfTmrwCXYo1ybTeGc4YFofEitXsZ7DbEMm09b/wC3Dbuvc/6wy0f81xj5T43QSPk0P33cfd/u4an6qNL20u+s+z++90C02p92deTZutB4y5nvuVjBszWzxsvbj0E8+LWwwpLW/89JBtmKLeZ6dTOfWfZoE5VMJMmZtLk/Cd0HAn8eoi/uEJdng2YPtlY6rdzNpMxxG9r/JIL6VbMWJnxqE/NE4dxM0M1ZWKnjaXSKFW/8P22Kl70ROvXazvPu0C0FpPZ7hC+Pd3yZ7X6Oe1iq0HLx0Rtluc8Vx1ce6cXUA/P/bsWwwy+EjAZAlFzEbRyfI4Hf/7jePN1bv21NzL40v2oimBdD+4Nom7BZ0B79+54jX8jK9ZJCfuCkudqsHrMaBZTVCYbF+zXMFu/7qw24ua15kKRF3Lqw49z7P89QOSF7H/brQy9/CCq3tpntfNd65FBVtgtOTz74dZIEJraemwq2pmjxCsfU37wKInLRlGSCaLzhiOWuXz6FBMNmIq95a8utfVrzrRbP98SdutxSltzu6j156Oqre87GBEWUzTQ1Jh29LmOxIyKgm6p6JZOonAucUUIQeBG+LVm6XSjFlCa9F5UAROK7SEs95SguBzLBXqvetWr+Od//mc++clPMjY2xi/+4i9y9913t/0ZA5fmSGVSzayDeohb8fGqAQtjNbxqM9CwUs2g0UoZWGkDPWldtKt/ilBIBVlKGZmh2AlGFJsn4uZkX4Qh03/1Ccr/cT+ZV95M8T+/EdU0gNYfBhcjjpenYa5fbHGyOrqlsjDVWzfshfmIv/vjOf7lbxZIpVV+7Jf7+cbvyJK2tu488BujmLLceVlOPThN5Mfsf+nazbUBCi30aZKsTsLPMpE62u1hLIuqKdhpAyd9YWgVhYur04s/5SnZbH2z2IqYceSaPpLpJKEXNTMOKs1m7XMnK0R+jOHoWOlzC9N6yur5Hr2bieH241urm85J1kdfmGJWqyy1Gxr7/GEe+7XPkBhKc9d730pqd66r49tO9EVpymoDvwVxz+pP0zhT2rxBtYGIYsY//SyH/+/X8KarjL7xag58z+3YxRSNcGtE+f44QQWfhiLnKi9EhBGVR4/R/6bb17X/sGoxKaS/cycYxGGK3oy3zq+AUYrnZTTGAr8R4S0aB1anWl/w6gY9LyiuxJVXXtnxZtrK+c03FxFCENRD3MWgsTJVZ+ZIQByLphtkysRML/5OGajazg8ak0EagaCq9Xba/3ZhVHH4pJgknCsz/lv/gHdsjP4fvJfsq2/p9tC2HQm/wFTmmXXvrygK2QGLhYneeOC4jZgP/WWJ9//pPHEseNuP5nnL9+dJJLf+vuI3RkkV7t/yz90OHP3KBJnhBIX968sg74uSHDYnNnlUOx8lVnHCNDWz1O2htISmqzhZEyfbzGpJDu78OKHX6HTMqCgKhq1j2Dqp4rnM43Mio0+j7FM6UyP0InRbw0yZ5ypfUia61bvVF53E9AaoZp7v9jB2BH1Rmlm9ShzGPPu+r3Pk7x9m5FWXct3PvBLd2Yqivp1DsY2FPruYZP7R05s0otYQQjDz9eM8/2dfoXpsloG7L+HSd7+Z5J51GMV1mH6RYEqVc8LlqD1zmrjukb75knXtPyLLnTvGIA7H2V6L+YqqLFWzADh92yN5bdsKiluFoiiYSQMzec7hRwiB5wq8io9f9anPuMwfLxMHMUZCx0qbi4FjU2h8YfnLdicd5KgYJdrIBJa8gAw6CTSOHXqOU7/1dyi6xq5f+QHsS3Z1e2jbDwGOn6dura/B9lmyg3bXMxTDUPDv/1jmr35vltJcxDd/Z5a3v6NAvtidW7QQ4DdGsBK9ETj3Gse+MsH+u4bW1eNEFQrZOMGcXIDZMIkgS6SE+Fod6Qgm6UWWzH36zpU2+YHAXxQZvWpAdaJG0AjRTHVxUfps9YuJZm2/3kmrocQ6up+XGYodoi9K83h0jPt//t+YffQMV73jLva/5foddc5sFa04PJ/FKqbwZmuIWHS1Sq301DjP/9lXmH/sDPnrR7ntj7+d3FXrq5jYDKTD88pUHjqClk3gXLK+1jvDqsWJuLMmIhcrA9jch3z2bAVSUGwDRVEwHA3D0WEgASy6QfoRXiXAr/q4JZeF0xUiL0K39SVx8Ww2o2Zu35XpjJ+nss0yRHqVEcVmslri2C//Oc6Vexn88beiZ1PdHta2xArTKELFa9GwITtosTDZHUFRCMGXPlnjfe+e4dTRgFffm+Y//2QfI3u6m2kQBTniKIFhy6y6FzJ/skrpVI1X/NT6gvdclCAipqL2RhbsdiYZZJvZiQpb0R5MIukImqHh5DWc/DmRMQ5jvGozXvQqPvWZBn4tQNVVrLSxlM1opgwMR9+2gpHhFYm1BpEuF1Q2iiIg7yf55K98gPLxWW7/7Xsp3igXn9ulL0px3Jhp6Ri7mEKEMX6pjlVovYf6RqmdmOP5v/gqU188QupAHzf+xr0Ub9vb9fvDQJzgIV3Gi8tRefgI6RsPrFuAHlZtvh6WNndQFwGGUClgMdlhh2fJ8khBsUMoioJu6eiWTvK88pfIb5a/+BUfr+pTnqgRNkI0S1sqezlbArNdVqYzQY6xxIluD2PbE7s+mceO8Lwwyb3hDvq+6zUo2vYVmrtNwivQMEsIpTWlITNoc/Lxre8H+ujX67z3N2Y59KjLrS9L8Iu/P8SlV/eG07TfGMWwplDbaFa/0zn2lQlUXWHPrf3r2r8vSjGnVWVCXQdI+DnqW+TwLJFsJqqu4uQsnPPcIOMoxq8FS9mMC6fK+NUAVGWprc5ZkdFMGNuij7fpDjSzE3t/qD1P9bNjcLVgPljgZX/+7TgDcvG5XVShkI+SrWco9je/c2+mtqWCYm2qzlN/8jBjH38Kqz/FNT/3WoZfdTlKL7TZEs2SZ5mh+GKCuQru0Un63/ySde1voFBUTMaFXIDeKP3YuERUpQfBliAFxU1GMzUSBe0CZ5/myrSPXwnwqj616TpBPXzRyrSVMppZGL0UiAlI+znKuce6PZJtTTAxx/h73s+u7/xexvttii95fbeHtO1x/AINs7VyZ1jMUJzyEEJsiaD//CGfP/nNeb76uQaXXWvxW/9vlJtfmtj0z20FvzEiDVlW4OiXJ9h1U7HZBmMdNA1ZZHZOJ0gGOeadsW4PQyLZFFRNxc5Y2JkXNGivB0vxYmW8ilcJQIimsHheJiOxDm24x24mhtdPYE91exjbmsiPeOr3vsjuuRzju6a47ffetK2rnHqBs5UDZbW17CV7UVB0Z6pkLhvYjKFdgFfxeeyvn+TJfziEahlc9sMvY/e916KavTN9zwkbDYVZRWaCvZDKw0dAgfSNB9e1/5Bq0SBiQfTWfXw7MojdzE7sJQ1lB9M7d6SLiObKtI2TO09kPLsyvRg0lk6W8WsBd/AWauY8VXOeqjVH1ZynYSy0nIXVKZwogSZ0qkYZQmvtAyQvIpic49Q7/wQtk+TSm67nSWUSxPZqGtuLJPwC5TbEhuyARejF1BcCkjlzE0bWZPx0yPt+e55P/EuN0b06v/QHQ9zzhhRqD2aZeNLheVn8esiph6Z56Q9fte5j+qIkJ4zZTRzVxUPCz3I683S3hyGRbBnKYnailTJJ08yIEkIQNMLFypeA2nSduaMBxfDHiKxZQnuK0J5s/ramEJrftfGbbj/lwkNd+/ztjhCCB372I8w9Mc63/fb/oLFLkWJiByhG6WZ2Yovhl5lzUFQFb3pzY/bQi3j6H5/h0b98gsiPue67riL3LS/FSPXevKs/TjCjNIi7NC/tZcr3H8a5dAQ9u76kgWFpyNIxBnFkufMWIgXFHmGllekPHf4zUl6BlJ9nqHKQlJ9HESo1s0TVnFsUGuepGyViNdr0cab9PFWjjFCkoX27lD72VRRN4+D/+WH6zQRjvkxt7wSOl2cy+1TLx2WHmsL+wqS3KYJiaS7ir/5ogQ/9bZl0RuWnf6XAvd+RJtQ3T7zcKH5jF6n8g90eRs/x/GfPELoRl796/X2rClGKR+yTmziqiwMtNrCjJDVTljxLLm4URcFMNMueU+eZBT545hfR3QF0dxCjthdn9la0ME1ozJ8TGBd/C30LJlpCxfD7CGzZFL9dZh4dZ+ah09zyf97I/v37OaW11vNPsjx9UYpZvXVRUNFUzL4k7iYJinEUc/jjR3nwvY9Sn2lwxZsu5aYfuI5EMcGJWu+JiQD90pBlWaKqS+XB5xl628vXfcyIajMeyzlhJxjE4WlK3R7GRYMUFHsYRVWomSVqZonJsxsFOGGalFcg6ecp1nezr3QdemxSN8pUzXlq5iw1a46aOU/U4R5omSBHxZjv6HteTEQ1l/LnHyH3xjvZlcqzIALZ36EDaJGJFaWot1PyPNAUFMuTLiOXpzs2pkY95gN/WeZv/3QBEcP3vSPHd3x/hkSy2fMm7NHF3DjWCdwBrITMUHwhT330BLtuLpIdXV/vJDPWSQm75T5NkheT9LP4WoNQk6v3EskLURSF2CjjG2X89OFz28PEosg4gOEO4pSuRQvyRHqF0J5E2JNE9iShM4HQKx0tDzO8AkKJCI0S0AO93rYhz/3jk6T25hl86T4KpTSP2se6PaQdQV+U4ojZXim+3Z/Cm+nsM10Iwckvn+GBP3yY+aMl9r96L7f80I3k9mY6+jmbQX+c5LRS6fYweo7SV55GRDG5e65Z9zHDqsUjYXkTR3XxMIjN52WG4pYhBcXthgINo0LDqDDNojGKACtKkPTzpLwCOXeI0fKVWFGShl6hZs5RNeeomXPUrHkCrf3Vj4yfZ0Y6v7bNwmcfRgQR2dfexqjiMCYb73aEhF/A06pEbZR2pYsmigILU50RKsJA8JEPVvnz3y2xUIr41rel+d535Mj3bY8ypcAdQtU8NLlwcAHVqQYn75/ite+6ed3H9EUpqoqL32N9zbYjiSBHzSh1exgSybZC6HWC1HGC1PGlqZUSmU2R0RvAdAcwKpehen0IzSNaFBjP/sTmXNsio+H1E1gzsodVm9TGK4x98TjX/MQ9JIRFUljMtZFVJ3kBovlsvl870tbhVjGFN9O5vsiTj01x3x8+zOSjUwzfPMi9f/UGBq4uduz9N5v+OMHDxuTaO15klD73BKnr92P0rT9RYVi1+biQPWc3iiM0MphMIufYW4UUFHcCCnh6HU+vM5c4g0qzHNmILJJ+geRiyfRg9SBOmMHT6k1xcbFkumbOUVXCdQV9aT/H0cwzm/wH7UxEFFP6xP2k7rgaPZ9mRLEZE3L1pBM4foGG1Xp2IoBmqKT6TBYmNvbgEULwuX+v86fvnufUsZDX3pvkv/5UjpHd6zPv6BX8xiimM8Y2MJzfUp7+xElUXeWyV4+u+5hClGw6PEs2TNLPynJniaQDCM0nSJ4mSJ4mVBZb5cQ6mteP1hhEcwexZm9B8waAmMieOicyOpOgV2EdbW9Mt7/p8Cxpi8P//BR60mD0tZdTiFIsqHUCZfNbG+10EsLEEgZzbZql2f0pZh/aeBuT+WMlHvjjRzjx+VMULs3z+t97FbvuGNkSc8BOYQiNvHCYkiXPF+BPzFN76hS7f/LedR+TQiOt6EzIHoobZgCbBXxceb/cMqSguIMJNI+SM07JGV/apsUGST/f/PEK7KnvxgmyRGpI2ZinbJaoGCXK5jy1F5S/mJGFHTtUZJZIW9Qefo5gcp7B//5WAEYUm89FMtjuBAkvT91sP6MuO2RvKEPxoa81+KNfn+fpx3xeco/D//6Dfi67ujf73axFU1A83e1h9BxPffQkl9wzgp1Zf+/LPunw3DESfo6plCz3k0g2BTUkcsaJzosXESqqV0BzB9HdIcyFa9AmX0VKaATmHL49TWBNLf6eRrwgE9vwBqhnpYlSO4SNgKP/dogD33QFumPQ10gzq8my0k5QjNIsqHXCNnvBW/2pDZmy1CZrPPK+R3nuI0dIDiV5xa/cxcHX7UfpQYO+teiPE9TwqSudba+13Zn//JOotkH2jsvXfcyIajMb+3hIj4KNIg1Zth4pKAKNyESLWjNI0NsyQGn9YaG3oa4n1FXKPjWP2KhSSZ7ibGiixBpzlX1kgyzZIMsu91IyYbNvR1kvUzJKLBgLqEKlqlapCgUiAz/q3dMnFq1/19PVVMvHqOr6b/zzH/s6zmW7SFw+gkrMkGIzodaXMkpXI2G2Xsrr6K0/4PU2AiytB5zdHL/AQuLFIpjG+saWG7AoT7poCE4Ffev+3JOHavzTb53k8S+WuPQ6h//1/w5y7R3N82hijUs318aKrtrGdx2I1npXufVdJPIPt3zcVtHOtV2LWxd34/N6fk09W2Lm+QXu+m/XXrD9hexPXejmPFyzOJU8zf7kyi7PlcBueWztYLcR8GtqG9d2G4+FQKzRDkBAKsgyaU+RWmzZUY1a/97auVPFbVwHaz23t9+0UXI+rcaMWxUvRm2cq8Zq56oSE9szxPYMAYuGZwJcbwDD7cf0BnBq+8nM3oYaJQjNeQJrmsCeIrCmMN0i5cEpVEUQxK2Pbc37Qodo5xp/ujrc5met79/12CeeJ6gFHPjWa4mFQiFsuhKv9/h2npPtxBdbRTtjW+k76AtTG+prbBeThDWfsO6jJ0xOVPPrOi6ouBz/+wc59aFH0ByTS37kHka/8VoUU+foOtYdg7j166Gd86AV+uMEM21mJ7YzNtHGKZo0W4992vmuzyaWCiGY/9wTZO+4As1Z/TnhJM7N7faQZZL6BduWI4xav1+ZRuttdzJW61VbcRvPrc24V+1xDRaUCnnr3LkZtfEM6oWYcbvEi72rCEm2DKFGlMwSJbN03kZIh+lzImNjFwW/gIrKK6ZewYKxwJRaY04vM69XCGSPsFVxT0xRf+IYIz/5rUAzHTtGMEvrQqHkQhSh4Pg56m2WPANkBy2OPlxa9/7Tp13++XdP8fWPzDCw1+Zn/nAvd7w+u61KVZZDCAjcEQznI90eSk/x9MeO4+Qt9t0xtP6DBKSDLBVDluluFD1y0GMb9/xnlEQi2XoUiMwFInMBl3PmL2qYwHCbPRnNxhDJ+RtQhUXh9DcT2FO45iyePYNnTRPp1e0zS+oCQggO/9OTjL5sH8mhNPUQ+qI0z1uyf3knaFYOtC8oWsXmorE3U0Pfs/bCQuSFnPqXRzn+/gcQQczeb7+F3W+9GT25PatYzqc/TjKlyiqM86k/N4Y/NseuH3l9S8cN4jAhe/51hGKc4AnZ13NLkYKiZHkUqBgVKkaF0zQzv26dvZWaXmPenCcbZBny+7iysZ9kbFNR64viYnlJZGxIN84l5j92H3ohTeaOK4mBEcVhHLet1Q/JhdhBFqHEeHr75UC5IZvpY3U+/d5jvObbsuQHlw8SK3MBH/nTM3z27yZIZHXe/sv7ufvbBijaOyMIiMM0cZjEsMfX3vkiIQ5jnvn4Sa54/W40Y/0rj06UQBUaNUM69m0Ux8/j6WViuXAlkfQksV7HSx3HSx0HwC5fSnrmVhYGv4jp9aM3hkhWD2L4eWLVx7On8a2mwOhbMwRmCXo4Q24rmXrgNJXj89z00y8DQBcquTghS547RF+U4rkNiLP2QNNk4/D//Rp733Ij6SuHl11MFlHM+H8c4shffg1/rs7oN17D/u++HauQ3PTMwa2iP07wuC6Fm/OZ/+wT6IU0qWv3tXTcEDbPI+PFDSOgGCeZkUL3liIFRcm6yYZZTiRPMGVPMe6MU10s1bNik0KYJh9mKIQZDnijpKMEruKfExmNMnN6hZLiXnQr02G5zsIXHqf4bS9D0TWIYQRpyNIpHK9Aw5zf0Hn1krfsYvJojU+99yif+IOY6+7Jc89bBrjunhy6oeLVIz751+N8/M/GAPjmd+zidd8zjJXYHs7N68VvjKJbM6htuGXvVE7eP0VtxuWqN+5r6bhUkKWmVxBykrxhbD/fvMYlEsm2wHQHCJwp/ORp/ORpvLhpTqbEGqbXh+n1Y3lFsqXrMb0+QOBbs0sCo2dP4xllRFvl4tub5//xCbKX9FG8oVlWXYhSuEpAXZHP5Y2iC5XsBsXZxEiWy37kZZz80KPc/6MfJLmvj9E3Xs3Qa67EzDoIIZj56lEOv+8r1E7MMfjySzn4/XeS2LW+0uhtg2hmKE5LQ5Yl4iCi9KWnKLz6BhRt/QvQCmczFOW8cKOkhImFxpwqv8utRAqKknWhxzqpKEVpGUMWT/UZN2cZN2fP218jH50TGa+pHyAbpomUiDmtypzeFBhn9TIlrbajJ92lTz8MQpB77c1L24YVh8dEqXuD2kEk/AJ1s/1yZ4BkzuA7f+0a3vxzl/PcJ0/yxQ9O8vs/8iyZosFNry7wyGfmqJVCXvldQ3zTD42SLmwv5+b1EjRGMZwz3R5GT/H0R4+T35dm8OrWJgNpP0dVuhJ3BMfP40pBUSLZNhheP27q6Iu2CzXCc6bwnKmlPt4IBcPPY3lFTK+fVOVSCjN3MBobeGYJ15rBtWaXfsc7eMGrcqrExFdPcsvPvXwp660vWjRkucgW4zeDQpTEUwJqGxRn9731JvZ+6w3MPnyK0x99iuff+2We/7Ov0H/nAbzZGgtPjpG/cTdXv/N1ZC4f7NDoe4uMsNBRmVXrsEMyLjdK5aHDROUG+Vde29JxBSwUYBZZ2bdRinGCecVt23RJ0h5SUJSsi2yQpaE28NcZyIVqxLRaYvo8AVIVCqkwQyFMUwjTXOqOcnt0BapQmT9PZDz7E+4Au3cRxcx/4gEyd1+Lnk0ubR/B4RNClpV2AsfPU0qe7Mx7pQ1e8R2DvOI7Bjl5qMYX/2mKh/5jjqvuyPItP76b/l1bY6DRLYLGiCx3Pg+/HvD8Z8/wkh+4suX+mKkgS0X2/OsItp+nnJNCt0SyLRBguP1Uivetb39FEFhzBNYc8NzSe0RBDtsrYntFko1R+krXYYQpfGMB15zFtc8JjaFW3xGC25EPPYmZs9n96kuWtm3URERyjqY425kenoqmUrx1L4Vb9uGX6ox/6hnG//1pVFPjxt98M4Vb9mz7vtqr0R8nmVMaRIqQguIi8599Anv/IM6+gZaOG8JmElf6O3cAWe7cHaSgKFkX2SDLwgbNBWJFLImFSwhIxwn6FkXG3X4/19cPYAuTslZnTiszqdWY0arMaBVctXW3rm5S+fohwpkyhTfevrQti4GNJpvvdgIBCa/AWP7Rjr/1niuTvO0X9vO2X9jf8ffuVYLGKE7usW4Po2d4/jNnCN2IK9+wt+Vj00GW8eSJTRjVRYYA28/JDEWJZJughknUKEFgTbf/JgoERpXAqFJZ7MsIoIX2osjYh+0VyZYvxQxyRFrjgixG15rBNxa2lcgY1HyOf+xZLnnLtWjWuelZX5TmSftUF0e2c9ioIctKmLkEe99yE3vfclPH37tX6Y8Tstz5PMJqg/L9zzP8Pa9o+dghHCZluXNH6IsTzaxZyZYiBUXJusgFuWXLnTeMAhWtTkWrc9w619jXiU0KYYa+ME1/kOVKb4RsnKCquMzqTXHxrMhYUXu3L+Pcx+4ncfVe7P3n3GFHcZjGJZSWLBvGWHR/lf3VNo6INQJvEFOWPC/x9EePs+vmfjIjybV3Pg9VqCTClHR47gBmmEYRKp40t5FItgWG109oziM2wUQp0l1q+mlqydNL25RYXxQYmyJj3/z1WH4BQYRnzV4gNHrmHELtzTyg4x9/lsiLOPjmq5a2KeKsCCYNWTpBX5TikDnW7WHsCPrjJJOqzJw9y8KXDyHimNw9V7d87BAOJ5BZdZ2gP05ybINtsCStIwVFybrIBlnGt7AUsqH6nDFnOGPO4EbN09QUGn1hmr4oRTFKszcoko+ShErErFZdEhhntApTeMRd7svYODJO49BJRn/2rRdsH1EcxoTMTuwEjl/AM6T7aycIvEEUJUSTD2IAKpN1Tt4/xWt/8ZaWj00GGSIlwtXkKulGsf0cnrmAkP1wJJJtgekOENhTW/Z5Qg1pOJM0nMnzN2L5uXOZjJVLGZy5AzXW8cz5C0TGujlHrHW3+kXEgiP/9AS7XnEApz+1tD0dNRezFmTGzcYRUAhTzDpSBOsE/XGCJ6TD8xLzn32C9A37MQrplo8dxOY+ZjZhVBcXioBC7DAj75dbjhQUJWuiCpV0mN5wyfNG8ZWIcaPE+Av6MuajJMUoTTFKcaU/Ql+YQkNlVq0xrVWbP2qVGa1GsIV9Gec/eh9Gf5b0rZdfsH1YsTkh5M2uEyT8PHWZndgRgsYIhjOGsoMNklrh0MdPopsal716V8vHpoMs1W1WbterONLhWSLZVhjuAL7T5V68SoxnzeFZcyzwfHObACNML4mMycYu+krXN/sy6mUaS9mMszS2uC/j+NdOUj1d5tZfeNUF2wthhjmtKlvUdYB0bKOjMq/JTLCNoguVvHBkyfMi7niJ2tOn2PNT97Z8rIFKAUuWPHeArLBRUJhX5He51UhBUbImmSBDqITUezDbJlYEs3qVWb3Ks2c3CnDCJP1Riv4ozb6wwK3RHhLCpKQ2mFGrTGs1ptWm2FhXO+8YGJaqlL/8JP3f9UoUTb3gtREcviZmVzhS0gqOV6AhM+o6QtAYxbBlKRCAEIJDHzvBwZePYKXNlo9PBVlZ7twhHF9e4xLJdsLw+qnle7AXrwKBUSEwKhf0ZVTCBLbXh7NYNp2tHMQKckSquygunhMaPWOhmQbTYQ7/4xPkr+yncPWFZg75MC0NWTpEX5RiXqt1vXppJ1CME7iEG3bL3ilMf+YpVMckc8fla+/8AgaxaRBRQVZabZRinGROrcsFmC4gBUXJmiwZsmyXC1SBBdVlQXU5bJxLIU/EBv1ximKUoj9KcWUwSD5OUFN8ptUqJ2OPcaXBOHXm8DZ0Q5r/5EOgqeRefeMF2200+hSLMbkS1RESfoG51NFuD2NHEDRGcbKPd3sYPcGZZ6rMHP7/2TvvMEnKcm/fFTv35NmZTWQWyVkERYKiYEAURDFhBiSqRwxHBD0qJpIERT36eUyImI75GI/xKGIgCiyweXd2Zyd0VXdXfL8/qidtmumemun03tc11+z2dFW9XV3hV8/7PL9njGddflhNy+e8DoZkcDYWkm4n27Or6z0MiUQyB5Qgge514CXn0ZBlkQm0MnZ6A3Z6yj9YCXWSbvdkoLFn9FCSbjcAZXOYpFpi1BhnVB9nzBgnmIclw/iT2xn6y3qOv+a0nboCd/l5VhuyFDIOegMZnI2LqCGL3TzPhQuIEIKtP3+QjhMPQktWPwG9hKTMToyJ3jAty53rhAwoSmalw+tYmIYsi0xR9VijjrBGnyqfM4RGb5ChL8ySDbp4psizhBQBgs0iCi5uVopsosQQJfw5zGwKL2Dkp/fSccrhaNnUjL8NkmJUuBRZvNLrVkUJNZJenmJCZi/FgVtaSn7gx/UeRkPwl+9tItWVYK9nDMz+5l2QdTtYnX8o5lG1H4pQZYdniaSJMMp9+Po4odbcPtFC9Sklhyglh5i8+ggl8mV0uwkKe7GiPMhh3kEYwqCgW4zqY4wa44xUfrvq3HwZH7/7AZI9aZaftt8Og4BuP8efk0/G+tnalZ4gyyZ9tN7DaAn6wowsd65gPbKJ8sZRll7ygpqWHyTFZhlQjIXeMC0bBdUJGVAEVEWgVp0CvzjTMuN+supltoXZ2d+0A+XA2O3f8l4Xj6We2uk91e8zyGpO1cvUsh0/VGd/ExAoPlvUMbYwxvpi5KuiAn0kWUqKpUqKw0QPZ5AigcYQZTZRYqMosYkSm5QipR2Cg+N/eJBgxKL7BU/faXuDpNiiFEma1RmAp6p8P4CptnbQMuV1EqgeXsyl+CrVZxrUskxQwzWkHC7MJTv0soR+B15iG35oYi6S12jA3M7T6SSV6stCjkvNPYvV9wUf/OFGnnd2nuf3PFjVdn5VOBg9MEmGKZTkEPk5GP0namgodFy2+gfM0SBd9TJBDWna2RoCCcVw17P6CacLoQQo5giJHYbihVrV21Gp/l6i1ZB5NNs9S5FZHU1N9Zpxcb7wWq6nhaB6jemJ3d+HkuUBnMQwTjhTL3qi+vM1p1Z/LSmL3WvZ3THkZeb+Zq0MqY087FWuCwIyYYKeIBf9lHvZJ9ibfJjGUssMawWGtQLb9QLDmoWvz8zqcsfLrPnJoxzw6qMIdYNw2mGVCk0SwmRUL9Skg9udHa/3PUGWBxPr9ngfCGs4V8Ma7pPBHJ9R6oGYw+fpCzM8oG+dfO9clomDWr6flFH981OfPnefzft+fR+pvgxHnZxB0arLJl4z3sVSN8GD2jAZbW7l43N9vp3OYHa86mXcGjRWLWPLGNVr4N2dc31hmscTm0jpO3/ntYytETRjs+hFGVCU7BFFQKeXZyRf/cWoWQmBLZTZQpm/ianMmE4MlpJikBT7KFlOoo8uxWREuGwiymLcIIr85fePkTlyPxIr+nZa9yApNilyVi8O0k43RXO7LLmIgaA8iGoOo9QQ8G817v1die3bAk4/p6Om5dNuF45mE9S5a2grkHC7ceQ5LpE0DWa5D6eJyp3njQK25mBrDmundWk1Q53uIBsFGf0ce5X66Aoy+ErA9kqAcbte4O+/+QuaqrL32YfstOpuP8+4VsSXHe7njSE08mFKljzHgZhW8tzmhF7A+l+sZu8XPW0nv/w5IaBPpBlS1sU/uDZDFQqd8hyvGzKgKNkjuSDKdizIrmiM4jGKx0OMMzFpkUKdDDIuJcVBbpoLrr4Wl5BNOFEWIyU2UmIrZZaS4n8VWb4XB7L7a3z45UG0ZJ27cjYIP/mOxd77G+x/aPWZOwBpt1N2Ho+JhNNNWVoaSCRNQ8Lpxc49Xu9h1B1X9dmsjrJ5ml2QKhR6RZpuP0e3n2O/0lKOPvJ8LvrKaxhTimwvTAUaR7QC3X6O7Vr7TOYvJD1+Dlsp48yxDF2ye3LCJIHOsOyky6Y/rsUdd9jr+QfWtHwGgzQ6W+W+nDddYRqPEEuRiRH1QAYUJXuky8szaowjZLnFLikT8AQWTxDNiGy49R78NUOccNNVLCPNICmOpYdBUugoaCgcGnaTU0w2K0U2U8JZpPLSViPtdrNNPrjEQlBaipaSTURsK+R/f1rkwss6dzLHnytpt4uiORrvwNqUhNtFMSUD3RJJM6CEGobbhZOQTUR2RaiIyexEgI2/Wc2f3/dTXvzF17PPyr3o8nMMet0cUtqLbJjCw8fSShxV2meydNpWHZmxXQM9QVZmLsVEn8gwopRk5iyw9ieP0nlgLx37dte0fL9IM4KDJ/flvOkOsmzXZKOgeiEDipI90uV3MKLLGdK54A2PM/7Hh1jy+jPYpJbZxJT/jwIcSJ4L2Jthyuwv8jxTDNCByfaKL+NmZaIBTJFxPHlR3BMCUm43JVNmL8VBUB7EzFfnF9iK/PrHNq4jOOMl1fvQTpD2OtmceiTGUbUvSbebkU55XEokzYDp9BCqDoEuAzdzYfXd99Nz+CDqASnWMMSaxNDk3xKhwYtGTmBIHyMfpNnHXUJnkMZVfIY1q+LJGP2MakU56T8LPUGWYXlcxkJfmGZINmTBHS+z6Q9rOPSinf3y50p/mJLNbWKiJ8iwXU4a1A0ZUJTskS4/z9qEzFyaCyM//guqqdNx6pE7/U0AGXQ2UOIX2tT+TAudAVIMijQDpDk07KaXJA4BmymySSmymSJWMMp2tUQoRSMApp9FDXVKxli9h9L0CKESlAfQZCYYP/2OxVEnJBlYplOoZcJYTJQ8j8Y9tLZDCXVMrwNHlo9LJE2B6VT8E+Vk6KyMPraN4b9v5LgPPW+Xfw8IyYgkf8s8jkXUtEATKl1Bhh4/agBzkLOcbj+LhsqIZkUBRj36vV0r4LV4Y75q6A5y3G+srfcwWoJ+6Z8IwLpfrCYMBCufe0DN64j8E2VAMQ66gwzrDJlkUi9kQFGyeyoNWf6Rldk2sxE6HqM/+ysdpx+Flk7s8j1LSbGJmTeOouLzBAWeUAqTr+lCoZ8UAyLNIGmOE/0MlFaiojKsFhlSLbaqNkOazVbVxm3Dkum020XZGENIwTxvAqcPlADVHK73UOrKlo0+9/2xzHs+1lvzOhJ+FkWoMtAdAwm3C18t4cfcxV0ikSwMCacPV5Y7z4kn7v4nqf4sg8/aZ5d/7wqylBSXsupCpTtpoIRs0wts06f0IgLyYYruSvOX5V4PR5T2IiOSjKtFhjWLYT0KMLZrybQiFLqDDNu0wuxvlsxKX5jhIV2e52t/+igDxy8n2ZOueR39Is3j6mh8g2pjuoMMf0/I5jb1QgYUJbslHaYwhM6oLm/CszH+2wcIrBLdZx2/2/cMkuJvzD574iuCjRTZOG3WqiNZplMk6Qsz9AcZ9gq6OM5bTk4kGFXKbFWtyQDjkGpTaHFT2pTbTUk2a4iFoLQULbkZpc2zX3/2XQvDVDjlzEzN60i7nZSk52wsJJ1unITs8CyRNAtmuZexrr/XexgNjzNSZP3/PMpBbzweVd91Z9huP8/IXLS3AuNaiXGtxFPmVMl0MjQqQcao0/R+7hI6gjRupcv0RDbjdq3AiGa39D2rI0wBMC5LS+eNJhS6RYohpb0zFK31Ywzfv4Xjrz295nUoQqFXpGSGYgwYQiMvUpGHoqQuyICiZLd0eXnGdYtQmsXuESEE23/4f2SPORBzcPfGvIOk+CE1dvJSYFQpM6qWeUyfyiRLCZ2+IEN/mKUvzLDK76U7TOPgM+LMFI2jmt0yJdNppwsrubXew2gJgvIgerK9bQ2EEPzkOxbPfl6aTG7XD3hzQTZkiY+E2y3LnSWSZkEomG4PblJmLs3GU997CEVV2fvFB+/2Pd1+juF5+JeXVY+N6nY2TisBnF4y3R3kOMhZtkPJ9ExvxlYpme4JcmzXLIScnJo3vSKNS0BBces9lLqy9mePoacNlj5r75rXkQuizMYRpTzLOyWz0R1kKCoOZdnFvW7IgKJkt3T5edmQZQ4UH1yD89QWllx4xm7f04mJicYQ5VgTbkqKz1p9jLVMlVhqQqEnTLOXmqDHz3GQs5RuP1cRjXY0O60X2F7x3HFVP8YRLQ4pt5ut+UfrPYyWICgNYuTb29bg0QddnnrM49L31tapb4K014ktGwXFQsLpZjz3RL2HIZFI5oDhdgECzxit91AamtALePI7D7D8jAMx88ndvq8nyPGA+VSs295dyXQuTNFTyWZc5nVzWHkvsmGSglqqTEpP6UVLLTdd1ni37PAcG30T/olNdgzEiRCCNT95lGWn7IueNGpeT2eQZZtSlIHuGOgOMgzL7MS6IgOKkt3S5XWwxZSzzbMx8oP/w1zRR/rwXXvhQOSfOEQZH0Htt5+5ESiCIc3GMYdhws5xUjRm6fZzLN1BNE6KxcQoI/o4tlpqWMGghgZJP09RBm5iISgvJdn/q3oPo6785NsW3b0axz0rNa/1ZNwutmZXxzSq9ibhduHIc1wiaQoSTm/kn9iguqFR2PjrJygPF9nvvMN2+x5FKHT5WbYvhuefAgWtRGGHkulEaNAdZCcbwOzj9tMZZPCUYFIvTgQaRzSroatfevwsa4329oiOi74w0/Ydnocf2IK9YZxjrn72vNbT5ecYUmqsWpPMoCfIsl02CqorMqAo2S1dfp5HMjJDZE+4Q6MU/vIvBt5yFoqyeyU9uIuGLIvKDNE4VSqcCPXIZyfI0e1n2cfenw4/i68EjOoFRvRxRiq/xxqk/D3tduFqRXxdlgnMl9BPEXqdaMn27fDs+4L/+b7Fc1+cRddrfxoWoU7Sy8mS5xjQgiRGkJElzxJJk5Ao9+EkpA3JbKy++5/0HrOM/L49u31PR5AmRFCoY0MqR/XYpI6wyZi6BqtCoSvITgYaD3SW0h1kMYTGqGZHJdOVQOOwZuE0SPlhT5Djb6mn6j2MlqAvTPNImzdkWfuTR0ktydJ31NJ5rafTz/GI9E+Mhe4ww2PGlnoPo62RAUXJLkmEJukwJUueZ2HkR39GTSfoOOWIPb5vKSmepPFKLhzVnyEa07qHKlTyfoYuP0+Xn2Of8lKO9g9CFxrjms2IPh4FG43ximn44gb2Uk4XJRloiIWgvBTVGEHV23eW9M+/LTGyLeTMl2bntR5R7idQPVzZlXjeJJwuXL1AqLW3T5NE0iyYTh9W/l/1HkZDM/LQZkYe2sLTrz9zj+/r9nOM6I3n+RcqIgoW6gUeS1QmIQVkw2SlZDrHEr+Tg50V5MIUtlKeKpeueDOOL3L1SzI0yIgE22XJ8/wR0B9m+K2ytt4jqRuBG7DuF6vZ9+yDUdT5Hcidfo4hTVZhxEF3kGE4KTMU64kMKAKaEqJVmXlVS0dUUYM6yNeQhbXdrb1L6QRdXp6CZuPvwV9Pr8Gweb9M9TPYQ26u6mXWja+sehnTqM5LMCi5jP78PnqefzSJjArsfn8sDVL8n7oFQwkwter3m0r1x5svqm8uMbHMNt1mm24DU6IxEybp8nN0+3m6vS72L60kF6YpqWXGjDHG9HHGjDFGjXEszdqjaAzV6sc2cY5mvC7KieE5nbOGsjj+kCHVfx5PaFUvE9SwHVPZ/fHml5aipjbtNP6A6jNR1RrGFtZwTfRq2E5yD8fBz79TYL8DdQ47VEWZ9r6gStNxx+kjmVrPCzr+XtVyo2G6qvcDFMPE7G/agZxafdC4lmUyavUd5keDmfespL8fJIZYsocJrb65dEDdgaRWfcZMLY8M5izXHV+VgdJmplrNuFh6MalUf3x7xHAfElHJ80jyt6i72S+JRapuqGUfrCt1Vb8drXptsfaev5NZmmfpiSv3eEz0BDlG9HHUynvURSonruV+HKIwrjqMqw5PGlOZa2aoR5mMQZbeIMfhpR66gywhIcOaPdkwcJtmsV2z8Bfg+AiFQqefZ0wtUULAHDRxLfsgCGvQPjXcWWoZWy3Xkd1tJyMMUugMKaWaxrIji3Vc1/L8tLvn281/ehKv4LDvWfvt9B69imNYCzVyYZrO3rU8TatOM1l+9fqv7Fcf7jFreMav5bqYNarXjG449XmSoUlamLiJEbJ7GHMtx2wjaMZm0YsyoCjZJZ2yIcusjP7qfsKSS89Zx+zxfSmh0UmCzfUseZ4vCthaGVsrs35aWZMRaiwlSYeXp8PrYH97Pzq8PALBuFFgTB9jzBhn1BhnXB/Dj6FrYMrpYWvHg/NejyTKUGzncmerEPLrn5Z4y1X5PVoWzIWgPICW3BzTyNobzeklkN1iJZKmQPfyKKGOa0qfut1R2mqz/pdPcOglJ6Boew5Adft5nko0973EVX02q6NsntakRxEKnWGabj9HT5BlX7ef44J9SQqDMbXIsBYFGIf1yKPRVtx5ZzP2yIYssdEfphlRyngNYH1UL576yeN0reqlY5/qJyGm0+HnKKsOTpXBRMnOdPpZCmoxludLSe3IgKJkl3R5HYwaY7O/sU0RoWDbf/+ZjhNWYfZ37vG9A6QZwaG0h0yxZsVTA4b17QxPa56gCIWsn6HD76DDyzPoDHCQdSDJMIml2YwZY5TN7RTMUSxjlLJWnLtoFAopt4tSQpYJxEFQGiTR177dsn/54yKuKzjzJdVnCe6IXxrE7Lg/hlFJNKeXctc/6j0MiUQyB0ynDy+xHdT2DTTMxurvPIhmauz9woP2/EYRNWu4L/PY4gxsERGKYESzGdaKPEbF70xAWphRJmMl0HigO0BnmKaseAxr1oyfEc2uqgFMb5BlmwwoxkJ/mGGojT3/nLEyG3+/liMuffq819Xh5xmXSTux0OlnGdXlOV5vZEBRsku6/DxPpdbXexgNi/X3J3DWD7P80hfM+t5BkW7u7MQqEYqgYFgUDIv1qQ2TryeCBB1+ng4vT6+fY0lxBWk/R6D4WOYoBWMUyxijYI5gGeOIXcyCJryo/L0sg93zRgglyqpLtW+G4g/uKXLciQmWDM7/VhiUB9EGfhbDqNocUclQTMgMRYmkGTBlQ5Y9Ejg+T37vIfY6axVGds/liukwgSkMRmuwdGhKFCgqLkV1O+uMqYliXah0B5nImzHI8jRnKT1BFg21EpS0pjIatQLObuyZeoMsTxjy2IyDPpFmqI076a79xRMIIdjrufvNe115P8dYu5zjC0xXkGNUThrUHRlQlOyEHmrkgowsed4D2/77LyT3XUL64BWzvneAFJuV9m16MYGjOQxpWxlKbGVLxRtUFSoZr4Oc20nW62CwuBcHjB6BJnSKxjgFYwzLGKVgjqKrPim3h7I5CovkvdLKhE4vAGqbBm42bfD5658crv1U97zXFfoZhJ9Hb+Py8bhQ/RxKaBLI8kmJpCkwnT5KmTX1HkbDsu7nj+OMltn/ZYfO+t5uP8+4ZhO0cVkpgK+EDOkFhqYHXQTkwxQ9FW/GQb+Tw5zl5MIUllKulEpbbNOiLtNjOHSGaZmhGBP9YZp/Ge17X37qx48x8PTlJLtT815Xh59nbVIm7cRBp5/l4ZS8/9QbGVCU7ESnn6esOpSlt8MucTYMU7j3cZZf8aI5+a4NiDQPqaMLP7AmJFRCCuYIheldmwUkgzQ5r5Os20mH28Mye1/SW59NoHgEqsvS4WMpmdspJbZH2YoywFg1QXkQLbkZpU0fXH783SKJpMJpz5+/OAxKg6jGdhR5zZw3mtNLaI6A9MORSJoCs9zLWPe99R5GQyKE4PG772fghBXk9uqctd1Zl59ju5zM3zUKjGslxrUSTzKVdWiG+mSQsSfIcqS3F92VRl8KCkc7KyuZjBbDmo3XgvZDC40mFHpEqm1Lngvrxhh+YIhnfPC0+a9MQIeXZywnz/N5I6AzkCXPjYAMKEp2osvvkNmJe2DbD+5F60jTefIhs75XFwp9JNuq5HneKFDWi5T1IltTGydf7tPL7LfxeXh6ES006Rs7mKTbhYJC2RyNAoyVIGPJ3E6gNUdnrHoRlAbbtiGLEIIffdvm1OelyGSr79C4I0F5sK1Lx+NEc3rx2zRrViJpNjQ/jRZkcGUTpV2y7R+bGX1smGdefMKc3t/t59k2rZGJZHZc1WeTOsqmHRrAHFFaySp3AEfx2cfr5djy3mREgjG1WAkw2tFv1aKglufdAKaV6REpfELGlPacNH3qp4+jpw2WPWuvea8rWbE1GJdBsHmTCZNoQmVca99S/EZBBhQlO9Hl5RmRHnW7ZfQ3D9B12uGo5uynTx8pXEJGkcGt+RKqPqafZWPPvdipCUNvhYSXI+X2kHK6yZWW0j96KGaQxdUtgsQQbnIrXmIbXmIrvjEmRWOFoDyIkX283sOoCw/f7/Hk4z5vv6YzlvX55fYNzsaN7vRJ/0SJpEkwy334xihC9eo9lIZk3c8eI9WfYclxy+f0/m4/x6OpdQs8qtZHKIIUJuuMEf6UemLy9VRo0FvJZOwNsuzn9tEVpvEIGNZstk74Mqo2w7L0fJK+MM1WtYoGii2EEIKnfvIYK07bBz05/7BJh5/H0mwCJWD+09ntTZefY1wrVtWoSbIwyICiZCe6/DwbE0P1HkbDktpvgOK/Nsz+RiYaspTa8iYcN1qQwAwylKeXRysCxxzHMccZzT45470pt4teL4Pp9JGy9sFwuxGEleDiNtxkFGT0EsNt+TAUdXj+bb2HURd++G2bnj6V409KxrK+oDSI0cbdsuNEK/fitmmgWyJpNkynT2Yn7oHOVb088f2HKG4pkBnM7/G9RqiTC9Oy5DkmeoIsjxlbZrxWUj3WqSOsM6Z0pCoUuoMMvUGW7iDHKncJvWEWU+iMVrIZt6n2ZNm0rbhtp+n7Rft2eN72zy3YGwrs/d6TY1lfh2zIEhudQZYRuS8bAhlQlMxAFSodfo4RXWYo7o6es45hzUe+RWn1ZlL7DezxvQOk2NSmN+G4STndOHphTqXMgeZgpTaTzE039FYx3C4Mpxej3EuqsB8d256OFmTwjNHJLEY9vYEgMYRo4WzGMEgivO62zKrzPMFPv1/krHPS6Pr8v2AhFAJniSx5jgOhoLk9+LJjrETSFJjlXtykPF93x8rnHsA/b/sTT3zvYQ676Ol7fG+Xn6WolnHacIIzdkTU4flPydWzvjVUBNt0i226RSgmql8gKxKVbMYMfWGWp3kDdIYpyorHNtWe7DK9mRLDamtnSfWFaR7Tts/+xhbkqZ88RnogS/+Rg7Gsr8PLMy4nDWKh08/KDs8NggwoSmbQ4WfxlQBbk12Jd0f++AMxenMM/+hell/2wj2+d1Ck+asiZ+/jIOV2UzLnIWiUEC8xjJcYhvy/Jl9W/TSG04vp9GKU+0hY+6E6PaB6BMkhwsQQQXKo8u+toPoxfJr6EpYGUYxRVL39gt1/+t8yI8MhL3hpJpb1hW43CA1NBsHmjep2AhCao3Udh0QimRum00eh88F6D6Nh0dMGe591IE/998Mc/IZjUfZgldMd5GV2YkxkRAJT6AzX6q2mgKU4WKrDU9M6G+tCpSfI0BtGZdMHu4M8K8iio7JdLbFNtdiq2pM/pRYJDveHaX6vt18pfuAGrP3FE+x/zsEoajwZBnk/z4bk5ljW1e50+jnWJOS+bARkQFEygy6/g1F9vGUzs+JA0VS6n380Q9/8PYOvfw5adtdlk4qAJaRlhmJMpJxuSon4Z0hDvYijr8XJrAWgQytCqKE6vWhOP2q5H2PsYBJDp6AESUJzO2FyiCAxFP1ODkGTGXoHbez598Nv2+y3yuDAg41Y1heUB9ESW9q2W3ac6E4fgTksu7ZLJE2AEpgYXieunEzZI/uecwiP3/0AG361muXPW7Xb90UdnmX5Xhz0+FlG1WLsHoi+ErJFL7CFqe/J8zXyIkFfmKUvzDAY5DncG6RTpLAVl62VIOO2SpBxRC0RNpFeTAudLCZb1fZLNNn4+7V4BZe9z9w/lvUpQiHvZxmX5/m8UYRCR5BhRDa3aQhkQFEyg07ZkGVOdJ9xFEPf+C3bf/EP+s7edRlLJwl0FLZRXuTRtSYpt5uxStBvwVEDwtQWwtQ0/x0Bip9FKy9BdfrQykswxg5FdbtBK0NyCyQ3R79Tm6GBsxnbtcNzEAh++4syb7wsj6LEo+iD0lJZ7hwTmtNLIP3YJJKmwHR68XWLUJcaZ0/k9+qi75hlPP7tB/cYUOz2c9yflte/OOgNsgwvVimkAuOKw7jqsJqpbEZDaPSG6SjQGGQ4wltKb5hBRWG7WmSoEmDcptps1WxKSmPqxb4ww6hSxlWCeg9l0dnwv0/ReUAPHXt3xbK+bJBBAJbsSjxv8kGakBCrDQPdjYgMKAKKIlAaNCPC9hNVL6Or1V/09cosXref54n0msn/7wm1hn025qeqXqYUVJ9J1JWqPiswa1TRibkbCqfsy7Yf38uKlx69y1T4vYI820QJ05xZ8hCK6gMZXqhVvYwWVD8za9Zw7Phi4fuUKUIl6XbiJIZRmftxV8sxqu1uGQUwCwizQMDjTO6pUCfjdkB5CZQHYPQI2PQ8CE1IDO8caNQLoEBt/d2q/06DXaRO+uVBzN7f7/JvEHmpVr2dRTgOAFxR/blgVoTwhvUe5ZLgwEOTeLOsx2Nu2/HKg6jpdXhoGFR//nSq1V+rkkr1ZVSFsPoGNJ6oXiJkVKfm7RhuN2Fqw5zWka5hO7XsN1FD6rE6y3k6298ljU0ja8Zq0WrI4NJEtEyy3IuXGEJboOO5lvt3MTSrXmZZqvpJdL3K4Ip/wQq++44/UXx8E92renf6uyIUOv0sRXM7SW3mdapM9RrYDaq/T9aiTcNFKs3ww+r0RVeQY0i1ql6uln2wOzwlYJNWYJNWYPIrFNAhkvRWgowrgg6O9pbSIZIUFGcyizH6KbJdLTKfIdVyndpxjy0RKbaq9p7Px0W6Hio17Azbq/6akNajc3D0yVE6V/Xhz+UZbA6HWtbrYEwv4KOCoKrnmQnMGhIVVL367dRybsd5/uyJtOayxO2hYBRI63N7dq/lWbURNGOz6EUZUJRMIaDTzzMqG7LMiX3POYT1P/8e439/io6j99np70vCNEOqnIWKg4yXQygBbiOWCag+pDdGPxMIwJsWZCwPwuiR4PSAVoLkFoLUJpTkJpTkFkgOoSxSNqMQCmF5ELUNMxTXrI7EwV77xVPuDFHJs9H959jW184o5T5E59/rPQyJRDIHog7Pstx5LhxwyiDZ/hSPffthnv6eZ+3097yfJVQEliYtcuKgL8jykL5l9jcuNgqMKWVGVIfH9KlsRlNo9IUZ+oIMfWGGo71l9IZpFBSG1SJbVZsh1Wao8u/yImYz9oXt2eFZhILCmlFWPCeecmeIPP9kh+d46PDzcl82EDKgKJkkG2RQhEJB+hHMiZ4jBknt3ceWH9y3y4Biv8jwlCqDs3GQ8zopJ0aax6dQAcyx6Cf/6NTroQHlvkqQsZ9w5BhEaaCSzbgNJbUZJVn5SW0GfZyYKnMnEW43CBW1DR8En1rtkUor9A9Wn72xK0RoIJwe1JQ0hZ43oYbidhMmh+o9EolEMgeMcj+l7BP1HkZToOoqR567D3/8z0c56tLjMXMzq4+iyXzpXx4HulDpCFNsa6Lur64SsEEbZ4M21ZRHEdApkvSFGXqDDCuDTo6Zls24dVqAcatqs10pzSubcXf0h2lWG+3X4bm01SYo++RjKneGyFZsiyltDeIg7+fYNp9GnZJYkQFFySSdXgdjxjiiRUp5FhpFUVjyoqN56raf4QyNkejvmPH3JWGa/9M37mZpSTVk3c75dXhuFFRvMptRq8wwCwF4nYjyAKI0gCgtJdx+NLhRNuNEcDEKNG5EmWc2Y1AaRG3TJiJrVnus3NdAjalbX1heEn1HsjPnvFGcXlDdyBJAIpE0NqGG4XbjygmAOXPES/fm9599mCd+9BgHnX/ojL91eh2MSv/yWOgJspQVD1upwsaoAREKjChlRtQyj+rDk+WkiYlsxjBNX5jhGG8pfZVsxm3TAoxbKz6N88lmVIVCj0iztQZrlmansGYEgNzKztjW2eHneDT9ZGzra2fyfo7V6afqPQxJBRlQlEwy2eFZMmd6TzuEtV/4FUM/+gcrLjx58vWU0MmTaMsygYUg63VSzD9W72EsCIoCmKMo5ijkH5l8XYQGorwESgOI8gDhyNEEpbMgNFES21CSm1FTm6LfyU1gzC2bMSwPorZpE5E1q71Yy53D8gBacnPsWaTtiOL0IxJbZYaORNIEGG4PoeoSyAmAOZPtS7Hi1H147J6HWXXeITO8tzv9PGuTG+o4utahN8iwTbVb9l7iKAHrtXHW7yabsS/cdTbj1mml0yNKmXAOySNdIkmIYERpv8ZLhTWjqIZKZjAXy/r0UCMbphk15DVzvmhCIxtkZLfsBkIGFCWTdHodbGhDX7X5oKVM+p5zKEM/+TvLXnUSqhGVUi4J04woZZw27IoWOwJyXgfbWyFDsQoU1UNJr4f0+snXVBGC10FYHkSUBghLSxEjRyOcXtDKqMlNkxmN6oQ/ozbzGAzLA2jpNYv9cRqCpx73OP6Z1TeG2h1BaQA1Kcud40At98lyZ4mkSTDL/XhJOQFQLQe+7Gn8/OIfsuXejQwcvyx6UUSlkP/MPVzfwbUIvWG2qcqd42BGNuO0TtMJodEbZuivZDMe7S2lN0yjTvNmnB5o3LHTdH+YYZtabMvzfHzNCNkVnShaPA0HO/wcJbWMozZ35mwjkPezuIpHuYbmfJKFQQYUJREiCig+mH1k9vdKZrDkhUez5fv3sf13/6L31IOByD9RZifGQyJIYYQJyuZIvYdSd5SKN6Nmju0im7F/KtA4ciR++UwIkniJbajJTaipTWjJTfjF5ejdf6rfh6gTo9sDRreHsWco6p33x7a+dkZx+gmzrZmFLJG0Gma5DzchJwCqpe/IATr26+LRex6aDCimwxSG0GWDgZjoDbI8YEq7IYiyGXf0ZqSSzdhfyWZcHuQ5yhukUySxFJetypQ348qgg220Z3PJwppRcnt1xrY+2ZAlPvJennHpOdtQyICiBIBUmMQQOqOGLHmultTKXvJHrGToB/dNBhQHwgxbZIfnWMh6HRT1AuEidUFuRqJsxg2o6amSqcibMY/qLCEoDRKWB/BHjgavi/Ka1+ClNs4INKrJzSiaV78PscCseSL+Ds9heRAt+bPY1tfOqE4ffu8f6j0MiUQyBwynD6vrH/UeRtOhKAoHvvRp3PupP2JvscgsydLp5RnXLcI29DWOHQE9QabtMhSrQoFRpczoDtmMUafpNL1Bhn6R4Uh/gKVhVO47UMrt0ASmiI3X0gGdwppR9nnR02JbX4efZ1QGFGOhw88xJkvHGwoZUJQAUXZiQQqamul/4dE8/uHvUnxiiPS+/fSLNA8pspNXHOS8TixpVl41UTbjOHpiBL2SzRjYKyk++TrS+36BsDxIUFqKP3oEbun5iCCNYm5HS23ET25ES21CS25ENUdQWqBR05rVHqoKK/aO57YXehmEn0NNbollfW1NkEDxOiIPRYlE0tgIBcPpxZXna03s/fz9+dttf+Hx7z7CEW89dqrDs2TedIQpNFRG2rCJyHyJOk0XWK9OBWMvLh7DL80nCYB+kWZZmONIfwmdIkkRf4eS6SLDSpGgBfSiZzmUh4uxZyg+mVo/+xsls5L3c2yUdkMNhQwoSgDolA1Z5kXXMw7A6Mmy5Qf3ccBlZ9IjUmyRgiYWsm4nBXO03sNoCYLS0ihQmN6Ilt6IwV+BKJtR+FnC0tIo0Fhegjt2OIHTD4qPntyMltqIVgk06slNKFpzeZesWe2xdIVOIhmPH05YHkQxh5tuPzQiitOH0Augl+o9FIlEMgu62wWAL21IasLImOxz1gGs/t6/OPQNR9HpdbCtzTyiF4reMMN2tRg1HBEtnD63CCSFTo4ET2ljOErA40wdo4ZQ6Q3T9Ik0/WGGw/wl9IVpTDS2K6Vp2YxFtio2BcVtqmzGwtpRgPgCiiLKqpMZivHQ4ed5RJcWOY2EDChKACqCZnj2N0p2iapr9J95JJu+9X8c/8YX4Wg+BaTxbhzkvE42ZdYQTxiovQnLA7vs8KwooBgWqvEo5B/FIGrkIkKNwOkjKC8lKA3ijR9CactzEX4HqjmMlozKpfXUxqhsOrGtYbMZn1qgDs+S+aOW+wlltpNE0hSYTh9eYlvUWlZSEwe89Gk89q2HWPfrp+g88rk8nn6y3kNqCXqC9mvIslD0h2nGFGeXzSU9JWSTZrGJaftaQE6Y9IsMfWGa/jDNIX4f3SKFSzCzZFopsk0t4jVoVVxhzSgAuRWdsawvFSYwhCG7EseAGRqkwqT0o2wwZEBRAkQd5h5PP1HvYTQ1/Wcewcav/4HsI2NsOaw9u6LFjRpqpP0sljFKvt6DaQHC0iBGz5/n/H5FDdBTm9FTm6Fr2nr8DEF5ICqZLg9SGjqIoDwAEAUZK1mME/9W9fr7ia5Z7XHyc9OxrS8oDaImdw7OSqpHcfoQssOzRNIUGOW+qMOzpGY69+2i/+hB1v/gSbKHpaV/eUz0Blk26KP1HkZL0Bdm2KpUod0UKCguBVxWa1PZy5pQ6BVp+iqdpg/yezk5zJBCZ1QpzwgyblVtRhWn7s9P42tGSS3JoqfjmYTu9PNYmk3QoAHUZqLDz1FUS3hq63q+NyMyoCjBCEwyoRQ088XsydF14oF0DcOWam7Ckt2S9fJ4qoejyVLI+SIEBOVBEqn5dz9UdRs1uxoju3ra+lVCpxe/PBhlM1oHUN56MqHXjaKPoVeav0RBxo1oiSEUdeeZ74XAKYdsXOvH3+E5/6/Y1tfOKOU+QtktWyJpCkynn2JOXvvmy4EvexqjXx+iEFq48uE4FnqDLP9ISJ+6OOgL0wzF0FwyUARbFLvSqLIyESEggzEZZOwL0xwQ9tArUgSISV/GKMgY/XtXmZILRWHNCLmVnbGtT5Y7x0eHn5OZng2IDCjWSFiTN0f1y1iBWcN2qiPr9GJrNoHmVlVWWss+2FyuPs/MDas/TDvNctXL1EJPaoeb7bkHs7I4yGObH6fnwF0LxFEntQgjq43ajuvqUec4S5fzO7CNUVQ1RFukmb2ghn3gCm1RtmPUIKiSStQdO3C7IDQwEltQ2HOpWlhDgXmgKJAcRk0Oo3Y+wEToTgRJgvISwtIgQXkQd/hEwvIAhAZqcgg1ubnSaXozanITijEWNZTZDXaYqHps254aIwxhcN8UZTG3oKK2h30khEJYHsBIbprxPo/qj4M9bWe3y9RwLmTU6r0e7RpOucecgeoWELDC6UNLbcSo4qHaVKrv+j7bcb8rRA337dnOn1rOL0nzslh60avhPlQ1AsxyH+N9v0Vd4JLnWj6PE1Y/adRfw2R6uYbtAGS0KSucVactZeT+TtZtWEtmxe4tcmo5fvyw+mvMYum/hRpbQujkRZKtik0olJo+j6hhmbCWe0QN26nlfKtlOxO2Nf0iw1P63Jry1TK2Mg7rNId1TGUzqkKhK0xNBhn3Czs5wV9GTiQYV8psrfgzblWLDKk2I0o58svc03b86s/V8TWj9B+3Al9UcazuQS91eB2MaBZ+uAjX6F1Qy/ej1/C8EVazvyqMutU9E6ecTsZquGYnteonbRpBMzaLXpQBRQkdnmzIEhfdhy9ln6F9uPuuHzBw4NH1Hk7Tk3M7KUjj91gIy0tRk4uXFTiBopXRM2sgs2byNSFAuF2VBjADhMVl+NuPJXR6QStHfoyTgcZNqMktKFrtnqRrV0fLrtwvngma0O0BQE3ITu7zRQ3SEGRAllBKJA2P5uVRQhMvIT2354uqqxx+0mE88OcHMA4NMbMLn0DQyvQGGQpKmbJa/WSTZCaKgJ4wxdZFbi4ZKoJhrciwVuSRaa8nhU5vmKbHz9IXpjnGH6Q3TKOiMDwtyDiRzWjj1Vw2HfoB9vpxcud2zf7mOdLpZ1mTkJ7bcdAdZlmvS73YaMiAooQOr4MxY6zew2gJOkQazdD55w/+j45XHkiqP1vvITU1Wa+LjZnVs79RMitBeRCtQTz/FAWUxAhqYgS946HJ10WoE5YHCMsDBKUB/NEjcMvPR/hZFHMbWmoTYWIbSnIzJDeDObfZ87WrPfJdKp3d8cwOB6VBtOQWFOmHM28MpwfM7SBL/iSShkd3+vETw7DIE1Otyl4r9uInX/sp6o9CDnn5QfUeTlPTG2TZpkm7oTjoElHW2IjSGHZDZcVnvTbOGmVmE5gukZzsNr00zHGkv4ROkaSEPxlc3EKJIbXINqWEPwfN5mwaRQQh2b3iCSgqQiEfZGXJcxwI6A4yPCj3ZcMhA4oSOr1O1iXn76smgd4gx4hmIzSFdT94gAPfcEK9h9S8CMi6nVhdo/UeSUsQlAbQ0o3tLaSoPlp6PVp6PdOLVEIvS1geJCwN4peWIcZXgdMPhFEzj+RmlOQWqPwo+sxZ9bWrXfaKKTsRouCsKjs8x4Lh9Ebfm0QiaXiMcj+e7MgeC6pQ6aATf8Dl8W+t5uDzVqHsye9Dskd6wwzbVNnhOQ76wjTb1CKLVAVfGwqMKGVG1DKPsX3yZUOok0HG3jDNoWEv/X6aBDojSpmhii/jkFJkq1LcqQlMaX2UfR2Xh2I+yBASYqmNEZxtZjLCxBC69FBsQGRAsc3RQo2sn2VUZijGQk+QY7thseyMg1j33w+y/2uOQzXq45nR7CSDDKrQsGWzoFgISksxu/9S72HUhGpYqMZjkHsMr+KhKIQKTg+UBxDlJQhrP9h2InhdCH18KriY3IxXdNj7gPjKk8PyAFp6zexvlMyK4fZAQnZ4lkiaAb3cRznT2BNTzULWyxEoAUvO6OXe79zHpr9uYemxVXrQSibpDbLcl1hX72G0BH1hZtHLnePCU0I2aRabiILLQahGCQoY9IcZ+kSK/jDNKtE91QRGKUbdppUiDxfXsbW/i0RPOpbxdPk5xnSr7p2rW4HuIMu4WiSU1UENhwwotjl5P4+jOpTVxWli0ur0+FnWGcPs9ZLDWPu9+9ny2ycYPO2Aeg+rKcm6nRSNcYS8ccwbERiEbg9aqjFKnuNAUcLIdy+5FYWpDsEiSEB5CZSXRIHG7cfx1tefRTKVYPyRrWiVBjBaxZ9RMUb32ARmVwSlAcyeP8X8idoTw+mB/IP1HoZEIpkDhrOEQs999R5GS5D3Ohk3Rhk8Zgmd+3Tw0N2PyIBijUSefxm2ygzFWOgLM6zRRus9jPhQwMLD0kZ5gtHJl1Wh0C2S9Is0fWGafcNOjjn8uVxx53nYI2VGtAIjujX5e0yzZ20CsyOdfpYRmVEXC91Bhu3S1qAhkQHFNqfT64z8E+XMSSz0BDn+lnqK3L49dB+xlDXf/acMKNZIzu2iYMiGLHEQOAMoWgmlDZovKZoDmbWQWYsCbN3o8sYL/sUnvngoRx61L0G50m165ChCpw9UtxJg3IyWjIKMWmozirbrSZbJ4GyD+FE2NaISUJQNWSSShkf1U2h+VpY8x0Te62DcGENRFA4+dxV/vOEv2ENFMv3xZEa1E11hGoFgTJaVxkJfmOZeo/WtsEJFsE0psY0SaFGp8wMf/jLLVvVz6pUvoMvP0hVkOai8kq4giyZUxjS7EmS0GNELjGgWtlre7XN0Z5BjkyGbWMVBd5CVAcUGRQYU2xzZkCU+kqFBRiTYrkUzpHu95HD+dt1PKDwxTG7fnjqPrvnIep2MygeXWAhKg2ipjVVn4rUC659wAFi6TwGj42GMjocn/yZCjcBZQlgaICgP4o0fQnnL6Qi/A8UYqQQXKxmNyU2oya3TgrNyxnm+aF4eRaggu2VLJA2PXu7HN0YRmlvvobQEea+T9emnADjgrH3586338ch3H+WYtxxZ13E1I71hlmHNbmzPvybBFBodIsk2tf0CN0IIyuuG0Z+9ki3GCFumJzUIyIapySBjt59jP2eQfJDGVwJGK1mMo3oh+tEsPNWn08/xcOqpun2mVqI7yLDGkHqxEZEBxTan0+vk0eyj9R5GS9AT5BhTi3hK1P1wybP2JdGdZs137+fQt59S38E1IVm3k/W5x+o9jJagnZuIbFjtYJgKA8uNnf6mqAF6aiOkZs7Eh36aoDxAWIqyGZ1tzyQoD4JQUXQLCHG2nlLJaNyMYoy1ZbB2vhhuD545giltDSSShsdw+vGT0u80FsRUhiKAmTU54Kx9eeQ7j3HUGw5H1dU6D7C56A1kuXNc9IUZCopDSfHrPZRFxxuxCWyH7F6dO/9RAUsrYWkl1jGV7KAJlY4gQ0+QocvPscJZwuHF/UiFSWy1RCZMsdztJxmajOoW45qNqLJsWhLZGnRVSp5l8KrxkN9JG6MIhZyXkxmKMdEbZBnWprKWVENjxYsO4clv/p1Vbz0RIxNfl9lWRwsNUkEWyxit91BagqA0iNl9b72HURfWP+GwfB8DTZt7xE/Vi6jZJyD7xORrQiiEbjelDS9GBBmC4nLc7ccROr0oWhk1uXnqp5LVqGjOQnyklsFwevESw8gro0TS+OjlfjzZQCkWUkEaTWgUpjWdO/jcVTx8z6M89eu17Pucves3uCakL8jyhCwrjYX+MM3WNsxOBCivq3R43qtrzssESsh2vcC4McaT015PhAZ7lwc5ongAhtB4WmlvOv0sCirjmsWoHpVMj2pRRmNRdaT92B7IhykAxtQSsuav8ZABxTYm5+cIlRBbswE5Gzpfevwcw9rMGdIVLzyU1V+5l40/e4S9zjm8TiNrPrJuJ45WxJMBmXkjBITlwbb1/Fu/2mGv/eYfslIUgZYYBmFgdv+ZRM+fARChTlBeQlAexC8P4o8dSrjlOQg/j2JsR01tRpsMNkZl04rMyAMi/0QvIR8CJZJmwCj3U+qQDZTioMPrpGCMz8hU6t6/i4Gj+nno7n/JgGKV9IZZ/k9dU+9htATN3OF5vpTWb0fRVDLL8vNel6N6kUejPsafcpXrpoBsmKbLz9Lp5+jxOtivvIxckMFT/EqpdIHRidLpStm0JPJPHNWKMruzQZEBxTZmRkMWeX7Om54gx2OJmWWlqf4s/Sfty5rv3s/KlxyGIusi50TW66QgsxNjQXgdiCCJltxS76HUhfWrHY48f/7iEKLgbFAaJDnw48nXFNVHT2+IfqZNL4d+hrA0QFgeICwP4m57JmF5AISKmtg6mcloJCe6Tbdf2bTh9FDM/6vew5BIJLOgBAaa1ylLnmNiernzdA4+dxW/fN9v2b56lO79Ohd/YE1IKjTICJNh2awhFvrCDPe1QUOWXVFau43E0i5UXYtlfZ1+jtHpftsKWFoRSyuyblq2tyZUOvwsnUGOTj8blU3b+5MSCSy1NCPQOKIX2rJsWnZ4bmxkQLGNkQ1Z4kMTKh1heqcMRYC9zjmMP1/1Xbb/YyM9Ry6rw+iaj5zbiWWO1nsYLUFQHkRNbEVpw1lOuxCwfchn5X47+yfWgvBziCA7p+CsqtuoudWQWz21vFAQbnfkz1geICwuo7T9mEq3aWdaA5hKE5jUZtTddJtueoSK4XbhmTJDUSJpdHSnj1C3CfUisqJl/uS9Trbtonx871NXkupO8vA9/+Kkdz29DiNrPvrCLKNKadK/XDIPBPSG6bbNUCyv205qRXds6+vyszyeWj/r+wIlZLsxzvZpFggQlU13+rnoJ8iyqrQXnX4WFZVxzZ7RAGZUL+yx23Sz0x1k2aqPz/5GSV1QhBDtFeKexvj4OB0dHfxh7W/I5rNVLRuI6gVVo+3pLX/fTGYgS3YgSy1XILWG2ZGwhhZsulq9SPDD6r+fQNQ+I+WOlxl+aDMDT99rpyxEIQQvf8ZL2P/gA/jof36ypvUHNey3Wr6fWu5DWg3lm4lZgltr/7qFruU5ckvSk68ZNQTEjBoEpkb1n6eWfV0Leg2fZ9OTJexCyEGHp+a8TC2fJqzh6AlruI5Ww9/ufZizTrmYn//uDo446sCqlhW7+Dyjwz5PPFzi6Gfm4hoiGiFhICjaIbYV/RQrv11HkEgqpDMqmZxKJquSzqqkMhqquvCq0a8hcDDXa3zRCnjoLwWOOaUDoVR/7a3lPA1q+DxqDduZjcK4zaqlL2BsbIx8Pp7sWcnCU6tmbAW9WNgwTmmkTP+h/Ui9OD+9CLD5z2voOrCfROfO9+U7PnIrd332q/zwgZ+TyWVqWn87acaRtQVK4y5LD53prCY1Y/WasVwM+McfLJ5xWrYqjdEqmvHYp53POS8/nQ988I1VL7ujZhRC8OdfFzjkmAzZfDwZjwCqCCiXxKROjH4CSkWBpkEmE+nESDNqpLMqurE4k0ALqRn/+YdxVh6YorPXIKxhO82qGZtFL8oMxTZFCIFru3RlpR1+HHi2i5FJ7LKkWVEUzn3D+dz4/k/yyD8e4qAjDq7DCJsHEQpc2yORjSerrN2xCyGZXHtmlDz26FoA9jtgRSzrK1oB6Wx8wnACVVPI5rWdRKfnikqAMcC2Qjau8yhaIWEIqXRFNGZV0lmNTE4lkVSaxlahZAWkMhqKokjHDYmkwXEtFzMj78lxEHgBgRNg7EZ/v/R15/L/bvoCX7ntS7zl6kua5ppeLxzLlXoxJoqFkHRWXZQJy0ajaJfYsG4LBxy4Mpb1uY4gCCCdiVd/K4pCKq2QSqv09E+9HgaCYjHELkST0tu3Bqx70sN1BGZCmZyQzmQ10jmVdKZ5vucwEJRLIakF0N+SeJABxTbFL/uIUGCk5U04DlzL2a04BHjBK17M97/2Xd7w/Ndwyb9fzgUXvwZVbc8gz2x4JR9QMNLy8hQHthXSP9ie5/lD969m6fJ+stm5Z2fuCbsithcLw1To7Nbo7J4SUUIIymWmAo2FkK2bfUrFEFWF9ESAMTsVcDTMxrvWLFRwViKRxI9ruXSs7Kj3MFoCz3LREvpufdqWLBvg1ZdeyOc/8Vkef/Ax3nfTB+jsmXvX2XbDsTyy/enZ3yiZFdsKyCyixmkkHn7wCQD2jymgWCwEpNIqqrY4QTtVU8jmNLK5HSamPTFV/VII2bTepWiHBEE0MT1dK6azGslU401Ml4shmgpmorHGJZlCPrG3Ka7lYmRMlCaZnWh0PNslu3T3Yjubz/LFn36FOz7yaW6+5lP84ee/4wO3foglywYWcZTNgWN5mBm94W5ozUgYCEp2e2Yorn5sHf/v89/jNW94UWzrLFoBXX2J2NZXC4qikEwpJFMqPX1Tt/AwjL7riZLpkWGfDWtCnLLAMHeYna78W1skobsrSlZAvltKEImk0RGhwCt6mLKiJRY8e88T0ACXXnMFhx5zGP9x5bW88lnn8oHbPsQJp564SCNsHsJA4BZ9EjJ7NhaKhYDOrvab6AuCgOvedwd77bOUgw/bL5Z12tbiTkDvDsNQ6OjS6Zg2JyGEwClPlE0HFK2QbVt8SnaIokZZlRNacUI7mon6fZaiFZDKavK5sIGRar5N8SxXisOYEELg21GAdk+YCZMrrnsHJ57+TK695H1ccPK5vPfGazj9xWcs0kibA8f2SMhjMxZKdoimt9+sXhAEXHXxxxgY7OHd11TvhbMrRCVg16iz96qqkMlpZHaYnfb9maJxyyaPohXge5BMKTtlM6bS6qJMNJXskCUr2+/BRSJpNjzbRVEVtKR8ZIgDbw56EeCUF5zGocccxnWXvZ/Lzr2I899yAZd94CoSyfpOajUSbtFD1RT0pLyXxEHRClm6ov2Cs5+7/R7u/dODfPsnN5NMJoD5N/hp5CqM6RPT3TtOTBejSemiFTI2ErBxnYtTEhiGMjkZPZHNmM6q6Poi6MVKQFHSuEh10Ka4lkuqR5YIxIFf8gDQ51g+ftzJT+drv72H69/xId79+nfywleezTs/+u6azbdbDcfyyPQk6z2MliAqX2m/Wb07b72be//vQb7z05tJZ1LEIQ5LpchoOZluzIDi7tB1hXynRr5zZtn0lD9jFGwc2eZTtEOEiGan0zmVVFYnlVFJ5zTMRHxlMIEvcEoh6YwUiBJJo+NWJqDb7T6yUHiWQ6p3bnqvd6CPm++6nW9+7ut8+robufe3f+ZDn72eAw6prslYq+JYkd+2PDbnj1+5L7dbRctj/1rD9dd+jjdd8jJOOOnw2NZbtEJ6lzRXcFZVFTJZjcwOwbvAn2gcGE1Mb93iU1zt4rlR48BMNtKJyYwW/U7H689YtAM6uptrX7YbMqDYhgghpB9OjHiWi56pTmx3dHXwkS98gpOe+yw+cfVH+dsf/8p1d3yEI44/cuEG2iQ4lkv3yvi66LYzxULQduLw0UfW8LEPfoG3XHoeTz8xXnGYyqgt8eCiKApmQsFMqHRNa4wphKBcFJOi0RrzGdoYUq5kuqazGqmJkulMZOxdS/fAkh2gGwq62fz7UiJpdVxbljvHhQhD/KKHkZl7lqGqqrzira/i2JOP55q3vofXPeeVvO39V/DKi17d9l7criWPzbgoWQGGqWA2oOfyQuH7Ple89XqWrxzg3R94U2zrnbCgadQMxWrRdIVch0auY+bncd3Il9G2o9+j212KVoAIIZmZymKc0I61Ng4sWQGDK2VmdiPTkAHFQqHAn/70J0qlEgcccABPe9rT6j2kliJwA0IvnNXDRTI3PNuZU/nKjiiKwgtfeTZHPuMYrrnoPbzlBRfyhne8mTe+863oekOemguO7wYEbogpO/bFQtEK6F/SPsdSJA4/yvKVA1wdU6nzBMVC45avxIWiKKQyCqmMCkvAJ3qwCINKGUwhoGgFjG712fikg+tE/ozpnEY6o5KqzFCnMtoe/RlL0g9HEiNSMy4sruWSG8zWexgtgWd7KLqKlqj+XrL/0w7giz/7Krd/+NPc9P5PTnpx9y9dsgAjbQ4cyyU3IKt74qBYCEjnWlvj7MgdN9/FP+77F9/7n0+TTsdXGTXhRZhItbbGMU0Vs0elszIx7aNG/owlQdEKKFkBxULItk0e5WLFnzGrTVa+pDMayay2x8aBgS9wy0KWPDc4Dfmkeeutt3LXXXcRhiHr1q2jo6ODf//3f+dNb4pv9qCd8SwXPaWjau0zC7WQeJZLsqd2QbN87+Xc+YMv8sUbP88XPvFZ/vTLP/DBz3yUFfvG02msmXAtDz2poeny2JwvQgiKhZDM/u1zE779prv4598e5fs//zSpVLyzmUUrJN+GZuUQdQ/cpT+jF4nGSDiGbN3gUrRCAl+QSE3MSquVrEaNZCryZyzaUbanRBIHUjMuHEIIPMuVE9AxMTEBXetkSiKZ4KoPvZMTT38m173t3yMv7huu4bQXPzfmkTY+Qggc26NXTkDHQrFBmogsFo88+ASf/PCXuPiK8zn26YfEuu5oX7bnpKmiKCTTSmQP1D91boahoGyHFc0YMj7ss3mNg1MW6Iayk15MZTQ0XaFoBeimssego6T+NGRA8bjjjuOwww5jn332Qdd1vvGNb3D11VfT2dnJueeeO/m++++/n+9+97uYpsnpp5/O0Ucf3fbp/3PBlQ1ZYkMIgWe75Pbqmv3Ne0DXdd78bxdxwinP4JqL38urTjmPd3703bzogpe01Q1pwg9HMn88R+B7om0E4sMPPMEnP/xFLrnyfI45Pl5xCFG258AKed2cjm4o5Lt08l1TUiIIwXNFNDNdCTSODTuUrAAhIJVR8VxBpkNjdJtHKqOh11gGI5GA1IwLiV/yATDm6BEt2TOeNbeGLLPx9FNO4Gu//RYfffsHufr17+BFF7yEd3zk6rby4vadgNAXmPLYjIWiFdC/rD00juf5XP7W69l732W8830Xxr7+qCGLvLdMR1Ur1Sw7TEx7XmSDM5HRuH2Lx/rVZXxXYCZVNA1UFbZtdqOMxowKctc2HIoQQtR7ELNRLBY544wz0DSN3/zmNwDcc889XHTRRRx44IE4jsOWLVv48Ic/zGtf+9rJ5crlMo7j0NGxa6/A8fFxOjo6+MPa35DNV1fOEYjqj+ZG2dNbHxwikU+QXzF9v1T/MKcq1X+gUFS/HV2tvqGCH1b//QSi+uyjwPXZ/H9rGTxx79gyPu2CzQ3v+zjf/+p3OPWFp/PeGz9Arqv6gGUt308tj/SaEla9TEL1d/n65oe3YyQ1evbZ+Zw1drPMnjCU6o8djeo/Ty37uhb0Kj7P6DaPp/5V5tiTqn/AqOXThDUcPWEN19Fd4Xk+Z51yMZ7r8dPf3UkiMVMUV7PfJhDTPk/gC/7vVwWOPTmLmYhXydRyvImaztTq8WtQbbu7xkdlMNHs9BMPFsnkdTw3pFwMUVWiBjCVWelUxW9nTzPStey3oIbPo9awndkojNusWvoCxsbGyOfzsa+/3Wk0zdjMetEesilsGGfgqMFpr0q9WIteBNj6jw1kBvKkl8TjEy2E4L+/9j0+9Z7r6err5oOf+SiHH3cEQQ37rtk0o7WtxPATY+x1/MAul5Gace7aRwjBvb8a5+DjsnTkqv9Wm00z3nD9l7nho1/iB7+8nSOPOWinv89XMz70tyJdPTqDK+MP0LaLZvTckJIVsOGJMr4nUHUlmpgOIZHWdtKLidSePc6bVTM2i15s2BivEIIwDCf/vf/++7NhwwYAHnjgAS677DJOO+00vvOd7/DLX/6SV7/61VxyySWsW7duch3/8R//wapVq9iyZUtdPkOjIjMU4yMqHzdiLR/P5DK8/5br+NiXbuC+39/LBc86l//79R9iW38jE2UoymMzDtqpfOWWT3yFhx9Yzc13vmenYGIcFCtNRAzZRKRmojIYjVynThjAAUdkOPwZeY49tYODjs3TvyKBbiiMb/d46iGbf/zvKH//3xH+9ddx1v7LZuuGMtaoR+A3SKRF0lBIzbgwuJaLGUNGnWSqoiXO8nFFUXjxq17CV39zN9293bzlBRdy58dux/erD6Y1G7KiJT6csiAMaQsrkgf++Rg3Xv//uPTtF+wymBgHMkNx/himSr7bAEVhYGWCQ47LccwpHRx+Yp7l+6dI5zTKxYCNT5R48I9j/O1XIzz0f2M8+aDF5jUlxra5uOWQJsibawkasuQZopvkxEFw//338/vf/55nPetZAHzpS1/CNE0++MEP0t/fD8Bb3/pWvv71r/Ptb3+bK664gh/96Ef85je/4Xe/+x1LlrSvYfGOhF5A4ATSDycmam3IMhdOe9FzOPSYw7ju0vdzxblv5RUXvYaL//0KEsnW7HQVhgK3KAViXNhtYrB9/z8e46aP/xeXv/PVHHHUqgXZRrEQksm1RofnelOyQ8ykgq5H+3KqDGamHAl8QcmOSmBKls/2LS4lK5gsg0ln1MmZ6XRWJZXWUPfQCEbS2kjNuDB4lkuqN13vYbQEQdlHhAI9Fb9mXL7PCu784Zf44g2f4wufvJM//vIPXHvH9SzfZ0Xs22oUXMsjkZfPMnFQLASkMiqqqlBbvmFz4LoeV7zleg48aG/e/p7XLcg2fC9qIiIDivEQNfGLGuYoikIipWCkdDr7pt4jQkG5FE7qRWvUZ+sGB6cYoulKpBMz0/0ZVenJGDMNG1AMggBN09i4cSPvete70HWdyy67jHK5zI9//GOe//zns2rVKoQQKIqCrut0dXXx5JNPAqBpGtdccw3777//5Ht2hxAKoobygGqp5VnUD6sPCBh7KPlwbBctoWGYO5jrh4uT4l5L6U8Q1FAuVPUStRGZlVcX4FOqKPdYsqyPW++5nW9/7r/41Adu5b7f/pFPfO6DHHjI/rMuW0uKeymoXzDPsz1UVUFPtn4QDECp4SitZpmiFdBbY4fnWo6duEpRZmP6HnAclyve8lEOfNreXHH1a3a7d2q5uk/f10UrIJNVUWfZ/7WUctVyHNTyiWoqH6yhdCOc5UbnWD7pjIY+Y1/tYjsGpDqBTg2YuiZ4bkjRCrGt6PfQeoeSHRD4kEyrUXCxIhrTWXWyEQyAKmr5fqpntlKuxSo/aidaTTM2gl4UQuDaLl37dKJOG4/Ui7XhWpWGLGp1+2+umtEwVN5y9Vs54dQT+MBF7+W1p57L+z72Ds551QvnNBnWbJrRsT3yS9vHM3IhNWPJCqImIjWeDc2iGW+8/ss8+shT/Oh/P4NhGguiGUuWj5lQSJizB2elZtyzZnSdEN8T5LLKDvtqh+1okMhCR1YFpiYZgkBQqjSCsa2Q0W0em9aUccsCw5xqBDP5u9IIZoJG0IzNohcbMqA4IQz/+c9/8opXvIJCocA3vvENjj76aP785z/zxBNP8MEPfnDGMslkkrGxscnZ5+c973mTf5NZJVO4lifLnWPEs93YvHB2h6qqvO6SV3LCycfyb2++hvNOvZC3X/s2XnPR+S1lKO/YHmbWkOdrDEx0U2v1DMWbrv8yj/1rDT/+7WcxzYV7sLGtkP7BhrxdNh1FKyCdq/26ZZgqHd0que6p64QQAtcRk01gilbA6FaPoh1CpRFMOquRrHjupLMqZlJmnLYKUjMuDIETEHohRkZWDcSBZ8fTkGU2Dj/+CL7zu6/wkXffwPve9iF+89Pfc+3N76aru3PBt71YhH6IV/JJyGMzFuxCQLajtfXiP+57hE9/6qtc9e7XcejhByzYdtrJbmihKVohiZQyI8hXDZqmkM1rZPPajKCd74lKI5goq3HbJpeiFQUvE0llclI6mZn4PZG9K9kdDfmEpGkaX/jCF7jyyis58sgj+dnPfsby5csBWLduHY7jcOSRRwJTwq9UKjE0NMTKlSsBZp1hbldcy5UedTERBiF+yVu08vFVhx7A3b/6Ep+69jauf8+N/O/P/sBH77iG/sG+2RduAhzLk+IwJkp21OgikWzda+Df//oIt97wNd7+ngs55LDZM3ZrRQhRyVBsTauBxaZohQysiPc8VxSFRFIhkVTp6p16XQhBuRhOzlAXC5FwnGwEUzH0nl4+bZiy43SzITXjwuBaLkY6Xo/odsazHJJdi1M+nsll+PBt7+fk557IB674KC858VV89I4PcOKpxy/K9hcax/bQDBU90dpBsMWiaIUsaeEOz+WywxVvuZ6DD9ufy975qgXdlm2FZGRAMRaKdpQ5Gze6oZDr1Ml1znx9ogJmouP0lvU+JSsgDCGZmlkyncpqMypg2p2GCygODQ3xb//2b3zrW9/iLW95CzfeeCMwNQM9MjJCNpult7d3xnJPPPEEpVKJAw6IZh2kMNw1ruWS6ZN+OHHg2y6qoaGZi3caJZIJ3nv923n2c0/k3Rdfx9knXsAHb3kvz33RqYs2hoXCsTxy/fLYjINixT8xug62nh9OJA4/yiGH78+l77hgQbflOgLfQ844x4AQoiIQk4uyPUVRoqBhRqO735gs4QnDSqCxIhrHR322rHdxSiGaocz0Z6xkNOqG/P4bEakZFw7ZwC9ePNslt6JzUbf5vJeczhHHHcp7Lv4gb3zJpVx46QVc+f6Lm96LWzZkiY8giO6H86kcaHQ+9ZEv8eTq9fz0d3diGAv7zBYFZ+WxGQfFwuJme05UwHR0R8dIKJTJCpgJvVi0A0a2epTsyC4klY7KpSe6TmfatAKmoQKKTz31FBdccAHDw8PceeedvOpVU7MImhZFqG3bJp/PY9s2HR0dAHiex69//WuWLFnCqlULY8rfCoRBiFf0MHNSIMaBZzl1a25z0ukn8P0/fp1rLv8Il7/6al766hfx3o+9g0y2OQNyQggcy6N3X3kTjgO7xUsuPvEfX2TNkxsXTRwm0wqabPgxb1xHEASQStf32FRVpeKxOHPmO/LbicqmS3ZUNr3xyTKeE/ntTJ+dTlfEY62lOJL5IzXjwuJYLsmOxQn+tzqBGxC6AUZm8QN5A8uW8IXvfpov3/51brjudv7wqz/zic9/iAMP3m/RxxIXjhVZ5EjmT9EK0Q0Fw2zNe9lf//wgd9x0F1df80YOOmTfBd2WEALbCsjkmjtg3ygU7ZDB7vrGLKZXwHT2Tl1zhBA4pXDKaqdSAeMUQ5RKBcwMvdjiFTANFVD85je/yZ/+9CeWLFnCX/7yFzzP49BDD2XZsmX09PRgmiaZTAZN09iwYQNLly4FYM2aNfzwhz/k2c9+Np2dnbJ0ZTd4todqqGimLBGIg8gPp343ja6eTm75yse457++z0fffQP3/v5vfPzzH+SIYw+t25hqxXcCQj/ElCXPsVAsBPQsac19+Zc/PcBnbr6L91z3ZlYdvM+Cby8qX5HXzDgoFgJSKbVhuzFHfjs62fzUawrge1Nl0yU7YHizxzqrXPHbUaPZ6WniMZHRG/YzthJSMy4sruWSX5af/Y2SWfFsBy2po+r1mUxRVZULL30VJzz7uMiL+5TX8Y7rLuXVb315U3pxu7ZHx7JsvYfREkQVLa2ZUVUqOVzx1us54uhVXHzl+Qu+PaccTZqmM813TjUaE3ZDjZocoSgKybRGMq1B/9TrYloFTNEKKEyvgNGVqHHgDnY7rRCXaaiA4qWXXspJJ53Ez372M37961/zla98hbGxMYIg4Ne//jUnn3wyz3ve87juuuv47Gc/y6pVqwiCgGuvvZaxsTHe8IY3ABCG4eTs9FywthYxNRMj3doNIZxK+Uorf8bFxLNcsss76joGRVE497Vnc+xJR3H1mz/Aq854Mxdf/Ube+o4L0fTmCSi5toeRlg/hcVG0Qlbs15g34flQLJa56qLrOerYg7jo8pcvyjbtBhY0zUbRbs7MWd1QyXWq5DpnSqbIb2cqo3HLeoeSFRAEkEhPBRknjL0TaWnsHSf10ozlcYd0Ol234NBiEHgBgRPILLCY8Kz6TkBPcNBhB3L3r77EDdfexkfffQO//Z8/8OHbr6F/oHf2hRuEiYoW6bkdD0VrYXzqGoHrr/s8G9Zu5ou//zy6vvAhj6IVkpL3+VhwygIRRk31monpFTA9014PAkF5ohGMHUQdp58KcB2BbiqTQcbJ31kNvYkqYBoqoJhOpznppJM46aSTJl8rFovce++9HHbYYQCsWLGCT33qU7znPe/hxBNPJJ1Os2bNGm655RZOP/10gKqEIUBhk0V5owOAmTEwcyaJrImZNTEzRssYbko/nPgQQuAVF6dj31zYe7+VfOWnn+OOj3+B26//PL//xZ+4/rPXsWKf5fUe2pyQfjjx4TohnitaUiBef93n2bh+iC998yOLIg4hEog9fQ11q2xaou6HrXNcTvntTL0mhMBxiPx27MhzZ3TYo2wFCAHJtEqoOPUbdAtRL8247V/bKay2MVJ6pBMnNaOBZrTG8e1aLnpSb5nPU298u34WOTuSTCV578fewcnPPZH3XPJBzn7GK/nQp9/H6S9sDi9ur+SDEJhpeV+OA7sQ0r+09fT3n37/Tz5327d4/4cv4oCD9lqUbdpWIBuyxETRCki2UHBW0xQyeZ3MDkn/vi8mg4wlK2BkyGXDEwG+KzASCqJJ9GLDX43T6TQnn3zyjNde/vKXc+ihh/KLX/yCkZERzj33XA4++OCatzF4eD+ZXAav5OMWXBzLxRqycZ8YIQxEFGTMTgsyZg2oUoA2Aq7lkl8uy1fiwC96KICeapybsGHoXP6+t/LM00/gXW++hpc+69W87+Pv5OxXvqDhs1JlQDE+ilZIIqW0nLfbH3/3Dz5/+z1c85GL2f/AlYuyTRFGN3pZ8hwPRSugu8WDs4qiYCYVzKRKxy78dsp2wNBmr44jbG0WQzMuP26QZDI1qRedcYfCxgJ+OUBPaJg5c4ZmVBPNd8zLCeh48SyXVF9jleg+8znP4Ht/+BrXXP5hLnvVuzj3tWdz9Uff3vBe3I7ltVSyRz2ZLCvNtZZXatEucdXF13PsCYfw5redu2jbtQuyw3NcFFvcC34CXVfIdupkd1EBU7IDtm0O6jSy6mg+lVPh4IMPnpcg3BFFUTDTBmbaILskA0QXWr8c4FqRaCxuLzG6ZozAC9HTlZnpaT+NPJMrQoFruSSkQIwFz3bQM41ZPn70CUfw3d9/lf9416d478XX8Zuf/p4P3PhuOrvrW569JxzLIz/Q2CK2WSgWAjK5xr0W1YJtFbnq4o9x3AmH8qZLXrZo2y0VQxQFkunGO8+bDRGKpi15joPpfjtaIlXv4bQdcWtG3dTQe1Kke6a+y8ALcC1vUjPaW2y8ko9qqJNBxokfPak3pH6YIAooykm+OAiDEL/kYWTrX/K8I929XXz6q5/g7v/3Pa5/zw38+Xf38fHPf4jDjzmk3kPbLbIhS3y4ZUHgt57n34evuZPNm4b56rc/XnUG+nwoWiF9A/LYjINWLsWfC4apYpgqitYcwf6mDSguBoqiYKR0jJROpm8q2OE7AWXLjUTjuENhQ4HACdCSGolsAiNrTP7WG2Rm2it6KIqCnmqM8TQ7nuU2pDicIJvP8tHPXMvJZ5zEdVd+lHNOuoCPfuZaTnj2cfUe2k6EQYhX8mWwOyZascPzf7z/Toa2bOfr311ccTixLxv5wb9ZKJdCFKKSX4mkFdEMjVSXRqpr6gEgDELKlSCja7mMrR2LGuRp6gytmMgm0NONE2R0LZdMf6bew2gJ/KKLqquoDWq8rygKL7/wJRz3rGO4+k3v51XPfSNve8+bedNVr1s0a5FqcG2PVFfj6u9momgFpDKN2yitFn736/v4z89+hw99/DL23X85YpG2G4aCUjEkk5MaJw6KVkhvizaXbEUa707RBOgJjXQiTbpnKsgYzUxHgtEtRDPTfslHMzWMrFH3mWlXNmSJFc92SfU2vtg+86XP5cjjD+O9F13HG158CR/9zLWc/coX1HtYM3AsD81Q0Ux5E46DYiGgu691xPZvf/VXvvS57/LhT17OPvstnjiE9im5WAxsKySVkcFZSXuhairJjiTJjqkgowgFru1OasbChgLb7e0AmFlzpmbMmIte2hkGIV7RlyXPMeFZLno20fDXvr33W8lXfvYFbr/+c9z6kTu5/76HuO3rn6r3sHbCsTw6lzdW+Xiz0moT0FahyFWXfIxnPPMI3nDROYu67aIdoqqQSDb2ed4MhKGgZLeW53arIwOKMRHNTKdIdU2Vv4R+OCUaCy5jw2N4xamZ6elBxoXuMC39cOJDCIFvORh7d9V7KHNicPkAX/j+bZxz0gX89Q9/a7iAomtH5SuNLrabgcmbcIuUPBfGba665OOcdPJRXPiWlyz69m0rpKOrNfZlvWn38hWJZAJFVUjkEiRyUxM/UaM3b8ak9MjqEUQoMDLGThY7qrZwQQDX8lANFa1BM+qaDc9unAZ+s2EYOle8/2I0XeO/7vh6vYezE4EX4juBrGiJiVazyLnuvXewfXiMb/3wRlR1cQOlRVnREhvlit1QIiX3ZbMgA4qApoRoSljVMkLMfqHSdIVUR4JUx4RoVAhDgTdtZtraUMC1I4P2iQ7TM2amqxwXQCh2PgEdyyXTn93l3wAE1Z+0wW7WtSdEDcvUgqpUn8c01yUCNyD0Q/R0bd+PXsPYwjkcbztiqv7UfzTQNJVkwsBQdm/w6irVC4tajp3pe6BseSQyxoJkntU2tlqO0epHry7AMqVigKJCOgXKoubyQUD1x2hS2XNzig+973ZGR8b59E9vIKEJIMAR1d+2XFH9cW0qAXYhYOmKuZdc1LLPa7si1nDs1HDdUWoYnbqba3zZCsh1aOjsfM2s7Uit4WGhhp0d1HDtne0aUts1RtIoVKsZ56IXFQUSGYNExoAlGUCp+Hj7k3qxPFxibM0YoRdi7MLHW6mhEdfu9KKZNRGoiF2cnFIvVnfN8iyHzNI8AlCbRDMmDBXT3LNehMXXjGXLRU9oqEYtCmou22kvzVi0QvoHjZrWPV/i1oy/+vm9fOWL/80nbr6S/fddAkTH7mJpRttyqm7gJzXjrjVj2fLJZFUMRbCrsbeTZmwWvSgDiouMOtvMtOViD9mMPDFKGIQYaQMjm6iUwZgYGRNVr+5gFSJqyNK1r5zRiwPPctDTBoqmwi4ejhsVz/UwzMY75V3LI7+08cvHm4FipcNcK8yQ/uJnf+a/vvhDPnnLlazca2DRt+/7AqcsSEs/nFiwrZCBZdIPRyKZK5GPt4GRMsj0Td0jfWcqyDi9w7SW0GboRTNroppa1feDqKKldWwz6okQAt920TPNtT8918cwG+967cqGLLERBFFFSyt4/o2NWlxxySd59qlHc+EbX1iXMRQLAV19jfeM1Yy0Wil+OyCP/AZAURTMTJSRyJLotYmZ6Qkz7/JIifF1Y4RugJ7So+BiNoGZiYTjnkpT/LJfKZuRAcU48JpQHAK4joeZaKxjQAiBY3skpECMhegm3PzlK2OjFle+7VOcctoxvO4NdRKHVohhKpjS23PeBIGgVBRSIEokMaAndPSEvpOPd6ng4dkunuVS3GrjF6PS5Si4mKjoxtl9vF3LJb+iYzE+SssTlDwEoKebS+O4rotpNpZeBCK9mGmufdmolOwQXQcz0fwT0O9/9x2Mj9vcfMc76zahblshy/eRGicOitJuqOmQAcUGZWJmWkmaM5p/BG40M+1ZLl7Bwd5UIChPNH+JxGKiIh61RDQz7Vlu5NG4yMberYpvuRi55gsoep6HYTSWEPPLASIUmE0mthuVYiGgq7f5L+vve9dtWFapruKwaAVkZAAsFkp2iKZDogUeXCSSRkQzNJJdOsnpPt5BOBlg9CyXwroxPNtFURWMzPRy6cSkRhQVWx7puR0Pnu1ipJuvIWIjV7RkViZnf6NkVuxCNAHdbMfmjvz0x3/ka//1E266/R0sX7GkLmPwvRDXES0xod8I2FZYld2QpP403t1Cskc0UyfVrZPqnpqZDv0Qz3JxLQfPchnbVoyav+jRzLQIQlRNxSu66CnZ/GK+eLZDejBX72FUTZSh2FgXaMfyMDMy2B0XthWyrMlnSH/yoz/wja/+jFvu+DeWLe+v2zhkyUV82FbrlOJLJM2Cqqkk8kkS+Zkdpr2ih1fRi/ZmixF7ezSxlzHREtEDceAGaKa2oM1f2oGow3PzBWcbsqIljCpaZMlzPNhW0PTlziPbx3n7pTfynDOO51WvPbNu4yhaIWZCwTCkxpkvQSAol2RFS7MhA4otgKqrJDqTJDoj0ahSmZkuelGAcc0oKLD5vk0AUfnLtNlpI2PW6vLadoR+SFD2m7Lk2fO8hvPEcSxXlq/EhOdGM6TVmkI3EtuHxyJx+Lyn88rXPK+uY7ELIUuWymMzDiYCihKJpL4oqjKp/SDSi9Obv9ibCyiqwraHhgi9ED01s8O0kTWhSh/vdsa3HRLTEgCahaiipbEeEd2iX6neaqxxNSvFQkjvQHPvy/e881bKZYcbb3t7XScsS7KiJTaKVohugGnKwEQz0dxXEsluUTV1svnL6JpR+g7qw8wnJoOMk81fnhxBBFHH4siPseKzk0lU3fylHfBtB9XU9uhZ2ai4jofZYAFF1/JIdTZfcLYRsa2QRFJBb+IZ0ve88zYcx627OBRCULQC0rIxQSzYVkhPX/NdMyWSdmB68xdnrIyeMujar5vADSb14kTzl8Dxo+YvmcSkl7eRmbLYkczEs1yyK7vqPYyqacQMRbeSnSiPs/kjhMC2QvbKNe99+Yff/x3fuusX3P65dzO4tK+uYylaAekm3peNhG3LipZmRAYUW5zA9QndACNrzmj+kpnW/CUo+5QtH89yKI+WKKwfJXQDtKQ+rfFLotL8pb0PGc9ym7K5jRAC13EbMEPRo2N5tt7DaAmKheYu0f3B937LPd/8Bbd//t0MDvbWdSyeI/B9mnp/NhK2FbJi7+a7bkok7YZnuWQGsiiKMtn8JTWt+UvoBZQtP7LYsV1K2yrNX3S1Elyc0ovtbrETuD6hF6A3oWb0XA+zwfS+Y7mygV9MuI7A95q3rHR42xjvvPxGnv+CEznvlc+p93AoWQFd0vMvFuxC2NSVVu1KY90tJLHjWi56St+tD46iKOgpg1QysUPzlwDPdipm3g7FIQu/5KEa2uSstF4RjtosHQNbCc920ZswaykIAoQQDeWhGHghvhNIgRgTkR9Oc96Et20d5Z2X38RZLzqJ815Rf3FYtAKSaQVNa4/r2kLie6JSit+cDy4SSbsghMC1Xbr2oHFUQyPRaZDonGr+IoIQr+hOenlbGyvNXwA9EzV90TMmejaBkTFQ1Pa4FniWi5YymtKH0nU9jAbr8uxYHtne1OxvlMxK0QqbWuO86+234AcBn7rlqro/f05UtGSa8NmwESnaIT39MjzVbMhvrMVxrdq69WmmhmamSXbt0PzFdicDjdbIKP5kx8AE+mT5i4meNluy0YZnOWRXdNZ7GFXjOh5AQ3V5dm0PPaGhGc0ZBGs07EJIV0/zXdKFELzrqpsJRcgnb76y7uIQJvxw5HEZB7YdYpoKhvTDkUgaGr/sI0KBka5OJyiaiplLYuaSTExLCyHwi96kXixttfCe2h5Z7KQiL0a9Yq9jZE1UvfWut77dnBUtEAUUG9Eix9w7X+9htAR2oXk1znfv+TXfu+fX3Pml97FkoLvew8Eth4gQUpnmmzhoROxCyMp95b5sNprv6VNSFa7lksjFM2ui6iqJjiSJjqj5S0jUdc0vulGg0XIobS4wbjuIUKCnZ3oy6hkTRWvOGxhMfVajCWehPDcKKDZShqJjuZiyIUssiFBQssOm9HD57j2/5vvf+V8+/+X307+k/uIQqMw2S0ETB3YhbPpOkhJJO+BaLmYmnslgRVGi8ueMCf0VvSgEgePjW9HEtDtaxt4wRuhULHYmsxgj7agYzV394llO1MSmCfFcl2y2cZrJ+E5A4IWyiV9M2FZz3peHtmznXVfdzIvPOZlzzj213sMBJrI9VdQWTKJZbDxX4LqCjAzONh0yoNjieJZLdiC3YOtXVKUSNEzAkmg7E76MXsVjx9lexFo7SugFaEkjmpnOJCbLppvFl9EvRdmYWrI5xjsdtxJQbCQPRcfyZLlzTJRKIQCpdHMJmi2bI3F49kufzUtedkq9hzNJyQroW9KcD4KNRtEOSUtxKJE0PAsdAFMUBT1poCcNktMsdkIvmNSLnuVSnrTYUSOtOFEBk0mgNZEvo2e7pJYsnP5eSFzXbyy9aHsYKV02i4yJohXSu6Rxvt+5IITgnVfchKqofPzGKxrmOlCyAlJNmu3ZaNh28zeXbFeaLzIimTOhH+KX/ZpKnufDhC+jnjJITWu8Fbg+nuXhWQ6+7VDaUiAoR76M02el9Uxj+jJ6lhtlWTbYuObCZIZiA3niuJZHemWy3sNoCexKQ5ZmOjYjcXgjuqbx8RuvqPdwJgkr2Z7NWg7UaNhWwJLB5npwkUjaEddyZzRgWSxUQyPRlSYx3WInCPEsD9+OAo3FDWN4xSlfxolJaSNjRrqswXwZwyAkKHlNm6HoOm5DVbRE9k2NM55mZlLjNFmG4ne++T/86L9/zxe/+gF6+zrrPZxJilZAWurFWChagZyAblJkQBHQlBBNCataRlVE1dtRqH4ZVVR/kfLDaBnXciteiLOvo7pPHyFEdcEL1TBIdBkzRaMf4hcjjx3fdrDWjeAXo0zAiZlpI2NEgcYqfBlrCauosxwDge1gZswZx4pWw3GgKUHsY9sVwbTvp1TxUNQMY8brO2LUMDavhmOUUODaHsmsMefvqpbvtJZzrhZq2Y5S0zVk1xStKAC2q7+rNYwtqGFvpxS3qvf/72/+xo9/8AdefM7J6FX4Z9XyefQqjutiKUBRIJ8Oq/6OFiucW/1ZWhvzPa6FENhWSDa352tYKKoXkEENy9SCqOFbDWe5N872d0ljU61mbAa9KITAtVw69uqcdZnF0IuKqmHmNcz81KTjhC9jFGR0KG+1KDzlIPwQPW1WGgVW78u4EHrRL5ZRDRXDVFCaUDN6ro8+i16ExdOMjuWRzMxdL4LUjNF2dqZkh6gqJJNK02hGIQTXvusWlgz0cOCqlVVtZ6E1Y8kKWDKoY9ZwLkjNOPO4Lloh2Zwy6/WrnTRjs+hFGVBsYdwm8G9RdRUzn8LMT+sYWPEqnJiZLg1ZjD+5HRFGojHy5ZkqgVmsEgjPckn3Z2Z/YwPiuT4AZqIxjge35IOiYKTkJSgO7ELQdA1ZjjzqAF71ujO5++s/55c/fyWvff0LuOjSl7F0Wd/sCy8gttV82Z6NiuuC7yH9cCSSBidwA0IvbOgmItN9GVNMWeyEjo9nR5rRHStT3DhO4PhoCb0SZExM6kY1oS3Ktd2zXIxsc1a0ALiui9EgehGiipZcf+N4OjYzka/x4pwHcaEoCu/+99dxw8e/xknHvpEzzjyBy646nxNOPKyunyMMBaViWPHcXpxgdCtjWyGDy5vrWUYSIb+1FsarscNzvZnuy5gimvGYMPOeyGR0RktYG0YJ3QAtoU/zZYxEoxKzaBRC4NouHdmu2Na5mLhONBNoGI1xyjuWRyLTPF5IjU7RClm2V3MFbfIdWW6+/Z285/2v53N3fIcvfv773Hn7t3nZy0/j0ivP52mH7FOXcRULoSxfiQnbCkmmFDRdnucSSSPjWS562kDVmus+oigKWtJASxrQk5nMkAm9YLJZoG+7lLdZ+EUPRVd3mpQ2F0CLeFbzdniGaBLaNBqjxDgMBW7Rl57bMdGsTefe+JazefWFL+Ceu37BrTd/kxedcRXHHPc0LrvqfM584YlodWj6WbRDNA3MpIIMKM6PiYqWZjw2JTKg2NK4tktHb2vM6E0382aamXfgBfgTZt6VEhi/5KHq6owO00bWRJ+HmXfgBAg/xGjSDnOeN9HluTEErvTDiQ/fEzhlQaYJOzwDDAz28P4Pvokr/+0C/uuLP+Qzt97DXV/7H55zxvFcetX5nPSsIxY18GxbAZ1Nlu3ZqETlzlIcSiSNzkSH51ZBNTQSnSkSndOqX4IQr+jiV5q/FDeN49suQlDx8DYnvbyNjDmv4Kpru+SW5eP4KHUhylBsDI3m2R6qrqAnmlPjNBp2IaRnSXNqHNM0eOVrns/5rzqDn//sz9x60ze58IJr2Xf/ZVxy+Xmcf8EZpFKJRRvPxAS0TI6YP44j8H1IZ+S+bEaa84oimRURhni215QZitWgGRraDmbeIggJiu7k7LS1cQzfjjL09Eq5jDnNzHsuotGzo9n7RjP+niuuMxFQbAyB6Fgemd7U7G+UzIptBZgJBaPJu6Llcmkuufw83nzxOXzn7l/x6Rvv4iVnviBR14AAAE4VSURBVIOjjlnFpVeezwvPfuaizEAXrZClTZbt2ajYhVCKQ4mkCXAtl0R+8R7E64GiqZi5JGZupi9jWPamOkxvL1JYO0roBegpY0aA0ciaaObsj01CCDy7eRuyQNTIr1EyFF3LJdHE5eONhm2FrNyvuYOzqqpyxvNP4Iznn8Bf//Iwt950F/92xc1c/8Ev8eZLzuENb34xXd0LH9C3mzTbsxGxLUEqraBp8jxvRmRAsUVx7ShLT0u031esaCpmPrmzmXfJw7OiTMbSNpvxNdsJvTASjdlILJqTonHmzbZZy8cnmOjybDSIQHQsj+69m3f2vpGwC61VImAYOi+/4Lmc98rn8Mv/+QufvvEu3viaD7LPvku5+LJzedmrziKdXpju4JPZntIPJxZsS9Dd29wPLhJJO+BaLrmluXoPY9FRFAUjbWKkTZhm3xu4/qRe9CwHe0uBoOShGlqkFbNTGY16Sp8R7PJLXtSNOtUYeqsWXNdrmAxF13ZJNGl1UKPhOiGeK0i3kGY85rin8cWvXsvqx9dzx6e/xY0f/yq3fOrrvOq1Z3LRZecyuHLZgm27aIV097Xfc/ZCIMudmxt5FrQozW4IHTczRCNZoDIz7U757HgFh+KmAn7ZRzW1yeCikTUpj5VJdi1MEGMxcN3GKXkO3IDAC6VAjAnbCpu23HlPKIrC6Wccz+lnHM/f7vsXt970Td79jlu5/j/+H2946zlc+JaX0NPbGes2i3aAYSoYpsri9cVrTaQfjkTSHIReQOD4TZ1RFzeaqaN16yS7p6pfQj8qmY58GR0K68bwbDfSl5Pl0iah66On9abW357rYZiNodFcy6NjoDXsm+rNhK+x3oK+xvvtv5xP3nwlV7/vdXz+s9/lP+/8Hl+483u8+KWncvGVr+CwIw6IfZtFK2TFPlLjxEGUHNF6x2W7IAOKLYrb5Bl1i4GiKGgJHS0RiUal0qY+9MOKJ6OLa7mU141FM9XjDuXhUqVkOhKOiYzeFCbmUxmK9T/lXcvFSGqL1p271SlaAUtXtva5ftTRq/jCl9/PU09u5LZb7uHWG7/OrTd+nVe+5kzeetnL2WufpbFsp9WyPetJuSQQAlJpKRAlkkbGtVy0hIZmtN7EVJyoukoinySRT07qRSEEfjGqfnFtl9JWG2fcgVCw+d4NM/SikTHREs1xf3EdD7MBAopCiErJc0e9h9ISTHR4bmX6+rt4z/tfz+VvfwVf+/JPuP3T3+KMk97MyacewyVXvZKTTz0mlmC/5wpcR8gmfjFhWyE9ffW/5khqoznubJKqcS1HBhRrRNVVEh1JskvzdB/YS9/hSwDoObSfzGAORVMobrXZdv8W1v1uHRv/spFtD29jbN0YpZESgdd4mU2uG3lINkKGotsG3p6LhRCirYJge++zlI/ccCX3PnwXl171Sr53z6848YhX89bXXsff73tk3usvWiFp2UQkFmwr8k9UVRlQlEgaGdd2MbOt7Z+4UCiKgpExSS/J0rlvN32HD2DmTPJ7ddKxTxdG2sAtOIw8NsymP61j/R/XM3T/ECNPjmBvtfFKHkI0lr1GEASEYdgQGYq+EyBCgSkrWmLBtoKWKnfeE5lMijdffA5/+MdXuOOL72dkpMArXvxOzjjpzXz7mz/H8/x5rb9oBZhJBb3J/csbASEERVvIJn5NTP3TlSSxM2EILYM28TAxe5/snNlERAgBro9bmZl2x12sjRZ+2UcztcqstIFZ8dvRk/UrgfHc6MbZCAIxmm2u/zhagXJxIgusvW7CPb2dvOO9F3Lxla/gm1/5CZ/59Dc58+SLOOnko7jkqldw6nOOr+lcK1ohS5bJYzMObEu0TaBbImlmZEVLfExkLCb26SKRT5LqmVkyHdhOpBctl/G147i2i6IqmJOZjJFmNNJG3apfppr41f+Y8Cw32hdyYioWioWQnjbz/NN1nZecdzpnn3sav/v1fdx+8zd42xv+g4984HO89dLzuOB1Z5HJVl9SLy1d4qNUFAggmZLnebPSXleVNsEvRmKgmQ2hGwnPcjEyOwsrRVHQkjp6UifdO1M0upY7GWjcUTQmsjqJrImZNTAzBuoidLRyncjnR9frn5rv2h75ftnhOQ4mZpuVNhXb6XSSC9/yEl7zxhfxo+/9lttu+jqvOudqnnbIvlx85St4ybmnzbnMP/L8C0jLTJ1YkGJbImkOPMsl3Zep9zBagtANCL1wl5pR1VWMziTJzmkNA0OBV/QmNaM9ZDP6xCihH2Kko+BiMqtjZg0SWWOnhoELQWNZ5HgyOzEmwlBQtFu/5Hl3KIrCs049hmedegwP3v84d9x8F9e993ZuuP7/8bo3nc0bL3opfUu657y+ohXKcueYsK2QjKxoaWrqf7eQxI5bCYA1syF0I+HZblVm5aquktyDaPRtB2uoiPOES+gLjHQUYExkjQUTjZ7nY5hG3Y+Jif0gG7LEQ+SHI4M2mqbxopeewgvPeTZ//O3fuf3mu7j8zR/h+ms/x5svPY8LX38m2dyeZ6BdRxD4kM7I/RkHViGkf0CKbYmkkQmDEK8oK1riwrVd9NTcswsVVZmsYplACEHgBJNBxvK4w9hGC78coJnaDK1oZg2MVLzVL41lkeOSyMtJvjgo2SGKKrPAAA45bH9u/fz7ePcH3sTnbvsWn7v9W3zmlrs474Lnc9HlL2fVgbP7cttWwNIV9T9HWgFZ0dL8yIBiCxL54ciLXFx4ljujbKUWpotGXYmy8yZEo2N5OJZHedydJhrVySzGRNYgndMxUlrNotF1XMxE/YN4ru2hqAp6UgYa4sC2Qjq65L6cQFEUTjz5KE48+SgeefAJ7rjlLj78/s9y4/X/jwvf9GLefPE5DAz27HJZuxCSyqiLkjHc6oShoFSUAlEiaXQ820U11EXJfGsHPKu6CehdoSgK+rTqF12JfLkDP8S1PFzLw7FcRtaWJzVVIjM9yGiSzqo1l0xPlDwbRgNoRssjN5it9zBagomqgXonFjQSy1cs4brr38ZVV7+WL3/h+3z+9m/x1S/9gLNedBJvu/LlHPf0Q3a5nBBCem7HiG2F5PJyXzYzMqAIhEIlFNUdyKZavZlrQvGqXqYQVF8a6hZcMv3Vla9olY511SCo/qakKNWbT9dy66vF4lrdxVLTM+p29fda9ps+sYwCRkolmUpA39QMbOCHlSCjj2N5jK4tM2R7oCokMzqJrEEiq5OsiMe5BEBcx5uTOFRr+H52tV92h287JLImmiqo9luqZjsT1HLs1LKdWpbRqP7YUXbYTtEKWLpC3+n1GcvU8J0mqKWx0OJ8PxMPV7Nx1GHLufNz7+ADH3gtn739O3zxzu/xmU9/i1e88nQuv/JcVq1aOeP9ru2Tyyok57j+XaHVsA+CWq6jVS9RWwe2Wq6jAijZAlWFVEqZ01hrOUaNGo7RWvZ1Tf0SlD3v7Vqus5LGoVrN2NB60XIxq6xokXpx9/d8z3JJ5Mzd/n0+mlE3INFlQJcBRJPcIhS4RZ9yZWLa3lpk+IkxQl9gpnWS2QnNaJDM6ehzCBxPlDzPZRJ6ITVj6If4ZZ9EzkCtYb9JzThTMxatIAoozrLtdtSMqZ4EV7/rPK64/Gy++fVfcMtNd3PWaZfzjBMP5cqrzuP5Zz4dVZ265pdKISKEroxAlZpxklo1o22FDC7V5zzOdtKMzaIXZUCxxYgasrgY2a56D6Ul8IrR7K+WXLxTRdNV0p0J0p3TyjzCcJpo9ClsLbPtSYvACzHTUQlMclqgUTNnzkJ6ntcQGYqO5WHKhiyx4PuCckm0rR/OXFm2vI8Pf+Qt/Nu7LuA/v/BD7rjtO3z5//2Es17wDK58+8t5xjOiGWirEJKVGXWxEHV4lpkQEkmj48aQUSeZwrNcsgOLl1GnqMpkwHCC6dUvZcujXPAY3VTEK0XVL8kZk9I6ZnpmybQ74aFY5yZ+ru2hmWolCFp70EYSYRdCutusIUu1JJMmr339mbzudc/jhz/4IzffdDfnn/cBDly1giuuPI/zX3EaiYSJJT3/YiMIJipa5L5sZuSVpcXwywGhH0oT45ioZfZ+IdidaPTdKJuxXIiCjWObirilAM1QpwRjzsDUEiQS9fehcW2P7JL5lY9LImwrxDAVTFPehOdCZ2eWt7/jfN526Tl8865fcfNNd3PG6Vdx/NMP5sqrzqOv52iWSM+/WLCtkGxOHpcSSaPjWS655fl6D6MlmMioq7flkKIoGEkNI6mR7Z3y8g78EMf2Jytgtq+zcewoeJjIVIKMOQPPDkkmk5h1Dig6Ff0tiQe7ELJiHzlpOhdUVeVFLz6JF734JP74xwe5+cZv8raLb+BD132Ji992Dmc+/wVkZHJELJSKAlWDRFJqxmZGBhRbDMfyMDIGiipvGnHQyLP3iqJgJDSMhEZ2mi1cWBGNE9mMI+ttTjr6VE488hSeundbpcv0VEajpi/OsSKEwLU8Evs15v5sNmRDltpIJExe89rn8apXP5ef/uTP3HTjN3ntqz/MXXfdxY9//Edefv4zSSblMTofbEvQ2S2PTYmkkRGhqHhu13+ysRXwbBfN1BrWj1LTVdIdJumOaQ1gQoFb8nGsSDNa2xwUK8U3vvENKIRseGBkhmbUE4uXee7KipbYcF2B60pf41p4xjMO4RnPuI5//Wstn775Hj78oS9TLvbR02vS1b2KZcv76j3EpsYqSG/PVkBeWVoMx5INWeLEa8IGN6qukuow6VqWYWBVB3sf08t3fnIXN936KbpXZtBNFXvYYeNDIzz22y2s/uMQ6+/fzrYnCxS2lvBKPqImE4g9EzhR9qyRlgIxDmwrkCW680BVVc486wR++j838KOf3kIYBlz2to9zyEGv4RMf/zojI4V6D7FpsSrm7xKJpHFxi37UACQlcwviwLWjCf1mYqKhS35Jiv798qw4ohvLGOJ1r3sdRndIMm/gFn22ri6w+k9DPPa7Laz92zBbHhtndFORcsFDhAvj8eVa3oyqHEntFK2ARFJBN2TQplZWrVrJrbdfxYMPf5nDDjuY73335xx68Gt5y5s/zoMPPFnv4TUttiXthloBqSJaDMfyMDplSWkcRBl1Ll0tkFHnui7jhXHy/SnonzJu991gcmbasXzGt5Zxiz6qplRKYAySuQmfnbk1gNkdjuVhpHXZRTcmioWQwRVSbMfBPnvvzTrV596/fZ5bb7mHj330K3zqE1/nwtefydsuexkrVvTXe4hNw4S3pxSIEklj41QqMGRmSDy4LTKh7zouY2NjJHIaPSun/CDDQODY3qRmHNtUxLHGCUNBIj3V/GWiceBcGsDsDiEEru21xP5sBGRFS3z09XeTTpf4r6++i69//cfc9ulv8/Wv/pwzzjiOK646j2edfIS8plaBbYV09zZmVrdk7siAYotRLrhklnXWexgtQVD2EaFoiYw61/UwzJ1Pd93U0Ls1Mt1RyZNAIQwFbsVnp2x5jG0u4lgeYRB1DZxeLp3IGmDM7UbQKmK7ERBCYMsssNiIGrIoHHDAcm7+9BW8799fy2c/8z0+d+d/85k7vse5553CFVeex2GH71fvoTY8RTvEMMCQp7pE0tA4BRmwiRPPckmuaH4/Ss+b6PI889hQNYVU3iSVn3o9FOCVg4ovo0dpzGV0g41XDtAT6owgYzJrYKTmphe9kg9CYMjs2ViQejE+bFug69Ddk+LSy17GWy86m3u+9WtuuvFuXnDmuzj66AO54qrzePHZz0TXZaBsNixLsGJveWw2O/JK3UL4bkDghlIgxoRrexhpA6UFunh5rodpzu24UFWFZC7KTOyovCaEwHcq2YwFj9K4y+hGe7JroJkxMSui0cyaGCl9p/3m2h6JnDw246BcEoQhpDLyJhwHlhXSM22GtH9JF+//wIVc9Y7z+a8v/4Rbb/k2d33jl5z+nGO44srzOOXUo+QM9G6wLSH9cCSSJsCxXFL9uXoPoyWY9KNsgSYirjP3Ls+KomCmdMyUTq5vqvol8MJKNmPUZdoednCLHqBgZoyKXox0o5kxUHfw8nYn/eDlfSQO7EJIV0/zJ0c0AtEE9JTGMQydV7zyOZz/itP5xc//yk03fpPXvebD7LPPIJde9jJe/dozSKeTs6y1PfF9gVOW3p6tgAwothCO5WEktZ1uzJLaaKWMOs/x5iQOd0fUNVDHSOo7dQ0sWiGO5eJaHmPrLdxK10Azo08GGs2sQbngkhvMzPuzSKLZ5nRGRZViOxYsS7DXLmZIs9kUF19yDm9+y4v5zrf/l5tu+CYvfuG7OeKI/bny7efxknNOljPQO2DJ0iqJpOERQuBYHh0tYOnSCHglr2X8KD23ouHmoRk1QyXdmSDdOdXwZ6IBjF0IcC0Pe1uJkafGCLwQPaWTqAQazaxJebSM2WR+lI2KCAVFOySTk1olDmxr1xpHURSe89xjec5zj+Vv9z3KzTfdzb+983Y+/OEv89a3vpi3XHQ2vb0du1hj+2JbIaYJpimfZZqd5r/zSSZxCq7MAIsRz3JJdLXGrJLreZiJ+MWZpqskOwySHdNEoxB4JR/X8nAtl+L2MqNrxwnckK3/GiGRtUnltMkyGCOpyWymKpF+OPHhedEM6Z48/3Rd47yXn8q5553Cr3/1N2668Zu8/nUf5dpr/pO3XfZSXvu655PJpHa7fDthWyH9A1JaSCSNjFcOCEOBkZaaMQ68FvKjdN25ZyhWw0QDGDWdhCVTr/tOgGu7Fc3oYQ0V8Yo+iqqwsTyEmTVI5/RYvLzbkVIxapqTSsv9FgeWFdLXv+fg7FFHH8iXvvw+rv3gJm695dvcdOPd3HTj3bz6NWdw6eUvY999ly7SaBsby5LZia2CVP0thCM7osWKa7vklje/Hw5EGYrp9OIEPBRFwUwbmGkD+qMGQeUxh833b6X/oG4cy8OzHaxtZRzbR1UVzIxeaf5iVJrB6KiavMnsDtsKyHfI2eY4sKwQM6FgzGGGVFEUTj3taE497Wj+8ffHueXmu3nP1Z/lox/5Cm9+84u45OKz6e/vXPhBNzCRV5N8cJFIGhmn4JKQJaWx4Vpuy2TUTWQoGsbiPCLqCQ09kSLdPaVRn/r9Brr3yYOiRNUvu/DyTmT0ip+3gZ6Qemh32FZAWtqQxIZVCNlnv7md63vvPcgnb3gb737vq/n8nf/NZz7zPb7w+R9y9kueyRVXnsfxxx64wKNtbKS3Z+sgA4othGN55AdkSWkcBF5A4AQtU/LsertuyrJo27ci/8RUV5JUVxJDiQKNIhQ4RX/S0LswVGKbVSDwQoyUNikWE1mDbE7FSEhRBFGG4uDy1nh4qTd2pSFLtRxx5P584Yvv4QPXvYHbPv1tbrv129xy87d49aufyxVXvIz99lu2AKNtbFxX4LpIgSiRNDhyAjpeXNsj05eu9zBiIWriZ9RNawVeQOiFZPoyaEZ0LzGUYKaXd8WbcWxTMfLyNtTJ7tKTDWAyigyYI4M2cTKhcfZU0bIrens7ePd7X83lV57L177yP3z6lns45eTLePazj+DKK8/jjDOObctnG6sQsmRQhqJaAfkttgihH+KVfBI5g6Deg2kBPMtFS7SOH6XnuHNuyrIQOLvxo1RUhWRF/E0ghCBwQ8qVIKNj+YxvKbGh6KPpCsmsXllGJ5XTSaT1tiqBCXxBuSTLBOLCsvZc7jwbK1cu4WOfuJir3/Mq/vNz/80dd3yPL3zhR5x99klceeV5HH/8QTGOtrGxrZBkUkHX2+d8lEiaEcfyyHS3hqVLvRFCRCXPe3fWeyix4LkLY5EzV1zLQ09ok8HECXbn5R36IY7tT2rG0Q02ju1DKCpZjDqpCd2Y09GN9tJOdiGks0dmcMaBVZifxkmnk7zpLS/i9W88i//+/u+56YZvcs45/86hh+7DFVe8jPPOO2Ve3qXNhBAC2wrJ5qRebAVkQBHQlABNWfgwnKqIqpdJqN6c3mcXXXRTJZMMsYKw6u0IUf0NVqnh8yjUsEwN1xq1pu1MLeMXIz9KXd3zvtSV6ve1VsN+U6l+OzM+j+eRSGgY6p6P86CG4yAUs39Bnu3SsSyLVvkcezoOFAXUhIqRSJDrmfJm1MKAsu1TrsxOj24uselxnzAQJNJRNmMkGqMf3VRrOkbVmr7TGr6fqpeIsO0Qw5hbiW7t1HJuLw61bGdPn8ayQpYu12v4xDPp6s7zjqtfxduuOI+vf/V/uOXmb3HKKVdw0jMP4/Irz+N5zz8eVd35/PJrOedq2Au1XKv0Kq87E+XO1X4iUdPxVst1tAZq2G+z3X/0RdAbkoVjMTTjQupFiEp0l+ydQtRwfEu9uIO+KvuEfkgqp6G2gGYMXAfTMGbVi7AwmtGzXBJZY1Ivwp6PBU1XSHcYpDtmTkyLslfRiz7WqMe29UW8coieUKdpxWhyOpGOvLxruq80uma0QpbttdAJBe2hGS0rJJur5YoxE1XTOPuck3nxS57F7393Pzfd8E3e/OZPcu21X+KSS1/K615/Jvn8risOW0UzOq7A8yCbUaVm3MPYmkUvyoBii1Au+CRz8uuMC7ciaFoF1/EwE/XJUIy6Sfok5ukvpGoK6bxBOm8Aqcl1e+Uom7Fk+RTHPbZvLOGWAjRDIZ2LZqZTWY1UVieR0Zq+M/JEQ5Z2LI+IGyFEJBBjzPZMJk1e/8YX8NoLn8+PfvBHbrrxbs4/9xoOetpeXH7FuZx3/qkk6nQuLjR2zPtSIpHEj+cE+G5IMqtTqvdgWgDH8jDSreP77C1QE7+54sSgvyMv76iCpaN/6vXACylbPqXKxPS2tTZl2wcgmdFJ57SKZtRJZrWmz2acaDonm/jFgxWzR7SiKDzzWYfzzGcdzsMPPcUtN32La6/5Tz5+/Vd5w5teyMWXvISBwZ7YttdI2FZIKiUrWloFGYFqEUoFj1QLBcDqjWO1jh8OVDwUF8lge0e8UgAiMtKOG0VRMFMaZkoj3zf1euCHlG0fz3IpWQHbNpQpWQEiFCQy2lSQsRJwNMzmEVvSDyc+ymVBGLAgTUQ0TeNFZz+TF774JP70xwe56YZvcslFn+JD132Ji992Dq9/4wvo6Ggtz1urIFi2QpZWSSSNTNnyMdMamq4iPXLmTzQB3TqTRK7jxd7huRocyyfbuzBNBDVDJdNlkuma+r5EKHBKAWXLx7Vcxoddtqwp4TkhZlKdDC6mJmx2Us0zoVucaDpnNMd4Gx2rIFi518JonKcdvDd33PlO3v+BC7nj9u/w+Tv/m9s+/W3Of8VpXH7leaw6aOWCbLdeRB2e5XHZKsiAYotQtnxyvYnZ3yiZlTAQeHZrGZbXM0PRsTzMRe4mqekqmQ4TvXPqxi+EwC2FlCqz0/aYz7b1ZdxyiG4qk2Ixm1NJZTWSabUhsxntQsDAstY5NuuJbQlSaWVBv2dFUXjGiYfyjBMP5V+PrOWWm+7mPz74//jEx77G6994Fm9527ksXdq7YNtfLBYi21MikcRPqeCTykr5HxeO5ZHMt1BA0fXq5uMmQoFbXFz9ragKyYxOMqOjD0xt13cn9GJAyfIZHy5StgIUhUlfxlROI5tTSWc1tAbMtLILgcxOjIkJz7+F3p9Ll/XyoQ+/mXe+6wK++IUfcsdt3+G/vvxTzjzrBK58+8s59oTDmiagvSekXmwtpKJoAcJQULZ9UrLkORa8ooeqq2iJ1sm08dz6dXl2bQ+zAYKziqKQSGsk0hqd/VPB98APJwVjqRCwZW0lm1FQKZXWSGe1SimMVtdsxklBI2/CsWAVIj+cxWLVQSu57TPv4N+vuZDP3PFd/vPzP+CO277LuS8/jbddcR4HH7LPoo0lbpyyIAwhnWl+oSuRtDLlgkcqX/97cqvgWi75pdl6DyM2Jro812XbRR9VVdCT9dffuqmS6zbJdU+9JkJBuRhMBhrHtrpsedLHcwWJlDqpF1O56He9sxmlXoyPUkkgBKTTi/N9dnRkuPLtL+fit72Eu+/6Fbfc/C2e95y3c+zxT+Pyq87nzBc8A02r/3lSK5YVsnKljFu0CvKbbAEc20fVFIwGuAG3AlFHYqMlZoAmiGac65ehmOpq3OxZTVfJdqpkOyMBrStB5PtYCikWAkpWQGHEZ8s6B7ccYiSUSDBmNdI5nXRWQ8+IRcnAdMqCIIB0RgrEOKiX59/g0h6u+9Abece/vYL//M+f8Jnbvs3Xv/oznvu847n8qvM58ZmHN931x6pke2pt1HFdImlGSgWfrqULU1LabgReiF8OWqqipZ5dnicrWhr0/qeoyqTH4gS6EuC5U3qxaAWMbPUo2wGKyrRJaX3y38Yi7V67ELJ0r9Y5NuuJVag0nVvkyqVEwuTVr30eF7z6ufz0J3/m5pu+xWtfeS377b+Mt11xHq+44AySyebKkI6SI4TMUGwhZECxBSgVfJJZvWFvwM2Ga7VWuTPUN0PRsTw6lzfX7L2iKCTTGsm0BkumXvd9QangU7Qi4TiZzUgU5EvnNDJZlUxOI51VY89mtK2QdFpFlUGbWLAKIf0D9ZuIyeczXHrF/2/vzuOjKu89jn9nJpMQEgIJBMIa2UmAACKyySJIRRC1uNQqt6gXsV4ErRXRy3Upl7oi5VarYL1iFamCl1pF1FIREWSVTVBESIBAgEAI2ZPZzv0jzZCRjEwmk8wM83m/Xr5MnjznnF+GJyff/GbmnJs19d4btGL553pxwTJNGPtbXdq/u6b/5he69rqhYfMMNG9fAUKf0+GSvdyp2CYXV8YJFluJTZYYiyzR4XGe9oWtwi5rQ3W8fqQiTPO3Ndqsps3Natr8XO0ul6HyUpdKiypfzZifa9OxTKccNkMxsSbFxVvUuIn5X/+3qFGsKaB/x517R8vFszaDqaTYCOqrPc1ms64ZN0hjrhmibVu/04sLlum3M/5HT895Q1P/4+e6a8oEJSYlBK2+2igv4x0tFxsaiheB8iI74TCAbMU2NWkdXg2wC7FV2INyZ1mn3SVHxcXz7H1UlElNEq1qknju+zEMQ84yu0qKK5+hLsh36vgRmyrKDVmjTYprUtVorAyPsXW4NmPVHZ5Rdy6XodLS0HiGNDraqltv/5l+cdsY/fMfW/XSgmW6c9IcdezURtNm3KRfTrpasbGh+ypfqfIVivFcYBsIaeVFDkXFmBUVRjciC2UX5RPQQbzLc0WxXU1aXhyvnjWbK9/N0vhHDT27zSVbsV0lRU6VFrt0JrdCZSUumcyqzInx/8qM/7o2o793wS0vNSqf7G6gt+he7IqLXEpoGhrnzcsGpOkvbz+hgweO6uUX39O8Z5Zowby/atLkcfqP6TeqfYdWF95JEBUXG2r8r+uXG8EuBgFBQ1FScVFJrbfxpx/gMNtqvU2568K/1PNOFqpZ60YqKqw80ZU47bU+jtNomJOkP6cOf56wM/t1HEOGYSg/t0AxKdEqLrzwPqJMrlofx59t/HvcKrdxOZ1yOp1yOlwqKvzpte7yYx3YXd63KT1rk81RobKyUqns3LjFr8et9o9BlKn2t7D0ZxuryamYWCkmVkpsKUlmOeyGSkucKi1xqDDfpeNHXSorccpwSbFxZsXFmdW4iVmN48yK8/HVjLknyxUXb1Zhoe81mv143Pxab7XeouHUVFtJsUvl5RWy2V2yFwavesePfuYGDu6pgYN/p927ftCil/+mmb95UU/N+Ysm//s4/eqOcUpMSpDhx6Pt18+cfN/m5MkKXXKJVYWFfvz+qfUW/v3O8udxc/mxzYWOU1RUWut9InTUNjOGUl48c6JELrPdnQXIi/7nRUk6czJfUdFRKi4s9mm7cMiMpcVlMlvMF8yLUmAzo2EYOnuqQI2SLefl74suM1qdSkiSEpIkySSXy6yyUpfKiiufnD6TV9lstNsMRTcyuRuNcXGVTUpfXs2Yl2uXZFdRce1+KMiMNdd28mS5miRYVVhY+3NzIFXPjMktE/XEf9+t+2bcrDcWf6Q3F6/Snxf+TROuH6Z7/uPnSu/VSZJ/2ac+M+OJEw6ZzIYKC51+1RZJmTFc8qLJMIyIbQ6Xl5erY8eOOnHiRLBLAQAAESIlJUVZWVlq1KhRsEuBj8iMAACgIYVDXozohqJUGRBttuA+2wAAACJHdHR0SIdD1IzMCAAAGko45MWIbygCAAAAAAAA8F1oXF0UAAAAAAAAQFigoQgAAAAAAADAZzQUAQAAAAAAAPiMhiIAAAAAAAAAn9FQBIAQ4XA4JEncKyswDMPgsQQAABcV8mJgkRcB/9FQRMQpKiqSxC9hhJZDhw6pd+/eKigokMlkCnY5FwWTycRjGSBOp9P9MedOAJGAvIhQRF4MPPJi4JAXIw8NxTCwe/dubd68OdhlXBT27dunPn36KD8/n18cdeR0OnXy5ElJksvlCnI14a9p06YaMGCA7rrrLu3cuTPY5VwUlixZojNnzvg0lzX80+bNm6d7771Xkjh3AiGKvBg45MXAIjMGDnkx8MiLgUNejDw0FMPAf//3f2vFihUeYzk5OTp79mxwCgpjKSkpGj16tCZNmqSvv/462OWEtY0bNyojI0NHjx6V2cyppK4SExP18ssv6+qrr1Z+fr4kQktd5ObmaubMmR7nSZfLpfXr18tms503nzX804YMGaJvvvlGv/vd7/jdA4Qo8mLgkBcDi8wYOOTFwCIvBhZ5MfLwExEGvvzyS7Vt21bSuV8Yt9xyi5YvX+4xz+Fw6K233tLBgwcbvMZw0axZMy1atEi333677Ha7JH4J+6tfv36aMmWKpk+frk2bNgW7nItCfHy8pkyZokGDBkk6F1qcTqecTidrtRa2bt2qsrIyNW3a1D329ddf66677lJJScl5cx9//PGGLjGsDB06VK+++qosFosqKiqCXQ6AGpAXA4e8GFhkxsAiLwYOeTGwyIuRh4ZiiDMMQ6dPn9all14q6dwvjC1btig5Odljbm5urmbNmuW+5gtqZjabdeutt573mDqdTjkcDn4J+yguLk6PP/64br75ZkVFRQW7nLCXmZkpu90us9ms2NhYj69ZLBZZLBaeFa2FzZs3Kz09XU2aNHFfw2XTpk1yOp3nPb6ffPKJPvzww2CUGTbMZrPS09M1ffp0tWrVyj1uGIb7DxiulQMED3kx8MiLgUNmDBzyYmCRFwOLvBh5OKOHuF27dslqtapt27ZyOp2yWCw6evSoXC6Xevbs6TH3yJEjOnHixHnjOGfXrl1KT0+X1WpVdHS0x9csFkuQqgpfMTExuu2229yfu1wujxDz489Rs+LiYvXo0UM7d+5Uenq6JMlut2vDhg166623dPr0afXs2VPXXnutBg8ezDVJfLB582b17NlTVqtVLpdLFotFmzdvVv/+/dWoUSP3PMMwtH37dvXq1SuI1YY2m82mgoICtWjRwuMZfKny+jicO4HgIy8GFnkx8MiMdUdeDDzyYuCQFyMTDcUQ9+WXX6pHjx7q2LGje2zz5s1KTk5WUlKSnE6nzGazTCaT9uzZo5YtW8pqtQax4tB16NAh9evXTwcOHFCnTp0kSaWlpVq9erWWLl2qgoIC9enTRzfccIMGDx4c5GrDw5YtW7R8+XKVlpYqISFBbdq0UadOndSjRw917tyZYOijXbt2KTo6Ws2aNZNUuS7/53/+R7Nnz1bbtm2VmpqqJUuW6K9//atefPFFXXvttcEtOAx8++23mjRpkkeA2b59u/uPGcMwZDKZVFZWpm+//Va/+c1vglluSKtad+vWrVPjxo0lSfn5+Vq9erWWL18us9msgQMHasKECeratWuQqwUiE3kxcMiL9YPMWHfkxcAjLwYOeTEy0VAMcXv27NGuXbs0Y8YMXXbZZbruuuu0fv169e3bV82bN/eYu2XLFvXu3TtIlYa+bdu2qU2bNu5fwmfOnNHcuXO1YMECde7cWe3bt9fSpUu1YsUKvfzyyxozZkxwCw5hJSUleuGFF/TMM8+oS5cuio2NVV5ennJyclReXq7k5GQNGzZMd999t0aPHs3bWy7gq6++UufOnRUXFydJWr16tV544QXNnDlTc+bM0YkTJ5SVlaX//M//1L333qvLL79cLVu2DHLVoe3YsWN65ZVXdPjwYV166aUaMGCAjhw5oiFDhkg6d+e5/Px8ZWdn6/LLLw9muSFty5Ytatq0qfvn+MiRI3rooYf03nvvqXv37mrWrJn++c9/6oMPPtDChQvVo0ePIFcMRB7yYuCQFwOLzBg45MXAIy8GDnkxQhkIaQsWLDCuvvpqo1evXkazZs2MqKgow2KxGImJicadd95pvPLKK8aOHTuMoqIiY9iwYcZjjz0W7JJD1vTp043Ro0cbJSUlhmEYxiuvvGK0aNHCmD9/vmEYhpGdnW2sXbvW6Nu3r5GWlmbk5+cHsdrQtmzZMqNTp07GvHnzjJycHPdjWlFRYezatcuYP3++MXToUCM1NdVYsmRJkKsNfRMnTjQmT57s/vz+++83Ro8ebZw6dcpj3pYtW4x27doZr732WgNXGF4KCgqMe+65xxg9erTRrl07w2q1GiaTyTCZTEZaWppx1113GX/605+Mr776yvjHP/5hWCwWw263B7vskDVw4EDjt7/9rVFeXm4YRuW5tE2bNsY777xjFBUVGfv37zeWLVtmNGnSxPjFL35hOByOIFcMRB7yYuCQFwOLzBg45MXAIi8GFnkxMpkMg6tihjK73a4zZ84oNzdXx48f15EjR5SVlaUDBw5o//79Onr0qAoLCxUbG6vCwkJ9/vnnGjFiRLDLDkmDBg3SiBEj9Oyzz0qSbrrpJkVHR2vRokVq0qSJe97q1at1xx136I9//KNuvPHGYJUb0u655x4dP35cK1asUFRUlPviutWv1XL8+HE99NBD2rBhgz766COu1fQT+vbtK4fDoYkTJ2rQoEGaNWuWrrvuOs2dO1cmk8l9Pazc3FyNGjVK06ZN07333hvsskNaYWGhSktLlZ+fr1OnTuno0aM6cuSIdu/ere+//16HDx/W2bNn5XK51KJFC+Xm5ga75JCVlJSk1157TRMnTpQkde3aVb/61a/0yCOPeLxlcv78+XrxxRf1wQcf8OonoIGRFwOHvBhYZMbAIS8GHnkxcMiLkYnXlIc4q9WqVq1aqVWrVu4fOJfLpYKCAp06dUo5OTnKzs5WVlaWDh48qIEDBwa54tB15MgRrV69Wna7XZdddpk2bdqkhx9+2B0Oqy4G3aNHD0VFRXEtl58QHR2t0tJSORwORUVFnXfRZ8Mw1Lp1a73wwgv62c9+pvXr1xMOf0KnTp2UmZmpd999V0uXLlVubq4sFoscDoesVqv7mi7FxcXKyclRRkZGkCsOfQkJCUpISFBKSorS0tIkVf7BXVZWpqKiIuXl5enkyZP6/vvvz3s7IM6x2+06e/asli9frqNHj6pbt27Kzc3V5Zdf7g6HVefO4cOH68knn1RCQkKQqwYiD3kxcMiLgUVmDBzyYuCRFwODvBi5aCiGOMMwtG/fPpWUlKhv377u4JKYmKjExER169bNPbeoqMjjblQ4x263a8iQITpx4oQ+/vhjvf/++yotLZXNZnPPqQqE+fn5ys3NVd++fYNUbei78847NWzYMN111116+OGH1b17d8XGxrq/XhUWy8vLlZubqw4dOgSr1LCwYsUKnTlzRpmZmfr+++918OBBJSUluX8BVz3jvGzZMsXExKhfv35Brjj05ebmaufOnWrfvr07IFqtVlmtViUkJKht27aSpDFjxsjhcASz1JB28uRJ9ejRQ3v37tXWrVtlt9vdr3CqUnXuzM3NlcPhUGpqarDKBSIWeTEwyIuBR2YMHPJi4JEXA4O8GLloKIawbdu26Xe/+51cLpeSkpJ0zTXX6LbbbnPfberHbxmo/jYMeLJarXrvvfdUUVGhQ4cOaf/+/dq/f79atWol6dwdvGw2m95++22lpKR43CkRni699FL95S9/0axZszRx4kSNGjVKQ4cOVXp6uhISElRaWqpjx47ppZdeUkpKigYNGhTskkNeUlKSkpKSdNlll533NYvFooKCAm3atEkTJkxw3zkNNVu8eLEWL16s7t27q6ysTLNmzVLv3r3dP+c/xgXgvWvXrp127NihY8eOud86mZ2d7Q6FVX+8nDp1Su+++6769OkT5IqByENeDBzyYuCRGQOLvBg45MXAIS9GLq6hGMKGDx+url27atKkSfr+++/13HPP6e2339bgwYO9nuhQM8MwZBjGBd+WcujQIU2bNk0ZGRl6+umnG6i68ORwOLR9+3YtW7ZM//jHP5SZmamysjJFR0crNjZWjRs3VqtWrbRw4UINGDAg2OWGrG+//VZnz55Vhw4d1KxZMzVq1Mj9lhWTyaTVq1fr6NGjuuWWW5Sbm6vExET3nSdxvrKyMl1yySWaNWuWRowYoTfffFOff/65duzY4X5cEThVv4s2b96sRx99VDfccINmzJgR7LKAiEJeDBzyYv0gM9YdeTGwyIsNi7x48aKhGMJ69eqlGTNmaOrUqZIqr0Hy97//Xddcc02QKwtfhmHI4XC4r+Hw42u5lJaW6sSJE0pOTuYZ/FpwOp06fPiwcnJyVFJSosLCQiUkJGj48OEeb2vB+a688kp98cUXatmypVq0aKHevXurX79+Sk9P18CBA/XrX/9aDodDK1asIOD4YO/evRo1apTWrFmjnj17avv27Ro0aJDOnDmj+Pj4YJcXlqrOm1VxwWKxnLcWz549q/z8fLVq1YpXRAANjLwYeOTF+kNm9A95MbDIi4FHXoxMvG43hM2ePVszZszQd999p7y8PKWkpGjw4MHBLissHThwQG3btlVsbKzHXaaqVF0ouqKiQhs3btSIESMIiF7Y7XY99dRTevPNN2UymTR58mTNnj1bnTp1kiRlZ2erd+/eatOmTZArDQ8tW7aU1WrV5MmTZTab9eWXX2rNmjU6c+aM+4+Xtm3b6qGHHlKXLl102223KTExMchVh65u3brp9ttv1+23367x48dry5YtGjNmjOLj43mljh8qKioUExNT43nTMAw5nU5FRUXJbrdrw4YNGjduHAERaGDkxcAhLwYWmTFwyIuBRV4MLPJi5OIViiHMMAx98sknWrt2rfLy8jR16lRdfvnlnORqyTAMJSYmqmXLlmrXrp26d++ujIwM9e7dW2lpaR537Prmm2/Up08fff3111zI2ItHHnlEr732mq677jrFxsZq+fLlWrJkif72t7/pjTfekM1mU+vWrfXggw9qxowZXG/EB7/5zW/0f//3f5o/f75uuukm5ebmKjs7WwcPHtS//du/qV+/fiotLdWePXuUlZXFRYwv4PTp03r77bf15ZdfKiMjQ/fee6+Sk5M5d9ZScXGx0tLS1KVLF3Xs2FFpaWnq2bOnevToodTUVI9nndetW6eRI0cqJydHKSkpQawaiDzkxcAgLwYemTGwyIuBRV4MDPJiZKOhGAY4qdXNvn37lJ6eruHDhysuLk45OTkqKCiQzWZTTEyMkpOT1aVLF/Xq1UuFhYV6/vnnVV5eztsFauBwONShQwf913/9l/793/9dkvT73/9ey5cvl91u1wsvvKCkpCQtW7ZMf/rTn7R+/XoNGTIkyFWHPrvdroULF+qvf/2rpk6dqkmTJikqKkr79+9XWlqaNmzYoO7du+vMmTPq3LlzsMtFhNi6dasGDhyo/v37y2w2Ky8vT+Xl5TKbzUpISFCbNm3UrVs39ejRQ4cOHdKiRYtUVFQU7LKBiEVerBvyYmCRGQOPvIhQRF6MbDwNFAYIh3Vz4sQJtWnTRrfccot+/etfa8+ePTpy5IgyMzOVmZmpI0eO6ODBg9q6dauysrLUsWNHwqEXu3btUmlpqcaOHauYmBhJ0i233KK5c+dq1apVGjt2rCRpwIAB2rFjh9555x3CoQ+sVqvuvfdeOZ1OLViwQCUlJZo2bZp27typxMREXXLJJUpMTOStK3XkdDplNpt9uuA+Ks+drVu31t13360JEyZoz549ys7O1uHDh5Wdna2jR4/qq6++0ieffKLMzMwa7zgJoOGQF+uGvBhYZMbAIy82DPJi7ZAXIxsNxRCWn5+vzz77TE6nU/3791eXLl2CXVJYSkhIUFJSkvuXQkZGhjIyMtxfLykp0enTp7V3717NmjVLXbt2DWK1oe27775Tu3btPAL07t27lZycrEGDBrnHoqOjddVVV2nt2rVBqDI8RUVF6YEHHlBiYqIeffRRFRUV6fjx4+ratSsXh66lDRs2aNeuXerevbtGjBjhfgtV9bsh4sLi4uLkcrlktVrVunVrtW7d2uPrp06d8jh3pqenB6lSILKRFwODvBhYZMb6QV4MHPJiYJAXIxsNxRD1xRdf6KabblJ5eblatGih9u3b67nnntOgQYM83tLidDp5dvQCMjIy9Pbbb6tVq1aSKh+zqsfPbDYrLi5OcXFxatasmYqKitSrV69glhvy2rZtq7y8PPd1WRISEnT33XerWbNm7jkOh0OHDx/mGdJaqPq5njx5stLT0zV58mTt27dPd999t6Kjo4NdXlgoKirSH/7wBz3//PNKSkpS48aNNXv2bP3iF7/Q66+/rnfeeUedO3fWjTfeqNGjR/O4XsDAgQP16quvqm/fvpIqf67NZrNMJpNMJpOSk5OVnJyslJQUlZWVERCBICAvBg55MfDIjIFHXqw78mJgkRcjG6/hDUG7du3StGnTNHToUH388ceaPXu2SktLNW7cOK1bt04mk0kul0uStHHjRv3sZz8LcsWhLSoqSr1791bLli0lVT7rZDabz3sJe2FhoTp16qQxY8YEo8ywMHbsWM2YMUPt2rWTJLlcLl177bWaO3eupMqQI1XetW/37t264oorglZruKn6o8XlcmnAgAFau3at/vznP2vKlCk13jEN53vvvfe0dOlSTZ8+Xe+++66GDBmil19+Wb/97W81c+ZMNWrUSFu2bNEvf/lLvf3225LOrVmcLy4uThMmTFD79u0lVZ5LqwJidQUFBerYsaOGDx8ejDKBiEVeDCzyYmCRGesHebHuyIuBRV6MbNyUJQQ988wzWrlypZYuXaoOHTpIqgwv119/vbKysrR69Wp17dpVhmHo2Wef1euvv679+/cHuWpEKpfL5Q7bVR8//vjjWrVqlV5//XWPtwsB9en6669XYmKiFi1a5L5e0xVXXKG8vDzNmzdPo0aNUl5enu655x7l5+frww8/9LhrJ/zHzSCAhkdeRLghMyIUkBeDh7x48eEViiFo27ZtSk9Pd19/wGazKSEhQe+++66SkpI0depUlZeXy2Qyadu2berfv3+QK0Ykq/7MfdXH1113nebNm6eePXsGqyxEoH379qlv376yWq2y2WySpNzcXE2cOFHjx49XbGys2rVrp4cffliFhYXavXt3kCu+eBAOgYZHXkS4ITMiFJAXg4e8ePGhoRiCGjVqpIqKCvcJLjo6Wk6nUy1bttSiRYu0Z88ePfHEEyovL9c333yjYcOGBbliwNNll12mkSNHcr0mNKiYmBhFR0fLbDa7r3dTWlp63l0jk5OTlZeX575OFgCEI/IiLgZkRjQ08iIQONyUJQQNHDhQTz/9tMezeFW/ZAcMGKC5c+fqwQcfVGpqqo4dO6ahQ4cGq1QACAlFRUUaOHCgDh065B5zuVxauXKlunXr5jH3+PHjKigoUPfu3Ru4SgAIHPIiANQOeREILK6hGIIqKip04MABpaWlnXchaEmy2+2aOnWq/vKXv0iS+4LbABDpzp4963H3yB87c+aMZs2apT179mjjxo0NVxgABBh5EQD8Q14EAoNXKIagmJiYn7yOiNVq1VNPPaUdO3ZwG3sAqOanwqEkHT58WDk5ObrzzjsbpiAAqCfkRQDwD3kRCAxeoRhCfnzXI5fL5R6r6ZnngoICnTx58ryXZwNApHI6nZIqL/pc9V915eXlKikpUUJCgqxWazBKBIA6IS8CQN2QF4HA4KYsIcRkMmnv3r06e/aspMq7n1ksFo9w6HA4JEmnTp3SypUr3be6B4BIVlhYKKny+mFV582qcGgYhvvcWVRUpFWrVqmgoCBotQJAXZAXAcA/5EUgsHiFYohp2rSpkpKS1KZNG3Xr1k0ZGRnq06eP0tPTlZKS4p63b98+paena/369efdkQoAIklZWZk6deqkjh07KjU1Venp6erZs6fS09PVsWNHjz+kN27cqKFDhyorK0upqalBrBoA/EdeBIDaIS8Cgcc1FEPIDz/8oKKiIvXv319NmzbVnj17tG7dOlVUVMhqtapFixbq0qWLevXqpbKyMpnNZvXv3z/YZQNAUH333Xc6efKkUlNTlZ2dre3bt6u0tFSSFB8fr9atW6tbt25KS0vTsWPH1KhRI8IhgLBFXgSA2iMvAoFHQzGEnDhxQm3atNHEiRN133336bvvvtORI0eUmZmpzMxMHTp0SEeOHNGOHTuUlZWlDh068BYWABHvxIkTat26te666y7deOON+uabb5Sdne0+Zx49elRbt27VP//5T2VlZSkjIyPYJQOA38iLAFB75EUg8GgohpCEhAS1bt3a/XlaWprS0tLcn5eVlen06dPau3evZs2apUsuuSQIVQJAaImPj3dfQ6x58+YaOXKkx9fPnDmjU6dO6dtvv9WsWbPUq1ev4BQKAAFAXgSA2iMvAoFHQzGE9OrVS0uWLFHz5s0lVd59quoisWazWbGxsWrfvr2aNm2qwsJC9e7dO5jlAkBIGDBggBYvXuz+g9rhcLgvsm0ymZSUlKSkpCS1bNlSpaWl6tmzZ5ArBgD/kRcBoPbIi0Dg0VAMIRaLRd27d/f4vCaFhYXq0qWLxowZ01ClAUDIio2N1VVXXeX+PCqq5l9thYWF6tixo0aMGNFQpQFAwJEXAaD2yItA4HGXZwBAxDAMw/1KHgAAAODHyIuAb2goAgAAAAAAAPCZOdgFAAAAAAAAAAgfNBQBAAAAAAAA+IyGIgAAAAAAAACf0VAEAAAAAAAA4DMaigAAAAAAAAB8RkMRAAAAAAAAgM9oKAIAAAAAAADwGQ1FAAAAAAAAAD6joQgAAAAAAADAZzQUAQAAAAAAAPiMhiIAAAAAAAAAn9FQBAAAAAAAAOCzqGAXAODiVl5eLpvNFuwyAAAAAARIdHS0GjVqFOwyAAQRDUUA9aa8vFxNYxNlU3mwSwEAAAAQICkpKcrKyqKpCEQwGooA6o3NZpNN5bpC4xQlq2Q6d5UFk9mkap94Ga/2sZdxk9nsZb6X8erbVjuut/37tk/VPO51nz4cV7V7HAyPOTUdsxbbnTf/3IeGD9+3T3O8HMvw9lh6q8HsZdxjvpdjqfp4tY/N3urxYZ/+zq8+1+OxufA+PHidX5dxXx7XeqhBPsypPu5lfl3qqXFOoPatAM2pw7+DTIYPc2pbQ7V9yguv+zRqnOPLsarGfdmfqbbHlLf91Pwdmmp5XJPHxxeuzWO+l+N6/TXm9bg1b+ttvlm+1FBtfg3jZm/787KdLx97nspruR95m+Pycixv256bb/G6/+r7PFezxeNxqPm4nvv0MsfbeLV9Vq/f4nGsavXXOObl+/ChFo/jeDt+9f3oHM/vyVXjuLfHxvv+a67B4uXf1tsck7fv18uaqj7uOUfnPvao4RyLx3oxnTfHYqo+duGPPeebvcw5f7ywyKXU/odks9loKAIRjIYigHoXJauiTD9qKHppsHkb96kp6Mu2Zi/b1qmh6PUvtwvX5stxg95QrN38sGkoemsehFlDMXCNQ2/jvjyu9VvDRdlQ9GWOfJhTpxrquaHo5Xu5KBuKPo3XfFzvjcC6NBRr1yCsU0PRl/kN1FD03hQMfEPRl/m+NRS9NZfqt6HotaFXQ9PMl4ai12PWoaFo8djPuYVmrrboqo97PjbVx2ue71lD9TneGpOqeY5Hnb7MuXBD0RLghqLn3JofG98aityCAcA5nBEAAAAAAAAA+IyGIgAAAAAAAACf0VAEAAAAAAAA4DMaigAAAAAAAAB8RkMRAAAAAAAAgM9oKAIAAAAAAADwGQ1FAAAAAAAAAD6joQgAAAAAAADAZzQUAQAAAAAAAPiMhiIAAAAAAAAAn9FQBAAAAAAAAOAzGooAAAAAAAAAfEZDEQAAAAAAAIDPaCgCAAAAAAAA8BkNRQAAAAAAAAA+o6EIAAAAAAAAwGc0FAEAAAAAAAD4jIYiAAAAAAAAAJ/RUAQAAAAAAADgMxqKAAAAAAAAAHxGQxEAAAAAAACAz2goAgAAAAAAAPAZDUUAAAAAAAAAPqOhCAAAAAAAAMBnNBQBAAAAAAAA+IyGIgAAAAAAAACf0VAEAAAAAAAA4DMaigAAAAAAAAB8RkMRAAAAAAAAgM9oKAIAAAAAAADwGQ1FAAAAAAAAAD6joQgAAAAAAADAZzQUAQAAAAAAAPiMhiIAAAAAAAAAn0UFuwAAFz+H7JIhVX8Ow2SYqs3wNl7tYy/jJsNc47i8jbuqbWvyMsfk5ePqz8F4zFHN41736cNxvY0bNY8bHnNqOmYttjtvfvXDV38sa55v+PDYeP7zVN+2ljWYvYx7XTrVjqXq49U+Nnurx4d9+jvfh6Xr9bGp7sI/Mn6M+/K41kMN8mGOl+UbqHpqnBOofStAc+rw7yCT4cOc2tZQbZ/ywus+jRrn+HKsqnFf9meq7THlbT81f4emWh7X5PHxhWvzmO/luN5O/4bX49a8rbf5hmquweVlvrmG8epjZl14O18+9jyV13I/8jbHVeO4Sd62PTff4nX/1fd5rmaLx+NQ83E99+lljrfxavusXr/F41jV6q9xzMv34UMtHsfxdvzq+9E5nt+Tq8Zxb4+N9/3XXIPFy7+ttzkmb9+vlzVVfdxzjs597FHDORaP9WI6b47FVH3swh97zpeXOefXVVhUPQQCiFQ0FAHUG8MwFB8fr/XFq/41UO2LzqCUBAAAAKCO4uPjZRhenzoCEAFoKAKoNyaTScXFxcrOzlZCQkKwy8FFqLCwUO3bt2eNoV6wvlCfWF+oT6wv1Keq9WXy9o4JABGBhiKAepeQkECYRb1ijaE+sb5Qn1hfqE+sLwBAfeGmLAAAAAAAAAB8RkMRAAAAAAAAgM9oKAKoNzExMXriiScUExMT7FJwkWKNoT6xvlCfWF+oT6wv1CfWFwBJMhncmgkAAAAAAACAj3iFIgAAAAAAAACf0VAEAAAAAAAA4DMaigAAAAAAAAB8RkMRgF/279+va665RoMGDVK/fv00bdo0FRcX+7Tt888/r379+mn48OEaOHCgVq9eXc/VItz4s77y8/P17LPPatiwYRo1apQGDBigcePGafPmzQ1UNcJJXc5hVebNmyeTyaQ33nijfopE2KrL+vrqq680btw4jR49Wn379lWfPn306quv1nPFCCf+rq+DBw/qlltuUf/+/TVy5EgNGDBACxcubICKEY7ef/99tW/fXnfccYfP25DxgchCQxFAreXl5WnkyJEaNmyYNm3apK1bt+qHH37Q7bfffsFtn376af3xj3/Up59+qnXr1umZZ57RhAkTaPrAzd/19dFHH2nBggVasmSJ1qxZoy1btqhLly4aPny4du7c2TDFIyzU5RxWZc+ePZo/f349VolwVZf19dlnn+mXv/ylFixYoM8++0w7d+7UlVdeqXXr1jVA5QgHdVlfY8eOVXl5uTZv3qy1a9fqnXfe0cyZM7V48eIGqBzhorS0VD//+c/13nvvyWaz+bwdGR+IQAYA1NLjjz9uJCQkGOXl5e6xL774wpBkbNiwwet2RUVFRlxcnPHUU095jF955ZXGmDFj6q1ehBd/19eqVauM5557zmPsxIkThiRj5syZ9VYvwo+/a6yKzWYz+vfvbyxZssSQZCxevLgeq0W48Xd9uVwuo0uXLsaLL77oMX7q1Cljx44d9VUuwoy/6ysvL8+QZLz00kse4/379zduuOGGeqsX4ef06dPG6tWrDcMwjNTUVGPy5MkX3IaMD0QmXqEIoNY++ugjXXrppYqJiXGPDRo0SGazWStXrvS63dq1a1VSUqIhQ4Z4jA8ZMkRr1qxRaWlpvdWM8OHv+rrmmms0c+ZMj7HY2FhJUlRUVP0Ui7Dk7xqr8uSTT2r06NEaOnRofZaJMOXv+tqyZYsOHDigMWPGeIy3aNFCffv2ra9yEWb8XV9JSUkaO3asli1bpoKCAknSpk2btGfPHrVu3bre60b4aN68ua666qpabUPGByITDUUAtfbDDz+oTZs2HmPR0dFq0aKF9u/f/5PbSTpv27Zt28rpdCozMzPwxSLs+Lu+avLFF1/IbDbX6q2suPjVZY1t2rRJH330kebMmVOfJSKM+bu+qi7NcOzYMV1//fUaOnSorrrqKi1atEgul6s+S0YYqcv564MPPlC3bt3Utm1bpaWlaciQIbr88sv1xBNP1GfJiABkfCAy8ZINALVWXFzs8cx4lZiYmJ+8KHjV1368bdXntb0hAi5O/q6vH7Pb7Xrsscf02GOPqWfPnoEsEWHO3zVWWlqqKVOm6K233qpxe0Dyf33l5eVJku6//3599NFH6tChg7Zv367Ro0fr+++/55qdkOT/+jIMQxMnTlRubq6ysrKUnJysb775RitWrFCTJk3qs2READI+EJl4hSKAWouPj1dFRcV54xUVFYqPj//J7arm/Xi76l9HZPN3fVXncrk0efJk9e/fn1de4Dz+rrGZM2fq1ltvVb9+/eqzPIQ5f9eXxWKRJE2fPl0dOnSQJF166aWaMmWKFixYoMLCwvopGGHF3/W1cuVKrVy5UnPmzFFycrIkqXfv3vrhhx9066231lu9iAxkfCAy0VAEUGtdu3ZVTk6Ox5jNZtPp06fVrVu3n9xO0nnb5uTkyGKxqFOnToEvFmHH3/VVxel06s4771STJk305z//WSaTqb5KRZjyd419/PHH+vTTTzVy5EiNHDnS/Uf4M888o5EjR+qNN96oz7IRJvxdX1VNxNTUVI/xzp07yzAMHThwIPDFIuz4u7727dsnqXI9VdelSxd9+OGHNKxRJ2R8IDLRUARQa+PGjdP27dtls9ncY5s3b5bL5dL48eO9bjdy5Eg1btxYGzdu9Bj/6quvdOWVV6px48b1VjPCh7/rS5IcDoduu+02JSYmatGiRTKbzcrPz9err75a32UjjPi7xjIzM/Xll19q7dq1Wrt2rd555x1J0iOPPKK1a9fqjjvuqO/SEQb8XV9XXnmlLBaLjh496jFe9Qd6SkpK/RSMsOLv+mrfvr2k8xs+R48eldVq5TIOqBMyPhCZaCgCqLX7779fjRs3dl/PyeFw6Pe//70mTJjgcdfTO++8UxkZGSovL5dU+XaH2bNn6+WXX9apU6ckVd40Y8OGDZo7d27DfyMISf6uL5vNpptvvlnFxcWaNGmStm3bpm3btmn9+vVaunRpUL4XhCZ/1xjgC3/XV0pKiqZNm6aXXnpJZ8+elVR5g5bXX39dkyZNOu9mB4hM/q6v8ePHKzU1Vc8884z7bajffvut3n33Xd188800FFErZHwAEjdlAeCH5s2ba+3atbr//vv197//XeXl5Ro8eLCee+45j3nl5eUqLS2VYRjusUcffVRWq1VjxoxRQkKCKioq9MEHH2jgwIEN/W0gRPm7vl577TW9//77kqRVq1Z5zB0xYkSD1I7wUJdzWJXrr79eJ0+elFT5luc33nhDb775pvttq4hcdVlf8+fP15w5czR8+HA1bdpUFRUVmjFjhh544IEG/i4QqvxdX02aNNGaNWs0e/ZsDR48WI0bN1ZBQYHuv/9+Pfroo8H4VhDCpkyZogMHDujEiRP65JNPNHLkSN1000267777JJHxAVQyGTWlZAAAAAAAAACoAW95BgAAAAAAAOAzGooAAAAAAAAAfEZDEQAAAAAAAIDPaCgCAAAAAAAA8BkNRQAAAAAAAAA+o6EIAAAAAAAAwGc0FAEAAAAAAAD4jIYiAAAAamXv3r0aMWKErrjiCl199dXKycnx+Pr+/fvVrl07nTp1KkgVAgAAoD7RUAQAAECtTJo0STNmzND69evVuXNn3Xfffe6vGYahqVOn6qmnnlJycnIQqwQAAEB9oaEIAAAAn509e1Y7d+7U2LFjJUnjx4/X559/7v76a6+9pujoaP3qV78KVokAAACoZ1HBLgAAAADhIyqqMj46HA73/61WqyTp+PHjevLJJ7V+/fqg1QcAAID6xysUAQAA4LP4+HgNGzZMS5YskSQtXbpU48ePlyTdd999evDBB9WxY8dglggAAIB6RkMRAAAAtbJ06VJ98cUXGjp0qBISEvSHP/xB77//vg4fPqwHHnhAH3/8sUaPHq3hw4frhRdekGEYwS4ZAAAAAWQySHgAAACog8LCQmVkZOj9999XfHy8MjIytHXrVrVv3159+/bVnDlzNGnSpGCXCQAAgADhFYoAAACok4cffli33nqr+vbtq08//VQ9evRQz549lZCQoOuuu04ffPBBsEsEAABAAHFTFgAAAPht/fr1WrNmjXbv3i1Jstvtslgs7q9brVbZ7fZglQcAAIB6wCsUAQAA4JeKigpNnTpVCxcuVKNGjSRJI0aM0J49e5SdnS2Hw6HPPvtMo0aNCnKlAAAACCSuoQgAAAC/PP744zp27Jj+93//12N84cKFWrRokaxWqwYMGKAFCxbIarUGqUoAAAAEGg1FAAAAAAAAAD7jLc8AAAAAAAAAfPb/WXt+Ls+gK98AAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " wandb/latest-run/files/media/images/r2m_example_1_14_f17a0d17a86ced57621b.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img_dir = \"wandb/latest-run/files/media/images\"\n", + "rmse_plots = sorted(glob.glob(os.path.join(img_dir, \"test_rmse_*.png\")))\n", + "if rmse_plots:\n", + " print(\"RMSE scorecard:\", rmse_plots[0])\n", + " display(Image(filename=rmse_plots[0]))\n", + "else:\n", + " print(\"test_rmse plot not found \u2014 check eval output above.\")\n", + "example_plots = sorted(glob.glob(os.path.join(img_dir, \"*_example_*.png\")))\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 p in example_plots[:n_show]:\n", + " print(\" \", p)\n", + " display(Image(filename=p))\n", + "else:\n", + " print(\"No prediction plots found \u2014 check eval output above.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Scaling Tips & Next Steps\n", + "\n", + "### \ud83d\udd01 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 \\\n", + " --name hierarchical \\\n", + " --hierarchical\n", + "\n", + "python -m neural_lam.train_model \\\n", + " --config_path \\\n", + " --model hi_lam \\\n", + " --graph hierarchical \\\n", + " --epochs 200\n", + "```\n", + "\n", + "### \u26a1 Enable GPU training\n", + "\n", + "Simply replace the CPU-only `torch` install with the CUDA variant and `--devices` will auto-detect your GPU:\n", + "```bash\n", + "pip install torch --index-url https://download.pytorch.org/whl/cu121\n", + "```\n", + "\n", + "### \ud83d\udce6 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 (\u226510 GB), use parallel preprocessing:\n", + "```bash\n", + "python -m mllam_data_prep \\\n", + " \\\n", + " --dask-distributed-local-core-fraction 0.5\n", + "```\n", + "\n", + "### \ud83d\udcca 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 `.\n", + "\n", + "### \ud83d\udd17 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": "myenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/neural_lam/train_model.py b/neural_lam/train_model.py index 2a9775c98..ced363d2e 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,43 @@ # 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 .models import ( + ARForecaster, + ForecasterModule, + GraphLAM, + HiLAM, + HiLAMParallel, +) from .weather_dataset import WeatherDataModule +torch.serialization.add_safe_globals( + [ + argparse.Namespace, + DatastoreSelection, + ManualStateFeatureWeighting, + NeuralLAMConfig, + OutputClamping, + TrainingConfig, + UniformFeatureWeighting, + ] +) + +MODELS = { + "graph_lam": GraphLAM, + "hi_lam": HiLAM, + "hi_lam_parallel": HiLAMParallel, +} + class AdaptiveHelpFormatter(ArgumentDefaultsHelpFormatter): """``--help`` formatter that scales the column width to the terminal.""" diff --git a/pyproject.toml b/pyproject.toml index 113329e13..138cf2969 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,11 +169,12 @@ core-metadata-version = "2.4" source = "vcs" fallback-version = "0.0.0" -[tool.hatch.build.targets.sdist] -exclude = [ - ".venv/", - "venv/", +[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.wheel] exclude = [ 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"