From 3799f6745d64b6e892fc2ce2b6a6150b0c8a3748 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 6 Jul 2026 21:54:55 +0000 Subject: [PATCH 01/17] Bump crate-ci/typos from 1.47.2 to 1.48.0 Bumps [crate-ci/typos](https://github.com/crate-ci/typos) from 1.47.2 to 1.48.0. - [Release notes](https://github.com/crate-ci/typos/releases) - [Changelog](https://github.com/crate-ci/typos/blob/master/CHANGELOG.md) - [Commits](https://github.com/crate-ci/typos/compare/v1.47.2...v1.48.0) --- updated-dependencies: - dependency-name: crate-ci/typos dependency-version: 1.48.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- .github/workflows/check_spelling.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/check_spelling.yml b/.github/workflows/check_spelling.yml index 4fd8e0d..d2e830b 100644 --- a/.github/workflows/check_spelling.yml +++ b/.github/workflows/check_spelling.yml @@ -18,6 +18,6 @@ jobs: - name: Checkout OpenBT repository uses: actions/checkout@v7 - name: Spell Check Repo - uses: crate-ci/typos@v1.47.2 + uses: crate-ci/typos@v1.48.0 with: config: ${{ env.TYPOS_CFG }} From ff39e15fe44b6224753ff3c0a0d215941ed008c5 Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Mon, 13 Jul 2026 06:10:15 -0400 Subject: [PATCH 02/17] Changes to developer environment and a section for R in documentation. --- docs/examples_r.rst | 97 +++++++++++++ docs/get_started_r.rst | 51 +++++++ docs/git_workflow.rst | 54 ++++++++ docs/index.rst | 8 ++ docs/tox_usage.rst | 303 ++++++++++++++++++++++++++++++++++++++++- openbt_pypkg/tox.ini | 4 + 6 files changed, 514 insertions(+), 3 deletions(-) create mode 100644 docs/examples_r.rst create mode 100644 docs/get_started_r.rst diff --git a/docs/examples_r.rst b/docs/examples_r.rst new file mode 100644 index 0000000..072d839 --- /dev/null +++ b/docs/examples_r.rst @@ -0,0 +1,97 @@ +Examples +======== +.. _Branin: https://www.sfu.ca/~ssurjano/branin.html + +To use |openbt| in R, install the ``Ropenbt`` front-end R interface as +described in :doc:`get_started_r`, then let's create a test function. A +popular one is the Branin_ function: + +.. code-block:: r + + # Test Branin function, rescaled + braninsc <- function(xx) + { + x1 <- xx[1] + x2 <- xx[2] + + x1bar <- 15*x1 - 5 + x2bar <- 15 * x2 + + term1 <- x2bar - 5.1*x1bar^2/(4*pi^2) + 5*x1bar/pi - 6 + term2 <- (10 - 10/(8*pi)) * cos(x1bar) + + y <- (term1^2 + term2 - 44.81) / 51.95 + return(y) + } + + + # Simulate branin data for testing + set.seed(99) + n=500 + p=2 + x = matrix(runif(n*p),ncol=p) + y=rep(0,n) + for(i in 1:n) y[i] = braninsc(x[i,]) + +And then we can load the ``Ropenbt`` package and fit a BART model. Here we set +the model type as ``model="bart"`` which ensures we fit a homoscedastic BART +model. The number of MPI threads to use is specified as ``tc=4``. For a list +of all optional parameters, see ``args(openbt)``. + +.. code-block:: r + + library(Ropenbt) + fit=openbt(x,y,tc=4,model="bart",modelname="branin") + +Next we can construct predictions and make a simple plot. Here, we are +calculating the in-sample predictions since we passed the same ``x`` matrix to +the ``predict.openbt()`` function. + +.. code-block:: r + + # Calculate in-sample predictions + fitp=predict.openbt(fit,x,tc=4) + + # Make a simple plot + plot(y,fitp$mmean,xlab="observed",ylab="fitted") + abline(0,1) + +To save the model, use the ``openbt.save()`` function. Similarly, load the +model using ``openbt.load()``. Because the posterior can be large in +sample-based models such as these, the fitted model is saved in a compressed +file format with the extension ``.obt``. + +.. code-block:: r + + # Save fitted model as test.obt in the working directory + openbt.save(fit,"test") + + # Load fitted model to a new object. + fit2=openbt.load("test") + +The standard variable activity information, calculated as the proportion of +splitting rules involving each variable, can be computed using the +``vartivity.openbt()`` function. + +.. code-block:: r + + # Calculate variable activity information + fitv=vartivity.openbt(fit2) + + # Plot variable activity + plot(fitv) + +A more accurate alternative is to calculate the Sobol' indices. + +.. code-block:: r + + # Calculate Sobol indices + fits=sobol.openbt(fit2) + fits$msi + fits$mtsi + fits$msij + +The ``Ropenbt`` package does not currently ship a dedicated automated test +suite of its own; the steps above (fitting the Branin function and checking +that predictions track the observed values) are a reasonable smoke test that +your installation is working end to end. \ No newline at end of file diff --git a/docs/get_started_r.rst b/docs/get_started_r.rst new file mode 100644 index 0000000..a46e009 --- /dev/null +++ b/docs/get_started_r.rst @@ -0,0 +1,51 @@ +Getting Started with R +======================= +.. _Meson: https://mesonbuild.com +.. _ninja: https://ninja-build.org +.. _remotes: https://remotes.r-lib.org + +Installed versions of the |openbt| R package, ``Ropenbt``, provide a front-end +R interface that wraps a dedicated set of |openbt| C++ command line tools. + + +Unlike the |openbt| Python package, ``Ropenbt`` does not build or invoke +Meson_ itself. It is a pure R package with no compiled code of its own; it +simply locates and calls the already-built command line tools (such as +``openbtcli``) on the ``PATH``, or in the current working directory as a +fallback. Building those command line tools is a separate, prerequisite step. + +Build the C++ command line tools +----------------------------------------- +Before installing ``Ropenbt``, you must first build and install the |openbt| +C++ command line tools using Meson_ and ninja_. Follow the +:doc:`get_started_cpp` guide to + +* install the required dependencies (a C++14-compatible compiler, an MPI + installation, and optionally Eigen_), +* install Meson_ and ninja_, and +* build and install the command line tools. + + + +Install Ropenbt +------------------------- +With the command line tools built, install the +``Ropenbt`` R interface directly from Bitbucket using the remotes_ package. First, make sure +``remotes`` is installed: + +.. code-block:: r + + install.packages("remotes") + +Now install ``Ropenbt`` directly from Bitbucket: + +.. code-block:: r + + remotes::install_bitbucket("mpratola/openbt/Ropenbt") + +Note that some ``Ropenbt`` package dependencies may also be installed. Since +``Ropenbt`` itself needs no compilation, this step is quick regardless of +platform. + +See :doc:`examples_r` for a worked example of fitting a model with +``Ropenbt``. \ No newline at end of file diff --git a/docs/git_workflow.rst b/docs/git_workflow.rst index 1a3f40d..92529bb 100644 --- a/docs/git_workflow.rst +++ b/docs/git_workflow.rst @@ -32,3 +32,57 @@ informal git workflow. A minimal set of rules are Developers are encouraged to create PRs early during branch development to begin and record a dialogue with potential reviewers in the PR. + +GitHub Actions +-------------- + +All of the following actions run automatically on every push and pull request to +``main``. A merge should only proceed once all actions pass. + +Documentation +~~~~~~~~~~~~~ + +* **Check Spelling** — Checks all ``.rst`` and ``.md`` files in the repository + for typographic errors using the ``typos`` tool with the ``typos.toml`` + configuration file. + +* **Check Links** — Checks all ``.rst`` and ``.md`` files for broken URLs using + the ``lychee`` tool. In addition to running on push and pull request, this + action runs on a weekly schedule to catch links that break between + contributions. + +* **Build Sphinx Docs** — Builds the |openbt| documentation in both HTML and + PDF format using |tox|. The built documents are uploaded as a downloadable + artifact so that contributors can review rendered documentation without + needing a local build environment. + +Python Package Testing +~~~~~~~~~~~~~~~~~~~~~~ + +* **Test OpenBT Python Source Distribution** — The primary test action. Builds + a Python source distribution and tests it across a matrix of six operating + systems, two MPI implementations (Open MPI and MPICH), and five Python + versions (3.10–3.14). The built source distribution is also uploaded as an + artifact for manual upload to PyPI at release time. This action additionally + runs on published releases. + +* **Test OpenBT Developer-mode Installation** — Tests the editable installation + (``pip install -e .``) on a reduced matrix. MPI is intentionally installed + |via| |pip| rather than a system package manager to confirm that pip-installed + MPI implementations work correctly. + +* **Test OpenBT in Anaconda** — Tests installation inside a conda environment + across six operating systems using a prebuilt Open MPI installed |via| |pip|. + +* **Measure OpenBT Python Coverage** — Runs the full Python test suite with + coverage measurement using |tox| and uploads the raw coverage file, XML + report, and HTML report as artifacts. + +C++ Tools Testing +~~~~~~~~~~~~~~~~~ + +* **Test OpenBT C++ Command Line Tools** — Builds and tests the C++ command + line tools directly across a matrix of six operating systems and two MPI + implementations, independently of the Python package. Prints dynamic library + linkage information for each built binary so that developers can verify the + correct MPI implementation was linked. diff --git a/docs/index.rst b/docs/index.rst index 1633abf..8ef7ce1 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -37,6 +37,14 @@ This package is being developed as part of |band| framework_. get_started_cpp bibliography_cpp +.. toctree:: + :numbered: + :maxdepth: 1 + :caption: R User Guide: + + get_started_r + examples_r + .. toctree:: :numbered: :maxdepth: 1 diff --git a/docs/tox_usage.rst b/docs/tox_usage.rst index 5e0a259..2fac2f8 100644 --- a/docs/tox_usage.rst +++ b/docs/tox_usage.rst @@ -2,7 +2,304 @@ Developer Environment ===================== -.. _tox: https://tox.wiki/en/latest/index.html -.. todo:: - Sarthak to write this +Tox +--- +.. _tox Usage: https://tox.wiki/en/latest/index.html +.. _Oliver Bestwalter: https://youtu.be/PrAyvH-tm8E + +Developers are free to setup whatever environment that they may need to +facilitate their work. However, the |openbt| Python package includes a +`tox Usage`_ setup, which developers can also use to automatically setup and +manage dedicated virtual environments for different predefined development tasks. + +Development with |tox| +~~~~~~~~~~~~~~~~~~~~~~ + +The following is a rough guide to help install |tox| as a command line tool in +a dedicated, minimal virtual environment. |tox| is made available with +no need to manually activate its virtual environment. + +.. note:: + Developers that would like to use |tox| should, at the very least, learn + enough about it that they understand the difference between running ``tox`` + and ``tox -r``. + +.. code-block:: console + + $ cd $HOME/local/venv + $ deactivate + $ /path/to/desired/python --version + $ /path/to/desired/python -m venv $HOME/local/venv/.toxbase + $ ./.toxbase/bin/python -m pip list + $ ./.toxbase/bin/python -m pip install --upgrade pip setuptools + $ ./.toxbase/bin/python -m pip install tox + $ ./.toxbase/bin/python -m pip list + $ ./.toxbase/bin/tox --version + +To avoid having to activate ``.toxbase`` every time we would like to work with +|tox|, we setup |tox| in ``PATH``. Note that developers can use this single +|tox| installation for multiple projects. Please replace ``.bash_profile`` +with the appropriate shell configuration file and tailor the following to your +needs. + +.. code-block:: console + + $ mkdir -p $HOME/local/bin + $ ln -s $HOME/local/venv/.toxbase/bin/tox $HOME/local/bin/tox + $ vi $HOME/.bash_profile + $ . $HOME/.bash_profile + $ which tox + $ tox --version + +No work will be carried out by default with the calls ``tox`` and ``tox -r``. + +The following tasks can be run from within the directory hierarchy that contains +the |openbt| |tox| configuration file ``/path/to/OpenBT/openbt_pypkg/tox.ini``: + +* ``tox -r -e nocoverage`` + + * Execute the full test suite for the |openbt| Python package using the code + installed into Python. + +* ``tox -r -e coverage`` + + * Execute the full test suite for the |openbt| Python package and save + coverage results to a coverage file. + * The test runs the package code in the local clone rather than code installed + into Python so that coverage results are clean and straightforward. + * If the environment variable ``COVERAGE_FILE`` is set, then this is the + coverage file that will be written to. If it is not specified, then the + coverage results are written to ``.coverage_openbt``. + +* ``tox -r -e report`` + + * It is intended that this be run after or with ``coverage``. + * Display a code coverage report for the |openbt| package's full test suite + and generate XML and HTML versions of the report. + * The environment variables ``COVERAGE_XML`` and ``COVERAGE_HTML`` can be + provided to specify the names of the files that the associated reports + should be written to. If ``COVERAGE_XML`` is not specified, the XML report + is written to ``coverage.xml``. If ``COVERAGE_HTML`` is not provided, the + HTML report is written to ``htmlcov``. + +* ``tox -r -e check`` + + * Run several checks on the code to report possible issues. + * No files are altered automatically by this task. + +* ``tox -r -e html`` + + * Generate and serve the |openbt| documentation locally as HTML via a local + server at ``http://127.0.0.1:8000``. The browser reloads automatically + whenever documentation source files are changed. + +* ``tox -r -e pdf`` + + * Generate and render the |openbt| documentation locally as a PDF file. + * Users are responsible for installing ``make`` and a compatible LaTeX + installation for immediate use by |tox|. + +Additionally, you can run any combination of the above such as +``tox -r -e report,coverage``. + +Direct use of |tox| virtual environments +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Many of the |tox| tasks will build the |openbt| binary automatically each time +they are run, which can significantly slow development work. In such cases, a +developer will likely start their work by creating a clean virtual environment +for their task using ``tox -r`` and subsequently load and work in that virtual +environment directly. + +Developers can inspect ``tox.ini`` to see what commands are run by their task +and adapt these for their work. + +The following example shows how to run only a single test case using the +``coverage`` virtual environment setup by |tox|. + +.. code-block:: console + + $ cd /path/to/OpenBT/openbt_pypkg + $ tox -r -e coverage + $ . ./.tox/coverage/bin/activate + $ which python + $ python --version + $ python -m pip list + $ python -m pytest openbt.tests.test_brt + +Note that using the ``coverage`` virtual environment directly can be +particularly useful since the package is installed in editable mode and +therefore facilitates interactive development and testing of the Python code. + +|Tox|'s ``-r`` flag takes a conservative approach by wiping and fully +rebuilding the virtual environment from scratch on every invocation, which +guarantees a clean state but adds overhead each time. For iterative work this +accumulates quickly. The ``html`` environment illustrates how to set up the +environment once and then work flexibly inside it rather than letting |tox| +drive every step. + +When |tox| runs the ``html`` environment it launches ``sphinx-autobuild``, a +live-reload server. A developer who wants to invoke ``sphinx-build`` with +specific flags, rebuild on demand, or simply skip the server overhead can +instead create the environment once and activate it directly: + +.. code-block:: console + + $ cd /path/to/OpenBT/openbt_pypkg + $ tox -r -e html + $ # Press Ctrl+C to stop sphinx-autobuild once the environment is ready. + $ . ./.tox/html/bin/activate + $ which sphinx-build + $ sphinx-build -W -E -b html ../docs ../docs/build_html + +On subsequent documentation iterations only the ``sphinx-build`` command is +needed — the environment is already activated and no |tox| rebuild is required. +Omitting ``-E`` on later runs reuses Sphinx's cached environment and speeds up +incremental builds. The live-reload server can also be started directly from +the activated environment when it is useful: + +.. code-block:: console + + $ sphinx-autobuild -W -b html ../docs ../docs/build_html + +Eigen +----- +.. _Eigen: https://gitlab.com/libeigen/eigen + +Eigen_ is a header-only C++ template library for linear algebra. Being +header-only means there is no compiled library to link against, it is used +purely by including its headers directly into source files. + +Installation +~~~~~~~~~~~~ + +Eigen does not need to be installed manually. The |openbt| Meson build system +handles Eigen automatically in two steps. First, Meson searches for an +existing system-wide Eigen installation discoverable |via| ``pkg-config``. If +found, that installation is used for the build. If not found, Meson falls back +to the ``subprojects/eigen.wrap`` file, which instructs it to download Eigen +5.0.1 automatically from GitLab and use it internally for that build. As a +result, Eigen is always available to the build regardless of whether it is +installed on the system. + +Developers on macOS who prefer to have a system-wide installation can install +Eigen |via| Homebrew: + +.. code-block:: console + + $ brew install eigen + + +Meson Build +----------- +.. _Meson: https://mesonbuild.com +.. _ninja: https://ninja-build.org + +The |openbt| Python package uses the Meson_ build system together with its +ninja_ backend to compile the C++ command line tools during installation. +Meson must be installed and available on ``PATH`` before building the package. +Please refer to :ref:`get_started_cpp:Meson installation` for detailed +installation instructions. + +Build Process with Python +~~~~~~~~~~~~~ + +The Meson build is not invoked directly by developers. It is triggered +automatically when the |openbt| Python package is installed |via| + +.. code-block:: console + + $ cd /path/to/OpenBT/openbt_pypkg + $ python -m pip install . + +or in editable mode |via| + +.. code-block:: console + + $ python -m pip install -e . + +Internally, ``setup.py`` defines a custom ``build_clt`` command that runs the +following three Meson commands sequentially from within the ``cpp/`` directory: + +.. code-block:: console + + $ meson setup --wipe --clearcache --buildtype=release builddir \ + -Dprefix=/path/to/src/openbt -Duse_mpi=true -Dpypkg=true + $ meson compile -v -C builddir + $ meson install --quiet -C builddir + +The ``--wipe`` flag deletes and recreates ``builddir`` before every install, +ensuring a clean compile from scratch. The ``--clearcache`` flag clears +Meson's dependency detection cache, forcing it to re-detect the compiler, MPI, +and Eigen installations. + +Files and Directories Created +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A successful ``pip install`` creates the following files and directories: + +* ``openbt_pypkg/cpp/builddir/`` — Meson's working build directory. Ninja + compiles all C++ source files into object files. This directory is wiped and recreated on + every ``pip install`` and can be deleted safely at any time. + +* ``openbt_pypkg/src/openbt/bin/`` — The eight compiled C++ command line + tools installed by ``meson install``: + + .. code-block:: console + + openbtcli openbtpred openbtmixingwts + openbtmixing openbtmixingpred openbtmopareto + openbtsobol openbtvartivity + + .. note:: + Only ``openbtcli``, ``openbtpred``, and ``openbtmixingwts`` are + included in the distributed package. All eight are compiled and + installed to disk regardless. + +* ``openbt_pypkg/src/openbt/include/eigen3/`` — Eigen headers installed + under the package prefix as a side effect of Eigen's own Meson install + step, regardless of whether Eigen came from the system or the bundled + ``subprojects/eigen.wrap``. + +* ``openbt_pypkg/src/openbt/lib/pkgconfig/eigen3.pc`` — A ``pkg-config`` + file for the installed Eigen, with its ``prefix`` pointing into + ``src/openbt/``. + +* ``openbt_pypkg/src/openbt/_version.py`` — Written by ``setuptools_scm`` + from the current git tag, not by Meson. + +Caching +~~~~~~~ + +There are four caching layers involved in the build, each with different +behaviour on a recompile: + +* ``subprojects/packagecache/`` — Stores downloaded Eigen tarballs + (``eigen-5.0.1.tar.bz2`` and its patch) so that Meson does not re-download + them on every build. ``--clearcache`` does not clear this directory; it + persists intentionally across builds. + +* ``cpp/builddir/`` — Ninja's compile cache of object files. Because + ``meson setup --wipe`` is run on every ``pip install``, this cache is never + reused between installs and is always rebuilt from scratch. + +* ``src/openbt/{bin,include,lib}/`` — The install destination written by + ``meson install``. This is the most problematic caching layer: ``meson + install`` overlays new files onto these directories but never removes + stale ones. If a binary is renamed, a tool is removed from the build, or + Eigen headers change, the old files persist silently. When the build + produces unexpected behaviour, these directories should be deleted manually + before reinstalling: + + .. code-block:: console + + $ rm -rf openbt_pypkg/src/openbt/bin/ + $ rm -rf openbt_pypkg/src/openbt/include/ + $ rm -rf openbt_pypkg/src/openbt/lib/ + +* ``openbt_pypkg/.tox/`` — |tox| virtual environments each contain their own + installed copy of the |openbt| package and compiled binaries. Running + ``tox`` without ``-r`` reuses the existing environment and does not + reinstall |openbt| or rerun the Meson build. Running ``tox -r`` forces a + clean environment rebuild and a full ``pip install`` from scratch. diff --git a/openbt_pypkg/tox.ini b/openbt_pypkg/tox.ini index 60ca6f3..aed5cff 100644 --- a/openbt_pypkg/tox.ini +++ b/openbt_pypkg/tox.ini @@ -54,8 +54,12 @@ deps = sphinx sphinxcontrib-bibtex sphinx_rtd_theme + # The command below is for live-reloading of the documentation during development. Uncomment it if you want to use it. + #sphinx-autobuild commands = sphinx-build -W -E -b html {env:DOC_ROOT} {env:DOC_ROOT}/build_html + # The command below is for live-reloading of the documentation during development. Uncomment it if you want to use it. + #sphinx-autobuild -W -E -b html {env:DOC_ROOT} {env:DOC_ROOT}/build_html [testenv:pdf] description = Generate OpenBT PDF-format documentation From 3d6de054ce5ac581956aa163125a5fe71867b7f3 Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Mon, 20 Jul 2026 09:27:00 -0400 Subject: [PATCH 03/17] Made changes to the notebook to fit current pypkg setup. --- .../BART_BMM_Technometrics.ipynb | 1656 ++++++++--------- 1 file changed, 819 insertions(+), 837 deletions(-) diff --git a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb index c72962d..e477d37 100644 --- a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb +++ b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb @@ -1,847 +1,829 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## BART-BMM Examples\n", + "\n", + "This notebook reproduces the BART-BMM examples shown in \"Model Mixing Using Bayesian Additive Regression Trees.\" Each code cell can be executed by clicking the \"play\" button, which is found on the lefthand side of the cell. Alternatively, one can click inside the cell and use the command `shift + enter`.\n", + "\n", + "### **Installation Step**\n", + "\n", + "This notebook uses the openbt Python package from this repository (openbt_pypkg), which wraps the OpenBT C++ command line tools.\n", + "\n", + "Before running this notebook, set up and activate a Python virtual environment with a C++14 compiler and an MPI implementation (e.g., Open MPI or MPICH) available, then install the package from a clone of this repository:\n", + "\n", + "```console\n", + "$ cd /path/to/OpenBT/openbt_pypkg\n", + "$ python -m pip install -v -e .\n", + "```\n", + "\n", + "See the \"Getting Started with Python\" section of the [OpenBT User Guide](https://openbt.readthedocs.io) for full dependency and installation details.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SqKKvc8ZS8d7" + }, + "source": [ + "### **Python Setup**\n", + "Next, import the required python libraries." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:10.175580Z", + "iopub.status.busy": "2026-07-20T04:09:10.175470Z", + "iopub.status.idle": "2026-07-20T04:09:11.002486Z", + "shell.execute_reply": "2026-07-20T04:09:11.002035Z" + }, + "id": "ZuRGYOA8VBYC" + }, + "outputs": [], + "source": [ + "# Required Imports\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "from scipy.stats import norm\n", + "from scipy.special import gamma\n", + "import sys\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The BART-BMM mixing model is provided directly by the `openbt` package's `Openbtmix` class (`openbt.openbtmixing`), which wraps the `openbtcli`, `openbtpred`, and `openbtmixingwts` command line tools built during installation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we load the data required to reproduce these examples. The training/test data live in the `Data/` folder next to this notebook, and the Honda EFT model definitions live in `eft_models.py` in this same folder." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **EFT Setup**\n", + "\n", + "The following lines of code import the `sin_cos_exp` Taylor-series model class bundled with `openbt` (used in Example 2) and the Honda EFT model functions from `eft_models.py` (used in Examples 1a/1b). Additionally, the EFT model wrapper class is created (`honda_models`)." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:11.004225Z", + "iopub.status.busy": "2026-07-20T04:09:11.004106Z", + "iopub.status.idle": "2026-07-20T04:09:11.042266Z", + "shell.execute_reply": "2026-07-20T04:09:11.041827Z" } + }, + "outputs": [], + "source": [ + "# openbt imports\n", + "from openbt import Openbtmix\n", + "from openbt.tests.polynomial_models import sin_exp, cos_exp, sin_cos_exp\n" + ] }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "## BART-BMM Examples\n", - "\n", - "This notebook reproduces the BART-BMM examples shown in \"Model Mixing Using Bayesian Additive Regression Trees.\" Each code cell can be executed by clicking the \"play\" button, which is found on the lefthand side of the cell. Alternatively, one can click inside the cell and use the command `shift + enter`.\n", - "\n", - "\n", - "### **Installation Step**\n", - "\n", - "The first set of code cells will pull the openbt package from its github repository. It will then be installed in this ***virtual environment***." - ], - "metadata": { - "id": "QzzGbACrSTz6" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "FBoGbNpBsvE6" - }, - "outputs": [], - "source": [ - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/openbt_mixing0.current_amd64-MPI_Ubuntu_20.04.deb" - ] - }, - { - "cell_type": "code", - "source": [ - "!dpkg -i openbt_mixing0.current_amd64-MPI_Ubuntu_20.04.deb" - ], - "metadata": { - "id": "cVLMD7wAtS5s", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "924136a8-9f20-4455-f618-acae41392d1b" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Selecting previously unselected package openbt.\n", - "(Reading database ... 120500 files and directories currently installed.)\n", - "Preparing to unpack openbt_mixing0.current_amd64-MPI_Ubuntu_20.04.deb ...\n", - "Unpacking openbt (0.current-MPI) ...\n", - "Setting up openbt (0.current-MPI) ...\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "!ldconfig" - ], - "metadata": { - "id": "klEsFy2xt0ZN" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### **Python Setup**\n", - "Next, import the required python libraries." - ], - "metadata": { - "id": "SqKKvc8ZS8d7" - } - }, - { - "cell_type": "code", - "source": [ - "# Required Imports\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.ticker as ticker\n", - "from scipy.stats import norm\n", - "from scipy.special import gamma\n", - "import sys\n", - "import os" - ], - "metadata": { - "id": "ZuRGYOA8VBYC" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "The BART-BMM software is included in the Taweret python package. This package includes model mixing methodology developed by the Bayesian Analysis of Nuclear Dynamics (BAND) collaboration. It will be publicly released in the coming months." - ], - "metadata": { - "id": "n3AzVUdMTMVQ" - } - }, - { - "cell_type": "code", - "source": [ - "# Clone the Taweret Repo\n", - "!git clone https://github.com/jcyannotty/Taweret.git\n", - "!cd Taweret && git checkout develop" - ], - "metadata": { - "id": "Gnn6RcAcVcw_", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "4b773298-c7b3-44e5-f780-1d686f45a830" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Cloning into 'Taweret'...\n", - "remote: Enumerating objects: 2200, done.\u001b[K\n", - "remote: Counting objects: 100% (520/520), done.\u001b[K\n", - "remote: Compressing objects: 100% (126/126), done.\u001b[K\n", - "remote: Total 2200 (delta 434), reused 445 (delta 393), pack-reused 1680\u001b[K\n", - "Receiving objects: 100% (2200/2200), 77.19 MiB | 23.70 MiB/s, done.\n", - "Resolving deltas: 100% (1176/1176), done.\n", - "Branch 'develop' set up to track remote branch 'develop' from 'origin'.\n", - "Switched to a new branch 'develop'\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "sys.path.insert(0,'/content/Taweret')" - ], - "metadata": { - "id": "tIRQ34KbUIo9" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Next, we can pull data required to reproduce these examples." - ], - "metadata": { - "id": "tyjbqQJWTtNV" - } - }, - { - "cell_type": "code", - "source": [ - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Python/eft_models.py" - ], - "metadata": { - "id": "lb2b067Y1NO0" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Examples/Data/honda_y_train.txt\n", - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Examples/Data/2d_x_train.txt\n", - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Examples/Data/2d_y_train.txt" - ], - "metadata": { - "id": "edyzQNUh20b3" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### **Taweret and EFT Setup**\n", - "\n", - "The following lines of code import specific modules from Taweret which are required to reproduce these examples. Additionally, the EFT model class is created (honda_models)." - ], - "metadata": { - "id": "-y74jgN-T2Rg" - } - }, - { - "cell_type": "code", - "source": [ - "# Taweret Imports\n", - "from Taweret.models.polynomial_models import sin_exp, cos_exp, sin_cos_exp\n", - "from Taweret.mix.trees import Trees\n", - "from Taweret.core.base_model import BaseModel" - ], - "metadata": { - "id": "iPvragCRVgpL" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "import eft_models as eft" - ], - "metadata": { - "id": "x0Bi_I8kI6uP" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Wrap honda models\n", - "class honda_models(BaseModel):\n", - " def __init__(self,sg = True, N = 2):\n", - " self.N = N\n", - " self.sg = sg\n", - "\n", - " def evaluate(self, x):\n", - " if isinstance(x, list):\n", - " x = np.array(x)\n", - " if self.sg:\n", - " m = eft.fsg(x,self.N)\n", - " s = eft.dsg(x,self.N)\n", - " else:\n", - " m = eft.flg(x,self.N)\n", - " s = eft.dlg(x,self.N)\n", - " if len(m.shape) == 1:\n", - " m = m.reshape(m.shape[0],1)\n", - " s = s.reshape(s.shape[0],1)\n", - " return m,s\n", - "\n", - " def set_prior(self):\n", - " return super().set_prior()\n", - "\n", - " def log_likelihood_elementwise(self):\n", - " return super().log_likelihood_elementwise()\n" - ], - "metadata": { - "id": "fw3J1Dhcy_q-" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### **Example 1a:**\n", - "\n", - "This section provides the code to reproduce the BART-BMM results for the first EFT example in the manuscript." - ], - "metadata": { - "id": "TFQuzuJPJHSs" - } - }, - { - "cell_type": "markdown", - "source": [ - "The BART-BMM model is trained using the following steps.\n", - "\n", - "1. Define the model set using the three lines of code shown below. The first two lines define a class instance for each EFT model. The third line of code defines the model set. " - ], - "metadata": { - "id": "4HCBcf99VMWs" - } - }, - { - "cell_type": "code", - "source": [ - "# Load the models, create the model set\n", - "fs2 = honda_models(True,2)\n", - "fl4 = honda_models(False,4)\n", - "model_dict = {\"model1\":fs2,\"model2\":fl4}" - ], - "metadata": { - "id": "i81g7jbAJbqi" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Format training and test data\n", - "x_train = np.linspace(0.03,0.5,num = 20)\n", - "x_test = np.linspace(0.03,0.5,num = 200)\n", - "y_train = np.loadtxt(\"honda_y_train.txt\")\n", - "\n", - "y_train = y_train.reshape(20,1)\n", - "x_train = x_train.reshape(20,1)\n", - "x_test = x_test.reshape(200,1)\n" - ], - "metadata": { - "id": "TZ4NBUpeJnsV" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "2. Define the class instance of the BART-BMM model using the `Trees` class. For this example, the class instance is called `mix`.\n", - "\n", - "3. Set the prior information using the `set_prior()` method.\n", - "\n", - "4. Fit the model using the `train()`. This requires the user to pass in the data and relevant MCMC arguments. " - ], - "metadata": { - "id": "w4mwJ3yxVa_u" - } - }, - { - "cell_type": "code", - "source": [ - "# Fit the BMM Model\n", - "# Initialize the Trees class instance\n", - "mix = Trees(model_dict = model_dict, google_colab = True)\n", - "\n", - "# Set prior information\n", - "mix.set_prior(k=5.5,ntree=10,overallnu=5,overallsd=0.01,inform_prior=True)\n", - "\n", - "# Train the model\n", - "fit = mix.train(X=x_train, y=y_train, ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", - " tc = 2,numcut = 300)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7XFXprPL46At", - "outputId": "dafa231d-1fc9-42e6-eb28-0ea764d62bb2" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Results stored in temporary path: /tmp/openbtpy_g53ic6t1\n", - "Running model...\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. Both methods require an array of test points and a confidence level." - ], - "metadata": { - "id": "Njm7D2mQVofQ" - } - }, - { - "cell_type": "code", - "source": [ - "# Get predictions\n", - "ppost, pmean, pci, pstd = mix.predict(X = x_test, ci = 0.95)\n", - "wpost, wmean, wci, wstd = mix.predict_weights(X = x_test, ci = 0.95)\n" - ], - "metadata": { - "id": "twbkYZMI83VU" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "6. Plot the resulting predictions and weight functions." - ], - "metadata": { - "id": "bCoZw9zDVrII" - } - }, - { - "cell_type": "code", - "source": [ - "# Predictions - Upper and Lower ci bounds\n", - "plower = pci[0]\n", - "pupper = pci[1]\n", - "\n", - "# Weight Functions - Upper and Lower ci bounds\n", - "wlower = wci[0]\n", - "wupper = wci[1]\n", - "\n", - "# EFT predictions at test points\n", - "f_test = [fs2.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]\n", - "\n", - "# Define the underlying true model\n", - "fdagger = eft.f_dagger(x_test)" - ], - "metadata": { - "id": "_XdK7S0w-AxU" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Plot the predictions and weight functions\n", - "col_list = ['red','blue','green','purple','orange']\n", - "\n", - "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", - "ax[0].plot(x_test, fdagger, color = 'black')\n", - "ax[0].plot(x_test, pmean, color = 'purple')\n", - "for i in range(2):\n", - " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", - "ax[0].scatter(x_train ,y_train,c=\"black\")\n", - "ax[0].set_title(\"Posterior Mean Prediction\")\n", - "ax[0].set_xlabel(\"X\")\n", - "ax[0].set_ylabel(\"F(X)\")\n", - "ax[0].set_ylim(1.8,2.8)\n", - "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", - "ax[0].grid(True, color='lightgrey')\n", - "\n", - "\n", - "for i in range(2):\n", - " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", - " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", - "ax[1].set_title(\"Posterior Weight Functions\")\n", - "ax[1].set_xlabel(\"X\")\n", - "ax[1].set_ylabel(\"W(X)\")\n", - "ax[1].grid(True, color='lightgrey')\n", - "\n", - "\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 487 - }, - "id": "xhw8PPAd89qi", - "outputId": "6de8b8bf-b3e1-417f-bad0-223d262be62e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "### **Example 1b:**\n", - "\n", - "This section provides the code to reproduce the BART-BMM results for example 1b in the manuscript." - ], - "metadata": { - "id": "lDJp2kAYJMeF" - } - }, - { - "cell_type": "markdown", - "source": [ - "The BART-BMM model is trained using the following steps.\n", - "\n", - "1. Define the model set using the three lines of code shown below. The first two lines define a class instance for each EFT model. The third line of code defines the model set. " - ], - "metadata": { - "id": "NvszngrcV2bl" - } - }, - { - "cell_type": "code", - "source": [ - "# Redefine the model set\n", - "fs4 = honda_models(True,4)\n", - "model_dict = {\"model1\":fs4,\"model2\":fl4}" - ], - "metadata": { - "id": "YMVfKwJzJPT8" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "2. Define the class instance of the BART-BMM model using the `Trees` class. For this example, the class instance is called `mix`.\n", - "\n", - "3. Set the prior information using the `set_prior()` method.\n", - "\n", - "4. Fit the model using the `train()`. This requires the user to pass in the data and relevant MCMC arguments. " - ], - "metadata": { - "id": "H_JYLHFMV6a_" - } - }, - { - "cell_type": "code", - "source": [ - "# Fit the BMM Model\n", - "# Initialize the Trees class instance\n", - "mix = Trees(model_dict = model_dict, google_colab = True)\n", - "\n", - "# Set prior information\n", - "mix.set_prior(k=5.0,ntree=10,overallnu=5,overallsd=0.01,inform_prior=True)\n", - "\n", - "# Train the model\n", - "fit = mix.train(X=x_train, y=y_train, ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", - " tc = 2,numcut = 300)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "P5rtbhRNJZiA", - "outputId": "5095861c-d060-43a2-da0c-30c4f1147f99" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Results stored in temporary path: /tmp/openbtpy_ya3zown0\n", - "Running model...\n" - ] - } + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:11.043370Z", + "iopub.status.busy": "2026-07-20T04:09:11.043287Z", + "iopub.status.idle": "2026-07-20T04:09:11.045394Z", + "shell.execute_reply": "2026-07-20T04:09:11.044985Z" + }, + "id": "x0Bi_I8kI6uP" + }, + "outputs": [], + "source": [ + "import eft_models as eft" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:11.046377Z", + "iopub.status.busy": "2026-07-20T04:09:11.046310Z", + "iopub.status.idle": "2026-07-20T04:09:11.050345Z", + "shell.execute_reply": "2026-07-20T04:09:11.049944Z" + } + }, + "outputs": [], + "source": [ + "# Wrap honda models\n", + "class honda_models:\n", + " def __init__(self,sg = True, N = 2):\n", + " self.N = N\n", + " self.sg = sg\n", + "\n", + " def evaluate(self, x):\n", + " if isinstance(x, list):\n", + " x = np.array(x)\n", + " if self.sg:\n", + " m = eft.fsg(x,self.N)\n", + " s = eft.dsg(x,self.N)\n", + " else:\n", + " m = eft.flg(x,self.N)\n", + " s = eft.dlg(x,self.N)\n", + " if len(m.shape) == 1:\n", + " m = m.reshape(m.shape[0],1)\n", + " s = s.reshape(s.shape[0],1)\n", + " return m,s\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TFQuzuJPJHSs" + }, + "source": [ + "### **Example 1a:**\n", + "\n", + "This section provides the code to reproduce the BART-BMM results for the first EFT example in the manuscript." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The BART-BMM model is trained using the following steps.\n", + "\n", + "1. Define the model set using the two lines of code shown below, each of which creates a class instance for one of the EFT models." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:11.051334Z", + "iopub.status.busy": "2026-07-20T04:09:11.051267Z", + "iopub.status.idle": "2026-07-20T04:09:11.052757Z", + "shell.execute_reply": "2026-07-20T04:09:11.052458Z" + } + }, + "outputs": [], + "source": [ + "# Load the models\n", + "fs2 = honda_models(True,2)\n", + "fl4 = honda_models(False,4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:11.053691Z", + "iopub.status.busy": "2026-07-20T04:09:11.053618Z", + "iopub.status.idle": "2026-07-20T04:09:11.055786Z", + "shell.execute_reply": "2026-07-20T04:09:11.055455Z" + } + }, + "outputs": [], + "source": [ + "# Format training and test data\n", + "x_train = np.linspace(0.03,0.5,num = 20)\n", + "x_test = np.linspace(0.03,0.5,num = 200)\n", + "y_train = np.loadtxt(\"Data/honda_y_train.txt\")\n", + "\n", + "y_train = y_train.reshape(20,1)\n", + "x_train = x_train.reshape(20,1)\n", + "x_test = x_test.reshape(200,1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Define the class instance of the BART-BMM model using the `Openbtmix` class. For this example, the class instance is called `mix`.\n", + "\n", + "3. Set the prior information using the `set_prior()` method.\n", + "\n", + "4. Fit the model using `train()`. This requires the user to pass in the data, the evaluated model set (`f_train`), the informative-prior standard deviations (`s_train`), and relevant MCMC arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:11.056679Z", + "iopub.status.busy": "2026-07-20T04:09:11.056616Z", + "iopub.status.idle": "2026-07-20T04:09:27.084838Z", + "shell.execute_reply": "2026-07-20T04:09:27.083977Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('numcut', 300)\n", + "Running model...\n" + ] + } + ], + "source": [ + "# Fit the BMM Model\n", + "# Evaluate the model set at the training inputs\n", + "f_train = np.concatenate([fs2.evaluate(x_train)[0], fl4.evaluate(x_train)[0]], axis=1)\n", + "s_train = np.concatenate([fs2.evaluate(x_train)[1], fl4.evaluate(x_train)[1]], axis=1)\n", + "\n", + "# Initialize the Openbtmix class instance\n", + "mix = Openbtmix()\n", + "\n", + "# Set prior information\n", + "mix.set_prior(k=5.5,ntree=10,nu=5,sighat=0.01,inform_prior=True)\n", + "\n", + "# Train the model\n", + "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train, s_train=s_train,\n", + " ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", + " tc = 2,numcut = 300)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. `predict()` requires the test inputs, the evaluated model set at those inputs, and a confidence level; `predict_weights()` requires just the test inputs and a confidence level." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:27.087580Z", + "iopub.status.busy": "2026-07-20T04:09:27.087466Z", + "iopub.status.idle": "2026-07-20T04:09:32.291565Z", + "shell.execute_reply": "2026-07-20T04:09:32.290903Z" + } + }, + "outputs": [], + "source": [ + "# Evaluate the model set at the test inputs\n", + "f_test_arr = np.concatenate([fs2.evaluate(x_test)[0], fl4.evaluate(x_test)[0]], axis=1)\n", + "\n", + "# Get predictions\n", + "pred = mix.predict(x_test=x_test, f_test=f_test_arr, ci=0.95)\n", + "wts = mix.predict_weights(x_test=x_test, ci=0.95)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bCoZw9zDVrII" + }, + "source": [ + "6. Plot the resulting predictions and weight functions." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:32.294503Z", + "iopub.status.busy": "2026-07-20T04:09:32.294378Z", + "iopub.status.idle": "2026-07-20T04:09:32.298787Z", + "shell.execute_reply": "2026-07-20T04:09:32.298431Z" + } + }, + "outputs": [], + "source": [ + "# Predictions - Upper and Lower ci bounds\n", + "pmean = pred[\"pred\"][\"mean\"]\n", + "plower = pred[\"pred\"][\"lb\"]\n", + "pupper = pred[\"pred\"][\"ub\"]\n", + "\n", + "# Weight Functions - Upper and Lower ci bounds\n", + "wmean = wts[\"wts\"][\"mean\"]\n", + "wlower = wts[\"wts\"][\"lb\"]\n", + "wupper = wts[\"wts\"][\"ub\"]\n", + "\n", + "# EFT predictions at test points\n", + "f_test = [fs2.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]\n", + "\n", + "# Define the underlying true model\n", + "fdagger = eft.f_dagger(x_test)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "execution": { + "iopub.execute_input": "2026-07-20T04:09:32.299928Z", + "iopub.status.busy": "2026-07-20T04:09:32.299858Z", + "iopub.status.idle": "2026-07-20T04:09:32.709444Z", + "shell.execute_reply": "2026-07-20T04:09:32.708989Z" + }, + "id": "xhw8PPAd89qi", + "outputId": "6de8b8bf-b3e1-417f-bad0-223d262be62e" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAHVCAYAAACNGrqAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV4FOfXxc/G3QMJJLhLcSst2pZChULdlbp8pe6l8i9Qd6HupaXeUlqkOMUKxV0SiLvrfs95hwmbsJvsbnazu8n99ZmyOjszu5l3znvvPddgNBqNEARBEARBEARBEATB5Xi5egMEQRAEQRAEQRAEQdAQkS4IgiAIgiAIgiAIboKIdEEQBEEQBEEQBEFwE0SkC4IgCIIgCIIgCIKbICJdEARBEARBEARBENwEEemCIAiCIAiCIAiC4CaISBcEQRAEQRAEQRAEN0FEuiAIgiAIgiAIgiC4CSLSBaGJ2LNnD95//33k5+fLMfcwPv/8c6xYsaLmflVVlfouN23a5LDPcMY6BUEQBOfx4YcfYt26dc3qEH/88cdYu3Zto8axjRs3Ony7PJ1vvvkGf//9t6s3Q/AgDEaj0ejqjRAEcyxYsABJSUk19wMCAtC+fXuMGDECPj4+Dj9oO3fuVELskksuQUhIiFMGvmuvvVaJ9S5dusCZHDp0CH/99Ze6fdZZZyE+Pv6E13AQ/u+//9Tt66+/HgaDAe6I6b4Qb29vREdHY9iwYWjdunWTbENMTAzOO+88dfFBSktLERgYiKeffhqPPvqo1espLy/Hp59+iqFDh+Kkk06q9Zy96xQEQfAEDh48iIULF9Y6l/PcynN5q1atHP55vLz94IMPMGDAAAwaNAjOgNci9957L2bOnAln8tFHH6lx/Mwzz6z1eE5ODubNm4fY2FhMnjy51nMlJSX44osv0KNHD5xyyilWfxavtW6//Xa88MILNm+nPo498cQTePLJJxt8PcfUfv36YciQIVat/8svv0RxcbHZ57j/PA6uhNuXkJCAUaNGnfBchw4d1PfASX9BsAbHKx1BcBAvv/wyFi1ahKuvvrpmMFq8eLES0F9//TVGjhzp0GPNGc5bbrkFp512mlNEerdu3ZQYDg8Ph7P5999/MW3aNHX74YcfxrPPPnvCa26++Wb1OnLNNdc4ZeLDkfsyZswYdO7cGRUVFWqWfseOHbjnnnswa9asJt8mHit+l7z4swVeXHBfnnvuuRNEur3rFARB8ATWr1+vzn9jx45Fp06d1KQlz+W7du3Cfffdh//9738O/TxGdfl5jzzyiNNEOs/ZnHR1Nm+88QZSU1Nx5MiRWo///vvvah+Dg4PVNZKvr2/Nc8uWLVPPvf766zaJdAYTOHHSFHD7HnjgAatF+vTp09W/Z5999gnPjRs3zuUindvHiRRzIp0BoK5du7pkuwTPxD2vygXhGP7+/jXRS3L06FH0798fF1xwgZqV5/Oewsknn6yWpoQR+88++0xFZ728jle3bN68WYlfDhiM7HsCvBi64ooraiIkN910E2bPnq0uvi666KIm3RYKatPfpbuuUxAEwd248cYblWDRz+U8t3PicvDgwZg6dSo8iXfffbdJPocClJFtTmh079695nEGLnr16oXt27fjn3/+qSXGlyxZUvNeW3j77bfhzvC6xhPHSmdnWwjNDxHpgkfRpk0bJcjefPNNVburz/ampKRg9erVKlJJ4cmZ7brp20VFRVi1ahXS09ORmJioxB1nnwlrylauXFlTN8R0asIZUaYu6RQUFKiU+IyMDLUtp556aq2Jgm3btqntuPzyy2sGUM5+8yKEYnjp0qVq+8PCwmptW0PbX99664NZCI899pjKSDj99NNrpc4xksHttyTSG9rX5ORk/PHHH+o2t5UpbrxY4CSKKabbztcxdb2wsFBlQrRr1w72wPXceeedmDNnDubPn6+OKf9lZIYpb4w28PuMiIjAGWecod5TXV2tvmfuL7eVnx8XF3fCuhmN4MUNozCjR482m4bJ53gMeVFZd3950blhwwbs3r1bfT5/o/w9ZWdnq9RDwu3QLzKYYcFZ9/rWyRRCfhecpGKkgBdioaGhJ6Q1shSkd+/e6mKN+8nvuKknhgRBEGw9l/Pcx3O4LtLLysrUOZzjDM+fPOeZy0LjZDPPdUzRZto0S+IIvV+YcUd4raCfbzt27Ijx48efcL6m+PXz81Pny7Zt29Y8X1lZqUrV9PMyI/8c0zhGUyyzJr1v374nRIIb2v6G1mtJpHPsryvSGflmmjVvm4p03ucYx3HZdH/5WSzv4/5yzDC9xiHcLr6nboZAXl6eGhu5b/wcHqdvv/0WUVFRtY6pKfwsTiBwrOc1hH5dw2sA/fth2Z3+/TAlnNmM9lL3uJry888/qxILlgDqMIjBcZLXA9xO/p5YRsfMPUvZhczi4zbz+PF75/HTx2+Oxbr/EOH1w7nnnltzbamv2xS+l9dIBw4cUOM6t6VuRoCt28nXcDt5vPn7lAi+h8KadEFwRyZMmGAMDg4+4fF7772XPgrGpUuXqvsPPfSQ0cfHx3jyyScbp0yZYoyKijIOGDDAeODAgZr3/PHHH8bIyEj1+OWXX24cN26csXPnzsZff/1VPT9v3jzjyJEj1Xovvvhi4/XXX6+WrVu31qzj3XffNYaGhhpPOukk9Zru3bsbExMTjevWrat5zcsvv6zW8ddffxn79++vtqdt27bquY8++kg9t2fPnlr7Y83217dec/zwww/q9fx30KBBxssuu6zmufLycmNMTIxxxowZah/5uoqKilrvt2ZfeWz043TdddcZzz77bGNQUJDaj4KCghO2nd/XkCFDjOeff75x4MCBRl9fX+MXX3xRzy+g9r589tlntR7fu3evevzSSy9V98ePH6/29f333zf269fPeN555xkvuOCCmm3t3bu3sVWrVsapU6eq7z8gIMA4e/bsWuv8+eefjWFhYcZu3boZL7zwQvWeX375xRgdHa32U6ekpER99tNPP13r/f/995+xT58+6js866yzjOecc46xQ4cO6rs/fPiw8corr1Tv43HQj92HH35Y7zoXLlxojIuLU+vhNvXo0cMYERFh/Oabb2pek5KSot77/PPPGy+55BLjaaedpj6bx5j7KwiC4Gq+/fZbdZ766quvaj2+c+dO9TjPj2TFihXGhIQENebwnMdzKsejjz/+uOY9+fn5aszmuZljCheO6dOmTVPPp6enq3GJ6+WYqZ9v33777Zp17N69W421XAfHi9NPP93o7+9vfPLJJ2tew7GM6+BjPLeOGTPGOHr0aOOcOXPU897e3sYHHnig1v5Ys/0NrbcuhYWF6nzO9enwGoHrWLZsmfGmm25S79fJy8tT22Y69nPM5BjJ8Yn7e8YZZ6j9ffTRR2t9Fh+75557aj32559/qmuoTp06GS+66CJ1bcDvkcecx15HH8cef/xxdbzHjh1rnDx5shpvOS5VVVWp12VmZtZcf3Bd+vfzxhtvGOujdevW6nu3hH5c646jZNiwYbWOEQkPD1fHjt/hKaecosZLXgMMHjzYWFRUVOu1R44cUfvD6xzuC1/L48F95TUUtz8wMNDYtWvXmv353//+V/P+9u3bq+tPU7Zt26aur3htwuPIawMe/1mzZtm1nby+4/Hm743/8rvq2bOnul33Ok9wf0SkCx4l0nmSoXDiCT8nJ0eJSZ6QTQfepKQkdTKkUNMHBJ40dcGmw0H877//rrnPdXBdpuJY56efflLPPfvss7W2hQNmfHy8GkBNBemZZ55pzMjIUI9RnFkS6dZuf33rbUikv/7662rg4KCtT0gYDAbjwYMHzYp0a/fVHMnJyWoQnT59es1j+rafe+65xqysLPVYdXW1EpF8bXFxscX11SfSX3rpJfX4K6+8UiPSub5bb7215rjxGPF3wu3mwJabm1vzfopcvv+3336rOe78vXGg1I9HaWmpmgTgoNyQSOe+8fOHDx9e8x0RHq8FCxao29wWvu+55547YT/NrZPHk4Mt/xb4POG+XXXVVWpiZ9OmTbVEOi+YTH/Tn3/+uXr8999/r/cYC4IguEqkc7KUj1Og8dxJETlq1KiasYbjxS233GL08vIyrlq1Sj1GEUMxk5aWVrMevu67776ruc/zONf7yCOPnLAtFDac+KRopWDU4cQ936NPguqir127dmps1NHH37oi3drtb2i95qA4jY2NVesjnJDm2F5WVqaOKY+HPp5ycpnr52sIH6eg5KSE6fjEAAZfZzphXlek8/WcGJ44caIaE0llZaWaEKFwNyfSeWw56V33uH755Ze19omP1Z3kqA+OsV26dFGTGaYLAxj2inRuq+nkCIMRXAevMXS4v5zs4WtNr+H4GzP9/rh9V199tdltryvSeSy5Pl7Tmn4n3HZ+vulv2drt5PfIx0wDTITbqH93gucgIl1wWyhMOFjoJ2FGCTnLyEFRF7WcoeYsYV10wb148eKaE5wecbVEfSKdJ3cKfX1wNJ2JNxWQuiD99NNPT1iHOZFu7fbXt96GRDrFo5+fn/G9995TzzHiTUFLzIl0a/eV8DUbNmxQAy8vBvg9MUrO2V0dfdt5gWbK999/rx5fu3atVfvCbeX633rrLXVxQJF66qmn1lyUcJ/4mOlFm+nnm2YB6HBbGfEmzzzzjHodow2mbNy4sebz6xPU/H02tD+2inR9mzZv3nzCBBOjKjfeeGMtkW56saRfWHCCwXTSRBAEwZUinect/VzO8yrHdEaSeQ7kpCtfs3Llylrv5QQrz2V6ZJgikvd5LrREfSKdn8/nlixZcsJzFNi6mNNFHx8zR12Rbu32N7Reczz22GPqPczYIhR8jOiajgHMvCJ33323ur9///5a1x+6mDWFmWWm0em6Ip0T/Xwvx0JTDh06dMK4o49j+jWGKRSwzG5orEjnokeq60bg7RHpFMl1YXR/0qRJNff1SY+GrsFsEekU4aYTQqa/W2ZimP42rN1O/Xpn165d9W6n4BlITbrg1rBWZ82aNeo266FpGMf2Fazj5XOsu7nssstOeB/rkQjrhugkS9d2mnbw9eecc46qNa5bY20JjiN0pWUN+yeffKLu64+zzpk1P1yvKXVroSztm7Xbb8t668J6MdZEsU6L+846ctZONXZf9+7dq9qSsU6adXysoWK9F+vWWLNWF9YLmqLXwbHNnjXOrvv27VP/0gCP+8S2M6wt42fqsHa+bg05W83xPTTL27p1q9oXfb/4Xn1/eKxZD0YHeVPowm6N8z3rGumsO3DgQDgKve6NNWWm8Fizxk9voWfpGHP/WJNo2spQEATBlbBml+Mfz8s8l/3444+YNGmSus9zGseZuudR1nOzrlY/51155ZXKtI312VOmTFG1uayL5hhgDXofcNZm04TWdFzgv6znNcXasdfa7bd1vYT7RxNY1oVzTOC/t912m3qO53keC9ah83V8jvX3XEz3l14prJM33V/9WsQSW7ZsUd9N3XGIY1BkZKTZ99Qdiwhr2B0xFjnaOM7ctvL6xHRbOb6T4cOHO+xz9d9C3c4DvN7gNuk+SbZs5/nnn6+6JPD3R38eXj/y96D/DgTPQkS64FHu7qZQNHIxJ7T1x9iui9A5liZw33//vWpZwpMYhR7XXbe3qDkjEg5iupFaXa677roTTp7WtAGxZfttWa852GKNLUsef/xxBAUFWXTQtWVfOfFB8xeKZ9OBeuLEiWpQr4up0RnRW8XQ7M1Wd3dLmDs+nDDgoEdjlrpQgOtmPtx3c98Fha41Ip3fFffJdNKgsfC74DrN9bDnttb9fdQ9xoTvt/YYC4IgNKW7e1108W7aSsz0nMdJYMJxiGZvnLRn+9Q77rhDmcXRRI2GoqbdTMzBcYGv4aR0XRgEqNsi09qx19rtt3W9hCZvND2lEKchKifITU3IeJvP0aSUk9Icr033l+MIjdzMid6ePXta/FyOjRzXzI1tnEQ2h6vGIn0beW1VFxqw0mDQnm3Vx1pz77cX/laIpWtAe8Z3miJz4olGsjQMfuihh5CZmakCNTTq4+9H8BxEpAseC09OnMnlQF0XnqT0wUeH0XMuhIMbZ+4p/HSRbk4I6Z/DWcj4+HiHzt7auv2NgRMUnGnnxQv7klKoN3Zf6VDOzAZTgc5Bh9Fqd4LRBU7OcGLGnFO7DiPofB0vcDiBo3Po0CE1uDdEjx49VHR///79yoXVHJZ+Y/VtE7sS0K3e1HGYF1yM/jAzQhAEobnAcx7HEWZqmbqYUyhyQtg0ksmo+f33368WChpGmbnwvMgsr/rOt1w3hRx7qDsyymjL9tsKBTHdvdklZuHChao7jWkWGkX6Bx98oFzMGSU3bb3GbeFj7Eluq9M394nHl2Mh3dd1OCnCbjnuBEUou+ewK40pPP50Tx8wYIBd6+X4ThiAoBC2hC1jvJ61x2vAug77vAa09/qP1y+ctOLC3/h7772ngir8bdx+++12rVNwDfVPNQqCm8NUcUZ8TaOkHExefvllJcg428xZRg6YpnBwZzoQBZA+m6nPaLMFV11uvfVWNVvPmcm6pKWlISsry2nb76jZZab7c1KioZO0tfvKQaXuBAMnAXJzc+FOcJ85K81WdHXhwK23oGNkhwPsK6+8Uus1r7/+usVoQd1sBb6On1N3Fp8XB4QXD9wWc78xc+jbxH7wdbeJ7foayiwQBEHwJNhOk+PV888/X+txThpz7NHPeRQxpudZTjBzMloXj4Tr4SSyufMt25NS5PJ8rad96/CawNzkuSO3316Yuswx9rXXXlNt0Ewj9hTpHNM4IU1MRTrLA0JCQlQ2Xd3xiffr298LL7xQ7dOrr75a6/E33nij0ZFlXndZOx5aC8sF//zzz1r7SaFqLrpuLZz04TXZM888o9qsmRvfbd0fRrf5nbz44ou1tu3XX39V5Qf2/FZ4PWMagWdWBwNSpn8XgucgkXTBo+GAw5p1itmbb75ZnUS/++47VU/GOjdGjClmOLPOWUuevHkSZS0Q+05y1l1Pj2KNOlOf77nnHhUhpuDS+6RPnz5dzYLzPoUTBT7Xy6gxP5+9v/Xe6o7efkfBixIuDWHtvvLihpMMrIFin2/2omVaFY/1smXL4C7we2d/Ul6k8HvngMW0MU7csC8vv29GFrifTzzxBJ588kkVDWed2KpVq9S/5tLM6sJZb6Ze8hgz2sHyAr0vPGv2n332WXWfdfSs94+JiVEXkHqfdHNw1p8Xe/fdd5+qI+RFGdMYP/30U/U98TMEQRCaC4z4UvxxMpmTwqyp5XjIfuSmafLsC84e3RynmLlEYcTX8JxpWs7F8Yhpvox+8pyr90lnZhIzny699FJ1XUDBFBERocY++rbws8z1K3fU9tuLLrwpxjgBbYpel07BzT7nvK/D7LgffvgBF198cc3+cvzhWMf9ZZnAgw8+aPYzOT5yHOKYw6wupt1zvOcxZMDD1gwxU/j98HtkhJ7XZo3tk044hvM48bqK4y2j34wu9+7d2+51UkzzmoyZl/yNcTKGk+68RuA1JPdB3x8GWWbMmKGOj2mf9LrwOorXApdffrn6nfC9rC+n1wI/5//+7/9s3k5mWLzwwguq7JDfG6/deF3C3z2/Y8GzEJEuuC0cfBtK92FqEyO+nHmkMGQKMAdBisfWrVur11DoclaSM6sUmRzAOKjzxK2nMBEOEIxoU9BRCHE2nYMRRTpnI99++22VMsTPosDjCZYClSdZPdLap08fNXCaE9cUY3xOr4G2dvsbWq85ONDx9aapaebgxAQxrd+zdl852PP74cDFmeTTTz9dDVx8jWnqlqVt5zr5eF2jNkv70tBvgeKbA5I5OODx2HIChL8FXtBxwH744YdrGQ1RpHNwZ7ogB8sbbrgBEyZMUBdbpgY/rFHnNtVNnWPEgUKavyH9uD311FM1x5nQwI8im9vB3yIHeIp0S+vkJAK3gRdYNP3hxSZ/p8OGDat5DY8t38tjXRduk+nFmiAIgiugULDmnM8Ja4oWnq95HqXQYYo3z606PK8ye+mXX35RgpWCiZFeTlya1k5zLOM4zklmCnBGminSCc+rHLv4OXyeEWqK3HvvvVeVohFGqs2dl3X43NChQ23e/obWawlOGt90001qP8yJP07ocnzgRHFdKH71/eX1D+vjKeQovtu3b1/zOoo50/GF3H333WqymSVhhw8fVoEMikoKSgpYHX0cM2egynG4rr8LJzR4/Hj8OWHAUq76RDoFbX1la4TjLb0GODnDcZ/HiZFwehPV/fyrrrrqhO+P8HqmrlEef0f8Pjm+8/gxYs3foGnZGcU5r/VY+8+JdV5r6t8Tr+3qlhpwQonXAVwn958BgZ9++kn9Nu3ZTl638Tjzuozr5bUBAyo0V7TGKFlwLwy0eHf1RgiCIAiCIAiC4Bkwc47BDWaJccJbEATHIjXpgiAIgiAIgiCYhVHhutDnhpl3lrrFCILQOCTdXRAEQRAEQRAEs/z222+qVItp2Exvp7ksH6NQNy0bFAShmaS70+nynXfeUcYLrBNhvc5tt91Wb90t63B4omCva9aVsm6ILaVMa30EQRAEQRAEQXAMbLtKYzJG1VkXztpnU68WQRCaiUinKReNoNhigGYMNHyiaRMdGJcsWXKCuYMODS7oys2WRDSUoisl2xfQQZlGHYIgCIIgCIIgCILgqbg0ks4e1exTqcP2SP369cPKlSuVi6Q56JRId0e2ztKhozFbLbz00ktNst2CIAiCIAiCIAiC0OyM40wFOtHbOJSXl1t8D/s7MuWGrQ8IW0GwVZK51gSCIAiCIAiCIAiC4Em4VQs29lacP3++6kNoqS6d0Xe+bvHixaq/MXsgzpo1S/WNtAT7LnLRqa6uRnZ2tuphbDAYnLIvgiAIgmAtHIoLCgrUuEbHZKHxcKw/evSo6j0sY70gCILgSeO927i7v/baa6rWnCK9PuO4N998U9Wssy9j586d8eeff+Khhx7CoEGDVJTdHM899xxmzJjhxK0XBEEQhMbDzLCEhAQ5lA6AAj0xMVGOpSAIguBx471bRNLfe+893HHHHfjmm29w3nnnWXwdZx0Y/X7rrbdwww031Dx+9tlnqxlzOr5bE0nPy8tTrvCMwoeFhTl4b5ofNPljdgON/ry9vV29OS36ON53nwEffOCFO++sxpNPuvxP1yXI71GOYXP8Lebn5ysz1NzcXISHhztsG1syHOsjIiLUhZCM9db9nnft2oXu3bvLWN8I5Dg6BjmOchyb62+R4z0nkBsa710eSX///feVQP/qq6/qFeiksLBQ1aK3bdu21uNMF6DpnCX8/f3VUpfIyEgZuK38cdIvgMdLRLprjyOTRf7+G4iN5e8XLRL5PcoxbI6/Rf39kpbtOPRjSYEuIt363zOPlYz19iPH0THIcZTj2Nx/iw2N9y4tfPvwww9VX3QK9KlTp1pMVaebO4mPj1cRi3fffbcmMs5o+E8//YRTTz21SbddEFzBzTcDe/cCjz4qx18QBEEQBEEQmiMuE+kM8U+bNk05vLPn+fDhw2uWn3/+ueZ1+/btw+bNm2vuMyWe6YWMnp900kno2bMnRo0ahSeffNJFeyIIgiAIgiAIgiAIjsFl6e5MG2A/dHPQEE7n4YcfVmnuOgMHDsSWLVtw5MgRZGVlqdpyphoKgiAIgiAIgiAIgqfjMpHu4+OjouYN0alTJ7M5/HTDEwdcoSXyzDPMKOEEFnDppa7eGkEQBEEQBEEQHIk0YxUEDyM1Fdi6Fdi0ydVbIgiCIAiCIAiCo3G5u7sgCLZx/fXAxIks/ZAjJwiCIAiCIAjNDRHpguBhDBigLYIgCIIgCIIgND8k3V0QBEEQBEEQBEEQ3AQR6YLggWzYAMyZAxw65OotEQRBEARBEATBkYhIFwQP5L77gBtvBP7+29VbIgiCIAiCIAiCI5GadEHwQEaNAnx9gagoV2+JIAiCIAiCIAiORES6IHggTz7p6i0QBEEQBEEQBMEZSLq7IAiCIAiCIAiCILgJItIFwYOprtYWQRAEQRAEQRCaB5LuLggeyllnacZxS5YAQ4e6emsEQRAEwQxGI1BefnxGubISqKjQ/tWXqqrjr+XreJ+P6+/RH9cX3tcfr/s6U7y9AR8f7Xl+pv68l5e26Ovz89Neq78nOBgICwNiYjQDGEEQhCZGRLogeCilpUBxMbBtm4h0QRAEoYnQBTGFNMV3SQlQWKgNSByY+DjFMB/Pz9eWsrLa7zMV4aai2x4otg0Gy9vKdfN5vs4U/XHT15lCcR4erjm08nUU7W3bAq1bAyEh9m+vIAiCFYhIFwQP5eWXgYAAoFMnV2+JIAiC0GwoKtLENxdCQU2hnZMDpKcDBQWaoNWj2HwdRbi5KDYj1Pqii2Q+ztuMcOu3LYlsV8J94n4nJWn3OQGxfr0m1tu105Y2bY4L9rqTAIIgCI1ARLogeCgnneTqLRAEQRA8Cgrp3FwgK0sT3UwBJxSjeXlA797At99qglR/To8yU4RyZtjfXxPVXIKCtGgzH2tuIpX7FBtb+zF9wmL7dmDLFiA0VJuA4LHo2hXo1087RoIgCI1ERLogCIIgCEJzhNHg/fu1dHQK7SNHgLQ07T7Ro9hM7abgJvyX0WJGunUx3twEuL0w8h8ZqS2cvGBWgV5fv3KldqwHDnT1VgqC0AwQkS4IHgqvtz77TKtJf/RRbUJfEARBEFQkfN8+4L//NGFOKLYZ5aXAZJp23RRz/T4Hk8bUiLcUOHHBLAIdmsylpgJ//gmcdpom2jn5wbQ3GtEJgiDYgIh0QfBQeD310EPA0aPA5MnAySe7eosEQRBOpLq6GvPnz8fbb7+NxYsX45577sHTTz/d4KFauXIl7rvvPmzfvh3x8fHqfTfccIPrDjHTw/U6bXeFZm2ZmcCuXZpgZFS8c2ctKi44P8pOYzm9TGDzZs1Mj9/JmDGSjSAIgk3IWVsQPJjLL9fGfwZGBEEQ3JEFCxbgzTffxM0334z9+/ejQhcx9XDgwAFMmDABt99+O7777jv8/fffuOaaaxAWFoaLLroITQ63ef58TQC7M7pjOqPhdBVtSJwzYs594+RDZSV8WV/NmV8+pqdxsw7b9LbeQk2/berW3tC/jCwnJgLt22vGa80xBYzHkHTsqJUVUKzHxwM9e7p6ywRB8CBEpAuCBzN7tqu3QBAEoX4mTpyoFvLwww9bdbjeeOMNtG7dGjNnzlT3L7vsMvz555+YNWuWa0T6Cy8A//yjpTDRUEzHtF+3aYq46eOOeqxuCrq5z9RT1jl7S5d2PZJr2ptcF+DHhLkOu4R3RxPD9mYU7Jxp5rbTKT0uThO1XPQ6eT6u9zH3JJjmzn1g6jsnTLp0cU8ne0EQ3A4R6YIgCIIguBUrVqzA2LFjaz02fvx4fPrppyguLkaQLt6aCk4W0NW7mVPt7w+DtzcMjHhTFFNYmt7WF9P7+m1r/uWkAVuaHT6stXPLztaWhuB72Z+cAp4Lt4k14RERWoo5zdrcNaWfkw30BWAmBrdz2DBt+wVBEOrBTc9ogiBYC4MnycmaD5AnBhoEQRDqkpKSokS5Ka1atYLRaER6ejo6dOhwwnvKysrUopN/TFRXVVWppTEYWFvEtlsUhnrLLXPGa/pjps/Z8lhj30/0VmlBQTDqkVyKQi66sOY+6I8du13l64vdHTqg26FD8G4K4zgK9sOHYaBg13uv5+XBkJLCH4CqqTeY9mpnGj4XMxh790Y1TVpMjdxcRNWx70H/V30vTPHnPq5bp5UjDB8uA3ZDx/HY32xj/3ZbOnIc3e8YWrseEemC4MHwmobXqrzG4fWjlLwJgtBc8KrT9ku/T6Fujueeew4zZsw44fFdu3YhhOnSjeHWW9FS2M3086aiV6+GX1NVBd/0dPglJanF9+hRGCor1eKTkYHQZcvgvW0bqu6/H4dfew2l3Zs8ad/649i377Endzf59ngqu+VYyXFsZr/FQr0FZgOISBcED4YT9Mz0Y3CB7VlFpAuC0BxgPXpGRkatxxhBNxgMKqJujoceegjTp0+vFUlPTExE9+7dleFco2CE/vvvAW6Tp9UU191evTe6aeTeywtV3t7YPWIEuq1bB29Ge/VJEk6KsHa9Tg17zboZidcXRu31tHP9cxwFv3cugwbVfvycc2B8+mn4HT2KzpdfDuNtt8FIR3tG1V0QWWcEnQLdYkYCMzzYq15viTdunObAL9Q+jlVVShR169YN3pImaP/vUY6j2x1DPcurIUSkC4KHM3eu1p6VY70gCEJzYMSIEcoozpQlS5agb9++CLbQc9rf318tdeFFVaMvrCg+R43SxLq7Y5r2ztvcd9PUaz6uL3XT5lNT4T1lCrz1mm9CwU6Bzt7r3H89BZ2CnREh1pTn5WlGdWz7prv36ymd/Hy6uOt12JwwcaToSkgAXnxROakaNm2C4aWXju//xRcDNBp0gcijQDcr0nksdFd71qovW6bdZ+264Jy/X8Hhx1FvDMGFpwjdx1JvBqHP6emnAf050wYRdR93Z8LDgawsb8THN/4YWvs9iEgXBA+H1yeCIAiezA8//IBLL70U+/btQ9u2bXHrrbfivffeU+7ud955J5YuXYovvvhC9Vp3GWwZ1pzhVTJFNgVj3YtICxMjtaCAZ921LuJ5n8KdBnEUo/qVO2vRmQLmSFjO8MQTwOefA4sXayqA2/LVV8CWLcD992smc+4Gj8O+fcDffwNnn908W9IJHgdFN+ffGPDlojeK0IU15+v4OP/laYOv19+nJ97o3SCtSaYxZ/HhTvB0yIQXJlI15VyaiHRBEARBEJxGWloa2h+rzy0vL8fOnTvxyiuvYNiwYUp86+mENH3T68179OiBn376CXfffTceeeQRxMbG4umnn1a90gU3hVkMZjIZFHqojOYpf/1Vu12cI6+kr75aWwiFLyd1tm4F7rkHuPtureVbdLTl7XQFNJbZswdYtYotDNzXpV5ollCMcx6NXo2cS9Mj3RTlXHQBzj8vPfmG//JPiMkx/FdPutGf0xs61LEV8VgMLppAkDOBIHg4vNZ55hlgwwbgnXe07jSCIAjuVF+em5tbrzHc1KlTUVJSggCTup0JEyZg+/btqK6uPsFETvAweNXOhZM1THdnGM7Z9eJjxmh9yTlA0rjl4YePR93vuktrheYO6MeFkwlUPMxaYA1bx46u3jKhmUEBzg6ITN5gFJyR8cxMrVpF/9PQK2GY1MGuh1Jp4DpEpAtCM5jhY0bfjh3ATTcBEye6eosEQRBqYyq+zUERbuk1ItCbEZGRWuSYA1ZTmLqxHuz554HXXwf+++94Hf2zzwJTpgBXXukekevAQM0Ub+NGbRsZ8Z88GYiNdfWWCc2EgweBzZu1bkCMjvN0y+tHzgnRt1DEuPvhBmcmQRAay513arOi4u4uCIIguDWMbm/bponRphDIDAnqUXSGDj/5BPj5ZxohsD8fcN99Wgq8q2HNvF43z/T31au1WXfdcE8QrIACnOnrvCZkpiWTmPgT+v137T7nrdyp2kOwjIh0QWgG3Hyzq7dAEARBEKyAKoF1WSyCTUxs2kNGtXLDDVp/9tde02rkmfrOmvUBA+A2MP2dPZl5rAYOdPXWCG6M3kAgJ0eLkvNnww5/un8jU9dPP10zPBNx7lmISBcEQRAEQRCaBiqFIUOA337TbKOtcY53NCefrKXdz5oFHDgAPPmklopGEc/oNZ93Jew5z9KATZu0XGQX9HsX3BvWkTN9nWnspKREs3pgXTlryVlBYWp6xvR2cx0BBfdFnFgEoZnAVrVLlmgnakEQBEFwWyg8+/TRXKx0++impk0b1VsdEyZo6oVRdaoePsbbrob16HT1oqGcIOB4xQbtFebNA/7553g/corz7t215AtdoAuejUTSBaGZwOsdZg+yi8uIEa7eGkEQBEGwAHNwGU1nXi6tpjt1co1zFaP6t92mtT5jIe+KFcCaNZrZ3CuvuDaCzRAoQ6IU6VRfdHwXWjS8xqNVwf792k+TPwt37i9uCbZ2Y3o+JxdWrgT+/FO7794x7d645x6jOjU0FSLSBaGZwHI6pjPprTQEQRAEwW2hyjjjDGDxYs0ojQMYhTpdzpu6eLZHD23hxMH06VrD6JdfBh5/3LXNnunyTnO7vXtFpLfQlmmcO9LN4Nau1bIl2Z2PFRGeBv/MaWC3fPnxmnnPwHDs36atFxCRLgjNhJ9+co9OMoIgCIJgdUr3mWdqtddlZVp7tEOHtNpwpqM3tbM584QfeAC4916tHRpzii+8EC6F7vQ8JkOHunbCQGgyWH2RkQGsX6/Nz1CkM82dTQj4Z+EpEwxMx6eRHfeHDR14WycoSMsCoEfi2WcDvXvDbTEYqpCYuBsBAd2a9HPlkl4Qmgki0AVBEASPjKiPHn38yp65vP/+q/1LUzlG13UjtaYQqTSUu/FG4I03gC++AI4e1bbjnHO09POmJixMM51hLy1G1oVmBVO++RNj8oZeX06BzvRvpoXrLdMoaD1hjoaR/kWLtC6HqaknXqeOHAmcdZZnpeobDExkqWpy+wwR6YIgCIIgCILroSDv2hVo105L8+bCK2NG2BmGYyiRQtXZ9evsWcXQH91YqTgIw5ovvaSFAJsSThBQxdFETkS6x8K+5RThjCrz50wRzhR2/avl/BRFLAUhKz84N0OB7ilwHokNG+bP1/ZPTwKhKOckA3+6Y8cCERGu3lLPQUS6IDQj7rhDu56YO1czkhMEQRAEj4NX9SedpC2EvaXouM6FRnNUOlQzTIenmuGVvyOFO9d9++1A376a+vjjD01NvfmmlgrflCFAfhYXhiW7NW26rWAfesSVyQ/JyVr/cgpyvQ6bgp2inD9ZurLr0XJPgvvzww+akR2j/+ymyH0i7Mk+eTIwbpw24SDYh4h0QWhG0AR2xw7NXEREuiAIgtAsoBAfPlwTzWzbVlCgCXUKaIpn1mzTId6RcALgtNO025wseOghzfGK28A6+qaEIUkqPV3ZCW4nytmogPMo/JoozvXUb/5UaXXAr1BvFkBvxKa2W3AUnGD46istnV0X5Tr0XpwyRbNPkJ9p4xGRLgjNCF5D3HMPcPLJrt4SQRAEQXBC6jeVQF3L6F9+ca6A5WdedRXw0UfAnDlaQS0ttpsKqjsWKmdlaQpPcCmcHzp48LipGxM9KNDpfUhBrvcp59wSjd48pfbaEnpfdkbL9Xp5fe6Kopz+j8wEcIVlQ3NGRLogNCPYzUYQBEEQWgxUQVRDVEo0l3MWzN/dskWrTZ81q2nr06n6qJD++ktTfIMGaRMFQpPD6DizFTdv1uaFGBFnLTkFqi7OmwsU4x9+CCxdWvtxivKbb9Y6FgrOQ0S6IAiCIAiC4LnRdRrNsV7dmSKd1tr/93/awhT7117T2rU1VZg0MVET6sw3/vtvTRFyv4Umg4kMFKyMoLdtq80NNUc4+UADuM8/1xzm+RNnhQfnhpiswnZpUmvufESkC0IzgxP9K1cC48drJrmCIAiC0Kxhs2UOfsw9dmafKqqy++8HHn4YWLVKywGeOvW4uZszocMYF8JcazrPs5dVTIxzP1dQsEUajXmZ7t2li+fWlFuC+8WUfYryr7/W/BkJ9/WWW+R60hWISBeEZgavHX79FXj1VTmpCoIgCC0A2knTmYsuXbo7l7Ngffq0acDbbwOffqotFMr33Qf07Ikmm5RgOHfZMmDixOaXZ+0mcM6HUWWawi1cCOTladdVnl5jbs4I7qefjrvS6wkqV14JTJjgfBM4va6ftf7uiJeL+tOLSBeEZgZbXtC8hGV6giAIgtDsYYSb+ccM/zlbpBPm/jLlnRbXVBZsdP3ss8ALL2gTBs6GKrFDB21/2QOLjvNUUtJH3aEtxlhVwJ7fbJ3GhV6BzUmgb9igzTVxXwmvG/kz4lzT5Zc7t3rEFH4+27i5axs6r2Mi3c+vaT9XRLogNDPuvltbBEEQBKHFwB7iu3ZpV/t08nImVGrXXw9ccokWinzmGU0wP/WUJtSbAuZbsyadSov1+FQ4nKXv3LlpPr+Z154zcs707+horcqA80CeLtCZaPLFF8crQ5jCrxvB3XST1jrNFTBDYdQooH9/uCVVVdqfd1OXkIpIFwRBEARBEDwbCla2J2NUOy6uaT6TOcFcHn0UuPdeIDkZXi+/DLz3XtN8Pt3lqRw4McHI/saNmsFcU4f8mhH05mPteUqKVo/tqlRnR8Jkj+XLDXj3XU0Q63DfzjkHuOwy11VMMFOBP2Mmhrjrz7aqTj/4pkJEuiA0UzhmM+2d1w+CIAiC0KxhJJl5uosXa/2wmjLsyXArDWEefBCGf/5B3IsvarnRnDhgmNKZMD+ZS0ICcOCAlk3A9HfBLjG7bp3my8fEjOYg0GkI98IL7bB0qbYznMNhKjuzA/hn4ure5tw+CnRn/5l4IiLSBaEZ8vjjWsbdY48BDz3k6q0RBEEQhCaAwph5yYcOaWE5Gro1VXiOEW02j379dcTQTI4w7f7JJ4GTTmqa9Hea5zGazuOgO8ELVkXP6WrO2mj2P+d8h7PN0pydrl9RAaxfD3z2mRdKSsLg42PEhRcacMEF7uFMz2POYBK3kxMinl5K4AxEpAtCM4TXKCUl2mAjCIIgCC0CGqf166cVEzOVbP9+TTw3leI6/XRUl5SgdM0aBGZlwcCc6eeeA55/XlN+zoZh0d27gT17gAEDnP95zQAKxT/+0NLbmdbMOR3OdXiqOH/9dW2e5jgG9O9fhGnTApCY6O0228m0e6a50++R0X3hRESkC0Iz5IorgLPP1mYnBUEQBKHFMHy49i97Ov32G5CUpOXTNhHGyZOx/6670HP3bng/8giwcyfw9NPAG284P4TJ/OyICGDrVq1VnLRmaxD+PA4f1kz5+fW4a110Qyxfrjm1s8abPwNWf1AEX3hhNW655QAOH+7pFi3OOBHCFHcaxelNCdzV1d3ViEgXhGYIPXOayjdHEARBENwypeyUUzShzsh6Uw+KVHsU6XfeqYVply4FTjvN+Z/L4l72UGcWQe/ezv88D4ailXMoTLX2NP8eNhXQW8Tx6161SnucZnfs8KNHpw0Go1vV1vNPgRMiFOicRBAs40ZfmyAIgiAIgiA4CCoVhuxY/0XX96aGPdsnT9Zuf/+91vfK2TA0ScX5339ac2/BIozo0mvP1eZp9kT/77kHeOstgPYHFOgU4uwIOHu2+6aPswUc/xQHDxaBbg0SSReEZgodSufO1cxur7vO1VsjCIIgCC6gVy9NrDIfODtbE8p0Y28qO+kzz9QG4+RkbWAeNsz5n0nVKU7vDcIINA3M3FXUmoMJGW++qUXSIyOBgQO1NP3TT2/6Pt7WwD891v3TmC8nR+vF7o7b6Y6ISBeEZsqGDZrD+xlniEgXBEEQWjA0k6OpHM3kWKtO2+t9+7RadWebyjGnd+JEYN48LZreFCLd1Omd++ipTmhOhHM1bALAZAdPgGL3/fc1kzvChgGMplOouyOsPT9yRHNvZ805/8yY1MJJBXdKv3dnRKQLQjOFJ8Mbb9RmVwVBEAShxcKiY/Ys12nTRousM5RKEets56pzzgF++gnYsQPYvl2L7jdFNJ0905n23rmzto/uquhcAGu5OV/jzvMXFLqMmDMB5KWXtHkl/pQvukhLbXfHNnG6MVxurtbQYMgQrRMihTmPtbRasx4R6YLQTOE1wLvvunorBEEQBMHNoHMVo9vLlmmimX2gnKnWGMUfNw74808tmt4UIp2qiGZ5q1drmQNM8T//fHF8PwZTr5nq7q716GvWaG7t3E5TL8Tp07VotDuZ7zErgQttH9hajceUHondu0vteWMQkS4IgiAIgiC0LCjKqST0tHCqC0abuVANOZrzzgP++gtYu1br+WUa2XcWjJxzXxjeZG43849p/y2oSC+FpTtFoyl4mWzBhgRM9DCFbuh0bWdU2h1gGnt6upaNoLet41wUOyDyJybO7Y1HRLogNHPoVcNFbx0rCIIgCAI0Qc42bVQ+//6ridmjRzV3dEerN+b+sh6dIVJacDN6P3o0cPLJzv0quB9cGFmnmZyIdEVamut7otNMjW3UFizQ5lCI3gCAaeFTp2qp7T4+ms2Au8BtZOo9f9L8+eoTBxERIs4diYh0QWjGLFmiZdix5I5jsyAIgiAIJlC8Mv2cC8OCX3+t5UE7I5rOdHOKdEbSuWzapDmAhYQ4/ythmJNKkMXYTfF5bgzdxlNTXXcYDh4E5s/XBDpbkpkSEACMHAlMmuS+LuhsAUdbh7POcs6fiaAhIl0QmjGDBmkzxRybec3B4IAgCIIgCGZg6jtTxLOynKM+WKT79NNASgrwyy+a2vn9dy1c6mxoY06jPKa8cztaMKxs4FwFy/SbIi38n380/z5GoDk3s3Pn8eeZUMEufcx2ZMScP0FXR/jNweNFAzsmmzAxgxMJItCdi4h0QWjG8ARK0xGpDRIEQRCEBmCOMXN4qaSc2Q6OS2Ag8OKLmlifPNn5DvPMGGDONPOUW7hIZz06U835VTsjSk8hy2svWhBw4eeZQpHLygd6FzKRwt0dz5lgwsyDbt20nxAnFpihKTgXEemC0MwRgS4IgiAIVsICWzp4cXGmemIt/Gefae5bixZp+c3OhqFjRu+pIFtwOza6kPOrdeTXu2eP1mVv5UpNpJvCQ822uIyS85qMddzMcPQEGD3n8WKkn4s7Ge01d0SkC4IgCIIgCAKheqKSYrGwM2e5qXboDPbOO1pbtgkTnK+AqBJpjEc32RYq0tk6nmb+jd19inKKV0bkGS1nJ7+6MGGC0fKhQ7VUdk+Cqfmcz+FEBicYWD7JZAyh6fCwn4wgCLbC64wrr9Rqotjao4X7xQiCIAiCZWhRzVqxggLnp6KNHw989ZUWTV+xQnN7dyZUXNwnKszevVuM6mIZPgUn68O3btV2OzbW/vVRkD/4YO3HKMJPPRU491wtHZyf4Y615dZQVqaZ28XFaQkfktreAkV6VlYW3nnnHaxatQo+Pj445ZRTcNtttyGogZNiUVER3nzzTSxevFi9dtq0aZjIqSpBEE6AZW9sy8qJc/5Lt3dBEARBEMzAaDaLlem83rq1cw8R69DPOQf4/HPgu++0kKWzC5SZzk/juowM5++fG8DdZKSbLddYT805mMYIdMKvivDwsYKA8x2sVmgKIzpnp7XrsNkBzeHoNyi0MJFeVVWFwYMH44orrlDCvLi4GE888QR+/vlnLFmyRIl2cxQUFODUU0+Fv78/HnzwQSXSKdijoqIwjC4MgiCcwOuva4PH4MFycARBEAShXlq10hzAnF2XTqju5s3T2qN98okWvmTRsrOss/VUfkbTmatNFeYpBdI2wt1btkwToD17Ouar5Ne0fr22rhkztFZknn6MmGnAn8WIEVq2JSczunRxr97sLRGXiXRvb29s3boVwSY9obp164Z+/fph7dq1OJknKDPMmDEDGRkZ2LlzJ0JZWwOW8UxAaWlpk227IHgaNI4VBEEQBMEK4uO1+m2mvDu7zxRVEXtw/fCDVptO/v0XeOgh530mRTn7tRNadjNHu5lRXg4sXw7s368JTkfNtehfEQWtJwp0prIzq4DmdpyHYuIIfwIM4nB+SHAfXJrubirQScixYtly/mVZ4PPPP8fVV19dI9B1AgICnLSVgiAIgiAIQouBrmLt2gG7dzdNM+gLL9Si25wUoD04BTQN3pylApnvzYUu76yHZzi1mbSCKSrSTM9oDsfe5KyndpRpG1PnGZkn558Pj4KxTP6kKM7bt9fS/inQeXwSE1uMPYFH4VbGcc8++yzi4+MxlDaIFmrY09LS0KNHD9x7773YsGED2rRpo0T7GWecYXG9ZWVlatHJZ8O/Yyn3XIT60Y+RHCvPPo40jvv7bwPOP9+oZpU9FVcfx+aAHEP3O47yexYEN6NzZ80hjH/fznZdZ5Dq1lu12089peVT//wzcPPNzv1cBrzoEJaV5fEinZUJFOZMQuBXxvkOWgs4MobHr4Tr7tsX6NoVHnNcCPucc96J205hLq3U3B+3EemvvfYaPvvsM8yfP9+icZye0k6Bftddd+Gxxx7DP//8g7POOgsfffSRqm83x3PPPafS5Ouya9eumui90DC7OaMseOxxvO++9li1KhRFRUdx6aXZ8HTk9yjHsDn9FgsLCx2yLYIgOAhadDOinpvbtI5grE+jSGfv9Msv14S0s2CImWFnFm0znOqhUIhu3qylt/NwcaE/niPd1XmK/vNP7TY753kKnH/p2BE46ywtgi4Rc8/BLUT6e++9h/vuuw9z587FeLajsEBkZCQMBoOKmj/++OPqsXHjxqkLJIp8SyL9oYcewvTp02tF0hMTE9G9e3eENUUak4fDCA+PMT0D6CUgeOZxvOgiA+LijBgxojV69vRcR1dXH8fmgBxD9zuOeoaXIAhuAksyGU1ftUpTOrxebIqi3ZNO0lTVgQPAH39oqfDOhEqWedBs6u2h8FCxgx098CjOncGCBVpFAoXuwIHwCNhyjhUNhFF0EeiehctF+vvvv4877rgDX331Fc4777x6X8sIe8+ePVWKuylMkV/Bv04L0AmeS114USUX+dYjx8uzj+Ndd2kL0DyErfwe5Rg2p9+ijEWC4IYwN5jFu1RnrBNn6aSZ60mHQoczXg+//DLw22/abWfabDPszFzoptg3J8AkWyYeMJruLIFOsfvLL9ptfh3ONvxvLDSGy8vTzPPoai94Ji61Cfjwww9V+zUK9KkWckeYqn45032OcdNNN+G7775DKk8oysQhQ0XgTzvttCbbbkEQBEEQBKGZQxd0RpiHDNFCkYw4NwWnnKJ9NtPQmcPtTHQXe36WB7Jtm9YWjfXnzmLpUu3wsOqBrezdGabl0zxv+HCA0shCsyzBA3CZSM/NzcW0adOUw/vs2bMxfPjwmoW90nX27duHzSw0Ocbtt9+Os88+W6UXnnTSSejYsaP6l+sQBKFhmFV7+LAcKUEQBEGwCmbKMA2drmH1dCByGIycn322dvvHH4+7fzkr3Z2hYg8U6dxkmsVRPDvKwb0uLNlndzxyzjnu3TucP5PkZKB3b02cc26pKe0UhGaS7k7DtpVsM2GGzqwBOsbDDz9cy1DHy8sLb775pjKCS05OVrXl0fILFASr+PBD4MYbgSlTgG+/lYMmCIIgCFah96pKSdEKk53NhAnAN99o7usMVvXv77zPosJNStLUnQexZYuW1s0+385iwwbt0AQGal+Ju6e5UxINGuT+KfmCG4t0Hx8fFTVviE6dOpl9PCYmRi2CIFhPjx5aIIADjiAIgiAINghZpr4zFa0p6reZhs58ZdalM5TrTJHO62m9FZuHBL7Y3n3HDqB1a+cIUh52CnSm0pMzz9S8BN0V9nBnu3v+ZNiUQPB8pHW9ILQgmPrEAYf+N4IgCIIg2ABd1xlRb6radLZjoyU3m3/TwtxZ0LmedekU6m4Ok2vZFW/rVu02ff0cDVPG33tPM6Sj+GWKO1Pd3S21nfZc7AC6a5cm0MeNA3r1cvWWCc3G3V0QhKaDAw29bwRBEARBsCOazog2o+l0fGcOtDNhyzcWF7ODEWvT777beZ/F/mUMTdPR3pENxh0IU9vpss75BIrS+HjnfI5uA0DBy8g052bcKXmXPz3+BOktOHKkZpnA2ybVwkIzQES6IAiCIAiCIFgDI+ldugA7dwJduzq/+TRNZCjSly1jL2It6n3++Y4X0nrKO0PUFOycIHCz/G5GuBk9pjVAq1bOmUtgX/HFi7XbV13lXpFpmtjREoETFH36AEOHauJcaJ6ISBeEFgZnoh94QEvjYtq7sxxRBUEQBKHZQVE+YoRmLU6DF2ebyHEigNFtuqSxUJqEhDg+/5qpdqyzX7JECyPzM884w20cyLhJe/cCAQHaXIWzYKS+slLz8HG1QOc+s50a/6Uw5wQCJyfGjNHM8pw9PyS4Fvl6BaGFwbGdhrE0RGGZmyAIgiAINkBztdGjtTxjFgSzMJima87irruAyy7TJgf0xt3OgPVwVH9t22r7xNC1m8DDSysAZ/raUQjPn6/dnjoVLo2Y06mdPy0GVlh7z4AKa86ZRMEJBBHozR+JoQlCC4PXFM8/r83G9uzp6q0RBEEQBA+EEXRaftPFjEXCbNhN13cKXEfDAfuSS7RQ6j//aAKairVNGzhtNp8qka3fuD9uoAiPHNGiygkJzvuMP//UPoO7zFTypoSddxgxLy3V5kZYfUBRznp4pvVTpDOLQGg5iEgXhBbIDTe4egsEQWhp7N69G9u3b0d8fDyGDh0KgxVptBs3bkRSUhKioqIwZMgQBMhVquBOUEHpUFX9/bemsFi37gzYW4tt4JgGxxp1CndnwQmAffs0hzJn7Y8NkWXOSzizRL6iAvj55+M2AE01L0FxzjpzTg5QiLPqYMAArRsPrQGElouIdEEQBEEQnMrdd9+N999/HyNGjMCWLVvQtWtX/PbbbwhlL2gzZGRk4Mwzz0RqaioGDx6Mffv2ITMzEz/88INahyC4HUwTZ8hTdx2j6iOONn5hmj1FOlPeL77YeTXjdK5naJeO78wacGFtOt3cme7ujHZrTCWnV96ePUBmpjYPMnYsmgQmYNCrj/Mh/EyKck4OxMa6RfKC4GJEpAtCC4UGLAsXAqNGud4cRRCE5suvv/6K119/HWvWrFGCOysrCwMHDsRTTz2F51l7Y4ZXXnlFCfRdu3YhhKm3oE/WObj33nuxcuXKJt4DQbASRpzp6sXiZqajM/2dZmy0I3eUyB0+XJsMYP73/v3O7bvFNHuqSKpXKkcXwbpsHlIazjua557TPPl0zj1Xi2Y7G04OMOmCHf3YRs3NjPQFN0DmaQShhfLII8AttwDffuvqLREEoTnz+eefY9SoUUqgk+joaFxzzTXqcUuUlZUhJiamRqCTjh07ory8vEm2WRDsRnd7p/MYHdj5G+asOHO2HQGtzZkLTZjy7kyY6cI8bE4GuJD8fC2oT08dR8IuehToXC89ek49FZg4EU6B28/UdiZYsIKAJf+se2cEXQS6YA6JpAtCC4V+Nxwk2N1FEATBWTC9ffz48bUe69u3r4qUM4WdYrwu06dPx5IlS3Dttddi9OjRKt39l19+waefflqvsOeik88re1XzWaUWoX70YyTHykHHkTbkjERTpNMynKFTRxUZjx4N75UrYVy2DNVXX+149WoK/z5ZEM7G3E3oCWH6e2S3O1YNODrj/scfGas0YMyYavzf/xnhLPjVM7FC3wf+LFh3TksDprU78/Qkf9fudwytXY+IdEFooVx7rbYIgiA4k7y8PGX8Zgqj6SQ3N9esSI+IiFC15z///LNKj9+7dy969OiBRKYNW+C5557DjBkzTnjcNGVesM7gT3DwcXSwVbihTRv0eP11eGdl4XB2Nor0yLoz0E3jDhyAq44jTx915vkazeHDfli9WotS3H77PnTocHyCzxlwjsMUJgWxxVpTIX/X7nMMCzlrYwUi0gVBEARBcBr+/v4nXJTo9y25tbP2fPHixcoNngLbaDTiqquuUnXpjMyb46GHHlIReNNIOkV99+7dERYW5tB9ao4wusOL0G7dusHbmZHZlngc16wB1q93aP24gbXpf/2F9t98A6Oz68Up0JkP3lSOaibHsX37bpg3z1tFoR1pHPfWWwYYjQYMGmSEj08nVXrfWFjRwKg/T29Mb6+s1EzhGDXv1Mk13nvyd+1+x1DP8moIEemC0MJhfRQHJ0l7FwTBGXTu3BmHWYRpwqFDh5RAZzs2cyxduhQTJ06siYCzXdv555+v6tgtpchzMoBLXXhRJaLTeuR4OeE4MhRMxUbl5kiX97/+gtfy5dp6mWVC1zNnKEHWpvNvmOUkrIlvQgoLvZGf763ErqMOH43oFi3Sbk+ZQrHeeOFF9/n0dK06oHdvLY2dTvE0/XeHzpHyd+0+x9DadYhIF4QWzObNmlEKx1+6jLqww4ogCM2USZMm4cknn1Rp7+Hh4SoqPnfuXNViTb9YSU5OxooVKzB58mQEBgaqCPgOtn4ygff5XN3UeUFwexgCpmU4c5zpzO4IqASpCOm8/uef2mOcbXdGuxZuP83jaGRj2hu+idqvMZhgZv7Nbn7/XfsqunShP4Z96+D7eTg4ccBWaryO4vUUvxZJ3BEcgYh0QWjBdO+uTe5zsGE3l4QEV2+RIAjNjRtvvBEffvghzjjjDOXqzij5pk2bVEs2Hd6+9NJLkZSUhISEBJW6ftppp+HKK6/E2LFjsWfPHrz66qt49NFH4SUNhAVPgyKXEWg6pTtKpHOC67HHgHXrgI0bge3btd7pzhDpeuSPFwouEOmOhMkAv/2m3T7vPPuDE0xrpys7Kw0o0FkNYCbBRxDsRlqwNZLK0kpUVzqorYYgNDFMwWI0nbPBItAFQXAGQUFBqrc509Upxjt06KBEei8TMcHI+cUXX6xeS+jozsh5p06dsHz5clRWVuL333/Hww8/LF+S4HkEBmq5zxTpjoSC+aKLtIWsXKnNvDsDOtMzms6wdhOgN2pITXVsFH3xYq2lGx3W2Z+8MdvXujUzhbQIugh0wdFIJL2RVFVUIfdQLmK6y/SZ4JlILbogCM4mNDQU999/v8Xnhw0bhq+//rrWY126dDHr1i4IHgmLqg8dcs66+/XTRDSLrTnzPmiQc7IBaGAzb56mmlkT76TSk9JSrWsds/04L8BItSNgavqvv2q3Wb7fmPJiZiA60shOEOoikXQHkLMvB5VlTpq5FARBEARBEDwbRtIdaRxnCtWmHhZetsw5n8E0fYaLGYbeu1dLwXMStKPQvSbpLemouYBt24CkJG2OobEt3fhVMt1dEJyFiHQHUF1VjcydmY5YlSC4hLfe0tq4/vyzfAGCIAiC4DTzOD2P29Ewsk3o9eCsz6BapmpmPzRamTsBzgH8++/xKDXL8hxlakvDODJmjGMEdhMb3QstDBHpDiLvcJ5KexcET4Sz1vSe0QcwQRAEQRAcSHS0lpJuZY9km+nRQyu0ptU4B3RnwtaINJFjY3AHs2WL1s6Mh8sRMOLNunb66q1erT02cWLj1smyfM5TiEgXnImIdAeSviUdBSkOtqEUhCbgmmuADz8EnnhCDrcgCIIgOBxG0du3d55IZ7iZDmbOTHk3Femsf3fwvnB1DBrQMd1RTRxoFHfjjcCDDwJVVdpcRqdOjVsnExWYMi8iXXAmItIdCHu/Hl1/FCn/pijXd0HwFOgxc+21WhabIAiCIAhOgIMslaKzatNHjdL+Xb8eKCyE06A6LS7W+pA5EPrS5eRo5fuOgIf5xx+PzyvExQGXX9749ert7kWkC85E3N0bQVVVlWoNc2DpAURGRaJ3r97w8vZCfnI+Co4WILhVMMLahiEoNgjevo2wkBQEQRAEQRA8G4aI9X7pVI2OpkMHoF07zXWNtemnnQanwDA3FTDz0hsbljZJIaexG53cHRVF37VLM9SnoH7vPccdckbSWbnA5AhBcBYi0u3k+++/x1133YX05HR0QAf1WEx0DKZNm4YRJ4+AsdqIwtRCtRgMBviH+yMwKlAtQdFB8PYT0S64F5wUZ036zp3Ao4+6emsEQRAEoZnBEDEd0ilunSHSmfLOaPrnnwNLlzpPpBNONrAufcgQh6yO8wqsHWdFgKP44w/tX1YBOPJwU6Q7KtovCJaQdHc7BfoFF1yA5OTkWo9nZWVh5syZWL3qmDOFSRp8aW4pcvbnqHT4vQv24uDSg8jYnoHizGL1vCC4mowM4MILtbr0TGlWIAiCIAiOF9GMdjMV3Vlp73rKOx3YmDvuLKh6ebHAGX4HsHu3dngcFZ3mIV6xQrs9YQIcCqP+0iNdcDYi0u1IcWcE3ZywNkJ7bM77c1Rbtvooyy9D9r5sJK1Owr4F+3B0w1HkH8lHdaXjnTIFwRo4ez11KjB9OlAplgqCIAiC4Hhat9Zyug8c0FzSHO2QzsLrbt209a5cCaeKdCrh3MZ3NuJcAiPprAZwFDSMY+0450S6d4dDkR7pQlMg6e42whp0PYIegABMxmRUoAI5x/4rRjEyMzOxbfs29O3b16p1VlVUqRp2LgYvQ00te0hciLovCE3FvHlyrAVBEATBaSQkAOeco+VML1qkuaQ7OneaPdMZmmbK+9lnwykw5M1sAFqyt2nTqFXxspqrcZR5LUX0ggXa7TPPdFyfdVMCAx2/TkEwRUS6jaSkpNTcbo3W6ImetZ4vRzmykIXDvx9Ga6/WiO4abVP9uWktu5ePlxLr4e3CERARYOumCoIgCIIgCO4EXdF0UZuYqBnBOFqkn3IK8MEHmnMaC70ZXXcGVL+NTKlnwH/PHq3E3VFimj3Rk5KAgABgzBg4PNWd8xPi7C44GxHpNhJvMs2Xi1wsxEJ0RmdEIAJhCIMf/BCPeBSsLMDilYvh5euF2N6xaDOoDeIHxSO0bagykrMGpr7nHspVC0V6ZKdIhMaHSnRdcCqcgeYA5+Pj+BQxQRAEQRBM6sy2btWUqqMszQlFP7M5N2/Wounnn68N6s4IJ6elNdoPh/Ev+uk52jCO5fmOFtPSI11oKkSk28ipp56KhIQEHDlyBHnGPKzCCgzDv/gPITiMMEQgCh2CO+D0fqcjc3umMoxL25Smln8/+BfBccFIHJGIxJGJiOoaZbVg53pSNqYgIyADEe0jENEhotk6xKdvS1f76Bfi5+pNaZHMmKEt112nTcQLgiAIguAEGPhhbXdBgdbTy5FQoVKkf/GFtjCkTNMZR4t0RtL1xuE2sHevFujnW0tKGi+m6aUzd67Wul0vxXe0YRxh9zxuq0TSBWcjIt1GvL298eqrryp3d8Jk9xdQhEIUIRJp8EEAIntHwmtgCsbcOAaGIj+kbEhRS8a2DBSlFmHnDzvVEtQqCO1GtrNJsFeWViJzVyay92YjLDEMUZ2j4BvUfBo1lmSXKBf88sJyJAxLcPXmtEg4rvv7a6VmgiAIgiA4CQrztm2B/fsdL9JPPhn45hsgPV27//ffwGWXOTb1nUqVoXAWlNsQCqeg3rhR62EeHNzoknbFkiXA118fv9+lC9C1KxwOLQR4aJ2RmCAIpshPzA6mTp2K7777DrfddhuCUtOxCAYUoAo0xK5EKf5Y+wfuXfsHegB4rE17VJwyESMvHolh7YYha2sWklYm4ei6oyhOL64R7MGtg9FxfEe1BMcGN7gNdI/PPZiLvEN5KoU+uls0/II9O/LMevzUzanqdlF6kVpooic0vUhnVxVntHAVBEEQBMGETp2Ou7w7MuWd6vfdd7Uw9axZWlSdlucU6o6CRd+lpTaL9KNHtaVjRy0o4MgUdwpoivORI+FwmOpOcd6unePXLQh1EZHeCKE+efJkLFmwBPsXH0BEZAT+iArD5j2bsXH7BnRf+D3Cqyrx59FD2DX3Hbwz9x2M8vPHtOjWqDj1LJz62iUo319eI9iL0oqw9cut2PrVVsQPiEen0zuhzdA28PatP6WdreDyk/NRcKTAJrHOevfSvFIERTu4WKcRMHrORYcZAyLSmx4OQCLQBUEQBKEJoHkca8iZNh4d7dh1e3trA/pppx0X6Zdc4rjJAD0DlOFlG9i3T5uTcJRAZ+o8zed4/XLLLY5PStDJygJatdK66AmCsxGR3sjUd9aoJ1Yl1jzWIaEDJo+djKJbnsTGf1fgmpxMrNy8Cqs2rcLkvGxckXIYn859G2O+fQcDegzA+OHjMfbCsfA64IV9f+1DxtYMVXvOxT/MX0XWu0zqgpDWIVaLdabBx3SPgU+A5a83fWu66svOlPKgGPcQ6mxFV7cOn+n99e2H4FyKi7WSM2e0LxEEQRCEFg97prOv+dq1jhfpOsOHa6npTH3ftk0zlXMUtDpn+p2VUM9TVDvDKI5RdGcJdMKEgcGDJdVdaBpE/TgLLy8EDxqFKQCmnDYV1dXVyP3tc2xeMBerKithPHoQG3dsRPKOjbj6o+exICgUb1RHIBSR6I7u6IiOQD5UKvyun3ah7fC26H5ud8T0jKm3dp1iPe9wnhLrER0jENUl6oRoPMV5XpI263lk3REVuWdPdldTVX5iETRb0dEkT2h6h/eLLgJ+/RXYsAHo1Uu+AUEQBEFwCiygZqSbM+POcCRjyJpt2f78U+vN7kiRrot/Fpozct/ArD5bo1Goc17CEfCQLVt2vCe6s9AN49jmXhCaAhHpDsTL20uJaKaQ03m9vKgcpTmlKEwrVP9GnXMVcM5VuBvAJRkpWLx2McJ+/Ry9jxxASXEB7kEBT1/Yjd0IRxh6oCd6oAfiq+ORvCpZLRTd3c7tpszm6kuFZ806zeUo2Nlnna/lYyVZJSjJKTn+uspqJdTDE8PRqm8rtQ+uQkS6+8AxlgMfS83++ktEuiAIgiA4DZq5sdCZOdsMBTNF3dF1Z+PHayJ91Srgppu0NDlH1b5TpNNBnlkBZ51Vbx774cOaEbyjMvToh8drFYrn3r3hNNhpjnMpsbHO+wxBMEVEuoOgw3rboW3hH3r8xMQ0bQp2CmumbbPfOUUzb8fHxuPysy4HRp2DJ6Zdgn3F2QhCOYpRjAqU4i+UYgnSMRvr0DaoD24ZfguSlicp4b3mpTX479P/0POCnuh0Wqd6W7FR+PI9DcHIOkU8+7m7k0gvzipWEwlePvZPHkjKvH08/TTw3HOOnXAXBEEQBKEOrBHnYMvZcRZrJydr7meMTDuKHj00G3U6tlGoU7Q7Ak4mVFRormpHjmhhchZum4FiOjXVcSnpzPqbP/94FN1ZpXn8WrhufkWO9PYThPqQn5qDaH1S61oCvS4U7KwTp6immGd6OdPWtxw8hK+LfbAOrZCABHRCJ1yAMFAXXcracRRjbfFa3PXPXTh02iG0PactAiIDUJxZjA3vbMCvN/6KXT/vQmUZveUbR8HRAmTtyYKrqK6oNuv4Tpf3xnBw6UFkbM9QpQCC9QwcCJx0ktSjC4IgCEKTuLxfeilw3nlawTYbfjsSqsxx47TbNJBzJDS+o5sahTp7vltA79bGgLsjYJ91tnFjZF7fNWeQkgJ07iyp7kLTIiLdAdDUzZq2aYTCnK9vO6StMoUr8itCpWrepuEDH2xGa9yAtngOMQhBJLzhjfyifAyb/wE2/TINv0Z/DZ8xPgiMDlR9xf99/1/8csMv2PH9DhU1bgyZOzNVxN9dIumkIMXyCb8hKMxVNsG+bHWsBEEQBEEQ3Bamj9MIhlbijg4ujB2rifUtW7SQtiPhernUI9LpL1dVpXnNOQI9in7qqY6vDmDUn53xdu/WKgMkii40NZLu3kgMXgbE9ravQMU30BftB7fHfuxHCEIQgQgEIQjVMGA5KPqDwTXHIAa3nDUS0377WMn5Tns34dG9mxATGoMrBl6B1odboyyzDJs/3qxM5vpc2kdF7O1NEU/7L01FtZmm70p3d1PzOHtT1pkqr1OcUexWLec8AV4jzJ4NbNyolbKJy7sgCIIgOBmmum/apKWORzjQPJcF1UyRo0kd69kY/Z4yBejZ0zHrZw+0ejIAWI/O1uqOgHMBK1Y4zzCOBnecK6E4Z6SetgGC0JSISG8k1vQkrw+2cEtISMCRI0dQaCyEH/yUWA9DGLzgBQMMiImJwcTLb0NaQiIqDu3B+TFx+OaPb5CSmYK9G1/Bd/DG6E6XoGdOT2VQt/6t9Uqs9728L3LDcpGbk4vIqEj07tXbamO4jB0ZShSHJYTB1ZF0prznHMhBbM/YRol0ps3H9HBgz48WAAem117TZpT//VdLgRcEQRAEwYlERWn252yv4kiRTs44QxPpBw5oC2fjX3zRMetmyJkmcswAqDOrX1ioPRXmoMtKZuyzFL5jR8c5xeuwZT13ZdAgID7esesWBGsRke4GvdZfffVVXHDBBSoVvtxYjnSkIxOZCEc4IhGJaTdMgyEkFLk0mgNwM4Abzr8Ba5b+iktfexhe1VUYuP8LfA1vTIyaiMElg1ULtlWzV6n1bMImtc6Y6BhMmzYNI04eYdW2pW5OhV+oH3xDGs5LKssvU33dnSHSSd6hPER3i7bZfd60zr00r1TV7vv4y8/eWlg39uyzmumsoybaBUEQBEFogD59tFxrimhH9k9nKza6rzPi/c47mqM8zeRoKtdYqGypxktKalrJsQadfdH5EKPfjnBH5xyA3hvd0YZxTMenkzt7rotAF1yJ1KS7AVOnTsV3332Htm3b1jxWjWqEJIZg9nezcf4d5yMgonZ+kI+3D8Z1Owno3h+liV0wYOKl8A/wx6/Zv2Jmyf+wDMtQjnKVKn8aTsNwDEd+Vj5mzpyJ1atWW7VdjGAfXXe0QVM61n0n/5OMoowip4l0psLnJ+U3OoWehnuCbUyfDlxwgeO6tQiCIAiC0ABUs/37a25rVI6Ogop26FBN3fbrpz2mNxpvLLxQ0NW4SYo7W7muWaM97QjD+q1bNSN5rm/0aDg8zZ3t3HjoBcGViEh3I6F+8OBBLFmyBF9++aX698CBAzj//PMR2iYU7U9tj8QRibUM6soTOiFp5hfImPUFHr/lCSz5cAmmX3YnlqECo7AYH+BVrMd6GGFUrvETMREd0AFz5sxR7dasoaKkAinrU+p9DYUva8ZT/01V/5YVlKnIuiPc3U3JPZjb6HU21ileEARBEAShyaLpDOfSXtwZjBmj/bt0qWNM6hihLy+vJdKZCMCHmZJO8dsY6HXH7nHffafdp0A/FrBvFOx6V1mpbSsnEUaO1Pz7BMGVSN6vm6W+j9FPmGYIiglSC9O2s/dka67nBgOqQ7SGk+Eh4bjA6IshMKIzDHgD5fgVv2IzNmMKpiAKURiBEcjLysPSOUsx4tIRCAhv2MGjNL8UiNIi6zAzA6pHuBlx379wv4qs01AvfkC8mmCwNuLdUIs0in9OCPAY2FOTrpvHqe0TBzSbyM0Fvv9eG8huuMG29wqCIAiCYAdUioMHazbmbNbtCEVqyrBhmvkMw9L792t9xhzBMZHOyzrOLzhis+mNc889tc3jJ0xo/Hp5WPU2bvS9Y5IBS/wEwdWISPdAKKzbDG6jRKsS60cLagTu1vhu+ArxCIARkQiFH4pUXfpqvAU/DMVInKJq3dN+T8MvC39Bz/N7osfUHlbVaadtTkObQW1qCVyKYLqv6+jboVLlNxxFXFUcwhO1SQR7U93rRtNtEel10905kcBoOtvgCdbz99/A9ddrs+DXXQd4SQ6OIAiCIDgfhqCZM/7ff5rruyMHYKpnqlLapDPl3REinUqXIWlmLxZpNemOiEqvXKkJdK6rfXstyaCxm0uBzkNLU9zevbVKgFatGr+tguAIRKR7MP6h/ogfGK8M1TJ3ZSqxHhkdhQXQoteU0mztNhw++BaHsRj/YArWowdOwkAMRJvyNtj61VYcWHwAQ24fgrh+9feXKEgtQOqmVPU6RspJ3uG8elPn2c6NDviBUYGNSnW3tx1b3Ui6bkInIt02WLrGcfy88zQ3VaauCYIgCILgZCjKGfFmSJpGcrzPevXISMesn+umSGfvdEfAQnHW0RuNyMszKCHsCLM4toElU6cCF17Y+PVxAoH15wMGAKNGaZF0QXAnRKQ3A/xC/FSEu6xrGQKjA5WLe1ZWlqpFJz1QhkoYUIQgRCMK+/32Y335evRGb5yBM4A04O/H/kbnCZ3R75p+9baVy0/OR0VRhZocYFu0nP059W6biqivP4r2o9rXK6ytjaQzUp97KBcx3a1rpWZO/DOSzlp79qkXrIN9Tf/5R46WIAiCIDQ54eFabjcd2ZmbTbHuKJHOEDJhursjUupDQrT+7jk5yM2NUp53DK43huRkYMcObX5i3Dg0Gkb3OecxZIjm4i4CXXBHJGm1GcEWaO1Oboe7XrwLJShRPdbJdwjHJLTH82iFAATgxekv4teZX+Cqrl54E29gLdaq1+1bsA+/3PKLEtX1UZJToqLvDQl00xTztC1p9b7GWpGuR+8bql+3lO5O+F5G0wVBEARBEDyCuDigVy/NSI4uZ44iJkZbN01nqIQbC0U689KTklTWuyOy8+kOT9i33BHd6GhAR4HObnQi0AV3RUR6M+Siqy/Cy/NeRnV8NSpQoR5Lgh+MMa3x4IMPqj7pI1b/ifv3bMHeoacCpwIf42NkIxsVuRVY9tQyLHpmEUpzSy1+hrUi2TRN3bR2vTEinenuNICzN929RujTCM9GzIn+lgS/9uXLtVYqgiAIgiA0MRTBjnBiNxdN37at8etiYXdICIy7diP1aFWjA/Ocj1i8WLt9+ulwGGwL39gIvyA4E/l5NuOWbpMnT8aypctwaO0hhFSHoHev3vDy1uZlKqPjUO0fCJx1GV4acAr2XrwXr3/6OoxrjaqnesbaDMy7fh76XNUHfSf3rVkv68+3bd+GnOwcREZF1lpnQ6RvTVemb14+Xo0WvxTZwa0adiKxVOvO6D4nDax1nzfdB9bjx/aKhbevA5p9ehgvvgjcdx9wxhnAggWu3hpBEARBaIEineFftjpzVBiYLmyLFjlGpJOYGBQfzEA+8hEc37i0/HXrtOz5iAjN6L6xUPSzzZq0WBPcHRHpzbyl29hxY1E9qhoHlhxQEWidnPOuRf7YyagKj1L3u7TrgvfOuxx7Tj6KF+b/jfa72iO+Ih47PtiBf3/5F6e/dzqS1yfj3bffRWZWZs16WP8+bdo0FZ1vCNaB00iO9eyNiaSTwrRC9R5vv/qFcn3in7Xttop0in5+Nt3wY3pYVxffnJgyBXjqKa09CTPjxOVdEARBEJqQ0FDNnK2kxHEiXY+k79kDlJU13h02IAB5+QYUFeQiqnPjRPpff2mBnbFjHRP51nfP0d3sBMHRSLp7C4CRa0Z+66ILdGIoLkT8Sw9g3GsP4/2pZ2HEUyOwJXaLSpcPSA/AgikL8PZzbyM9K73WOmhQN3PmTKxetdqqbck/kq/aqNnr7q7DVPW8pIbryutbL3uulxeW2/S5uuinUG+JsN0JTVvnzBGBLgiCIAhNDtUlF4p0R9G6tVbszTAzbdR37dJm4htBSWAUKlIz4Xus7NIe0tN9sGGDY1PdRaQLnoKI9BZCWNswBEQEWHzeUFWJkt6DUNEqAUX9T8bw/sPxzPvPoPXNrZHtm40gYxDOrDoTPdADRSiqcY7X/53z/px6W7GZkr4tHSXZJY2KpJPcA7kN1sZbqkmvWcehEycMrBH9ZflltTITWhLSfk0QBEEQXARrvmn2Vlrq2HXq0XTOwrOubcmSRq2yNCgKhtJiINe26yzdfZ190d96qxWqqw3o2RNISIDDRDpT3cUwTnB3RKS3IIKiLef2VIdGIOWeF3Do5XkwBmq13gaDAVOifXDKI8PhdYr2UxmMwTgP56ESlShGcY1Qz8zMVLXq1qC3ZWP6e2NEOt/P3vD10VCtO1vK2WKCZ7q+lhpN1zlyRFsEQRAEQWhCGPWm2nQkkycDPXpoEwB6MXgjKIM/wOAN0+9s5IUXgJkzvTFvnpbxedppjdqU2ttV5rjudYLgTESktyD8QhuuXaoOPl6jHbJmERKevRWj5jyOKa+djRX+K1QUPRaxuBJXoh/6KVOQcmgp4zSTsxYatx1dd7Qm+m6PSFefuS+n3smAhhzc+bklWdanjJluZ1FaEVoqM2dqdemzZrl6SwRBEAShBdalM/rtSLp2BWbPBu69V7tPE7lGuMgXl3rBOygASEuzqWUc/fC2btVuDxxYhPHjqzF6NBxGRYVmQicI7o6I9BaEf6iNRiDVlagKDkVulz6Ary8yfDIwH/OxH/vhBS8MwRDcgBvQC72UePfyt+3nVJpXitR/UxvV2ozrYG25OaxdZ0FK/dF4S6Kfn2tPG7fmQL9+Wrna4cOu3hJBEARBaIEO77Qod2S/dFOxzlxwWqonJ9u9mvwSH/iGBmi56znWB3H27tV2KyLCiI8/PoD/+z+jQ1PTOe8gzu6CJyAivQVhTSTdlMKTJ+Dg67+g+vYn1H0DDPBDCbZhJRZiIVKRCh/4YCiG4lpci8+f/xxzvpuDsnLrU7AokDN3ZjZYO14f2fuyzT5u7Trr699uSt1oP7MAitJbZjSdBi40gf3xR1dviSAIgiC0UId3R9al6/j6At27a7cb0ZKtqNQHPgzeVFdp0fT0dKCg4aDIjh3av6xDd3SygJ4YIM7ugicgIr0FwX7mvkG+Nr2nMiYOhoBjhnNGI/6HNPyIQ2iFw1iMxViERUhBihLrYyrG4MinRzD11qlYuGah1bXeWXuy0BgolMsKyux2jKcBXF0jO2sj89l7zU8QNHfYBqVLF1dvhSAIgiC0QBgK5rWZIx3eTdFN5OwU6VVVQFGZN/x8qoHQMGD3bmDlCmDLlgZT6Hfu1P7t2dPxmYpMdecchIh0wRMQkd7CsDnl3YSHbrwefbwq0AqV0Cc3q2KqMOyBYRh480DAG8r9fUr6FLzxvzdw/RPXY1/SPjQFOftPTKWyJYXemmi6OdFfklOCooyWGU3X4US+HeatgiAIgiDYA1PdY2OBYvPlfo2mTx/tXxaH21GXXlbpjcpKA3y9jUBYmGbNHhmlpb7XM7HAj3KmSJf2a4In4ePqDRBckPKeZt97Txp/OgoHL8OBBT9gQqtOuCQqEr179YaXl0HlJMV0i8GqF1YBR4FLcAm2bNqCS+64BFPPnorbLrkNYSFhcBZ0aY/pEQMf/+M/aVtS6Nm/PaZnjHK0t4Ql0Z+1OwvBsZojfkvjo480j5lrr9XcWAVBEARBaALi44/nhjsaprszZS4rS0tVj4uz6e1lFV6oqPJCqI9JzTwj/5zRL8i3GMo+elQrhWe0u3NnOCWowDayEkkXPAGJpLcwGhNJV4SFI/bCazBq9Cj07dsXfrkZaHffxfDfswVRXaIw8bWJ6Hk+C4mAvuiLm6pvwpqf1+DMW87Et39+iyrmQDkBGrixb7o96e56yntD0XRL62OqvCXzuuYOO7VkZwOLFzfKBFYQBEEQBFvQLcrp4upoqGRpIEd0q3UbRXp5pRd8fUwuDLy8eLGmRdMtoEfR+dEU6s6IpIeHa4kIguDuiEhvYdhiHucT4IPortFoM6iNut/u5HaI6x+HgIhjNeoAYj9+AYG7/0Prd59WKs3bzxv9ru6H058/HWGJYQhBCC7FpRiZNxIz3piBC++9EBu3b6xlvrZlyxYsW7pM/au3ZLOHnAM5taLdtjrG1xX5damvTZwl87rmzqRJwO+/a+1UHW3wIgiCIAhCPSKdIWE3rEsvLfdCZZUBPl51Zu/9A4CMTIvv0xMD2K7dkXBe4MABLagQpbVeFwS3R9LdW2AknSnd9Zm68Xmmfkd2ilS3VfQ7C/AP90dQVBDCE8NRcLQAqZtSkXbz4zAaDMi69PZaKi26WzQmvDwBW77Ygp0/7sQg4yDEe8Xji31f4LIHL8M5o8/B+L7jMferucjMOn7CjomOwbRp0zDi5BE27xvT2ym0+dn6fVsozipGWX4Z/MPMZxvUJ/ppXldeWA6/EAf2CfEAOBs9caKrt0IQBEEQWhis9WYrtsJC5/QUo0j/7ju7I+nkhMl7OtKruvRiIDCoXmd3R5KaqmXw8zB16ODYdQtCs4ykZ2Vl4dlnn8VZZ52FyZMn4/nnn0exDSYYX3zxBYYPH45XXnnFqdvZnDB4Gep1ePf29UbbYW0R1Tmq3vrs0DahSBiRAENEBFKnz0ZFfLua54I2LodPVpqKqve/tj/GPjVWidc21W1wV8BdiEc8fln6C6a/MR17svbACGOt38TMmTOxetVqu6Ppuji3Jd1dJ/eg5Wh6Q+szZ17XkuC8D1PJBEEQBEFoglly1qUXOcm8lkqZKeqsSc/IsOmtpRXequzxBPS2cfkntmJjd7akpOMf7Sj0mBSj82PHAu3bO27dgtAsRTqjs4MHD0ZpaSluu+02XHnllfj4448xYcIEVFaaGE1YYNeuXXjwwQeRnJyMgwcPNsk2NxeCW5mfcfXy8VIC3VoTtMDIQLQ7pR38go9Hj/0P7ELb/92B9v83Fb5Hte+ldb/WOG32aQiJC4FfqR9u9rkZww3DUY1qZCADh3EYJdDStXTBPuf9OXalvjMlnULdnnR33UDOUgS+ofXRvK6+lPjmzIIFwMCBwIMPunpLBEEQBKGF0KqV1lfMGTCVvlMn7fb27TanuxtMAjC169KNZuvS9Xr0tm21JAFHwWoA7oqkuQuehstEure3N7Zu3Yqnn34akyZNwgUXXICvvvoKK1aswNq1a+t9b1lZGS6++GK89NJLiKFzlWATER0jaqLkjKonjkhUKeIJwxKU8LYFRsjbndoOIa1D1P3qwCCUt2mPsk49UdE6oeZ1YQlhOP3F09FmSBsYK40403gmLsbF8IMfylCGJCQhDWmoQpUS6pmZmdi23b7+nDn7tNp0W9Pd1fZXViuhbk8knZMKlt7b3KFvzaZNwLffav1RBUEQBEFogrp0RtSdNfDqdek2prwXlPjAh+3XLJnSZWY2WT06I/SsCqBhnCB4Ei5Ndw+uU0MTwr8iAOXl5fW+75577kH//v1x4YUXOnX7miuMfOvR9NhesQiKCUJM9xgERtkm0GulyA9ti7h+cahKaI/Ds7/C0ftfBryPWR5w1rS6WtXDn/rIqQg9JVRF0XuiJ27GzSr9nVCg+8MfXdBF9Vs/uvaoXZFpCvTsPdl2pbuTvEN5FtfbEPlJLVOkn3EG8MYbwH//iWuqIAiCIDSpeRzzxNm/zNFiXe+XbqN5XGGJd21nd3N16Ux7N+F4f3T7NtXithRq0XlxdBc8DbcyjmN9enx8PIYOHWrxNT/++CPmz5+PTQzbWQkj71x08o+l2TDl3lktwdyd8A7hat+DWgU1eAz05xt6XUjbEPhF+iFlQ4oyUWPyOon64QME7PoPKXc/BwQEocM5HfDW+rcwpHQIohCFKwxXIMUrBR2rOsIbx/ti5PyUg4VbF2LczHHKad4Wsg9mq5p4o8H2vmAl+SUozi5WRnmmVFVWNbg+9d68YviH+Nt9HD2Vm2/W/nX27jX349gUyDF0v+Mov2dBEGwmNBTo1g3IydGsy1k7bmNP83rp1Utzf0tO1j4jMrLBtzAuU1jqA1/v6vpFOkPc7J3ONriVwO7dzhHpPD2zKkAQPA23EemvvfYaPvvsMyXAgzgraIakpCTceOON+OmnnxDKE5OVPPfcc5gxY4bZunY9et8iCQXyd1gf+d2tn0EbghUIx6oQfNLTEfPl6/AqK0PeOWORd/bZ6NahG16Z9AoKkwqx4qYVQBLQpaqLen1VTBW252xnWF1F1LEPWP3BagyfPbxeIztzVMD+Oq39R/cDR+s8SNP4aCvem7TfMcfRg+Gg6OxZ65ZwHJ2NHEP3OY6FDPcIgiDYAq+L6IZGVq4E/vnHsSKd19p0WqP3E+vSR45s8C0VlQbVI93PUiSddenVVZpQj41VD+3fzyxa7eMY9XYULNfntYgVcwuC4Ha4hUh/7733cN9992Hu3LkYP368xdf9/PPPKCkpwd13313z2J49e5CWloY1a9Zg5cqVqta9Lg899BCmT59eK5KemJiI7t27I8yR7hTNFEZ4eBHarVs3s8e3Pqf0zFJfJD31IYLXL0NR78nwOagJ7bX/rMXLL78Mf6M/BnoPVHXou3x3IackB+V+5QhqH4QNOzfgKlyFo38cxa9Hf8W4m8YhvF3TFBV5eXuhw9gOKpVfZ++CvTBWNxyZZ9S/w5gOJ0wqWDqOrIOnaV9zYO9e4LHHDCgpMeDHH+3vee+M36Mgx9Cdf4t6hpcgCIJd0OndGbPkrEunSGdduhUinc7uFVUGBPrVk2Hk5892PkDnzifUo1PDOwrOfTIWJ6ZxgificpH+/vvv44477lCmceedd169r6W53KBBg2o9dtVVV2HgwIH4v//7P4sXSf7+/mqpC18vF/nWY+vxiu4cjZBWIUgNDUBWz0FaNw5q3MoKjIoMQvUdd2HOnDlYVLxIe0MVlBHgXTfcpfqkL9uwDN+/9D2GFwxH+X/l+OO2PxA7NBYjbhmBoGjz2RaOguZ2hcmFiOoSpd2nOK9iR5GGo/lVJVUozy1Xtf7WHMfCI4VqQqNVn1Z2+wK4C76+WltVprslJ3s7tdWJ/P3KMXQXHPFblLFIEIRG0bq15o7GCT9Hho4p0n/7zeq6dDq7V1R6wdennol6przn5mp9W/39nWYaR5Hepo32cYLgabhUpH/44Yeq/RoF+tSpUy2mqtMFnj3RW7durRZTmBofFxen+qUL7gfN4timjUZuWbuzYKyuRtybTyBs6S84467nMOz995WLe052DiKjItG7V28VxSajBo3C0A+H4qM3PkL6snR0M3ZDxtoM/PTvTzj1/lOVG70zoXCO7BypIuK2GtgVHC2wKNLrwnWX5pUidXMqOo7tCE+G3VpefRUYPVp6kQqCIAhCk0Ez5oQE1nI6XqSTQ4e0OvIGyk0PpAWiuKyedHfCWnTWzxcWwujnX6P/9Y9yFGwh39GzL6uEFozLcmxzc3Mxbdo05fA+e/ZsJbL1hWntOvv27cPmzZtdtZmCA6DIVS3ehifAxwcwlJWoeiS2a6Mg79u3L0aNHqX+1QW6ToB/AG655xZc9vplWNphqWrVZqgwYPFzi7F5nXN/FxUlFShMKbSr53pBSgGMDCdbgT4BQLO9soLjBoeeyh13ACed5OqtEATBnUhPT8f999+Ps88+W4391pq//v7777jmmmtw/vnnq8w7a8+rgtAiSUzUirsd+XdCwc9Cca6zgX7pGXl+2HQgHK0iylW5vEV4McjerSkpSF6TjLw8wM8P6NrV8anujqxxF4QWEUmnYRtryM3R+ViNCnn44YfrNdSh2ZzUlXsGjCx3OL0rMuLeR86iZSjtMcDq93Zt1xVvvfIW5s6fi6NzjqJNdRv89fRf+HPyn7jt8tsQFBBU06vcUmTeHnIO5CC0TajN7dwovIszixEcG2zVa3U4KcDsg+YCx3Qb/f4EQWhmsN5+xIgR6NSpkxLof//9t7q/fPlyDB482OL76FXzwQcf4NFHH1UeMjSWnTVrFh588MEm3X5B8BiYbcqIOkPIjjRGZiu2I0e0lPdhw8yKc5rFbTkYisISH7SJKmp4ndzOPXuwdXs7AAno3l0rmXMUNLtnqnu0FYa/guCOuEyk+/j4WJWizkG9Phh9FTwHGrHFDWyDwrZnI21zGirLKuFVkIvo7+Yg84q7YPT1s/heLy8vXHLWJTjU5RCWP7gcCVUJ2P/Tfly84mLcf/v98CnzUTXumVmZNe+JiY5RF4WscbeHkuwSlOWX2RxJ11PebRXpfA+zDjwdZsTNnq2Vsa1Zo82QC4LQMnnrrbeQl5ensuQCAwNx0UUXqSy5xx57TAlvcyxbtgwvvPACFi1ahHHjxqnHzjrrLHHBF4T6oEMa3d3ZM92RIp156AsWaOZxdTiUHogFG2NRXOaN8iovtI8ttr7He0QEtq1oo31Er2qHJfgyQFBcrHWnk0CB4Kk0D0tpweMIaR2iHNCDogLRZvZ01Uu99RuPWfXe9t3bY9wj4wBfoBM6YUrWFDw741ncOfNOpGal1nptVlYWZs6cidWrVjeqNt3WSLoeFbfGDd5UpDPdXesx79lQlH/wAfDvv8C8ea7eGkEQXMmff/6JM844Qwl0nSlTpmDx4sWoZINkM3z88cfo3bt3jUDXadFtUwWhIahIu3TRFKoj0YvF2Svt88+BJUvU3bIKL6zdE6H+7dC6GN3bFiLIv9omMb01RTPo7dOx8dvM0wlL3Rn0Z/MmSXUXPBmXu7sLLRdvP28kjEhE1o13wO+J/cg57zqr39tmcBtMenUSVsxeARwErsSV+Bk/Ywu2IBaxCEOYcmJnazf+O+f9ORg2bJhdqe/5yfmqrZqtMPpelF6EkLj6LyrrmtLlH8lHTPdjjeY9FDZTeOEFLXXNgiekIAgthIMHD56Q1p6QkIDy8nKkpKSolqh1oWHs0KFD8eWXX6r2rBTnp512murowqwqc5SVlamlbls7tsrjItSPfozkWHn4cWQknS7vFOpMKXcErVrBKz4ehpQUYO5c9VBVu3bY6jUQyTmB6BhXDB87GlykZvsju9AfPl7V6B6fDYPh+ESewVBV619rYAIBd5kCnanu9Lhr6X/6Lv89NgOqHHwMrV2PiHTBpRi8DIi59RKkDhmBstRSm94blhCGCS9MwIKnFiD/v3xMwRRUoQpbsRX5yEdrtIYf/BCIQPTP7I9f7voFZ71wls2Cm3XuuYdyYQ95SXk2i/Sc/TmIaB9h18SAO3HZZa7eAkEQ3AGKcdMout6ZRX/OHMXFxfj111+RlpaG66+/Xv37wAMPKC8bljVZ6gYzY8aMEx7ftWuXROBtYPfu3ba8XHDH43jyyQ5fZeDs2YiYPx8hq1bB/+BBpCcnw/+a03D6OGYM2tbjLCvLG598EoPduwPU/b79StBjHCfVtIk1U9q3t/44duhQ+77e2k2Qv2t3+puuz2vNFM9WAUKzIW5Ie2BzKvIO58H3yAHEvfk4UqY/j8qYuAaj8cGnBWPdf+vQHd1xDs5BMpKRi1wcwiH12ARMUEK95HAJdny/A30vs93HoLLUfEpmQxSlFam6ex9/839qdCquW+9eXVmNjO0ZiB8Yj+aCbjQrtWGC0PKIjIxENl2c6pQi6c+ZIyoqSgnz77//Hv5MzeHEbFgYrrjiCjz//POIYD1rHR566CFMnz69ViSdUXqazonBrHXRHV6EduvWDd7edoRFBfc5jnRhX7hQS3131MDLv7lLL4WB7dM+/BDBf63G1wXXonN8Ebxs/IgP/0zED6tia+5380vDwU/SgFNOAbx9aiLoFOiHDnWD0ehtVRSdCQSTJzvWgM7TcYvfo4dT5eBjqGd5NYSIdMFtiOsXp9Rc2IOPImj7BrR67xkcffiNBt8XFR2FjdiIaEQjBjG4FJfiU3wKL3jhXJyrBHoRihCMYOz8fic6nd4JAeEBKEwtVOnoER0jEBRtXU9zW6EILzhSgMhO5i9ELdW6M+U9vH2407arKfn+e+Cpp4CXXgLqlJcKgtAC6N+/PzZu3FjrMd6ngKYYN8fAgQOVsNcFOmnXji7QrDnNMCvS+VrT1+vwokouTq1HjlczOI4sxmb2CsUAc78dSa9e6p+A3VvhN7wSzEa3teHb1oNar/VTe2WhS3wRzuibDmNeMcClzsQdBXpDIp3Zw2zjNnKk1oJdOBH5u3afY2jtOsQ4TnArWveLQ8Hst1E4dCzSbj0xbdEcbLMWHR2NVViFClSoNPeLcBEuxsUIQhCO4ihew2soiylTqeV/3fsX5l0yD/Nvn49lTy3DogcX2eXebkvKu7Wp7qZk7jzuUu/J0F9m82bg5ZddvSWCILgC9jlfvXo1lhwzmzp69KgyhuPjOmzHxprzzEztvHfttdeqyMWqVavU/erqanzyySdK2Ju2aRUEwQyc/OrYEUhPd/zh6dQJ1f4B8CvNR6eynTa/vbTcC/tStFr5a8YnYcqIVASHeAGVFUCBdRHGuqSlad3nGmgIJQgehYh0wa0wGAxoNWkwCt7+AlURJq3IKiw7ntMMjm3WGC2nUGddenu0RwISUIlK/IE/UIYyfJT5EapRjdKcUpVS7hvkC29/b5WSvm/BPqftE1u4leaW2izS2f6tOMvBDq0u4J57AJaJfvKJq7dEEARXMH78eDz11FOYNGkSBg0ahB49eigjz0ceeaTmNUxtZ7u10lLtXNmvXz+88cYbOPPMM9VrKczZX/3bb7+1aBwnCIIJ7D9GLPg+2IvR2wcF7fuo2wlp621+/64jwag2GhAbVobYcJNtM3gBxSU2r49ekSzxHTRISx4QhOaCjHSCWwr1uAFxCGurpWgF/bsSHW+ZCL/Dey2+h33QH3zwQZRFl2EZlilxTnaF7MKMB2fgzYffRHVUtUqDn4d5ODDmAM744AwMuG6Aet32udvtrju3BkvGc/WJdJK9p3YdpydCI5fHH9cm9gVBaJk8+uijOHToEF555RWV6v7jjz/WSk0fNWoU/vrrL8TGHq9TvfHGG5GUlISXXnoJv/32G3bu3KkEuyAIVsCuCbQ4d1A0vboamL8+Fp8tScCuCO3vMOrwJpvXsz1JS3XvlVhQ+wkWkhfUecwKkpOBrl2B7t1tfqsguDVSky64tVBnpVPE/a/DL/0IIn/6GGl3PFOvUOcF3Lbt25CxNwOBxkBceO6F8D7WF2RInyF4/uPn8e2f32LL31vw59Y/8cRNTyA4LhhFqUXY8O4GdDu7GyI6RajPdySsS4/qHmWzSC/KKFJR+ICI5lNkxT6mPnLmEYQWR6tWrdRi6Tmmu9clPDwcI1loKgiCbXCgZf34/PnAvn2Anx97H9ptJJdd6IcD6UHw9jIiM7E/sBaIPvyv5gxrwzp1kd6zXeGJIp0hcc4GWJktw5J7vo1RdLmuEJobEkkX3FyoxyP/nS+QPeV6pN38eIPvYep73759MW7KOIyYOqJGoJOwkDA8ffvT+Pjpj5EYl4iUzBTc/OzN2Bq5VT1/YNEBLLh7ARbctQBJK5NgrLbVCqX+Nm6FKYU2i3Rib/s3d+PAAeCSS4ALL3T1lgiCIAhCC4BF2mzH1r+/JnzprmYnqTn+KCr1RpuoMhi7dkeVty8CCrMQnJNk9TqqqoFdyVpb2t51I+mcRGBqvg3p+axF79FD88kThOaGiHTB7YV669G94P3Ki/Aysez0KrTPXIQM7zccP7/+M66ZfI2qbfxkxyf4I/AP+HTxUTXquQdzsXLWSiy8fyGy92Zjy5YtWLZ0mfqXYtuRBnLWiHSKe0dOGLgK1o19+y3w00/A/v2u3hpBEARBaOYEB2ttzcaM0WrUMzLsXtXBtEAE+GnXQNU+/sht01vdjjpkfcr7/tRglFZ4IzigEomxderPGRKnQC+1ri6dQXdWzPTsacteCILnICJd8AjC24Wj/aj28Av2Q+RPn6DjrZPgl2y/0gv0D8SD1z+Ir2Z9ha7tumJNyRo8uvdRrOizAh0md4BPoA+ydmfhj+l/4L1H3sMLL76gTI5uuOEGrF612m4DubpY4yrP17BdnKfD2e5XXgH+/VccWAVBEAShSWHRNnPCi203pM0v9sHR7ABEBlfUPJbVTvP0USnvVrI9SYui90woPLG3OreN9XClJ14rmSM1FWCjh/h4qz9eEDwKEemCx+AX4od2Q1sjYvkv8MnNRMjqvxq9zn7d+2Hey/Nw+6W3w9fHFws2LMAdC+/AgeEHkIQk1Wt9AAaof0lWVhZmzpyJVcu1tkCNxZpIOslPti5zgBH37H3ZqCg5PpC6E3fcQddmV2+FIAiCILQwqGbp5MoccTtS3fNLfBAadNxgN7tdf5tF+g5LpnFEr2s/1uHBUkbe7t3awig6S+4dbCEkCG6DiHTBo/AOCYLPskXIuecZZF9wo0PW6efrp0Q6xfpJ3U5CQVEBPljyAb7BN6qtG3utd0In+MAH3dANkzAJB58/iNTNqXZ9nmnKvLUivSi9CJVlDbvPU5xnbM9Q9fXWvN6V2DGZLwiCIAiCPbAmnaqW0eoK2ybykzMD4ONdXSv6nZ3QF9UGbwTlpSAgr2HhT3+5bbpIb2fBxZ2Ku6SkQSf3c84BzjxT88EThOaKiHTB4/Bq3QrhMx9CQOSxhpjV1fAqtN8MRadb+24q/f2qiVfBAAMKUajauZE+6KPE+SAMQjjCVWR97Qdr7foc9mW3VaQbjUbkJzUcTa8qqzr+eiuj765g1ixtcF1tX+WAIAiCIAi20r695rJmQzS9ssqApMxAhAXWvl6p8g9GXrzW9yw6qeG69JQcf+QV+cLXuxpd449fB9XCz3IbNnre6U7uLK+nJ56VJvCC4JHIz1vwSLx8vNBuZDvEdotC3JuPod0Dl8M7r/E9xb29vXFKr1PQHu0RiEBswAYl1hlND0GIur0RG1GFKhQfLFZ167aSdzjPZpFOmMbekHGdaa93dxbpe/YAOTnARx+5eksEQTBHcXExvvjiC1x33XWqh/ngwYMxadIkzJgxA5s22d4bWRAEN4Aqt08fLZWtyrrrj5xCXxSWeiMk8MTsPD3lPcqKlPfth7Uoetc2RfD1sWCG6+sHFBVpbdhM4N2UFKBvX3FyF1oOItIFj8XgZUBUaAXCtq2B35H9CNztmAvHyKhI+MEPCUhAFKKwEAtRiUolzr/AF9iBHTiEQ+q1O7/fqYzdaApnjQkcKckpUa9ntLu6wnq3eAr6vEN5Vot0fkZpnuXaLlfyxBPAJ58Ab7/t6i0RBMGUkpISPPnkk2jbti2mT5+O7Oxs9OvXD+PGjUN8fDx++eUXDBkyBKeccgpWrlwpB08QPA2GoGNjtWg6U9+Zh14PuUW+KC33QoDvidcrunlc3O7l6LnwNcTus5wep6e69zRXj246icDCcy4mcFNbtdI6yQlCS8HH1RsgCI2iTRsYFi8Ctm9H5KkTUPRPcqPblfXu1Rsx0THKJC4CEchDHl7CSyiGVkQdgADEhcahU0EnJK1KUouOf7i/ivB3ntgZEe0jLH5Gzv4cxPaKVULdFhhNj+gQoSYozFG3Dp0p8gHhx1vXuQuJicBVV7l6KwRBqMull14KX19f/PDDDxg9erRqg1mXzMxMfPnll7jsssvw1Vdf4WT2YRYEwTMIDNRC0itWAIcPa0Kdhd4WHNgy830ZFjH7dHZiP1R7eSOgMBNd1nyBjuu/w4J7/kSVb4BF07jelurR9V7pTHeneVyQn3qI5fP5+VoNeliY3XstCM0/kn7kyBG89tpruOCCCzB8+HC1XHjhhXj99deRwlwUQXBFW5EpUxAUE4Q2g9rAq7wMqLTf3dzL2wvTpk1Tt1mb7gtftEVbtEZrVYteilKsLl6N8sTyE95blleGPb/vwV/3/qXM3iyRfyQf5YUnvr8hGCk312/d9Plan5Ocj4pi93R6N01jO3DA1VshCAJ599138e2332LMmDFmBTqJiYnBnXfeid27d6MXjagEQfAsmPJ+4YXAeecB4eFAtuVyweSsQAQHmM8UrAgMx/oLZmLviCtQHhgO78oyRBzZVus12QW+2HY4RLVwM8CIHm3raSmr2rBVKJGul6YfPAh06aJd6glCS8JqkZ6UlIQrrrgCHTt2xBtvvAF/f381e87Fz89PCff27dvjyiuvVK8VBFcQElCJzi/egvYfPw1vb/v7cow4eQQefPBBREdH14h1GsYNiByAfp37obKqErOSZuGPxD/Q99m+uOiHizD1y6kY/cRoFemmgdue3/ZYXD+j/fbUs+tR+IaM42ruV1ThyLojDdayuwqK88GDgVGj6jV0FQShiWjdurXVr+V1QESE5YwhQRDcFKaVx8VpRnIU7BkZZtPeC0u8kVvoq66tLJHWbRR2jL8DGR2HqPtRJiZy+1ODcN1r/fHQp9pkXrtWJQipY0B3IgaV7q7H/WgyO3SotsmC0JKwOt190KBBuPrqq7FlyxZ0tzCdtWvXLrz//vvqtenp6Y7cTkGwjg0b4LX2HwSEbEPC448hKc3fboFKoT5s2DBs274NOdk5qladqfBMNf/575/xvzn/w5qkNbjkiUtw80U348YLbkT8oHglwJc9vQz7/tyH3pf0hm+g+ZGlKMNypL0+GIEvTCtESOuQBiPpem162uY0xA+Mhzu2bc3M1FLZ6EU1YoSrt0gQBI7zfZkOWw9r165FSEiIRNIFwdPp2RPYtk0bjFmrbsY0Lias4cw/msi13b4Q0Yc3QQ9RrN0TgWqjAf6+VQgNrMR5w6xoXWswoLK4DL5B2t2pU2nqa9eeCULLiKRz0H7++ectCnTC5/ia//77z1HbJwi2MX488PnnwNKlCBjUB20Gt7GYsmlt6jsvVkeNHqX+5X2ub/LYyfjljV8wfth4VFRW4PUvX8eF91yI7fu2K6Ee2iYUFUUVOLjkoFO+QUvRdHMiXU+vt3dSwJkEBADffgvs2ycCXRDcBRrGcVI+n7NndSgvL8cjjzyCkSNHIjc31yXbJwiCA2G6e+/eWsuVOlCkV1cb4OPdsH9OVqLm6hZ5ZCsM1ZW16tCvGZ+ED+/cjPH9MhveHm9vlOeXqvJ0QWjJeDkjBS6OKTSC4CouuQTo10/dDG4VjLjeUY0S6pZoFdUKbzz8Bl6890VEhEZg54GduOjei/Dal6+h08RO6jU7f9iJwtR66q/spDiz+ATndkbw63OYz9iWYbNRXVMwbBhrXF29FYIg6Lz44ovYuHGjcnVfQXOpY2zevFk5u3/88cf4+eefxTBOEJoLx0r76pKW6w9fH+uyEQtiO6HCPwQ+5cUIS9sDJjHuTNYy/nrV5+heF19fVOSXiEgXWjw2Gccxmt4QHLwFwW3YswdhZ4xAm/SNTlk9xf9Zo87Cr2/8igknT1C16m/PfRsPL3gYPqE+KEorwh93/oG98/c6XCDnHsi1KoquU1ZQhtyD7h35YhLO7t2u3gpBaNmcdNJJWL9+Pc477zyMHTsWjz76KJ599lkMHTpUZRRt3boVEydOdPVmCoLgKIKDNdM2Wqkfg5csGfl+CPSzrr0svLyRnXiSuhl1eBMOpgehpNwbQf6VaBdrg+mMr4/KRPQx1H9NIwjNHZtEOmfQX375ZbNiIzU1Feeccw5uu+02R26fIDQONuLeuxchr/wP0Z2cZ3AUExmDVx98Fa888AqiwqOwI3kHXi58GWUxZUo8r397PZY+vhTFqcXYvn07li1dpia9GmPoxhR29k631H7NHDSrq650TxO5OXOAAQOA229vsG2rIAhOhqZwHO9fffVVJdAp1GfMmIHPP/8ckZGRcvwFoTkREqLVn5n0J6fALi71RqCf9dcM2cdS3qOTNtWkuvdIKIS3LWrDxxfl5UYEedveAUcQWmyf9E8//RQ333wzfv/9dxUxb9u2rXr8m2++UeKcNemb6P4kCO7CrFmAlxdw//2IadUKZcWVTkk/1zlz5JkY1ncYnn73afy+/HfMzJyJSeGTMLRoKNI2pWH5DcvxecbnKC7Weq6zHzvbvdGkzlaY3p57KBfRXaOtiqQTinr2Wo/p7n755ePGae6tvP5ni1S2chUEwTVwMp5dWx566CFMnToVXl5eeOqppxAWFoZbb71VvhZBaG6RdIp0tlmhYD/m7E6hHhFifRvXrHaaSI86vBnbDXakuuvp7qXlCPE7PmEgCC0RmyLpF110kTKFq66uVulwFOp8jAYz999/P5YvX46uXbs6b2sFwVao+l54AWjVSt2lw3lARIBTj2NkWCReuu8lVa8eHRGN3/J+w2uVr6EEJSg8VIj4quMu61lZWZg5cyZWr1pt12cxfV3PbLFGpOumc6YReHehc2ct1f2bb0SgC4IrOXDggEpzf/LJJ1Xf9Hnz5qne6W+//bYS7WeddRbS0tLkSxKE5gLt09lO0SSSXljqg/JKL/j5WJ/alhffE1XefvArzsGOw5o9e69EGwMjNI4rNyLUV0S60LKxSaSThIQELFy4EGPGjMG1116LH3/8EUuWLFEinTPtguDOeP29BO2euxX+vs7Ppz5t+Gn49c1fce6Yc5GFLKzDOvV4h/IONa8xQtuOOe/PsSv1ncKcde/meqRbgunujKa7I+3auXoLBEG46aabEBAQoGrPr7zyypoDwgl5msfR9Z216bvFQEIQmpd5HCPpx2Akndjiu1vt44fctr1xEB2QVRQIH69qdG1jY2cZgwFGowFBBhvq2AWhGWKzqubgfMMNN+CXX37Bfffdp1LcL7vssloOsILglhQWKud3w/zfkbjqa4v9y01hKrmXj/2TT3R9v/L0K9EGbbARG1GFKrQ2ap0SqlFdI9QzMzNVP3Z7YMq7LZF0kncoT6XLuysFBcCjjwJHj7p6SwSh5cEI+h9//FFT0mZKhw4d8Pfff+Ouu+5SXjSCIDSjVmwmhjC5xb7w8rL9OoGt2FbgFHW7c3wx/H3t8cExwh+1O9gIQkvDJvWxaNEiNXv+zz//YPXq1Zg9e3YtB9iHH34YFSbOkILgVrDOirnUV14J70ceQuLJiQ0K9bCEMLTqraXK20tOdg5CEIKEoATkJeSpxwZiIA7jMIpRjAhEYCRGYttj27D7F9utzYszilFRUmGTSGertoIUG+vEmhAG7559Frj7bldviSC0PE4++eR6n/f29la90keNGtVk2yQIQhPUpZNjQj0zzw8BNpjG6WS3Oy7Sba5H1/H2hn+Z+16jCILbifQJEyaoGvQNGzZg0KBBtRxg58+fr4zlRoyw3QBLEJrUnezTT/nDhW+QrxLq3r5aSlddfAJ84Bfih/B24QhprRmg2ENklOaE7G3wxgUvXqAi6D3QAxfjYozCKEzCJLRHe4bWse2bbTbXi7MmPe9wnlXu7nWj6dbS1I7wTz4J0N7i6qub9GMFocVD8b106VKrsuoYcV+zZk2LP2aC0GwCGX5+QHk5KioNyCv2QaCv7f41OQl9akR6v+hkm99fWWWAj68B/qXu3TJWENxKpHPgfv7555Uwr8tpp52mTOU6derkyO0TBKfi++UniC/YZfa5oBjN9ITE9Y9Tot0eevfqrVzcDTAgslck1vqvRSUq0Rmd0Q3dlGjfju3wDvNGWX4ZDi8/bPNn5Cfl2xRJJ8VZxSgvsq7FSVPXsPfvD+zYAUya1KQfKwgtHk60s/a8X79++N///ofFixdjz549SEpKUt1bPvnkE1Wn3qZNG+zbtw/dunVr8cdMEJqVw3tpqTKNKy33ti+SXhWB7eitbo80Lrf5/eWVBvgFeCOgLN/m9wpCixXpI0eOrPf5qKgozJ07t7HbJAhNw5dfAtOmIfjmqxDhp7VEsyTSvf280WZQGxhscVA5hpe3l2qzppPik4K/8BfSkY6d2Im38TbmYi4W5C9Qz+/8ZWeNYzvT0q0R30x3t8ex3dpouisc4Wk2q1Ptnq3dBaHZcfbZZ2Pnzp24/fbblffMGWecoYR4u3btMGDAAGUSy4n6lStX4rPPPlPjviAIzYCgIG2hSFft17wQ4Gf7uL8zWcs87I6d6Jy2yub3V1R6wdffC/7VYhwntGysFumcOWdblobgzLqpG6wguC1TpgDDhgF33YXYcSchJC7EokgngVGBiOlhX39x9kG/26TAOgc5WIiFOBxzGDPunoHLJl2mjOUYYc/bn4cf7vgBP1zxA749/1vMu2QeUjakwBkwTb6hVHam0fM1fK0r+P13oFcvYOdOl3y8ILQ46OzOiUV6z+Tm5mLLli1Yu3atugagWdz777+vIu2CIDQjGITgpFtuLgpTC2GsqIK3Hb6525O0a6lTsALRSZttfn+5LtKNYhwntGyszt/t0aOHGpQZTT/nnHNUTXrr1q1VxI+D9rp16/Dzzz8rU7kHHnjAuVstCI4gMBBYtkzVYHEcajukLbL3ZqvFy9fLrKlcVJcoFGcWoyjDxpYiAIYOG6pE+OOPP46s9CxVq85UeEbax40dhwkjJ2DB0wvQrbQbyg8fT0OnC/v277YjftDx/uqOgpF6iu/ITpGWX3OstRt7skd2jrQrm6AxvPUWsGsX8NRTWvKDIAhNR0hICPr06SOHXBBaAJkBCUgvK0VqXiCQx5rwQJvXsT0ptEakh6bvg09pASoDtMesoaLKgLAQwKviWJ/0rVuBLl2OG9sJQgvBxxYzmeuvvx5vvfUWXnnlFVWjZgrT4S699FJ8/vnniIuLc8a2CoLjoUmKTlUVorYsReS5k1FWaLlWO25AHA4tPWSzUZtOr169YOh5otAd1ncYur3RDV/P+hor9qzAURxFWFgYLi24FBnbMpRIjugQAUfDVPaIjhEWxbeebs+U+sMrDiO4VTAiO0aqEoCm4I03gN69gccea5KPE4QWD2vSOQHPri3jxo1D+/btW/wxEYSWwHbvvlhl6AXf6jRE+v9ns0gvqzBg71FNTA8I2wdDvhFRyVuQ3qX+jhF1091Dg6oA32OBkkWLAHaOGjzYtp0RBA/HpkQWiu+nnnoKu3fvRlpamnJ537hxI9LT07Fr1y7l9CoCXfBIWPR8wQXA1KkwvPUmAsIDLL7Ux98Hsb1inbIZka0iccuLt2D6zOnwb+uPXfm7sN24XT239cetTvlMiu+Co5ZbnZjWxJfmliJrdxaOrDvSZH3WO3QAZs3SjGcFQXA+zJjbv38/brrpJtUXnYawN9xwA7788kukpDin9EYQBNeTlweERXijWy9fxIaW2mwIszclGJXVXogILkdk+3D1WGQSxb5t6e6hgZVAu3baA0zB37IFKLI9g1EQPBk7qk00WrVqhYEDByojmdhY5wgWQWgyvLzYHFhzNrXCCIn90wMiLAv5xjKo1yD8+MqPuH7K9VhnWKceO7D4AL5/6HusmLkC/374L/b9uU+J66rKKlUzumzpMvVvdZUdbqx7Lbu3mzOuK8kuQeqmVLiC1atr2rgKguAEbrzxRqxYsULVoy9YsAAXX3wxtm3bpiLsdHXv2bMnbr31ViQn295eSRAE94TjKkW6SjBkOSBvlB1LObcx1b1XYiFy2mm+FVE21qVzO4L8Ta5jeE2WmQns3WvTegTB07Gpp9TgwYOxfv36mvtMbb/iiiucsV2C0PTce6+KpKNzZ6te3qp3KxxeaXu7NGsJ8A/Afdfeh9NHnI41D69BRGUEyreVIxm1L4xzfXLxZ+Wfqt6dsN0bTZ9oVmctbP1WlF6kUtnrYsldPv9IPvzD/FWdflPAgfuGG4APP/TG//4XrszkBEFwHkFBQcrdnQspLCxUHVyeeeYZvP3225g6dSoSEhLkKxCEZgD1OJcakc6lvFz710p2HBPpPRMLkJ14krodeXQbDFUVMHqf6PNjFgNqt35jECU8XIums+WjDdsjCC0mks70dlPExV1oVrAm21SgFxdriwXo9s6IurPp36M/ps6aiqJuRVhkWIT5mI+NvhtRFl2GKlQp8d4RHWten5WVhZkzZ2L1qtU2fU7Wniyzj9fXAi5zZ6bqt96UX4+XlxFHj5p4CQiC4DRYzkZhzsj5kCFDVJQ9Ojoa99xzj/LXEAShecDLHYp0f/9jPVBDQ22KpLMCbscxZ3dG0gujO6A8MBzelWUIT91l9ToMMCLIv07rt1atgLQ0wIouU4KAlp7uLgjNmkOHWJiphW7rya1u3bc1/IKdLxhbdW2F61+4Hne/dDfyOubh54qf8VzWc1iCJer5buhW81ojtO2d8/4cm1LfmcJuTnDXJ9JpLsX2cA21cXMU990H/PNPNW66KaNJPk8QWiKLFi3CHXfcoVzdGSl/6aWXEBoaihdffBE5OTmqm8sLL7ygUt8FQWgelJRogXMl0klEhGbYZiWHMwJRVOaDAN8qdIorUjPr2QlaND3q8Ca2qmlwHaWqN3s1QgLqXHdw0oDliNu3K5NfQWgJiEgXBHMcPqy1/Vi4EEhKsvwH5OOFNoPbwODVNG3JenXuhbkvzMXF4y9W99dhHcpRjnCEoxVa1RLqmZmZ2LZ9m81O77aIdPV8WSXykpqmhzrNXgcMaJKPEoQWy3PPPYePPvoIkyZNUnXna9aswaxZs9R9inVBEJqnSKf+pR5WBAXZVY/evW1hTX91PeW996LXcdb/TkGnNV/Uu46yCm8E+FYjOMCMEG/dGqAPhnhhCC0Em0X6jz/+WLPUvW/6uCB4NKeeqjXlpgeD7jBqAdZlx/VruraDfr5+GN9/PNpDa4u0GZopSyd0QjCC4WNiNZGTfaLoro+itCLl9m4aKa8qr7JK3PO1TUlGBktutPkUQRAcB1PZL7nkEsybN09F0k855RQ8+uijWLhwIYrrKQESBMGzRXotggIBHx+ro+k7Dmup7j0TC2seS+0+BpW+Wg25l7EK7f/9qf5tKPdCcEAl/H3NRN0Z4ud1xs6dx3PzBaEZY5NxHJkyZUq990lTX6wLglO48EKrX8radJqvZe+z7JLuSCKjIuEPf7RDO+zBHgzBECXS+R8pRSkO4qB6nS3wb5f92GN7ah0bqsqqrPp7riiuQGFqIULjG46yMTWe62QWgqXe7NZw441e+OUXTaz/8YfdqxEEoQ4TJ05UCzl8+DCWLFmCv//+W7VhO3r0KIYOHYoxY8bg9ttvl7argtBMYIezWkNyYJAmjCmG9Z7lZtieFIJdR0Lw3yHNo6dX4vGWrkXR7bDgngUIKMjE+DenIiTrEPyKclAebP7apKzCC9Gh9UwKsDZ92zYtw5EGcmefrZnKCUJLj6SzFs2aRRCaHevWAeeeW6+RXEzPGATHnuiObgnfQCudTs3Qu1dv5eLudexPeCM2IhWpKIE2FR6AAPRADyQE2+68nHc4r6YHekOp7g2lypuDfdb3/rEXR/45gsbw/PPVGD5c66EuCIJzaNeunWq9xvT3nTt34p133lFC/dlnn8VWlgQJgtAsYPu1WlqcAp0p7yxUt0BxmRce/6IHPlrYDjmFfvD2qka3tscj6aTaxx/FkW2RH6sFEaKSLfdNr6jyQmRIPSI9LAyIj9fq048eBfbts2UXBaH5ivSIiAirFkFoVnCAuuACqLDtjBkWX8aocPygeKuN5ELiQxDW1j53eC9vL9VmTX0uDNiJnViERfgQH2ImZqr7ZP5781FdbZupG9Pb2V7NVpFO4zlG0xuivEgb8IsyilCSUze/znq6dAFWrQL6aa1YBUFwMOXl5Vi+fDmeeuopjBs3DpGRkbj++utVJsy1116Lrl27yjEXhGZCbq6JaZxpj/LSUovv2ZUcgvJKL4QGVmJMn0zcdc6B2j3OTchO1Pumb7K8EUaj+Xp0U0JCtOg59QaN5OrZPkHwZMQ4ThAagk1DP/kEOP984KGH6n2pt6832gxpo0R0Q/iH+qvouzWvNQf7oD/44IOqHZIu1iMRiZ6RPXEkVotSV26vxHUPXodDRw/ZtO7sPdnqQtwWkU7St6XXROHrS43Xydplvu2btZim5h08aKamThAEm/n4449x+umnq0n3UaNGYc6cOWjbti3efPNNHDhwQC0ffvgh2rfXfDEEQfBsWHbOREHVI90UGkXWU/Kmm8UN7pKL6eftx5i+lsf04yJd89GpC5vRsCX6Cc7uloiJ0dqysRuPIDRDbK5JF4QWyZgx2mIFFN8RHSOQvbf++nS/ED+V8h7ZKdJij3JrhPqwYcOUiztN4liDzlR4urvPvW4u/HL84L/THxfccQFuu+o2XHn2lfCusW6tP9pdcLTAZpFOAc66/Oiu2sSBOSpLjq+T0XS2fQuKts1Fti4//QRcfTVw+eXAm282alWC0OKhQRwn/1555RWMHTtWIuaC0ELarzGbvBbBwZp5XGWl9q8Fkd7TpA69IZEenrIT3hWlqPINOKEe3aKzuzm4PQz9s0adqXVWXNsIgichIl0Q7IFOZUOGAMei2HWJ6hKlDNjq6x9Oka5e2zVKtTCzVRDrMBLft2/fEx4fcskQrH97Pcbyv4qxKP2gFB9/+jES+yWix7geSBiRUG8Un9F0//C6uW8Nw/eFJ4bDJ+DE00tVRZVaTGFtOjMKIjvaZnJnCsvTWE+3aZOW+cb7giDYx+effy6HThBamEinP9wJkXSKdAphDqxMMzehosqAXUc0H57e7RoW6SXh8SgJjUVgQQYijmxDVodBtZ8v94a/bxWC/W24FoqL01q8MJreSat5F4TmgqS7C4KtvP467Y+1sC2bilpIe2eE3BLeft5qUX+E3l5o1ft4j3NH0WFcB7QZ2ka1iNPN5IIrgpG9PhurZq/Chnc31Pv+soIyq2rM61JdVY2MHRkNprqbvj59azpSN6XCXiZMAObPB/7+WwS6IAiCINgq0pnyfoKJOwU6U97N1H3vTw1CeaU3QgMrkBBtRV24wVBvyjsj6aGBVfDztaFDFLePOfKcoWe0XxCaESLSBcFWRo/WWn/QNKkeUzaKdHPRZD0l3pTQNqEIimlcynddfPx9MOrRUZjy+RRM/XIqhvxvCDZ224g1WKOe3/3HbmzdUr87c32ZAPWRn5xv1hTOnEjXYTaBvWn/5Mwz6+0SIwiCIAiCGfTGNWa7otI8zozD+/FU90Lz7zNDdrv+FkV6abk3okMtO8lbpE0bzZTmwAHb3ysIboyIdEGwlZNOAnbs0CLq9ahCRtMThiWofuCWUt1N0XuT20pdwW8Ofl7nPp0x6/lZGH3XaKR4pcAb3njjsTfw5tdvoqKynpYndpKxLcMmkU4yd2aqOvXGQI8b1qU/+WSjViMIgiAIzR7GGpKTLQh0wjR3M+ZxO5JCTuiL3hB6JD2Sbdiqq05In48IsSMazmg68/Q3b7aY3SgInoiIdEGwh7quxhb6pzPVvO2Qtqp/ekB4QL0iPSAiwOZousHLgOju0da/3mDAlPFTMP6G8er+wOqBePPLN3HhPRdi+77tNennW7ZswbKly9S/vG8PjKQXZxbbJNJJxnbzqfLWsmIFcPvtWre8tWsbtSpBEARBaNYwAM24AwPSZmFdOgMSJtF0anY9kt4r0fqyuPzYzqjwD4ZveTHC0vfWdnY3GBEZbEckXa9NP3IESEmx7/2C4IaIcZwgNIbCQuC22zTTkkWLzLqLUnhzqaqqwg6OhBTpoX4WDefqCtv6oDt8SFyI+reixPpoeO8JvbF/7n4gF5jkOwnLDyxXQn3i8Ikqmp2dfdyZPiY6RvVkp5O8rdDh3nTiwRqRXpZfpvq029tD/tRTgXvuARISNG8/QRAEQRBOvHyh7l63Trt0oRY3C5+gG2tZaY2z3JHsAOQX+8LPpxqd42zIfvPyRk7CSWi1b7VKec+P664eLijxUfXoseF2inRG01mTvn+/NvgLQjNAIumC0Bg4a/v998Dy5VoI10rMRdKJirhHWG9Nzpp3RscjOkTAFpiK3/Xsrur24IrBuBt3Y0r1FKxatQobszeiBMfrybOysjBz5kysXrUatsLU9dK8UptEuvrMXVmqT7u9vPAC8H//V0/6niAIgiC0ULZvB77+Gvj2WyApCWjbtp4XM4oeGQkUH78u2H5YS3Xv2qYQvj62jdXmzOPyi33QKrwMIYGNSFdnt529e4GixpXMCYK7ICJdEBoDzeM++QRYskQzlLOC0PhQFfm2REyPGKs/XjemC28fXm87NXP0uqAXBt86GK36tgIMQB/0wW24DQlIQBKSkIEMVKNa9Vwnc96fY1fqe9buLJtFOvu0U6g7Ak6u80JEEARBEFo6NGr/91+t5Rr7onfubLYFem1iYzT792PssCPV3axIPzYZT9O49q1ONJu1iYgIICdHm3UQhGaAiHRBaCxTpwKjRln98the9RvEMZpOIW8NPoE+NZHxiI4RNtezdzmzC8Y9Ow6db++MNKQpM7nx0OrVc5CDQziEYhQroZ6ZmYlt27fBVtjGrTirWPWBN1ZbP+NOp/eCo9Yb0piDHjJsz3bRRcB77zVqVYIgCILg8TDYzCRARs/pCWdVV5TwCC2lnMrexNndFtM4ndw2vVDt5aP6pQfmpqCi0gBvLyNiwuxMdddhzj53Zv164IcfgFWrGrc+QXAxItIFwZGkpwOPPVavw6jeH70+WvVpZdYVvi6mLd6iOkdZ9R5zlPiVYCVWogpVaIu26Id+8IEPKlCBZCQjFanquZzsHLvWzz7ojI7bCnunm6bL2zNmn366diHSurXdqxEEQRCEZhFFZ0txtj43Y6FjGb6BA2lREXIKfZGSEwADjOieYHskvco3ALnxPdTtPn+9hE6L56CVV4b99eimcOaB6e6HD2s5/ZL6LngwItIFwVEwr/qUU4BnngFmzmzUqii+Y7o3nPZumjZP8R/ZMdKuz4uMikQpSnEYh9X9ARiADuiAcISr+/nIx0EcxJ7UPXatn2Zw9qSvM73+6PqjqKqwv07tgQeALVuAyZPtXoUgCIIgeDy7d2tRdJsnrb28NAf1khJsP9Z6rUPrYoQE2Dc2Z7UfqP6N270c/dfOwfAdH8Hf175OMrWgsR1t6tmBJz8fSEtr/DoFwUWISBcER8GirkcfBXr2dIgiZPp6YFSg1ZF0Etk5UqW+20rvXr2Vi/su7FL326GdiqjHIQ4d0RFBCFKR9Oe/eB53zbwLGTm2t0ljyrs9sI499d9Us8+VF5araHvaf2kWU+lpHtehw/H7eXmaq60gCIIgtBQ47rEWnaXbNkXRdWgeZzBg+yFNpPe0ox5dZ9+IK7B84J1I7TVW3W+bsh4OhTvIendpySZ4MCLSBcGRXHWVNgr26dPoVdG1Pa5/XL2GcHpNug4FOtu42Qo/g23WWIeejnR4wQtjMRYX42JcjauV+/v5/c+Ht5c3FqxagLNvOxvfL/q+UQ7stlCYVqjaudWlIKUAeUl5yD2Ui5wDDafi79kDDB8OXHklUO2ASXtBEARB8AS2bdMq8lq1su/9H/0UhSkfn4tf1ser+73iThyTraXYNwIbBkyD8Zpr1X3/g7u1XHxHQlc8NoFnlqMgeCAi0gXB0dBcRYcjYiOErF+wn4qOWzJ+8/E/0ZI1slNkve7xlmAf9AcffBDbI7djD/ao9HeKdeILX0yOnYzvXvoOvTr3Ql5hHh5+9WFc/8T1SE5NRlOQuSsTpbm1B/GitOOtVphOT3O6eteRqbVRZV/YI0ectqmCIAiC4HJYkr10KbBokVaLHhurZa7bCm12/ljog6pq7c1hQRXoH6mVx9kDW66FB1coLx21UfyAnTvhUBj5z84GMmzP/BMEd0BEuiA4i7lzgW7dtBZtjYB15uai6eYEui7eo7tH2/VZFOpvffgWznv2PHT8v47oem9XjH5Say138O+D6BjZEXNfmIv7rrkP/n7+WLVpFc65/Rx88tMnqKrHLM8RMJ09ZWNKTRu4qvKqWqKdj6duTq3XQX7ECGDePE2kJyY6dXMFQRAEweVO7v/8o0XRSZTtiXYKBqRLSoDgYODjj4GPnj2KMJ8iu4MQecW+aBtVqtWh9+6tPahvpCMDJuXlUpcueCwi0gXBWezbpxVAf/llo6LpNIRjH/SGUt1NCUsIU1F4e+CEQN++fTF63GgMGjUIcQPiEN0tGtUV1dgzfw+M5Uac3eVsvDnhTdwWchv+r/z/kPJBCi67/zLsPrQbzoQO8Tn7tbT24sziE9Lti9KLcGj5IVWrbomzzwbitWw9hZPnFgRBEAShyaE+3boVCA8HOnbU/NTo0WIPun6m5Q6Fvm9sJOAfYHeKekWVAW1jjr1XF+ncWEcTGAgcOuT49QpCEyAiXRCcxf33A3PmAL//bv/IaJLCzgh5faZxdevZ+R5HwHV1P6+7ur392+2Yd8k8LHl0CZJ/SUZsYSz84a+c4Mv2lOH8u8/H61++jvKK8loR7i1btmDZ0mXqXz0Sbi+5B3JrBLklJ/nDKw5b1bptxQrNPoAp8IIgOBdm26SmpqLsWK9lWzh8+DCOSI2KIFgNtSnNzZlN3ljYzYz06mXSko0OdEW2m8eVlHshwLcasXpfdN3Dh9bznFlwJGwbl5Xl+Hp3QWjuIj0rKwvPPvsszjrrLEyePBnPP/88iouLHf4eQXAJdBe94QbN9b2RsMY8okPECY/VR1himF1O7+ZIGJGAkPgQGKuMgBEIjAlEu1PbYdDNg9B5Qmf1mknBk1BRWYE3v34TU/9vKjbt3ITVq1bjhhtuwCOPPIIXXnxB/cv7fNxedJHPSLol2LIteU2yEuyWYBD+vvu0MrgnnrB7cwRBsIIvv/wScXFx6N69OyIiInDvvfdabTz51VdfoX379hg/frwca0GwAhqj7tihXX742m5RUwv+mZ4g0hl4YEpaqe0TbnlFPogILkd06DFBzhA/BX9Fhebu6kiYn09b+1xtcl8QPAkvV86oDx48GKWlpbjttttw5ZVX4uOPP8aECRNQacGJ0Z73CIJbYDTC8NZbCGZxmJ3E9opFcKtgqyLpetp6XWFvL1zX+JnjMfbZsTjvs/Mw+cPJOPm+k9F1Ulf0uawPvHy9EFYUhtlTZ2NY4DD0TuqNFfevwBczv0B6VvoJE20zZ85slFAnDfVOZ8160uokixF1XmOwPv3mm4F3323UpgiCUA8bN27EVVddpSbV8/LysHLlSsyZMwevv/56g8dt3759uO+++3DhhRfKMRYEK6Fn7eHDdvRDN8PRo1rlHsV+164mT0RGaHXfNmbGFJT4oF2r0uNt4DgYO7MuneJfRLrggTQ+xGcn3t7e2Lp1K4I5y3WMbt26oV+/fli7di1OPvlkh7xHENyCt96C1513IoG9T847D4iOtivtvM2gNipCXJJTUm9NummvdbYmq65sfL+xwMhAtZh7vOO4jti3YB+Kvy/GREyseW44hmM91iP42H/ECCMMMGDO+3MwbNiwelvMNRYK9eTVyWg7rK3ZbecE/ttvO+3jBUEAJ8HeRZ8+fXDNNdeo4zFw4EA1yf7WW2/hzjvvtHiMKioqcOmll6rsuR07duC///6T4ykIVsDKEGrnoKDGHy5dN1Og14rKh4VrBepsm2LlbAB9XY1GA9pE1pk8Z7H7ypWOd3jXJwHo8i4IHoZL091NxTYJYe2IMrsod+h7BMHlXHMNjP36IfPaa7XenXbi5eOFxJGJaN23tVXGcHSAVy1OnEyPKT2UwR0JbxeO6FOikYEM+MAHQzEUR3AEqUhFFapqhHpmZia2bXfwrLmFiPvR9UcbjLwTGvHfc0+jfP4EQajDunXrTphEP+WUU7Br1y7k5+dbPF5sCdmhQwdcffXVckwFwUpohkpX9zqXy3bDtHmiB7trYC+3du20D7Qym7Wg2AehgZVoFVF+okjXP4y5+o6EMxXiZyF4IC6LpJuDs+Xx8fEYOnSoQ99DkxpToxr9ooDp885uG9Uc0I+RHKtGEBCAqtWrkbVvH6KpABv5uwtNDLX6OwnrEIacwzkN9hBvDCFtQzDp3UnqdlBMEFatXIU96/YgtiwWgzEYO7ETbdEWgQhEhHcEwhAGb3gj+3A2jCfZpoiNBmOtf62hoqwCadvT0LqP5dl+Xhtce62XmuUfPboKZ52FZov8TbvfcWzO59eMjAxE18keiomJUf9ysi7MzMTl/Pnz8e2332Lz5s1Wf46M9Y1DzgvN4zjSLI5eaUzca6RnrWL7dsbzDOjVq+rE9cVFA62igJICrS95AxRW+KJNTAmCgzllb7KyTp3g5e8PQ1ERqiio27VD1bEP0/+1G55fCgq0xRGpBR6Gq3+PzYEqBx9Da9fjNiL9tddew2effaYG5iAr/4isfc9zzz2HGTNmnPA4Z/H1SLzQMLvpvCk45jhWVcGrsBDV7I3SFMQ5/yP8OmiR/UpUYmiHoRhy2RAsunAR8nbl4Tpcd/yFJucm43YjKm+3b/Kgqr1tJ8ts/rej/pS36dOjkZvrgw4d0mqiB80Z+Zt2n+NYSHOjZoqXl9cJvjFMZdfL2OrCunVGz2fNmqVu6wvfc/DgQbRu3RqBbK1UBxnrHYOcFzz/OI4a5Zj1ZGT4ICWlBwwGIyZM2IXQUDNR7i7WZ+t1UP8Pwo5jt2o9d9JJCFm3Dqnp6cgx2YHd7dvDIbTwVmzyd+0+x9Da8d5gtNZe1Ym89957uOOOO/DNN9/gPNbrOvg95mbXExMTkZ2dbXYGXzhxxoc/TNb/m7ugEmw8jn5+8GXae2AgqufP11LGmgDWZpfkljTJZ9GBnX+fful+GF42XKW5p3ulK6FcUF2AUpRiFEbBC14YO3ssWvVsZfW6GUGnQPc+5A2D0bYZdrrdsz7dP9QfLRn5m3a/48hxKSoqSonR5jYujRw5Uh2jjz76qOYx3p42bRqKiorgT3MnEw4dOoTRo0fXeiwnJ0d1cmnbti0+/PBDjBs37oTPkbG+cch5wfOPIwN0P/ygBY3jHDA5zzals2Z5o1MnI1591UIaOq+vt2wBysuAwiKtcN3MOay80gspOf6YMjwVrSNONJszfPYZvObORfW4cTDefbeKoFOgdzt0CN6NlSrM/6fw79BBqwNwQNcdT0H+rt3vGFo73rv8V/r++++ri3m2WLFWoNv6Hl4A1L0IIDzQIjqtR46XY/CuqoLh339VizZvthup6WniXFjHfnj5YavbHulmdfbM43l7eePKy69ULu7pSFeivLJai6RVoELVp0cgAv3RH1888QXG3D8GbX3aKid2GuK1GdxGfXa922Y02CzSq8urkbIuBe1OaVdvC7vC1EL4hvrj0Sd9MWECcNppaJbI37T7HMfmPBaNGTMGn376Kaqrq1VUnfzxxx/KOFIfmynA09PT1QQ6260xYl63Pv3HH3/EznqMpWSsdwxyXvDc40gPt4wMLdXdESE43TSuZ09eC1jYF78gYNAw7fa+fcB/mwH/YK0NLcfTEm+k5ASgrMILiTElaBVSZl50H6tL9+LfuMnzfG2jRTqvJ9hdh8vgwcCQIWhpyN+1+xxDa9fhUuM4zoazlRrF9tSpU82+hulrl19+uU3vEQS3pls3Ng0G6FTcRAKdBIQHILy9ben1kZ0arjGzxIiTR6gL64DoAJUCrxMfE483H3gTg68ajGpUo01JG+yesRtLHluC1S+sxvKnl+PQMuelpbE2nw75lozkygvLcWTdEcy8PwsvvABMmaK1sxEEwT5uv/12JcIZOf/333/x8ssvY968eXj88cdrXvP777+jY8eOSElJkcMsCHbCsaq0VCXqOQRdpJ9gGmcJGsnFxmqzBcdIzfVHz4QCnNY/A8O758DH24Lg7t79eM83R7dMY8o8negZ9ZcBXfAQXBZJz83NVQN2eHg4Zs+erRadhx9+GOeee25Nj1TdOMba9wiC22Nl1oijie0Zi6K0IlSUaPWgDRHVJQpFGUUoy7etD6qpUGe0jC7uOdk5iIyKRO9evWvari1PWo4jS44osc5UeD4eVRWFLV9sQeLJiSo9XYdRdmYCBEQFIL5DvDKnCwsNq7U+a1FCfO0RJAxPOOG93F8ydXw+/l4Xgiuu90erVpaj7oIg1A/NXZctW4bHHnsMl1xyibr//fffYwLTVEw6tzCC7mMhDTUyMlKluguCUH/ZdUCAY45QUdHxMm7dfL1BmOreuYsWsa6qQsUxmdEjoRAd4xoot6NHFEU+G7wzmj5iBBwGI5f0rgoN1dqx0UG+iUoNBcHjRDoN21ayJ6IZOnfuXEt86wX21r5HEDyK7du1/qDTpjn9o9jCLW5AHJJWJVn1WrZVi+kRowTt/7d3HuBRlOsXP6mEkEIKJCGE3rsovakgiFgRFcWOhWtXvHa9eu3dv4gN7P3SRIqKSi/Se+8kgRBSIJCQQJL9P2fGDUlIz2yymz0/n3FLdmeHb2dn5nzv+563wp/p5YmOHTsW+bc+9/dB2lVpWH9oPT777DMj3fVBPAgkABt+2YAuV3XB4Q2HsXvObsT/HW/0e2f7toHnDMT7497HyfSTCA8LNybvOCFQHk6mnETixkREdilYuJeRlGHc+vrY8NEz8agV4IvTJxuWmB4vhCiZ9u3bG8K8OIYOHXpWint+Hn/8cWMRQhQN69CZiGKVHy11MrUsa9sLNWcoGQphX1+jLVvKydoICzyFBmFlnOjnbABFOp1brRTpdjiDwdmHjAxzUkAIJ6baRDpny3v27Fnq65o1a1bu9wjhMtDMpGtXs8foueea9x2Mf5i/kcaeuie1xNfZRWlARABqh9TGyVTrTec4EVC3SV0MaDIAM86ZgQ9++ACLf16Mi20XY9NXm7D9++0sYs8jC1mohVrY8MYGNls3SE5ONmrfmVpfXqF+LPYY6kTUQWCU2dKO9fd2kW4vYzuVfgr7F+xHQIv6+PcLQXj+eU4KWjQAQgghhAUwi5tCndnmVsUPSLmr8ugzwYj66dM4mu6Dvm1TUMunjL3P27QBfv/9THN2q2EdAPvTMfgnkS6cHOV6CFGdtGgBsEyDaZ8RxffwtpqwlmGlpoj7+PsUSHt3NP5+/njstsfw6BuP4oT3CfiAJ3ngtOdp1OtXD8uCl+FX/Go4xSetTkJUTpTxPkbWyYSJEwxX+fLCSL29h3zm0UwjWl8Y1q8/eF8uvv0WuOKKSre5F0IIISyFpdzEKq+6Cot0lqz4+iIzIxe+3jbE1Mss+3vtefUMYJw6Bcv5Z/LAEOlCODnV7u4uhNvz1VdmClYpbuZWwjT24EbBSN2bWiaRHhAZAN8AX6OW29F0aN0BjT5qhOk/TcfXC7/GwVMH4bHUA8E5wQhBCHb67ESb023QNaur0cJtN3YbQj0pKcmofS8utb44ck7lIG55nFEDn3HkTBS9MPffkIRte2vhpUcz4OVVntw/IYQQwnpoej53LlsUmotV3RupY+0tocst0nkt4++PxNgMRDXNRGTdcoj0qCgzX//YMdMpnka7jkAiXbgAiqQLUd0w/Sq/QGfqexXAlPeS2pyxFVp+Qps7PppuJygiCDc9cBO+/PBL9D2vL7JzspGMZBzAAaz1XIvg1sHwhS+6ozuGYigaoIHxPprTVQQa48Uvj8eJw8XPrtcLycFPbx5Aq7AkJO9MrvC/TQghhLACprcz6JyQYD4OD7dmXNkdlkKderkifo05fnVw8iTQodHx8kX2eU3yTzTdw1Ep74z0c0ZDCCdHIl0IZ4GpXS+8APTo4Zg0ryIi5QFRAWWKpJOghkHw9qva5Jvo+tH4+NmP8fDIh+EFL5zCKWzP2o7F7RZjjc8ao/86+62fj/NxHs4z3OMrCmvume5eEvY5jeTtydi+LgMDBwJ791b4I4UQQogKw4AzPdAaNjQN3qxKdbfrY+rliiT5JZ4MQGSdE2gaUXx2WrHYRbo9395qmLmYr0WcEM6KRLoQznS2HT8eWLMGmDy5Sj6yfof68K3jWyaR7uHpgfDWFk3TlwNG+++87k6cG3IugmHa1k6ZNgWzs2fje3yPLdhipLu3QivUy7XIMacUaDB39102I81w9Ogq+UghhBDirMsGeqRYJc4r3B89H3SEP5bphw5RyfDzLb9PTF5dOu3lmc/viOxFpiCwZ7oQToxEuhDOAi1ZJ04EfvgBuP76KvlI71reaNir6PZiRT3HOna/uhVrwlreXuaF3/uvu/+FSESihV8LNG3aFNm2bCP9fSZmYju2G69bO3FtkcZvjuDFew+h/7npGPfq8Sr5PCGEECI/DAgze9tKKLLtkfRy16P/M3EQEu6F5uHHzJWVF7ZP8fGBx7FjaHbDDfB4801rBTXd55mLr7p04eRIpAvhTNDpfeTIKjWRoxhv3L+x0QrNXqNu75FeFPXb16/Q59RtWrdSvcbZXo1t1hrVa4TJkycj0icSHvBABjIw03Mmcn1zcWz/Maz/aj2ysxxf118/NAef/icOPkcO4fghU6hXQZWCEEIIYQSZ2Rfd39/awdi/32wlzqzwfF2Qywz1dJ263ggM8jAL2yviwP6PAaz/pk3wXLgQ4GIV/IdxIyXShZMjkS6Es5KZCfzxR5V8FAV5RMcI1O9oCvCSxHTt0Nqo27huuT+DafXhbSuXLk+hPm7cOPj6+uLlsS/j/UfeR58ufXAi9wRmnpppvGb79O2YefdMbJ261TCEq4rU90NrDmH+b5lGR73lyx3+kUIIIdwcakxmbdepY836jh4Fvv8e+OYb83Hr1hVLo6f+Danva7Rhq/DM9aOPIufZZ5FyzTXm47/+gmV4epozHDKPE06ORLoQzgjPll27AkOHmjXqVURwTLCRAl+4Hr0w9drXK7aWvThoOhcUHVThdPnCafO9+/TGRedfhIkvTMS7j72L2JBYTMM0HMVRZKZkYv2X6/HL7b9g+fvLkbrbsU6utlwbnn8uB7GxwOuvO/SjhBBCCCOtnBFvqyLpkyYBP/4IrFplPu7QoWLroS4PrqxIDwgAundH4t13w0ZRTRM5eyN4K+D6//4b2G6WygnhjEikC+GM1K1rniHZT6UKZ3tpDsfWbKWJdArlyHMiS2zhVlxLN5rVled9pcF1De07FLM/nI2Ol3bEOIzDdExHomei0QN975978fvDv2PnrJ1wJO88Go87RhzFZx8r510IIYTj5/JZ8m1VTfqGDeZt377ADTcAl15asfUwSF0n0MsM8Veyljw7IgLo3Nl8MG8eLKNBA7Os8M8/zxTgC+FkSKQL4ax89JFpsco+X1VIcONg1AqqVerraofURljrsDKv196+je+jAV1FKU7gB9YJxDN3PYMf3/4RWc2z8GHuh/gMnyE+IN74+7ov1uFEQvF90CtLndo2PHrzYRzdFI+c0zl5vWaFEEIIq0lONjO3rYBp8wcOmPfvusu0xqlMGr0R3WewwQLDN5v9GogivSJGdCUJdUb7588Hdu+2br1CWIREuhDOSliYuVQxXj5eRk/0shDWMgx16pV+JjeM6HzOFLexNp1p9eWFQj+wYWCJr+nYsiMmvTUJT9/1NFJqp2DCiQnYi71GVP3vcX8bNeSO5FT6KRxafQjffGNDmzbABx849OOEEEK4IYcPW5fqzmAyT43R0aa2rij2dnDscobgYCC78iautp49zX9oYiKwaRMshc3lCfupMqrOiYCUFGs/Q4gKIpEuhCuwaBFw663WziKXkvZeVqK6RhkivCxRdDsU7OWJwtthGj4nBkrDy8sLN116k5ECz1T4GZiB0ziNpI1JmDJmCrZO2YrUPalGLTnJzcnFxo0bsXDBQuOWjytD+pF0LPwtw/i69uyp1KqEEEKIAtA0ncZxNCqv7r7o+WHgnB3ODJFOYW3FpDhX2K+f9QZydho2NG9Z907n1xUrquxaS4iSsLi7ohDCIe4wLA5LSwP69AHuvNOpBpnO8GzflrIrpcwi3W5Sx/eczjhdLpFengh8RFiEYSq3aOAi/PTuT+id1hvZh7KNNm1c/Ov5I/jyYHz181dISk7Ke194WDjuvPNOw02+ooy9Lg7ntQ3BLQ8yLFE+kz0hhBCiODIy/jFoq3jlWAGoT60S6cwgNyL8hlK3CKa8//47sHQpcPfd1veds0fUObA0k2vVqmL954SwEEXShXB2eBZ++WVTnI8YAWeEZnMlRd+LaunG15clKl5gPfkM7crjLt/v3H5467O3kHRZEn7z/A07sRNZyELGkQxs/mwzklnclw8+fu2117Bs6TJUFJbOn985FQcW7kPS9iTk5tiM1HdeAwghhBAV5eRJU6QzyGxFt9ddu8z77dpVXqQzum9sF4va2fO8og7v+WE/OObi8wMo1B0FxT9P3uyqY8V2C1EJJNKFcAXuuw/49FMgJATOCKPbJZnBFRVJJ0ExQaU6yRcn9uu3N3u6lxW/Wn544M4H8Oy4Z7Gjww7DBT4DGQhFKFqhVYHX2mCm6E2YOKHSqe9MqU/ekYxH7kzD/fcDl1yiTDohhBCVE+lMebfC2Z2BY9aSs5lM/fKdVs+CupY17Ya/KwMMFOrsE1dZuMILLzTvT58OTJlifX16/vT3ffvk/CqqHYl0IVw1Bd7JCG0RWmwqur39WlFO7REdI8r8GfkFfe2w2kbf9fLSPKY5vn75a9xy9S34Db8Zz52Lc3EJLsEADEA/9ENf9EUv9EJQUhA2bbbmQqBH62OoG5SLm26yzpFXCCGEe4p0YkU30/Xrz6S6V3Z9BVLwme5OxW5V+tgFF5gbuH8/8NVXwHPPmX3orIbRf/ZRX7v2zEALUQ3oUlEIV4JOMeyPwpw0R5ycKgGj3DG9Y4oU6sVF0kmd+nUQ2jy0bJ9RKOper329Aq7xZYWTA52bdEY60rEO64zn6qIuohGNGMSgERqhCZqgJ3ri4OKDsIKu7U5i9vg9uKxnYp7DvION5oUQQtRArNKOPActWWLe79at8uuj3xr1bR5RUdaJdIb6H3rIjKjXq2c6x7N9miNgjfqhQ8COHY5ZvxBlQCJdCFeCuW0LFwIHDwIzZ8LZ8A3wRUyfGAREBJRak56f8Dbh8KvrV6qwLhyR54RA/Q4Vy88LCQ2BF7ywBVvwLb7FD/gBP+Nn/IJf8Dt+xw6YJ+e0uWlIi0szDO6O7j+KuL/jDPf2ihAanGO4ynMdJ47lGNca339foVUJIYRwU+gja0WqO7uPUIvS7M0KkU4KeLqxRM/K2WhG0ynU7f48f/zhmNlu9pFjFgBr0zkRwJkMC3q+C1Ee5O4uhCtBR5YvvzRzyvr3hzNCQ7fo7tHISMpA7LLYUiPpdhO5hj0a4sCSAzh1omizFq6DQr0w7OmeFp+G9MTyCef27dobLu40ifOEJ3KRi0M4hCM4Ytz/G39jtMdoNDzVELPvmV3gvX6hfrj43YvhF1JwYiE7MxtpsWmo26wuPL2KnwPl2Hz6ZCrmzw/Hhg3A0KFOazcghBDCCSveKKwriz2Kft55lTdjZ107T9EF1sPcd84msICeaeRWweufzz4DYmPNaDeN5ayGBfoMiLAegNsfGgq0bWv95whRDIqkC+Fq9OzptAI9P/7h/giIDDAEONu0lQZfE9Mrptioe0kGcxGdIkoUxUXB17PNGvH4579gBKMpmhq3NI/7yfYTTnicKLANvoG+yEzJxNK3liLreBYOrT2ETT9swrxn52HqDVMxZ+wcLHt7GTZs2FBi3/UbhiTjzhEp+P6LLAl0IYQQZU4pZyS9ss7uDEAvXmze79u38pV4qanmNhWIpNvN46xua8J19u5t3v/zTzgEmsfQRI6t2DjzwGbynIkQoopQJF0IV4Z16QsWAFdcAWckrFUYTh0vexsTRsvD24bj0JpD5RLpFPY0rmOrs/LAPuhPPPEEJkyYkNcnnSnw7cPbY+AlAzF16VS8t+s9+MIXzRo3w1P3PIXmAc3xx9g/kLgxEdNGTStyvbGLY7Fh8QZswqZi+67z/D/25iPw8knBqRONjFIB9qrlZL29ZasQQghRuB6dmdcVjXxTULNZTEoKkJBgRuQZSa8oNG9nynxQkFk2Tv2cBx9QqPPDrGrqbueii8xUdJYAjh5tZho6iogIIC7OjNw3aeK4zxEiHxLpQrgqPLuecw6QlGS6kHboAGfDL9gPwY3Ld2KmY3vKrhRkpWWVySHeDkX6sdhjRu14eaBw7tGjBzZv2YzUlFSjVp2p8Iy0j7xqJCbNmYR3v3kXm/Zvwg2P34CrB12NUaNHYcOHG9irDXUi6hg19WGtw5BgS8DPE35Gd3RHJ3QyjOn2Ym9e33VOCOQX6iTndA7ilsehVosYDB3qY0RJfv+98v1qhRBC1Nwe6SyZrgizZxf0W2NyXmX0LYPkYWHA1Vebgv+sNHy7wLUa2tFzRpvXQuydbm/R5gjsaQtbtwKNG1tjqy9EKSjdXQhXhScnnl2bN7c+lcxCQpqWv9iaorcwpfVTZ1p9RU3kKMg7duyI/gP6G7f21HkvLy+MHDoSv370qyHOyZQ/p+C2r24Drgcu+/wyXDbhMvQa2wsthrbAl1O/xC7swjZsM17LNm4t0bLUvuucWNgx/yD8auUaF0s0xBVCCCGKi6RXpMSbKe7z5pn3L7sMGDsWGDOm8ttDkU5X9yLr5PlHpomzdvzAAVgG09EGDTpjIOdoWKPO/unMChCiCpBIF8KVmTjRNDXp3h3OCsVzeaE7fGCDwHKJdPv76japYHihBEKDQ/HyAy/j+9e/R5umbXDsxDE8//3zuOWVW7Bx50bjNYzE21Pm12ANtmO7cb8buqEd2hlCPSkpyXhdUTQIzcT3L+3BpC+Oq0ZdCCFEsaKYYpsG5OVl+3YgPt4MDI8aBQwYUKhlWgXIzDT1a7Ew8nzxxUCfPubsgpV13YyeM6rNenGavDmSwECzVsDRnyPEP0ikC+HKcIa6su4xTkpU16gCUfiyiHRSv3191ApyzJh0bdsVk9+ZjKfvehoB/gHYtGsTrn30Wjz7wbM4EFcwQrAaq7ERpoDvgi7ojM7GfabUF0dA7RzUTj2II1uP5KUlDh8OHD/ukH+OEEIIN+qRbo+i9+pVyOCtkrAevVg4C8ByPC52oWsVLIJn2Z8jDeTyw0Hbtcsxbd+EKIREuhA1AZ4wJk0Cnn0WNQW2W2P6evOLmqPZoGal9lrPe5+nBxqc1wBePhUIM5QBby9v3HTpTfjto99wxQVXwGazGXXrz33xHFKRmpfaTijSGVUn7dEeHdDBqHkvDdbk71mWgNtus2HaNOCddxzyTxFCCOFi0KitIiXR7CK2aNGZduNWkJ1tRvSpvUuFYp2i2upZZxrIkblzzQ1yJOyVyhp4WtkL4WAk0oWoCbDZ9rXXAi+9BKxYgZoEHd/LKtDz92qPOjeqyL7qVhEeEo7XH34d3732Hdo2bYv0zHSjx/p+7EcGzngEsD59JVYa92kmF5BYttzC00nH8PkbSbj2WhuefNJh/wwhhBAuMA9Pf9hZs8yy6Iok0K1aZQaxmYDXqZN1UX26zJdJpJOYGHOWwUpY7md3kF++HA6FEw1KeRdVhES6EDWBzp2Bu+4CnnsO6NixurfGKahTrw7qta/n8M85t925Rgr88/96HnX86uAUTiEOcTiIgzgN02meZnJbsMW4v3L8SsT9XTan2xahKfi/Jw/nmfHwQm3KFLVqFUIId4K15Ow0tnevGcStV4FTmz2K3q9fxerZixPpzAAvc107I+k0fLOyLp0OekOGmPd//RUOhRP//Afv3q2Ud+FwJNKFqCl8/DHwwgsVb55aA2FNe0Xc5cuL3QX+r8/+woVdzTYwJ3AC+7APyUhGSFgILn78YsT0jUFudi6WvLYEe/7YU6Z1s61c4ubEvK94xAjg8sttRqs2IYQQNRtmVy9ebLZJowdbo0blP81TTNuT7Pr3t27b7M7u1N1lwm4Db2VdOqFI50Ywq5C9zB0Jo/aJiU7dVUfUDCTShagpFE7tpouqMKLpderXKcPweSCsZVilRqxuYF18+PyHmPrOVLRt0taoT6dIj/OOw0mvk+j5SE80HdgUtlwbVoxbga1Ttho17aWRuicViZsSjWuD2rVt6NQwBSeTLE4ZFEII4VTQOZ0CnWXcDRpUfD0U6Oytzvae7NpqFbzMKFdUn3nxFOpW16VzI847z7z/yitmVuFKs8zMcjhDwtkJqycahCiERLoQNQ32Ib3iCuCWW6p7S5wCiu/IzpGlGsn5Bvoa/dnZxq2ytGvRDlP/byreGvsWIsIiEHc4Dve+ci/ufvFuhA8PR5vhbYzXrf9qPdZ9sa5sQn1vKvo3j8PM8ftwy7AkxK+Mx/FDx5ESfxLpSRmG8BdCCFFzYB06U9wZQa8M+VPdrbZqKdHZvSiYCuCIKDQbvxP2mFu3DvjoI8fUhrH+jC58arsiHIxEuhA1jeRkYOZMYOpUYE/ZUqprOjSfC2tdcpS8dqiZPxh5TmS5jeqKmxy4dMClmP3hbNw14i74ePtg8drFuOKBKzDHNgdtR7U1Xrf95+3Y/GPRvdMLk56YjujwU8ZFFkX5geUHMeySXNx43WlsnL4bCesScCr9VKW3XQghRPWyfz+wZg0QGWmWXZcX6sgXXwTuuMM0jbM61Z3rL7Oze374D+IbGdq32puHUfSxY82NSkoyxbqjUCRdOBiJdCFqGuwZOn68eXJq1qy6t8ZpqNukLvzq+pUq0hlxj+4eDU8vaw6PdWrXwSM3P4KZH8zE+d3OR3ZONj6f9jnum30fvC/wNl6z6YdN2D1nd7nXvXZrbazY5I85SwNxKNHTqF/fN28fkrYnWbLtQgghqh4KYAprdhSrW7di66DAZ8Y3y6fpYdKmjRnEtlKjsry83NtHkU4DObqxWw17sQ8YcKbH3O+/wyF4eztm+4XIh0S6EDWRMWOAdu2qeyucCka2G/ZsiIDIotPZa4ecceKpFVQLUV2jKvQ5/mH+RT7fuEFjfPzsx/jkuU+M+0dSj+CZec9ge9j2PNf37dO3lyn13U63Difx+X9j8coDh9Ckgekkz/cn70hG0jYJdSGEcEV27TJbrTVsWPF1LFli3l54IfD222ZU3UqY7V2/vml2Xi6YFsDC+GPH4DDsvdM5S+GInuZ08WOkXggHIpEuRE3n4EGzRkuYUfJu0UakPKJjRJ6g9q7lDR//gvmEFPMhzcrvDB/SPARhrYpPrR9w3gDMGDcDj97yKPxr++OH5B/MPursg/vZWqz5dA1yc8pu3d6z00lc3PeMgc2eOF88+0EEDmxIQcL6BMNNXgghhGtE0BmhZhSc4tfefrMi67G7udP4vGXLivVWLwl6p7HteYXg7AOj0VanvNthEX/r1mZN+ty5jjGP4ywFnf2EcBAS6ULUZCZNMk9UDzxQ3VviVNAcjunvjJZ7envCL6ToNPh6beuhVmD5rmz8gv0Q3rpkAzpfH1/ccfUd+PXDX3H5+ZdjFmZhDuYYf9s5aycWvrQQp0+akfHywJTGR9+OwqQ5dfHqxPo4duAY9s3fh/QjcoIXQghnZts24LvvzNM259bpxF4Zwzl6s9FInZcAVsM0fJaVc/0Vwp7yzlz89HTHGLwNHmze/vGH9T3NKdIp0GUeJxyIRLoQNZm2bc3pbp7xeSIUZxnK0dHdXo9eGA9PD1PIl7E+3cvXy1gn4fso2EuCzu9vPPIGvn/texxrcQw/4SecxmkkrE7Azw/8jPRytlljm9in70xE+xaZeGCUmYpHsR/3d5xhKqeouhBCOB8UvRs3AkePmsfxpk1NEVzZVPfevcvRw7wcMNpv76ZWIZjy3qKFeZ/p6Mztt5q+fU0xzeufzWUzZy0zTEugSJd5nHAgEulC1GRoorJsmXnGrlN6r3B3hBH1oOjie8iwPr2sRnL5RTkj9HxfWZziu7briklvTcLND96M6UHTcQInkHM4B5PumoS1i9aW418DnNvuJCa/vR/1Q89EJuYur4MDW48jdlksck47IGIhhBCiwsTGAnFxZvp4aGjlUtPzp7r36eOYL4UBZAbCK3VZwb7mN9wAnH++mQZmdTSdAp0958gcM1PNMux97BRJFw5EIl2Imk63bo6ZSq9BhnL26Hdx+If7I7pHtCG8S6JWcMErK643pncMfOuUXljo6emJqwZeha8mfIWTw07iCI7AL9sP695ch5defQmLly3GwgULsXHjxlJr1vP3wV23zQ8PvBaNKx5ogri9ZlQ959SZi6HMY5mIXxGPXb/vQsouudUKIURVwkzsLVvM43ZFa9Dzw8YuTJyj2KejuyNgKn2F69HtsCY9OBho0sS0iGcagdWwIJ8sXWp91JvXVY40vxNuT8lXpkKImgNnqSdOBK68EoiIqO6tcTloMteoTyPELY9DdmZ2sVH3wtCQrlHfRkYUOystq0wt2+6/+37sG7wPfzzzBwKPByJiWQQeW/YYPOGJEISgXlg93HnnnejVu1ep6/P2tiE64jTaN89EWN0cZB7NQezSWCACOJlyEodWHcpLgz+y9Yjxb2N2gU8dH2MCQwghhOM4fNjM9rbqtOyoVHcGu7dvN7U1I+iMpFsW8aZQX7++EvnzxcCUeq6bA3zPPWbPON4yy9AKh/eEBGDTJjP1gWZ1VsyyCPEPCq8J4S6MHm22ZnvyyereEpeFIpyCm7XnRVFcDTpf37BHQ8NFvqw0adoEbUe3RQpSEIhA3Ipb4QMf7MM+7E/ej1dfexXLli4rdT0dWmRh6rv78MI9h/Mi7Olp2di3zxfxK+PPqlNP3ZuKvfP2Ytdvu3B4w2GcOuEg910hhBBGqjutY6gfKwtT3ZcvPyPSrYSBbkbnOc9/2WWVaw93FmzgzpQCq1PeedLjxtr/AawpoDufFTD6v3+/2Yt9xgzg55/NWQwaDAhhARLpQrgLFOg8w7IOTFQY1phHdo4863nWrDP6XBxMfW9wXgPDjK4sMKX9828+x3zMxzEcQxCCcDtuRxd0QQISEIc4vPfxe2Vq11antg2Bdc687t2v6+Gaa1pg2p+BxX9+di6O7j+KfQv24fih42XaZiGEEGWHmpQ90WnCZgUMRjPVPSTE9I21kpQUoFkzc6FAr4yx3Vk0aGCmvjsi5X3QIGD8eLNRPFMLaCLHmZHKwlkVWue3amVG648cAWbNAn75xYyus4bh0CEr/gXCTZFIF8Jd6NkTOHDATPUSlYI91Os2rntWlL209HC6yLNPe2m17WTzls1ISk5CJjKN9mwHcdCIpA/DMDyIB9EQDbH+6Ho89OpDSDlW9lry7Bxg535fZGZ6IjigdIFvy7Xh0OpDRoRdCCGEdbADGbUd58+tTHXv1ctaEc0IPQPddJ13CGwKT6HLmQCr4XmZBfSdO58JUjD6bSV0q2c2AJf4eHP9s2eb0fXVqxVdFxVCIl0Id0IO75ZRv2P9vDZrderXQWiLsl1l8bWsbS/N9T015YwoZlu2BViA1ViNDGQYUfXrcB1aoAXmrJiDIWOG4MvpX+LU6dJT0729gE+fj8Onn+7FBd3PGOkcO1H86cBmsyFxUyIOLD6AzKOZZfp3CiGEKBnquVOnzPJmK4T033+f6T5mJcnJQL16QHQ0HEfLlmakO6t075YKc/HF5u3cuY75HNamc7KB0XVG2VlvP2+eKdodMQEhajQS6UK4I2vWmIVlciatMIyas3Vb4/6NjXpzRtfLCqPujQc0RlDD4lu/hYSGFHhsgw3bsR2/4Bfsx354wQsjMRJDg4YiOz0br332Gi5/4HL89fdfhqguCV4H9ep1pgd7+kkPXP1wYzz+biSOpxd/WjiZetIQ6knbkowIuxBCCOdIdd+wwUx1Z6m01anuzEKn7nSoLxpnALjQSc9RnHOOOdtAp/fFi+FwaIRH0b51q1m3TsG+YAGwbZs5OyNECUikC+Fu0KL15puB6dPNGi1RLXj5eCHqnCiEtSzazbZ9u/YIDwuHBwqm0OciF0ux1KhJ94Y3eqT1wONej+MGnxvgGe+J+165D7c8cws27dpU5m1Zuq4O4hN9sHKTf4H2bUXBCYDkncmGWD+VrosMIYQoD2lpwF9/mcFVpruzftyZU93ZCpxJeNSaDoUb3a6d6aJntYFc/s8YOtS8P22aeT3kaBhd5wwHI/ecSVm7Fpg5E5gyBdixo2q2QbgkEulCuBsMo77zDnD99cBDD1X31rg94W3Ci4zC04iObdZIYaFOlmAJQi4KQd2mdYEcoNXpVrgZN2MsxiJkYwhGPTIKj73zGA4dKd245qJeJ/Ddawfw5thDCPA/c8Fw6nTx72F/9f0L98tUTgghysHBg6ZO27PHzIbmUlloKG53de/Tx9qvg4Ht5s2B+vXheDgTwAJ9R6aGM+Wdg06PnlWrUCVw9jsqynTd42DyNjXVNJr780+lwosikUgXwh0ZPBj4/nuLe6iIisKIekDE2UKdfdCfeOIJhBXqHRsWHobHnngMQ+4fgiHvDcHgdwajxSUt4BvgiwAEoBd64SbchDnz5+Dif12Md795FycyztSfF0XXtpk4t93JvMeLVvtj2L1NsWJT7RId4A+uOojUPTKVE0KIsopeBnTZVjvy7EYhFYIBWka8aZDevr113wOD2pzXZ/p8aVlWlsCQPaPpLIJ3FHRlt0fTJ082HfGqGhrN0cyOrvb88qZONQ3mOHPDnu5KhRf0ENIoCCGMaXhvHQ6qC7q9R3ePxvGDx422Z1nHspBzOidPqPfo0cNwe6eZHGvVmQrPSLu9Np6mdVzOGX2O4cS+YtwKNDzeEGP8xmBq5lR8MukTTJ4zGfffcD9GDB6R50K/dMlSBAUGFVgf4TXLR/8LQ2yCL/5YFojuHc6I96JI3JyI0xmnUa9dvTK3mBNCCHeDWdzs/mVVHXpCgqnxHJXqzvVzMqFK5/NpIMdecqwLcBSXX262SmNtOFulWTmzUV5Xe6bCJyWZZnacEeH5mQPetatpp29przvhSuiqXAh3hidB1qUz3WrFCnN2V1QbgQ0CjYVkJGUYEeoTh08YArpjx45lqnNv2LMh6kTUwbxn5qHu8bpGb/U0rzSsOrYK73z0Dj7936cI9wjHt3O/xfvj3sfJ9JNG7TtT6zkhQHiN8Ol/4jFhSijGXHsmosHSOV5DFAVbtNH5PaxVGLIzs+Eb6IvaIRbkcQohRA2BWdz0aw0Pr/y6OJn6wgumQ7wdK1PdMzLMY36HDsUf9x0CM8datDB7jTsKptQPHGgaA7A2vLpEuv2ESzM7LnabftZE0GiO48AvgPb/dO0rlFUnajZKdxfCneEZ+MsvgXXrTCMT4TT4h/sb0fW6TQr2Yy8LIU1DMOiNQWg6qCm8a3sjKCcIF+JCPIAHEJAcgA1JGwxRfjLHjJAnJyfjtddew7Kly/LWwdr0h29KQu1aZ1IBH383Cq9+Vg8ZmR7Fur/HLY9DwvoExC6NxYmEklPshRDCnWDAlCnkDKBWFjrDU6BTu3XvDlx9NVCGudwyExcHtGljlk9XOfxge9CA7nrM9rOaq64yZx9Yl753L5wG/rvt6Qu7d5sGdz/9BEyaZKZM0MJfuAUS6UK4M+zVMn68aV7ClmzC6ajfoX652rvZYXu4Hg/0wJVfXYkeD/cwItx0g2d/9Y7oiBXLV2BH5g4kIAGnYLq0T5g4Abk5RTvNbtldCzMWBOGbGSHYG196Hx62aGO9+sHVBw03+KzjDux9K4QQLlSPbgWLFpm3PXoAzzwD3HJL5SPeLIVmpJ+BXJZuM+O6SqPodmiyxtp0e6SZsxtWw3rw3r3N+6wJdzYYPbebzFG0c2Zn6VLg55+BnTvlCu8GSKQL4e5cey1wySVV5Aojygvrxxuc2wCRnSPh41/+cgRvP280vaApIm6MwD7sM/qrX42r8WStJzEMwxCOcBzAARzBESQmJRq170XRrnkWJvwnFmNvOYL2zc8I7pI8d9iujXX27Ku+b/4+xK+IR1aaxLoQwv1gMJj16EFBlV8Xj7v2Nt9WprgzoJyZaU4kUKBXiaN7UXBmoF8/8z6FKvuaOwKmH9hnPMaMAZ5+2nTgcyb4ZdAziL36WK/PpvUMrLDfOtu6iRqLatKFEGfg2ZknKHttlHAKaMYW3CgYgdGBiF8ej4zkjHKv4+ixo1iGZTiJk2iBFvDN8kW3f/5jJD0WsViHdfhl/i9o164dvIoI9/Q7N8NY7CSleuG2Z2PwwKgko41babC+Pj0xHUExQUaGQH6zOiGEqMlQW9EGxorT6/btZnCZncTOPdeKrTM7gtHQ7tJLTZd4BnKdAtaPO6qXOCcAWCtATx6mD3CZPh248UY4JTwvN2pkTlowTZ+1E8wGYM0Dv7BqSXsQjkLfphDCZOFCs8/K3XdrRJwUilrWqdcOLb8hG13hbbBhLdZitv9s9PmwD/Z67zVEuy980RzNjQj7vj/24coHrsS8lfOMSHhJ0Fhu54Fa+OinMMO1uCxwnccOHEPcsrg8B3tR88nNzcXUqVPx0ksv4bPPPsMx5tSWwr59+zBx4kS88cYbmDVrVqn7oxDODEuJGfisVavy67JH0akvrVifvfSbpeBsC0fx7zTJdSzLoziloZoj+Pe/gTfeAO64w3zMKLWz132zFoHO7zTXY636d98Bs2c7/3aLciGRLoQwod0sc/E4o+zIHqXCknZttQLLd2XGNmt0cfeAB3I9chHZLxLraq3DNEzDLMzCNmwzXjcQA9Ejtge+e/E7PPTAQ1izfk2x63zk5iTcNSIZL92fkFdnSR1VFi1Fkzmay51KN+vhRc0lJycHQ4cOxdixY5GSkmII786dOyM+vy11IZ577jkMHjwYf//9N5KSknDfffehd+/eyKDltBAuCHddHhsrG+xkUNnecs2qVHdG+NminPP0TgdFOkWpowQoZzk4O8EUAvYu5+f8+iucHm4327exVp1RdLaS++sv50vXFxVGIl0IYUKTFqZ5MY9ObT6cGrZai+4RbdSblycKT0d3QqGenzSkGRH2kAtDjMdMhx+EQei1vxe2PbsN7971LvbE7jlrnbV8bYZQZ726nSl/BOP25xpi38HS6+dZn75/wX6jfZuouXz99ddYtGiRsbzzzjtYsGABgoOD8TTrP4uBon7Lli15kfSVK1di69at+Pjjj6t024WwCqvml9jam/Po1GasG7eCI0fMzO9qq0EvCYb1WY/tqLp0O5w9GTHCvM9rIVeo9+bsOE0OOJHBdm3cOVhf7wg3fFHlSKQLIc4wbJg5nS6cHp/aPkZP9PIIdfZBf+KJJxDKGr98hIWHGc8PeWgIhvzfEHS5vQvqdauHU36n4AlPRCVE4et7v8Z/3/svjqQeOWu9dITfuHEj5s5djHe+DsKy9XUwb0XZHOn53sRNiYYTfG62g+oORbXCNPdBgwahIVsKgeWTvrjxxhsxbdq0YlPYe/XqBW+aJf1DeHg4mjZtiv3791fZdgthJaz5tncVsyLVna7uLEW2ApYrMc3daaETO+uvHQ3N6jhTwXKcP/+ES8GdiynwjKhv3FjdWyMsQMZxQoiimT8fOO88M81MOCVMeW/crzHi/o4rc4szCvXuPbsjF7l44P4HEBQYZKTC203c2GOdS5sr2xiPl09fjt2f70YbWxtgLjBp3iT4N/JH1wFdEdowFHsS9+DLaV8iKdlskROEH+DrNwYtw5ma2NN47tRpwLeUi9Pjh47j1IlTRoYAJyBEzWH79u24lKmk+WjZsiXS0tKQkJCAKLZbKoVNmzZhw4YNePLJJ4t9TVZWlrHY4frt6fZcRMnYx0hj5ZhxpO5j9Lsytd5c5dKlPFZ7oF+/HEvqxpk+z/kwnuqd6WdSYBwZSWek29GF8j4+8Bg+HJ4ffwzb1KnIvfhic3BcBWYdsHRx9WpzvLy9kfPP7It+185zbCzrelxozxNCVBkPPgi8/z7w7LPAf/+rgXdiGElv1LcREtYnGO3OygIFOUV67z694WEr+aKnxxU90LR5Uyx6bxFOJ55GqC0U2A9s+XpL3muaoAmSkWwY0/kiFrUyn8GbbwBenk+gZ69euOP5GETXP43HbktESFDx0XJONMQuiTUyBHwDLAoRiWonPT0dQYX6TjHd3f630khNTcU111yDgQMHYoQ9HbUIXn31VbzwwgtFThIEaLKxzOzYsaPsLxZlHsfWrSs/WKtW+SMlpRkCA3Nw5ZXb4ONjjZkiW3EzHX/rVjjvOA4aVCWf5zF6NFpNmgSfI0dwaPNmHL3iCrgUTZqcuc9MpUOHjLv6XVceq8bwRBlLNyTShRBn078/MH581aSXCUvM5NhLPTU0FUe2HIEt11oXbLZLu3ri1chMy8Sfv/yJRb8ugt9xPwQhCA3QAK3QCoEINNq4pSMdSUhCNrIxYeIE1Ao+Hys31cYGHz/cOzKpRJFOTp88jQOLDyCySyQCIpXFUROgQC7s5n6U/aj++VtJ8H1DhgwxRP3kyZPhWYLrFqPsjzzySIFIekxMDFq3bn3WJIEoOrrDi9BWrVoV2YJRVHwcmdQxebJZPlyRirI///TAF194GF1SSffuHoiPN7OdrEjDZ2Dv2mutc4q3fBy5gXQxZ9ifkWIH43HZZcCXXyL6zTcRPXkybK1bwzZqlBNZ3pcRZhHt348dF16IVtHR8NJx0CmOjfYsr9KQSBdCnM3w4aaBHJ1khMvANHW/un5GfXd2pvXGMX5Bfrj0xksxZOQQvP/l+/j8l8/REi2N1m1R//xHGKU/giNYnrQcPrmr8P3rHjhwyBcNI85sU9oJTwQFFC3Y2ZotfmU8QpuHol47C5oKi2qlTZs2Z0Ug+Lhu3bqILKEQlhcyFOgeHh74/fffSxXatWrVMpbC8KJKorPsaLysH0eKa0aq6cla3k6C9AD75htT6BPqxIsu8iz3eoqDySzs3c5UfKcdRxbfN25spnFXhbEt09ynTIEHJxfXrYPHunVAx45Ap05wKTipyb7qHMeZM+HF7W/Z0nm/bDc5NnqVcR0yjhNCnA2vAiTQXZLaIbUR0zsGXr6Oi4T5ePugW8tuaIqmhhj/HJ9jOZZjK7YiFamG2VwEIjAYg400/HPaZOKKC87MHO+N98H5o5vj7a/CkV1CaVbK7hQcXH3Q8swAUbVcffXV+Ouvv4y+5yQzMxPffPON8bydzZs345lnnsmLMBw/ftwQ6DSWmzNnTl56vBCuCIUw23xXxDju77+BlBTTwPvDD9ktwWzGYhVMmKNId3rYHo1UReE8ReybbwLMzOlpeqsYqRCuiL2mnjvgnDnATz8By5aZPdY3bzZ3LuGUKJIuhCiZhAQzzez++zVSLoJvHV807NEQsctiHeaYHhIaYojxMIQZqe3LsAxHYaYwhyAE1+E6RCISyf9LxowFM4z0dS712tfDjAVhyDjpie37auEfv7piYZ19TlYOGnRrYLSeE67HqFGjjFT1fv364fLLLzd6n1Oov/TSS3mvYXu1l19+GWPGjDEi5rfccgtWrFiBe+65B2/yYvkfOnTogJEjR1bTv0SIisEoekUzpWfNMm+HDAH+aZBgKcwgpy+b08OsG85UsFSmKqLpdJTnwh7qK1YYEXXs2mW2OnNF6FrPzi4U5UuXnvnymaHEf1PnzlVSSiBcRKQnJycbPU+XLl1qtFrp27cv7r33XviXkoaxcOFCjB8/HocPH0bHjh3x1FNPlckdVghRTo4fN6fsWbTG24EDNYQuAtPemwxogiNbj5TZUK480BE+PCzcOI57wxv1UR91UdcwkGM0/TN8hmEYhs4enZF+OB27f99tLKRRaG2M7d4TA2+OyrtwzTrlgfhEHzRreOqsz8pIzkDs0lhj4qE8LeeEc8DUvunTp+PXX381IuZsr3bVVVehTr7iXIrvF198MS9iTjf4rkU0gfaxooeVEFUMfaIqItL37jWDncxaZga21VCjkcBAOD/UBkx5Z3uxqhDp+ScH2JptwQIzmv7EE3BZmGbNtAl76gRrJpi9tHYtsGcP0KWLaZrA4ywN6HS8rVa8q7MI/7zzzjN6pVKYZ2Rk4D//+Q9++eUXzJs3r0B/1Pzwb4MHD8bjjz+Om2++GePGjUOfPn2wfv16BLrEUUYIF4K/qRtvNGeRZTjicvj4+xiGcrldcuHh6YG0uDQkrEvI+zsj07mnKhZpp0P8nXfeiddeew0e8PjH2d3XqEsPRaiRBv8zfsZs22y09G6JoU2GIjIzEifiTiAz5SQCV8zD7rQwRPy7N+rUq4PPp4Vg/I/heOjGJNxx9dnpd1lpWYahHFu0sfWccC1YV37JJZcYS3F160x3t3P77bdX4dYJ4Vg4z10RU7ZffzVvmXHtCF3KWnk/PxcR6YT11Yxoc0ApOKvquoSlORTpTBOPi3NMSkN1wJkjToxyHJOSGAU98zwt/9mGNzra9Qzzagje1Tmzzr6n+WfS6ZrXuXNnI8Wtd+/eRb6PJ3HWsdnT5C644AIjiv7pp59i7NixVbb9QrgNb7xhXl3oIO2y2HugB8cEI/d0Lo4nHEca0tCwd0MkrEzAqfSzo9dl7bn+xBNPYMKECXl90kl0eDSev+N5eAZ64p2v38H67euxeddmBNUJwuiRozGwwUCs/2Q9krclY8boGQhqFIzlp69Cdo4H6tf9x764GOd3tmhrcF4D+IfL+EYI4fwwWFkRkc4UeepCUszcliX16AxQu4xIZ/o5RSOL/Jm2zVQApsA7GkaVu3UDVq4Epk2reeV/vL7LH2E/dQqghwgnJFq1MlPhIyKqeyvdjmrNG8wv0PO3YjnFnaMIGG1nLRtr1OwwNX7QoEH4888/JdKFcAScZhc1hpBmIQhqHIS0rWnw9fc1eqzTDZ4p5RUV6j169MDmLZuRmpJq1KozFd4+MfDjGz9i3op5ePfbd7Fz/068++O7+KbuN/jXZf9CvbX1kLI9BWkHjuFifIm2aASvyUeR1rovghoGYdOuWvDztaFFo1MFnN/jlscholOEMekghBDODA3C7RHr8jB/vimiGbSlsbiVMMOZdjO83GbJNc3TXQLqBka1Kc4Z1abbe1WIdDJihCnS580Drr++Ztdvc4egeTDrNGgwd+AAcP75rluP76I4VXEfTWMYFe/evXuRf4+NjUVubi4acCYtH3xM59jiyMrKMhY7dvdYptxzESVjHyONlZuPY3Y2PL76ykgxs916a7VthsuPoxOQfwyZ1RTVLcqoXT92oGAv67Li4e2BDp06FHiO6e/mH4ELel6A/t36Y/ai2Rj33TjEJsTixR9fRHT9aNx7973oGtwVSVuS4LckDsfjM/HHo3+g0eDmeGL+YCSkBWPsqBW45eqgPOFPx+9D6w8h60QWwlpVYW2iA/dF7c9C1AzsrdHi402RvWqVGfRl56vyrMOe6s5adKsT2Q4fBtq3N73EqrK82xLsddKcXWDBPoXkP0E+h9K2rTlo/Mzp04HRo1Hj4bhyx2VEnc7w3JGZEsL0+KZNq3vrajxOI9Lff/99oyULjWWKM447zfYB//RCzU/t2rXz/lYUr776Kl544YWznt++fXte9F6UTuE+t8K9xjF49mzEPP44soODsaNtW+RWc426q46jM1FgDKl/mzj284Y2H4pBowZh6tSp+OSTTxCfGI+nPnkKLVq0wH333YcLx16I5WOXI3lNMjb+vA8BOAw/Lz8MvNwbuc3Zfb1g/XxiTiIStyaiurFiXzzBC00hhEvDLGwGd2mizaxoXprWrm1mDJenvfK2bcD+/WZA88ILrd1GBqE5CcBAaXkmDpwOpl/zH7F1a9VFeBlNp0j/7Tfgmmvcx6uH6RxHjgCLFpmPuWOyLJlGcxb0DRdOLNJZT/7vf/8b//vf/zCwBPfoUB712Du3UE8/uguHlTAV+OSTT+IR9jrMF0mPiYlB69atjVYvovQIDy9C6RnAqJtw03Fs2RK2GTPgedVVaM0Dc0VccCzA5cfRCShpDBlRP7rPbKXmCOgEP6rHKAzvPBzfzfoOEydPxK5du/DQQw+hU6tOuLjrxdi6aSvCcsNwdXYasnJCMf+aZKzyW4UjXkfQottnuPLiMJzb/mSB3vBRXaMc2hve0fuiPcNLCOGa0Hdr7lwzgn7RRabvFsVwRaLg1ICEpuJWx5LsgWdG0V0aDiy7znCSlLMjhUpoHQI7TvCLpRP6zJnADTfAbchfs04dxnoMCnfWYtg7bLENgag5In3ixIm4//778cMPP+DKK68s8bVMa4+MjMTKlSuN9ix2li9fbvRfLQ5G3gtH3wkvqnSRX3Y0Xm4+jtzmhQsNl2ZnwGXH0YkoagwjO0TC188XSduSjLRyR+Ffyx93Dr8T1w2+Dp///Dm+/uVrbNixwVj84W/0X+d//dAPgQhDr8xeWIAMTJ7fFVMW2PDbR3vRuIGZQZWZkom4pXFGizbfAF+X3Be1LwvhelDwcmHN+eLFQGKiGdwlFT1Vcr6O6yJDh8IhNfLUVDUiRsUIL9PeN2wAWrd2/OfxS2UE/fXXgRkzAOqWUtpG10gYNKXJwpYtwO7dZ2aSmALPiQxlKVtCtU55fP7550b7NQr04cOHF5uqPmrUqAJtWSjs4zlVCWDKlCnYsmWL2rUIURU4iUAXjiW0RSiiu0fDu5bj53GDAoLw0I0PYc4nczC011CjnVsGMhCLWOzETszCLOzCLnjCE91QH62xAP077csT6IRzCaczThst2tKPpDt8m4UQgubXTGn/3/+An382I+kU6JWdO6bFEtPkGbB1RDo66+SppWrE6ZyRW4pCzjgkJ1fNZ7Ifnt1h/v33gR9+MM3VHDip7ZRwcoI7KAU7fVmys4G//zZ/DBTvxZiACxcQ6UePHjV67NLh/Y033kDPnj3zFvZKt7N7926jB7qd5557zuiLzhpGphjedNNN+OCDD9CNrRGEEFUDi+6Yz8fZa1EjqVO/Dppc0MRwWa8KwkPCcVXvq9AETRAE8zPTkY492IPpmI4lWILaOI7rMR8X7v8uz+Qu7YQnhj/UGL/MC8LprBzEL49H6t7UKtlmIYR7Qg1CYzdGpRnMZftuCvTKZvuyXvz3389E0a0W0tRN3t41INU9P3RZZwkeU69L8KeyDM7CsDadLF1qivSnngIef9x0f3c3sc6oOdPguVMxm+H4cWD2bFOssyzA3cajJqS707BtyZIlRf6tuT1XCNzvnypgqMO0ddauHzx4EIcPHzbEeqDLNHgUoobAVK8//wSefdZ0ORU1Ei8fL0SdE2XcVoXwZfs2H/ggEpEIQQiSkYwTOIHjOI4/8Af2Yz8ux+UIOBpgOMB3f6A7fok9B1v3+uGTyaEY2i8Nnp42JG5KxKkTp1C/Q32nKc8QQtQM6IzOdHSKXQp0Kzh4EHjtNTPVneW+NJvr3x+Ww0kFdiyzlxbXGDp1Mgdx1y4zuuvo2mi2I0tNNScGGFFnOzi6/b34ItC4sTlrwx2E3aoYeXeX0jyOO38UnCxhxjNLAlizTpM/nos5LkqFd36R7u3tbUTNS6MZ832KqU8v3IpNCFFFvPKKeRXx3/9qyN0AQ+x6eiB1T2qpdeqe3p7IzS7owl5W2F89PCzcMAOthVpogAbIQhaSkGRE1XdgBz7Eh7gn5B4EpAZg6RtL0e2yVDx04/no2DILPv+c0biJ21cfN4R6g3MbVLmhnBCiZsJINPUYY0dWpqJPmgQjfd4O267xFGs11JU9epzpYlZjYH00ZzX4xVCoMxWbA+io/nL5o+mEMysMWNDxj7b8XAh7qnNGZNgwYPBg9xGo3MGaNDG/j7Vrz5yYaYbAHZDBWE2gO79xnBDCBWG7E/ZMF25DvXb1ULdJXaTsTkFabBpyc3KNCDuN2k6mmk7rderVQdS5UTiypWI919kHnWVQr732mlGbzl7rFOvRiC4g1t9JfQeDPAaht6039s7YilYdk3Hu4N68UjPW89uSQDzxXiT+dW0y7r91P6K7RaNWUPV0IxBC1Bw2bjQ1oJUtohk9X7jQvD92rBls5GI1DG5SWzpi3U4Ba6MvuMAUhayPjo01I7shIVXz2bfdZgp3zuJkZZk18sw4ZLT9yy/NayZ+AZw8YF89GmAzwlyT4aQE+w8S1q0zus46EWYYnHee+2QYVBCJdCFE5WEhnVpv1Hh8/H0Q0TEC9drWQ0ZyBvzD/Y0I++H1h5GemI7IcyIN4R7ZORK1Q2sbz5fXIb5X71544oknMGHCBBxJPmKIdRIdHo3n73gefqF+GPfdOMxZP8cwl7sSVyJxYyJ+ffBX9HuyH8LbhGP+yjrIOuWJnFyPPEO5iE4RVVZfL4SoedAYbs0aU4+xTbRV/PGHKaAZXGQw2FEBRmpGlm/bu2XVSGjoxoUsX2729WZUvapaxrL8lhFzO2zRtmCBmfbNVAlOHrBmm1F3PseM4iuuMB3qa3pk2T5DdPSo+b0wys5MB/6YWMsuwX4WEulCiIrDg+3LL5sHXBqoSKi7BUxpD4g4k7YX2SUSp9JPFXCDD44JNiLjh9Yegi23/EK9R48e2J+1HwkHEhBwOsBIhef6yOcvfo4Vm1bg/W/fx4QtE3AdrkO91Hr44/E/0O7mdnj1QRuG9DmOnp0yjNcz6r9k+hEs274drXvsRHR0A6Ntp9qeCSHKOg9Nv1TWdNsDg1bA4CI9tggDq47Uadx2lgfXuFT34qDrO2dWtm6tmjr1oqAApcnuoEHm9RK/cIp1GmSvW2deN3HhTsVW0vxymB7Pba+popWmCPx30hSck/jc6ZlOwjT4mj5RUU4k0oUQlbty+fRT8wBLS1pHNHUVLoFvnbNDS4ENAo10+IR1Ccg8llmu9Xl5e+GiSy4y6smPHzpurCN/rXv3Dt3xzavfYNn6ZRj/zXg039kc7WztsPWrrVg9fzWueP4K+PuZ9YjLli7D2LebIeV0fwSNW4Z03IyohlH4v//7v2LbfwohBPueU1OxFp1aLybGWh2xYoWZDc0AbN++jjlFsw6dkXrqRW6/20Ah2Lu3KdRpKmeVy19F4E5jT7tnOgNTvVm3TrE+fz6wY4e52OFrLrsMuPzyminW69Q5Y+rA2SO2buP3xTQVZ8RmO9O/sAp9BSTShRAVhwfU//s/s66KTjdCFIK14I36NcKx/ceQvCMZ2VnZZRojvxC/PMO3wKhAYz0HVx5E1vGsvNfQub13l97o1bkXFqxagDkfzkGH5A7w3++Pb2//Fj6X+qB189b4v/fGwYaH4IFzEYJfUQ9NcCjuEEaMGIHJkydLqAshim21xkZE9CWjxmLmtJXMmmXeMkPaERnZLAGm9uH2M829ppdAnwW/NAp1pisw35+DzJpwZxC+dIG//37gppvMIMfeveasCnc6Tix88YWZpXjllaZTPFPCHWWEV50EB5uzYHPnOm82ppeXmQ3B74jpKFWERLoQonLceqtGUJQIxTRN54JignA8/jiO7j+KzKMlR9bzp9PbI/UU+6xzT4tPO2v953c7HwM+H4Bff/wViT8lIiI3AidnnMT7eB/JSEIo3kQoPoEX0nnGRUM0RKxtJG699TAGDMhBWJgTXLQJIZwGBs3Y5pklzo7QRgcOABs2mLrkkkusXz+3n/5lAwea+s6tjW7POcdMheCAxMWZz1H4Okv693XXnXlMwUpXeJrN0aXwrbfM5zm5MGaMaY5X02CKvzP3BfT4J32minu+O+mUhRDCJeHJhSdBIYqANeXBjYLRuF9jhLcOP+vvfsF+eX3NAyIDinx/VNeovJZwheF7L7n+Elz9ydXwivRCbdTG9bgendEZ+7APR3EAOcgxXpuDusjEYzh+/F94/70t+r6EEAVghjRTxamhHMHMmeYtS3EdoU+oRSnOqUfdGp5TWEtAE7drrjEd+jj7wqi1M8K6hCFDgA8+MGdY2rUzZ4o46/Luu8B775n3RY1HIl0IYQ10K23b1jyxCFEKYa3CDKd4n9qmi1Fo81AjUh7dI9oQ66xlL46QpiGI6RUDb7+iIyGBEYEYPn44/Dubuan90R+jMAqZyMRe7EUykmFDMqLwCAIxA9HZy/PayDG6RQNeIYR7w5JhRrmtzIxmbTh11qOPAn/9ZT7HFtpWw7bdTM0/91znyOyudvhFsvCfJXoDBpg135yFcWaYvvHgg8Brr5nXVZxk4L+DaeGPPALs3l3dWygcjES6EMIaWO/F2WnWUTnrDLVwKpgC32xQM7Qc2tLow85IOHutx/Qp3d2ILd4Yka8dUrvIv7MVXNNrm2IJliAb2WiGZhiDMUbPdYr0fdiLLExBfTyM0MC6iF0SiyPbU4y0006dgE2bHPAPFkK4BBkZpmGc1S22Fy82M5npEUbB3qyZ9SWuNBCn4R0zvN2uBr2s4rdLF7MFmKvAmZaRI4GXXjInGGg28O9/m23caNzLHVbUOCTShRDWcPPN5mwve5M6q/mHcNqWbgUe/9NqrTQYSY/pHWOk0BcF27alh6Xjd/yOYziGQATiNtyGvuiLXOSaYt1jH+ZtmIejx49ixZ/HEB+bg4QEW7UaAQshqpeEBLNjltWp7najOGYzP/MM8N//Wt91ivqNxy9ONopi4OwFTeQyy9d1pNrp0MFMd2eNBFO+JkwAbrzRFPCvv246pYsag66khRDWQBOWe+81W2sIUUWwNj2yc6SROl+4Tp1i/84770Qa0jAHc4y6dE94YhAG4WbcbIj2HFsOPvzpQwy8YyBmL3oLk95ai/FPx8M760yU5Z13TIMnIYR7QK1DjygrU8V37jQj6DxVjhoFdO8OBAXBUhhQZYS+WzfTZ0wUA6PRTH3nTIyrwZ3mqaeAu+4qeL3FNgT33Wf2XRc1Aol0IYRjiI3VyIoqTZ1v2LOhkeaen169e+GJJ55AcFgwlmIpVmKlYR7H9PfHQx7H27e9jVaNW+FExglDrF/54PlYuOJlbP5rMw5vOIw1q3MxdqyZOsp6dSFEzYfazepabnsUnR5mjjKj42mX1jBMoxclwJmSJk2A48ddc5iYfnHppcD335t+QDQ6YEs3zi6xhp3LTz+Z7oTp7GgiXBEn6T8ghKgxsM7r+uuBP/4wQwcxpdcXC2EF/mH+hvlc/Ip4nDpxqoBQ79GjBzZv2YzUlFTUSq+Fw5MPIyMpAxnfZeDdu9/F7jq7Mf7H8di+bzs+/t/H+GbGN7jx0htx6cD7MOKqNvCt7Y1Gjc58VmZmDpYvX4ywsDAsXrwYffv2hZccmoSoEbBNtZWRaGontrx2lFGcfZvZcppmcao4KwNsHM90CRbxu+qx214rQcd6pnxRmE+ebEbT/4moe06ejMD//EczNy6IIulCCGth+hVnp1kvNX++RldUKeynTkO5wi3cmPresWNH9B/QHz0u6YEh7w0x2rnlnMrBynErUXdNXUx6fRLGPTkObZu2RfrJdHwy6RNc93APhHrdi6f/tR22XLNH6jffzEBAQAIuuuhvZGV5YNiwYWjSpAmmTp2qb1uIGtBJlKcwPz/r1sk5a6ahsx1aq1bWrZfrZCttptHTu5UZP8zkFmWgfn0zddxVo+mF8fEx69PffNOMstP4ICoKHikpaPzgg/CkCQIDJ8JlUCRdCGH9zO748eYJw8qrESHKYUQX3S0ayTuSkbQ9qcjX1Aqqhf7P9cfm/23Gph82Yc+cPUjZmYI+T/TBoPcGYe7yuUZkfcueLfh08qf4dua3GHXFKHTr1w133Ufr98uQm3sZvL3NTgbx8fEYMWIEJk+ejOHDh+u7EsKFk8HoJ0YTcCtgoPbXX89E0a0yiuNkAhuqsBc6M7eZwc2AqigjbMnGaDoH0VH1B9VBy5bmQrKykPu//wE//wzP9eth1G6x3uKKK8xUEdblBxSc0BbOgyLpQgjrad9eAl04RS/26O7RZ7nH26HRXIeRHXD+C+cbov3o3qOY88gcxC+Px8CeAzHl3Sn48JkP0b5Fe2RkZmDCTxNw9313oxY+BTActWo9lpclaWPaJICHHnoIObwqF0K4tEin+bcVrFwJHDliasJ+/axZZ1aWqS1Zfz5woOnk3q6dddvsNlDMMh2hph6za9WC7eabsXPGDORecIE5Q8Q+gGzfRpO5W24x2+bWlGyCGoZEuhDCsfDq5OBBjbKoFgIiAoz0d6bBF0dkl0gj/T2sTRhOp5/G4lcWY90X64z09gu7X4jJb0/GJ899gpYxLWGDDVlg255pQPZfRgTdDoV6bGwsFtmLT4UQLgd9tqx0drcbxg0eDPgWfxgqldxcU09y+yjQORd+4YVqqFIpaDTC+gDWCtRgTkdHw/bII2b7NntbAUbQuUNNm2Y6xbOWneNA10TubKLakUgXQjiOb78FmjYFHn9coyyqDd8AX8NQzj/cv9jX8G8DXxmIVpebJRrbpm3DvGfm4WTKSXh4eGDAeQPw6DWPIhrRqA3TUSozOxOXXnopsum/kI9Dhw45+F8khHAUVgYV58wBmGVMI7eLL67cunbvBuLizHnvLl1Mge5f/CFNlAWmfLNeIDXVPcaL12OsTee12XffATSUY60EZ36+/hq47Tbg5ptN0f7XXzU3w8BFkEgXQjgO5t/x4E9XGxbQCVFNsDUbW7SFNA0p9jVMi+96R1f0ebwPvGt748jmI/j9od+NVmwkNCwUdVAHMYhBQzREgGcA/P39z3J1j2KdoxDCJWEwsTJp4wxObthQ28gq/vhj87mRI4GIiIqvk5F9LsxYvu46U6BbaWzn1lC4Uqwz448W+e4iTJn6zlYAjK4//DAQGXnmb4mJwP/9H/DAA2b/dUXWqwUZxwkhHEfXrsDff5vpVVa55QhRQRgRr9+hPnwDfZG4MTGvjrwwMX1iENwkGEteW4Jj+49h/nPz0eGGDmh3VTuEh4UjOTkZ/vBHWO0wvDf9PSOabl9/w4YN0c+qwlMhRJXCQ0JKSsUFMOvZ//1vT8THn3Fw693bFNaV4eRJc5saNLDO0E7kc3lnbXpCgtmV5sABU7i7C0zz4OwPF7vhAWs0pkwBYmOB1183HQnpHN+mjVkHohmiKkEiXQjhWHr00AgLp6Ju47pGjfrBVQeRc7roqElQdBAueusirP54Nfb+tRcbv91oRNZvH3U73nz/TXjAnDCsunMAACeCSURBVHQK/6ffEQU6ee+999QvXQgXJSPDXCrSI53BRraqjo/3QJ06OQgM9ETLlh6GP1dl56gp0pnazlJiYTH8cmgYwBma/fuBX34xMwDZTtYdYRoJO5Swhdv06ebCWosXXjjzGvb6Y1q82gk4FKW7CyGqBs5Qz5un0RZOAWvQG/VtBB9/n2Jf413LGz0e7IHuD3SHl68XEtYmIPm7ZDx040MIKxTOYgRd7deEcE2oz1iLzmxnOrtXJFD444/AqlU0h7Phiy/2YsKEXMNEuyKCvzCcOGC3LHY2FQ4U640bm9FiFv+7O5ykuOEG4NNPgSuvLFgDsnatmSL/7LPmdd2aNcCmTWath7AMRdKFEI6HYQDWPm3dCqxbB3TurFEXTmEoR+f3+BXxOJl6stjXNRvUDKEtQrHk9SU4Hn8cmd9n4tGbHkVuW9MBd9asWejbt68i6EK4IMxy3rAB2LvXFOsUxOV1YWebNYp0cu+9NrRtm4l9+6zbRk4cVKamXZRDqDNKzJ2B5gSqLQCCg4HbbzfbtTFdhM6FP/wALFxouiJysWPvM3j++aYhn8ocK4VEuhDC8TCUQGF++LDZO0YiXTgJjJDH9I7BobWHcPxg8bbOdZvUxeC3B2Pl+JU4sOgANny1AQ26N8Cpvqck0IVwMag12D1x2zZg1y5TmFMEs9y2Xr2yaQv6i1HcMzN6/HjzuUsuoalb0V4XlYGTB3XrWr5aURTcAc47z4wQU3RWpm9eTYI/Di40Rhg7Fhg1ynSAZ1SdmZI0c2D7ttmzzYUGqhTrHEtvb1PsMx1ElBmJdCFE1fDuu2b6FE96QjgRHp4eaHBuAyTVSULyzuL75TI1vtejvQzzuTUT1uDgioM4eu1R1P+5Php2a1il2yyEKJ/IpWE1s3EZlaY453wxtQXFecNy/nwp0JnpywxfO8ySHj3a+m+F20xtpHr0KqRTJ3MWhzM40dHmF1AZy/+aCN3gKdS55J+1mj8fWLaMvUjNiDuX/D+SPn2Avn2VpVAGJNKFEFVD/vYeQjgh4W3C4VPHx2i5ZsstOhpGg7gWQ1sgtJWZ/p6ZmglvP51KhXDmaqvVq82sXBpXM4rO2m6ekiraZ5wtpinQqdtYxkyDcAp0R9SMyzSuGuAX2auXGRlmhJg7DgMM/KJF0XAig6UCXMaMMTv7ULDb60jS0szZMS6ffUbXVdNZnpMgAwYAzZo5b3q8hwdqcbasijMBdGUhhKh6aDLCq5v27TX6wqkIjgk2IuYHVxbv/E5Cm4di8HuDkZSehHrt6lXpNgohygaDoUuXmjqBWiAgwNQBldECFPyTJ5v3H3zQDAo6Eqbic7vd1Wy8WtPeR4wATp0y27LNnWs6CiqloWwljvnbuhHW+DPCvmiR6U9El0bCFBemzDsxXgBaskzm0UfNCYUqQiJdCFG1sHiPPWnY3uO33zT6wunwD/NHo36NEPd3HE5nFO9WyzZu9dsrsiKEM8EM5dRUM/i5caN5yzbYLIutLAysvvfemfpzRwt0u0hn225nDTLWaJhqwYX11LT/p8hklN0Ky353gyZ8l15qLhTszFBgijzNhBcvBo4dg7Ni8/BAjqcnPKu4P7xEuhCiahk61IyiM9WJM9QyZRFOCAU4W7TFL49H5rHM6t4cIUQZoPE0A5683mf2LbNTy1tvXhzM2P3gA3PdTHGn4bWjYWo+T5Nydq9mOEPSvbvpEsi6CfYHVz+8ygl2u3M+69RHjoQzk+vhgW1NmqAtf5BViES6EKJqYd0RU8dU2yWcHPZJp/P7wdUHkZ6YXt2bI4QoRUQza5alr7zut5rffwdWrDAj8o88UjXzy4zch4SYkwKimqEoZ+rEiROm62CLFuZMkBAOwtNRKxZCiGKRQBcugqe3J6K7Rxst2IQQzsv+/aYnlVWR8/zExQETJ5r3b77ZTD+vCli2y1R9lUE7CUx9Z501d7Ldu810bSEchES6EKL6YE3S11/rGxBODR3dIzpGoF5bGcQJ4axQoDMb1SqDNUbmd+wws5vfecdMO+/cGbj8clQJrEVntJ4iXTgRTG0YPBiIiQG2bzd3EhohsM5aol1YiNLdhRDVAwv7WNfFfD66vJ97rr4J4dSEtgiFd21vJKxLKLZFmxCi6mF3pIQE09/LKqZPBz7//MxjOqw/9JDZNaoqYJtpRuzVvdQJodkBzW/ZNoAzQ6yxYAo8F0LfHdaxM0Weol491kUFkEgXQlQPvJqiyyftdzNlzCVcg6DoIKNW/eCqg8jOzq7uzRFCwNRI9PSiH6kVUGvZk7zYuo2mzjfeeMbrytEwKEtdx5bTVTUpICpwDdOly5nHNJbjTNHhw2aWIFMxGIQ4eNBsMcBUebsrPNM9+FiIEpBIF0JUHx9+eKZxrRAugn+4v2EoF7siFtmQUBeiuqEW4lyvFZ2xqKfefhvgHFyPHsBTT1XNKYqZ0uzyxVuKdJY+N2rk+M8VFkHRTWNcLna4E9FYgMKdMz/8ggmfO3nSFOuBgeai2RhRCIl0IUT1wROTEC5IraBahlDfuWdndW+KEG4Pq6cYuLRCTH/5JRAba2Yp339/1Ql0ljXXrWt+XqdO5iJcHLYCYL0CFxoaEKbHU6RzJ2Onm8REs7aB10P2NHkGL5Qi7/ZIpAshqh9eoUyebF6VtG1b3VsjRJlg2rsQovphoJIp6ZVl9Wpg1izzPuvPq8pVfd8+M62eZc4MrrKUWYHVGgq/WHa44UIvHs4wcQfYssV0J+RsE1PkeZ/1G6x/V7ahW6IrDCFE9cOms++/D4wcCfzwQ3VvjRBCCBeBGcUU6RUt8WUZMQ3ijhwxA5rkssvMevCqgO3dGDgdMMDUY8INa9sZZWeQggKdQQtG2tlTkJ49dJCnsOfCiDx3FuEWSKQLIaqf228Hvv0W6NDBupxFIYQQNR4GItmurCKmbosWAR98YJYH22ncGLjlFlSZQKf2Yv15gwZV85nCSeF1DxfuEFFR5sL+e0yLt6fIs88gZ5OYdsH+fKJGI5EuhKh+OIscH29NvqIQQgi3EunlNY2jOdyECcCcOebjdu2Aq68GvLyAVq0cp384B81THZ3oqcVYhkyBzm6kQpwFZ57ss0/ceVq3NmsymB7PHZ5CnjutqJFIpAshnAMJdCGEEMXALOATJ0yBy77o9lR3il4GGsuagMUs4jfeMAOUfM811wDXX+94rcNt5mczu5mp7cxaps6qV8+xnytqCNxZmebBlAu6DK5ZA+zcac702Huyc+dShL3GIJEuhHAuNmwAli0D7r67urdECCFEFUMRzhZkjJDzPgOIvGW9OG8ZNadgzw+d2Eti1SqzvJcR9D//ND25WP/98MNnTLcdhT16zpT8Jk2Avn2BiAjHfqaowVCM02CXgp1mc4yq238krJ/gzBV/EHQgJAqAuCwS6UII54GzwrxiYtuSwYOBpk2re4uEEEI4CEbA2YWKh35GmimeWXqbllbQnoRRbkaeGSikwOUpoixQzLOl2vTpBZ+nqfaDD5otzxwNJxy4vcOGmWnt1FhCVBo6JZ53nrkQ/nhYr84UEZrNccezP88d7+hR80ek9HiXQSJdCOE80CTl4ourru+NEEKIaoGRchq37d5tCnJ72zEGAJs1q7yWoEZ55x0zgk5Y+01Rzmg2082rqsUZJx0YPW/Tpmo+T7gpTHOnoRyXLl1MN0T+sCjcOQPGCPuePeYPiynzirA7PRLpQgjn4pdfFGoQQogaDFumzZ1rpoE3alQ+07eSYPbvwoWmHmHV1PHjphZhz/PevVHlMCOAwcsWLar+s4Ubw53eLsKZfrJ1q+mMmJgIbNoE7N17pmaEs2M0oJNodzok0oUQzoVyAYUQosbC0tk//jADfBSvVmTfMmA4axYwcaKZQm+HWb6PPmoGF6saBi85GdGxo8zhhJOkx/MHwVQSGjzY60s4s0VHQ/6IwsPN2gymmXDmTO1wqxWJdCGEc5KaCowfD9x1F1C/fnVvjRCiEmzcuBFPP/00tmzZgqioKDzyyCO46qqrLH+PcH6Y3p6QYJ1Ap9b46CPTEI706mWmy9M7iynuVT3vy+g9OXjQrNxSmrtwKvija9jwzGP+EGk4xzp2inXOcjHKznR5inWKewr2WrXOOMfz+aqqF3FjJNKFEM7JiBFmPiRPFC+/XN1bI4SoIAcPHsSAAQMwYsQIvPTSS5g/fz6uueYazJgxA0OHDrXsPcL5oTM7G3iwa1R5BToDffS+Yo03NQRT2ll3zgj6tm2mZrj1VuCKK6ovAMgsAU5AMHrO7GIGJe1troVwSvhDpFM8F/Y4pEjnzBd/aEwF4cK6Dc4+2Xsf8jX8QXIHp3C3C3becn32x/w7H9t/kLzl3zhzJgO7UpFIF0I4J/ffb+ZD2p1LhRAuyQcffIA6dergk08+gYeHBzp16oSlS5fixRdfLFZwV+Q9wjmhoOa1Pa/pGUXnNT+zbgmfo9C2R58pwpmJS6HLhe+jHkhJMR+zhVpR0Gzu3/8GunZFtRrhcdu7dTMfs/+5dIhwKWigYIezS61bn5ld4wwU0+Ptj/ljZcYjBbxdvHPmzP6j5Y/b3i8xfw0K73M9+Z+z46zp9V5eZplAFSORLoRwTi6/vHpDIkIIS1iwYAEGDRpkiG07F198Me644w5kZmbCrwjDooq8x5Gwz3bh3tw1Df779u2rbVxzFycu+Rped9uvx9n7m8lOvOVCEW2/9ubfeS1uv0bnNTvXTbH9229m6zV2i+L7ywp3B/Y3tzvB8z6NqocPN2+rEv67OI/MfyN1CbeH5nScKOBkhBA10oiuNPhD5w+ei1208zn7wud5sOCBxP6c/XXOToOqPchIpAshnBPVOwlRI4iLi0P//v0LPBcREYGcnBwcPnwYjZlmacF7srKyjMVOGhWhIaZyjKUyDBzoibS0mj5hSGXevOo/1ctmpL8T3kZG0mzaZtyyHJaEhJiPGZ2uTm9Re6kus4K5e3F7WN7L0xXr4Js2pQYx97XK7nPujn38NI4uOo78UTAV3l7Hnh/2QnQhcjh2O3YghyYTFoxjWb8LiXQhhHPDWddp08zZVtapCyFcitzcXHizNjEfPv8oreIuVirynldffRUvvPDCWc9v374dAfnTOCtAREQLBAbKKKmy1K6di2bNstC8OZdM47Zx41Pw8bHB1eH8EGvj7ezYsaM6N6fGoHHUONa0ffEEZ/nKgES6EMK5+fZb4JZbgJgYMwVeRX5CuBT16tVDEk2I8mF/HM6WPxa958knnzQc4PNH0mNiYtC6dWsEMQJSCdhm2J7B6SqCkSWjjPoyi9Q+r2E3brZnnfL2DDkICNiB48dbGVH1/H9jNirXyXXZs1L5d3sXJ/7dPj7532d/fOY5L2Rn+yA725w02bfvTPcnR2H3quKtvXqCpxH7Yve6skfo+ZiZvZzXYYtpeyCQc0Z8jtF+3hZXicVJJF7Mt2rVCl46X1UYjaM1aBydbwztWV6lIZEuhHBurr0WeO01M4rOK0Jd9AjhUnTv3h1Lliwp8NyiRYvQpk2bYsVzRd5Tq1YtYykML6qsuLBypUMPh6G88xIU75yM6N69fONlLynlYp8AsD+fX7jbn+dh3C747TXr+d+XX/zmF+92kZ1fbFNQ29s628W4/b797/kX+3r4Hi4U5vb7VldYWbXfuTsaR42js2DduaRs65BIF0I4NwxpbNp05gpKdX5CuBRjxozBxIkTjWX06NFYtWoVvvnmG7zyyit5r5k9ezbuuusu42+RkZFleo9wDih6KXars1ZcCCFqGiqwEkI4PzKRE8Jl6dKlC7799ls888wzCAwMNPqf33PPPbj33nvzXpORkYH4+HhkMxxbxvcIIYQQNRVF0oUQrsPmzfD47jvg+uure0uEEOVg5MiRuPbaa5GcnIzg4GD4FnL8HTZsGGJjYxEVFVXm9wghhBA1FYl0IYRrQDfMnj3heeIEAth+qV276t4iIUQ58PT0NAzhiqJ27dpoyF5W5XiPEEIIUVORSBdCuAa0073rLtj27cPpiIjq3hohhBBCCCEcgkS6EMJ1eOsto39yFi2IhRBCCCGEqIHIOE4I4ToU15hWCCGEEEKIGoJEuhDC5fBMS4PH668bRnJCCCGEEELUJJTuLoRwORq88go8Z80Ctm8HvvqqujdHCCGEEEIIy5BIF0K4HMk33ojgAwfgMWRIdW+KEEIIIYQQliKRLoRwOU526IDcNWvg5a1DmBBCCCGEqFlUe03633//jVtvvRU9e/bEmjVrSn19dnY2Jk6ciOHDh+OCCy7ALbfcgsWLF1fJtgohnAiZyAkhhBBCiBpItYr0p59+Gg8++CDatm2L5cuXIy0trdT3PPbYY3jyySdx2WWX4bnnnkNkZCTOP/98zJs3r0q2WQjhROTmAtOmAd99V91bIoQQQgghhOuLdApuivNRo0aV+T0///wzxowZg9tuu82IpL/++uto06YNZsyY4dBtFUI4IVOnAsOHA2PHApmZ1b01QgghhBBCVJpqLegMDg4u93vOO+88rFy5EqdPn4aPjw8OHDiA2NhYdO/e3SHbKIRwYq64AujUCRg2DDh9GvDzq+4tEkIIIYQQolK4nOvSF198gdGjRyM6OhoNGjTAvn378MYbb2DkyJHFvicrK8tY7Bw7dsy4TU1NRU5OTpVstyvDMTpx4oQxXl5eXtW9OS6LxtFB48hSF9anZ2fzR23Rp9RstC863zjay71sNptFWyfsY1mWUjpxZn/meOlcX3E0jtagcdQ41tR9sazne5cT6ePHjzfqz19++WU0b94cc+bMMWrUzz33XCPKXhSvvvoqXnjhhbOeb9KkSRVssRBCCFE2jh8/XqEsM1H0WJKYmBgNjxBCCJc633vYnGDaPi4uzjiJUnzTBK6kf0xYWBg+/PBD3HHHHXnPX3rppcjNzcXs2bPLFEnna1NSUox1ecghukwzPvx+WFYQFBRU3q9XaBwtRfujxrAm7os8FfMcxwwxT89qb7xSI+C5/uDBgwgMDNS5vgzo2GoNGkeNozOh/dH5xrCs53uXiqQz1YC16Ex1zw//kRs2bCj2fbVq1TKW/NStW9dh21lT4Y4pka5xdBa0P2oMa9q+qAi6tfDip2HDhhavteajY6vG0ZnQ/qhxrIn7YlnO904/Xc9Udbv7e1RUFFq0aIFPPvkkLzLOmvTp06ejX79+1bylQgghhBBCCCFE5ahWkT5r1iz07NkTl19+ufH4nnvuMR5PnDgx7zW7d+/G+vXr8x7/9NNP2LVrlxE979Spk9FjvX///nj++eer5d8ghBBCCCGEEEJYRbWmu7Nt2nvvvXfW8/nT05566ikjzd1O165dsXHjRsTHxyM5ORmNGjVCSEhIlW2zO8JSgf/85z9nlQwIjWN1oP1RY+gsaF8UNQntzxpHZ0L7o8bR3fdFpzCOE0IIIYQQQgghhAvUpAshhBBCCCGEEO6CRLoQQgghhBBCCOEkSKQLIYQQQgghhBBOgkS6wLZt23D77bdjwIABuPXWW7Fp06ZSR2X79u14+OGH0atXL0yePFmjCGDOnDkYMWIEzj//fIwdOxZJSUkljktCQoLRlWDo0KG46qqr8P777+e1FnRXaJHBFosck4suughvv/02Tp8+XeJ7Dh8+jOeeew5DhgzBFVdcYbwnPT0d7szx48fx7LPP4sILLzTGZMqUKeV678UXX2x02jh16hTcmb179+Luu+82jo033ngjVq1aVeLrf//9d2PcCi/5zU+FqC7S0tLw9NNP44ILLsCVV16JadOmlfqelJQUvPPOO0YXnUcffbRKttPZYdehO++80zgu3HTTTVizZk2Jr+d5/dNPP8U111xjnKcee+wxHDp0CO7O/Pnzce211xrXTA888IBxTVQSPB99/PHHGD58uDGOvM5iG2Z358svv8SwYcMwaNAgvPbaa+W6juQY8hy1cOFCuDMZGRn473//a1wzXXbZZfj+++9LfP2xY8eKPNf/+eeflm6XRLqbw4tQCu3c3Fw88cQT8Pb2Ru/evbFjx45i3/PDDz8YF/504aegL+3A6g788ssvxkGS3Qd4IcOLeZ54ijtY8gfOcfb09MSDDz5onKgo0inW3dnLkfsgOzqMHDkSd9xxh9H9gRdDJZ20eVCtU6cO/v3vfxvvmzBhgnGQdVe4/1xyySVGi0vuWwMHDsQNN9xQoLVlSfzrX/8yumcsX77cOC64Kzyu8diYmppq7JehoaHo168f1q5dW+x7jhw5gp07dxr7bf6ldu3aVbrtQhSGv2VOvnEi6aGHHjLOT9ddd51xgV8cFJIdO3bEgQMH4OHhYUzouzsHDx40jguczORxISgoCH379sWGDRuKfQ8nRCjkeZ5ncIPXTbxWcGehTjHDiXi2Uea5m/sWx7GkCc2bb77ZCBDddtttxrmN7ZjZJYrfibvy4osvGmPBiYsxY8YY5/lRo0aV6b3ffvst/vjjD+Ncz8k4d2b48OFGi+/77rvPuH6yX38WB4NHHLd77723wLn+nHPOsXbD6O4u3Je77rrL1qFDB1tubq7xmLddunSx3XrrrcW+59ixY3n3g4ODbePGjbO5O+3bt7fdfffdeY+Tk5Ntvr6+tokTJxb5+tOnT9tOnjxZ4LkFCxZQnds2b95sc0cSExNt3t7etm+++SbvuV9//dUYk61btxb5Hu6vhcfxl19+Md7D9bkj9n//nj178p57+umnbREREbbs7OwS3/v555/bunfvbnwHXEfhsXUnHnvsMVvjxo0LjNmAAQNsV155ZbHv4bhxnIVwNqZOnWrz8PCw7d+/P++5xx9/3NagQQNbTk5Oke/JysqyZWRkGPevu+4627Bhw2zuziOPPGJr1qxZgeNC3759bSNGjCj2PcePHy/wODMz01a3bl3b22+/bXNXeJ4ZNWpUgTEKCAiwvffee8W+Jz09vcBjnp88PT0LXDO4E2lpabbatWvbPvroo7znFi1aZJy7V61aVeJ7d+zYYYuKijJex9dPmzbN5q7MnTvXGIONGzfmPffqq68a+oa/1aI4cuSI8Z61a9c6dNsUSXdz/vrrL1x66aXGLDnh7eWXX15iygZnjkXBiNvmzZsLRG8ZdeOscHHjyIwFPz+/As8FBAQYt+6aYrxgwQJkZ2cb+6Mdpm/5+/sb+2lRcH/NP46MIi9atAiNGjVCSEgI3BGOVYcOHdC0adO855j5wrKAkkpZGKF48skn8d133xn7p7vDcWTZhZeXV4Fx5G+6pGwXphTzfVwYaWN0XQhn2J87d+5sHBvz78+MQm7durXI9/j6+ioLpIhxZKQt/3GhtGsm+7k9/7iy37K7nuuZhbBy5coC10wcI2bFlTSOvBbIz5IlS4xbZnu4I/z3nzx5ssA49unTB2FhYSWOI/c7Zh2+8soraN68Odydv/76C40bNzaum/IfG5nxWlqJGzNjuN/eddddpZa9VASJdDdn//79aNCgQYHn+DguLg45OTnVtl2uNoakqHG0/60s2A+Y+Q8U7gTHiifhunXr5j1HsVi/fv1Sx5F16D169EBMTIzhDcBaN3cVmsX9pu1/KwqWZfCk/fLLL6NFixZVsp2uOo5Mx2QKfHGTRqw7ZckAyzSYDte+fXu3TscUrntcEGUfx6NHjxoTdGWBKcn0rMk/Ie1OsHyCE50VuWaiMGXtL9PkWT7AUkNOPrkjHCuecyIjI/Oe4+OoqKgSx5GeCM2aNTM8qASMsYqOji73sZHXnPTzevzxx42JNz6ePn26pUPqnlexwoAHSQpxzujmx14/yahm/tliUTR2Y7OixrE00zM7NKyYPXs25s2b57bikmNVeAzLOo5XX321USdIQx8KTdZo8WBpzxBx93G0/6aLG0eax/CkPXr06CrZxpo6jjSOzF8PSJ+Kdu3aGRNwH3zwgYO3WIji4T5bOBJZ2v4srDku5IcGXTRJe/XVV912Qr4y10yc9GTtLyc5aMbHGmKKdHokuRscK14vFr5OL2kcZ86caRjJluSh4G6crsBvmpmaixcvzrtep5FhZmamcS3FKLxVKJLuxlDAMGpZ2DAiOTnZMOIqSjCJs2FqOylqHJl2VBpvvvmm4cjJGWHOxLnzODK9qLBZWVnGsUmTJoYRH512eQKaMWOGEU1313Esal8kxY3jV199ZRj32B1K6QxP6F5ckrGUO44jzR7zZ3vkp/Axk49pNrd+/XqHbqsQjjguiLKPIy/Wg4ODSxyypUuXGtFzmsvSLM1dqcw1E4+9PEdxHO3dCcaNGwd3HUeKyMJmeyWNI8/1vMZiORbHkeZ9hNFgdjJxR0IrcGzkxEjhgBrLMxkosrKbi3uG7EQedBhlbVB+mKJpuUNhDaZly5YIDAw0xpF16PYsBT4uzWWTadpsH0aBzh+4u++LPHmsXr0a3bp1M55je5XExMRy7Y9M9SKltcCryeP4888/GynsdtHI3zRPKsXV7s2dO7dAeQvr2SjUOYHkrjVrxR0bGRkvzwQmPSs46SlEde/Pv/76q3FR7+Pjk7c/80LTXSO6Vh4XOIYlZcEtW7bMcNe///77DUdud4ZlaeHh4cY4ckzsrFixolzXQTyn1atXz63P9YTjyLaKhNdLvG4q7pqJWV12AUooKCnUmUXnruUXXbt2xeeff26Mhd0/gr9p0qVLl3Kd63lsZeq7ZTjUlk44Pd9//73Nz8/PtmLFCuPxmjVrDLfIL774Iu81P/74o61Hjx5Fvl/u7ib33HOPrXnz5objI6Gru5eXVwFX8ieffNJw07fz7rvvGmM9Z84cB327rgWd2jt37my7/PLL85xzb7vtNlujRo0KOGxecskltvHjxxv3Fy9ebPv9998LuBE/9NBDNn9/f1tCQoLNHTl06JCtTp06hjup3TWXHRuuvvrqvNfExsYav2mOX1H88MMPbu/uPnv2bOM3PG/ePGNMtm3bZhzv+Lu1M3PmTGMc7e7NdCbO31WAx046auc/ngpRHcTFxRnnmzfffDPPGbpjx46Ga7udffv2GfvzsmXLznq/3N3PdM9gF5KFCxcaj7ds2WILCgoq0OVm+vTpxjjanfGXL19uvIZdNsSZ7hkNGza0HTx4sMCxcvXq1XlD9N///td20003Gfd5jH3nnXeMzjj5OxbwGD1p0iS3HdbevXvbBg0aZDt16pTx+L777jM6jJw4cSLvNew88NZbbxX5/tTUVLd3d09JSTG6Ldh/n+wa0KtXL9uQIUMKdGzib/qPP/4wHk+ZMsXQS3Z4rR8dHV3geGoFEunCOFjWqlXL1qpVK6NtGEWOvSUb4UVp/vkc7ozcWbnwANmkSRPjPkWou8IDIsUjxSHFOluJfP311wVeQ5HUp08f4z7b4HBMw8PD88bSvrAdhLuyfft2W9u2bY1xYXsQtsBauXJlgdfwBMTWQfYLz+HDh9vCwsIMgc8DLW/deQzJjBkzbKGhocZvMzAw0Njv7BNIZOfOncb+x9cVhUS6yUsvvVTg2Dh69OgCrZcovjmOvNCxT3pyn+XrOblEUc8LSyGcgZ9//tkWEhJia9q0qXFc6Nevny0pKanAuZ37M1tf2uGFKs9LPMby+Mr7F1xwgc2deeGFFwocF9h+NX8buwkTJhjjaJ+84znNx8fnrHP9K6+8YnNXKIR47maQqEWLFsa108cff1zgNbfccotxPic87vIak/shJ5co8OvVq1diyzZ3YO/evbZOnToZ53uKRLZULDz5zmvSe++9t8j3S6SbUHzXr18/77zdrVs3W3x8fIHgB3/TvDYi69atMyZIOOZt2rQxjgO33357gRbVVuDB/1kXlxeuCtNf6GLI9ixMQyqcwsH0GdavkPT0dGzcuPGsdbB2g6nf7gxdSzmWrVu3PsukZ+fOnUaqIdNlmYq8du3aItfRqlWrvJotd4SHJLYDo3EhHVwLm6KwzQVT3JgyZ4euunv37jVcTiMiIqphq50P7mOsM2cpBk3hCv+N+1+bNm2KrK/mPsz9lR4J7mi+lx+6NnPfottr4X2L7dVYg8byDPt+yv2Xz3Hc6JUg803hjMcFtlLN36aR0Pho3bp1xnHXXl/N8qPC5kncp+0lSe4KOzzwuEDDMnYgKeq40L17d8PDgmPKsS0M31f42OxuxMfHGynavHYs3KqOY5iRkVGgTIvtw3bs2GGc1zj2Or6acEz42+Zvt3DZBfc/nud5PioMy9yYLs9rVndtW2uHxzm2o+S1e+EuN/wbj4XcT/PXqbO1LcsteCwtfM1vBRLpQgghhBBCCCGEkyB3dyGEEEIIIYQQwkmQSBdCCCGEEEIIIZwEiXQhhBBCCCGEEMJJkEgXQgghhBBCCCGcBIl0IYQQQgghhBDCSZBIF0IIIYQQQgghnASJdCGEEEIIIYQQwkmQSBdClJmcnBz873//w7Zt28762+LFizFnzhyNphBCCOHizJ07FwsWLDjr+V27duGnn37CqVOnqmW7hHAXJNKFEGXGy8sLS5YswbBhw3DixIm85zds2IBBgwYhLS1NoymEEEK4OOnp6bjooouwZs2avOcyMjKM8//8+fPh6+tbrdsnRE3Hw2az2ap7I4QQrsPJkyfRpUsXXHjhhfjoo4+QmZmJbt264bzzzsMXX3xR3ZsnhBBCCAu47bbbsHLlSqxevRq1atXCmDFjDIFO4e7v768xFsKBSKQLIcrN33//jX79+mHWrFnGMnPmTKxbtw6BgYEaTSGEEKIGwOy4jh07YuTIkcY5f/jw4Vi6dKkxKS+EcCwS6UKICvHUU0/h008/xbFjx4y6td69e2skhRBCiBrEX3/9hYsvvtiYhB87diyefvrp6t4kIdwCiXQhRIU4dOgQYmJi0KdPnyLNZYQQQgjh+nTu3Bk7duzA4cOHERQUVN2bI4RbIOM4IUSFuP/++9GqVSssW7YM06ZN0ygKIYQQNQx6z+zduxdRUVF48sknq3tzhHAbFEkXQpQbGsTdd999hnnMpEmTMG7cOGzatAn16tXTaAohhBA1gO3bt6Nr164YP368MSnfv39//Pbbb0Y3FyGEY5FIF0KUC86oM/XtjTfeMJxe2Tu9V69eaNSoESZPnqzRFEIIIVyc06dPG14zjRs3zju3P/bYY/jxxx+NSXmlvQvhWCTShRBlhoKcM+mhoaGYMWNG3vNbt241Zts/++wz3HDDDRpRIYQQwoWhQdyXX36JjRs3Gud8kpWVZZzre/Togc8//7y6N1GIGo1q0oUQZYatV5o0aWKI8fy0bdsWH3/8MRYvXmwIeSGEEEK4JsnJydi/fz++++67PIFO2Cv9m2++wcmTJ42/CyEchyLpQgghhBBCCCGEk6BIuhBCCCGEEEII4SRIpAshhBBCCCGEEE6CRLoQQgghhBBCCOEkSKQLIYQQQgghhBBOgkS6EEIIIYQQQgjhJEikCyGEEEIIIYQQToJEuhBCCCGEEEII4SRIpAshhBBCCCGEEE6CRLoQQgghhBBCCOEkSKQLIYQQQgghhBBOgkS6EEIIIYQQQgjhJEikCyGEEEIIIYQQcA7+H0Cva/9RjqTzAAAAAElFTkSuQmCC", + "text/plain": [ + "
" ] - }, - { - "cell_type": "markdown", - "source": [ - "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. Both methods require an array of test points and a confidence level." - ], - "metadata": { - "id": "pJdmM4kVV-D1" - } - }, - { - "cell_type": "code", - "source": [ - "# Get predictions\n", - "ppost, pmean, pci, pstd = mix.predict(X = x_test, ci = 0.95)\n", - "wpost, wmean, wci, wstd = mix.predict_weights(X = x_test, ci = 0.95)\n" - ], - "metadata": { - "id": "HBJ61xMxJdLc" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "6. Plot the predictions and weight functions." - ], - "metadata": { - "id": "_0Ch2Z5bV_X9" - } - }, - { - "cell_type": "code", - "source": [ - "# Predcition upper and lower bounds\n", - "plower = pci[0]\n", - "pupper = pci[1]\n", - "\n", - "# Weight Functions upper and lower bounds\n", - "wlower = wci[0]\n", - "wupper = wci[1]\n", - "\n", - "# F test data\n", - "f_test = [fs4.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]" - ], - "metadata": { - "id": "OdW84RzBJgO6" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Plot the predictions and weight functions\n", - "col_list = ['red','blue','green','purple','orange']\n", - "\n", - "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", - "ax[0].plot(x_test, fdagger, color = 'black')\n", - "ax[0].plot(x_test, pmean, color = 'purple')\n", - "for i in range(2):\n", - " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", - "ax[0].scatter(x_train ,y_train,c=\"black\")\n", - "ax[0].set_title(\"Posterior Mean Prediction\")\n", - "ax[0].set_xlabel(\"X\") # Update Label\n", - "ax[0].set_ylabel(\"F(X)\") # Update Label\n", - "ax[0].set_ylim(1.8,2.8)\n", - "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", - "ax[0].grid(True, color='lightgrey')\n", - "\n", - "\n", - "for i in range(2):\n", - " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", - " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", - "ax[1].set_title(\"Posterior Weight Functions\")\n", - "ax[1].set_xlabel(\"X\")\n", - "ax[1].set_ylabel(\"W(X)\")\n", - "ax[1].grid(True, color='lightgrey')\n", - "\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 487 - }, - "id": "I-f8MkmmJnqq", - "outputId": "df0d0dbd-7bd4-45cb-e63f-3225bed0a677" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the predictions and weight functions\n", + "col_list = ['red','blue','green','purple','orange']\n", + "\n", + "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", + "ax[0].plot(x_test, fdagger, color = 'black')\n", + "ax[0].plot(x_test, pmean, color = 'purple')\n", + "for i in range(2):\n", + " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", + "ax[0].scatter(x_train ,y_train,c=\"black\")\n", + "ax[0].set_title(\"Posterior Mean Prediction\")\n", + "ax[0].set_xlabel(\"X\")\n", + "ax[0].set_ylabel(\"F(X)\")\n", + "ax[0].set_ylim(1.8,2.8)\n", + "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", + "ax[0].grid(True, color='lightgrey')\n", + "\n", + "\n", + "for i in range(2):\n", + " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", + " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", + "ax[1].set_title(\"Posterior Weight Functions\")\n", + "ax[1].set_xlabel(\"X\")\n", + "ax[1].set_ylabel(\"W(X)\")\n", + "ax[1].grid(True, color='lightgrey')\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lDJp2kAYJMeF" + }, + "source": [ + "### **Example 1b:**\n", + "\n", + "This section provides the code to reproduce the BART-BMM results for example 1b in the manuscript." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The BART-BMM model is trained using the following steps.\n", + "\n", + "1. Define the model set using the line of code shown below, which creates a class instance for the new EFT model. The other EFT model, `fl4`, is reused from Example 1a." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:32.711317Z", + "iopub.status.busy": "2026-07-20T04:09:32.711224Z", + "iopub.status.idle": "2026-07-20T04:09:32.712951Z", + "shell.execute_reply": "2026-07-20T04:09:32.712564Z" + } + }, + "outputs": [], + "source": [ + "# Redefine the model set\n", + "fs4 = honda_models(True,4)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Define the class instance of the BART-BMM model using the `Openbtmix` class. For this example, the class instance is called `mix`.\n", + "\n", + "3. Set the prior information using the `set_prior()` method.\n", + "\n", + "4. Fit the model using `train()`. This requires the user to pass in the data, the evaluated model set (`f_train`), the informative-prior standard deviations (`s_train`), and relevant MCMC arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:32.713934Z", + "iopub.status.busy": "2026-07-20T04:09:32.713865Z", + "iopub.status.idle": "2026-07-20T04:09:47.421551Z", + "shell.execute_reply": "2026-07-20T04:09:47.419898Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('numcut', 300)\n", + "Running model...\n" + ] + } + ], + "source": [ + "# Fit the BMM Model\n", + "# Evaluate the model set at the training inputs\n", + "f_train = np.concatenate([fs4.evaluate(x_train)[0], fl4.evaluate(x_train)[0]], axis=1)\n", + "s_train = np.concatenate([fs4.evaluate(x_train)[1], fl4.evaluate(x_train)[1]], axis=1)\n", + "\n", + "# Initialize the Openbtmix class instance\n", + "mix = Openbtmix()\n", + "\n", + "# Set prior information\n", + "mix.set_prior(k=5.0,ntree=10,nu=5,sighat=0.01,inform_prior=True)\n", + "\n", + "# Train the model\n", + "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train, s_train=s_train,\n", + " ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", + " tc = 2,numcut = 300)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. `predict()` requires the test inputs, the evaluated model set at those inputs, and a confidence level; `predict_weights()` requires just the test inputs and a confidence level." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:47.424200Z", + "iopub.status.busy": "2026-07-20T04:09:47.424089Z", + "iopub.status.idle": "2026-07-20T04:09:52.428382Z", + "shell.execute_reply": "2026-07-20T04:09:52.427630Z" + } + }, + "outputs": [], + "source": [ + "# Evaluate the model set at the test inputs\n", + "f_test_arr = np.concatenate([fs4.evaluate(x_test)[0], fl4.evaluate(x_test)[0]], axis=1)\n", + "\n", + "# Get predictions\n", + "pred = mix.predict(x_test=x_test, f_test=f_test_arr, ci=0.95)\n", + "wts = mix.predict_weights(x_test=x_test, ci=0.95)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_0Ch2Z5bV_X9" + }, + "source": [ + "6. Plot the predictions and weight functions." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:52.431300Z", + "iopub.status.busy": "2026-07-20T04:09:52.431192Z", + "iopub.status.idle": "2026-07-20T04:09:52.434252Z", + "shell.execute_reply": "2026-07-20T04:09:52.433828Z" + } + }, + "outputs": [], + "source": [ + "# Predcition upper and lower bounds\n", + "pmean = pred[\"pred\"][\"mean\"]\n", + "plower = pred[\"pred\"][\"lb\"]\n", + "pupper = pred[\"pred\"][\"ub\"]\n", + "\n", + "# Weight Functions upper and lower bounds\n", + "wmean = wts[\"wts\"][\"mean\"]\n", + "wlower = wts[\"wts\"][\"lb\"]\n", + "wupper = wts[\"wts\"][\"ub\"]\n", + "\n", + "# F test data\n", + "f_test = [fs4.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "execution": { + "iopub.execute_input": "2026-07-20T04:09:52.435297Z", + "iopub.status.busy": "2026-07-20T04:09:52.435232Z", + "iopub.status.idle": "2026-07-20T04:09:52.529133Z", + "shell.execute_reply": "2026-07-20T04:09:52.528700Z" + }, + "id": "I-f8MkmmJnqq", + "outputId": "df0d0dbd-7bd4-45cb-e63f-3225bed0a677" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "markdown", - "source": [ - "## **Example 2**\n", - "\n", - "The BART-BMM model is trained using the following steps.\n", - "\n", - "1. Define the model set using the three lines of code shown below. The first two lines define a class instance for each Taylor series expansion. The third line of code defines the model set. " - ], - "metadata": { - "id": "T6o6fkY6WA5L" - } - }, - { - "cell_type": "code", - "source": [ - "# Define the model set\n", - "f1 = sin_cos_exp(7,10,np.pi,np.pi) # 7th order sin(x1) + 10th order cos(x2)\n", - "f2 = sin_cos_exp(13,6,-np.pi,-np.pi) # 13th order sin(x1) + 6th order cos(x2)\n", - "model_dict = {'model1':f1, 'model2':f2}\n", - "\n", - "# Get train data\n", - "x_train = np.loadtxt(\"2d_x_train.txt\").reshape(80,2)\n", - "x_train = x_train.reshape(2,80).transpose()\n", - "\n", - "y_train = np.loadtxt(\"2d_y_train.txt\").reshape(80,1)\n", - "\n", - "# Get test data\n", - "n_test = 30\n", - "x1_test = np.outer(np.linspace(-np.pi, np.pi, n_test), np.ones(n_test))\n", - "x2_test = x1_test.copy().transpose()\n", - "f0_test = (np.sin(x1_test) + np.cos(x2_test))\n", - "x_test = np.array([x1_test.reshape(x1_test.size,),x2_test.reshape(x1_test.size,)]).transpose()\n" - ], - "metadata": { - "id": "WUnzkJlVWFtM" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "2. Define the class instance of the BART-BMM model using the `Trees` class. For this example, the class instance is called `mix`.\n", - "\n", - "3. Set the prior information using the `set_prior()` method.\n", - "\n", - "4. Fit the model using the `train()`. This requires the user to pass in the data and relevant MCMC arguments. " - ], - "metadata": { - "id": "JdUjxZV2YMqn" - } - }, - { - "cell_type": "code", - "source": [ - "# Fit the BMM Model\n", - "# Initialize the Trees class instance\n", - "mix = Trees(model_dict = model_dict, google_colab = True)\n", - "\n", - "# Set prior information\n", - "mix.set_prior(k=2.0,ntree=30,overallnu=5,overallsd=0.01,inform_prior=False)\n", - "\n", - "# Train the model\n", - "fit = mix.train(X=x_train, y=y_train, ndpost = 5000, nadapt = 2000, nskip = 1000, adaptevery = 200, minnumbot = 4, tc = 2)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "gd981k7zYUWP", - "outputId": "ce1c8242-e358-42eb-b6bd-65d03b020c82" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Results stored in temporary path: /tmp/openbtpy_k074kw9y\n", - "Running model...\n" - ] - } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the predictions and weight functions\n", + "col_list = ['red','blue','green','purple','orange']\n", + "\n", + "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", + "ax[0].plot(x_test, fdagger, color = 'black')\n", + "ax[0].plot(x_test, pmean, color = 'purple')\n", + "for i in range(2):\n", + " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", + "ax[0].scatter(x_train ,y_train,c=\"black\")\n", + "ax[0].set_title(\"Posterior Mean Prediction\")\n", + "ax[0].set_xlabel(\"X\") # Update Label\n", + "ax[0].set_ylabel(\"F(X)\") # Update Label\n", + "ax[0].set_ylim(1.8,2.8)\n", + "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", + "ax[0].grid(True, color='lightgrey')\n", + "\n", + "\n", + "for i in range(2):\n", + " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", + " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", + "ax[1].set_title(\"Posterior Weight Functions\")\n", + "ax[1].set_xlabel(\"X\")\n", + "ax[1].set_ylabel(\"W(X)\")\n", + "ax[1].grid(True, color='lightgrey')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Example 2**\n", + "\n", + "The BART-BMM model is trained using the following steps.\n", + "\n", + "1. Define the model set using the two lines of code shown below, each of which creates a class instance for a Taylor series expansion." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:52.530520Z", + "iopub.status.busy": "2026-07-20T04:09:52.530428Z", + "iopub.status.idle": "2026-07-20T04:09:52.533733Z", + "shell.execute_reply": "2026-07-20T04:09:52.533323Z" + } + }, + "outputs": [], + "source": [ + "# Define the model set\n", + "f1 = sin_cos_exp(7,10,np.pi,np.pi) # 7th order sin(x1) + 10th order cos(x2)\n", + "f2 = sin_cos_exp(13,6,-np.pi,-np.pi) # 13th order sin(x1) + 6th order cos(x2)\n", + "\n", + "# Get train data\n", + "x_train = np.loadtxt(\"Data/2d_x_train.txt\").reshape(80,2)\n", + "x_train = x_train.reshape(2,80).transpose()\n", + "\n", + "y_train = np.loadtxt(\"Data/2d_y_train.txt\").reshape(80,1)\n", + "\n", + "# Get test data\n", + "n_test = 30\n", + "x1_test = np.outer(np.linspace(-np.pi, np.pi, n_test), np.ones(n_test))\n", + "x2_test = x1_test.copy().transpose()\n", + "f0_test = (np.sin(x1_test) + np.cos(x2_test))\n", + "x_test = np.array([x1_test.reshape(x1_test.size,),x2_test.reshape(x1_test.size,)]).transpose()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Define the class instance of the BART-BMM model using the `Openbtmix` class. For this example, the class instance is called `mix`.\n", + "\n", + "3. Set the prior information using the `set_prior()` method.\n", + "\n", + "4. Fit the model using `train()`. This requires the user to pass in the data, the evaluated model set (`f_train`), and relevant MCMC arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:09:52.534756Z", + "iopub.status.busy": "2026-07-20T04:09:52.534690Z", + "iopub.status.idle": "2026-07-20T04:10:14.089325Z", + "shell.execute_reply": "2026-07-20T04:10:14.088555Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running model...\n" + ] + } + ], + "source": [ + "# Fit the BMM Model\n", + "# Evaluate the model set at the training inputs\n", + "f_train = np.concatenate([f1.evaluate(x_train)[0], f2.evaluate(x_train)[0]], axis=1)\n", + "\n", + "# Initialize the Openbtmix class instance\n", + "mix = Openbtmix()\n", + "\n", + "# Set prior information\n", + "mix.set_prior(k=2.0,ntree=30,nu=5,sighat=0.01,inform_prior=False)\n", + "\n", + "# Train the model\n", + "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train,\n", + " ndpost = 5000, nadapt = 2000, nskip = 1000, adaptevery = 200, minnumbot = 4, tc = 2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. `predict()` requires the test inputs, the evaluated model set at those inputs, and a confidence level; `predict_weights()` requires just the test inputs and a confidence level." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T04:10:14.092088Z", + "iopub.status.busy": "2026-07-20T04:10:14.091972Z", + "iopub.status.idle": "2026-07-20T04:10:21.655409Z", + "shell.execute_reply": "2026-07-20T04:10:21.654720Z" + } + }, + "outputs": [], + "source": [ + "# Evaluate the model set at the test inputs\n", + "f_test = np.concatenate([f1.evaluate(x_test)[0], f2.evaluate(x_test)[0]], axis=1)\n", + "\n", + "# Get predictions\n", + "pred = mix.predict(x_test=x_test, f_test=f_test, ci=0.95)\n", + "wts = mix.predict_weights(x_test=x_test, ci=0.95)\n", + "\n", + "pmean = pred[\"pred\"][\"mean\"]\n", + "wmean = wts[\"wts\"][\"mean\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 412 + }, + "execution": { + "iopub.execute_input": "2026-07-20T04:10:21.658265Z", + "iopub.status.busy": "2026-07-20T04:10:21.658157Z", + "iopub.status.idle": "2026-07-20T04:10:21.979518Z", + "shell.execute_reply": "2026-07-20T04:10:21.978798Z" + }, + "id": "meVGDrOAZp5w", + "outputId": "831c346f-95af-47f6-8783-094f81317f36" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Posterior Mean Residuals and Weight Functions')" ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" }, { - "cell_type": "markdown", - "source": [ - "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. Both methods require an array of test points and a confidence level." - ], - "metadata": { - "id": "ss60BLXDYXSF" - } - }, - { - "cell_type": "code", - "source": [ - "# Get predictions\n", - "ppost, pmean, pci, pstd = mix.predict(X = x_test, ci = 0.95)\n", - "wpost, wmean, wci, wstd = mix.predict_weights(X = x_test, ci = 0.95)\n" - ], - "metadata": { - "id": "P9aVdBgrYg_-" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# The posterior mean weight functions\n", - "cmap_hot = plt.get_cmap('hot')\n", - "w1 = wmean.transpose()[0]\n", - "w2 = wmean.transpose()[1]\n", - "\n", - "w1_mean = wmean.transpose()[0]\n", - "w1_mean = w1_mean.reshape(x1_test.shape).transpose()\n", - "\n", - "w2_mean = wmean.transpose()[1]\n", - "w2_mean = w2_mean.reshape(x1_test.shape).transpose()\n", - "\n", - "w_sum = w1_mean + w2_mean\n", - "\n", - "# Posterior Mean resiudals\n", - "cmap_rb = plt.get_cmap(\"RdBu\")\n", - "fig, ax = plt.subplots(1,3, figsize = (24,6))\n", - "\n", - "pcm1 = ax[0].pcolormesh((f0_test - pmean.reshape(x1_test.shape)).transpose(),cmap = cmap_rb, vmin = -2.5, vmax = 2.5)\n", - "ax[0].set_title(\"Posterior Mean Residuals\", size = 16)\n", - "ax[0].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", - "ax[0].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[0].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "ax[0].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[0].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "\n", - "fig.colorbar(pcm1,ax = ax[0])\n", - "\n", - "pcm0 = ax[1].pcolormesh(w1_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", - "ax[1].set_title(\"Posterior Mean of $w_1(x)$\", size = 16)\n", - "ax[1].set(xlabel = \"$x_1$\", ylabel = \"$x_2\")\n", - "ax[1].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[1].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "ax[1].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[1].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "fig.colorbar(pcm0,ax = ax[1])\n", - "\n", - "pcm2 = ax[2].pcolormesh(w2_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", - "ax[2].set_title(\"Posterior Mean of $w_2(x)$\", size = 16)\n", - "ax[2].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", - "ax[2].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[2].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "ax[2].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[2].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "fig.colorbar(pcm2,ax = ax[2])\n", - "fig.suptitle(\"Posterior Mean Residuals and Weight Functions\", size = 18)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 412 - }, - "id": "meVGDrOAZp5w", - "outputId": "831c346f-95af-47f6-8783-094f81317f36" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'Posterior Mean Residuals and Weight Functions')" - ] - }, - "metadata": {}, - "execution_count": 15 - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" } - ] -} \ No newline at end of file + ], + "source": [ + "# The posterior mean weight functions\n", + "cmap_hot = plt.get_cmap('hot')\n", + "w1 = wmean.transpose()[0]\n", + "w2 = wmean.transpose()[1]\n", + "\n", + "w1_mean = wmean.transpose()[0]\n", + "w1_mean = w1_mean.reshape(x1_test.shape).transpose()\n", + "\n", + "w2_mean = wmean.transpose()[1]\n", + "w2_mean = w2_mean.reshape(x1_test.shape).transpose()\n", + "\n", + "w_sum = w1_mean + w2_mean\n", + "\n", + "# Posterior Mean resiudals\n", + "cmap_rb = plt.get_cmap(\"RdBu\")\n", + "fig, ax = plt.subplots(1,3, figsize = (24,6))\n", + "\n", + "pcm1 = ax[0].pcolormesh((f0_test - pmean.reshape(x1_test.shape)).transpose(),cmap = cmap_rb, vmin = -2.5, vmax = 2.5)\n", + "ax[0].set_title(\"Posterior Mean Residuals\", size = 16)\n", + "ax[0].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", + "ax[0].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[0].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "ax[0].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[0].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "\n", + "fig.colorbar(pcm1,ax = ax[0])\n", + "\n", + "pcm0 = ax[1].pcolormesh(w1_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", + "ax[1].set_title(\"Posterior Mean of $w_1(x)$\", size = 16)\n", + "ax[1].set(xlabel = \"$x_1$\", ylabel = \"$x_2\")\n", + "ax[1].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[1].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "ax[1].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[1].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "fig.colorbar(pcm0,ax = ax[1])\n", + "\n", + "pcm2 = ax[2].pcolormesh(w2_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", + "ax[2].set_title(\"Posterior Mean of $w_2(x)$\", size = 16)\n", + "ax[2].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", + "ax[2].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[2].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "ax[2].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[2].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "fig.colorbar(pcm2,ax = ax[2])\n", + "fig.suptitle(\"Posterior Mean Residuals and Weight Functions\", size = 18)\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "openbt (.venv)", + "language": "python", + "name": "openbt-venv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From a567d5a9f35851923c1308c3f8d5449210cea567 Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Mon, 20 Jul 2026 13:14:20 -0400 Subject: [PATCH 04/17] Simplified setup instructions --- .../BART_BMM_Technometrics.ipynb | 7 ------- 1 file changed, 7 deletions(-) diff --git a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb index e477d37..b20a470 100644 --- a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb +++ b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb @@ -12,13 +12,6 @@ "\n", "This notebook uses the openbt Python package from this repository (openbt_pypkg), which wraps the OpenBT C++ command line tools.\n", "\n", - "Before running this notebook, set up and activate a Python virtual environment with a C++14 compiler and an MPI implementation (e.g., Open MPI or MPICH) available, then install the package from a clone of this repository:\n", - "\n", - "```console\n", - "$ cd /path/to/OpenBT/openbt_pypkg\n", - "$ python -m pip install -v -e .\n", - "```\n", - "\n", "See the \"Getting Started with Python\" section of the [OpenBT User Guide](https://openbt.readthedocs.io) for full dependency and installation details.\n" ] }, From 433ef5d3cdda459a9b789deafa0ae21743524fc2 Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Mon, 20 Jul 2026 15:35:03 -0400 Subject: [PATCH 05/17] Simplified instructions in documentation --- docs/get_started_r.rst | 30 ++------- docs/git_workflow.rst | 11 ++-- docs/tox_usage.rst | 135 ++++++++++------------------------------- 3 files changed, 41 insertions(+), 135 deletions(-) diff --git a/docs/get_started_r.rst b/docs/get_started_r.rst index a46e009..37953e1 100644 --- a/docs/get_started_r.rst +++ b/docs/get_started_r.rst @@ -1,47 +1,27 @@ Getting Started with R ======================= -.. _Meson: https://mesonbuild.com -.. _ninja: https://ninja-build.org .. _remotes: https://remotes.r-lib.org Installed versions of the |openbt| R package, ``Ropenbt``, provide a front-end R interface that wraps a dedicated set of |openbt| C++ command line tools. - - -Unlike the |openbt| Python package, ``Ropenbt`` does not build or invoke -Meson_ itself. It is a pure R package with no compiled code of its own; it -simply locates and calls the already-built command line tools (such as -``openbtcli``) on the ``PATH``, or in the current working directory as a -fallback. Building those command line tools is a separate, prerequisite step. - -Build the C++ command line tools ------------------------------------------ -Before installing ``Ropenbt``, you must first build and install the |openbt| -C++ command line tools using Meson_ and ninja_. Follow the -:doc:`get_started_cpp` guide to - -* install the required dependencies (a C++14-compatible compiler, an MPI - installation, and optionally Eigen_), -* install Meson_ and ninja_, and -* build and install the command line tools. - - +To build these tools, follow the :doc:`get_started_cpp` guide to build, install, +and test them before continuing. Install Ropenbt ------------------------- With the command line tools built, install the -``Ropenbt`` R interface directly from Bitbucket using the remotes_ package. First, make sure +``Ropenbt`` R interface directly from GitHub using the remotes_ package. First, make sure ``remotes`` is installed: .. code-block:: r install.packages("remotes") -Now install ``Ropenbt`` directly from Bitbucket: +Now install ``Ropenbt`` directly from the codebase: .. code-block:: r - remotes::install_bitbucket("mpratola/openbt/Ropenbt") + remotes::install_github(“https://gitub.com/bandframework/OpenBT”, subdir=”Ropenbt”) Note that some ``Ropenbt`` package dependencies may also be installed. Since ``Ropenbt`` itself needs no compilation, this step is quick regardless of diff --git a/docs/git_workflow.rst b/docs/git_workflow.rst index ab406d3..4cb4bfc 100644 --- a/docs/git_workflow.rst +++ b/docs/git_workflow.rst @@ -67,9 +67,9 @@ Python Package Testing ~~~~~~~~~~~~~~~~~~~~~~ * **Test OpenBT Python Source Distribution** — The primary test action. Builds - a Python source distribution and tests it across a matrix of six operating - systems, two MPI implementations (Open MPI and MPICH), and five Python - versions (3.10–3.14). The built source distribution is also uploaded as an + a Python source distribution and tests it across a matrix of operating + systems, MPI implementations, and Python versions to validate broad + compatibility. The built source distribution is also uploaded as an artifact for manual upload to PyPI at release time. This action additionally runs on published releases. @@ -79,7 +79,7 @@ Python Package Testing MPI implementations work correctly. * **Test OpenBT in Anaconda** — Tests installation inside a conda environment - across six operating systems using a prebuilt Open MPI installed |via| |pip|. + across a matrix of operating systems using a prebuilt Open MPI installed |via| |pip|. * **Measure OpenBT Python Coverage** — Runs the full Python test suite with coverage measurement using |tox| and uploads the raw coverage file, XML @@ -89,7 +89,6 @@ C++ Tools Testing ~~~~~~~~~~~~~~~~~ * **Test OpenBT C++ Command Line Tools** — Builds and tests the C++ command - line tools directly across a matrix of six operating systems and two MPI - implementations, independently of the Python package. Prints dynamic library + line tools directly across a matrix of operating systems and MPI implementations, independently of the Python package. Prints dynamic library linkage information for each built binary so that developers can verify the correct MPI implementation was linked. diff --git a/docs/tox_usage.rst b/docs/tox_usage.rst index 2fac2f8..9e8e9c8 100644 --- a/docs/tox_usage.rst +++ b/docs/tox_usage.rst @@ -54,54 +54,18 @@ needs. No work will be carried out by default with the calls ``tox`` and ``tox -r``. -The following tasks can be run from within the directory hierarchy that contains -the |openbt| |tox| configuration file ``/path/to/OpenBT/openbt_pypkg/tox.ini``: +Run the following from the directory hierarchy that contains the |openbt| +|tox| configuration file ``/path/to/OpenBT/openbt_pypkg/tox.ini`` to see the +full list of available environments and what each one does: -* ``tox -r -e nocoverage`` - - * Execute the full test suite for the |openbt| Python package using the code - installed into Python. - -* ``tox -r -e coverage`` - - * Execute the full test suite for the |openbt| Python package and save - coverage results to a coverage file. - * The test runs the package code in the local clone rather than code installed - into Python so that coverage results are clean and straightforward. - * If the environment variable ``COVERAGE_FILE`` is set, then this is the - coverage file that will be written to. If it is not specified, then the - coverage results are written to ``.coverage_openbt``. - -* ``tox -r -e report`` - - * It is intended that this be run after or with ``coverage``. - * Display a code coverage report for the |openbt| package's full test suite - and generate XML and HTML versions of the report. - * The environment variables ``COVERAGE_XML`` and ``COVERAGE_HTML`` can be - provided to specify the names of the files that the associated reports - should be written to. If ``COVERAGE_XML`` is not specified, the XML report - is written to ``coverage.xml``. If ``COVERAGE_HTML`` is not provided, the - HTML report is written to ``htmlcov``. - -* ``tox -r -e check`` - - * Run several checks on the code to report possible issues. - * No files are altered automatically by this task. - -* ``tox -r -e html`` - - * Generate and serve the |openbt| documentation locally as HTML via a local - server at ``http://127.0.0.1:8000``. The browser reloads automatically - whenever documentation source files are changed. - -* ``tox -r -e pdf`` +.. code-block:: console - * Generate and render the |openbt| documentation locally as a PDF file. - * Users are responsible for installing ``make`` and a compatible LaTeX - installation for immediate use by |tox|. + $ tox list -v -Additionally, you can run any combination of the above such as -``tox -r -e report,coverage``. +Environments can be combined in a single invocation, e.g. +``tox -r -e report,coverage``. Users needing ``pdf`` should note that |tox| +does not install ``make`` or a LaTeX distribution; those must be installed +separately. Direct use of |tox| virtual environments ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -132,37 +96,18 @@ Note that using the ``coverage`` virtual environment directly can be particularly useful since the package is installed in editable mode and therefore facilitates interactive development and testing of the Python code. -|Tox|'s ``-r`` flag takes a conservative approach by wiping and fully -rebuilding the virtual environment from scratch on every invocation, which -guarantees a clean state but adds overhead each time. For iterative work this -accumulates quickly. The ``html`` environment illustrates how to set up the -environment once and then work flexibly inside it rather than letting |tox| -drive every step. - -When |tox| runs the ``html`` environment it launches ``sphinx-autobuild``, a -live-reload server. A developer who wants to invoke ``sphinx-build`` with -specific flags, rebuild on demand, or simply skip the server overhead can -instead create the environment once and activate it directly: +The ``html`` environment can be activated directly in the same way to rebuild +documentation iteratively without paying the cost of a full |tox| rebuild each +time: .. code-block:: console $ cd /path/to/OpenBT/openbt_pypkg $ tox -r -e html - $ # Press Ctrl+C to stop sphinx-autobuild once the environment is ready. $ . ./.tox/html/bin/activate $ which sphinx-build $ sphinx-build -W -E -b html ../docs ../docs/build_html -On subsequent documentation iterations only the ``sphinx-build`` command is -needed — the environment is already activated and no |tox| rebuild is required. -Omitting ``-E`` on later runs reuses Sphinx's cached environment and speeds up -incremental builds. The live-reload server can also be started directly from -the activated environment when it is useful: - -.. code-block:: console - - $ sphinx-autobuild -W -b html ../docs ../docs/build_html - Eigen ----- .. _Eigen: https://gitlab.com/libeigen/eigen @@ -178,10 +123,10 @@ Eigen does not need to be installed manually. The |openbt| Meson build system handles Eigen automatically in two steps. First, Meson searches for an existing system-wide Eigen installation discoverable |via| ``pkg-config``. If found, that installation is used for the build. If not found, Meson falls back -to the ``subprojects/eigen.wrap`` file, which instructs it to download Eigen -5.0.1 automatically from GitLab and use it internally for that build. As a -result, Eigen is always available to the build regardless of whether it is -installed on the system. +to the ``subprojects/eigen.wrap`` file, which instructs it to download a +pinned Eigen version automatically from GitLab and use it internally for that +build. As a result, Eigen is always available to the build regardless of +whether it is installed on the system. Developers on macOS who prefer to have a system-wide installation can install Eigen |via| Homebrew: @@ -203,7 +148,7 @@ Please refer to :ref:`get_started_cpp:Meson installation` for detailed installation instructions. Build Process with Python -~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~~~~~~ The Meson build is not invoked directly by developers. It is triggered automatically when the |openbt| Python package is installed |via| @@ -219,20 +164,11 @@ or in editable mode |via| $ python -m pip install -e . -Internally, ``setup.py`` defines a custom ``build_clt`` command that runs the -following three Meson commands sequentially from within the ``cpp/`` directory: - -.. code-block:: console - - $ meson setup --wipe --clearcache --buildtype=release builddir \ - -Dprefix=/path/to/src/openbt -Duse_mpi=true -Dpypkg=true - $ meson compile -v -C builddir - $ meson install --quiet -C builddir - -The ``--wipe`` flag deletes and recreates ``builddir`` before every install, -ensuring a clean compile from scratch. The ``--clearcache`` flag clears -Meson's dependency detection cache, forcing it to re-detect the compiler, MPI, -and Eigen installations. +Internally, ``setup.py`` defines a custom ``build_clt`` command that wipes and +rebuilds ``cpp/builddir`` from scratch on every install, forcing Meson to +re-detect the compiler, MPI, and Eigen installations rather than reusing +stale detection results. Developers who need the exact Meson invocation can +inspect ``build_clt`` in ``setup.py`` directly. Files and Directories Created ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -243,19 +179,10 @@ A successful ``pip install`` creates the following files and directories: compiles all C++ source files into object files. This directory is wiped and recreated on every ``pip install`` and can be deleted safely at any time. -* ``openbt_pypkg/src/openbt/bin/`` — The eight compiled C++ command line - tools installed by ``meson install``: - - .. code-block:: console - - openbtcli openbtpred openbtmixingwts - openbtmixing openbtmixingpred openbtmopareto - openbtsobol openbtvartivity - - .. note:: - Only ``openbtcli``, ``openbtpred``, and ``openbtmixingwts`` are - included in the distributed package. All eight are compiled and - installed to disk regardless. +* ``openbt_pypkg/src/openbt/bin/`` — The compiled C++ command line tools + installed by ``meson install``. Only a subset of these are included in the + distributed package; the rest are still compiled and installed to disk. + See ``cpp/meson.build`` for the current list of built tools. * ``openbt_pypkg/src/openbt/include/eigen3/`` — Eigen headers installed under the package prefix as a side effect of Eigen's own Meson install @@ -275,10 +202,10 @@ Caching There are four caching layers involved in the build, each with different behaviour on a recompile: -* ``subprojects/packagecache/`` — Stores downloaded Eigen tarballs - (``eigen-5.0.1.tar.bz2`` and its patch) so that Meson does not re-download - them on every build. ``--clearcache`` does not clear this directory; it - persists intentionally across builds. +* ``subprojects/packagecache/`` — Stores the downloaded Eigen tarball and its + patch so that Meson does not re-download them on every build. + ``--clearcache`` does not clear this directory; it persists intentionally + across builds. * ``cpp/builddir/`` — Ninja's compile cache of object files. Because ``meson setup --wipe`` is run on every ``pip install``, this cache is never @@ -302,4 +229,4 @@ behaviour on a recompile: installed copy of the |openbt| package and compiled binaries. Running ``tox`` without ``-r`` reuses the existing environment and does not reinstall |openbt| or rerun the Meson build. Running ``tox -r`` forces a - clean environment rebuild and a full ``pip install`` from scratch. + clean environment rebuild and a full ``pip install`` from scratch. \ No newline at end of file From 62a9b57180ce09c4d041d53d16b27e2926979cce Mon Sep 17 00:00:00 2001 From: Sarthak Mistry <56183762+Sarthakmistry@users.noreply.github.com> Date: Mon, 20 Jul 2026 15:43:14 -0400 Subject: [PATCH 06/17] Fix GitHub URL in installation instructions --- docs/get_started_r.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/get_started_r.rst b/docs/get_started_r.rst index 37953e1..e1c569f 100644 --- a/docs/get_started_r.rst +++ b/docs/get_started_r.rst @@ -21,11 +21,11 @@ Now install ``Ropenbt`` directly from the codebase: .. code-block:: r - remotes::install_github(“https://gitub.com/bandframework/OpenBT”, subdir=”Ropenbt”) + remotes::install_github(“https://github.com/bandframework/OpenBT”, subdir=”Ropenbt”) Note that some ``Ropenbt`` package dependencies may also be installed. Since ``Ropenbt`` itself needs no compilation, this step is quick regardless of platform. See :doc:`examples_r` for a worked example of fitting a model with -``Ropenbt``. \ No newline at end of file +``Ropenbt``. From c51f13c1c5e76a53474f28f6ba9003d2d1cb6a9f Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 20 Jul 2026 21:55:13 +0000 Subject: [PATCH 07/17] Bump actions/setup-python from 6 to 7 Bumps [actions/setup-python](https://github.com/actions/setup-python) from 6 to 7. - [Release notes](https://github.com/actions/setup-python/releases) - [Commits](https://github.com/actions/setup-python/compare/v6...v7) --- updated-dependencies: - dependency-name: actions/setup-python dependency-version: '7' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/build_docs.yml | 2 +- .github/workflows/measure_coverage.yml | 2 +- .github/workflows/test_CLTs.yml | 2 +- .github/workflows/test_py_devmode.yml | 2 +- .github/workflows/test_py_sdist.yml | 4 ++-- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/build_docs.yml b/.github/workflows/build_docs.yml index c50ad5a..c2c6d88 100644 --- a/.github/workflows/build_docs.yml +++ b/.github/workflows/build_docs.yml @@ -21,7 +21,7 @@ jobs: # We would like to use 3.12, but this presently fails. - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.11" diff --git a/.github/workflows/measure_coverage.yml b/.github/workflows/measure_coverage.yml index bdd7603..c8aca60 100644 --- a/.github/workflows/measure_coverage.yml +++ b/.github/workflows/measure_coverage.yml @@ -27,7 +27,7 @@ jobs: sudo apt-get update sudo apt-get -y install openmpi-bin libopenmpi-dev - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Setup Python dependencies diff --git a/.github/workflows/test_CLTs.yml b/.github/workflows/test_CLTs.yml index c04e561..7bca0cc 100644 --- a/.github/workflows/test_CLTs.yml +++ b/.github/workflows/test_CLTs.yml @@ -51,7 +51,7 @@ jobs: fi fi - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Install Meson build system diff --git a/.github/workflows/test_py_devmode.yml b/.github/workflows/test_py_devmode.yml index 7028701..2602513 100644 --- a/.github/workflows/test_py_devmode.yml +++ b/.github/workflows/test_py_devmode.yml @@ -28,7 +28,7 @@ jobs: - name: Checkout OpenBT uses: actions/checkout@v7 - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Setup Python dependencies diff --git a/.github/workflows/test_py_sdist.yml b/.github/workflows/test_py_sdist.yml index 4fcb14a..ff75445 100644 --- a/.github/workflows/test_py_sdist.yml +++ b/.github/workflows/test_py_sdist.yml @@ -26,7 +26,7 @@ jobs: steps: - uses: actions/checkout@v7 - name: Setup Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Setup base Python environment @@ -103,7 +103,7 @@ jobs: fi fi - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} - name: Setup Python dependencies From 314f4fc24ca9bb836cbda9a9a44234d04eef7738 Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Tue, 21 Jul 2026 12:57:37 -0400 Subject: [PATCH 08/17] changed to single quotes --- docs/get_started_r.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/get_started_r.rst b/docs/get_started_r.rst index e1c569f..600628c 100644 --- a/docs/get_started_r.rst +++ b/docs/get_started_r.rst @@ -21,7 +21,7 @@ Now install ``Ropenbt`` directly from the codebase: .. code-block:: r - remotes::install_github(“https://github.com/bandframework/OpenBT”, subdir=”Ropenbt”) + remotes::install_github('https://github.com/bandframework/OpenBT', subdir='Ropenbt') Note that some ``Ropenbt`` package dependencies may also be installed. Since ``Ropenbt`` itself needs no compilation, this step is quick regardless of From 584d59aaa5e3eff55b30aac4e73eda95351086d0 Mon Sep 17 00:00:00 2001 From: Jared O'Neal Date: Thu, 23 Jul 2026 10:20:34 -0500 Subject: [PATCH 09/17] Very minor tweaks and polishing as part of PR review. --- .../BART_BMM_Technometrics.ipynb | 264 ++++-------------- 1 file changed, 60 insertions(+), 204 deletions(-) diff --git a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb index b20a470..c6f40b6 100644 --- a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb +++ b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb @@ -6,11 +6,11 @@ "source": [ "## BART-BMM Examples\n", "\n", - "This notebook reproduces the BART-BMM examples shown in \"Model Mixing Using Bayesian Additive Regression Trees.\" Each code cell can be executed by clicking the \"play\" button, which is found on the lefthand side of the cell. Alternatively, one can click inside the cell and use the command `shift + enter`.\n", + "This notebook reproduces the BART-BMM examples shown in [\"Model Mixing Using Bayesian Additive Regression Trees\"](https://www.tandfonline.com/doi/full/10.1080/00401706.2023.2257765).\n", "\n", "### **Installation Step**\n", "\n", - "This notebook uses the openbt Python package from this repository (openbt_pypkg), which wraps the OpenBT C++ command line tools.\n", + "This notebook uses the OpenBT Python package from this repository (`openbt_pypkg`), which wraps the OpenBT C++ command line tools.\n", "\n", "See the \"Getting Started with Python\" section of the [OpenBT User Guide](https://openbt.readthedocs.io) for full dependency and installation details.\n" ] @@ -27,14 +27,8 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 1, "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:10.175580Z", - "iopub.status.busy": "2026-07-20T04:09:10.175470Z", - "iopub.status.idle": "2026-07-20T04:09:11.002486Z", - "shell.execute_reply": "2026-07-20T04:09:11.002035Z" - }, "id": "ZuRGYOA8VBYC" }, "outputs": [], @@ -74,32 +68,19 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:11.004225Z", - "iopub.status.busy": "2026-07-20T04:09:11.004106Z", - "iopub.status.idle": "2026-07-20T04:09:11.042266Z", - "shell.execute_reply": "2026-07-20T04:09:11.041827Z" - } - }, + "execution_count": 2, + "metadata": {}, "outputs": [], "source": [ "# openbt imports\n", "from openbt import Openbtmix\n", - "from openbt.tests.polynomial_models import sin_exp, cos_exp, sin_cos_exp\n" + "from openbt.tests.polynomial_models import sin_exp, cos_exp, sin_cos_exp" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 3, "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:11.043370Z", - "iopub.status.busy": "2026-07-20T04:09:11.043287Z", - "iopub.status.idle": "2026-07-20T04:09:11.045394Z", - "shell.execute_reply": "2026-07-20T04:09:11.044985Z" - }, "id": "x0Bi_I8kI6uP" }, "outputs": [], @@ -109,20 +90,13 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:11.046377Z", - "iopub.status.busy": "2026-07-20T04:09:11.046310Z", - "iopub.status.idle": "2026-07-20T04:09:11.050345Z", - "shell.execute_reply": "2026-07-20T04:09:11.049944Z" - } - }, + "execution_count": 4, + "metadata": {}, "outputs": [], "source": [ "# Wrap honda models\n", "class honda_models:\n", - " def __init__(self,sg = True, N = 2):\n", + " def __init__(self, sg = True, N = 2):\n", " self.N = N\n", " self.sg = sg\n", "\n", @@ -138,7 +112,7 @@ " if len(m.shape) == 1:\n", " m = m.reshape(m.shape[0],1)\n", " s = s.reshape(s.shape[0],1)\n", - " return m,s\n" + " return m,s" ] }, { @@ -163,33 +137,19 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:11.051334Z", - "iopub.status.busy": "2026-07-20T04:09:11.051267Z", - "iopub.status.idle": "2026-07-20T04:09:11.052757Z", - "shell.execute_reply": "2026-07-20T04:09:11.052458Z" - } - }, + "execution_count": 5, + "metadata": {}, "outputs": [], "source": [ "# Load the models\n", "fs2 = honda_models(True,2)\n", - "fl4 = honda_models(False,4)\n" + "fl4 = honda_models(False,4)" ] }, { "cell_type": "code", - "execution_count": 25, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:11.053691Z", - "iopub.status.busy": "2026-07-20T04:09:11.053618Z", - "iopub.status.idle": "2026-07-20T04:09:11.055786Z", - "shell.execute_reply": "2026-07-20T04:09:11.055455Z" - } - }, + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ "# Format training and test data\n", @@ -199,7 +159,7 @@ "\n", "y_train = y_train.reshape(20,1)\n", "x_train = x_train.reshape(20,1)\n", - "x_test = x_test.reshape(200,1)\n" + "x_test = x_test.reshape(200,1)" ] }, { @@ -215,15 +175,8 @@ }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:11.056679Z", - "iopub.status.busy": "2026-07-20T04:09:11.056616Z", - "iopub.status.idle": "2026-07-20T04:09:27.084838Z", - "shell.execute_reply": "2026-07-20T04:09:27.083977Z" - } - }, + "execution_count": 7, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -249,7 +202,7 @@ "# Train the model\n", "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train, s_train=s_train,\n", " ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", - " tc = 2,numcut = 300)\n" + " tc = 2,numcut = 300)" ] }, { @@ -261,15 +214,8 @@ }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:27.087580Z", - "iopub.status.busy": "2026-07-20T04:09:27.087466Z", - "iopub.status.idle": "2026-07-20T04:09:32.291565Z", - "shell.execute_reply": "2026-07-20T04:09:32.290903Z" - } - }, + "execution_count": 8, + "metadata": {}, "outputs": [], "source": [ "# Evaluate the model set at the test inputs\n", @@ -277,7 +223,7 @@ "\n", "# Get predictions\n", "pred = mix.predict(x_test=x_test, f_test=f_test_arr, ci=0.95)\n", - "wts = mix.predict_weights(x_test=x_test, ci=0.95)\n" + "wts = mix.predict_weights(x_test=x_test, ci=0.95)" ] }, { @@ -291,15 +237,8 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:32.294503Z", - "iopub.status.busy": "2026-07-20T04:09:32.294378Z", - "iopub.status.idle": "2026-07-20T04:09:32.298787Z", - "shell.execute_reply": "2026-07-20T04:09:32.298431Z" - } - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ "# Predictions - Upper and Lower ci bounds\n", @@ -316,30 +255,24 @@ "f_test = [fs2.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]\n", "\n", "# Define the underlying true model\n", - "fdagger = eft.f_dagger(x_test)\n" + "fdagger = eft.f_dagger(x_test)" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 487 }, - "execution": { - "iopub.execute_input": "2026-07-20T04:09:32.299928Z", - "iopub.status.busy": "2026-07-20T04:09:32.299858Z", - "iopub.status.idle": "2026-07-20T04:09:32.709444Z", - "shell.execute_reply": "2026-07-20T04:09:32.708989Z" - }, "id": "xhw8PPAd89qi", "outputId": "6de8b8bf-b3e1-417f-bad0-223d262be62e" }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAHVCAYAAACNGrqAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV4FOfXxc/G3QMJJLhLcSst2pZChULdlbp8pe6l8i9Qd6HupaXeUlqkOMUKxV0SiLvrfs95hwmbsJvsbnazu8n99ZmyOjszu5l3znvvPddgNBqNEARBEARBEARBEATB5Xi5egMEQRAEQRAEQRAEQdAQkS4IgiAIgiAIgiAIboKIdEEQBEEQBEEQBEFwE0SkC4IgCIIgCIIgCIKbICJdEARBEARBEARBENwEEemCIAiCIAiCIAiC4CaISBcEQRAEQRAEQRAEN0FEuiAIgiAIgiAIgiC4CSLSBaGJ2LNnD95//33k5+fLMfcwPv/8c6xYsaLmflVVlfouN23a5LDPcMY6BUEQBOfx4YcfYt26dc3qEH/88cdYu3Zto8axjRs3Ony7PJ1vvvkGf//9t6s3Q/AgDEaj0ejqjRAEcyxYsABJSUk19wMCAtC+fXuMGDECPj4+Dj9oO3fuVELskksuQUhIiFMGvmuvvVaJ9S5dusCZHDp0CH/99Ze6fdZZZyE+Pv6E13AQ/u+//9Tt66+/HgaDAe6I6b4Qb29vREdHY9iwYWjdunWTbENMTAzOO+88dfFBSktLERgYiKeffhqPPvqo1espLy/Hp59+iqFDh+Kkk06q9Zy96xQEQfAEDh48iIULF9Y6l/PcynN5q1atHP55vLz94IMPMGDAAAwaNAjOgNci9957L2bOnAln8tFHH6lx/Mwzz6z1eE5ODubNm4fY2FhMnjy51nMlJSX44osv0KNHD5xyyilWfxavtW6//Xa88MILNm+nPo498cQTePLJJxt8PcfUfv36YciQIVat/8svv0RxcbHZ57j/PA6uhNuXkJCAUaNGnfBchw4d1PfASX9BsAbHKx1BcBAvv/wyFi1ahKuvvrpmMFq8eLES0F9//TVGjhzp0GPNGc5bbrkFp512mlNEerdu3ZQYDg8Ph7P5999/MW3aNHX74YcfxrPPPnvCa26++Wb1OnLNNdc4ZeLDkfsyZswYdO7cGRUVFWqWfseOHbjnnnswa9asJt8mHit+l7z4swVeXHBfnnvuuRNEur3rFARB8ATWr1+vzn9jx45Fp06d1KQlz+W7du3Cfffdh//9738O/TxGdfl5jzzyiNNEOs/ZnHR1Nm+88QZSU1Nx5MiRWo///vvvah+Dg4PVNZKvr2/Nc8uWLVPPvf766zaJdAYTOHHSFHD7HnjgAatF+vTp09W/Z5999gnPjRs3zuUindvHiRRzIp0BoK5du7pkuwTPxD2vygXhGP7+/jXRS3L06FH0798fF1xwgZqV5/Oewsknn6yWpoQR+88++0xFZ728jle3bN68WYlfDhiM7HsCvBi64ooraiIkN910E2bPnq0uvi666KIm3RYKatPfpbuuUxAEwd248cYblWDRz+U8t3PicvDgwZg6dSo8iXfffbdJPocClJFtTmh079695nEGLnr16oXt27fjn3/+qSXGlyxZUvNeW3j77bfhzvC6xhPHSmdnWwjNDxHpgkfRpk0bJcjefPNNVburz/ampKRg9erVKlJJ4cmZ7brp20VFRVi1ahXS09ORmJioxB1nnwlrylauXFlTN8R0asIZUaYu6RQUFKiU+IyMDLUtp556aq2Jgm3btqntuPzyy2sGUM5+8yKEYnjp0qVq+8PCwmptW0PbX99664NZCI899pjKSDj99NNrpc4xksHttyTSG9rX5ORk/PHHH+o2t5UpbrxY4CSKKabbztcxdb2wsFBlQrRr1w72wPXceeedmDNnDubPn6+OKf9lZIYpb4w28PuMiIjAGWecod5TXV2tvmfuL7eVnx8XF3fCuhmN4MUNozCjR482m4bJ53gMeVFZd3950blhwwbs3r1bfT5/o/w9ZWdnq9RDwu3QLzKYYcFZ9/rWyRRCfhecpGKkgBdioaGhJ6Q1shSkd+/e6mKN+8nvuKknhgRBEGw9l/Pcx3O4LtLLysrUOZzjDM+fPOeZy0LjZDPPdUzRZto0S+IIvV+YcUd4raCfbzt27Ijx48efcL6m+PXz81Pny7Zt29Y8X1lZqUrV9PMyI/8c0zhGUyyzJr1v374nRIIb2v6G1mtJpHPsryvSGflmmjVvm4p03ucYx3HZdH/5WSzv4/5yzDC9xiHcLr6nboZAXl6eGhu5b/wcHqdvv/0WUVFRtY6pKfwsTiBwrOc1hH5dw2sA/fth2Z3+/TAlnNmM9lL3uJry888/qxILlgDqMIjBcZLXA9xO/p5YRsfMPUvZhczi4zbz+PF75/HTx2+Oxbr/EOH1w7nnnltzbamv2xS+l9dIBw4cUOM6t6VuRoCt28nXcDt5vPn7lAi+h8KadEFwRyZMmGAMDg4+4fF7772XPgrGpUuXqvsPPfSQ0cfHx3jyyScbp0yZYoyKijIOGDDAeODAgZr3/PHHH8bIyEj1+OWXX24cN26csXPnzsZff/1VPT9v3jzjyJEj1Xovvvhi4/XXX6+WrVu31qzj3XffNYaGhhpPOukk9Zru3bsbExMTjevWrat5zcsvv6zW8ddffxn79++vtqdt27bquY8++kg9t2fPnlr7Y83217dec/zwww/q9fx30KBBxssuu6zmufLycmNMTIxxxowZah/5uoqKilrvt2ZfeWz043TdddcZzz77bGNQUJDaj4KCghO2nd/XkCFDjOeff75x4MCBRl9fX+MXX3xRzy+g9r589tlntR7fu3evevzSSy9V98ePH6/29f333zf269fPeN555xkvuOCCmm3t3bu3sVWrVsapU6eq7z8gIMA4e/bsWuv8+eefjWFhYcZu3boZL7zwQvWeX375xRgdHa32U6ekpER99tNPP13r/f/995+xT58+6js866yzjOecc46xQ4cO6rs/fPiw8corr1Tv43HQj92HH35Y7zoXLlxojIuLU+vhNvXo0cMYERFh/Oabb2pek5KSot77/PPPGy+55BLjaaedpj6bx5j7KwiC4Gq+/fZbdZ766quvaj2+c+dO9TjPj2TFihXGhIQENebwnMdzKsejjz/+uOY9+fn5aszmuZljCheO6dOmTVPPp6enq3GJ6+WYqZ9v33777Zp17N69W421XAfHi9NPP93o7+9vfPLJJ2tew7GM6+BjPLeOGTPGOHr0aOOcOXPU897e3sYHHnig1v5Ys/0NrbcuhYWF6nzO9enwGoHrWLZsmfGmm25S79fJy8tT22Y69nPM5BjJ8Yn7e8YZZ6j9ffTRR2t9Fh+75557aj32559/qmuoTp06GS+66CJ1bcDvkcecx15HH8cef/xxdbzHjh1rnDx5shpvOS5VVVWp12VmZtZcf3Bd+vfzxhtvGOujdevW6nu3hH5c646jZNiwYbWOEQkPD1fHjt/hKaecosZLXgMMHjzYWFRUVOu1R44cUfvD6xzuC1/L48F95TUUtz8wMNDYtWvXmv353//+V/P+9u3bq+tPU7Zt26aur3htwuPIawMe/1mzZtm1nby+4/Hm743/8rvq2bOnul33Ok9wf0SkCx4l0nmSoXDiCT8nJ0eJSZ6QTQfepKQkdTKkUNMHBJ40dcGmw0H877//rrnPdXBdpuJY56efflLPPfvss7W2hQNmfHy8GkBNBemZZ55pzMjIUI9RnFkS6dZuf33rbUikv/7662rg4KCtT0gYDAbjwYMHzYp0a/fVHMnJyWoQnT59es1j+rafe+65xqysLPVYdXW1EpF8bXFxscX11SfSX3rpJfX4K6+8UiPSub5bb7215rjxGPF3wu3mwJabm1vzfopcvv+3336rOe78vXGg1I9HaWmpmgTgoNyQSOe+8fOHDx9e8x0RHq8FCxao29wWvu+55547YT/NrZPHk4Mt/xb4POG+XXXVVWpiZ9OmTbVEOi+YTH/Tn3/+uXr8999/r/cYC4IguEqkc7KUj1Og8dxJETlq1KiasYbjxS233GL08vIyrlq1Sj1GEUMxk5aWVrMevu67776ruc/zONf7yCOPnLAtFDac+KRopWDU4cQ936NPguqir127dmps1NHH37oi3drtb2i95qA4jY2NVesjnJDm2F5WVqaOKY+HPp5ycpnr52sIH6eg5KSE6fjEAAZfZzphXlek8/WcGJ44caIaE0llZaWaEKFwNyfSeWw56V33uH755Ze19omP1Z3kqA+OsV26dFGTGaYLAxj2inRuq+nkCIMRXAevMXS4v5zs4WtNr+H4GzP9/rh9V199tdltryvSeSy5Pl7Tmn4n3HZ+vulv2drt5PfIx0wDTITbqH93gucgIl1wWyhMOFjoJ2FGCTnLyEFRF7WcoeYsYV10wb148eKaE5wecbVEfSKdJ3cKfX1wNJ2JNxWQuiD99NNPT1iHOZFu7fbXt96GRDrFo5+fn/G9995TzzHiTUFLzIl0a/eV8DUbNmxQAy8vBvg9MUrO2V0dfdt5gWbK999/rx5fu3atVfvCbeX633rrLXVxQJF66qmn1lyUcJ/4mOlFm+nnm2YB6HBbGfEmzzzzjHodow2mbNy4sebz6xPU/H02tD+2inR9mzZv3nzCBBOjKjfeeGMtkW56saRfWHCCwXTSRBAEwZUinect/VzO8yrHdEaSeQ7kpCtfs3Llylrv5QQrz2V6ZJgikvd5LrREfSKdn8/nlixZcsJzFNi6mNNFHx8zR12Rbu32N7Reczz22GPqPczYIhR8jOiajgHMvCJ33323ur9///5a1x+6mDWFmWWm0em6Ip0T/Xwvx0JTDh06dMK4o49j+jWGKRSwzG5orEjnokeq60bg7RHpFMl1YXR/0qRJNff1SY+GrsFsEekU4aYTQqa/W2ZimP42rN1O/Xpn165d9W6n4BlITbrg1rBWZ82aNeo266FpGMf2Fazj5XOsu7nssstOeB/rkQjrhugkS9d2mnbw9eecc46qNa5bY20JjiN0pWUN+yeffKLu64+zzpk1P1yvKXVroSztm7Xbb8t668J6MdZEsU6L+846ctZONXZf9+7dq9qSsU6adXysoWK9F+vWWLNWF9YLmqLXwbHNnjXOrvv27VP/0gCP+8S2M6wt42fqsHa+bg05W83xPTTL27p1q9oXfb/4Xn1/eKxZD0YHeVPowm6N8z3rGumsO3DgQDgKve6NNWWm8Fizxk9voWfpGHP/WJNo2spQEATBlbBml+Mfz8s8l/3444+YNGmSus9zGseZuudR1nOzrlY/51155ZXKtI312VOmTFG1uayL5hhgDXofcNZm04TWdFzgv6znNcXasdfa7bd1vYT7RxNY1oVzTOC/t912m3qO53keC9ah83V8jvX3XEz3l14prJM33V/9WsQSW7ZsUd9N3XGIY1BkZKTZ99Qdiwhr2B0xFjnaOM7ctvL6xHRbOb6T4cOHO+xz9d9C3c4DvN7gNuk+SbZs5/nnn6+6JPD3R38eXj/y96D/DgTPQkS64FHu7qZQNHIxJ7T1x9iui9A5liZw33//vWpZwpMYhR7XXbe3qDkjEg5iupFaXa677roTTp7WtAGxZfttWa852GKNLUsef/xxBAUFWXTQtWVfOfFB8xeKZ9OBeuLEiWpQr4up0RnRW8XQ7M1Wd3dLmDs+nDDgoEdjlrpQgOtmPtx3c98Fha41Ip3fFffJdNKgsfC74DrN9bDnttb9fdQ9xoTvt/YYC4IgNKW7e1108W7aSsz0nMdJYMJxiGZvnLRn+9Q77rhDmcXRRI2GoqbdTMzBcYGv4aR0XRgEqNsi09qx19rtt3W9hCZvND2lEKchKifITU3IeJvP0aSUk9Icr033l+MIjdzMid6ePXta/FyOjRzXzI1tnEQ2h6vGIn0beW1VFxqw0mDQnm3Vx1pz77cX/laIpWtAe8Z3miJz4olGsjQMfuihh5CZmakCNTTq4+9H8BxEpAseC09OnMnlQF0XnqT0wUeH0XMuhIMbZ+4p/HSRbk4I6Z/DWcj4+HiHzt7auv2NgRMUnGnnxQv7klKoN3Zf6VDOzAZTgc5Bh9Fqd4LRBU7OcGLGnFO7DiPofB0vcDiBo3Po0CE1uDdEjx49VHR///79yoXVHJZ+Y/VtE7sS0K3e1HGYF1yM/jAzQhAEobnAcx7HEWZqmbqYUyhyQtg0ksmo+f33368WChpGmbnwvMgsr/rOt1w3hRx7qDsyymjL9tsKBTHdvdklZuHChao7jWkWGkX6Bx98oFzMGSU3bb3GbeFj7Eluq9M394nHl2Mh3dd1OCnCbjnuBEUou+ewK40pPP50Tx8wYIBd6+X4ThiAoBC2hC1jvJ61x2vAug77vAa09/qP1y+ctOLC3/h7772ngir8bdx+++12rVNwDfVPNQqCm8NUcUZ8TaOkHExefvllJcg428xZRg6YpnBwZzoQBZA+m6nPaLMFV11uvfVWNVvPmcm6pKWlISsry2nb76jZZab7c1KioZO0tfvKQaXuBAMnAXJzc+FOcJ85K81WdHXhwK23oGNkhwPsK6+8Uus1r7/+usVoQd1sBb6On1N3Fp8XB4QXD9wWc78xc+jbxH7wdbeJ7foayiwQBEHwJNhOk+PV888/X+txThpz7NHPeRQxpudZTjBzMloXj4Tr4SSyufMt25NS5PJ8rad96/CawNzkuSO3316Yuswx9rXXXlNt0Ewj9hTpHNM4IU1MRTrLA0JCQlQ2Xd3xiffr298LL7xQ7dOrr75a6/E33nij0ZFlXndZOx5aC8sF//zzz1r7SaFqLrpuLZz04TXZM888o9qsmRvfbd0fRrf5nbz44ou1tu3XX39V5Qf2/FZ4PWMagWdWBwNSpn8XgucgkXTBo+GAw5p1itmbb75ZnUS/++47VU/GOjdGjClmOLPOWUuevHkSZS0Q+05y1l1Pj2KNOlOf77nnHhUhpuDS+6RPnz5dzYLzPoUTBT7Xy6gxP5+9v/Xe6o7efkfBixIuDWHtvvLihpMMrIFin2/2omVaFY/1smXL4C7we2d/Ul6k8HvngMW0MU7csC8vv29GFrifTzzxBJ588kkVDWed2KpVq9S/5tLM6sJZb6Ze8hgz2sHyAr0vPGv2n332WXWfdfSs94+JiVEXkHqfdHNw1p8Xe/fdd5+qI+RFGdMYP/30U/U98TMEQRCaC4z4UvxxMpmTwqyp5XjIfuSmafLsC84e3RynmLlEYcTX8JxpWs7F8Yhpvox+8pyr90lnZhIzny699FJ1XUDBFBERocY++rbws8z1K3fU9tuLLrwpxjgBbYpel07BzT7nvK/D7LgffvgBF198cc3+cvzhWMf9ZZnAgw8+aPYzOT5yHOKYw6wupt1zvOcxZMDD1gwxU/j98HtkhJ7XZo3tk044hvM48bqK4y2j34wu9+7d2+51UkzzmoyZl/yNcTKGk+68RuA1JPdB3x8GWWbMmKGOj2mf9LrwOorXApdffrn6nfC9rC+n1wI/5//+7/9s3k5mWLzwwguq7JDfG6/deF3C3z2/Y8GzEJEuuC0cfBtK92FqEyO+nHmkMGQKMAdBisfWrVur11DoclaSM6sUmRzAOKjzxK2nMBEOEIxoU9BRCHE2nYMRRTpnI99++22VMsTPosDjCZYClSdZPdLap08fNXCaE9cUY3xOr4G2dvsbWq85ONDx9aapaebgxAQxrd+zdl852PP74cDFmeTTTz9dDVx8jWnqlqVt5zr5eF2jNkv70tBvgeKbA5I5OODx2HIChL8FXtBxwH744YdrGQ1RpHNwZ7ogB8sbbrgBEyZMUBdbpgY/rFHnNtVNnWPEgUKavyH9uD311FM1x5nQwI8im9vB3yIHeIp0S+vkJAK3gRdYNP3hxSZ/p8OGDat5DY8t38tjXRduk+nFmiAIgiugULDmnM8Ja4oWnq95HqXQYYo3z606PK8ye+mXX35RgpWCiZFeTlya1k5zLOM4zklmCnBGminSCc+rHLv4OXyeEWqK3HvvvVeVohFGqs2dl3X43NChQ23e/obWawlOGt90001qP8yJP07ocnzgRHFdKH71/eX1D+vjKeQovtu3b1/zOoo50/GF3H333WqymSVhhw8fVoEMikoKSgpYHX0cM2egynG4rr8LJzR4/Hj8OWHAUq76RDoFbX1la4TjLb0GODnDcZ/HiZFwehPV/fyrrrrqhO+P8HqmrlEef0f8Pjm+8/gxYs3foGnZGcU5r/VY+8+JdV5r6t8Tr+3qlhpwQonXAVwn958BgZ9++kn9Nu3ZTl638Tjzuozr5bUBAyo0V7TGKFlwLwy0eHf1RgiCIAiCIAiC4Bkwc47BDWaJccJbEATHIjXpgiAIgiAIgiCYhVHhutDnhpl3lrrFCILQOCTdXRAEQRAEQRAEs/z222+qVItp2Exvp7ksH6NQNy0bFAShmaS70+nynXfeUcYLrBNhvc5tt91Wb90t63B4omCva9aVsm6ILaVMa30EQRAEQRAEQXAMbLtKYzJG1VkXztpnU68WQRCaiUinKReNoNhigGYMNHyiaRMdGJcsWXKCuYMODS7oys2WRDSUoisl2xfQQZlGHYIgCIIgCIIgCILgqbg0ks4e1exTqcP2SP369cPKlSuVi6Q56JRId0e2ztKhozFbLbz00ktNst2CIAiCIAiCIAiC0OyM40wFOtHbOJSXl1t8D/s7MuWGrQ8IW0GwVZK51gSCIAiCIAiCIAiC4Em4VQs29lacP3++6kNoqS6d0Xe+bvHixaq/MXsgzpo1S/WNtAT7LnLRqa6uRnZ2tuphbDAYnLIvgiAIgmAtHIoLCgrUuEbHZKHxcKw/evSo6j0sY70gCILgSeO927i7v/baa6rWnCK9PuO4N998U9Wssy9j586d8eeff+Khhx7CoEGDVJTdHM899xxmzJjhxK0XBEEQhMbDzLCEhAQ5lA6AAj0xMVGOpSAIguBx471bRNLfe+893HHHHfjmm29w3nnnWXwdZx0Y/X7rrbdwww031Dx+9tlnqxlzOr5bE0nPy8tTrvCMwoeFhTl4b5ofNPljdgON/ry9vV29OS36ON53nwEffOCFO++sxpNPuvxP1yXI71GOYXP8Lebn5ysz1NzcXISHhztsG1syHOsjIiLUhZCM9db9nnft2oXu3bvLWN8I5Dg6BjmOchyb62+R4z0nkBsa710eSX///feVQP/qq6/qFeiksLBQ1aK3bdu21uNMF6DpnCX8/f3VUpfIyEgZuK38cdIvgMdLRLprjyOTRf7+G4iN5e8XLRL5PcoxbI6/Rf39kpbtOPRjSYEuIt363zOPlYz19iPH0THIcZTj2Nx/iw2N9y4tfPvwww9VX3QK9KlTp1pMVaebO4mPj1cRi3fffbcmMs5o+E8//YRTTz21SbddEFzBzTcDe/cCjz4qx18QBEEQBEEQmiMuE+kM8U+bNk05vLPn+fDhw2uWn3/+ueZ1+/btw+bNm2vuMyWe6YWMnp900kno2bMnRo0ahSeffNJFeyIIgiAIgiAIgiAIjsFl6e5MG2A/dHPQEE7n4YcfVmnuOgMHDsSWLVtw5MgRZGVlqdpyphoKgiAIgiAIgiAIgqfjMpHu4+OjouYN0alTJ7M5/HTDEwdcoSXyzDPMKOEEFnDppa7eGkEQBEEQBEEQHIk0YxUEDyM1Fdi6Fdi0ydVbIgiCIAiCIAiCo3G5u7sgCLZx/fXAxIks/ZAjJwiCIAiCIAjNDRHpguBhDBigLYIgCIIgCIIgND8k3V0QBEEQBEEQBEEQ3AQR6YLggWzYAMyZAxw65OotEQRBEARBEATBkYhIFwQP5L77gBtvBP7+29VbIgiCIAiCIAiCI5GadEHwQEaNAnx9gagoV2+JIAiCIAiCIAiORES6IHggTz7p6i0QBEEQBEEQBMEZSLq7IAiCIAiCIAiCILgJItIFwYOprtYWQRAEQRAEQRCaB5LuLggeyllnacZxS5YAQ4e6emsEQRAEwQxGI1BefnxGubISqKjQ/tWXqqrjr+XreJ+P6+/RH9cX3tcfr/s6U7y9AR8f7Xl+pv68l5e26Ovz89Neq78nOBgICwNiYjQDGEEQhCZGRLogeCilpUBxMbBtm4h0QRAEoYnQBTGFNMV3SQlQWKgNSByY+DjFMB/Pz9eWsrLa7zMV4aai2x4otg0Gy9vKdfN5vs4U/XHT15lCcR4erjm08nUU7W3bAq1bAyEh9m+vIAiCFYhIFwQP5eWXgYAAoFMnV2+JIAiC0GwoKtLENxdCQU2hnZMDpKcDBQWaoNWj2HwdRbi5KDYj1Pqii2Q+ztuMcOu3LYlsV8J94n4nJWn3OQGxfr0m1tu105Y2bY4L9rqTAIIgCI1ARLogeCgnneTqLRAEQRA8Cgrp3FwgK0sT3UwBJxSjeXlA797At99qglR/To8yU4RyZtjfXxPVXIKCtGgzH2tuIpX7FBtb+zF9wmL7dmDLFiA0VJuA4LHo2hXo1087RoIgCI1ERLogCIIgCEJzhNHg/fu1dHQK7SNHgLQ07T7Ro9hM7abgJvyX0WJGunUx3twEuL0w8h8ZqS2cvGBWgV5fv3KldqwHDnT1VgqC0AwQkS4IHgqvtz77TKtJf/RRbUJfEARBEFQkfN8+4L//NGFOKLYZ5aXAZJp23RRz/T4Hk8bUiLcUOHHBLAIdmsylpgJ//gmcdpom2jn5wbQ3GtEJgiDYgIh0QfBQeD310EPA0aPA5MnAySe7eosEQRBOpLq6GvPnz8fbb7+NxYsX45577sHTTz/d4KFauXIl7rvvPmzfvh3x8fHqfTfccIPrDjHTw/U6bXeFZm2ZmcCuXZpgZFS8c2ctKi44P8pOYzm9TGDzZs1Mj9/JmDGSjSAIgk3IWVsQPJjLL9fGfwZGBEEQ3JEFCxbgzTffxM0334z9+/ejQhcx9XDgwAFMmDABt99+O7777jv8/fffuOaaaxAWFoaLLroITQ63ef58TQC7M7pjOqPhdBVtSJwzYs594+RDZSV8WV/NmV8+pqdxsw7b9LbeQk2/berW3tC/jCwnJgLt22vGa80xBYzHkHTsqJUVUKzHxwM9e7p6ywRB8CBEpAuCBzN7tqu3QBAEoX4mTpyoFvLwww9bdbjeeOMNtG7dGjNnzlT3L7vsMvz555+YNWuWa0T6Cy8A//yjpTDRUEzHtF+3aYq46eOOeqxuCrq5z9RT1jl7S5d2PZJr2ptcF+DHhLkOu4R3RxPD9mYU7Jxp5rbTKT0uThO1XPQ6eT6u9zH3JJjmzn1g6jsnTLp0cU8ne0EQ3A4R6YIgCIIguBUrVqzA2LFjaz02fvx4fPrppyguLkaQLt6aCk4W0NW7mVPt7w+DtzcMjHhTFFNYmt7WF9P7+m1r/uWkAVuaHT6stXPLztaWhuB72Z+cAp4Lt4k14RERWoo5zdrcNaWfkw30BWAmBrdz2DBt+wVBEOrBTc9ogiBYC4MnycmaD5AnBhoEQRDqkpKSokS5Ka1atYLRaER6ejo6dOhwwnvKysrUopN/TFRXVVWppTEYWFvEtlsUhnrLLXPGa/pjps/Z8lhj30/0VmlBQTDqkVyKQi66sOY+6I8du13l64vdHTqg26FD8G4K4zgK9sOHYaBg13uv5+XBkJLCH4CqqTeY9mpnGj4XMxh790Y1TVpMjdxcRNWx70H/V30vTPHnPq5bp5UjDB8uA3ZDx/HY32xj/3ZbOnIc3e8YWrseEemC4MHwmobXqrzG4fWjlLwJgtBc8KrT9ku/T6Fujueeew4zZsw44fFdu3YhhOnSjeHWW9FS2M3086aiV6+GX1NVBd/0dPglJanF9+hRGCor1eKTkYHQZcvgvW0bqu6/H4dfew2l3Zs8ad/649i377Endzf59ngqu+VYyXFsZr/FQr0FZgOISBcED4YT9Mz0Y3CB7VlFpAuC0BxgPXpGRkatxxhBNxgMKqJujoceegjTp0+vFUlPTExE9+7dleFco2CE/vvvAW6Tp9UU191evTe6aeTeywtV3t7YPWIEuq1bB29Ge/VJEk6KsHa9Tg17zboZidcXRu31tHP9cxwFv3cugwbVfvycc2B8+mn4HT2KzpdfDuNtt8FIR3tG1V0QWWcEnQLdYkYCMzzYq15viTdunObAL9Q+jlVVShR169YN3pImaP/vUY6j2x1DPcurIUSkC4KHM3eu1p6VY70gCEJzYMSIEcoozpQlS5agb9++CLbQc9rf318tdeFFVaMvrCg+R43SxLq7Y5r2ztvcd9PUaz6uL3XT5lNT4T1lCrz1mm9CwU6Bzt7r3H89BZ2CnREh1pTn5WlGdWz7prv36ymd/Hy6uOt12JwwcaToSkgAXnxROakaNm2C4aWXju//xRcDNBp0gcijQDcr0nksdFd71qovW6bdZ+264Jy/X8Hhx1FvDMGFpwjdx1JvBqHP6emnAf050wYRdR93Z8LDgawsb8THN/4YWvs9iEgXBA+H1yeCIAiezA8//IBLL70U+/btQ9u2bXHrrbfivffeU+7ud955J5YuXYovvvhC9Vp3GWwZ1pzhVTJFNgVj3YtICxMjtaCAZ921LuJ5n8KdBnEUo/qVO2vRmQLmSFjO8MQTwOefA4sXayqA2/LVV8CWLcD992smc+4Gj8O+fcDffwNnn908W9IJHgdFN+ffGPDlojeK0IU15+v4OP/laYOv19+nJ97o3SCtSaYxZ/HhTvB0yIQXJlI15VyaiHRBEARBEJxGWloa2h+rzy0vL8fOnTvxyiuvYNiwYUp86+mENH3T68179OiBn376CXfffTceeeQRxMbG4umnn1a90gU3hVkMZjIZFHqojOYpf/1Vu12cI6+kr75aWwiFLyd1tm4F7rkHuPtureVbdLTl7XQFNJbZswdYtYotDNzXpV5ollCMcx6NXo2cS9Mj3RTlXHQBzj8vPfmG//JPiMkx/FdPutGf0xs61LEV8VgMLppAkDOBIHg4vNZ55hlgwwbgnXe07jSCIAjuVF+em5tbrzHc1KlTUVJSggCTup0JEyZg+/btqK6uPsFETvAweNXOhZM1THdnGM7Z9eJjxmh9yTlA0rjl4YePR93vuktrheYO6MeFkwlUPMxaYA1bx46u3jKhmUEBzg6ITN5gFJyR8cxMrVpF/9PQK2GY1MGuh1Jp4DpEpAtCM5jhY0bfjh3ATTcBEye6eosEQRBqYyq+zUERbuk1ItCbEZGRWuSYA1ZTmLqxHuz554HXXwf+++94Hf2zzwJTpgBXXukekevAQM0Ub+NGbRsZ8Z88GYiNdfWWCc2EgweBzZu1bkCMjvN0y+tHzgnRt1DEuPvhBmcmQRAay513arOi4u4uCIIguDWMbm/bponRphDIDAnqUXSGDj/5BPj5ZxohsD8fcN99Wgq8q2HNvF43z/T31au1WXfdcE8QrIACnOnrvCZkpiWTmPgT+v137T7nrdyp2kOwjIh0QWgG3Hyzq7dAEARBEKyAKoF1WSyCTUxs2kNGtXLDDVp/9tde02rkmfrOmvUBA+A2MP2dPZl5rAYOdPXWCG6M3kAgJ0eLkvNnww5/un8jU9dPP10zPBNx7lmISBcEQRAEQRCaBiqFIUOA337TbKOtcY53NCefrKXdz5oFHDgAPPmklopGEc/oNZ93Jew5z9KATZu0XGQX9HsX3BvWkTN9nWnspKREs3pgXTlryVlBYWp6xvR2cx0BBfdFnFgEoZnAVrVLlmgnakEQBEFwWyg8+/TRXKx0++impk0b1VsdEyZo6oVRdaoePsbbrob16HT1oqGcIOB4xQbtFebNA/7553g/corz7t215AtdoAuejUTSBaGZwOsdZg+yi8uIEa7eGkEQBEGwAHNwGU1nXi6tpjt1co1zFaP6t92mtT5jIe+KFcCaNZrZ3CuvuDaCzRAoQ6IU6VRfdHwXWjS8xqNVwf792k+TPwt37i9uCbZ2Y3o+JxdWrgT+/FO7794x7d645x6jOjU0FSLSBaGZwHI6pjPprTQEQRAEwW2hyjjjDGDxYs0ojQMYhTpdzpu6eLZHD23hxMH06VrD6JdfBh5/3LXNnunyTnO7vXtFpLfQlmmcO9LN4Nau1bIl2Z2PFRGeBv/MaWC3fPnxmnnPwHDs36atFxCRLgjNhJ9+co9OMoIgCIJgdUr3mWdqtddlZVp7tEOHtNpwpqM3tbM584QfeAC4916tHRpzii+8EC6F7vQ8JkOHunbCQGgyWH2RkQGsX6/Nz1CkM82dTQj4Z+EpEwxMx6eRHfeHDR14WycoSMsCoEfi2WcDvXvDbTEYqpCYuBsBAd2a9HPlkl4Qmgki0AVBEASPjKiPHn38yp65vP/+q/1LUzlG13UjtaYQqTSUu/FG4I03gC++AI4e1bbjnHO09POmJixMM51hLy1G1oVmBVO++RNj8oZeX06BzvRvpoXrLdMoaD1hjoaR/kWLtC6HqaknXqeOHAmcdZZnpeobDExkqWpy+wwR6YIgCIIgCILroSDv2hVo105L8+bCK2NG2BmGYyiRQtXZ9evsWcXQH91YqTgIw5ovvaSFAJsSThBQxdFETkS6x8K+5RThjCrz50wRzhR2/avl/BRFLAUhKz84N0OB7ilwHokNG+bP1/ZPTwKhKOckA3+6Y8cCERGu3lLPQUS6IDQj7rhDu56YO1czkhMEQRAEj4NX9SedpC2EvaXouM6FRnNUOlQzTIenmuGVvyOFO9d9++1A376a+vjjD01NvfmmlgrflCFAfhYXhiW7NW26rWAfesSVyQ/JyVr/cgpyvQ6bgp2inD9ZurLr0XJPgvvzww+akR2j/+ymyH0i7Mk+eTIwbpw24SDYh4h0QWhG0AR2xw7NXEREuiAIgtAsoBAfPlwTzWzbVlCgCXUKaIpn1mzTId6RcALgtNO025wseOghzfGK28A6+qaEIUkqPV3ZCW4nytmogPMo/JoozvXUb/5UaXXAr1BvFkBvxKa2W3AUnGD46istnV0X5Tr0XpwyRbNPkJ9p4xGRLgjNCF5D3HMPcPLJrt4SQRAEQXBC6jeVQF3L6F9+ca6A5WdedRXw0UfAnDlaQS0ttpsKqjsWKmdlaQpPcCmcHzp48LipGxM9KNDpfUhBrvcp59wSjd48pfbaEnpfdkbL9Xp5fe6Kopz+j8wEcIVlQ3NGRLogNCPYzUYQBEEQWgxUQVRDVEo0l3MWzN/dskWrTZ81q2nr06n6qJD++ktTfIMGaRMFQpPD6DizFTdv1uaFGBFnLTkFqi7OmwsU4x9+CCxdWvtxivKbb9Y6FgrOQ0S6IAiCIAiC4LnRdRrNsV7dmSKd1tr/93/awhT7117T2rU1VZg0MVET6sw3/vtvTRFyv4Umg4kMFKyMoLdtq80NNUc4+UADuM8/1xzm+RNnhQfnhpiswnZpUmvufESkC0IzgxP9K1cC48drJrmCIAiC0Kxhs2UOfsw9dmafKqqy++8HHn4YWLVKywGeOvW4uZszocMYF8JcazrPs5dVTIxzP1dQsEUajXmZ7t2li+fWlFuC+8WUfYryr7/W/BkJ9/WWW+R60hWISBeEZgavHX79FXj1VTmpCoIgCC0A2knTmYsuXbo7l7Ngffq0acDbbwOffqotFMr33Qf07Ikmm5RgOHfZMmDixOaXZ+0mcM6HUWWawi1cCOTladdVnl5jbs4I7qefjrvS6wkqV14JTJjgfBM4va6ftf7uiJeL+tOLSBeEZgZbXtC8hGV6giAIgtDsYYSb+ccM/zlbpBPm/jLlnRbXVBZsdP3ss8ALL2gTBs6GKrFDB21/2QOLjvNUUtJH3aEtxlhVwJ7fbJ3GhV6BzUmgb9igzTVxXwmvG/kz4lzT5Zc7t3rEFH4+27i5axs6r2Mi3c+vaT9XRLogNDPuvltbBEEQBKHFwB7iu3ZpV/t08nImVGrXXw9ccokWinzmGU0wP/WUJtSbAuZbsyadSov1+FQ4nKXv3LlpPr+Z154zcs707+horcqA80CeLtCZaPLFF8crQ5jCrxvB3XST1jrNFTBDYdQooH9/uCVVVdqfd1OXkIpIFwRBEARBEDwbCla2J2NUOy6uaT6TOcFcHn0UuPdeIDkZXi+/DLz3XtN8Pt3lqRw4McHI/saNmsFcU4f8mhH05mPteUqKVo/tqlRnR8Jkj+XLDXj3XU0Q63DfzjkHuOwy11VMMFOBP2Mmhrjrz7aqTj/4pkJEuiA0UzhmM+2d1w+CIAiC0KxhJJl5uosXa/2wmjLsyXArDWEefBCGf/5B3IsvarnRnDhgmNKZMD+ZS0ICcOCAlk3A9HfBLjG7bp3my8fEjOYg0GkI98IL7bB0qbYznMNhKjuzA/hn4ure5tw+CnRn/5l4IiLSBaEZ8vjjWsbdY48BDz3k6q0RBEEQhCaAwph5yYcOaWE5Gro1VXiOEW02j379dcTQTI4w7f7JJ4GTTmqa9Hea5zGazuOgO8ELVkXP6WrO2mj2P+d8h7PN0pydrl9RAaxfD3z2mRdKSsLg42PEhRcacMEF7uFMz2POYBK3kxMinl5K4AxEpAtCM4TXKCUl2mAjCIIgCC0CGqf166cVEzOVbP9+TTw3leI6/XRUl5SgdM0aBGZlwcCc6eeeA55/XlN+zoZh0d27gT17gAEDnP95zQAKxT/+0NLbmdbMOR3OdXiqOH/9dW2e5jgG9O9fhGnTApCY6O0228m0e6a50++R0X3hRESkC0Iz5IorgLPP1mYnBUEQBKHFMHy49i97Ov32G5CUpOXTNhHGyZOx/6670HP3bng/8giwcyfw9NPAG284P4TJ/OyICGDrVq1VnLRmaxD+PA4f1kz5+fW4a110Qyxfrjm1s8abPwNWf1AEX3hhNW655QAOH+7pFi3OOBHCFHcaxelNCdzV1d3ViEgXhGYIPXOayjdHEARBENwypeyUUzShzsh6Uw+KVHsU6XfeqYVply4FTjvN+Z/L4l72UGcWQe/ezv88D4ailXMoTLX2NP8eNhXQW8Tx6161SnucZnfs8KNHpw0Go1vV1vNPgRMiFOicRBAs40ZfmyAIgiAIgiA4CCoVhuxY/0XX96aGPdsnT9Zuf/+91vfK2TA0ScX5339ac2/BIozo0mvP1eZp9kT/77kHeOstgPYHFOgU4uwIOHu2+6aPswUc/xQHDxaBbg0SSReEZgodSufO1cxur7vO1VsjCIIgCC6gVy9NrDIfODtbE8p0Y28qO+kzz9QG4+RkbWAeNsz5n0nVKU7vDcIINA3M3FXUmoMJGW++qUXSIyOBgQO1NP3TT2/6Pt7WwD891v3TmC8nR+vF7o7b6Y6ISBeEZsqGDZrD+xlniEgXBEEQWjA0k6OpHM3kWKtO2+t9+7RadWebyjGnd+JEYN48LZreFCLd1Omd++ipTmhOhHM1bALAZAdPgGL3/fc1kzvChgGMplOouyOsPT9yRHNvZ805/8yY1MJJBXdKv3dnRKQLQjOFJ8Mbb9RmVwVBEAShxcKiY/Ys12nTRousM5RKEets56pzzgF++gnYsQPYvl2L7jdFNJ0905n23rmzto/uquhcAGu5OV/jzvMXFLqMmDMB5KWXtHkl/pQvukhLbXfHNnG6MVxurtbQYMgQrRMihTmPtbRasx4R6YLQTOE1wLvvunorBEEQBMHNoHMVo9vLlmmimX2gnKnWGMUfNw74808tmt4UIp2qiGZ5q1drmQNM8T//fHF8PwZTr5nq7q716GvWaG7t3E5TL8Tp07VotDuZ7zErgQttH9hajceUHondu0vteWMQkS4IgiAIgiC0LCjKqST0tHCqC0abuVANOZrzzgP++gtYu1br+WUa2XcWjJxzXxjeZG43849p/y2oSC+FpTtFoyl4mWzBhgRM9DCFbuh0bWdU2h1gGnt6upaNoLet41wUOyDyJybO7Y1HRLogNHPoVcNFbx0rCIIgCAI0Qc42bVQ+//6ridmjRzV3dEerN+b+sh6dIVJacDN6P3o0cPLJzv0quB9cGFmnmZyIdEVamut7otNMjW3UFizQ5lCI3gCAaeFTp2qp7T4+ms2Au8BtZOo9f9L8+eoTBxERIs4diYh0QWjGLFmiZdix5I5jsyAIgiAIJlC8Mv2cC8OCX3+t5UE7I5rOdHOKdEbSuWzapDmAhYQ4/ythmJNKkMXYTfF5bgzdxlNTXXcYDh4E5s/XBDpbkpkSEACMHAlMmuS+LuhsAUdbh7POcs6fiaAhIl0QmjGDBmkzxRybec3B4IAgCIIgCGZg6jtTxLOynKM+WKT79NNASgrwyy+a2vn9dy1c6mxoY06jPKa8cztaMKxs4FwFy/SbIi38n380/z5GoDk3s3Pn8eeZUMEufcx2ZMScP0FXR/jNweNFAzsmmzAxgxMJItCdi4h0QWjG8ARK0xGpDRIEQRCEBmCOMXN4qaSc2Q6OS2Ag8OKLmlifPNn5DvPMGGDONPOUW7hIZz06U835VTsjSk8hy2svWhBw4eeZQpHLygd6FzKRwt0dz5lgwsyDbt20nxAnFpihKTgXEemC0MwRgS4IgiAIVsICWzp4cXGmemIt/Gefae5bixZp+c3OhqFjRu+pIFtwOza6kPOrdeTXu2eP1mVv5UpNpJvCQ822uIyS85qMddzMcPQEGD3n8WKkn4s7Ge01d0SkC4IgCIIgCAKheqKSYrGwM2e5qXboDPbOO1pbtgkTnK+AqBJpjEc32RYq0tk6nmb+jd19inKKV0bkGS1nJ7+6MGGC0fKhQ7VUdk+Cqfmcz+FEBicYWD7JZAyh6fCwn4wgCLbC64wrr9Rqotjao4X7xQiCIAiCZWhRzVqxggLnp6KNHw989ZUWTV+xQnN7dyZUXNwnKszevVuM6mIZPgUn68O3btV2OzbW/vVRkD/4YO3HKMJPPRU491wtHZyf4Y615dZQVqaZ28XFaQkfktreAkV6VlYW3nnnHaxatQo+Pj445ZRTcNtttyGogZNiUVER3nzzTSxevFi9dtq0aZjIqSpBEE6AZW9sy8qJc/5Lt3dBEARBEMzAaDaLlem83rq1cw8R69DPOQf4/HPgu++0kKWzC5SZzk/juowM5++fG8DdZKSbLddYT805mMYIdMKvivDwsYKA8x2sVmgKIzpnp7XrsNkBzeHoNyi0MJFeVVWFwYMH44orrlDCvLi4GE888QR+/vlnLFmyRIl2cxQUFODUU0+Fv78/HnzwQSXSKdijoqIwjC4MgiCcwOuva4PH4MFycARBEAShXlq10hzAnF2XTqju5s3T2qN98okWvmTRsrOss/VUfkbTmatNFeYpBdI2wt1btkwToD17Ouar5Ne0fr22rhkztFZknn6MmGnAn8WIEVq2JSczunRxr97sLRGXiXRvb29s3boVwSY9obp164Z+/fph7dq1OJknKDPMmDEDGRkZ2LlzJ0JZWwOW8UxAaWlpk227IHgaNI4VBEEQBMEK4uO1+m2mvDu7zxRVEXtw/fCDVptO/v0XeOgh530mRTn7tRNadjNHu5lRXg4sXw7s368JTkfNtehfEQWtJwp0prIzq4DmdpyHYuIIfwIM4nB+SHAfXJrubirQScixYtly/mVZ4PPPP8fVV19dI9B1AgICnLSVgiAIgiAIQouBrmLt2gG7dzdNM+gLL9Si25wUoD04BTQN3pylApnvzYUu76yHZzi1mbSCKSrSTM9oDsfe5KyndpRpG1PnGZkn558Pj4KxTP6kKM7bt9fS/inQeXwSE1uMPYFH4VbGcc8++yzi4+MxlDaIFmrY09LS0KNHD9x7773YsGED2rRpo0T7GWecYXG9ZWVlatHJZ8O/Yyn3XIT60Y+RHCvPPo40jvv7bwPOP9+oZpU9FVcfx+aAHEP3O47yexYEN6NzZ80hjH/fznZdZ5Dq1lu12089peVT//wzcPPNzv1cBrzoEJaV5fEinZUJFOZMQuBXxvkOWgs4MobHr4Tr7tsX6NoVHnNcCPucc96J205hLq3U3B+3EemvvfYaPvvsM8yfP9+icZye0k6Bftddd+Gxxx7DP//8g7POOgsfffSRqm83x3PPPafS5Ouya9eumui90DC7OaMseOxxvO++9li1KhRFRUdx6aXZ8HTk9yjHsDn9FgsLCx2yLYIgOAhadDOinpvbtI5grE+jSGfv9Msv14S0s2CImWFnFm0znOqhUIhu3qylt/NwcaE/niPd1XmK/vNP7TY753kKnH/p2BE46ywtgi4Rc8/BLUT6e++9h/vuuw9z587FeLajsEBkZCQMBoOKmj/++OPqsXHjxqkLJIp8SyL9oYcewvTp02tF0hMTE9G9e3eENUUak4fDCA+PMT0D6CUgeOZxvOgiA+LijBgxojV69vRcR1dXH8fmgBxD9zuOeoaXIAhuAksyGU1ftUpTOrxebIqi3ZNO0lTVgQPAH39oqfDOhEqWedBs6u2h8FCxgx098CjOncGCBVpFAoXuwIHwCNhyjhUNhFF0EeiehctF+vvvv4877rgDX331Fc4777x6X8sIe8+ePVWKuylMkV/Bv04L0AmeS114USUX+dYjx8uzj+Ndd2kL0DyErfwe5Rg2p9+ijEWC4IYwN5jFu1RnrBNn6aSZ60mHQoczXg+//DLw22/abWfabDPszFzoptg3J8AkWyYeMJruLIFOsfvLL9ptfh3ONvxvLDSGy8vTzPPoai94Ji61Cfjwww9V+zUK9KkWckeYqn45032OcdNNN+G7775DKk8oysQhQ0XgTzvttCbbbkEQBEEQBKGZQxd0RpiHDNFCkYw4NwWnnKJ9NtPQmcPtTHQXe36WB7Jtm9YWjfXnzmLpUu3wsOqBrezdGabl0zxv+HCA0shCsyzBA3CZSM/NzcW0adOUw/vs2bMxfPjwmoW90nX27duHzSw0Ocbtt9+Os88+W6UXnnTSSejYsaP6l+sQBKFhmFV7+LAcKUEQBEGwCmbKMA2drmH1dCByGIycn322dvvHH4+7fzkr3Z2hYg8U6dxkmsVRPDvKwb0uLNlndzxyzjnu3TucP5PkZKB3b02cc26pKe0UhGaS7k7DtpVsM2GGzqwBOsbDDz9cy1DHy8sLb775pjKCS05OVrXl0fILFASr+PBD4MYbgSlTgG+/lYMmCIIgCFah96pKSdEKk53NhAnAN99o7usMVvXv77zPosJNStLUnQexZYuW1s0+385iwwbt0AQGal+Ju6e5UxINGuT+KfmCG4t0Hx8fFTVviE6dOpl9PCYmRi2CIFhPjx5aIIADjiAIgiAINghZpr4zFa0p6reZhs58ZdalM5TrTJHO62m9FZuHBL7Y3n3HDqB1a+cIUh52CnSm0pMzz9S8BN0V9nBnu3v+ZNiUQPB8pHW9ILQgmPrEAYf+N4IgCIIg2ABd1xlRb6radLZjoyU3m3/TwtxZ0LmedekU6m4Ok2vZFW/rVu02ff0cDVPG33tPM6Sj+GWKO1Pd3S21nfZc7AC6a5cm0MeNA3r1cvWWCc3G3V0QhKaDAw29bwRBEARBsCOazog2o+l0fGcOtDNhyzcWF7ODEWvT777beZ/F/mUMTdPR3pENxh0IU9vpss75BIrS+HjnfI5uA0DBy8g052bcKXmXPz3+BOktOHKkZpnA2ybVwkIzQES6IAiCIAiCIFgDI+ldugA7dwJduzq/+TRNZCjSly1jL2It6n3++Y4X0nrKO0PUFOycIHCz/G5GuBk9pjVAq1bOmUtgX/HFi7XbV13lXpFpmtjREoETFH36AEOHauJcaJ6ISBeEFgZnoh94QEvjYtq7sxxRBUEQBKHZQVE+YoRmLU6DF2ebyHEigNFtuqSxUJqEhDg+/5qpdqyzX7JECyPzM884w20cyLhJe/cCAQHaXIWzYKS+slLz8HG1QOc+s50a/6Uw5wQCJyfGjNHM8pw9PyS4Fvl6BaGFwbGdhrE0RGGZmyAIgiAINkBztdGjtTxjFgSzMJima87irruAyy7TJgf0xt3OgPVwVH9t22r7xNC1m8DDSysAZ/raUQjPn6/dnjoVLo2Y06mdPy0GVlh7z4AKa86ZRMEJBBHozR+JoQlCC4PXFM8/r83G9uzp6q0RBEEQBA+EEXRaftPFjEXCbNhN13cKXEfDAfuSS7RQ6j//aAKairVNGzhtNp8qka3fuD9uoAiPHNGiygkJzvuMP//UPoO7zFTypoSddxgxLy3V5kZYfUBRznp4pvVTpDOLQGg5iEgXhBbIDTe4egsEQWhp7N69G9u3b0d8fDyGDh0KgxVptBs3bkRSUhKioqIwZMgQBMhVquBOUEHpUFX9/bemsFi37gzYW4tt4JgGxxp1CndnwQmAffs0hzJn7Y8NkWXOSzizRL6iAvj55+M2AE01L0FxzjpzTg5QiLPqYMAArRsPrQGElouIdEEQBEEQnMrdd9+N999/HyNGjMCWLVvQtWtX/PbbbwhlL2gzZGRk4Mwzz0RqaioGDx6Mffv2ITMzEz/88INahyC4HUwTZ8hTdx2j6iOONn5hmj1FOlPeL77YeTXjdK5naJeO78wacGFtOt3cme7ujHZrTCWnV96ePUBmpjYPMnYsmgQmYNCrj/Mh/EyKck4OxMa6RfKC4GJEpAtCC4UGLAsXAqNGud4cRRCE5suvv/6K119/HWvWrFGCOysrCwMHDsRTTz2F51l7Y4ZXXnlFCfRdu3YhhKm3oE/WObj33nuxcuXKJt4DQbASRpzp6sXiZqajM/2dZmy0I3eUyB0+XJsMYP73/v3O7bvFNHuqSKpXKkcXwbpsHlIazjua557TPPl0zj1Xi2Y7G04OMOmCHf3YRs3NjPQFN0DmaQShhfLII8AttwDffuvqLREEoTnz+eefY9SoUUqgk+joaFxzzTXqcUuUlZUhJiamRqCTjh07ory8vEm2WRDsRnd7p/MYHdj5G+asOHO2HQGtzZkLTZjy7kyY6cI8bE4GuJD8fC2oT08dR8IuehToXC89ek49FZg4EU6B28/UdiZYsIKAJf+se2cEXQS6YA6JpAtCC4V+Nxwk2N1FEATBWTC9ffz48bUe69u3r4qUM4WdYrwu06dPx5IlS3Dttddi9OjRKt39l19+waefflqvsOeik88re1XzWaUWoX70YyTHykHHkTbkjERTpNMynKFTRxUZjx4N75UrYVy2DNVXX+149WoK/z5ZEM7G3E3oCWH6e2S3O1YNODrj/scfGas0YMyYavzf/xnhLPjVM7FC3wf+LFh3TksDprU78/Qkf9fudwytXY+IdEFooVx7rbYIgiA4k7y8PGX8Zgqj6SQ3N9esSI+IiFC15z///LNKj9+7dy969OiBRKYNW+C5557DjBkzTnjcNGVesM7gT3DwcXSwVbihTRv0eP11eGdl4XB2Nor0yLoz0E3jDhyAq44jTx915vkazeHDfli9WotS3H77PnTocHyCzxlwjsMUJgWxxVpTIX/X7nMMCzlrYwUi0gVBEARBcBr+/v4nXJTo9y25tbP2fPHixcoNngLbaDTiqquuUnXpjMyb46GHHlIReNNIOkV99+7dERYW5tB9ao4wusOL0G7dusHbmZHZlngc16wB1q93aP24gbXpf/2F9t98A6Oz68Up0JkP3lSOaibHsX37bpg3z1tFoR1pHPfWWwYYjQYMGmSEj08nVXrfWFjRwKg/T29Mb6+s1EzhGDXv1Mk13nvyd+1+x1DP8moIEemC0MJhfRQHJ0l7FwTBGXTu3BmHWYRpwqFDh5RAZzs2cyxduhQTJ06siYCzXdv555+v6tgtpchzMoBLXXhRJaLTeuR4OeE4MhRMxUbl5kiX97/+gtfy5dp6mWVC1zNnKEHWpvNvmOUkrIlvQgoLvZGf763ErqMOH43oFi3Sbk+ZQrHeeOFF9/n0dK06oHdvLY2dTvE0/XeHzpHyd+0+x9DadYhIF4QWzObNmlEKx1+6jLqww4ogCM2USZMm4cknn1Rp7+Hh4SoqPnfuXNViTb9YSU5OxooVKzB58mQEBgaqCPgOtn4ygff5XN3UeUFwexgCpmU4c5zpzO4IqASpCOm8/uef2mOcbXdGuxZuP83jaGRj2hu+idqvMZhgZv7Nbn7/XfsqunShP4Z96+D7eTg4ccBWaryO4vUUvxZJ3BEcgYh0QWjBdO+uTe5zsGE3l4QEV2+RIAjNjRtvvBEffvghzjjjDOXqzij5pk2bVEs2Hd6+9NJLkZSUhISEBJW6ftppp+HKK6/E2LFjsWfPHrz66qt49NFH4SUNhAVPgyKXEWg6pTtKpHOC67HHgHXrgI0bge3btd7pzhDpeuSPFwouEOmOhMkAv/2m3T7vPPuDE0xrpys7Kw0o0FkNYCbBRxDsRlqwNZLK0kpUVzqorYYgNDFMwWI0nbPBItAFQXAGQUFBqrc509Upxjt06KBEei8TMcHI+cUXX6xeS+jozsh5p06dsHz5clRWVuL333/Hww8/LF+S4HkEBmq5zxTpjoSC+aKLtIWsXKnNvDsDOtMzms6wdhOgN2pITXVsFH3xYq2lGx3W2Z+8MdvXujUzhbQIugh0wdFIJL2RVFVUIfdQLmK6y/SZ4JlILbogCM4mNDQU999/v8Xnhw0bhq+//rrWY126dDHr1i4IHgmLqg8dcs66+/XTRDSLrTnzPmiQc7IBaGAzb56mmlkT76TSk9JSrWsds/04L8BItSNgavqvv2q3Wb7fmPJiZiA60shOEOoikXQHkLMvB5VlTpq5FARBEARBEDwbRtIdaRxnCtWmHhZetsw5n8E0fYaLGYbeu1dLwXMStKPQvSbpLemouYBt24CkJG2OobEt3fhVMt1dEJyFiHQHUF1VjcydmY5YlSC4hLfe0tq4/vyzfAGCIAiC4DTzOD2P29Ewsk3o9eCsz6BapmpmPzRamTsBzgH8++/xKDXL8hxlakvDODJmjGMEdhMb3QstDBHpDiLvcJ5KexcET4Sz1vSe0QcwQRAEQRAcSHS0lpJuZY9km+nRQyu0ptU4B3RnwtaINJFjY3AHs2WL1s6Mh8sRMOLNunb66q1erT02cWLj1smyfM5TiEgXnImIdAeSviUdBSkOtqEUhCbgmmuADz8EnnhCDrcgCIIgOBxG0du3d55IZ7iZDmbOTHk3Femsf3fwvnB1DBrQMd1RTRxoFHfjjcCDDwJVVdpcRqdOjVsnExWYMi8iXXAmItIdCHu/Hl1/FCn/pijXd0HwFOgxc+21WhabIAiCIAhOgIMslaKzatNHjdL+Xb8eKCyE06A6LS7W+pA5EPrS5eRo5fuOgIf5xx+PzyvExQGXX9749ert7kWkC85E3N0bQVVVlWoNc2DpAURGRaJ3r97w8vZCfnI+Co4WILhVMMLahiEoNgjevo2wkBQEQRAEQRA8G4aI9X7pVI2OpkMHoF07zXWNtemnnQanwDA3FTDz0hsbljZJIaexG53cHRVF37VLM9SnoH7vPccdckbSWbnA5AhBcBYi0u3k+++/x1133YX05HR0QAf1WEx0DKZNm4YRJ4+AsdqIwtRCtRgMBviH+yMwKlAtQdFB8PYT0S64F5wUZ036zp3Ao4+6emsEQRAEoZnBEDEd0ilunSHSmfLOaPrnnwNLlzpPpBNONrAufcgQh6yO8wqsHWdFgKP44w/tX1YBOPJwU6Q7KtovCJaQdHc7BfoFF1yA5OTkWo9nZWVh5syZWL3qmDOFSRp8aW4pcvbnqHT4vQv24uDSg8jYnoHizGL1vCC4mowM4MILtbr0TGlWIAiCIAiOF9GMdjMV3Vlp73rKOx3YmDvuLKh6ebHAGX4HsHu3dngcFZ3mIV6xQrs9YQIcCqP+0iNdcDYi0u1IcWcE3ZywNkJ7bM77c1Rbtvooyy9D9r5sJK1Owr4F+3B0w1HkH8lHdaXjnTIFwRo4ez11KjB9OlAplgqCIAiC4Hhat9Zyug8c0FzSHO2QzsLrbt209a5cCaeKdCrh3MZ3NuJcAiPprAZwFDSMY+0450S6d4dDkR7pQlMg6e42whp0PYIegABMxmRUoAI5x/4rRjEyMzOxbfs29O3b16p1VlVUqRp2LgYvQ00te0hciLovCE3FvHlyrAVBEATBaSQkAOeco+VML1qkuaQ7OneaPdMZmmbK+9lnwykw5M1sAFqyt2nTqFXxspqrcZR5LUX0ggXa7TPPdFyfdVMCAx2/TkEwRUS6jaSkpNTcbo3W6ImetZ4vRzmykIXDvx9Ga6/WiO4abVP9uWktu5ePlxLr4e3CERARYOumCoIgCIIgCO4EXdF0UZuYqBnBOFqkn3IK8MEHmnMaC70ZXXcGVL+NTKlnwH/PHq3E3VFimj3Rk5KAgABgzBg4PNWd8xPi7C44GxHpNhJvMs2Xi1wsxEJ0RmdEIAJhCIMf/BCPeBSsLMDilYvh5euF2N6xaDOoDeIHxSO0bagykrMGpr7nHspVC0V6ZKdIhMaHSnRdcCqcgeYA5+Pj+BQxQRAEQRBM6sy2btWUqqMszQlFP7M5N2/Wounnn68N6s4IJ6elNdoPh/Ev+uk52jCO5fmOFtPSI11oKkSk28ipp56KhIQEHDlyBHnGPKzCCgzDv/gPITiMMEQgCh2CO+D0fqcjc3umMoxL25Smln8/+BfBccFIHJGIxJGJiOoaZbVg53pSNqYgIyADEe0jENEhotk6xKdvS1f76Bfi5+pNaZHMmKEt112nTcQLgiAIguAEGPhhbXdBgdbTy5FQoVKkf/GFtjCkTNMZR4t0RtL1xuE2sHevFujnW0tKGi+m6aUzd67Wul0vxXe0YRxh9zxuq0TSBWcjIt1GvL298eqrryp3d8Jk9xdQhEIUIRJp8EEAIntHwmtgCsbcOAaGIj+kbEhRS8a2DBSlFmHnDzvVEtQqCO1GtrNJsFeWViJzVyay92YjLDEMUZ2j4BvUfBo1lmSXKBf88sJyJAxLcPXmtEg4rvv7a6VmgiAIgiA4CQrztm2B/fsdL9JPPhn45hsgPV27//ffwGWXOTb1nUqVoXAWlNsQCqeg3rhR62EeHNzoknbFkiXA118fv9+lC9C1KxwOLQR4aJ2RmCAIpshPzA6mTp2K7777DrfddhuCUtOxCAYUoAo0xK5EKf5Y+wfuXfsHegB4rE17VJwyESMvHolh7YYha2sWklYm4ei6oyhOL64R7MGtg9FxfEe1BMcGN7gNdI/PPZiLvEN5KoU+uls0/II9O/LMevzUzanqdlF6kVpooic0vUhnVxVntHAVBEEQBMGETp2Ou7w7MuWd6vfdd7Uw9axZWlSdlucU6o6CRd+lpTaL9KNHtaVjRy0o4MgUdwpoivORI+FwmOpOcd6unePXLQh1EZHeCKE+efJkLFmwBPsXH0BEZAT+iArD5j2bsXH7BnRf+D3Cqyrx59FD2DX3Hbwz9x2M8vPHtOjWqDj1LJz62iUo319eI9iL0oqw9cut2PrVVsQPiEen0zuhzdA28PatP6WdreDyk/NRcKTAJrHOevfSvFIERTu4WKcRMHrORYcZAyLSmx4OQCLQBUEQBKEJoHkca8iZNh4d7dh1e3trA/pppx0X6Zdc4rjJAD0DlOFlG9i3T5uTcJRAZ+o8zed4/XLLLY5PStDJygJatdK66AmCsxGR3sjUd9aoJ1Yl1jzWIaEDJo+djKJbnsTGf1fgmpxMrNy8Cqs2rcLkvGxckXIYn859G2O+fQcDegzA+OHjMfbCsfA64IV9f+1DxtYMVXvOxT/MX0XWu0zqgpDWIVaLdabBx3SPgU+A5a83fWu66svOlPKgGPcQ6mxFV7cOn+n99e2H4FyKi7WSM2e0LxEEQRCEFg97prOv+dq1jhfpOsOHa6npTH3ftk0zlXMUtDpn+p2VUM9TVDvDKI5RdGcJdMKEgcGDJdVdaBpE/TgLLy8EDxqFKQCmnDYV1dXVyP3tc2xeMBerKithPHoQG3dsRPKOjbj6o+exICgUb1RHIBSR6I7u6IiOQD5UKvyun3ah7fC26H5ud8T0jKm3dp1iPe9wnhLrER0jENUl6oRoPMV5XpI263lk3REVuWdPdldTVX5iETRb0dEkT2h6h/eLLgJ+/RXYsAHo1Uu+AUEQBEFwCiygZqSbM+POcCRjyJpt2f78U+vN7kiRrot/Fpozct/ArD5bo1Goc17CEfCQLVt2vCe6s9AN49jmXhCaAhHpDsTL20uJaKaQ03m9vKgcpTmlKEwrVP9GnXMVcM5VuBvAJRkpWLx2McJ+/Ry9jxxASXEB7kEBT1/Yjd0IRxh6oCd6oAfiq+ORvCpZLRTd3c7tpszm6kuFZ806zeUo2Nlnna/lYyVZJSjJKTn+uspqJdTDE8PRqm8rtQ+uQkS6+8AxlgMfS83++ktEuiAIgiA4DZq5sdCZOdsMBTNF3dF1Z+PHayJ91Srgppu0NDlH1b5TpNNBnlkBZ51Vbx774cOaEbyjMvToh8drFYrn3r3hNNhpjnMpsbHO+wxBMEVEuoOgw3rboW3hH3r8xMQ0bQp2CmumbbPfOUUzb8fHxuPysy4HRp2DJ6Zdgn3F2QhCOYpRjAqU4i+UYgnSMRvr0DaoD24ZfguSlicp4b3mpTX479P/0POCnuh0Wqd6W7FR+PI9DcHIOkU8+7m7k0gvzipWEwlePvZPHkjKvH08/TTw3HOOnXAXBEEQBKEOrBHnYMvZcRZrJydr7meMTDuKHj00G3U6tlGoU7Q7Ak4mVFRormpHjmhhchZum4FiOjXVcSnpzPqbP/94FN1ZpXn8WrhufkWO9PYThPqQn5qDaH1S61oCvS4U7KwTp6immGd6OdPWtxw8hK+LfbAOrZCABHRCJ1yAMFAXXcracRRjbfFa3PXPXTh02iG0PactAiIDUJxZjA3vbMCvN/6KXT/vQmUZveUbR8HRAmTtyYKrqK6oNuv4Tpf3xnBw6UFkbM9QpQCC9QwcCJx0ktSjC4IgCEKTuLxfeilw3nlawTYbfjsSqsxx47TbNJBzJDS+o5sahTp7vltA79bGgLsjYJ91tnFjZF7fNWeQkgJ07iyp7kLTIiLdAdDUzZq2aYTCnK9vO6StMoUr8itCpWrepuEDH2xGa9yAtngOMQhBJLzhjfyifAyb/wE2/TINv0Z/DZ8xPgiMDlR9xf99/1/8csMv2PH9DhU1bgyZOzNVxN9dIumkIMXyCb8hKMxVNsG+bHWsBEEQBEEQ3Bamj9MIhlbijg4ujB2rifUtW7SQtiPhernUI9LpL1dVpXnNOQI9in7qqY6vDmDUn53xdu/WKgMkii40NZLu3kgMXgbE9ravQMU30BftB7fHfuxHCEIQgQgEIQjVMGA5KPqDwTXHIAa3nDUS0377WMn5Tns34dG9mxATGoMrBl6B1odboyyzDJs/3qxM5vpc2kdF7O1NEU/7L01FtZmm70p3d1PzOHtT1pkqr1OcUexWLec8AV4jzJ4NbNyolbKJy7sgCIIgOBmmum/apKWORzjQPJcF1UyRo0kd69kY/Z4yBejZ0zHrZw+0ejIAWI/O1uqOgHMBK1Y4zzCOBnecK6E4Z6SetgGC0JSISG8k1vQkrw+2cEtISMCRI0dQaCyEH/yUWA9DGLzgBQMMiImJwcTLb0NaQiIqDu3B+TFx+OaPb5CSmYK9G1/Bd/DG6E6XoGdOT2VQt/6t9Uqs9728L3LDcpGbk4vIqEj07tXbamO4jB0ZShSHJYTB1ZF0prznHMhBbM/YRol0ps3H9HBgz48WAAem117TZpT//VdLgRcEQRAEwYlERWn252yv4kiRTs44QxPpBw5oC2fjX3zRMetmyJkmcswAqDOrX1ioPRXmoMtKZuyzFL5jR8c5xeuwZT13ZdAgID7esesWBGsRke4GvdZfffVVXHDBBSoVvtxYjnSkIxOZCEc4IhGJaTdMgyEkFLk0mgNwM4Abzr8Ba5b+iktfexhe1VUYuP8LfA1vTIyaiMElg1ULtlWzV6n1bMImtc6Y6BhMmzYNI04eYdW2pW5OhV+oH3xDGs5LKssvU33dnSHSSd6hPER3i7bZfd60zr00r1TV7vv4y8/eWlg39uyzmumsoybaBUEQBEFogD59tFxrimhH9k9nKza6rzPi/c47mqM8zeRoKtdYqGypxktKalrJsQadfdH5EKPfjnBH5xyA3hvd0YZxTMenkzt7rotAF1yJ1KS7AVOnTsV3332Htm3b1jxWjWqEJIZg9nezcf4d5yMgonZ+kI+3D8Z1Owno3h+liV0wYOKl8A/wx6/Zv2Jmyf+wDMtQjnKVKn8aTsNwDEd+Vj5mzpyJ1atWW7VdjGAfXXe0QVM61n0n/5OMoowip4l0psLnJ+U3OoWehnuCbUyfDlxwgeO6tQiCIAiC0ABUs/37a25rVI6Ogop26FBN3fbrpz2mNxpvLLxQ0NW4SYo7W7muWaM97QjD+q1bNSN5rm/0aDg8zZ3t3HjoBcGViEh3I6F+8OBBLFmyBF9++aX698CBAzj//PMR2iYU7U9tj8QRibUM6soTOiFp5hfImPUFHr/lCSz5cAmmX3YnlqECo7AYH+BVrMd6GGFUrvETMREd0AFz5sxR7dasoaKkAinrU+p9DYUva8ZT/01V/5YVlKnIuiPc3U3JPZjb6HU21ileEARBEAShyaLpDOfSXtwZjBmj/bt0qWNM6hihLy+vJdKZCMCHmZJO8dsY6HXH7nHffafdp0A/FrBvFOx6V1mpbSsnEUaO1Pz7BMGVSN6vm6W+j9FPmGYIiglSC9O2s/dka67nBgOqQ7SGk+Eh4bjA6IshMKIzDHgD5fgVv2IzNmMKpiAKURiBEcjLysPSOUsx4tIRCAhv2MGjNL8UiNIi6zAzA6pHuBlx379wv4qs01AvfkC8mmCwNuLdUIs0in9OCPAY2FOTrpvHqe0TBzSbyM0Fvv9eG8huuMG29wqCIAiCYAdUioMHazbmbNbtCEVqyrBhmvkMw9L792t9xhzBMZHOyzrOLzhis+mNc889tc3jJ0xo/Hp5WPU2bvS9Y5IBS/wEwdWISPdAKKzbDG6jRKsS60cLagTu1vhu+ArxCIARkQiFH4pUXfpqvAU/DMVInKJq3dN+T8MvC39Bz/N7osfUHlbVaadtTkObQW1qCVyKYLqv6+jboVLlNxxFXFUcwhO1SQR7U93rRtNtEel10905kcBoOtvgCdbz99/A9ddrs+DXXQd4SQ6OIAiCIDgfhqCZM/7ff5rruyMHYKpnqlLapDPl3REinUqXIWlmLxZpNemOiEqvXKkJdK6rfXstyaCxm0uBzkNLU9zevbVKgFatGr+tguAIRKR7MP6h/ogfGK8M1TJ3ZSqxHhkdhQXQoteU0mztNhw++BaHsRj/YArWowdOwkAMRJvyNtj61VYcWHwAQ24fgrh+9feXKEgtQOqmVPU6RspJ3uG8elPn2c6NDviBUYGNSnW3tx1b3Ui6bkInIt02WLrGcfy88zQ3VaauCYIgCILgZCjKGfFmSJpGcrzPevXISMesn+umSGfvdEfAQnHW0RuNyMszKCHsCLM4toElU6cCF17Y+PVxAoH15wMGAKNGaZF0QXAnRKQ3A/xC/FSEu6xrGQKjA5WLe1ZWlqpFJz1QhkoYUIQgRCMK+/32Y335evRGb5yBM4A04O/H/kbnCZ3R75p+9baVy0/OR0VRhZocYFu0nP059W6biqivP4r2o9rXK6ytjaQzUp97KBcx3a1rpWZO/DOSzlp79qkXrIN9Tf/5R46WIAiCIDQ54eFabjcd2ZmbTbHuKJHOEDJhursjUupDQrT+7jk5yM2NUp53DK43huRkYMcObX5i3Dg0Gkb3OecxZIjm4i4CXXBHJGm1GcEWaO1Oboe7XrwLJShRPdbJdwjHJLTH82iFAATgxekv4teZX+Cqrl54E29gLdaq1+1bsA+/3PKLEtX1UZJToqLvDQl00xTztC1p9b7GWpGuR+8bql+3lO5O+F5G0wVBEARBEDyCuDigVy/NSI4uZ44iJkZbN01nqIQbC0U689KTklTWuyOy8+kOT9i33BHd6GhAR4HObnQi0AV3RUR6M+Siqy/Cy/NeRnV8NSpQoR5Lgh+MMa3x4IMPqj7pI1b/ifv3bMHeoacCpwIf42NkIxsVuRVY9tQyLHpmEUpzSy1+hrUi2TRN3bR2vTEinenuNICzN929RujTCM9GzIn+lgS/9uXLtVYqgiAIgiA0MRTBjnBiNxdN37at8etiYXdICIy7diP1aFWjA/Ocj1i8WLt9+ulwGGwL39gIvyA4E/l5NuOWbpMnT8aypctwaO0hhFSHoHev3vDy1uZlKqPjUO0fCJx1GV4acAr2XrwXr3/6OoxrjaqnesbaDMy7fh76XNUHfSf3rVkv68+3bd+GnOwcREZF1lpnQ6RvTVemb14+Xo0WvxTZwa0adiKxVOvO6D4nDax1nzfdB9bjx/aKhbevA5p9ehgvvgjcdx9wxhnAggWu3hpBEARBaIEineFftjpzVBiYLmyLFjlGpJOYGBQfzEA+8hEc37i0/HXrtOz5iAjN6L6xUPSzzZq0WBPcHRHpzbyl29hxY1E9qhoHlhxQEWidnPOuRf7YyagKj1L3u7TrgvfOuxx7Tj6KF+b/jfa72iO+Ih47PtiBf3/5F6e/dzqS1yfj3bffRWZWZs16WP8+bdo0FZ1vCNaB00iO9eyNiaSTwrRC9R5vv/qFcn3in7Xttop0in5+Nt3wY3pYVxffnJgyBXjqKa09CTPjxOVdEARBEJqQ0FDNnK2kxHEiXY+k79kDlJU13h02IAB5+QYUFeQiqnPjRPpff2mBnbFjHRP51nfP0d3sBMHRSLp7C4CRa0Z+66ILdGIoLkT8Sw9g3GsP4/2pZ2HEUyOwJXaLSpcPSA/AgikL8PZzbyM9K73WOmhQN3PmTKxetdqqbck/kq/aqNnr7q7DVPW8pIbryutbL3uulxeW2/S5uuinUG+JsN0JTVvnzBGBLgiCIAhNDtUlF4p0R9G6tVbszTAzbdR37dJm4htBSWAUKlIz4Xus7NIe0tN9sGGDY1PdRaQLnoKI9BZCWNswBEQEWHzeUFWJkt6DUNEqAUX9T8bw/sPxzPvPoPXNrZHtm40gYxDOrDoTPdADRSiqcY7X/53z/px6W7GZkr4tHSXZJY2KpJPcA7kN1sZbqkmvWcehEycMrBH9ZflltTITWhLSfk0QBEEQXARrvmn2Vlrq2HXq0XTOwrOubcmSRq2yNCgKhtJiINe26yzdfZ190d96qxWqqw3o2RNISIDDRDpT3cUwTnB3RKS3IIKiLef2VIdGIOWeF3Do5XkwBmq13gaDAVOifXDKI8PhdYr2UxmMwTgP56ESlShGcY1Qz8zMVLXq1qC3ZWP6e2NEOt/P3vD10VCtO1vK2WKCZ7q+lhpN1zlyRFsEQRAEQWhCGPWm2nQkkycDPXpoEwB6MXgjKIM/wOAN0+9s5IUXgJkzvTFvnpbxedppjdqU2ttV5rjudYLgTESktyD8QhuuXaoOPl6jHbJmERKevRWj5jyOKa+djRX+K1QUPRaxuBJXoh/6KVOQcmgp4zSTsxYatx1dd7Qm+m6PSFefuS+n3smAhhzc+bklWdanjJluZ1FaEVoqM2dqdemzZrl6SwRBEAShBdalM/rtSLp2BWbPBu69V7tPE7lGuMgXl3rBOygASEuzqWUc/fC2btVuDxxYhPHjqzF6NBxGRYVmQicI7o6I9BaEf6iNRiDVlagKDkVulz6Ary8yfDIwH/OxH/vhBS8MwRDcgBvQC72UePfyt+3nVJpXitR/UxvV2ozrYG25OaxdZ0FK/dF4S6Kfn2tPG7fmQL9+Wrna4cOu3hJBEARBaIEO77Qod2S/dFOxzlxwWqonJ9u9mvwSH/iGBmi56znWB3H27tV2KyLCiI8/PoD/+z+jQ1PTOe8gzu6CJyAivQVhTSTdlMKTJ+Dg67+g+vYn1H0DDPBDCbZhJRZiIVKRCh/4YCiG4lpci8+f/xxzvpuDsnLrU7AokDN3ZjZYO14f2fuyzT5u7Trr699uSt1oP7MAitJbZjSdBi40gf3xR1dviSAIgiC0UId3R9al6/j6At27a7cb0ZKtqNQHPgzeVFdp0fT0dKCg4aDIjh3av6xDd3SygJ4YIM7ugicgIr0FwX7mvkG+Nr2nMiYOhoBjhnNGI/6HNPyIQ2iFw1iMxViERUhBihLrYyrG4MinRzD11qlYuGah1bXeWXuy0BgolMsKyux2jKcBXF0jO2sj89l7zU8QNHfYBqVLF1dvhSAIgiC0QBgK5rWZIx3eTdFN5OwU6VVVQFGZN/x8qoHQMGD3bmDlCmDLlgZT6Hfu1P7t2dPxmYpMdecchIh0wRMQkd7CsDnl3YSHbrwefbwq0AqV0Cc3q2KqMOyBYRh480DAG8r9fUr6FLzxvzdw/RPXY1/SPjQFOftPTKWyJYXemmi6OdFfklOCooyWGU3X4US+HeatgiAIgiDYA1PdY2OBYvPlfo2mTx/tXxaH21GXXlbpjcpKA3y9jUBYmGbNHhmlpb7XM7HAj3KmSJf2a4In4ePqDRBckPKeZt97Txp/OgoHL8OBBT9gQqtOuCQqEr179YaXl0HlJMV0i8GqF1YBR4FLcAm2bNqCS+64BFPPnorbLrkNYSFhcBZ0aY/pEQMf/+M/aVtS6Nm/PaZnjHK0t4Ql0Z+1OwvBsZojfkvjo480j5lrr9XcWAVBEARBaALi44/nhjsaprszZS4rS0tVj4uz6e1lFV6oqPJCqI9JzTwj/5zRL8i3GMo+elQrhWe0u3NnOCWowDayEkkXPAGJpLcwGhNJV4SFI/bCazBq9Cj07dsXfrkZaHffxfDfswVRXaIw8bWJ6Hk+C4mAvuiLm6pvwpqf1+DMW87Et39+iyrmQDkBGrixb7o96e56yntD0XRL62OqvCXzuuYOO7VkZwOLFzfKBFYQBEEQBFvQLcrp4upoqGRpIEd0q3UbRXp5pRd8fUwuDLy8eLGmRdMtoEfR+dEU6s6IpIeHa4kIguDuiEhvYdhiHucT4IPortFoM6iNut/u5HaI6x+HgIhjNeoAYj9+AYG7/0Prd59WKs3bzxv9ru6H058/HWGJYQhBCC7FpRiZNxIz3piBC++9EBu3b6xlvrZlyxYsW7pM/au3ZLOHnAM5taLdtjrG1xX5damvTZwl87rmzqRJwO+/a+1UHW3wIgiCIAhCPSKdIWE3rEsvLfdCZZUBPl51Zu/9A4CMTIvv0xMD2K7dkXBe4MABLagQpbVeFwS3R9LdW2AknSnd9Zm68Xmmfkd2ilS3VfQ7C/AP90dQVBDCE8NRcLQAqZtSkXbz4zAaDMi69PZaKi26WzQmvDwBW77Ygp0/7sQg4yDEe8Xji31f4LIHL8M5o8/B+L7jMferucjMOn7CjomOwbRp0zDi5BE27xvT2ym0+dn6fVsozipGWX4Z/MPMZxvUJ/ppXldeWA6/EAf2CfEAOBs9caKrt0IQBEEQWhis9WYrtsJC5/QUo0j/7ju7I+nkhMl7OtKruvRiIDCoXmd3R5KaqmXw8zB16ODYdQtCs4ykZ2Vl4dlnn8VZZ52FyZMn4/nnn0exDSYYX3zxBYYPH45XXnnFqdvZnDB4Gep1ePf29UbbYW0R1Tmq3vrs0DahSBiRAENEBFKnz0ZFfLua54I2LodPVpqKqve/tj/GPjVWidc21W1wV8BdiEc8fln6C6a/MR17svbACGOt38TMmTOxetVqu6Ppuji3Jd1dJ/eg5Wh6Q+szZ17XkuC8D1PJBEEQBEFoglly1qUXOcm8lkqZKeqsSc/IsOmtpRXequzxBPS2cfkntmJjd7akpOMf7Sj0mBSj82PHAu3bO27dgtAsRTqjs4MHD0ZpaSluu+02XHnllfj4448xYcIEVFaaGE1YYNeuXXjwwQeRnJyMgwcPNsk2NxeCW5mfcfXy8VIC3VoTtMDIQLQ7pR38go9Hj/0P7ELb/92B9v83Fb5Hte+ldb/WOG32aQiJC4FfqR9u9rkZww3DUY1qZCADh3EYJdDStXTBPuf9OXalvjMlnULdnnR33UDOUgS+ofXRvK6+lPjmzIIFwMCBwIMPunpLBEEQBKGF0KqV1lfMGTCVvlMn7fb27TanuxtMAjC169KNZuvS9Xr0tm21JAFHwWoA7oqkuQuehstEure3N7Zu3Yqnn34akyZNwgUXXICvvvoKK1aswNq1a+t9b1lZGS6++GK89NJLiKFzlWATER0jaqLkjKonjkhUKeIJwxKU8LYFRsjbndoOIa1D1P3qwCCUt2mPsk49UdE6oeZ1YQlhOP3F09FmSBsYK40403gmLsbF8IMfylCGJCQhDWmoQpUS6pmZmdi23b7+nDn7tNp0W9Pd1fZXViuhbk8knZMKlt7b3KFvzaZNwLffav1RBUEQBEFogrp0RtSdNfDqdek2prwXlPjAh+3XLJnSZWY2WT06I/SsCqBhnCB4Ei5Ndw+uU0MTwr8iAOXl5fW+75577kH//v1x4YUXOnX7miuMfOvR9NhesQiKCUJM9xgERtkm0GulyA9ti7h+cahKaI/Ds7/C0ftfBryPWR5w1rS6WtXDn/rIqQg9JVRF0XuiJ27GzSr9nVCg+8MfXdBF9Vs/uvaoXZFpCvTsPdl2pbuTvEN5FtfbEPlJLVOkn3EG8MYbwH//iWuqIAiCIDSpeRzzxNm/zNFiXe+XbqN5XGGJd21nd3N16Ux7N+F4f3T7NtXithRq0XlxdBc8DbcyjmN9enx8PIYOHWrxNT/++CPmz5+PTQzbWQkj71x08o+l2TDl3lktwdyd8A7hat+DWgU1eAz05xt6XUjbEPhF+iFlQ4oyUWPyOon64QME7PoPKXc/BwQEocM5HfDW+rcwpHQIohCFKwxXIMUrBR2rOsIbx/ti5PyUg4VbF2LczHHKad4Wsg9mq5p4o8H2vmAl+SUozi5WRnmmVFVWNbg+9d68YviH+Nt9HD2Vm2/W/nX27jX349gUyDF0v+Mov2dBEGwmNBTo1g3IydGsy1k7bmNP83rp1Utzf0tO1j4jMrLBtzAuU1jqA1/v6vpFOkPc7J3ONriVwO7dzhHpPD2zKkAQPA23EemvvfYaPvvsMyXAgzgraIakpCTceOON+OmnnxDKE5OVPPfcc5gxY4bZunY9et8iCQXyd1gf+d2tn0EbghUIx6oQfNLTEfPl6/AqK0PeOWORd/bZ6NahG16Z9AoKkwqx4qYVQBLQpaqLen1VTBW252xnWF1F1LEPWP3BagyfPbxeIztzVMD+Oq39R/cDR+s8SNP4aCvem7TfMcfRg+Gg6OxZ65ZwHJ2NHEP3OY6FDPcIgiDYAq+L6IZGVq4E/vnHsSKd19p0WqP3E+vSR45s8C0VlQbVI93PUiSddenVVZpQj41VD+3fzyxa7eMY9XYULNfntYgVcwuC4Ha4hUh/7733cN9992Hu3LkYP368xdf9/PPPKCkpwd13313z2J49e5CWloY1a9Zg5cqVqta9Lg899BCmT59eK5KemJiI7t27I8yR7hTNFEZ4eBHarVs3s8e3Pqf0zFJfJD31IYLXL0NR78nwOagJ7bX/rMXLL78Mf6M/BnoPVHXou3x3IackB+V+5QhqH4QNOzfgKlyFo38cxa9Hf8W4m8YhvF3TFBV5eXuhw9gOKpVfZ++CvTBWNxyZZ9S/w5gOJ0wqWDqOrIOnaV9zYO9e4LHHDCgpMeDHH+3vee+M36Mgx9Cdf4t6hpcgCIJd0OndGbPkrEunSGdduhUinc7uFVUGBPrVk2Hk5892PkDnzifUo1PDOwrOfTIWJ6ZxgificpH+/vvv44477lCmceedd169r6W53KBBg2o9dtVVV2HgwIH4v//7P4sXSf7+/mqpC18vF/nWY+vxiu4cjZBWIUgNDUBWz0FaNw5q3MoKjIoMQvUdd2HOnDlYVLxIe0MVlBHgXTfcpfqkL9uwDN+/9D2GFwxH+X/l+OO2PxA7NBYjbhmBoGjz2RaOguZ2hcmFiOoSpd2nOK9iR5GGo/lVJVUozy1Xtf7WHMfCI4VqQqNVn1Z2+wK4C76+WltVprslJ3s7tdWJ/P3KMXQXHPFblLFIEIRG0bq15o7GCT9Hho4p0n/7zeq6dDq7V1R6wdennol6przn5mp9W/39nWYaR5Hepo32cYLgabhUpH/44Yeq/RoF+tSpUy2mqtMFnj3RW7durRZTmBofFxen+qUL7gfN4timjUZuWbuzYKyuRtybTyBs6S84467nMOz995WLe052DiKjItG7V28VxSajBo3C0A+H4qM3PkL6snR0M3ZDxtoM/PTvTzj1/lOVG70zoXCO7BypIuK2GtgVHC2wKNLrwnWX5pUidXMqOo7tCE+G3VpefRUYPVp6kQqCIAhCk0Ez5oQE1nI6XqSTQ4e0OvIGyk0PpAWiuKyedHfCWnTWzxcWwujnX6P/9Y9yFGwh39GzL6uEFozLcmxzc3Mxbdo05fA+e/ZsJbL1hWntOvv27cPmzZtdtZmCA6DIVS3ehifAxwcwlJWoeiS2a6Mg79u3L0aNHqX+1QW6ToB/AG655xZc9vplWNphqWrVZqgwYPFzi7F5nXN/FxUlFShMKbSr53pBSgGMDCdbgT4BQLO9soLjBoeeyh13ACed5OqtEATBnUhPT8f999+Ps88+W4391pq//v7777jmmmtw/vnnq8w7a8+rgtAiSUzUirsd+XdCwc9Cca6zgX7pGXl+2HQgHK0iylW5vEV4McjerSkpSF6TjLw8wM8P6NrV8anujqxxF4QWEUmnYRtryM3R+ViNCnn44YfrNdSh2ZzUlXsGjCx3OL0rMuLeR86iZSjtMcDq93Zt1xVvvfIW5s6fi6NzjqJNdRv89fRf+HPyn7jt8tsQFBBU06vcUmTeHnIO5CC0TajN7dwovIszixEcG2zVa3U4KcDsg+YCx3Qb/f4EQWhmsN5+xIgR6NSpkxLof//9t7q/fPlyDB482OL76FXzwQcf4NFHH1UeMjSWnTVrFh588MEm3X5B8BiYbcqIOkPIjjRGZiu2I0e0lPdhw8yKc5rFbTkYisISH7SJKmp4ndzOPXuwdXs7AAno3l0rmXMUNLtnqnu0FYa/guCOuEyk+/j4WJWizkG9Phh9FTwHGrHFDWyDwrZnI21zGirLKuFVkIvo7+Yg84q7YPT1s/heLy8vXHLWJTjU5RCWP7gcCVUJ2P/Tfly84mLcf/v98CnzUTXumVmZNe+JiY5RF4WscbeHkuwSlOWX2RxJ11PebRXpfA+zDjwdZsTNnq2Vsa1Zo82QC4LQMnnrrbeQl5ensuQCAwNx0UUXqSy5xx57TAlvcyxbtgwvvPACFi1ahHHjxqnHzjrrLHHBF4T6oEMa3d3ZM92RIp156AsWaOZxdTiUHogFG2NRXOaN8iovtI8ttr7He0QEtq1oo31Er2qHJfgyQFBcrHWnk0CB4Kk0D0tpweMIaR2iHNCDogLRZvZ01Uu99RuPWfXe9t3bY9wj4wBfoBM6YUrWFDw741ncOfNOpGal1nptVlYWZs6cidWrVjeqNt3WSLoeFbfGDd5UpDPdXesx79lQlH/wAfDvv8C8ea7eGkEQXMmff/6JM844Qwl0nSlTpmDx4sWoZINkM3z88cfo3bt3jUDXadFtUwWhIahIu3TRFKoj0YvF2Svt88+BJUvU3bIKL6zdE6H+7dC6GN3bFiLIv9omMb01RTPo7dOx8dvM0wlL3Rn0Z/MmSXUXPBmXu7sLLRdvP28kjEhE1o13wO+J/cg57zqr39tmcBtMenUSVsxeARwErsSV+Bk/Ywu2IBaxCEOYcmJnazf+O+f9ORg2bJhdqe/5yfmqrZqtMPpelF6EkLj6LyrrmtLlH8lHTPdjjeY9FDZTeOEFLXXNgiekIAgthIMHD56Q1p6QkIDy8nKkpKSolqh1oWHs0KFD8eWXX6r2rBTnp512murowqwqc5SVlamlbls7tsrjItSPfozkWHn4cWQknS7vFOpMKXcErVrBKz4ehpQUYO5c9VBVu3bY6jUQyTmB6BhXDB87GlykZvsju9AfPl7V6B6fDYPh+ESewVBV619rYAIBd5kCnanu9Lhr6X/6Lv89NgOqHHwMrV2PiHTBpRi8DIi59RKkDhmBstRSm94blhCGCS9MwIKnFiD/v3xMwRRUoQpbsRX5yEdrtIYf/BCIQPTP7I9f7voFZ71wls2Cm3XuuYdyYQ95SXk2i/Sc/TmIaB9h18SAO3HZZa7eAkEQ3AGKcdMout6ZRX/OHMXFxfj111+RlpaG66+/Xv37wAMPKC8bljVZ6gYzY8aMEx7ftWuXROBtYPfu3ba8XHDH43jyyQ5fZeDs2YiYPx8hq1bB/+BBpCcnw/+a03D6OGYM2tbjLCvLG598EoPduwPU/b79StBjHCfVtIk1U9q3t/44duhQ+77e2k2Qv2t3+puuz2vNFM9WAUKzIW5Ie2BzKvIO58H3yAHEvfk4UqY/j8qYuAaj8cGnBWPdf+vQHd1xDs5BMpKRi1wcwiH12ARMUEK95HAJdny/A30vs93HoLLUfEpmQxSlFam6ex9/839qdCquW+9eXVmNjO0ZiB8Yj+aCbjQrtWGC0PKIjIxENl2c6pQi6c+ZIyoqSgnz77//Hv5MzeHEbFgYrrjiCjz//POIYD1rHR566CFMnz69ViSdUXqazonBrHXRHV6EduvWDd7edoRFBfc5jnRhX7hQS3131MDLv7lLL4WB7dM+/BDBf63G1wXXonN8Ebxs/IgP/0zED6tia+5380vDwU/SgFNOAbx9aiLoFOiHDnWD0ehtVRSdCQSTJzvWgM7TcYvfo4dT5eBjqGd5NYSIdMFtiOsXp9Rc2IOPImj7BrR67xkcffiNBt8XFR2FjdiIaEQjBjG4FJfiU3wKL3jhXJyrBHoRihCMYOz8fic6nd4JAeEBKEwtVOnoER0jEBRtXU9zW6EILzhSgMhO5i9ELdW6M+U9vH2407arKfn+e+Cpp4CXXgLqlJcKgtAC6N+/PzZu3FjrMd6ngKYYN8fAgQOVsNcFOmnXji7QrDnNMCvS+VrT1+vwokouTq1HjlczOI4sxmb2CsUAc78dSa9e6p+A3VvhN7wSzEa3teHb1oNar/VTe2WhS3wRzuibDmNeMcClzsQdBXpDIp3Zw2zjNnKk1oJdOBH5u3afY2jtOsQ4TnArWveLQ8Hst1E4dCzSbj0xbdEcbLMWHR2NVViFClSoNPeLcBEuxsUIQhCO4ihew2soiylTqeV/3fsX5l0yD/Nvn49lTy3DogcX2eXebkvKu7Wp7qZk7jzuUu/J0F9m82bg5ZddvSWCILgC9jlfvXo1lhwzmzp69KgyhuPjOmzHxprzzEztvHfttdeqyMWqVavU/erqanzyySdK2Ju2aRUEwQyc/OrYEUhPd/zh6dQJ1f4B8CvNR6eynTa/vbTcC/tStFr5a8YnYcqIVASHeAGVFUCBdRHGuqSlad3nGmgIJQgehYh0wa0wGAxoNWkwCt7+AlURJq3IKiw7ntMMjm3WGC2nUGddenu0RwISUIlK/IE/UIYyfJT5EapRjdKcUpVS7hvkC29/b5WSvm/BPqftE1u4leaW2izS2f6tOMvBDq0u4J57AJaJfvKJq7dEEARXMH78eDz11FOYNGkSBg0ahB49eigjz0ceeaTmNUxtZ7u10lLtXNmvXz+88cYbOPPMM9VrKczZX/3bb7+1aBwnCIIJ7D9GLPg+2IvR2wcF7fuo2wlp621+/64jwag2GhAbVobYcJNtM3gBxSU2r49ekSzxHTRISx4QhOaCjHSCWwr1uAFxCGurpWgF/bsSHW+ZCL/Dey2+h33QH3zwQZRFl2EZlilxTnaF7MKMB2fgzYffRHVUtUqDn4d5ODDmAM744AwMuG6Aet32udvtrju3BkvGc/WJdJK9p3YdpydCI5fHH9cm9gVBaJk8+uijOHToEF555RWV6v7jjz/WSk0fNWoU/vrrL8TGHq9TvfHGG5GUlISXXnoJv/32G3bu3KkEuyAIVsCuCbQ4d1A0vboamL8+Fp8tScCuCO3vMOrwJpvXsz1JS3XvlVhQ+wkWkhfUecwKkpOBrl2B7t1tfqsguDVSky64tVBnpVPE/a/DL/0IIn/6GGl3PFOvUOcF3Lbt25CxNwOBxkBceO6F8D7WF2RInyF4/uPn8e2f32LL31vw59Y/8cRNTyA4LhhFqUXY8O4GdDu7GyI6RajPdySsS4/qHmWzSC/KKFJR+ICI5lNkxT6mPnLmEYQWR6tWrdRi6Tmmu9clPDwcI1loKgiCbXCgZf34/PnAvn2Anx97H9ptJJdd6IcD6UHw9jIiM7E/sBaIPvyv5gxrwzp1kd6zXeGJIp0hcc4GWJktw5J7vo1RdLmuEJobEkkX3FyoxyP/nS+QPeV6pN38eIPvYep73759MW7KOIyYOqJGoJOwkDA8ffvT+Pjpj5EYl4iUzBTc/OzN2Bq5VT1/YNEBLLh7ARbctQBJK5NgrLbVCqX+Nm6FKYU2i3Rib/s3d+PAAeCSS4ALL3T1lgiCIAhCC4BF2mzH1r+/JnzprmYnqTn+KCr1RpuoMhi7dkeVty8CCrMQnJNk9TqqqoFdyVpb2t51I+mcRGBqvg3p+axF79FD88kThOaGiHTB7YV669G94P3Ki/Aysez0KrTPXIQM7zccP7/+M66ZfI2qbfxkxyf4I/AP+HTxUTXquQdzsXLWSiy8fyGy92Zjy5YtWLZ0mfqXYtuRBnLWiHSKe0dOGLgK1o19+y3w00/A/v2u3hpBEARBaOYEB2ttzcaM0WrUMzLsXtXBtEAE+GnXQNU+/sht01vdjjpkfcr7/tRglFZ4IzigEomxderPGRKnQC+1ri6dQXdWzPTsacteCILnICJd8AjC24Wj/aj28Av2Q+RPn6DjrZPgl2y/0gv0D8SD1z+Ir2Z9ha7tumJNyRo8uvdRrOizAh0md4BPoA+ydmfhj+l/4L1H3sMLL76gTI5uuOEGrF612m4DubpY4yrP17BdnKfD2e5XXgH+/VccWAVBEAShSWHRNnPCi203pM0v9sHR7ABEBlfUPJbVTvP0USnvVrI9SYui90woPLG3OreN9XClJ14rmSM1FWCjh/h4qz9eEDwKEemCx+AX4od2Q1sjYvkv8MnNRMjqvxq9zn7d+2Hey/Nw+6W3w9fHFws2LMAdC+/AgeEHkIQk1Wt9AAaof0lWVhZmzpyJVcu1tkCNxZpIOslPti5zgBH37H3ZqCg5PpC6E3fcQddmV2+FIAiCILQwqGbp5MoccTtS3fNLfBAadNxgN7tdf5tF+g5LpnFEr2s/1uHBUkbe7t3awig6S+4dbCEkCG6DiHTBo/AOCYLPskXIuecZZF9wo0PW6efrp0Q6xfpJ3U5CQVEBPljyAb7BN6qtG3utd0In+MAH3dANkzAJB58/iNTNqXZ9nmnKvLUivSi9CJVlDbvPU5xnbM9Q9fXWvN6V2DGZLwiCIAiCPbAmnaqW0eoK2ybykzMD4ONdXSv6nZ3QF9UGbwTlpSAgr2HhT3+5bbpIb2fBxZ2Ku6SkQSf3c84BzjxT88EThOaKiHTB4/Bq3QrhMx9CQOSxhpjV1fAqtN8MRadb+24q/f2qiVfBAAMKUajauZE+6KPE+SAMQjjCVWR97Qdr7foc9mW3VaQbjUbkJzUcTa8qqzr+eiuj765g1ixtcF1tX+WAIAiCIAi20r695rJmQzS9ssqApMxAhAXWvl6p8g9GXrzW9yw6qeG69JQcf+QV+cLXuxpd449fB9XCz3IbNnre6U7uLK+nJ56VJvCC4JHIz1vwSLx8vNBuZDvEdotC3JuPod0Dl8M7r/E9xb29vXFKr1PQHu0RiEBswAYl1hlND0GIur0RG1GFKhQfLFZ167aSdzjPZpFOmMbekHGdaa93dxbpe/YAOTnARx+5eksEQTBHcXExvvjiC1x33XWqh/ngwYMxadIkzJgxA5s22d4bWRAEN4Aqt08fLZWtyrrrj5xCXxSWeiMk8MTsPD3lPcqKlPfth7Uoetc2RfD1sWCG6+sHFBVpbdhM4N2UFKBvX3FyF1oOItIFj8XgZUBUaAXCtq2B35H9CNztmAvHyKhI+MEPCUhAFKKwEAtRiUolzr/AF9iBHTiEQ+q1O7/fqYzdaApnjQkcKckpUa9ntLu6wnq3eAr6vEN5Vot0fkZpnuXaLlfyxBPAJ58Ab7/t6i0RBMGUkpISPPnkk2jbti2mT5+O7Oxs9OvXD+PGjUN8fDx++eUXDBkyBKeccgpWrlwpB08QPA2GoGNjtWg6U9+Zh14PuUW+KC33QoDvidcrunlc3O7l6LnwNcTus5wep6e69zRXj246icDCcy4mcFNbtdI6yQlCS8HH1RsgCI2iTRsYFi8Ctm9H5KkTUPRPcqPblfXu1Rsx0THKJC4CEchDHl7CSyiGVkQdgADEhcahU0EnJK1KUouOf7i/ivB3ntgZEe0jLH5Gzv4cxPaKVULdFhhNj+gQoSYozFG3Dp0p8gHhx1vXuQuJicBVV7l6KwRBqMull14KX19f/PDDDxg9erRqg1mXzMxMfPnll7jsssvw1Vdf4WT2YRYEwTMIDNRC0itWAIcPa0Kdhd4WHNgy830ZFjH7dHZiP1R7eSOgMBNd1nyBjuu/w4J7/kSVb4BF07jelurR9V7pTHeneVyQn3qI5fP5+VoNeliY3XstCM0/kn7kyBG89tpruOCCCzB8+HC1XHjhhXj99deRwlwUQXBFW5EpUxAUE4Q2g9rAq7wMqLTf3dzL2wvTpk1Tt1mb7gtftEVbtEZrVYteilKsLl6N8sTyE95blleGPb/vwV/3/qXM3iyRfyQf5YUnvr8hGCk312/d9Plan5Ocj4pi93R6N01jO3DA1VshCAJ599138e2332LMmDFmBTqJiYnBnXfeid27d6MXjagEQfAsmPJ+4YXAeecB4eFAtuVyweSsQAQHmM8UrAgMx/oLZmLviCtQHhgO78oyRBzZVus12QW+2HY4RLVwM8CIHm3raSmr2rBVKJGul6YfPAh06aJd6glCS8JqkZ6UlIQrrrgCHTt2xBtvvAF/f381e87Fz89PCff27dvjyiuvVK8VBFcQElCJzi/egvYfPw1vb/v7cow4eQQefPBBREdH14h1GsYNiByAfp37obKqErOSZuGPxD/Q99m+uOiHizD1y6kY/cRoFemmgdue3/ZYXD+j/fbUs+tR+IaM42ruV1ThyLojDdayuwqK88GDgVGj6jV0FQShiWjdurXVr+V1QESE5YwhQRDcFKaVx8VpRnIU7BkZZtPeC0u8kVvoq66tLJHWbRR2jL8DGR2HqPtRJiZy+1ODcN1r/fHQp9pkXrtWJQipY0B3IgaV7q7H/WgyO3SotsmC0JKwOt190KBBuPrqq7FlyxZ0tzCdtWvXLrz//vvqtenp6Y7cTkGwjg0b4LX2HwSEbEPC448hKc3fboFKoT5s2DBs274NOdk5qladqfBMNf/575/xvzn/w5qkNbjkiUtw80U348YLbkT8oHglwJc9vQz7/tyH3pf0hm+g+ZGlKMNypL0+GIEvTCtESOuQBiPpem162uY0xA+Mhzu2bc3M1FLZ6EU1YoSrt0gQBI7zfZkOWw9r165FSEiIRNIFwdPp2RPYtk0bjFmrbsY0Lias4cw/msi13b4Q0Yc3QQ9RrN0TgWqjAf6+VQgNrMR5w6xoXWswoLK4DL5B2t2pU2nqa9eeCULLiKRz0H7++ectCnTC5/ia//77z1HbJwi2MX488PnnwNKlCBjUB20Gt7GYsmlt6jsvVkeNHqX+5X2ub/LYyfjljV8wfth4VFRW4PUvX8eF91yI7fu2K6Ee2iYUFUUVOLjkoFO+QUvRdHMiXU+vt3dSwJkEBADffgvs2ycCXRDcBRrGcVI+n7NndSgvL8cjjzyCkSNHIjc31yXbJwiCA2G6e+/eWsuVOlCkV1cb4OPdsH9OVqLm6hZ5ZCsM1ZW16tCvGZ+ED+/cjPH9MhveHm9vlOeXqvJ0QWjJeDkjBS6OKTSC4CouuQTo10/dDG4VjLjeUY0S6pZoFdUKbzz8Bl6890VEhEZg54GduOjei/Dal6+h08RO6jU7f9iJwtR66q/spDiz+ATndkbw63OYz9iWYbNRXVMwbBhrXF29FYIg6Lz44ovYuHGjcnVfQXOpY2zevFk5u3/88cf4+eefxTBOEJoLx0r76pKW6w9fH+uyEQtiO6HCPwQ+5cUIS9sDJjHuTNYy/nrV5+heF19fVOSXiEgXWjw2Gccxmt4QHLwFwW3YswdhZ4xAm/SNTlk9xf9Zo87Cr2/8igknT1C16m/PfRsPL3gYPqE+KEorwh93/oG98/c6XCDnHsi1KoquU1ZQhtyD7h35YhLO7t2u3gpBaNmcdNJJWL9+Pc477zyMHTsWjz76KJ599lkMHTpUZRRt3boVEydOdPVmCoLgKIKDNdM2Wqkfg5csGfl+CPSzrr0svLyRnXiSuhl1eBMOpgehpNwbQf6VaBdrg+mMr4/KRPQx1H9NIwjNHZtEOmfQX375ZbNiIzU1Feeccw5uu+02R26fIDQONuLeuxchr/wP0Z2cZ3AUExmDVx98Fa888AqiwqOwI3kHXi58GWUxZUo8r397PZY+vhTFqcXYvn07li1dpia9GmPoxhR29k631H7NHDSrq650TxO5OXOAAQOA229vsG2rIAhOhqZwHO9fffVVJdAp1GfMmIHPP/8ckZGRcvwFoTkREqLVn5n0J6fALi71RqCf9dcM2cdS3qOTNtWkuvdIKIS3LWrDxxfl5UYEedveAUcQWmyf9E8//RQ333wzfv/9dxUxb9u2rXr8m2++UeKcNemb6P4kCO7CrFmAlxdw//2IadUKZcWVTkk/1zlz5JkY1ncYnn73afy+/HfMzJyJSeGTMLRoKNI2pWH5DcvxecbnKC7Weq6zHzvbvdGkzlaY3p57KBfRXaOtiqQTinr2Wo/p7n755ePGae6tvP5ni1S2chUEwTVwMp5dWx566CFMnToVXl5eeOqppxAWFoZbb71VvhZBaG6RdIp0tlmhYD/m7E6hHhFifRvXrHaaSI86vBnbDXakuuvp7qXlCPE7PmEgCC0RmyLpF110kTKFq66uVulwFOp8jAYz999/P5YvX46uXbs6b2sFwVao+l54AWjVSt2lw3lARIBTj2NkWCReuu8lVa8eHRGN3/J+w2uVr6EEJSg8VIj4quMu61lZWZg5cyZWr1pt12cxfV3PbLFGpOumc6YReHehc2ct1f2bb0SgC4IrOXDggEpzf/LJJ1Xf9Hnz5qne6W+//bYS7WeddRbS0tLkSxKE5gLt09lO0SSSXljqg/JKL/j5WJ/alhffE1XefvArzsGOw5o9e69EGwMjNI4rNyLUV0S60LKxSaSThIQELFy4EGPGjMG1116LH3/8EUuWLFEinTPtguDOeP29BO2euxX+vs7Ppz5t+Gn49c1fce6Yc5GFLKzDOvV4h/IONa8xQtuOOe/PsSv1ncKcde/meqRbgunujKa7I+3auXoLBEG46aabEBAQoGrPr7zyypoDwgl5msfR9Z216bvFQEIQmpd5HCPpx2Akndjiu1vt44fctr1xEB2QVRQIH69qdG1jY2cZgwFGowFBBhvq2AWhGWKzqubgfMMNN+CXX37Bfffdp1LcL7vssloOsILglhQWKud3w/zfkbjqa4v9y01hKrmXj/2TT3R9v/L0K9EGbbARG1GFKrQ2ap0SqlFdI9QzMzNVP3Z7YMq7LZF0kncoT6XLuysFBcCjjwJHj7p6SwSh5cEI+h9//FFT0mZKhw4d8Pfff+Ouu+5SXjSCIDSjVmwmhjC5xb7w8rL9OoGt2FbgFHW7c3wx/H3t8cExwh+1O9gIQkvDJvWxaNEiNXv+zz//YPXq1Zg9e3YtB9iHH34YFSbOkILgVrDOirnUV14J70ceQuLJiQ0K9bCEMLTqraXK20tOdg5CEIKEoATkJeSpxwZiIA7jMIpRjAhEYCRGYttj27D7F9utzYszilFRUmGTSGertoIUG+vEmhAG7559Frj7bldviSC0PE4++eR6n/f29la90keNGtVk2yQIQhPUpZNjQj0zzw8BNpjG6WS3Oy7Sba5H1/H2hn+Z+16jCILbifQJEyaoGvQNGzZg0KBBtRxg58+fr4zlRoyw3QBLEJrUnezTT/nDhW+QrxLq3r5aSlddfAJ84Bfih/B24QhprRmg2ENklOaE7G3wxgUvXqAi6D3QAxfjYozCKEzCJLRHe4bWse2bbTbXi7MmPe9wnlXu7nWj6dbS1I7wTz4J0N7i6qub9GMFocVD8b106VKrsuoYcV+zZk2LP2aC0GwCGX5+QHk5KioNyCv2QaCv7f41OQl9akR6v+hkm99fWWWAj68B/qXu3TJWENxKpHPgfv7555Uwr8tpp52mTOU6derkyO0TBKfi++UniC/YZfa5oBjN9ITE9Y9Tot0eevfqrVzcDTAgslck1vqvRSUq0Rmd0Q3dlGjfju3wDvNGWX4ZDi8/bPNn5Cfl2xRJJ8VZxSgvsq7FSVPXsPfvD+zYAUya1KQfKwgtHk60s/a8X79++N///ofFixdjz549SEpKUt1bPvnkE1Wn3qZNG+zbtw/dunVr8cdMEJqVw3tpqTKNKy33ti+SXhWB7eitbo80Lrf5/eWVBvgFeCOgLN/m9wpCixXpI0eOrPf5qKgozJ07t7HbJAhNw5dfAtOmIfjmqxDhp7VEsyTSvf280WZQGxhscVA5hpe3l2qzppPik4K/8BfSkY6d2Im38TbmYi4W5C9Qz+/8ZWeNYzvT0q0R30x3t8ex3dpouisc4Wk2q1Ptnq3dBaHZcfbZZ2Pnzp24/fbblffMGWecoYR4u3btMGDAAGUSy4n6lStX4rPPPlPjviAIzYCgIG2hSFft17wQ4Gf7uL8zWcs87I6d6Jy2yub3V1R6wdffC/7VYhwntGysFumcOWdblobgzLqpG6wguC1TpgDDhgF33YXYcSchJC7EokgngVGBiOlhX39x9kG/26TAOgc5WIiFOBxzGDPunoHLJl2mjOUYYc/bn4cf7vgBP1zxA749/1vMu2QeUjakwBkwTb6hVHam0fM1fK0r+P13oFcvYOdOl3y8ILQ46OzOiUV6z+Tm5mLLli1Yu3atugagWdz777+vIu2CIDQjGITgpFtuLgpTC2GsqIK3Hb6525O0a6lTsALRSZttfn+5LtKNYhwntGyszt/t0aOHGpQZTT/nnHNUTXrr1q1VxI+D9rp16/Dzzz8rU7kHHnjAuVstCI4gMBBYtkzVYHEcajukLbL3ZqvFy9fLrKlcVJcoFGcWoyjDxpYiAIYOG6pE+OOPP46s9CxVq85UeEbax40dhwkjJ2DB0wvQrbQbyg8fT0OnC/v277YjftDx/uqOgpF6iu/ITpGWX3OstRt7skd2jrQrm6AxvPUWsGsX8NRTWvKDIAhNR0hICPr06SOHXBBaAJkBCUgvK0VqXiCQx5rwQJvXsT0ptEakh6bvg09pASoDtMesoaLKgLAQwKviWJ/0rVuBLl2OG9sJQgvBxxYzmeuvvx5vvfUWXnnlFVWjZgrT4S699FJ8/vnniIuLc8a2CoLjoUmKTlUVorYsReS5k1FWaLlWO25AHA4tPWSzUZtOr169YOh5otAd1ncYur3RDV/P+hor9qzAURxFWFgYLi24FBnbMpRIjugQAUfDVPaIjhEWxbeebs+U+sMrDiO4VTAiO0aqEoCm4I03gN69gccea5KPE4QWD2vSOQHPri3jxo1D+/btW/wxEYSWwHbvvlhl6AXf6jRE+v9ns0gvqzBg71FNTA8I2wdDvhFRyVuQ3qX+jhF1091Dg6oA32OBkkWLAHaOGjzYtp0RBA/HpkQWiu+nnnoKu3fvRlpamnJ537hxI9LT07Fr1y7l9CoCXfBIWPR8wQXA1KkwvPUmAsIDLL7Ux98Hsb1inbIZka0iccuLt2D6zOnwb+uPXfm7sN24XT239cetTvlMiu+Co5ZbnZjWxJfmliJrdxaOrDvSZH3WO3QAZs3SjGcFQXA+zJjbv38/brrpJtUXnYawN9xwA7788kukpDin9EYQBNeTlweERXijWy9fxIaW2mwIszclGJXVXogILkdk+3D1WGQSxb5t6e6hgZVAu3baA0zB37IFKLI9g1EQPBk7qk00WrVqhYEDByojmdhY5wgWQWgyvLzYHFhzNrXCCIn90wMiLAv5xjKo1yD8+MqPuH7K9VhnWKceO7D4AL5/6HusmLkC/374L/b9uU+J66rKKlUzumzpMvVvdZUdbqx7Lbu3mzOuK8kuQeqmVLiC1atr2rgKguAEbrzxRqxYsULVoy9YsAAXX3wxtm3bpiLsdHXv2bMnbr31ViQn295eSRAE94TjKkW6SjBkOSBvlB1LObcx1b1XYiFy2mm+FVE21qVzO4L8Ta5jeE2WmQns3WvTegTB07Gpp9TgwYOxfv36mvtMbb/iiiucsV2C0PTce6+KpKNzZ6te3qp3KxxeaXu7NGsJ8A/Afdfeh9NHnI41D69BRGUEyreVIxm1L4xzfXLxZ+Wfqt6dsN0bTZ9oVmctbP1WlF6kUtnrYsldPv9IPvzD/FWdflPAgfuGG4APP/TG//4XrszkBEFwHkFBQcrdnQspLCxUHVyeeeYZvP3225g6dSoSEhLkKxCEZgD1OJcakc6lvFz710p2HBPpPRMLkJ14krodeXQbDFUVMHqf6PNjFgNqt35jECU8XIums+WjDdsjCC0mks70dlPExV1oVrAm21SgFxdriwXo9s6IurPp36M/ps6aiqJuRVhkWIT5mI+NvhtRFl2GKlQp8d4RHWten5WVhZkzZ2L1qtU2fU7Wniyzj9fXAi5zZ6bqt96UX4+XlxFHj5p4CQiC4DRYzkZhzsj5kCFDVJQ9Ojoa99xzj/LXEAShecDLHYp0f/9jPVBDQ22KpLMCbscxZ3dG0gujO6A8MBzelWUIT91l9ToMMCLIv07rt1atgLQ0wIouU4KAlp7uLgjNmkOHWJiphW7rya1u3bc1/IKdLxhbdW2F61+4Hne/dDfyOubh54qf8VzWc1iCJer5buhW81ojtO2d8/4cm1LfmcJuTnDXJ9JpLsX2cA21cXMU990H/PNPNW66KaNJPk8QWiKLFi3CHXfcoVzdGSl/6aWXEBoaihdffBE5OTmqm8sLL7ygUt8FQWgelJRogXMl0klEhGbYZiWHMwJRVOaDAN8qdIorUjPr2QlaND3q8Ca2qmlwHaWqN3s1QgLqXHdw0oDliNu3K5NfQWgJiEgXBHMcPqy1/Vi4EEhKsvwH5OOFNoPbwODVNG3JenXuhbkvzMXF4y9W99dhHcpRjnCEoxVa1RLqmZmZ2LZ9m81O77aIdPV8WSXykpqmhzrNXgcMaJKPEoQWy3PPPYePPvoIkyZNUnXna9aswaxZs9R9inVBEJqnSKf+pR5WBAXZVY/evW1hTX91PeW996LXcdb/TkGnNV/Uu46yCm8E+FYjOMCMEG/dGqAPhnhhCC0Em0X6jz/+WLPUvW/6uCB4NKeeqjXlpgeD7jBqAdZlx/VruraDfr5+GN9/PNpDa4u0GZopSyd0QjCC4WNiNZGTfaLoro+itCLl9m4aKa8qr7JK3PO1TUlGBktutPkUQRAcB1PZL7nkEsybN09F0k855RQ8+uijWLhwIYrrKQESBMGzRXotggIBHx+ro+k7Dmup7j0TC2seS+0+BpW+Wg25l7EK7f/9qf5tKPdCcEAl/H3NRN0Z4ud1xs6dx3PzBaEZY5NxHJkyZUq990lTX6wLglO48EKrX8radJqvZe+z7JLuSCKjIuEPf7RDO+zBHgzBECXS+R8pRSkO4qB6nS3wb5f92GN7ah0bqsqqrPp7riiuQGFqIULjG46yMTWe62QWgqXe7NZw441e+OUXTaz/8YfdqxEEoQ4TJ05UCzl8+DCWLFmCv//+W7VhO3r0KIYOHYoxY8bg9ttvl7argtBMYIezWkNyYJAmjCmG9Z7lZtieFIJdR0Lw3yHNo6dX4vGWrkXR7bDgngUIKMjE+DenIiTrEPyKclAebP7apKzCC9Gh9UwKsDZ92zYtw5EGcmefrZnKCUJLj6SzFs2aRRCaHevWAeeeW6+RXEzPGATHnuiObgnfQCudTs3Qu1dv5eLudexPeCM2IhWpKIE2FR6AAPRADyQE2+68nHc4r6YHekOp7g2lypuDfdb3/rEXR/45gsbw/PPVGD5c66EuCIJzaNeunWq9xvT3nTt34p133lFC/dlnn8VWlgQJgtAsYPu1WlqcAp0p7yxUt0BxmRce/6IHPlrYDjmFfvD2qka3tscj6aTaxx/FkW2RH6sFEaKSLfdNr6jyQmRIPSI9LAyIj9fq048eBfbts2UXBaH5ivSIiAirFkFoVnCAuuACqLDtjBkWX8aocPygeKuN5ELiQxDW1j53eC9vL9VmTX0uDNiJnViERfgQH2ImZqr7ZP5781FdbZupG9Pb2V7NVpFO4zlG0xuivEgb8IsyilCSUze/znq6dAFWrQL6aa1YBUFwMOXl5Vi+fDmeeuopjBs3DpGRkbj++utVJsy1116Lrl27yjEXhGZCbq6JaZxpj/LSUovv2ZUcgvJKL4QGVmJMn0zcdc6B2j3OTchO1Pumb7K8EUaj+Xp0U0JCtOg59QaN5OrZPkHwZMQ4ThAagk1DP/kEOP984KGH6n2pt6832gxpo0R0Q/iH+qvouzWvNQf7oD/44IOqHZIu1iMRiZ6RPXEkVotSV26vxHUPXodDRw/ZtO7sPdnqQtwWkU7St6XXROHrS43Xydplvu2btZim5h08aKamThAEm/n4449x+umnq0n3UaNGYc6cOWjbti3efPNNHDhwQC0ffvgh2rfXfDEEQfBsWHbOREHVI90UGkXWU/Kmm8UN7pKL6eftx5i+lsf04yJd89GpC5vRsCX6Cc7uloiJ0dqysRuPIDRDbK5JF4QWyZgx2mIFFN8RHSOQvbf++nS/ED+V8h7ZKdJij3JrhPqwYcOUiztN4liDzlR4urvPvW4u/HL84L/THxfccQFuu+o2XHn2lfCusW6tP9pdcLTAZpFOAc66/Oiu2sSBOSpLjq+T0XS2fQuKts1Fti4//QRcfTVw+eXAm282alWC0OKhQRwn/1555RWMHTtWIuaC0ELarzGbvBbBwZp5XGWl9q8Fkd7TpA69IZEenrIT3hWlqPINOKEe3aKzuzm4PQz9s0adqXVWXNsIgichIl0Q7IFOZUOGAMei2HWJ6hKlDNjq6x9Oka5e2zVKtTCzVRDrMBLft2/fEx4fcskQrH97Pcbyv4qxKP2gFB9/+jES+yWix7geSBiRUG8Un9F0//C6uW8Nw/eFJ4bDJ+DE00tVRZVaTGFtOjMKIjvaZnJnCsvTWE+3aZOW+cb7giDYx+effy6HThBamEinP9wJkXSKdAphDqxMMzehosqAXUc0H57e7RoW6SXh8SgJjUVgQQYijmxDVodBtZ8v94a/bxWC/W24FoqL01q8MJreSat5F4TmgqS7C4KtvP467Y+1sC2bilpIe2eE3BLeft5qUX+E3l5o1ft4j3NH0WFcB7QZ2ka1iNPN5IIrgpG9PhurZq/Chnc31Pv+soIyq2rM61JdVY2MHRkNprqbvj59azpSN6XCXiZMAObPB/7+WwS6IAiCINgq0pnyfoKJOwU6U97N1H3vTw1CeaU3QgMrkBBtRV24wVBvyjsj6aGBVfDztaFDFLePOfKcoWe0XxCaESLSBcFWRo/WWn/QNKkeUzaKdHPRZD0l3pTQNqEIimlcynddfPx9MOrRUZjy+RRM/XIqhvxvCDZ224g1WKOe3/3HbmzdUr87c32ZAPWRn5xv1hTOnEjXYTaBvWn/5Mwz6+0SIwiCIAiCGfTGNWa7otI8zozD+/FU90Lz7zNDdrv+FkV6abk3okMtO8lbpE0bzZTmwAHb3ysIboyIdEGwlZNOAnbs0CLq9ahCRtMThiWofuCWUt1N0XuT20pdwW8Ofl7nPp0x6/lZGH3XaKR4pcAb3njjsTfw5tdvoqKynpYndpKxLcMmkU4yd2aqOvXGQI8b1qU/+WSjViMIgiAIzR7GGpKTLQh0wjR3M+ZxO5JCTuiL3hB6JD2Sbdiqq05In48IsSMazmg68/Q3b7aY3SgInoiIdEGwh7quxhb6pzPVvO2Qtqp/ekB4QL0iPSAiwOZousHLgOju0da/3mDAlPFTMP6G8er+wOqBePPLN3HhPRdi+77tNennW7ZswbKly9S/vG8PjKQXZxbbJNJJxnbzqfLWsmIFcPvtWre8tWsbtSpBEARBaNYwAM24AwPSZmFdOgMSJtF0anY9kt4r0fqyuPzYzqjwD4ZveTHC0vfWdnY3GBEZbEckXa9NP3IESEmx7/2C4IaIcZwgNIbCQuC22zTTkkWLzLqLUnhzqaqqwg6OhBTpoX4WDefqCtv6oDt8SFyI+reixPpoeO8JvbF/7n4gF5jkOwnLDyxXQn3i8Ikqmp2dfdyZPiY6RvVkp5O8rdDh3nTiwRqRXpZfpvq029tD/tRTgXvuARISNG8/QRAEQRBOvHyh7l63Trt0oRY3C5+gG2tZaY2z3JHsAOQX+8LPpxqd42zIfvPyRk7CSWi1b7VKec+P664eLijxUfXoseF2inRG01mTvn+/NvgLQjNAIumC0Bg4a/v998Dy5VoI10rMRdKJirhHWG9Nzpp3RscjOkTAFpiK3/Xsrur24IrBuBt3Y0r1FKxatQobszeiBMfrybOysjBz5kysXrUatsLU9dK8UptEuvrMXVmqT7u9vPAC8H//V0/6niAIgiC0ULZvB77+Gvj2WyApCWjbtp4XM4oeGQkUH78u2H5YS3Xv2qYQvj62jdXmzOPyi33QKrwMIYGNSFdnt529e4GixpXMCYK7ICJdEBoDzeM++QRYskQzlLOC0PhQFfm2REyPGKs/XjemC28fXm87NXP0uqAXBt86GK36tgIMQB/0wW24DQlIQBKSkIEMVKNa9Vwnc96fY1fqe9buLJtFOvu0U6g7Ak6u80JEEARBEFo6NGr/91+t5Rr7onfubLYFem1iYzT792PssCPV3axIPzYZT9O49q1ONJu1iYgIICdHm3UQhGaAiHRBaCxTpwKjRln98the9RvEMZpOIW8NPoE+NZHxiI4RNtezdzmzC8Y9Ow6db++MNKQpM7nx0OrVc5CDQziEYhQroZ6ZmYlt27fBVtjGrTirWPWBN1ZbP+NOp/eCo9Yb0piDHjJsz3bRRcB77zVqVYIgCILg8TDYzCRARs/pCWdVV5TwCC2lnMrexNndFtM4ndw2vVDt5aP6pQfmpqCi0gBvLyNiwuxMdddhzj53Zv164IcfgFWrGrc+QXAxItIFwZGkpwOPPVavw6jeH70+WvVpZdYVvi6mLd6iOkdZ9R5zlPiVYCVWogpVaIu26Id+8IEPKlCBZCQjFanquZzsHLvWzz7ojI7bCnunm6bL2zNmn366diHSurXdqxEEQRCEZhFFZ0txtj43Y6FjGb6BA2lREXIKfZGSEwADjOieYHskvco3ALnxPdTtPn+9hE6L56CVV4b99eimcOaB6e6HD2s5/ZL6LngwItIFwVEwr/qUU4BnngFmzmzUqii+Y7o3nPZumjZP8R/ZMdKuz4uMikQpSnEYh9X9ARiADuiAcISr+/nIx0EcxJ7UPXatn2Zw9qSvM73+6PqjqKqwv07tgQeALVuAyZPtXoUgCIIgeDy7d2tRdJsnrb28NAf1khJsP9Z6rUPrYoQE2Dc2Z7UfqP6N270c/dfOwfAdH8Hf175OMrWgsR1t6tmBJz8fSEtr/DoFwUWISBcER8GirkcfBXr2dIgiZPp6YFSg1ZF0Etk5UqW+20rvXr2Vi/su7FL326GdiqjHIQ4d0RFBCFKR9Oe/eB53zbwLGTm2t0ljyrs9sI499d9Us8+VF5araHvaf2kWU+lpHtehw/H7eXmaq60gCIIgtBQ47rEWnaXbNkXRdWgeZzBg+yFNpPe0ox5dZ9+IK7B84J1I7TVW3W+bsh4OhTvIendpySZ4MCLSBcGRXHWVNgr26dPoVdG1Pa5/XL2GcHpNug4FOtu42Qo/g23WWIeejnR4wQtjMRYX42JcjauV+/v5/c+Ht5c3FqxagLNvOxvfL/q+UQ7stlCYVqjaudWlIKUAeUl5yD2Ui5wDDafi79kDDB8OXHklUO2ASXtBEARB8AS2bdMq8lq1su/9H/0UhSkfn4tf1ser+73iThyTraXYNwIbBkyD8Zpr1X3/g7u1XHxHQlc8NoFnlqMgeCAi0gXB0dBcRYcjYiOErF+wn4qOWzJ+8/E/0ZI1slNkve7xlmAf9AcffBDbI7djD/ao9HeKdeILX0yOnYzvXvoOvTr3Ql5hHh5+9WFc/8T1SE5NRlOQuSsTpbm1B/GitOOtVphOT3O6eteRqbVRZV/YI0ectqmCIAiC4HJYkr10KbBokVaLHhurZa7bCm12/ljog6pq7c1hQRXoH6mVx9kDW66FB1coLx21UfyAnTvhUBj5z84GMmzP/BMEd0BEuiA4i7lzgW7dtBZtjYB15uai6eYEui7eo7tH2/VZFOpvffgWznv2PHT8v47oem9XjH5Say138O+D6BjZEXNfmIv7rrkP/n7+WLVpFc65/Rx88tMnqKrHLM8RMJ09ZWNKTRu4qvKqWqKdj6duTq3XQX7ECGDePE2kJyY6dXMFQRAEweVO7v/8o0XRSZTtiXYKBqRLSoDgYODjj4GPnj2KMJ8iu4MQecW+aBtVqtWh9+6tPahvpCMDJuXlUpcueCwi0gXBWezbpxVAf/llo6LpNIRjH/SGUt1NCUsIU1F4e+CEQN++fTF63GgMGjUIcQPiEN0tGtUV1dgzfw+M5Uac3eVsvDnhTdwWchv+r/z/kPJBCi67/zLsPrQbzoQO8Tn7tbT24sziE9Lti9KLcGj5IVWrbomzzwbitWw9hZPnFgRBEAShyaE+3boVCA8HOnbU/NTo0WIPun6m5Q6Fvm9sJOAfYHeKekWVAW1jjr1XF+ncWEcTGAgcOuT49QpCEyAiXRCcxf33A3PmAL//bv/IaJLCzgh5faZxdevZ+R5HwHV1P6+7ur392+2Yd8k8LHl0CZJ/SUZsYSz84a+c4Mv2lOH8u8/H61++jvKK8loR7i1btmDZ0mXqXz0Sbi+5B3JrBLklJ/nDKw5b1bptxQrNPoAp8IIgOBdm26SmpqLsWK9lWzh8+DCOSI2KIFgNtSnNzZlN3ljYzYz06mXSko0OdEW2m8eVlHshwLcasXpfdN3Dh9bznFlwJGwbl5Xl+Hp3QWjuIj0rKwvPPvsszjrrLEyePBnPP/88iouLHf4eQXAJdBe94QbN9b2RsMY8okPECY/VR1himF1O7+ZIGJGAkPgQGKuMgBEIjAlEu1PbYdDNg9B5Qmf1mknBk1BRWYE3v34TU/9vKjbt3ITVq1bjhhtuwCOPPIIXXnxB/cv7fNxedJHPSLol2LIteU2yEuyWYBD+vvu0MrgnnrB7cwRBsIIvv/wScXFx6N69OyIiInDvvfdabTz51VdfoX379hg/frwca0GwAhqj7tihXX742m5RUwv+mZ4g0hl4YEpaqe0TbnlFPogILkd06DFBzhA/BX9Fhebu6kiYn09b+1xtcl8QPAkvV86oDx48GKWlpbjttttw5ZVX4uOPP8aECRNQacGJ0Z73CIJbYDTC8NZbCGZxmJ3E9opFcKtgqyLpetp6XWFvL1zX+JnjMfbZsTjvs/Mw+cPJOPm+k9F1Ulf0uawPvHy9EFYUhtlTZ2NY4DD0TuqNFfevwBczv0B6VvoJE20zZ85slFAnDfVOZ8160uokixF1XmOwPv3mm4F3323UpgiCUA8bN27EVVddpSbV8/LysHLlSsyZMwevv/56g8dt3759uO+++3DhhRfKMRYEK6Fn7eHDdvRDN8PRo1rlHsV+164mT0RGaHXfNmbGFJT4oF2r0uNt4DgYO7MuneJfRLrggTQ+xGcn3t7e2Lp1K4I5y3WMbt26oV+/fli7di1OPvlkh7xHENyCt96C1513IoG9T847D4iOtivtvM2gNipCXJJTUm9NummvdbYmq65sfL+xwMhAtZh7vOO4jti3YB+Kvy/GREyseW44hmM91iP42H/ECCMMMGDO+3MwbNiwelvMNRYK9eTVyWg7rK3ZbecE/ttvO+3jBUEAJ8HeRZ8+fXDNNdeo4zFw4EA1yf7WW2/hzjvvtHiMKioqcOmll6rsuR07duC///6T4ykIVsDKEGrnoKDGHy5dN1Og14rKh4VrBepsm2LlbAB9XY1GA9pE1pk8Z7H7ypWOd3jXJwHo8i4IHoZL091NxTYJYe2IMrsod+h7BMHlXHMNjP36IfPaa7XenXbi5eOFxJGJaN23tVXGcHSAVy1OnEyPKT2UwR0JbxeO6FOikYEM+MAHQzEUR3AEqUhFFapqhHpmZia2bXfwrLmFiPvR9UcbjLwTGvHfc0+jfP4EQajDunXrTphEP+WUU7Br1y7k5+dbPF5sCdmhQwdcffXVckwFwUpohkpX9zqXy3bDtHmiB7trYC+3du20D7Qym7Wg2AehgZVoFVF+okjXP4y5+o6EMxXiZyF4IC6LpJuDs+Xx8fEYOnSoQ99DkxpToxr9ooDp885uG9Uc0I+RHKtGEBCAqtWrkbVvH6KpABv5uwtNDLX6OwnrEIacwzkN9hBvDCFtQzDp3UnqdlBMEFatXIU96/YgtiwWgzEYO7ETbdEWgQhEhHcEwhAGb3gj+3A2jCfZpoiNBmOtf62hoqwCadvT0LqP5dl+Xhtce62XmuUfPboKZ52FZov8TbvfcWzO59eMjAxE18keiomJUf9ysi7MzMTl/Pnz8e2332Lz5s1Wf46M9Y1DzgvN4zjSLI5eaUzca6RnrWL7dsbzDOjVq+rE9cVFA62igJICrS95AxRW+KJNTAmCgzllb7KyTp3g5e8PQ1ERqiio27VD1bEP0/+1G55fCgq0xRGpBR6Gq3+PzYEqBx9Da9fjNiL9tddew2effaYG5iAr/4isfc9zzz2HGTNmnPA4Z/H1SLzQMLvpvCk45jhWVcGrsBDV7I3SFMQ5/yP8OmiR/UpUYmiHoRhy2RAsunAR8nbl4Tpcd/yFJucm43YjKm+3b/Kgqr1tJ8ts/rej/pS36dOjkZvrgw4d0mqiB80Z+Zt2n+NYSHOjZoqXl9cJvjFMZdfL2OrCunVGz2fNmqVu6wvfc/DgQbRu3RqBbK1UBxnrHYOcFzz/OI4a5Zj1ZGT4ICWlBwwGIyZM2IXQUDNR7i7WZ+t1UP8Pwo5jt2o9d9JJCFm3Dqnp6cgx2YHd7dvDIbTwVmzyd+0+x9Da8d5gtNZe1Ym89957uOOOO/DNN9/gPNbrOvg95mbXExMTkZ2dbXYGXzhxxoc/TNb/m7ugEmw8jn5+8GXae2AgqufP11LGmgDWZpfkljTJZ9GBnX+fful+GF42XKW5p3ulK6FcUF2AUpRiFEbBC14YO3ssWvVsZfW6GUGnQPc+5A2D0bYZdrrdsz7dP9QfLRn5m3a/48hxKSoqSonR5jYujRw5Uh2jjz76qOYx3p42bRqKiorgT3MnEw4dOoTRo0fXeiwnJ0d1cmnbti0+/PBDjBs37oTPkbG+cch5wfOPIwN0P/ygBY3jHDA5zzals2Z5o1MnI1591UIaOq+vt2wBysuAwiKtcN3MOay80gspOf6YMjwVrSNONJszfPYZvObORfW4cTDefbeKoFOgdzt0CN6NlSrM/6fw79BBqwNwQNcdT0H+rt3vGFo73rv8V/r++++ri3m2WLFWoNv6Hl4A1L0IIDzQIjqtR46XY/CuqoLh339VizZvthup6WniXFjHfnj5YavbHulmdfbM43l7eePKy69ULu7pSFeivLJai6RVoELVp0cgAv3RH1888QXG3D8GbX3aKid2GuK1GdxGfXa922Y02CzSq8urkbIuBe1OaVdvC7vC1EL4hvrj0Sd9MWECcNppaJbI37T7HMfmPBaNGTMGn376Kaqrq1VUnfzxxx/KOFIfmynA09PT1QQ6260xYl63Pv3HH3/EznqMpWSsdwxyXvDc40gPt4wMLdXdESE43TSuZ09eC1jYF78gYNAw7fa+fcB/mwH/YK0NLcfTEm+k5ASgrMILiTElaBVSZl50H6tL9+LfuMnzfG2jRTqvJ9hdh8vgwcCQIWhpyN+1+xxDa9fhUuM4zoazlRrF9tSpU82+hulrl19+uU3vEQS3pls3Ng0G6FTcRAKdBIQHILy9ben1kZ0arjGzxIiTR6gL64DoAJUCrxMfE483H3gTg68ajGpUo01JG+yesRtLHluC1S+sxvKnl+PQMuelpbE2nw75lozkygvLcWTdEcy8PwsvvABMmaK1sxEEwT5uv/12JcIZOf/333/x8ssvY968eXj88cdrXvP777+jY8eOSElJkcMsCHbCsaq0VCXqOQRdpJ9gGmcJGsnFxmqzBcdIzfVHz4QCnNY/A8O758DH24Lg7t79eM83R7dMY8o8negZ9ZcBXfAQXBZJz83NVQN2eHg4Zs+erRadhx9+GOeee25Nj1TdOMba9wiC22Nl1oijie0Zi6K0IlSUaPWgDRHVJQpFGUUoy7etD6qpUGe0jC7uOdk5iIyKRO9evWvari1PWo4jS44osc5UeD4eVRWFLV9sQeLJiSo9XYdRdmYCBEQFIL5DvDKnCwsNq7U+a1FCfO0RJAxPOOG93F8ydXw+/l4Xgiuu90erVpaj7oIg1A/NXZctW4bHHnsMl1xyibr//fffYwLTVEw6tzCC7mMhDTUyMlKluguCUH/ZdUCAY45QUdHxMm7dfL1BmOreuYsWsa6qQsUxmdEjoRAd4xoot6NHFEU+G7wzmj5iBBwGI5f0rgoN1dqx0UG+iUoNBcHjRDoN21ayJ6IZOnfuXEt86wX21r5HEDyK7du1/qDTpjn9o9jCLW5AHJJWJVn1WrZVi+kRowTt/7d3HuBRlOsXP6mEkEIKJCGE3rsovakgiFgRFcWOhWtXvHa9eu3dv4gN7P3SRIqKSi/Se+8kgRBSIJCQQJL9P2fGDUlIz2yymz0/n3FLdmeHb2dn5nzv+563wp/p5YmOHTsW+bc+9/dB2lVpWH9oPT777DMj3fVBPAgkABt+2YAuV3XB4Q2HsXvObsT/HW/0e2f7toHnDMT7497HyfSTCA8LNybvOCFQHk6mnETixkREdilYuJeRlGHc+vrY8NEz8agV4IvTJxuWmB4vhCiZ9u3bG8K8OIYOHXpWint+Hn/8cWMRQhQN69CZiGKVHy11MrUsa9sLNWcoGQphX1+jLVvKydoICzyFBmFlnOjnbABFOp1brRTpdjiDwdmHjAxzUkAIJ6baRDpny3v27Fnq65o1a1bu9wjhMtDMpGtXs8foueea9x2Mf5i/kcaeuie1xNfZRWlARABqh9TGyVTrTec4EVC3SV0MaDIAM86ZgQ9++ACLf16Mi20XY9NXm7D9++0sYs8jC1mohVrY8MYGNls3SE5ONmrfmVpfXqF+LPYY6kTUQWCU2dKO9fd2kW4vYzuVfgr7F+xHQIv6+PcLQXj+eU4KWjQAQgghhAUwi5tCndnmVsUPSLmr8ugzwYj66dM4mu6Dvm1TUMunjL3P27QBfv/9THN2q2EdAPvTMfgnkS6cHOV6CFGdtGgBsEyDaZ8RxffwtpqwlmGlpoj7+PsUSHt3NP5+/njstsfw6BuP4oT3CfiAJ3ngtOdp1OtXD8uCl+FX/Go4xSetTkJUTpTxPkbWyYSJEwxX+fLCSL29h3zm0UwjWl8Y1q8/eF8uvv0WuOKKSre5F0IIISyFpdzEKq+6Cot0lqz4+iIzIxe+3jbE1Mss+3vtefUMYJw6Bcv5Z/LAEOlCODnV7u4uhNvz1VdmClYpbuZWwjT24EbBSN2bWiaRHhAZAN8AX6OW29F0aN0BjT5qhOk/TcfXC7/GwVMH4bHUA8E5wQhBCHb67ESb023QNaur0cJtN3YbQj0pKcmofS8utb44ck7lIG55nFEDn3HkTBS9MPffkIRte2vhpUcz4OVVntw/IYQQwnpoej53LlsUmotV3RupY+0tocst0nkt4++PxNgMRDXNRGTdcoj0qCgzX//YMdMpnka7jkAiXbgAiqQLUd0w/Sq/QGfqexXAlPeS2pyxFVp+Qps7PppuJygiCDc9cBO+/PBL9D2vL7JzspGMZBzAAaz1XIvg1sHwhS+6ozuGYigaoIHxPprTVQQa48Uvj8eJw8XPrtcLycFPbx5Aq7AkJO9MrvC/TQghhLACprcz6JyQYD4OD7dmXNkdlkKderkifo05fnVw8iTQodHx8kX2eU3yTzTdw1Ep74z0c0ZDCCdHIl0IZ4GpXS+8APTo4Zg0ryIi5QFRAWWKpJOghkHw9qva5Jvo+tH4+NmP8fDIh+EFL5zCKWzP2o7F7RZjjc8ao/86+62fj/NxHs4z3OMrCmvume5eEvY5jeTtydi+LgMDBwJ791b4I4UQQogKw4AzPdAaNjQN3qxKdbfrY+rliiT5JZ4MQGSdE2gaUXx2WrHYRbo9395qmLmYr0WcEM6KRLoQznS2HT8eWLMGmDy5Sj6yfof68K3jWyaR7uHpgfDWFk3TlwNG+++87k6cG3IugmHa1k6ZNgWzs2fje3yPLdhipLu3QivUy7XIMacUaDB39102I81w9Ogq+UghhBDirMsGeqRYJc4r3B89H3SEP5bphw5RyfDzLb9PTF5dOu3lmc/viOxFpiCwZ7oQToxEuhDOAi1ZJ04EfvgBuP76KvlI71reaNir6PZiRT3HOna/uhVrwlreXuaF3/uvu/+FSESihV8LNG3aFNm2bCP9fSZmYju2G69bO3FtkcZvjuDFew+h/7npGPfq8Sr5PCGEECI/DAgze9tKKLLtkfRy16P/M3EQEu6F5uHHzJWVF7ZP8fGBx7FjaHbDDfB4801rBTXd55mLr7p04eRIpAvhTNDpfeTIKjWRoxhv3L+x0QrNXqNu75FeFPXb16/Q59RtWrdSvcbZXo1t1hrVa4TJkycj0icSHvBABjIw03Mmcn1zcWz/Maz/aj2ysxxf118/NAef/icOPkcO4fghU6hXQZWCEEIIYQSZ2Rfd39/awdi/32wlzqzwfF2Qywz1dJ263ggM8jAL2yviwP6PAaz/pk3wXLgQ4GIV/IdxIyXShZMjkS6Es5KZCfzxR5V8FAV5RMcI1O9oCvCSxHTt0Nqo27huuT+DafXhbSuXLk+hPm7cOPj6+uLlsS/j/UfeR58ufXAi9wRmnpppvGb79O2YefdMbJ261TCEq4rU90NrDmH+b5lGR73lyx3+kUIIIdwcakxmbdepY836jh4Fvv8e+OYb83Hr1hVLo6f+Danva7Rhq/DM9aOPIufZZ5FyzTXm47/+gmV4epozHDKPE06ORLoQzgjPll27AkOHmjXqVURwTLCRAl+4Hr0w9drXK7aWvThoOhcUHVThdPnCafO9+/TGRedfhIkvTMS7j72L2JBYTMM0HMVRZKZkYv2X6/HL7b9g+fvLkbrbsU6utlwbnn8uB7GxwOuvO/SjhBBCCCOtnBFvqyLpkyYBP/4IrFplPu7QoWLroS4PrqxIDwgAundH4t13w0ZRTRM5eyN4K+D6//4b2G6WygnhjEikC+GM1K1rniHZT6UKZ3tpDsfWbKWJdArlyHMiS2zhVlxLN5rVled9pcF1De07FLM/nI2Ol3bEOIzDdExHomei0QN975978fvDv2PnrJ1wJO88Go87RhzFZx8r510IIYTj5/JZ8m1VTfqGDeZt377ADTcAl15asfUwSF0n0MsM8Veyljw7IgLo3Nl8MG8eLKNBA7Os8M8/zxTgC+FkSKQL4ax89JFpsco+X1VIcONg1AqqVerraofURljrsDKv196+je+jAV1FKU7gB9YJxDN3PYMf3/4RWc2z8GHuh/gMnyE+IN74+7ov1uFEQvF90CtLndo2PHrzYRzdFI+c0zl5vWaFEEIIq0lONjO3rYBp8wcOmPfvusu0xqlMGr0R3WewwQLDN5v9GogivSJGdCUJdUb7588Hdu+2br1CWIREuhDOSliYuVQxXj5eRk/0shDWMgx16pV+JjeM6HzOFLexNp1p9eWFQj+wYWCJr+nYsiMmvTUJT9/1NFJqp2DCiQnYi71GVP3vcX8bNeSO5FT6KRxafQjffGNDmzbABx849OOEEEK4IYcPW5fqzmAyT43R0aa2rij2dnDscobgYCC78iautp49zX9oYiKwaRMshc3lCfupMqrOiYCUFGs/Q4gKIpEuhCuwaBFw663WziKXkvZeVqK6RhkivCxRdDsU7OWJwtthGj4nBkrDy8sLN116k5ECz1T4GZiB0ziNpI1JmDJmCrZO2YrUPalGLTnJzcnFxo0bsXDBQuOWjytD+pF0LPwtw/i69uyp1KqEEEKIAtA0ncZxNCqv7r7o+WHgnB3ODJFOYW3FpDhX2K+f9QZydho2NG9Z907n1xUrquxaS4iSsLi7ohDCIe4wLA5LSwP69AHuvNOpBpnO8GzflrIrpcwi3W5Sx/eczjhdLpFengh8RFiEYSq3aOAi/PTuT+id1hvZh7KNNm1c/Ov5I/jyYHz181dISk7Ke194WDjuvPNOw02+ooy9Lg7ntQ3BLQ8yLFE+kz0hhBCiODIy/jFoq3jlWAGoT60S6cwgNyL8hlK3CKa8//47sHQpcPfd1veds0fUObA0k2vVqmL954SwEEXShXB2eBZ++WVTnI8YAWeEZnMlRd+LaunG15clKl5gPfkM7crjLt/v3H5467O3kHRZEn7z/A07sRNZyELGkQxs/mwzklnclw8+fu2117Bs6TJUFJbOn985FQcW7kPS9iTk5tiM1HdeAwghhBAV5eRJU6QzyGxFt9ddu8z77dpVXqQzum9sF4va2fO8og7v+WE/OObi8wMo1B0FxT9P3uyqY8V2C1EJJNKFcAXuuw/49FMgJATOCKPbJZnBFRVJJ0ExQaU6yRcn9uu3N3u6lxW/Wn544M4H8Oy4Z7Gjww7DBT4DGQhFKFqhVYHX2mCm6E2YOKHSqe9MqU/ekYxH7kzD/fcDl1yiTDohhBCVE+lMebfC2Z2BY9aSs5lM/fKdVs+CupY17Ya/KwMMFOrsE1dZuMILLzTvT58OTJlifX16/vT3ffvk/CqqHYl0IVw1Bd7JCG0RWmwqur39WlFO7REdI8r8GfkFfe2w2kbf9fLSPKY5vn75a9xy9S34Db8Zz52Lc3EJLsEADEA/9ENf9EUv9EJQUhA2bbbmQqBH62OoG5SLm26yzpFXCCGEe4p0YkU30/Xrz6S6V3Z9BVLwme5OxW5V+tgFF5gbuH8/8NVXwHPPmX3orIbRf/ZRX7v2zEALUQ3oUlEIV4JOMeyPwpw0R5ycKgGj3DG9Y4oU6sVF0kmd+nUQ2jy0bJ9RKOper329Aq7xZYWTA52bdEY60rEO64zn6qIuohGNGMSgERqhCZqgJ3ri4OKDsIKu7U5i9vg9uKxnYp7DvION5oUQQtRArNKOPActWWLe79at8uuj3xr1bR5RUdaJdIb6H3rIjKjXq2c6x7N9miNgjfqhQ8COHY5ZvxBlQCJdCFeCuW0LFwIHDwIzZ8LZ8A3wRUyfGAREBJRak56f8Dbh8KvrV6qwLhyR54RA/Q4Vy88LCQ2BF7ywBVvwLb7FD/gBP+Nn/IJf8Dt+xw6YJ+e0uWlIi0szDO6O7j+KuL/jDPf2ihAanGO4ynMdJ47lGNca339foVUJIYRwU+gja0WqO7uPUIvS7M0KkU4KeLqxRM/K2WhG0ynU7f48f/zhmNlu9pFjFgBr0zkRwJkMC3q+C1Ee5O4uhCtBR5YvvzRzyvr3hzNCQ7fo7tHISMpA7LLYUiPpdhO5hj0a4sCSAzh1omizFq6DQr0w7OmeFp+G9MTyCef27dobLu40ifOEJ3KRi0M4hCM4Ytz/G39jtMdoNDzVELPvmV3gvX6hfrj43YvhF1JwYiE7MxtpsWmo26wuPL2KnwPl2Hz6ZCrmzw/Hhg3A0KFOazcghBDCCSveKKwriz2Kft55lTdjZ107T9EF1sPcd84msICeaeRWweufzz4DYmPNaDeN5ayGBfoMiLAegNsfGgq0bWv95whRDIqkC+Fq9OzptAI9P/7h/giIDDAEONu0lQZfE9Mrptioe0kGcxGdIkoUxUXB17PNGvH4579gBKMpmhq3NI/7yfYTTnicKLANvoG+yEzJxNK3liLreBYOrT2ETT9swrxn52HqDVMxZ+wcLHt7GTZs2FBi3/UbhiTjzhEp+P6LLAl0IYQQZU4pZyS9ss7uDEAvXmze79u38pV4qanmNhWIpNvN46xua8J19u5t3v/zTzgEmsfQRI6t2DjzwGbynIkQoopQJF0IV4Z16QsWAFdcAWckrFUYTh0vexsTRsvD24bj0JpD5RLpFPY0rmOrs/LAPuhPPPEEJkyYkNcnnSnw7cPbY+AlAzF16VS8t+s9+MIXzRo3w1P3PIXmAc3xx9g/kLgxEdNGTStyvbGLY7Fh8QZswqZi+67z/D/25iPw8knBqRONjFIB9qrlZL29ZasQQghRuB6dmdcVjXxTULNZTEoKkJBgRuQZSa8oNG9nynxQkFk2Tv2cBx9QqPPDrGrqbueii8xUdJYAjh5tZho6iogIIC7OjNw3aeK4zxEiHxLpQrgqPLuecw6QlGS6kHboAGfDL9gPwY3Ld2KmY3vKrhRkpWWVySHeDkX6sdhjRu14eaBw7tGjBzZv2YzUlFSjVp2p8Iy0j7xqJCbNmYR3v3kXm/Zvwg2P34CrB12NUaNHYcOHG9irDXUi6hg19WGtw5BgS8DPE35Gd3RHJ3QyjOn2Ym9e33VOCOQX6iTndA7ilsehVosYDB3qY0RJfv+98v1qhRBC1Nwe6SyZrgizZxf0W2NyXmX0LYPkYWHA1Vebgv+sNHy7wLUa2tFzRpvXQuydbm/R5gjsaQtbtwKNG1tjqy9EKSjdXQhXhScnnl2bN7c+lcxCQpqWv9iaorcwpfVTZ1p9RU3kKMg7duyI/gP6G7f21HkvLy+MHDoSv370qyHOyZQ/p+C2r24Drgcu+/wyXDbhMvQa2wsthrbAl1O/xC7swjZsM17LNm4t0bLUvuucWNgx/yD8auUaF0s0xBVCCCGKi6RXpMSbKe7z5pn3L7sMGDsWGDOm8ttDkU5X9yLr5PlHpomzdvzAAVgG09EGDTpjIOdoWKPO/unMChCiCpBIF8KVmTjRNDXp3h3OCsVzeaE7fGCDwHKJdPv76japYHihBEKDQ/HyAy/j+9e/R5umbXDsxDE8//3zuOWVW7Bx50bjNYzE21Pm12ANtmO7cb8buqEd2hlCPSkpyXhdUTQIzcT3L+3BpC+Oq0ZdCCFEsaKYYpsG5OVl+3YgPt4MDI8aBQwYUKhlWgXIzDT1a7Ew8nzxxUCfPubsgpV13YyeM6rNenGavDmSwECzVsDRnyPEP0ikC+HKcIa6su4xTkpU16gCUfiyiHRSv3191ApyzJh0bdsVk9+ZjKfvehoB/gHYtGsTrn30Wjz7wbM4EFcwQrAaq7ERpoDvgi7ojM7GfabUF0dA7RzUTj2II1uP5KUlDh8OHD/ukH+OEEIIN+qRbo+i9+pVyOCtkrAevVg4C8ByPC52oWsVLIJn2Z8jDeTyw0Hbtcsxbd+EKIREuhA1AZ4wJk0Cnn0WNQW2W2P6evOLmqPZoGal9lrPe5+nBxqc1wBePhUIM5QBby9v3HTpTfjto99wxQVXwGazGXXrz33xHFKRmpfaTijSGVUn7dEeHdDBqHkvDdbk71mWgNtus2HaNOCddxzyTxFCCOFi0KitIiXR7CK2aNGZduNWkJ1tRvSpvUuFYp2i2upZZxrIkblzzQ1yJOyVyhp4WtkL4WAk0oWoCbDZ9rXXAi+9BKxYgZoEHd/LKtDz92qPOjeqyL7qVhEeEo7XH34d3732Hdo2bYv0zHSjx/p+7EcGzngEsD59JVYa92kmF5BYttzC00nH8PkbSbj2WhuefNJh/wwhhBAuMA9Pf9hZs8yy6Iok0K1aZQaxmYDXqZN1UX26zJdJpJOYGHOWwUpY7md3kF++HA6FEw1KeRdVhES6EDWBzp2Bu+4CnnsO6NixurfGKahTrw7qta/n8M85t925Rgr88/96HnX86uAUTiEOcTiIgzgN02meZnJbsMW4v3L8SsT9XTan2xahKfi/Jw/nmfHwQm3KFLVqFUIId4K15Ow0tnevGcStV4FTmz2K3q9fxerZixPpzAAvc107I+k0fLOyLp0OekOGmPd//RUOhRP//Afv3q2Ud+FwJNKFqCl8/DHwwgsVb55aA2FNe0Xc5cuL3QX+r8/+woVdzTYwJ3AC+7APyUhGSFgILn78YsT0jUFudi6WvLYEe/7YU6Z1s61c4ubEvK94xAjg8sttRqs2IYQQNRtmVy9ebLZJowdbo0blP81TTNuT7Pr3t27b7M7u1N1lwm4Db2VdOqFI50Ywq5C9zB0Jo/aJiU7dVUfUDCTShagpFE7tpouqMKLpderXKcPweSCsZVilRqxuYF18+PyHmPrOVLRt0taoT6dIj/OOw0mvk+j5SE80HdgUtlwbVoxbga1Ttho17aWRuicViZsSjWuD2rVt6NQwBSeTLE4ZFEII4VTQOZ0CnWXcDRpUfD0U6Oytzvae7NpqFbzMKFdUn3nxFOpW16VzI847z7z/yitmVuFKs8zMcjhDwtkJqycahCiERLoQNQ32Ib3iCuCWW6p7S5wCiu/IzpGlGsn5Bvoa/dnZxq2ytGvRDlP/byreGvsWIsIiEHc4Dve+ci/ufvFuhA8PR5vhbYzXrf9qPdZ9sa5sQn1vKvo3j8PM8ftwy7AkxK+Mx/FDx5ESfxLpSRmG8BdCCFFzYB06U9wZQa8M+VPdrbZqKdHZvSiYCuCIKDQbvxP2mFu3DvjoI8fUhrH+jC58arsiHIxEuhA1jeRkYOZMYOpUYE/ZUqprOjSfC2tdcpS8dqiZPxh5TmS5jeqKmxy4dMClmP3hbNw14i74ePtg8drFuOKBKzDHNgdtR7U1Xrf95+3Y/GPRvdMLk56YjujwU8ZFFkX5geUHMeySXNx43WlsnL4bCesScCr9VKW3XQghRPWyfz+wZg0QGWmWXZcX6sgXXwTuuMM0jbM61Z3rL7Oze374D+IbGdq32puHUfSxY82NSkoyxbqjUCRdOBiJdCFqGuwZOn68eXJq1qy6t8ZpqNukLvzq+pUq0hlxj+4eDU8vaw6PdWrXwSM3P4KZH8zE+d3OR3ZONj6f9jnum30fvC/wNl6z6YdN2D1nd7nXvXZrbazY5I85SwNxKNHTqF/fN28fkrYnWbLtQgghqh4KYAprdhSrW7di66DAZ8Y3y6fpYdKmjRnEtlKjsry83NtHkU4DObqxWw17sQ8YcKbH3O+/wyF4eztm+4XIh0S6EDWRMWOAdu2qeyucCka2G/ZsiIDIotPZa4ecceKpFVQLUV2jKvQ5/mH+RT7fuEFjfPzsx/jkuU+M+0dSj+CZec9ge9j2PNf37dO3lyn13U63Difx+X9j8coDh9Ckgekkz/cn70hG0jYJdSGEcEV27TJbrTVsWPF1LFli3l54IfD222ZU3UqY7V2/vml2Xi6YFsDC+GPH4DDsvdM5S+GInuZ08WOkXggHIpEuRE3n4EGzRkuYUfJu0UakPKJjRJ6g9q7lDR//gvmEFPMhzcrvDB/SPARhrYpPrR9w3gDMGDcDj97yKPxr++OH5B/MPursg/vZWqz5dA1yc8pu3d6z00lc3PeMgc2eOF88+0EEDmxIQcL6BMNNXgghhGtE0BmhZhSc4tfefrMi67G7udP4vGXLivVWLwl6p7HteYXg7AOj0VanvNthEX/r1mZN+ty5jjGP4ywFnf2EcBAS6ULUZCZNMk9UDzxQ3VviVNAcjunvjJZ7envCL6ToNPh6beuhVmD5rmz8gv0Q3rpkAzpfH1/ccfUd+PXDX3H5+ZdjFmZhDuYYf9s5aycWvrQQp0+akfHywJTGR9+OwqQ5dfHqxPo4duAY9s3fh/QjcoIXQghnZts24LvvzNM259bpxF4Zwzl6s9FInZcAVsM0fJaVc/0Vwp7yzlz89HTHGLwNHmze/vGH9T3NKdIp0GUeJxyIRLoQNZm2bc3pbp7xeSIUZxnK0dHdXo9eGA9PD1PIl7E+3cvXy1gn4fso2EuCzu9vPPIGvn/texxrcQw/4SecxmkkrE7Azw/8jPRytlljm9in70xE+xaZeGCUmYpHsR/3d5xhKqeouhBCOB8UvRs3AkePmsfxpk1NEVzZVPfevcvRw7wcMNpv76ZWIZjy3qKFeZ/p6Mztt5q+fU0xzeufzWUzZy0zTEugSJd5nHAgEulC1GRoorJsmXnGrlN6r3B3hBH1oOjie8iwPr2sRnL5RTkj9HxfWZziu7briklvTcLND96M6UHTcQInkHM4B5PumoS1i9aW418DnNvuJCa/vR/1Q89EJuYur4MDW48jdlksck47IGIhhBCiwsTGAnFxZvp4aGjlUtPzp7r36eOYL4UBZAbCK3VZwb7mN9wAnH++mQZmdTSdAp0958gcM1PNMux97BRJFw5EIl2Imk63bo6ZSq9BhnL26Hdx+If7I7pHtCG8S6JWcMErK643pncMfOuUXljo6emJqwZeha8mfIWTw07iCI7AL9sP695ch5defQmLly3GwgULsXHjxlJr1vP3wV23zQ8PvBaNKx5ogri9ZlQ959SZi6HMY5mIXxGPXb/vQsouudUKIURVwkzsLVvM43ZFa9Dzw8YuTJyj2KejuyNgKn2F69HtsCY9OBho0sS0iGcagdWwIJ8sXWp91JvXVY40vxNuT8lXpkKImgNnqSdOBK68EoiIqO6tcTloMteoTyPELY9DdmZ2sVH3wtCQrlHfRkYUOystq0wt2+6/+37sG7wPfzzzBwKPByJiWQQeW/YYPOGJEISgXlg93HnnnejVu1ep6/P2tiE64jTaN89EWN0cZB7NQezSWCACOJlyEodWHcpLgz+y9Yjxb2N2gU8dH2MCQwghhOM4fNjM9rbqtOyoVHcGu7dvN7U1I+iMpFsW8aZQX7++EvnzxcCUeq6bA3zPPWbPON4yy9AKh/eEBGDTJjP1gWZ1VsyyCPEPCq8J4S6MHm22ZnvyyereEpeFIpyCm7XnRVFcDTpf37BHQ8NFvqw0adoEbUe3RQpSEIhA3Ipb4QMf7MM+7E/ej1dfexXLli4rdT0dWmRh6rv78MI9h/Mi7Olp2di3zxfxK+PPqlNP3ZuKvfP2Ytdvu3B4w2GcOuEg910hhBBGqjutY6gfKwtT3ZcvPyPSrYSBbkbnOc9/2WWVaw93FmzgzpQCq1PeedLjxtr/AawpoDufFTD6v3+/2Yt9xgzg55/NWQwaDAhhARLpQrgLFOg8w7IOTFQY1phHdo4863nWrDP6XBxMfW9wXgPDjK4sMKX9828+x3zMxzEcQxCCcDtuRxd0QQISEIc4vPfxe2Vq11antg2Bdc687t2v6+Gaa1pg2p+BxX9+di6O7j+KfQv24fih42XaZiGEEGWHmpQ90WnCZgUMRjPVPSTE9I21kpQUoFkzc6FAr4yx3Vk0aGCmvjsi5X3QIGD8eLNRPFMLaCLHmZHKwlkVWue3amVG648cAWbNAn75xYyus4bh0CEr/gXCTZFIF8Jd6NkTOHDATPUSlYI91Os2rntWlL209HC6yLNPe2m17WTzls1ISk5CJjKN9mwHcdCIpA/DMDyIB9EQDbH+6Ho89OpDSDlW9lry7Bxg535fZGZ6IjigdIFvy7Xh0OpDRoRdCCGEdbADGbUd58+tTHXv1ctaEc0IPQPddJ13CGwKT6HLmQCr4XmZBfSdO58JUjD6bSV0q2c2AJf4eHP9s2eb0fXVqxVdFxVCIl0Id0IO75ZRv2P9vDZrderXQWiLsl1l8bWsbS/N9T015YwoZlu2BViA1ViNDGQYUfXrcB1aoAXmrJiDIWOG4MvpX+LU6dJT0729gE+fj8Onn+7FBd3PGOkcO1H86cBmsyFxUyIOLD6AzKOZZfp3CiGEKBnquVOnzPJmK4T033+f6T5mJcnJQL16QHQ0HEfLlmakO6t075YKc/HF5u3cuY75HNamc7KB0XVG2VlvP2+eKdodMQEhajQS6UK4I2vWmIVlciatMIyas3Vb4/6NjXpzRtfLCqPujQc0RlDD4lu/hYSGFHhsgw3bsR2/4Bfsx354wQsjMRJDg4YiOz0br332Gi5/4HL89fdfhqguCV4H9ep1pgd7+kkPXP1wYzz+biSOpxd/WjiZetIQ6knbkowIuxBCCOdIdd+wwUx1Z6m01anuzEKn7nSoLxpnALjQSc9RnHOOOdtAp/fFi+FwaIRH0b51q1m3TsG+YAGwbZs5OyNECUikC+Fu0KL15puB6dPNGi1RLXj5eCHqnCiEtSzazbZ9u/YIDwuHBwqm0OciF0ux1KhJ94Y3eqT1wONej+MGnxvgGe+J+165D7c8cws27dpU5m1Zuq4O4hN9sHKTf4H2bUXBCYDkncmGWD+VrosMIYQoD2lpwF9/mcFVpruzftyZU93ZCpxJeNSaDoUb3a6d6aJntYFc/s8YOtS8P22aeT3kaBhd5wwHI/ecSVm7Fpg5E5gyBdixo2q2QbgkEulCuBsMo77zDnD99cBDD1X31rg94W3Ci4zC04iObdZIYaFOlmAJQi4KQd2mdYEcoNXpVrgZN2MsxiJkYwhGPTIKj73zGA4dKd245qJeJ/Ddawfw5thDCPA/c8Fw6nTx72F/9f0L98tUTgghysHBg6ZO27PHzIbmUlloKG53de/Tx9qvg4Ht5s2B+vXheDgTwAJ9R6aGM+Wdg06PnlWrUCVw9jsqynTd42DyNjXVNJr780+lwosikUgXwh0ZPBj4/nuLe6iIisKIekDE2UKdfdCfeOIJhBXqHRsWHobHnngMQ+4fgiHvDcHgdwajxSUt4BvgiwAEoBd64SbchDnz5+Dif12Md795FycyztSfF0XXtpk4t93JvMeLVvtj2L1NsWJT7RId4A+uOojUPTKVE0KIsopeBnTZVjvy7EYhFYIBWka8aZDevr113wOD2pzXZ/p8aVlWlsCQPaPpLIJ3FHRlt0fTJ082HfGqGhrN0cyOrvb88qZONQ3mOHPDnu5KhRf0ENIoCCGMaXhvHQ6qC7q9R3ePxvGDx422Z1nHspBzOidPqPfo0cNwe6eZHGvVmQrPSLu9Np6mdVzOGX2O4cS+YtwKNDzeEGP8xmBq5lR8MukTTJ4zGfffcD9GDB6R50K/dMlSBAUGFVgf4TXLR/8LQ2yCL/5YFojuHc6I96JI3JyI0xmnUa9dvTK3mBNCCHeDWdzs/mVVHXpCgqnxHJXqzvVzMqFK5/NpIMdecqwLcBSXX262SmNtOFulWTmzUV5Xe6bCJyWZZnacEeH5mQPetatpp29przvhSuiqXAh3hidB1qUz3WrFCnN2V1QbgQ0CjYVkJGUYEeoTh08YArpjx45lqnNv2LMh6kTUwbxn5qHu8bpGb/U0rzSsOrYK73z0Dj7936cI9wjHt3O/xfvj3sfJ9JNG7TtT6zkhQHiN8Ol/4jFhSijGXHsmosHSOV5DFAVbtNH5PaxVGLIzs+Eb6IvaIRbkcQohRA2BWdz0aw0Pr/y6OJn6wgumQ7wdK1PdMzLMY36HDsUf9x0CM8datDB7jTsKptQPHGgaA7A2vLpEuv2ESzM7LnabftZE0GiO48AvgPb/dO0rlFUnajZKdxfCneEZ+MsvgXXrTCMT4TT4h/sb0fW6TQr2Yy8LIU1DMOiNQWg6qCm8a3sjKCcIF+JCPIAHEJAcgA1JGwxRfjLHjJAnJyfjtddew7Kly/LWwdr0h29KQu1aZ1IBH383Cq9+Vg8ZmR7Fur/HLY9DwvoExC6NxYmEklPshRDCnWDAlCnkDKBWFjrDU6BTu3XvDlx9NVCGudwyExcHtGljlk9XOfxge9CA7nrM9rOaq64yZx9Yl753L5wG/rvt6Qu7d5sGdz/9BEyaZKZM0MJfuAUS6UK4M+zVMn68aV7ClmzC6ajfoX652rvZYXu4Hg/0wJVfXYkeD/cwItx0g2d/9Y7oiBXLV2BH5g4kIAGnYLq0T5g4Abk5RTvNbtldCzMWBOGbGSHYG196Hx62aGO9+sHVBw03+KzjDux9K4QQLlSPbgWLFpm3PXoAzzwD3HJL5SPeLIVmpJ+BXJZuM+O6SqPodmiyxtp0e6SZsxtWw3rw3r3N+6wJdzYYPbebzFG0c2Zn6VLg55+BnTvlCu8GSKQL4e5cey1wySVV5Aojygvrxxuc2wCRnSPh41/+cgRvP280vaApIm6MwD7sM/qrX42r8WStJzEMwxCOcBzAARzBESQmJRq170XRrnkWJvwnFmNvOYL2zc8I7pI8d9iujXX27Ku+b/4+xK+IR1aaxLoQwv1gMJj16EFBlV8Xj7v2Nt9WprgzoJyZaU4kUKBXiaN7UXBmoF8/8z6FKvuaOwKmH9hnPMaMAZ5+2nTgcyb4ZdAziL36WK/PpvUMrLDfOtu6iRqLatKFEGfg2ZknKHttlHAKaMYW3CgYgdGBiF8ej4zkjHKv4+ixo1iGZTiJk2iBFvDN8kW3f/5jJD0WsViHdfhl/i9o164dvIoI9/Q7N8NY7CSleuG2Z2PwwKgko41babC+Pj0xHUExQUaGQH6zOiGEqMlQW9EGxorT6/btZnCZncTOPdeKrTM7gtHQ7tJLTZd4BnKdAtaPO6qXOCcAWCtATx6mD3CZPh248UY4JTwvN2pkTlowTZ+1E8wGYM0Dv7BqSXsQjkLfphDCZOFCs8/K3XdrRJwUilrWqdcOLb8hG13hbbBhLdZitv9s9PmwD/Z67zVEuy980RzNjQj7vj/24coHrsS8lfOMSHhJ0Fhu54Fa+OinMMO1uCxwnccOHEPcsrg8B3tR88nNzcXUqVPx0ksv4bPPPsMx5tSWwr59+zBx4kS88cYbmDVrVqn7oxDODEuJGfisVavy67JH0akvrVifvfSbpeBsC0fx7zTJdSzLoziloZoj+Pe/gTfeAO64w3zMKLWz132zFoHO7zTXY636d98Bs2c7/3aLciGRLoQwod0sc/E4o+zIHqXCknZttQLLd2XGNmt0cfeAB3I9chHZLxLraq3DNEzDLMzCNmwzXjcQA9Ejtge+e/E7PPTAQ1izfk2x63zk5iTcNSIZL92fkFdnSR1VFi1Fkzmay51KN+vhRc0lJycHQ4cOxdixY5GSkmII786dOyM+vy11IZ577jkMHjwYf//9N5KSknDfffehd+/eyKDltBAuCHddHhsrG+xkUNnecs2qVHdG+NminPP0TgdFOkWpowQoZzk4O8EUAvYu5+f8+iucHm4327exVp1RdLaS++sv50vXFxVGIl0IYUKTFqZ5MY9ObT6cGrZai+4RbdSblycKT0d3QqGenzSkGRH2kAtDjMdMhx+EQei1vxe2PbsN7971LvbE7jlrnbV8bYZQZ726nSl/BOP25xpi38HS6+dZn75/wX6jfZuouXz99ddYtGiRsbzzzjtYsGABgoOD8TTrP4uBon7Lli15kfSVK1di69at+Pjjj6t024WwCqvml9jam/Po1GasG7eCI0fMzO9qq0EvCYb1WY/tqLp0O5w9GTHCvM9rIVeo9+bsOE0OOJHBdm3cOVhf7wg3fFHlSKQLIc4wbJg5nS6cHp/aPkZP9PIIdfZBf+KJJxDKGr98hIWHGc8PeWgIhvzfEHS5vQvqdauHU36n4AlPRCVE4et7v8Z/3/svjqQeOWu9dITfuHEj5s5djHe+DsKy9XUwb0XZHOn53sRNiYYTfG62g+oORbXCNPdBgwahIVsKgeWTvrjxxhsxbdq0YlPYe/XqBW+aJf1DeHg4mjZtiv3791fZdgthJaz5tncVsyLVna7uLEW2ApYrMc3daaETO+uvHQ3N6jhTwXKcP/+ES8GdiynwjKhv3FjdWyMsQMZxQoiimT8fOO88M81MOCVMeW/crzHi/o4rc4szCvXuPbsjF7l44P4HEBQYZKTC203c2GOdS5sr2xiPl09fjt2f70YbWxtgLjBp3iT4N/JH1wFdEdowFHsS9+DLaV8iKdlskROEH+DrNwYtw5ma2NN47tRpwLeUi9Pjh47j1IlTRoYAJyBEzWH79u24lKmk+WjZsiXS0tKQkJCAKLZbKoVNmzZhw4YNePLJJ4t9TVZWlrHY4frt6fZcRMnYx0hj5ZhxpO5j9Lsytd5c5dKlPFZ7oF+/HEvqxpk+z/kwnuqd6WdSYBwZSWek29GF8j4+8Bg+HJ4ffwzb1KnIvfhic3BcBWYdsHRx9WpzvLy9kfPP7It+185zbCzrelxozxNCVBkPPgi8/z7w7LPAf/+rgXdiGElv1LcREtYnGO3OygIFOUV67z694WEr+aKnxxU90LR5Uyx6bxFOJ55GqC0U2A9s+XpL3muaoAmSkWwY0/kiFrUyn8GbbwBenk+gZ69euOP5GETXP43HbktESFDx0XJONMQuiTUyBHwDLAoRiWonPT0dQYX6TjHd3f630khNTcU111yDgQMHYoQ9HbUIXn31VbzwwgtFThIEaLKxzOzYsaPsLxZlHsfWrSs/WKtW+SMlpRkCA3Nw5ZXb4ONjjZkiW3EzHX/rVjjvOA4aVCWf5zF6NFpNmgSfI0dwaPNmHL3iCrgUTZqcuc9MpUOHjLv6XVceq8bwRBlLNyTShRBn078/MH581aSXCUvM5NhLPTU0FUe2HIEt11oXbLZLu3ri1chMy8Sfv/yJRb8ugt9xPwQhCA3QAK3QCoEINNq4pSMdSUhCNrIxYeIE1Ao+Hys31cYGHz/cOzKpRJFOTp88jQOLDyCySyQCIpXFUROgQC7s5n6U/aj++VtJ8H1DhgwxRP3kyZPhWYLrFqPsjzzySIFIekxMDFq3bn3WJIEoOrrDi9BWrVoV2YJRVHwcmdQxebJZPlyRirI///TAF194GF1SSffuHoiPN7OdrEjDZ2Dv2mutc4q3fBy5gXQxZ9ifkWIH43HZZcCXXyL6zTcRPXkybK1bwzZqlBNZ3pcRZhHt348dF16IVtHR8NJx0CmOjfYsr9KQSBdCnM3w4aaBHJ1khMvANHW/un5GfXd2pvXGMX5Bfrj0xksxZOQQvP/l+/j8l8/REi2N1m1R//xHGKU/giNYnrQcPrmr8P3rHjhwyBcNI85sU9oJTwQFFC3Y2ZotfmU8QpuHol47C5oKi2qlTZs2Z0Ug+Lhu3bqILKEQlhcyFOgeHh74/fffSxXatWrVMpbC8KJKorPsaLysH0eKa0aq6cla3k6C9AD75htT6BPqxIsu8iz3eoqDySzs3c5UfKcdRxbfN25spnFXhbEt09ynTIEHJxfXrYPHunVAx45Ap05wKTipyb7qHMeZM+HF7W/Z0nm/bDc5NnqVcR0yjhNCnA2vAiTQXZLaIbUR0zsGXr6Oi4T5ePugW8tuaIqmhhj/HJ9jOZZjK7YiFamG2VwEIjAYg400/HPaZOKKC87MHO+N98H5o5vj7a/CkV1CaVbK7hQcXH3Q8swAUbVcffXV+Ouvv4y+5yQzMxPffPON8bydzZs345lnnsmLMBw/ftwQ6DSWmzNnTl56vBCuCIUw23xXxDju77+BlBTTwPvDD9ktwWzGYhVMmKNId3rYHo1UReE8ReybbwLMzOlpeqsYqRCuiL2mnjvgnDnATz8By5aZPdY3bzZ3LuGUKJIuhCiZhAQzzez++zVSLoJvHV807NEQsctiHeaYHhIaYojxMIQZqe3LsAxHYaYwhyAE1+E6RCISyf9LxowFM4z0dS712tfDjAVhyDjpie37auEfv7piYZ19TlYOGnRrYLSeE67HqFGjjFT1fv364fLLLzd6n1Oov/TSS3mvYXu1l19+GWPGjDEi5rfccgtWrFiBe+65B2/yYvkfOnTogJEjR1bTv0SIisEoekUzpWfNMm+HDAH+aZBgKcwgpy+b08OsG85UsFSmKqLpdJTnwh7qK1YYEXXs2mW2OnNF6FrPzi4U5UuXnvnymaHEf1PnzlVSSiBcRKQnJycbPU+XLl1qtFrp27cv7r33XviXkoaxcOFCjB8/HocPH0bHjh3x1FNPlckdVghRTo4fN6fsWbTG24EDNYQuAtPemwxogiNbj5TZUK480BE+PCzcOI57wxv1UR91UdcwkGM0/TN8hmEYhs4enZF+OB27f99tLKRRaG2M7d4TA2+OyrtwzTrlgfhEHzRreOqsz8pIzkDs0lhj4qE8LeeEc8DUvunTp+PXX381IuZsr3bVVVehTr7iXIrvF198MS9iTjf4rkU0gfaxooeVEFUMfaIqItL37jWDncxaZga21VCjkcBAOD/UBkx5Z3uxqhDp+ScH2JptwQIzmv7EE3BZmGbNtAl76gRrJpi9tHYtsGcP0KWLaZrA4ywN6HS8rVa8q7MI/7zzzjN6pVKYZ2Rk4D//+Q9++eUXzJs3r0B/1Pzwb4MHD8bjjz+Om2++GePGjUOfPn2wfv16BLrEUUYIF4K/qRtvNGeRZTjicvj4+xiGcrldcuHh6YG0uDQkrEvI+zsj07mnKhZpp0P8nXfeiddeew0e8PjH2d3XqEsPRaiRBv8zfsZs22y09G6JoU2GIjIzEifiTiAz5SQCV8zD7rQwRPy7N+rUq4PPp4Vg/I/heOjGJNxx9dnpd1lpWYahHFu0sfWccC1YV37JJZcYS3F160x3t3P77bdX4dYJ4Vg4z10RU7ZffzVvmXHtCF3KWnk/PxcR6YT11Yxoc0ApOKvquoSlORTpTBOPi3NMSkN1wJkjToxyHJOSGAU98zwt/9mGNzra9Qzzagje1Tmzzr6n+WfS6ZrXuXNnI8Wtd+/eRb6PJ3HWsdnT5C644AIjiv7pp59i7NixVbb9QrgNb7xhXl3oIO2y2HugB8cEI/d0Lo4nHEca0tCwd0MkrEzAqfSzo9dl7bn+xBNPYMKECXl90kl0eDSev+N5eAZ64p2v38H67euxeddmBNUJwuiRozGwwUCs/2Q9krclY8boGQhqFIzlp69Cdo4H6tf9x764GOd3tmhrcF4D+IfL+EYI4fwwWFkRkc4UeepCUszcliX16AxQu4xIZ/o5RSOL/Jm2zVQApsA7GkaVu3UDVq4Epk2reeV/vL7LH2E/dQqghwgnJFq1MlPhIyKqeyvdjmrNG8wv0PO3YjnFnaMIGG1nLRtr1OwwNX7QoEH4888/JdKFcAScZhc1hpBmIQhqHIS0rWnw9fc1eqzTDZ4p5RUV6j169MDmLZuRmpJq1KozFd4+MfDjGz9i3op5ePfbd7Fz/068++O7+KbuN/jXZf9CvbX1kLI9BWkHjuFifIm2aASvyUeR1rovghoGYdOuWvDztaFFo1MFnN/jlscholOEMekghBDODA3C7RHr8jB/vimiGbSlsbiVMMOZdjO83GbJNc3TXQLqBka1Kc4Z1abbe1WIdDJihCnS580Drr++Ztdvc4egeTDrNGgwd+AAcP75rluP76I4VXEfTWMYFe/evXuRf4+NjUVubi4acCYtH3xM59jiyMrKMhY7dvdYptxzESVjHyONlZuPY3Y2PL76ykgxs916a7VthsuPoxOQfwyZ1RTVLcqoXT92oGAv67Li4e2BDp06FHiO6e/mH4ELel6A/t36Y/ai2Rj33TjEJsTixR9fRHT9aNx7973oGtwVSVuS4LckDsfjM/HHo3+g0eDmeGL+YCSkBWPsqBW45eqgPOFPx+9D6w8h60QWwlpVYW2iA/dF7c9C1AzsrdHi402RvWqVGfRl56vyrMOe6s5adKsT2Q4fBtq3N73EqrK82xLsddKcXWDBPoXkP0E+h9K2rTlo/Mzp04HRo1Hj4bhyx2VEnc7w3JGZEsL0+KZNq3vrajxOI9Lff/99oyULjWWKM447zfYB//RCzU/t2rXz/lYUr776Kl544YWznt++fXte9F6UTuE+t8K9xjF49mzEPP44soODsaNtW+RWc426q46jM1FgDKl/mzj284Y2H4pBowZh6tSp+OSTTxCfGI+nPnkKLVq0wH333YcLx16I5WOXI3lNMjb+vA8BOAw/Lz8MvNwbuc3Zfb1g/XxiTiIStyaiurFiXzzBC00hhEvDLGwGd2mizaxoXprWrm1mDJenvfK2bcD+/WZA88ILrd1GBqE5CcBAaXkmDpwOpl/zH7F1a9VFeBlNp0j/7Tfgmmvcx6uH6RxHjgCLFpmPuWOyLJlGcxb0DRdOLNJZT/7vf/8b//vf/zCwBPfoUB712Du3UE8/uguHlTAV+OSTT+IR9jrMF0mPiYlB69atjVYvovQIDy9C6RnAqJtw03Fs2RK2GTPgedVVaM0Dc0VccCzA5cfRCShpDBlRP7rPbKXmCOgEP6rHKAzvPBzfzfoOEydPxK5du/DQQw+hU6tOuLjrxdi6aSvCcsNwdXYasnJCMf+aZKzyW4UjXkfQottnuPLiMJzb/mSB3vBRXaMc2hve0fuiPcNLCOGa0Hdr7lwzgn7RRabvFsVwRaLg1ICEpuJWx5LsgWdG0V0aDiy7znCSlLMjhUpoHQI7TvCLpRP6zJnADTfAbchfs04dxnoMCnfWYtg7bLENgag5In3ixIm4//778cMPP+DKK68s8bVMa4+MjMTKlSuN9ix2li9fbvRfLQ5G3gtH3wkvqnSRX3Y0Xm4+jtzmhQsNl2ZnwGXH0YkoagwjO0TC188XSduSjLRyR+Ffyx93Dr8T1w2+Dp///Dm+/uVrbNixwVj84W/0X+d//dAPgQhDr8xeWIAMTJ7fFVMW2PDbR3vRuIGZQZWZkom4pXFGizbfAF+X3Be1LwvhelDwcmHN+eLFQGKiGdwlFT1Vcr6O6yJDh8IhNfLUVDUiRsUIL9PeN2wAWrd2/OfxS2UE/fXXgRkzAOqWUtpG10gYNKXJwpYtwO7dZ2aSmALPiQxlKVtCtU55fP7550b7NQr04cOHF5uqPmrUqAJtWSjs4zlVCWDKlCnYsmWL2rUIURU4iUAXjiW0RSiiu0fDu5bj53GDAoLw0I0PYc4nczC011CjnVsGMhCLWOzETszCLOzCLnjCE91QH62xAP077csT6IRzCaczThst2tKPpDt8m4UQgubXTGn/3/+An382I+kU6JWdO6bFEtPkGbB1RDo66+SppWrE6ZyRW4pCzjgkJ1fNZ7Ifnt1h/v33gR9+MM3VHDip7ZRwcoI7KAU7fVmys4G//zZ/DBTvxZiACxcQ6UePHjV67NLh/Y033kDPnj3zFvZKt7N7926jB7qd5557zuiLzhpGphjedNNN+OCDD9CNrRGEEFUDi+6Yz8fZa1EjqVO/Dppc0MRwWa8KwkPCcVXvq9AETRAE8zPTkY492IPpmI4lWILaOI7rMR8X7v8uz+Qu7YQnhj/UGL/MC8LprBzEL49H6t7UKtlmIYR7Qg1CYzdGpRnMZftuCvTKZvuyXvz3389E0a0W0tRN3t41INU9P3RZZwkeU69L8KeyDM7CsDadLF1qivSnngIef9x0f3c3sc6oOdPguVMxm+H4cWD2bFOssyzA3cajJqS707BtyZIlRf6tuT1XCNzvnypgqMO0ddauHzx4EIcPHzbEeqDLNHgUoobAVK8//wSefdZ0ORU1Ei8fL0SdE2XcVoXwZfs2H/ggEpEIQQiSkYwTOIHjOI4/8Af2Yz8ux+UIOBpgOMB3f6A7fok9B1v3+uGTyaEY2i8Nnp42JG5KxKkTp1C/Q32nKc8QQtQM6IzOdHSKXQp0Kzh4EHjtNTPVneW+NJvr3x+Ww0kFdiyzlxbXGDp1Mgdx1y4zuuvo2mi2I0tNNScGGFFnOzi6/b34ItC4sTlrwx2E3aoYeXeX0jyOO38UnCxhxjNLAlizTpM/nos5LkqFd36R7u3tbUTNS6MZ832KqU8v3IpNCFFFvPKKeRXx3/9qyN0AQ+x6eiB1T2qpdeqe3p7IzS7owl5W2F89PCzcMAOthVpogAbIQhaSkGRE1XdgBz7Eh7gn5B4EpAZg6RtL0e2yVDx04/no2DILPv+c0biJ21cfN4R6g3MbVLmhnBCiZsJINPUYY0dWpqJPmgQjfd4O267xFGs11JU9epzpYlZjYH00ZzX4xVCoMxWbA+io/nL5o+mEMysMWNDxj7b8XAh7qnNGZNgwYPBg9xGo3MGaNDG/j7Vrz5yYaYbAHZDBWE2gO79xnBDCBWG7E/ZMF25DvXb1ULdJXaTsTkFabBpyc3KNCDuN2k6mmk7rderVQdS5UTiypWI919kHnWVQr732mlGbzl7rFOvRiC4g1t9JfQeDPAaht6039s7YilYdk3Hu4N68UjPW89uSQDzxXiT+dW0y7r91P6K7RaNWUPV0IxBC1Bw2bjQ1oJUtohk9X7jQvD92rBls5GI1DG5SWzpi3U4Ba6MvuMAUhayPjo01I7shIVXz2bfdZgp3zuJkZZk18sw4ZLT9yy/NayZ+AZw8YF89GmAzwlyT4aQE+w8S1q0zus46EWYYnHee+2QYVBCJdCFE5WEhnVpv1Hh8/H0Q0TEC9drWQ0ZyBvzD/Y0I++H1h5GemI7IcyIN4R7ZORK1Q2sbz5fXIb5X71544oknMGHCBBxJPmKIdRIdHo3n73gefqF+GPfdOMxZP8cwl7sSVyJxYyJ+ffBX9HuyH8LbhGP+yjrIOuWJnFyPPEO5iE4RVVZfL4SoedAYbs0aU4+xTbRV/PGHKaAZXGQw2FEBRmpGlm/bu2XVSGjoxoUsX2729WZUvapaxrL8lhFzO2zRtmCBmfbNVAlOHrBmm1F3PseM4iuuMB3qa3pk2T5DdPSo+b0wys5MB/6YWMsuwX4WEulCiIrDg+3LL5sHXBqoSKi7BUxpD4g4k7YX2SUSp9JPFXCDD44JNiLjh9Yegi23/EK9R48e2J+1HwkHEhBwOsBIhef6yOcvfo4Vm1bg/W/fx4QtE3AdrkO91Hr44/E/0O7mdnj1QRuG9DmOnp0yjNcz6r9k+hEs274drXvsRHR0A6Ntp9qeCSHKOg9Nv1TWdNsDg1bA4CI9tggDq47Uadx2lgfXuFT34qDrO2dWtm6tmjr1oqAApcnuoEHm9RK/cIp1GmSvW2deN3HhTsVW0vxymB7Pba+popWmCPx30hSck/jc6ZlOwjT4mj5RUU4k0oUQlbty+fRT8wBLS1pHNHUVLoFvnbNDS4ENAo10+IR1Ccg8llmu9Xl5e+GiSy4y6smPHzpurCN/rXv3Dt3xzavfYNn6ZRj/zXg039kc7WztsPWrrVg9fzWueP4K+PuZ9YjLli7D2LebIeV0fwSNW4Z03IyohlH4v//7v2LbfwohBPueU1OxFp1aLybGWh2xYoWZDc0AbN++jjlFsw6dkXrqRW6/20Ah2Lu3KdRpKmeVy19F4E5jT7tnOgNTvVm3TrE+fz6wY4e52OFrLrsMuPzyminW69Q5Y+rA2SO2buP3xTQVZ8RmO9O/sAp9BSTShRAVhwfU//s/s66KTjdCFIK14I36NcKx/ceQvCMZ2VnZZRojvxC/PMO3wKhAYz0HVx5E1vGsvNfQub13l97o1bkXFqxagDkfzkGH5A7w3++Pb2//Fj6X+qB189b4v/fGwYaH4IFzEYJfUQ9NcCjuEEaMGIHJkydLqAshim21xkZE9CWjxmLmtJXMmmXeMkPaERnZLAGm9uH2M829ppdAnwW/NAp1pisw35+DzJpwZxC+dIG//37gppvMIMfeveasCnc6Tix88YWZpXjllaZTPFPCHWWEV50EB5uzYHPnOm82ppeXmQ3B74jpKFWERLoQonLceqtGUJQIxTRN54JignA8/jiO7j+KzKMlR9bzp9PbI/UU+6xzT4tPO2v953c7HwM+H4Bff/wViT8lIiI3AidnnMT7eB/JSEIo3kQoPoEX0nnGRUM0RKxtJG699TAGDMhBWJgTXLQJIZwGBs3Y5pklzo7QRgcOABs2mLrkkkusXz+3n/5lAwea+s6tjW7POcdMheCAxMWZz1H4Okv693XXnXlMwUpXeJrN0aXwrbfM5zm5MGaMaY5X02CKvzP3BfT4J32minu+O+mUhRDCJeHJhSdBIYqANeXBjYLRuF9jhLcOP+vvfsF+eX3NAyIDinx/VNeovJZwheF7L7n+Elz9ydXwivRCbdTG9bgendEZ+7APR3EAOcgxXpuDusjEYzh+/F94/70t+r6EEAVghjRTxamhHMHMmeYtS3EdoU+oRSnOqUfdGp5TWEtAE7drrjEd+jj7wqi1M8K6hCFDgA8+MGdY2rUzZ4o46/Luu8B775n3RY1HIl0IYQ10K23b1jyxCFEKYa3CDKd4n9qmi1Fo81AjUh7dI9oQ66xlL46QpiGI6RUDb7+iIyGBEYEYPn44/Dubuan90R+jMAqZyMRe7EUykmFDMqLwCAIxA9HZy/PayDG6RQNeIYR7w5JhRrmtzIxmbTh11qOPAn/9ZT7HFtpWw7bdTM0/91znyOyudvhFsvCfJXoDBpg135yFcWaYvvHgg8Brr5nXVZxk4L+DaeGPPALs3l3dWygcjES6EMIaWO/F2WnWUTnrDLVwKpgC32xQM7Qc2tLow85IOHutx/Qp3d2ILd4Yka8dUrvIv7MVXNNrm2IJliAb2WiGZhiDMUbPdYr0fdiLLExBfTyM0MC6iF0SiyPbU4y0006dgE2bHPAPFkK4BBkZpmGc1S22Fy82M5npEUbB3qyZ9SWuNBCn4R0zvN2uBr2s4rdLF7MFmKvAmZaRI4GXXjInGGg28O9/m23caNzLHVbUOCTShRDWcPPN5mwve5M6q/mHcNqWbgUe/9NqrTQYSY/pHWOk0BcF27alh6Xjd/yOYziGQATiNtyGvuiLXOSaYt1jH+ZtmIejx49ixZ/HEB+bg4QEW7UaAQshqpeEBLNjltWp7najOGYzP/MM8N//Wt91ivqNxy9ONopi4OwFTeQyy9d1pNrp0MFMd2eNBFO+JkwAbrzRFPCvv246pYsag66khRDWQBOWe+81W2sIUUWwNj2yc6SROl+4Tp1i/84770Qa0jAHc4y6dE94YhAG4WbcbIj2HFsOPvzpQwy8YyBmL3oLk95ai/FPx8M760yU5Z13TIMnIYR7QK1DjygrU8V37jQj6DxVjhoFdO8OBAXBUhhQZYS+WzfTZ0wUA6PRTH3nTIyrwZ3mqaeAu+4qeL3FNgT33Wf2XRc1Aol0IYRjiI3VyIoqTZ1v2LOhkeaen169e+GJJ55AcFgwlmIpVmKlYR7H9PfHQx7H27e9jVaNW+FExglDrF/54PlYuOJlbP5rMw5vOIw1q3MxdqyZOsp6dSFEzYfazepabnsUnR5mjjKj42mX1jBMoxclwJmSJk2A48ddc5iYfnHppcD335t+QDQ6YEs3zi6xhp3LTz+Z7oTp7GgiXBEn6T8ghKgxsM7r+uuBP/4wQwcxpdcXC2EF/mH+hvlc/Ip4nDpxqoBQ79GjBzZv2YzUlFTUSq+Fw5MPIyMpAxnfZeDdu9/F7jq7Mf7H8di+bzs+/t/H+GbGN7jx0htx6cD7MOKqNvCt7Y1Gjc58VmZmDpYvX4ywsDAsXrwYffv2hZccmoSoEbBNtZWRaGontrx2lFGcfZvZcppmcao4KwNsHM90CRbxu+qx214rQcd6pnxRmE+ebEbT/4moe06ejMD//EczNy6IIulCCGth+hVnp1kvNX++RldUKeynTkO5wi3cmPresWNH9B/QHz0u6YEh7w0x2rnlnMrBynErUXdNXUx6fRLGPTkObZu2RfrJdHwy6RNc93APhHrdi6f/tR22XLNH6jffzEBAQAIuuuhvZGV5YNiwYWjSpAmmTp2qb1uIGtBJlKcwPz/r1sk5a6ahsx1aq1bWrZfrZCttptHTu5UZP8zkFmWgfn0zddxVo+mF8fEx69PffNOMstP4ICoKHikpaPzgg/CkCQIDJ8JlUCRdCGH9zO748eYJw8qrESHKYUQX3S0ayTuSkbQ9qcjX1Aqqhf7P9cfm/23Gph82Yc+cPUjZmYI+T/TBoPcGYe7yuUZkfcueLfh08qf4dua3GHXFKHTr1w133Ufr98uQm3sZvL3NTgbx8fEYMWIEJk+ejOHDh+u7EsKFk8HoJ0YTcCtgoPbXX89E0a0yiuNkAhuqsBc6M7eZwc2AqigjbMnGaDoH0VH1B9VBy5bmQrKykPu//wE//wzP9eth1G6x3uKKK8xUEdblBxSc0BbOgyLpQgjrad9eAl04RS/26O7RZ7nH26HRXIeRHXD+C+cbov3o3qOY88gcxC+Px8CeAzHl3Sn48JkP0b5Fe2RkZmDCTxNw9313oxY+BTActWo9lpclaWPaJICHHnoIObwqF0K4tEin+bcVrFwJHDliasJ+/axZZ1aWqS1Zfz5woOnk3q6dddvsNlDMMh2hph6za9WC7eabsXPGDORecIE5Q8Q+gGzfRpO5W24x2+bWlGyCGoZEuhDCsfDq5OBBjbKoFgIiAoz0d6bBF0dkl0gj/T2sTRhOp5/G4lcWY90X64z09gu7X4jJb0/GJ899gpYxLWGDDVlg255pQPZfRgTdDoV6bGwsFtmLT4UQLgd9tqx0drcbxg0eDPgWfxgqldxcU09y+yjQORd+4YVqqFIpaDTC+gDWCtRgTkdHw/bII2b7NntbAUbQuUNNm2Y6xbOWneNA10TubKLakUgXQjiOb78FmjYFHn9coyyqDd8AX8NQzj/cv9jX8G8DXxmIVpebJRrbpm3DvGfm4WTKSXh4eGDAeQPw6DWPIhrRqA3TUSozOxOXXnopsum/kI9Dhw45+F8khHAUVgYV58wBmGVMI7eLL67cunbvBuLizHnvLl1Mge5f/CFNlAWmfLNeIDXVPcaL12OsTee12XffATSUY60EZ36+/hq47Tbg5ptN0f7XXzU3w8BFkEgXQjgO5t/x4E9XGxbQCVFNsDUbW7SFNA0p9jVMi+96R1f0ebwPvGt748jmI/j9od+NVmwkNCwUdVAHMYhBQzREgGcA/P39z3J1j2KdoxDCJWEwsTJp4wxObthQ28gq/vhj87mRI4GIiIqvk5F9LsxYvu46U6BbaWzn1lC4Uqwz448W+e4iTJn6zlYAjK4//DAQGXnmb4mJwP/9H/DAA2b/dUXWqwUZxwkhHEfXrsDff5vpVVa55QhRQRgRr9+hPnwDfZG4MTGvjrwwMX1iENwkGEteW4Jj+49h/nPz0eGGDmh3VTuEh4UjOTkZ/vBHWO0wvDf9PSOabl9/w4YN0c+qwlMhRJXCQ0JKSsUFMOvZ//1vT8THn3Fw693bFNaV4eRJc5saNLDO0E7kc3lnbXpCgtmV5sABU7i7C0zz4OwPF7vhAWs0pkwBYmOB1183HQnpHN+mjVkHohmiKkEiXQjhWHr00AgLp6Ju47pGjfrBVQeRc7roqElQdBAueusirP54Nfb+tRcbv91oRNZvH3U73nz/TXjAnDCsunMAACeCSURBVHQK/6ffEQU6ee+999QvXQgXJSPDXCrSI53BRraqjo/3QJ06OQgM9ETLlh6GP1dl56gp0pnazlJiYTH8cmgYwBma/fuBX34xMwDZTtYdYRoJO5Swhdv06ebCWosXXjjzGvb6Y1q82gk4FKW7CyGqBs5Qz5un0RZOAWvQG/VtBB9/n2Jf413LGz0e7IHuD3SHl68XEtYmIPm7ZDx040MIKxTOYgRd7deEcE2oz1iLzmxnOrtXJFD444/AqlU0h7Phiy/2YsKEXMNEuyKCvzCcOGC3LHY2FQ4U640bm9FiFv+7O5ykuOEG4NNPgSuvLFgDsnatmSL/7LPmdd2aNcCmTWath7AMRdKFEI6HYQDWPm3dCqxbB3TurFEXTmEoR+f3+BXxOJl6stjXNRvUDKEtQrHk9SU4Hn8cmd9n4tGbHkVuW9MBd9asWejbt68i6EK4IMxy3rAB2LvXFOsUxOV1YWebNYp0cu+9NrRtm4l9+6zbRk4cVKamXZRDqDNKzJ2B5gSqLQCCg4HbbzfbtTFdhM6FP/wALFxouiJysWPvM3j++aYhn8ocK4VEuhDC8TCUQGF++LDZO0YiXTgJjJDH9I7BobWHcPxg8bbOdZvUxeC3B2Pl+JU4sOgANny1AQ26N8Cpvqck0IVwMag12D1x2zZg1y5TmFMEs9y2Xr2yaQv6i1HcMzN6/HjzuUsuoalb0V4XlYGTB3XrWr5aURTcAc47z4wQU3RWpm9eTYI/Di40Rhg7Fhg1ynSAZ1SdmZI0c2D7ttmzzYUGqhTrHEtvb1PsMx1ElBmJdCFE1fDuu2b6FE96QjgRHp4eaHBuAyTVSULyzuL75TI1vtejvQzzuTUT1uDgioM4eu1R1P+5Php2a1il2yyEKJ/IpWE1s3EZlaY453wxtQXFecNy/nwp0JnpywxfO8ySHj3a+m+F20xtpHr0KqRTJ3MWhzM40dHmF1AZy/+aCN3gKdS55J+1mj8fWLaMvUjNiDuX/D+SPn2Avn2VpVAGJNKFEFVD/vYeQjgh4W3C4VPHx2i5ZsstOhpGg7gWQ1sgtJWZ/p6ZmglvP51KhXDmaqvVq82sXBpXM4rO2m6ekiraZ5wtpinQqdtYxkyDcAp0R9SMyzSuGuAX2auXGRlmhJg7DgMM/KJF0XAig6UCXMaMMTv7ULDb60jS0szZMS6ffUbXVdNZnpMgAwYAzZo5b3q8hwdqcbasijMBdGUhhKh6aDLCq5v27TX6wqkIjgk2IuYHVxbv/E5Cm4di8HuDkZSehHrt6lXpNgohygaDoUuXmjqBWiAgwNQBldECFPyTJ5v3H3zQDAo6Eqbic7vd1Wy8WtPeR4wATp0y27LNnWs6CiqloWwljvnbuhHW+DPCvmiR6U9El0bCFBemzDsxXgBaskzm0UfNCYUqQiJdCFG1sHiPPWnY3uO33zT6wunwD/NHo36NEPd3HE5nFO9WyzZu9dsrsiKEM8EM5dRUM/i5caN5yzbYLIutLAysvvfemfpzRwt0u0hn225nDTLWaJhqwYX11LT/p8hklN0Ky353gyZ8l15qLhTszFBgijzNhBcvBo4dg7Ni8/BAjqcnPKu4P7xEuhCiahk61IyiM9WJM9QyZRFOCAU4W7TFL49H5rHM6t4cIUQZoPE0A5683mf2LbNTy1tvXhzM2P3gA3PdTHGn4bWjYWo+T5Nydq9mOEPSvbvpEsi6CfYHVz+8ygl2u3M+69RHjoQzk+vhgW1NmqAtf5BViES6EKJqYd0RU8dU2yWcHPZJp/P7wdUHkZ6YXt2bI4QoRUQza5alr7zut5rffwdWrDAj8o88UjXzy4zch4SYkwKimqEoZ+rEiROm62CLFuZMkBAOwtNRKxZCiGKRQBcugqe3J6K7Rxst2IQQzsv+/aYnlVWR8/zExQETJ5r3b77ZTD+vCli2y1R9lUE7CUx9Z501d7Ldu810bSEchES6EKL6YE3S11/rGxBODR3dIzpGoF5bGcQJ4axQoDMb1SqDNUbmd+wws5vfecdMO+/cGbj8clQJrEVntJ4iXTgRTG0YPBiIiQG2bzd3EhohsM5aol1YiNLdhRDVAwv7WNfFfD66vJ97rr4J4dSEtgiFd21vJKxLKLZFmxCi6mF3pIQE09/LKqZPBz7//MxjOqw/9JDZNaoqYJtpRuzVvdQJodkBzW/ZNoAzQ6yxYAo8F0LfHdaxM0Weol491kUFkEgXQlQPvJqiyyftdzNlzCVcg6DoIKNW/eCqg8jOzq7uzRFCwNRI9PSiH6kVUGvZk7zYuo2mzjfeeMbrytEwKEtdx5bTVTUpICpwDdOly5nHNJbjTNHhw2aWIFMxGIQ4eNBsMcBUebsrPNM9+FiIEpBIF0JUHx9+eKZxrRAugn+4v2EoF7siFtmQUBeiuqEW4lyvFZ2xqKfefhvgHFyPHsBTT1XNKYqZ0uzyxVuKdJY+N2rk+M8VFkHRTWNcLna4E9FYgMKdMz/8ggmfO3nSFOuBgeai2RhRCIl0IUT1wROTEC5IraBahlDfuWdndW+KEG4Pq6cYuLRCTH/5JRAba2Yp339/1Ql0ljXXrWt+XqdO5iJcHLYCYL0CFxoaEKbHU6RzJ2Onm8REs7aB10P2NHkGL5Qi7/ZIpAshqh9eoUyebF6VtG1b3VsjRJlg2rsQovphoJIp6ZVl9Wpg1izzPuvPq8pVfd8+M62eZc4MrrKUWYHVGgq/WHa44UIvHs4wcQfYssV0J+RsE1PkeZ/1G6x/V7ahW6IrDCFE9cOms++/D4wcCfzwQ3VvjRBCCBeBGcUU6RUt8WUZMQ3ijhwxA5rkssvMevCqgO3dGDgdMMDUY8INa9sZZWeQggKdQQtG2tlTkJ49dJCnsOfCiDx3FuEWSKQLIaqf228Hvv0W6NDBupxFIYQQNR4GItmurCKmbosWAR98YJYH22ncGLjlFlSZQKf2Yv15gwZV85nCSeF1DxfuEFFR5sL+e0yLt6fIs88gZ5OYdsH+fKJGI5EuhKh+OIscH29NvqIQQgi3EunlNY2jOdyECcCcOebjdu2Aq68GvLyAVq0cp384B81THZ3oqcVYhkyBzm6kQpwFZ57ss0/ceVq3NmsymB7PHZ5CnjutqJFIpAshnAMJdCGEEMXALOATJ0yBy77o9lR3il4GGsuagMUs4jfeMAOUfM811wDXX+94rcNt5mczu5mp7cxaps6qV8+xnytqCNxZmebBlAu6DK5ZA+zcac702Huyc+dShL3GIJEuhHAuNmwAli0D7r67urdECCFEFUMRzhZkjJDzPgOIvGW9OG8ZNadgzw+d2Eti1SqzvJcR9D//ND25WP/98MNnTLcdhT16zpT8Jk2Avn2BiAjHfqaowVCM02CXgp1mc4yq238krJ/gzBV/EHQgJAqAuCwS6UII54GzwrxiYtuSwYOBpk2re4uEEEI4CEbA2YWKh35GmimeWXqbllbQnoRRbkaeGSikwOUpoixQzLOl2vTpBZ+nqfaDD5otzxwNJxy4vcOGmWnt1FhCVBo6JZ53nrkQ/nhYr84UEZrNccezP88d7+hR80ek9HiXQSJdCOE80CTl4ourru+NEEKIaoGRchq37d5tCnJ72zEGAJs1q7yWoEZ55x0zgk5Y+01Rzmg2082rqsUZJx0YPW/Tpmo+T7gpTHOnoRyXLl1MN0T+sCjcOQPGCPuePeYPiynzirA7PRLpQgjn4pdfFGoQQogaDFumzZ1rpoE3alQ+07eSYPbvwoWmHmHV1PHjphZhz/PevVHlMCOAwcsWLar+s4Ubw53eLsKZfrJ1q+mMmJgIbNoE7N17pmaEs2M0oJNodzok0oUQzoVyAYUQosbC0tk//jADfBSvVmTfMmA4axYwcaKZQm+HWb6PPmoGF6saBi85GdGxo8zhhJOkx/MHwVQSGjzY60s4s0VHQ/6IwsPN2gymmXDmTO1wqxWJdCGEc5KaCowfD9x1F1C/fnVvjRCiEmzcuBFPP/00tmzZgqioKDzyyCO46qqrLH+PcH6Y3p6QYJ1Ap9b46CPTEI706mWmy9M7iynuVT3vy+g9OXjQrNxSmrtwKvija9jwzGP+EGk4xzp2inXOcjHKznR5inWKewr2WrXOOMfz+aqqF3FjJNKFEM7JiBFmPiRPFC+/XN1bI4SoIAcPHsSAAQMwYsQIvPTSS5g/fz6uueYazJgxA0OHDrXsPcL5oTM7G3iwa1R5BToDffS+Yo03NQRT2ll3zgj6tm2mZrj1VuCKK6ovAMgsAU5AMHrO7GIGJe1troVwSvhDpFM8F/Y4pEjnzBd/aEwF4cK6Dc4+2Xsf8jX8QXIHp3C3C3becn32x/w7H9t/kLzl3zhzJgO7UpFIF0I4J/ffb+ZD2p1LhRAuyQcffIA6dergk08+gYeHBzp16oSlS5fixRdfLFZwV+Q9wjmhoOa1Pa/pGUXnNT+zbgmfo9C2R58pwpmJS6HLhe+jHkhJMR+zhVpR0Gzu3/8GunZFtRrhcdu7dTMfs/+5dIhwKWigYIezS61bn5ld4wwU0+Ptj/ljZcYjBbxdvHPmzP6j5Y/b3i8xfw0K73M9+Z+z46zp9V5eZplAFSORLoRwTi6/vHpDIkIIS1iwYAEGDRpkiG07F198Me644w5kZmbCrwjDooq8x5Gwz3bh3tw1Df779u2rbVxzFycu+Rped9uvx9n7m8lOvOVCEW2/9ubfeS1uv0bnNTvXTbH9229m6zV2i+L7ywp3B/Y3tzvB8z6NqocPN2+rEv67OI/MfyN1CbeH5nScKOBkhBA10oiuNPhD5w+ei1208zn7wud5sOCBxP6c/XXOToOqPchIpAshnBPVOwlRI4iLi0P//v0LPBcREYGcnBwcPnwYjZlmacF7srKyjMVOGhWhIaZyjKUyDBzoibS0mj5hSGXevOo/1ctmpL8T3kZG0mzaZtyyHJaEhJiPGZ2uTm9Re6kus4K5e3F7WN7L0xXr4Js2pQYx97XK7nPujn38NI4uOo78UTAV3l7Hnh/2QnQhcjh2O3YghyYTFoxjWb8LiXQhhHPDWddp08zZVtapCyFcitzcXHizNjEfPv8oreIuVirynldffRUvvPDCWc9v374dAfnTOCtAREQLBAbKKKmy1K6di2bNstC8OZdM47Zx41Pw8bHB1eH8EGvj7ezYsaM6N6fGoHHUONa0ffEEZ/nKgES6EMK5+fZb4JZbgJgYMwVeRX5CuBT16tVDEk2I8mF/HM6WPxa958knnzQc4PNH0mNiYtC6dWsEMQJSCdhm2J7B6SqCkSWjjPoyi9Q+r2E3brZnnfL2DDkICNiB48dbGVH1/H9jNirXyXXZs1L5d3sXJ/7dPj7532d/fOY5L2Rn+yA725w02bfvTPcnR2H3quKtvXqCpxH7Yve6skfo+ZiZvZzXYYtpeyCQc0Z8jtF+3hZXicVJJF7Mt2rVCl46X1UYjaM1aBydbwztWV6lIZEuhHBurr0WeO01M4rOK0Jd9AjhUnTv3h1Lliwp8NyiRYvQpk2bYsVzRd5Tq1YtYykML6qsuLBypUMPh6G88xIU75yM6N69fONlLynlYp8AsD+fX7jbn+dh3C747TXr+d+XX/zmF+92kZ1fbFNQ29s628W4/b797/kX+3r4Hi4U5vb7VldYWbXfuTsaR42js2DduaRs65BIF0I4NwxpbNp05gpKdX5CuBRjxozBxIkTjWX06NFYtWoVvvnmG7zyyit5r5k9ezbuuusu42+RkZFleo9wDih6KXars1ZcCCFqGiqwEkI4PzKRE8Jl6dKlC7799ls888wzCAwMNPqf33PPPbj33nvzXpORkYH4+HhkMxxbxvcIIYQQNRVF0oUQrsPmzfD47jvg+uure0uEEOVg5MiRuPbaa5GcnIzg4GD4FnL8HTZsGGJjYxEVFVXm9wghhBA1FYl0IYRrQDfMnj3heeIEAth+qV276t4iIUQ58PT0NAzhiqJ27dpoyF5W5XiPEEIIUVORSBdCuAa0073rLtj27cPpiIjq3hohhBBCCCEcgkS6EMJ1eOsto39yFi2IhRBCCCGEqIHIOE4I4ToU15hWCCGEEEKIGoJEuhDC5fBMS4PH668bRnJCCCGEEELUJJTuLoRwORq88go8Z80Ctm8HvvqqujdHCCGEEEIIy5BIF0K4HMk33ojgAwfgMWRIdW+KEEIIIYQQliKRLoRwOU526IDcNWvg5a1DmBBCCCGEqFlUe03633//jVtvvRU9e/bEmjVrSn19dnY2Jk6ciOHDh+OCCy7ALbfcgsWLF1fJtgohnAiZyAkhhBBCiBpItYr0p59+Gg8++CDatm2L5cuXIy0trdT3PPbYY3jyySdx2WWX4bnnnkNkZCTOP/98zJs3r0q2WQjhROTmAtOmAd99V91bIoQQQgghhOuLdApuivNRo0aV+T0///wzxowZg9tuu82IpL/++uto06YNZsyY4dBtFUI4IVOnAsOHA2PHApmZ1b01QgghhBBCVJpqLegMDg4u93vOO+88rFy5EqdPn4aPjw8OHDiA2NhYdO/e3SHbKIRwYq64AujUCRg2DDh9GvDzq+4tEkIIIYQQolK4nOvSF198gdGjRyM6OhoNGjTAvn378MYbb2DkyJHFvicrK8tY7Bw7dsy4TU1NRU5OTpVstyvDMTpx4oQxXl5eXtW9OS6LxtFB48hSF9anZ2fzR23Rp9RstC863zjay71sNptFWyfsY1mWUjpxZn/meOlcX3E0jtagcdQ41tR9sazne5cT6ePHjzfqz19++WU0b94cc+bMMWrUzz33XCPKXhSvvvoqXnjhhbOeb9KkSRVssRBCCFE2jh8/XqEsM1H0WJKYmBgNjxBCCJc633vYnGDaPi4uzjiJUnzTBK6kf0xYWBg+/PBD3HHHHXnPX3rppcjNzcXs2bPLFEnna1NSUox1ecghukwzPvx+WFYQFBRU3q9XaBwtRfujxrAm7os8FfMcxwwxT89qb7xSI+C5/uDBgwgMDNS5vgzo2GoNGkeNozOh/dH5xrCs53uXiqQz1YC16Ex1zw//kRs2bCj2fbVq1TKW/NStW9dh21lT4Y4pka5xdBa0P2oMa9q+qAi6tfDip2HDhhavteajY6vG0ZnQ/qhxrIn7YlnO904/Xc9Udbv7e1RUFFq0aIFPPvkkLzLOmvTp06ejX79+1bylQgghhBBCCCFE5ahWkT5r1iz07NkTl19+ufH4nnvuMR5PnDgx7zW7d+/G+vXr8x7/9NNP2LVrlxE979Spk9FjvX///nj++eer5d8ghBBCCCGEEEJYRbWmu7Nt2nvvvXfW8/nT05566ikjzd1O165dsXHjRsTHxyM5ORmNGjVCSEhIlW2zO8JSgf/85z9nlQwIjWN1oP1RY+gsaF8UNQntzxpHZ0L7o8bR3fdFpzCOE0IIIYQQQgghhAvUpAshhBBCCCGEEO6CRLoQQgghhBBCCOEkSKQLIYQQQgghhBBOgkS6wLZt23D77bdjwIABuPXWW7Fp06ZSR2X79u14+OGH0atXL0yePFmjCGDOnDkYMWIEzj//fIwdOxZJSUkljktCQoLRlWDo0KG46qqr8P777+e1FnRXaJHBFosck4suughvv/02Tp8+XeJ7Dh8+jOeeew5DhgzBFVdcYbwnPT0d7szx48fx7LPP4sILLzTGZMqUKeV678UXX2x02jh16hTcmb179+Luu+82jo033ngjVq1aVeLrf//9d2PcCi/5zU+FqC7S0tLw9NNP44ILLsCVV16JadOmlfqelJQUvPPOO0YXnUcffbRKttPZYdehO++80zgu3HTTTVizZk2Jr+d5/dNPP8U111xjnKcee+wxHDp0CO7O/Pnzce211xrXTA888IBxTVQSPB99/PHHGD58uDGOvM5iG2Z358svv8SwYcMwaNAgvPbaa+W6juQY8hy1cOFCuDMZGRn473//a1wzXXbZZfj+++9LfP2xY8eKPNf/+eeflm6XRLqbw4tQCu3c3Fw88cQT8Pb2Ru/evbFjx45i3/PDDz8YF/504aegL+3A6g788ssvxkGS3Qd4IcOLeZ54ijtY8gfOcfb09MSDDz5onKgo0inW3dnLkfsgOzqMHDkSd9xxh9H9gRdDJZ20eVCtU6cO/v3vfxvvmzBhgnGQdVe4/1xyySVGi0vuWwMHDsQNN9xQoLVlSfzrX/8yumcsX77cOC64Kzyu8diYmppq7JehoaHo168f1q5dW+x7jhw5gp07dxr7bf6ldu3aVbrtQhSGv2VOvnEi6aGHHjLOT9ddd51xgV8cFJIdO3bEgQMH4OHhYUzouzsHDx40jguczORxISgoCH379sWGDRuKfQ8nRCjkeZ5ncIPXTbxWcGehTjHDiXi2Uea5m/sWx7GkCc2bb77ZCBDddtttxrmN7ZjZJYrfibvy4osvGmPBiYsxY8YY5/lRo0aV6b3ffvst/vjjD+Ncz8k4d2b48OFGi+/77rvPuH6yX38WB4NHHLd77723wLn+nHPOsXbD6O4u3Je77rrL1qFDB1tubq7xmLddunSx3XrrrcW+59ixY3n3g4ODbePGjbO5O+3bt7fdfffdeY+Tk5Ntvr6+tokTJxb5+tOnT9tOnjxZ4LkFCxZQnds2b95sc0cSExNt3t7etm+++SbvuV9//dUYk61btxb5Hu6vhcfxl19+Md7D9bkj9n//nj178p57+umnbREREbbs7OwS3/v555/bunfvbnwHXEfhsXUnHnvsMVvjxo0LjNmAAQNsV155ZbHv4bhxnIVwNqZOnWrz8PCw7d+/P++5xx9/3NagQQNbTk5Oke/JysqyZWRkGPevu+4627Bhw2zuziOPPGJr1qxZgeNC3759bSNGjCj2PcePHy/wODMz01a3bl3b22+/bXNXeJ4ZNWpUgTEKCAiwvffee8W+Jz09vcBjnp88PT0LXDO4E2lpabbatWvbPvroo7znFi1aZJy7V61aVeJ7d+zYYYuKijJex9dPmzbN5q7MnTvXGIONGzfmPffqq68a+oa/1aI4cuSI8Z61a9c6dNsUSXdz/vrrL1x66aXGLDnh7eWXX15iygZnjkXBiNvmzZsLRG8ZdeOscHHjyIwFPz+/As8FBAQYt+6aYrxgwQJkZ2cb+6Mdpm/5+/sb+2lRcH/NP46MIi9atAiNGjVCSEgI3BGOVYcOHdC0adO855j5wrKAkkpZGKF48skn8d133xn7p7vDcWTZhZeXV4Fx5G+6pGwXphTzfVwYaWN0XQhn2J87d+5sHBvz78+MQm7durXI9/j6+ioLpIhxZKQt/3GhtGsm+7k9/7iy37K7nuuZhbBy5coC10wcI2bFlTSOvBbIz5IlS4xbZnu4I/z3nzx5ssA49unTB2FhYSWOI/c7Zh2+8soraN68Odydv/76C40bNzaum/IfG5nxWlqJGzNjuN/eddddpZa9VASJdDdn//79aNCgQYHn+DguLg45OTnVtl2uNoakqHG0/60s2A+Y+Q8U7gTHiifhunXr5j1HsVi/fv1Sx5F16D169EBMTIzhDcBaN3cVmsX9pu1/KwqWZfCk/fLLL6NFixZVsp2uOo5Mx2QKfHGTRqw7ZckAyzSYDte+fXu3TscUrntcEGUfx6NHjxoTdGWBKcn0rMk/Ie1OsHyCE50VuWaiMGXtL9PkWT7AUkNOPrkjHCuecyIjI/Oe4+OoqKgSx5GeCM2aNTM8qASMsYqOji73sZHXnPTzevzxx42JNz6ePn26pUPqnlexwoAHSQpxzujmx14/yahm/tliUTR2Y7OixrE00zM7NKyYPXs25s2b57bikmNVeAzLOo5XX321USdIQx8KTdZo8WBpzxBx93G0/6aLG0eax/CkPXr06CrZxpo6jjSOzF8PSJ+Kdu3aGRNwH3zwgYO3WIji4T5bOBJZ2v4srDku5IcGXTRJe/XVV912Qr4y10yc9GTtLyc5aMbHGmKKdHokuRscK14vFr5OL2kcZ86caRjJluSh4G6crsBvmpmaixcvzrtep5FhZmamcS3FKLxVKJLuxlDAMGpZ2DAiOTnZMOIqSjCJs2FqOylqHJl2VBpvvvmm4cjJGWHOxLnzODK9qLBZWVnGsUmTJoYRH512eQKaMWOGEU1313Esal8kxY3jV199ZRj32B1K6QxP6F5ckrGUO44jzR7zZ3vkp/Axk49pNrd+/XqHbqsQjjguiLKPIy/Wg4ODSxyypUuXGtFzmsvSLM1dqcw1E4+9PEdxHO3dCcaNGwd3HUeKyMJmeyWNI8/1vMZiORbHkeZ9hNFgdjJxR0IrcGzkxEjhgBrLMxkosrKbi3uG7EQedBhlbVB+mKJpuUNhDaZly5YIDAw0xpF16PYsBT4uzWWTadpsH0aBzh+4u++LPHmsXr0a3bp1M55je5XExMRy7Y9M9SKltcCryeP4888/GynsdtHI3zRPKsXV7s2dO7dAeQvr2SjUOYHkrjVrxR0bGRkvzwQmPSs46SlEde/Pv/76q3FR7+Pjk7c/80LTXSO6Vh4XOIYlZcEtW7bMcNe///77DUdud4ZlaeHh4cY4ckzsrFixolzXQTyn1atXz63P9YTjyLaKhNdLvG4q7pqJWV12AUooKCnUmUXnruUXXbt2xeeff26Mhd0/gr9p0qVLl3Kd63lsZeq7ZTjUlk44Pd9//73Nz8/PtmLFCuPxmjVrDLfIL774Iu81P/74o61Hjx5Fvl/u7ib33HOPrXnz5objI6Gru5eXVwFX8ieffNJw07fz7rvvGmM9Z84cB327rgWd2jt37my7/PLL85xzb7vtNlujRo0KOGxecskltvHjxxv3Fy9ebPv9998LuBE/9NBDNn9/f1tCQoLNHTl06JCtTp06hjup3TWXHRuuvvrqvNfExsYav2mOX1H88MMPbu/uPnv2bOM3PG/ePGNMtm3bZhzv+Lu1M3PmTGMc7e7NdCbO31WAx046auc/ngpRHcTFxRnnmzfffDPPGbpjx46Ga7udffv2GfvzsmXLznq/3N3PdM9gF5KFCxcaj7ds2WILCgoq0OVm+vTpxjjanfGXL19uvIZdNsSZ7hkNGza0HTx4sMCxcvXq1XlD9N///td20003Gfd5jH3nnXeMzjj5OxbwGD1p0iS3HdbevXvbBg0aZDt16pTx+L777jM6jJw4cSLvNew88NZbbxX5/tTUVLd3d09JSTG6Ldh/n+wa0KtXL9uQIUMKdGzib/qPP/4wHk+ZMsXQS3Z4rR8dHV3geGoFEunCOFjWqlXL1qpVK6NtGEWOvSUb4UVp/vkc7ozcWbnwANmkSRPjPkWou8IDIsUjxSHFOluJfP311wVeQ5HUp08f4z7b4HBMw8PD88bSvrAdhLuyfft2W9u2bY1xYXsQtsBauXJlgdfwBMTWQfYLz+HDh9vCwsIMgc8DLW/deQzJjBkzbKGhocZvMzAw0Njv7BNIZOfOncb+x9cVhUS6yUsvvVTg2Dh69OgCrZcovjmOvNCxT3pyn+XrOblEUc8LSyGcgZ9//tkWEhJia9q0qXFc6Nevny0pKanAuZ37M1tf2uGFKs9LPMby+Mr7F1xwgc2deeGFFwocF9h+NX8buwkTJhjjaJ+84znNx8fnrHP9K6+8YnNXKIR47maQqEWLFsa108cff1zgNbfccotxPic87vIak/shJ5co8OvVq1diyzZ3YO/evbZOnToZ53uKRLZULDz5zmvSe++9t8j3S6SbUHzXr18/77zdrVs3W3x8fIHgB3/TvDYi69atMyZIOOZt2rQxjgO33357gRbVVuDB/1kXlxeuCtNf6GLI9ixMQyqcwsH0GdavkPT0dGzcuPGsdbB2g6nf7gxdSzmWrVu3PsukZ+fOnUaqIdNlmYq8du3aItfRqlWrvJotd4SHJLYDo3EhHVwLm6KwzQVT3JgyZ4euunv37jVcTiMiIqphq50P7mOsM2cpBk3hCv+N+1+bNm2KrK/mPsz9lR4J7mi+lx+6NnPfottr4X2L7dVYg8byDPt+yv2Xz3Hc6JUg803hjMcFtlLN36aR0Pho3bp1xnHXXl/N8qPC5kncp+0lSe4KOzzwuEDDMnYgKeq40L17d8PDgmPKsS0M31f42OxuxMfHGynavHYs3KqOY5iRkVGgTIvtw3bs2GGc1zj2Or6acEz42+Zvt3DZBfc/nud5PioMy9yYLs9rVndtW2uHxzm2o+S1e+EuN/wbj4XcT/PXqbO1LcsteCwtfM1vBRLpQgghhBBCCCGEkyB3dyGEEEIIIYQQwkmQSBdCCCGEEEIIIZwEiXQhhBBCCCGEEMJJkEgXQgghhBBCCCGcBIl0IYQQQgghhBDCSZBIF0IIIYQQQgghnASJdCGEEEIIIYQQwkmQSBdClJmcnBz873//w7Zt28762+LFizFnzhyNphBCCOHizJ07FwsWLDjr+V27duGnn37CqVOnqmW7hHAXJNKFEGXGy8sLS5YswbBhw3DixIm85zds2IBBgwYhLS1NoymEEEK4OOnp6bjooouwZs2avOcyMjKM8//8+fPh6+tbrdsnRE3Hw2az2ap7I4QQrsPJkyfRpUsXXHjhhfjoo4+QmZmJbt264bzzzsMXX3xR3ZsnhBBCCAu47bbbsHLlSqxevRq1atXCmDFjDIFO4e7v768xFsKBSKQLIcrN33//jX79+mHWrFnGMnPmTKxbtw6BgYEaTSGEEKIGwOy4jh07YuTIkcY5f/jw4Vi6dKkxKS+EcCwS6UKICvHUU0/h008/xbFjx4y6td69e2skhRBCiBrEX3/9hYsvvtiYhB87diyefvrp6t4kIdwCiXQhRIU4dOgQYmJi0KdPnyLNZYQQQgjh+nTu3Bk7duzA4cOHERQUVN2bI4RbIOM4IUSFuP/++9GqVSssW7YM06ZN0ygKIYQQNQx6z+zduxdRUVF48sknq3tzhHAbFEkXQpQbGsTdd999hnnMpEmTMG7cOGzatAn16tXTaAohhBA1gO3bt6Nr164YP368MSnfv39//Pbbb0Y3FyGEY5FIF0KUC86oM/XtjTfeMJxe2Tu9V69eaNSoESZPnqzRFEIIIVyc06dPG14zjRs3zju3P/bYY/jxxx+NSXmlvQvhWCTShRBlhoKcM+mhoaGYMWNG3vNbt241Zts/++wz3HDDDRpRIYQQwoWhQdyXX36JjRs3Gud8kpWVZZzre/Togc8//7y6N1GIGo1q0oUQZYatV5o0aWKI8fy0bdsWH3/8MRYvXmwIeSGEEEK4JsnJydi/fz++++67PIFO2Cv9m2++wcmTJ42/CyEchyLpQgghhBBCCCGEk6BIuhBCCCGEEEII4SRIpAshhBBCCCGEEE6CRLoQQgghhBBCCOEkSKQLIYQQQgghhBBOgkS6EEIIIYQQQgjhJEikCyGEEEIIIYQQToJEuhBCCCGEEEII4SRIpAshhBBCCCGEEE6CRLoQQgghhBBCCOEkSKQLIYQQQgghhBBOgkS6EEIIIYQQQgjhJEikCyGEEEIIIYQQcA7+H0Cva/9RjqTzAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -365,17 +298,13 @@ "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", "ax[0].grid(True, color='lightgrey')\n", "\n", - "\n", "for i in range(2):\n", " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", "ax[1].set_title(\"Posterior Weight Functions\")\n", "ax[1].set_xlabel(\"X\")\n", "ax[1].set_ylabel(\"W(X)\")\n", - "ax[1].grid(True, color='lightgrey')\n", - "\n", - "\n", - "plt.show()" + "ax[1].grid(True, color='lightgrey')" ] }, { @@ -400,19 +329,12 @@ }, { "cell_type": "code", - "execution_count": 30, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:32.711317Z", - "iopub.status.busy": "2026-07-20T04:09:32.711224Z", - "iopub.status.idle": "2026-07-20T04:09:32.712951Z", - "shell.execute_reply": "2026-07-20T04:09:32.712564Z" - } - }, + "execution_count": 11, + "metadata": {}, "outputs": [], "source": [ "# Redefine the model set\n", - "fs4 = honda_models(True,4)\n" + "fs4 = honda_models(True,4)" ] }, { @@ -428,15 +350,8 @@ }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:32.713934Z", - "iopub.status.busy": "2026-07-20T04:09:32.713865Z", - "iopub.status.idle": "2026-07-20T04:09:47.421551Z", - "shell.execute_reply": "2026-07-20T04:09:47.419898Z" - } - }, + "execution_count": 12, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -462,7 +377,7 @@ "# Train the model\n", "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train, s_train=s_train,\n", " ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", - " tc = 2,numcut = 300)\n" + " tc = 2,numcut = 300)" ] }, { @@ -474,15 +389,8 @@ }, { "cell_type": "code", - "execution_count": 32, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:47.424200Z", - "iopub.status.busy": "2026-07-20T04:09:47.424089Z", - "iopub.status.idle": "2026-07-20T04:09:52.428382Z", - "shell.execute_reply": "2026-07-20T04:09:52.427630Z" - } - }, + "execution_count": 13, + "metadata": {}, "outputs": [], "source": [ "# Evaluate the model set at the test inputs\n", @@ -490,7 +398,7 @@ "\n", "# Get predictions\n", "pred = mix.predict(x_test=x_test, f_test=f_test_arr, ci=0.95)\n", - "wts = mix.predict_weights(x_test=x_test, ci=0.95)\n" + "wts = mix.predict_weights(x_test=x_test, ci=0.95)" ] }, { @@ -504,15 +412,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:52.431300Z", - "iopub.status.busy": "2026-07-20T04:09:52.431192Z", - "iopub.status.idle": "2026-07-20T04:09:52.434252Z", - "shell.execute_reply": "2026-07-20T04:09:52.433828Z" - } - }, + "execution_count": 14, + "metadata": {}, "outputs": [], "source": [ "# Predcition upper and lower bounds\n", @@ -526,30 +427,24 @@ "wupper = wts[\"wts\"][\"ub\"]\n", "\n", "# F test data\n", - "f_test = [fs4.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]\n" + "f_test = [fs4.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 487 }, - "execution": { - "iopub.execute_input": "2026-07-20T04:09:52.435297Z", - "iopub.status.busy": "2026-07-20T04:09:52.435232Z", - "iopub.status.idle": "2026-07-20T04:09:52.529133Z", - "shell.execute_reply": "2026-07-20T04:09:52.528700Z" - }, "id": "I-f8MkmmJnqq", "outputId": "df0d0dbd-7bd4-45cb-e63f-3225bed0a677" }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -582,9 +477,7 @@ "ax[1].set_title(\"Posterior Weight Functions\")\n", "ax[1].set_xlabel(\"X\")\n", "ax[1].set_ylabel(\"W(X)\")\n", - "ax[1].grid(True, color='lightgrey')\n", - "\n", - "plt.show()" + "ax[1].grid(True, color='lightgrey')" ] }, { @@ -600,15 +493,8 @@ }, { "cell_type": "code", - "execution_count": 35, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:52.530520Z", - "iopub.status.busy": "2026-07-20T04:09:52.530428Z", - "iopub.status.idle": "2026-07-20T04:09:52.533733Z", - "shell.execute_reply": "2026-07-20T04:09:52.533323Z" - } - }, + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ "# Define the model set\n", @@ -626,7 +512,7 @@ "x1_test = np.outer(np.linspace(-np.pi, np.pi, n_test), np.ones(n_test))\n", "x2_test = x1_test.copy().transpose()\n", "f0_test = (np.sin(x1_test) + np.cos(x2_test))\n", - "x_test = np.array([x1_test.reshape(x1_test.size,),x2_test.reshape(x1_test.size,)]).transpose()\n" + "x_test = np.array([x1_test.reshape(x1_test.size,),x2_test.reshape(x1_test.size,)]).transpose()" ] }, { @@ -642,15 +528,8 @@ }, { "cell_type": "code", - "execution_count": 36, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:09:52.534756Z", - "iopub.status.busy": "2026-07-20T04:09:52.534690Z", - "iopub.status.idle": "2026-07-20T04:10:14.089325Z", - "shell.execute_reply": "2026-07-20T04:10:14.088555Z" - } - }, + "execution_count": 17, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -673,7 +552,7 @@ "\n", "# Train the model\n", "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train,\n", - " ndpost = 5000, nadapt = 2000, nskip = 1000, adaptevery = 200, minnumbot = 4, tc = 2)\n" + " ndpost = 5000, nadapt = 2000, nskip = 1000, adaptevery = 200, minnumbot = 4, tc = 2)" ] }, { @@ -685,15 +564,8 @@ }, { "cell_type": "code", - "execution_count": 37, - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-20T04:10:14.092088Z", - "iopub.status.busy": "2026-07-20T04:10:14.091972Z", - "iopub.status.idle": "2026-07-20T04:10:21.655409Z", - "shell.execute_reply": "2026-07-20T04:10:21.654720Z" - } - }, + "execution_count": 18, + "metadata": {}, "outputs": [], "source": [ "# Evaluate the model set at the test inputs\n", @@ -704,40 +576,24 @@ "wts = mix.predict_weights(x_test=x_test, ci=0.95)\n", "\n", "pmean = pred[\"pred\"][\"mean\"]\n", - "wmean = wts[\"wts\"][\"mean\"]\n" + "wmean = wts[\"wts\"][\"mean\"]" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 412 }, - "execution": { - "iopub.execute_input": "2026-07-20T04:10:21.658265Z", - "iopub.status.busy": "2026-07-20T04:10:21.658157Z", - "iopub.status.idle": "2026-07-20T04:10:21.979518Z", - "shell.execute_reply": "2026-07-20T04:10:21.978798Z" - }, "id": "meVGDrOAZp5w", "outputId": "831c346f-95af-47f6-8783-094f81317f36" }, "outputs": [ { "data": { - "text/plain": [ - "Text(0.5, 0.98, 'Posterior Mean Residuals and Weight Functions')" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB4YAAAJJCAYAAABGY1paAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QeYU9XWxvGdzAy9g4AgIqCgIHZBBQULNhTEhhdUVEQUFXsFAZVrL9i9eu3YBbFgxYINsKGigAURUIoKSm+Tyfe823vyZTLJTHJOev6/54kySU4/k6zZe6+1fcFgMGgAAAAAAAAAAAAAAHnLn+kdAAAAAAAAAAAAAACkFh3DAAAAAAAAAAAAAJDn6BgGAAAAAAAAAAAAgDxHxzAAAAAAAAAAAAAA5Dk6hgEAAAAAAAAAAAAgz9ExDAAAAAAAAAAAAAB5jo5hAAAAAAAAAAAAAMhzdAwDAAAAAAAAAAAAQJ4rzvQOAAAAAEivlStXmmAwaGrXrm1KSko4/Ugb3Xe6/6Ru3bqmqKjI9fL16tUzfr8/L44r32TrdfJqw4YN9qHPTX1+JtO6devMpk2bTLVq1UytWrWSum54s2rVKlNWVsZ3JgAAAPJCfvx1BgAAgIKlzoe///673MNpxM3G/SwtLc30rpjWrVubhg0bmsmTJ5tstHr16tC11L9TtUy+CD9256H7LRvutUjaL917esyaNcvT8rNnzzb5clz5xu11Wr9+fegzvDIbN24M3eubN2+u9L3O+7SMV2PGjLHHdMwxx5hkGzZsmF33GWec4Wp559ytXbvW036En9uqHrnO+V6u6h7q2LGjvTbPPvts2vYNAAAASBU6hgEAAJDTWrZsGeqAcB7169c3xcXFZptttjGDBw823377baZ30zRu3Nju25QpUzK9K1lvzz33DF3LLbbYwixfvrzS9//++++h86vH3nvvbQr1fDmPBg0a2KzG5s2b206sd999N9O7CVTpnnvusfdvo0aNQhnH0QwfPjx0r996660x3zdnzpzQ+1566aW8vgKXXHKJPc6BAwd6Ws99991X4fMk1kPZ07nMGSSV7/cGAAAAEI6OYQAAAOSF6tWr2w5hPerUqWNLmS5YsMA8/PDDZrfddjPjx4/P9C5mDec85UIZaWWvPf7445W+55FHHqky46sQ6Ho611ble2XZsmVm4sSJ5sADDzSjRo3K9C4an88X2sdCL7eMivbff3/7/0AgYD788MOYp+j999+P+u/K3tezZ0/Pp7xmzZqh75hC4Pyuxnro97kQOMerMt8AAABArqNjGAAAAHnh4osvLldKWFmmDzzwgM2cVKfhaaedZubNm5fp3cwK6jDXeerdu7fJZp07d7b/f/DBB2O+RwMA/vvf/9p/77TTTqaQDRgwoFwpaf0evPzyy6Zt27b29WuvvTbjmcPqXHH20bm+gGPXXXe1n9mVdfguWbLE/PDDD6Zp06Z2QNDHH38cs2y6s45OnTrZ93s1evRoe+++8MILBXHRli5dWmkpaZ3/QvDdd9/Z4z3++OMzvSsAAACAZ3QMAwAAIC+pFOmQIUNsxrCoc7iqDkbN0ZgoZbZVtty6devKzcWo+R8j50OuitYfz5zJzjq1T+FU7jO8LGu88yomel7i3X68evXqZcuBqxysOn9idfz89NNPpkOHDmbfffdNeBvxnttImzZtijtLOdZ5cbvteCmr8cgjjzSTJk2ypdWlst+ByPtW1z4R6pyrqrSs1hnrfESTyO+ktu90isez/XjOvY4nnv1M9nlyI9591XE75yDyGuu6u+HmszMav99v9ttvP/vv9957r9LOXmUXd+3a1axZs8Z89tlnVb63Mjpv8VwTvSfeeXy1Tn1OuF0+/H6pbH5kbUfrdLalz6XIDtxUVlQIv58q+53Sd12sfXG+kyI7+L18Rup8xBow4MzH7Nz/zvd0+MCaePfdy3dmMo9b94Hb318AAAAUFjqGAQAAkNf69esXykD7/PPPKzS+3njjjWbnnXe2ZXhr1aplO9MOPvhgm2kZi7KRNZ/jdtttF1pOmZA77rijufzyy21HpmPYsGF2DkOnw+bYY48tN0dj+/bto25D2z/88MNtSWCtX9tRhuVNN90UtQNDzznrnDZtmpk+fXro2FX+NDxbzplXcfLkyVG37ea8JLL9eKlMqeaIrqxDU1nhokEA8Ur03MqPP/5oz4k6n5s1a2Zq1Khhy4puueWW5sQTTzTffPNNXOflq6++snP+6n7RtpVxp3W+/fbbJlV0bMqYlJkzZ0Z9j+7Pxx57zHagab9q165tj69Lly72HMfqcFT2+Zlnnmm23nprex51rTUoQ+XblaG8cOHCCh0hzvmYNWtWzHWefPLJ9t4JP0fPP/98pcf5xhtv2PVq3vFYVFrb2b6yTiPp+qjktuZt1rzVOh4dl35nhg4dan7++WfjRqLnKR5u91XH7ZyD3377zXbAHnrooaHrrntbP0d+XibrOlXF6cTV8UXr5Hc6e1UaukePHuWeCzd79mw7/3j4OiP3/5xzzrEZ9brXdf40p/lJJ51k5s6dG3XfxowZY8+bfodjdQpqMJIyn7VOnRN9Ruh6KNPZWb5///6VngN1HOvabrvttnY9uia6rldddVWFTmJ1imudzmfka6+9VmEu4Fif9cmge9fZTmX3sc5zrPl8nTnip0yZYrNzdX70s+4rHb/mjX/11Ver3Je33nrLfu80adLEnnudNw0uOvXUU80nn3xSYT5mZ2DWoEGDyp2vyM+Qjh072uefffbZqNvVNbn99tvN7rvvbvdX+62HSvhXll3u9bjVqXzllVfagVF6v35/9b2m/b3oootifsYCAACgwAUBAACAHFa7dm2l/ARHjBgR8z2dO3e279lzzz1Dzy1evDj0vPOoUaNGuZ+HDBkSLCsrK7cuLbf11luXe1/NmjXL/dy1a9fQ+88666xg/fr1Q69pf/Wz82jfvn259W/YsCF4wgknVFi/3+8P/dylS5fgX3/9VW659evXh14/44wzgj6fz/67qKjIbqdJkyah9zr78+KLL1Y4V27PSyLbr0qHDh3sshdddFHwt99+s+vQOfj777/Lve/PP/8MVq9ePVitWrXg77//Hjz77LPtcp06dYq6XrfnVnbfffdKz4n2YcKECRWWCz8v5557brC4uNj+W/8vKSkJvaZ9iLZ8Iudr0KBBMd9z2GGH2fe0aNGiwms63v3337/CeXGuoR5HHHFEcOPGjeWW+/bbb4MNGzas9Hehf//+FbblvDZz5swK+/Lll1+WW6euvc5t+L3l/HvWrFnlln3llVdCv2OxLFmyJLT8nDlzKrzeuHHjSq9zvXr1gh9//HHUcxjruNycp3i43Vcdt/Oe888/P/Rv3Y863+HrmzZtWtRte7lOVfnqq69Cy7788ssVXtdnpl6bPXt2cMqUKfbfBx98cIX33XPPPfY13cf6rAg3ceLEYK1atcrtf/j50/V59dVXK6zzsssus68fcsghFV7TZ+Kpp54a8/doiy22CPbr18/+u3fv3hWW1++vXuvVq5f9DIt1XfW7HP75+9lnn9nPWOf867Ml/DtGj2jHEsvtt98e2pY+v6oyf/780Pv176ru1+eff77Ca859N2zYsNBx6Lnwz0idxyeeeCLquvXZdPLJJ5c7T5GfsToPjksuuaTc97LuhfDz1bJly3Lr1896X7Tt//HHH8E99tij0t/vE088MVhaWprU49Y9ve2221b6GRDruxAAAACFjYxhAAAA5DVlcM2fP9/+Wxl6znMnnHCCzaZRls24ceNsZpoyZfXegQMH2vcpA+u2224rt75///vfNitKGUkTJkywZUxVvlEZXsoUvvnmm222juPee++1WT1FRUX2Z2UPhZes/P7778ut/7zzzjPPPPOMff+IESPMr7/+atevfXvuuefsdj/99FObgRaLMjyVIfrOO+/YTCZt548//ojrXLk9L8nYfjQtWrSwcyFrH5588slyrynDVevv27evzfSripdzq2uqzE5lMf711192GS37wQcfmIMOOsiWLT3llFPMihUrYm7/rrvuMrvssotdRvute0b/VlagyoZq/5Jdttjxyy+/hM5n5DXX3MTKGlWWmq6rrpWOTXMU/+c//7HPK2tN2YrhLrvsMnsu2rVrZzP1lB3tLPf111/b+ViVrRcvLauMeq2zefPmZuLEifY8a73KtlYWppMhnirKvtU5ULapjkPbV1ahsjD32GMP+2+dr0RK8yb7PCVzX/U7fsghh5gvv/wydE++8sorNsNf+3nBBRek/TpprnBlUkYrJx0+v/AOO+xgMyqVJa1S85HH6Swbvj4nw1afczqO7t27h34fdQw6l6omoH//61//slnF8dLn4iOPPGL/rQxVfU9oG/oM1XnW5+CLL75Y5XpUPUCft3feeWfos2bx4sWh6gmvv/56ucoNutZat1M1QZ+XkaWk3c4n75Q6jvaIVabZC31fbr/99qHvDp0/3VP6/NVnle7HaGW19fzjjz9u/62Mb1Vw0Gey7kldw0cffdRea4eqQ+gYVLnB+S4JPzZ9N8RL21N2vcr1q6qErpn2e9GiReb000+37xk/frwZO3ZsUo9bsYamUVDG/tNPPx36DNBDcYUymFX1AwAAAKgg0z3TAAAAQCozhh988MFQ9syYMWPsc5MnTw499+ijj0ZdzsnsatCgQXDNmjWh53fbbTf7/Lhx4xLaTycz6PXXX4/5nq+//jq0X7fddlvU97z33nuh93zzzTdRM1ObNm1qs5hiiZUx7OW8JLL9RDKGwzNBd9lll3Lv22GHHezzb731lv25soxhL+e2KsoE23nnne1yd955Z7nXws9Lu3btgqtXr66w/Icffhh6z/Tp04PJzhh+9913Q+u/+OKLy7320ksvhV5TFmU0jzzySCgbTZnZjkaNGtnnJ02aFPe+VpZZe/fdd4cy/ZQ1GmnFihU24zmVGcOV0bVr3rx51EzWyo7LzXnyqrJ9Dc8Y3meffaJmMipD0XnP0qVLk3qd4nH00UfbZXfddddyzz/11FP2+eOOOy70nI5Bz4VnRyujVhm6TlZ0uL333ts+r8oIqiIQafPmzaGMXX2mxJMxrHPYqlUr+9qxxx4b9Zjuv//+0DmpLGM41u+ijsmp5nDKKadUeN35/Ovbt2/Qi/CM4coe+rxMdsawMnN1/0TLUHe2oSzxcLq/nKxsXZ9EON+F0fYpnozhqVOnhvZLvxfRKFvYyUqOPDYvx73ffvvZ58eOHZvAEQMAAABkDAMAACBPOJmpeihrU3OpKsNRc0iK5sg944wz7L+dOf80v6/mFoxGmcGi9SnLz6H1SLS5L71yss2UWXj++edHfY/m1dQ8nhJtrkZRlpKyXxPl5bwkY/uxHHbYYWarrbay2brOvKcfffSRzdBu06aNzdhN17l1KFvOyaZTppaWFWUcx6J70bl/wimTrW7duvbf0ea9jZcy5JzfAWWtffvttzbr0JkPVVnVykqOdl40B6vm5oxG94LmxlX23Ztvvpmy3wXn/tN+RMt009yb0TJYU0lZqM511jVXhmpV1zlSKj8zvO6r5lp1qhlE/s45Iu/JdFwnZ05gZVTrXo7MAnZ+38SZZzg8u1jztTpVCsLnF1YmpTIx5ZZbbrHz0EZS5qfmbZVJkybFtb86x8oQlZEjR8b8XNR8w1XRfLHRfhc157qyu71+TiRCGbWxHjpPyaZ5uHX/RFIWurLTox37E088YbNq9fl29dVXm3Ryfhf0/XTWWWfF/M7UtVMWcKz5gt0cd7o+VwAAAJB/KCUNAACAvKBGfjWs6qGyobvttpst3agOYzViqwHXaZT/4osv7P8r61BUmVI19orKrDp69epl/691q5NNJUzVIZcMn3zyif3/PvvsY0u6qky1Oh31UFlYPdQIrJKTopLP0XTt2tXV9r2cl2RsPxZ1XJ122mmhcq3ilKpVeVU1uqfj3KqTqE+fPqZZs2a2fK1KeDr33B133GHf8/vvv8fch86dO8d8rWXLlvb/2h+3VE7U2R+VTdf2dI+qY03H/e6774auXeR56datmz0n0c6LHtHOi/O7cPbZZ9vOMN0/XkphO/fTAQccEPM9lb2WDCrprbKyOjadQ5VUD7/OTingyq5zpGSfp2Tua6x7Up+hNWrUiHpPpuM6OR2/OkaVena8//775TqDw//tvBb+b7/fX+69zv2uTk11usX6HNCAE/ntt9/KdUzHokErovMfq3yvPsecgSeVqexzwvn99fI5kYilS5fGLCUdXpo5Wdwc+/Tp0+3/9XsQraM/lZzvTN3vutei0aAadfZX9p3p5ridzxWVkx82bJiZOnVq1DLbAAAAQCQ6hgEAAJAX1CDsZDKpcV6Nqfvtt58ZM2aMzSx1Mq1k+fLl5TrjqmqQ/fPPP8tl2KnjVNl5ysZU43i9evVsx5uylRKZkzKS5s90MqCUQaqH1q1H+LE5naOx5rONlnkUDy/nJRnbr4w6gNXwrs5Pzf+ojn51tGguz1SfW2WjnXzyyTaLT/OvOh1tNWvWDC3rdEhU1jBfWaeFk7WpjjC31Fnt7I/2Lfx53bPhc1+LOiedrEoNdKjsvDjZ4eHn5YYbbgh1rikrTnOdajl1kmj+y0Tmldbvkzrlos2DHK6qe9MLXTt9Tmiu6ClTptgOQQ06CL/OOpfOe+OVzPOU7H1N9J5M13XSHOXOvOFOJ69+h3/88Uf7fPi9rEEN6uhVp68zSMdZRgOEnHlknXWIMqo1T3Gs+12f547K5g13OJ+FVWUEV3bO0vU5kc3cHPuyZctCHbDplqzvTDfHrQoURx55pP0cv+++++xgCt3PGpilainz5s1L+HgAAABQGOgYBgAAQF64+OKLy5XRVVlPZdCMHj26QmO9k2GqDr/KOA2x4ZlAasB9++23zRtvvGGzWLfbbjvb8aLypOqE1s933323q2Nw9ie8c6eyR6zG5HgyaCtbzs15Scb2K6NG/4MPPthmTak08vr1603v3r3j6mjxem6fe+4526Es5557rs360vZVGtS55zRgINMGDBgQ2h/tmzqwb7zxRvvaNddcYzNWw4Vf59q1a8d1XpzORlG58M8++8w8//zzdtutWrWy21VJ30svvdS0bdvWTJgwIa59D7+XKrv/UtkhNm7cONvJqmMcNWqUmT17tv3dDr/O/fv3T3i9yTxPqd7XbLlO+gxxsoadEtHO/zXgJ/wzRiV11QGsY1dJZ+2XPvsjy0iH77OOI577XY94jiXRz04kTyY7y5P1nemGBkO8/PLL5p133rHTZCgrWQMe9DuggT76+aabbkra9gAAAJA/6BgGAABAwVEpYPnll18qfZ+T/avMskjK1nvooYfsvH/KAnr22WftnJ7KqBs+fLj55ptvEt4vpwNbnYyxyneGP2LNV5jJ85JKQ4YMKTdnqvNzqs+tOvTkuOOOs1niyv50yuyGl1zNNsqsVMejssnk/vvvtx0J4R0LzlzQd911V1zn5d57763QKXPssceaJ5980ixcuNCW3tW8xcroVIbsSSedFFfZZa1H5Yulsqx7bSMWp9NFnSOxqIx4LM511hzUyv5X2fTwjnAv1zlZ5ykd+5rq6xQvp1NXn6XK2nWygMPnF45WTlpzazuZmZEdw87ngO77eO53PTTYJ97PTlUzqKyT0JmHOJ+Ed3ZW9runjvtUcAYHZSJDNt7vTOf1VHxnqvLAf/7zHzN37lybwaxBJvp9UCbxZZddFppTGwAAAHDQMQwAAICC06VLF/v/N998M2aWkeYOdEpUOu+PRR0lxx9/vJ3DVR0O6hhQVnGiWU3O/JOvvfaayYfzkmya33fbbbe1WXzt27c3hx12WNzLejm3ixcvrnQeSDXAR17vbKIy3M6crxdccEG5ObGd8zJ58uSkddKovLGyO9VhpMzqDz/8MK5l99xzT/t/ZePH8vrrr8d8TeWARZmzscozK3PX7XXW3LPJ6mTxcp7Sva/Jvk7xcjp1nQzgaPMLO5zndD6dzGINfIicB9e539UJ//nnn5tkUXlwUSd/rPOu+9LJZM6nzFnn966yjm911useTwXnGusz2Clznq5z5nwHKns//HM1nDpsf/7553LvTxVN43D00Ufbc6HKBOJMAwAAAAA46BgGAABAwVE5V6cR+7bbbqvwurKeVJpamjdvbg488MDQa5Vlgyljz8mechqcHc48l5XNJ6pykFpOHRbxlKOuqnxlOs9LOqijR3OMKovv+++/r3COK+Pl3DZq1Mj+P1aHj8o1e5lbOh1uvfVWe2+qg0LZwY6zzjrL/n/ixInlsom93nPVqlWL+bsQywknnBDqcNQgi0i6L++4446Yyyv71intqjmoo2ULa47fWKq6zsq+rizj2A035ylT+5qs6xSv7bffPpTh+9RTT9nffQ3C2XHHHaN2Duo86nw4HWHqrNWcq+GU/et8bmmO1qrOUbz3u6oIaLCKjBgxwg4WiTbXdDzzFbsVz3dMKmhOZmeO3Wi/dzqHOiepogEW+m5Qp7CuaaxO3mjX0us5c74zlaF+3XXXVXhd+3LRRReFOm01/UGyVHZv6nw4nyeJfK4AAACgMNAxDAAAgIKjTgRl1TgdKGq4VUaTssiU0aUy0U52mjr91Hnj0Lx9p556qi0drexDZe6pI0QdJEceeaRdhxpiDz300HLb3GWXXez/77nnHrucGpLVwRme4aR1a75QZy5bZSEr807r13pVUlWdMVdeeaXp1KmT+eSTT7LmvGQ7L+fWaczX+4cOHWq+/vpru4xKWp9++ukp7fRIFt1/AwcOtP9W56jTQXXQQQfZ+1mdDLr26kBXxqXua5UinjlzpnnllVdsyeI2bdrYEsiie1fzPmve4kmTJtn36f3qIFcZbt3/GkigjrloGZ6xOll22mknuy9HHXWUnUdXJVi1L/p9U7antltZZ2mvXr1C969+13766Se7/Isvvmj22Wcfez/H4lxnldweOXKkmTNnjr3OH3zwgd2fBx54wCQqFecpVfsaL6/XKRFO2WhnDubI+YXDO/h23nlnm5XqVAWILCPt0H2hzswZM2bYZVRqXXM06zNZ5YiVua3SvDrHiZSrdwYd6DNS1Qy0Hl0T3XPK1FfJ71RyvmM0+EVzoqustVMOW1McpJIzn7XO21VXXWW+++47W1lC34v63ohn0IlbrVu3NqNHj7b/1nGr41+/W/qs0ue7roPmWHfOTzjnOf2+TJ8+3XYQ63wp4z4eWl5l4EXXVx3T+i7Rej7++GNzxBFHhO5Hzftbq1atpB23s+2nn37afhfpeHXN9V2tz3L9Tup35fDDD0/aNgEAAJAnggAAAEAOq127ttJmgiNGjEhouZUrVwYPOuggu2y0h8/nC/773/+usFzDhg1jLqNHcXFx8P7776+w3EsvvRT1/c2aNSv3vrKysuC1114bLCoqqnQ7enz88ceh5davXx96/sMPP6z02OvXr2/f9+KLLybtvCSy/ap06NDBrueiiy5KaLmzzz7bLtepU6eor7s9txs3bgz27Nkz5nu1v2eccYb9d48ePVydF+2z3nPXXXcF3Z6vQYMGVfq+BQsWBGvUqGHfe/7554ee37RpU+jcVfX47bff7DJ///13le+tVatW8OWXXy63D3/99Vfo9ZkzZ1bYx3nz5gW33nrrmPeerp/z86xZsyosP2fOnGDjxo2jLl9SUhK85ZZbQj/rvZH71rFjx5jHs88++wSPPvroqOc61nG5PU9V8bKvOm7nfYsWLarys/WVV15J+nWK1wMPPFBu3ePGjYv5Xt3T4e996623Yr73iy++CLZp06bKa3PSSSeVW+6yyy6zzx9yyCFR1zty5MiY62rfvn3w5JNPtv/WtYmk66TXBg4cGHO/9fkQ6zNOnzVt27aNuu1on/Wx3H777aHltM5470fncyjaQ+fF+b18/vnnKyzvfCa//vrrMbfRtWtX+57rr78+6me7YgDde7H2Qd/dkaZMmRJ1Gd374Vq2bGmff+KJJyqsY+3atcEjjjii0vvoiiuuiHpMXo67VatWlW7T7/cHb7vttpjrBQAAQOEqznTHNAAAAOCFMr9UNrFmzZoJz4uokqPKcFOZUmV1aX5IzRHcrVs3M2zYMFseNNIPP/xg52PVPLwqbaosHZWL3GqrrexyZ555ptlhhx2izo+r5ZThN2vWLJsprHKjTilLhzJ8lAGorDxlMSn7TFlAeq/KN6tkp7LmlJ0cvh0t56xL56MyzvtU+jpZ5yWR7VdF+6B1JXpNlY2l5cLnvEzGuVVmtK63yuM+//zzNhOrRo0apm3btva9Oid6TduuU6eOq/PiHHP16tUTOubwZavKRlPm6oUXXmgzJnVt9W/NQ6n7QOW1lR358MMPm48++sgsWbLE7rtK+eo9mqNY97DmxhVtT9l4yszTfJbz58+3GaPKltd2lK2pMtXOPJfRzke0Eqc6p8q4u/nmm22msvZD71dZYGV6K5v7lltuibm8yg9rHmyV7VXm8/Lly235YWXD63h1H1977bVRl9dniUoRa9vKcNTx6HqqRPCxxx5rTjvtNLsP0c51rONye56q4mVftW1nX50y1rG2oXs22ueE1+sUL52f8M/IWFnAokzRRx55xP5b+6zPq1h22203m2U9fvx4e/6U4aosUWWd655XuWple0ZuT59J0X7PHbq3lPmtcu3KDlc2uK5z3759zfDhw23mvXNuY31+1a5dO+Z+6/Mh1mecPpOUHat7X59tykx35r2Ndg2r2oZEy86ORsejjNubbrrJfs/pflAWvO4HfT7qnOgzR+cjWqUJLa/XKttPrU/7peOMpP1URq4yl5W1rPOgjGWdS2UUK/NclRGi3TP6vdRn4ldffWXvAX0fRF5fbVffg9H2XddNvwMqx6+MZf1erF692n7u7L333jYmiDW3sJfj1v6qioUeTiyidekzWtURVP1Bmf0AAABAJJ96hys8CwAAAAAAgKTRPNjqkNac3xqoAAAAAADpxhzDAAAAAAAAHlU27v6xxx6zncISOQc9AAAAAKQLpaQBAAAAAAA8Ouigg2zZYpWkVwljlZ5W+fCnn37aliuWo446ymYOAwAAAEAmUEoaAAAAAADAI83xrPleY+nataudg1fzzwIAAABAJtAxDAAAAAAA4NGiRYvMww8/bD788EPz66+/muXLl5v69eubTp06mWOOOcYMGDDAFBdTuA0AAABA5tAxDAAAAAAAAAAAAAB5zp/pHQAAAAAAAAAAAAAApBYdwwAAAAAAAAAAAACQ5+gYBgAAAAAAAAAAAIA8R8cwAAAAAAAAAAAAAOQ5OoYBAAAAAAAAAAAAIM/RMQwAAAAAAAAAAAAAeY6OYQAAAAAAAAAAAADIc3QMAwAAAAAAAAAAAECeo2MYAAAAAAAAAAAAAPJccaZ3AED8fvnlFzNlyhSz7bbbmp49e3LqkLJ7Zvbs2eaTTz4xO+64o9lrr70ycqa53wEASL1bb73V/PXXX+byyy83derU4ZTnke+//968/fbb5o8//jCBQMAcc8wxZtdddzXZat68eeaRRx4xhxxyiNl33309rUvHPXXqVDNs2DDTokWLpO0jAAAw5rPPPjMvvfSS2Weffczhhx/OKckjGzduNK+++qqZM2eO2bBhg9liiy3MeeedZ7LZfffdZ/+eueKKK4zP53O9nvXr15vrr7/edOzY0ZxwwglJ3Ucg29AxjKw2a9YsM2PGjHLPFRUVmYYNG5qddtrJtG3b1hSSzz//3AwZMsQMHDgw4x3DS5YsMZMnT7b/1pfuySefbEpKSmK+/5lnnjFr1qyx/1bgqC/ZfBF+Lhw6J7Vr1zZt2rSxDXDVqlXLqXvm3XffNeeee64N/jLVMZxN9zsAID/cfPPNZuXKleWeq1mzpmnZsqXp0aOH/d4uNHfddZdZsGCBOeecc7KiY1j7s2zZMvvvAw44wD5ief/99+0AOMmFRqt0n0edj2AwGHpOAwWzuWP4oosuMm+88YY588wzPa9rq622sg17ixcvNg8//HBS9g8AUNidoJFtkw0aNLCD6dVeUVl7WD764osvzL///W8ba2RDx/DXX39tnn/+eftvtb9dddVVMTsIS0tLzbXXXmsHzYnanHbYYYe07m+2Wrp0qR2c99NPP4We69ChQ1bH2NOnT7cDAS+88EJPncLO34Xqi9DfjGq73nrrrZO2n0C2oWMYWe3NN980l1xySczXu3fvbh588EGz/fbbp20U+3vvvWfat29v9ttvP1PoGQjqtHM0atTI9OvXL+p7f/jhB/Ovf/2rXENVPnUMR56LSI0bNzajR4+2Ha0AACBz7rjjDvPbb79FfU0NCWoYuv/+++3grnTRIMhXXnmFjIv/+c9//mO+++67UNZn5CDRcFdeeaWZNm1aTjRapdOff/5pLr74YtsprCzhzp072wbs3XbbzWSrDz/80Da6q2FPnbpeqYH3uOOOM4899phtKFTDPQAAXjpBY9EAw0cffdQcdNBBaT3B6txUdueYMWNMcXFhN/GrMy/8Gqlzc//994/63tdee81cc801oZ/32GMPOobD7il1Cm+zzTbm+OOPN3Xr1jVNmjQx2Uwxrzp0L7300qSsb9SoUWbSpElm5MiR5vHHH0/KOoFsVNjfGsgZahxQSTHZvHmz/ZJSI9BHH31kR+bNnDnTbLnllinfD21THYCDBg3KSMewslgGDx5s9t57b5MtatSoYUuLqNElVsewAuTw9+ar6tWrmxNPPNH+Ww1xGmmncszLly83w4cPtyNIk5EBkev3DAAAmaZKJ9ttt53994oVK8zHH39sPv30UzN+/Hgba6rSSTqzUDKZcaHGlL///ts2/GSTevXq2Wsyd+7cqINANfBQsbnet2rVqozsY7bS/bxp0ybbIPrCCy+YXDB27Fj7/2QOpNS6nn32WZs5/OSTTyZtvQCAwqTsQScpQFmnP//8s5k4caIddHjkkUfauEWDsdLlxhtvNGvXrrUdWOnuGO7SpYvtROzatavJJk5cqDbKWB3DThslMWT06oGi+EnXONspeUtx7ymnnGKaNWuWlHWquo4S0RQ76h5v3bp1UtYLZBs6hpETOnXqZP773/9WGFXeq1cvW2ru9ttvNzfddJPJd7vvvnuF85BpGhmp8jkacaf5y1TGL1xZWZl54okn7HsUMCoLPF+p/GLk9VFAesQRR9j7VY1S6e4YzsZ7BgCATFMlk0MPPbTccyNGjDDXXXedbQi5+uqrbQZqIVAJ6WykbM+HHnrINt7dcMMNMRv1lM1ArFPe77//HiodnQvmz59vs8MVtyazEpRKACrjZcKECebOO++0VXwAAHCrVatWthM2cmCTvr9UrUPlZwslw1BVSLKxEok69dRRr4Fxd999d4VpUpS4oangdtllF1tNRdngyN0YUpWGRFWfkknrUzKa/sZQ5zCQj+gYRs5SWRBlQt57772hEU3hNFeavuA1eq558+Y2Y7KyedNUJlpzUmge3BYtWtgskvBRQS+++KKdx0x+/PHHcg1QanCIVjJGnYKa60Cd19q2RlupIzUaZUPoS0ed4NpXTXivnzUvlrI+laH8yy+/2HnU9AUda87VeI87nu3FSyOzNCJfo6nOP//8cq9pf3/99VfbIaq5eKuSyDlz6Fi//fZbe+yaI0TXQ4F5tHl9ox23Om2V3avRZbqvatWqZZJFIxBV5vCwww4zCxcutBk56iRPxnFXdc9KVfeMMpuVqaSsG2UK6Zw0bdo05jb1Xm1T79M5jKTSj8re0Rzg0UYXJnKtqhLP8QMAEC+V4dNgQ8UGqvgR3jGs7y99nyqOcL6/Dj744EpLq2mqiQ8++MDGP/Xr17ffUfouDo8Dbr31VtshJvr+DG9sVGPb0UcfXW6dyk5R3PLVV1+Fvv+0H2qojKTX1aGqbWtqFv2s+VsVx+oYnG1pH/766y9z+eWXR40ZlVH91ltv2c47v99vp1RR3Bstw1jxlBrhFMOcddZZNu7R4EEtq3UnUuq5T58+Nv7WAENlVKvxLtrAw6OOOqrKjmFlz06dOtWWGdS1dKoR6fzFon3X9dO+K05TXK34ONaAAZ0jvV8xX7du3WxspWur86fro0witx2TOl7Fr4rxdR0VsyoLxsl6D7/ndF6+/PJL+7Pe71zneOZgVlyoOflUjk8DJcIpnleZdRk6dGi5e073k5Pxq+2FX6t4PPLII3bb6uSPxtm21qu4WlV6wqmM5i233GJ/d3U/qCSkUx5eAwzUUP/UU08xrQsAICVZxGeffbYdVKjMxUiKPRS7qeNYcctee+1VaSamvssUPyjmVPyi71tlIYd3wjpzHut10bbDv3ujxXRqj1Lbqb5T9T2qDlTFEtG+s5UFrVhC36E777yzjTudY1Diw5577hnaBw3CilXxRm1cmhJk5cqVNg5RHBWtHUnUoa7Y6dRTTzXt2rWzy+qhOEoDOhOZA1hVHhXPqHNY7ZXh1G6p86bnFTNVRVnhykpVPK/4SDGGjqOyuWx1btQ2pnOtyok65gMOOKBC/CKqqqgYStPYXHHFFfb6v/766/b6q51MMaWXCoBq49X9tGjRIrsvmlpD1z1yXzTln9ojFSeLEluc98QzB7P+xlCs2rdvX3t/hHv44YftedQ6Ijtw9feV2to1YFdZuolQrK6/FfT3mM5vNM62dcwHHnhghded7WsdipOd66p7X9ObKEalYxh5KwhksZtvvjmo2/SQQw6J+vrdd99tX2/VqlXouV9//TV46KGH2ufDH7Vq1QqOGTMmGAgEyq1j8eLFwQMPPLDC+/XYf//9g3PmzLHv23nnnaO+R4++ffuWW+f69euD5513XrB69erl3ufz+YL/+te/gqtWrapwLPfdd599z9lnnx3873//G6xbt25ouZNPPtm+5/nnn7c/Dxw4sMLyiR53PNurzHvvvWff265du+Dy5cuD1apVC+6yyy4V3qfj1fumT59uz5P+fdddd1V4n5tztmzZMnsuateuXeG4mzVrFhw/fnyl5/mpp54KNmjQoNxyW2yxRfCtt96q8vijnYvGjRtX+roeq1ev9nzc8d6zVd0z33//fXDXXXctt3xxcXHwsssuC9555532Z+1bOL2m52+//faox6rn9fpFF13k+VrF2vdEjh8AgHAtW7a03xevv/561BOz3Xbb2ddvvfXWct9Hig+ixViKVSNt2rQpOGjQoKjfU/oevOGGG0Lvbd26dcz4UusI9+677wbbtm1b4X367r788suDZWVl5d6/ZMkS+7qOWbFN+DEo7ovcB70/0h133BH1u7tRo0Y2joo0c+ZM+/ruu+8efPbZZ8vFlzq38ejUqVPoGile07/feOONcu9588037fNnnnlm8O2337b/7tChQ9T1vfbaa/ZvhchjUOx69dVXR13mhBNOqBCbOY/+/fsH165dW2EZJ0a68cYbg+eee26F5erVq2f3NVHffvttcMcdd6ywPsWKJ510UnDdunWh977yyisx76dY5ydSjRo17LmJNHz48NC6ImPlF154IWa8GY+99trLLv/RRx9FfV339h577FHhd1NKS0uD/fr1s68dc8wx9udwL774on3tyCOPdLVvAAA47UjdunWLejIee+wx+3rDhg1Dz6mdrHfv3lG/k/fZZ5/gwoULK6xHcULTpk2jLqPYyonVnP2J9QiP6RQnDB48OOj3+yu8b4cddgh+9913FfbDiWMfeOCB4FFHHVVumXvuuafcPkS2GcnPP/8c7NKlS9R90/r+/vvvCsuo3VevK35Uu074MhMmTKjyJnziiSfse3v06GHPrY63Z8+eFd6nNrCSkpLgH3/8Yc+pllGsEEltcWqTU7wVeQxax7x58yosM3ny5Kixuh7NmzcPTpkypcIyf/31V6g9cdq0aVFj1uOOO65CfFMVtQFfeuml9lgj17f11lvbdspo8Xe0R7TzE0ntznrvbbfdVu75BQsW2L9V9NoBBxxQIb5r3759sKioKDh//vxgoiZNmmTXe8QRR8R8j9OuqPO6YcOGCn9bKd7X3yuffvpphWUVO2vZaL8jQD4gYxg5TeVBnKxMUbaDRhgpS1IjqzQiSKPSNEJPmYXKBFFZjHvuuSe0jhNOOMGO7tdIKGWLaq5ilUTWiHuNCtPIOJU0U8ZGw4YN7Ugijc4Pz6jVSLvwTA6NltOyGmmkkYBt27a1I+s0evDpp5+2I7W0nmgj85RtoP1TVkKPHj1sRkBVo8PcHLeX7UVq1KiRzYJQmTZtTyMKRaMCJ02aZEeFVTbviNtzphGPGu2n7AuNntRIzXXr1tlrpuyOk046ye6bMjcivfPOOzbbXNdb11IZMLoPdO01MkzzWFeWBZQIjTATZZiEj9p0e9zx3rOVUfkc3ScaPaiRiRpdp4wijebUPDXKBkomL9cqUjKOHwCASMoe0Peu6DtJNAWGshiVzajvRmVJ6PtHcYTmkVMmrmKICy+8MLSecePG2XnNSkpK7Pe8vpOU8anR6srUUMbFZZddFprfV9t49dVXbfwVnnHhxFOibFdluGr+Y8UKGvGuOEXZBC+//LLNDNbcctFGtGs0veJYfd8rg0LLK+OhKoqTnAxTVffQFC6KXVR+b86cOWbAgAG2yooyAyLpu/3EE0+039GKq5Rh7SZbVtkcilNVNlrHH1lGWq+vXr065vLKuFCMqoxWXT9lbOvazp49257z0aNH2+vpXA/HK6+8YmNpXRPtu+I0VSrR+lRqPNr0IY477rjDxleKq5VVokwQZTPoOWW8qGpKvNVptIz2WbGh9vvYY4+1sbpifF13Zboo3lbGjuhe0z2gTBW9rowNZV5LvHGttqPt6vfBqeiiuFFlvZUlrvOt7J1wuued+zlRigeV2az7N1ZJSp1/ZQTrXKjc++mnnx76+09zPer8KnNeWcGRf185f4Moi0W/x5Vl+AAA4Ibaj8LjR8VrattQrKjvUsVhakdUnPn888/byjRqj5k5c2aoAou+XxUzKW5TzKLvNbVBqt3zm2++MZ9//rmNB9R258zvq4e+rxXPhM8x7KxT8Y/iAGVF6vtR/1asoG2pLVDxnNqC1I4XbX7WUaNG2WowqhSjdk9991Y176z2X9/XagPSfuiYVElG7TXKRFYboeLpWG2iij3Vftm7d2+bKa34tWPHjgldD2VZ6/wq7lY7qWI5Ufykc67qIpXFRTqninvVPqbrp/3V9dOxKRbUOhSLq+1J7WgOZVkrznOquuicKobSfihmV8ysTOJole6Uqau/A/T3g+JbxdDajjJxdc+ozXf48OFxnwPFZKqEJNofZXbruitm0rVRhq6qFTnt2Vq3zruq9Ch2VeUYZRhLPOffufcj4/LbbrvN/v2geyEyflRVIWWJq43PuUaJULugVHZPKnZWPK9j1d8Uzt9s+n3S9VBc6MTMkRRDOhWgEr0HgZyQ6Z5pwG3G8NKlS0Mj6U455RT73AUXXGB/3nLLLYNz584t936NanNGO3322WehEXz6uU6dOnZEWySNoPrqq68qjECLzOAId8stt9j3tGjRIvjFF19UGCnVsWNH+/ojjzxS7rXwEX/K2A0f/V9VBmWixx3v9uLNGA7PUDj//PND7/nPf/5jn3MyY2JlDLs9ZxoFqHOizJxIznF379693PPhx60sk/ARY7///nuwTZs29jVloyd6LnQfPfjgg/ahkZXXXHNNKANCI+A0ms3rcSd6z8a6ZzSqU89rdJ6yzcNHFV5yySWhc5SsjGE31yravid6/AAAxJMxrBHr+u5yvv9++OEH+9z2229vfz766KODmzdvLrfMFVdcYV9TRq2+nxy9evWyzytujKRM0w8//LDcc4qLYmVciDIEFG8574ncD1VlcbI8VVUjMmNYD8Uj4fsYLlrGsCqc1K9f3z5/4YUXVtgfZdTqtW222aZcBoOTMazHYYcdFlyzZk0wUeEZw6JsWR2fk12i/9esWdNmuUisjOGNGzeGrveVV15ZIdPi/ffftxkMun4rVqwo95oylKNlZij2UEaH4rrIZZwYKdq117lXpoheU3ZtvM444wy7zLbbbmurr4TT+XGyWJRBHS3eHTp0aNDt+f/zzz8rZIGMGjXK/v/ee+8Nvaa/L/TcwQcfHHV9iq91X8S6/xS3afmtttqqyn3r06ePfe9VV11lf3Z+Z5XBFS2L26H7R+/77bffqtwGAACJZAz/9NNPtpJKeFvhww8/bH/W98/nn39e4f1NmjSxr4dXLnnnnXfsc6rEpxgmktqMwr+bxanqokp00ag6oFOlLbKymrahSht6XW2K4cIr38TK1o2VMayYy2mf/OWXX8q9poxYJ4P1ySefjJoxrNcVoyUqPGNYVJVOPyuGiWw7femll+zPsTKGnbY6xciRmaxqO3X2NbLyjOKd8Pa1cMOGDQvFpNEyhp37Sz+Hc2IvVU6Jl+4xJ0PcyfB2KF7SdvSaMrMjOfF/5H7Ee/4vvvji0HOK/XSPHnTQQcG9997bZiqHcyoBRraHOvH+jz/+GLUN0eFUzYxWgTDcJ598EsrKXrlyZXD27Nn2d1B/B6gtO5bRo0fb5VQJCMhHdAwjJzqG1UDhdLipIUINVE7gpaBBX77idBSrjEs0TkOdSqGJGqvUoKJSH5Hl96KJp2PYabhTCZFoVDokWme3E1TpGCLLDVfVyZfocce7vUQ6htV4pgYvrc9psNQXvxrOnEaYWB3Dbs9ZeECrAPPpp5+2ga/TMasGUt0f4WW0neNWB3C0AEPl//T6kCFDEj4XsR4qQz516tQKy7k57kTv2arumVdffbXCMjov4Q3QyegYdnOtou17oscPAEA4p6NQpeFGjBhhH2qoCZ8yZMCAAfa9X3/9dahRL1qHkr7TnE7V8I5AlRqO1lkXS1Udwypzptf13Rc5NYjDKbms79ZoHcPqPI4lWsewGgH1nM5XtMGD6qR0GiP1vR6tY9hNSbhoHcNO45wGHIYPPFTMVlnH8Msvv2yfV8dyrJjBafh85plnKrymmEONRdq+GuWc+0WdtFpG1yVajKQO8Wg0eFKva+BgPLTPzt87EydOjPoep4NeJSKT1TGsgXrh108NiGo8U+Op8zsxduzY0Pv1+6LnIstkq9S4GuycaVsU80XjXL+ddtqpyn3TAFinM18Nj045x2glKcOpcVrvZfAgAMAN53tV5WideEDf+yrx6ww+0qA1Tf8gigX0nEr5RjNu3LhQW2dkDBWtsy6WqjqGVbI62oC1yFhRA/2ixUcq+xxLrI5hZ1oWtfNEc84550Sdks/pbFUChxuRHcOKXzWNh9N2pHZKtYOFt1nG6hh2kjRidRqqk93pxI/mm2++scd/7bXXBkeOHGnvF+ecRg6kC+8YVpwVLSnKmcImXk67psp5RxMer2sAXzI6htW2GBl7KuZ1YkT9TijBwzFr1iz7mjqHw91///02JtR71S6pUs+Kc6MNMHSun6aNqcqxxx4bipk1GFEd59GmxYmcUkfLKN4G8hGlpJETVGpDZcIiqWSHyprtsssutryKyl7IMcccE3U9Kt/y9ttv23IfopIkKk+iUnIq2XHqqafaEhMqO+KGytmqzJxKUWh/VOZOAzDE+b9TVkPHFI1KVYSXG66Km+P2sr1YVAJGJQNV5k3lQFSeRqU6VD6nRYsWKTtnN998sy0pp5IusajEnkrwhNN1VomWSCqvKJWtLxaVItQ5kI0bN5pvv/3WnnPtt44xvPy42+NOxj3r3DM6fpWPiaTndd3uvvtuk0xur1W4ZP/OAgAKk6ZriKSS0CeffHJo6g19j4vK2EWLZVRaTqXyVDZapekcgwcPtuWGVYJapZtVok+lmLfaaitX+6qywKLyw9dcc439d3jMoIdTwlDlzqJ9r6ukcSKcY1fsEq3sdNOmTW38rakvdOx77bVXuddV/s5NSbhoFFtdfvnlNlY644wz7P8Vd2oainjOm67T1VdfHfW8OaXDI8/bgw8+aEvwrVq1qtKpXKKJVopOnFilstLX4ZYsWRIquadyktGovPYzzzxT7v7zyikF6Bz7ww8/bEtX6vfCKZfo7JdKTqu8ocoQqsxkOP3tce6555rrr7++3LQ70WK/8LKXldG0LLoHVOZcf3PoZ5ViDy/jGI1KX+p8OtsCAMANxQ0qtRtJpYE1hVinTp3KxVHh02CEc57X1BYq96y4RvGm2uc0PZZK/6oErn7eaaedQlM7JErlcp2YSLFiZJuT/q92LJVbDp9CwpHoNHNqB/vxxx/LHWMkPa+2plixS6LbjEXxq2JxTf2haVzUDqV2sAsuuKBc2e1oU1zouoiW0zmMPG+aIkZteZHx46+//mqnDdH0FYnGjyrbvOOOO1Z4XuWoFctrv5x7pSpV3X+K4bXeZcuW2ffqfkt2/Lh+/Xpz11132WlCFCOq7X7NmjW2zLqOxylzrWl5HCo5ffbZZ9sy1prmRX/76Bxred2/Kj/uNobUtDsqGa39kPvvv99eq8o405YQPyJf0TGMnKCGNOcLTV+C+uNf865pfgznC8DpbNL8Zeo8isaZxyH8i/jxxx+3X0Sak0pzN4jm7FADjBozEmlIU2efEyyo0aIysb5YEm00dHvcbrdXGc2DoUYaNdg5c7zquVSdM23r0ksvtf9u166dDaJ0bzgdvrqmCkYUPEWK1fnoBIgK9BIVbb45zf2mRuGhQ4fagMiZL9DLcXu9Z517Ro3csYJKzQGcTF6uVaRk/s4CAAqTOoA195fTEKPvRHWChsdFTsNGZQPcNGda+HtFc5Jp/jENhlJn2p133hn6/hs4cKD9DktkUJ4Tv6nhxmnoiSVap6Pmyo2nESmc22MP7xhOFjVcaSCbBoVp7l9n4GFV23DOm+Z70yPe86Zr58Rm6tDUvGU6h2o4leeee842ZsaKFWM1TmngQSIxpnNeFS/FivEruwZuOTGyzonisltvvdUOnNQAVOc8OR3DathVA194o55DHcpS1T3boEGDhI7BuQ5OfKlrUxUnlna2BQCAG2oncZJW9L2u72h16Hbr1q1crFVVHOV8f6s9SJ1lWo+WV5KFBrOprcPpBFMHp2JLtadoO/HSnLXq7BUnFq2MvuPVruglnguPp2ItW1XskswYUu2RaqNTG6XTDlZVG2V4u+lNN91U6XudNixdO8V3Rx55pE0OUbyhzsw2bdrYGE6va65m/V0QKw7U+5xYMZLzvNMxnaw4Xh3DyYohw+NHJw5Uu6dz74UPLlSn+pNPPmkHPYR3Xut5DXjUoAiHBgFqXmA9NOjA+fst0RhSnc7qaNbvhH6P1EZbFeJH5Ds6hpETNOoussMtktNgoi97ZwRSJH3phb/X+fLSujWS6dNPP7Uj6TQqTF9G48ePt/8/7rjj4tpPJ6MiPHM0FjVCRhMrEEj2cbvdXlXXSZ1ykydPto12Ord9+/ZN2Tm77bbbQlkdp59+ernXFJzp+mWaslmmTp1qR6UpkHnnnXc8H7fXe1bBUHjndDROFnokBWqVBaQaxRhNMq9VMn9nAQCFSSPEo1XNiDZKXFmRlVXhkMiMRa1bDzVUfPHFF2bGjBk2s1IZv1OmTLGxQWXZCtH2Qx2UanCqjDKTY313J8LLsbvdZmXUiKeOYacxr6pGvfBj6N69e8yMiWjZKQ888ID9vxpgb7zxxgrvfeutt0w6hGcpqHE3Whxf2TVIRsOeMt+VRaQMXTVqap90bdVoqsZQnSsNQPUSdzkdu05nc2WUfawME3W+a//UMXzEEUdUuZzTyBtPJzIAALGo+sfIkSOrPEH6vtT3t+IoJ2ki2ve32uPCB5Qp6/KOO+4w48aNM3PnzrXZqu+++65t41AcpBjkwAMPjOsCqd1HsaY6xK688sqoFWAi3+81nnNiF1GljmgJB1XFLsmMIdUBqI5ExeDqENSAP3VGxnMM2o/Ro0dXObjSaVNVu5Q6hdWxresW2SmrTn+nKlGqeY3jkzWwUB3jTozodOIqJlN8qezyyIGFOtfhncIO53dk+fLl5TqG440hFy5caAdX6HdSg3NV8Uht1lVlpxM/It/RMYy8CtD0Aa/RdvqQV2m/SB988IH9/w477FDhNQVJPXr0sA+VjlMHnkZ4KRBwvsiqGumvoEdfduqkVekLfQlm+3EnmxrqzjnnHDsa7qyzzio3qj+Z50zBhgJNHbtKNkZSUKZAIxtoxKc6LBXQa9SnrlEy7pV47tlotG01LqqRURk0ymSOFKv0jdMoqXMfTbRy5am6Vm6PHwCAeDgNR8oOVeOJk+Hg0HeXyv2JskViNcyoPJseavxQ6bZPPvnENhg55ZedBqdYVTOczl5tL57GyGQeuzqw1QEY2ZioQYczZ86s9NiTSR3iymJRg1A8Aw/Dz5vi9kTO24IFC+z/+/fvX+E1bT9arJMKalBs0qSJLeOscsmaGiaSspuTfQ3CSwEqU0aNbk5HvNOArQY4VXDR+bjqqqviHuQQTfv27W3pSv3tEKsD3Cn5p4ZtlShXTK3fKd2fyiKvbMCEyn7qd0f3jyrMAACQjjhK3z+qcKYpRWJ9f3fs2DFqsoY6JdV+p4eSDfSdp0p0Ghwf3jFcWQypdagjVO0tijmrGlyYDPo+V4anyv/q2KNVx0tF7FIZnTcnDoxnYKHiHHU+KjtV127fffdNKH7UgMRomboaGJouThyva+BMQxNOMbyTQBStfLWX+FHtf6quM3/+fFtZxrlHnQ5oxXv33Xefbcs+4YQT4p4CSG3LkW3a2nfdT86UOrGSXtQprN9HJazo9+3888+3bYhqQ6+MUxY9WecIyDbJSxUEMkxfNs6IcY3wVyNWOGVqqAFD+vXrZ/+vxoxYXyDOaCbNERE5SskZWRVtHwYMGGD/rblP1VkbjToDf/jhh4SPMVnHneoMHHX+6TFs2LAq3+/2nCmLVo1Qen/kvB5qrNK8FNlCDck6Nhk7dqyn4070nq3qnlEjtTLNw6mky/Tp02M23snEiRMrdOaqY3bChAkVlknmtUrG8QMAEA81AqjBbsOGDWb48OEVvi/VIaYR6Br41Lt379DzkyZNijp9h2I0p7KGOvsiv79+/vnnqPuhRimV8v3666/tvGjan0jKBlHDSKx5yxKlBhR1wCrTQAPYwiuFaFuaukHHovLYsebUTXZD43/+8x9z7bXX2izVqgYeyuGHH24b5tQRr2NwyimG03Oab0wdkg6njKI6Y8Opo1QxW7xzBCeDM9BN86w5DXgOZQ4pA0bibVhLJOND69Y9p3s/fGCAGvYUjymjSe+NrASTKMWJqjikRm1l18dqEFS8qI5dNaxqQKXT0KlzU9lUJKou4zTUJjuTHQCAaDS3rahjzJnn16H2HWee4vDvb029EPleh753I+PHeGJIp+z1mWeeGXNOX3VoRs7dmoxjHzNmjK06EpmAoCpyyY5dKqO2ScWPelRVrS/yvKkjOVbbrdqlwjsWnfhRbbBO2WqHBrGpUz9dNP2H2v00KCAyS1ntck4bnBIrNAgxGVS9UoP7nIGFWu9pp50Wet3pGNbvhGLaquZ6dqgMuAYEKh6NzG52Ou2dWC+SMoRVNUjXUIMDtE0lMGmQof4+ULtmZZz1xjs4AMg1ZAwjryjw0Beuvvw0Qkoj6/RlpABIXyZqNNBIO6dTTKN/VDpCDVoaQadMSjU0zZs3z3aOSfjoPmd+WAVN5513nh2tpC8yfanoC9XJDlXDnEawawSUgiI1mqnRQx1Wc+bMMW+//ba5/PLL7f5m4rhTSaPEqir7HcnNOVPQ4czhpzkBFXCoA1YBseZjUTCi5aM1nmaC9l3lpNV56pQscXPcid6zsSirVg3XCrCUUaMOfWU1ad9UpkgBV7R5sFUWU69pe2rEUzCv/VVDnsrB6LXIRulkXqtkHT8AAPHQvFiaw14NByoFqLlt1UmpWNDJmFV52/C5SzUCXaPS9X2lDqymTZuGsj41uFANR+ENDE7Hqkb1q3yashTUmKOKHsoSVaz52GOP2VhTpQX1fafvOn2XqnNW21IjlLah70mnY88LNeyoUUcNYyrd62RoKqZ0Ruark03nJ5nTklTVyJUIxRaKg9Vpr/meNdeZqrbovKlRTOdNA+E0SE2VTZxMVV0DdT4qO1Vxm+J/NWDp3/q/lo81SDTZRo0aZe89nW/df0cddZS9nxTj635Rh73OS7xlJePh3D8a7KdzEjnQU7Hed999Z7etDvdYGb6JUJyoBjo1sCpWjCy9qGwfbVe/Q4qVRY27KiWtc6G/PWLNFaf1OtsAACAdBg4caAey6Xttn332sdm62267rY091A6jwYLKrFW7okMxieIufc8p9lBbh75r1WHsVKiJTPZQDKlBiooXFe9osKKoDUn/VtuLtqfvUrUVKv5UPKG2Hw3+U9yotpyTTz45avVBNy666CIbq6q9R4Mstc8aqKfOObVbOu2T6arypkFliVbc0XXRADxVX1S7r86N4nPFPIoBlfCgCjJ6nzPvs/6vbel6aJk+ffrYtioNstN6ttpqq7QlMejvD/09oilRVNFRbXxqP9PgRg2IVNyrQX8q95xMiiHVNqf7Vu2dkQMLRXGt/m6KZ2ChYjh15Hbt2tV27EdSzKhzrL+DnLmeHfobSW3guk7qCHeW199xGlyoe16/J/rdjDYlozKNFX/rukUrBw/khSCQxW6++WalJwQPOeSQuJd5//33g1tuuaVdLvKh9axYsSL03h9//DG43XbbRX2vHvvuu29wyZIl5dZ/0kknVXhf3759y71n0aJFwQMPPDDmehs2bBh86qmnyi1z33332dfOPvvsmMf2/PPP2/cMHDjQ03HHu73KvPfee3b5du3axb2MzpOWueuuuyq85uaczZs3L9i6desK761Xr17wxRdfDDZr1sz+/Mcff8R93FpOrx9zzDEJn4vGjRtX+r5TTz3Vvu/www93fdyJ3rOV3TOvvPKKPVeR6+jZs2fwhhtusP8+77zzKiw3YcKEYLVq1Sosd9RRR4WWu+iiizxfq2j77uZ3FgAAR8uWLe33xeuvvx73SXn55Zejxlh169YN3nnnnRXef8kllwQbNWoU9Xtql112Cc6YMaPCMmeddVaF9w4aNKjcez777LPgbrvtFnW9JSUlNr5Yvnx56P36PtRrOubKON/P0b4/77///mD9+vUrbK9p06bBF154ocL7Z86caV/ffffdg2516tQpoWv09ttv2/d36NAh6usfffRRsHPnzlHPW/Xq1YN9+vQJrl69OvT+QCAQPO200yq8t2bNmsEHHngg2L9/f/uz4pRwl112mX1ef79Ec/vtt0eNkaoyd+7cqNfd7/cHTz/99OCGDRsqLOPEu0OHDg0m6rXXXgttI1oc2L17d/tajRo1gkuXLq1yfbNmzbLvf/DBB2O+55dffrHHs/POO5d7furUqfa816pVK/jJJ59UWO7VV1+161YcGX4NHWVlZcFWrVrZfY38WwgAgHg536vdunWLe5m///47ePTRR0eNP/bff//g4sWLy71/+vTpwT333DPq++vUqRO8/PLLg6WlpRXirmgxZ3hMt3HjxuCll15qv0+jrbtNmzbBxx57rNx6FYPqtSeeeKLKcxItVli4cKFtm4m2PcVRq1atqrCM2i31uuI6N7SvWr5Hjx5xL6N4VcuoTSrSunXrguecc46NFaMdR/v27SvEwoo5mzRpEvV6v/XWW1Fj5L/++qvK9kRnHzZv3hz3sSkGuuqqq6Luv9pxta/ROHG/9itRO+20k11Wcduff/4ZNWbTQ/dyVWbPnm3v7Y4dO5b7+ybSgAEDKvzdsGnTpuBhhx0Wak/UuQinWN/Z12jt06Ln9fqoUaPiOHIgN5ExjKymEW0q+5FIPX/NN6pRPRoFpZFvKg3XrFkzO0pcI/XCacSeRq1pnlWN5FOZE41sUiaA1qOMyEjK2NCcY3q/yrloVJLm7QinEUXKNNB6lV2gUYEauaTnO3XqZEf1R45I0ogyHWvkPkaO+tJ7lIHi5bjj3V5lttxyS7u8shbipX1RJrPOQSQ350xlFTV6UuXlvvnmG5tRo1LHypzQfn344Yc261UZI/Eet7K/9Xq0a1/VuXBKjceirApl1SjDRqVlNEou0eNO9J6t7J7R6DmtS6MHNVJUI0o1ylEjTZXFHGs5jUadO3euzRDWaEgdh/ZTDx2LltOIPq/XKtq+u/mdBQDAoWk3VKnCmRohHhpJrhhGWcL6/lPsp3hB33vhmcIOZdqqRKAyPxSbKV5UTKYYJNb31L333mvnYdMyqryhbTiVahxaVjGevkdV2kyZrhqZr6oj+t6NzBRWXKLR8coKqYwyChSXRItjlIWpqiKKUTRXmGIYnTtlLEfOO+zERNpmtLnV4qVScRqlH+81UmygbcYqhafYRudMGd4q0ajzqwo3Om/KnogsS6dYTVVetB/K8NDUGXqvMsd1jrUd/W0S+feJStUpllLJ4mgUe2o/o8VWlVFGkfZb11zXX9nOup+UbaNsomi6dOlit+XMs5wIHZeTVeFMhRJOGcQ6VmU0aT+SoXXr1rYqjTKalI2sGFhzQyvLRpnbytSJdt4Us6qktX6ndX9Gzleo66fYWtnFycikBwAUJud7Ndb3bjSKL1R9Q+0Xau9QZRc9p++zyBhPFMvpu15tHGrvUFuLshsVg6itI1o8t8suu9jM3LfeesuWhHaqsIXHdFqHMkevuOIK+72o9+s7Vm0oirUi2zNF7TSKr7T+qs5JZNuPaJ+1LcVeyuZUW88WW2xhMzy13mhUHUQxVKzXq6J91f4opoiXYhplTmvqmEiKc1X+WdX71D6m86s4WOdNGaTR5khWzKnzO3nyZPt+XTNldSuGV9WZaDGytqPna9WqFXM/tQ+ayiU8I7Yq2ldlxmr6F6etUdm1ivN0HWKVcVZ2te6jaHF+VS688EK7HcWuTmntaPGlU6o7Fq1DsabOn6ooOvMXR6My6apEqCx1xZKiLGHF3aq2pHg+cioRxfqqNqNKNNGyhUXr0/vUJgnkK596hzO9EwAAAAAAIL9oYKAaTzWnYGVlAzWdiRrxNEBC80kng8qCq4SmOpijDUwFAABA9tDAVw0Q0EBOzUntTCFSGQ0g1AAEdcprkKpXGpCpDn3NMf3II494Xh+QrdIzIRQAAAAAACgIypZXxobm4XOyP/SzsrejUQaVOnLVAKcsm2R0SGseO82vSKcwAABAdtu8ebOtbKiKhjfffLOdE1mxo/NQ5nk0t9xyi63wc8MNNyRlP5z5kaPNawzkEzKGAQAAAABA0ig7WBkXkVTGUFkd0ah85vjx422pcrfT3Tjeffdd88knn9j9aN68uad1AQAAILU0/Y6m6onl9ttvt1OpRPPwww/bLOOLLrrI0z6sX7/e3HbbbXYKIE2jB+SzrOsY1qgQzbE1a9YsO2eX5g066aSTYta+F40gUe13zXep+b4qS/PftGmTnR92yZIl5pVXXrFzHDg0b5jWo9IDmg9Bf0TGmiMKAAAA2UFzLj3++OPm9ddftyOJNU/UOeecU+UcVZ999pm57777zOzZs824cePsfKOxPP/88+bWW2+1fyBqnlqH/gBV2VPNe675i9SZoW1rrlEAAABkL8WA999/v53fXHNi9unTxwwYMMDOLRmLYk3FnS+88IKtSKA2zFjWrVtnjjvuONvhMWXKlHLxoebOfPrpp22VBLVlaq5MlS8FAAAoqFLSKjP1r3/9yzbijRgxwk40ftlll9mJwivr6NWk5l9++aWpW7eu7VCuzCWXXGLLWmmUssoMOO655x5bKqBr167myiuvtEGZatSrERAAAADZa8iQIWbmzJnmxBNPNBdeeKFZvHixbVjTYL9YVBrqrLPOsg16igv//vvvmO/VerReDSyMXOcee+xhVq1aZRvzNA+RGvg00lkxKgAAALKT2hFVbl6ZYSNHjrSZaGp/vPzyyyvtFNb7586da2rUqGE7litz7rnnmoULF9pYUwMZHTfeeKMtf7rvvvvaNsimTZvaAYqvvfZaUo8RAAAg6zOG1VFbUlJSbmSeasorYPrzzz+jLqPdX7Nmje0UPv/88+3E5NFKVokyhNXRrJrzffv2tfMcbbXVVvY1rSMys+Pkk0+2ncgqQQUAAIDspGyMWrVqhX4OBAI2NlQZKHXYxmrYq1+/vo0xVUFG2caHHnpo1LmOunXrZhv2NJBwl112sZkljsgY8ocffrCDFt955x1bDhUAAADZRyVD1bmrii+O0aNHm8cee8yWto9Gnbtqu6xdu7atMqg2Q1UfjOaZZ56x7ZlXXHGFrVyoKjOqjBirDVJVafT8W2+9ldTjBAAAyOqMYc03FN4prIBr2rRpZuedd465jAI4NfxV5bfffjNDhw61cxaFNxw6opX703NkewAAAGS3yNhOJaI3bNhgdtppp5jLqFM4HmrMa9u2rZ3aJJrIGNL5mRgSAAAge9WsWbNcp7Bit+nTp1faBqlp7tQpXBVVmFHyiqarq1atWoXXaYMEAACZFHvi3gxS6RYFY/Pnzze77767nbfDi7KyMjNw4EBz3nnnmd12283O61EVzfGhAE6lp2PRKMHwctTazooVK+y8JOHBJQAAuUhVOVavXm1atGhR6TxbyaKOvFR1pqlBRhkByO9ygMOGDbP3rEpJazoQzffrxRtvvGHX8/XXX8e9zL///W/TpEkTm2UcCzEkACBfpTt+FGJIeKHMX8V66sxVaecnnnjC0/pUbUbT5F111VWmY8eOtppMVfQetX1ed911Md9D/AgAyGe0QaZXVnYMa7634447znz77bd23l81sGnuDbeuueYa21FbWSdvOM0x16dPH5tlotLTsVx//fV2/wAAyGfhUy+kskGvZt1GxpSuT8n6mzdvbgec0Tmcv7bddlszbtw4s3z5cvPoo4/agYYq+9yuXTtX69N8wqeeeqqdM9gp+1eVBx54wD5efvnlSivaEEMCAPJdOuJHJ4Zs06aNWbp0aUrWTwyZ/y644AKb5PHVV1/ZNr5bb73VjBkzxvX6VG1GgwTPPvvsuN7/xx9/2DbI7t2726lLYiF+BAAUgnS1QbYp8Pgxq+YYjmbChAm2k1g3RMuWLSt9b6w5hnWRNXdxo0aN7M+rVq0yc+bMMbvuuqudR1jLhc83d/DBB9uOZM3rUa9evbhH62nZrbfe2sx77g5Tt1bNhI/1l6cmGjeadelo3KrWIL4yitH82u00V8vVr17kepslfneZ2G/8tML1NmctXuVqueb1q7veZv8dm7tetlqRu3O0KeD+o6BmibuR4Gs3lbnepstbwdM5qlXk/hz5ykrdLbdpnettFq2JPjd7XFyO7i8rSfyzL6SoxN02q1Vdyismv8vPIy9fnV4qSrjcrq8s4Go5ZXu07bSzHTAVb9ldt/TdrG0Udzze9b0QU2CzKZ39nP2erux7HflD4e2OO+5oevbsaecFrkysOYYfeugh27ncuXPn0HPfffedLVut2PK9996zJQgdmo9uyJAhNstE88hVJlYMebhiHZM+m036efmzqK3L5f75C8AdtxFZEw/b7OHl43Zfl8tt6WGb27lcbqsMXBgvN6CXi1ovA/vrc5upmanGi8Yul6s4TVT86ufYOcrKcf0VrFpValq1+iAt8WN4DKk2o2THeVp3q1atiCELiOK5wYMH287ahg0bVvreWHMMK65Ux7Bz/2tuYWUE77HHHnYZTXPn0IDGAw44wG7rtddeizr1XVXxY480fzr85WHZDS6XW+Jhm+mMrR1rTG7x8snpvoU3t7bphT+HvvWLCui6BApkm7lEvQQ//y9pM11tkIsKOH7M+r8sttxyS9u4p9F7VXUMxzJx4sRywZPmnVNDn0YChs89p4t2yCGH2O1V1SnszImsRyR1CternfgfqHWquQtX6tV03wFZrZb7P2rr1HV3Y9etkf6O4Zp13Dd9Vq/lrvOyRm3357auhw+N6i47PTd66Biu5bJj2J+hjuHqOdUx7P73pci3IQMdw7XS3zFcveIc8XErmI5hd/dfaPk0To/gK6lhfEUV5+HyIuj2OiNn6Z5t1qyZ7fR1S5kbnTp1KvecGvPat29vLr300nIxoDqDzzjjDPP4449X2SlcWQxZkqHGq3TycnzVM9CF4/ZbzcOQJVPPl4ET7OVjt2YG+vPqZOBmiF0EIEs7ht3eSL4cazYtykBzSKaaUbK++aacdE+vVa9eLftILm8xNHKP2iADgYBtlK6qY7iyqUhUTtrxwQcf2GqEyvjdfvvty3UKH3jggbYyzeTJkyvtFK4sfixO86dDJjqOvHyapKegfXm5NrmgP8fObya2mWsRjluF1DGM7JXOGLJeAcePWfWXxaRJk0zr1q1tJq+TqXTTTTfZ5zQvh6xZs8YcdNBBdq6O3r17x7VeZ30OrcN53klL17acTuG33347LSNbAQAA4I0a726++WZz4YUX2rmknQa5jz/+2PznP/8JvU9lAadPn27nDI6Hsj30CFenTh3TtGlTs9dee4Wee/LJJ22HsTJMTjjhBC4nAABADnjuuefsIEBnIKA6gxUvqvN2m222sc8pc/jII4+0nbr7779/XOvdfffdy/3slKlUxrAzPYmyiHv16mXbHpUpXLu2lyFlAAAAOdwxrDngzjnnHFuKpXHjxubnn382e+65px05V1T0z7iT0tJSM2PGDBucOQYOHGjmzZtnFixYYDt4nca6yBJ/lVGDohoL1QGtDmKH5odTRzEAAEg9n7/IPpIqyNjVfKYYUfPDaLCfsoRVAUaDAK+55hpzyimnhN6n+V1mzpwZ+nnKlClm5MiRNrZ05pfTfHKaZmTYsGFxbXv9+vVm0KBBtsNY8xvr4bj44ovNsccem9RjBQAAsZSmIEMjNzI+4L4NUoP7VEZSU8+pXVHz/L788suhbCVVH1QbpLJ7Hf369TNLliyxbZaKQZ02SLUpxuvaa6+1cammLFHWsEMDELV9AACQDqUFGz9mVcewAqKpU6faTl+NqFMDX2TpFnXUTps2zQZwDpVkWbeu4jyc0UqsSJcuXew6FHA5NCfc4YdrZrfyiouz6hQBAJDX6BiGG+rQHTFihPnxxx/toEDN5xIZw6mjVo1/DlWOCe/IdVQ2dYnmHQ4v86dY86OPPor6Xs1DDAAA0qVwG/bgjjJ71Ta4bNky8/vvv9v40cnodajdUO/RVCKOUaNGlZuurio9evSw61B7pkPT2x1//PFxt2MCAIBUKC3Y+DErez2jle4LzwoJL98n4fMEx0NzB0euQwGgHgAAAMg9JSUloalHonFKAjpUnUaPRETOOez3+yvElAAAAMgdqjijRzSapiQy1oucrq4qSniJXIfi0sjYFAAAoKA7hgEAQGHy+VJQSrqMUtIAAAD5rXAzPgAAAOBGacHGj/5M7wAAAAAAAAAAAAAAILXIGAYAAFnDV+Q3vqIkZ/gGGQcHAACQ3wIpyNDQOgEAAJCfAgUbP9JSCgAAAAAAAAAAAAB5joxhAACQNfz+5M8xHEz2nMUAAADIMoU7RxwAAADcKC3Y+JGMYQAAAAAAAAAAAADIc2QMAwCArOFLQcawIWMYAAAgzxVuxgcAAADcKC3Y+JGOYQAAkDXoGAYAAEDiCrdhDwAAAG6UFmz8SMdwCvg7dDX+unUTXq7VQfNcba+ofmOTCc1ru7t9ahT5XG/TV7rR1XJ7tKjvepvN61R3tVyJh+OsW819lfdil5v1sr8lLhcNuN1Zj9weqy8YMGnnd/8xHaxWy/2yPpf3YFGJ+20WFac/G9TtcZoy99sEAAAAAAAAACADmGMYAABkDZ/fn5IHAAAA8lkgRY/4rVmzxjzwwAPmgAMOMCeffHJcy2zcuNHccMMN5qCDDjK9e/c2jz76qMvjBwAAQK7Fj/L555+b008/3ey1117m448/NvGYPn26GTBggOnZs6c566yzzMKFC00iaCkFAAAAAAAAXAoEAqZ9+/bms88+M/Xq1TPffPNNXMupQe+hhx4yZ555punXr58ZPny4GTt2LNcBAACgANxwww1m6NChpmPHjmbGjBnmr7/+qnIZva9Hjx6mZcuW5tJLLzWLFy82++yzj1m+fHnc26WUNAAAyBrMMQwAAIDEBVIwp1v8GR9FRUVm7ty5tlP44osvNr/88ktc2SETJ04006ZNsxkismHDBtvAd95555m6LqYoAwAAQG7Ej6Js38svv9z8/fff5qKLLjLxGDVqlOnVq5e5+eab7c+qPNOqVStz9913m9GjR8e1DjKGAQAAAAAAAA/UKZyIKVOmmCZNmoQ6haVv375m/fr15pNPPuFaAAAA5Ln69esn9P7S0lIzdepUc+SRR4aeq1atmjn00ENtbBkvMoYBAEDW+GdO4KLkrpQ5hgEAAPJcaQoyPv5Z36pVq8o9W716dfvwasGCBaZFixblnttyyy2Nz+ezrwEAACCVSnMufly2bJnZuHFjhRhSP7/33ntxr4eMYQAAAAAAACAKleZTNofzuP7665NynjZv3lyhgbC4uNg+9BoAAAByU6sUxo8SGUPWrFkzofiRjGEAAJA1fL6i5GcM+5K8PgAAABRMxseiRYvKlYlORraHNGrUyKxYsaLcc6tXr7aNeo0bN07KNgAAAJBf8aNExpDLly9PKH4kYxgAAGSPoiLjS/JD6wQAAEAhNOwl+/HP3MHhj2Q17O22227ml19+MX/++WfouRkzZtj/77rrrknZBgAAAPInfqxXr55p166d+eyzz8o9rxgykfiRjmEAAAAAAAAghdavX2/22msv8/LLL9ufjzjiCJvZMXbsWPuzMoVVZrBbt26mQ4cOXAsAAACYcePGmX79+oXOxODBg80TTzxh5s+fb39+4403zKeffmqfjxelpAEAQNZQGelkl5JOemlqAAAAZJlACkoBap3xO/nkk80PP/xgFi5caFauXGk7gWXKlCmmTp06JhAI2GyO33//3T6v5yZMmGD69+9vXnjhBbNu3To7H91LL72U5OMAAABANsaP7733nrniiitsnCgXX3yxHTQ4cOBAc+6559rnVGFm5syZoWUuueQSM3fuXLPDDjuY1q1b29jzpptuMj179ox7u3QMAwAAAAAAAB6okW7t2rUVnq9Zs6b9f61atcy0adNs+T9H9+7dzYIFC8ycOXNsicH27dtzDQAAAArEzjvvbDOCI7Vo0SL07wsuuMAMGjQo9HNxcbF57LHHzI033miWLFli2rZta+rXr5/QdukYBgAAWYOMYQAAACTu/+d0S57E1te5c+dKX/f7/aEs4nBq3KtqWQAAAORf/NioUaOo8WE4ZQXrEal58+b24QZzDAMAAAAAAAAAAABAniNjGAAAZA2/v8g+krtS5hgGAADIb5nP+AAAAEAuKS3Y+JGMYQAAAAAAAAAAAADIc2QMp8DKGk1NWc16CS/XaOdurrZXtn6tq+Xssqv/dr1szeAmV8v5Nrpbzi67eYOr5ZrWbuJ6m7VKarpaLhB0vUlTEvQwsqR0s7ttujxO8QXcXdNqRdVcb9PD6TVFPl/6N+pzNw4n6Hf/MR0sru5+WZf7a4qrpf0cuV7Ow3G6vIP+t9EyL0vnPZ/fb+cZTvY6AQAAkM8KN+MDAAAAbpQWbPxIxzAAAMga6hROfscwpaQBAADyW+E27AEAAMCN0oKNH0mhAQAAAAAAAAAAAIA8R8YwAADIGmQMAwAAIHGBFGRoaJ0AAADIT4GCjR/JGAYAAAAAAAAAAACAPEfGMAAAyBpkDAMAACBxhTtHHAAAANwoLdj4kYxhAAAAAAAAAAAAAMhzZAwDAICs4fMV2azhZK8TAAAA+axwMz4AAADgRmnBxo9kDAMAAAAAAAAAAABAniNjGAAAZA1fUZF9JHudAAAAyGeFm/EBAAAAN0oLNn6kYxgAAGQNn9+f/FLS/sQLpHzwwQdm6tSpJhAImC5dupjDDz88qfsEAACAZCrchj0AAAC4UVqw8SMdwwAAAGEOOugg2yG877772p8HDx5sunbtaiZOnGj8LjqZAQAAAAAAACAb0DEMAACyhrKFk58xnNj6brvtNrPTTjuFfj7++ONN586dzdtvv20OOeSQpO4bAAAAkiGQggwNrRMAAAD5KVCw8SNpLwAAAGHCO4WlQ4cOpqioyCxdupTzBAAAAAAAACBnkTEMAAAKImN41apV5Z6vXr26fVTl8ccft//v3r17UvcLAAAAyczOCBRkxgcAAADcCBRs/EjHcAosWLnR1CnbmPBy9Vvs4Gp7Rat+N275iqu5XrasdIO7BYNlrrdpAptdLVa3xOd6k9WK3P2abAoEXW/TBDa4v6ZlLssfBDa53qYJujvWIr8v3Zu0fC43G/Slv8iCr6jE9bLBkhoeNuzuWIP+4rRfGE/Xxe1xut+icX/XS1laz1HQ7S9LlmrVqlW5n0ePHm3GjBlT6TJffvmlOe+888zIkSNNu3btUryHAAAAAJCfcqOpPHf3FwCAeNExDAAAsobf77OP5K70n/UtWrTI1KtXL/R0VdnCs2bNsnMKn3zyyVV2IAMAACCTSlMwR1yy1wcAAIDsUVqw8SMdwwAAoCCoUzi8Y7gy3377rTnwwAPNMcccY+65556U7xsAAAAAAAAApBodwwAAIGv4/D77SPY6E/Hdd9+ZAw44wHYK33vvvcaXZyW1AQAA8k/hZnwAAADAjdKCjR/pGAYAAFlDnbDJ7ohNdH0HH3yw2bBhg/H7/ebcc88NPX/kkUfa0tIAAADIxtlAk90QxwyjAAAA+StQsPEjHcMAAABhRowYYcrKyiqck8aNG3OeAAAAAAAAAOQsOoYBAEDWUNlnf5JLSQcTXN+wYcOSun0AAACkWuGWAgQAAIAbpQUbP/ozvQMAAAAAAAAAAAAAgNQiYxgAAGTXHMNJzhhO9pzFAAAAyDaFm/EBAAAAN0oLNn4kYxgAAAAAAAAAAAAA8hwZwwAAIGsoWzjpGcNJXh8AAACyTeFmfAAAAMCN0oKNH8kYBgAAAAAAAAAAAIA8R8YwAADIGn6fzz6SKcgcwwAAAHmucDM+AAAA4EZpwcaPdAwDAICsQSlpAAAAJC6QgoY4rRMAAAD5KVCw8SOlpAEAAAAAAAAAAAAgz5ExDAAAsgYZwwAAAEicsj2KCrIUIAAAANwoLdj4kY7hFPh22WpTc23iy7Xu0MTV9hrUKTNuFZe5v1HLAi6XLUr/befbvN71sjWKSlwt5y8uzvfPj5wVDLpc0J/sL4o4BD0Udiiu7n5Zn7vtBl0u50UwA9fF56HgRtDTdt0u6HKrGbieAJAPPH0z+TOw4aICqV2Vqa81t+fX5+XCuP1bxMvfal7+iCnKwP5m4hwVQvONl2gXQD7LRLgBAABy9y8LAABQAPx+n30kUzDJ6wMAAEC2KdyMDwAAALhRWrDxI6lAAAAAAAAAAAAAAJDnyBgGAABZQ9Wrk13BmorYAAAA+a5wMz4AAADgRmnBxo9kDAMAAAAAAAAAAABAniNjGAAAZA2fz2cfyV4nAAAA8lkgBRkaWicAAADyU6Bg40cyhgEAAAAAAAAAAAAgz5ExDAAAsobfr0dyM3yDDIMDAADIc8r28BfkHHEAAABwo7Rg40c6hgEAQNbw+X32kex1AgAAIJ8VbsMeAAAA3Cgt2PiRHBoAAAAAAAAAAAAAyHNkDAMAgKzh86UgY9hHxjAAAEB+K9yMDwAAALhRWrDxIxnDAAAAAAAAAAAAAJDnyBgGAABZw+/z2UcyBckYBgAAyHOB/z2SvU4AAADkp0DBxo9kDAMAAAAAAAAAAABAniNjGAAAZA9/8ucY1joBAACQzwIpmNMtNzI+AAAA4EagYONHOoZT4KN5f5pqNTckvNyOzeq62l6nLRobt3xlHm784mquFgsWV3e/zWCZSbsyd7/MRcUl7rfpc5/MH/QXp32bJgN9LmXBYNq36fdwoG7310tJXX+Ru9/RXCu9m4FbwRgP58fnoViH20P1+Vx+dubQfQDkg6L/PdIlkGPlityeGw8RmetlvWzT003gz8A2M3GS3C7rPjTKzP56+nO9RpqXMx4bVTKxvzUycF0ytWw6pfObDABQaNyGu2U59jdMrslEWdqyDFyX3OjyA/LnLwsAAFAAfCnIGE56BjIAAACyjAYmJDvmS3YGCQAAALJHacHGj3QMAwCArOH3++wj2esEAABAPivchj0AAAC4UVqw8WMmsvwBAAAAAAAAAAAAAGlExjAAAMgaPp/PPpK9TgAAAOSzws34AAAAgBulBRs/kjEMAAAAAAAAAAAAAHmOjGEAAJA1fP5/HsleJwAAAPJZ4WZ8AAAAwI3Sgo0faSoFAAAAAAAAAAAAgDxHxjAAAMgafr/PPpK9TgAAAOSzQAoyPrROAAAA5KdAwcaPZAwDAAAAAAAAAAAAQJ7Lyozh1atXm9dee83Url3bHHHEEXEtM2fOHDN79mxTrVo1s9tuu5mWLVsm9J7S0lIzfvz4Cst0797dbLvtth6PCAAAxMPn99lHMiV7fchen376qY31evXqFTUWjLR27VrzySefmBUrVphWrVqZvfbay/j9/oTe42wzXL169czRRx+dxCMDAADpn88tN+aIgzd///23ef31103Dhg3NoYceGtcy3377rZk7d66pUaOG2WOPPUzz5s0Tes/69evNs88+W2GZ/fff37Ru3drjEQEAgPiUFmz8mFUdw4FAwJxzzjlm0qRJpnr16qZJkyZVdgyXlZWZk046ybzyyiu2EXDNmjXmgw8+MNdcc4255JJL4n7Phg0bzKmnnmoOP/xws8UWW4TWr05hOoYBAEgPn89nH8leJ/LblClTzGWXXWY2bdpkG+HUuFdVx/DUqVNt522bNm1Mu3btzPTp003dunXNO++8Y5o1axb3e5566ikzYcIEc+CBB4bWrdfoGAYAIJ0Kt2EP7mzcuNGcffbZNjGluLjYtG3btsqO4c2bN5vjjz/evP/++zb2U6fyxx9/bG655Ra7rnjfs3LlStsG2bdvX9OgQYPQ+nfccUc6hgEASJvSHFlnnncMB4NBs9NOO5mbbrrJXHXVVeajjz6qcpn33nvPNsh9+eWXZtddd7XP3XPPPWb48OHmzDPPtI138bzHoe0qEwQAAAC5QZVfHnjgAduQFj7ArzKXX3656dmzp+3UdTKDO3ToYMaNG2euv/76uN8jO++8s3n00UdTcmwAAABIPnXgqv3vjjvuMOedd5756aefqlxGnchKZvn+++9N+/bt7XM33nijueiii8yQIUNshcJ43uMYO3as7QwGAAAo2I5hjdA766yzEs4ylhYtWoSeU4aISvypkTDe9ziUCbJgwQKbFaJy05HlBAEAQOr4/T77SPY6kd+c7I4///wz7mUUH4bHhprCRCUEVWkmkffIX3/9ZZ577jlbQlrxY9OmTT0eEQAASEzhZnzAnTp16pjTTz89oWUUG6qdMLwstFOlxokP43mPQwkxmpJElQqVyEKlIwAA0qk0R9aZ5x3Dbqg0tAK5o446ygwcONBmcjzyyCN2xJ8a7uJ9jygAe+aZZ8yWW25p55JT1skLL7xgtt5665hlZ/RwrFq1Kg1HDAAAAK+U9Tto0CBz6aWX2tKBqjCjUn7K5kjkPTJv3jzz9NNPm2XLlpmvvvrKZoWce+65MbdNDAkAAJB7VPp5wIABdtq7/v3725LQqhpz//3327mE432PqPN4/Pjxdho9dRBvv/32tg0y2nzFQvwIAACSJec7htWZq+BJc8tpvjd1+uq58M7ceN5TUlJiPvzwQ9OtW7dQJ69KB6rMy5tvvhl12yohePXVV1d4/s9Vm0zx5v/vMI7X72s3GTe2aVDduFW9eh3XywZ97rKpg0X/XzYnUT5/4ufVK1+Zu1Eenqa09Be5X7b8ANS0cH0vBJO+K/Ft1+VygQzssJdteroVMnVxcoTfePgF9/Dh4HN7WVz+jrpezuscw0nO8GXkPaJRyelWrVqZt99+22y33Xbmiy++MAcccIDNCk7kPZpDTh3B1av/E49p8KEGJHbp0sV07do1oRhSkWA6P303u1zOQ5Ti6bspkOblvJwjt8t53uGyDGwzkIGTlImbIRPXpcjLaPMNJreUZuA4c2M0f+7J1HkN5Mg6kcvUmav2RbUfqn1R8werNPRWW22V0Htq1aplZsyYYfbYYw/784oVK0z37t3tHMTOFCbxxo9+j7FZojJRV9HL8RVKHUh/hs5vOu89rwrlXvByXXLpenq9phloPs+581sYAjmyzuTL+c9Ele278sor7RweL774onnrrbfMyJEjzdFHH23mz58f93vUmOd0CotKAWqOEQVx4VnB4a644go78s95LFq0KE1HDQAAAC+UxbHNNtuYmTNn2ljx22+/tRVjLr744oTes88++4Q6heXUU0+15adff/31mNsmhgQAAMg9GgB43XXXmXfffddMnDjR/l9VYvr06WOWLFkS93vU5uh0CkujRo1sp/Abb7xRody0g/gRAAAkS853DH/88cemffv2Zocddgg9p5LRmzdvtqPv4n1PNBrBp7lBNLovGjUCKpgLfwAAAPeK/L6UPIBwf/zxh/nhhx9sqT9HzZo1zcEHH2yzO+J9T2Ux5PLly2O+TgwJAEAqMpVT8QD+n9oXd9ppJzvFSHj74vr1621lmXjfEyt+XLdunX1fNMSPAAAkW2nBxo851zG8adMmOzfHTz/9ZH9WOWhl6obP7/vNN9+EXov3Pb/++qsJRpROff75502bNm1Ms2bN0nBkAAAASBUNBlTWhjRu3NiWg1YGcLhZs2aFYsN43iMLFy4s97qyixWn7rXXXlxMAACAHKaOWrVBLliwwP6sGPDnn3+2z1fWBlnVe6JVHFQb5I477lhuyhIAAICCmGP4pZdeMn/99ZeZPXu2zbRQACYnnniiKS4utoGVSvSpNMu2225rBg8ebO655x47H/CgQYPs/MF33323Oeyww8zee+9tl43nPe+99559z+GHH24aNGhgy06rVKDKBgIAgPTwpyDDt4yM4bynqUGmTp1q1qxZY3/WnMBLly41nTt3Nrvvvrt97oknnrDl+TSViOZ+0xxtI0aMMH/++aedP1ix4EcffWTL/Uk87xHFjpoTTg15ixcvNvfdd5/p3bu36d+/f4bOBgAAhUjZGeUH+xfKHHFw74UXXrDx448//miWLVsWaoM85ZRTQnP/qg1SnbatW7c2Z511lnnggQfMAQccYAYOHGgrDN51113m2GOPtVnCEs97Jk+ebMaPH28OPfRQU7duXdsWqsGFkyZN4nICAJA2pQUbP2ZdxvBnn31m3n//fTs3W48ePey/9VBJZ6lWrZrt3FWnsKgTV5kbQ4YMMfPmzbNB27hx48yrr75qfD5f3O856aSTzH//+1/7bwWEhxxyiP2/gjQAAJAelJKGG7///ruNFz///HMbJ2pwoX5WtoZDGbzHHHNM6OeLLrrIdvTWqVPHxom77babLR2tOYMTec+XX35pBxrq+aKiIvP000+bl19+2Q5oBAAA6VK4pQDh3vTp023MqGqBihWdNkiHsncVW26zzTb256ZNm5o5c+bY5BXFfqtXrzb3339/uaSSeN5z5pln2oSV0tJSW2lGpab1f7WDAgCAdCkt2PjRF4ysnwzXVKq6fv365oBb3jTFNRMv/XJ2z3auttulZV3jViMTfe6SeAR97sYVBEtqut6mf+Nqd9v0u2+c9QXLXC0XqF7H9Tb9gc2ulzVlLkel+IvSfi+U+dxvs8zDR1ehfOgxq2rq+P83qMgND4san8vfb7efY/pea9piK7Ny5UpTr149V+tI9Dv0kHFvmxIX36GV2bx+rXnz/F5pOQ7Ay/1/hDGmJI2n0G204f7b25gaHpb9Z1ho4rbwsM3maV5OejTysPABLpdr4WGbHVwu18rDNt3ur5evFy/XpbHL5Yq8/LYVZ+C31ItmGdjfJi6X8zLwJ1PLps+qVZtN/fqvpy3ucr5DV67sYOrVK0ryugOmfv3viSGRlZx7v1ea48flHpb9/+LaiVnqYZtezo27v6KNcddymbnMrwYelk3up26OZrml6Bz5M7DNogK6LmV5nQuam3RuvzcmrW2QKws4fsyNvywAAEBBZQwnE6WkAQAA8l3hlgIEAACAG6UFGz/SMQwAAAAAAAB4sHHjRnP77bebKVOmmOrVq5vjjjsuNFdtLPPnzzd33nmn+fbbb01JSYnp2rWrOffcc02jRl7KFAAAACCXpra48847zeLFi80OO+xgrrjiCrP11lvHfH9ZWZl54oknzCuvvGKnUttqq63Mqaeeag444IC8zfIHAAB5jDmGAQAA4C47I9nzwyWW8TFgwADz0EMP2flj+/XrZ4YPH27Gjh0b8/1//PGHndf2559/Npdccok544wzzKRJk0yvXioODAAAgHyPH2fMmGF69OhhWrZsaS699FLbObzPPvvYDt9YxowZY8477zxzyCGHmNGjR5u2bdva+HHy5Mlxb5eMYQAAAAAAAMClzz//3EycONFMmzbNdvbKhg0bbAOfGu7q1q1bYRm99/fffzcPP/ywadz4n8nI69SpYxv2Fi5cWGmmCAAAAHLfqFGjbOx38803258POugg06pVK3P33XfbTt9oNJBQGcJDhgyxP/fs2dO8+eab5qWXXjK9e/eOa7tkDAMAgKxR7NfDl+RHpo8KAAAAqRVI0SM+Kh/dpEmTUKew9O3b16xfv9588sknUZfp3LmzqVatWrnXP/roI9sY2Lx5c4/nAwAAANkcP5aWlpqpU6eaI488MvScYsNDDz3Uxpax7LHHHuaLL76w05jIkiVLzLx580yXLl3i3jYZwwAAAAAAAEAUq1atKvez5g/WI9yCBQtMixYtyj235ZZbGp/PZ1+Lpk2bNuadd94x/fv3N5dffrntRK5Xr55tIFSjIAAAAPI3fly2bJnt3I2MIfXze++9F3Pd9957rxk2bJgtP635hefPn2/LS59++ulx7x85NAAAIGswxzAAAAASV5qih7EZvPXr1w89rr/++gpb37x5c4XGvuLiYvvQa9GsWLHCnHXWWWb33Xc3t956q334/X5z/vnnm2AwyE0AAACQ5/GjRMaQNWvWjBk/ykMPPWTLRl977bXmtttus7Hj1VdfbSvPxIuMYQAAkDX8fp/tHE6mQJLXBwAAgGxTmoLchzL730WLFtlMXkdk4500atTIdvSGW716tW3Uc+YPjvTggw+axYsX2/mJnXWqvPR2221n3n77bXPwwQcn+XgAAACQTfGjRMaQy5cvjxk/Kra85JJLzHXXXWcHGMoBBxxgvv/+e3PllVeaDz74IK69JGMYAAAAAAAAiEKNeuGPaA17u+22m/nll1/Mn3/+GXpuxowZ9v+77rpr1POqRkDNSxy+PqeUYGQDIQAAAPIrfqxXr55p166d+eyzz8o9rxgyVvy4YcMGO/2IykiHUwyZSPxIxnAK1K9VbEpqlph08VJhKFjk/hbwlf2TFp+oMp/7zK2gPwO3bPCfUR6J8mWq9JPL8xv0MU4klcoycDsUSpKkl8P0u/x98fAxlpnPBpefY66X86DI5zdFfn/S1wnkgs05sr1076fX7W7MwDY3eNimp4U3ZGCbG3Nom0U5dl1KAu63WeRy2SJ3f+N5V8flcl72t4bL5bz8TZqpZdOpNO8yPuJxxBFH2MyOsWPHmnHjxtlsDpUM7Natm+nQoYN9jxrx9t9/f5vN0adPH7PffvuZm2++2bz22mvm8MMPt++588477fzCXbt2TfKxIF+p9TF9LZDetlUjA9v0Mlt3IAP7uzkD2/SyrJfQyq1c++ve7TlK5+91Mq5nJu4Fk2O/3x4i+4LgL8D4UQYPHmxuv/12c84555g2bdqYN954w3z66afmhhtuMA7FllOnTjUvvviiqVu3rtlll11s5ZnevXubWrVq2Qo0L7zwgv053/6yAAAAAAAAALJOnTp1zIQJE0z//v1tw9y6devs3HKa/80RCARsBsjvv/9uf1bj3ZgxY8xxxx1n36uOYy33yCOP2IZBAAAA5LdLLrnEzJ071+ywww6mdevWZuHCheamm24yPXv2DL1HVWlmzpwZ+nn8+PHmpJNOslnDW2+9tfnxxx/NQQcdVK4zuSp0DAMAgKxRlII5hpO9PgAAAGQb5eEku9pNYpV+unfvbhYsWGDmzJljywW2b9++3OvK6Jg2bZotGegYNWqUbRCcP3++zRRWg2BJSSbyxAAAAApNIOPxY3FxsXnsscfMjTfeaJYsWWLatm1r6tevX+49F1xwgRk0aFDo506dOpkvv/zSZgr/8ccfdoChM19x3NtN6N0AAAAAAAAAKjayFRebzp07Rz0zfr/f7LXXXhWer1mzpunYsSNnEwAAoEA1b97cPqLRwEE9ImleYT3coGMYAABkDTKGAQAA4G6OOF9GMz4AAACQS0oLNn7MtfnaAQAAAAAAAAAAAAAJImMYAABkDTKGAQAAkLjCzfgAAACAG6UFGz/SMQwAALJGkc9nH8leJwAAAPJZ4TbsAQAAwI3Sgo0fKSUNAAAAAAAAAAAAAHmOjGEAAJA1/H6fLSed7HUCAAAgjwXLkp+gkRsJHwAAAHAjWLjxIxnDAAAAAAAAAAAAAJDnyBgGAABZoygFGcPJXh8AAACyTNn/HsleJwAAAPJTWeHGj2QMAwAAAAAAAAAAAECeI2MYAABkjWK/zz6SKUDGMAAAQH4L/O+R7HUCAAAgPwUKN34kYxgAAAAAAAAAAAAA8hwZwymwX4empmbtugkv165hLVfbq1+9yLjlW/uX+2WD7gqm+4uru99mWalJO5fb9LSvLs/tP8sGc+bc+j0MTfH73C8c9KV/vlGXl8UTL4fpdn8zcGqNz8vJDbobxuUrK8up32/X2yxL/zA35hhGIVuT5uB8cwZGlrrdpqx2uVyJh20mHtH/o4aHbQbWuV+2yO1JcrucrMqhbW7ysE0vN1JRBm4kt9ss8fDd7yVsqLfU5YJ1TPp32P3fs4XRfJOhNIkCzvhAYWtojKlmcsOGNC/n9es7kIGv780ZOM5GJreUZGDaT38GQrKiHMsEzMTnUCa+pnMtNMiR6W6tDPT6mEKOH3PlLwsAAFAA6BgGAACAq5bPsgJuTQUAAEBiygo3fqSUNAAAAAAAAAAAAADkOTKGAQBA1ijy+WzWcLLXCQAAgDxWwKUAAQAA4EKgcONHMoYBAAAAAAAAAAAAIM+RMQwAALKG35/8jGGtEwAAAHmsgOeIAwAAgAtlhRs/kjEMAAAAAAAAAAAAAHmOjGEAAJA1lC2c9DmGyRgGAADIb2UpmNMtRzI+AAAA4EJZ4caPZAwDAAAAAAAAAAAAQJ4jYxgAAGQNMoYBAACQsEAKMj6SvT4AAABkj0Dhxo90DAMAgKxR5E9+6Wet0421a9ea+fPnm1atWpn69esndZ8AAACQ5LJ9ZYVZChAAAAAulBVu/EgpaQAAgDDqDB4+fLjZdtttTefOnc3rr7/O+QEAAAAAAACQ88gYBgAAWSMbSklPmzbNdgrPmjXLbLHFFkndFwAAAKRAAZcCBAAAgAuBwo0f6RgGAAAIM2DAAPv/0tJSzgsAAAAAAACAvEHHMAAAyBrZkDEMAACAHFPAGR8AAABwIVC48SMdwwAAoCCsWrWq3M/Vq1e3DwAAAAAAAAAoBHQMp0DjmiWmVq2ShJcr8pv0K67metFgsMzVcpt97m+7kpKa7hZ0ua9Wmbv9DfgTvweSwW+CrpYL+tKfURcoc7evEnS/qCnzsN10C3o4UJ+Ha+p2u1626Tap08ud6/cVudum391ydlkvN6/LzzKf28/AovR/jvlTkDGsdUqrVq3KPT969GgzZsyYpG4L8GJDmoPzzSb9yjyeHzc2etjmWpfL1c3AcUrtDRnY6Loc2qbJ0DZrZGC0udtQJTN/whhTw+XBlqx0v01fui+o8fgpnyvNN2WZ22xZfhwKkOgnkvuWvfR+AgYysM2SDOxvJmLsTJ0j9y0jubVNL9w296fz99rhz7Hrkonfby/bJKzIvs9OU8DxY678ZQEAAODJokWLTL169UI/ky0MAAAAAAAAoJDQMQwAALJGkc9nH8lep6hTOLxjGAAAAHmigOeIAwAAgAuBwo0f6RgGAAAIs2bNGvPLL7+YQOCfaO7XX3813377rWnUqJFp0aIF5woAAAAAAABATqJjGAAAZA2/z2cfyV5nIr7++mszdOhQ++9OnTqZRx991D769+9vrrrqqqTuGwAAAJIgmII53bROAAAA5Kdg4caPdAwDAICsUWRLPyd/nYno1q2bzRAGAABAjijgUoAAAABwIVC48aM/0zsAAAAAAAAAAAAAAEgtMoYBAEDW8Pt99pHsdQIAACCPFXDGBwAAAFwIFG78SMYwAAAAAAAAAAAAAOQ5MoYBAEDWKPL57CPZ6wQAAEAeK/vfI9nrBAAAQH4qK9z4kYxhAAAAAAAAAAAAAMhzZAwDAICs4ff57CPZ6wQAAEAeK+A54gAAAOBCoHDjRzKGAQAAAAAAAAAAACDPkTEMAACyht+nOYGTv04AAADksQLO+AAAAIALgcKNH+kYBgAAWcPv99lHstcJAACAPFb2v0ey1wkAAID8VFa48SMdwymw79b1Tb169RJerlZR0NX2ilYtMW75AptcLxssquZquaKaDdI/4sLnoWq6y0UDQXfXM2OfPRnYXy9bDJRl5vy65XZ3vRylz8M1dbtkkYc9LjPuOu+89PmVuTxHfpf7anmY79bn8gMp6PIzMOgnTADS6S/7OZo+mzMwF02Jh2VXmPQrycBx/uFh2dp/ZGCHG7tcrpaHbRZlYJte/sAPZOC6FGVgm15scLlcDQ/brL3S3XIlLpczHj/kc2UisNz6Mw3IeQ2NMdVNbqiV5pjV69daWQa+mjZnYJv1PSybzr9dMrlNk4Gvb3et7t74C+i6ZCKpM0f6CzPGfS8V3KDFFwAAZA2/z2cfyV4nAAAA8lhZClp5acEFAADIX2WFGz/myphTAAAAAAAAAAAAAIBLZAwDAICsUeT755HsdQIAACCPFfAccQAAAHChrHDjRzKGAQAAAAAAAAAAACDPkTEMAACyBnMMAwAAIGGBFMwRl+z1AQAAIHsECjd+JGMYAAAAAAAAAAAAAPIcGcMAACBrFPl99pHsdQIAACCPFXDGBwAAAFwIFG78SMcwAADIGpSSBgAAQMLK/vdIpmSvDwAAANmjrHDjR0pJAwAAAAAAAAAAAECeI2MYAABkjSLfP49krxMAAAB5rIBLAQIAAMCFQOHGj2QMAwAAAAAAAAAAAECeI2MYAABkDZ/PZ+cZTvY6AQAAkMcKOOMDAAAALgQKN34kYxgAAAAAAAAAAAAA8hwZwwAAIGsU+X32kex1AgAAII8FjTFlKVgnAAAA8lOwcONHOoazqVHbZanLYFGJq+W8bNNut7iaq+U2lrr/bSv2p/+WLSpyd442b072p0p83PZ/UGo1O3npzvLSF1YWTP995Predb1FbdPd0rlWmTjo9vsl1w4UyHHpjhwCGaiMVORhWbfb3exhm26XXedhmxtMBhb2ssNrM7BNL8u6VSMDy5Zk4JfNyza9qJaBD86iDHyo+DP0AZpOmfj9BApYS2NMzTRur3YGQoaiHCuV6eVjcHMGwpRGJv0ycU3Lcuzr259j1yUTIWQmWt5zpEpwTh7rxjRvr9DRMQwAALKG/vhJdoIv82YAAADkuQKeIw4AAAAuBAo3fqRjGAAAZI0in88+kr1OAAAA5LGyFKQOZaYIGAAAANKhrHDjR5JoAAAAAAAAAAAAACDPkTEMAACyhuZ9djv3c2XrBAAAQB4r4FKAAAAAcCFQuPEjGcMAAAAAAAAAAAAAkOfIGAYAAFmjyP/PI9nrBAAAQB4r4IwPAAAAuBAo3PiRplIAAAAAAAAAAAAAyHNkDAMAgKzh9yV/TmCtEwAAAHms7H+PZK8TAAAA+amscONHMoYBAAAAAAAAAAAAIM+RMQwAALKGsoWLkp4xTMowAABAXivgOeIAAADgQqBw48esyxj+7bffzNFHH23q169vmjVrZoYPH242bNhQ5XIPPvig2XnnnU29evVMjx49zBdffBF6be3ateaWW24xu+66q13vjjvuaO644w4TDAbLrePNN9803bp1Mw0bNrTb7tOnj5k9e3ZKjhMAAETvxE3FA/nv/vvvN9ttt52pU6eO6dKli/nwww+rXOaXX34x//rXv8wWW2xhttpqKzN69GizefPm0OvTp083xx57rNlyyy1NixYt7L9/+OGHcutYtWqVOeecc0zr1q1N3bp1TceOHc1tt92WkmMEAACVlO0LJPmRI6UA4d78+fPNkUceadsSFe9dfPHF5WLBWO6++27btqjlDjzwQDNr1qxyseH1119vdtppJ9sGqbbK//znPxXW8fLLL5u99trLNGjQwDRv3twcc8wx5qeffuJyAgCQLmWFGz9mVcdwIBAwhx9+uO3I/frrr80bb7xhAyU1tlXm6quvNpdeeqkZM2aMWbx4sbn11lvNQw89FHr9kUceMcuWLbP/X7hwobnhhhvMyJEjzU033RR6z48//miDQQV0P//8s/n888+N3+83Bx98sCkry5GrCQAAUICefvppc95555nrrrvOxnEHHXSQOfTQQ+2/Y1HMqMY4xXuK+7755htTvXr1ch3Kl1xyiRkwYID56quvbCexYkLFiitXrgy95+yzz7aDC1966SW7Tu3DlVdeaR5++OGUHzcAAADc2bRpkznkkENMUVGR+e6772ws99RTT9n4rzJ6Xe2QN954o1myZIkZO3ZsuTZIdQKvWbPGPPnkk7YNctSoUeb8888399xzT+g9ijuVFHPUUUfZgYqKM9UWqjZRAACAVPMFI9NmM+i1114zvXv3tiP2ttlmG/ucAqlBgwbZYEvZHJF+/fVX06ZNGxt4nXbaaXFv69xzzzUfffSRmTlzpv15woQJNgtk9erVNtNE3n77bdsxrG20bNmyynVqVKBGAy5cvNSOGkxUdZfd9P61y93fAGWlrpcNFldztdy6ag1cb7PYn/6sryKX21y/OTMDCtyeIl+OZdRl0UdXXMoysLtefl3c7q/b3xdP924GSgxn6tfF5/K+D7rcYX2vNW/WzHaCufleS3Rb+g79cM4CU6ducre1ZvUqs+8OrdNyHMiM3XbbzT7++9//hp5TfNivX7+Y2bunn366+eCDD2x1mOLi+GZX0UBDZXS8+uqrNmaVHXbYwfTt29cOPHR07drV7s99992X0P2/TZpHbVadD5N8NTws28Hlcu4jT2Oau1yukYdt9vOw7PYt0nygXi5MKw/bdLu/tTxs08tFbexyuRIP2yzKwDa9aJCB/a2b5nNrPH7Ie9luGq1aZUz9FiZtcZfzHbryPmPq1UzyutcbU/+s9B0L0uu5556zlWM0sE9VA0Vtixps+Mcff9hKMJFUOWb77bc3zzzzjDn++OPj3tapp55qs4GdAYiPPfaYbcNU57Q6puXFF1+0ncV///23vafjvfdvN8Yk+dav1AoPy651udyyHMuIWpeB+LxGhkIck0NfpWU59vXtz7HrkokQMhMt7zlSJTgnj3WjMeYWk564axXxY3ZlDH/88ce2Q9jpFBZlZSiTeMaMGVGXeeWVV+z/+/fvn9C2li9fXi7I22+//WwgqHIw69evt69rxJ+eV+lAAAAAZB9lVyijd//99y/3vGLITz75JOZykyZNsvFjvJ3CovhQwmNINQqqwo0aCktLS+3Awjlz5thygAAAAMhOaoPUFCBOp7ATP27cuLHc9HThlFVcs2ZNO/jQSxuktqMS0vfee6/d3u+//24effRRW/Emnk5hAACAvOkYVlZw06ZNyz3XpEkTm8m4dOnSqMvMmzfPdiSrXF+rVq1M48aNbflAlQSMRY2EGhk4ePDg0HPKRlaj3rhx40ytWrXsdlVeWu+LlUmp4E2jC8IfAADAPeYYRqKUxasqEpExpGK7WPGjMjHUQKcqMYob1VDXvn17WxYw1rxyKiN94YUX2gzhvffeO/S8pjLRnMYdOnQwJSUlNpP4lltuseuNhRgSAIAkC6TokQB9v6uCiGIAxQPq6IvHl19+aSuZHHDAAeaCCy4wf/75p7tzAM9tkE6lwsraIBUz3n777TaJRG2Hhx12mC0NHcuUKVNstZnwNsitttrKZggr9qxRo4btnFbnsEpZx0L8CABA/sWPoiklNI1Zz549zVlnnWWnoqjKhg0bbDyiaSg0NYUGryUi/hSJDHE6ZWOVjVUjneaPU3aGRvspoBoxYoTp1auXnSMkMtt37ty59kSpjItKVDuU5aGy0SoZM3z4cJt9ooDc6WTWnHORrr/+ehvERVq5MWDKNiR+B9Qsdlfqs35N96MJg2UeigL43RWYWL/ZfU3dYpdDGYo8lH0tcrm7pR5qB2eirLOXc5SBCt+eavn60lx2OFMysbs+D58pvqDLIjBul8tBQb/Lr21fjtQeBJJIcwdXFj/KtddeaxvgFHwr3jvuuONsSb9///vfUach+eyzz2wJQHUAO4YOHWqDeL2mhsJ3333XnHjiibazWeUJo4kVQyrMSedva1kGRpZmogxbrn0CeirxvSHNy3mpl7g6AyWAvdRDy0RZ5xoZ+GVzN1tQ5mrr1cjA/maq3HaufAiuMQVLDXrqINT3vAahqW1JU5ONHDky5jITJ0608YIGnyl+UNuUOolV2QSZiR+lshhS11gxn2I/vV9zDqvtUBVjlKwS7uuvv7bVZdTWGF5NRuvQ4AHdG0OGDLH3i2JNtUtOmzYtakWbWPHjbsaYfybES4/lHsuEuvGbh216+VpLd8lsL3Ggl9kyvEy7UlToWW5Z+vWdiXNEKWlksgx/LpsxY4bp0aOHjRsVC2pai3322cfGEJFxhUMVj9WOpfYr9YWq2sgDDzxg26E00DDnPks1Qk7zeITTSEkFZOGlXcJtueWWNjBT7/jWW29tR/vdddddZs2aNeatt94q914F2DoxGs2nExzukUceMQ0bNrRBlk641nXPPfeYb7/91rzxxhtRt33FFVfYmufOY9GiRZ7PAQAAhUwDGlLxQP5S7KcBVZExpLIuYsWPKt2nwYTqCO7Tp4+dv0Yx4hlnnGGeffbZCu8///zzzdNPP20zPlRy0LF69Wo7r/FVV11l9thjD7seDUA84YQTYs5tLMSQAACkYLRTKh5x0gAzdfI+8cQT5thjj7Wdu9ddd519KF6IRs8ri/TSSy+1nX5q4FMsovlrkZk2SMWPzmuVtUHeeeedpmXLlvZnTUmn9bz33nvl3jtr1izbYaypSyLjwgcffNBWP7zssstMo0aNTNu2bc0dd9xh76OpU6dG3TbxIwAA+RU/yqhRo2yS680332yzf59//nlbyU7xRSw33nijrWLyzjvv2LhTy2s5dSjHK6s6hrXj8+fPL5cqrawLjcDr2rVr1GW6detWblSfqHHQeThUFlpzzykoUydw+PvDlwnnvKeoKPoYHWURqwEw/AEAAID0UTnozp07V2hEU+NcrKBYMZ7KQccTDyqD5/HHH7edwrvuumuF9TjLRT4fK34UYkgAAPKL4gSVFd5rr71Cz/Xt29dmdGg6s2hUXliZosOGDSv3vAavIfUUJ86ePbtc6W61QVarVs3svvvucbdBRosHlWSieYSVJax5hCNjRdogAQBAaWmpbcs68sgjQydDccihhx5qY8tYNBBRA880uMxtDJlVHcPK5FUWxtlnn23ni1MZFvWYDxw4MDRaT5m5KqmiBjonkNt3333NxRdfbEf26fWLLrrINhKqBIuo91ydwgrKNMdLZCOgKFtkwYIFdpSmykhrXSr1ovlFEulpBwAA7vmNLyUP5DfFfooN1cC6atUqc80119jSjeENrYrrtt9++9DPys5RdrAqzKj8jsr2KftX2b4OlQZU7KiAfLfdVKivvNq1a9uRmcoG0hQmWs+bb75py1MrcxgAAOT+HHGKLcIfmus1ktqTIqcyUzapOgD1WjTqlNQyarM6+uijbRuWMkgjs1iRGv369bPVAhUv6pyrvLOmGVEWt0oyym+//WbbIJUNLko2UaexBg4uX77c/PXXX3YaOrVZKuNb1JbpdArfd999UacKU5yozmNlCa9bt87Od6x1au5hVaEBAAD5Hz8uW7bMPh8ZQ+rnWPGj5hbW1LqdOnUyV155pe331LQkr7zySkKHnlUdwwq2Jk+ebHvKFZwpS1iB1f333x96j8pKBwKB0NxwogBNc72p9EqrVq1scK05hxWEixr5FMypkU497tqOHhrN6dCozgkTJpgXXnjBliTs0KGDDfLUuBfZ8w4AAFKDUtJw4+STT7aD+84880wbtymeUyex5n9zKH5UjOnQCEzFmBqQqA5eBdL69+jRo+3rGih4yy232EyeLl26hOJHPZT54Rg/fryNWdVQqIGJalxUqT91KgMAgNxv2FM7kzoKnYdijkgq+aeKIOGcuEGvxWrYU3LDOeecYxMiNHWF5plTXBGr/DSSR1k1avNbsWKFLQu933772YwdTVUXqw1SiSZqeFVnru4LlYPWtHIaaOjMA6g4UckmKhettkrnPtB7HZrCRG2Uqmiotkk17mqA4euvv27jSQAAUBjxo0TGkDVr1owZPzodzJpbWHGJpjbToDVNlRbej1oVX1BRTo5Ro57K80UbdReNArjwjmSHlq+szF+i1POvizxr/m+mbt3Ey0rXLHaX0VS/OMHC5eHK/nenuuF3d+5WbHY/HqHY7+4cFXlIFityuc2Npe6vS7z3djKP1e1xiodFM8Lt7vpzbKLSTOyuz8Nnii/o8nfG7XI5KOgvdrlckevvtebNmtkGq1RPl+B8h874YZGp4+I7tDJrVq8yXdu3SstxIHspFlTYm0jsF96RHC6RODSR+7+t1m3SJ/qfGakdWVriYdn/z/dOTAMP29zC5XJehpUe4WHZzm433NzDRrdzuVz5QdHpWdZLdVYvF7VBBvbX7S9qNQ/bDOTYOaqVgQ8yL9x+QaTzi0XfaauNqd/epC3ucr5DV95iTL2aSV73emPqX2xsx1/4sajxLrIBT5VIlLTw008/hZ5T566We/rpp8tVJHGogVCZHtOnTw9Nn6YMVHUUqkTggAEDkntAyMs2SE2mks6u5OUelq2YKxWf3zxs08vXmltrMxCfu/1K8xorp/krJvuy3LL06zsT5ygT4VEmWgO9hLuo3DpjzHH/qxicrjbIlRmOH539iIwVVfFO8werukgkDVhTx/EhhxxSLkv43HPPtcsoaTYfP0stjbRLpDFOPefhWR7OI5kBGQAA8E4DTVLxAKqa9zeaaPFjonEoAABIU+twKh7G2Ea98Edko55oyolffvml3Hy1yv6VXXfdNeouOyWDw8sHNmjQwGayqoMY2YE2SAAA8lRZZuNHPd+uXTvz2WeflXteMWSs+FHtWnot2hQmicSPOdkxDAAAAAAAAGSDI444wpYSHjt2rP1Z5f+UEdytWzc7VZmsX7/eTmP28ssv2581J9x2221n7rnnntB6Hn30UVtSuEePHhk6EgAAAKTL4MGDbaWY+fPn25/feOMN8+mnn9rnHePGjTP9+vUL/Tx06FDz0ksv2axkUYewso41xVm83NWkBAAASOEcw8leJwAAAPJYWQrqOyZQo1Lzwk6YMMH079/fvPDCC6E5aNVoF176Txkgmn/WyURV+eljjz3WzjerTOHly5ebhx56yOy4445JPhgAAABkU/wol1xyiZk7d67ZYYcdTOvWrc3ChQvNTTfdZHr27Gkcqkozc+bM0M+nnXaamTNnjunYsaNp06aNfX3fffc1d9xxh4kXHcMAAAAAAACAB927dzcLFiywDXUqF9i+fftyr9eqVctMmzbNlgx0qANY7//+++/tz23btjXVqmViVlQAAACkmwYKPvbYY+bGG280S5YssbGg5h0Od8EFF5hBgwaVe+7mm282V1xxhe1Ibtmypdliiy0S225S9h4AACAJ/MZnH8mU7PUBAAAgy4TN6ZbUdbpo3OvcuXPU1/x+vy0lHcnn85ntt9/ezR4CAAAgx+NHad68uX1Eo0xiPSI1atTIPtxgjmEAAAAAAAAAAAAAyHNkDAMAgOyRgjmGSRgGAADIc4EUzBGX7PUBAAAgewQKN36kYxgAAGQNv++fR7LXCQAAgDxWwA17AAAAcCFQuPEjpaQBAAAAAAAAAAAAIM+RMZwCy9eVmo1FpQkvV696kavtFfvdLSclRe5vgbKgu+XWlyZ+bhzVi9yNZXC52D/LujzOzR4mLvf7gl4WdrVY0O0F9VCl1UsWn4fddb3dpJe3TbFMZEkW+dx/Hvlcfpb5gh5uhqDLX1RfZsZVlbn8bdsccHeONrlczgsdIZWkUaj0yZLOTxe323L/SW9MNZNb3A723exhm+s8LGtWu1yutodt/u1yuVoetlmSgeP0MvJ7c5qP08uyXn7BTQbOUQ0P26yVgeviRaauTaLWZGi7CuvLUrBOIMs1NcbUTeP2vHwEbsjAV3AmPrK9xHKBDIQ49TPw1RQogK9Dr/ubiVanogz8ruVIcmXOhga5dH4zEkKWFW78SMYwAAAAAAAAAAAAAOQ5MoYBAEDW8Pt89pHsdQIAACCPFfAccQAAAHAhULjxIxnDAAAAAAAAAAAAAJDnyBgGAABZw84xnOQEX/KFAQAA8lwBZ3wAAADAhUDhxo9kDAMAAAAAAAAAAABAniNjGAAAZNWItWSPWmMUHAAAQJ4LGmPKUrBOAAAA5Kdg4caPdAwDAICs4fP57CPZ6wQAAEAeK+BSgAAAAHAhULjxI0k0AAAAAAAAAAAAAJDnyBgGAABZw+/755HsdQIAACCPlaWgFGCy1wcAAIDsUVa48SMZwwAAAAAAAAAAAACQ58gYBgAAWUPTASd7SmCmGAYAAMhzBTxHHAAAAFwIFG78SMYwAAAAAAAAAAAAAOQ5MoYBAEBWjVhL9qg1RsEBAADkuQLO+AAAAIALgcKNH2krBQAAAAAAAAAAAIA8R8YwAADIGj6fzz6SvU5kt5UrV5r69etnejcAAECuKvvfI9nrBAAAQH4qK9z4kY7hFKhdzW8fiapW5K7husjvvsE715rKg8FggRxp+s9RmYdz5PYWLHN7OYFk8aW/cEbQQydlwOUvTanL5dxuDwi3YcMGc95555nnnnvO1K1b1wwePNiMGDHCFBf/fxjauHFj+77w5wpRWZojlkz8vbIpAxWZNnjY5lqXyxV52OZyD8v+vdndcg2WethojQyU2NqQ5n2VBh6WXelyuRIP23Qb4lQzmbEiA9e0VgauS1GGlk2ndZneAaCwtKhjTL00BpBbrHa/7EaXy9V1v0lPXxMmA7FnWQaOs1EGvpoCObZNk4H99edYyOAlPDI5dE1zpM8vJ63K9A4UmMJufQMAAFlFA008jHeKuU5kztixY81rr71mRo4caZYvX25uvfVWM336dPPiiy+aGjUy0VQDAADyTgHPEQcAAAAXAoUbP9IxDAAAsgr9uPnl2WefNc8884zp1q2b/fm0004zhx9+uDnyyCPNyy+/bGrWrJnpXQQAALmuLAUNcaQFAQAA5K+ywo0f019DEwAAAAXj999/N507dw79vO2225oPPvjA/Pbbb7ZzeP369RndPwAAAAAAAKBQ0DEMAACyrpR0sh/InB122MHMnTu33HPNmzc377//vlm6dKnp06ePCQaZzxoAAHjMzkjFAwAAAPmprHDjRzqGAQAAkDKDBw82Dz30UIXnmzZtat59913bOVxWliORMwAAAAAAAJDDmGMYAABkDZ/PZx/JXicyZ9CgQaZJkyZRX1Pn8HvvvWcmTJhgioqK0r5vAAAgTwRSMEdcstcHAACA7BEo3PiRjGEAAACkTLVq1Uy/fv1ivq5O46FDh4Y68Pv27UsGMQAAAAAAAJCNHcOBQMCsX7++3HO//fab2bBhg9dVAwCAAsMcw5g8eTIdwwAAIDEFPEdcIdm8eXOF9sZFixaZTZs2ZWyfAABAjior3PjRU8fwN998Y5o3b25atGhhRowYEXq+f//+5vPPP0/G/gEAAAAAAAAoYNOmTbPTkLRs2dLccMMNoecPO+ww88MPP2R03wAAAHKJp47hW265xZx33nlm+fLlpmbNmuaSSy5J3p4BAICC40vRI1FffvmlOemkk0yPHj3MkCFDzLx581JwtAAAAEjqHHHJfiBrXH/99ebaa681y5YtMytWrDD//ve/M71LAAAglwUKN3701DGsQGzXXXc1fr/fjBw50pSUlJixY8cmb+8AAEBB8ft8KXkkWhGle/fupkGDBubyyy83q1atMnvvvbdZvHhxyo4bAAAAHhRww16hcNogi4uLzU033WRj87vvvjvTuwUAAHJVoHDjR08dw8cee6yZOHFi6GeN1lP5lpkzZyZj3wAAANLu6quvNl26dDF33XWXLU331FNPmVq1apnbb7+dqwEAAABkQGQb5J133mneeecd8/PPP3M9AAAAElBsPDjllFNMaWmpWbdunW0w9fl85qGHHjI77bSTad26tZdVAwCAAqTk3gQTfONaZyLUwHTVVVeFfi4qKjK9e/c2U6ZMSe6OAQAAIDnK/vdIpmSvD54MHz7cPPjgg2bz5s22YqFidA3gVAdxs2bNOLsAACAxZYUbPyacMTxmzBgbhDlOP/102ynsUHB28cUXm1atWiVvLwEAADxSSejwx8aNGyu8Z+XKlfbRokWLcs/r5wULFnANPFi7dm3M11QKMBgM2n+fffbZdpoSAAAAFLZRo0aZQOCfmoyKD4cOHWrbHR01a9Y0l112mdliiy0yuJcAAAB5njH8/vvvm08++cSWb6lTp06515RJs8suu5gmTZqYQlaz2G9qlSTeoFnid5ci5XY58ZKVFSwLutum+03arPRC4PLUWm5PkT+Y/o162GJGzq/fwx7n2r3r9hwV5dZhuhb0cD29/Kq5vS4Blwu6Xc4LXzBoH8lep0QOWhs9erQd8BbOGfxWvXr1cs+r0Sl8YBwSt8cee5jHHnvMlukO9+KLL5ohQ4aYpUuX2jnj7rjjjoI9vekeWBrIsWN0+xu4ycM2Kw4fiU/sYRBV2+Bh2dUul6vh4eOthtuDXZeBA/XyMV5k0q8kA8tm4ji92JyBD0Ev18WLXLk26zO03bIUfLHlSMZHPnvttdfM119/bZ555hkbj4ebPHmy2XfffU29evVMQWvodaLAxFTzsqzLIKexlzjFpJ+X2DMTx1nby8L+DHy+ZmKbJgP7m4nvfS/bzEB8VJRrf9DmmjSf301quluT3m2aAo4fE/5oeumll2z56B49ephly5bZ52bMmGEOOOAAc/DBB1eaDQIAAJApixYtCmUE63HFFVdUeE/9+vVtWboVK1aUe3758uWmcePGadzb/HPggQea7t27m3//+9+mrKzMrFmzxlaeOeGEE8yll15qO4UBAAAAx5tvvmn++OMPG0c68fmHH35oY8o+ffqYTZsy0QUHAACQ2xLuGFaD6RtvvGE6dOhg9tlnH9OvXz+z9957mwYNGthRfMwtDAAAXAuWpeZhjM0mCH9EZgWLStPtuOOO5rPPPiv3vAbB7brrrlxYD+6++25bcUYZwfvtt589nx999JGZNm2a7RgGAABwLZCiBzJKAzPfeecdO4dwt27dTO/evU3Pnj1tJaDvvvuu4CsWAgAADwKFGz+6Ss1Qqb/atWubn3/+2T6effZZc/zxxyd/7wAAANJs8ODB5qqrrjIXXHCB2X777c3UqVPtVBqTJk3iWnh0+OGHmxNPPNHcfvvtdp44lQfcbbfdOK8AAACIavHixXYqu7lz55rvv//evPLKK7aDGAAAAGnKGL7sssvMdtttZ2bNmmVH7V100UVm2LBhNtsDAADAC1+wLCWPRJx99tm2vPEuu+xiK6QccsghZtSoUeaII47g4nos5a2pR8aPH28zhxVD6pyOGDGC+ZsBAIA3ZSl6IKPOPfdcO1BzwYIF5oMPPjBDhw61U5F8+eWXXBkAAOBNWeHGjwlnDGt0njKEjzrqKPuzGvhatmxpevXqZZ588knTt2/fVOwnAAAoBGGln5O6zgQok/X+++8311xzjfn1119NmzZtTMOGDZO7TwVIpaP33HNP880335jmzZvb6UgOO+wwc/LJJ5u33nrLfPrpp8bn82V6NwEAQC4KuEl9iGOdyKiffvrJvPTSS7bqjOy77762DVLlpJ9//nk7gBMAAMCVQOHGjwl3DEcro6hSiy1atDD/+te/zA8//GC22mqrZO0fAABARjRt2tQ+kBxjxoyx2djhnb/777+/7ShW9kcgEDDFxa5mOQEAAEAeev311ys8N3LkSNs5rEGGGsTZqFGjjOwbAABArkpa61v//v1Ns2bNbJYNAACAK8HgP49kSvb64Mo555wT9XllYz/33HOcVQAA4F4qSvflSCnAQnTqqafaCjQAAACulRVu/JjUtAyVcgEAAACq8ueff9ps4U6dOtnBhQAAAEC8NCUJAAAAEkd6LwAAyL45hpP9QEb9/PPP5sILLwz9/P3335sOHTqYXr16mXbt2pkPPvggo/sHAAByXCBFDwAAAOSnQOHGj3QMAwAAIKUuu+wys+eee4Z+vvHGG03fvn3Nxo0bzVVXXWVGjRrFFQAAAAAAAAByqZQ0AACAF75g0PiSnOGrdSIzXnvtNVNWVmbefPNN06dPH/Pqq6/a599++20zfPhw88Ybb5jWrVubzz//PPRa7969jc/n45IBAID4BVKQ+pAjGR8AAABwIVC48SMdwwAAAEiJpUuX2o5hPTSnsDKE9f8VK1aYhg0b2tc3b95sH/o3AAAAAAAAgNShYxgAAGSPVMwJzBzDGXPaaafZ/48fP96sWbPGDBs2zFxzzTVmv/32M6effrp97dtvvzWdOnUK/QwAAJAwFYgpS8E6AQAAkJ+ChRs/0jEMAACyBx3DeWns2LG2RLTmEq5bt66ZMmVK6LUHHnjADBkyJKP7BwAAcpzK9vkKsxQgAAAAXAgUbvxIx3AKNPOtNfV8iRcnD/qrudqef80aV8vZbRa726bdbklNV8vVLnF/2xX53f2mFnn4BXc7z2HQw5yWXgaqFLncX5en1nK7qJdteuH2PsrE7vo9zLPpZYpOt7evP+jh28/lNpM9H218G/UwAYW/yKRbIJje5YBI3bt3N/PnzzezZ88222+/vWnSpEnotX79+plu3bpx0owxG1IwvU1lNrtcrihDfyOtzcA2N6d5X2Wxh2WXpvk4pbXLHS7yslG3J7jEwzYbe1i2bgb21+0vajo/hMI1yMA5qpeBc+TlAzRT18bNlxmA9Ono8bMwUSvS//mwhZcZZ2pk4DN7Uwa2WStDMU6ufDeJl6ajTHz3p7/pyJt0fg5lsgMuA02QhdBJaZUaY97P9E4UDjqGAQBA9iBjOG81atTIdhBH2n///TOyPwAAII8UcMYHAAAAXAgUbvyYS+N6AAAAAAAAAAAAAAAukDEMAACyK2O4LMm1eTJRbhwAAADpo3Av2SEfISQAAED+Kivc+JGMYQAAAAAAAAAAAADIc2QMAwCArOELltlHstcJAACAPFbAc8QBAADAhUDhxo9kDAMAAAAAAAAAAABAniNjGAAAZA9l9yY7w5eMYQAAgPxWwHPEAQAAwIWywo0f6RgGAADZIxj855HsdQIAACB/FXApQAAAALgQKNz4kVLSAAAAAAAAAAAAAJDnyBgGAADZg1LSAAAAcFO2L1CYpQABAADgQlnhxo9kDAMAAAAAAAAAAABAniNjGAAAZA1fMGh8yhpO8joBAACQx8pSMEdcjmR8AAAAwIWywo0fyRgGAAAAAAAAAAAAgDxHxjAAAMgezDEMAACARAVyZJ0AAADIDoEcWWcKkDEMAAAAAAAAAAAAAHmOjOEUKFq1zBQF1ya8XLBaTVfb8wU2uVrObrO4hutly1zOAVmtWgPX2yzyuyv6XuRLdrH4qpW63FerzP18mG436+UMud5mBq6L3a7L5fwZ2N8MnSL32/UwlavreWW9zEfrS//4KC/T3QZcfjakezlPyBhGAUv3VDSBHBsAu9EUxrVc52HZ1S6XK8nANhv8bdLP/Z8+3mzIwIUpcrmcP0M3vttf8OoZ+GXzcl1MBq5purlvnvCmgDM+UOC2VkNbGrdXN8c+d71897vd7uYMbLO2h202KoDvpkx+pmciJsuEXLoXMnU/5MjcswUVQwZyZJ0pQMcwAADIHnQMAwAAwE1ja7IH1dKACwAAkL/KCjd+zLWxJwAAAAAAAAAAAACABJExDAAAsoZKirsuK17JOgEAAJDHCrgUIAAAAFwIFG78SMYwAAAAAAAAAAAAAOQ5MoYBAED2KCv755HsdQIAACB/FfAccQAAAHChrHDjRzKGAQAAAAAAAA82btxobrjhBnPQQQeZ3r17m0cffTTuZTdv3myOOeYYs9dee5klS5ZwHQAAAArE9OnTzYABA0zPnj3NWWedZRYuXBj3shMnTrTx4/XXX5/QNukYBgAA2SMYTM0DAAAA+avsf3O6JfORYMaHGvQeeughc+aZZ5p+/fqZ4cOHm7Fjx8a17OWXX25++OEHM2PGDNvBDAAAgPyPH2fMmGF69OhhWrZsaS699FKzePFis88++5jly5dXuewvv/xizjvvPLNs2TIzb968hLZLxzAAAAAAAADg0ueff24zNp544glz7LHHmtNPP91cd9119rF69epKl3399dfNq6++arONAQAAUDhGjRplevXqZW6++WZz+OGHm+eff95Wkrn77rsrXa60tNT861//Mtdcc43tVE4UHcMAACB7BMtS8wAAAED+CqToEacpU6aYJk2a2FJ+jr59+5r169ebTz75JOZyKhutTuTx48eb2rVrez0LAAAAyJH4sbS01EydOtUceeSRoeeqVatmDj30UBtbVmbkyJG2Q/jUU091db2LTRZ66623zDvvvGNq1Khh51jZaaedqlxmxYoV5tlnnzXz5883u+66q+nfv7/x+/+/3/v33383L774ovn5559Nq1at7OtbbLFFuXWoXM9zzz1nZs+ebS9A165dzWGHHWZ8vmTPQA0AAKLxBcvsI5mSvT5kJ5XOUaOqGlg7duxoTjzxRBvPVUVBuALu6tWr29GW7dq1K/e6Xvv4449tPKhyPpo3MNKsWbNspo/iUSfObNasWVKPDwAAVKIsdetctWpVuacVM+gRbsGCBaZFixblnttyyy1t/KDXoq6+rMzGK8OGDTN77rmnef/995N9BIjD5MmTbTyojvnjjjvOxpFV+eOPP2wbpOYA1LVTlnh426HiUbVB6tpvs8025oQTTjANGzYstw4NGtA65s6da9s/u3XrZjOGAABAYcSPy5Yts32SkTGkfn7vvfdibuLtt982Tz31lPnqq69c72bWZQxfccUVtjFNAdXSpUvNHnvsYcvxVOaLL74wHTp0MJMmTTJNmza1ncoKriMnYJ45c6Zp1KiReeONN2yjn0r9ONauXWu6dOliS/fUq1fP9tYPGjSo3HoAAACQfTTwTwMJNbhQcZxK8Oy///5m06ZNMZcJBoM21lNDnuI+DShUY2B4YK049KabbrL/3rBhg23U0zLhHn74YbP77rvbhj/FoYozt912W/PNN9+k8IgBAEC6aNBX/fr1Q4/rr7++wntU8i+ysa+4uNg+9Fo0KjOtWEXtYMiMc88915xyyimmpKTExnJKNFEsVxkNGGzfvr1588037UBADQ4cMmRI6HUNVOzevbv57rvvbBukOojVBqmfHX///bfZZZddzB133GEaNGhg48zjjz/eDB06NKXHCwAA0iPe+FEiY8iaNWvGjB/Vmax2qUceecTGGW5lVcbwDz/8YBvfFDT16dPHPqeTds4559ifFVBH0glSg57qbz/22GPlJl52dO7c2QZgOqFy2WWX2XRsBd/qXZd3333XNuD9+uuvoZrcCgjVQDhu3LgK2cUAACAFUlH6mYzhvDdixAjTtm1b89prr5mioiJzxhln2J8fffRR++9o7r//fjt3izqC1bgnF1xwQblRner0Da9co3hz3333tZk9qiwjatAbPHiwue++++zPF198sc000bKKIQEAQBqobF8wyev8X0i6aNEiO/DMEdl4J2qYU+WQcJpbWG1WjRs3jrp6pw1LFUnEiUH69etnkxT+r737AJOiyto4fmeGIAgDZhQQERNmxJzAHFAR14giCqioa1ZUdAUVc1wV1rCYXTO7Ys6iKKB+ghkDICCYAEkSp7u+571uzdb0dM9UV/V0qPr/9umV6anQc7u66vS9dc+54IILcve3oBbFgKrfp8kle++9t31OM3fPPPNM8/3336fNHrhkyRLbT9i7d28zfPjwtH2QmkGsTITucTJo0CCz55572pSP6u9060prH3PmzKmeSbzZZpvZmPLWW28lrTgAADGJHyU1hpw7d27G+FE3sOkGM/WD6SGKOzS2qsmxynrXokULU1IDw7rLTo3Vo0eP6uf69OljZ3189NFHZpdddqm1jjoAFYC5A7wupWpxbbzxxrXW22KLLeysElebNm3sfxcsWFA9MKwG1uuhzgsAAEBxUhrG559/3s660aCwG9cpFd9zzz2XcWB4xIgRdmaGOygsuonQvZFQUsuZKH4UZbVxaV+KH12a+aNOQ6WPBAAApU/9Qt6OvXS22247O6CngT7VGpYJEyZUTzpIRzeoaaao65NPPrGDkldccUXGdZA7o0ePtvGaOyjs9kHqZr8vvvjCTjJJpYFdxYEa5M3UB6mMhl4aYNZNg95sMoofFcPqZgB3YFh9kOogTtdxDAAAohc/VlZW2qwiGvtUhjqXYshMsaAmLGiSq5cyjigW0URYb59WyQwMf/fdd2b99dev7tQTzfZwf5duYFhppJW2T3/wNddcYzvi1GhHHHFEjRrDXosXL7YBuDsr2b2jTzNH1EGotIFKLT1lyhTbodi8efO021H+bz1cqXnDAQBAlhynAWYM5/r2PxQT1XBT3NaxY8cazyuGVM24dBS/KZvM2WefbZ555hkbdKtj8C9/+Yvp0KFDxn1pFrA669zZwnLfffeZgQMH2k5F7VOlSjTT59xzz824HWJIAABKZ8aHH4cccoid2TFs2DCbMUQzhZUyUHVj3YFC1ZRVqYvBgwfb/iilEvZyB4nVp+UdaETDUD9juvjR/V26gWH1QWoZxXJXXXWVvSFQ/Yl6P9PNMJbff//dlr47+eSTq5/TcaDjRBNjtL5uMtTMIg1Wp8uWKMSPAABEK34UZQu57bbbbNZkxSWaEfzhhx/akrcuxQxjxoyxN6gps3FqduOWLVva5zRj2K+iGhhWkKw/wkuzdTVQrAHfdDQYq7vs9tlnHzsYrLQvSgN477332kZMHRxOJBI2JY+ev/LKK2sEWO+8846tN6cZxupgHDdunPnggw9M9+7d0+5bQb53G9X7aLWuSVTW/Dt8KQtW8rls+eJA64XZp1Ue7PBJhviw/e+WgfwpD3h2SP+VwOe6Gb5QNOR+y0O84IqAK4dpo/IwbRRw1bKkrhYB141LKtsQbRRYmLYtc/J+6iwrD34mC/o5DdpCMTlqUeIUP0pqDKk7LzPFj0rtqJhPwbcC727dupnx48fb2R8aTFZnXap3333XduTecMMN1Zlm5OuvvzaffvqpOeigg+zs41mzZtmAXbNJMg0yZ4ohV7FxR/7kc1+uJiHWDTp/Ru2a79dbXmLvS0EkCrBu5rLj9fvf/cD5O5DCtFEhvjiFeb2NC7DPQrRtRQxODmE+ZyVMKfueffZZc8wxx9ibzhSDqLacJht4+6N0M9qvv/5a0NeKzH2Q7syeuvog1V+o8nRKKa3+St0gqPIlbppoL90goBlAqiOsONKl7asPUoPA6oPUbGEdG3qkmxRTV/xo1g8Z7GSr7slPdfvfBPnspJ+v488qBbg2JQtwrl81xD7XisG1qRQ7OEqpbUsx9ozLcVRKgl4jStxFF11kJk+ebDp37mz7kGbMmGHL7XrHJJUxeeLEiTndb8EGhocMGWJzZUu7du3MJZdcYgNpBUOpQZeC50zTrhXEKVXPo48+ag444AD7nGb9qiFVs8OblloDyCeddJKdmq0AzJun+5///KftCFQju7m9Feipo1Adfemmbmtq9vnnn1/jtSrwBwAAATmJ3N9goG0iEnTT3mOPPVb98+mnn14dz6XGkJqdkSl+VMypm7C0rndW8ZFHHmk77bQfL3XSHXroobbWn3cmsHvDoWoOux11qiOn+FExojqI0yGGBACgBDpqs9zm7rvvbqZPn25vGlOGEW+5ClE2OsUYShmYKR21fk85itxTn6OyB4raXxNKFA/++OOPteJHqasPUjf/afBfs8FFMaJm/erGQMWArqqqKjso/M0339jfebd55513mvfee89MmzatenBaHcCaea4UkanHjhA/AgAQvfixUaNG5qGHHrKTEJQRT5lJWrVqVWMZxS19+/bNuA1NktWE2az2awpEgZg75dn9r+q26S47pc9x/xAF1KJ6HOlsueWW9r/egdvNNtvMppbWIK93ULhfv37mzTfftIPCqXWHVZxZqXrcQWHp2rWr/a+CuHQDwwr0qf0BAACQHwqOFed5M8to9q7iN8WMhx9+ePXv9HOm+FFxpmLR1PhOP7///vs1nlMKH918qNkgqmPsNW/ePHuDohszejt2X3/99Yx/BzEkAADRpM69dCmIRZnr6krxp4HDbFIAwj/1AbpZZtZbb73qPsjnn3/e3ujnlrQL0geplOC64VB9kO7AsAaFjzvuOJt6Wn2QqVlk1AepwV/vjGXFk8po4/4uFfEjAADR1aZNmxrZ6bwUR9RV9ixT3FKUSQlOPPFEmzdbD6XakZ49e9rgSSPkruHDh9t6LNtss439WYGc1tHMDdFs3tVWW828+uqr1evorjst5wZqCqyUq/u1114zb7/9dtoAS4G7gq+pU6dWP6dU1N7ADwAANCwnmWyQB6JBwa4bP+rh1t9TLPnwww/b1H6i+sHqhHNjTHn66adrpN/r3bu3jQuV4s+9ifCNN96o0dGnLDP777+/HRTW3ZupdHOjAnc3ZhRt76233srYKQwAABqAwr1Ejh+EkJGhPkE3flQZOtF/lfnviSeeqF5uxIgR9ga/jTbaqDojjdaZNGmS/Vm1hHVjorcPUjcDqt/RrRmtgebjjz++OlthunrRihM///xzW4LEpXhSA8wasAYAAHmQjG/8WFQ1hnXXntKpnHPOOTYg0iyMzz77zLz00kvVNVdVC1iDxdtvv73Zaaed7B2V999/vx1oVj0PzQAZPXq0zc296667Vhdn1kxkzfbQ9r1pfJSvW5RietSoUXa7Sj+tjkXt97LLLmNgGACAfEk2QCrpQtS+Rl5dffXVti6wOvI020I3A2pQWKmhXUrhp/hS5Uzk4osvts+pY04x4yeffGIWLFhg13VjTsWOmvmj1IPqFHSpbMmee+5p/33ffffZzj917mk2ytixY22HoOrAAQCAPFEn3J/dRrnj5Hh7KCrKHnPTTTeZU0891fYnKn2jJoy4saAoBlQfpNI8a+BXNwUqXaPSOT7++OO2r/KFF14wQ4cOrZ7QogwzTz31lE0LffPNN1dvS5NaFLO65VDUd6ltKnW0BqA12Dxs2DDTsWPHArQGAAAxlIxv/Fjm6La2IjNlyhTz7rvv2jQp6pDz1gJesWKFDcL23XffGqkEFcBplodS86hD0Ps71WhR+pZU2v4pp5xS4znd0afUMU2aNLHbSU05XRfdaagUh79N/95UVv4vHYxvZcEmcJct/7NOSrCVg08adxpnl7fctbiiReB9Nq4I9kmt+O+NBUGUB/w0L6kK/tFKhPhUBmwiUx7iJFgRcOUw593yEO9p0FXLQgwulTklcrtQKQ7AhWnboOfA8j9TjQWRrGgceN3lVcH+1oUrgq23aOFCs2XHtnawLFOdrVxxr6HzJrxgKlusmtttL/7DrL7TIXn5O1A4ihHVkaeYUDMt3BsEXYotZ8yYYWsCuzRLWLOGVd+tXbt2dnDZLROimb/33HNP2n0pTaB3RvDcuXPtgLDSSq+//vq287Bx48ZZH//r5zmdzwqTf01CrNsu4HrBItZwrzfM+/i/6oTZ2y7gev8rppO92vOg/GkdppFaB1wv+CXYmDCXjwBfDa0wbRQ8VAkuUYD3NMwHvHkB2jbMugXL95adhSuMafWEyVvc5V5DF7QypjLHHXsLHWNaLcjf34LCUPk4lRLR5BH1QWoA16VJIw888IDNVuitDa3axMoQoxsId9xxx+oZxm7MqUkuqVTTWJNSvMaPH2/3r3J4qlOczaBw9bF/tTGVYc6F2ZoXYt1lAdf7OcQ+w7RN0LghWYBzfZiv0H9WeIz0tckqtW65UmrbUow943IclZCFy4xpdVV+4q6FxI/FOTBcqhgY9oeB4foxMFw/BoaLFAPD9TcRA8N1DwyPe65hBoZ36UmnHooWA8P+MDBcPwaG68HAcMNiYLh+DAw3XMdeiwYaGF7MwDCKEwPDPjEwXD8GhosTA8P1Y2A4UgoyMNwivvFjqZ1iAAAAAAAAAAAAAAClXGMYAADEm5NI2EeutwkAAIAIS8S3RhwAAAACSMQ3fmTGMAAAAAAAAAAAAABEHDOGAQBA8Ugm/3zkepsAAACIrmR8Z3wAAAAggGR840dmDAMAAAAAAAAAAABAxDFjGAAAFNmM4RzXBGbGMAAAQLTFuEYcAAAAAkjEN35kYBgAABQNJ5mwj1xvEwAAABEW4449AAAABJCIb/xIKmkAAAAAAAAAAAAAiDhmDAMAgOLhKJV0MvfbBAAAQHQ5pTNDAwAAAEXAiW/8yMBwA6iYP8tUJFpkvZ7TuGmg/ZWtXG4Ca9Q48KrJxMpA6zVv1TLvnftliaoQ+wx2dmhcEez9lPJk8DNSWVmw/AflIdImBF21POBrLUVOWTwSNJSVFWIALkTbBjwGw7yfiRCf74ST330mAp7/AASzIs/pfIJFcoUTNOJNFqCNgkfYxswPse68gOuFSbjfJOB6y0K8MasG/EPDfL5W/S3EyqvkuXFLUcs8t600L8AHPIwKUxpCfPUGEED7EOezIFqHWHdZwPVCdCOGuk40LqHAKngXpDFrxeDaVMgvP/HoDiw9hei+pMpZ3Zbk6X2AxcAwAAAoGtQYBgAAQJC+1lz3t9J/CwAAEF2JGMeP3LMCAAAAAAAAAAAAABHHjGEAAFA8kok/H7neJgAAACIrzjM+AAAAkL1EjONHZgwDAAAAAAAAAAAAQMQxYxgAABSPZPLPR663CQAAgMhStJfriI8IEgAAILqSMY4fmTEMAAAAAAAAAAAAABHHjGEAAFA0nETCPnK9TQAAAERXnGvEAQAAIHuJGMePDAwDAIAiSyWd4zCKVNIAAACRFudUgAAAAMheMsbxI6mkAQAAAAAAAAAAACDimDEMAACKh2YL53zGcKkkcgEAAEAQcU4FCAAAgOwlYhw/MmMYAAAAAAAAAAAAACKOGcMAAKBoOMmkfeR6mwAAAIiuZAPM0CCCBAAAiK5kjONHZgwDAAAAAAAAAAAAQMQxYxgAABQPagwDAAAg2xCyAWZolMqMDwAAAGQvGeP4kYHhBvD76puYqsrKrNdrUlEWaH/Nqv4wgTn5P1RXOsHXrSirCLReeYi58WUB2ygZ4u8MozzYYWTKQu0z2NoBVwutzAn45pQFP5CcQv2x+RaijQpxPgr6epMhPjFVieB/54pEsGN3RcAT0spCnciAmGqlWCeP+1tpSitdUfOA64Vp08YF2GeYdRcFXG9FiH0uD7jeLFNamoQIU8qXBFwx6HoFEiaSazU/2HqrhNjnqnk+L4SVz+uDKcB5CEBAuxtjWuax9RaEWHdFAfYZNIAs1Im3PM8XNWldgNdbiJGTMAFvGIX4W3OdG7dYFeLvLJVRv1JEEJlXDAwDAIDi4ST+nDWc620CAAAgshTt5TriI4IEAACIrkSM40cGhgEAQNFwkkn7yPU2AQAAEF1x7tgDAABA9hIxjh/DZHMDAAAAAAAAAAAAAJQAZgwDAIDiodm9uU4lzYxhAACASFN+mFzniCHnDAAAQHQlYxw/MmMYAAAAAAAAAAAAACKOGcMAAKB4aLZwzmcMl0qFDwAAAAQR5xpxAAAAyF4ixvEjM4YBAAAAAAAAAAAAIOKYMQwAAIqGk0jYR663CQAAgOiKc404AAAAZC8Z4/iRGcMAAAAAAAAAAAAAEHHMGAYAAMUjmfzzkett5sGkSZPso1u3bqZjx4552ScAAAD+nJ2RiOmMDwAAAGQvGeP4kYFhAABQPJKJPx+53mYD+uCDD8yFF15oFi1aZL744gvz+OOPMzAMAACQR4r2ch3xUYwEAAAguhIxjh9JJQ0AABDC8uXLzc0332wmTpxIOwIAAAAAAAAoWswYBgAARcNJJuwj19tsSHvttZf9b1VVVYPuBwAAAJnT9iVjmgoQAAAA2UvGOH5kYBgAAMTCwoULa/zctGlT+wAAAAAAAACAOGBguAEsqUqaipXZ3xvgOGWB9rdKRWMTWIhZVGVOsPsfkk7gXZqKYE1UckK1UcD1ysuCN27QVcucEH9owOOvUMpC/KmlJOh5oVCCvi1l5UE/aYWRSOZ3vTCcZNI+cr1Nad++fY3nhwwZYoYOHVpr+f/7v/8zn3/+eZ3bPPjgg83aa6+d09cJ6MySz7NLIWrflNbZszBtFGafywqwz6Bn7BDfYAK/3jBXF2owNWz7Lgq4Xpjbu1YtwHmsPAbnz8UF2m+ca8Qh5tZqb0xlHq9Sa/8cfF1nebD1FgTfpWkeYt0wwUpQZUGvbC1C7LRtAYYWqmJ2hcp3G8Ulm1kh/s64tG0BLFQvbc0JHQ0tEeP4kYFhAAAQCzNnzjSVlZXVP2eaLTx16lTzzjvv1Lmt3XbbjYFhAAAAAAAAACWFgWEAAFA0nKRjnBxPVdY2RYPC3oHhTI466ij7AAAAQGmI84wPAAAAZC8R4/iRjFgAAAAAAAAAAAAAEHHMGAYAAEVDs4VzPmO4gYslz5o1y7z++usm+d9axmPGjDHLli0zm266qdlll10adN8AAAD4s8Z1riO+ho0gAQAAUEjJGMePDAwDAICi4SST9pHrbTakefPmVdck7tu3r1m6dKn9uaysjIFhAACAPIhzKkAAAABkLxHj+JGBYQAAgBC22mor8+CDD9KGAAAAAAAAAIoaA8MAAKBolGIqaQAAABSW0wCp+7RNAAAARJMT4/ixvNAvAAAAAAAAAAAAAADQsJgxDAAAigYzhgEAAJCtONeIAwAAQPYSMY4fmTEMAAAAAAAAAAAAABHHjGEAAFA0nETCJBOJnG8TAAAA0RXnGR8AAADIXiLG8SMzhgEAAAAAAAAAAAAg4pgxDAAAiobjJI2TTOZ8mwAAAIguRXu5jviIIAEAAKIrGeP4kYFhAABQNJxE0j5yvU0AAABEV5xTAQIAACB7iRjHj6SSBgAAAAAAAAAAAICIY8ZwA1iZdOwj6zcjWRZof07j4G9jsD3+d79OsPsKHCf7tnElAq5aVl4ReJ8m4N+ZqAr+dwZf05hEgGMv7G0iFQGPpDDHX1mY1LCFSCsb4rgvKSWWsjfwuaEs+AemrCz4kZ8MeBwl8rxeGMwYRpyV5/muzRDRERrQyhDrLivAXc2JAhx/QfdZqCglLndjJwvQRk0K8FlrbAqjVM7ZfxRov3Ge8YG42y3k2TBbc4KvWhYwUmn9c/B9mjVDrLtKiHXzvc/WIfbZtsSGFqoCrrfYFEZVntcLu26+ldrVtpTattRer6Lzf+d1j4kYx49x+Y4KAAAAAAAAAAAAALHFjGEAAFA0nKRjnGSOawwHzaQAAACAkpBsgKwApZULCQAAANlIxjh+ZMYwAAAAAAAAAAAAAEQcM4YBAEDRSCaS9pHrbQIAACC6kg1Q040IEgAAILqSMY4fmTEMAAAAAAAAAAAAABHHjGEAAFA0nETSPnK9TQAAAERXnGvEAQAAIHvJGMePDAwDAICiwcAwAAAAspVogFSAud4eAAAAikcixvEjqaQBAAAAAAAAAAAAIOKYMQwAAIqG4ySNk8xxKmmnVBK5AAAAIIg4z/gAAABA9hIxjh+ZMQwAAAAAAAAAAAAAEceMYQAAUDSoMQwAAIBsKT9MrnPEkHMGAAAgupIxjh+ZMQwAAAAAAAAAAAAAEceMYQAAUDSYMQwAAIBSrBG3fPlyc9ttt5k33njDNG3a1Bx11FHmpJNOqnOdd9991zz66KNmypQppl27dmbAgAFmjz32CPW6AQAAUBrxo4wfP97ccccdZvbs2aZz587m0ksvNeuvv77JZP78+eaee+4xY8eOtT/vuuuu5qyzzjItWrQwfjFjGAAAAAAAAAihd+/eZuTIkWbgwIGmV69e5uyzzzbDhg3LuLw69P72t7+ZHXbYwQwePNh06tTJ7LXXXubxxx/nfQAAAIiBCRMmmG7dupm2bduaQYMG2cFhDfTOnTs34zo77rijHRw+7bTTTL9+/cxTTz1lunfvbm9S9IsZww2gouzPR7bKA6xTUE7AjOml9ncG5IRYNxli5aDNWxF8l/HhOAXYZ6lUJvhTWYm9XscprfujnIDHYCKZ3/XCSCaT9pHrbQIofbm+k7chrQyx7rIQ6y4KuF6Yq2FFAWLPFQHXC3M1KK2IIbhCXTGDHverhNhn84DrNTaFUSrf15bEdMbHxx9/bEaNGmXGjRtndt55Z/vcsmXLbAffOeecY1q2bFlrneOPP9526Ln22Wcf88MPP9hZx8cdd1xO/gbEQeeQZ8Ns/Rxi3aqA67UJsc81Qqybz3YNu881Q+yzbYh1CzG0EPQ4WmwKI5HnvzPsN4pSUhWTfcaFjtt/xyp+lCuuuMLst99+5qabbrI/77vvvqZ9+/bmrrvuMkOGDDHpfPLJJzVmB2+zzTb2BsMxY8aY/fff3/gRl++3AACghFJJ5/oBAACA6NLtjMkcP7K5RVLpo9dcc83qQWHp2bOnWbp0qfnggw/SrpMu3Z+eW7Ei6O0vAAAAKJX4saqqyg7mHnroodXPNWnSxBx44IE2tswkNYZ0f84mhmTGMAAAAAAAAJDGwoULa/ys+sF6eE2fPt2st956NZ5bd911TVlZmf2dHzNnzjQPP/ywOffcc3kfAAAAIh4//vLLLzb9c2oMqZ/ffvtt3/u65pprzOqrr2722GMP3+swYxgAABSNP2f4JnL8YMYwAABAlCUa6CFK59eqVavqx3XXXVdr/ytXrqzV2deoUSP70O/qs2DBAjvDePPNN7f1hgEAABD9+FFSY8hmzZr5ih/l/vvvN8OHDzcPPfSQ3Y9fzBgGAAAAAAAAMszkraysrP45tfNONEtj3rx5NZ5btGiR7dRbY426a5xqOaUMrKioMC+99JJNIQgAAIDox4+SGkPOnTu33vhRHn30UTNw4ECbceaQQw4x2WDGMAAAKBpOMtkgDwAAAERXsoEeok497yNdx952221nfvjhBzNnzpzq5yZMmGD/26VLl3oHhTWA/Prrr5vWrVs3QOsAAACg2OLHyspK06lTJ/PRRx/VeF4xZF3xo/zrX/8y/fv3tzOGe/funfWby8AwAAAAAAAAEJBmaWhmx7Bhw+zPGuhVysDddtvNbLrppva5pUuXmp133tmMHj3a/rx48WJz0EEH2dpyDAoDAADET//+/c0jjzxipk2bZn9+5ZVXzIcffmifd91+++2mV69e1T8/+eST5uSTT7aDwieccEKg/ZJKGgAAFA07wzfHNYGZMQwAABBt3ppuudymXy1atDDPPvusOeaYY8wzzzxjlixZYmvLPffcc//bXiJhZ4D8+uuv9udbb73VvP/++6Zz5852gNjVvHlz89Zbb+X0bwEAAEBxxY9y0UUXmcmTJ9t4sEOHDmbGjBnmxhtvNN27dzcuZaWZOHGi/feKFSvsYLDixTvvvNM+XOedd56NRf1gYBgAAAAAAAAIYffddzfTp083X3/9tU0XuMkmm9T4vTrwxo0bZ1MGSr9+/cz+++9fazuqNQwAAIDoa9SokXnooYfMDTfcYH766Sez4YYbmlatWtVYRgO+ffv2tf9u3Lixee+999Jua4MNNvC/35CvGwAAIHcSuZ8xrG0CAAAguophxofbubfVVlul/V15eblNJe1q166dfQAAACC+8aO0adPGPtLRTGI9pKysrEY8GVTRDgxPmTLF/te9k7I+VVVVZtasWaZJkya2AdVA2SyTTCbNV199VWsdBemtW7cO9bcAAAB/komkfeRSrreH4rVw4UKbdkd3SSqlox+///67mTdvnll33XXtTJ5sl/n555/NnDlzajynWUIbb7xxiL8EAABkQ9FeriM+Isj4+O677+ygfseOHX0trxrS6l9cZZVVzDrrrJO2D7KuZdQ/qbSRqdZff31TWVkZ8q8BAAB+JGMcP5abIuI4jhk5cqTZfvvt7R2WfvNhqy7Lmmuuafbcc0+zzTbb2EDupZdeymoZ1X/RPnv27GmOPfbY6seYMWNy/ncCAAAgd7755htz2mmnmY022sjGc2PHjq13nWnTptmUj6r/pzSOa6yxhjnxxBPN8uXLs1rm+uuvN7vuumuN+PGcc87h7QUAAChiqvl899132z5CPU4++WRf611zzTU2JlTtvy233NLeDJhaE7q+ZXRToWLWXr161YghVYMaAAAgVgPDupvugw8+MCNGjDCnnnqqr3U+/vhjc8EFF5h7773X1nLRrI0jjjjCHH300bYQs99lXI899pj54osvqh8aKAYAAPnhJJMN8kC0qb5Kly5dzIcffuh7ndNPP91mjFFcqEw1n3/+uXn++efN7bffntUyohsPvfFj6g2KAAAgP6kAc/1AdC1atMhMmjTJ1vXr3bu3r3Xeeecdc/nll5snnnjC/PDDD+aXX34x++yzjznqqKNszOh3Gde///3vGjHkfvvt1yB/KwAAqC0R4/ixqAaGleJZM4Z33HFH3+v8+OOP9r8HHXRQdc2WAw880Pzxxx825Z/fZVwLFiywHX8apAYAAEDxGzBggBk4cKDv9NFufLjHHntUr6PZxprNMXPmzKyWEXXyTZ06tVZKaQAAABQnlY3TjOFtt93W9zqKDdWnqEwyUlFRYQ444ADbt6g+Rr/LeMuVKIZUamkAAIB8Kdoaw34puFLq6TPPPNOcccYZNsi64oorzCmnnFJdrNnPMi6lcVG6F93RpzQyt9xyS1adjAAAIDgnkbSPXMr19hANF198sbnkkktM165dzYYbbmjefvttW5/4gQceyGoZefnll023bt1s517btm3NP/7xD7P33nsX4K8CACCekg0wQ4MIEqkOO+wws/nmm9u+xf79+9vJJVdffbU577zzTMuWLX0v49IEFg1Q//bbb/YmxxtuuMHWJAYAAA0vGeP4seQHhps1a2Zrd/Tt29d21i1dutR06NDBXHjhhVktozv47rjjDhuINW7c2Hz22Wc2QNMMkPvuuy/tvlVfzltjbuHChQ381wIAACAXDj/8cPPqq6/aGwHXWWcdmy76qquuMltssUVWy+yyyy7mr3/9q51NrBIlgwYNsh2CiiU1mJwOMSQAAEDpqaysNNdee63p16+feeWVV8zixYvNpptuas4666ysllG/o8rdKcZs1KiRLYGnPkjNNL7tttvS7pv4EQAAlPzA8Lfffltd31cDt506dQq0nbFjx5oePXqYJ5980tYN1kCuannstttu5ptvvjGrr766r2X0GrxB2tZbb20uvfRSc9FFF9nUMho4TnXdddeZK6+8stbzTcrLTZOK7LN0NyovC9ACxpQlSyvtddC/UyoCrlueCNFGTrD7PBqVNwm+S8fJexsFf1cKwykv+ftaIskJ+HkpmLJgFRVWBv+Imqpk8JVXBlx3WVWw92V5wPXCcBKOfeR6m4gGzcidNWtW9c+60S915oVfGvTV9fann36yHXjff/+92X333W18OnjwYN/LHHPMMTXKotx8883m0UcfNU8//bSdcZxOphgymefrcanUvnH973bM/P2dQSPIZSH2uWqIdacXoI3C/K1BLYnJMV9iUVWo9m0dcL3GIfbZPOB6wb/lFaYOWO2ejIb1Zy9PYT4vyZh/BpHZ5MmTq9M1r7rqqqZjx46Bmuu1116z/YrPP/+8LVGXSCTM+eefb+ND7UNxqZ9llKlQWQxdynJ4wQUXmBtvvDHjwHCm+NGYziHOaEGsU4ArxeIQ+2wVYt1CzN5ukecrqbQNsW4p9c0tCLFuIdK9h4mySyk9fVWM9ltK70sh1Cy3kA/JGMePBasxrEHYY4891j4ydZr5MWrUKDtDQ0GX6O46bU813t58803fy6TTrl07s2zZMpvSJR0NHCsljPtIrTcHAACA3FHmFzd+1GPixImBtqMab2+99ZYtM6IBX1GseNRRR9kbCf0uk45mfahUSV1xITEkAABA/mgQ1o0fhwwZEng7zzzzjK1JrAFf0SQSZYuZPXu2nZTid5lMfZC6CVIzjNMhfgQAALlSsNt6lJYvCM32/eqrr2zApDocq622mpk/f769A8+d1esO5Op37n/rW0YzPzTLw2vMmDH292uttVba19K0aVP7AAAAuaHrfDLHNYG1TUSDbvJzb/TLlmb9qqNt4403Ni1atLAp/HSToJfiQzc29LNMuhhSnX6aWXzaaadlfC3EkAAA5FaiAbIClFqWAWT23nvvBWoezTLWLN/111/f3iioGHDu3Lk2o0xZWVnGPsj6lsnUB7neeuvZGDQd4kcAAHIrEeP4sejyPagjTbN0FUTpv1988YV9fvPNN7czfVXHd6uttjIPPPCAOemkk8xxxx1nU62ceOKJ5owzzjB//PGHueKKK0znzp1tqmjxs8xdd91l01urJpwGnF966SX7nFK4pEsjDQAAgOLgZm7RjYAyffp0G0Pq5j7VBpZrrrnG1nlTrKmOuL59+9p4UJ1vGizWbGSlf3744Yft8n6WcVP/nX322WbLLbe0g8JDhw61nYeKUwEAAFC83DJ3mqmrvkK3D1Jxnfz888+2D1Lx35FHHmn69Olj7rjjDjNgwAD7UOyp8iLbbbed6dq1q13HzzLqo/zll19s2Tulln7uuedsP+d9991XwNYAAABxUXQDw6rp+91331X/rDQv8tFHH9k6wBqk3WKLLarvslNKvwkTJphbbrnFrqtOvD333NP+W8v7Xebcc881jz32mK0nrDv5NtxwQ5tmWssBAID8cJKOfeR6m4i2cePGmQsvvND+W3HinXfeaR/qjFOMJ5qBsckmm1SvM3z4cLP11lvbesCaFazB3NGjR9sOumyWUUferbfeau6//37TqlUrc/TRR9t9ZprtAQAAci/ONeIQrszdrFmzavVBugPEyh6j2FIxnjtgPH78eDuJRHWD1ad40EEH2ThUy/pdRmmhH3zwQTshRRNjdAPi+++/b3baaSfeTgAA8iQZ4/ixzFFuE+SEZjMrWPz6h9mm5X9r0WWjScWfKWayVVm+0hREMtjE+JWN/hyMD6KiPFgblSdCtJET7OO8rKxJ8F2G+FgGbaNga/2p/L/pkbJez3D6iZyAn5eCKSsPtNrKEIfuikTwlRcuD3be/eWPYOfAPxYtNPtu1dHOxnRrrDb0NXTs4fuaFo1ze9/a4pVVZvf/vJGXvwMIc/xvrut4HptwhSktlQVI5RQ0glwWYp8bh1j3z+7m/LZRmL81qCURT+vlKrGoKlT7ts7zMS/NA64X/FteOMGi1vxeV9xry1P/zeaRj7jLvYZeYYxZJcfb1vntqjz+LUCQY3/BgqdMZWXQM1oQNcus5OdKkb7usj9/DuoHk+uzih8t8nwllbZRmnNWhwUh1q0y+besxF5vqb3WQuy3lN6X/Fu48A/TqtVf8toHeUWM48eg3y0AAAAAAAAAAAAAACWilG7rAQAAEeckksYpT+Z8mwAAAIiuRANkBSi1LAMAAADwLxHj+JEZwwAAAAAAAAAAAAAQccwYBgAARcNJOMYpd3K+TQAAAESX8sPkOkcMOWcAAACiKxnj+JEZwwAAAAAAAAAAAAAQccwYBgAARSOZcEwyxzOGtU0AAABEV7IBarqVyowPAAAAZC8Z4/iRGcMAAAAAAAAAAAAAEHHMGAYAAEXDSSSNU57M+TYBAAAQXYkGmPGR6+0BAACgeCRiHD8yMAwAAIpG0nFMMpnjVNIOqaQBAACiTLcB5vpWQG4tBAAAiK5kjONHBoYbwFpVc0zlyuVZr+ckgr0d5csXBVrP7rOiSeB1TVmwTOSNV60Ivs+gdSKd/H8kGzcuC7xumHKYQfdaXhb89QZd1Qn8aktPqY1LBR1IqygP8fkuqfcl+Bua4zFPABGyJM91Xlaa0lJRgL8z6LrLQuxzfoh1ywvQRkH/1mQB9llqx3yp3G2ei9cb9D1tHGKfqxZgn2GUSpRdVegXAAAF7/puVIB1C7HPsOvm+0pTqGGQQrzeUroaF+rvbFRC+4wL2iefaG0AAFA8Eo5xynI8eh7mbhsAAAAUvTinAgQAAED2EjGOH/M5KQEAAAAAAAAAAAAAUADMGAYAAEUjmUiaZFky59sEAABAdMW5RhwAAACyl4xx/MiMYQAAAAAAAAAAAACIOGYMAwCAouE0QI1hbRMAAADRFecacQAAAMheIsbxIzOGAQAAAAAAAAAAACDimDEMAACKBjOGAQAAkK04z/gAAABA9hIxjh8ZGAYAAEUjmUiaZFky59sEAABAdKlwSK4jPoqRAAAARJcT4/iRVNIAAAAAAAAAAAAAEHHMGAYAAEXDcRzjJJ2cbxMAAADRFedUgAAAAMheIsbxIzOGAQAAAAAAAAAAACDimDEMAACKRjLhmGSOK3JomwAAAIiuOM/4AAAAQPYSMY4fmTEMAAAAAAAAAAAAABHHjGEAAFA0nIRjNGc419sEAABAdCl6zG0EmfvtAQAAoHgkYxw/MjBcTMoDTuAuCzHxO8y6cRGwjcrKQuyyxMYwnICvN0wbldLfWSjJEnvBZYV4vQEPwjCf0fIQx315wNfbOOD1pVHQ6xIAFBHOZAAAILoq8ty92yhG3deNCvB6C7HPQuD10r6uqhgdR6XWvogyPj0AAKDIZgzn9iYBZgwDAABEW5xrxAEAACB7iRjHjwwMAwCAopFMKJG0k/NtAgAAILrinAoQAAAA2UvGOH4ksxoAAAAAAAAAAAAARBwzhgEAQNFwkknj5LgAubYJAACA6IpzKkAAAABkLxHj+JEZwwAAAAAAAAAAAAAQccwYBgAARYMawwAAAMg6hmyAGRrknAEAAIiuZIzjR2YMAwAAAAAAAAAAAEDEMWMYAAAUDSfpGP0v19sEAABAdCUbYIZGqcz4AAAAQPaSMY4fmTEMAAAAAAAAAAAAABHHjGEAAFA8EknjOGW53WayVO7XAwAAQBCJBpj5kOuacwAAACgeiRjHj8wYBgAARSOZcBrk0ZAmTZpkevfubdq2bWvatGljDjvsMPP555836D4BAABQsxOuIR4AAACIpkSM40cGhgEAAEIYNGiQ6dmzp/noo4/MJ598Ylq3bm323ntv8/PPP9OuAAAAAAAAAIoGqaQBAEDRcBKOcZzczvB1kg07Y/i1116r8fPdd99tWrZsad58801z/PHHN+i+AQAAYIwKh+S6eAjFSAAAAKIrGeP4kRnDAAAAOTR//nyTTCbt4DAAAAAAAAAAFAtmDAMAgKKRdBz7yPU2ZeHChTWeb9q0qX3k2rnnnms6dOhg9t1335xvGwAAALUlGmDmQ6nUiAMAAED2EjGOHxkYbgBOkxbGadoi+/XKgh2GTsVyE1h5hcm7gH9nuMn4IfZZVhZstRADG+UB91kohXi5OR43Qmr7BmyRMMe9cYJ9vssCrmfXDbpiRePA+2wUookalQd7xY0r8rtesWrfvn2Nn4cMGWKGDh1aa7nLLrvM3HDDDXVua8yYMWa33Xar9fzgwYPNK6+8YtNIN2/ePAevGnGiaCWfkVmppDhyVRTgi1nQCDJMtFtegDYKcywU4NtEYKTLKl4VBTj+ykvsmC+V47dUXieAuAjT9R2XbvO4tFGY11plSkspvS+mxN6XUjuOSulYKKXXWvpobQAAUDQSjmMfud6mzJw501RWVlY/n2m28NVXX22uvPLKOrfZqFHtEEqDzHfeead5+eWXzQ477BD6dQMAAMCfONeIAwAAQPaSMY4fGRgGAACxoEFh78BwJuXl5faRDQ0k33LLLeall14yu+++e4hXCQAAAAAAAAANg4FhAABQNBLOn49cb7MhXXPNNebmm2+2g8J77LFHw+4MAAAAaWdnJGI64wMAAADZS8Y4fqT8CwAAKLpU0rl+NCSlkP7jjz/MXnvtZVNMu49rr722QfcLAACAPyUa6AEAAIBoSsQ4fmTGMAAAQAjLli0zTprB54qKCtoVAAAAAAAAQNFgYBgAABSNUkwlzQAwAABAYSUbIHVfqaQCBAAAQPaSMY4fSSUNAAAAAAAAAAAAABHHjGEAAFA0kg1QE1jbBAAAQHSpnltZA2wTAAAA0ZSIcfzIjGEAAAAAAAAAAAAAiDhmDAMAgKKhO+tyXmM4t5sDAABAkYnzjA8AAABkLxHj+JEZwwAAAAAAAAAAAAAQccwYBgAARUP1hRMmt1OGc12zGAAAAMUl+d9HrrcJAACAaErGOH5kYBgAABQNpZHOddqVXKemBgAAQHGJcypAAAAAZC8R4/iRVNIAAAAAAAAAAAAAEHHMGG4AycarmGTjZiZfnIrGwVeuCHEIOKUyMT6ksmD3T5QlqwLvsjzgPkMJs8+As/Gcslzfk4OCC3FeCPqZKUusNPlWHuLvbNKoafB1K8pKYr0wmDGMONOVOJ8RQFzuEK0IsW6yxF5vRQHuag7zeoOKy7EbJ+Ul9Hkp1PFXiM9aEE4B95vrczZJZ4C4C9qvR3c7kB9hPmvB++0RHU6M40e+UwMAAAAAAAAAAABAxHELEwAAKBoJxzGJHN9fp20CAAAguhqinlup1IgDAABA9hIxjh+ZMQwAAAAAAAAAAAAAEceMYQAAUDSSTu7vrtM2AQAAEF1xnvEBAACA7CViHD8yYxgAAAAAAAAIYfny5eb66683++67r+nRo4d58MEHG2QdAAAARMf48eNN7969Tffu3c3pp59uZsyY0SDreDEwDAAAiqvGcAM8AAAAEF3JBnpkQ51zI0eONAMHDjS9evUyZ599thk2bFjO1wEAAEA04scJEyaYbt26mbZt25pBgwaZ2bNnm1133dXMnTs3p+ukIpU0AAAoGokGSCWtbQIAACC6Cp0K8OOPPzajRo0y48aNMzvvvLN9btmyZbaz7pxzzjEtW7bMyToAAACIRvwoV1xxhdlvv/3MTTfdZH9WFpn27dubu+66ywwZMsTkap1UzBgGAAAAAAAAAnrjjTfMmmuuWT3AKz179jRLly41H3zwQc7WAQAAQDRUVVWZMWPGmEMPPbT6uSZNmpgDDzzQxom5WicdZgwDAIAimzGc2ym+zBgGAACItoac8bFw4cIazzdt2tQ+vKZPn27WW2+9Gs+tu+66pqyszP4unSDrAAAAIBrx4y+//GKWL19eKx7Uz2+//Xba7QdZJx1mDAMAAAAAAABpKDVfq1atqh/XXXddrWVWrlxZq7OvUaNG9qHfpRNkHQAAAEQnfpTUeLBZs2Z1xo/ZrpMOM4YBAEDRoMYwAAAAspU0xpQ1wDZl5syZprKysvr51I44WX311c28efNqPLdo0SLbQbfGGmuk3X6QdQAAABCd+FFS48G5c+fWGT9mu046zBgGAAAAAAAA0lCnnveRrmNvu+22Mz/88IOZM2dO9XMTJkyw/+3SpUvadg2yDgAAAKIRP1ZWVppOnTqZjz76qMbzigczxYJB1kmHgWEAAFA0Eo7TIA8AAABEV/K/Nd1y+XBnfPhxyCGH2Fkaw4YNsz9r1q9SBu62225m0003tc8tXbrU7Lzzzmb06NG+1wEAAEA040fp37+/eeSRR8y0adPsz6+88or58MMP7fOu22+/3fTq1SurdepDKmkAAAAAAAAgoBYtWphnn33WHHPMMeaZZ54xS5YssbXlnnvuueplEomEnc3x66+/+l4HAAAA0XXRRReZyZMnm86dO5sOHTqYGTNmmBtvvNF07969ehllmJk4cWJW69SHgWEAAFA0nAB31/nZJgAAAKIrWQTb3H333c306dPN119/bdMFbrLJJjV+37x5czNu3Dib/s/vOgAAAIhu/NioUSPz0EMPmRtuuMH89NNPZsMNNzStWrWqscx5551n+vbtm9U69e43y9eJYlQeIiN4WQGyiTshPnJB04GWBS8jnqxoHGi9iuWLC/O+BF23vMLkmxOwbUtRsgCpbMPsMRn0oxbiklqWWBlsxZXLgu8z6PmoUZPA+yxPKrFIMM0aNQu4XrDzQlXA9QAAAIA4UkfdVlttlfZ35eXlNpV0NusAAAAg+tq0aWMf6WhWsB7ZrFMfBoYBAEDRsDWBczzHlxrDAAAA0aZbL50SmEUCAACA4pCIcfzIwDAAACgaCefPwCzX2wQAAEB0xbljDwAAANlLxDh+JEckAAAAAAAAAAAAAEQcM4YBAEDRIJU0AAAAimF2RqnM+AAAAED2kjGOH5kxDAAAAAAAAAAAAAARx4xhAABQNKgxDAAAgKxjyBjXiAMAAED2EjGOH5kxDAAAAAAAAAAAAAARx4xhAABQNKgxDAAAgCCzM3I94yPX2wMAAEDxSMY4fmTGMAAAAAAAAAAAAABEXNENDH/33XfmvPPOM/vuu6858sgjzQMPPGCqqqrqXGfRokXm7rvvNnvttZc5+eST61x2xYoVplevXmbnnXc2v/32W43fvfPOO+aUU04x++yzjznppJPM2LFjc/I3AQAAf5LOf+sM5/ChbSLaFCvef//95qijjjL777+/Offcc833339f73offfSR6devn40Lx48fX+eyTz/9tF3uxhtvrPH877//bq6//npz6KGHmsMOO8z+e/HixaH/JgAAkN2Mj4Z4INq++uorc/bZZ9t+wKOPPto8+uijJpms+51fsGCBufPOO023bt3MGWecUeeyS5YsMT169LAxZGp8+Prrr9s4VPvu37+/jUsBAED+JGMcPxbVwPA333xjjjvuOLPRRhuZyy67zBxwwAHm4osvtkFaXQO9m266qfnkk09My5Ytzeeff17nPi666CLbUThhwgSzfPny6ueHDx9urrzySrPTTjuZwYMHmw022MB0797ddgICAIA8ppJugAeiTTf2TZw40Zxwwgnm/PPPN7NnzzY77LCDmTp1asZ1rr76anP66aebLbbYwsaF8+fPz7istqPt/vTTT7W2uf3225uFCxeagQMH2hsLH3/8cdvBpxgVAADkR6KBHogu9SNqYLZz587m8ssvt5NN1P94ySWX1DkorOUnT55sVlllFTuwXJezzjrLzJgxw8aa3kkvN9xwg7n55pvNHnvsYfsg1157bTt4/NJLL+X0bwQAAJklYhw/FlWNYQ3Gfvjhh6a8/M/xagVl6qRTwDRixIi06zRu3NgOKGtQWLND1BGYyfPPP2/vyNNMjp49e9b4Xd++fc2ZZ55Z/bM69NTxd9ttt9nZJwAAAChOusGvefPm1T/vt99+NjZ87bXX7IBtOur4+9vf/mbmzJljLrzwwozbXrlypTn22GPNtddea/eT6tNPPzUtWrSo/nnLLbe0Ny0q88zee+8d+m8DAABA7mmAd9y4caasrKy6D/Lnn382Dz30UK0MMa5VV13VZjrUfwcMGFBnhponnnjCDj4r3jzmmGNq/E79j5oI4+2DVN/m7bffbg4++OCc/Y0AAABFP2O4adOm1YPCorvpFKRts802GddRAKeOv/rMmjXLnHbaaTYtjLfj0OXt0PM+x2wPAADyx95dl+t00ryBkZca2ykV37Jly8zWW2+dcZ1WrVr52vall15qNtxwQ9OnT5+0v0+NId2fiSEBAMifOKcCRDDNmjWrHhR2YzeVFqmrD7JRo0Z2ULg+mmiiySuPPfaYadKkSa3f0wcJAEDhJWMcPxbVjGHvDA4FY9OmTTNdu3Y1zzzzTKjtqT7I8ccfb8455xyz3XbbmTfeeKPedaZPn24DOKWezkSpqL3pqJVSxq15nE/ly0LsrzzEIeAEO8ydxitD7DNgOlBPsJ+tZKOmgdarWP5H4H06IV6vKQt4v0d5hcm3ZEXjwOuWWmbYZAFecJg9Bq3JusLUXRO+LmVVAdOuVi0Lvs+g57GK2l/u/a8b/Lhf2SjY+XPRsmBDo4v/ez1z8nj8rmiAEKohtonioxkZqvOmOEwZZFQOZNdddw21zVdeecVuR7OC/brmmmvMmmuuaXbbbbesY8h8H6ml9skIepNHmJtDEgVo26oCXPvD7DMu70shxOn1FuI4Cnrch/imFkqpfP1x2zWf8aPdX4lsE8VHM38V62kwV6mdH3nkkVDbU7YZlcnTTOHNN9/cfPvtt/Wuo2XU96kMNdnGjwsXLjH5FWZ/Qc/aSwv0ehsVoLu9rAD7XFRiQwtBr+DB+2kLE3GEidDDrJtvhbqVvxBtVErvS/6517N8xpBOiWwzNgPDqvem9M1ffPGFrfurDjbV3gjqqquusncB1jXI66X01YcddpidZeJN7ZLquuuus68v1UabbBr4tQIAUGzmzp3re3ZlULqTvk2bNuaxn2c1yPa17XR36yM6NtpoI5t+T8frgw8+aG803HbbbU2nTp0CbU/1hE8++WRbM7h169a+1rn33nvtY/To0XVmtMkUQ2auiIw4+bnQLwAASiR+9MaQSgHcEIgho++8884z8+bNM5MmTbLx2S233GKGDh0aeHvKNqObBL3l6ury22+/2T7I3Xff3dYkzjZ+bN8+fVYbAABKUT77IH+OcfxY5uT7Ns7/6tWrl+1wk0022cQ8/PDDaZd79tln7SDxzJkzTdu2bevcptK0qJ7bxx9/XOP5jh072lrEq6++uv154cKF5uuvvzZdunQxJ554ol3Pe8fd/vvvbweSVZeusrLS9916GlDu0KGDmTFjRl6+AMWN3rf27dvbY6Gu9wW0bbHh2KVtS5Wuieuvv775/ffffQ+MhaHUvw2VflcB2SqrrNIg20b+aMDVO5NCHXfpZuYqvFWt3+7du6etC+ylGsNrrbWWefnll82BBx5Y/fzIkSPt4PJWW21V/dyXX35p01Yrtnz77bdtCkKX6tGdcsopdpZJah25VMSQ+cM1mPYtVRy7tG+pynf8KMSQqI9iPPXZiVJF33PPPWmXUzzXv39/O1i72mqr1blNt8bwO++8U+N5xZUaGHb7BfVZ0Izg7bff3q6jMnfezu+9997b7uull15KW/rORfyYX1yHadtSxbFL25Yq+iBjMmP4iiuuqB5Uras+x7rrrms793T3Xn0Dw5mMGjWqxgCu6s6po0932nlrz+nEecABB9j91Tco7NZE1iOVgj8GLhuO2pb2pW1LEccubVuqyssDpqjPkgZuGbxFXXbZZRc7K9i12WabpV1ON/its846dtA3KM3c2GKLLWo8p8483dA4aNCgGjGgBoNPPfVUe6NjfYPCQgyZf1yDad9SxbFL+5aqfMWPQgyJ+igToVI8S139SeqDTCQSdhC5voHhukqRuPuSd99912Yj1Ixfb+yqQeF99tnH3kDx4osv1jkoLMSPhcF1mLYtVRy7tG2pog8y4gPDmq2b6j//+Y+dcev+TjXibrzxRvuc6nLI4sWLzb777mtrdfTo0SPQvrQN9/l27dpV78sdFH799deZ8QsAAFBkNANDDy913t10003m/PPPr07Vow65999/v8ZsEM0uHj9+vK0ZHHRfLVq0MGuvvbbZeeedq5977LHH7ICxZpgce+yxIf9CAAAA5FrXrl1rPffUU0/ZmwDdGwE1GKx4UYO3G2ywgX1OM4cPPfRQO6i71157BdqXm6ZSM4bdWfSaRbzffvvZvkfNFK5rwgwAAECkawyrBtxf//pXm4pljTXWMFOnTjU77LCDvXOuoqLCLlNVVWUmTJhggzPX8ccfb6ZMmWKmT59uB3jdzrrUFH91UYeiOgs1AK0BYpfqw2mgGAAAAMVHMaJSSOpmP80SVgYY3QR41VVXmZNOOql6uWnTppmJEydW//zGG2+Yyy+/3MaWbn051ZNTmZEzzjjD176XLl1q+vbtaweMNZPZO5v5wgsvNEceeWRO/1YAAADkrg9SN/epXJlKz6lfUXV+VbpE2WdE2QfVB6nZvaml8dRnqRjU7YNUn6JfV199tY1LVbJEs4ZdugFR+wcAAIjNwLACojFjxthBX91Rpw6+1NQtGqgdN26cDeBcSsmyZMmSWttLl+ZZdtxxR7sNBVwu1YQ7+OCDay3bqJH/JtL+hgwZknG/CIf2bTi0bcOifWnbUsWxi1KhAd3LLrvMfPfdd/amwPbt29eK4TRQq84/lzLHeAdyXXWVLlHdYW+aP31Gxo4dm3ZZ1SH2i89aw6FtGxbtS9uWKo5d2hbQzF71Df7yyy/m119/tfFjal1s9RtqGZUSSVcaz49u3brZbag/06XydkcffXTacxPnseLAdYK2LVUcu7RtqeLYza8yR7mTAQAAAAAAAAAAAACRVV7oFwAAAAAAAAAAAAAAaFgMDAMAAAAAAAAAAABAxDEwDAAAAAAAAAAAAAAR16jQL6DY/P7772b48OHmgw8+MBUVFWaXXXYxZ5xxhmndunXGdRKJhHnhhRfMyJEjza+//mreffdd06RJk4zLX3rppebtt982w4YNM/vuu2/1899++6259957zaeffmpWX311c9hhh5nevXubsrIyExWzZs0y9913n3nttdfM0Ucfbc4999x61xk7dqz55z//aaZPn25WW201c9BBB5l+/frZ98fvMuPHj0+7r2eeeca0a9fORMVTTz1lHn30UbN48WKzxx57mEGDBplVV121znV++eUXc9ttt5mPPvrIrLvuuuaCCy4wXbp0qf79tGnTzN13320mTpxoWrVqZQ4++GBz4okn1mh/7U+fG70PS5YsMZtuuqk566yzTOfOnU2p+/e//20eeughs2DBArPrrruaiy++2FRWVta5zpw5c8ztt99uj7u1117bnHfeeWaHHXao/v2MGTPMP/7xD/PJJ5+Yli1bmgMOOMCcfPLJplGj/52S//jjD7uMzif698Ybb2z++te/mi233NJEhc6X999/vz1/6lw4dOjQetf5v//7P3s8Tpkyxb4P++yzjzn11FNN06ZNfS8zefJkc9JJJ9Xats7hW2yxhYmCpUuX2nPtm2++aVasWGG23XZb+5lcb7316lzvnXfeMffcc4/93P/rX/8yG264YcZl9Zl/5JFHzMCBA2u0508//WSP3Q8//NA0b97c7L333rb967ouAlHwyiuvmMcff9zMnDnTdOjQwfTv39/svvvuda6jz5piP332tPyAAQMyLvvVV1/Z32+00Ubm4Ycfrn5en3F9Fl999VUzf/58s/XWW9vrTtu2bU1UZBtri67bd955p70WL1++3MYkZ599tm2/bJZRzKMY3atnz542no8KnbevvfZa8/nnn5t11lnHnHnmmWbPPfesd71Ro0bZY17tuP/++9tY241l9J7pdy+++KKNizbffHP7+44dO2Yd55ein3/+2bbpZ599ZmNBfZ/s3r17vev95z//sddffSfdb7/97Ge5cePG1W365JNP2s/Cb7/9Zo/Xc845x3Tq1KnGNvQ9VjHADz/8YL/DHnjggfb84o0zS5njOPa7pP7GH3/80Tz//PNmrbXWqnMdP3G1n2V0flB849WtWzdzww03mKjQ36dz7XfffWfatGljjj32WNsvkauYXseu+gHUx/HWW2/VeF91TtFnQOcktb/aOwrfJ4H6Pj/6XjVhwgT7fVX9OPp+1aJFi4zrrFy50vZTPPjgg/Z8NWbMmDr3oe+B6u9RH8XOO+9c/fwXX3xhz6VffvmlPY8eddRR5ogjjojUG5ZNrO164403bNvqGrPmmmvauO+EE06o0Tdb3zL6/eWXX15r24rX1a8WFep/fOKJJ2z/w1577WX7E5s1a1Zvv7D6INXHqP5Y9Vt6+2H89I37ieFLldrzscces59txRgXXnhhvf26ijvVph9//LHt87nooovsd0KX+sbUzzNp0iQbG/bo0cP06dPHlJf/b77gokWLzF133WXef/99s2zZMrPZZpvZc4f6d6Ni9uzZ9pynz+Ff/vIXe7zWx09cXd8yOv+qLVMprle/QRTo+NExpnOtYrquXbvav7muGD3bmF7xtq59+kwceeSRWfWxIwMHNXTp0sW56qqrnFdffdV5+umn7c/bbrutk0gkMrbU/vvv7xx66KHO2Wef7ahJly5dmnFZbXOrrbayyz3++OPVz//f//2f07lzZ+eWW25xXnvtNefuu+921lhjDeecc86JzDs0btw4p0OHDs4VV1zhbLLJJr7+trfeesupqKhwLrnkEvvvkSNHOquvvrpz3nnnZbXMyy+/bJfRa/A+li1b5kTFiBEjnFVWWcW58847nVGjRtnjrHv37k4ymcy4zvfff++0adPG6dmzp22jf//7384uu+zi/P777/b3kydPtu/VjTfeaI9Lte0666zj9O/fv8Z29ttvP2ezzTazx/cbb7zhHHvssU5lZaUzbdo0p5Tdf//9TpMmTZzbbrvN+c9//uNst912tn3qOh9Mnz7dadeundOjRw/nxRdfdJ577jln9913d3755Rf7e7XJRhtt5Fx//fX2PPPggw866623nnP88cfX2I7OKVruySeftG164oknOquuuqrzzTffOFGgY0vtNGjQIGf77bev9fen88knnzhNmzZ1zjzzTOfNN990HnnkEadt27ZOnz59slrmo48+sufg119/vcb5YNGiRU5U6PhT2+oYHD16tP2Mqr3nzp2bcZ3TTjvN6datmzNkyBDbPp9//nnGZSdMmOBssMEGzmqrreZcffXV1c/PmTPH2XDDDe1zOqc89thjTseOHZ1DDjmkznMRUOr+/ve/O0ceeaTz6KOP2nPP4MGDbdzx/PPPZ1znlVdesZ+XYcOG2fOUPnuZLFmyxF7Xt9hiC2ebbbap8bvDDjvMGTBggL1eaJv6ea211nJmzJjhREU2sbZL1+utt97axkSKYXr16mVj69mzZ2e1jNr7rLPOqnG9mDJlihMVCxYssOfzgw46yF4zdOw2atTIefvtt+tcT3G22krx5zvvvONcdtllNsZ3nXDCCfba+69//cu27XHHHWdjQ13/s4nhS5HiiU6dOtnj9oUXXnD+9re/2TZVPFeXiy66yF5X77rrLtumWk/t6jrppJNsvKRrq9pU/27RooXz1VdfVS8zZswY26aKAdSmimXXXHNNewxHhb5nKK7RcaPzwcyZM+tdx09c7WeZffbZxx7X3vNBVGJz0TVr7733tp9FHT8333yzjat1jctFTK9Y8MADD3S23HJL27ZeOr/rOvrwww/bGP3UU0+1+1bcDkRVVVWV7Qe87rrr7HGvPkL9vMcee9S53s4772w/L+7npC733nuv/czpfKnvZy5d5xUD6fOtc576kVq2bFlnPFpqsom1Xer3KS8vt/3CaqN//OMf9lp75ZVXZrWM3stWrVrV6oNcuXKlExXqJ9S5XP3XzzzzjLPpppvafoi6fPnllzZ+PProo6v73XfYYQdn+fLlWfWN+4nhS9Edd9zhNGvWzBk+fLj92/Tdb999961znW+//db20x5xxBH2mH/22WftOcLt3/riiy/se3PTTTfZtvrnP//prL322rb/x2uvvfZyNt98c/te6nyk96h169a2jzMKPvzwQ2f99dd3Lr/8cnuMqc+wPn7iaj/LqD11Dk49H/j5Tlsq1Jeo7y3u2IL6wRVX//HHHzmJ6dXHouPYHfdw+e1jR3oMDKdIPWA/+OADe3B+/fXXGZrQcebPn2//qwtaXZ1VOlh1cE6cOLHWwLA6/FIHm+655x6ncePGkRm8XLx4sQ18pWvXrr4GhtUxpCDWSycaDTRks4w7MBxVCi4VBHkHaHTM6jhTYJDJAQcc4Oy22241jj1ty32fdCynBq7qjCorK6s+7vW+aj9PPPFEjW2oA0ydCqVKbbLuuuvW6JDTZ1h/u74IZKJBdnWKuG0o+veKFSvsv/V5dv/tUuCmNnQHj/V7fdHQBc37epo3b24DxCjQseUG/zoO/Vy0r7nmGnsjg5cG7fUFNptl3IFh9waIOFzLfv31V/s31zVI5X6m3WtUpoFhDSIo8FIHgr5ge887+uynXrMUwGl7Ueo4BVKl+8Kz5557On379s3YWPqy7l5/NYhUV2eVOv7OOOMMGzulDgyn3tSia4i+7Ot8GBV+Y22XrqdaToNy3nbScxr08buMqL3VkRJV6tRTp4+3Tf/yl7/YL/OZvPfee7adUgc6vdtIPS51rOs41+BnNjF8Kbr11ltt3OE9LxxzzDG2ky4T9ztnatxeV5tqkE03cHoH0tW+ulnTS+eW9u3bO1E7H6gz3s/AsJ+42m/srYHhiy++2InTtaxfv372+2IuYnqdb7SMOr5TB4bT3aCpwYKTTz45y78CKC3qC/R66aWX7Lntp59+qvc8eN9999U5MKxBOPVB6qbe1IFh9eOk3rh7ww032MHMqNzQm02s7dI5JzUG0gCSJg1ls4z6e9VHF+XjVoPh6mtJ7WcZO3ZsxvV0PdFAkJf6D9xjzk/fuN8YvtToWqobBHWjiEuDuulibi/FJvre6f3cKq7x9ut6+yfloYcesnGPe+1VH4/2o0Fh7+vRMlo2KjGO27+90047+RoY9hNX+1nGHRiOstQYUjcs6G/W98awMb36M9WeupYpfvQODPvpY0dm1BhOobSXXkoltcYaa9SZjs9PGpCqqipz3HHHmb/97W82HUMqpdrwpnAQpY5RyjCtGwVKfZFtWrjtt9/epmTUw02Zo/RWO+64Y1bLSDKZNIcccohNdXf++efbNAVRoXQgc+fONYceemj1czrONtlkE5vCJlPKIqXPOO2002oce0q14L5Pq6yySq3UCzoudVOJUle676vStowbN656GaVzcVNHlCql7FQaM2+bbrDBBmarrbbK2KZKZ6PUF0qb6z3W9W83DaDSQ7n/drlpotw21e+32WYb26ZqRzc9stK56HiPAh1b2aYW1vE0b948mwpadH5UG3k/636WcemcrHR3Sm/y/fffm6hfy3Rc1ZWOz29KK50zlCpLKbpT6XzhTeud7vgGoij1M6d0XkqDpnN5JvpspMZ+6ajsxXvvvWduvvnmjNvx0mddn8MofeayTbmn2F3XbKX18qYsVtsotb7fZVxK1a1Ubkpjp5RfUaKSA7oW6rrs0jle7aLyIOmoPRRjpl4HvNtIPS51rOtz4j0u/cbwpdimahvveUFtqjShSrOWKRWjyjco9ZnfNlVKRcXhqW2qFI1Kze22qfZb6m0a5nzgJ67OJvYePXq0TQt+zDHHmAceeKB6+Shey1QuSGn56rqW+Y3plUZRaS7VZulKZaVLm6vnonQtA9JJTburmE/pdRWnhDkP6vyl89Qtt9xi1l9//Vq/1/Uj9bOoz5yuG+o7iwK/sbaXzvnqG1Dae7cddT1I7YOsbxn3HKpSbEorq5Jk6oOLCqnBCSEAABtISURBVMUW+vu8/WVqF6UxztRfprTeSlN8+umn13he31vcY9FP33g2MXwp0fVWpUS8baoU24oPM7WpUiMr7lT6ee/nWW3h7ddN7YtXm+pzrs+7KP2uYntvm+rf2uZ2221nohLjZJta2E9cnU3srfdWYxIqFaP0x1Hvg9RzdaV393MtU5zdt29f28+erk399LEjM5Jtp6E6V3qoU08HmOp16CQZhmpLKE+6TtYKGuqjg1cdgKotVV8tgShTB5wG2zQYpwu/LnrqvNL7k80yovoBWlZBhn6nWmeqv6CLX6lzL0Cp9UP1s/u7VF9//bX9r+oKq/bB1KlTbcChuhyZvvwrEFNO/912261G3n8FIsrvry8cOrGrbrFqytXViRDFNtVgpIIrfZHTRUu1uVRLT7X6Mg2Sa/nrr7/e/t5b71q1KlV/S22qmns6rlVzK0ode9lSZ6k6k1TruX379vaLlYLUZ599NqtlRDUMVRdX51d1xqp+nL5MRGXgXXTjx5AhQ+yXC50jVbsjtQ5htnTu1LlDdbf9Uo1FnWepEYeoU+ymuqyqc6Xzv2o7qaZqGKpTpGuIrgn11evyDtrpy6m3UyFu1Pmh+kaK/VSvVed63UD3+uuvV8d9fpYR3RyquFJxpmqh6eYYDR6pTl8UKKZRB0VqrKP4RDdRpouTdfOcrpe63qrt3Hry6ujLNECkG+dUw/jvf/971jF8KbZpao1mtak6NjQIru8gmdpU11fVlVMnnmr16fOfqU1ffvlle0x669sqdlStccXgbptqO6r/Gmd+4mo/y6iOpI5RvVeKh9TRr+9BiiWjRPUcdR3RtUwDSxrQDWPhwoX2hswRI0bY755+aPBA/TBRuxkHSEcxxeOPP24/dxr0UnyS2tGdLcWgGiRTnXD1bdZH9Ux1jVb8mO2Ejig544wz7ICn6pyrL0eDN4oV77jjjqyW0YCaajarn0wxlWq36vqvSR3efp849Zcp1nGvpRroUUykQSMdq+lio0x9435j+Dj167Zp08b069fPfndUv+4555xj4+tM/bo33nijvelV8Y57vL711lv2eFXN28rKStuXplhTfWVx5Seu9ht79+rVy9Yh1+D0yJEj7aC/bppLN3mwVOmGdn1e58yZYz+7OqZ0bIahm5sUR1566aW+ls/Ux44M6phNHFuauq50Xkr9oVQgqu+ROi09nUzp7ZTDXylpNfVd9PvUVNJeSv+gFExKhxql+nBeflNJK02AUmkoZZfSkao+itIjqt5RNsukpjZVahK9t0rrFgU6lnRMKf2Hl+rFHX744WnXUao6raMaC0qRptQkSqWhFNCqvZAplaXS4Xz33Xc1nlcNLqXOUDpp5fTv3bu3TdUza9Ysp1SpJkK61BOqXaLaWOmoHpzWUXpdpUhTmyq9n9KYZ0qno3paSuHorQ/ntrXS9bq1+ZSOVDW6o1Lfw8tvKmm1kc6LSqeqVCxKaaN0IpdeemlWy6RLz6/0O3pEyW+//Wbrlij1uerSqB6HnqtPplTSalt9/pWSzJWaSjqV6iMqDSP14RAHit/0mdO5XzGJjn1vyr66pEtvp1RXqp+l1JuudKmkvbR/7Vc1z6LIbyppNx2y6jIrJZpiHtXdUj0p73nQzzKp1wzFXCorEZU6w6npneX999+37az0demoZIZSTaqeteI+lRlRjKL2TOfTTz+1y59//vk1nvcTw5ciXW9T6yS7aTwnTZqUdh2lmVYbHXLIIfZYVPyn2s8qUZKO3hu1neJIr48//tjWab7wwgttm6qOnOrOqe5W1PhNJe03rvazTOr5wE0NGLU455NPPrHtq3SWShWqNJ5hYnrVkFP7upQCMDWVtJfOr4rn9R0TiIMffvjBXnsfeeQRG4eoHyc1nW46mVJJK67RNcTtH1Ja6tRU0qkxp67pWsftt4wav6mkVSO0srLSGTp0qL2O3nXXXfa6qhglm2VSrxdKy7vxxhvXqutaqnTs6ZhKTVGs/vMTTjgh7To6LrWO6j7ruqJraP/+/W3N0HRlrOrqG/cTw5caff7VPqkpeZV6WzXF01E6ba2jeGXEiBH2e+jpp59uU2+rXnO6NlWJCNXATf0uo35ctaHScSu+V3+5jtm60tqXKr+ppP3E1X6WSTcmoXIZmb47laqff/7Z9kfoc6m08dtuu23aUiF+Y3qNTehYVVlHV2oqab997EgvtgPDCgh0InAfqXU9XDoBqvPnqaeeCtxZpYuiLmTuvnbccUe7nL54nnTSSbVO0gMGDLCdIt7O91KiQNLbtuk6d/wODGsArkePHrUCkCZNmlSfXPwsk84FF1xQqw5AKVDdF2/7zp071160dUx5T5aiY02BVjo6wWqdYcOG1ersS1fLSe+XOqDUUeCli6C2o5O/9yKn+nCpHY2lZMyYMWnri6t2R6ZBzM8++8yuc/nll9d4XvVnjjvuuFrLDxo0yH6hUGehl1tHRBdH77lBx+tZZ53lxHVgWOdSHfOpA/g6R//444++l0lHHV8KOKJKgaj+vmuvvTbwwLC++CrA8p5/dJ5t166dHXhOpX1pgEpfnIGo0Bdo72fg7rvvzrisYrztttsucGeVey3Ql0Z3f4on9bnSv1Nv4tLPGljSl9Koxud+B4bdG7W85zHd5Kn2u/LKK30vk446nLSebrqJQnyu4ys1Vhw9enSd9Q33339/ez3wdnKoPbRO6k2BOo7XWmst55RTTqlVszBoDF/sdENHan1xt2ZkpkHMgw8+2NYl9h7bbmdf6k2Bik3V4aSOvdQ21cCy4iqvBx54wN74mXoDaVwGhv3E1UFjbw2m6AZQdQJGlb4r+q05mi6m13lCbbv11ltXn380+KS6hfr3qFGjaiyv77Pq4FYnuFsLEIgC9T+5n4G66nZPnjzZfmZ0g0rQgWFdC/Qdzd2f4lFtM905TQN7Rx99tJ0wMHXqVCeq8bnfgWHdqJV6HrvpppvsTTLuYL2fZdJRvKV1oxCfuzU8UwdiN99884x9veoX0Dq333579XO6tmgwMvW4rKtvPGgMX+xefPHFtHGNPr+ZbijQpDatk3oDoAbkFHun0mCobvbXTZte48ePr3Wjm84NOi94J1nEbWDYT1wdNPbWjbEaF4oqfZdr1qyZvWEhaEx/7rnn2n5M7/lH8aPiyHST4DL1sSOz2KaS7tOnj63z4EqtiehSigulcNE0+KCGDh1q04C5NJ1eKRuUOuPwww+vfl4D9Uo1rbpFmm6fKZVGsVMqYW96vTBpA1QrNLVGhNJoqA2VukV54/0sk47S6ZRimm6lo/Gmp1Oac/39SpGtNBRKXSGqC/fFF1+YE088Me12lLZCaepS05QovZdSz3qpJvPDDz9s61p06dKlxu/U/uKtw63Xovfd/V0p2nrrrW2KD29qDx1Tn376qU2vls6mm25qjzc/bTp48GBz99132/S+qemh07WpUrtoO6XcpmHpb0+t9+6mZlT76nd+lonS+cAvXeOUJijMtUwp51NrH+qz0KNHDzNgwIAazyut5dVXX21eeOEFm0YHiAqdh70xTl3pibSs4rmglAZMKYu9tG/Vn9J/dc1xqa6Z0gHrc3rTTTeZqMfn9Ul3HVU8rzIY7u/8LJOOm46x1K4ZmeJzlVtIPc5UF0u/zxTDu7X1vO+Pmx5W11o3DlLKQKWYVn3de+65p1Ytw6AxfLFTm7799tu12lTHVqY4RG2quN1bU9jbpm59yG+++cZeV1US47777kvbpqkp6dSmShuoNGxKDRg3fuLqoLG34irVPSy180E21AY6dvS5DHJOVir01HOMUg0qrbTOSbrWuZQqU8e3Pg9Kq5ttLUCgmJ1yyik2Taukq7Odeu4P871NqTy9/Q86j+k7m8pheL/P6fyl1Kb6jCo1r9IiRz0+r4/aKl05CKXaVllAlc/ws0yU+hzSxedu3Vn1lykmER1zKkEwaNCgtNtRzKfzure/TJ8FxZve47W+vvGgMXyxU1+r2kNt6h7DiocVT6tUXTpKF633w08fpMoG6tqqEhjq76yvTZWye5111inpNg3LT1wdNPYu1fOBX/oep/GKMNcypZlXSRMvfbdUGvnjjz/edx876lDHoHHsKLWX7nry3h2ju410l8e3335bI71CullXfmcxZEolPXDgQHs3VKa0bVGSacaw0u3qDhD3LhHNetEd8Uqt495xrBQ33rtq/Czzj3/8o8ZsQaUaUWoN3dUXFfqbNevDTTui2X2aeeBNBaQ7FL2zWXUHmVK9LF682P6sO/F0l6NS4XjvbNVM4XRpSER3CGodzQ527yRXGiS174MPPuiUMt056019obvwNFPLOxtGaVp0V5JLdzrqGF64cKH9WecOzarxzpy/7LLL7F1Muisvnfnz59s787Ut945TzQTT3cB1zU6L2oxhnQvVlu45Ue2vdnPvGNUsAs3I0XlTqZn8LqO7977//vsad1kqHYnu2ItK+hYdJ967lZVSW7Omla7JpeNWx6/fGcPppEslrfOqPidKowPExd///ndnzpw51T9/88039vPhvbtbsYfOaTrHB53FkC6VtDJ56Dqt63XU1RVre+NzxZFKS6dYyKXzn+4wVmorv8soE4jSqbl+//13O1tWs3D8pLMuBbqjWtcHZddw20UlcBSrZIrPVVJEMYlmNrjfmZRtRu3izvDTjCfF55rtkWmmoZ8YvhQpZlab6ngVxY06H3jjDGXaUZu6f7tmO6lNNVtbdA1XnL7eeutVxy+KKfXeqK0zzUi65JJL7Axtd9aX2lRlUJTJJ2rqmjHsjc/9xNV+ltFM1vvvv7/69/rOddRRR9nz77x585woGDlyZI0MVIopNVPJW24lNT4PkgUoXSpppQnVcaq0iswURlzoe6g3vbNmPSqe0ywrb5/DoYceaktV+Z0xnCpdKmmdyxQ7qexSVMpj1CVTrJ0anytu0Wy02bNn25/VV7bXXnvZzHouP8vo/fKWJVNsqRhT71lU7L333jajnptBRnGdUup6v+uk9p8rk56uFW4cre8xise9fYf19Y37ieFLlTLIaFa5mzVJ/bfq3/J+z1RWKu+xrLiwe/fu1X3B6sfRNdbbd6iZl5oprL6edHSsqg9HcaQbt7/77rt2POTRRx914jJjODU+9xNX+1lG74U3HbqOV2VIUubCKNA1RH2O7rGj/yrW0/chb5az1P7zIOVh0qWSrq+PHZkxMOyhE22fPn3shUydbjppqkaU+wXdtcUWW9RIueam9lXufR3ISt+rn72pdesbGHZTASso806R1yMqQZoG19y/SR9kN7222tz1/PPP23Zwa9gqwFIaKV30VT9C782WW25ZI52xn2W0Xb0/CgZ1ctb+Nejvp25LqdCFXKnrdDJU+i2lW1DaOi+1t7eust4TpfBTh4baToGA8vG77eLWmFNnVupx6Q3S9BnRMnoodYzeC9VW85NyrNjPCRo41wC7jhu103PPPVdjmW7dutWo/6ZgTEGABoPVpvpSp8DWrb2izkK1qTr2UtvUO/iuL206H2g5nXPUpgpconTMKoWW/m51xLnpQfSl16VzqDdNub4oKwjWl199xvVlQZ3HClhdfpZR0KHf6cucfqe21Y0NfmrJlwJdYxT461yotH06htSxnPolVMetjl+XakTqPdBx603553Zs+xkY1vVK6yowTj2+lZ4diCrFdDqnbLLJJvahc7/qKbo3XnnrRrkp19SZ5H4+dM5yr7Xpbtioa2C4S5cuNpVp6mfOz0BzqfATa6fG5yoDo0FHXUuVok7vyeDBg2tst75lVK5DNS51PtW5UfGj4oJSLfeSyfDhw20MqPbVNVGDXd400anxudt2ahe1m2J6/debfk4dpOoMcN8r9+G9gcFPDF+q1AGkNnXjDNW+895MoDgvtWSJblDW90+l+tS1W99DvR0cqjGnNvWml9dD13xvHKobG9021fYUm0epBq7aVn+3jjm1oc6B+lmd+5nicz9xdX3L6HjV+dn93qTvB7rZOUptq5v63BjZ/U6nz6g3rXxqfO4npvczMKzzjrarNvUe35nKIgFRoFhQnzGdqxXfuecX1Qn1UozovX5qsEifD9Vq1XUhXR9NfQPDuvFNz6mfIzWGjEqdYT+xdmp8rht91EemmFDfh9Wvo/OS93rtZxm1r/vdQOl41U+XrsxeKdMgjm4e0t+v66di6tQyUqnxudpOZah0zOt6o1jJO1Dkt2/cT5xfivRZda+nOm7Ur6I28dKx5r0JS+mKVZfcjaPVpooN3f5Yt0xeun5d7zGrsjCKgbz9uqVcoiiVBtvdv1uTm3T86N+6eSFTfO4nrvazjG6m1blAYxI6b+s90nf1qPTvamxB/d5uH6TaVuMS6mP0So3P/cT09Q0M++1jR3pl+r+6ZhTHkVI1TJ061aahUEqL1DQvn332mZ0S76Y9mjZtmvnll19qbadz5842bVsqNbnSiW288cZmjTXWsM/Nnz/fTJ48Oe3r2WabbUyzZs1MqVOaGqXESKXUCUp/4W0HpdDwpqpSCowZM2bY9lJqi3Spd/wso/dK6RyUblmpRqJoypQp9hjW8afUXV5ffvmlbdeNNtqoxvM//vijTX+h1EFK9eBS2gulLUlnyy23rJHiT++v0n8phbW2E6WUGDpu1BZKD5KaQk3to3Q4m2yySY3nZ8+ebX777TfbFt7UIXpvlCowHaXI8S6rNtUxrXW0nVJNqZiJzoOplyC1r5uu3G2r1GNN78UPP/xgz6/t27e3qctT+Vlm5syZNt2T2jZoutJitnz5cvPtt9+a1q1b23NiahvodzofuqmZfvrpJ/sZTqX2UQqhdCZOnGjWXnvt6pRDSp01adKktMsq7a3SWQNRpfOZ4kd9rpT2NTV2Uxolpd9VikxdN/QZ1Wcola4DmcqJ6DOq85sbN7lxqa69qRTHdurUyUSBn1g7NT4XvRdqM52bdC5Ll9rPzzLudwOd69zYPWoWLVpkj0+d71PT0WWKz3UM63ldZ3TMe2NvxUc6VlPpOuBNg+43hi9FOm6UUtF7nXQtWLDAfP311zatojd9tNumOq7Vpt5rd6Y2VfunprDTe6Y2VXsrHWFU2tT93qJHKn2/URmoTPG5n7jazzJLly61nxX1E+g8G0WKkXWs6Rj0fjfMFJ/XF9On0vlc7bzDDjvUiEvTpavU/lUCCYgyfd4U6+i8ku57l+JFXSPdsgI6B6VLz5n6vdm1cuVKW3bEGze5cWk6ShOc2pdUivzE2qnxuWvu3Ln2WqPzfGpc5HcZ97uBdOjQIbLp8RXr6Nqo4yu1nzVdfC66BigW0vPevsNs+sb9xPClSsekvt8pvkv9LOoarHZI/Z6na7diarVpav9Zpn5dfaf0tr/aVO+N3k/1m0epXzeZTJoPP/yw1vM6btzU2pnicz9xtZ9l1Eep0hw6XqM4JuHGyGoDnRNT+yBT43M/MX0qjSvpWuheK7PpY0dtDAwDAAAAAAAAAAAAQMTVnkIFAAAAAAAAAAAAAIgUBoYBAAAAAAAAAAAAIOIYGAYAAAAAAAAAAACAiGNgGAAAAAAAAAAAAAAijoFhAAAAAAAAAAAAAIg4BoYBAAAAAAAAAAAAIOIYGAYAAAAAAAAAAACAiGNgGAAAAAAAAAAAAAAijoFhAAAAAAAAAAAAAIg4BoYBFK1kMmmOPPJIM3LkyOrnFi1aZP7yl7+YESNGFPS1AQAAoDg9/fTTpkePHmb58uXVzz3wwAOmZ8+eZt68eQV9bQAAACg+K1euNIcddpj517/+Vf3c77//buNHxZEAECUMDAMoWuXl5WaXXXYxl156qfnjjz9skKZBYQVmAwYMKPTLAwAAQBE64IADzIQJE8w999xjf37xxRfNX//6V3P22Web1VdfvdAvDwAAAEWmcePGpmvXruaSSy6xNxcuW7bMDhQnEgnTp0+fQr88AMipMsdxnNxuEgByR4HYxhtvbM4880zz9ddfm08//dS8++67prKykmYGAABAWjfffLO59dZbzeOPP24OOeQQc++995rjjjuO1gIAAEBaylLYqVMnc/nll9u+xx9//NG89dZbpnnz5rQYgEhhYBhA0fvnP/9pBg4caNq1a2fGjRtn1l13Xfv81KlTzeDBg+2/ldqFzj4AAAB4by786aefzI033mjOP//86oa5/vrrzaRJk+y/lS5QWWoAAACA22+/3Vx44YV2gPj99983a665pm2Ur776ylx11VX238ccc4zp1asXjQWgZPENGEDRmzJlik3dosFfd1BYVlttNXP44Yebpk2b2pnEAAAAgGiGh9IANmnSxPTt27dGo6hUiWLI//znPyaZTNJgAAAAqNEHeeSRR1YPCov+rfhRyVe//PJLWgtASWNgGEBRGz58uK0Pd80119gUgOrk8w4MH3vssaZLly4FfY0AAAAoHr/++qutM6xsMhtssIGdIezVrVs3G0M2atSoYK8RAAAAxUUx41NPPWWGDh1q7rzzTjNnzpzq36299to2ftxqq60K+hoBIBcYGAZQtEaNGmUGDRpknnvuOXPppZeazp07V6dtAQAAAFItXrzY9OjRw3Tt2tXcdttt5oorrjB33XWXmTVrFo0FAACAtB555BE7KeXFF1+0NYbXW289c+2119JaACKJgWEARWns2LGmT58+5qGHHjJ77LGHKSsrs3fsPfDAA+bbb78t9MsDAABAkamqqjJHHXWUadasme3cU+3go48+2my00UbmyiuvLPTLAwAAQBF6/fXXzWmnnWaefPJJs/3225uKigp7c+GIESPMzJkzC/3yACDnyJ0FoCi1aNHCDg5700Qfdthh5s0337SdfQAAAIDXwoULzcUXX2zjx6ZNm9rnNDg8evRoM3v2bBoLAAAAtay++upm/PjxZuutt65+Tmmj27ZtaweJASBqyhxVTAeAErRkyRLTr18/O4N42bJlNoD7+9//btZZZ51CvzQAAAAUKWWgefXVV82zzz5rjjjiCNO9e3dz+umnF/plAQAAoEjNmzfPnHHGGearr76yP2+++ebmnnvuMa1atSr0SwOArDFjGEDJaty4sTn88MNrPLfqqqsW7PUAAACg+G2zzTY2A40bR3bs2LHQLwkAAABFzI0dvf2QboYaACg1zBgGAAAAAAAAAAAAgIgrL/QLAAAAAAAAAAAAAAA0LAaGAQAAAAAAAAAAACDiGBgGAAAAAAAAAAAAgIhjYBgAAAAAAAAAAAAAIo6BYQAAAAAAAAAAAACIOAaGAQAAAAAAAAAAACDiGBgGAAAAAAAAAAAAgIhjYBgAAAAAAAAAAAAAIo6BYQAAAAAAAAAAAACIOAaGAQAAAAAAAAAAAMBE2/8Dq02Dt2ncj+sAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -791,7 +647,7 @@ "ax[2].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", "ax[2].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", "fig.colorbar(pcm2,ax = ax[2])\n", - "fig.suptitle(\"Posterior Mean Residuals and Weight Functions\", size = 18)\n" + "_ = fig.suptitle(\"Posterior Mean Residuals and Weight Functions\", size = 18)" ] } ], @@ -800,9 +656,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "openbt (.venv)", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "openbt-venv" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -814,9 +670,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.6" + "version": "3.14.4" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 4 } From b0f06c25cc5b56df367afa70d0d539973b056bb7 Mon Sep 17 00:00:00 2001 From: Jared O'Neal Date: Fri, 24 Jul 2026 07:55:46 -0500 Subject: [PATCH 10/17] Cleanup landing page and homogenize structure. This branch is addressing the R wrapper issue, so we can remove the note. Sarthak has grown the "tox usage" section into much more, so a more precise name is needed. Since R doesn't have an empty bibliography, C++ shouldn't either. --- docs/{tox_usage.rst => developer_environment.rst} | 0 docs/index.rst | 10 +--------- 2 files changed, 1 insertion(+), 9 deletions(-) rename docs/{tox_usage.rst => developer_environment.rst} (100%) diff --git a/docs/tox_usage.rst b/docs/developer_environment.rst similarity index 100% rename from docs/tox_usage.rst rename to docs/developer_environment.rst diff --git a/docs/index.rst b/docs/index.rst index 71496e6..a23dbd4 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,11 +3,9 @@ Welcome to |openbt|'s Documentation! .. _Open MPI: https://www.open-mpi.org .. _MPICH: https://www.mpich.org .. _framework: https://bandframework.github.io -.. _Issue 35: https://github.com/bandframework/OpenBT/issues/35 .. _OpenBT repository: https://bitbucket.org/mpratola/openbt/src/master .. _OpenBTMixing repository: https://github.com/jcyannotty/OpenBT - .. image:: images/openbt_logo_rect.png :align: center :alt: OpenBT @@ -37,18 +35,12 @@ frozen. This repository and its contents are being established and developed as part of |band| framework_. -.. note:: - While an R wrapper does exist for the original |openbt| and |openbtmixing| - repositories, that functionality has not yet been included in this new, - combined repository (`Issue 35`_). - .. toctree:: :numbered: :maxdepth: 1 :caption: C++ User Guide: get_started_cpp - bibliography_cpp .. toctree:: :numbered: @@ -75,6 +67,6 @@ This repository and its contents are being established and developed as part of contributing git_workflow documentation - tox_usage + developer_environment versioning release_procedure From 359dd290877c3484a54809f5bf6a901a9c9ccbcf Mon Sep 17 00:00:00 2001 From: Jared O'Neal Date: Fri, 24 Jul 2026 08:01:53 -0500 Subject: [PATCH 11/17] Cleaning as part of PR review --- docs/bibliography_cpp.rst | 13 ------------- docs/index.rst | 2 +- openbt_pypkg/tox.ini | 2 +- 3 files changed, 2 insertions(+), 15 deletions(-) delete mode 100644 docs/bibliography_cpp.rst diff --git a/docs/bibliography_cpp.rst b/docs/bibliography_cpp.rst deleted file mode 100644 index 203aa7f..0000000 --- a/docs/bibliography_cpp.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. raw:: latex - - \cleardoublepage - \begingroup - \renewcommand\chapter[1]{\endgroup} - \phantomsection - -Bibliography -============ - -.. bibliography:: references.bib - :style: plain - :keyprefix: cpp- diff --git a/docs/index.rst b/docs/index.rst index a23dbd4..f9ddb99 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -27,7 +27,7 @@ it can be built with MPI installed on a laptop using the system's package manager or with MPI installations on leadership class platforms and clusters that were installed by experts and optimized for their specific platform. -This repository was established by merging the contents of the original Bitbucket +This project was established by merging the contents of the original Bitbucket `OpenBT repository`_ with the `OpenBTMixing repository`_, which was based off of the former. It, therefore, will supersede those two repositories, which will be frozen. diff --git a/openbt_pypkg/tox.ini b/openbt_pypkg/tox.ini index aed5cff..86a4cb1 100644 --- a/openbt_pypkg/tox.ini +++ b/openbt_pypkg/tox.ini @@ -54,7 +54,7 @@ deps = sphinx sphinxcontrib-bibtex sphinx_rtd_theme - # The command below is for live-reloading of the documentation during development. Uncomment it if you want to use it. + # Uncomment the following dependence if optional live-reloading will be used in this task #sphinx-autobuild commands = sphinx-build -W -E -b html {env:DOC_ROOT} {env:DOC_ROOT}/build_html From 5b5a86ef971a6fc8bc43e379da6c02bf1985b48d Mon Sep 17 00:00:00 2001 From: Jared O'Neal Date: Fri, 24 Jul 2026 11:12:18 -0500 Subject: [PATCH 12/17] Restructure the dev env section. Since we ask users to refer to the C++ CLT build script for more information, I moved some technical information from this section to the script's docs. This makes sense since we shouldn't ask users to read the dev guide. Split up the intermediate/cache information so that info only appears in the section related to the tools that create them. Will reevaluate with Sarthak to determine if this is helpful. Having this section only point developers to the "list" tox subcommand is lovely. Improved the tox.ini descriptions to improve the self-documentation contained in that file. --- docs/developer_environment.rst | 264 ++++++++++++++++----------------- openbt_pypkg/tox.ini | 12 +- tools/build_openbt_clt.sh | 18 +++ 3 files changed, 157 insertions(+), 137 deletions(-) diff --git a/docs/developer_environment.rst b/docs/developer_environment.rst index 9e8e9c8..a997662 100644 --- a/docs/developer_environment.rst +++ b/docs/developer_environment.rst @@ -3,15 +3,104 @@ Developer Environment ===================== +This section is a repository of information that might be potentially useful to +developers. Note that information regarding intermediate files/caches that are +created automatically, which might cause issues during development and testing, +is split across sections. + +Eigen +----- +.. _Eigen: https://gitlab.com/libeigen/eigen + +Eigen_ is a header-only C++ template library for linear algebra. Being +header-only means there is no compiled library to link against, it is used +purely by including its headers directly into source files. + +Installation +~~~~~~~~~~~~ + +The |openbt| Meson build system satisfies the Eigen dependence automatically. +First, Meson uses different techniques to search for an existing Eigen +installation. If found, that installation is used for the build. If not found, +Meson falls back to the ``subprojects/eigen.wrap`` file, which instructs it to +download a pinned Eigen version automatically from Eigen's repository and use it +internally for that build. As a result, Eigen is always available to the build +regardless of whether it is preinstalled on the system. + +Developers using macOS who need to test the build system or who prefer to have a +system-wide installation can install Eigen |via| Homebrew: + +.. code-block:: console + + $ brew install eigen + +Meson Build +----------- +.. _Meson: https://mesonbuild.com +.. _ninja: https://ninja-build.org + +The |openbt| Python package uses the Meson_ build system together with its +ninja_ backend to compile the C++ command line tools during installation. +Please refer to the relevant installation instructions to determine if manual +installation of these tools is required for a particular task. + +Please refer to the documentation in ``tools/build_openbt_clt.sh`` script for +information about using that script, for an example of how to configure and use +the Meson build system, and for potential build difficulties (|eg| due to +intermediate and cached files). + +Build Process with Python +~~~~~~~~~~~~~~~~~~~~~~~~~ + +The Meson build is not invoked directly by developers working on or testing the +Python package. The build is triggered automatically when the |openbt| Python +package is installed |via| + +.. code-block:: console + + $ cd /path/to/OpenBT/openbt_pypkg + $ python -m pip install . + +or in editable mode |via| + +.. code-block:: console + + $ python -m pip install -e . + +It is also invoked automatically to build wheels. We generally refer to this +automated process as a "package build." + +Internally, ``setup.py`` defines a custom ``build_clt`` command that wipes and +rebuilds the Meson build directory ``openbt_pypkg/cpp/builddir`` from scratch on +every package build, forcing Meson to re-detect the compiler, MPI, and Eigen +installations rather than reusing stale detection results. Developers who need +the exact Meson invocation can inspect ``build_clt`` in ``setup.py`` directly. + +A successful package build creates the following files and directories: + +* ``openbt_pypkg/cpp/builddir/`` — Meson's working build directory. Build + output including object files are stored here. Since this directory is wiped + and recreated on every package build, it can be deleted safely at any time. + +* ``openbt_pypkg/src/openbt/_version.py`` — Written by ``setuptools_scm`` + from the current git tag, not by Meson. + +Note that while ``openbt_pypkg/cpp`` officially contains the package's C++ +source code and Meson build system, its contents simply alias the actual code +and build system defined at the root of the repository. Therefore, for example, +all intermediate and cached issues associated with the base folder also exist +for package builds. + Tox --- -.. _tox Usage: https://tox.wiki/en/latest/index.html -.. _Oliver Bestwalter: https://youtu.be/PrAyvH-tm8E +.. _tox setup: https://tox.wiki/en/latest/index.html Developers are free to setup whatever environment that they may need to -facilitate their work. However, the |openbt| Python package includes a -`tox Usage`_ setup, which developers can also use to automatically setup and -manage dedicated virtual environments for different predefined development tasks. +facilitate their work with the Python package. However, the package includes a +`tox setup`_, which developers can also use to automatically setup and manage +dedicated virtual environments for different predefined development tasks. Some +tasks are more broadly useful at the level of the whole repository since they +can, for instance, build the User Guides for all |openbt| tools. Development with |tox| ~~~~~~~~~~~~~~~~~~~~~~ @@ -23,7 +112,7 @@ no need to manually activate its virtual environment. .. note:: Developers that would like to use |tox| should, at the very least, learn enough about it that they understand the difference between running ``tox`` - and ``tox -r``. + and ``tox -r``. Some potential issues are highlighted below. .. code-block:: console @@ -47,7 +136,7 @@ needs. $ mkdir -p $HOME/local/bin $ ln -s $HOME/local/venv/.toxbase/bin/tox $HOME/local/bin/tox - $ vi $HOME/.bash_profile + $ vi $HOME/.bash_profile (add $HOME/local/bin to PATH) $ . $HOME/.bash_profile $ which tox $ tox --version @@ -62,19 +151,24 @@ full list of available environments and what each one does: $ tox list -v -Environments can be combined in a single invocation, e.g. -``tox -r -e report,coverage``. Users needing ``pdf`` should note that |tox| -does not install ``make`` or a LaTeX distribution; those must be installed -separately. +Two or more tasks can be executed in a single invocation, (|eg| ``tox -r -e +report,coverage``). Users needing ``pdf`` should note that |tox| does not +install ``make`` or a LaTeX distribution; those must be installed separately. + +The |tox| tool caches all of its virtual environments in ``openbt_pypkg/.tox/``. +Running ``tox -r `` forces a clean environment rebuild including +installation of (potentially more modern) dependencies and a full package build +from scratch. Happily, developers can activate and work directly in |tox|'s +cached virtual environments. Direct use of |tox| virtual environments ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Many of the |tox| tasks will build the |openbt| binary automatically each time -they are run, which can significantly slow development work. In such cases, a -developer will likely start their work by creating a clean virtual environment -for their task using ``tox -r`` and subsequently load and work in that virtual -environment directly. +they are run, which can significantly slow development work. In such cases, +developer productivity can benefit from creating a clean virtual environment for +their task using ``tox -r `` and subsequently loading and working in that +virtual environment directly. Developers can inspect ``tox.ini`` to see what commands are run by their task and adapt these for their work. @@ -97,7 +191,7 @@ particularly useful since the package is installed in editable mode and therefore facilitates interactive development and testing of the Python code. The ``html`` environment can be activated directly in the same way to rebuild -documentation iteratively without paying the cost of a full |tox| rebuild each +documentation iteratively without paying the cost of a full package rebuild each time: .. code-block:: console @@ -108,125 +202,29 @@ time: $ which sphinx-build $ sphinx-build -W -E -b html ../docs ../docs/build_html -Eigen ------ -.. _Eigen: https://gitlab.com/libeigen/eigen - -Eigen_ is a header-only C++ template library for linear algebra. Being -header-only means there is no compiled library to link against, it is used -purely by including its headers directly into source files. - -Installation -~~~~~~~~~~~~ - -Eigen does not need to be installed manually. The |openbt| Meson build system -handles Eigen automatically in two steps. First, Meson searches for an -existing system-wide Eigen installation discoverable |via| ``pkg-config``. If -found, that installation is used for the build. If not found, Meson falls back -to the ``subprojects/eigen.wrap`` file, which instructs it to download a -pinned Eigen version automatically from GitLab and use it internally for that -build. As a result, Eigen is always available to the build regardless of -whether it is installed on the system. - -Developers on macOS who prefer to have a system-wide installation can install -Eigen |via| Homebrew: - -.. code-block:: console - - $ brew install eigen - - -Meson Build ------------ -.. _Meson: https://mesonbuild.com -.. _ninja: https://ninja-build.org - -The |openbt| Python package uses the Meson_ build system together with its -ninja_ backend to compile the C++ command line tools during installation. -Meson must be installed and available on ``PATH`` before building the package. -Please refer to :ref:`get_started_cpp:Meson installation` for detailed -installation instructions. - -Build Process with Python -~~~~~~~~~~~~~~~~~~~~~~~~~ - -The Meson build is not invoked directly by developers. It is triggered -automatically when the |openbt| Python package is installed |via| - -.. code-block:: console - - $ cd /path/to/OpenBT/openbt_pypkg - $ python -m pip install . - -or in editable mode |via| - -.. code-block:: console - - $ python -m pip install -e . - -Internally, ``setup.py`` defines a custom ``build_clt`` command that wipes and -rebuilds ``cpp/builddir`` from scratch on every install, forcing Meson to -re-detect the compiler, MPI, and Eigen installations rather than reusing -stale detection results. Developers who need the exact Meson invocation can -inspect ``build_clt`` in ``setup.py`` directly. - -Files and Directories Created -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -A successful ``pip install`` creates the following files and directories: - -* ``openbt_pypkg/cpp/builddir/`` — Meson's working build directory. Ninja - compiles all C++ source files into object files. This directory is wiped and recreated on - every ``pip install`` and can be deleted safely at any time. - -* ``openbt_pypkg/src/openbt/bin/`` — The compiled C++ command line tools - installed by ``meson install``. Only a subset of these are included in the - distributed package; the rest are still compiled and installed to disk. - See ``cpp/meson.build`` for the current list of built tools. - -* ``openbt_pypkg/src/openbt/include/eigen3/`` — Eigen headers installed - under the package prefix as a side effect of Eigen's own Meson install - step, regardless of whether Eigen came from the system or the bundled - ``subprojects/eigen.wrap``. - -* ``openbt_pypkg/src/openbt/lib/pkgconfig/eigen3.pc`` — A ``pkg-config`` - file for the installed Eigen, with its ``prefix`` pointing into - ``src/openbt/``. - -* ``openbt_pypkg/src/openbt/_version.py`` — Written by ``setuptools_scm`` - from the current git tag, not by Meson. - Caching ~~~~~~~ - -There are four caching layers involved in the build, each with different -behaviour on a recompile: - -* ``subprojects/packagecache/`` — Stores the downloaded Eigen tarball and its - patch so that Meson does not re-download them on every build. - ``--clearcache`` does not clear this directory; it persists intentionally - across builds. - -* ``cpp/builddir/`` — Ninja's compile cache of object files. Because - ``meson setup --wipe`` is run on every ``pip install``, this cache is never - reused between installs and is always rebuilt from scratch. - -* ``src/openbt/{bin,include,lib}/`` — The install destination written by - ``meson install``. This is the most problematic caching layer: ``meson - install`` overlays new files onto these directories but never removes +Tox tasks that build the |openbt| package in editable mode install build +products, such as the command line tools, directly in a developer's clone rather +than caching them inside the task's ``openbt_pypkg/.tox/`` folder. These +cached files, which can occasionally cause issues, are + +* ``openbt_pypkg/src/openbt/{bin,include,lib}/`` — The install destination + populated by ``meson install``. This is the most problematic caching layer: + ``meson install`` overlays new files onto these directories but never removes stale ones. If a binary is renamed, a tool is removed from the build, or - Eigen headers change, the old files persist silently. When the build - produces unexpected behaviour, these directories should be deleted manually - before reinstalling: - - .. code-block:: console + Eigen headers change, the old files persist silently. Consider deleting these + if the build produces unexpected behaviour. Note that, of these contents, + only a subset of the command line tools in ``bin`` is included in a package + build. See ``meson.build`` for the current list of built tools. - $ rm -rf openbt_pypkg/src/openbt/bin/ - $ rm -rf openbt_pypkg/src/openbt/include/ - $ rm -rf openbt_pypkg/src/openbt/lib/ +* ``openbt_pypkg/src/openbt/include/eigen3/`` — Eigen headers installed + under the package prefix as a side effect of Eigen's own Meson install step, + regardless of whether Eigen came from the system or the bundled + ``subprojects/eigen.wrap``. These files are uninmportant once the command + line tools are built and are not included in package distributions. -* ``openbt_pypkg/.tox/`` — |tox| virtual environments each contain their own - installed copy of the |openbt| package and compiled binaries. Running - ``tox`` without ``-r`` reuses the existing environment and does not - reinstall |openbt| or rerun the Meson build. Running ``tox -r`` forces a - clean environment rebuild and a full ``pip install`` from scratch. \ No newline at end of file +* ``openbt_pypkg/src/openbt/lib/pkgconfig/eigen3.pc`` — A ``pkg-config`` + file for the installed Eigen, with its ``prefix`` pointing into + ``src/openbt/``, that is installed as a side effect. This file is unimportant + and is not included in package distributions. diff --git a/openbt_pypkg/tox.ini b/openbt_pypkg/tox.ini index 86a4cb1..0f9f69e 100644 --- a/openbt_pypkg/tox.ini +++ b/openbt_pypkg/tox.ini @@ -8,7 +8,9 @@ requires = tox>=4 env_list = [testenv] -description = Run OpenBT's full test suite with or without coverage +description = + coverage: Run OpenBT's full test suite with coverage + nocoverage: Run OpenBT's full test suite without coverage passenv = COVERAGE_HTML COVERAGE_XML @@ -28,7 +30,10 @@ commands = coverage: coverage run --rcfile={toxinidir}/.coveragerc --data-file={env:COV_FILE} -m pytest ./src/openbt/tests [testenv:report] -description = Generate XML and HTML format coverage reports +description = Write coverage results to stdout as well as generate XML and HTML + format coverage reports. This is typically run after or at the same time as + the coverage task. See tox.ini for information on env vars that control + where the reports are written. depends = coverage deps = coverage skip_install = true @@ -38,8 +43,7 @@ commands = coverage report --data-file={env:COV_FILE} [testenv:check] -# The work done in this task does not alter any files. -description = Check code against typical Python standards +description = Check code against typical Python standards. This task does not alter any files. deps = setuptools flake8 diff --git a/tools/build_openbt_clt.sh b/tools/build_openbt_clt.sh index b5a58c3..e1292aa 100755 --- a/tools/build_openbt_clt.sh +++ b/tools/build_openbt_clt.sh @@ -12,6 +12,24 @@ # This script returns exit codes that should make it compatible with use in CI # build processes. # +# Intermediate & cached files +# --------------------------- +# This script has Meson create and use the /path/to/OpenBT/builddir folder for +# the build. Developers can use this script to create that folder and then use +# Meson manually with that folder to develop and test the code. Users could +# similarly use the contents of the script to guide custom builds. The Meson +# setup, compile, and install commands in the script might provide a good +# starting point for such efforts. +# +# While the /path/to/OpenBT/subprojects folder does contain necessary files +# under version control, it can also contain cached third-party dependencies +# such as Eigen's source code. The subprojects/packagecache folder can also +# contain cached files such as third-party dependence tarballs and patches. +# Please note that setting up the Meson build directory with the --clearcache +# flag does **not** remove such files. Rather, they intentionally persist +# across builds. Consider reviewing those contents if Meson uses Eigen versions +# or installations different from those intended. +# #####----- HARDCODED VALUES use_mpi=true From 4554a64e63938324ec6d10010ec7a8a7f27481de Mon Sep 17 00:00:00 2001 From: Jared O'Neal Date: Fri, 24 Jul 2026 12:00:12 -0500 Subject: [PATCH 13/17] Cleaning docs as part of PR review. --- docs/examples_r.rst | 18 +++++++----------- docs/get_started_r.rst | 20 ++++++++++++++------ docs/git_workflow.rst | 25 ++++++++++++++----------- 3 files changed, 35 insertions(+), 28 deletions(-) diff --git a/docs/examples_r.rst b/docs/examples_r.rst index 072d839..8ac12f9 100644 --- a/docs/examples_r.rst +++ b/docs/examples_r.rst @@ -2,9 +2,10 @@ Examples ======== .. _Branin: https://www.sfu.ca/~ssurjano/branin.html -To use |openbt| in R, install the ``Ropenbt`` front-end R interface as -described in :doc:`get_started_r`, then let's create a test function. A -popular one is the Branin_ function: +To use |openbt| in R, install ``Ropenbt`` as described in :doc:`get_started_r`. +This example assumes that the command line tools were built with MPI support. + +Let's create a test function. A popular one is the Branin_ function: .. code-block:: r @@ -25,7 +26,7 @@ popular one is the Branin_ function: } - # Simulate branin data for testing + # Simulate Branin data for testing set.seed(99) n=500 p=2 @@ -34,7 +35,7 @@ popular one is the Branin_ function: for(i in 1:n) y[i] = braninsc(x[i,]) And then we can load the ``Ropenbt`` package and fit a BART model. Here we set -the model type as ``model="bart"`` which ensures we fit a homoscedastic BART +the model type as ``model="bart"``, which ensures that we fit a homoscedastic BART model. The number of MPI threads to use is specified as ``tc=4``. For a list of all optional parameters, see ``args(openbt)``. @@ -85,13 +86,8 @@ A more accurate alternative is to calculate the Sobol' indices. .. code-block:: r - # Calculate Sobol indices + # Calculate Sobol' indices fits=sobol.openbt(fit2) fits$msi fits$mtsi fits$msij - -The ``Ropenbt`` package does not currently ship a dedicated automated test -suite of its own; the steps above (fitting the Branin function and checking -that predictions track the observed values) are a reasonable smoke test that -your installation is working end to end. \ No newline at end of file diff --git a/docs/get_started_r.rst b/docs/get_started_r.rst index 600628c..5ccc551 100644 --- a/docs/get_started_r.rst +++ b/docs/get_started_r.rst @@ -2,10 +2,14 @@ Getting Started with R ======================= .. _remotes: https://remotes.r-lib.org -Installed versions of the |openbt| R package, ``Ropenbt``, provide a front-end -R interface that wraps a dedicated set of |openbt| C++ command line tools. -To build these tools, follow the :doc:`get_started_cpp` guide to build, install, -and test them before continuing. +Installed versions of the |openbt| R package, ``Ropenbt``, provide a front-end R +interface that wraps a dedicated set of |openbt| C++ command line tools. The +package locates and calls the already-built command line tools (such as +``openbtcli``) by first searching the folders specified in ``PATH``. If they +are not found, it searches the current working directory as a fallback. + +Follow the :doc:`get_started_cpp` guide to build, install, and test the tools +before continuing. Install Ropenbt ------------------------- @@ -27,5 +31,9 @@ Note that some ``Ropenbt`` package dependencies may also be installed. Since ``Ropenbt`` itself needs no compilation, this step is quick regardless of platform. -See :doc:`examples_r` for a worked example of fitting a model with -``Ropenbt``. +Testing +------- +The ``Ropenbt`` package does not currently ship a dedicated automated test suite +of its own. However, executing the full set of steps detailed in +:doc:`examples_r` is a reasonable smoke test that your installation is working +end to end. diff --git a/docs/git_workflow.rst b/docs/git_workflow.rst index 4cb4bfc..e3931dd 100644 --- a/docs/git_workflow.rst +++ b/docs/git_workflow.rst @@ -1,7 +1,5 @@ Git Workflow ============ -Since we are currently standing this repository up, we are working with an -informal git workflow. A minimal set of rules are .. note:: @@ -10,6 +8,9 @@ informal git workflow. A minimal set of rules are which might result in unwanted side effects. Rather, a gatekeeper should resolve the conflicts in a local clone, merge locally, and push. +Since we are currently standing this repository up, we are working with an +informal git workflow. A minimal set of rules are + #. No one should make direct commits to the ``main`` branch. #. Each addition and change should be made on a dedicated feature branch that is based off of the latest commit on the ``main`` branch. Try to group related @@ -66,29 +67,31 @@ Documentation Python Package Testing ~~~~~~~~~~~~~~~~~~~~~~ -* **Test OpenBT Python Source Distribution** — The primary test action. Builds +* **Test |openbt| Python Source Distribution** — The primary test action. Builds a Python source distribution and tests it across a matrix of operating systems, MPI implementations, and Python versions to validate broad - compatibility. The built source distribution is also uploaded as an - artifact for manual upload to PyPI at release time. This action additionally - runs on published releases. + compatibility. This action additionally runs on published releases so that + the source distribution built and tested by the action, which is stored as an + artifact, can be manually uploaded to PyPI as the official release + distribution. -* **Test OpenBT Developer-mode Installation** — Tests the editable installation +* **Test |openbt| Developer-mode Installation** — Tests the editable installation (``pip install -e .``) on a reduced matrix. MPI is intentionally installed |via| |pip| rather than a system package manager to confirm that pip-installed MPI implementations work correctly. -* **Test OpenBT in Anaconda** — Tests installation inside a conda environment - across a matrix of operating systems using a prebuilt Open MPI installed |via| |pip|. +* **Test |openbt| in Anaconda** — Tests installation inside a conda environment + across a matrix of operating systems and installs |via| |pip| a prebuilt + Open MPI installation included in a Python package. -* **Measure OpenBT Python Coverage** — Runs the full Python test suite with +* **Measure |openbt| Python Coverage** — Runs the full Python test suite with coverage measurement using |tox| and uploads the raw coverage file, XML report, and HTML report as artifacts. C++ Tools Testing ~~~~~~~~~~~~~~~~~ -* **Test OpenBT C++ Command Line Tools** — Builds and tests the C++ command +* **Test |openbt| C++ Command Line Tools** — Builds and tests the C++ command line tools directly across a matrix of operating systems and MPI implementations, independently of the Python package. Prints dynamic library linkage information for each built binary so that developers can verify the correct MPI implementation was linked. From 1e3aaff19da9cdea1da19d3513932f8fb3d890b3 Mon Sep 17 00:00:00 2001 From: Jared O'Neal Date: Fri, 24 Jul 2026 15:18:18 -0500 Subject: [PATCH 14/17] Clean up content as part of PR review. It was important to tie cached files at the root level -- editable installations -- rather than to tox. Apparently sphinx substitutions don't work inside bold environments. --- docs/developer_environment.rst | 54 +++++++++++++++++++--------------- docs/git_workflow.rst | 10 +++---- 2 files changed, 35 insertions(+), 29 deletions(-) diff --git a/docs/developer_environment.rst b/docs/developer_environment.rst index a997662..e26011e 100644 --- a/docs/developer_environment.rst +++ b/docs/developer_environment.rst @@ -91,6 +91,33 @@ and build system defined at the root of the repository. Therefore, for example, all intermediate and cached issues associated with the base folder also exist for package builds. +Editable Python package installations install build products, such as the +command line tools, directly in a developer's clone rather than inside the +Python execution environment (|eg| within the ``site-packages`` folder of a +virtual environment). These cached files, which can occasionally cause issues, +are + +* ``openbt_pypkg/src/openbt/{bin,include,lib}/`` — The install destination + populated by ``meson install``. This is the most problematic caching layer: + ``meson install`` overlays new files onto these directories but never removes + stale ones. If a binary is renamed, a tool is removed from the build, or + Eigen headers change, the old files persist silently. Consider deleting these + if the build produces unexpected behaviour. Note that, of these contents, + only a subset of the command line tools in ``bin`` is included in a package + build. See ``meson.build`` for the current list of built tools. + +* ``openbt_pypkg/src/openbt/include/eigen3/`` — Eigen headers installed + under the package prefix as a side effect of Eigen's own Meson install step, + regardless of whether Eigen came from the system or the bundled + ``subprojects/eigen.wrap``. These files are unimportant once the command + line tools are built and are not included in package distributions. + +* ``openbt_pypkg/src/openbt/lib/pkgconfig/eigen3.pc`` — A ``pkg-config`` + file for the installed Eigen, with its ``prefix`` pointing into + ``src/openbt/``, that is installed as a side effect. This file is unimportant + and is not included in package distributions. + + Tox --- .. _tox setup: https://tox.wiki/en/latest/index.html @@ -204,27 +231,6 @@ time: Caching ~~~~~~~ -Tox tasks that build the |openbt| package in editable mode install build -products, such as the command line tools, directly in a developer's clone rather -than caching them inside the task's ``openbt_pypkg/.tox/`` folder. These -cached files, which can occasionally cause issues, are - -* ``openbt_pypkg/src/openbt/{bin,include,lib}/`` — The install destination - populated by ``meson install``. This is the most problematic caching layer: - ``meson install`` overlays new files onto these directories but never removes - stale ones. If a binary is renamed, a tool is removed from the build, or - Eigen headers change, the old files persist silently. Consider deleting these - if the build produces unexpected behaviour. Note that, of these contents, - only a subset of the command line tools in ``bin`` is included in a package - build. See ``meson.build`` for the current list of built tools. - -* ``openbt_pypkg/src/openbt/include/eigen3/`` — Eigen headers installed - under the package prefix as a side effect of Eigen's own Meson install step, - regardless of whether Eigen came from the system or the bundled - ``subprojects/eigen.wrap``. These files are uninmportant once the command - line tools are built and are not included in package distributions. - -* ``openbt_pypkg/src/openbt/lib/pkgconfig/eigen3.pc`` — A ``pkg-config`` - file for the installed Eigen, with its ``prefix`` pointing into - ``src/openbt/``, that is installed as a side effect. This file is unimportant - and is not included in package distributions. +As noted above, some |tox| tasks build the |openbt| package in editable mode. +They, therefore, can suffer from the potential caching issues mentioned above +for direct editable installations of the package. diff --git a/docs/git_workflow.rst b/docs/git_workflow.rst index e3931dd..032d648 100644 --- a/docs/git_workflow.rst +++ b/docs/git_workflow.rst @@ -67,7 +67,7 @@ Documentation Python Package Testing ~~~~~~~~~~~~~~~~~~~~~~ -* **Test |openbt| Python Source Distribution** — The primary test action. Builds +* **Test** |openbt| **Python Source Distribution** — The primary test action. Builds a Python source distribution and tests it across a matrix of operating systems, MPI implementations, and Python versions to validate broad compatibility. This action additionally runs on published releases so that @@ -75,23 +75,23 @@ Python Package Testing artifact, can be manually uploaded to PyPI as the official release distribution. -* **Test |openbt| Developer-mode Installation** — Tests the editable installation +* **Test** |openbt| **Developer-mode Installation** — Tests the editable installation (``pip install -e .``) on a reduced matrix. MPI is intentionally installed |via| |pip| rather than a system package manager to confirm that pip-installed MPI implementations work correctly. -* **Test |openbt| in Anaconda** — Tests installation inside a conda environment +* **Test** |openbt| **in Anaconda** — Tests installation inside a conda environment across a matrix of operating systems and installs |via| |pip| a prebuilt Open MPI installation included in a Python package. -* **Measure |openbt| Python Coverage** — Runs the full Python test suite with +* **Measure** |openbt| **Python Coverage** — Runs the full Python test suite with coverage measurement using |tox| and uploads the raw coverage file, XML report, and HTML report as artifacts. C++ Tools Testing ~~~~~~~~~~~~~~~~~ -* **Test |openbt| C++ Command Line Tools** — Builds and tests the C++ command +* **Test** |openbt| **C++ Command Line Tools** — Builds and tests the C++ command line tools directly across a matrix of operating systems and MPI implementations, independently of the Python package. Prints dynamic library linkage information for each built binary so that developers can verify the correct MPI implementation was linked. From 7fe9599d8630f3b8be3eee97c952c5b5d957971e Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Sun, 26 Jul 2026 19:47:59 -0400 Subject: [PATCH 15/17] Added some untracked files in gitignore --- .gitignore | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 11f91bc..6ff199f 100644 --- a/.gitignore +++ b/.gitignore @@ -34,6 +34,9 @@ openbt_pypkg/coverage.xml openbt_pypkg/htmlcov openbt_pypkg/src/openbt.egg-info openbt_pypkg/src/openbt/_version.py +openbt_pypkg/src/openbt/include/ +openbt_pypkg/src/openbt/lib/ + # Other files -.DS_Store +.DS_Store \ No newline at end of file From f1bca0493c2dcaaf807188b61419aed1032078fd Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Sun, 26 Jul 2026 20:27:04 -0400 Subject: [PATCH 16/17] resolved broken commands --- docs/developer_environment.rst | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/developer_environment.rst b/docs/developer_environment.rst index e26011e..6cbb816 100644 --- a/docs/developer_environment.rst +++ b/docs/developer_environment.rst @@ -44,8 +44,8 @@ ninja_ backend to compile the C++ command line tools during installation. Please refer to the relevant installation instructions to determine if manual installation of these tools is required for a particular task. -Please refer to the documentation in ``tools/build_openbt_clt.sh`` script for -information about using that script, for an example of how to configure and use +Please refer to the documentation in ``tools/build_openbt_clt.sh`` for +information about using that tool, for an example of how to configure and use the Meson build system, and for potential build difficulties (|eg| due to intermediate and cached files). @@ -183,7 +183,7 @@ report,coverage``). Users needing ``pdf`` should note that |tox| does not install ``make`` or a LaTeX distribution; those must be installed separately. The |tox| tool caches all of its virtual environments in ``openbt_pypkg/.tox/``. -Running ``tox -r `` forces a clean environment rebuild including +Running ``tox -r -e `` forces a clean environment rebuild including installation of (potentially more modern) dependencies and a full package build from scratch. Happily, developers can activate and work directly in |tox|'s cached virtual environments. @@ -194,7 +194,7 @@ Direct use of |tox| virtual environments Many of the |tox| tasks will build the |openbt| binary automatically each time they are run, which can significantly slow development work. In such cases, developer productivity can benefit from creating a clean virtual environment for -their task using ``tox -r `` and subsequently loading and working in that +their task using ``tox -r -e `` and subsequently loading and working in that virtual environment directly. Developers can inspect ``tox.ini`` to see what commands are run by their task @@ -211,7 +211,7 @@ The following example shows how to run only a single test case using the $ which python $ python --version $ python -m pip list - $ python -m pytest openbt.tests.test_brt + $ python -m pytest --pyargs openbt.tests.test_mixing Note that using the ``coverage`` virtual environment directly can be particularly useful since the package is installed in editable mode and From 3f718dbf9cc8d9492f5e7919e573a8a553bb8279 Mon Sep 17 00:00:00 2001 From: Sarthakmistry Date: Sun, 26 Jul 2026 20:27:52 -0400 Subject: [PATCH 17/17] changed wordings for clarity --- docs/examples_r.rst | 2 +- docs/git_workflow.rst | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/examples_r.rst b/docs/examples_r.rst index 8ac12f9..c78dea0 100644 --- a/docs/examples_r.rst +++ b/docs/examples_r.rst @@ -36,7 +36,7 @@ Let's create a test function. A popular one is the Branin_ function: And then we can load the ``Ropenbt`` package and fit a BART model. Here we set the model type as ``model="bart"``, which ensures that we fit a homoscedastic BART -model. The number of MPI threads to use is specified as ``tc=4``. For a list +model. The number of MPI processes to use is specified as ``tc=4``. For a list of all optional parameters, see ``args(openbt)``. .. code-block:: r diff --git a/docs/git_workflow.rst b/docs/git_workflow.rst index 032d648..60c3fcd 100644 --- a/docs/git_workflow.rst +++ b/docs/git_workflow.rst @@ -50,13 +50,13 @@ All of the following actions run automatically on every push and pull request to Documentation ~~~~~~~~~~~~~ -* **Check Spelling** — Checks all ``.rst`` and ``.md`` files in the repository +* **Check Spelling** — Checks all files in the repository for typographic errors using the ``typos`` tool with the ``typos.toml`` configuration file. * **Check Links** — Checks all ``.rst`` and ``.md`` files for broken URLs using the ``lychee`` tool. In addition to running on push and pull request, this - action runs on a weekly schedule to catch links that break between + action runs on a regular schedule to catch links that break between contributions. * **Build Sphinx Docs** — Builds the |openbt| documentation in both HTML and