From df439f6941c1cfa53fed85ec472c58d9e7b4737e Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 10:23:14 +0800 Subject: [PATCH 01/14] Min Python version >= 3.9 for users & >= 3.10 for developers (#606) * Min Python version * Pass Python version to environment * Pre-release tests * Get more info * Security Fix * requires-python = ">= 3.9" in pyproject.toml * Python 3.9 Compatibility * Fix versions * Fix windows test failures * Installs the missing l3backend MiKTeX package --- .github/workflows/alltests.yml | 155 +++++++++++-- .github/workflows/unittests.yml | 205 ++++++++++++++++-- CONTRIBUTING.md | 26 ++- README.md | 4 +- docs/ci-testing.md | 28 ++- docs/mpmc-compatibility.md | 23 +- makefile | 15 ++ pyproject.toml | 24 +- .../digital_net_b2/digital_net_b2.py | 4 +- test/test_accumulate_data.py | 7 + 10 files changed, 432 insertions(+), 59 deletions(-) diff --git a/.github/workflows/alltests.yml b/.github/workflows/alltests.yml index a2b8f551c..ea8d95f42 100644 --- a/.github/workflows/alltests.yml +++ b/.github/workflows/alltests.yml @@ -8,6 +8,13 @@ on: - master workflow_dispatch: +# CodeQL "Workflow does not contain permissions": restrict the GITHUB_TOKEN to +# the minimum. These jobs only read the repo -- checkout, conda/python setup, +# caching, and tests. Codecov uploads authenticate with CODECOV_TOKEN, not the +# GITHUB_TOKEN, so no write scope is needed. +permissions: + contents: read + concurrency: # Keep push and pull_request runs separate so same-SHA PR updates do not inherit cancelled push checks. group: alltests-${{ github.event_name }}-${{ github.event.pull_request.head.repo.full_name || github.repository }}-${{ github.head_ref || github.ref_name }} @@ -68,9 +75,36 @@ jobs: - uses: conda-incubator/setup-miniconda@v3 with: miniconda-version: "latest" - auto-activate-base: true + python-version: ${{ matrix.python-version }} + channels: conda-forge + auto-activate-base: false + # Name the env explicitly: without this the active environment is + # ambiguous (base vs the auto-created `test`), which can leave pip + # and python pointing at different prefixes. + activate-environment: qmcpy-ci conda-remove-defaults: true - use-only-tar-bz2: true + + # Without python-version above, matrix.python-version reached only the job + # name and every job ran the conda base interpreter. Steps touching Python + # must use a profile-loading shell (bash -el / pwsh) to see the env. + - name: Verify interpreter matches the matrix (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: | + echo "which python : $(which python)" + echo "which pip : $(which pip)" + conda info --envs || true + python -c "import sys; print('prefix:',sys.prefix); print(sys.version)" + python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)" + + - name: Verify interpreter matches the matrix (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: | + Get-Command python | Format-List + conda info --envs + python -c "import sys; print('prefix:',sys.prefix); print(sys.version)" + python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)" # ----------------------------------------------------------- # Clean old coverage files @@ -222,18 +256,22 @@ jobs: - name: Build and cache wheels (Linux) if: runner.os == 'Linux' + shell: bash -el {0} run: | - python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch,test_umbridge] || true + python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]" || true - name: Install Python dependencies (Linux) if: runner.os == 'Linux' + shell: bash -el {0} run: | pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]" - name: Build and cache wheels (macOS) if: runner.os == 'macOS' + shell: bash -el {0} run: | - python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch] || true + python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch]" || true - name: Install Python dependencies (macOS) if: runner.os == 'macOS' + shell: bash -el {0} run: | pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch]" - name: Build and cache wheels (Windows) @@ -246,12 +284,25 @@ jobs: shell: pwsh run: | pip install --find-links ./.wheels -e '.[test,test_torch,test_gpytorch,test_botorch]' - - name: Install MPMC dependencies - run: | - qmcpy-install-mpmc - - name: Validate MPMC dependencies - run: | - python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" + - name: Install MPMC dependencies (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: qmcpy-install-mpmc + + - name: Install MPMC dependencies (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: qmcpy-install-mpmc + + - name: Validate MPMC dependencies (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" + + - name: Validate MPMC dependencies (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" # ----------------------------------------------------------- # Install minimal LaTeX required by Jupyter notebooks (OS-specific) # ----------------------------------------------------------- @@ -375,7 +426,7 @@ jobs: Invoke-WithRetry -Description "Refresh MiKTeX package database" -Script { mpm --admin --update-db } - $packages = @('latexmk','dvipng','cm-super','lmodern','type1cm','tex-gyre') + $packages = @('latexmk','dvipng','cm-super','lmodern','type1cm','tex-gyre','l3backend') foreach ($pkg in $packages) { Invoke-WithRetry -Description "Install MiKTeX package $pkg" -Script { mpm --admin --install=$pkg @@ -386,6 +437,10 @@ jobs: Invoke-WithRetry -Description "Refresh MiKTeX filename database" -Script { initexmf --admin --update-fndb } + $L3BackendPath = kpsewhich l3backend-dvips.def + if ([string]::IsNullOrWhiteSpace($L3BackendPath)) { + throw "MiKTeX install did not provide l3backend-dvips.def" + } latex --version latexmk -v dvipng --version @@ -393,12 +448,60 @@ jobs: # ----------------------------------------------------------- # Run doctests (OS-specific) # ----------------------------------------------------------- - - run: pip freeze - - run: make doctests_minimal - - run: make doctests_torch - - run: make doctests_gpytorch - - run: make doctests_botorch - - run: make doctests_markdown + - name: pip freeze (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: pip freeze + + - name: pip freeze (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: pip freeze + - name: doctests_minimal (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make doctests_minimal + + - name: doctests_minimal (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: make doctests_minimal + - name: doctests_torch (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make doctests_torch + + - name: doctests_torch (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: make doctests_torch + - name: doctests_gpytorch (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make doctests_gpytorch + + - name: doctests_gpytorch (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: make doctests_gpytorch + - name: doctests_botorch (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make doctests_botorch + + - name: doctests_botorch (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: make doctests_botorch + - name: doctests_markdown (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make doctests_markdown + + - name: doctests_markdown (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: make doctests_markdown - name: Run umbridge doctests on Linux full sweeps when Docker is available shell: bash -l {0} run: | @@ -411,12 +514,26 @@ jobs: else echo "Skipping umbridge doctests because Docker is not available on this runner" fi - - name: Run MPMC doctests + - name: Run MPMC doctests (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make doctests_mpmc + + - name: Run MPMC doctests (Windows) + if: runner.os == 'Windows' + shell: pwsh run: make doctests_mpmc # ----------------------------------------------------------- # Run unittests for Python source files # ----------------------------------------------------------- - - name: Run unittests (parallel) + - name: Run unittests (parallel, Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make unittests + + - name: Run unittests (parallel, Windows) + if: runner.os == 'Windows' + shell: pwsh run: make unittests # ----------------------------------------------------------- diff --git a/.github/workflows/unittests.yml b/.github/workflows/unittests.yml index 14342777c..1ef7bace0 100644 --- a/.github/workflows/unittests.yml +++ b/.github/workflows/unittests.yml @@ -11,6 +11,13 @@ on: - master workflow_dispatch: +# CodeQL "Workflow does not contain permissions": restrict the GITHUB_TOKEN to +# the minimum. These jobs only read the repo -- checkout, conda/python setup, +# caching, and tests. Codecov uploads authenticate with CODECOV_TOKEN, not the +# GITHUB_TOKEN, so no write scope is needed. +permissions: + contents: read + concurrency: group: unittests-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true @@ -21,23 +28,19 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: + # These versions are real: python-version is passed to + # setup-miniconda and asserted by the "Verify interpreter" step. + # Floor is 3.10 -- the `test` extra needs pytest >= 9.0.3 and + # parsl >= 2026.01.05, which both require 3.10+. Older interpreters + # run in the core-tests job below. Each version appears once; the + # full install set resolves on all three OSes for 3.10-3.14. include: - - os: macos-latest - python-version: '3.5' - - os: macos-latest - python-version: '3.8' - os: macos-latest python-version: '3.11' - os: macos-latest python-version: '3.14' - - os: ubuntu-latest - python-version: '3.6' - - os: ubuntu-latest - python-version: '3.9' - os: ubuntu-latest python-version: '3.12' - - os: windows-latest - python-version: '3.7' - os: windows-latest python-version: '3.10' - os: windows-latest @@ -48,9 +51,37 @@ jobs: - uses: conda-incubator/setup-miniconda@v3 with: miniconda-version: "latest" - auto-activate-base: true + python-version: ${{ matrix.python-version }} + channels: conda-forge + auto-activate-base: false + # Name the env explicitly: without this the active environment is + # ambiguous (base vs the auto-created `test`), which can leave pip + # and python pointing at different prefixes. + activate-environment: qmcpy-ci conda-remove-defaults: true - use-only-tar-bz2: true + + # Guards the failure mode this matrix used to have: the job name claimed a + # Python version while every job actually ran the conda base interpreter. + # Steps that touch Python must use a profile-loading shell (bash -el / pwsh) + # or they will see base rather than the activated env. + - name: Verify interpreter matches the matrix (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: | + echo "which python : $(which python)" + echo "which pip : $(which pip)" + conda info --envs || true + python -c "import sys; print('prefix:',sys.prefix); print(sys.version)" + python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)" + + - name: Verify interpreter matches the matrix (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: | + Get-Command python | Format-List + conda info --envs + python -c "import sys; print('prefix:',sys.prefix); print(sys.version)" + python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)" # ----------------------------------------------------------- # Clean old coverage files @@ -194,21 +225,25 @@ jobs: - name: Build and cache wheels (Linux) if: runner.os == 'Linux' + shell: bash -el {0} run: | - python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch,test_umbridge] || true + python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]" || true - name: Install Python dependencies (Linux) if: runner.os == 'Linux' + shell: bash -el {0} run: | pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]" - name: Build and cache wheels (macOS) if: runner.os == 'macOS' + shell: bash -el {0} run: | - python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch] || true + python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch]" || true - name: Install Python dependencies (macOS) if: runner.os == 'macOS' + shell: bash -el {0} run: | pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch]" @@ -227,5 +262,145 @@ jobs: # ----------------------------------------------------------- # Run unittests for Python source files # ----------------------------------------------------------- - - name: Run unittests (parallel) + - name: Run unittests (parallel, Unix) + if: runner.os != 'Windows' + shell: bash -el {0} run: make unittests + + - name: Run unittests (parallel, Windows) + if: runner.os == 'Windows' + shell: pwsh + run: make unittests + + # Exercise the supported 3.9 floor without the `test` extra's Python 3.10+ + # dependencies. First verify the built wheel as a user would install it; + # then run test/test_*.py against the slim `test_core` extra. Modules needing + # an optional stack skip themselves via pytest.importorskip. + # The 3.9 support claim is OS-independent, so prove it on every OS we ship + # for. qmctoolscl publishes exactly one wheel (cp312, win_amd64), so all three + # legs build it from its sdist -- which is precisely the risk being covered. + core-tests: + name: Core Unit Tests on ${{ matrix.os }} (Python ${{ matrix.python-version }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ['3.9'] + steps: + - uses: actions/checkout@v4 + + - uses: conda-incubator/setup-miniconda@v3 + with: + miniconda-version: "latest" + python-version: ${{ matrix.python-version }} + channels: conda-forge + auto-activate-base: false + activate-environment: qmcpy-core + conda-remove-defaults: true + + - name: Verify interpreter matches the matrix (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: | + echo "which python : $(which python)" + conda info --envs || true + python -c "import sys; print('prefix:',sys.prefix); print(sys.version)" + python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)" + + - name: Verify interpreter matches the matrix (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: | + conda info --envs + python -c "import sys; print('prefix:',sys.prefix); print(sys.version)" + python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)" + + - name: Build and test the user wheel (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: | + python -m pip install build + python -m build --wheel + python -m pip install dist/*.whl + python -m pip check + python -c "import os,tempfile; os.chdir(tempfile.gettempdir()); import qmcpy; print(qmcpy.__file__)" + + - name: Build and test the user wheel (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: | + python -m pip install build + python -m build --wheel + $wheel = (Get-ChildItem dist/*.whl | Select-Object -First 1).FullName + python -m pip install $wheel + python -m pip check + python -c "import os,tempfile; os.chdir(tempfile.gettempdir()); import qmcpy; print(qmcpy.__file__)" + + - name: Install qmcpy and minimal test dependencies (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: python -m pip install -e ".[test_core]" + + - name: Install qmcpy and minimal test dependencies (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: python -m pip install -e ".[test_core]" + + - name: Run core unit tests (Unix) + if: runner.os != 'Windows' + shell: bash -el {0} + run: make unittests_core + + - name: Run core unit tests (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: make unittests_core + + # Early-warning job for the next Python. 3.15.0-rc.1 is published in + # actions/python-versions but NOT in conda-forge, so this uses setup-python + # rather than setup-miniconda like the jobs above. + # + # Non-blocking by design: at time of writing scipy (a core dependency) and + # scikit-learn publish no cp315 wheels, so the install is expected to fail + # until the scientific stack catches up. The job exists to tell us the day + # that changes -- when it goes green, promote 3.15 into the `tests` matrix. + prerelease-tests: + name: Core Unit Tests (Python ${{ matrix.python-version }}, pre-release) + runs-on: ubuntu-latest + # Never gate a merge on an unreleased interpreter. + continue-on-error: true + strategy: + fail-fast: false + matrix: + python-version: ['3.15.0-rc.1'] + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + allow-prereleases: true + + - name: Report interpreter + run: python -VV + + # Step-level continue-on-error is still needed: without it a failed + # install would skip the reporting step below. + - name: Install qmcpy and minimal test dependencies + id: install + continue-on-error: true + run: pip install -e ".[test_core]" + + - name: Run core unit tests + if: steps.install.outcome == 'success' + run: make unittests_core + + - name: Report pre-release ecosystem not ready + if: steps.install.outcome != 'success' + run: | + echo "::warning title=Python ${{ matrix.python-version }} not installable::\ + qmcpy could not be installed on Python ${{ matrix.python-version }}. \ + This is expected while the scientific stack lacks cp315 wheels (scipy \ + and scikit-learn in particular). See the install log above; when this \ + job passes, promote 3.15 into the tests matrix." diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index a4dc7a59a..d3ee3a831 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -60,10 +60,7 @@ While `dev` contains the most complete set of install dependencies, a number of pip install -e ".[dev]" ~~~ -The `dev` extra includes QMCPy's PyPI-hosted MPMC dependencies. MPMC additionally -requires a platform-specific `pyg_lib` wheel that is not available from PyPI. -After installing `dev`, let the QMCPy installer select the wheel page matching -the installed PyTorch build: +The `dev` extra includes QMCPy's PyPI-hosted MPMC dependencies. MPMC additionally requires a platform-specific `pyg_lib` wheel that is not available from PyPI. After installing `dev`, let the QMCPy installer select the wheel page matching the installed PyTorch build: ~~~bash qmcpy-install-mpmc @@ -76,6 +73,27 @@ pip install -e ".[mpmc]" qmcpy-install-mpmc ~~~ +### Minimum Python Version by Role + +`requires-python` covers a bare install; the optional dependency groups in `pyproject.toml` raise it. Each row shows the strictest floor among that role's pinned dependencies. Rows marked `+` add a capability to the Application-user install; unmarked rows are self-contained role profiles. + +| Role | Install command | Binding constraint | Minimum Python | +|---|---|---|---| +| Application user | `pip install qmcpy` | QMCPy support policy | 3.9 | +| + torch / GP features | `pip install "qmcpy[torch,gpytorch]"` | inherits the QMCPy floor | 3.9 | +| + MPMC | `pip install "qmcpy[mpmc]"`, then `qmcpy-install-mpmc` | `torch >= 2.10.0` | 3.10 | +| + Bayesian optimization | `pip install "qmcpy[botorch]"` | `botorch >= 0.10.0` | 3.9 | +| Course instructor (`class`) | `pip install -e ".[class]"` | `arviz >= 0.17`, `matplotlib >= 3.9.0`, `statsmodels >= 0.14.3` | 3.9 | +| Test developer | `pip install -e ".[test]"` | `pytest >= 9.0.3`, `parsl >= 2026.01.05` | 3.10 | +| Documentation developer | `pip install -e ".[docs]"` | inherits `test`; `pylint >= 4.0.5` | 3.10 | +| Release / core developer | `pip install -e ".[dev]"` | inherits `docs` / `test` | 3.10 | + +Using `qmcpy` needs Python **3.9+**; contributing code, running tests, or building docs needs **3.10+**. We recommend 3.13 for development. + +Python 3.9 is a deliberate QMCPy **support-policy floor**, not a claim about source syntax or `qmctoolscl`'s declared floor. It is the oldest interpreter whose current runtime stack QMCPy commits to support and test; earlier versions are outside that policy even if a particular toolchain can install them. + +CI measures the lower tier rather than assuming it: `unittests.yml`'s `core-tests` job builds the QMCPy wheel on Python 3.9 on Linux, macOS, and Windows, installs it with no extras, checks its dependencies, and imports it from outside the source tree. The 3.9 claim is OS-independent, and `qmctoolscl` ships only one wheel (cp312, `win_amd64`), so every leg builds it from its source distribution. It then runs `make unittests_core` with the slim `test_core` extra and no notebook stack. Its main `tests` job runs the full suite on 3.10-3.14, each version on one operating system. Every conda matrix asserts the running interpreter before any test runs. Test modules self-skip via `pytest.importorskip` when an optional stack (torch, gpytorch, PyG) is absent, so each interpreter runs what applies to it. + ## 📚 Using `qmcpy` In Courses (`class` Extra) `qmcpy` provides a `class` optional dependency group that installs a complete teaching environment (JupyterLab, plotting, statistics, and utilities) in addition to `qmcpy` itself. diff --git a/README.md b/README.md index b55375193..5d31f0817 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,8 @@ The [QMCPy documentation](https://QMCSoftware.github.io/QMCSoftware/) contains a pip install qmcpy ``` +Requires Python >= 3.9. Contributing code, running tests, or building the documentation requires Python >= 3.10 — see the [Minimum Python Version by Role](https://qmcsoftware.github.io/QMCSoftware/CONTRIBUTING/#minimum-python-version-by-role) table in the contributing guidelines for the full breakdown. + To install from source, please see the [contributing guidelines](https://qmcsoftware.github.io/QMCSoftware/CONTRIBUTING/). ## Citation @@ -64,4 +66,4 @@ Want to contribute to QMCPy? Please see our [guidelines for contributors](https: This software would not be possible without the efforts of the [QMCPy community](https://qmcsoftware.github.io/QMCSoftware/community) including our steering council, collaborators, contributors, and sponsors. -QMCPy is distributed under an [Apache 2.0 license from the Illinois Institute of Technology](https://github.com/QMCSoftware/QMCSoftware/blob/master/LICENSE). \ No newline at end of file +QMCPy is distributed under an [Apache 2.0 license from the Illinois Institute of Technology](https://github.com/QMCSoftware/QMCSoftware/blob/master/LICENSE). diff --git a/docs/ci-testing.md b/docs/ci-testing.md index 5f33765b4..97956fdb0 100644 --- a/docs/ci-testing.md +++ b/docs/ci-testing.md @@ -6,9 +6,11 @@ This page summarizes QMCPy's current GitHub Actions CI layout. | Workflow | Trigger | Runner / Python | Main work | |---|---|---|---| -| `alltests.yml` | Feature-branch `push` | `ubuntu`, Python `3.13` | | -| `alltests.yml` | `push` to `develop` or `master`; PR into `develop` or `master`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.13` | | -| `unittests.yml` | `push` to `develop` or `master`; PR into `develop` or `master`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.5` to `3.14` | | +| `alltests.yml` | Feature-branch `push` | `ubuntu`, Python `3.13` | | +| `alltests.yml` | `push` to `develop` or `master`; PR into `develop` or `master`; branch name ending in `choi`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.13` | | +| `unittests.yml` (`tests` job) | `push` to `develop` or `master`; PR into `develop` or `master`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.10` to `3.14` | | +| `unittests.yml` (`core-tests` job) | same as above | `ubuntu`, `macos`, `windows`; Python `3.9` | | +| `unittests.yml` (`prerelease-tests` job) | same as above | `ubuntu`; Python `3.15.0-rc.1` | | | `docs.yml` | `push` to `master` | `ubuntu`, Python `3.13` | | | `pep8.yml` | `push` to `develop` or `master`; `workflow_dispatch` | `ubuntu`, Python `3.13` | | | `pypi-stats.yml` | Weekly schedule; `workflow_dispatch` | `ubuntu`, Python `3.13` | | @@ -18,13 +20,29 @@ There is no nightly CI schedule. ## Policy - Linux is the default feedback path and runs on every push. -- macOS and Windows in `alltests.yml` are reserved for `develop`/`master` pushes, pull requests into those branches, and manual runs. +- macOS and Windows in `alltests.yml` are reserved for `develop`/`master` pushes, pull requests into those branches, branches whose name ends in `choi`, and manual runs. - `concurrency` cancels superseded runs in both workflows; in `alltests.yml`, `push` and `pull_request` use separate groups so a PR does not inherit cancelled sibling checks from a same-SHA push. -- `alltests.yml` pins Miniconda base Python to `3.13`; `unittests.yml` still uses the base environment without explicitly passing `matrix.python-version` into `setup-miniconda`. +- Both `unittests.yml` and `alltests.yml` pass `matrix.python-version` to `setup-miniconda` and assert the running interpreter before any test runs, so their version labels are real. Steps that touch Python use a profile-loading shell (`bash -el {0}` on Unix, `pwsh` on Windows); the default non-login shell silently falls back to the conda base interpreter, which is how these matrices previously went green without testing the versions they named. - Booktests are skipped on feature-branch pushes and run only in the full sweep. +- `unittests.yml` is tiered: `tests` installs the full `test` extra (needing Python `3.10`+ via `pytest >= 9.0.3` and `parsl >= 2026.01.05`), `core-tests` verifies the built no-extra wheel before installing the slim `test_core` extra, and `prerelease-tests` looks ahead to the next interpreter. Test modules self-skip through `pytest.importorskip` when an optional stack is missing. +- The pre-release tier is informational and never gates a merge. Promote a version out of it into the `tests` matrix once the job passes; `Programming Language :: Python :: 3.15` is deliberately **not** in `pyproject.toml` classifiers until then. - UMBridge doctests run only on Linux full sweeps with Docker available. +- MPMC steps in `alltests.yml` are **not** OS-gated: they run on every OS the matrix selects. See [MPMC Coverage by OS](#mpmc-coverage-by-os). - `workflow_dispatch` means manually triggered workflow. +## MPMC Coverage by OS + +MPMC needs a platform-specific `pyg_lib` wheel that PyPI does not carry, installed separately by `qmcpy-install-mpmc`. Only `alltests.yml` does that, and its MPMC steps carry no `if: runner.os` condition, so they run on every OS the matrix selects. + +| Workflow / trigger | Python | Ubuntu | macOS | Windows | +|---|---|---|---|---| +| `alltests.yml`, full sweep | `3.13` | Run | Run | Run | +| `alltests.yml`, feature-branch `push` | `3.13` | Run | Not in matrix | Not in matrix | +| `unittests.yml` (`tests`) | `3.10`-`3.14` | Skipped | Skipped | Skipped | +| `unittests.yml` (`core-tests`) | `3.9` | Skipped | Skipped | Skipped | + +"Run" covers both the MPMC doctests (`make doctests_mpmc`) and the MPMC unit tests in `test/test_dd_mpmc.py`. `unittests.yml` never calls `qmcpy-install-mpmc`, so those tests skip there via `pytest.importorskip("pyg_lib")` and its jobs pass without exercising MPMC — treat `alltests.yml` as the only source of MPMC signal. See [mpmc-compatibility.md](mpmc-compatibility.md) for the version-support policy behind this split. + ## Related Docs - [tests.md](tests.md): local Makefile targets and coverage commands. diff --git a/docs/mpmc-compatibility.md b/docs/mpmc-compatibility.md index 92d6f1526..ebe1939c9 100644 --- a/docs/mpmc-compatibility.md +++ b/docs/mpmc-compatibility.md @@ -7,7 +7,7 @@ - Treat MPMC as an optional feature, not part of the minimum QMCPy dependency set. - Prefer `pyg_lib` plus `torch-geometric`; do not require `torch-cluster` as a separate dependency. - For reproducible local work and future CI pinning, prefer a modern PyTorch line with matching `data.pyg.org` wheels installed by `qmcpy-install-mpmc`. -- Keep older Python jobs in `unittests.yml` for core QMCPy coverage, but do not require them to run MPMC. +- `unittests.yml` runs the full suite on `3.10`-`3.14` plus a slim `core-tests` tier on `3.9` (see [Minimum Python Version by Role](CONTRIBUTING.md#minimum-python-version-by-role)); neither installs MPMC. ## Support Policy @@ -17,7 +17,8 @@ | `3.13` | Target | Supported | `torch >= 2.10`, `torch-geometric >= 2.6.1`, `pyg_lib >= 0.6.0` | Run MPMC doctests and unit tests | | `3.12` | Target | Supported | `torch >= 2.10`, `torch-geometric >= 2.6.1`, `pyg_lib >= 0.6.0` | Run MPMC doctests and unit tests | | `3.10` to `3.11` | Best effort | Not a release blocker for MPMC | May work with matching PyTorch / PyG wheels, but not required by current CI policy | Optional manual testing only | -| `3.5` to `3.9` | Legacy core-package coverage only | Not supported for MPMC | Do not spend CI budget trying to keep MPMC running here | No MPMC doctests or unit tests | + +Python `3.9` is covered only by the slim `core-tests` tier, which never installs MPMC's PyTorch Geometric stack (see [Minimum Python Version by Role](CONTRIBUTING.md#minimum-python-version-by-role)). The distinction is intentional: @@ -26,27 +27,25 @@ The distinction is intentional: ## CI Policy -The current CI split should be: +The current CI split is: + +- `alltests.yml`: the only workflow that installs the MPMC stack (`qmcpy-install-mpmc`) and runs `make doctests_mpmc` plus the MPMC unit tests, on Python `3.13`. The steps are not OS-gated: Ubuntu alone on feature-branch pushes, all three OSes on full sweeps. +- `unittests.yml`: `3.10`-`3.14` on all three OSes, plus a `core-tests` tier on Ubuntu for `3.9`. Neither calls `qmcpy-install-mpmc`, so `test/test_dd_mpmc.py` skips throughout via `pytest.importorskip("pyg_lib")`. This workflow gives **no** MPMC coverage. -- `alltests.yml`: full-sweep validation on Linux, macOS, and Windows for Python `3.13`, including `make doctests_mpmc` and the standard unit-test suite. -- `unittests.yml`: a broader version sampler for the repository, with explicit MPMC jobs on Python `3.12`, `3.13`, and `3.14`. -- Older `unittests.yml` jobs: keep them for core QMCPy regressions, but do not require MPMC there. +See [MPMC Coverage by OS](ci-testing.md#mpmc-coverage-by-os) for the per-operating-system breakdown. -This gives one place to enforce modern MPMC compatibility without forcing the entire repository to abandon older Python jobs immediately. +This keeps MPMC enforcement in one place. The trade-off: MPMC regressions are invisible to `unittests.yml`, so raising MPMC coverage means adding a job to `alltests.yml`, not widening the `unittests.yml` matrix. ## Local Developer Commands -Install the usual test and MPMC extras first, then add the platform-specific -PyG runtime with QMCPy's installed helper command: +Install the usual test and MPMC extras first, then add the platform-specific PyG runtime with QMCPy's installed helper command: ```bash python -m pip install -e ".[test,test_torch,test_gpytorch,test_botorch,mpmc]" qmcpy-install-mpmc ``` -The `mpmc` extra contains dependencies available from PyPI. The helper handles -`pyg_lib` separately because its wheel page depends on the installed PyTorch -version and accelerator build, which standard project metadata cannot select. +The `mpmc` extra contains dependencies available from PyPI. The helper handles `pyg_lib` separately because its wheel page depends on the installed PyTorch version and accelerator build, which standard project metadata cannot select. Then run the MPMC-specific checks: diff --git a/makefile b/makefile index 57e4f66e6..c81bea6df 100644 --- a/makefile +++ b/makefile @@ -122,6 +122,21 @@ unittests: ensure_artifacts --no-header \ test/ -W ignore::DeprecationWarning +# Core unit tests only: skips test/booktests/ (needs the notebook stack); other +# modules self-skip via pytest.importorskip. Pairs with the `test_core` extra so +# interpreters at the `requires-python` floor can run this. Unlike `unittests` +# this omits -x: on a compatibility run the full list of failures is the point. +unittests_core: ensure_artifacts + @mkdir -p $(UNIT_COV_DIR) + COVERAGE_FILE=$(UNIT_COV_DIR)/.coverage \ + python -m pytest $(PYTEST_XDIST) $(PYTEST_EXTRA_ARGS) \ + --cov=qmcpy \ + --cov-report term \ + --cov-report json:$(UNIT_COV_DIR)/coverage.json \ + --no-header -rs \ + --ignore=test/booktests \ + test/ -W ignore::DeprecationWarning + tests_no_docker_no_mpmc: doctests_no_docker_no_mpmc unittests coverage ########################################################## diff --git a/pyproject.toml b/pyproject.toml index dac48d235..570ba971d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,6 +27,14 @@ classifiers= [ "Development Status :: 5 - Production/Stable", "Intended Audience :: Science/Research", "Programming Language :: Python :: 3", + # Keep these aligned with `requires-python` and the tested interpreter + # matrix. See CONTRIBUTING.md. + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", "Topic :: Scientific/Engineering :: Mathematics", ] readme = "README.md" @@ -45,7 +53,9 @@ keywords=[ ] license = {file = "LICENSE"} dynamic = ["version"] -requires-python = ">= 3.5" +# Deliberate QMCPy support-policy floor, not a source-language or transitive +# dependency floor. CI verifies the built wheel on 3.9; see CONTRIBUTING.md. +requires-python = ">= 3.9" dependencies = [ "numpy >= 1.17.0", "scipy >= 1.1.0", @@ -92,6 +102,18 @@ test = [ "nbconvert >= 7.2.9", "pytest-xdist >= 3.8.0", ] +# Minimal set for `make unittests_core` (test/test_*.py only). Omits the +# notebook/booktest stack (parsl, testbook, ...) whose 3.10 floor would +# otherwise force every unit-test job onto 3.10+, so CI can exercise the +# published `requires-python` floor. See CONTRIBUTING.md. +test_core = [ + "pytest >= 7.0", + "pytest-cov >= 4.0", + "pytest-xdist >= 3.0", + "scikit-learn >= 1.0.0", + "pandas >= 1.3.0", + "pyyaml >= 6.0", + ] test_torch = [ "torch >= 2.7.0, < 2.13", # kept in sync with the mpmc extra: PyG pyg_lib wheels stop at torch 2.12 ] diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py index 0a463507f..89887d578 100644 --- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py +++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py @@ -323,6 +323,8 @@ def __init__( repos = DataSource() if repos.exists(local_root + generating_matrices): datafile = repos.open(local_root + generating_matrices) + elif repos.exists(generating_matrices): + datafile = repos.open(generating_matrices) elif repos.exists( "https://raw.githubusercontent.com/QMCSoftware/LDData/refs/heads/main/dnet/" + generating_matrices @@ -354,8 +356,6 @@ def __init__( "https://raw.githubusercontent.com/QMCSoftware/" + generating_matrices ) - elif repos.exists(generating_matrices): - datafile = repos.open(generating_matrices) else: raise ParameterError("LDData path %s not found" % generating_matrices) contents = [line.rstrip("\n").strip() for line in datafile.readlines()] diff --git a/test/test_accumulate_data.py b/test/test_accumulate_data.py index 8de9d3ebd..dc17f4f13 100644 --- a/test/test_accumulate_data.py +++ b/test/test_accumulate_data.py @@ -2,8 +2,15 @@ from unittest.mock import patch import numpy as np +import pytest from qmcpy import CubBayesNetG, DigitalNetB2, Keister + +# `pf_gp_ci` imports torch and gpytorch at module level, so skip rather than fail +# collection where those optional stacks are absent (as test_dd_mpmc.py does). +pytest.importorskip("torch") +pytest.importorskip("gpytorch") + from qmcpy.stopping_criterion.pf_gp_ci import PFGPCIData From d8fec0037fa2e4af8479ec15a4498e55f1453cf5 Mon Sep 17 00:00:00 2001 From: Joshua Herman <30265+zitterbewegung@users.noreply.github.com> Date: Wed, 2 Sep 2026 21:32:15 -0500 Subject: [PATCH 02/14] Update demo notebook dependencies and initialization cells (#531) * Update demo notebook initialization cells * Notebooks have been moved * Add Colab dependency install cells * Fix Colab notebook install cells * Fix spelling in Colab notebooks * Remove unused os import from Colab cells * Use capture for Colab install output * Automating Colab/notebook consistency * Update * Update makefile * Add make target for Colab bootstrap classification * Debugged `harden_colab_notebook.py` and add unit tests for badge handling * Add branch notebook execution script * Skip Colab bootstrap during branch notebook execution * Download Dakota Genz points in notebook * Remove Dakota Genz generation fallback * Use gdown for Dakota Genz data download * Add local notebook execution script * Comment out gdown in Dakota notebook * Fix Windows notebook CI LaTeX setup * Address Colab readiness review feedback * Reconcile Colab tooling with develop * Refresh safe Colab bootstrap cells * Preserve notebook serialization during hardening * Better Colab notebook handling: more dependencies support and improved smoke tests * Fix CodeQL check errors * Add title to notebook and update kernel name and version * Fix errors after manually testing in Google Colab * Fix problems after manually running in Google Colab * Minor enhancements * Fix colab error * Fix typo * Simplify Colab smoke tests: drop dead PR scoping, fix diagnostics * Add harden_colab_notebook to format target * Add tools to open in Colab (for developers) * Attempt to fix Colab errors * Correct Colab notebook manifest and build process * Fix unit test failure --------- Co-authored-by: sou-cheng-choi --- .github/workflows/alltests.yml | 9 + .gitignore | 1 + CONTRIBUTING.md | 10 +- demos/DAKOTA_Genz/dakota_genz.ipynb | 49 +- demos/GBM/gbm_demo.ipynb | 294 +++++---- demos/GBM/gbm_examples.ipynb | 42 +- demos/acceptance_rejection.ipynb | 22 +- demos/asian-option-mlqmc.ipynb | 30 +- demos/brownian_bridge.ipynb | 27 +- demos/control_variates.ipynb | 26 +- demos/copula_examples.ipynb | 25 + .../Iteration_Log_Tolerance_Demo.ipynb | 27 +- .../accuracy_and_resume.ipynb | 34 ++ demos/demo_resume_data/resume_examples.ipynb | 36 +- demos/digital_net_b2.ipynb | 25 +- demos/elliptic-pde.ipynb | 39 +- .../gaussian_diagnostics_demo.ipynb | 20 +- demos/iris.ipynb | 25 +- ...obov_hammersley_latinhypercube_demos.ipynb | 27 +- demos/lattice_random_generator.ipynb | 25 +- demos/lebesgue_integration.ipynb | 18 +- demos/linear-scrambled-halton.ipynb | 25 +- demos/nei_demo.ipynb | 27 +- demos/plot_proj_function.ipynb | 25 +- demos/pricing_options.ipynb | 23 + demos/product_measure.ipynb | 25 + demos/qei-demo-for-blog.ipynb | 23 + demos/qmcpy-logo.ipynb | 25 + demos/qmcpy_intro.ipynb | 20 +- demos/quickstart.ipynb | 32 +- demos/ray_tracing.ipynb | 23 + demos/sample_scatter_plots.ipynb | 23 + .../scipywrapper_demo.ipynb | 25 + demos/some_true_measures.ipynb | 23 + demos/statistics_for_TrueMeasure.ipynb | 25 + .../talk_paper_demos/JOSS2026/joss2026.ipynb | 33 +- .../MCQMC_2020_QMC_Software_Tutorial.ipynb | 26 +- .../Parslfest_2025/01_sequential.ipynb | 46 +- .../Parslfest_2025/02_parallel.ipynb | 45 +- .../Parslfest_2025/03_visualize_speedup.ipynb | 34 ++ .../output/01_sequential_output.ipynb | 37 ++ demos/talk_paper_demos/Parslfest_2025/util.py | 2 +- .../sorokin_thesis_2025.ipynb | 25 +- ..._LD_seq_QMC_fast_kernel_methods_2026.ipynb | 30 +- demos/talk_paper_demos/pydata_chi_2023.ipynb | 27 +- .../why_add_q_to_mc_blog.ipynb | 25 + demos/vectorized_qmc.ipynb | 36 +- demos/vectorized_qmc_bayes.ipynb | 36 +- docs/tests.md | 91 ++- makefile | 84 +++ scripts/__init__.py | 1 + scripts/check_colab_notebooks.py | 567 ++++++++++++++++++ scripts/colab_notebooks_manifest.json | 57 ++ scripts/harden_colab_notebook.py | 503 ++++++++++++++++ scripts/report_colab_notebook_patterns.py | 164 +++++ scripts/smoke_test_colab_notebooks.py | 379 ++++++++++++ test/README.md | 89 ++- test/booktests/__init__.py | 19 +- test/test_colab_notebooks.py | 314 ++++++++++ 59 files changed, 3549 insertions(+), 276 deletions(-) create mode 100644 scripts/__init__.py create mode 100644 scripts/check_colab_notebooks.py create mode 100644 scripts/colab_notebooks_manifest.json create mode 100644 scripts/harden_colab_notebook.py create mode 100644 scripts/report_colab_notebook_patterns.py create mode 100644 scripts/smoke_test_colab_notebooks.py create mode 100644 test/test_colab_notebooks.py diff --git a/.github/workflows/alltests.yml b/.github/workflows/alltests.yml index ea8d95f42..97486f78f 100644 --- a/.github/workflows/alltests.yml +++ b/.github/workflows/alltests.yml @@ -304,6 +304,15 @@ jobs: shell: pwsh run: python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" # ----------------------------------------------------------- + # Colab readiness tests (Linux only) + # ----------------------------------------------------------- + - name: Run Colab readiness tests (Linux) + if: runner.os == 'Linux' + shell: bash -l {0} + run: | + make check_colab_notebooks + make check_colab_notebooks_smoke + # ----------------------------------------------------------- # Install minimal LaTeX required by Jupyter notebooks (OS-specific) # ----------------------------------------------------------- - name: Install minimal LaTeX (Linux) diff --git a/.gitignore b/.gitignore index 5c4b0f3c8..9fae76cab 100644 --- a/.gitignore +++ b/.gitignore @@ -39,6 +39,7 @@ demos/prob_failure_gp_ci_plots/ demos/fgpr_figs/ demos/GBM/images/*.png demos/GBM/outputs/*.* +*.tmp_colab* # Generated notebook/demo images figures/ diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d3ee3a831..486686ac7 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -226,12 +226,18 @@ In the built HTML documentation: ## Demos -Demos are Jupyter notebooks which may be launched using the command +Demos are Jupyter notebooks under `demos/`. To open one: ~~~bash -jupyter-lab +jupyter-lab # or: make open_notebook NOTEBOOK=demos/quickstart.ipynb +make open_colab_notebook NOTEBOOK=demos/quickstart.ipynb # in Colab, from your current (pushed) branch +make open_colab_notebook_gist NOTEBOOK=demos/quickstart.ipynb # in Colab, from your uncommitted working copy (needs the gh CLI) ~~~ +`open_colab_notebook` uses the branch version only when the notebook is new or differs from `develop`, otherwise the `develop` version. See [docs/tests.md](docs/tests.md) for details. + +Note: `make format` runs `make harden_colab_notebook`, so it will insert a Colab badge and bootstrap cell into any unclassified `demos/*.ipynb` and add it to `scripts/colab_notebooks_manifest.json` (and fail if a notebook cannot be hardened automatically). + ## Other Developer Tools The [Developers Tools](https://qmcpy.org/references-for-python-and-mathematical-software-development/) page on [qmcpy.org](https://qmcpy.org) documents additional tools we have found helpful for mathematical software development and presentation. diff --git a/demos/DAKOTA_Genz/dakota_genz.ipynb b/demos/DAKOTA_Genz/dakota_genz.ipynb index ea83ae0fd..77830a313 100644 --- a/demos/DAKOTA_Genz/dakota_genz.ipynb +++ b/demos/DAKOTA_Genz/dakota_genz.ipynb @@ -14,12 +14,28 @@ }, { "cell_type": "markdown", - "id": "385fe7c1-64b4-46a2-a7de-8599511b83da", - "metadata": { - "id": "385fe7c1-64b4-46a2-a7de-8599511b83da" - }, + "id": "6952b7c0", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/DAKOTA_Genz/dakota_genz.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fadab1b", + "metadata": {}, + "outputs": [], "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/dakota_genz.ipynb)" + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n" ] }, { @@ -75,7 +91,7 @@ "kinds_func = ['oscillatory','corner-peak']\n", "kinds_coeff = [1,2,3]\n", "ds = 2**arange(8)\n", - "ns = 2**arange(7,19)\n", + "ns = 2**arange(7, 13 if IN_COLAB else 19) # smaller sweep on Colab\n", "ds" ] }, @@ -240,7 +256,7 @@ "# takes about 5.5 min to run for me\n", "ref_sols = {}\n", "print('logging: ',end='',flush=True)\n", - "x_full = DigitalNetB2(ds.max(),seed=7).gen_samples(2**22)\n", + "x_full = DigitalNetB2(ds.max(),seed=7).gen_samples(2**16 if IN_COLAB else 2**22) # 2**22 needs ~4 GB RAM\n", "for kind_func in kinds_func:\n", " for kind_coeff in kinds_coeff:\n", " tag = '%s.%d'%(kind_func,kind_coeff)\n", @@ -275,10 +291,19 @@ } ], "source": [ + "if not os.path.isfile(\"x_full_dakota.txt\"):\n", + " try:\n", + " import gdown\n", + " gdown.download(\"https://drive.google.com/uc?id=1ljmpq3w5L4OjjdinAMSLhXBeWGW6EJ3U\", \"x_full_dakota.txt\", quiet=True)\n", + " except Exception as e:\n", + " print(f\"Auto-download of x_full_dakota.txt failed ({e}); the Dakota comparison will be skipped.\")\n", + "\n", "if os.path.isfile(\"x_full_dakota.txt\"):\n", " x_full_dakota = np.loadtxt(\"x_full_dakota.txt\")\n", "else:\n", - " print(\"please download Dakota's Halton points from https://drive.google.com/uc?id=1ljmpq3w5L4OjjdinAMSLhXBeWGW6EJ3U\")\n", + " x_full_dakota = None # data file absent (e.g. Colab); Dakota comparison skipped\n", + " print(\"x_full_dakota.txt not found; skipping the Dakota Halton comparison.\")\n", + " print(\"To include it, download https://drive.google.com/uc?id=1ljmpq3w5L4OjjdinAMSLhXBeWGW6EJ3U into this folder.\")\n", " # with tempfile.TemporaryDirectory() as tmp:\n", " # with open(os.path.join(tmp, \"dakota.in\"), \"w\") as io:\n", " # io.write(f\"environment\\\n", @@ -311,7 +336,8 @@ " # x_full_dakota.append([float(lines[n + 1 + j].split()[0]) for j in range(ds.max())])\n", " # x_full_dakota = np.vstack(x_full_dakota)\n", " # np.savetxt(\"data/x_full_dakota.txt\",x_full_dakota)\n", - "print(x_full_dakota.shape)" + "if x_full_dakota is not None:\n", + " print(x_full_dakota.shape)" ] }, { @@ -329,8 +355,9 @@ " 'Lattice (random shift)': Lattice(d_max).gen_samples(n_max),\n", " 'Digital Net (random scramble + shift)': DigitalNetB2(d_max).gen_samples(n_max),\n", " 'Halton (QMCPy)': Halton(d_max).gen_samples(n_max,warn=False),\n", - " 'Halton (Dakota)': x_full_dakota[:n_max,:d_max]\n", - "}" + "}\n", + "if x_full_dakota is not None:\n", + " pts['Halton (Dakota)'] = x_full_dakota[:n_max,:d_max]" ] }, { diff --git a/demos/GBM/gbm_demo.ipynb b/demos/GBM/gbm_demo.ipynb index 5199aa087..7cbaf6415 100644 --- a/demos/GBM/gbm_demo.ipynb +++ b/demos/GBM/gbm_demo.ipynb @@ -7,13 +7,6 @@ "# Geometric Brownian Motion Demo" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gbm_demo.ipynb)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -32,9 +25,45 @@ "- Random seeds: 42 (QMCPy), 7 (QuantLib)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_demo.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/GBM\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " !pip install -q qmcpy\n", + " !pip install -q ipywidgets QuantLib\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n", + " extra_path = f\"{repo_root}/demos/GBM/gbm_code\"\n", + " if extra_path not in sys.path:\n", + " sys.path.insert(0, extra_path)\n" + ] + }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -78,7 +107,7 @@ "os.makedirs('images', exist_ok=True)\n", "\n", "# Toggle debug mode\n", - "cf.is_debug = False" + "cf.is_debug = IN_COLAB # use the smaller parameter sweep on Colab's limited runtime" ] }, { @@ -121,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -130,14 +159,24 @@ "text": [ "Help on function __init__ in module qmcpy.true_measure.geometric_brownian_motion:\n", "\n", - "__init__(self, sampler, t_final=1, initial_value=1, drift=0, diffusion=1, decomp_type='PCA', lazy_load=True, lazy_decomp=True)\n", + "__init__(\n", + " self,\n", + " sampler,\n", + " t_final=1,\n", + " initial_value=1,\n", + " drift=0,\n", + " diffusion=1,\n", + " decomp_type='PCA',\n", + " lazy_load=True,\n", + " lazy_decomp=True\n", + ")\n", " Args:\n", " sampler (DiscreteDistribution/TrueMeasure): A discrete distribution or true measure.\n", " t_final (float): End time for the geometric Brownian motion, non-negative.\n", " initial_value (float): Positive initial value of the process, $S_0$.\n", " drift (float): Drift coefficient $\\gamma$.\n", " diffusion (float): Positive diffusion coefficient $\\sigma^2$, where $\\sigma$ is volatility.\n", - " decomp_type (str): Method of decomposition, either \"PCA\" or \"Cholesky\".\n", + " decomp_type (str): Method of decomposition, either \"PCA\", \"Cholesky\", or \"BrownianBridge\".\n", " lazy_load (bool): If True, defer GBM-specific computations until needed.\n", " lazy_decomp (bool): If True, defer expensive matrix decomposition until needed.\n", "\n" @@ -150,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -159,7 +198,14 @@ "text": [ "Help on function gen_samples in module qmcpy.true_measure.geometric_brownian_motion:\n", "\n", - "gen_samples(self, n=None, n_min=None, n_max=None, return_weights=False, warn=True) -> Union[numpy.ndarray, Tuple[numpy.ndarray, numpy.ndarray]]\n", + "gen_samples(\n", + " self,\n", + " n=None,\n", + " n_min=None,\n", + " n_max=None,\n", + " return_weights=False,\n", + " warn=True\n", + ") -> Union[numpy.ndarray, Tuple[numpy.ndarray, numpy.ndarray]]\n", " Generate GBM samples using the parent's transform pipeline.\n", "\n", " Args:\n", @@ -188,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -204,7 +250,7 @@ " decomp_type PCA" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -216,7 +262,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -228,7 +274,7 @@ " [0.619371 , 0.31898397]])" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -255,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -282,7 +328,7 @@ " decomp_type PCA" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -329,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -373,12 +419,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -388,7 +434,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -414,12 +460,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -448,12 +494,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -475,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -533,13 +579,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "94b59bbda4a549769e9b6fd0fde33b1f", + "model_id": "24ea5c51fdde42e5a790a7bc459f3009", "version_major": 2, "version_minor": 0 }, @@ -578,7 +624,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -598,7 +644,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -790,9 +836,8 @@ "6 21.2361 " ] }, - "execution_count": 16, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -828,7 +873,7 @@ "#======= Parameters for GBM comparison\n", "results_data = []\n", "params_ql = {'initial_value': 100, 'mu': 0.05, 'sigma': 0.2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'seed': cf.QUANTLIB_SEED}\n", - "params_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'replications': 3}\n", + "params_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**10 if IN_COLAB else 2**14, 'replications': 3}\n", "theoretical_mean, theoretical_std = calculate_theoretical_statistics(params_ql)\n", "\n", "# Add theoretical values once\n", @@ -879,7 +924,7 @@ "\n", "# Create DataFrame\n", "results_df = pd.DataFrame(results_data)\n", - "results_df.round(4)\n", + "display(results_df.round(4))\n", "\n", "# Store variables for visualization cell (extract individual values from params)\n", "paths, qmcpy_paths = quantlib_paths, qmcpy_paths\n", @@ -892,12 +937,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABEwAAAMgCAYAAAA5kPcVAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qe8ZVV1P/A9BRBpihQFwS7YRcQGKraoRMVeYy8xsSUmxphEE42J0RijRvNXI2ps0dgVW7BiQ1CkitIFKQLSBBxgZt7/8z1n1pv9zpxbXpt5Zf0+nztz373n7rP32vvstdZvr732iomJiYmSSCQSiUQikUgkEolEIpGYxMqNbxOJRCKRSCQSiUQikUgkEkmYJBKJRCKRSCQSiUQikUj0ICNMEolEIpFIJBKJRCKRSCQ6SMIkkUgkEolEIpFIJBKJRKKDJEwSiUQikUgkEolEIpFIJDpIwiSRSCQSiUQikUgkEolEooMkTBKJRCKRSCQSiUQikUgkOkjCJJFIJBKJRCKRSCQSiUSigyRMEolEIpFIJBKJRCKRSCQ6SMIkkUgkEolEIpFIJBKJRKKDJEwSiUQikUgkEolEIpFIJDpIwiSRSCQSiUQikUgkEolEooMkTBKJRCKRSCQSiUQikUgkOkjCJJFIJBKJRCKRSCQSiUSigyRMEolEIpFIJBKJAfjXf/3XsmLFinLjG9+4XH311ZtFTs95znOae3p95zvfmdOylRdlu0/gn/7pn5rPdt99983WzuWO6Idb3vKWS3o8D8J1111XXvva15bb3OY2Zauttmrq9djHPnaL1inRj4997GNN/9zgBjcov/71r5eVmJIwSSxqnH322ZPK5uCDD578/B/+4R8mP//Qhz406/v84R/+YVPWwx72sLK5QHlGG+Yag+SjfT7T3sT8Y5DROt/YEuN5EC688MLyR3/0R2WPPfYoK1eubOr19re/fUtXK9GDF77whU3/3OUudykTExMpoyWE3/zmN+U1r3lNudvd7lZ22GGHsu2225Zb3/rWzbz0s5/9bOjc5XWjG92o/P73v59yzbXXXlt23XXXKdd97Wtf26Qshvdf/dVfNffecccdy3bbbVfucIc7lGc/+9nlm9/8Zq/eql877bRTOfDAA8thhx02L+PyqquuKm95y1ua9y94wQua+tX46Ec/Wg466KCm7ttss0252c1uVu55z3uWF73oReWoo44qiwkvfvGLm76/6KKLyrve9a5p//4rX/lKedKTnlT23nvvxqnikN/xjndsPuNs1c55X3+uXr267LbbbuUhD3lII9dhdpHXxz/+8U2uednLXjblmqc+9anTIqfiRR/tvPPOTV0++9nPlpni85//fNNWLzbrlsaw8cyO7nvGBtminvF//ud/bvpYf9/kJjdpyI5jjz127Pq87W1vK2984xvLmWeeWdauXVsWKz74wQ8243zPPfccKrMaJ510UmP/+I25w9i///3vX97//vdPue4v/uIvyn3ve99y05vetGy99dZl++23b/SwOfuyyy7bpFzzzuMf//jGrkJC3fCGN2yuR0z97ne/G1gfv1u1atXAZ+fJT35yU6Z+R64uK0wkFi0uvPDCib/+67+euOtd7zqx/fbbT9zgBjeYuNWtbjXx7Gc/e+LYY4+dWMj42c9+NvH3f//3zevb3/72Jt9rg+Hp5ZpBOOussyave+ADHzj5ud/E5x/84AdnVdcf/ehHk2UdfvjhU7675pprJl7/+tdP3PGOd2zkv+22207stddeTV1e+cpXTpx//vkzvu8tbnGLyfvONQbJ58tf/vLk50cdddS0yvz9738/8f/+3/+beOhDHzqx6667Tmy11VYTu+2228Td7373iT/+4z+e+NrXvjaxfv36yevJKO4Vr6233nri5je/+cQTnvCERu6D+tpr5cqVE+eee+4m9bjLXe4y5Tp1mo6s47V69eqJPfbYY+LJT37yrJ6nf//3f58c610Y+3E/Y35zYNh47sqgftXPV+CCCy5o+laf6W//v/jFL27mpnHx8Ic/fJN7kdliwrXXXtv078Me9rCJHXfccajManzxi19s2r/zzjs3Y3/PPfeceNSjHjXx3e9+d/IaY/x5z3teM65dt2rVqokb3ehGE/e73/0m3vWud02sXbt2k3I/8pGPTDzgAQ+YuPGNb9xcv9NOOzXXv+9975vyDHbx5je/eeizc9JJJ01+94lPfGJGskosPBhvxtagZ99c+2//9m8D5654/fd///eUa/7nf/5nk2u++tWvTrnm05/+9MR222038N7Gbp/eGvR67nOfO+fy+Y//+I/J8n/xi19M+e4f/uEfhtbnH//xH2d839oO6rOTZoNhuudpT3ta8/lNb3rTieuvv36s8n73u99NPOYxjxnZP1/60pem1Z//+q//OlRXP+hBD9rEJjM/1tc85SlPmZasB73YevPRj/Gdtm0ODBvPfXZZ/aphbDzkIQ/pvW6bbbaZ+MY3vjFWfQ488MDJ3/3nf/7nxPe+972Jn//85xOLDXe7291GyqzGZz7zmUbv9/2GXGvQ44P65M53vnNjgwS+9a1vNfbroOvvc5/79NoByrjTne408tl5zWte03yn7r/97W8nlguSMFlGBs5CAic96trnSI5LmKxZs6aZXL1OOOGEeSFMOO/K4TzXk4z3D37wg4cqF/VaTISJNnHafK7d4+KXv/zlxL777jvS4GBUjauYOeA/+MEPBhImfQZMTQbMljDp1uWII44YWx6Dyl4IhMmg8QzDZNB1/s8555yGIOm7du+995749a9/PbIuFLS5ym9ucpObNASOZ+a8886bWEy47LLLxpJZjb/4i78Yy8kij2H98qIXvWhKuX477Pq/+qu/6q3Paaed1hC+o56d+973vs13+++//6xkllgYQMgh1qLP73//+zckBoIbUTfI2e0jTPy2Rp9+rAmTH/7wh83cGt/d6173akgXBv9HP/rRiac+9anNvNCntx75yEc2z4Z5+QUveMGUexxzzDFzKqN73OMeTbmciRr0GcfQd56dt771rY2T+L//+78T//RP/9Q4Jm984xsXHWHyqU99qrfPh+Gxj33s5G84a4jzz3/+801ffvjDH554znOe0yzsDSJMoj/J73GPe9xAEqGrq1esWDFx+umnT37vXt0xN13CBOmmLp6BQw89dEq7ZrIIttAIk0HjubbLLHSFbV2/arzjHe+Y4rQjAP7u7/5u8jP2ARt9FCz0xm+GEfo1rrrqqomFBotr5kx6sx5/fTjjjDMmbnjDG07OHfSyZ4MN9La3va0hYmtYSHnnO9/ZXPP1r399E/vBWA3Uz4852HeIqHqu/clPfrJJnYL8tfg77Nk55phjJr9Hvi0XJGGyjAycpUiYDMJcESaXXHLJJAP8kpe8ZMp3//d//zd5j1vf+tYTH/rQhya++c1vNgrb5OezxUaYgHZOhz3mLN7ylrecLI+Bi8gwHsnIKjhjiGM8iDD5m7/5m0ZWVtxF6/QZcn2EifvWCrY7/gc5fcNkTSmpi2eqrkufcbHYCJNh4xm6BmP9qgnJrlJ+/OMfP/GFL3yh+T8+e+ITnziyPr/61a8mrxcRMS6uvvrqiYWEK664YuLe9773xJ//+Z9PvOpVrxpJmIjOiGsQlAwkRhCD83Wve12zMh8Q3fRHf/RHE4cddlhzDTn/4R/+4RQjvjYeayL9ZS97WeNQvvzlL5/8bIcdduitk5XarrHU9+xY8Y3vTzzxxDmRX2LLwRiJ/txnn302cXA4uvG9KKe+ucuYivfIc+DEcma739eESZBvXt5fd911m9SvXmmu9VY9X9IBtdPleeJ4x9/PetazppR53HHHTX7HERl3jvJ81xCFWc+B485VCImDDz64iZ4xH6u7+bjrjNd2kOeYQ8MJ9Yyy+37605/2Ep/6LKL+zAf0b3e1f5juqQlgOnUU1C2u1+fmqEH6pybSB/VnHcmGkBqkT2NcWfEOkEt3zE2XMKltTpGzNZH82c9+tvlcBLExKwpHH4qS2m+//Zr5MaJy+myW+hXkSfytbX6DfEIusfNFcKpDjfe85z0NYe2e7m3xQ0SCCMFRGDaea7tsVHQk3OEOd5gsq44IrqNG2VHj+AHdlz7oRpBbKEZCGv/1ePEcsDd23333Zsz738JQlxTo+h1sUzJHXHhGLAKRNX3JjtUHSJDpRlEoo25LH/70T/908nsRobONaDGn9BHVdRTxPe95z4ER5CeffHIzloz1mvQa9OzceIMP6l7LBUmYLCMDZ5CTPEhxmpxMQre97W0bxW4iutnNbjbxpCc9aeL444+fcs+67A984ANNSP1tbnOb5gG0ZQiRMM5qfiiqud6SY2JUH8oXu86RHwdWu6KcrhHwL//yL1Oc7C7WrVu3iaKzou53JjqTtMmJfN70pjdNCanryuniiy9ujD6hpkL+n/70p0/85je/2eSe5HzIIYc0k31skSDLU089dWzCxKpQfIf8GYW//du/nbzefc8888ze60zItUFcEyZ1HfRVfE7x9vU1uUWIIicSrrzyysnQ7tpYmi5hUq8Afec735kyPi+99NLG4EMo6Dft5bBSHhzOz33uc2MZA6FEu8+e1TiOt3Fqa5cVnG648V/+5V82z6RnyxhCGiEvwpCb6XiGcZ652IoTkSHmhhjn/ve3z/XPsK05w0KgyaVr3OjH29/+9o286/EyE+fjK1/5SjOPcib0nevNo4zJRz/60c04YnQZ257j6YBD2Dcn1QgijuHXfTZnEtFifgB1rVeRgkjxf3xmzHRX8f7rv/5rcpXQ3DLs2amdzTe84Q3TrntiYcE8E/1p7u0CKVaPtZjf67nLnBVbIRGG8OpXv3rSRqnn+iBMOCd1uebaURjkYHedBzq2JlHoA3NnwLiNaz/+8Y8PvafvBzk2dFp8Ry9zZPu2idawmDJo3uN81/qznrPom+717hkEFfz4xz+eovvqFyLDKvO4ZL0Fn+i/UagXKmqdPZP+ZAeJyonPu5Fsta5+4Qtf2PyPMLA18ZRTTpkSeTcXhAnUW3xiK2JEFg3bFjZdwsR9jIHudfTQsAiamnwfhWHjGeJZRRawb+hU9obn2sJAAIkQ5dA59dZQC2bx3Ste8Yo5IUz0cU3mx3hhx9Q6r375vLZz6vvxB7rXe8bqSKl4PeMZz5iYa8Ik5l3yFRV6u9vdrhlT/n/LW94y1O6w8MjeC3n4XU1E1vMbQoONXEeYsD9qW9y9grxG+NVyGvTsPHgDKcNW6tsWvBSRhMkyMnCmS5hw4gdNZozuQSs/oWjrFyXO2dwShEmfoWHiOPLII0fKula6XUPo3e9+9+R3JiBEw+WXXz6wLA6ZVfRBbfddTZrUcuprg89qskx9YkWvT/5HH330WIRJbcha3RiFur+NmXHRR5hwBDms8bmww76+5szGdQg8iDBIRodVgbkgTOTaqeWIAOjb9tO3j3+6hAmjpG/fab0VqC+CZjpKfdh4hvhODhrPuBeCkbKtnWyREIP2kEekgldNIM2GMOnOKTFeZup89BlLz3zmM6esUscLmTCXhIlQ3PjeiiSjn6HL+LElQZTVIOgD5EhtkCI5atSrSxFhUpPsti/UQCx5ZhBgVp1qOfU9O1ZPw1mYjnOUWHhAMtdj/fvf/37vmKsdkoha7RImEZ5vbhZV4X9/M/77CBPlxGfI1b7oknEcbDqQE1nrPrm4uo5DnXMnVlrNb6NC+1/72tdOltHNq6XOth925wwLFRaubDkaFJHiebeFx/Nez5mPeMQjJq+vn0V1JWN2Rr1SHJEt+qmOiLTYRQ7qH+Q254x+H4cw+YM/+IPmO3Id5RAhNaKsOsrBOBgWqTgqhwk9VG/L7epq5UXEJMdY1EdEg47j9NXoszmNjX/+53+eUickWYwtkYAiaZF9HFjPQciMfo0t46IXuhGsXmEv1uXb2ky/1lsrd9lll0221LIVEHQWyT72sY81ttJBBx00sp3DxvOordJI0YgSFtVR69oa9ZYUeW0GwaIfOdQkUcjG4kWXcGIj2apnwYNtoX/IJr7/kz/5k+a7OnrD9/GMd20y9oNxE9vQQ66eS8RSRBaZn4bZ9tMlTMhw2Ljv09Nduda2UTcXnXH3/Oc/vzfviYXX7mKrMek7z7FnfZxn50WVLcmmWQ5IwmQZGTjTJUxMxPanUeiuYXjXSQEZ+oMUn9Ulv6tXfYLcsf/NFoy+8H+T5FwTJiYNys2kUocKcgRHIcI7u2GhQHF2JySKkrLGxp999tkDI1KQXiZkCrc2uFzTZxiYFD/5yU82235qBRGRLYygMBwYR0LqGEvIhLiWMRVO76gtS1FWd0/6qInfClftiHWNpejfcXKY2EN70UUX9fY1Y5yi815dOZGxL5eyHOX0jUOYUCr1thMJbMlPPfQTo0aYs+uRJIw711khGGUMxFatbh4A+6U9r/bu921tseLjM/UV6ipSylYNSvClL33prMYzDOsPDkBAfqT4XF1rULB1aPwgiKyo98rXe6YZJ13jxrPLWZAfAPk3G+fDqogEqO9///snnQkvfcWxqhM5ck7mkjCpHcW+lzmkb+Wvlmu8GMjdCBWGevRz/WL8McK7SRxjG9Wf/dmfbSKnQc+OSJ+YxxKLF1Yl6zFSRyvUqOcwzlkfYWLFOYg05K3/2SHmwT7ChONTz+fjYJwkoZ7XcPDpxXi+Eeyhl4Jc6c5dfeCEDUqQGZG4dMOg+tRRgvXWuHoxgP4K2albbAGon8U6ysAzX899iBtb9+p5rCagwsmuE2qPIkzq+aYvmrUGRzaufe973ztw8a47J47qT7ZRnZuhq6tFlISNQz+EbUTvzIYwGfRiDwTY3vQ1WfctdNSRDePmMPGySBOo88KFwx62AQKN/VFHfYyDUeOZrOgCepDs2ZJ1YtLIr2XBse6nGmySQclLp7Ntubb5PMfd+iKpBkUi1SReLNzUY0IS9O429Fg4CdRbX0VWzhVhQkfX32s/e5KPVEcu1WNhEGFijHSjhdmpiOqwF+uX8VovyrDJRRMZw9HGcZ6dV2+IIOza/UsZeazwIsOVV1455W9H9nXhKChHew36zbi4z33uU37729+Wv/3bv22OIXUE6atf/erJ73/yk5/0/u7QQw8t//Iv/1Ie/ehHN0deBU4//fTmf8ft3e52t5v83PFzjuTz8n6u4VgsR2lpwyc/+cnmeC1w7Nm555479LeXXHJJ87+j8bpwjNq///u/N0d2Bei+k08+uTnj/k53ulP50Y9+NPldffzdf/7nf5anPe1pTd3e/e53T37+P//zP731eO9739sc5+WYxTe96U1TjquDT3/6081Z9vC4xz2u/OM//mM55JBDmmP8HEMGP//5z8vxxx8/Ul51e6P9g3DFFVdM+dvRkoHPfOYzzfFo9esDH/hAGReONhx2/Jn+dHyjdv/Zn/3Z5DF2jsmbDR70oAc1z9Duu+9ePve5z01+7jnwuWMNydTRt0984hPLgx/84KZfLr744ua60047rXnmHA9nTDsqLhDj3KsL1xufj3rUo6YcqxvPDcRYI+fb3OY25QEPeEB53vOeV/77v/+7/Md//MfItg0bzzGmjR3j6ktf+lIzRgOOn/7+97/fvK+PhnTEXY367/q6LswB5oKAo0FDNt7XuMUtblEOP/zwZm5xbN8BBxww5Xl6yUte0hy7Z8753//930mZf/3rXy+XXnrpJvd+xSte0RyR+/znP785vjTgmLynPOUp5XWve11ztGpX/nOByy+/fMrfD33oQ8uXv/zl8vKXv3xyDnnlK19Zrr/++pFlGQ/r1q2b8pl660fHc9Zw5Ktn8qyzzpr8zPh2XKYx7VjHcTHu/JBY2IgxHujrT+ORHRAwL/bB8atPeMITmvf0DjzmMY9p5rU+1M+4+44z3ofBvON4TscWOxYT9tprr/IHf/AHzXufa4d5LY4erue3cdB3ZLE5+Je//GVzDKj5qba94K//+q8nn/lTTz118vN73/vek+932WWX5gjnuEffnFNfb+6MZ3DNmjXl/PPPn1L2Pe5xjyl2yb3uda/J9/V1023rINR96YjomeCRj3xk+d73vle+9a1vlTe84Q2Nrj3nnHMae8bR84NgHo+53jgy9z/rWc8qcwnH7pqf45jjo48+urETvvCFLzR16zsKtzvPjwPHUt/97nef/LseS1Hec5/73EY211xzTaM7yN44N/YH2eTT6eNPfOITjV1LDz784Q9v7AFjOPDVr361+b8+itgRszXCFu1eNxsY8/vss8+UzwY9T+OM+fp7c1egtkk8l7Ppz0GobcKwLR0BzI7xf6A+Uh0c1+wZ+eIXv9jYMMbBL37xi+YZqW3717/+9c0x7eY745Y9etxxxzVzt/HKbo3jrfWtY6Zf9apXNce6j4uJeTi+faEjCZNlbOCMAmPCufEnnnhiMzl3MWgCeeADHzh0wt/cqCdSyqWedJ37PpvJ4WUve1ljLCExtNs59LWzyIkbNbmPY8wMuj7qP6hsRtN+++03svyZToZdx3amxtLf/M3fNIqA0RNGLLLJxD4IjGLGQ22g77///lPaOxdw5jxSKxxaxsRznvOcpr7GdJ+sZjLWEZShSAc9Nxx8oBy1kzHCOeZgX3DBBWPfa1D/Ivv+7u/+rjH8ETdICQ7BljaWHvGIR2xCAMzG+RhlLDFE4vO5nre6xhLyFLmJJNtzzz2bz5BvJ5xwwpTrGEHf/e53G0LI9fDtb3+7MZo5TbVRhWBlxOs/xhAiDhhNnNj169c3fzPQwPXT6avlaCwtRXDQYswBXd8For0mM+rFji66ZPUw8ro2zpF+Rx111IwcbCSu+dBz+pGPfGQTwiLmTG3w7HA2AOFgXhmF2mm67LLLeq9BYLsPovmiiy5qCFCEfxCVnJpRMOdMB9O5frpl123tLsCN6ssf/vCHk+/vfOc7N3NF6I1hiAUGRIQFLs56yC/6rA/mP4RvPf+Nqu8osCuMrR/84AflpJNOamTxjne8Y3Kx7T3vec/kM0FPfuUrX2mur4mamGOng+5CRq3zYs5FAKoXoogNoE7sLjYQG3SUTTvOeB6mL2NhqJY5f6MmjWqC61a3ulWZC0zXjxk15mvbdeXKlVPmxPnWecZnjKVYEOp7313stlDnGbEwxF545jOfOTnWQsfDf/3Xf00hY/iNntEgY9hoxiwgW4EPQ2ZeYVeDcn32+Q2Ls31jpx5TSxlJmCwjA6eeQOpVyT7SBbMfSmr77bdvjPrvfOc7zWuUQqgn/b4Jf0tjOsZDTATDFAuFgKUlG6vZVqkDP/vZz0a2ez4NpZlcXzuJoyZCYyOc066x9NKXvrRpex2VNAjGKEXAGPjwhz/clBvyG0byMFLr9s02ugTe+c53NsYPwoazzRj50z/908nv60gOLL5VANff5S53mTNjadBzY7VHFJIoC8Sftp9yyikNiUN2fStd0x3P0zWWfvOb30y5fikaS3OJbhRdGEjqbKVwkLGkv5FX+t4qecj2vPPOK0ceeeRkdFPM0SJnkI+IENFpEUnDeQsHLkg2zkkYS6KVAn/yJ3/SfNYljWL8LBdDaSmDgxlADHfnkLe97W2T742/YVGgBx98cLntbW/bvHddRHf0wVi/733vO/m3aNS+KBPz2zAH+8ADDyx3vetdJwmKLhCEMU4PO+ywyVVb0TDd6Lg+1BFoXfKVvu8SPeYThOa+++67ib11+9vffvIzUQq1w3nGGWc07z1vIcMa9fXqEZFzFmmQ+nXZ9Gbdjz/+8Y8n39fXDUO01fURsTMIohEC5BvO2GxQ672+KMEAeYmynEsbIKKe73e/+zWRwnW0Tsy5AY4m8s71XV3Yp2NmYht05eK5ed/73tdE1YrC/bd/+7fmOwubIqlmOp45z30LL/X4CV1sQSHKMtaOOeaYyWvqyGqRxXOBPp0+6Hnq/j3umN9cMB7quY+/1fc+7AGk4SiZ1Dq69uksmATqiO3685ng9A1jh31RkzxLGVOX7BKLxsCJbRz+5zTWDtYgA6d2Emqnpm+CrRUCY5rhDNNdBRqEuVQgo1BPnLaQiAgJ1M5+HygEzjBG1vad2qGx8sDBqg1IRhuiAKsbhlJMaibtWDVWJ1tKxjVmXP+Qhzxkk+uj/oMUBwOU8TSq/Bom7IgSEL0wCoyl2CZEcTNeGHBzhWHGkvZbkRLGi7F/+tOfPuv7IT76tsx0nw2rBG9+85sno4nqZ2bYWK//ngls4/ICkQVWGWzJMh6RS8P6bNh4Fl1im08dJdUdT2EsMSS1Q3uML/XwO//HeGNk10bBfBhLMXepIyJhXOdjS8JKDyMjtit53tSRIVxHaNXG0iBnsGss1YZSdztUbSDNxlgyp4RRN878kFjYQPpanTaGLMDQ93SY+dS8Etso2RgI22HwvCGU2QmitUbNdfSFVXFjyqo550rU081vfvPGcUMMHnHEEbPa+oUUMUcilX/6059Ofj7udhyETICDGqu6oZvMcaIDhcXTHZxr+kg0V0SUIXTingh5eNe73tXoSYsFVosjUo/866i3gPqbf9kb9aIMZ909beUwvyOYyO4Zz3hGEwnJXoitpWQR26aGwViIrXt1+wcBMcaeEVkD7mEMsVnUbRwCRWSOaCHOt4UX/T6u3SLagq2lfWEnzSdqB5HtY0uuKBoRsqMWQ2zroRu9htkZgyDSVf/aIk9HeC7p9EERn9MZz+wH/WicGod8BmW/5S1vmbxG9GngxS9+cbM1JPrAVipl/t///V/zmedYBM58wbhjh9H5tiMZc+pvvMX2JGQpWW0OiAC1qNQlfs2jkUIhIvDJK8hbz7N28MtskQX2VPgI5P+Nb3yjea7MF+ZZvxVRV2/DCyD5wg570Yte1ES6izz61Kc+NXlNbP0is5o0D3sq0gOIYhI5dZdqQRBifhPdO4pQXTLY0klUEtOHJD31MWdORZD8SIImmZXjc0l8JCTrSzboOM23v/3tTaLIOrt8JP8677zzJj9z7KYEpZKO1qdLSFQUmG5CWUmH4vMDDjigSShbZw2vk2QdeOCBTYKh7ms6SV8dUycJap2t3AkV0zmGVcLJGk7PkNRO4i/ZyrVBYtn6WDJHdfUlfSU7CV8l1nIs7Kikr+Qu2aXTAOoEc5FQTnK7SPQrOdbrXve6Jlt4nbht3KSv0z1WWIK6OnGt498k4JQ0mMwl/epL4FsnApQEWP87/iwSBkZb4sjUbtLXgEzvyq0TZc5F0tdBkNS1PhVIG+NEgXipayCS0Xp55uqTAoYl3ut7zownSW0l/zXePPf1yQgS/810PJOhY8P1hTaZL572tKdNaVd90lKdENeY90zXn9XJagdh0PML3WOFu6hPK5L4UKI/da7H26Ckr3Uf1+Ow7rdBiegGQQJbr/qYbX0Tn8fpCvDiF7948hpjx7Mq0V58Jll24GEPe1iT2FCSWkl+JfutT5Iyf0fiV89inYhakknPVJ1sUlI5ycNBAsjuy3wc17qvz+rTuPJY4aUHzwM9Xz/r9cuYkSC5+5s66esw9CV9DRjPcRx838tx4eMcKzwMJ5100pQyzXPTOS48Ekh2T6Q67bTTBtY7XhJI15jpyV613omXZI0Sn871scJ1Mu7uCRyDIPloVw/2vR760IdOK4kv/VknsO0mfR2EuTglZxDIuXsiob/jaNauXTUo0fcwXT9INzn9ZJCsJPYe58SSQeO5m4S+L8m4hKYBCcRrfdudMySlHQfjJH3tS6AO7JiZHCtc9/Ege3hUst4uRh1k0G1DfZpj91U/q6OeE/1SPyPGW98JOfHSZ/Wph9N9do455pihJ7UuVSRhsowMnEFH4N3hDnfoVZx1huiavJgLwqTOCl+/YlIaJ2P5uIRJn6GBTBpnAuSARIbw7ikkCJNh9XOPWmFwOvpOrxjnWOG+NlB2tfKaq2OFI2O4/ols/aPAGew7Trr7QlyNq1y8HIcaGESY9GE+CRPn1HfrKTv/Pvvs0+t4Ow1hkOKcLmHSdxxu7ZyPOv5x2HgepZT/8i//csr1SDrHZ/Zda55xAsd8EiazcT7mgzAZNZbrNuiHerx0naD6WR31nJDBuDLxcmLYbJ6devxzRBNLAxdccMHEX//1XzdkXdfp/ta3vrXJ9XNFmMSpEU6Wc2yp8c/xc/LK05/+9CnHqs+UMIE48tXrFa94xbR+yymI39anUrGpkNZ//Md/3JzyZTGD3regdfDBB0+eKNSFxQ8y2XHHHRunzqIJvesEn0HPIuLTQhGyh27mJHFculA/v3NUqrqwExHHtRxH6Z4gys2ho3RKDU5YELp+q236kv3COUTYO2p4lM7xG/YN8rl7CsxCIEzCUTdekfVORtTuYXaVRST6uz5RZ5iuH6SbPIvqSn8gEznGxp1Fi5/85CcTsxnPTj10ypGFRWNS25CZCBb1r+3T2q79p3/6p+a0FuPSYqyjhB07PC5mQ5iAdlugiefPiYVOf+s+HwuNMEE4WZCIcWTedcpfd460OOQkRH1uztDnTsBRnr7s6xenOBkTcYqTU5XM7fqq9htm8uy85jWvmbaPsBSQhMkyMnDACjQWnNPE2Xn961/fKNI+xXnppZc2f3MGGQCO2/LZXBAmYFIQ5RFnnc8XYfKBD3ygOWKLAtBu9+weVTcMJmLlMEBqVvaSSy5pSCmrsEgnMjIxmaBM1o497VMuokjuete7Nu02SZosRSrUq7hdJSLih8FhstTXjpa78MILNykfQUPZUVrqItrDRNs9enRQf2lfnEk/ToRADWfdm/yRQu5vUldf45NBqb/rVb0+5YLwYQQg5iju+vqFQpgwIBE/fkMJMYxFjAxyvK3mO7NeXwShNVPCxHgT0RT3DmNbxELfeJjOeBa5Rpk6bo9RrmzGthVBR94NmoP0rbJc739/j1uX2RImM3U+tjRhAgwNUSXuo96MPM911wngdDFAXWfOCDkbB/XxgAF9yjFBwJqTRGl5prRzkAM3nWcnVlGne9xyYnHBkZahm83HfUb5YgJbZ6bHYHIk48jaLkG51MCuiX5/85vfvKWrk5gHLKfxnJhbXHfddY0ta+w4ono5IQmTJYSlZuAsFCA+wtASOr+UYSvGTI3KxOLAchrPiblFvbXBFs3E0ka9he+FL3zhxGJ1Dm2diUhaK+EzgUUXv0dCWhxYqrAYoJ1W6+tokMTSwnIZz4m5xUc/+tHJ6BKRgcsJK/yzpfOoJOYOThiRgCqSCsmknZg9IpGUI+zqZGRLDZJjSS6lvYcffviWrk5inrBcxnNibkGnvP/9728SwDnKdSYncCUWF5wsI0F09H99St9iQHeMSnA7F8nBE4lEIrF8kITJEsRiN3ASiUQikUgkZos4LtvpMq985SubU0YSiUQikZgOkjBJJBKJRCKRSCQSiUQikehgZfeDRCKRSCQSiUQikUgkEonljiRMEolEIpFIJBKJRCKRSCQ6WN39IDG/WL9+fTn//PPLDjvskAnzEolEIrFsIef87373u7LHHnuUlStz/aZG2gqJRCKRSJQFYSskYbKZgSzZa6+9NvdtE4lEIpFYkJCk/OY3v/mWrsaCQtoKiUQikUgsDFshCZPNDJEl0ek77rjjnKxCXXzxxWXXXXfNFbqU44JAjsmU40JCjseFK8crr7yyWUAIvZiYH1shn4G5Qcpx7pCyTDkuNOSYXLhyvHIB2ApJmGxmON4OGEBzRZisWbOmKStDmlOOCwE5JlOOCwk5Hhe+HEMvJubHVshnYG6Qcpw7pCxTjgsNOSYXvhxXbEFbITcNJxKJRCKRSCQSiUQikUh0kIRJIpFIJBKJRCKRSCQSiUQHSZgkEolEIpFIJBKJRCKRSHSQhEkikUgkEolEIpFIJBKJRAdJmCQSiUQikUgkEolEIpFIdJCESSKRSCQSiUQikUgkEolEB0mYJBKJRCKRSCQSiUQikUh0kIRJIpFIJBKJRCKRSCQSiUQHSZgkEolEIpFIJBKJRCKRSHSQhEkikUgkEolEIpFIJBKJRAdJmCQSiUQikUgkEolEIpFIdJCESSKRSCQSyxAXX1zKySeXctFFo69dv76U005btTmqlUgkEolEYqHg178u5dxzy3JGEiaJRCKRSCxTwmS33Uq58MLRpMmVV5ayMi2GRCKRSCSWF045pTUUljHS/EkkEolEYhnimmtK2WWXUu50p1LOPLOU664bfO0VV5Sy004Tm7N6iUQikUgktjQuuKCUq68uyxlJmCQSiUQisQwxMVHKihWlrFpVyj77lHLGGcMJkx12WL85q5dIJBKJRGJL4rLLSrnpTUu56qpl3Q9JmCQSiUQisUzJksCNb1zK7343+Pprry1lm202S9USiUQikUgsBJx9dim3vW0pa9eW5YwkTBKJRCKRWIbbcW54w6mfIUQQI12sW5f5SxKJRCKRWJYJX/faqyx3JGGSSCQSicQyJEy2227qZ/KZXHLJpteKPNlxx81WtUQikUgkEgshFFVkyVZbleWOJEwSiUQikVhmkL+tG2HSR5iwl9qEr5u1eolEIpFIJLYk5C2J1ZJtBoSgLhMkYZJIJBKJxDIkTLoRJl176Fe/KuVHP2q3MN/oRpu9iolEIpFIJLZkwtdQ/tttt6xPylm9pSuQSCQSiURi8+L3vy9l2203/dxi0m9/W8rOO7cnCd73vm1y2PV5QE4ikUgkEsuLMJERPggTESeMg2WIjDBJJBKJRGKZn5ITkAz/tNPaPG+7795/TSKRSCQSiVlC+OYRR5RyxhkLU5SXX76RMNl++2UdYZKESSKRSCQSywSnnlrKSScNPvVm9epSbn/7Un7xi0yMn0gkEonEvGDNmlJ++tNS7nGPUk4+eWEKuU5gtl1uyUkkEolEIrHEcf317Yk3d7hDG2EyCCJuDz64JU8SiUQikUjMMSQJ23ffUm5yk3YFA4FygxvMj5iPOqqUCy8sZc89SznggPF/Zy9urK5sv327JWeZIiNMEolEIpFYBmAv3fSm7ek43YSvXeQpgolEIpFIzBPOOquUW96yfX/rW5dy5pnzcx8kh8Rkj31su9d2OmRJvSd3uwERJp/5TCnHH1+WOpIwSSQSiURiGeA3v2nzkiQSiUQikdhCEOJ5zTUbVy7mkzCx3efOd27fixYZN4P7lVdu3I4TqyjCVGtcd117vJ7PHam3hJGESSKRSCQSSxzsmlWrcptNIpFIJBJbFBdfXMpuu23821YcJMpcb3lR5rnnlrL33hv321566fRPyBkWtnqzm5Wy//7tiswSRhImiUQikUgscVx0UUaXJBKJRCKxxSGa5Ba3mPrZgQeW8s1vtiTHCSe0ZMRcbPtxn9hag6RhDIxLmNzoRsOvOf/8UvbYoy1/WGK0JYBlQ5gceeSR5dGPfnTZY489yooVK8rnP//5gde++MUvbq55+9vfPuXzSy+9tDzjGc8oO+64Y7nRjW5Unv/855erlnECnEQikUhsWYiaZbMEnG4z6nTARCKRSCQSWwAiPJAhN7/51M9Ff8hp8vGPtzlHfv7z2d9LGXe608a/d921jW6ZaYTJ9tu3meMDokoiUmbbbUv5/e/LUsWyIUyuvvrqcre73a28+93vHnrd5z73uXLUUUc1xEoXyJKTTz65HHHEEeXwww9vSJgXvehF81jrRCKRSCQ2ol7EYXchSCKPG1vFwpWTALuwXZo9k0gkEolEYgtg7dpSvvWtUh760KkJVQN3u1sphxxSyoMe1BIWswFiwz5cWd4DCJBxy7Uas+OOUz/bbbeNW28YI/KhuAc47QfRs0SxbAiTRz7ykeWNb3xjedzjHjfwmvPOO6+87GUvKx/72MfKVp0jAk455ZTyta99rbz//e8v9773vctBBx1U/uM//qN84hOfKOfXy3uJRCKRSMwDzj67lGOO2fj3aae1W4e33rqUa69tF45ue1u6bOrvapsmkUgkEonEPENY5/e/P/Wzn/60JUVEagxCRHWIOJkNaXLSSRuTvQb6SJpBxE6f0bD77hsJEys2SJJAEibLA+vXry/PfOYzy6te9apypzp8aQN+9KMfNdtw7nnPe05+9tCHPrSsXLmy/PjHP97MtU0kEomFAfq8jtBMzA9EjiBF2DBsGREjFo78Lcr2kkvaxZ1b3artjzoSxULRDjtkzyQSiUQisVkg2apVjYAjeS+4oJTb3W6831PmMz05hwFg5WSvvTb9rrutpsa6dcOTnu2yy8YoEqGt9W4M3zFElihWb+kKLBS8+c1vLqtXry4vf/nLe7+/8MILy251RmPCW7267Lzzzs13g3Dttdc2r8CVLNcNBI3XbKGMiYmJOSlrOSPlmLJcaFgsY/JXv2q3gtz73mVBYrHIcRic2Cd65IAD2igT76kVCzqaZSHKVmXXIVB8zt5BpMRCkMja2YhgPuS4mPskkUgkEomBQFg4ljdWN374w1Lud7/xBSbHyfHHt2Gk0wUjoY/wgH32abcFWXl5whM2kjs/+UlLpDzjGS2x4/SbLlat2kiqSCj7qEdt/I6R4ffr15etlGVr0RJCEiZNhNRPyzve8Y5y7LHHNsle5xJvetObyutf//pNPr/44ovLmjVr5sTgvOKKKxpDVrRLIuW4pZFjcnnJ8bzztio3uMFEOf30dWXHHRdelvTFIsdhOPPMVWXHHdeXiy4i3xXll79c1ZAj++67djLhvX7YeWfXrCurV5dy4omry53vvLb57qyzVpfb3W7jtQtFjr/L0KREIpFILEUgSkSTIE6QH1Y5OgvvQ0GRR56Q6ercc87ZeJRwF6JOvJAmtg05Cee440r5wz9sk6KdemqblLa7naeOUJGKwlHI6lhDfY8+uqxHFC0xJGFSSvne975XLrroorJ3NbjWrVtX/uIv/qI5Kefss88uN73pTZtraqxdu7Y5Ocd3g/Ca17ymvPKVr5wSYbLXXnuVXXfdtTltZ7ZgxCJ5lLdYnYGFgJRjynKhYTGMyYhuuMtd2ggH+TMWGhaDHIfBYo6FnDveceNnthBL4Lrnnhs/u8Md2siSOAWQutI37BlRKd2E/AtBjjdgcCUSiUQisZTgBNXttmuVtCOC7S6olfi4kM9EFvfpHnGH0Lj73Ydfo24RBSPaRDI0hsThh7ffb7NN/+92372U7363P1pGmy+5pKy7173KUkMSJqU0uUvkI6nx8Ic/vPn8uc99bvP3fe9733L55Zc30Sj7bwiP+ta3vtUYkZLADsI222zTvLpgcM6V0cmIncvylitSjinLhYaFPibZAPS4BQd6kpM+hD/eYljochwGMrVNuK66fCRsm/qz7rZov/Fb6oc9NBdNn2s5Lsb+SCQSiURiJGFhlcKqhT2xcnvst9/0heb3coZ0CRPRmfZD90WBWGWxmtWN/uiCkXDUUW3US+zfdeCJVRchrIOw++4Se/ZHsGij7UdLMHp02RAmV111VTn99NMn/z7rrLPKcccd1+QgEVlykzrTbzNmtmoiR/ax16tZvbtDecQjHlFe+MIXlve85z3l+uuvLy996UvLU5/61N4jiBOJRGI5JHyNiAYLE3SvvzNwYG4XqjrqqdziFqNPvUFcScgvQlbuk0QikUhsQXBw+QudUzibSdp2jVScSwciNyLCI0iImSwQUP7yi3TDd22ZcQIPH7U7nnzXl3+kCysviA3l1+GqDjexnWgQdtmllD/4g/4TdxAvyJolSJgsm+Wdn/zkJ2W//fZrXmCbjPeve93rxi7DccP77rtvechDHlIOOeSQ5mjh973vffNY60QikVjYhEksfLAF7nrXdiusg8OG6dsaIkHzZPbBkFhf9E7XzrGIMwwWl0T+3P72eaRwIpFIbHFQdJJx9rHi8kYklg5ElYRx5BjhUdtjBiEiVPqML8r95JM3/e6MM/pPx+mDvb1O4qkJEwbGoISxYLXGCT7LDMuGMDn44IObZHXd14c+9KHe6+Ut+bM/+7Mpn4lG+fjHP94kqpP87gMf+EDZfthZ2olEIrGEcd11U7e5mg7vc592q+649h+9XwX/JXpkbPvNTHCnO7X2VmJ8HHnkkeXRj350EzlqC9LnP//5Ta455ZRTymMe85iy0047le22264ccMAB5RxJ9jZAQveXvOQlTeQqG+EJT3hC+Y3EM4lEYnlCBIm9kXEkaw2r8ZjxxOKCrS9WfCJKKIiNeiUJbF1BQswEoo6qk1Yn4R7yhDCehPZ+9rOl0FWf/nRLaIy7NxpRovyZGhnLCMuGMEkkEonE3MFC2aAIYrYBW2IcG5DedyxxnjCbWAi4+uqry93udrfy7ne/u/f7M844o4kuFW36ne98p5xwwgnlta997ZQEtn/+539evvSlL5VPfepT5bvf/W45//zzy+Mf//jN2IpEIrGgIHEn9poziwXvEibmj3C+E4sDJ57YEhT68zvfKeXLX2778LTT5j4DPkKmBqPJCpUcmkiPxz2ulEMPbY8JPvDA8bf/IHP23Xdu67pEsWxymCQSiURi9mAP2PJqoWxYDjNJSNkNfZGodL3tr2xEdqTo0Zkkgl/qmE10SWJmeOQjH9m8BuFv//Zvmy25b3nLWyY/u81tbjP5XvTpYYcd1kSjPvjBD24+++AHP9jkQTvqqKPKfYRgJRKJpQ+rABJJOSiCgpMEFGFitaHeAmGFH5lia04kBauVgBwVffkiElsWDCHz+f/8T0s66GdbZH796zYPyFwhco3UJ6sGgTLu1ptBMN42HGSSGI6MMEkkEonEWECSyE9i8YKOHZZ4lG5n63WTrdPzxx7bkikgEkVeM5Emyxl9Ozb68pckthycivflL3+53P72t29O0tttt92aU/LqbTtO0pMUvj55TzSK5PI/crJAIpFYHuDkUngXXNAm9ZIvgrKr85ggVShU0QJ9IZnOlHfCSmJhQb9ZPbrlLduoDpEeSJOf/7zty7k8Ac6YqbdyIdgGHfmbmDdkhEkikUgkxoItupKyS5I+DhwIIFk8myJsRwncLYr4nH3IhhRZYlEG2AXdU2GWOtg/FiIf8IDW1gpYcMw0WQsHF110UXPi3r/8y7+UN77xjeXNb35z+drXvtZst/n2t79dHvjAB5YLL7ywbL311uVGnZXi3XffvfluEK699trmFbjSmd0bSBqv2cDv5WybbTnLHSnHlOW0YBXg1rduT8cRKhjPn7kBQ+5EEc85JSiLt3Pgu6ebCMd07QClmGNyC41JBozEqK7Vd/Gbe9yjXeWYy7nWeEGyOR4vDDH5cBbofL5+HvTNQtBdSZgkEolEYixw4G15HRdsv2OOafOPnXBCS4wgTSR3F3nyy1+25Atb0t/8ScSBE+u6J+UtBsi/ZjGQLeOY5ekcnmBXB9Ko3k6MUKojtxNbFmG0HXrooU2eErj73e9efvjDH5b3vOc9DWEyU7zpTW8qr3/96zf5/OKLL26SyM623rYKMWJXzuXK5zJDyjFlOR2sPvvssvZ2tysrRQOsW1fWI0Rg663L6hNPLGvvdKey8sILy8TWW5eJK64oqy+4oKzt7EtdvSGR6FpbdtasKSvWrSsTVQLRHJNbZkxuddxxZd3ee2/s0wDlD93PZ4OJibLN8ceXaxlUq1eXVQyNiYmybi7vMYdYPw/6xmErWxpJmCQSiURiLEw3EtSWHXlKkCB3ucvULbi2c4telesEkCZOw3PCDjtgMRIFFgsPOKAlTqYTKWPxyJZn5BJCKbar55achYVddtmlrF69utzRIK0gP8n3v//95v1Nb3rTct1115XLL798SpSJU3J8Nwivec1ryitf+copESZ77bVX2XXXXcuO9YMzQwPWiT/KSsIk5bgQsOTHZIRTcnK7USNgkhc5goQVhUKxup7SwKALw1SGv5EolCml4v1uuy0fOW5GTEuW9hs7hm5zyfxBDyrluOMk2WoNJcf6VuNgIWH9PIzJOqn6lkISJolEIpGYN9Drl18+lSwB9qEojNhywj5Emnj94heLkzCRj4Vdq83HH78pYcL+FUlTJ3IVtSOil10h2kaEikjtenv7XEP+QTlk5jIv3XKArTaOEP6l0KgKp556arnFhnDp/fffv2y11Vblm9/8ZnOcMLjescP3ve99B5a9zTbbNK8uGJxzYXQyYOeqrOWMlGPKciyY2Cm9Qc8bEsWEL4LElhywlUMoponfioIcGb6z9ePoo9v9sNj1Tpk5JjfzmIyVo9Wb0YUWgsp4+L//aw0NynuhzeWXXtq+1q0rq668sqzcffc50zcLQW8lYZJIJBKJeTuxRYRqRKl2UZ+8FyQB2IFQR1osBtT1JSe2MvKjzveCCJL7j91zt7u1tvCZZ27cmsxGDqKFXVxFXs8pRMCw+ch5ASzcLCjIUXI6AW3AWWedVY477riy8847N4lbX/WqV5WnPOUp5QEPeEB50IMe1OQwcYSwI4Zhp512Ks9//vObaBG/ER3yspe9rCFL8oScRGKZwCrBIMUXsO8UGVIn/aIERJ4IL0ScmKA550I0RawNyYOU2Iyn40xnb/JcwX5dxsW3v73wkr5ec02bs8dq0YoVm25VWgJIwiSRSCQSI7E5E5CyM21vGWVvLjR7QaRIvSD0k5+0bWAXI5zI0JYd1554Ymtz+S7ayQby2Ukntbn+XDsTIEO8+nZyqIPFGluh5EypSauEPvtJQ4QEYpvMs5/97PKhD32oPO5xj2vylcg58vKXv7zss88+5TOf+Uw56KCDJn/z7//+782KmAgTiVydqPOf//mfKd5EYjlAZAi2HMkxHcSRaP5HmGDgg9HuHjec2HI4++yZK+fZwvYtWfQXGtasaceoENsFkKB1PpCESSKRSCQWFGFia65FtsVEmHTzjYjWtSCE/BBNwsay+AKIFVuQbIs58MCp5UhzIb8Zm2imUahHHtlGr1Q+fBMBYwv8qae2dry+FEiRhMlUHHzwwU2yumF43vOe17yG7bd+97vf3bwSicQyg4nVBM55nAlMzthsSqR7JB2lMF97NRPjYUuv5izEvl+zZnEZbDPAApR6IpFIJJYzYWJLigW6xS4fCy4irn/2s5ZQqW1fW9gRGn22j+iPmeb5ZGdbmNxwKu0kTj653eZz17u2W31co36iaBOJRCIxB8D02zYxm4gQUSVCDPv2TPq7On48sZkhAdgsk3AvSaxZs/C2Cc0xkjBJJBKJxIIiTDjzDgPYcKLiosCgE21sS99//1L222/T7+YjR4uTdu5//zYqXHSLiBJEiUXJOskuiHKxHTuRSCQSY8DEOmjLASUpd0OEEs4UoRgku7Jns49MSWwZ/OpXG5OOJTZCItrNmQR3CyAJk0QikUiMxOaOAp5LZ17+kPnGQkigaiuPxa9Y6GG/W+x0fHPnJNwGIk0it2AikUgkRkCo3gUX9H/nuFf7MOeCCadMECZ9n2eEyZaDLO1bIuFrYosjCZNEIpFIjCQDZnJCzmwgEsJC2nHHtclTZwo25w9/uPWy2HqCYEI0hV2t32ylf+ADBy/+2BrE/rcwesopSZ4kEolEL0yUWGbbMgYdI9eNCJkphCv2Kd2MMNlyoCTrFYnExqirJR5dAkmYJBKJxBKHHJZ02kwhL8aee5bNjjvfuZTb376NbJnpoprTaG55y3XN1vL5Ql/k9FxEuH7+823fjRs5UxMmkr6O0+f69Ze/bH8rZ9uPfzy7sZJIJBJLjiixv1FiLdtt+iI/kChzmfQSMVMfuxYIJjyx+XHssaXc4x4p+YUYXrsZkIRJIpFILBHIVTEoaT97bzYLK06u2dwQZcJmjFNzpovzzmt/f4tbrJvXCBPykah2LnH++S0hgqwahI9/vCU7ALEiIgdRAhZ8Rhz20gDRc/e7t3agfCtO6VlsCXcTiURiXuBoMXsdJYByvJjtNpRKN48IwmQuj/4VyeAI2S5M7Mlob37Y32oVI4933hRJmCQSiURioSMiLzjXRx21adQBHY9IodO8ny5i4Ww+EpSOC4QJUmI60N5zzmkjVNRdFO18bf22AGlry1znljv44I2ESBf6me0mP8mFF7Z2vUS5X/5y+72onHH7e+edN/av94sp2W4ikUjMCygMjLWz1+sjginEyy+feu0112xkq+cKW1LpJjZddZKfJrEpkjBJJBKJxEKGhJ1HHtnmnRBNwWHuRlKcfXabx4JDL2phulDuzW9etihs5R52OAFbtW8rjgXBSFQ7E9JlXFvBol+9hRdBNZtFQJEhjgVWZ3a6xa1vf3tqJLa26NNDDmnHgH5m37PrRIyztWdSBwubFlQTiURiWUNYoz2O3WznmOqaMMFMu2ZzERzulZm6Ny+svmSy12V7pDDklpxEIpFYpBAJYKuzaARRBk5CqaMD2HThWMtVMRPCJE5e2dIYFvnwox9NjR6J02HqI3SRD2ed1ebqmMuIZoRSnd8F2aE/HKYw060tfrfrru17ETKiSE44ob1XHdVi+ww7xcKX6CK/s71GtIl6RISJ99/6Vilf//roqJOw+cfZzpNIJBJLFljrvrwklIsQvyAtXLc5leTuu7fMeGLzgMFAIc51orKlgomJzXuE4hbC0m9hIpFILFGIJhFFIWrYtmoLX2y3iHL4xS9Kuec9WydYBITE+0iD6erChRAZPChChs1qO3kdPWIxKJKf1jbuAQe0ts+pp85dvZA4u+wyNeoHuYO8GpRTZhTYwre4xUbb2ElB++03NZ8JggxhAsaA39jy7jP3jX4jH2SJcvbZp92yg1AaBrZ/jKNEIpFYdjCBmjzrrTh92bKF85mYTfqbC9h0STanq8wTM4P+3dJhtoktjiRMEolEYpHCVhQkiHx0t7lNS/KHnYcUuNe9pi6K3OlObYTBuAlgXTvIXtzcEEmDjOhGSPiM7RpJYbVfZE2f/WqLuUMOfD+XERQ1oYSMENlC7n2HKYwCsgepE0l2EV2iYu5976kRKyJqIgpWROz9798mbmVLk4XfGQ9f/GIbSazvbc066KBSvvnNdnyQZZ8cbO3KPCaJRGLZQmglpTMIWHLRJ0L/sNt1OOPmgEndJH/yyWWllYTjj59ZkjLI7T3DgZhiOCQGH6e9DJCESSKRSCxCcKqDzGC7hb0mOkBkiRNPulGSHHv560RkdJPD9iGc/4UCbbIVpWvXOqEmcpwgFeqIjz6ItpiLY4b7cp3VdvZ0t5rrF2TW/e43lRBCYOgL9jESpntfbdGv7BZRRmSk3+52t1Ie/OBSbne7jdcikh7zmHaM/OAH/UllXWNbTyKRSCxLYNVHnYhCIe2//5bbsyqMcu+9y4SJnxKcyaSNGf/pT6f/u+4pQUsVFDCjYj4jiKx+uM9ixJrlcaQwJGGSSCQSS8ie41yLII0tHX0QXSpqYbaLbJsbIkm0zXaU2J4TpA57Ru4QkROjcrMNar/fTwd9hBI7MuwH0T/TsYPYZfqtjupBaNhKFCfxaHfkL6kJk4hIQdKIPNJv7Ok+Wx5xpp5efW2O/C8//OHwY40TiURi0cHEd+yxbVTGIJIhjodb6NhhhzJhhcAqwLhZza0uxHHJFKHQy+mEQ1IwP/vZpqsXSw3a+dWvlvKQh8zvfWRsJ8/FiDVJmCQSiURiAcPCUN+ihy0ZtmYMy8E1boTFQiFMtFWkRpz8ol5sjLqOQSZo26ikrray2IpSX6ccuT6ms1WnS5jEb2OLjnpN58SZvtyBZ57Z5qGJAxt+8pNSjj66TQYbkLMkksRGPUZtpfIbkSfInb6cJhLJ3uc+7RahRCKRWDJAFmCmJX/i9HdJE44yBbqYElnG3ttxMppj4U36FKbEVqJTusfrDQPlK7u4VZulvHfziCPaEM35zk8TScf6jvtb6FiThEkikUgkFijoVjq2L8LEto1RW1LYgRbP6pMRRxEC9QktmxPsvzPOaLeKOypYdAhCQv0RDBbG2IrIiQMPbKM0xomeYQPV7bdFhTynY7N0CRO2g8W6gO9EcLBPxzkxp3sog/ppVywA6lf31M6ayLJ1PY41tnDq+mER0+QjcoRsbeUZdOBCPU7c9+ij85SARCKxRMIzTXCyc2OFg+020QpTrPcxLhZgzQdlGhd9YuJHkgh9RBghSzDmwlJHGQMBKwDYeFnmlbFUCZPY1zzfZEms3EhEd9ppZdHh2mszh0kikUgkFiZi28lsErLawjFqy3MkfWVr/d//jZf3ZK7BUVdX+Ti8JC5l07L5bM3pwnfjkBPsoFNOKeXww9ttM+xMiXNFYo+yD0Ryd7ff9EXk+M6Rx+yhI4/sJ53q0ym7BAybjR0FtuA4XvgBD2gJI3WwOBqkCmg3wkQEzSA71kKiLeuHHNJGAbOxB0VWGx/aa0HxAx8wFvKs4UQisYROv0GaCOuLvZNC+iiCxZjIEqMuFLEvZNDnFIN2dvfrUlSjcpKQGdnUCVDjeOWlBkpPMjH5aeYbsfVL31HOM03cuyWxYgEco7gZsIjizRKJRCJBv7J5usfmThcc82HbRerjhBELyIotcYoh2w8hoC5RH/asulsYrO1adWb/+ozNMwwiMmxvse3ka19riZj6OF0RGH22INKDXRORKLWtgGDoyxliEfNRjyrl29/edAEQkfK5z7WkFJs0osC9F50S/XznO7fHCyOKECPsW6SI7Tkiy0GkiK06fIFBEUEWGbVdXhT3Umf2cp+8tJMMPvvZ1ka+/e0XoTGXSCQSw/Y9irAw2VEgwgQXwj7UmcDE7zg0xEat3IORt/IgcqbPwUWmDFOaFJRQzrvedaPSpUjG2QK02CAb+n3vu+mWLMpwJkffDQO5RgIySlY47ULAOHuTJyojcRkgCZNEIpFYROAsz5YsAds22IZhT3UjchEVnHM2lBenPPKGbE705VFhr9HVFs2C4ABEkjrLZzIqHx2ige1n+/ajH93m7LDQ437aLvKkL0IW4UEWyKPYBgPqwb4SqRxggyNiRIOwYUVzfPe7U8sT5aG+73vfVBv3O99pt4lrJxvNvVzn+m98oyWxghhRrusQKGwudh07tl6sYpeJdhGdhFTR/36PgBsUyU0OfAnjxPsrrlg+xlEikVgmyb9M/CbCcU7GWehAathqU+9LHSeB7ahtOZStLSpLHCspSspThvkaPqe8v/nN6SUmG4U6AZmwYSs1DDJ1mGtyZlwYL+PswV6zpiXalgmSMEkkEolFhPk46pdjH9tMAsgRNgPSgIPNDqMb+6J95xORo6QL5ERXVyMtkCu2r6i/CJI+koctgmCQIFZ7EDDKE9GBCBEJIiIkFnvY2LbDiMZgd8YJjkHkKMvvbn3rqfdB2iBiEDNILvnjajuWfaovLdIoI/pAJAmChN3LbonIHu1Coqg3ux6pEnZdnKITi35s2zhJCE4+uSVJ/E7eEiDXyI3Sd8ACG5ntJgrn0ENntwUskUgktihMspzBLgNvYjPRmQTr7NmLFaEYY0WEgkeIDAPFMCjxK5lRVH0KYIlFGGzFaLj//Tf9ghFAkdsjO5Pjm/vGImOAAo6IHbJkKDAAkDNHHdVGu0jetjlzxVh5GrU3GaykLZMjhSEJk0QikVhEsBWjTiw6G33NYabz6GJ6O+wr/7tPJC2NY3pFL2zOU1PqLSqBWHSxJUZ9ahvOwo9oa/YHkodto77drTVBLlhoDDtEm0VfsGG0V3JZERru9/3vt79hx/gcbAOPRbuIgukSO3EfbRD54nuv2M6jPHV0T1ue1OG9721zl9gyA+rnenVRDnvefdX94IPbCBZRRyJPtBkBRAbqGUSLNpCBOh500EaZspGVy+YJGxCJ4zNkC+LFtaK4Rc7c7GYbQrsTiURisQEDjB3uc/JNjhj3OkRwMYMCiDPhKahRqyzDtuQopxtxESDL2PKz2HHJJWWCcu0zsCL6iOKdC8JEIjHKmkKuYdVFXzzwgS1xwxAg++6K1nyCwcEoGBXhsmb5nJADSZgkEonEMoSFFElT6Wy2gGiGOGo4tm1Y2LD9pHawx1l4mM9omh/+sN1OE9EetZ1Xb08XYYGkEOFxxhmrN7H/2JNsn1hUs2VGrhHRF7HIiJCR+42t4h4iRKI+CJO4LkiKLvoW9iwgyTXCxtQH5IwUUV9l+15/iNSNiFdliDTRHvLXD+rqvXI+/el2y7Xv2cbKsEhkwRT54T6Ila59I2IFMab+rkOi2e4jskZkjrwpIatEIpFYFDAJdpOYYn8pvEGOv7BBE+JSAYWkzbF3c5xIkL7j1eJUnUGOsdWJLbV1ZK5x0knleoZQHxgAlDFibbphtlZAvve91sgA/YKUsFpS7+ut89DE5+TLUBnnWMO5AqOC0TFOBvxtcktOIpFIJBYY5ko/0fecefqXbclZFgnBwea80+f0Nac9oktgJrbCTID4YOepT02YRASoRRikgL8tGMapOH3ykU/tyitXTLHpYrFIWRFVg8SQTFYkRmybEVnx9a+3RAn7ZpDNGREmCAfkxAc/2JJO3egYYI+xn+RIIWv2kN9qAxvFEcSiTdgqkQ/OS6RPXKfNbbva/nDije/VkQzYt6J59eHHP95Gn9SRvwF9i3iKrUy2HRkL6h6RLONEcycSicQWASUVYY+xrxHzbxIzWQrzw3rbk4g1HjSJIxjmIjnYQoLVAqx/d6/ouHlMKAYKoHuqTo1xMqwvBlB8v/1tmaBcRyU37UbVWMUZlOCNUjZGrWgYj94zMKa7CmHsbo4kcmH81RnwB+G66xbnaVIzREaYJBKJxAJGrZfHiawdNxpUpCeShIPOwaYjkQaf+lSry22hvd/9pv4OATDf0bdsEwsxYU9w2hEMYIHQIiCbRvQDGyfyiQzDzjuvbwgItl8ks+3aCF4W2LQRuRBHFz/sYa3dWZMrEIlVgY3p2GWRHuT4rGe1cu07bEH+ETY8O4pNIoJD+QiP/fZrf8PGVWaQFeolUlzfB2EC6nbPe7bEhwgVi1ixSGpRSrSMCCHRKf7u2oLIpYgsQSDZLq0cMuVjiFKJhUXXnH12JjFJJBILCCIgwsnn4FEYMfH5m3NrJR8LvdgTus4EJvBxtxl185hQTmQ5LDplMR4tTIkKo6xPgkGwWTHpQ6wodJMEAwXKEGCEKCNg9cGKR4TpMgyMQYoVYTJdci7CYcc5vWY2YJgYL5EMbb7vt4iQhEkikUgsUJx77somz0X3iN3ZQMQtPcgRl8OMPo9DA5Ahts1apLOFdtC9ZqpD3VcS2WELF+xf0RPuzVZji4k2sWiIaKijpmMxhB3hmkGRwdtvP9Es7HzrW+39LdaA65ECyA2faX+QR2EP+Yx8kEsImwASB8nhe7aRZKxPelL7v6ha1/ctviA95B5BnCBG/Na2HPfzW9Ei7FP1RWiQlfv6LnKNdA95ALJBrChTndxbZC+SxG+RbX2RIurJRopcKeTu3mw/tl1EKOuXq69eWgn+EonEIoaJH+tswjWZmxyxvYD5FllBYWS26vEQWcApeESA16iQ1sVGmDAaTjihbZus6f5HbFDod75zWcEg6CL2wQbq5GcRBrr//q2SVJ4yfE8pk0/8liytSEQys+kCyWIl68gj54/ICMIk2lkbPTWWIZGShEkikUgsQHB6L7hg1WS0w6AjdqcL0QaxzYYzrexwkjnucmOIXBgUyeLzPptiHIgoZd+qQ9+pLKAenPh6MQixg9QIggNEe9DlyB32iq0ztqH0YYcdJppr2QKIgGj/Mce0dUGiiDomX1vc3cOipT5AXnixu+ujikXjIDvY7MqtF4zYEqLE+7YAs5N8b4ELGaEMdUBu6Acv5SlXu1wnIihsfvZYn/1PHha+wt5ho2mDOssrh/zoA6JIPS0mIlyQMmTN/nv4w9ttSdHeW92qOqc4kUgkNicokHoVv5uMaq5CMJczGAUc/zqUcSkRJsgSRg5jh9IWzoqEeOQjG4W/tSPyKNka3eOmkXJBmERmd2BEWEUJ5S6iRNhoDfe9171mVncrSFZbjPdBBtRcEib6P5KcBaKv/b+M8pdAEiaJRCKxAEHv7rnnukanR06NWpfNFN0kno9/fEs6IA3iuNlhGGdrax/oXISHyIpw0ruIPBt1BDC7jT2CPGDb/O//traC+j7oQa1tgyjh2CMSyK2L7babaCJUXMsGiG0/yIkgcGL7NtlYhEJkkHeQVeodSXG1RZ+Q22c/u6n9EycLDVqEcV/lsdv0h6002tLWtS3fi42G6EGGqIf6dbcTQRA7FlX5DYgTOUiQT+w6ZI+y+mws15HxN7+58fdO17nHPTZeQx62qd/whstvVSmRSCwAYGxN8CYiExJyBLuLgTZ5myi7yiMxfYiAEKmDNBnniOX5IEzmK3rBuKFYjRnKnJKmfBEbxtKZZ5YJhFv3eGXGSp3VnRFmVUVZsQ0MlEf5k98g2Rmfs414ms98JoykOhEtEshYCIjE8Qwus4SvkIRJIpFILEBYuNhjj/WNs8sW5PzSZbOxB9kh3WOJLYTQe5F0dD4IkyAoIvcc26SbjH9QBE1NEtmKLq8KggS5ox2IADqdDXHggf3RqmRGhmwYBIVtTuwaeVAQJNruGu0KkoQ9JHmryBVgQyAfXKMMdRKBYbHHFuUayBZkCHKjLxqHjUkWSB9kkGuijZFDJaJFvLcoxT4SadJdsKoXwNxPO/WRerFzlKdtIkZE1HThO+0QxcP+cx+fqY/+YB9JGpsn5SQSiS0Cio/CsHqAaTbJ1XkgQqHEdpzEzGHyp1wRB90TXDYHYYLVP+ywma3KjAJFSTFSavbnIk4iQoTRcP75ZS0jo06KRgH3hXVaJWGI1CtYrlH+oJOY5gr6xipKNxJmtoiVlxraFIl9f7/BaNM3cYTfMkISJolEIrHAQBchAyJqgLNK18tFMRuwA/qibCUOlbtkHHDGp3u0sMUcW1RC34ZO7hIbQZggEDjubJXY6mvRhx3CqSeTIH3oeH/T6ZKnWkSKiJyAa5AT2ki2InDvfe+2HmxsxITvlR/bcuQCiRNsIqeguvz4x22CVyQJAobtUp+4qE3qwI6K6I0uYtsz4kZkCeLGfQOIj1jYUQ5yxXG/5K6+ZBMHQwAix+fsJ+3zXRwQwb8AhArbpy9BLtmSHTmyfdmMomc+9KGWZPFyj8xhkkgkNjvqo7ooMArF5F1PvBjzvuROiemD0om9mKMwl5ngKR/K+VGPKuWIIzZmVZ8rUOTGkdUn7ZPDhPK1TcdqxB57lPW+r5Wk1QL7ZftkZPWiG5Zr5cEKx3yDkWLlZj4Mzy4iZ8tll7UkJcIkI0wSiUQisaURDnBApCf9PtfbcWqbh53gvqNOCESY1M79ODaQBUHOfJ3AFimAqOjaM2xhW4BtC5HINeSgbkgAkRtRxzgamZ5HCLiWvv/+99vjfQOnnLK6ISAQNmTpfcgycrQhRpTBFnAP23TUj61k2zybEEmCxEBIIB8QH91ImXq7M9uebVZDnZXtGv8HYVLnR9HX6mkhLHKnIGvYLWRj4U+fxfYjZfoemaT96u1FHnU+mPvcp5XNj37UnoQYQDBpp+sRLGy+2KJla7cTOUUiOZ45kUgkNitqpt/EZ1Ksz7sHE9c4ERGJhQmKWDinEFL9a3Xo6KOnXkPRzyaahaKMEFZkh5WHBzygVXRWSCi5OmKGsqdYB22voTC7JN3m2hJGRn2rMbNBN/w4QGa/+93GfcL6KgmTRCKxmGE+s/qdWHgQLdElCAZh0Ekos0UdcdCHr361Tfg5DIiCiASlXzn9g5LA+g7pYVEC0cKWiGiN0MEBZSID6GFEBDsGeRJ2MgLFokpESlh8QijY2i7KI0gKMlYGoiLyj5xwwuqm3YgPkRQIE3XeEIXb2ETqIo8H2asnQkddRVsgDzxbfuM70SFIExG52ug7tpxIDDZY1Nn/tU2DOGIDOoGo3oKvvDq/CJ/AlhyECPvN67nPbZO3qhfSy4v8I2KYrJAe2h6LXiJqalsvti8hUSKhP7i3+yGFRLOwF73Iijzc3zajm91sns+UTiQSiS5MrnU0CUXQl8wpsThB8TA+KLDYzuKIXwozyAuK9FOfmrrqMl0wDihxCpcR8axntStFjAPkR5AdtppQrgwMqwcLEVZ8xjUoZ0qYMJjscbbCMjGxMUeQa1zLUFlGWF6tTSSWODjEnKy53tqYmD3k8BhFRgTo9LlO9h/JQAfpOOOGc93dztIHuhMxhzAQ+SFqQVRr1wbibMunRq+zUSwaxXVdwgQhwpFXP7YAe+ahD23tGd+xl4OI0A6LUQgN91BubN1xHRJBZK/y1ePii1c25dlm4h5sI/aXtsr5hkTQDiSNe4nCtWXH5/oNCeKlTP3y4he3JIqIHcTNO99Zyr/8S9tOpE+QFOwu9p7rPv3pUj7ykfa+P/hBKV/4wsbIXW3mE9QRyNqozkHQeG8BtT5WmWyUrU6RMNfWajIgw77ceWQlet0L6cMmJVeyZK+SGdIFoaLt739/S7R0F/sSiURi3oGNzpNvFjYoptkYnVYdKKFIchZAVjAYKGWK+nGPa6+dCShDypRiC1JmUPJVBgLjBmmzUI+knsutUH3EZIQGM4qE3J511kYyxerXTI5FXuRIwiSRWEKwymyOr5NaJ7Y86GqOMn00KAG8SAk6muM7Hzqagz9sW7ItvCIS+pKxdnHAAW2UhO0ktqlIGoqQqXObxDaXOmcHEiDK7yZ+dQ07BnER9jH7JkiJemuJbTPkKXqFDo/tNeTL1kEc+B6Z0h6eMNG0zbVkG1tl2AB+IzrXIpP7sNHUQxnahixwDfmJuLB9Rl+x25785NZOlAMGMUS+nr06Oohdg4A59ND22TzkkPZFhrbIhKxOPLElKALsEXU2HurF1RrqFhE2IYMYO11CqgtkDQLPgp02kykSxaKa+0Ubn/jE9uX9JZekyZBIJDYj5ivcMjF3oHxmk6SV8cBA6ILCpHgpqkc/ulV0FCOFPAyuD2NEvayMBPFWHwM8CIwIxoAVk+WEIJXAyg/5h6HxwAe2xoGVI8aFVSHGz3ydaLQAkdZPIrGEQO9w3PqOVk3MDWaykMI5Zw9E7qxAHCkrQoOeop+RJuOcVjMTwmbQVlxEG52IUHDv7ql6ffZEN0E6MkEEZ4CdEoQJm7fOyRJ62csiCdsEecIW4qxbsHINsgNhwM4JmcSJMogB7eH4x3YW19vaTs5+h4Cg93faaaL5PaKC4y+aW3SFPlGW+7Gv1JktZbuLOvteO52+w95CpLifOsTWlz/907advouI35rwso3GfX0W+U+8RHT4nTpL2P+wh5Vy+OHtglpEmiBghiWi952xpWyvmiAZRZhYJIqtRCJn1EMfGZPIm2c/u41YVg4iBdn1858v0NW2RCKxNFEf25pYmIij/OYiqW8NBsJjH1vKIx6xMT8NI6nOeD6IMIlQVg7+SSe1pIlxJHLCasgwUIQPfnBZ8CCT2Hc8F4ZthB8zvtpjGjd+v+22bbQJOcbKFLnO1/HGCxBJmCQSSwQx35nHaqc8MXfg3Mf2k1GLHMDxpXvod458167gNItukOcMmc9Z9xqWZ2QmcM9hiyq2qbIltEm+kVH2SB/UmfOuvWySIEz8HSfZAPIjcp5EQvpYDDJuOeeuQfpx+OVii+T2IAGpiA73OvjgdosJ3e4eCBs6HumC7ECYiCLZfvuJpi7kjxwC5IZtPSI91DEIE0SCv22bsYUHkSMi1fvIk4J8QoJENIZ761917kbJRs4VbWOnaQvSRtt8TtYxljzDyBxjDJlRJ5CN3Cw1/O169UEasWXIByL56zDIcSdiRr38znjVN+qqTl5xrDNCLHMqJhKJzYaYTJdZroRFB0qQ8pqp8075DiLFuklIGQiU+jBEUi/jhzITqikclYKPo6hHYaFuxanRlzl/pmDoRJgqQ4acuglsV6xo5R8h7Iywblb7JYychRKJJQJOU+R4mMnRr4nR4OSKPqAz6u0TwxY6ONURDcAmqCNXOad0Xm0PilqIyIw+BAHRB2UrMyJSw35hOwwiTGzJoPMQE/E7CT59bltGDeUNO0UHWeHY3S9+sSUvtLlrC9VjM5Kd0r/eRxSMCBHOeiQvjQWoSJzrfZAwrlcG4sXJOCHL+963JTmQE5KVRkQLAgI5ENtNLFj5XNnk5391996CiohgMvd5ECtOI7SNxd9IDWSR+iA/Btl9yjFuguRgn8Rxx7Y0GVf779+WgSz5ylfaNqkv++XYYzeefhjQbtu+Ix8bYieSwA46urmGLUdxOhDiDoHEvkTgKTfy2Rg/yt9qq0z6mkgkNhOCwU4sfFiNoMgZSVZMpmOA1isqo0BhUZCDFBvlh+yg2GVxR7hYgRExQrlSeksFc02YkJW+YNzGdpwubrph1c999UXcn5FWGydLEEmYJBJLBJyaSAjJ2RnHoZ8LLKMtjI0NwH7zCod3kEys1nP6Od/1Fmw6LiIs6i2j44JN0peYlY2C4AhnX7RkHFWLEAkyrQbn2nUiXtXRdi6JPznqtscgHGogGoYlhRWxQOc+5jEtIUE+HP1Ibgo1acQJjwgci1SIB/Jg34hoCNkEYSL6E+kA/kYYsLO0TRJVJ9qoo204bCrOvz7bY4+N+6iQMLad6Ad2lW0vyCILUAgbBAiCAongZasNAknbtOVLX4ojdtvnjIwQRWRtUSa2A3WBOCPbyI+n3trN5jCe3AtppP6iZshCn/rbvWwLEg0TETLkph3qT+YRlVRvxfEZkkV/DkL0tT6Sk+aP/qiVp3J9p562jemTNWvSZEgkEpsJg7ZqJBYehDbHsXleVhWG7Qnt2woyLhgBlHwfKH1KmIKXmT4UI4Xps25CsDYrfFmUEBEy6IjCcWD1JvaYM5TIh+OAbBrUJ1tt1cqM8WEVzqqYchhnjJMl7BCk9ZNILBFwZEM3WK0e57ST2cAcaduCly0E9Qkfy2HBi1M5yBH1OQeZQ86BpY/j2tgyhUyZbqJxegoRwCHvOuVIfw58kApxDK5+QQIEgUafhX1Av6kHwqDWwQ95SPuZ+kVEid+wNYbZQBx3pIsyER7sFURAnb+E/OooGwSCe6hLXY8ayqOXjenYMoT4iDEuMsPWEttk3B/JIXeI+iNldtutZbYivwhC5GlPa+06dUF4iNpFSJAXWyAS9iMORN6wIbRPuzxn7kcm5KU+FlrkRUM89OW/Q8a4j3boK3Lx7ETi1xhTiAlEkTapH3/BophIFKQMO1EkjVNrbAOK5LmRn6YmpKKefjfIrjIW4xhj4yTyw8hrokzfk7VTgyJiN5FIJOYdlM2wcMvEwgGlRTlSmLbMUHTj7A3/2Memn6PGyoOVnj64Z5AiHPpjjtmYKMxKRBeUJWONwbTYUK++zQRxZDBDzWqQ91bkuqcVdbHrru0KkxXayKDPeGCQMHSWKJIwSSQWOTjAyHyOZOgJDhDHazaJy4eBU2lupbc4pjPNe7E5MJdEDsc+knDSFRHB0QVyJLZrcJJtd/Ceo8ux/uEPW2d5urZgbLviCEekAVgkiDwYEXnBUQYOtu/oRvVXD0k96TgkiqiGbpRLON2IFwSMtvifLTTOAoLfxgkzXRulJkwsaugfdpZ69yU4jfuxg6JeIj5EXIjAiC1KiBe/90Js0PnqQF5ByvzzP7dJdfUBEse2GnpfGerKznO9e0RUkLKQU8ol93i2/C/SJAgT9pZ6xJaj2MYTddfX+km5CI44fac+HED5onMQQe6BAGKDkJHFVuPGWFKGaBrEkLKQQrEg1N2OF1E02t1NBq3OyvVb7TM21NG99bd6kIWtPmS//fa5JSeRSGwGROTBdEMwE1sWkZgL4z+MMEFkCM/kqA/LbN4Hhi4l1bdiRYmH8ULxUZIIkYc+tD/MlrJkgAjPZSQwKpY6YeI3ZESGDHjbbyTXtQfZa9Qzt8ce7W8ZHsgT8iVbsp7psc+LAEmYJBKLGBy0b3yjdd45fzWsCg+KWpwtrHZbSY+ElCJarMovRCDPOdgzBR1KL8fW2AAdT/7d5K+cTk4rR5vuQCbRK3QSZ5ee4RhzdKdDmHDAObec5dg6GtGUcWyvhRTjQPnGhHuwXdSTXrOll267xz3aqCCRE7HFpUY43bG1y30RDNrPVhmV8NbCIAdb9EQ3stPfESljzBhHiKB6204NCx4WiiwosWvYWSI54pQc+VJe//qNCUmRUkGSiTZhUwDnn+Ov/T4H/UJO+kl9yYq95DdRHmKJjHzOjiALv2GXuV6dogztIDtkg6OE1UX95YNxXSSvZVcov5tXRvn6V7n6LmSnfz1j/o4TcSLSqZvQV5u6Np+xquxICBtAtCJhYnHNOA8yC9FlfJFL/H6ffWZwRFQikUhMFybTOjQxsfDAKOkmNaNMhHZSdN0VOwnOGAeRuEyiLsp6JiQFBfXtb0+NaEDQMHqtplCMjAoKVXb4MFa7UB/XWJk4++yy2p7mUccELhSQ80wS7WqfVTPPl/YzRkadHFSDUYBYifcRXTLOEYuLGEmYJBKLBH3JNpEBiBHOWBfzRWLQbbG9IMCBo48W2uk8cVwtR3FQvpFRIENOdjjDNcg+kroGgryIlf8a5MS5pWP0Z03kk+swcp4eIuP4jXvEllF2ie8sHND9yH73ok99xgbwmfLZKaIi6DcOcd+JPLFwgdxh/wRpMW5CYTp8mP7VVoQDGSAV2DWDtichbNxTnZE12huJ8y1iSVCqb+UbU2flIYIAkRFbVpAQ7vPkJ7cJYQPkoI+Vr+8sNFmYQgqRj/a7B5mwC5AKZEHm5ILEEM2jDjFOtA1hQu7+lkdEREgQJra3IHAGnTqjHSJfAvo5jveNE4gC6qPP2YlxeIC+7x5/TY5IpyBHlMNmEiVmoU9fqL+oHPVERslpgpxKJBKJzQpMdewzTCxMUDif/ezUsNPYW0vpQnwXRwvKLI7oeNjD2j6m7LqhuhRrrO4MAoPG3mGhzkInGR2UfOTVoNStUg0jYyI8lcKkRPfZp6ylqJXDWELwUIYLGeNGYNVEBmUfyVrJmrMwXWy11cb7M5BiWxVDZb5C27cwkjBJJBYBOD+f/OTUz+gZTumgvA+xGj3XuUVEl9iK0IVohDhVhQ6ycr2l8j8dcUSrm+lROhOh1F1dHxf0jKgNUSrdrbYIBc58nLLGGeXMk7v+EV1SHyMciFNg6r5hMwzLOxMnyAQQJBYH2ByRaLRLOqgvO4WTTu+rr99xrsmEbqujRaK/6hNW3FPdgqTonvQzKJKanYI0UL/a+Q99HVtS6NpIVtwH92aDISWCjApoj7IQCeTMFuPwIzz0t75BdPzmNyub70V2BPES0FbElygQn4tCIU/lxul6foc8QBIaD2w13yOb9Iv2SsKPeLBoox/kRFEe+y1s/8jFAsaMfulunTZukDgRHRbJa8lBWdochJXv/E3W6upvW73ct+4jz6M+UGbYpuxM7QwS76tfbevtM/WN05vyKOFEIrFZQZmZmHPyWdiI4+1sqwlQkBQKZRQn2vgMYy8qwZ5TypTx4zrJwerj+KwAIGIYBsOylQMFKnrEConVCYaAMYMMoMy8p8S6qwcB10UIaoBCDAPX/ws9YsJzMo6hbU92GBsMAs5DGKmzPUJ5j2r1VH929/4uESRhkkgsAiC7zW31dsX6GOFBiASjcwn6o2/hh+Nm3vX9Oeesauq6pfI/WVzgOCJ3OMNW0b2fac45LwsPfbnJEFZBmHDsOdFsAe2PnBfdk9/0S+TKCJBVJCDvqwdHv7u9JcgM5XVPYGQ/fO1rbb1dh6CIrTnIDzo2iJaI6qTnIiFsnFjn2nqRRj+zb+qxqKwghtTVNWwoJE046fX17BjXi3DoI1/cV/3VJcgdJIBytKGWkUUodg2SRJ2VZ+GJzWWBqN36s6r5f9CBC/Ec6UuklbLYIQiOOircfSycBaHENggiDslBVspiEyLqlIdo03cIliCdYvENyVjnogF/I220g9ydUAPGlL4zBkOWQaIgaoxxZJE6qpP2kyNbkhz8ngz1sff6x/WeV2XWBwqwU7skVyKRSGwWdJnxxMIEowX5QWmGkUM5WQGhcBkYDFCKHgFCcbZZ2FvFROG89KWtAULZMiRce897tspynNU+xhllF+QMBVwfpxef98HKQ59RR1FaJfHdOCf9bEkwLkZFwUQbamODrO0Rn+tM7rtsSAK7BJGESSKxCGD+50TVBMQ4Eau+n4+5a1AUYCQvP//8leVe9+rfEsRBYw/NF+hGEYYWFWJbCaLBa7oRL+GQAhugb8GLLBAVccQte4CzS9dztv3+v/5r4/W+o6PIJ6I7wtZgK9Bt6ongifoGEdMFfe7e7lvrfr+To+Txj2/r7YU4CfmwJdg4nHzfIS/YLOrMvvF75SJGOO1du0UbLBgpy31tg3nve9u/faff1Vf5ZMj+CWLBvdwTEaC+TmPpgi1li83b3tZG7rJdgLMveannIYCQsDUnEuuyy9g7j3pUKX/4h209f/ObVU3fBWHRB31l7Iat5p7IthoRQYTw0IcILnlAyEC/sxWUgZxSf3Jzmg3yhBxiGzW5kk3YkzWQFWTHznOd9qm7Zytyl7i/shF17ieiKsaHOmg7Of3v/7afifayHcmYU56/I2GsOUVOmz/4g7bfjcnY/tW3DTCRSCTmFZm/ZOEjVi0i+znlHAZL7IMNBdcNjwWKi4KlsChDipTSiqPkgLLtrjZ1ofxY1WCIMJQZTBG2OmwPMYNh2Ak9jLthESoLAQw7obzDkr8yuiJEl+HA2BuHKGE8TTdHyooVTZ+uWIKn5SRhkkgsUHDOOL3AgeHw1OTHODYFXTSX81Z9Skwf6El66ra3XTdJztckBb3DCeRQ043zkWOFrEQS2BLBeQ5EPg6wTWXUwgG90o3aGASkCLIjdHToZ04vu4Kz7H7ec/b1iTrSLfE9h5uzevjhrQ3g89/+dkVjd3CY+3J8qF+MibquyBbt1f/K0S+iL9wjxgP7hp3iOvcVxaT+6hU2CBuHY10v0HgvsoK+pU9Fgsi/xplHdHDGlSO6wmdBvrg3G+mww9p7ev/wh2/cIlRD3dz30EM3JjPWH5x9n0USX9dpY5yKg1ypo0iMQd+tXLm+uecwsJ2M74h4Yet187B0o3kQFtoa9ZFMlk1iu4vvjT/2FlmwWcI2ExUjakb/e56CODNGvPcbpJaEzuwgYyCeoyjDNmvyD8Ku3lqlzDhRkZxFi8jbIhee33zpSy2ZFJEuEb3C7rJ1nP0bW76WG4488sjy6Ec/uuyxxx5lxYoV5fOf//zAa1/84hc317z97W+f8vmll15anvGMZ5Qdd9yx3OhGNyrPf/7zy1WL8djKRGJzw4TXF06Z2LLgOEeSrGD2IzQzjkmMFapYUWMAUYj6s15lo0Apn9hPjuSg8Dj/wjsDlO2obTkMICe9IFwoYwrO6kLcL5LrdVfLtIdBOih5WsDvZ5LHJI4XnG+QraRoVmYGQR8w9uIUoEh2NwyMWMTTTLYk3fKWZdVCPQViFsgZKZFYoKB/zFecL04g3VGTH6MSa3aPcJ0LDIpgrEHf7bZbu/pgTq7nW44xvcih44zRKXOdUysIE45yfXpIJPDm5Lo/535YIlikg8iAcRA5IyI3hvuQPZ1NV4tAFWHB4XZdJGtlT3BoyYLutsVXnTiuFl8uv3xl85sgYuJ0mTj+1X1i60yc4uM7940FnficjtR34VjHFmOIU3uCZDHOjC2LPeqvjFjoUX5sGWE/iebxHb1t64dxGpEZromoDsSHbbTGh+T4+sZ4cpKOhaHoC+M6onB8F2McIaWe7qd92uPZEDUBkbetC0TjNdesaNoxaKEpTiBSfmyv6gNSyf0jCav2I+aC8PFdyDC2QSO7tE256oAEYbewMcH/bDz41rc2bn/Sf4gMY6fe3mbses+PJ1Pl6496GzgoRx3Ze+wl99GfykRGxfYcv9UO5VqEsjVHHxm/kZNvOeHqq68ud7vb3cq73/3uodd97nOfK0cddVRDrHSBLDn55JPLEUccUQ4//PCGhHnRi140j7VOJJYI6gzjiYUDSsQe38hMX4ffUnoUBeMgwigjOsRKgRWWGowhxkiERTJwKMc6qz10jd4+UKZ+T1FSZu5Zb+dSXt/pLerfM3dvgpmc/MKYiqRimwOMwEGnLjBuIsEdg4BS94wNa7vfMAoYBDMx0HfcsUxM5wjIRYIkTBKJBQoE7SGHbEw6znGM6DjO0LingI2bE2ocjBtxEaiPZeeo0R8cQfrMPHzAAW3+hdnKqW5fECYBsrLCTn/FMa+caHWTSFcUT1cf+luZg3JedKGPOJmh27WNrucoK4veoZ/ljXBfzr1r2Rv+FqHhNxHhQae5ZtttJ5r6cm59/4lPtPJSjpfFF79nk0TkTxAmEX0U+fOQBaIalK1P6n70Phx8C3tsGfVme9DD9HEQCcgdNoryfUcP09NBrtQ51NwTiaHvlRt5VJy88oIXbHTy9VFszbFVSH26W5D0XUQMsYuQL8rvbpvpwmLThReunjy+mPy6JIB2snH0wyDCJPpEvfRl2IjkT75B8hjjEsh++tPtAQLyhCB29K02IsXqU630t/YHgec69UGE6DuLZ+QWi3sRDSR6xLgic9uIkDbev+ENLeHm74c+tCW7nvnMtt/MGSJNyM/vEZb+Vp7xrm3KitOVRIGR+0xOfVyseOQjH1ne+MY3lsc97nEDrznvvPPKy172svKxj32sbNVZoTzllFPK1772tfL+97+/3Pve9y4HHXRQ+Y//+I/yiU98opw/jI1LJJY7TIAmv1HhgInNAxM/BRLGhgSrlJnVPHMZpziSl1FkjCyf+R0jD8kSR67VoOysnEUUkWv79o6PyjBvvEQZj3hEe20f2eaz+iQeyo6yHBVlAQya6RIfZMJoHxUdM5dwvzoCKFC3k4K3F9pK4LAtOfEbfRlhqNPEunFXGxcRlg1hMizM9vrrry+vfvWry13ucpey3XbbNdc861nP2sS4yTDbxOYExwhJbwtCrEZzeOiiOhpyFOKY9M0VYTKInKdDQpfFsaeIDKvr9XaC6SJyafTVMXKIua/cZHRERGtySMPhtg0hyCg6mCPPwa6BJAhiRh9EfoeIvkCY0Mm+8+L0c1rZFsgIfeB/fRmRJ+oTxEZsp43ybNtwP86y+oi4pL/8b2pSd7+JrSFBgHB0/T7Gh/fIFLYEUoOT/cUvbnoyTR0BHbaOvlM/ehaREeQLe0f7I+eJ67z4jlFOnAjj9xxzzjc7WPSoF/2uLJE8dDMywdYWMtOWWKgKhBwhtjzHdp1hiGeHDMk2ErvWIEt2gW09g2wjW40QNvqAjPUPefrbOI+kwsqxoMYe1BbtRqoYT8g9MqxP6QG2hciOOIlHfyI4RK+wNeukxexV8nNfBBA5GzfGHrUmn4sxot3yuqjzIx+50e5E1hj7CCe5TtzPGBHpZAw/9rHt30hA8rXNCLmypU68WmhYv359eeYzn1le9apXlTvpmA5+9KMfNdtw7ol52oCHPvShZeXKleXHQrAG4Nprry1XXnnllFfcby5eExMTc1bWcn6lHOdRlmecUdbvuusW7+MF+Vq7dn7H5KWXlvUXXTT1s29/u6z/znfK+tNPL+vPPLPtm0c+sqw/99yy/ne/K+t/8Yuy/uST22tvfvOy/uc/L+uPPLKs/+Y3y/rtt2/LXLmyrF+zZmOZ55zTtsX18dkNblDWX3XVpnWKdg1q+5VXlvU3vGH7Xh1PO62s32GHTa9bvbqtx69+1dbl1FPL+pvcZGP5o2SpzN/+djw5rltX1l92WVm/555l/eWXb77xseOO7f1qWWnrz35W1t/iFu3fu+zStvu2tx1elrbe+MYbZVf33/otN09uafSkMFzaYbbPe97zyuNlQqxwzTXXlGOPPba89rWvba657LLLyite8YrymMc8pvzE8loVZnvBBRc0YbZIluc+97lNmO3HP/7xLdCixFJGTQrXEYqcYGQJMt57jlv3VLQuOFyRM2O24AwOS5zZh8i5xQHnfAFfgK/BUZRPhAPuO0QDp3vco+VjAUT5EQFoXo1T0jjZnP2IbKhPKuGUcirJkQP67W+3iS8RMBzyboJXDiuSwfVW5N0X2RLJd5EDPouoyCAyXCtXBweYQx5bNCIfWhAmfku+sVXF+1/+cnV5ylNaMkL7yAvx5J4R3cH559yKjgj5kTVygZOrXESbtrs3Z54Tr/zISeM6fRJEE9LD/Tj4/D4kw2c+0xIafk+mnGv3Qnq5v3EY8lHHyIuBfNEP8mbYPlOPQ9eK8kUmcORFZdiGo//rRUbtRy7pV2UH8TEqHxxo3957ryuPfnT7vDg9SfvUP4g78iIb9whZ1bl6jAnEgjYiKBBA5G2cKCOIQc+ZdpOnPhRNQob6AtGhbeTVPQDCGBHQoE/9FtGiHGNIn0SeEwSZco0DxEid/Na1iBl94z71CT/KRAT5X1u9LBYaa0H2GTtxfRBTxrx7a/dy25ozCG9+85vL6tWry8tf/vLe7y+88MKyW6eDXb/zzjs33w3Cm970pvL6179+k88vvvjismY2jPIG0uWKK65ojFjETSLluKUxZUyuWFFWnXZaE8bPOZ3XrPCLEBJo3uCrXy0TN7xhuX6//co6hsQGrP/97xtydbbP9qrTTy8r1qwpa62oKOv888s2P/95WfHb35ZrDz20bPP1r5dr7nWvsspnnOF99ikrL7qorLj++rL2zDPLxFZblR2OPrpc/cd/XFafemq5/rTTytbHHdeSLGecUdZRsOvWlRt84Qtl3W67lespzqqfb3DllWVNT7+vWr26TPDDVq0qK669tqy66KKydu+9y4r168uKK64o6/bcs6z86U/L6uOPL6vOP7+sPffcch1Drosb3aisvOSSsvLMM8u6m92sqW93nA2cJ7feuqw+4YSyNjLnD8GKyy4rK5AmF19cVqkfA2DccPBZYtU225SJ449vyBoGxNY//nG5/k53KhOMvQ2RIqt22qmsG7GCuvrcc8vaDStDKzckHlw/7grtPOmb3y2AhGqrl1OYrVcfdtppp4YEqfGud72r3Ote9yrnnHNO2XvvvSfDbI855pjJlSNhtoccckh561vf2ruPObGwwKHhXI6zKr2lYY6NlfEaHFArw+YgzimHxgkXwyILXWfFuc6lNZ8wv5599qrJk944gVbjraoHkcHp4/DGqSoccU6arQyu8d0487Ny5I2I/xERQbbwMZBLVtmhe0oOMoPd4f5kjbjh8HIMu9s86BcyVl4kcqVv45SYiEbhrIpkqEkR5UXy06gb55YjimiIrTvqx59SX9MJJ50T694c1jgNB+GjviIKOOqSqEp26jp6mbz9VvnkTpZ+G/qGL2cc0f3uz+nXBvUmw4g80V+ic5Ac6u8ax+Xa7mFLh/aoi8+RAfJeyk1CpiJ4jQOkmLqTp3t1twIZ57bI/Pmft84/WSEZECfGAnKGDF0TTjwygZ2j/t1IkUE46KDrmnbrM21E0uhr/UVW7AukTh29G6cSApLDUcWgHU94wtTv9betLf/zPy3xpx8jEoX8EFxkpc4iaSp7txl/ok7UCyL/jOu0OaJR1Et/aodxp5+Mj4hiR6zE1rA6GbR+EkGlD8k4jmlGyERiV9f3RdZEDiRl6+dR+fGWOn7605+Wd7zjHc0Ci0jVucRrXvOa8spXvnLyb07QXnvtVXbdddcmeexswIBVX2UlYZJyXAiYMiYZZybAelJNhKDaY9DkQKJMP/ax1kjYwOhPHH542fbXvy47vOAFZaVJmiILo2c6oOTiOGf9QfkzKFasKNszMr/61bI9xeQ6/UQZUYoMD79z7UtfWra1B9X3EnKpL4XIcFKusFAKXj27PtPNblZ2dH13BdAqBoOA8mFUWKmglChduVAoSErtGc/YeJIA47HPUe87anDQmOz+PpIRj9ouRnYMJAqf8rX6EvuR+45ZnAtQ5mSsnxhjVlT0nyzv3dUZsh92ZDcZ6+eQFd1jq9Vuu21RfXODbljuFsCyIUymC+yYDhdaO06Y7bD9zomFAU4Mh2ExECac+TrPQYCjzFES2e17jkwkvhwU+WEIuy5O5pgp4ijVUSDjbbaZaPRk5L4SXfC0p228hnNG7yBVzMehny1uuAcHeVzCxDweuTDq7Tjay+Gs/Zo4lcYcjlChEyLPBv0t+kA0SBfsATqIvkNSISEiusLv4h7K85m+iPxn7Ai6LEgQOVPkloi6xpYl+iBOw+HAs5HufOe1zbhVFvIBQcCe4OCSLWdXHpg4EpijT4bKoauRQALq6OywQ8j3SU9q5R+Egzpw5o075bBdkR7KZ5uwR7RJe2I7mHt94Qvt2NN3ZBDEkN/5TOQOID+UyZYhe/d1PfsG3DO2NH/gA+19jHPkDFkbD051UTY7MWwiZM+o/GVws5utnyTrtF8Z5KptkeMnSIbop7Ddg/AKfY30sXWmBlnqD3XWf8aBsa0sfcmu039x/HSdD83z0SUz9RVVU2+b0lbEJ2JG3cmT/alM8tR/CKvuljltNOaNW8SNupCz8azeyvJ9n08eW42QNeQ8jUWmJYnvfe975aKLLmoWUQLr1q0rf/EXf9GclHP22WeXm970ps01NdauXdts6fXdIGyzzTbNqws2xlwYneyZuSprOSPlOA+yNAkxTnJsbgrRFUiImNglALNqxlCxBePaa8u6O96xrPzSl8pKzDllxsgdxW7H6lEYL/ZdUmJf/Wqr/Ch8iomCYqyYmygDbD+lHDkqKDvK3vf2kG44VrYpI/aSUvDKpoAYKIyibl8z5ITcdpOFUjzaTqEy6BgXSJdQlIwj4ZLK1Gb1UucZ5tAY+Hyb8xke3b3aXVjFCGML8aAu2q6eo347E1DwcXwfQ8BYYch6nrr6Rp9r17DnTD0p/riGwaRNK6enN1ZedVVZufvuc6ZvFoLeSsKkB8Jf5TR52tOeNrmyM9MwW/uSvQLdfcmzRb1XLDEcVpS9+kQ133I0BEYRuwHOr1dEKXQh1wBdFA5e6LRhczHny3G1nLdRW3gGgd4yj44S0eWXry977LGukWWcVGOLAJ0RyT/jWHtlmt+RDHHSCvjea9QiLpmShevIjDNPt3JqOYPuX9eXLkYO0K0cYNeQnWvcL04eqn9DP7vWPRAr9bYebatl4hq2Cr1F77guohjUk52DYLAIZGrhjNPByKU4EWVjWQya9WXffY3N1mnnMMeWFmOZXNkkcleEE6w99CTHmG0TUSm1LIyB0J10IQKLc29bknFEjl4WSvSNKc77SIZLTuFI+18dkDMRNWOMkhM5aJMIIuMUceK3yBh9z87y+Yc+1EavkAl77TWvaeWG1PKdOjzveW09PRdsF20QgfLTn25qF4x6tmOxh11nvLAVI9JHHyNy4nJ1ZKf5W91DbvUYMY6QO54z5J1pHqkSeXHcS5lIH3LRl36vz/3dHXPkpo2xlQz8bfcnO5nsIjeMMY08cb++stig7NsgqsjKmPY+tmL5Td+zvSGKuulXz/VNbjK3c+Ri01tyl1goqfHwhz+8+dwWXbjvfe9bLr/88iYaZX/7pprTj77VtFUS2EQiUYESNMEs9/C1QUAUPPGJG/9mSFCIjlszkR90UFnL8KAUsOanntoq3Nj/3IUJncKjnChrUQkUKUVACVMoQiWtzolQoJQZE+6rbHtba7g3owE5UBtscXwdxaJuVoqw/d2s/N0TceoTdSjIMIYpMIoujtFjAFCkCKRQdJS5ekdi07lEZLcfhlgJDKh31MO+8/rUBEYqOYyzCjkMEVZKPspjbNpN0UcwMLJH7alnuHYdFc/ntZ19ysNw3XXN9qg574MtjCRMOpCb5MlPfnJjYP+///f/Zi3g+dyXDLk3eXycddY2Zc2aFeU3v1mziSM+33I88cTV5cwzV5dDD93Y5+edt7KceurqZrtAbSuceeaqDSvRG1iFCpddtqJccsmqssceaye3X3J4zz57dbnRjdYOrcNuu61qHNV99tm03JhL1fHKK1eU/fe/fpO58cQTtyoHHHD9yO3Fv/rV6rL11pc3Dj9ZnnGG+k6UCy5YWX7xi/Vlxx3Xl6uu2qpceOH15eKLtym3uc11ZeXK1eX3v58oF13UtuH3v19VfvWr9eWGNxyeafKSS1aXSy5ZW66/flU544z1Tf13331dOfHEleWud90oo8DExOpy+umcPiSIo2Zds7qcc87apqwrr1xVLrpoI8EJJ520umy//fqy9datc9fd+to99e6SS1aUiy4i663Kgx50XdluuxXl4otXlLvf/frGWaVDf/SjG5Q73OH6csIJWzVH3v7+9+vLDjusL1deef3kFo3tt19VTjzx2rLnnheVn/1sm3LttcbuyrLvvmsbnbbffuvLzjuvb+py17uuKMceu7r8+termjH8wAdeX44+eqvyyEdeO7S/1q5dWb75zZXliitEyq0oN77xRLnmmomy115ry8TEVmWXXdaWX/1qVVPHXXdd19Ttuuu2KiedtLaceuqqcutbry0f/eh2zRg2/s46a1U5/fQVzbHS5567qpx55vXliCNWla22mihXXbWibLvtyvK5z60t55yzupx99srGBnvc49aUL395m3L22deWiYkV5ZprblgOO2xdefzj15QLLlhVHvzgdeW0025YzjqrTaJx/vkrG7vIM0BO55yzTbnwwmsHLoD0PdurVqnHNuWWtxQ6OtGcRnTzm28c25deuk0zDtT5Ax/Yvrz85VeViy6aKOeeu7IZN91n87rrVpRrr6VOry/nnLN1M27Xr7++seeUuWrVqmZ8HXvs2nLttVuVM89csyG6Y2XzvF9xRRvCqh6ev512mijXX79uk7674IIdyhVXXNWM92uvXVt+97sdyr77XldOOWVl2W+/35f167ctZ5yxptzoRhufmzPOWN0QmEiTG95wRbniim2asXzKKavLRRddXS6+eHUj95126n+2V65cUX75S/POynKTm1y+5PYld3HVVVeV06szms8666xy3HHHNYsjIktuUu93auaDrZrIkX027Bm7wx3uUB7xiEeUF77wheU973lPY1O89KUvLU996lNz625ieQNDS2FymjnGFLHwxflYeV8qQHBEeGSAQ4xI4XRbWTBx26piXray8alPDSZMZC+3RxZRZd8nP8RqFqKBw42IQGxEn+gnYcxWA6wwdOsS1wyCVRW/RyZg+4VH912vbKs9NbRL+4SYiuJXBkWGuLGCUM/FEdIb+0zrE3T6wHgQxqu9ZNY9yaeG8qxKMZJFyAzalmOVqaMfJmH1CvHk98gH5EtE3Mx0q47nKVZwQN94IZr68qaMc1pEyLgGmV5++cgtTZO48MKybpg8FymSMOkhS371q181K0L1vuGZhtnO575kyL3J4wOxiji94Q133CTqb77laA6iz37/+x0ndUVEGCL7kfahh5AaIgz7tuxFstQuASxiYVT0iuEmwmHQdRYlRPEhSugtCw+BsG/qE9voEHoD+RRJZekDhISV6Dvd6cblmmtWNosCIltcr410A0dZnf2G7o5tLFE3NgI9MKxNdLyyXaNc5cdn2tr3WKqrrbV0qbxgdJvrPNoWU+jPevsr/cieUOfuAkqtd/lXkQ9MPZBY5KUv2Tb0TE3s0510F5vEde95Tyl/+ZdtW5RnMeLhD19fPvGJ1eWyy3Yo22yzsknyGREWrhHRYDFBH2iLMe0z0ZmiPWyBGrWYQA/aHiySlj1EHqI59Ys+Ei3DntU2ESj6yXv3URe/d9LKJZfcoNkaREezwUQNkZtyyTaSpJKL+z3nOe1YsS37vPO2a+T3299u39hw2mJx4pOf3K78wz+0ffrsZ4sm2raRj/azMSJvjzq616Dt733PtggY9iEbLE6xdE/180wa5z5jW2rfr361bSNz9umDH9xvL7m/aCH9aZzUY9dzayEornvrW3csr351O87jiGKy0lbt654QFGgjg7Zt+tW1bMZnP3vbJjJo2213aBZ0Vq7cYcq9PRueMeWy04wjsnfPG994u8nk0ZFDpQvfi7JBzu2ww/Vlt92W1r7kLiR6f1C15yr097Of/ezyIeFOY8Bxw0iShzzkIY2snvCEJ5R3vvOd81bnRGJRgKNrRd0EdfLJZTXDgmKY7Sr7UsWwo285tV7dKD0rOhQ4ZcXwqkFpUNIUnBBD11GE9nJS4BQPJWZFIqIDGFNCTBlKo/a+diMsIPYkh4KmrPvm/fpIxUAkGmOYaCtFpD6UtvYxBAIc+tjbqp4Ubt8Rw1GHz362JYYoRkaL3wyKAESWCA/1G+UOIkyEPFfbNTfplyBNgLFNIXsmEDYzATl0Q8bJiry7bWdQd/fVdwmeSALYNXSNi1/9ajzCZMORzRODZL+IkYRJhyw57bTTyre//e1NVpFmGmY73/uSIffUjgfi1q1xfOvmkmPoGoS/5ItB3tINkS/DHMxh4bDBIPuBM+66bhX93TfP1YitiIOuo+viyFFkDkfXfOxabeAEx305WAgW12qPCMhwru585/VNxMsDH7iyXHTRysaBdB0nj56hm+mUiMJVpvdxOonr2Aic7FFbLV0XJ7pI5IlYryMUuzDfO3VG24IAV2f3VYZ+oqODbAnbgd2h3D57QWSsbcZ///cb5WjhILZf0Btdsh/p9clPtjnTkCaPeETbFuWoD5nSg7e5zbpy9NEryzOfuXJyEUIbyV+ZjoC1mEQHu69yjanYWjQK5E5HIugi74lyyEdbfaYt6qh+xoV22Rryhje048l4/N//beXp+WJ3Ra4VRIFxzsaJ04z8j9Chf9WbnaTNxgbnnqwPOaSVZzjrxiWyJrZPuU+MYQQOYqNOpNr3bK9YsbKcfvrKhqAAfaws/WtMIkrYDxaz3IcdiSxC6rDvfKceg0gobbU9CaGCBIWaeCMnbdUO/YfkQEqSIXvE+OsSuV3EGFE3fSEamdzI3NYkzxp512NfG2Ms+I7dqgz9w+Z0rTIGPWs+d616Xn11Oz8upX3JXRx88MFNFM24kLekC9EoeXpeItGz1ziy2d/xjmVtZC5P9KOP9BgHFINj7bD9tXwjqStQbnyZOCbQdRQRYy6OS6ew48i+UQu8DMKvf72Ul7xkU+ODAmWwDYv66O5zpTQZKMoNYiSOXKToKOo6uW1N1kRExCCn3d5gbQ9jPLbxWAnqrhxQfGGUqgejJcgkdWQcM5QY5xTlMCNc/d0TYaNtXtpd70efDmLVsnuPSBNBj4XR6tqugSHRHyMkjJo+wiv6b82YOyIi0meOk6IvBCw8a2Uew2yF1XrVYbZOwUGWPPGJT2xWlqwMSeImL4nXdRs82DrM9uijjy4/+MEPMsx2ESHmlTjKdb5geHVPmzDfc+oiZ0bcPyItzc+RfJMT1I2GGyfxqnLHOfYzjiXuQ2wF0QbkCFsmSI1YcQ/4Tps4kBw18zBd4lqfKSeOao3tRvQ+R1RkCSeYbtR28grimnMO5u9RR8bWpIfoAPKMvBnDIivihKGAeoWzTbcoC+gH7US+IHjiFJUa7kfHxpHC8TvjzT3o9T7igjyf+tSNJ/eIqmAbiVwV/RB6zfYbCVrriE3vtbHW6+RmyzC9T0+NQ5aoL7JHP8SYjASoyCFEwhe/2LZPXhFEjb5SZ/3r9+FIkxE7xu9Ex4j6IBM2GztMud6ru77mY4roMYbIyP/GURyzLCICCaCs2PKsbxAtSKZaF5OVsRLyH9RWhJoxbjEHqaF/RFyJKtI2/UaGbD5j9hOfaGUcx/q6/6BxpXyRxve730YCop4HyAvpxJZAqiCdwmYy9sZ5dpVHVp4hC2PkGJFY2qLP9X99YqA+qSOoY0HJPKJOiB3lRgQYQldUVBC3AeW77vjjc40lkUjMAJRprXhNWKNCIJc7rNjMhDBhJB56aJttv8qh2CjoIEwYOow2SheLHsnHKL9YMJY0TR0iqmMQrDIhMBgyFAiF+sEPtgoX9DOlwlAZRrwwEPw2jGFtr4+MZDhRgK5RXhDblJN6h2FAace9+6DMrqFNeUf0Rw1KM+qMSGIIagcjFulEVr634jJOzg7X1iGgkQ0/oE3jHqut3V0ShAwYB8aA70NGYVwFGACMlfpefaRKN4/JKJDXEtyOs6wIE2TIfvvt17wizNb7173udeW8884rX/ziF8uvf/3rcve7373c7GY3m3z90NLlBiBT9t133ybM1nHCBx10UHnf+963BVuVmG5k41wTJuYijpJ5KZKMc0I5RewD7zmVEWLPEbSNoiaUzS1BFPjdTPIkBfE+DLF9se8oVo4XfenFaQePCn3VPe1Pm4NENodyahEskaSbUycHAx0Q9lE4akEk0GfaTMf4PT0YJEsgEmP2IbbJBJHgXvqW8zmbI++1V//QiUj60D3uE/onQGd/7nNtss04NSaS1I+TG4scONaRxsH92BvGQOh6+sx9ySrsCKCnEVuhy2dy5KutN+wYOSwtNNS2j3uxSxAV7C73EFVCl7KhRKSIUlB/dUWYkJn36qKvESL6xfsvf7ktQ/+84x3te6SKthtb5I4wMv5iMQmxgaxxDdLEWFFmXzvZU7XN0cWRR27dEHm2HXneyNXzqt5xbDL7TD8jNsnFWBz3dEZ1R6rFMx3H8UJsMTZGLGK5LrYWxWlXw3Kfei6Mq7BryS0IRc9m3Ie9p1z3Yfd6pkWxdBft1BFBQ57+973fsZ+ROrFlvIZ+Ny/I1ZJIJBLTwoYw/YH5HRL9oPgGbckZBUrIaTL/938blQQFwECi5BkpFLjPGDbuRQlSApEBnPKlWOwrHrTSBvY5i2ahtBkw7snAsVroXvrdqojEr8Miiihyv3EvSo5RsSE3VAN1d49Y+QhjlgETe6KBgTnMIEa2dA1FRsDee5dV7un+ZAGMrwiNjTBQfp/vGUPkPOrIYAZChLZ2oQ8YtGHgUcrCUMeJ6BgUsRNHY8bKjedPm2vDVL8zvOsVljopbRc3vvHwMRBQ7yVKhC4bwiTCbLsve5Jvectb9n7n5XfdMFuJ6iQR/MAHPlC2H3Umd2JBESaj5tHpwlxqvrFSzbGx8ms7ASKWA8e5qXdsxfGcfhckLKecE+iIUM7MIIc/joHvwzjtolPUqetYmt/kN+YgcrQ47l6D5vcgSyCOJOVkkS8Hjt6RvJLeja2qVu2DWKHn4ghbhL7Te7Q/cpAE6KVBiwTqFtGW5nDXqgfyYjbbodUDQSDaQV4Nco1Fi3Dq4/4cbjYGe4ITjGjxuXEwalFIXREOsWBCd/ktPXPQQa2suvYIOwIi74XxY/urttdyG4R6lwG56xufsVHCNvroRzdu+9KeiJJ1Go/707dkIz8Ku0i9Oej6H7ds25n+93lEsJIjub7pTW2/i1YxfkSQICv83gvRZoyHvBEJZMMukfcEedJnO4Ydg0Tqg2dNO+oFJeNKxIg2sCcQEfqC/aM/jQG2Zve430FgY9Vbl2vCJI4lfu97W1l6BsjdGInojnphrQsyQDjF8cnhc2h3nMQIYTeJNHZv84nxazzWNlGAvD37npdYaNKP6sO2it94vkQaSTUgYXMikUhMC5SKSXEJhunPGyiEmSYDDVBsjBSn3pjIyf+//7tVdGGYUuqUCIXC+KQYKCxkRER2RF6MPlAUyqCElc8IUG+rP7H6RDkyhhksgxJ0AYOAEcrYUA8hpd3ktepoJYNypvQpcYqsLnfYCuKwvDD771+2tqrBYCUjiFWfULQSn0nCxmhhzDL+RwFRxGC0gtoHxkckOaO8I6SZYWdVpc/AY3yPOvIyHIO+PASR/4QhGOUP28u9666tkTBqu+qoZLuLGEuzVYnEgDkytkDMFcylovSQJBwtMN9wFDmE3aSlETFgS0IdtRbbH4bBvNeXe2WcCMRYZY7jX83xXsrkfNM1dCtShbNEZ5lju6H57sEB5rjR59oRK9X0aRAFIkzqCE7lfeELLXEe+UXoOtseyIoe0S/13D2MBHIvOhKRwIH3G/XgmM+2f5XBqaWz6V1tRDDU0UmcWJFAnHqgO4MIU+dh+TRC14lcNVaUwa7wO21iV9RpEbSHLaM+cpOxD/QLcoiOZaO4vkuy1IhtUKDfyF55ogbUXR045fQnp9kCimtiO3Mcw+zebN+I+Iw8MmSG2KD3LSzpD/3vGUAyaZMylKX/fa4sNpk2K8P/tsrIr4Z8QTrGOLHNFgHX3V5MZuSoTrGVqgv2xj3useF83w1wrT5i1yFi1Mk4ZNOQBTlYUJHbRH6WQGzr6T5b9VHTwHaMaCTX6292a+SVYwNGdJBxXhMsXZAxedkuow/juYxTBLt58oI08azpa8+eXKU14RrPSXva0Ka2EnvUvYwrzyY7Fmnm9KdEIpGYFkxug4yXRD8o93FPJRkGxANFgEFn7DEcGKyhTBkADARKy6pCGB/IjVgxGEaYUMD1CQGUPbIE6aJMBmeEXyovSDPOd3frCaXGCGDoWEmjGAeF61JicrVQvt2kqRT7oD263dWNGttvX64TxirRHcXuRWaMg1C06sTQpfC1hREllHOQ4ckYIgtHNnePVAwwgKJ8Ro3yKWQGOcPH/0gchpn7+ZusRq3MkXmEp3ZJogg35aQwUMhrGNGxcmU7HgetpKrvXK5GL0AkYZJYFqjJBs89Z80K/2xRRzqMC8QEZ4ZTFqu43pvD/T9oPhpGmAxboa6jQsx3nCHODyeILguCXm4I8y9njs6kZ9WFHkDmRJQifWiepc85hbENtpaFleiY/yO3CN2CpOGgmZ+15fnPb8kJBDybSjs4s+7le/Wm30IXISr8lh5WPseQ/vebIC/iFJmZIn5r+xTdhFhAEpF/JMr0v7pwumPLiP/dmw2AvJAbYxjRRl/Rx/Q+O8XvyQoxoQ5BciFhyJXDq53vf3+78BMnAUWUUzdyyO/DZgiZgrrStxLNRlJb5bB5yJP+1Be2/LgvYkgfGzPu671y1TlOSXKt3yN+XKNN5OQ+CAkRvXVyYnKiv9XJuDGe3NNn7ul/ZUYi2RhX3QUV7ULCsCmU27W/9J2yd9hhozFjLOo749BvyUk7jClRxRGRym7SZoRLPFvuV29fGjQH1PnrPF+2uFiUcq3+ZaOyn+L57yMHEUVsRs8W29bzGKdBfvjDrYzZYZHHxOdRT+PVQtjHPtbaaMaaRcbIX0KOyjXnGA/duYXMlKU/jXHt0+4DD+wwqIlEIjEKw3IjJIafFjAbRJ6Khz2sZdkpv+6ebwqfgmD8UeqMPP1FIUfURjjeQHFELgvKh1KMSJQuKNj6JBf7f8MQoQzdpxsayjh47nNb4gTxMgzaVh+ZNw4YlIPqq0kMdIqVsczIVUflW01gYFDm+sbfVj9e8Yp2pSW28HTBGIxtRYMMdfejxBkNsXJB2SOCrIowkClhbWU0MHZHHYsJYWyFoVmDIYD0UX6cOjTqGb3phiMlu21QZyuXVhbH2Y++SJGESWJJw3Ntlbw+BYJzxUkwTw/LHTBO2dB3LP0wcFLMv+a9iOhQ1tOf3oa9dx2y7iLNIGKEbjOv9m1NqJOjx0lBHDcOsnnOHMdRpAfNnxwoOtI8SL+IBOBkxrHDPpfTi+7zHcfMdTFXijAJZ9A8jFhBtNjhZnsr5+4Zz2gXHOKUGPpGucgkutRcr3z6io5G6qgfkoezSx7md/oLyVPn+5oN0R12Cjlwmjn76h0nz7kfuwLZwJE1lmJLUOT44Ghry6CoATKJJKBAtvJrcE5FMWg3R10ZcR96z+8sfiC7QBn6m1wiD05ARIIcK7bZuE+MG/JzH200BsjK/bTPfbTD58ZjHSnDyTd22TGxtRgZQO+yCSIXims46WwIsvI7ERIBtkAkjPW/NrJLjDcyj7qyH5AmsV2klqU6ancskhi7nqkgtjxT5Kgexl0NJABC0G+015HegXrbjudJe9TR/Y1Z/d/NATRowSpsI+PaOFc/v9fXUT6yL0iresyKxtKfxrU2eX78z8574hPb5yySEGuHa/UreXleyNSYsAXqb/+2tZE9655f9zEXaBf5HHVU/7Hk5IpUjhONzHM3vvEchuclEonlgXGPbUtMNURmejQrhWByR2YgQhgKHGZ7xrugQChjyikSXIlGEb3RB2G9mHxgNHS3zNRAPsRqSR0KTXFz1ikmSrIOR47tW4yp2WxJGkRO9CVK7QOlHsfyMZIZRQwL8mTwWMFgdGoHY5YRTEl3IVKH/AftMw/DjUGgz6LNcYpOGyK7ca/3OHlEajA8GGHDts4w5oyVUSchrVjRGkndcGZGAuMi+nWJIgmTxJKG0H7zRU1UI705nPTDuMmozXHduZdT33fMrDlWKP8gsBs4Pcrk0JhPvTenmR/NN5yaODY9YK7m2AiRF53XTViNfJb/wvwbiUQDCAdluk8dxh+n4MTxvrFqHffVPrqC3vb7IEQ4q0go86x6IwjM9dpiS8X3vrf1pEOHdFaO+iHNyV/kQC07OjdI7tjCyV6g28zPyiZvDq66ifww33vvPsoFpArdP4ow6W41CsRpKeSgre5NR0QUBjnS8WSkH/2vjogF8jPekF70WpBRfffgtNNPnG869rDD2nEa23KUYWyedtrqhgTTTosNT3hCSz5EJGb8pnsiX/S5caa+ZBnRCCJo2U1xwiNi4bOfbXW5ctxLe0Qc3f/+G8sjB78nB/V2jT6UiN/zpC4RbaHO+pSNwa6oERGnxqHx437GMnuBLI1vnz/+8e11xop7d09/4czXEaT0tfFnDCEpyEP9PA9swFjAIZc6AmnQgoh+MrYQLvpLf2g7wjEiayMha18qK7aHuiCV4vkhJ/WOiKkgnbQ9xqx7eb48V8a7usv7IqcKWbCnRKcY88pXH9tn1FN/Iuwiitc16kaOytTH0Q4n9SjT2LZtpxv9rX/I0dHVEv6KBEskEolpYVSof6IfwxJwDoPVB5O/yduKRWy9YQyE414jnP5wqoUmWkXoOtmuiaOBKZRPfrLt22GKoZs8LBL2UayhcOrkcMAIGJWbYxz05TGhbMeJ2qGgtV94rHYzZBj26h5HXdZKXxse/vB2xcJKUYBxoM1hZFDAtXFOfuT4kY+0hl+s5NSGKgPRyl2c2qD+g8LQ+8C46CbajUz0AUYFUmZYfplA7CGOPotQ5kh8O+y4wkWOnMUSSxocxThSvgt6pJ6nYVBEACcnyGPzQZxS0o3s850V2y5h0YU5Jo5vNxfHca3h+NFziHwnmdhWwKHkoNOBoisRCn1EMyfPSnHkqzD/cu6CAHHPOKIeOE/0mblSnc3tdJV6mavjhBafxZyvPNEL5mAOIB3MKadn6RELCg984LWNjJRPdq6LCEdyp3fqLQB0gHvTSZxL33MUYyuKemiv9+6L0BaJInoISeS3vrPlJ/KIeHE+u6Ar2BN9uR/i1D1t7NoLCBD3FS3AKdVPZKSuZIosQZRZbADtNZ66x0zbGkHfIMsk2/23f2v7lm51fzrVmNAeYwLhhAggW+MinG3Xx5HG6lATRXWOL052HM2LpIlIiUiWG1t0jSnPg77QBu+Nwdgq5D7a4n9l+q3tXU9+8kbCSruQJWSo7z173W226hinsXh+IimrMSe5K4JFO/0t2hW5o311BA1ZhHwC7mO86wvtVD+/c5+f/GTrZizoV/Iblqg/gEQgF8SQsRxbyvV7RIEpc9CpVmSBjDI2kVXGArlpn/4E/a7f9GUcR+078vSs+tuzSZ4hY9C3nilzA6IKiRb5Z9hW5gtlBlll7LL7XF9vIfJbc5EIqlgAjhOZ2IPKcQ2ZTndhK5FIJBqlkYcjTA8m5ZkkyDVhm+Ql1KMUGIujIntipSWU6aCQacw8IwfLb4WMIhRWOl1EiHMYKMYGAzUc7a4zP1N0wzatblhpq1eBBsHvkDoMJ4qTcUSelCfjuo9YYEhb6TLe46hJhnIkNwyjoHYOKFVyZDQz7smgJkwYQsqM1R5yCQPEtcP24Q9DbMepYZyEIT0KN7/5xoR+2ht1ZriOc7rPIkUSJokFDfMBA77rdI4Dz/Mwx4jTWBMm55+/slkt7wNnJ3JhcWDVKU74qIEcsNLLeYkIENGLtXOuLPOo+ZsDHsftBszF5h/zM31kjrTq3obEb/y/z+HnpHIK/d7cTi8hITh25jj1Ul4QJq5xbRwL6z39FeS6e4iqVG7oMPmtfFbryvYo4VaPcqjNmxYpRJuI3kNqxAl2/u7q8DgiOHQD+dI/nMSIutAGkQ3kylGnP9yLM2mc0C3KR6TEEbXdKJ3QUeHQ16B/6Art6DvNT/3oKttcfE+3xHV+x9HlsNZEkBV8TnPUIba5kocIDP3xlreU8oIXtN/p+xg7ZPTjH6+ejALRN+QeydSRRdrBGSbbOv+NsUofGldkaRGI3JWjDLJT39CZ+k/5SIJIhqoMY5Du97n+iDw2vtPmqAvENhqkkX7h8LtGWZFw3n1FRwWRRYacd3VUlt+Qp2cstu34HjFVPyPkTta1bkaOIHuUrS5kGFurrrpqxeR26bBRRp0spBykFvmrW5xspcw4HWpY/jh9497GsPp45sjYGGdzhZ2qLsaseolI0i6EkjnP2Nd+de0ujJEr+ZBNbWN59hBGcQIS6GfX6xe2VhAm5O9Vly2aBTmsPsaVesf4SSQSiWkh85dMHybfmRzBTDFFDg4YZ3tEvV97GNSHwRr5OOp90NOBcrrHz1FAlBaFHkcrzhbdkxCs5CAvurk8+hCrOhQoJcgwYwBT3hQ0BdqNpGA06zf7bMmUgdZNzNrdksNYj0RtHJYICa1X9nxGITPMIjxXpIxs9PbuzgSxl7kLzsIgJ6iGfo+VO8ZYEEix8rdEkYRJYsGCQ2FOQJgjGKYLc8ywY0E5D/W2lp//fKtJp69GnLYWhC6HMSImuuBAcbJ8FyvEdAAn0TzJuUFE2F4Rp6+ZJ9Wlnn+9Rw5wmjhU/ufghq4aRJhw6pRlbuXk0hmcVs5uOJn1lgR1MT+bJ0XGyGEVJ5xI9GqLqrI4ZJHYNQiRUav0dGC0ObaM2hZLht1tGhDbdLSB7iTz0HnqjgSh6/xNX5FfnPpNVpKsuicHz/uIlqlPT9G3cbqe8uvTaGq7gcy6UaE+07fGlLr6rXqRjeTlImy6p+OQkToizcjYdpjInaF8siAbUQqccvINwoXNc/LJWzX613jR/5GTzfjQBrqTTJRBzkGYcMD1K4KAPJSh7vqNjGxRFr1kq1pEjNJ55KhtHHe2hXLJWrmxFcW4EDnCHhBNGiBzYx6R5r3nV5uN3eiDOJGJHSCXDWg72aqLpKvk5TkKMkZ9jEljNkgOdgP7hCzcE4xPz6V7kRVSTbuM5ZvdbF1Tf/YjO0Gb+o7arUGexojfqZ+/Y3uxOttarG6xHaprJ6gveaqHfjJWlKcMtlgQEMak+U0/yDeD+CMjdScD76MuXQwjTv2mtoONp9h2Vy+Q1ac/kat6IItiK5E6GNdkP9MFrUQisUyRhMnmy18yk0SxcV79KFC4yJjZEhoUUZcMokiNEwbDXCUHjlMDgILWzjpMcxgYmZTgoYe2v6mJISskFGg3EiNCSRlnTiGihCV8q9GNMIlVmCAgyDhWJilgipcxxGB0X/Vy7QtfWMrTntZey9jrhrQzIrp79rvt60Z9KYOzpW3jJnecmNh4osQ4p08sciRhkliw4PQgC8LJrp9hTlifozCNZNgNIskkUoODYU4K5yHmA3O4eUxZtieGkxTfm5vCQQryOraf+C3nUsQd0gRBYbXWXGY+NxdHEtHYchDJyTll5kzl0mccyZjjumQPcNjC8dUWv9MuBAHnN05xi+0e9Ae5kqUIAFsfYu5GpNONIkb8LSEpXSyCxnecJ46nObYvX4hyP/OZth41aaUs8ujrF+3lAHMw6YDY+syhQ+ZwMo2JOOnD5+GkIsfoKqRKnGKD7OHU+9x15BxkuLaL2pG7gyyMrUgi6xr9WutI9+PMStApgghx4MXxtw1I+baP9Nk4cSKK8UgW+sR9lBURAsC5RkAYF/rZWNtpp/VNf9mWYXxw+NXT+4huImv9ZtzqX3KL3Buxvchn7q1t2u5abY6ty3Eqke9DtsZS5IlRB+WEjeA5oVsjn4nP1ct7Y9k2HXXQPvIPfU5enmnPiSiLOMEFIcQmUEdjw9g13mxfUify0CexOBNzgboZf5HANI5A9lxHUmff3/zm65v7kJvxNSoxsPrG4pxrtaEm0JBPopNje3ZsG6+hf9VXnbStJtO0VxSNdhqH5OV58pwaD8pWd8+//weRk32EieuNCTKux7B2uJf6eOajL2NLNBmaB9QhItMQPfrBODIfnHtuHiucSCSmgUz4On2YkGdyQk7fVotx7jUOOUMJSKI2H6CoGAaMo7k6frpW8hTpuGSJ3zAAKFIGb18/MEj6tq5QyIwrypesun3RzWFSG3L1ygXUpxlEHpUIqQ3FbgWVscDYYYCEYcT4rUNCGU+uiVXZMHYDDAKGrNBnBvKonALAQGSsdKOCGGDjbOtZhEjCJLFgIfov8kkhDGKVmlNoW0RfQs1AOJejTrAR6RCO9b77rp0Mtw+4pxB1uoLDg/Coc6JEmL95yj1jRTcIkzie19ztO4595DmJU0Fcx0mkt+LYd/rLHGSO51iag7qLAN1En7G4EHoiIig5a+5FluZZ9eTYinrgiHOuEMPKjwSW7k9+5m/OE8cpnGJ1jSgc5XRPDYGzzlrVlI1E+NM/LWOBs4zU12bzsCgF5AdHTRtsx0US6Qf15KxGRIXVftEJ+sdvgxCK3BiIGDJ3PccX8aI8JIxtQ0H0+x5R0V1EURfbayKPTRBRnGKfIbOGRXrSLbbO6hNyFmkif4l+URd2jrFC57mW80+f/f73K5sxZuwYR/rT2OJshx4PEoiM6M6/+qv2c/UhLzpVBAPCR59G4ldlGjPKdT/9rl0cZe/JkdwQWeQtv4gTesjWPcnRgskHPtBGcfrb2DD29MVLX9rKXD3YK0BWrlNfpIEoE2OMXOrFFnaCZ9zz6zcICuV6VtQxok0QN/pK+eSlbeqqzu4RRy7vsMP6xh4xntgnkTfE2CfL+jlyjWe+3rbit/XWG/eM39qiJpqrPp3Ke2WQh/GnHbW95jPliaCLPEBkYEEK0SUha2w/U3Ycmd2FNnYJE+OSHLrzhTogn9lE7MA46CAiiCJKy3NlXMZxxuqgvp7PCy5IkyGRSPTApEOB1yG6mfB1ZgilOB10neBxYYKvM5+796AogXG2s8wUjDWKv2+ryEwQJ/4AI3qcrOXXX19uwChhZDCcKMu+UHJl9+UJiK01g9CNwKjJRIo4nA9GC1kzTOpIEEo8fs9AiyR6jAmEh/BfRAsDJRIZugZ5ok1xkkJdps85QQxc44dRV28b8jzbzrSmk5skVl7DyYoVY4bOqaeW1VbUlhjS+kksSDDeI/kncJo5b55PDoqE33VIfT13cTA5iLYhjAInwJzYrqCum9xKE/CeU8yRM8fYNlAT4OrA+eKk1NGQ9I/5JSIxIo+VucV2iDg2F/wmou44Wn4XOsP8Fae2dNFdJdduDlRskzSfITo4puD+ZCrnhXbHMb5Im4hMieg6TpO6c1DNnxx17zlzUT/zdszd3WiXU05ZPdn2btLPQeC4R24IskEeRNJaDp6TOkRq6KM4pYZcOJTuJUGnz+PkD2XoN9EqdAe5K8s87jpjSmJznyEQyIGzTI61PlEP9+S017rQ5xxQOjJO4OvqGvC3uhuTiAVEn9+quz7y3veIOPYlokd7EU7bbjvRXO9vRKGoHbrRb1wX0RWcY2RIHLWrP4J80//qJacMvRfJfY15/Urmnikv9fEbZZCZe0aSXdfHYsg//3Mrb2PK78kvTlHy+yB8vJ75zLZuseXIsypiSfvVG+mgv9Q5iCrPGXl4boxThEVsMVJ2bC+LXB/GArsA2WUcISqQNQi0WHRTP+XEIou6y8+CICL/IN/87z71wpJ61oSHunqO4l6S45oHtNF84d5IG+NrENiGorW0hwzMQxHVRY6eNX1M/oMWAPkn3Vws+sNn9eEEETEVzwhoN5kZv34jAi6II/c312pf2Iv65n73q44XSiQSiZgQKYw6dG06R7gmpqIb4jpf23EYJ7VB674MJIq0zrK+WMFY+tSn2vfjEDFWZxgGxjMDJRKhdhErcV0SYVTo6qBjfYGSj1VhBhUDo7udTf/qH6SIVSJGhpBZK2WMJqQQQ1e5rkGEIFFi1UWfMurUO5L4MXo5BHGfrhHLGGJIHX/8VOcojLrYjhN5UTacBrCWwbzEsGgIkzVLOPNuYiM48FaWrYbX++wj8sNcYDXfsxoRFuaUD31oY14OiS0f8YjxiWoOA+dFed0Qd/c0d0Y4fjeqL3JDmXtcy7lwvRN0OCTKMnQ5Zpw1offmptiaYY7xm1iU4ax1o/i0K77n7AU5VNe1XsjhEPlNJHPsO6HN9pvnPKfNWUKGVrmjPUG6xBaOcGSVhRiKE1eQGUL4/V3Po663Eh1JXscF/aOdIi446MgY83xsdTCHkzMChMzN43SHXBxIAb+PtiDL3NtnSCAEXGyD0BexJYhO5Khqg9+Sm3qHzJWtLzmfdCkCxu8joarf13kijKX6NBF9LC+X8ej+QcjHNovYPqGdTqZRr/e8p+0z301MTDTON4LQllXEieujH0RG6XuOtveiQI1l96B7g0wwNvTXs5/dRn/Qze4fSUuNa3UlW4sRPtPfyv7yl1vCQDvZUeqCeKFD9Qk56wcyUS9ycS99xfEO598CiPsZc/oltn5FVBDZBoy/pz61JU3YDvrD79QPOaFuiDgv7RR1FFuDnBLj99rkfvG8IBfYIJEbxTjXt7bLaRPCyDiOsVCTZt1oWWWQUUReIUYiR43+Uh/k0rBIZ3LRPoSQenQXrPQjIi6ezS7YSMaN39aLumwifVJHmHgG6m096szW0k8RDa0+xk+QlsaUdiBZFhPSVkgk5gEmmfo403rSMQlTklZ9agMq85dMH4ywmRwnPG7y1hqc5VpRUHLKkO0dk0/hM8YYeoyBxXZkLOOOMRjJ7oaBkXHxxWXduDLshqPXWdRH5QDx7JB1fbJA7I32zOgXxmAcEVkbmIwpxgHjgaFDQTOifEepMzqe9azWeGD02GNrFYax4H7GCQOGcasesYc9UBMmcToAY+eWt9x4SgZjkeHBOA95dY+DnklC4AWOBU2YrF+/vvzjP/5j2XPPPcv2229fztxwtMJrX/vacthhh23p6iXmAfQuneu593wHIjElpyxWPMM5ZfRzXCxwcPasio5znHgf4lStIInjGNtBp/SYV8wlbAROSpxUoj7qyulCcAdhLVrAPBvJV2NRADFseJvr6Cnh/HH0sHZqu/lctOAHP9jOc+a+sE3MsbWOVQ9z2qAFBw505JeoTxPShiBsbCFBEmgPp9l2Af2jfuZwRIA5Wb0i7wdwGG9723WNDAYd0zwIHLa3vnXjCSQcuTgeFdkkxwdZ6t9PfKLtc9fE8bRkQIaIfjJTBn1Cvs99bnu9Ntdbbnzfkjxtf2mzFXq6gQMMnHRjS3s4/sh2xD49VZNodB750EkSwdruIwmqvkJc0G/IKuSHaBl18RkCAUnofwsHiARO7m1us27ypCRkj7a6zt8RDaWdEUmBVIioC5/pJ+1wb21xrbHtbzII4obsvNQFIeMaixN0IpnJfSZCBrngPk71YUvRl9qDMHj/+9s2qbu6IjfpaUC+RZRKkAiRWywiufvGqr4xjuSaUbfIm6Mcfa0ukdskiD3lRUQzHY9kilwsyoox7Z6eXc+8MWaBRpRFLIrWxJd+ja1n5CkiJeqLuGOXSfpr7Bur6qQukSR2GJBFtodZCHJ/sgNjA/nTZ3e4pzZ7JjyvxqfnXdvJwWf17+rFx9jCxe7SJ8A+Jq/IMWcM6GNljNOGLY20FRLLHiYsRpMJpJu5fi5g0mRsmSyVz5iJhcwwQPrCXjPCZPpynm7CV/1h8p/ulplIVBWg3Pxt0hchQElQ3pQHZc8gWGygvLvHWfaBgqcEY4VpFGJ/cyShG7ZPtgbDm2PBSKxXiShb5TFsGSaeM/UYRTz43vVWk+LUCm1gVDB8GJ+cKp8xbmJPu35lHDEerHhZaVYvRnDkMGEMeKb95rLL2vop0zixAmiMhOMRv13CWNCEyRvf+MbyoQ99qLzlLW8pW1dHBNz5zncu72edJ5YchLN7ts0TntE6b5GtFvUR6kHw0uEcNo6m+dxWhtmAw8vRNbdwTDht4Tx1iWNzE8eGcxtbhMwr5mck8NOf3q5eI7k5srYiqHeQPeHIcGQ5u+Yw/7NFbL+IJJmuQfRGfgk2UU0Es1HqyEqfk4frw3byd2ydQTBHRJ45kH70f53zxXvRCL4Lctk9Oc6iGfQHssDcWttJ6n6f+1zXXBufhYMH2mwe7gOZkQUby//aauU/5Bb5Y2xtMefHkarkaazENgSRBPSWa8hZPfxem+mPOqeV+xhvCHc6k9Prf7LnoBsPSAtRIpzsIIeQRWRaL9DEIoG+i2SlEVGCeCD/iADxXt9y4NWN0/r617d10RdsJu9tpTWu/c7YoNu0FamGxHrSk1rdFclwkUfkpT3kiOyS7FP5yA11iRNUkCX6RR/7jLOPXHrHO9p20OdkhxxBhMTiB0JTnysLMSDnBrLEeCAbMjMOkEohF1N4/WzGFih1Fy1Rb6OugaxRF2OWfqbfzRP6h0x9h0jTD7GtzGe+N4fogx/8YKvJk2qQKaKEjEOy1SbkDkKJfDxnkQjV+HE/Y4YckFWIQs8fO0VZfAb95DfkoG/NHeMcPBAkK/LLGBNNoq8jWm4Q9L+6grlP35mzPJfe19txor+DJIy8NF7k6Hv/s/+MCc+qsTRXW8k3B9JWSCwrmLRMVJRHKHgPcTgwc72dgkKiPCkH91E+pWGijz20cUpIGxq5aSb8RD+6RuU4W2s6v1nR3VozDvShPguHN456q6MEYpWSUc7Yme4K2GKAdjPsKPOIoomEaKMQhkKAURcJDAchEr9G0rYaHAXGm/owYMYhIPQZJ8W4QbbEUZoMLitcjFH1Mjd4Ht2bwcKY9vwyypArjA/Gff38euaNB4bhpZduXBFUdwZVTRZF8lffdUmkJYIFTZh8+MMfLu973/vKM57xjLKq8uTudre7lV90jyRILAmYZxjtnmdOb5xAA5yhWveal8xV5gLGPTLcvDGTFVHDyfxonqB3zGmSWXJ6OKqRSBEJy3FyXyvC5g4OtjkiTgkJRzJI6nqLTZDFHDBl9h2HLooDMaSt2qQ94Qxr80MestH5Dr0Z+b6Uh0wgRw4VxwrhwLayjYKDqo3qiWhCCkcOD45SNxKUM0tnWn2vF4q8N69HeyJxZOTHMMeaO9UxVvxje6a6Ddrm6VpOrjkfwSSygJw4dyAPBwcWCUCG7quNxgbbMa4DDqg2qZf5W/t9T57aWefAoVtcx4knX9EV5Ia4jyifOPHO/wgkbYgkpQF9rx50R7RTfd1bVKuxpF/1pc/oIVEYkdSV/nV//WFMqhe9pKwgb7x3f4QVx1gf6tf4X9voRv1DdqIIbL+iD41JhAuH3hgiYzrQc2OM6GftVQ6ZxjZV7fGdCCef+5sNpT6uMZ4QSHGkrzZa7IhoTb8JMjSg/yyKeCHQPvaxNgmq/yOaA8Ghre6HXPI8GFtkZzFVO0RZ6BOyiyT12qivETjadvrpq5oyJQdmQ2ijviRbiyxxkpBEqH/0RxuPNhbxwUdA6Ohn91IHshRphKAgK1Fk5K/dyjK26mhb6IvSrRcTg8BCTI1ayKsJUmPTbyXkRWyRc30iDxnVz7XvzWvGgt9qAxkYB9roszrB7WJA2gqJZQWTmYeYMgtDIrLcR4b8uYwyiSRrHDhK3aTH4TJBd6NIwiHsrsAk+vGRj0wNYa5PDxgE2bkrp3wlpTPd7ThWVGzXCMQKSR8oCy/3WWowVj0vnI1TTilrKeBRyVsDjBEkxIbtPI3xF8/HIFDG7ucZ7hJjEfbrGaaohyX+1V+MVAaUvrdixXhR/0A4MBGuz3hhMLsPZc/AjxBpfzN2GNeMRs+8Pje3eKZXrGiNhMiw3418Md+4DwOwzoC/hLCgCZPzzjuv3LbnKCjht9ePWoJLLDrUJ15xBtgCnMRBx4lzwjj9sUWHk1ifYDMuzG30wJVXrmgcmDjJi6PGcYq5k5OlPpwnZAmHkBPMeeF0+N8xqJy32B4yCBwjc2YfgWye0hZzWhBE6uM3ogfMVZwzTqP6cibNsZw0UQeiEBAO6h95WczjHEU6ln5Qd/f/yldax848qm3dhOARfUsvcOzJwzUiG2K+jLxYyqSD6/mavURuQUa7N/n0naxT24FW6tkQ6hQ5RWJ1nOOsP+J43diC6X19XDHdTy5kQqcgz0UrGFec6TjxBtwrcnogGowjpJW6qINx5vo6nx3Zd7d+kYPPjAXbSGP1PtpNHymHzopIG84pAiUWBvxPjxoDe+/dPhT6UTuRiNrue/2tTQgZstUu9YxtSeqt7Wyi6FfPmHqQr/a6B/lGHh39hGxAtqmn+qkzfcwe19exKGEsPPax7Tiju5Wl/7THQok+icDAOBmvjoxVT/pefxrrorFsyRKR5bliR4ocIWdjWhSI8SXSx9+uiUTKj39824fGcpwCFcmOW3JgRVNXv41osLADEFW2voQvoF7GDnmqP8IQMcUGIF/3cT1CC7ElqS0Ziz4JObs+no9YkP3whzcd757BiEQJkkS9jY9BC1xdktV4Myb0H3KIX9ONNou5qD0xaKMfY04wVv02ytSvo45jX2hIWyGxbOBhpWxNWB52k0gkUAMPd2RyngtQThRfTN4mePcN48TkU084scezmz09sSnieMX6RBHGzrBVP/0d2ew3YOUwsmNQGfqzJroo9mFlUCJxksFiB5kH+WOcMgK0fb/9ygRF6P0gI7ULzx0lHyHFDBbPZx3GbH804wHInOHDGKkzsEe4LDBAPWPD6uA3DDEGQN9JPgEGRrSVUcI41P7Y8+9vRkAYIFYa3Z/BxaCKBMS77NL2PWMzDASf+57hpIzYRxwrUEsMC5owueMd71i+xxPt4NOf/nTZL2K9E0sGnPlILBrEajeJZhf0dB1+Pl3ESVuclCuvXNlEwpmnOGSIUvNQbH0xJ7qXcPzI+4HPU78XvrCUV7+6dbaVJUJhWB6V2MbTtygQWxuRGLYOxMo0h42NYmUbeaEMc7R5mMNpfuMAmbvIkWNnPjO3HXJIW6Z5TN39by7kxNoGRD9rdzdBLDLZ9wFlIpTqCBHlIDLMp6JtOPUBsjOva6eXhKbqZG7u6l31Ilv3I3f1JldzdyymqA+dJAeI9riX1XRtJ486saXvYwFFGfpDREVEwEReCyCPOImJTEQQkAfCXLlW7vWzvvW5uiEVwimuowdEiBhX5GR80BsiEExZpjNyCAfX9+QTi4UgkoMj7vNb33ptM04iisN9ycbf2me8kbtrtIEclBs2q9/UU6X+QWzESUPqxvFXX3VASBg/kUuH3BEYYXt73mzTMu7IAnEWNoJFL3ZC9Be7oyZBjcmaMPEd+ekTbQ99G8lHEShIK/WInGUIHJ/ry8hzRJbtkbfteIu8MhHh1ZJLKyb7yjMefaqe5Ox6z522es6MM8SV8aMvtMmWJnatvkbykKH66YcgBsk9tgxHwme+RhCqXfI3/BzXIUBdE6fZRH6RLmIcBFzP3kNwmQeQgoOiUcxp5B3QH8aDcR/jLxafFhPSVkgsG9QPtIeWMuuSFphvDpvJbLaRJsqoQzfdJxzrOKu9Xh2K1S6T6HS3iWxJRNb3UUBUbMinOGtQbrGK0k0iNwgmcQrC5L0hkmEFxTudrU9+x+CZzrHEynfPcPyH5elYyPA8MOZie1FE9zBkItzTuDZ2I9ntMMT2HUo5ssN7HsJoYgAgGTgQYWhR0rUxxBAh16ib7zzDXefH+IzEb8aKOno2q5QVmyD2KdfzB+MtSB7jjWHD2FEP84m2MLYYNEHq7LVXO+4ZvvG8Rxg5GSor5om99iqrIqR8CWFBEyave93ryktf+tLy5je/uYkq+exnP1te+MIXln/6p39qvkssLUTIfp08uns6RRfI0HFyBfTB3ET3cX4887/85arJcHpzEucpnAfzUxw3GlsZODh0ndX6WNGP43jjeN5hiPmu+1kkbNQuizm22IgEoa/MS7Y+xJYCTrl6kJH51TXmZN+ZF30W5IY20KvKcA1nm7PIQZVvwufdrYd1pKfvzKdx2kuQBPpI/gTRAMqt9T0ZmHPZT2SpXuTtXjV5ru+DhIocZOZen3H4OfV0l7mbc0duylYnxADShNPYjQBmsz3veW3f6CPtVW9bM/yObDnKyouTl3weUQ+IDoQ5PcXx9pl+iTEXuWWUF0csIx04wfolIlas2ksMGgSce0oSapwgiYyjgHog7IylHXecaO5NbsZfkInK0A719hL1xOnXfmNaP5BTSwRuHO+IKmRQECp0NPnqV+SHPkHUqVfk8NMfxrTtaGE71OPbs4A4iC1LZKJcfRILG/pRhEe9TcU9yYRd757dXZbawm5QT+/VO+QUEVgiWRA1kaeMTMgoonWgJU42MgDqzlZ0b9E5fhPHgGsrm8B7Y5actM29yDK2IMWR2uxO0SCRtyjyLepnfazPjEtyFXllnNdQhvv4Xp3IELRTWX3beFyjzBqeFfOS8hA8tY8U9+hGtASQTU4kqqOnFhvSVkgsG9QrSuHIdCcEk14w0bPJZ0J5mPwGOfGR7KhWvMHgYphnmn1/c4NiY2QJyRwFzuVcJT9lyDF6Kc44bnBYwlcTeCQmpeQonxNPLOuHRfJQBl0iiPKtoxJiD/kgpjyUCMVklYLhZVWwL1cFY3ohR6GE8RIGG2M0to/VcqRUKfVxHH/GVxiQyorcJowSBkok0I3M+/UqJEQyNDKO7PXdIzvB7+2fnU5i4DhONKBO5gbGCIfBCpO6R9JAz7zx5X+vkMkNbjA1Iax2+j5OgmAwBnGz115lZSRJXEJY0ITJoYceWr70pS+Vb3zjG2W77bZrjKJTTjml+exhktQkFi08SzFfBWIOmE6Eie+HJbSOeYLz0T3pJpJiI1Q549ddt6KJWDDXmwdqAt58Zn7hgEfyWYQKor9e8EFwxBa+QUksgZ6J/GiuNVfSfebCOs8Dx51TiCTxv9+Z6zmj7CBOGMfcCjadW+cLoxfUJ0Lu5Z/gyGqfuTiiCMhGGbYMcLoCcZpG6FAy8JuIzgtn2Fyr/uTyp3/atj9gDtWG6F/tUB8kBGc1oKwgSIKgiXsog9z1kXvHliSr/uZqUYnu3yVL2D4IJYth+l65sYWLnBBd5n9JPNl2HGUOvXvRW0gQ9oHrLQCFPqD3tMUYcW9khXGk3eob9VQ/kRHkgowgh8iTE1vA6UbPQjdnBN2EyL/oopVNf2oDOSNg2KKxDYvuUhcy4QiTmX40jpA0IRuIZKKRMN19EQTGf0RD+FxbkAPscOWpM5l4Djnr7sdGDpuIzqV/2WCxtZU94NmIfGj6tRs1aty7Tt8Yx+7RRWyHM1cgOBCkQB627KobuYoWUSdjmR1ZRxq1W5jWNe1FSLofGcRWI+Uak7FtWDnkH3Izrow33xkHsb3KvIPE0WYklfLIOJIIxylAkZhemUGI6Ecyj4Uan1vgCULFPbVDufqsXuTq+ktxfWwvqrdfmy/Chon8UH02sbaPOglxISNthcSygQmlduw84IO2UsSWnZkimOBBMKlRsosdjCNKjwEQERR9YHRF0ihK3ERutWlcMBZqkoGCjGMS5Y5AQgxKIGWCtqrA+Q7FyyjcdtuybtgeSvVk4NUGcCTjpeQYJKNW+GJfp7ZTNoxVsqoTnoKyGECUubp2jfyFgNh6RFFHIkAKszZ2Awyk6WxtIyfPC2ONgYRcii1W5IdYMQbqiA9wDdn6fUQKea7rseJZ9JnxguSoHYVRUKayghjz3MZedvODcc3IMPY4AWHM6uc66mifDUYJA1O4su/CAYlxCatWletne/rGAsSCJkzg/ve/fzniiCPKRRddVK655pry/e9/v/yBmPXEoobkiqGXzB0cjZgr6kTdfSTrKCBhY24wb5sPvDzjcTqLeZ0DQc+E/bHPPmub33EeakI+jkzn0HOscXXmEvODebHOEUCXcKh8r97+52RxhCIc3+ciGyL5qv/lm1KORY44yjagbPIgJ3MaWZkrXR+RHhxWjpTcKpJicyB9Ty/QiZxTuoAzaA7kqCqTrIX+0wsctlr/dVeya2LInB155bSXDNkb5luyvOSSjYondJD5Wb3jGNXIQ1VHgvou9EWcOOOeZGdhx7043uZ8xIXIRr/Rr/XpeLYtucbvlO99kAxsnSDhyEM0hygQ9VNXfS9aRvuVrwzkmfv4PggH8tA3kf8kThBS/9hCTk7+JpfYeq4vIrFxkPZdPR1RlL/5zcqmXcYPmbFNjU8OuHGF1DGukRPKs13FPRBSCBPlqItrEUOibUK++j5spMhNor/9Po7g1XZJWMlIP6gv2ZKR5zdOsfK5ewZ5iRjzfMTiZl8Sf2Mt7Dz/9y1IsDM8p5LB1mMJyFwbyET7jAt63qkxdRRFexjARPNMuCe5BiGkTyPJLVtGVI6+dk/jz3hzjfkqItPJxHvkqjoYD8aT966N47/97fl0QhHbwbPo+f70p9s6sEtikch17M9I0g9IJNd4puVGIh+26CC7Vvs918oMG69+Zj0jw7Yvho23WJG2QmJJwoTi4fcyIYxzRGog9qkOW3Uahtq4GXaPxYwwDChVDHicQ98HRgtla3JGbnBcBx351wUDxitYc4hwakqHX/PsZw8OmaZ0XFfnN6EQb3vbMlGvENQII5MCj5MC6twy6k/pGR/dLOV94yAiERjWlFoYjIygyLZOscYedgp6IUF91D9WGBjjjBbPVp/cXRvOxDjQ7iAy/I7sGdaRBJbhZxWtzlkTx1RS1LGNzd5qhEQkEQTGltWhSBI3bEW2i1h9rPvZWGDouB/jRx3JhWHHiPAsxFGLga23bsk9q30MPo6H/fF+30lgu7JLpi0BLGjC5Jhjjik/5hF04LOfmNQSixLmUca9eRqQBRwIf3NM6nDyyLMwLiI5u3mH86pceoYjyInjUIWTH4RyJN60/UEdODY1uet784P8IMqjD2J7SzjBtc3gd+ZMCw/mYw6raxDLgPCwqs0O8pm6IR/MUe3WoP42x2klHgn1Q3g4yUf5ESFJl9O55lkRE9pHl8kxRV9yHslDG9yTnjWX6g9tC71HPuZWejXq4t4xR5vfzf2xwEJ+cWwpR/viizc1opTn1BtQf+1F1kRkUTdKNBy4iArxt/aFcxm57dTbmOLM6o/YPqVd2klGsY2CzjDe4kh57YlcGr5TprZZHNFHHFBjQh8hGmKrCjKA/MhZHd773vYo3s99bqNstaeOfortXO9+98atnrGtqgvta6OwVjRjIpKPur+6+J16BnkWUZf0l+vUOX7HxuJ011tPa/lGPZBHIUO5c8g5TgFyD7Lxe7pePwRhGLYAgsa1YVt4H9tz6lOjQN1ikUt93dv1XfvK337v+2En1emDOLnJcx2EqOcdgfizn23dEBfkpc7GfTxDSIWIHmMPRw4349g48owa367XV2SGrDMnaJ/xQ24hB1uXPBNvf/tG+ye2Q7u3vlUPzzn51jYMmy3sDLKxVUY+F9uZLOSog1xxXURy4Yim1X6yQ5wEYRIRJoNQHw2+2JC2QmLJIhQNBWaFt14ZGAeuH3ZqxyCYRLyGhfAuBcRKDpg8ESd9p3xQvhFxwzDiUApTpYhH5T4xMVP+spNH/pMwdGMVIFZR+hA5MKabsM9vYr94MPux7ScUcCQrG0S6RP3DeIjVOzLQBkrDKh+DJQwO7WBAzGafJwVZH5M5F6iNTAaDOsc2k0ErEbFyNw4YA7GSE0cYev70sXtT1GTEWI6IH2PKb9qVxo0GRexdV4b6+V1sjZtuMuUwNMwlMX+ok7HAYPVC5OlHe8VjHznjLPr9sg0rwHF8YsAYcm2Nq64qKxYaWTYHWNAz4Ute8pJybk+WYBnxfZdYuODkdB2ccKQ4C7YpRFSaeYSjwClAxnYjufpIE39HyLy5JHJImA+sHnv26SXzBKeeYxOOn7/rCMRIojgx0eaLcL9wHiIiIFbeY5un8uKUk9rJ5wiaP5CwZMDhDj1kuwCnjV6MKICQE32mDeZJ+gZxFNGMdAZdq23aHA45J4uDp53KIT/1Vj92VcjXNbFl072i7Y5MRQxbLIkoHmWJuKOr1MP/kfS7m7hdn5nPfU83RB+5btWqicn+AXMnsoZ8wykTCSDSJo6F1oY+e4ADaq5HYOBJ1YnzGNtOY1Xefc33iCN1izwe5nv3N070mzYiathJdIfvjM3ISaHP/u7v2m1XkTw8tmoZq7b66FNjQT/RKbZnSVBLjyjT8bNkjLSLhLWIBo69KKXI3RVkXBf6ltO9yy7rG/ImtjXpO2MLEeAajrz7k632G4vuTz4iGbRHPS0kWZSox2kkAY4ts8rwfLgfctG40x9IGDJyrfFlbIWNZyzGqZZ9EWHaprwg0wL6ME6lCbKAbOrocXU3Rs0Jru2LQDFu2BN+aywas+6n7caN9+2i4PWNrDx/ngHPk7FCVv4XoaIsfS8SxfghM/OI77TZc4140tb62F59wv6U7DdOCorIVTa1/lYffWgckYXjsRExxmIsHII69iXG1362tme1b0uNvlFORG2pv7b7n30bW8HIUPSLtmmHe8VzGqftLEakrZBYMvCwUlDxYFJCJgYP87DkjoNAMZhAutsARqF7XPBSRTeLNqXFWKtB4Vp1qlMBMJ7IllFRHfE7iVhRA8qc0UvZRT+EozwIlGNEr6iPeo3Kxk0ZxiKzeyNMYotPGLWxDYgyYDAoN/Jv9CG27ISTbkzEuPB7kRAcbAoucnNQcoyz7j74GhR8KHyyqg1G7fYcUF6xsjpbhNEVq36xAharDHXSXPdmsDEGyG2cbW2R74McI/N+yCkMhsgaz7AK4ixWTPStvoqEee6rLOPE/aezBacLBhIDL/o+jtpTvnsax4gh/RfH5TFKyMrzITT2lFPavmAEjVrFPv/8sr57ZPISwIImTH7+85+Xe/Tsg3JCju8SCxPmA1varLbXx7Zb6WfQ+948EvkiPKexfcFntTMyaFsO/cTpURaHBtHAmXa/2M4TuTXMDTHX03EcC+XRK34fR7KKijCvRDJNuoVO4Uh41Su0seWCPqhzLynbPfy+Dm93rRV+91Imh9E9OVmOIw0iR/l+H5EX6q+dEYVBr3DCfO+93Bjqq93sm9j24+9IXG3+dT/bMZyW43fve18rN6vX5j71Dd1p/qT/1Ekd2yOX+yNzyR2ZpI9qe2z33ddPJsm1vUW/xzHAYQNw/L0P/RVzeQ06V//ZGkNWHD1lkZOoxSDOyIBNY/5nW/hffehwq/TkICpCO40xiU7JNRL+k0UkVuX0anfoTE6qsUSP0B3Kog8RCUgFsqL/yBhZp1z2VxxUIFpDHY0nfadcY0muETpSfciB/RD9R562vpx55qopW2f0pbb7mzyNFeOM0x82nroZH/537Zve1EaB1tED5Kgttk1rjz4wRhE87HLX050+84zKN6MtQbBFVLH6e17DyY8krQF9Ygo3poKQ0i7kmLbUNiOZhW1EPmRrAc8Yi6jZGkFgiVryf9xXnyEXIvEuGaxZs6Jpj/uqSxxJbEybG0RD60NEkc+Qmfo1TtXTL7HAQlb1fBS2JJtGnZEibAsEpufdGNNu9VIu+4j8PTeiX2p73f2Urd7mM/f2no1iS5Xf9W0Ldw1CjAz8RjnkHrlOInGufvMcec6MEQRJLKZGtNU4B0UsNKStkFjUoMA83Bxck4cJxaQW4Y+zjfIYdURpH8bJXL8UUJ8yEBNhnDwEFKfJ24TeR1gwzPocaoYApawPKa/6BBZlU/qxDcQETcnW4dWUr/sGu02RUUD1lp4u1IOCoGSMJeXH2IlICvemGCLaQlvrow27oNQozWg7xWU8URQ+t6JRn3MPyIfYXz8IkRCN8WL1AKnEYPAsUJgMMQaHNs80WoEstFd5jItuiKW2k1XXz3Q9WZGT54axNYokqKNXEEZhCDIC9IHvYqwwepSpfsaBOvhfkjbGJtlFskDjgAy6W/GMlXH20JKnMecekdQMWaOODKyIFiHv2gCP/eL6Rr3ud7929ceYGka+ut/VV5eJJXik+IImTLbZZpvymx7m9oILLiirh51TntisYODXW/zML5xJx49a7QfOu2dRwuggNDhanCfX9s0HXXIUwR8EjLnGfB1zud/WOT3MNwgKc5C5IhI7GzbKi62kogc815zwW95y3eTWkFi5pufoT06PeSvm2yBm44hO8ytiwJY/jlls0zGncUiQ8O5JDsL5EdecNwsW6uh6ZUXEnjpqayRjp58iGaW2knkcR4sEUS/yMH+a3zi+7nXYYa1+M9drm62sSBIy0T/mZPdTdkQvxJYA/yufA6lP+04INPeTQ/c0o512mmhkrp3ar5+C1KbHzd3ah9BQXzkqIu8C/YnQ1ha2o9V6/eYz8715/Y/+aGNumNhWjKBTXjivriVTDje9pZ6xYIEc0R9xqov70GHuGTaiMrTd98ZflIt4Z0O5VttiUSeiWn2PMHQfi0r6gXNKL+mnsFkiF5ix4b1X7DR0jXF34IHXNY57jLHQbaJtYkFGP7mne7sPuXKekV/K1Gb10EZAgLgOaRQROW97WzuetMX93F/dRAEhnNgtnicy9NzWpyqycfRzEG9k472yOPL6mvwRR7F92pgjg8gdB/op8hp5JhAzrjPePRc1YeIexoP+1XaERpxAr24iSdwLMeJ+D3vYdc1zIPLH8+c7v4tjl92bPaP+vvPsepGxvDBkb3zGs1dvz/XcuP9//Vc7xo3FZz2rjVAyBowNsmM7u1Yfk2OQWHW+RveM6GttRnZFglsvbYmTnQLGofpEXpY+v8i41Z+eD/cwF7g/WdQEV53/pH+hcWGeN5y2QmJRw0NIOZjwKF3srcmiTkI0G8Q2gNjeM1f5SxY7TPDd8EegfCg1hhkjFZNOHlb9usc0Uxzhp0QiWJN4hA5TVBRogAJV9vvf3zrVDBlGjMm3zphPcXJSKf3YtxtH5Q2C75AfDBNKpI6cYbS6V6wCMA5GRSxRYNpQn4BQ7+GmVPqikLQ9kqoCpYL4CTmRK+NTXSlDBo3VBIY7RR5HRYa86uPlKEb1Gue4bPLUTm2Ivcz1djOGint1k+bqR4ZnHPXnt3XfdBGZ2bU5DFdGe5xiEYjErq6nsBlfDGDto5iRRnUuFfdnJOmnLmlqDPm9MdmXMT+gLmQfc4n7MXI826OOGOVcMLLqcbLzgKNLY3XQmB6293cRY0ETJpK7vuY1rylXVEujl19+efmbv/mbPCVnAYDRzulEgtRbDT27njGOGgM/HAzzh3nJ3ElnW4HnuJl7h22V9XwiS8x14VByQv0+TroBes887FpzKuLCnGDOMYTMU+pJd3Fe6CLHxppLzY077DDRzG/qaq6OhLEREUM/0GsxT5sTIopPeciI5z63Lc/8ogyyMfcql/OoLRxbbaYDOXbC8zlV5i7OufrG/OS35mF6znwdBDAdY24yvyJ93VMdheGTNyeQzRXEUCRvVSfbDTnBHCZy9Dt6iywjaXadOF3dya+PMI7tv31zKH1AXj43t9Ot2mwMyPlBZ3Aqfa9fvPSHz/WjyBv1oZ9dY3wgxGNrJTnZ6mCe5lSKKiBH44GMtQ/M3+qvXPpbW+kwMo0oA7I1fuqFEvXxuTqwgYLQJyf2CHJMvhj3pI/YFPJLcGzZV8aDMUJHIQLIz9jS90FEuQZJpV76lLwjz4rxefLJWzW/Y09rh89A+5Eg5OU5fMELSnnKU1oCBAnHaTf23MO15KFsbUbQeG9cGXtyrxj/b31r21b1I6+I0o0TY4wpJIjIHuRUTMvGi+voZXpf3/nfuFPHOGHH2DMmyc84sGjhd+EPkIl+Juf4Deh/96q3+GknWSiPreW3kUyZLD0HcbKm8bv33usaOftNbNXT1+yuOPkpENvtQH+TifqaBxAO+qcmTMhEXdVbWWRpjIe8tcm9PA+eN+PSs+senhvyCh8mSGDleWZ9HqRsnD4kl5LnKRY1Y5t6nKxTH8+s/urlXuaqrv+jTPKPBaNhp5K123cWJmGStkJiUYMjaeKhMCI8PxJEDUvGOR2YLE2KJohhCaEg9vBtqYSu4zjDcwGTZ99WBwqCUqFQ/E+BmnAZZpHpPGBijS0lDDoKxr5dilPZ+tDEzwBl1FBe9ou++MWlPOlJbWSJ/rYSZBxE3o/Ihh+rQOC7QSGAsRoRkQEM5NqopuwoUisijIZBJyt15VOTPd2s9INAHgwJ94nwX+UwhPyOQor7U/BRT2PU5/WKTERHxJiIox5HjWF18AypA4Udocx+hzRAzDCs+raOkFOsnEUYr3oPIhvdI0iCyAjP4FVXY6KG8aSftYtC11f2dDNsGRt1yDojl+ziM0YORcy40g4Gp9+7ZtC2Ifc35tSF8eK+6jfoqPAaZNM1CG54w/6TOOIkDH047pHHiwwLmjB561vf2uQwucUtblEe9KAHNa9b3epW5cILLyz/9m//tqWrtywRq9Axl8b2Bw5OnFBWh9lz3DjN5kfzD33DUeLMyf/AuRSWPizy07P3jGdszKEUcyVHpE6S6P7qZL6NiBKRdlbazX8x53LszBmxbYVDEnOH7809iBllBWFh7vXyeV9ixIgo5MiY6znPdB0nU/s5TuY+99Zu84qXttGLdJn6c6p8ZsWbY6p99J/2ui/drG0RQcMx5/BwhCJ3l20WHDa2jrI5iubHensU/RyEtmviJBjXkK+5lx4Lu81KdK171SWcPnOq/o7jX5V32mmrGvKb7OgEjthzntPeD2kdpxO12yXa9toqIOpVeyO6h/6IRL7KVs8gfzjK5BtOsDbGeIxcWxDbInynvnSkOZ/dGI4xQsRnxqH+ohf1mbHq/spDNKirhZCPfKRttzqro8gF40t/cXjDAfe/MkV86DNyRWj4jXbSqV7GjbFGDp4lY48uvOqqFU3bIgeJa8mB/N3f80WuceSx9/oxFn/0gW1bytAHEYUTkcIIE397vj7/+fa9cv2+XjiKBLHGueeJXLzXH+7jOWZbGsf6LRbakEC2IbEJI/qB/WGOcB/9HeOKPeNlHNULaZGoPuqgL4xTY8nzSsYIjUisTLYvelHbz3//9+37009f1XxvnCpbvSKJctduIL+IjAmCga3hOramOrinceG9fkVmGdfmlbBnyUKkl+fIMy/aJU5lkpuFXER7RS42bTHGyFSfeb6M9ZqIjG3pxmAsKrHfI/cP2ymOMgbbeGxZiue9j5Qmi3qLlTZ3beGw929604V59nDaColFCw9X5HyoQTma6CMkd7aIfBsc2TCQBqF2ADcnTNKUHSMGqRBJmaYLK0XdPCR9oBjrowBrMJwkwIztKowFSln9ujBpRi4Pjq9J2ssEbDLHkkse5V6uoQyDCadwIiTWZBzbUoyHmsmP4xwHnYSgjIgYiCMLayhXXUzklPOwo4ghjtrtUxrDMoTHtg/sPWWrLyK6g4FBJhyA7jaeAIUfCdbA/xS3MUn2kW+jznkC7lUTbZQzZUpWMd6NL/3EcHIPfdqVk9/VUUcRUus37t8nezINp4dcGAKMOv3lHjXR5bMgXoxRhp1+DkOmzqUSq3ieWfeNI4kpbGNKe7XD+NN+Rg+5hAEjRN1zbE+78cEg1D8ckXFO21KXmqBbs6Y1ZvqSSKtXOCNLNFH0gm7VnnvuWU444YTylre8pdzxjncs+++/f3nHO95RTjzxxLLXqIc9MS9gnIdx7dmMFWjOO1Ldc1qTi3HShLkuci549s1BHF0Op99GUss+BMlhnjM3IC08t+6DEKFHkMVxepq5MbYIqZu529/mMTqQo2Tuji2NoVcvvnhFEyWpTAsBol+UaR4057mn+3cj85RtbmKL0IXqad6IbT0cH/U3j3Dwlae9yjM/xnbCIOPNpYgQsrNA4X+/c1+6xLwX20c/8YnWEdYOJHIkLeeQ0YkccI5eENNdKEtd4sQOfeU3HOs6Wi8iEugfL7rA/2RPf6mXcSG6R36UU09d3fSz8j2qZKNubA/XqTvCIk6mUT/ESmynoO/pA44oeZIN0obeDXIttnqSp//1QZz2Qt6RDFb5xpkxIhoHOWD8kZk+ZteQYeTZY5/aXuV+6u0zY1RECblrE91gXHl5DvStPrS4wJGtdxIqg1zVhUyUxwFXPn3mN+rld8qIU2OMIVtyONr0vM/JVz4LZIExqj70eA330J/uY/zEGGP/KCNIQHX3TCIUIKI/1ClOdwoYC/otIh847MaA6+MoaVu89JlnPLYdGcvsAH1KrhHtFLZfd25RPzaB/oxoXlCG8aluZMAe8YpIXXLTJuOJvJVNfuptfB5xxDbNGIpjoH1ujJhDuotG2qTu//APG22XmPNi+5n7yUHDBiZvfUjOyDAkCXv/v/+7jbAxPvU1gsQc6Tm1pQxh6lkzNtxH5Ld6q3/kDooTtOq68SOMuTjpCbFnXguYv+KELnObMthkfZHnoJ/rBaOahIY4nj3s+4WItBUScwYPXF+G6fkCRd0X5WAC89CNSvQ5XVCSgwiTSJBkgpnO8cVzBQ6ddlMmyAkTXhhz3pvsRpE9HEIK1qQ9LFKFgjH5j7vlyZhgzJjQGV4f/3j7f6xCmPiRBDEp24qjDbGlwWfeU8xWHEzODBzGHYXq7HhGihUXCqibEDZILEqM4u62ue83XSKAciEXBkbtmPdhUBZ+YFQxwITX1ns6wd9BtDBOKMcgJSh5ComSMe77tnbEvnXyopgYBNpMnvorCMY6fweZUuix7zg+YyAwJuMYQffXB/pc/wu17hA3q+IUirqt7u/3jJtYqakRKzexF59hxlCg0D1HnAAOhzJi1SuOALT9axgYn9psrDAaKHuGhXJ8zgDxv3I4YLbouIajZExaydEeIdj6g6HNqRj3tK2aNPnBD9r7hFHCIHQf7VOfuZ6rFhgWNGEC2223XXnRi15U3v3udzerSM961rPKVqMe9MS0wUAeJyeYZ7xObG3e8SzRI+Z8ep/zV8PzyenlkMZxqp7niIQzfw57dhEF5sFYYY+Q85iTzWHmpUhUSR/QK/WJZkEacBbNj+YtL46LSI52FX/rZl6P5J3mIE4eh1WZ2s4h6m4X9DdnThvMHxYMIpFinNKCxIgTV+hYcxrHx5YSdWfDkBHyVnmRaDvIBQ6+7StxvKly1Ud7zd+cnoiytChiYYYOfcMbWtlpv3vHyT6h19yXHOkQ8qEr/I5zZ+4NqBs5KIv+QgzFMcjgd0gECxjK22uvtY0upW/N8fQ4uSK0lE/f215jPuck04/GIKdROfpDmeQZJ+D4jfm+dvxiGy57hf2CGCEDTqP7xbYi7TQ+yFo5xqmxqyz2jra7HqETp6zRSaD+ZOEaiXONc+PYfdXP/XzvN+Qe21PAvYJki6TvguNiHOtjdpP6ByHFfvKbyKMRTjP5+JveI2e/cT0nvIY2IiPlH4nFHvVgP3jm1JH+jFx0ESGq/saY8ReLJAHXiBIJxzyIJItHYQtFHjP1Mv49Z+RiMcnzGNEncZRwjTgK2j09E/qVvRRkhj6MrVbGEBmbZyJyF3ljTJKzdkROcPrb83Gb26ybPBEo0gSQv7mju1BmHDzzmW0ekljg1M/6TJuMB/2rje7LXlEuufue7D3bf/InG0+gMgcYT+RjzKmX38Q8pS7mIfLRb55Rz6x71oSJuonijoU2z6L21im9okwLefwO79VhWBRfRLHFe3N72Ehk7B4zOaBjcyJthcSMIbzOwxXJkLCy3RXs+YAHPjKKd2GSmMsojzgRxETVd3pJOD+cTBP05t6OE/uz66z/sUfaJBYrW5yzYUA4YK8ZZHXuiy5MuibzcRFRH4xAoZGSW0WCLwaS/uLEWx3wv1DMSEbF0GE4+FufM2QoN5MuZU/J299rwo4IgHrFIvqHAjReIgkpRXfttWU1xactoxxWhhBFOOp4YmVrw7DEndpH6dan2MSe5YjaCYdAvdSZAeRvfey3cQxdDc8g44zCYbTGPliyIcNQovXzSa5hnITCRMZEORQw49dnriX7WB3rYKXx1nVIyEs7jU/Pak30UJbhk0YCYTLgCETERYTUGhvmGWVZbREmPSoag7FpPDDSPA91uyMviXb4XD2QduYv7SVn30coLUPf+DO2xn2+Y5/uORtOaGBcu69+QvIhfZCYgyKOlhAWHGHyxS9+sVy/wVLzftgrMXeIrSR9MKcxvhG85h7PXpAJcYIE0O3mla4zZN7gyCLVu9+NA3NLHOPq3pFXKRxnzykdaZ4yl5njzRm1o8GhUA6ClL41j9NT6ms+8dmuu65vnFXbFNQ5Vp/N1eZ080us/tb2hjmdzuSERS4SczdyxoKJa7Xf/elocqBz/U8XqLstDdqI7IhIRO0xt8Yx7uQdR95HSP7zn99+h3wmDy/tUf9YKSYTJLc2K8+LDvcb8yvd6BqOr9/HKTKRL4atQi/TAeyCOIXN7/SJv9k65lWPJbmfc87q5nOnjyBmEBHab8723hzrt4gSTjoCwDhSX4S6OZmM9PdLX9o6iBuSb0+B7/UH+SuHrNyfHmJDxIltod+RC+QVR/y6VsLZ2PbBqfQchH6IcR0nOAXJYIzRPcaTdmi3vjWeONJBNiGZIoeP33KK3YcjHdGW2h3En9/6O05zizYbJ7a81NEkiAALWL7/2MemRk76bWxrpcuUr2xjTJnGUhz17Dmo5eRexnS9ZUn7lV/bl3Qx+yBsqsiFYUxFZClHm0z0qb7Xtr4Ez8aDMWv8e7YRmeoRY1Adfe4zbdF3yldntqjxoX/J03vPhnHObjB/3eMe1zVt9fywX/w2ElHX208i+a5yYvuP59P/IR9jU3/HyVkR9RrwO6femz/i6G/XxpHP+pkctNmcElEw6o/U8xyab9SPbWduju2O+kk5yGPjyviK6Lx4Dj2jnrFYoG5PABu++Kh+dZSJentW1N243RKLzaOQtkJiTsDhMcg5JR5sykOIJ4dmECJ8cTbwUEfG7vkGRUBZxWpMRG3EdoG4xuRmAht39XmuQCm6fzdcMrZDmIgYJSbPQaev6A+TcezH7SZ0MkFqWxi6Jtm+/Bx9iHwiYNKuV20YexQAJhvbHys0HF1GoERjJm0GirFG9voAYdA9ncYkrWy/qwkT9XZfCoHioMgYKMo59tgyQSbDGPFIbut6ynjUNq9YCRoFdaJg9F8cz0ceQQKEoQGx+uczK31+p09jdaSbF4Ox4XtyII9QQhSbMmuDJyKiKMNY+fWb2IlA6Rv/5Ov3jOguIQUTE2U1w9iKR03MRZgwUOx1BJq6xL7eMKiircYFI1idGCTGuLHgO+/HCduM1R1jmjGC0I1tYUGYuEab1JFx4RkwrxgX+kZ9/E2ekSi2jsYZBnKN04zufe+2z401z5q2K1NbPFdB5lx/fVk9zpa4RYYFd9TMYx/72CZHyW677da8H4QVK1aUdbNVWIkGnq+I6OvCnIQEQCJwAulXzx29ay7geJofPJ+D5uDIGTDTY7k9i8gF/9ND5tmazKRDzCPyAYD5icPJ0QhE4kMEgz399B/nDKI911+/srmPtpjfkBjsJ84TUpwO8KKHzVc+44Qq16oyHWOONTcrw3XmKdEq9J2ojdCh5lfXmnuQBebSV72q7YvI3WBeNSe5xhzu80jG6Z7mSS/2HYfZnBrEi3vQqz7nnNNH5rpalygb8eF79zIvKkvblM9Z9Ttjw/d0nJNAtMuc67ecYaQ5O4Btw8Ykl3vd69om4kPZyiPDWMEmH/Nt5G1hM0RCUPMvnWdMmZ/ZFP5nx9H32uj6OGaZnP1PL0RkIxm6H1tIG0WyQMzlsX0IkWDbRGwr1k/GM9nQP7E4pN22OMVpNZxw3xv/2hhHMEciXuXRRcaf/iJDdY/8Gp4l8Dy4X9g5fsdJjeOw21NVtm70Okc6IlLVL5J5Grt+ZwsROWmDe3GkjW9RIZ5bsmcv+L3fGIuRdyhsv7BxyM9YcU9jQJJRz9wf//HURQl9EmSpuuj7WBxE6Fm0NRaNDX1hHGizMaivIorV/2w/Poo6vP717XjzHXkowzWIFvaFcV1HqunHIGOMPfLWPra3+rr39ddPNPaY5z4iwYx3Oj7yE2mj5znKpl7YAuRu3omTB43Tf/3X9jcS5qqj+wW0JaKTtDVO2YpE9+QQOUqM9Thp0Atp4lp1Mbb9r77m4CBlwfMRuWx8b/6InGvaGASYsWWc8jeGLabGseDkHke1R1Lc7omLCwVpKyTmBOFYmZQM+CALPKzBXldYYcLxYHtAYs+nB3c6YFhRZiaA+Q5jV0eOrNC1OLaQwox8BtpLeWmnSYrC29yI4/a6YCwE408pgQnaRB0RBeRIKZAjBRGGAMVGeWKQTdCMROy+/7HRFMC4q+zqZ6IOpdUFMgRM3pxpdaRcjSfGYdQ1jk6EQauHkaekPnpSORHlEKsSFMSGPBbrek4TnYJ6u844SYQj5HQcRJZ0fUTZ1I6A9/rKeGd89J2o4xlglDNkPEchF+3X9/qxljslGMe+1ZE3kQeEMaB/KfxIWEhBusbnjKRQ8l0wtMme8cSAqYkmdadclVcTcdql/DgpIcLTo63+V4bPbI+hjLWN4TjOCrJ7e4bJEFnCuGJM+kw5ETqPmBMCXStsz4W66k8Gludb6Kw6M2zGibBibDCADzlkYySNz+y9V1Yk3lOfd72rPX3g+OPL+kG5gRYxFlyEyfr16xuyJN4PeiVZMjPECR/1FkjPk3mqnp8DDGfzmTnIfM0oNwd98IMbEwlyFgclaKaP6epREYCDwF4xD9Gl7u05Ne/EogjHkWNpDuMcmzci5L3eemce87l5nVNgjglHMfIjXHrpyqY92kI+dC/Hh67R/nBszbvmB45z6BR6TCLQWATRXr+N6MfIt6Yt5hdt4PBwqun32JKjDRwu82EQPvrAPM7JIgdRGe7hPTmINKA3YyuEequ/umhrJCSPRKrK039IA7ZRncMsVvK1T704zOplfHAuJRXVHnVXDvKETlMGncdpj0SZ2qn/yEu9XBvRM+rLCQz5gzLjZBC2qDne3K8eVtT97V76EtFBhsZsJAMFdYzoZvJQRzrbOHQNm+vNb27tKM+C8vwdCcf1j7boA9/pD4RDEF50tS0m+j3yv5C1pK/IJvdG6JD7O9/Z6jrlaJu6aYtxoQ3sL30QERqudQ8EFEIIeXfAAdc3/Wh80eHq4r716XP6VP0kTxZtIUrSc2B80HHKi0gwhAYdSk8ac35XJ2mOrWrqYix4fsK+6+bAQLxE5Ix2cN6VFZEQ3mubcWcse45iS1ZEW0E810HYhA5XJ2PN/BIR2Ugs5deLae6rrdolt5lnGDlEjbCJ2ceHH36DyeOOo++NKbaL62PxiN1jnIafRPba8bSntXWMo8E9Y64xDoy/iPIgu9j247nxzMdxy+De5EiufmdsGC/qGgte6qnexm2cWsRuEwlVL4jq/9hK53llR5kH9Qv5m/88W+rg/bCdrHWECTkbJ8afyLg6n8lCQtoKiTlBrL5GosqAB76bnyEIE9dTipSx3/VtcQlQwLVxRRmYSDzMgxILzSWCCWWEhPNlElYnyshkYULsy6PSRZ03Yi5BqSFuhEXGfuaAyaiOPFFPikC9OXLkiQzy6hqaDAgTIFbbdQwUitpKwrDEeV2YBE3YcXb9IFBOZCnxqzHBkKjDDynm2G89DBQnQ8TET1kYcxSiSTr6MEKPYRTpViv5cTCd46y1T//VW3EClKixZwVn0PjSNiGpnhNlBNGgfz1bDL/6Ofn/7N0JuK5XWdj9dfaZMpEQSMIYIAFCCEMEAUURpFiKWD+xaqXF6vVpQZxwHnCiKhQ/tVoFpxb4rC2otdZ+CC2jIiVQgRCQMQkQCJBAJjKQ4Uz7fNfvffb/nCcve5+cQCCH41nXta+99/s+z1r3uud1r3vdC1ycCQ6VXYfktx0x47Qb54y3c+6lvHaOv5/l9spXjh34yHecNQ5gzRjGgmuy1OIC3Aw1R5Az0bGceROswG9w5Xv93NKVvsv8wJFjlAXgXIvof/wPZ5ymZz3rs3c30AMPgnl+prZgb44xXuMMrXf7jbHpiXutBTQ56HDcccJqMtiZpA/XnJHVg8lQ+hJrh1zApOZYzhOe8IRx4YHulz7SblWjo+kP+qmsLEFGtrsMueUbyyxq8iHYXbdfWRyy9RZv9AO9vV7RZI08e6bjDQfbLKLoy25K8b7fHZekP+lR8wC/YK1Ci/QnljFXiw79sJMVLSx40yK14wl0Bv3RpgCd7X36R8DY+9kPtppN50uxA56HU3gCizHho5pOxupIa/UMqrs0L/xtsUuH0mEW+oLFT3/6tIBp913f3mMr6C9BB4s6jc6sToRnBVjocrD5XKALfHQcnW0RaGNEX+YOl56jk9kGOhFc4OtqV3PUP38AHJ5nE/3vRhJJYRaK/+2/HbWwN55twQiX1Zagx7tqttbtI9EDfflJFsvVOQOXII65FgiAMwElC0pBAziXGWtsNsL7+WNoR7fLNBIgYTfIBHtgjnBjMwj9zUvwoczCjiahhXHhHk7gS3AInivCKtOBfS7rRHAN/Y0Bp91kYoyOh2gtmqvX46pr76CdfsmB33CKr6ojgp/8LjuhbJguWoBXz7JnZbNWzLggooY/zSO/50DXzHqfXwBH5ggv3vVTPQ5/g9nxY/zUdc9o26bY/Nrreeu4mHfQBw3Xy3gwP/CTOTTuaB5fB07g6xGP2LWYG9yUgcV3YuPxDrmCHz5DV6Hnn8KP93yPL+nEsojhx3f5BuYElm4FMjb8pTv87/lukqSPNLgSONGvOQimdYyuArDLNykax//4frlGpb7S23h5ngGj4d/5WrAjaWXyFAiGx41uUjxU2hFf4Ug7qIa517uKdKMrVinP9QImDMF8p5ywdnZxvTEZ2BwkAs6gzJ2QL3SjgDIsOUWloBH8Kq9vdGtJjQKkLL8QrQU6BbxcVd9Cc77YLppPuQt+UKoHChhwGhhcxgQ9Oa+cWY7GwWSpdzUZnK1X1ybjzamq2BWDVrYOBwrdOTACLvM04lrnt82dE+Jdjgh8l7aq6Qe/CQIdTICrtryIR/ON1lYVPjvYzKeu+oPnja5hE83f6JgX2SEPjJadwuSC4cGv6LucicEJ4HRxBP1tfLjrGm70MufO6TLm8LbsaFTcTSE7i6GVlbEaXvXPmYxH9FFq+zyYaly06kxtx3GWeVhfcIv/6I950Ax/VnAZ3Gg+/56zwoiXyQYf8IUPOJt01XrHe7quer2sMZ9xYux0coItdDhZ6/F4afIf/ODkhKGJoA3nzvGl9CFHrQDNYdgO2YCJwq5uyDnSbrtGR9NZFrKOBdAj9G+Fm+mZ+bEcdoDeVDuB7rJ44KSTXfLTgm2jGmKC8hWEtsi9paD6vAlIdHRVcMQOtcUXu24ebJDUfTvt9Bt/APz0mMUyewAuOs0Ch22gq+g+84AHC/tu+aAntm1bXSyyyLq+yioxvudkvAkAWfzq06LH/wJIFQC1YPK9udvZLovBuHQ1fFv8exY8Ag2epU/tjpuXz40JZ3QTHMI/u4Jm4KOTsv++qzAj++JoRNks8OGokuAWHPU9u1b9Kp+ZRzU9OvZEr7PX9DAeEKT3ucUwuHxPrwu6wBedrXaD+b3rXVsX9qZaIN71PftUIEPrSIaGl8xFX/Q3OzA/LuqdjhewHXClf7QtWGY+8Kkf/hT7gpfwtTnzV/RhXPjDxxbNeIActAGkf3QDU4Vn22xw7Enf5iQjsQ0km1ho5332jD2qgCsfycZAwS3f68Pmmb/xEt5gUwVL5psPZUPBvd9o7ns+n+/wf4tatMM31ZgBDzsPP+hsLuiZ34vv+CgFTPTd0Y4CXRsFQwWMwADn1SABR3Lgb7gHoz7LcMc/cEs+0WWevYoX8Fot/YFeaISeyz6Z76sHUpZL9TvASNbVJwKP/qvZ5hkyjn6+c8ym7Jj8S3Il8CBgBQ/miK/5Vh2RK2tYoxf01y098Iz+8Tu/kGx6B1/jmZ/5mYmHraPwvSAsnMyvHcc79ANfrDUfnDiOzm+qnlT8Yo7zI9rL60HzMrajXGUbtrZbr87krdHdX+x2xFc40g6qUUYyDOZCVP2B9Rx8QrPObTmbqjReK42OkDBOFENZEvonUD4rHZYCKQ3zix0wKeW0nTEGn7KbH79g6NarP8A4dNzhtmxwR2F1l33nTQ/U7AhwPA72ymXPMRRV5LfI5qBxIm6p1gKaMiIVD51f38bZkO5KaUtPtCMBfnhShI0SZ8TgmHIX4KGgLTyjAQXMuJhPu/kMqL85Qd5hNEr9REN8dWuubq36fc2c271abp/LDUnwOb8e82AbQ4g2jLf3GW07JTlerQE5SXO8wy+ent/qxEHQD/kuuGHXsMrp3lnO6HLsxkKAs0Yu7frUuuZXuqrWtZcaGnDu0a1d11o7N/MGLs4mvOMJdQPic04Dw4uHzBEf5YxrdBVeMUZ6x3M59/OiuWR7ORBmXuvtSHFs7NJ2TACPcurn1fZr5vihD03PccLMEa+3A1R1fPgVrLIwOwzbIRsw0b7jO75jvPjFL769wThs2vyado1t4oTTo/QpmZwHvsmd59fqSu0LPHdcQaCAfFT8mh21MKqIIh3gM84+OZwf+1uvWbixXxWnFNix4CDHdIgFDLmli372Z6fFApmnY43FttBnFjeCAuQW3PQBHUx3Wox6hq7xnOAwPc2GecZi03zLXqz2AB3sff4TOMFD/7Lb3mN7BJf/7/970ntwxZayrzYO6HL6tyMaFvfGKpNPAILOZxfMCd7Nh92AU+Obk7G6lh6e6G106gY4tOQH0JHmBibj6Y9toaPpt/kNN/AJh3Sfz/CBZ7wD9/DMbtG5vgezOQnCtPhrkaV/utZiuxuVOhqtycYQtMAXxhFccpVz1xOzcXgQTuDBfMFtXDDDkWfZrgqjqqvCrvGF4FEAhB3C344U2DwAi3GrX1KhdQELAXINr4GhxT88OtKCThWE5UfAMzjM27Ngw0tsYf2bGzpZsMMJX6gi7VqBnY65oTO56ajyvPFfyQIbBSfG6Rpj+I0X4NYNTMaqZskf/MHEd47CsNHgQWdzg2e+GP8s/x0+8RR66bPaGsvNvM1LRhHY4KVMY9ftwjUed0yt66XJimwIwSF0RQOB0Gobkanf+70puOPKZPiA546M4Sn46SYnDV3RTJZLgVRwtanUMWiZOmjSe/7uiIqAA1zhF7iiM+DaDxqZ3/zGpjKtZSjxHeCggEoBoPmNWeghIDm/iEKmHhgF3H7rt6b6MPgbrspYAl+Z5PDKpwO3cdLF9Gq+o7HNHS7gMH+8jeH5qQA8pUZhRwE1ffKflo+uV0bgUG5HfIUj7RZbip8z3yKDQtmo6Op6O0Eb1bDgnBBujoDCZ5Q0AaTEKCIOAKEjxF+ozBJzWicjZqEkW9BRFJ6jdC14KAVKbF752jz8v3zDDNxxAtZL2/98WumfcGZRSQmWfgiHlPB6mUEHahWsmmcQCWBUmMtvjiGntCj7eo3yRbeuR8tZnsPOEDBeXf9XJkdXysInw0fZcqrMD0+Ao0ALB4YB9T1aUboF3QqMlIWDhgzOemfoN2oV6apxRnIAGTVGgDG28DXurb2d6dYEb+atIqk1Ti96wTE5K3NrvauwOUBwSybhHW3wdVX9OVJowcBzks2N8WyRYxzvcGQ5wPTDck0P/5dZMZd7NOo6Ojxb8+xGN0x1paiGn7pamDOBj8gbR5uDxrBzsjkm+MTcq4Mz11vdRABfZULp82AMtjmUocVB5BSCPVzMg8XGu+c99wecOIrt0HJA/JBT9LQLd0uLvS/RdkgHTHbv3j1+//d/fzziEY8Y3/u93zt+7Md+7GY/R9qtaxXK1HK4k10OtYXC/MgeeakoJ7+BviCHFkMVwmZzyTh7R88KorfAoQeqS2Fnnc040MYBvUWv2fWkC+gAsluw0yLCooB+Jad0KF0hKOx2N/qIvqQDPGcssLML4KMbzd+8yXeBdPrIoob9MX/zKsBuzv72LF3nb/NxzNGCho3vSCkdDT90Dj3nHYtE9rAMPfiASzDpW59wA6fo4HnzacGDTvRSwRF2Xd/8LrqarusmFPrbvLpNyKLW974zPj+R/rcA7JY1Dd6yj2xxAatuImFnnva0/ceLwcuuV0w/fwS+0RguH/jAPYvFHj07tzP0rcCThRnbZWzwW0S3eYMec7+SL4GnjFnxeAt/3+M/2Z7onX/EVkVjPkBHj9HNO/oR9DJHvIJPHe8xhgCi/vPR+FX8FDbRHNvkwYsCHejvpyyWslTQWEBRtmPHQNgyx2nbVNAveHzuewEGfRi3jRM8gObo01WzbfIJdAg4waVxBXfMq2u6ZVrhGZ87foVe/kevftqYSSeAvaxPcBXYmsstvqEvKmwq6CSQw4Z24QQcwyN/UDYbHoifzFPgEr3IBtxZY4APP/z8z0+23HNwJOPE+HgHn6AlPiMj/+bfTAEaDV95Nr8QPPNCx+QLLuGq66XBSz58bjyf6Rt/6RcfwAecwx1ZoCPgDezVI+KDqYHWTVT0kL7wtGfoDcEs+tHxJDDCI/0GFvSS1USHwDea8GHxhT4qsQCP5g8uuOoIUDdi4UV4ALN5kCXyNd8sryZTx398bg7dkEVm5jWuOpp0KLcjvsKRdsBWZWhKAHMf7E0p8xRI7YYbxt5uxJg3AkYAGX8GieEj7JwYgkqwCPjBZkSs1w4UNKCAKGzKab7rRdnNDXBHbxgJn1NYRe3nzzN8lElzLyVwvYXrRq3djeVmsS+qS5Fx7sDdTRwUEmXHeaGoOIWUj8XcwTaKlXEoOwGtGSlzRyd9M6iMeima6/XfUQ1GxN9Vq5/vCJoLmDksjCd+yqBSpPCl+Bil3FEMDpj3OKcCBH6Wj5zY6eGwzWlpXE4fmDKaOQo19Fs+UrEc5OuquIq/mQcccLTAzmn8YhwXy7GYZ2t19R1eKLXU7/X4rh0XdAYvo80Bwk+cr3Y9/eZUoyP5cG5bQysLGThA/64BXm52MCooCJ4CVaWLzo86bXS+uLZ8xrUCbGSNDFQPgJMJF+DyDPjjkXYjyxgSoLBwwn/42/+c9XnK6Xo3emhoXoYJnJsbelgokF3OE2cV3HdcGy9nIcdW/3BrAcn5oTvg9AtV7+h2bId0wOQ973nPePjDHz7ucIc7jAsuuGCcd955+37eOV/ZH2kH1aad1vWLZpNTBT3pnm6bqtA0eyDjjlNucSbjgO5md+gGOkIgwuLIYpksk/H5DSD5KxvdZFXWhIUUmbUQKIuODjBmR0jpDbqAjpjfymZudD+Y6ItqYlgId3uHftlK37FfxqBnwP/hD29eLB4cvfEePeE7C08Lc+PTKfD1Qz806TPf09H0B3joFz9wYnHFx6loZ9ks3pMFUbBZQMSc9dFRno4S6YuP5XNzMG8ZEdXGSn/rF73a1GBP6Ti60P9sDrjZSf8buyMRaJRd1g98dSQJrmygsKHGrEit/tgkcJq3cehKc/D9aaft3rfpsuwjorNFPP8Rb9HvbEa73eZZNo7GjnX7oWAa/hKIYOv8XfYSPY8fBGr0VQFMx54sUsFuzGpLmJ95VI8LnHwXz/PTKqreEaoCTey0m2MEd3xvbN/rg/3xPTxatJah5bf+4MMi1nv4tJt4wMG/Bne1ZtD6gx/csm/To2NQ+T7mBwb8aSy00CfctCkBl9VlEQz6vu+b/iYnngdrVx2XQVGw0HdsIh5ow48+4JcIGLaJ4l0Lf3Cbh2dkXYCVT0oO9EFWBPsEWvSBXvwNviEeAyd42W7yCQfopW+BIbxifuaB9zzPTyVP3qd70PmXf3nif+8bv9oy3jWu/8sqKxtN32y+fsiE+dKHglQVIia//KmO6fhBPzTTXxmqZauhazjiQ/C7/tk/m54HG36Z+7s+x5v0qAwbMMHF/DrtMrjwctcaw2EXB5BFOMH3//JfTvCjK/jK1INLckKmwABGcwM72hi/MgL4y1wO9YDJEV/hSDtgKzAiaksZdPWmttFNFR1jmGcUXHfd2LveYrKK8hSd/p/5zMloMyRFcA/2Rpb1GuUpIjuPZNYobYtrThJjxjcuLX/5KIZG4c4/mxeq6iwiWEViC6TkOFXpf3mhznAv1zeBj+WK0Z7TJwV++ulju9Q7jqSjERVdoqy8V9ouJc6ILtf9YCBFueeBJHDZmZfCx8DNjzOEq+jA2eOIWKy2Sz/HqdRXwS8OaI4zB8BzFHFHaRgRfTIggkCcGQoTPvx4Fy4zFhwBDvX/9/9trFj1x0lknAqA5Gw5hsFJsWDn7NQ4757nSMwbGOcFX7sKDp59h07zI0cHc4vObdG6qm65wbe5tXOATutle+EbeGinB46ls/th5JfPoZoXWjOo6Aef8M9wk5lqoKxHC7zfOf/0htYNBXOYDhQwmadrVpzM82jgN+cbX+E/z9rpYtjn52vbJanph5PUkRn6DL3Nrx088rRcoFIzl/RZt0/VOGOMP6cEr9xww/4ijy2oNDqB/jNmtwBs2zY2L2eoHQbtkA6Y/M3f/M2GP39tq/FIO+hGp8xvSZjXgMLnZJDuKnutxQ871aKpAoR8jY5vVHCRHCXb3ncLS8fs6AR6hP4XXJi37C7byF6Cy6KHHaXTuvFGP5z9bpuxICTnbGO+gcUM/VetC3JOV7BhniG//mbvBH7Ite/pw+n2sy2Lhafn6E6BCTatHWrj83/otd6zoAMj+CqQ3QaTwEeLF/qf7TRfC0iwool3Ou7hO2O1+LYJ41k47mY1sHV0F67VUkA3C71qN1j0GLdMQXTL3nSMV18W4tVYK/W/nX3P0698zHwN9JCJga50uXfB4Dc75PYYtPH86afvXgQS6FX0WN4c857xy3QFA57DixZ/yzWz9GkRCV/gr86HeaIjm+p/cIHb7Wb5eN7tiJIMHnwf3+lLn/k8GvpaVOJZcwO/d8viQVfjsNVlSeBXgTEBF8+hX7aVbBgTnfwWkEMbvANuOLD4J1P8FvLiOUE3QTw0AAs7aI6exw/JNN/Qs575zd+cxsZrfleMWOvWP3aPb+1d38FNAUowkreuCQcXW1kGu7njv/mmkPmz9+DWT5sV+JYM4lF8gT+8JxDBpwOP/80FjuCwumXwoA/v8Q/1Ye5kS7/GEfihe8izn2RHP2XpdtToXe/asvBVu2EJL4MHXb3TBo/54R985adjxuhEhwi4+J+c4RMyRea75RIO20RaDhTmG7ZeM8f59ejJKhx0nKfMLeMXvKBLug65ICn9ITjSWkdDR/OvZh3/yZzRG24rOux5fED2zAtO23Clb8AIl9MNhodmMbcjvsKRtmGjKDE/5UfhYGSCRslvdIVu9UgqGlUjNITbwpQy4bhQKJ6nNAkQgeuKLQqsq3w/10ZJCTSIuC4XRNUqLtdCSzYDZWF+lOJ8saXNlbdWtf8UTemmlLf39aXfMmsom/mONfx4hgJq972jSP5voeYdOK1g6z3uMXZ3dR7DTBEZh2GgPAWBKP6qv3cd69zwMHAyLVrEUljdPqQ/hmt+5IqhZHwp7K7OFUAy77KO8AvHT5+lmwpG2JnglKEn+hsfLhgFcDEIFSVDL0ERcPseXzCSBV44OIJByw7xvHUFbgWzBJUEA9CvqwopeQra+B0P8vc8uwAsxtLwbjhh2DnS+ro9inSuZyRrBfTID/xXib15VcOFHMOHfjgVHHTOBNqYn0AI566sjoqu+rydRYbbO+i33pE2DY44WMuZLgVM0Ap/4t8D3Xw1f59xNh748Yz3GP8WGuSQDNmdm2e14aPOMddy/DP++Ivs4gnPmptFyfIxrrmTBA/LdUO9a3521f7iL6bfXbGtmXfptPidY4kfjz56bIavw6wdsgGTP/uzPxtPe9rTxrd927eNP3AQ/0j7vBoZm9dkonsKmPhd8JZsCBrQ8XTIvBA33W6RR0+TbTqk4DQZqp39vUsAAQAASURBVMiqTQ5HDxwZ5Y/Y8bZrSS94viKNbL8aB8ZuZ5SdtZPPVtHzbITFjIW6hSZdQvb9tHj0bjvg+Sr0jt1sNpBOpBvVPSHzfAv/G4t+sLCf6lasLsaWJSCAYCwBFv5HV5+yr57xNx0NBnDCAZwYX9CJ3WTrjOMdMNnMsNCHA76MPjzfwpCN8DebWKo+nHUsAP4t4PTBl7A452f4AQvdTW+yjTY78hOMDWZ+S8dVjGXxxR8AJ96wSIIP/kM3DXZFqQZH3eZjHPapIqJoxA5lCxTZhA9z9+zywlDf9DQ6llkjow8vwM98QyQ/zvGLbkOzU29cNkWAxzvw428BGAtrPFNGtABXRyHwu/4KBHaDXxsFcIBHBQbQV+ABrfhQ7AJ+7tpcvI7+XXULh2VBaeYNL2y7eZKJjjzBuSAiPOBBdMT36ETu4PvYY/cu6ISX8YWGV9CNrHU9r/7Ijz6N7wcfROvlzQDzJhvktppoaNLGAb+zYsp4ptumfL6caQkP8IHv+cH96AvMbCwYyTs7bsEOPjyMh/iDjtKQlXxWtltACl35Ct7j95iLd3wONvgCp+Dm85434ckRIFnQeLGjPOedt3XxPzkle/isq7cLCIDrGc+YbL758n/wL15Bk47984HpkAqz4h34BCPewTPe3+hWxo7sm0ubQNYbHTeDD0fFwAsn6I82bqHqGDF68/nm/mbXXNe8H/ya541VXbjWXvMrh41jjh1T8jkY/A3vN9xw6AVMjvgKR9oBG0XDqLdgqqI5IdjoOA4BqGgahU2gKZMbbhhbGDtKw3309UFwumqvBRPh4zwwQvOClQfbjCcYYGxpdRS8Bf9ya9FDoEXKKXlKygKGY3Qw13syxByeecHPMk8yBrV2waqiLd2Nw0GBFllvt2Jej4QzRblQUhaO118/NlN6FoTg7VYiOGdAv//7J6dJ/4IxLXQ1z1DQ8MtQVJizK2Y1xhCt5gU4u09+XgiqG2m6/kxfnR1u95AB17egFVg4K4wPJ4wR6TgI3DB4YKCc/UYP46HT/Halzk0vL2LhVGQbLqsizlGe3z4SXtfOxK/4Owef4TEHzq7gjiAKI+4oj41muG6nguH8XOuPfL5tua7KvJGXMiW6SrnrITUyWbE3su15DhtcMfDdJMQRIZPkCC9zShhKTqz3qyViV8b/8yyjeSPL8F+K8TKcaI7eHLwDtXnAxNz0hXalG5Ojagi1i9oNTxodg3brZavNg17wCtbS3vVpPDqCTHQlXufCNb/XdNzNGnyC+1/9q6kvOItnwFnB2M706ufOdx6ry5lth0E7JAMm6pb8i3/xL8bb3/72xbXCP/ADPzB+8id/8vYG60u6zYOC82OMy8dcpdpbhNG3bEI8nx4hZwU3K1w9v1Y4/e+9Fh0WFmwLfeBd9o/es6C1uCGPZJRdonM49GVs0IXsPjtFH1qU0XXsCXtjTh33tOgiq23usF9goDvAz976jg4h32478S4/gV66851XF7Lf8Qn+ArtEh7HxdIX5CxpVtLysl26cAbe/BXsdS/A9Wwwv1Zwrxd9C0G8wGZfONQY7afFcXS+LzmpdgMXY+rWYMabn2NV8Qc3CLdsy31Qqk5TdKBDTQlD/YBIEmKflV8fCwsvz3Z6HTvQr+ODKHPha4NixY9Ni1xoNw7+5FMAvCCPoUZAdPAII+ANf4cE28eDI53wrsKA/HsYvxmYnwStQgofxlc0TtIZXvhrfRqPTC1oEQxsZ1TIxT/PpOuRf/MVprhWQVZxUjQj8bc4F6NCEXwvH7DwcVKwTLvxus0nzP5gtvI1X9gI6TcHIPQv40RJfoDXYyMXLXjbRjZ3Cb+YHHr/5enhmvZvm2H5ywQbyqfzArXmRU/TIR66WoTmWhSQoNW9sOflwTbmFvmKibKsAFRlFn9/93Skw1y1B5sw/8Yy583nBW4FZ45J5dNIH2S1YY+EOHzb54BjtOjIl2KFWCP2Dl/nX5A5e8R/98Tu/M/VDztEafeCwjSayh6dlqsAvfdjtTtXsq8gq/Ba0qQYd2MnxRv5CxbfxLhqQ1W7xMn61ofC3cSqcnW/nvbKp56cJjA83v/Eb03P42Rom/4cOUpSavsYv6fzqEs6PYJsX/d/1xuYEL/e4x60oNPhFaEd8hSPtgM1iBKOXwo7R2+1gJJazLZavFCSgFIxIuLoYO3aMLRQCQ0RQO+9I8VLwDFaOld+d19to5/pAzTjeJfyMqP4JOYVT1knVx0utpIxb0DEkKn3f0nXBGiVYNskcJ/7uCt6aeXs+o5Ty65pScMB50XqKjGLxf8GLzoFTzGW0UNBde0cJMabwK2giEMQgwoGFKyPEKMAF58f3nSsto4aShZ8Wd8aiYKvWPzeOYKdoCyi0Y07pU5z6cA6b0eEgGdfznBOw+B6PmANnlHFLOXMYwWjssm3KvMGL8yM0jIH+GOlub2qn7Nd+bX/wrqsc0eUTn5iOP5SWi9cZPrsGnFDz5rAwvgwuQ4xPOBYVI74tr0HrLP8ttQNltRQE9Aw+gG9OK3mGHw5LcmYueEJwCk3JJscLDHgAPcmQ89ycI8YVveGM84FnyMpG131qnbElS/MMkxwLcKL5RvpkOZtLM6eK+4Kn1GL8WyAFbbqi0Xwq5rdeWw50lE6sb3JAFr1rvM59tyNWK5Or5jnwVvvg+NktUeBKT+JPeOjowumnT7eJHWbtkAyYvPCFLxzPec5zxvnnn7+oVfKf/tN/Gr9H4I+0z7l11n0u59mR+W4oebZQIQPkzQ0kgrN0FH3LdpaZUoBSwDKHu1st2E99yjShvy2IytKgp9kIsltQkpxVzFAwwBFXer0FA/tpbPpdENfnFmdgKHvDb+/r27j0AztN1tl0z9C5dnCNC64yLsB8v/vtXvTPrrGTdCnY6DV+R3UY2E/POwpRnbcWUN5v8cYmg5n9pDv0I+BPt1QEvMK03XhIt/ktm8bf9B1by37q3zz4E8aFR4ENz4GVr2IMMJZxEl38bZ7oW2DFAtg8wcDWCCCgcRkedGOFu81XHwI25gomi2Q0YqPgFX31w3dxrbCNDfjHI2irD7Dph/3pyFZFTdHHQg4uHOnynkuyqucAjrIxBEzQoY0ScPB//W3ubB8+gp9uBMqeFKiKj81XPwUq/BgHnuAbbGQFvcEE9jbe0FX/YEJntGtThJ8DB94lF+QPb+qnW9cEdcAJnorYgoVvNBUS3rKwXzJqBEHAinboT6YFEbslyvNoIJjChwf3esXuzanjIGSXbLGd+N7c4bnNMLTml5ufwEqZFuxo/iecexY+wIBHuiXQLTACkxbw5tnmH33AnwMnnEWnaKPpF43NDa34QH/0R5NNL4jU98ZHMzVatPx48qbvv//7rQtY0Zgsqe/BvuM/89F3x9MFpOCNPy5YgC5w7Z3qAPmNxub59KdPuMQvbXqR1fkRyBoY0M8P+e+ad3PyLny3/urYH16zEWhjlDzBCx7JJ0WHAm35W3xDcHcVtXnhw9Zv5k1vgcccK1WQji7DzRzACSY8ceWVh1aGyRFf4Ug7YLMoJ1w1gslYUBzz7JLlhVJBCE4KAbGzwoi88pVjFyPJcHKUKM4WEZSXv5dTyza4nvgWGyVQBe4aYy9w060VorqUDyElsOZqcXVrFyveX+9q2I3qrrQzUHGpnq3g2jxFVJ8UNjwWzFjb/d5bTQ8BILsRFBCFPj9GQ3EJOtgpo8ikejJc+uJUBDeDO68vQ8HN8dCxrOCfL9g9a0yODPqZS7UrPIcO1TlB52c9azIKlKtUzh/8wcnQMWb4gzEsUAV+OwRlmWho5nsG106fKLpgDBj9bgdNXyruu+QCL+LDdizK6DnttLGZUxjOzYUxysHXnzYvBotG5gKvHOX51bSfbwOfjJsDtfmtE+u1+VERBrL+ONXmiX45UfBXRfSNbuDhmAukoK/+GEZ8BkdV7b+lhibgiobVLEDXuaPFCSe7nN71AlHe4Xxw/vSB9zlhXe/H2OI3AUy/fUfW8Jt5rldMFQxl08xxjL5kwrzpDHoI38TT81oomnHm103TJfRc7bjj9u+UtquWIwOHcEN+7n//sblaBodROyQDJh/+8IfHd33Xd+37/1/+y3+5qIJ/6XIBqSPtgG1em4icVEdieROhxdw8QFkx0O/4jkkG2Co6Zl7IkI7XT/UuypyroKpFFdkR1GXT6Hoyb/Fl8VH2nOAwPSFwQHeR466vNV6Lt46c0A0WZWSU7ermC9/ZYTa2W3PYGvMAY5mydKX/u26d7IMPzGeeuWvf8U/PsiF0Mz0DVv0LEuiTfeZ3sTndFuJdODJWNSvoum6xgxs0QBcLHwugFqv0EpjQCR4sqi18jVlNCfizcBJMsVDu+lL4n2/woCf9KIjCJnRlbdk34POZIL1MT2IFNrqTH8kWsTMdHfA/H8XcLSyNC040QVew44k2PdD4+ONX9xXarIA8+wdvAirwWnYqnBivwtvV4sI//Fa+iO/AiHfgpOt7wVEQQw0dsPEnwVt9i3igjB30BSccWFjiObrf2N6Fa9e8dgNhPp756Ad/ymKpTzU5PG8hXj0TC3s2nk33DJyzU+aAjtXDgm/8hZf4NR2NsQiX7XLRRVsWOMxv7rgs2nXlMlkgQ/rsSth5Hb/lBncCFnBL7isy3zGv+vHbZ3yxf/2vpwxp8ILFcW64b0MBT5I3coeW1UDR+IpoM/cpuu3HfMBeLR9z7egrnPmhCyrajnZ+4zu8jU+6StqYcCK4KchTEFHGyxOesGPRb0fDPCdAx7czvmBFGyZwUtCUz9NVy90sRC/i5frix+J5csQvE/RaXndo4IbPeb205SZQ4cf88sXMsU1Oc0zPlCUDJnrMb3LCb8dz+XWewUutQboCusz6AiZlu2noP79OuozBq65aOex9hTe+8Y3jG7/xG8fd7373sWnTpvE/nAtda7t27Ro//dM/PR7ykIeMY489dvHMd37nd45Llu7evuqqqxZHio8//vhxxzvecXzP93zP+MxGu5dH2heuzYsaTgScBHDuzGN8ir/PPFNEk3B0fzwlccklYy+lZUFE8XYMR6CC0FjsLN+iQ/EdbMCE0rWTUYRzOTsEDBwcConypawoCMqo4qQMLsXVUZiDbUVraxQvwd+Ib82dsipdUqv41jxoxBBQsqUGzgvolkUg8MHZpCCr6t645umHke2oAmMjOAHvcGRRZxdlXnCzYwhwT2m2u6RRrGg+b5wbcDAa9RMO9GOnjXJl+PX5Pd8zZWz0rN8cW4aeUzfnA7TEdx0pAhtHh3GEM04DJ8BYDNdLXzr9X4HPFHPOnvc9C95PfWqszI+JmFvHqhhMeOJQzK/UrWggpw6vVwjwc22MQ2nk4DK+8fyUmrrMO+vdNrVewAQvMWKcP4YbDhl1PIXXOFp4ZUkHL2DCL2QBHGSnFGw41S98wEOBBv1vdBtVaZdlWMA9nYFX8TXeFbTzk5O6ngyiHwcF/HiihdL8e/CRxXRSznO1BOY71nAAJgZ+rmfmTlg7v1V6925Zb97NXqILh4oMVDSNfKLh618/wcA5kV49P+5XSm8LgaOPHrvXS2/+Em+Hlvez1nbs2LFwRmorKytj27Zt48bD8JqiL1Sjn2QXsvUFRekPCy16n2zNiwH6vx1L/oIffbAv5IaMPfe5U39sD5min9grOoes0FvsN90rQ6SMQ74G0pFZWSEWFfRLRZfpMt9ZiLH3LQB8RjfQO2BJ51ZPTMtudnW8MS2euva2RbhgRNfsWoCD1+JWXzITLI6xHByAoUBBmZPV9wJ/fgLY6SCBjzZPygCAb/Nb0x0LeEunh0uwmB8djk7sPV2jD+/7DXbvqjNmgcpOg4VNAh/dhT75E/oSUK6Gl/7YXAGKMgPgqswT+KI3rQfYZ3aebfGMZ+EmH9Bz6FMhbPP2LDzDhSA5v6Ujnbt3b1rQFfx8y447mLPM1XbCq+cFHniH/456VavKmPDFrsk2YWfQQcbDr//6/mMVZTHosxtTBDwclWFX8K4AHVvATlU3Gh/73m/0Aw/8oRXbmc/KdukDPGy3BbdxOoqlD3DBH//IKUJHz8HT5ltBK8+jC9vP7sCTbBSbbHgRHHjqgQ/ctQiceaabjtha+IEPz8FrN6+UlTvPGpg3ctfVzQIL8As2G2Z4he3u+l18Ab4CW+RBcBD+zMO1u56pYGwFded2WsOr5syX5LNq9JC6ZvgGz/ocvekisNEveBJtZbihFbqTCXDjOeOiR3KRL1SwQ9/R0HE7eDVO/g46mjt/Ay67vUjTN7/VXLxjbYRG5IDv0iaRpo+OuJMHvEO25jXPzEdgir5arsE4b/M1Erp7p+CS/vFgWf98LD/+h6eOhuHDgqU2KcEE38ub1XgQvquvaKPOPLVuIpsH3cG1fGPl4egrXH/99ePss88ev+sc2VK74YYbxjve8Y7xC7/wC4vf//2///dFJuz/ZSE1a4Il733ve8drX/va8YpXvGIRhHmGAjlH2hevLe/udkMKIatwKWUgal4qnXcIf+mHhJkw+e3zb/qmseI9/3c9L2PAANmNWa8eBP6cC9KBGuepO8jnwYsaJWwcClqf5kMJFvnUOAYW4geza36gxtHotpL1GgMmOmx+KU54A8t8Rw5+KHdRc7BSZJTnHe4wVikyyp1i1I/FGINBaTEAjCdcUKYVaEOPHNuUKYVLic+Vq3c5WwxNt/C0o150eX6TByVNwXG2MqQ+oyjh0lz1ET05EfqYR8erOwEf4cBCkxFxLKQjNYwSGurD7gvny249hUzxM6icia5Y9nxnpO2oUdjVLXn4w6d6EfE7IwFmOpBDBDcMCL4pMOJzOMe/DOt6heY2atXksXtHptCS82/3wTxLcWV07EZxugXL5vKYc34wARMNnjh/borqDC1e4YRwsvwwdjVjwTu8weHyOeKyOCo+V6X2O97x5sGnWk6rHSV9cVj1b44cCc4mnsEfUuA5zqX+Lje8wVmpsnyGHl9VXR39S/PkSPcZ2WjXLGcA/PBTmvtGQSnv4hk6A03wE37n9NF97VKyZZx7tIQ7fZKbRz96gpWjiL/woGBRC0f8Oyuivbvz14dR26Dizu3fOCTHzKLrO3fuHM973vPGCbNI3G+6EuJIW7fR82wdXUgmKnjOFtDbFnV+oJg80MGeLbOKvWJLyCqZ9BzZ1Re9xG63w28BxVazb93y5Vk76fSCwD9ZNkYp3+yNYwZsmf7oaraioun60D8ZBYfUekcSLODYlhrH3nwc4TA2257PYqGuP/ZLf/qgg9lci+gKPLM5Uzblyr4bN6T2s+8WZxaM9Ji+wTPt/E/6wvd0nXmaA73lffMzD/hr1994HXOgW+CSHuzGCrbd3ARvzQH96CI2Dtx0HT3dUQJj0OHZUfoVjPRqYkIHdxWpBTk/g43h71nsozmbYaEkiAwWtGZPzUWmBNx5jt2u+HxFPtHeghetPeN9czvnnJWFHmdP9ONZOhnM4GM/0V8w3jtoAmZ+DTrbcFHk1dw8A4YKbcJTtzqFC/rfd2DBm37zBfRjzmADQ4WKZUQIlOG/jjeQB7j/t/92f+BH/y2M8SNe1Dcc8tvwdvVO4Jos+bzj7xq48Z5x8mnB8tu/PdX66DgpPsSrnpdtwjZ98pObF7CQXfNGb8eU8Bh7RB7aBOu6X225mLuGztW6Ixto5sgdv4MP4Lgzf0Twrg0YmTp+24wzJjnxmSCh/9EO38BJtnl+jFzrFiB8CC70JDv6Nf+Ky+sPzciTwBZaCbLAnXkpemqeAhv8F32ZU1cH40v/ozUfEW3hcLpVce/iOzg2V7oCPGTT+N3Kh6+MbV50h/G6LbPjOvN5VSRfv+gYzc0DjPrpcgS649ZcRoDW5Lnrwflh1hYV0y+rz9hwRGfjOzJJHvBaWTV8uuXbDskNXJNJPERO575/fnkZdNPtQbOU38PUV/j6r//6xc96TZ+CIMvHgh71qEeNiy++eNzrXvca73//+8erXvWq8ba3vW08QhRxjPGCF7xgPPnJTx6/8Ru/schKOdK+wI1giLQSUA4CBVTGgcaxZ5wIKCVhMSlaTWgZ87mgE1qC4Zzvt37r2Mkg1I/3Knp1oMagz6+03ahxGihXSm2jG0QotO5YF0yoSNz8+Y5lfK6NsYMHfVbocr6ArTgrJWWsrn6lnIpIU8qMMcVYlX7PW4yR1127xlYKyG5Wx6OMyRmBc/27gcj37YBT7PqwEKXAcqo0abloyrGh+NASbBaznRGtgZdCpeAYb8qN8ve8eVLaDIQ+KMCuDNQYu40KpXYlIBi7PYgBkaIJP4yTIAKHh1Hv2j8G33jGx7s//MPT8/APX5ym5lB6rL7w8crK2AO/cITP6T1jMArwrKCpxihzEsDU7l045whzavHzLbV2VcDLGJtvZ0vnhVzNkRHyf6mgpVdW3OxgC8KaK+eDMevaP3P3N0OFzzgtZAPv4A8wkiUNnHMZ6UpNrUKla4Zy03JqLt63YMAnaMVpcBEJWfVO11Yvy2v1ezgeGX5/m1s7MnDYYoADAkd0CWcPj5EZfGIR0E0NVexH6/mxwo7lJavzcfs+GPCSAKCgCFnhdNsxiRfwoUCn8RvzmDUbS6eSPe9wiOk/f2u3VwHhL1I7JGf32Mc+drFrc9555+37+aqv+qpF+m3/q21ypK3fyJysBLpRNokgIL/NItXCQ/bHt3/79EMuyRc9zIaQZYFTC79uidEffWWBRpdUSJXMkCXynX0iU92sYkzPVrOJjNOR8zpJ+uXPGJe+YG8tHi3k6PUyC+gG41eoet58BxYLBbqPDbQIahOIzn7BCya9FDzsbNkC5mJs/oxFvYWN99kAnwlGC2SwWWwzO2AuMllsArRTnn6m++gZ9isfzXhly9CR1Zzq9rOu1zUXC3lw0FF0JN0OZnZXfwLZFrllwNWqCTcvyI92YMk26Yv9tKBqXn57hs2uCCd9zi8AczfQ4RMBFDyDfh3RYC+Naw5wAeaPf3zzvkCK79kY/kPBcnhQlgg+jU/n4ln+BruHjnDvPX6q/7vJhl32DrwKAv3ET0w4BSfatUsOf3jTuOyNgAi+xifw0SKZPeK3PfOZk83DL2hTjS/zxndgj9fhvyxtvJ3soAG/Db29b+76wuNwCd/4vwxu8MKTRTx+ga9uIQTzueduWfg+bBuayKoxDzgyL3gAC9gK5mnVx9HwIxzSA2VXtlGGnwQP4ANtyZggE34GO74QPCRz3QJYYdOCRP7uWIo5k6v5ZQBauLbxyRcnN2Vvwh29ROYqul4tJLxGjwikJffWQXQYvFvrwJn1LXrDmd/0AThtCE2f7dn3P/zRMV2FjOdtlpmzv+GebNELcFqhY/DOExe6qUiDA/iaX3iAxmiPfmT21t7c2HE8fqLArDnh8TJh4Mmc4IX8gYe/woeiA6wd4M743ew1b+SUT4T/fvqnP3t9xQen89pg7na0Q6kdCr7CNddcszi64+iN9pa3vGXxd8ES7eu+7usW2S9/d0tn+4+026ahOQGsGrdG8AtsoJXv/N/5N04/h4dyTFgpGQpTpJKgEaIKmmqeZWSXjxwst+Xd3+VjA9pccW4ULNGmK/0mI9quxXr1ICpkdmsboedwFGFdPlJEyVEuFMd8HAaH4mmhyxlQmdy7pedTIPomB9ddN3ZUWK42X+Qxmmp3UMIp1oqAwvs8LVpjrDlW1XUBH3xWPHfewGthCF59dBYcDfANgw92Dh1jC8/BNd9FWa+1eM8ppgc6WsEAFuku24XxAA+nsmvRljOcjA+usoa6JQeNPvWpsQcOGTqODCPFKHKM4Mn7NU4tJ2G+6+hdfM5JmBf8XK9xhhhCQRPywoHNidXmQQ747X/jzbN54KAiX3DEATI2ulnELwdT0LBsDEbLHF74wv2Fg9ER33Iauh5zfiQEDsA8bwU7Kkzmfxkmy5k27bb1Pj7pmlEO6IEMO9nx/lzeGW7OLTqZa8X/jMEB66xxjaOIjuG4avEVTMNbpX56hiM5x+987FJzNX2Yg7HBwpnENxxrz3a0oOBkzf/xD376B1Qq45DMMHnDPLXqSLvVjZ1SUJENwMv0KIedrv2BH5h0PZ1AXvgJAgCl+FdPTNCEnFrEWqxZkFWHyq5vdrjaIdWhqH4G3UaPdMTEWAI2Fmf8Fj4C/Un3yabTt8UgXUwPTEVYpx1/OpKd0bp5rlvu6O+Orlgos1EdASb3vgOHuTsiQQ9VT4NPJcuBH0Nnf/zj2xZ+ADtjYwPsdC+b1C4/PUcnpbssFNkFc9dnBVf9D7aukwUzOAo0se0VQbWjX+aGRoc5cgrXPjMGGvLrOg6hn3a49Te3375n931P71kkCiLRieZhsWgBVdF2vpZFqP67hc937Je5oz/aKeAJv/wIMBmTfmej0axras3ruus27atLgt5aR4KqRyGDR2AM3bxjzvpD845o0/lgNE8+K30eL5a5i2bGKShu/tWigks4kz0BNpuIfGV4cKuLIAn/qnlqbIrgkUW9MfAS/Bd4Bw/fxYKbTyYo6XPP5ieBF/353+arfzhic8mev/mD/BTvoFdFlfkC5ElA7vzzNy0yMqpfYz5d1Yy3+HPoLEhT8Vi8zp7hdbSGE3MBj/mTT8/Ci7ny9T0rWAAvXUqAL/AEGnRjH31CBjqOxxeuqC276/v1FtVlROErdCdv+jc2GMkMvVMBWfPArwICcGzDDaz4nlxXBBU+yIg50xfkVTBF/+hJxtHpfe/buoAX3Mag5/CgzUO6sY1Fc+HfGges6KQPfXdsK18BHfg7aKuvjjjPfWt9wH3lBm5NMy/6ch584tNUw8b4yXTFW8mkYCv+54NWkBq9q1vZLYXe9V7BPX4nWfZ8awKyAtfdxnjBBdv2bVgeCu329hVuuummRU0Tt/qpV6J98pOfHKcsVVvesmXLuNOd7rT47kDHi/zUrl1LDV9dXV38fD7N+3v37v28+/mSaJRKt0IQeotzAlBxsflZugyZRqkyxhR4Qm6xY9HAqHzwg5+NR4JO0VCslMlGV/gSzu5CrxmHYS7aSQlSRgeiUfxRQTmOT4Usl9/TZ4vqW9MYI4qv/sBOCRbYgEt9loIZ7hgNuGeQGDCGuiwNUfeepSh/5VfG6vOeN/bu2LEfl+hTZkmtecJN1+JVYNc4He+pUbIMhHlzfji1nJocSK1jEt5DM4ECesT1Yube9WbmkrPld+NU9KtMh+VGYedk0wn4Bww5AOS6a3EZ3oJMHGAKvrow6ZA5z4CvK2HX6L963XVjzxlnjL3veMdYZeztPshQ8kxB22Dv1gNGcv7Zi1400RltGbuNCrLCt+8Zvs6ukyMGDlzkwNHD5ffRq/P83abS7go8cTQ4P+1U2hUgu/ObKdAFT8ETx43h8oy0ebyDN9DR3MGED+Zz9J5x4jXw0hMc5LUCYavk75prxionz/f6NOccMAZTv91yIEvJs2BZ7zYq38kCE1yq2DQae5ZjZVHB8bJbg3f1Y1HCeB+oBkhHxsyv2444adVe6pz3XDbaMYLjeMv4dB5e8Tl48bVjij2TI766uj8wSmfNZb8bfr6A9uZQsF2HZMDkSPv8Gl1Lfth6vM8mW5TksFvkdASS7iOXFoT0lYUi/UDfsDF2djnt9DB50Ge1g9ga/QiuSGNnFwQ3BEuqs9bNKhx873mfXIPBwrs6BPwW+pBtNS5dzNaWdfojPzLBZJHAXrHNdA99ZoHiebqani3N3/vkmG4ytnf5M3Q9XWi+cLK/JtXqomgle2JxAG5zp2fALBBlF97itGxvPoOxXNdJr3gGzGS7YzU+N5a/+WF0DXzOi6V2bKcG1zJNzEE/xjFmWacd3wVbwaP5u+Zd5lC3DVarA+67jYSthnO6kR1AV74XPSpIYlFvDIF0sNOtjqN4Dx1s/qCj/83JIhYN7n//3YvnFHg3xzKIBOd9zybwJdgbOIZDPgXeoY878oWPusUI/I6xyBbCK+wPu8Xf6b0yoOCWbcBvAhJwqJ+KBOMBgTrPmJdgTBsLYMT3YBDsQNOygAU10MK4+mRDNb8F5DzbUStzIh/PfvYkf2WBoge/ie0mN+iPP8yjOm9oI7Pg3vfevcCRPuDCXPg1+B3c2WlzAw//QQAov1sAAZ90RNk8yDq+4jPBGf4EM5qjJ7wbs8CKIIhgCL7GewV1vIevjN+R3OrwLbduWkEPNOoYC7yQY/6PsfAmvuc/VMgY3cktfYPn8Jpgj/+7+hjN+T5gh5OKVuMp2SfXXrt38Sy5VyMUnQp+mec8Uwtu0B4NyAT+NH/6Bf+UWV8dPuMZm28Krm4k63ga2QLXgQIm+ZEdCZ//4Jn559U4wsPVm0E/9EUXMJonHOAzz5K/srrxiZ9kA/wFzOF9Lct78QNmwdRuK7vznQ+9Izm3V1MA9p//83++cAxdb/z5tuc///njl37plz7r88svv3wRmPl8nU2ZMGCV6XI4t83nnz82nXTS2HTRRWPXySePTWecMY7+8z8fN6LVZZeNTVdfvahT4Pfuor61E04Y2/7mb8bOtRSzbe9//9j5iEeMrW9609j9gAeMPZdd9ll4XDn11LFy2WVjxXuU0jr4lYG09QMfGDtnAZVt73zn2HXWWWPvne88tr3+9WPzFVeMGyn9AxSIXbn88iEWCw5ty0c/Orbs3j1umt/e0Zh7947NF1wwdh+ouOZ6+PvkJ8eeeRHKPXvGMa961bhJzZFTThnbzz137GDo53BSSmsLrK2XXjpW3/jGsU2B3JNOGquPe9zYaXdsDY5NN944tp9xxrjhpptuhstN1147Nu/cOXZfdtniho09nMI1xbzlmGPG3ne9a+y9053G5osuGqt3veuibodsgD0W0Uu76Vsoss2bx5673nUc9clPjhvXYDXG0S996dh0/fXjhoc9bKxccsnYes01Y+cznzm2/cmfLGDb/YlPjJVPf3rsevzjFzRZvfHGsYeRufbaCf979oxNF188dnNg1uDbpIBtaYm7do1NKytj7/3uN7ai8Y4dY/PWrWPzX/3Vgoe2fupTY7PPzz57Qfu9DMlJJ43t558/brrnPcdeuLj00rHpox+djtrM6X/ssWPzq189Vs4/f+w97rixE9/t3DmuufTSsfXoo8emxz1uwVNos+Xd717w+a6dO8deR00YiM2bx5bTThu7wD2n31OessDl0S95ydh99dVj52Mes8DzntNOG3tPOGFsqWL+nj1jdceOsXXbtrEDnY46auzhiNx00+Kmnm3o8YpXLN5fblv37Bl73vGOsemKKxY8dONJJ43NH/nIYv57qutx3/uOzRdfPLZ94hNj1xvesJBPuN26ujp2fvKTY9vf/d3YdN/7jl2XXz42b9s2dh133Fh50IPG3qOOWhRjvuMf/uG4iUE379NO2ycn2vZdu8bOD31ocTOTYzfb3va2setrvmasrhV724IPrrxyrNIRL3vZ2LS6Onb8o380tn/602PH1VePLWu7viuf/OTYjG9PPHGhl7fc5S5j7zvfOfasHY/BU/gRr+3dtm3sfcITxlF/9Vdj5c/+bKFL9l555dh0ww1j14knjm0rK2Mn3V4AZO3s8lbfV7TtQG3XrrF9x46x6b3vneZNDrZuHVvf9a6x+/73X+i7BX9effXYvGfP2P3pT48t9N4nPjE2uSJ9586x69JLx5b3vW9Ba/piLx655z3Hzkc9amw599yx+aqrxk1r/Wy+8MKxere7jb0f+9jYcuGFi8Kum086aaz8n/8zds0yKr8Q9ua65TPmt0M7EjA5zJrFDL1T5gFH2SLITreFMJ1pgcyptxhgxyySuyWOvPpfgMJiixNtoSgYwum3MJN90cKxoyYWDHaCOdYd0bZgYGf0y37ZQXZMziJUijmY6AQLy47UWcjoj+6xsHIDiQWgxbedaYtG4zz/+dP3FpICHAI1gicKrVv82pE2noWvhbqFYberqV/BpnjHIrVbsm64YfMiE8FCq/onghy/9VsTnvgjAs3gEUBYuxlv8W4BVs85cgs2iyyL24rvWqDTjf63WESLcL6cgdsxQ7Skh+hT/4PJfCyGCpiwZb4Dm1ZQ3MLPHC1EzafgjQBZ9UTACh4LJkFwNIcfNLRI87xFKtjhCSwC2ubGT7FANHeLSvQW7MJ3V121c0HfgjHoTp+DwwaIsW384SN/40X48JnFNRoIsvtMsKoMAkEci1xBF/PFm10bjA/879nv/u6J9hpaV5S0LAxjoolNB9/hybIg1zYZFmOUgVBgAB7gRxmDrh52VLiC4RXfBSN+83zZC+3ksx/mJFgim6MaNgKP3msjDYz3uMeefZks7DV56XiOYJYgVRsBFufmIvjm9iOyYg7k33OyxfQjc0Vf1VxB3xbIgiYdW9fwNLjQY22TdYFfAS84I5cCHAVuKpq8XrNxZE7zq5vVPUJH85bZJbuILunqaX3ig67oZrfTHfhOEIYc6LvbBrsuGx74m2h34YVbF7IDNjoML6KbOcyDJeSZzuxCA3Lob3SDX/3CD55bq1s4nve8CcfdxtRGK97nS6JfBf6Xj0v1f/hf/inAQQ/0mQCxYAm+EtAg6/SzH7pAxqBGtsgoGacHljOH0RE/wAO9JOhbkeqavs1LP/jyrLOOBEzmwZKPfvSj46//+q/3ZZdod73rXcdlS4teN/e4Ocd3G7VnP/vZ48ccQZhlmJx66qnj5JNPvln/n0vjwFq06+uwDpgwBJiVgqoqufbDPzyOy8hWDJRAFvWcN59RnHZ+K5REyZ555vp4ZOQpe9F3Smm9iLH3K7yUgFESHZdYu2v+DreUDUIYGcKUvvTDU08dx1PQ62UFEOD17pY/UDOH3qHkGKoHPWgcR2GA3fzWuwasRukxrJ21ppirhK1xBh//+HHcHe+4WLSdfMopEy67Vs9zXQNX2qe5oYnnqjFSXZHoE7xkr6MPHKx733vcwTOiwxyMtavUjmX4POO2GzSv5gQjwPC0G49m+tc3fFLAncGFB0aN4uVYLeO640DG7to3zhOjWm2V4H70o8dxBarME5+2a1hb48PFHDgBp5wyVh/ykLHlf/7PccIxx4xNcM4J4twYx7icHnhghMyLwWyBvtw4PAxHV8syZgwg48+IMBQMBh6AL3NrRwCsdif8HazzZidKRJ+T8ZCHjOPA09zNB8zgssvEkZcG6n+7HhwC9Efz4JPqKKBArvGHPk4/fSykQF9zOdHAbD7kFb3siM5rD91441jdvn1c9bCHjeO/7MvGij44uxyH6C4lOkfyAQ8Yx1eEGcyNha/K3PA9+N3w9LGPjWPxfru4paXOYexIGhrPcehZ/XTevMYh4wRt3jyOhx8OZzjlAHUkimMIb+jY8UF86zNOG6eBXJFdCzw7x2URnXjiOB4cO9eKU+IHeOTo2u2iw7p14wtob446BM4DH8aW8x9mw798supX0Y10ILvKOWYPBCXoZbqOXJMLiwyLMc+QZTLLztEx9KRGx9Bf/JGyNtLBHYFgxzrSq99uxyuLkNx39NTYbgcDG/1DD5NB73XjhB96z/ee05JNtsFc2Ld0owWexUvX9xrbpo2FKdtEt3iWLgGPRZHn2eU73Wl14WNZlNMJHW38hV+YbIOAQin99CjbZzEHPxbrLVbgTSCjjBs6jb0yvosX9FkhcW1WWHrRwC7AAD9sRj5PxR/psOpIdBxlWhTu76NrWrtu3rtoU5FI37PD3Z7kO3zDH4N/MKMzOKuBVf0XuLQIQ0t0pnPhwaJVg99jjtm0+F8ffFj2hK5HL5kVYJAtguf4VvgH79LVcO3/giMW5PAOT+yLgAu/rdsI4dwiWxDD8xUBZQv9jbbmZ078aP0ICDoCZCw85vmurW2jriKixvTbnNll9ll/YGIT4UNGhmATftcfP4XtKQO0I7LeRxO0Y+/NQz9lLfFN2T38h+5nn71n4TsIHMKjcdltAZeyIqsx4X3PdLSEnJkD3sHX3jN/dG7tYP5sOLraNOwoD3r6DcfgJtOyaPAYPIANztnP+MLYaxtx67ayYMAMP2Cio9CjAC/fQzYonqXDPAOvZJ0/VtCSXuuolM+MC14yR1eUdYM3fX/WWTsXv8kJOfWd/srCoFPwmzmZS8Wu6Qd8gzfhlZ5U9BY+yrTTT0GRrjjnk8ExWUAH9CRv/odjv/vxP73ne3qpG7DKJjK3rjKGbz98eZ/zW8grX8q8W19o9BD90KUeNTjg0+mbTMrI4/OYQ7UpNf+TT+NZZ5jP/Ij6P/RgyYUXXjhe97rXjTsvnbd/9KMfPa6++upxLqW31gRVOJFfsezwztr27dsXgZH5j8bhvC1+OLC3VV+H5M+uXWPlla8cK49//FjZsmWsbN26/7s73GH6vWPHWDnmmLFy/PFj5eijP7sPODrqqLHy3veOFde1nnjiWHnPe8bKV3zFxng0lnfucY9FBsJiDJ9fddVYueiisWKX9a1vHSs33TRWzjln+u7GG/fD5Gf79rHyVV91y3O85pqxcqc77f/7LW8ZK6ur09/rPQ8uYx0sDsG6bdt+fL7+9WPlAQ8YKw9+8Fg5/fSx8nd/N1bOOuvAfYBP5oOxzzxzrNzlLmPlyiun7/CzDA6ZAW9+89h64YX737v++oku4L3rXaf/r7turNxww0SHd71r+v9+9xsrsoT0BW/N3Xsf+MD0t+wTY5qL5z/4wbHymc+MlQ9/eILrtNPGyrd8y0TX+ADccPmmN000fPvbF5kmK3e+8/S9OaExvgLfa187Vt7xjmnMhz50gm2OB/SOxngErPD5uteNlXvda5rfBRcsMg8W4xj/f/2vsfLyl09j3/3u07vnnz/RpX7Nya7+zp3T/3hu9+6xyfOySu5737HyuMeNlfvff8InOhoH/R71qLGyVk9p3Z+73W2an36+8isnvP+3/zbhHu/CzVd/9YQT+DU/fA6W979/rNznPmPl4Q8fK+ed99l9owkcyuyBd3wAZ2jyhjeMlXPPnWiKTvo3R2P/j/8xVk44YaITupgPHJBj/ZJVNPDeYx4z8cE//aeT7M3HN94ll0zj44E9e27+vbled91YPeOMiQ/MT+AEDtEGrxr30ksnPJk7HQHOeNB7PsPf97znxHePfvRES3N+2tPGynd8x1h54hPHyjvfOVbufe+bwwAH8Kl/dJ3DfvHFE0/N9R1+IguepWNkQfkOD8AlHvUu+piH78jjFVdMcMKDH7RJBgUw9f2IR0zvbt48Vt72tmn++kUDP/42N7y1e/fNefQLZG9u73b7Q3Ck3aatI4gWG4LBnHULEc6/35zgijlyoi14LTIsIBxj5HhzjC3IOP4V4ezIA+fb4sLCgBNtMWPR2u0kFhbGsvDjaOvb9wLyFt/es3CzuLCA6VpWwZCO+AjqWwS3KWNBqUAt+AQSqo0hgGEx728LG3Pi0Ftw+Nw84UCA2NgWExZHPrPQsJgyJzBPR4L2LhYQdrD5qhXCJ6cCxBbf4LGwtLDSlwWf7EOLVviqgHo3hfjbAs8cLWzgs40g/Rdomjdz8R08wJexpqtRb34cumwbY1h4WwQVPK6GiYUonBhH9ot+qo1QXQXwWfwJ0KC/hbwFY8eFOh5ljmjbDX4WVgUSLJrnBbuvumplgXPv4pOOtgi4WXQKMMGzjZZuFMF38FxWjfG8By7zLRsDL+EJMPoeDeDW4k5gQb/6h2efmR96Cnx0GyG+qz6GvvvfAtx48GLx2lFSNCgQQ6YEMWQjlZVb3Z02ytDDkZdo25EYczMeOnkO/vAj/NocQOP5zYd3u9u0eoVrC2u1iQR2CrJV46umzwq2Wix7x+I+nl5uHVUyJpgrakwe8IIgAt4hl/Bo3I4/k1kL9wIl+Ml4y0Xm57AZB691XKUadx2fw0OeEzjBY7Ji4FAQqeL++AncPif7aI8+5k2vwDUag6di8fe6154Fz5iXPoxJBsgyXBmzIGyBDHOrEL2AB3mSWQZf5t6xturZ0F/4AK3goAsCwEqeyQ5aVLfPfAREwTVvBSwO1NCJPKCDCxjorYLdk/xN39ERy7Um0RId5kfwC26GOzijIwWTBSi7YfAfQvvMZz6zKBRbsdiLLrpo8bdbcARLvvVbv3W8/e1vHy996UvHnj0ywD65+HE7j/bABz5wPOlJTxpPf/rTx1vf+tZxzjnnjB/8wR8cT33qU4/ckPOFbBQe56IK9uvVE6EoNqozonVVK2UvAk9p29m4pUhhZ6A92+48g9D1qwyKnRvKi6LjdNza2iJa17dRWHYXnC+kbDY6xsPp6WaU0oE1SnBejHK9616lnsKnuVEklKmI+3Imy3JtAdH0dsVyQOHdmCLg4KGUHvOYxdGYfY1xNUZXJFcgjXMgJZaCojA5Rp5FJ9Hs6lFQrpQahUuZt8BitChs6ZAMlOjzcoVrClyUnmK0QwNuSpsCjF8o6jJrui7PPLr9p8J+FKizqYxcFf/nuOI4mB/+6OwtQ4t/4RqOKXL4NwdnQefFWL3jfY6Hvz/4wXGTtFE7RFJ858epNH2aX+e+D1Sk1PzIAPzkXOPpDAwD2a0y7S6YJxxUqKyrrpcLIZMl82Iw4ZfjXHG9KtlXFKx3Zf9wCjmZDJKx8MFyLSCOG7jtUNkBQDd8kVyUkm2Mrg5fvvIXXxbk9h2Hgh5APw4AR7ACZz4vRT8c2/nDY+boe/xITqtPoJXGi8ftks11UYafg0AO5oVfzbtUYQ1s8AF3HDaOSbfemB+Z6WpF/JiuwX/oZk7dZtCNGVpn42UCoQlHF+7wzkMeMs2lawU19J+n/x7m7ZAOmHBONmpXrJ07O9Ju3vA2nUeOOmdf/RIL1bIqK6rIjnb1ezUFyD59bJFVjQuZIIIg9EC7/2qL6Jd8WiyQGTalWmN0dwspuoPMISl97n92l1616PU+/4Suq4YF3dfNKvS3Psm/xRMYwQI+/XhHX54xDj2QnHvWeBam5i7bjC0Aa3Uv2Ncrr1xZvGNu1fmqdUwC7PQavQeXdGOZgnOW7LpRzSKXvaJPFU7Vl59s3nyBpA8wWTAKyNCB8Dq/Pa8AmIZuXTdsYdf1v/QtHNKDPu9WRXAb2wKJjuXLtRB97nP3F4EEu+CU65rBU+2GFoItstGG3hVkmev+q67atOAniy3ZHJ5nj2RiWKSyr45NsZ3xH1vcNcHGxBfGU4uNX4hf2Qn9ojUc0dX4kI7Hd8bp2lWwwQ2bBo9sHv8rHKJ1Vw53FMUaSWDHfPBcwQjPmbd38DSfww86ww0eqxYPu5EPV4ZNtw16B9+Bie9o7uA2Pn/EuHDkGcGkv/zLoxY1YsggXi4rtrp03Zaj8Qnhjb9nfPLHf4RTY2xUBkGf3XzUFdx8TDDjBX2RBT4JvJkP/wXu0QQveQeMeAHPedbvfsiKWhjoAWb/8zdk6IC/gvpwyUeCT7Dz0wTB8CN7LYhhLOMLGOAB/fCD0bcLI7pRRvPZK1959EJmytDgD/E3yJ/58yeWa6ylu7SuKxY0Ao/P3TpEF3a8JpqXmWI+ZFEji+htLYEnNPMmp3jaekAToKOnaxvRzDhkWfAKDuawG5seIU94Ohg09O0o0fzzrpHvWJX3o4n5odP8koPD2VcQDHnYwx62+NEck/H3L/7iL45PfOIT4+Uvf/n4+Mc/Pr7sy75s3O1ud9v38+ZSIIejZi8dZ5555njCE56wuE74MY95zPgP7uw+0m6bRtiWaV6xJQ2zLhf30ghnynO9lsEsE4igbXR8Yd4oEE4GR6JjHRQdJ4URBBeF4siCc4echlsbMCG4HeEo6smAMhyOBIF9OXhB2XGkKBjw2VHTCDmnZH6lXgqHAfU9PDF683vql88OM4DOVdYYBEU4wdJVo97xLsPK0DDsYFbfoVTlxvZDIRrXdxaJcFiVb4ae8kZ7Z6MzfpzHajigfdXBKTz06PpW+OJUUH7tlsGNd4xpfI4R5deulOYd+Mhho8j1ZY76mF/ZylB41u92yqYz39P/FDfamw/awI95wnnp3PpGX0aVQaTUu6INvjiiXVM8T1tdbxeegRacOJhIvHlbBDC+4BYwq6I/OJMdY1cwDm/DAYeAAwCHZKidgYxou7X65YihM4OPJ8yJs+H6d3NSEwotwYL+cAFHaMngwbf5eKfr7iqgnEHGY4JQFdgzDrxzxPWBFtXFAL/5gA1v4bOumsP7nY3lhHE20KedWTyGBniB81eBOQ7v/DYi/XLq9G2cZVrBE/2RLonX+qGH8DsdxlGQistR6zo98/O9YAc60DHoKZBWoI/8owscGwf/+R//owf4FO1F9wK7+kC3666bxiVHcx1aUT8y/7ncyvUl1A7pgIkdGUVjltunPvWp8bW2B4+0m7WuvkzOLJLwONtN99Al9A49wMb53U5kGR4WamSo2yDYnAoo05v0B/mju71ToUL906cWROwiv6CNCrqkYAo9KyChkUfyKTCT7SHHdBl9UqFnsixYox+LY34RvSW7xfP0KJ3N7rGh9BV7RgfTIeRZMJ/+osvpNItScwFPV5tec82mRV8WGsubUGApIwXc9DT9x07BhfnBgzGXWRY94EMWA5sGvo6GWqjMd5i7Urbr1LvWdn58z/f0kvHbcJp20aejQr6zgIK7rjv2HPpYrNGx1TJp0YXmfBI2oMwEgSXPswcVZe8aU/AbH17gfPm46mc+s7JPj8ML/KTT2a5uJmHTLCThp80Yn0/HUSZ60et8GPjCJ+wyXuEjmgf7g2aCeuywdwve8834vt4p8NatO2yHz6rHU0HgaonY+MFnv/M7+3fjC5jAhSAHP60bcWwcoTWb7jk8CzfdKOg7+MMvHXnFl8Y2B3KK18kXGgkIPPnJOxb043/ky3SVsXH9oIFNKDDDaxtEGvsJFnYOzGxoQQw+mMU5fwN92Ebj40fH4+gKAYpuawQjvuioid+CMoJReAlcfvsfLufHTvii+sPXnsFDnivrxTMdO0FzNtmz+BN9svfGp4s6rlf9DzwG7+aLbmQN35q3wsOPetTOxTw73kYe6MaCBmRl2X+pdgi8lnXkM3DJeOPHdXzM3OGS7OB7tZE6AkRfoYm5wWEbRx2zZ8rQCy+ZOz1XcWByNt8IJof68IPXyQy+ITf8Hu/jMzju5ibzbk1SgM778w0hz6K98fhb7EMXi+AN8oTXzj136arCw9BX8Ly+ln/+6I/+aNznPvdZ9zs/83HciPOyl71sUahO8buXvOQl47h5BP4fYksR3hZNIan5Fc0EJoOjUQbLO+2EnqOyUWp3t3Z0Xtmza0GzW2w5WJ0FpdgZH4JH2LozndIQ+bUrPA8+tHg/UOvWFX3JPuDEaGCkcAl/kdd5o6Q4SHaMCzAwCpT68pWg7SpZsM1TyvDuPFOi5n2Kzm/Kz5ljfTDWBbQYWcrN2Iz9bN6KyC4UVI2ihCeGkkKjsNEtY2AxR1HJOoBbz1BMKUxj2+Wh3PTNkFmEdxMBo8zhNCYHkhLmlKAdHBZ5Zmi66lEzZoEzMFH4GQjKk1Gv8BhYzF9ApKuiM04b1ZNhzATW5o2zo84Jw6nvMiLM1/+UPxk40G0qWtczcvDWyyqat6ric5jsvMALgwSv7abE7+iONubHCJmz5z1TQS184fpf45bBw1Eq9Zqz73OGEHw5Yfqq+j3+NT6D552uwkX7gpT6LCjY2XSwcP7ISud20ZQT1W4SI4d2fsPjGWeMbdKTwYdP5nSPltExWnre55y6aI0n8FaOi7kIJOIbzqw5LQfy9ctR4mjoA78an0OazmLcBZPwp+wPMNbKBKN3OMQcuXmNJjjAu4Jnrjrl3KEPHMMbZ5XT2flmvIyWnDMO43vesz+Db7mhN/1Sdt1h2g7pgIkU2H8t33jWpL5yTOzeHGk3b2SLbmSb6BLyQUbJCFmiC93ywjaTSzqMnJAHsmphRAfQJRZW9DH9UoCejvIuJ7rjDR1rsAjuNh0LB4sx+pWPRKfrv+M0HHLvWQjr2/gC6WSfXqCLwfac50zz4L8IztCpftg67wue8BnoUrrHc20e0BPk3eLA8/yDdsLBkL43vjnR0aeeuntfIVM6pKMF3gEPvwd+BSXomW60Y9f0Zb7mv3TD1qLBHdundRVu2aTZMPa+ozx0Dzi7KWbu4/GZzEXAwELZor4MT89VR656EnBXjSYw4AN05bvAFT3YbnI35fiMzwFPbIDPjAE/+kIHWaDGgOvlK+6rXYW/+Lb6q3YFuyYwpZlHwbUyjf02hkWvuTzrWTcPwGvGZj8tTMHF7nqW3Ss4hBb0e1lMbAB6o0/HvtCWfwvesp7wFN7UJxhkwggeaXzGNnbgGm7YZPjkB7cJI5uiWmXst3HxKRpp6mCAD23QkR+NLuSgmxTx1Q03bFrgfroad+IZuCHX/Eq+hj7bPEMv/YC/Gj5qtXSVNNyime/gXKYG/IOfj4JP8Zc5GEt/Xa1sPvo1/46rdeui78uSrRjxvK3VedtHgzKWwI/P51nCZWTzDcp2gle47CjYPKDZcSf+QRti+WGCJxP8KwtfC7+YHxj1c0tZE/jNM+g93yyqXg/akhPwogtfyA9dhl/htMz0burkO6WvBTTxfNc2o4fgJfmHQ/OEB7xZphHdY41kDuoreU//cFrmTq1Mm5IfjB088FoGC1gL4Oijq8/pxTadwXbmmUtp1odIO+IrHOKNgM5qunxODeN3r31nD2sVCjtQFsktHcehZFsMUEjOSN6au8C7bpCRY6A0Sohy91MKV1HRdvwZ6QqVljq6XiO4DJbnOV1lf1DynCiKkLJYL/BCcXedVueHKQqGYJ55wNFLMc7nTgGsl+5G6dpp+y//ZXqXojdWWQeML4c04wQfOQMCJuZg7hQeJwJsaMBIcVopXcpJ8AFMjIjvOFsWhRwSDiYl6Ko1ZzgZe47Rr//6VPndc+DvDKxIPQeEAmVULEgrEJUhKgtkAeTarmBHkdCpc7Mapdl5Rr/nZ1/bmcJ7GYrPpXE04A9/cHDQuTTZgzkryUkgHxVkPVAzD/iay1BX5LUgNh/47Do4c2aA8BRjVQaPABX8/+EfTrsXDJe54Ae/4Zuh44TgafOSks25Y0gZQ/0wSngVbTvSlfPjGXC4YcxO2jzLAb4FfyruRf6MxaHAW/rAexwHNP+Kr1jcjLQwyPDruYIO5A6P54SCVR/ehR+/zQGNKoSI18ODoE5Xc4OHwzBv+gdPxaC7qQLfwCuckEFObkUe544WfiaPOSUcjnZj/S8jxTNwjj70HZkCr9RmAbt2BrsaFJ7xeo7uURsUXjUvfbZ7eAhcAfwPLmDyP//n/1ykuVY5/pJLLhmPe9zjxkMe8pDxX6U1Hmn7Gl0mmM6HsLChXwTQK0pNp1RcldOcnaJrBR78T540z5MLska/+O7Xfm1aGNF93jEOOaowJvmgs+hyesYimc2yMAQHGwgmtkP/dD874wgOePTBDtJFdHIFCcl2aeJ8DvoCDOymjIKyxtoJ1z/W0Le50oWKi+oHjnzWLRX0TQW+jX3ve+9Z/K0/QdgKodNTghJtDmVLLcrYCnPRD3tgQVNwgq9QFuW80cFg6Wr6Kbtlf7Yb/Pm/gD1fyPMd64Rz9snncAtXxtePOGIbNgW3qg0hCMYGgskOst9oKFOcL0sngx1MFYJlYy1awQo2NpL98WzXvKM7mgYfnXnUUdNuL9spU8SRGrZFIEGggh4uEzYfFV7xTxkabGGBPq1Ctxpa6w8tja1PeJhf0Qwf+N4YaN1mjGfXbvJb+Gj6r/gt3w9/oePazYSLcf3N9hmLb+77itEbpyOxZEMhdQtq8ua7rrdvTuwmXIIHHdklfIXe8O27rvtWe8PnFY1l6/nMXdFL1tG8mkVtqnoX/dDJu+w43sdP7CN77L2Ojc0bPKBr2eWeRUOBpfmGJByW0U0+W6j7vCLPmrl3FM/z+BCPGCddtDy+z/AdHxX99M+ek6uuva3hCXyGhvDfhppbX9j5CZ5Ni/mimzmRCzQiA2Ah88ubrRr5IP9kfz4mmee/+U4Gi/EEjPkq+Xw+o5ON2bF6sPnenMwdvB1Ph2PPmTu4ZA5bG5Z9S+7ID/0Bv/BED9HxGr1hHvNgLXrj345Wyv7zG307clTmDX1L/uEJrQqAz2/zO/bYz87iOBTaEV/hEG8UYVW1P5fmPYsQCo/SskPaPfAaZdhO8EbHcUoP3KiVpl67tRlBHeMwzyqDM0ZltTC+FFk3nHB0GHCGgLGwiGyBQymFK8aHgaa4CX01M+bNAowy4ghxtCjZbjQpvYyy8TcD1mKY0mjR1e4NheM3JQFnKSiKgLJBBwtAwQELZ4bBDtlLXjKlosEhRQQOnzPwxtE/A0gJoqNWtfAi0hwd/RqzjBb0pIhzBAVP7FqhMaPQOV3vW2CWlfHv//3keDDoFt8d1akSOoNN6YEXrBsdWVkOwFG+DFMLc32hJ6XJABRNh69qv+RgHChgd6CGjzhYOXccW/jgsNxSfZ2OMFkM+71cW2TefIeXGMMKrDGgeI6zhO+61q/zwPi3I2wMDrnkbFQHKHyBA+4ZG/gAC73g+ks8xKEmN2gBhxb33UyhX/Q1bruk+ESfFc9j7Bm4zl3X4Bz8eAffdY1c6aPRyTzvd7/FFcX7nFJ943m1czzXDnPN32SKUc1RrEaOoKn/wdN1mOG+mzkKLJR9Rf7JANqCmxFm+Du6RZ5KswYLnp4b6HYlPWee+ARPkkc4JXtwSN9YKOEruKzIX7eCFZADD76uIONGrVsm4E2mUOeOD7N2SAdMXEn0mte8ZvzFX/zFImgis8RZ4j/5kz85JCrmHkqNPZXZQXbILplgc2yS4F0/9DqdA3V0XwuxWkFdcs1+kWf6hU6mD9ki8tAGQdlx9CdZLsBC31jYyM60o0vWwOHziorSH3Qm22wXs6zCfKBuj6PP6ISO01ZDKd+pQorqCeifjmbj9W2udFkZB2w1myGYAx90SZkBdIr3q1cGB/SEd9go/dIJ9Lr+6S9w0Htgt1hsZ5be0+ADbMtFF30v2ENXoZXv6WTBpXax6TA63iIKTvQvsDG/waIrnOlGfkeZsGxIm3H0qnf4T+lRizBwm7/nPVNAij4Hl/n//M9Pn+OlgtvgmV/DymexyNKXfgUL0OXEE1cXn7Gl+KgaIPky7Bpb43t9GFf/HTmwQ29Hu8ATHFS0lo01f/3Q+56Dwxa85mueZceCT9YkHxv/4ivj+16fZTSRDzC1wWCxCA9tcBgDf+MLPoVFrfnMbzvBH4JtsiV9h9/Mv+O4njFX88OjNkRsTMApnqxWWL76hz60eWFL/92/m+YCFjYN/3kfv5k/W5js6Mf/eD7cmjP/rlof691AqZFr/ZRxpHUMXC06PkE8SF7gsf/nfJGPqIG/DTnvF7TVyF5FRitujC7w3LFx+kHWW606ITX0iI+6RXS53fWuexb4R0PjmxvZ79ac6gMt14FD/2oxLTfwwb2+6Ejw4x0ZwHQxP90Y/BZrFPMkA/SFMbuCWt/LhV/VDCFr9IRn4ME4HX00Nr/KeqCNKd+hcRtiaIlH0dpndHEbrexF16KTO/hGI3KA9mQuXZjvgw8uuujQtLtHfIVDvBF4jLXeDsLBNAJEcVFs0sY6e4yZKQwMjplz1ucZAJrnqkOwUSOQ8/SsW9ssRuygcxpkLXS8p9bCumrVZchMqYT7i4V5T0CCo0XZEUTzo+S8207HvDEYlBllWSr/858/KQEKT/8UTU5Y6YBVo9YoEd9RTgwMgy5zhMNEeTKCjBtlx0D6Hyyl2jIulF3HCTgd5tI1tpQMw+d/YxQQEc3vTKRoraMgFBGnw/sVVYInRj7FTXFRjuhqXvO6GpQbpY7nuhaua+D0C9eMc8Xk/L3RcYIi+PMUU/zIIeZcgtv45jQvSNpuEJqhXzsAn0vjlHF6GAFjoaexNzJ4NTzGYSqgoZ8DHY3r6Eo7nAwTXAY7vlNsmAHhBPke/4ALTO2KMhwMMuPZURa8oW8/3VfvvQIQ5FefZMa7FYMzNlziyRwpfMBZ4rzCO+PGyfNeV0LW2tElk/ijwqnz7ysSePTRYzcYcmbwiwANHuVI0jXzRRNaezdexEfmI/jTVYXkB8/AGfnMUfU8Z08j7xZUFmDok7OG1ztNIbDXDpnd6K4oho8CLxyFgn/mAA/4D07RhcPVFZ9wr7/lazoriIhGxqRTS43eqLXjDRYwzPF/GLVD0/uZtVNPPXW89rWvXRRRe9SjHrUIlmyee+ZH2r6r59sxpNfIPp2Oz+kPxZvZXzJZNhvdXkCCfaKL8LrFJpkpsEvmu661lPpqFpTJyDaSFboTPGSxQK4+fUYH0ye+Yz/pJTDaZKFv6BHwWiiAr6Os+VrmmC70XNewsxv0DT1Rir9nyzTjE/isjNc2f+g5O/YWPfp95zu3LuZT0VHwVAATLuj9bufo2tcWUvkvZdiYLxzZnQe/eeqz22hsBIUDOjIdS3/Cr+fQoyzSanugFZsGJnRiL3wHH96pID3fysINPMbv1hB4UoTVWHDBT6FD+UB8IWNVY6taYvwM+KT34wX0otPB7T2BgvSkMaoP0TEvvgV7CDZ2p9pVeMY77J1AEhh95j3PdPSXX4YWHRXHc/iJ/bfJ5HdXs4LRsx2V8eNZ8ykjGl7KuIBz+PCe+VYbw7wFfczFHNgWv/Mj8On8KAmakw/jdisTO4vvHOPtxiYBkm6kEfjrKGubMvkUbNrll29eZCvAS9kqBRfZav5Ix0uqn5OfTv7MCe07xrVe4H8e9BCAwjfd1GR+ZYL7gd+CCujk+eWshmBr47KNXfPTF7oLvqBJtWTQH9zV1iB7+Ew/cFYQAJzkt6wKLX8UH27Uzj57974aQh2771YtvNtmFvwt10HcKIsaL3a0zPhdzICX+PZ4B83RBc7QuSw5Jgwe/Obj4af5Bmc3KpFD/EKPCZDQVfwkAWIyAG7rC4FKvISnBKH1xzczpzaWbFbR/3iC7qEj8INnPE+P8EmNQxbRinywDXBCTt73vkOzhol2xFc4hBtBx8wb3Tl+S43R6KhGQQ/GjvKI0TGxxQ2DsBwYuaXjOITx8wmW1MBB0VQRfG4gWiwTeEJMYRA6xo1w2o0nrBb0cAUmgsiQMHCepRQ2ugHI3D2nfw4GZUF5Elw4qrYCGgQLJVaRMgaaQmE4KKaOF3i+4nXVJQFH99fLLJEloKI948hQcAb8cEwoEnNgFBljThFl+LrXjU3VSsjBMXZjUvQWwxSQ7zlc7c4xfF0jyMGRjucdTsDv/d7k1GjGaSeBswKvXbtW7ZFSpbs5ZLl1e0/9pdSruK+ZH1xXHRtcFHoBM7/L9Om6yVvTqo2BP3Iw8Zc+g2m5Gaer7OLDbkDYqFXs1ziUPzpzvo3HEDK8jIY+8ATHDs7UjelsdzhmANFDSi0aMmR+GwP+pU12fpyBIRMylNClauXV9YBTvM14CRj0PAOsLw454+p7dJG+DD9V3rfo55CQkXaeCtD438/arsne6pQs4xLPGYN8zgMCZWm1A6nPjiSRM/V2yDqnALzt+Pmfw+M5C4SODXFkOGXLjX6gJ9QZgVNOAfrrOycS3TiI5IyTILjcTRBoAbf42fecMHOJBjWwwSN+ph8EbnLON2pwXS0g9Lr66rEp2TiM2iEXMDnxxBMXBdPmP1/5lV+5KJz2V3/1V+POd77zvs+PtP03knB+OdD0GhuGt9kd+pIfQNfSdWWmkR06hD2iU8gHuSM/Ahj0ZAFy9pS8kTHBSTv11ctgwyws/ZAP9raioHQzmyFAQCcITtBR6qhUYDr7a5FJJtkvY7IvdIl50J1sNZ0AblmmxpCdIWBAx7aba54+p0/bMfUs+0l32TSh0+gNesu8yDdYNm/eu8AD2+P//Dt9WEAWmIZDn9GpFr4Ww3S5z+lpeo/O7agNnLItjj7BC3tUgKWMTfODA+OxQYIo5g13+gG7xYy+6P+KmBun3WEwsFsWsvBOL5ov28WHsuvNp1TEVDAe/OiCL/g58ELn8SvwhEVYWZDGhwP4Mg/6HX+1cYUX4IcOpmPPOWf72tGcKRjOh6z2R74W/mDbLPDwb3Xb4MCzeAx/mY/feKPCoNXOkLkEtq5ARssWfGxbvGUsfCWjw/vmC5fGgk+8hSfzuQQNylSsADJfwAYiOWlTq0WxZm78d/YT/lrk8zvBjwZwhUfwheCDd/Vfhg164uMylu59792LcToiQ167GlfDfx0x08y9mnrdGmQseEPX5WOzZFyfBUHgnE02RnXeBFu76cbc8AM5Nj88Z8zljeMCmWX1+l8No46c+elYGfqaA3y0ccVmw3eXJNToGPTRX7XdwAjeW4qj61Mwg19XTchqJtXWq78yb3QjHmmjcb4eomPKzDVP8Hm2Yy1wnc9Ct5F5OO2IHb1Y0IQsVCNHw9d0E18ofUcHOKKDn8gBGuFHPpQM4o7Z+YE3PNz11GChW/ArHYFW8A/n+ueTganja3iEHrr73Q+ds8lHfIUvkZYC6M7qW9u6TorBme+oUz6cAcqLQFK6GymBioNt1Bi2g7kN52Abg7zeAoMCIMiULOXNgWF8CKR5UgwUZYXCKH19maP5UqiljS03/TFi/XS2lKE0fws0GR7wOD/uY/wWVfXTbgMlB+cWVZTdPP2fsdYXuCkMY1qktavNGShVtkJojDAlrJ+9e8c2yosDQvlEW0rMgpDR5PToA3yUICekc4uUGQXmf04Q5wUPtDjs/noKeH7dGV6hrM0bfn3flcQMYOl+FTbTR0bBOxwbyrtjFVqpf5yojmbM6yxWLLX6MOBeTiu8pYb+7RqWUbSWgbGyntFqzsvnaM157cr0z2rtruQ0JhPmhw85Vq6JU3y3HZ7OwpeBUnqqRX9n2jmAAnjoyOgxQmjUrioYwdX5drgkC+aFjsFRYKuaIXbnuuaX0TQePjQG+Bh7iyC4gDOGjhPG6fMMOnqXnKyl9e4xFuPYkaECaeDVd/zYkSzfkzWyrG8wek6fcINujDDcw2uZOfpBP/w3D4CSgwKpNfJCBwh+lYmV80cWCvDQs/i4AGs7jHQfuNAELtCI7H7/9+8/8x7924EqldmYHN9Xv/rmvAL2iln7aSdvbedxZX4t8mHSbuHw2xe//XvnDo+0W9U+9rHNC/nvenb8T84F/P/zf55kvyxNC0FyQHcpqupzAU06glxZvLKrGvnMBrIv1b2qqLIx6IiKWHPYBUU6hmFcsknvGBc8HHn2jJ6zaKEn/C0Qw552hWnXtnrWIpdctoOuT7rSQk2dL3opP8LzdIldeQ2sFpvmx19TbwB8YNZvCxdj/f3fb1nYNZsEYCH/FZGmw8zZe9V2ow/g3bjdpEa/0xfmW0aI4Af99YIXTHqSPajguGcqUgsGeC5LIL3s+wLJ+Qf6hT/BFTgECzq+6EXTAqpjJObhFpxuXGML6Xbz9reUf4shNo0N6spcz5g7+md34QtPsAFgT68by5zZUnqZb3XeeSv7gubZLbQt2wYsZcCalzmYe8e+wI6+5uVokOwWvkgLVY2OXr7EgO3jf4F9flSkYufwWD0NdOW3oisc4AP9F3QsyAF+uM7H7YY9PMuWoDk86Ru9wODdCrX6nB3yLl6QGep9x3bAauPAGHP/iuyYw5lnri58NPbWXPFPddLmmQ9lXnnPc/OaIm1MkV2ZHOhsrvAHFhsVfIpuZ4IvfchYYC/hxvvZWO8Kuqk/VA0jMJbxUMNf7Dhag03/Mpls1BRo6OiO9zqiz+cqiItPC+Zq8ywNOOvGJ3yLdvzUjizP106K5/peYOHZz95/M2EZ6cENRnhfznQ2Rke42pTkP80bvgInGMDsB7wVpEYbupc/Y00EF+kBPEeX6B+uu3ksPPmtv3mxXTLL3/RO+ooOQtOCH11AgJ8rjs2/xBNks7qP9BMZdewa3syNLtEnPqM/8Oed73zoBEyO+ApfIq1bJdpFuLXNArprzub1GrrNgcPCaCzXLqgRMAKC6VswMTZdccchqBjobdUo+/VulSmKTmH7m+Lxu8WmXXdKl2KjeDlUYKsmgYXmweKQ4mX09MMgMT7GpRg4XRQRnMIhJ48x811X21KEFZEzF7jzm9LiAFHAflOmVf72PVpzoozLaUAXY+mvXWtGgGJiADsfnjLSf7sSlKlxZbBojgh1Nz14nVU1ht0g1dm9J/LMUFLIVa8Ga2dfGR38wAGAVwYFjuHVwr4igJSysSnerqUtE8Z84595gy/86L141fwpaXB2GwNaCoox5OAz/3n0fb3GseJk4d8Wy2tFRDetlzqK5hQ448WglXUFPvO2eG4nSF/ktAXzvHUdMnxwDPCHucEnh41DwICoRJ/zXqooOWuxAFecDeOgMQcDPvB6NXySDbzBkJknR3B+GwzaMZJd84nHGTa8aC7oSx9UQFUjXxVexjt2i52ZhhPjmgfHGV0qolzxOcYYTF1fh0+N360xeAJtjMW5xSe+N+d5vZM5j8AhvQZ2Z+3xLaeghUtH+zjiWtlfy+muFTyreDPY/c3xhGtybTGBXmSJDpTx0nGceXFW75d1U4uH8dEHPjBlcpln6dRoXyC0c7/k5R73GFvhmJNzGLVDLmDyXQ5lfwHaG9/4xvHrv/7r49xzzx2XXnrp+Mu//MvxFFHsteZawOc85znjP/7H/ziuvvrq8dVf/dXj93//98f9Z+e7rrrqqvFDP/RDi0wXNVS+5Vu+Zfz2b//27X5d4LnnblnoXbpF1gG9gOeBVQ2Pdio7nkKXkH96SZCRrNDFnu/62AL3FXdM5/Iv2D124Ed/dJKxsgI9Q4Y9U7CTrmMbyCs4uiqdX6CIOX3DftPdXftLn7Cj9HDHB83JM9UjAyv9CA4LUDqCLqS7unKTbiLf3qeTvCMrj55md9iNsgjZWDoTzL6zYDCO/ipwTh+2wcOO0AkWQ115Tn+rpcQ3oIeNyzdoB988BavoZ/OCC33Dh/7MsfpKHfXUTwF/ukhavWCXTB++B3uiGR+u6XjzQlM79AJK3XJDD6OXv/XXEVJ4QXPjs110fnbZHLxPN1b3Bf7Qr0AIvc8v9aw5ffmX7xw33XT04vkf//GpT7iFt4r5s9fgB3c3MvWZ8eIT/pH34AU+wKGFNw1/ekdwSVCLaLPTFo76wZ/m3m0++NB84QKv4deKtrPjaAZmdqKAB14ES5lUAijm29XJ3kdDOAMLOv/ET0x94E80xbtkpLo3eLIjqZ7X8JL++G7gbs7sXhmV5l69Gzhgr8wFLfkobFuLa3TBs2jm+xe/eMKPDQP0Bz8+lz1R/Rq6w3uyiQTV/N1GZToE36GZiwlkJVQDEC90xLo6GJ7lV2uVHuhoMdg9iwbkkD4gi76HGzSFp660DmYNnto8Nr7n0YuumWeaXnzx5oUv5F3ft6niPbJawES/eK3rumsVl9a/8arFNG8+t9GKf+DEyQBzQnc/1UUje3iFrwt+c9U33wvcYPPs8gmBedkCz3fc2bqhDHN0MSYeaF0DD9ab5snH8Q4/rHp+5KXTA/RU9aXgHI/gBThhHx784Ftw6g8DX+FIu40aY8hgYjpMSnjnGQrLrUj1vFFcfkpLnLfSEUX3KA2Kp9S0ecPwhNMCqSvYKAvGgcARxFvKLunat4NtYC6Ndr3MlnmB2fxHAsfhokQYBIaCIqckKCTKJ0fgYBtnkFNovJSenRWGUC0KDgI4GB94o6yjAeVNUcGvhaZ5oB+nh6L3DmXXYttiyhy6Rg3tpR6Xekvxlv6YYUdDiplxktXiuQI2HDHV6Tk8YEJrhpAT5do6cDPq4LC49K4dNEEYdMVPVbCmIBn0zutStr7vGkYNvFrHeSqQywHzt8Wn9+f8VTX2ea2agilaGS+ORmgV7CvTwPcclYM5EgZ3Oef4pCuAGZT1biXB9+aJ5yswWGpuWT4UPnlgcCrEymHMQcQDxiujgtPT0S44Rt8CYeiAphwJOFN1HX7AjcbtFlYDoHTbavWAVSsTjYOpL59XdNdYjC84SlFn6OIfBo+xq/q/9FiBKvMu80SDc+9Xid2iAA3M3bwrgoqnS7PW8DleNH+f47uyvSw68Bj+AC/4N2rwjc8VLjTXX/7lqS9yyWCTuYrpdk1eBn7eOE9wgqaCh/idA60PcyYn+LYUVe/Hm+AXSEze4Ma485TbGv143XVTAKQUW7qWLpGi2s4XeVyribTrQPP/Em2H3JGc5cr3r15OAxoWm68Z/0tE+Va066+/fpx99tnjd1UiXaf92q/92vid3/md8Qd/8Afj7/7u78axxx47/sk/+SfjptnZwKc97Wnjve9976Kmyite8YpFEOYZUtNu5/b612/bx79kn12jkxzlxOPkgd2rWKCFGL6nl7pxwTTpgq4OpgvpFzJFH9BvFV6nr+hHeoMtt8i1QLcIY1/oafYdLHQVndBNDRo9xF8h//SAz73H/pF9sknfmpPFrmfbESfTnH3z4ud4v6Cvd8HHdpg/2yQzgb4RmKHD2Fq/+SHtXHtmKna5stB17JtAaSnt3T7nOzBlPzWLIotF/dAPdK3F1U//9KSj1BcAEzzCKx1ecLZsBnMwHhyaX1c8w485dTMImoClTEU+Gf3nN5vXNfDoAGcFUKrx1m0w1SbgK8FRuh8v+AEX/LBj3gMP/Vs2rEA4uGRD6xuuzUGf1We7+OItC3/5p35q/60vdKqxOg5KL/OljFlGEVtnTngIvPQ9m2d+7AdegU92xTPsrfHAVoHxbmXjo+NNvKIv74HfwtMz8CPjoOxD/aO9sapzAg/gjp9lg5QpQn7gkM0RXMNX5sLH8J0+2S8Laz5YBWQLBlBt6O9vMFR7D17nGTJkD8zoAY8F7coqATffA291rJzM4he+I7mtPhBe4o/zK/gwbm139Er/glvzyxnIv+fhsYwG/gl8l+3QTZV8726/4ePw9/GEjDLHRnzWjXVkB17hrRpxZfDiQz/VqOn4FR7E061r0mcVWvUcmlZcHv67rtt427bt3VeTZ7leIv00b+R2nsWMDm1A4lf4gJu5X9HRIzDx78u4IbdldJNLm3DWGD/5k/tvE0J3Y7RuqPjtRqdO8YyxyClYq5tSqQJxBOMV/CKHHVfkH/M/wUu20RcN0Y8u8ww8gon/i+crsIz3HvGI3Ye9r3Ck3QaNIsCMGI9hLFU9pYbBKID5zjg6lXLXEQMLGA7M8g03hICQMC6Us7EsQCnf5dtOGKmqtBNajNx94u1Wr9co2s4MS71d77pewr1cLLTKy8YpE6NzybV58UjvUy5VX2awKDqCTSAZOU7b53LDEAFmDCnfjmHAmfEdmZmuYpscBUaFURQZNVc//oefbhKBL4oarquYTmFY8IGfw+MdiygGhUI0dpXoNbT17nveMzbBFSVknhQYpd01ufDn3VL9wWC8aKwfjiGlzqhRnIwQmumnM7WUoIVdBkOfXVfGUMQLnLh5QVR0MzaDbS6eNe48/bCbkTZq3p3fvGSXbH7jDqNEUR/s8RwOBUOMTxjg0n/hoFo01ehAYzCXgsyxQQc4wm+MKNnidLUz6Dec+Q2HnA5yiZ8tGrplwK4gZxLvdI6VQw6/nCNOeoE2Y/sOrOhM9vEgmkQXvFgDc9fzMVbzM7lksiJrfuABn+IVfIMW1XXhdJgnGuEbMPoxH04GvYHn9WleHNj5mWVzLmMGb1SIuNThbl2o+Bmn9Nu/fXLgDqaVsSUzCi04xfiMw8SRNX/wlNHh9/z4zDxgYr7dEsTZLAhLlzLsXYk8z1Ax37L+fFf23XqNDrjiiom+zvPjCzjRLxg6qoZ2nJFHPnLsSW4Po3ZIB0x+5md+ZuxZ56qv1dXVxXe3pn3913/9eO5znzu+uZSnWZNdIr3353/+58c3fdM3jYc+9KHjj//4jxfXGP8PK+1BFt4/XvWqV40XvehF4yu+4ivGYx7zmPGCF7xg/Omf/uniuduznXfetn23W7RbzsZ2Zh0/t5BnCy2s6Rw6jL4h++w6WSWfbQrRb3yNim8KnpIr/ZBz8iEAayy70PSg/izU6MAWGdl+uqbMDnJtIdyOMV1kcUXO9U+v5XN1E0oLWGPQs+S1opxg1he4mw99xz7RQ3DBTtJv/vYsHwoO9EuPnHTS6r5dWfhij7qdwnNgg1t2gJ3jw1jkGCNfzLwFWfXDhlcni79Fz0p5Z8cF5ult/csy9RxdwwZYUFXcXp/gALv/jcMXoSPBBNf0uef4nt6HM7pWf/oOtrIa2mWGN3oPXHDeYpR9Z6PAZr7mKTO4hTx9bBx6E83UfBPwgTdHNWwK3f3uexbvlyWCh0r7byHJnvFZyvLTOmbRVdNoZB4F7sxN0Au87KIgQMePux2mY7jsmXlYR1VYsyNGjoeZb0ff9eVzMBrfZ/wu4u898IDdMxbEbTaCv7o3Ze6wm3BI9rLjbAhZMg/yh4bkga0ni3wauMWL3rOxUGFT46NbWUpgQDvy1g1S4DPn4rvmHrx4oeOy+M8Y8NUGq2ct5PE1PLWIZ0v5v+Q1XvOZfsFTBpsfesH8yS35K3AjIGV8c/NuvNeGGBxXuL/j0PrwTrYbzfQ9v07YnAsY0U3VPqpVg0VfU/Bwvx0hn5kVOmZ+HFnDb9VI8Vx18OiBsvXIxLzhuTYZ8Sl/Md9trmeqB+K7ss3xIHqgA77C22WOr9e6BASN8n+MSfeDi17M7+1aca3MemsMvA9v7AG4BbY78mw9UqagvsBVMP4fgq9wpN0GjXInBKWjzRuhZxBLX+xMH6Z2lINxZ2AIZgvobtqoMfgEXj0F31Os7fK0i6xhakqwRbjWbmg352xU90Q/HAwKuEj4PGhBkbdDMOe9ztURHGMzovpiJJv/PNpqcSRqa86MtLmVHkcxMI4UB+NH6OEip+xggijm+33fN8HQrgGFQagZTwodzIS+62/BA8auHkMbiquzmxbdFHdnMvUJR3/wB9PfFfssSFOB1W5SsaP/nveMVX2ZE7h+9mf33wuv5VCl5MDaTQP+LpgGFxSpxSqj5HeBDEpP6/gK/M7pbV6diwY3J4fyRHP0rpo+g8yRXF60UpCM20a3P8ULB2pgzPB320A7P8vN/DkCpQau3fqyqcK5eI1z4fOKpwYn59luV9egkT2054DAQ5kv5CwDgR/gq+CLZhxGFJ/qA7/IYgAPnq+eiX48WxV682HoO8JSDYwyOub4gE90mOMaj6A5WnCsOCeMq3niqW6DwXOcK+N/z/dM8/Y3x5GT0XEwc/NshQ/pk3mxV3Qokwdf4f2ut8Z/eINshFsw0XXg4XSSoQNd4SzNXOZRR2Dg2dGz6gzBIZmD540y4OZXVnNaBEfIpsYpBDf4OrO83MgbHuXsrB3vWrd11Oe88yb8g0+/Fnh0PN0LpwVwDtN2SAdMLrzwwnHWPLq41s4888zxwdLnboN20UUXjU9+8pPj6xjrtXbCCScsAiNvYdgXGwxvGXe84x3HI0Rj15rnHc2RkXJ7NbIiMyJ7Rc8WKKQzyKugNH3C9nZriqxK8kHG6RH/4316lm6h+8iqBSMdxC/oaCL9Ycrsid9I5Fn+A/3ZjVXG4huQL33yocg9HQXWzvbTsf73rEACGbdz7zOyWCZIR0Y7ukNmBR3oL0Gbros3T8/Tix3/sAisThc9BS9sIpsMd2yG8/nsEdbymeQhtqlsP/6OILt56kcQoQKcdJ750ZHgstj1W/DDwpTfZG6eg0e4MU8B4HQqm93tfdiubGM4oDuNBRfwZcFvrOpGOJaIHuhDr4Gf7m8jzlwtOC2Yu4UR7dg2PimbkU5kg9h4eo9PpH9HMwQK8Ai+wUP6ZLNkKdDbdKa5yMTcvXvTYvFmHtWz6WYY/k83AHWDGpzgIcEWc6B780HxSdcmG58Py16hjR+w42Gw8p+q0aLBmezNNtXwSvUg6Ha2BQ3ICB6HC/MFVwtMvGRhiZb+nm8QaXhSbRxBQPYSnO3sl43t824A4s+xUeDCq8Ywh4J98As2P+efv3nfRhkfBY/hJzIAdvPwP1/aGPBrDnA7FTKe+A7+4Acf4WXjl/FU7Ry8Em7ZRc8UoDBG9T58X4F+NBPMxAPkAa2Mp/FB4LFC7GQVXarrxvfQD/yZs00mMoCm840OvArmue8EH13FDD/dhjhvdFtH2fObNTzSjZ58ahtiNnXmrdso6VO+IFkB40Y1K+c3T2p0YicBZKSBHf/As/GMX222bmjS/KZDlwvXzxv86G+5zgpdEb+ZIz2HPmiqob1+y3TC0+S/EgSCld1OhY985rku5ljm+3+IvsKRdhCNQmO814v4YT4GtKgdJmZoKtRJmClBtLTwE8nriswW0hZZmJJSx6gUDGNf2rj+KamKglb9et7AVgXt9VoF4TxnPEJMYbUYqJZHV8oVlQR/1wNrFF234HQcqcUqJUCxgJNiUHAO3PrwPZjtSPA5p/Su6fkyO/RrfvM71rV5EKUoLdxRop3fhTcK37iUBRmB/6rWM0jeKc0P/jk/FobVKOGAmCdDoDCUZ9EV/MZiNCiTnEdniBnq0lM/+tGxqQV1QaflAFDwV+QJrIwS3uDQ+I6DoR/fwZ+xu85xHsjCB/OjM7VunenaMgoWzSnobhPoTHDnZmtgkQXBGK8XvLqlYsO1rt/Duxw2xqaq5vMGjwwTIx+v//3fT8Vz8RP6Mnjo2bVtWgUD8ZDvOY54N+NbrZvqAmnmDH8Uf1cedjTNM2TO4t6uYQX3ur0IXOEWLOjrvRxjPFXK6Dp6e9E4TPNituZI1hgsn+Mt9NcHB4hzAWa0IK/oYjezaxbNo8r99BOj1m0/+qZ3jjpq/81NFgX6iZcEAHOEwKAoIXlEB7uH1SuJlt0ooMFBtzVpFVtb5o2uqKb3OGHoZEcRj28UNKliPrnFr+aETtUx0AreLrcCdGhWcG2jtnOt2BoZIedg6hx2NKUDDtMrhQ/5gImgxYfbVp01DpAjM7dVEyzR7rKUq+3/vvP7lCoPrrUtW7YsbuvpmfXajh07xrXXXnuzn3a+boufU06ZtmqnYo2rY8+e1XGnO62Ohz1sdVx55fT9OeesjuuvXx3HHbc6tmxZHZ/85PSzffvq+MhHVse73706Lr54dTzykavj/vdfXRSa3LFjdVx11eqiz02bprG+5VtWx/HHr47HPnZ1fOVXTn975973Xh1vecs0hqCDn7vcZXXc736r46ijVsexx66OE05YHTfdNPXtO78vu2x1bNs2wehdMJx++up48INXx0tesjruec9pLn/xF6vjOc+Znn3qU1fHf//vq+NRj5r6NocLL1wdRx+9Op7+9NXx+Mevjg9/eHVce+3q+M3fXB0PfODqePObJzjHWB1f/dWr48//fHWceOLq+Nu/nWC44x0nvNEH11yzd4EnMIPzkktWx9///fSs8e5xj9XxjnesjrvdbcKJ91/0ogkX4PaZsfX34hevjic/eXXc976r413vWh1f9VUTLmWy/O//vTq+7usmvOkL3PD78IevjuuuWx0XXDDNTT/g2bVr+vnd310d55+/Op7whKkvNIY7uLrhhgkX+vRjvuh8zDGr4w53mOYDv+hgDuB43/tWx9veNtHdZ+edN81h9+7Vcfnlq2Pv3tXxyldO/6MnvvK+d9Ed7PjBM2ecMeEbLJdfvrKAz/Ovfe3quPHGCb7HPGZ1rKysjje+cXWcddZEDzT2Gbp+8zdP/ID34Bvt/H+ve62Ob/3WCRfnnjv94FH9vfWtEz+Yp7HNFe70YS76Nz5cveENq+Pkk6fP9fnpT6+OH//xaf5orA9jXHPN1OfWrRPOvvd7J/jBgjbJH1yA/UEPmvgen8MN3OENY3vuM5+Z+OPVr56+M97ZZ6+Oj31sogv+ef/7J1o89KHTO56/4ILNY/fuvQsehX98Cx7z9J4x0BzMeAUNrr56dbzudZPcX3HFxDdw8mVfth8fT3nKBDdYv+ZrprHwKR7Fi+CBQ7zWXMk8eugL7ekS48OjzzwDb+95zzRHfZOfRz96dXzDN0zfgQ9Owe57eLj00qk/9Pasz+AVbRo7HdQP3gavuaOzv5d1o2eMp29ZhH2e7H7iExNd8CDcX3TRzd+HO8887nGr44lPXB1f/uUTTsjb/Dl4h3M8NucLn/kNT8kU2oFHH/DvczxHz/obDtDauBvp/E99aoKDjtroGXP8Z/9sdXzTN030QCfw0C++N1f8ADb4Nzef0T30bP2wD96HY/Lzqldtu81s1346fen4CkfaQbT1qiYvV4LO+Rf5tZhoYdmtJNIWLcIscDn61XdAY86ORV71FvRlMWdBJCIo8moBZOFU7Y/lJlJpQeL3eq0jQN4VKLBIKIsFXBUB1dpp1UpjrAlMdENKxeBK6SzoIdvC3MFtR8Mce86iqhoDFjfwKpjT4s+ink/ZbS3GUiyzVMN5lfRqvMCbhZkgDhzZaTFuO9Bwamden2UHgRXOf/EX9xfQsjiqAJYFIthk/FhMqYhO7tDFTlMFZS1OjWch+8xnjs1rGRKLPi1kLQ5bWPrcItacKuhrDFni8BXtLOYFz9rd6ErirsM7mAafFZ7Dg+i93gJ1vfoOaIzmy/oHDeeVuw/U4Ka6Fha/5idYMV9k18xboMyCHi5uumnsaEcPnvFUxbI0+EBn/NrZa0EAO5cWuuCDK7gVCChjvoKnnvcuWnTFcplfFvdl/Zi/grueK4AoCIM+6C7dGW7JkPerdzNP76x1vhv/dF0fvqQHjFdmiQAM2JxDFbwQwBNssJMHl+jqOTqnXYFSyj0jGAbfUuTJ+53uNLaA2W6CsQQESjn1g8fwPZ2laj8+F+jEN1XqN3eFIc0NzORDQALfh1cBngq6rtfwAvjQWn+CMWisH/INvlq32OgXjOmparRocFAdgXmzq0JndiQg+NZrO3ZM9ACbQKu5orlx7Ja1k1xQeZ2Mzy/1dsgVfZ03x2N+5Ed+ZFGg9b5rFQ45QD/+4z8+/q+KKB3i7fnPf/74pV/6pc/6/PLLL79ZfZTPtf3RH+0dT3vaKWPv3j3jxhs3jfved9e47LIt46KL9oyjjto8tm/fO0455cZxr3ttG2eeuWtcdNHRi8WBYM/HP37jIhNg+/YtC71+8sk7Fv/TTY961Kbxv/+32ih7xpvfvDJOO233OOWUXePud986rrpq78Lpf+c7t4/73vfGtQ2RY8ZjH3vTuPLKzWN1dcv4V//q+vG2t21b6MXTTts1PvGJbeN+93Nzyp5x4ol713aZt40nPemGccEFW8b97rd58fvGG68b55+/aVx99dZFocbHPnbn+Jqv2TP+0386Zpx+Osdj17j44mPHX//1jsXcjjlm63jNa7aNRz5y59i69fqF7nvhC49fLMquu25lnHfejeO887aPhz3shrGysnccf/zeceWVJ4xrrtkxrr9+0zj33K0L+T/11N3ja77m8vG2t+0dd7jD5rF5865F9uLxx6+MnTtXxiWX7BknnLB3XHrp3vHxj28dl1xy02KR+opXbB979uxdPLtjx6bFBoR+4eiVrzx6bN5807j00pVx1VUr4/LLPzMuvHDLOOGElfGa12wfr3zlpnHttZvGox+9a7zmNXvH2WfvHh/60Lbx7ndvHisru8fOnXsWOucud9k5rrhi03j3u7cv9OFNN20ZH/jADePkkzeNN7xh6/j0pzePk07aMT7wgaPGNddsHh/96Obx0IfuHKeeumu8611Hj8c/fseCN/DEFVfsXWwOvfnN28Y73rFnodPvcpc944ILdo9duzYtaHnBBXvGZZetjIsvPnr83M9tHve5z+5xn/vsWSz4HvCAveNDH8JXW8epp+4cF164abzmNSvjuuuOGmeddeNiLm9728rYsWPPeNObdo+TT945duzYOj784a3j2GP3LuYCn2j9kIdMz/L5rrxS/9vGwx9+43jjG7cv8CQINgVddi946cIL964didgy3vzmLeMJT9gxLr547+L4z/vfv2fs3btpnHzy7n2FV887b8s466zdC3/gHe/YssD5d3/3jYvABv8MDEcfvXm85S27x549m8Y//sebxpvfvHVxle+97w1XfFl97lnMmU180IN2j/PO2zqOP37Xvhuqjj5607jiit0LXpRlYlHMT7vyypVx5pm71zJvVhYBh7vdDW1dX71pEUT72Me2LWwQXLzudceM1dVN46STbhy7du0eJ564Z9zjHjcs5rN7986FvX/lK48Zd7nLDeO66zYt5iuAwjdi09///s3jM5/ZtFhIv+pVxyyCCPD9X//ryrjnPfeMM87Ys+jLuwIxp5yCloIxe8fll0+ZLBbv+vz0pyfcnX++gtJ7x+mn71mrqXPMOOYYc9qzGOuUU8js7sWC+iMf8ezm8fa3bx6PfjT+W13Y+3vec/fCVtM9q6s3LjaB5hc9XHjh9nHGGTsWn+H3D35wy1rW9N7xgAcc2OiecML2BbzXXrtrw+yPKZBzzSJoIiPQPHbvPmohc0cdRR/sGu973x3Gn/zJrgV/aHDxylceNb75m29awNImLpx/4AObFoHTGvm+6CK4Jx971uo8bV2rDbVp/NEfbVkE6b7xG2/a50du27Z1fOADu8ed73zzXcnLLtu2CCb97d+ujPvdb88iuEVnza+Q//Snt41t2yZ83VKjL6699rhxzjk71o7usQ/g277QeXhx06a9C9xcf/32sbKya3zykyvjsst2rx0XouNXx8tedvS48MI942lPu2pcdtlNCzzeFu26AxUB/QfmKxw2jcNsQbxes7CdF83kqBMYixWLGmnvFkQ/8iPTIsuCyKKHkRDEIOQWdaUXMvizwvyLRZaFk371ZVGyXqp5mRPzYz7z1u0bhIYQaZyWs88eWy1WbK6VrQA+CxnNYnV+CUCL985Gww2DYIHTFXh25S1cBGYoSjiyUKYsLIaMazFTrQYLuo71VNxSNgKYquxt0WpRSb5aOLdIFShiTOBPUMSizvsEvrO8AgAyQpJzu/VSBJ0zni+KzY18WTgKlmhdz2vuaGjBiOYWid6vqOcjHzl2MUiesTgUwFEt2/lQ/dohRx99U8IWZZr5mKsMl66ZdYyrAq1wDAc+h6uDqaXQeW74hlPw3ZrLHPCsrBlBhI78LAfPDtTQoyruNXCjjcVpPKjpH64s6GVVnHnmdLRJpgajU70ZjgXDhV8LPqC/dzrG4ggHh99ivmvf8KrPyID3BCTgRf1HY6CvxfH8DCxY9CejgcziPQEvPCaltoJ9xuUk4yVp0eF6ngKKD8kInSBgpx9ZVQJx5odWXQ8Nb+QPn+DXruCU8op3BTzQxFxk1wgYwp/gUOnXZKkgwUknja0CEgpEg6kTBXQKefN8txIYz/wEYQRI9EfnlDFF9ziiBkY47UiZxQIczG/8Wq+ZE3rhe/xeEUGp3oJlZfuYn7H9lC78//6/N9fB4a0bj7SO53UVNn7FR27qkiY815sVXrziigmXcI4HwVhgDT9I10b/M84Y27qp5zBqh3TARCHWJz3pSYu02nuuVQb/+Mc/Pr7ma75m/MZv/MZtNs5d1wz4pz71qXG3mRLw/5etXe3gmcuWPNTduy0Urtr3/nrt2c9+9vixH/uxff/LMDn11FPHySefPI7f6JD6rWj//J+vLjYDdu604LFQnxY+V1yxZd+ZeIvVSRcfte+2CT7GW9967CIIS3anGhfbFjqPHNKXAprXXLN1YUt9x3+wGUImKnB47bXbFroS2j7yka376iQ9+cnbFrqKXCuA6miGz8kaPcHPoZO8X40T/tIll9xpAYP/6b5nPevoxbv+v/rqoxZ6+gd+QDB9mktp+G9849bxl3957OIzvgjdApbzzjtqrQbSMQtfgC6eCkVvX+hfc/P8fe5jN//O4w53OG4cd9zKYv5dPcte0CXI5ZgJm/43f+O5qT/wOiLTsT7HJhxlokve/e5t+475vve9xyz0LNyBoSKyZ565fYGnn/u5iS6/8AuTb8N3Yn/YYb4DnPEDwLaycvS+a+3psuuuO2Zhm7sx45nPPHq8/vVHD6x37bVbF591Ux/fh32EH1cO+7vsSLpUn45odbzxhhu2L+YigI7ObBkd/qAHHb3YyPM/23fSSXdY8MSnPiVId9044YTjxrvetbIPh+w/GDsOyp6wHfxF9nPC83H7bkdDN3CZf3U3BEIc87RZ8cAHbl3ARHebg00G78G179FPpqTNAzZ0uj772H2bnPCBx4k1HLKheBJ/d/wAb3TtKt/SO56DD7BUZFyfaMq3k6XK3+W3gQVsxsZD3iV/5BKPssfoYK6u6ZVpfPLJRy2etdA/4YSrxllnHT/ufW9Bt4lGr371cftqzPAd88/AiJ/+7b+dfBAXBphbR1y6tdI73vW/57qtxXN0hs8rHo9HyRyZ1Qeeg3O8gafwW8WXq3fBTp5wwjH78KJVMPW44+5wM9+oYsrz5D4BFTB2gcH8tprlxv/2/YFU6ZShIvB18r6FvrUJOSZPfKGJR44aJ554h4V/5hjOdP338TfzC31mfm3coAmZRvOOsvAf6Br/W0fBEb/9pJOOX6yn4Bz9uommRi8Yi3zyk31HP1kDkHn0JWt45UCXenQEj04nbxOPHLMIlPK7u7qd3u5CCM1z9A2enQJwk2xW8Fhw5y53OW6ccspJt1nA5Kj5QuBLwFc40m6hVf14I7qudxMIRYHBKEpMS8m0226xRxgJBeGgsDG4xTFnZL57z1gRzt4nBBYvKUhKGWyUjXEUWNqozYsSLcG/yxGEghCEqToPBGW5HgrlwHBRgAVMGDWK33sEHcwUBiXWmWd4quaJOVOGFILvymhpMV7FdHMz34pWdUSBsDPq/mfELHyq5eF7xsl87JT7zAJXM5b+GEcGgDEsmMHQoYH3qvNQYbV0AyNvHmhHYVX/AY+YO+VpvO/+7oke5s8JcD6Sc1BFcnTjrKXkuwrW/DlbMnP0Y27mxVBRwvrHAx3xakG5XsZHMBvDPOY1bw6mcQQqNFYAD366+WW9xrHo2ub1Gtp01WJBk5wjPBC/PehBYzMjRh7M2RyMzWAwZtVH8aMPfM1g42O4IWdkisKv2J+Mns4n68//FUjs+XltIjzHUUdnTpRxu2KWEfPDyDL4zqSq8dG1d93glKxw/MHpWbQUTERrcBs3h8QYDG8Lfe+gPzj07Rk6wWcW+njI/wJ0jtfAqzn4HAxrtwltoYcK1qFftUzAhb/RuuwytxJUB6XbrDjHeLGbGYztZghBDBlUgoMHs/YzDlmgzzjK9EBndckg/imoRz+UcQWXAlYddepYG9pw3qq+DxfduIXunBWyKduMXuJM4js8CudnnbXfMdCPv32Hj8hz11h3Vfth2A75IzlvfvObxytf+crx/d///Yvdote//vXjr//6rxf1RG6rdtpppy2CHvqeBzbUJnm0YhpDTY1HL64bdi1xDRyccbVONmrbt29fBEbmPxqH87b6OeOMaYdcNsSXfdnKOPbYlfHAB66Ma69dGbt2rYwPf3hlseC66KKV8chHTtkOmzatjKOOEhhYGf/oH62MJz1pev6Od5SVsTIe9KCVcfbZK2Pz5pXx2MdOv+083uEOMiWm97/6q9VvWRl3utPKeMhDVsYxx0yfe+bCC1fG6uo07iteMcEE1h07Vsbpp0+f6xds3/ZtK+Pud5/GV4/loQ+1uzp9/+IXr4xPfGJlnHrqyvjUp1bGRz6yMh784OlZ2Qme9xx4wQH++vmGb5hg8PxJJ01zeO97V8Y//acr46yz7PivjD17Jrj/xb8whvT6CT/m+oAHTP34ufOdZdlM759yysoiqHLjjStj27YJpx/72IRrY59xxsrYunX6fZ/7rIyPf3z6HPwf/ejKImPnAx+Y+n/84ye4TzxxZfyf/zPB8+hHT30fffTK2Lt3ZdzjHivja792ZXz7t6+M88+fcAcmcwUTfH7oQyvjq75KBs/K+Mf/eHrPc/D7vvdN+APTve41Zcw8+ckri53xN75xZVx//TQ/n4Pvrned+ga7vh/1qJVxl7tM9NY32tztbtPz55478dpTnjLR/WEPW1lkHky2faLXmWdO/GVe5g0m8L/97RM85gB+8N3znlTShGN4hV/j/vAPT/Px/f3vv/+7hz98ggOu/uIvJtpdcsnUx7vfPc37Oc+Z6Ak/fuMJ/IkvZPugG1jBj0/15X1zRhe085nn8DB6+czfspg8I5sEnbZsWRlveMM0Dlrhu+3bp/mZE/jBaM7mY87JKD7Ek2Ty05+Gx6kffRgL/3zTN028F77g03do/M53TnhFz8c9bnrXfPyA94Ybps/wlrmCnUz4MQaa33TT1J/P0i/oe/HFUx/kG/1PPlkWwjQH+AAb+NEar6LJXEd5Fx3f+taJLnSIPskNXMyfxX/wCP9wdSDd5xlw35KOFDCZ/09focXXf/0kV3QgvnjBCyZ9A390KXlY7gv+4Qku4RuP0b3oi/fCE9jx6BOfONHYs29608r4+79fGeecM8nfvN/ohRf0iTfxAT7CE8Z8//snnvc/nl2GzeeyU8yB3qVv4Qit0cczr3/99DmZn7+bPTA+PNB1ZO3qqycdIHPunHO236a267YKvHyxfIUj7RaaXYONblrYqFlIF8HuaIJmAcr5VxQLn1gsKQTEGa8YWK2Ufbuv3rHYtFjj1Mt2sHixALHosZjU10a8Z9FwS9cIe1cwRwTalWDGtGCw0zC/acOiwwK6KusWkWCBIwspCxtzsvNsPAtTPqZFzo//+LQo0h8eLoADX/PNO8EBix/wtFgXnbYYFjgR3BAsgVvjVcwTfi0A9Sv7w+6KxVw7PBaW+u0Ikb4shgo46Q/NRJ6rEA23YLfYNYbAkDlwCOYFWI15wQVjT9fwVW/D4lTGCr/b+GhvbH3iLX3ajbIoFj22MAUHuNR7qWaE/ssishCsKj1cPPe5n12Mc36cBy02Oqq1UYtm3c6CFuZ8IFnoppcDNXxlQY8H0AFOSqX0e+1qvk1og554zM6/wlXwCQ9zfuv2HHSxgLZjAIdwha4CB916Ql6mXaaJx+xOgIGcWbDPi4pZcAvWeL+6GWAhexba/+bfTHQFoz4EgrqiEa+QD2MK5hUQ6vq4CqF164H+zKfsMbSPngJW5mT+HbHCb57t6mTvt9NVem7Fhq+5Zlz/rGdNesS8X/jC6RlzKsiJn9BEI/N+7HjSLe064iHPC5TAk3l4TrDCb7ty80LBZKAjOzUBIXAI3IBvXtgMHsrOnN9YUBPESN6iP9i6OlDzdzsv8Uc7WAJR6NC1x/D/5V8+fS/7pOugCywWAOr41rSrOw63dsjPiKP7xCc+cfzkT/7k+MEf/MHxWFuDn0P7zGc+M975zncufir06u+LL754MYZ0XrfovPzlLx/vfve7x3d+53eOu9/97uMpIpGLAOoDFztYT3/608db3/rWcc455yzgeepTn7p47vZs3/ANN+7LFiM37YhO12lOf4sF0a30C7mj37oVjA4m036TM3pFEFjgVgC2K2ErJkmH0q2OCpJlQVOyKdBfkJF+15fx6S7PlelHt9O9dBj7TP/6nKzRjY410Osy3qBWBs38thjZCN3QwSegc43PjnbrBX/C52wWOxZO6G+2WMC6a1bh7cUvJue7F7LeDSxgp7O7Xtj/z3/+9K7PvQdO8+44KFvA/pifnWU4l61Xke4KeIKhY8wC0hWAFVDuCmJzgmdZk94TzJZlx7bzC+gw2W/97X2wCayjrYyUMviMiW5o2QaT3WOf8/HgHLxo9h/+w/4C5R2Thts2UOAMnmVv0LP66epiOAHvJZdsXvgn3oF/P/S2eeI5sNC76AsH1Y2if83x6U+f6Gh8PAIG9gVd6OrGw4N4QKC8CwnMpYL//CrBd3PDm/jL8/orIxKPzLNvy0TCM2helitZMD6a4q+KkGtoYEx0qyYW/NvI4aN2nJavKr7quQq2tzkB1jJHuv74gx/cuui3m3rgE+7IC1qSR3PG6+jSVdAyfviuYO4GRjwKDu94fp6Zod82TZbLSpgjnpO1Yy740gYRnBjLfPGDjRD+OryBv9pxGnz6zuaEeZAFuKko8nqtCxS+EA3NbTDDGT7n75NTcoYv4Nbv9eqFmjNfBk34WPnEZNxmGBkxP3zDd4UL7/gcHm3ASVxcvo1Uf93kiDZ4iu6EM76Q33Qk2Mm7/7WypzV+oE0h8yHjZdpV5LYrhPFZm0savaVfvr4x0RBdyAsagRdfTsHIw9tXONI+j4aJ5ylZB9MyEBThsjKg/CgOyoBAUpiEaTmrlxNhcbSc4cHYcHos/DExYyONb3597LLSm+/crtco765a5aRYXDAuPmM8CLYdYX0SfnBbUBEgCpfipETBUEZENUgoRfCC1Rwt1Bj2+cLbHPRdjQDvMPwEvwyerneV5UGwGTx9eoYBAZMUQfBWENJz4YGiYIC6krhddwqZIYZnSrLjDXBibuhHiVF23k35wf+8psGas7SZIWXwy0iiNNvtZqhayFKc6towduahdgc8U1jmKFjCyFdHBIw+1z9HE64FMfysV9uEAkRPuESTjbI+1mtoR0Hrg2MHx8ZePmKz3CpceksNLLJ7GFl46vgIHK4F0VYZenD4zEK9IxbwhjfAhwYcJ8GI+ARtOifqfQElhr7jNehbBhG+Y9AsFJZlHEzVtSnbihwxioxstV/wtvHAwZgJanA8ugb6z/98MloMqffxvv7oADzZMRxzy4DhP3TXJ7jJDX7GA91upV+8Yy5gBZ9+8Gc1XBjSE08ce+ALz3PUumFiftMTeEp7hWeOLhg4R/PjgRq60UEcdQ68RYex6TG8GC3hAX2rI2TuAjBoUKX25AcM+B69/A1fdN9GrVpEXZFZW755DN+TIQ1O9El2ZJ51jGDHjol/8BN9MNdLcEgHcjL37h2bPpdr0A/xduh6P2vtb//2b8c3fuM3jvvd736LH+eR//e84M1Btre//e3jYQ972OJHc0zG37+oiNUY46d+6qfGD/3QD41nPOMZ45GPfOQiwOIa4XnK8Etf+tJFyu8TnvCE8eQnP3lxtfB/sLq8ndsTn7hrsbCjP8jd/NYMuqqMLH+T7bJVu4oVfwukspUC8WS/m9p87xiaxRC5JM8WGvQMGepqVjrPGOwdfeO3Psh9mxFlJ7KB7KHFCHg8R5/ot5t2+D+cfMcsyDUY2YLsRdmIFQTv9hd+iueNDw8tbj0ns5ddxT70VgtU+lR/L33p0Qt9TgfAI/unL4sT/cqoMyZ9Qe/4vkLt9LA+6S8LDnOUgUjHgNv89Q2f3qE76Rx40z//DMwWPK64p6f4K8aBq/xBePIc+v77fz/pNXCwm2xG2a74oZs40B399Mc+gpeet6jXvzmxNfwR9tLcuwKaT9TREv2yOexMtMYr+ICuRBt2zzzvcY/di0AN3LJdcA2H5o9f4IMty5eCt3w2sJsvXR5+Jz6f6KgPv7vtQx987TKf8bCgiXmB3XEpfGC+cDQV952CU3iiW2qyi+jSRpWGf31PvtASrcyLTwRH/AfPgBk/gdffbCKbO8/s5ivgHzgyT/Rmp8DVUXd8BCY/V165aV8tRPChNz43Dvqyp3AJT+igf+PiRz9ddoBm+JL9hxNBzmygBlf4vlvqlpv5Jct4gi0Hq/87vtYtl601ss1kq4L79AUZx8sCZtYbG61NKh+w0Y2Nn29b9mfxh3nw39G5EgDLdr8af2QEnSt0Hz745mhifmhGr9Jf+K3NN2OhVQEh/AzvcOwzOo3M4ImuIK7WonHwhvfhnu+EZ9CELu3mLn47+L1Hp+qb/usIVg2MeBncfCMw8ovJpY1BAZOp1hEZ3DEOd1/hSPs8GmZbKp5/i40z0t3iyzv7CVVXXRGIajWksHM2DhR5JYAZRUaX4BKcskn83Y6tvg5ws8lmSh8c1QhgGAgcAQSD+XNsOAwilxwnwkgwu8pYH4SKoDOUFHxXqRJyfTEkFLQFj8UUx6AFlT4IJiFlOKvZoemj+8/hyi4Ioe84ivEc36CkGFHOHDxTzF0vBwfzIxdd48YBYSRK12dE5jdwgJlisguUQTAmJ0SAA14oOOPc615jUwVxa+DxXgV8KT8+uwg1o2HnD34LPP0//09nrCenqYKT+vcuOnF27OJYzNlhobwpPP/Dq/Hs/sAZRWqxDk7K8mDqDIpcgw0e8QGHjWFD2/UKbWqUfTUq0LeaHPOmL8+Fo3YdzX86h71vwbsHLfEQWTEnfEPpky38bhzvMvLzYAeYM+74lCNiXPTCr2CCF/TofUGhMixqxnFeHVxoBTZ0h+85H3FU8I1+jCFoF58LhHX22t+cI/C0G4yPOZj67wpkze92P8mbMfAf+oMHDvFS9QAY4pzGuXOmzwc/eKxUaNdY9Mb8mtzlgHDBiHlxXnJSIVtyygkU4ONQoB0YjZsjVU0Q/6Oh9wWt8Hi7egU7Ciqh24teNDkJcLVRYXOyhkcKJOdQ+Xw58xIPd9TQvMgHvsCb5nPCCTefn3mX2QMu9IIH8nbaaWMnfjjM2iEdMPkv/+W/LK7uPeaYY8aznvWsxc/RRx+9CFi8zC7BrWhf+7Vfuyhst/zzRwpYre1O/fIv//LixhvFWF/3uteNM5aKRbkRx7gK1Ski+JKXvGQcd2sKQ32BmoKMZI2txsdkDt92vTB5KpOi68oLYNApsq7IMp3C/pIBtgK/0xV0Jj9Gso06C/okg/pPn3VdsLHIEx1lLJt8/udHWYS2WWFhLrOBTgArNLLF9AA/hNyyO2wbfdJRWfrK8/weY5H7qdDq/g0CPglZJrcW+GynxTqfiK53BaxAjGf4ERYH05W1mxewtjD8vd+b8MHWph/Ao3/vyMSl+/kW4IYLdglO6UifgU2f9DPd6Hl47QiyftkhNhfsAin0EtrQWd771V+dcPujPzrhr1oEdClc0qX0sH7gPHsqaCPTxZhrccJFoyfpzLLpjKcuTNlAxixj0nz4sWiCXviMvZDlgS/gDT3Qij8EX/jJ8QN9dPMdnjJv9sez1UQx9prvtC94Al/G9d78qCd8soOyHNlhdPJuOCvwgrd/8AenOXsWjPqGE3gFO58OL8A7eNAB7jrmrLUJVX2dggK+7zpccgWfeE0/+Fgf/PHlWoPdmpgNNEc/+Jqc4Uv8Ar94SY01t/Lgce91hNnf5mE8sLVO8Dk+6VpfPGiDht+Dd43Dvpb9Qt48Pw8IdHXwciPrXS8On+QaTtGgSy/gAM74K2D1v77xOvkluza/+A4FwTaquVgDdxtgBUo/l+Y4SfM0v/lthTV0qSYeXUgHoGfj1/SDh7pmu7ngZ3oUvvFGdW34d/Cdj0Im8J3NHHpQy2+iZzv2ba3fLX4y4Ap+eMdz+Jxeg280Nz64q+tmLskoWVTbxjj8zi5C0KoPqT/jCZh0vTX+Jkuu+56C5HsPe1/hSPscW8XPNipmSFlUkEvz+zd/cxIW73YLQ21eC0W/8yyQ+XEGAnowWb7d5NKOtvGlgjG0FFF3rTOqByjWuYXzQWDmjUFibPXBSDLW7R5TlBQkJZ+RsuhhqNtNIVwUur/b7SaEDDJYROU5FhQHGCuoxUhSMt4PP93wMy/wOG8MGEWUoYA/CoqS8J735wuqbtoBFyPFuTMemODBOBZs5kWx+BG1N3+80G1HFBSngjxSig972Njbrr1WcSV9gbEithw9ChFsFJ9sHTsd3RbE0KMpmClteObMCBZR9Bwr7/rOXMEiKIJ/1GT5d/9uel/mDUfH4lsABe4oPjBv1MDcMTS8ZY5lnFCkpQEuNzxG0VPe5gbn3epUY7w5f+ABa0c65lXIc1bQnjHAX4wE3uDwm2+FUeGV4RJ0mgeq4AM/lpVkDDxVwTVGv2uwBQfBvXRj6GLBEL3xBdyTh3YIlpu1FVyRDf3CNWedAWOkwIf+aMxZr8iez8FThoxn8Sc+1F8Lfv2CFZ3BgIc4j5xQz8B3gbna2rW4K+Ss68jhIAeATHqHg2ZMckj+GPKcRbws/dac0FU/82Mwdp/xvGBaNUW6VQx/opF3vDtPAUUP/VQEWyE/8osXDnQLHH6AxwIbHcvhoG4UYNbwEBriCTJfsbOjj55kt9TZHCl8BQ8+n27LGHsPgbXxP6iAyfOe97xFMbc/+7M/2+cE+ftXf/VXx6/8yq/c3uAdMo1toOfJOx1F57bzTtdaXFkckkv8TqbJHxmQuk930SUKgOJ/7+N/tpsMW7yx23RXGZkaHVo9KbrOjqtjiu30V0CWjunGMosl73u3o4WyAbRsJb1rTDqUHu74K3m04LZgoK/oPcX0+RPGYbMsnj3jO3rLnPkdXTfPNoDXBoMFJbzQvb7/xm+8cVHUWqaLuXtWgAiO4MoYNn/oGzoLLuhSGz1sGT0qU0d/BWPLwoEDcNKFYLcYglu6XJ/sNfjYPTSE/47LoC87pB/63vEYeIYnO8DoCw7zaWMIfvW1Xu09eOrIBNuOd/yNRvjF5pMGzmwTvWyxjcY2zjS8xC+wkGP32QA05Z+srLiJZcID3ezYUrvUbAF+YvuiC9zys7zjd/awAN684Tlzh09zRGMLcWN0pIeP5m885zfbg054DRzgZWs7mmZeeKasCHzIf2WnwcbGtRHXURS2ToDDPGwIsD8dc+0oLtjZXzzIH1r2680Tb/C39YnWeFJw0hzUJ8Lv+jEH+EC/+GGeCQN3+m+94jn40WcFRvGxRbAgoLHxIN8zHM+Pxs4b/oIrcp0v3U2D4IRPdEMbdDF2wTQwwlXH3+mH5c20jdo844XsdLvkrWnWae9615Z9m0B8nDYUlxtcoXcZxHhn+VgO2bUmgqv5LZP42ufd2qjBE7zBH5mFL9k9+B8dBBc7pg3v1izwakz4SvdVBoBu8ix/j6xXrBivkf+y0vID0YE8kw387D3wtAFmrvQZ3rJ2pGPxEdmgQ/hM4GYfvO+GqEOxHfEVDoFGMaxX1FXDwHYsCX9G09kwypPzQDlaZM9bC3WCwSCnmFKujFK3ybRQOlBrccPoEhCLLMqFkyGKrH+GnEAtH+2p7do1ZUWUEloU1rvgJYQUIEOo/gZBokT0ab5g9T0jKTJLYWiMIMViwciRMB8LeI3itnCnHDhGpYByDubXsjLInC5Kxvvr7SIv41ej1BkdfTHo+qDYcgbtNJkrnHCIzMeNOOCh9ChNUVg79xwrDozGaHYLirlxzKTdOmNtsfe+943N8FM9lgIPFGPXSXNI/BbQ4qww6PADd/CIr7rWWPM+OKqsDv7O5lKg4BPpNlfPck4o2irH6xNf4JOymfDNRkET8He7DINsnqUu6pNhnWeZlNpHiVO66GReAhb6Ao/GaHICW7AzCvoXLGII/eTcra6ObeZlsUoe2hEiJ/Ep58IPPjOvxtEKTnR1dLcpwBscCoCYA5nlQHgOzOYGv5wqxsHzcIvGZBmNNyr+3I0K3aoDZrjQJ+eE0SELYPODxhwpvEfHcC7KqIHvAgHz7LYW+W184y94xZ90jjlMVxjuf+fEE8dmPI2my4HIUrbLhqvYq77Qzg4r3kMz/MkR87x5Gss8qoPAgU2f+Z3ThgcFeeijeQ0lcyYDHAOLJjTEXzka5oBP8bk54o8CyhxIczIP+PrTP51wfaDCxuSHLHCmjU12d+yY/sYLcAM+fEYfcdR8xxE0x1tbx+pLpB3SAZMPf/jDixTb5SbVVg2SI21/49DiY/LWUQe6ik72f7vrnqET2RcyTp96rgAnmabryIL0bLrGYtD7bLtdb/qNfOqDTluzfQubS5bpB/XD6DH9WEjSD/SMPvTZrV7sRMEH8liBZ7aZ/PGjyHY3c9HzbGjFtG0ukF3v+5uMW7Qai+7Qh/FaaBmTfmd/zLsM0GkxsG1hHy1Q+CoCqekJC1g6kO2ms9Q5g4Of+IkJZ/CoT/5TdTvKJvC976p7wW/iV2Fhz9FnduzREO4ERdisjuGYK3paXJkfnKMje1Bmjb+7FcnClc7c6Cg5W+UZug4v0MNsEVtsTvjAwpzNYpcEBSriTw/LNrXAl+liUWV+09W4kz9irne7255Ff+BxXIoORceOYJWZTC+X8eg3u8l+0PXGNH/zrhnLGGiNruwKPmTLwQBWuGxjzrzQFK3JQVlT1Y9BK7QrQ9Pz6EuO9PHHfzz9jW/xSHYaz+rXHNhpAX9+RfVB8BXe5WfhGb4pWNfbCO2dmr7N2/xdB90NbtYM6JYtAhN81vhq/Fbw4lW4JY/WKXAG1up14K+OcpszWdfQq8DQHOdlynq2o7ZkjF/ZEeXqI2lghFfzJ5s+R6+ODJOL5UDYRg3dpuNJ+4NlB9uMMR17cqPZ9Bna8+v4JfOGR+F0nn1hzujomJdApSCsOaBlRf7Jc/UI82HwU/NDW/2gjfUOeRPE4GehBZ0Kx+aJH+kofNYmNj0Kl+Di25MvffC78FPrJXDSGfNMY/qBriFPnmUP8AJ6kTMwGNNn9IWxmksbhm1I6+ee91wqcHOItCO+wiHQGLeNjuMw2pQRJUaZce6/7/umq7zseFfocd4IPaFgzChzzzBMjA4BpFQYaQbllgImhJ4QVagyp4izQDFR9hjeb4qNAhSQsLgQSay96U1jlTB09WkLde+B5bd+a1LKYCdk3U7CWaEUGQrGsyNCKf5SAKtXQFkzRIwZBet/O7eUDkVPqU132O9fVBLughScj3nAZPlcISWhYK3P9SmbgYPSuVDjMX4ysH3HoDBKcEaxwSWnTwCDc0QZuV2nIpcahcIYcQA6CtOczfejHx2b2lGIRjkxDDajRIFRTpwjSsz4nnv2s6dxOicMPkqWMgOXhbhnOTH4hcNmRxCOBYDAz2CXaso4tGOHx/ygJyMvwGOMCkHNW2dqNbCTgYqBaf4uy8Qi+3nPm3YozK9ouzUOp1tU2zzMl9MDVjIiK8vRI+UD0MAcwZMh/F//a6wwDnDJMUI/smZ+XRsM7xwXCh5PkBnz64YatMJrHS9jaDhw4DQWJ57RQU/9GI9seJ/T1nl7feKdUoPb0VqvoRGeBpuFNlqTkWSiWjv69zkZMz/Poil9UCaYdzgj8wAN/MqYwU/tMqBVRer8zyjOU2ozehV/1Co+Z27oWX0YmVL+F4BRoNmcwcZwk/eK+tF9HAfvk1k81zlsMge/aM4hoRfNVT8Z9lq37cx1HTg5CxytHDLjlGUFTrzg3Y6gweHyUbjltl6m4FVrMtIRyerUcIznNVQEzIx3S2N8CbZDOmDi+t35zTU1x2V8d6TtbxaKUqfpe/qXDWCT6SvyahOFnON1upmOpEPIKPvBxheEp2/5IxU1tABgV/Np2De2i34lJ+w5e8h20l8WBtVbqrh7RaPzI8gZeMh2xdE7NuG9bqyarkWe3qFHyKLAKL/MGPQdXc5OFaBmC/hlbqsr4KHP0uUtKoxP75Np9kg79tjVhc1NZ/Pr6FJztbigv8sioC/asYYPC3GflSVAh8Crd8uEgB/zAYN3BRzYRc/AN5q0eIdbutRcvA9/xuYr6R/OzB/+zI0uo7s9w86Zw0abZHw8tKeb7Vh3fJKPYM42s/gZsnWyDX4Uq+TnED16v2M/5pEtgX+fVV9GgJqvE5zgZlvhwXzR1px8p0YJ/wcu8Bnbje5sY/HRbrWLP6oJww/A5/pB+27rw8/8C3xnkVwmDfp3a50x8Tz/Ah7BA7f8HPMRbCMb8NOxsAJb3qswPN+Vr4Z2xsJn8GDOYO640XoNLvEwO9uV0vDBZnlXY4+NMT/W2nEdc0ArY4ERTuAM39IHfFl06ZiJxo7y0RQ79b4jZhrc+p8dht8y1vlU5o3/1lujtKbR8JM58fnxwPLVwGAvgHFLzTjwiq7VFDzYBk5wuxLXnOgZ/+OBijrXyEQbvsl2xU/JPjzyNfxdzUXzwiNwl+/WMfP5sR94KTCMV+kdsPzMz0xzg+OCHMYu2EK/8oHwI/7ms8MDWaMT8AMfG48WaKE3CkjhPzzX5jV/V194UyDchhg4+K3WcuAkM/iG3sQr/KwufDj99IOMcn2R2xFf4XZsHbHZKGCCKVuc9FypbgQixbGc8kUQpGOVuk8ZtUuTsfSbUGxk7GqUewUN56lrjAxFTpAIewtu9QEEARhBhqwd2nPOGbt9boFTCpj5mx+49OmIB4UAXmMaO4fJOBwRY3GUOvMMD4Q2HBmDEq/gre8tfs2TMDPC/hYlpaA4HHADJgbU8xUFpQgsqCrIRAmAjQJkcLxj7I5qUDr6yrHS30/91DTXaiKgDRxSzhvdJtTOwTwCXbNL9LVfO3YZq7opZQpRWHBGyTFcHAaBCzD7jrHt7nmKDC2qPo5WjBqe62w4+NGVk4rWFJr/wce44iOOiD45RRw873czk8+9hw/nxqc03gJExmZUU95+d/4ZT0nNxffmA5Za9XlKEUeHIuNoxkn7oR+anDJGBe0ZVk4VeN/5zrELzJ7nwOIZTqk+3VLQ+Vg8IsDjGbgzrh1LeCVDFSzNwfNet0WgDR6Hb3wr4s8YghMPwzmcdqY1w8oAC3Ss19BG4ICzU4bXnJeMyeHHK2DoBhpwwePykZKNsqnwHxrOr7yGL84sozZ3Aq64Yuwhm/Oi0AwumcngwwG+IQdokjMKfxzQggrkWtAVvvxYEHS0CW/ozztkXh9w4Ids4eV5/RzPoun8mI5nwGYHmw4N92htBxEs6EQ2Cr7QRxwZNEvulhs9vF5m0OWX75c7QSx9kFOwzwNM8PfgB48ty4WVD4N2SAdMXA3oGM73fd/3jf/8n//z4ueZz3zm4kabn7C1f6R9VtBEAJIuIHd0Q0c56UByKDsAf5NFss+Ok7nf+I3pnDydR9bofTqAnrDgrT4IPcAOsd18CLJJfshX9YH4TOwDuSHndCKYNDLGBtI37cjTH+wRWwFmdsD43rXIsxFCt/rewtV3HY2lY9kwY7AF3qfHOq5q0UmvyIIxH/3pl58BXkeo2Tv266ST9i4CTdUF8XdZbX6bFx3Eh2Dz6DmLH/aa7tY/vIONbqtWQBtN5ko/ercaMP6WjUPHeh+ezZUfIxBhzI4As92O3AqIeK8shhZR1bYrc4RtWQ5Ss+8CAfBiLr6Hw/xZdHXM0qKQ/fE8e8dWCfiAiY2mn8FKfxub7UEb/FZB1m5kgRP4y7+AF7bEsQgweM9RLWPrhw3Gq/StAAmbaZOPj1C2aA1P8rvhFV2MB4941sIRfP4ve9v34PIdupAL9gQfCx7iPb4T3oX3ghE22TpChIeraxZ9NTa84rpwxS/B937DVX7MvOELsgMf9c8/QGP86Yrm+TH05fUImnVLnffhGg7RoeL6eAF/mtN6cWb4cSsRew6earLgK3MDM3rj1zaO4OZA9UfMCV7Z5vWyM81jPT96uaEp2tE15gCO+TEk/C8QtVHD121a0g14vw1BstulCuaW74sn6ULN2GShm7faBNdvgTj8B0f+J0/6QIP5zZ+9Qxd7h89OhtEMr/Cr4JSus0Y0R3q4Mfk93hfY4KvUfGcO+JEcVmQa3vQJz2THJnB1MmXT4wn9/fzP7y89AWbfk2+806UKdLPskqlG3Qb1KW7ndsRXuJ0aJYhJKpo2d5xrDH1RXwq4VDgKoEUHRSOFS3/tSHdNmv4Jrsir5+dFJAkzB0Sf6xUmwtiEAWMTlISHwTUO42NxVEEzCtzzFFiZApwD78m2eNCDxqrnUsT6oZiMTUCc9+c4UDbdQkP5cF70W3DIzrd3wG/RyrBTzsuRZc14FIdx7HbJ2ChlNyXjf0aA0gZ7V69xRjgT5kkReEa2BaeF8mBgGRpwUkQ/+7OTwfc+OI0RrkpLRhPjLNX4u1nrCA9HgyKbN0YOvHe5y9gNxwyY/7t6UAYGpeN98zO28fj8ORwaXKEpIwuv5ltqrzHs/qBtacfwgg+7khGtGQHKzfjoK1BgLP0UCNOMCx5KlQLnbMLhnN+rb9GuiLREu3HGVVGfEjaeBfc84ycjpcEB/vFORUHbSeFIwAWHhLECpzPkD3vY2IMWcMcQlCqMR/VjQS0ybrGsH/zIWeE8MVqdkTZnsopX8AVHRFbOPEPLTzsl5sJY+Q1+Bg1eBAT1CR/tMpHf+Y1A4DNX33Hw4BI9C17hyYrZtTM1r0a/0VGf5dbVisuOE9rDZRlTFX++6aaxm54xjwIp+I1zBMdkgEz4H33wRRkoeIwjYMeRvvmP/3H/rUDmzoHlQHfdMhzhT8Em/AcefZFZz8BHx4HwwDxYolVXyK5ru5p4E/xwhrYFoLreUctBNvZ6wSx6ab2i11ddNeGIMwJ/7YbOr5eOtscdN3bPr0E+TNohHTARKPnTP/3TxTW/giR+3vOe9yzqmHyvwhJH2s0afS5gQieyq/ienSX3AiVkiXyRaTqKPawuAttOfuwyktFuayD3ZI/8sLccdnqZ7OUr0NsWuxYO+vAdGCwQ6QD6tEBuBZvpQfaZzqHLHI2lP0rbt4ngGXqDXOYPWJDQ9eamH/IOfjra/Gyk+Nu8vadveszivJpNFv90r80Nc+qa4Usv3bzQ256jz9g4tgNu6HW6go3JjrH19Bib6bIkuJKF4X923jPtKtMd9P8P//CEM/1ZNFUDwtzhpmzJrkiGQ76gz/xm0/wNTvP7yZ+c3rERRg/S5TYk2hFe3sU3/4rX8tn4MvRyvqk5wjuY4LwaDBq6oHm1sip4j8bdlOjzAmHGtviizy0A+Q823vKluoUJvtAJ7/AJ9AN/aFSdBu90ZTUY+TXgKJNJ811HVFoAZ1fhgi8hqGQsgbMKf+Nb6gTt9FuB9m6nMW+wFQxkH8gQnioAwr9YvvnRHP2gS1nOfuaZinBXrRP47yaofIMPfGDLYt4bNfwh0INmXf+tgbULJjQ0PtCxUjgnc+QBPivEq1948C4/m02GIxk0t9Tyhddr4DLmejfyzBuexzP4Cd7KwhWAg7vkoeYZcje/QGO6jWjz4nM+S/52x5419PV/uIq3Nf6LQJRx8AWfScZetY/gmUx3vKkA4vKNkXBKNwnA0Kl4iZx7Hu/i19aW1kRwjtfME5+WuVctRK1MLe+CiV/aRlMFffFwfhR/ntygqULP3W5Kb+Bncte4ZJOuLSNpujHr0HQZjvgKt1OzuMF8lPx8h9dnfiy6CFS7wV21x7AyEBiNIBFqSkHak6gh4SmQgYEJGeOwbNAsRhhXuyiEc1noKCuFM71PETDYVfYGE+YuQ4awWKxTBIIkBW4oAMZBhshZZ40VcOnLuKUbtvvMsBBuu/m+I4gMCoGjfFpsmndZDP4m8Jyo9RpB5NAwstXD6FYYzhenh9Lo5hILf4a9q4rRgMLWDyNoLMaYkvN/i0BzoGQKKol2t5PeFXwWyBRWtVk2amUbMWbLV6/l6GlwxsEAI2Vt5w488112AQZ07aYf9KOcu9OdA1eBUs+jTRkFFVrTHzrBl3kIXqC/H/B0b3p1GvAo49VxLPRrd1GQwoIZLzJM+oUPToBxwIZWpWfiaU4GZxt85omH/F0mTOmF+MbfjuJQuJ2dLXAEJ/gcvGUAXX/92MKRpMzBwbE1R7SzO6lP8sYRLjXS/MBgoYAH8Sy+4VCQCTjgFIHdPHLcGagauaxA3XIQw04NvHIA0V7giANfMMnY+kMntOvmHTIFduP4Hy+SRbzouQoeHkwrm2q94qYVixNcsoCAU3DCNXzACxh8RwehZ7fYkGO4RCc6q3RO/CiQIHDkqCHe1C8a4t/5zULoUUDQb32gJZ0Bd8brPW2+W1MruNQ5ZbIs+IcHK5xWQ/NuY9LAagGADsuB5vUCJgVu9q7VGTAm58n8K1RZ49SY92HYDk3vZ9a++Zu/ebzpTW8aV1555eLH399kRXikrdvIAf0lmCw4TE7ojI5qklM2hC0h/z5LR5FH8kZX/P7v768DVUHAgsVk2PFSY5GTjqWy6fQ2O1KxyY6DsvNkuwKfdE1yR+75Qhb9/An6nn6ojgMY6GwLOrqMP9MRF/qYjqG36Ws2j721uWDOdFb14ixm6H0w+pt940fQ635/+MObF4tPss5eSJfvKln/05XmQqfCAVsHt894xrSBBG/8AL+NSW/AW4spOOBjwJW/y6hjb+G+4uRtuHQ9NN3FvtHRaMamCeKUZVIdDnPyTgtjtFo+AtIxYTg1Jvqhi8B3GQPeL+uEb4Wfuprags1YFmZ8BnbCsVwwgKUjG26gciQKLvig5moO+u32pI5DCVjDMf3btbpwADf67fYPNgAN+ARtVM6D7ngr/50dnNuXbinit/gbrrJRFpF42WK2I1xlbOKtbqozP3QzB3jmZxes8dn8hjoNvvCIOdnk8VtfaEAGwIo+4AA7fwjOyR1en04j7t3nu7WAh49sobm4Nhku4YrN7IbCW7qBZrmhNb8V38JPC2V/6x9O0NPaZnlTYb1WlsvclqJNQYp5wGK9Zg7GMaa5y2h29AQfmBv8l62k4T2fdXsUWnWL4PXXryxoSEfh3bJ0873n9PM/fWBNwUfmM843L31G3whQ8OHoC/Sqthv6daPSvBmzjPuuhcb/ZToJVsMxnVaRXfxlTmWK2YynCwuG4Jmu+G5zE4+ZIzgKXqIlmbMmE/TG53RIN0O5iKCsbMexmViyEp/xET1/6qmz4jaHWDviK3wRG2FgpJ3Nr9App0OAAFMJoFhcVzhQ6w5s6YQUVbU+Ch50JRXho4QwOEbGtF1Fh9H1W/2GqpwT5nYw5o0wSali4CoYSoESaE6CiGCCSvAJHOXOkaji97w693XXjb0MZIWFwG8RZ47tJPjOgjfnBnzmY74dCaDIKAkCynlYLjg2v66T0yZFlgKh0CyAOQKUYEeZKAJwMwhw07V9f/iH+wMJdoM5fBaucM5h0gc6UsScDYs6u1cW2nZlwEeJ65tCYCgpy66jrbVDX5uf2eT0zCPnlElnHzWOns/wTul5lA2ngdIq6KF1247nq5+C9t7h2OGPjjFpYPBDsVJwHJiuWYZz8+8GgJwDsOFbASlRZHwAh+bEWcG7duo4OPr7pV+ajAyaUtYyDBQALfMC7fAb/EYr7+FNtMBP8IpG7eRVSAzM8AdeeNcn+eKEog2D8pGPjE3eA1dX6mbUNDzO+WHI4dG4BZD0DZZwyCC5vpqM4mnwc8TAVA0XTnA1NwQS5ymecJpzVUYUx9bf9AO8gZvMoFFXCZKbnDlzNDYj5/MCsRxePHswld/xIjxxAtfL2tLMt8KHHMZuntJKO0d78HKO0K/6QHA4z7DqWucKFBfo8jm6MtzmgUfJMZki4/7uimh94i8yWPYK3OZYrBcwQQf0NRYcdyOHZzPeXdtIHyynOJMvOnne8Pp8d818OdvHHLMfl5weczEG+nKWzLOU6yMBky9+O/300xdBkuV29dVXL7470tZv5JXd7xYtOtHuMH7u+Ajep1PJos8413SURVq3abAr7I/gCV3APslUsTgoJZ8f4Rl+DV1GnuhC/kJ6gV70mef83WKOPWCDjMfGd/06e0i+6UXwsZt0CD+JbWdz6OkKqbfxUh0tesgGC51H//ue/Hu/LEA+gQWbRXI3u5x44urCBtJD5gh+utviwjiC3T/3c5PfY97f8R3T92wkPVV2bHWhwMF+saVsdgEfc6aj4BwuwJF99z3dTc+iHbtFd6YzzZ3PYwwLNvNEN7qcraqoLntlrmUb1oytH0GJFp8Wb8aHe/ajrBi6tUCzfi3G9A1n9Cy+4mN0vALs8Ix3HG+C1+ZWTTO2Ce+YBzi6vYUd9zeetVhD7/hFMwc6uAxwMOOB+a11xgeL56q1V6sujrH4BvDO12iBW80OtC6riX0GN7uavWTD2TF9G5udgLdqb4VjDS66UhtvdvsPXuLbsHFtvvqcT1kRZvOdrnndtPAx4NJ7fBl4gQMZUF3lCzbPm6fx5jelaGSK73eg4ytojZ74Dr/BozHB0+UOZYuZK5kzjwO1/LsanuLva/otI3bekqOyvs1XMNX6phtr9Mu3qEaMfuACLtvIQ1t8jE8f/vBdC5kxBzwJP57HE9Yytep+RG/+En8XvtEcHdBXAM84aI+PwOk9NOwY2LzhqTYwwcZ/BYsM/mS3zVG8J4Bhs6qbOK1nquuDTugsk58MowOdQFcUvEZnPE2e0RDuNOsCY9M/9JJNRfyNr+gzY/q+jcr0K1zKjLnvfQ/NgMkRX+GL2DAHw0pAMasFICHFLIwhpmLwKNDqImicbsaB8GFIzMnhIDiUAieiHX7Mi4ktVvwvaMBJ8C4mr/AYZcGZqBCW/yuwVVo/RiZ83QFOsc0FtMh2Bs8uR7ewtEgk/Az/2WePvV17q3EyKEcCXEVrjaBS4vBRWq5nfJbDAiYOS2mBtRY4cCANlQKCT0oZrPDvs4pcgguujKlfCglcFB/lS0m7U1wQouNN4KQ8GPNSTCnXMh+6scW4XdOnb/SEn+XjOOhnB8o7DJbxq9NQRgr6lZkxz0ag2NBG35xASqgUT30IduXE+MxcGWowtcMNZvNEbz8dwYADzp3fdgPQE107qlPGk34qjBd9nFMFE6fPrg+cVR2b4jdXsCgKKxtDxJsDg585cQIKFpUV0eOsMa45Cx2hqChZmRzGRwuK3zul/OIlc/Q3OBk766ALLhibqjuBngyUuRhHeqbjXsYADx5SmFgfnctktMiP4BOnn3ETYBJU8R6nn/PL6dMnw4GeAn1Vvm8hDqc5GfplXJo/J5LzYN6dkV6vqBv+F4jFxwVba3QK3OCLggxzR68GBvJ1S7e14E3zhS88PQ8CgpHBDE++b3dGxstctxmrdM2Cn3ayukED3o2FPvjkX//rKYgCL3Qc2Sk4yCnxU+CwmjDLu1TwxAkFR4Xv4LwaCe3W0bFg4gDhn3mWXvVHCjSTpQrf1roB4Q1v2I8fOocODzZ4+Z3fmZ7pppxbU53/S6Qd0hkmH/nIR8aedYRhx44d4xPzg+xH2oaNLqBv2R9BE7YHr7MhdA1b2e0MdCW5JduO9vjOEVQ2hp0ScKWjBENs+rDZFq1+l6lnIcMPqsaa7+hJfXTrA/8iGSN/dH+1QiyUwUOfsOfk1PEhuqGaB3QB3ULW2Sd6np2ll+hrMNILFhF0Bf1QVm83n3Vshk4ELzv44AfvXOj9rvtktyvizl7SA3BCL4JTvxb3bWyYY4X9+UDepdvpMjDTbfQRWwMX+vW599qs6/aWCniC32KRzkavjjOZKxr4u5tY6Gbwobl+y6hpo8Ez9Jnx+VbwBy/0eEckW/RVI0ZDHzaPjyrQ0k0tfAQ0Egjp+ApaTz7xysIvMzY9bS4VeDc3fXmHDTAH9rjjwHwbeMWHAgh8I3hFU++zhcvB9prFMJjwQ7a4Wwf5ONUGxKfmjUbGMSdwgjGbYAyF6fED221c8LBLcAhH6NutfAUg534/nFtPsPPeRzfzFiCCfzTiE6FLR5PRjh3iD51yyp7F+xWora6E+aC/oBl5BntFlz1jM2Huh/PtLHjx2oGyOuAaL5gzmPA2fsKXlQ5AH/Mns8sbFsvNHOELL4Hb+ObRRkhBpRo6yyTRbxlBbXhUuyw73NqkAF9XYGt42ftw2q2Pnvc3+TQnJsS84KvxKgqLL/kDcIrO9CfZdYQdHPCkPzzUrU8Vy41/4L/N6zaIyBbakFm8So+RGf4pvgl+8+Gfece45kMH6I8PCV7woTt9RjcZF89Yr+IJOspvcJVtRA4FmsBhbujb3+ZQhjmcpu/ZBHMpK/dQbEd8hS9AwwwdBahhcEzFkUh5MwoY0245hVdldga31CgC73uC1wIWQ2NsxoAQMcTdAEJZERBp4ww5ISE0FESpVxRQ9REYB8EFgRXjEjLKmWJO6XeOl0Ki+EvTAkN3nzMEFJ+xqovhM3NeS7ndZE5FdSvyVOS9hT2ccX4I3nQ//M0jtZSMOXR18LxR0AyOOTDoFA78MRoWwBZEYEsRwRdBruhRx3Y6L21xB+8CNxQZxeHIABjgrsCQ58HtM0qEEeO0cAzhyFgKnHVtXM07YMYvDCjnBn3RoyAK+pSaZyy0aXHGyaGIvYO2cNW1vzkR+ftgqkgdnAgimDu6mgfnAz+W3ZKBodDwHaWIz4zvc3ynL+P4nkKtWB/+5gBT9ObI2RXwgQtXRjPCeJ1MUNiUJLhF2zltFsaKtcrWAQ9FDH6ZK4IXHAe8LdhkLujXFX0FC8EtANjVzV2BHIyCGaedNlbwH+WOxvBZYTaOKycZXskKhxreOQ6ecVNEt7boE99XaMuzDBQeJIf64JzAtzmCBc7xCPqSE3MEP5kGs2ft1OBb86iWUTdKVERs3sgh3dAZ2Xmr/grc0Cdg46zPr27GU2A7mKvGa3hqo2v7qqMCT3gCftYrdEyefFcWWc+QW3JXvRO8XEANDex8cebIju8qPgiPZankxNfSVxYpcOVvuNdH1efBih+8j0YcGYExDjK+wG/SZwWFqmXSjs+8eb4g2rnnTrDgPU4tGaBz6RSOBbyjzac/PbZ69jBrh2TA5OUvf/niR3v1q1+9738/f/mXfzl+5Vd+ZdznQOcnj7R9jd21sBUMJhcVVXVEgIyyXficTJG5jnJywO1+0pOa3ccKl9KDbGJHf9kqckKG6Xl6kWzaiKCzyRqdTR/T1WwUfc1+0tN2Rjv/z76BkS2jZ5yzN16F2c0H6elCfkA3OujbM/qi2+guO7D0PdgK0jgebWFExxqDbtLX1Pfexdxb4NF3Fg18JfOhH+gANpEu90wFyH0PV4L5fAJj8R2NDc90e9ejwwf80T9gkcHp6C6dBTfdVgN/dB/44N+zaIR2bBBdCFa6MDpp4OZ3sqHVMamIJxwJRvjbAojtQfuOSOb3sI3dKMSmeQY92FFj0pf4qJvL+E/0qvma+yMfuXORfeEdC220xSfwxjdBDzZBUM337AL+5I/wI9C0LEO0qSA7HJrbsv2omW/1WMokKeBX7QoNDdAvPJkv+Pi8AnDmXXZN2aEdZUIHdCq4pg8+kLHQLr+4o9tlZldI0zzYMnSxgdDmCzyiE3tV0fMHPWj3gif5MXhP3+SV3yoAkc9Y0f0yeclTdrsAE3jIRrczrtf4M+SXX1ndE3Oeb5628Mcf5lVgDZ/A9fJRFDBX9w9ccNwmx3KdndYIeLvjwekcfGK8ecAHD+Fp/GROrY3Qim7p++VWAA/euw3KGsG8yv4WdINbcBhfQBMsXemN/t7zmeeqJVib1zGpyDBYCjjCJx8HfsiMZ80Pfj3jt2OVfvPXBXXJmLnBGV2Qn6510yRdiGcrydARbrjgS4O7m7psjuIlsmcMfbZRTYeCjyzgs41ueLo92xFf4QvYKLrpfOX+2h9uj8FcFJsfSolyxlyEu2ttMShlzdBrghAca4p7fl6Q8rT4EvXDfIxlu76YkOOgFR0mtBjVb4sOQs5B97wgDkXIIBrLtbjzBRplQlgwP0EikCKgFqwcAsaZ8fG+uVOk+iVYFMZaJeft3mGECTUBJJAVQqOo/Xjf2OAmXJQeQSR85tUiaL6TS4HYOQAH4aPo9Ekp+gG3hbordWv65LRxUijfHJ2uODNfgQtGxM4GGnZ7DyNEMYOhApPRAQ3RqV0McDH40vE4k/5n2CibrhcGi3fQR8qa7xkTz5g//JmTOZjjH//x2E7RV1m7OhFVkwcXWsAVvFFA+LBsIThBH8aKErVYZcjRar6ANna3vqTMjcmJkgWAThywDCT8VAG7oIB+vYdfje/9juSgG0PQbg684s+Cc/DA+FPkAiLtOHjed/jH3fTwhN/RhiKHJ3ND1xbQnER8jxYUNzhXVqYME7B7l+OI/ylvARWOPGcT7jib6NRVt3BMnhkf41RcmSyTawEkP+jC4XD+vOuh0RKfmqdgDhg5NOQJH6KjQAkjw5EnM3gRXAwdnll2FjRjzwNyy8135kLmuo3AO52ZRb/Ovq7X1nMe1ztDu9zMF70PdLphnqFSq5I8nVetJjQAP2e8mwEy7PROad+a4BN+L2jYgsf79JU+yXwOX60zx/iYU4OudC3+o7s5B3QV2egIDT2ChmRaQ1N4xScnrN0qQbbJXbWC0BnNjcEhFih+yEPGdrQ+zNohGTB5ylOesvjZtGnT+K7v+q59//t56lOfOl772teOf+fqtiPtoBqe/tEfHeO5z91/nAZvk3uyKRBQtii5qCZGNX3Il7/JUYsdeopdZcfoRHrdznDBEwEBAVT9crjpL/LJYeeblA1CHuk/foV++CZ0IVsGBrLI1+Hf+A3WsscKytAfdH16TH9sCRg8r9CqQD8dQaewJeS7m2o6erxjx6ZFgIUP0e0S4KfPpnT0Sd83RgvbrqhlI9Mt+oTrgvt0Eh3Eh2OH2DnjCOBU847Or84UuNsQ0dBLMIhNt9iy8QFXfhc0Wi9wAA4+LfzQZebsh75je+npjkGjtbHNg/41JljBQFfCkX5aKPMTPFP2QLXP4KMbgdCeT2tMOO/63QqH+rsbFdkL8OiDvS2YA8/m0q1AbMm8ntW8mS/eMp5AU7cjrnfjHD6GT3w/t3Nwxzb1Dr7jq7WAr6Crv+Gx7KZuNURLz1fstawB+IAjeOPr4Qc+VFnLZQOgO7zA1VVXbd6XkSuYBO/kx7tw7v9utpvLO74lh+aGBh1dAjt4Oxaz3HwPb+wzuNtwI+sCkJp58c3wUwGPirx7B1zzUgLwL8ijoannC5J05EPDg+iKdvwva59u89L8hqeO5fgta85Y4FvObAfLPIBR49vCfzdDwRe/BZ92HE4DR5khaCsoaR7kBcz4Ek7oAms5+gKvlAEDj/hVoyfRAkx4g/4sMGOOgov4n+ygJZkuA9dmcEFJMk9u6SN+i77sLfib7njZyyae1BcewR/ooV/+Kt/SppQ5yDgHK7z7H2zwj+/zvcpmWb4m+VBpR3yFL1Dr/Blm6B52woZBLNxEXSllO5aixZwEwkbpMNaEh7GwEKuIEwbGvPPINeZjmAlh10gRAIU1GfAYsSu+MCLm5mwwbAQ5A1rl7O5Yx7gt7Ci8gjzVBfDjGTVOjGkRKfJJSDTCBiZKsODDa14zbmLUfUbYPEOYq9QNB97vqEIK0MKGwqRMPeP5+TXK8ObMcGdvzUvwQZ9lQ1AUaNFxls4PiviWBo82nAIKUZCK8kILxqVr5PxN0TGOjBhjbKeZoUgZw2kF38AML+AzBhrAJ1rCSfj3OSPQMRKZFXa1wMmoK75LCeIptH3Sk8aKOXL+GBLjFKjgdFFe4PM8nFrgwyE+QI/Or9Y4WujF2KE5/MKjPrp6EbyliOIpgQxKDr8wui1q8YMItZ2rMqF8pg/K2JzAjj/JBBx03rqIeE4y+jG6+oFHPFNNE8E384JLY6BPVwD7KbUPb6Kx79GXIZWZ4Dq3b/u2CY/oS244scZnxPGTYAyZMQZnAVzVauHcOf9pnK6QZmjBXNq3hmfIOHmCA0UMfRa/dKtPRRHJ/gtfOO3W6tvcfI+WcNeVyWXC1HyH/usZ7hq9ZFdLvxb6DG0ZZehc0a71GnwwlPNz6gcTMOlIHrwvByYOpqF/jmApvBUX5kzhi64m9jf+JPNoDU9+k0W8gC7pRvPB3+ids6HRN3DpNx2Hdp6Bd7qYbLh1SvCzekYcCZ971ph/+qfTosxndNjJJ0/8YYHQYovs0Elkl7yQW/x11VVjp5T3w6wdkgGT1dXVxc+97nWvcdlll+3734/jOOeff/74p9LjjrSDbmTKD7lTv4Oc4H+bMvwbvE0+LcrILT/IAoAut1CvsCTZalFKBwpsCCjqu+CuIKaMCnJnEWJBrN9ukOEbsCkWRH5XO4Hc0RcCHJ73bLUU6CqLBIGEshroRvKrPzrH+93g1a0mYO14n0A3fUc3siXdAkZ/ldLeUVD9s/10Prx0BME8LeboeOPBgXkIBIFDn/6mr/2vT/W/2PGyPp///GmhBQZ+lY0KMHWNrvnxXwocaxWH5yvQveZi44qPw652O0zNfOBegIfvQq/Rw8bT4Nz47FK1E4yfXp3vJrMVfMwKxcIZ+oLH/PWJh/xma/HA+9+/dcFr+EzQhR2lf/XlPXRkO42HVtmSro01vr/bFAQn/6YCrHhxvSyJMjQKhvCdCoYsn+7zLB5ZztzsEoVus8E/smsrQGsB2rXdGp+noAf6VEdHwyNlSPLN0MRPGbcWr+AUxCOPxvR5/sK5525b9FWheTxIVsgnPuWbtIlaw3dwXlYCP2XuVxrfd2AwV3Oat4rCkwFz+93fnfiabx7Ou+q4TREyZK7erU4G+QwPlR/oSDLbX/FVv/kN+K9NPc/CQTcu5t+Yu+fYcXzCJzd2BZ7nzfzWu0YZ38M5GKu9xk/Gr2BvjuDwU8kAuC7AZm78BnKD3/gv/IQyr7Q2aNHAmL5HZ/rDeBW9Nk94Q3dzw5fzgvpo0S1g/EK6Ay/KPqHf6G6+IhrTDTYZOz73K78y8aXjxfikWyGNAcfVfKSXyJc5VuS6I9Lm1Bp3o6zl26sd8RVu41ZNAApnuYo1YWGEOeYEA9MRml/7tYkxMVPHL0Tw2vnvLJ53Oeycb0qHUvDbAtui3bMW+RiZwbDwmzc75Rn0Cj21q4FhGX6fM3TGZlwIRFkglFiBhZQgx6FMD/Nr8U6oyo7QB+XmOe8ycu38E9rSOxMiQj/HXcqL4FEmGZyKL2lwQBHAP2fFghQu4Y6xZFzhuCNOnuMsmDflYVzGA24sfLpK2fw4efDuf3CJ+lo0OXcNL4ScE8Poifwy8vDvh4Jm7M2B8oWXqlebL1hL4Tdv/VZMahLQycERkbZrZScLf1TzxffgN/cMNKWYA1CjmMDejUTwsZ5yZxTQ3bw4RfoGH0eE82ceYBTIyYDr0/+lTOfECABxUtAa36EHZQkHgkelTXa9IPyTCzQzB4pfAKtjDvCnDz/4zHjwZz5gzhi7jhZNOFqexbNwjr/xLF712bOeNdHq3vceuy1gFfjFu2juN5yTT8+hPSPmCI45VINGsA0P40ljcRzMFVzomBPECc8okWNzxlc+hyvBGHPvtgcp0b6HP8E5Y5AdzrHP0KWd1woCM3Bott6tNus145V9BG/mhE8OlJ3S9cilfsZznevdqOWUzeuWHCyMZLL03Bzgrgn0PdmsICsdmpPuc3zcjRr6gOcCfRq6whs+oK84iPSqXTVyS9/MM66M3UIFDdDSO3gDHcgCOnOEOFfgod+6nk/zXcFgegCf4zP8zUHCR/pcr7bMl3g7JAMmtYsuumicdGvOoR1pB9Xok4IQdL/APN9E8JkzL1hB59INHHV6mI2h28gm2aH36FILILqePvmxH5t0lsC5BZHANae92zumYqCT7JP5CnxWR8mY7AyZ4xuR8XaPySoY6Tm2pIxCc6EDLRLoPH6ExbtAARsGZvMsSGos77O99Dyfj8yzL3e8456FrTMWvSHAQ6+BS5+yUdVvMQ77xV/QtyxFuo6OoNva2NBvwSG+h7EFS+ALfrwHJ/QcX4zO6hiiRvfPj3jSdfBHz9Ht5oMu6Ffds1o38PiMfVS4F6w+gzfv64f9BUu3AfnN3mUnwW9B63/2E+7A0c1zYDA2n7LbS4z39rdvWdCtwAt7jjfYYgu3jgR4vyxazW9zBHc6uSLueAbM9PCyfQMD+9sRdziHO/63xaP/O75bMyfPF6ypsRvmCXYLRONURwsOHFvGo2QDHuCsYvdlObCt+m7Tat7A0HFf76IJeeT/gUUWLd60FnjQg3Yu/EbP4XE2k59eJkibM2iLdwv2VNumRfS8+V52D56W2cBv65hL1x+zkR3fYbfLkFjOMjBfgQlyVK2zaqX5ji3F2/ObJPn/bYDQH2y3YBofoBuUvFMhZTgmI/SBZ8Bv7uxzgUk+5PIVxV2XO29dad3FCdXu0dCv4rvmCQZ8aJxOGPiNb41rTuAhr3Dl99qlBYvnPMOP6IbR6q8YDy/Cv/niEXxNl9Ed/p7Xd/O+jU40ESgFH7zgPzoar6E7+hifH+/3b//2pP+6qKCsXvwMNrSnY8icIIxgjr8LNtKx8GOOcA8/H/zgmlAeYu2Ir3AbNApLJBYzIDwFVZGndv8JAwGysLbrj/ExokV4AlidCM8RIoZTP+08U1QEghPBuHAEqlfSXeMc+flxFQ1T6pcCsMst9aoMiAwZgSVk+hGNxsyUZQXUGBLMTxkJEhSxp8TMt4rWYDdvQgpm3wtEHH/8dK0wxUhRUWb6795zQtZC1zsUajsShK/bgDRCTrg5LZ6nRAm0uZm7/jhROShd1drd6QS0orEZEXNogdZNOca0QAczevgeLc0LTSgXCzP9gqcCc/6HA/0zQmXIdMY0JZiP7piOv9HFOx2DAiNDhAdywuDlbW8bOzkDlAslXiqh/j07V4LoAdfwK1Dk2eWd/orM+g7OKGTGt+tfKUp9o0XRdUqzIsRo3bEOOKKQy/4wrv7RCfxozEGEw4JynmG08bJn4aybbMBaLRoGtWshjccIBA950A/6CjjAJ0Xtc3Ik4MT56ViR/j760bEbXtGq2xZE0xk/c/Ys+ajI3c/+7P40Y+9x+js3jcelPePnbmAozTJ8Gxee0bRrBRl/vFZAET+SrQI+9IRxLATIZqmW5g13jvoJEpLXAwU85s3cvd8Z+QqjaZwazjFjOF+4M+wd69Pg1K5vV37Oeak6ReSAI/m53M4KDjhMNy7fdhMu4atCkPAKdwVZHKWDMzSCz4qyzR1fMKIzR9/xMnzT7i9HR9+esdNEF+JJ+rK6O3QH/qGz4kX4AGu6Yfs6tw3hZQu6bhtDA78f+MCx5zC8mOWQDJi85S1vGa+gJGbtj//4j8dpp502TjnllPGMZzxjkWlypH1ujaywnxZNdPr/z96dQFublYWd3/cbamQSKKCAUhBMQBRBBUKCSAIdFEWT1u6VNKuNhojDwkgQERIlUbSJGAkBVKI0GhNs49BpTZw1cQAMBmVUDCjzTAnFXPUN9+v1O+f+qe3Lufe7VVRRVR/nWeuue+8577uHZz/zfvazH/7wNS+wITqOIWhCv9OHNgjI7zZnOmJLr+NVcpJ8JZu9L/DimK226SFyttvg6BcBCfK6Ixg5YclQwF7Cy3QwXsV7ZIhnyZE2eXxGHtDL+L3aR2Qux8JmGDuBA0z/GBs7o7pb5Jl+OTGnTu2s5AodQDaRkT5n33VTXUdOyIWKYJI3ZJAgDbzRU+bhe31Xs8QGCzyxC8kk84KHrro3N3IcabMhOZ0+a6e7a+sLYljH7INNV7RmG8CDdRD01x75Bi9wBF/mbE5zpoL36E9rm6PLYWezke3Wv2xAcxLsqYj4+uaX06v/ta8vY2hziiyvfoNnBZPYMwVpjMt6W3v2GxvNOsCrvrrMYHbe0aHASFfSy4xgj+sHHukGuiP68lzHagrMBHDbjSrshzZT2Q/wrF9zq94O+6XMiGCm5SWYExzI2jI+Y+iGn7KG2V1+f87nnF6tMxrUp74850hw1x7TmR0777Y+f9N99NgmqOZO5QO6qW8unGq+eB9doEd4z4YI9MMGEhiZs1iSM9V/SfcG+KFgRutd7Txj7sY99r0fcqKbSNER28uz0bi18v3MA9apY1Xvf//Oii4EV7PvfY//OqZvDap9h/aql4Q/usRDn2gAnzqhUMaFNtmEcFcGOB4hG8zNmqFJz8AhO9V8+aeeM84Kz7fBBMr8blNOAKZ6Tp2YkAFUZjhc2zgmh71XWYay8sk+9nk3CbWxay3KOjY3bRuj33DvHe0o5nxjgq2tcB0CIY1JESxHQxTY0Rdp/girM2yUOOKl2CgBzIwBu1UDECoEMMHgXVFsvwkJxOo5jigmX99XfXXRpIIim6CrUTEzQeFZzEVgcyQwp/YRLMIthav2ELf3fEdAEp5F3kUdq9ZO4HFSEL0AEiWlzzNnxnmEA2GAYbQFbxgL3rRH2WDiIsC+I8Q4ZvA0n0fUFmFPeQg6GReByxnvaEa7w+bZneKEszkLHnAMrVVFm/SN4bVp3gwZO02EGRxbpyKp2i5YJIBE4Xuv6t+dmSSYMgC7MhGe4BO+u1JVUMP/5lm9EZABaH0JFvO+xS3GGYKI4KJ40ASh1Y03y+g82iTYrEOCl0HWjhvaWF7PHJgnOjD+HMKKjOlbcKZ76SmEqtjDrTWwjsZctgh6MD9rTkFYQwYgmtAuRVTQax6rNex4FEeYEpbCbc6UN/qxrmgGvfhN2Zk3/HPa4Y8SEbSkFH7rt8ZR7VWJPEfZfNAgPOKZziijAQZbbRirOZfijY+MI2O/++ZnQF/a1Q98wHsFodEZGoPnDNaCAoKMFRzMQGLAoxf0ywDa7xrgJcCZdTPujs3pS10c49eW78gh/+NvP3Did4XmPIePZgMOnvigcGkNMryuCZBt2scTFfY1xplGwyPDoQr6aBXPBvFQV5J25rfdMfzjMzhAl/rpBgcGmCAL3D/jGWs84/sMeDhkgKExuAr3+I/c77rxZXDyxIk1zvSdfIVPR8T2UtGP3BjP8H6CcOOyfvbge77ne8Yf8xD24FWvetV49KMfPR72sIeNJz3pSeM//+f/PJ5mq34L1xrIueUxP7yNf/wW8CWDs0lyEvA3o1/gHVS/wffz7n32Cf4jL8pmwH90Dt1Mbs2Or3fSW6Wsl8Xq/YLReLljBnicLqDn7ZDSPwIQ+iI7cmDotDZ42pEmSziexkOmqGGiHXPpCtBuCyvLNh1K5mhD/10MQF+QeWSTvitwS1fQQeZHR7FP6BTjgUvy0XPGTo+5xY4N6jl6irymAwQsujmR7aBN7fi/bIP5Ji86S3v0qOBS9gh82XxjV6EBOKezZj3lM7qv2k7GZ17w2VXP2qJv/e974ylb9gEPOLkKMqAfbcARGQ5f3vUzZ14afzWt9G0ubWahkY4SkMXWqNsEs0Xg3br6Dk7g0gZON+2gh7KRgPFsOo6DttLz+mUXWyO6j67RLv6gm9pY1Cb8VicLdGPKJrCu9FVHN6wTnFXHml0GN8Z729ueXukhY/GcOnBlvbJZrX0XOGgD3owL7tDQpiL0AR1oHdoQwpver9gtIIa7OYjP0y2bM1gDa6vPJeBRASsyZAa4hC/vaps8sFbm0e0z7Mcy4aN3eNMXeoOjNlPNw2cyVbRpLNWrJD+uuOLIyvbzDBruSvO5nALA79bbmLud0w/e8btjw/kE8/Gr5uV7a9WtVGiI/CIz0IpAbUWE0VFHHb23rGVu/eaNGviUmcafLRCV/0WeOW7JPtSO9vCoeXqm24HgEQ75Z2xywTL9ky9kqDXI3oVb73mG73v8+OLs9w0MW1vhE4Ai1EECm5J1pIYDiHEpTQxAGGAwCpOBTbAirIo+dTUXoco5xriIybuEMaXOISWYvEOxIljKN2enNmfQTs4E4YmZuuaOAYJACXjjNAbMiWAxfoqquZbSVdaDObWrSsCVKtd1eO12EDQY9iu+Ypxu98Sc4KdUV/Msaqx9bbbbUIVobREK3YPetcyEA8b13Q/8wNpJIfQIF0wpsuoYCPz56aYgEVQOnzHBL4dUZNYzBI/5EjIdmbATJQtBCm9HVxJGKW8C0u6D3SWGTWcICcfSF/3dWWUKKKesKLjntJWC7Xo8eDHWvaNGu1Vdt2Z27ghH/1esatO5W8Kre9Mbg/mVLjwXqwwKHqDtUj4zPtEqIwztqUtTcWLnGO2yEYxoHq3ZYSioAb+dwWXkUljoj7GgPWOiSNCe73yOXihuRpmx+HEcSCCEMeEYBHw6RsMQFXj0Y66CeOiya8zQDpy9973jSFcJ27GrYJnnCHa0h44B3Ha8Sh0Q8+HMV+lfO2iZgWisHTszV+Pyrh+4wn8+z3AzXrTkffNCn3gCncGftrsS0f9wrC24Qf/Gf7Zr92ZArznyFK820T5+gAPrbSy+K5OkrKWOksADXLbzF1hHdF/gGJ73C+LuB4wQ/E8m7F3/vOpr3llCi8bdjVxd6Vjm0wz417i7LhSNed6aGj+e7tgj+c1YRWtwBK9olEMQGFtFCbWFzvGmfvCzNSHnyFW0vDvxova6oSye871xCIDf4hbj1DK1+RyAG2XA5OUvf/l4KCGxBz/90z89HvCAB4wf+7EfG49//OPHs571rPEzCGIL1yngK/qZ84xP6HZyFo/7KbCPJ/A23SawjufYSQfdotCVqHiZMa4P0DWtAT3ZrWoVHc95YfvQgZ7XZ3qtI7Ce84626Xo2BhlJdlbMHQ/7nqyoLgW+1+erXnVspT/pB/K+oxPdNmcM5l6tCbqy60u10TETeooeor+NCy59b26yb7VNLumLbBT7q1YSPHpe39kvCsVWP6ygRBt59AHZnn2i/Y416psj3+03bLCOodLxdC8Hjs3VkcjAOvu+em0VyQVdOcwBRSPkbHXEum3ysst2V3giy42DrPa7jQDPzn2yq8zZXARhqk8xH51EK9WEK7BhXuR0Nx3qj71L1xtvDq7+vIeeulrZe3PGBBvbmqAj0K1NfndrjzbZLf6OX6x5tnZgLh3pBW2c+W39ux1QfwVW0E/ZwAII3TDne2My/4JVve8d+jynujbhh+4sC+NsgEfY2Pk/jRmtte58qWWtHOMQuLBZxg7adGyVb4Mm2ODN1TjxoncCPNFGFr7yYz07yo5W4Rp/kDV+G6P1jtfwGF3PzsGj9Pm6KP3plSwr0xWOO96zBPZMdn4bsnDShQcdWUHT2hTQDIylq8Ed3fYeGoFf88fDxshHsnFdkMu6o3fPFtTzWTVoZsDDcApX5q898kw71deDm2QE2iybJNvXvEoSsL7kUJd+VNwYffsfLcIv+X+rW924AiZbW+FaAkEie2QOmlB2lBpBgKBE5jggOabeQbiEMMFjh7FqwgR3xXYQ0r/+12vCQVwM786LIkJESmATZBRwhbMqasSBCggcOyAKVxLE6wJZV+9ECBD4vFtcGCTGT+lxyn1mDAx+BoH+CH/GA0amFBN4HAwMh9D107W3BC88ePd1rxtnMEhXcnUnOYEGTxhyvtNeG5itgpEETlf8GqvCnfAp6ILh7GpzoDG1rA5BK6lsbjeROmZNCHvjZ9wwwuwEGx8lbIyUsLnoT1BHmiAHPGUIJ9YIzigWzA6fnClKg/Dk0BPandF1XEIf/ocPjjEbnaC0q5yymJ1B8y5907wrSqdd6a5FogljNGDN4MK8zMXPpih86bSEKeHYdWeElPYFnMqMQHfdHW8tOgIBzINRWACk22zQK9xT9HDZmWc0USCs4z+MButfO+YF3wJNnNWyAowDvZkz+oBPdGxnDVAWaJmSqJCu9/VNyRoTnOsXn1lXdACvj3rUOAV/+M1PuwAFiaytdghzCmq+JrwdUvgqq0T9C+uMxgUf4ED/1g+/eL9zoB39AHMRN30ap/60jxYoGcZiNw9Q7ni0axK7PegwYKyz8q4uifbnXTDPwRNesPaUNRnDqNRXARR9ZyzBMdqCk4qOMbyr63IYsNYVAg43eGqZqdOuMXyg/wr4cQjga4au3m63D/7MqfP5eMlcjZPBXtBXvxWUnHfx4D3nC5/pFx9Lq+5sO9rzDEPltdNuGRowFzRbwKTUf+1+9KPjOEPsHIMbZcDkfe9737j9lP70O7/zO+NLu15udTTgfuMty0qFW7hOAJ+qj/XMZ16t2/A8/iTT8Cr9QEeR7eQoGU3uzXJ4CelYfE3PzMdTuwoVdMxl72jm6jkOfbu46QByT3F7utXYulGFziSzyQ78TQ/SlWS+z7SLzz1Lx9EB5AEn5OTJ9bXCZJc22V10M7uQc0RPkmn97V26oauYyZcKwuqLbtG2wAygX8gW+tN7ZJd5lTlhrtpgS9FZ5K05aIPszK6A87JQjY/tw64zTzKPHez9Mjjgw7uNewZjXe6yA3IYiwle0OvZCIC9x6ayCaGP7F6gLfLbZxVwXdJBV6Zu0n/sWu3LUkUX7bwH5LG1hsPqK7D7su1mPQpvxowmrC870Vp2TJv+6dgo+jNfesGc6Um2q8xourLixaD2zcWahpcuCUBjdC17ge3P3lXI2Lpq0xqhGevSNcPd7Ijmu77Y2mSDGqsgEJqc7Qq85/02YfFo9gz6ZJt1Y9xB0I2JXX8LKnoesH2WQdFs1oJi1TZagvGbD1oKshOiZeuZ2Ec76MsmGlopGBCOrbd5Zy+zc+hu/hp6sCbsfwFENGmd0BP8CjDhTZvlB21ooTvjqAA2fq1QsfXqWBZ6zh/UnmCFsejb2snkwA/Wil1cgBmef/RH17yKVj1PphqfdcdjHUGcoQ0rdAXfcACHaA19zD6LORiPzSf+DZrrSmw8gYa7bdDaGDfZWh0hdKE9cma9YXfjKuS2tRWuJSA2RJRRjuC6dQWTqJUgokd4EKyELkKgSAgJxCmQgYkQsYAGpsQwmI0A1Y4oIKLTLkbojDuhjKAwD8Ys+6LbUTA5oUGZEcBqeSiGiUg7S2c8hBQlpJ3Sws3JdwQ2oaJ/ilnqGMJ2zt+81HLo3HG70xyHougEiECGZ3y/V7TrSMdQyuDgVFJc5tXOSFkyBHM1JPQPfxWmJNgoHLvXFDiDxLvt8nfNl+CHz0u3tE52zM3JfCrERZmYrzF5XjDEesAFhtcXwfdzP7cucGRMxsDJ9L1169xzuyJdg0iod1Wt9wjZUiOtT8exltlBQUZjdvu8W9I5XmDchKH2zandhRngE73qs2h+1xJaQ0YfgxTuCFxBDfjtLCLhK8BXhBiuZWaI+gtIEYKEo8BVAR+0iQ7gt+KueAJ9ZNRQDpQgWpENBJfmloPeDQdVphcsqSAeo6Sgo92+riur8r/n9SvQsjz7etll40hKF22gZ/ipLkznfjsewyGu6BVh73PztyZqn5iPufphkFZUD5/BS5k/jBjrCkf6tW5wwtAyHw5zBcLQKYXZTVeUIGNf/9ahFEhyqYKsB0HHjmZgrNUfQKf4BG9S1AwKgSyOCF4zlm486maYyy8fR9EoPFmHpzxl7TyAzodvAjIwQ+agivNLsDbtdsEvg9Qc0DX+a13JNTIHf7Sr4vsKJLcTCo8MFQZ0GTOMAMYGflreBERGGDfD2DNkAZyRVfAggOo3+n/ta69OzQ3/+ut6TO3QAfjob/yNceba3CZ0I4cb5YwESxRxAydOnBh/9Ed/NP4a5bAHH/zgB8fxTfddb+EThvQWfiXPcnjJMrIeb+agWyJGeuf3BS8Y8OQTwEeMf58x5Mmpufgj6Ea2HDE81q4noL/odP2XOUmm4F9yl6xpZ59+oXPIFLYMO8M75L82yUPz0T855Dm6VCzOXI8d21ndKmFM5uh5crXbdKpXVpFGQG7YBDJe/cCRebMjPVddrQpVVuSzgqjtDDcPMp1j43dZpwIufuhX8o6c0p/v6H5joBt8x0E2Nno2WdsxA+MrawbkRAbdtKidbvXwN1artg3oKtxNLDgXY6VH6anlFcDGMQe6jcOa+s1On48gzBmIoMsArIPxGS+8CqLDqXnTI9pCc75nv3RkjE3leZ/Bd7c+pd/Yk3BfJlJHf+mjZRF1n+MX+oN9Zy35EdoWlEPXshPZFewofbPjOq7PhrGOOa/G/RM/sV4TY1/bUes0AWPvSJM5hRP4hZM2VgVV6PouaegI1WEKlrON4vfq0M0BtmoRsRm7TRDO8bQrw/XP7hJsZffMgS52EX8JXc2ZnfORPLw2H9PqZq90NH43n+omagv+rKF6MGXVtznJN7FGeEOx0rL14Z/8QNPWa7+bX9CtvtGa/tAWPLMh2BV4Dx702ZF7c2B3sp/YWbKZCsCSYXiimn82jD3TMR2+RzdSsfPZMDK1NwWiBbWtlXesAZq1Nl0PbgzaMaY50Id+9A0Xnu/WVD+VliiTZq73QvZMSZ83GtjaCtcCMCblw1hu19BvBCBbpGJkiLkjBaLIghPdmPLd3z3G93//+jkBg5wcxIghEWSONCWIUD1DOFGYCJPg4qx2RS1Cr1I7p06ABEO0w0KQGot3CHxMlxCnII2XIC69T78d9QEEF0ar5kq1IoooU14EkggmIZ7CJJQovb3iqEcJFsaF/rs6q7TU7iA3JsLBnPTbcwlO88BkjCJ4EbV0RIKTJnta5JTzCYcEiDF41jsUAZzZScKYDArtElQcXopLWxzIIut+w1up93BgDSikjuGUMdTVia73q6J+158BAhSufEf4Ve+FsvPZpttG4IxSrMBTQi1hjibNgVAvVbXgh7Esj+Z0PXCRagrRsxSPQBeH0bp6F60wgKwRx7hirNaJIZLz7P1SeWfnF84pF+M3Puug7+qcaENbBCwlRbjCrwBTBYrREcFsnCLweIxj6hltoIdv+7Y1LnzXjkBOsffRiO/nIld7sItGuloXb1NUpWQmxM0PTWlDn3gjhdtVytWB6QhSznHgXTTHCPUuGjLWUmeNs1tX0HKBMe101pcCrfhrt0Aw2LuJh6yZsyvQztKAgZt51xX9wKv1JgMYJf6uvkZHAAWH8G4ZEhSiNfUd3n3pS8cFdrYEzeadCji1fvPNCoF+KNLOZKNV+FhW+98Pom1jJY/QIDA+64hWGSqdS4d7n1W4sUJ62qnooDVEk2gAXhln2k/++A1PAn5o1e6zIB+elyWV81HBQXDJJeuAHaPGWjOc6AvteJdMwndw/Gu/Nna2t+R8cuARj3jEqlbJ7/3e740nP/nJ46KLLhpfRODtwStf+cpxN4J6C9crkK0F58kb/N/18ewO+rrgBBmKL8meAhiCKeQMXUQXd9U7uwOQtfiPHF06BfiefI/n1kVZr76eNN3NXsOnZVvqv2y7Ciza2dVHRVM5q57PDjEf+uOLvujESo5om26iL7z3j/7RWv4iuc73tzPdDXtkRvLMOOGEfdcOfTfWlNouKEB+dfSbM01nVXze33DPjiE/yT3yitwrwF8Bf+3AL5nv/27M48QuE7G6qr4bSMjCbtjRHllIZtPfnPxubLT+bR51DGMOZMxQm8Daz2Oo6Oz8GTvLfOF3uZtOh83HZroVjR1JP/nxfbdKsu2Mn93UkSk0x74xP7oEPs3H+qAJa1sttOjc39XaAp6rblhAX1dbL/sN/aCHgknozVzZTPijm4FAwQNzhwPBEvhGr55H24psWlf8Zf3LkrSOc/0SNGCu1d2hzwpYwOFhNm2suXng7Wy+JaDbH/zB9TPsGnobngW6/Cj2zC63Lo6Ds3nNDR7gKns0gG80gW7hoeuUZ6C7fRdtaKPs0aDAnzXBs90kZSzr6413VnYc3JijMXQ5AJpHL8uNzDYHPVMQC39rw//V99AenuZ7dPMl/jcOP+jRePmabMVsGmtpbdiV7PguIGFr2ryX9VHtqKBNQbTkNiV2reBJm8PsPHK5jWc+E7srmVztJONnD62P2Vz9HTmIfsk39ny3PuGVZc2rGwNsbYVrARQmJ1LmAOaUcYCpCQmGOWXAECbEOPoEp+8wlB1aKY7Sm7ohgQHPCek+cgwrpQ7DIyZCCVMgeIKN4NAHodZ1bSK9CqfZdSljApFynO1UC7IgWFFXwse4jQkDag+xIuTOavrBfIQiJ0AbnA8KgqDDEARxu96UHUPAZ5iHQifc9GeshDvh8ta3jl3fwyGhZOwFciok6YfCplT8YJxS+jMOCCDjYQxh2N5lMDBc4NaY2wFgjGH6rnHVprWSLVOWC/yI1FIMBAVlgpGNhUIzfv0TuOabs0XoGJ/3KSgCQ+DFlVzGTMHAJWGFbqyJvykq78OTOVQMa2nMMeIIGnSCBrSPTq64YhwnzBg/5muNrT38Wgf9WluGJIE4w3xdI8GsfYIV3RR0QFNwiVaMF37RIiFnzoxEtErRzcWjrA3ct0Pf7o62tcNRRR/GZX20WU0Zc43WKUv/+96c9NH5Xvi05ubNQOnMN9wYkz5ScnjEZ9qFqzlQsAe72uP8UrxonCLoKsxSiI2va/26DUG7ZT3hA/xA8Vh3P9ZhTsNEV5RO54cpSP1UCyaFOd/kAgc+bxxdP2t9rQUll2Ej0Aqn5ECFpinn5Y0GAk3oDv3ArzHgAZ9bW+tjnqL86HI+SoNmfW7OHYOBJ+t11VXjlPGZA3kQ4FnPz8Yt0Ldgr0BBQZ7ldYwz7uwozUEXtICGBXvgG89mPKILa+23ddG3I3xknLG1o1QgCj1bQwYjWtGWG4+0Z93xR2fsjYODg+7M3fdozdzhH747imadzP9d71rPt4JmagWgNQYUw4f8hWu885GPjBPW4xyDG2WGyVOf+tRx7Nix8cVf/MWruiV+zusqg4Fmnj/+NgG9hesV8BmdgzfxJH5uGaCfM9JRG/LX32XoOUbKHqCvyA9GvaxaeiO5ia/wJH1ELuaM6occSFbjXfxJznBy6PQM+XSHwEvFuMkgY2HDVPukIrdlF5oP+SagXbbune+8+7G2ySc2hXGTP+QKeUKHztew0gPa0I/xsic8q7+C8IAM4hTSDeQWedbNiXBcFsMM9KR2c/qMn37TjrHPspeNwoZLP3Q8gZxrk0l7cMPGpVfIUjan9RNwIbPNFc7hw7oYvzlXNwIYg3GZX5sPcJOOWDvsa+/W/Izbu9rRhzX3bgUpCxBtgjZuog2y3ZpbW3g2Pm3AD1x0S54+tFmgh87tSFnt0X/ztc7aZvsCz83FT0E3781gDPrIzrTZVk0LdoV19Y71se6e9Tc82KANt8CY1UAM2pAzJn2XHcympsPYJ9rxDDuK/dzGJD2Gb7Ob9wtuzcCmMH60w0/YlFFpDGWLwrvxT8l/q3WVkWme5utKcrZLeMVX6K1gB3qDezgz5iVU12zerOn4EBoow7SNEyDY6ZkCAetjPzsrWq3MALuggtDdFtZxIW3J8KguCroh79BLR1UC/8MBWan9CrvyHytia02q2WLt0FX1kIyDzMCrSgFoz3uCJh37b5MddDTP89o0/4oyw3HPwY124z8ygXy0Pt0CiHaSh+HV+PASG6jrpG/MsLUVrgUQQBiZwJHmxGDvmi7EQjFxVDlOou4YvJ0IDoZnKO8yQro6CkF2za1nGNaYKgcRgWmLcCEE9IHoMUOpppgOw3aOFJFiBI4V4oyIOdCERsVTGRvGZwzm09VPdg+qzC6iW4V0CglzYwaC1ph91+0RhJHxY4JS0TllT3vaOGbuUki9145vZ/AEZwQxPFPqKCaCa+MCMlgo364m7OyxNv1mCHjXGOGuqvrWiPKFE8Em49emzwg1WTacGgLJ76phm4dxWoOyJfRpPbzrOQILbs2/M9IJDcKE8wOfVZmmUMzX+wlQgpehZg2bK+CQUnLWHBiT+fzMz4wLBOuM1w9h5McYzJvhYz19Rpk49kU4MSjhT3BAu9ZeO8bCmEoZwDsBy0lktFnLKoFXZd5uOkUq4Eawd/MKuuCQowmfURzmXw0KOLGrbt2NDa0aJ0M4A9faVogYPjnwcC9Cjr7gi4I0drQJzMe8GCNlBliProU0/g3KfMf6d/TGb3zIKOjq3aAbkdBsu2HwYezWtirx5mUtO9bWER4KqHPrdggoGTjiPMOXcbYTVaFXBijDLIPCbwqo6zWtD5x1O5b5MYSss+AoeaGtAE6N1VE2dEdZ60M7FLDxeR++jIPi3q/6PTwVvCQD/vf/fVxll8E8o8vSutshm42NrtUuOIbm8EVZQUu5W3ZIBi3exFsMbg6HPqorAnc+Nx5zQmMCSvgYv3Y8Dp/oG19aUzgkw8hH36NdODVWYxOMMua9I4Yr3HIInNvVLjlKLyRXPIOnT59ej8f/5I95MO7g0Pjg2rzIS7S/IbB3U4cbZcDktre97fjd3/3d1flkP39X9G6Cn/3Znx3//J//8xtsfJ9K0JE5fED+kuV0PztEwLyMTXKAHsCTdlLxESeD3ZRMTne1GUMOcwzowAqfz4XsyQW8TF7lBOHBgiXzGD2jPgTexcdkJBlK1pAPZfBVCNGYyJuZp8mZjguRGezGvu+yADqsWw3Di3GRWWUzGPcTn7h+r2OWnvF8t1EYIweKXq5mEugWuo6tklMVoSTTyD848w62gF9yVLAEzMdkjJNdQkb6od+sHT1Er9P9MnfZNv7uKIx6YhxZfZG/BQSS8daHzOTEk+k+1z57yN/r2hxX39XrWe9wwrRDfhuHz+gL+mq/YxGggvxt+HR82dzhHc60Ze5+ysCscC56oS/oV2OjYwXCjINsZ4uXMRz+qtk1Ax3I+Z3tFThNP823pNi89Tn/AM2wI8yhTGi0KQsS7cMd+jbe+Wg3WtHGMrMRDbM3fG990ZZ14t9UcB1u+DZtUhh7maKbNj8AOwDelkeDg67sfvzj1+vF7pGNNWcFecZmNZyyA9BXtU2aE50v6zWahXt8F28GxrnfUWDjhEM2L/sCHtlEFd/XP/7qKMyHP7yz4iG4Ipsq+NqGERmCHtASGxXN4dMyUdAr+mETzMeYu3m0m4/ICJ9ZT59ZW/6ENrvgYHnzpXe0aa3gwu8y9vAgWeQzc/U/GvIbv7Fv8FDHmMve8ewsV+JV0Cav38nSeAs/qVlIBsBrWcaHKRx8Q8DWVriGkDAp4o9pMCTiIAwRDgZKwSEIkVdM9KQnXZ3FgZHtUiBwip/QqUZCxy4wPqWCMMs6IFQx3Td8w9qx8h6i7SiH/hj6ggL6QoCUOUXISeakElDaRPg+T6hhro6L+N/4Oq/qN4YkdAgPzGGOhDkhrh0Kv2yArj/mjFE2npUCeLObjV1jpoQp0s69EjaMBIqFIGZ4rO/hXuPA3/CK8TB8zqbvOM1wjLFl9mBMOGyn12/CgGAxV7g1Ns7kt3/7Wsh200d1RbynH3PP8YEfa0RoW3NXBHq+K0i7Rs84GShwQohT4GihQAtagX/rJAgxp6j5m8Cj5IzPOhqv+cM9Y6wU3be9bZyEM30zbuCKAWm+6MrYZeBQZHAjA4UCdlSLg09gc3TtHPmfMLMOFf+yZtYI7QpkUULwTHFQZOjTO934YdeoAAkFqk/faaMgAP6QNqkN6wQn1hHeCH00mSFljeAJvgTQtMk47tw7owUv4KuENfqQwdPRnrKeuhEgR3y+0eXUqXGEsJbxYzyl4eI1wYYUdAXKGPKlpDJWvdNVhgKRnX/Fj/hDX76z9tYXvxqXdhkigj0CLN2uYL2M0zpYa7hZXsmLbuDTfCm3QNtlm+AxOCzijy7N03rDB3rVF1lkbIxa89hUWNWaZvgsU0nNE++j1Xe8YxwppRXe/W2dOtEwnzmH544RwSu5gSfarVsGtuAGvnyPvs21OkVBO1/dONDaUfbWl6HUzQ9osFR8gWn8NQfO9Cfll0yypl0rCkf+9rw1ykDHQ75H48aEl6pUr82PfnRNB+pSOSvsWCZ5y3gyPuvQrTvLWyTOEbhRBkyCW97yluNo26oT3PrWt/5LGSdbuH4Bf3Z1Ol1Mz6zX4eq6ceSiz+k/zxfE8B75Qq91ZJkephf93W41HvMsuUdvkj1kZbUG8D85Q7ZWuyKoLoDvyC+/6QKytZvZbOqU/t8Nb8vbJ+Zz/pvSz8m6ToaRDcY7Oz/ksf49Rx9ry3zK6ESy1TywWbbpiJ82yUGyH269X603sjAHlczzPV3G7oEfNslcZBVe6Gcymf1jPbTNlrJOZDbd43vylk6bAy7dSFJmb0df4RV+Oy5TfRfP0aPk6gtfeHzVdrpJ++ZLzlZH0G/6xTzYifsdeTR3ctoPPdTtauwpOLGu1oPdMgO6o9/MFW22s48m4AbdcjjRNHrs6GibKbPoQaNoRh8cbs8UxE+XtDFgjQQUZWv43Dt0HR8BXxRs7Cph9ILml440uMtdTn3czTTAPNhg1qwMko5ttQFCJ7Yx0/Xc7NX5iNPyhr6Dbs6z4cSuoEtli6kbgu7mDRdrbo2/+ZvXPgN7t1qGlUvoSAv/J7tq09yN09ouAykAj5tfmVGy+ckY+PYbf5EtFZb9/M8/uZJLcOa7sqVm+wcNs6utO30Pt2RVdNUFCXhsPprl827GrCivNRNg6fgg/LOlC5TO4HO29uMet/Y90Qr661ICfNYtrd2GWqCwWwPLeGdXerYbHYMybr1jbOi5ozrogj3VUffmXsFszwp2kkn7BdtuaNjaCocATi+ha3ERKoGBuBABRmR8+41wEBqGdQUtQuBgEzoEaZH0hLrfHYtATPogCNptnIuUUYaUSNdVIjxMhQm0wbkmGLST00eIdYMIZjZ+zEAJIkzjRtgUmud9jqkxkOgtAcFZfs5z1uPwLGFN+OvbeM1bhNRvDKwvzgvjg8Psc2P7yq8cH3UWzry9SwDp3zOch84jCogYNxzDgT4wPoUMOIMEnHc5LnAOx92Trh0KD+OalzXSJpzAYdXFOWvmTJBRgsZMQBkffMIVRUVJe5+yMfecKkq+TCHCQ5/m4Xu/WzsBDf1qzzy6XnAu8qr/inpp1xgINmMkICkE36lPwyC73e3GKeOtnkgCytrp03eUQ4Vr0SKFW7aGHw6k2h/VeOlKQMIKDXctmvFy7DtKZNwEOzr1fztSz372eq2tSTsHlIg2rBWcFmBBX9YFjVB0DBnKZd5psY5oGQ06o8rIiG+sKyUxPw/HxojW/NYH3FUlvyNBxtAtPb/3e+MUfoSLanJ0O8IMtZ1hYy3KIEATxoEHFHtOSaAL6wqnKXu46mal0iC9h37xlM/MmcKt3tASjI2xgl7sdBbwLFWy64+TW2hRAA49kCvVE8nofuxj1+PcdA11a9jZXw5AaaIdASu49Uu/NI5bF2OHS/Oucjq66Oo4UBC49OiyoaxF1ya2E2hNKryrXXM3n6Ux0LEftGh9yZCM9Oixa+8YfaXEk1cMS89S/gJlFLy/4Yq80QZ6QwPG2TXSpZ2SNcbY7RkV5+2I31/ZO89eum+BMfO33v5H595f7jaeI3CjDphs4cYB3Xbih8NUGjx7ocLN9A99xa6xO0lGkrkdKwBltsneozPobkCmsqH8JiuqT5IMmp04MgKvz8dktUs+2AnWr4BqRwIrhtnuKz3UUe258Gj1qs4G5CgbyNzZRfNRkq6Znwurl8lLRnfMqGDN8lim97u+mW4m482H7mc/yCjxfg6v9rr1T19kqDUSCCDH/CbfOPhdQkD+eY9cJqvJSL/J2TaaOtaUXPS7YrDeN3brni3FqaqYrTXllF5++dEVrugesr+17ipcNhLbyPENNEJeC5pYt+U6GBP6qr6Yn2y19Cs9uXT2fVeturnQcM6/zbOyDOiOasuhhaW8rzaeuVcU2HjoW39XuBze2PBoj55Cb9kLbWp2LbR5Cea0Ibgpk+LSS3c3Hqfp9ir0gAbZkeY60xV7Gg3gFXpXLUE0L8t+iWN0s+m2pAB/WuNl9kmbGwB96NM8yr4tuIkW8jvgF90Zu03gOYARZDebkzXhZ8ybanDCRmU3KqeAV6yhNRCw8T/+7KKB97znyGqdtQffZZvPRWfhVHv6ZvPAKbqZA2cVj25NPAs33sXnMoL1g2d8jufQIXqS/Z2PtummKnZPNVjgkEzLT0PrbLayv7WpD3SEvgo4lT1b8G8G7xujZytQyybyeZcyzGDNtE+GdvrgT/5kQ/RqCzcNsJiIA+GXKkoxdkQBIDgOE0JjbFNcBTUIOsxAyXmesKkgIaGGkSl9QhyD6APxYAgCm4AQDPGMTBFCtZtzfM+5TVkjcs8zKAhZY/e3sWBeRNtZOOPnrGEg30stJ2Awju8JAAzEefebQsVkDALCsQJE+vOsIIi/ZTJw7js/Wsp5YyVMYyqCgaCjRIxj3k0yP3jyfMczqkxtLCLrGJEi95k1Che+w+BwbS6yXDzje2loVbWnYI3bswwkCk6/lB/8+BF9LaBBYZmb96yFtdVmBdAI37IrCJr6osRKy2vXP+hmFsYEYwwt+aw6LBUEhgvPfcEXjNOUiu/gTrulFRuX7J7qclSzpAK1xq8PxosftKHdJzxhvcZoyPPdVEPgUXIcy24iMfYK23lHO+jWrpjnfY8X7A7oSwDH2sO3dbWepUZqT/vztXKgoyBdw2ec5mrd8RfjxThz9ClCuLcOcM5AYqgUMDF347U2XTN87Ng4BmfoGK7xF0NtVtbdgAWqTE5BlS7MUBP0gN/qYHQkBS13pMvYMlT0leJG851911frdVDhT8aPH3SCdo0LHvTZNZNogoGhPf1bE0q3azDnazHJs3aIOPDzriq67agMOVDqpMBYNXT26hgd0VeGcrd1CeDYbcqYro/SVlsb642XvYsG8aExOW43GxKUMFzlWAXhHT7RhvZd0T7PBU7K5gH4xNrBj7mRO8Y2355AfnS1do4PXkxuzQZvBSOtiecFGhky97//xxsWaNQaos+MMPy8NHLOEdgGTLZwVmjHlSNMp9CnZaLiQ98JXAqm+J78lSVKllaHiByWhk+e0Oe+T56TK9pu93+/IDHZi3+1V8CE/Ete0XnGon86nu4iW/A+O4ZNwH7D98Zb7TlArqlzcDbQfvYd3TEf6SG/5tphXf9ZUXoyztjYgjn+6RtjNH5yh6z2bIXbfU6GmQsdlQ7WDv0vICGATEZzLNkDbvvxuyKrxlshf/JNG2QyJ0nf8EB/s//IdviYMyVzhK17GYRlVsB/QTFjgtuHPOSq1djoGs/oI5lMptIFMpeT6dadbuDUy7ytDkjHW6obSOdl/9A5bGJr6n1BivRzdR82JaLRG2xcczFe+GGf+Jt92JFY9g3bz4/xdwwb3gRF6Dn0bn0KmNC/bCt6HK2iuTkQgfb5IGXgekd/cLl0WAFeQ8vL2+CAzKn0NTqqtpq1Y0/BU0WZ4Sk9bB3mI+bwRqfPN9QswXqgmyWYRzctWhvrUMZxNMKmhG+2ok1edQm7NQj+4IsNP9tWcJ9dVvvW2TPkg/+zbW0Qsq+72cm8vU9no3n+wGtfe3S1RmTUfETF+MgeQKYIeHRcj71gzDOwCcoWsXZ8Q3zsHXIM/WgTbaDR7GHj2i97x5yWiZRdC81eZtsZW8fH9W+DtkCc/6v/Quawr+c1ANWy6SphfAdnaMvYrcWyZo3+BU3QvN9k2z3vecDZuS3c+AERUnwUiqMFiIvimqurE2ICGQibwsh5JkgoKIyJQDE1ZqtWQsVFMSQnM0dZMEI/0s4wjnYxX4UdI1iEzCHqqApidpY+Z5RxT6A94xnrvhn+/tYexlCQtltFMAuCpuz9aNd3GJjy0yaHDJP6/uu+bs2EvhOYwCzaJ+AIDUVQCR7KABBcBAqB7uwx4WNMBEu7FJhf0IOALTXT94yBdmsJYm1Zl9JPKaiuHxNR9g5BR2HaSXdkg0L3LKWFic2nHRJCTF927jFtNSIoCQ4OBdFRJ+tMsVJCcF4Fa0KXYVHBrK7emotGwbvPi24T0GhDBk43xhCIFYuswr2I9l7WyXneMdZSUz0L92XwaAuuusbXGhojnFQ/B+4dJaHE0Z42GJuEJiUBD469EOgUGZxSiHburH1FxhgCBKkgDRoU3CtrI4PNuqBV3/tOO9rvOm0GjH6sv7RHQTdpg9/4jVfXedCP8RLuwFzMoeuVK+Jnbtrt/Gj8SzmhTc/C/QMfOE6hoa6GRa9wXfG6OV3Y/M2h+i/ol6GGV/B2Vzqi1wquGZ/165hIRQKXFf2B9/ShHYYcGbMfwKf28BY+aRfM+9rGP+jZelRQ2HzNEQ7hKBoF1T1CK2RYKa0A7jt2Yt7ayDDK8GEs3OpW4ySnpmsnKx5sfHilIsLaKtMpoEiNv2ABeYbXraMxVpANWB/4ttvT7VQBfoUL81PjydqiRXMrYwUejIOhiaY69tiNRWSIzxkoZFxF1hhD5mLN1c7BAxXvJosLBvnMfDgWcLffJSsX7RWhI+/L1mEs3FhTUT9B2AZMtnAoyH7Bj+RWxQBziMhvOje7q2xCurnbMeywtpkyZ3J6rh1+GyhPe9rVAZkZygQmwwq40o05pAW/O8LqOXzLgd8rgL36TUYCskCtrwID733vmh3YPfQeWTIHdgNyjLybg6gVnN+v/gO5Qs9XhLGCrvpu8yG70LOcyLkgd0eEtA9/xkYns6Fs8MGL23zYFPQlnNO1XQfMTiJbyWXyzLv0Ro57RybobX3ZWCloQQ7SJcbI/uJcm6+xscHCQ0cctaWALhlfliZ9QeelL8xjDmqza4zJ2KtbVQH8jlKVmWMO1e5jo3czY0d3gOeXRVu7yrmMTHqYnQZn6MJ86B1/04vmg1aqz9bxVHYOWoUH+KheCvu2Y6Jwpm04rqgr8LfdenMUdPGOTcA5q2oJ+txUs6wb3/SVfc+W9ltggo7UPr0P/132gL7abLEexlkJg2X9EMEqtoF39juWanwCdea2KUsG/uh2eF/f/LNeG3ZK1yu3GQsqZFp/7D74Mf4f//Gr69aZSxdLVG8PPnw/Z76h90c84sTKBoiftM2mRkfdZESm8SFql23SxvsM3R6ER4wJDZTN35XOZdV0hXG0XkmBoCuL94My9dkk1oyMEOAx3/3eWwZLskHhZFMh34Mg3shOu6bvb+FGBIhIkAKjcfgY6hw3RCYQUCZFSgpx53j6QXiEBKKmVChWwo6ypug5S87pOSKB0byDeDirnBNGuc840T4nfDhuBBZhikg5SYx67RpvQRO7nAIrGA2jEibO0hNwFChFjvkRP0eVUfKYx1x9m433OAn6owwZGpiIQZOjpX19EQ6MGQ44Q4ajxIDZi47vEBpFS3NYMCfDgWL2bgxPkXuOgDZmwooi6352DMbpo9QJ4a7BI5SrW9J1eOZC+UihJdwZOAQVw4LQ7ApReIRTAtBYzZFzRPGYs/c4s8ZEcBN62k54e6ZaK6WzGluV660lYdfVf5St+VPetZFwt8ZuAGDYoKt2qfdu7diFB5951njQDQcNHaIFggdddZVcx2PQBjoiENFuBgFFoS39GSf6hXPj0o/n0Q1atK4EP8OjTB3HftBJxcO6XKJxZPCiQTjuTK41RlvVepl3bKwtwwWdWHMKAI4zXNGK9YNjtNENNvh0zj4ICGHtWPu9c5WrGiZ4qtovgl6UUMoGv5aSi2/huhol3apT2xQ6OqLYrC1jsmNZ+nFTS0d1zDFjXb/mH40XbEP3B4G1reo6urG2ZFN1eDpLa330p83OpVasDcAv2kYPeLnjOwAu0J2xoHWGHpqpLoq+rQEDquKuXb9pTD7XJ7zqRzp0xl5QEdVZSXY1OeMD7RVg6tpeyl1AJmO7DCh8xgC2noqKKWLruBi8KH7seBd+IjfJQIZqt+eQA8aPdtA5umTsGpfglzGZL1mHZtCE79BbmTcdq9pUtwBYc/Qwp8iak7Vi2P7yL48d4zjHYGv+bOFQQC50HfDy5ji6E8/SuxWXJvPZAn6TO94vM4Hc4uTPQVX2GxlA5tCTm2RsxbbnwKa2jYdMwuP0gM/IBfKiIzNspI4QdVuK9+h4RxRskgmYdLSULBFQSSbMQGfTl/QzmU6PmufyOOJ+UMFT4yVDyUbjgh99Gyugc8hO8nvOMPAcXHTjB31Hv6br2I6C9mw1czRe+s4asCXodniuEH6ZEubiOePqdrsKp2uLjrbO9Kj+6LAcTPhnv1hHuHn964+ucFuhfzAfZQdzELoMQuurHzRQ8XW2BXzR72jLWOHM+Mhta4UeC6CYl3fngAmZbrw2O+kVtNllDvSedrJtq/dXxix6ssZdE9sRKGOA3+wDa8eWMi88wSadb5DpNijjrwhxlx0cBMurlWeAA4EpbVbrBw90a595WQ/rSWfDf8dM6FY4LdAAd9VoswmN9tmY8LbpBpuATha4K2t3BnPGdzYVBc7YatbLOuBh8zLGrgSHF2s52yHp//DPN7NG6K7bmsydbmcHoKM2fuB4vvnoBS9Y2wdolU2F5q2fNgG5wbbit8wZrTNYLz7L13/9ej5dfsBWYHeyfxzXL0O3W5mqT1RgaD42dhBYT7a9tTY/mUXW8zA3H8GR5ypOe00Bf7At5yDPFm6iQBAXFVesB7MTjIxpggPhM3YJUE4HwiMwECjh5l3Peg4Rc6ooTs67DI12/gnYlIL3u7nDexQIQiTkFd8ibDjUBCVh438Mz0AgqDCs9zE6RuvYiUwCbWkH01EMHAxz5HBTUnYeN1HxAAEAAElEQVS3u8oTI2JQkfBSSwUiCM6uNSXwMG3X75o/QUUpYeC9c68Xchif9aw1U33f960DNN3uY2yOunCMpIFhVgKyYzLVguhqYEKGkQLnzjJzjAgqgS3ChSFEmbh5p1tytN05ToKTEPcc4WjuxgoPnDFztVbWBP4pbu/6TLAMXioKS9l+13etn7Fe8FUBLUaF+VTwkyCDN+92xCYjRVuEHUVZoSR4NlbrZE32jLlTUg0rDkwoWzd9EOZwpCBuBccENtBYR3fgTUCE8GVsVKyTctefTBttGqd5UIBoKtzn0HXeGX4YRIQtpxS+K+rGCPA3GiTgOdDoX3sMYziDFwEbc4dvtxZRMv/qX43hkgrrbqxozPzQZTuMlCccokvp1/BTobbOvAL8ij6qkWEOBamsvbY53bODz6jBt10/3c5O9TbmK+hAuy/VaemsOPzhXWuU8tG38RWc6Vw9x5viaKemCu/mC9/4G54KaKAB6wSfDG/zwtcMLGsqsOZv7Zu7Pruicgb0BgfwPGfAMIK6stu6+lz/5oiuzWuvFssRdOxzdDKnkJMP1riijnA7f48+2k0JyJGMIHizZugmHkb31r0sPuuLFq0P3oV3xog542fyyFi7sUJhPPjBn3ig6zG1w7jEJ+bM+BJszSBvzeHcWMxVH77rNgtjWt6wEXie/IEP75M/DC3y2Twf9rBxdD+j9SYM24DJFg4NpY2TC/iNfMRbgqN0FF1CltOf+JDtxF4gCytcTVeSR/itTA9A/pHHdBVdh9fmLBTv4csCIGS6mkldF19GAZlKHtE1c1o/4NQZU3oJGDMZ0k0ibCh6hExtI20+pgu0bb7m4TvPklX7yZYl0NUVQ/W3cRsHnUNOtXNMH5BB5k7OAt+TnzJz4YveySnvKtxqM5Sx4vuOY1Rcl8yHY7IcTuh8Mr0jxfplk9qYorvpMZ/BO3xnm7GXtcOW9q6xs1Ee9KATK9uRDevHuOd6EcbAFqYXqw2ITvRBn/vcGNk8AgLZCNWzs2ba7YY7a9AFDWipwq4BOd7xA2Nkixo7fJhf9h/7sSOexkA/003GbTwBe6SaNV3N6l3rwXbStp8yafXfjTzWU9ubshdm4Au88pXHPnaLVLbzDPQnmg+vwDytuXUQ0OrmSI4+nOBZY+j2JPim++DWcVk2Klrsumd6dhkIWYI1NPc5a8gahU9zbYxsBHpWf56Hm2rP2fD0bGvH1oMHNI8f2QDm0g0yaLdMm+jdu9Xi0b+AEIAPGW7s7o6mkTVlrllL+GiN5qDNJkBrHUWrmL+xmi97Z+8iiBXAcUeK8Fl0D+9nC5iw4eEJP7J7rGNB0PkY06YsWPM3x67XvqZAFpSptIWbOBRBRfwUCqItDY5CIyxyXhEvg53xHsEhoG5cIIw5QV3/5bOODlA2HHxHH7oujJLg3BBgDH9E5TsCX5+IW9vuWu/qTAqbccGRJxjUp8DEAiuYBhNRagSD6GWFmDgiFHkp88ZjDoQIpmuXmlNHSHs+YcqJLS2Qw4tBHbkwNwLinvcc55XqpS2Kw5gJZ4aP7BIOC6Er+PQv/sV6LBQp4cXQkLUgeJKQ42AQJNWZKBiC6eHLLrK0W2tBeGmvmykKGlkrbXP62hERMNIv5qfw4IiQgnvHo/yuSJR+GTOygeBY+5x/ODNHa0+ocWal3ztmYn4dy7J21rjCvZQdoSrVET4oz7JI0M5eNtCxjkChxQrgmgMhKhhCCHMG0cejH73+3JyrWUGp6JvyF9UXaNK39TUONO15yokw6/y3ow7WihFF8ZtfR1H8TxnZ2beO8GtsnmfQWhMKVh/WDB1bF+9KO/S/zwUojOU7vmMdCEM/jEb8UqHZBGsRd3hAe8aFrudMEKCPCnTC914gchdNM4h9liGmH/yD1/EZReBvdJPxgYfQ8wz6Rw9w7R2GmiCM+fhhpDce7cCXdWPkh0PrlnKEs265gne0L3gBR2U0wKXP2tF0FAu9kQN2ntBp1253lRx+W1aLh8dupYDP6LMjT4xXNIFHuoKvWwj2CsztWCMGL5roDLCxFsTqqMphdizQTU4InFZrCegDTVQLyfEcz5BJMuqMo5urqvcEj+iBTBBYsxOlj7L3ANm9qYo+0Hf1BEC34mi3qzIrYn3QsZq3vGU9HjgiB+CIzAi/F1wwTiVXzyHYBky2cK0gR4y9hc+SAZxHP+QAZ5cMJJOTLeQc2UD+Fbzm4NJheJzsLqNRrQMyhB6vxkIO6DrN/urACBmBX8mXajL4Paetk0UdRTV2+oSMYRewd/7iL458LGASmANdMUNHhskVenqZhXcY6NYKUEYhh6riqDm15qc/dgigX+jS9EKbCvQh3Wg8Mok9D4eegWuyzTqwlwVHrJk1pOvIZfKYHWcNqt1UMU76j140T/1UL6KCs/SMdfS932iBbdSYzIHdYM4ccXa0eXBerbu2yFt46KYPdgSZzi77zu9cB8nZKNamixfoWLZzGZQFSuh4Y4BfetG8rTNcsKfKPi3zFA7RpHF4D83R7WWj0y8zTQDvwHXHHDjfgmbrgrdrWqyYJrtNcMe8rAUeKGCCL+ajxoG20fS97nVqRQvGSr/Ox97YDfrxoz3P+eEbwLUxt6mGrtmL1ou9BLfmxn6RjWRz0/r7m31Lfx5U02QJ1RiMpo3RPI3BHOc6LGX9G3cbw218wJExsUn9dByn22zwNXo0XzYnHu/IUwGtNrz4bL7T5ktecvxj/oGgA7sFCIjBM1puYwp/4JP9AhlzPbQZ0DC5gnb1b05dbY0G2hRqc9Bn6OVswSigLTw8H+/q9qr6xvNz9krZ+uZtbtlI1wTgH+7hnA11+eXnvsnwu7/7u+ORj3zkuOMd7zh2dnbG/8dhm+DMmTPjKU95yrj00kvHhRdeOB72sIeN1y0iSu9973vHox71qHGLW9xi3OpWtxqPfvSjx4dijhsKMBimKj2TACFwEUpViTEEx5oTzxhG6BgYERD8lBSlj7kITN9RrJifIkaAHMaKFiJMghETcrwQLaFOIGDs0v0FRAQrMA4mIYQIYUIebjmklLS+RKsxcPezEyI+I+AFOVIoGBXzIV7Olb4c9+n6zBxKz1A+FAPhL8jgfKv34YGiJ+Aw0KWXjl1zKJ2TEO9KX3iVPgeHjAbPU4iEMXwYF8fdeV/OfWlynE3zJhDgE34pXwJNwAUeCXDtF91nKFkbShHeG4+gDDw4dmKNBZm8D/8dDSHsKH+RcAIfLgjFjuuYA9owL0Ja0MOzlFx3k5uPn66BpljNRbpuDrkded9zwigf8+tML3xffvnYJfysKxx1Fte73SgDRxQRpW/trJWxojG0aAzowPzgl4JkWBRAsqaMuFIR4UggRGDIka3q+XSuvNt/jAetwYFzoMYGP9bFThDDwviMAa4Ec9Ag51N71sANTcZlrviCsCbw4bHK4GWPdLa2880MNMc+4BIvMJgoPXOwruZqzM985oqvzoPbbs6BD7sE2tI3GhEogns0n3FgXYyFkqqAKKjAqnm1m2Gc5IEgJkXAeGjHE84YYmU34dX5jLG5ce7RGifaPODYHM2lHcllkS9jbZcDvq31D/3QmhYqvIefNgEegSNzNwfKEQ8LIsKTueEVP3iBsWetHG+CP7xr/c3bfOCfQQCnZB3jY1lY1ufz2WlrQa4Zr8/94JOuEC9gWio4nKIfhhIZgaddG85oI7/wFmUuANWtN3AiwILGM0rmYor+N9eyqRg22rVWXTNNJ1TEsOwd+NbGbOScPn312dxqteBVwR0yBv9zPg66avEmDue+9bOF6wXwBFlL7s4Gf7YBIA/wHP1S8JM9QP+VvUHmFrilB8kLbdMvZCsnTuC8c/sBnq+GGz7ngLTT7h26suDDDPotY5dMqA6anXT9kl1z8EObFdyfoYyDTc7uYaDjI4AclCFN9ldbqV1vQEeTmex2uGhzwBzJTkD/CBSQx+QynUAuV/TUs3QdvdUGGj0hYFAQiSyEh27EoGsLRncLIX09F/IEZG5OPLuO/Ab0i3f93+1s7C30YG3Idbqha2ADOKiQLNzrr7o5bcoYe7VD2Cdogw1ZFm3BMDQoQ5r+1hb667gGO7tj1mxJ75D5jjGzZ2WvpgNtcsBtTicdb32sf5tS6K6j2xWih0/2IfsJbRt/OtF4jJEO84y2yiTyNzzEQ9Vg0w9eME5BLjRYQKf6euaCJ6yfts3Xc9UBoycFBdAAe5K9nd2J5+hiV9wuM6uWYC3RJD/HnLyXPa2vNpm69tja0LPGxI7OzhesQR/GAyfoBm+as2ey2ytaj4fh1VzmbGK4RZfWSqZMWUMVNC1bFn2Uac1WgHPteYY8gbfqN24CfNuxnRnM0ZytBZsDXRk7uuy2sC7ZgC90os/9ilwHaNwzy+uVy9qpiLG54hu05Hl9lCVjvgVhDwtov9qNfNz1bUvnvsnw4Q9/eHze533e+CHG+QZ4+tOfPp71rGeN5z73ueMlL3nJuPjii8fDH/7wcWVpi8NFLY8af/zHfzx+4zd+Y/yX//JfVkGYx3DQbkiocFTCrjOZhFo3Q+QMENJVWKdkBCIQNufeD2HUjiJCIywQHacEoVCkmJNAJOAroEVIVLyx2ihVXyZ0HXfBlHaYMXDGN0appgIiNz4M2t3yhLTPMab3zKvCjoSidwk+iofwszOr3gqnUUo+4WmMhL7jRcaCqQhubXHqKaC3vnWc1EY7AwQOZ5nDQIhog/D/p/90LbzMBWN25SjhjU66ycKY7AbAHyeJQPWOMVYsjKCh+KuGbp0EZAiqUsdExjvOlJNH4VeoM6OM0jMv87WOxlv17AySBIv1tP6dR60grWCF3SxCmzCj+Hxn7dFWBdr0AQfGU2E5c+7qU5kRBV28xzFmxMjS8E47NQxDxiYlbqzmXc0OdCCgU5VuyobC58ShSwqOAkB3cGQe+ihiDzeEM1oyF+0WPdc/PJsL2sog86zgCBp5ylPGeOIT17hGs+ZgTgIW6Aj9GJf1/Sf/ZL1WxmWNrQP8JzfQlHnolwPfOemOjrQjJqhnfOZSoNDnnS0ua6Iz0cZbpN36M7bm9Fv/o6luxRFU0A78WjfPfuu3rteI446O7VYaz3wzALDmgjPLQlrAmCj4dj+AtenabDhCG91043N0ad3hwTr5QecVmSOjloFoxrrv4h2BMPyLhsgkwV74h7fScfWN5z7wgXGeMXT9t3aMMRmCbtAx2dItOACeHeNy9CqFjk/gHg0x8u0EmXeFUWeoVoy5M+wY5OgNjZK/3tNvR3CsVwY2Gkcj8FBgF33ATcWv8W11bXyXIcmYxlM5CgVQPKv/uRbAa/duJeo8eTiuEHhG/h4cXRYEPgfg3Ld+tnC9AZl4mGMonmOs40FymFwvO7XMTbungP4jWyrySCdUdJCutWlRan9BTt+TxeQA3ifX2GmbUurpQrKDLqLju0GGznCMZLJ5PwZkc7vyAblWHa9N75wNOp5CBpJPxtHONjAPstJ3ZDS9yLYiO+cjrTOQo+ubLNb6u7pnOUlw1THcji1X1NR31Rcxz7IyyWRy3DjpHhs4IJtb2xXKZxfTlzmj3jHPsgTokwLi5DX95X80MAe3zMO4CrwAawkn1XvLpqtumu+th+xA+pGs7gpkdgMd3y1E3UxHvpu7II+5oAPynk7WP7o0RsF7G2zmwGZVL5C9CDdwoi/6r2PXnqNv03dtmqI5unCZFdVxNXgu2IJXyo7yOfpn31Z7jg42L3Pt+JXvytQqIEffoQlrSid2GyX806NlxLMH/N/Vvd0GtYSuKramMkPwkPViOxiDPisGn2xAS2jBuNAI2sn+Mwd2rM98Z5z8GHYZm1/7ZUChUXPQnrku63+EBzjtxkn4XNP4yY87qg3KBtJXWT/VlttU8Ll3yKkyisvsqQB18s5vfkHFgo27YzEFfOFuPk61BOtB1syZJQFewDf60C87lN0SDZVdEpjX2YJgM8xHGq0dmfJ5n3fu35LzpV/6peN7v/d7x991BGIBskue+cxnju/8zu8cX/mVXznufe97j5/8yZ8cb3/72z+WifKa17xm/Oqv/up43vOeNx7wgAeMBz3oQePZz372+Omf/unVczcYEDh+CBLE0BkyQhCDUbwEI+KJgAhOgrJCNsZPIWE2WR454J5xE0gBFwxA+WAoQqrMAe3LmmCoc4iMhzDAyIQrR9G7T37yWikj7O7VptQpLcKLoDV27xL0BBLGJAA7AmSc3dyDyTBKQh8DEiDm5DlCnTAnjLRLIHAOCB39a5Px8brXjRMUAoFurPBTzQ1ZHfBUPYrqoJiD542/jJSCDXYwCC1ZPdqyC2/MGNecjY0SsoMPnwQJg0c2kHatJcOnYBbFRNAZT7vG5qhPAs1Yu6qtAqkUAKENJwRf13EJQsGn24dk+6iD0XXPBLxAERqwpsbWVanGrg3vm0vZCpRktx3t3ZF+rCK1nFT4p1R878iQtrRDaTPA4A9toRXfec5c/Y924U5mkM+qaG7t9IHWNhlqik0l5Chi+Om8pzbxiGuqrcVcAJNxZD7m3DlU621t4BPdoAUKFj05EmWcAioMITVwfGcNBCjgwI6Z4Iq+4LgCXOZB8VUw2VzgjzD3fnU5CgKZQzsX6DBFjAeMdbkT4F1jRT/Wsat+rZ/29A338I3+0IZ5+tz6VIywIl2bdiopMfgxHwaIeQL0ibbhuTPH1oz8se5w0Hlb7cMBxV7NDLiZs/sYctowVutJDqA9x6Ksv74ZYDI37CgyYBlFX/u1Hyu4+FE8KYgaD5MFgh9wL+iB76U9V89HGwKaZKG1sz74iDwj36yR9TAuhoP31A8CZKMaSPCBps0JTtBMDpI52bHQtufxsyCJddO+fvGhIJbjgwWrPFchNfzFwNI2uaMddI5X/GSY4GU4RQ/WAG6tsXPa5523/qErOv9ccNTYPSszDE7e/vZxZFv0dQtbuHZA9uGzWVazh9qcCchCmz+eozPsNHOcfUYu00WlvBcwKVOAfPD5QUU0c2YKIsw1AG5+8zMfCwLMQDeSRXOGARlMz3bkLyDnDpP6XoCW/CdHu2KVTiuTWB9lHHR9LBnZFcQzeL7sYvLO9/BF1qU7A/YMnNED2c30SpmI5Gcbex1rJ1s5sQWyPce+aXOQvNeGTZZ1Qd+dVXt0Z3qQ7vVe+O1IJ101Z/Ghlbn4efPPsYSDHN15c4HzjTbofPKePIeHro4XfGcL+J8eatOoY8p0fYEVthAnfgb9o1k2m3qF7DO6oTpnOcjZOnQSeqSD2Btd/2ve5sOGKAvZ9+zKbuxcbkDAIz5BJ2VWp+fK4u2yAf+zaawNGwovCXSx8+EN/ssUL9sDrRnTTCt04NLGLBtWv3CB/jtCY87Z5HPtILRmPGgd/tPT+i+bi81Hj7eJw75EzwKpgonw0QUXnjXu+D7QFjwKPMJxOPc3etwE1pQNkx3ATuIXsQv936mDGdCV/mWssFu7UcuzAnbJA+vK9jN2v83DmNm5AiVsGHbPpoAJ3vUOembvzrcXguqy6YNNNNeOwRfoOLqfP89uPRuQI8a6vBlpmeXyqQZveMMbxjvf+c7VMZzglre85Sow8vt7FcL9dgznC6e0Oc8fOXJklZGyH1x11VXjAx/4wF/6Abu7u9fJz5kPfGCcedvbxu6ZM2P3vPPG7vvfP3bvda+xe/HFY/dv/s2x+7/+r2P37W8fu89//tj90IfG7ud8zth9z3vGrkyAV796/fuRjxy7d7nL2P1rf23sfuEXjl3HKv7qXx27r3rV2H3yk8fui1+8/vH+p33a+tnb3W7s3va2Y/cNbxi7f/RH6z7//t8fu3e607q9Cy8cu7/wC2P3gx8cu4961Nj9rM8au/e+99j9i78YuydPjt3P/dyx+3/8H2P3rW9d9/nrvz52f/iHx+6xY2P3He9YZSms2r7rXcfuzs6wv7t7j3uM3fvcZ+x+xVesx/F1Xzd2f/AH13//5E+O3V/+5dUNLbsvetF6TD/wA2s8XHXV2H3d68bun/3Zeuz/7t+N3T/4g/X/5nrve4+jr33tuh2f/8mfrPt83/vG7s1vvsbTiRNj96d+aux+5meux/yud43dd75z7L75zeu5/fZvj93P/uyx+5CHrHH3xjeu2/grf2Xs/tiPjd3zz1+3/4hHrN/98IfH7n//7+s53upWY/ee91z3Az+/+qvrNoz7Ax9Y93fq1Poz8/uCL1i/c+c7r/vXhvY+//PH7rvfvV4DP9ZZn+b+P/7Hur1f+7VVbYzV9w94wNi95JL1mP/W31p/Bs9Hj67fu9nN1uP6P//PdV+/93vr7+HA8+gK3VnPyy5bt/3lXz5OmvP97z92H/7wsXvHO47d48fX7+nX31dcsR7THe4wdtEu/OnnNrcZuy984Xp+F1ywplX93vrWa/r6r/91vX7oAz70A1fmuR+PWAPjfMtbxu7tbz92X/GKNU0Yj7EYw/Ida65NeP/zPx+7R46M3U//9PU4WhPj1Y7nH/Sgsfv0p69xYR2MFS/iEbT4sIet+8YT+BNNv/e9axq5293WeEU7f/iH68/0C0fWAG7gwvP+f+UrV8fHVnSib7SqjXn8cIvv4B49mL93H/jA9TjQiflrA58Zk/eM2efGh39+4zfWv7/kS9Zzs35uQYJ7z6M9a+BvskB7fWfM5k++XHTRmmZ+7ufWf/veuLzrHfzsM7gmF/7G3xi7/+2/jd0rr1x/bu7o1N/w6f/HPnYtD/T3Ez8xdv/O31m3jV7+9E/X47U+6OmrvmqceOADxxlj0p91t17oyDvW8su/fN2v+aFJMgI/kAvo0NjxuDGhDbLGGn3rt47dn/3Z9bqjjd/8zbXcM168bm7W8DnPWdMNGXj3u6/xQZYZ/5veNHZf+tI1DWj/Mz5jPYbmrQ/z8T9es5bWlLxFM9rXFtqxRn7DLTqKHqwPfr/f/dZjJy/h79WvXsuSX/mVdZ/kvP7xgLbIQHx83nnjzH/4D+PYS15ynemufm5o+BQ3f7bwyQJBSA72ZGduBE4P56B6I35zaP3dDSWcYU4xw5+TYrdd9iMH5zD1AHKGPMu5zeHkfJTJ4HfHS3zOabEZIYBbJgiHUhDbZzamOITVjGPr2qA8yMFY11ZYOzKcWv/n0Gif4yzAUMFqziMHW6BbIKRxc4A5V8bIKTM/jpY2OYM2icrgAdqHR4ETDhH8woU2OErzbT9wzWnmFNuYMyabQG2wCKL43tg53hxBzvCv/MrxVbZyG3COSDjeCKfwZc4CFHA618rgTJqXz6tpUZ2UsgPNUzuybTj61soaWY9unURHAi7m1VXPHG7ZC90kaZzdYmjNteV4iDXoWFDACdZvGS1AuwIZ81XS/hdE6ciS8aMHNF0dLU51ReELGKBneM/pB9ZdIAJdVey440noF76tVzTmd0e0rI+24LLjMB01gQeOunl3fa81hA99VeNHX11zLUjTkRr0rx04tDlmzhXt7Zpc9O+39uEOvS6deHQ5g/H5zHpWpxF/lxlVcKCAgvFvgmpSwpmgIB74hV84vhozfJJB2kaXZb50ZNB49e8HDs23wvFt6BRY9Jmgp6Cfvgpg8JsrF6Htas2ZH56Ef7jxPvpEb93yFcBXGTKboJpAy6DIQYBOBaTw+bImzxLK6t3CXwbBEnD7RTTV/33n9+3maO+KN4+NW9/61h97ZhM87WlPG9/93d/9cZ+/5z3v+UvHfa4NMDbff+bMuN0HPzhOcQ72zrIKOohf2zc4Q5h/7ueO83/xF1eG8GlE/PKXr5y/nVe/epz6nM8ZFz//+ePDX/u1q2tMj77gBeP8V75ynNjZGUcuvHAceetbxxEM8cIXjjM+v/e9x8lb33pc9MY3jjO7u+Pohz88rvzczx1H/+zPxukrrxyn73zncfRlLxunKZJP//RxjFPy5jevdiYZ5sfe+tax86Y3jRP3uc847xnPGCfuda9xZu/6uyO3ve04dd/7jgv/438ckjKPvvnN46q7331cwNm92c3GVZdeOo698Y3j+AtfOI6/9rXjo295yzhx2WXjvM/6rHH8939/fOgJTxjY7SLR/He9a5yyG8zB+NM/Hee9/vXjQ1/zNePon//5uPDKK8fxEyfGycsuG8f/9E/Hla997Th14sS48p3vHKco+N3dsXPixNgREHne88bRK64YZ06eHBe+/OXjykc+chwlQDkqcPjKV64/e+tbx5mXvGSc+Ot/fZy5/PJx5PjxsfPiF4/jf/zH45SADMf0fe8bJ+HlNrdZXWN8/AMfGBf88R+PE5/5mePMFVes5rtz1VXjzN3uNk69/vXjyPvet8LJlSLNF100dt7xjnH6DncY53FqCNDXvnYcIfCOHh07Z86Mqx760HHeC184Tj7wgWPnwx8e5//ar40zn/Zp4+gv/dK46ku+ZDXGU/e61zhuHpddtkqvP02o7imsY8ePj1N7NXCs/Xkvfek4efHFY+e3fmscede7xvH3vW8cfe97x0cuuWTs/MmfjPPf9rZx+mUvW82Z8jrv9OnxkcsuG1e95CXjfRddNI69613j5P3vP8485CHjwp/+6bHzZ382ruKwPehB48Kf//nx0a/4ihX+rzKGd797HLvnPVfZKSf/+38fRy69dJz+jM8YRzjO+O7kyXEcf548OU58+qePM+2gfd7njfN/5VfGVRTAouicMR95xztWNHjiTncax970prHzoAeNo7/7u+PMy18+ThjLX/zFOPLa167wdfpOdxpnbn7z1XtH3/CGVYHLM8eOjQt/4RfGlV/xFePMZ3/2OntmZ2ecYgwsbgw58jf/5jj/p396fPRRjxrnwdXznz/O3Pe+48Qb37i+XeT881frfOrSS8cFL3vZKvBx6uTJcfN3vWtcecEF45hsgePHx4cf8Yhx/Bd+YbzvjnccJ25723E+hWdu1vllL1vztgDe+943jr33veMkxdpYrrpqXXT3zW9erfUOpXfq1NjBrxdeOM7c6U6rdT9+3nnj1MtfPnbe+95x7C1vGVdyiM8/fxy5+93Hsd/93dURtQt+7ufWtPQbvzFO3ve+4zhjXwDqL/5inL7d7Vb0e3La5TuOxvH+7W43Lnre81b94aMjL3rROHPkyNi54orxUXz+qleN837/91eBtdOMW0GKT/u0cQS+/+f/XAWxzr/1rcep3/7tcZqc+P3fH2eM7xa3WI39pMDu3i7Q8csvHzu3uMU487KXrcZIweGBnd///bFjDf7iL8YHz5wZ79/ZGeff614rnkL/Rz7ykfHRv/t3x3G88dCHjiPvfvcqoLJzl7uMnfe8Z1z0f/1f46ov/dLV7TrW6zw08yd/ssLRh7/sy8bFP/RD48T97z+uOn58HHn4w8fNnvOc8YGnPGVc9B//42oup+5wh3EEbzzoQeP8//pfx3nHj4/TH/nIuFLgbW+tjr7udePM3/pbqzntXHDBOLlXLPnIq1+9osWjcHHLW44zt771OP/1rx+nLrhgxa/wd9TzHIpHPWotq9785nH0NrcZR+D3hS8cV375l4/zzz9/nPijP1r1Tyec3DOOj9/hDuP0ZZet8LN7ySXj2M/93Ni56KJx6tSpFX2QpXYi8d8OOn/xi8eJL/zCceFHPzre89f+2vjwu9+92ii4LuCD1yQ99nqCbcBkC58UYPjbcFvuWO4HHA261Y64IAQjX3F2gJc5UBxEzqfjqtq3w34YsCuunpY+5h16UBBAJoC+/ZQVw2F2NIPDnz1sPoIq6sRxgBoLecaZ5PhvAraLfh23dQw24Ahznuyic8K6Vcg4q7NQXRE2NOfNj+/Y4h1D6pgHJ46jVNHc+va3542V48m+2NPvfymNv0AEZ9iOuu9kkMhWECT6N//makc9J4wj91mfdWqV4SkzyDvehx9Zy/DXUSiBgmpLcCr9bw04a2VLCwwYf0VAjbnAFsfRWlgbgQqgX7RjTtZONq8MEs5xa9kRB7i1fuwP4zNXTihbsAxcz1iHOVgScMYFbxyRBrJAnvrUdf/ku/W0FsbOdjZWNCuwE567bMGc9eE5a2scf/7nx1bBB+MPT91cgsb2CxpE52xF62VccCg7pqAG/Vawxbg6lo+2BMo47Zx7eIz+Ci55XpBBIAjOOirXLXvWwlz0i87YqPgY/numDBa/4cc88aRMLjhxHFh2q2zXLteYYZMetk7oqAyX6n989KM7K5ybo8wVwHYUIDHn6rt4D1/Ox3e8LyPXOgo4GC/ahxu0WDCr8ZBz1ZjDF+oKlkXnPdnt1VvRdicFzN14yBxj8B3aEpCagyl80rJ/r0nABJiX/qKB/YD8W2a1bOH6hSc/+cnj8Y9//Mf+l2Fy2WWXjUsuuWRVPPYTDZisHKJb3nIcwyCIGAFJ9a6IU/VMMChCrbgYwpfqicB3dsatOusl3ZARrT0GOcKsovt97jOOYzSMhekojFvdatyMoyINDaFLFyMkCTzCVnoXRhftN4a9NLgLCK4PfWhcQMFTXI4zqKlCgTz4weMC43joQ8fFGFF/5503bqZAaAVbH/rQcRxzVafggx8cF9plIeQUOCWEMJxoLeF83/uOizr/vxf1Py6gIqCwV7/ggksuGUcUepLGT0GovUJ4YFYGxH3uMy6u8CrlQuH9/M+PCylE81EfR8Cla2bNqUJuFDHcG7P+Knj5hCeMCyhSt4VQBpiZcMfI2vzSLx03q9im1FTvdzUahoYbyrXoLuOEULZ+1kPf3/Ed42IC3lpy1u5733GLarAUiQZ+a9N8E6R+l/K5V0jrAvOA5wqpEppw8gVfMC6+y13Gey68cHzaC184juhbP9bfGr/rXeNidLennC8mFLs5BTjagqbgRpCIIiut1M6EuXWV8pyuaYxd6Wq3qnO1Aohwij7g1NwYc8bcUZOK1RLe3lG7haIjnCs0dv/7j5tThJ3XNl7CHT91frvbX1760nHzbrCBP7y4Fwj5WPosnJuPQrXW6qu/epyPbhS9+/RPHxfLMjjvvHH6ZjcbtxY0gwdtWXf404+aMOYtBdc6mofxou8q+6MBY6uAM/x0NWGFk71z+eXj5h1Ba6eEgeUIFVqGfzzBADIGf+u7myACvC+4w7CxM4Cu4RENCGK+/OXjImOys4NeGFr66Rpcn8M9+rAT55iMvvx4hqEDF+ahXfRu3nBCJnQOvSuhra8rw9/85nH+u989bn7/+48jDELvPvjB4zy4eOc7x0Xo09zIBYYJOvjiLx7H0BqadBuSeWnvWc8aFxrjHe84LjSmrsH8uq8bF5A/1pS8RS97N8usDBZHG3/918fNfEbmMrSsIxoyX+2gXXTo+epSWQvrmxGLhkrLRedoqaskHTtSzPhBDxo3Nxfym2HS+9bbnMkw7aPTN7xh3abjgHQFeY1vySYpzPgFbv+f/2eVgfiR+9xnpbuuq4DJBfPO5A0E24DJFj5pcLZrOpfQzXn0NxlFNnGGyW1ykDM115e6Juni5CW5ttxFpavIeXKFfVamRoBn2Vhzdhg55hlyobF0M6MAALk3g7bJOzKNDqnOEhlrztUZAWQ6eVmdJVAxcrLQ39X8qKh70M16dCJ5pr+uQS4wQg8lh9haxrDc7abT6MccfNk8bAB6udsVl9fP3/GOuyu7hyyF6xngi13te8eEvatPuGZratu42J/VIqxmnkCX+ZZJYeyOQ9AnaASNsXvZ6uiEHqCP2ALmN9c6A3QCuxKuKuIJz+y7rqqea6Usga6BYzq8+modTRYMEzDp2Iq+0ZQacQIMxgfP7G3jts7Gof4Juvb/W95ydHWEmvPdrTjonA1YjcL9AM4q/F+AQz/dOkX3dnzEWsD/HHRkW1Q7CA9aC++jRWsAz35bY3ZVdWfYYd7LPilLqFuUcvIr5AsP+Nr6oidrZ/3N0/y6cSafEa8UxFkex2bjz3ZZtQAf/OATqzGiffjwuXF2xAxuZhtwrp/TFeNs9gJZYL9b88wVXuasOnZk2TJow/zM2RwKfFortikcWYcyUbw3JzRYj44Cen5J02eD6kRquwsmlsGTaghu4S/DHfYEwbve9a7VLTmB/++zFxXzzLsXO8p25Nyc0/ubwC6fnyUwOK8Lo9MO8Y62StdKoBoTgYf5MLG/uyYYEfoekRHOhD8nFXFgTM/4u2tdOeXGikkrBvVt37Z2DCgiRKsmBoZGyCLNhKiIJIOboMOImF87VcfGdAlFzMkwIOAIIUxMOIhMUra+Jxx9RphTUMbCGeVIE+pVOcfEGL6rbX3ubwqToCxNjpIiON7xjnH8da8bRx7xiFWWzQpPIrycWA4IxaR9Ox6Y37jNz5g4gqWwYWhzKJ1NO94ljLp6zQ8HkEHCae4GCnMxxoqHcr6qlxKdEIw542pmZCjACWeSAiKQ/ZgnfBMKBB0BrGCRwIFCpd2qQVDpq2JMOdI5dFJPCReOoHOK1kt9BrhBJ3ChfbV+4PlVrxo7t771OCJTIweeEqoiOQFJQBGgBOYSjAlOZiD8zZMzSUhag3YOgLVA8/DpGWOuCOqec/uxK82qro+mlkYc/JuHdxkZxp4jr01gja0fmrYW3jEfa2LdBA85nWhQIA2erSl6ZTgaR5W8raF+/uW/XM9RAWm0iRe/6qvWmVkvfvE4gqf0S3Fam2rXGF9pn2jDd/D7j//x+hnfG5cxVgcIXVgvOPEumkan5lnKqfkyDsIVPKMN/6MBPIO/BJc8j2e6plz7yYd2KKoKj4akJRuvPro9AggAdf5ZGxXytYbGKJBm3c0r5WiucN4VidZEAMlz6K3rwx/84HFKNtYb3jCOCIg4d92tV/gT30hD1q7/yS0GHZoyxirUV+BRsGIuGoju7fz8q3+1lq3kn51VRjF+M348CcddKcxIIn8yyvESejR/xk0BZ2tlh8X78Gjd/N7LtlrJYHgie/3ABTpj9GizApACkGiGAVeqclXrjx5dP4tGStMmFzhFaMNY1GO6/e1XmXHXle4C11U7n9AYbugBbGEL+wG+pIvZOHSLoCheZhsIKJP5m+pLHQbow2rdzTVIANumAtrk1aabJZa8S2Yvgy/aIKeXwPHK1sjhS75VI27GQTUxAjYJ2WXs1eOgtxW6nAMd3XxCJ3mWTiAT2RNsNzKwmlr1RRfPWePt/M+OqXeMwXMybti5m2C/lH6y3pjMAY7JcW2ZhzX2Gb1PV5L1/q8QNzzNNW/0Yb3Mv40a83J1cYFxuqRahEvo6ml6Vx8V+rQO1omeScfvB3MhfHZ2Ny3RLRU9V6eloyn6o9Mq3pvjz04wXvaSIBWaQn/o3RqU+QT38KKNTYVMZ+i2JWtOJ89XWvuuQr9w1d8zoAl2ZMdR4ALNlcmBPozTWNgKcEh/whs7wbtle3STXVDAxPzo2Y4owecc/Oy2oaAbFZcF+ufaQkEXSahPBNhx5pk9SK6wnfSpzWoWwnd1A6u5x5Yx78Mc++NzsIvQXvX/tJmd3lhsaBsz+spHtF7wYTzeZ2vp13gr4mzdC3wcBrxrvbxLLhhLNxB2FXFHwPKDt/DxcNe73nUV9PitnKK9TBC1SR7IOF5tnj5wXHHFFeMPRfT34L9Kdd7dXdU6ucEAYRGOlF8pRl1TKnLNwWHodxc64sIoCKKikn7L7iC0/S2ai+EJWO1T1tpFtJwR33E8OmNqFxazKQrGYcDECBExc4QwF4eEAvBZt4loH/FXcBSTczaNifDpujsGgsKflBRnFdMaF6fUu+bipgnfe8f8/VSYqx3yrqTDLMaoyCMheeTIOMH542RxYs2TQw9Pdl69S5F5T3/GzWGX8UIAUrxFPBkg8O07wsJcKlqpvW4t4kjl/BsjRqZo9A3fFBucC9yUtm6shA6jwrsUhr+th35EjwmfnKLOYRI68O85tDIXbvScsXQLCUHMcbKuBLS5wEtndvVHkOiD0veu/z3PWXvf+8Z5FKd+KDdCCW7LrIEDAmoW/geBMXEYzTsB66cCtAGaEDwzNzvoXT0Ml10tl7LcDyi3BLzdCw41+qx4FsOP0yszCR8ZmzUwt4KLDBbrab0pQuuLLzitZIexE/T+Z+ii0YK0cIvGBLbOO291/GwVAEDbCXHz4IwbjzmiU0E6/O9zay0AYMz+bkfMu4yWHHw8aQyUoP+tc+ejzYkSBfjSe4IA2u3qboDm8BG8+0Gn+qsYW4AerIW543Gp21WiD3wOt+gm5aV9dIbPGRbhLcDPnHrjb/cVD8GZccD/nhF0Bp/q3/vmRg6h2zI5uv48xW0cDFDPkxnWVpYIvPkcTcElQ7UdKTJQO89+9noussbIDnxiXfdu7FnJyDnFFO34jGFv3OiUzCIrMhRKJzYWxiiozgAwP+vi3dKg8U3BZfj1nYCQNTM+hstHPnK1rDcGc+iaSLt85DT879Hozrbo6xa28MkF+qxbNEDHQyr++IkEHclBMmGya1dQUBUsC2HuB2TJsthrQWZygw4jl+hV9gbZVXFS+oD8IsfIXvbNDNqYjw21uUcneE8/fsgucou9UgZMWTJknIw7dgPbxHg2FZs0X7K9G1LohE1p/xz8sm/nYM5hgG1nfOZg/nBCv5pPBT+71bC6Mn5X5DSboeK2Ajb0rrl1Lbx32P90EB2yKbuJvWcs8A8f2rBGQH/0BtztV0dC/2x275chbDONTaLf2qCfrRmbxRhtRqTnrBmd5AICz9vkQN9lcNz61rsrXUUPwVeFz8syWh7VoHdn+6KACRoKB93gyb5Gg/M6Lm/GYUeYAz1Jl+ub3eRztoJgB71tvBVHZY/BubZkcRUANN85GIenzd3az0EwwF6u+P4SjJe9WtHkxglPfqxrxZzZKnPb+THZD75no7Ob2kQ0F3xkc1TRdzYvujRP/u58ZG0JFccXKMruAuQJ+sKPs/2P/vQNv+aEH2z8W2/03k1VeNZc8WKZLfPV5AcBW8pas5HbPKw2VCcx4IQN5HvrNMubGT74wc3Fc88l+NCHPjRe/vKXr34q9OrvN6sbsbMzHve4x61u0fnFX/zF8apXvWp8zdd8zbjjHe84/o5o7yogfM/xJV/yJePrv/7rxx/8wR+MF73oReOxj33s+Ht/7++tnrvBABEjsjIpOi5BiWASDEfgVbBH9NZ1ol19xnkgoAQ2ECNBhbgQDyLiEEhJ54x3BRQhVaofRattgsPnmMnOhxTBrvZSbIsiVVWbIiDMCSCGPWVEYBC0+i8V0riNnyIpJZCANVdHBfRnLpwHO/L+Nx/Mj+i9w9g354qWGY9jD5waThlm9N2ZM6taG6vn7dZiFEKf02A88MCRrmq4cXK24Fm7dqQpDe96B66M1TuUEJrjNHIqpSXKmsHwgiLdJmPcXVNHKWjLcRVj9n1Oqv66wlj/jJ12MdAh/PtOv5wiAQ19EUpwyviimNwgRLD53hwpDbv91pRS0wbcalMQxviq0m09BQ8IMMKKsO/moQc+cF0DgXMHv+gr2kwg+u4wEWpz4ARbo6K9FBWaJ9gZCu186QPOzHMWxhUIoxAOk7aXIdLZUkqVAO08tOt/4eJbvuXqVFv4smb6wg8yKTIQzROdWme8VeYRhQrXbkiYb4TBEwJwp06ta+V0a4/AAOWFvwvumb+ggUwFmRuccHyF14q6c5rLzIAH+GKwZKA2V7SxrBzuWUYPWvBjHhkUlCG6NHb0ZV7WHa3MheLma28B+hRA0hY5E1i7ivYxBvAiQwPPaM/40CPFaVzoby4OB6dkgGcZC1KB0Zq+nve8cZyMgG9BJGshsIIeZMYJEKMbMtF8KWtj9r728GVHgvSXstW/scIjOWaO5JTPybqu17YWFDN+JDvIhnCExuDCuODY99ZQH9bes3iIMdSVfcZiLuiriv8VgyO3GR+MXnMhQwtUAryDlzJ4dnauriNABhs7GmTg+vE8w0kfl18+zsPz5xhsM0y2cKOGHI4l0AvXxRn7js2SYbPcLuDge/KE/CHr2E7kwPJqX3YOfUBuz7qEfuIgy6Qkd8m5bucj9+mmggNt4M1OMGBTLR0YcpJsZFt1rJjeIKfZp3u2/koH07dkMvlJrumvTalNN/qQ88ZHvrYJuQk8V8HKs4H26Bg2FB1vrnCYvKcDBMHgkL5jc9Dv8w56GTX0E53H3sz/KIhvLHD4tKddncG9V8vwL0FHR82BDoIzmwHW1//sno58LtcjMFZ97B2xXwH9wn4WQCkAhnbg0tjpW8868m5tzPEFL1j3j06yRwHd+4AHnPpY5jRegIOu7TXPMmL8zynOBwi6KncJ3kOL7KycbvRhPGVu2OCAp2qdZA8AQTlzbSOOn1DWJ33tODb69C4wZvaTuXd1tnf0b87LoBzcd2x8Pv5Gx3c0Bw1bW/2xvfAd+/e5z13bTpvAWnZDY4Ecn8V7oD4LSpoXm4u/sAngvQAN29B77Cg23UFgjvwJtgucwOcmOx1u2NpwOWc6bQpwLaGbVtnQjhvDt3Hp22/4Ymt5Br3yN9iImzKqvPOHf3hAtOgcgZe+9KXjvve97+oHqCvi76fsFZt64hOfOL7lW75lPOYxjxn3u9/9VgEW1wjPZ6xf8IIXjHvc4x7joQ996HjEIx6xulr4R135ekMCQsc0iJPTXxCCcvHDScNMlCtiYChTVhWKIqwRelkFPm/3nKAjODlCXR/c0Z/Stn33gz+4DhpUF6ICXaJ5lBOiJIAY8oQ7oeyHkCDYPMPRJGgYAJz6runFxJ55+tPX42uXt+rU7TCYo7H5jDLym5KkQDlZjnkQAN0tTlBxrIzHDRdwhXE90zV9Xe0ry4Qw95njSymPnLTSBgmhzlkC3xFmfgSKHJXA9JQ7J9O84LDgQ+eS4RSuCQOBAQKIk0tY7dVdWAk6cxMlNpeu0tOm5wTBCHv0vleUdSWwOY5ohOL2XGMAaBkurZW5G1PKsqvFOtZirX1n7vCtL0L6539+VWhzpZwpko4fGBthbt0YSfsp4MCzZZYsjRVKDk21qw44pARdu+8zGBsFU6Gnw4B3GC/wZ8zWVBuMJ1XmzdsctDdfPQdHnFS0bafDOnSNskAKeu4Kb+/hWfME2hC4ZFT+u383TqI9fcAzQ4IC1j9HmPMNr/rSjvUn+NGgvvCTIyIZt127Zh7o2Pz8rmgZeqsuCJziewEROLbm2vdbn/hEv4wa/1sPa9pxDjIk5an/gk3Ae7JitGEeDHVgbMaEdrqKmtLCYwKMZf9pl3EFr9aBrOnKRim/XS0Ol2QMHD72seNIAVcKE/3rf6+Y8seCGvjEPDzH+NC/vsv08QxlG8C3743FuIzFPOAEf8ArRWy3Ba/im3gVkEMMTkZANWqM2xr4ndHoO2NyxMt4tW99tIV/22Gqpgl8My6tC+PDu/jDc51FJ2u7Cvyd71zTsT7Rr/47WgUHeND4/9t/W1+/fo7BNmCyhU95yHF6zWuOrewR8oVsIQvoHHxPtpAj3YzC3mKb0NVsBs+xb8idMlbIHDKI0yLLtbpfNmfITzKX3KGXDireucleIO/IWM5UGxBkovbZWORr1+qy6chfYzc28zHejlYugcz1TkHq/aDnyhpgY7URkA2TTKcT6BdyXptkLf3o3a7DFbg21+orFKgC2tA2HLMRbdLREXPhbDZK/3eDiU0ZMnyumcg+KWClP2tdJmRZl9bIc+yErrCd36fH2KV0nEwnAar5uEnz5ajS0Zxwa8b+8VnHcavRYs76LuCCdmw6XnTRmZX/Yl3hqLo0si3RJBzIHGI7maexsW8bZwGkJRgvGwH9FGAxn0oLwDf6MU847ziHH/oTnm0AzdlFNrJs8gLvmUu1fOAGzUcv6IINTidvurHFOPgD1oT+LdvEnAsA4UE4shFr4479pU+Z1QdtbsBnmz+Nlb2azWGtrJ3xsoPRqeQBbfOt+BF8HVBmbjxgnmiFzzUHrpZAJsxHrOebes4mA+CffeoHbbK9NmWLATi2caafjnx3jXlHHtEkWiAP4BSNbWoPXX3u5y7So89BeMhDHjLOnDnzcT8/Yad9tRY743u+53tWN964veY3f/M3x18pMrgHbsT5qZ/6qVVl//e///3j+c9//rjZQVV2PxmAMDG3oAkh/O3fPsY/+2drJi1zA0O3c0gICI5813ethReHkCHOWSf4tEM4KH4qmOA9wgwjOvsvNR8xITD4EbXHKLJKKB6EyQngtFG6CJKQ6z5w4yUoOE3aA1VsxjwVVEK82uUUYQgKxZwI1Ap7aQtDG0cODsb3PKHC8cSUxusZeHCuE54IbMoJc3/RF43zOKS+TyhWxZvzYf6+M2cC1JoTLoSZcdnh6H55+OLQmbf34FeknVC2ToQQp5Gwga/OhhojBUowwgFBY34MDLvg1o1jx5mMwTvK0+4QIWZ81sC4CVBCKGFCgHVExHf6gicC11rBCwWvWC18iBoTlhVFMreuz0M/MmDKyKEcCf33v3981LoSosap3WonAHhcph7CdxH3QHvocVOUt7OL8IPG4Yaim6/mm6GIPJpc1CHaF+DF3Cp+RqlzjDncKUhGY0XSCs7Bt7nKynKUxhrBO5ox7rKkjKUjZf72juwVBp3Ams/bpbPDry90hBY6e8np93mV1bsGzXuMCbipwCg8UnpdKwdn3qHcO7eKXuHRDiElgx49y+F3VA0/dpsA/OPT2RARxDE3igjvwRk6nuVoOxl+BCHwEZ70HFnl/86moycGCTwZLxrpzLtnq80jKMzYM7auCQwPezWP3Bi0whNaXNKUOegLz6OPsobwCSNffww08pM82bsafjUm59dbP+N2tJFswz8+7xib38bvM2vLKcGzcDOnOxsLww+tMDJnwJ8VHvYeecJA8xu0A1YBbrjL6LF+DFJrLGCOVzqv/yu/sh43fNqVIsvJMOvJoYFD9OQWoeZ+DsE2YLKFT3kgL8nFe97z1ErekqdkOX0ByBMykr4hT+gLsogc4bTQg6XzkynaI0/ZRBws8oVtRpawlyrOXVYtJ+XaXOFJFlaccplJwHYhZ6sBBcrWy26vhsim2hXkvjmdbXOnoznkLpmpbX287W1HVzgk5+kHNqB5ksHGTbbSN/QtXcJulo3jb3j3Hd3GViTjBUiMn34yZ21m5wfzEYWCID6j67VJj1UfpCK9bLqKrgL2TRmQ/AI2C1ssG47NyYcwD99X9J/v4HN2LdtMf/rXFl2PDsoS8jycV/STPU53O47sBy7has4eECTSNxq0MUY/e6bNOButdGT1QIxLH5voih7TVraEcdiUQbtwWnBQW2xYNKBf44FDunlTDT46VQYw/wX9s6HKqmZLwW0+RUV5BYfaiNGf+Ribtsoc9c66AO6aj2abgS1YlrB5wK0AFhzut0Fow24uDGvubCQ0yI7EE8aE5+HQGOHfvMqGhR9j8Zx3/Z/dT4Ysg4lLqABvsF/wcgls1G6Wwh/sKkfPuiFqBvPH411PDiolgd7ICLjUXhuz5kteLI/6eA/d3OY2h0gn28KNEyw8hiE4OFOEMMHs2AuiR1wUE8JKGGDCCiYSYgR8GR3VrvA/5qzoF+Fgh5txTVhxsgkbxrdaIARDhQMpRe1jAJ9rh/FunAQCAYlIOSUYpjvbPaNNzhLh5H/MhtAJVERtRxeTGiflsXeF6oq4CR9zIuA57dqWHaJ/jiGlYXwEGkFOMInCfvVXj6MEpLojlIv5EfaEA2HF+fOsdyguyh9z6dOcKRMK59/+2/X8zNlYOR5wYL7+NraKl3VbkeNFHBVjrygsB5sjVqYKp8fzopvmYa21aXxVVOd0Fpwg9KxPu/+cH8KJANe/8cIBoc/oqap5N6zAhe/g7Ud+ZC0Mc9gJQvitJolxVwODQPnQh8Yp47WG+kQ34afo7hI4wXZ9SmulbD2/XyoyQKPwSXkJ7DC8KH5HwTir85Xd+uwMtDWb0xuB/83ZeEtpRXOdpxWIMkbrP5+txmcEPPqFC4aPZ6y/ddTuN33Tuo3GB5fo1nMMH2sE5x0/waNo5X3vGzeTuSV4RbkZPwVkrayB8TAI0AQeYJCUpotvjF9ACxiP3RTtWguBQu+aqzX2Xcf40AjahzN9oQPPWQvjNA8pq2iuHYqCXXirOiZ4iYFnnGVVeM580S5ag2fBWrRuDmiqLCk0IFhKdqEFeDdOa+t98owRgnfmHZ5239BdmUWWGL0Yc+eZl9DZ2Y71ZFBbD/jUX0HlzinjN+0JllVADU/jPfLTGKwDxc7Qqm6KdspkmQ0fzzBkjZMM8iy+R+MZEnDrHfTSbiWDoLRkBqN10EZ0bA2sHZpkIBirdQd//MdrgxFfCFaZO9lgvvoJt3vBu52Zr84R2AZMtvApD7OjXRCcDCNbDuJ5+oC8q24UKKhK/pD3niHbyBZ6j97u+EHZmRyzg4qKHgbm64+BoAQbky7pc46nTT86OzuAbpgzB2c4bH0YurCs7QqqHzt25mNBfM6xORdwr56GwIcNEbqy7Am2mOe12W2BHMKO1GqD/iwrYd4Jp4tyDOmS8MyOrRYY21QwpswZ4543m4xh3lgyfrrIj77pDvq4LA42ZM8LmtA9bDL6L/zRgd2m41m/0Y3500nG511jhxdj93vvePIqIEcXwt28uVbBX+vLxmC76FfNQ1kXXZ09g3W3IdTtOhXEhXO/6X79sHvSxYJuxsQ2MUa/q6u3BDoT7XVkFm9VvzFa6aZR4xfoEES0jmz3bhyaabmrpa3Bcj58ALaed9lw7HR4Z2cYd8foAHvF5olxtWZwxv6W8Qvf8IBP4MD6sDPKVmX7+BvPaN+8jJVNaz7suI7jAHbEsj5SNDtnl4Aypcs63gRsLvagNYFn75A9ZEfBQFAA1Dqhe/NlP2q7IBuoMLH14ENVE6jAWz6J3wKXy4sitnATAwuJoDFzQQ/piAQtQuA8+JuRTBA86UnrXVMCmzJjXBPQiIPgEiAhnBA+psBEPscMgiCUHmItbRthYkpOnToKdiLL5qiOSDUeEGIMjeiLPPrs+75v3V7RckKdYDAec+yGHIyvqCIFR+kRWgSf3wQT58Z3AgvehQvzMHaCVc2PAiEEGKfr+PFxpag2piLMBIEELfTJie04kp1fY8B0cFmmjL67BYVzTYiYG0VdpLbUO0oA4xI6FazyDGWpPX0RlBUxgydMLRgmzc4YCc9SWK2LQJY2CAK4YBB0/KRaNgIzhADF9f3fvxYOhJx1JyzQiKg0IYpurIWosgwi7ZY+B2/W1poIJDmKZY2ty17Gz07p/F3/6qdru5ZpbujCHCv6CayJNdsUXJnBeLrNxZowKuDXeO16AThFd3BWXYj5XKV1QuOdie0KY3PEO9Xc4NR3jd8M8G4NCG6GD+e0G6YoFDRG6VB2VcW3HtairBd0bK4V3eK8P/nJ44MyxdAdfgw3nmMUcbYpNvxoDQW0fE55WotuEehqSM9qCx2hBZ8XIBRAgQNtwadxWUuKzv/Gj8YFI+APzZsPfOEvssIYzR1NlQ0WD3DK8ZJ1RV9or3VHQ+2O4E9zZ+xQuMZmjbtFQLFYClVmjXfw2Xy9NEBnAprwOlX2P8PQMGfruylgkqFoDQLrymiYa7Kgp+QePjE3a1Y2D4MDr8BBGTgZ7D4vMOv89rx7Zm0qLI1u4EawCE3ppzo3rQs+zuCFA7hHI2QQmeU9/+vPOmnLGmgHbVD+1uP1e9cxowHQzoo5kdP40jiN73/5X8bpagWcQ7ANmGzhUx72K+xKVuyX6j4DeUwm0gPdzMcO4QSz/8gin5FvZPvsoHe74bWF5Ci5tayNpm36Ys4SqdAlW5UdRb5mDxtnAQeyNr0b0D9leM5QMCineH009djKlqRb0wNdcawPOtAPm8135DkZ7d2uqze2MlPYsGS/DZhuxGRX0mllElSfwpp1BKcjoKAMUeutDw6l9dInHTIXIl0CvelzuPN8tms33nTZgPl0/H7GD6ee/qR74MDfHX9oY1bbcK4vuom++s//+fyVXa1ddELHmp95wZln2CMdJ/eZn3/xL9ZzWmaYVJMu/FgbmwZ0tvbZEOwe9ARH7B8/5mR92TjGy7agF+dboKJjn6F74+xYdZsw+qs2Ilpi62ar8eX8dDRpCW2eAbYUO9d82H7ww17NXoFjdp9NcfbAq151bLUhZl3QEPvWeGU2qytT/UM8oe2lbcVO6Pg44OexNzuOp1+BP35KgTLzsE7LOkFzwXp8Zx7okH1RcGcJ1kJf8D/zs77Mw5oLCLEL0Y4f69+crKH/sycDfXc8me3ElyDPCj6SizYJ4dlcDlOvaAs3Uii1vVtCGOYcMIqC80GY5rwwmjER4YY5Oe4IVBVkQRFn1BjJnYPn8CJGggihPec56zoBCKZMFYEGzwnEECAMdkJYexwLjh3GFOk1rgrqIGzEj5ERNmbnEHVffEGfbhjhTPhOsAfBC14QqmV/dDSCwC1whIEoGNHbalhoaxZGmPb//X/HTkdbBH0wPuYg0Ah3Y6AMzMPnxgyXpbR5199dRwtnnHeRbrgwTsKndDtKTuYLJ5cAKlLbMQlCFG70D2/dXgIoGJ+ZF8XBAU7JFqCBP8Je+zly1o/Ta0ffGsCnNVSTpbvZjfHJT14LJLhiUHAIGTr60L6+GQDWkGKDB7U57Eozjt7//nFeZwbhLuFCQXd2sM8IH2uDRigNQlq7xm8HnZCqYvsSjIWApaAJcmO27nYtzEe78MgRnIV8Z2j144dA9L41MAbKqiMepWzuB8bftbro7bGPXeNZ+13rZpzGZi3RWvVcZqUDh4Q2BQvPnu9qb3wo1dRc0I/3GVDW0Bg9Y9yUCQHPiMLPjBO06lntwyP6NDZr4ciQDI75al/KmEFnrNaP7MDbxmZNtAFn+hQ01Z930LjMMzLIWNCooAX+Rc/ahFdzsWY+ZyThSbKGwha0w1fV0yCj9GlNzRutGScj3Pjxe8fEltBOZcVQg2p3HOZGgzLh0CyDzFqTP2Sm9cMD1q7dQuvFSCLH8BY8oAVj9T/eInPhUuANnRa4Qz/kpvbwercHWDuGoPmgI+/DjzWbjSk06nNy2rNkpHcrhuhvPFCBOMCoITtP7hXlRReOm5HFcJzMgSvj2UtzPnKYlNmbGGwDJlv4lAdyoyy1GdhKS2dnzjghk+h0crLU/LJOA/qgGh1gWU+j2kvXBshkt0EaOxk1X8V6ENBF5CH5TXd17BYeyDif+82GSV+3Kca2agNuPqJI/sJNxdLvda+TK5mak0W3wxXdRuZrmx4V/KYf4IU9ww6i68rg0C453k1/9Cc9FD7ZnnPheDqHbqFj6TB2N1ugGhjGTzd4xlisMTuRTS7AY202FcKlS9kDggbGBIcVHbbecNc6birqj1asNXvLGLKFtFH9im4sgXtjW9+Ud/RjxTrZIGVMdINh9QbbZA3Ywl//9VfXlIF7a6xtY19m0Zg3PJun8VtD42HvVGPMeJ7xjKsLFVujjjJrT3CC3WwO2S76Nce5PkebRPAFJ3R09ow5VVh2P+jok7EKdLCXBSFme7WNFP3K0H/+8y9azYFN0UYY24sdh4aMCW1Vw8U6zdBRrWwD8yurRTvWBv2zY9B7tIDG0VXBpDm7xDjYROYrmMNG894c5AvYfJtqvWjX+ps7/wS+2fDaqaan/rqhFV21FhW29Rm7zHgKsFWrkT9DhrGp9fGGNxzi9ogt3DgBARDEFtUCIwSLTxh3MwZABIx4BF6hJ8whOwHDIDqElXDm8CE4zlZHNyhCig/xVBAwpiSoOmtHsGOSxz9+/W5ZFoSwMWE8QR471Rirc5n/5J+s3xWt5NxVHVwfshiM1/P6MlZZIBSI6LO2PYOhHcfpOk2ZJoS89gQIOGWYUdvGLXBBUMCjNghivz3r+I9njB3OBIs4HgRpCgJ0hSnBVcEs+PMcwWZOFTnr1hrPcaCNg5AkoAjsIu0UOFxTyASytSAMMKy141zLerAu/nYEi5Mq6GQOPk9hVrRJAEI/lMETn7ieAyFHeZqLcXWlKjohUAl/gRfjkWaJTtAIJ1mf1gbNwam1vcc9xhmCSf/mK8gE0GaV8Cl7f+u3K778wJG+CDkKRtSbUvDMEgjgMi+8a37o1lp4VyBPoWBKaXklHoFuboQv+pmd6tIBrfnZbiDAA9rQLycTzWsX7lIsnoEbOOvc6HL3xthLGzSevcyhHYIcX3g+PoMbNKJ9AQr8ZT4VZYXXzjgbF57wmTUhF/BP18b63hwpU3yAtjjbAjHoXBDMmGXEUGacbc/Elxl1xlBGCzqpTggaxzfml5ENJ2QSI1Ufxoz+0QeDw/t4RNvGiUbIN3Rj3gUdGazWbVO03/NoYxlMIb/Q5UHQ3NqpQsPt/FGm1q8jRWXzWRMyC//7vp24quGbF/z4HL1aX+PIyEXj3ZxjThUc87edLzxoHRkWcLKs9wPwss/1qx3jEpTpph9yBG1b9wogGvMHP7hu0xyNr2uy5+sMPWMdb3nLsVsg8ByCbcBkC1vY23xbXvfejTU5MH6T+QURyMFu8iDD9jvCMqfeL2uCXJOACX0wy3x6gB503HS+TeYwUF2WAskdm6Vr6X82NNuBE0yf+GGzsQ3ZKdWlC4zBRhl5TWaePLmzcmTpOPIz/Q7YTOQwXQCn2qxAepmtdCW8lM1Ip7MRbZbRGWyw6gP+0A9dfaSKztaW+bRxRqezRQQt6CBj9/9c20Gwnx6oHtec9aO/3of/OUMg8K41yIaCg45jVGS2WjnG5X14SMf6u9ssBY/oLvN+wANOrmxxP3QWG6XsD3qtyxXgbZk9Csd7R8VXa2UN4dB84NVPY7H2Xd/sNzzMBevLVu62JXYp+1nAS6Y1G4mPwm7q8gH2jHY48GiVXq0WHPxUj4RtYmxs/bMdey1jQ79wWoa99udj7OZp/H7g6u///Y+u1g3/ZrcYGzu7wsjoEL3aON9Uuwe/tIkJr+ajTZvtglNsSYD+8JD1seZorvdm2jEWgQr2ELpln6DN+cYuYHxse2NbAlvJfLyPX6qZh546ntTRNHyor2h0vjKcfan9+oC/ssn4EwKP5vUZn7EhmrOFmwZgNkyKEErl44h0jo4jZqF9VwEnAlaaov8xCMGKmDnoiNlvzKtNRMfgRzSEFaFA8BA4dr69R3kSjBiDo0OBEW6Erp1sClEfCLHIMdCXYx9Vyaagun5W/xwK88FEDHWOdveMJywIIkKcwMSgmIHTQGh5nhDRt3kKyBCuakMIshAy3r33vceFlB2FJHij767LFUzRhuCO+XCIvOO5amJ0rzlBRshTdpQUheb9CosZr6AHHMGZH8wuOlt0n4AlTChz46jegDUkNBynoLj0K6LuGWtg/t7vCj1r/5jHXH1NLcGG+Tmj3cLRtckCTwQOWupqP7iANziyE41utEFwEPi+73yu9D5gjW5/+7FrDgwFOCfYGWGEXXUsyg7xG32W9trZQu9y+gk664gO5jPGxtOV0AwBtWN8Nkef4Vg2DQGObpfGFPws75I3Puc7SwWlaMx57tvflCyazcFHg/BeBXXvcXCtEXqwRh1JgS//O5aRUlB4WsDFnNHX3tXSq7obXWNtDtZxTi+1XtYHP+HlHGw8UAClgKgAGTyXkkixGk+8aJ76sIboryuaO8qSM23+pWhbP045A6a06LlgmXesgzHiperHwI21ISfMt1RV/aLlgmRqaqA7a9z1i9rG//Cg/eW6Fozz/XKHBJ/ud+4YWFMyiXzr6BOArwodFnQRpDR+Y0MHfmqbwibPrA85lYLGN+bobzzWlZbd7tAZ/LLhyHHzNi40iTbhxDrOu2NdX23M5m0O5Ka16dw8OmTI+ztDyHxOnFjje67NgzeiZUCeopOzHZG7icI2YLKFLezVg3jzmz9+95TOIqe6xazNAPKfrKAr6N7DZncsgaybA7T7AR1TAVTQcWXj9h2d0wUCgI2T86n9TVkTyUFOp2AM2VkBW/KfDGUnsOfKrpjfI8O1TYaS7exdgQby8k532v3Y9fNwSJaT88ZKpmevdxsiZ0x72eQCOWyrajukZ7zPLiKf4cAmIH3eMeSODelLP9qkM+gJdjkcVsScnvUM/QboW+Ocg1hdw8r2dxsN3dZNjTPQK/RjxWG1ow190F/agWObmPRRxf6Nkx2wDJqxBfg2D3zgyZXd+93fvbatzK+sEnZFG4/6qKi9OWUbsNXZ3Z73XgHArjtG03OgxbwEPGRhzkey2HAdfWZnwQF72Fy0hf6XNqW1ZedZH7Qk+FYZBLhqMw8No1802o2AYNOGEDxaL3zgdxkpsnDm48PmJVNYuzZv73Ofkyt8eqcbQb/1W6+2Obulii263JQpeNaGET9CcJB96RYm36Mz9h57Fc3iF3PHG+xwJyB8V3YJ2rce9Qvn/Bx23vK2HHOdg1czmKc55ZPFj8bjc7hNNhmXNbHe7Cv0Qn4F7DWbefwJ/hT64B9VhoGd5SaxLdzEAROLjHfveWfhGe+ELAFIoJY2hcktPuWAeBCD7xE4pi2lDgFpG3NgPI45p4tglbWhHwSLgWSUdL0bYeIzgongRLCMdQRY25iY0ytAg3mN8Z//87WzikEQqeAGJug++M59yprAgAQK5sMkCQuKwP/miUEo5BjeLUKYsRsz9q47O6MNQkNGDQar5ghn2BwoUgEQAoIiI7QIVmPoXCdGFAAiuDhU2iRkfQdfhCvIyYJ7itU7+u7WEkwMz4IYskZSlHBKWZUOSLB41lgJ4K6UM051IqpFQgjBnXFYQ4qa06k/38/pf+rD+L6q5yLH7WbAKZyVYUJZowXrXSrgXe4yzhif7ykzCoQii5YIVIKUoIRDmUYpWLgybk4vpWH9KDcCi7JGP9oyRviBC9lEaEGU3NzmglEc5gSnNisKth90ZR98UuyUpR/91i5a9mNu1n92XFM6BHfFu0pTpWjNRbueozzNoduZqnYPn5R9UW8AP6VqLo8IMfQo4/kqtI6BoH28ho667haPGDOlbf3jGXMuEJpSt7742Xwos3aE4MRawSl8Gq9ntIUfOwNqzOZWkT1rWHo2PHnP2DxDVlWTyLEw71LqxgNn8MWghHN0CD+l8VpX82U46lvAknybjdvDgHUW3EAvy5RYn2nbuMO3MVrfqqqn+Mk633kGTXYtNXogFwqUmatAc8drMkIrZla1fn3AP5qCX8fM0F9Fewu04C+yHx7xRLcRGUsFuPE2g8daw+NXfMUad/Cp/4JEZQo1LuuzKWX/HIBtwGQLW9jLwHvrWz8+YEL2cdzZOnQfmV09umsqY/eD6n4dBOxTspHdyH4g5wRq/E3ukWXsvIIvxkp3VOdhrjWxBHLPphibttvQyHl6k1ynW/TXEZwyLehXOlfb5Dkd73m4ef3rj67kL31Hd8viZH9zxtiZ5myM2iCj2UY2i9gK/qdTOv6gXbYYe4nzKVjPNqUj6RmOMR3OPqJnrQ99QY6bT1f8+j8bDC5lRqRrQLXz9M8e6WpkYzQu+qkCtXPWUNBRFHqZ3uCgGws7G30Zp4wC+BS4odfnuh5lOPl7zvLVF1waA7vD/OHRZmP177opEA7pVTak9rKL6UvrZ53oO32WUcJe9Rue2DZsJPQwX1dLZ5oDYOsIjsEHG6hi6q1X4+fXdPwMXvgGgi0Ce+bCFvC3udHx6M96WDtHq9UbnI+nVHemDHbPB/MxtzmTo8xtY+52PHTNZ2APoOVq+YBoOkADc+FWWRtsDe/77fl546oARseY4B3ejMGalV2CJ+ebhtAOPsS/y4KrBRgPugVzPo2A7yvquwnwkfVkX82bkOjNGqF5OMFz1bQxbnxz+9tvM0xu8lCKFSGAuCgJzEzZWXx/c0DdeoKYECamFEUjWDjm3sfMnHvCjiBGvGodIFbMJqukYlRVgkZk+sXghCzhi5EpB445oYnJikxidEKAYDLWHCtz4AjIBGmXkyNWJDomIlgIDYz5b/7Nuh1jNid1VsyRwkLomBpjZOwT5Op+YGaOKFxceeU4gbm0LYBDoHtf6h0lYy6cNYIWwxCO3tUG5URRE8CEmGcwofYwr747vwsXlByl5nNrpJ+KrnLScgi9750CQo7TEGyUNuHKQHBExnphaorA+hh/RWZlFcAtXGu7egWEGaVLec1pd8ZCiVk389afNaE8zNfc7FB0vSmB5/ywm2ASsBddNE4xYgSFrJ2xd4Y0QJM+F8DpPnrztANOkVJUhJ5Ib0dqzJEj79YY9Ggd0G5OnrHqx3pSzv43ZriglOG+25TQ+aa0xypqW0tOdzVlChSgX+1ZZzRoHdBthl5HNuC0Qq/mw6jUBqVB8VgzfAM/FL6jVZ7RL5pJiXf0pGrzzWM/sC4ZOmhMW2gLLq0tp1qQrusIGcC+96y+0YO5mBuatcNCyVX53zjgJVpBg96HB/QqwBa9zUBpojeGgZ2xbtbpVhnj8YxrmBmVXado3dEYfjQO9Msg6kgb/jMHNyOhH0ZU47umANcFejKUZ8DTBRMYPhlOgPxbpiebT8aT9XBUrnO2Xa1eWnQBE7SZAwKPBcrg1VoyshnI8ERmP+EJa1mH19EFeY1O8cx89Ai/C87BIR5W/wkdW9/LLlvP27qjDc+AjgaCgnD7HYG6icM2YLKFLewFei+44MzHZZKxH228kf/0LTlWEf9rEjAhZzZd35sMXRZYDaojRbZxZsqUoGONpR13wM4pU8F7dCZdQj+Rj4e55YvsZEMk022isEnYNfQ3O6Rb7fRBJxlbmxxwQ66eOLGzcijpqQqbdukAJ9Mz5p1e8YzPBQTYKrKgPUvmm0cObTabd9m9aiuYG9334z++7gee2Ifww2bUh7lXI4T+1Zc50bfsx+wv46evfM7upeu6Yp49TR8dVAeMveC9dCg88i8KyrD/ZJjyCWYn2FzNGehv05FoOKaP2Ib6oa/YIHQye13Aw3qbJxuUP0GPsj/oWv2ZN1xWk6bMWnYL3JtnGd9sIbSgXU758mhZdgy9biwV12eLWhNjMd4CQR1H0o7PtQ/vMke7NIIdj874COievmZDwKnNEjY6W7ULGDZBlzToh+4uO2M+/hygZTzUGNswDfB5twACbXY7K3vJ8wUStdEFC61XR2RsnMF5x/asy7KwbPUc0WttGut8BfKmOoL1B9/o3f+biuaiK/6nubB38fUSzIedxOeopEAyxjq8971bk+EmDwiPkLWoHCRORc60XU3CCoFQcIQNgxtDV6MAcPxTPIiNwY9oETGB4HmES/gxrgkHwQOK1HedweRsYxzCgMNJwWEATEb5MMQJCAEQY+12EIKJsOBIEmIYTPsEBEYwJs8RbpiQ4E6Q6d/Yu8aWo6VtQle7mIqyxwzGJchSdsev/do4gik9a3575/VXzp324IgzRkGbV3eLYyLj1LbxVKE85hUE8bm0N8dG4EybgiycvJwmgi8lYg053owUwtPVaISM9RSs0j6la24UJfwSjIIvFGFRa0Kxa1q9Yz5++x+ejBHzw4M0S58zAPRDWJs3gWaMDAh0wNghjDjTpXh2VfVy97moMxxb72XKLVpBl9bNmpT1Yw5d7ayNClOinY7c+BveOHzGQMByCOG3wBknkiI1vlJ4KRlrhzYqshtUMMu6Ughom+FF8XEmi1rDXUWprFnXMVovNGTO2ipVGS0Suh1rMz+KG07wF55kUBiPNihsP29/+zhKWfoOzXd8Bi7Mq6uQtTE7sWiYsYBWjcPzxlBWC2WGBrUrc8fY4K4MJfRqDvtd8WgM0T+5gAe0jweso9+bMhEE3gRCy2iBT+vdNYLebScOTo2zgCf6K+sNHQnw4JnwYKxkQkHWawPwMwdJ4A1e9Nt6ZUDjnTn11jzms7XG2BEtf1tXMrMr6bpRQDvwon1yTMBrvTN59Vn5jsOYqww+641HK9RmHRha5GqG3fImG3LA+PVfH4xT9Pu2t63XkdHESMipKDsNZORcdNHYOdsu8E0QttbPFrawB3e96+mV/qn+QPqQ40+HzRkAZNLyCMJ+QKawLzgrm4Bc6tZE+iM5w06wgdOxjTYV2GNlAc4Bk46ScFrTNZw6MN/EB8yF3VFgOCBv2abzMQ2ymsxlkwpG+E0+2yQ0p7JEtFm2yD3u8fFX//huzl7091z3hWzvxkS6j21s3svsgaDjGGQ1+xEejb+affRstwl2zN3Y2CzdiskGgWPOo+AMu4A+ETwxN/g0luqLaBttzLcNBulLwQD2ujVlL8xHRcCm41tzYXQ2/5x9EJQ5D09+6MR/8A/W9TOsgQACO48dRJ91q2S3JbExAnoTPdG12s1fQTtokI0Hr95jC1R/ZgbzbD2Ni76u2L51s7bGISjS5QN0P5pkp9PZAjQdpbXe8C34xX60RvBhHfgNeNB82QjNxRzniyGA5/a7DRCNGCceRudoogzeAA2WVd3tNXMWCb+hI1noog2iZRAVfXbsqIslytzOD9kUMJmPhNkshgO+xxKW/VnHbh9dAt6Ec+toLbpZZwnV2jQGtig6QQ/WzLzvdrdthslNHhAIgxghIgrBEp9ZdETYDSVdH1sEG7NyRDExBuIoMrpFfzEdgmkHOkYjCAgKgoWAIyA584IPFTCihHyXIED8BAdnDeEVgKEYKC0M2W41hvG/4ykcum/7tvX4CGCCmyDRDmZs94CwJGSNz80vmNFvOMm5cvyBoOccwAUBuVdc9SSDwLvaJOTt+hPynApj6kyfNv7lv1zv/IvCEwB2dwWKOiNLUFWv4hu/cZ26Z55d+0pAf+/3rgMpcGUOxkLw+hvuBC38VLRI4IvQMA6CktPTER1r5rgPPDJKzJdSI2QJQjRR8MyadOzD+gs6aJNyFJywhhxUita6aZ+BQImiAwIc7ciMIERkBIA50wIQYl0vSIhZy4wttIhO4BcdVBtHu4Jl6IPw9kP4wa+1EV2nSASM0CylmKONdikbAk2QiYICnoPvFHlnGHMWA32g6440wZf5oRXBLvjSNtzo19pE453tRkuEcME7YC3Mw45YTjLcWhP4xlNosxtuzB8tXnXVOOMz+IlfrJsgk8CNtYdffNWRp6D6HmgE38Iz48k6UP4ZaMbpf0G2+QYDeFlmTMyAVuGwXQq80JG3boypevocwKggWVc44wlrwvicz5FWAI7Bgt/bxUPLcAV3+rcDxEhEA+rAMFTm2wKuCcBlRwWN2Rp1vAUt4/NNKcigQrwBWsXL3heY9rtjOdpmXHgHf6Ila4kWrMGP/uiazq09/iMH0Zn5lr0EN2UwybbSfmneBU/n4o3kFzkCr9aJbIA7xyyf97yrjz+15to31goGFzy7+c3HztK5OAdgGzDZwhb24JJLdlcyifNDD3Kyy/YrSwKQx9fkxiyOId1Njm2qhbQXkF21S+bScfQaWeo9eozs81y3iAF2XMcfZzuk20dmSK8EZSlziASJ0lXaYwedLRhEFtpgYFNX5JMs389RPSywWbW73xGETUB2c5zZD3BgDmw2OoZOZo9UjJQ8hxv6zlqzm5cFez2rfzqcLpqPCAM6W3/sthxbep2dB2/V6Cj74rBgE5S946j1fvNnm7GVqtsWdLsN/FcKgF2R429cZWSw7di981qZP/yx7YxZ/2wNdGk8m7IcOrqVnmWj0L1z5kflD9jmxgVf9Lfn/W9N2GjGggb161k8R6d7Dv9YC8+yCfgnnmNHsRPmIqnVR9yvppB56qtrqtkm2pwLGFefsaCK/8v48ByczOtaMJIdtczOncG66ddP2awzdAFHG5FkAH524cayEOwS/0HHieGLTcj+5sf8h/9wde0lthN7fFNW2yw7jBd+8QB7aK6HsoWbOBB6FEBX+s6KAmN28wmC9ozPpBdK+fIZ4YdgRZcxKwGIOdpNL60fk/msIkuYhKGOEDlm1abwP2IlPCpkREkRpgiPINdXN0kYW7f1eMeYKKNS2jgsHFjnaQlmn3NkCE5BCU6BKDnlgTG0pe2K1+rP+UsETxBRbp655JJxnMKkqLXNmShNEWgv40DmgiBDu7GCCZw+AqPzenCEyfTDyfW/4Ig6G4I7imT6HG4YJPoxTuvTOUw/HCFBDT/GA8fw1o0wHB6C2FoSGuZpjh2lIBQIWM5Q5wkdR3KMRpaRz+HP5xVcNVY4JIi0X4FNSlzABR0ISFj/buyJxubrewuYlN2ibfVj4A++itZXV0G7+hT8sDbm7h0BAsEPN95oq7OzpdZ6n0BlWAkcoQk41r+20A26FdCDY/NEg9bT2uMT7+hb+3ZatEVB+Q59+41W0BQagRMBJmtk/fABGtQ+/FsTgT78Y0zSQY23s7/wCDdwzxjsiEkGC5xedtnYna/mgy98YcyMKYYQGqjAaxXyA/Mk7Pdz8gM0pf/5PQq+M5zWYHmrz3w8KBpldAG4qpg03FNKXT0JV3BEIaFXOKDcMi7K+ME3eKIaNhV4wzMCJOhJnRNrUCYRsLNmnez6zWeJNwGFqoiqcXUVeLiiXNEzvkCXBwUJyDprGh/M523xcjgyJw6HsXZFMVxR2GX24Gu8Z77mz+DDdwXqADmDNv0mL8sYg2+yURp2RwYBekGf6LYaUr4nR+Drm75pLcMYFuEKXesXXZCH7W4KmBymOONNDLYBky1sYQ/IMXoJ78+2AyAvyDCyiUxnY5QVchB4VhvdorhfULvacWwrTrEgsOButSGSQ/RiwXjydHl0o0KbS0e9mlMVnDcPOpINamxzwVg64GzBYTKcnNRWzvSc7fLJBH12XDgnkKymx8qOMH+6uQx00M2Cy6MRnhWMt8abMj2sCRvfd3Dl0gT6mF2gTbRinTqOcViwdgJ0+922FBjz8vZDgBboUTigM7ulZgn73YKof0ET824Td3lz1AzL2hrwje7mYCK93NEUthLcoTefGWOZ+3Q5XS1Ywv4yP9/zgdgK//gfr30RtO0Z9hH+w5PaK3BFfx8UtADGiM+0YYMOvucbHK0dnoM7fFf2PBsMLGm8TPEueDjI3kSX8FbNtyXAYRvyauwIXlY8eVmM1nj5lvONTv42frLEbxn07Hq8zrdAr+YqaNPNPTMsjwB1sYj5n4O3BH7qAqLiGBKG864zoU45YDREjZn85oy288goJ0A8SxFxqDkVhG1XfzLmtYtoGeuMcESHEAUwfF4RJM9XS4Mg7WYZAskNITI1GOoVH/IMo59g50RSqp7XH0FCAAvuYEaES2FSdAQJolfLxHw4QJgcQwr+CCIQfj4jJDhcFZT1m/L8zd8cx8yf0sDMnBtz5bBov0Ji5tMuBxx39t84CUKCWjt7Du/qnSLJBLixa4sQ7/ouYzNXgiEHkkPjvSL05kXYWg9jsgMNJxwvwtiPoAJcM0i0rb/OLXo3pUGoMkYIXvggPOCSgDZnzxHSzoNSmAIS1bPxPEH9Yz+2prPqaZiTeXcHerSobcGZnvuu71o7+o5jWRuBtx/4gXWgTgYGhVCtBOvtb7guRbWdJOsGB9YD3p3bFYQRICH8KW0BE7RTwIoC0061JCgDn6NVdW84xmhQ5gxlIMUTHcJdxdwIZ/SLP+w4dBMLnqGkSt/ThnYduxIkYHgKkllfz2vfuwI7+0Wr3/SmcQxdpyDKIOvYm9+9a72s96a7668poA8KAo+RFxxw6zMrpDk7RVDAfNCm5zMgqlHjt3UmRzxrPdBIR4vQeQB3PoNLcgRvWCdrz9kX2EUnxuIZ9IJf0C16IYOM31gEcPCVH3S4VLSMcbLBc/MuBbwyEPxvPsZgvJuOGeELip3804d1l+lSoNXY5yvyjBE/wQFZY5cODmWHoYt28soYMW+4nIvNWWs4hh98noxguHre2NF/hg05DifdQOQ58sp7ZNTtbrfu1xoKJKIh6+V9z8R35oQmDjIeb6KwDZhsYQuHBDqTriczur0MkBM+r4bYHKhe1hjpeOqmttk+fpNDFfMHy4yRClNuut62G1c2HWMhz9k6ZN18M1hHhwHbimwnB5cbEYG+2RgFKoIKpX+ygT3RxQFwAtiExtcGJKDHzK+b6dhhm+o4gDaB5qPLm/plTzrWQ5ft5wR/sgAtoC1+BH3V/8vaOdXl2gR0rncrXDr7UjZeo9104XJDSaCloJUgHFpiQ7Dj6fX5CE+3FK4LLq9tY3aBDWB0xN5ma+E1a2c+eMxn+A19VmPO2NhG0eZBYOz8hi4LCHfNhb3ZzZjhCf+hhbl+2wz8xwJvHRnfRDsVod0P4M8GDh5Hp+HI7znLpBtA0eBcJxGt4+VukeKrsKHY8exFczcu71eHcwZ4nuufsIUEbpdHnbdwjgDCngV9kT/M5DfCJgQQAQPd85xdjM0R6fowBOYZZ8g6H8jJE+ggaAlKjiWCQ8iCB54lZBTnxLSYTv/aVfGZEOeUYBpjYfgjUJF/72F2jq13OpvnewpZ/wS4NvXPGSCEjAkzYRptvuAFV2e4pLy0T0mW6k+xaHfvirMdf3NcMCoHv3ogsk3aFRbUMG7fwRXlTsBx1OHHmM0Pc8Kx+WA8AobwgIMYEZMTVJR6TlqFuLwrEIWpZYtQROb+VV+1zlTplg7RUp+bUwXVpOMnPOYry0qx9z1HyXhk1RAaItjWzroWsQYUKUfOkSjGg5Q2qZpF4dsp4gyjE3MSuIB3Ow7W0nfqNxDE5oReXHeM3gQvHJvyrjF1/hdQvMbPIPMZ3HX8oKiz9E1BCQaY+jtdm5rhI6hCgFt37xekMS5z+OEfHuP5z18rHsEHOHDEqJoUraH2zatAUwEtOLWenuOMUmRwZA2lEKJN+Esoa7MghzXddH4y+OAHx2nBGmNP6XSu0zpz9lMeVXtfXsW2CTr+0W6atgsmkA/4gYJA+52nRfub0q8LXgke4if8uEzdpfDwsJ+uc0Nf1kFwqyAP/CQD0IrAgP/hFq7xd2eCZT14F24Zap3TRisCfnDDiLU2cPjpnz6OCVzVl+d9J5A176JY/86ukwf+xtNoqAAE0I7gF/ybuyCOwJ1xCv6iQXKwI0PhnPFTIeBoscw29NMa4m/rg9aNCZ7btUED5lfdl443ga6lhl/jw9u+E/iDP0fZuvoYvmZH4y57wRG7NYwzYy447F3rDG/nYDrqNmCyhS0cEsgferzbNtpoqNAi24ysmq/wXWZdaGO+hSPoCHnvsAk69tkxx0D/dPKm21rIwP2yPOgXGwJ06DLQQgfQ/WSnvuj7+bjpDGQ/XTdnIPq9X+2vTwZ0SyA8kuMCJ/Ako7XAFttwv+tZNwE8FoA5CCoEekNDmzTpKfTBD5ntF2tMd26qc7EE5QvYzOwidjodyElHI3QkOlraXV1iAefohA1fqYG5oLz+GwPcsb/RnWfp47Kt6e1q/LQBZ07WBb+lpwUA9ZmvdBDgHW3ON8mwW2e/sfor+Sz6PChoAO/wirdlWGvL72VAiU22qR7MTHP6YgPNtwAt7TCbeYJL7NTom81TZpPfcI4G4MaawY1583+r8TgXwF1myHg+O3AL5zB0JAJBYPDOoZVl0s4woY/gGPoM/Kc+dW3YKyzEYeaYEjBzeiLGJSQ6D4ZIMTthgkARI2VD0HSMBvEiVJFTt7cY25waJQrIcdGuMdu1pYgJqXY7KTrz4HR0Uw9GwTiECuY0H86eH06PzzzHeeU4EELmjhn1tze30wRVjpCxcqIJWX9rs6u14IrAIwzgx1nC6rroA46NyZw4e97rfnrCrivXZshBLAjhff8LzmBmY+saNApf4ACeO25kDJwl3wtoEKTGwZFTf0PmiXXSLgFsHBR9V5FaNwKFoKvQK9AePOq7DCLvA2tZhg066Mqt//SfxnllulgjdGD921nyN2EGD9/yLet52uX3vuwT6yWIQRF5Bw1YA0GXHEdzQdP/7J+t5w4XZRsZj8CF+Vg/WS2Cf2U8UAA+Z5AJqPhf4IXBR2kZc0E27eqra5+rz2HslJpxmVMFvOASTaDFdjAIeW0LxKlnk2A/CNDkLW4xzuhrTpNER9rsetpum5p31Q4qeoof0D2FS4nI2PJjvaJD613hWmDtjQMvg9kQLjKPp9DMHJk3T4ENQbGCSgUGKXP4RC8dHazQVkWXl2eTzUuQybgFx9C5wKa2SpP0dxl0Zc2B888fx81bZpRgm90fhhCwZl0paP4FsaxnOxvW1xwy8tGO9YQnwVk0IoMILeFhBqr2ZSGhEfTlp/O7jAV02g1cySR85Bk8gW46jjMbKebY7llpsuGefApv8MxoNr/Dwn3us8Yl3tFuRd60o08ybBsw2cIWPnWBXPGTnKR3yWX6iJyiO+ebauZr5gMyfnZSNgEZSx7VDvuzrAjQdaibUuQ71rEfeJcds3SYG1cp+WQdubdM2zenudC332Q3nXlDHMdZBjfIb7/pJDLbHKpZ11XIh4Wlk3ptgL2y6VjM9QGbjtCiVWuavcL+O6hG2wxsEnY4/S9bmj2PlvlINv3oe88s6/KgHZshNlE6ysHulf25n43WrYFs99YoGmUT0O/eZQOzNfDhXEy3bIzDZDhVTH6GMuA/UbDefC32i81FNsw1zUxlE2mjDZ7ZpwX4rQzlrsLGk2WcdUGH5/LV2ID8C+91RMfasc9bEzb/TBts1jkTbQvnKFRtGGFwegQk2rnkaHGai5phTjeuUH4idpzLCnT5jtHtPY4Vx4ZD2k04dlIxBeLzW70GipOjTGBz6DhhhDUFKHtFO5SqAA3GxaiIlJDBEGo9+JxgIjC6gYajR/D8+3+/dsgoNY5cV476MWcKohtMqnatfXMmEAgyQlUbHC/OnOe1q33MxZGkkH0uiMRBNw5CKgMAI8IR5uyIi2CScVSQNSXFGbfLjFk5aKUIVtARXtuN55hx3P3ts9nYANYNnvUhvVRmxQ/90JqxCVV4JEgJYI6aZwgb+EMXCTQCxlz0RTGq6WAd5xRE6/4d37FWmoIgCWhj0KYACFDvRCDoznceu76DY5F1tORz7Zo7gSYLwxjN3Vp3/VmBO88JgsFvN8GUiWPN1GERWNL+N3/z2jHlmKNJwk9f1pVjXRaPMWm7Kwmf8pQxnvGMNX3DvbWyDubLWZa5Ys3h3pj1xYhDSx3P6Lq9cGhN8Uq3IAnIcNCrxYMG0EkGCEd3eeUysK5HjqxvbppvDwD4wPj1ZZ5VDm937iBDFD6NmfIXrODUO5IH92jdOnHc0YYgGiOH8oVHYxAcEDirT3IET/hO2ww2hoSsoh/8wasLB5u3NbaW+FsgBY9alwIwe0Gij8HSqDAvARK0a00pe7j0vzF2HTDjBs/40bd23va29VXXghNoGH+3i1CBMTxXOrW5UMAz33VTDbyjNYEPfcOnAMlyd202SsuaIq869ohWcwAcUcS31ZwxP32jKbSyVNhz2+YjkEkmo/HGgZ/xMZzPxdwOgqNHry6IbJzahL9q5vzhH46dTTvDN3HYZphsYQvXAGTNHbQ7PwdEyIulgz7fgLEJyBz6KPutYPoS2JsHZWleU2hc880b2q+we7DMduHMkpXsy8M64tcHdEOm8ZY5HrD96HsO/jUB+oC9MBfFPQwUnGALs5HYFnTI2WqCXBfA3po3JdFfx6XpdmM7W42PGdCA99h26Vd+kqK67KWOhwVohX3b9dIBm6M6k5uAfcmX2FRc1nqWdV+tQDbCfE0225Q9uczoWAL8499N9e3Mb1OdsuWRZsDu43+x9wq06LtbDkFFmg+zUbgEts3S92EL8Rv5B4Ki+bDwxo6ykdWxILhht7P7zct6WTfrYN2sK1vXc2x+fhl/BP+bD/+ED+V5voAA2aaj2Vs4B6AsCMqmNHlR9Wp8EIJzzQMKCUERqvO5RcSkDcdVMIhgRxkFdtIRdURLKCOyhBFnHUEiTk6u7zCS1H1/25Ww+18dA31rV59+KACBHkxCCXiXwEX8/s7pFjDB/PpVkBQgfg649gg0z1Im3/md67kLJHHQ9naprzIW38eEGB2TmKs56IPTxGHiiGGkub4JZaLPqm5zalNepahpQ5TafERdy1qhcL3bLoo+MSmHbL+iWdaUUi8zRoCgYqrmbc4Eh/WRdifY4NnS97Rv3IJEnD9rzklCIxwsn1l3eCvKTjDOkXTjtvtMOXFCBXFOnx7nm2vHBspookQoDwqY0Kl4nDXzu/oK1abRJ7wRmOjMGnQcheLVlp0t42MECHQ4BiSQgsY941njtabWp50iV9H5jBEA/5SMiDZn2XGhRz/66gKu3odffRGk+vEepWNsFERXs1rrjkmoAeP4kaDhHAhgxAgYwDElou2CZ5xjRpd5vuIV43hZDHDEAPUc3OIzStP/AnI5xN1ihe9l7QhuzODz2XjFR11tix4LWqAPNGOeZTbJ8DFHR2DQp2AQnrMO5mDt/I/OzM//aK/dHs47ehXcszb6I0+MYa4NFFBOAk9wan7WwfjxrnarE9QVuO38wA8cesfz+PDlLx+nzdFz6NH6FPjCB+SOTCY01+7D8lyrsTEEnv3sdTYdenzc49Y7Rvs5D9YXv8/GhnHMRr7xW3dt5GT4G33+6399dYB2eW3gPC70L5BJrid/4JpxwMiDG21XoR8OljcYBXBjTfAnJ0DgGy9rv8J05xhsAyZb2MI1gLMdZeiWCkDWLItrdhPGfkA2FbAgn8nHTQU62UqHOVZxWCh7Fcy6yC73fIWuOc2OML3A/nJkelMh0k8W6Jt+ruD9dQV0kTVjj+wH1rMj8XQ7vStQwh6jP9rsZFOyua5PoPPKxpjpJB9grpu2Cehac2H/0Jnogm3EH2lz2Nyq7cHmm+1i9MH2xgdzoG15XW/ANsIvm+rxBBWJpdPZKd1g6re5drNUt/kdxF9tjC2hmx612fXIZYULjMzBGfM1T3ZQBefZc9Vnm4HNiS6ui4Lx8KN942ObBHBj09/mKZvJWNhZm+oYoY9u+eoGHL4DW9sGIvuS7cxOFWxBz2imWphbOEeB8zynZBMYbmoh2Oer2QJKgrPBWeLAEzgYkUHO6BY0YfATGIiLYksxMqRF/jj4CK5bHTAUx6U0QcJLTQyOs50KEcDO21VzgHOKqUs7J5wwLweK4NAGJ9oYHOvQPsYWoOG4Kw7JScEI+iWkKD3KBMNhJLvmnB3z6ho2ioZiIAzmIwaOfWhbIAJ+BBMILsKwc3KYipMh4EDwcJT1L6CgECQhTKlSGnBrHpy7ipNxRjlqhJ33OxN6UAo8R88a6dff1o2jrM2OBEUHhCwlZg3ggoDA/NYNns2BktWvz+BfwKgzhPAmYGSNS4ujCOEHTXVN9CMeMXbNh3CER0omp5jAgW/rUVDOGqDRKpobOxxSIn5kkFRUGO7hSVucVmNNcZg/oWks+vOO9gVH4MF7xoT2BHb+6T9dj0/flLl3vVchLkfH2l2y1mhDvRVOI2FMQciUsYYd5xFQ6lxlmTjWZo744xnte946VIkdTtt5MKeHPGRc1flZ+PS9+eMP78sQ8Rse0DuFhFbMSTDFvIxhVpzLO+sD+EG/c5aENcLvzVdgER8KZFhHOIe3Cr1aT4rMOKyhsTMu1IQpWwwPwI/1pdzgEO95Z95BLMJvvWQumUe8RnZ1hCjahj/0g9+0bWx4wd/44xWvGEcEcvTDuNEmejIXdAsnxgZX5oL2zXc2EADDhMzy3NIoCKxXu6eMbMam4NJ+u2p4DN+RW8Zk/YzZeCtEiA+WWSKeywBBYwJ58G0Nuxlqvgmh7CwAj10H/551cG5Fu92KRBaSu3gejcKr9XnnO8fpTY7LTRy2AZMtbOE6BrYA+Um+zNkYQYXcN8EckCDLObnXZSbJQdAtdzN0fWvZytXbujEC2c2WOVsNi2sK9Cw7ew7+F4hnt7DNAR3GGaUnBR3mtUQH7LJqa11fUM2KuX6GvumwasptAnqTLjR+Y4ZHNg9dSg/OR3+XtJvf4Fn+Cf1akf4lzJkhbbSyaeDzoBtmOO/GTq/T5ei0LFc2BJvHZ8tCxGe7IaiNQJmzAlzsPZva7CPz0S87Zj6als3V0fQy1v09HxMKysb+RAB+0Bma4l/NuPKZjTq2Gz5lK+9XJ6Uje9V9xMvouuQCfpE2ytRng5ELhzlKuIWbMOQEHvZsYulqBTkY0RgUsQuCYGwKjNIQccMwHT0R3WRYd+970FEaN0gQIhzwbtXgIGuDMzDvdmqPwy+ogEkQNWEn4ICIK1Ykwmh+iN93nEmMJFsE4whW6ItQESggPO2Ua8s8zMFc3/rWcUyf3icIMJs+SonXp3nAJ6aqErUoLSHgb3Or1kgFhwQD7EJrwzMEEDxiSH104w/Hxw+mtyONMfU/14vYD8y9oJi5EhICIxi7DBd4LEuEUDRn+HKUIGOEwBAM8duzcE4AFkXvSj4/AgUJFOtf0AxdXHbZONn10IwlzloOMweQsNa/MXFA/SbsBTHQAeOEQKsIK/qTlWBdquaOzqpr0R3r6Nn8zdGcnvvcNR2gReOBS4q0YxAUoH4EwUSVPVcGDqA4/O+5lLt1wR/m8H3ftxaknuH0doRFO/MZUuPvfGVZUimV+Ud/aMn8BQw7ZiJQJ4sEeJ9TbL6tGwOEwy9DAp1rA796tyNi8EqZtGZLsLZlaMwKoQAMw0MQSBAEjTq6hZ+siV0YvGYdyoaxnpSs/hkN6CLaQZ/ooACiY2rGO1es1x8+4bB7XkDKusF/hV8L2lnDKtkL7DJE4Ne7jIq9K/aOGTe6bYztpiQDjRed+dx4zDW8A7xrntbAGJZXVrY+cEIWmp/2zdW4yMXoql0Kz5OpjDi4hw+Gih/vkWXop+KC1YwiO4zFnKy5OaMDMsS6oEc0gv/Mz2/vwbFxdzQMjf3pn66NS7LIu+gUvQu6kdVVk98rvn1mk/NzE4dzr4ztFrZwAwNZQ27vF1juYoJNAVj2QlfZFtDez8m9roE9uqkvm0OC6ORhm4GfakAXszu64YSOoRc6Tk2vzBnRPqM7lllA1ryivtcXsDuy5ek+tiGfYlNmRYAeO1qfbdGx3uWtLgU9OjJiTvqj0wU0uviBPQYH2mpzsqPT9Ho32KH3s11jHbAFtMN2YOMuj61of9NR3qBMYvOi59l5+NTYjWvvIoyVDWbc2u+nzA12FBwH7IeDrpDGw3OW1rUBm3rm3i2KAbwK5tjgE/hhy6LV+aabJcBR68zG7yZZ+LAW/CpBLGtaX+iYb3TFFTsbj01t4RwGxjICwTQIoQKpMjdyWDnNnA8OBicFUfkMI3UdFUeDIEJInDtOR9fjchS1rR9EJ8BB4FKm+ics7DL7roJZnKtSu/RFGPvNIbM7rV39AH0S2POOQMLbD6fCjq+d5mc+c80ghGfBHmBOv/RL42RXGhNahAVn3nEgNVrmM6ulhJk3x8d8KkJbkMkcjF+wQLuULZzCWdWsRbKNlQNFeAkiyA5RYJSDpQ2BjwTUJuC8GxtHSbvWBQ47cyqoRAByvoyfgiPkCR1j8S7ces7YCUqOdQVqBRJAASvrStFx6gXAzMkPxxIetXe/+40zvvescRHCaMA6uTmJQDIGhWu7vk8Qp7otxkrJcCK1wejqVh5rx0ksbREOfVf6KYXtHKPPOHscV3Rs7miho1Rde4se9UUQo5GUqefwg3a7TrrK8pSctZWBYqxokoDWjs+MSdbHDNa7227QRHVRrFP0Y64Ed1e2FaQxVrRMIQikwJdnWkttMTysKae8IAd+IezxJtrSr/oiy/PXgbEIMKI14zd/fDBnLljHsnDQ24/8yLpdyhuOjAFPcPzRkeyxAoLexVvmYm7mq6+KwVbYtCsQ0YM1zHhFN2Wh+Nxc9WOO8Ot77bVj0xEz8uWSS8ZV1lIdGdePK2hNgXsW/uHUmDzPKFacF3+QARk78PDYx67Hs2kHBeA5uEZPdkIqPGhu+MncuurO2qGVjqklz8wJLyafBG7QG2PEWDPYC/zFYz63vp4zNzyiXTLCnAS84HmWJWjrQx9a4xDtmbOxCTTBp+wgYzZn8khgdnskZwtb2MLZgENBrux3q8Zyt5Zs6+gheygn23PzTR7XN5Crm7IzOhJh8++GrFNyQwL92C2TYM/eW9lJmzZm2f+bru5lP3yihWTPBh3ZpYPpMP9naxzmKNg81k3OsXnNN8qgGTYi3yLfCc34jP7lW6HxuUA/wCPGRcdek+uo2WTsuDnbNmCboePlVcqA3RV9syGNke43F7yKtul5f+PDufaINdYfG2+JJ0EMds98o1LHzdk68O+da1sDjd2k/U4YAPKC7cbuqt4JvLCZrmkwzprYdGM/1T4csAHntta17D5J0dst3LgAkTCyOTcYGqNwnBA35wwjI9TOcyIkxDOnzwsydLYOUCiYys5xt/NgEjVMRF05OxiPoc6p4HwQGghfX35rT3aGjAdtcHoELzhgBUvAOtq3//wq7CPowZlVn8LxmnmHwNzudrdxhCAhLDhInK0KQ4o2CiQ0Psxvjt4TOMGc5sdhJFwIMQqkopQEiMgnR6oCoxy8+VYfAaWygewUAwIU83uG4KGcqvoMqvthvTC2dymzjvgYh+f1L6AhMFOF7Y5bCW4J5pRd4MiSteA4U4Tm5Tvvwg/lATfmR+haFw4wYev9vQydHU4VPHHIfI6WZM5Ye+vgXUIXbtVQEeRxm82TnrTeVbebb+2KghOMxsmJNz7KquK4AlcBPDjD6NiGdZEWKugDV9YPbl0DndOHluFYP2iTMjVu65iz6xl9GgclT6iaszEQphSk99EVw85zy9RDzr31qACtuenjp35qXWTqec9br9um6/7KmLCTgOaMBd6sdwoY7Qg6wT88mat1pqzQgGCTsVsna8mAWF4VWOAOXzquRQl5RhtlW+EDa6WtrmcWhDQmRgH8e0fQyrjxErqxforfohd4hQe0hBeMTV/Nldyots2804e/4Lwq/95V/4gS9U5BM2Ptykh41vfnf/444nntVs8HbRovmrf25gS/ZESpnujFOnmerCmbZRPgE3gwr9JTuzEBz/hccE2ffgRgrPnyFhv9zPKJzDUHYzN3smO+LQId6Nv6qL1Tppq5+867/i6Dbz4aRKZ89mevDZnmzGjzecFobeMB+N1k/J4DsD2SswenT58e3/Vd3zXuete7jgsvvHDc7W53G0996lPHmSn9099PecpTxqWXXrp65mEPe9h4XffLb2ELe0BWsOH2ywwhc8gZcstv8tfmyLIGQs7fjQHo2f3k/6cK0GMF/q3dtbk1rWyLw2ZUfCLAjihw4G/6bVOhfTa2OS3pFe1t2mBaXsE7g7nVlvfZa2XbNA40T7dqY1O26mGAf2Zs1mMJ7MCyT2dgt/ETOl6FT9kMgpfGwW7yY9yyaoyzdWJvGrvfcxCBjUcF+I6dpj3vsPe0y98A3jnMsRzts0HZdmxntiNfBa2xf9g1fAF+jfYF5g667vgwQM7w+ea1KPNnDqCyiy67bCr+uYVPHUAMfgQiOPDzlWhlLJztzvbuOW+3gNPlqAdHhBDizGBehNaVutX6EAzhmAu6cB44YJyXnDRMICCASTZd10Z5daaScb9p95NDLWBR4dsZsgPvfvdxnMPHGW6Xw9gqGuozQkCAB7POBcGMzw4vh8zvrnYzJ8KKQ0jJECCe5cxyYDhKMhy0C/+ECqdkFsKYl4DnDBsfoQHPMicYF9WSgAf92hUmRHwmEMCBMw99ywARbIILmSycTWOBH46cMVWzgHA3JnggtDzPYbee6MH8Bds62xdOjPe97x07PhdUsm6UhrHqnzCtWLD1NnfCSHCjugllMRCU3vdMdECIm7/vjYvSWhpTS4PGGnpXEVZBPbQoIFPBXePwThk/gnTWzN/W3veOSKiFIhBgXj6zvujY/wIzgkHaEbTQvmCWNXV8BV1Yv3amBJGsFdw94QnrNTBPSmJWfuhZWxVbQ68VBsa3lI+AGrqltODO52UvdHtThVbxH35hlKLXnGdt9rc1pmgpj+/93jX9WTdGhiCD9beW/qawjVsQzFoYH34WtEJb+jU+9UrgHl0JlBlHdWzgzLsylgTV4IYyJCfwncCDseKLzhODdrTIEX2qE5KyNmZHlODceF/96nFcEBeNWX9j0B6Fbr5VjNc+3goXDHfBEmu5LBTXM+Yp6KcuSkEbuJGdoV3PeR+u8EzHk4yj2wzOBp4RuBFYmm+wmg2MCr9ae3SF941d8AX/kKvzri7a0v9n7GWfkdPowBrCPR71e3n14DkI24DJHnz/93//+JEf+ZHxnOc8Z7zmNa9Z/f/0pz99PFul4z3w/7Oe9azx3Oc+d7zkJS8ZF1988Xj4wx8+rtyvIMUWPiWBPD3oil2yWLDWhh05zTYh+8m3c/DY3zl3++am24+uCbCX2JXX9405y6KsaIvNubylaVN2yUEi7aDCxdXVC9g7bIEKvqJ9Nh+bpCz8gO11tltuZqieyTzmNszYLHOhXrYHu7ONILqdDcxOwKvGxe9iB7EZqofChzCnsnLRALsMr7K5sj88z39g78iotTnGztGvdWa3su3MseM5fCUyoHps7Fi2C//RGOGC7WSs1tF4/MCdsZqjPq+L4s/L4J82Nx1ruuUtr8F1UVs4dwDTHyT0GOCbrnNbgsjhfI1XwEHCLJ1tQ9jtiic4AOeT8e47jhkhwqD3ns8TOJuA88HJxLz73SQxz4GjzGHkzGJsDF+NkgpnYlTBCILFbnHFvhgB/sbUBK4xUhwiqwUTSieF14S09zA2Bjc/wrmdXzVVCBUBDs4NZ26+C51zytkkfOC5jB9zmp1rY+4OcX1hdI6koIz/BQ18rw341Ze2jFugw1qjhwSnH2MSQBAsqWCm9ghDcxB88Tnh1/pfeuk4YlwcSIJPe+qTmENnSI3HPPX/Dd9wtXLRLhroCAflJiMAfuaIuvET6vB+NkFpreZoOKeWY6hQqjkLgpgDvJX5QzEYH6dbX5zfpz99HRgg3LvW1vEJygZOSqc0T+vOOeXomws6qv4E8BmcC5ppH5+gA/hEk3tBs6PWi0Kk/AQe9JVSp9DMq6uOHTMxNgrTWBignkEDaBq969cY/A2XHHA0LKMIvaKJrrkugCkQgWa7YrnaF561jvr7t/92rUR9Zq20nXLuiJ3AErzg19Ji0aQxoR1j7FpdPAd/5ux6b1k4cIS/ql1iHl2dbUxwRwY4gmcdjUFmk3W63/3GqRQ6nKApClfQTTDPOpWdZD3QYXwLBwVWzKfMOfVQZAgJZuJrfDoHF6LLjlyhcc8k/8zb+h1G0cOFNYNjdDlX3sdDs/HalXlkateAM1Tgy7qVEovG4rvTp68+RmRtBIqsU7R3jsM2YLIHL37xi8dXfuVXji/7si8bd7nLXcZXf/VXj7/9t//2+IO9e8Rllzzzmc8c3/md37l67t73vvf4yZ/8yfH2t799/H/SOLewhWsA5CWZX7CXPiT7r8ubb7Zw3YJ1ohfp2oPqgZwN6CTrTrde32DDYbaV2aRsDraPzIhu1Zt9ITa4TcWDgibmsLwFB9DRmzZC5mM8bJYybWfw/TUJmNDPlRCwASUL2N/mRoezFzuO/qIXHV/ZBfS79ateGzsu24UdZhOq+h/WiM/DNmC/sAttAnqfP8B2EPwp2OA9dOHZaquYqzGwLW1IKTXAbjVWfotNPjYVe1tJA/Y0GrMe7LpqvBkr2WD9Kn67hS3c5CCjehktxkSORJTmxmDHNJgMU9vFJqw6AoRZBEgwHIYnYDgzBwlmAoGgIAgOUySVk5jjxAnR55/92ThF6ORMFH0FOe0veMHa6RVE8JvDY9e+4zQcRQKEICGQSqFf4oNDTaAaB0HSNXTtcnNy5uJI5l6xSwEn/4vO+yHM4ROuzIWgqSBUmQFdwcVRcwygQpEEWPU/4LnCkPAIP+ZVDRZtdNaSQPQOJ5ggIxjNnQNp7U6cGLtwRlh7NqdQcKO2zVMbcBntVCuC8ykQIaDQbUGdmaXErAXnjmF1mN1vNDGfDU3wmosfAS41OwTnOOcCBD/6o2tF6ialzqVWs8fRMEok2oNruIQ7eDaH6nr4X3aFQJGxtq7alsGzHL+5CnTwT3Z3x9GuK6YY4Bl+i3ijJYpGXQ4BQFk6FAknvoJ7wNoJeHSVGhoQ7JLm+OM/vh4To4VC7XpEYxcEKZvE3AQq0Br8+N5a2iHCB3jIDkS7g/hCIAye4LYr6ihiASE7igJV3jE2fOJdmTz6hz/9ej66MF88hV8YFT5D7xlc1hUO4MP75g3v1u4udxmnGOZdxe1HEBCNUd5dtVuGhraNt9RdfJoBYY0ESYylYqt4U6ABbuEpvjdvMqFr1+HT2qNnOMDPhwG8iK+N19zQqWOUeFrgsICg9a1wNRlWcGY+N52RB/edzX7b29Y0Zk4Mo+j7UwS2AZM9+Ot//a+P3/qt3xqv3SP8V7ziFeOFL3zh+NK9YlZveMMbxjvf+c7VMZzglre85XjAAx4wfl90cwtbuIZAX1RX6WxZKVu4cQDdSo99okc06TN6vU2Q6ws6Rlzwo0wK+rqjJ37m7GT2gPFtOr4TVOh1BrYJe3PTUaUKHQf0/2wDsrPYN9f0qJJ2bKCyCdg71qfC8v62ycNOO3NmZ2V3t1FN72/it/kIClupY8Tmyn6zAdqm36YbmZZlG+BaXzKI2RbsNvYU25aNpw92Gx/Q72VBXeDZxgpHnmVf7XcsagtbuNErPk702QDhc0YIBcGDjHqCi3OFgaphgCE4rWUYbALv2cFdXvXFacGk8/3oghQcrG5Y4ZRxMN7znrFDWGJcigCj5qSDBCphRBgSQuYh64OjoX+/CVnvdUuQMXFyA441B8uYBQsEP6qNEggomMfcf8Cg4Hy1A8N57srRsk8IKhFhDr6gBafI2OBSfxxqYzcPO+oEF8dSQEj0dy7YRhh5p2hySsD73tWnoIYjKcb9/Oevdu7P40A7v2xc3aADD9aWM+376lWwsylMAp7yqMgtfKOTH/ux9VEVGTnGR+BSEKXtdkPRfkCwLwuSdeuT+ViHrjzmGJs7gU4ZblJ6y88oIHNwrEkAAaAHikWAx3pom5DvWrbZyV2C54z31a8ep8v2AdoxtuWxM+sS3T/ykWuaRmNwgo9s/MIv3vK/9UQLMoA88/3ff3WQynuCMP7Gn37MFy3qwzyqN1IWlP7+7/97HbQUSJgLcJW5JbhVFgOe97+2rKnAqWcEbPC598gEtMyp7/pzY8FfjDTBBs+Zh3arMTODOaGTApIzlD0GJ3g1AwoP4Ac0Sv4InKEzQS/z8r+1c4xKzZp/+A/XNA1ncC8gYcztEKHl+RYI+NAfPMHbfJvYQSD4VbFBRhWak3Ej8CUDLPmoX3+XzQTfBbEZN8Zn/RmP5EOB7NfvBXnNhTy8rq+kvJHD9pacPXjSk540PvCBD4x73OMe4+jRo6uaJt/3fd83HuWu9hU9rxX87RdnJvzfd5vgqquuWv0E+gC7u7urn08UtCH75bpo61MZtnjc4vIwQIfQn/T2J8pybFO61WbH9UWT9Jzx2gxgp7Lb2RH0MbtK0/Sh38QUm8EGiDHJ2q2u4BLYXjYpOtYL6FwZF5uG29XDbAg2WTgM6Gc+CL3Obl7efnMQ0N/V/tEG25o9zW7i27zpTbvjVrc6PW5zm92VH8KuasPkbKj1rIxcdhm7h60Hd+yMNoMOAnM0N+OBU/YM+5etpI2yhH2WvWuM1uqgsfEvjGN5lOqmJiO3eutTEDAfwXe26sScKSldCnNydjFMdRkwJseHw4KBCK1rkvbXGUECshoXnH79EGoEFScJo3GIurLud35nnCTkODAYu6uI56vE/E3IzRFh/eSMG78UM0UjA0EJ88sB4bwLcjhiwPE3V6lojoEYT0CIFzQ6CCpCSahrz7i7HpTTXjaC/zlYBLAxlOFCeAkQEYDwQ4AJnnCyOKHa7hhV5xcT8NnM+oFrNjXH+Xa3Gyce+MBxcUEaO92yG7w7C3XgO4qLw+Z7uIfTAkPe6257NS4ENzjuaIOzL/hlzXzfTS5LmMe8LDiHXsyD0w6X8GAtPE+ob3p3CdrgaBqHtTReARlBnm7LMceOeTgKZPxzHZwloLFf//VxWhZKQD7jh46sBGgOjQmEcaqtZwV3f/iH14ENay+Tout2qzGDVqwZ/FWjo9oW+NnuAcUlcKWGC6WpLXTiHcoT3WlHIATO3PIUCEJ0BhU9CM5wyMkIa243QbBJIMTf6NQ80D//yzzwpQBbGWBo07vaRsvWS7aMdUQDaNH3NsXPVnW+Iq2grCBzMUcBJfxjnQRR4IChhR82XYXZMTfr07XPcL0sIldh4P2ue19CwQ/yxfobozUSRMLPjotFu8bKgLAuwLgF6eCw7Jxoepar73jHOsBJ5lzfu303QtgGTPbgZ37mZ8YLXvCC8VM/9VPjXve613j5y18+Hve4x4073vGO4x8483ct4WlPe9r47u/+7o/7/D3vec91UvuEwfn+979/ZcgeOUiwbmGLx08SnOs0Sd/Otxx9IvD+9x8ff/Znp8YtbnHmesMjXUkPvuIVx1b28r3utd7xmefwlrccHS996fHx4AdfNS6//Pj48IdPjPPOOzZe/erdcbvbbXaQd3aOjte85sy47W0FIo6M3d2dccUVBxUFPbpnW58Zv/3bR8ZnfMbpVb+f+Zmnxutff2xVUHRnZ2dlG9/pTtfeKb/oomPjZ3/2yHjd646NO9/51MoPeshDLh/vfvfJ8T//53nj7nc/tcLJYdaQvfHWt54/vuiLToyLLz4zfud3zhv3vOep8eIXHx33ve/Zi9CwXz7ykfPG/e9/YtXfzW52ZLz61UfGrW61Oy666My4613PjNe//ui44ooz49JLd8fll++s+viyL7tq3/F95CM74yMfObpXbP/UJ60Y8/XB1x+cd/W38KkBHAMOvnP+djk37ewCxr16DaWuC5K4JcSuvmMmHDGOMwfrmlY+7upbUd9uneFoKJzZ/eja9D8h0Bl9DhLHxLOcVIEV6XrzM95zjGC/dPXqdVSnAXDYOIHwgvHNvd3xjuR4hnO4DJh0LdkmMD74FdQxV85TNwJxzjlWs7PPabULzmnnGHOmy7Th2PnOuLUhMOHKXw51VewrmmUu8Drfb+5v33PU966ePlmgydpyXgn/TXeic545osas9oRATlcZA+8aW5XzzZNzzTEWVOPAdrMLx1t/szO7TOsLuoo1Z1lgRqBorinRMaXD3LdehLsbdWQPwEE7/9pEl3jEeklpPAis3Xw7FTAW68qpNSb44OjCifVCCwIW6My5T+uBzh0hMl/rbgzOiX7t167bF2zp5iXfoVvrwfFHF8bbzUgMJPjsHK7AhKyKMm4czyrw5bnq6aBVdCkw0zXNnsFnz3nOeidFO2VE6dd6C1YYn8/M2XligQD9aqNU0G4NYgSZA5zDk3kqHLYHO9qYK6Dr12cUrQBVZ3cdd8GT5g6v2v3Jn1zjW6aJwNN+MgCuZBl1g9N8200QHxx0XfgM1hTe4FN7Apt4QOAGbn3e2eIlrXpeMMnaoyW8UYC0o3BXXrnGARq1rvh8U1YWuOKKcZzckPV3DsE2YLIH3/7t377KMvl7ripbbRJ87njTm960CngImNxhj2Df9a53rW7JCfx/n/m6sgU8+clPHo8XcZ0yTC677LJxySWXjFscNs3qLEYsJ0N756Jz+smCLR63uLwhwMYd23STvryuabKj/zY12LjZL2wSupbok7XJpuhKa7bpflkmxJcNNzYgm8Jm1kHDnHU0O4U9yGZhO3ULDJ3siP1hbM+D+qHLtb3O1pbNd2Lc9ra3HRdddORQxeaD/LE2YM2VPVR2/NmKNNu0YR82H7877qTNMn3YsL5jO/E7qJhlDTW2D78I3tg17Fe2/KZNrJuKjLzgmqQSbeHcAcTPCcHsB52D72ovARLOihR1jgChyQEUDOB42PW8JqBdwovgjdEwGOYTiaxIqOc4Vz0zB3c4NJwlTienXF0FDgKmJmQIuU2BHI6I+hO+zxEq0FCBWf0SAo6wCL5geE6/eXP2c9aXBV1n6KiR4AVBxkn7+q9fCy3OJKEjk8D84LhCtRxR4yLsCBv9lm1Stg/n09iqiwJn5l/NF0Gcdri75978CE6OtHG87GVjR1sEX8We4GZ5fSpoR1uQxvg58l1BBoynY1CUnLURLFGklELL1hbo4ux6lxNJERqfeW4qWmzM8/lbcm95C4qxJ8APCwJmbiniwBoDxecH7o1HgMhaCCBVsAoOZp8BH1Ce+IIigB/rUPoinpG9IhgQTtBltxc5VoIGKXmbwmjempkf+hBEaWeBg6wdgQeZHd5HF2hUn/iCIvI+XFgH8ynDYz6exMGmFPGMtvFWt7WgMePTl7RYNOh4FTpiwFDq+F2GjrWEK3OjVAVNBFh9jxb9lrmzvt5tHRihvK2XvqyXW7pkcTEUPPOhD42j1ZlBx8aNJrWPDsgL/eElx5EERfzdjTuuohbULSNJW5sy3+CP3POcQAa+6NytttAtuYK/BGaMc6ZP+Jh1cIWUfW4cySnrpw1zg0f9oI3leWRtdWzPHDuv7VnBULj67d++2lBFD763XsuCatb0f/yPcRLfnWOwDZjswUc+8pGPMwIdzSll2HXDgibqnBQgEfxwW843fdM37Yvg888/f/WzBH1dV0YnI/a6bO9TFbZ43OLykw3Z5XTkpiMe1zVNCmqwE+ljtoS+6Ug631joZTaP7tgw7AT2+LJAK2B/aY/OtIlxTa5Znm8gZS/RsWW0ljH6iUAZtGwyPsNrXnPRePCDj4y/+lfh8vDtGNecFc22tUHJltK2klZdFc22njN719kp6wziuU92lP/ZxmyOec5sE/4Qu2ZZ54/fYzyeZTfyh9hA1Y38ZMB1TY9bnfUpDDl/3SqzCRj7HKwKnSJ8jmPHZjjeHEXOEUf4sKAtDotsAQ4f455zQPhxjApk6LvbaDYJOE4i55uD6whFjgynX9HLZcBEIEGb+pA5UnZHV4lxzjggBEm72QQGB5HdSWhwjjvC4fv5ppwZODWEOjz9o3/0l3FsvASYedql54xx7Cr+2u52AQIONAe+orLGKjjiXW0QioS698zL2mqTw+vok2wZwFE2Dv3c9rbjAo4tHHHsOPj67gak6sdwXqt4/c3fvF57/ZSd1tEquDBfwtN6cvpkoZhDhWjDWXOSJQGv1n7TsQxznrMNNoGxW4P9aGS/d4zbWNEJukY7cIF2ZCtQrr5DDwS/wAYccX69i+Z998EPjqPWGK7NkYLQjoAGhaKAlkAJmpkD1I6oPO1p6/VTZ8bVvmgLz1Ho3/Ed6/Ot5iT7BM6to0CUvgRzjFN/DAd4ZlhU90KAAx3MJQu6pQVtCyw87nHruXDG0YSAoOBNdCj4Yk7oAH662tmYH/3o9U4POrDWdnaMXd+MFv2bs7+tDTnB2NE/HkTD+oB789oLPp4SOMCfxoC30ay/jdkzaMV4CpaiT3IEHgoqAWuj3U0BE3M2dm0KQuDFspwEsYzRu2SdnStBlTbm0b+jijJv8KK5oYVu/xGEC+AJ7TNiPOf7/QrIGq/gjPHgZzT1v/1vax4R3Hvwg682SuDA0SrrNgdM4Br/Moy61vkcgq2HvQePfOQjVzVLfumXfmm88Y1vHP/pP/2n8YxnPGP83b1zdgxFR3S+93u/d/ziL/7ieNWrXjW+5mu+ZnVk5+8QFlvYwha2cC2AnqdvP1nA3mI/dSujDc10Hn09+8J0NBsmm5zNwgajSwHbhZ18mBtF9wP26KzD2TJdtXttgC1jw3B9HGZty33e551Y/X9NM1fMdc4iYf+xw9gd7NE2OdkzbIdlgIOttym2YM5wmk1hzsbchRLLsljwoW/2sjXhP2iXvVddxC1s4SYH1Q7ZD5Y7tAQX4uewYYau5eXgcNRyJA9TZ4cj4V0OkvRxzhhBxDHHvAQJASLNneO46cw+gck59w5HI0HeDnPFOwOFNQsUEUbzuTuOFmfIT7vboOtN7aAT3gTHfJRtWTAWEFDPfe7aEROV3RSQ4kxxMOGNQ8WZ1f7yGA0HlHNs3NUN8RkntawGwpCwI9B8ZjwVhiWoPCMgUcFN+HrAA8Yp0WG78qXWcUw5Z9qShUMYOroFBxxSDlsFcCkdQhPOi8ATlL63tp6noDimhOSyoni75RThfhkmxrRfMG+Gbha5JgB/P/IjV98IxAFF3/BlPeCcAwpnlLDgD2caraJxAT9zvfOdx1FrCL/WC+1ymo0bP9g5kD66zObzHXyK6KNXuwF4Cv0JPDEK8IPgkqAC2tCnscCp7/EhZZaSMx70mNLUB8VbsENGhjmgX2PFv56Hf7wi4ODIHZngfwoWHgosdu01nKEpQVLrrz1jY5iYK54179YVP+AD1z0XeMj5R1vmoD9ypGwyNKM9PCuAV1aGMTi+4nnZX47kma8xMg4COERzy4AmGpW9A7fWSlCIIreGAA8ISuEhPIdOjb8AazcM4RPjg1P8J7iCjuZaOtYc7rXdtdH71WtBA3btGDOCxGgQ73VL2WdMOzjGAU/W3XjRpPRk4xGIO0evGN4GTPbg2c9+9uoq4W/+5m8e97znPccTnvCE8Q3f8A3jqU996seQ9cQnPnF8y7d8y3jMYx4z7ne/+40PfehD41d/9Ve3acVb2MIWrjXQq3Tj8qbN6xPYOuwWG0Q2DvbbGPM5XayGG71rA4kNx47pZs3rGirSfm2BD1ImL7sDfOEXnlrh+KBLEjZBNvcM1UtjW5UJy4bx3GyT75eZE7CXbCg3Z/YQe4V9J4DCRtM/gA/96ZudvSzwz4adA1vXJVh3NlOXWGxhC9cZLB1NBBxTITgO+OzIYmzOAuaej0oQaDIGCCoOAyP+INA2Z6rCs/rlEHFYOQacfo60PvxPSHZn+RJyqAU1jIsg57xw/AhJV3h1y4edWU5IBT8J0nbPOSld3TuDuck24DD7zWEkcGYFstzN1a5jSmo+7HdzEOEh8EAoVv9hmebIubLrTKiaQ4Ea6wBHxmLc1oSzJnhk/px/jqAjNJyprkXzLLzDw87OOMlBJ/zg+t//+6srh1cThTOqHgRBWZS4iLq140zDqza1bWfcOsCTIxje91637ixpwPy1geYKFKWIl8ce9gPrd20CJoS7wr9wBr97F0J8LAMInXA8ZRehFc4vmkIP8GutONwXXDCOdmyMsxuOZO/AL0c4RRKIsFtL9NFuiXXoBqjAWsxncvGHQJYgB14TXJl3OwQf9e09PAX3/mZoCPI40iXAIWsBrRs/sJ7f+q3rsRqXIAEaLhvJGMgBNAhPsivgzJoZj/ettfl23AVN4At0KfBg7OhZMElgI+ULt/jUvNtRQbPw7fSAvvRdEMDaCDKZu2Np5oD+0fSm2iCMJnVVzBmUpeNZNZEEM4yxmkz42Rx8Zz5AIEIGED4RvDVmQSPrjRaMb65NAnetueCj560tfB20G4UWf+In1kEPfIS3nBtnLP7yL69xlpywFmQL3vEbTtAnPtvvmOBNHLZHcvbg5je/+XjmM5+5+tkPZJl8z/d8z+pnC1vYwhauK2jT7GwXR1xXwI6hs9l6ZysQb6OBPSazV7Ywm4iOZJ/S89c18BfYigcFGzYBO5deZzewhY21DRbgf7YKnX4YKNN3E3RNsvnDhT7YdNn7vX/QTTod8fejHQEP9iTQlnnY5GJXsueWR+cDY7R5ZFOVnVK9lRkvNgTZP2e7yGETsG/Nw9wOU3tuC1s4NHSPdjvInA/Cxm+MgeiXRMth4Rgg9goScTAwgd8YS+DiIGGas8SpxswyFDqyoT8MyOkoC8E47UQfVGCJw6V/QQLz4UR4h6Nk4813jiBoXxACsxNynDM4MIblOTwwR7Mr7spZDGeEhz44Vd6vmKtAw0F18rTrx7yrJbHEtcBFNQ04mpwheDWv1ogT53vOLSVGsRBcgkw5rZxo6wJ3c+AFeM4RA44f51ufAh+Kf5qP8RG2BSSMVTDG/DnJHNqcR8KdM68/Dlw3GJknZ7wCmhSEQERFYWehyTH1jDaX16aaDyBs4ducOzoED/o9TAFiNN6ZV7jShh169F6xTjjtyuau0rNGfvQn0IMuX/vasUMJCUpwZjnvaAo+tUEBoA/8AQQyHO9Br/BScSxjMa55/JuujTVWAQljg8eKs/q8FFV9CnQUgKwt+MFb+JNio1zgwbsCN4wN88A7/mdkyHxBg/pgGFgbeBckgBvzFBCztmWjmU9FldEAmOUBmjIGuOiGp3W1+XHUOlJ2slGMy7PmOR+50m4K2W/BqWVdkGRVhaDxvIAFnpmDUl0PqB9BJYGSMknMEX7hzlo6xqQfuDEvuMSHxlNtIzstBVQ9N2eMwa91Ma5NwNDoCKBgzdd93bofxslll62Dv445dfU1OpiLqBk3evJzWEPrJgTbDJMtbGELW7iBoZp3n0ygpw8b8KCX2SXZlXQqu/b6APYLe6vsbfaF7Iuz3WrDXmbr2rAxPjidwWds9cPehmd++wUIuimJj+MoDr+HHcOfYlvp4zBX/rY53O1985jZr+wddglb7WxZrt7dhCN2LfuyzbxrAtqzHuyrisxuYQvXKXCYckQ5xRxcDkwRz03AkRDFm3cyfaat3pnPqXESpH8RKpwsjhjnx04zo3++9QRgmBztoEjxQcd9OBgyQURNS8UjRJ785DH+4T9cjxHTc2446lLxMbq+NgVLlmCMZQEkgDlTnEoOqPFxzAiks9XeABhb3xysBBbhVTqZMRIcHcngmBJGdrkFDOxic544bByzHF3BFeunTePijAJrJqDTNbRwCcec7LI5/K9tTrJ59R7Qr7GquWGN9M3JczzBOOezjNqhuFpD69wuv51zTqzdAo6hdaI84E5Qp8LCs7PpXYqIQ+1zjqPCn2jIb7ghrKPlg6CjUpQVnAkawQncmqvv0HE3nOSw4w9BEQE/CoMietGLxm7jrBCv9or2o1s0b1zmpW/rAh/o0PcUY0dCDluHhaOMfii+Ge9oT0CmIACwlp4zB30pjow/zUWAURorwB+elb2Ch9TlQCf4lvKxzhUTnY/OLa+/BdYWXWpvUxDL2AUXwpF5W3M4gtdZ9lRtfRNoH8/A5RIobf2gVVkbCu0uLwmhuM3D+AVqrJ9gDn4Q+DIevIzOlIjQHzojL2S1mBs8y2QRAEafDDtrQGlrD57xScfYZtmoja5mtrOiLpSjUfhMgV/4F9y9zW3WayvTBD0xfPCj8S3PIX/mZ46j5nKOwTZgsoUtbGELNzDQ7fTWjRnm4Apdzla9vhxofg8dzyfIhmHPOa4rALAJ2BZsivmY8hJkane0/mzATt1Ur20uvcD256+UDcO2+MEfXNtF+7276fgRf87YlsBOY3OdLQuoNWFrL+kIDtmjHYe/JuDdNubYaW984zYpdQvXMTD8ZURwCgkVzgVn5Wy1IwQbGP8d3+AEdxSHA5Qz5DPCBANIMbNLzXHglF7TlKs73GEcOegsIibE1Jw6jrAMCP9z3AgJDjkhJqBgXBwtjMWBPUwaO4cTE3OGm19gLvolUDhnhwGOtr5LcwOcMTvdP/Mz6zVw5KFgjj44hqXs+y0gAr8cWMEGOCAYO0JDIJkrRznQ7qWXjiMV+uToWxtOGkfPtbCEmbUisK2xvoxFEAUeOLWOTOgfLQhacNJyBuEJjjjZAh3Ggb4EPgQNikQTrrJRvO85QQrZGIIS8EL5aIeyExQhqNHXknY4voSlNg4Cjq16NPBhTJSGMVIonFsOJ3wKvDlWxQk1XnjxLEfVrj/c7mWiXCkYB19wKJAzKwwKRHAEHmUOwP2crliWERo927Vvm8CaG2+pnQVK4NBalOEBKHG0hH49I1hlDnOWAvyjBxkiPve8zAbtUuwFh8xD3/vtBOC3AqObdhvQcYE8gK7+4A/GkY4EzdD13ZsAHTA69rvaO0A/gmLLAmXw7jM0joeM2RzRB+PC5/BgHrI2HKMyFrRjjlXN7/igccAhuSMjRUCK3LE2ZJeAJjpo96iaQwIh6LtsLEE39GgM2r/kknX2CzmBlnwvOCPQGPh/73rCo9fXjtoNCNuAyRa2sIUt3AiA3rwp1Ymg+yv+el0AXd5mEjtIpjI/yqaHzUp2qoAIG2d5XJxe9xk/5CAfCI7ZtDK+541iG6Xz/7Jg2cn7Halhq3neWLtZiH3NlmG7Vr+wtvcLVJRhwuZbZsQE7Jv5VqGDwNxmv4sdyzZlU12brCB4gDPABr/73a+HIilb+NQGxjmG52geJso4g6AHoiYsOBU5I/7mDEvvF2HlHGEkxj9mvbbp4ne84ziyTAUkpJYMjukxNqYh2PzNmRcJ5swImnA4/AbmwCnhTNtd3w84xAIMhF3Xqy0FIcdpv7OE+wFHqzOCBB+nyXgcd1kWcQoSDIQOATbvNAd2uM0bPtRxmKO5hCtBaj6cak6pZ7XHcbQz7zP44ohZW+1QkgQ4pVAFc445fIgMC0YItMBlx6sc/bAOnL7nP38dVBBc8hwwX+uoXzj0Hjyqq1LRz00R7RkEnsxXIGOZjWD81jUH01EgTqfxUHDes2YEtoAOgQ3vvke76EiwwHw5yRUWs0uArj3rHc8sa+AAWU6lMApSbApG4sFrW72dguookXXDZ9Y6ZdS1ydVXAfgI3T/lKWt6nrMe0EbBU8EeilXwyBxnRW1eHP5NBeDM9SADRVvmW8opHH/0o+OoVNVlRopnzS8+J1vQWXCYrJwCg2TSj//4mh797epnwQs8ULaRgBZjxlp1e5FgU/0L7pAF1SkRZOmqPkGNgj54WJDR3BgA+NS48ZK+jQE9wbOA3XysqGu3rZPnP+3T1rRlXMaH7gQaM8jgxJp77ujRccI4zjHYBky2sIUtbOFGAOyZa3Ns4oYCttvSHqHPl/XlDgN0NfvR/PkQ7ER6nt3K7skW77hxmdWBDTobjYcB9jPbwbHj2rWhOts/7Gi+2EHALsjWYq+xZ8o8/sZvXNu+7FlZsubk7+VxoG5LZV/ut6HeM4cB/hjbjQ3uxwZ3ZR7g8ZoETNhoyyPs52jx+y3cGIQJhjrMObYlc2DUmJqAQLj/P3vnAedUlfbhN0NVFFQEBARRUVEpdhTrKiuWz7J2ZRVdK2Jfuwj23ntZ69pRsSKCFRUUu9iwCyogLCJNaZPv95xw4p1MkklmUm/+j78rk+TmlnNP7j3v/7xl3ry/FE06vc/xwPoM5DP9QSWy0kpWFTSGEWMw8vmxebgB4gXAMaHwYoCzDiViEXJYMGBQVDk+bgwYNoSF8OPFcEzmbcI5sT88D/hh84PG+Pf5PPyNzGe6zubmS9sgMCAscAy0HWVbU4VEBaFNMTB9Xpgg3NAxyFCVOWe8gLghLq0e5NoSIwsPEUQbDEYMZH8z46HI+dGGtDHnh1iC90LQuGddjET6D7PkfA9RjBs854d3Cvvi3Kj4QX9jfxiMHBMPEIw+BCIMZtqZzzgv34/8g82HdXFcQePd55PhGLim/pqwLfqfL6XLsXAN+ZxzwUDmmLxXFJ4kwZwq/C4QWnBbpA/4MBj+5fpw3L5CSyrVHTByETbqk8iqLhBCfN4XHhIcH95CXHOOiWOkj/v8Pzww6eMIPPxmOV/W923sc80k4rO504eCSU2TDZy41uwPISwRBEyEN9rDh47wunNnq+LaJnvQebdXoI/wMEeoAPoKv0k8gZKF7HHdEBToH4gjHBt5jfitc104l6BgwfscF9V0DjzwL88OP4Dg+BDN6GfA4IM2RUT0FQS4//z737HtMjBhe97DZ599YscLXBs8TvCwCt7b6HNcT77rzzMSia3PYAsvGH7b7AdhkfubD60KKRJMhBCiBGCMV+g8Jg2BCaCglzXw3GXsnQ2ILjz3GUfyvGUSg2c8YzDGB7zHJAbPbNZj/MO4xT/bGfswXmHiI1MYnzFWYkzAObCwX8bkbJ9t1+WdzHiV9RkHEsrLWMWH4dM2eKwz5iMMm3E4Y2+EGF+K2MP4JTFRa0OgHRjPsDAp5/M+MrbOJoSKcVEmaRCEaDAMxOtyD0v3XT9r7WeVuWEgpKC6YkhiUDFbm81NIsW+osEfEkazn8FlxhfwlPEz/fywEQR8RRR+jNzIfBUUSqBiNGO8eEOffxEGMLLYPt/HSCQsAREAcQEBAUMfAxKll1n6a6+N3biSeRgEQajxSWNpJzw/EBDYt78hIkgkS/iZCo7J5zTxYPxz/t6Aw/DnXz97P2GCNeXYDz00dqPk5uln0TkO/sVI9HXvMX45fx4Uia5/nLN3O+Tmy42L4+F9bvScm6/AxAPFu//R1hh9qPDMpvtcFYgWCE8Yg9zIaQ88BICbvjcgfXynF0c4X64ZN3m2gYjEwwFxh6SuPAhIBoZgxzlj+HoRg2twxBGx9/Fq8W6OtCneJ/zN+2wTg5p2ZX8dO1rjYGhJsfBluAFBgOtMu3sxiz7rrxt9A0Pc/965ZvQhzo1r78sNJ8I2MeIR1vw18NcsmRsn15r+4wcqiBmEp3ANmXVBbPExvkuTfUW5lyQObPx+fFgO/RTvCrbN3/zmETv4PSI8Jnq80B/oS6zP9hHIrrwy1ufpJ1xr/32EJGZYaEtyiXCvYD2ONVj9i35CG3Ef4PfMudJuwVLsPukvr7nf+ETGbJvPyFHCMTFYoP95QYb2RBDhN8N7HNP//hcTn9mf96jxIXt8F1HUz874tg4ZEkyEEKIEYBzOczrbPBPFJDjpwnN0qTdmDe/aVPA8ZSzJ852xB2OmYOixr/THuIAxBmNLRAnGsTzLmRRkjIMdgb2SbcUexmtManlPWOwrxrWMS31RgnSwTwQJP95ILJ7h0xZ4GMOzXSangiDMpCtmkUsYIwVLH6fD52gRomzghsHsNIaVv6FgICCWpCtZlQXV3JAwgPjh8+PlxuQrVBAahIESvBmgmGLo8+Pj+FjPZ1Bmdh3RhKSKGBs+CSo3IwwvbkjDhsW2R1iCV3FJesoNCGOabZ9/fswIYx9BQyXRcOPhwnHTRhjfqNsYWhjxvMf+kgkSmXr6YJRxg0EAQuhB6OBa4LnCcbF93kck+PxzW8I58wChHbhh8vDAWERc4Dg5P7bHzRNlOVWel8QkYJwL1z14A+MmzcMDIQUDnm1z7bxXCEYr+/ThMCwYqt7jgM8RJjhG2syHynDOnB/rsU2+g/GPtwFtzHnzkCOkh/P2td85Nq4Zx4LB60sDY4ByvR95JDZzz/HRf4n1pE/TttdfHzNeeXCttZZF2Ab7D8JgIttSx+ngoZ7MWwNoe/p+MEzEV78BjpVrQlvw0OYhm/jA5nohDvBgpv1SDZIYZATFA4x7rlWy3EJcK8Qujg04fox7Bhx+Vob90q8QEZZZxhbTJ5N5S3mhgX7AdWIQgmDFd/n9cM14ze8AzxAvqnLO7Ivfps/TxO/Qu6TyPfoP7+NFhFhK6A6eJ0HRiO97zzkPAyJCs7gH0Aa+r/p7H3BMDKgIQ6PN2Rd9ljZkW3ivcBy0FQv9hnbiPsTvkGuB6PzkkzHPHoQR/zvkt8s9hjYNzvYtXGhN6srlU4ZIMBFCiBIhOIlRDmA7MA7imcnYjEkUxsc8bxnDkTcwWXgx4wW81nmWM44NesD6XBs8473gwHpMHjMm8JNXvMekH2NdbIls8eNaxsB+YoTxGkumKQAYMzFWqivfm4fxCNsuVoJfn2Q2HYzn8d7lGqVKXyBESeJDbrIN7cmCJcwEY/jz4wh6rBBK4lXddHCz8eVb+TEy+8v3uCFiZHLzY/sY9hg+3GQwVn2oCD9MvovRh3CC0cLNzFcXCiaDZfY6WDrLJ+b0OTP4PsY438dAa4hCysOAmzNiEu3vyzxzc6Rt8ObA4OOmjjDRtq0tQBxAtfYVPDDoEGv++c+YMID3DedFO7Adb5QlJp3iurMO5+bDsIKJRIMlrDlH2hujGAPTCxi4R7JNHiwYoBiBLOzfh0twDXzIECCacL4+VAHBgPXYF4YlCnn//n95svBwx1Bmnxj6nDPGJ+3GOflcLT6MiL7MAyZoCJMQl+2ynaX9fBHHxL59jCntRogExrT3fGoobAcDOnE2hOPmIYpXFf0vsToK14y+QTvSxlyjVPGunGMm4XL0K8QqBhp4inC9fXhKIvy+EN3oe/w2fEldP9ji90jCU2ZONtnEGuGNRqJUZoB4z/cP4LeI2IDAwDXh+jNr4l1LebAjeCDmXHJJbDaHmR36Ip/RR+gL9HG2wbX34TaEa7Fv+k+qnCicS3DGxSfwpe1pd/pvYr/nO/Qp3170K/oR9yDy+ASz4PPb4HpxnWgf7g0Ildznll021s+5RohBHCt9n/ZgcMZx8Tvm/TfesMWZVP0qM5TyXgghSgRfYS6P4/2cwrOYiTTwYSWMPxhXMRZggpHxDM9dYKyEXcBzl8m2oAeGx3vj8vxNVe0GoYOxDOOVxPFBNjBBR1v78U4h4LwZq/s2KSSMy7DDghN4vooh4z5fWZHxbbJKjEKUPPn+MWOk8ONItp9UN6wg/MgwcDHyEDTwMmBGmpldFGcMUG8IYXCR78ILGRhpGNXeTR+vDIwXDGW+ww0VI5kfOuooRjk/eO/xghGIKMONzydP8rB+Q2Pw6jp/2g0hBGN/u+1ixinGGIYWN3MeGogBnBcPF8QPjtVXC0GkwgOFvxF8fDUi4NwxiGk/jM5k4V0YyGyX/XCutD8GIG3CdzD4WSeYH4V2pr0ReTi2oEGPGIWggeGIwo9YhjHKw5BtexENUQijlXPkuHko+lASHkD+ge/zdiDUsE3akwchx4cowf65vhi/QeGCdvEzFdzcad+DDoq1H30IAYeHcX2hf3EOhIhwXsEqTLQL19B75bBvnwDL5yphVsQn0s1VDhXO1z+42O/w4bHzT/bg4rrwG/Nima+yxG+J3yN9CJHs++9tMUIfogHt6ysk+bbjOiEmIAZwvYODBwQIhBd+r/5Bi3hCf7300r+EMAYstAHiBn2R7/MdSpJzXR9/PLY9+iHHGpy9oY/zG+b3Qv/h4c21pR8G+1EQ9kW/4ng5b35btBFCDh5XvM/COfHb4frSNhxXMAl3jx6x68pxsU3cgxFc6cO0I8KJFyIXLrRIJqX9ygx5mAghRInAuDY4IVjq8Oxl4oYxkhc/GE8yvmPcxvifMYIPbWaswTOa8UFi5b4gPLsZs6ayfRjjsG320ZBEpGwn28IcDYWxC+Mxxhm0C+OWxDCdfMH5BvMXYqMhkHDtsF14nzEibZKP3IBCiKVglHAzJKeCTzzEjQDVHEOTHySvg14f/M0NJBga4VV24EdLzg1+1Bg+zHRj6AI/bowakoxihGWToyRXcGNnhh0viZkzLcINkHbwxj/H6BPNIhpgnPE5xhcPGo4bYYO8J7SXj90E2ox28eEEycDg86WUMeRpCx4gGLu0KzfEZAo67YpRHbxRcyPlezy0EU3+8Y/YzRMhxpd4ZfbA31QxVnk4+ocmwgoPx2SxpJwnN2WEFVw1OR7/UPUeArRPsEoSIg3HhyCFkOSPm5AwjHcEA3LGPPBArPJKNm6OiDX0Ue8l47OH0/b0o6BxzIPd908edBynf5jk8qFCexAq4t0g8VbCs4Z+EMxBggcW14D1GTTQ15YmHY4na+Z6LS11t5h2RDjjWPmbwY2H68f2aTt+d8E2JLwNQclfT1/tyYuYhAXxe/dt4D2M6He0Ge1Kv6V/0L54oyRzB+XaIlDgbeYTtyKcpPPM4TzwEGIdPFnIeI/g4sPKGJj5suxsn2PGCyY4uOrZM3asnBdeMcz40Db0f7ZDe/h+suWWsfLMIUOCiRBClAj+mZesQmOpwvjWh317eJ7yDAUmbJiMwC7AEM8kfIVxYQir0tWwaQglZpzC5CXeMokh6Mlg3Bf0uK+vhwvjRfoYYg37Z3zE2JYxWEM8doQQWYAYQMUKjHGMa59LAUOOkA6U5cRcABhZGFVeKPDudj50gJsxN0/+xaBkZhth4emnYyJDJiVQ84kP01l/fVvi3RIRCDD2ORcfooNhRrt4AxNjl5l+vC7YBjctDDgMQQxkRAFuXr76DYYtNzXfLhjKPrcDBjLtzewEHgrckBFAgpVafJ4JL0bRnixe3PFihz8+DE+uC+fGexjLHBNGKCKKj19lnxijGMx4GaSKe8QQ5eHJeWJ8erdAzgFjFQM2mEGc/XDOiCLBUDHaivAt2oWFcCcEgWBZuHTQDgg37A8QBXAT9blwEh8YCBO0EceSqtpNPqD9ORbOC88OriXXnmvI9eAacDw8QBmc8CDkXLheXAdEBJ8sDQGD64MgxvXxxj/Xk8/YD8KaT5KKQJSsyhcDnlNOif0++d2xTw/9wIsrXFP2zT55IOMtQ79GZElMnsp2EDUIQaIfcT/gPc45VQI8to+3E2E7hxxitu++sd8W22ZbiB2IiXiR0EZ45HBvQmwK7v+XX/6aYaINucaIsLQR6+LVxHe7drXFfgAYIiSYCCFECeEr8pULeHem8/ZlTEBxAMakjHkzgfFNmPNn0CbYNFTyY1zCBCWhTYhKCCmpYPzE+KQhML5iUpDxFWMcJrP8xCeCSWLyWiFEAfAhMsz+c3PAyCG5KA+DxHrk3ED87DaKNYYOs+veYOLmiSKKYUfIDwkbMQQJOygVmjePVSTxAgaCCUacF1G4GdVVqoz1uYGRHBXjmIcnDxlm6zEOETVoP2bgubH6ZLa0E6KKzxdBe3IM3By5CWNkM4uP8U87+xkMDGIMbrbN930IE+uzYOyybdbnRsrf7BdPAcQK/x7XK9MQKI452Ww9hjuG+J9/WoRjQX1HXGE/ySqUBGNgOW+EuVQzM7QZoSFsh31wTby3AR46GNycE+E+yYx0xC6+x7qFjHdFKOLc6De0Bw/LpZWE3PkjOiH8eOGMNmQAg2jAd31ImQ+rQiiij3LNaSuuJcl7uSasg7iGaMBvL3GGh3Zhod3wiMKrykOfReBJTN6GWAEIWiRmo28mKztI2AvHjbDK9UYs4990CfD4Lfh8QFwX9sc15PwYgCA6Ihr5/Ez8nvBS895ECxbE7lHBY/bl3PFo414V9Oypb+n2EkaCiRBClBCMuRg7Br1tSxme05lMIgWT5ouaMIYhiT0Lk8zJqhoytvEFOBrq7UofYzzIpJgfo3EdGecWcnwrhAjgXeS9UMANkxAMXMEA44WQCqpVBFV1bsDMEqOCeiMYgxjDiB87RiI3l1JVoTHSMOY5PgwtBAwMXAxSbojJjHLUXoQLDD7Ww5sEcYMHDQYn3hcYttw4CUPAmPR5HFgPcQovCdZj+xj4tBnGMwIVN0iOw8dQMruO0em9X7hW3CzZt69+goGNEYvoBT4ZL8Y4XjTcvLm2GML8nUmyMvqAN76D0E6IYc8+a83wqiD0xpdHzqTMMOeXbGYGbwm8GxAT2C5/Jybc4rzwJGAWhFAfKjkFa9Zzbj5fRzZw3L7sXjJo62QPx+B+uTb0HQQM2syLZOm8eYD+FwwtQoxjhgIPL8Q7foP0FyrZ4AkCXFOutc9cHxQ2Eel8/hGOy4s0PMR9CFhimyKCsF+fx2f33WPXA8HGP/TpiwhVePFwzITlcL7sj/fxgkmEPs82fKiWPybW5ffBtglpQjhBZGIfrE9/8tv7/vuaZYM99Gfa2nukhBgNjYQQooRgfMQkhg+vFZUF4+uglwljPsYueODSL3zS+4bA2MznWQRsLMaVqao5ir9YsmSJnXvuubb66qvbMsssY2uuuaZdeOGFFg0YNPw9ZMgQa9++vVunb9++9nWyUpVCBOEHiNESBCMOwwujDQOWmWqMG37AeFY88UTMqMXYwoCiHDE3DG+gYVgjuvjcIKUINyTvWRJ8EHKz48aUaARiHPpZdWa2jzkm5q2BcMFsA23G7xGRhHVJqElIAmIKogbufAggGJCINT68AZGAbXI8LBi2PmcFIHwgAmA8YqhibPo4RgQrXC0xdBGq2Cb755o0dKaAbfpEYEFon/XXt0U8NLww4EONEqvZBPEJtPCM4NwI1/LwHvlY8LZABOGckyUKQ7zDoPbr0q4ezpd8HcHkuZlAEtd0oUIIKrSrD5NKhHPmd0H/p214zTWiDyAypvpeIogrfI8HJLk9+P5998U8RQjhQmTDq4Jrj2iHKIlAxLHxXRbEA/pbIqyHWJKsTyS2M8Iav3W8nuiLiCdUP0L8RMyhzyGuIOQww0Z7035cC46N+4MPm6GPBPdJf+Fa016cD4MKfhccM4lqfQUhfkcIKv/7X/qZMX5zXkgKKRJMhBCixOCZxbNv6lTdoisNJsgYu/gJOyaN+ZsJRCZFGQf66pr1hTGQDy/3ofUiMy6//HK79dZb7aabbrIvvvjCvb7iiivsxhtvjK/D6xtuuMFuu+02e+edd6xFixbWr18/+zOdESNEKjA+n302NvuMMc5CfhKWvff+K8kmoQckVUUk8eVTyx3c4DAcfc4Wbl54nTCrjlHrK3rgBeGFJQxIzh9vBEQojDmfPBcjH4EDrwBEJdoM4SToDcE+ERF86A3bxZglTMcnc0UkwEDEUPWeCb7CEclkOcZkBnM6+E6yZFYMBlIZo+utZ0uCuTEAkSOdQIvAxjo8SM44IyYmIEAhTPEA8uEU5PhIVSYbg9onJPOJXr1xjWCDQIcok2l8sU8Qy7VM9kBC1Ue4QCBArPHlmTH6eUgSPoLhz7EjniEaMMPA5wgAXJNgsmS2RS4W/k0E0e2WW2LXm/6DKInggIcKwgViBf2BmQ0eyLxHv+NvBBaOjXt9ssTKCFTZVJChbclBwwwa/Z0HNn0PsYRzxOOMY0Fo5T36HGIepZHp13jA0C7BeGh+FySiRYjD64o249rThoQCIdL4cDmuCe936pTetdWHAQbLMIcMlRUWQogShHHd0083judaE5WD93TGFmBMH/SkZezOGM/n92Nsk20YDRN1fuKTMRZja+wGUTdjx461PfbYw3ZFwXKe3F3s4YcftvFLXcLwLrnuuuts8ODBbj24//77rV27dvbUU0/ZAQccoGYW2YFAwkx+MKcHhhHGKIYpiqpPyOhLzJY606dbI248nFtQWMDoxnjjxuQT1HJeiBcYmhinGOoY+Bik3pOGmxkiAAYy5+9LnAZr17MfjPnE8rYcg4fts39f4QYjEcOU48GwxBPGr49QEcwXgqHtb6yEy6TLKeHP1Vfu4V/2jVGcmN+C12w705s07YVohJGc6MngSyrTl444Imb0s99rr415VARzbaQC8QYPhWD1G4QkDHOMdT6jrRAHMKD5rK6cFv54MdQJLeE+GTx278nDww7BgP1g7POdYCWp4DEikCB4cQwcE78Vjgkxg77Bdzl/wpiCICZwHfFe4rt4i3BcCAdcA/oe+Dw0tCkPZd//SNabDB7atIN/YPscN7zvc68E4XMEGJ/zhj6AtxgPcMJg6JOs49uJdehHiE9LvY9cH0RkCQ4SuE4cL0laCTmiTfh98Xvj94RIhJgEfJfz//nn2DXwlX7o94kDDz/70qGDVSH8hSwhmqYvhRCiBGHc265dtXsWi8oCe4DJY5/3MRHsBAQVxkqZehkD6zP2YUzjJ6CZvGRMlSrBvqhJnz597OWXX7avlpYr+vjjj+3NN9+0nalo4kK9v7epU6e6MBxPq1atrHfv3jaOwbQQ9SHRjR/jBuMLDwcMd2bDE0NXMFoymfHFGEqWKDRfLA2dWIIhzQ3M537gGDBkOa9gOVfOG+MLscPXqfclWRPB8GQ92gcDNpi3AsOa76eb4ccYxSjE6CVJLh4WZC3nOxwvRmMQbzQGc6r4m3i6EAWEETw9OE/CO7h+XEefzNVX6wFfijhTMJgRYWhb2sq7JGIks23EAPbLa0QIxDjODwEimCMkVZ/wwlAQVH28GshkjlDMg2v//WOiBPv0x8U9MBi+Azx88BrheiJs8B1K6wUJlnCjPxBixTVKJpYAbYlnCJ4XeJrQ1rxHBRoegFxjvsvDFA8UcpRMm2YRHoaIZDx8OQ7OC+8U+hv75bry2SWXxB6iXC9+d7QV2yXvTWKeFfoFvzG2HcxbQ3uzf/opfyd61tDO/BYQVfgefdGH+yCW+Lbw4AWC+EMIGqFDtBn/BgcRfJ/rQFvQR1gfQYZ/EWO4DmzTezXRvznf9u1j20eEot8gKiXCufP7mjvXGnE+IUMeJkIIUaKsscZi93xKHJuI8MNkWNCzJAgTQIynmZAiPJlxCuunCpVnItpPIGE/JRbLwMZgfKN+VjdnnnmmzZ4927p162aNGjVyOU0uvvhi69+/v/scsQTwKAnCa/9ZMhYsWOAWD/uA6upqtzQEvo/nS0O3U+mUXDv6pEMY1Bii3BQQHzB2mDXGYKJP+VKgqQx3DCNuDBhEDcF7dCTLeRHk22+tevXVLfr771aNNwjio48T5Fg5fox9DDv/O8KQZmYcwx4DjtfJrgNGNyET/lxoEwxa9oPxh4HL8SX7Lm1GW7Ke/5y/MSwRXrjJIjQgnCD68DfHzXcQPfgcw9i3N9/jd8w1QLjwx8S2MYYx+tk+62Ck+xAOxCGfuBXDlu1y88Z7wHvUpOqTHA/b5nrihcG50p5cG44BoQADHA8a9ovHDN/FsMYbA08Pzou2YLYGQ50S1xjC9CeMe0IvOI5gGyJS4Q7rc3j460ZeF8KbaCNylBAK5QUUDPWl/cGJIX57eEZw/bneeL3Q1rS/92zw0F6pfov+Acl5IHwg5vAevxm2RzvxXZ+fpndvi77xhjWdMMGqERj4XQST7fIdvk+eD9qRfoTww/HRb/mb9xDKOU/aHEGGa49bKN/lnPCOYb+0IQ9dHsY+iS7eHrQF58mxsz7upjzkETLYnk/Cm+q8vScPfRCvR7xX+E16YY9jRXwLVlNiuyz0GY7dl2imH3F+HMfmm8eOizwtnBP3Gd8fOWbv1bbsslY9frwt6tAhp/fJUrjnSjARQogSxVd3S+b9KCqXoLDBuJrxC/2EcWFiYQLGxozVmDxK5RXNmIhckYyhU/Uzxl0ffdTYTSBWMo899pg9+OCD9tBDD9n6669vH330kZ100knWoUMHGzBgQL23e+mll9r5559f6/3p06c3OPcJg83ff//dGVZVupGEsh2b/fSTLejVyxp5Q3vxYlvStas1+uYbW5Lqh79okTX67jtbsvbasX8x4oLhKfPnW+TPPy2aQTWXyO+/x9zwZ860JQnZoyOzZrntVK+yikXmzHF/L54166+2XH55azRxoi3h5sXNaqmHiHuPh9/S4288a5ZF582zJczys04KGs+ZY4sx9ps3d+fFbPdCnxR16XnFWbLEmr7xhi3aeGNrNGmSLenc2aLJtr3sstaY8AgEzI8/tqpff7Ula67ptl+F8LPiira4a1dr8t57tghRIBKxSFWVNcIAraqy6pYtreq772zxGmvE2qlJE6sO5itB2Ajut107i8yfb43GjrXoUpEk+sknVo2hm6ZPUmK4CsN2aa14ri1/4zkR5Rw++siqV1rJqvmcdvRhQ/QBRJVo1Bp/9ZVVt25ti3fYwRp/+KE1vv56q2ZbnTtbk1Gj7M/ddqvZRtGoNX33XVvYu7c1ff11W4hHRkC9X+b7763qk09sHsl5GdRssIE1f/RRWzR3ri1ZYw1rPnq0/UmIY3Cb3btb8+HD7c8WLaxqaf6a6sTrkmZgVDV5sjVCePr5Z9evGzVubI1ff93++Ne/rOqXX6zx00+7c6JNqqJRWzRjhkW7dLFGw4bZnEjEFu60kzvHqilTLLLyyla1cKFVd+zo2qPJ/Pm2cL31rMm4ce6acOxVHTpYZMkSq/7uO4u2auU+W7j55haJRKwaYYfzZjuffOKuK9ck2rJlzT7gH96LF7v9Rtu3tyjCzcoru+1VI2o0bmzVP/xg0VSeNZ6FC60RYtqsWdaIPCZLltjiddd1x89+FyOW+ao2gbCeSLt21nj0aFvUq5c1Rdj86SeLrriiLeE4aNeWLa3JG2/YYsQxxKUVV7Smr71mC5cssSgiUaNG1uyjj+yP9u3t13btcnafnNPQ0oA5QIKJEEKUMISl+tx2QgTxuUx8GDdezHiLMP6hzzBBi/3B+D0djJ2xcRgvk1cyGWxrueUUt3Paaac5LxOfi6RHjx72448/OsEDwWSVpWEC06ZNc1VyPLzegNnFFJx11ll2yimn1PAw6dSpk7Vp08ZaZps8MgGMKgbubKvUDP1yoqTbEWMLwwwPAh+Gg1cCNwje94IBCio/dmb88UBgVpyHC8YzM94+7wCzyswmA3ktUpVk9eVTMWoJkcALAUOWG48PGwK+7z1f1l/fqhs3rtmWyUrQIiJgXPI74qbmS8bW5cGC5wY3LIw6Ql1QhPHSSPY74pz5XXK+deV/4fiZ4ccLY999Y8fB+dJ+bNvnPUHB5m8e3uC9WzBQmbXnmrDPTKrnoI7jEcDx4d3AMfpwimR9kuPx2+b6cm249kvFA/egwEskGayDOyLX0Xuy4IHCg4H+wnXdcENbHs8PPEfYH2IuHkLsEzGHc8PbgvbmwUMfoP2XW85a0Bfom3iY4F1Cngzaa4MNrKX3vuE6c74c9667Wkv2RfvyYPJlegGvC8QGknglg/PgGL2nBkr/xIm2PJ5A9HVygHAs3K85nmbNXFv+sdxytsw++1gVHhRcP1wzOQ/2TfvRrkcfbcvivfGvf5m98IIth5BDSCbtRH/iN8UMBecS7E9cD/ZJm+DFQx/CuwuvD9rLV4qiTXzIjYdrSNUb+jbnw3YTvI3isF9+u7Q3AwK8VwihwdMHgeycc/76Lu3E+eMZQ9+iD3De9HF+P2wHj5OFC2O/UT579dXY9UZAZHtcA/o24tynn1r1ppta9S+/WKu2bXN2n2xeAlW+JJgIIUQJwzOKZ7AEk8qGcQnjFsYf/M04DlGEiTnGXoz7GK9iD+G96/PRJY67UsEYD8GF9YOTsZ5YEYDiu8UWm/nz59caBBKa412GKTeMaEKeEy+QIH5QLWfgwIEpt9usWTO3JMK+cjHoxKjK1bYqmZJtRwxKDDaMu6C4gdiAaOBFBtz+8ULBrR+3MsIPMKowSHz4ATcYQnyowMPNhPwOJFVKxIf98D1uTuyXm5BPrIrHCoIHx4YRjNcHBif7Wmrop21LYg3ZFr8t3P99OE5d8LDECMXowwDEQwbjOlmZWx9uwI0PoSPddWX/hEggXHDOGNBsn+PjZutDfmg73kfUCCrQ7J97QjBRZyZwQ2Y7iFNsn+uJGLA0hMe1IwsDBdrWh/YgjHB+GLMcO9cA4zndvtl+IokqOtfVJwVlX5yrF4UwmlnoQxjb9D+MfAYyGO30CyrdcB25plwn+ixJuThGjhXjnAcbwh5iDFVwiE/11wbRg78RHjiWVGWP6dvsxyfs4jrTdnyX/VF9xlfV4WE6apQt2GEHazFzplWxXUQRhDD6NWIG149j5T3Ol+tCX6PULyICopIPZUKgefPNv9qF3wHniwDG74k+Q9Z2rgXXEuGEY2Jd+kcyV07WQ2iijfhdJHgbxUEAQYCiT9MXfYJerj1CImIQv3n6O4MHzok2JizLex6xH86f3z3X9+23Y+3N9aaPcN24TmyXc+T8Ecs4DzxYWrfO6X2yFO63EkyEEKKEYazHxISoXBg/kaCf8SSTPoToM8bB5mG8wiQcYxUmHlmPCcJUeQ2xlRj7JdodbIfceIyLmBxLHFMz1m7RQh4mu+22m8tZ0rlzZxeS8+GHH9o111xj/2K2canxQojORRddZGuttZYTUM4991wXsrMnuQCEyAcYYhjyie5k/NAxnDEqMZ4w+rhxcKOgPzJTz82DHzyGGIYjxjAGK9/FUwKjFSOQv4P47NEYWf6Gwd/BnCn+RsQMPTeyZIla04Hhx/4xWrP5Lm53nKP3csAw9GIA54vBiRHmK7pk6sVFm+AxgfCE0YtHD/jzD1Zx4bNkhl42YkkQDFcMUgxU72WwZIlVIVpxfhjB5P/wcK1ZaHeMZM6/vvtOvCZsl2uaansY3Rj0iBskgWW9RG8QhBSUf3LMYJgjCCEyYajHHjix7yBCPPZYbBsMiBAzvEcHolUwRtWLUXi+JHvIce2AtiIBLN5TbHPYMCfqEHbkvKV8aWjvJeTLeXv8rAJ9nb7GMfD7IfwFrw3Oh/VffDEmfvAeD148jOhr9En6BseECMF2/G+J3ykhKMGZC76PAMTvie3i6ZRKMEEcxIMG+O1Tkpx9UXKc82JmhPb13kicI6IYvxfELI6J/bCub8PNN4+JKsB3EMQQTPgN8Hvi/sK50ue/+sqi5VCpK0skmAghRInDuMF7PotwwqQTY5xk40/GNUy2MU7ClvFjMQ9jHWwKxsqMd1LBOBNxhe0lmzCmfzFhxiRU0DOFsXYGaQwqghtvvNEJIMcee6z9+uuvTgg5+uijbciQIfF1Tj/9dJs3b54dddRRNmvWLNtqq61s5MiRJeFWLEIKBhFGLD9WZo4xaJiR9vF5/KD5YZNkkpluDBsMN4weZqQxDjGOHn88ZowGHzbcVJ56KmZk+hAbDC5EjLrCY4KkivdLB8eBoYlRnc0DkOPE4PP4ZKTec4AbnU/emS14vnAT5XyS3bB5YOcjlpb2JwwCYxbhhGuLAs4xIIKluhZ8zjHnkmRuiIlgNCOupBJVfEUjvBlYx28TYYi2ox0RL7x3CTMCI0bERBa8Jdj2zTfHqhhxLfAeYTaBqj/BB2Qy2DYzA3h18JtAlFlnHZdfJy7MJQqEqeC3hIDGMeNFSOgMx4mXC/0WQQGhhBwuXC+8bHhY8zzgM/ojD39f1YiF35v3YuF3hoDiPaR80mL6MuFPviQxfSLRk4p90Z6IJf63i5cU9weED/9gZxvcCzgWZk4gKDhVVcXOk/7H9hB4vGcM36Evci1pg2SeXCEgEiVTkCgYuOZSYpAkTQ2NSwbcgBm0tc1hrFglonZUW5Zyn5wxo8qNzxgjiPDdI5mYwqt3p51i4xvGS4xV/PgGkYSxSipvdMZOjM+YFE43gYjHNuMu1iGU2lfhYZzEGJRxGGMhxp3BiWomCVu3rraqqty2Y66fh2Eil21TDr+BcqDk2xHjDI8Rr64jNDAz7X/kGF7cJHiPdTBUMbruvDM2g8yMP4oqs9IYcsHQHgw9jErWQyzBAMSgq6cIWPC25Abny+ty3vk26ripc8P1lWAAcwtDlZuvzxWTLVwXjFYM6RYtrHrmTPu1Q4ea7ejDpAiDyYVHSaGh7RDxeAgRY+rLJLMgCCBwPPlkbBYBl0ifK8Tn0cDLAzEAz5a6GD061pfXW8+qv/jCZq20kq2wyy5WVZ9+7b1beGATjrPLLrHzIPQNEYLjJSwJwWJpGXoHVWboKwg03Ot58HONKYnMA5v+gsDjS1YDv2F+74hniBSISXjccC6ct+9f/FYRcxJL46UCLzXEVRbEo2zaIRp195/qzp3t1wULQjdWkIeJEEKUODz7mEhgbMvzBy9UPAp4BmYS0i3yB+MZbAnGaoyH8MxNVZQiFYxvmXDiXwQTPHK51ggajFnw3k13nekTjBf95BATyNg9TFhhN2EHYR8wxmIMyrgLr1zGodhEeNpiIzHJzPq+0iIwBmM8xufBhP5CiBIDAxlDC1EE4xIVlZl3jKmllWccuPLzI8e4470DD/xLQMAAw8jjpoKxhBHHetwACIvgJsfNDs+Mcnr4cLz18SapLxh1vgoJCjg3ZDx/CFWh7VMloa0LVG1u6Bi2hGUQUuIriGCwonZzXVj4vK6cJaUI7cI5YezTbvRfztmX7qVvk6SUsCfOnz7Pw4zv0U9feCHW5l4kTDXLgFjihQw8cGbOtIWE16T6Tl34dkZUxPOCY8aDg1AXBAi8Ro49NvZgpg/4cDUe3okhLDyICbPCw4ZjS+wrtAEzGYSC8hunDfCo8mImgwAe+PQJPzOSCQhNDA7oq/QfBpmZhsJFIrF90bZpqliVKxJMhBCiDGCMi0hC2DjPT14zaRYMWRaFATGDsQRjHsQHxnPYG4xvGGsgcGUzRuGaMtZhYopxFtvk+wgx/E3ocl0wTmRyGRuJcQu5ThgrM2ZHEMF7ljGUn6TCy37kyNi6hOcwfqdP8R7jOfLRcR6MO5noki+qECUOP+ZgnhxCFTxBjwYU3WCMXdDbAtd8FsBYQzzBoOQGgRs+RlqyJEeiNrQZN12Sz2LUeqMXFRzBA2O0Pu2IGOKrIfG3F0y4XggqvqyzD83KRTwlHkl4NKSqsJNrEOzwxuCB5auLBR+qGPHeS4MHF/lIWBdR5d//jrU74Tl4+Pikp0HwXGF2ghkBX90JMcYnzG3odWdb7IMH8EEHxUQEqtN47w2fb4jrkyz0x89QcPxcV2J26UN+XQYb++wTE0rYDiE9XCOfz4UHNw95L5LWBX0IEYb1EY2YlWNgwO89KJhMmBAb8FRgeKkEEyGEKAPwrsazk2c74x8MWCZIMITx5mSChckrn9NM5AfCkhEmaGeuRRDGESwIFMEJpHQwCeYT/jMGwXuWcSHjtmxDsBBJGCsHw8s5BnLOEaodrNzJuBohhH/9RDF/sy796fnnY2M1JvJAgokQFQbKvJ/p9vlKMPAklmQGeSV8haKghwA3em7GeADUlRwTwxcVnQcFhjPXA8OZhwZCAdcDMMgxchkQeDB02UdQMOHh5XOGJIPPfZLgIIgPPBj8vuszy8BsAsZ9Jg9GHqCcL95PdfU3joeKTpw/3hVsn4XwJTxUeMDh7RHcNm3KLAXVXRA1mJ3g2BBacgEzWXi6IFqRUyUIAzXECdqUY0kmmLAOCyFHHDv5WlgfsQ1RhOPk+jJw8DNn/Mtn2Yab8XAnxImZGcQSL+oAx+9LIf/5Z0xYIk8SFXWSwQAm09J8ZUYJBmEKIYRIhOcVVfD82IcxBBN+PEOZ+MHIxphnkkHkHl9JkTEZkzmMX1KBmMI4ORPw5vDjCyZ2GQcxTsplLj4mlOk7wXB6YOyd6FXPa8bwjKGCxQeEEBWIrwrjK7BgNEk9zQy8eohzTDaLgdjBzZ8HSzpwZfRVSBBDGAjwHteAxLJ4ISCqkAQLwz8odKC6+0omgEjAPjF6g3AMCC8IFMk+56GEkcz1RzzLFo4V10XaAxEBL4X774953iSDcA7ODQ+pupK3BqGPBnN18JAmPIY2CvZZQnm82ybiEDlPeJ1JIttMYYDGQCEoYAXBQ4gKQJwn1yUZXBfaG9EEUQhBh+uDV4kX2vCS4ftce8SN+uTmwXXZl6tO1k8RygDxjUEE+yTMiHYLfodwINxl2V4IkWAihBBlCt4MPFMZIzCuwLsAg17kFsabeMSSTw6vj7q8dhG18HBlnFsXjE295wcTTb4aYD7IdGIYgeXgg2NjZCGEcMIJBiVGKDPZom7wyiF8KVn4AjdjFGk8IlKB2ygGNUYrYgAPHgxlQk/4jH9//92aIEAwe4JwgtEchO/7fBIMDniIsU8vojDDggDDbAuGOW6TPjmux+dCQTAhzCQbeAgiktBvmNUhESrv7b9/bFt4LwTh+DHCyS2SqwpDtI0/JwQHvE98bCpeGrvv3rCwJcSmZCIiXkV1VYbi2BAZgPC34PXjfcQ2ts31oc8gtHCdgzM29AkfspMt9AO8QmhvBpF4vPAeQhvQ9whbmjcv1n/oh4hA9CPcTzkun9wM7yREHc4hk8FPmSHBRAghyhTGYTw/vYcsngqMB0TDCY7jmDBhnJCNpyljmLrsCsZBTNj6STSEilxOcjUEJpGU5FUIUQPySTDjjAt/onEuahOsbJIISjkPbAQJRAIfXhOsnkIsbrKHi/f0QHHHOMXwx5uC3Bje2AXex6hl+wgiPHAwfnGXRGghJIXjwABHWOH7PPy8qyrrcoy+rj1GO4mySACMIZ0O+gf9BAObeFEvIiC+IMDxHsY6D0IvOPCa9zPNvZEJvloUQgMiDWEnQeqb5BUQFzhHMq7XB64PYg7XEM8X2j9xNoXrSrsA7YYIFwyLYhucU328S/gtI9z53CVknKe0ODlhEEB4n1mcN96Ihehx/VkQ4jgGjo3jJtwKEJ66dLFGeFaFDOUwEUKIkODHGIx38DzhdbYVWyoVxoU88xEsGD/hXYG3LmMtnv0+l0emMDFDjhk8XRPDwT1Un0GYKEUYE3Hc6QoNCCEqDLwcuBlyU6R0KsabaFjYBsICLokYyKjsvrwzCn2yhwcPduI2MWg7drTFiBA8cDBg8QJ55x2zTTaJXSvWxbODbfMv4oX3GkAgwa2RcA68BwiZ4T22gxcG63ONg26PJLligMFsDSIBxjLbYH+JIgdiDO6vweRZQfCeePHFmHHO9vBawChn3+wDMSKbhw+CCA/uxP0h9PAg8+2S6oFcHxC1EHhoNzxEiHP1uUUyFdQYfLAdhCR+VwhnXF8GCHhs0E8Y0LGkGtBxTesD/c2HJ9FunAPxuwyECKPCy4elb4oBENeH5LBBOne2RvSLkCHBRAghQgQenoS44lnJuIfnHuMQxiBMGvEcZxylvH2xMSoTKoxJaDPymDGBw/iVcQ+JUhkPMP7JNs8d7cuEDZN4qZK3Moat7zinEHhP5lI+RiFEEcBIxmDHDa1UVd9ygAcFYgELs/Z4gyA0BCuiJAMvk6UVUqJBV0C8DHjwIIh4rw4edCQ6YyAAwcozQZ5+OiaoMHggHIQcIzwIeRB4guFFffrERA0q03AshHXwwGDfiBQ8PFOJJf7cd9op9vdDD8W8QBBkgAcnoUOIKpkmmqWqDnlY+vev/dl229UvWW0iCAGIL8RD402BxwrVetg2bYA3DqIHbZMpDMgQyHbbLebKSnZ/EtLSfn6g5t2H0yVPqw/BKkq+ZJ4H8Y1rgGDSOAu5oFEjW4jrc8hQSI4QQoQIxljea5NJAcZIjF/wwMUrlzEung/K2xdLjI8XCR7ReKUyUUfb8S/jH8Zq5Dbz48xsYYzDWJU2Z+KLMWswKS9ju1xUfMwXeNcwHvTh7kIIEQeFmZJgIndgnGK0phNLgAcVRnkyEQDvBB48eGlgZGOMI4TgvZEMPxjgIYXgwnYxkFHKEUwQcVLB/vGI4eGGcINogZjD+xj9mUDSUmYlfHlkjoOHMzMXHH8m4S4INRj8HHOycJBciCWcI23BsXJMTz31l9iFuOETubIeD02OP5PQFLbHQADPF9qb3xWzNcEY4GDy1VyBV0yw3HgiiDf1TYrXKHyuzfIwEUKIEMHETnDyiLETHhRBEFDIy1GfHGFhgZBhxme0TapJG8asjIOS5ezLFMaMTNYRcs5YiLErYb+Mo3xIcCn3JfoIghJj4OnTq9KOr4QQFQTuixjlvoqLKB0wsHnIIz6kElYI8SA3Ba6OPIww3FH0eeD5UCvWQRTDiyjRCObaEwbDDAOhN488EkvmiqcMxnYmINbgycL3KflHaIrPNk6VHMQHzoPwFLbrwcvDJ1v13jCU70WowEOnLsEpWxA/mD3Za6/YoMCXdE7W73lYch6EtzDIYOYq3YOThyyxux5EK/YTHBwwkEvMcdNQCMcJ7jcR71XCjE/Ppd5KFYwEEyGEqDB4RuJlQh63Ss1PUddYwcMYsiH48s/eqxlxhjEqbZ9Y5rcUoY0I/cbTJF3+QiFEBeJnvtPdTDHCMXi56QXB6CWBKP/iWREsCSuyI5g9HPBOwEuDMJlkYgnCAiE4PIQIV0F0IDSEsBgEFAx0bviIJL70bdBDhbwbhKcgmnF92QfXL1HUwCODsBxv/LMfZg34HqIKQgRiAh4zHOt//xtbn5AXZhgQZfCOweOCzzlPvDuIMWZfbBcxB1EiGGvMMfH9XEBb0U/x/AgOmGijZBASde+9sVhchCdKPnuhJZUwkRjyksxDg3NGTGqIWyrXg2uAdwl/M3uTDvrUs8/Gft/ZlHgOIQrJEUKICsPn12A8VYkwKcXEVa4noTKBMQc51eob5lMMGKcyFu7QQbE5QogAGFLMpqcDFzWSRQX5809rTlJJDHaMSYy3xBKzInMefDDmieFBwEBEwPsjGXhL4NmAMOFnBjDIyVuBeMG2EEkAoYT4UQ9hGoglCAIkhuXhgOGNke9LGNMnRo2KCRd4KHBtWVDeEXMYgCB+4DWBRwbgrcHMAuv7Sjb8y/EgKDBgQXhDpOPhTcws+8YjhtAdPDp4uHNedVXwyQZyitAuwVwu6eB4dt01VqKZBz4PUGYdGgqhT1w3vH7qA2FLJPHlmHCt/ec/6w5VYrCIuDVmTOzaVnB8rgQTIYSoQBizMEb1z95KymnCeI+xTymHwwghRMmDkU2S0FTwgGFGmzADn6MCxoyxhVQs8fGQqXJPpCNYPreCqUJEIAkXpWeDbYxokShCET5FiA1iBSJAInhB4LlBCAbeJggewXAQhAj+Jswn6HHAw5SEYAgtCBckQEW4IK8JHiOIHSwY6AgjXGuSZCG6eKOdQQieRoT14C3it4s4su++sXOhos/f/hYTavibMryEBSEmIA4R+0pbkKw0FXhppMvLEgSRgONKN8PBgILzCbY9/doPMPCsYjscZ31ApPjjj5hwgcCIe/ALL8S8brIRMGh/YoQRyfjdZgL9hbadMCH2/Qce+KucOAKMD5/ivUzbtEyRYCKEEBUKz3HGFUz68OytFBjTlZOHhxBClCx4JyCKpLrZYqBxw/UeEBj4ixZZdTCpJV4GxElmAsYZ5Wgx3lLtt4JojIiBJwbJYvHqwMDHmEW0eOKJvzxFMNh5jSCSWAo2EbxF2CaZ4hE0ECsQvzCKeT+ZZwJCiB9UeMMcsQTRBfEAoxthjGuN14gXyDC6yUHiQ4FSJRWjGo2vqoPHCYILJXERaoAQn2BeEW/YJ4J3DO1EWFFd4BmCh0gyECs4btqG8KV0/RcPnEQvq0ygzYYNi4X1cF0Rg0hSR6gP7Ui+FsSYuvKb8F3Eq2DIVF3QXxCutt46JlKxb4Qqri9CCqFRxBcj5rzySkyIW9rXIl5ICRESTIQQokJhvMHzmHEFkzOl/IxjrNaQCUXGj88/HxuzMAZgvCaEEKKBEBpBXopkRhoPGDwZ/Kw/D5vXX69dQQUPFG/YpwOvguHDY9s86KBY+bf6ztyHgWg05mGCZwZiA14db78dC72gTO0uu8TEJYxq/qWKiw/DqQu8TfDuQAggHwjiSbpkrnit8KBGJPHJv/g+wgheSIgbPo8N/QEjn2PHKwQhBQ+NdGEvHE9iktVEN1HymSAMMLhhu8kgvIh2IS8Jx0WfeuyxWE4XzsHDdhBmEASSeXIQ10ubc+yELSEipQqXod0QVrKJg+b4CTXab79Yu/kwI9qWtuA9RBPal5CZoIdLIqyTbQxy8Du9esVCpThfPI/w7MHzBE8jBB36FCWh+W2PGGFN6yMOlTgSTIQQokJhEomJCj9JU8o5TXxJ5PowZUqVOzcmp5joDFYREkII0QBI2okRmmgsEiJCjhOMOwxPVGqMUmbsCS9I56mCgYpBGgTDFiMXTwOMcnJFMPONsVip/PyzLQmKDHh/YOhjTBMyQzvvvnvMhZT3si1zhkcChj6DBQz4RO8PBDCuPcIYwgqzESRp9fA9vsP1QswJeqYw6GCbrI8gw78NKUkHtAWzI/S7YB4TPEo4TtoGUQWBA9GOnCAISRj7vXvH8urQB/E+oc0IXaHf0ZeDYgqwrWDb1xWexj4QG4K5ZhI9Q5i1evTRmGcLHhwM0BCFECfwjEmMnUasIbSNc0Eo4xg5h2DOGUDQ9J44mUIyZy+YNGkSOxbyEfF747fOZ/QPwqVob7xsOI7117doCDPEq0qOEEJUMH7cioeJrxJYisnQGQNlm+uMcU5soqPKjasZuwUT/QshhMgBzDBjoOJtAniLYByS0NVDtmuEEwzAZDP2eI1g9JEwEwOcXBg8mLh5I7pg2KJ6B/Mv4FlBeAA3+1QJTnMFM/j+gYm7Y6FKzGEk0y5bbFH7swkTbDFCRBDK8QY9LxAx8MapL8wyUPKX/QSruWBQIxBwPbj+qcQOvEmSQfuRfDSX+GvCcTKQ+fjjWP9ArMP7gTAwX9GJvoOniadlS/vzb3+zloS/IFwg7OGpgpDHwAihw5fX5bzpb4mlfxEqUlWxYV3Evueei/1N+zGwYT+0MQMw8pPQxxFj+C359kaw4DUDGrw6gAHRww/HQmYQThApcKOlTRGCODe+j/iDsJVp3pJgOFPQFXfZZc323DN2nkEvJZ9vxrfBO+/YonIoAZgl8jARQgjh4HnMGLXUwCOWcVAw91wm4DXKGLNXr8W1qvYJIYTIEXgHBMNyCAkh/CNoUGL0pcu07cMaMCJ5EDFzjYGKAevDcAjdSQQDMRdVSNKBsczMP7P85Aa5666YURskVc6MhoLnBg+zxJhZ9vfHHxZNNIRznc2chyeDg6DIxbEgIHF9MNYb6hmSSxA5cEml/xHyQ3+iJDDeIPRLvF2SsXixNcbj5R//MDv11JhHhQ8tQiyg//qwFxK9JoYnIaYh3CUTvLxnCP0bQZDjQ7zp3z/W1xEDH3885i3C9STUJvG6EhaDUId4hQiEpwdeI4iLgPCCWIZAwvVCZAO8Qkium22f89WLkrXvd9/VfA/xht8Dg7W5cy0awpkpCSZCCCHiEy5MkJRadUc8s/Hq9eHQQcgnx2QK46LE7zDRg6evEEKIPIKijZjh81UACne2UCYWcYQZaoxLjFKEE2bVg6EeiQ8uPACSJeHCUPW5IPB6wdBMNPQwKNOVieM7rHPoobG/ESTw2MD4BsIgMHjvvTc/D09iUTGyyc4eBIEqVZvkGq4lD1ugrTCYsw3xKBQ89FkIraG0MrlcgAEEYgkCCtcRUSAYuvLjj7aEgQZhJsm8h3weHsQS+k2iK26w2o8HkYlwHq4hQhuf4eqKsMG14zv8zcwOQk0qkcKz3Xax7+BJgoBDPDV9jj7IdgnjwXOF/SGckLuGdsg2fwnnmcozqGPH2ADLz15xjoTKIerdd5+7DzSqq9R4GaI5NyGEEHHwVuVZ5718mTBhXFBMDw3GJ1ttFTsGxgGMOfx4h3Ew4b1M2DAu8WMWxhBMEAkhhCgA3KQROzCumSmvD4Q5ELYQNNYQKNIlAwVu9oQ6EDIQ9HZA6MCwI1wBAxJjGQMacccbeqzPbD2iDCEPzJLzOceAEcpMPbP3PICCISSsQ9JZKscQFoGhjTiTaVLVTMDgxdOAWX08C3j40R4Y7Hi9EPKUmK8iX3gPCrwcOFfaplQhXwsCE+IdbYe4gHBAAlU8OrhmeMYgoiEw4EkyZ45Fg5WbEiH0hL5C25MrJlUbMXtDrhgGKSRPYz/M3rCfZJVqGLRkE06GSMLiQXhBjEEwRMygLyJ4IOIh6v3rX5YVdQ36qqpi4T6INnh9EYqHeIZXCyFQXbrYkkwqEJUZEkyEEELE4dlOfjTGkoyLeAbzL2NA/mXsVtfYNZcw3mGs45Pjc3xU0mPMyDjI50TzYb2JJAuVF0IIkWOYlcf1H5HChzLUB19JJRvwKCDsgvAdckBggPLwwHBEVPBhKognPEBIhPrCC7EHG4YewgchN3i4YNDy4MOwxjgmS3iyMA68AliHRJfe6CVPRi4FE8QaDGD/8CP0CKMcMQBRqpCiBSIAYgDePOTcKGW43ngp0QfwxGEgQJ/kOgW9cggdYXaFWRm8OxDL0lHXtcVDBWEEDwwGLQgYPqcJYgzHkk1p30zguOkPDIL87w6x7+ijY/062wSs/H7rykGy3HKxwRcCEF4viKTeu4r+WVc7liESTIQQQsRhPEEy959+ik2oEDbLRAkTZzwjeZ+/GSvmOlQ6GUycBCf1GKeV+lhNCCEqEgzKusIK8gVKPiEYKP48yAhTwFslMTEnRuUDD8SECFR3wOjDqPYuijzs6gpjICEmD0gP32GfGI7ZumR6z5EgPGiZofChTYhRuFWyLp407L+QMwIIQngTIAQEk4GWMrQfghdeE8kqMwHXCjGKtmyooY9omEpUod0QuOgjucz5wjaDyZWDbL55zNOE30UmwgkeN/RfKgnVRZOl/cCHIOHplMn3yhQJJkIIIWrAmDE4VuS56EUKJtoIffFep6lgTMDkBpN99YVweCaAlIdECCHKhGDp2ELDbP4++yQXIDwo8HiVJOZYycVx4x1TV1iOPza8H3hIYqDiycJx+2PgM7xJgoYwxnihcpYkg2PG6E5VBaaUyXcFpUxhAEWSVgY2iDT59hBCmEEMfPlls7//vWZFm0TIUYNHEyJLMiFl/vyYl4wH8Q7BkTA3X146xLNZEkyEEEJkBd6eTDSlE0woJsBYgGdofROm4+1MonshhBAiY9K5P/Jgqk9C2kxAiCGXCl42yQQYHohPP/2XAY8RixfEZ5/FcpTwcCVkiIcmIUaFKl2cKSQ3K6YgVu6Q94b8I+RQIVlcJgIDYWSIavUN5aF/EWqG5xV9KlmlKYQ733+Tff7TT395bSGSMGOGcMbviPVJLofoR38NaRy0BBMhhBBZwfORCYdU+GqLJGMlnLc+ggnJXCl+oHLAQgghygKSZZIAk1hSHnyIIBiWPAwJV2AGn3AaL9h4YYfkmSTMJZfGHnuk9wQoJhJLctOGhI8hnlGm2IcKMUNEuJgXLEj4i1CB4IHHEe/7ZG7ZQl8kLOeVV2KCTdBTBA8RjolcPMlAAFm0KNaHyc3CbJjP7eP7MP0XD5QQI8FECCFEvZ6/CCPJQlbxOMWrkzEf+cMAL2W8UTN93jN2YFJECCGEKBtImIn4gZG7994xo5jZfQxVwnFShbRQXhbvF4kSlQHeJXhm0F9IMszsEEmKEVCYkWKQRY4c76pLjHJD8gMRTkWMNDlNGJjhzcQAjnLAJK5LhEo3DOKCA71OnWKuxYTvBGez+LtUwp7yhAQTIYQQWUP4Lc/2RMGE5z6TbH6CjIm0t96KTVDw3N1007q3zbiAMUO55JUTQggh4vzjH3/9zUOQUsaPPWa2666pG6m+3gOiPCF8BW8kKtzgpYEHB4Ia4gi5cILCGeIJAyOS0tbX+4ht47rLzBUCB2Wp8WJhv4mDLUJvCBPzIWHrBXLnsG4FDs4kmAghhMgant9MUiQWBKBqXrBwQNeusWc0HptvvhkTVNLljCOEh2WrrXRRhBBChABmEQ49tNhHIUoNvD7wMPGJgFlS5SohfwwiB32pPqWryTvCzJUPpUEEIYN/Yj4fjuWLL8y6d4+tT5hY0xLLpVMElLlHCCFEveCZTfJXD+GtEKzex7MYsQTwSMb7E5ElGYTFTpwYq/Yor2QhhBBChBrEiEw8NhBKmI1C0EiXRC4V5EMhDMfDIAtRBBEmCDlNEG3YH/lTilmZqYSQYCKEEKLeYTl4iTJx8cYbMe/OLbZIvT6epEymkPfOe30iknjwRCFENl2BAyGEEEKIigTRAzdcoJwv3iAMqhBSUkGYD0ljE7PoI9Yst1ysEo+HCj4kpRU1UEiOEEKIeoGwQRU6cpkw8ZFJzi+ew+TAe+kls+bNY94mbIdqd4wBNtpIF0MIIYQQIqVHCp4hJGYlESyiB0IHVXaAUBrcf/Ei4e+FC8169kw980UsNe7AbI+BGYlmRQ0kmAghhKg3PGtZsk0Oz+Ih5xnPdiZL8AIVQgghhBBJICksWfSJi2bGiVwoH38cE0woA0ypQoQUhBW8ShI9SxIFGOKoEWBw+e3YUU2eBIXkCCGEKCqEyJK7pEMHXQghhBBCiJQghCBs+PhlPEIQPRhI+ZLB5B/BWySdWOJBXCGTP4S8PHB9kWAS4Oeff7Z//vOf1rp1a1tmmWWsR48e9h4ZCpcSjUZtyJAh1r59e/d537597etgxkMhhBDZP4iqzLbbrn6J34UQQgghrNK9Ttq2jcU1pytFmAoEE8oci6RIMFnKb7/9ZltuuaU1adLEXnjhBfv888/t6quvthUD5ZauuOIKu+GGG+y2226zd955x1q0aGH9+vWzP8lcKIQQot4QgpvJRIgQQgghhAjAAAqbVSUG84KGp0u5/PLLrVOnTnbPPffEG2d11LqAd8l1111ngwcPtj322MO9d//991u7du3sqaeesgMOOCA/V0gIIYQQQgghhBAFR4LJUp555hnnLbLvvvva66+/bh07drRjjz3WjjzySPf5999/b1OnTnVhOJ5WrVpZ7969bdy4cSkFkwULFrjFM3v2bPdvdXW1WxoK20DMycW2Khm1o9qy1FCfVDuGvT/quSWEEEKIUkeCyVK+++47u/XWW+2UU06xs88+295991074YQTrGnTpjZgwAAnlgAeJUF47T9LxqWXXmrnn39+rfenT5+ek1AeBpy///67G8hWyQ1L7VgCqE+qHUsJ9cfSbcc51JcWQgghhChhJJgEBoObbLKJXXLJJe71hhtuaJ9++qnLV4JgUl/OOussJ8IEPUwI/WnTpo21zEEmYo47Eom47UkwUTuWAuqTasdSQv2xdNuxORn8hRBCCCFKGAkmS6HyzXrUtgyw7rrr2hNPPOH+XoXa1mY2bdo0t66H1xtssEHKBm7WrJlbEmHAmatBJ4PYXG6vUlE7qi1LDfVJtWOY+6OeWUIIIYQodWRhL4UKOROpXx3gq6++stVWWy2eABbR5OWXX67hLUK1nC222KKQ10wIIYQQQgghhBB5Rh4mSzn55JOtT58+LiRnv/32s/Hjx9sdd9zhFj+zdtJJJ9lFF11ka621lhNQzj33XOvQoYPtueee+b5OQgghhBBCCCGEKCASTJay6aab2vDhw13OkQsuuMAJIpQR7t+/f7yxTj/9dJs3b54dddRRNmvWLNtqq61s5MiRisMWQgghhBBCCCFChgSTAP/3f//nllTgZYKYwiKEEEIIIYQQQojwohwmQgghhBBCCCGEEAlIMBFCCCGEEEIIIYRIQCE5BSYajcYr7OSC6upqmzNnjsujohKNasdSQH1S7VhKqD+Wbjv656B/Lor8jBX0G8gNasfcobZUO5Ya6pOl246zS2CsIMGkwNCJoFOnToXetRBCCFGSz8VWrVoV+zBKCo0VhBBCiNIYK0SimtopuPL2yy+/2PLLL++SyOZCdUN8mTx5srVs2TInx1iJqB3VlqWG+qTaMez9keEHA6AOHTrIQzKPYwXdS3KD2jF3qC3VjqWG+mTptmO0BMYK8jApMFzoVVddNefbpVNKMFE7lhLqk2rHUkL9sTTbUZ4lhRsr6Degdiw11CfVjqWG+mRptmOrInuhKumrEEIIIYQQQgghRAISTIQQQgghhBBCCCESkGBS5jRr1syGDh3q/hVqx1JAfVLtWEqoP6odKx39BtSOpYb6pNqx1FCfVDumQ0lfhRBCCCGEEEIIIRKQh4kQQgghhBBCCCFEAhJMhBBCCCGEEEIIIRKQYCKEEEIIIYQQQgiRgAQTIYQQQgghhBBCiAQkmJQBN998s3Xp0sWaN29uvXv3tvHjx6ddf9iwYdatWze3fo8ePWzEiBEFO9awtOOdd95pW2+9ta244opu6du3b53tXklk2yc9jzzyiEUiEdtzzz3zfoxhbMdZs2bZoEGDrH379i6j+9prr63fdz3a8brrrrN11lnHlllmGevUqZOdfPLJ9ueff1olM2bMGNttt92sQ4cO7jf61FNP1fmd1157zTbaaCPXF7t27Wr33ntvQY5V1EbjhNygcULu0DihOO2ocULu2lJjhdqMqdSxQlSUNI888ki0adOm0bvvvjv62WefRY888sjoCiusEJ02bVrS9d96661oo0aNoldccUX0888/jw4ePDjapEmT6IQJE6KVTLbteNBBB0Vvvvnm6Icffhj94osvooceemi0VatW0Z9++ila6WTblp7vv/8+2rFjx+jWW28d3WOPPaKVTrbtuGDBgugmm2wS3WWXXaJvvvmma8/XXnst+tFHH0UrmWzb8cEHH4w2a9bM/Usbvvjii9H27dtHTz755GglM2LEiOg555wTffLJJ6MMDYYPH552/e+++y667LLLRk855RT3rLnxxhvds2fkyJEFO2YRQ+OE3KBxQu7QOKE47ahxQu7aUmOF5Iyo0LGCBJMSZ7PNNosOGjQo/nrJkiXRDh06RC+99NKk6++3337RXXfdtcZ7vXv3jh599NHRSibbdkxk8eLF0eWXXz563333RSud+rQl7denT5/of/7zn+iAAQMkmNSjHW+99dboGmusEV24cGFuL2iFtSPrbr/99jXe40G+5ZZb5v1Yy4VMBkGnn356dP3116/x3v777x/t169fno9OJKJxQm7QOCF3aJxQnHbUOCF3bamxQt1YBY0VFJJTwixcuNDef/99Fw7iqaqqcq/HjRuX9Du8H1wf+vXrl3L9SqA+7ZjI/PnzbdGiRbbSSitZJVPftrzgggusbdu2dvjhhxfoSMPXjs8884xtscUWLiSnXbt21r17d7vkkktsyZIlVqnUpx379OnjvuNdcb/77jsX1rTLLrsU7LjDgJ41pYHGCcVrx0Q0TmhYW2qc0PA+qXFC7n7fGivkhnEhsUsbF/sARGpmzJjhjCGMoyC8/vLLL5N+Z+rUqUnX5/1KpT7tmMgZZ5zh4vUSf/SVRn3a8s0337S77rrLPvroowIdZTjbEcP+lVdesf79+zsD/5tvvrFjjz3WCXlDhw61SqQ+7XjQQQe572211VZ4WNrixYvtmGOOsbPPPrtARx0OUj1rZs+ebX/88YfLDyPyj8YJxWvHRDROqH9bapyQmz6pcUJyNFYoHlNDMlaQh4kQdXDZZZe5ZKXDhw93iaJE5syZM8cOPvhgl0R35ZVXVtM1gOrqauelc8cdd9jGG29s+++/v51zzjl22223qV2zgORjeObccsst9sEHH9iTTz5pzz//vF144YVqRyFEvdA4of5onJA7NE7IHRoriCDyMClhMDAbNWpk06ZNq/E+r1dZZZWk3+H9bNavBOrTjp6rrrrKDYReeukl69mzp1U62bblt99+az/88IPLqB18oEPjxo1t4sSJtuaaa1qlUZ8+SWWcJk2auO951l13Xafe427atGlTqzTq047nnnuuE/GOOOII95pKYvPmzbOjjjrKCVC46Yq6SfWsadmyZdnMGIUBjROK144ejRMa1pYaJ+SuT2qckLu21FghN6wSkrGCRoYlDAYQM8kvv/xyDWOT1+QySAbvB9eH0aNHp1y/EqhPO8IVV1zhZp1Hjhxpm2yySYGONlxtSXnrCRMmuHAcv+y+++72t7/9zf1NSddKpD59csstt3RhOF5wgq+++soNkCpRLKlvO5JnIFEU8SJULIeZyAQ9a0oDjROK146gcULD21LjhNz1SY0TcteWGivkhi3CYpcWO+usqLsMFiUw7733XleO6aijjnJlsKZOneo+P/jgg6NnnnlmjbLCjRs3jl511VWuHO7QoUNVVrge7XjZZZe58mOPP/54dMqUKfFlzpw5Fd9ls23LRFQlp36/7UmTJrlKTccdd1x04sSJ0eeeey7atm3b6EUXXVTRfTLbduSeSDs+/PDDrtzdqFGjomuuuaarMFbJcG+jjDoLQ4NrrrnG/f3jjz+6z2lD2jKxVOBpp53mnjWUYS/HUoFhQOOE4rSjxgm5a8tENE6oXztqnJC7PqmxQnLmVOhYQYJJGUDN6s6dOzsDnrJYb7/9dvyzbbfd1j1Ygjz22GPRtdde261PKafnn3++CEdd3u242mqruRtB4sINVGTfJ4NoIFS/Pgljx451ZcJ56FNi+OKLL3YlmyudbNpx0aJF0fPOO8+JJM2bN4926tQpeuyxx0Z/++23aCXz6quvJr3n+bbjX9oy8TsbbLCBa3f64z333FOkoxcaJ+QGjRNyh8YJxWlHjRNy05YaKyTn1QodK0T4X7G9XIQQQgghhBBCCCFKCeUwEUIIIYQQQgghhEhAgokQQgghhBBCCCFEAhJMhBBCCCGEEEIIIRKQYCKEEEIIIYQQQgiRgAQTIYQQQgghhBBCiAQkmAghhBBCCCGEEEIkIMFECCGEEEIIIYQQIgEJJkKIUHLooYfannvuWezDEEIIIUSJorGCEKIuGte5hhBClBiRSCTt50OHDrXrr7/eotFowY5JCCGEEKWDxgpC/D7IBwAAxiBJREFUiFwQicqiEEKUGVOnTo3//eijj9qQIUNs4sSJ8feWW245twghhBCiMtFYQQiRCxSSI4QoO1ZZZZX40qpVKzeLFHwPsSTRzXa77baz448/3k466SRbccUVrV27dnbnnXfavHnz7LDDDrPll1/eunbtai+88EKNfX366ae28847u23ynYMPPthmzJhRhLMWQgghRKZorCCEyAUSTIQQFcN9991nK6+8so0fP96JJwMHDrR9993X+vTpYx988IHtuOOOThCZP3++W3/WrFm2/fbb24YbbmjvvfeejRw50qZNm2b77bdfsU9FCCGEEHlAYwUhRBAJJkKIiqFXr142ePBgW2utteyss86y5s2bOwHlyCOPdO8R2vO///3PPvnkE7f+TTfd5MSSSy65xLp16+b+vvvuu+3VV1+1r776qtinI4QQQogco7GCECKIkr4KISqGnj17xv9u1KiRtW7d2nr06BF/j5Ab+PXXX92/H3/8sRNHkuVD+fbbb23ttdcuyHELIYQQojBorCCECCLBRAhRMTRp0qTGa3KfBN/zGfWrq6vdv3PnzrXddtvNLr/88lrbat++fd6PVwghhBCFRWMFIUQQCSZCCJGCjTbayJ544gnr0qWLNW6s26UQQgghNFYQopJQDhMhhEjBoEGDbObMmXbggQfau+++68JwXnzxRVdVZ8mSJWo3IYQQosLRWEGIcCPBRAghUtChQwd76623nDhCBR3ynVCWeIUVVrCqKt0+hRBCiEpHYwUhwk0kGo1Gi30QQgghhBBCCCGEEKWEpkiFEEIIIYQQQgghEpBgIoQQQgghhBBCCJGABBMhhBBCCCGEEEKIBCSYCCGEEEIIIYQQQiQgwUQIIYQQQgghhBAiAQkmQgghhBBCCCGEEAlIMBFCCCGEEEIIIYRIQIKJEEIIIYQQQgghRAISTIQQQgghhBBCCCESkGAihBBCCCGEEEIIkYAEEyGEEEIIIYQQQogEJJgIIYQQQgghhBBCJCDBRAghhBBCCCGEECIBCSZCCCGEEEIIIYQQCUgwEUIIIYQQQgghhEhAgokQQgghhBBCCCFEAhJMhBBCCCGEEEIIIRKQYCIqjkMPPdQikUjK5YcffnDr3XvvvfH3Xnvttbwek98Px5bJcY8ZM6bW5x988EH88z333DPjfRfyPOs6r6qqKmvevLm1b9/ett56a7viiivs999/r7E+18evf95552W1r6eeesp9J9vvpdpnJtetPlx33XVuP1ybRLp06eL2ud1221kpQ1tznB07drSFCxfG3/ftz+e54JZbbrGddtrJVlhhhfj1OPPMM2ut9+9//zvr34YQQgghhKhsJJgIUSbsv//+8b+HDRtW6/PgewcccICVI9Fo1BYsWGBTp061N99808444wzr1auXff755znZPkb6+eef75ZSBsGEY0wmmJQD1dXVds4557i/TzrpJGvatGn8M9/+uRJM7rjjDnvxxRdrCWuJnHzyydakSRN7+umn7e23387JvoUoR1544QXbbbfdrF27du632bZtW9t1113t2WefrXOCYfTo0bXEZIRu//nmm29eaxtffPGFHXXUUda1a1dbZpllrHXr1rbxxhvbBRdcYDNmzKgl3PulcePGtuqqq9rhhx9uP//8c07bYP78+dahQwe3n+eee67GM+ihhx5y58FxLrvsstapUyf729/+Zueee2699hVsw1yRbKLj119/de3L9fjwww8z3taiRYvcfRQRfqWVVnKTFquvvrrts88+NnLkSCt1OG7agcmEcicXv7eGTsoUeoLNby/Z9fMTRLn87SSDdvWTOR999FFe9yXKEwkmoqJ59dVX3QApuPibNg8u/14pzOb//e9/dwM4eOKJJ5xRmkwwYYDHYLhcrwfeCBMmTIgLRD/++KP93//9n82bN8+95vr465Ktp0h9+OOPPwq+z7oe7BxHMbyBMoVBNiJXo0aNbMCAAXnd1z/+8Q/nZXLrrbemXQ/Da4cddnB/X3/99Xk9JiFKlVNOOcV22WUXJxJgYGMsT58+3UaMGGG77767DRo0KO3377rrrlqvuR+l4v7777cNNtjA7rzzTvv222/tzz//tJkzZzqPyKFDhzphPBVLlixxQsndd99tvXv3dseZK2644QabMmWKrb/++k4s8iDm9u/f39555x13nNz/f/rpJ3e/reseU2wQvg477DB3Pc4+++yMvvPbb7/Ztttua0cffbS9/vrr7jWTFjxnGGck89YThSPb31ulTMrkGvq7n8yRYCKSIcFEiCyUdP717912223OzZ9ZuhVXXNH2228/+9///hf//nfffWf77ruvm1Vr2bKlm8ljpgohZvLkyVm3O7Nte++9t/ubgV5woMlsEoNRQCxp0aKFPfDAA25WjFm0Zs2aOSEFb41rrrnGDUTTETzP4AMVsSAxdAnwCDn22GOdsMB5tmnTxg488ED75ptvsj5PvAC6d+9ujzzyiG2xxRbuve+//94NmtOFxzz22GNuUO1nyDp37mx77LGHvfHGG+5z1r/vvvvi6/tteDEsOLPDA5NBJLN1Z511VkZhQGx77bXXdvvedNNN7a233op/lur7iX3MtzsiETCATfxeqpAcvCz69u3rQlO43uuss46bEWXAn2x/Tz75pP3rX/9yfZeBNgNmZl09GFNHHnmkrbbaau6c/Kwwnhp1cc8997h/Cati28F9B9srWR/LFoyugQMHWrdu3epclxlTGD58uM2ePbve+xSiHOGZcO2117q/8SDgHoWAwb9+ogDxMd3vEc8whATgOZJu3Xfffdd5hyCCI54SYsl9hXvSuHHj7J///GfSmWN+0xiFPOe4hwDCyU033WS5YPHixU4wAQQGfwy8z/MRuId7geerr75y57n99ttbqeMFakTriRMn1rk+58+18OeM9x2CyS+//GK33367e46WKv7ZxnOT/hIck4SFbH5v+YT25bdQahOJQhQKCSZC1BNmXhhcMQCcNWuW8/A4/vjj459PmjTJHn/8cTfomjNnjpvJY6YKQ5EHDYOSXIXlJAvHeemll9xAgkEnA1YGF5988okTeRiQ5goGVptssombfcPQ5zxxs0bw2Gyzzdxgs74QzhF0I08FAz7Oe/z48fEZMkSpZ555xs0UZgueCOSJYYCQCaNGjXIDia+//trt+7333rMdd9wxZ6FEdfGf//zHdt55Z3v55ZddaArXm3a/6KKLnGdSMIeIB7EEYYO+y8wtLtmsHxx4s136MefkZ4WZKU4HA6lXXnnF/e0Fr1KhT58+7l/OxwtpQlQKl1xySfxvhBF+D4ir/Bv0nrjsssuSfh/jmd8Owos3ynmmpTKqL774YidCwKmnnmqnnXaaE9MRYAkl+O9//+u8B1Oxyiqr1BBoua8idC633HJO5MATJMgJJ5zg3kd0R8RPBeIyz8WgiArcB3lWw4YbbmhrrLGGa5+11lrL3Q8R5YPg5YmIw7pMSDBRwTMvnVHLfZlnA+uT34l7bqLHQCbidyqYNGBiBuoyrpkYIEQRll9+eXv++efd95n0II8YYVSIy9mc75VXXhkXwhlveBDj/XXz4xj6T79+/Zz3H5MT9AuE78RzDU7g0G+PO+4414+YDEoVklOfbdc1CQaM90488UQ3Eca1YYJmm222cWOPXE8gZft7y+Scs52UefTRR2299dZz58H2Eyd56BNbbrmle01bTJs2zW3j/fffd5N8vH/EEUdYrsm0jZnwYnzK59wX+E1xXsHwQ8ZuTC56vIjqJwYT+x+TS61atXK/kauvvtp9h98F14V+w0RpfSdPg3nxGJPxnWSTcKIIRIWoMAYMGMDoJOnSq1ev+Hr33HNP/P1XX33Vvce//r0VV1wx+uabb0anTp0a7d69u3uvadOm0SVLlrh1J02aFH3++eejU6ZMiS5YsCA6a9as6NChQ+PfHz58eHxf/j2OLR1se5VVVnHrtm/fPr6vrl27uvdatWoV/fPPP+PH+sEHH0RnzpwZXbRoUfSHH36IbrTRRm69FVZYIVpdXZ3RefK5J3j833//vXvv8MMPj+/79ddfd/tnvyuttJJ7f5999sn4evj9ez788MP4Z+uuu657j/369zgeuOqqq9zr5ZdfPvrtt9+6Y/jmm2+i//nPf6IjR45Muq90x7HppptGJ06cGJ09e7bbTrJ9Bq9bJBKJPvTQQ279Sy+9NP7+gQcemPKYU7U9rLbaau69bbfdttZxJn7GPlu2bOnea9OmTfSdd96J/u9//4vuu+++8W3fcccdtfa3+uqrRz/99FPXXr5P0Y88yy23nHvv5JNPjv7xxx/R6dOnR8eMGRMdPHhw2usZPNcHHnig1ufp+nq636ZfOP9kBPvsGWeckXQd+nyTJk3cOueff37a8xAiTPz888/x38fKK68cv/97eN26dev4Or/88kut36S///fs2dN9tscee7jX5513Xnyd3r17u88WL14cXXbZZePv8xxMR/DeFLxHPvHEE/H3d9llF/fe0Ucf7V4vs8wy7rnqj79jx47u/V133TXtvrin+WdoEJ6T/v7Ast1220Uvuuii6GuvvRZduHBhre3885//THmfOu200+LrBduQfSauGzzfO++80z1Pkm1zyy23dGOJxPZKfG7ut99+7v1NNtkkbTsEn1W0aV1kcr4//fRTtKqqyr13zjnnxL/72GOPxdd97rnnao0nEpf+/fsnvbf7cYUfcwDPwsRnQ322zfYS1/XPcP8b6tSpU9Jt+nES6/h+mLgwZmRckY76/t4yPefg+abqh36MwTgx2BcZsybrd19//XW0RYsW7r3999/f/VYYS/txBmOUdKR7tvtjYQleh0zbOPj94MJ5jRo1qlabJy6MZ4JtFrxH+sVfl1T9Jl2br7HGGvExe7AtuEcnrsv99LPPPkvbliJ/yMNEiHqCao6yzmwEMeHATL5X2HkfzwfceFGjUbaDyUYzcZdNhGRfKNXBsBxmibyqTgUQZj387BwziswOoFCjxOMhAHgVMFOSC4h9BzwbCGNhXxtttFHcjdR7G9SHYJ6WdEm/CBuBuXPnukSCeEEwE8MMJDMu2YK7NuE1zLqtueaada7PDC2zG6x/+umnx8NQyMmSb8aOHRsPL2EWlBk/ZnqCs8nJEvcx40v8PrOozJAB3iSJbcr1vfTSS911ZEb0wgsvTHs8wX7lc+6UCn4WDPzvVIhKIDiTyUxo4v2U18GZa+6fyfIF8ZvGc4AcKHgk8EzCWy0RvAx9iB/PP55H9ZlF9iFEQEgg+DwrzJqToBV41vrEsHVVLfPPQe5/QZgRZ/bYw8zy4MGD3Yw09z5mfD14IPqZfzzpaC88DH1o4FVXXZX0Gc+YgbbBI2HllVd27xGqxDMZ7xY8HLCbmBHHO5KZav/MZ4Y5GFaaih49erh/GRsk5joL4r0MoK6QxkzPl3byoUvJvGA5L/9MJncMzy88e/BMZUzjx1JcVz+GCMI1x3OXZ326/Df12TZ9mW3S7wgLTswXN2TIkPjvCI9Wnpd4tBI248cJrEM/pM/jvYGXKv2N5w7r+mTomZDN7y3Tc6Yv07/8850xW6r8bPRJQup4prOtVB6jeEHgWQR4pDAO/fjjj92x4pHCuCgT6I+JiZ+DfdSTTRvjBY5XF78tvHUIE8Q7ivO9+eab3TocY3CshudtYk5DD+Przz77LH4PAby0aDv27dso2G/oG1w72pBjoF29lzfeJ8m8p/ndc80Y2zH+Au6nQS9gUVgkmIiKJjHpazbJnnDT9SASeHyoDe7H3NyoEJAstCMT99pMwnKSheNwk8Xtl4EFD/9kOUvqs/9k26krEV+ygUmmBMN50mXA32uvvdwggjh5BpSERjEwwGWSB1W2kOslG7wLNDBI8K7CvgJEKurKJZMJwX0EjyP4d7JrlKz/BkN3iF8nzwGDYEQo+h0PflzoGYzlAwYuiUmYE5eGxqmnMyCEEDG4lyaCsUDeETjkkENcuA3PmeC9xtOQqhZMLPB97t/eKEZw8UIJgoDPbeKTYvKsA4wmktdmIuomE3RJhonxx70vCPdQnxgVgkYOBhpCAYYjggdwryJUMxGMH/aLi70XdngWI47UV/xOxAsxXJ/EkJL6XqNszpe+4Z/fGM4Yev45zMQCwhSwDSY3mGDBiOV6+wkYtocgkwjbJpcb4UBe1EhGfbZd1ySY/z6GOjnV6PdMhJErzffHXE4gZfN7q+85p4Nzu/HGG53Ixe+PdkkFecS8EOb3SUi1n4zJJdm0MZ/xu0UM9qEtXsitz6Ql4TpMQhKW5ifGCLGhoqMP98nF5GkxJ+FEciSYCFFPiIdMN/DwQgYPGkQTDLVkZRuzhRupnwlExfb7YZBE3DOQuM3PhBx88MFO0eaB6ZPG1oX3UoGg2EPy1UR4mAJx1skM3IYYqMFqJn4AkwxECgbOiAfMCjITuO6667rzDuZByXSASPxvfWdvOV/yugQHrtm0ZzbHGdxH4qxw8JiC62Tafxk4MvtB3yVBrG9HBr6JsfxB/IMd0g3WMympmGxpSOlIrg2zQJBu8CdE2CCvgSdZ0nHu1UEPs1RGmc9H4H9HqfIT+JK83rCpj0cXog1GH8Yiz7Tgb9aLJ+RKwCjnWegnDYJlzOuzT7zvuPcxk+y9DT0+50d9herg58Frwvbqu81EMn3mBj2K6jIeszk2JjAQNIDxCc8Mb6R6MYVjRHxnNp/+mEyETzapk8lkRn23XdckmD8/vDNSjRFyPYGU6e+tvuecDp/EPlPIIRSEHCPZQLsmjh+9J0x92hgvLrxdEBlov8RcQfWZNAyOP3wf8HmZIHjvacjkaX0n4UT+kGAiRJ7wN0sGYKjEuBBefvnlDd4uRiPJyAAXPz9rgBjiZ26CCWW5qXMTHz16dFyZr4vgzZoEdN77JpgAzkOyUT/g8m6JDI5Q1BnUZnvOPOg//fRTp64zSAbCRlD2U8EDEddL2hi3bVyY/eAn+HAlIZeH0sW5gplBXFFx+/SVIMAnEmOg7wUKZj+YfcBTwleTScQfJwYMxkZdApp3ecW7hsSIXANcyT077bRT1ufELCLXniRlDMRwD85kwMIAx4e9cB1TnRthZPX1sgpC+zCICLYT2000QODLL7+MJ6H07v1CVALMPnvDn99v4kwl3gFe4GQW1gvhiTCrT8JWL46m8ubguUfCaU+qUt7JvOx8lRx+q4jP3NcSDSeMch/mQxJQL/bUFY7jjzuZoMs+ffl6YCYZb8WHH364ljFWX6E6+Hnwe6xb320m4s+L8YC/Fycj+Fx48MEHkwrc/vpkc2yIJf55gWDiBXYmMfx9l/s/1f2AiR4ENdrfe6w0ZDKjvtuuaxLB/yYIE0mVED7XE0iZ/t6yPedMJmWymTiiPRAag/C7zAeZtjGhUl44IvyGY+TzZJ5lmU5S+TF2Xe81dPK0rkk4UXgkmAiRJyjvCxjxzCQhQvjM/A0lGJaTGI7jvQP8QAlvC2b6cJdkti4TOF7/kOahg9GMC2IyCNdgMA64GbJfBkwY8mQUz7TSjBcYEHdwuabKjlf0ebj42cpkMIBhYEBMOuIBRjkVchIHhRgCnp49e7qHZFBYqC8IIrQ/7URWdj/Y8NtmhsB79xBDy/ER3oIHTDL8ceKBgvsmx0nVo2RwvsSPA0IN3+UaIOAA1zETIyIRBtC0HdeWa4Lrqx9UpiuvybH6z325ymTnRjw+15T1fQ6e+oTk4A7NAIqZJA+zwryXaPQhbHmPH+9CLUSlgNu455hjjnH3IsRbhOngbDAu4OngHsfvDoE8aGQmE129MUGYCxUlMMp5JrBPwg3IzVAf2C9VXMCH7SBwBO/xqcB9H/AgCcJEA6E45EggRwHHyT3a30vB5+wIPlcImeE5j1eKL0vMfY3wiWRtguiCsO2ry/Cs4D6dK/HbTwZssMEGSUOrPHzOdQTEfnJg+D7BWIWxgxc+sj3fYFgOYwjv7Rpsaw/3Y9qA86VyUkPJ17ZpH0Ccx9MD4YgQKvowOV7yMYGU6e8t23POZlImE84++2wnBvB79yIN4WPBvD+5ItM2DrYJFZoQYJnQSiYMBifTqG6Yi3Dphkye1jUJJ4pAHhPKClGSpKvKEqSh1WN+++236CGHHOKyupO5+6ijjnJVcxIzkkOmVXKC+Mo4LB06dIhXzPG89dZbrtpL8+bNo2uttZarWBI8d3+cqbLt8/mOO+7oqqWw/XPPPddlvU/8PlAB4dhjj3UZyakyQIZvMvRTUYUqLJleD19piKotW221VfSKK66IV0EIHldiG1LthbbmPDleqifQPqeeemqNDO1UbjjxxBNrVCrwmfzTVdCpq0oO37333nvdPjn+jTfeOPrGG2/U2MaMGTNc5Royz9M+gwYNit54441J25723H333d26/vPRo0enraBD3/rb3/7mKuZwDWiLs88+Ozpv3rz4OqmudbJzp/IQ+2jXrp3bHhV4dthhh3hm+XSMGDHCbatRo0auilSQL7/80lWfoKKR3ydZ9uuLr5CQagnSr1+/WhnshagkuE+n+70EK5sk3hu++OKLlNtNVrUD7rvvvhqVZxIXXy0uVZWcdFCRpXHjxvHvXX755Rl9jyotyZ5jVANL1zbcA4P3M+4jqdY95ZRT6lUl5/bbb0+5zc033zyjKjmrrrqqe//MM8+ssy2oosd2M6kcmOn5AuMRxg3BqiRUDvRQSSU4hvHLmmuumfG4y5NYJScX2042pqNyVF1VcuiTqSq4ZNK36/t7y+acgfFo4rp1jTFS9TuqSPlqOmeddZZ7j4pWvGY89t1336U952yr5GTaxq+88kqtz6hy48dVwf0xTmKcHlyXfaTrI/7YUlVn8v0mWRWe4HVJNqb0lQuDC+NaVckpHhJMhBBC5BQGy+utt15WRky+mTx5cty4evvtt4t9OEIUjWeffdaV3m3btq0TNf2A/Kabbqq1bkMFE2CQf8QRR7gSo82aNXOGCSXuKY9KufL6Ciaw9957u+9wHr4Ucl0gnHtj/sorr4y/T2niu+++O3rAAQdE1157bVdmlnsGhhMldROFXe5z1113nRMVmJjAoGGi4K677krZhpQ8/fvf/+7WRTy58MILa5V4boj4PW7cuPj7iNOZgAhz2223RbfZZhtnTCL6YwTutddeTvzO9nw9TFj4Y+F8Evn888/d+5SkRYi4+uqraxic9RVMcrHtZIYvTJs2LXrCCSe4crC0E+219dZbR995552cTyBl+3vL9JzrOymTrN8xIdWlSxf3ulu3bvESuYgavkwz/SpxQq8hgkk2bUyZbsQJ+ivC4Pvvv59U6PBC6vrrr++uay4Fk/pOntY1CScKS4T/FcOzRQghRHjBDRt3bpKVEVrUkESMuQA3YdzHCd1JlotHiEqEGH9CDchxRdgooXKpEr6WGsT246JOOAQhsD4MMxMuu+wyF+pAGA+5lhpS1aeUoFrJbbfd5sIWMs1ZJoQoDfx9iCpZPmRPlAYSTIQQQgghKpS5c+c64YGcByTmfOONN5ImRiwldthhB/vkk09cYmeMDI6Z3F2ZQs4DyuKSq4McWSS2LndI5kvlG3ImUD0oVd4xIURpIsGkdEmf2lcIIYQQQoQWEiKS7LOc+Pbbb13yRpKCn3vuuVmJJUDCaV95IiyQ5DoXlceEEELURB4mQgghhBBCCCGEEAmorLAQQgghRMi5+eabnUdG8+bNrXfv3jZ+/Pi06w8bNsyV0WV9Sr0rJ4YQQohKRIKJEEIIIUSIefTRR+2UU06xoUOH2gcffGC9evWyfv362a+//pp0/bFjx9qBBx5ohx9+uH344YcuWTILCVKFEEKISkIhOUIIIYQQIQaPkk033dRuuummeIUZquEcf/zxduaZZ9Zaf//997d58+bZc889F39v8803tw022MBVYRFCCCEqBSV9LTAMUkg0tvzyy4emjJ0QQgiRLdFo1ObMmeNKT1dVyeE1XyxcuNBVTaGMrof27tu3r40bNy7pd3gfj5QgeKRQLjwVVGdhCY53Zs6c6SruaLwjhAgbeoZVDhJMCgxiCbM6QgghhDCbPHmyrbrqqmqKPEHp3SVLlli7du1qvM/rL7/8Mul3pk6dmnR93k/FpZdeaueff36OjloIIcoDPcPCjwSTAoNnif9xtWzZ0ooJsz/Tp093pejCMruncyoPwnadwnY+oHMqD8r5Os2ePdtNIPjnoihv8GAJeqX8/vvv1rlzZ9vKdrHG1qSoxyaEELlmsS2yN22EnmEVgASTAuPdUhFLSkEw+fPPP91xlNtAOxU6p/IgbNcpbOcDOqfyIAzXSeEa+WXllVe2Ro0a2bRp02q8z+tVVlkl6Xd4P5v1oVmzZm5JBLGkcUSCiRAiZERj/+gZFn7Kc3QlhBBCCCHqpGnTprbxxhvbyy+/XENo4/UWW2yR9Du8H1wfRo8enXL9jGDCSIvaQH1AfSBMfUBUBPIwEUIIIYQIMYTKDBgwwDbZZBPbbLPN7LrrrnNVcA477DD3+SGHHGIdO3Z0eUjgxBNPtG233dauvvpq23XXXe2RRx6x9957z+64446GHUhE83RCiLBQFfcyEeGmZJ9cN998s3Xp0sWaN2/uyuGNHz8+7frDhg2zbt26ufV79OhhI0aMiH+2aNEiO+OMM9z7LVq0cBn5GRyQgDUI2dz79+/vXJtXWGEFO/zww23u3Lk11vnkk09s6623dvsh9vqKK67I8ZkLIYQQQuQOygRfddVVNmTIEFca+KOPPrKRI0fGE7tOmjTJpkyZEl+/T58+9tBDDzmBpFevXvb444+7Cjndu3dv8LFEqiJa1AbqA+oDoegDojIoSQ+TRx991M2G3HbbbU4sYSaEcnYTJ060tm3b1lp/7NixduCBB7qZkf/7v/9zD/k999zTPvjgA/dwnz9/vvv73HPPdQ/+3377zc2e7L777m7GxINYwoABt1NEFmZejjrqKLc9n6Buxx13dKX4OLYJEybYv/71LyeusJ4QQhQbqmFw/2oouOyzHfJjlGtujER0ToWlSZMmLneGKA2OO+44tyTjtddeq/Xevvvu65a8IFd2IUTZI8GkUohEKSJdYiCSbLrppnbTTTfFB7l4cxx//PF25plnJp05wbX0ueeei7+3+eabu1kUhI1kvPvuu84t9ccff3RZ3L/44gtbb7313Pu4rAKzL7vssov99NNPzivl1ltvtXPOOceV1SMmGDgeZl1SleZLBNGlVatWLnt8KSR9/fXXX50IFSaDSOdU+oTtOpXC+XAr5940a9asnG2P8+J8wpLQTOdUeJhQIFFosj5USs9DkXv89d3O9oglfXUx/1WxWVnF/wshypzF0UX26sJheoZVACXnYbJw4UJ7//33XXk6DwN2vDrGjRuX9Du8HyxlB3ikIGSkggEaAzgGc34b/O3FEmCf7Pudd96xf/zjH26dbbbZJi6W+P1cfvnlzmtlxRVXbNC5CyFEffFiCaLNsssu22CRA3Fh8eLF1rhx41AJJjqnwrU13p0IidC+ffsC7VmUFSG5twghKhHdvyqFkhNMZsyY4VzKfVyth9epvDgwFJKtz/vJwMWcnCaE8fhZLdZNDPfBUFhppZXi2+Hf1VdfvdZ+/GfJBJMFCxa4JTjjAszcshQT9u9nXMOCzqk8CNt1Kvb5cM9EtOUexj0rVxCSQ1hFmNA5FQ5yffG7QDTxpW2DhOX3LxpGTJCV4SGEKC8ium9VDCUnmBRisLzffvu5QRwhNvmGvCrnn39+rfenT5/uhJtiwmAVTxvaIgxhEaBzKg/Cdp2KfT7c1zgGvN/woMgFnAtCDITJw0TnVFjok/RNJhUSxbc5c+YU+GhEaRIxU/JEIUS5EQ3H2EiUoWDiZ6GmTZtW431eEwedDN7PZH0vlpC35JVXXqkRM8263nXYg+FB5Ry/nVT78Z8lg9CiYLgQHibkY2nTpk3RY7YZxGIIcSxhMFpB51QehO06Fft8EF8xPjFI8YzLJWHzMAGdU2Hbmt9E69atncdJkMTXosIJiTArhKgUdM+qFBqX4mzUxhtvbC+//LKrdOONEV6nyu6+xRZbuM9POumk+HtUuuH9RLHk66+/tldffdUN3hK3Qfw/+VPYPyCqsG+S0Pp1SPoadOlmP+uss07K/CXNmjVzSyIMIEvBUMTIK5VjyRU6p/IgbNepmOfjE7P6JVfeGH5bYfIw0TkVFt8nk/02wvLbFzkkJPcaIUQloPtVpVCSoxU8Mu6880677777XPWagQMHuio4lPmFQw45pEZSWEoEU9Hm6quvdnlOzjvvPFcu2AssCBz77LOPe+/BBx90Ltm4B7OQZBbWXXdd22mnnezII4+08ePH21tvveW+f8ABB7gKOXDQQQc5Qefwww+3zz77zJU/vv7662slnBVCCFFZ8NyhMpvn0EMPjYv+2XLwwQfbJZdcksOja9jxBEvPIn74Skw8dzln5SIROcVX0NGiNlAfUB8o9T4gKoKS8zDxZYLJ8TFkyBAnajAgY2DmE6xOmjSpxsxUnz597KGHHrLBgwfb2WefbWuttZarkNO9e3f3+c8//2zPPPOM+zs4oAW8Tbbbbjv3N2IKIskOO+zgtr/33nvbDTfcEF+X8nijRo2yQYMGOS8Uwoc4xqOOOqog7SKEENly9NH1azMKzkejVVmPCW6/Pft9TZ482YYOHeru8yT+pqIKxj3310RvwELAM4FnxXXXXRd/74cffnBJvz/88MNazxE49dRT7fjjj2/wvj/++GMbMWJEjRxb33//vfNuRLAgTJRnD88gKrTh4VgsmGQ499xz3bMTkUeIXBEWrzYhRHhR0tfKoSQFE0C4SBWCw6AxkX333dctyejSpYtzxa4LqksgvKSjZ8+e9sYbb9S5LSHqbcHWx+IUokz57rvvXLjj2muvbQ8//LATJfDgO+200+yFF16wt99+O6eVf/LFcsst55aGcuONN7pnmd8WHpJ///vfnTDy5JNPOjHpp59+cm3jPT2KCZ4rTCxIMBEVixLWClGZKOlrxVCSITlCCCEqAzz2CHXEe2/bbbe1zp07284772wvvfSS8w7EsyI464z3YJAVVljB7r333vhrSsYjviy77LK2xhprOA8IRAfPBRdcYBtuuKH997//dWI6noOEXvqKLQgAr7/+ugu39Pk38C7JNiTHQ5U0n+T7mGOOiYeBJoNw0ccff9x22223+HuIR99++63dcssttvnmm9tqq61mW265pV100UXutWfChAm2/fbb2zLLLOO8cvB8nDt3blbHs2DBAjvhhBNceWoSsm611Vb27rvvpj1vjpVwV45RiLyIEaW+lCy4B1ZpURuoD+SzD4iKoGQ9TIQQDYixkJeKKAMIL3nxxRft4osvdoZ+ECqP9e/f3+WKQizI1EV/+eWXdwIKuacQEchLxXunn356fB2Me4SX5557zn777TeXEPyyyy5zx4FQ8tVXX7mQTsQVQGAgbChbSEaO8IBXJKILebgQM9hPMj755BNXnnqTTTaJv+crLyGkkNicKnKJkOOL8Bg8dRA4qPh2xBFHOC/NoJhU1/HQRk888YTLH4Ywc8UVV1i/fv3sm2++Senlg8BFuCyel2uuuWbWbSREZoa/2qlsUXiVCCvyMKkYJI0JIYQoClQtI1ySpNvJ4H0EDXJaZQq5rMhrhfcI3g/kFnnsscdqrEOSUoQERJGtt97ahZMgJgAeJ3i84KGCaMOSTKTIBLZz99132/rrr2+77rqrE2AIX0mVJJWS9+wLDw9Px44d3XfI50I1NrxILrzwQhfK5HnkkUdcaen777/fnRPr3HTTTc6LZtq0aRkdD6ILeVOuvPJK5+Gz3nrrueTrCFl33XVX2vNEnOLYhcgLTiwpgeSOZblYBS/FbnstFdEGoiKQh4kQJe5Iwv24TRszbEZS8SjDiQgbdeWYwtDPFDxSEAHwIiEkZfHixS78JAhiCl4nHvKC4JWRa3r16uWEFw8eIBwT3ip4cCTyxx9/uDL0id40hC1RHQ7PEHK6DBs2zFXRIZl53759XXU49tWiRYv4dwjbQQiZOHFiPGF6uuPBs4XQJb7nadKkiW222WauWl06EFXmz59fz1YSIgO8ASxEphSku6hPVjS6J1UM8jARQghRFLp27erEgVQGOe8TkkKeEmDdRHElmJ9k3LhxLoxnl112ceE2VLQhB0pi3hCEgCBstxRK41L9BuEhWZ4TBB48ZgifoZIOnjHkMSmV0CqukxB5p9izyVrKpw3y3xmLf45ait8GoiKQh4kQRWTMmNrvPVjPMrBClBvkz6ACDDlKTj755Bp5TCgpT7lavCs8GOVTpkypEdIT9GwYO3as89wIJoqtT6gIHi0kYG0oCBt4jfjzwjuE6jedOnVKur5PGvv5558nTSAbFHi6devmzhf4m3Acwmq8l8lbb73lcp8Eyw6nOx7EGs6b73nvF8QocqKQOyUVhALhzUMiXSEKgjNSZKiIEOOM8WIfhKgbXaRKQYKJECVG/zE1FZNoVcQWrdPGmkycbpHqqNk2RTs0IXIOuTbIOUJyUTwmgmWFqXZD7g6Pz81BKAmCBhVxgt4ia621lk2aNMnl9Nh0003t+eeft+HDh2d9TITsvPPOOy4xKoJCMOEpIS6JkBMkGXiKHH744S6vCtsaOnSoS8SKkJEMBKGNNtrI3nzzzbhg8tFHH7nvkWeFvCKIGlTxIRcJ5w8HHnigy0cyYMAAV62HnC/HH3+8+44Px6nreBBaBg4c6Nqd8yWZK0lfEaT4TioQXQgj4poIURi8MSljRYSUHHftTJOmC7WrSI4EEyGECDH1LZhE5MvixdXWuHFVXr1OETnwYsDQp1oNuUQIu9lrr71c0tJgzo2rr77aVXYhHIVEo1S0ef/99+Of77777s5TBRGAErkkNqWsMNvOBhLFIj4gUOCR8f3338c/owRxIqkq6Oywww7u/LbZZht3PAgbdR0L1W3wFuEcYNVVV3UCDuWAETkY+PrXnCvQRiNHjnSeIAhFvN57773tmmuuyep4qBREaBJCC2WWqdZDFSOSzabi4YcfdmFQweskRP6h5LfaWYiCoh+d2qNCiUTryrYncsrs2bNdFQYS7CUmIiw0DIwxTqjIkGrGs9woi3MKlAVOFpKTSKKHyTaZeJiUeFnhsrhOZXQ+hEVg1OOdQdnYXMCjgYSpjRs3LvjsFJ4PGPujR4+2zTffPGfbLeY5ZQoCDWE0JK/NxGujmOc0Y8YMd6zvvfee63vZ9s1Seh6K3OOv73a2hzWONFkaZlBlkaqaOQAikSqzWu8t7csJ7/ttxNaRASdEwWjo86VEn7kNYXH1Qntpyu16hlUA8jARonD6iKN/BiKJEJUM3hN4URDuQZWWMIhqmUJ+ETxMECNKHTxeyD+TSiwRoiCE0BATIlSENUFqCE9JJEeCiRBCiJKD0JtKZbvttrNygJAdFiGKDp4oQogSpZ6/z1IXWUr9+ETOqJxpOyGEEEIIEVJKoMSoFrWB+kCSPmD1W+pxC1BZ4ewhfxlhkMGKeEzc8F5wOeaYY2p8jyT75Iojhxkh6SSNJ0Q4jMjDRAghhBBClDe+co4mfYWoULL88Tf0XhGCew1J92+//Xbr2bNnrc+OPPJIV4HPE0zuTqVCxJJVVlnFxo4da1OmTLFDDjnEVS685JJLLGxIMBEiD3lKioVPIvvg0WWXB1YIIYRoGCo3LITI9F5R4Yls586d66rc3XnnnXbRRRfV+hyBBEEkGaNGjbLPP//cXnrpJWvXrp1tsMEGduGFF9oZZ5zhqu81bdrUwoQEEyGEEEIIUTmowo4QoqHiSB4FEyrMLVy4MKvvIFJkUylx0KBBzkukb9++SQWTBx980B544AEnmuy222527rnnxr1Mxo0bZz169HBiiadfv342cOBA++yzz2zDDTe0MCHBRAghhBBChAufO6HQ+xRCiAaKJauvtpxN/XVJVt9D2Pj4449riCbNmjVzSyKPPPKIffDBBy4kJxkHHXSQrbbaatahQwf75JNPnOfIxIkT7cknn3SfT506tYZYAv41n4UNCSZCCCGEECJclHNOEwkvQlTs7xTPEsSS799fzVoun1l9ltlzqm31jX+sJWIMHTrUhcgEmTx5sp144ok2evTolB4pRx11VPzvHj16WPv27W2HHXawb7/91tZcc02rNFQlRwghhMgDd911l+2444453ea9995rK6ywQoO3Q8b7p556yv09Y8YMl+H+p59+ysERClFCxO2ZSJktOThvVWtRG6gP5L8P5JEWy2W3eDHk999/jy9nnXVWre2+//779uuvv9pGG21kjRs3dsvrr79uN9xwg/ubhK6J9O7d2/37zTffxL1Zpk2bVmMd/zpV3pNyRoKJEDmm/5ij0y65SOyaahGiHOEB/69//cu5fhKDixsosx//+9//aqzny9xRAi8R4nD5LHEmhYf7YYcdZquuuqqbSVl77bWdq+l7770XXydYNq9Vq1a25ZZb2iuvvNJgl1rifZnd8cyfP98NXpid4VjatGlj2267rT399NNWTFZeeWWX3T54rEKEh0jF6SUN3kixz1+L2qBc+kAeqbZoVgu0bNmyxpIsHAdPkQkTJthHH30UXzbZZBOXAJa/GzVqVOs7H330kfsXTxPYYost3DYQXjx4rLDP9dZbz8KGQnKEECLM1LeEUzRqVdFo9rMoWZZj+u6779yDFyHj4YcfttVXX90lDDvttNPshRdesLfffttWWmml+PqdOnVyXhZnnnlm/L2ff/7ZXn755fiD3IMowsCge/furmzeOuusY7/99ps9//zz9u9//9vNqHjuuece22mnnZy3xTnnnGP/93//Z59++qmtscYaVh8ef/xxN3BAfPEcc8wx9s4779iNN97oBhQIQpTjSxSGigGi0sYbb2xXXnlljfYWIjQozCWbxrJono1BIcqdaJ4Vk2r3X+brZsryyy/vxkVBWrRoYa1bt3bvE3bz0EMP2S677OLe++STT+zkk0+2bbbZJl5+GO9ZxjEHH3ywXXHFFS5vyeDBg10i2WQiTbkjwUSIEJLUkyX4lmoMixKBhyteJZSoW2aZZdx7nTt3dhnW8cRAvLj11lvj6yNkPPbYY/bWW2/FxYj77rvPPbwnTZoUXy8ajdqhhx5qa621lr3xxhtWVVXl3lu8eLGbSTnppJNqHAdhLriRsrC/jh07utkSjomBwi+//FJjELDnnnu6Qcd///vfpOdFQjWyygd55pln7Prrr3eDEOjSpYsTKYIg6OBd8+yzz9qCBQucBwpuspxHEMJpEJXwzmEQ85///Me1m4dzuOqqq9zniFAMZBjYpGL99dd3Hj7Dhw+3ww8/POV6QpQz0SqpAPmnTPPGCFFiIuySaNQtma6bKxiTUS74uuuus3nz5rmJqr333tuNIzx4oTz33HOuKg6TXgguAwYMsAsuuMDCiEJyhBBCFIWZM2faiy++aMcee2xcLPEgXOAe+uijjzqhI/gg5308Qjx4nBDSk+g+iqcKniSIJYmkywPij4XEa/vuu6+L50Xs8OCCipdK4j6DvPnmm06YSTynESNG2Jw5c1J+D5EHzxj2R9k+zh2BZdGiRTVCey6++GK7//773X5mzZplBx54YPxzRA9EF84dL5mjjz7aeZC8+uqrlo7NNtvMiUtChBvltshvXof6XBJdE7VBmfaBEgvJqS+vvfaaE0gAgQQPXLxfCS/++uuvnRcJXrNBCJ9mTMOYZPr06W6ShhwoYUSCiRBCiKLAQxhBYN111036Oe/jccGDOAhCBV4mzHyMGTPGJTbD8yRx29CtW7esjokHP7MozJ7g3YF4Qs6ToEDzwAMPOG8OcqokAwGDY8JjI8gdd9zhQnBwcd10002d5wqeMsFjRijBW2Trrbe2Xr162YMPPuhCjnyCVkA8uemmm9ysDh4qJJdlu+PHj3efM2hBeEGIItTplFNOsb322su9nw6O98cff8yqvYQoSSIZfFZsQ0tL/Y1OtZ3aoFT6QB5BBFmS4dJQwUSkR4KJEEKIohL0IEkGXiVBEBIIUSFPyN133+1CTRJnNeraZiJ4aCy33HIuzOaJJ55wIoSP1T3yyCNdyBDChfdoQZAgSWwy/vjjD/dvYrk+QmfI2UK+lX322cd5wCCMXHjhhe7zL774wp2Hz0YPiCvkXuEzD+sguHgQhfCY8evwbzB3CvA6uI1kIA4hGAlR9tRlyPjPi50wUkthEm2qndUGFZL0VeSHcPrNCCGEKHm6du3qRAcM+X/84x+1Pud9KskkC5/By+Tmm2+2zz//PO5ZEQTPCvjyyy9dPpS6uPbaa61v376uSg77DML3EWkIgSFXCkIHITmpQOTgvPCOSaRJkyZOJGE544wz7KKLLnIxv/xdCiFSiecuRGhxxk49Q0hE+ZFnbwBRgYQ0h4mojTxMhBBCFAWEhb///e92yy23xL0yPGRcJxwFT45kECZDSTsyuicrYbfBBhu496+++mqrrq5OGjaTmF8EASeVYHDEEUc4zxJCcxBWiPFN5xHDvhFz6oL1SERLnDAhSPxNJR0PMcQTJ06scY6sEyyLzOecjw9t4t9gqA/wuq5Sf+Q7yURcEiI0uFniEnDr11I6oRO6FmqDkgnJyW4R+UOCiRBCiKJBLg6qwfTr18/lI6Gqy8iRI52QgpfIkCFDkn5vxRVXtClTprjwlmTg4YG48dVXXzlvDhKTEQ5DeTwSpu6xxx5ZHScCzU8//WR33nln2mSvHs6HhKxByHlCeeP333/ffvjhB3dMZ599tv3tb39zydQIM+K4CAHiux9//LH985//dBV7gseLl8rxxx/vhBW2hZiz+eabu6StQPUcxB0q5ZAX5ZprrrEnn3zSTj311JTHSygO28KDRoiKQ0ay2kDCivpAieUwyTR/iV9EhQkmuFlTbpH4b2K5k7lbBxk2bJiL4Wb9Hj16uEFoEAaKDAK9mzTVE4IwcOX9ZAvb9iT7nNKRQpQDY8b8tRx9dM1FiGKBSPDuu+/aGmusYfvtt5/Lur7zzjs7sQSvCPKKpIJQHUrZpQIBAU8MPEcQIfCwoDQenh8+G3ymEKrDdzkeSgrXBaV5eRaR/DUoovgSyHiBIHrwHglsPYg8JHIliS1JXcnFwnYQSTzLLrusC+FBxNlqq63cMQWfRRwf5YtJ8kq5YEQatpsqSS08/fTTLpEt4pIQFYtyXagNMuoDGRrKEbOollC3QT5ZEs1uERWUw4QSkmT0v+2225xYwqCWASUux23btq21PpUBSNZ36aWXugHmQw895AaLH3zwgXPVBiopMKhkMM6gORFcq5mpTKxmcOWVV7qBexAGnTvttFNGpSmFEKLo3H57/b4XjVr14sVWRTLVPM+iIJDjEeEZOnSo84rAGwTPiWDZu3QkiuGA8IJIAYgPhLOQNDWYsDXTBLEkfaWkcbNmzepcF3Fm1113deFGZ511lnuPf/3fqcBzhlwpqSBEyYcpUfkmeE5BBg4c6JZUJJ4zAksqbx4hKgLlNBE5JnaXrSsBsZq9bClQSE6m64oKEkwYJCNqHHbYYe41wgnJ9aiEcOaZZ9Zan0EeAgYuyEC1gdGjRzs3b74LVFDwniTJoHwk8etBhg8f7gSWxNlNBJLEdYUQQuSO888/34kob7/9tvMSqaoqrjMkyVsRa1gQQDIF0f3ZZ5+1UmfGjBlOfGHyQYiKhlljJYIVBe5zokzJe5WciC3JcCesKypEMFm4cKGLoQ7OwDFQJsHeuHHjkn6H9/FICYJHylNPPVXv4+AYmKkkNCiRQYMGuXhx3MePOeYYJ+ykKi0phBCifnjRvBQgESqiyeWXX+5K/GYKog9hN6XOyiuvbKeffnqxD0OI0qAA5UKFyAxVcapoD5NobMl0XVEhggmzXEuWLLF27drVeJ/XlIZMBpUUkq3P+/XlrrvucvHlffr0qfE+pR+33357Fz8+atQoO/bYY23u3Ll2wgknpNwWyQxZPLNnz3b/UrUhWeWGQsL+ccsu9nGE4ZyC98xoVW5voGzPxUrmcLuRSM32KXQXCFvfK/b5+P37JVf4beVym8WmPuf0/fff1/p+KVHK18n3yWTPvLD8/kVI0WSYKAfUT0Pb9kuy8DDJdD0RAsGkFKC0JXlQzj333FqfBd9jxpHcKLhcpxNMyK2Ce3ki06dPd2UkiwmDVRISMpgttst7uZ9TsBLponWSlyWtN5GILenY0iLOVzg3BlGbNr/WeP1rzZd5J2x9r9jns2jRIncM5LJgyQWcCwI2hMWLTudUeOiP9E3KIwcT18KcOXOKcERC5JiQ3B9FCFHXLOv2lWBSOjQuNbdg8olMmzatxvu8TpU3hPezWb8uHn/8cVde8ZBDDqlzXZLSkjMFD5JUSQAJLwqGDOFhQpLZNm3auDKSxYRBLIYQxxIGo7WY5zR9+l9/N5kYeJErDxOLWuOvZlgkRz530xMSKCfJp5xXwtb3in0+iK8YnyT+TEz+2VASjdwwoHMqHPRHfhNUqaOSXZDE10KEGhmvosC4fDypUH9sePvmPSQn4pZM1xUVIpg0bdrUlVN8+eWX42UbMUR4fdxxxyX9DmUX+fykk06Kv0fSV96vbzjO7rvv7gyfuiDPCRUN0lVM4LNknzOALAVDESOvVI6lnM8p6PiRK1EjSCQa226uth2N1mybYlz+sPW9Yp4P+/ReILnyBsEbI9fbLDY6p9L6bYTlty8qgBzcA9Mar0n32eBdCqH+lU/kYVIxlJRgAnhjDBgwwDbZZBNXHYGywoS++ASAeH507NjRhbrAiSeeaNtuu61dffXVroTjI488Yu+9954rC+yZOXOmTZo0yX755Rf3mhLFgBdK0BPlm2++sTFjxtiIESNqHReVDvBcocQls2KIMpdccomdeuqpeW8TIYTIxGMC77hllllGjSVKBvpkWL16RGWR79nkGijxrCgWIZkgCYdgUuWWzNYVFSWY7L///i6/x5AhQ1zi1g022MBGjhwZT+yK8BGclSIxKzlHBg8ebGeffbattdZarkJO9+7d4+s888wzNSouHHDAAe7foUOH2nnnnRd/n9LFq666qu244461jovBHlVzTj75ZDdL2bVr13gJZCGEKCaEMlLy/NelyWhITN1QrxDuc+SfIKQiTB4mOqfCtTViCX2SvkkfFaLsKTUhIyT3ZlHiqJ8VpV2iWYTksK6oIMEECL9JFYLz2muv1Xpv3333dUsqDj30ULfUBR4jLMnYaaed3CKEEKWI95bzoklD8ZVNguE+5Y7OqfAgltQ3p5gQpUmZ3Q9Dcv8WpUel2+j5rkunpK+lQ0kKJkKUNEcfXeut/mOKciRCxEHUaN++vbVt29ZVzWkovrIJyTrDkmtC51RY8MyUZ4kIJSEyFEuvGLkoaypJoMt3WeFolVsyWzevh1LxSDARQogQgYGaCyMVcQGDl5xNYRJMdE5CiLLLaZJPQnIaooSolD6V5/OstohVZ5jDpLoB0udll13mqrqSF5Tcob764r///W+XG3TBggXWr18/u+WWW+IpMnyajIEDB9qrr75qyy23nMtBSo7RXFdrLAXCd0ZCCCGEEELkm4oxDCOVc64iL4RGYCzgORUiJOfdd9+122+/3Xr27FnjfXJ2Pv/88zZs2DBr1aqVS5Wx11572VtvvRXb35IlrtgKIbdjx461KVOmuMIsTEqlSm9RzkgwEUIIIYQQpUVVCRhYmRhEITQEs0ZtINKQ0veh3H86+a6Sk1VITvYeJnPnzrX+/fvbnXfeaRdddFH8/d9//93uuusuV1Rl++23d+/dc889tu6669rbb7/tKsaOGjXKPv/8c3vppZec1wlFWi688EI744wzXEGVpk2bWpgIh5+1EEIIIYRICZX+unTp4sLsevfubePHj0+5LgPorbfe2lZccUW39O3bN+36FU+kApaURJxBrEVtkKoPpOg2SbyYynDJe0hO5ku2DBo0yHmJcH8P8v7777tceMH3u3XrZp07d7Zx48a51/zbo0ePGiE6hO3Mnj3bPvvsMwsb8jARQgghhAgxjz76qJ1yyil22223ObGEOHUGtxMnTnSJopNVJDzwwAOtT58+TmC5/PLLbccdd3QD4Y4dOxblHEqdMIYc5AQ1iwhr38nz8S2KNraF0cxy0i1aWrIIwSJIs2bN3JIIuUk++OADF5KTyNSpU52HCFXugrRr18595tcJiiX+c/9Z2JCHiRBCCCFEiLnmmmvsyCOPtMMOO8zWW289J5wsu+yydvfddydd/8EHH7Rjjz3WuVkzs/if//zHJU1++eWXrWwohoBRbC+QUlzqbLMS8BLQUvw2SEI5eC3lExK+ZrNAp06dXM4Rv5CENZHJkye7BK/c5xHERd3Iw0QIIYQQIqQsXLjQuVhTBcFD5Svcrb17dV3Mnz/fuWivtNJKeTzSkCBPk5ywdMJciKW/q/j/KqiscMQtma7rxZCWLVvG30/mXcLz4Ndff7WNNtror+8vWWJjxoyxm266yV588UX33Jg1a1YNL5Np06a5JK/Av4lhmnzuPwsbEkyEEEIIIULKjBkz3GA4mfv0l19+mdE2SOTXoUOHWrHuQSg9yeJJdA2vJGTs5xEJUsL1gxLQT/Icp7HEqtyS2boxfxfEkqBgkowddtjBJkyYUOM9vA/xJuRej5cK1W7wKNx7773d54RvUkZ4iy22cK/59+KLL3bCiw/rHD16tNs3XoxhQ4KJEEIIIYRIymWXXebi3clrks59G9fv888/X63okWFfWIptPIuiES3Sxc/3fqujVW7JbN3MA4SWX3556969e433WrRoYa1bt46/f/jhh7u8V3gVtmzZ0o4//ngnklAhB8hphTBy8MEH2xVXXOHylgwePNglkk3m1VLuSDARQgghhAgpK6+8sjVq1CjuLp3MvToVV111lRNMKB3Zs2fPtOsS8sMAO+hhwkxlRSMjvujtne88E6LYkAOleLsuNQ+TXHHttde60E08TBYsWOCShN9yyy3xz3mmPPfcczZw4EAnpCC4DBgwwC644AILIxJMhKhA+o85uuYbCS/t9tsLeThCCCHyBNUONt54Y+deveeee7r3fALX4447LuX3mDXE5Zp49k022aTO/aSqxlDxRGS0V6xBLYpDJBz7qQ7kJslk3YaAB2EQvAkpRc+SitVWW81GjBhhlYAEEyGEEEKIEIPnB7N/CB+bbbaZKys8b948F7cOhxxyiCsX7CsqUEZ4yJAh9tBDD1mXLl3iZSKXW245t4jMcfO+Cs8pPSSihJ58l/rO9/aD1W8yWVfkDwkmQgghhBAhZv/997fp06c7EQTxg3LBI0eOjCeCJZkf7teeW2+91VVJ2GeffWpsZ+jQoXbeeedZ5XmI5MAwkoFeFuTbCBZFJFJmITnRKrdkuq7IHxJMhBBCCCFCDuE3qUJwEt2xf/jhhwIdVWUR866XQV426FKFkxyFyeW7Gla1RdyS6boif0gwEUIIIYQQIu8sNWpk25QvunZlT1wsaaiAmWdvJHmYlA4STIQQQgghhCgEMrjLmqSeCfIcqszfY0lVyVFITj6RYCJEhhy9tJJM/zFqMiGEEEKUrju/KCSqxFOJv8m8h+REI27JdF2RPySYCCGEEEIIUQpUyfApd2S7ljkl8hOk8k2mniOqkpNfJJgIIYQQQghRDFSVpTIoESNc5NBjKN9lhaNVbsl0XZE/JJgIIYQQQghRLDKwu+S1EAakmpRvctgkn+c9h0nELZmuK/KHBBMhhI1JyMvy4NJ8LXD77WogIYQQIp80yPiSl0rZIQGsTCiiDiEPk9JBgokQQgghhBDFJlfCRyRFNRdRmsg5oDyvUd49TDL3HGFdkT8kmAghhBBCCFEKCV4j+Sx9K0oeXaeSJhoQNYN/5wN5mJQOEkyEEEIIIUT4yKVBEymcMVvwcA0Z6SWJE74UblV6RArkYRKtckum64r8IcFECCGEEEKIEhBLau23wOR71lw0AF2a0oGwtzxfj6hFrDrDi866In9IMBFCCCGEEKKUWGr/lEQuEtliJYeSxpYA8jCpGErSf+fmm2+2Ll26WPPmza137942fvz4tOsPGzbMunXr5tbv0aOHjRgxosbnTz75pO24447WunVri0Qi9tFHH9Xaxnbbbec+Cy7HHHNMjXUmTZpku+66qy277LLWtm1bO+2002zx4sU5OmshhBBCCCESQjIKuYjyEEu0FL8N8kx1NJLVIipIMHn00UftlFNOsaFDh9oHH3xgvXr1sn79+tmvv/6adP2xY8fagQceaIcffrh9+OGHtueee7rl008/ja8zb94822qrrezyyy9Pu+8jjzzSpkyZEl+uuOKK+GdLlixxYsnChQvdPu+77z679957bciQITk8eyGEEEIIIQKUoGGIfUbaBC2Fb4Na16TY/aOSlzyyxKqyWkT+KLnWveaaa5xwcdhhh9l6661nt912m/PouPvuu5Ouf/3119tOO+3kvD3WXXddu/DCC22jjTaym266Kb7OwQcf7ISNvn37pt03+1lllVXiS8uWLeOfjRo1yj7//HN74IEHbIMNNrCdd97Z7QtvGEQUIYQQQgghsiWTyWEnUJTQIkqESM38M1oK2wbl6GFy6623Ws+ePZ2dy7LFFlvYCy+8EP9cURclLpggPLz//vs1hI2qqir3ety4cUm/w/uJQggeKanWT8eDDz5oK6+8snXv3t3OOussmz9/fo39EO7Trl27GvuZPXu2ffbZZ1nvSwghhBBCiIwp9mx6utn1hM9kuBfIaLe/FhEuqq0qqyVTVl11Vbvsssuczf3ee+/Z9ttvb3vssUcNe1ZRFyWc9HXGjBku9CUoSgCvv/zyy6TfmTp1atL1eT8bDjroIFtttdWsQ4cO9sknn9gZZ5xhEydOdPlP0u3Hf5aKBQsWuMWDwALV1dVuKSbsPxqNFv04yuWcvJAcrSrsQ4n9xVxfC7ffSOSv9stH9whb3wvb+YDOqTwo5+tUjscsRNFhPGClDvlQin0Mwl+D0u8v5Um+Pa2WRCNuyXTdTNltt91qvL744oud18nbb79t66+/fo2oi2SMWhp18dJLLzlbmMgLoi6wnc877zxr2rSphY2SEkyKyVFHHRX/G0+S9u3b2w477GDffvutrbnmmvXe7qWXXmrnn39+rfenT59uf/75pxV7sPr777+7wTaePGEgn+fUpk3s30XrLP2jUEQitqRjS4u4UVJhHntt2vyVMyhF+qAGEba+F7bzAZ1TeVDO12nOnDnFPgQhyjcRbDlSpodd9qjdy7Jdswm18ev5iXlPs2bN3JIKHBUonkK+T0JzglEXpKFANNltt93s3HPPdSJKuqiLgQMHOi+VDTfc0MJGSQkmhMM0atTIpk2bVuN9XqdSuXg/m/Uzheo88M033zjBhO0lVuvx+023L0J7SGLroSN36tTJ2rRpUyNHSrEG2lQD4ljKbaBdjHOaPj32b5OJS/8opIeJRa3xVzMsUl0YwaTvxPPif7dNdrq33NKg7Yet74XtfEDnVB6U83Wisp0QojKN4JjwU+yjqCDU1mXXptFolVW7LL+ZrQvYmEEoooLXRyITJkxwAgmT98stt5wNHz7c5Q7NZ9RFOVNSggkuPBtvvLG9/PLLrtKNHwzy+rjjjkv6HS42n5900knx90aPHl1DJasPvvQwniZ+P7gsUa2HksJ+P4gevoMlI5Wyx8C2FAa3DLRL5VhK/Zy8c0ehRIsgkWhsv8XYd1WyXeagbcPW98J2PqBzKg/K9TqV2/EKUWqeHaFKvhqmcylxQtVvwhySYxG3ZLouTJ48ucaEfCrvknXWWcfZunioPv744zZgwAB7/fXXnU2br6iLcqakBBPAG4OLtskmm9hmm21m1113nXMTomoOHHLIIdaxY0cX6gInnniibbvttnb11Ve7sr+PPPKIS2Bzxx13xLc5c+ZMmzRpkv3yyy/uNSoZ+Go4dICHHnrIdtllF2vdurVT004++WTbZpttXBZh2HHHHV0nouIO5YZR0AYPHmyDBg1K6+okhBBCCCGEqBt5nhQS5ZppWPPlu0rOX6E2mawLvvJNJk4KXbt2dX/jrPDuu++6yrO333573qIuypmSm97Zf//97aqrrnJlgEkig/o1cuTIuKsPwseUKVPi6/fp08eJHQgkvXr1cirZU0895SrdeJ555hkXT4WgAgcccIB7Tcli32lIXIMo0q1bN/v3v/9te++9tz377LPxbRAq9Nxzz7l/8Tb55z//6cSbCy64oICtI4QQQgghQkdDjK8SKDPc4EViSVGTwmqpXxvkE8JxslkatK/q6hpFSuqKupgwYYKLuvBkEnVRzpSchwkQfpMqBOe1116r9d6+++7rllQceuihbkkF8V64IdUF8VwjRoyocz0hhBBCCCEKQai9MkosDCpsKDynhJO+WsQtma6bKeTX3Hnnna1z584u+TqOB9jXL774oqIuykkwEUIIIYQQQmRByMUFGfd5JtzdJ/eUaVlhPEOIkiBio1WrVi79BGLJ3//+d5cDhagLnxIDp4K9997bpaFIjLqgKg7eJi1atHDpNMIcdSHBRAghhBBCiBBQMaJCpZxngamY/lMWZYUzD7XJJiTnrrvuSvmZoi6SI8FECCGEEEKE2KgpEytwaS6PXGynkpCRnycqrB+VZEhOpklfdbHyigQTIYQQQggRUoukfKy+XCeRzHdSypKkfC53eaD2LBrRLHKYsK7IHxJMhAhw9NFqDiGEEKIkCHlOjnwS6kSwqai08y0AFSm6ZUj+q+Rk4WEiN6u8IsFECCGEEEKIMIo4ZXa4uUQ2ZI6o4D4Uxhwm5cxvv/1mX3/9tUUiEevatautuOKKBdmvBBMhhBBCCCFCioQDGf25y7Ej9eSv31V+20IeJn/x/fff26BBg1w1n2g05tuDaNKvXz+79dZbbbXVVrN8IsFECJGWMWNqv/fg0tCl229X4wkhhBA5I182mOzcgHikxlBfKpOkrxnuJMxJX6dNm2ZbbbWVK2d8ySWXWLdu3dz7EydOtJtuusn69OljH3zwgbVr1y5vxyDBRAghhBBCiEogvHZVhkTUBjlqxoon7yE5ymECF198sa200ko2fvx4W2aZZSzICSecYJtuuqlddNFFduONN1q+qIyAJyGEEEIIISqZpSEVlbyI3EBQhJbCCCaZLmHlueees/PPP7+WWALNmze3Cy+80EaMGJHXY5CHiRBCCCGEEJVCeG2rrAmxnZl/Kr3t5GFSEKZMmWI9e/ZM+Xn37t3t559/zusxSDARQgghhBCigpBQkEClG/8N8lqqTPL9G1oSjVgkw+o3rBtW2rRpY4sXL075+aJFi/KavwQkmAghhBBCCFFphNfGahAhtj3zQ6W2lzxMCsLGG29so0aNiid7TWTkyJHWq1evvB6DcpgIIYQQQgiRIdEwGYmch5aabaB2ya5PVHJ75RHlMIlxyimn2O23326///67JTJ79my788477aSTTrJ8Ig8TIYQQQgghSoUCizGVGlIhckSFhuXk+5xVJSfG1ltvbZ999pklo2XLlvb5559bvpFgIkSA/mOOVnsIIYQQorIIi8dMrqlQMaBeVFofUkhOQXnppZfsiy++cH8TntO3b1+LRArT6SSYCCGEEEIIUeEod0caKk0MqC+V1E55PtdoNOKWTNcNKz/99JPtvvvu9umnn1qnTp3ce5MnT7b111/fnnnmmfh7+UQ5TIQQQgghhCghosycFmj2tAbFzglRqovaJqN2ilbYkk+qLZLVElaOP/54F3rz/fff27fffuuWH374wb133HHHFeQY5GEihBBCCCHCi7MlwmtQ5Bw1VeUk/c0XldA+CskpCC+//LK9/vrr1rFjx/h7HTp0sOuvv97lNykE8jARQgghhBChJsQe63kVBrTUboOKEAMagtonpyE5mS6Zcuutt1rPnj2dhwbLFltsYS+88EL88z///NMGDRpkrVu3tuWWW8723ntvmzZtWo1tTJo0yXbddVdbdtllrW3btnbaaafZ4sWLLR9UVVXZokWLar3Pe3xWCCSYCCGEEEIIIeLEhQEtqUvJqm3SltotdrhM2YfkRCNZLZmy6qqr2mWXXWbvv/++vffee7b99tvbHnvsEa9Ec/LJJ9uzzz5rw4YNc54dv/zyi+21117x7y9ZssSJJQsXLrSxY8fafffdZ/fee68NGTIkL+2w8847OwEnWA2H5K/HHnus7bTTTlYIFJIjhKg3R6cpKnT77WpYIYQQoqyRt0Ba5LlUwX2nTJO+7rbbbjVeX3zxxc7r5O2333Ziyl133WUPPfSQE1LgnnvusXXXXdd9vvnmm9uoUaOceEHVmnbt2tkGG2xgF154oZ1xxhl23nnnWdOmTS2X3HDDDXbAAQdY9+7dbYUVVnDvzZo1y7bddlu78cYbrRBIMBFCCCGEECJb8p2UtZQMTpXXTds2IlXbREJbltklZs7n9rPwHPGCyezZs2u836xZM7ekAm8RPEnmzZvnQnPwOiHUhZK9nm7dulnnzp1t3LhxTjDh3x49ejixxNOvXz8bOHCg81LZcMMNLZe0adPG5TH54IMP4l4mCDgbb7yxFQoJJkIIIYQQQmRLpRjKiWJJpZx3tqhdKssDJ98eJk4IyXxdSCyxO3ToUOf1kciECROcQEK+EvKUDB8+3NZbbz376KOPnIeI9+TwtGvXzqZOner+5t+gWOI/95/li4022sgtQb7++mtba621LN9IMBFCZE3/MWlicczswW0UjyOEEEKEgbB6COReVAqzOiAKDaWC+S/TdWHy5MkukasnlXfJOuus48SR33//3R5//HEbMGCAy1dSDkybNs0eeeQRFzb07rvvWnV1dd73KcFECCGEEEIIUTcJSU8lEqRpHxHu9ijBHCa+8k1d4EXStWtX9zehLQgPlOndf//9XTJXcoQEvUymTZtmq6yyivubf8ePH19je76Kjl8n18ydO9eefPJJe/DBB+2VV16x1Vdf3Q488ED773//a4VAVXKEEEIIIYQQqQlUQCF3g1v8G6oWU7NCjNojob+EdLHyrJKTdF/V1bZgwQInnjRp0sTlDPFMnDjRlREmhAf4l5CeX3/9Nb7O6NGjnVBDWE+uIeErIT8klSV3yVtvvWVfffWVnX/++bb22mtbxQomN998s3Xp0sWaN29uvXv3rqViJUKyGhLSsD5JaEaMGFHjcxSpHXfc0dWTjkQizgUpyMyZM+3444937knLLLOMS2xzwgknODelIHw3ccElSAghhBBCiIrJA6Eyu5UpEtSn9G6YlzxC/pJslkw566yzbMyYMfbDDz844YPXr732mvXv399atWplhx9+uJ1yyin26quvuiSwhx12mBNJSPgK2NQIIwcffLB9/PHH9uKLL9rgwYNd6d90CWbrC3Y+wgh5Vq677jrbbLPNrNCUnGDy6KOPuotEkhqy4fbq1ctl3g2qWEGo/4xLDhf3ww8/tD333NMtn376aXwdMv9utdVWdvnllyfdBvWlWa666ir3PWpJjxw50m0zEUorTZkyJb6wLyGEEEKIUibbySgPE0NMEGm8U0QKYJxlTOJxJAoFEgtqClzFNuhLYQlzOxQgJCfTJVOwqQ855BDnKLDDDju4cBxEj7///e/u82uvvdb+7//+z/bee2/bZpttXJgNzgeeRo0a2XPPPef+RUj55z//6bZ3wQUX5KUdsL2plLP11ls74QSNAA+TQhKJRrPRpPIPD/FNN93UbrrppriLEBl/8QA588wza61PrBWCCBfOgwJGTejbbrutxrooacQ8IazweV1qFh2AbTduHEv1woABdashgwbKPaHe4b2SSYxZPqFt+dG0bdvWqqpKTjsryjmNWTd9MtNiEK2K2KJ12liTidMtUl1SP9e0SV9vv71y+l7Yzgd0TuVBOV+nUnoehh0moxjQMi5inMUsHeMcXK3pO6lg3MSE0xprrGErrbSSPfXUU1lf3+1sD2scaRIrwRupskgV//61RCJVZrXeiyx9b2mfdsaJ/7xq6TqB94LfZ+WE7fFWvARo4L3EdVwJ1FqfWa333JOY1+xn6QH+NZPu//bftdrb8V4jS7/v1wnOxtdYN/DTrrXt+Hs1txE/xoRZfhdGU+u9ZOsl+X6wlGrwveCFz7MRWVaoLUrXQyoHLFnwp31x69k5f4b5e+e6D59hjZbNzGNjyfwF9sWBl4f6eTp16lT3LHvggQecUwUVcw466CA7+eSTKyvpK0lmcP3BNcjDAJBa0NR8Tgbv45ESBI+UbB7qyfAdzoslHtyNjjjiCDd4OOaYY5ybknuwp4B4MBaPr4/NILcQWX3Twf7Ry4p9HKV0TogTpQbH5NwaS/DYUhGJ0L8rp++F7XxA51QelPN1KsdjLleuueYaO/LII92YBRBOnn/+ebv77ruTTkbBkiVLnIs2ceJvvPGGSwIokuAFlEoiMByJCyt1rFfJhFUwyJqwtUOez4e8JJEMO09Dc5iUA6ussoqdeOKJbsHDhCo5eE5WnGAyY8YM94BOVtv5yy+/TPqdVLWgG1IHmuO48MIL7aijjqrxPq5G22+/vS277LI2atQoO/bYY13WXvKdpOLSSy91g41Epk+f7mpfF3uwijDEYLvcZibzdU54cpQckYgt6dgyVlqstBzCUtKmza+WIooulH0vbOcDOqfyoJyv05w5c4p9CBVBfSaj/JgH7xPCkxFMRAkQKb9jqwA7LjPUDuFrg7yH5GQ+7C8T8yBnEJpz3nnnuaUQlJRgUgrgAbLrrru6ZDaJF+Hcc8+N/73hhhu6cJ0rr7wyrWDCACXoAcP2CTEiFqvYLlMMtPGO4VjKbaCdr3Mi7KUkPUwsao2/mlE2ITnT27a1NF7eoet7YTsf0DmVB+V8ncilIUpzMurNN9+0u+66q1aS/HSk8qgVISWShTgSNkO5PlR4G6T1RCpTogURTDLbSZgFk4ULF9rtt99uX3/9tfXp08dVzYHFixe7cU8hxj4lJZisvPLKLoGMr+WcrPZzIryfzfp1zXbttNNOtvzyy7tcJZRVSgdxwHiiMEBIlRWY95N9VqgLXBcMtEvlWErhnEpVkIhEY8dWqseXSDRK+1dW3wvb+YDOqTwo1+tUbsdbKTAWovrBnXfe6cZlmZLKo7a0CJnFVqpGsIST1O1VqeinlzXZJHPNJulruTFw4ECXdHaTTTax//znP/a///3Ppci4+OKLbfLkye69fFNSo5WmTZu6+s/B2s/MnvHa135OhPeD6/ta0KnWTwUzIZRJ4hieeeaZjGa+mHlZccUV81JCSQghhBCi0JNR3377rUv2uttuu7k8biz333+/GxvxN5+n8qglPMwvDGRLjlDYFCV0EtmIJQGiFboUvaKLlvKqkpNt/wopw4cPd8lese+p4EPVHNh9993tlVdeKcgxlJSHCRC+MmDAAKciUWeZTO6EvvhEZWR579ixo5vJABK/bLvttnb11Ve7UBrK37333nt2xx13xLc5c+ZMmzRpkisdDGSFBwYKLF4smT9/vsu8y2vvSoqbMwONZ5991g0uqMCDmMJFu+SSS+zUU08tQisJIYQQQmQ3GeWr/PnJqOOOO67W+t26dbMJEybUeG/w4MHO8+T66693YcXZeNSK3OEr3JQF6Y6zXM4hX1To+YfNCSL/ITnyMPFetFS5BexwnyKDym0NyVla1oIJZYJJiDpkyBDXCJT/HTlyZDz2FuEj6MZLLBNZcnmYn3322bbWWmu5Cjndu3ePr8OsiBdcwMc+UceZPCWUJnrnnXfce127dq1xPN9//7116dLFhef4TLwk12M9n3VeCCGEEKJUyWYyikmh4BgKVlhhBfdv4vtC1Dvha8iM50oWDrIiTOee73PJxnUkxC4mBx54oP33v/91ichJm/HHH3+498eOHWudO3euTMEEmPFINusBr732Wq339t13X7ek4tBDD3VLKrbbbjsngqSD3CYsQgghhBDlRLaTUSVFpEy8KsrhGPNIfRO+Vqx4oPMuf/IumGTuYRLmH1KrVq3shhtucFXd1lxzTZcE9vjjj7d7773X5TGpWMFECCGEEEIUbzIqCANTIeokS5stxDZeeir1vEPmCJHvc1FZ4RgvvPCCrbHGGi7ZKwuVakmTQS6TffbZxwqBBBMhhBBCCCFE3lB4TgKRcIkHFSkWKYdJQSB1RrGRYCKEEEIIIUS5UMpGZ33zlpTyOeULnXN5U4CQnIzdsCrWXavMBJPvvvvOucsIIYQQQgghRC3S2HXx0ruVQiWdawjt+vxXyYktma4bVg4LFG5Jhi8zXBaCCVVjKO97+OGHu3gisqwLIYQQQgghKoe6hI+KE0ZE6MSSgqAqOY7ff//dglDhbcKECTZ37lzbYYcdrBA0zmV8EQoPpetIKkZGdsQTytcJIYQQQgghckNZTCjXp3JOhRnVFScihOl8lcOkIDz55JO13lu8eLEdccQRtvbaa5eXYEKJuuuvv96uvvpqe+aZZ1xG9a222sqdyL/+9S87+OCDrU2bNrnanRD14+ij1XJCCCGEKG8i4S05LBEhxJRRvy2JcykLZbTwNG7c2M444wzr27evnX322XnfX1U+TmCvvfayYcOG2eWXX27ffPONnXrqqdapUyc75JBDbMqUKbnepRBCCCGEEMUlEiZrMDfUJX74vJbBJU6kQpYKOVd3fS1cSz6JRiNZLZVI8+bNbdGiReVXJee9996zu+++2x555BFr0aKFE0sIzfnpp5/s/PPPtz322MPGjx+f690KIcrImefWWwt5JEIIIcRSJGoUh8q05zKjEkoMh/H65/uclMMkLeuuu659++23Vghy5mFyzTXXWI8ePaxPnz72yy+/2P33328//vijXXTRRbb66qvb1ltv7cJ0SqGWshBCCCGEEGVN0EOhHEh3rCk8L5J5oIRxKbb3h5YGeAfl9QeT+4O59NJLbdNNN7Xll1/e2rZta3vuuadNnDixxjrbbbedRSKRGssxxxxTY51JkybZrrvuassuu6zbzmmnneZyi+QaqvCiJaRa4H//+1/875L2MLn11ltdrpJDDz3U2rdvn3QdGvOuu+7K1S6FEEIIIUILYc3MoG2zzTa2zDLLWDQadQNXIcqVaLaeFpXQ3SvhHEOYmyZaph4mr7/+ug0aNMiJJggc5ADZcccd7fPPP3fRIZ4jjzzSLrjggvhrhBHPkiVLnFiyyiqr2NixY13KDVJvNGnSxC655BLLJSeddFKd63DcJ598spW8YDJ69Gjr3LmzVVXVdFrh4T558mT3WdOmTW3AgAG52qUQQgghROhgtoxqg6+88ooTSL7++ms3y0aI84orrugS7AtRliV6/bFG0th8yc6nnM6xnoRNUKhF2M+vTASTkSNH1nhNBAhODe+//74T54MCCYJIMkaNGuUElpdeesnatWvnir9ceOGFLhHreeed52z+XHHCCSdklMskk/WKHpKz5ppr2owZM2q9P3PmzLy6yAiRLWPGpF6EEEKIYsNMGUn0cXkOzuohoiQOdkWFEwmZQCCxJJyUcT8tGlnHdZnNnj27xrJgwYI6d/P777+7f1daaaUa7z/44IO28sorW/fu3e2ss86y+fPnxz8bN26cS8WBWOLp16+f2+dnn31mueaTTz5x5YVJ91EMcuZhgidJMubOnetUHyGEEEIIUTfM3r344ou26qqr1nh/rbXWKtqAUWRG6L0ECkWkAttW51de5Pl6YVqnMK+TrgtUpQ0ydOhQ5/GRiurqahfysuWWWzphxHPQQQfZaqutZh06dHBiBZ4j5DlBtICpU6fWEEvAv+azXHL99dfbKaec4sJ98Lh89tlnXTnhG264wYUG5TMUJ2eCCScAnMCQIUNqxTe98847zk1HCCGEEELUzbx582qMp4Jeu82aNVMTioowOmsJJBIUypKwCl2lmMOENBgtW7aMv13X84JcJp9++qm9+eabNd4/6qij4n/36NHD5SfdYYcdXE4tokoKyZVXXmnXXnutC7mh+u5ll13mBJNevXrZ8ccfXx6CyYcffhj3MJkwYUKNmCX+5mQ4OSFE5dB/TJqawnBsxCyN4i2EEJUMlQWpNkhMuJ+UYibwiiuusL/97W/FPjxRipR5MuB4pZhEKkg0Cauw4AjjueVdMPkr1Cajdc2cWBIUTNJx3HHH2XPPPWdjxoyp5c2YSO/eveOJyBFMyG0yfvz4GutMmzbN/Zsq70l9mTVrlu22227u7/32288eeeQR9zcpP7777jsrBA0WTF599VX372GHHeZcZjK9SEIIIYQQojYII8zmvffee7Zw4UI7/fTTXVw4HiZvvfWWmkyEmzTCSRa5LcuLMAoKnkhIr1qez4vNZ7qLbA4FJwc8M4YPH26vvfZaRrlGP/roI/evr4S7xRZb2MUXX2y//vqrSxjrC8CgA6y33nqWS0hEiwcMx0meFfKkAGJJYt6Vks9hcs899+RqU0IIIYQQFQux5F999ZXddNNNtvzyy7t8cHvttZdzn/YDViEqSSxJW0EnLIRUWAit50y+z6s6ElsyXTdDeI489NBD9vTTT7vni8850qpVK1e+nrAbPt9ll12sdevWLocJYS8IFz179nTrUoYYYeTggw92Aj/bGDx4sNt2rsNG+/fvb2eeeabL39WxY0dXCvmJJ56wc889N+55UtKCCQ9vShGhJvF3OnySGCGEEEIIkR4Gr+ecc46aSVSkYZo0RKdGSeLwiQthun410HmVVFnhW2+91f273Xbb1XJ+OPTQQ11KDcoFX3fddS6fVqdOnWzvvfd2goinUaNGLpxn4MCBztukRYsWNmDAALvgggss1xxyyCHxBLYe9kt4zuWXX24lL5jwMCeu1v8thBBCCCEazp9//ulm9nB5Jn9JkN13311NXMqUeT6RksJ7l0SCcQphlEtCKiyE8ZyyTC9SaoJJqsq2HgSS119/vc7trLbaajZixAjLN7/99luN1wg6ha7A2zhXYTgKyRFCCCGEaDgjR450s2ozZsyo9RkTVVQhFA1AgkZ5EqmA8JyQnVPohK1CXp88CSblRssSyI+asxwmf/zxh1OsfBk84oxIJkN8E3FOQgghhBCibkjIt++++9qQIUOsXbt2ajJRsQZ3TaLhFkvCSCTE51OCVXLCyH333Zf2c0KBykYw2WOPPVwek2OOOcaV/9lss82cywyzI9dcc42LNRJCCCGEEOmhPOMpp5wisUSIZNTIZRIuQmf3hvl88nxu+aqSU26cfPLJNV4vWrTI5s+fb40bN3aOGoUQTKpytaEPPvjAtt56a/f3448/7mow42Vy//332w033JCr3QghhBBChJp99tnHlXsUot6EzVCtYxI+LIuFaakqgWPI4ZL0euW1c2e5hJSZM2fWWObMmeMq+ZC09tFHHy3IMeTMwwSlh9JEMGrUKOdtUlVVZZtvvrkTToQQQgghRN1QTpiQnDfeeMN69OhhTZo0qfH5CSecoGYUleOlUBdhOt8QnUtobPgQXZOw0KVLF7vssstcyeHPP/+8fASTrl272lNPPWX/+Mc/7MUXX4y7z5DdvRSStQghhBBClAMPP/ywm3yiEgCeJr4iIfC3BJMyQEaWyLK/hEZgCNNvIN055DskJ4tQmzA0dbbwLJw8ebIVgpwJJiQmO+igg5xQssMOO7iazMADf8MNN8zVboQQQgghQs0555xj559/vp155pnOW1eUKZEK33+hKXfRIWzXKxJuj638h+Qo6Ss8/fTTFoQiM1OmTHGemFtttZUVgqpcxttOmjTJ3nvvPVcOz4N4cu2112a1rZtvvtm52jCz0rt3bxs/fnza9YcNG2bdunVz6+O6mlgT+sknn3SVelq3bu3UqI8++qjWNv78808bNGiQW2e55Zazvffe2yVdC8L57brrri7BTNu2be20006zxYsXZ3VuQgghhBDpWLhwoe2///4SS4RVurGaDU4sKYFcF1rCkb/kr7wy0dRLvju0cpgYaT6CC5rDhRdeaBtttJHde++9VghyOm1Bole8SYKzIVTLQczIFJK3kBl+6NChLpFsr169rF+/fi60Jxljx461Aw880A4//HD78MMPbc8993TLp59+Gl9n3rx5ToG6/PLLU+4Xz5hnn33WiS+vv/66/fLLL+6ieJYsWeLEEgYx7JMSR1wkPGuEEEIIIXIFWf8LlcxOCFEChEjgckKDlf9SEFEkbUNKMPE2eHDBWQE7/b///W/BKsnlLCQHUYLkKy+//LITN6qrq2t8/t1332W0HUoQH3nkkXbYYYe517fddps9//zzdvfddzvX1ESuv/5622mnnZy3B6A4jR492rnp8F04+OCD3b8//PBD0n3+/vvvdtddd9lDDz1k22+/vXvvnnvusXXXXdfefvttl7iW0CKSyrz00kvu4mywwQZuX2eccYadd955roSyEEIIIURDYVB4xRVXuJxwPXv2rJX0lbFSZREJlUEpCkC59ZdyDycKW33bTPpPvnOYqKxwLebOnWt//PGHtWnTxgpJzgSTI444wnlmIE60b9++RoKyTMF74/3337ezzjor/h7eKn379rVx48Yl/Q7v45ESBI8UEtBmCvukpjP78eAV07lzZ7d9BBP+JdwnqGSxn4EDB9pnn32WMk/LggUL3OKZPXu2+xdBKVFUKjTsnziwYh9HQc8pErFomYWDR6siMbW+qtye/qmp5jqEqO9V5G+pDNE5lRZh6lu5ZsKECfFxRdBjFuozvhKVS8VVzCnncw+D2FBubd6AflOwssKZrhti7r//fueg4J0fOnTo4HJ9YYeXlWDywgsvOE+QLbfcst7bmDFjhptVSXSv4fWXX36Z9DtTp05Nuj7vZwrr4iGywgorpNxOqv34z1Jx6aWXusRtiUyfPt3lTSn2YBXvGoyisCSVq/Oc2rSxRetYeRGJ2JKOLS3iph/CcUf8tU3Efp81KzR9ryJ/S2WIzqm0mDNnTrEPoWR59dVXi30IIgdEw2JBljPlJEKEoauEwVMm0+sgwaQg3HnnnXbSSSfZv//9b5cbFV555RX3ulmzZvavf/2rfASTFVdc0VZaaaVcbS404C0T9IDBw6RTp07OlajY5ZYxHpip4ljCZBClPafp063JRCs/DxOLWuOvZlikuuwfQ4627SIWWWGF0PS9ivwtlSE6p9KCRO1ChN44DYMRLPJPCPpJ2Xn0JKOEzkEhOTEoHkPaj+OPP37pO2bbbrutG58SnlpWggn5PEiASjJUqsjUh5VXXtkaNWpUqzoNr0komwzez2b9VNsgHGjWrFk1vEyC2+HfxGo9fr/p9oXyxZIIBkgpGCEYRKVyLAU5p2jUImXoBe5umtXR0AgmVdHw9b2wnQ/onMqDcr1O5Xa8+YZE8ySTZzIlmHQ+GVT/EzmgUsKbKuQ0y70Nyl5wqLTjV1nhgkAe1J133rnW++QwPfXUUwtyDDkbrVx99dUuORlhKuT6oNRPcMkEwmI23nhjlzg2OCPI6y222CLpd3g/uD6Q9DXV+slgnyRUC25n4sSJroyw3w7/ElMcrNbDfhjYrLfeehnvSwghhBAikVatWsXzk/B3ukUIkT2+TGypLsUuo1vRS1U9rlm+f4SqkhN3qPA5QIMQNt66dWsrBDnzMKGUby4gfIVyeptssokrSXzddde5Cjy+as4hhxxiHTt2dLlB4MQTT3RuOQg2lP195JFH7L333rM77rgjvs2ZM2c68YMSRF4M8Z4hLAw+KEvMvgkrQgTB7QeRhISvsOOOOzphhKS2ZK4nb8ngwYNt0KBBST1IhBBCCCEyhep8F1xwgZsx428hcu+9UO4uADmgVJugVI+rAo4/Wt88N3nOj6OQnBj77LOPjR07tpYDxltvvWV77723lZVgMnTo0JxsZ//993cJUQnvQZSgfO/IkSPjCVYRPoJuvH369HHlgBEvzj77bFtrrbVchZzu3bvH13nmmWfiggsccMAB8WMm466Pj2K7NDxVbaiAc8stt8S/Q6jQc88957LxIqS0aNHCCTsMboQQQgghGgpJ4o855ph6hzYLkRqVZk5sjpKi1I4nC8izV87HX7LkqUoOTgeEdVJQZZlllnG29OWXX27rrPNXVQwKk5BUFUeEBQG7OFgABZscu5gk5cstt5yzi9l248Y5kxccOE8k44QTTrBCkdMzIgfI448/bt9++62ddtppzlvjgw8+cI2LV0imHHfccW5JxmuvvVbrvX333dctqTj00EPdUlfyuZtvvtktqVhttdVsxIgRabcjhBBCCFEfqEolQoiMydKi1K6HC+8o099+qbVlIc+hAFVyMnZiyaL7vP766y5CYtNNN7XFixc7hwMiKT7//HPnEAAnn3yyq347bNgwF4mBXU5uLbw6gKq2RHYQqYH3x5QpU1wUCCkuLrnkEssHL730ktMVEGd69erVoMq8RRNMPvnkE+vbt69rVGokH3nkkU4wQcFCgaJ+shBCCCGESI3PYyKEqJAkq+VU+jgZpdKOhT72Mi0rTORGEJKNt23b1t5//33bZpttXG6Qu+66y0VwbL/99m4dwkTXXXdde/vtt126ilGjRjmBBREDxwgiQigAc8YZZ7joDfKS5gpSc+yyyy42btw4J9CQYmP55Zd36Ttw1ChEXq+cJX0l/wdeHF9//XWNUoGc4JgxY3K1GyGEEEKI0LL22mu7Cad0ixChEApKAZ8oopiLO44yXaoq/NhDkPQVgQT8swXhZNGiRc4RwtOtWzfr3LmzEy2AfynyEgzRIWyH5KyfffaZ5ZJzzjnH5syZY998843zjiGMiCIseJoQNlRWHibvvvuu3X777bXeJxSHXCRCCCGEEKLuPCaqhCNEAYlU+P4r7Nhj2kLD867UO1lsHpO+JlaToTBJuuIkVKM96aSTXHiLz/+J3Y6HyAorrFBj3Xbt2sVtev4NiiX+c/9ZLnniiSfs7rvvdoINJYaB0B/ynSLSlJVgwsVIVvLnq6++sjZt2uRqN0KIEPDGG2Yv3Ww2fTox+zU/S6K7CiFExUBietyjhcgrZWjohpJyvQ7xsrplFk5Uru2dIZ06darxOljgJBnkMvn000/tzTfftFJl+vTpzvMyEarakpC2rAST3Xff3VWMeeyxx+IxuOQuIZapUCV/hBDlw7af3WxNJk63SHXCw/bopf9KORFCVBjKXyJEMX+AFbLPHJBv74qyaO8SzGEyefJkJyR40nmXkMiVCrCkzlh11VXj75MnZOHCha6YS9DLZNq0ae4zv8748eNrbI/P/We5hO39/PPPrvhKECJbSFxbCHKWw+Tqq6+2uXPnOm+SP/74w7bddlvr2rWrS8py8cUX52o3QgghhBChRFVyikCBkuxGlcy3PChwHg2Eh3JcKjZnSQFzmNQnFQ5iSXBJJpjwnEEsGT58uL3yyiu2+uqr1/h84403diEvL7/8cvy9iRMnOkeILbbYwr3m3wkTJrhcIp7Ro0e7fa633no5bQcS0Qar1FLyeK211nLJaq+55horKw8T4m1pKMoNffzxx0482WijjWokjBFCCCGEEKnjyYUoFEr+WmTviTL1Linb4y5H8tAVCcOhAs7TTz/tHBt8zhFseRKq8u/hhx/uCrqQCLZly5Z2/PHHO5GECjlAGWKEkYMPPtiuuOIKt43Bgwe7bafzaqkPl156adx7BY+XU0891dZcc03bZ599auVZKWnBhAc8Kg8lhCkpjEspahUuNKhYcjEVQgghhBCixJDxq3YPe1/JlwCWb2EtT2WFb731VvfvdtttV+N9SgdT8RauvfZaq6qqcmk1FixY4JKr3nLLLfF1GzVq5MJ5Bg4c6ISUFi1a2IABA1x6jlxDARkWQMBBQCk0DRZMEETIX4KrTK9evVyJId774osvXKMjojz11FO5OVohMuTYY2snE4X+qnAthBBCiGJQrgZnpZLv61WO/aEcc5fkq50LFJKT6bq5DP1s3ry53XzzzW5JBTlFgqEyYabBggmeJSSLIc7pb3/7W43PiIvac8897f7777dDDjmkobsSQgghhBBC5JpyNN7LvV0kPhSGMhVM8uVhIoqQ9PXhhx+2s88+u5ZYAttvv72deeaZ9uCDDzZ0N0IIIYQQQog8IHurDnKaLDRqVlWmiVPLhXI85hwkfRUlKph88sknttNOO6X8fOedd3ZJYIUQQgghhBAlShkbl/lvl2julnJs52ILNfURpQqx5JNsu1YF82ugWk9JCiYzZ860du3apfycz3777beG7kYIIYQQQgiRT8rRmC8UufTSiJTR4rxhymgppPdOPpFgUmfRGRLP/uMf/7BVV13VSjqHyZIlS6xx49SbIYvu4sWLG7obIYQQQgghyptIxU8Glze5MJLLKX6i3AS0SHj2la+kr+XON998Y3fffbfdd999zrNkhx12sAceeKD0q+RQDSdVzWVKEQkhhBBCiOJBtYMrr7zSpk6d6qoa3njjjbbZZpulXH/WrFl2zjnnuGqHeBNTEeG6666zXXbZxcJJuVmG+cPZXmqO/Fmo5dS25XSsBY9LKc+ywuXIH3/8YcOGDbO77rrL3njjDVtjjTVcSWM0iHx7l+REMKHmcl2oQo4QQgghRHF49NFH7ZRTTrHbbrvNevfu7YSPfv362cSJE61t27a11l+4cKH9/e9/d589/vjj1rFjR/vxxx9thRVWsFBab5Gysgrzj5qjjvapELGknCzxYrRroUJyMl03pBxzzDH2yCOPuIiVvffe284//3zbbrvtCnoMDRZM7rnnntwciRBCCCGEyDnXXHONHXnkkXbYYYe51wgnzz//vHNrppphIryPV8nYsWOtSZMm7r0uXboU+cpEJGwUoclFDtunrNqzfJLTFkvvzPd+FZIT484773Ri/X/+8x8nmESKcMEbnPRVCCGEEEKUJniLvP/++9a3b9/4e1VVVe71uHHjkn7nmWeesS222MIGDRrkkvd3797dLrnkEpe3TlQW0TIxmotGKVZuaeASYamKCQIlvxQ7IW0+UdJXB6E4m2++uR144IFOuB88eLB9++23VkgkmAghhBBChJQZM2Y4oSOxoiGvyWeSjO+++86F4vC9ESNG2LnnnmtXX321XXTRRSn3Q8662bNn11hECpzxXEZKRBkdalHIVIQotriQ4VJO4k7RKwgVt1sVTLspJnvttZfziPzhhx/s6KOPduE5a6+9tgvLuffee23+/PmlH5IjRElx7LFmbdrYgW9Mt0h1iO8eQgghRB7LNZK/5I477nDVDjfeeGP7+eefXdLYoUOHJv3OpZde6mLLRSZgmZZhS5XjMZdK85RL25WL5V0u7dkQlMOkBuTSOvvss93y2muvudBRvCBPOOEE23fffV1C2HwhDxMhhBBCiJCy8sorO9Fj2rRpNd7n9SqrrJL0O+3bt3czeHzPs+666zqPFEJ8knHWWWfZ77//Hl8mT56c4zMRxS+HXAlWav1wLROCcJyie2xkuMS8YaLFXQpVJSfTJcRQlZe8Wh68S+6//36bMmWKXXHFFfbxxx/ndf8STIQQQgghQkrTpk2dh8jLL79cw4OE1+QpScaWW25p33zzjVvP89VXXzkhhe0lo1mzZtayZcsaiwgh0kzqaJ8kIoTLs1EGIkRVkQWITJd43pLit1m+f2olcihF5ZVXXnEej4j/3bp1c88moOQ9ebioovPee+/l9RgkmAghhBBChBhKClNp4L777rMvvvjCBg4caPPmzYtXzTnkkEOch4iHz5nNO/HEE51QQvw4SV9xfxa5TahalklVy/GYC0ktb4hyESHKQdQpsXwv+exG1dktYeWEE06wXXbZxd544w1bffXVbciQIfHk5enyauUS5TARQgghhAgx+++/v02fPt0NNAmr2WCDDWzkyJHxRLCTJk1yg09Pp06d7MUXX7STTz7Zevbs6WLHEU/OOOOMIp6FKCXKUugpIJEyywdS8pfTHWCptWeBQnJK4FCKCUnIn376aVtzzTXt9NNPtyOOOMK936tXL/v0008LcgwSTIQQQgghQs5xxx3nlmSQQC8RwnXefvttq6wcHaI+7SaStctSj40Sp2yEnRIUdQpS6KoMLk2+WWeddezHH390gkmHDh1c5TeYM2dOjTxb+USCiRBCCCGEqGhidkmpmWQljpqr7iYqEzGilClZUSfPx5RNueBSbJ5cccMNN9ipp57qStu3bt3a5dZCNMFjMlUerlyjHCZCCCGEEEKIeqHwnABLc5bUoFTzgfj8KlbCS7wijZXkUq5VcsaMGWO77bab89iIRCL21FNP1fj80EMPde8Hl5122qnGOuS56t+/v0vwvcIKK9jhhx9uc+fOtVxDRRySum6zzTa2/vrr2/z5810S2O+//96uv/56q2jB5Oabb7YuXbpY8+bNrXfv3jZ+/Pi06w8bNsxlzmX9Hj162IgRI2qVI0KJIsP7MsssY3379rWvv/66hjtqYsfwy7vvvuvW+eGHH5J+XlEuq0LkmTFjYsvRR9dehBBCiFBREMurAITlPOrtAZF+mj9Saks84auV7rK0ao+V6OIS5eazX2V5SNlA0m9ygGBvpwKBhLK9U5YuDz/8cI3PEUs+++wzGz16tD333HNOhDnqqKMs1wwfPtwt/9/encDLVPd/AP/Ovde+y762CdkjHkskIjxRSZInVJY8iPyj9NhVCmmjaKE8EWnR5hEpqceWLY+KkCI7hSjbvef/+vzmnnFm7sy9M/fOmfmdM5/363Vcc+bMzDlzZjnnO9/f97to0SI1oQg5apeglfDll18uCTskZ8GCBaqi+4wZM1Sw5Nlnn5W2bdvK9u3bVUQp0KpVq6Rbt24yceJE+fvf/y7z5s2TW265RTZu3Cg1a9ZUy6BHM1J6UCEeFXZHjRql7vP7779XQZYmTZqoF4MVlkHbvQYNGvjN/+yzz1SEy4T0ICIiIiKiyLkn0mC4a3MyZwZJwt1ejcZNxKT+RrZ5Azk6QyAn1ePcoq/t2rVTU2bQKr5MmTJBr0O3NRQOR1KBeZ78wgsvqG42U6ZMUZkr0dKxY0eJNy0DJlOnTpU+ffr42t0hcIJo0qxZs+SRRx7JsDzScRAFGzZsmLo8YcIEFe2aNm2aui2ySxB0GTlypHTq1EktM2fOHFUdHpGqO++8U3Lnzu33ojh//ryqyDto0CCVRWKFAEmoFxAREREREblYNk/o9QgE6B+Q0DXohmFC6f+xfR3jXcMEoy+QqFCsWDG54YYbVAtfM0lg9erVahiONakAozfQbW3t2rVy6623Rm09UPA1XJUrV5aECJicO3dONmzYICNGjPDNw5OPnYCdEwzmIyPFCtkj5ngsjHFCGz3ch6lIkSIqewW3RcAk0IcffijHjh3zBW0CI11nzpyRq666SrU3yizydfbsWTWZTp48qf6iYA2meMLjI5gU7/WIpjSP96PMSNL0kzYbsC0YH5xo2+QJ0lRe15eqK99L3CZHcPJ+cuI6E1GY8B1vfsU7/vDFkkUSle438emg43FEJxx9snCy6tQTsxom4S5rOc+0ZolgihQSEW677TY1KmPXrl3y6KOPqowUnDejMw3OqwNHfaSkpEjx4sXVddGEYTc4zskMkhvsPBbSLmCCqrepqakq+8MKl7dt2xb0NtgxwZY3d5j5N7NlAr322msq6FKhQgXfvIIFC6oKvU2bNlVBnHfffVcN/UFgJlTQBMOExo0bl2H+kSNHVNAlnvCiOnHihHqBYXvcIK1kSTlRuLBcuArf1Bp/6EbC45HU8oXFI4m1TSVLHs4w73DGWVpw5XuJ2+QITt5PaAlIRC4vnOrUoInHxm2IV4tczQMSume9BBbztb0DUjYCJhUrVvSbPWbMGBk7dmzED21NJqhVq5bUrl1btfVF1kmrVq0kljZt2iTxpl3ARAe//vqrfPrpp/L222/7zS9RooRfJsu1114r+/fvl8mTJ4cMmCBTxnobRP7wYi5ZsqSqKhzvA21E5LAuTjvQDiXtyBHxGIYc+vGoeNL0/VKIOBtDDElJsG06EqReUZBZWnDle4nb5AhO3k+oH0ZEicFX20Tzk+IMARIbT4pj2XLYacEIJ6ybR8MhOXv37vU7v8xOdkmoLI8SJUrIzp07VcAEpSkOB/yKeeHCBdU5J9plKxCsiTftAibYGUj1OXTokN98XA61AzA/s+XNv5iHLjnWZerWrZvh/mbPnq3GaIVTZAbDelAvJZRQqVA4sNXh4BYH2rqsS1QY6a3H0gzXBBd8H5oJtk2GkfE1qfPL1HXvJW6TYzj1tee09aUE4JQTehfQLqMmfd8bMT5xj1kgI701r5bilXGTw1ovtu+7bGSYIFhixw/yv/76qypVYZ5HN27cWI4fP67KaNSvX1/N+/zzz9WPODg3jrbff/9d1UbBCA3rsBtk16IFcsIFTFB8FU88utNguAvgicHlgQMHBr0NdhquHzJkiG8eghiYDxh/haAJljEDJMj0wBPfv39/v/vCE4+ASY8ePSRXrlxZru/mzZv9gjBERERERBHT86wxRpkcMd5+a/ZI3J93e2uaxH3zMg04GA5eN7vbChtqCnfZSJw6dUpli5hQ7xPntKhBggnlJDp37qzOn3ft2qVqdl555ZWqXAVUr15d1TlBkxY0WEGzFJynYyhPNDvkmHVF//GPf8iff/4phQoV8mvGkrABE8AQlp49e6rKuw0bNlQdbtAv2izAimBG+fLlVX0QGDx4sLRo0ULVF+nQoYPMnz9f1q9fLy+//LK6Hk8sgimo7lulShVfW2HsUDMoY0J0DC+a3r17Z1gvtCRGQKdevXrq8nvvvac697z66qsxeFaIiIiIiFwEWR1ZZZ94slFzJFR1TjOTxNrtxOUZFroOd9F3mFB4XYR0zDAJF86TW7Zs6btslo/A+fdLL70kW7ZsUee9yCIpV66ctGnTRnWhtY6amDt3rgqSYIgOMkYRYHn++ecl2tAF995771Xn/fny5ZN40DJg0rVrV5VyM3r0aFWUFVkh6PVsFm3ds2ePXypvkyZNZN68eaptMKr4IiiCQqw1a9b0LYPIGIIuffv2VTu/WbNm6j4Dx1Cj2Cvur1q1akHXDS8WtDdCJWAss2DBArn99tttey6IElX3lf0yzrTOmjkzlqtDRERENvPrrOPXacfw/t8TXo0U7+WLmRuZ3VYXdgQ2dA1KqOKzHmfvB7sDUXa2Fb7++usz7TyDWp5ZKV68uDr/ttu+ffvkgQceiFuwRNuACSBiFWoIDir0BurSpYuaQkGWyfjx49WUmcx2PKJumIiIiIiIok7Tk0itBAZBXPScRTPAoW9miabrZfPyOmWYOEmrVq1kzZo1qvBsvGgbMCEiIiIiynBG6aITZCI7si+0fItoWng2uwEcJ2eYOEnHjh3VSJHvvvtOlcUIrDHaqVMn29eBARNyrH5BRmzc9bXI+aoiWZfrJSIiIsfR8YyLyIbXuMdFQQldi7zmJKPHyTVMnKRv377q75NPPpnhOgwrsnbNsQsDJkREREREPvE95XTxuQ9F8grMRtpAkoZBCX3rqYRX3DUUZpjERmpqqsQbAyZERERERKZ4n9jpd2ZJcQ2cRLK8fsESHWuWRCPbxfbnmhkm2rjYaoaIiIiIiIj04MHJmhHWlOxJU8EJnaakJEPLdUrCXzy3OZxs3/1GeJPbLV26VHW4zZ8/v5QqVUpuvPFG+eqrr2L2+AyYEBERERERaSq8wIRoNFmDJaLNlJweLIlW8MVWaPsbyeRSy5Ytk5tvvlmqV6+uut2ePn1aWrdureZ98MEHMVkHDskhIiIiItIJR+VQkNdExpdFepFXzV4vGK6i48iyaA6jsXtIDrvkeCFI8q9//UtGjx4tP/30k4wbN04efvhhKV++vLouFl1ymGFCRERERESkMY8vQJI+pQ8rUdkOosmk1il9vUSHybpOUc52sXuHGxFOLrVp0ya5/fbbM8y/7rrr5Pvvv4/JOjDDhIiIiIhIQ4aGv9JT/KgggNl2WMPiFd7gjT5UFohNK2R7l5w07xTusm6VK1cuSUrKmOOxc+dOlWUSCwyYEJFjrFx58f9z+/lfN3NmzFeHiIjI3mCJTmefpI3kJP3OkHUL4Ng9LCjN9homEWSO6PXUR1W1atXk22+/VX/NNsNz585VQ3R69uwpscAhOURERERERLpLH4Lj/W/8O874is5qNCzI2zEoNsOCdOiQ4/ZOOb1795atW7f6Lp87d06GDx8uvXr1kpEjR8ZkHZhhQkRERERkpVvFSs1Wh+IhYLhLLOpoZCm9LojoILaFZmPWJSfcZV3qvvvu8/3/8ssvl1OnTknevHljug4MmBARERER6UqPs1HSpOhrhvlxSC/waDgUJ9adeZBVYyd2yQku1sESYMCEiIiIiIhIUyoQ4Ilfi9vAddEnhufdbgy/ibWYdckJd1myDQMmREREREQaM3QbIkQxE24GR6yCBnZnVkQqXhkutnfJiaA2iWa7xHUYMCEiIiIiItKFr2ipoc1JvLelsT5n5vFeH9sDR6xhog12ySEiIiIiItK8XklYt03vWhP9KU2rrjxqfeLckcepXXJWrlwpN998s5QrV048Ho8sWrTI73rDMFTb3rJly0q+fPmkdevWsmPHDr9lfvvtN+nevbsULlxYihYtqoqzoiCrGzFgQkREREREpIGcjqy52PY2Sm16rUET0WTy6DHFpIZJuFMETp8+LXXq1JHp06cHvX7SpEny/PPPy4wZM2Tt2rVSoEABadu2rZw5c8a3DIIl3333nSxbtkw+/vhjFYTp27evuBGH5JCz9Ovn+2/3lRmvNuJR9YmIiIjcx5OhkWv8abY6FF3RG2ISnY4x8R72om/9FEOSHVzDpF27dmoKBtklzz77rIwcOVI6deqk5s2ZM0dKly6tMlHuvPNO+eGHH2TJkiXyzTffSIMGDdQyL7zwgrRv316mTJmiMlfchBkmREREREREcWRHXd+cZlAke9K0yShJ1mAIjjfjJk0FS2wPJKUZkU1Rsnv3bjl48KAahmMqUqSINGrUSFavXq0u4y+G4ZjBEsDySUlJKiPFbZhhQkRERESOgTH3iUqdFiXu5ruS3Vkc2am14W0drEc2h6pbomF2i+0fQ9loK3zy5Em/2Xny5FFTJBAsAWSUWJUuXdp3Hf6WKlXK7/qUlBQpXry4bxk3YcCEiIiIiMhJdDiDpBxRJ9wxGmISyVAW9dLSJEihgjYqeBP/9QhcB2S+2PuYEQzJSf9bsWJFv/ljxoyRsWPHRn/lEgwDJkTkSN1XXqxnAyur+18/t/lM9Xem9w8RERFR3HkDEpb/x/RxjbAKxma3Q09UWAIkOmS5hMq28WjYVnjv3r2qa40p0uwSKFOmjPp76NAh1SXHhMt169b1LXP48GGxunDhguqcY97eTVjDhIiIiIiIKEbiEghIzxpJCjlZ65dInCazZklaXNsYX6zhknk7Zd3aCiNYYp2yEzC57LLLVNBj+fLlvnknT55UtUkaN26sLuPv8ePHZcOGDb5lPv/8c0lLS1O1TtyGGSZERERERA5jxHucAmWDoW29FB060KihLxq8rr3DbTJ/PuwekpOdGibhOnXqlOzcudOv0OvmzZtVDZJKlSrJkCFD5LHHHpMqVaqoAMqoUaNU55tbbrlFLV+9enW56aabpE+fPqr18Pnz52XgwIGqg47bOuQAAyZERERERJmPUSDKPpWREINCoWHyD44gqyP+9Cju6s0sCYfdASaPYagp3GUjsX79emnZsqXv8tChQ9Xfnj17yuuvvy7Dhw+X06dPS9++fVUmSbNmzVQb4bx58/puM3fuXBUkadWqleqO07lzZ3n++efFjRgwISIiIiJyJA0qYpIjY27ebA5Di/XTJVgSSXcg2zNy0tKncJeNwPXXXy9GJkEWdCIbP368mkJBNsq8efMkEegQUAxq+vTpcumll6pIFsZCrVu3LtPlFy5cKNWqVVPL16pVSxYvXux3PV4Uo0ePVsVr8uXLp3pF79ixw28ZPB5eINbpySef9Ftmy5Ytct1116nHQSXiSZMmRXGriYiIiIjClH6WyeE5+rkYAIj/UJdgVK2O9IyK+NUK8dYqwXp44jT51iH9+TADSOFMscgwCXeiBAuYLFiwQKUGoRXSxo0bpU6dOtK2bdsM1XhNq1atkm7dusl9990nmzZtUuOrMG3dutW3DAIbSBPCOCsUrSlQoIC6zzNnzvjdFyJpBw4c8E2DBg3yK3jTpk0bqVy5sipyM3nyZNWq6eWXX7bx2SAiIiIiCo6nShoye8LGP20ihPTAQHpGRcyDFIKCqmmqqKq3sGp8p+yuh63SjMgmSqyAydSpU1URmXvuuUeuvvpqFeTInz+/zJo1K+jyzz33nCo8M2zYMFWEZsKECXLNNdfItGnTfNklzz77rIwcOVI6deoktWvXljlz5sj+/ftl0aJFfvdVqFAhVRnYnBBYsY7VOnfunFqPGjVqqMI2DzzwgFpfIiIiIiJKcA4YJYUTQOs6xj5AkRbXzBaPdT1yEPjRrUsOJUgNEwQkkL0xYsQI3zwUksEQmtWrVwe9DeabxWpMyB4xgyGo/Hvw4EF1H6YiRYqooT64LQIfJgzBQcAFFYLvuusuefDBByUlxfs0YdnmzZtL7ty5/R7nqaeekt9//12KFSuWYd3Onj2rJmuWCqDtEqZ4wuMjmBTv9YiIpVqWESTcZyR5VFoq/roFtyl7PB7v6zoWL29HvpeywG1yBifvJyeuM5HW3HPo41h2t5rNudCZEbHqkmN7d5msHj9K22n784VhNuEOteGQnMQKmBw9elRSU1OldOnSfvNxedu2bUFvg2BIsOUx37zenBdqGUC2CDJTUMQGw3wQtMGwHDODBMuitVLgfZjXBQuYTJw4UcaNG5dh/pEjRzIMB4rHweqJEyfUwTaCUo5QsqTvv+erBrne45HU8oXFg6MGt3x4cJuy5fbDY9Tf9D8ZDRggCf1eygK3yRmcvJ/++OOPeK8CUfh0aW+SBdYyiROth994mUNw4hnMiHfr4mg+vu1dctK8U7jLUgIFTOLJmqWCYTvIJOnXr58KeuTJkydb94mgi/V+kWGCYrElS5aUwoULS7wPtFHYFuvimAPtI0d8/821PUQ2hhiS8uNR8bhkPB+3KWdKlYr0igR5L2WB2+QMTt5P1vaEREROpHmMxCeSQqXRzpK5+LjxCyp51yG6nXjsHpLDDBN9aBcwKVGihCQnJ8uhQ4f85uMyaooEg/mZLW/+xTx0ybEuU7du3ZDrgiE7Fy5ckJ9//lmqVq0a8nGsjxEIgZZgwRYc2OpwcIsDbV3WJSyWrJFQ0VQV5E8zXBMwAW5T9iWFehlE+TXvuPdSGLhNzuDU/eS09SUi8pceANB8GI7Ht45GxAGGnD94/IfgeGwLBNkdMIlgl+n9EnQ87Y5WkNVRv359Wb58ud8vaLjcuHHjoLfBfOvysGzZMt/yGEaDgIZ1GWR6oFtOqPuEzZs3qwO6Uum/RGPZlStXyvnz5/0eB8GUYMNxiIiIiIhiyilpD07nkOc5O5kV6jZRKO6aYrbrjVv3mzTfpFooR3myE9sK60O7DBPAEJaePXtKgwYNpGHDhqrDzenTp1XXHOjRo4eUL19eDZWBwYMHS4sWLeTpp5+WDh06yPz582X9+vW+dr/49W3IkCHy2GOPSZUqVVQAZdSoUVKuXDnVftgs6IoASsuWLVWnHFxGwdd//OMfvmAIisCiHgnaFz/88MOqbTE69DzzzDNxe66IiIiIiPyglBufkujzjS/R/9nFaubkpF7dPgdZGfHOLLG7xgiLviYOLQMmXbt2VUVRR48erYqpYtjMkiVLfAVW9+zZ45fK26RJE5k3b55qG/zoo4+qoAg65NSsWdO3zPDhw1XQpW/fvnL8+HFp1qyZuk9zDDWGzSDQMnbsWNXVBkEVBEys9UfQWWfp0qUyYMAAlQWD4UNYR9wn2aNfP//L3VfymabIrAzxmpnbT2TmTD6bRETkrsKvfhy4ytrSfOhN4Es1WkNQIh16oh47yvVCwofMEv/Ldkmyu9IqVj3ch3DOS9ORtAyYwMCBA9UUzIoVKzLM69Kli5pCQZbJ+PHj1RQMuuOsWbMmy/VCMdivvvoqy+WIiIiIyEZODGCQMyX4Sy2cbAozsOKJ0/NlBmk8LqlrYQ7JCXdZSqAaJkREREQUXdOnT5dLL71UZdaiqP26desyXR7DoVGjLV++fKq7H7Juz5w5o89uYbAkgufKxv3gVg59zi52g4n+CbQns3oeql6Id1L1QyQOU/pje2I42V/01QhzsndVEp22GSZERERElHMLFixQQ4xnzJihgiUIhrRt21a2b9/uK2xvhWHOjzzyiMyaNUsNe/7xxx+lV69eKlt36tSp3CUOE6/BEe5oUSiO4rFxnVUwJkiQIKe1TqIhHvVSbM86MIMh4S5LtmHAhIiIiMjFEOTo06ePr3g+AieffPKJCoggMBJo1apV0rRpU1XsHpCZ0q1bN1UcnxzKYSf+ceXA5woJV7EKWiCLRI/irt6MknixvYZJWgSvRZtXJdFxSA4RERGRS507d042bNggrVu39s1D4XxcRkfAYJBVgtuYw3Z++uknWbx4sbRv3z5m6002dc5xYDAgds+N8zJKIJZ1Oy4+prdlr7dtcOwn9dhJ8WlZbG43/saihkm4E9mHGSZERERELnX06FFJTU31dRo04fK2bduC3gaZJbgdOgoahiEXLlyQ+++/X3UiDAUdBjGZTp48KW7kioCDG7Yhyni6GRmzTokdtVLCK10Un4Fmqj5M+gOzrXDiYIYJEREREfl1I3ziiSfkxRdflI0bN8p7772nhvBMmDAh5LM0ceJEKVKkiG9CoVjSWKIHTTyB6RlODZkY8S0um96+OBaTN8PDzDKJXWHXDFkmlkKztgq74GsEtU4oWxgwISIiInKpEiVKSHJyshw6dMhvPi6XKVMm6G1GjRold999t/Tu3Vtq1aolt956qwqgICiSlhY8DX3EiBFy4sQJ37R3715btoeiwwgMGiQQwzzRdcF2mwGLmD2er2aJ+Zix6YDj7cCTFp/uO2JIiidVTWodLJMTAyZjx45VBbytU7Vq1XzXoxvagAED5JJLLpGCBQtK586dM3x/JBoGTIiIiIhcKnfu3FK/fn1Zvny5bx6CHrjcuHHjoLf5888/VZ0TKwRdAEN0gsmTJ48ULlzYbyKH1O6QBBKPgh9u2ZRMCsvaXTPEG6iIba0SBEhypQdKQgVSbJUW4RSBGjVqyIEDB3zT119/7bsOLeQ/+ugjWbhwoXz55Zeyf/9+ue222ySRsYYJ6aVfP7+L3VfGbU2IiIhcAS2Fe/bsKQ0aNJCGDRuqtsKnT5/2dc3p0aOHlC9fXmWQwM0336w669SrV0+1Id65c6fKOsF8M3BCLuOSIELIujMuCpSAN6sklpklWQcIol3TI8kSBYj1rgtnW+yuYRJJMddIi76mpKQEzTBEduBrr72mWsvfcMMNat7s2bOlevXqsmbNGvnb3/4miYgBEyIiIiIX69q1qxw5ckRGjx4tBw8elLp168qSJUt8hWD37Nnjl1EycuRIlaaNv/v27ZOSJUuqYMnjjz8ex63QyMXKk+7ipi46Zscbt2yPKcZDcCKl6prk+F6Q4eH9G4+6LOb/sxKzGibhLhuk2DYy/zAF2rFjh5QrV07y5s2rMg0RLK9UqZLqjnb+/Hm/rmrVqlVT16GrGgMmRERERORKAwcOVFOoIq+Bvz6OGTNGTRSC207EXbR91qCPvqEFB7UQRpAm3GUDOslEzhtwiXn3nfSsnUhW2/YuOWkI+hnhLyuSodg2PsNRs8QKWYOvv/66VK1aVQ3HGTdunFx33XWydetWFVDHMM6iRYv63aZ06dLqukTFDBMiSlgBI8D8zJwZyzUhIiLShIODJY5e90x5W/jGq5VuJA/sDbBkr+WwGbiINf9CtuHxRFo4JAYZJii2ba0fFSy7pF27dr7/165dWwVQKleuLG+//bbky5cvGmvuOgyYEFFC6r4yk2gJ4GpGTYiIKEH5an84oWitE9Y1x91wJC6BBE92a55EEPiwfXhLUN7uO9lle4YJnpOwa5N4l8tOwW1kk1x11VWqVtWNN94o586dk+PHj/tlmRzKpKtaImCXHCIiIiIiCs7jEcMcl+HRI0DiiGCOk0vmZNIRJxLhtuy1tuqNxYSuO7mi0KbYiW2FA506dUp27dolZcuWVR3VcuXK5ddVbfv27arOVaiuaomAGSZERERE5OCzyfidObutRkY422gNVthZJNZ33x4joQIk8eyGox4zyhkfwWqDZHfITk5Zg0A5fXwEXmyl6pJEVsMkHA899JAq4o1hOGgZjDon6H7WrVs3KVKkiNx3332qs1rx4sVVtsqgQYNUsCRRC74CAyZERERE5DzxGqeQTmVdJLKAzc/20JjA24T6PzmSrxCs5eTf/uEswdYjunVgbB+mYaR5p3CXDdOvv/6qgiPHjh1THdCaNWumWgbj//DMM8+ormmdO3eWs2fPStu2beXFF1+URMaACRERERERZY8Z8LB2p/FE3sXGL4skkQMlyMiIYyzQjswPX7DCE796JdEO0thenDYbRV/DMX/+/EyvR6vh6dOnq4m8GDAhIiIiIqLoSg+AWDNPLg6zSfCgSCY8cRzspYIKNu0XBEtQr8QJRWvDkWz3PrJpSA5FjgETIiIiIiKiOItHS12T3Zkf5v3HKsPE2wHHvseyvYaJTRkmFDkGTIiIiIiIsouZEhQF8SiC6n1ce4MYwVoMq8ez4X1jrZVi99vS/i45EQRCGC+xFQMmRESh9OuX+XMzcyafOyKiRMZgCeX0JWTWK4lXzRIbh+Go+w92Nu+rZRLFbjxmwCRGz6PthWuZYaINBkyIiIiIiIjiIn7pAdHsGhM5IypZGp5M2hfbySN2txXG/adFsCzZhQETIiIiIiKiWHN5hlI4dT5ymqmRbHfgIhhVwJY1TBIFAyZERERERNkVr/6v5GixzoiI9eNHkj2SraBHHFoUJ0ma7zm7YHeghkNytMGACRERERERUSyYNUsSOFiTk3XyH0Zkf8BE1UZJz4LxxLKGCdsKa4MBEyIiIiIiIhd3w/HydpGxN1iSvfv3FW3NdBkUdY3d83dxnYyg2SZ2Mow0NYW7LNknSTQ1ffp0ufTSSyVv3rzSqFEjWbduXabLL1y4UKpVq6aWr1WrlixevNjvesMwZPTo0VK2bFnJly+ftG7dWnbs2OG7/ueff5b77rtPLrvsMnX9FVdcIWPGjJFz5875LePxeDJMa9asseEZSKxGJOa0cqX/RERERETkfHHu/ZoeibA3u8Ub8MhuUMMMUCB74+KU5puS8Te9WKydU7JvSn9Mv/W5ONk+JCctzCnc9sPkngyTBQsWyNChQ2XGjBkqWPLss89K27ZtZfv27VKqVKkMy69atUq6desmEydOlL///e8yb948ueWWW2Tjxo1Ss2ZNtcykSZPk+eeflzfeeEMFRUaNGqXu8/vvv1dBlm3btklaWprMnDlTrrzyStm6dav06dNHTp8+LVOmTPF7vM8++0xq1Kjhu3zJJZfE4FkholjKLGDXvHks14SIiIicLp6tg9Xj5yCQEa4kDDfKYWAIz5M1eyNUhoedksN4nmyvn6KCIGE+BgMmiZdhMnXqVBWsuOeee+Tqq69WgZP8+fPLrFmzgi7/3HPPyU033STDhg2T6tWry4QJE+Saa66RadOm+bJLEHQZOXKkdOrUSWrXri1z5syR/fv3y6JFi9QyuP3s2bOlTZs2cvnll0vHjh3loYcekvfeey/D4yFAUqZMGd+UK1cum58RIiIiItLyTFStg4ihW1EI0kcMh5HEizfIEb3tREAixZOqutEggBGrKZcnVW1LVpPtQRy0Co5kosQJmGAIzIYNG9SQGVNSUpK6vHr16qC3wXzr8oDsEXP53bt3y8GDB/2WKVKkiMpeCXWfcOLECSlevHiG+QimINOlWbNm8uGHH2ZrO4mIiIiIyOU0CKTFI0sjp9QwHDVEJs32yRuY8U5hB1dikWESyUSJMyTn6NGjkpqaKqVLl/abj8sYNhMMgiHBlsd883pzXqhlAu3cuVNeeOEFv+E4BQsWlKefflqaNm2qgjjvvvuuGvqDLBUEUYI5e/asmkwnT55UfzH8B1M84fGRfRPv9bCOpTSQy5cDuD1+4cnp/eiE26SfNPPllf7e0eW9FE3cJmdw8n5y4joTEUVCg9wn7zAcm1ciusGYi4VpvUVe7SuUa96v+ViRsL3oK77fPSz6qgPtAiY62Ldvnxqi06VLFzU0yFSiRAlVW8V07bXXqmE9kydPDhkwQV2VcePGZZh/5MgROXPmjMT7YBVZNDjYRgAoXkqWvPj/81UtF7LD45HU8oXFo3JjXRJt5TZp57D5Mj18WKv3UjRxm5zByfvpjz/+iPcqEEVfvM+OSa9ISbyH4qhgg70vSxXQSH+cqN2nJXhhZsd4NMu6sT1jhzVMtKFdwARBieTkZDl06JDffFxGvZBgMD+z5c2/mIcuOdZl6tat63c7BEBatmwpTZo0kZdffjnL9cWwnmXLloW8fsSIEX5BFmSYVKxYUUqWLCmFCxeWeB9oo8sP1iWeB9pHjlz8f67tlgvZzcbAmMcfj4pH9S93Pm6Tfny1p9P/o8t7KZq4Tc7g5P2EgutE7sOICYHdrXv1OKnPTmZGdh/HW2TViN795TCYFU5h2BzBeUy4j+GWH4k1pV3AJHfu3FK/fn1Zvny5Gu5iHhDi8sCBA4PepnHjxur6IUOG+OYhiIH5gK44CJpgGTNAgsDF2rVrpX///n6ZJQiW4PFRADacg8/Nmzf7BWEC5cmTR02BcN86HNziQDve62J9j0cjyKEyD9MM1wRMgNuklyTzpWV53+jwXoo2bpMzOHU/OW19iYjCYW/b3vDZ3fbWm1kS3cdQLYVDBkVy3soXbYKjxe4hOd4TpDAfgwGTxAqYADIyevbsKQ0aNJCGDRuqDjdo74uuOdCjRw8pX768Gu4CgwcPlhYtWqj6Ih06dJD58+fL+vXrfRkiOJhEMOWxxx6TKlWq+NoKlytXzheUQbDk+uuvl8qVK6u6JRgyYzIzVNCSGAGdevXqqcvooIPOPa+++mrMnyMiIiIiItKIJsESJ/LWKwmvnW92slpUIMbjnICUkZoqhie8HxYMI9XWdUl0WgZMunbtqgIWo0ePVkVZkRWyZMkSX9HWPXv2+P0yheEz8+bNU22DH330URUUQSHWmjVr+pYZPny4Crr07dtXjh8/rjrc4D7NlGBkpKDQK6YKFSr4rQ/GhpvQsviXX36RlJQUqVatmixYsEBuv/32GDwrRKSdfv0u/syCYjwItFqj/DNnxm3ViIgoTnjSnHjS63joQA2Tsb3IK0Q7uyTc5S4WhM1yWXWnZmHX6K6v/UVfDTHCDMpYz1UpQQImgOE3oYbgrFixIsM8FGjFFAqyTMaPH6+mYHr16qWmzCDrBRPl8OQyQPeVfEaJiIjIJTQ5caZYi/9Jq6+zjK3r4s0EierL3JO9bJSsbmbncxF66FB0XDDOImoS3rJy3tZ1SXTaBkyIiIiIiJyLkRPXi0HL3khEu6ZIrIaiZKeg68VCsIGMmAQ07ArEoPwDykF8fXBxRLfDbXBbij4GTIiIIrQyICvKSEJLbHR5QsHhi/PnBiRVcYQOEVFiUL99a3QiTdGnyxAcr/Dqf+gop4VYrUNj8BzYHSgxJVsP+KII5SJ2794t586di+h2CJaw+5w9GDAhIiIiIiIKl1bBEmR9xOhx4lS3JCspnrSYtDe2DgfCY9oFgQ8GP/TBgAkREREROZtHw7NYcimdMjmiXEskhx1sIrvP6A0hMmuVeGIyFMn7OMlavQ7ITgyYEBEREZHDMVhCifcyU8OCbB+KY3aliZ5oBjjMoIsZgIn+LvLeZ2B2TayG/lD8MWBCRGST7isDipgENopiURMiInfT7ASb3LMvPTEc7uOxJWMlGvfkX7PEG9iI7lCZUMVlGTBJHAyYUNwKZRIRERERaS0mWRxOLzqrl2gMl/EOwQl9P0k21jAhvTBgQkQUp6ChtYsOk02IiNzJ4JktRVmsCpza0UI4OYrDZjLL8sjeul/MWMlqHZlhkjgYMCEiIiIiItJeeu0PTyyDMtELmniDDDm/P2x/OEGjSOqkmMuGG4xiwCRxMGBCRERERERkQnZCtCudRkOM1smuh/FEOXAUzuNlFTSx3k8kXXui3TWI9MWACRERERERkeZi00LYLvEJMIQq2prTYUdJOVgnchYGTIiIiIiI7KRbpgIFx/2UPuTHiPp9RqseCoIf2anhYn18tT4aFJYlZ2DAhIhIh7bDgS2HgZVgiYiI7Kfj8JuAk/1YFHr1Po6+656MlsGenAVbvAGXnGMNk8TBgAkRkaZtt80uOoybEBG5gCdegxIoM7rvk1g1WbKjI45Jl1iUCphEKShk5/NFemHAhKKqX7BfydN153NNREREdtLlzCwInl7pSt894+0G41weje7rYhec6CQUsYZJ4mDAhIiIiIicT50FaX56qfnqJRyth+JEpwVv/JjDXwwtaqAkRVAINrz7c/K+oUgwYEJEREREFBMOTxlwE433g8osieH62XHynxylISvezBB7ghNJ7nz5UJQxYEJERERERK5nmCfxGp/tRrtDTVaPFcvHi4esslOSs/layKXxa4iiiwETip5+/aR7kMKVRJTjt1ZIM4O217EuMJNPPxEREU9wY/K0RGO4i+++bOjaE/RxwnwerMuxhkniYMCEiIiIiCiGDJ68x5ZDOhTF9mVh2FRGKHq1V7wBiuzfV7i3zaoQrMf6N/1CEt/DCYMBEyIiTXVfmUX2CDSPxZoQERE5FE9sg8BQHDuyS2KTERKe9K44YQ45ChYwMQMkSUG2Ktg8cicGTIiIiIiIYs36czXZk8XjmKc3trVEUNPDrkKq0ZIkaTnafdnt0JNsqbab2UuIQ3ISBwMmREQOtjKTukHNmX1CRKQ3x5zQO4yDntdYdsSJZn2R4EGYnPNEscNOdqVYtiTUNiU76UVGOcKACRFRolaMBRaFJSKKK71/53fgc+mori/Rq/cR2WNGPxtEJ9EI3mDITWaBLE8s+z5TXDFgQkTkUsw+ISJyCJ57JeTzF+tzbo/m95vTIq8XZe8+rENwLtZ4Cb51Hqe+6ChiDJhQ9H6pJiIiIu2sXLlSJk+eLBs2bJADBw7I+++/L7fcckumt1mxYoUMHTpUvvvuO6lYsaKMHDlSevXqFbN1Tig874rK8+etWeKc7JJY1izxPl70nx+PDcGSnD0vOcwsSQ+SWAfkeGuVsOhrImPAhKL6qzUROex9XL1f8LonOLIqWVJk3LiYrxsRRdfp06elTp06cu+998ptt92W5fK7d++WDh06yP333y9z586V5cuXS+/evaVs2bLStm1b/XePU1PlHbrapD9v9xq7apdEZzgOAiU5Xcec1Gjx3jbYmxBBEwZMEpm2AZPp06erX0MOHjyovuRfeOEFadiwYcjlFy5cKKNGjZKff/5ZqlSpIk899ZS0b9/ed71hGDJmzBh55ZVX5Pjx49K0aVN56aWX1LKm3377TQYNGiQfffSRJCUlSefOneW5556TggUL+pbZsmWLDBgwQL755hspWbKkWn748OGSCMkk3RkoIUqYQIqRJHK+qsg7/8TnZ9atjzMtMMs6KURx1a5dOzWFa8aMGXLZZZfJ008/rS5Xr15dvv76a3nmmWecETChhOGcfBILVeQ11h1x3A/baVdBW+/9ezK9TO6lZUekBQsWqDRQBDg2btyoAib4gj58+HDQ5VetWiXdunWT++67TzZt2qTSTDFt3brVt8ykSZPk+eefVwcBa9eulQIFCqj7PHPmjG+Z7t27q9TTZcuWyccff6xSWPv27eu7/uTJk9KmTRupXLmySmtFQGfs2LHy8ssv2/yMEBEREcXG6tWrpXXr1n7zcMyE+WQvgydhWTPHTDiqbbA108Mdopm1ktMWwjkV7ksJmSbWiRKDlhkmU6dOlT59+sg999yjLiPI8cknn8isWbPkkUceybA8skBuuukmGTZsmLo8YcIEFfSYNm2aui2yS5599lk1/rZTp05qmTlz5kjp0qVl0aJFcuedd8oPP/wgS5YsUZkjDRo0UMsgqwVZKlOmTJFy5cqptNRz586p9cidO7fUqFFDNm/erNbXGlhxQ1oJs0mICLp99U/xpOXsgGhlwLCfQHObz4z4Ppm0QmQfZPfiGMkKl/HD0V9//SX58uXLcJuzZ8+qyYRlKZt4HkZRYlcmi7fWSHTrl+R0fXKSbxTJ43sDJWZtE0oE2u1rBCSQvWH9ZQPDY3A51C8bWf0SgrG4+PK3LlOkSBFp1KiRbxn8LVq0qC9YAlgej42MFHOZ5s2bq2CJ9XG2b98uv//+e9SeAyIiIiInmThxojq2MicUiqUcYNAkKFXY1cnBi5iuv33ZLB7N7iy2yUbe/jjMMEkc2mWYHD16VFJTU4P+srFt27aIfgnBfPN6c15my5QqVcrv+pSUFClevLjfMhjTG3gf5nXFihXL8heXEydOqL+oo5KWFp0iSUOHity+amjQ65o0CX27/67xyPkrL5FcO4/l+BdkXRiGR85fOCu5jPPiyazwgoNwm/THfSSy+MvsP3+dvrw34tssrhb54xhJ2f/My+yzNCxTp2b9QZ6N+8D3CH7JRyAfAf4cyWodstqGCJkZCMgCJb2UKVNGDh065DcPlwsXLhw0uwRGjBihhlNbj3cqVaokF+R8+g+/6acY3lYmvkmdeoScl+T967FMuNZ6Wc0K8n/xn69OHUPezpO+ChnvTw2R8a1a+gCEDNeZj5H+f6y2pd2GuZz1MXwn/uZjS7BlA+b7OsGY86zrlHGYijnfug0X51nux3J76+Oa//fdXoIsH3jbcO4/q9tnuA8j9O0zPGb650mw51D8r794HwHzzOVCXvb+39d1xny5WeenZ2DgevUnyZDU9GW9uy09Q8OyrLfoqfU675AXw/J/8/o0v2VRu8P7f2+9Eu/fZA9u670v1Pa4uKz3erO2ifU25v/VZd+8tIv3n17kNRXzfPeVdnHZ9L8eCbzee/vkgOWxXIonTS74lr94O6yDWl4N1/Fuz8XrvffhnZ8mKZKWfn3AOqVvNx7fe1/meqY/JyKSy/uWTd82b+ZIcvrnjMc6BEdd570ef0+d9r5u+B3mftoFTNz4i8u4IF0mUAclmmaHumJ7Fjf8QdyH2+QMbttPbtse4DaF/1maldkhP6Vjex8aPv4ff/yhMhJIH40bN5bFixf7zcNQZ8wPJU+ePGqy/gAGX0v6/ZgZ89H5rYiISAv8DnM/7QImJUqUkOTk5KC/bOAXj0h+CTGXN/9iHlriWZepW7eub5nAorIXLlxQnXOs9xPscayPkdUvLvg1EPd5ySWXeH8hiSP8uoeU2b1796pfjdyA2+QMbttPbtse4DY5g5P3E36Vw4EmaoSRvU6dOiU7d+70XcZQZdRgQxYtskBwrLJv3z5V3w3QThh14NAFEK2IP//8c3n77bdVPblw4b5hz549CRUQc/J7MicSdbsTedsTfbvx2YZzOX6HuZ92AROkFdevX1+WL1+uOt2YQQZcHjhwYNDb4BcPXD9kyJCgv4RgGA0CGljGDJDgxY7aJP379/fdB4bJoH4KHh9wgIDHRq0Tc5l//etfcv78ecmVK5fvcapWrRp0OE6wX1wAtVJ0gg85t33QcZucwW37yW3bA9wmZ3DqfkqkE+l4Wr9+vbRs2dJ32fwhp2fPnvL666/LgQMH1MG/CcdNCI48+OCDqrB+hQoV5NVXX42opbA5RAz72ImvzUR9T+ZUom53Im97om53on62JSLtAibmFzm+xFGAtWHDhqrDzenTp31dc3r06CHly5dXw11g8ODB0qJFC3n66aelQ4cOMn/+fHVwYLb7RfQPwZTHHntMqlSpog4ERo0apSKCZlCmevXqqtMOuvOgsw6CIgjQoIOOGTm866671PAatC9++OGHVdtiHEg888wzcXuuiIiIiDJz/fXXZzrOHkGTYLfZtGkTn1giIkpoWgZMunbtKkeOHJHRo0erYqrICkHLX7PAKn4FsRa3a9KkicybN0+1DX700UdVUATtgmvWrOlbBmmlCLqg/S8ySZo1a6buM2/evL5l0DYYQZJWrVqp++/cubM8//zzfpHEpUuXyoABA1QWCoYPYR1d0VKYiIiIiIiIiPQOmAACF6GG4KxYsSLDvC5duqgpFGSZjB8/Xk2ZjbdF4CUztWvXlq+++krcAEOFxowZk2HIkJNxm5zBbfvJbdsD3CZncON+IndI1Ncmtzux9jdwnyfWPk/U/Z3IPAZ7IRERERERERER+bk4roWIiIiIiIiIiBQGTIiIiIiIiIiIAjBgQkRERERERETEgEliGTt2rCp4a52qVavmu/7MmTOq688ll1wiBQsWVJ2BDh06JDq79NJLM2wTJmyH2Qox8Lr7779fdLJy5Uq5+eabVctqrB+6OlmhtBA6MJUtW1by5csnrVu3lh07dvgt89tvv0n37t1VD/iiRYuqdtenTp0SHbcJbbrRirtWrVpSoEABtQzag+/fvz/Lffvkk0+KrvupV69eGdYX7cmdup8g2HsL0+TJk7XcT2gvf+2110qhQoWkVKlSqlX89u3b/ZYJ53MO3dfQlj5//vzqfoYNGyYXLlwQHbcJr6lBgwZJ1apV1edDpUqV5IEHHpATJ0743U+w/Th//vw4bBG51fTp09XnAToONmrUSNatW5fp8gsXLlTHIFge3weLFy8Wt2/3K6+8Itddd50UK1ZMTfg+z+p5csv+NuFzB58/+CxLhO1GN0585+AYDoVBr7rqqoR4rcOzzz7r+26qWLGiPPjgg+o72CmyOkYK1YzkmmuuUfv6yiuvDNqmnZyNGSYJoEaNGnLgwAHf9PXXX/uuwwfZRx99pA5ivvzyS3UCe9ttt4nOvvnmG7/tWbZsmZpv7ZLUp08fv2UmTZokOkGL6zp16qgvomCwvmhpPWPGDFm7dq0KMrRt29bvSwcn4d99953a/o8//lh9yMezxXVm2/Tnn3/Kxo0bZdSoUerve++9p04AO3bsmGFZdLKy7jucGOq6nwABEuv6vvXWW37XO2k/gXVbMM2aNUsdNCDIoON+wucWDkzXrFmjnmME59q0aaO2M9zPudTUVBUsOXfunKxatUreeOMNdcCDoKWO24T1xzRlyhTZunWrWtclS5aoYFyg2bNn++0np56wkH4WLFggQ4cOVd0i8LmOzxV8Tx0+fDjo8nhvdevWTb1ON23apF6LmPAadvN242QK2/3FF1/I6tWr1Ukk3s/79u0TN2+36eeff5aHHnpIBY2cKNLtxvfIjTfeqLb7nXfeUcc6CJqVL19e3L7t6DT6yCOPqOV/+OEHee2119R9PProo+IU4Rz3We3evVsdP7Rs2VI2b94sQ4YMkd69e8unn35q+7pSDKFLDrnXmDFjjDp16gS97vjx40auXLmMhQsX+ub98MMPBl4Wq1evNpxi8ODBxhVXXGGkpaWpyy1atFDznALP9/vvv++7jO0oU6aMMXnyZL99lSdPHuOtt95Sl7///nt1u2+++ca3zH/+8x/D4/EY+/btM3TbpmDWrVunlvvll1988ypXrmw888wzho6CbVPPnj2NTp06hbyNG/YTtu+GG27wm6fzfjp8+LDari+//DLsz7nFixcbSUlJxsGDB33LvPTSS0bhwoWNs2fPGrptUzBvv/22kTt3buP8+fMR7V+i7GrYsKExYMAA3+XU1FSjXLlyxsSJE4Muf8cddxgdOnTwm9eoUSOjX79+rt7uQBcuXDAKFSpkvPHGG4bbtxvb2qRJE+PVV1/N8vvSLduN747LL7/cOHfunOF0kW47lg08Xhg6dKjRtGlTw4nC+Q4dPny4UaNGDb95Xbt2Ndq2bWvz2lEsMcMkAWAoB1LLLr/8cvVrN1LPYcOGDeqXS6SHmpAqi/Ru/AriBIjkv/nmm3LvvfeqX8FNc+fOlRIlSkjNmjVlxIgRKsPBKRCtPnjwoN9+KVKkiEqFNPcL/mJ4R4MGDXzLYPmkpCSVkeIEGD6AfYbtsMLQDgydqFevnhoGEq9hEeHCr4cYNoEU1P79+8uxY8d81zl9P2HYyieffBI0c0HX/WQOSylevHjYn3P4i+EBpUuX9i2DX9FOnjypsoN026ZQy2DYV0pKit98ZKrgs7Bhw4YqW8h7DEiU8+9evLes7yt8ruFyqOMHzLcub77PnHK8kd3tDoTjEXwmZfZ+dst2IxMR34/BvkPcut0ffvihNG7cWH324jsFx6FPPPGEymR0+7Y3adJE3cYctvPTTz+poUjt27cXt3LD5xplzf/IilwHJ9lI18bJHNKxx40bp9IikQKLk/LcuXNnOGHFBzyucwKMLcRYUdSSMN11111SuXJlFSTasmWLqp2BlEgMA3EC87m3nryZl83r8BcHIVY4UcIBmBP2HYYWYb8gTRkneSbUYcA4UGwH0rcR7MLrdurUqaIjDMfB0I7LLrtMdu3apdJO27Vrp74ok5OTHb+fMDQFdTQCh+npup/S0tJUOmzTpk3VQSqE8zmHv8Heb+Z1um1ToKNHj8qECRMyDPXCycoNN9yg6rIsXbpU/vnPf6r6Odh/RDmB1xxOAIO9b7Zt2xb0NqHeZ/F+j9m93YHw3Yfjk8CTLLdtN4Z/Y0gGhik4VXa2G0GCzz//XP1AiWDBzp071WcvgmQYquLmbcfxN27XrFkzFZzHDymoIeikITmRCvW5hh9c/vrrL1XLhZyPAROXw8mbqXbt2iqAgmDC22+/7Yo3Mb6MsY04+DBZTxrwqzGKbrVq1Uqd0F5xxRVxWlMy4aDhjjvuUF+mL730kt8Tg7Gy1tcrTnT79eunimCimJZu7rzzTr/XGtYZrzFkneA153TISMBBH4q9OWE/4Rc9BIOtdZqcLqttwkEZxk9fffXVqsi3FWoGmZAJhLHZyAZiwIQoPpCZhwKo+I4I/Fx1kz/++EPuvvtuVbsDGW6JBEFu/FDy8ssvqx9O6tevr+rV4LPXSQGT7MDrGtk0L774ojrfQLBo8ODBKqBv/T4ichoOyUkw+JUV1brxIVamTBmVcocMjcA0fFynu19++UU+++wzVVwpM/jQBmyzE5jPfWAXD+t+wd/AoluI5KN7hs77zgyWYN+hmKU1uyTUvsN2oXiaE2DYGw4OzdeaU/cTfPXVVyozK6v3ly77aeDAgaqoLgorVqhQwTc/nM85/A32fjOv022brCclyHJCFtD7778vuXLlynI//frrr3L27Fkb15oSAT7ncDKY2fdUoFDvM90/C3O63SYUaUbABNleCDQ7SaTbjR+o8H2AbiPIqsQ0Z84cNVwF/8f1bt3f+JEOx9m4nal69eoqEwHfRU6RnW1HUASBMhw34EekW2+9VQVQ8GMKAkluFOpzDce3bvhhmrwYMEkwSMfGFxU+0BH1xgH28uXLfdfjBAk1TjD+Unfo/oAoPn5dzYyZDoptdgIM78AHsHW/4Fdk1Lww9wv+4gQQY0VNSAHFF5IZINI1WIKaOgh0of5FVrDvMGY2cFiLrnAyihom5mvNifvJmr2FzwhUi9d5PyFTCYEFBAzw3OL9YxXO5xz+/u9///MLbpkBPWRu6LZN5mcCOm0guwcnIeH8Wo39hLamOmZrkbPgdYf3lvV9hc81XA51/ID51uXN95kTjjdyst1m5zv8yo5uVtaaVm7dbtSJwmcqPnPMCV3xzE4i6BTk1v2N4ZP40cQaIPjxxx/VcQHuzymys+2oz4NjASszcOTW+llu+FyjMMS0xCzF3P/93/8ZK1asMHbv3m3897//NVq3bm2UKFFCdV2A+++/36hUqZLx+eefG+vXrzcaN26sJt2hUjfW++GHH/abv3PnTmP8+PFqW7DNH3zwgapW3rx5c0Mnf/zxh7Fp0yY14W04depU9X+zY8yTTz5pFC1aVK3/li1bVGX5yy67zPjrr79893HTTTcZ9erVM9auXWt8/fXXRpUqVYxu3bppuU2oFt+xY0ejQoUKxubNm40DBw74JrMLyapVq1TnFVy/a9cu48033zRKlixp9OjRQ8ttwnUPPfSQ6rSC19pnn31mXHPNNWo/nDlzxpH7yXTixAkjf/78qtp/IN32U//+/Y0iRYqozznr6+rPP//0LZPV5xw6OdSsWdNo06aN2q4lS5aobRoxYoSW24T9g+4itWrVUp951mWwLfDhhx8ar7zyivG///3P2LFjh/Hiiy+qfTp69Oi4bBO5z/z581X3ttdff111BOvbt6/63jK7Td19993GI4884lsexyApKSnGlClTVKcqdPFDByu8Rt283fg+Rwerd955x++9is9iN293IKd2yYl0u/fs2aO6IA0cONDYvn278fHHHxulSpUyHnvsMcPt2473NLYdHR1/+uknY+nSpaqLJTpkOUVWx0jYXmy3CduJ79Zhw4apz7Xp06cbycnJ6jiC3IMBE5dDa6uyZcuqL+vy5curyzjANuEE/J///KdRrFgx9Ya/9dZb1Re57j799FP1QYYvIyt8USE4Urx4cfUhf+WVV6oPMZxg6OSLL75Q6x844YDCbC08atQoo3Tp0mo7WrVqlWFbjx07pk68CxYsqNqf3nPPPXE9AMtsmxBQCHYdJtwONmzYoE4CcaKYN29eo3r16sYTTzzhF3zQaZtw8ooTbJxY46AfrXb79Onj15rWafvJNHPmTCNfvnyqJW8g3fZTqNfV7NmzI/qc+/nnn4127dqp7UZQGcFma4tenbYp1D7EhPea2b66bt266nVXoEAB1V5+xowZKthMFC0vvPCCCkbiGAMtSNesWeO7rkWLFn6fK2b766uuukotj1acn3zyieu3G98Nwd6rOLl0+/52Q8AkO9uNHxbwPYnjN/xo9/jjj/uC2W7ednxnjh07VgVJcHxQsWJF9d37+++/G06R1TES/mK7A2+D71s8R9jf1uMPcgcP/gknE4WIiIiIiIiIKFGwhgkRERERERERUQAGTIiIiIiIiIiIAjBgQkREREREREQUgAETIiIiIiIiIqIADJgQEREREREREQVgwISIiIiIiIiIKAADJkREREREREREARgwISIiIiIiIiIKwIAJEbnS66+/LkWLFo3JY3k8Hlm0aFFMHouIiCgR9erVS2655ZZ4rwYRJRgGTIjIVkeOHJH+/ftLpUqVJE+ePFKmTBlp27at/Pe//9Uu4HD99derdcGUN29eufrqq+XFF1/M8nYHDhyQdu3axWQdiYiI3Mb87g01jR07Vp577jn1YwgRUSylxPTRiCjhdO7cWc6dOydvvPGGXH755XLo0CFZvny5HDt2THTUp08fGT9+vPz5558yZ84cGTBggBQrVky6deuWYVlsV+7cuVUQiIiIiLIHPzyYFixYIKNHj5bt27f75hUsWFBNRESxxgwTIrLN8ePH5auvvpKnnnpKWrZsKZUrV5aGDRvKiBEjpGPHjmqZSy+9VP299dZb1a9I5mV46aWX5IorrlBBiapVq8q///3vDPffr18/KV26tMoIqVmzpnz88cchM10aNGigHufs2bMh1zl//vwqAILgDn7RqlKlinz44Ye+DJSBAwfKkCFDpESJEipTJliGzK+//qoCLMWLF5cCBQqox127dq3v+g8++ECuueYatc54nHHjxsmFCxey+SwTERE5G753zalIkSLqe9U6D8GSwCE5+E4eNGiQ+k7GDxs4FnjllVfk9OnTcs8990ihQoXkyiuvlP/85z9+j7V161aVFYr7xG3uvvtuOXr0aBy2moicgAETIrKN+YsQggmhghTffPON+jt79mz1C5N5+f3335fBgwfL//3f/6mDGwRGcAD0xRdfqOvT0tLUAQ+G9rz55pvy/fffy5NPPinJyckZHmPv3r1y3XXXqYDKO++8o4YGhStfvnwqk8SETBkEcPC4M2bMyLD8qVOnpEWLFrJv3z4VaPn2229l+PDhan0BAaQePXqobcM6z5w5U6UYP/7442GvExEREXm/k/EDxrp161TwBEOAu3TpIk2aNJGNGzdKmzZtVEAEWaPmDy033HCD1KtXT9avXy9LlixRma933HEHn04iCs4gIrLRO++8YxQrVszImzev0aRJE2PEiBHGt99+67cMPoref/99v3lYtk+fPn7zunTpYrRv3179/9NPPzWSkpKM7du3B33c2bNnG0WKFDG2bdtmVKxY0XjggQeMtLS0TNe1RYsWxuDBg9X/L1y4YPz73/9W6zZt2jTf9fXq1ctwO+v6z5w50yhUqJBx7NixoI/RqlUr44knnvCbh8cpW7ZsputGRESUCMzv70A9e/Y0OnXq5LuM7+RmzZr5LuN7u0CBAsbdd9/tm3fgwAH1Hb169Wp1ecKECUabNm387nfv3r1qmVDHE0SU2JhhQkS21zDZv3+/yra46aabZMWKFWo4SlaF23744Qdp2rSp3zxcxnzYvHmzVKhQQa666qqQ9/HXX3+pzJLbbrtNFYtDim9WUOQVWTHILEE9kwcffFD9YmWqX79+prfHeuGXKwzHCQYZJ6iRYmbfYMLjILvG/AWMiIiIsla7dm3f/5Fheskll0itWrV88zDkBg4fPuz7DkamqvU7uFq1auq6Xbt28SknogxY9JWIbIdaHTfeeKOaRo0aJb1795YxY8ao8cjZhYBGVjD0pnXr1qquybBhw6R8+fJZ3qZ79+7yr3/9S91/2bJlJSnJP66MmiQ5WS8M2UHNEgRxgj1PREREFJ5cuXL5XcYPI9Z55g8l5rBYfAfffPPNqrZaIHznExEFYoYJEcUc2vWiKJsJBzepqal+y1SvXt2v9TDgMm5r/qqE4qo//vhjyMdBsAOFYpEVgqKzyHTJCorNoUgcgiuBwZJwYL2QZfLbb78FvR7ZNaj8j8cInLLzeERERBQefAd/9913qsB84HdwVj+IEFFi4tE5EdkGrYNRXA1FWbds2SK7d++WhQsXyqRJk6RTp06+5XDgglbDBw8elN9//13NQ0YIhu2gU86OHTtk6tSp8t5778lDDz2krkdh1ebNm6shP8uWLVP3jUr4KOBmhRTduXPnSp06ddS64DHshO44qOiPSv4I8Pz000/y7rvvyurVq9X1aJWIdsXIMsFBG4YYzZ8/X0aOHGnrehERESW6AQMGqB808F2NIvMYhvPpp5+qovKBP9wQEQEDJkRkG4wNbtSokTzzzDMquIEuNRiSg5od06ZN8y339NNPq6BHxYoVVf0PQMABdUemTJkiNWrUUN1k0EkHbQRNCERce+216sAHmSfoRhPsgCclJUXeeustdT8Imphjme2ADjpLly6VUqVKSfv27dVYamv3HrQixhAhLIN1/9vf/qaeH7RcJiIiIvuUK1dO/ZiBYwV00MF3NNoSFy1alFmeRBSUB5Vfg19FRERERERERJSYmGFCRERERERERBSAARMiIiIiIiIiogAMmBARERERERERBWDAhIiIiIiIiIgoAAMmREREREREREQBGDAhIiIiIiIiIgrAgAkRERERERERUQAGTIiIiIiIiIiIAjBgQkREREREREQUgAETIiIiIiIiIqIADJgQEREREREREQVgwISIiIiIiIiIKAADJkREREREREREARgwISIiIiIiIiIKwIAJEREREREREVEABkyIiIiIiIiIiAIwYEJEREREREREJP7+Hw78k9PrxsIqAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -930,7 +975,7 @@ "\n", "# Generate specific data for visualization (ensure we have data for both libraries)\n", "params_vis_ql = {'initial_value': 100, 'mu': 0.05, 'sigma': 0.2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'sampler_type': 'Sobol'}\n", - "params_vis_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'sampler_type': 'Sobol'}\n", + "params_vis_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**10 if IN_COLAB else 2**14, 'sampler_type': 'Sobol'}\n", "\n", "# Generate paths for visualization\n", "vis_quantlib_paths, _ = qlu.generate_quantlib_paths(**params_vis_ql)\n", @@ -996,7 +1041,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -1006,7 +1051,7 @@ " for sampler_type in samplers_to_test:\n", " print(f\"QuantLib ({sampler_type}) timing:\")\n", " benchmark_func = lambda st=sampler_type: qlu.generate_quantlib_paths(**base_params, sampler_type=st)\n", - " timing_result = %timeit -n 10 -r 3 -o benchmark_func()\n", + " timing_result = get_ipython().run_line_magic('timeit', f'-n {1 if IN_COLAB else 10} -r {1 if IN_COLAB else 3} -o benchmark_func()')\n", " timing_results[sampler_type] = {\n", " 'average': timing_result.average,\n", " 'stdev': timing_result.stdev,\n", @@ -1027,7 +1072,7 @@ " for sampler_type in samplers_to_test:\n", " print(f\"QMCPy ({sampler_type}) timing:\")\n", " benchmark_func = lambda st=sampler_type: qpu.generate_qmcpy_paths(**qp_params, sampler_type=st)\n", - " timing_result = %timeit -n 10 -r 3 -o benchmark_func()\n", + " timing_result = get_ipython().run_line_magic('timeit', f'-n {1 if IN_COLAB else 10} -r {1 if IN_COLAB else 3} -o benchmark_func()')\n", " timing_results[sampler_type] = {\n", " 'average': timing_result.average,\n", " 'stdev': timing_result.stdev,\n", @@ -1039,7 +1084,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1047,17 +1092,17 @@ "output_type": "stream", "text": [ "QuantLib (IIDStdUniform) timing:\n", - "762 ms ± 4.04 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", + "1.09 s ± 4.85 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", "QuantLib (Sobol) timing:\n", - "835 ms ± 6.01 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", + "1.17 s ± 5.28 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", "QMCPy (IIDStdUniform) timing:\n", - "287 ms ± 6.01 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", + "279 ms ± 993 μs per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", "QMCPy (Sobol) timing:\n", - "297 ms ± 3.86 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", + "275 ms ± 1.03 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", "QMCPy (Lattice) timing:\n", - "285 ms ± 2.8 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", + "277 ms ± 1 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n", "QMCPy (Halton) timing:\n", - "2.01 s ± 5.91 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n" + "1.93 s ± 58.6 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n" ] }, { @@ -1093,49 +1138,49 @@ " 0\n", " QuantLib\n", " IIDStdUniform\n", - " 0.761604\n", - " 0.004041\n", + " 1.086473\n", + " 0.004846\n", " -\n", " \n", " \n", " 1\n", " QuantLib\n", " Sobol\n", - " 0.834711\n", - " 0.006006\n", + " 1.170537\n", + " 0.005275\n", " -\n", " \n", " \n", " 2\n", " QMCPy\n", " IIDStdUniform\n", - " 0.287149\n", - " 0.006005\n", - " 2.652299\n", + " 0.278809\n", + " 0.000993\n", + " 3.896829\n", " \n", " \n", " 3\n", " QMCPy\n", " Sobol\n", - " 0.297095\n", - " 0.003863\n", - " 2.563506\n", + " 0.274826\n", + " 0.001031\n", + " 3.953305\n", " \n", " \n", " 4\n", " QMCPy\n", " Lattice\n", - " 0.285152\n", - " 0.002803\n", - " 2.670867\n", + " 0.276884\n", + " 0.001002\n", + " 3.923928\n", " \n", " \n", " 5\n", " QMCPy\n", " Halton\n", - " 2.007001\n", - " 0.005915\n", - " 0.379473\n", + " 1.926630\n", + " 0.058623\n", + " 0.563924\n", " \n", " \n", "\n", @@ -1143,17 +1188,16 @@ ], "text/plain": [ " Method Sampler Mean Time (s) Std Dev (s) Speedup\n", - "0 QuantLib IIDStdUniform 0.761604 0.004041 -\n", - "1 QuantLib Sobol 0.834711 0.006006 -\n", - "2 QMCPy IIDStdUniform 0.287149 0.006005 2.652299\n", - "3 QMCPy Sobol 0.297095 0.003863 2.563506\n", - "4 QMCPy Lattice 0.285152 0.002803 2.670867\n", - "5 QMCPy Halton 2.007001 0.005915 0.379473" + "0 QuantLib IIDStdUniform 1.086473 0.004846 -\n", + "1 QuantLib Sobol 1.170537 0.005275 -\n", + "2 QMCPy IIDStdUniform 0.278809 0.000993 3.896829\n", + "3 QMCPy Sobol 0.274826 0.001031 3.953305\n", + "4 QMCPy Lattice 0.276884 0.001002 3.923928\n", + "5 QMCPy Halton 1.926630 0.058623 0.563924" ] }, - "execution_count": 19, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -1163,7 +1207,7 @@ "# Create base params without sampler_type to avoid conflicts \n", "base_ql_params = {k: v for k, v in params_ql.items() if k != 'sampler_type'}\n", "# Add the required parameters for QMCPy benchmarking\n", - "base_ql_params.update({'n_steps': 252, 'n_paths': 2**14})\n", + "base_ql_params.update({'n_steps': 252, 'n_paths': 2**10 if IN_COLAB else 2**14})\n", "# Create QMCPy parameters (note: diffusion instead of sigma)\n", "base_qp_params = {\n", " 'initial_value': 100, \n", @@ -1171,19 +1215,19 @@ " 'diffusion': 0.2**2, # sigma^2 for QMCPy\n", " 'maturity': 1.0, \n", " 'n_steps': 252, \n", - " 'n_paths': 2**14\n", + " 'n_paths': 2**10 if IN_COLAB else 2**14\n", "}\n", "# Run benchmarks\n", "quantlib_timing_results = benchmark_quantlib_samplers(quantlib_samplers_to_benchmark, base_ql_params)\n", "qmcpy_timing_results = benchmark_qmcpy_samplers(qmcpy_samplers_to_benchmark, base_qp_params)\n", "# Create comprehensive timing table\n", "timing_df = du.create_timing_dataframe(quantlib_timing_results, qmcpy_timing_results, quantlib_samplers_to_benchmark[0])\n", - "timing_df.round(10)" + "display(timing_df.round(10))" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1211,12 +1255,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1255,7 +1299,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -1363,12 +1407,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1394,7 +1438,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1457,8 +1501,8 @@ " 20.944804\n", " 0.407318\n", " 0.292635\n", - " 0.017228\n", - " 0.000108\n", + " 0.023385\n", + " 0.000189\n", " \n", " \n", " 2\n", @@ -1471,8 +1515,8 @@ " 7.248263\n", " 0.239544\n", " 13.989176\n", - " 0.001672\n", - " 0.000053\n", + " 0.001647\n", + " 0.000030\n", " \n", " \n", " 3\n", @@ -1485,8 +1529,8 @@ " 21.122113\n", " 0.046672\n", " 0.115326\n", - " 0.020083\n", - " 0.000352\n", + " 0.026723\n", + " 0.000335\n", " \n", " \n", " 4\n", @@ -1499,8 +1543,8 @@ " 12.455526\n", " 0.001055\n", " 8.781913\n", - " 0.002039\n", - " 0.000091\n", + " 0.001896\n", + " 0.000028\n", " \n", " \n", " ...\n", @@ -1527,8 +1571,8 @@ " 4.031370\n", " 0.113094\n", " 17.206069\n", - " 0.296038\n", - " 0.002294\n", + " 0.285090\n", + " 0.001583\n", " \n", " \n", " 80\n", @@ -1541,8 +1585,8 @@ " 21.051757\n", " 0.036463\n", " 0.185681\n", - " 0.802716\n", - " 0.007826\n", + " 1.167934\n", + " 0.003894\n", " \n", " \n", " 81\n", @@ -1555,8 +1599,8 @@ " 5.809188\n", " 0.000607\n", " 15.428251\n", - " 0.301287\n", - " 0.002927\n", + " 0.282971\n", + " 0.000132\n", " \n", " \n", " 82\n", @@ -1569,8 +1613,8 @@ " 6.154125\n", " 0.005287\n", " 15.083314\n", - " 0.292405\n", - " 0.003091\n", + " 0.291808\n", + " 0.003596\n", " \n", " \n", " 83\n", @@ -1583,8 +1627,8 @@ " 21.559537\n", " 0.000925\n", " 0.322098\n", - " 1.995156\n", - " 0.014354\n", + " 2.089140\n", + " 0.021533\n", " \n", " \n", "\n", @@ -1607,34 +1651,34 @@ "\n", " Std Dev Mean Absolute Error Std Dev Error Runtime (s) \\\n", "0 21.237439 0.000000 0.000000 0.000000 \n", - "1 20.944804 0.407318 0.292635 0.017228 \n", - "2 7.248263 0.239544 13.989176 0.001672 \n", - "3 21.122113 0.046672 0.115326 0.020083 \n", - "4 12.455526 0.001055 8.781913 0.002039 \n", + "1 20.944804 0.407318 0.292635 0.023385 \n", + "2 7.248263 0.239544 13.989176 0.001647 \n", + "3 21.122113 0.046672 0.115326 0.026723 \n", + "4 12.455526 0.001055 8.781913 0.001896 \n", ".. ... ... ... ... \n", - "79 4.031370 0.113094 17.206069 0.296038 \n", - "80 21.051757 0.036463 0.185681 0.802716 \n", - "81 5.809188 0.000607 15.428251 0.301287 \n", - "82 6.154125 0.005287 15.083314 0.292405 \n", - "83 21.559537 0.000925 0.322098 1.995156 \n", + "79 4.031370 0.113094 17.206069 0.285090 \n", + "80 21.051757 0.036463 0.185681 1.167934 \n", + "81 5.809188 0.000607 15.428251 0.282971 \n", + "82 6.154125 0.005287 15.083314 0.291808 \n", + "83 21.559537 0.000925 0.322098 2.089140 \n", "\n", " Runtime Std (s) \n", "0 0.000000 \n", - "1 0.000108 \n", - "2 0.000053 \n", - "3 0.000352 \n", - "4 0.000091 \n", + "1 0.000189 \n", + "2 0.000030 \n", + "3 0.000335 \n", + "4 0.000028 \n", ".. ... \n", - "79 0.002294 \n", - "80 0.007826 \n", - "81 0.002927 \n", - "82 0.003091 \n", - "83 0.014354 \n", + "79 0.001583 \n", + "80 0.003894 \n", + "81 0.000132 \n", + "82 0.003596 \n", + "83 0.021533 \n", "\n", "[84 rows x 11 columns]" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1652,7 +1696,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -1765,7 +1809,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.13.13" } }, "nbformat": 4, diff --git a/demos/GBM/gbm_examples.ipynb b/demos/GBM/gbm_examples.ipynb index 20b156f75..e35b8374b 100644 --- a/demos/GBM/gbm_examples.ipynb +++ b/demos/GBM/gbm_examples.ipynb @@ -8,6 +8,42 @@ "This notebook demonstrates MAE plots and comparisons for GBM samplers. " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_examples.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/GBM\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " !pip install -q qmcpy\n", + " !pip install -q QuantLib\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n", + " extra_path = f\"{repo_root}/demos/GBM/gbm_code\"\n", + " if extra_path not in sys.path:\n", + " sys.path.insert(0, extra_path)\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -25,13 +61,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from matplotlib.ticker import FixedLocator, FixedFormatter\n", "\n", + "# colab-deps: QuantLib\n", + "# (needed transitively by averaged_mae -> quantlib_util)\n", "import config as cf\n", "import averaged_mae as am\n", "import plot_util as pu" @@ -228,7 +266,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.13.13" } }, "nbformat": 4, diff --git a/demos/acceptance_rejection.ipynb b/demos/acceptance_rejection.ipynb index 7f6f99f1c..8bed5e925 100644 --- a/demos/acceptance_rejection.ipynb +++ b/demos/acceptance_rejection.ipynb @@ -13,21 +13,37 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb)" + "**Reference:** Zhu, H. & Dick, J. (2014). *Discrepancy bounds for deterministic acceptance-rejection samplers.* Electronic Journal of Statistics, 8(1), 678–707. [DOI: 10.1214/14-EJS898](https://doi.org/10.1214/14-EJS898)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**Reference:** Zhu, H. & Dick, J. (2014). *Discrepancy bounds for deterministic acceptance-rejection samplers.* Electronic Journal of Statistics, 8(1), 678–707. [DOI: 10.1214/14-EJS898](https://doi.org/10.1214/14-EJS898)" + "## Setup" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Setup" + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" ] }, { diff --git a/demos/asian-option-mlqmc.ipynb b/demos/asian-option-mlqmc.ipynb index 2b91aeaf2..b67f19757 100644 --- a/demos/asian-option-mlqmc.ipynb +++ b/demos/asian-option-mlqmc.ipynb @@ -1,5 +1,28 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -27,13 +50,6 @@ "# Comparison of multilevel (Quasi-)Monte Carlo for an Asian option problem" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb)" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/demos/brownian_bridge.ipynb b/demos/brownian_bridge.ipynb index 7d0e3c41d..96cdaa00a 100644 --- a/demos/brownian_bridge.ipynb +++ b/demos/brownian_bridge.ipynb @@ -10,19 +10,36 @@ }, { "cell_type": "markdown", - "id": "0271b99b-5c80-4484-a30c-bb4170665b47", + "id": "f01eecc1-b4ff-47c3-8b66-1c008da8dd8d", "metadata": {}, "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb)" + "`BrownianMotion` supports multiple path construction methods via the `decomp_type` parameter, including `'PCA'` and `'Cholesky'`. This notebook introduces `'BrownianBridge'`, which samples time points by conditioning on the two nearest time values that have already been sampled. The default order follows the van der Corput sequence, with the first term replaced by the terminal time and the full sequence scaled by the provided `t_final`. This ensures that each QMC dimension is used in decreasing order of variance. A custom order can also be provided through `monitoring_times`. " ] }, { "cell_type": "markdown", - "id": "f01eecc1-b4ff-47c3-8b66-1c008da8dd8d", "metadata": {}, "source": [ - "`BrownianMotion` supports multiple path construction methods via the `decomp_type` parameter, including `'PCA'` and `'Cholesky'`. This notebook introduces `'BrownianBridge'`, which samples time points by conditioning on the two nearest time values that have already been sampled. The default order follows the van der Corput sequence, with the first term replaced by the terminal time and the full sequence scaled by the provided `t_final`. This ensures that each QMC dimension is used in decreasing order of variance. A custom order can also be provided through `monitoring_times`. " - ] + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb)" + ], + "id": "efc21d5e" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "647e9e4c" }, { "cell_type": "code", diff --git a/demos/control_variates.ipynb b/demos/control_variates.ipynb index 2e604b6c0..2f22ad452 100644 --- a/demos/control_variates.ipynb +++ b/demos/control_variates.ipynb @@ -11,6 +11,15 @@ "This notebook demonstrates QMCPy's current support for control variates. " ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "v_CDThSJUpUz" + }, + "source": [ + "## Setup" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -19,12 +28,19 @@ ] }, { - "cell_type": "markdown", - "metadata": { - "id": "v_CDThSJUpUz" - }, + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "## Setup" + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" ] }, { diff --git a/demos/copula_examples.ipynb b/demos/copula_examples.ipynb index 874d57a1e..d3ab52d64 100644 --- a/demos/copula_examples.ipynb +++ b/demos/copula_examples.ipynb @@ -165,6 +165,31 @@ "Nelsen, R. B. (2006). *An Introduction to Copulas* (2nd ed.). Springer." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/copula_examples.ipynb)" + ], + "id": "de7b5ea9" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "9773e229" + }, { "cell_type": "code", "execution_count": 14, diff --git a/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb b/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb index 93f2b969a..1d2b3e9af 100644 --- a/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb +++ b/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb @@ -6,6 +6,31 @@ "metadata": {}, "source": "# Stop Re-running: Efficient Numerical Integration via Solver Log and Resumption\nSou-Cheng Choi \n\nMay 4, 2026\n\nIn high-dimensional integration, achieving high precision in the solution estimate often requires solving the same problem across a wide range of tolerances ($\\varepsilon$). Traditionally, this meant running the entire simulation multiple times, leading to prohibitive computational costs. This demo shows how using QMCPy's resume feature and internal solver logs can substantially reduce computational overhead while maintaining accuracy.\n\n## Approach 1. Classic Loop\nUsing the same approach as in, for example, [MCQMC2022_Article_Figures.ipynb](https://github.com/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC2022_Article_Figures/MCQMC2022_Article_Figures.ipynb), we will set up to create the two tolerance subplots:\n\n1) Time vs tolerance and \n2) Number of samples, $n$ vs tolerance, each on log-log axes, with the Lattice series plus the $\\mathcal{O}(\\epsilon^{-1})$ reference trend.\n\nThis naive approach requires re-running the solver for every target tolerance. This method suffers from poor scaling, making it impractical for large-scale parameter sweeps.\n" }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb)" + ], + "id": "86e67406" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "02988ece" + }, { "cell_type": "code", "execution_count": 1, @@ -499,4 +524,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/demos/demo_resume_data/accuracy_and_resume.ipynb b/demos/demo_resume_data/accuracy_and_resume.ipynb index 20b9cdc38..d0b558f2e 100644 --- a/demos/demo_resume_data/accuracy_and_resume.ipynb +++ b/demos/demo_resume_data/accuracy_and_resume.ipynb @@ -83,6 +83,40 @@ "Let's see how this works in code. We will use a Genz oscillatory integrand and QMCPy's `CubQMCLatticeG` routine." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/accuracy_and_resume.ipynb)" + ], + "id": "e5547174" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/demo_resume_data\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " !pip install -q qmcpy\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n" + ], + "id": "d7037d28" + }, { "cell_type": "code", "execution_count": null, diff --git a/demos/demo_resume_data/resume_examples.ipynb b/demos/demo_resume_data/resume_examples.ipynb index e49585cb3..afefc1817 100644 --- a/demos/demo_resume_data/resume_examples.ipynb +++ b/demos/demo_resume_data/resume_examples.ipynb @@ -22,6 +22,40 @@ "This demonstrates workflow and checkpointing correctness. For small examples, wall-clock timing differences can be negligible; performance gains become clearer when the initial run already used substantial work." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/resume_examples.ipynb)" + ], + "id": "0bc91a9d" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/demo_resume_data\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " !pip install -q qmcpy\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n" + ], + "id": "2667504c" + }, { "cell_type": "code", "execution_count": 1, @@ -760,4 +794,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/demos/digital_net_b2.ipynb b/demos/digital_net_b2.ipynb index c8feb3d2c..fc51ada3c 100644 --- a/demos/digital_net_b2.ipynb +++ b/demos/digital_net_b2.ipynb @@ -7,6 +7,29 @@ "# Digital Net Base 2 Generator" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/digital_net_b2.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -116,7 +139,7 @@ ], "source": [ "t0 = time()\n", - "s.gen_samples(2**25)\n", + "s.gen_samples(2**18 if IN_COLAB else 2**25)\n", "print('Time: %.2f'%(time()-t0))" ] }, diff --git a/demos/elliptic-pde.ipynb b/demos/elliptic-pde.ipynb index 820fd2a27..039255111 100644 --- a/demos/elliptic-pde.ipynb +++ b/demos/elliptic-pde.ipynb @@ -5,10 +5,33 @@ "metadata": {}, "source": [ "# Elliptic PDE\n", - "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/elliptic-pde.ipynb)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -389,7 +412,9 @@ { "cell_type": "markdown", "metadata": {}, - "source": "In the multilevel Monte Carlo method, we will rely on the ability to generate \"correlated\" solutions of the PDE with varying mesh sizes. Such correlated solutions can be used as efficient control variates to reduce the variance (or statistical error) in the approximation of the expected value $\\mathbb{E}[Q]$. Since we are using a factorization of the covariance matrix to generate realizations of the Gaussian random field, it is quite easy to obtain correlated samples: when sampling from the \"coarse\" solution level, use the same set of random numbers used to sample from the \"fine\" solution level, but truncated to the appropriate size. Since the eigenvalue decomposition will reveal the most important modes in the covariance matrix, that same eigenvalue decomposition on a \"coarse\" approximation level will contain the same eigenfunctions, represented on the coarse grid. Let's illustrate this property on an example using `n = 16` grid points for the fine solution level and `n = 8` grid points for the coarse solution level." + "source": [ + "In the multilevel Monte Carlo method, we will rely on the ability to generate \"correlated\" solutions of the PDE with varying mesh sizes. Such correlated solutions can be used as efficient control variates to reduce the variance (or statistical error) in the approximation of the expected value $\\mathbb{E}[Q]$. Since we are using a factorization of the covariance matrix to generate realizations of the Gaussian random field, it is quite easy to obtain correlated samples: when sampling from the \"coarse\" solution level, use the same set of random numbers used to sample from the \"fine\" solution level, but truncated to the appropriate size. Since the eigenvalue decomposition will reveal the most important modes in the covariance matrix, that same eigenvalue decomposition on a \"coarse\" approximation level will contain the same eigenfunctions, represented on the coarse grid. Let's illustrate this property on an example using `n = 16` grid points for the fine solution level and `n = 8` grid points for the coarse solution level." + ] }, { "cell_type": "code", @@ -1000,7 +1025,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1014,9 +1039,9 @@ " tol = []\n", " n_samp = []\n", " for t in range(stopping_crit.n_tols):\n", - " stopping_crit.rmse_tol = stopping_crit.inflate**(stopping_crit.n_tols-t-1)*stopping_crit.target_tol # update tol\n", - " stopping_crit._integrate(stopping_crit.data) # call _integrate()\n", - " tol.append(copy.copy(stopping_crit.rmse_tol))\n", + " step_tol = stopping_crit.inflate**(stopping_crit.n_tols-t-1)*stopping_crit.target_rmse_tol # update tol\n", + " stopping_crit._integrate(stopping_crit.data, step_tol=step_tol) # call _integrate()\n", + " tol.append(step_tol)\n", " n_samp.append(copy.copy(stopping_crit.data.n_level))\n", "\n", " if verbose:\n", @@ -1208,4 +1233,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb b/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb index 2783acf31..a5023bcbe 100644 --- a/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb +++ b/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb @@ -13,7 +13,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics_demo.ipynb)" + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" ] }, { @@ -1795,4 +1811,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/demos/iris.ipynb b/demos/iris.ipynb index 9848264eb..ef10f38a3 100644 --- a/demos/iris.ipynb +++ b/demos/iris.ipynb @@ -6,11 +6,34 @@ "source": [ "# ML Sensitivity Indices\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb)\n", "\n", "This notebook demonstrates QMCPy's support for vectorized sensitivity index computation. We preview this functionality by performing classification of Iris species using a decision tree. The computed sensitivity indices provide insight into input subset importance for a classic machine learning problem." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !pip install -q scikit-learn scikit-optimize\n" + ] + }, { "cell_type": "code", "execution_count": 2, diff --git a/demos/korobov_hammersley_latinhypercube_demos.ipynb b/demos/korobov_hammersley_latinhypercube_demos.ipynb index fbf654e81..aa902c86f 100644 --- a/demos/korobov_hammersley_latinhypercube_demos.ipynb +++ b/demos/korobov_hammersley_latinhypercube_demos.ipynb @@ -25,6 +25,31 @@ "5. [Summary: which sampler should I use?](#summary)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/korobov_hammersley_latinhypercube_demos.ipynb)" + ], + "id": "5c5ba22f" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "c01c8c05" + }, { "cell_type": "code", "execution_count": 1, @@ -475,4 +500,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/demos/lattice_random_generator.ipynb b/demos/lattice_random_generator.ipynb index 849687b2e..824bb3be7 100644 --- a/demos/lattice_random_generator.ipynb +++ b/demos/lattice_random_generator.ipynb @@ -7,6 +7,29 @@ "# Random Lattice Generators Are Not Bad\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lattice_random_generator.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 16, @@ -471,4 +494,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/demos/lebesgue_integration.ipynb b/demos/lebesgue_integration.ipynb index f1c7f4617..4db928774 100644 --- a/demos/lebesgue_integration.ipynb +++ b/demos/lebesgue_integration.ipynb @@ -12,6 +12,22 @@ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lebesgue_integration.ipynb)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 26, @@ -305,4 +321,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/demos/linear-scrambled-halton.ipynb b/demos/linear-scrambled-halton.ipynb index 35a165963..4582cff1c 100644 --- a/demos/linear-scrambled-halton.ipynb +++ b/demos/linear-scrambled-halton.ipynb @@ -59,6 +59,29 @@ "### Here we set up the QMCPY environment:" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/linear-scrambled-halton.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -544,4 +567,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/demos/nei_demo.ipynb b/demos/nei_demo.ipynb index eecc346a7..28fca267b 100644 --- a/demos/nei_demo.ipynb +++ b/demos/nei_demo.ipynb @@ -9,6 +9,29 @@ "You can also look at the Botorch implementation, but that requires a lot more understanding of code which involves Pytorch. So we tried to put a simple example together here." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/nei_demo.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -413,7 +436,7 @@ "\n", " vals[mc_strat] = np.array(vals[mc_strat])\n", "#reference_answer = compute_qei(next_x, 'lattice', 2 ** 7 * max(num_posterior_draws_to_test))\n", - "reference_answer = compute_qei(next_x, 'lattice', 2 ** 20)" + "reference_answer = compute_qei(next_x, 'lattice', 2 ** 14 if IN_COLAB else 2 ** 20)" ] }, { @@ -476,4 +499,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/demos/plot_proj_function.ipynb b/demos/plot_proj_function.ipynb index 941a8722d..0bf549cc8 100644 --- a/demos/plot_proj_function.ipynb +++ b/demos/plot_proj_function.ipynb @@ -26,6 +26,29 @@ "### Here we set up the QMCPY environment enabling us to utilize this function:" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/plot_proj_function.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -403,4 +426,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/demos/pricing_options.ipynb b/demos/pricing_options.ipynb index 9838717f3..f5b8a6ff6 100644 --- a/demos/pricing_options.ipynb +++ b/demos/pricing_options.ipynb @@ -11,6 +11,29 @@ "- The option is only exercised at expiry, unlike American options, which can be exercised at any time before expiry.\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/pricing_options.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 36, diff --git a/demos/product_measure.ipynb b/demos/product_measure.ipynb index 29e1c14c2..72a9b4432 100644 --- a/demos/product_measure.ipynb +++ b/demos/product_measure.ipynb @@ -26,6 +26,31 @@ "A single outer sampler generates points in $[0,1]^d$. `ProductMeasure` splits each point along the final coordinate axis, sends each block to the corresponding marginal transform, and concatenates the transformed blocks." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/product_measure.ipynb)" + ], + "id": "70fcf150" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "6a14b189" + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/qei-demo-for-blog.ipynb b/demos/qei-demo-for-blog.ipynb index b2ca867e1..05015e345 100644 --- a/demos/qei-demo-for-blog.ipynb +++ b/demos/qei-demo-for-blog.ipynb @@ -7,6 +7,29 @@ "# QEI (Q-Noisy Expected Improvement) Demo for Blog" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qei-demo-for-blog.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/qmcpy-logo.ipynb b/demos/qmcpy-logo.ipynb index 57b5c6b4d..b8db4b7b0 100644 --- a/demos/qmcpy-logo.ipynb +++ b/demos/qmcpy-logo.ipynb @@ -10,6 +10,31 @@ "Generate three lightweight scatter-plot logos from a two-dimensional randomized digital net, deterministic digital net, and lattice transformed to a zero-mean multivariate normal distribution with covariance `[[2, 1], [1, 3]]`. The deterministic net starts at index 1 because its origin maps to non-finite Gaussian coordinates." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy-logo.ipynb)" + ], + "id": "45d7d128" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "3204c240" + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/qmcpy_intro.ipynb b/demos/qmcpy_intro.ipynb index e1407623a..17960da7a 100644 --- a/demos/qmcpy_intro.ipynb +++ b/demos/qmcpy_intro.ipynb @@ -12,14 +12,30 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb)" + "Here we show three different ways to import QMCPy in a Python environment. First, we can import the package `qmcpy` under the alias `qp`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here we show three different ways to import QMCPy in a Python environment. First, we can import the package `qmcpy` under the alias `qp`." + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" ] }, { diff --git a/demos/quickstart.ipynb b/demos/quickstart.ipynb index 39b1eed31..55491b95f 100644 --- a/demos/quickstart.ipynb +++ b/demos/quickstart.ipynb @@ -12,13 +12,6 @@ "In this tutorial, we introduce QMCPy [1] by an example. QMCPy can be installed with **pip install qmcpy** or cloned from the [QMCSoftware GitHub repository](https://github.com/QMCSoftware/QMCSoftware)." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb)" - ] - }, { "cell_type": "markdown", "metadata": { @@ -36,6 +29,29 @@ "The Keister function is implemented below with help from NumPy [3] in the following code snippet:" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 4, @@ -198,4 +214,4 @@ }, "nbformat": 4, "nbformat_minor": 1 -} \ No newline at end of file +} diff --git a/demos/ray_tracing.ipynb b/demos/ray_tracing.ipynb index 9cedb4f09..61294dadd 100644 --- a/demos/ray_tracing.ipynb +++ b/demos/ray_tracing.ipynb @@ -11,6 +11,29 @@ "- [Ray Tracing: Graphics for the Masses by Paul Rademacher](https://dl.acm.org/doi/10.1145/270955.270962)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/ray_tracing.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 9, diff --git a/demos/sample_scatter_plots.ipynb b/demos/sample_scatter_plots.ipynb index 2e1c7baa5..ab5672311 100644 --- a/demos/sample_scatter_plots.ipynb +++ b/demos/sample_scatter_plots.ipynb @@ -7,6 +7,29 @@ "# Scatter Plots of Samples" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/sample_scatter_plots.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 14, diff --git a/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb b/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb index 7e04d612f..b0cbdd3c3 100644 --- a/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb +++ b/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb @@ -10,6 +10,31 @@ "This notebook demonstrates independent and dependent distribution support in `SciPyWrapper`, including custom marginals, joint transforms, and diagnostic checks for user-defined distributions." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb)" + ], + "id": "7aabd19e" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "12896311" + }, { "cell_type": "code", "execution_count": null, diff --git a/demos/some_true_measures.ipynb b/demos/some_true_measures.ipynb index 4784acf3c..eb2eddee1 100644 --- a/demos/some_true_measures.ipynb +++ b/demos/some_true_measures.ipynb @@ -57,6 +57,29 @@ "## Imports" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/some_true_measures.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/statistics_for_TrueMeasure.ipynb b/demos/statistics_for_TrueMeasure.ipynb index 9627042c8..33ddcd0db 100644 --- a/demos/statistics_for_TrueMeasure.ipynb +++ b/demos/statistics_for_TrueMeasure.ipynb @@ -21,6 +21,31 @@ "`Uniform` and `Kumaraswamy` have diagonal covariance matrices, so they store and return the covariance as a sparse `scipy.sparse` `dia_matrix`. This notebook densifies it with `to_dense_statistic` before building the comparison tables and plots." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/statistics_for_TrueMeasure.ipynb)" + ], + "id": "3a719fcf" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "77388722" + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/talk_paper_demos/JOSS2026/joss2026.ipynb b/demos/talk_paper_demos/JOSS2026/joss2026.ipynb index df5e6e86a..15f4849ea 100644 --- a/demos/talk_paper_demos/JOSS2026/joss2026.ipynb +++ b/demos/talk_paper_demos/JOSS2026/joss2026.ipynb @@ -10,19 +10,38 @@ }, { "cell_type": "markdown", - "id": "a32d4c28", + "id": "e862347b", "metadata": {}, "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/joss/demos/talk_paper_demos/JOSS2026/joss2026.ipynb)" + "## Setup" ] }, { "cell_type": "markdown", - "id": "e862347b", "metadata": {}, "source": [ - "## Setup" - ] + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/JOSS2026/joss2026.ipynb)" + ], + "id": "32b4a6c5" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !pip install -q seaborn tueplots\n", + " !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n" + ], + "id": "754742b8" }, { "cell_type": "code", @@ -44,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "ae0d77e0", "metadata": {}, "outputs": [], @@ -62,7 +81,7 @@ "MARKERSIZE = 5\n", "OUTDIR = \"JOSS2026.outputs\"\n", "FIGWIDTH = 500/72\n", - "assert os.path.isdir(OUTDIR)" + "os.makedirs(OUTDIR, exist_ok=True)" ] }, { diff --git a/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb b/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb index f58532cca..82136d126 100644 --- a/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb +++ b/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb @@ -63,6 +63,30 @@ "QMCPy can be installed with ``pip install qmcpy`` or cloned from the [QMCSoftware GitHub repository](https://github.com/QMCSoftware/QMCSoftware). " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !pip install -q torch\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -616,7 +640,7 @@ "ld = qmcpy.Lattice(64) #define a discrete LD distribution\n", "print(ld) #print the properties of the lattice object\n", "start_time = time.time() #time now\n", - "points = ld.gen_samples(2**20) #construct some points\n", + "points = ld.gen_samples(2**14 if IN_COLAB else 2**20) #construct some points\n", "end_time = time.time() #time after points are constructed\n", "print(f'\\nLD Points with shape {points.shape}\\n'+str(points))\n", "print(f'\\nTime to construct points is %.1e seconds'%(end_time - start_time))" diff --git a/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb b/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb index 3367a9ff2..8a10d76e3 100644 --- a/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb +++ b/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb @@ -23,6 +23,42 @@ "Our presentation slides for ParslFest are available at [Figma](https://www.figma.com/slides/k7EUosssNluMihkYTLuh1F/Parsl-Testbook-Speedup?node-id=174-95&t=t3jENVMltXWwdLdb-0)." ] }, + { + "cell_type": "markdown", + "id": "542c89c4", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f2bf29e", + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " # This notebook shells out to `make booktests_no_docker`, which needs the\n", + " # full test toolchain (coverage via pytest-cov, testbook, etc.), not just qmcpy.\n", + " !pip install -q \"qmcpy[test]\"\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -69,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "efac7e90", "metadata": {}, "outputs": [ @@ -87,7 +123,9 @@ "source": [ "out_path = os.path.join(output_dir, \"sequential_output.csv\")\n", "if (not os.path.exists(out_path)) or force_compute:\n", - " run_make_command(\"booktests_no_docker\", out_path, is_debug=is_debug)" + " succeeded = run_make_command(\"booktests_no_docker\", out_path, is_debug=is_debug)\n", + " if not succeeded:\n", + " print(f\"Warning: 'make booktests_no_docker' failed; see {out_path} for details.\")" ] }, { @@ -153,7 +191,7 @@ "kernelspec": { "display_name": "qmcpy", "language": "python", - "name": "qmcpy" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -165,7 +203,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.13.13" } }, "nbformat": 4, diff --git a/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb b/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb index 8f8f6c3be..2c4249517 100644 --- a/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb +++ b/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb @@ -9,7 +9,6 @@ "\n", "# [Accelerating QMCPy Notebook Tests with Parsl](https://www.figma.com/slides/k7EUosssNluMihkYTLuh1F/Parsl-Testbook-Speedup?node-id=1-37&t=WnKcu2QYO8JXvtpP-0)\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb)\n", "\n", "Joshua Herman, Brandon Sharp, and Sou-Cheng Choi, QMCPy Developers\n", "\n", @@ -24,6 +23,42 @@ "* Parsl: `pip install parsl==2025.7.28`" ] }, + { + "cell_type": "markdown", + "id": "0a00e53c", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a4b48ad", + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " # This notebook shells out to `make booktests_parallel_no_docker`, which needs\n", + " # the full test toolchain (coverage via pytest-cov, testbook, parsl, etc.), not just qmcpy.\n", + " !pip install -q \"qmcpy[test]\"\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -204,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "6bfa7a6b", "metadata": {}, "outputs": [ @@ -234,8 +269,10 @@ "if (not os.path.exists(par_fname)) or force_compute:\n", " env = os.environ.copy()\n", " env['PARSL_MAX_WORKERS'] = str(max_workers)\n", - " run_make_command(\"booktests_parallel_no_docker\", par_output, is_debug=is_debug, env=env)\n", - " \n", + " succeeded = run_make_command(\"booktests_parallel_no_docker\", par_output, is_debug=is_debug, env=env)\n", + " if not succeeded:\n", + " print(f\"Warning: 'make booktests_parallel_no_docker' failed; see {par_output} for details.\")\n", + "\n", " parallel_time = parse_total_time(par_output, r\"Total test time: ([\\d\\.]+)s\")\n", " print(f\"\\n=== RESULTS FOR EXECUTION {execution_id} ===\")\n", " print(f\"Parallel time: {parallel_time:.2f} seconds\")\n", diff --git a/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb b/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb index 6e50f0b4f..bffaf1ff9 100644 --- a/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb +++ b/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb @@ -1,5 +1,39 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb)" + ], + "id": "54f401f5" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " !pip install -q qmcpy\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n" + ], + "id": "28712456" + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb b/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb index 14b2f7d33..2389cc644 100644 --- a/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb +++ b/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb @@ -23,6 +23,43 @@ "Our presentation slides for ParslFest are available at [Figma](https://www.figma.com/slides/k7EUosssNluMihkYTLuh1F/Parsl-Testbook-Speedup?node-id=174-95&t=t3jENVMltXWwdLdb-0)." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb)" + ], + "id": "13703ae3" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025/output\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " !pip install -q qmcpy\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n", + " extra_path = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n", + " if extra_path not in sys.path:\n", + " sys.path.insert(0, extra_path)\n" + ], + "id": "ff1f3561" + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/talk_paper_demos/Parslfest_2025/util.py b/demos/talk_paper_demos/Parslfest_2025/util.py index b9a941623..88b4673ac 100644 --- a/demos/talk_paper_demos/Parslfest_2025/util.py +++ b/demos/talk_paper_demos/Parslfest_2025/util.py @@ -64,7 +64,7 @@ def run_make_command(cmd, output_file, is_debug=False, tests=None, env=None): Returns: bool: True if command succeeded """ - is_linux = sys.platform.startswith("Linux") + is_linux = sys.platform.startswith("linux") if tests is None and is_debug: tests = "tb_quickstart tb_qmcpy_intro tb_lattice_random_generator" diff --git a/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb b/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb index 8e115eb62..95e13d4fe 100644 --- a/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb +++ b/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb @@ -9,6 +9,29 @@ "https://www.arxiv.org/abs/2511.21915" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -1088,4 +1111,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb b/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb index a3c3db549..78a468ba2 100644 --- a/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb +++ b/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb @@ -14,6 +14,31 @@ "## Setup" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !pip install -q sympy torch tueplots\n", + " !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -35,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -54,7 +79,8 @@ "COLORS = palettes.tue_plot\n", "MARKERS = markers.o_sized\n", "pyplot.rcParams.update(probnum2025())\n", - "pyplot.rcParams.update(cycler.cycler(color=COLORS,marker=MARKERS))" + "pyplot.rcParams.update(cycler.cycler(color=COLORS,marker=MARKERS))\n", + "os.makedirs(\"outputs\", exist_ok=True)" ] }, { diff --git a/demos/talk_paper_demos/pydata_chi_2023.ipynb b/demos/talk_paper_demos/pydata_chi_2023.ipynb index c863016a2..4be7e706f 100644 --- a/demos/talk_paper_demos/pydata_chi_2023.ipynb +++ b/demos/talk_paper_demos/pydata_chi_2023.ipynb @@ -31,6 +31,31 @@ "## Python Setup" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/pydata_chi_2023.ipynb)" + ], + "id": "31df2e6e" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "f8b903bf" + }, { "cell_type": "code", "execution_count": 1, @@ -1573,4 +1598,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb b/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb index 8e90d5a0c..d62ff27f0 100644 --- a/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb +++ b/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb @@ -1,5 +1,30 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb)" + ], + "id": "2a8b11ef" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "1792a809" + }, { "cell_type": "code", "execution_count": 1, diff --git a/demos/vectorized_qmc.ipynb b/demos/vectorized_qmc.ipynb index 11d17a57c..0ab7d522d 100644 --- a/demos/vectorized_qmc.ipynb +++ b/demos/vectorized_qmc.ipynb @@ -12,14 +12,30 @@ }, { "cell_type": "markdown", - "id": "6df4c2a4-92ec-437e-80a1-28a82ea6544b", - "metadata": { - "id": "6df4c2a4-92ec-437e-80a1-28a82ea6544b" - }, + "id": "f696f50e", + "metadata": {}, "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc.ipynb)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "c318b211", + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -29,23 +45,13 @@ }, "outputs": [], "source": [ - "%%capture\n", - "# @title Execute this cell to install dependancies\n", - "try:\n", - " import google.colab\n", - " import os\n", - " !pip install -q qmcpy >> /dev/null\n", - " !apt-get update && apt-get install -y --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng\n", - "except:\n", - " pass\n", - "\n", "import matplotlib.pyplot as plt\n", "\n", "plt.rcParams.update({\n", "\"text.usetex\": True,\n", "\"font.family\": \"serif\",\n", "\"text.latex.preamble\": r\"\\usepackage{amsmath}\\usepackage{amssymb}\\newcommand{\\bx}{\\boldsymbol{x}}\"\n", - "})" + "})\n" ] }, { diff --git a/demos/vectorized_qmc_bayes.ipynb b/demos/vectorized_qmc_bayes.ipynb index bcb095ef2..2b4ac95be 100644 --- a/demos/vectorized_qmc_bayes.ipynb +++ b/demos/vectorized_qmc_bayes.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "markdown", - "id": "a306d01c-390a-4bb3-a2aa-b79f4c800d95", + "id": "e593c419", "metadata": {}, "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc_bayes.ipynb)" @@ -20,7 +20,26 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, + "id": "cc63050b", + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n", + " !pip install -q scikit-learn\n", + " !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "7cb5370c-b821-45a0-b0ea-5fa311690954", "metadata": { "colab": { @@ -31,24 +50,13 @@ }, "outputs": [], "source": [ - "%%capture\n", - "# @title Execute this cell to install dependancies\n", - "try:\n", - " import google.colab\n", - " import os\n", - " !pip install -q qmcpy >> /dev/null\n", - " !apt-get update && apt-get install -y --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng\n", - "except:\n", - " pass\n", - "\n", "import matplotlib.pyplot as plt\n", "\n", "plt.rcParams.update({\n", "\"text.usetex\": True,\n", "\"font.family\": \"serif\",\n", "\"text.latex.preamble\": r\"\\usepackage{amsmath}\\usepackage{amssymb}\\newcommand{\\bx}{\\boldsymbol{x}}\"\n", - "})\n", - "!pip install scikit-learn\n" + "})\n" ] }, { diff --git a/docs/tests.md b/docs/tests.md index 1120146dc..a1f20762e 100644 --- a/docs/tests.md +++ b/docs/tests.md @@ -14,6 +14,13 @@ This document describes the available test targets in the Makefile for QMCSoftwa | `make doctests` | All doctests with Docker | Slow | Full docstring validation | | `make booktests_no_docker` | Jupyter notebook tests | Slow | Validate demo notebooks | | `make booktests_parallel_no_docker` | Notebook tests with Parsl parallelization | Variable | Distributed notebook execution | +| `make check_colab_notebooks` | Audit enabled notebooks for Colab-readiness | Fast | Catch missing pip installs, repo-local imports, and source-install drift | +| `make check_colab_notebooks_smoke` | Execute Colab notebook setup smoke tests | Fast | Run bootstrap plus early import/setup cells for enabled notebooks | +| `make harden_colab_notebook [NOTEBOOK=...]` | Insert Colab bootstrap and classify notebook(s) | Fast | Harden one notebook, or attempt to harden unclassified demo notebooks | +| `make report_colab_notebook_patterns` | Group notebooks by Colab bootstrap family | Fast | Audit which notebooks use basic, extra-pip, LaTeX, or repo-local setup cells | +| `make open_colab_notebook NOTEBOOK=...` | Open a notebook in Colab from the current branch | Fast | Preview branch-only notebook changes in Colab before merge | +| `make open_colab_notebook_gist NOTEBOOK=...` | Upload the working-tree notebook to a secret gist and open it in Colab | Fast | Preview uncommitted notebook edits in Colab (needs `gh`) | +| `make open_notebook NOTEBOOK=...` | Open the working-tree notebook in local JupyterLab | Instant | Edit/run a demo notebook locally with full repo context | | `make coverage` | Display coverage report | Instant | View test coverage summary | | `make delcoverage` | Reset coverage tracking | Instant | Start fresh coverage analysis | @@ -146,12 +153,6 @@ Runs notebook tests with **Parsl distributed parallelization** for compute-heavy - **Dependencies**: Parsl must be installed and configured - **Use when**: Running large notebook suites with distributed compute resources -#### `make tests_parallel_no_docker` -Runs only unit tests with parallel pytest workers (no doctests or booktests). -- **Time**: ~13–20 seconds -- **Coverage**: Incremental -- **Use when**: Testing unit tests only in parallel mode - --- ### Helper / Internal Targets @@ -166,6 +167,72 @@ Auto-generates missing test stub files for notebooks. - **Output**: Reports any generated files - **Note**: Called automatically by `booktests_no_docker`; rarely used standalone +#### `make check_colab_notebooks` +Runs the strict static Colab-readiness checks. +- **Behavior**: Validates the manifest, badge and bootstrap placement, early dependencies, and repo-local imports +- **Use when**: You change a demo notebook or its Colab setup + +#### `make check_colab_notebooks_smoke` +Runs a lightweight execution smoke test for each Colab-enabled notebook. +- **Execution scope**: Simulates a Colab runtime, rewrites shell install commands to no-ops, then executes the bootstrap cell plus up to `$(SMOKE_CODE_CELLS)` smoke-safe import/setup code cells +- **Purpose**: Catch runtime regressions in early import/setup logic that static checks miss +- **CI usage**: Invoked in Linux CI after test dependencies are installed +- **Default depth**: `SMOKE_CODE_CELLS=2` + +#### `make harden_colab_notebook [NOTEBOOK=...]` +Hardens one notebook, or if `NOTEBOOK` is omitted, scans `demos/` for notebooks that are not yet listed in either `enabled` or `disabled`. +- **What it does**: Inserts the badge, adds a generated Colab bootstrap cell, infers common extra pip dependencies, and adds repo-local `sys.path` setup when needed +- **Classification rule**: Existing `disabled` entries are left untouched; unclassified notebooks are added to `enabled` only after hardening validates. Failures remain unclassified for manual review +- **Force mode**: `make harden_colab_notebook FORCE=1` regenerates the Open in Colab badge and the `# @title Execute this cell to install dependencies` cell for every notebook already listed in `enabled`; `make harden_colab_notebook NOTEBOOK=... FORCE=1` does the same for one notebook +- **Cell order**: The generated `import google.colab` bootstrap cell is always inserted after the Open in Colab badge +- **Validation**: Runs the existing Colab checks after rewriting; if validation fails, the notebook and manifest are restored and the failure is reported +- **Examples**: `make harden_colab_notebook NOTEBOOK=demos/plot_proj_function.ipynb`, `make harden_colab_notebook`, and `make harden_colab_notebook FORCE=1` + +#### `make report_colab_notebook_patterns` +Groups notebooks already classified in `scripts/colab_notebooks_manifest.json` by the current Colab badge/bootstrap cell pattern. +- **Pattern families**: Reports basic `qmcpy`-only bootstrap cells, extra-pip variants, LaTeX setup cells, repo-clone/path-setup cells, and disabled notebooks grouped by reason +- **Dependency details**: Lists extra install commands for notebooks that need more than `qmcpy` +- **Placement summary**: Reports where the badge and bootstrap cells appear, for example `badge cell 1, bootstrap cell 2` +- **Use when**: You want to batch-normalize notebook Colab setup or review which notebooks will be affected by bootstrap changes + +Every enabled notebook, grouped by its Colab bootstrap pattern family (regenerate with `make report_colab_notebook_patterns`): + +- **Basic qmcpy bootstrap** (28): [acceptance_rejection.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb), [asian-option-mlqmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb), [brownian_bridge.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb), [control_variates.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/control_variates.ipynb), [copula_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/copula_examples.ipynb), [Iteration_Log_Tolerance_Demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb), [digital_net_b2.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/digital_net_b2.ipynb), [gaussian_diagnostics_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb), [korobov_hammersley_latinhypercube_demos.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/korobov_hammersley_latinhypercube_demos.ipynb), [lattice_random_generator.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lattice_random_generator.ipynb), [lebesgue_integration.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lebesgue_integration.ipynb), [linear-scrambled-halton.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/linear-scrambled-halton.ipynb), [nei_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/nei_demo.ipynb), [plot_proj_function.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/plot_proj_function.ipynb), [pricing_options.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/pricing_options.ipynb), [product_measure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/product_measure.ipynb), [qei-demo-for-blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qei-demo-for-blog.ipynb), [qmcpy-logo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy-logo.ipynb), [qmcpy_intro.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb), [quickstart.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb), [ray_tracing.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/ray_tracing.ipynb), [sample_scatter_plots.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/sample_scatter_plots.ipynb), [scipywrapper_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb), [some_true_measures.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/some_true_measures.ipynb), [statistics_for_TrueMeasure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/statistics_for_TrueMeasure.ipynb), [sorokin_thesis_2025.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb), [pydata_chi_2023.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/pydata_chi_2023.ipynb), [why_add_q_to_mc_blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb) +- **Extra pip bootstrap** (4): [iris.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb), [joss2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/JOSS2026/joss2026.ipynb), [MCQMC_2020_QMC_Software_Tutorial.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb), [Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb) +- **LaTeX bootstrap** (4): [dakota_genz.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/DAKOTA_Genz/dakota_genz.ipynb), [elliptic-pde.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/elliptic-pde.ipynb), [vectorized_qmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc.ipynb), [vectorized_qmc_bayes.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc_bayes.ipynb) +- **Repo-local bootstrap** (7): [gbm_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_examples.ipynb), [accuracy_and_resume.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/accuracy_and_resume.ipynb), [resume_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/resume_examples.ipynb), [01_sequential.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb), [02_parallel.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb), [03_visualize_speedup.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb), [01_sequential_output.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb) +- **Repo-local bootstrap + extra pip installs** (1): [gbm_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_demo.ipynb) + +### Opening a demo notebook + +| Target | Notebook source | Opens in | Requires | +|--------|-----------------|----------|----------| +| `make open_notebook` | working tree | local JupyterLab | `jupyterlab` | +| `make open_colab_notebook` | `origin/` (or `` when unchanged) | Google Colab | branch + notebook pushed to `origin` | +| `make open_colab_notebook_gist` | working tree | Google Colab | `gh` CLI | + +#### `make open_colab_notebook NOTEBOOK=demos/.ipynb` +Opens a demo notebook in Google Colab from the **current git branch** instead of the committed `develop` badge URL, so you can preview branch-only notebook changes in Colab before they merge. +- **When it uses the branch**: The Colab link points at the current branch when the notebook is new on the branch, or when its content on `origin/` differs from `origin/`; otherwise it opens the `` version, since the committed badge already covers that case +- **Requires a push**: Colab loads notebooks from GitHub, so the branch and the notebook must already be pushed to `origin`; the target stops with a hint if they are not, and warns when your local working copy differs from what is pushed +- **Base branch**: The comparison base is `COLAB_BASE` (default `develop`) and must itself be a branch on `origin` +- **Output**: Prints the `https://colab.research.google.com/github///blob//` URL and opens it with `python -m webbrowser` +- **Examples**: `make open_colab_notebook NOTEBOOK=demos/nei_demo.ipynb`, `make open_colab_notebook NOTEBOOK=demos/GBM/gbm_demo.ipynb COLAB_BASE=master` + +#### `make open_colab_notebook_gist NOTEBOOK=demos/.ipynb` +Uploads the **working-tree** copy of a notebook to a throwaway secret GitHub gist and opens that gist in Colab, so you can preview uncommitted edits without pushing to a branch. +- **Requires**: The [`gh` CLI](https://cli.github.com), authenticated with `gh auth login` +- **What it prints**: The gist URL, the `https://colab.research.google.com/gist///` URL (also opened with `python -m webbrowser`), and the `gh gist delete ` cleanup command +- **Gist visibility**: "secret" means unlisted, not private; delete it when finished +- **Limitation**: A gist is a single file, so sibling `.py` helpers and repo-local imports will not resolve; the bootstrap cell's `git clone` falls back to `develop`. Use `make open_colab_notebook` for notebooks that depend on repo files +- **Example**: `make open_colab_notebook_gist NOTEBOOK=demos/quickstart.ipynb` + +#### `make open_notebook NOTEBOOK=demos/.ipynb` +Opens the working-tree notebook in local JupyterLab (`jupyter lab `, falling back to `python -m jupyterlab`). +- **Use when**: You want to edit or run a demo notebook locally with the current source install, helper files, and uncommitted changes all in place +- **Note**: Runs the Lab server in the foreground; stop it with `Ctrl+C` +- **Example**: `make open_notebook NOTEBOOK=demos/quickstart.ipynb` + #### `make coverage` Displays the current coverage report (must run other targets first to accumulate coverage data). - **Output**: Terminal summary of coverage percentages per file/module @@ -175,15 +242,7 @@ Displays the current coverage report (must run other targets first to accumulate Deletes `.coverage` and `coverage.json` files to reset coverage tracking. - **Use before**: Running a fresh coverage report without accumulated data -## Redundancy Analysis & Status - -### Removed Redundant Target ✅ - -#### `make tests_parallel_no_docker` (REMOVED) -- **Was redundant**: Ran only unit tests in parallel. `make tests_fast` is a strict superset (doctests + unittests + booktests in parallel). -- **Status**: **Removed from Makefile** to simplify maintenance and reduce user confusion. -- **Migration**: Users should use `make tests_fast` instead (faster, more comprehensive). - + --- ## Currently Active Targets: Justification @@ -409,4 +468,4 @@ A second workflow, `.github/workflows/unittests.yml`, runs a matrix across Pytho - `.github/workflows/alltests.yml` – CI all test workflow - `.github/workflows/unittests.yml` - CI unit test workflow - `make clean_local_only_files` – Artifact cleanup utility -- `scripts/pytest_xdist.py` – Parallel execution detection helper \ No newline at end of file +- `scripts/pytest_xdist.py` – Parallel execution detection helper diff --git a/makefile b/makefile index c81bea6df..8f30cb146 100644 --- a/makefile +++ b/makefile @@ -2,6 +2,7 @@ PYTEST_XDIST ?= $(shell python scripts/pytest_xdist.py 2>/dev/null) PYTEST ?= PYTHON ?= python3 +SMOKE_CODE_CELLS ?= 2 WITH_MPMC ?= 0 HAS_MPMC ?= $(shell python -c "import importlib.util; mods=('torch','pyg_lib','torch_geometric'); print(int(all(importlib.util.find_spec(m) is not None for m in mods)))" 2>/dev/null || echo 0) @@ -146,6 +147,88 @@ generate_booktests: @echo "\nGenerating missing booktest files..." cd test/booktests/ && python generate_test.py --check-missing +check_colab_notebooks: # faster + $(PYTHON) -m scripts.check_colab_notebooks --strict + +check_colab_notebooks_smoke: # slower; executes bootstrap + a few cells of every enabled notebook + $(PYTHON) -m scripts.smoke_test_colab_notebooks --cells-after-bootstrap $(SMOKE_CODE_CELLS) + +harden_colab_notebook: # Add Colab button if necessary + @if [ -n "$(NOTEBOOK)" ]; then \ + if [ -n "$(FORCE)" ]; then \ + $(PYTHON) -m scripts.harden_colab_notebook --notebook "$(NOTEBOOK)" --force; \ + else \ + $(PYTHON) -m scripts.harden_colab_notebook --notebook "$(NOTEBOOK)"; \ + fi; \ + elif [ -n "$(FORCE)" ]; then \ + $(PYTHON) -m scripts.harden_colab_notebook --force; \ + else \ + $(PYTHON) -m scripts.harden_colab_notebook --all-unclassified; \ + fi + +report_colab_notebook_patterns: + $(PYTHON) -m scripts.report_colab_notebook_patterns + +open_colab_notebook: # Open NOTEBOOK in Colab from the current branch, but only when it differs from COLAB_BASE (default develop); usage: make open_colab_notebook NOTEBOOK=demos/foo.ipynb [COLAB_BASE=develop] + @nb="$(NOTEBOOK)"; nb="$${nb#./}"; base="$${COLAB_BASE:-develop}"; \ + if [ -z "$$nb" ]; then echo "Usage: make open_colab_notebook NOTEBOOK=demos/path/to.ipynb [COLAB_BASE=develop]"; exit 2; fi; \ + case "$$nb" in *.ipynb) ;; *) echo "Not a .ipynb file: $$nb"; exit 2;; esac; \ + branch=$$(git rev-parse --abbrev-ref HEAD); \ + slug=$$($(PYTHON) -c "import json; wprint(json.load(open('scripts/colab_notebooks_manifest.json'))['repo'])" 2>/dev/null); \ + [ -n "$$slug" ] || slug=$$(git remote get-url origin 2>/dev/null | sed -E 's#(git@github\.com:|https://github\.com/)##; s#\.git$$##'); \ + if [ -z "$$slug" ]; then echo "Cannot determine the GitHub owner/repo (manifest 'repo' or 'origin' remote)."; exit 1; fi; \ + git fetch -q origin "$$base" "$$branch" 2>/dev/null || true; \ + if ! git rev-parse -q --verify "origin/$$branch" >/dev/null; then \ + echo "Branch '$$branch' is not on origin -- push it first (Colab loads notebooks from GitHub)."; exit 1; \ + fi; \ + if ! git rev-parse -q --verify "origin/$$base" >/dev/null; then \ + echo "Base '$$base' is not a branch on origin -- set COLAB_BASE to a pushed branch (e.g. develop)."; exit 1; \ + fi; \ + if ! git ls-tree -r --name-only "origin/$$branch" | grep -qxF "$$nb"; then \ + echo "'$$nb' is not committed on origin/$$branch -- commit and push it first."; exit 1; \ + fi; \ + git diff --quiet "origin/$$branch" -- "$$nb" || \ + echo "note: local '$$nb' differs from origin/$$branch; Colab shows the pushed version."; \ + if [ "$$branch" = "$$base" ]; then \ + ref="$$base"; echo "On '$$base' -- opening the $$base version."; \ + elif ! git ls-tree -r --name-only "origin/$$base" | grep -qxF "$$nb"; then \ + ref="$$branch"; echo "'$$nb' is new (not on origin/$$base) -- opening the '$$branch' version."; \ + elif git diff --quiet "origin/$$base" "origin/$$branch" -- "$$nb"; then \ + ref="$$base"; echo "'$$nb' is unchanged vs origin/$$base -- the standard badge covers it; opening the $$base version."; \ + else \ + ref="$$branch"; echo "'$$nb' differs from origin/$$base -- opening the '$$branch' version."; \ + fi; \ + url="https://colab.research.google.com/github/$$slug/blob/$$ref/$$nb"; \ + echo "$$url"; \ + $(PYTHON) -m webbrowser "$$url" >/dev/null 2>&1 || echo "(could not auto-open a browser; copy the URL above)" + +open_colab_notebook_gist: # Upload NOTEBOOK from the working tree to a throwaway secret gist and open it in Colab (needs the gh CLI); usage: make open_colab_notebook_gist NOTEBOOK=demos/foo.ipynb + @nb="$(NOTEBOOK)"; nb="$${nb#./}"; \ + if [ -z "$$nb" ]; then echo "Usage: make open_colab_notebook_gist NOTEBOOK=demos/path/to.ipynb"; exit 2; fi; \ + if [ ! -f "$$nb" ]; then echo "No such file: $$nb"; exit 2; fi; \ + case "$$nb" in *.ipynb) ;; *) echo "Not a .ipynb file: $$nb"; exit 2;; esac; \ + if ! command -v gh >/dev/null 2>&1; then \ + echo "The 'gh' CLI is required (https://cli.github.com), then run 'gh auth login'."; exit 1; \ + fi; \ + base=$$(basename "$$nb"); \ + url=$$(gh gist create --desc "qmcpy Colab preview of $$nb (safe to delete)" "$$nb") || exit 1; \ + id=$${url##*/}; \ + login=$$(gh api user -q .login 2>/dev/null); \ + colab="https://colab.research.google.com/gist/$${login:+$$login/}$$id/$$base"; \ + echo "gist (secret): $$url"; \ + echo "colab: $$colab"; \ + echo "delete when done: gh gist delete $$id"; \ + echo "note: sibling .py helpers won't resolve from a gist; the bootstrap cell falls back to develop."; \ + $(PYTHON) -m webbrowser "$$colab" >/dev/null 2>&1 || echo "(could not auto-open a browser; copy the colab URL above)" + +open_notebook: # Open NOTEBOOK from the working tree in local JupyterLab; usage: make open_notebook NOTEBOOK=demos/foo.ipynb + @nb="$(NOTEBOOK)"; nb="$${nb#./}"; \ + if [ -z "$$nb" ]; then echo "Usage: make open_notebook NOTEBOOK=demos/path/to.ipynb"; exit 2; fi; \ + if [ ! -f "$$nb" ]; then echo "No such file: $$nb"; exit 2; fi; \ + case "$$nb" in *.ipynb) ;; *) echo "Not a .ipynb file: $$nb"; exit 2;; esac; \ + if command -v jupyter >/dev/null 2>&1; then exec jupyter lab "$$nb"; \ + else exec $(PYTHON) -m jupyterlab "$$nb"; fi + check_booktests: rm -fr demos/.ipynb_checkpoints/*checkpoint.ipynb && \ find demos -name '*.ipynb' | while read nb; do \ @@ -423,6 +506,7 @@ format: $(MAKE) flatten_qmcpy_imports $(MAKE) markdown-unwrap MARKDOWN_UNWRAP_PATH="$(MARKDOWN_UNWRAP_PATH)" $(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)" + $(MAKE) harden_colab_notebook flatten_qmcpy_imports: $(PYTHON) scripts/flatten_qmcpy_imports.py diff --git a/scripts/__init__.py b/scripts/__init__.py new file mode 100644 index 000000000..e3d9df4d4 --- /dev/null +++ b/scripts/__init__.py @@ -0,0 +1 @@ +"""Repository maintenance scripts.""" diff --git a/scripts/check_colab_notebooks.py b/scripts/check_colab_notebooks.py new file mode 100644 index 000000000..444ff0afe --- /dev/null +++ b/scripts/check_colab_notebooks.py @@ -0,0 +1,567 @@ +#!/usr/bin/env python3 +""" +Validate Colab support metadata for demo notebooks. + +Every notebook under ``demos/`` must be explicitly classified in the manifest: +- enabled: notebook should expose the expected Colab badge and bootstrap cell +- disabled: notebook is intentionally excluded, with a reason +""" + +from __future__ import annotations + +import argparse +import ast +import json +import re +import sys +import warnings +from pathlib import Path +from urllib.parse import urlsplit + + +REPO_ROOT = Path(__file__).resolve().parents[1] +DEMOS_DIR = REPO_ROOT / "demos" +DEFAULT_MANIFEST = Path(__file__).with_name("colab_notebooks_manifest.json") + +CORE_BOOTSTRAP_FRAGMENT = "import google.colab" +BOOTSTRAP_CELL_MARKER = "# @title Execute this cell to install dependencies" +REPO_QMCPY_INSTALL_FRAGMENTS = ( + "git+https://github.com/QMCSoftware/QMCSoftware", + "pip install -q -e", + "pip install -e", +) +EXTRA_PIP_DEPENDENCIES = { + "QuantLib": ("QuantLib", "quantlib"), + "parsl": ("parsl",), + "seaborn": ("seaborn",), + "skopt": ("scikit-optimize", "skopt"), + "tueplots": ("tueplots",), +} +UMBRIDGE_MARKERS = ("import umbridge", "from umbridge", "UMBridgeWrapper", "HTTPModel(") +EARLY_EXTRA_DEPENDENCY_CODE_CELLS = 3 +REPO_FETCH_FRAGMENTS = ("git clone", "raw.githubusercontent.com", "wget ", "curl ") +PATH_SETUP_FRAGMENTS = ("sys.path.insert", "os.chdir(", "%cd ", "cd ") +IGNORED_NOTEBOOK_NAME_PREFIXES = (".tmp", "._tmp") +EXTRA_DEPS_MARKER = "# colab-deps:" +COLAB_URL_HOSTNAME = "colab.research.google.com" +URL_PATTERN = re.compile(r"https?://[^\s)\]\"']+") + + +def load_json(path: Path) -> dict: + try: + with path.open(encoding="utf-8") as handle: + return json.load(handle) + except json.JSONDecodeError as exc: + raise ValueError( + f"{path}:{exc.lineno}:{exc.colno}: invalid JSON: {exc.msg}" + ) from exc + + +def as_source_list(source: str | list[str]) -> list[str]: + if isinstance(source, str): + return source.splitlines(keepends=True) + return list(source) + + +def cell_source_text(cell: dict) -> str: + return "".join(as_source_list(cell.get("source", []))) + + +def python_source_for_ast(source: str) -> str: + filtered_lines = [] + for line in source.splitlines(): + stripped = line.lstrip() + if stripped.startswith(("!", "%")): + # Replace rather than drop, so a magic-only block body still parses. + indent = line[: len(line) - len(stripped)] + filtered_lines.append(f"{indent}pass") + continue + filtered_lines.append(line) + return "\n".join(filtered_lines) + + +def imported_modules(source: str, location: str = "") -> set[str]: + cleaned = python_source_for_ast(source) + if not cleaned.strip(): + return set() + try: + # Notebook code often contains valid runtime strings such as LaTeX + # preambles that trigger irrelevant SyntaxWarnings during static parsing. + with warnings.catch_warnings(): + warnings.simplefilter("ignore", SyntaxWarning) + tree = ast.parse(cleaned, filename=location) + except SyntaxError: + return set() + + modules: set[str] = set() + for node in ast.walk(tree): + if isinstance(node, ast.Import): + for alias in node.names: + modules.add(alias.name.split(".")[0]) + elif isinstance(node, ast.ImportFrom) and node.module: + modules.add(node.module.split(".")[0]) + return modules + + +def badge_markup(repo: str, git_ref: str, notebook_path: str) -> str: + return ( + "[![Open In Colab]" + "(https://colab.research.google.com/assets/colab-badge.svg)]" + "(https://colab.research.google.com/github/" + f"{repo}/blob/{git_ref}/{notebook_path})" + ) + + +def contains_colab_url(source: str) -> bool: + # Parse candidate URLs and compare the exact hostname rather than + # substring-matching the domain, which a crafted URL could spoof. + return any( + urlsplit(match.group(0)).hostname == COLAB_URL_HOSTNAME + for match in URL_PATTERN.finditer(source) + ) + + +def is_any_badge_cell(cell: dict) -> bool: + if cell.get("cell_type") != "markdown": + return False + source = cell_source_text(cell) + return "Open In Colab" in source or contains_colab_url(source) + + +def has_expected_badge(cell: dict, repo: str, git_ref: str, notebook_path: str) -> bool: + return ( + cell.get("cell_type") == "markdown" + and badge_markup(repo, git_ref, notebook_path) in cell_source_text(cell) + ) + + +def is_any_install_cell(cell: dict) -> bool: + if cell.get("cell_type") != "code": + return False + source_lines = cell_source_text(cell).splitlines() + return bool(source_lines) and source_lines[0].strip() == BOOTSTRAP_CELL_MARKER + + +def pip_install_lines(source: str) -> list[str]: + return [ + line.lower() + for line in source.splitlines() + if line.lstrip().lower().startswith(("!pip install", "%pip install")) + ] + + +def installs_qmcpy(source: str) -> bool: + install_lines = pip_install_lines(source) + if any("qmcpy" in line for line in install_lines): + return True + return any(fragment in source for fragment in REPO_QMCPY_INSTALL_FRAGMENTS) + + +def installs_packages(source: str, package_names: tuple[str, ...]) -> bool: + install_lines = pip_install_lines(source) + return any( + package.lower() in line + for line in install_lines + for package in package_names + ) + + +def declared_extra_pip_packages(cells: list[dict]) -> list[str]: + """Escape hatch for deps outside EXTRA_PIP_DEPENDENCIES/EXTRA_IMPORT_DEPENDENCIES: + a `# colab-deps: pkg-a, pkg-b` comment anywhere in a code cell.""" + packages: list[str] = [] + for cell in cells: + if cell.get("cell_type") != "code": + continue + for line in cell_source_text(cell).splitlines(): + stripped = line.strip() + if not stripped.startswith(EXTRA_DEPS_MARKER): + continue + for name in stripped[len(EXTRA_DEPS_MARKER):].split(","): + name = name.strip() + if name and name not in packages: + packages.append(name) + return packages + + +def is_bootstrap_cell(cell: dict) -> bool: + source = cell_source_text(cell) + return is_any_install_cell(cell) and ( + CORE_BOOTSTRAP_FRAGMENT in source + and "except ImportError:" in source + and "if IN_COLAB:" in source + and installs_qmcpy(source) + ) + + +def notebook_code_cells(cells: list[dict]) -> list[tuple[int, dict]]: + return [ + (idx, cell) for idx, cell in enumerate(cells) if cell.get("cell_type") == "code" + ] + + +def early_non_install_code_cells( + cells: list[dict], limit: int = EARLY_EXTRA_DEPENDENCY_CODE_CELLS +) -> list[tuple[int, dict]]: + early_cells: list[tuple[int, dict]] = [] + for idx, cell in notebook_code_cells(cells): + if is_any_install_cell(cell): + continue + early_cells.append((idx, cell)) + if len(early_cells) >= limit: + break + return early_cells + + +def imported_modules_in_cells(indexed_cells: list[tuple[int, dict]]) -> set[str]: + modules: set[str] = set() + for idx, cell in indexed_cells: + modules.update( + imported_modules(cell_source_text(cell), location=f"cell {idx + 1}") + ) + return modules + + +def code_source_upto(cells: list[dict], end_index: int) -> str: + return "\n".join( + cell_source_text(cell) + for idx, cell in enumerate(cells) + if cell.get("cell_type") == "code" and idx <= end_index + ) + + +def find_first_module_import(cells: list[dict], module: str) -> int | None: + for idx, cell in notebook_code_cells(cells): + location = f"cell {idx + 1}" + if module in imported_modules(cell_source_text(cell), location=location): + return idx + return None + + +def local_module_matches(notebook_dir: Path, module: str) -> list[Path]: + matches: list[Path] = [] + + def add_if_present(directory: Path) -> None: + direct_file = directory / f"{module}.py" + package_init = directory / module / "__init__.py" + if direct_file.exists() and direct_file not in matches: + matches.append(direct_file) + if package_init.exists() and package_init not in matches: + matches.append(package_init) + + add_if_present(notebook_dir) + for candidate in notebook_dir.rglob(f"{module}.py"): + if candidate not in matches and "__pycache__" not in candidate.parts: + matches.append(candidate) + + # A notebook nested in a subfolder (e.g. a demo's `output/`) may import a + # shared helper module that lives in an ancestor folder, up to demos/. + directory = notebook_dir.parent + while directory == DEMOS_DIR or DEMOS_DIR in directory.parents: + add_if_present(directory) + if directory == DEMOS_DIR: + break + directory = directory.parent + + return matches + + +def validate_strict_enabled_notebook(path: Path) -> list[str]: + notebook_path = path.relative_to(REPO_ROOT).as_posix() + notebook_dir = path.parent + payload = load_json(path) + cells = payload.get("cells", []) + errors: list[str] = [] + full_source = "\n".join( + cell_source_text(cell) for _, cell in notebook_code_cells(cells) + ) + early_imports = imported_modules_in_cells(early_non_install_code_cells(cells)) + + for module, package_names in sorted(EXTRA_PIP_DEPENDENCIES.items()): + if module not in early_imports: + continue + first_import_index = find_first_module_import(cells, module) + if first_import_index is None: + continue + source_before_import = code_source_upto(cells, first_import_index) + if not installs_packages(source_before_import, package_names): + errors.append( + f"{notebook_path}: imports '{module}' without installing {package_names[0]!r} before that import." + ) + + imported_roots = sorted( + { + module + for idx, cell in notebook_code_cells(cells) + for module in imported_modules( + cell_source_text(cell), location=f"cell {idx + 1}" + ) + } + ) + if "umbridge" in imported_roots or any(marker in full_source for marker in UMBRIDGE_MARKERS): + errors.append( + f"{notebook_path}: depends on UM-Bridge and should be classified as Colab-disabled." + ) + + for idx, cell in notebook_code_cells(cells): + for line in cell_source_text(cell).splitlines(): + if "IN_COLAB" in line: + continue + hit = re.search(r"\b2\s*\*\*\s*(\d{2,})\b", line) + if hit and int(hit.group(1)) >= 20: + errors.append( + f"{notebook_path}: cell {idx + 1} uses 2**{hit.group(1)} without an " + "`... if IN_COLAB else ...` guard -- likely to OOM/timeout in Colab; " + "guard the size or Colab-disable the notebook." + ) + break + else: + continue + break + + for module in imported_roots: + local_matches = local_module_matches(notebook_dir, module) + if not local_matches: + continue + first_import_index = find_first_module_import(cells, module) + if first_import_index is None: + continue + source_before_import = code_source_upto(cells, first_import_index) + if not any(fragment in source_before_import for fragment in REPO_FETCH_FRAGMENTS): + errors.append( + f"{notebook_path}: imports local module '{module}' without fetching repo files first." + ) + if not any(fragment in source_before_import for fragment in PATH_SETUP_FRAGMENTS): + errors.append( + f"{notebook_path}: imports local module '{module}' without updating the working directory or sys.path first." + ) + nested_match = next( + (match for match in local_matches if match.parent != notebook_dir), None + ) + if nested_match is not None: + # Repo-root-relative (not notebook-relative) so this also works when + # the module lives in an ancestor of notebook_dir, matching the + # path harden_colab_notebook.py embeds in the generated bootstrap. + rel_parent = nested_match.parent.relative_to(REPO_ROOT).as_posix() + if rel_parent and rel_parent not in source_before_import: + errors.append( + f"{notebook_path}: imports local module '{module}' from '{rel_parent}' without referencing that path in Colab setup." + ) + + return errors + + +def manifest_sets(manifest: dict) -> tuple[set[str], dict[str, str]]: + enabled = set(manifest.get("enabled", [])) + disabled = dict(manifest.get("disabled", {})) + return enabled, disabled + + +def is_discoverable_notebook(path: Path) -> bool: + return ".ipynb_checkpoints" not in path.parts and not path.name.startswith( + IGNORED_NOTEBOOK_NAME_PREFIXES + ) + + +def discovered_notebooks() -> set[str]: + return { + path.relative_to(REPO_ROOT).as_posix() + for path in DEMOS_DIR.rglob("*.ipynb") + if is_discoverable_notebook(path) + } + + +def validate_manifest(manifest: dict, allowed_missing: set[str] | None = None) -> list[str]: + errors: list[str] = [] + enabled, disabled = manifest_sets(manifest) + discovered = discovered_notebooks() + declared = enabled | set(disabled) + allowed_missing = allowed_missing or set() + + overlap = enabled & set(disabled) + if overlap: + errors.append( + "Manifest paths cannot be both enabled and disabled: " + + ", ".join(sorted(overlap)) + ) + + missing = (discovered - declared) - allowed_missing + if missing: + errors.append( + "Manifest is missing notebook classifications for: " + + ", ".join(sorted(missing)) + + " -- run `make harden_colab_notebook` to classify them" + ) + + extra = declared - discovered + if extra: + errors.append( + "Manifest references notebooks that do not exist: " + + ", ".join(sorted(extra)) + ) + + for notebook_path, reason in sorted(disabled.items()): + if not isinstance(reason, str) or not reason.strip(): + errors.append(f"Disabled notebook is missing a reason: {notebook_path}") + + if not manifest.get("repo"): + errors.append("Manifest must define a non-empty 'repo' value.") + if not manifest.get("git_ref"): + errors.append("Manifest must define a non-empty 'git_ref' value.") + + return errors + + +def validate_enabled_notebook(path: Path, repo: str, git_ref: str) -> list[str]: + notebook_path = path.relative_to(REPO_ROOT).as_posix() + payload = load_json(path) + cells = payload.get("cells", []) + errors: list[str] = [] + + badge_positions = [ + idx + for idx, cell in enumerate(cells) + if has_expected_badge(cell, repo, git_ref, notebook_path) + ] + any_badge_positions = [ + idx for idx, cell in enumerate(cells) if is_any_badge_cell(cell) + ] + bootstrap_positions = [ + idx for idx, cell in enumerate(cells) if is_bootstrap_cell(cell) + ] + any_install_positions = [ + idx for idx, cell in enumerate(cells) if is_any_install_cell(cell) + ] + first_substantive_code = next( + ( + idx + for idx, cell in enumerate(cells) + if cell.get("cell_type") == "code" and not is_bootstrap_cell(cell) + ), + None, + ) + + if not badge_positions: + errors.append(f"{notebook_path}: missing the expected Colab badge markup.") + if not bootstrap_positions: + errors.append( + f"{notebook_path}: missing a Colab bootstrap cell with the core qmcpy install command." + ) + + if len(badge_positions) > 1: + errors.append( + f"{notebook_path}: expected one matching Colab badge, found {len(badge_positions)}." + ) + if len(any_badge_positions) != len(badge_positions): + errors.append( + f"{notebook_path}: found Colab badge markup that does not match the expected notebook URL." + ) + if len(bootstrap_positions) > 1: + errors.append( + f"{notebook_path}: expected one Colab bootstrap cell, found {len(bootstrap_positions)}." + ) + if len(any_install_positions) != len(bootstrap_positions): + errors.append( + f"{notebook_path}: found google.colab setup code that does not include the core qmcpy bootstrap." + ) + if badge_positions and bootstrap_positions and badge_positions[0] > bootstrap_positions[0]: + errors.append( + f"{notebook_path}: Colab badge must appear before the Colab bootstrap cell." + ) + + if ( + badge_positions + and first_substantive_code is not None + and badge_positions[0] > first_substantive_code + ): + errors.append( + f"{notebook_path}: Colab badge must appear before the first substantive code cell." + ) + + if ( + bootstrap_positions + and first_substantive_code is not None + and bootstrap_positions[0] > first_substantive_code + ): + errors.append( + f"{notebook_path}: Colab bootstrap cell must appear before the first substantive code cell." + ) + + return errors + + +def validate_disabled_notebook(path: Path) -> list[str]: + notebook_path = path.relative_to(REPO_ROOT).as_posix() + payload = load_json(path) + cells = payload.get("cells", []) + errors: list[str] = [] + + if any(is_any_badge_cell(cell) for cell in cells): + errors.append( + f"{notebook_path}: manifest marks this notebook as Colab-disabled, but a badge is present." + ) + if any(is_any_install_cell(cell) for cell in cells): + errors.append( + f"{notebook_path}: manifest marks this notebook as Colab-disabled, but a Colab install cell is present." + ) + + return errors + + +def run_check(manifest_path: Path, strict: bool = False) -> int: + manifest = load_json(manifest_path) + errors = validate_manifest(manifest) + enabled, disabled = manifest_sets(manifest) + repo = manifest["repo"] + git_ref = manifest["git_ref"] + + for notebook_path in sorted(enabled): + errors.extend( + validate_enabled_notebook(REPO_ROOT / notebook_path, repo, git_ref) + ) + + for notebook_path in sorted(disabled): + errors.extend(validate_disabled_notebook(REPO_ROOT / notebook_path)) + + if strict: + for notebook_path in sorted(enabled): + errors.extend(validate_strict_enabled_notebook(REPO_ROOT / notebook_path)) + + if errors: + for error in errors: + print(error, file=sys.stderr) + return 1 + + print( + "Colab notebook check passed: " + f"{len(enabled)} enabled, {len(disabled)} disabled, " + f"{len(enabled) + len(disabled)} total." + ) + return 0 + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Check Colab badge/bootstrap cells for demo notebooks." + ) + parser.add_argument( + "--manifest", + default=str(DEFAULT_MANIFEST), + help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})", + ) + parser.add_argument( + "--strict", + action="store_true", + help="Run additional static Colab-readiness checks for enabled notebooks.", + ) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + manifest_path = Path(args.manifest).resolve() + return run_check(manifest_path, strict=args.strict) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/colab_notebooks_manifest.json b/scripts/colab_notebooks_manifest.json new file mode 100644 index 000000000..ed62ba8be --- /dev/null +++ b/scripts/colab_notebooks_manifest.json @@ -0,0 +1,57 @@ +{ + "repo": "QMCSoftware/QMCSoftware", + "git_ref": "develop", + "enabled": [ + "demos/DAKOTA_Genz/dakota_genz.ipynb", + "demos/GBM/gbm_demo.ipynb", + "demos/GBM/gbm_examples.ipynb", + "demos/acceptance_rejection.ipynb", + "demos/asian-option-mlqmc.ipynb", + "demos/brownian_bridge.ipynb", + "demos/control_variates.ipynb", + "demos/copula_examples.ipynb", + "demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb", + "demos/demo_resume_data/accuracy_and_resume.ipynb", + "demos/demo_resume_data/resume_examples.ipynb", + "demos/digital_net_b2.ipynb", + "demos/elliptic-pde.ipynb", + "demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb", + "demos/iris.ipynb", + "demos/korobov_hammersley_latinhypercube_demos.ipynb", + "demos/lattice_random_generator.ipynb", + "demos/lebesgue_integration.ipynb", + "demos/linear-scrambled-halton.ipynb", + "demos/nei_demo.ipynb", + "demos/plot_proj_function.ipynb", + "demos/pricing_options.ipynb", + "demos/product_measure.ipynb", + "demos/qei-demo-for-blog.ipynb", + "demos/qmcpy-logo.ipynb", + "demos/qmcpy_intro.ipynb", + "demos/quickstart.ipynb", + "demos/ray_tracing.ipynb", + "demos/sample_scatter_plots.ipynb", + "demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb", + "demos/some_true_measures.ipynb", + "demos/statistics_for_TrueMeasure.ipynb", + "demos/talk_paper_demos/JOSS2026/joss2026.ipynb", + "demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb", + "demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb", + "demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb", + "demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb", + "demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb", + "demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb", + "demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb", + "demos/talk_paper_demos/pydata_chi_2023.ipynb", + "demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb", + "demos/vectorized_qmc.ipynb", + "demos/vectorized_qmc_bayes.ipynb" + ], + "disabled": { + "demos/talk_paper_demos/Argonne_Talk_2023_May/Argonne_2023_Talk_Figures.ipynb": "Need Umbridge", + "demos/umbridge.ipynb": "Need Umbridge", + "demos/talk_paper_demos/MCQMC2022_Article_Figures/MCQMC2022_Article_Figures.ipynb": "Need Umbridge", + "demos/talk_paper_demos/ProbFailureSorokinRao/prob_failure_gp_ci.ipynb": "Need Umbridge", + "demos/talk_paper_demos/Purdue_Talk_2023_March/Purdue_Talk_Figures.ipynb": "Need Umbridge" + } +} diff --git a/scripts/harden_colab_notebook.py b/scripts/harden_colab_notebook.py new file mode 100644 index 000000000..196c80aa8 --- /dev/null +++ b/scripts/harden_colab_notebook.py @@ -0,0 +1,503 @@ +#!/usr/bin/env python3 +""" +Harden a demo notebook for Colab and classify it in the Colab manifest. + +This script is intentionally conservative: +- it updates one notebook at a time +- it inserts a standard badge/bootstrap before the first substantive code cell +- it only auto-classifies notebooks that are not already in enabled or disabled +- it can force-regenerate Colab bootstrap cells for notebooks already in enabled +- it validates the result with the existing strict Colab checks +""" + +from __future__ import annotations + +import argparse +import copy +import hashlib +import json +from pathlib import Path + +from scripts.check_colab_notebooks import ( + BOOTSTRAP_CELL_MARKER, + DEFAULT_MANIFEST, + EXTRA_PIP_DEPENDENCIES, + REPO_ROOT, + as_source_list, + badge_markup, + cell_source_text, + declared_extra_pip_packages, + discovered_notebooks, + early_non_install_code_cells, + imported_modules, + is_any_badge_cell, + is_any_install_cell, + local_module_matches, + load_json, + pip_install_lines, + validate_enabled_notebook, + validate_manifest, + manifest_sets, + validate_strict_enabled_notebook, +) + + +EXTRA_IMPORT_DEPENDENCIES = { + **EXTRA_PIP_DEPENDENCIES, + "botorch": ("botorch",), + "gpytorch": ("gpytorch",), + "ipywidgets": ("ipywidgets",), + "seaborn": ("seaborn",), + "sklearn": ("scikit-learn", "sklearn"), + "sympy": ("sympy",), + "torch": ("torch",), + "umbridge": ("umbridge",), + "yfinance": ("yfinance",), +} +LATEX_MARKERS = ( + "text.usetex", + "\\usepackage", + "dvipng", + "latexmk", + "computer modern", + "tueplots", # tueplots bundles typically set text.usetex=True internally +) +COLAB_BADGE_IMAGE_FRAGMENT = "colab.research.google.com/assets/colab-badge.svg" + + +def dump_json(path: Path, payload: dict, *, indent: int = 1) -> None: + with path.open("w", encoding="utf-8") as handle: + json.dump(payload, handle, indent=indent, ensure_ascii=False) + handle.write("\n") + + +def json_indent(source: str) -> int: + for line in source.splitlines()[1:]: + if line.strip(): + return len(line) - len(line.lstrip()) + return 1 + + +def dump_notebook(path: Path, payload: dict, original_source: str) -> None: + dump_json(path, payload, indent=json_indent(original_source)) + + +def generated_cell_id(notebook_path: str, cell_kind: str) -> str: + return hashlib.sha256(f"{notebook_path}:{cell_kind}".encode()).hexdigest()[:8] + + +def discovered_imports(cells: list[dict]) -> set[str]: + modules: set[str] = set() + for idx, cell in enumerate(cells): + if cell.get("cell_type") != "code": + continue + modules.update( + imported_modules( + cell_source_text(cell), + location=f"cell {idx + 1}", + ) + ) + return modules + + +def local_repo_import_matches( + notebook_path: Path, cells: list[dict] +) -> dict[str, list[Path]]: + notebook_dir = notebook_path.parent.resolve() + matches_by_module: dict[str, list[Path]] = {} + for module in sorted(discovered_imports(cells)): + if module == "qmcpy": + continue + matches = local_module_matches(notebook_dir, module) + if matches: + matches_by_module[module] = matches + return matches_by_module + + +def needs_latex_setup(cells: list[dict]) -> bool: + source = "\n".join( + cell_source_text(cell) + for cell in cells + if cell.get("cell_type") in {"code", "markdown"} + ) + return any(marker in source for marker in LATEX_MARKERS) + + +def extra_pip_packages(cells: list[dict]) -> list[str]: + early_cells = [cell for _, cell in early_non_install_code_cells(cells)] + modules = discovered_imports(early_cells) + packages: list[str] = [] + for module, names in sorted(EXTRA_IMPORT_DEPENDENCIES.items()): + if module in modules: + package = names[0] + if package not in packages: + packages.append(package) + all_install_lines = [ + line + for cell in cells + if cell.get("cell_type") == "code" + for line in pip_install_lines(cell_source_text(cell)) + ] + for _, names in sorted(EXTRA_IMPORT_DEPENDENCIES.items()): + package = names[0] + if package in packages: + continue + if any(name.lower() in line for name in names for line in all_install_lines): + packages.append(package) + for package in declared_extra_pip_packages(cells): + if package not in packages: + packages.append(package) + return packages + + +def extra_repo_paths(notebook_path: Path, cells: list[dict]) -> list[str]: + notebook_dir = notebook_path.parent.resolve() + repo_matches = local_repo_import_matches(notebook_path, cells) + rel_paths: list[str] = [] + + for module in sorted(repo_matches): + for match in repo_matches[module]: + if match.name == "__init__.py" and match.parent.name == module: + parent = match.parent.parent.resolve() + else: + parent = match.parent.resolve() + if parent == notebook_dir: + continue + if parent == REPO_ROOT: + continue + rel_parent = parent.relative_to(REPO_ROOT).as_posix() + if rel_parent not in rel_paths: + rel_paths.append(rel_parent) + + return rel_paths + + +def bootstrap_cell_source(notebook_path: Path, manifest: dict, cells: list[dict]) -> list[str]: + notebook_dir_rel = notebook_path.parent.relative_to(REPO_ROOT).as_posix() + packages = extra_pip_packages(cells) + rel_paths = extra_repo_paths(notebook_path, cells) + latex_setup = needs_latex_setup(cells) + needs_repo_clone = bool(local_repo_import_matches(notebook_path, cells)) + + lines = [ + f"{BOOTSTRAP_CELL_MARKER}\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + ] + + if needs_repo_clone: + lines.extend( + [ + " import sys\n", + " import os\n", + ' repo_root = "/content/QMCSoftware"\n', + f' notebook_dir = f"{{repo_root}}/{notebook_dir_rel}"\n', + " if not os.path.isdir(repo_root):\n", + f" !git clone -q --depth 1 https://github.com/{manifest['repo']} {{repo_root}}\n", + ] + ) + + lines.append(" !pip install -q qmcpy\n") + + if packages: + lines.append(f" !pip install -q {' '.join(packages)}\n") + + if latex_setup: + lines.append( + ' !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >"$tmp" 2>&1; then rm -f "$tmp"; else status=$?; cat "$tmp"; rm -f "$tmp"; exit $status; fi\n' + ) + + if needs_repo_clone: + lines.extend( + [ + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n", + ] + ) + for rel_path in rel_paths: + lines.extend( + [ + f' extra_path = f"{{repo_root}}/{rel_path}"\n', + " if extra_path not in sys.path:\n", + " sys.path.insert(0, extra_path)\n", + ] + ) + + return lines + +def badge_stripped_cell(cell: dict) -> dict | None: + if not is_any_badge_cell(cell): + return cell + + kept_lines = [ + line + for line in as_source_list(cell.get("source", [])) + if COLAB_BADGE_IMAGE_FRAGMENT not in line + ] + if not "".join(kept_lines).strip(): + return None + + cleaned_cell = copy.deepcopy(cell) + cleaned_cell["source"] = kept_lines + return cleaned_cell + + +def remove_any_badge_cells(cells: list[dict]) -> list[dict]: + cleaned_cells: list[dict] = [] + for cell in cells: + cleaned_cell = badge_stripped_cell(cell) + if cleaned_cell is not None: + cleaned_cells.append(cleaned_cell) + return cleaned_cells + + +def badge_bootstrap_insert_index(cells: list[dict]) -> int: + insert_at = 0 + while insert_at < len(cells) and cells[insert_at].get("cell_type") == "markdown": + insert_at += 1 + first_code_cell = next( + (idx for idx, cell in enumerate(cells) if cell.get("cell_type") == "code"), + len(cells), + ) + return min(insert_at, first_code_cell) + + +def remove_existing_bootstrap_cells(cells: list[dict]) -> list[dict]: + return [cell for cell in cells if not is_any_install_cell(cell)] + + +def pending_unclassified( + manifest: dict, current_notebook: str | None = None +) -> set[str]: + enabled, disabled = manifest_sets(manifest) + missing = discovered_notebooks() - enabled - set(disabled) + if current_notebook is not None: + missing.discard(current_notebook) + return missing + + +def harden_notebook(notebook_path: Path, manifest_path: Path) -> None: + original_notebook_text = notebook_path.read_text(encoding="utf-8") + original_manifest_text = manifest_path.read_text(encoding="utf-8") + manifest = load_json(manifest_path) + notebook_payload = load_json(notebook_path) + + original_manifest = copy.deepcopy(manifest) + original_notebook = copy.deepcopy(notebook_payload) + + # Cells that survive unchanged: remove only the old badge/bootstrap cells. + # These dict objects are never modified; they are passed through as-is. + kept_cells = remove_any_badge_cells( + remove_existing_bootstrap_cells(list(notebook_payload.get("cells", []))) + ) + + insert_at = badge_bootstrap_insert_index(kept_cells) + + badge_cell = { + "cell_type": "markdown", + "metadata": {}, + "source": [ + badge_markup( + manifest["repo"], + manifest["git_ref"], + notebook_path.relative_to(REPO_ROOT).as_posix(), + ) + ], + } + bootstrap_cell = { + "cell_type": "code", + "execution_count": None, + "metadata": {}, + "outputs": [], + # Pass kept_cells (not the final list) so the source scanner only sees + # the original notebook code cells, not the badge cell we just built. + "source": bootstrap_cell_source(notebook_path, manifest, kept_cells), + } + + # Build the final cell list purely by concatenation — kept_cells are untouched. + cells = kept_cells[:insert_at] + [badge_cell, bootstrap_cell] + kept_cells[insert_at:] + + notebook_payload["cells"] = cells + + notebook_rel = notebook_path.relative_to(REPO_ROOT).as_posix() + if notebook_payload.get("nbformat_minor", 0) >= 5: + badge_cell["id"] = generated_cell_id(notebook_rel, "badge") + bootstrap_cell["id"] = generated_cell_id(notebook_rel, "bootstrap") + + enabled = list(manifest.get("enabled", [])) + disabled = dict(manifest.get("disabled", {})) + if notebook_rel in disabled: + raise ValueError( + f"{notebook_rel} is already classified as disabled; harden_colab_notebook does not reclassify disabled notebooks." + ) + if notebook_rel not in enabled: + enabled.append(notebook_rel) + enabled = sorted(enabled) + manifest["enabled"] = enabled + manifest["disabled"] = disabled + + notebook_changed = notebook_payload != original_notebook + manifest_changed = manifest != original_manifest + try: + if notebook_changed: + dump_notebook(notebook_path, notebook_payload, original_notebook_text) + if manifest_changed: + dump_json(manifest_path, manifest) + + reloaded_manifest = load_json(manifest_path) + errors = validate_manifest( + reloaded_manifest, + allowed_missing=pending_unclassified(reloaded_manifest, notebook_rel), + ) + errors.extend( + validate_enabled_notebook( + notebook_path, + reloaded_manifest["repo"], + reloaded_manifest["git_ref"], + ) + ) + errors.extend(validate_strict_enabled_notebook(notebook_path)) + if errors: + raise RuntimeError("\n".join(errors)) + except Exception: + if notebook_changed: + notebook_path.write_text(original_notebook_text, encoding="utf-8") + if manifest_changed: + manifest_path.write_text(original_manifest_text, encoding="utf-8") + raise + + +def error_summary(exc: Exception) -> str: + return str(exc).splitlines()[0] if str(exc) else "unknown error" + + +def validate_target_notebook(notebook_path: Path, notebook_rel: str) -> None: + if not notebook_path.exists(): + raise FileNotFoundError(f"Notebook not found: {notebook_rel}") + if notebook_path.suffix != ".ipynb": + raise ValueError(f"Expected a notebook path ending in .ipynb: {notebook_rel}") + + +def manifest_notebook_paths(manifest_path: Path, mode: str) -> list[Path]: + manifest = load_json(manifest_path) + enabled, disabled = manifest_sets(manifest) + if mode == "enabled": + notebook_rels = enabled + elif mode == "unclassified": + notebook_rels = discovered_notebooks() - enabled - set(disabled) + else: # pragma: no cover - internal guard + raise ValueError(f"Unknown notebook selection mode: {mode}") + return sorted((REPO_ROOT / notebook_rel).resolve() for notebook_rel in notebook_rels) + + +def harden_batch( + notebook_paths: list[Path], + manifest_path: Path, +) -> tuple[list[str], list[tuple[str, str]]]: + successes: list[str] = [] + failures: list[tuple[str, str]] = [] + + for notebook_path in notebook_paths: + notebook_rel = notebook_path.relative_to(REPO_ROOT).as_posix() + try: + validate_target_notebook(notebook_path, notebook_rel) + harden_notebook(notebook_path, manifest_path) + successes.append(notebook_rel) + except Exception as exc: + summary = error_summary(exc) + failures.append((notebook_rel, summary)) + + return successes, failures + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Harden a demo notebook for Colab and enable it in the Colab manifest." + ) + parser.add_argument( + "--notebook", + help="Repo-relative path to the notebook to harden, e.g. demos/plot_proj_function.ipynb", + ) + parser.add_argument( + "--all-unclassified", + action="store_true", + help="Attempt to harden every notebook under demos/ that is not yet listed in enabled or disabled.", + ) + parser.add_argument( + "--force", + action="store_true", + help="Regenerate the Colab bootstrap for enabled notebook(s). Without --notebook, processes every enabled notebook.", + ) + parser.add_argument( + "--manifest", + default=str(DEFAULT_MANIFEST), + help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})", + ) + args = parser.parse_args() + if args.notebook and args.all_unclassified: + parser.error("specify either --notebook or --all-unclassified, not both") + if args.all_unclassified and args.force: + parser.error("specify either --all-unclassified or --force, not both") + if not args.notebook and not args.all_unclassified and not args.force: + parser.error("specify --notebook, --all-unclassified, or --force") + return args + + +def main() -> int: + args = parse_args() + manifest_path = Path(args.manifest).resolve() + if args.notebook: + notebook_path = (REPO_ROOT / args.notebook).resolve() + try: + validate_target_notebook(notebook_path, args.notebook) + except (FileNotFoundError, ValueError) as exc: + raise SystemExit(str(exc)) from exc + manifest = load_json(manifest_path) + enabled, disabled = manifest_sets(manifest) + notebook_rel = notebook_path.relative_to(REPO_ROOT).as_posix() + if notebook_rel in disabled: + raise SystemExit( + f"{notebook_rel} is already classified as disabled; update the manifest manually before reclassifying it." + ) + if notebook_rel in enabled: + harden_notebook(notebook_path, manifest_path) + print(f"Hardened {notebook_rel} for Colab.") + return 0 + try: + harden_notebook(notebook_path, manifest_path) + print(f"Hardened {notebook_rel} for Colab and added it to enabled.") + return 0 + except Exception as exc: + summary = error_summary(exc) + print( + f"Could not harden {notebook_rel}; restored it and left it unclassified." + ) + print(f"Reason: {summary}") + return 1 + + mode = "enabled" if args.force else "unclassified" + successes, failures = harden_batch( + manifest_notebook_paths(manifest_path, mode), + manifest_path, + ) + for notebook_rel in successes: + print(f"Hardened {notebook_rel} for Colab.") + if failures: + print("") + print("Not yet hardened:") + for notebook_rel, error in failures: + print(f"- {notebook_rel}: {error}") + print("") + print( + f"Hardened {len(successes)} notebook(s); {len(failures)} notebook(s) still need manual follow-up." + ) + return 0 if not failures else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/report_colab_notebook_patterns.py b/scripts/report_colab_notebook_patterns.py new file mode 100644 index 000000000..2af0bd8f7 --- /dev/null +++ b/scripts/report_colab_notebook_patterns.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python3 +""" +Group demo notebooks by Colab badge/bootstrap cell pattern. +""" + +from __future__ import annotations + +import argparse +from collections import defaultdict +from pathlib import Path + +from scripts.check_colab_notebooks import ( + DEFAULT_MANIFEST, + REPO_ROOT, + cell_source_text, + is_any_badge_cell, + is_bootstrap_cell, + load_json, + manifest_sets, + validate_manifest, +) + +def first_matching_cell( + cells: list[dict], + predicate, +) -> tuple[int | None, str]: + for idx, cell in enumerate(cells, start=1): + if predicate(cell): + return idx, cell_source_text(cell) + return None, "" + + +def extra_install_commands(source: str) -> list[str]: + commands: list[str] = [] + for raw_line in source.splitlines(): + line = raw_line.strip() + if not line.startswith("!pip install"): + continue + if "qmcpy" in line.lower(): + continue + if " -q " in line: + commands.append(line.split(" -q ", 1)[1].strip()) + else: + commands.append(line.split("!pip install", 1)[1].strip()) + return commands + + +def pattern_family(source: str) -> str: + if not source: + return "Enabled but missing bootstrap cell" + + has_repo_clone = "git clone" in source + has_path_setup = "os.chdir(" in source or "sys.path.insert" in source + has_apt = "apt-get" in source + extra_installs = extra_install_commands(source) + + if has_repo_clone and extra_installs: + return "Repo-local bootstrap + extra pip installs" + if has_repo_clone or has_path_setup: + return "Repo-local bootstrap" + if has_apt: + return "LaTeX bootstrap" + if extra_installs: + return "Extra pip bootstrap" + return "Basic qmcpy bootstrap" + + +def placement_label(badge_position: int | None, bootstrap_position: int | None) -> str: + badge = "missing" if badge_position is None else str(badge_position) + bootstrap = "missing" if bootstrap_position is None else str(bootstrap_position) + return f"badge cell {badge}, bootstrap cell {bootstrap}" + + +def print_grouped_notebooks( + title: str, + groups: dict[str, list[str]], + details: dict[str, dict[str, str]] | None = None, +) -> None: + print(title) + for group_name in sorted(groups): + notebooks = sorted(groups[group_name]) + print(f"- {group_name} ({len(notebooks)} notebooks)") + for notebook in notebooks: + suffix = "" + if details is not None: + detail = details.get(group_name, {}).get(notebook) + if detail: + suffix = f" [{detail}]" + print(f" - {notebook}{suffix}") + print() + + +def run_report(manifest_path: Path) -> int: + manifest = load_json(manifest_path) + errors = validate_manifest(manifest) + if errors: + for error in errors: + print(error) + return 1 + + enabled, disabled = manifest_sets(manifest) + + family_groups: dict[str, list[str]] = defaultdict(list) + placement_groups: dict[str, list[str]] = defaultdict(list) + family_details: dict[str, dict[str, str]] = defaultdict(dict) + + for notebook_path in sorted(enabled): + payload = load_json(REPO_ROOT / notebook_path) + cells = payload.get("cells", []) + badge_position, _ = first_matching_cell(cells, is_any_badge_cell) + bootstrap_position, bootstrap_source = first_matching_cell( + cells, is_bootstrap_cell + ) + family = pattern_family(bootstrap_source) + placement = placement_label(badge_position, bootstrap_position) + extra_installs = extra_install_commands(bootstrap_source) + + family_groups[family].append(notebook_path) + placement_groups[placement].append(notebook_path) + + if extra_installs: + family_details[family][notebook_path] = ", ".join(extra_installs) + + disabled_groups: dict[str, list[str]] = defaultdict(list) + for notebook_path, reason in sorted(disabled.items()): + disabled_groups[reason].append(notebook_path) + + total = len(enabled) + len(disabled) + print("Colab notebook pattern report") + print(f"Manifest: {manifest_path.relative_to(REPO_ROOT).as_posix()}") + print(f"Enabled: {len(enabled)}") + print(f"Disabled: {len(disabled)}") + print(f"Total: {total}") + print() + + print_grouped_notebooks( + "Enabled pattern families", + family_groups, + details=family_details, + ) + print_grouped_notebooks("Badge/bootstrap placement", placement_groups) + print_grouped_notebooks("Disabled notebooks by reason", disabled_groups) + return 0 + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Group demo notebooks by Colab badge/bootstrap cell pattern." + ) + parser.add_argument( + "--manifest", + default=str(DEFAULT_MANIFEST), + help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})", + ) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + return run_report(Path(args.manifest).resolve()) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/smoke_test_colab_notebooks.py b/scripts/smoke_test_colab_notebooks.py new file mode 100644 index 000000000..c0e447a60 --- /dev/null +++ b/scripts/smoke_test_colab_notebooks.py @@ -0,0 +1,379 @@ +#!/usr/bin/env python3 +""" +Run lightweight Colab readiness smoke tests for enabled demo notebooks. + +This executes a temporary notebook prefix consisting of: +- a prelude cell that fakes ``google.colab`` +- the notebook's Colab bootstrap cell (with shell installs rewritten to no-ops) +- up to a few smoke-safe import/setup code cells after the bootstrap cell + +The goal is to catch runtime import/path/setup regressions in CI without +executing entire notebooks or re-running heavyweight package installs. +""" + +from __future__ import annotations + +import argparse +import ast +import copy +import json +import os +import re +import tempfile +from pathlib import Path + +from scripts.check_colab_notebooks import ( + DEFAULT_MANIFEST, + cell_source_text, + is_bootstrap_cell, + load_json, + python_source_for_ast, +) + + +REPO_ROOT = Path(__file__).resolve().parents[1] +def make_prelude_cell(notebook_path: Path) -> dict: + notebook_dir = notebook_path.parent.resolve().as_posix() + repo_root = REPO_ROOT.resolve().as_posix() + source = f"""import os +import sys +import types + +google = sys.modules.get("google") +if google is None: + google = types.ModuleType("google") + sys.modules["google"] = google + +colab = types.ModuleType("google.colab") +google.colab = colab +sys.modules["google.colab"] = colab + +os.environ["QMC_COLAB_SMOKE"] = "1" +os.environ["QMC_COLAB_SMOKE_REPO_ROOT"] = r"{repo_root}" +os.environ["QMC_COLAB_SMOKE_NOTEBOOK_DIR"] = r"{notebook_dir}" +""" + return { + "cell_type": "code", + "execution_count": None, + "id": "smoke-prelude", + "metadata": {}, + "outputs": [], + "source": source, + } + + +def rewrite_shell_magics(source: str) -> str: + rewritten_lines: list[str] = [] + for line in source.splitlines(keepends=True): + stripped = line.lstrip() + indent = line[: len(line) - len(stripped)] + if stripped.startswith("!"): + command = stripped[1:].rstrip() + rewritten_lines.append(f"{indent}print({command!r})\n") + else: + rewritten_lines.append(line) + return "".join(rewritten_lines) + + +def rewrite_bootstrap_source(source: str) -> str: + repo_root = REPO_ROOT.resolve().as_posix() + source = source.replace('"/content/QMCSoftware"', repr(repo_root)) + source = source.replace("'/content/QMCSoftware'", repr(repo_root)) + return rewrite_shell_magics(source) + + +def assignment_target_is_smoke_safe(node: ast.AST) -> bool: + if isinstance(node, ast.Name): + return True + if isinstance(node, (ast.Tuple, ast.List)): + return all(assignment_target_is_smoke_safe(elt) for elt in node.elts) + if isinstance(node, ast.Attribute): + return expression_is_smoke_safe(node.value) + if isinstance(node, ast.Subscript): + return expression_is_smoke_safe(node.value) and expression_is_smoke_safe(node.slice) + return False + + +def expression_is_smoke_safe(node: ast.AST | None) -> bool: + if node is None: + return True + if isinstance(node, (ast.Constant, ast.Name)): + return True + if isinstance(node, ast.Attribute): + return expression_is_smoke_safe(node.value) + if isinstance(node, ast.Tuple): + return all(expression_is_smoke_safe(elt) for elt in node.elts) + if isinstance(node, ast.List): + return all(expression_is_smoke_safe(elt) for elt in node.elts) + if isinstance(node, ast.Set): + return all(expression_is_smoke_safe(elt) for elt in node.elts) + if isinstance(node, ast.Dict): + return all( + expression_is_smoke_safe(key) and expression_is_smoke_safe(value) + for key, value in zip(node.keys, node.values) + ) + if isinstance(node, ast.UnaryOp): + return expression_is_smoke_safe(node.operand) + if isinstance(node, ast.BinOp): + return expression_is_smoke_safe(node.left) and expression_is_smoke_safe(node.right) + if isinstance(node, ast.BoolOp): + return all(expression_is_smoke_safe(value) for value in node.values) + if isinstance(node, ast.Compare): + return expression_is_smoke_safe(node.left) and all( + expression_is_smoke_safe(comparator) for comparator in node.comparators + ) + if isinstance(node, ast.Subscript): + return expression_is_smoke_safe(node.value) and expression_is_smoke_safe(node.slice) + if isinstance(node, ast.Slice): + return ( + expression_is_smoke_safe(node.lower) + and expression_is_smoke_safe(node.upper) + and expression_is_smoke_safe(node.step) + ) + if isinstance(node, ast.IfExp): + return ( + expression_is_smoke_safe(node.test) + and expression_is_smoke_safe(node.body) + and expression_is_smoke_safe(node.orelse) + ) + if isinstance(node, ast.JoinedStr): + return all( + expression_is_smoke_safe(value.value) + if isinstance(value, ast.FormattedValue) + else expression_is_smoke_safe(value) + for value in node.values + ) + if isinstance(node, ast.FormattedValue): + return expression_is_smoke_safe(node.value) + return False + + +def statement_is_smoke_safe(node: ast.stmt) -> bool: + if isinstance(node, (ast.Import, ast.ImportFrom, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Pass)): + return True + if isinstance(node, ast.Assign): + return all(assignment_target_is_smoke_safe(target) for target in node.targets) and expression_is_smoke_safe(node.value) + if isinstance(node, ast.AnnAssign): + return assignment_target_is_smoke_safe(node.target) and expression_is_smoke_safe(node.value) + if isinstance(node, ast.AugAssign): + return assignment_target_is_smoke_safe(node.target) and expression_is_smoke_safe(node.value) + if isinstance(node, ast.Expr): + return expression_is_smoke_safe(node.value) + if isinstance(node, ast.Try): + return ( + all(statement_is_smoke_safe(stmt) for stmt in node.body) + and all( + expression_is_smoke_safe(handler.type) + and all(statement_is_smoke_safe(stmt) for stmt in handler.body) + for handler in node.handlers + ) + and all(statement_is_smoke_safe(stmt) for stmt in node.orelse) + and all(statement_is_smoke_safe(stmt) for stmt in node.finalbody) + ) + if isinstance(node, ast.If): + return ( + expression_is_smoke_safe(node.test) + and all(statement_is_smoke_safe(stmt) for stmt in node.body) + and all(statement_is_smoke_safe(stmt) for stmt in node.orelse) + ) + return False + + +def is_smoke_safe_code_cell(source: str) -> bool: + cleaned = python_source_for_ast(source) + if not cleaned.strip(): + return True + try: + tree = ast.parse(cleaned) + except SyntaxError: + return False + return all(statement_is_smoke_safe(statement) for statement in tree.body) + + +def build_smoke_notebook(notebook_path: Path, cells_after_bootstrap: int) -> tuple[dict, list[int | None]]: + with notebook_path.open(encoding="utf-8") as handle: + original_nb = json.load(handle) + + bootstrap_idx = next( + (idx for idx, cell in enumerate(original_nb["cells"]) if is_bootstrap_cell(cell)), + None, + ) + if bootstrap_idx is None: + raise RuntimeError("missing Colab bootstrap cell") + + stop_idx = bootstrap_idx + safe_code_cells = 0 + for idx in range(bootstrap_idx + 1, len(original_nb["cells"])): + cell = original_nb["cells"][idx] + if cell.get("cell_type") != "code": + stop_idx = idx + continue + if safe_code_cells >= cells_after_bootstrap: + break + if not is_smoke_safe_code_cell(cell_source_text(cell)): + break + safe_code_cells += 1 + stop_idx = idx + + temp_cells = [make_prelude_cell(notebook_path)] + source_indices: list[int | None] = [None] + + for idx, cell in enumerate(original_nb["cells"][: stop_idx + 1]): + cloned = copy.deepcopy(cell) + cloned["id"] = f"smoke-{idx}" + if cloned.get("cell_type") == "code": + cloned["source"] = rewrite_bootstrap_source(cell_source_text(cloned)) + cloned["execution_count"] = None + cloned["outputs"] = [] + temp_cells.append(cloned) + source_indices.append(idx) + + smoke_nb = { + "cells": temp_cells, + "metadata": copy.deepcopy(original_nb.get("metadata", {})), + "nbformat": original_nb.get("nbformat", 4), + "nbformat_minor": original_nb.get("nbformat_minor", 5), + } + return smoke_nb, source_indices + + +def execute_smoke_notebook(notebook_path: Path, smoke_nb: dict, source_indices: list[int | None], timeout: int) -> None: + try: + from testbook import testbook + except ImportError as exc: # pragma: no cover - depends on the local environment + raise RuntimeError( + "testbook is required for Colab smoke tests. " + "Install test dependencies, e.g. `pip install -e .[test]`." + ) from exc + + notebook_dir = notebook_path.parent.resolve() + with tempfile.NamedTemporaryFile( + suffix=".ipynb", + prefix=".tmp_colab_smoke_", + dir=notebook_dir, + delete=False, + ) as handle: + temp_path = Path(handle.name) + + try: + with temp_path.open("w", encoding="utf-8") as handle: + json.dump(smoke_nb, handle) + + original_cwd = Path.cwd() + try: + os.chdir(notebook_dir) + with testbook(temp_path.as_posix(), timeout=timeout, execute=False) as tb: + for temp_idx, cell in enumerate(tb.cells): + if cell.cell_type != "code": + continue + try: + tb.execute_cell(temp_idx) + except Exception as exc: # noqa: BLE001 + source_idx = source_indices[temp_idx] + if source_idx is None: + location = "prelude cell" + else: + location = f"notebook cell {source_idx + 1}" + detail = (str(exc).strip().splitlines() or ["(no message)"])[-1] + detail = re.sub(r"\x1b\[[0-9;]*m", "", detail) # strip ANSI from tracebacks + raise RuntimeError( + f"Colab smoke failed in {location}: {type(exc).__name__}: {detail}" + ) from exc + finally: + os.chdir(original_cwd) + finally: + if temp_path.exists(): + temp_path.unlink() + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Run lightweight Colab readiness smoke tests for enabled notebooks." + ) + parser.add_argument( + "--manifest", + default=str(DEFAULT_MANIFEST), + help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})", + ) + parser.add_argument( + "--cells-after-bootstrap", + type=int, + default=2, + help="Maximum number of smoke-safe code cells to execute after the bootstrap cell (default: 2)", + ) + parser.add_argument( + "--timeout", + type=int, + default=600, + help="Per-notebook execution timeout in seconds (default: 600)", + ) + parser.add_argument( + "--notebook", + action="append", + default=[], + help="Optional manifest-relative notebook path to smoke test. May be passed multiple times.", + ) + return parser.parse_args() + + +def smoke_test_batch( + notebook_rels: list[str], cells_after_bootstrap: int, timeout: int +) -> tuple[list[str], list[tuple[str, str]]]: + passed: list[str] = [] + failed: list[tuple[str, str]] = [] + for notebook_rel in notebook_rels: + notebook_path = (REPO_ROOT / notebook_rel).resolve() + print(f"Smoke testing {notebook_rel}") + try: + smoke_nb, source_indices = build_smoke_notebook( + notebook_path, cells_after_bootstrap + ) + execute_smoke_notebook( + notebook_path, smoke_nb, source_indices, timeout=timeout + ) + except Exception as exc: # noqa: BLE001 + reason = str(exc).strip() or type(exc).__name__ + failed.append((notebook_rel, reason)) + else: + passed.append(notebook_rel) + return passed, failed + + +def main() -> int: + args = parse_args() + manifest_path = Path(args.manifest).resolve() + manifest = load_json(manifest_path) + enabled = list(manifest.get("enabled", [])) + + if args.notebook: + enabled = [path for path in enabled if path in set(args.notebook)] + + if not enabled: + print("No enabled notebooks selected for Colab smoke tests.") + return 0 + + try: + import testbook # noqa: F401 + except ImportError: + print( + "testbook is required for Colab smoke tests. " + "Install test dependencies, e.g. `pip install -e .[test]`." + ) + return 1 + + passed, failed = smoke_test_batch(enabled, args.cells_after_bootstrap, args.timeout) + + if failed: + print("") + print("Failed:") + for notebook_rel, reason in failed: + print(f"- {notebook_rel}: {reason}") + print("") + print( + f"Colab smoke tests: {len(passed)} passed, {len(failed)} failed, {len(enabled)} total." + ) + return 0 if not failed else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/test/README.md b/test/README.md index 1120146dc..0a243c785 100644 --- a/test/README.md +++ b/test/README.md @@ -14,6 +14,13 @@ This document describes the available test targets in the Makefile for QMCSoftwa | `make doctests` | All doctests with Docker | Slow | Full docstring validation | | `make booktests_no_docker` | Jupyter notebook tests | Slow | Validate demo notebooks | | `make booktests_parallel_no_docker` | Notebook tests with Parsl parallelization | Variable | Distributed notebook execution | +| `make check_colab_notebooks` | Audit enabled notebooks for Colab-readiness | Fast | Catch missing pip installs, repo-local imports, and source-install drift | +| `make check_colab_notebooks_smoke` | Execute Colab notebook setup smoke tests | Fast | Run bootstrap plus early import/setup cells for enabled notebooks | +| `make harden_colab_notebook [NOTEBOOK=...]` | Insert Colab bootstrap and classify notebook(s) | Fast | Harden one notebook, or attempt to harden unclassified demo notebooks | +| `make report_colab_notebook_patterns` | Group notebooks by Colab bootstrap family | Fast | Audit which notebooks use basic, extra-pip, LaTeX, or repo-local setup cells | +| `make open_colab_notebook NOTEBOOK=...` | Open a notebook in Colab from the current branch | Fast | Preview branch-only notebook changes in Colab before merge | +| `make open_colab_notebook_gist NOTEBOOK=...` | Upload the working-tree notebook to a secret gist and open it in Colab | Fast | Preview uncommitted notebook edits in Colab (needs `gh`) | +| `make open_notebook NOTEBOOK=...` | Open the working-tree notebook in local JupyterLab | Instant | Edit/run a demo notebook locally with full repo context | | `make coverage` | Display coverage report | Instant | View test coverage summary | | `make delcoverage` | Reset coverage tracking | Instant | Start fresh coverage analysis | @@ -146,11 +153,6 @@ Runs notebook tests with **Parsl distributed parallelization** for compute-heavy - **Dependencies**: Parsl must be installed and configured - **Use when**: Running large notebook suites with distributed compute resources -#### `make tests_parallel_no_docker` -Runs only unit tests with parallel pytest workers (no doctests or booktests). -- **Time**: ~13–20 seconds -- **Coverage**: Incremental -- **Use when**: Testing unit tests only in parallel mode --- @@ -166,6 +168,72 @@ Auto-generates missing test stub files for notebooks. - **Output**: Reports any generated files - **Note**: Called automatically by `booktests_no_docker`; rarely used standalone +#### `make check_colab_notebooks` +Runs the strict static Colab-readiness checks. +- **Behavior**: Validates the manifest, badge and bootstrap placement, early dependencies, and repo-local imports +- **Use when**: You change a demo notebook or its Colab setup + +#### `make check_colab_notebooks_smoke` +Runs a lightweight execution smoke test for each Colab-enabled notebook. +- **Execution scope**: Simulates a Colab runtime, rewrites shell install commands to no-ops, then executes the bootstrap cell plus up to `$(SMOKE_CODE_CELLS)` smoke-safe import/setup code cells +- **Purpose**: Catch runtime regressions in early import/setup logic that static checks miss +- **CI usage**: Invoked in Linux CI after test dependencies are installed +- **Default depth**: `SMOKE_CODE_CELLS=2` + +#### `make harden_colab_notebook [NOTEBOOK=...]` +Hardens one notebook, or if `NOTEBOOK` is omitted, scans `demos/` for notebooks that are not yet listed in either `enabled` or `disabled`. +- **What it does**: Inserts the badge, adds a generated Colab bootstrap cell, infers common extra pip dependencies, and adds repo-local `sys.path` setup when needed +- **Classification rule**: Existing `disabled` entries are left untouched; unclassified notebooks are added to `enabled` only after hardening validates. Failures remain unclassified for manual review +- **Force mode**: `make harden_colab_notebook FORCE=1` regenerates the Open in Colab badge and the `# @title Execute this cell to install dependencies` cell for every notebook already listed in `enabled`; `make harden_colab_notebook NOTEBOOK=... FORCE=1` does the same for one notebook +- **Cell order**: The generated `import google.colab` bootstrap cell is always inserted after the Open in Colab badge +- **Validation**: Runs the existing Colab checks after rewriting; if validation fails, the notebook and manifest are restored and the failure is reported +- **Examples**: `make harden_colab_notebook NOTEBOOK=demos/plot_proj_function.ipynb`, `make harden_colab_notebook`, and `make harden_colab_notebook FORCE=1` + +#### `make report_colab_notebook_patterns` +Groups notebooks already classified in `scripts/colab_notebooks_manifest.json` by the current Colab badge/bootstrap cell pattern. +- **Pattern families**: Reports basic `qmcpy`-only bootstrap cells, extra-pip variants, LaTeX setup cells, repo-clone/path-setup cells, and disabled notebooks grouped by reason +- **Dependency details**: Lists extra install commands for notebooks that need more than `qmcpy` +- **Placement summary**: Reports where the badge and bootstrap cells appear, for example `badge cell 1, bootstrap cell 2` +- **Use when**: You want to batch-normalize notebook Colab setup or review which notebooks will be affected by bootstrap changes + +Every enabled notebook, grouped by its Colab bootstrap pattern family (regenerate with `make report_colab_notebook_patterns`): + +- **Basic qmcpy bootstrap** (28): [acceptance_rejection.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb), [asian-option-mlqmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb), [brownian_bridge.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb), [control_variates.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/control_variates.ipynb), [copula_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/copula_examples.ipynb), [Iteration_Log_Tolerance_Demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb), [digital_net_b2.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/digital_net_b2.ipynb), [gaussian_diagnostics_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb), [korobov_hammersley_latinhypercube_demos.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/korobov_hammersley_latinhypercube_demos.ipynb), [lattice_random_generator.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lattice_random_generator.ipynb), [lebesgue_integration.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lebesgue_integration.ipynb), [linear-scrambled-halton.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/linear-scrambled-halton.ipynb), [nei_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/nei_demo.ipynb), [plot_proj_function.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/plot_proj_function.ipynb), [pricing_options.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/pricing_options.ipynb), [product_measure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/product_measure.ipynb), [qei-demo-for-blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qei-demo-for-blog.ipynb), [qmcpy-logo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy-logo.ipynb), [qmcpy_intro.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb), [quickstart.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb), [ray_tracing.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/ray_tracing.ipynb), [sample_scatter_plots.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/sample_scatter_plots.ipynb), [scipywrapper_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb), [some_true_measures.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/some_true_measures.ipynb), [statistics_for_TrueMeasure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/statistics_for_TrueMeasure.ipynb), [sorokin_thesis_2025.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb), [pydata_chi_2023.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/pydata_chi_2023.ipynb), [why_add_q_to_mc_blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb) +- **Extra pip bootstrap** (4): [iris.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb), [joss2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/JOSS2026/joss2026.ipynb), [MCQMC_2020_QMC_Software_Tutorial.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb), [Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb) +- **LaTeX bootstrap** (4): [dakota_genz.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/DAKOTA_Genz/dakota_genz.ipynb), [elliptic-pde.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/elliptic-pde.ipynb), [vectorized_qmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc.ipynb), [vectorized_qmc_bayes.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc_bayes.ipynb) +- **Repo-local bootstrap** (7): [gbm_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_examples.ipynb), [accuracy_and_resume.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/accuracy_and_resume.ipynb), [resume_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/resume_examples.ipynb), [01_sequential.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb), [02_parallel.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb), [03_visualize_speedup.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb), [01_sequential_output.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb) +- **Repo-local bootstrap + extra pip installs** (1): [gbm_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_demo.ipynb) + +### Opening a demo notebook + +| Target | Notebook source | Opens in | Requires | +|--------|-----------------|----------|----------| +| `make open_notebook` | working tree | local JupyterLab | `jupyterlab` | +| `make open_colab_notebook` | `origin/` (or `` when unchanged) | Google Colab | branch + notebook pushed to `origin` | +| `make open_colab_notebook_gist` | working tree | Google Colab | `gh` CLI | + +#### `make open_colab_notebook NOTEBOOK=demos/.ipynb` +Opens a demo notebook in Google Colab from the **current git branch** instead of the committed `develop` badge URL, so you can preview branch-only notebook changes in Colab before they merge. +- **When it uses the branch**: The Colab link points at the current branch when the notebook is new on the branch, or when its content on `origin/` differs from `origin/`; otherwise it opens the `` version, since the committed badge already covers that case +- **Requires a push**: Colab loads notebooks from GitHub, so the branch and the notebook must already be pushed to `origin`; the target stops with a hint if they are not, and warns when your local working copy differs from what is pushed +- **Base branch**: The comparison base is `COLAB_BASE` (default `develop`) and must itself be a branch on `origin` +- **Output**: Prints the `https://colab.research.google.com/github///blob//` URL and opens it with `python -m webbrowser` +- **Examples**: `make open_colab_notebook NOTEBOOK=demos/nei_demo.ipynb`, `make open_colab_notebook NOTEBOOK=demos/GBM/gbm_demo.ipynb COLAB_BASE=master` + +#### `make open_colab_notebook_gist NOTEBOOK=demos/.ipynb` +Uploads the **working-tree** copy of a notebook to a throwaway secret GitHub gist and opens that gist in Colab, so you can preview uncommitted edits without pushing to a branch. +- **Requires**: The [`gh` CLI](https://cli.github.com), authenticated with `gh auth login` +- **What it prints**: The gist URL, the `https://colab.research.google.com/gist///` URL (also opened with `python -m webbrowser`), and the `gh gist delete ` cleanup command +- **Gist visibility**: "secret" means unlisted, not private; delete it when finished +- **Limitation**: A gist is a single file, so sibling `.py` helpers and repo-local imports will not resolve; the bootstrap cell's `git clone` falls back to `develop`. Use `make open_colab_notebook` for notebooks that depend on repo files +- **Example**: `make open_colab_notebook_gist NOTEBOOK=demos/quickstart.ipynb` + +#### `make open_notebook NOTEBOOK=demos/.ipynb` +Opens the working-tree notebook in local JupyterLab (`jupyter lab `, falling back to `python -m jupyterlab`). +- **Use when**: You want to edit or run a demo notebook locally with the current source install, helper files, and uncommitted changes all in place +- **Note**: Runs the Lab server in the foreground; stop it with `Ctrl+C` +- **Example**: `make open_notebook NOTEBOOK=demos/quickstart.ipynb` + #### `make coverage` Displays the current coverage report (must run other targets first to accumulate coverage data). - **Output**: Terminal summary of coverage percentages per file/module @@ -175,15 +243,6 @@ Displays the current coverage report (must run other targets first to accumulate Deletes `.coverage` and `coverage.json` files to reset coverage tracking. - **Use before**: Running a fresh coverage report without accumulated data -## Redundancy Analysis & Status - -### Removed Redundant Target ✅ - -#### `make tests_parallel_no_docker` (REMOVED) -- **Was redundant**: Ran only unit tests in parallel. `make tests_fast` is a strict superset (doctests + unittests + booktests in parallel). -- **Status**: **Removed from Makefile** to simplify maintenance and reduce user confusion. -- **Migration**: Users should use `make tests_fast` instead (faster, more comprehensive). - --- ## Currently Active Targets: Justification @@ -409,4 +468,4 @@ A second workflow, `.github/workflows/unittests.yml`, runs a matrix across Pytho - `.github/workflows/alltests.yml` – CI all test workflow - `.github/workflows/unittests.yml` - CI unit test workflow - `make clean_local_only_files` – Artifact cleanup utility -- `scripts/pytest_xdist.py` – Parallel execution detection helper \ No newline at end of file +- `scripts/pytest_xdist.py` – Parallel execution detection helper diff --git a/test/booktests/__init__.py b/test/booktests/__init__.py index 2ad77b1fe..a28ec9790 100644 --- a/test/booktests/__init__.py +++ b/test/booktests/__init__.py @@ -3,18 +3,27 @@ Each tb_*.py file tests a single demo notebook. """ -import unittest, gc -from pathlib import Path -import psutil import gc -import time import os import subprocess import sys +import tempfile +import time +import unittest +import uuid +from pathlib import Path + +import psutil from testbook import testbook import nbformat + +if os.name == "nt": + worker_id = os.environ.get("PYTEST_XDIST_WORKER", "main") + mpl_config_dir = Path(tempfile.gettempdir()) / "qmcpy-matplotlib" / worker_id + mpl_config_dir.mkdir(parents=True, exist_ok=True) + os.environ.setdefault("MPLCONFIGDIR", str(mpl_config_dir)) + import matplotlib -import uuid matplotlib.rcParams["text.usetex"] = False # Disable LaTeX diff --git a/test/test_colab_notebooks.py b/test/test_colab_notebooks.py new file mode 100644 index 000000000..858c4c4b9 --- /dev/null +++ b/test/test_colab_notebooks.py @@ -0,0 +1,314 @@ +from __future__ import annotations + +import json +import os +import sys +from pathlib import Path + +import pytest + +from scripts import check_colab_notebooks as check +from scripts import harden_colab_notebook as harden +from scripts import smoke_test_colab_notebooks as smoke + + +def markdown_cell(source: str, cell_id: str = "markdown") -> dict: + return { + "cell_type": "markdown", + "id": cell_id, + "metadata": {}, + "source": source.splitlines(keepends=True), + } + + +def code_cell(source: str, cell_id: str = "code") -> dict: + return { + "cell_type": "code", + "execution_count": None, + "id": cell_id, + "metadata": {}, + "outputs": [], + "source": source.splitlines(keepends=True), + } + + +@pytest.fixture +def colab_repo(tmp_path: Path, monkeypatch: pytest.MonkeyPatch): + demos_dir = tmp_path / "demos" + demos_dir.mkdir() + notebook_path = demos_dir / "example.ipynb" + notebook = { + "cells": [ + markdown_cell("# Example\n", "title"), + code_cell("import math\n", "imports"), + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5, + } + notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8") + + manifest_path = tmp_path / "manifest.json" + manifest = { + "repo": "QMCSoftware/QMCSoftware", + "git_ref": "develop", + "enabled": [], + "disabled": {}, + } + manifest_path.write_text(json.dumps(manifest, indent=1) + "\n", encoding="utf-8") + + monkeypatch.setattr(check, "REPO_ROOT", tmp_path) + monkeypatch.setattr(check, "DEMOS_DIR", demos_dir) + monkeypatch.setattr(harden, "REPO_ROOT", tmp_path) + monkeypatch.setattr(smoke, "REPO_ROOT", tmp_path) + return notebook_path, manifest_path + + +def test_badge_stripping_preserves_intro_and_drops_badge_only_cells(): + intro = markdown_cell( + "# ML Sensitivity Indices\n\n" + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]" + "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/" + "blob/develop/demos/iris.ipynb)\n\n" + "This notebook demonstrates sensitivity indices.\n" + ) + badge_only = markdown_cell( + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]" + "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/" + "blob/develop/demos/iris.ipynb)\n" + ) + + cleaned_intro = harden.badge_stripped_cell(intro) + assert cleaned_intro is not None + assert "# ML Sensitivity Indices" in check.cell_source_text(cleaned_intro) + assert "sensitivity indices" in check.cell_source_text(cleaned_intro) + assert "Open In Colab" not in check.cell_source_text(cleaned_intro) + assert harden.remove_any_badge_cells([badge_only, code_cell("pass\n")]) == [ + code_cell("pass\n") + ] + + +def test_is_any_badge_cell_rejects_spoofed_hostname(): + spoofed = markdown_cell( + "[click](https://evil.example/colab.research.google.com/assets/colab-badge.svg)\n" + ) + genuine = markdown_cell( + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]" + "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/" + "blob/develop/demos/iris.ipynb)\n" + ) + + assert not check.is_any_badge_cell(spoofed) + assert check.is_any_badge_cell(genuine) + + +def test_bootstrap_detection_uses_marker_and_real_install_command( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + misleading = code_cell( + '"""import google.colab\n# @title Execute this cell to install dependencies\n' + '!pip install qmcpy\n"""\n' + ) + comment_only = code_cell( + "# @title Execute this cell to install dependencies\n" + "# import google.colab\n" + "# !pip install qmcpy\n" + ) + assert not check.is_any_install_cell(misleading) + assert not check.is_bootstrap_cell(misleading) + assert check.is_any_install_cell(comment_only) + assert not check.is_bootstrap_cell(comment_only) + + monkeypatch.setattr(harden, "REPO_ROOT", tmp_path) + notebook_path = tmp_path / "demos" / "example.ipynb" + notebook_path.parent.mkdir() + source = "".join( + harden.bootstrap_cell_source( + notebook_path, + {"repo": "QMCSoftware/QMCSoftware"}, + [], + ) + ) + generated = code_cell(source) + assert check.is_bootstrap_cell(generated) + assert "except ImportError:" in source + assert "if IN_COLAB:" in source + assert "except:\n" not in source + compile(smoke.rewrite_shell_magics(source), "", "exec") + + +def test_extra_pip_packages_preserves_later_explicit_installs(): + cells = [ + code_cell("import qmcpy as qp\n"), + code_cell("import ipywidgets as widgets\n"), + code_cell( + "try:\n" + " import QuantLib as ql\n" + "except ModuleNotFoundError:\n" + " !pip install -q QuantLib\n" + ), + code_cell("!pip install -q seaborn\n"), + ] + + assert harden.extra_pip_packages(cells) == ["QuantLib", "ipywidgets", "seaborn"] + + +def test_needs_latex_setup_detects_tueplots(): + cells = [ + code_cell("import qmcpy as qp\n"), + code_cell( + "from tueplots import bundles\n" + "pyplot.rcParams.update(bundles.probnum2025())\n" + ), + ] + + assert harden.needs_latex_setup(cells) + + +def test_imported_modules_survives_magic_only_block_body(): + # A shell-magic line as the *only* statement in a block used to leave an + # empty `if:`/`try:` body, making ast.parse raise and silently hiding + # every import in the cell (not just the magic line itself). + source = ( + "import os\n" + "from util import helper\n" + "if True:\n" + " !echo hi\n" + ) + assert check.imported_modules(source) == {"os", "util"} + + +def test_local_module_matches_finds_ancestor_directory( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + monkeypatch.setattr(check, "DEMOS_DIR", tmp_path) + (tmp_path / "util.py").write_text("", encoding="utf-8") + notebook_dir = tmp_path / "output" + notebook_dir.mkdir() + + matches = check.local_module_matches(notebook_dir, "util") + + assert matches == [tmp_path / "util.py"] + + +def test_extra_pip_packages_honors_colab_deps_marker(): + cells = [ + code_cell("import qmcpy as qp\n"), + code_cell( + "# colab-deps: plotly, some-package\n" + "import plotly\n" + ), + ] + + assert harden.extra_pip_packages(cells) == ["plotly", "some-package"] + + +def test_dump_notebook_preserves_existing_json_indent(tmp_path: Path): + notebook_path = tmp_path / "example.ipynb" + notebook = { + "cells": [code_cell("pass\n")], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5, + } + original_source = json.dumps(notebook, indent=2) + "\n" + + harden.dump_notebook(notebook_path, notebook, original_source) + + assert notebook_path.read_text(encoding="utf-8") == original_source + + +def test_harden_check_smoke_round_trip_is_idempotent( + colab_repo, monkeypatch: pytest.MonkeyPatch +): + notebook_path, manifest_path = colab_repo + harden.harden_notebook(notebook_path, manifest_path) + + assert check.run_check(manifest_path, strict=True) == 0 + smoke_notebook, source_indices = smoke.build_smoke_notebook(notebook_path, 1) + assert len(smoke_notebook["cells"]) == len(source_indices) + + sentinel = object() + old_modules = { + name: sys.modules.get(name, sentinel) for name in ("google", "google.colab") + } + old_environment = { + name: os.environ.get(name, sentinel) + for name in ("QMC_COLAB_SMOKE", "QMC_COLAB_SMOKE_REPO_ROOT", "QMC_COLAB_SMOKE_NOTEBOOK_DIR") + } + namespace: dict = {} + try: + for cell in smoke_notebook["cells"]: + if cell["cell_type"] == "code": + exec(check.cell_source_text(cell), namespace) + finally: + for name, value in old_modules.items(): + if value is sentinel: + sys.modules.pop(name, None) + else: + sys.modules[name] = value + for name, value in old_environment.items(): + if value is sentinel: + os.environ.pop(name, None) + else: + os.environ[name] = value + + monkeypatch.setattr( + harden, + "dump_notebook", + lambda *_args, **_kwargs: pytest.fail("unchanged notebook was rewritten"), + ) + monkeypatch.setattr( + harden, + "dump_json", + lambda *_args, **_kwargs: pytest.fail("unchanged manifest was rewritten"), + ) + harden.harden_notebook(notebook_path, manifest_path) + + +def test_checker_rejects_wrong_badge(colab_repo): + notebook_path, manifest_path = colab_repo + harden.harden_notebook(notebook_path, manifest_path) + notebook = check.load_json(notebook_path) + badge = next(cell for cell in notebook["cells"] if check.is_any_badge_cell(cell)) + badge["source"] = [check.cell_source_text(badge).replace("develop", "wrong-ref")] + notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8") + + assert check.run_check(manifest_path, strict=True) == 1 + + +def test_harden_failure_does_not_disable_notebook( + colab_repo, monkeypatch: pytest.MonkeyPatch +): + notebook_path, manifest_path = colab_repo + original_manifest = manifest_path.read_text(encoding="utf-8") + monkeypatch.setattr( + harden, + "harden_notebook", + lambda *_args, **_kwargs: (_ for _ in ()).throw(RuntimeError("failure")), + ) + + successes, failures = harden.harden_batch([notebook_path], manifest_path) + + assert successes == [] + assert failures == [("demos/example.ipynb", "failure")] + assert manifest_path.read_text(encoding="utf-8") == original_manifest + + +def test_smoke_batch_continues_after_a_notebook_failure(monkeypatch: pytest.MonkeyPatch): + def fake_build(notebook_path: Path, cells_after_bootstrap: int): + return {"cells": []}, [] + + def fake_execute(notebook_path: Path, smoke_nb, source_indices, timeout): + if "broken" in notebook_path.as_posix(): + raise RuntimeError("boom") + + monkeypatch.setattr(smoke, "build_smoke_notebook", fake_build) + monkeypatch.setattr(smoke, "execute_smoke_notebook", fake_execute) + + passed, failed = smoke.smoke_test_batch( + ["demos/broken.ipynb", "demos/ok.ipynb"], cells_after_bootstrap=1, timeout=60 + ) + + assert passed == ["demos/ok.ipynb"] + assert failed == [("demos/broken.ipynb", "boom")] From 3c285bb4744a77e3be779f6d447451fed160e5e5 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 11:25:42 +0800 Subject: [PATCH 03/14] Remove unreferenced file --- pyproject.toml | 1 - .../kron_vector_d-100_N-2exp20_2026_06_01.txt | 100 ------------------ 2 files changed, 101 deletions(-) delete mode 100644 qmcpy/discrete_distribution/kronecker/generating_vectors/kron_vector_d-100_N-2exp20_2026_06_01.txt diff --git a/pyproject.toml b/pyproject.toml index 1e082e593..dac48d235 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -179,7 +179,6 @@ includes = [ "qmcpy/discrete_distribution/generating_params/korobov_p2_table.npz", "qmcpy/discrete_distribution/digital_net_b2/generating_matrices/*.npy", "qmcpy/discrete_distribution/lattice/generating_vectors/*.npy", - "qmcpy/discrete_distribution/kronecker/generating_vectors/*.txt", "qmcpy/util/qmcpy.mplstyle", ] excludes = [] diff --git a/qmcpy/discrete_distribution/kronecker/generating_vectors/kron_vector_d-100_N-2exp20_2026_06_01.txt b/qmcpy/discrete_distribution/kronecker/generating_vectors/kron_vector_d-100_N-2exp20_2026_06_01.txt deleted file mode 100644 index 098e8d858..000000000 --- a/qmcpy/discrete_distribution/kronecker/generating_vectors/kron_vector_d-100_N-2exp20_2026_06_01.txt +++ /dev/null @@ -1,100 +0,0 @@ -0.618033988749895 -0.3173225474723 -0.59332263014446 -0.20776441643926 -0.27373719258623 -0.649734278361753 -0.478954018631769 -0.86866022435182 -0.22845082022244 -0.581365429377986 -0.282365231829842 -0.0822850909119904 -0.223849641007295 -0.5770772201756 -0.51769659336634 -0.568025390904592 -0.156782234569368 -0.82246227056154 -0.805675312097409 -0.63877102813393 -0.358300563495856 -0.241741343018598 -0.705003192174204 -0.1931911954956 -0.261022001488623 -0.897938992038015 -0.46839743115877 -0.884022067965329 -0.752352896871505 -0.1601583600427 -0.10727599509739 -0.151478435512877 -0.163863657127101 -0.948303450359399 -0.80350943597439 -0.426371623468333 -0.435930910910882 -0.21329852459791 -0.661698149534002 -0.900679822160453 -0.122436710671457 -0.483663584095611 -0.928181067731583 -0.443143014606576 -0.74491332336194 -0.87948409225588 -0.0428242449803 -0.534576896789579 -0.24340042100879 -0.30424418245585 -0.574003104342617 -0.897289023268963 -0.541424476559586 -0.356895660350464 -0.507567280910795 -0.513983550428507 -0.0610821922457415 -0.183871471606587 -0.446015178033969 -0.455684287415085 -0.280817534817491 -0.115220095666085 -0.433740673279323 -0.515605957977756 -0.113076735656464 -0.733928297688305 -0.0597515651584137 -0.422268695684775 -0.0979181139173599 -0.213699261322352 -0.866811679881922 -0.0878569329036737 -0.678412735893121 -0.181093969536107 -0.128913741473518 -0.109341703717108 -0.289067270578427 -0.352218331663839 -0.303605902333137 -0.0613899204730832 -0.959535877660851 -0.475508309069064 -0.688698902674194 -0.657037932118495 -0.645555897563869 -0.720658665263604 -0.914423387894897 -0.425763295044487 -0.328825255006553 -0.892452975558004 -0.16973367306396 -0.912292406867098 -0.0923260018966512 -0.216301713289429 -0.147861410064151 -0.8600781655845 -0.752129792595509 -0.337431120990153 -0.542476014178907 -0.307279789725491 From b455c2ea22a7a588902090a98d5175037e50963a Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 11:26:47 +0800 Subject: [PATCH 04/14] Add notebook to documentation --- mkdocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/mkdocs.yml b/mkdocs.yml index 792731c47..47d9040cb 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -47,6 +47,7 @@ nav: - 2020 MCQMC Software Tutorial: demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb - Technical Examples: - 2023 Random Lattice Generating Vectors: demos/lattice_random_generator.ipynb + - Lattice and Kronecker Generating-Vector Search: demos/lattice_kronecker_methods.ipynb - 2022 Bayesian Cubature Stopping Criterion: demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb - 2020 Why Add Q to MC?: demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb - 2020 Bayesian Optimization Expected Improvement: From 1e76924bcf7423028340da8a33e0d477f7daaf0f Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 11:55:04 +0800 Subject: [PATCH 05/14] Remove trailing spaces --- qmcpy/discrete_distribution/kronecker/kronecker.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/qmcpy/discrete_distribution/kronecker/kronecker.py b/qmcpy/discrete_distribution/kronecker/kronecker.py index 0041269bf..d6a291498 100644 --- a/qmcpy/discrete_distribution/kronecker/kronecker.py +++ b/qmcpy/discrete_distribution/kronecker/kronecker.py @@ -285,7 +285,7 @@ def __init__(self, gen_vec = _richtmyer_generating_vector(self.dvec.max()+1) elif isinstance(generating_vector, str) and generating_vector.lower() == "suzuki": self.gen_vec_source = "SUZUKI" - gen_vec = _suzuki_generating_vector(self.dvec.max()+1) + gen_vec = _suzuki_generating_vector(self.dvec.max()+1) elif isinstance(generating_vector, str) and generating_vector.lower() == "cbc_mt": self.gen_vec_source = "CBC_MT" CBC_MT = np.array([0.618033988749895, @@ -459,7 +459,6 @@ def periodic_discrepancy(self, n, k_tilde=None, gamma=None): k_tilde = (lambda x, gamma: np.prod(1 + (x * (x - 1) + 1/6) * gamma, axis=-1), 1) return np.sqrt(self._square_periodic_discrepancies(n, k_tilde, gamma)) - def wssd_discrepancy(self, n, sample_weights, k_tilde = None, gamma = None): # calculates the weighted sum of square discrepancy @@ -472,7 +471,7 @@ def wssd_discrepancy(self, n, sample_weights, k_tilde = None, gamma = None): discrepancies = self._square_periodic_discrepancies(n, k_tilde, gamma) return np.sum(sample_weights * discrepancies, axis=-1) - + def _square_periodic_discrepancies(self, n, k_tilde, gamma): n_array = np.arange(1, n + 1) # we need the points without a random shift for the calculation, so we can't use self._gen_samples From 790f484bfb1b05856da18bb8dc5f996af4742c78 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 11:57:33 +0800 Subject: [PATCH 06/14] Make LVS deterministic --- .../lattice/lattice_vector_wssd_search.py | 38 +++++++++++-------- 1 file changed, 23 insertions(+), 15 deletions(-) diff --git a/qmcpy/discrete_distribution/lattice/lattice_vector_wssd_search.py b/qmcpy/discrete_distribution/lattice/lattice_vector_wssd_search.py index f95ac7f0d..bbbdb2db2 100644 --- a/qmcpy/discrete_distribution/lattice/lattice_vector_wssd_search.py +++ b/qmcpy/discrete_distribution/lattice/lattice_vector_wssd_search.py @@ -9,6 +9,7 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): d_max (int): The dimension of the lattice rule. coord_weights (array-like, optional): The coordinate weights used to compute the discrepancy. Defaults to j^(-2) for j=1,...,d_max. kernel (callable, optional): The kernel used to compute the discrepancy. Should accept a single argument and return a scalar. Defaults to the second Bernoulli polynomial. + Returns: gen_vec (array-like): The generating vector of the lattice that minimizes the WSSD. @@ -34,13 +35,13 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): Custom kernels >>> bernoulli6 = lambda x: x * (x * (-1/2 + x * (x * (5/2 + x * (-3 + x))))) + 1/42 - >>> gen_vec = lattice_vector_wssd_search(n_max=2**15, d_max=10, coord_weights=None, kernel=bernoulli6) - >>> gen_vec[0] - 1 - >>> len(gen_vec) - 10 + >>> lattice_vector_wssd_search(n_max=2**15, d_max=10, coord_weights=None, kernel=bernoulli6) + array([ 1, 12589, 12955, 12021, 25, 14249, 1949, 2487, 8893, + 14279]) - The algorithm in its current form is sensitive to differences in floating point precision across platforms, hence the lack of specificity in the previous example. This can cause differences in generator quality, though in my ad hoc testing it is usually not catastrophic. It was originally built on a Windows machine. + Ties in the WSSD score are broken by smallest candidate index (tolerance rtol = 1e-13), + so the vector is reproducible across platforms; a strongly degenerate kernel can still + depend on that tolerance, but the default Bernoulli polynomial is well conditioned. """ np.seterr(all='warn') @@ -55,7 +56,7 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): raise ValueError("coord_weights must be array-like") if not isinstance(n_max, int) or not isinstance(d_max, int): raise ValueError("n_max and d_max must be integers") - + if len(coord_weights) < d_max: raise ValueError("coord_weights must have length at least d_max") if n_max < 8: @@ -64,6 +65,8 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): raise ValueError("d_max must be at least 1") m = np.ceil(np.log2(n_max)).astype(int) + if d_max > 2**(m - 2): + raise ValueError("d_max exceeds the CBC candidate pool for this n_max; increase n_max") # ---------------------------------------------------------------------- # Set up rhovector - how often each value appears @@ -93,7 +96,7 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): gRows = np.ones(2**(m - 1), dtype=int) # gRows determines* ordering of cols to have circulant matrix gRows[-1] = 0 - rowVects = np.ones(2**m - 1, dtype=int) # rowVects + rowVects = np.ones(2**m - 1, dtype=int) # rowVects gStrtIdx = 0 vStrtIdx = 0 @@ -118,7 +121,7 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): rowVects[-1] = 2**(m - 1) # ---------------------------------------------------------------------- - # Set up prodV - where we store information about previous components + # Set up prodV - where we store information about previous components # ---------------------------------------------------------------------- prodV = np.ones((2**m - 1, 1)) prodV = prodV * rhovectorNx1 @@ -134,6 +137,12 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): # ---------------------------------------------------------------------- # Begin search # ---------------------------------------------------------------------- + def best_index(scores): + # smallest index among (near-)tied minima -> reproducible across platforms, since + # bit-level FFT/FMA differences can otherwise flip which near-equal score is the min + lo = scores.min() + return int(np.flatnonzero(scores <= lo + 1e-13 * abs(lo))[0]) + gen_vec = np.ones(d_max, dtype=int) for hComp in range(2, d_max + 1): @@ -150,7 +159,7 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): prodIdx2 = prodIdx1 + 2**(l - 2) curRow = gRows[curIdx2:nextIdx2] - col = curRow / 2**l + col = curRow / 2**l fftCol = omega(col).astype(np.complex128) # first column of this circulant matrix block pCol = prodV[prodIdx1:prodIdx2, 0].astype(np.complex128) # corresponding section of prodV @@ -164,13 +173,12 @@ def lattice_vector_wssd_search(n_max, d_max, coord_weights=None, kernel=None): wssd = wssd + omega(1 / 2) * prodV[-1, 0] # not actually wssd; we avoid subtracting a constant to save precision - bestIdx = np.uint64(np.argmin(wssd)) - newH = np.uint64(gR[bestIdx]) + bestIdx = best_index(wssd) + newH = int(gR[bestIdx]) - # Avoid duplicates - while newH in gen_vec: + while newH in gen_vec: # avoid duplicates wssd[bestIdx] = np.inf - bestIdx = np.uint64(np.argmin(wssd)) + bestIdx = best_index(wssd) newH = int(gR[bestIdx]) gen_vec[hComp - 1] = newH From f3b15a60dbb3046303f02a5202225b5a508c1bca Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 12:07:02 +0800 Subject: [PATCH 07/14] Optimized k_const computations. Reduce memory usage. Add custom kernel input to wssd method. --- .../discrete_distribution/lattice/lattice.py | 41 ++++++++----------- 1 file changed, 17 insertions(+), 24 deletions(-) diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py index 451a5aa80..21762df44 100644 --- a/qmcpy/discrete_distribution/lattice/lattice.py +++ b/qmcpy/discrete_distribution/lattice/lattice.py @@ -437,40 +437,33 @@ def expected_squared_periodic_discrepancies(self, n_max, coord_weights=None, ker k_vector = k_vector.reshape(-1) # get the constant vector term of the summation - k_const = -1 + k_vector[0]*np.array([j**(-1) for j in range(1, n_max + 1)], dtype=np.float64) + k_const = -1 + k_vector[0] / np.arange(1, n_max + 1, dtype=np.float64) # group the kernel evaluations by powers of 2 k_sum = np.zeros(np.ceil(np.log2(n_max)).astype(int), dtype=np.float64) for i in range(k_sum.size): k_sum[i] = np.sum(k_vector[2**i:(2**(i+1))]) - # get the frequency matrix for how often each kernel evaluation appears - # this is always the same and can be precomputed, but for values of n_max large enough to matter (~ 2^25) - # the precomputed file is >1GB and would take longer to load than to compute - i = np.arange(2**k_sum.size) - pattern = np.zeros((k_sum.size, 2**k_sum.size), dtype=np.float64) # start with the pattern for the full power of two + # k_sum @ freq_mtx in O(n_max) memory: the shared 1/(j+1)**2 factor collapses the + # (log2(n_max), n_max) frequency matrix to cumsum(2*w) / (j+1)**2, with w[j] the sum + # of k_sum over the set bits of j. + idx = np.arange(n_max) + w = np.zeros(n_max, dtype=np.float64) for l in range(k_sum.size): - pattern[l] = ((i >> (l)) & 1) * 2 - - # truncate the matrix to the correct size, get the cumsum and divide by the square of the index - pattern = pattern[:, :n_max] - freq_mtx = np.cumsum(pattern, axis=1) - divisor = np.arange(1, n_max + 1) ** 2 - freq_mtx /= divisor - - # multiply by the frequency matrix and add the constant vector - discs = k_const + (k_sum @ freq_mtx) + w += k_sum[l] * ((idx >> l) & 1) + discs = k_const + np.cumsum(2.0 * w) / (idx + 1.0) ** 2 return discs - def wssd(self, n_max, coord_weights=None, sample_weights=None): + def wssd(self, n_max, coord_weights=None, sample_weights=None, kernel=None): """Returns the weighted sum of the expected squared periodic discrepancies for the first n_max points of the lattice sequence. - + Args: n_max (int): Number of points to calculate the weighted squared periodic discrepancy for. coord_weights (Union[None, np.ndarray]): Coordinate weights for the discrepancy calculation. If None, uses weights gamma_j = j^(-2). sample_weights (Union[None, np.ndarray]): Sample weights for the weighted squared periodic discrepancy calculation. If None, uses weights w_n = n. Note that the time cost may be higher for other sample weights. - + kernel (Union[None, Callable]): Kernel function for the discrepancy calculation. If None, uses the second bernoulli polynomial. + Returns: wssd (float): The weighted squared periodic discrepancy. """ @@ -478,12 +471,12 @@ def wssd(self, n_max, coord_weights=None, sample_weights=None): raise ValueError("Length of coord_weights must be greater than or equal to the dimension of the lattice") if coord_weights is not None: coord_weights = coord_weights[:self.d] - if sample_weights is not None and len(sample_weights) < n_max: - raise ValueError("Length of sample_weights must be at least n_max") + if sample_weights is not None and len(sample_weights) != n_max: + raise ValueError("Length of sample_weights must equal n_max") if sample_weights is None: sample_weights = np.arange(1, n_max + 1, dtype=np.float64) - discs = self.expected_squared_periodic_discrepancies(n_max, coord_weights=coord_weights) + discs = self.expected_squared_periodic_discrepancies(n_max, coord_weights=coord_weights, kernel=kernel) wssd = np.dot(sample_weights, discs) - - return wssd \ No newline at end of file + + return wssd From 84c6f9ff97515eebfb1820ae32c6aaac81fb712e Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 12:10:28 +0800 Subject: [PATCH 08/14] Resolved UnboundLocalError when calculating WSSD for d_max = 1. Improved warning for missing sympy. Better format. --- .../kronecker/kronecker_search_methods.py | 39 ++++++++++++------- 1 file changed, 25 insertions(+), 14 deletions(-) diff --git a/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py b/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py index ac5fccb4b..268fae01a 100644 --- a/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py +++ b/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py @@ -1,5 +1,9 @@ +import warnings + import numpy as np +from ...util import ParameterWarning + def kronecker_vector_search_mobius_transform(n_max, d_max, searchsize, kernel=None, coord_weights=None, gen_vec_init=None): """ Note that the sympy package is highly recommended for this search method, though not required. @@ -43,12 +47,12 @@ def kronecker_vector_search_mobius_transform(n_max, d_max, searchsize, kernel=No raise ValueError("d_max must be at least 1.") if coord_weights is not None and len(coord_weights) < d_max: raise ValueError("Length of coord_weights must be greater than or equal to d_max.") - + # the quadratic Bernoulli polynomial if kernel is None: kernel = lambda t: t * (t - 1) + 1/6 - + # define coordinate weights if not provided, default to j^(-2) if coord_weights is None: coord_weights = np.array([j**(-2) for j in range(1, d_max + 1)], dtype=np.float64) @@ -59,7 +63,11 @@ def kronecker_vector_search_mobius_transform(n_max, d_max, searchsize, kernel=No try: import sympy except ImportError: - print("While not required, installing the sympy package is recommended for this search method. It is used to compute the Bezout coefficients for the linear transformation used in the search. If sympy is not installed, the search will use a recursive and likely slower implementation of the Euclidean algorithm instead.") + warnings.warn( + "sympy is recommended for this search method: it computes the Bezout coefficients " + "for the linear transformation. Without it a slower recursive Euclidean algorithm is used.", + ParameterWarning, + ) has_sympy = False else: has_sympy = True @@ -83,7 +91,7 @@ def get_primes(n): primes.append(num) num += 1 return primes - + # search over the first n primes, n = searchsize searchspace = np.array(get_primes(searchsize), dtype=np.float64) @@ -95,7 +103,7 @@ def recursive_euclidean_algorithm(a, b): x = y1 y = x1 - (a // b) * y1 return x, y, gcd - + # gen_vec is our generating vector, will be found cbc gen_vec = np.zeros(d_max, dtype=np.float64) @@ -143,14 +151,14 @@ def recursive_euclidean_algorithm(a, b): t = gen_vec[0] * np.arange(1, n_max) % 1 # t vector is the vector of coordinates generated for the first dimension kPrev = 1 + coord_weights[0] * kernel(t) # gets the k vector for the first dimension, which is used in the wssd calculation and updated each dimension of the search. # The k vector is Ktilde(x_i) for i = 1,...,n_max-1, where Ktilde is the kernel and x_i are the points generated by the gen_vec vector, up to the current dimension. - + # the main search loop for dim in range(1, d_max): best_wssd = np.inf # stores the current wssd found for each dimension, initialized to infinity best_gen_vec = 0 # stores the current best gen_vec component found for this dimension, initialized to 0 best_k = None # stores the k vector for the current best gen_vec, used to update the k vector for the next dimension after the search is done for this dimension for i in range(searchsize): - p1 = searchspace[i] + p1 = searchspace[i] for j in range(searchsize): if j == i: # the two primes have to be distinct, so we skip this case continue @@ -170,13 +178,13 @@ def recursive_euclidean_algorithm(a, b): b1 = b d2 = np.abs(d + p2) b2 = np.abs(b - p1) - + gen_vec_dim1 = (p1 * gen_vec[dim - 1] + b1) / (p2 * gen_vec[dim - 1] + d1) # the linear transformation to get the next gen_vec_dim candidate to test gen_vec_dim2 = (p1 * gen_vec[dim - 1] + b2) / (p2 * gen_vec[dim - 1] + d2) # the other candidate from the linear transformation t1 = (gen_vec_dim1 * np.arange(1, n_max)) - np.floor(gen_vec_dim1 * np.arange(1, n_max)) # vector of coordinates generated by this candidate component - t2 = (gen_vec_dim2 * np.arange(1, n_max)) - np.floor(gen_vec_dim2 * np.arange(1, n_max)) + t2 = (gen_vec_dim2 * np.arange(1, n_max)) - np.floor(gen_vec_dim2 * np.arange(1, n_max)) k_vector1 = kPrev * (1 + kernel(t1) * coord_weights[dim]) # get the k vector for this candidate component, used in the wssd calculation - k_vector2 = kPrev * (1 + kernel(t2) * coord_weights[dim]) + k_vector2 = kPrev * (1 + kernel(t2) * coord_weights[dim]) wssd1 = np.dot(freq, k_vector1) wssd2 = np.dot(freq, k_vector2) @@ -193,7 +201,7 @@ def recursive_euclidean_algorithm(a, b): wssd = wssd2 k_vector = k_vector2 gen_vec_dim = gen_vec_dim2 - + if wssd < best_wssd: # if this candidate has a better wssd than the best found so far, we update the best coefficients and wssd coeff[dim-1, 0] = p1 coeff[dim-1, 1] = b @@ -208,7 +216,7 @@ def recursive_euclidean_algorithm(a, b): best_wssd = nK0[dim] - num + 2 * best_wssd # calculate the best wssd for this dimension using the formula from the paper, which involves the nK0 constants precomputed at the beginning of the function. This is used for debugging and to check the wssd at each dimension of the search. # print(coeff[dim - 1, :], (nK0[dim] - num + 2 * best_wssd)) # debugging line to check the coefficients and wssd at each dimension - + # Adapted from Jimmy's code for calculating the discrepancies for n = 1,...,n_max from SURE 2025 n_array = np.arange(1, n_max + 1) k_tilde = lambda x, coord_weight: np.prod(1 + kernel(x) * coord_weight, axis=1) @@ -216,10 +224,13 @@ def recursive_euclidean_algorithm(a, b): left_sum = np.cumsum(k_tilde_terms[1:]) * n_array[1:] right_sum = np.cumsum(n_array[:-1] * k_tilde_terms[1:]) - + k_tilde_zero_terms = k_tilde_terms[0] * n_array summation = np.zeros(n_max) summation[1:] = left_sum - right_sum discrepancies = (k_tilde_zero_terms + 2 * summation) / (n_array ** 2) - 1 - return gen_vec, best_wssd, discrepancies, coeff \ No newline at end of file + if d_max == 1: # the CBC loop never runs, so best_wssd is unset; report the 1-D WSSD directly + best_wssd = float(n_array @ discrepancies) + + return gen_vec, best_wssd, discrepancies, coeff From 706e0fe6b6274981973638a04a9ceadee4caa8c6 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 12:10:34 +0800 Subject: [PATCH 09/14] Add unit tests --- test/test_dd_lattice_kronecker.py | 125 +++++++++++++++++++++--------- 1 file changed, 87 insertions(+), 38 deletions(-) diff --git a/test/test_dd_lattice_kronecker.py b/test/test_dd_lattice_kronecker.py index 4c1355b63..b19558638 100644 --- a/test/test_dd_lattice_kronecker.py +++ b/test/test_dd_lattice_kronecker.py @@ -1,30 +1,35 @@ +import inspect +import re +import sys + import numpy as np import numpy.testing as npt import pytest from qmcpy import ( Kronecker, - Lattice, kronecker_vector_search_mobius_transform, + Lattice, lattice_vector_wssd_search, ) +from qmcpy.util import ParameterWarning ###################################################### # Helper functions ###################################################### -def _bernoulli_two(x): +def _bern2(x): return x * (x - 1) + 1 / 6 -def _periodic_kernel(x, coord_weights): - return np.prod(1 + _bernoulli_two(x) * coord_weights, axis=-1) +def _pkern(x, coord_weights): + return np.prod(1 + _bern2(x) * coord_weights, axis=-1) -def _direct_squared_discrepancies(points, coord_weights): +def _direct_disc(points, coord_weights): """Evaluate the periodic-kernel definition directly for small prefixes.""" return np.array( [ - _periodic_kernel( + _pkern( (points[:n, None] - points[None, :n]) % 1, coord_weights ).mean() - 1 @@ -36,19 +41,19 @@ def _direct_squared_discrepancies(points, coord_weights): ###################################################### # Test class for Lattice and Kronecker methods ###################################################### -class TestLatticeKroneckerMethods(object): +class TestLatKron(object): - def test_lattice_discrepancy_and_wssd(self): + def test_lat_disc_wssd(self): n, coord_weights = 8, np.array([1.0, 0.25]) lattice = Lattice(2, randomize=False, order="RADICAL_INVERSE") - expected = _direct_squared_discrepancies( + expected = _direct_disc( lattice.gen_samples(n=n, warn=False), coord_weights ) for actual in ( lattice.expected_squared_periodic_discrepancies(n), lattice.expected_squared_periodic_discrepancies( - n, coord_weights=coord_weights, kernel=_bernoulli_two + n, coord_weights=coord_weights, kernel=_bern2 ), ): assert actual.shape == (n,) and np.isfinite(actual).all() @@ -67,38 +72,69 @@ def test_lattice_discrepancy_and_wssd(self): atol=5e-14, ) - def test_lattice_validation(self): + def test_lat_valid(self): lattice = Lattice(2, randomize=False) with pytest.raises(ValueError, match="coord_weights"): lattice.expected_squared_periodic_discrepancies(8, coord_weights=[1.0]) with pytest.raises(ValueError, match="coord_weights"): lattice.wssd(8, coord_weights=[1.0]) - with pytest.raises(ValueError, match="sample_weights"): - lattice.wssd(8, sample_weights=np.ones(7)) + # sample_weights length must match n_max exactly, both too short and too long + for bad in (np.ones(7), np.ones(9)): + with pytest.raises(ValueError, match="sample_weights"): + lattice.wssd(8, sample_weights=bad) with pytest.raises(NotImplementedError, match="linear order"): Lattice(2, randomize=False, order="LINEAR").expected_squared_periodic_discrepancies(8) + with pytest.raises(ValueError, match="n_max must be at least 8"): + lattice_vector_wssd_search(3, 3) + with pytest.raises(ValueError, match="candidate pool"): # d_max > CBC pool, once an infinite loop + lattice_vector_wssd_search(8, 3) + + def test_lat_wssd_kernel(self): + # wssd must forward a custom kernel through to expected_squared_periodic_discrepancies + lattice = Lattice(3, randomize=False, order="RADICAL_INVERSE") + n = 16 + bern4 = lambda x: x**4 - 2 * x**3 + x**2 - 1 / 30 + npt.assert_allclose( + lattice.wssd(n, kernel=bern4), + np.arange(1, n + 1) @ lattice.expected_squared_periodic_discrepancies(n, kernel=bern4), + rtol=0, atol=5e-14, + ) + assert not np.isclose(lattice.wssd(n), lattice.wssd(n, kernel=bern4)) - def test_lattice_vector_search(self): + def test_lat_search(self): default = lattice_vector_wssd_search(16, 4, None, None) - explicit = lattice_vector_wssd_search( - n_max=16, - d_max=4, - coord_weights=np.array([1.0, 0.25, 1 / 9, 1 / 16]), - kernel=_bernoulli_two, + npt.assert_array_equal(default, [1, 5, 3, 7]) + # passing the built-in weights and kernel explicitly must reproduce the default + npt.assert_array_equal( + lattice_vector_wssd_search(16, 4, np.array([1.0, 0.25, 1 / 9, 1 / 16]), _bern2), + default, ) - npt.assert_array_equal(default, np.array([1, 5, 3, 7])) - npt.assert_array_equal(explicit, default) - assert default.shape == (4,) and default.dtype.kind in "iu" - assert len(np.unique(default)) == len(default) and np.all(default % 2 == 1) + # coord_weights[0] and kernel= must each reach the search (both were once ignored) + bern6 = lambda x: x**6 - 3 * x**5 + 2.5 * x**4 - 0.5 * x**2 + 1 / 42 + w = np.array([1.0, 0.25, 1 / 9, 1 / 16]) + base = lattice_vector_wssd_search(64, 4, w) + assert not np.array_equal(base, lattice_vector_wssd_search(64, 4, np.array([1e-6, 0.25, 1 / 9, 1 / 16]))) + assert not np.array_equal(base, lattice_vector_wssd_search(64, 4, w, bern6)) + # selection is deterministic and yields a valid generating vector + v = lattice_vector_wssd_search(2**6, 5, kernel=bern6) + npt.assert_array_equal(v, lattice_vector_wssd_search(2**6, 5, kernel=bern6)) + assert v[0] == 1 and len(np.unique(v)) == 5 and np.all((v % 2 == 1) & (0 < v) & (v < 2**6)) - def test_kronecker_discrepancy_and_wssd(self): + def test_import_conventions(self): + mod = lambda name: inspect.getsource(sys.modules["qmcpy.discrete_distribution." + name]) + # importing qmcpy must not need optional sympy: no top-level `import sympy` + assert not re.search(r"(?m)^(import sympy|from sympy)\b", mod("kronecker.kronecker_search_methods")) + # the discrepancy code must not use np.vecmat (a NumPy >= 2.2 only API) + assert "np.vecmat" not in mod("lattice.lattice") + + def test_kron_disc_wssd(self): n = 8 kronecker = Kronecker( 2, generating_vector="SUZUKI", randomize="SHIFT", shift=[0.1, 0.2] ) points = (np.arange(n)[:, None] * kronecker.gen_vec[0]) % 1 sample_weights = np.arange(1, n + 1) - expected = _direct_squared_discrepancies(points, np.ones(2)) + expected = _direct_disc(points, np.ones(2)) actual = kronecker.periodic_discrepancy(n) ** 2 assert actual.shape == (1, n) npt.assert_allclose(actual, expected[None], rtol=0, atol=5e-15) @@ -109,8 +145,8 @@ def test_kronecker_discrepancy_and_wssd(self): atol=5e-14, ) - coord_weights, kernel = np.array([1.0, 0.25]), (_periodic_kernel, 1) - expected = _direct_squared_discrepancies(points, coord_weights) + coord_weights, kernel = np.array([1.0, 0.25]), (_pkern, 1) + expected = _direct_disc(points, coord_weights) for actual in ( kronecker._square_periodic_discrepancies(n, kernel, coord_weights), kronecker.periodic_discrepancy( @@ -128,7 +164,7 @@ def test_kronecker_discrepancy_and_wssd(self): atol=5e-14, ) - def test_cbc_mobius_fallback(self): + def test_cbc_mt_fallback(self): kronecker = Kronecker(3, generating_vector="CBC_MT", randomize=False) assert kronecker.gen_vec_source == "CBC_MT" assert kronecker.gen_vec.shape == (1, 3) @@ -139,12 +175,12 @@ def test_cbc_mobius_fallback(self): assert fallback.gen_vec_source == "RICHTMYER" assert fallback.gen_vec.shape == (1, 101) - def test_kronecker_search(self): + def test_kron_search(self): n = 8 + coord_weights = np.array([1.0, 0.25, 1 / 9]) # == the j^-2 default for d=3 + # coord_weights also accepts a plain list, not only an ndarray vector, wssd, discrepancies, coefficients = ( - kronecker_vector_search_mobius_transform( - n_max=n, d_max=3, searchsize=3 - ) + kronecker_vector_search_mobius_transform(n, 3, 3, coord_weights=list(coord_weights)) ) assert vector.shape == (3,) and discrepancies.shape == (n,) assert coefficients.shape == (2, 4) @@ -155,11 +191,10 @@ def test_kronecker_search(self): wssd, np.arange(1, n + 1) @ discrepancies, rtol=0, atol=5e-14 ) - coord_weights = np.array([1.0, 0.25, 1 / 9]) points = (np.arange(n)[:, None] * vector) % 1 npt.assert_allclose( discrepancies, - _direct_squared_discrepancies(points, coord_weights), + _direct_disc(points, coord_weights), rtol=0, atol=5e-15, ) @@ -169,7 +204,7 @@ def test_kronecker_search(self): n_max=n, d_max=3, searchsize=3, - kernel=_bernoulli_two, + kernel=_bern2, coord_weights=coord_weights, gen_vec_init=1.25, ) @@ -184,13 +219,27 @@ def test_kronecker_search(self): n_max=n, d_max=3, searchsize=3, - kernel= lambda x: 3 * _bernoulli_two(x), + kernel= lambda x: 3 * _bern2(x), coord_weights=coord_weights, gen_vec_init=1.25, ) ) assert 0 < wssd - + + def test_kron_search_1d(self): + # d_max == 1 skips the CBC loop; best_wssd was once left unbound (UnboundLocalError) + n = 16 + vector, wssd, discrepancies, coeff = kronecker_vector_search_mobius_transform(n, 1, 3) + assert vector.shape == (1,) and discrepancies.shape == (n,) and coeff.shape == (0, 4) + npt.assert_allclose(wssd, np.arange(1, n + 1) @ discrepancies, rtol=0, atol=5e-14) + + def test_kron_search_no_sympy(self, monkeypatch): + # the missing-sympy branch must warn (filterable), not print or call input() + monkeypatch.setitem(sys.modules, "sympy", None) + with pytest.warns(ParameterWarning, match="sympy"): + vector, *_ = kronecker_vector_search_mobius_transform(8, 2, 2) + assert vector.shape == (2,) and np.isfinite(vector).all() + @pytest.mark.parametrize( ("kwargs", "message"), [ @@ -208,6 +257,6 @@ def test_kronecker_search(self): ), ], ) - def test_kronecker_search_validation(self, kwargs, message): + def test_kron_search_valid(self, kwargs, message): with pytest.raises(ValueError, match=message): kronecker_vector_search_mobius_transform(**kwargs) From 55a9fc5a151cd67d3df0dd9493085703e51d6f99 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 12:27:54 +0800 Subject: [PATCH 10/14] Change ParameterWarngin to UserWarning --- .../kronecker/kronecker_search_methods.py | 4 +--- test/test_dd_lattice_kronecker.py | 3 +-- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py b/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py index 268fae01a..e22111ce9 100644 --- a/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py +++ b/qmcpy/discrete_distribution/kronecker/kronecker_search_methods.py @@ -2,8 +2,6 @@ import numpy as np -from ...util import ParameterWarning - def kronecker_vector_search_mobius_transform(n_max, d_max, searchsize, kernel=None, coord_weights=None, gen_vec_init=None): """ Note that the sympy package is highly recommended for this search method, though not required. @@ -66,7 +64,7 @@ def kronecker_vector_search_mobius_transform(n_max, d_max, searchsize, kernel=No warnings.warn( "sympy is recommended for this search method: it computes the Bezout coefficients " "for the linear transformation. Without it a slower recursive Euclidean algorithm is used.", - ParameterWarning, + UserWarning, ) has_sympy = False else: diff --git a/test/test_dd_lattice_kronecker.py b/test/test_dd_lattice_kronecker.py index b19558638..dacba504f 100644 --- a/test/test_dd_lattice_kronecker.py +++ b/test/test_dd_lattice_kronecker.py @@ -12,7 +12,6 @@ Lattice, lattice_vector_wssd_search, ) -from qmcpy.util import ParameterWarning ###################################################### # Helper functions @@ -236,7 +235,7 @@ def test_kron_search_1d(self): def test_kron_search_no_sympy(self, monkeypatch): # the missing-sympy branch must warn (filterable), not print or call input() monkeypatch.setitem(sys.modules, "sympy", None) - with pytest.warns(ParameterWarning, match="sympy"): + with pytest.warns(UserWarning, match="sympy"): vector, *_ = kronecker_vector_search_mobius_transform(8, 2, 2) assert vector.shape == (2,) and np.isfinite(vector).all() From ca2b9acfb8c20a7b664e44c70e7b5d60494801f9 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 13:01:52 +0800 Subject: [PATCH 11/14] Fix GitHub Action failures --- qmcpy/util/install_mpmc_pyg.py | 32 +++++++++++++++++++++++--------- test/test_install_mpmc_pyg.py | 32 ++++++++++++++++++++++++++++---- 2 files changed, 51 insertions(+), 13 deletions(-) diff --git a/qmcpy/util/install_mpmc_pyg.py b/qmcpy/util/install_mpmc_pyg.py index b559c3f5b..33cd7881a 100644 --- a/qmcpy/util/install_mpmc_pyg.py +++ b/qmcpy/util/install_mpmc_pyg.py @@ -7,6 +7,7 @@ PYG_LIB_REQUIREMENT = "pyg_lib>=0.6.0" +PYG_LIB_SOURCE = "git+https://github.com/pyg-team/pyg-lib.git@0.8.0" TORCH_GEOMETRIC_REQUIREMENT = "torch-geometric>=2.6.1" @@ -79,7 +80,6 @@ def main(torch_module=None): TORCH_GEOMETRIC_REQUIREMENT, ) - last_error = None accelerator = accelerator_tag(torch_module) for wheel_url in wheel_urls(torch_module.__version__, accelerator): print(f"Trying pyg_lib wheels from {wheel_url}", flush=True) @@ -97,14 +97,28 @@ def main(torch_module=None): wheel_url, ) return - except subprocess.CalledProcessError as error: - last_error = error - - raise RuntimeError( - f"Unable to install pyg_lib for torch {torch_module.__version__} " - f"({accelerator}). " - "PyG wheels at https://data.pyg.org/whl/ may not support this build." - ) from last_error + except subprocess.CalledProcessError: + pass + + print( + "Pre-built pyg_lib wheels were unavailable; trying the official " + "source release", + flush=True, + ) + try: + run( + sys.executable, + "-m", + "pip", + "install", + "--no-build-isolation", + PYG_LIB_SOURCE, + ) + except subprocess.CalledProcessError as error: + raise RuntimeError( + f"Unable to install pyg_lib for torch {torch_module.__version__} " + f"({accelerator}) from PyG wheels or the official source release." + ) from error if __name__ == "__main__": diff --git a/test/test_install_mpmc_pyg.py b/test/test_install_mpmc_pyg.py index 41b1b4e0b..c62ae27b6 100644 --- a/test/test_install_mpmc_pyg.py +++ b/test/test_install_mpmc_pyg.py @@ -62,6 +62,24 @@ def fake_run(*args): assert "--only-binary" in calls[1] +def test_main_falls_back_to_official_source_release(monkeypatch): + """A wheel-index outage falls back to PyG's pinned source release.""" + calls = [] + + def fake_run(*args): + calls.append(args) + if install_mpmc_pyg.PYG_LIB_REQUIREMENT in args: + raise subprocess.CalledProcessError(1, args) + + monkeypatch.setattr(install_mpmc_pyg, "run", fake_run) + + install_mpmc_pyg.main(_torch()) + + assert len(calls) == 4 + assert "--no-build-isolation" in calls[-1] + assert calls[-1][-1] == install_mpmc_pyg.PYG_LIB_SOURCE + + def test_main_explains_that_torch_must_be_installed(monkeypatch): """Running the helper before installing the extra gives a useful error.""" def missing_torch(_name): @@ -73,13 +91,19 @@ def missing_torch(_name): install_mpmc_pyg.main() -def test_main_reports_missing_wheel(monkeypatch): - """Exhausting candidate wheel pages reports the build that failed.""" +def test_main_reports_missing_wheel_and_source(monkeypatch): + """Exhausting binary and source installs reports the build that failed.""" def fail_pyg_lib(*args): - if "pyg_lib>=0.6.0" in args: + if ( + install_mpmc_pyg.PYG_LIB_REQUIREMENT in args + or install_mpmc_pyg.PYG_LIB_SOURCE in args + ): raise subprocess.CalledProcessError(1, args) monkeypatch.setattr(install_mpmc_pyg, "run", fail_pyg_lib) - with pytest.raises(RuntimeError, match=r"torch 2\.12\.1\+cpu \(cpu\)"): + with pytest.raises( + RuntimeError, + match=r"torch 2\.12\.1\+cpu \(cpu\).*official source release", + ): install_mpmc_pyg.main(_torch()) From 58a1aab23daec6e5e26bf1eb8e30b2ad4be0bb79 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 16:20:54 +0800 Subject: [PATCH 12/14] Another attempt to fix --- .github/workflows/alltests.yml | 4 +-- qmcpy/discrete_distribution/mpmc/__init__.py | 8 ++++-- qmcpy/discrete_distribution/mpmc/models.py | 29 ++++++++++++++++++- qmcpy/util/install_mpmc_pyg.py | 30 +++++++++++++++----- test/test_install_mpmc_pyg.py | 12 ++++---- 5 files changed, 63 insertions(+), 20 deletions(-) diff --git a/.github/workflows/alltests.yml b/.github/workflows/alltests.yml index 97486f78f..777f232f6 100644 --- a/.github/workflows/alltests.yml +++ b/.github/workflows/alltests.yml @@ -297,12 +297,12 @@ jobs: - name: Validate MPMC dependencies (Unix) if: runner.os != 'Windows' shell: bash -el {0} - run: python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" + run: python -c "import torch, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" - name: Validate MPMC dependencies (Windows) if: runner.os == 'Windows' shell: pwsh - run: python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" + run: python -c "import torch, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')" # ----------------------------------------------------------- # Colab readiness tests (Linux only) # ----------------------------------------------------------- diff --git a/qmcpy/discrete_distribution/mpmc/__init__.py b/qmcpy/discrete_distribution/mpmc/__init__.py index 9ceea1244..0df695c88 100644 --- a/qmcpy/discrete_distribution/mpmc/__init__.py +++ b/qmcpy/discrete_distribution/mpmc/__init__.py @@ -17,12 +17,13 @@ If these dependencies are not installed, attempting to use MPMC will raise an ImportError with installation instructions. You can check availability by running: - python -c "import torch; import pyg_lib; import torch_geometric; print('MPMC dependencies ready')" + python -c "import torch; import torch_geometric; print('MPMC dependencies ready')" + +(``pyg_lib`` is an optional accelerator; MPMC runs without it.) """ try: import torch - import pyg_lib import torch_geometric from .mpmc import MPMC except ImportError as e: @@ -32,11 +33,12 @@ class MPMC(object): """Placeholder MPMC class shown when PyTorch dependencies are missing.""" def __init__(self, *args, **kwargs): raise ImportError( - f"MPMC requires PyTorch, pyg_lib, and PyTorch Geometric, but they are not installed.\n" + f"MPMC requires PyTorch and PyTorch Geometric, but they are not installed.\n" f"Original error: {_missing_dep}\n\n" f"To use MPMC, install dependencies with:\n" f" python -m pip install 'qmcpy[mpmc]'\n" f" qmcpy-install-mpmc\n\n" + f"(pyg_lib is an optional accelerator; MPMC runs without it.)\n" f"For GPU support, see: https://pytorch.org/get-started/locally/\n" f"For torch-geometric installation details, see: " f"https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html" diff --git a/qmcpy/discrete_distribution/mpmc/models.py b/qmcpy/discrete_distribution/mpmc/models.py index 48deb56cf..76e3e28ed 100644 --- a/qmcpy/discrete_distribution/mpmc/models.py +++ b/qmcpy/discrete_distribution/mpmc/models.py @@ -1,6 +1,33 @@ import torch from torch import nn -from torch_geometric.nn import MessagePassing, InstanceNorm, radius_graph +from torch_geometric.nn import MessagePassing, InstanceNorm + +try: + from torch_geometric.nn import radius_graph as _tg_radius_graph +except Exception: # torch_geometric built without the pooling ops + _tg_radius_graph = None + + +def radius_graph(x, r, batch=None, loop=False): + """Edges between points within distance ``r`` (per batch), shaped ``[2, E]``. + + Uses torch_geometric's compiled ``radius_graph`` when its backend + (``pyg_lib`` or ``torch_cluster``) is installed, otherwise a native + ``torch.cdist`` fallback so MPMC runs without those optional packages. + """ + if _tg_radius_graph is not None: + try: + return _tg_radius_graph(x, r=r, batch=batch, loop=loop) + except ImportError: + pass + dist = torch.cdist(x, x) + mask = dist <= r + if batch is not None: + mask = mask & (batch.view(-1, 1) == batch.view(1, -1)) + if not loop: + mask = mask & ~torch.eye(mask.size(0), dtype=torch.bool, device=mask.device) + row, col = mask.nonzero(as_tuple=True) + return torch.stack([row, col], dim=0) from .utils import ( L2star, L2ctr, L2ext, L2per, L2sym, L2mix, diff --git a/qmcpy/util/install_mpmc_pyg.py b/qmcpy/util/install_mpmc_pyg.py index 33cd7881a..fe0540cec 100644 --- a/qmcpy/util/install_mpmc_pyg.py +++ b/qmcpy/util/install_mpmc_pyg.py @@ -60,7 +60,13 @@ def wheel_urls(torch_version, accelerator): def main(torch_module=None): - """Install PyG dependencies that cannot be resolved from PyPI alone.""" + """Install the PyG dependencies MPMC needs beyond what PyPI resolves. + + ``torch-geometric`` is required and comes from PyPI. ``pyg_lib`` is only an + optional accelerator -- MPMC and ``torch-geometric`` run without it -- so + when no wheel exists for this torch build and the source build fails, we + warn and carry on instead of aborting the install. + """ if torch_module is None: try: torch_module = importlib.import_module("torch") @@ -80,6 +86,18 @@ def main(torch_module=None): TORCH_GEOMETRIC_REQUIREMENT, ) + if not _install_pyg_lib(torch_module): + print( + "WARNING: could not install the optional pyg_lib accelerator for " + f"torch {torch_module.__version__} " + f"({accelerator_tag(torch_module)}); MPMC falls back to " + "torch-geometric's native (slower) scatter path.", + flush=True, + ) + + +def _install_pyg_lib(torch_module): + """Best-effort pyg_lib install; return True on success, False otherwise.""" accelerator = accelerator_tag(torch_module) for wheel_url in wheel_urls(torch_module.__version__, accelerator): print(f"Trying pyg_lib wheels from {wheel_url}", flush=True) @@ -96,7 +114,7 @@ def main(torch_module=None): "--find-links", wheel_url, ) - return + return True except subprocess.CalledProcessError: pass @@ -114,11 +132,9 @@ def main(torch_module=None): "--no-build-isolation", PYG_LIB_SOURCE, ) - except subprocess.CalledProcessError as error: - raise RuntimeError( - f"Unable to install pyg_lib for torch {torch_module.__version__} " - f"({accelerator}) from PyG wheels or the official source release." - ) from error + return True + except subprocess.CalledProcessError: + return False if __name__ == "__main__": diff --git a/test/test_install_mpmc_pyg.py b/test/test_install_mpmc_pyg.py index c62ae27b6..74a09dca1 100644 --- a/test/test_install_mpmc_pyg.py +++ b/test/test_install_mpmc_pyg.py @@ -91,8 +91,8 @@ def missing_torch(_name): install_mpmc_pyg.main() -def test_main_reports_missing_wheel_and_source(monkeypatch): - """Exhausting binary and source installs reports the build that failed.""" +def test_main_warns_when_pyg_lib_unavailable(monkeypatch, capsys): + """pyg_lib is optional: when every install path fails, main() warns and returns.""" def fail_pyg_lib(*args): if ( install_mpmc_pyg.PYG_LIB_REQUIREMENT in args @@ -102,8 +102,6 @@ def fail_pyg_lib(*args): monkeypatch.setattr(install_mpmc_pyg, "run", fail_pyg_lib) - with pytest.raises( - RuntimeError, - match=r"torch 2\.12\.1\+cpu \(cpu\).*official source release", - ): - install_mpmc_pyg.main(_torch()) + install_mpmc_pyg.main(_torch()) # must not raise + + assert "could not install the optional pyg_lib" in capsys.readouterr().out From 4b2866af61a4b5c2f62ee474d6bfe0dc2227c4b5 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 16:30:22 +0800 Subject: [PATCH 13/14] make harden_colab_notebook --- demos/lattice_kronecker_methods.ipynb | 25 +++++++++++++++++++++++++ scripts/colab_notebooks_manifest.json | 1 + 2 files changed, 26 insertions(+) diff --git a/demos/lattice_kronecker_methods.ipynb b/demos/lattice_kronecker_methods.ipynb index 1d11ccc52..2951e79de 100644 --- a/demos/lattice_kronecker_methods.ipynb +++ b/demos/lattice_kronecker_methods.ipynb @@ -8,6 +8,31 @@ "# Lattice and Kronecker Methods" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lattice_kronecker_methods.ipynb)" + ], + "id": "31badecd" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " !pip install -q qmcpy\n" + ], + "id": "f534a4d7" + }, { "cell_type": "code", "execution_count": 1, diff --git a/scripts/colab_notebooks_manifest.json b/scripts/colab_notebooks_manifest.json index ed62ba8be..b03fc7f2a 100644 --- a/scripts/colab_notebooks_manifest.json +++ b/scripts/colab_notebooks_manifest.json @@ -18,6 +18,7 @@ "demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb", "demos/iris.ipynb", "demos/korobov_hammersley_latinhypercube_demos.ipynb", + "demos/lattice_kronecker_methods.ipynb", "demos/lattice_random_generator.ipynb", "demos/lebesgue_integration.ipynb", "demos/linear-scrambled-halton.ipynb", From f6b5088de400bf10f2cd7c532f5a5bb5867d3081 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Thu, 3 Sep 2026 17:36:52 +0800 Subject: [PATCH 14/14] Fix windows test failure --- qmcpy/discrete_distribution/mpmc/models.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/qmcpy/discrete_distribution/mpmc/models.py b/qmcpy/discrete_distribution/mpmc/models.py index 76e3e28ed..5d236b2bf 100644 --- a/qmcpy/discrete_distribution/mpmc/models.py +++ b/qmcpy/discrete_distribution/mpmc/models.py @@ -7,19 +7,23 @@ except Exception: # torch_geometric built without the pooling ops _tg_radius_graph = None +_tg_radius_graph_ok = _tg_radius_graph is not None + def radius_graph(x, r, batch=None, loop=False): """Edges between points within distance ``r`` (per batch), shaped ``[2, E]``. - Uses torch_geometric's compiled ``radius_graph`` when its backend - (``pyg_lib`` or ``torch_cluster``) is installed, otherwise a native - ``torch.cdist`` fallback so MPMC runs without those optional packages. + Uses torch_geometric's compiled ``radius_graph`` when its backend is present + and working, otherwise a native ``torch.cdist`` fallback so MPMC runs + without ``pyg_lib`` / ``torch_cluster`` (and on platforms where their + compiled ops -- e.g. ``torch.ops.pyg.radius`` on Windows -- fail to load). """ - if _tg_radius_graph is not None: + global _tg_radius_graph_ok + if _tg_radius_graph_ok: try: return _tg_radius_graph(x, r=r, batch=batch, loop=loop) - except ImportError: - pass + except (ImportError, AttributeError, RuntimeError, OSError): + _tg_radius_graph_ok = False # backend missing/broken -- use native from now on dist = torch.cdist(x, x) mask = dist <= r if batch is not None: