diff --git a/.github/ISSUE_TEMPLATE/BUG_REPORT.yaml b/.github/ISSUE_TEMPLATE/BUG_REPORT.yaml new file mode 100644 index 0000000..6bbe0ad --- /dev/null +++ b/.github/ISSUE_TEMPLATE/BUG_REPORT.yaml @@ -0,0 +1,50 @@ +name: 🐛 Bug report +description: Create a report to help us improve 🤔. +labels: ["bug"] + +body: + - type: markdown + attributes: + value: Thank you for reporting a bug! Before you do so, please ensure that you have tested on the latest released version of the code. If it does, please also use the search to see if there are any other related issues or pull requests. + + - type: textarea + attributes: + label: Environment + description: Please give the actual version number (_e.g._ 0.1.0) if you are using a release version, or the first 7-8 characters of the commit hash if you have installed from `git`. If anything else is relevant, you can add it to the list. + # The trailing spaces on the following lines are to make filling the form + # in easier. The type is 'textarea' rather than three separate 'input's + # to make the resulting issue body less noisy with headings. + value: | + - **qiskit-addon-sqd version**: + - **Python version**: + - **Operating system**: + validations: + required: true + + - type: textarea + attributes: + label: What is happening and why is it wrong? + description: A short description of what is going wrong, in words. + validations: + required: true + + - type: textarea + attributes: + label: How can we reproduce the issue? + description: Give some steps that show the bug. A [minimal working example](https://stackoverflow.com/help/minimal-reproducible-example) of code with output is best. If you are copying in code, please remember to enclose it in triple backticks (` ``` [multiline code goes here] ``` `) so that it [displays correctly](https://docs.github.com/en/github/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax). + validations: + required: true + + - type: textarea + attributes: + label: Traceback + description: If your code provided an error traceback, please paste it below, enclosed in triple backticks (` ``` [multiline code goes here] ``` `) so that it [displays correctly](https://docs.github.com/en/github/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax). + validations: + required: false + + - type: textarea + attributes: + label: Any suggestions? + description: Not required, but if you have suggestions for how a contributor should fix this, or any problems we should be aware of, let us know. + validations: + required: false diff --git a/.github/ISSUE_TEMPLATE/FEATURE_REQUEST.yaml b/.github/ISSUE_TEMPLATE/FEATURE_REQUEST.yaml new file mode 100644 index 0000000..4b66a76 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/FEATURE_REQUEST.yaml @@ -0,0 +1,14 @@ +name: 🚀 Feature request +description: Suggest an idea for this project 💡! +labels: ["type: feature request"] + +body: + - type: markdown + attributes: + value: Please make sure to browse the opened and closed issues to make sure that this idea has not previously been discussed. + + - type: textarea + attributes: + label: What should we add? + validations: + required: true diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..7141543 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,13 @@ +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + labels: ["dependencies"] + schedule: + interval: "weekly" + - package-ecosystem: "pip" + directory: "/" + labels: ["dependencies"] + versioning-strategy: increase + schedule: + interval: "monthly" diff --git a/.github/workflows/README.md b/.github/workflows/README.md new file mode 100644 index 0000000..f0a38a9 --- /dev/null +++ b/.github/workflows/README.md @@ -0,0 +1,37 @@ +# GitHub Actions workflows + +This directory contains a number of workflows for use with [GitHub Actions](https://docs.github.com/actions). They specify what standards should be expected for development of this software, including pull requests. These workflows are designed to work out of the box for any research software prototype, especially those based on [Qiskit](https://qiskit.org/). + +## Lint check (`lint.yml`) + +This workflow checks that the code is formatted properly and follows the style guide by installing tox and running the [lint environment](/tests/#lint-environment) (`tox -e lint`). + +## Latest version tests (`test_latest_versions.yml`) + +This workflow installs the latest version of tox and runs [the current repository's tests](/tests/#test-py-environments) under each supported Python version on Linux and under a single Python version on macOS and Windows. This is the primary testing workflow. It runs for all code changes and additionally once per day, to ensure tests continue to pass as new versions of dependencies are released. + +## Development version tests (`test_development_versions.yml`) + +This workflow installs tox and modifies `pyproject.toml` to use the _development_ versions of certain Qiskit packages, using [extremal-python-dependencies](https://github.com/IBM/extremal-python-dependencies). For all other packages, the latest version is installed. This workflow runs on two versions of Python: the minimum supported version and the maximum supported version. Its purpose is to identify as soon as possible (i.e., before a Qiskit release) when changes in Qiskit will break the current repository. This workflow runs for all code changes, as well as on a timer once per day. + +## Minimum version tests (`test_minimum_versions.yml`) + +This workflow first installs the minimum supported tox version (the `minversion` specified in [`tox.ini`](/tox.ini)) and then installs the _minimum_ compatible version of each package listed in `pyproject.toml`, using [extremal-python-dependencies](https://github.com/IBM/extremal-python-dependencies). The purpose of this workflow is to make sure the minimum version specifiers in these files are accurate, i.e., that the tests actually pass with these versions. This workflow uses a single Python version, typically the oldest supported version, as the minimum supported versions of each package may not be compatible with the most recent Python release. + +Under the hood, this workflow uses a regular expression to change each `>=` and `~=` specifier in the dependencies to instead be `==`, as pip [does not support](https://github.com/pypa/pip/issues/8085) resolving the minimum versions of packages directly. Unfortunately, this means that the workflow will only install the minimum version of a package if it is _explicitly_ listed in one of the requirements files with a minimum version. For instance, if the only listed dependency is `qiskit>=1.0`, this workflow will install `qiskit==1.0` along with the latest version of each transitive dependency, such as `rustworkx`. + +## Code coverage (`coverage.yml`) + +This workflow tests the [coverage environment](/tests/#coverage-environment) on a single version of Python by installing tox and running `tox -e coverage`. + +## Documentation (`docs.yml`) + +This workflow ensures that the [Sphinx](https://www.sphinx-doc.org/) documentation builds successfully. It also publishes the resulting build to [GitHub Pages](https://pages.github.com/) if it is from the appropriate branch (e.g., `main`). + +## Citation preview (`citation.yml`) + +This workflow is only triggered when the `CITATION.bib` file is changed. It ensures that the file contains only ASCII characters ([escaped codes](https://en.wikibooks.org/wiki/LaTeX/Special_Characters#Escaped_codes) are preferred, as then the `bib` file will work even when `inputenc` is not used). It also compiles a sample LaTeX document which includes the citation in its bibliography and uploads the resulting PDF as an artifact so it can be previewed (e.g., before merging a pull request). + +## Release (`release.yml`) + +This workflow is triggered by a maintainer pushing a tag that represents a release. It publishes the release to github.com and to [PyPI](https://pypi.org/). diff --git a/.github/workflows/citation.yml b/.github/workflows/citation.yml new file mode 100644 index 0000000..6a018f0 --- /dev/null +++ b/.github/workflows/citation.yml @@ -0,0 +1,68 @@ +name: Citation preview + +on: + push: + branches: [ main ] + paths: ['CITATION.bib', '.github/workflows/citation.yml'] + pull_request: + branches: [ main ] + paths: ['CITATION.bib', '.github/workflows/citation.yml'] + +jobs: + build-preview: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - uses: actions/checkout@v4 + - name: Check for non-ASCII characters + run: | + # Fail immediately if there are any non-ASCII characters in + # the BibTeX source. We prefer "escaped codes" rather than + # UTF-8 characters in order to ensure the bibliography will + # display correctly even in documents that do not contain + # \usepackage[utf8]{inputenc}. + if [ -f "CITATION.bib" ]; then + python3 -c 'open("CITATION.bib", encoding="ascii").read()' + fi + - name: Install LaTeX + run: | + if [ -f "CITATION.bib" ]; then + sudo apt-get update + sudo apt-get install -y texlive-latex-base texlive-publishers + fi + - name: Run LaTeX + run: | + if [ -f "CITATION.bib" ]; then + arr=(${GITHUB_REPOSITORY//\// }) + export REPO=${arr[1]} + cat <<- EOF > citation-preview.tex + \documentclass[preprint,aps,physrev,notitlepage]{revtex4-2} + \usepackage{hyperref} + \begin{document} + \title{\texttt{$REPO} BibTeX test} + \maketitle + \noindent + \texttt{$REPO} + \cite{$REPO} + \bibliography{CITATION} + \end{document} + EOF + pdflatex citation-preview + fi + - name: Run BibTeX + run: | + if [ -f "CITATION.bib" ]; then + bibtex citation-preview + fi + - name: Re-run LaTeX + run: | + if [ -f "CITATION.bib" ]; then + pdflatex citation-preview + pdflatex citation-preview + fi + - name: Upload PDF + if: always() + uses: actions/upload-artifact@v4 + with: + name: citation-preview.pdf + path: citation-preview.pdf diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml new file mode 100644 index 0000000..be286f2 --- /dev/null +++ b/.github/workflows/coverage.yml @@ -0,0 +1,43 @@ +name: Code coverage + +on: + push: + branches: + - main + - 'stable/**' + pull_request: + branches: + - main + - 'stable/**' + +jobs: + coverage: + name: coverage (${{ matrix.os }}, ${{ matrix.python-version }}) + runs-on: ${{ matrix.os }} + timeout-minutes: 30 + strategy: + max-parallel: 4 + matrix: + os: [ubuntu-latest] + python-version: ["3.10"] + steps: + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install tox + run: | + python -m pip install --upgrade pip + pip install tox coverage + - name: Run coverage + run: | + tox -e coverage + - name: Convert to lcov + run: coverage3 lcov -o coveralls.lcov + - name: Upload report to Coveralls + uses: coverallsapp/github-action@v2 + with: + github-token: ${{ secrets.GITHUB_TOKEN }} + file: coveralls.lcov + format: lcov diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..a73ccdd --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,59 @@ +name: Build Sphinx docs + +on: + workflow_dispatch: + push: + tags: + - "[0-9]+.[0-9]+.[0-9]+*" + branches: + - main + - 'stable/**' + pull_request: + branches: + - main + - 'stable/**' + +jobs: + build_and_deploy_docs: + runs-on: ubuntu-latest + timeout-minutes: 20 + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: '3.9' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install tox + sudo apt-get update + sudo apt-get install -y pandoc + - name: Tell reno to name the upcoming release after the branch we are on + shell: bash + run: | + sed -i.bak -e '/unreleased_version_title:*/d' releasenotes/config.yaml + echo unreleased_version_title: \"Upcoming release \(\`\`${GITHUB_REF_NAME}\`\`\)\" >> releasenotes/config.yaml + - name: Build docs + shell: bash + run: | + tox -edocs + - name: Prepare docs artifact + if: always() + shell: bash + run: | + mkdir artifact + cp -a docs/_build/html artifact/addon_sqd_html_docs + - name: Upload docs artifact + if: always() + uses: actions/upload-artifact@v4 + with: + name: addon_sqd_html_docs + path: ./artifact + - name: Deploy docs + if: ${{ github.ref == 'refs/heads/stable/0.3' }} + uses: peaceiris/actions-gh-pages@v4 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./docs/_build/html/ diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..a7acd45 --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,32 @@ +name: Lint check + +on: + push: + branches: + - main + - 'stable/**' + pull_request: + branches: + - main + - 'stable/**' + +jobs: + lint: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - name: Set up Python 3.10 + uses: actions/setup-python@v5 + with: + python-version: '3.10' + - name: Install tox + run: | + python -m pip install --upgrade pip + pip install tox + - name: Run lint check + shell: bash + run: | + tox -elint diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..664def4 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,47 @@ +name: Publish release + +on: + push: + tags: + - "[0-9]+.[0-9]+.[0-9]+*" + +jobs: + + github: + name: github + runs-on: ubuntu-latest + steps: + - name: Checkout tag + uses: actions/checkout@v4 + with: + ref: ${{ github.ref_name }} + - name: Publish release + uses: ghalactic/github-release-from-tag@v5 + if: github.ref_type == 'tag' + with: + token: ${{ secrets.GITHUB_TOKEN }} + generateReleaseNotes: "true" + + pypi: + name: pypi + runs-on: ubuntu-latest + needs: github + environment: + name: pypi + url: https://pypi.org/p/qiskit-addon-sqd + permissions: + id-token: write + steps: + - name: Checkout tag + uses: actions/checkout@v4 + with: + ref: ${{ github.ref_name }} + - name: Install `build` tool + run: | + python -m pip install --upgrade pip + pip install build + - name: Build distribution + run: | + python -m build + - name: Publish release to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.github/workflows/test_development_versions.yml b/.github/workflows/test_development_versions.yml new file mode 100644 index 0000000..9607a04 --- /dev/null +++ b/.github/workflows/test_development_versions.yml @@ -0,0 +1,44 @@ +name: Development version tests + +on: + push: + branches: + - main + - 'stable/**' + pull_request: + branches: + - main + - 'stable/**' + schedule: + - cron: '0 1 * * *' + +jobs: + tests: + runs-on: ubuntu-latest + timeout-minutes: 30 + strategy: + max-parallel: 4 + matrix: + python-version: [3.9, 3.12] + steps: + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies (development versions) + shell: bash + run: | + python -m pip install --upgrade pip tox + python -m pip install extremal-python-dependencies==0.0.3 + extremal-python-dependencies pin-dependencies \ + "qiskit @ git+https://github.com/Qiskit/qiskit.git" \ + "pyscf @ git+https://github.com/pyscf/pyscf.git" \ + --inplace + - name: Test using tox environment + shell: bash + run: | + toxpyversion=$(echo ${{ matrix.python-version }} | sed -E 's/^([0-9]+)\.([0-9]+).*$/\1\2/') + tox -epy${toxpyversion} + tox -epy${toxpyversion}-notebook + tox -edoctest diff --git a/.github/workflows/test_latest_versions.yml b/.github/workflows/test_latest_versions.yml new file mode 100644 index 0000000..7ce2e67 --- /dev/null +++ b/.github/workflows/test_latest_versions.yml @@ -0,0 +1,45 @@ +name: Latest version tests + +on: + push: + branches: + - main + - 'stable/**' + pull_request: + branches: + - main + - 'stable/**' + schedule: + - cron: '0 1 * * *' + +jobs: + tests: + runs-on: ${{ matrix.os }} + timeout-minutes: 30 + strategy: + max-parallel: 4 + matrix: + os: [ubuntu-latest] + python-version: ["3.9", "3.10", "3.11", "3.12"] + include: + - os: macos-latest + python-version: "3.12" + - os: windows-latest + python-version: "3.12" + steps: + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install tox + - name: Test using tox environment + shell: bash + run: | + toxpyversion=$(echo ${{ matrix.python-version }} | sed -E 's/^([0-9]+)\.([0-9]+).*$/\1\2/') + tox -epy${toxpyversion} + tox -epy${toxpyversion}-notebook + tox -edoctest diff --git a/.github/workflows/test_minimum_versions.yml b/.github/workflows/test_minimum_versions.yml new file mode 100644 index 0000000..cc36322 --- /dev/null +++ b/.github/workflows/test_minimum_versions.yml @@ -0,0 +1,40 @@ +name: Minimum version tests + +on: + push: + branches: + - main + - 'stable/**' + pull_request: + branches: + - main + - 'stable/**' + +jobs: + tests: + runs-on: ubuntu-latest + timeout-minutes: 30 + strategy: + max-parallel: 4 + matrix: + python-version: [3.9] + steps: + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies (minimum versions) + shell: bash + run: | + python -m pip install --upgrade pip + python -m pip install extremal-python-dependencies==0.0.3 + pip install "tox==$(extremal-python-dependencies get-tox-minversion)" + extremal-python-dependencies pin-dependencies-to-minimum --inplace + - name: Test using tox environment + shell: bash + run: | + toxpyversion=$(echo ${{ matrix.python-version }} | sed -E 's/^([0-9]+)\.([0-9]+).*$/\1\2/') + tox -epy${toxpyversion} + tox -epy${toxpyversion}-notebook + tox -edoctest diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..05d0012 --- /dev/null +++ b/.gitignore @@ -0,0 +1,131 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ +docs/stubs/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ +.DS_Store/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..b1ca960 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,3 @@ +# Code of Conduct + +All members of this project agree to adhere to Qiskit's [code of conduct](https://github.com/Qiskit/qiskit/blob/main/CODE_OF_CONDUCT.md). diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..3d3b4c4 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,26 @@ +# Developer guide + +Development of the `qiskit-addon-sqd` package takes place [on GitHub](https://github.com/Qiskit/qiskit-addon-sqd). +The [Contributing to Qiskit](https://github.com/Qiskit/qiskit/blob/main/CONTRIBUTING.md) guide may serve as a +useful starting point, as this package builds on [Qiskit]. + +This package is written in [Python] and uses [tox] as a testing framework. A description of the available +`tox` test environments is located at [`test/README.md`](test/README.md). These environments are used in the +CI workflows, which are described at [`.github/workflows/README.md`](.github/workflows/README.md). + +Project configuration, including information about dependencies, is stored in [`pyproject.toml`](pyproject.toml). + +We use [Sphinx] for documentation and [reno] for release notes. +We use [Google style docstrings](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html), +except we omit the type of each argument, as type information is redundant with Python +[type hints](https://docs.python.org/3/library/typing.html). + +We require 100% coverage in all new code. +In rare cases where it is not possible to test a code block, we mark it with ``# pragma: no cover`` so that +the ``coverage`` tests will pass. + +[Qiskit]: https://www.ibm.com/quantum/qiskit +[Python]: https://www.python.org/ +[tox]: https://github.com/tox-dev/tox +[Sphinx]: https://www.sphinx-doc.org/ +[reno]: https://docs.openstack.org/reno/ diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..4c370ab --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,203 @@ + Copyright 2024 IBM and its contributors + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2017 IBM and its contributors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..7d1bc2d --- /dev/null +++ b/README.md @@ -0,0 +1,95 @@ +# Qiskit addon: sample-based quantum diagonalization (SQD) + +### Table of contents + +* [About](#about) +* [Documentation](#documentation) +* [Installation](#installation) +* [Computational requirements](#computational-requirements) +* [Deprecation Policy](#deprecation-policy) +* [Contributing](#contributing) +* [License](#license) +* [References](#references) + +---------------------------------------------------------------------------------------------------- + +### About + +Qiskit addons are a collection of modular tools for building utility-scale workloads powered by Qiskit. + +This package contains the Qiskit addon for sample-based quantum diagonalization (SQD) -- a technique for finding eigenvalues and eigenvectors of quantum operators, such as a quantum system Hamiltonian, using quantum and distributed classical computing together. + +Classical distributed computing is used to process samples obtained from a quantum processor, and to project and diagonalize a target Hamiltonian in a subspace spanned by them. This allows SQD to be robust to samples corrupted by quantum noise and deal with large Hamiltonians, such as chemistry Hamiltonians with millions of interaction terms, beyond the reach of any exact diagonalization methods. + +The SQD tool can target Hamiltonians expressed as linear combination of Pauli operators, or second-quantized fermionic operators. The input samples are obtained by quantum circuits defined by the user, which are believed to be good representations of eigenstates (e.g. the ground state) of a target operator. The convergence rate of SQD as a function of the number of samples improves with the sparseness of the target eigenstate. + +The projection and diagonalization steps are performed by a classical solver. We provide here two generic solvers, one for fermionic systems and another for qubit systems. Other solvers that might be more efficient for specific systems can be interfaced by the users. + +---------------------------------------------------------------------------------------------------- + +### Documentation + +All documentation is available at https://qiskit.github.io/qiskit-addon-sqd/. + +---------------------------------------------------------------------------------------------------- + +### Installation + +We encourage installing this package via `pip`, when possible: + +```bash +pip install 'qiskit-addon-sqd' +``` + +For more installation information refer to these [installation instructions](docs/install.rst). + +---------------------------------------------------------------------------------------------------- + +### Computational requirements + +The computational cost of SQD is dominated by the eigenstate solver calls. At each step of the self-consistent configuration recovery iteration, `n_batches` of eigenstate solver calls are performed. The different calls are embarrassingly parallel. In this [tutorial](docs/tutorials/01_getting_started_fermionic.ipynb), those calls are inside a `for` loop. **It is highly recommended to perform these calls in parallel**. + +The [`qiskit_addon_sqd.fermion.solve_fermion()`](qiskit_addon_sqd/fermion.py) function is multithreaded and capable of handling systems with ~25 spacial orbitals and ~10 electrons with subspace dimensions of ~$10^7$, using ~10-30 cores. + +##### Choosing subspace dimensions + +The choice of the subspace dimension affects the accuracy and runtime of the eigenstate solver. The larger the subspace the more accurate the calculation, at the cost of increasing the runtime and memory requirements. It is not known *a priori* the optimal subspace size, thus a convergence study with the subspace dimension may be performed, as described in this [example](docs/how_tos/choose_subspace_dimension.ipynb). + +##### The subspace dimension is set indirectly + +In this package, the user controls the number of bitstrings (see the `samples_per_batch` argument in [`qiskit_addon_sqd.subsampling.postselect_and_subsample()`](qiskit_addon_sqd/subsampling.py)) contained in each subspace. The value of this argument determines an upper bound to the subspace dimension in the case of quantum chemistry applications. See this [example](docs/how_tos/select_open_closed_shell.ipynb) for more details. + +---------------------------------------------------------------------------------------------------- + +### Deprecation Policy + +We follow [semantic versioning](https://semver.org/) and are guided by the principles in +[Qiskit's deprecation policy](https://github.com/Qiskit/qiskit/blob/main/DEPRECATION.md). +We may occasionally make breaking changes in order to improve the user experience. +When possible, we will keep old interfaces and mark them as deprecated, as long as they can co-exist with the +new ones. +Each substantial improvement, breaking change, or deprecation will be documented in the release notes. + +---------------------------------------------------------------------------------------------------- + +### Contributing + +The developer guide is located at [CONTRIBUTING.md](https://github.com/Qiskit/qiskit-addon-sqd/blob/main/CONTRIBUTING.md>) +in the root of this project's repository. +By participating, you are expected to uphold Qiskit's [code of conduct](https://github.com/Qiskit/qiskit/blob/main/CODE_OF_CONDUCT.md). + +We use [GitHub issues](https://github.com/Qiskit/qiskit-addon-sqd/issues/new/choose) for tracking requests and bugs. + +---------------------------------------------------------------------------------------------------- + +### License + +[Apache License 2.0](LICENSE.txt) + +---------------------------------------------------------------------------------------------------- + +### References + +[1] Javier Robledo-Moreno, et al., [Chemistry Beyond Exact Solutions on a Quantum-Centric Supercomputer](https://arxiv.org/abs/2405.05068), arXiv:2405.05068 [quant-ph]. + +[2] Keita Kanno, et al., [Quantum-Selected Configuration Interaction: classical diagonalization of Hamiltonians in subspaces selected by quantum computers](https://arxiv.org/abs/2302.11320), arXiv:2302.11320 [quant-ph]. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..6d50cc2 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,20 @@ +# Security Policy + +## Supported Versions + +The package supports one minor version release at a time, both for bug and security fixes. +For example, if the most recent release is 0.2.1, then the 0.2.x release series is currently supported. + +## Reporting a Vulnerability + +To report vulnerabilities, you can privately report a potential security issue +via the GitHub security vulnerabilities feature. This can be done here: + +https://github.com/Qiskit/qiskit-addon-sqd/security/advisories + +Please do **not** open a public issue about a potential security vulnerability. + +You can find more details on the security vulnerability feature in the GitHub +documentation here: + +https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability diff --git a/docs/_static/.gitkeep b/docs/_static/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/docs/_templates/autosummary/class.rst b/docs/_templates/autosummary/class.rst new file mode 100644 index 0000000..a2481c8 --- /dev/null +++ b/docs/_templates/autosummary/class.rst @@ -0,0 +1,32 @@ +{# + We show all the class's methods and attributes on the same page. By default, we document + all methods, including those defined by parent classes. +-#} + +{{ objname | escape | underline }} + +.. currentmodule:: {{ module }} + +.. autoclass:: {{ objname }} + :no-members: + :no-inherited-members: + :show-inheritance: + +{% block attributes_summary %} + {% if attributes %} + .. rubric:: Attributes + {% for item in attributes %} + .. autoattribute:: {{ item }} + {%- endfor %} + {% endif %} +{% endblock -%} + +{% block methods_summary %} + {% set wanted_methods = (methods | reject('==', '__init__') | list) %} + {% if wanted_methods %} + .. rubric:: Methods + {% for item in wanted_methods %} + .. automethod:: {{ item }} + {%- endfor %} + {% endif %} +{% endblock %} diff --git a/docs/apidocs/qiskit_addon_sqd.configuration_recovery.rst b/docs/apidocs/qiskit_addon_sqd.configuration_recovery.rst new file mode 100644 index 0000000..7724266 --- /dev/null +++ b/docs/apidocs/qiskit_addon_sqd.configuration_recovery.rst @@ -0,0 +1,10 @@ +====================== +Configuration Recovery +====================== + +.. _qiskit_addon_sqd-configuration_recovery: + +.. automodule:: qiskit_addon_sqd.configuration_recovery + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/apidocs/qiskit_addon_sqd.counts.rst b/docs/apidocs/qiskit_addon_sqd.counts.rst new file mode 100644 index 0000000..9d80a54 --- /dev/null +++ b/docs/apidocs/qiskit_addon_sqd.counts.rst @@ -0,0 +1,10 @@ +====== +Counts +====== + +.. _qiskit_addon_sqd-counts: + +.. automodule:: qiskit_addon_sqd.counts + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/apidocs/qiskit_addon_sqd.fermion.rst b/docs/apidocs/qiskit_addon_sqd.fermion.rst new file mode 100644 index 0000000..2470c78 --- /dev/null +++ b/docs/apidocs/qiskit_addon_sqd.fermion.rst @@ -0,0 +1,10 @@ +======= +Fermion +======= + +.. _qiskit_addon_sqd-fermion: + +.. automodule:: qiskit_addon_sqd.fermion + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/apidocs/qiskit_addon_sqd.qubit.rst b/docs/apidocs/qiskit_addon_sqd.qubit.rst new file mode 100644 index 0000000..7eec7fa --- /dev/null +++ b/docs/apidocs/qiskit_addon_sqd.qubit.rst @@ -0,0 +1,10 @@ +===== +Qubit +===== + +.. _qiskit_addon_sqd-qubit: + +.. automodule:: qiskit_addon_sqd.qubit + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/apidocs/qiskit_addon_sqd.rst b/docs/apidocs/qiskit_addon_sqd.rst new file mode 100644 index 0000000..94e67a0 --- /dev/null +++ b/docs/apidocs/qiskit_addon_sqd.rst @@ -0,0 +1,10 @@ +==================================== +Sample-based Quantum Diagonalization +==================================== + +.. _qiskit_addon_sqd: + +.. automodule:: qiskit_addon_sqd + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/apidocs/qiskit_addon_sqd.subsampling.rst b/docs/apidocs/qiskit_addon_sqd.subsampling.rst new file mode 100644 index 0000000..f043d8a --- /dev/null +++ b/docs/apidocs/qiskit_addon_sqd.subsampling.rst @@ -0,0 +1,10 @@ +=========== +Subsampling +=========== + +.. _qiskit_addon_sqd-subsampling: + +.. automodule:: qiskit_addon_sqd.subsampling + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..89bf5f2 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,176 @@ +# This code is part of a Qiskit project. +# +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +import inspect +import os +import re +import sys +from importlib.metadata import version as metadata_version + +# The following line is required for autodoc to be able to find and import the code whose API should +# be documented. +sys.path.insert(0, os.path.abspath("..")) + +project = "Sample-based Quantum Diagonalization" +project_copyright = "2024, Qiskit addons team" +description = "Classically post-process noisy samples drawn from a quantum processor to produce more accurate energy estimations" +author = "Qiskit addons team" +language = "en" +release = metadata_version("qiskit-addon-sqd") + +html_theme = "qiskit-ecosystem" + +# This allows including custom CSS and HTML templates. +html_theme_options = { + "dark_logo": "images/qiskit-dark-logo.svg", + "light_logo": "images/qiskit-light-logo.svg", + "sidebar_qiskit_ecosystem_member": False, +} +html_static_path = ["_static"] +templates_path = ["_templates"] + +# Sphinx should ignore these patterns when building. +exclude_patterns = [ + "_build", + "_ecosystem_build", + "_qiskit_build", + "_pytorch_build", + "**.ipynb_checkpoints", + "jupyter_execute", +] + +extensions = [ + "sphinx.ext.napoleon", + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.doctest", + "sphinx.ext.mathjax", + "sphinx.ext.linkcode", + "sphinx.ext.intersphinx", + "matplotlib.sphinxext.plot_directive", + "sphinx_copybutton", + "reno.sphinxext", + "nbsphinx", + "qiskit_sphinx_theme", + "pytest_doctestplus.sphinx.doctestplus", +] + +html_last_updated_fmt = "%Y/%m/%d" +html_title = f"{project} {release}" + +# This allows RST files to put `|version|` in their file and +# have it updated with the release set in conf.py. +rst_prolog = f""" +.. |version| replace:: {release} +""" + +# Options for autodoc. These reflect the values from Terra. +autosummary_generate = True +autosummary_generate_overwrite = False +autoclass_content = "both" +autodoc_typehints = "description" +autodoc_typehints_description_target = "documented_params" +autodoc_member_order = "bysource" +autodoc_default_options = { + "inherited-members": None, +} + + +# This adds numbers to the captions for figures, tables, +# and code blocks. +numfig = True +numfig_format = {"table": "Table %s"} + +# Settings for Jupyter notebooks. +nbsphinx_execute = "never" + +add_module_names = False + +modindex_common_prefix = ["qiskit_addon_sqd."] + +intersphinx_mapping = { + "python": ("https://docs.python.org/3", None), + "numpy": ("https://numpy.org/doc/stable/", None), + "qiskit": ("https://docs.quantum.ibm.com/api/qiskit/", None), + "rustworkx": ("https://www.rustworkx.org/", None), +} + +plot_working_directory = "." +plot_html_show_source_link = False + +# ---------------------------------------------------------------------------------- +# Source code links +# ---------------------------------------------------------------------------------- + + +def determine_github_branch() -> str: + """Determine the GitHub branch name to use for source code links. + + We need to decide whether to use `stable/` vs. `main` for dev builds. + Refer to https://docs.github.com/en/actions/learn-github-actions/variables + for how we determine this with GitHub Actions. + """ + # If CI env vars not set, default to `main`. This is relevant for local builds. + if "GITHUB_REF_NAME" not in os.environ: + return "main" + + # PR workflows set the branch they're merging into. + if base_ref := os.environ.get("GITHUB_BASE_REF"): + return base_ref + + ref_name = os.environ["GITHUB_REF_NAME"] + + # Check if the ref_name is a tag like `1.0.0` or `1.0.0rc1`. If so, we need + # to transform it to a Git branch like `stable/1.0`. + version_without_patch = re.match(r"(\d+\.\d+)", ref_name) + return f"stable/{version_without_patch.group()}" if version_without_patch else ref_name + + +GITHUB_BRANCH = determine_github_branch() + + +def linkcode_resolve(domain, info): + if domain != "py": + return None + + module_name = info["module"] + module = sys.modules.get(module_name) + if module is None or "qiskit_addon_sqd" not in module_name: + return None + + obj = module + for part in info["fullname"].split("."): + try: + obj = getattr(obj, part) + except AttributeError: + return None + is_valid_code_object = ( + inspect.isclass(obj) or inspect.ismethod(obj) or inspect.isfunction(obj) + ) + if not is_valid_code_object: + return None + try: + full_file_name = inspect.getsourcefile(obj) + except TypeError: + return None + if full_file_name is None or "/qiskit_addon_sqd/" not in full_file_name: + return None + file_name = full_file_name.split("/qiskit_addon_sqd/")[-1] + + try: + source, lineno = inspect.getsourcelines(obj) + except (OSError, TypeError): + linespec = "" + else: + ending_lineno = lineno + len(source) - 1 + linespec = f"#L{lineno}-L{ending_lineno}" + return f"https://github.com/Qiskit/qiskit-addon-sqd/tree/{GITHUB_BRANCH}/qiskit_addon_sqd/{file_name}{linespec}" diff --git a/docs/how_tos/add_fermionic_excitations_to_configuration_pool.ipynb b/docs/how_tos/add_fermionic_excitations_to_configuration_pool.ipynb new file mode 100644 index 0000000..a24ecc9 --- /dev/null +++ b/docs/how_tos/add_fermionic_excitations_to_configuration_pool.ipynb @@ -0,0 +1,195 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9e40af77-7f0f-4dd6-ab0a-420cf396050e", + "metadata": {}, + "source": [ + "# Add fermionic transitions to the pool of configurations\n", + "\n", + "Here we demonstrate the functionalities to augment the pool of electronic\n", + "configurations obtained by the action of transition operators on each electronic \n", + "configuration.\n", + "\n", + "We demonstrate how to add single-electron hops of the type:\n", + "$$\n", + "c^\\dagger_{p\\sigma} c_{q\\sigma} |\\textbf{x} \\rangle\n", + "$$\n", + "for $p, q = 1, ..., N_\\textrm{orb}$ and $\\sigma \\in \\{ \\uparrow, \\downarrow\\}$,\n", + "and for all $|\\textbf{x} \\rangle$ in the batch of electronic configurations." + ] + }, + { + "cell_type": "markdown", + "id": "0a7e9fcd", + "metadata": {}, + "source": [ + "Let's begin by generating a batch of random electronic configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e9506e0b-ed64-48bb-a97a-ef851b604af1", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "n_qubits = 8\n", + "n_orb = n_qubits // 2\n", + "\n", + "rand_seed = 22\n", + "np.random.seed(rand_seed)\n", + "\n", + "\n", + "# Generate some random bitstrings for testing\n", + "def random_bitstrings(n_samples, n_qubits):\n", + " return np.round(np.random.rand(n_samples, n_qubits)).astype(\"int\").astype(\"bool\")\n", + "\n", + "\n", + "bitstring_matrix = random_bitstrings(100, n_qubits)" + ] + }, + { + "cell_type": "markdown", + "id": "4155599f", + "metadata": {}, + "source": [ + "The excitation operators are specified inside a numpy array whose length is\n", + "equal to the number of fermionic nodes (or qubits). Each element of the array\n", + "must be a string that can take values:\n", + "\n", + "- ``'I'``: Identity\n", + "- ``'+'``: Creation operator\n", + "- ``'-'``: Annihilation operator\n", + "\n", + "Let's generate all possible single-electron transitions (amongst same spin \n", + "species)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "389284f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[['I' 'I' 'I' 'I' 'I' 'I' 'I' 'I']\n", + " ['+' '-' 'I' 'I' 'I' 'I' 'I' 'I']\n", + " ['-' '+' 'I' 'I' 'I' 'I' 'I' 'I']\n", + " ['I' 'I' 'I' 'I' '+' '-' 'I' 'I']\n", + " ['I' 'I' 'I' 'I' '-' '+' 'I' 'I']\n", + " ['+' 'I' '-' 'I' 'I' 'I' 'I' 'I']\n", + " ['-' 'I' '+' 'I' 'I' 'I' 'I' 'I']\n", + " ['I' 'I' 'I' 'I' '+' 'I' '-' 'I']\n", + " ['I' 'I' 'I' 'I' '-' 'I' '+' 'I']\n", + " ['+' 'I' 'I' '-' 'I' 'I' 'I' 'I']\n", + " ['-' 'I' 'I' '+' 'I' 'I' 'I' 'I']\n", + " ['I' 'I' 'I' 'I' '+' 'I' 'I' '-']\n", + " ['I' 'I' 'I' 'I' '-' 'I' 'I' '+']\n", + " ['I' '+' '-' 'I' 'I' 'I' 'I' 'I']\n", + " ['I' '-' '+' 'I' 'I' 'I' 'I' 'I']\n", + " ['I' 'I' 'I' 'I' 'I' '+' '-' 'I']\n", + " ['I' 'I' 'I' 'I' 'I' '-' '+' 'I']\n", + " ['I' '+' 'I' '-' 'I' 'I' 'I' 'I']\n", + " ['I' '-' 'I' '+' 'I' 'I' 'I' 'I']\n", + " ['I' 'I' 'I' 'I' 'I' '+' 'I' '-']\n", + " ['I' 'I' 'I' 'I' 'I' '-' 'I' '+']\n", + " ['I' 'I' '+' '-' 'I' 'I' 'I' 'I']\n", + " ['I' 'I' '-' '+' 'I' 'I' 'I' 'I']\n", + " ['I' 'I' 'I' 'I' 'I' 'I' '+' '-']\n", + " ['I' 'I' 'I' 'I' 'I' 'I' '-' '+']]\n" + ] + } + ], + "source": [ + "transitions_single = np.array(\n", + " [[\"I\" for i in range(2 * n_orb)] for j in range(4 * (n_orb**2 - n_orb) // 2 + 1)]\n", + ")\n", + "count = 1\n", + "for i in range(n_orb):\n", + " for j in range(i + 1, n_orb):\n", + " # spin up\n", + " transitions_single[count, i] = \"+\"\n", + " transitions_single[count, j] = \"-\"\n", + " count += 1\n", + " transitions_single[count, i] = \"-\"\n", + " transitions_single[count, j] = \"+\"\n", + " count += 1\n", + "\n", + " # spin down\n", + " transitions_single[count, i + n_orb] = \"+\"\n", + " transitions_single[count, j + n_orb] = \"-\"\n", + " count += 1\n", + " transitions_single[count, i + n_orb] = \"-\"\n", + " transitions_single[count, j + n_orb] = \"+\"\n", + " count += 1\n", + "\n", + "print(transitions_single)" + ] + }, + { + "cell_type": "markdown", + "id": "c15c5b3f", + "metadata": {}, + "source": [ + "Let's now apply the transition operators to the configurations in ``bitstring_matrix``" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6a44f358", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(723, 8)\n", + "[[False False False ... False False True]\n", + " [False True False ... True False False]\n", + " [ True True True ... True False True]\n", + " ...\n", + " [ True False True ... False False True]\n", + " [ True True True ... True False True]\n", + " [False False False ... False False True]]\n" + ] + } + ], + "source": [ + "from qiskit_addon_sqd.fermion import enlarge_batch_from_transitions\n", + "\n", + "bitstring_matrix_aug = enlarge_batch_from_transitions(bitstring_matrix, transitions_single)\n", + "\n", + "print(bitstring_matrix_aug.shape)\n", + "print(bitstring_matrix_aug)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/how_tos/benchmark_pauli_projection.ipynb b/docs/how_tos/benchmark_pauli_projection.ipynb new file mode 100644 index 0000000..1752539 --- /dev/null +++ b/docs/how_tos/benchmark_pauli_projection.ipynb @@ -0,0 +1,463 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55900f6c-2fb6-4d2c-8745-29bad8b66d9f", + "metadata": {}, + "source": [ + "# Benchmark Pauli operator projection" + ] + }, + { + "cell_type": "markdown", + "id": "b5caa5b4", + "metadata": {}, + "source": [ + "### Pauli string action on a computational basis state\n", + "\n", + "The action of a Pauli string on a computational basis state is rather trivial, and just a single computational basis state itself. This is a direct consequence of the structure of Pauli matrices, which only have a single nonzero element on each of their rows. Consequently, their action on a qubit is:\n", + "\n", + "-------------------------------------------\n", + "\n", + "$$\n", + "\\sigma_x |0 \\rangle = |1 \\rangle\n", + "$$\n", + "\n", + "$$\n", + "\\sigma_x |1 \\rangle = |0 \\rangle\n", + "$$\n", + "\n", + "-------------------------------------------\n", + "\n", + "$$\n", + "\\sigma_y |0 \\rangle = i|1 \\rangle\n", + "$$\n", + "\n", + "$$\n", + "\\sigma_y |1 \\rangle = -i|0 \\rangle\n", + "$$\n", + "\n", + "-------------------------------------------\n", + "\n", + "$$\n", + "\\sigma_z |0 \\rangle = |0 \\rangle\n", + "$$\n", + "\n", + "$$\n", + "\\sigma_z |1 \\rangle = -|1 \\rangle\n", + "$$\n", + "\n", + "-------------------------------------------\n", + "\n", + "$$\n", + "I |0 \\rangle = |0 \\rangle\n", + "$$\n", + "\n", + "$$\n", + "I |1 \\rangle = |1 \\rangle\n", + "$$\n", + "\n", + "-------------------------------------------\n", + "\n", + "Each bit on the bitstring labeling the computational basis will be labeled by $x \\in \\{0, 1 \\}$. In order to keep the implementation at light as possible, we will\n", + "represent the bitstrings with `bool` variables: $0\\rightarrow \\textrm{False}$ and\n", + "$1\\rightarrow \\textrm{True}$.\n", + "\n", + "To represent the action of each Pauli operator in a computational basis state\n", + "we will assign three variables to it: `diag`, `sign`, `imag`. \n", + "- `diag` labels whether the operator is diagonal:\n", + " - $\\textrm{diag}(I) = \\textrm{True}$\n", + " - $\\textrm{diag}(\\sigma_x) = \\textrm{False}$\n", + " - $\\textrm{diag}(\\sigma_y) = \\textrm{False}$\n", + " - $\\textrm{diag}(\\sigma_z) = \\textrm{True}$\n", + "- `sign` Identifies if there is a sign change in the matrix element connected \n", + "to either 0 or 1:\n", + " - $\\textrm{diag}(I) = \\textrm{False}$\n", + " - $\\textrm{diag}(\\sigma_x) = \\textrm{False}$\n", + " - $\\textrm{diag}(\\sigma_y) = \\textrm{True}$\n", + " - $\\textrm{diag}(\\sigma_z) = \\textrm{True}$\n", + "- `imag` Identifies if there is a complex component to the matrix element:\n", + " - $\\textrm{diag}(I) = \\textrm{False}$\n", + " - $\\textrm{diag}(\\sigma_x) = \\textrm{False}$\n", + " - $\\textrm{diag}(\\sigma_y) = \\textrm{False}$\n", + " - $\\textrm{diag}(\\sigma_z) = \\textrm{True}$\n", + "\n", + "Let's label an arbitrary Pauli operator as $\\sigma \\in \\{ I, \\sigma_x, \\sigma_y\n", + "\\sigma_z\\}$. The action of the Pauli operator on a computational basis state \n", + "can then be represented by the logic operation:\n", + "$$\n", + "\\sigma |x \\rangle = |x == \\textrm{diag}(\\sigma) \\rangle (-1)^{x\\textrm{ and sign}(\\sigma)}\n", + "(i)^{\\textrm{imag}(\\sigma)}.\n", + "$$\n", + "The same is straightforwardly generalized to arbitrary number of qubits." + ] + }, + { + "cell_type": "markdown", + "id": "a8fd7e11", + "metadata": {}, + "source": [ + "Let's check that this works:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dcb15308", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------\n", + "I\n", + "|False> --> |False> ME:(1+0j)\n", + "|True> --> |True> ME:(1+0j)\n", + "-------------------\n", + "SX\n", + "|False> --> |True> ME:(1+0j)\n", + "|True> --> |False> ME:(1+0j)\n", + "-------------------\n", + "SZ\n", + "|False> --> |False> ME:(1+0j)\n", + "|True> --> |True> ME:(-1+0j)\n", + "-------------------\n", + "SY\n", + "|False> --> |True> ME:1j\n", + "|True> --> |False> ME:(-0-1j)\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "import numpy as np\n", + "from qiskit_addon_sqd.qubit import matrix_elements_from_pauli_string, sort_and_remove_duplicates\n", + "\n", + "\n", + "def connected_element_and_amplitude_bool(x, diag, sign, imag):\n", + " \"\"\"\n", + " Finds the connected element to computational basis state |x> under\n", + " the action of the Pauli operator represented by (diag, sign, imag).\n", + "\n", + " Args:\n", + " x: Value of the bit, either True or False.\n", + " diag: Whether the Pauli operator is diagonal (I, Z)\n", + " sigma: Whether the Pauli operator's rows differ in sign (Y, Z)\n", + " imag: Whether the Pauli operator is purely imaginary (Y)\n", + "\n", + " Returns:\n", + " A length-2 tuple:\n", + " - The connected element to x, either False or True\n", + " - The matrix element\n", + " \"\"\"\n", + " return x == diag, (-1) ** (x and sign) * (1j) ** (imag)\n", + "\n", + "\n", + "sigma_indices = [0, 1, 2, 3]\n", + "sigma_string = [\"I\", \"SX\", \"SZ\", \"SY\"]\n", + "sigma_diag = [True, False, True, False]\n", + "sigma_sign = [False, False, True, True]\n", + "sigma_imag = [False, False, False, True]\n", + "qubit_values = [False, True]\n", + "\n", + "for xi in sigma_indices:\n", + " print(\"-------------------\")\n", + " print(sigma_string[xi])\n", + " for x in qubit_values:\n", + " x_p, matrix_element = connected_element_and_amplitude_bool(\n", + " x, sigma_diag[xi], sigma_sign[xi], sigma_imag[xi]\n", + " )\n", + " print(\"|\" + str(x) + \"> --> |\" + str(x_p) + \"> ME:\" + str(matrix_element))" + ] + }, + { + "cell_type": "markdown", + "id": "f40a3463", + "metadata": {}, + "source": [ + "Let's generate some large number of bitstrings (50 M) for a 40-qubit system" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "74c16c91-cc5c-46ce-aff8-17d0e71ac50f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of unique bitstrings: 49998839\n" + ] + } + ], + "source": [ + "rand_seed = 22\n", + "np.random.seed(rand_seed)\n", + "\n", + "# Generate some random bitstrings for testing\n", + "\n", + "\n", + "def random_bitstrings(n_samples, n_qubits):\n", + " return np.round(np.random.rand(n_samples, n_qubits)).astype(\"int\").astype(\"bool\")\n", + "\n", + "\n", + "n_qubits = 40\n", + "bts_matrix = random_bitstrings(50_000_000, n_qubits)\n", + "\n", + "# We need to sort the bitstrings and just keep the unique ones\n", + "# NOTE: It is essential for the projection code to have the bitstrings sorted!\n", + "bts_matrix = sort_and_remove_duplicates(bts_matrix).astype(\"bool\")\n", + "\n", + "# Final subspace dimension after getting rid of duplicated bitstrings\n", + "d = bts_matrix.shape[0]\n", + "\n", + "print(\"Total number of unique bitstrings: \" + str(d))" + ] + }, + { + "cell_type": "markdown", + "id": "184bf287", + "metadata": {}, + "source": [ + "### Let's time the projection time for a Pauli String\n", + "\n", + "The Pauli string under consideration is $\\sigma_z \\otimes ... \\otimes \\sigma_z$.\n", + "\n", + "Different subspace dimensions are considered by just slicing the matrix of bitstrings. We time the subspace projection for the different subspace sizes." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8fe182bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0 took 0.31216s\n", + "Iteration 1 took 0.510622s\n", + "Iteration 2 took 0.775817s\n", + "Iteration 3 took 1.047106s\n", + "Iteration 4 took 1.354705s\n", + "Iteration 5 took 1.583962s\n", + "Iteration 6 took 1.846798s\n", + "Iteration 7 took 2.072656s\n", + "Iteration 8 took 2.313123s\n", + "Iteration 9 took 2.539087s\n", + "Iteration 10 took 2.831971s\n", + "Iteration 11 took 3.149036s\n", + "Iteration 12 took 3.36273s\n", + "Iteration 13 took 3.661241s\n", + "Iteration 14 took 3.998323s\n", + "Iteration 15 took 4.310177s\n", + "Iteration 16 took 4.654591s\n", + "Iteration 17 took 4.686089s\n", + "Iteration 18 took 5.002513s\n", + "Iteration 19 took 5.188594s\n" + ] + } + ], + "source": [ + "pauli_str = [\"Z\" for i in range(n_qubits)]\n", + "\n", + "# Different subspace sizes to test\n", + "d_list = np.linspace(d / 1000, d, 20).astype(\"int\")\n", + "\n", + "# To store the walltime\n", + "time_array = np.zeros(20)\n", + "\n", + "for i in range(20):\n", + " int_bts_matrix = bts_matrix[: d_list[i], :]\n", + " time_1 = time.time()\n", + " _ = matrix_elements_from_pauli_string(int_bts_matrix, pauli_str)\n", + " time_array[i] = time.time() - time_1\n", + " print(f\"Iteration {i} took {round(time_array[i], 6)}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9abb110f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Data for energies plot\n", + "x1 = d_list\n", + "y1 = time_array\n", + "\n", + "# Plot energies\n", + "plt.title(\"Runtime vs subspace dimension 40 qubits\")\n", + "plt.xlabel(\"Subspace dimension (millions)\")\n", + "plt.ylabel(\"Wall time [s]\")\n", + "plt.xticks([1e7, 2e7, 3e7, 4e7, 5e7], [str(i) for i in [10, 20, 30, 40, 50]])\n", + "plt.plot(x1, y1, marker=\".\", markersize=20)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8c486bc7", + "metadata": {}, + "source": [ + "Let's do the same for 60 qubits" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "359ed3f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of unique bitstrings: 50000000\n" + ] + } + ], + "source": [ + "n_qubits = 60\n", + "bts_matrix = random_bitstrings(50_000_000, n_qubits)\n", + "\n", + "# We need to sort the bitstrings and just keep the unique ones\n", + "bts_matrix = sort_and_remove_duplicates(bts_matrix).astype(\"bool\")\n", + "\n", + "# Final subspace dimension after getting rid of duplicated bitstrings\n", + "d = bts_matrix.shape[0]\n", + "\n", + "print(\"Total number of unique bitstrings: \" + str(d))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7bb0d8d8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0 took 0.331874s\n", + "Iteration 1 took 0.604671s\n", + "Iteration 2 took 0.91632s\n", + "Iteration 3 took 1.219938s\n", + "Iteration 4 took 1.598329s\n", + "Iteration 5 took 1.9079s\n", + "Iteration 6 took 2.188979s\n", + "Iteration 7 took 2.530264s\n", + "Iteration 8 took 2.827899s\n", + "Iteration 9 took 3.154194s\n", + "Iteration 10 took 3.514766s\n", + "Iteration 11 took 3.83003s\n", + "Iteration 12 took 4.185016s\n", + "Iteration 13 took 4.514196s\n", + "Iteration 14 took 4.948467s\n", + "Iteration 15 took 5.388114s\n", + "Iteration 16 took 5.596917s\n", + "Iteration 17 took 5.776064s\n", + "Iteration 18 took 6.082537s\n", + "Iteration 19 took 6.356327s\n" + ] + } + ], + "source": [ + "pauli_str = [\"Z\" for i in range(n_qubits)]\n", + "\n", + "# Different subspace sizes to test\n", + "d_list = np.linspace(d / 1000, d, 20).astype(\"int\")\n", + "\n", + "# It is better to do this once\n", + "row_array = np.arange(d)\n", + "\n", + "# To store the walltime\n", + "time_array = np.zeros(20)\n", + "\n", + "for i in range(20):\n", + " int_bts_matrix = bts_matrix[: d_list[i], :]\n", + " int_row_array = row_array[: d_list[i]]\n", + " time_1 = time.time()\n", + " _ = matrix_elements_from_pauli_string(int_bts_matrix, pauli_str)\n", + " time_array[i] = time.time() - time_1\n", + " print(f\"Iteration {i} took {round(time_array[i], 6)}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6b961c81", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Data for energies plot\n", + "x1 = d_list\n", + "y1 = time_array\n", + "\n", + "fig, axs = plt.subplots(1, 1, figsize=(6, 6))\n", + "\n", + "# Plot energies\n", + "axs.plot(x1, y1, marker=\".\", markersize=20)\n", + "axs.set_title(\"Runtime vs subspace dimension 60 qubits\")\n", + "axs.set_xlabel(\"Subspace dimension (millions)\")\n", + "plt.xticks([1e7, 2e7, 3e7, 4e7, 5e7], [str(i) for i in [10, 20, 30, 40, 50]])\n", + "axs.set_ylabel(\"Wall time [s]\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/how_tos/choose_subspace_dimension.ipynb b/docs/how_tos/choose_subspace_dimension.ipynb new file mode 100644 index 0000000..8bbfbc5 --- /dev/null +++ b/docs/how_tos/choose_subspace_dimension.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9e40af77-7f0f-4dd6-ab0a-420cf396050e", + "metadata": {}, + "source": [ + "# Bound the subspace dimension\n", + "\n", + "In this tutorial, we will show the effect of the subspace dimension in the [self-consistent configuration recovery technique](https://arxiv.org/abs/2405.05068).\n", + "\n", + "***A priori***, we do not know what is the correct subspace dimension to obtain a target level of accuracy. However, we do know that increasing the subspace dimension increases the accuracy of the method. Therefore, we can study the accuracy of the predictions as a function of the subspace dimension." + ] + }, + { + "cell_type": "markdown", + "id": "a6755afb-ca1e-4473-974b-ba89acc8abce", + "metadata": {}, + "source": [ + "### First we will specify the molecule and its properties\n", + "\n", + "In this example, we will approximate the ground state energy of an $\\textrm{N}_{2}$ molecule." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "677f54ac-b4ed-47e3-b5ba-5366d3a520f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parsing ../molecules/n2_fci.txt\n" + ] + } + ], + "source": [ + "from pyscf import ao2mo, tools\n", + "\n", + "# Specify molecule properties\n", + "num_orbitals = 16\n", + "num_elec_a = num_elec_b = 5\n", + "open_shell = False\n", + "spin_sq = 0\n", + "\n", + "# Read in molecule from disk\n", + "mf_as = tools.fcidump.to_scf(\"../molecules/n2_fci.txt\")\n", + "hcore = mf_as.get_hcore()\n", + "eri = ao2mo.restore(1, mf_as._eri, num_orbitals)\n", + "nuclear_repulsion_energy = mf_as.mol.energy_nuc()" + ] + }, + { + "cell_type": "markdown", + "id": "c58e988c-a109-44cd-a975-9df43250c318", + "metadata": {}, + "source": [ + "### Generate a dummy counts dictionary to proxy samples taken from a QPU\n", + "\n", + "Here, we randomly generate bitstrings sampled from the uniform distribution. SQD can effectively estimate the ground state of $N_2$ using uniformly sampled bitstrings; however, that is not the case for more complex molecules." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e9506e0b-ed64-48bb-a97a-ef851b604af1", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_addon_sqd.counts import generate_counts_uniform\n", + "\n", + "# Create a seed to control randomness throughout this workflow\n", + "rand_seed = 42\n", + "\n", + "# Generate random samples\n", + "counts_dict = generate_counts_uniform(10_000, num_orbitals * 2, rand_seed=rand_seed)" + ] + }, + { + "cell_type": "markdown", + "id": "851bc98e-9c08-4e78-9472-36301abc11d8", + "metadata": {}, + "source": [ + "### Transform the counts dict into a bitstring matrix and probability array for post-processing\n", + "\n", + "In order to speed up the bitwise processing required in this workflow, we use Numpy arrays to hold representations of the bitstrings and sampling frequencies." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7a102a7f-aae6-4583-ab82-ae40fcb5496a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from qiskit_addon_sqd.counts import counts_to_arrays\n", + "\n", + "# Convert counts into bitstring and probability arrays\n", + "bitstring_matrix_full, probs_arr_full = counts_to_arrays(counts_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "eb704101-0fe8-4d12-b572-b1d844e35a90", + "metadata": {}, + "source": [ + "### Iteratively refine the samples using SQD and approximate the ground state\n", + "\n", + "\n", + "Let's wrap the self-consisten configuration recovery loop into a function\n", + "\n", + "There are a few user-controlled options which are important for this technique:\n", + "- ``iterations``: Number of self-consistent configuration recovery iterations\n", + "- ``n_batches``: Number of batches of configurations used by the different calls to the eigenstate solver\n", + "- ``samples_per_batch``: Number of unique configurations to include in each batch\n", + "- ``max_davidson_cycles``: Maximum number of Davidson cycles to run during ground state approximation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b72c048e-fe8e-4fc2-b28b-03138249074e", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_addon_sqd.configuration_recovery import recover_configurations\n", + "from qiskit_addon_sqd.subsampling import postselect_and_subsample\n", + "from qiskit_addon_sqd.utils.fermion import (\n", + " bitstring_matrix_to_sorted_addresses,\n", + " flip_orbital_occupancies,\n", + " solve_fermion,\n", + ")\n", + "\n", + "\n", + "def configuration_recovery_loop(\n", + " hcore: np.ndarray,\n", + " eri: np.ndarray,\n", + " num_elec_a: int,\n", + " num_elec_b: int,\n", + " spin_sq: float,\n", + " iterations: int,\n", + " n_batches: int,\n", + " samples_per_batch: int,\n", + " max_davidson_cycles: int,\n", + ") -> tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Perform SQD.\"\"\"\n", + " # Self-consistent configuration recovery loop\n", + " e_hist = np.zeros((iterations, n_batches)) # energy history\n", + " s_hist = np.zeros((iterations, n_batches)) # spin history\n", + " d_hist = np.zeros((iterations, n_batches)) # subspace dimension history\n", + " occupancy_hist = np.zeros((iterations, 2 * num_orbitals))\n", + " occupancies_bitwise = None # orbital i corresponds to column i in bitstring matrix\n", + " for i in range(iterations):\n", + " print(f\"Starting configuration recovery iteration {i}\")\n", + " # On the first iteration, we have no orbital occupancy information from the\n", + " # solver, so we just post-select from the full bitstring set based on hamming weight.\n", + " if occupancies_bitwise is None:\n", + " bs_mat_tmp = bitstring_matrix_full\n", + " probs_arr_tmp = probs_arr_full\n", + "\n", + " # In following iterations, we use both the occupancy info and the target hamming\n", + " # weight to correct bitstrings.\n", + " else:\n", + " bs_mat_tmp, probs_arr_tmp = recover_configurations(\n", + " bitstring_matrix_full,\n", + " probs_arr_full,\n", + " occupancies_bitwise,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " rand_seed=rand_seed,\n", + " )\n", + "\n", + " # Throw out samples with incorrect hamming weight and create batches of subsamples.\n", + " batches = postselect_and_subsample(\n", + " bs_mat_tmp,\n", + " probs_arr_tmp,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " samples_per_batch,\n", + " n_batches,\n", + " rand_seed=rand_seed,\n", + " )\n", + "\n", + " # Run eigenstate solvers in a loop. This loop should be parallelized for larger problems.\n", + " int_e = np.zeros(n_batches)\n", + " int_s = np.zeros(n_batches)\n", + " int_d = np.zeros(n_batches)\n", + " int_occs = np.zeros((n_batches, 2 * num_orbitals))\n", + " cs = []\n", + " for j in range(n_batches):\n", + " addresses = bitstring_matrix_to_sorted_addresses(batches[j], open_shell=open_shell)\n", + " int_d[j] = len(addresses[0]) * len(addresses[1])\n", + " energy_sci, coeffs_sci, avg_occs, spin = solve_fermion(\n", + " addresses,\n", + " hcore,\n", + " eri,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " spin_sq=spin_sq,\n", + " max_davidson=max_davidson_cycles,\n", + " )\n", + " energy_sci += nuclear_repulsion_energy\n", + " int_e[j] = energy_sci\n", + " int_s[j] = spin\n", + " int_occs[j, :num_orbitals] = avg_occs[0]\n", + " int_occs[j, num_orbitals:] = avg_occs[1]\n", + " cs.append(coeffs_sci)\n", + "\n", + " # Combine batch results\n", + " avg_occupancy = np.mean(int_occs, axis=0)\n", + " # The occupancies from the solver should be flipped to match the bits in the bitstring matrix.\n", + " occupancies_bitwise = flip_orbital_occupancies(avg_occupancy)\n", + "\n", + " # Track optimization history\n", + " e_hist[i, :] = int_e\n", + " s_hist[i, :] = int_s\n", + " d_hist[i, :] = int_d\n", + " occupancy_hist[i, :] = avg_occupancy\n", + "\n", + " return e_hist.flatten(), d_hist.flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e0847f28", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting configuration recovery iteration 0\n", + "Starting configuration recovery iteration 1\n", + "Starting configuration recovery iteration 2\n", + "Starting configuration recovery iteration 3\n", + "Starting configuration recovery iteration 4\n", + "Starting configuration recovery iteration 0\n", + "Starting configuration recovery iteration 1\n", + "Starting configuration recovery iteration 2\n", + "Starting configuration recovery iteration 3\n", + "Starting configuration recovery iteration 4\n", + "Starting configuration recovery iteration 0\n", + "Starting configuration recovery iteration 1\n", + "Starting configuration recovery iteration 2\n", + "Starting configuration recovery iteration 3\n", + "Starting configuration recovery iteration 4\n", + "Starting configuration recovery iteration 0\n", + "Starting configuration recovery iteration 1\n", + "Starting configuration recovery iteration 2\n", + "Starting configuration recovery iteration 3\n", + "Starting configuration recovery iteration 4\n" + ] + } + ], + "source": [ + "list_samples_per_batch = [50, 200, 400, 600]\n", + "\n", + "# SQD options\n", + "iterations = 5\n", + "\n", + "# Eigenstate solver options\n", + "n_batches = 10\n", + "max_davidson_cycles = 200\n", + "\n", + "energies = []\n", + "subspace_dimensions = []\n", + "\n", + "for samples_per_batch in list_samples_per_batch:\n", + " e_hist, d_hist = configuration_recovery_loop(\n", + " hcore,\n", + " eri,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " spin_sq,\n", + " iterations,\n", + " n_batches,\n", + " samples_per_batch,\n", + " max_davidson_cycles,\n", + " )\n", + " energies.append(np.min(e_hist))\n", + "\n", + " index_min = np.argmin(e_hist)\n", + " subspace_dimensions.append(d_hist[index_min])" + ] + }, + { + "cell_type": "markdown", + "id": "9d78906b-4759-4506-9c69-85d4e67766b3", + "metadata": {}, + "source": [ + "### Visualize the results\n", + "\n", + "This plot shows that increasing the subspace dimension leads to more accurate results." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "caffd888-e89c-4aa9-8bae-4d1bb723b35e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Data for energies plot\n", + "x1 = subspace_dimensions\n", + "n2_exact = -109.10288938\n", + "y1 = energies\n", + "\n", + "fig, axs = plt.subplots(1, 1, figsize=(12, 6))\n", + "\n", + "# Plot energies\n", + "axs.plot(x1, y1, marker=\".\", markersize=20, label=\"Estimated\")\n", + "axs.set_xticks(x1)\n", + "axs.set_xticklabels(x1)\n", + "axs.axhline(y=n2_exact, color=\"red\", linestyle=\"--\", label=\"Exact\")\n", + "axs.set_title(\"Approximated Ground State Energy vs subspace dimension\")\n", + "axs.set_xlabel(\"Subspace dimension\")\n", + "axs.set_ylabel(\"Energy (Ha)\")\n", + "axs.legend()\n", + "\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/how_tos/index.rst b/docs/how_tos/index.rst new file mode 100644 index 0000000..e410c27 --- /dev/null +++ b/docs/how_tos/index.rst @@ -0,0 +1,10 @@ +############# +How-To Guides +############# + +This page summarizes the available how-to guides. + +.. nbgallery:: + :glob: + + * diff --git a/docs/how_tos/project_pauli_operators_onto_hilbert_subspaces.ipynb b/docs/how_tos/project_pauli_operators_onto_hilbert_subspaces.ipynb new file mode 100644 index 0000000..58193de --- /dev/null +++ b/docs/how_tos/project_pauli_operators_onto_hilbert_subspaces.ipynb @@ -0,0 +1,157 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "21a1d83f-183f-4da9-bb8c-71400120fd31", + "metadata": {}, + "source": [ + "# Project Pauli operators onto Hilbert subspaces" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "74c16c91-cc5c-46ce-aff8-17d0e71ac50f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from qiskit_addon_sqd.qubit import matrix_elements_from_pauli_string, sort_and_remove_duplicates\n", + "\n", + "L = 22\n", + "\n", + "# Write all of the Pauli strings for the Heisenberg model\n", + "paulis = []\n", + "for i in range(L):\n", + " pstr = [\"I\" for i in range(L)]\n", + " # Sigma_x\n", + " pstr[i] = \"X\"\n", + " pstr[(i + 1) % L] = \"X\"\n", + " paulis.append(pstr)\n", + "\n", + " pstr = [\"I\" for i in range(L)]\n", + " # Sigma_y\n", + " pstr[i] = \"Y\"\n", + " pstr[(i + 1) % L] = \"Y\"\n", + " paulis.append(pstr)\n", + "\n", + " pstr = [\"I\" for i in range(L)]\n", + " # Sigma_z\n", + " pstr[i] = \"Z\"\n", + " pstr[(i + 1) % L] = \"Z\"\n", + " paulis.append(pstr)" + ] + }, + { + "cell_type": "markdown", + "id": "0540e60f", + "metadata": {}, + "source": [ + "Let's make some random bitstrings" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "56350454", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subspace dimension: 4194276\n", + "Full Hilbert space dimension: 4194304\n" + ] + } + ], + "source": [ + "rand_seed = 22\n", + "np.random.seed(rand_seed)\n", + "\n", + "\n", + "def random_bitstrings(n_samples, n_qubits):\n", + " return np.round(np.random.rand(n_samples, n_qubits)).astype(\"int\").astype(\"bool\")\n", + "\n", + "\n", + "bts_matrix = random_bitstrings(50_000_000, L)\n", + "\n", + "# NOTE: It is essential for the projection code to have the bitstrings sorted!\n", + "bts_matrix = sort_and_remove_duplicates(bts_matrix)\n", + "\n", + "print(\"Subspace dimension: \" + str(bts_matrix.shape[0]))\n", + "print(\"Full Hilbert space dimension: \" + str(2**L))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f31f5e40", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.sparse import coo_matrix\n", + "from scipy.sparse.linalg import eigsh\n", + "\n", + "d = bts_matrix.shape[0]\n", + "\n", + "# The first Pauli operator\n", + "matrix_elements, row_coords, col_coords = matrix_elements_from_pauli_string(bts_matrix, paulis[0])\n", + "\n", + "# The complex double precision is required to match exactly Netket's results\n", + "# We can relax it to complex64 most likely\n", + "ham = coo_matrix((matrix_elements, (row_coords, col_coords)), (d, d), dtype=\"complex128\")\n", + "\n", + "# The remaining Pauli operators\n", + "# It will be a good idea to make this operation in parallel\n", + "for i in range(len(paulis) - 1):\n", + " matrix_elements, row_coords, col_coords = matrix_elements_from_pauli_string(\n", + " bts_matrix, paulis[i + 1]\n", + " )\n", + " ham += coo_matrix((matrix_elements, (row_coords, col_coords)), (d, d))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3ce6e519", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-39.14735935]\n" + ] + } + ], + "source": [ + "# And we finally diagonalize\n", + "E, V = eigsh(ham, k=1, which=\"SA\")\n", + "\n", + "print(E)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/how_tos/select_open_closed_shell.ipynb b/docs/how_tos/select_open_closed_shell.ipynb new file mode 100644 index 0000000..781d6af --- /dev/null +++ b/docs/how_tos/select_open_closed_shell.ipynb @@ -0,0 +1,536 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "72420c62-2716-4f64-ad5b-73394b481cc1", + "metadata": {}, + "source": [ + "# Understand open-shell vs closed-shell options and its effect in the subspace construction\n", + "\n", + "In this \"how-to\", we will show how to choose subpace dimensions in the `sqd` package to post-process quantum samples using the [self-consistent configuration recovery technique](https://arxiv.org/abs/2405.05068). \n", + "\n", + "More importantly, this \"how-to\" also highlights some differences in the behaviour in the susbapce construction when run in `open_shell = False` or `open_shell = True` modes:\n", + "\n", + "- `open_shell = False` only works when the number of spin-up and spin-down electrons is the same. \n", + "\n", + "- `open_shell = True` must be used when the number of spin-up and spin-down electrons is different. It can also be used when the number of spin-up and spin-down electrons is the same. However, in this last case, there is a difference in the sizes of the subspaces generated between `open_shell = False` and `open_shell = True`, as discussed in this notebook.\n", + "\n", + "**NOTE:** Some of the electronic-configuration (bitstring) manipulations in this package have as a goal to preserve the total spin symmetry $S^2$. Standard Selected Counfiguration Interaction (SCI) solvers cannot impose $S^2$ conservation exactly. Consequently, they do so approximately via a Lagrange multiplier. \n", + "\n", + "The choice of electronic configurations entering the eigenstate solver can also have a strong effect in the conservation of spin. For example, in a (2-electron,2-orbital) system, one may sample the configuration $|1001\\rangle$ (having a single spin-up excitation over the RHF state $|0101\\rangle$) which is a linear combination of the open-shell singlet and triplet states, respectively $(|1001\\rangle ± |0110\\rangle) /\\sqrt{2}$. If the configuration |0110⟩ is not sampled, one can construct neither eigenfunction of total spin, leading to spin contamination or redundancy (i.e. the configuration |1001⟩ is involved in a CI calculation, but has coefficient 0 in the CI vector). Consider that a single sample $|1001\\rangle$ is generated in the quantum computer, this is how the `sqd` package handles this situation:\n", + "\n", + "- `open_shell = False`: \n", + "\n", + " 1. The $1001$ bitstring is split in half, representing spin-up and spin-down configurations: $10$ (up) and $01$ (down).\n", + " \n", + " 2. The list of unique spin-polarized configurations is constructed: $\\mathcal{U} = [01, 10]$.\n", + "\n", + " 3. We then consider all possible combinations of $\\mathcal{U}$ elements to form the basis: $\\left \\{ |0101\\rangle, |0110\\rangle , |1001\\rangle , |1010\\rangle \\right \\}$, which contains the singlet and triplet states.\n", + "\n", + "\n", + "- `open_shell = True`: \n", + "\n", + " 1. Contrary to the `open_shell = False` case, we do not combine the halves of the bitstring to form the basis." + ] + }, + { + "cell_type": "markdown", + "id": "a6755afb-ca1e-4473-974b-ba89acc8abce", + "metadata": {}, + "source": [ + "## Closed-Shell\n", + "\n", + "This example shows how the bitstrings are manipulated in a (2-electron, 4-orbital) system." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "677f54ac-b4ed-47e3-b5ba-5366d3a520f9", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify molecule properties\n", + "num_orbitals = 4\n", + "num_elec_a = num_elec_b = 1\n", + "open_shell = False" + ] + }, + { + "cell_type": "markdown", + "id": "c58e988c-a109-44cd-a975-9df43250c318", + "metadata": {}, + "source": [ + "### Specify by hand a dictionary of measurement outcomes" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e9506e0b-ed64-48bb-a97a-ef851b604af1", + "metadata": {}, + "outputs": [], + "source": [ + "counts_dict = {\"00010010\": 1 / 2.0 - 0.01, \"01001000\": 1 / 2.0 - 0.01, \"00010001\": 0.02}" + ] + }, + { + "cell_type": "markdown", + "id": "851bc98e-9c08-4e78-9472-36301abc11d8", + "metadata": {}, + "source": [ + "### Transform the counts dict into a bitstring matrix and probability array for post-processing" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7a102a7f-aae6-4583-ab82-ae40fcb5496a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[False False False True False False True False]\n", + " [False True False False True False False False]\n", + " [False False False True False False False True]]\n", + "[0.49 0.49 0.02]\n" + ] + } + ], + "source": [ + "from qiskit_addon_sqd.counts import counts_to_arrays\n", + "\n", + "# Convert counts into bitstring and probability arrays\n", + "bitstring_matrix_full, probs_arr_full = counts_to_arrays(counts_dict)\n", + "print(bitstring_matrix_full)\n", + "print(probs_arr_full)" + ] + }, + { + "cell_type": "markdown", + "id": "eb704101-0fe8-4d12-b572-b1d844e35a90", + "metadata": {}, + "source": [ + "### Subsample a single batch of size two:\n", + "\n", + "- ``n_batches = 1``: Number of batches of configurations used by the different calls to the eigenstate solver\n", + "- ``samples_per_batch = 2``: Number of unique configurations to include in each batch" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fe60aee2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[False False False True False False True False]\n", + " [False True False False True False False False]]\n" + ] + } + ], + "source": [ + "from qiskit_addon_sqd.subsampling import postselect_and_subsample\n", + "\n", + "n_batches = 1\n", + "samples_per_batch = 2\n", + "\n", + "# seed for random number generator\n", + "rand_seed = 48\n", + "\n", + "# Generate the batches\n", + "batches = postselect_and_subsample(\n", + " bitstring_matrix_full,\n", + " probs_arr_full,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " samples_per_batch,\n", + " n_batches,\n", + " rand_seed=rand_seed,\n", + ")\n", + "\n", + "print(batches[0])" + ] + }, + { + "cell_type": "markdown", + "id": "93a6d05a", + "metadata": {}, + "source": [ + "### Obtain decimal representation of the spin-up and spin-down bitstrings used by the eigenstate solver\n", + "\n", + "The fist element in the tuple corresponds to the decimal representation of the spin-up configurations, while the second element in the tuple corresponds to the decimal representation of the spin-down configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ef90e039", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([1, 2, 4, 8], dtype=int64), array([1, 2, 4, 8], dtype=int64))\n" + ] + } + ], + "source": [ + "from qiskit_addon_sqd.fermion import bitstring_matrix_to_sorted_addresses\n", + "\n", + "addresses = bitstring_matrix_to_sorted_addresses(batches[0], open_shell=open_shell)\n", + "print(addresses)" + ] + }, + { + "cell_type": "markdown", + "id": "70d7883c", + "metadata": {}, + "source": [ + "Note that while the number of samples per batch is 2, and the sampled bitstrings are: $00010010$ and $01001000$, four electronic configurations are generated per spin-species. In this case, the set of unique spin-polarized configurations is given by:\n", + "$$\n", + "\\mathcal{U} = \\{ 0001, 0010, 0100, 1000 \\}\n", + "$$\n", + "whose base-10 decimal representation is \n", + "$$\n", + "\\mathcal{U}_{10} = \\{ 1, 2, 4, 8 \\}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "03b32ed5", + "metadata": {}, + "source": [ + "### Basis of the subspace:\n", + "\n", + "The eigenstate solver takes all possible pairs of spin-up and spin-down bitstrings to construnct the basis $\\mathcal{B}$ of the subspace:\n", + " \n", + "- Element 1: $|00010001\\rangle$ \n", + "\n", + "- Element 2: $|00010010\\rangle$ \n", + "\n", + "- Element 3: $|00010100\\rangle$ \n", + "\n", + "- Element 4: $|00011000\\rangle$ \n", + "\n", + "- Element 5: $|00100001\\rangle$ \n", + "\n", + "- Element 6: $|00100010\\rangle$ \n", + "\n", + "- Element 7: $|00100100\\rangle$ \n", + "\n", + "- Element 8: $|00101000\\rangle$ \n", + " \n", + "- Element 9: $|01000001\\rangle$ \n", + "\n", + "- Element 10: $|01000010\\rangle$ \n", + "\n", + "- Element 11: $|01000100\\rangle$ \n", + "\n", + "- Element 12: $|01001000\\rangle$ \n", + "\n", + "- Element 13: $|10000001\\rangle$ \n", + "\n", + "- Element 14: $|10000010\\rangle$ \n", + "\n", + "- Element 15: $|10000100\\rangle$ \n", + "\n", + "- Element 16: $|10001000\\rangle$ \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "11c924ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Basis elements of the subspace:\n", + "|00010001>\n", + "|00010010>\n", + "|00010100>\n", + "|00011000>\n", + "|00100001>\n", + "|00100010>\n", + "|00100100>\n", + "|00101000>\n", + "|01000001>\n", + "|01000010>\n", + "|01000100>\n", + "|01001000>\n", + "|10000001>\n", + "|10000010>\n", + "|10000100>\n", + "|10001000>\n" + ] + } + ], + "source": [ + "addresses_up = addresses[0]\n", + "addresses_dn = addresses[1]\n", + "\n", + "print(\"Basis elements of the subspace:\")\n", + "\n", + "for address_up in addresses_up:\n", + " for address_dn in addresses_dn:\n", + " format_name = \"{0:0\" + str(num_orbitals) + \"b}\"\n", + " print(\"|\" + format_name.format(address_up) + format_name.format(address_dn) + \">\")" + ] + }, + { + "cell_type": "markdown", + "id": "aa43a4fc", + "metadata": {}, + "source": [ + "**The subspace dimension is upper-bounded by**: $2 \\cdot$ (`samples_per_batch`)$^2$" + ] + }, + { + "cell_type": "markdown", + "id": "9412e52b", + "metadata": {}, + "source": [ + "## Open-Shell\n", + "\n", + "This example shows how the bitstrings are manipulated in a (2-electron, 4-orbital) system." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9b515b8a", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify molecule properties\n", + "num_orbitals = 4\n", + "num_elec_a = num_elec_b = 1\n", + "open_shell = True" + ] + }, + { + "cell_type": "markdown", + "id": "9ef78560", + "metadata": {}, + "source": [ + "### Specify by hand a dictionary of measurement outcomes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "06b2185a", + "metadata": {}, + "outputs": [], + "source": [ + "counts_dict = {\"00010010\": 1 / 2.0 - 0.01, \"01001000\": 1 / 2.0 - 0.01, \"00010001\": 0.02}" + ] + }, + { + "cell_type": "markdown", + "id": "08b32957", + "metadata": {}, + "source": [ + "### Transform the counts dict into a bitstring matrix and probability array for post-processing" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "90561893", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[False False False True False False True False]\n", + " [False True False False True False False False]\n", + " [False False False True False False False True]]\n", + "[0.49 0.49 0.02]\n" + ] + } + ], + "source": [ + "# Convert counts into bitstring and probability arrays\n", + "bitstring_matrix_full, probs_arr_full = counts_to_arrays(counts_dict)\n", + "print(bitstring_matrix_full)\n", + "print(probs_arr_full)" + ] + }, + { + "cell_type": "markdown", + "id": "416bfb6c", + "metadata": {}, + "source": [ + "### Subsample a single batch of size two:\n", + "\n", + "- ``n_batches = 1``: Number of batches of configurations used by the different calls to the eigenstate solver\n", + "- ``samples_per_batch = 2``: Number of unique configurations to include in each batch" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cf4fe11d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[False False False True False False True False]\n", + " [False True False False True False False False]]\n" + ] + } + ], + "source": [ + "n_batches = 1\n", + "samples_per_batch = 2\n", + "\n", + "# seed for random number generator\n", + "rand_seed = 48\n", + "\n", + "# Generate the batches\n", + "batches = postselect_and_subsample(\n", + " bitstring_matrix_full,\n", + " probs_arr_full,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " samples_per_batch,\n", + " n_batches,\n", + " rand_seed=rand_seed,\n", + ")\n", + "\n", + "print(batches[0])" + ] + }, + { + "cell_type": "markdown", + "id": "54d699ca", + "metadata": {}, + "source": [ + "### Obtain decimal representation of the spin-up and spin-down bitstrings used by the eigenstate solver\n", + "\n", + "The fist element in the tuple corresponds to the decimal representation of the spin-up configurations, while the second element in the tuple corresponds to the decimal representation of the spin-down configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b40b049b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([1, 4], dtype=int64), array([2, 8], dtype=int64))\n" + ] + } + ], + "source": [ + "addresses = bitstring_matrix_to_sorted_addresses(batches[0], open_shell=open_shell)\n", + "print(addresses)" + ] + }, + { + "cell_type": "markdown", + "id": "28921e56", + "metadata": {}, + "source": [ + "If we specify that `open_shell = True`, now we do not include all unique half-bitstrings as spin-up and spin-down configurations, thus yielding a smaller basis as when specifying `open_shell = False`" + ] + }, + { + "cell_type": "markdown", + "id": "e1959b72", + "metadata": {}, + "source": [ + "### Basis of the subspace:\n", + "\n", + "The eigenstate solver takes all possible pairs of spin-up and spin-down bitstrings to construnct the basis $\\mathcal{B}$ of the subspace:\n", + " \n", + "- Element 1: $|00010010\\rangle$ \n", + "\n", + "- Element 2: $|00011000\\rangle$ \n", + "\n", + "- Element 3: $|01000010\\rangle$ \n", + "\n", + "- Element 4: $|01001000\\rangle$ \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a550aba2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Basis elements of the subspace:\n", + "|00010010>\n", + "|00011000>\n", + "|01000010>\n", + "|01001000>\n" + ] + } + ], + "source": [ + "addresses_up = addresses[0]\n", + "addresses_dn = addresses[1]\n", + "\n", + "print(\"Basis elements of the subspace:\")\n", + "\n", + "for address_up in addresses_up:\n", + " for address_dn in addresses_dn:\n", + " format_name = \"{0:0\" + str(num_orbitals) + \"b}\"\n", + " print(\"|\" + format_name.format(address_up) + format_name.format(address_dn) + \">\")" + ] + }, + { + "cell_type": "markdown", + "id": "7317bc49", + "metadata": {}, + "source": [ + "**The subspace dimension is upper-bounded by**: (`samples_per_batch`)$^2$" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/how_tos/use_oo_to_optimize_hamiltonian_basis.ipynb b/docs/how_tos/use_oo_to_optimize_hamiltonian_basis.ipynb new file mode 100644 index 0000000..4d8d91f --- /dev/null +++ b/docs/how_tos/use_oo_to_optimize_hamiltonian_basis.ipynb @@ -0,0 +1,428 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9e40af77-7f0f-4dd6-ab0a-420cf396050e", + "metadata": {}, + "source": [ + "# Optimize Hamiltonian basis with orbital optimization\n", + "\n", + "In this tutorial, we will show how to use the `sqd` package to post-process quantum samples using the [self-consistent configuration recovery technique](https://arxiv.org/abs/2405.05068) and then further optimize the ground state approximation using orbital optimization\n", + "\n", + "Refer to [Sec. II A 4](https://arxiv.org/pdf/2405.05068) for a more detailed discussion on this technique." + ] + }, + { + "cell_type": "markdown", + "id": "a6755afb-ca1e-4473-974b-ba89acc8abce", + "metadata": {}, + "source": [ + "### First we will specify the molecule and its properties\n", + "\n", + "In this example, we will approximate the ground state energy of an $N_2$ molecule and then improve the answer using orbital optimization. This guide studies $N_2$ at equilibrium, which is mean-field dominated. This means the MO basis is already a good choice for our integrals; therefore, we will rotate our integrals **out** of the MO basis in order to illustrate the effects of orbital optimization." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "677f54ac-b4ed-47e3-b5ba-5366d3a520f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parsing ../molecules/n2_fci.txt\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from pyscf import ao2mo, tools\n", + "from qiskit_addon_sqd.fermion import rotate_integrals\n", + "\n", + "# Specify molecule properties\n", + "num_orbitals = 16\n", + "num_elec_a = num_elec_b = 5\n", + "open_shell = False\n", + "spin_sq = 0\n", + "\n", + "# Read in molecule from disk\n", + "mf_as = tools.fcidump.to_scf(\"../molecules/n2_fci.txt\")\n", + "hcore = mf_as.get_hcore()\n", + "eri = ao2mo.restore(1, mf_as._eri, num_orbitals)\n", + "\n", + "# Rotate our integrals out of MO basis\n", + "k_rot = (np.random.rand(num_orbitals**2) - 0.5) * 0.1\n", + "hcore_rot, eri_rot = rotate_integrals(hcore, eri, k_rot)\n", + "\n", + "nuclear_repulsion_energy = mf_as.mol.energy_nuc()" + ] + }, + { + "cell_type": "markdown", + "id": "c58e988c-a109-44cd-a975-9df43250c318", + "metadata": {}, + "source": [ + "### Generate a dummy counts dictionary and create the bitstring matrix and probability array" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e9506e0b-ed64-48bb-a97a-ef851b604af1", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_addon_sqd.counts import counts_to_arrays, generate_counts_uniform\n", + "\n", + "# Create a seed to control randomness throughout this workflow\n", + "rand_seed = 42\n", + "\n", + "# Generate random samples\n", + "counts_dict = generate_counts_uniform(10_000, num_orbitals * 2, rand_seed=rand_seed)\n", + "\n", + "# Convert counts into bitstring and probability arrays\n", + "bitstring_matrix_full, probs_arr_full = counts_to_arrays(counts_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "eb704101-0fe8-4d12-b572-b1d844e35a90", + "metadata": {}, + "source": [ + "### Iteratively refine the samples using SQD and approximate the ground state" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b72c048e-fe8e-4fc2-b28b-03138249074e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting configuration recovery iteration 0\n", + "Subspace dimension: 4624\n", + "Starting configuration recovery iteration 1\n", + "Subspace dimension: 215296\n", + "Starting configuration recovery iteration 2\n", + "Subspace dimension: 214369\n", + "Starting configuration recovery iteration 3\n", + "Subspace dimension: 219961\n", + "Starting configuration recovery iteration 4\n", + "Subspace dimension: 217156\n" + ] + } + ], + "source": [ + "from qiskit_addon_sqd.configuration_recovery import recover_configurations\n", + "from qiskit_addon_sqd.fermion import (\n", + " bitstring_matrix_to_sorted_addresses,\n", + " flip_orbital_occupancies,\n", + " solve_fermion,\n", + ")\n", + "from qiskit_addon_sqd.subsampling import postselect_and_subsample\n", + "\n", + "# SQSD options\n", + "iterations = 5\n", + "\n", + "# Eigenstate solver options\n", + "n_batches = 10\n", + "samples_per_batch = 300\n", + "max_davidson_cycles = 200\n", + "\n", + "# Self-consistent configuration recovery loop\n", + "e_hist = np.zeros((iterations, n_batches)) # energy history\n", + "s_hist = np.zeros((iterations, n_batches)) # spin history\n", + "occupancy_hist = np.zeros((iterations, 2 * num_orbitals))\n", + "occupancies_bitwise = None # orbital i corresponds to column i in bitstring matrix\n", + "for i in range(iterations):\n", + " print(f\"Starting configuration recovery iteration {i}\")\n", + " # On the first iteration, we have no orbital occupancy information from the\n", + " # solver, so we just post-select from the full bitstring set based on hamming weight.\n", + " if occupancies_bitwise is None:\n", + " bs_mat_tmp = bitstring_matrix_full\n", + " probs_arr_tmp = probs_arr_full\n", + "\n", + " # In following iterations, we use both the occupancy info and the target hamming\n", + " # weight to refine bitstrings.\n", + " else:\n", + " bs_mat_tmp, probs_arr_tmp = recover_configurations(\n", + " bitstring_matrix_full,\n", + " probs_arr_full,\n", + " occupancies_bitwise,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " rand_seed=rand_seed,\n", + " )\n", + "\n", + " # Throw out samples with incorrect hamming weight and create batches of subsamples.\n", + " batches = postselect_and_subsample(\n", + " bs_mat_tmp,\n", + " probs_arr_tmp,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " samples_per_batch,\n", + " n_batches,\n", + " rand_seed=rand_seed,\n", + " )\n", + "\n", + " # Run eigenstate solvers in a loop. This loop should be parallelized for larger problems.\n", + " int_e = np.zeros(n_batches)\n", + " int_s = np.zeros(n_batches)\n", + " int_occs = np.zeros((n_batches, 2 * num_orbitals))\n", + " cs = []\n", + " for j in range(n_batches):\n", + " addresses = bitstring_matrix_to_sorted_addresses(batches[j], open_shell=open_shell)\n", + " energy_sci, coeffs_sci, avg_occs, spin = solve_fermion(\n", + " addresses,\n", + " hcore_rot,\n", + " eri_rot,\n", + " spin_sq=spin_sq,\n", + " max_davidson=max_davidson_cycles,\n", + " )\n", + " energy_sci += nuclear_repulsion_energy\n", + " int_e[j] = energy_sci\n", + " int_s[j] = spin\n", + " int_occs[j, :num_orbitals] = avg_occs[0]\n", + " int_occs[j, num_orbitals:] = avg_occs[1]\n", + " cs.append(coeffs_sci)\n", + "\n", + " print(f\"Subspace dimension: {len(addresses[0]) * len(addresses[1])}\")\n", + " # Combine batch results\n", + " avg_occupancy = np.mean(int_occs, axis=0)\n", + " # The occupancies from the solver should be flipped to match the bits in the bitstring matrix.\n", + " occupancies_bitwise = flip_orbital_occupancies(avg_occupancy)\n", + "\n", + " # Track optimization history\n", + " e_hist[i, :] = int_e\n", + " s_hist[i, :] = int_s\n", + " occupancy_hist[i, :] = avg_occupancy" + ] + }, + { + "cell_type": "markdown", + "id": "9d78906b-4759-4506-9c69-85d4e67766b3", + "metadata": {}, + "source": [ + "### Visualize the results with no orbital optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "caffd888-e89c-4aa9-8bae-4d1bb723b35e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAP3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMS5wb3N0MSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8kixA/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC7VklEQVR4nOzdd3gUVdvH8d+m94SSEEJJQg0dBEV6N/QiICDSH7Ch0vQRVKqKoAgqSlEEFZAmAiIgSBVp0pv03muABEggOe8fvNmHJQkkkGQh+X6uay7YM2dm79nZzJ6998w5FmOMEQAAAAAAAJCOHOwdAAAAAAAAADIfklIAAAAAAABIdySlAAAAAAAAkO5ISgEAAAAAACDdkZQCAAAAAABAuiMpBQAAAAAAgHRHUgoAAAAAAADpjqQUAAAAAAAA0h1JKQAAAAAAAKQ7klJ4olksFg0cONDeYaSqSZMmyWKx6MiRI/YOxa6OHDkii8WiSZMm2TsUAIngbxQAgPurXr26qlev/lDb2uN7Tvz3kI0bNz6w7qMcW1IGDhwoi8WSqvvE44+kVAb3zTffyGKxqHz58vYOJUO5fv26Bg4cqBUrVtg7FG3fvl2dOnVSaGio3Nzc5OXlpdKlS+udd97RoUOH7B1eujhy5Ig6deqk/Pnzy83NTYGBgapataoGDBhgU++bb755pC/Qp06d0sCBA7V169ZHC/ge8V/uk1o++eSTVH2+zCYmJkZffPGFypQpIx8fH/n5+alYsWLq1q2b9uzZk6D+rl279NJLLylXrlxydXVVUFCQXnrpJe3evTtB3fjGW/zi5uamoKAghYeH68svv9S1a9eSFeOKFStksVg0a9Ysa9maNWs0cOBARUREPPSxp4apU6dq1KhRdo0BwOPpcWpnJnbtbtu2rXbt2mXv0JBOduzYoRYtWig4OFhubm7KlSuX6tSpo6+++ipNn3f37t0aOHCgXX9Qvnjxot5++20VLlxYbm5uypo1q8LDwzV//vx0iyGt2snI+JzsHQDS1pQpUxQSEqINGzbowIEDKlCggL1DSlU3btyQk1P6v42vX7+uQYMGSVKq/0KQEt9++61effVVZc+eXW3btlVYWJhu376tnTt36scff9SoUaN048YNOTo62i3GtHbgwAE9/fTTcnd3V+fOnRUSEqLTp09r8+bNGjZsmPU8SXcaz9mzZ1fHjh0f6rlOnTqlQYMGKSQkRKVLl06dA7hLmzZtVL9+/QTlZcqUSfXnykyaN2+uhQsXqk2bNuratatu3bqlPXv2aP78+apYsaLCwsKsdWfPnq02bdooa9as6tKli0JDQ3XkyBFNmDBBs2bN0vTp09WkSZMEzzF48GCFhobq1q1bOnPmjFasWKEePXro888/17x581SyZMkUx71mzRoNGjRIHTt2lJ+f36O8BI9k6tSp2rlzp3r06GFTHhwcrBs3bsjZ2dk+gQGwu8elnfmga/e0adPUrFkzu8SG9LFmzRrVqFFDefPmVdeuXRUYGKjjx49r3bp1+uKLL/TGG2+k2XPv3r1bgwYNUvXq1RUSEmKzbvHixWn2vPH27t2rWrVq6fz58+rUqZPKlSuniIgITZkyRY0aNVKfPn306aefpvrz3ntsad1ORsZFUioDO3z4sNasWaPZs2fr5Zdf1pQpUxL0HEkvt2/fVlxcnFxcXFJ1v25ubqm6vyfJmjVr9Oqrr6pSpUqaP3++vL29bdaPGDFCH3300QP3c/36dXl4eKRVmGlu5MiRioyM1NatWxUcHGyz7ty5c3aK6uE89dRTeumll+wdRpr9vdrDP//8o/nz5+ujjz5Sv379bNaNHj3aphfSwYMH1a5dO+XLl0+rVq2Sv7+/dd1bb72lKlWq6KWXXtL27dsVGhpqs6969eqpXLly1sd9+/bVsmXL1LBhQzVu3Fj//vuv3N3d0+YgUyi1/ubje4YByJwel3Zmcq7d7dq10/bt25UvX750jw+pJyoqSp6enomu++ijj+Tr66t//vknwQ859mwPpnVb6tatW2rRooUuX76sVatW2fRa7Nmzp9q2bavPPvtM5cqVU6tWrZLcz82bN1Mca0ZoJ+LxwO17GdiUKVOUJUsWNWjQQC1atNCUKVMS1Im/beizzz7TyJEjFRwcLHd3d1WrVk07d+60qduxY0d5eXnp0KFDCg8Pl6enp4KCgjR48GAZYxLd56hRo5Q/f365urpab31ZtmyZqlSpIk9PT/n5+alJkyb6999/rdtPnDhRFotF33//vc3zf/zxx7JYLFqwYIG17N57rePvQ963b59eeukl+fr6yt/fXx988IGMMTp+/LiaNGkiHx8fBQYGasSIETbPERMTo/79+6ts2bLy9fWVp6enqlSpouXLl9scX3yDZ9CgQdbbdu6OY8+ePWrRooWyZs0qNzc3lStXTvPmzUvw+u/atUs1a9aUu7u7cufOrQ8//FBxcXEJ6iUm/rmnTJmSICEl3UnYDRkyxKaXVPXq1VW8eHFt2rRJVatWlYeHh/WL+rlz59SlSxflyJFDbm5uKlWqlH744QebfcbfYnTvbYuJjS0T/345efKkmjZtKi8vL/n7+6tPnz6KjY212T4iIkIdO3aUr6+v/Pz81KFDh2TfsnTw4EHlzp07QUJKkgICAqz/DwkJ0a5du7Ry5UrrOYvv5Xbp0iX16dNHJUqUkJeXl3x8fFSvXj1t27bN5tiffvppSVKnTp2s+7j7mNevX6+6devK19dXHh4eqlatmv7+++9kHUdyhYSEqGHDhlq9erWeeeYZubm5KV++fPrxxx8T1I2IiFCPHj2UJ08eubq6qkCBAho2bJjNe+xBf68rVqxQuXLl5Obmpvz582vcuHEJ7vevVq2aSpUqlWi8hQsXVnh4eJLH07BhwyS/JFSoUMEm0bNkyRJVrlxZfn5+8vLyUuHChRMkmu518OBBSVKlSpUSrHN0dFS2bNmsjz/99FNdv35d48ePt/lSI0nZs2fXuHHjFBkZmexfG2vWrKkPPvhAR48e1eTJk5O1TbyBAwfq7bffliSFhoZa32933xowefJklS1bVu7u7sqaNatat26t48eP2+znfn/zc+fOVYMGDRQUFCRXV1flz59fQ4YMsfn7rF69un7//XcdPXrUGkP8r8BJjSn1oGt8/PFZLBYdOHDA2hPM19dXnTp10vXr123qPsx5B5D27tfOvHXrlrJmzapOnTol2O7q1atyc3NTnz59rGVHjx5V48aN5enpqYCAAPXs2VN//PFHom2OeyXn2h0VFaXhw4fbrDt58qS6dOlivQaGhobq1VdfVUxMjLVORESEevbsqZCQELm6uip37txq3769Lly4ICnpcUATay/dfT2uWLGi3N3dFRoaqrFjx9psm5y2qGT7+T1+/Hjr5/fTTz+tf/75J8HrtGfPHr3wwgvy9/eXu7u7ChcurPfee0+StHz5clksFv36668Jtps6daosFovWrl2bxBn43+uwatUqvfzyy8qWLZt8fHzUvn17Xb58OUH9hQsXWj8nvL291aBBgwS3Wca3Iw8ePKj69evL29tbbdu2TTKGgwcPqlixYon2LL67PSjd+f7QvXt3TZkyxXq7W9myZbVq1SqbekePHtVrr72mwoULy93dXdmyZVPLli1tzvekSZPUsmVLSVKNGjWsn5Xx5/7ecZeSe36T65dfftHOnTv17rvvJriN1tHRUePGjZOfn5/N95T49+e0adP0/vvvK1euXPLw8NDVq1etda5fv/7Ac3n3sT2onfzXX3+pZcuWyps3r1xdXZUnTx717NlTN27ceKjjRgZjkGGFhYWZLl26GGOMWbVqlZFkNmzYYFPn8OHDRpIpUaKECQkJMcOGDTODBg0yWbNmNf7+/ubMmTPWuh06dDBubm6mYMGCpl27dmb06NGmYcOGRpL54IMPEuyzaNGiJl++fOaTTz4xI0eONEePHjVLliwxTk5OplChQmb48OFm0KBBJnv27CZLlizm8OHD1n00bNjQ+Pr6mmPHjhljjNm+fbtxcXGxHk88SWbAgAHWxwMGDDCSTOnSpU2bNm3MN998Yxo0aGAkmc8//9wULlzYvPrqq+abb74xlSpVMpLMypUrrdufP3/e5MyZ0/Tq1cuMGTPGDB8+3BQuXNg4OzubLVu2GGOMiYyMNGPGjDGSTLNmzcxPP/1kfvrpJ7Nt2zZjjDE7d+40vr6+pmjRombYsGFm9OjRpmrVqsZisZjZs2dbn+v06dPG39/fZMmSxQwcONB8+umnpmDBgqZkyZJGks3rca+oqCjj5ORkateufZ93QELVqlUzgYGBxt/f37zxxhtm3LhxZs6cOeb69eumSJEixtnZ2fTs2dN8+eWXpkqVKkaSGTVqlHX75cuXG0lm+fLlNvuNP+cTJ060lsW/X4oVK2Y6d+5sxowZY5o3b24kmW+++cZaLy4uzlStWtU4ODiY1157zXz11VemZs2a1tfh7n0mplu3bsbR0dEsXbr0vvV+/fVXkzt3bhMWFmY9Z4sXLzbGGPPPP/+Y/Pnzm3fffdeMGzfODB482OTKlcv4+vqakydPGmOMOXPmjBk8eLCRZLp162bdx8GDB40xxixdutS4uLiYChUqmBEjRpiRI0eakiVLGhcXF7N+/fr7xhb/+g0aNMicP38+wXLr1i1r3eDgYFO4cGGTI0cO069fPzN69Gjz1FNPGYvFYnbu3GmtFxUVZUqWLGmyZctm+vXrZ8aOHWvat29vLBaLeeuttxI8d2J/r5s3bzaurq4mJCTEfPLJJ+ajjz4yQUFBplSpUubuj49vv/3WSDI7duywOa4NGzYYSebHH39M8th//PHHRK9NR44cMZLMp59+aoy583fl4uJiypUrZ7744gszduxY06dPH1O1atX7vrZr1qwxkkzXrl1tXsfEBAUFmZCQkPvWCQkJMblz57Y+njhxopFk/vnnn0TrHz9+3EgyLVq0uO9+4/+2Zs6caYwxZtu2baZNmzZGkhk5cqT1/RYZGWmMMebDDz80FovFtGrVynzzzTfWa2lISIi5fPmydb9J/c0bY0zTpk3NCy+8YD799FMzZswY07JlSyPJ9OnTx7r94sWLTenSpU327NmtMfz666/GmMT/7pN7jY+/VpcpU8Y8//zz5ptvvjH/+c9/jCTzzjvvWOs97HkHkPYe1M7s3Lmz8fPzM9HR0Tbb/fDDDzbXzcjISJMvXz7j7u5u3n33XTNq1CjzzDPPWD9r7m1z3Othrt0nT540QUFBxsPDw/To0cOMHTvWfPDBB6ZIkSLWa+i1a9dM8eLFjaOjo+natasZM2aMGTJkiHn66aetbcL4z4B722yJtZeqVatmgoKCTEBAgOnevbv58ssvTeXKlY0kM2HCBGu95LRFjfnfNbhMmTKmQIECZtiwYWb48OEme/bsJnfu3CYmJsZad9u2bcbHx8dky5bN9O3b14wbN8688847pkSJEsaYO22xPHnymObNmyd47erXr2/y589/39c3/nUoUaKEqVKlivnyyy/N66+/bhwcHEzVqlVNXFycte6PP/5oLBaLqVu3rvnqq6/MsGHDTEhIiPHz87N5HTt06GBcXV1N/vz5TYcOHczYsWPv25547rnnjLe3d4K2SGIkmeLFi5vs2bObwYMHm2HDhpng4GDj7u5us/3MmTNNqVKlTP/+/c348eNNv379TJYsWUxwcLCJiooyxhhz8OBB8+abbxpJpl+/ftbPyvjvUNWqVTPVqlWz7jO55zc+zru/5yTmxRdfNJLMkSNHkqzToUMHI8ns37/fGPO/92fRokVN6dKlzeeff26GDh1qoqKiUnQu7z62B7WT33jjDVO/fn3z8ccfm3HjxpkuXboYR0fHBO2j+PYBMhfOeAa1ceNGI8ksWbLEGHPnwyZ37tw2X0aN+d8Hmru7uzlx4oS1fP369UaS6dmzp7Us/oL2xhtvWMvi4uJMgwYNjIuLizl//rzNPn18fMy5c+dsnq906dImICDAXLx40Vq2bds24+DgYNq3b28tO336tMmaNaupU6eOiY6ONmXKlDF58+Y1V65csdlfUkmpbt26Wctu375tcufObSwWi/nkk0+s5ZcvXzbu7u6mQ4cONnXvbTxdvnzZ5MiRw3Tu3Nladv78+SQ/KGrVqmVKlChhbt68afM6VaxY0RQsWNBa1qNHDyPJJmFx7tw54+vr+8Ck1LZt24wk06NHjwTrLl68aJPQuPt4qlWrZiSZsWPH2mwzatQoI8lMnjzZWhYTE2MqVKhgvLy8zNWrV40xKU9KSTKDBw+2qVumTBlTtmxZ6+M5c+YYSWb48OHWstu3b1uTYg9KSu3cudO4u7tbk5FvvfWWmTNnjrWxcLdixYrZNAzi3bx508TGxiY4JldXV5v4//nnn0RjiouLMwULFjTh4eE2H9bXr183oaGhpk6dOvc9hvjXL6ll7dq11rrBwcFGklm1apW17Ny5c8bV1dX07t3bWjZkyBDj6elp9u3bZ/Nc7777rnF0dLQmfO/399qoUSPj4eFhTcwZY8z+/fuNk5OTTYMhIiLCuLm5mf/+978227/55pvG09PTmkhJzJUrVxLEbowxw4cPNxaLxRw9etQYY8zIkSONJOt1Jrni4uKs7/scOXKYNm3amK+//tq637uPQZJp0qTJfffXuHFjI8n6N/GgpJQxxvj6+poyZcrcd7/3JqWMMebTTz9N9Fpw5MgR4+joaD766COb8h07dhgnJyeb8qT+5o258/6818svv2w8PDxsrl8NGjQwwcHBCeom9nef3Gt8/LX67uuqMcY0a9bMZMuWzfr4Yc87gLSVnHbmH3/8YSSZ3377zWbb+vXrm3z58lkfjxgxwkiyJsyNMebGjRsmLCzsgUmph712t2/f3jg4OCR67Y7/HO/fv7+RZPOD4r11UpqUkmRGjBhhLYuOjrZeN+OTSMlti8Zfg7Nly2YuXbpkLZ87d26C171q1arG29s7wWff3W2Wvn37GldXVxMREWEtO3funHFycnpgYiT+dShbtqxNMmz48OFGkpk7d64x5k6iz8/Pz3Tt2tVm+zNnzhhfX1+b8vh25Lvvvnvf5463ePFi4+joaBwdHU2FChXMO++8Y/744w+beOLFt682btxoLTt69Khxc3MzzZo1s5Yl9jm5du3aBD+4zZw5M8n36r1JqeSe3/g4H/Taly5d2vj6+t63zueff24kmXnz5hlj/vf+zJcvX4JjTO65TOzYkmonG5P4azl06FCbtp4xJKUyK27fy6CmTJmiHDlyqEaNGpLudFNt1aqVpk2bluDWKUlq2rSpcuXKZX38zDPPqHz58ja3ysXr3r279f/x3V9jYmL0559/2tRr3ry5TTfq06dPa+vWrerYsaOyZs1qLS9ZsqTq1Klj81yBgYH6+uuvtWTJElWpUkVbt27V999/Lx8fn2Qd/3/+8x/r/x0dHVWuXDkZY9SlSxdruZ+fnwoXLmwzQ52jo6P1/ui4uDhdunRJt2/fVrly5bR58+YHPu+lS5e0bNkyvfDCC7p27ZouXLigCxcu6OLFiwoPD9f+/ft18uRJSdKCBQv07LPP6plnnrFu7+/vf9+uyfHiu9d6eXklWJcvXz75+/tbl3tvG3R1dU3QnX7BggUKDAxUmzZtrGXOzs568803FRkZqZUrVz4wpqS88sorNo+rVKli85ovWLBATk5OevXVV61ljo6OyR6QslixYtq6dateeuklHTlyRF988YWaNm2qHDly6Ntvv03WPlxdXeXgcOdyGBsbq4sXL1pvE0rOed+6dav279+vF198URcvXrSe96ioKNWqVUurVq1K1m2Z3bp105IlSxIsRYsWtalXtGhRValSxfrY398/wXt55syZqlKlirJkyWKN58KFC6pdu7ZiY2MTdFG/9+81NjZWf/75p5o2baqgoCBreYECBVSvXj2bbX19fdWkSRP9/PPP1lt5Y2NjNX36dDVt2jTJ8R8kWW+VnDFjhs1twNOnT9ezzz6rvHnzSpK1O/7cuXOTfYurdOca9ccff+jDDz9UlixZ9PPPP+v1119XcHCwWrVqZb1NNH6WvMRuhb1b/Prkzqon3fk7TUn9B5k9e7bi4uL0wgsv2JzbwMBAFSxYMMEtAIn9zUuyGeMq/npVpUoVXb9+PdFZCR8kJdf4eIldHy5evGi9xj3seQeQtpLTzqxZs6ayZ8+u6dOnW7e7fPmylixZYjO2zaJFi5QrVy41btzYWubm5qauXbs+MI6UXruvXr2quLg4zZkzR40aNbK5RTxe/O3pv/zyi0qVKpXoAOkPO2W9k5OTXn75ZetjFxcXvfzyyzp37pw2bdokKeVt0VatWilLlizWx/Htg/g2wfnz57Vq1Sp17tzZ+pma2HG0b99e0dHRNrPATp8+Xbdv3072eJfdunWzmfzi1VdflZOTk/X6v2TJEkVERKhNmzY2n1+Ojo4qX758orew3d0+vJ86depo7dq1aty4sbZt26bhw4crPDxcuXLlSnQIjQoVKqhs2bLWx3nz5lWTJk30xx9/WN/Dd39O3rp1SxcvXlSBAgXk5+eXrPZhYh71u8a9rl27lqL3/906dOiQ5HiXDzqXKXX380RFRenChQuqWLGijDHasmXLQ+0TGQdJqQwoNjZW06ZNU40aNXT48GEdOHBABw4cUPny5XX27FktXbo0wTYFCxZMUFaoUKEE98g7ODgkGP+lUKFCkpSg7r0DAR89elTSnTFm7lWkSBHrl/h4rVu3VoMGDbRhwwZ17dpVtWrVSvqg73Hvh66vr6/c3NyUPXv2BOX33h/9ww8/qGTJknJzc1O2bNnk7++v33//XVeuXHng8x44cEDGGH3wwQc2iSF/f3/r4J/xgy0ePXo00dc9sdfnXvEfLpGRkQnWzZ07V0uWLNFnn32W6La5cuVKMDBhfCzxiZl4RYoUsa5/GG5ubgnGd8iSJYvNa3706FHlzJkzQYItOa9DvEKFCumnn37ShQsXtH37dn388cdycnJSt27dEiRLExMXF6eRI0eqYMGCcnV1Vfbs2eXv76/t27cn67zv379f0p0P93vP+3fffafo6Ohk7adgwYKqXbt2guXeZOy9728p4eu6f/9+LVq0KEE8tWvXlpRw0M97/17PnTunGzduJDqTUmJl7du317Fjx/TXX39Jkv7880+dPXtW7dq1e+Bxt2rVSsePH7eOV3Hw4EFt2rTJ5ktLq1atVKlSJf3nP/9Rjhw51Lp1a82YMSNZiQpXV1e99957+vfff3Xq1Cn9/PPPevbZZzVjxgxrkj25yaZr167JYrEkuJbcT2Rk5AMbjCmxf/9+GWNUsGDBBOf333//TXBuE/ubl+6MadesWTP5+vrKx8dH/v7+1i8eyXm/3iul13gp4Xs5/otV/Hv5Uc47gLSR3Hamk5OTmjdvrrlz5yo6OlrSnaT6rVu3bK7vR48eVf78+RMkepIzk19Krt3x9c+fP6+rV6+qePHi993m4MGDD6yTUkFBQQl+qEmsHZ2StuiDrqPxyakHHUtYWJiefvppm7HBpkyZomeffTbZsyre26718vJSzpw5rccW316qWbNmgs+vxYsXJ/j8cnJyUu7cuZP13JL09NNPa/bs2bp8+bI2bNigvn376tq1a2rRooV1rMykYpXunIvr16/r/Pnzku7M8t2/f3/r2Jzx7cOIiIiH+pyM9yjfNe7l7e2dovf/3e5t+93tQecypY4dO2b90Sp+nNlq1apJerg2BzIWZt/LgJYtW6bTp09r2rRpmjZtWoL1U6ZM0XPPPZfmcTzqTFMXL17Uxo0bJd2ZajUuLi5B0iQpdw/ufb8ySTa9MyZPnqyOHTuqadOmevvttxUQECBHR0cNHTrUOmDy/cR/UerTp0+SgzunxnTJBQoUkJOTU4LB6CVZL/BOTon/eT/KeUnql8HEet9JSb/macXR0VElSpRQiRIlVKFCBdWoUUNTpkyxJmKS8vHHH+uDDz5Q586dNWTIEGXNmlUODg7q0aNHsr78xtf59NNPk5wCN7FebQ8rOe/luLg41alTR++8806ideMbwfEe9e81PDxcOXLk0OTJk1W1alVNnjxZgYGBD3ztJalRo0by8PDQjBkzVLFiRc2YMUMODg7WgUPj41u1apWWL1+u33//XYsWLdL06dNVs2ZNLV68ONnvtZw5c6p169Zq3ry5ihUrphkzZmjSpEny9fVVUFCQtm/fft/tt2/frty5cyd7xpkTJ07oypUrqTpNelxcnCwWixYuXJjocd/7Xkvs3EZERKhatWry8fHR4MGDlT9/frm5uWnz5s3673//m25Jnwe9l1PrvANIPSlpZ7Zu3Vrjxo3TwoUL1bRpU82YMUNhYWFJTo6RUr6+vsqZM2eyrt25cuWSj49Pqg6snNJ2UXKktC2anDZBcrVv315vvfWWTpw4oejoaK1bt06jR49O8X6SEv/Z8tNPPykwMDDB+nvbrnf3ZE8JFxcXPf3003r66adVqFAhderUSTNnzkzx7JBvvPGGJk6cqB49eqhChQry9fWVxWJR69atH/pz8lG/a9yrSJEi2rp1q44dO5boj5aSrH8f9/a8T69ZgWNjY1WnTh1dunRJ//3vfxUWFiZPT0+dPHlSHTt25IcmkJTKiKZMmaKAgAB9/fXXCdbNnj1bv/76q8aOHWtzIYr/5eJu+/bts86yFC8uLk6HDh2y+UK7b98+SUpQ917xs6Pt3bs3wbo9e/Yoe/bsNr8evf7667p27ZqGDh2qvn37atSoUerVq9d9n+NRzZo1S/ny5dPs2bNtGhr3fogl1QiJ70Xm7Oz8wC/jwcHBib7uib0+9/L09FT16tW1cuVKnTx50ubWy4cRHBys7du3J0j8xd/CE3/u4n99u3dmvIftSRW/76VLlyoyMtLmy3RyXof7ie+Sf/r0aWtZUudt1qxZqlGjhiZMmGBTHhERYdMjJqnt8+fPL+nOrWjJScKkh/z58ysyMvKh4wkICJCbm5sOHDiQYF1iZY6OjnrxxRc1adIkDRs2THPmzFHXrl2TlTTw9PRUw4YNNXPmTH3++eeaPn26qlSpYnPboHSnp2atWrVUq1Ytff755/r444/13nvvafny5Sk+TmdnZ5UsWVL79++33vrWqFEjjRs3TqtXr1blypUTbPPXX3/pyJEjKboO/fTTT5J03xkIk3K/95sxRqGhoQmSi8m1YsUKXbx4UbNnz1bVqlWt5YcPH052HPdK6TU+uVLzvAN4dClpZ1atWlU5c+bU9OnTVblyZS1btsw641u84OBg7d69W8YYm+tNYp81iWnYsKG+/fbbB16742+b8/f3l4+PT6I/7N0tf/78D6yT0nbRqVOnFBUVZXMtvLcdndy2aHLFt00fdCzSnSRir1699PPPP+vGjRtydna26dX2IPv377fe0ind6Sl8+vRp1a9fX9L/2ksBAQHpdv1OrD0YH+u99u3bJw8PD2sv/1mzZqlDhw42s3XfvHkzwflOye2cqX1+GzZsqJ9//lk//vij3n///QTrr169qrlz5yosLCxFP5A96FwmJqnXYceOHdq3b59++OEHtW/f3lq+ZMmSZMeDjI3b9zKYGzduaPbs2WrYsKFatGiRYOnevbuuXbuW4N7qOXPmWMc6kqQNGzZo/fr1CcaOkWTzi4kxRqNHj5azs/MDb6/LmTOnSpcurR9++MHmYr5z504tXrzY5iI3a9YsTZ8+XZ988oneffddtW7dWu+//771gzutxH+BvvvXpfXr1yeYBtfDw0NSwkZIQECAqlevrnHjxiX48JNk7Q4sSfXr19e6deu0YcMGm/V3d5u+n/79+ys2NlYvvfRSorfxpeQXsvr16+vMmTM24z7cvn1bX331lby8vKy9r4KDg+Xo6JhgPKJvvvkm2c+V2HPfvn1bY8aMsZbFxsbqq6++Stb2f/31l27dupWgPP6e97tvJfL09ExwzqQ75/3e12vmzJk2fxPx20sJz3vZsmWVP39+ffbZZ4mei7vPe3p54YUXtHbtWv3xxx8J1kVEROj27dv33d7R0VG1a9fWnDlzdOrUKWv5gQMHtHDhwkS3adeunS5fvqyXX35ZkZGRyR6DQrpzm9apU6f03Xffadu2bQkawZcuXUqwTXyvtPjbQhKzf/9+HTt2LEF5RESE1q5dqyxZslgbn3369JGHh4defvllXbx4McHzv/LKK/Lx8bEZV+9+li1bpiFDhig0NDRZY8XdK6n32/PPPy9HR0cNGjQowfvWGJMg9sQkdq2LiYlJ9G/Z09MzWV3rU3KNT66HPe8A0kZK25kODg5q0aKFfvvtN/3000+6fft2gut7eHi4Tp48adM2vXnzZrLHhXz77bfl7u5+32u3h4eH3n77bWtMTZs21W+//WbtkX+3+Oti8+bNtW3bNv36669J1olPstzdLoqNjdX48eMTjfX27dsaN26c9XFMTIzGjRsnf39/6/hGyW2LJpe/v7+qVq2q77//PsHn4b2fIdmzZ1e9evU0efJkTZkyRXXr1k3R7erjx4+3aZONGTNGt2/ftn6fCA8Pl4+Pjz7++ONE226P0l5avnx5om3fxNqDkrR27VqbMZyOHz+uuXPn6rnnnrOeg8Tah1999VWCnnBJfV4nJrXPb4sWLVS0aFF98sknCd7PcXFxevXVV3X58uUUJ70edC4Tk9TrkNgxG2P0xRdfpCgmZFz0lMpg5s2bp2vXrtkMFnm3Z599Vv7+/poyZYpNo6BAgQKqXLmyXn31VUVHR2vUqFHKli1bglt/3NzctGjRInXo0EHly5fXwoUL9fvvv6tfv34Jxg5KzKeffqp69eqpQoUK6tKli27cuKGvvvpKvr6+GjhwoKQ7Y9m8+uqrqlGjhvXL3+jRo7V8+XJ17NhRq1evfqiuvMnRsGFDzZ49W82aNVODBg10+PBhjR07VkWLFrVJNri7u6to0aKaPn26ChUqpKxZs6p48eIqXry4vv76a1WuXFklSpRQ165dlS9fPp09e1Zr167ViRMntG3bNknSO++8o59++kl169bVW2+9JU9PT40fP97aa+lBqlSpotGjR+uNN95QwYIF1bZtW4WFhSkmJkb79u3TlClT5OLikmj36Ht169ZN48aNU8eOHbVp0yaFhIRo1qxZ+vvvvzVq1CjrPei+vr5q2bKlvvrqK1ksFuXPn1/z589PMAZASjRq1EiVKlXSu+++qyNHjqho0aKaPXt2su8vHzZsmDZt2qTnn39eJUuWlCRt3rxZP/74o7JmzaoePXpY65YtW1ZjxozRhx9+qAIFCiggIEA1a9ZUw4YNNXjwYHXq1EkVK1bUjh07NGXKlATjp+XPn19+fn4aO3asvL295enpqfLlyys0NFTfffed6tWrp2LFiqlTp07KlSuXTp48qeXLl8vHx0e//fbbA49l8+bNmjx5coLy/Pnzq0KFCsl6PeK9/fbbmjdvnho2bKiOHTuqbNmyioqK0o4dOzRr1iwdOXLkgQ3NgQMHavHixapUqZJeffVVxcbGavTo0SpevLi2bt2aoH6ZMmVUvHhxzZw5U0WKFNFTTz2V7Hjr168vb29v9enTR46OjmrevLnN+sGDB2vVqlVq0KCBgoODde7cOX3zzTfKnTt3or+Mx9u2bZtefPFF1atXT1WqVFHWrFl18uRJ/fDDDzp16pRGjRplbSwVKFBAP/74o9q0aaMSJUqoS5cuCg0N1ZEjRzRhwgRdvnxZ06ZNS3QMhoULF2rPnj26ffu2zp49q2XLlmnJkiUKDg7WvHnz5ObmluzXIl78F5T33ntPrVu3lrOzsxo1aqT8+fPrww8/VN++fXXkyBE1bdpU3t7eOnz4sH799Vd169ZNffr0ue++K1asqCxZsqhDhw568803ZbFY9NNPPyXaoC9btqymT5+uXr166emnn5aXl5caNWqU6H6Tc41PiYc97wDSxsO0M1u1aqWvvvpKAwYMUIkSJazjVcZ7+eWXNXr0aLVp00ZvvfWWcubMqSlTplivmw/qhVKwYEH98MMPatu2baLX7gsXLujnn3+2JpCkO7ftL168WNWqVVO3bt1UpEgRnT59WjNnztTq1avl5+ent99+W7NmzVLLli3VuXNnlS1bVpcuXdK8efM0duxYlSpVSsWKFdOzzz6rvn376tKlS8qaNaumTZuW5A8/QUFBGjZsmI4cOaJChQpp+vTp2rp1q8aPH28dVDq5bdGU+PLLL1W5cmU99dRT6tatm/X1+f333xN8nrdv314tWrSQJA0ZMiRFzxMTE6NatWrphRde0N69e/XNN9+ocuXK1veLj4+PxowZo3bt2umpp55S69at5e/vr2PHjun3339XpUqVHvp2wTfeeEPXr19Xs2bNrO3hNWvWaPr06QoJCUkw4Ufx4sUVHh6uN998U66urtYfZQYNGmSt07BhQ/3000/y9fVV0aJFtXbtWv3555/Kli2bzb5Kly4tR0dHDRs2TFeuXJGrq6tq1qypgICABHGm9vl1cXHRrFmzVKtWLVWuXFmdOnVSuXLlFBERoalTp2rz5s3q3bu3WrdunaL9PuhcJiapdnJYWJjy58+vPn366OTJk/Lx8dEvv/ySYFxfZGLpMscf0k2jRo2Mm5ubiYqKSrJOx44djbOzs7lw4YJ1OtlPP/3UjBgxwuTJk8e4urqaKlWqmG3bttls16FDB+Pp6WkOHjxonnvuOePh4WFy5MhhBgwYYGJjY6317t5nYv78809TqVIl4+7ubnx8fEyjRo3M7t27reuff/554+3tbY4cOWKzXfwUt8OGDbOW6Z6pUuOnEb13+vD42O9VrVo1U6xYMevjuLg48/HHH5vg4GDj6upqypQpY+bPn286dOiQYEr0NWvWmLJlyxoXF5cEcRw8eNC0b9/eBAYGGmdnZ5MrVy7TsGFDM2vWLJt9bN++3VSrVs24ubmZXLlymSFDhpgJEyYkOr1wUrZs2WLat29v8ubNa1xcXIynp6cpWbKk6d27tzlw4MB9j/duZ8+eNZ06dTLZs2c3Li4upkSJEolO6Xr+/HnTvHlz4+HhYbJkyWJefvlls3PnzgRTwCb1mic21evFixdNu3btjI+Pj/H19TXt2rUzW7ZsSXJa2bv9/fff5vXXXzfFixc3vr6+xtnZ2eTNm9d07NjRHDx40KbumTNnTIMGDYy3t7eRZJ3G9ubNm6Z3794mZ86cxt3d3VSqVMmsXbs2wVS3xtx5HxYtWtQ4OTkliG/Lli3m+eefN9myZTOurq4mODjYvPDCC2bp0qX3PYb4v5mklg4dOljrBgcHmwYNGiTYR2KxXrt2zfTt29cUKFDAuLi4mOzZs5uKFSuazz77zDrN74P+XpcuXWrKlCljXFxcTP78+c13331nevfubdzc3BKtHz9l8Mcff3zfY05M27ZtjSRTu3btRONo0qSJCQoKMi4uLiYoKMi0adPG7Nu37777PHv2rPnkk09MtWrVTM6cOY2Tk5PJkiWLqVmzZoK/x3g7duwwL774ogkMDDQODg5GknFzczO7du1KUDd+6uT4xcXFxQQGBpo6deqYL774wjr9+IPET888c+ZMm/IhQ4aYXLlyWeO4+7rwyy+/mMqVKxtPT0/j6elpwsLCzOuvv2727t1rrXO/v/m///7bPPvss8bd3d0EBQVZp8/WPdNaR0ZGmhdffNH4+fkZSdZrYfx7596/0Qdd441J+lp97/TqD3veAaSNlLYzjbnTtsqTJ4+RZD788MNEtzl06JBp0KCBcXd3N/7+/qZ3797ml19+MZLMunXrkhXb9u3bTZs2bUzOnDmNs7OzCQwMNG3atDE7duxItP7Ro0dN+/btjb+/v3F1dTX58uUzr7/+uomOjrbWuXjxounevbvJlSuXcXFxMblz5zYdOnSwHpsxd9p8tWvXNq6uriZHjhymX79+ZsmSJQmupfHX440bN5oKFSoYNzc3ExwcbEaPHm0TV3Lbovf7/L63XWqMMTt37jTNmjUzfn5+xs3NzRQuXNh88MEHCbaNjo42WbJkMb6+vubGjRv3e8mt4q/dK1euNN26dTNZsmQxXl5epm3btubixYsJ6i9fvtyEh4cbX19f4+bmZvLnz286duxoNm7caK2TVDsyKQsXLjSdO3c2YWFhxsvLy7i4uJgCBQqYN954w5w9e9amriTz+uuvm8mTJ5uCBQtaX+e7z5cxxly+fNnaNvby8jLh4eFmz549Jjg42KZtZowx3377rcmXL59xdHS0Off3ts9S8l0jsfOYlHPnzplevXqZAgUKGFdXV+Pn52dq165t5s2bl6BuUm0OY1J2LlPSTt69e7epXbu28fLyMtmzZzddu3Y127ZtS9COSOx7AjI+izEPMQoeMowjR44oNDRUn3766QN/We/YsaNmzZr10L/SAMgYmjZtql27diU6HsMXX3yhnj176siRI0kOuPmk+fHHH9WxY0e99NJL+vHHH+0dDgBkCqNGjVLPnj114sSJRx4783FQvXp1XbhwIVljO9nT7du3FRQUpEaNGiUYazMpkyZNUqdOnfTPP/9Yx3B6nFksFr3++uupOog7gIfHmFIAgCTdO0vR/v37tWDBAlWvXj1BXWOMJkyYoGrVqmWYhJR051aGoUOH6qefflK/fv3sHQ4AZDj3ftbcvHlT48aNU8GCBTNEQupJMmfOHJ0/f95mQGoASEuMKQUASFK+fPnUsWNH5cuXT0ePHtWYMWPk4uJiM95cVFSU5s2bp+XLl2vHjh2aO3euHSNOG//973/13//+195hAECG9Pzzzytv3rwqXbq0rly5osmTJ2vPnj3JnvwFj279+vXavn27hgwZojJlylgnuQGAtEZSCgCQpLp16+rnn3/WmTNn5OrqqgoVKujjjz9WwYIFrXXOnz+vF198UX5+furXr999B8EEAOBe4eHh+u677zRlyhTFxsaqaNGimjZtWoKZ+pB2xowZo8mTJ6t06dKaNGmSvcMBkIk8VmNKzZ49W2PHjtWmTZt06dIlbdmyxTr1c7ybN2+qd+/emjZtmqKjoxUeHq5vvvlGOXLkkPS/e5oTc/bs2URnQZDuTBn7xhtv6LfffpODg4OaN2+uL774Ql5eXql6jAAAAAAAAHjMxpSKiopS5cqVNWzYsCTr9OzZU7/99ptmzpyplStX6tSpU3r++eet61u1aqXTp0/bLOHh4apWrVqSCSlJatu2rXbt2qUlS5Zo/vz5WrVqlbp165aqxwcAAAAAAIA7HqueUvHiZ4S7t6fUlStX5O/vr6lTp6pFixaSpD179qhIkSJau3atnn322QT7On/+vHLlyqUJEyaoXbt2iT7fv//+q6JFi9rMGLFo0SLVr19fJ06cUFBQUOofJAAAAAAAQCb2RI0ptWnTJt26dUu1a9e2loWFhSlv3rxJJqV+/PFHeXh4WJNYiVm7dq38/PxspjCtXbu2HBwctH79ejVr1izR7aKjoxUdHW19HBcXp0uXLilbtmyyWCwPc4gAAOAJYYzRtWvXFBQUJAeHx6rz+WMnLi5Op06dkre3N20kAAAygeS2k56opNSZM2fk4uIiPz8/m/IcOXLozJkziW4zYcIEvfjii3J3d7/vfu+9tc/JyUlZs2ZNcr+SNHToUA0aNCj5BwAAADKc48ePK3fu3PYO47F26tQp5cmTx95hAACAdPagdpLdklJTpkzRyy+/bH28cOFCValSJVWfY+3atfr333/1008/pep+4/Xt21e9evWyPr5y5Yry5s2r48ePy8fHJ02eEwAAPB6uXr2qPHnyyNvb296hPPbiXyPaSAAAZA7JbSfZLSnVuHFjlS9f3vo4V65cD9wmMDBQMTExioiIsOktdfbsWQUGBiao/91336l06dIqW7bsA/d77tw5m7Lbt2/r0qVLie43nqurq1xdXROU+/j40OACACCT4Ha0B4t/jWgjAQCQuTyonWS3ARC8vb1VoEAB63K/2+vilS1bVs7Ozlq6dKm1bO/evTp27JgqVKhgUzcyMlIzZsxQly5dHrjfChUqKCIiQps2bbKWLVu2THFxcTaJMwAAAAAAAKSOx2pMqUuXLunYsWM6deqUpDsJJ+lOT6bAwED5+vqqS5cu6tWrl7JmzSofHx+98cYbqlChQoJBzqdPn67bt2/rpZdeSvA8GzZsUPv27bV06VLlypVLRYoUUd26ddW1a1eNHTtWt27dUvfu3dW6dWtm3gMAAAAAAEgDj9VUMfPmzVOZMmXUoEEDSVLr1q1VpkwZjR071lpn5MiRatiwoZo3b66qVasqMDBQs2fPTrCvCRMm6Pnnn08wKLokXb9+XXv37tWtW7esZVOmTFFYWJhq1aql+vXrq3Llyho/fnzqHyQAAAAAAABkMcYYeweRUVy9elW+vr66cuUK4yUAQCYUGxtr84MHnnwuLi5JTmPM537y8VoBAJC5JPez/7G6fQ8AgCeRMUZnzpxRRESEvUNBKnNwcFBoaKhcXFzsHQoAAECGQ1IKAIBHFJ+QCggIkIeHB7OxZRBxcXE6deqUTp8+rbx583JeAQAAUhlJKQAAHkFsbKw1IZUtWzZ7h4NU5u/vr1OnTun27dtydna2dzgAAAAZymM10DkAAE+a+DGkPDw87BwJ0kL8bXuxsbF2jgQAACDjISkFAEAq4NaujInzCgAAkHZISgEAAAAAACDdkZQCAACpYtKkSfLz87N3GCnyJMYMAACQUZCUAgAgk+rYsaMsFkuCpW7dug/cNiQkRKNGjbIpa9Wqlfbt25dG0f4PiSQAAICMgdn3AADIxOrWrauJEyfalLm6uj7Uvtzd3eXu7p4aYQEAACAToKcUAACZmKurqwIDA22WLFmyyBijgQMHKm/evHJ1dVVQUJDefPNNSVL16tV19OhR9ezZ09q7SkrYg2ngwIEqXbq0vv/+e+XNm1deXl567bXXFBsbq+HDhyswMFABAQH66KOPbGL6/PPPVaJECXl6eipPnjx67bXXFBkZKUlasWKFOnXqpCtXrlife+DAgZKk6Oho9enTR7ly5ZKnp6fKly+vFStW2Ox70qRJyps3rzw8PNSsWTNdvHgxbV5YAAAAPBA9pQAASGXGGN24FWuX53Z3dkyVGeN++eUXjRw5UtOmTVOxYsV05swZbdu2TZI0e/ZslSpVSt26dVPXrl3vu5+DBw9q4cKFWrRokQ4ePKgWLVro0KFDKlSokFauXKk1a9aoc+fOql27tsqXLy9JcnBw0JdffqnQ0FAdOnRIr732mt555x198803qlixokaNGqX+/ftr7969kiQvLy9JUvfu3bV7925NmzZNQUFB+vXXX1W3bl3t2LFDBQsW1Pr169WlSxcNHTpUTZs21aJFizRgwIBHfq0AAADwcEhKAQCQym7cilXR/n/Y5bl3Dw6Xh0vyP97nz59vTerE69evn9zc3BQYGKjatWvL2dlZefPm1TPPPCNJypo1qxwdHeXt7a3AwMD77j8uLk7ff/+9vL29VbRoUdWoUUN79+7VggUL5ODgoMKFC2vYsGFavny5NSnVo0cP6/YhISH68MMP9corr+ibb76Ri4uLfH19ZbFYbJ772LFjmjhxoo4dO6agoCBJUp8+fbRo0SJNnDhRH3/8sb744gvVrVtX77zzjiSpUKFCWrNmjRYtWpTs1+txN3ToUM2ePVt79uyRu7u7KlasqGHDhqlw4cL33W7mzJn64IMPdOTIERUsWFDDhg1T/fr1reuNMRowYIC+/fZbRUREqFKlShozZowKFiyY1ocEAAAyMG7fAwAgE6tRo4a2bt1qs7zyyitq2bKlbty4oXz58qlr16769ddfdfv27RTvPyQkRN7e3tbHOXLkUNGiReXg4GBTdu7cOevjP//8U7Vq1VKuXLnk7e2tdu3a6eLFi7p+/XqSz7Njxw7FxsaqUKFC8vLysi4rV67UwYMHJUn//vuvNfEVr0KFCik+psfZypUr9frrr2vdunVasmSJbt26peeee05RUVFJbrNmzRq1adNGXbp00ZYtW9S0aVM1bdpUO3futNYZPny4vvzyS40dO1br16+Xp6enwsPDdfPmzfQ4LAAAkEHRUwoAgFTm7uyo3YPD7fbcKeHp6akCBQokKM+aNav27t2rP//8U0uWLNFrr72mTz/9VCtXrpSzs3Oy939vXYvFkmhZXFycJOnIkSNq2LChXn31VX300UfKmjWrVq9erS5duigmJkYeHh6JPk9kZKQcHR21adMmOTravgb39gTLyO7t9TVp0iQFBARo06ZNqlq1aqLbxPcge/vttyVJQ4YM0ZIlSzR69GiNHTtWxhiNGjVK77//vpo0aSJJ+vHHH5UjRw7NmTNHrVu3TtuDAgAAGRZJKQAAUpnFYknRLXSPK3d3dzVq1EiNGjXS66+/rrCwMO3YsUNPPfWUXFxcFBub+uNmbdq0SXFxcRoxYoS1N9WMGTNs6iT23GXKlFFsbKzOnTunKlWqJLrvIkWKaP369TZl69atS8XoHz9XrlyRdCfJmJS1a9eqV69eNmXh4eGaM2eOJOnw4cM6c+aMateubV3v6+ur8uXLa+3atYkmpaKjoxUdHW19fPXq1Uc5DAAAkEE9+S1mAADw0KKjo3XmzBmbMicnJ82fP1+xsbEqX768PDw8NHnyZLm7uys4OFjSndvyVq1apdatW8vV1VXZs2dPlXgKFCigW7du6auvvlKjRo30999/a+zYsTZ1QkJCFBkZqaVLl6pUqVLy8PBQoUKF1LZtW7Vv314jRoxQmTJldP78eS1dulQlS5ZUgwYN9Oabb6pSpUr67LPP1KRJE/3xxx8Zajype8XFxalHjx6qVKmSihcvnmS9M2fOKEeOHDZlOXLksL4v4v+9X517DR06VIMGDXqU8AEAQCbAmFIAAGRiixYtUs6cOW2WypUry8/PT99++60qVaqkkiVL6s8//9Rvv/2mbNmySZIGDx6sI0eOKH/+/PL390+1eEqVKqXPP/9cw4YNU/HixTVlyhQNHTrUpk7FihX1yiuvqFWrVvL399fw4cMlSRMnTlT79u3Vu3dvFS5cWE2bNtU///yjvHnzSpKeffZZffvtt/riiy9UqlQpLV68WO+//36qxf64ef3117Vz505NmzYt3Z+7b9++unLlinU5fvx4uscAAAAefxZjjLF3EBnF1atX5evrqytXrsjHx8fe4QAA0sHNmzd1+PBhhYaGys3Nzd7hIJXd7/w+zp/73bt319y5c7Vq1SqFhobet27evHnVq1cvm1kPBwwYoDlz5mjbtm06dOiQ8ufPry1btqh06dLWOtWqVVPp0qX1xRdfPDCe9HitQt79PU32K0lHPmmQZvsGACAjSu5nPz2lAAAAMghjjLp3765ff/1Vy5Yte2BCSrozA+HSpUttypYsWWKdmTA0NFSBgYE2da5evar169dnuNkLAQBA+mJMKQAAgAzi9ddf19SpUzV37lx5e3tbx3zy9fWVu7u7JKl9+/bKlSuX9bbIt956S9WqVdOIESPUoEEDTZs2TRs3btT48eMl3Rm4v0ePHvrwww9VsGBBhYaG6oMPPlBQUJCaNm1ql+PMzNKyR5hErzAAQPoiKQUAAJBBjBkzRpJUvXp1m/KJEyeqY8eOkqRjx45ZZzaU7ozRNXXqVL3//vvq16+fChYsqDlz5tgMjv7OO+8oKipK3bp1U0REhCpXrqxFixZl+ltWuWUQAIBHQ1IKAAAgg0jOUKErVqxIUNayZUu1bNkyyW0sFosGDx6swYMHP0p4AAAANhhTCgAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDvGlAIAAABwXwzqDgBICySlAAAAADx20jIRJpEMA4DHAbfvAQAAAAAAIN2RlAIAIJPq2LGjLBZLgqVu3brp8vwDBw5U6dKl0+W5AAAA8Pjh9j0AADKxunXrauLEiTZlrq6udooGAAAAmQk9pQAAyMRcXV0VGBhos2TJkkUrVqyQi4uL/vrrL2vd4cOHKyAgQGfPnpUkLVq0SJUrV5afn5+yZcumhg0b6uDBgzb7P3HihNq0aaOsWbPK09NT5cqV0/r16zVp0iQNGjRI27Zts/bQmjRpUnoeOgAAAOyMnlIAAKSVqKik1zk6Sm5uyavr4CC5uz+4rqdnyuK7j+rVq6tHjx5q166dtm3bpkOHDumDDz7QzJkzlSNHjv8PI0q9evVSyZIlFRkZqf79+6tZs2baunWrHBwcFBkZqWrVqilXrlyaN2+eAgMDtXnzZsXFxalVq1bauXOnFi1apD///FOS5Ovrm2rxAwAA4PFHUgoAgLTi5ZX0uvr1pd/vmlkqIEC6fj3xutWqSStW/O9xSIh04ULCesakOMT58+fL6544+/Xrp379+unDDz/UkiVL1K1bN+3cuVMdOnRQ48aNrfWaN29us933338vf39/7d69W8WLF9fUqVN1/vx5/fPPP8qaNaskqUCBAtb6Xl5ecnJyUmBgYIrjBgAAwJOPpBQAAJlYjRo1NGbMGJuy+ASSi4uLpkyZopIlSyo4OFgjR460qbd//371799f69ev14ULFxQXFydJOnbsmIoXL66tW7eqTJky1v0BAAAAdyMpBQBAWomMTHqdo6Pt43Pnkq7rcM8QkEeOPHRI9/L09LTpvXSvNWvWSJIuXbqkS5cuyfOuWwQbNWqk4OBgffvttwoKClJcXJyKFy+umJgYSZL73bccAgAAAPdgoHMAANKKp2fSy93jST2o7r3JnaTqpbKDBw+qZ8+e+vbbb1W+fHl16NDB2hvq4sWL2rt3r95//33VqlVLRYoU0eXLl222L1mypLZu3apLly4lun8XFxfFxsametwAAAB4MpCUAgAgE4uOjtaZM2dslgsXLig2NlYvvfSSwsPD1alTJ02cOFHbt2/XiBEjJElZsmRRtmzZNH78eB04cEDLli1Tr169bPbdpk0bBQYGqmnTpvr777916NAh/fLLL1q7dq0kKSQkRIcPH9bWrVt14cIFRUdHp/vxAwAAwH5ISgEAkIktWrRIOXPmtFkqV66sjz76SEePHtW4ceMkSTlz5tT48eP1/vvva9u2bXJwcNC0adO0adMmFS9eXD179tSnn35qs28XFxctXrxYAQEBql+/vkqUKKFPPvlEjv9/62Lz5s1Vt25d1ahRQ/7+/vr555/T/fgBAABgP4wpBQBAJjVp0iRNmjQpyfX9+/e3efz888/b9GaqXbu2du/ebVPH3DMDYHBwsGbNmpXo/l1dXZNcBwAAgIyPnlIAAAAAAABIdySlAAAAAAAAkO5ISgEAAAAAACDdkZQCAAAAAABAuiMpBQAAAAAAgHRHUgoAgFQQFxdn7xCQBu6dTRAAAACpx8neAQAA8CRzcXGRg4ODTp06JX9/f7m4uMhisdg7LKQCY4zOnz8vi8UiZ2dne4cDAACQ4ZCUAgDgETg4OCg0NFSnT5/WqVOn7B0OUpnFYlHu3Lnl6Oho71AAAAAyHJJSAAA8IhcXF+XNm1e3b99WbGysvcNBKnJ2diYhBQAAkEZISgEAkArib/HiNi8AAAAgeRjoHAAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDuSUgAAAAAAAEh3JKUAAAAAAACQ7khKAQAAAAAAIN2RlAIAAAAAAEC6IykFAAAAAACAdEdSCgAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDuSUgAAAAAAAEh3JKUAAAAAAACQ7khKAQAAAAAAIN2RlAIAAAAAAEC6IykFAAAAAACAdEdSCgAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDuSUgAAAAAAAEh3JKUAAAAAAACQ7khKAQAAAAAAIN2RlAIAAMggVq1apUaNGikoKEgWi0Vz5sy5b/2OHTvKYrEkWIoVK2atM3DgwATrw8LC0vhIAABAZkBSCgAAIIOIiopSqVKl9PXXXyer/hdffKHTp09bl+PHjytr1qxq2bKlTb1ixYrZ1Fu9enVahA8AADIZJ3sHAAAAgNRRr1491atXL9n1fX195evra308Z84cXb58WZ06dbKp5+TkpMDAwFSLEwAAQKKnFAAAAP7fhAkTVLt2bQUHB9uU79+/X0FBQcqXL5/atm2rY8eO2SlCAACQkdBTCgAAADp16pQWLlyoqVOn2pSXL19ekyZNUuHChXX69GkNGjRIVapU0c6dO+Xt7Z3ovqKjoxUdHW19fPXq1TSNHQAAPJlISgEAAEA//PCD/Pz81LRpU5vyu28HLFmypMqXL6/g4GDNmDFDXbp0SXRfQ4cO1aBBg9IyXAAAkAFw+x4AAEAmZ4zR999/r3bt2snFxeW+df38/FSoUCEdOHAgyTp9+/bVlStXrMvx48dTO2QAAJABkJQCAADI5FauXKkDBw4k2fPpbpGRkTp48KBy5syZZB1XV1f5+PjYLAAAAPciKQUAAJBBREZGauvWrdq6dask6fDhw9q6dat1YPK+ffuqffv2CbabMGGCypcvr+LFiydY16dPH61cuVJHjhzRmjVr1KxZMzk6OqpNmzZpeiwAACDjY0wpAACADGLjxo2qUaOG9XGvXr0kSR06dNCkSZN0+vTpBDPnXblyRb/88ou++OKLRPd54sQJtWnTRhcvXpS/v78qV66sdevWyd/fP+0OBAAAZAokpQAAADKI6tWryxiT5PpJkyYlKPP19dX169eT3GbatGmpERoAAEAC3L4HAAAAAACAdEdSCgAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDuSUgAAAAAAAEh3JKUAAAAAAACQ7khKAQAAAAAAIN2RlAIAAAAAAEC6IykFAAAAAACAdEdSCgAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDuSUgAAAAAAAEh3JKUAAAAAAACQ7khKAQAAAAAAIN2RlAIAAAAAAEC6IykFAAAAAACAdEdSCgAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDuSUgAAAAAAAEh3JKUAAAAAAACQ7khKAQAAAAAAIN2RlAIAAAAAAEC6IykFAAAAAACAdEdSCgAAAAAAAOmOpBQAAAAAAADSHUkpAAAAAAAApDuSUgAAAAAAAEh3JKUAAAAAAACQ7khKAQAAAAAAIN2RlAIAAAAAAEC6IykFAAAAAACAdEdSCgAAAAAAAOmOpNQT4syVm1pz8IK9wwAAAAAAAEgVJKWeANuOR6jmiBV6Y+oWXbl+y97hAAAAAAAAPDKSUk+AokE+CvJz18WoGI38c5+9wwEAAAAAAHhkJKWeAM6ODhrUuJgk6ce1R/Tv6at2jggAAAAAAODRkJR6QlQqkF31SwQqzkgD5u6SMcbeIQEAAAAAADw0klJPkPcaFJWbs4M2HLmkedtO2TscAAAAAACAh0ZS6gmSy89d3WsUkCR9vOBfRUbftnNEAAAAAAAAD4ek1BPmP1XyKTibh85ejdZXy/bbOxwAAAAAAICHQlLqCePm7Kj+DYtKkr5ffVgHzkXaOSIAAAAAAICUIyn1BKpVJIdqhgXoVqzRoN8Y9BwAAAAAADx5SEo9ofo3LCoXRwf9tf+CFu8+a+9wAAAAAAAAUoSk1BMqJLunulXNJ0ka/Ntu3bwVa+eIAAAAAAAAko+k1BPstRr5FeTrppMRNzRmxUF7hwMAAAAAAJBsJKWeYB4uTnqvwZ1Bz8esPKjjl67bOSIAAAAAAIDkISn1hKtfIlAV82dTzO04DZm/297hAAAAAAAAJAtJqSecxWLRoMbF5ORg0eLdZ7Vi7zl7hwQAAOxk1apVatSokYKCgmSxWDRnzpz71l+xYoUsFkuC5cyZMzb1vv76a4WEhMjNzU3ly5fXhg0b0vAoAABAZkFSKgMomMNbHSuGSJIG/bZb0bcZ9BwAgMwoKipKpUqV0tdff52i7fbu3avTp09bl4CAAOu66dOnq1evXhowYIA2b96sUqVKKTw8XOfO8UMYAAB4NCSlMoi3ahdUdi9XHb4Qpe9XH7F3OAAAwA7q1aunDz/8UM2aNUvRdgEBAQoMDLQuDg7/ayJ+/vnn6tq1qzp16qSiRYtq7Nix8vDw0Pfff5/a4QMAgEyGpFQG4e3mrL71wiRJXy3brzNXbto5IgAA8KQoXbq0cubMqTp16ujvv/+2lsfExGjTpk2qXbu2tczBwUG1a9fW2rVr7REqAADIQEhKZSDNyuRS2eAsuh4Tq48X/GvvcAAAwGMuZ86cGjt2rH755Rf98ssvypMnj6pXr67NmzdLki5cuKDY2FjlyJHDZrscOXIkGHfqbtHR0bp69arNAgAAcC+SUhmIg8OdQc8tFmnetlNad+iivUMCAACPscKFC+vll19W2bJlVbFiRX3//feqWLGiRo4c+Uj7HTp0qHx9fa1Lnjx5UiliAACQkZCUymCK5/LVi8/klSQNmLtLt2Pj7BwRAAB4kjzzzDM6cOCAJCl79uxydHTU2bNnbeqcPXtWgYGBSe6jb9++unLlinU5fvx4msYMAACeTCSlMqA+zxWWn4ez9p69pp/WHbV3OAAA4AmydetW5cyZU5Lk4uKismXLaunSpdb1cXFxWrp0qSpUqJDkPlxdXeXj42OzAAAA3MvJ3gEg9WXxdNHb4YX13q879fmSfWpUKkjZvVztHRYAAEhjkZGR1l5OknT48GFt3bpVWbNmVd68edW3b1+dPHlSP/74oyRp1KhRCg0NVbFixXTz5k199913WrZsmRYvXmzdR69evdShQweVK1dOzzzzjEaNGqWoqCh16tQp3Y8PAABkLCSlMqjWT+fVzxuOaefJqxq+aI+Gtyhl75AAAEAa27hxo2rUqGF93KtXL0lShw4dNGnSJJ0+fVrHjh2zro+JiVHv3r118uRJeXh4qGTJkvrzzz9t9tGqVSudP39e/fv315kzZ1S6dGktWrQoweDnAAAAKUVSKoNydLBoUOPiaj5mjWZsPKE2z+RVmbxZ7B0WAABIQ9WrV5cxJsn1kyZNsnn8zjvv6J133nngfrt3767u3bs/angAAAA2GFMqAysbnEXNn8otSeo/d5di45JupAIAAAAAAKQnklIZ3H/rFZa3q5N2nLyiGRuZ+QYAAAAAADweSEplcAHebupRp5AkafiiPYq4HmPniAAAAAAAAEhKZQrtKwSrUA4vXb5+S58v2WfvcAAAAAAAAEhKZQbOjg4a2LiYJGnyuqPadeqKnSMCAAAAAACZHUmpTKJi/uxqUDKn4ow0cN6u+87MAwAAAAAAkNZISmUi79UvIndnR/1z5LLmbj1l73AAAAAAAEAmRlIqEwnyc1f3mgUkSR8t+FfXbt6yc0QAAAAAACCzIimVyfynSqhCsnno/LVofbXsgL3DAQAAAAAAmRRJqUzG1clRAxrdGfT8+9WHdeDcNTtHBAAAAAAAMiOSUplQjbAA1S4SoNtxRgPn7WbQcwAAAAAAkO5ISmVSHzQsKhcnB60+cEF/7Dpj73AAAAAAAEAmQ1IqkwrO5qlXquaTJA2Z/69uxMTaOSIAAAAAAJCZkJTKxF6tXkC5/Nx1MuKGxqxg0HMAAAAAAJB+SEplYu4ujnq/QRFJ0thVh3T0YpSdIwIAAAAAAJnFY5WUmj17tp577jlly5ZNFotFW7duTVDn5s2bev3115UtWzZ5eXmpefPmOnv2rE2df/75R7Vq1ZKfn5+yZMmi8PBwbdu27b7PnZz9ZkR1iweqcoHsirkdpyHzd9s7HAAAAAAAkEk8VkmpqKgoVa5cWcOGDUuyTs+ePfXbb79p5syZWrlypU6dOqXnn3/euj4yMlJ169ZV3rx5tX79eq1evVre3t4KDw/XrVu3Hnq/GZXFYtHAxkXl5GDRn/+e0/I95+wdEgAAAAAAyASc7B3A3dq1aydJOnLkSKLrr1y5ogkTJmjq1KmqWbOmJGnixIkqUqSI1q1bp2effVZ79uzRpUuXNHjwYOXJk0eSNGDAAJUsWVJHjx5VgQIFHmq/GVmBAG91rhyq8asOadBvu1SxQDa5OjnaOywAAAAAAJCBPVY9pR5k06ZNunXrlmrXrm0tCwsLU968ebV27VpJUuHChZUtWzZNmDBBMTExunHjhiZMmKAiRYooJCTkofebmOjoaF29etVmeVK9UbOAArxddeTidX3312F7hwMAAAAAADK4JyopdebMGbm4uMjPz8+mPEeOHDpz5owkydvbWytWrNDkyZPl7u4uLy8vLVq0SAsXLpSTU+Idw5Kz38QMHTpUvr6+1iW+Z9aTyNvNWX3rh0mSRi87oFMRN+wcEQAAAAAAyMjslpSaMmWKvLy8rMtff/2VKvu9ceOGunTpokqVKmndunX6+++/Vbx4cTVo0EA3bqRuoqVv3766cuWKdTl+/Hiq7j+9NS2dS0+HZNGNW7H6eMG/9g4HAAAAAABkYHYbU6px48YqX7689XGuXLkeuE1gYKBiYmIUERFh06vp7NmzCgwMlCRNnTpVR44c0dq1a+Xg4GAty5Ili+bOnavWrVs/1H4T4+rqKldX1wfG/aS4M+h5MTX6arXmbz+tF8tfUMX82e0dFgAAAAAAyIDs1lPK29tbBQoUsC7u7u4P3KZs2bJydnbW0qVLrWV79+7VsWPHVKFCBUnS9evX5eDgIIvFYq0T/zguLu6h95tZFAvy1UvPBkuSBs7bpVuxib9mAAAAAAAAj+KxGlPq0qVL2rp1q3bv3i3pTmJo69at1nGdfH191aVLF/Xq1UvLly/Xpk2b1KlTJ1WoUME6Q16dOnV0+fJlvf766/r333+1a9cuderUSU5OTqpRo4Yk6eTJkwoLC9OGDRuSvd/MpFedQsri4ax9ZyP149qj9g4HAAAAAABkQI9VUmrevHkqU6aMGjRoIElq3bq1ypQpo7Fjx1rrjBw5Ug0bNlTz5s1VtWpVBQYGavbs2db1YWFh+u2337R9+3ZVqFBBVapU0alTp7Ro0SLlzJlTknTr1i3t3btX169fT/Z+MxM/Dxe9U/fOoOejluzT+WvRdo4IAAAAAABkNHYbUyoxHTt2VMeOHe9bx83NTV9//bW+/vrrJOvUqVNHderUSXJ9SEiIjDEp3m9m8kK5PPp5wzFtP3FFwxbt0WctS9k7JAAAAAAAkIE8Vj2l8PhwdLBoUONikqRZm05o09HLdo4IAAAAAABkJCSlkKQyebPohXK5JUkD5u1UbJx5wBYAAAAAAADJQ1IK9/VO3TB5uzlp58mrmvbPMXuHAwAAAAAAMgiSUriv7F6u6lWnkCTp0z/26nJUjJ0jAgAAAAAAGQFJKTxQu2eDVTiHtyKu39KIJXvtHQ4AAAAAAMgASErhgZwcHTSoyZ1Bz6esP6adJ6/YOSIAAAAAAPCkIymFZHk2XzY1LhUkY6T+c3cqjkHPAQAAAADAIyAphWTrV7+IPFwctflYhH7dctLe4QAAAAAAgCcYSSkkW6Cvm96oWVCSNHThHl27ecvOEQEAAAAAgCcVSSmkSOfKIcqX3VMXIqP1xZ/77R0OAAAAAAB4QpGUQoq4OjlqQOM7g55PXHNE+85es3NEAAAAAADgSURSCilWrZC/6hTNodg4o4HzdskYBj0HAAAAAAApQ1IKD6V/w6JycXLQmoMXtXDnGXuHAwAAAAAAnjAkpfBQ8mT10KvV8kuSPpy/W9djbts5IgAAAAAA8CQhKYWH9mr1/MqdxV2nrtzUN8sP2jscAAAAAADwBCEphYfm5uyoDxoWlSSNX3VIRy5E2TkiAAAAAADwpCAphUfyXNEcqlIwu2Ji4zR4/m57hwMAAAAAAJ4QJKXwSCwWiwY2LiZnR4uW7Tmnpf+etXdIAAAAAADgCUBSCo8sv7+XOlcOlSQNnr9bN2/F2jkiAAAAAADwuCMphVTxRs2CyuHjqqMXr+u7vw7ZOxwAAAAAAPCYIymFVOHl6qR+9YtIkkYvP6CTETfsHBEAAAAAAHickZRCqmlcKkjPhGTVzVtx+vj3f+0dDgAAAAAAeIyRlEKqsVgsGtSkmBws0u87TuvvAxfsHRIAAAAAAHhMkZRCqiqS00ftK4RIkgbM26VbsXH2DQgAAAAAADyWSEoh1fWsU0jZPF104FykflhzxN7hAACQaaxatUqNGjVSUFCQLBaL5syZc9/6s2fPVp06deTv7y8fHx9VqFBBf/zxh02dgQMHymKx2CxhYWFpeBQAACCzICmFVOfr7qx36haWJI36c7/OXb1p54gAAHh8dejQQatWrUqVfUVFRalUqVL6+uuvk1V/1apVqlOnjhYsWKBNmzapRo0aatSokbZs2WJTr1ixYjp9+rR1Wb16darECwAAMjcneweAjKll2Tyauv6Ytp24ok8W7dHnL5S2d0gAADyWrly5otq1ays4OFidOnVShw4dlCtXrofaV7169VSvXr1k1x81apTN448//lhz587Vb7/9pjJlyljLnZycFBgY+FAxAQAAJIWeUkgTDg4WDW5SXBaLNHvzSW08csneIQEA8FiaM2eOTp48qVdffVXTp09XSEiI6tWrp1mzZunWrVvpGktcXJyuXbumrFmz2pTv379fQUFBypcvn9q2batjx47ddz/R0dG6evWqzQIAAHAvklJIM6Xy+KlVuTySpP5zdyk2ztg5IgAAHk/+/v7q1auXtm3bpvXr16tAgQJq166dgoKC1LNnT+3fvz9d4vjss88UGRmpF154wVpWvnx5TZo0SYsWLdKYMWN0+PBhValSRdeuXUtyP0OHDpWvr691yZMnT3qEDwAAnjAkpZCm3g4vLB83J+0+fVVTN9z/V1UAADK706dPa8mSJVqyZIkcHR1Vv3597dixQ0WLFtXIkSPT9LmnTp2qQYMGacaMGQoICLCW16tXTy1btlTJkiUVHh6uBQsWKCIiQjNmzEhyX3379tWVK1esy/Hjx9M0dgAA8GQiKYU0lc3LVb2fuzPo+Wd/7NWlqBg7RwQAwOPl1q1b+uWXX9SwYUMFBwdr5syZ6tGjh06dOqUffvhBf/75p2bMmKHBgwenWQzTpk3Tf/7zH82YMUO1a9e+b10/Pz8VKlRIBw4cSLKOq6urfHx8bBYAAIB7kZRCmmtbPq/CAr115cYtfbZ4r73DAQDgsZIzZ0517dpVwcHB2rBhgzZu3KhXXnnFJpFTo0YN+fn5pcnz//zzz+rUqZN+/vlnNWjQ4IH1IyMjdfDgQeXMmTNN4gEAAJkHSSmkOSdHBw1uUlyS9POGY9px4oqdIwIA4PExcuRInTp1Sl9//bVKly6daB0/Pz8dPnz4gfuKjIzU1q1btXXrVknS4cOHtXXrVuvA5H379lX79u2t9adOnar27dtrxIgRKl++vM6cOaMzZ87oypX/fVb36dNHK1eu1JEjR7RmzRo1a9ZMjo6OatOmzcMfNAAAgEhKIZ08E5pVTUsHyRip/7ydimPQcwAAJEmNGzfW9evXE5RfunQpxbPWbdy4UWXKlFGZMmUkSb169VKZMmXUv39/SXfGrLp75rzx48fr9u3bev3115UzZ07r8tZbb1nrnDhxQm3atFHhwoX1wgsvKFu2bFq3bp38/f0f5nABAACsnOwdADKPvvWLaMnus9pyLEK/bD6hluWYiQcAgNatW6tRo0Z67bXXbMpnzJihefPmacGCBcneV/Xq1WVM0j/8TJo0yebxihUrHrjPadOmJfv5AQAAUoKeUkg3OXzc9GatgpKkYYv26OrNW3aOCAAA+1u/fr1q1KiRoLx69epav369HSICAABIHySlkK46VQpVPn9PXYiM0agl++0dDgAAdhcdHa3bt28nKL9165Zu3Lhhh4gAAADSB0kppCsXJwcNbFRMkvTD2iPae+aanSMCAMC+nnnmGY0fPz5B+dixY1W2bFk7RAQAAJA+UjSmVFxcnFauXKm//vpLR48e1fXr1+Xv768yZcqodu3aypOHMYLwYFUL+atusUAt2nVGA+bt1M9dn5XFYrF3WAAA2MWHH36o2rVra9u2bapVq5YkaenSpfrnn3+0ePFiO0cHAACQdpLVU+rGjRv68MMPlSdPHtWvX18LFy5URESEHB0ddeDAAQ0YMEChoaGqX7++1q1bl9YxIwN4r0ERuTo5aN2hS5q//bS9wwEAwG4qVaqktWvXKk+ePJoxY4Z+++03FShQQNu3b1eVKlXsHR4AAECaSVZPqUKFCqlChQr69ttvVadOHTk7Oyeoc/ToUU2dOlWtW7fWe++9p65du6Z6sMg48mT10GvVC2jkn/v08YJ/VTMsQJ6uTAYJAMicSpcurSlTptg7DAAAgHSVrCzA4sWLVaRIkfvWCQ4OVt++fdWnTx8dO3YsVYJDxvZytXyatfm4jl+6oa+XH9A7dcPsHRIAAHYRFxenAwcO6Ny5c4qLi7NZV7VqVTtFBQAAkLaSlZR6UELqbs7OzsqfP/9DB4TMw83ZUf0bFlPXHzfq278OqUXZ3Mrn72XvsAAASFfr1q3Tiy++qKNHj8oYY7POYrEoNjbWTpEBAACkrYe+X+r69es6duyYYmJibMpLliz5yEEh86hdJEDVC/trxd7zGjx/tyZ2fJpBzwEAmcorr7yicuXK6ffff1fOnDn5HAQAAJlGipNS58+fV6dOnbRw4cJE1/NrHlLCYrGof8Oi+vvAKq3Ye15L/z2n2kVz2DssAADSzf79+zVr1iwVKFDA3qEAAACkq2TNvne3Hj16KCIiQuvXr5e7u7sWLVqkH374QQULFtS8efPSIkZkcPn8vfSfKvkkSYPm79LNWyQ2AQCZR/ny5XXgwAF7hwEAAJDuUtxTatmyZZo7d67KlSsnBwcHBQcHq06dOvLx8dHQoUPVoEGDtIgTGVz3GgX06+aTOn7phsavOqQ3axW0d0gAAKSLN954Q71799aZM2dUokSJBLMcMzQCAADIqFKclIqKilJAQIAkKUuWLDp//rwKFSqkEiVKaPPmzakeIDIHT1cnvdegiN74eYu+Xn5AzcrkUp6sHvYOCwCANNe8eXNJUufOna1lFotFxhgGOgcAABlaipNShQsX1t69exUSEqJSpUpp3LhxCgkJ0dixY5UzZ860iBGZRMOSOTVl/VGtO3RJH/3+r8a2K2vvkAAASHOHDx+2dwgAAAB2keKk1FtvvaXTp09LkgYMGKC6detqypQpcnFx0aRJk1I7PmQiFotFAxsXU4MvV2vRrjP6a/95VSnob++wAABIU8HBwfYOAQAAwC5SnJR66aWXrP8vW7asjh49qj179ihv3rzKnj17qgaHzCcs0EftKwRr4t9HNHDeLi18q6pcnFI8Hj8AAE+c3bt369ixY4qJibEpb9y4sZ0iAgAASFspTkrdy8PDQ0899VRqxAJIknrULqTftp3SwfNRmrTmsLpVzW/vkAAASDOHDh1Ss2bNtGPHDutYUtKdHsSSGFMKAABkWMlOSvXq1StZ9T7//POHDgaQJF93Z/23bpjenrVdX/y5X01K51IOHzd7hwUAQJp46623FBoaqqVLlyo0NFQbNmzQxYsX1bt3b3322Wf2Dg8AACDNJDsptWXLFpvHq1evVtmyZeXu7m4ti/9FD3hUzZ/KrakbjmnLsQh9snCPRrYqbe+QAABIE2vXrtWyZcuUPXt2OTg4yMHBQZUrV9bQoUP15ptvJmiDAQAAZBTJTkotX77c5rG3t7emTp2qfPnypXpQgIODRYMaF1OTr//Wr1tOqs0zefVMaFZ7hwUAQKqLjY2Vt7e3JCl79uw6deqUChcurODgYO3du9fO0QEAAKQdRpDGY6tkbj+1fjqvJKn/3J26HRtn54gAAEh9xYsX17Zt2yRJ5cuX1/Dhw/X3339r8ODB/PgHAAAyNJJSeKy9HV5Yvu7O2nPmmqZuOGbvcAAASHXvv/++4uLu/PAyePBgHT58WFWqVNGCBQv05Zdf2jk6AACAtPPIs+8BaSmrp4v6hBfWB3N26rM/9qpBiZzK5uVq77AAAEg14eHh1v8XKFBAe/bs0aVLl5QlSxbG6wQAABlaspNS27dvt3lsjNGePXsUGRlpU16yZMnUiQz4fy8+k1c/rz+m3aev6rPFezX0ed5jAICM6fjx45KkPHny2DkSAACAtJfspFTp0qVlsVhkjLGWNWzYUJKs5RaLRbGxsakfJTI1RweLBjcpphZj12raP8fV+um8KpXHz95hAQCQKm7fvq1Bgwbpyy+/tP7Y5+XlpTfeeEMDBgyQs7OznSMEAABIG8lOSh0+fDgt4wDuq1xIVj1fJpdmbzmp/vN26ddXK8rBgVsaAABPvjfeeEOzZ8/W8OHDVaFCBUnS2rVrNXDgQF28eFFjxoyxc4QAAABpI9lJqeDg4LSMA3igd+uFafHus9p2PEKzNp3QC09zawMA4Mk3depUTZs2TfXq1bOWlSxZUnny5FGbNm1ISgEAgAwrWbPvHTuWslnPTp48+VDBAPcT4OOmt2oVlCQNW7RHV27csnNEAAA8OldXV4WEhCQoDw0NlYuLS/oHBAAAkE6SlZR6+umn9fLLL+uff/5Jss6VK1f07bffqnjx4vrll19SLUDgbh0rhahAgJcuRsVo5JJ99g4HAIBH1r17dw0ZMkTR0dHWsujoaH300Ufq3r27HSMDAABIW8m6fW/37t366KOPVKdOHbm5uals2bIKCgqSm5ubLl++rN27d2vXrl166qmnNHz4cNWvXz+t40Ym5ezooIGNiumlCev149ojavV0HhXJ6WPvsAAAeGhbtmzR0qVLlTt3bpUqVUqStG3bNsXExKhWrVp6/vnnrXVnz55trzABAABSXbKSUtmyZdPnn3+ujz76SL///rtWr16to0eP6saNG8qePbvatm2r8PBwFS9ePK3jBVS5YHbVLxGoBTvOaMC8XZre7VlZLAx6DgB4Mvn5+al58+Y2ZXnyMG4iAADI+JI90Lkkubu7q0WLFmrRokVaxQMky3sNimrZnnPacPiS5m07pSalc9k7JAAAHsrEiRPtHQIAAIBdJGtMKeBxk8vPXa9XLyBJ+njBv4qKvm3niAAAAAAAQEqkqKcU8DjpWjWfZm46oWOXruurZQf0br0we4cEAECKhYaG3vc29EOHDqVjNAAAAOmHpBSeWG7OjhrQqKi6/LBRE1YfUstyuZXf38veYQEAkCI9evSweXzr1i1t2bJFixYt0ttvv22foAAAANIBSSk80WoVyaGaYQFatuecBs7bpR87P8Og5wCAJ8pbb72VaPnXX3+tjRs3pnM0AAAA6SfFY0pFRUWlRRzAQ+vfsKhcHB301/4LWrz7rL3DAQAgVdSrV0+//PKLvcMAAABIMylOSuXIkUOdO3fW6tWr0yIeIMVCsnuqa9VQSdKQ+bt181asnSMCAODRzZo1S1mzZrV3GAAAAGkmxbfvTZ48WZMmTVLNmjUVEhKizp07q3379goKCkqL+IBkeb1GAc3efFInLt/Q2JUH1aN2IXuHBABAspQpU8bm1nNjjM6cOaPz58/rm2++sWNkAAAAaSvFSammTZuqadOmOn/+vH766SdNmjRJH3zwgcLDw9W5c2c1btxYTk4MVYX05eHipPcbFNXrUzdrzIqDav5UbuXJ6mHvsAAAeKCmTZvaPHZwcJC/v7+qV6+usDBmlgUAABnXQ2eP/P391atXL/Xq1UtfffWV3n77bS1YsEDZs2fXK6+8onfffVceHiQFkH7qlwhUxfzZtObgRQ2Zv1vj25ezd0gAADzQgAED7B0CAACAXaR4TKl4Z8+e1fDhw1W0aFG9++67atGihZYuXaoRI0Zo9uzZCX71A9KaxWLRwMbF5Ohg0eLdZ7Vy33l7hwQAwAMtWLBAf/zxR4LyP/74QwsXLrRDRAAAAOkjxUmp2bNnq1GjRsqTJ4+mTp2q1157TSdPntTkyZNVo0YNtWvXTnPnztWKFSvSIFzg/grl8FbHiiGSpEHzdinmdpx9AwIA4AHeffddxcYmnKTDGKN3333XDhEBAACkjxQnpTp16qSgoCD9/fff2rp1q7p37y4/Pz+bOkFBQXrvvfdSK0YgRd6qXVDZvVx16EKUvv/7sL3DAQDgvvbv36+iRYsmKA8LC9OBAwfsEBEAAED6SHFS6vTp0xo3bpyefvrpJOu4u7szPgLsxsfNWX3r3RkY9sul+3Xmyk07RwQAQNJ8fX116NChBOUHDhyQp6enHSICAABIHylOSt2+fVtXr15NsFy7dk0xMTFpESOQYs3K5FLZ4Cy6HhOrjxf8a+9wAABIUpMmTdSjRw8dPHjQWnbgwAH17t1bjRs3tmNkAAAAaSvFSSk/Pz9lyZIlweLn5yd3d3cFBwdrwIABiotjLB/Yj4ODRYMaF5PFIs3bdkrrD120d0gAACRq+PDh8vT0VFhYmEJDQxUaGqoiRYooW7Zs+uyzz+wdHgAAQJpxSukGkyZN0nvvvaeOHTvqmWeekSRt2LBBP/zwg95//32dP39en332mVxdXdWvX79UDxhIruK5fPXiM3k1Zf0xDZi3S/PfqCwnx4eecBIAgDTh6+urNWvWaMmSJdq2bZvc3d1VsmRJVa1a1d6hAQAApKkUJ6V++OEHjRgxQi+88IK1rFGjRipRooTGjRunpUuXKm/evProo49ISsHu+jxXWL/vOK09Z65p8rqj6lgp1N4hAQCQgMVi0XPPPafnnnvO3qEAAACkmxR3G1mzZo3KlCmToLxMmTJau3atJKly5co6duzYo0cHPKIsni56O7ywJGnEkn26EBlt54gAALD15ptv6ssvv0xQPnr0aPXo0SNF+1q1apUaNWqkoKAgWSwWzZkz54HbrFixQk899ZRcXV1VoEABTZo0KUGdr7/+WiEhIXJzc1P58uW1YcOGFMUFAACQmBQnpfLkyaMJEyYkKJ8wYYLy5MkjSbp48aKyZMny6NEBqaD103lVPJePrt28rU8X7bV3OAAA2Pjll19UqVKlBOUVK1bUrFmzUrSvqKgolSpVSl9//XWy6h8+fFgNGjRQjRo1tHXrVvXo0UP/+c9/9Mcff1jrTJ8+Xb169dKAAQO0efNmlSpVSuHh4Tp37lyKYgMAALhXim/f++yzz9SyZUstXLhQTz/9tCRp48aN2rNnj7Xh9M8//6hVq1apGynwkBz/f9Dz5mPWavrG42pTPq9K5/Gzd1gAAEi682Oer69vgnIfHx9duHAhRfuqV6+e6tWrl+z6Y8eOVWhoqEaMGCFJKlKkiFavXq2RI0cqPDxckvT555+ra9eu6tSpk3Wb33//Xd9//73efffdFMUHAABwtxT3lGrcuLH27t2r+vXr69KlS7p06ZLq1aunPXv2qGHDhpKkV199VZ9//nmqBws8rLLBWdX8qdySpP5zdyouztg5IgAA7ihQoIAWLVqUoHzhwoXKly9fmj732rVrVbt2bZuy8PBw65AMMTEx2rRpk00dBwcH1a5d21onMdHR0bp69arNAgAAcK8U9ZS6deuW6tatq7Fjx2ro0KFpFROQJv5br7AW7zqj7SeuaMbG42r9TF57hwQAgHr16qXu3bvr/PnzqlmzpiRp6dKlGjFihEaNGpWmz33mzBnlyJHDpixHjhy6evWqbty4ocuXLys2NjbROnv27Elyv0OHDtWgQYPSJGYAAJBxpKinlLOzs7Zv355WsQBpKsDbTT3qFJIkDf9jr65cv2XniAAAkDp37qwRI0ZowoQJqlGjhmrUqKHJkydrzJgx6tq1q73Deyh9+/bVlStXrMvx48ftHRIAAHgMpfj2vZdeeinRgc6BJ0H7CsEqGOClS1Ex+nwJg54DAB4Pr776qk6cOKGzZ8/q6tWrOnTokNq3b5/mzxsYGKizZ8/alJ09e1Y+Pj5yd3dX9uzZ5ejomGidwMDAJPfr6uoqHx8fmwUAAOBeKR7o/Pbt2/r+++/1559/qmzZsvL09LRZz1hSeJw5OzpoUONievG79fpp3VG1ejqvigbRUAYA2Nf27du1b98+SVLhwoVVokSJdHneChUqaMGCBTZlS5YsUYUKFSRJLi4uKlu2rJYuXaqmTZtKkuLi4rR06VJ17949XWIEAAAZV4qTUjt37tRTTz0lSdbGUzyLxZI6UQFpqGKB7GpQMqd+335aA+bt1IyXK/DeBQDYxYYNG9SlSxft3r1bxtyZhMNisahYsWKaMGGCdabj5IqMjNSBAwesjw8fPqytW7cqa9asyps3r/r27auTJ0/qxx9/lCS98sorGj16tN555x117txZy5Yt04wZM/T7779b99GrVy916NBB5cqV0zPPPKNRo0YpKirKOhsfAADAw0pxUmr58uVpEQeQrt6rX0TL/j2nf45c1tytp9S0TC57hwQAyGR2796tWrVqqUiRIpo8ebKKFCliLR85cqRq1aqldevWqWjRosne58aNG1WjRg3r4169ekmSOnTooEmTJun06dM6duyYdX1oaKh+//139ezZU1988YVy586t7777TuHh4dY6rVq10vnz59W/f3+dOXNGpUuX1qJFixIMfg4AAJBSKU5KxTtw4IAOHjyoqlWryt3dXcYYepvgiRHk567uNQvo0z/26uMF/6p20Rzycn3oPwcAAFJs4MCBqlOnjn755RebNlTp0qXVpk0bPf/88xo4cKBmzJiR7H1Wr17d2uMqMZMmTUp0my1bttx3v927d+d2PQAAkOpSPND5xYsXVatWLRUqVEj169fX6dOnJUldunRR7969Uz1AIK38p0qoQrJ56Ny1aH21dL+9wwEAZDLLly9Xv379Ev1Rz2KxqF+/fvRQBwAAGVqKk1I9e/aUs7Ozjh07Jg8PD2t5q1attGjRolQNDkhLrk6OGtComCRpwurDOnAu0s4RAQAyk2vXrt33FrjAwEBdu3YtHSMCAABIXylOSi1evFjDhg1T7ty5bcoLFiyoo0ePplpgQHqoERag2kUCdDvOaOC8Xfe95QEAgNQUHBysDRs2JLl+/fr1Cg4OTseIAAAA0leKk1JRUVE2PaTiXbp0Sa6urqkSFJCePmhYVC5ODlp94IL+2HXG3uEAADKJ1q1bq1evXtq5c2eCdTt27FCfPn3UqlUrO0QGAACQPlKclKpSpYp1GmHpzpgHcXFxGj58uM1sL8CTIjibp16umk+SNGT+v7oRE2vniAAAmUHfvn2VO3dulS5dWvXq1VOvXr3Us2dP1a1bV2XKlFFQUJD69etn7zABAADSTIqnGxs+fLhq1aqljRs3KiYmRu+884527dqlS5cu6e+//06LGIE091r1Apq9+aRORtzQmJUH1atOIXuHBADI4Nzc3LR8+XKNHDlSP//8s1auXClJKlSokD788EP17NmTXugAACBDS3FPqeLFi2vfvn2qXLmymjRpoqioKD3//PPasmWL8ufPnxYxAmnO3cVR7zcoIkkau/Kgjl28bueIAACZgYuLi/773/9q69atun79uq5fv66tW7fq3XffJSEFAAAyvBT3lJIkX19fvffee6kdC2BXdYsHqnKB7Fp94IIGz9+t7zqUs3dIAAAAAABkWA+VlIqIiNCGDRt07tw5xcXF2axr3759qgQGpDeLxaKBjYuq7qi/9Oe/Z7V87znVKBxg77AAAAAAAMiQUpyU+u2339S2bVtFRkbKx8dHFovFus5isZCUwhOtQIC3OlUK0bd/Hdbg33arYv5scnVytHdYAAAAAABkOCkeU6p3797q3LmzIiMjFRERocuXL1uXS5cupUWMQLp6s1ZB+Xu76vCFKE1Yfdje4QAAAAAAkCGlOCl18uRJvfnmm/Lw8EiLeAC783ZzVr/6YZKkr5Ye0OkrN+wcEQAAAAAAGU+Kb98LDw/Xxo0blS9fvrSIB3gsNC2dS1PXH9M/Ry7ro9//1egXn7J3SACADKpXr16JllssFrm5ualAgQJq0qSJsmbNms6RAQAApK0UJ6UaNGigt99+W7t371aJEiXk7Oxss75x48apFhxgL3cGPS+mRl+t1vztp9W2/EVVyJ/N3mEBADKgLVu2aPPmzYqNjVXhwoUlSfv27ZOjo6PCwsL0zTffqHfv3lq9erWKFi1q52gBAABST4qTUl27dpUkDR48OME6i8Wi2NjYR48KeAwUC/JV2/LB+mndUQ2ct0vz36wsZ8cU3/EKAMB9xfeCmjhxonx8fCRJV65c0X/+8x9VrlxZXbt21YsvvqiePXvqjz/+sHO0AAAAqSfF37Dj4uKSXEhIIaPp/VwhZfFw1t6z1/TT2qP2DgcAkAF9+umnGjJkiDUhJUm+vr4aOHCghg8fLg8PD/Xv31+bNm2yY5QAAACpj24fwH34ebjonbp3Bj0fuWSfzl+LtnNEAICM5sqVKzp37lyC8vPnz+vq1auSJD8/P8XExKR3aAAAAGkq2Ump+vXr68qVK9bHn3zyiSIiIqyPL168yDgHyJBeKJdHJXP76lr0bQ1btMfe4QAAMpgmTZqoc+fO+vXXX3XixAmdOHFCv/76q7p06aKmTZtKkjZs2KBChQrZN1AAAIBUluyk1B9//KHo6P/1Evn444916dIl6+Pbt29r7969qRsd8BhwdLBoUONikqRZm05o87HLdo4IAJCRjBs3TrVq1VLr1q0VHBys4OBgtW7dWrVq1dLYsWMlSWFhYfruu+/sHCkAAEDqSnZSyhhz38dARlYmbxa1LJtbkjRg7i7FxvH+BwCkDi8vL3377be6ePGitmzZoi1btujixYsaP368PD09JUmlS5dW6dKl7RsoAABAKmNMKSCZ3qkbJm83J+04eUXT/zlu73AAABnE5MmTdf36dXl5ealkyZIqWbKkvLy87B0WAABAmkt2UspischisSQoAzILf29X9apzZzyPT//Yo4jrDDgLAHh0PXv2VEBAgF588UUtWLCA2YwBAECm4ZTcisYYdezYUa6urpKkmzdv6pVXXrF2K797vCkgo2r3bLCmbTiuvWevacTifRrStLi9QwIAPOFOnz6tRYsW6eeff9YLL7wgDw8PtWzZUm3btlXFihXtHR4AAECaSXZPqQ4dOiggIEC+vr7y9fXVSy+9pKCgIOvjgIAAtW/fPi1jBezOydFBg5rcGfR8yvqj2nnyygO2AADg/pycnNSwYUNNmTJF586d08iRI3XkyBHVqFFD+fPnt3d4AAAAaSbZPaUmTpyYlnEAT4xn82VTo1JB+m3bKQ2Yt0uzXqnArawAgFTh4eGh8PBwXb58WUePHtW///5r75AAAADSDAOdAw+hX/0webg4atPRy/p1y0l7hwMAeMJdv35dU6ZMUf369ZUrVy6NGjVKzZo1065du+wdGgAAQJohKQU8hJy+7nqjZkFJ0scL9ujazVt2jggA8KRq3bq1AgIC1LNnT+XLl08rVqzQgQMHNGTIEIWFhdk7PAAAgDRDUgp4SJ0rhyg0u6cuREbry6X77R0OAOAJ5ejoqBkzZuj06dMaPXq0KlSoYF23c+dOO0YGAACQtkhKAQ/J1clRAxoVlSRN/PuI9p+9ZueIAABPovjb9hwdHSVJ165d0/jx4/XMM8+oVKlSdo4OAAAg7ZCUAh5B9cIBqlM0h27HGQ38bZeMMfYOCQDwhFq1apU6dOignDlz6rPPPlPNmjW1bt06e4cFAACQZpI9+x6AxPVvWFQr953X3wcuauHOM6pfIqe9QwIAPCHOnDmjSZMmacKECbp69apeeOEFRUdHa86cOSpatKi9wwMAAEhT9JQCHlGerB56tVp+SdKH83frRkysnSMCADwJGjVqpMKFC2v79u0aNWqUTp06pa+++sreYQEAAKQbklJAKni1en7l8nPXqSs39c2KA/YOBwDwBFi4cKG6dOmiQYMGqUGDBtYxpQAAADILklJAKnBzdtQHDe/cZjFu5SEduRBl54gAAI+71atX69q1aypbtqzKly+v0aNH68KFC/YOCwAAIN2QlAJSSXixHKpSMLtiYuM0ZP5ue4cDAHjMPfvss/r22291+vRpvfzyy5o2bZqCgoIUFxenJUuW6No1ZnUFAAAZG0kpIJVYLBYNbFxMzo4WLd1zTsv2nLV3SACAJ4Cnp6c6d+6s1atXa8eOHerdu7c++eQTBQQEqHHjxvYODwAAIM2QlAJSUX5/L3WuHCpJGvTbbt28xaDnAIDkK1y4sIYPH64TJ07o559/tnc4AAAAaYqkFJDK3qhZUAHerjp68bomrD5s73AAAE8gR0dHNW3aVPPmzbN3KAAAAGmGpBSQyrxcnfRegyKSpK+W7dfJiBt2jggAAAAAgMcPSSkgDTQuFaRnQrLq5q04ffz7v/YOBwAAAACAxw5JKSANWCwWDWpSTA4W6fcdp7XmAFN8AwAAAABwN5JSQBopktNH7Z4NliQNmLdLt2Lj7BwRAAAAAACPD5JSQBrqVaewsnq6aP+5SP2w5oi9wwEAAAAA4LFBUgpIQ74ezvpv3cKSpFF/7te5azftHBEAAAAAAI8HklJAGmtZNo9K5fZVZPRtfbJwj73DAQAAAADgsUBSCkhjDg4WDW5SXBaLNHvzSW06esneIQEAAAAAYHckpYB0UCqPn14om0eS1H/uLsXGGTtHBAAAAACAfZGUAtLJO3ULy8fNSbtOXdXPG47ZOxwAAAAAAOyKpBSQTrJ5uar3c3cGPf9s8V5djoqxc0QAAAAAANgPSSkgHbUtn1dhgd6KuH5L/eft0sHzkYrjVj4AQCr7+uuvFRISIjc3N5UvX14bNmxIsm716tVlsVgSLA0aNLDW6dixY4L1devWTY9DAQAAGZiTvQMAMhMnRwcNblJcL4xbq9+2ndJv207J191ZpfP4qUxeP5XJm0Wlc/vJ18PZ3qECAJ5Q06dPV69evTR27FiVL19eo0aNUnh4uPbu3auAgIAE9WfPnq2YmP/13r148aJKlSqlli1b2tSrW7euJk6caH3s6uqadgcBAAAyBZJSQDp7JjSrPm1RUjM3ntD2kxG6cuOWVu47r5X7zlvr5Pf3VJm8We4kqvJkUaEcXnJypGMjAODBPv/8c3Xt2lWdOnWSJI0dO1a///67vv/+e7377rsJ6mfNmtXm8bRp0+Th4ZEgKeXq6qrAwMC0CxwAAGQ6JKUAO2hZLo9alsujW7Fx2nvmmrYcu6wtxyK05XiEDl+I0sHzd5ZZm05IkjxcHFUyt++dRFUeP5XO66cAbzc7HwUA4HETExOjTZs2qW/fvtYyBwcH1a5dW2vXrk3WPiZMmKDWrVvL09PTpnzFihUKCAhQlixZVLNmTX344YfKli1bqsYPAAAyF5JSgB05OzqoeC5fFc/lq3YV7pRdiorRtuMRdxJVxyO09ViErkXf1rpDl7Tu0CXrtrmzuFuTVGXy+qlokI9cnRztdCQAgMfBhQsXFBsbqxw5ctiU58iRQ3v27Hng9hs2bNDOnTs1YcIEm/K6devq+eefV2hoqA4ePKh+/fqpXr16Wrt2rRwdE372REdHKzo62vr46tWrD3lEAAAgIyMpBTxmsnq6qEZYgGqE3Rn3Iy7O6OD5yP/vSXWnR9Xes9d04vINnbh8Q79tOyVJcnF0ULFcPiqTJ4tK5/VTmTx+yp3FXRaLxZ6HAwB4gkyYMEElSpTQM888Y1PeunVr6/9LlCihkiVLKn/+/FqxYoVq1aqVYD9Dhw7VoEGD0jxeAADwZCMpBTzmHBwsKpjDWwVzeOuFp/NIkq7dvKUdJ65oy//3qNp8LEKXomLuJK6ORUh/39k2u5fr/w+gfmdsqpK5feXpyp89AGRU2bNnl6Ojo86ePWtTfvbs2QeOBxUVFaVp06Zp8ODBD3yefPnyKXv27Dpw4ECiSam+ffuqV69e1sdXr15Vnjx5knkUAAAgs+DbKfAE8nZzVsUC2VWxQHZJkjFGxy/dsPak2nLssnaduqoLkdFasvusluy+8+XEwSIVDvT5/yTVndn+8mX3lIMDvakAICNwcXFR2bJltXTpUjVt2lSSFBcXp6VLl6p79+733XbmzJmKjo7WSy+99MDnOXHihC5evKicOXMmut7V1ZXZ+QAAwAORlAIyAIvForzZPJQ3m4ealM4lSf/X3p2HZVXn/x9/3YAsIou4sAmiYi6paJqGk22S4PQtLSeXn+OeZcmkUmZWLuUYaqVmOTmWmjZq1kxaY6NmlJrlFkqWqalpkAIuiAjEIpzfH+Sttyxu3OcmfD6u677kPud9zvtzwPvchxfnPkd5hUXac+yM9eypXcmndexMnvamZmlvapaWbUuWJHm7u6jtRdemahdSWz41azhycwAA1yEuLk6DBg1Shw4d1LFjR82ePVs5OTnWu/ENHDhQwcHBio+Pt1luwYIF6tmzZ6mLl2dnZ+vFF19Ur169FBAQoEOHDumZZ55ReHi4oqOjTdsuAABQ/RBKAdWUew1ntW/op/YNL9zqO+1MnpKsZ1NlavfRTGXlndOmn05o008nrHWN63mqXUht60f/mvl7ycXZyRGbAQC4Sn369NGJEyc0ceJEpaWlqW3btlq7dq314ufJyclycrLdp+/fv1+bN2/WZ599Vmp9zs7O2r17txYvXqzMzEwFBQWpW7dumjJlCmdDAQCA60IoBdxAAnzcFeMTqJhWJR+3KCwq1v60syV3+kvO1K6UTB0+maOfT5Q8/rPzV0mSRw1ntWngU3K3v9+Dqvpe7o7cFABABWJjY8v9uN6GDRtKTWvWrJkMwyiz3sPDQ+vWravM4QEAAEgilAJuaDWcndQq2Eetgn00ILJkWkZOgb77/QLqu1IylZScqbP557TtcIa2Hc6wLhvs6/F7QFUSVN0c5C03l9K3BQcAAAAAoCyEUgBs+Hm66u7m9XV38/qSpOJiQ4dOZP9+JlXJGVX708/qaOZvOpr5m1bvTpUkuTo7qWWQ94WgKsRXDWp7yGLhIuoAAAAAgNKq1EViPvroI3Xr1k116tSRxWJRUlJSqZq8vDyNHDlSderUUa1atdSrV69Stz1OSEhQ586d5eXlpYCAAI0bN07nzp2rsPeVrBe4ETk5WdTU30u9bw1R/ENttHb0Hdo9qZuWPdJJY6ObKapFfdXxdFVBUbGSUjK16OsjenL5LnWZ8aVunZqg4Uu+1T82HNSWQ6eUk1/x6xAAAAAAcOOoUmdK5eTk6Pbbb1fv3r01fPjwMmvGjBmjTz/9VB9++KF8fHwUGxurhx56SF9//bUk6bvvvtOf//xnPf/881qyZImOHj2qESNGqKioSK+++mq5vS+3XgAXeLnXUOfwuuocXleSZBiGUjJ+s55JtSv5tPYcy9LJ7Hyt/zFd638sCXidLFKzgN/PpgopOaOqcV1POTlxNhUAAAAA3GiqVCg1YMAASdKRI0fKnH/mzBktWLBAy5Yt0z333CNJWrRokVq0aKGtW7fqtttu04oVK9SmTRtNnDhRkhQeHq4ZM2aod+/emjRpkry8vK5pvQDKZ7FYFFqnpkLr1FSPtsGSpLzCIu05dsZ6p79dyad17Eye9qZmaW9qlpZtS5Ykebu7qO3vH/drF+qrtiG+8q3p6sjNAQAAAACYoEqFUpeTmJiowsJCRUVFWac1b95coaGh2rJli2677Tbl5+fL3d32rmAeHh7Ky8tTYmKi7rrrrmtaL4Cr417DWe0b+ql9Qz/rtLQzeUqynk2Vqd1HM5WVd06bfjqhTT+dsNY1ruepdiEX7vTXzN9LLs5V6tPGAAAAAIDr9IcKpdLS0uTq6ipfX1+b6f7+/kpLS5MkRUdHa/bs2Vq+fLl69+6ttLQ0vfTSS5Kk1NTUa15vWfLz85Wfn299npWVdQ1bBdw4AnzcFeMTqJhWgZKkwqJi7U87W3Knv+RM7UrJ1OGTOfr5RMnjPzt/lSR51HBWmwY+1jv9tQv1VX0v94paAQAAAACqOIeFUkuXLtVjjz1mfb5mzRp16dLlutfbrVs3vfLKKxoxYoQGDBggNzc3TZgwQV999ZWcnCr3TIv4+Hi9+OKLlbpO4EZSw9lJrYJ91CrYRwMiS6Zl5BTou5SSj/vtSslUUnKmzuaf07bDGdp2OMO6bLCvx4U7/YX66uYgb7m5ODtoSwAAAAAAV8thodQDDzygTp06WZ8HBwdfdpmAgAAVFBQoMzPT5qym9PR0BQQEWJ/HxcVpzJgxSk1NVe3atXXkyBGNHz9ejRs3vq71Xmr8+PGKi4uzPs/KylJISMhltwNA+fw8XXV38/q6u3l9SVJxsaFDJ7J/P5Oq5Iyq/elndTTzNx3N/E2rd5ecAenq7KSWQd4XgqoQXzWo7SGLhYuoAwAAAEBV5LBQysvLq8yLjlekffv2qlGjhhISEtSrVy9J0v79+5WcnKzIyEibWovFoqCgIEnS8uXLFRISoltuueW613sxNzc3ubm5XdU2ALg6Tk4WNfX3UlN/L/W+tST0PZtXqO9/PaNd58+oSs7UqZwCJaVkKiklU4u+PiJJqlvLzfpxv3YhtdWmgY883f5Qn1oGAAAAgGqrSv12lpGRoeTkZB07dkxSSTAklZzJFBAQIB8fHw0bNkxxcXHy8/OTt7e3/va3vykyMtLmYuSvvPKKYmJi5OTkpI8++kjTpk3TBx98IGfnko/2HD16VF27dtWSJUvUsWPHK14vgKrBy72GOofXVefwupIkwzCUkvGb9UyqXcmntedYlk5m52v9j+la/2O6JMnJIjUL+P1sqpCSM6oa1/WUkxNnUwEAAACA2apUKPXJJ59oyJAh1ud9+/aVJE2aNEmTJ0+WJM2aNUtOTk7q1auX8vPzFR0drX/84x8261mzZo2mTp2q/Px8RURE6OOPP1b37t2t8wsLC7V//37l5uZap13JegFUTRaLRaF1aiq0Tk31aFvyUeC8wiLtOXbGeqe/XcmndexMnvamZmlvapaWbUuWJHm7u6jt7x/3axfqq7YhvvKt6erIzYEdGYahwiJDBUXFKjhXrPxzRSo4d/7rYuv0omJDhvH7Mrr465J1nP9aZdUY1skyDOOiry8sYFtTsnxZy6q8mqsZj1TutuiiZS+M37hkbFcwnnKm66Jlr3k8FWyLbKZXPJ5HujRWsK+HAAAAUHVUqVBq8ODBGjx4cIU17u7umjt3rubOnVtuzRdffFHhOsLCwmwOrq90vQD+ONxrOKt9Qz+1b+hnnZZ2Jk9J1rOpMrX7aKay8s5p008ntOmnE9a6xvU81S7kwp3+mvl7ycW5cm+UcKMoLi4JgPJ/D37Ohz7WR1HRhXkXzb90Wv4ly5RbX1R6XdbQ6ffnuDH1bBtMKAUAAFDFVKlQCgDsKcDHXTE+gYppFShJKiwq1v60s9brUu1KydThkzn6+UTJ4z87f5UkedRwVpsGPtY7/bUL9VV9L3dHbkqZDMPQuWLjCgObovLnXbrsRfOsZxbZTCs/DDpXbFx+4A7k7GSRq7OTXF1KHm6//+viZJFFFl18nfzzF823SNbpFots6iy6MNOmrrzlZfl9odLTL+1x0aqt47Ho4pqyp+uiZa+khypYV1nTdcn4bOsvmn7RArbfF9vxXNxD5a3r4ukXfV9V1rb9Xlffm2tAAgAAVDWEUgBuWDWcndQq2Eetgn004Pd7GmTkFOi78xdQT8lUUnKmzuaf07bDGdp2OMO6bLCvx4U7/YX6KtSvpgrLCWrKO8unVJhzadhTwTzbdRdZ12VU7QzIJgAq72u3i8Ih2xpn2/CovHW5OMntkuc2679oPc5cTwwAAABwGEIpALiIn6er7m5eX3c3ry+p5ONnh05k/34mVckZVfvTz+po5m86mvmbVu9OdfCIy+dk0UWBjHM5QU/5YY5bGWFQqcCnjPDHrZwwyNXZyebsFwAAAAA3NkIpAKiAk5NFTf291NTfS71vDZEkZeef0+6Uko/7nf/o36mcAtVwtpQZ0ri6OF9dmGMTDDlfceBz6TyugwUAAACgKiOUAoCrVMvNRZ3D66pzeF1JF+4s5sRHwQAAAADgihFKAcB1slhsL4gNAAAAALg8PtsBAAAAAAAA0xFKAQAAAAAAwHSEUgAAAAAAADAd15Syh5wcydm59HRnZ8nd3bauPE5OkofHtdXm5kqGUXatxSLVrHlttb/9JhUXlz8OT89rq83Lk4qKKqe2Zk1ZL+6Tny+dO1c5tR4eJd9nSSookAoLK6fW3f3C/5WrqS0sLKkvj5ub5OJy9bXnzpV8L8rj6irVqHH1tUVFJT+78tSoUVJ/tbXFxSX/1yqj1sWl5HshlbwmcnMrp/ZqXvfsI8quZR9x9bXsI0q+tvc+oqLXHQAAAC6LM6XsIShIqlWr9KNXL9u6+vXLrqtVS+re3bY2LKz82jvusK1t2bL82ltvta299dbya1u2tK29447ya8PCbGu7dy+/tn5929pevcqvrVXLtnbAgIprLw4HHnus4tqTJy/UxsVVXJucfKH2+ecrrt2790Ltyy9XXLtz54Xa11+vuParry7Uzp9fce26dRdqly6tuHblygu1K1dWXLt06YXadesqrp0//0LtV19VXPv66xdqd+6suPblly/U7t1bce3zz1+oTU6uuDYu7kLtyZMV1z722IXa3NyKawcMkI2KatlHlDzYR1x4sI8oeVTVfURQkAAAAHDtCKUAAAAAAABgOothlPe5DFytrKws+fj46MyxY/L29i5dwEdzyq7lozlXX8tHc0q+5uN711bLPqLka/YRV1/LPqLk699f91lZWfIJCtKZM2fKft+HlfUYyY7fq7BnP7XLeiXpyLT7boiejupb1bYVAHD9rvS9n2tK2YOnp+0vSRXVXc06r9TFvyRWZu3Fv9RWZu3Fv4RXZq2b24VfICqz1tX1wi8xjqqtUePCL3OVWevicuGXz8qsdXa+8v/DV1Pr5GSfWovFPrVS1ahlH1GCfcTV17KPKHH+dV9RAAoAAIDL4uN7AAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAABUM3PnzlVYWJjc3d3VqVMnbd++vdzad999VxaLxebh7u5uU2MYhiZOnKjAwEB5eHgoKipKBw4csPdmAACAao5QCgAAoBpZsWKF4uLiNGnSJO3cuVMRERGKjo7W8ePHy13G29tbqamp1scvv/xiM3/GjBmaM2eO5s2bp23btsnT01PR0dHKy8uz9+YAAIBqjFAKAACgGpk5c6aGDx+uIUOGqGXLlpo3b55q1qyphQsXlruMxWJRQECA9eHv72+dZxiGZs+erRdeeEE9evRQmzZttGTJEh07dkyrVq0yYYsAAEB1RSgFAABQTRQUFCgxMVFRUVHWaU5OToqKitKWLVvKXS47O1sNGzZUSEiIevTooT179ljnHT58WGlpaTbr9PHxUadOncpdZ35+vrKysmweAAAAlyKUAgAAqCZOnjypoqIimzOdJMnf319paWllLtOsWTMtXLhQH3/8sf71r3+puLhYnTt31q+//ipJ1uWuZp3x8fHy8fGxPkJCQq530wAAQDVEKAUAAHADi4yM1MCBA9W2bVvdeeed+uijj1SvXj3985//vOZ1jh8/XmfOnLE+UlJSKnHEAACguiCUAgAAqCbq1q0rZ2dnpaen20xPT09XQEDAFa2jRo0aateunQ4ePChJ1uWuZp1ubm7y9va2eQAAAFyKUAoAAKCacHV1Vfv27ZWQkGCdVlxcrISEBEVGRl7ROoqKivT9998rMDBQktSoUSMFBATYrDMrK0vbtm274nUCAACUxcXRAwAAAEDliYuL06BBg9ShQwd17NhRs2fPVk5OjoYMGSJJGjhwoIKDgxUfHy9Jeumll3TbbbcpPDxcmZmZeuWVV/TLL7/okUcekVRyZ77Ro0fr73//u5o2bapGjRppwoQJCgoKUs+ePR21mQAAoBoglAIAAKhG+vTpoxMnTmjixIlKS0tT27ZttXbtWuuFypOTk+XkdOFk+dOnT2v48OFKS0tT7dq11b59e33zzTdq2bKlteaZZ55RTk6OHn30UWVmZur222/X2rVr5e7ubvr2AQCA6oNQCgAAoJqJjY1VbGxsmfM2bNhg83zWrFmaNWtWheuzWCx66aWX9NJLL1XWEAEAALimFAAAAAAAAMxHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAFDNzJ07V2FhYXJ3d1enTp20ffv2cmvffvttdenSRbVr11bt2rUVFRVVqn7w4MGyWCw2j5iYGHtvBgAAqOYIpQAAAKqRFStWKC4uTpMmTdLOnTsVERGh6OhoHT9+vMz6DRs2qF+/fvryyy+1ZcsWhYSEqFu3bjp69KhNXUxMjFJTU62P5cuXm7E5AACgGiOUAgAAqEZmzpyp4cOHa8iQIWrZsqXmzZunmjVrauHChWXWL126VE888YTatm2r5s2b65133lFxcbESEhJs6tzc3BQQEGB91K5d24zNAQAA1RihFAAAQDVRUFCgxMRERUVFWac5OTkpKipKW7ZsuaJ15ObmqrCwUH5+fjbTN2zYoPr166tZs2Z6/PHHderUqXLXkZ+fr6ysLJsHAADApQilAAAAqomTJ0+qqKhI/v7+NtP9/f2VlpZ2ResYN26cgoKCbIKtmJgYLVmyRAkJCZo+fbo2btyo7t27q6ioqMx1xMfHy8fHx/oICQm59o0CAADVloujBwAAAICqYdq0aXr//fe1YcMGubu7W6f37dvX+nXr1q3Vpk0bNWnSRBs2bFDXrl1LrWf8+PGKi4uzPs/KyiKYAgAApXCmFAAAQDVRt25dOTs7Kz093WZ6enq6AgICKlz21Vdf1bRp0/TZZ5+pTZs2FdY2btxYdevW1cGDB8uc7+bmJm9vb5sHAADApQilAAAAqglXV1e1b9/e5iLl5y9aHhkZWe5yM2bM0JQpU7R27Vp16NDhsn1+/fVXnTp1SoGBgZUybgAAcGMilAIAAKhG4uLi9Pbbb2vx4sXau3evHn/8ceXk5GjIkCGSpIEDB2r8+PHW+unTp2vChAlauHChwsLClJaWprS0NGVnZ0uSsrOzNXbsWG3dulVHjhxRQkKCevToofDwcEVHRztkGwEAQPXANaUAAACqkT59+ujEiROaOHGi0tLS1LZtW61du9Z68fPk5GQ5OV34u+Rbb72lgoIC/eUvf7FZz6RJkzR58mQ5Oztr9+7dWrx4sTIzMxUUFKRu3bppypQpcnNzM3XbAABA9UIoBQAAUM3ExsYqNja2zHkbNmyweX7kyJEK1+Xh4aF169ZV0sgAAAAu4ON7AAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAEzn4ugBAAAAAEBVEfbsp3Zb95Fp99lt3QDwR0QoBQAAAAAORBAG4EbFx/cAAAAAAABguioVSn300Ufq1q2b6tSpI4vFoqSkpFI18+fP11133SVvb29ZLBZlZmaWqsnIyFD//v3l7e0tX19fDRs2TNnZ2RX2zsvL08iRI1WnTh3VqlVLvXr1Unp6eiVtGQAAgHnmzp2rsLAwubu7q1OnTtq+fXuF9R9++KGaN28ud3d3tW7dWv/73/9s5huGoYkTJyowMFAeHh6KiorSgQMH7LkJAADgBlClQqmcnBzdfvvtmj59erk1ubm5iomJ0XPPPVduTf/+/bVnzx6tX79eq1ev1qZNm/Too49W2HvMmDH673//qw8//FAbN27UsWPH9NBDD13ztgAAADjCihUrFBcXp0mTJmnnzp2KiIhQdHS0jh8/Xmb9N998o379+mnYsGHatWuXevbsqZ49e+qHH36w1syYMUNz5szRvHnztG3bNnl6eio6Olp5eXlmbRYAAKiGqtQ1pQYMGCBJOnLkSLk1o0ePliRt2LChzPl79+7V2rVrtWPHDnXo0EGS9MYbb+jPf/6zXn31VQUFBZVa5syZM1qwYIGWLVume+65R5K0aNEitWjRQlu3btVtt9127RsFAABgopkzZ2r48OEaMmSIJGnevHn69NNPtXDhQj377LOl6l9//XXFxMRo7NixkqQpU6Zo/fr1evPNNzVv3jwZhqHZs2frhRdeUI8ePSRJS5Yskb+/v1atWqW+ffuat3EAgAo54vpk9uzpqL5VqWd1V6VCqcqwZcsW+fr6WgMpSYqKipKTk5O2bdumBx98sNQyiYmJKiwsVFRUlHVa8+bNFRoaqi1bthBKAQCAP4SCggIlJiZq/Pjx1mlOTk6KiorSli1bylxmy5YtiouLs5kWHR2tVatWSZIOHz6stLQ0m+MkHx8fderUSVu2bCGUAoAyOCqoQfVT3f8vVbtQKi0tTfXr17eZ5uLiIj8/P6WlpZW7jKurq3x9fW2m+/v7l7uMJOXn5ys/P9/6/MyZM5KkrKysaxw9AAD4ozj/fm8YhoNHcsHJkydVVFQkf39/m+n+/v7at29fmcukpaWVWX/+GOj8vxXVXMoRx0jF+bl2W3d5465uPR3Vl211TM9Wk9bZrack/fBitOl9HdGzvL78//1j971RelbUt7LWe7njJIeFUkuXLtVjjz1mfb5mzRp16dLFUcO5JvHx8XrxxRdLTQ8JCXHAaAAAgCOcPXtWPj4+jh5GlVLdjpF8Zt8YPR3Vl22tfj0d1ZdtrX49HdX3RulpRt/LHSc5LJR64IEH1KlTJ+vz4ODgSllvQEBAqQt5njt3ThkZGQoICCh3mYKCAmVmZtqcLZWenl7uMpI0fvx4m9Pdi4uLlZGRYb17YGXKyspSSEiIUlJS5O3tXanrhvn4eVYv/DyrF36e1Ys9f56GYejs2bNlXq/SUerWrStnZ+dSdxCu6JgmICCgwvrz/6anpyswMNCmpm3btmWu08xjpKvlqNe4I/reKD0d1ZdtrX49HdWXba1+PR3Vtyodx17pcZLDQikvLy95eXlV+nojIyOVmZmpxMREtW/fXpL0xRdfqLi42CYEu1j79u1Vo0YNJSQkqFevXpKk/fv3Kzk5WZGRkeX2cnNzk5ubm820Sz8CWNm8vb0d/p8LlYefZ/XCz7N64edZvdjr51nVzpBydXVV+/btlZCQoJ49e0oqCYQSEhIUGxtb5jKRkZFKSEiw3kxGktavX289BmrUqJECAgKUkJBgDaGysrK0bds2Pf7442Wu0xHHSFfLUa9xR/S9UXo6qi/bWv16Oqov21r9ejqqb1U5jr2S46QqdU2pjIwMJScn69ixY5JKgiGp5C905/9Kl5aWprS0NB08eFCS9P3338vLy0uhoaHy8/NTixYtFBMTo+HDh2vevHkqLCxUbGys+vbta03ojh49qq5du2rJkiXq2LGjfHx8NGzYMMXFxcnPz0/e3t7629/+psjISC5yDgAA/lDi4uI0aNAgdejQQR07dtTs2bOVk5NjvRvfwIEDFRwcrPj4eEnSqFGjdOedd+q1117Tfffdp/fff1/ffvut5s+fL0myWCwaPXq0/v73v6tp06Zq1KiRJkyYoKCgIGvwBQAAcC2qVCj1ySefWA+YJFnv5jJp0iRNnjxZUsltjS++RsEdd9whSVq0aJEGDx4sqeR6VbGxserataucnJzUq1cvzZkzx7pMYWGh9u/fr9zcCxcMmzVrlrU2Pz9f0dHR+sc//mGvTQUAALCLPn366MSJE5o4caLS0tLUtm1brV271nqh8uTkZDk5OVnrO3furGXLlumFF17Qc889p6ZNm2rVqlVq1aqVteaZZ55RTk6OHn30UWVmZur222/X2rVr5e7ubvr2AQCA6qNKhVKDBw+2BkvlmTx5sjWgKo+fn5+WLVtW7vywsLBSV4B3d3fX3LlzNXfu3Csdrqnc3Nw0adKkUqfC44+Jn2f1ws+zeuHnWb3cqD/P2NjYcj+ut2HDhlLTHn74YT388MPlrs9iseill17SSy+9VFlDdBhH/Z9wRN8bpaej+rKt1a+no/qyrdWvp6P6/hGPeyxGVbqPMQAAAAAAAG4ITpcvAQAAAAAAACoXoRQAAAAAAABMRygFAAAAAAAA0xFK/QHMnTtXYWFhcnd3V6dOnbR9+3ZHDwnXaNOmTbr//vsVFBQki8WiVatWOXpIuA7x8fG69dZb5eXlpfr166tnz57av3+/o4eFa/TWW2+pTZs28vb2lre3tyIjI7VmzRpHDwuVYNq0abJYLBo9erSjh4IqwOzjKke89zvi/akq7EPNeq1PnjxZFovF5tG8eXO79pSko0eP6q9//avq1KkjDw8PtW7dWt9++61de4aFhZXaVovFopEjR9qtZ1FRkSZMmKBGjRrJw8NDTZo00ZQpU0rdqKqynT17VqNHj1bDhg3l4eGhzp07a8eOHZXa43L7A8MwNHHiRAUGBsrDw0NRUVE6cOCAXXt+9NFH6tatm+rUqSOLxaKkpKTr6nclfQsLCzVu3Di1bt1anp6eCgoK0sCBA3Xs2DG79ZRKXrvNmzeXp6enateuraioKG3bts2uPS82YsQIWSwWzZ49+7p6XknfwYMHl3rdxsTEXHdfeyCUquJWrFihuLg4TZo0STt37lRERISio6N1/PhxRw8N1yAnJ0cRERFV9i6PuDobN27UyJEjtXXrVq1fv16FhYXq1q2bcnJyHD00XIMGDRpo2rRpSkxM1Lfffqt77rlHPXr00J49exw9NFyHHTt26J///KfatGnj6KGgCnDEcZUj3vsd8f7k6H2o2a/1m2++WampqdbH5s2b7drv9OnT+tOf/qQaNWpozZo1+vHHH/Xaa6+pdu3adu27Y8cOm+1cv369JFV4t87rNX36dL311lt68803tXfvXk2fPl0zZszQG2+8YbeekvTII49o/fr1eu+99/T999+rW7duioqK0tGjRyutx+X2BzNmzNCcOXM0b948bdu2TZ6enoqOjlZeXp7deubk5Oj222/X9OnTr7nH1fbNzc3Vzp07NWHCBO3cuVMfffSR9u/frwceeMBuPSXppptu0ptvvqnvv/9emzdvVlhYmLp166YTJ07Yred5K1eu1NatWxUUFHTNva62b0xMjM3rd/ny5ZXSu9IZqNI6duxojBw50vq8qKjICAoKMuLj4x04KlQGScbKlSsdPQxUouPHjxuSjI0bNzp6KKgktWvXNt555x1HDwPX6OzZs0bTpk2N9evXG3feeacxatQoRw8JDubo4ypHvfc76v3JrH2o2a/1SZMmGREREXbtcalx48YZt99+u6k9yzJq1CijSZMmRnFxsd163HfffcbQoUNtpj300ENG//797dYzNzfXcHZ2NlavXm0z/ZZbbjGef/55u/S8dH9QXFxsBAQEGK+88op1WmZmpuHm5mYsX77cLj0vdvjwYUOSsWvXrkrpdaV9z9u+fbshyfjll19M63nmzBlDkvH555/bteevv/5qBAcHGz/88IPRsGFDY9asWZXSr6K+gwYNMnr06FGpfeyFM6WqsIKCAiUmJioqKso6zcnJSVFRUdqyZYsDRwagLGfOnJEk+fn5OXgkuF5FRUV6//33lZOTo8jISEcPB9do5MiRuu+++2zeR3HjupGPq8x+fzJ7H+qI1/qBAwcUFBSkxo0bq3///kpOTrZrv08++UQdOnTQww8/rPr166tdu3Z6++237drzUgUFBfrXv/6loUOHymKx2K1P586dlZCQoJ9++kmS9N1332nz5s3q3r273XqeO3dORUVFcnd3t5nu4eFh97Pgzjt8+LDS0tJs/h/7+PioU6dO1X4fJZXspywWi3x9fU3pV1BQoPnz58vHx0cRERF261NcXKwBAwZo7Nixuvnmm+3WpywbNmxQ/fr11axZMz3++OM6deqUqf2vlIujB4DynTx5UkVFRfL397eZ7u/vr3379jloVADKUlxcrNGjR+tPf/qTWrVq5ejh4Bp9//33ioyMVF5enmrVqqWVK1eqZcuWjh4WrsH777+vnTt3Vvr1QPDHdaMeV5n5/uSIfagjXuudOnXSu+++q2bNmik1NVUvvviiunTpoh9++EFeXl526fnzzz/rrbfeUlxcnJ577jnt2LFDTz75pFxdXTVo0CC79LzUqlWrlJmZqcGDB9u1z7PPPqusrCw1b95czs7OKioq0tSpU9W/f3+79fTy8lJkZKSmTJmiFi1ayN/fX8uXL9eWLVsUHh5ut74XS0tLk6Qy91Hn51VXeXl5GjdunPr16ydvb2+79lq9erX69u2r3NxcBQYGav369apbt67d+k2fPl0uLi568skn7dajLDExMXrooYfUqFEjHTp0SM8995y6d++uLVu2yNnZ2dSxXA6hFABUgpEjR+qHH34w7a9psI9mzZopKSlJZ86c0b///W8NGjRIGzduJJj6g0lJSdGoUaO0fv36Un/1Bm40Zr4/mb0PddRr/eIzdtq0aaNOnTqpYcOG+uCDDzRs2DC79CwuLlaHDh308ssvS5LatWunH374QfPmzTMtlFqwYIG6d+9eadfEKc8HH3ygpUuXatmyZbr55puVlJSk0aNHKygoyK7b+t5772no0KEKDg6Ws7OzbrnlFvXr10+JiYl264mSi5737t1bhmHorbfesnu/u+++W0lJSTp58qTefvtt9e7dW9u2bVP9+vUrvVdiYqJef/117dy5065nF5alb9++1q9bt26tNm3aqEmTJtqwYYO6du1q6lguh4/vVWF169aVs7Oz0tPTbaanp6crICDAQaMCcKnY2FitXr1aX375pRo0aODo4eA6uLq6Kjw8XO3bt1d8fLwiIiL0+uuvO3pYuEqJiYk6fvy4brnlFrm4uMjFxUUbN27UnDlz5OLioqKiIkcPEQ5wIx5Xmf3+ZPY+tKq81n19fXXTTTfp4MGDdusRGBhYKtxr0aKF3T82eN4vv/yizz//XI888ojde40dO1bPPvus+vbtq9atW2vAgAEaM2aM4uPj7dq3SZMm2rhxo7Kzs5WSkqLt27ersLBQjRs3tmvf887vh26kfdT5QOqXX37R+vXr7X6WlCR5enoqPDxct912mxYsWCAXFxctWLDALr2++uorHT9+XKGhodZ91C+//KKnnnpKYWFhdulZnsaNG6tu3bp23U9dK0KpKszV1VXt27dXQkKCdVpxcbESEhK4xglQBRiGodjYWK1cuVJffPGFGjVq5OghoZIVFxcrPz/f0cPAVeratau+//57JSUlWR8dOnRQ//79lZSUVOVOW4c5bqTjqqry/mTvfWhVea1nZ2fr0KFDCgwMtFuPP/3pT9q/f7/NtJ9++kkNGza0W8+LLVq0SPXr19d9991n9165ublycrL9NdXZ2VnFxcV27y2VhBaBgYE6ffq01q1bpx49epjSt1GjRgoICLDZR2VlZWnbtm3Vbh8lXQikDhw4oM8//1x16tRxyDjsuZ8aMGCAdu/ebbOPCgoK0tixY7Vu3Tq79CzPr7/+qlOnTtl1P3Wt+PheFRcXF6dBgwapQ4cO6tixo2bPnq2cnBwNGTLE0UPDNcjOzrZJpw8fPqykpCT5+fkpNDTUgSPDtRg5cqSWLVumjz/+WF5eXtbP+/v4+MjDw8PBo8PVGj9+vLp3767Q0FCdPXtWy5Yt04YNG0w/aMD18/LyKnXtHE9PT9WpU4drvt3gHHFc5Yj3fke8PzliH+qo1/rTTz+t+++/Xw0bNtSxY8c0adIkOTs7q1+/fnbrOWbMGHXu3Fkvv/yyevfure3bt2v+/PmaP3++3XqeV1xcrEWLFmnQoEFycbH/r4/333+/pk6dqtDQUN18883atWuXZs6cqaFDh9q177p162QYhpo1a6aDBw9q7Nixat68eaXuHy63Pxg9erT+/ve/q2nTpmrUqJEmTJigoKAg9ezZ0249MzIylJycrGPHjkmSNfwMCAi4rjO0KuobGBiov/zlL9q5c6dWr16toqIi637Kz89Prq6uld6zTp06mjp1qh544AEFBgbq5MmTmjt3ro4ePaqHH37YLtsZGhpaKmyrUaOGAgIC1KxZs2vuebm+fn5+evHFF9WrVy8FBATo0KFDeuaZZxQeHq7o6Ojr6msXjr35H67EG2+8YYSGhhqurq5Gx44dja1btzp6SLhGX375pSGp1GPQoEGOHhquQVk/S0nGokWLHD00XIOhQ4caDRs2NFxdXY169eoZXbt2NT777DNHDwuVxIzbxOOPwezjKke89zvi/amq7EPNeK336dPHCAwMNFxdXY3g4GCjT58+xsGDB+3a0zAM47///a/RqlUrw83NzWjevLkxf/58u/c0DMNYt26dIcnYv3+/Kf2ysrKMUaNGGaGhoYa7u7vRuHFj4/nnnzfy8/Pt2nfFihVG48aNDVdXVyMgIMAYOXKkkZmZWak9Lrc/KC4uNiZMmGD4+/sbbm5uRteuXa/7+365nosWLSpz/qRJk+zW9/Dhw+Xup7788ku79Pztt9+MBx980AgKCjJcXV2NwMBA44EHHjC2b99ut+0sS8OGDY1Zs2ZdV8/L9c3NzTW6detm1KtXz6hRo4bRsGFDY/jw4UZaWtp197UHi2EYxvVHWwAAAAAAAMCV45pSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAAAAAAAAMB2hFAAAAAAAAExHKAUAAAAAAADTEUoBAAAAAADAdIRSAFCGsLAwzZ4929HDuCKDBw9Wz549HT0MAADwB3HkyBFZLBYlJSWVW7NhwwZZLBZlZmZeV6/KWk9V6QOgchFKAXCoSwOVu+66S6NHjzat/7vvvitfX99S03fs2KFHH33Urr05eAIAANcqJSVFQ4cOVVBQkFxdXdWwYUONGjVKp06dqpT1d+7cWampqfLx8ZFU/jFTZfgj/TEQQOUilAJQLRUUFFzX8vXq1VPNmjUraTQAAACV5+eff1aHDh104MABLV++XAcPHtS8efOUkJCgyMhIZWRklLvslR4jubq6KiAgQBaLpbKGDQClEEoBqDIGDx6sjRs36vXXX5fFYpHFYtGRI0ckST/88IO6d++uWrVqyd/fXwMGDNDJkyety951112KjY3V6NGjVbduXUVHR0uSZs6cqdatW8vT01MhISF64oknlJ2dLankTKUhQ4bozJkz1n6TJ0+WVPovdsnJyerRo4dq1aolb29v9e7dW+np6db5kydPVtu2bfXee+8pLCxMPj4+6tu3r86ePXvF23/+L5Dr1q1TixYtVKtWLcXExCg1NdVaU1RUpLi4OPn6+qpOnTp65plnZBiGzXqKi4sVHx+vRo0aycPDQxEREfr3v/8tSTIMQ1FRUYqOjrYul5GRoQYNGmjixIlXPFYAAOA4I0eOlKurqz777DPdeeedCg0NVffu3fX555/r6NGjev755621YWFhmjJligYOHChvb2+bM8H37dunzp07y93dXa1atdLGjRut8y4+o7uiY6b33ntPHTp0kJeXlwICAvT//t//0/Hjx69r+ywWi9555x09+OCDqlmzppo2bapPPvnEpuZ///ufbrrpJnl4eOjuu++2HjNebPPmzerSpYs8PDwUEhKiJ598Ujk5OZKkJUuWqFatWjpw4IC1/oknnlDz5s2Vm5t7XeMHcOUIpQBUGa+//roiIyM1fPhwpaamKjU1VSEhIcrMzNQ999yjdu3a6dtvv9XatWuVnp6u3r172yy/ePFiubq66uuvv9a8efMkSU5OTpozZ4727NmjxYsX64svvtAzzzwjqeS09NmzZ8vb29va7+mnny41ruLiYvXo0UMZGRnauHGj1q9fr59//ll9+vSxqTt06JBWrVql1atXa/Xq1dq4caOmTZt2Vd+D3Nxcvfrqq3rvvfe0adMmJScn24zptdde07vvvquFCxdq8+bNysjI0MqVK23WER8fryVLlmjevHnas2ePxowZo7/+9a/auHGjLBaLFi9erB07dmjOnDmSpBEjRig4OJhQCgCAP4CMjAytW7dOTzzxhDw8PGzmBQQEqH///lqxYoXNH61effVVRUREaNeuXZowYYJ1+tixY/XUU09p165dioyM1P3331/mx/8qOmYqLCzUlClT9N1332nVqlU6cuSIBg8efN3b+eKLL6p3797avXu3/vznP6t///7WM8BSUlL00EMP6f7771dSUpIeeeQRPfvsszbLHzp0SDExMerVq5d2796tFStWaPPmzYqNjZUkDRw40Lrec+fO6dNPP9U777yjpUuXcrY8YCYDABxo0KBBRo8ePazP77zzTmPUqFE2NVOmTDG6detmMy0lJcWQZOzfv9+6XLt27S7b78MPPzTq1Kljfb5o0SLDx8enVF3Dhg2NWbNmGYZhGJ999pnh7OxsJCcnW+fv2bPHkGRs377dMAzDmDRpklGzZk0jKyvLWjN27FijU6dO5Y7lyy+/NCQZp0+fto5FknHw4EFrzdy5cw1/f3/r88DAQGPGjBnW54WFhUaDBg2s38O8vDyjZs2axjfffGPTa9iwYUa/fv2szz/44APD3d3dePbZZw1PT0/jp59+KnecAACg6ti6dashyVi5cmWZ82fOnGlIMtLT0w3DKDmm6dmzp03N4cOHDUnGtGnTrNPOH1NMnz7dMIyyj1PKOma61I4dOwxJxtmzZ8tcT1kuPu4yDMOQZLzwwgvW59nZ2YYkY82aNYZhGMb48eONli1b2qxj3LhxNn2GDRtmPProozY1X331leHk5GT89ttvhmEYRkZGhtGgQQPj8ccfN/z9/Y2pU6dedvsAVC4XhyRhAHAVvvvuO3355ZeqVatWqXmHDh3STTfdJElq3759qfmff/654uPjtW/fPmVlZencuXPKy8tTbm7uFf8VbO/evQoJCVFISIh1WsuWLeXr66u9e/fq1ltvlVRyeryXl5e1JjAw8KpPX69Zs6aaNGlS5jrOnDmj1NRUderUyTrfxcVFHTp0sP419ODBg8rNzdW9995rs96CggK1a9fO+vzhhx/WypUrNW3aNL311ltq2rTpVY0TAAA4lnHJx/cr0qFDhzKnR0ZGWr8+f0yxd+/eqxpHYmKiJk+erO+++06nT59WcXGxpJJLH7Rs2fKq1nWxNm3aWL/29PSUt7e39Zho7969NsdDku22SCXHj7t379bSpUut0wzDUHFxsQ4fPqwWLVqodu3aWrBggaKjo9W5c+dSZ1sBsD9CKQBVXnZ2tu6//35Nnz691LzAwEDr156enjbzjhw5ov/7v//T448/rqlTp8rPz0+bN2/WsGHDVFBQUOmnZteoUcPmucVisR6YXc86ruag8/z1sj799FMFBwfbzHNzc7N+nZubq8TERDk7O9tcSwEAAFRt4eHhslgs2rt3rx588MFS8/fu3avatWurXr161mmXHiNVlpycHEVHRys6OlpLly5VvXr1lJycrOjo6Ou+6cz1HldlZ2frscce05NPPllqXmhoqPXrTZs2ydnZWampqcrJybH5AyMA++OaUgCqFFdXVxUVFdlMu+WWW7Rnzx6FhYUpPDzc5lHRQVZiYqKKi4v12muv6bbbbtNNN92kY8eOXbbfpVq0aKGUlBSlpKRYp/3444/KzMy8rr8AXi0fHx8FBgZq27Zt1mnnzp1TYmKi9XnLli3l5uam5OTkUt+ri8/0euqpp+Tk5KQ1a9Zozpw5+uKLL0zbDgAAcO3q1Kmje++9V//4xz/022+/2cxLS0vT0qVL1adPnyu6a97WrVutX58/pmjRokWZtWUdM+3bt0+nTp3StGnT1KVLFzVv3vy6L3J+JVq0aKHt27fbTLt4W6SS48cff/yx1PFQeHi4XF1dJUnffPONpk+frv/+97+qVauW9XpTAMxDKAWgSgkLC9O2bdt05MgRnTx5UsXFxRo5cqQyMjLUr18/7dixQ4cOHdK6des0ZMiQCgOl8PBwFRYW6o033tDPP/+s9957z3oB9Iv7ZWdnKyEhQSdPnizzbitRUVFq3bq1+vfvr507d2r79u0aOHCg7rzzznJPh7eXUaNGadq0aVq1apX27dunJ554QpmZmdb5Xl5eevrppzVmzBgtXrxYhw4d0s6dO/XGG29o8eLFkkrOolq4cKGWLl2qe++9V2PHjtWgQYN0+vRpU7cFAABcmzfffFP5+fmKjo7Wpk2blJKSorVr1+ree+9VcHCwpk6dekXrmTt3rlauXKl9+/Zp5MiROn36tIYOHVpmbVnHTKGhoXJ1dbUea33yySeaMmVKZW5qmUaMGKEDBw5o7Nix2r9/v5YtW6Z3333XpmbcuHH65ptvFBsbq6SkJB04cEAff/yxNXg6e/asBgwYoCeffFLdu3fX0qVLtWLFCusdiwGYg1AKQJXy9NNPy9nZWS1btrSeAh4UFKSvv/5aRUVF6tatm1q3bq3Ro0fL19dXTk7l78YiIiI0c+ZMTZ8+Xa1atdLSpUsVHx9vU9O5c2eNGDFCffr0Ub169TRjxoxS67FYLPr4449Vu3Zt3XHHHYqKilLjxo21YsWKSt/+y3nqqac0YMAADRo0SJGRkfLy8ip16v6UKVM0YcIExcfHq0WLFoqJidGnn36qRo0a6cSJExo2bJgmT56sW265RVLJ3W38/f01YsQI07cHAABcvaZNm+rbb79V48aN1bt3bzVp0kSPPvqo7r77bm3ZskV+fn5XtJ5p06Zp2rRpioiI0ObNm/XJJ5+obt26ZdaWdcxUr149vfvuu/rwww/VsmVLTZs2Ta+++mplbmqZQkND9Z///EerVq1SRESE5s2bp5dfftmmpk2bNtq4caN++ukndenSRe3atdPEiRMVFBQkqeQPfZ6entblWrdurZdfflmPPfaYjh49avdtAFDCYlzNxUoAAAAAAACASsCZUgAAAAAAADAdoRQAAAAAAABMRygFAAAAAAAA0xFKAQAAAAAAwHSEUgAAAAAAADAdoRQAAAAAAABMRygFAAAAAAAA0xFKAQAAAAAAwHSEUgAAAAAAADAdoRQAAAAAAABMRygFAAAAAAAA0xFKAQAAAAAAwHT/H7syQrnc3y6+AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Data for energies plot\n", + "x1 = range(iterations)\n", + "n2_exact = -109.10288938\n", + "y1 = [np.min(energies) for energies in e_hist]\n", + "yt1 = [float(i) for i in range(-110, -106)]\n", + "\n", + "# Data for avg spatial orbital occupancy\n", + "y2 = avg_occupancy[:num_orbitals] + avg_occupancy[num_orbitals:]\n", + "x2 = range(len(y2))\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Plot energies\n", + "axs[0].plot(x1, y1, label=\"Estimated\")\n", + "axs[0].set_xticks(x1)\n", + "axs[0].set_xticklabels(x1)\n", + "axs[0].set_yticks(yt1)\n", + "axs[0].set_yticklabels(yt1)\n", + "axs[0].axhline(y=n2_exact, color=\"red\", linestyle=\"--\", label=\"Exact\")\n", + "axs[0].set_title(\"Approximated Ground State Energy vs SQD Iterations\")\n", + "axs[0].set_xlabel(\"Iteration Index\")\n", + "axs[0].set_ylabel(\"Energy (Ha)\")\n", + "axs[0].legend()\n", + "\n", + "# Plot orbital occupancy\n", + "axs[1].bar(x2, y2, width=0.8)\n", + "axs[1].set_xticks(x2)\n", + "axs[1].set_xticklabels(x2)\n", + "axs[1].set_title(\"Avg Occupancy per Spatial Orbital\")\n", + "axs[1].set_xlabel(\"Orbital Index\")\n", + "axs[1].set_ylabel(\"Avg Occupancy\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e8c6d5e4", + "metadata": {}, + "source": [ + "### Orbital optimization\n", + "\n", + "We now describe how to optimize the orbitals to further improve the quality of the sqd calculation.\n", + "\n", + "The orbital rotations that are implemented in this package are those described by:\n", + "$$\n", + "U(\\kappa) = e^{\\sum_{pq, \\sigma} \\kappa_{pq} c^\\dagger_{p\\sigma} c_{q\\sigma}},\n", + "$$\n", + "where $\\kappa_{p, q} \\in \\mathbb{R}$ and $\\kappa_{p, q} = -\\kappa_{q, p}$. The orbitals are optimized to \n", + "minimize the variational energy:\n", + "$$\n", + "E(\\kappa) = \\langle \\psi | U^\\dagger(\\kappa) H U(\\kappa) |\\psi \\rangle,\n", + "$$\n", + "with respect to $\\kappa$ using gradient descent with momentum. Recall that \n", + "$|\\psi\\rangle$ is spanned in a subspace defined by determinants.\n", + "\n", + "Since the change of basis alters the Hamiltonian, we allow $|\\psi\\rangle$ to \n", + "respond to the change in the Hamiltonian. This is done by performing a number of alternating\n", + "self-consistent optimizations of $\\kappa$ and $|\\psi\\rangle$. We recall that the optimal\n", + "$|\\psi\\rangle$ is given by the lowest eigenvector of the Hamiltonian projected into the\n", + "subspace.\n", + "\n", + "The ``sqd.fermion.fermion`` module provides the tools to perform this alternating\n", + "optimization. In particular, the function ``sqd.fermion.optimize_orbitals()``.\n", + "\n", + "Some of the arguments that define the optimization are:\n", + "\n", + "- ``num_iters``: number of self-consistent iterations.\n", + "- ``num_steps_grad``: number of gradient step updates performed when optimizing \n", + "$\\kappa$ on each self-consistent iteration.\n", + "- ``learning_rate``: step-size in the gradient descent optimization of $\\kappa$." + ] + }, + { + "cell_type": "markdown", + "id": "917cf2d0", + "metadata": {}, + "source": [ + "#### Setup of the subspace\n", + "\n", + "To define the subspace, we will take the addresses of the batch with the lowest energy\n", + "from the last configuration recovery step. Other strategies may be used, like taking the union \n", + "of the addresses of the batches in the last configuration recovery iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2a587030", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subspace dimension: 229441\n", + "Energy of that batch from SQD: -109.03502554132504\n" + ] + } + ], + "source": [ + "addresses = addresses = bitstring_matrix_to_sorted_addresses(\n", + " batches[np.argmin(e_hist[-1])], open_shell=open_shell\n", + ")\n", + "print(f\"Subspace dimension: {len(addresses[0]) * len(addresses[1])}\")\n", + "print(f\"Energy of that batch from SQD: {e_hist[-1, np.argmin(e_hist[-1])]}\")\n", + "\n", + "# Union strategy\n", + "\n", + "# batches_union = np.concatenate((batches[0], batches[1]), axis = 0)\n", + "# for i in range(n_batches-2):\n", + "# batches_union = np.concatenate((batches_union, batches[ i+ 2]))\n", + "# addresses = bitstring_matrix_to_sorted_addresses(\n", + "# batches_union, open_shell=open_shell\n", + "# )\n", + "# print (f\"Subspace dimension: {len(addresses[0]) * len(addresses[1])}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b5e56baf", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_addon_sqd.fermion import optimize_orbitals\n", + "\n", + "k_flat = (np.random.rand(num_orbitals**2) - 0.5) * 0.01 # initial guess for rotation params\n", + "num_iters = 10\n", + "num_steps_grad = 10_000 # relatively cheap to execute\n", + "learning_rate = 0.1\n", + "\n", + "e_improved, k_flat, orbital_occupancies = optimize_orbitals(\n", + " addresses,\n", + " hcore_rot,\n", + " eri_rot,\n", + " k_flat,\n", + " spin_sq=spin_sq,\n", + " num_iters=num_iters,\n", + " num_steps_grad=num_steps_grad,\n", + " learning_rate=learning_rate,\n", + " max_davidson=max_davidson_cycles,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e06f5c28-83d0-4dc2-b2bd-2ec92676745d", + "metadata": {}, + "source": [ + "Here we see that by optimizing rotation parameters for our Hamiltonian, we can improve the result from SQD." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "78a80e64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "improved_energy in the new basis: -109.03585435604712\n" + ] + } + ], + "source": [ + "print(f\"improved_energy in the new basis: {e_improved + nuclear_repulsion_energy}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/images/lucj_ansatz_zig_zag_pattern.jpg b/docs/images/lucj_ansatz_zig_zag_pattern.jpg new file mode 100644 index 0000000..83c069c Binary files /dev/null and b/docs/images/lucj_ansatz_zig_zag_pattern.jpg differ diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..e876442 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,90 @@ +######################################################## +Qiskit addon: sample-based quantum diagonalization (SQD) +######################################################## + +Qiskit addons are a collection of modular tools for building utility-scale workloads powered by Qiskit. + +This package contains the Qiskit addon for sample-based quantum diagonalization -- a technique for finding eigenvalues and eigenvectors of quantum operators, such as a quantum system Hamiltonian, using quantum and distributed classical computing together. + +Classical distributed computing is used to process samples obtained from a quantum processor, and to project and diagonalize a target Hamiltonian in a subspace spanned by them. This allows SQD to be robust to samples corrupted by quantum noise and deal with large Hamiltonians, such as chemistry Hamiltonians with millions of interaction terms, beyond the reach of any exact diagonalization methods. + +The SQD tool can target Hamiltonians expressed as linear combination of Pauli operators, or second-quantized fermionic operators. The input samples are obtained by quantum circuits defined by the user, which are believed to be good representations of eigenstates (e.g. the ground state) of a target operator. The convergence rate of SQD as a function of the number of samples improves with the sparseness of the target eigenstate. + +The projection and diagonalization steps are performed by a classical solver. We provide here two generic solvers, one for fermionic systems and another for qubit systems. Other solvers that might be more efficient for specific systems can be interfaced by the users. + +Documentation +------------- + +All documentation is available `here `_. + +Installation +------------ + +We encourage installing this package via ``pip``, when possible: + +.. code-block:: bash + + pip install 'qiskit-addon-sqd' + + +For more installation information refer to the `installation instructions `_ in the documentation. + +Deprecation Policy +------------------ + +We follow `semantic versioning `_ and are guided by the principles in +`Qiskit's deprecation policy `_. +We may occasionally make breaking changes in order to improve the user experience. +When possible, we will keep old interfaces and mark them as deprecated, as long as they can co-exist with the +new ones. +Each substantial improvement, breaking change, or deprecation will be documented in the +release notes. + +Contributing +------------ + +The source code is available `on GitHub `_. + +The developer guide is located at `CONTRIBUTING.md `_ +in the root of this project's repository. +By participating, you are expected to uphold Qiskit's `code of conduct `_. + +We use `GitHub issues `_ for tracking requests and bugs. + +License +------- + +`Apache License 2.0 `_ + +System sizes and computational requirements +------------------------------------------- +The computational cost of SQD is dominated by the eigenstate solver calls. At each step of the self-consistent configuration recovery iteration, `n_batches` of eigenstate solver calls are performed. The different calls are embarrassingly parallel. In this `tutorial `_, those calls are inside a `for` loop. **It is highly recommended to perform these calls in parallel**. + +The :func:`qiskit_addon_sqd.fermion.solve_fermion` function is multithreaded and capable of handling systems with ~25 spacial orbitals and ~10 electrons with subspace dimensions of ~$10^7$, using ~10-30 cores. + +Choosing subspace dimensions +---------------------------- +The choice of the subspace dimension affects the accuracy and runtime of the eigenstate solver. The larger the subspace the more accurate the calculation, at the cost of increasing the runtime and memory requirements. It is not known *a priori* the optimal subspace size, thus a convergence study with the subspace dimension may be performed, as described in this `guide `_. + +The subspace dimension is set indirectly +---------------------------------------- +In this package, the user controls the number of bitstrings contained in each subspace with the `samples_per_batch` argument in :func:`.qiskit_addon_sqd.subsampling.postselect_and_subsample`. The value of this argument determines an upper bound to the subspace dimension in the case of quantum chemistry applications. See this `example `_ for more details. + +.. _references: + +References +---------- + +[1] Javier Robledo-Moreno, et al., `Chemistry Beyond Exact Solutions on a Quantum-Centric Supercomputer `_, arXiv:2405.05068 [quant-ph]. + +[2] Keita Kanno, et al., `Quantum-Selected Configuration Interaction: classical diagonalization of Hamiltonians in subspaces selected by quantum computers `_, arXiv:2302.11320 [quant-ph]. + +.. toctree:: + :hidden: + + Documentation Home + Installation Instructions + Tutorials + How-To Guides + API Reference + GitHub diff --git a/docs/install.rst b/docs/install.rst new file mode 100644 index 0000000..cac7005 --- /dev/null +++ b/docs/install.rst @@ -0,0 +1,81 @@ +Installation Instructions +========================= + +Let's see how to install the package. The first +thing to do is choose how you're going to run and install the +packages. There are two primary ways to do this: + +- :ref:`Option 1` +- :ref:`Option 2` + +Pre-Installation +^^^^^^^^^^^^^^^^ + +First, create a minimal environment with only Python installed in it. We recommend using `Python virtual environments `__. + +.. code:: sh + + python3 -m venv /path/to/virtual/environment + +Activate your new environment. + +.. code:: sh + + source /path/to/virtual/environment/bin/activate + +Note: If you are using Windows, use the following commands in PowerShell: + +.. code:: pwsh + + python3 -m venv c:\path\to\virtual\environment + c:\path\to\virtual\environment\Scripts\Activate.ps1 + + +.. _Option 1: + +Option 1: Install from PyPI +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The most straightforward way to install the ``qiskit-addon-sqd`` package is via ``PyPI``. + +.. code:: sh + + pip install 'qiskit-addon-sqd' + + +.. _Option 2: + +Option 2: Install from Source +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Users who wish to develop in the repository or run the notebooks locally may want to install from source. + +If so, the first step is to clone the ``qiskit-addon-sqd`` repository. + +.. code:: sh + + git clone git@github.com:Qiskit/qiskit-addon-sqd.git + +Next, upgrade pip and enter the repository. + +.. code:: sh + + pip install --upgrade pip + cd qiskit-addon-sqd + +The next step is to install ``qiskit-addon-sqd`` to the virtual environment. If you plan on running the notebooks, install the +notebook dependencies in order to run all the visualizations in the notebooks. If you plan on developing in the repository, you +may want to install the ``dev`` dependencies. + +Adjust the options below to suit your needs. + +.. code:: sh + + pip install tox notebook -e '.[notebook-dependencies,dev]' + +If you installed the notebook dependencies, you can get started by running the notebooks in the docs. + +.. code:: + + cd docs/ + jupyter lab diff --git a/docs/molecules/n2_fci.txt b/docs/molecules/n2_fci.txt new file mode 100644 index 0000000..74f72f2 --- /dev/null +++ b/docs/molecules/n2_fci.txt @@ -0,0 +1,1611 @@ +&FCI NORB= 16,NELEC=10,MS2=0, + ORBSYM=1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + ISYM=1, + &END + 0.8227153295684669 1 1 1 1 + 0.05187587577524144 2 1 2 1 + 0.5219201962559413 2 2 1 1 + 0.535263084520174 2 2 2 2 + -0.1347836972470542 3 1 1 1 + -0.008657841512417053 3 1 2 2 + 0.05793493716089329 3 1 3 1 + 0.08632998383785331 3 2 2 1 + 0.2097929322213681 3 2 3 2 + 0.5579235002150018 3 3 1 1 + 0.5400470008931167 3 3 2 2 + -0.03025371939317356 3 3 3 1 + 0.5605460154373538 3 3 3 3 + 0.09174878837664172 4 1 4 1 + 0.04723726824560959 4 2 4 2 + 0.01793854091372141 4 3 4 1 + 0.02777111434804593 4 3 4 3 + 0.6167116434966806 4 4 1 1 + 0.4950011142931046 4 4 2 2 + -0.05120347206217244 4 4 3 1 + 0.4994721784892377 4 4 3 3 + 0.5574513568785978 4 4 4 4 + 0.09174878837664172 5 1 5 1 + 0.04723726824560959 5 2 5 2 + 0.01793854091372141 5 3 5 1 + 0.02777111434804593 5 3 5 3 + 0.02173144186568365 5 4 5 4 + 0.6167116434966806 5 5 1 1 + 0.4950011142931046 5 5 2 2 + -0.05120347206217243 5 5 3 1 + 0.4994721784892377 5 5 3 3 + 0.5139884731472305 5 5 4 4 + 0.5574513568785978 5 5 5 5 + -0.03561566048469387 6 1 5 2 + 0.03274533140789082 6 1 6 1 + -0.06326282529165393 6 2 5 1 + -0.03802750942520941 6 2 5 3 + 0.07187262411478063 6 2 6 2 + -0.03634033716578009 6 3 5 2 + 0.02129640076005778 6 3 6 1 + 0.03508481685867926 6 3 6 3 + 0.01461681127204733 6 4 6 4 + -0.08239995604786524 6 5 2 1 + -0.1408740357900443 6 5 3 2 + 0.1491913500304486 6 5 6 5 + 0.5357098613594921 6 6 1 1 + 0.4797794886355124 6 6 2 2 + -0.02657196082195435 6 6 3 1 + 0.4797443654275239 6 6 3 3 + 0.4715924627481501 6 6 4 4 + 0.5081607966085441 6 6 5 5 + 0.4820906746005189 6 6 6 6 + -0.0356156604846939 7 1 4 2 + 0.03274533140789088 7 1 7 1 + -0.06326282529165396 7 2 4 1 + -0.03802750942520942 7 2 4 3 + 0.07187262411478068 7 2 7 2 + -0.0363403371657801 7 3 4 2 + 0.02129640076005779 7 3 7 1 + 0.03508481685867928 7 3 7 3 + -0.08239995604786529 7 4 2 1 + -0.1408740357900444 7 4 3 2 + 0.1199577274863541 7 4 6 5 + 0.1491913500304488 7 4 7 4 + 0.01461681127204733 7 5 6 4 + 0.01461681127204734 7 5 7 5 + 0.01828416693019705 7 6 5 4 + 0.01825888562015071 7 6 7 6 + 0.5357098613594925 7 7 1 1 + 0.4797794886355127 7 7 2 2 + -0.02657196082195444 7 7 3 1 + 0.4797443654275243 7 7 3 3 + 0.5081607966085445 7 7 4 4 + 0.4715924627481504 7 7 5 5 + 0.4455729033602178 7 7 6 6 + 0.4820906746005196 7 7 7 7 + -0.03524297684128183 8 1 2 1 + -0.04074732313525206 8 1 3 2 + 0.05461805447735864 8 1 6 5 + 0.0546180544773587 8 1 7 4 + 0.03139253594027781 8 1 8 1 + -0.09902456594727965 8 2 1 1 + -0.04661452206194711 8 2 2 2 + 0.01745134735859632 8 2 3 1 + -0.0434285157352537 8 2 3 3 + -0.07441150662198262 8 2 4 4 + -0.07441150662198263 8 2 5 5 + -0.05756619827574588 8 2 6 6 + -0.05756619827574614 8 2 7 7 + 0.03454616823267013 8 2 8 2 + 0.01020038606708412 8 3 2 1 + 0.03390671413208901 8 3 3 2 + -0.01685771610674289 8 3 6 5 + -0.01685771610674282 8 3 7 4 + -0.001758941272080179 8 3 8 1 + -1.454253424481812e-15 8 3 8 2 + 0.02574499145622101 8 3 8 3 + -0.02077063701641325 8 4 4 2 + 0.02061769217890737 8 4 7 1 + 0.009719515085149335 8 4 7 3 + 0.01542975405064832 8 4 8 4 + -0.02077063701641325 8 5 5 2 + 0.02061769217890735 8 5 6 1 + 0.009719515085149337 8 5 6 3 + 0.01542975405064834 8 5 8 5 + 0.03382971287644416 8 6 5 1 + 0.006981782449266088 8 6 5 3 + -0.02290667301698743 8 6 6 2 + 0.01920341543530237 8 6 8 6 + 0.0338297128764442 8 7 4 1 + 0.006981782449266106 8 7 4 3 + -0.02290667301698751 8 7 7 2 + 0.0192034154353025 8 7 8 7 + 0.3849906228031625 8 8 1 1 + 1.532139515234422e-15 8 8 2 1 + 0.3739434384087874 8 8 2 2 + -0.01189244298406278 8 8 3 1 + -1.70487262919109e-15 8 8 3 2 + 0.3806281806388789 8 8 3 3 + 0.3592472833223549 8 8 4 4 + 0.3592472833223548 8 8 5 5 + 0.3518218572933207 8 8 6 6 + 0.3518218572933239 8 8 7 7 + -9.213014454321943e-15 8 8 8 1 + -0.002559575988447579 8 8 8 2 + 2.582877514276093e-15 8 8 8 3 + 0.3533280612079513 8 8 8 8 + -0.08437056478993962 9 1 1 1 + -0.02483152558294141 9 1 2 2 + 0.03508237116075699 9 1 3 1 + -0.04238233132830437 9 1 3 3 + -0.03130903659562344 9 1 4 4 + -0.03130903659562344 9 1 5 5 + -0.0247567692246128 9 1 6 6 + -0.0247567692246129 9 1 7 7 + 0.006664526188246471 9 1 8 2 + -0.0187004290474871 9 1 8 8 + 0.03411063970385471 9 1 9 1 + -0.000324543222555269 9 2 2 1 + -0.009544290122943031 9 2 3 2 + 0.0005846207771048886 9 2 6 5 + 0.0005846207771048843 9 2 7 4 + -0.004225446575758229 9 2 8 1 + -0.0160233903830305 9 2 8 3 + -1.296223756241197e-15 9 2 8 8 + 0.01252498165364666 9 2 9 2 + 0.1150822839777867 9 3 1 1 + 0.04437457961389323 9 3 2 2 + -0.03205451729612252 9 3 3 1 + 0.05345664062548897 9 3 3 3 + 0.07018063195288905 9 3 4 4 + 0.07018063195288905 9 3 5 5 + 0.05161063877667307 9 3 6 6 + 0.05161063877667314 9 3 7 7 + -0.03084929147706867 9 3 8 2 + 0.003453484898978239 9 3 8 8 + -0.01908776834443358 9 3 9 1 + 0.0376521330958023 9 3 9 3 + 0.02105492525439208 9 4 4 1 + 0.009612956934137195 9 4 4 3 + -0.0170208385670036 9 4 7 2 + 0.0101644211871623 9 4 8 7 + 0.01781400513488478 9 4 9 4 + 0.02105492525439208 9 5 5 1 + 0.009612956934137199 9 5 5 3 + -0.0170208385670036 9 5 6 2 + 0.01016442118716232 9 5 8 6 + 0.01781400513488478 9 5 9 5 + -0.002498627753198275 9 6 5 2 + 0.00165309872168953 9 6 6 1 + 0.0008160296419366277 9 6 6 3 + 0.004146388883456698 9 6 8 5 + 0.006081954311234169 9 6 9 6 + -0.002498627753198287 9 7 4 2 + 0.001653098721689535 9 7 7 1 + 0.0008160296419366425 9 7 7 3 + 0.004146388883456699 9 7 8 4 + 0.006081954311234147 9 7 9 7 + -0.02886065392650743 9 8 2 1 + -0.08059579771897678 9 8 3 2 + 0.05013528703473159 9 8 6 5 + 0.05013528703473144 9 8 7 4 + 0.00512605536727401 9 8 8 1 + -0.03791888034075609 9 8 8 3 + 1.79921551363938e-15 9 8 8 8 + 0.0223703801094375 9 8 9 2 + 0.07999279914080047 9 8 9 8 + 0.4512983231568335 9 9 1 1 + 0.3840689338373527 9 9 2 2 + -0.03229840501917277 9 9 3 1 + 0.3951272309006291 9 9 3 3 + 0.4007276788093279 9 9 4 4 + 0.4007276788093278 9 9 5 5 + 0.3756829401859137 9 9 6 6 + 0.3756829401859138 9 9 7 7 + -0.02463475509719546 9 9 8 2 + 0.3350906948054849 9 9 8 8 + -0.01899282782297876 9 9 9 1 + 0.0301941885483401 9 9 9 3 + 0.357505673937019 9 9 9 9 + 0.03002688675915308 10 1 4 1 + 0.0005995709470891994 10 1 4 3 + -0.0172438543749579 10 1 7 2 + 0.01291169677940597 10 1 8 7 + -0.003259507299477913 10 1 9 4 + 0.02102579188104308 10 1 10 1 + 0.01645536769518047 10 2 4 2 + -0.01311940331444267 10 2 7 1 + -0.009565545339108458 10 2 7 3 + -0.01007660992560598 10 2 8 4 + -0.001949322189805196 10 2 9 7 + 0.0150687251098785 10 2 10 2 + -0.00782040018913332 10 3 4 1 + 0.005781477858077181 10 3 4 3 + -0.001699410038954856 10 3 7 2 + 0.001405760196545938 10 3 8 7 + -0.001632221494911969 10 3 9 4 + 0.001484050816561781 10 3 10 1 + 0.011469849615765 10 3 10 3 + 0.1449696637125928 10 4 1 1 + 0.09695275968073921 10 4 2 2 + -0.02683904819641667 10 4 3 1 + 0.1040182545591939 10 4 3 3 + 0.1054748177652819 10 4 4 4 + 0.09906461632725239 10 4 5 5 + 0.08547188003399001 10 4 6 6 + 0.09092939778596297 10 4 7 7 + -0.02924953767671292 10 4 8 2 + 0.04394828485485928 10 4 8 8 + -0.02947686995983997 10 4 9 1 + 0.03114857713688626 10 4 9 3 + 0.04298462169731809 10 4 9 9 + 0.07359191071476424 10 4 10 4 + 0.003205100719014754 10 5 5 4 + 0.002728758875986386 10 5 7 6 + 0.008191070656016116 10 5 10 5 + 0.003740916537628832 10 6 6 4 + 0.003740916537628842 10 6 7 5 + 0.006733892595476496 10 6 10 6 + -0.03175412552065111 10 7 2 1 + -0.04419991710849876 10 7 3 2 + 0.04413705154502855 10 7 6 5 + 0.05161888462028632 10 7 7 4 + 0.02799596056973121 10 7 8 1 + 0.003753276611977636 10 7 8 3 + 1.440315974143754e-15 10 7 8 8 + -0.007265518703405046 10 7 9 2 + -0.006288168906483342 10 7 9 8 + 0.0512691171069093 10 7 10 7 + -0.01432355064897697 10 8 4 2 + 0.01266500684362559 10 8 7 1 + 0.009476848815356763 10 8 7 3 + 0.00610087739275617 10 8 8 4 + -0.003319323720434755 10 8 9 7 + -0.006527882109888947 10 8 10 2 + 0.008819030357028728 10 8 10 8 + -0.0277610868460422 10 9 4 1 + -0.002712441545701519 10 9 4 3 + 0.01407969203382054 10 9 7 2 + -0.01213075044001345 10 9 8 7 + -0.0153864513142966 10 9 9 4 + -0.001978189261451786 10 9 10 1 + 0.007699118725409356 10 9 10 3 + 0.02254152233110553 10 9 10 9 + 0.4998988132267892 10 10 1 1 + 0.4218026079703191 10 10 2 2 + -0.03382189309417083 10 10 3 1 + 0.4255207026306143 10 10 3 3 + 0.4651404872687848 10 10 4 4 + 0.4344993981198162 10 10 5 5 + 0.4056300253382854 10 10 6 6 + 0.4333081365746642 10 10 7 7 + -0.0536352304400848 10 10 8 2 + 0.3204238854796895 10 10 8 8 + -0.02152976366663165 10 10 9 1 + 0.05340750800241357 10 10 9 3 + 0.3587531393113008 10 10 9 9 + 0.06855019518349734 10 10 10 4 + 0.4196213574578366 10 10 10 10 + 0.03002688675915308 11 1 5 1 + 0.0005995709470891968 11 1 5 3 + -0.01724385437495788 11 1 6 2 + 0.01291169677940596 11 1 8 6 + -0.003259507299477917 11 1 9 5 + 0.02102579188104309 11 1 11 1 + 0.01645536769518047 11 2 5 2 + -0.01311940331444265 11 2 6 1 + -0.009565545339108448 11 2 6 3 + -0.01007660992560598 11 2 8 5 + -0.001949322189805188 11 2 9 6 + 0.0150687251098785 11 2 11 2 + -0.007820400189133322 11 3 5 1 + 0.00578147785807718 11 3 5 3 + -0.001699410038954843 11 3 6 2 + 0.001405760196545969 11 3 8 6 + -0.001632221494911968 11 3 9 5 + 0.00148405081656178 11 3 11 1 + 0.011469849615765 11 3 11 3 + 0.003205100719014754 11 4 5 4 + 0.002728758875986387 11 4 7 6 + 0.008191070656016116 11 4 10 5 + 0.008191070656016116 11 4 11 4 + 0.1449696637125928 11 5 1 1 + 0.09695275968073919 11 5 2 2 + -0.02683904819641666 11 5 3 1 + 0.1040182545591939 11 5 3 3 + 0.09906461632725239 11 5 4 4 + 0.1054748177652819 11 5 5 5 + 0.09092939778596278 11 5 6 6 + 0.08547188003399016 11 5 7 7 + -0.02924953767671275 11 5 8 2 + 0.04394828485485827 11 5 8 8 + -0.02947686995983996 11 5 9 1 + 0.03114857713688622 11 5 9 3 + 0.04298462169731804 11 5 9 9 + 0.05720976940273201 11 5 10 4 + 0.07030411420044645 11 5 10 10 + 0.07359191071476423 11 5 11 5 + -0.03175412552065102 11 6 2 1 + -0.04419991710849857 11 6 3 2 + 0.05161888462028608 11 6 6 5 + 0.04413705154502847 11 6 7 4 + 0.02799596056973113 11 6 8 1 + 0.003753276611977717 11 6 8 3 + -0.007265518703405005 11 6 9 2 + -0.006288168906483526 11 6 9 8 + 0.03780133191595628 11 6 10 7 + 0.05126911710690923 11 6 11 6 + 0.003740916537628846 11 7 6 4 + 0.003740916537628855 11 7 7 5 + 0.006733892595476501 11 7 10 6 + 0.006733892595476504 11 7 11 7 + -0.01432355064897697 11 8 5 2 + 0.01266500684362557 11 8 6 1 + 0.00947684881535678 11 8 6 3 + 0.00610087739275618 11 8 8 5 + -0.003319323720434811 11 8 9 6 + -0.006527882109888937 11 8 11 2 + 0.008819030357028617 11 8 11 8 + -0.0277610868460422 11 9 5 1 + -0.002712441545701516 11 9 5 3 + 0.01407969203382054 11 9 6 2 + -0.01213075044001344 11 9 8 6 + -0.01538645131429661 11 9 9 5 + -0.001978189261451785 11 9 11 1 + 0.007699118725409364 11 9 11 3 + 0.02254152233110554 11 9 11 9 + 0.01532054457448425 11 10 5 4 + 0.0138390556181893 11 10 7 6 + -0.000876959508474574 11 10 10 5 + -0.000876959508474574 11 10 11 4 + 0.01686640172407809 11 10 11 10 + 0.4998988132267891 11 11 1 1 + 0.421802607970319 11 11 2 2 + -0.03382189309417081 11 11 3 1 + 0.4255207026306143 11 11 3 3 + 0.4344993981198162 11 11 4 4 + 0.4651404872687848 11 11 5 5 + 0.4333081365746639 11 11 6 6 + 0.4056300253382856 11 11 7 7 + -0.05363523044008468 11 11 8 2 + 0.3204238854796894 11 11 8 8 + -0.0215297636666316 11 11 9 1 + 0.05340750800241346 11 11 9 3 + 0.3587531393113008 11 11 9 9 + 0.07030411420044641 11 11 10 4 + 0.3858885540096804 11 11 10 10 + 0.06855019518349731 11 11 11 5 + 0.4196213574578366 11 11 11 11 + -0.07252386655652338 12 1 1 1 + -0.04817345291726773 12 1 2 2 + 0.015099798508844 12 1 3 1 + -0.05318236739596851 12 1 3 3 + -0.04716894759288759 12 1 4 4 + -0.0471689475928876 12 1 5 5 + -0.04179543267217408 12 1 6 6 + -0.04179543267217419 12 1 7 7 + 0.01408923904948181 12 1 8 2 + -0.0204044608969251 12 1 8 8 + 0.01867381427566084 12 1 9 1 + -0.01628485414144834 12 1 9 3 + -0.0186581299537927 12 1 9 9 + -0.03353576020360035 12 1 10 4 + -0.0322807452863257 12 1 10 10 + -0.03353576020360034 12 1 11 5 + -0.03228074528632571 12 1 11 11 + 0.01910336208871495 12 1 12 1 + -0.03939125656177737 12 2 2 1 + -0.08351109442138421 12 2 3 2 + 0.06035578438358322 12 2 6 5 + 0.06035578438358328 12 2 7 4 + 0.02657881534326089 12 2 8 1 + 0.002880040031260157 12 2 8 3 + -0.00971459606606043 12 2 9 2 + 0.00271726226155141 12 2 9 8 + 0.04416334315709407 12 2 10 7 + 0.044163343157094 12 2 11 6 + 0.06224984401876937 12 2 12 2 + -0.06608964947588568 12 3 1 1 + -0.09713728354111256 12 3 2 2 + -0.004241995776670988 12 3 3 1 + -0.09978990080079095 12 3 3 3 + -0.06799506263101959 12 3 4 4 + -0.06799506263101959 12 3 5 5 + -0.06553981908388333 12 3 6 6 + -0.0655398190838834 12 3 7 7 + 0.01975324686647371 12 3 8 2 + -0.02354589783669184 12 3 8 8 + 0.00716344036070267 12 3 9 1 + -0.02118156067447154 12 3 9 3 + -0.02596187478894659 12 3 9 9 + -0.04103114102031719 12 3 10 4 + -0.04957853931904679 12 3 10 10 + -0.04103114102031719 12 3 11 5 + -0.04957853931904679 12 3 11 11 + 0.02112603363828457 12 3 12 1 + 0.05563156668223655 12 3 12 3 + 0.001360532093856368 12 4 4 1 + -0.001865410561475097 12 4 4 3 + 0.002949064082123812 12 4 7 2 + -0.004129123910208721 12 4 8 7 + 0.009713428192873592 12 4 9 4 + -0.01271668494554261 12 4 10 1 + -0.01216822350056109 12 4 10 3 + -0.0115411996596363 12 4 10 9 + 0.02137424328036308 12 4 12 4 + 0.001360532093856368 12 5 5 1 + -0.001865410561475096 12 5 5 3 + 0.00294906408212379 12 5 6 2 + -0.004129123910208734 12 5 8 6 + 0.009713428192873593 12 5 9 5 + -0.01271668494554261 12 5 11 1 + -0.01216822350056108 12 5 11 3 + -0.01154119965963631 12 5 11 9 + 0.02137424328036308 12 5 12 5 + 0.009766317487263866 12 6 5 2 + -0.007501073572382757 12 6 6 1 + -0.004241359248528507 12 6 6 3 + -0.007452898112146149 12 6 8 5 + -0.002139376722845498 12 6 9 6 + 0.01557363897454371 12 6 11 2 + -0.004249302739867289 12 6 11 8 + 0.01827608533775912 12 6 12 6 + 0.009766317487263913 12 7 4 2 + -0.007501073572382807 12 7 7 1 + -0.004241359248528555 12 7 7 3 + -0.007452898112146157 12 7 8 4 + -0.002139376722845514 12 7 9 7 + 0.01557363897454372 12 7 10 2 + -0.004249302739867345 12 7 10 8 + 0.01827608533775913 12 7 12 7 + 0.03044988156632234 12 8 2 1 + 0.06756198653910885 12 8 3 2 + -0.04986483869970083 12 8 6 5 + -0.04986483869970072 12 8 7 4 + -0.01406191610573038 12 8 8 1 + -1.080333248396813e-15 12 8 8 2 + 0.02493472505019834 12 8 8 3 + 1.440349271024081e-14 12 8 8 8 + -0.01376888426618416 12 8 9 2 + -0.04949655272668021 12 8 9 8 + -0.01275713323238072 12 8 10 7 + -0.01275713323238045 12 8 11 6 + -0.01746029070894922 12 8 12 2 + 0.03962473388070775 12 8 12 8 + 0.05508998484749093 12 9 1 1 + -0.002955593588340783 12 9 2 2 + -0.01608302160181269 12 9 3 1 + -0.005151171020618813 12 9 3 3 + 0.03550952711503414 12 9 4 4 + 0.03550952711503415 12 9 5 5 + 0.01723353856311708 12 9 6 6 + 0.0172335385631171 12 9 7 7 + -0.0211329424596859 12 9 8 2 + -0.01714150619978659 12 9 8 8 + 0.005098713337477478 12 9 9 1 + 0.01954367251789673 12 9 9 3 + 0.01628532881206809 12 9 9 9 + -0.004504819323704517 12 9 10 4 + 0.02979711331954439 12 9 10 10 + -0.004504819323704525 12 9 11 5 + 0.02979711331954446 12 9 11 11 + 0.003827210683347468 12 9 12 1 + 0.007038755390908001 12 9 12 3 + 0.03507224564177311 12 9 12 9 + -0.05320300990442641 12 10 4 1 + -0.02764334152860565 12 10 4 3 + 0.05402128462326911 12 10 7 2 + -0.01775062632354522 12 10 8 7 + -0.0216425866503939 12 10 9 4 + -0.00771891755914737 12 10 10 1 + 0.005296650399220154 12 10 10 3 + 0.02292175083659569 12 10 10 9 + -0.009386397610115274 12 10 12 4 + 0.05546692121091104 12 10 12 10 + -0.0532030099044264 12 11 5 1 + -0.02764334152860565 12 11 5 3 + 0.0540212846232691 12 11 6 2 + -0.01775062632354523 12 11 8 6 + -0.0216425866503939 12 11 9 5 + -0.007718917559147367 12 11 11 1 + 0.005296650399220158 12 11 11 3 + 0.02292175083659568 12 11 11 9 + -0.009386397610115277 12 11 12 5 + 0.05546692121091105 12 11 12 11 + 0.4612715133426393 12 12 1 1 + 0.4460021322160238 12 12 2 2 + -0.01342930830522628 12 12 3 1 + 0.4501859991440598 12 12 3 3 + 0.4355791013471 12 12 4 4 + 0.4355791013471 12 12 5 5 + 0.4173012039011873 12 12 6 6 + 0.4173012039011875 12 12 7 7 + -0.03884382664863605 12 12 8 2 + 0.3367575220269805 12 12 8 8 + -0.01460096907704438 12 12 9 1 + 0.03913468761098396 12 12 9 3 + 1.241679171819887e-15 12 12 9 8 + 0.3587517868916215 12 12 9 9 + 0.06367642279364272 12 12 10 4 + 0.3876931236919529 12 12 10 10 + 0.0636764227936427 12 12 11 5 + 0.3876931236919529 12 12 11 11 + -0.02991153585599569 12 12 12 1 + -0.0635400339204665 12 12 12 3 + 0.01000980712782574 12 12 12 9 + 0.3982928899844128 12 12 12 12 + -0.020319337564739 13 1 5 2 + 0.02224504243948042 13 1 6 1 + 0.007303279157504984 13 1 6 3 + 0.01539731922688624 13 1 8 5 + 0.00010585505933846 13 1 9 6 + -0.01351852248110953 13 1 11 2 + 0.009979615328135778 13 1 11 8 + -0.01171551176798921 13 1 12 6 + 0.02065132184080299 13 1 13 1 + -0.02292391261233528 13 2 5 1 + -0.007888724132528075 13 2 5 3 + 0.0191622120320625 13 2 6 2 + -0.01497087246967277 13 2 8 6 + -0.002945694958561035 13 2 9 5 + -0.01568330259791023 13 2 11 1 + -0.009819411494828043 13 2 11 3 + 0.001802834271914497 13 2 11 9 + 0.01590191499321475 13 2 12 5 + 0.009131032405078742 13 2 12 11 + 0.02109041605834197 13 2 13 2 + -0.006049362796284102 13 3 5 2 + 0.001483055387208707 13 3 6 1 + 0.005091728364954059 13 3 6 3 + 0.003704000817336953 13 3 8 5 + 0.00450154807940028 13 3 9 6 + -0.01024827571669118 13 3 11 2 + 3.400098133011532e-05 13 3 11 8 + -0.01244771019446972 13 3 12 6 + 0.003357186308430416 13 3 13 1 + 0.01189977128418155 13 3 13 3 + 0.006360636661278265 13 4 6 4 + 0.006360636661278275 13 4 7 5 + 0.006926787460608169 13 4 10 6 + 0.006926787460608174 13 4 11 7 + 0.007815895711498062 13 4 13 4 + -0.04432168342255804 13 5 2 1 + -0.0609879701803436 13 5 3 2 + 0.07489211275466962 13 5 6 5 + 0.06217083943211314 13 5 7 4 + 0.03768176780051597 13 5 8 1 + 0.001246387383123882 13 5 8 3 + -0.007503220822896541 13 5 9 2 + 0.001250807188627407 13 5 9 8 + 0.04343454830114046 13 5 10 7 + 0.05728812322235669 13 5 11 6 + 0.05034100916186603 13 5 12 2 + -0.01958891806602949 13 5 12 8 + 0.06797631516837395 13 5 13 5 + 0.1708917255615217 13 6 1 1 + 0.1109290241461297 13 6 2 2 + -0.02873191044619955 13 6 3 1 + 0.1154136514336689 13 6 3 3 + 0.1209064905311454 13 6 4 4 + 0.1327928196100237 13 6 5 5 + 0.1090301273474307 13 6 6 6 + 0.1012348012918779 13 6 7 7 + -0.03993334901219062 13 6 8 2 + 0.04482238724961198 13 6 8 8 + -0.02514924897402358 13 6 9 1 + 0.04007441040968897 13 6 9 3 + 0.05593702487726505 13 6 9 9 + 0.06151976894521784 13 6 10 4 + 0.08777311961906925 13 6 10 10 + 0.07683726687686593 13 6 11 5 + 0.09089144702137343 13 6 11 11 + -0.03410693308859207 13 6 12 1 + -0.0468710214756633 13 6 12 3 + 0.007964859467688087 13 6 12 9 + 0.07853343406964182 13 6 12 12 + 0.08954469366957284 13 6 13 6 + 0.005943164539439119 13 7 5 4 + 0.003897663027776591 13 7 7 6 + 0.007658748965823991 13 7 10 5 + 0.007658748965823991 13 7 11 4 + 0.001559163701152005 13 7 11 10 + 0.009102174321067639 13 7 13 7 + 0.03049879613328867 13 8 5 1 + 0.01218653580737627 13 8 5 3 + -0.02950523141910915 13 8 6 2 + 0.007100546452261653 13 8 8 6 + 0.002481900508305642 13 8 9 5 + 0.01198949053395889 13 8 11 1 + -0.002169492299201969 13 8 11 3 + -0.002893654703571947 13 8 11 9 + -0.00230859043329256 13 8 12 5 + -0.02282671306080726 13 8 12 11 + -0.007458180140383461 13 8 13 2 + 0.01969697547480767 13 8 13 8 + -0.005211747531120573 13 9 5 2 + 0.0003180027094939873 13 9 6 1 + 0.008753467642890861 13 9 6 3 + -0.002911675924558019 13 9 8 5 + -0.003030202151339226 13 9 9 6 + 0.0006830247340703307 13 9 11 2 + 0.003620423075862616 13 9 11 8 + 0.002311795390860396 13 9 12 6 + -0.002837239927799319 13 9 13 1 + -0.0006134313282216038 13 9 13 3 + 0.007775585655510064 13 9 13 9 + 0.01036288286294282 13 10 6 4 + 0.01036288286294283 13 10 7 5 + 0.002240529654206095 13 10 10 6 + 0.002240529654206108 13 10 11 7 + 0.00431082603472827 13 10 13 4 + 0.01024211616271652 13 10 13 10 + -0.06703052743447452 13 11 2 1 + -0.1157687838098387 13 11 3 2 + 0.1219925595027842 13 11 6 5 + 0.1012667937768985 13 11 7 4 + 0.04522690010249331 13 11 8 1 + -0.01782050275107696 13 11 8 3 + -1.44332556010002e-15 13 11 8 8 + 0.002616667269095521 13 11 9 2 + 0.04501326399199456 13 11 9 8 + 0.03822716442227384 13 11 10 7 + 0.04270822373068593 13 11 11 6 + 0.04979598355697969 13 11 12 2 + -0.0464142526959522 13 11 12 8 + 0.06251041156989467 13 11 13 5 + 0.113256030597099 13 11 13 11 + 0.0332333884752652 13 12 5 2 + -0.02406050459101049 13 12 6 1 + -0.02784244761275203 13 12 6 3 + -0.01193474670606555 13 12 8 5 + 0.0007874510779574634 13 12 9 6 + 0.008456377155188387 13 12 11 2 + -0.01213426280234414 13 12 11 8 + 0.001771749533639082 13 12 12 6 + -0.01182872452064643 13 12 13 1 + -0.0006877470781163472 13 12 13 3 + -0.00706138745189237 13 12 13 9 + 0.03095947911215346 13 12 13 12 + 0.5050262226298633 13 13 1 1 + 0.4389181655673818 13 13 2 2 + -0.03281907698126586 13 13 3 1 + 0.4438172532847061 13 13 3 3 + 0.439717348069014 13 13 4 4 + 0.4678487895461089 13 13 5 5 + 0.444061375818176 13 13 6 6 + 0.4154111112115643 13 13 7 7 + -0.05046002042170361 13 13 8 2 + 0.3352105865180082 13 13 8 8 + -0.03060992899015901 13 13 9 1 + 0.04979106181529502 13 13 9 3 + 0.3564016583483769 13 13 9 9 + 0.0823476578938087 13 13 10 4 + 0.3867621774153833 13 13 10 10 + 0.08746627524833039 13 13 11 5 + 0.4142004572909493 13 13 11 11 + -0.04074553881022964 13 13 12 1 + -0.05711544314260815 13 13 12 3 + 2.073081039098704e-15 13 13 12 8 + 0.01211268605646502 13 13 12 9 + 0.3920491471497343 13 13 12 12 + 0.1005252754960653 13 13 13 6 + 0.4275603326390163 13 13 13 13 + -0.02031933756473895 14 1 4 2 + 0.0222450424394804 14 1 7 1 + 0.007303279157504955 14 1 7 3 + 0.01539731922688616 14 1 8 4 + 0.0001058550593384699 14 1 9 7 + -0.0135185224811095 14 1 10 2 + 0.009979615328135724 14 1 10 8 + -0.01171551176798922 14 1 12 7 + 0.02065132184080292 14 1 14 1 + -0.02292391261233519 14 2 4 1 + -0.007888724132528025 14 2 4 3 + 0.01916221203206242 14 2 7 2 + -0.01497087246967264 14 2 8 7 + -0.002945694958561022 14 2 9 4 + -0.0156833025979102 14 2 10 1 + -0.009819411494828045 14 2 10 3 + 0.001802834271914478 14 2 10 9 + 0.01590191499321474 14 2 12 4 + 0.009131032405078647 14 2 12 10 + 0.02109041605834191 14 2 14 2 + -0.006049362796284054 14 3 4 2 + 0.001483055387208682 14 3 7 1 + 0.00509172836495402 14 3 7 3 + 0.003704000817336941 14 3 8 4 + 0.004501548079400289 14 3 9 7 + -0.01024827571669118 14 3 10 2 + 3.400098133009913e-05 14 3 10 8 + -0.01244771019446973 14 3 12 7 + 0.00335718630843041 14 3 14 1 + 0.01189977128418155 14 3 14 3 + -0.0443216834225579 14 4 2 1 + -0.06098797018034342 14 4 3 2 + 0.0621708394321129 14 4 6 5 + 0.07489211275466949 14 4 7 4 + 0.03768176780051582 14 4 8 1 + 0.001246387383123694 14 4 8 3 + -0.007503220822896632 14 4 9 2 + 0.001250807188627908 14 4 9 8 + 0.0572881232223567 14 4 10 7 + 0.0434345483011403 14 4 11 6 + 0.05034100916186597 14 4 12 2 + -0.01958891806602978 14 4 12 8 + 0.0523445237453777 14 4 13 5 + 0.05388875950043791 14 4 13 11 + 0.06797631516837373 14 4 14 4 + 0.006360636661278242 14 5 6 4 + 0.006360636661278252 14 5 7 5 + 0.006926787460608162 14 5 10 6 + 0.006926787460608168 14 5 11 7 + 0.007815895711498053 14 5 13 4 + 0.004310826034728256 14 5 13 10 + 0.007815895711498044 14 5 14 5 + 0.005943164539439075 14 6 5 4 + 0.003897663027776549 14 6 7 6 + 0.007658748965823982 14 6 10 5 + 0.007658748965823982 14 6 11 4 + 0.001559163701151966 14 6 11 10 + 0.009102174321067623 14 6 13 7 + 0.009102174321067615 14 6 14 6 + 0.1708917255615215 14 7 1 1 + 0.1109290241461296 14 7 2 2 + -0.02873191044619954 14 7 3 1 + 0.1154136514336688 14 7 3 3 + 0.1327928196100235 14 7 4 4 + 0.1209064905311454 14 7 5 5 + 0.1012348012918778 14 7 6 6 + 0.1090301273474309 14 7 7 7 + -0.03993334901219016 14 7 8 2 + 0.04482238724960783 14 7 8 8 + -0.02514924897402352 14 7 9 1 + 0.04007441040968897 14 7 9 3 + 0.055937024877265 14 7 9 9 + 0.07683726687686578 14 7 10 4 + 0.09089144702137315 14 7 10 10 + 0.06151976894521789 14 7 11 5 + 0.08777311961906932 14 7 11 11 + -0.03410693308859203 14 7 12 1 + -0.04687102147566336 14 7 12 3 + 0.007964859467688143 14 7 12 9 + 0.07853343406964172 14 7 12 12 + 0.07134034502743711 14 7 13 6 + 0.09508297990203549 14 7 13 13 + 0.08954469366957248 14 7 14 7 + 0.03049879613328862 14 8 4 1 + 0.01218653580737628 14 8 4 3 + -0.0295052314191091 14 8 7 2 + 0.007100546452260979 14 8 8 7 + 0.002481900508305636 14 8 9 4 + 0.01198949053395889 14 8 10 1 + -0.002169492299201915 14 8 10 3 + -0.002893654703571985 14 8 10 9 + -0.002308590433292583 14 8 12 4 + -0.02282671306080728 14 8 12 10 + -0.007458180140383519 14 8 14 2 + 0.01969697547480879 14 8 14 8 + -0.00521174753112057 14 9 4 2 + 0.0003180027094939756 14 9 7 1 + 0.008753467642890873 14 9 7 3 + -0.002911675924557971 14 9 8 4 + -0.003030202151339219 14 9 9 7 + 0.0006830247340703535 14 9 10 2 + 0.003620423075862462 14 9 10 8 + 0.002311795390860438 14 9 12 7 + -0.002837239927799346 14 9 14 1 + -0.0006134313282216337 14 9 14 3 + 0.007775585655510114 14 9 14 9 + -0.06703052743447442 14 10 2 1 + -0.1157687838098386 14 10 3 2 + 0.1012667937768984 14 10 6 5 + 0.1219925595027841 14 10 7 4 + 0.04522690010249301 14 10 8 1 + -0.01782050275107694 14 10 8 3 + 0.002616667269095518 14 10 9 2 + 0.04501326399199504 14 10 9 8 + 0.04270822373068599 14 10 10 7 + 0.03822716442227363 14 10 11 6 + 0.04979598355697962 14 10 12 2 + -0.04641425269595145 14 10 12 8 + 0.05388875950043794 14 10 13 5 + 0.09277179827166585 14 10 13 11 + 0.06251041156989443 14 10 14 4 + 0.1132560305970989 14 10 14 10 + 0.01036288286294282 14 11 6 4 + 0.01036288286294282 14 11 7 5 + 0.002240529654206083 14 11 10 6 + 0.002240529654206097 14 11 11 7 + 0.004310826034728261 14 11 13 4 + 0.01024211616271652 14 11 13 10 + 0.004310826034728247 14 11 14 5 + 0.01024211616271652 14 11 14 11 + 0.03323338847526518 14 12 4 2 + -0.02406050459101049 14 12 7 1 + -0.02784244761275203 14 12 7 3 + -0.01193474670606554 14 12 8 4 + 0.0007874510779574387 14 12 9 7 + 0.008456377155188365 14 12 10 2 + -0.01213426280234417 14 12 10 8 + 0.00177174953363907 14 12 12 7 + -0.01182872452064637 14 12 14 1 + -0.0006877470781162816 14 12 14 3 + -0.007061387451892377 14 12 14 9 + 0.03095947911215342 14 12 14 12 + 0.01406572073854749 14 13 5 4 + 0.01432513230330575 14 13 7 6 + 0.002559308677260895 14 13 10 5 + 0.002559308677260895 14 13 11 4 + 0.01371913993778317 14 13 11 10 + 0.002721147797015235 14 13 13 7 + 0.002721147797015192 14 13 14 6 + 0.01481144565396225 14 13 14 13 + 0.5050262226298629 14 14 1 1 + 0.4389181655673815 14 14 2 2 + -0.03281907698126584 14 14 3 1 + 0.4438172532847058 14 14 3 3 + 0.4678487895461085 14 14 4 4 + 0.4397173480690134 14 14 5 5 + 0.4154111112115637 14 14 6 6 + 0.4440613758181757 14 14 7 7 + -0.05046002042170381 14 14 8 2 + 0.3352105865180141 14 14 8 8 + -0.03060992899015902 14 14 9 1 + 0.04979106181529493 14 14 9 3 + 0.3564016583483767 14 14 9 9 + 0.0874662752483303 14 14 10 4 + 0.4142004572909493 14 14 10 10 + 0.08234765789380849 14 14 11 5 + 0.386762177415383 14 14 11 11 + -0.04074553881022965 14 14 12 1 + -0.05711544314260802 14 14 12 3 + 1.867867414639241e-15 14 14 12 8 + 0.01211268605646466 14 14 12 9 + 0.392049147149734 14 14 12 12 + 0.09508297990203528 14 14 13 6 + 0.3979374413310908 14 14 13 13 + 0.1005252754960654 14 14 14 7 + 0.4275603326390156 14 14 14 14 + 0.03044141800615992 15 1 2 1 + 0.02775919187179186 15 1 3 2 + -0.04782202090248545 15 1 6 5 + -0.04782202090248552 15 1 7 4 + -0.03151848209199964 15 1 8 1 + 0.008326438161106019 15 1 8 3 + 1.669076790689618e-15 15 1 8 8 + 0.0002309364660409982 15 1 9 2 + -0.006705060713479979 15 1 9 8 + -0.0216234984797302 15 1 10 7 + -0.02162349847973007 15 1 11 6 + -0.01475101655209674 15 1 12 2 + 0.01447032795644045 15 1 12 8 + -0.03147813015009365 15 1 13 5 + -0.04286708697868889 15 1 13 11 + -0.03147813015009358 15 1 14 4 + -0.04286708697868886 15 1 14 10 + 0.04076970500824031 15 1 15 1 + -0.03136458934142195 15 2 1 1 + -0.08818110018002655 15 2 2 2 + -0.0105723260519533 15 2 3 1 + -0.0948146429818385 15 2 3 3 + -0.04186475250153127 15 2 4 4 + -0.04186475250153124 15 2 5 5 + -0.04645260220078171 15 2 6 6 + -0.04645260220078179 15 2 7 7 + 0.006582685207325696 15 2 8 2 + -0.0233679942730151 15 2 8 8 + 0.006687102977542664 15 2 9 1 + -0.01201334134253564 15 2 9 3 + -0.01875526326982519 15 2 9 9 + -0.0324771651831138 15 2 10 4 + -0.03250134456653433 15 2 10 10 + -0.03247716518311378 15 2 11 5 + -0.0325013445665343 15 2 11 11 + 0.01761361875258758 15 2 12 1 + 0.05496203765440077 15 2 12 3 + 0.01655936757279138 15 2 12 9 + -0.05495450809468003 15 2 12 12 + -0.03446967184007887 15 2 13 6 + -0.04118943239354392 15 2 13 13 + -0.03446967184007887 15 2 14 7 + -0.04118943239354392 15 2 14 14 + 0.06106198754139933 15 2 15 2 + -0.0533585297976502 15 3 2 1 + -0.1207627621785575 15 3 3 2 + 0.08328266732299341 15 3 6 5 + 0.08328266732299353 15 3 7 4 + 0.03712673258774375 15 3 8 1 + -0.009080954901278063 15 3 8 3 + -4.428656228738066e-15 15 3 8 8 + -0.007187108169355868 15 3 9 2 + 0.01562481940718271 15 3 9 8 + 0.05370148413066796 15 3 10 7 + 0.05370148413066779 15 3 11 6 + 0.07857803532511899 15 3 12 2 + -0.03021586142641745 15 3 12 8 + 0.06321615582185275 15 3 13 5 + 0.07268665640086933 15 3 13 11 + 0.06321615582185269 15 3 14 4 + 0.07268665640086922 15 3 14 10 + -0.03101539935010343 15 3 15 1 + 0.1137534373244117 15 3 15 3 + 0.00735987842516544 15 4 4 2 + -0.01273879809213867 15 4 7 1 + -8.243599524844258e-05 15 4 7 3 + -0.007606960663715061 15 4 8 4 + 0.0006411202605107796 15 4 9 7 + -0.003980467653867636 15 4 10 2 + -0.003336662789570667 15 4 10 8 + -0.008044159008872171 15 4 12 7 + -0.007111530115937463 15 4 14 1 + 0.009598565795186307 15 4 14 3 + 0.002248493390622297 15 4 14 9 + 0.006349167183720436 15 4 14 12 + 0.01595061708813343 15 4 15 4 + 0.007359878425165441 15 5 5 2 + -0.01273879809213866 15 5 6 1 + -8.243599524845776e-05 15 5 6 3 + -0.007606960663715056 15 5 8 5 + 0.0006411202605107689 15 5 9 6 + -0.003980467653867634 15 5 11 2 + -0.003336662789570652 15 5 11 8 + -0.008044159008872174 15 5 12 6 + -0.007111530115937487 15 5 13 1 + 0.009598565795186314 15 5 13 3 + 0.002248493390622319 15 5 13 9 + 0.006349167183720431 15 5 13 12 + 0.01595061708813342 15 5 15 5 + -0.03025944787330322 15 6 5 1 + -0.002283795877970493 15 6 5 3 + 0.0178229666524834 15 6 6 2 + -0.00795952458360292 15 6 8 6 + -0.008584718985450152 15 6 9 5 + -0.003974250221986837 15 6 11 1 + 0.01389542184326985 15 6 11 3 + 0.01460042637259149 15 6 11 9 + -0.01445810525781787 15 6 12 5 + 0.02176561968567571 15 6 12 11 + -0.005276650427334219 15 6 13 2 + -0.01096677516645306 15 6 13 8 + 0.02442543164267973 15 6 15 6 + -0.03025944787330321 15 7 4 1 + -0.002283795877970462 15 7 4 3 + 0.01782296665248336 15 7 7 2 + -0.007959524583603049 15 7 8 7 + -0.008584718985450141 15 7 9 4 + -0.003974250221986842 15 7 10 1 + 0.01389542184326985 15 7 10 3 + 0.01460042637259146 15 7 10 9 + -0.01445810525781787 15 7 12 4 + 0.02176561968567567 15 7 12 10 + -0.005276650427334242 15 7 14 2 + -0.01096677516645285 15 7 14 8 + 0.02442543164267975 15 7 15 7 + -0.0924307240911155 15 8 1 1 + -0.03067928196580939 15 8 2 2 + 0.02450023639187779 15 8 3 1 + -0.03494376669011357 15 8 3 3 + -0.05762671066981698 15 8 4 4 + -0.057626710669817 15 8 5 5 + -0.04083690103752287 15 8 6 6 + -0.04083690103752402 15 8 7 7 + 2.102115738229499e-15 15 8 8 1 + 0.02213345507178682 15 8 8 2 + -1.765607928560978e-15 15 8 8 3 + -0.005819208475255151 15 8 8 8 + 0.01100119904847704 15 8 9 1 + 1.002191395941522e-15 15 8 9 2 + -0.02412098488203195 15 8 9 3 + -2.003432149056456e-15 15 8 9 8 + -0.02631368844743107 15 8 9 9 + -0.01915040921121656 15 8 10 4 + -0.04102690820299756 15 8 10 10 + -0.0191504092112165 15 8 11 5 + -0.0410269082029973 15 8 11 11 + 0.009165596289369572 15 8 12 1 + 1.213890927747704e-15 15 8 12 2 + 0.007014069022724971 15 8 12 3 + -3.23777466944977e-15 15 8 12 8 + -0.02019558260908361 15 8 12 9 + -0.02637353118408428 15 8 12 12 + -0.02681726541558315 15 8 13 6 + 1.30107484958257e-15 15 8 13 11 + -0.03611916811946701 15 8 13 13 + -0.02681726541558171 15 8 14 7 + 1.471798756202369e-15 15 8 14 10 + -0.03611916811946921 15 8 14 14 + -0.001652696170450979 15 8 15 2 + 1.335990754032636e-15 15 8 15 3 + 0.0218479269683841 15 8 15 8 + -0.02546830526879993 15 9 2 1 + -0.05336303325780448 15 9 3 2 + 0.04109554329063003 15 9 6 5 + 0.04109554329063016 15 9 7 4 + 0.01815219511843496 15 9 8 1 + -1.053895829077056e-15 15 9 8 2 + -0.01471802089962576 15 9 8 3 + 2.418961336263387e-15 15 9 8 8 + 0.004706010546922384 15 9 9 2 + 0.02114616881365863 15 9 9 8 + 0.02220291793541937 15 9 10 7 + 0.02220291793541935 15 9 11 6 + 0.02687205638132724 15 9 12 2 + -0.02599256232701278 15 9 12 8 + -1.120787010719512e-15 15 9 12 12 + 0.02753814454077633 15 9 13 5 + 0.04124762665224765 15 9 13 11 + 0.02753814454077623 15 9 14 4 + 0.0412476266522479 15 9 14 10 + -0.02203548374492184 15 9 15 1 + 0.04618908814705567 15 9 15 3 + 0.0306885869145945 15 9 15 9 + -0.01532423648385693 15 10 4 2 + 0.005282170322131661 15 10 7 1 + 0.01902638379796371 15 10 7 3 + 0.001335494565586746 15 10 8 4 + 0.002372387197577185 15 10 9 7 + -0.0005601547779748133 15 10 10 2 + 0.001764123519820467 15 10 10 8 + 0.003052306408875617 15 10 12 7 + -0.003671631344471829 15 10 14 1 + 0.002416384554203166 15 10 14 3 + 0.006589065645297271 15 10 14 9 + -0.01659318229326026 15 10 14 12 + 0.002118633372270245 15 10 15 4 + 0.01728983383512368 15 10 15 10 + -0.01532423648385693 15 11 5 2 + 0.00528217032213167 15 11 6 1 + 0.01902638379796371 15 11 6 3 + 0.001335494565586758 15 11 8 5 + 0.002372387197577171 15 11 9 6 + -0.0005601547779748177 15 11 11 2 + 0.001764123519820453 15 11 11 8 + 0.00305230640887563 15 11 12 6 + -0.003671631344471817 15 11 13 1 + 0.002416384554203197 15 11 13 3 + 0.006589065645297271 15 11 13 9 + -0.01659318229326026 15 11 13 12 + 0.002118633372270238 15 11 15 5 + 0.01728983383512368 15 11 15 11 + 0.05509345738141417 15 12 2 1 + 0.1364678514912272 15 12 3 2 + -0.09273551224350647 15 12 6 5 + -0.09273551224350657 15 12 7 4 + -0.02625814730722659 15 12 8 1 + 1.592071814197265e-15 15 12 8 2 + 0.02029315643215096 15 12 8 3 + -9.703115627392411e-15 15 12 8 8 + -0.002770397420757454 15 12 9 2 + -0.05488084151676324 15 12 9 8 + -0.02504309200063039 15 12 10 7 + -0.02504309200063028 15 12 11 6 + -0.0544680805314228 15 12 12 2 + 0.04435234780419385 15 12 12 8 + -0.03731432641061377 15 12 13 5 + -0.0816082299278978 15 12 13 11 + -0.03731432641061365 15 12 14 4 + -0.0816082299278979 15 12 14 10 + 0.01893878124971229 15 12 15 1 + -0.08152660231786792 15 12 15 3 + 4.662249907619488e-15 15 12 15 8 + -0.03716508764284014 15 12 15 9 + 0.09819087994775232 15 12 15 12 + 0.00451847984096453 15 13 5 1 + 0.02013927846579784 15 13 5 3 + -0.02287991149439415 15 13 6 2 + -0.001575258919952063 15 13 8 6 + 0.00829896076112089 15 13 9 5 + -0.007478508142297292 15 13 11 1 + 0.001553933597459135 15 13 11 3 + -0.001323839896357677 15 13 11 9 + 0.005515839829751486 15 13 12 5 + -0.02362774394156145 15 13 12 11 + 0.002215844806292582 15 13 13 2 + 0.007294540640154988 15 13 13 8 + -0.002514255323290775 15 13 15 6 + 0.02357983866044654 15 13 15 13 + 0.004518479840964569 15 14 4 1 + 0.02013927846579784 15 14 4 3 + -0.02287991149439416 15 14 7 2 + -0.001575258919951893 15 14 8 7 + 0.008298960761120907 15 14 9 4 + -0.007478508142297288 15 14 10 1 + 0.001553933597459102 15 14 10 3 + -0.001323839896357678 15 14 10 9 + 0.005515839829751527 15 14 12 4 + -0.02362774394156146 15 14 12 10 + 0.00221584480629263 15 14 14 2 + 0.007294540640154745 15 14 14 8 + -0.00251425532329083 15 14 15 7 + 0.02357983866044661 15 14 15 14 + 0.5888362159727467 15 15 1 1 + 0.5226357441174675 15 15 2 2 + -0.04738527973015375 15 15 3 1 + 0.5452324477874863 15 15 3 3 + 0.5125552369937889 15 15 4 4 + 0.5125552369937889 15 15 5 5 + 0.4818138570767732 15 15 6 6 + 0.4818138570767739 15 15 7 7 + -1.424863144494648e-15 15 15 8 1 + -0.06033677732581991 15 15 8 2 + 1.24355490582272e-15 15 15 8 3 + 0.364863153452819 15 15 8 8 + -0.04700187297971079 15 15 9 1 + 0.07383601952592586 15 15 9 3 + 1.939090452742828e-15 15 15 9 8 + 0.3968744670154452 15 15 9 9 + 0.1112506145950965 15 15 10 4 + 0.4422271495783164 15 15 10 10 + 0.1112506145950963 15 15 11 5 + 0.4422271495783161 15 15 11 11 + -0.05482504152864644 15 15 12 1 + -0.09960549503384478 15 15 12 3 + 1.447512116327338e-15 15 15 12 8 + 0.008378882630141344 15 15 12 9 + 0.4510636656674261 15 15 12 12 + 0.1279685001286668 15 15 13 6 + 0.4562947593175627 15 15 13 13 + 0.1279685001286661 15 15 14 7 + 0.4562947593175631 15 15 14 14 + -0.08782987266323351 15 15 15 2 + -0.04704785735754439 15 15 15 8 + 0.5611472592729118 15 15 15 15 + 0.04754974087521629 16 1 2 1 + 0.05066412723300744 16 1 3 2 + -0.07138564783720869 16 1 6 5 + -0.07138564783720878 16 1 7 4 + -0.04740031987765951 16 1 8 1 + 1.003211350129202e-15 16 1 8 2 + 0.008313980857567418 16 1 8 3 + -1.401948397472586e-14 16 1 8 8 + 0.002364366534097741 16 1 9 2 + -0.002580595991342075 16 1 9 8 + -0.04815731557139715 16 1 10 7 + -0.04815731557139705 16 1 11 6 + -0.04081258522196578 16 1 12 2 + 0.02346865824993675 16 1 12 8 + -0.06066083175298818 16 1 13 5 + -0.06443535314817342 16 1 13 11 + -0.06066083175298809 16 1 14 4 + -0.06443535314817335 16 1 14 10 + 0.05364758399556558 16 1 15 1 + -0.06318427887987718 16 1 15 3 + 6.30990073027696e-15 16 1 15 8 + -0.03687363171974134 16 1 15 9 + 0.03068465040733496 16 1 15 12 + -3.150257832373882e-15 16 1 15 15 + 0.08508703902178139 16 1 16 1 + 0.07878529408254563 16 2 1 1 + 0.03578420427666056 16 2 2 2 + -0.01885157859851253 16 2 3 1 + 0.03884809950421694 16 2 3 3 + 0.04943457232940395 16 2 4 4 + 0.04943457232940395 16 2 5 5 + 0.03720652674804684 16 2 6 6 + 0.03720652674804677 16 2 7 7 + -0.01646337718967937 16 2 8 2 + 0.02045518467997691 16 2 8 8 + -0.01476936147829247 16 2 9 1 + 0.01674934954825139 16 2 9 3 + 0.02169753928351671 16 2 9 9 + 0.03230478576248436 16 2 10 4 + 0.03272889726767521 16 2 10 10 + 0.03230478576248424 16 2 11 5 + 0.03272889726767548 16 2 11 11 + -0.01665466847536994 16 2 12 1 + -0.0155091329490265 16 2 12 3 + 0.00227813627756481 16 2 12 9 + 0.02530412211824514 16 2 12 12 + 0.03616940357650335 16 2 13 6 + 0.03775785478108273 16 2 13 13 + 0.03616940357650358 16 2 14 7 + 0.03775785478108232 16 2 14 14 + -0.009512872492070208 16 2 15 2 + -0.01176080309533684 16 2 15 8 + 0.04588291289681454 16 2 15 15 + 0.02027866045096046 16 2 16 2 + -0.0204858689153179 16 3 2 1 + -0.02954567093354679 16 3 3 2 + 0.03369742074016061 16 3 6 5 + 0.03369742074016075 16 3 7 4 + 0.01849317348025143 16 3 8 1 + -2.337947068968215e-15 16 3 8 2 + -0.007631838629009745 16 3 8 3 + 1.124590816503284e-14 16 3 8 8 + 0.0009693404036978086 16 3 9 2 + 0.006767142743383332 16 3 9 8 + 0.01020322863962801 16 3 10 7 + 0.010203228639628 16 3 11 6 + 0.01054255752056294 16 3 12 2 + -0.01015258004043366 16 3 12 8 + 0.01638595063423207 16 3 13 5 + 0.03065481514735076 16 3 13 11 + 0.01638595063423194 16 3 14 4 + 0.03065481514735099 16 3 14 10 + -0.02561093916619582 16 3 15 1 + 0.02474257804124047 16 3 15 3 + -4.015046311440693e-15 16 3 15 8 + 0.01631317802151091 16 3 15 9 + -0.02049446913197003 16 3 15 12 + 2.518818487118324e-15 16 3 15 15 + -0.03118151229159045 16 3 16 1 + -2.867295259716347e-15 16 3 16 2 + 0.02009765746216917 16 3 16 3 + 0.01093148667687619 16 4 4 2 + -0.0159595493694262 16 4 7 1 + 0.001252907295878571 16 4 7 3 + -0.01185442749082831 16 4 8 4 + 0.001548279453137327 16 4 9 7 + 0.01324684559486278 16 4 10 2 + -0.009025134366227558 16 4 10 8 + 0.01355826078512428 16 4 12 7 + -0.01956136325876803 16 4 14 1 + -0.003766630416723935 16 4 14 3 + 0.003540278368507793 16 4 14 9 + 0.004381199543892442 16 4 14 12 + 0.004156779657657476 16 4 15 4 + 0.009360179577992537 16 4 15 10 + 0.02201007696467926 16 4 16 4 + 0.01093148667687619 16 5 5 2 + -0.01595954936942617 16 5 6 1 + 0.001252907295878571 16 5 6 3 + -0.01185442749082833 16 5 8 5 + 0.00154827945313734 16 5 9 6 + 0.01324684559486277 16 5 11 2 + -0.009025134366227512 16 5 11 8 + 0.01355826078512426 16 5 12 6 + -0.01956136325876803 16 5 13 1 + -0.003766630416723923 16 5 13 3 + 0.003540278368507751 16 5 13 9 + 0.004381199543892425 16 5 13 12 + 0.004156779657657487 16 5 15 5 + 0.009360179577992537 16 5 15 11 + 0.02201007696467921 16 5 16 5 + -0.01784142870614424 16 6 5 1 + 0.00643602345941146 16 6 5 3 + 0.002952791268262128 16 6 6 2 + -0.009938615342536899 16 6 8 6 + 0.005229312932773657 16 6 9 5 + -0.0187324425446103 16 6 11 1 + -0.004390889032713494 16 6 11 3 + -0.001110555755610752 16 6 11 9 + 0.01523896160801917 16 6 12 5 + -0.003841997665240205 16 6 12 11 + 0.01624871589049986 16 6 13 2 + -0.007143290506388999 16 6 13 8 + -0.002768056319380716 16 6 15 6 + 0.01417310201428625 16 6 15 13 + 0.02289979965183728 16 6 16 6 + -0.01784142870614432 16 7 4 1 + 0.006436023459411426 16 7 4 3 + 0.002952791268262227 16 7 7 2 + -0.009938615342536728 16 7 8 7 + 0.005229312932773643 16 7 9 4 + -0.01873244254461034 16 7 10 1 + -0.004390889032713493 16 7 10 3 + -0.00111055575561069 16 7 10 9 + 0.0152389616080192 16 7 12 4 + -0.003841997665240112 16 7 12 10 + 0.0162487158904999 16 7 14 2 + -0.007143290506389293 16 7 14 8 + -0.002768056319380741 16 7 15 7 + 0.01417310201428629 16 7 15 14 + 0.02289979965183762 16 7 16 7 + -0.1407212768767965 16 8 1 1 + 2.079277954188646e-15 16 8 2 1 + -0.06991245387268401 16 8 2 2 + 0.03182443297932339 16 8 3 1 + -0.07660703034673567 16 8 3 3 + -0.0929971341104211 16 8 4 4 + -0.09299713411042132 16 8 5 5 + -0.07447215480573277 16 8 6 6 + 1.418913112035805e-15 16 8 7 4 + -0.0744721548057293 16 8 7 7 + -1.235496650450857e-14 16 8 8 1 + 0.03058385024012861 16 8 8 2 + -2.807618449520703e-15 16 8 8 3 + -0.02162514696570199 16 8 8 8 + 0.02292707768165599 16 8 9 1 + -3.251211823944972e-15 16 8 9 2 + -0.03305362734233186 16 8 9 3 + 1.198113803374731e-14 16 8 9 8 + -0.04047120735154422 16 8 9 9 + -0.0436136845792128 16 8 10 4 + -0.06660155569040506 16 8 10 10 + -0.04361368457921235 16 8 11 5 + 1.463491660010121e-15 16 8 11 6 + -0.06660155569040617 16 8 11 11 + 0.02249343448980179 16 8 12 1 + 0.02283701299315213 16 8 12 3 + -2.51805614312191e-15 16 8 12 8 + -0.0141620101163715 16 8 12 9 + -0.05196836611442802 16 8 12 12 + -0.05003984710396388 16 8 13 6 + -2.531158421807263e-15 16 8 13 11 + -0.07057045222541083 16 8 13 13 + -0.05003984710396864 16 8 14 7 + -1.216273631049413e-15 16 8 14 10 + -0.07057045222540506 16 8 14 14 + 3.79844221080359e-15 16 8 15 1 + 0.01216215746575668 16 8 15 2 + 3.067028103237474e-15 16 8 15 3 + 0.02553272980478118 16 8 15 8 + -1.184736758566405e-14 16 8 15 9 + -0.08945000627081254 16 8 15 15 + -1.885148753175887e-14 16 8 16 1 + -0.02268601333133103 16 8 16 2 + -6.982787611444669e-15 16 8 16 3 + 0.04364362361703802 16 8 16 8 + -0.02328740596505909 16 9 2 1 + -0.0341445044705503 16 9 3 2 + 0.03789323894263637 16 9 6 5 + 0.03789323894263621 16 9 7 4 + 0.01990141487515895 16 9 8 1 + -1.769783988096733e-15 16 9 8 2 + -0.01237780914110229 16 9 8 3 + 2.487937102691625e-14 16 9 8 8 + 0.003232605014997546 16 9 9 2 + 0.0201751912812144 16 9 9 8 + 0.0137717600085071 16 9 10 7 + 0.01377176000850698 16 9 11 6 + 0.01296667359171537 16 9 12 2 + -0.01915028448904604 16 9 12 8 + -1.59564548212461e-15 16 9 12 9 + 0.0208729992628594 16 9 13 5 + 0.03662416839527009 16 9 13 11 + 0.02087299926285967 16 9 14 4 + 0.03662416839527043 16 9 14 10 + -0.02635727351133685 16 9 15 1 + 1.153001801588478e-15 16 9 15 2 + 0.02772220207190784 16 9 15 3 + -1.343675923343791e-14 16 9 15 8 + 0.02008476535573606 16 9 15 9 + -0.02498675818995541 16 9 15 12 + 6.286637876939949e-15 16 9 15 15 + -0.0346223583056286 16 9 16 1 + -2.808777214152596e-15 16 9 16 2 + 0.0170445544789866 16 9 16 3 + 4.15319597915637e-14 16 9 16 8 + 0.02380874268885576 16 9 16 9 + 0.02769440758746226 16 10 4 2 + -0.02673016631071906 16 10 7 1 + -0.0161557132592215 16 10 7 3 + -0.01638813739815387 16 10 8 4 + -0.0007699984003947267 16 10 9 7 + 0.007442968458760703 16 10 10 2 + -0.009889489083785945 16 10 10 8 + 0.001554393503338174 16 10 12 7 + -0.01735043648355827 16 10 14 1 + 0.002753286902048062 16 10 14 3 + 0.001494807418268969 16 10 14 9 + 0.02335754497241757 16 10 14 12 + 0.01404471420438996 16 10 15 4 + -0.006396325132918946 16 10 15 10 + 0.01091245741709193 16 10 16 4 + 0.0277313078959266 16 10 16 10 + 0.02769440758746226 16 11 5 2 + -0.02673016631071906 16 11 6 1 + -0.01615571325922149 16 11 6 3 + -0.01638813739815391 16 11 8 5 + -0.0007699984003947657 16 11 9 6 + 0.007442968458760724 16 11 11 2 + -0.009889489083785927 16 11 11 8 + 0.00155439350333822 16 11 12 6 + -0.01735043648355834 16 11 13 1 + 0.002753286902048006 16 11 13 3 + 0.001494807418269107 16 11 13 9 + 0.02335754497241761 16 11 13 12 + 0.01404471420438998 16 11 15 5 + -0.006396325132918912 16 11 15 11 + 0.01091245741709197 16 11 16 5 + 0.02773130789592675 16 11 16 11 + -0.03222053773764886 16 12 2 1 + -0.04825017259262916 16 12 3 2 + 0.0533838638975611 16 12 6 5 + 0.05338386389756125 16 12 7 4 + 0.02303025246046144 16 12 8 1 + -4.509262430078913e-15 16 12 8 2 + -0.003494809294692472 16 12 8 3 + 3.84297303606773e-14 16 12 8 8 + -0.001519629208699993 16 12 9 2 + 0.01384026476000111 16 12 9 8 + 1.776653005017684e-15 16 12 9 9 + 0.01460262989473362 16 12 10 7 + 0.01460262989473362 16 12 11 6 + 0.01891237059503479 16 12 12 2 + -0.01498043615347002 16 12 12 8 + -1.457920716678454e-15 16 12 12 9 + -3.051532156117631e-15 16 12 12 12 + 0.02386454932121355 16 12 13 5 + 0.04683595810183153 16 12 13 11 + 1.383016952962567e-15 16 12 13 13 + 0.02386454932121322 16 12 14 4 + 0.04683595810183153 16 12 14 10 + 1.276115389668579e-15 16 12 14 14 + -0.02179737382377572 16 12 15 1 + 1.856803597162178e-15 16 12 15 2 + 0.0264119391333841 16 12 15 3 + -1.25333291974904e-14 16 12 15 8 + 0.01288433222568699 16 12 15 9 + -0.03421263480964471 16 12 15 12 + 3.604755383079805e-15 16 12 15 15 + -0.02855049523302051 16 12 16 1 + -5.219375524274725e-15 16 12 16 2 + 0.01651322398521536 16 12 16 3 + 4.362257616865854e-14 16 12 16 8 + 0.01542447990351162 16 12 16 9 + 0.02682900793297205 16 12 16 12 + -0.05668006138333965 16 13 5 1 + -0.0161562579681439 16 13 5 3 + 0.0458493427584348 16 13 6 2 + -0.02133831631236967 16 13 8 6 + -0.01242301321668599 16 13 9 5 + -0.01829474708738727 16 13 11 1 + 0.007411196438025029 16 13 11 3 + 0.0195624809948784 16 13 11 9 + -0.00273197443016854 16 13 12 5 + 0.04251675853009274 16 13 12 11 + 0.01216894721678041 16 13 13 2 + -0.02205337167814066 16 13 13 8 + 0.02403042546124195 16 13 15 6 + -0.008850108812868383 16 13 15 13 + 0.007384989569455208 16 13 16 6 + 0.04513224232659596 16 13 16 13 + -0.05668006138333961 16 14 4 1 + -0.01615625796814387 16 14 4 3 + 0.04584934275843478 16 14 7 2 + -0.02133831631236992 16 14 8 7 + -0.01242301321668604 16 14 9 4 + -0.01829474708738724 16 14 10 1 + 0.007411196438025063 16 14 10 3 + 0.01956248099487841 16 14 10 9 + -0.002731974430168641 16 14 12 4 + 0.04251675853009265 16 14 12 10 + 0.01216894721678029 16 14 14 2 + -0.02205337167814028 16 14 14 8 + 0.02403042546124205 16 14 15 7 + -0.00885010881286854 16 14 15 14 + 0.00738498956945486 16 14 16 7 + 0.04513224232659604 16 14 16 14 + 0.1569633113847971 16 15 1 1 + 0.05787714956534407 16 15 2 2 + -0.04994490156642798 16 15 3 1 + 0.07686411480382442 16 15 3 3 + 0.08303790680849328 16 15 4 4 + 0.08303790680849335 16 15 5 5 + 0.06081298889881077 16 15 6 6 + 0.06081298889880927 16 15 7 7 + 5.310399066097946e-15 16 15 8 1 + -0.0231604828365148 16 15 8 2 + 2.712708624576935e-15 16 15 8 3 + 0.03639814722352972 16 15 8 8 + -0.03902419268036143 16 15 9 1 + 1.59899267460415e-15 16 15 9 2 + 0.0351701600430642 16 15 9 3 + -4.436474560991833e-15 16 15 9 8 + 0.04604524611495352 16 15 9 9 + 0.0525136519141776 16 15 10 4 + 0.05544937108918365 16 15 10 10 + 0.05251365191417747 16 15 11 5 + 0.05544937108918409 16 15 11 11 + -0.02729364114267291 16 15 12 1 + -0.02046989051649213 16 15 12 3 + 3.954528327059162e-15 16 15 12 8 + 0.004497148195492229 16 15 12 9 + 0.04149040805239823 16 15 12 12 + 0.05596924463339107 16 15 13 6 + 0.0635965839010509 16 15 13 13 + 0.05596924463339334 16 15 14 7 + 0.06359658390104776 16 15 14 14 + -1.950499113974221e-15 16 15 15 1 + -0.01336194832617421 16 15 15 2 + -1.272433537729245e-15 16 15 15 3 + -0.0252597323102154 16 15 15 8 + 4.745472317309655e-15 16 15 15 9 + -1.032702527524231e-15 16 15 15 12 + 0.0930165819216586 16 15 15 15 + 8.703197119210286e-15 16 15 16 1 + 0.03023672607424808 16 15 16 2 + 4.801543401410668e-15 16 15 16 3 + -0.04266373857922931 16 15 16 8 + -8.944651560152458e-15 16 15 16 9 + 4.54937645014102e-15 16 15 16 12 + 0.06578256216923312 16 15 16 15 + 0.6095177502791381 16 16 1 1 + 3.413477667354715e-15 16 16 2 1 + 0.4514856598796156 16 16 2 2 + -0.07283207717602366 16 16 3 1 + 0.4694776049347383 16 16 3 3 + 0.499413913175186 16 16 4 4 + 0.4994139131751858 16 16 5 5 + 0.4561590215966879 16 16 6 6 + 1.668732234451617e-15 16 16 7 4 + 0.4561590215966919 16 16 7 7 + -2.137924509739039e-14 16 16 8 1 + -0.0645202770416191 16 16 8 2 + -5.628194789149302e-15 16 16 8 3 + 0.3505526213192748 16 16 8 8 + -0.05255663699969248 16 16 9 1 + -4.88449799296871e-15 16 16 9 2 + 0.07246707264790894 16 16 9 3 + 2.338442757089573e-14 16 16 9 8 + 0.388479126897645 16 16 9 9 + 0.09884064916343566 16 16 10 4 + 0.4293099836227132 16 16 10 10 + 0.09884064916343638 16 16 11 5 + 1.741943194642991e-15 16 16 11 6 + 0.4293099836227113 16 16 11 11 + -0.0489141873120035 16 16 12 1 + -0.05002398657977705 16 16 12 3 + -7.816833871831079e-15 16 16 12 8 + 0.0299487240229355 16 16 12 9 + 0.4061588202601188 16 16 12 12 + 0.1158501412475767 16 16 13 6 + -3.710521830287963e-15 16 16 13 11 + 0.4362464030193691 16 16 13 13 + -1.1187828317558e-15 16 16 14 4 + 0.1158501412475714 16 16 14 7 + -1.418465610520137e-15 16 16 14 10 + 0.4362464030193751 16 16 14 14 + 7.77876570191495e-15 16 16 15 1 + -0.02772008861884064 16 16 15 2 + 4.027542590396144e-15 16 16 15 3 + -0.05828834141623013 16 16 15 8 + -2.004025150191673e-14 16 16 15 9 + 0.493391201597973 16 16 15 15 + -2.887579115224201e-14 16 16 16 1 + 0.04957040081284462 16 16 16 2 + -1.198756349736642e-14 16 16 16 3 + -0.09244148681404396 16 16 16 8 + 3.20929905823288e-14 16 16 16 9 + -8.789410358037327e-15 16 16 16 12 + 0.09929387371351053 16 16 16 15 + 0.4988558024531632 16 16 16 16 + -6.683210272480665 1 1 0 0 + -5.05801991735896 2 2 0 0 + 0.5093740535790473 3 1 0 0 + -5.060718004401872 3 3 0 0 + -5.241594321289754 4 4 0 0 + -5.241594321289755 5 5 0 0 + -4.495352077885957 6 6 0 0 + 1.031276567087045e-15 7 1 0 0 + -4.495352077885959 7 7 0 0 + -1.852207064622862e-15 8 1 0 0 + 0.5862891072481656 8 2 0 0 + 5.217912372939835e-15 8 3 0 0 + -4.174967908523783e-15 8 4 0 0 + -3.004188106134393 8 8 0 0 + 0.353765259990788 9 1 0 0 + -0.6083289518389058 9 3 0 0 + 2.666971454264797e-15 9 8 0 0 + -3.157845111668903 9 9 0 0 + -0.9400165388605516 10 4 0 0 + 1.175322440382098e-15 10 8 0 0 + -3.516783993981039 10 10 0 0 + -0.9400165388605513 11 5 0 0 + -3.51678399398104 11 11 0 0 + 0.4229990555408695 12 1 0 0 + -1.905974893100913e-15 12 2 0 0 + 0.626081952156225 12 3 0 0 + 5.823279594237991e-15 12 8 0 0 + -0.2288000350163298 12 9 0 0 + -3.333008040651025 12 12 0 0 + -1.174115690312534 13 6 0 0 + 1.462965175656052e-15 13 11 0 0 + -3.451001907784892 13 13 0 0 + -1.174115690312534 14 7 0 0 + 2.097688254432345e-15 14 10 0 0 + -3.451001907784885 14 14 0 0 + 1.510890214156748e-15 15 1 0 0 + 0.4323970482854796 15 2 0 0 + -1.262860516547564e-15 15 3 0 0 + 1.982594591989286e-15 15 4 0 0 + 0.4973837150599378 15 8 0 0 + -4.330965086964359e-15 15 9 0 0 + -3.214794676707322e-15 15 12 0 0 + -3.961405744595176 15 15 0 0 + -0.4289222488017268 16 2 0 0 + 5.039051098775309e-15 16 3 0 0 + -3.293855240294314e-15 16 4 0 0 + 0.8512656679561205 16 8 0 0 + 5.29294696293402e-15 16 9 0 0 + 1.301363795748629e-15 16 10 0 0 + 2.727924913158556e-15 16 12 0 0 + -0.838369929881854 16 15 0 0 + -3.317587539899629 16 16 0 0 + -77.40622425962903 0 0 0 0 \ No newline at end of file diff --git a/docs/tutorials/01_getting_started_fermionic.ipynb b/docs/tutorials/01_getting_started_fermionic.ipynb new file mode 100644 index 0000000..44f6684 --- /dev/null +++ b/docs/tutorials/01_getting_started_fermionic.ipynb @@ -0,0 +1,531 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9e40af77-7f0f-4dd6-ab0a-420cf396050e", + "metadata": {}, + "source": [ + "# Improving energy estimation of a Fermionic Hamiltonian with SQD\n", + "\n", + "In this tutorial, we will show how to use the `sqd` package to post-process quantum samples using the [self-consistent configuration recovery technique](https://arxiv.org/abs/2405.05068).\n", + "\n", + "This technique can be done iteratively by repeating 4 steps:\n", + "\n", + "- Correct the full set of bitstring samples, using *a priori* knowledge of particle number and the most updated orbital occupancy information obtained from the ground state approximations at each iteration.\n", + " \n", + "- Probabilistically create batches of subsamples from corrected bitstrings.\n", + " \n", + "- Project and diagonalize the molecular Hamiltonian over each sampled subspace.\n", + " \n", + "- Save the minimum ground state energy found across all batches and update the avg orbital occupancy.\n", + "\n", + "In this tutorial we implement a [Qiskit patterns](https://docs.quantum.ibm.com/guides/intro-to-patterns) for post-processing quantum samples to find good ground state approximations:\n", + "1. **Map** problem to a quantum circuit\n", + "2. **Optimize** for target hardware\n", + "3. **Execute** on target hardware\n", + "4. **Post-process** results (using *SQD*)" + ] + }, + { + "cell_type": "markdown", + "id": "afeb054c", + "metadata": {}, + "source": [ + "## Step 1: Map problem to a quantum circuit\n", + "\n", + "In this tutorial, we will approximate the ground state energy of an $N_2$ molecule. First, we will specify the molecule and its properties. Next, we will create a [local unitary cluster Jastrow (LUCJ)](https://pubs.rsc.org/en/content/articlelanding/2023/sc/d3sc02516k) ansatz (quantum circuit) to generate samples from a quantum computer for ground state energy estimation." + ] + }, + { + "cell_type": "markdown", + "id": "a6755afb-ca1e-4473-974b-ba89acc8abce", + "metadata": {}, + "source": [ + "### Specify the molecule and its properties" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "677f54ac-b4ed-47e3-b5ba-5366d3a520f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parsing ../molecules/n2_fci.txt\n" + ] + } + ], + "source": [ + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "from pyscf import ao2mo, tools\n", + "\n", + "# Specify molecule properties\n", + "num_orbitals = 16\n", + "num_elec_a = num_elec_b = 5\n", + "open_shell = False\n", + "spin_sq = 0\n", + "\n", + "# Read in molecule from disk\n", + "mf_as = tools.fcidump.to_scf(\"../molecules/n2_fci.txt\")\n", + "hcore = mf_as.get_hcore()\n", + "eri = ao2mo.restore(1, mf_as._eri, num_orbitals)\n", + "nuclear_repulsion_energy = mf_as.mol.energy_nuc()" + ] + }, + { + "cell_type": "markdown", + "id": "96bfe018", + "metadata": {}, + "source": [ + "### Create the `LUCJ` Ansatz\n", + "\n", + "The `LUCJ` ansatz is a parameterized quantum circuit, and we will initialize it with `t2` and `t1` amplitudes obtained from a CCSD calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "66270387", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "converged SCF energy = -108.867773675638\n", + "E(CCSD) = -109.0935188821144 E_corr = -0.2257452064762984\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Overwritten attributes get_hcore get_ovlp of \n" + ] + } + ], + "source": [ + "from pyscf import cc\n", + "\n", + "mf_as.kernel()\n", + "mc = cc.CCSD(mf_as)\n", + "mc.kernel()\n", + "t1 = mc.t1\n", + "t2 = mc.t2" + ] + }, + { + "attachments": { + "lucj_ansatz_zig-zag-pattern-rsz.jpg": { + "image/jpeg": "/9j/4AAQSkZJRgABAQEBSgFKAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/2wBDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAARCAH0AsADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD+7f4pfFLwN8GfBGufET4i69aeHfCugW/n3t9clmkllc7LWwsLWIPc6hqd/OVt7DT7SOW5u53WONDyR+YF18bf2wP2pSdT+Gdxa/sr/BO+bfoniPW9GtvEfxg8Y6ZIGMGqQaZdsdM8O2F9EI5rYwy2V5AJUuLDWdbtZEkFD4h3P/DXn7WHiTSNbP8AaHwE/ZU1aLRLXw9ITJpHjf40SRv/AGzfavbY8m/tvCJjn0s2dwZY43t4wqvY+INVtpvsYAKAAAABgADAAHQAdgOgA4A4FfG4jF4nN69eNLEV8LlVCtUw0VhqkqGIzCrQm6eIqzxFNqtRwkKsZ0aUMPOnUruEq06vspU6b/qvIuG8i8McpymvmGR5VxF4j5xluBzzEy4hwOHzbJOCMuzXDUsfk+X4fIcbCrluacS4rLq+GzLM8TneGxuDyiOKw+W4bLo5jh8Zi4/Gp/ZF1u/IvfEP7WX7Wuq62fnbUbf4t3OmwJN1LWlidPvfscIYkpBHdMsYO0N3q3B4d/bU+BuNX+E/x6ufjxoVlmW5+GXx3gjvtW1O2Q5aDS/iAlxHqg1N0LLai6vdH0xJAsl19pVFgb53+Mv/AAWT/YC+BfxL8b/C7xh8T/GWtav8KdS/sf4yeI/ht8FvjB8U/h58GtVVd0+mfEz4geAPBXiDwr4c1KwIePWNO/tK6vtBuIbi11y3065tp4Y/0j8G+MvCfxE8JeGvHvgTxHo3i/wV4y0PS/E3hTxV4d1C21bQfEXh7WrOHUNJ1nSNTs5JbW+07UbKeG6tLqCR45YZFdWINY/2PQpxVWh9dwc3ZwxOHxeKpz5t4yk5VZU690m+XEQrQmrtwkrs9ReKOcZjKpgs3hwpxTgI3jicjzvhjhvG4H2SfJKnRhQy/D4zKnF+5HE5NistxmGkkqGJozird/8Asy/tY+DP2jLHWNHXStT8AfFjway2/wAQPhR4oPk+IvDtwGSJ760MkVsdY0GWd1SDVIba3kQyW66hZ2El3aJcfV1fjT+1J4O1vwTPon7WHwniWw+K3wVZNX1lIAYYPHfw4hwnijwx4hEW03dtb6S11dRTyb57exjv47Yi6/s6az/WL4c+OdE+JngLwf8AELw1K02g+NPDmj+JtLaTZ5yWmsWMF9Hb3CozLHd2vnG2vIQxMN1FNE3zIa9rJ8wxFadfL8e4yxmFhTqwrwioRxuEquUYYj2abUK0KkJUsVTh7kZ8lSCjTrQhH8m8U+B8kyvB5PxvwZSxGG4U4ixOMy3E5LisRPGYnhLibAUsPicZkjxtRKtjcpxeDxdDMeHsdif9rrYT63gMXPEY3KcVi8R2lePfG745/D/4AeC7nxt8QNSkt7TzVstH0iwjW617xNrMqs1toug6f5kbXl/OFLMXeK0tYQ9zfXNtaxvMvsDEBSSdoAOSe3v+FfkV4Hn/AOGovjj4s/aG8TH+0vh/8Pde1LwH8AdDuR5umRxaNMsetfEBbZv3E2oateok2n3bK8tu48l/32haXPB+ucB8LYLPcRmOaZ5PEUuGuHaFDE5p9UnCnjMxxWMqyo5XkeBq1IVIUMVmdWnXnPEzpVY4PLsHmONVKtUw9OhV/KsuwlPESq1sQ5RwuGjGdbksp1JTly0qFNvRTqtNuTT5KcKk0m4pG7P4o/bF/aD/AOJrdeKYf2W/h3efPpXhnw/YRa58U7+xcB4pdf1q9W0OgXMiMWjXTTpd5an9xe6QWjE8tT/hlbUGf7bL+07+1VJrH3v7THxbuVcS9Q6x/wBmM6oGAxF9oICgKGwM19aUV+p0+LcdgYrD5BgMk4by+Hu0sDlOT5fdU0korGZhjKGLzXNavKlz18zx2LqS6OMLQXqfXqkPdw1Ohhaa0VOjRp7f36k4zq1W0ld1Zyu72STsfK0Go/tkfAXGreGvHkP7TXgiyxJqXgfx3ZxaX8Q0sojumPh/xZamefVtS8lSy/2pLdbz+6s9DvbmVQ33P8Bv2gvAP7QnhOTxJ4LuLq1vtMuBpvivwnrMYtPE/hDWlDiTS9c08sXiJaKYWl5GXtL1YZhDL59vdwW/A18bfGFZ/wBnH4neGP2rfBcUlppB1TTPCfx90CxQra+JvBOt3kFhF4kltY9scmuaHePbeRccTXV1/ZQkkS2i1AXfNiMpyzxCjPLamWZblfGVaE3kOb5RgsNlWHzzHwjzUsiznLMDToZbLE5nyvDZbm2Fw2FxKzGpQp5lLF0K7rYROlSzJOk6VOljWm8PWowjSjXqJJqhXpU1GlzVbctKrCMJKo4qrzxd4/rzRVe0uoL21try1mjubW7giuba4hcSQz288aywzRSKSskcsbK6OpKsrBlJBFYPjTxboXgHwh4p8deKL6PTPDXgzw7rfivxDqUv+q0/Q/D2mXWrateycjK2thaXEzDPITHev58pUK9evSw1GjUq4itVhQpUKcJTrVK1SapwowpxTlKpOo1CMIpycmopNs+ZqVIUYVKlWUadOlGU6k5tRjThBOU5Tk7KMYxTcm7JJNs+Xf2w/wBtj4X/ALHnhXR7vxPaax43+Jfji7fR/hT8GvBkX2/x18RdeLRwx2+n2ccdw9ho9vc3FrHqeuT280dqbiK2srTVdXuLHSb38yruy/4KP/tRMfEHxc+P5/Y/8D6kfO0z4N/s92lvN48sdPkkYwx+KPircznU7PX1g2C6OiX19pUsh3/2PpE4ksoub/ZB0DXP2ivG/i//AIKDfGiya68efF291PTvgj4f1LF1B8Ivghpl5e6Z4e0rQoXzBZapr0AurnUtTtY0k1C1uZtSieGTxRrkdz9/+I/Efh/wf4e13xb4s1vSvDXhfwxpGpeIPEfiLXL+20vRdC0LRrObUdW1jV9TvZIbPT9N02wt7i8vr26mit7W2hlnmkSNGYf2FTyrIPBv/hAyvKchzvj7Loqnxfxln+W5fxFhsozqmv8Ab+H+EMrzWji8kweGyKtz4DGcSV8Di81zHMsPicVlmKy3LY4anV/CJYzNOPH/AGnjMbmWX8NYqSlkWQZZisTllbHYCT/2bM88xmCnQzCvWzGHLiaGVUsRRwWFwtWlSxdHFYr2k4fCf/DBmvWZbUND/bo/b203xJgumtzftA3t8GuMcSXdmNFtHu4SxYy273qiVWZGkAJJ2LP41f8ABQ/9jIrrfjDW7L9u74A6biTxGi6DaeD/ANobwfosfN1qml/2Z5+neNYNOiY3F0moya3q2omMq0vhywWfULfyf4Xf8Fkv2Afi58RPBnw68MfFPxbpk3xP8QJ4T+E3jnx18Gvi98PfhP8AFbxNLJJDa6H4A+J/jTwXong3W9R1G4ie10aB9VtP7eu2gtNDbUbm6tIp/wBRqqPiViOIaf1fizK+FePckm/ZYnAZvkWUU8TCEkuf+y+IcowmB4hyHFRpybo18rzLDxUnCVehiqCdGcy4RpZXNVclxec8M5hFKpRxOCzHHSoykn7v1vK8dWxGWZjRclapTxeEqSdpKFSjVXtI/Tf7Pn7Q3wp/af8AhhoXxc+DviW38SeEtcV4W+X7Pq2h6vbrGdR8O+I9LdjcaPr+ltLGt7YT7g0ctve2c13pt5ZXtz7bX89Nhe/8MDftsfD34l+FSNI/Zu/bG8XWHwp+NPhKDbbeHvCHxl1UzyeA/iPplspS10v+2bx7uHXWVUtYbH/hKL25MstzpUdh/QtX4V4q8CYDg7M8qzDh3E4vHcF8XZdPOeGMTj/ZvMsHCjiquBzXh/OJUYU6E83yDMKM8LXxFGnRpZjgqmXZxSw+Fo5lTw1L9I4L4kxOfYPG4XNaVHD5/keKjgM4pYbnWFryqUYYjB5pgY1HKpHA5nhqka1OlUnOeFxEMVgZ1Ks8JKrMJwCfSvz8/bI/b78Jfsxah4e+Fvgvwhqvxw/aY+INuZPAHwT8JXCR3v2RzKo8UeN9WEVzH4T8JweRcyfbbmCS5vls7uSCGHTLHV9Y0r6Q/aY+Ofh79mr4DfFL45eJ41uNL+HPhLUNcj08zC3bWdZby9P8N+H4p2BWGfxD4ivdL0S3lYERzX8blWCkV+P/AOxN8HPEGneH9Y/aY+NMn/CRftKftJPH498e+Ir+Efa/Dnh/WlgvvDHw90OOQu2iaLomjrpa3Gk2xjS3uYLXSXM1j4f0hbf3/CngXIcZleaeIXG+GrZjwzk2YUskyXhyjiK2ClxhxVUw8cdUwOKx2HlDFYPh/I8vnQx/ENbBVKWYVvr+UZXga+Eq5pLMcB5nGvEeZUMZg+F+Hq0MLm+Pws8wzDNJ0oYhZFk0av1aOJo4eqpUa+Z5hiVUw2WU8RGeGp/V8Zi69OvDCrDV6Nx8M/8AgoD+0G39v/tDftheIfgdpt+RND8IP2UIE8FxeHreZQ32G5+JjyzeI9RvIsiK7juZvEdisySNY6rNbupqmn7CvjDQSdR8A/t3ftz+GvESkSw6hq3xtuPE+lSTqQytqegvpekw6rAWCmS1uLxY5ANrkg190+J/E/hzwV4c13xf4w17R/C3hTwxpOoa/wCJPEniDUbTR9C0HRNJtZb7U9X1fVb+WCy07TtPs4Jrq8vLqaKC3gieWWRUUkfKv7I/7fP7K/7dEHxDuv2YviLffEG2+Ft/4b07xnPeeBPiB4ISxl8Yadfav4XuLEePfC/hmTWtO1zSdPn1TTtT0dL6wuNPe1u1uPJvbV5v1mPinxBg508BlMeFeHsFyS+r8P5LwhwpgssWHjo4VMFPKa1TM4292riM2qZjisTq8Xia83KT+IfBmWV4vFY15zmmIUkquaZhnec18W6slfmjiI42nDCydrxpYKGFo0tFRpU42RhaX+11+25+xPcQXX7Udtpv7WX7N8E0cGrfGz4eeG7fwx8YPh1pxZUGseNfBNh5ei67olpGoN3cWW6dIxLe6n4q+1G10y8/bP4bfEjwP8XvAvhn4lfDfxJpni/wR4v0yHV/D3iHSJjNZX9nNuRuHWOe1u7WdJrPUNPvIoL/AE2/t7mwv7a2vLaeCP4quLeC7gmtbqCG5tbmKS3ube4iSa3uIJkaOaGeGRWjlhljZkljdWR0ZlZSpIr4c/ZQ1af9h79t2P8AZntbiS2/Zm/a8t/EfjT4N6RNI39nfDT41eG7VL3xZ4Q0gyP5dnoXibSEheztAFX7dceFdMsY/Ot9SuL3wOJ+FuH/ABKyDO81yfIsq4Z8ReGsrxvEOIwvDuDpZXw/xvkGVUJYvPpU8gwsYZfknE2SZdTxGdL+xKOCyjNcpwWY05ZZhszw9GtmHp5PnOacI5nl2Cx2Y43N+Fs2xlDK6VbNK88ZmfD2ZYypGjlqnmVZvE5hlGYYqdPAP6/UxGMwOMr4WSxVTCVJ08P++FITgZpa+J/+Cgn7Tt3+yf8Asx+NfiP4et49Q+I2sT6Z8PvhHpDxpctqvxM8ZzPp/h1VspMLfro8SX/ia508kG/stDubNSrTqy/zdwzw7mnF3EOScL5JQWIzbiDNMFlGXUpzVKnLFY/EQw9KVatL3KGHpyn7TEYidqdChCpWqNQhJr9ZzfNcHkeV5hnGYVHSwOWYPEY3FTjFzmqOHpyqSjTgtalWajyUqcfeqVJRhG8pJHjH7W//AAUPk+F/j8fs1/sy/D//AIaB/alvbKO81Hw5FeG08AfCbTLiOJ4de+K3iGGWFLLCXNrcxeG4b7Try4tp7c3uq6NLqOiRav8AHVx+z/8AtpfGh/7a/aR/bu+Kvhqa9LyP8Pf2XJYvhH4T0OORiw0yDxHa2yav4ktYlJj8/XtHe+ZRiW8uiPNb1P8AZI/Zys/2evhuIdauW8SfGDx/dN40+NfxC1CVtQ13xh491l5dR1U3WrzF7m703Sby+u7TSlZ1SXddatLENR1bUJZuj/aY/ar+An7H/wAPI/ih+0L8QLLwH4Wvdc07wroSf2brXiLxJ4t8Wax5v9k+FPBfg/wvp2s+KvF3iTUFguJoNI8P6RqF2lpbXWoXKQafaXV1D/VizThbw0jLKPDzAZHXnl/7jM/EjPcly3N8+4hxkGqeJxuTLO8PjsLwlkU66ksowuU4fDZvUwTpVM4zPF4itKhQ/Fngs54vlHHcUYnMYLFfvMJwpluPxeBy3LMPL3qWHx39n1cPXzrMY07PHV8bVq4KFbnjgsJQpU1UqeAx/sS/E7wljUPhJ+31+2h4S1+FvNgk8Y/E/wD4WV4XlnAJVtS8IX1noWn6mm8ktHdTspDMMEnNd34P/b4/ab/ZH1/RvC/7feg6H8RPg1q9/a6Npf7Wvwo0WWxTw9d3lytvZ/8AC3/AdhapDpiXDyxiTUvD2n2FtbnFvptr4pumna1xf2XP+Ci37Kv7Xvi/xP8ADX4TeMfE+mfFjwbotv4n8R/CL4q/Dfx98H/ibZeFbu6isrbxVa+EviN4e8PX+teHHuri1t59X0H+1LPTp73T4NUksp9Qso5/sjxJ4b0DxjoGseFfFOkWGv8AhzxBp11pOtaNqltHd6fqWnXsTQXVpdW8oZJIpYnZSCMqcMhV1Vg3xxgOLKawfiFkWR8aZHib0qmOw2V5Nk/FuWpvkli8h4ryrA4fH0sXhmuengc2lmmRV6lNU8bldWLcopcOYnI5uvwvmOY8P5jR9+OGq4zHY7JMXKykqOZZNjMRVw0qFZWUsTglg8whCXtKGLi7KX6IaJrekeJNH0rxD4f1TT9b0LXNOstX0bWNKu4NQ0zVdL1G3ju7DUdPvrV5ba8sr21miuLW6gkeGeGRJY3ZGBOnX4h/8E3vGWvfs5fHv4pf8E8/F2sXur+CtP0GT42/sr6vrFw899F8N9W1eS28VfDx7qV2a5fwxrc81zpcKqZ5I7PxTqTrBYS2Fpa/t5X85eJHBE+AeKcRklPHLN8pxOEwGd8N53Gi8PHOuHM4w8MZlWPlh3Kf1bFexnLCZngvaVPqGbYXH4B1aksM5y/VuE+Io8TZNSzCWHeCxtGviMvzXL3NVXgM1wNR0cZhlUSj7WjzpV8JX5Y/WMHWw+I5I+15UV+Z/wAef25/ETeONY+CH7J3hXSviT8R9BlNl45+IGvzTx/Cr4Z3RkaGSy1G8s3jm8Q+ILZo50n0ywuESzuoZLdV1i9stV0mz73/AIKA/G/xR8MPhZoPw/8AhneNZ/F749+Jofhr4IvIpWiuNAsbxEPivxbFIjLLAdD0y4htor6FhLpd/q1jqi5+xkH54+Evws8MfB3wRpPgnwtbqtvYxCXUtSkjVb/X9ZmRP7Q1vU5AWaW8vpV3YZ3S1t1gsrfZa20EafBn0p5hd/Cf9oLx+51H4w/tgfGq7v7gB5tG+E+rQfC3wxZu3P2aGx0a3a31CCD7kNzcadaXEiqryoJC2WWvwV+NPgp11D4U/thftBaJqdv+8gtPiB4li+JvhmaVACiXHh7WYbXTtshUJJK9tclU6QyBdjfTlFAHNfCb9uvx78P/ABXonwu/bM8PaF4bk8QXcWleD/j14Q86L4a+Ir9xtgsfFdvcgN4R1S4YZkvX+y6b5jPLNpekaTAdTk/VRWDKGUhlYAqw5BB5BB7gjkEcEcivyj8deB/DXxI8Kaz4L8XabFqmha5aPa3cEir5sL/et72zmKs1rqFjOEurK7jxJb3MUci524Pa/wDBO74q+KJdI+If7MfxI1WXWPHH7O+o6dp3h/XLtv8AS/FHwp1uB5/BWoyBneSa40i2jXTLpgWW0sZ9BtJ5JbwTyygH6UVDc3NvZ2893dzw2tpawy3N1c3EiQ29vbwI0s0880hWOKGGNWklkkZUjRWZiFBNTV+WX/BQr4heIPGfiL4b/sdeCNWutGn+K1pd+MPjBrWnSeXfaR8IdGuZLeTS4nAYxHxjqdreaaznCSCwTTLtJtP1i7joAwPiL+3L8VfjL4h1nwP+xjouiReFtFvJtI8Q/tG+OrSW58LC/hLC5tvh1oLROviK4tv3bRapf29/p85dfN0qDTrmw1m68dufgV8V/FjtffE39sD9pHxBqszeZMng/wAZD4eeHY5Dgt9j8NaZDqGnWqgghPIESheBGvQfQPhjwzoPgzw/pPhbwxplro+g6JZxWOmadZx7Ibe3iB6nl5ZpXLzXNzM0lxdXEktxcSyzyySNu0AfNNl8OP2lvhs41L4NftdfFW4urXEkXhr413sXxP8ADOo7SSbGaXU7d5dGtpgSslzpmmS3kYJaFkk2yJ9Yfs7fty3ninxrY/Av9pHwhafCT413qlfDN/Y3Mlx8OPiiqceb4N1S5lmksdTlPyp4fvby9lkfZbxX51SU6Pb4teQ/Gz4RaN8ZPBN54cvnOna7ZsNW8GeKLcvDqfhXxRZ/vdL1ewu4Ct1CqXKRpexwSI9xaF1Ro51gnhAP2Oor42/YX+POufHf4G2tz44xH8U/hvr2q/C74pQN5SSy+LfCphhfVniiIUHW9OmsdQupIo4bT+1n1W2s4xBaqB9k0AYfiXxLoHg3w/rHirxVq9hoHhzw/p9zquta1qlxHaafpun2cTTXN1dXEpCRxxopPUs7YRFZ2VT+R3ij9sb9on9pG+vbP9luwsPhB8H4rmezj+OXj7Q11TxV4tSCXyJ7zwH4N1CJ7G208usyRXGsQTyTooLX2hapBcaXFY/bT8T337Q37Qmgfso2V5cQ/Cv4ZaVpHxL+O6Wk8kH/AAkutX7w3fgnwFeSwMki2iWslpr1zAZAlyl610nlahodhMvpllZ2mnWdrp+n2tvY2Fjbw2dlZWkMdva2lpbRrDb21tbwqkUEEESJFDFGixxxqqIoUAUAfM037PPj3XW+2+Nv2uP2pte1dyXkn0f4l3PhfSI5CdxNhoMFvqNtp0e7kQ28+xRgLgAVpaf4c/a5+Ecg1X4N/tQ+K/HUNoRI3gL9oLHjrSdYhjwxsm8VOBrmlK+wJENLTTWJYK2oW0e9j9IUUAem/sv/ALaWj/GzW774U/Efwvc/CH9oDQLVrnVPh9q1ytxp/iSxgUmbX/AWsELFrmltGjXctorS3dnb+ZLBPq2n2s+q19x1+JP7Qvws1Hxr4fsfGvgS4m0L4zfC+5Xxd8MfFGnbYtTh1bSWF8dBkkIxc6frYhNqbS532gvHt5Z0ktvtdvc/p1+zB8brH9on4FfDz4tWkMNnd+JdG8vxDpkJPl6T4q0i4m0jxLp0au7zJbQ6xZXb6f8AaCJ5dMlsrhx++BIB75XAfFD4oeBvg14H134i/EbX7Tw34T8O232i/wBRuyzM7uwjtrGxtYle51DU76dkttP06zimu7y5kSGCJmPHf1+Jvxs1xv2sv2rfEPhrU3+2/An9lfVIdGj0Bj5mk+NfjVLE/wDbN7q0H+pvrbwdtn0f7FcCRYZ7ZgA9l4g1KCQA09a/aU/a4/abd734Uva/su/Be8JbRvEuuaNZ+JfjB4w0x93k6nBpl4X0nw3YX0QjmthA9tewCRLiw1zWrSRJBxT/ALN/ivUGF7r/AO1j+1nqesn531C3+L99p0CTHq1nYCyuxZwgkmOCO5ZYwdoYivqQDAAAwBwABgADoAKKAPnfTLj9tT4IOurfDH48XXx10KzJluvhr8d4I9T1PU7ZOWh034hJNFrKamyFktRc3ulaYkoWW6Fyii3P6Dfsv/tceCP2lNP1jSotN1LwD8V/BuyH4gfCjxORH4i8OzFkiN/ZSNDbDW/D0s7pHb6vBbW7oZbZNRstPku7NLjwGvlX9oTw/r/gS+0L9qb4Uqun/FT4MOusaksAMUHjn4ewZHinwr4gEWDd2aaQ95cRSvvnt7Vb2O023b2M1oAfu1RXFfDjx5ofxQ8AeDfiN4ZlaXQfG/hrRvE+lmQp50VprNhBfJbXKozLHeWnnG1vIdxMF1DNC2GRgO0JABJ4AGST2A6mgDxX49/tAfDX9m/wFefEH4l6s9nYJKtho2jafEt54i8Va3MjtaaD4b0wyRG/1K52MxLywWdlbpLe6hdWllDLcJ+X+sfFf9tj9o1n1MeKLb9kz4aXm5tJ8MeHNOh1/wCLmo6fIAYZ/EOv6glr/wAI7dSod6LpP9jXtmf9HvdJlaMXMvKaZrjftbftB+Mf2hfEb/2n8M/hhr+qfDz9njQZyJtJWPRp0TXviQtqc28+o63fpHcadesjSwDybdz53h3S54vqagD5bP7NniR5Pt037V37XUmtffOqj4z6ikgm+8HSP+z2dEVsFYhcYVQEDcA10mk+O/23P2eiureH/iFB+1P4EssSan4B+ItnFpXxHWxjIM7eG/GtkJ7rVdT8lWIOsyXysR5dpoN7dSjP0BRQB9Xfs6ftKfDf9pnwZJ4r8B3V3aahpN0NK8Y+C9ciWy8WeCdeUP5uk6/pu5jHuaGf7DfwtJZX6QTrDKLm1vbW1+gq/B34lahefsv/ABa8J/tb+CY5bbR11XSvCH7Qnh2wTba+LPAGuX1tYDxDLaR7Ul1/QLx7OSzuMedcXi6V50i2kOoJd/uzZ3lrqFpa39jcRXdle28N3Z3Vu6ywXNrcxrNBcQyKSskU0TpJG6kq6MrKSCKALNfMv7TP7VHw+/Zj8NadfeJItR8TeNfFVw+m/D74aeGo/tfizxrrGUjWGxtlSVrTTIJ5rdNR1eaGSK286KC2gv8AUriz0669/wDEviLSPCPhzX/Fev3aWGheGdF1TxBrV9LxHZ6To1jPqOo3UnT5Le0tppW56Ia/Dn4IR6z8c/Gfib9r74mW7zeJvH93fWHwr0W+xPD8OvhZp91dWOi6dpcbZittQ1SIXE9/fQIjXqTz6hG6Nr2pJKAdbqviH9tv49O2reOvi6P2b/Cd4fMsPhv8HLeGTxba2buxhXXviDPJ/aNvq6wlROdJu5tOlfEn9madKHto+fX9m3xNaub7TP2r/wBriz1rll1OT4y6hchpcfeuLf7BA1xEzEmSFrlRIpKFgCTX1JRQB4To/wAdv2zP2anTUfFWqWv7WXwjsyr6zG2k2vhr4y+HdMXJnvdNlsBJZ+KEs0Jmnj1A6rqN+U2eZotqJbyD9Ufgx8afh58ffAGkfEn4Za7FrnhvVg0TZXyNS0jUoFQ3uia5YMTNpmsWDSILm0lyrRyQXdpLc2F1aXc/xJXzT4T11v2Rf2ovB3jTRHGnfBX9pHxHZfD34o+H0Ih0fw/8RdRMv/CIeOLOEMlvYNe3b3EWsShVgisTrtzOJZriwFoAfuNRRXlPxy+K+i/A34RfED4s+IFE2neB/Dl7rAszKIW1PUvktdE0aKVsrHPrWtXNhpUDkELNeIxBANAHhf7Uf7Y3hb9nufRvA+gaBf8AxS+OXjGEyeDvhX4emVLxrYmRRr/inUPLuE8O+HIjDO32ueGS4uxbXLW8KWVnqWpad8G6lY/tkfGZzqvxc/aO1j4UafdkSxfDr9nyNfCqaRDIoP2WfxyZJdevblB8lwk9xrNoJQ5tL14WUVQ/Z08Ca4bLVvjp8UJf7a+NfxrdfFnirWLqPM2i6PqaxXOheD9JSQu2maVpemLYJJp0JRYJIbfTm8230iw8v6boA+XI/wBnTxnpDG98KftaftW6NrCkPHd3/wAVrzW7B5QQQb/SZLSxi1CEkDfbz3AR8AMccV3egftXftR/szTwP8f7ey/aG+C0Mixaj8TvB2iW2gfEvwbZZVRqfiTwxZiLSdZ0u2jUm4ktsXCL5l1feIDN5Flc+0UyWKOaOSGaNJoZkeKWKVFkjljkUo8ciOCro6kq6MCrKSCCCRQB+g/gbxz4S+JXhLQvHXgXXbDxL4T8S2Eeo6NrWmymS1u7aQlWGGVJre5t5kktb2yuYobyxvIZ7O8gguoJoU6yvxh/Zb8Qzfsu/tRJ8Co53i+CH7R0WteI/hzpsrkWXgb4p6JbJda7oOm7m8u20rxDpqRiC2AAa9k8P2NoivBezXX7PUAFfml+0X+2v4ri8eap+z/+yroekeNPino4WHx98QNeMknw6+EpmYxtbai8Gf7c8UwYl3aVC0sOn3cZtri01e9tdU0iz9r/AG5/jprHwF/Z91/XPCOW+I3jXU9L+GfwziQKZv8AhM/GDTW1pe26sHRrnR9Ng1TWrNJUeCa90+1t51Mc7A/GnwR+E2lfBvwDpnhazf7frM2dW8YeIZS8t94m8V34E2r6veXU2bmcSXBaGzFw7yQ2MVvE7PKJJZADy2//AGatf+JLnVP2h/jv8XPi7rF0TLd6UniW48JeArV5MNJBpPhLRTHb2EKtuTNnNZRTJhzZQMdq04P2LPhToTi8+HuvfFL4W61Ed9trvgT4jeIdO1KGcZKS+be3GoAkP8zBBExywWRCQw+u6KAPCvDP7TH7Sf7Jt1an42alc/tGfs/ieG31D4hWemRWfxZ+HdrI6xpqGv2kDGHxVo9sW/0q8uZrnUZctPLqtgRa6Xd/sF4R8XeGvHvhnQ/GXg7WbHxD4Y8Sabbatoms6bL51nqFhdpvhmiYhXVhzHNBKkdxbTpJb3MUU8Uka/nZc29veW89pdwQ3VpdQy211bXESTW9xbzo0U0E8MitHLDNGzRyxSKySIzI6lSRXm/7D/iO7+A/7QXjn9k+6u53+G3jnRLz4v8AwOhupZJk0C7S6MfjfwPZSSb3+z5W41qytBII7S10u4vpt99rlxJIAc3+wCW1D4ByeLromTWfH3xH+Ini/wAQTNzLNrF54hn0+eSZiSzSGDTLfJYk/iTX1p411i68PeDfFuv2MQnvdD8M69q9nCV3ia603Sru9t4iv8QklhRNvfOO9fKP7LcB+FXj79oX9mTVx9k1T4d/E7WvF/g+3mOxtR+Gnjl4NT0G8s0KjzUtPNhfUXjLR21zrFvbEiRWFfaE0UVxFLBPGksM0bxTRSKHjlikUpJHIjAqyOjFWUghlJBGDXwWTxayrDUXpWoUpYSunpKOKw8pUMQp9Yy9vCbba631P7N8WJxr+IfEuZ0dcuz3GUuI8kmrOlV4e4gwuHzjIZUJL3JUVlGMwlOHL7sfZum1FwcV/N//AMEg/jjc/Cj9hb/gmV8JYP2YPjP8aoP25bf4++Ofjl8d/B/hCLxL8PvA3jDW/HvifXPEPiz9oPX5YpIlfxq+protrc65NAbjRdDNhZNqX9mQaRX09/wQavbiz/Yk8Z/DSATR+FPgV+2H+198Gvh1aTSSTHTfh/4W+NniTUfD+kRTzFpZbTSP7du9Nsg8kgt7O1gtIisNvHFH5B8GfhF/wVX/AOCeXw81/wDY1/ZW/Z8/Z4/aW+Auj+KPH11+yv8AHb4g/tA3fwq1T4H+BvH3ifWvF+l+Dvjh8M5vBHiDXPiY3w813xFqdtZ6j8P/ABFp8mu+HLewiK6fdN/Z9j+m3/BPz9kxv2J/2U/hv8A9S8WD4geNdKm8VeM/in8QhaGyHjr4sfEvxXrPj34ieJIbZ1SWHT7jxN4gvrLRIp0S5i0Cx0uK6VbiOQV9HWnTl9Zqx5eWtZU439/3qsKtNSpXap/VKMZ0NFGP71qDmuZr8Xy6jiITy6lUjVTwWGnTxDnQdOnGXsaNGapV3FPFLGV4PGcylPlUP3rhPki/r7WNOtNY0nVNIv4lnsdV069029hcZSa0vraW1uYnB4KyQyujA8EE1/np/tW/8HDH/BTv9gv4w6n+y/8As/fE/wCHGn/CX4f6LoEvhTTfEvwk8IeK9Y0+PxDYJr+p29zruqWz395G2r6hf3Fmk7sLSynt7KEi3t4lX+9f9oT4m2Xwh+Dnj3x1d3EcN1pug3lroMTH573xNqkbaf4fsok5eRpdUuLZ5hGrtFaR3Nyy+XBIRy37PH/BLr9i28+CHwxvf2gv2L/2W/in8YdQ8KWGqeOPGXxU/Z7+FHjnx1danq5k1WPSNc8S+KvCOqa5fP4Ys7228NWsd1eypZWekwWVsEtoIkXy8FepxDRcNsNlON+stbL63i8B9VhLzm8JiZwv0pTtuz7ji2UcH4H5rHFqzz7xN4VWRxno6kuGeGuMJcQ4ijfVxwsOJ+HqGIcLpyx+HU9YRP4Dfgt/wdM/8Fgvi78Y/hP8J/Ffxc+E0fhf4n/EvwL8PfEkmnfA7wLpuoR6D408UaX4b1d7HUILQT2F4un6lcNbXkP722mCTR/Mgr/QT/ZP0q00f9nL4RWtkqrFP4RtNVk2AYa71ya41m9Y46sby/n3E8547V311/wSz/4JuLbXDaH+wP8AsY+GNaWCVtI8S+HP2Xvgjo/iDw9qgRjYa5oWraf4Itr/AEvWNJuvKv8ATNRsri3u7K9t4bm2mimiR18T/Y71q8t/hnffCnxGBa+OPgj4n174eeKdOcnzYxY6rey6NexoQGOn3Ni5s7K5wY7o6ZPLGxUjP9McDzjX8POJ8NQ/3jA8V8OZljqcUueeX4jLc7y7C4mXV0MHjqn1ectqdbNcPHR1tf59wPvZbi4x+Kni8NUqLr7OVOtTjP0hUajfo6qXU+Xf2/dRGl+PfBE3xb/4KoeHv+Cd37Os/hC7jj8P+FvEHwH+Fvxs+JvxNTWJmm1SL4t/H3TvHOmW/gXQdDbS7dfC3gvwDa6tc6reajda94hnsm0q1s/Ov+CRv7XXi74+63+2n8D/ABD+0d4V/bH8M/spfGbwZ4Z+FP7Vnhg+BXf4s/C/4nfDyw8c6DaeJ734ZQ2vgHXvF/gDUBrPg3X/ABP4bsdLt9bu9OJvtMttVtL+S45b9oz9lT9o3wR/wUW8U/tufDb9lX4N/t2eDvij+z38P/gpD4G+JfxN8KfDPx3+z1rngLxF4j1a71jwJqPxD8FeL/C954G8eW+vR3PiW00efTvEw1yC4uBa3NpGsOqed/Cv4Tftm/sMeLv+Cpf7UfiX4Q/AWw8I/Hn4AD9prQ7j4Q/EC9nsPg98XfgD+z7c+H9G+BkHw51P4caFN4+026l0ya/vPira3/hSy1u7sDd/8K/02bxLJpOgfPSrVqGJniJ060aNN45148uIl7lKUp0Zc05exaq06PtKbpRUaSqRoSkpNp4yU51qcYKz9tRTb5rSpTw3LJ6e6oxrzpxcbSnJwdVpRUmv6CM14/8AtBaXaaz8DPi9YXqI8LfDnxhcrvGRHc6fod7qFlOM5+a3vLWCdD2eNTX4h/Cuyf4EePP2AfGHgbwR8efDvjH4h/Gf4N/BP44/Gb4g+P73xV4X/bc0D49fsXfFX41eM/H8lpL8QfFN1rOsfDv4r+ENA1hPEHiLwx4U1HwjfaZrvhbwWkfgPVtRsa/X39rvxdNoHwY1zwzpEb3vi/4qT2nww8H6Nb4a81bU/F8q6ZdwQRjLnbpUt8RIF2C5ktIHeNrmM19twWsTmPE2R4fDr2OKhn+XUlUjOShQlSrYTFzxTqTjScKGFoT+sVq04whShSqTk1CDk+nL262Lwsad1KU8PWg9U1TlUdpS0tFx9lUc7NxUI8yk0z+B/wDaH/4Oc/8Agrb+zj8bvib8Bfhx8WPhWngD4ReK9Q8A+C4dX+CngjWtVtvDHhspp2iWepavd2rXeqX1np8Nva3WoXTNc3k8L3FwzTSOx434f/8AByX/AMFVf2vvE8P7Nfxk+Kfwzuvhd8XNI8T+GfG1n4f+D3g3w1q99oY8MaxqVzYWmt6dare2H29rBLO4e3ZXltZ5rfIEpr/RZ8Pf8Esf+CeS+H9BTx1+wx+xz4+8aRaJpMHizxx4t/Zm+DPiPxP4v8Rwafbw6z4l8Qa/rXgq71fWNX1rUEuNQv8AUtSuZ727ubiSa4leR2Y+X/tF/wDBJf8AYY8R/Af4u6J8E/2Jf2SPhp8Xr/4feKY/hr438A/s7/B/wR4s0PxrFpNzceHZNJ8VeHvB+m6zo323U4rfTb65sb2CR9NvLyBy0MskbfK8IZ/kOC8buGOKMZGnT4Zwvink2fYqM4pUqeRUOLMNmFZTi1ZU4YCMuaLVuVNNHwnHWGxGZ8NcYYPLVJ4rMMj4gw2AUNJOvi8Bi6WFUdrN1KkErap7alv4QaDYeFfhN8MPDOlRxx6Z4e+HvgzRNPSIARrZ6X4c06ytggHGPKhU575yeTX5b/8ABeXVtRtf+CbPxN8NWVxe2lj8Tfij+zl8LPFFxYTy2tx/wh3jj49fD7S/FVkZ4mR0tdb0Y3WgXy7gs9lqs9s+UmZT9sfsOfFy2+Mf7MXwu112ePxL4Y0C0+HfjzTbkNFqOkeNvAltB4f1u21O1dUlsrq++yW+tx2syiWOy1W1L4ZiAn7df7K2mftrfsofGL9mvUfEE3hC7+IWhafL4W8ZQQPdS+D/AB94Q8QaR43+H3ig2sckE13baJ408OaHfajZQXFtNf6bFeWMVzbvcCVP03j7Kszy7OuLcnzGnOpmuDzbNsJjac2ubE4mjjasa6U21GccY1Jwq83s6kK0aik4SUn+dcL43B4nAZFj8NKMcFXwWBrYecdqNKph6bpO0dYuhePNFLmhKDjbmVj8qf8AgqX8U7L4lfsb/wDBTj9l26/ZV+Lnwv8ABX7InwE8C+PfhF8b9c8IR+Hfg34x8ReGLXQPGPhA/A/XraGCBL74canpmn6ay6FNMbKGx1LTbwaSALG6/br4G+KtV8dfBT4P+N9eAGueMfhb8P8AxVrICeWBq3iHwnpOraiBGAojxeXcw2BRs+7gYxX4sfF/4Y/8FbP25PhFB+xN+0T8D/2efgD8MPF1z4U8P/tM/tW+APj7c+P7v4pfDrQNZ0zVvF2nfBH4NJ4C0LXfAeufEYaQmmvL4+1u70/R9H1XVIfJW4NsqfvXpmm2Gjabp+j6Xaw2OmaVY2mm6dZW6CO3s7CxgjtbO1gjHCQ29vFHDEg4VEVRwK+Wy9VJ4rGYmSqunUo4WjGdfDyw1SpOjWx9WUnRlGElGnRxWHw8ajinV9i272UpexiuWNDC0Y+zUoTxE5RpVfbwjGpSwMIL2qbTlOdCtWlBNqn7ZLRtxXwZ/wAFQtKgv/2Jvi3qLMYNR8LXXgLxRoV8jFJ9P1jTfiD4YiiuraQYaK4e0u7yzSRCrr9qbaQcV9Z+G/8Agprr134f0O6uv+Cd/wDwUp1K6utH0y4udQ0f9nnwbcaTfXE1nDLNeaZcSfF+3kn066kdprGeSCB5bV4naGNmKD42/wCChLXXxT0n4K/sb+FpGuPGv7Uvxd8H6Bd2dtmS40j4b+EdasfFXjTxbdRxrI8VjoR07Tb2UugWaztdUkiMpsJoj/QtZ2lvYWltY2kSwWtnBDa20KDCQ29vGsUMSDsscSKi+wFe34uSjhPCvwty7FW/tDG8UeJPEmCpSf7ynw9jMLwLkOHxUV8X1fH53w1ntCl9j2uVYmUfenJnn8DqVbjPjLFUV/suHyfhTKcRNfBPNKNbiDMqtJvZ1cNl+aZfOevMoYuknpZH84P/AAUo/bH1T9of4J/Dz4K337Jv7ZHwJ0D4iftEfBvQvE/iv9oH4T+H/AngfVNDGt3WoS+GrfWNI+IPii4uNevL6y0/U7PTpdOjt5bLSNSuWu4pbSKOb9PlVUVURQqoAqqoAVVUAKqgcAADAA4AwBWH/wAFZfhF4i+Lf7EnxMbwZbyXXjf4V3nhz42eEoYYmnne++GmqxazrAtoYw0094fCTeIxY20KNLdXptrZATKRXG/Bf4p+H/jb8KfAXxW8MTRyaR448N6drccMcglbTr2aIR6to1w4/wCX3RNWivdIvl/gvLKZeQAa9bh2cMb4HcG1MGk6eRcd8eZfnUIavD5lnOXcIZhlmKrpfCs1y7AV8LhJNfvP9X8ZGP8ABkcOaKVDxFz+Fe6nmPDnDmKy+T/5e4TAYrOcLjKVN7/7JisVTq1or4P7RoN/xU355+09+yn8JP2vvB3hb4c/G+38S658OvD3xB8N/EPWPAeleJtT0Hwp8SJ/Cq302k+EfijpWnvHH41+H/8Aa9zY+IL7wjqDLp+oazoOiTXnm2trPaXX5y/8E57Cx0r/AIKP/wDBavS9LsrTTdM0z4vfsd6fp2nWFtDZ2NhYWf7Mdjb2dlZWlukdva2lrbxxwW1tBGkMEMaRxoqKqj9MP2kPFf7RHg34cHWf2YvhD4K+NnxN/t7S7X/hCvH3xMb4T6D/AMI9PHeHVdX/AOErTw14rIvbGWOyS303+ysXi3Mrm5h8jD/iR+zr4E/4LAfA79pr9sT9oKX9iX9mzWl/bI8efB/xZrvh8/th/ZI/h1B8Lvh7b/DswadfR/Ca6l8UNqlpG+sMZ7PRTbT4sVWdP9Jr4vEyp08xws44bEOSnUeIrUsJXqRfPh/ZUb1oU5Rko3UbKTVNyk2o3k39FR5p4GvCVakk3TVGnPEUoNctXnqWpymmm273aTnok5WSX9Gdfm7/AMFItXl8DeH/ANlv4vaVpmq6v4n+Fn7X/wAHvEOiaZ4ft4brxFrke7W7i/8ADGiW1xc2UF3feIG0+ytYbKe8tbe9njht7m4hhd5F/SKvz9+PVq3x9/bU/Yp/Ze0Ff7Rj8GfEe0/ap+LPlDzIPD/hL4WrcN4Wj1YoknlReKdWn1HQFjcq6T6lpLMqx6hDcJ+veFk4Ybi+hm2IssryHJuJs+zypPSlHI8s4czTEZnTrSdko43DKWXUoPXEYjGUMLTU6teEJfCcZKVXIp4KlrjczzDJsty2EdZyzHF5tgqeElTW7dCpbEykk/ZUqFStK0aUmvspf+ClHigDH/Ds/wD4KenHcfA34Pn9T+0N/kV+ff7X/wC0/rH7T/7Qv7AXw51/9mT9qP8AZ58O6Z8fNV8f3CftJeBPB/gyz8Y654N0C1vPDy+FR4U+I3j0anPoMtxenV11GPTBaprWmi1a8+1XK2/9IagAcDH4Y/T/AA49K/IP/gsJ4X1nRvhT8D/2oPD2mXGq3f7J/wAefB/xF8TWlpG0l3P8NNbuIvD3jSG2VFZ8vO/h43UgxHa6ct9eTMkVszp+KfR5r0aXi9wrRqSp06+aUOJuH8sqVJRhGnn/ABLwjn3D/Dk1OTjGM45/meWunKTSjNRk2rXX6D4pQqT4FzqpGEp08HPKMzxkYJyby7Kc7y3M80XKk3JPLsJiueKXvQ5lbWx7rXkXjn4DfCL4lfEX4Q/Fnx54H0vxN8QPgJqPivWPhF4i1KbUWfwRqvjbQ08N+JtS07Tor2LSLq+v9GjS0iu9U0+/n0xkW60p7G8AuK9H0DXtI8U6Fo3ibw9qFvq2g+IdK0/W9F1SzfzLXUdK1W0ivtPvraTjfBdWk8U8TYBKOMgHivyv/wCCrvw0/b5+NHgb4YfCf9jrRvDurfDHxdrPiMftVWR+MH/CjPiJ4o8A2UOgjQPht4L+JY8P+K7nwnonjt7vxHa/EHV9D0J/Ez6Hp1toulato8Gs6jLP72Y+0wlGqquDrV6+Hqwg8L7GcqsMTTqqKdSn7OdSm8PVXPVkqUqlFQlKNOU4qD83BqOIqQ5cRTp0qsHL23tIqnOjKDbUZc8YTVWD5YR54wqcyTlGLcl4p4f17RP23/8AgsF8Mfjd8Ao11j4Kf8E+PhH8cfhP8W/jzpMat4O+Kfxn+MsOj6Xa/Ajwlr8KiDxrB8JNOtbzxn4m1HTLm+0Xw74i1RNJmMN/f2k17+6Nfkb+yPqP/BQD4W3Hwk+Bd1/wTm/Zc/Zz/Zl8LiHw9dXXwu/ar/4Su58CeGYoLq4a+0bwWnwk0JvEuqXepMs+py3mtw6lq1/f32s6pqN3qE1zNcfrlXNlkFGhOT9o6tWvVrV3UoVcLetVcZzdOhWSnGlFOFOEnfmULylKpzt64yV6sUuTkhSp06ShVp1mqUFyxVSpSbjKo2pTns05WSUORH5q/tbeOr/4I/tl/wDBP/42+G/Afjz4l+ItM1/40+Ebv4f/AAt07RdV+IPjnQ9e8G6ZYPovh3TPEWv+FdD1C9shq2o31tb6r4h0q0jeSS5+1LNFEG+8v+Hkvjr/AKRc/wDBUA+//Cp/2cuf/NqK+VfBdm37Qv8AwVU+FmmaMn9oeD/2JPhl4x8c+N9SQNJYW3xJ+LumJ4b8P+FpZEVoxqcGknTPE1qvmLzo+qwP5ctjLC/70joPoK18e5woUvCTJ69v7Wyvwwp1cyg/42Go5/xrxlxNkeFrp+8pSyDOctzSkpJNYXNaCXuKJHhopVZ8b46nrgcZxfKOEkvgq1Mt4fyHKMxqw6NRzLAYrCTa3q4SpfVH4FeMfj3rf7Sn7ZvwUvfEv7P/AMfv2d4Phz8L/H+o6J4O/aL8O+CPDfijV9S12U6Zf+J9DsPAvxC+JGkzaFNZrBpsV3c6vZaidR0i+R9OS3t7W6uPsauO/wCCh2myfDz4ufsw/tJSRlPC2h6z4g+EPxEv8N5WmaR47tS3hrVLxkRjDpul6kus3N3PIdgmNjbr+9ukV+wBBAIIIIyCOQQehBHUGv58P1AWiiigAr481P4u65+z3+3DoXjnwn8GPi/8ebzxh+z5qPhvW/ht8C9N8Ear48v4rXxgb+38QR2fxA8d/Dnw41lpR0y0jvrifxLFeRWi7LO1uy7xj7DrzP8AY20x/ir+2T8bvjRax+f4P+EHgPTvgP4e1PDG11LxVqOrp4l8VSWMoXy5JtBe3u9MvMOwNvq9jOu9LhCgB6D/AMPGPid/0iu/4Ka/+EN+yf8A/RfV8k/Dj4lav8df2wv2hfih4n+F3xN+C+saT4G+F3hDTPhj8ZLHwpp3xH8JaPd2D6jdRa5ZeCfF/jzwvbpreoaaniTThpPivVFl0nWNPmvfseoS3en2n741+N/7Remt8If29tG8XX6/Z/Cf7TXwys/DcOpOdlsPiX8PpoLa3sJ5CNivc+G00i0sEdlku77VBDCG8l8gHsFFFFABRRUNxcQWlvPdXU0VvbW0MtxcXE7rFDBBCjSTTTSuQkcUUas8juQqIpZiACaAPkP4MftB+L/2c/2nP2tNC8E/svftE/tM6d4tvfhR4kvNI/Z6tPg9dXXgvU38I3Vzf6l4kT4u/GP4Q2UUPia51dxaPolzrd3LPpNx9ugs4kgkuPr3/h4X8Yf+kUf/AAUp/wDBP+xV/wDRq1m/8E0dGu/FEf7RP7SNzbzQab8bviXbaV4Ke4heN77wL8L7a/8AD+javFvVWEd7dahqFjNGPuXejTKfuqT+o9AH4IfsyeJtQ+JHj/8Aap+K2v8AhTxN4F8TeMPjhqGn6l4K8broqeNfBln4b06GLSvCHitPDet+JvD0eveGYdRm0XVY9A8Sa/okeoWVymlazqdisF7P9f1893mnN8Hf23/2gvh1qam10r43R6N8cfh7cS4SLU7q4tZrPx3ZQnGyS/TW01C4FsjGVNO0p7uRQkqmvoSgAooooAK+P/2RP2m/iN8BYf2gfhn4G/Yr/an/AGmvDel/tHfEi/sPEfwDl/ZvTw54TS9fTLb/AIRLVF+Nn7RXwa1hNShGnLqiLoui6rpX2bUo2fUlvDPaxfUPivxNpHgzw1r3izX7lbTRvDmlX2salcMRlLWwgeeRY1JHmTy7BDbwrl57iSOGMNJIqn0b/gmd4I1vw7+zafHXia0ex8Q/Hf4geMPjXfWkqFZbez8XXFrbaH8zKrPBfaLpNlrVo2MG31WNsKzMAAc2v7e/x/mB+zf8Ekv+Ci8m37/nax/wT1sduclcC/8A29rXzQcHJg8zZgeZt3Ju+Pf2I55NX+DF74yvA39s+P8A4kfEPxh4geQ5nfWNQ8QTWlw1w25i03lWEAYlmz/ePU/vfX4T/AnTX+EvxP8A2iP2bdVU2l94E+J2t+M/B0Mv7s6l8NPHckOq+H7yzTaFmSzjmtxqTwlo7a81SO0YiRGFAH1RRRRQAVT1GxtdU0++0y9iWey1GzurG7hcZSa1u4Ht7iJv9mSKR0b2Jq5XlHxw+Itl8KvhV418b3cyRT6Vol3Ho0TEb7zxDfRmy0GyiXlnM+qT23m7FcxWyz3DIY4XwAeTfsQftefHP4efs1+BfAHhL/gn5+13+0bo/hO98XaVp3xT+FXib9jrSfAesWzeL9cv/wCzrEfGX9q/4V+O1u9BN6dIuhe+BrPTjLabNMvb20VLlvefif8At0/tMj4a/EMz/wDBLb9t34ewjwN4tM3j7xL49/YIuvDngiIaBqHmeL9ftvB37afifxdcaL4aTOs6rB4W8NeIfEctjZTx6Joeram1rYXH13+xB8KdR+C37K3wb8Ba1byWmv2vhhte8QWk6FLmy1vxjqV94u1LTrtWAIutKuNbbS5gc4eyKgsACfozxb4dsfGHhXxN4S1ME6b4p8P6z4c1AKAzGx1vTbnTLvarfKx8i6kwDwTweKAPxn/ZN0q10f8AZx+EVrZqqxT+E7bVZNoAzda3c3Ws3rNjq5u76bceueO2K+iK+Uv2RNR1HSvh5q/wd8UKLXx78CPFviL4ceK9PckSqtjq9/No2oQoyqzabeWTva6fdAeXdrps00RKMpP1bQAUUUUAeSfHzSrTWvgh8XNOvUVoJfhz4xlBcAiK4s9Bvr2zuMHjda3lvBcr/tRDvVf9nn9tP9qLTPgT8INJ0b/gmT+1v8W9J0X4deEtE034m+EPij+w7pfhnxzY6LotppVt4k0bT/iH+1l4N8b2tnqUNok6R+JvC+h6ruZmuLCLcC3EftbeLLnQvg1rnhjRYZNQ8ZfFWe0+FfgzRLb5r3WdY8ayjSJ7W1jGXLjS574o4Gz7S1rAzo9xGa/YT4P+BI/hd8KPhr8N4pEmXwH4F8K+EmuIwQl1NoGiWWmXF4AQpzdz20lySVUlpScDOKAPyF/a8/bG/aX8R/s2/Frw54n/AOCcX7VHwH8PeIvDkegax8V/iB8Sv2L9c8H+FLDWtW07TLhtZ0r4UftSfELx/dx61HdHw7aroHg/WTFfavaz6otlosWo6lZ+v/DvSrXQvAHgfRbFVSy0jwh4a021VBhRb2OjWVtFj6pGD75zX3X+078MLj4zfs+/F74ZWSI+qeLPA2t2WhpKwSJvEVrbnUvDgldshIv7dstO818ZSPc4+ZQa/Mj9mPx7H8Qfgp4J1CTfFrmg6ZB4M8V2FwrRXuneJvCkMWkalBfW7hZLa4uRbwamIJAHjt7+AOA2QAD32iiigAr5S/basY7v9mr4g3Rcw3eiP4X1vTLpGKS2moWPi3QxHNBICGjmaGWe3V1IZROSpBr6tr5K/aqt7r4i23wy/Zt8Pl5vE/x6+InhvQ5beAF5tO8HaDqlpr3ifxHOqLIyWmjJZWd3OzJhrSG+lTzPskkZAPp/Rv24P2x7zR9Ku4/+CSf7WmuR3WnWVxHrWn/HP/gn7aWGrpNbRSJqdlaat+11p+q21pfqwure31Kwsb+GGVI7yztrhZIU+Uv21/2lP2h/i38KvDXwz+Kf7Bnx8/Zi8FeNfi18OtH1Xx98Tfih+yl4x8OaqF1htQh8IppXwO+P3xR8Wx6jqL2I1W3vb/w9b+H4YdDuorvVbe/n0u2vP3stbaCytreztYlhtrSCG2t4UGEiggjWKGNR2VI0VVHoBXxL/wAFFfhprHxL/ZQ+IcfhqCS48VeBJNG+J/h2GKNpZnu/A2oxarqS28SBpJrt/Dg1uOzgiBknu3hhQEyYIB5eoCgKoCqoCqqjAUAYAAHAAHAA4Apa4j4beOtK+JfgPwr470WRHsPE2jWmpLGj+YbO6dPL1HTZWAH+k6ZqEd1p9yMfLcW0i9s129ABRRRQB8e/thapqXhPSvgd8RPDuj3WveLfAX7Q3w41zw3omnXOn2OpeIb2OTUZV8M2V7q93YaVay6/cW1nZiXVL+y0xW2NqF1BaLLKn13/AMNn/tw/9Iff2oz7/wDDTH/BPL/6LCvm7xxprfGH9qP9l/4F6Wn22Lw745tPj38QtgZ4dI8M/D7zZdHTUSisI4vEOoSXejIHKMLi808Hat3FKv7kUAfgT+0b8cPjz8Z/i7+yZ4c+Nv7HHxV/ZT0HTPipqfiLR5fiX8Tv2dPiLb+Odc0vSIJLSPSY/gP8WvifJpM/hxyklw/iePRkvRrduujPfPbaktp9jVrf8FMfBOt6h8FPCvxf8LWMmo+IP2dfiR4c+K0tlCrNNfeFLF3sPFloApG23jtLm01fUJc/u9N0i8b3HG+GfEej+L/D2i+KfD95Hf6Jr+m2mraZdxkYmtL2FJ4iygkxzIH8ueFsSQTpJDIFkjZQAblFFFABXzr4vkk0z9sP9h3WtPYx6pJ46+IOgyGPiSbRta8K2llqiv3aGG1uJgQThRcycEsK+iq8T+COlv8AG79vTS9Y05Rd+DP2T/BWuy6rqajzbN/if8RrWXRItCSRSY5J7PRFnvJCCzWeo6Dd28yxyiPIB9Qftifs1eM/Geq+Fv2gvgHLa2Px/wDhhaTWkGm3jrDpfxP8Fu8k994D1p2kgiExaa7l0S5uJ4IVnuri3lubOWWw1bSPH/g7+1B4A+Kc0vhfVGn+HPxX0mU6f4n+FfjbOi+KNL1eDC3dtYQaglo2tWyyZaKWzjF4kDRPf2FhJIsVfq5Xz38av2VvgJ+0HFH/AMLU+HWja/qdvEIbLxJbfaNE8VWMabjDFb+JNFmsdXa2gdmljsLm6uNO8wlntHJOfncdk+IWJqY7K6lGFWu1LF4LE88cLiqkVGKrwq041KmExPJFQqVI0q1KtGMfaUeePtD934Q8UskqZDl/B/iNgc0xWXZLCpQ4Z4s4fjha/EfDuBrV54mpk2Ky3H18HguJOH44mtXxODwVXMspx+VVsRiPqWZvCVXgDzuvOfiR8W/hz8I9El1/4ieLdH8M2KRyPBFe3KtqWovGMm30nSYPN1PVbojpBYWtw4GXcJGrOvxJ8ff2TNL+D/7Rf7CvwX8CfG/9o7SvA37UPxg+L3w78a2R+Kl35+gaH8Pv2XvjN8bdIfwe1vplvbWV5ceJPhxo2lX0mtWmvwPoF1qUEFvBfyWupWv6H/C//gnv+zF8Mdbh8V/8IfqHxE8ZwSpPF4s+K2tXPjnVI54m3xXEdnfpF4fiu4ZAHgvotFS9gcB4bhGVSOFYbP6vuRwOBwrdr16+PliKcP70KNDDRnWt/JOphr9ZxPrJ574LZfH63X4y4u4ihH3qeTZNwbRybHYp7qhic2zjPK+CymMvhnisNgs/dLeGDxB8q/Bz4Y+O/wBs34leEvjT8UPC+qeCf2bPh1qkXiL4T/D3xFB9n1r4oeJIDnTvHPijTiWSLQLMYudLtZvMtr6NltLU32m3urXd9+wagKMD/P8AShVCgKoAA6ADAFLXvZZltPLqVRe0liMTiJ+2xeLqJKderyqKtFaUqNKKVOhQi3GlTW8pynUn+N+IPH+N48zHBT+oYbI+H8jwkst4Z4awNSrVweTZfKrKvWc8RWtXzHNcwxM5YzN83xKWIzDFy0hh8HQweCwpX52/tN/A7x/4S+ISftQ/ADSf7e8UrpsGlfF34ZRFoz8S/DNkiLBqek7Ec/8ACYaPbQRRW6pHLcXttbWi2UNxcw3Ol69+iVFfa8LcT4/hPNFmWCp4fFU6tCrgcyy3GxnPAZtlmJcPrOX42nTnTqOlVcKdWlVpVKeIwmKo4fG4WrSxWHo1IfFYTF1MHV9rBRmpRlTq0ppunWpStzU5pNOzsmmmpRkozi1KKZ+dHwo+Pnw2+MNmD4Y1uO18QW4ePWPBet7NL8XaJeQnZdWt9o07ieQW0qvFJd2X2qyLqyC48xJET1fV9J03XtK1PQ9asLXVNH1nT7zStW0y+hS5stR03UbaS0vrG8t5A0c9rd2s0tvcQyApLFI6MCrEV1fxf/ZE+APxuvTrXjbwJaJ4p+Ux+MfDdzc+GfFKyxqqRTz6ppEludUlgRFSD+2YtSjgUARRpXhf/Du7wWP9Gj/aA/anh0n7v9kR/Fe2+wiI/wDLEIfDO7y8fLtOTt6sTzX6lHO/DTM4Ous4z/hx1E3WyjMclhntOg5L3qWEzjAY3DTx9FXcYyxmU5bV5bRn7R3qP1lXyupapGvicI93SnQVfkat/DrU6kHNX2cqVOWmrb1PhC0/Z4+AH7JGtfCfxV8Q/wBor44/E7Qf2eNP1Wx/Za+A/wARvEPw58R6Z8JG1XwnffD20fwLYeD/AIbeEfid481vSPh9rGr/AA58M+Kvjd46+JN74c8Ma/q9umuW17qt7qsn2j+zr8GPH/xY+JWnftO/HjQZ/CtroNtcwfA34T6gGN34Ws74ATeM/E9tIiCPxJfwbfsltPDHdWzeVdTW9q+naOsP0J8Jf2Nf2e/g1qcfiHwv4Ij1Txejib/hM/GV7c+LPEq3Oc/bLW71ZprXS7w9GutHstOmdSVdmVmB+oxwMV4+a8cZFlGW47KeBaGZzxOaYetgcz4qzmlRwePll+Ih7LF5fk2V4bF5hHLKWOo3w2Nx+JzLG47FYCUsFShl9CriaVfnq47D0KU6OXwqc1WHs6uLrRjTn7Jq0qWHowlONGEl7spOc5ODcYqmpSTKRlDDBHGc/wCf60tFfkR45+E37U3wD+K37GHxu8aftgfs5eCtU+JPwI+Kl5/bf7UfwK8MQGbxJ4d1+MyyXnxm+HOnDAu5J1lub7xXpcS5FzNf3l4f7HvV1TwV7L8FP2ivgz+0L4eh8R/Cbx5oniiFoI5r/SIrlLXxNoUjABrbX/Dl0YtX0maNyYw11arbXGPOsri6tnjnf9c2AYYP+e39a/Pn47f8Evf2Nvj54hn8ca38N7jwB8R7i4kvJfiP8Htcvvhv4qlvpnaSfUbwaIR4f1XVJ5HLzarrGg6hqcjAbrs8g/0jkXizwrxLleW5V4oUc7wWd5RgcLlWX+IHDeEwmb4zH5VgKMMLluA4u4ex2OylZrWy3C06WBwfEOX5xhMyhl1GjhsfgM5qUKFan+TZlwTnWUYzFY3g6eXYjLsdiK2MxXDOa16+Bo4bGYipKrisRkeZ4fDY36nDF1ZTr1ssxWCrYR4mpUq4bE4GNScJJXyn+0D+2L8H/gBHHomoanL46+KurSw6f4Q+DHgFf+Ej+InibW71vK0zT10XTRd3GjwXtwyxrf6pFCsoEiabb6nfCKwn7D/hzb8LrnFnrH7Wn7eGveH/ALjeGtT/AGgLOTSZYBkfZZY4/BEchgZcIyxvE2zhXQ8j7E/Zz/YM/ZT/AGVZW1L4NfCXRdH8VTRSRXnjzXJr3xZ48uxOhS7A8V+I7jUtU06C+3Fr2w0SXS9MuWwXsjtXHs1OKvBTIo/XZ57xZx7Xpvnw/D+W8PQ4RwGLnH3o0824jzLM8fjcDhpNJVqeV5Dj8RWpudOljMFUccRDhhkviDmT+rxy3JeGqU3y1czxeaPO8TRg7c08DlWEwmHw+IrJN+zljcxw1KEkpVKFeKdJ/LP7BH7I3xPsfHnib9tL9rWztLf9oj4iaKvh3wL8O7eQXml/AH4XSSGeDwrZuzSwjxZqwYP4gurdnls4pr21a5N7rniKF/1moor8D4441zjj7iCvxBnCwtCToYbAZbleXUpYfKciybAUlQy3JcowsqlWWHy/AYdKFOM6tXEV6sq2MxtfE47E4nE1v0rhzh7AcM5XSyvAOtUiqlXE4vGYqaq43McfiZ+0xeYY6sowVXFYmprJxhCnTgqdChTpYejSpQZLHHLG8UsaSxyIySRyKHSRHUq6OjAhlZSVZSCCCQQa/nm+KHw18f8A/BL34keLvGvhHwlr3j39gD4l+IbnxTrek+FbOXVPEf7LfizVpVOqXMOlJmS7+F9/LtaJ4ykOmQLBZzyW2r2Vq/jj+hyoZ4IbmKSC4iSaCZHilhlRZIpYpFKSRyRuGV0dWKurAqykhgRXs+HPiLiuAsXmVDEZbQ4i4V4iw9DB8UcMYvEVMJSzOhhasq2Bx2Bx1KFWplOf5RWqVa2TZxSoYh4WVbE4bE4XG5Zjswy/F8HFfClHiWhhKlLF1MrzrKqtTEZPnFGlGtPCVK0VDEYfEYecoRxuW42EYU8dgZ1KarKnSq0qtDFUMPiKX5cfDP4ufDL4y+HLfxZ8LfHHh3xxoNwkbm80HUYbqWzeVd4tdVsCU1HR79BxNp2q2lnfwMCk1vGwIr0X/P8AP/A/ka5T4r/8Ekf2MPiV4iufG2g+EPFPwL8c3ckk1z4r/Z+8W3vw0upZJPmd10O0gv8AwfbSSSZlnmsvDdrcXMrNJcTSuSa8vH/BGn4O6owtfHH7T37cPxE0AfLL4X8XfHuO60G7hzhrW7hsvCFjdPA6bkcQXlu5VjskU81+yRz7wQxsVi6HHPGOR0prmqZRm/AlHM8zwz0cqFDMMp4jhlmaKOsaeLrxyJ19JVMFg03GPwTy3xEwz9hV4cyLMqi92OPwPEc8Hg6utlUq4XHZVLF4O61nRpvMfZ7Qr1935L8d/wBtPwR8OtWg+FXwmsJ/j3+0h4kmfSPB3wb+HbHX9QTWXRglx4zvdLNxbeF9J0/i71OO9mi1RbFXuRawael1qdl9f/8ABP39jfxN+z/pfjj4yfHXVrLxh+1V8e7y11v4qeIbXbPpvhPSrZQdC+GPhObLRxaF4ch8qO9lsitrf3lvZ20LXWmaFolxX0b+z5+yF+zf+yzpc2l/An4T+GPAj3kKwanrltDcar4t1mJGSRYtZ8Ya5PqXibU7dZkE0VldarJY28pZ7a1h3EV9I18Xxx4q5NVyDGcE+HWXZpluRZrPDvifiTPnhY8T8W0sHiKeLweWzweAq4nA8O8O0MZRo46WSYXHZriMdj8NhcXmWcYqGEwWFwn0HDvBePhmeH4h4qxWDxWZYKNVZRlOWqtLKMkniKcqNfFxr4mFLEZpmtShOphlj6uHwdLD4arWo4TBUnWr16xXP+LPC3h/xx4Y8Q+DPFmk2eveF/Fei6n4d8RaJqEQmsNX0TWLObT9T068iPElteWdxNbzLkEpIdrK2GHQUV+GUa1XD1aVehUqUa9GpCrRrUpyp1aVWnJTp1adSDU4VKc4qUJxalGSUotNJn6POEKsJ06kI1KdSMoVKc4qcJwmnGUJxknGUZRbjKMk002mmmfzhyj4gf8ABLHxVN8K/i9a+JfGv7EWt65PJ8E/jxY2N5rt78Hk1m9luV+GvxVt7GKa8isbO4nkGj6zDbH7aC0+k21zFcX2heEP0M8HeN/B3xC0Gz8UeBPFGgeMPDuoIHs9a8N6tY6zps4Khii3dhNPCJk3ASwMyzQvlJURwVH6OazoejeI9L1DQ/EGladrmi6vaT2Gq6PrFja6npWp2F1GYbmyv9PvYp7S8tLiItHPbXEMkMqMyyIynFfmB46/4I7fseeINfvPFfw4h+Kv7OPiPUJWmvr/APZ8+JGp+BrW4ldy48vRL+28Q6DpcEbH93Z6HpulWcQH7uBSM1/T+F8VeA+OoRxfiIs64U40nGKzTivh3KcLnuRcVYlRSlm2ecPzzDKMZkueYqzq5rmGTYjMsFmmKlLF/wBh4HEVcTWr/j1bgviThyUqPC31DO8gUm8HkuaY6tluY5NSbusFl+ZrC4+hj8vo3ccJhsdSwtfCUVGj9fxFOFOMPSXkSJHkkdY441LvI7BERFGWZ2YhVVQCSxIAHJNfAvxg/bIl1zxN/wAM+/scaTF8f/2k/ESy2NrD4YeLVfh/8MYnkFrdeLPiF4rgdtCtbXQ3kMkunfbikV3HHa63PpzTWttfeef8E7/+Cdfwy/bN/Yn/AGWP2lP2kvjH+1B8Tta+Nfwe8G/EXxb8Pda+NutN8NYtU16xW7u9O03Tls/+Eog0iN8LbxTeLLm9jQAPfSP84/eD4Kfs7/BH9nPwv/whvwR+GnhX4c6A7RSXcPh/Tkjv9WuIVdIrzXtbuWudb8Q30cbtGl/rmo6heJERGs4QKo1r8deEHCa+v5dWzzxOzmj+8y/K8dkn+qnB1PExadGtnmJqZrjM/wA5wtOXv1slwWBySOLUVTqZ3TpSqUp50+G+Os7f1bFQy7hDL5+7icbh8w/trPZUnpOGX0oYOhluArTjeMMfiMRmEqDfPHL5TUZLxD9hf9kHTf2QvhPc+H9R1o+N/i58QNZuPHnxu+Jdwsj3njbx/q2Zr14p7lVu/wCwtGMstjodvMIiyvfavNbW2o6zqCH7Woor+cuJOI854uz7NOJeIMbPMM5znF1Mbj8VOEKanVnaMadGhSjChhsLhqUaeGweDw9OnhsHhKNHC4enToUacI/q2U5VgMjy3B5RleHjhsBgKEcPhqKcpuMI3cpTqTcqlWtVm5Va9apKVWtWnOrVnOpOUn558V/hf4R+M/w78WfDDx1p/wDaPhfxhpU2l6jCrLHcW7FknstSsJmSUW2p6Tfw22p6ZdeW/wBnv7S3mKOEKN+K9r4l8c/sf69Z/BL9pc3T+DYpv7N+Efx+S0uG8KeKtAhBXTtF8V3CeedA8SaXarHbXCXkjiKGLzLuaTTobfxDq3711z3inwn4X8caFqHhjxl4e0XxT4d1WLyNS0PxBplnq+lXsQIZVubG/hntpdjqskbNGWikVZI2V1Vh4h6J+cenanp2sWVvqWkahZapp15GJrTUNOuoL6yuom+7Lb3VtJLBPG3Z45GU9jU1zdW1lbzXd5cQWlrbxtLcXNzLHBbwRICzyzTSsscUaKCWd2VVAJJAra1z/gl1+zhNqVxqnw+1v4x/BOS7kM1zafCj4lahpGnyzNyzi116z8SGAcnZBaS29tEDshhjjUJVXTf+CW37P0t5BdfETxp8efjLb28iyro/xL+KV7faSzoQVZ4vD2neHL1sNyQL9UYfKyFSQQD5D134qeMPj54juPgb+yZF/wAJT4ovttn4z+LkAlPw++FuiXTNDeaq3iCJHttR1ryBN/Zcemtc751P9mf2jqED2sH68fs9/Avwh+zl8KfDXwr8Gq81losMlxqus3MaJqPibxHfETa14j1RlLFrzU7rLJE0sq2NjFZ6ZbyG1soAvc+BPh54G+GHh2z8JfDzwloHgzw3Y5Nvo/h3S7TS7MSsqpJczJaxRm6vZwim6vrppry6ceZczyyEseyoAK+dP2ov2dvDv7TXwp1L4f6veS6Frdrd23iPwJ4xs0Y6l4N8aaSJW0fXLMxvFK8QMstnqNtHNDJc6ddXKW89reC1vLb6LooA/CTwp8bfEPw18Rp8FP2q7GP4bfFTTB9m0zxVf4tvAHxQ06F/s9r4k8N+Injg02OW+AU3VrObSIXjm3WOy1FrjQtO+p4pYpo0mhkjlhlRZIpYnWSORHAZHR0JV0dSGVlJDAggkEV96fEj4U/Dj4weHZvCfxO8F+HvG3h+ZjINP17TobwWtwUaP7Zp1yyi80q/RGZYtQ024tL6IE+VcJk18J3n/BLT4E2txK/w/wDiN+0P8JNPkd3XQvh98Vri10eDeclYY9e0fX9QxnvNqMzHoSeoAMfWdc0bw5p1zrHiDVtN0PSbNDJd6nq99badYW0YGS893dywwRL7vIM9BzXy1anxx+3Nr0/wn+Ca6rofwJhvVsvjF8d57KeysNR0uJ0e/wDBXw/+1xxvq2panD/o13OI/KEMytfJFok4fWPtXwz/AMEwP2Z9N1W21rx3P8UPjbqFnIJrT/hb3xA1DxDZQTKQdzafpFt4es7yM4xJbalFfWkq5WWBxxX3/oeg6H4Y0mw0Dw3o2l+H9C0u3S00zRtE0+00rStOtY87Lax0+xigtLWBMnbFBEiAkkLkmgDL8EeC/DXw58IeG/Ang7TIdG8L+E9HsdC0PTIMlLXT9PgWCFXkbMlxcSBTNdXczPcXlzJNdXMktxNJI3U0UUAfHP7Y/wCzBL+0P4N0PVvBmrQ+Evjb8LtSl8T/AAn8YuCsNvqZWI3/AIa1pkimeTw74kS2t4L4eTP9luILS7e2vbSO903UPz++Hv7Q1pca3P8AC742aS/wa+OOhNHZa54N8VFdMsNZuBlI9V8HatcytYaxpeqbftOnxQXtxNNE5awm1axjTU5/3Hrx/wCL3wB+Dnx60aPQvi58PvD/AI1s7cSCxuNRtng1jSjNgyto/iDT5bPXdHaUqpmOm6jaifaomEijFAHxfmua8V+MvCngbSJ9e8Y+IdI8NaPbKTJf6xfQWUJYDIhh851e5uZMbYbW2WW5nciOGJ3YKejk/wCCWvwdsnaPwd8Zv2n/AIf6SSfK8P8AhP4sxW+j20eSRBbR6j4b1K8EQB2jzr2d8dWYkmu18B/8E0/2XPCGtW/ibxJoniz4yeI7R0kttW+M3iq78aCJ0YN+80ZYNM8OX6Fxu8vVNGvkB5UA80AfFHgTwF4w/b88U6RHHpGueEv2PPDWtW+p+IvEWqW93o2r/HPUNIuhLbeH/DttJ5N5F4SW8hB1DUiI/LMbuXh163tbPTf3LsrO006ztNP0+1gsrCwtoLOys7WGO3tbS0tYlgtra2giVIoYIIUSKGKNVjjjVURQoAp1ra21jbW9lZW8FpZ2kMVta2trDHb21tbwIsUMEEESpFDDFGqxxRRoqRoqoihQBU9ABX5+ftpfsveLPiNeeGPj18C5LKw/aB+F1pPa2Wn3rJBpfxO8GSPLPfeAdbmeSCJJi893NoF3cTw28V1eXVtPcWTXNnq+jfoHRQB+J/ws/aJ8F/ES6n8K6wl18O/ipo87ad4m+F3jVW0XxRpWrwYW6trK31BLR9Yt1ky0UtpELoW7RSX1jYvKsVfQFfV3xs/ZY+Af7Q8ES/Fn4caJ4j1G1h8ix8SQfadF8V2ES7miitfE2iz2Gs/ZYZGMsenz3c+nGUl5LN8tn8mf2lf2OPCnwO+Jv7EngPwJ8ZP2krHwz+09+1Xf/ATxZpp+LUiweGvC1n+yx+018dotQ8KrDoEfl6t/wkXwP8PaOTrB1az/ALD1XWE+y/b2sb2zAPfPH/xP8A/C7R5dd8e+KdJ8OWKRu8K3tyv2+/ZASYNL0yLzNQ1S5OOLewtriXALFQisw4n4CfBjxv8AtgfEbwl8a/in4Y1PwZ+zf8PNUg8SfCvwB4jga21v4qeJrc79M8a+JtLJZYfDNiCt1ptrceZBqUbLbWxvtKvtVubv7E+Fn/BPH9lz4W61B4rXwXffETxnbyJNF4t+K+tXXjrVI54iGhuI7G/WHw5DdwSAS29/DoUd/byhZIbmNlUj7dACjAAA9AMD9KAFooooA/L79sL9m74g6F8QE/ax/Zz0Ya/42h0uDSPjH8K4WMTfFXwpYJGttqmjBFYnxroVpBFBbRoktzqNpa2UdjDcXVpNpHiLyr4VfHr4b/F+1I8M60lp4itTJDrXgjXQuleMdCvbclLy01DRLhxcP9llV4pbuy+1WPmI0f2jzUkjT9lq+WPjb+xd+zh+0BetrfxB+HViPFuFMfjjwxc3fhTxessaqkE1zrGiS2j6vJbIqpbLrsWqw26gCGJMDAB87V5P8Ufjd8Nfg9pjX/jbxHaWl46Z03w5ZOl/4o1qZvlhttJ0OF/tlw00pSIXMqwWEDuhu7y3jO8ep/8ADrr4aA+RF+0P+1xDpPQaNH8XtPFgsef9QqnweX8rblMFy23qxPNe+fBj9hn9mj4FarF4m8IfD+HVvGsTiZfHXji+u/GXipLoHP22zvNZeaz0e+PIa70Kw0ud1LI7srEEA+Vv2T/2efiF8VPibpX7V37Qvh248JWvh22uYfgD8INUVvt/ha11BNs/jzxbaSoqw+Jr632/2dZXEKXdm5jvZ4LSXTNE2frFRRQAV+Pv7TPwK8f/ALOvxQ8T/tL/AAP8L33jT4YePZ/7U+Pfwn0GIy61pOrxmSS6+J3gyxXAupJ98134j0+IeYLmW7vJ92m3jX3hf9gqOvUUAfkL8Nvi/wDDn4t6RHrHgLxTputx+Wr3enpMsGtaW7YBg1bRpymoWEqudgaeAQTEb7aaeFkkb0qvZPi/+wL+zF8ZdZn8Vaz4Ek8JeN55XuJPG3w21S68EeIJLuRmeW9uhpRGjalqEztul1HVdIvr9yADc4yD4sP+CXPwylxBqP7Qf7Wmq6VwG0W9+Ltg+nPF3gdI/CMchiIwpCyI20cMDzQB4j8Vv2g/h98KhHpd3eS+KPHeoyxWXh74b+E0/trxlruqXbCKxso9KshPPYpdTMqJc3scSyYdLOO8uvLtZfoL9jH9mTxzo/inWf2n/wBoa1toPjP4x0kaL4Q8FxOLqz+D/gKVjMmhwuWkiHiXVFYNrE8BMlpFJdWzTC51bWrevoz4I/shfs8fs8u178MPhvpOmeIJY2jufF+rSXXiPxfcCVWW52+IdcmvtQsYrvcTdWelSWFhOcF7X5Rj6VoAKayq6sjqro4KsjKGVlYYKspyCCOCCCCODTqKAPxB+Lfwq8X/ALC/jfxL4z8I+G9W8XfsieN9Yn8QazpmgWsl/rXwF8Q6gynULiLT4/mn8A3cm1opYwsWmwrFZTvb31pbSeKfXvBXxA8FfEbR4te8D+JtI8TaVKqMbjS7uOd7dnG4QX9oSt5p12B/rLO/t7a6iIIkhUgiv1dkjSVHilRJIpFZJI5FDpIjgqyOjAqyspIZWBBBIIIr4T+I/wDwTg/Za8f61P4p0zwtrnwo8V3LvJP4i+DviG68C3Ejycu40m3ivPDEEkj5kmmttCgnnkJeeWRiTQB59Xzn8TP2i/D3hbU7fwD8PrG4+LPxn1yZtO8NfDbwaDq9+dSYHbJ4iuLHzYdD0+0H+kX32qRL1LVXuBbx2iXF7bfRK/8ABLf4TXbCHxP8c/2qPGWk5xJoPiL4t20+k3EX8VvcR2fhazuWhYZVhFcwuQeHU819hfBj9mz4H/s+adLp/wAIvh1oHhFrqJYb/VoIptR8R6nGrI4j1PxLq019r19AsiCWO0uNQezglLPb28RY0AeGfsXfsu618E9L8UfEr4r39p4i/aD+Lk1vqPj7V7UrNYeGtMgCtpHgHw7NllXS9GQRi9mtWFve3cNtBG91Y6Rpdw33JRRQBVvrGz1OyvNN1G1t77T9QtZ7K+sruGO4tbyzuomgubW5t5leKe3uIXeKaGVGjljdkdSrEV+IPxB+FPxE/YP8Qa1qPhzw7r/xI/ZB1zUrzWYY9Dim1fxb8Bru/me6v7W5syTc6n4G8x5JYr8v5dqvz391bat5j+J/3IpCAwIYBgQQQRkEHqCD2PegD8jPAnxa+GvxNsYr/wAC+NfD/iOOWMSNa2V/EuqWoYA7L/Rrgw6tp8oBGYr2zt5MEHbggnsNX1vRdAspdR17V9M0XT4FLT3+rX9rp1nCoBJaW6vJYYYwACSXcAAZr3/4k/sBfsi/FXUZ9a8T/Bfw7Z65cyPPPrHhC51fwNeT3MjF5Ly6TwhqGjWV/eSOxeS5v7S6mlf5pXc81+c//BNL9iz9m743fsx+FPjP8V/h8fG/jq7+K37TXhh7nWPEvir+yF0j4XftQ/GP4XeEYP8AhH7TWrXR5mtvCHgzQbS8a7s7kX91bzXtyrT3MrMARX3xl8Z/HfXrj4Sfsg6RJ438UXDLZeJPi1NbzwfDL4Z2VyWSbVrrXJ7Z7bVdTigEs2mW1nHdRXUirJpsOuzwyaa36vfsy/s7eFP2Zvhfp/w/8O3E+tarc3U+v+N/GOoL/wATfxr4x1JYzq+v6gzPM8ayNHHbafZtPObLTre2hluby7FzfXXsPhTwf4T8C6JZ+GvBXhnQfCXh7T1ZbLRPDekWGiaVahjlzBYabb21rG0h+aR1iDyNl5GZiSejoAKM4615P8aPjT8P/gH4A1f4kfEjWk0jw9pKrGkaIJ9T1nUpw32HRNDsN8cmoavfujLbWyMkaRpNd3k1rYW11dwfmddeNP2xf2q/+J03im+/ZM+DV9+90Hw/4ZhW5+M3iPSnw1vqOta/KbaXwo93E3nW6aa9hPbhhFPpuoRLDqVx5OYZxQwNSOGhSrYzG1Ie0jhMMoOcad+VVsRUqzp0cPRck1GdWpGVRxkqMKkoyS/TeCfC3OeMMBXz/E5hlfCvCOExLwVfijiCeKhg8Rj4QhVqZXkuAwGGxubZ9mlOjUp1a+GyzBVqOBp1aFTNMVl9HEUas/Uv2zSD+3H/AMEfyCPl/ac/aaJ56A/8E+P2qFH5k4r9Nsj1/wAmvxXuf2B/hPq11Zat4n8c/G3xb4k06aW6sfFHiH4lX15rtje3FtLZ3N5Y3iWUQtLie1uLm2kkhQO9tcTW8jPFI6trW/wh/aa+CJ/tr9nf9o7xh4qtbDEx+FXx6vv+E28M6xDFmRtNsNedbW98O+aRshGnRac0kjD7TrFtF5sjecs+x8PexGSy9lo39Ux1HE14x0vJ0KlLCqfL1jRq1ZvaEZO1/uZ+DPBmMj9XyTxZwn9pyXLSjxRwhmfD2TV632acM4wOYcR1MMqj92FfMctwGFg3GWLxGGpKdSH7J0V8b/swftd6L8erjW/Afivw7efC746eCET/AITb4Ya5KrXAhDRIPEHha9YRjXfDlw00DC4iTzrL7Va+cJ7K80zVNR+yK97CYzDY6hDE4SrGtRndKSTTjKL5Z06kJKM6dWnJONSlUjGpTknGcU1Y/GeJ+F8+4NznFZBxJl9TLc0wipVJUZzpV6NfD4inGvhMdgcZhqlbB5hl+Nw84YjBZhgq9fB4zD1IVsPWqU5KTKKKK6T58KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKM0AFN3KOpA+tflB+1V/wUJ8V6R8TtR/ZZ/Yx8E6T8Y/2h7CFD488T67cTQ/CL4GW0+B9o8b6pZyxSar4hgByPDNldQSW85FvNJf6tBJ4cm+Tbn9jX4y/GE/23+1h+2j+0B8RdYvP3114N+GPiVfhN8KtNkk+aSysfC+i2bw3sVvkwRaqtnod7dxKr3NusmRX7nkHgjiquVZfnvHfE+W8AZdm+FpY/KMtxGBx2e8X5rl1eMZ4bNMPw3l/sYYDLcXTftcFi+Ic1yP+0aDhictp43CzVc/OMz8RKUMbicu4bybF8TYnBVp4bHYulicNl2R4PFU3y1cHUzXE+0licXRl7mIpZZg8esLUUqWKnQqxlTX2b/wROI/4dLf8E+B3H7L/AMMgR3BGjpnPp+NfqLkV/OzpX/BNT4eeArK0X4G/Hf8Aaf8AgZqelQpFo134C+L2pWum2YhUrDBcaK1okVxpy5Ik062udPimjLRF1jYrXeeHv2xP2u/2HdS060/a/ktv2lf2Z57200yX9o/wT4cTRviZ8NI7udbSyvPib4L03NlrOipI0MU+o6ak+ofvDNJr2ta1c2Ph+79XE+A+FziEoeHHHeA4vzeMZOjwtnGS4rg7iXNHFXdLIaVfG5xkWa4xpNUcrjxBh83xs3CjlmX47ETVFcdLxJrYGcZcVcN4nIsC2lPOcDj6Oe5Tg72SnmU6eHwOY4Kgrrnxjy2pgqCvPE4mhSjKov3rornfCPi3w1488MaD4z8Ha5pviXwt4n0mx1zQNf0e6ivtL1bStRt0ubK+sruEtFNBcQyK6MpyMlWCsrKOir+e61Krh6tWhXpVKFehUnRrUa0JU6tGrTk4VKVWnNRnTqU5xcJwmlKMk4ySaaP1CnUhVpwq0pxqUqkI1KdSElOFSnNKUJwlFuMoyi1KMk2pJpp2YUUUVmWFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFeV/Gb4z/D74B/D/WfiV8S9bj0Xw5o6KihVE+pavqU4b7Doeh2AZZNS1jUXRktbSMqqok13dy21ha3d3AAeqV+af7e5/wCL/wD/AASO9v8Ago7rRPsP+HdH/BQMZPpyQPqRXz3rXxc/bA/ajZtVtPE17+yf8HL0s+h6H4ahS6+M3iTS3INvqOteIpTDJ4Sku4j51vFpLWFxahxDcWeqQiHUrjz6+/Yr+HOt3FlqXirx38avGGvaddnUbHxF4k+JWo6hrVlqjWl1YvqdldfZYxaXzWd9fWn2mGNZvst7dW5dobiVXAP3xor8NtL8F/tP/BF11f4A/tGeMPFNnZYlb4W/Hi+bx14X1eGP5206x1uYQah4bWQrth/spNOkklYfaNWtojLI335+yx+2H4f/AGg5Na8DeJ/D918L/jp4KiVvGnww1q4WWY2+YYx4i8KX22Nde8NXDzwN9oiUz2BubZbjz7K70vVNTAPs2iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK/LX4//ALZvxD8WePte+AX7Ilvo9z4j8MSmw+J3xw12BNQ8H/Di83vFNofh+zeO4s/Efi+3ljkjlSeK9sLO5gns30+8MOpXuigH6f32oWGmW73epXtpp9rGMyXN9cw2lvGPV5p3jjQf7zCvzH/4I+6lp5/Yd8H6UL+zOqW/xv8A20rq400XUH9oQWuoftsftDahYXM1nv8AtMUF9YXdrfWkzxrHc2dzb3MLPDNG7fLr/sh+EfGF2uv/AB38a/Eb49+LJC0txqvjjxfrtvpkE7nLpomi6TqNr/ZOnrwsOm/2hd20EYEUYWELGr779iT9nWby7jRfCOqeD9XtiHsdf8KeLvFOnavp8wGFntJLjVr6zSdOqyyWcrA+xYEA/eKivxH8P/Gf9pj9jyWPUvEfiTX/ANpv9na0ZP7fh8QFLj4y/DvSQ5E2r2OuyPu8Xadp8JE13DqkjIIYjHEvhuyjn1MfsN8PvH/hH4p+DPD3xA8B63aeIfCXinTotT0bVrMt5c9vIWSSKWKRUmtb2znSWz1CwuY4ruwvoLiyu4YrmCWNQD8oPENx/wANY/tdeMda1zOo/Bf9lbWT4J8GaDNmTSPEfxfi2v4q8S39swkgvJPDdzELK1jk3IqwaHdw7BcalDc/ZNfEn/BP7/TP2eofElwd+r+MfH/xC8S6/K3M02sXPiS6sZpZz1MrW2n2uSxLFQvOMV9rTRJcQywSGQRzRSQuYZpreUJIhRjFcW7xTwSAMdk0Ekc0TYeN0dVYfCZU/b4VZhP3q+ZyeYVpv4v36UqFK+6hhsN7LD010hTva7k3/ZXiXSjk/Ec+B8IvZZN4d0o8F5XhaelFTydujnOZcqfLLF59nqzLOsdX+KtXxripexpUIU/zk+Iv/BVj9j34b/tXeC/2NLzxT4r8V/GTxf498E/Cy8k8B+DtR8U+AvAXxJ+Iiatc+D/AfxG8e2kkfh7wt4x1jS9C1nXI/DElzda7b6Lpt1qF3YQRRkV+kFfzpfty/svfA/8AZG1T/gjd8KPgJ4JtvBnhRv8Agrj8LPE+tTS3+p6/4n8Y+L/EHgP4rXuv+M/HXjDxBeal4m8Z+LdauSpv9f8AEWqahqDW8Fnp8M0Om2FjZ239FtexJQ9lGcOa6rVaUnKy5uSjhanMoq/Kr1pJJuTaScndtL8twlbFTxGLpYn2SdP2E4RpczUI1lUlyOclF1HFRjefJBNt2hGNkvjr9rDwNrGlabov7Snww26X8YvgLL/wlen31uhQ+JfBtiXl8VeEtb8opJfaVNpEmoXC2zmRjE2o2FuIv7XnkH6nfCr4h6N8Wfhv4I+JXh4t/Y/jfw1pHiOyjd0ea1XU7OK4msLlo/k+16dcNNYXij7l1bTJxtr5p1KyttS06/069iSezv7K6sruGQZSa2uoJIJ4nB4KSRSOjDuCRXEf8EttQu739jD4dW1yzyR6NrnxB0ixmkJYy2Fv45124hIJJ+SJrqS3QcBVhCgYWuXLW8Nnk6MNKWZ4GviqsF8P1vAVsHQ9tb+etQxcadSX2lhqN9UfRcfUln/g/hs1xlqmY+H/ABjlPD2XYuWtefDfGuWcS5o8qnU+KeGynOeF8RjMvoybVCWf5o6doT5Y/oZRRRX1p/MoUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV8If8FGv2l9b/Ze/Zg8VeLvBKfafit431XRfhP8ABuxVI5Zrj4keO5JrLSrq3glVo7i40HTrfVvElvaypJb3lxpMNlcL5Vy5H3fX4uf8FSZn1P8AaN/4Jm+Db3LeH9S+O/j7xldxt/qG8QeAPDvhi88LO4zgzR3GrX5tyVJBZwGXPzfq3gjkOWcReJ/DGCzrC08flGBec8TZnl1X+DmmA4N4fzXi7FZVWSaboZpRyOeArKLU3SxE1Bqdmvi/EPMsZlXB2cYnL60sNjq/1DKsJiofxMJiM9zPBZJSxlPp7TCTzBYmm3eKnSi2mkyb9lT9nfRf2bvhTpnhKOX+2vHGtyHxP8VPG91JJd6x43+IGqg3Wu6xqGpXO69u7eK7mmtNJW6kaSKwjSScyX9zfXVzR/aq/bD+CP7HXhHw54n+MGqeIrjVPHfiWDwV8Mfhv8PvCeufEL4rfFXxpdQtcQeFfh34A8M2t5rfiHVTCvmXEqxW+l6ekludT1Ky+1WvnfUdeX/F7+39N8Ea34z8CfCrQfjH8VPAOk674l+FPgfW9f0bwW2seNv7B1PSrPStO+IGt6Rrlt4BuNfsdSvvD134oXTrkWelarfw3MFzZXFzbTfo3EWc5txBj80z3MsZLE5tmeJq47GYupRlWlOrUlz1PZYek46Qpr2WEw1JKnRhGjRpUvZU40j5TKsBgssw2Dy7C4dU8FhKMMPQoRqRpJRhHlhz1ppq8p2nXrT9+o3UqTnzycz5M/Zg/wCCknwJ/ad+J+s/AmLwd8e/2fvj9o3hT/hPv+FGftS/B7xB8FviTrXgL7cumP4y8M6dq8l/pHiTQob90triTRtbvL21JeS5soYYZpI/vTVdK03XdL1HRNa0+z1bR9XsrrTdV0vUbaG80/UdPvoHtryxvbS4SSC6tbq3lkguLeaN4pYneORWViD/AD9/B3xj8VPjN/wVq+C3jH9vX4Ot+xt8afAP7PXxi0j9jf4IaL4q0L4yeE/jRp3iFtEk+NvjCT9ojwvc6bpGueJfA3h+G1hPwduvh94T1TRNL1I+NRqesWkiqf6E68XK8XXrUlWlNxq0sRUjTqxhPD1l7Gp+7qTpXdTDV1ZScHKM4tKfLTcuSHoY2hShP2ajzU6lGEpwlarTbqQ/eQhO3JWpauKkrxavG87OUvj7/gnh4j1L9lv9p74o/sDaxqN5efCrxN4eu/j5+y1LqVzNcyaDot5qjw/ED4aW9zO00ksem6kbvWdLtBLuittK1vW7xnu/EeB+5NfgR8bnbQv+CgX/AATP8U6WTFrV14/+Mng668o4lvPD/iHwPp1hqEU3TzILOC+vHRSdsTXkkgUttZf32HQdeg69fx96j6QGGp4zNuCeOHCMMw8QOCqWc8QuK5XiuI8l4h4g4PzLNZxWksRnlLh3B51mFdW+s5tmGY15L2k5leGNWWHwXEHD15SwvDHEE8Blab5vY5Vj8ryzPMJg03qqeXyzSvgcNBt+zwWHwtNO0UktFFFfgB+mhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABX4kfEzWm/aq/a48W3WrM198Gf2VtXbwX4S0GT95pPiL4wIobxZ4j1C3O+C7l8M3MQ0u1ikLpGLXSLy38sXmpwXH7bnoa/BD9iCWTUfgjJ4luyW1jxh8QviD4m192/1sms3niK4tbh5zklpjDZWwYszHaFG4gCgD6/ooooAK+W/2kfCuu6JbaH+0X8MWGl/GD4FT/wDCV6VfwKynxD4TsPMm8UeEdaEJSXUNJu9IfUJPsbs7PG9/p9v5Q1e5c/UlVry1t76zu7K7jWa1vLae1uYnG5Jbe4iaGaNx3V43ZWHcEigD75+FPxF0X4t/DXwN8TfDpI0fxz4X0fxLZwu6yTWY1SyiuZ9OuXj+Q3mmXLzafeBeEuraZB92vQK/O3/glfqF3d/sXfDy0uXeWLQ/EHxF0bT5nJYy2EHjrXrqEhiTlI3vJYI8BQqQqgGFBP6JUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHxX+3x8a/EHwW/Z91STwPLJF8SviZr2jfCb4cPAxW5tvE3jJriBtStnUM0V3pej2uq3unT7WSLVotOEmVfa3yn8HPhbofwd+H+heB9ERJGsYBca1qhXFzr3iG6VJNY1q8kbMskt7dBvJErO1tZR2tkjeTbRgdV/wUXklm+Ln7DmmXGTos/wAVfGup3Ib/AFP9s6PomgSeHy3GPNEtzemDJzu3bQecdNQAUUUUANdEkRo5EV43VkdHUMjowKsrKwKsrKSGUgggkEYryr9jLXZvgB+0940/ZoWWSP4X/GHQ7/4t/CTT2LG28NeK9Mcp428KaYvAitLvTre41lLZf3NjZ6TpyIpuL28nm9Xr508Zu9n+2B+w1qFgzJqx8ffEDTB5ZIkk0bUvC1la60Gxy0SWcrq+QQqTSDIDtkA6H9m23/4VB8WP2if2YdXBsrrwr8Q9W+JPw9hm+Uar8NPHUlve6e+n8BJ00WR7SDUpIiUj1DUpLYDfbTLH9pVg/thfsw+Ifiq3hX4xfBjUbPwz+0P8KVnk8J6jebY9L8Z+H5TLLqHgDxLIxVDYagZrk6bcXJNvaXN3eW8rWtvqc9/Z/N/ww/av8HeJdTm8AfFO1m+Cfxm0aSOx8QfD7x6f7E82/AANx4a1bUPIsdZ0++OZtOVJ1vp7dllgt7qzMF/c/CwSyes8txX7qh7Wo8rxM7Ro4jD1JOpDC+0fuxxWF5nQ9jJqdajThWpqd6ip/wBkYmU/FLKaXiBw3CWZ5vHLsFDxFyHCx9tm+S57gsLQwWM4jeApqWJxHDnEkqMM3WaUIVcNluZ4vG5VmE8NKlg6mN/I39rT9lv/AILW/tQ+Pf2bvE95pn/BLjQNO/ZU/af0D9pP4dxW/wAU/wBrBL3xRqPhHS/FOg6HoXjSKT4IX8FvZ3mmeJHuNW/sO5jmjv4ESzvDb7i/7N/sz3H7V1z8O7mT9sbSv2e9H+LI8Taktnafs0a/8R/Enw7bwcLHSjpE1zqHxR8N+FvEq+JX1I62upW0WmNpcdlHpb2t1LPLdxw/QaOkiLJGyvG6hkdCGRlIyGVgSGUjkMCQRyDivHPir8f/AISfBjTp73x74y0rTr1Iy9p4ctZ49Q8U6pIQPKg07w/aNJqMpmcpGLmWGGwhaRHuru3iJkHo1sXSoYeTryoUaMb1JVajVNRbjTjKbnKSV5RpQi+6Wiuz4PJeG8zzbNoYTJcLm+cZpjZRp08vwdGrja9eSvGEYYbD0ZVX7Pm0aVoLWTtqUP2k/ijafCD4L+OPGMswTVBpFxovha2XJuNQ8Wa5FJp2g2trCv7yd47yZb64SENIlhZ3k4XbCxH1H+xx8KL34JfszfCH4carC1vrmkeF01HxDbOB5lp4i8T3l34o12xkKkh307VNZutP8wEq4tQy4UgD4u+BfwU+JX7T/wATfC37Qvx78L3vgP4SeAb0az8EPgvrSlNa1nWhsaz+Inj2zYIbd7crHdaLpdxGknmxwGOJdKjnuvFX60gADAGBTyShVxOLq5vVpzpUXh/qeXU6sXCrOhUqQrYnFzpySnTjialKhGhCaU/ZUFVaSrKKz8XM4y/IOG8u8L8vx2EzLNY55HirjvF5fiKWMy7CZzhMBicryDhnC47DzqYfHYjh/B5hndfOMVhqlbCLMs6nl1CrUllVWrVWiiivqD+dwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr8j/wDgsF4M8QQfBL4VftJ+EdMn1fXf2R/jb4P+L+q6bao0l1qHw9a4XRvHNjEqsGSLZPo2o6nOcJa6NpupXLsiRNKn64Vla7omk+JdE1fw5r+m2es6Fr+m32ja1pGowJdafqmk6nbSWWo6dfW0oaK4s720mmtrmCRTHNDI8bqVYg/Z+HnF0+BONeHOLI4RZhRyfMYVcfl0punHM8pxNOpgs5yuVVXdKOZ5TicbgHVSbprEOaTcbHgcU5HHiTh7NckdZ4aePwsoYbFKPO8JjqM4YjAYxQ+28JjaOHxPI9J+y5Xoz87PCfinQfHHhjw94y8L6jb6v4c8U6Np2v6Hqdq26C+0rVbSK9srmM9R5lvMhZGCyRvujkVXVlHyL+114K/bhv8AVPhj8Rv2KPir8K9K1rwHP4jt/HvwE+PGi3y/CT426D4gg05beS88feD9H1P4i+AfGPhCXT5p/Ct/pEWoeH76fVJ4fEOmmzif7T5h4k8K/E//AIJVeJtX0bVdA8V/FL/gn/r+uXeq+DfGug21z4i8W/s0z63eSXV34Z8ZWCF76+8DJe3DNZ60CyuZRcRyv4hvZ9D1H7i+Gvxg+F3xj0OHxH8LvHvhfxzpEsaSNP4e1a1vp7PeARBqmno41DSLxMgTWOqWtneQudk0CPxX9FcUcHexwVPiHhzFYnPuAc1q+1yDi3L1LkjBuFWnleeex51kvE2BUo4fNsjx6hONWMquHjjMsxGExmJ/Ksmz7nrvK82o0ct4mwcPZ5lkmK5eZyUeSWMy7ns8flWJs6uDzDCOS9m1CrKhiqdWjT/MT4U/sp/tofHT9sb4H/tl/t3337P/AIAi/ZW8J/FbRv2d/gR+znq/jfxpHD4p+Nmg2PhD4gePPij8RfG2ieF/7RuP+EW05dL8P+F/DugyadB51rqc2p2t7aX9trH7BVR1LU9N0axudT1jULHStNsomnvNR1K7gsbG0hXlpbm7upIreCNf4pJZFQdzX59+P/2vfEfxp8T3X7PX7A+kp8aPjHqiiy1v4n2Efn/Br4MaZdu1vceLfEnjBoZtG1W5so98uk2tgdQ067vEWKI63qMSeGdS87hPgjNs+niI5VQ9ngMJzYzPeIs0rLCZHkmGfIq+acQZzXUMHl+Fo04wV6k4zqqNLC4KhWxE6GHn1Z1xDgctVGWLqc+JrcuGy3KsFD2+YY6reTp4PLMBTbxGJqzqTlJqKcYSnUr4ipTpqpVj2Xwwsz+0j/wVP8JT6Mg1HwF+wr8MvFOreJtXjzNp6/GD4w2D+HLLwuJkBha9s/D6Jq4+cm11LwxqtpOsVzabH/egdBXyJ+xZ+yT4V/Y8+D1t8P8ASdTufFvjLxBqd34y+LHxI1NXOt/ET4h61sk1rX755pZ7iOzjcCy0aylnme1sIVluprvVbzU9Qvfruvyvxi4vyniribA4ThurWr8J8G5DguD+GsVXoyw1bMsJgcVjsyzPO6mGnaphln/EebZ1nOHwtVKvg8HjsLg6962Hm39pwHkeOybKMRXzaMKedZ9mVfPM2oU5qrTwdbEUcPhcJl0Ksfdq/wBm5XgsBgalWDdOtXoVq9P3KqCiiivyc+2CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvwr+DmmN8HPjR+0T+zZqymzm8P8AxC1b4m/D1JRsGq/DXx7JBqGntYH7lwmhySWtpqUkZxHqV9PbYD20yRfupXwn+2Z+yxrnxkh8MfFn4QajZ+Gv2hfhUlxJ4P1O8Kw6X4w0KXzZNQ+H/iWXKqdO1EzXJ0y5uCbexu7y8hla1tdUvL22APO6K+avAH7SnhvVtWn+H/xUsLn4L/GPRpFstf8AAHjv/iTNLej5Rc+G9UvvIsta06//ANfpvlTC7ubdlmt4ruzMN9cfSisrqrowZWAZWUhlZSMgqRkEEcgjgigBa8c+P3xJtfhT8JfGXi+WYJqMWlXGmeG7deZ7/wAUavG9joVpbRDMkz/bpUup0iV5I7K2u7jaUgci38TPjh8LvhHYS3njjxdpem3Sxl7bQYJ0vvEupOR+7h0/QbVpNRnMrlIxO8MVlC0iNdXVvETIH/s7fs+/EX9pH4k+Fv2hfj74WvvA3wn8B3qa58Evg1rkfl65ruuIVex+Inj+xYA2q2xWO70PR7hFleWOBxEmkJPdeLAD7p/Yz+Et98D/ANmL4PfDfVoWttd0jwsmp+IrVxiWz8R+Kr688Va7p8pBIZ9M1TWrrTS4O1haArhSAPpyiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA/PL/gpT8Ptf8Q/AnR/ih4Psnv8Axb+zx4+8P/GKysokZpdQ0HQTNB4qsuOfs0WlXP8Abd8BlpLTRJY0DM4RvNvBvi7RPHnhXQPGXhu7W90PxHpltqmnzqV3eVcIC8E6qW8m7tJhJaXtux8y2u4J7eULJEwH6ozwQ3MMttcwxz288bwzwTIssM0MqlJIpY3DJJHIhKOjgq6kqwIJFfiv8UPgJ8T/ANi/xP4g8ZfB3wprPxS/Ze8Sajda/r3w48Pxte+Nfg1qF05m1O+8KafkvrPg4/NOLSMhrCBBFqT2S2kuv6mAe+0V4r4D/aK+CvxItIbjwx8Q/Dj3UigyaLquoQaFr9s+QrxTaLq72d+TFJmNpoIZrV2GYbiVGV27XXfiT8PfDFo9/wCI/HPhHQ7SNS7T6p4i0myQjGQsfn3aNLI3SOOIPJIxCxqzEAgHa14x+z3pT/HT9uh/GNgPtPgH9lHwhrOj/wBqKolsr34s/EC3n0i/0y2kyI5TpegfblvTGGk0/VNHiSUAXlrJXmNv8Rvif+1Jqdz8N/2SdF1GTSppm07xh+0JrunX2leBfBVk5CXv/COy3cEN1rviTyWcWUFtCLqNjHdWltJas2sad+un7O/wD8F/s2/C/Rfhl4JSae3s3l1LXtevgh1jxZ4nv1jOr+JNZlTPmXt/JFHHFHvkSx0+3stNgdreziJAPca8f+LPwB+Dfxz02PTPit8O/DPjSG3R47O61Ox8vWdOSQ5ddK1+xe11zSRISWkGnaha+YceZur2Cis61GjiKcqNelTr0pq06VanGpTmu0oTUoyXk0zvyzNc0yTHYfNMmzHH5RmWEn7TC5jlmMxGAx2GqWa9ph8XhalLEUZ2bXNTqRlZtXPwR/aM/Yt+Dvws/aa/YD+EvgG7+InhvwF+0v8AGr40eA/iLoVp8QNflji0DwJ+yj8b/jNokfh24upri40y5bxf8PtBS9nuZdR+0aQb6xVYpbhLqH9PPhF+w/8AsxfBPUoNe8E/CzR38TW8gmh8U+J57/xh4hgugc/bbG+8SXWorpF22Tun0aHTpCCw/ibPzx+2YwP7cf8AwR/5+7+05+00T17/APBPj9qgD9SB6dutfpwDnpXm0MiyXDVY1qGVYCnVg04VI4WjzU2utJuL9k/+vfKfeZt4y+LOe5fWyrN/EfjTH5dioOnjMHX4izN0MdTas4ZhGOJj/aEZXfNHGOupNtu7YAAcAYFLRRXrH5oFFFFABRRnHWm71xnP/wCvOOnX8uPegB1FAOelFABRRRQAUUUhOOvrQAtFN3LjOadQAUUUUAFFFFABRSE4o3Djn/P4UXAWiiigAooooAguba3vIJ7W7ghurW6hkt7m2uI0mguIJUMcsM8MgaOWKWNmjkjkVkdGZGBUkV+b/wAU/wDgkp+wp8Utdn8Vn4PL8N/FdzK00mv/AAd8Ra58NZfNkO6SZNE8P3kXhOOeWQmWW4Tw8txLJ88srsa/SekJA68c4/z/AJ/pX0/DHG3GHBWKq43hDijiDhjE4iCp4mtkWbY7K5Yqkr2o4tYOvRjiqOr/AHOIjUp6v3Tx844fyLiCjDD55k+W5vRpS56UMxwWHxaozdrzouvTnKjN2Sc6ThK3U/nA/wCCZH/BNb9l/wDah/Yd/ZH/AGmf2gtM+IPxW8ffFr4MeCviJ4o0vxL8T/GaeDofEWt6et1eHSdE0jVNMuLawEpxFZXOpXkfljy5jMhZT+/3wz+E/wAMvg14XtPBfwp8A+E/h54Vszvi0LwhoWnaFp7XDKqy3lxDYQQ/bL+faGutQuzPe3TjzLieVyWr8+/+CJpH/Dpb/gnyPT9l/wCGQ59f7HXj61+o1ejxT4l+IXG9GjheL+NeJ+I8Hhp+1w2AzbOcfi8vw1WzTq4fL6lZ4KhVabUqtKhCcr6yZy5Nwjwvw9UqVsj4fyjKq9VctXE4LAYahiqsNPcqYmFNYicFZWhKo4q2iQUUUV8OfRBRRRQAUUhYDqaQMDwDz6d+/H1oAdRRRQAUUUUAFFFNLAdfb9elADqKQEH60tABRRRQAUUUUAFFGaKACiiigAooooA8i+LPwE+Dfx00yPSfi38OfDPji2t0eOyudWsdmsaYkhzINI1+ye013R/NJzKdM1G0MnG8tgV+N/7Vf7D/AMEvg98Wf2DPBvw5m+Ifhvwr+0j+2BqXwR+ImhW/xB8QXFnH4Itv2Rv2rfjZFH4ee8nuLvTNT/4TP4NeD0a+nub8No51Wx8gS3sd1bfvbX5p/t7n/i/3/BI7/tI9rX/ruj/goJ/iKAPevhD+w5+y58ENSt9e8DfCjRT4otpBPD4r8UT6h4y8RW92CT9tsL/xNd6mNHvDk5n0SHTXILA8MwP1kOOB0HFGaKACiiigAooozQAUUm4eo/OlzQAUUUUAFFFFABRRRmgAooooAKKKKACiiigAooooAKKKKACiiigD5u+Jf7IH7MnxfvZ9U+IXwV8Da5rF27SXmu2+lnQPEF9I+cyX2veHJtI1i9fJJVrq+lKkkqRX5p/8Etv2Tf2cviZ+yv4S+LnxC+EnhTxr4/u/i5+1P4dutY8Tw3ms2k+jfDn9q342fDnwZZSeHr+7n8NFdF8GeE/D+jLL/Y4nvxp4v9TlvdTuby9uP27d0jVnkdURRuZ3YKqgdSzMQABjqTivzJ/4I/On/DCPgyPevmJ8dP22WdNw3os/7b/7Rk0LMudyrNC6SxEgCSNldMqwJAP0n0nSNK0HTrTSND0zT9G0mwhW3sdL0qyt9P06yt1ztgtLK0jhtraFcnbFDEiLk4UZrRoooA83+LPxa8B/BHwLrXxF+JGuwaB4X0OENcXMgMtzeXUpK2ml6XZR5uNR1W/l/c2VjbI80r7mISGOWWP8xLr4tfti/tUE6r4M1Vf2T/gnfZfRLuXTLfXvjN4v0qTmDUpluWS08LWt/CEntTYzade2YkV4L3xDYyR3L0vG9yf2uf2tfFEWuMdR+BX7KerL4a0Tw9N+80fxh8ZipPiDVtVtjugv4/CkkcmnJaz+YkZt7B0H2XWdWt5/sivjcRisRm9esoYithsqoVamHpxwtSdCvmFSjN069aeJpONWnhI1Y1KNKnQnTlW5JValSVKcKZ/VuR8O5H4XZTlNTF5JlXEHiRnGWYDO8ZX4hwGHzfJ+CMBm2Go5hk+W4HIcwpVsszDiatl1fC5jmmOznCY2hlDxVDLMDgaOYYXGY1/DN/8AsJ+GfEOo6H4i8Z/Hf9pTxb4w8OXd3qWheKtW+JqXGreH9V1HS7vRdQ1Hw3c3WiXd1odxe6RqGoaVcS2l1582l313p888tpczRP0Nt4H/AGw/gYRq/wAE/wBoXWvjBpFifOn+Fn7QDL4hfVreMljaad478231Sxu2XMdnCkug6csm1rq5MKiCvmX4n/8ABaT9hb4WeNfH3hO+8QfGLxvoXwg1+78LfGv4vfCb9n34wfFL4H/BvxHpromr6N8QPip4L8Jat4Ysr7RDIq65Fo9zrQ0icTWWoNb39rd2sH6b+CfGvhL4keD/AAv8QfAPiLSPF/gjxtoGk+KfCXirQL2HUtE8Q+HddsoNS0jWdKv7dnhu7DUbG4guraeNirxSKeDkDH+xcNSiqtCGKwc3bkxWFxOKo1btc0XKaqONbmXvKOIjVhUSbcZx5j014rZ9mUp4HN6/D3FeAjdYjIs/4eyDNMtdJNQnTo0HgadbLeV+5HE5PiMvxmFn/u2KoVEmu5/Zi/a28J/tDw614avtF1L4cfGPwXsi8e/CjxK4XWdGbdHEdU0id47c674dmmkjWLU4baCWAz2ovbW3S90+a9+t6/Gz9qnwZrfhYaH+1P8ACpF074ufA2RdeuZLcNFH40+H9sSfFXhTXxDse8sU0iS+uoy5aaKzGo2tqY57uCa3/Vv4Z+PdE+KPw+8G/Ebw3K0uh+NvDekeJdN8wqZobfVrGG7FpchCypeWTyvaXkQOYbqCaJsMhFe1k+YYirUr5djpRqYzCwp1oYiMFTjjcJUcoQrunH3adenUhKliacEqak6dWChCvGnD8n8U+CMky3BZPxxwbQr4PhbiLFYvLMZkmIxFTG1uE+J8DSo4nFZPHG1r4jG5PjsHiaWY8PYzFOWMnh1jcuxlXFYvKcRjcV3FeE/tBftEfDn9m7wNL42+IN/cD7RONN8N+G9JiS88S+L9dlXNtovh/TTLEbm5k4M88jxWdjCfOvLiJCm/3ORgiO7EKqqWZicAADJJJwAAO5OB1PFfi78NZz+1d8evGn7UPivOp+A/Auvan8O/2ctCugZdLstM0KfydZ+IUVs+YZNU12+XzrO8YPNbTGe3ZmfRdHmttc4zCthIUMNhIwljsdOcKDqJypUKVKKlicXVimnOFCMoKNNOPtK9WjTcoxm5LzvCvgfLOJ8TnOfcUTxdLgzg/DYTF51TwNSNDH5zmGY1qlDI+F8uxM6dWGExecVqGLr18bOlV+oZPlubY6nSr4jD0MPW3rrWf22f2k86x4k8ev8Asn/De/HmaT4D8A266h8U7rT5Rugl8S+L7r7JdaDqLRNu26U9hJESYb/w9bXEQlOcf2LtNci6m/aL/asl1nG4623xin+3+dnd5qudFIHz/MAQxGBly3zV9i39/Y6VY3uqapeWmm6Zptpc3+o6jf3ENnY2FjZwvcXd7e3dw8cFraWtvHJPcXM8iQwQxvJK6opYfkWf+C53/BPZNWt55vGfxctvhFeeKF8F2X7Ud1+z38Zbb9lW88UPqh0RNOt/jpL4PXwg9m2sBrAeJPPHhP5Wvv7e/ssG/rwY5PSxMubEvFZliNOaria9apLmk0v3dGEoUMMpS0hTw1KlHZRTkmftE/E/MsjhHDcOUuHeBMnTcMLlPD+TZXhYeyikuXHZnjMPi87z2qo8qr4zPMyzHETv79SMOWEfr62H7bH7OxGseAPipP8AtPeBtPAl1L4afFlUi8eyWEZBm/4Rzx7E019qGrGFWMK6nMLYMNsOi6ncskUn6Bfs4/tLfD39pXwjc+IPB732la9oN0NJ8ceBPEEX2LxZ4J15TKsum6zYMd5ieSC4FjqUQ+y3ogniHkX1pf2Fn5xb3EF3BDdWs0VxbXMUc9vcQSJNBPBKoeKaGWNmjlilRleOSNmR0ZWVipBr4m+O0d1+zX8UfB37YvgOCW0s7DVtK8IftBaFpybLbxh8O9evbXTP7curaIok+uaDdvYi0uHBkmuho0k0i2+nXCXBGvXyJqvCtXrZZCSWNwmJq1MRPC0XJRni8JWrSnXhHDX9piMPOpOi6EZujClVilOK+T5L4vwqZJjMoybKPETE0qkuE+Jshy7BZHQ4jzWFN1MNwzxPlOV0MLlGJr55KP1LKM/wmDwmZUc3r4SObVsxwWIqVMH+09FVLC9tdRsbPULG4iu7K/tYLyzuoHEsNza3USz29xDIuVkimhdJI3XhkYEcGsnxb4m0jwZ4X8ReL/EF2LHQvC2h6t4i1q9bBFrpWi2FxqV/cEEjPk2ttLJjIztxnmvtXOMYubklBRc3Jv3VFK7lfayWt9ran8k0sPiK2Ip4SlQq1MVVrQw9LDQpylXqYipNU4UI00uaVWVRqnGCXM5tRSufPv7TP7VXgj9m7RdKi1Cx1Pxp8RvF87af8Pfhd4ZXz/E/i7UtwiUoiRXD6bo8Nw8Ud7q0ttPsLiKytNRvClo/wtceHv2z/j5nWPi58cdQ+AXhq+/e2fwr+BjLYa5p9pIcrDrnxCM0movqflBUvIra51fSpXJkggsQ0lmMv9mXQ9X+L3iHxN+2L8ULYz+OPind30Xw7028/fxfDv4WWdxPY6FpGio/yWtxqdskk91ewKr3tpIt5lJtZ1YXX2xXxLrYjO0sVXrYihl1T3sFgKFWrhvaUH/DxGOqUZQrVZ4iKjVjhueNCjTlGFSnVqqU1/XVPLcl8Ip/6u5LleS5vx1gEqPFnGWcZdgM/jl+dwSWOyHhDA5nQxmU4DB5LX9pgK/EH1OvnGZ4+hiMVgcbgMulh8PP4v8A+GMLC3JutK/aO/ar0zWgN0etQ/GG4a8E4HyyzFdHhMg3cusbwMwJCyR5yNO28e/tpfswFdXuvEg/a3+EVj8+s6Nq1hHovxk0DTEy097o+p2f2geKXtIgZZl1KTVby7K+XDZaZCZL6DH+Mv8AwUI/ZW+A37SHwY/ZM+Ivj69s/jr8eb7QdO8BeENG8K+JfEUKXHivU9U0jwoPFWuaNpl3ong9fE99oPiJdB/4SK/sH1OHw5rt1bI9tptxKv2rQsqp0FGtgZ4nLqrcvZ18LWqqEp07JqpQqSnhcVGLa54VqVTfRxdmnLxIzDOXUwHF2D4f46yuLVPGZVn+UZbUxFKnUim1l+dYHD4TP8hxPs23QxGU5lhJQbXPCtS5qMvbvgn8bvh3+0D4B0z4jfDPWRq2g6gWt7mCZFt9W0LVoURr3Qte0/zJJNO1ewMiedAzPFNDJb31jPd6fd2l3P61X4yPct+yJ+1L4J+Jfh1hpvwb/aQ8SWXw5+LmgRfudH0b4gak0z+EfHVvArLb2cl1dPcnVpggiS2Gvzy+ZcanbG2/ZuvoMnzGpjaValiowhjsFUVHFKmmqVTmip0cVRTcnGjiab5lCUpOlVjVouU3S55fh/ilwPgOEcxyrMuHa+KxfB3F2Xzzfhyrj5U55jgfYYmpgs24ezapRp0qNXNMizClPD1MRRpUqeYZfWy3NoUMNDMY4akV8jftE/tW6T8HdR0v4eeC/Dl58UPjf4pg8zw38O9HmWJbG2cMF1/xbqIDpomiQhJJgZds13HDI5azsUudUtPZfjd8UdM+C3wo8dfFDV0Wa18IaDdahBZvJ5Q1LVZWjstE0oS/8s31XWbqx09ZMHyzc78Hbg/Af7NHw31TSdBvvi38QpDq/wAZPjEyeLfGet3ibrvT7PVNl5pHhWwDljp2m6VYG0SWwg2RxXKLaAG00zTo4P2fgThjK6+Ax3F3EmHnjcny/GQyvLMmjWqYZcQZ7OjHFVKGJxNGUMRQyjKsJOjic2lhalLF1pYzL8Fh62HeLqYvC/CZfhaLpzxuKi50Kc1SpULuP1nEcvM4ykrSVGlFqVZwam+aEIuPO5Rzp/ht+078Wz/avxs/aM8T+C7e7/eL8PfgPIPB2l6RDIN32KbxMRNqWrlN2yZNSh1VVkVhFqN1CImWt/wyZ/Zp+1+Ff2h/2lfDmsRkPDqMfxQuLpGlBzuvLX+zrY3cROPMgFxAko+VyVJB+uqK/RY8a59QXssvllmU4JaQyzKskyfBZbGmrctOphKeCcMWrK06mOeKr1nederVm3J+h/aGJjpSdKhT2VGjQowpJdnDkfP5uo5ye8m2fLln8b/2nv2ZXS7+LkkH7RPwYtyq6p430DSYNF+J/gywVlDalrGi27Lp+u6Zaxb2uJjLPdMqyXV9rdiqpBP+k/gfxx4V+JHhXRfG3gnWrPxB4Z8QWaX2larYsxhniYlZI3jdUmtrq2mSS2vbK5jhu7K7hntbqGK4hljX54kRJUeKVEkjkVkkjkUOjowKsjowKsrKSGVgQQSCMV8vfBG8f9mP9p2H4S2kjW3wW/aKi1XXPBOmFtun+DPifotutxrGkachby7TTNesBEkNuqqHup9DsbVFXT53n8PPMjyvjTK8zx2ByzA5Pxfk+BxObzp5RhqWAyvifK8BTeIzWLyrDxhg8vzvL8HCtmUJ5ZRwuCzDBYXGU6mDjjo0a1fGtQo46jVnTpU6GNo05VnGjFU6WKpU1er+5jaFOvCF6i9kowqQjNOCmk5fqpSE4GaAcjNfEX/BQv8Aac1D9lT9mDxn4/8AC0KX3xO8RXmlfDX4P6U0cdw+o/EvxvLJYaC8dpIdl6dEtY9S8TPYsCt9Foklk2Bcbh+ScMcO5pxfxFknC2SUY1824gzTBZRl9OpNUqX1rHV4YenOvWacaGGpOftcTiJ/u6FCFStUahCTXxucZrg8jyrMc5zCbp4LLMHiMbiZRjzz9lh6cqko0oKzqVqnLyUaUfeq1ZQpxvKSR4l+1l/wUN1PwF8Rpf2Zf2UfAMHx5/aeazS78QWlxdyWnwx+DWnTpE0Ws/FDXrW4tj9qVbi3lTwvaahp148VxCl1qdlfXWk6Zq3yBc/syftX/GhhrX7UP7dnxsN5dlppvAH7OOqQ/B3wDo4c5XS4prGwaXxNaWy/uo9Q1fQbTVJI8GaeS433UvsH7Jf7OWnfs6fDC30m/nPiD4peMbhvGHxk8fX0rX2ueNPiBrDS3+s3V7q05e7vbHT7y8u7PShLJhovP1GVP7S1TUZ7j6ir+r6OacPeHTeSeGeX5TOeBbw+P8RM2ybL814n4lxlJ8mIzDK55vhsbT4TyOrUjL+ysvyalg8xeB9jPOcxx2LnNUfxSeCzTiq2Y8XYrGqOJXtcNwtgsfisFlGU0J+9Sw2MjgquHnnWYwg0sZisfOvhliHOOBw2Hoxi5fm54b/4J1v8J9G0rTf2eP2vP2tfgv8A8I7aQ2XhzStN+JUWq+A9NtbVNtrZSeAbbS9A0q50yDjZpa3NvYbcoIF+Ur6h4V/bo/ap/Y51nSdB/bq07SfjH8CNQ1C00m0/aw+GGgNpet+EJby4S0spPi98PtMgW0hspJJIFk1Lw9ZW32cNstbjxbqtwLGOb4Mft/fsu/tBftFfF/8AZa+Evjy88V/Fz4G2Goal8QLKDwv4jtfDNtbaP4ni8E63/YnjK902Dw34lfRfGBuvDGqDQtRvltNc0vWNPdvO0u8EX1vr2g6L4p0TVvDfiPSrHXNA13T7vStZ0fU7aK807U9NvoXt7yyvbWZXint7iCR45Y3UqysfrUvj3DcW0lhPEPKMn48yLEuVGtjHgMrwHFmXx5nTni+H+MMBg6Wa4bGYWSc6WEx9bMsir1acaeYZTiqacU/9WquSTdfhfHY7hvMqPLOFD6zjMVk2KdlONDNMjxOIng61CtFpSrYaGEzCnCfPhsZSla/6C+HvEOheLNC0fxN4Z1fT9f8AD3iDTLHWdD1zSLuDUNL1fSdSto7uw1HT761klt7uzvLaaKe3uIZHilikV0ZlINbNfh9/wTk8Wa1+zR+0P8U/+CfHibVb3U/h4+gT/HX9lbUNVupLi6sfA+p6q9v4z+HAuZ3ke4Ph/Wpbm/0u3U+c0Vh4m1m52xalbQ2/7g1/OXiTwRLgHinEZNSxv9rZPi8Hgc84azr2P1f+2eHM4w8cXleOqYfmn9WxkKcp4HNcGqlRYHN8Hj8D7Wr9X9pL9X4S4iXE2TU8fUw/1LHUMRiMuzfAc/tfqOa4Gp7HGYeNVJe1oSly4jB1nGLxGCr4au4QdXkSMwUZPAr8ef2gP+CifxF8X/EzxJ+zh+wP4N8P/E74h+E5zpfxQ+OPjGa5X4JfCG/aR4JtM+0WBEvjHxXavHcK1jp8strZXlrJFHp/iZrPW7HSvSf+CpH7QPjj4Z/CHwb8FPgzftpnx2/ar8awfB/wFqkMzw3fhXQbuOJvH/jmCWFluLb/AIR7Rry2sV1G3ZbjR7nXbXWrdhNpqA8j8A/gZ4G/Z0+F/hv4WeAbCO20rQ7VW1DUmhjTUvE2vTxxf2v4m1uZMm51TVriPzZSztHaW622m2Yi0+ytIIv0/wAN+DOHsj4WwniNxjlOH4ixmd4zHYPgPhTHzrwyevSyitHDZrxbxHSw1WhiMflmFzFyynJcnhiKGHzTM8FmtTM51MvyyWXZp8dxZn+a5jnNfhTIcdUyrD5fQw1fiTOsNGDx9OeNg6uEyXKp1Y1KeFxlbCqOMx2PdOpVweEr4SOEjHE4tYjC/Ls/7Hfx2+J7f2x+0j+3n+054z1u6HnXWh/CjxRbfBv4f2k0nzSW9p4W0WyvtOmhgJ8uK7hsNInmVUd7eHJhDYf2JPid8P2XVvgD+3V+1r8PfENt+8tbbxp49j+KfgaaZCGiGo+CtVtNI0+/jJUI/wBulvUVM7YGG9JO3/a1/b6/Z2/Yp1T4X6F8b7/4g/2/8Y18ayfD/wAP/Df4VfEH4sa7rMPw9h8OXHi24bR/h9oHiDULO30qHxXokkk91bxRSJcu0bMLeYpX/Zc/b9+An7X3iXxL4U+EenfGqy1XwpoUPiLVX+KHwD+Lnwi019Pnv4dNRdN1X4i+EvD2n6rfC5nQvp+n3FxeRwb7l4RAjOPvo+MHFHtXl9LM8gp4VP2f+rlHhXhCnw/GCgpfVv8AVmGSLJXRVK16MsBKLp/GmrnzL4EyZU1i54PM51Xaf9rVM5zyWZSk5KKq/wBrvMPr6qOdvfjiU+a1raI6/wCFH/BQ341fADxx4b+D/wDwUR8O+G9O0bxXqMGg+Af2s/h7FNbfC/X9VmU/ZNN+JelSRwJ4G1e72SNNqkMGl6PE4eVtEtNAsb7xIn7XRSxzIksTrJFIiSRyIweOSNxuR0dSVdGUgqykqwIIJHNfmB8Tfhp4M+MHgXxJ8OPiBottr/hPxVp0um6pYXKruUPhre+spypey1TTrlYb7TNQgK3Fhf29vdQOssSkcP8A8Erviz4y0W2+Mf7EHxa1u41/x5+yhrGlWngXxJqDk33jL4EeKLdrvwBfyB3kaa58N2qw6TeeW7Q6Zp1/4c0bdJcWNxNL8V4g8IcPcVcK5rx9wpk2D4Zz7hd4OrxvwzlEZ08hx+T5jjaGWYfi/h7A1KlWWTPCZvjMDlnEGSUakstpyzTLcwyejgcIsdg8L9BwvnuaZLnOC4ZzvH183yzOPb0+Hs3xzhLMsNj8Lh6mLqZHmmIjGCx3t8FRxGKyzMKkVi6iwmKwuNniK3sK9X9e6o6lqVhpFhe6pqt7a6bpunWlzf6hqN9cQ2ljY2VnC9xd3l3d3DxwW1ta28ck9xPM6RQwo8kjqisRer8XP+Cnvj3xN8YviN8Gf+Ce3w/1u/0GD4w2V18Tf2idf0iUw6lo/wACPDOoSWyaBDOiyeR/wnuuWN7pckjDYZ9O03Tb6K50jW9Qgf8AIvDrgqvx/wAV4Dh6ONhlWA9jjc0z3OqtKVejknDuTYStmWd5rOjGUHiKmGwGGrLB4NTpzx+PnhMBSqRq4qmz7ririCnwzkuJzR4eWMxPtMPg8twEJqnPMM0x9enhMvwcajUlSjVxNWHt67jJYbDRrYmUZQoyRzPjz9v39ov9qvxNr3gP/gnzo+g+FPhd4f1K40PxL+1/8TNKkv8AQ77UrVzHe2fwe8G3dvNB4intCoZNY1qw1PT7rzBHeaboUE+m6tf+by/sL+NfGrNqnxt/bh/bD+I3iKfD3LaH8TpPh/4SilOC50nwdY22s2ukRbs7LezvkgVesRfLV9yeDvB3hj4feFtC8FeC9EsfDvhbwzpttpOh6LpsIhtLCxtU2xxIuS8kjktNcXEzyXN3cyTXV1LNcTSyv5v+0H+0X8G/2Wfhnq3xd+OnjWx8D+CdLurHTI7qe2v9U1fXtf1aU2+ieFfCXhrRrXUPEPi7xbrtyDb6N4a8OabqWsahIsjQWjRQTyxf0pDjbA8IUpYHw2ybK+DMkwi9nDNa+X5VmfGmaQg0vr+f8WY7B18dHE4l/vamXZNUyvIcLKfssLl6UfbVPyWXDuIz2ccRxZj8Zn+YV7SlgqeKxuFyDBSlr9WyzJsNWpYd0qXwRxePhi8xrKPPWxXvezh8z2/7J/7Sfwjf+2v2ZP28v2hND1W0Alt/CPx2122+M3w91Jo8n+z59M1Wwgg0W2us+XPqVrouq6jAh3wK0qQtF9Tfsw/8FE/FN58TtJ/Zh/bW8CaZ8FPj7rOYPh94v0K5nuPgz8cTG6RL/wAIZrF9NNJoniK6aSJYfDWo3ty91cvHZJNp+tXtl4bPdeDvE8HjTwr4f8W2ukeI9BtfEelWesWuj+L9CvvDHijT7a+iWe3g17w3qscOq6DqghdGu9H1W3tdV06VjaalZ2d9FPbReQftN/s8+Ff2lfhVrPw/18Lp+sxD+2fAXi+BGTV/A/jawRpNC8R6VdwtHdW5gugkOow200LX2mS3Vp5kbyRyxFbPOH+P+XJ/FDLMuxFHGtUcNx3lGS5dlnGPDVeq1GjmdXE5VhsEuKssw82p5hkufxxtWvg/bQynHZVjXSxCUMuzPhm+P4PxmLpTw69pV4cxuYYrGZFm1KGtTCwpY2riXk+LqQThhcflssPCnW9m8bQxeHU6T/YsHIzS1+e3/BNL9pPxT+0T+znFbfFAlPjh8EvFmu/BD40QyNH9puvGfgd4rZPEEyo3zv4i0iawvr66jihs59fTXYrGNba2RF/Qmv5V4u4XzTgribPOFM5jS/tLIcxxGXYmph5+1wuJ9jL9zjcFWslXwOOoOljMDiIpRr4SvRrRVpo/aMjzjB8QZRl2dYBz+qZlhaWKpRqx5K1L2kffoV6d37PEYeop0MRTu3TrU6kG24nPeLPFnhvwL4b1rxh4w1qw8O+GfDun3Gq61rWqTrbWOn2Fqm+aeaVuvZI4kDzTzPHBBHJNJGjfkZ4m/a3/AGkv2mru6h/ZsitfgX8FhPLa23xk8ZaJHq/j3xpDE5imvvBvhO+3afpelSnzEhub9TdyIqzwa1puoxXOlW1v9szxJd/tE/tG6H+y3b3c6fCf4R6Xo/xJ+N1vazSQp4o8T6oIrvwT4G1B4WDNYwWE1trk8G9EuUvbuTEeoaNptxH6la21tZW1vZ2dvBaWdpBFbWtrbRJBbW1tAixQW9vBEqxQwwxKscUUaqkaKqIoUAV86eqfLsv7Mut645vvG/7Tn7T/AIr1qVjJNen4p3umWUcpO4nT9LS0u10+INzHbpdSwxKFWNVUYrS07wL+1F8I5BqnwO/am8e6+toRKPAfx6uv+FieGdWjTaTp/wDa80S6hoEEgTYJNGsra5ycC+tt0kx+l6KAPQ/2YP21bD4w+Ibr4P8AxX8Kv8IP2gtFszd3Xgy9uftGheMtPgR2n1/4faxI7Lqtl5cUt3PpZmubyztVmltrzWLWx1G+tfu2vxM/aF+FV7498MWnifwZcTaH8X/hrcjxf8L/ABTp22HVLHX9JZb5NJFxjL2OtNbJayW8xe1W7NrdSxSpA8Uv6Y/ss/G+1/aJ+A/w9+K8UUNpqPiDSDbeJtNgyqaV4t0W4m0fxLYpE7yTQ2w1ayubjTknYzPpdxYzScy5IB9BV5z8V/ix4C+CXgTXPiP8SdftvDvhXQIBJdXk+6S4urmU7LTTNLs483Go6rqE2ILGwtUeaeQ5wsSSSJ6NX4l/GHXG/av/AGsvEulaq/2/4G/sq6qvh3TPD8hMmkeL/jO8bf8ACQatqtscw30fhF45NIjtbgOsMlrBIi/Zdb1W2nAL2t/tAfte/tPu2o+AdRX9lP4L3h36LfTaXa698ZfF+lSZMGpTLdN9h8KWt9CqXFsNPksL+zMgeHUPEFhLHcSeZ6r+x3pPii70PWfG/wAdv2kPGXiXw5qreINA8Q638Tnu9Q8PeIpNK1PQ5Nc8NyXmkXk2h6mdG1vWtIW9tLj7Yulavqemm5azvrmGX7CooA+cNKsf2xPgc66r8Hv2hNb+L2j2RMs/ww/aBceJ/wC17ePL/ZdP8dmW31nTrtlzFZwwz6JpyyFDd3Bt0EQ/QT9l39r3wf8AtH2+teHbrRtQ+HHxj8FqiePfhR4jkX+2NIy0UX9raNctHbDX/Dc800SRanBbwSwNcWi31pbJfabNf+FV8r/tFeG9e8ITaD+058LAunfFn4IyjxA8kIaOLxj4EtSz+KvCWviEo97pz6RJfTqrl5Y7b+0LW0MU95FNAAfuxRXD/DPx/ofxU+Hngr4keGpGk0Lxx4Z0bxPpodkaaCDV7GG8+x3Xlkol7YySvZ3sQOYbuCaI4ZCK7ckKCxOAASSeAABkkk8DAoA8N/aC/aH+G/7NfgOfx38RtRmSKWcab4d8O6XEl54l8X67MjNa6H4d0wyRG7vJsbpZpZILKyhzcXtzBEAx/MHWfiH+2r+0e76pq/jhv2Ufhve5fSvA3gKBNR+KV3p8ozBL4l8ZXYtbvQtRMb7gujnTHh5gv9AguoROeY8P62/7WHx/8a/tI+I2Op/D34f69qnw7/Z10S4/e6Xa6bolyIta+IcVsxaCTVNfv1E9neFWmtmLWzMz6HpE1t9UUAfKh/ZXDt9rm/aL/apm1k/Odcf4yX/9oifr5qyf2WQCHwyhgzAAAuxG49Lo/ib9tX9nl01bwT8Upv2mvA9jiTUvhr8XFVfHEtjHjzv+Ec+IMLSale6sYQxgXVpzZIw/daLqdyywyfQ1FAH1N+zd+038Ov2m/B9z4i8GSXula9oN0NJ8c+AvEEQsvFngfXh5qyabrNgTuaCV7e4/s/U4QbW+WCeL/R9Qs9QsLL6Kr8Hfirf337NPxT8H/teeB4Zbaz03VNK8JfH3QdPUpb+Mvhvrt7a6dJqt1bxlEn1zQLlrJtPuGVpJLtNIknkFpps0Vx+7FjfWmp2VnqWn3EV5Yaha297ZXcDiSC6tLuJJ7a4hkXKyRTwyJLG6khkYMODQBar5b/ad/au8B/sy6Dpb6vZ6j4x+IXi6d9P+Hvwv8NAT+J/F+pgrGNiJHO2m6PBPJCl/rE1vOsO8Q2VpqN+0VjL9D+KfEmj+DfDPiHxd4hu0sNB8LaHq3iLWr6TGyz0nRbC41LUblskZEFpbTSkZGduM1+HfwIg1r40eKvE/7XnxMt2m8YfEy7vbb4c6VeHz4fh58LbK6ubLQdG0eNsx2txqNuslxe3sCI9/FK1+Ck2t6qLkA6bVrv8AbP8Aj276r8T/AI2X3wB8MXp8yy+F3wKK6brmn2khykWt/EQzS6tJqnlBUvI7S71LSZXJkt7awDSWlc8P2V2t2+16Z+0b+1TpusLl01mD4yX/ANu87qJJXXTI9+Ty4jMDMCQHQnI+rKKAPA9G+MP7Z37NDrqeo+Ix+1p8J7Mh9Y0XW7CHRfjFoWmrkz3miaxZCceKZbVP3syasdWvb3b5FtZ6bG0l9b/qh8Efjh8Ov2hPh/pfxI+GWtrq+g6gWtrq3mQW2saBq8CRtfaD4g07zJJNN1iwMsfnW7PJDPDJBfWFxeadd2l5P8V18z+H9cb9kr9qPwX8RdDf+zvg7+0V4isfhv8AF3QYyYdH0nx3qbSnwd4+hhVlt7OWS9kuRrNx5YjSyOuTP5l3qkL24B+5FFFeSfHj4taP8Cvg98Qvi3riJPZeCPDl5qsNk8nk/wBqas5jstC0ZZT/AKuTWdbutP0uOTny3u1fa23BAPB/2o/2yfD/AMA73Sfh34P8OXfxX+PPi63M3hb4ZaJcLD9js33qviLxjqYWWPw/oEXlyyq0qC4vkt5mU2enxXmq2XwfqXhr9rT4zOdV+Nn7S/irwFZ3h81Phx+z5KfA+k6NC43fYZvFQ8/WNaKbtkyasusKsisItRuofKZYv2cfAOtWulap8ZviXO2t/Gr40yjxh401y8TN1ptjqgju9G8Jaerljp2l6Rp4so202DZFBPFHYgPaaXpyQfTFAHyrH+y/qGlML3wn+0r+1H4a1qMiSHUoPi3fXSNKMEG9tDY2/wBsiJA8yD7RAkoGxyUJU93oH7Tv7VX7L8sVx8ang/aW+CNuwXVvHXh/R7bQfiz4I09SobU9V0a1ZNL8R6XZxb5LmSSSW9dVku7/AMQadGiQT+3010SRGjkRXR1ZHR1DI6sCrKysCGVlJDAgggkEYNAH6AfD/wCIPg74p+DtB8feAdesfEvhPxLYpqGj6vYOzQ3ELFo5I5IpFjuLS8tJ0ltL+wu4oL2wvYZ7O8gguYZYl7Kvxe/Zk16X9lz9qqH4M28ptvgf+0vFq+t+CNKdyuneB/i3oVst1q2l6YhbyrPTPEumJDDDbIqiW+n0GwtUji02Zp/2hoAM1+ZH7Q/7avjS88eaz+z/APsm6To3ib4iaERbfEX4peIA1x8P/hTLIzQvp+2ISR+IPF0DrIHsFW6s9Ou4ZLSew1i5tNastJ9v/bs+OOt/Av8AZ+1vU/BrP/wsjx7q+k/C74aLD/x8p4w8ZNPbwX9rlXAu9I0q21XVrAyRvC2pWdjDMvlzGvj/AOCvwo0f4N+ANI8H6bi61BU/tHxRrj7nvPEfii9VJNY1m8nkzPMZ7nMdoJ3eS3sIrW2Lt5RZgDyK+/ZX/wCFiy/2t+0T8X/ip8cdduHE91bav4ov9A8GWsxwxj0Pwro08Uej26NuCxWV7Db4+eO1t2ZlMJ/Yi+BunTJf+B4fHPwz1yAf6L4h8DfEDxTZazaycESQ3Oq6jrCIwYBjtiAJ6Y4x9d0UAeB+G/2h/wBpf9ka4t5/iprWpftLfs9QyRxar4rltEj+MXw5sGdUOp6jIspTxlpNorGS9udSuLm+m2tK+paFbxR29z+wngrxp4X+InhTQfHHgrWrLxF4V8TadBquiazp8nmWt7ZXC5VwGCyQzROHgurS4jiurO6imtLuGG5hliT885oYbmGW3uIo57eeOSGeCaNZYZoZVKSxSxOGSSORGZJI3Uq6kqwIJFeZfsTeIbn4CftGeOf2WJZ5v+FZ/EfRb34vfBW1nkkki8O6vbzmPxv4L05nDFbWSJLjWra0D+VZ2mki5fffaxdSzAHPfsAE3/7P/wDwlVwS+seOPiJ8Q/FfiCV+ZZtYu/EVxYTyTHqZWt9Nts5JOMc19ssAwKnowIOCRwRg8jBH1BBHaviz9mGA/Cf4j/tEfsx6uPsmoeBPiVrPjnwRBKdh1P4Z+Ont9R0a6sVPE0enebajUniJjt73VktTh43UfaTlwjmMAvtbYGyFL4O0MRyATjJHavg8nXJleFoyV6uGpywuJjo5fWcLKVDEqS/mdanN66yTUtpI/s3xXlHEeIXEmZ0Gnl2f4ynxLklWOtKrw/xFhqGcZDOjJe7KjHKsZhKUeVtQdKVJ2nTlFfl7+1F8SP2V/wDgmL+x5d/C34ffDHRo5fiCvjf4ffs5/speANOm1nxZ8dvi98ULrVr2TwZ4Y8Ls2p6xrNvrfifxRJqHjXWrmO8sPD2iX00t02w6Tpd16f8A8Evf2aPG37Hn7AH7Lf7OHxI1GPUvH/w0+Glta+M2gu1v7XTPEviLV9W8Yaz4asb+N5Ir/T/Cd94hm8L6ffW7fZryy0iC5tgsEsaj8gvgf+zv/wAFmvh58ePHX7WHxf8A2Yv2J/2jv2nvF76lonh/4oeNv2o/Hmj6R8GPhfPPMdO+EvwE8BWvwa1XS/hn4ThtZXHiDUbbUdW8ZeN9QuL/AFDxX4o1M30luv7+fs5a9+0T4j+GFhqn7Ufw++G3wx+Lkmq6vFqXhT4UeOdW+Ing630iG6K6JeWvibW/D3he/uLy9s8TX9q+kxx2c+Yo5p1G+vemuSjOPtIVJ1JUp1pe0jJ3pRqKlCK5uZ8ixFT2k7e82oxioQ56n5BhJutjY1Z4avhY0KFfDYShLDVKUIUqs6FStOpNwjSU6rw9F0qUG1Tgm+aUqso0/ZtWsLXVtK1PS7+JZ7HUtPvdPvYH+5NaXltJb3ET/wCzJDI6N7E1+d37Ff7a3xS+Fn7OXgf4eaN/wT+/bk/aJ0nwrd+LLDT/AIp/BGw/ZUufh/q9tP4t1vUV07T5viv+1d8KPGTXmhNetpOoLdeDLKyjuLUx6ddX9qiXL/W37RPxPsvhB8GvHnje5nWK9stDu7Hw9CSPNvvFGrRPp/h+0gj+/KzalPDNOIld4rKC5uWXy4HI+kP2LPhVf/Bf9l/4P/D/AFiB7XXdP8M/2x4gtZV2T2eu+LL+88V6tp9wP+e+l3msy6ZIcnJs+DjFcGBXPxBS5P8AmGyjGfWGtl9cxeB+qxlbS8/qeJlFPW1OWiufX8XSjg/A/NI4tpPiDxN4W/sOnPR1Xwvw1xe+IcTQvvHCx4p4fw+IcdHLH0FN3hFHxR8Uf+ChXxmvvhn8RLJf+CX3/BRv4eteeBvFlqvj7xlpn7FUXhDwQbjQb+IeL/FUnhT9tjxT4oj8OeGy/wDbOtv4b8M+IteTTbO5bSNC1bUBb2FxvfseaVZ6N+zH8F7SxRUin8F2WqybcfNea5Pc6zfucAZZ72/uGbvk47V+nXi/w7Y+MPCnibwlqYJ03xR4f1jw7qAABJstb0+4026AB4JMFzJgHgnGeK/I/wDYl1u/sPhjq3wW8Ubbbx/8APF3iH4ceKdPYkS/Z7XWNQudC1SGNvmbTL2zeWz0+55S6XS5Z42aN0Zrzf3M6y+pP4K2XY7D0pPZVoV8HXnTXadWlFzS6xw0/wCU4/DKccZ4RccYLC2eLynjng/PMzox/iTyjFZPxNk+Fx0lu8Nl2aV4YOpP4aWIz3CQeuIifYF9ZWep2V5p2o2ltf6fqFrcWV9Y3sEV1Z3tndxPBdWl3bTpJBcW1zBI8M8E0bxTRO8ciMjFT/Ox/wAFY/id+0JoH7OPxv8A2RrP9hEfBL9gq98NaF8JfFH7bmk+Jvh78Rvh/wDBr4CzadoQ8SePfDf7IfwkMvxetLHwFZLe6LpEFzYeHND8Jy6TB4uubhdDsIYJ/wB8/ipoHjfxX8NPHvhn4aePD8LfiHr/AIR8QaR4H+JH/COaX4vHgXxXf6Zc22g+K28La3jSPEUeh6nJbahJo2oslpqMcDWs0kaSmRfxM+Lvg/8A4La/tH/Ajx5+xf8AET4TfsS+CbL4qeA9b+EHxQ/bN0P4xeOdf0bVPAPizSbjwz418SeC/wBnRvh3pfiLT/Het+GL7UBpumax4wtvDGneILosl1a6bFBJDvS1f/LuSTg3TqzcIT13upRT5VdNOXwzdoT1t4eZuTpOlFYuMqlOqo1cJQhXbbjb6vO8JypxqtxbmvZL93/Hpta/tF8EtG8HeHPgx8I/D3w718eLPh/oPwx8BaN4F8UjUINXHiXwdpfhXSrHwzr41W1AtdT/ALY0WCy1H+0bYCC9+0/aYQI5VFYn7SGl2es/s/8AxpsL5EeB/hh42uAXGRHc2Hh+/wBQsp+f4ra9tre4jz0eNTWx8DvhRoXwG+Cvwg+B3he7vr/w18Gvhf4B+FXh6+1RkfU73RPh74V0rwlpV5qLxKkTX91Y6RBPeNEixm4kkKKq4A8c/bS8ZXGg/BLV/BehRPf+OfjJe2Pwn8E6HbkNeavqXjC4i02/jhiB8zYmkTXsfm7fLW8uLG3d42uomPBnFWnDCZjVm3VpulidZR96tzqcYLlS1nVclFQSvKclFK7SPu/DjA43HcYcF4LCKOGxjzzI5KcZ2pYFYbF4fEYjFzqzdqeFy6lSq4qviKklCjh6E61SUYwlJYHwB/b7+MHhz4H/AAl8OW//AATQ/wCChXxYt/D3w98J6DbfEr4c6d+xtN4G8b22jaLaabb+IvDE3jr9svwN4wl0rUYbZJoJfEPhHw9qchLNcabASAeO/a4/bp+LXjv9nP4p+Db/AP4J1/t5/Aiw8TaHbaLf/FX4w6f+yRb/AA48L2N/rGm294viSX4Y/tc/E3xwseuWzy+HdOGieCNb3avq+nrqQ0/STfapZfsZ8JvBEHwz+F3w6+HdtIs8PgbwT4Y8JLcIpVblvD+jWelyXW0gENdS2r3DZAO6Q5Gc1xf7Tfwxm+Mv7P8A8WvhnZoj6n4r8FaxaaIsrBIj4itYP7S8Oea7YCRDXbLTjK+Rsj3MCMV7GIwuJlw7XwMbvFyyWphVbd4l4GVFarq6vbqflGR8R5DR8dMn4tqxhT4YpeLGX8RVIzjy0qeRQ4wpZlNTi0rQhl6fNFpWimmj54+G+lWehfDzwHomnIkdhpHg3wxplkiAbFtbHRLK2gC44I8uJee/XvXm37UH7RXgb9lH4FfEL48fEIX13ongfSY5NP8ADuiwm78S+OfF2r3lvongj4eeENPUNJqfi/x74t1HR/CfhqwjU/aNX1a180x26zTR5n7JvxGi+JXwI8C38xeLxB4a0yHwN4w0+4DR3+m+KPCMMWj6hDqFu4WS2ubyOC21YQSKrRwahCpAYMq1P2rf2P8A4B/tr/DvRPhZ+0V4U1jxd4M8N+O9A+Jmh2eg+O/Hnw61PTPG/he01ey0DXbXxH8OvEnhXxDHNpkWuahJbwDVPsoungvDAbuzs5oPJwVWjiMLhKtN/uKtLDzXLpKNKUYOSiulSEW0oy0U0lJWuj9J4wy7NMo4h4lyzGx/4V8Bm2a4Ws68pctTGUcVWj7Wc43cqVeolVjUhzKpSmqkHKMk3+Anxt/Zu8d/CK+/4JffGz9oNrHUv2wP2sv+Cx37PHxd/aO1OylW8sPCl2Pgz8dbD4dfAfwpeZlc+APgF4Le18C6BGtzdQ6jrEfifxUs8kviWXH9S1fzm/tT/wDBv5+zp4w1/wDZTuvgJ4Y+IFnpHg39qXwL4x+P6+OP2uv2otYu734D6d4Z8a2niqz8CyeJPid4lm0fxxLruoeGH0zV/Dk/hnxFb2UepQ2fiWyt7i7trz+gXwD4J8P/AA08DeDPhz4Shv7bwr4B8K+HvBfhq31XWdY8R6nBoHhfSbTRNHh1HxB4hvtT17Xb6LT7G3S71jW9S1DV9SnWS91K9uryaaeT0684Tow5Z6xxFZxpctlCm6GEpwivfk1CEaKjBtty9/md4c1T4rLKGJw+JxUatCMITp4d+1VeVZ1aq9pKrNt4ejzTqTqSqVWlHlnJJRs/d+Zv2+dPgvP2V/iRdSMYrvRZfCOtaXdIxSaz1C08Z6BFHPA4wyStBc3FsrqQyi4baQ2DX+Z74w/4Lw/8Fj9D8WeJ9Gsf+Cgv7QLWek+Ida021f8AtPQm329jqVzawNuPh7Lbo4lO7PI546V/pX/tkPN8Q4PhT+zFoEjTeJvjz8RfD1hqFtB88umeAvDOo2+v+JvENyihmittNNlZ3ZLqPOtrLUmi8w2ksZ/YO28L+HLWCK3h0LR0hgijhiQabZ4SKJQkaDMJOFUADJzgY7Vx5L7+b5vVhf2dPCZZhJvo8TCeOxMo/wCKnQxVBvyrR7I+g8V5xwnhf4Y5biv9/wAbxL4icTYOlL+JSyDGYbgvIMPiIprm9hj854bzulT+x7TLK8ldzZ/l1f8ABI7/AIKa/wDBQv8Abf8A2tLL4H/tUftc/Fr4ufCW78JjXb/wN4w1DTG0HU9UtPiB8PtIsLi6is9Js5Zn0+LXLy9t0abYk0KzFGaJcf6QQAUAAYA4AHQDsB6AdhzgVzn7c/wofxr+zd43bwhpNnF4s8GNpfxD8PmxsIEunufBt/Fql/FAsESyy3EuhrqqW0Ee5p7owRKrMwFZHwy8eaV8TvAHhTx3o0kb2XiXRrXUDFG2/wCxXjJ5WpabKR/y30zUYrrT7gdprZwCwwx/qDJpRxXhlw7LDpOGVcUcUYPMoRt+6xeZ4PIcZgcRVilp9fweFrYehJ/GsoxEVpSPxGi+fKsM47UcXio1Vb4Z1YYaVNv/ABwpzUb/APPqS6H4M/tdeOfh/wCD/iX8cJfjd/wXzH7Nvxtsda8TX/wL+B/wy8d/s5/DbwH8GtAj09Lj4e+HPi98I/FuhfEHxt8VNckn8i88Zav408UaBD4rhu54vC2ieEdP+yxW36X/APBML9pnxp+2L+wJ+y7+0p8RrTS7Tx98Ufhrb6j4zGi232PSbzxNoesat4U1rV9PsFLJp9rruoaDPrUWmxM0OnLf/YoWaKBGP52/s1/sh/tzfsiat8c/gL4H/Zv/AGTPi34G+Nn7QXxj+Ltn+2/43+K97o/j7SvD3xg8U3/iMH4ufBdfhJrHin4ofEHwJb6jc6bpNrpHxR8P+G/EUdrpWnyeJPC9rJfanb+z/sR/sHftD/D3/gnr4S/YA+PXjC0+Fmh/CbxPc+Ck+I/7OnxE1DUPEPx8+BL+JtX8V6vY32p6v4L8K+Ivghd+Pf7cn8KeIYPCd/qnivSPD9vdyeHPGumajqqXmmfJYOWKhU5/Y1EquFi5UpusowxKnDmhOrXlU5pQVR89amoxrqDlTVVw5Y8mrq3SfLzYlS5VJ8yvTdBp8yptSjCoqaVo0nNQlOPMr/s7X5gf8FbtZ8ReDf2S9c+JPgfxHf8Agv4hfD6+1jxD4I8Z6PKtvrXhnX7TwD40u9O1fS7h45ViutN1Ky0/VYS8UkfnadEZYpIwyHU/4JE6bY6J+wV8M9C0u3FppOgfFD9q/QNHsY2keLT9G0T9rv466VpGm25leR1tNO020tbK1jLEQ20EUS/Kgr3b4o2w+L37Sn7OnwN05Vv7Xwv4qi+OfxDXaJrfS9D8GI40CDUFAYBNcv5rrSngk2sp1HTndfJvFkX9H4EqxhnmHzOsuXBZXleb5zmbl8EMsweT4ytjIVG/ctiab+owi3+9r4mlQipTqwjL0MudsSqk9IUIYipWd9FTpUqiqK7SvzpckU0uaU1G2p/l5H/gvp/wWZBx/wAPA/2gR6f8THQun/hPV+tf/BG39vv9tr9vv9r74Y+C/wBsP9pj4l/HHwh4C+J/w+8ZeFPDnjq+sJ9L03xRZW3jHUYNZtrey02xD30Z0aCySSUy7IbuZIwvnOT/AKeA8P6CBj+xNI/8Ftl/8Zr8kf8Agr14EvPDvwi+Dn7Tngzw9Fdan+yh8dfBnxN8SWWlWUSXd/8ADbULhdA8Z2sa28auQZp9Bmu5W/dWmlwajeytHHA0i/L/AEecRQo+L3CtCrKnSq5tQ4m4cyypVlGEKWe8T8I57w7w9NTlaMJwzzM8vdOo+Xkmoz5o25l+OeKFOpPgbOpwjKcMHPKczxUYRlKUsuynO8tzPM1yxTck8uwmK5opO8bqzvY99r8+P2/Pjl8RPDHh3wF+zF+zlqUdn+1h+1vq2q/D74W6uIRdx/CDwNptpDc/GP8AaQ1633IqaL8HfCV6LrQ45mxrnxI1rwL4cgt7w6nPCv3b4c8RaL4u8P6H4q8Oahb6t4f8SaTp2u6Jqlo/mWuo6TqtpFfafewP/FFc2s8UqZAOHAYAggfFf7Tv/BNn9kb9sD4keHfi78c/BXjbV/iJ4V8EN8OdE8SeDPjX8afhTdW3gx9dvPEsmiTQ/C7x94PtL6CXW72W+mmvre4uZnjtElmaKxs0h93M8PjFSq4SFL2ddVfYYmjXnUwtSnCMnHE0W1SqVKNa0ZUX7inScpSVpwSPMwVXDudOvKfNS9n7WhOnCNeEpOKdGdueEalJXVS3M41ElFpwk2vz/wD2V/gN8PP2Yf8AgsNcfAX4VabLpngX4af8EevhFoGkC7lFzqmq3P8Aw1t8Tr3W/E3iC9EcR1PxR4r1271LxL4n1d41l1bXtV1HUJFV7giv3ur8D/hh/wAER/g38LP+Cjtj+0T4b0DxdB8A/BvwF+HLeALfUP2mf2hPEXjm1/aV8HfGbWPGM2pa7/b/AI81DUPEXw7HhJPD6J4R8Ra/rHgi81SO++0eDzNd3t3dfvhXLlEK9LDVKdfDww/LjMc6dOE3KKp1MbiKkeVOlTUadpr2VladLknaHNyR1xrpyrKVKrKqnRwvNOUeV88cNRhK755uU7x/eSbv7Tmi3Jrmf5q/tceOb/4Lftk/8E+/jR4b8B+O/iX4k0nxL8afC0/w/wDhdY6DqXxA8c6Hr3gvTNPn0Tw9p/ifxF4S0C+vbWPVNQu7eDV/Eek2cbSyz/akljjz97/8PHfiD/0i2/4Kd/8Ahtf2Yf8A6LSvlDwHaN+0T/wVS+HVro0f9oeCv2Hfhj4t8WeMtUQGTT4Pil8YNOHhvRPC7yoGi/tG30T7F4htxvBS40HWLaTZPYvFJ+9I6D6Ct/HyUcPS8JMlr/8AI3yjwxpVMzjL+LhqPEPGfGPFOR4Ssn7yc8gzvLc1pKWqw+a0VH3FEjwzTqz42x9P/ccdxfOOEavyVqmWZBkWT5jXh9lpZlgMVhJNXvVwdS7P5xPHHx2139pj/gpj+zbceLf2fvj5+zvb/C74CfFPXvDfgz9ojQvAeg+KNU1nxJd3eg6n4p0Oz+HvxH+JujS6JcaYttpcdzdaxYamdQ0e/STTUtobO5uf00r5W/4Kg2cnwb+P/wCxf+2RPEY/BPhDxT4n+BPxf1LEhh0fwt8VLFovDGv6i8asbfR/D+rDXb28uJPkN3NplomZruOOT6nR1kVXRldHUOjoQyurAFWVgSGVgQQQSCCCDivucxnDG+HfgzmmDV8thwNj+H3y6wwudZJxnxPiM4wM0naOJnDN8vzucHr9XzzC1dqqPnMKnh+KePcHX0xcuIsNmi5virZfmGQZPTwOIj1lSi8FiMApbKrgKsPs2PyA/bW8N/tSW/7fX7H3xi/Z8/Z0ufjmnwv/AGfP2rPDVhfa1410n4c/DHwt8QfizrfwQsdOn+InjS9ttZ1fSNJXwp4O8R3kMHhjwl4p17WL+Ky0e00+2gvb3V9K7z9lP9uz40+M/wBpnxb+xP8Atk/s8aL+zz+0fpHwsj+OPw/1DwB8Rl+KXwi+Mvwoj8RQ+E9a1zwn4huNC8OavoeveG/EV1BYal4U1ywk1KW1E2rqba0SOOX1f9rG2/4KA+G/HHw9+KX7G9x8G/ih4O0LQPEHh/4p/st/GC/l+HQ8dXGpXthe6H488AfGnSfD3iS/8N+MPD4tJdIfw/4k06bwZqGiahqN1JGdcTT5IvBP2ZP2aP2rviB+2Zqf7f37a2lfCj4YeLdA+A9z+zx8Cv2efhB4s1b4j2XgTwp4g8X2njTxt4z+InxJ1TQfC9v4j8da3qWnWmk6dZeGtHi8Oaf4cwZN2q+Y9fm0FiaePUaH13lnjKk8VCtSh9T9hOjL97SrqHNKftI0o04qu6i2qUlBNx+ubpTwrlV+rtwoU4UHTqVPrHtI1Yp050nK0Y8jqOo3TUNOenUcuVS/WmvzP8YfFvXf2dP+Co3grx74M+Cvxh+Pd/4+/ZH1rwt4l+GfwI0/wDqPj3U7bTviBc6nZ+I0s/iT8Qfhj4Xez0qTSdPhvbm58VRX0NpbrFY2d4ZHir9MK+Pv2HrU/Hz/AIKH/tLftHafGt58PfgL8OtI/ZY8Fa0oZ7HWvGNzrkfjHx9PplwqmCWXw3dw3ulXMiSskth4h0y6hMkV2pj/AE/hyUcHwx4rZxi1bKsH4Z57luKlPSlWx/EmJy7Isgwib0niJZzjcJj6VKN6jpZbicQl7PDVZw+OzVSxGccF4GhrjK/FuXYukl8cMLlVPEZjmVZ9Y0lgaFXDznpHnxVKk23VjGX0Wf8Agox8VmBEf/BJ/wD4Keu+DsQ+E/2L4d7dl825/bZht0z03TSxRDq7quSPgr4B/ETW/jx/wUT/AGx/ix4z+FHxO+CHiPw98M/gV4E0X4V/GeLwJF8SvBnh7VdD/trULfW4vhp48+JvgiKLXNV0a38T6eug+ONaRtL1rTn1H7BqzX2mWX9GZ/zmvwm/aMtP+Gev+CpXhXx9q6/Y/AH7aHwetPh9HrEreXZw/Gf4YXNnDpNhdzYKJLqnhWPQ9I0eKRlm1DU9YaKEMLWTP559H6Ua+YeJWTUf+RrnnhVnlDJoR/i1q+S8Q8K8XZtQoL4pVKnDHDefXhBOpUpxqUkmqkov6nxOTp4XhPHz0wWXcZ5dVx8ndQp08dlucZLg6tR7KEM1zTL/AHpe7CTjNtKN19o1/Nz8ZPFv7S/7VH/BXP4xeHfgL8JPhd8VZv8Agm58P/hRo/wutv2iPG/iTwV+zv4A+NXx/wDCUvxC8VfGzxFD4L8LeM/GfjL4o23hBNH+G3wy0LSfDxsPDlvbeNPF134h8L6lDov/AAkf9I1fkL8VvgB+2V+zd+138b/2uf2JPAnwc+Pfh79q3wz8LLH4/wDwF+KvxG1T4O+I9P8AiL8G9AvfBfgr4kfDT4iQeFvGHh3+y9R8E3UGj+M/CviDR7a4kvtIsdW0vULmS9uYLDPNaU6n1J/7R7ClinUr/VYe0qq1CsqE1TUKjnGGIdKd405ypzVOrFR5PaQvBTjD6yrUnVnQUKSry5KbvWpOrFz5oRXNQVSNpTjGcXKm21Pll6z+w5+2r8T/AI6/EX9oL9mT9pz4OaJ8Dv2rf2YrjwPe+ONB8F+LZ/HHwv8AiB4C+Jem32peB/iZ8MvEd9p2las+i6j/AGZqFjquh6taSal4fu0sYNRuxqN3e6VpH6Q1+Zf7D/7Lfx78I/Gr9pL9s79rm++HFv8AtEftM2nw28JW3w2+EN9rWufD34K/CH4Uabqdv4T8FWfizX9P0fVfGXivV9R1vUNc8c6/JpVppT6tHbweHYodLXY36U39/ZaXY3up6ldW9hp2nWlzf399dypb2tnZWcL3F1d3M8rLFBb28Eck000jKkcaM7sFUmuvL1ip4ajHEKpPETlUjFOC9tODr1FheeFNW+sTw/sXWhCOldzUYpWisMW6Ea9R0nGNGKg21JuEWqUHW5ZTd3SjV9p7OUmn7NRbb3PzT/Z8+Pvjv9m79uv9v/wz8Nv2Uf2hP2o9J8YXvwF8X6lov7Plx8Cbe58Da3c+ALu91HVfEQ+OPxu+CmneX4su9duPIbw/ea9fSXGjzHULeyhW2luf0E/4eCfH/wD6REf8FIf/AAY/8E/P/o8a8l/4JG6Rf+P5P2sf2xb61ubXTP2mfjLFp/w7+1wPDNf/AAt+DltqfhPwtrIDgMgvbnUdW02eIgbbvQpmyVKE/srXj/SIqU34qZrgk4yxeR8O+H/DOcyi+Z/6w8L+H/DHD/ENKo03++wmc5bjcFXbbk62GnKT5nI7vCyElwXgsRZqhmOacS5vgE72/szN+JM2zLLZw/6d1sDiqFenbTkqxtpZn4H/ALMPiXU/iJ47/ao+KXiPwj4l8A+KvF/xz1Oy1fwL42bw/J408E23h/T4Y9M8G+K5PCev+K/C7a94Xj1G40TVf+EZ8UeI/Dv9oWV1/Ymuarpv2a/uPsCvnzUtNb4NftxfHn4e6mptdH+O1to3xt+HtzL8kOo6gbWez8eafC2Nkuo/2xHqV8bZW82LTNMF1IoW4jLfQdfiJ+hhRRRQAV8dfsk/tK/Fz4Er+0H8OPht+xB+0x+1H4X079o/4kX9p4m+BviH9mHSPD3hFrxtNtj4R1KD47/tFfBnW21CKPTo9VjOh6JqukLbaknmaoL1p7WH6i8X+KdH8EeF9f8AF+v3K2mjeG9JvdY1CZiAfs9lA8xiiBI8y5uGVbe1gXMk9zLFBGrSSKp9P/4JpeBNc8L/ALNkXjXxRbPZeJPjr468W/GzUrOVWElvb+MZ7WDQ+WAJhvtB0nTtZtsgEQ6quQrbhQBxX/Dev7TP/SIL/goKPf8A4Tf/AIJ2/wBP27M18k/sQzyar8FbnxbeBv7Z8dfEX4g+LfEDyczSazf+IJ7S4adssWl8mwtwxLMTgfMetfvfX4UfA/TW+EfxY/aJ/Zt1Vfsl34M+JWs+PPBEUnyf2l8NPHkkGqaLcWQ+7OumedbRanJEWjt7/UxaEiSGRVAPqeiiigAqpf2VtqVjeadexLPZ39pcWV3C4yk1tdQvBPE4OQVkikZGB7E1bryT46/Eez+FPwn8a+NbmdYrrT9GurbQoiR5l74k1KNrHQbOFOXkaTUpoJJhGrtFaRXNyUMcEhAB5J+w/wDtW/tK+Av2bvBHgP4ff8E8P2mP2k/DXhO+8X6bpvxW+HfxT/Yu8H+ENXgk8X63fnTrCw+OH7UXwu8dG50Ka9k0m7a68IWdgXtVOmXV9abJ296+KP7a/wC2H/wrP4im+/4JTftbfDuyHgXxcbz4ga98dP8Agnpqmh+BbX/hH9Q+0eMdZ0zwV+2V4m8ZajpXhiHfreo2HhLw54g8TXlpYzW+g6JquqSWtjP9i/sT/CfUPgn+y18HPh7rNu9rr1h4X/tvxDazKVuLLX/F+oXvi3VtOuQeftGlXuty6VKeRmy+UlQCfonxV4esfF3hjxH4U1RS2m+J9B1jw9qKqAS1jrWn3Gm3YAPBJt7mQAHgnrxQB+M/7J2mWmk/s5fCK1skVIpvCVrqbhQADd6zcXOr3znH8b3l9Oz99xIr6Gr5R/ZGvtS0TwHrvwV8VAW3j34CeL/EPw78TWLZWRre21e/udD1WBGALaXfWby22m3Iyl1Fprzxs0bo7fV1ABRRRQB5N8etMtNY+CPxc0+9VWt5fhx4ykywGIprXw/f3drcDPG62uoIbhCeA8SntVD9nb9sP9sDTfgP8H9K8Of8Ew/2kfi7oGjfDrwlomjfE7w18eP2HfD+heOdN0bRrTS7PxHpmi/EP9pzwn430621GC0SZbfxN4b0fVQxZriyj3KTxf7W3iu70b4P6r4Q0GGTUfG3xcvLL4U+C9DtiGvdY1XxnOmk3VvbxjLnGl3F4ok2+WLqazgd42uY2r9ifhH4Eh+F/wALPhx8N7eRJ4vAfgfwt4RFwgKrdP4f0Wy0uW8AIBBu5bZ7lsgHdKcgHigD8fv2vf2t/wBrPxD+zZ8WvD/jP/gm7+0N8BfC2v8Ah2HQ9d+LHjP43/sX+LPDPhTT9Y1jTNOmOq+H/hP+0h46+IGox62LkeHIF0Dwrqpt7zV7e71RbTRoNRv7X2T4e6Za6L4B8EaPYqqWWleEfDenWioAEFtZaNZ20O3HGPLjXB79a+7/ANpf4YTfGf4A/Fz4YWixtqXi/wADa5p+iecwSEeIobY3/hxpmbhYU120095W6rGrMOQK/MD9mDx6vj/4K+Dbq4EkHiDwzp8fgfxdp1yjRX+meJvCUUWkahBqFu4WS2urqOC31QwOoaKK/jRgrhlUA+gKKKKACvlL9tuxhu/2aPiJcOxiudIPhjWNOuVJWW1v7PxboYimgcYaOZ4pZrZXUhgJ22kE19W18lftS21z8Sf+FW/s0aAzzeJfjx8Q/DulXkNv882l+B/DupW2v+KfEdwqB2jtdJSytrxyyjzbW01B4vMNpJGQD6d0X9tH9uO70fSbuH/gkx+0PrkV1ptjcRa1Z/tLfsJ2Npq8c1rFImqWtlqn7R1nqdnb36sLuG11Gztb6COVYru2gnWSJflP9tb9ob9p34qfCzwt8O/jB+wl8Uf2ZfAHjL4ufDnSNT8d+N/jZ+zZ8QtP1J11aS/h8JyeHvg18UfHWvW9zqL2L6rBqd1ajRIIdFkhu7yDULzT7aX97ra3gs7eC0tolhtrWGK3t4UGEihhRY4o0HZURVVR6AV8U/8ABQ/4Yax8Uf2UviLaeGYJLjxX4J/sn4meGoYY2luJL7wNqEWsX8VrCgaSa8n8PprVvYwRAyT3k0EKKxfaQDyoAAAAAAAAADAAHAAA4AA6ClrhPhj490r4n+APCnjzRpI3svEujWmoNFG+/wCxXxTytT0yU/8APfS9SjutPuBzia2fBK4J7ugAooooA+Pf2xNS1Twvo3wR8feGtJm1zxh4F/aG+G2ueF9Gtbyz0271/UoZdSlh8NwajqEsFhZf25c29paPcX00VjFhJLyRbZJSPrv/AIa6/b/7f8ElPin/AOJefsef1+JWfzr5w8Y6Y/xl/ap/Zk+BulJ9st/CfjO2+P3xFaMGSDR/D3gHfJoEWo7FbZH4g1SWfRgjFHWXUdOZgI7uOVf3GFAH4E/tGfGX9oj4ufF/9krQfj3+yJ4s/Zd0HTfinq2u6HL4n+MHwa+KsHjXXdO0e2ktY7WP4UeJfEL6JN4ecxyF9cW1TUP7ZRdNaZrO+8r7Grb/AOCl/gbXNV+B/h34t+FLJ9Q8Sfs6fETw78XBZRKWlv8AwxpbS2Xi2z4I2W0VhdQa1qEnJXT9FusAkgHhfCvifRvGnhvQ/Fnh27S/0TxDplpq2m3SFT5lreQrKiyKrN5VxCWMN1Ax8y3uY5YJQskbqADfooooAK+dfGMj6f8AthfsOatYMY9Vfx58QdFYx8SS6Nq/hW0s9WVsfM0UdpPKGH3VW4kzjfX0VXinwJ0t/jh+3haeINPX7V4I/ZP8Ga3FfamqiWzm+KXxFtZ9FbRopA3lyS6foYuppyoaSw1TQpoZlR5IGoA+pv2w/wBmfxb4/v8Awr8dvgXd2WkftB/C63nh0qG9KQ6T8R/CLtLNf/D/AF+R5IYwJ2nupNEurmaK2gubu7tp7ix+2QaxpHh/wj/am8C/ES7k8HeK0n+FXxg0iYad4l+F3jrOh65aatGoE8ejPqK2qa7ayOHktfswXUPs3lzXWn26SRvJ+steD/GX9mT4GftAWkdt8Wfh1oPiq5t4TBZa28VxpniXT4csyw2PiXR7iw123tlkbzTZJf8A2KSQBpreTkH53HZPX+s1cdldSjTrV+WWLwmJU1hcXOMYwjWjUpqU8LieSMYTrRpVoVYxj7SjKaVRfuvB3ilkryLL+D/EXL8zx+VZNGrR4a4pyF4apxNw3g8RXnia2UVcDmFbDYHiTh9YqrXxeFyzE4/KsZluJxOJlgc2p4WtUwM/L68u+J3xo+GXwd0eXWfiJ4v0jw9EsTyW1hNdJNreqMoOIdI0S2MuqajKzDb/AKNbOkX353ijVnWgf+CXvwatz5OifF79pvwzpAG2Pw/oXxZig0aKLGBBHDeeGr26ESqAoBvGbA5evWvhT+wF+y/8JNZi8UaX4B/4S3xhDKtxH4u+I2p3vjbWY7qPBivLeLV3fRbK+iYBor+w0i1vo2wVuBtTbxLC5/U9yOCwGFbspV6uOqYmEFdXlChSwtKdZpXtGdXDX6zWx9bPiHwUy+P1urxXxrxJCK5qeS5XwfgshxWKdrqhjM4zPiHMcLlMZfDPE4XLeIJU/sYWqtV8o/Bf4TfEH9r34l+Evjn8YfC+o+Bv2f8A4e6hH4g+Dnwt8QQmHXfHviCPa2neP/Gen7sQ6XbLtutHsZt8V0pjhtRc6Rcalfa9+vSjaMDoOnt/OlA2gAAADgADoOwpa93LMtp5bSqJVJ4jEYiftcXi6qSqYiryqKfLH3aVKnBKnRoQShSgrK83Oc/xrj/j7H8eZjgqs8FhckyLJMG8s4Z4ay+dapgMky11ZV6sVWrt18fmWPxM54zN83xX+1ZjjJuclRw1LC4TDIeRivzU/au/Z5+Ivh34iQftXfs26bFrHxAs9Lh0j4tfC7f9nh+LnhGySJYbjTiudvjPRra3hisgEe4v7a0sUs1nurI6Pr/6WUHnitMwwFHMsO6FZzpuM41aFek1Gthq9O/s69GTUkpxu01JShUpynSqRlTnOL4uB+Nc24Cz2OdZXTwuLp1sLiMszfJ8xpzrZTn2S43kWOyfNKFOpSqVMLifZ06kKtGrRxeCxlDC5hgMRhsdhMNiKX5c/B/9pX4WfGaD7JoOtDRPGNo8ltrfw78UmPRPGuiahbEpe2c+jXkkc16tpKDHLd6d9qtkbEczw3Akgj9+rrPjT+x1+zr8fpzqXxI+G+lXviPagj8X6NLd+G/FqGJQsDTa7oc9ld6ktsABbW+rtqNrAB+7gFfOZ/4Jf/CIN5MXxp/ajg0r7o0GL4t240gQ/wDPv5TeF2uvKxlcfa92wkbs4YfPPB59Qfs3h8DmEV8OJp4qWClJdHWw1ShWjTl1bpYirF9IR+E/cKfFHgvnMVjI55xjwTVmufEZDj+HcNxZhsLN6ypZZxDgM4yrEZhRi240lmOSZZWhFRjVxGInzVnn/F/9oj4U/BSxeTxj4lt316UKuleC9FaPVvGWt3UpC21pp2g20huVNzIyRR3d99k09XdBLdpuUGn+zF8BPiR8UfihYftXftHaE/he70eyubP4EfBy93SS+AdL1BSLjxb4ngkWMDxhqVswEUFxDHd2LP8Aabq2srmx0W00n6Z+DP7FP7N3wIvk1zwH8OdPfxWjGT/hM/E9xeeLPFS3D58y5tNU12e8/sieYEiZtDh0xZgWEitufd9VAYGK6cLk+Lr16WJzadBQw9SNbD5dhZTq0FWg1KnXxWIqwpSxM6Ukp0qcaFGjSqWm1WnGlOn4XEfirw5k+T5nw/4ZYXOZYnO8HXyvO+OuI6OEy/OKuUYqDpY7J+Hcjy/GZlhuH8HmdJzw2aY+tm2aZpmGAqTwFOWV4SvjsPjADAxS0UV9Mfz4fk7+0H8GfiL+zj8VPEv7S/wH8M3vjf4dePJlv/j78HtFQnWIdSiMjzfEnwRaJu+037CSe616xijMz3Et5cyJNZX8t54c7v4U/Hj4V/GnSotS+H3i3TdVnMSyXugzTJY+JtIk6SQaroNyyahatE4aP7QIpLG4ZGezu7iHEp/SevkH4v8A7Cn7M3xq1aXxN4n+HsGi+MZpmuZPGfga/vfBviKW7Zt7X17Nok1vYatfk/8AL9rOn6jdDA2ygACvl8Rk2Lw1arXymVCVGvUnWrZdipzo0o1qknKrUweJp06zw/tZNzqUKlCrRdWTnTlQ5pqX9EZF4q8McQZZl2UeJuGzrD5rlOCw2V5bx5w1hsHmeY4nK8FShhsuy/inh/MMdlVHOZZdhoU8Hg87web5fmdLL6NHC4zD5w6GGlRq183/ABg/af8Ahv8ACl08P291L49+JupSrYeHPhb4Izrni7V9XuCY7OzuLTTkum0eKWbbvmvkW4eISGwsr+dRbt84WX7IPg29/b58Rfsnar8T/j7q/wALdJ/ZB8GftARJqHxSvH1W48UeIvjP48+HF7oVzLBpkFi3hePRfC1jdQWsdjFqg1Ga6kk1WS2aK1i/V/4L/spfAH9n1DJ8Kvhxonh/VZITBc+JbgXWueK7mJ/9dFJ4k1u41DV4redvnlsrW7t7BmxttVVUVcFgs+xD5PY4LLoPSeIniZY6rFdXRw0KFGlKVvhlVxEYxdm6U1eJ7FXivwYyOP1z+1uLePcRTtPD5FhcgocIZbiJxfNGGbZ/jM4zTMMNh+ZJV6GV5LXr1qbnChmeCqcmIXz3+yF+zZ450fxTr/7S/wC0OLSX44+OdNTSdD8L2zrdaV8I/ArMJ4PC2mOJJof7ZuxsbWbqF5jEDNbpdTXGoa1Pe/oZRRX0eAwNHLsNHDUOaSUp1KlWo+atXrVJc1WvWnZc9WpJ3k7JLSMIxhGMY/hXGnGOccdZ9iM/zl4alUnRw+CwGXYCi8NlWS5TgaSoZdk2U4Tnn9Vy7AYeMaVGnKdStVk6mKxdbEYzEYjEVWsqurKwDKylWUjIZSMEEHIIIOCCCD0r8lvHvgXxj+xX4y8ReMfCHh3U/GP7LPjLVJ9e8ReH9Aga81z4L69dsDqGp6dp6sDceDbphvKp5cFhDHHazvZzWdtPr3610jKHVkYBlYFWUgEFWGCCDkEEHBBGCOtfd8IcX4nhXE4uE8JSzbJM2o08NneSYmpUo0cfRo1Pa4evQxNNSqYDM8BUcquXZjShUlh5zq0qtHE4PEYvCYjwcFjZYSU04RrUK0VCvQk7KcU7xlGWrp1abu6dVJuLbTUoSlGXwv4E+JfgL4m6THrfgPxVo/iawdEeQ6ddK13ZmQArDqWnyCPUNMugCN1rqFrbXCnhox1qr8UfAl98R/CF54W074jfEH4VXNzc2V0vjL4YX3hzTfF1ktlcLcPbWl34r8MeL9Gjtb5VNvfCfQ55XtmcQTW8mJR1fxB/YM/Zs8f6vJ4kTwfdeA/E8rvJJ4h+Ger3ngu8aWQkyzmw08toJuZWJkmujo5uZ5CzzTSFmzwC/wDBN/4P3R8rxH8TP2hPGWlniTQ/E3xQ+06TNFwPIki07QtMuTEVyrBbpXIY4cHBH6N/a3hjjKbqriPifK6c0nPLsbwzhsfjKG16VDHYDPMNhMcote7Xq0sp9p9rD0lv6Xtcrl70cViaKf8Ay6nhY1Zxv9lVIVowqf4nGlf+VH5+fB3wl8P/ANiW2uPgp+zx8WPjz+014x1658UHwl8FvE/iTwP4y8PeE/E3jPxlrXj7xX4o1DVPCHw/8KXWhtf+KfEWtaxrceqa5eJBb39wkNhpGnKt9Y/qb+yl+zrqnwg03xH46+JGpweJ/jj8UbqHVvH/AIgixJa6bDEv/Et8H6C+AItG0WMiJjAkUV3NHEqKbCw0yKD2T4V/Av4SfBPTX0v4X+BNC8JQzokd5d2NvJcazqSxkFBquvahLea1qYRuY1vr+dIiWMaoSa9Zr5jiTjjLZZRW4Y4OwONy/J8W6LzjNM0nSlnefxw1WNfDYSrSws6mFyrJ6GIhDExyrD18bOviqNDEYzMMSsPhKWG5cVj6PsZ4XA06lKjUadetWkpYjE8rUlGSi3GlRU0p+yjKblNKc6krRUSsPxN4b0Lxl4c17wl4o0qy1zw14n0jUdA8QaLqUC3On6tour2kthqem3tu3yzWt7ZzzW08Z4eORh3rcor80pValGpTrUak6ValOFWlVpSlTqU6lOSlCpTnFqUJwklKE4tSjJJppo8icI1ISp1IxnCcZQnCcVKE4STjKMoyTUoyTalFppptNWP5x9SsPiL/AMEq/E974B+Ium+KPiD+wlrmuXF18JvjFpVleeIdb+BB1q/e4b4f/E2ys0mvm0G2u7l/7J1uCFxe7/P0uO6vLy98OaB9/eBviJ4E+Jug23ij4eeMPDnjXw/dqph1bw1q9lq9nuK7jBNJZzSm1u4+Vns7kQ3du4aOeGORWUfpZqemadrWn3ukaxp9lqulalazWOo6ZqNrDe6ff2VzG0VzaXtncpJb3VrcRM0U9vPG8UsbMkiMrEH8x/iH/wAEe/2KfGfiG68XeEfC/jX4CeKL53ku9Y+APjrVvh7G5d/M222gFdY8KaXErcrBo+g6fb5ALRNgV/T2F8WOBeOIQxPiPDPOGOMXCMcy4v4YyrBZ7lHFNeMeV5nn3DlfM8jxGVZ5ieX2maZtk2OxuFzTFTli55FhsVVxWJxH4/W4K4k4dlKlwpLLs4yFSk8Jkeb4yvluOyem3dYTLc1p4TMKWMy+jdxweDx+GoVsHRUaEcxq0IUqVLuZ7iC1glubmaK3t4I3mnuJ5EihhijUtJLLLIVSONFBZ3dgqqCSQBX5/wDxT/bGv/HHih/2ev2JNJh+PX7Qmuo9lJrOgGPUfhd8JLOWT7LdeL/HXi9PM0Fk0hmZ4tPhubi2+3xpZ6jKL1rXRtU+k7X/AIIsfstX1xCfiT8Sv2p/jXpMMqSnw38U/jjf6joc3lvvSOWPwvonhTUQgwoBh1GKQBVKyBsk/pB8HvgT8Hv2f/C6eDPgx8OfCfw58Nq6Szaf4X0mCwfULhFMa3us34Empa7qPlny21LWby+v3QBHuGVQBtW4+8IOE19fyp8QeJmeUffwGXZtkdLhTgujiY60a+c1FnOZZ/n2HpSXNVybDYXIKWKSjCrm7oyq0Z50+GeOs7f1bGrLOEcun7uKxOCzCed59VpP46WBj9QwmW5bUnG8Y46rVzKdK7lDBc6jOPh/7EH7Ieh/sffCJvCbazJ42+J3jbWLrx18afiZfLK2p+PfiFrH73Ur1prktdjRtNZ5LLQ7Wdg6wm51K5jGq6tqk0/2VRRX85cR8RZxxZnuacScQY2pmOc5zjKmNx+LqKEPaVqlkoUqVKMKOGw1CnGFDCYTD06WGwmGpUsNhqVKhSp04/q2VZXgMky7B5TlmHjhcBgKEMPhqEXKXJTh1lOblOrVqScqlatUlKrWqznVqzlUnKT8v+NHwf8AAvx9+Fvjb4PfErSV1nwV490S50PWrPIjuIll2TWep6dOyv8AY9Y0bUIbTVtGv1R3sdUsrS6RWaEA/gp4e+JXxK/4J46/pv7OX7Y51TVPhBBdLonwB/avs9NvLzwnrnhmIMui+D/iW1st1N4X8UaLYxx2W66Moitrdmme60K0i8UXn9Hdc54t8H+FfHvh/U/Cfjbw3oPi7wvrVu1prHhzxNpFhruh6pasVZrfUNK1OC5sruLcquEnhkUOquBuVSP0Dw58To8JYPMOGOI8pnxNwLnWKpY/G5TSxiy/NcnzelSWHp8RcL5lOhi6OX5tHCpYXG0MTg8VlmdYKNPC5jhnVw2XY3L/AJjivhCWd18NnGU42OUcR4CjPDYfHVKDxODx2BnP2s8rzfCRqUZ4nBOr+9oVKVeji8DXc62FqqNXE0MR+f3hzxN4c8YaPZ+IfCev6L4n0HUYxNYa14f1Oy1jSr2JgCJLXUNPnuLS4Qgg7opWHPPNXNV1bS9D0+71bW9S0/R9KsIWuL7U9UvLfT9Ps7dBl57q8u5Ire3hQctJLIiL3IrzfxT/AMEZv2N9R1m8174ct8ZP2fNQ1GQzX/8Awoz4ra54Xs7iYljuTTteh8VWNjGNxVLTTbeysYUysNrGCao6L/wRd/ZF/tKz1H4m+Iv2g/j+thMtxbad8aPjLrOt6Yk6cpI9t4WsvBzzKDndDNNJBMrNFPFJC7xt+o/294HSh9cXHnHNPD253lU/DnAVM8Wif1dVIccRySo73pxxTzGipaVZYSnf2C+N/s3xGjL2D4a4dnV+H67HirERy5vb2rpy4e/tCMftOisNOS1gq70qP5C8b/tGeP8A9rTxLqP7NX7BCyeJ9av2GlfFH9pWOK4j+Ffwa8O3uYdQu9J8SIqxeIPFtxZmf+xP7Gefc+J9AfUruG5udF/aj9l39m/wD+yf8FPB3wT+HUEjaP4ZtHl1PWryONdX8WeJtQf7T4g8V65JGW83U9avi0xj3vDp9klnpNns0/T7SKP034e/Db4f/Cbwtp/gn4ZeC/DPgLwjpa4sPDvhLRbDQtJgZlUSTiy06CCGS6uNivdXkqyXd3Lma6mmlZnPbV+a+Inihh+JMswvCHCWUV+G+B8Djo5nUw2MxcMfn3E2c06NXC0c84nx9GjhsNUq4TDVsRQyjKMDh6OW5LRxeMVJ4zG4zG5li/ruFuDquU4ytnud46nm3EWJw7wcatCjLD5blGAlUjWqZflGGqTq1Ywr1adKpjsdias8Vj6lGg5LD4ejQwtEr5V/bH/ZT8HfthfBPWvhV4nvbjw9rMF3a+KPh34702MtrXw++IOiLM/h/wAVaWUlt5X8hpp7HVLSK5tpL7R76/tILuyupLe+tvqqivzTIc9zbhnOcr4hyHHVstznJsbh8xy3H4dx9rhsXhqiqUqiU4yp1I80eWpRqwnRrU3OlWp1KU5wl9dmWXYHOMBjMrzLDU8XgMfh6mFxeGqp8lWjVi4zi3FqUZWd4VISjUpzUZ05RnGMl/PH8Of2r/FXwO8U2v7N37e9lB8J/jBpQNh4Z+LN9mD4QfG/RrRhb2nivQvFzQ2+k6XqV5EI31e11H+zbSK/kMVwmiavcSeGbD9C7K9s9RtLe/0+7tr6xu4kntbyzniurW5gkG6Oa3uIHkhmikUhkkjdkYEEE19kfFP4PfC743+FbrwR8XPAPhX4ieE7wh5dD8WaNZ6xZxXCo6R31l9qjeXTdSgWR/sup6fJa6hasxe2uYn+avwU/wCCh3/BNv8AZ+/ZJ/Y8/ab/AGlv2dfEfx1+EviT4S/DHxL8QPD/AIL8H/GXxRbeAr7WNMSOSG21ey1P+1vEEunyM586O08R2dwVwsdzEFGP6Ro+IXhLxevr2exzzw04grLnzHDZDkVDifgnG4qWtbF5Xh3nGVZ3wxSrzbqLJlR4iwlCUpxwmNwuFVDB0vyapwvxvkb+rZc8u4tyyn7mEq5lmNTKOIKFFJKnRxlT6jjMvzaVOK5XjvaZZXqJJ1sPWq89af6C+L/Gvg/4f6Hd+JvHPijQPB/h6wRnvNa8S6tY6LpkAVWfD3moTwQeYwU+XEHMkjfLGrOQp/PC61v4l/8ABTzX5/gn+zvD4j8Gfskwamth8eP2l77TrrRx420q0nR9R+G3wjt9RghudRn1VENtrGoy26pFbyqusW1rosiWXi37q8E/8Eb/ANi7w7r1l4n8d6V8TP2gNd05xJY3nx6+JGteNbaFwwY+fo2np4e0HVIXwBJZ6zpeo2UmAz2xcKw/T7QtB0Pwvo+neHvDWj6X4f0DSLWKx0nRNE0+00rSdMsoF2w2en6bYQwWdlawr8sVvbQxRRrwiAVnifFTw+4Hi8Z4fwzvi/jKmm8r4k4nyfA5Fw7wziv+Xea5Xw9TzLO8Xn+b4OVq2WYrOcTluX5fjIwxNbJczlSo8lUuC+J+I2sPxPLL8iyGTX1zKcox+IzHNM2op+9g8XmksJl9DLcDXXuYulgaWKxWJouVGGOwsZzcsX4feAvCfwt8D+E/hz4E0W18PeDfBOg6Z4a8NaLZqwg0/SNJtY7Szg3uzyzzeVGHubq4klury5eW6upZbiaWRuwoor+YsRiMRi8RXxeLr1cTisVWq4jE4mvUnWr4jEVpyqVq9arUlKpVq1akpVKlScpTnOTlKTk2z9gpUqVClToUKcKNGjThSo0qUFCnSpU4qFOnThFKMIQglGEYpRjFJJJI+Qf2wv2YB+0b4K0a68L6xH4Q+Mvw01J/FHwl8bFSE03WgIWu9D1dkjlkfw54iW1trfU1WG4NvPb2N+bW/htZ9Nvvzv8AAv7Q8dprsnwq+P8ApDfBf42aLstdT8P+J2XTvD/iRwTFFrPg3Xp5W0vUtN1Vl82xhS/laYyGPTbnVoYjdn9zq8r+K3wQ+Evxx0NfDvxZ8A+HfHGmReabMazZZv8AS3mCrNNo2s2r22s6JcSqqpLcaTf2U8iAI8hTisTQ+IlYMoZSGVgGVlIKspGQQRwQRyCOCORXJ+MfHng34e6RLrvjbxNo/hnSoVdvtWrXsNqZ2QZMNnAzfab+6bgR2llDcXMrELHE7EA9dcf8ErfgBBIy+EviF+0T8O9LLEpoPgr4ryWukQxsxPkxx63oWu3vljJAL3ryYJJcsd1d98PP+Cbn7KfgPWoPE2oeDdW+KPia2eN4Nb+LniK/8cSK0bB0aTR7r7L4ZuXWQCRJLvQp5IpBuhaPJyAfEfw8+G/jX9vfxTol5f6Hrngv9jzw1q9trGoXuswXGka78e9R0q4EtnpulWjGO6tvBEd1GGu78FVk2N5U39uxQxeHf3FtLW2sbW2srK3gtLOzghtbS1tokgtra2t41igt7eCJVjhhhiRY4oo1VI0VURQoAqSGGG2hit7eKOCCCOOGCGFFjihhiUJHFFGgCJHGiqiIoCqoCqAABUlABXwL+2h+y54n+KMvhj43fBG5sdH/AGhPhZb3EWipfMkGk/EXwnK0s9/8PvEMzvDGizvPdy6Fd3EsVtbXl5eW9xPYrfx6xpH31RQB+JHwy/aO8IeNb+fwZ4tguvhb8W9GnGneJPhj44B0XXLTVUAEsWktqCWq63ayNmW1a1UXzWxjnnsYIpInk+h6+uvjP+zN8Cv2g7KO0+Lnw38P+Lbi2hMFjrcsdxpnibTYcswh0/xPo1xp+vWlsJGMrWcWoCyllAae2lxivkOT/glf8D4m8rRfix+0z4Y0ocJoGg/FmGHRo4sYWCOK/wDDGoXghUYUA3rPgAb6APO/iL8Wvh18KNJl1jx94r0rQIFiaS3tLi4WXV9RKg4i0vR4PM1LUZWI27bW2kVOXmeONXdee/Z/+B3j39rD4jeE/jr8ZPC+peCPgF8P9Rh8RfCD4YeIYTb678QfEUJD6b488ZaaTi30W0wl3o+nzh478eXHALrRrnULvXfsf4Tf8E/v2WfhDrEPijSPh4vi3xlDMlxH4w+I+qX3jjWo7qI5hvLaLWJJNFsL+BgGh1DTtItL6NgCtwNqbftDpxQAUUUUAfmR+2H+zP8AECz8dwftWfs4aZFq/wAR7DSodH+K3wx3/Z4vi74QsVjEE+nOMgeNdEtYIYLEbXn1GztLGGyE13p6aPr3jHwr/aC+G/xZjay0fVTonjCzeS11z4f+J1Gi+M9E1G2Yx3tlc6NdtHPdfZJlaOW5sBcwIw8udoLgSW8f7PV8y/G39jz9nP8AaDmOo/E34aaPqPiMKixeMNIkvPDfi5PKULb+br+g3FhfajHahQLW21Z9Qs4OkdsMmgD5prx74p/Hf4Z/CCyMvi7xDbnWZQq6X4R0kpqni7WrmUhLa107Q7eQ3Ra5lZIY7q7+y2CyOizXce5c+vn/AIJY/BUP5cXxh/ahg0vOP7Bh+LdsNH8rP+oEb+FHvPJ25TH20vtJ+fPNfQ3wW/Ym/Zq+Al+mu+AfhtpzeLVYy/8ACa+J7m98WeK0uHBEtzZ6rr1xe/2PPMCRM2hQ6WsoZxIjb33AHyr+yd+zh8Q/iF8StP8A2rf2jtBk8L3mjWd1bfAj4OX+6S48CadqSbLjxj4qgkWPZ4w1G2IW3tLiFLqwLi6u7ayu7HRrXS/1WoooAK/In9pz4AfEP4DfE7xJ+038A/DN5418C+OJEv8A4+fB7RYy2sjUojI83xK8EWSbvteoSK81xr+mwxtcSXUt3fMlxaajdXXh39dqKAPx7+GXxq+Gnxe0yPUfAvinT9Tm8sPe6JNKln4j0lxxJDqmh3DLf2rROGj88RSWU7Iz2l1cQ4kPqle5fGL9hP8AZh+N+qzeJfFnw4tdI8ZzTG5fxt4Iv77wZ4llvGYs19fXOhzW1lrF+xP/AB+63YalcgKgWUKoFfmNdfsYeCI/+Cgfhz9lS8+KHx71j4Tav+x341+P13aap8TbmTVv+Ev8PfGrwD8ObLSUvLbTLW0XwtJoPijUJrmxOntqcmpR2k8esxW0ctnMAemfFL9orwD8NZovD9vPP45+JGpzpp/h34Y+C1OueLtY1a4OyzspLHT1upNMSaUgebexrNIgk+w2l/Ogtn+k/wBjL9mDxp4Z8R67+0p+0JHZyfHHxxpiaPoPha2kW60z4QeBWfz4vDGnyLJNC2u3x2vrd5BJL5IM1tFdSz6hrU179I/BT9lH9n39nlGf4T/DTQvD2qyxNDc+Jrj7Vrviy6jkB86KXxNrtxqOsx205O+Wwtbu204tjbaIqIq/Q9ABSEBgVYAggggjIIPBBB4II4IPWlooA/En4w/CDxr+xD438TfEHwB4Z1Xxp+yd431W48ReKfDHhy2N5r3wN8Q3hVtT1XTNMVgbnwLdsPMIi8uDSoEjsrp7JrGyudd9O8CfEvwH8TdIj1vwH4q0fxLYOiPIdOuke7smkAYQ6lp0nl6hpdyARuttQtbadcgmMAgn9Z2AYFWAZWBVgRkEEYIIPBBHBFfD3xO/4J1/sqfE3WpfFB8B3Hw+8WTyPLL4l+Fes33gW+eaXmWdtO0xm8ONdTOTJPeNobXlxIzPPPIXfcAeY5r5s+In7RuiaRrEHw5+FOnT/GP4063I9h4f8A+DSNWFrfEYN34p1KzZ7PRNN08EXGorPcR3UNupluFsbLztRtvpKL/gld8CJ3EfiX4nftJeNtKJHmaB4q+LC3GjzRcZglj0rw5pF4YnHyttvUfBOHBwR9m/B/8AZ8+C/wAA9Kk0j4RfDvw74LguI0ivr3T7aS51zVUj2mNdY8RalNe69qyxsoeJNR1K5SFizRKhZsgHg/7Gf7Lmp/AvRvE3j34m6na+Kfj98Wbi31b4i+IbfEtlo9rCu7SvA/hyQgCLRNDRhHM9usUV9dRwqofT9N0lIPtyiigCvd2lrf2tzY31tBeWV5BNa3dpcxJPbXVrcRtFPb3EMitHNBNE7RyxSKySRsyOpUkV+JPxH+DfxI/YY8Ra7r3gTwzr3xO/ZI17UbvXJ9C0GOTVPGnwJvb2V7rUhbWLOZ9X8Cl2knS4LhbGIb9UubK+hm1DxP8At9RQB+P3gL41/Cn4m2cN54J8d+HdaaVFdtOW/itNatt/RLzQ7422rWj5yo+0WaK5B8tnXk9prnijw14Ys5NQ8SeIdD8P2ESGSW91rVbHS7WNAMlnuL6eCJRjnJavpr4m/sLfsl/F2+uNW8a/BHwnLrN3I813rPh06p4J1S8uXJZru/u/BuoaDJqV0zHLz6l9reTAEhcACvO/DX/BMf8AYl8M30eowfBi21e5hcPEviXxb438QWKkNu2yaTqXiOfSLpDwCl5YXAIAB6tuAPhKX4uePf2h9auvhX+yFo1z4l1OWRdP8U/Gu/s7qx+G3w5tLglJ7yPVbm2xrGtpB5s2m2trBP55VLnTLbWljmjg/Wb9mv8AZ68Ifsz/AAu0z4c+FZZ9UujcT634u8V6ggGseM/F2orGdX8Rao3mTMHuGijt7K2aec2Om21nZtcXMsMl1P7F4c8M+G/B+j2fh7wloGi+GNA0+PyrDRPD2l2WjaRYxZLGOz03ToLeztkLEsVhhRSxLEEkmtygAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK80+LXxe+H3wP8Eap8QfiX4jsvDfhrSgEe4uS0l1f3siyG10vSbCEPd6nqt40bLbWNnFLM4SSVgkEM00f5tXX7SP7ZX7QxN/8EfCPhv8AZ1+F90C+j+OPinYDxF8R9es5ObfVtL8H+Vd6LpkM8bLLHa6tZ3dvPGUns9euYjsPlY/OMJgJxoSVbE4uceeGDwlP22IdO9vaTTlClQpNpxjVxNWjTlJOMZOSaP0jgzwt4n40wdfOMPLK8h4ZwmI+p4rivifHf2VkUMYoRqSwOEnGlicwznMYU5wq1cuyHL80x9CjOFevhqdGcaj7rTP+Uyvjf/tGT8Lf/WqPjDX6bV+Icf7Ln7RsXxRu/jtF+2PrC/Ga+8A6f8Mrvxj/AMKi8KlJ/AuleIdU8W6d4VfSjrJ0v+yrXxHrOqapEVsBcefeS73eLZCnplp+0r+2R+zwVvvjl4Q8NftD/C60G/WfHfwqsB4e+IugWMePtGq6t4PZbPSNVhgjV55bbSbKytLeLzJ73XraJQg4VxHCDTxmWZlgqPXETjhMVSprvWjgMXi61OK15p+ydOC96c4x1X2VTwGxeMj7PhXxD8PuLc0atTyTCYriXh7MMZU0tRy2txpw1w1lOOr1G3GhhYZnDHYmpyUsPhKtWpCD/XCivNvhR8XPh98bfBWl/EH4aeI7LxL4Y1ZSIru2LR3FndxhTc6XqtjOqXemarZF1W7sLyKK4i3xybGhlhlk9Jr6ClVp1qcK1GpCrSqRU6dSnJThOEleMoTi3GUWtU02mfiOYZfj8qx2LyzNMFisuzHAYithMdgMdh6uFxmDxVCbp18NicNWjCtQr0akZQqUqkIzhJOMkmgoooqzjCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiikJwPfBx+FAC1+ZP/AAWbP/Gq39u7/s3fxv8A+iIKxv2lv+ClNv4M+Iupfs6/spfDS6/aa/aK00NF4nstN1FNL+F3wok3GF5PiR413C1S/s58JP4dsbu0kWdJtM1DXNG1gQafcfEPxY+BH/BQX9rv4e+Mfh7+0t+1r4B8DfDn4j6HdaF4v+DXwe+Dumax4XvNF1Mf6Zo9z4s8RXmi+MnjMeyKZTq9+pZMQ3bD9/L+25H4F8RYzLcDnPFOf8L+HWW5phqWNyuPF2JzaedZnga8VPD4/CcM8N5PxBxBRwGKg1UwWPzTLsty/H0X7bBYvEUvfPzzMfEfKqGLxGAybLc44pxWEqyw+MlklLBRy/CYim+Wphq2b5rjstyyeJpO8a2GwmKxVfDzXs8RTpT0P6Lc0V+CEOh/8FSvhS39sfD79s7wN8e47Yec/gL46/B7RPDen6j5e1jbp4r8GzXfiQTzqHjhH9q6Rah3UT3Ea/v4vq79l7/gpJpPxK+IFr+zx+0n8OtR/Zn/AGlpYx/Y/hTxBqEWpeBPiaiF4zefC/xsgSx1aaeWGVo9CmklmJzZ6Rq3iK5tNQNpOfeBnEeAyzHZ3wxnvDHiJlWV4epjc2lwfic1/tfKcDSXNWx+O4Z4iyfIOInl+HjzSxmZYDLMflmBgvaY3GUKcoSdZb4i5VicZh8uzfLs34XxuMqxoYKOeUsG8FjcROyhhsNm2V43Msr+s1W1GhhcRi8PisRK8aFCpJNL9QaKM0V+KH6CFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRXm3xZ+Lvw9+B/gjVviH8TvEll4Y8L6QqiW7ut8lze3koc2ul6TYQLJeapqt60braafYwzXEu2SQosEM0sYB6TX5k6n/ymV8Ef9oyfil/61R8Hq8o1j9rj9r749s918CvB/hv9nv4ZXILaR46+KdgviT4ka9ZuM2+raV4Q2XWhaRDPG6yx2urWmo208fl3NnrtzExiPjUnwK/aRl+Klp8eJP2v9af4zWPgHUfhjZ+Mj8JvCISDwJq3iLTPFuo+FV0Yap/ZB0u68SaLpepyM1ibgT2cW11hLwOAfvlRX45aP8AtbftgfAV0u/jn4Q8NftCfDK2w2r+OPhbp6eG/iRoNkn/AB8atqfhDba6Hq8MEStNJaaRaafbwRh7i8121iUJX6ifCb4u/D344eCNK+Ifwx8SWXifwvqyssV3al47iyvIlQ3Wl6tYzLHeaXq1kXVbvT72GG4iDRyhGgmhlkAPSaKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACmswUEnoP8M8+1Orwz9pzxNfeDf2dPjn4p0yR4dT0L4TfEDUdMnTIeDUoPC2qGwuFK8gwXZhmzkY2dRWVessPQrV5K8aNKpVkl1jTg5tfdE9LJssrZ1m+VZNh5RhiM2zLA5ZQnP4I1sfiqWFpylt7qnVTeux+ZWlz/APDafx98TfGbxYDqnwJ+DXiTUfBfwK8J3GZdD8R6/pUsa6/8StQtX/cagLi5WFtHMsTR+SbK2kVJ9Euft321PPBaW81zcSxwW1tDJPPNKwSKGCFDJLLI5wqRxxqzuxICqCTwK+e/2SfDtn4X/Zq+C2nWSIkd34B0HxDMEA+a88V2w8T3ztjq73erTFieei9FGOw+PmqX+h/Ar4061pdtdXmp6R8JviNqmnWljbzXd7dX9h4P1i6s7aztYEknubqe4ijit7eBHmnlZIokZ2VT8Vl0Jxwn1yraeMx0VjsXU1bqVqtNTVNP4vZUIOOHoQTahSpwUb6t/wBYeIONoPiCvw5lUJYbhfgupX4V4Xy9e5Tw+VZTiKmGljalOKUXmWd4qnXzrOMTZ1MXmWNr1JTcFTjD47/4fA/8Etc4P7fv7KgI4wfjJ4OzkHB/5iXODxxmv0Q03UdP1rTdP1fSru31HStWsbXUtNv7SVZrS+0+/t47qzvLaZCUmt7q2ljmhlQlZIpFZSVbn+Vn9lj9q74K/sifsHfsmXXxm/4JXftDaz8Efh3+zv8ABbTfjX+1ldfs4fDO80Hw54ouPCGgHx74r1PwZ4l1Oz+Neq+AvC/ii/1S11r4gXPg2Cyv4NPuNW8MReJNFn0jUtV/qR8H+IfDHi7wl4W8V+CNS0vWfBnibw7oniHwjrGiPFLouq+GNa0y21LQNS0iSALDJpl9pVzaXVg8KrE1rLE0YCkCvbr0Y0nNQ55RjVlT9o5RlGXL8LtFc0HOzklJ+9HVXtJn5flmPqYyKlVnQU5UKNb2FOlXp1KftIxk3z1ZtVoRb5PaUlyc6eq2PkK/n/4Yr+P/AIY+L3hTGl/AT41+JdP8FfG/wlBuj0Pwx4m1WSRfD/xI060jHkabHFcNM2rmKNIRCL60jV5tYsBY/tOCCMggg9xyPzFflX+114cs/FH7NPxo0+9jSSOy8Caz4jh3gHZeeE4f+EmspEJ5V1udJi2kEE5K8hiD91fs2+JL7xh+z38D/FOqSyXGp+IPhN8PtV1KeXJefUb3wrpc19OzEZZprppZSTkndknmuXI5PC5hjsuhphZ0aWY4amrKNCpVq1aOMpU4r4KU6kaWIjBe7GrWrtJKSS93xgpLiPgrg7jzFe/xDg80zDgLPsdJXr5zgsty3Lsy4Vx+Mqb4nMcJga+ZZLiMTUvVqZdleTU5ynOlKT9rooor6k/nAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK/M7/gpt+0n47+D3wz8EfB34IXQtv2iP2o/FZ+FvwyvkkeOXwjpRjgfx18RC8aNJAvhTSb60igvk/eaVf6vaa4qTx6TNBJ+mNfhp8fZD44/4K9+DtK1Rmm074K/sY33ivwzavzFa+KPG/xFvPDesapCGHySXXhzU4rCVlOWFpEpbAZa/ZPAvJcszTjmWZ51g6GZZXwXw9n3G1fK8VBVcJmeLyLBuWRYDG0pe7Wy/E8R4jKIZnh5pxxGXfW6DTVQ+C8SMwxmD4cjg8vxFTCYzP8ANMt4fp4yjJwr4OhmVe2Y4nDzWtPFUsrpY6WEqKzpYr2NS65T0j9nL9njwJ+zT8N9M8AeC7b7RdfLqPi/xZeRhtf8ceKriMHVPEuvXbNLPNc3dwZPsls88sOmWRisbY+XGWfgvjX+3v8AsV/s4eMx8O/j3+1F8EfhB47bSLHXx4S+IHxB8P8AhnXzoupyXUWnaoNN1K8guPsN7JZXaW1xs8uVraYIxKNj64r45f8AYm+DuoftT/FL9qzxjpumePPEPxN+FHwx+FVx4S8beFvC3iDwz4Y074X6x411iz1rQX1TTLq+t9T1p/Glzb6uXn8gwabYiJFIcn7HPs2zzO8yr5vjcW8wzTNMdWxWa5jmEpVqlSdWFWrUrztUpuUpVo0qMYQahSpztCCp0oxXgZZgcuy7C0sDh6P1XB4PDwo4PC4ZRhCKjOnBQ1hJJKm6lSUmrznH3m5Tua/wN/br/Y2/aZ8XXvgH9nz9pv4LfGXxrpvh+88V3/hf4d+PdB8Ua3Z+GtPv9L0q+1y40/S7ue4i0y11LWtIsZ7tkEUdzqNnEzB50B6b9pn9nDwb+0t8Obvwh4hDaT4l0t21n4dePNP3weIvh/4ytQs2leINGv4Hhu4kS7htv7TsobiFdRtI/L3w3UNneWv5g/8ABLnwV4L+PP7SX7Y//BSHwz4Q8MeG/h3438Sz/sj/ALI8fhjw9pOg6Td/s8/AjX57bxz8RtIGjWlpa39j8afjTbavrEd3NF9shs/BunWUjeTDGK/cejhfPs4ynE5XxDluLnl+a4LExx2X4zBuVOUOSpJ4aslNzUoYnD8sqtCpz0qtGtPD1oTpyqQdZzlmAxtPGZVjKCxWCr0/q+KoV1Gak3CPtqd4qNpUa3NGFSPLOFSnGrTlGSjIz/8Agmp+054w+P8A8GNe8HfGHZD+0L+zv4vvvg/8Zo+BJrOqaKHXQfHSKqRo9t4w02CSSS6iSK3vtZ0zWryygt9Pls4l/Rivw9/ZQZ/Bf/BWX9ojwrpbNBpPxe/ZN8E/FnxBaRkrBN4l8D+NtG+Hmm3jxj5BONM1LUCWwGZ7u4kOWldj+4VfE+OORZZkvHtbF5Jg6GW5PxZkfDvGmByvDR5MLlM+Jspw2YZplWDpr+HgMuzyWaYPLqd7wy+jhYuzTS9/w5zLGY/hqFDMK9TF47JMxzTh/EYyq+atjY5RjauGwmMry+3iMVl6wlfFT+1iZ1Za3uFFFFfkB92FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUABOAT6c1+FWp6837aHx+8S/FbxG/8AaXwI+C/iPUfBXwR8LSky6L4k8RaTJGniH4l6hav+41Fbm5WI6K00TRi1NhbOkdzpF99u/Wf9pfxNqHgz9nb46+LNJlaDVfD3wi+ImraXOhIaDUrLwnqs2nzgjkeTdrDLkdkPI6j8wf2W9AtPDf7PHwgsLNFSO78D6Nr8u0Ab7vxTB/wkt47Y6s11qsuScnjHQAAA98ooooAK+WdN11/2L/j74b+LHhpv7N+BHxm8R6d4K+OPhWEtFonhvxBq0skfh/4mafaxgwacLS6klOstFEsbW3220jSS41mzNh9TV4L+1FoFp4k/Z5+MFhexo8Vr4F1zXot4B2Xnhe1bxJYyLno6XelQlSOc8dyCAftVmivEP2Z/Et/4y/Z1+BPirVJHm1TxB8Ivh3q2pzyEs9xqN74T0qa/uGJAJM9200xz/f6nqfb6ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvOfjB4JX4lfCj4lfDxnWL/AITjwH4t8JpM/CwS+INBv9KhuCcHBgmukmB7FARk4FejUhGeD/n86ipCNWnOlNXhUhKnNd4zi4yXzTaOvAY3E5bjsFmODqOli8vxeHxuFqpXdLE4WtCvQqJPRuFWnGVvI/Ij9inxe3iX9nzwfouoRyWfib4am++GHivSLgbLzR9X8GXDabDZXUZJZJf7HGlzMpACPK0Q5jNfRHjf/hM/+EM8W/8ACuf+EZ/4WD/wjWuf8IN/wmi6m3g8+L/7Muf+EbHioaIyaz/wjh1j7GNa/sphqQ003Jsv9JEYrwH9o/4beM/2XPi/4i/ai+F/hzUPFnwg+IrQz/tD/D/Q4jLqnh/Vbbfj4p+HLJCqXCmN57nxFCcKk8uo31/KlpqJ1Lw97X8PPiZ4F+Kvhy18VeAPEumeJNGulXM9jODPZzMgdrPU7GTZe6ZfRA/vbK/gguEGGMe0qx+HwMpYVLKMVLkx2Cpqkr2i8XhaSVOhjqH/AD8hUpqDrct3Qr+0pVLOKcv684xw1DiHn8TOG6X1jhLi/GVMxqvDN1lwvxFjpfXM44RzhRvLA4vLsdVrxyuWJ5I5vkzweZYOVWNStGj+FXxz/aY/4KRftG/sx/FP9i/Uv+CWnxU8KftM/Gn4U+Lvgb4y+Kt/8QfhMf2LvDkHj/w1feCfFXxY0b4nR+NtU8W6poFnpOq3vizQ/AK+Dr3xasgtfDM9xqOpW8s9z+z37MXwaX9nT9m79n/9n9NZbxGnwP8Agr8LvhGPEDxPbtrp+HPgjQ/CLawbd3le3/tNtIa9Fu0shgWYRF32bj7lXB/ET4m+BPhT4cuvFXj/AMS6Z4b0a1RyJb6Yfab2VULiz0uwj33uqX8oGIrOxgnuH5bZsVmHq1cTThRqOfsaFK8atao5OEF7NS5XJzk4whD2lSSW37x3ulFR/PMrybGYzMMNh8HHH5vmOJ5cBgMJRoLEYqrKtUg1RoUMJQVXEV604U1pCc5ckVCKk5ufhH7bHi5/Dv7P3ivQNOR7vxR8TptO+F/hLSIMtd6xq/jG7TT7iytY1O+SX+xv7UlVQCHkSOE8zLn9OvhN4M/4Vx8Lvhz8PvMWX/hB/A3hPwiZkHyTt4d0Gw0l516H989o0pJ6l89Sa/NT9m74Y+NP2n/i74f/AGp/ip4c1Dwl8J/h+J5f2dvh3rkRh1bWtRuwA3xU8R2Thlty8aQz+HocENPFp17YytZ6VFqfiH9bKMiozr18Vm84ShSxFKjhcApxcJzwlGVSrPFSg7OCxNaq/ZRkuZ0KNKroqtkvGbMsJkuT8N+GOFxWHxmZ5HmGa8ScaVsJWp4nC4TiXNsPl+X4bhyniaMp0MTV4byvLYrMKtCc6dLOc2zTL1UqfUOdlFFFfTH8+BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABX4d/tpWz/Bj/gpZ+zD8atR/wBF8GftA/B7xL+zLququjfY9P8AGeieJJfG/hG3vJwPLivPE9/qelaNpaOd8/2K8K/ureYx/uJXyn+2b+y14Z/bA+BPiX4Q69eyaDq7zWfib4feNLWIyah4F+IegefN4a8T2JjaOcCCWafTtUitpbe5vND1LVLK3ubSe4juoP1Hwe4syvhLjbD1+IJ1aXDOfZXnHCXEmIoUnXrYHKeJMBVy6WbUqEU54ipkWNqYLPYYaHv4qWWrDx1qnxvHmSYzPOHqlPLIwnm+WYzAZ3lNKpNU6eIxuVYqnilgp1JaUoZjh44jLpVW0qP1r2r0geR18If8FJz+0hqf7H/xQ+H/AOyZ4T1TxL8c/jJFpXwX8L6pp95ZabbfDjSviXfxeGvGfxV1jU7y+sG06w8BeDbvXtatbyya51CLXo9G+zWk25ylL4C/tSeIPDPir/hlv9sW0t/hT+034RWHS7a+1mVLHwZ8btKiJtdL8ceAfEMyW2lahc68sXmXOmRPA91qH2g6ZaxXEepaFoP35mv1nizhLNOH8RUyrNYx9hjcNHEZdm2X1Y4nKs9yjEq+HzfIczpqWHzDLMdRfNh8ZhpNx5pU5qjiqVSnT+JyPPMJmdKGNwbftcNV5MXgsTB0sZluOov95gsxwkrVcNisPUVqlGrFKVlJe0ozjKXjX7O3wN8F/sz/AAJ+En7P/wAO7X7L4L+EHgHw34D0ItFFFcX0GgabBZ3Gs6gIQscmr69fJda3rNyBuu9W1C9upC0kzMfZaP8A9f5V+e/xw/aY8VfE3xdJ+yd+xVHD8R/2hPFSTaX4l8Z6PKbnwH8A/D0ziy1rxl4v8T2iXOn2+r6Qkskdhp8D3U9lqoiS4t7nWf7L8N65vwzwtmfFGNlg8uhRw+EwdB4vN84xs1hcl4dymj/vOb53mE0qGX5dhKacp1akuerNQw2Fp18VVo0Kmeb5zhMnw6r4qVSrWr1FQwOCw8fbZhmmNqfwcFgMNH95icVXm0owguWCbq1ZU6MJ1I+qfsBW8nxg/b9/bM/aH0/M/gr4Z+E/B/7LPhPVlVmtdX1mwvbbxZ8RLe1nG6GQ6B4h0i1SUxsVkt9Z0+dCVlJr9vK+av2SP2ZfBv7I/wACfBfwU8GyyaimgW8+oeJvE11EsWpeMvGmruLvxL4r1IBpHE+p3pKWlvLPcvpukW+m6StzPFYRSH6Vr8b8XuLct4x45x+OyF1pcN5VgMl4W4aniKToYjEZHwvlOEyTB5jiKDblQxOdSwdXO8Vh5OTw+JzGrQu1TR95wLkmLyHhzDYfMlBZtjsTj85zaNOSnTpZjnGMrZhXwtOorKpTwCrwwFKqklVp4WFSycwooor8yPsAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDz34t+CV+Jfws+JPw7eRYV8d+A/FvhDznOFgbxHoN/pCTk4JXyHu1mDAZBQHtX46/sheJptc+BvhjQtTiksvE/wAN5tQ+GnivSLj5bvR9Y8H3Ummx2N1GTuSZdKXTpHUgBJHkiBPlE1+5lfj3+1Z8IPGX7OHxY8Q/tUfCrw5f+K/hX4/8ib9oj4f6FAZdV0LU7TcF+K3h2xTatwvlNLP4nhAGy4k1DUr6QWmpzan4dAPVKK4vwH8Q/BfxN0C28TeBvEOneItHuVXM9lNme0mZQ5tNRs5Al5pt9GCPNs76CC4j4LR7SpPaUAFfMn7XnieXQvgZ4p0TTopL3xL8R3sfhp4V0i3+a71jWPGVymmSWNrGDvkmOlPqMyooO940iODKDXtHjv4h+DPhnoFz4n8c+IdO8O6PbK58+9mAmu5VUuLTTrNA93qV9IB+6srGCe5k6rHtDEc7+yr8HvGX7SPxX8O/tT/Fbw9qHhP4U+ADNcfs7/D/AFuEwatruq3QUf8AC1fEVk4YW8axpDceGoed9xHp+o2MptNMj1LxEAfqH8JPBI+Gvwr+Gvw7EiTHwL4C8I+EGmj+5PJ4c0Cw0iSdTgZ8+S0aXJAJL5I5r0KiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAa6LIpRwGVgQQRkEEEEEHgggkEHqDXwR8Tf8Agnb8EvF/iK68dfDnUvGn7P3j+8ZpbrxD8HNbbw1ZajMzmRm1Xw2I30mWORy0lzHpSaM97K7SXk07O5b75orjxmAweYQjTxmGpYiMHzQc4+/Tl/NSqRtUpTtpz0pwnZtKSufUcK8a8V8EYytj+FM+zHJMRiaX1fGLB1v9lzDDJ831XMsDVVTA5lhOb3vquPw+Iw7laXs+ZJn4Q2nwf/aPuv2zNc/Y+P7YfjePSNG/Zk8LftE/8Jx/wgnhw6xcxeJfip4w+Gf/AAh32T+0BPDLZL4T/tn/AIScazK9w1+bH+xIfs32y4+5/hj/AME7vgj4N8R2vjr4h6j4z/aA8f2bRy2niT4ya43ia0024RvMEmleHGjj0mOOKQJJaJqsesy2MqLLZzwOqFeA0z/lMr43/wC0ZPwt/wDWqPjDX6bVwUuHcnpVI1fqsq8qclKn9cxWMx8KclqpU6eNxGIpwlFq8ZRipResWtD7TMPHXxSzDB4jAR4koZPh8ZRnh8a+FeHOFuDcTjqFRctWhjcdwnkmS47F0a8bxr0cRiKlKtBuFWEotptVVQAKAoAAAA4AGcfzp1FFe2fkYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHgH7Qn7LvwH/al8If8IX8dPhxoXjvSoPPl0m7vEmsvEHh27nRUkvfDXiXTJbTXdBupPLi89tNv4I71Ykgv4rq2BhP4h/tq/sUfEn9g/8AZW+PP7Rn7O/7aP7Qdj4a+CHw71rx5p/wh+IU+hfEPSryDRUSRPDmj6/qtvbJ4Z09g/l28y+HdYe3RQZor2UtI39HdfmT/wAFnP8AlFb+3d/2bv43/wDREFfo/Cni34hcF5e8nyLiKosjdaeIXD+cZflPE3D0MRUd6uIo5DxNgM3yfD4ms7e2xFDBU69W0faVJcqt8pnPBHC2f4pY/Mspg8w5I03mWBxONyjM50ofBSqZllOJwOOq0of8u6dTEShTvLkjHmd/FYf+CS3jjx0fsf7SH7en7Q/xZ8MSYF/4P8D2GifBfQNbhOPMstctNIvfFK6hp8wBSeBRbzbWJguoJCJK/S74C/s2/BD9mTwdH4G+B3w60D4f6AWimv10uKWfVddvIUaOPUPEmv6hLea74i1BEd0ivNZ1G9mghYW9u8VuqRL7lRUcV+LHiDxrgYZTxBxHWqZJCtHER4fynAZVw1w59Zh/DxU+HuGsBlGS1MVT19niamBlXpqUlCpFSld5JwTwvw9iZY3K8ppwzCUHSeZ43EYzNc0VJ/FSjmea4jG4+FKW86UMRGnN6yi2kFFFFfnZ9UFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABSMAwKsAQQQQRkEHqCDxS0UAfAPxT/wCCcnwJ8c+Irvxz4CvfGXwA8fXrPLd+I/g3rX/CM2Wp3DtvZ9W8NeTNo0scjlpLpdJi0Wa/ld5b24ndnLfBF18Afj5bftn6H+yB/wANe+M30bWf2ZPFX7RX/Cb/APCAeGl1i3j8NfFXwd8Mx4N+yf2k00st4niz+2f+En/tiNrdrD7D/YU/2n7bb/vrX5k6n/ymV8Ef9oyfil/61R8HqAO4+Fn/AATk+BPgfxDZ+OfH174z+P8A4/smSa08R/GTWz4lstMuEbeG0nwyIodFiijcLJbR6rDrUtjMiy2VxA6oV+/QAoAUAAcAAYA+gHApaKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr4G+Nv/AAUE+GXw28VXvwy+GvhrxL+0D8W7EyxX/g74ciOXSfD1xExSSHxd4xeK60zRWhmBgvY7S31e60ydTDqttYvgHhP26fjp44uvEvhX9kr4JazN4f8AiB8R9Im8RfEjxzYmQ3fw2+FSTtZXN1YyQtG1r4g8STJcWOnzJcQXVpEkSQPZ3Wt6Zqll578L/hT4J+D/AIYtfCvgjSItPs4lje/vnVJdW1y+VNsuqa3qARJb++nYsxZtsFujC3soLa0jigQAguP2sP8AgoJrMn23RPgb+z54NsXbemjeMfFniPxLrKRkkrFJqXhjW9N00y7Sqs4tVXcCSi52rsaZ/wAFCPjR8OZEl/aR/Zj1Gw8KoR9v+IfwZ1+DxnpmlxZVZLzUvCly7apYabBuMs97da3HIkYKwWl3LtV+1oIyCCMg8EEZBB6gigD7r+Fvxa+HPxq8IWHjr4X+LNK8YeGNQykd/pkr+Za3KKjzafqlhcJBqGkapbrJGbjTdTtbS+hWSN5IFSSNm9Fr8FfFFprv7Ifjr/hpv4J2c0XhQ3VpH8f/AIS6aRBoHi/wi9xtuvFGk6au210zxNoBnkvo7uCOOKLdNfSeVYv4ht9Z/cnwl4q0Lxz4X8O+MvDF/Fqnh3xVoumeIND1GHcIr3StXs4b+xuVVgHTzbaeN2jkVZI2JjkVZFZQAdDTJJEijeWV1jijVnkkdgqIigszuzEKqqASzEgAAkkAU+vyI/bJ+KXir48/Fu5/Y++HGvX/AId8BeF9M0/W/wBpLxjoshi1G5ttXiW50f4WaXeBTHbvrFm0dzrjZkFxBPJaTxy22j6xpGqgHq3xM/4KOeDLPxHqXgL9nX4feJf2lfGmlSm21W98J3dvonw10S53+WYtS+IV7bXmnzOGyyS6faXOk3G14k1qOZXVPIJP2qP+Ch15KLyy+Dn7NujWJ+b+xdZ8ReLtT1pVPJibVdK8QwaSZRyokW28otzt29eo8HeC/C3w/wDD9h4W8G6HYeH9B02MR21hYQiNC21RJcXMp3T3l7cFQ91fXck13dS5luJpJCWrqKAOY0L/AIKOeLPAV3b2n7VP7PfiT4Z6HNNDbt8T/AOpx/ETwNaNM+xbjW7TToTqug2meERLnWtTmYgR6aQC1fpl4P8AGXhT4geG9K8YeCPEOk+KfDGuWy3mla5ol7Df6dewMSpMVxAzKJYpFeG5t5Nlxa3EcttcxRTxSRr+d1xb295bz2l3BDdWtzFJBc21xEk9vcQTIY5YZ4ZVaOWKVGZJI5FZHRirAgkV8seHPEV7+wd8U9L8deGJrlP2XviZ4ksdF+LfgYNLNpfw11/V5Y7PTfiN4Zg/ef2bp6y+XBrNlAgiltUGlokzy+G49EAP3dopkUsc0cc0MiSwyoksUsbB45I5FDJJG6kq6OpDKykqykEEg04nAyeg9j/SgDP1bWNJ0HTL/Wdc1Kw0fSNLtZ77U9U1O7gsNP0+yto2lubu9vLp4re1tbeJWkmnmkSKJFZ3cKCa/NzxN/wUQn8X6xf+HP2UPgr4q+PkunXUljfePby7j8CfC60u03b1tfEOs2xk1h4SpZoGTR1uois2nXd5E6O/kXxi8Qar+258cPE/wstNUv8AT/2W/gXr0ek+ORpNzNZt8Yfidp8omufD8t9A0bv4Z8MTJ5NxFC5zPH/aMTtPqmhaho/1noeg6L4Z0mw0Hw7pWn6Homl28dpp2laVaw2NhZW0QwkNta26RwxIOSQqDexZ3LMzE/JYjM8bmFWrTy+v9RwNGrOi8bGnTq4rGVaUnCr9VVeFShRw9OalT9vUo15V5xl7KFOmo1an9NZL4fcI8C5bl2M45yiXF3GeaYHCZrT4QxGPx2V8O8MZfmFCnjMtXE1XKa+DzrNM9xuEq0MbLJcDmWUYfKMNXoU8xxWMx1XEZfgPhOBv26bf9pLU/wBq9PhX8Bz461b4JaF8BrrwwfGHiL+z18DeHvHniL4iWLwk6iIE8TPrnifUYLjU31B9OksEtYV02KWKS4m+lvDP/BRGXwnrGn+Gv2rPgr4q+ANxqVyljYeO7e8i8c/C68unwEW58R6PbK+kPMTkQBNXS0iDT6je2cKu6+2Vk67oOi+KNIv9A8R6Tp+uaJqlu9pqOlapaQ3the28gw0VxbXCPFIvRl3KSjqroVdVYYKOaUH7TDZxip1I2bpY+nhsVhqtteWpGFChXhzbXoV6fLe/LJLlfr1MX4dZxH6ln/hXw1hMHP3P7Q4LxmfcPcQZfGXu+1wdXGZvnOTYydJXl7LOsmx/t2uR4ig5e2j9n6Vquma5p1jrGi6jY6vpOp2sF9pup6bdQX2n39lcxrLbXdleWzyW91bXETLJDPDI8UqMGRipBq/X44fBnxHrH7Evxw8M/CO+1XUNR/Zd+OmuTaX8PW1a5lvH+EPxOvpWmg8Mpf3DSSDw14mml8u0imkGLmYag5SbTfEOoav+xwOc47da+hyvMlmNGpz0nh8XhqnsMZhnLn9lV5IzjKnO0fa0K1OUatCryxcoStOMKkakI/iPiNwFPgXNMCsJmCzzhniDA/2vwtn8cO8K8xy329XC16GNwntKywGc5VjaFfL84y729dYfFUfbYevicBisFi8Qtcv4z8a+E/h54a1Xxj448Q6V4W8MaJbNd6pres3cdlYWkQIVQ00pG+aeRkgtraISXN1cSRW9tFLPLHG3RTzw20MtxcSxwQQRSTTTTOscUUUSF5JZZHISOONAXd3IVVBZiACa/FMT3f7e/wAUtS+JnjR7qb9l/wCGniO90T4O+AJDJDpPxH1zR5XtNT+Inii2/d/2lYNOJIdKsp4zGkLtpMixC28Qxa5Ga5nLAxo0aFONfH4yU4YWjOThTSpqLrYnETV5Rw2HUoOo4pynOdKjC0qqkuvw18P6PGWIzXNM7zCtknBnDFHC4jiLNsPQhisdVrY6pVp5VkGSYWpOnRxOe53Uw+JWEjXqU8Lg8Hg8xzXFyeGy+pSq+16j/wAFBPH/AMSrqe3/AGU/2dvEnxI0CKaW3j+KHxC1KL4d+Brton2NcaNaajGmpa7ahvldBeaTqcJGJdNBIIyk/aB/4KPWTm9vPg3+zZrdmvz/ANi6L4m8U6ZrLqBkwpqereIptJEx6eY8IiDditfRtta21lbwWdnbw2lpaxR29ra20SQW9vBCgjigggiVIooYo1VI4o1VI0VVRQAAJ68F08yqvnr53jo1Xry4SGDw2Hg7rSlRlhq83FOySxFbEN9XrY/ZIZh4f5bH6nkvhJwfUy+Hue24oxnE/EOe42CVvaZhmVHPMowdKvNayeRZVklGL1p0ou8n5h8O/wDgob4Xk8Tab8P/ANo34deKP2avGuqzC20q78XXFvq/w41y5L+X5el/ECyt7TT1O7Bea9tbfSYSyQNrEkzor/opHIkqJLE6yRyKrxyIQyOjAMrowyrKykFWUkEHIJFfBfjrwF4P+JfhrUfCPjjQNP8AEfh/VIjHc2GoRB1R9rCO7tJl2z2N/bli9pf2ckN5ayYkgmRhmvGP2TfiF4t/Z7+MMP7HfxJ16/8AEfgTxLpmoa/+zX421qXzNRGnaUjz6x8MdVuyu24udFtEefRzujW3ggS2gjhtNX0XStN6sJmmMwdejhsyqxxWGxNSNDDZgqcKNaliKjUaVDHQpKNCSryfs6OJowpL2rhRqUU6kaj+c4m8POFeKsjzbiHw+y7EcOZ/w/gK+cZ5wPLHYrNsrzDI8HD2mZZxwjmGYVK2bUZ5NQTxua5Dm+LzTEf2XTxWa4LNqtPB4nA0v1eoozXN+MfFug+BPCniTxp4ov49L8O+E9E1LxBrmoS5KWel6TaS3t5NtALSOsEL+XCgaWaTbFErSOoP1EpRhGU5tRhCLlKUnZRjFXlJt6JJJtt7I/nXD0K+Lr0MLhaNTEYnE1adDD0KMJVa1evWnGnSo0qcE51KlWpKMKcIpynKSjFNtI5r4q/F74c/BPwjfeOfif4s0vwj4csSIzeai8jTXl0ys8WnaVp9tHPqGr6pOqO1vp2nW1zdyqkkiw+VHI6fnxcft2fHv4olp/2bf2XtRufCcmTp/wARPjTr1v4M0zVIiSI7zTfC0EkWpX+mzAeZBe2WsztIjBZra2lDIPHfhn4Z1r9rbxov7VXx4sJLrw7NcXK/s/fCbVAtx4f8G+D47gLZ+KdV01s2mp+JNdNvHei7nieGbZDqaebajw9Bov3SAAAAMADAHoPQV8fLMMwzX99hsRUyzLp64d0qVKWOxdJ/DiKk8TTrU8LSqr3qVGFF1/ZuM6lanOTow/qahwTwL4bWyzPciwfiDx1h7Rz2GaZhmVDgzhrMEl7fJMDhMhx+WY7iLM8tqc+GzPNMXm0MmWNp1cLgsrx2HoRzLFfN0X7RP/BRTRGN9rXwM/Z88aWSHe+jeDfF+veG9ZkjByY4tQ8T65f6aJSuQGNu43ciNvun2n4Mft8/Dj4g+K7T4Y/E/wANeJ/2fvi5eGKKy8G/EiJbfTNfuJWCRx+E/FohtdO1rz5SIbJLq30m51OZhFpdvfNnHU15b8W/g54C+NnhS68JePNGh1C1kSR9N1OJY4ta8PagyBYtV0LUSjy2F9Cyox27re6RPs19Bc2jyQOovNsI/aYXMq2LcdZYTMlQnRrLR8scTRoUsTh5yXw1HKvTi2nKhNXT1qw8MuJV9Q4j4AyzhiNVezpcT8AVc2wWaZZOWkK+IyHNs3zLIc7wlJ2lXwMKOT4/EU+aNLOcPUcZn6Mhgehzxn8KWvzb/Yn+NHjjS/FXi79kn436xJrvxD+Gmlwa98PfHF2X+0/Ev4VzTR2djf3TymSS413w9I9vY6jM881zco7xTyXl3oup6ldfpJX02X46lmOFhiaUZ07ynTq0alvaYfEUpOFahU5W489KaavFuM48s4OUJxk/59444NzHgTiLFcP5hWw2NjCjhcflmbYFzll2d5LmNCGLyrOMvnUjCo8LjsJUhU9lVjDEYSuq2CxdOli8NXpUyvHPjP8AHr4XfAPw6viP4leJbfR4rpnh0fSYUkvvEHiC8QL/AKHoWjWwe7v5QzxJLMFjsbMzRPf3dpC4krS+NHxW8O/BH4Y+Lvid4oZjpfhbS3u1tI3VLjVdSmkjtNI0a0ZwyLdatqc9rYQu6mOFrjz5sQxSMPzp+DPwt17xprx/aP8Aj4i698W/FqR6j4d0W+jZ9H+FXhmUvPovh/w7plwZI7DUYLWZZby6dTfWs8ssTSf2nJrF/qX6pwXwdgc0wWJ4l4lr4rDcNYHFxy+jh8BKlTzPiDN/ZQxEsry+tXp1qGDo4XDVKWIzXNKuHxMcDSxGEpU8LiMTjaEF4mBwVOrTnisU5xwtOfs4xptKria1lJ0abkpKChFqVWq4yUIyilGUpxR3M37W/wC1B8QGa7+D37M9l4a8Ny/Np3iL42eJRpN7fwOA0VxJ4P0qax1ayR0IdGjvtRt5VIaO6IwDFH+0R+3P4Z/07xR8BfhD490+LMlxY/DvxlqXh3VhCuS3kf8ACUX+srcTBfuw29pPLKw2xxMzAD6Dor71Y3hWnD6vQ8OeEfqa932WKq8TYnGVY3+Ktmq4go4xVpL4p4R4OipNunh6cbQXf7XCL3Y5Zg/Z9pvFTqNedX6wpc3nBQV9ope6J8EP2w/hh8Zdal8EXMGu/DT4qWaE3nwz+IVidE8RSNGheZ9Fkkxaa7CqJJOqWjpqQtEa8n0y3th5g+sa/OX40fA/wr8ZNEii1DzdC8YaKy3vgvx7o+bbxJ4T1i2kFzZXdjfQPBdSWiXSRyXOn/aI45tvmwSWl/FaX1t6b+x38dPE3xH0HxT8NPir5Nv8a/gzqVv4c8aeXhI/E2m3Ebv4e8bWUYjhDQ65aRM120MaxNcImoJFZ22q2lpF8nxXwblFXJ8TxTwjHFYbC5fUw8OIeHcbX+uV8nhi6scPhc0y7HuFKpj8kr4upTwVRYmmsdleLr4Shia2Nhi6WLOTF4KjKhLGYJTjCm4rE4acueVDnajCrTqWTqUJTag+ZKdKbjGTmpKR9m0UV8Rft9ftYS/sl/AybxP4Z0lPFXxf8f69pnwx+B/gny3uG8S/ErxSZYNJNxaRMs1xpWjQpPq2oRJJbi+e2tNFW8s7rV7SdfhOGeHM34v4gyjhjIcN9bzfPMfQy/A0XONGn7avKzq4ivUcaWGwmHhz4jGYutKFDCYWlWxFecKVKcl8vm+bYHI8sx2b5lV9hgcvw9TE4iooynPkgtIUqcbzq16s3GlQowTqVq04Uqac5xTuftWft5/AD9kaPTNJ8e6xq3if4l+JEU+D/g18OtMbxX8T/FLyu8Vs1poEEsMem2N1Ojw2+p65d6ZZ3ksNxb6dJfXkD2tflJ+018Zv2+P27fgR8VvgVp/7Hvgb4MfCL4zeENV8F6tf/Fv4qySfESXw7qwCS3ltpPh2DT7jwtq7RojfY9Z0S++yPvQ/a0KTH1v9l39laD4SDUvit8VdWf4pftRfEhm1v4p/FrXympanHqmoxIbnwv4SnlQDRvC2kxhNMgj06KyXUYLSHdb2ml2+k6LpP2TX9NUMm8LeB/8AhMyrhfLPErNcN+7zDjDi2tnUclxWLhpXfC3C+U5lk1OjlEZpxwuM4kq5vj8wpJYuWCyd1vqNH8hnmHGPEX+143N8Xwngq1p4XI8kp4B5hSoys6azjN8bhcdOeNlFp1aGV08Fh8NNugq2N5PrE/km2/br/wCCkPwzxqXxj/Yt+G/xW8MwkNql7+zl8RLy08Q2FqCPMuLDwf4sn8S614huFTcY9OsEgaZwEa7t0PmV9+fsq/ty/s//ALXun6mnwx8RX+l+OPDakeM/hN4508+GPid4OmSQQTrq/hq4ll+02lvcsttNq2h3er6RDdSJZXF9DfFrVfOa+Kf2ov2Wrj4hXWm/HH4G6m3wv/au+Gh/tz4d/EfQjFp0/iG40+BgPBXjfC/Ztd8Pa5ah9IJ1eO6jsorlre4S60K41XSdQK+ReF3Hf/CZmHDWV+GWdYn93lnFvC2IzuXDtLGT0oR4s4bzfMs6SyqpNqniMy4br5Xicspv648szhUpYSoqeZcY8N/7Zhs2xnF2X0ffxeSZzTy+OaVMPHWrLJc2wWEwH+2xinKlhc1p4yjipL2CxWBc/bw/d4HPSivjr9hf9quy/a8+AWh/Ee50oeGPH+h6nqPgH4veCmSaGXwf8TvC5hg8R6ULe4zcQWV2s1prelwzyTXFtpuqW1lezPqFreBfsWv5h4i4fzfhTPc34az7CSwWc5Hj8TlmY4VyjUVLFYWo6dT2dWm5Uq9CpZVcPiKM50cTQnTr0ZzpVITf7BlWaYLOstwObZbWWIwOYYali8LVScXKlWgpxU4SSnTqRvyVaVRRqUqkZU6kYzjJJCQOtfn3+1H/AMFHfgb+zV4mg+F1naeK/jb8e9SRDpfwP+Dul/8ACUeMIWmiWa3l8TzRH+z/AAravFJFcvHfSza19gkTUbXQ7uyPnjlf+Cj/AO1V47+DHhbwF8DvgGsF3+05+0rrV54O+GckqrNb+BdBsYYpfGXxQ1KMw3CJB4W0+5RtPNzC8CXkk+rvbanZ+H9R0248O/Zp/Zc8A/s2eGJ7XR/P8U/ETxK8mp/Ev4s+It1942+IHiO9lN7qmoarqt3LdX0eny6hJNPY6QLuaG3DG4u5r/Vp77U7z9n4B8N+G8Nw5gePfEWGPx2Azmti6fB3BeWYv+zMXxJSy7ETwePz7Oc2VKvWynhbC5hSr5ZRjgqLzXPcwwmY4XB4nK6OX1swfwHE3Fma1c2xHDPCssNh8TgIUZZ9n+LorF0cpniqUMRhsuwGDc6dPG5xVwtSGLqfWJrB5fhq2Fq4iniqmJp4Y52f9sj/AIKpeNsan4G/ZN/Z1+E2kTgS2ml/GP4la54z8QG3cBojct4E1Xw5FaTshzJb3en21xA5Ec0CsrCp7b/gob+3R8Iiuo/tHfsRad408FwfPrPjL9mHxsniLUtJto1Lz3cXw51+51PX9SiijVpJHm1fR7S3jVpJ74Aba+s6K+9ebcBVorCYrwY8PP7Mfu+wwFfjjA5nRp7c+Hz18YYjMZYmCs4VcwlmOHc9a2DrU3Kk/m/qPEtOXt6PH3FKxitJTxNPh7E4Oct+Wrl39h0sN7GWvNHDrDVVF/u69OVpr3n9mr9rH4FftaeDH8bfBLxxZ+JbSykitfEOg3MUmleLvCOoyq5Gm+KfDV6I9S0m5Zop1t7ho5dM1P7PPNpF/f20TTV9H1/Pd+0n8CfFvww8V/8ADaX7JUaeEv2g/h7DPrHjTwvpULQ+Gvj94Htil54n8I+MdDs/Ki1TWruxt5J9Ov4ozql/d29vEko1uDw9q+ifs5+zV8fPB/7T3wQ+Hfxy8Cu66B4+0CLUjp00iS3mg6xbTS6d4h8N6hIior3/AIe1201DR7qVFWG5ks/tVtvtp4Xb8o8S/DjKciyzL+NuCcXmGO4KzbHyyjEYPN5Uaue8IcQrDzxkMiznE4ajhsLmWHx+DpV8bkGeYbCYKGa4fCZhRrZfgcbluKon2nCHFmNzHF4nh7iGjhsPxDgsNHG0sRglUhl2eZY6kaDzHA0a06tbC1cPXnToZll9WtXlhKtbDTp4ivh8VSme60hIHU4pa/IH/gox+0N8Tdd8b+BP2EP2b/ENx4X+Kvxh0W58V/Fv4l6cZHvPg38Dre5fT9R1Swkt3ia08T+LLiK60vR50ura8s0WKG3l06+8R6PrWnfF8BcFZjx/xLhOHcvr4bAQnRxeYZrnGPdSOW5FkeWUJ4zNs6zGdKE6n1XAYOnOoqNGE8TjMQ6GBwdKtjMVh6NT6HiXiDC8M5TWzTFU6uIkqlDC4LA4bleKzLMcXVjQwOX4VTcY+2xNecY883GlQpKpiK8oUKNWcfRP2hP+Conwl+FfjnUPgv8ABnwZ40/ap+POntLDqXw++EMMdzo3hW6hYxyxeO/HrQXujeGxbTqbbUUtLXXbzRbgNDrlppzhd3zrN+1p/wAFaPEbf2l4d/Zo/ZS+HenSHzY/D3xC8f8Airxf4hjibJWGbVfBXiPTNHM4UqC4tUXeCWiUfIPU/gT+z/8AC/8AZy8DWPgL4X+HbfSNPhSGTVtWmWK48ReKtURNs2ueJ9XEUc+qancOzvucJa2Ubiz021srCKC1i9pr+h6EPC3hhfUOGvD3K+KY0b06vFHiJVzjG5tmk42U8Rh8gyfOcs4fyLB1XeWHwE8PnOYYam4RrZ5iqilN/lc5cZZw/rObcU4zJnP34ZPwvTwGHweDTty06uZY7AYzM8xrU01GpiPaYHC1ZXlDL6UWonylaf8ABTT9p/4Lst1+1/8AsV6vYeBIQG1b4s/s6+KbT4j6NokAKrNqGseCLmaTW9K0e2DefdajqPiC2eOJdttZXsxWNv1X+CXx3+Ev7RXgPTfiX8GfHOi+PPB2qExx6lpEziawvURJJ9K1vTLqK21TQtZtVlja60nWLOy1CBJIpJLZYponk+VSAQQQCDkEEZBB4IPqD6HivzP+MHg/xH+wh8RH/bc/Zk0ua08HxXliP2qvgNo2LXwp8QPAT3e2/wDHGh6RHix0Xxj4XNzLqP260hit4N9zq8oisW8WWniPKvwLwF4m/wDCXw/kOD8OuPcQnHII5XmOZ4jgnijMJaUMjx+E4gzDNMfw3mmZ1OTD5Xm2Fzepkjx1Wlg8dlWX4avPNMJpT4j4l4QtjMyzLEcVcNUmnmUsZhsJT4gyfCqyqZhh6+W4bB4fNcJhI3q4vB1sFHMPq8J1qGMxNWmsLW/o4orkfAHjjw18TPBHhP4h+DdTi1rwn438O6P4p8N6rACI9Q0XXbC31LTrkIwV4nktbmMyQyKksEm+GZEljdB11fyhXoV8LXr4XE0auHxOGrVcPiMPXpypVqFejOVOtRrUpqM6dWlUjKFSE4qUJxcZJNNH7VSq069KnWozhVo1qcKtKpTkpwqU6kVOE4Ti3GUJxalGUW1JNNNpjJJEiR5ZXWOONWeSR2CIiKCzO7MQqqqglmJAABJOK/OH4m/8FHPBdj4j1LwD+zv8P/Ev7SnjXSpTbareeEru30X4baHchzH5ep/EK9t7zT5GDAlJdPtLrSp9rwrrMc6OieVftmfFPxV8dvi1P+x58N9dvvDngbw1pdhrv7SfjLRZfL1Gay1eNbjRvhdpd4o2202s2Tx3WuYMguba4a0nWW10nW9J1Td8G+CvCvw+8PWHhXwbodh4f0HTYwltYWEIjVn2qJLm5lO6e9vbgqHur67kmu7qXMk80jktWRoczJ+1R/wUNvJPttl8HP2btFsSd40TWfEXi7VNaROvktquk+IbbSGm/h8xbfys8gYrqND/AOCjni7wDdwWv7VH7PPiT4a6HLNFA3xP+H2qRfEXwPatM+xbnW7LT4f7V0Gzzwirc6zqczECPTTXT1DcW9vdwT2t3BDdWtzFJBc21xEk0FxBMhjlhnhkVo5YpY2ZJI5FZHRirAgkUAfoh4O8aeE/iF4b0rxh4H8Q6T4q8L65bLd6VrmiXkV9p97AxKsY54WYLLDIrwXNvIEuLS5jltrmKK4ikjXpq/CHw/4ivf2Dfilpnj/wtLdJ+zB8S/Ello3xe8Bq0s2l/DfXdYljs9N+JHhe3/eDTbGOYxw6zYwIIpbWNdKjSdpvDiaF+7UM0VxDFcW8sc0E8aSwzROskUsUih45I5FJV43QhkdSVZSGUkEGgCSqGq6rpmhabfazreo2OkaRpdrPf6lqmp3UFjp2n2NrG01zeX17cvFb2trbwo8s9xPJHFFGrPI6qCav1+KH7QfjjVv2zPjZ4n+D+matfWH7MXwO1yPSfH50m6mtG+L/AMTtPlWa58OTX1u0cjeGPCdxGYLmCF/nvoDqKtJLf+H9Q0cA9u8Y/wDBSS28Q6vqHhr9lb4NeKfj9c6dcyWN947ub2PwJ8LrS6TcHW08RazavNrMkDLloPI0iK7hKzaZf3kTxyN8zTeOP2z5/j3p/wC05J8EP2dj8RdL+E2sfBW0i/4TLx+Lpfh3rvjLQ/Hmo6QYx4n/AOEYfU5fEXh3Sp01l9PNxFFDJbRuttPJEfpfRtF0jw7pdjomg6ZY6No+mwJa6fpmm2sNnY2dvH92K3trdEiiQEliFUbmLO2WYk6dAGb4P/4KSW/h3V7Dw3+1R8GvFPwDuNRuY7Gx8d2t9F47+F11dPhUW88RaPaxzaK0zHKwmDV47SINPqV7ZwpJIv6Z6Vquma5pthrOi6jY6vpGqWkF/pmqaZdwX2nahY3UazW15Y3trJLbXVrcROssFxBI8UsbK6OykGvzL1nRtI8RaXfaJr2mWOs6PqUD2uoaZqVrDe2N5byfehuLa4SSKVDgEBlO1grLhlBHiP7PvjnV/wBjH41+GPhBqeqX2ofsxfHHXZNI8BHVrqW6b4QfE7UJGmtfDsN9cGSRfC/iq5k8m3gmkAjvJ/7Tdo5dO1+/1oA/bGiio5ZooIpJ55EhhhR5ZppXWOKKKNSzySSMQqIigs7sQqqCzEAE0Ac74x8Z+FPh94b1bxh448Q6T4V8L6HbNeatrmt3kNjp9lACEUyTzMoaWaRkgtreMPcXdzJFbW0UtxLHG35na5/wUc8W+Pru4tP2Vv2evEnxK0SGaW3X4nfEDUo/h14Gu2hfY1zolpqEI1XXrTJwytc6NqcLArLpmCDXzz4i8RXn7ePxT1Px74nlun/Zf+GfiK80b4R+BGeWHSviRr+kSSWepfEfxNb/ALs6lYNL5kOjWVwnlxWrnS5I4Wi8SQ619T29vb2dvBaWkENra20UcFtbW8SQW9vBCgjihghiVY4ookVUjjjVURFCqAABQB5tH+1R/wAFDrOQ3l78HP2bdasR8/8AYujeIvF2l60y9fKXVdW8RXGkiXHy+Y1v5eecY5r174Z/8FHfBd74j03wF+0R8PfE37NXjTVZltdKvfFt1b618NtbuS/l+VpvxCsre00+Jy2Gkl1C0tdJtyyQtrMkzIr0K5fxl4K8LfEHw9f+FfGWiWOv6DqUZjubC/iEihtrCO5tpRtns723LF7W+tJIbu1lxJBNG4DUAfqskiSokkbrJHIqvHIjBkdHAZHRlJDKykMrAkEEEHFOr8if2Nfip4q+BHxat/2PPiTrt/4j8DeJtMv9c/Zt8Z61KZdRhs9JjNxrHwu1W8ZAtxNo9kklzoZLItvb26WkKx22r6JpOmfrtQAV458bvj58K/2ePB0vjb4reKLXw9pZc22mWQV7zXPEOo7dyaV4e0a3D3uq37gqXWCMW9nETd6jcWdlHLcx9r4+8b+Hvhr4J8V/EDxZeCw8NeDdA1TxHrV1gM8dhpVpLdzrBGSpnuplj8i0tkPmXN1JDbxBpJEU/iT8NNH8R/tF+NH/AGsfjlam61fXmkk+C/gK9Y3WifDDwD5zSaFc2dpKot5vEGqw7NTfVjCHkaZNWjEF1eRQaaAe2aj+2x+1z8U5DdfAv4BeEPhn4PuGzpvir9oLVdTk1vVLNl3R3q+DfC09pfaK0ilHiW4bXbOZCJILyZHzFlx/HL/gpBoTC/kl/Zc8cQowafQv7M8daLdzx5BeHT74XGnW0UzLlY5r+cxIcM8UoBU+uUUAaXwk/wCCiHhrVfFWmfDL9ozwDrH7OXxE1aUWui3fiDULfWfhp4qutyxiLQ/HdtDb2FvcTSMu2DUEXT4pJIbFdcur+aGCX9HQQwBBBBGQRyCD3Br8nfH3w/8ACPxO8Mah4Q8baNa61omoxkPDOgE9pcBWWHUNOugPOsNRtS5a2vLZkmiJZdzRvIj637Cfxg8XeDfG3iT9jf4s63deINU8H6Gniv4IeM9UkDX3i/4XrOLRtBvpnIe41jwjJiCBQZJX0+31KBFTTtCtJrgA8C+Et2/j74//ALYHxg1FhcX958bdX+FWjzSDc9p4X+Ftvb6Np8NsW5ghvrZ9PnuYkCiS4tI5ZAXBY/TVfMfwWtX8FfGr9sL4T6gn2fU9F/aB8R/EG0gkO2Sbwz8ToYNZ8P3EaEKZEGnWtq8siAopuoc48xN305QAUUUUAUdT02y1jTdQ0jU7aO803VbK607ULSZd0N1ZX0EltdW8qnho5oJZI3HdWIp//BM74j6TpP7Ouq/Dbxb4s0Syvvgz8XPiR8MLH+2tZ0+xvbnSNK1O31uzm8u8uYpXgik8QXNjbsqmKOGzS3jO2Dar7u7trC1ub68mjtrOzt5rq6uJWCRQW1vG0080jnhI4okZ3Y8KqkngV86fsQ/sIfsfftMfB/XPjx+0v+x9+zN8dfFvxO+K3xI8SeFfFXxw+AXwr+KPivTPAkmvNZ6d4esdc8deE9d1ax0G31+08S6paaRb3cenx3mrahfwQLNqNxLMAfsZcfEr4eW8E9xJ468HiOCGSaQr4l0ViEiRnYhReksQqnAAJJ4Ffif+xxLceKPh74q+MerDzPEnxv8Aib48+IGs3T/PPibxFf6Za6f5nU2tg9jeNaQjEcAu5VjVVO0fczf8Enf+CW4VjB/wTb/YJtJgp8q6tP2Pv2era7tpMHZPa3EXw7EkFxC2JIZoyHjkVXUhgDXwx+xeLjQvhPqnwv1UeT4k+DnxF+IHw88Q2jgpNDqFh4mv9SaRomw6RStqckcTEbXe3mCkmNwAD64ooooAK8/+K3g+08f/AA18deDb2JJYfEPhfWNPi3qGEN89nLJpt2gPHnWOox2t5AT92aCNu1egVxXxI8VWngf4f+NPF99IsVv4c8Ma1q7FiB5ktnp88ttbpnG6a6uVitoEHMk0saLywoA98/YP+N2geMf2Rvgbqvirxh4dtNfsvCLeFr+HVNe0y11AjwVq2peD7O4u4rq7juDPd2Gh2t28sq7pzOZiW8zcfaPjb8b/AAj4F+DvxT8Z6N4y8K3es+Ffh74x1/RrW18QaRc3NzrGleHtQvdLt4LeO7d5pZ7+G3iSNUYsXxtIr88P2Qv+CYv7DHjn9mr4QeNf2gf2G/2Rvi38WPF/hWPxR4j8ffFf9mr4NeP/AB5rdn4gvrzVvCya54q8XeC9W8Qaj/ZXhG70LR9Pjv7+Y6fplhZ6bbiG1tIYY/Vvih/wSi/4J42/w1+IM3wo/wCCf37FXgb4nR+CvFL/AA88Y+CP2VvgX4X8X+GfGqaHfP4Y1vw34i0PwJY6xous6drIs7mw1HTLy1vrW4jSS2nilCyLz4x1Y4TEujf2yw9Z0bb+19nL2dvPntY93heOXT4m4djm/J/ZMs9yiOae0/h/2c8ww6xvP/c+rOrzeVzj/wBjLwhB4P8A2bfheigvf+KNCTx3rN7IS9zqOp+M3bXjd3crEvPOtleWVmJZC0hgtIVY/LXt3xI+IPhP4S/Dzx38VPHmqRaH4H+Gvg7xN498Y6zMCYtJ8L+ENFvdf17UZFHLrZ6Xp91cFF+Z/L2KCxArxv8AY68WWvjD9mj4RXts4Mmj+E7LwhfQ9JbW+8G7vDU0M6H5opGTTIrlUYAmG4ikA2yKTxP/AAUW+DXjb9ob9g/9rv4I/DZDN8QPib+z78T/AAn4MsfPitBq/iTUvC2orpGgvdTskFtH4gvVi0SW4uHS3hi1B5J2WJXI+Py3kWV4D2OlP6jhfZta+77CnZ6bvq923e99T+m/EieYf6+8dTzGM5ZkuK+I3ioTupPERzXFqVNdFBNKFNR9yNNRULQSR+Hv7IH/AAUd/Y68d/HjRP2pv29/2w9B8HftC/FthD+zR+zFqmseOYfgX+yD8H/F8cd54E8P+MPEGj6S/wAF4/2kviB4WudI8WfE3xX8S/Etr4n8PnVrDwno+m+ErHR7iyf+o5XV1V0ZXR1DI6kMrKwyrKwyGVgQQQSCDkcV/LB4y/4KDf8ABNjxB/wSL1L9i3TIrS++POqfstyfs76N+wmvww8VSfH+y/acm8Bt4ZsvCk/wyfwsdctvGWk/F0r4huviA1s0X9sW0njWDW7vUZIp5/6Bf2KPh/8AEL4T/sc/sp/C74tXD3XxR+HP7OfwW8D/ABEmlvE1GU+NfCvw58OaJ4ljk1GKWaPUpINXsruB9RSaVb9ozdiR/O3H3cTCEVPljKEaVaNGjdp06tKSqSU6bSTbjyRlUnzVPaSrwnKalKz/AC/J8RNyjRlVw+JlWwyxeIq0VNVKWJcqcJUcS5VKic5JtUo8uH9nChOnGioQio1v20PCMPi39mz4m5Bj1Hwpo3/Ce6JfRkpc6bqngyVdcF5aSghoZ2sLa+szIhEggu5lQgtmvvH4M/G3wj44+Efww8Zaz4x8J2mseKfh/wCDvEGr2s+v6RbTW2qax4f0+/1G3lt5LtJIZIL2eeN4nRWjK7SoIxXwx+2R4rtvCP7NPxaup3Am1zwvdeDtPgGTLd3/AIxZPDkUFvGPnllWHUZ7lkQFhDbyyEFUbHWfDT/glD/wTum+HfgOT4p/8E+/2J/G3xLfwb4Zf4g+MPGf7KvwK8T+LfE/jV9Fsm8Ua74k8Ra34DvdY1vWtU1o3l5qWqaneXV/fXUstxdXEs0jueDKr/27jOT4XlWD+sW251isX9Wcv73K8VbZuPeyPqvEblfg3wo8V/Gh4k8UwyXn+P6rPhrhiXEEaN9fYRxKyCU0vcVapJq05zv6R+3r8bPD/hL9kj41ah4W8X+H73X9T8MweE7CDSdf0251AJ4z1jTPCmoXFtHaXclwJLTS9YvboSxLuh8nzQylQwwPhD4Js/hx8LvAPgaxhSCHwz4U0bTJQihfOv47KJ9UvJACQZ77UpLu9uGB+ae4kYcHFfPX7YH/AATL/Yb8Afs1/Frxx+z5+xD+yT8H/ir4Q8Nr4m0Hx98Jv2bPg78P/HOkadoep2GpeK4dK8U+D/Bmka/Yxan4Rttc03UIrO/iW9sLq4s7oS200sMn0l8MfF9n4++HXgfxrYTLNbeKPCuh60rIQdkt9p1vNc274ztmtblpraeM/NFPFJE+GQgZ42/+sNbn6ZPg/q9+iljMd9b5L93HB+0t2p36X6+EOWPgbl31Tep4q8U/27y3vz0eE+Df9WVXS05VCvxS8G5auUseo6KR8hf8FHv2XfiL+2F+zvpvwV+G/iyLwdc3/wAavgf4m8a6i/jXxl8Pbm/+FXhD4kaFrvxP8P6T4p8BWl14lsdb8QeC7TV9K0dbR9Pjn1C6t47jV9JiLX8H4hf8FCv+CZP7L/w/8W/sifssfsyal+0f4Y/aS/a/+O2maFYeJ5P2vP2nfFUvw0+AHwsjg8e/tF/FJdA8UfFfV/Dl9caR4OtrXwvo9trmnzWt1q3i2FrJl1Kzt2T+rOvxC/YDmP7Z/wC3b+2N/wAFHL8/2j8Lvh5eXX7BP7Gk7/vLC7+H/wALdcXWf2gPinop/eWd9afEr4vsml+H/EdmsF6/h7wpdaLcySwRAV34apKEvicadKU8XO2jm4qjSp02+sJ1lQjKDv7k60lo5Hx+aYPDYicFOnGpicb7LBQc4xkqFCnKtWxFammm6dRUJ1lGqv8Al88NF7RP26jQRoka52xqqLklm2qoUZY5LHA5J5Peviv9uhZvDfw08HfGjSh5PiX4GfFTwH470i8jwswhfX7HR77Tmk4P2PUJr7T2u4eUn+yRJIDHuB+16+KP28ZJda+DmjfCvTR53iL40fE34efD7QLJAXmnu5/EtjrDSiNfmMML6TbxSy42xvdQqxBlTPh5228qzB/8vPq05UXrf6yrPDOPXn+sqlyW1c7JLofr/hEreJXBNNqP1KWfYKjmsZ/wf9X6jdLiGOIeywryGWYLFOXurDe1cvdufrPbfEn4ez28MyeOfB4SaKOVA3iXRVbZIgdcqb0EHDdCAR35r8/v+Ck3xB0nxB8CvDHwr8JeK9Hv7741/GT4bfDK/XQ9asL28g0fU9Tn1i6mZLO5lkWCW60OxsZiwEckd20D5SVkbt0/4JO/8Etiqmb/AIJtfsEXUxAMtzdfse/s8z3NxJj557ieT4dtJNPM2ZJpZGZ5JGZ3JYmvkP8AbR/Ya/ZC/Zc+GfhL4+/sz/sifs1fAbxR8MPjB8M/Evi3xR8D/gH8Lvhf4k1XwNDrogu9C1PWPAXhXQtVv9Ek8ST+GtRm0y6upbBrzT7O7eDz7WCWL3+InNZDmdrr/Y6ntXG9/YNJYnz0oOq290j8S8B1hn4z+HalySa4qwMssVZR5Z5vGc5cPxkpe7zTzlZfFKXuubSleLaPujS9MsdF0zTtG0u2istM0mws9M06zgXbDaWNhbx2tpbRL/DHBbxRxIvZVA7V+SP/AAWjf4w/8Mz/AAth8CeKviv4E+Ct1+098Hrb9tzxv8DZdctvin4R/Y1ll11fi54g8P3vhS0v/F+naVp11/wjU/jPUvClje6tp/g4a3dXNpc+H49chf8AXSzu7a/tLW/sp4rqzvbeC7tLmFxJDcW1zEs0E8Uikq8U0TpJG6khkYEHBr8RP+C2s11o/hv9jDxn8UdA8UeLv2F/BH7Vvh/X/wBurwz4b0TXPFOmXHwvi8Na0ngnXPih4S8O297qPi34M+F/iCdL1fx/4dn07WNJ1Ex6It/oupyR2kFc1BJ1cOlyKLrUEuZfuuX2kFaSVk4WdrXSa6rde9nE6v1PMJVnX9s6Vf2snKSrqpLm9pOc5XmpKbc60neSSm3dnwP4L8H/ALGHgv8Aa/8A2HT/AMETfjj4s8e+NtZ+Oujyftj+CPhp+0V8Xv2gfgrc/sg3HhzxDN8TPHHx3Hjzxr4/8J+D/F1lqkHh3T/hp9u1Pw9rupeLdXeHSdIv9XtbSXT/AOrsf5xX8r/7Svx4/YK/aD+NX7Bfhn/gk0/wq8W/th6F+1d8H/Ed34w/ZX+Hy+Ho/h3+y5pt9cj48x/G3xd4P8O6FpFl8JNU8JSR6XrHgHxVqMr6zey2aafoT3lsWH9UFdFdt0qN1UX7ysl7bWrZKi9HZfuNbU01pVjiEtLKPnZPyRq42FKWGnBfVZc2B0wXNKnNSjCPNO2IXKpV+WTTpzwzdpSbl+cv7efxe0L9kbVfgv8Ats6vpmvalpXwQ1fxhF4803wlBp9x4n8SfDy68F69r3iDRNIttV1LR9Mv9XGkaHry+HrTVNX0zTjquoKbnULBGN3D+b3/ABGp/wDBMEcf8KE/bn444+HfwJ/+iLr9FP8Agon8IIv2stN+En7FsGvXnhy7/aA1/wAX2Gq+INLsYtU1Lwn4UtvAniDQtf8AFFvps8sFvcz6VpfibUNRsbe6ngt7yfTJIXlWNZXX8W/+IIH9nY8/8N4/Gnnn/kkngbv/ANzJXNkD/wBsz1R/hfW8I32+svL8P7b/ALe9isLzLzTtds9fxp5Hwr4OTxH/ACMv9WuJ6cHL+K+H6fGeb/2S3f3vYrM5cRQoX2UJxj7kYpffHwT/AOC1P7NH/Barxt4D+D/7PHw8+O3gzw58Nvil4R8XfFCL40eH/AegW/iO0Gj+LtU0PSdITwT8SPHj39v5HhrxBJrUWprpccJfSZLNr2Vpfsf7y3EyWtvPcukzpbwyzOltbzXVw6RI0jJBbW6SXFxMwUiKCCOSaaQrHEjuyqf50/2SP+CIngT/AIIi/EzwV8T/AAV8fPGfxn8N/GL4neEfBPiybxl4Q0PwrF4PnTQPG2k6Pe202janfrcW+o2/irWjfvd+Str/AGbbNEz+c4H72fGHX/G3hT4S/FHxR8NfDcfjL4i+G/h1431/wD4Ql83yvFfjXR/DWp6j4V8NSeRJFN5eu67bWOmP5MsUu26IjkRyrj+oKs4UvD3w8nh1/ssco4ir4lwTlfOf9a84jjbw0viP7KpZCmt3QWFT0cb/AI8lfAZVGPwShiea7svbfXKqnd9H7L2Hny8vdH5OePP+Cqv7Qfwp8BX37S/xT/4Jl/Hn4efsWaNNZX/if4teJ/ih8M7L49eDvAt9rVvoq/EbxZ+yYA/jHRfDtm11Bqmr6RL4zfxxo+htJqmpeE7eG2uFi/ZrStU0/W9M07WtIvINQ0rV7Cz1TTL+1cS2t9p9/bx3dleW0q/LLBc200U0Mi5V43Vhwa/iO+Mnxd0b9rT/AIJh/FHxL4x/4Ky/tSfGz9uD4i/s2eONe+IP7BHwsb4K+GNF8O+ONJ8MX+u/EX4U+Lv2cPDXwFuPir4d8BfC6PT9b0zxV4o1vxbop1bS9Ak1e218XWq6ba3P9Lnwg+K/xY+N37Kn7IOvfsM+LvgPrXg7xf4B0/TfGPx48f2HiH4meDfBVp8PfDMfhbUdL0D4YeD/ABx8LNa+IHifUPiHo+o+EbsH4leEdL8Jf2Hrl9qEmrXK2GlXXymCxtSU8RGUp4iMKeDqU2nh51JOvPEQqa0HGjywdOk3r+7U5OpNxlTZwRneUVfScKkrPlvFw9loox96Lam7xnzS01aakfpJX5Zftw/tjfD3/gmR8R9K/bY+JHh7xz4j+G0nwx1vwj8TPDvwy0/QNT8ZazbWniXwxYaFqGmad4l8ReE9Eu7qw1jxN4fa+kvtfsJIdA0y7+ym6uVisLr6O/Ys+Pnjj4/fDn4gXnxJ0rwpa+OfhH8fPjN+z94l8Q/D+HVrX4d+P9T+D/i648Mz+OfA+na7qWuavomk6uUFpqfhvUPEPiS48LeK9N8R+Gn8R64NJGpXPyj/AMFGP2M9J/4KceJND/Yd1Dx5rXw40XVfhr4i8XeNvHPhzRrPxBq3hjSG8U+E77Tlh0zULmzsJZtW1Twlp+kSrdXMRgs9a+1oHbyY5fu+FZ0q1PiOdVv+zq/AHGtTGcyag6L4Yx9fLnNNaSWcxymWHUldYtYdW57I9DBu/wBcUk1BYLMIVk7aOnRqxSbTa93Exp2abi5qLTeh8M/8Rqf/AATB7fAP9ufPb/i3fwJ/+iLrsP2ev+ClnwX/AOC0/wC2b8Gvix8GfB/xS8JfB/8AZh+GvxM1ux8O/GXRvCeka9ffFLVNV8M6Df65b6d4Q8ZeOdIk0y00vxB4Un0e+uNVhv4dX0W/YWNukdrcXfx//wAQQH7O3/R+Pxp/8NJ4G/8Amjr6P/Yu/wCCY/hr/gir+2L8NvgXofxW8SfFzwL+0r8KPic3hzxr4v8AD+l+Fby38eaPrPhjXdZ8LR2mlX19YzQ22i+FdHu7SZp0urm78R/ZfJBit/O876PXIuKuLJ0v+RtT8LvEGeSW/irEPIqkM2lQ6qrDhWfEMrx96NJVJRaaTPxPxQv/AGJk0an+5z4w4Yjj739m6X9pU5YNVejhLN45bG0vdc3BO6dj9/K/nx/4KV6R4D8Sft6fBnw//wAFAPib49+GX/BMq6/Zr1uTw3NpvxI8e/CD4K+Lv2w/+FjTx3Xhj46/EP4eat4du9KkT4Sta6z8ObHxT4l8P6PqV/p2vRaHqM18uu6VqX9B1fzu/tV/ED4EfBf/AIK1P4+/4KTWejr+y/rf7LvhLQP2NvHPxc8J3fjD9nnwL8XLfxZrFz8aNKvFutJ1rwd4Q+MfiHTl0e7tPFeu2NjqU3gu1tNFttejhuLXTp1nPL7LCQm6Uac8bTjOWJ/3OMY0a87YtXipUpyhGnSi5RTxU8Pd2um8v5ufESiqkpRw0nFULfWG3WoQ/cN3cZxUnKo4pyWGjXtrY6H/AIJhaX4U8P8A7bn7Q+g/sL/En4g/E/8A4Jf2fwD8EvZ6j4g+IXjv4r/CXwt+19/wneowa14R/Z9+IXxE1HXb/X/D9t8LIbfVviCvhjxJ4j0bTvE2qaVZarqUV3FpOn2f9ANfzzfsaeOfgn8Yv+CsPjT4i/8ABOfT9Oj/AGPbD9lG/wDDv7UvjL4XeE77wb+zt8QP2jz8QtNuvhrH4etIdM0Twp4s+LXh/wAF/wBrHXfGnhzTror4VuG0bUdbnmMdtX9DNaZM19RilZxhXxcYyg26MorFVWnhm7v6sk+WhG75KcYwUpKKk4zBP6zK6acqWHbjJWqpvD0k1WS/5ft+9Vejc25csW+VfFX7I3i/w38Af+Ckn7Wvw21fxFoHhDwN8bvhH4B/aCtU17VtO0PSbfxjo+sJ4L157KfUbm2tjqPiS91nV9Y1BEb7RdtbLIyvHZhl/Y3/AIXf8F/+ivfC/wD8L/wp/wDLavw7+C3wG+Cn7ZP/AAUk/ab1L4z/AAa+Ffx2+F3wC+Cnw4+FMeifFv4e+EPiZ4RtviT4j1iTxgmp6Zo3jLSNb0qDxFoNhF4r0CbUbe1TUdOivdSsTLHBqMqT/pj/AMOxP+Ca/wD0j0/Yc/8AETPgJ/8AMBWP0huX/XbJJ1P+RpU8NfDSedX/AIjxr4NymODnX2bxFTIo5PUruf7yVScpVLzcm78Lbrh7MIwv9TjxZxZHL9PcWG/tzGOtGl09lHMHjowt7qUbR91I/OvTte0n48f8FS/2nviPBq2meJvD/wCzv8JfhJ8Hvh3f6de22q6VEfH+lT+N/Emp6XdWks9p9rj1QeItGnu4JC7211PaM5RSi/d9fnf8L/hr4B/Za/4KSftYfAnwD4D8HfCr4ffFL4XfBn4v/CbwT4F8M6L4J8HafonhfTbnwn4rtPDfhrw9YaZodikvjHVfEGoTW2mWUIaSHUL2RHka5mr9EK/U+OVGL4Ghhv8AkVQ8KPC15Tb+H7KpwPktbNXC2inLiapnssYl/wAzB4y/v8x8Zw42/wDWKVW/1yXGnGH17mvzqpDiDHU8GpX1ssphlyo9Pq3seX3eVn8+ml/BjwR/wUy/4KF/8FBPhx+114n+JHiL4X/sa658Dfhx8GP2ZvDPxa+I3wn8IWFh47+GcPjzWfjX4vsfhf4q8H674w8SeLdcuLmz8KaxqWpfYdH0CwfS1tr0ray2ntn/AATT8W6l8Nf2sv8Agop+wDpfxM8afFj4Pfsna5+zx4r+DOq/ELxbqXxC8Z/DvRfjz8PdZ8QeJ/gvq3jrWbm81rXNG8Ca/wCHd/gyLXb3UNa0nR9WuNEv7+4bS0Caf/BTD9nH/gnloc8H7ZP7St58Tfhf8XbLS7H4a+HvFX7NvxU+I/ws+O/x3luJd/hn4IaBonwv8QaNq/xW8Ra9eLDYaHpS2lxrFhZorTa3o3hrTLm5sd7/AIJH/sb65+zZ8NPiz8YfiN8PrP4T/F79rLx3p3xD1z4TWmpXeuzfBr4Y+FtIfw78FvhDr3iW/ur3UfF/jnwz4ZuNR8QfEvxlqt1caz4m+JPjHxbqOs3Woam1zqd9+RYShWpZlSpqFF1aU8XXxuLpTlKriaFdVfq1PErkioTdSpRq06bnU5Vhpqj7OjZS+6xFWnUwc581RRqLDU8LQqQioUatF0XXnQam3KHs4VqU6ijBSliIOopVbtfrdXxn/wAE0fij8O/2e/iV+3X+zd42+IHgfwB4V8C/HnSviH8ObHxh4r0HwvBDo/xi8Oza3daFoK63qFkJ9P0GLRdKL29p5i2supedMEkvcv8AZlfA37A/7OfwC/a0+Nn7evx6+NHwL+Dnxu8KX3x00D4X/DS9+K/wz8E/Ei209vhR4XfRPFWo+FW8YaLrS6dZ+IIr/wAMSXdzpfkR6mun2S3BlbT4lg/Sfdl4S+M8cXb6lHJeDK2D5vgXEsfEHh2llzp30+s/6v1+LY07e/8AVnjOX3faHyOq434BdD/eHj8/p1+X4v7JfDWZzxXP/wBOVmVPJXK+ntvYfacT9kv+Gmv2bv8Ao4L4If8Ah1/Af/y/r8Xf2S9VsvjJ+0r+3z+0w17aa4+v/tBX/wAE/B2s208N9aj4ffB7TrLTNHk0W8geSA6X4gsLrQ9TkNrI0F7JaW14S7ne36lf8O6/+Cff/Riv7HH/AIjF8E//AJiK/Kz9i3w/pHwX+N37eX7Mtjo+m+FofAX7S2sfEfwj4Z0ywtdG03T/AIa/FbSbC+8EWmh6RZxW1naaPpPh/R9KtILbTraGxsILixt4YoIngjr5PwQ5Vwp4zzw//IzXDHC1Oo4/xY8O1ON8l/tZxt7ypSzaPDUK7VouM4xn7srP2/ETmedcAxq3+qf2vnM4p/A80hw/jvqN+nOsHLNpU79U2veSPhf/AIK8/An9qT4ufCT9sf4p+OvjFd/Cj9lr9mT9mj4l/Eb4A/DL4H+NPFPhzx78ZPjVo3wn1jWoviN8fPFemwaDeaZ4S+G3iIyW3gj4VeHdQ1DSvEeqWUfijxfqU9tBa6Fcfoh8G/i0fhT/AMEzvhV8dvEj3Wun4b/sLeBvi1r0l9dzz3ust4P+AOl+MdUe8vpmluJrrUTp07XF3M8k0k0zzSM7sSfin/gsh/wUD/Y2+GP7K37av7KHj349+EPDX7RHi/8AZW+KWjeG/hZfW/iBvEGrap4++G+t2/g6ytpbbRp9JE2vTXdsln52oxIplU3DQjJE/wCxx+1B+yJ+3v8AsFWH7EPwV+Png/xr8XJv+CfWk/Df4h+E9Lg8QRaj4Kj1P4M6F8JPEF7qsl9o1naNFofibxHaabd/Yrq6czupgWWMGQeCqtCljc3hhMVCpiquCpumvrFOrWnjYVMybpKPM7To2pU/YqK9nTjTi4rr6vJUnhsuliKU4YeGMnGb9lKFOOGlHAKMm+X4ardV+0k3zzlNqV2fI/7Ov7CnwO/aq/Z3+Cnxs/aM/au+Jlv/AMFQP2wPgs/7Tnwx+Iuj/tU+PPAfxE+HbeMtFHjnwta/Az4HaN4/0jw43wx+FOl6hoel6ppdv4I1uwihsdUjm1PTreazj079XP8AgmT+0Brf7cP/AATm/Z9+MHxct7LWfFHxK+HGv+DfimBbQQ2PiXxH4L8R+JvhP431OSyto4bS3i8V6j4W1HV5rG0hhs7Uao9rawxQRxxr+Nf7Nf7aH/BOD4C/Ar9m7xX+1b4UsfCH/BUH/gnz+z6P2RdK+DuteGvGsn7Q/wDwkvg/wxf/AA4sPCHwz8N6baTaV42034t2lz9r8K+KdMh1jQ7PTvHl+517SrSfWJB+vv8AwSX+A3i39kX/AIJrfs0fCn4u2q+GPGnhXwF4j8dfELS79vJbwjq3xH8ZeLPi3rWg6sZDst7zwmPF76Nq67migvNMulWWWNBK+2SSUMdSeXSgksPGcpYOpUnNYlVsP/Z9SpJWlHMJr626tr1uaNNzk2o2yzJSeGl9cUrus42xMIwSo+yqrGKCV4vBqX1VUv8Al2lKooRScme4/wDBKL9pj4RfCr9mnxL8BvjN8c/hb4H8Qfs+/Hj4wfCTQ7H4ifEfwj4T1zUfCei+II9Y07U4bHxBrNheXGmpqGvatpNndQxNaIultYwPiyMcf6Yv+2T+yIiO/wDw1N+zq+xWbZF8bPhrLK+0E7Y408TM8kjYwiKCzsQqgkgV+W//AASp/Zd+A/xw/Z8+IH7QHxp/Z8+D3xJ1f48ftHfGn4l+E9a+J3ws8EeNNes/BV/r1to1lpltqPijQtU1C00xNe0TxFeQWMU62gnvLi8ij33cksv6XS/sKfsSvFIg/Y9/ZchLxuolg/Z/+E0U8RZSBJDKvhENHKhO6ORSGRwGHIrz/pAxox8avEtUVTjU/wBa8ylmEaXLyRzqU4yz+KUfdTjnbzCMox0jJOKStY6fDGVWXh/wk6jk4/2LhVhnO7k8Ak1lrblq08vWGab3TTPzD/Y6nuPFfgLxh8ZtWBk8SfHD4oePPH2sXUh3ziN/EN9plnpwk/59NOks737HCMR24upUiVY9qj64r5F/YvS48P8Awq1n4V6r+68R/Br4kfED4e+ILRwUmivrLxLfam0xibDrDPJqc6QuRtdreZVJMbY+uq/Hj7sKKKKAOC+Kfg+z8f8Aw48b+DL6JZYfEXhnV9Oj3qG8m9ls5W067QHgTWOoJa3lux+7PBG3auk/Yz/bt/Zotv2YPg1pfxf/AGm/gH4D+Ifh/wAJReF9e8M+PfjN8O/Cviuyj8LX974e0W51bRfEHiOw1e3k1XQNM0vVoZru1Rr22vob1GljuEkfG+Inim08EeA/GPi++kWK28N+Gta1hy5A3vY2E88ECZ+9NczrFbwRj5pJpY41BZgD037C/wCyB8C5P2TvgrqXxP8AgH8HfF/jXxD4YuPFWp6/4x+F3gnxD4hvbPxVreq+IfD632ra1od5qVwLXw5qWk2tulxcP9ntoYreMJFEkaAHqvxQ/wCCgn7IuifDX4g6x4H/AGrf2avFPjTS/BPirUPCHhrw98c/hdrmu6/4ns9DvrjQdG0jR9O8UXV/qeo6lqsdpZ2djZ209xczzJDFE7sFPxL+yP4Xj8L/ALPnw5zul1DxPo48cazfSs0l1qWpeMJG1w3d3MxZ5p1sruytPNcl2htYgxLAk/d/xl/Yr/Zz174RfFHRPBP7OXwL0Pxlq3w98Zaf4S1nQvhF4A0vWdK8TXfh7UIdBv8AS9SsPD0F9Y31pqj2s1tc2k8NzDKivDLHIFYfC/7Jvii28V/s8fCu7gYebpHhiz8J30J4ltb3wju8OywTxn5opCmnRXCqwBMM8UgGyRSQD6KooooAK+cP2tvC0Pin9nz4kKd0V94a0WTxvpF7ESlzp2peD2GurdWkqkPDO1pZ3loZUIdYbqYKQTkfR9fPH7WHie28K/s8/FS7uG/eav4WvfCllCOZbq+8XBfDkEEEYBaSQDUpJ2VASIYZZCNqMQAfV/w2/wCCmH7Dl/8ADvwFffEP9tX9knwh4+vPBnhi68b+FPE/7Rvwc8O+I/Dfi240Syl8R6Frmg6p4xs9S0fVdK1d7yyvtNvrS3u7O4hkgnhjkRlHkf7X/wDwUV/ZD1n9mj4xaD8EP2vP2aPiX8TvEvhGfwv4b8HfDP4+/Czxn411FPE15Z6Drl3ovh/wv4s1LW7qTRfDuo6trdzPZWjtYWenT38rwxWzzJ9VfBP9lD4K+G/g38KfD/i74I/CfU/Fmi/DnwXpfijUdW+HHg+/1O+8RWXhzTrfW7q/vbvRpbq6u59TjupJ57mWSeWRi0sjuWY+J/t5fsvfCi6/ZH+Nlx8PvhB8NPDfizQfDNr4s0/WPDPgHwvo+tW1p4R1zSfEuupaX+laTbX0X2nw/peqWsqwTL50MzxSB43dGAPNvhV4OtPh98NvA3guyhSGLw74Y0jTpQihfNvo7ON9Tu3A486+1GS6vZyPvTzyNgZrv64v4c+K7Txz4B8GeMLGVJbfxL4Z0bWAyEEJLfWEE1zA2Puy21y01vOh+aOaKSNsMpFdpQAUUUUAfIv7ZE0/hX4feE/jJpWYvEnwQ+J3gPx7o11Gds21PENhpl1p5k/589QkvbI3cJzHOLWJJVaMMp+8R/wVZ/4JegASf8FIP2DIJBxJBc/tffs+QXELjh4p4JfiGksM0bZSWKRFkjcMjqrAgfB37aSz6/8ACfSPhbpY87xJ8ZPiP8Pvh74ds0VpJp9QvfE1hqiyLEmXMUT6XFHK4G1XuIUJBkXP7MW3wR+DdtbW9uvwo+G7LbwRQq0ngbwu8jLFGqBpHOlZZyFyzHlmye9AH5I/tw/t0/si/tK/CHw/8Bv2af2uf2avjr4t+KPxZ+G3hnxT4X+CPx7+F3xP8UaV4Gl10Xl9r+oaL4E8V65qtjocXiCz8N6Vc6pdWsenLd6tZWM0/nX1vDL9EWdpbafaWthZQR21nZW8FpaW0KBIbe2tolhggiRcKkcUSJGigAKqgDgVk/8ABSf4R+E/C/7P+h/FPwJ4B8LaHqfwZ+L/AMNviTqU3hnwvo+lahdaFp2qT6NeW0k2m2ME8lpHda5YahcI7NDGlj9olULCXXS07ULPVtPsdV064ju9P1OztdQsLuE7orqyvIEubW4ibjMc0EiSIccqwNAFyiiigAr5i+Mt43gf45/sdfFmwZrbUtK+Pvh/4b31xESkk/hj4nwz6Pr1tLgr5yLp1teiGORtqNdTYwJXz9O18yfFqzbx9+0F+x38IdPQ3V/d/G/SPitq0EfLWvhj4WwXGsajPc45hivLSTUYbeRsCWW1ljQmQBSAe8/t1/CTxb4D8d+Hv2y/hXol34hufC+gnwj8d/Bulxb7/wATfDSOZbm38T2MKAG41bwi+Zbp28yQ6ba6ZNI8OlaNqAlo+BPHvhP4leGdO8X+C9Ztdb0LU4g8NzbuPMt5tqmaxv7c4msdQtWYR3VlcpHPA/DptKs36vkBgVYBlIIIIyCD1BB4IPcGvzb+K/8AwTu0S58Uap8Sf2Z/iFqn7OvjzV5Gu9c0fStPg1v4WeKbsF3EmqeCJ3itNNuJpHKtdad5tha75bmDQWvZZp5ACpRXyD8c7j9uj9mLwnpHin4haT+zx4y8O6z8Uvgt8HNJ8QeG7zxnBe3Hi/4+fF7wV8Efh4dS0q8bSPJs7jxx4/8ADsWt3VpbrBpOnSXl8ouY7XbJ7lpv7F/7YnxVdLX42/HTwP8ACfwfcYGp+GvgHpurXfiTVLRiolsZPFviaK3n0GWSMyK1xYXGt2rKdk9jcI5WMA8Y+J+teIv2hfGcf7JnwOuTea/4jKRfGPxxZKbrRPhd8P8Az0j19NQu4m+zvrupwFtMj0vzlkcznS2MN7fJLZftp4A8D+Hfhn4J8KfD7wlZiw8N+DdB0zw7o1rlWkSx0q0itIZLiRUTz7ucRm4vbllEl1dyzXMuZZXJ4f4G/s//AAq/Z08HR+CvhT4Yt9B053S51bUZXa91/wASakqbG1XxFrU4N5ql6+X8sSMlnZRu1tptpZWYjtk9noAK/G/9rbwHrf7MPxx1L9qXw1pF9qvwU+K8ek6T8fdL0m1kurjwX4psgtjonxJis7ddzabfRyJa6w6RsRqE2oSXDz3+t6YkX7IVU1DT7HVrG80vVLK01LTdRtbix1DT7+2hvLK+srqJ4Lq0u7W4SSC5triCR4Z4Jo3ilido5EZGIIB+Ymg69ovijSNP1/w7qljrWi6rbpd6dqenXEd1Z3dvJ92SGaJmU4IKOpIeKRXjkVJEZRrVjeOP+CdGp+Etb1PxZ+yJ8Wrz4Ly6rdPf6n8LfElk/iz4TajeSsplbT7Kfz9Q8Kedg+ZJZ2+sNDHstNLTSrOOOFPNH+Ef/BSXT2Ng/hH9mHXZEPlprtl4l8Z2lhIB0nlsrx7O/bPVljtrfJyFiTpQB7GSACSQAASSeAAOSSTwAB1NfJlxpd7+238VNP8AgN4Alnuvgj4M1zTNc/aE+Ilgzf2PqFvpd2l7p/w38P6nGfIvtR1a7tlNxPbNKLZ4BqMJlt9Huorz3HSv2DP2ivi1IkX7Tfx70fQfBcpU6j8MvgBYX2mW+tQNuMljqvjbxDaQautlIu2G909rDWLa5jLCCe2lRLpv00+GXws+H/wb8H6Z4C+GfhfTPCXhXSFItdM02Jh5kzhBPfahdzNLe6pqd2UVrzU9RuLq/u3VWuLiQquADtrOztdPs7WwsbeG0srG2gs7O0tokgt7a1tolht7eCGMLHDDDEiRxRRqqRoqooCgCrBGQQehpaKAPxh8dabcfsNfHnxNf6nbXEf7LP7QPiiTxDp+vW8Dyad8JPinqnOraXqwhXZYeHvEDIbizm8tILeyitobdduhanJP9m2d7Z6jaW1/p91b31jeQRXVneWc0dza3VtOiyw3FvcQs8M0M0bLJFLG7JIjBkYqQa+rvFvhHwz478Oat4S8YaFpfiXw1rto9jq+iazZw3unX9tJhvLnt5kdCUkVJoZVAlgnjjngeOaOORfzS1X9g34ufCO7ubz9kT46f8I34YmuJblPg38YLa98WeBrJ5neV4dC8RQRX3iDQrLe3+ohsLjUJ2JkvNbuWAB+Qr5djcsqVHgsPPH5bVqTqxw1GdOGLwE6snOrCjCtOnTxOEc5OcIKrCth03TpwrU1TjT/AKiyjjnhLxEwGX0+Lc9ocHce5fgsJllfPs1w+OxHC/GOFy+hTweX4vNMTleFx2YZFxNTwlGhhMZjKuAxWUZ17GGY47F5XjpYutjPcB4e0Aa03iQaHo48RPZjT218aZZDWmsA/mCxbVBB9uNmHAcWxn8kP82zPNX729s9NtLnUNRu7awsLKCW6vL28njtrS0toEaWe4ubiZkigghjVpJZZXWONFZ3YKCa+ZT4U/4KXHNiPAv7Lwn/ANX/AG7/AMJF4zOljkKZ/sA1A6ljGZAvlFjjHlZ+St3Sv2C/iz8Wry1vf2vPjn/wlPhiC4hum+Dfwhtrzwn4EvHheOVIdc8QSxWOv67ZeYpxDNYWuoQECW01qAkouMa+Or2hhcox8qj0TxdOOBw9Ju13Vq1pc7hHdrDUcRN2tGLeq9SeScGZOnjOJPE/gmhl0P3kqPC2OqcY59joqz9jl2WZTRWEhiqi0pvPc0yPCQaft8VTaUZeXeAtNuv25fjz4a1fTrW5b9lf9n7xMniCbXLm2eKw+LfxV0vJ0mx0pbhAt74d8PMwnvJjG8M9rNc21wpXXrB7X9n65zwp4S8NeBvD2leE/CGh6Z4c8NaFaR2Oj6LpFnDZafYWse4iKC3hVUXc7NJLId0s8zyTzPJNI7t0dfQ5Vlv9n0qsqtRYjG4uoq2MxEYuEJTUIwp0aMG26eHw8F7OjBtt+/Vm3Vq1JS/EfErj2HG2Y5dQyvAVMm4T4awUsq4WyatXhicTQwtSvPFY3M81xNOnSp4vPc7xlSeNzTE06VOjD/ZsvwkIYDL8HThUv7Kz1OxvNO1G1hvbC/tbiyvrO5jWa3urO6heC5tp4pAUlhnhkeKWNwVdHZWBBIr8V/CE91+xN8UL79nT4lXE9n8F/F+t6nrv7O3xI1ORho1naapdvd6h8N/EGqSkW9lqWlXtw3kT3LRCee4a9laK11iwjtf2zrzv4ofCn4f/ABm8H6l4D+JfhjTfFfhfVFUz6dqEbBoLiMOINQ069geK90rU7XzHNpqWnXFte2xd/KnUO4bPNstnjVQxGGqQo4/Buo8PUqJujUp1VFV8LiFH3vY1uSD54Jzo1adKtGM+R059fhnx/hOEp5vkfEeCxWa8FcURwcM8wWBnSp5nl+Oy6Vd5TxLkcsQ1h/7Xyj63jaSw2JlDC5nluPzDLMRVw31qljcJ89AhgCCGVgCCOQQRkEHoQR+dIqqihUVUUdFVQqjJycAADk8/Wvm66/Yt/ab+DDNB+zN8fdH8S+B4S39mfDH4/wBhfapDolsu0x2OleM9AtJ9Wa0iQGCzsI7PRbS2j2CWWaV2ulzx4P8A+CluoH7Angz9l/QJXIjk1288QeNL2yi3DHnw2Npc314u3qqy2lzzgNE4yK8J4jGUvcxOUZlCrs1h6McZRk+jpV6E5RcNXZ11Qkl8cYt2P2SGQcKZjFYzIvFLw/xeWy96NTO80xHCmbYaDSbhjslzvCUcQsTT+GrTymtnOFlJP6rjMVDlqP6I8R+JNA8IaJqXiTxRq9hoOg6RbSXmpatqdzHa2VnbxjmSWaUhcsxWOKNd0k0rxwwpJLIiN83/ALMPhXXP2qvjvYftT+JtIvtJ+Cfwpi1XRf2e9G1i1a3uPF/iG+zZ698TJ7OdSVsYI0NtpRdQPtsOnNA0V7oOom47rwl/wT817xzrmmeLf2vvi9ffGmXSrmPUNL+F3h2zfwn8JdMvY2Yxte6dbC3vPFHkZCxzXVtpEk0W+01RdUtZJIn/AEt0/T7HSbG00zTLO10/TtPtoLOwsLG3itLOys7WJILa0tLWBEhtra3hjSGCCFEiiiRY0VVUAdWFy3GY+vQxGYUPqWCw1WFejgZzp1MTisRSalQrYt0pVKVGjRnarTw8KlWdStGnOrKnGn7Gfz3EnHnCvBWTZvknBGcR4r4sz/L8VkuacX4PCY7A5Bw/kmPpSw2b5dwxHNMPgs0zPNM4wk62WZhnmKy/LsLhMqxGMwmV0MbPHf2lh7lcZ8RPAvh34neBfFnw98WWhvfDnjLQdS8PaxApCS/Y9TtpLZ5raVlfyLy1Mi3VlchS9tdww3EeJI1I7OivqZwhUhKnUip05xlCcJJOM4STjKMk7pqUW000007M/nHCYvE4DFYbHYKvVwuMweIo4vCYqhOVOvhsTh6ka1CvRqRalTq0asIVKc4tShOKkmmj8Wfgb41174DeKj+yH8d7z7B4o8LZt/g542vlNpovxS+H3mtH4ei067mYwLrmmWyrpv8AZfnGZVt10tfPv9Ple6+3SAwIIBBGCCMgg+o6EV678cv2e/hX+0V4Tbwf8UvDUGs2UMj3Ojanbu1h4h8N6i6Ko1Pw/rMA+1addqUjMiAy2V6sSQajaXlsDAfgy5/ZU/bU+EGbP4LfHXwN8XvBttxpnhr4+6Zqtv4l0y1BKx2MXizw5HNc65JHHsVLi/vNHtY1ULBYW8abJPjpYLH5T+4hhq+ZZfDTDVsM4TxmGoqyhh8VQqzpyxCpL3KeIw8qlWpCK9rRU1KrP+qaXFXA/iZ/wr4rP8p4A43xf7ziDKs9pYvC8J55mUknis64fzjAYTGYfJamZ1XPGY7Is6oYDL8Dialb+y81rYWpRwGE980Xwz4b8NreJ4d8P6HoC6hdPe366LpNhpS315JxJd3gsbeAXNy/G+ebfK2Buc4rC+IvxH8G/CrwpqfjTx1rdpoWg6XEzyT3Djz7ufazQ6fptqCZ9Q1K6KlLSxtkknmfooRXdfjX4SeOP27v2iNR+L/h3wLo/wCzr4Km+CXxh1/4FfELXddn8Z3TWHjrw34b8I+KtUHh61t59Xj1OwTSPG2hSWl7c2TW1xcyXFtIIvs7yH6x+GP/AAT+07/hKtL+Jn7TfxG1X9ozx/pEi3WiaVrFjBo3wv8ACtzujk8zR/BEBlsr6eJ0GLi/WLT7lkiuptCW9iiuI1GpmeLap4LLMVSlLT61mUPqeGobe/KnOX1uu43vGlSopTatKtSi+curguAOGY/XuLPEDh7H4aj+8jw9wDjP9Zs/zaS95YahjsPhv9WsnpVbKFfH5lmk62FjN1aGVZlVpvCy5r9ij4Y+L/iN8QvEv7ZvxX0S68P3vi3Q18JfAvwZqcai+8J/DDz/ALS2v3sLqWg1XxY5+0W8g8uUWN3qk8TSaZrdjHD+n1NVQoAAAwAOBgAAYwMdqdX0uW4CnluFjh4TlVm5Tq4ivNJTxGJqvmrV5paR55aQhH3aVOMKUPchFH8/ce8aY3jziOvnmJwtDLcLTw2EyvJMlwkpzwWRZDllFYbK8pws6n7yssNQjz4nF1V7fMMdVxeY4m+JxdZvxv4//BzRfj18JvF/ww1qT7Iuv2AfSdUWPzJdE8Q2Ei3uhaxEoKuwsdRhge5hjkia8sWurIyIly5r4P8AgR8XNYmvLv4G/GWM+Hfjt8P0Gl6pY6hIEj8daXZx7bHxh4cuZfLj1eLUrGOO8vDbAsxZ9QihjtZjFbfqpXz78d/2Z/hf+0JptlH4y0+807xLoZ83wt488M3Q0bxn4YuVk86OTTNXjil8y3Wf98dPv4byx87FzHBFeJFcx/rXBXF+W4HL8RwtxPHFPh/FYx5jgMxwNKGIx/Dmb1KVLDV8bRwtSpRhj8uzDD0cPRzfLvb0KtVYTB4vCVo4jB+xxXgYHG0oUpYPFqf1adT2tOpTSlUwtZpRlUjBuKqU6kVGNanzRbUITg+aCjLzq18P6DZapqGuWWiaRaa1q6wJqusWum2dvqmppbLstk1HUIoUu71LdAFgW5mlWJQBGFAFfE/7c1h+2Dr3hbwF4C/ZR8PWraB4u13VbX47+MdE+Imh/Dn4q+Gfh5a2ds8WhfB3VvEelanoeh+LvHV5c3OlXfxCuLe/1H4f6LaX+oeGtHm8V6lomv8Ahr2Sb4D/ALcfw2/0LwR8T/hV8bPD0BCWQ+KGl6z4a8YxWwAEcMl7oLSWupTRgbZNR1TWJp53PmtCocRRRp8Pf+Cg/ipjYyj9nn4X2jjZPrcVx4m8T6zbhvl83TrJ01TSZ5lzvSG/hiib+KUYwft6mQ5HiaLnQ494IeAnyv6682r4KuqfNGTVTKMdltPOk5K8atGGV1pNOcY+0unLv+rUGuaGY4Dk/n9tOE1dbqlOkq/OunLTck0nG+jPKPhd4+0P9mL9nTTdG8a/AfRv2aNH8DSyeEvhh8GfC/j/AEb4lX/iexjtbS9trnTNT0mztJ73Wtc17UtTfXrzVzf6vd6iL3xT4k1a6u9YmuZPrH9jL4M+LvDdr4z+Ofxcs/sfxe+Nd3aanf6NIuH8EeC7GPZ4Y8HIsima3uoLbyp9VhZklVoNNs76M6hptxLJofBv9ivwl4C8U2/xP+JvirW/jj8XoNj2ni/xjHHFpPhuRGaRf+EO8KJJdWGiGKRt9tNJPezWUgMmlnTTLKr/AGr06CvmOKOLMlwGSYrhThLFV8zWZ/V48R8TVcNUwNPMMNhK1PFYfJsmwVaMMVQyhYyjQxuMxeNpYbGZlicLhI/UcBhsK6eL5MTi8PRw8sFgpSqqpyrEYpw9mqkINShQoQspRoKSUpSqKM6kow92EYWkV8B/8FEv2Utf/af+DGnXPwzv4dB+P3wV8T2PxY+BfiGR4YAnjHw/++m8M3l1PiKLS/FtnGLCUXEiWEerwaHqGpCWx0+aCX78or4XhTifNuC+I8n4pyKrTo5rkmNpY3CuvSjXw1blvCvhMbhp+5isBjsPOtgsfhKn7vFYOvXw9ROFWSPk87yfA8QZTj8mzKnKpgsww88PWVObp1YXtKnXoVV71HE4arGniMNWj71GvSp1Y+9BH4mfst/tReH/ANoXw5e6ZqljL4F+NngSV9B+L/wi12OXTfE/g3xTpsn2HVWXS77ZfTaBPfpJ/Z9/sfyQ407UHi1O3uIR9O6npem61Y3Ol6xp1jq2mXieVd6dqdnb39jdREg+Xc2l1HLbzx5AOyWNlyM4zWt+1d/wTs+D/wC054hsPijpeseJvgd+0JoMCReH/jr8K7oaN4qKwQm3trLxZZRNb2njHSY4RHamG9ms9XXT4xplnrlnpzzWsvxbc/s//wDBXD4XOdL0Hxn+yj+0noMBMVn4g8YWPiz4bePbmFCRFJqem6Gun+E7aRk2h/I1DVpGbJlnLBp5f6bo4nw045X9pcM8V5JwRjMT+8x3A/HOLxWXwyvEzV61LIOK54Svkmb5LGbksHLOMZk2dUKThh8ThMa6U8xr/kE6PFvDjWDzfJcx4hw9H3MNxHw7Ro4uWMpRsoTzLJY1qeYYHHuP8dYGhj8BUmpVaVegprDU/r7T9O0/SLK203SrCz0zTrOJYLPT9PtYLKytIE4SG2tbZIoIIlHCxxRqi9gK+Uv2qP2o9N+BWj6b4P8ABunP8Qf2h/iTInh/4OfCTQ4zqWva94h1Rms9O1bU9Ptm8+z8M6fdEz3d1ObZb/7NLY2cyuLm5s8+3/Z1/wCCtXxXf+yfFHxB/Za/Zl8O3BWG91zwDpfiv4lfEGC3kx5z6dYeIvtPheWTyy6pJ/bGjXMTFTDMkoFwn29+yd/wT2+DH7K+q6l8QI73xJ8Xvjx4lidPFvx3+Kd9/wAJB451ETxLHdWWiGfzLbwto8wBjNppxk1K4tPJstX1rVoLS0EJWxvhrwH/AMKnEfFGR8eZjhWquX8D8FYnFZjhcxxULSox4l4rWFw2TZdkjnb65TyPF5znOLpRnhaNLLfbwzKgU8PxbxG/qWVZNmPDeFre5iuIeIKNHC1sLQlpUeVZM6tXH4rMOVv6vPMKOAwNGdq06mK5Pq1S7/wT7/ZTvv2UfgPBoHjHUo/EXxl+I/iHVfin8cvFaulw2t/EjxUyTalaw3gjVrnTtBt0t9JtZRsgvLm3v9Zht7RtXmt0+5qKK/mHifiTN+MOIc44oz3ELE5vnmPr5jjqsKcaNFVa87qjhqEP3eGweGp8mGwWEpJUcJhKVHDUYxpUoRX7Dk+U4LIsrwGT5dSdLBZdhqeFw8JSc5uFNWdSrUledWvWnzVa9abc61ac6s25zbf5Y/8ABSv9mr4i+NLD4a/tU/s8aaNS/aI/Zi1DUdZ03wzDGzS/FP4Y6tDs8c/Dl1hX7ReX89mJ7zw/bRtJO7XOt6dpUP8AbGtWU8HG/s8/tF/Df9pbwDaeOfh9qeZY9ln4p8KagyQeKPBHiBFK3mgeJdLJE9ndW88cyW9yU+x6lBH9rsJpoGyv7Adeor8yP2k/+CZXw/8Aiz4+u/jp8DfH3ib9lj9oi7Mkmp/ET4b28Fx4e8aSyOs0n/Cxvh/JPYaR4pNxMnmXl1FdaZc6nMVn15tbMFvHF+08BeIfDGacN5dwH4hYzEZL/YMsVDgvjihgq+aUcowOPxVTH4vhribLsIp5jieHnmNfF5nluYZTRxmZ5LjMdmNNZZmuDx0KeX/n3EvC2b4PN8VxLwvQp5h/aSovP+Halelg547EYajDD0M1yjF13HC0cz+q0qOExeGxk6GEx9ChhpvFYTEUHPEdayIxUsisUOVLKCVPqpIyp4HIweKdXxlL8HP+CwHgJv7JgH7HfxzsIgEtfE895448DeJLtE+UXGs6Ykeh+HrW4kwZJLfSbe4gX+CfnYs9r+yd/wAFSfjUf7M+KPx1+Af7Mfg27LRal/wojQvE3jX4jT2RBE1rBqniySCx0W5mUhItY0PxHb3dpJ/pCWzqn2ef7p8NcNUI/W8Z4seFlDK1ac8ww/EGOzLEyp96XD2XZPieJ5VZR0p0K2TUJ89oVPZLmlH5xZvm9RqjR4J4xqY1+7HDVcsw+FoqfSM8zxOOp5TGCfxVIY6pFK7jzOyfL/tWftDeI4tT0/8AZX/ZrhPjT9q34uodB0LS9Il86D4V6FqMO3VfiL41voVmh8PQaLpU0upab9t2yRFItZnt5dPtlgvv1l/ZI/Zw8M/snfs/fDv4GeF5VvovCGj513XTCIJ/FHi7VZpNU8VeJLlDulQ6prV1dy2dvNLO+n6YLHTFnkisojXKfspfsR/Ar9j/AEXVLf4Z6NqOreM/FBM/jv4r+Nr8eJPiX47vXm+1Sz694imggMVo11/pC6RpNtp+ki5zfS2k2pS3F7P9eV+V+JviJkuaZRguA+BaePhwjl+YrOc1znNKNPCZtxpxFSw9XBYbNMVgKNbE08qyjKcJiMZheHcn+tYuvQhj8xx+PxM8ZmLw2B+z4Q4VzHB47EcS8RywzzzFYX6hgsBg6k6+CyDK51Kdetg6OJnClLG47HV6VCtmeO9jRp1HhsLhsNSjRw3tcQV+L/8AwUY+Dfj/AOEHxW8Hf8FDPgh4cvvFd54H8NyeAf2m/h3osQfU/HHwVFyt7H4s0y3jCm417wHMv2u4dvNkbTbPR7m4eHRfD2px3H7QUjKrgqyhlYEMrAEEHqCDkEHuDwa+I8PuN8bwBxLh8+w2EoZpg6mGxeU57keMnUp4LPsgzSl9WzXKcVOl+8o+3oNVMJjKSdfLswo4PMsNbE4Si19FxRw9h+J8pq5bVr1cHXhWoY3LsxoRjLEZbmeDqKtgsdRjL3ZulUXJWoTap4rC1K+Fq/uq80flZ8Kvip8N/jj4J0f4jfDbXtM8VeGNbgR4L228s3VncBEa40rV7OT/AErStXsC4jvtMvUiurZ/vR7HR39ISGKMkxxRoSMEpGqkjrglQDjIHFePfGX/AIJYaQPG+tfGP9jP4t65+yR8UdemN74l0PQdLtfEfwU8cXoaWUSa/wDDW7aHTdLup5ZWBu9LWfTLIyT3tt4afUbi4upvjn49eIf+Co37JHwr8YfFP4qaJ+x546+H/gOHSpNY8a+Hb/4mWmpm31nXdM8OaddXfhxjpc1xcS6nq9glzb6Rp0UNuskskbyxRGU/0PQwPh5xN/wocH+IfDmW0K/7yXDviDjFwrxFk8pWc8NiMxxOHXC+c0qTbhRzHLM3hWxdOHt8RlGV1aiwkfy2eI4pyh/Vc94WzXFVYWhHM+GKH9s5XjkrJVqeGpVf7WwE52UqmGxmCdOhJ8lLG4uEVWf6KT6BoN1q9p4gutE0i517T4Jbaw1ufTbObV7K2m3edb2epSQte20E29/NhhmSOTe29TuNfnv+0j8QvFH7UPjofsEfsxX41Txp4022n7QnxJ0wG+8N/BL4UmdYPFcOrahbt9kbxPrVo76MuiCdbh1un0NjbarqsE2n+vWf7D3/AAUU+PeNP/aK/aa+GvwE+H158us+D/2WdE1678Y61YOyrNpsvjzxlFb3vhmaWLzEe70m+8QWToxjudNu45THF+oP7Nf7LHwS/ZM8BR/D34KeDbXw3ps0kV5r2s3Ejal4q8X6ukZR9a8V+Irlft+sag5eVokdotP05JntdIsNOsdlqmdXizgPwuf9s4PiDJ/EHjvCP23DuU5Bh8XiuEMizSNpYXO+I85zHBYGhnlXLaqhjMDkOSUMxy7H4qnR/tbN6OFpVsuxlQyTiTjH/YK+WY/hfhuslTzXGZnOhRzzMsFK3tsuyrAYatiKuXQxdNuhiMyzCrhsTQozqRweBnVlDFUfSfhV8NPCnwa+G3gf4VeBrD+zfCPw+8MaN4T0C0JV5l07RbKGyhnvJUSMXOoXhia81K8ZFkvb+e4upcyzOT39FFfydi8XicfisTjsbXq4rGYzEVsXi8VXnKpXxOJxFSVavXrVJNyqVa1Wc6lScm5TnJybbZ+2UKFHDUKOGw9KFHD4elToUKNOKjTpUaUFTpU6cVpGEIRjGMVoopJH44/tdeAtb/Zj+OF/+1T4Y0i+1X4MfFSLSdG/aB0rSLV7m48H+JbHFjoXxKhs7dQzafdwulrq7Khxfy38s7zX2vWHkej6Dr+i+KNH0/xB4c1Sx1rRNVt0u9O1TTbiO6s7u3fo8U0ZKkggpIjbZIpVeKVElR0X9PL+wsdVsrzTNTsrTUdO1C1nsr+wvraG7sr2zuomgubS7tbhJILm2uIXeKeCaN4ponaORGRiD+YXjj/gnRqPhPW9T8Wfsi/Fm8+Cs2q3L3+p/C7xHZP4s+EupXsjKZXsLGcz3/hTzsHzJbO31gwRbLPSYtKtI4oo+c1NikJABJIAAySeAAOpJPQCvHH+Ef8AwUk09jYN4R/Zh111Plprtl4l8Z2djJjgTzWN69nfnP3nWK1t89FjTjPQ6V+wd+0Z8WnSL9pn496P4e8Fykf2l8M/gDYX+mw61A27zLHVfG3iG1t9WSzkTEN7p7afrFrcxswhmt5ES5YA8NvNLvf22/inYfAH4fTT3HwV8Ha3pmu/tDfEXT3I0i8tNMulvLD4ceH9Tj3QXmq6veWwM01q0n2aS3F/GZLXR72K7/duxsrTTbK007T7aGzsLC2gs7K0tokht7W0tYlht7a3hjVY4oYIUSKKJFVI41VVAAArifhj8K/h/wDBrwdpfgH4Z+FtM8JeFdIVvsum6bE2ZZ5Aonv9QvJmlvtU1O62KbzU9RuLq/uiqme4k2rj0CgAPPHrX4e/F7wtdfsSfHfxJr13a3C/svftAeJpPENtrdtA8mn/AAl+KuqfNrOm6ssK7LDw94jdGu7Cby1gt7WOC0tlWPQb+S5/cKue8V+E/DXjnw7q/hLxjoWl+JfDWvWcmn6xoms2UF/p2oWkuC0VxbXCPG211WWF8CSCeOOeF45o0dQD86bW6tb62t72yuYLyzu4Yrm1u7WWO4trm3nRZIZ7eeJnimhmjZZIpY2ZJEYMrFSDU9cb4i/4J5/Ez4Y3l3ffsjfHD/hFvDk9xNdJ8HPi9bX3izwLZSTPJK0OheJLeO+8R6FYh2H+jx6ffahOxMt5rVwQEbjf+FTf8FJd32H/AIQv9mHzs+X/AG5/wk/jP+y8Z2+f9g8/+1NuPn2+Tv8A+mX8FAHrt1d2tjbXF7e3MFnZ2kMtzdXd1NHb21tbwoZJp7ieZkihhijVnllkdUjRSzMFBNfOfwj8K3f7bnx28Na5aWlw37LnwB8Tx+IbzW7m3aPT/i18U9K+bR9L0pZ49l94e8PO4utQl2PBcWctxaXKFNe06S29h8Pf8E8/ib8T7y0vv2ufjgPFHhuCeK5k+Dvwgtr7wn4HvnieOVYNd8S3Edj4j12w8xf+PeTT7LUIGVZbPWrcnYv6g+FPCfhnwN4d0jwl4O0LS/DXhnQbOPT9H0TRrOGw07T7SLJWG3trdEjXc7NLLIQZJ5nknmeSaSSRgDoarXlna6jZ3Wn39tDeWN9bT2d7aXMazW91aXUTQXFtPDIGSWGeF3iljcFHRmVgQSKs0UAfg3a6XefsSfFTUPgH4/mntvgn4y1vU9d/Z6+ImoM/9j2Ntql215qHw38QapKfIstT0m8uSYJ7qSMXMkzahMY7fWLSK0+swQQCCCDggjkEEZBBHqOR7V94/E74WfD74y+DtT8BfE3wtpni7wrqyj7TpupRNmGdAwgv9OvIXivtK1O13u1nqem3Nrf2rMxguI9zZ/M3Vv2Df2i/hK7xfsy/HvR/EHguIn+zfhl8f7C+1KDRIFwUsdK8beHrWfVns41zFZ6eunaPa20YUTT3ErPcqAehVka9r+i+F9H1DxB4i1Sx0XRNKtnu9R1TUbiO1s7S3jHzSSzSlVGSQkaDMksjJFEryOqnzJPhH/wUk1BhYL4R/Zi0F3Plvrt74l8Z3lhHngzw2Nk95frj7yrLbXGOA0bc16X4H/4J0aj4t1vTPFn7XXxavfjRNpdzHqGmfC7w3ZP4T+E2m3sTMYm1CxgMOoeKxDu/dy3cGjNNHvtNVj1WzklhcA85/ZH8A63+078b9P8A2qPE+kX2l/Bb4Vx6ro/7P+laxaNbT+MfE17mx134lTWdwhcabZxRm20ZmQZ1GHT5LeSC+0HUluf2PqpYWFjpVjZ6Zpdla6dpunWsFlYafY28NpZWVnaxJBbWlpa26RwW1tbwxpDBBDGkUUSLHGiooAt0Ac34x8JaD498KeJPBPimwj1Tw34s0PVPDuu6fLkLd6VrFnNYX0IcfNE7288gjmjKywybZYmWRFYfhz4Pvdf/AGTPHA/Ze+N95LDoMdxdN8AvirqQFvoHjfwa1xmx8OahqDkWum+J9CE8djJYTSpHEWg06HbbNoF1rn71V5n8WPg78Nfjj4PvfAnxT8J6Z4u8NXrLN9kv43S5sbxFZIdS0jUrZ4dR0fU4EeRIdQ026tbpYpJYTKYJpY3APhvNFcNqP/BP748fDZzD+zl+03K/hSMldP8Ah98cdBXxRZ6XAB+6tLLxlpkE2rwWEH+qtrK00SzWGFVMs11Jlj84fCnQP22Pjn8W/wBpj4IWvxM+CXw/1j9ln4g+A/hr8RPFOk+E9e1xNU1j4ifBb4dfHXR9Q8D22twyRalYWfhD4m6Fp+ovr1p4duIvElnq1na2l3pkFnrN8AfQvxN+Kfgn4ReF7vxZ441iHTLCBXWztFZJNU1q+CFotL0WwLpLf385ACxx4ihQtcXc1taRTXEfefsK/A3xte+JvFX7W/xq0WXQPHfxG0iHw58M/A9+jG8+HHwqjnS+to71JlRrfX/E0qwXt7GYYLm0gE8kq2s2u6hpdj3PwV/4J8fDf4feKrL4nfFTxT4k/aE+LOnyJPpvir4grCNA8OXEbeZHN4S8Exy3mmaO8M2J7Vru61Z9PuUjutLawuF3n7+oAKKK+avjv+1z8A/2clgtviZ44trbxHfRpJpfgjQbefxF411QSki2Nv4f0xZrm0gunV47bUNWbTdMmmRoUvTKNlAHzb/wVX/5No+GX/aQH/gll/68n/ZVr9J6/BT9sH9qjxd+1R8L/Cvgb4dfsu/HjTtO8P8A7Rn7JHx0XxF4v0Ox0VtR0n9m79qH4RftB6lo1ro8V1fObnxXpXw1ufD2mXq38tvY3uq299cR3FvbyRSfZnhL/gpz8ELjWLLw78XvCPxV/Z51bUJUgs7v4p+EZrTwtdzyEKqW/iPS5b9I4VOTLfalY6bp0KgvNeIoYqAfo/RWfpOr6Vr2m2Os6HqVhrOj6nbQ3um6rpV5b6hp2oWdwgkgu7K+tJJba6tp42WSGeCWSKRGDIzKQa0KACiiigAooooAKKKKACiiigAooooAPwooooAKKKKACiiigAox7fp6dKKKACiiigAooooAKKzdY1nSPD2mX2ta9qmn6Lo+mW0t5qOq6reW+n6dYWcCl57q9vbuSG2tbeFAXlnnlSONQSzAV+fPib/gpZ8HTq974e+DXgj4sftDatYSPBeXfwt8H3N34YtJ4zhluPEOpNZhoSdpjvrDT7/TpUYSRXciFC/DjMywGX8n1zFUqEql/Z05NyrVbW5vZUIKVary3V/ZwlbqfYcKcAcaccTxK4U4czPOaWBUXmGNw9FUsry5VP4bzLNsTKhlmXKp/wAu3jcXQVSz5OazMH/gnB/yN/8AwUz/AO0m3xj/APVGfs2V+m1fg7+zD+0T4+/Zq1z9qbxD8RP2Wfj3c6B+0J+1R42/aLtbvwp4etdcuvCOj+KvAHww8GLoGq2bXFkl5d6fJ8PrjUbjUkurO2aHUYYRCjW7ySfqf8DP2t/gP+0Sk9v8NvG1tceIrJHfU/BOuQTeH/GmmCIhZzceH9SWG5uoLWRliub7STqOmwzN5TXvmfKcMNnmVYurGhRxkPbzvyUK8KuFrVLb+ypYqnRqVbdfZxlbqe1xD4P+JPC+W1s5zbhbFyybCuKxmb5Rist4jyrAObSgsxzHh3G5pg8v55NRh9drUOeb5Y3lofSdFFFeqfmoUUUUAFFFFABRRRQAUUUUAFH4UUUAH4UUUUAFFFFABRRRQAmB6D8qWiigAooooAKKKKACvzJ/4LIf8o2P2m/+wT8Ov/VxfDyvdv2l/wBu79mL9kyO2tPjD8RrWz8W6lFHJonw58NWlz4r+ImtidmS0Nr4V0Zbi8sra9kV4bPVNcbSdHuJ0aBNR84bK/H79t79t74nftl/svfFT4G/CP8AYX/amsdO+JFl4Zh0zxx488Naf4ZSC30Lxv4b8WfbF8Oxz6nPfRX1toL21ubXVCoa5jm3OkbBv07h3wZ8TeKssoZ3lHCeMjkuLclgs5zjF5Xw1lOYODUZ/wBm5lxJjspwWY+zk+Wp9Rr4j2ck4z5ZKx8fmvH3CGTYypl+Ozug8wo29vgMDRxmbY3Dc1nF4rC5Vh8bXwqkmnF4inSTTTWmp/SDRX5KeDv+Cw/7Po1/TfCf7Qfw4+Ov7J2u6rMltYX3xu+H95p3gu/uZDhY7Pxbo8moolupz52p6rpmlaTbxgyz38cayNH+qmg6/ofinR9N8Q+GtY0vxBoGs2cGoaRreiahaarpGq6fdRrLbX2nalYSz2d7Z3EbB4Lm2mlhlQhkdga8Pi3w8424EnhY8W8NZpktLHqUsuxuIoKrlWZRp/xHlmb4WVfK8yVLRVXgcZiFTbSnyto9HI+KeHuJI1nkmbYPMJ4ZxWKw9KbhjMI5fAsXga0aWMwjn9j6xQpc/wBm9jXooor4098KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiud8WeLvC/gTw9qfizxn4g0jwv4a0W2a71XXNdv7bTNLsYAVQPcXl3JFChkkZIoU3GSeaSOCFJJpERgDoq/Lv9ij/k+r/gsn/2dV+zB/67m/ZHqTX/APgpt4c128urD9nT4F/FT4+xWkz258Vw2o8AfD+4mRijJaeJdesr28LIynct5oVgWA3RF0y4+Rfgl8cP2hfgR8dv2wfjl4r/AGSPFOtaV+1r8U/hl8Tr/Q/CPxD8K69q/wAPh8N/2d/hN8AhpFnbadbXlx4vbV7f4Wp4pNw9v4aezm1ptGW2ulsBqV4Afv1RXyJ8BP23fgP+0Hqj+E/D2s6r4O+JNssn274XfEfTD4T8bwPDGZZ0tLG4mnsdZeGNXmmh0XUL+7tbZDc31taREE/XdAHwZ+2z+034m+Etl4T+EPwahs9T/aB+ML3Vp4TW7RLix8D+HLYMus/ELW7do50NvpqrOukQ3UEtrdXdrfXUlvqEOj3Wl3nyR8JfgB4W+Gkt14n1Se68e/FbXpHv/F3xS8Vu+qeKNZ1S6XN7Ja3d9JdTaVYyOSiW1rN50sCwrf3N7JEsgyPCGoSfFf8Aau/aq+M2qMboeFvG7/AHwTvYvHpGh/DxY7fxDHYglgkOtautrrDshANxdXjJhbl1r6RoAKydc0HRPE2l3eieItI07XNHv4zDe6Xq1lb39hdRn+Ga1uo5YXwfmUlNyMAyEMARrUUAfKfhHxX4k/YB8Y6f4i8P32sa7+yR4s122sPiD4Cu57vVpvhBqOtXawQeNvB8kzT3UejG7mRdW07c5vQ4tZxd6jcaTe2H7pWN9Z6nZWepaddW99p+oWtvfWN7aSpcWt5Z3cKT211bTxM0c9vcQyJLDNGzJJG6ujFWBr8ufFnhnSvGnhjX/CWuwC50fxJpF/o2owkDJtdQtpLaR4yQdk8Qk823lGHhnSOVCropHp//AATP8baz4o/Zc0jwt4juZLzXvgz4y8X/AAZ1G6kd3aSLwdewTaNEN+WWLT/D+raTpUCfwwWEfAORQB+gNFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVLUtQsdK0++1TU7u3sNN020uL/AFC+u5UgtbKytImuLq7uZ5CscNvbwRvLNLIypHGjOzBQTV2vz7/4KWeMtZ0H9mufwX4cuZLPXvjb478HfBmwuIS3mRw+Lbya61ePapBaHUNF0jUNIuV/jg1B4wQzqRxZjjFl+BxeNlFz+q0KlZU46SqThFunTi+jqT5YJ7Jyuz6zgThatxvxlwzwlRrxwj4gzrAZbVxs4ucMBhMRXgsbmFSCs5U8BhFXxlSKd5QoyS1aPk28vPEf/BQXxhfeMvF95rGi/sk+FNeubH4cfD61nvNJl+Ll/ot21vceNfGEkLw3UmkC6heLTbAPG9oUezt/st5bate6n9q6B4d0HwrpNnoPhnRtM0DRdPiENjpWj2Ntp1haxj+GC1tY4oUzyWITc7Es5ZiSang7wro3gbwp4d8HeHrZbTRPDGjadommQKBlbTTrWO2ieRlA8yeUR+bcTEb5p3klcl3Yn84f+Cnv7SXxr+D2gfsw/BD9m/xHoPw/+Nv7aP7S/hL9nTwz8XPEvh6z8W6Z8G/D+oaJr3irxt8RrDwnqjJo3izxZpGh6AbPwl4Z1t10nUdX1KOW+8yGzNvP8xgsHOMva1msRmWLlTWKxUrc06s2oqlSb/hYSjKXLQoRfLTpq9pVHOcv6E4v4roYmjTynJaNTJ+BOHvaUeGeG6EuWlh8LBqmsxx8IckMw4kzZRjiM4zfEqWIxeMqumqlHB0sNh6H6hV83/Gv9mrwd8V3g8U6TLP8Pvi7oUiah4P+KvhQtpXiXSNXtU/0FtQuLF7aXWNPV1WKS3upftMNu8y6fd2byOW/KP4jN+1f/wAExvip+yR428YftwfFX9sH4C/tJ/tP/DX9lH4ufDr9oLwp8L7fxL4U8V/G+PWdP8EfFf4TeMvh94U8IX+iWPhrxRpdvD4h+H+p2+u6Vf8AhvUb17SSHUbS1v7P97K6sXg6OIoKFaMMRQqOUL2nFwq0vZy9yUoxnTqwVSnUp1abUoc0XGUZpqPh8N8UZxkWZxzDJsVi8mzXCRjzcs6U1WwuJUozo4mlGVbC43AYyEKuHxeBxcKuGxVNVaGJw9WhNxngfsZftIeKPilb+L/hB8Zba10n9oH4OS22n+MobYRw2HjLQbgIui+P9DgVIU+y6rE0J1OO1gjtbe6urK7igsbfWLXTrT7nr8c/itMfhT+1l+yj8a9KP2MeMfGJ/Z+8dbC0cWs6N46Up4ZS+KMgdNH1Z7vVQ0mSZLKwLMY7NUr9jB0FdmQ4qvUo4nBYqpKtiMtrrD+3nrPEYepSp18LWqPS9X2VT2NaX261GpUslNI+R8Z+HMpy/NOH+K+HsDRyrJOPcllnayfCqUcHkmfYLMMXlHEmVYGEm3Sy/wDtDBrNsrw3NJYLK83wWB55vDSkyiiivePxkKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK/M/wD4KFfte+Nvgxa+AvgB+zzaWOtftU/tA3F7pngCK9WO50v4deFbRWTxF8V/Elu0VxGtlocS3P8AYsN7bTWd3eWWpX0trqttoF9o9/8AphX8/vwQuG+OH7cv7cv7Rutk3w8BfEMfsp/DPzWMsOgeHfhckcfjKLTN5cRw+IPEC2Gus8W0faL/AFJkPl3si1+1+CfDeUZjmvEPFnEeAoZtkfh/kcM9/sXFJywee5/jczwWTcNZTj4KUXVy1ZjjXnGa4bmisdlWT47Ac9N4pTX594hZtjsLgsqyTKsTUwWY8T5jLLvr9FpV8uyzDYWvj83xuGk01DFfVcOsDg6vLJ4fGY7D4lRl7Gx6D+zr+x98P/gZJdeNdauLv4q/HrxNK+qePvjl46L63401/XL2P/iYvpd5qUl5P4f0l5GaKGysbj7VcWqW6atf6lLBFIn1zX4Wf8FRPi//AMFDk8KftQaj+zhd6j+yZ8Cv2QPgN42+NPiT9ojUtH8FeLfHH7R/xB0T4Z6l408NfCz4N+HNbi8SaV4c+Gmg3QtE+KHj/wAQ6ZB4iv8AW7aTwp4WsLOCx1PU9Q/Tz9nH4ieK/Ef7HPwG+LHiW31z4g+N9e/Zo+F3xE1+10e30ePxJ438Vap8LdD8S6rBpVrcXGhaAmueJNXnnjsbee70fR1v72KOS40+yBkh+uzfi7NOKs4zDMM8xeOx2OhCjKWKxStD6snWo0MPgMLTSjg8DhPq08Pg8FhsPh8Jh8PClTwNCOG9mjwsBkOCyTAYTDZbQw2Hw9SU0qVB3l7e1GpUqYqvK7r4mt7eFWviKtWrWqVJSliKjq8zPd/FHhTwx430LUPDHjLw9o3inw7qsDW2paH4g0201bSr6Bv+WdzY30U9tKFOGQvGWjcK8ZV1Vh+d+map4u/4JU+PtM8feBb/AMQeJv2DPHHiez0z4t/Cm+ur7Xrn4Bat4hvltrX4jfD+a5e5vYvDzX9xFFrOlNJI980q2F2b/UrzQdS0f89NN+PH/BSuy/b8/wCCdPiX9oPx0Pgl8K/21fiF+0Ho0H7DWgaL4P1aL4ZfDH4WfAjWfGfglvip8Rp9FufEuufGHxBrupWmveMLLQNU0vQPDT6Zp+g28TsNQ06w/oN8feCdA+JXgjxb8P8AxTaLfeHfGfh7VvDes2zBSXsNXsprKd4mYHyrmBZfPtJ1Akt7mOKeJlkjRh7nBXGNGhHH5Hn2CxOacC5xiqeX8W8L4yUfZ4vDToYarHNsupylVhlnEmV4fFwxmR5vSjTxuBxlP2NbnwdXGYTEedxDkE6ksNmOW16WD4jwOHeMyPOcNdSpVFWrU3gsVNKDxmVYurhp4fMMFU58NiMPP2lO1VUqtP8ASbStV07XNM07WtIvbXU9J1extNT0vUbGeO6stQ06/t47qyvrO6hZ4bm1u7aWKe3nhd4poZEkjdlYGtCvy0/4I9/EDxF4p/Y40/4f+L7uXUPFH7OXxK+IP7PGq30zu8k8Hw/1G2udBiAcl0g0rw1ruj6FaIfu2ulRL1Br9S6/nfj3hStwNxpxTwfXxEcbLh3PMxyqnjoR5KeYYXC4icMHmNOG8aWYYT2GMpxesadeKdmmfqfDWdQ4j4fyfPadJ0FmmX4XGTw8nzSw1arSi8RhZSsrzw1f2lCTtrKm2gooor5I9wKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAzdZ1jS/D2j6rr+t31tpejaHpt9q+r6leSLDaafpmm20t5fXt1M3yxW9rawyzzSNwkaMx4FfhVeanr37ePjaX4s/EtdRs/2c/DetXtv8EvhHO81rZeKV06eWyk+Injm1jdRqFxfOkq2OnTM8VvGZtOQtpsV5P4m+1v+CnvizVtG/ZmHgfQrqWz1X43fEjwL8HYbmEkSxWniS+uNU1RMD70N9pmgXWk3SHiS21GWI/frifD+haZ4X0LRvDei2y2mkaDpdho+mWqY2wWOnW0VpaxcAZKQxIGbGWbLHkmgC9Z2dnp1pb2Gn2ltY2NnDHb2lnZwRWtpa28ShIoLe3gVIYIY0AWOKJFRFAVVAGKs0UUAeM/F74G+C/jBp0DatDNoni/R2S78I/EDQWbT/FvhTVbWQXFhe6dqls8F1JBb3apO1hLP5DOvnQG2vUt7yD6O/Yf/AGkPGXjuTxf+z/8AHCaJ/jr8H4LaafW41WK3+JngG4eK20fx5ZIFTddo01naeIAkcai5vdOuHWK9vL+ysOXr5p8f3zfDL9qL9kf4y6awtJ9U+Jdt8DPFbrlU1Pw38So57CwivyP9Zb6Jdy6lqturZCXZjnA3QpQBU/Z+hbw78Q/2uvAV8GTV9A/ag+IuvSxSDEsmieL54Lrw9fsDltmoWenS3EZJIKnIY5r6hryv9tDwhqX7O/x70z9rTSdPurv4VfEfTNG+H37QEVhby3EnhvVdPMNh4M+Ik1vAHke0FstpoV3IIitv9lNrH5uoeIrRF9H03UtP1jT7LVtJvbXUtM1K1gvdP1CxnjurO9s7mNZbe5tbiFnimgmiZXjkjZldWBBINAF2iiigBGIUFmIVQCSxIAUAZJJPAAHJJ4Henf8ABLSGW8+CXxX8aqjDSviV+0t8WfGvh+TawjudGuv+Ef0eO4hyADH9u0a/hyoA3wupG5SB8wftBeO9e1A6V+z58JU/tr43fGInw7o2nWsjE+FPDuoJJFrvjPXZoVdtK0/T9LW9e3u5djxGOfU4lmi0ueNv16+CHwo0L4HfCXwF8J/Dh83S/BHh6z0gXZi8l9T1DDXWs6zNCHdYrjW9ZuL/AFa4iRykc97IkfyKooA9UooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK/NP8A4KdpJpnww+CPj50LaV8Mv2nPhT4x8QuciK20WA6zYy3UpwQEW+u7C2yQRm69Rhv0sryX46/CXQ/jp8I/Hvwo8Qt5WneNNAutMS88sTPpWqI0d5oeswxMVEk+jaza2GqQxlgsslosbEKxrzc4wlTHZZjsLSsq1XDz9hzaR9vD95QUn0i6sIKX91s+/wDCzibBcHeInB/EeaRnLKctzzCPOFSi51lk+Kk8Fm06EFdyxFPLsTialCK+KtGC6niCsGUMpBVgCCDkEHkEEcH8K+Ov23f2LPh7+3H8J9F+HXjLxP43+HHijwF8QPC/xf8Ag38YPhlqkOi/EX4QfFzwS92/hfx14Tv7m3u7Rrm0jv7+wvrC9tpIL7Tb+6SGSw1KPT9V0+3+zB8T9aNrqX7PnxbVdD+OvwYVPDWvaXdykP4r8O6bHFBoXjTQ5plQ6tYX+lmya7vIfMaVpINVkWG31a2QfWV7aQahZ3dhdCU217bT2lwIbi4tJjDcRNDKIrq0lguraXY7eXcW00NxC+JIZY5FVx4WDxccTRpYik5Qldc0HeFXD4ilJe0o1Evep1qFWLhUjvGUWtVv+x8U8N4jh3NcbkeYqjiqcFGeFxlFqrgM4yrF01Wy7N8urxbhicuzXA1KOMwWIpScalCtBpqSaX8tv/DO3xd/ac/4KGfs1fs6+P8A9tn4o/t3ad+wX8X/AA1+1L+0j8TtW8AfC34UfCb4J+KfAtlqL/Az4CaX4Y+EOg6ZoHjP47ePfFlyniT4h6t4x1bXvEvg34deF5bHRn0B/Evi7StY/qbryz4PfA/4Qfs++Dx4A+CXw38H/C7wb/a2qa/N4e8F6HZaJYXuv65cfa9Z17UhaRJNqmuarcbZNQ1fUZbrUbvy4lnuXSGJU9C1fV9L0DS9Q1vW9Qs9K0jSrSe/1LUtQuI7SysbO1jaa4ubq5mZIoYYY1Z5JHYKqgkmu2tWUoQjpGFPnnKTjCmnOfL7SpJRtCK5YQitXaEFKcnUlUk/l8ty6dGpNRjOtisZVpwhThKtiZ2T9nhsNTlVc69aScna7cp1aklCMYezpw+Rf2qYz4i+IH7HXw+svn1jXv2ovAfiWKKPmePRfBf2ibxDfIo+by7Cz1iK4kYEAADJHUfskOg+gr8lv2R/D+p/tJ/tBax+1vq9heWXwq+Hml6t8PP2erfULeW2k8QXl3JPY+M/iJHbzhJIoLiCS80W0kaJfPivPscojvfD86t+tVTw7B1VmGZ2apZhiaf1S6a9pg8JRjQp10nry4it9Yq0pfbw8qM1pIvx1xVLLqnBXAPPCpmXBORYx8SxhKM1geJuJM0r5tjclcoNxWIyXLf7Hy/MqfM5YbOqWaYOaU8M0FFFFfSH4EFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFfz6fsTRnwr8Uf+CgHwr1HMev+Fv21/in4wmhkyJpPDXxGNne+EtSZWJcR6pYaHcXURJIKkkM2dx/oLr8KP27fDGsfsgftUaD+3doml31/8Dfi3ougfCX9q230u1uLubwnqenSW2nfD34tz2lqsss1rbW62HhzUJVgYW0FibCATar4rs1T+g/APE08zq8b+HvPCGZ8cZDgpcLxnKMFj+KuGc1w+b4HJYym4x+sZ3lTzzL8spc6lis7rZVgoRlUxMEvy/xLozwkOHeKOWUsJw7mWIWbuMXL6tk2b4KpgcTmDSvL2WX4xZficXNJqjgI4uvK0aTZ5T/wVi8eeB9N/wCCdv7eXhfUfGXhSw8TXX7I/wAd4bXw7e+ItItNduZr74ZeIlsYrfSZ7yPUJpLxnRbVI7dmuC6iEOWGfWf2CfHPgnXP2PP2UNH0Xxj4V1jV9I/Za+A76tpWl+IdI1DUdMSz+F3hC1u31GxtLya5sktbllt7h7mKJYJ2WGUrIyqcX4ofsC/8E/8A9rbxJb/HL4r/ALNvwM+OXiXxVoWiC0+JHiDw3pnia71zw7aWMcegG31kPIl5p0NgY1sWidoxAV2Eiuq+BX7An7F37Mev6/4q/Z9/Zo+Evwi8R+KvDN34M8R6z4H8K2mi3+s+Fb69sdRvNBv54Pmn025vtM0+6lt2+V5rSBzygrNYbMqOZYmpWo4eknCnhJ0p1K8cRS+qVcXJe0pyw8eWrKWIUK1N29k6crOTdnp7fCVMFQp051ZtTniI1FGm6c/rEMLGXJKNV3go0XKnJJ+05o3UVqfnF+3p8UfhnqH/AAUt/wCCLOqWHxF8CXumaH8U/wBsibWtRtPF3h+4sdIivf2apbazk1S7h1B7ewju7kfZ7Z7qSJZ5/wB1EXk+Wv3D0fX9C8RabHrPh/WtJ13R5jMIdV0bUrPU9NlNtI8NwIr+ymntZDBLHJFNtlPlSI6PtZWA/Oo/8Ecf+CWhOT+wh+zgTnOf+Fe6b1rF+NMXgj9nj4Z+D/8Agn3+wt8OvC/hL4qfGmXV/DPw++GPw+sl0rRPhn4a8ZX2oX/j34m61BYrIPDmnRQ3Wu6jFqM/lSLetfeII0uLbRL2Nve4K4XzniTiB5RT+o0I5jiZ5hjcfOvUWCyXLcJgcJDNM2zOvVo0qeHyrKsBga+Y47F1JwVKjCUeVtJy8ziHOMBleWRx0/rNSWEw8MHhsMqUHXzDF1cTiZ4TB4SnCpOdXGYzFYulhcPQinzzd7pXS+zv+CMiSav8Cf2hfiXDGy6D8Yv2zfjv8RfCc2CIr3w7fP4Y0iG8tycK0J1HR9StsoAoktZFPzKwH6/14d+zV8DvDf7NfwI+GHwN8Jt52j/DnwtY6Ib9ohBJrOrsZL/xH4guIA7iG58Q+IbzVNbuYVdkhnv5Ioz5aIB7jX5H4rcUYHjPxH4y4myqNSOUZpnuMnkyrR5K7yXDSWCyeWIhZcmInluGws68be7WlNdD7fgrJ8TkHCeQZTjHF47B5bQWP5HzU1j6yeIx0acutKOLq1o031gosKKKK/Pj6gKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA/M/wD4KmWtxZ/BD4X/ABBSMvp/wm/aN+FXj3XTtJWHRraXWdEeZsdANS1vTIeeP32OuKZHIkqJLE6yRyIskciMHR0cBkdGUlWVlIZWBIIIIODX3b8Xfhl4e+M3wy8b/C3xUjNofjfw9qGhXc0aI9xYyXMe6x1WzWT939u0jUI7XVLBnyiXtnA7AhSK/G74FeL/ABH4H1fUf2XvjPt0n4v/AAsj/svSZ7hmSz+I/gW0Vk8O+K/DVzOEOpKdJhiW8jG688qD7VdKL2PV7bTQD6nooooAK+XvjzanxX8Vv2PPhvZ5k1XXv2lvBPi0wxjdMnh/wEZr7xLehQd2yy07UjOxOFwhJPynH0T4g8QaL4V0XUvEXiPU7PRtD0i1kvdS1O/mWC1tLaIZaSSRupJISKNA0s0rJDCjyuiNyv7DvgDXPjd8Xtb/AGyvF+k3mk+CtL0a+8A/s5aLqkMkF5c6LcyzQeJ/iPNauVNu+tI13pOmybX+0WV/qdtJ5kOl6be3YB+r2uaHo/ibR9T8PeIdLsNb0LWrG50zV9I1S1hvtO1LT7yJoLqyvbO4SSC5triF2jlhlRkdGKsCDX5OeL/2GfjZ8DdS1DWv2PvGGja74AvLue/n/Z++Kl9eNYaVLcSGWaLwD4xaUz2KSySOILDWbuwgiObjU9V1qYoqfrvRQB+CHjz9oP43/BnSrTUfjR+yV8Q/B0N54r8GeBLXVtN8R6D4j8M3/jP4i+MNF+H/AID8P2evWMQsX1Lxh428R6D4Z8P2cc1w9/rOsafYW7zTXEe70TTfB/7enxkddO8M/CDw3+zh4fuiY7nx18UfElh4k8RW9scebLo3g7SIXuYNTRT+4h1vS5NPlfCNfW53SxfQn/BVf/k2j4Zf9pAf+CWX/ryf9lWv0noA+Sv2ZP2QPh/+zZBq2uW2oar8QPiv4tRT44+LPi0i48Ta626OV7GwVpbldB0BZ445I9JtbieSbybQ6nf6m9jYvb/WtFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAfJn7S/wCyL4G/aJXSPEi6pq3w7+LvhEbvBHxa8In7P4k0Qqzumn6gkctr/bugmWWWR9MuLm3mhM11/Z1/Yfbr4XXxnOv7e/wZP9l+Mvgx4b/aQ0K0YRW3jv4WeJLLw34iurYA+XNrPhHVLYTzak6gGePR9JttPjf5FvLglZZP1/orxcZkeGxNaeKoVsRl+LqW9rXwcqaVflSUXiMPXp1sNWkorlVWVH26h7saqSVv1vhbxiz/ACDKMLw3nGVZDxxwzgXU/s3J+KqGPnVyaNao6tenkWeZNmOUcQZVhqtWUq88uo5nLKJ4mc8TUy2pXqVJz/Enwj+1h8ZfixdeLtF+Dv7I3xB8Va/4E8ZX3w68Zx6x4p0Dw5pXg/x3punaRq+oeGPEWo3lubex1bT9L1/RdSu9Pu5rOZLLU7KZ2ijuY5K9X8O/sZ/HT4/6pp+tftieM9H0L4f2V1BqNt+z58Kby8i0rU5reVZbdPHvi0S/adQ8po4/OstLvL+GQ5m0zVNGk8xJOp/4Jwf8jh/wUz/7SbfGP/1Rn7NlfptXNDhylUa/tHHYzMqSd1haqw+Hwkuq9tRwtGjLEK6V6depUoyt71J6397E+PGYYKlUXA/BnCnAmPqU5U/9YsueeZ3xLhlOPLOWVZnxLm+a4fI6/LdU8fk2X4HNqDblQzGnKzWToeh6R4a0nTdB0DTbHRtE0exttN0rSdMtYbLTtOsLOJYLWzsrS3RIba2t4USKGGFEjRFAC9Ma1FFfRJJJJJJJJJJWSSVkklokloktEj8JqVKlapOrVnOrVqzlUqVKkpTqVKk5OU5znJuU5zk3KUpNylJtttsKKKKZAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVi+I/DmgeMNB1jwt4q0bTfEXhvxBp15o+u6DrNlBqOk6xpWoQPbX2najYXSS213Z3dvI8M8E8bxyRsyspBraoq6dSpRqU61GpOlVpThVpVacpU6lOpTkpwqU5walCcJJSjKLUoySaaaJnCNSEqdSMZwnGUJwnFShOEk4yjKMk1KMk2pRaaabTVj8NPFH/BPb9pj9lnWNV8Q/sAeP9A8T/CnUb651W8/ZR+N+oahNo2jXF1K091H8LfHhm+16SLiSWQ2+ma7f6ZaxOPtetaz4imESR+N/EP9tP8AaU+A3hHWvFn7Qn/BP74w+BdH8LrbDxF4r0Dxf4Z8Y+A7E3moWuk2lxN4q020XTLW3vtTvbO0ts3N0hmu4IkuJmdWb+i+vzJ/4LIf8o2P2m/+wT8Ov/VxfDyv3zC+P+ZY6lTXHfBfCXH+Y04Qg+JMzef5HxRi404qMXm2Z8MZzlGGz3EOKSq5lnWXY/OMQ0pV8yqSu3+Z1fDLC4acnw5xBnfDWGk3L+ysKstzHKKLk+ZrBYTN8BjauXU1JtwwuAxWHwNK7VPCxWh8hWsX/BUL9oUjRfAH7PPg/wDZB8L35MF58T/jZ4x03xn4usrNgPOuPD3gDQrQ3FrrMaN/osHiPRLvSp5cRPqFod1xB+hf7Hf7B3wz/ZMi1/xWNZ1z4sfHfx6qv8Svjt49b7Z4x8TOzxTyaZpaSz3q+GPCy3EMMkWh2V3czT/ZrH+19U1Y6bpjWf3RRXz/ABZ4z8Q8RZRiuGcnynIOBOF8c6f9p5LwlQzCnUzuNCcatCnn+e51mWccRZvhqVaMcRDLa+axyaGJhDE0ssp16dOcfUyTgDK8rx1LN8fjsz4jzjD8/wBUx+d1cNOGXupHkqSy3LcBhcDleBqzg3TliqWDeOlScqU8XKnKUWUUUV+QH3QUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFfNH7SH7Knwv/aa0OwtfGNvqGieLvDjtdeCPiR4WuBpfjXwfqAdZo5dM1NVbz7Fp0SS50q8WW0lYC4t/seox22oW/wBL0UAfjPqXwO/b++EEh0/SLD4cftS+Frbcmnaout2vwy+IslrEcRjWotcuIfDbTiIAbra81q7uGBkuL2SZmDeQ+Cfi/wDtYfFzxv8AFn4W/Dn9lzSLPx58DvE3hzwZ8WI/FHxd8OtpvgTxN4v8B+F/id4dsdSjS00V9Y/tDwJ418L+JEPhm91ZI7TVYreeaG/hubWD99q/Lv8AYo/5Pq/4LJ/9nVfswf8Arub9kegDJ8Bf8E/PHPxF13SvGH7ZnxF03x1ZaTdRalpHwP8Ah3FfaR8LbK+jCvBL4ivrtbbWPFhhLODZ3FvAFcPBJq+p6VcT2Ev6o2VlZ6bZ2mnadaW1hp9hbQWdjY2cEVrZ2dnaxLDbWtrbQKkNvb28KJFBBEiRxRoqIqqoAs0UAFfH3x8/bg+B3wB1ePwbql/rXj74oXQj+w/Cz4Z6WfFXjJ2mRJIRqFvBNDp+ieZFJHcJBqt9bajcWj/arDT72IE153+3H+0f4x+H6eD/AIC/BKaFPjt8ZVul0/WJAJIfhv4HtTJFrfj68TbJtuUEV1a6D5kTxtc2mo3ca3F1p1tp9983/B/4H+Dvg5pUyaTHNrXizWGe78YePtcZr3xX4t1W5k+0317qWpXDz3SwT3bPPFp6XDQRsfOma6vpLm9uADyr9qP42/tNftZfDvw54I0P9k288D+H/D3x5/Zn+Odnq3ib4p+Fk8QalP8As1/tE/DH9oPTNAuvDt3a6PJpEfi29+Glt4av7iSe7l0e21efULeLUJrNLaf6c0r/AIKV33hG5hi/aR/Zs+JHwe0l5o4J/G/hu/svip4L0/zCoFzrGo6HZ6dcafASTtisoNavCcLHBKd+zeqOWKKeKSCeKOaGaN4poZUWSKWKRSkkckbgo8bqSrowKspIIIOKAP0D8BfEHwT8UPC+m+NPh74o0bxf4W1eMyWGtaHexXtpKUwJoJDGfMtby1c+Te2F3HBe2VwGt7u3hnRox2Nfgpfp4g/Yo8aP8f8A4LWt23wpvr+1Hx6+C+nsRod9oU0ywzeNvCenM4ttJ1zQhIJtlqIbeGEFWNvobarBX7m+FfE2ieNPDPh/xf4a1CDVvD3ijRtM1/RNTtixgv8AStXs4b+wuog4V1We2njk2SKkqbtkiI6soAN6jOOTwKK/Lf8AbY+O/jrxR48039kH4Ga9P4a8Sa3osfiP41fEfTnf7b8PPAN3sW30XSZYXSS38U+J4pY2SRJbe6tNPvNP+zyRJqs+paUAeu/Gn/goJ8FfhX4nufh14Ws/FXxv+Klq8sF34D+E2ljxDPo9xCxjlj8Ra4sqaRpRtpVaHULaCbUtU0yQD+0NMt0IY+DN+3P+11fst7pH7E+m2emP88dtrnx08MxavLEeV8yI6VZ/Y5iMBoZ7VnRgQQRg1mfDD4TeBPg/4bg8M+BNDt9LtFWNr++YLNrGuXiKQ+o63qbKLjULyRmdsuVt7ZX8iyt7W1WOBPR6AKfhn/gpj4c0XU7LR/2kvgr8Rv2env7hbSDxXdqnjz4ci5dtkcM/izQLO1nikkYqR9n0a9t4I90t1dQQIZj+kmgeIdC8V6NpviLwzrGmeINA1i0iv9K1rRr621LS9Ssp13Q3VlfWcs1tcwSLyksMroeecgivzZ1PTNN1rT7vStY0+y1TS9Qgktb7TtRtYb2xvLaUbZILq1uEkgnhccPHKjIw6ivmbwP4t1b9gf4kaRq2k31/d/sk/EjxFbaR458JXc91fwfBvxNrMyw2PjXw88ryz2vh+4uGVNatcuskCvA63WoDw+IgD916KZFLHNHHNE6yRSoskUiMHSSN1DI6OpKsjqQyspIKkEHFPoAa8iRI0kjrHGiszu7BEVVBZmZmIVVVQWYkgAAk8Cvzv+Jf/BSL4S6B4i1DwN8GfCvjP9pHxvpjPFqNt8MbNJvB2kzodoj1fx3OsumpEzkJ9u0e01ywjkEkM9zFcRtDXg/7V3xU8V/tMfFzxB+yv8OfEF/4Z+D/AMO/sq/tDeM9DnMGp+KNYuwZIvhXot6m5YLWONJYvErjest1HfWV9C1vpgsNd7DwZ4H8JfDzQLLwv4K0HT/DuhWCgQ2OnQiMPJtVXuruZi9xfX0+1Wub68lnu7lxvnmkbmgCr/w3H+2C7i8j/Yn0VdO/1n9ny/Hvwt/axi67fP8A7LSFJioPytZblYhShIIPoXgH/gpV8M7rXdP8IfHvwF45/Zr8TapItvp9349tUv8A4f6hcswQw2Xj2xit7QIjEmW/1PTNM0iFAGm1FGOwUawPE/hXw5410S+8N+LNF07xBoWpRGK80zVLaO5tpRg7ZFVxuhuIid9vdQNHc20oWa3lilRXAB+pNtc295bwXdnPDdWl1DFcW11bSpPb3FvOiywzwTRM0c0M0bLJFLGzJIjK6MVINTV+LX7OHxJ8R/sffF7wt8BfFuuajr37Nvxd1V9I+EWta3cyXd58KfHd05e18CXWoTFnbw3r80iwaUkpCQXs0V3CsAi8SXVx+0tABVDVNV0zQ9NvtY1rUbHSNJ0y0nv9S1PU7uCw0/T7G1jaa5vL29upIra1tbeJGlnuJ5I4oo1Z5HVQTV+vw8+MPjrWP26Pir4k8I2mr6hp37JPwj8Rtod5aaTdz2TfHHx9o8qvfyXl9ayJI/gzQ7gRixS3lKXK/ZtUt5Df38E/h0A+kvGH/BS/wReavqHhz9nT4VfEH9o/U9MuDaXuveHYV8LfDi3uwxRrd/G+s2tzvZSC8dxHozaZdwlZ7LUbiFvMHFj9uX9r+1Zr2+/Yn0i405QZHsdO+PHhdtWSIZJCN/ZVylxMFxiOGz3yMCqoCwA6DQ9C0bw1pVjoXh7StP0TRtNgW2sNL0u0hsrG0gXJEcFtbpHFGCxLsQu53Zncs7Mx1aAOz+En/BRP4NePPE1l8PfiNpHi79n74lag8UNh4Z+LGnLo+l6zcTMEjj0DxYr/ANkXqzSlILQ6kNFl1C4kSDToLuR1U/foOenP0r8lviF8NvBXxU8OXXhbx1oFlr2k3KsY1uIwt3p9yVKpfaVfJtutNv4s/u7q0ljk27opPMgeSJ3fsa/Gjxp8IvihD+x78Y/EN74o0fU9KvNY/Zz+I2suz6jrGh6VE82pfDnXbxiVudY0Cyikn0qWQh0srWSzDJZ3XhywgAP1noorP1bVdP0LS9S1vV7yDT9K0ewu9U1O/upFhtbHT7C3kur28uZXwsUFtbRSTTSMQqRozE4FJtJNtpJK7b0SS3bb2SKhCdWcKdOEqlSpKMKcIRcpznNqMYRik3KUpNKMUm22klcyvF/jLwr4B8O6p4t8a+IdH8L+GtFtzc6preuX9vp2nWcOVVTNc3LonmSyMkUEKlprieSOCCOSWREb87dT/wCCjc3jK8ubP9mX9nj4k/HSxt7h7QeNb+SH4aeALqVOHbT9d8QWV3PciM4EkF/ZaPcL1CFSrt8/adDq/wC3t46m+MnxOTUIP2b/AArrl9ZfA/4T3DTWun+MG0yeWxuPiL41tQ6i/a7mimistOl3xxqJtLJOn29+/iP7ns7O0060trDT7W2sbGzgitbSzs4Ira1tbaBBHDb21vAkcMEEMaqkUUSJHGgCooAAr5GeaZhmbdTAV1l+XX/cYhUadbG42N/94prERnh8NhprWjz0K9atC1Vqimov+osL4d8D+HlOGD40ympxxx3GEJ5vkNTNMblXCPCeInFTeSZjWySvhM74gz/CXVPNlgs3ybLcqxarZdGWa1qNatR/Pn9nv4hfta/s0at+0b4j1P8AZJl8ZaZ+0J+0f4t/aL1i10H4seEhq/hK78WeC/h34Mn8NaZY2kWsT+IoLG3+H9vfw3XkWNzdT6lNA9vBHbpLJ+g3wR/bq+DHxl8RD4f3o8R/Cf4rhhCfhl8VdJbwt4iurjbnytFmmkk03WJHw7W9lBdxaxPAj3P9lRwo7LZrxv4zfAr4ffHPw6dF8ZaWBqNorS+HPFmmhbXxR4V1HIeDUNF1VAJ4vKnWOaWykaSwuzGgubeQpGyRGrnWFftaOYyzFR1lhMxo4SCqrS8aWKwWGwsqFR/ZnVpYmmnvTSba3q5f4TcSL6jm/AlHgaVb3KPEfAeacR4upl9R2VPEZhw7xdn3EGGznB0pa4jCYDH5BjalO8qWOdSKpVf0rBB6EH6HNLX5z/sW/Hbx2/iTxZ+yz8edT/tX4tfDHTINX8KeNJ98Z+KvwzlljtNP8Qs0rN5+uaSz29nrEhd7i580Ncvdanp2t3kn6MV9Ll+OpZjhYYmipwu5Qq0aq5auHr05OFahVim0qlKacXZuMtJwlKEoyf4DxvwdmfAnEWK4fzOphsU6dLDY3Ls0wE51cszvJ8xoQxeV5zllacKc6mCzDB1adamqtOliMPN1MJi6NDGYfEUKZXnfxP8Aix8O/g14VvPGvxN8WaR4Q8N2R2SahqtwUe4uCjyR2Om2MKy3+ralOkcjW+m6Za3d/OEcw28gRsW/iX8Q/DPwn8BeK/iP4xvPsHhrwdot7reqzgB5mgtI8x2tpEWT7Rf39w0Njp9qrq91e3Fvbp88gr8ifht4A8RftReKLb9qD9pKyOoQ6iXu/gn8HdQLXPhT4e+DbiUTaVq1/pkyi21fxHrNulvfyXV5blJla31CeHf/AGVY6BxZrmlTCTpYPB0oV8wxEZVIRquSoYbDwkozxWKcPfcFOShSowcamIqXhGUIQq1af1vhx4dYLibC5lxTxVmGLybgjI8VQwOJr5fSpVc64gznE05Yihw5w7TxP+yxxjw0JYvMszxUauCyPAulicRQxeJxWXZdj/bZ/wDgoZ478eSs/wCzp+yj8RviR4fdpBZ+NvHGtaX8K/DWpxoxC3ujPq9vqP8AallIPnjL3en3ePkktIpQUEKftrftYeHMXvjv9iK/u9EVs3Vx8Pfit4e8Ua1bQjLM1v4ctbG7vNSlCj5Yo5rUMwwZFJUV78qqiqiKFVQFVQMKqjgKo6AAdAOBTq8drN5PnlnuLjU35aOEy2GGT7RpVcJiK3J5TxU52+3fVfqka3hhh4/VcN4N8NYjAL3fb5xxN4gYviCpHb2lbMss4pyXK1iUtVLCcP4XCc+ssHKF4Pd+An7ZPwT/AGhrm50DwprN/wCHfiBpqSPrPwy8d6c3hnx1phgz9p/4lVxNLBqaWuM3UujXuorZK0f2/wCyvIqV9V5z05r8r/jp+zr4W+Mdra63Zzz+Cvit4baO/wDAvxR8OtJp/iXw9q1k3n6eZ7yye3utQ0tJ1AkspZS8CSSy6dLZ3TCavdP2Lv2jPEfxf8O+Kvh38VrW30r48/BfU4PDHxGs4USC31+CVZP7C8c6ZCiRxfYPEdtC8swtUW2W7R7u2htdO1HTYB6GXZrifrEMvzNUnWrRnLB42hGVOjjPZx5qlGpRlKfsMXCClVUIznTr0o1KlJxdOdKHw3HXhvkEuH8Xxz4ezzKGVZXWw1LivhTOMRRx+a8LrH1oYbA5rgs0w+HwcM74ZxeNqU8v+tVcFg8wyjHV8Dgswhio43C5hiPtyiivCv2j/jr4d/Zz+Efin4peIojejSLeK00LQ4ZDHeeJfE+pubXQtBs2CyOr3t4ytczxwztZadDe37QyR2rqfdr16WGoVcRXnGlQoU51atSXwwp04uU5P0Sbsrt7JNn45k2T5nxDm2WZFk2DrZhm2cY/C5ZluBoJOti8dja0MPhqFPmaipVK1SEeacowjfmnKMU5K78a/wBoP4R/s9+G18UfFbxlpvhmzuGki0uwbzb7XdduYgpe10LQrFJ9T1OZC8Qne3tmtrMSxy39xaW5Mw+In/b3+N3jdjdfBH9jTx1rnh2QeZZ+JPih4v0L4Y/bYG/1VzaaLfw3puradfnhnttZlDIysyKDXmvwZ+Buv+JvEP8Aw0X+0o8fjP45+KVh1DTtL1KHzvD3wk0hybjS/C/hXRp2mtbG+0uOQfab0rLcWd2Zlt7h719T1bV/sevk5Y3N8x/ewrzyjCy1o0aVGhVzCdN6xniquKp4ihQnJWbw1KhKVL4Z4icrxj/S9HhPwx4GX9m4nJcN4o8R4d+zzbNsyzXOsu4Kw+NhpXwnDuXcOY7JM3zfDYapzUVnmY51Sw+ZOHtsLk2Hwzp1sR4BH+3P+0f4QZbv4r/sUeKovD6Ze81f4W+P9B+IOpWsKYMsg8M2Vqs8qxpukLzarZxhRy4AZl+w/gP+1D8Gf2j9Mub34YeK4r7UtLRW1/wlq0EmjeMfDrlhGy6toF5tuUhSY/Z/7Qsze6TLcq8NvqM0iOo87r5T+OP7PDeJdStfi98HL/8A4Vx+0L4Rc6r4a8ZaNsso/Ek1tH83h3xjbov2TWNO1eBP7PluL+G4eKF1gu1vNLM+nzEcVnGBftViZZvQjrVw2JpYajjHDq8JiMLSw1F1EtVRr0Gqr9329H4gq8N+FfGaWW1eH8P4X5xiLU8u4iyDMs/zPhanipWjShxLkfEWY5/mtLL6s3GNfNMkzelVy2Dlink+aRi8O/10zRXy/wDslftE2/7R/wAKrbxPe6aPDvjzw1qd54M+KHhJlkil8N+OdE2R6pbpBOzXEWn3waPUNPEzSSQRTvp880t5YXbD6gr6rC4mjjMPRxWHn7ShXpxqU52avGSvZp2cZR+GcJJShNShJKUWl/N/EWQZtwrnma8OZ5hZYLN8mxtfAY/DOUKkYV6E3FypVqcpUsRh6seWthsTRnOhicPUpV6FSdKpCcjNeA/G/wDaa+EP7P1nav8AEDxHt1zVF3aF4N0K2fW/GOvMzmOIafodqwlSGaZWgj1DUZbDSzcAW5vRMQhwP2q/j7J8Bvh5DeaBpq+IviX421a28G/C/wALYMjav4s1T93DcXMCPHI+l6Sji8vQHiWeU2emm5tZNRiuI/lv4L/ASDwXdXXxF+IuoN8Qvjn4pZtR8WePdZxez2N1cxgPovhhZkEek6RYRn7FC1lDbPcwRiNUtdNSy0uy/V+EeC8sxGVx4p4sq42nktXE1sJk+UZbOlQzTiPFYTk+uShi69HEUssyfAyqU6OLzOWFxdWvipSwOBw06tLGYjA54PA0pUfreMc1QcnCjRpNRrYmcWudqUoyVKhTvyzquMnKf7umuZSlDff9sn9ojxOWuvhx+x54gGiE7rXUfiR4/wBC8E6pcRtyjSeG7y0FzbFgQ3y6hdIBn5+Qacn7cHxX8Ft9o+NX7J3jnw74fiG+88S/DrxNovxKgsYBnzLq+02whsTZ2sI+aaabVCyoCyxN8ob3CivsHLgiUfYT8N8ijhdI+1oZ3xhTzaMdLzjjq3EOJwPt7XfNPKKmG5tVhOW0Ts58A/deV0OTa8a+MVa3dVHiJQ5vN0XFv7NtD134TfGr4ZfHDw4vin4Y+LNN8T6WrJFepbtJb6npN06lhZ6xo92kGp6XckKzRpe20QuI18+1ae3ZJW9Tr8lfit8Itf8AAXiB/wBob9nRU8NfFTw8kmoeJPC+nxNH4c+K+gxMtzq2ha5o9sY7ebVbqKN5rW6gjS6vLxUbeurDTtTsP0S+CHxd8OfHT4YeFfib4YJj0/xFY77nT5XV7vRdXtJHtNY0W9KqmbnTNQhntjKI40uolivIF+z3ETH4TjLgzB5TgsNxJw5isXjuGsZivqFalj1Sea8P5rKlPEU8rzSeHhTw+Kp4rD0q1fK80w9HD0sfSw+LjPCYPE4StQXDjcDClTjisLOVTCzn7OSqW9rh63LzKlVcUozUoqUqVWKjGooyTjCUXE9YozRX5c/8FFf2rPiH8O3+Hv7Ln7N01t/w05+0Qb2DRNdmUSWvwj+HFl5sXif4paomyfy7i2ihvrbw35sEkb3dhq19DHeXmj22lal4nBXB+b8ecSZfwzkv1enisb9YrYjG46q8PluU5ZgMPVx2a5zmmJUZvDZZlOX4fEY7G1owqVFRoyjQpVq86VGp8lxBn2B4bynE5vmHtZUaDpU6WHw8Pa4vG4zE1YYfBYDB0rx9ri8biqtLD4eDlGPtKilUnTpxnOPp/wC03/wUc/Zz/Zh16D4e6vqPiL4o/GnUBEul/BH4OaI/jj4iTS3ESzWyanZWs9vpvh7zoZIbqO31vUrPVLuxkF5pmmahCCa/Lv8Aa7/aG/bm/bY/Z3+JPwO8L/sCX/w58I/Ei30G3j8U+OPjh4HtfFtrb6B4u0DxZDNJ4K1C28PT2NxePoMVnLaXd2/2YXMkizztCFf6b/Zv/ZW+Gv7NmgTxeHoJ/EvxB8QmS++Ifxa8TFtS8eePddvZvtmp6hq2sXcl1ewWNzfs9zb6PDdNawsftF09/qst7ql59MV/RVHKvCHhaP1DKeCKXiJWo2p4jijjvMuJcuo5jVikquIyfhjhLPeHY5PgKkk/q1HOMzz7Hyp2rVquGnU+qYf8rnjeOc5f1rG8RVOF6dT36WT8O4PKMVUwsHrGnjs3zrLs0eOxKT/fTwWDy7DKd4U4VYxVap81WH/BWrxR8NbqGP8AbD/Y0+MPwB8PtPFbXXxL8H6lp3xu+HOlebtC3niDV/C9jpk2k2xYnbDYR+INQcgJDaTPvEf6tfC74sfDj40+DNJ+Ifwq8aeHvHngvXYzJpniDw5qEN/ZTMmBPazhG8+x1Gzc+Tf6Xfw2upafcq9tfWtvcRvEvxrcQQXcE1rdQRXNtcRSQXFvcRpNBPBKhSWGaGRWjlikRmSSN1ZHQlWBBIr8zvHvhXxN/wAE6PHs/wC1v+zJp16Pgpe6lZH9qX9nHSWK+F9U8LT3KQXPxI8CaQXW08P+I/DIm+0vFZLb2Vrb5Y/ZPDLa/ZzZYjw88P8AxHi8u4SydeHfHdZcuR5bRzjMc04I4oxrX7rIlPiHFZhnnDOcZhU/cZTjcTnmb5Ri8bUoYHGUspp1XmMLpcUcT8KNYrO8c+KeG6b/AOFHF1MDhcHxBk+HT9/MWsso4bL83wOFh+8xtClgMFjqNCNTE0Z42UPqz/o+orlfA3jXw38R/BnhXx/4N1S31zwn408P6R4o8N6xabvs+paJrthBqWm3kauBJH59pcxO0UqpNCxaKZElR0HVV/KtehXwtethsTRqYfEYerUoV6FaEqdajWozdOrSq05pTp1Kc4yhOEkpQlFxkk00ftFKrTrU6dajOFWlVhCpSq05KdOpTnFShOE4txlCcWpRlFtSTTTsxCcAn0Ga/Nb9oD/gqP8As/fBrxpdfCPwLpfjj9pP432jz2958LvgRoZ8XXmhXVuzRzR+LPEMcq6Hon2SZGg1W1t59W1rRpFzqmj2yMrnxf8A4KBftDfE/wCI3xX0L9gL9mfxNc+DvGPibw6vi/8AaL+Luls5v/hH8KLwpFBouiT28kctr408ZRTw/Z3intb2y03UNJ+yzWya3NrOhdB8Cv2e/hT+zj4MtvBHwq8MWuiWKpA2r6vKqXXiTxTqMSFZNY8T620a3WrajM7yyDzClnYrKbTS7OwsI4bSL+h+EfDPhbI+H8p4t8SaWY5rjeIsLHM+F+A8sxv9kutks5yp4biHizOFRxGKwGXZlOnUnk2S5ZRpZpm2DgszqZnlGArZfVzL8szzi/OcxzPG5JwlUwmCw+V1nhM44lxeH+vKnj4xhOrleS4Fzp0MTi8Kpxjj8djJzweCry+qRwmNxMMTDC8J/wAPA/8AgoXq5XUtA/4Ju6Rp2jSfvILPxP8AtMeB7XX5oM5XzrZ9L05tOuHUjdb3VkXiYMrbuK6Lw1/wV20XwdrGnaB+2N+zX8X/ANlFtTvE0+28d3sSfFD4Qi8dtkcFz478LWFnNFLMxQqtloWp28EZaa8u7e2Xzz9B1l63oei+JdJ1DQfEWkabruh6tay2OqaPrFjbalpmo2c67JrW+sbyKa1ureVflkhnieNh1U19XOXhTmMfqeZ+DuQ5Xgp+59f4P4n47y/iHCQentcPieJ+JeL8lxNaCtPlx2RVoVZR5VKhGba8WK40wrVfB8d5jjMRH3nhs9yjh3FZXXlvyVaWVZVkuPowlqlLDZhTlBNO1Rqz++/Cnizwz458O6P4u8G6/o3inwv4gsodS0TxD4e1K01jRdW0+4G6C807UrCae0vLeQfdlgldCQRkEEDoa/nM0HWdb/4JX/F3Q/GHhS/1W+/YN+L/AIts9B+KXw+vbi81W1/Z78Y+IbhbbTfiN4RkmkuLqy8KXd06x69YhnWSBGsJRf6kfCa2f9FtvcQ3VvBc28sc8FxFHPBNC6ywzRSoHjlikQskkciMHjdCVdCGUkEGvxbxL8O48EYnKswyjM5cQcG8T0cTiuGc+nhVgsVN4GpSpZpkmdYGNXEU8v4hyStXw8MxwlLE4nD1cPisBmeCxFbA5jhpv9A4R4qfEVHGYXHYRZZn+T1KNHOMtjVeIox+sQlPCZhl+IcKcsTlmYQp1ZYWrOnSrU6lHE4TEU4YjDVETVHLNFDG8s0kcUUSs8kkjqiIiAs7O7EKqqoJZmIAAJJAFSZr8If2xPip47/bW/aA8U/sR/CXxXq3gz9n/wCEq2TftbfEfw1ObfWPF2t6jmW0+B3hrUk3JbwNBFNF4tl/eJJcwarp+pW722iNpPibz/DrgLF+IGd18EsfQyTI8nwFXO+KeI8XRqV8LkORYetQw9XFfVqTjVx2PxeLxOEyzJ8sozhVzLNcbhMKqtClOtiaHVxVxNQ4Yy+niHhqmYZhjsTDL8nyqhONOvmWYVYTqRpKrNOGHw1CjSrYvHYucZQwmDoVq3JUnGFGp9CfFn/grV8FtB8X6p8Mv2dPAXxF/bA+JWju8Oq2HwW00XXgPQblGMfl+IPiVcJPo0Fu0n7v+0tCsvEWmRSrLb3N5BdRPBXl3/Dfn/BRWVxqMP8AwTd8PR6UR5o0u4/ai8BDXWgOGCmf+zYoI7gpkGKTTt6OQrR5UqfZPhn8LPh78G/COm+Bfhj4T0jwd4W0tAttpmkW4iE02xEkvtRunL3mq6pciNDearqdxdajeOPMubmV+a7+v3enR8JMlX1LJvCzL+JcPT9yWdeIHEHF1fO8fZe9W+pcG8R8J5LlMKrvOng6eHzKvhYONGWbYyUJYir+bSqcb5g/rGP4yxOU1J+8sBwzluSU8Bhr6qn9YzzK85x+NlBe7KvOphqdZ3nHB0FJU4+M/Dr/AIK6fCtfE+k+Af2qfhN8T/2OvGOtypa6VqHxRsRqfwr1a8ZlQwaZ8UNMtrWw8qNyxn1TVdH0jQbWMBrnWImJRf1ksr6z1KztdQ067tr+wvreC8sr2yniurS7tLmNZre6tbmB5Ibi3nidJYZoneOWNldGZWBP5qeOfAfgz4meGNU8F+P/AAzo3i7wtrUBt9S0TXbKK+srhSDslVJVLW93bsRLaX1s8N5ZXCpcWk8M8aSL8a/s3fELxd/wTt/aA8E/s2eMfEmr+KP2Nf2gNek0H4E+IfEt3PqGofAr4oXspls/hle6vOzO3hDxRPKINEW5ZY4b2ePUYltza+ML++8fPPDPg/jbLMyzDw5y/G8L8XZTgcZm2I4Fr5jXzrJ+Issy+hPF5lV4PzHHKWcYTN8uwVKvjp8O5xis4qZng8NiamWZv9epUcqxXfl3F2fcPYzCYXirFUM4yPHYmjgqXEdPCUsvx2V4zE1I0cLDPcLh2sBWwOJrzhQWaYGjgo4SvVpRxeCWHnPGUv3/AKKM0Zr+Yj9gKOp6ppmiade6vrOo2Ok6TplrPfajqep3cFhp9hZWsbTXN5e3l1JFb2trbwo8s9xPIkUUas8jqoJr83fGP/BS/wADXWsah4b/AGdfhZ8QP2j9V0yc2l7rvhuFfC/w4trpWKNbv431i1uQ7BhujuYtGfS7uLbNY6lcwsJB83fGPx5rH7c/xV8SeDbHV9Q039kr4ReI20LUbfSbuazf44+P9HkR78XV9aujt4M0K5EYtI7eVkuV+z6pBIb7UbSfw575oehaL4Z0qx0Lw9pWn6Jo2mwLbWGl6XaQ2VjaQr0jgtrdEiQEks5C7ndmdyzszEA58fty/tf2zteXv7E2kT6cuXex0/48+F21ZIsZIV/7LuI7iVRj93DZ7nIKqoLDHs/wl/4KKfBrx14msvh98SdH8Xfs+fEi/eKGw8N/FjT10nSdauJWEccegeLVb+yLxZZWWG1bU10STUJ3SDTobuV0VuNrh/iD8N/BXxS8OXXhXx1oFlr2kXSuUS5j23VhcMhRb7S76PbdabfxBj5d3ZyxS7S0bl4XkjcA/WcEHkEEe3NLX5L/ALG/xn8Z/B/4oW/7Hvxi8Q3vinRNW0q81f8AZy+IusuX1LVdG0mJpdS+HGvXjfLc6toFjE8+kSOVdLO2ezUrZ3vh3T7b9aKACuF+I/xN8BfCLwlqfjn4k+KtJ8H+FdIQNeatq9x5UZkcN5NnZ26LJd6jqN0VKWemadb3WoXsg8q1tppPlrpNf13SPC+haz4l8QX8Gl6F4e0rUNb1rU7ptltp+laVaS32oXtw+DthtbSCWeVsHCIxANfhXpkus/tr+P3/AGhfi3a3LfCbRtSv7L9n74SamN2j22iWly1s3jvxRphLWuo65rk0Bl8u5W4i/diENcaRZ6QGAPo3VP8Agop8S/iFJIf2Zv2Z/EHi3w0WcWnxI+KmuW3w+8OaiiuUW80bQ5Fk1LWdOmILRXEOq2t2q4W40+CUOkfzJ8IvF37Z3wP+MP7T/wAcIvgv8LPHWo/tU/ETwB8S/HXhXS/H02h/2Fqnw7+CPw2+BOl6d4RvdUeWOCyvfC3ww0fVL8au+s3D+IL/AFKa1mg09rXTbb7GVVRVRFVERQqIqhVVVGFVVGAqqAAAAAAMDinUAdn8GP8AgoT8L/iF4osfhp8T/Dfif9nz4r6g8UOn+FPiPHHDoniC5mYRxw+FPGaR22mauZpyILNb230ebUp2WDS4L2UlR9+5zyORX5G/Ez4W+Cfi74Yu/CnjnRYNV0+dXa0udqR6po14yFY9T0W/2NNp9/AcFZY8xzKDb3cNzaSTW8nZ/sNfHHxtonjDxF+yF8a9cn8Q+MPBOip4l+Efj3UXYXnxE+GCzC0W11CSaR3uPEXhd9ttMxluLq7s4b5ZGnTQZtT1AA8B8MX8nxL/AGvf2tvirqe64fwp4vsvgT4TEh3rpGkeBLdYPEVraZz5cep61bW2qyhcYuZ7lukzCvo2vmr4VQSeE/2if20/h1qOIdTh+PGp/E2CF8LJcaN8UrYa/p9xEuf3kK2q2hd0BCNcxK5BkUV9K0AFFFFAFLU9NsdY03UNI1O2ivdN1WyutO1CznUPDd2N9BJbXdtMh4aKeCWSKRTwVYitn/gl54g1A/ATxf8AC3VLx72f4EfGj4ifC2wmmbfcSaHY3trrmnSSNgZRbjXNQtbdckRW9rFCgWKONFpMwUFmIVVBZmY4CgDJJJ4AA5JPAFfIP7H/AOwV+yz+174W+K3x3+PPwpPjy88X/Hn4mP4C1V/GXxD8MRDwLDfWbWxhtvB3izw9ZXaya7PrqPdXNvPceZC0KzeXGsaAH73E4BNfg/8AsuXz/ECf42fHzUj9o1r4zfGLxdqdvdv8zweEPD99LpPhbRo3I3fZtIiF7a24yP8AR1gRgTEGP1Sf+COH/BN7Bx+zhED2/wCLsfHI/p/wsw/yNfJv7Gds/hn4c+Lvhbejyda+EPxZ+IvgLV7STi4insdfnvEmkQkt5czXs0cUp+WVreUIW2MaAPrqiiigArhfib4LsfiL8PfGXgfUY0kt/E3h7UtLUyKGFveTW7tp16gYECbT9QS1vrdyDsnt43HK13VYniXXbHwv4c17xLqcoh07w/o2p63fSsQojtNLsp724fJIAxFA5GT1wKAPef8Agnl8QtR+JX7HnwV1zWJ2uNX0nQL7wVqEkjF5mbwJrepeErB7hyMyXE2kaRp1xPKxZ5JZmeRmdmY/T3xI8Wx+Afh5498dTRrLD4L8F+KfFksTkhZIvDmh32sSRsRyFdbMqSOQCcc1+L37Gv8AwS//AGQvjR+zd8Nvip8evgp/wlfxJ8c2mta9qOry+Pfij4eMuj3PiTWF8LhNM8L+NtE0iOJ/Dcel3EUsNgkk6TiWaSWRmc+7eOP+CO37Bdt4K8X3HgD9n9NK8eQeF/EE3gnVE+J3xkvn03xdFpN2/hu/Sy1P4iXmm3jWesrZXC2uo2d1Y3BjEN3bT27yRMAeF/sd6DPp/wADdA8TarK974o+Jmpa58SfFmqzYa51bWfFOp3Fyl7cPjLSPpkdgHyceaJZAFMjCvqOvmz9kLxDb+Iv2c/hdPCwEuk6E3hm+gPEtre+Gr260WWGeM/NFK0dnFcBHAYwzxSYAcV9J0AFFFFAHzt+1d4Qi8Y/AL4iw/NHqPhvRLjxxod5ESl3Yax4NRteguLKZcPBczW9ndWAljKuIb2ZVZS2R+rf7P8A49uPij8DfhF8Rb1lfUfGnw58H+ItVKABBrGp6FY3GrxqAqgLFqb3cYAVQAnAA4r8wf2kfEVp4W+Avxb1e9kWKM+BPEOlW5cgK2o+ILCXQNLi5IyZtS1O1i2j5jvwvOK2Pgt/wSK/Yd8SfCD4XeIvir8A/wC2fiVr/gDwlrXjrUp/iP8AF/SZrnxTquhWN9rPm6bovj/TdKsnhvZ5rdrewsLW3jMWEhWgD7n/AGz/AIjX3wo/ZY+OPjnS7mSy1bTfAmo6bo19ExSax1nxRNbeFNIv4GwcT2Wpa3a3UOQR5kK7uM18GfAHwRZ/Dv4M/DjwpaQpE9l4V0q61IqoXz9b1a3TVdbuG4yTNql7dsm8syReXHuIQVzf7Uv/AASl/Yx+G/7PPxc+IHwV+B3/AAi/xL8FeDtQ8U+Hdch+IPxX12Sxi0JodS17ZpPiPx1rGjXhuvDdvrFmVvNNujELgz2yx3cUE0fo3wq8R2ni74Z+APE1jIklvrfg/wAO6guwgiOWfSrVrm3fBO2W1ufNtp0JzHNE6NypoA76iiigAr5J/bFS78O/Dvw58ZNCHleLfgX8Q/BXxC8P3cfyTYh8Q6dpt9YNJgk2N4Ly1nvoCDHOlhGsquilG+tq+Tf22L6QfADxB4ZsYzca74/1/wAG+CPDdiuDNqGsap4n0y7SzgTILzSWOnXzIq5O5QSNoNAH7q6ZqFvq2m6fqlmxe01KytNQtXIwXt7yCO4gYjsWikU496+C/wDgph4u1bw/+yzrvhjQrlrLV/i34u8G/CazuVLBhD4p1T7Rq0Bx1iv9E0vU9NuFP3oLyUAg4NcDaf8ABG//AIJ1i0tRqf7PUd/qQt4RqF8fin8bYTe3wjX7XdmG3+JMMEJuJ/Mm8qCKKGPfsjjRAqj5b/bG/wCCeP7KX7LXwjs/jv8AAH4Pf8IX4o+HvxD+H2r+INUg8bfEnxPLceDn8SWlpqNh/Z3i7xjr+mokmrXGh3DXcNnHeQ/ZdqXMdvLcpJ4vETmsizdwbi/qGJ5pRveNL2bVaSa1TjS55J9Grn6x4E0cLiPGXwypYuFKrCXGeROhRrqMqNfMIY6lPK8PWjNOE6VfMo4SjUhJOM4zcZJptH078Tv+Fj/Bn9nTX7X9mn4W6Z8V/iV4D8CWuj/Cj4Yav4r03wLo/iXWbGG00rS7bWfFWphbHS7C2Qtq+rTOUuL2C0ubW1kS+u4ZB+JX7H3h39r74K/8FirH4SftM/tefFL4/wCv/Ff/AIJt+NP2kPid4JXxZ4lsf2bPBHxZ1D9pnwf4KtNH+BfwfuLxNA8KeFPBHhLT4vC+ha3d6YfFmv8A2jXvEesXNpd+KL7S7b+gTxN8QfAvgrwRq3xL8Z+MfDHhD4d6BoMvinXvHPinXdM8P+EtD8NQWovZ9f1nxDq1zaaTpej29mRc3Go313BaQQfvZZUQE1/OfqP7ff7C8n/Bdfwx8Yk/bM/ZXf4SW/8AwSs8TfDif4nr+0B8Kj8PoPiDcftW6J4kt/A03jEeK/8AhHovF8/h6GbXYfDj6gusSaRFJqSWZs1Mw58HFJ+zpwi4ewrJWjzcsI4TEOlGO6jFzjFxsk5SjFXaSie7n9adTFUsXjsXW+uTzPD1K6xFfknUrVcdCWLr14ycZ1arcqiqSquUYc1R8qlKbf2l/wAFDPHHxZ+L/wC1b+x1/wAE5/hN8ZfH37PuhfHrw98Z/jd+0b8WfhFq0Phr4v6b8GPg3p2h2ej+B/hz4ultr2XwbqPxF8b+I4LHWPFunQw6zoml6LnT554bvUNOvPFvAum+L/8Agnd+3d+xz8KfA37UXx0/aN/ZD/b3tPjR8PJvDn7Q3xcvPjvq3wm+N/wo8Fn4h+E/Ffw0+JGt+f4jj8NeOtO03XvCWv8Ag+XUbrSbTXd2tFpJ5bWDSqf7c3jj4M/D79vb/gnl+3R4/wDF/hfUv2LPjR+z/wDtBfsn+Nvjvp/iCC9+E/hqH426R4b8c/B7xHrXj3Qrx9L07wT8UFsNf0LTPHEGqRaFZF7bUrrWLCwZNQTwDwF8Ov2M9T/bc/4JWfsbf8E3tf8ADXxG+Cf7C2t/tOftT/GnxH8OviPP8Y/CnwxsPiF4N1fw94F0PXviSmteJNOuvFnxE+Jfi++mt/C/9vNqml6Dpst9/ZsGmCBj1UIxVOguW3Mq6xC9mmtKmIjU9s3rTdHCxoVKMf8An5KNRKM5Nz8jF1JPF4mopQlWhi8CsHJ4icaipVIZbKlHD0YJxrUcTWq46GJmmlywlFucIL2X7aftISn4c/Gf9kv486Z/o2oaF8ZtH+F3iKeEbXvPBXxKhu9P1SC6IH7+Kwt4dSeyic7YbvUXlTbIwkT9lB0H0H8q/FT9tbQtO+Jb/s5/Aq7tRqLfFj4/+EbPU9MWaeGSfwZpUF7D4xuRJaTQXkMNnYa1bvcXFrNFPBC7vFJHL5bj3Qf8EcP+Cb2Bn9nCLOBn/i7Hxy/+eZXBkLax2eRj/C9tgajVrJYmeDjGr/286FPCOXWzi3ufT+MyjU4N8H8Ridcx/srjHBUpS/iy4ewnE86uVXe7owzfGcS0qN9IunUpxdocsXf8FJb6XxRY/s5fAPzZItK+M/xt0dfFkUbFTqHg3wQkOra1pz8Y2yXOoaXfRtzsuNPgbBXKnjP2tNX/AGofD3wVu9O/Yx8B+A/Ffxt8RazoHgvw3ffEbxBB4d+Hvwr0jXZmsdV+K/iSwjjfUPFekfD6zC6oPBHh9DrOvyiC1sopoo5raXwr9oP9i39mz9iv4g/swfFr4FfDZPh1o198bNO8GfEK8Pi3x14mgng8RabdQ+Hry6bxn4n8RJp1vpfl65I89iLTzBc4u2m8u3Ef2l8U/i98KPgb4Nv/AIi/Gn4meAfhF8P9LudPs9T8cfEzxfoHgXwjp13qt3Fp+l2194j8T6hpej2lxqN/PDZWMNxeRyXd3NFbQLJNIiHkeud5zKorzjUy2lTi7pvCrB0qlOF4tS5Z4qtjY2hJSu5crUnc+hShT8H/AAoo4ao6ODr4TjrH4+pTcYqHEVTizGYHHVZOUZU/rFPh7LuFbyqKTVBYfmXs+VP8Tv8AglVo/wAdPhR+31/wVB/Zq+MX7Vfx5/aot/g94T/YV17TvE3xq8ba1r1nZeM/i58Nvib45+J+oeAfBdxqF14Z+GPhjXfE1yiaV4P8J2ttY6R4d0jw5oc1zqX9iW9230L/AMFDvBP7cXxt1TxD8Ofhb8QdZ/ZV/ZN+Hfwj1f4vfEz9oL4V+OhpX7RPxg8a6HZ+ItS0X4FfDO40hotZ+D/hjSbjQNM134lfERpRrPiTS9X0zwr4Skitn8VGvg39kv8Ab6/YX8Nf8FZ/+CuPxK8R/tmfsr6D8Ovib4U/4J+23w48eaz+0B8KdM8HePrjwV8G/HmleMYPBniW98Vw6N4nm8Kane2eneJItFvL19Evrq3tNSW2nmjjb9ef20/2vf2UPgp8MPib8PvjH+0z8AfhR488Y/A7xzrHhLwX8SPjB8P/AAR4r8UaTrPh7xLoukan4e8PeJfEGm6trOn6rrFhfaVp15p1pcW97qNndWVtJJcwSxp6Fb2lqVV07zeGhJR9naPtFRurQikm6b95Qs4pxXNFpWPgsC8NUwWIovFctKnj8XGTWJXP7FY6oqcZ1pylUUKkUo83Opzi7RmrnD/8EgfHfjf4m/8ABMr9i3x/8SfGHij4geO/FfwQ8Pat4o8aeNdf1XxT4r8R6rPcX6zanrviHXLu+1fVr+ZUQS3l/d3Fw4VQ0jBRXtt5Ofhh+37+zx4y04m2s/jn4S8c/CbxmkKhY76Xw9YQeIPDV1coB+9u31RtHs1nYmRLHThEpCIVf87v+CFf7VH7Mnin/gn1+xL+z94Z/aI+B/iH47+H/gJpkWvfBbQ/ir4G1X4raLLor311rEerfD2x1yfxZp8mlW0iXGpLd6TE1jC6yXIjRgx+0/2ifhj4L/aS/aj/AGXP2e/G2jL4n8H3Fl8TPG3xH0MahqumbvCkGjW6aX59/oN/pmsWEOo6xok+nrcWV9aymdokWYKXB4s8i4V6Uox5akc8y14a0bazzWjRlybe7KhOtTm1p7N1E7q6P0fwsqU8Ths7oYioquWYnwn8Q6edtzU4LD4bw9znMKE6zbkvbYbOMLleKwsZ+9/aNLB29/lv+3Vfld+2hN/wsP8Aax/ZO+DF6xl8NeG7bxd8cvEenNhrfUNQ0OKXTvBkk8TqUkWx1TT9RjZGyr2+pXKMPmBra/4c4f8ABN7/AKNvi/8ADsfHL/55tfM3iT9l34G/sVftjfs8x/BTwQvw88A/Fvwj8RfDV9at4j8W+JLebxvp1tBeQzPf+MfEHiC+tp9TtZtE0y2s7e7htZZYg0VsZ3uJW9DiV/8ACdTi/wCFPMsqhX7eylmOGTUv7kp8kKi2cJSUrxbPz76P3LHj3G4in/yMsHwF4k4zJdLzWaUOB89lGrQVm/rWFwf1zGYSUf3kMVh6NSm1UjFnVftu2f7aPi7wn4K+En7GT+E/AGs/FfxBfeHPij+0x4qv7C+l/Zt+HcGm/atS8Y+DPhzO0d38RPiPrqmXQvAtmJYtE0LXWt9V8SyQaYPtlp8S/wDBETUfiTb+EP8AgoT8MfiN8cPjZ8f1+AH/AAUy/aD+BPgTxv8AH34l+I/ip4/j+H/w+8D/AAes9D0y68SeJLu5mjgNzc6lrE2n6ZDp2kJq+r6reWmm2rXsyn9VvjN+0R8Av2c9E0rxL+0F8bvhL8DfDmvaqdD0TX/i98RfCPw40bWNaW0nv20jTNT8Yavo9lf6mLG1ubw2FrPLdC1t57gxeTDI6/gp/wAEdP21f2OtH8ff8FKPCurftW/s4aZ4n+N//BXz9pDxL8GfDt/8bfhtaa38WvDvj7SvhDongXXvhrpVx4kjvvHGj+M9Yt7jSvCupeGYNTs/EGowTWWlTXdzG8YVHnlDERjC6eHb5lBylKp9cwCilJ3s4wlUtGNtJzbvdsnGSo0syy+pPE8spVasHTnWhCnSpfU8S1an7q/eVFB+0qc0nKEIxklFRPvP42fsIfH/APax/aN+JPib46ftc/G74Ufsv+HtG8HaP+zh8GP2PvjD4v8Aglrt1qTaU8/xE8ffH7xZoui6drPibxNL4jKWngfw7pOtXvhPRPDttb3M8cms3Oo+fxX/AASL+J/xj1S7/bo/Zt+JvxZ8YftE+Fv2NP2tNd+B3wl+P3xBvbTW/H3i7wePCmg+JJvBPj/xZYwQReM/Hnwv1DU5NF8TeKLuOPVtQm1G2i1C3tBa29tF4z+37/wVF8Kv8ePEP/BPL4G/tTfAT9k74iaPp2kzftMftafH74j+AvAOm/s/+F/E+m22qWnhf4HeE/HviHw9dfF74+6/4fv7fULC505JPA3w3tL6wvvEWsjX7q3s9J+7v+CdMv7A3gn4L23wA/YQ+Ovwd+Nfhz4XLHrHj7Vfh58ZvBHxm8car4r8cXmo32p/Ef4veIPCes6pd3njL4ia1Ya1qN1rWrxWMN9NZXGm6Ja2ejaLZ6Xp9R51h5uUbwnSjGjFQ6qrTm8TJpaXhGpTjKT5qirNxtTjFuIvD1M0gsPX/eUK9d4ypPEXlWlKjUhHAU6Tl78aM5U60uSChQeHjTTdWVXlwfFP7XP7PH/BN/8Aaz+Jvj/9pH4n6X8G/gR8cPhn4V8Qan4l1bTNf1PR4Pinpuv3Xh/SoTZeGNG1vUorjWNPt9furi6Sx8qa+vQ11MGePHcf8RG//BE//o/r4bf+EX8ZP/nbV+X/APwWJ/4J5fG7/grb41vv2WP2dfF/wt8G+JPh54H8DeL/ABd4k+LGp+K9M8LWMEXijVdRGiLc+DfCPjXVDr+oQ61oN7p9rNpMFo+nw6nNLfRSQ28Nz+C//EFD/wAFJv8Ao5T9h7/wsPj1/wDQ/wBZ8N3WGx8I/wAGGb49UOyjKUKldR8o4yeJVtLNNJKx1+PqhLiDgvE1LPNMZ4X8FVc4b/iSr0cLisDlE6z+J1KnC2D4fmpSvKdKVKd2pJv+yD4aftTfAT/goX+014Y+M37PPxH034ufAr4T/C3Vx4O8U6Vp+uafpF38QtX8RzaJ4juoLHxNpGjakJbGzQaa8klgiLeaPDNbyybA4+sfjv8AGnwl+zv8JPG3xm8c2HjDVvDHgXTIdQvtH8AeENd8e+NdauL2/s9I0nRfDPhLw5aXmq6zrGr6xqNhptpEkcVnbyXX2zVb3TtLt7zULb8X/wDgjZ+wb8Zf+CVq2/7Hf7Qfir4a+LfGWp+A/Enjjw94k+FmpeJ9S8Jarpl/8QtR1RNNgufF3hXwdq51qxN1rMuoWv8AY/kRWtrDcRXUySnb9vf8FXP2qfij+xv+xd44+NvwftPDEPjC28Y/CvwR/wAJr440q+13wN8JtE+I/wARPD3gnXfi14w0bTrvT7jUtE8C6drU2ptbSahaWP2/7DLqbzabFd2lz/UnE04YXKOD44d8uCocA8NTwThFSiquLwjxmbOMXKnBt8RYrNvauUoxVb2jqTVpSPy7EtKlgUtKUMtw80tWv4cqteVlq37Z1eZL3m04rWxz/gH/AIKa6de/Gb4R/Bf9oL9kn9qf9j/Uv2h9R1DRPgH4v+O+jfCq58EfELxRY6RPr8XgHUNa+FXxU+I7/D/4karo1pe32j+DvHFro1xqZsLywtLyXVEisZv0+r+Qb9s/xlrfhX4w/wDBMnxV8V/+Cv3gX9s3wh4Y/wCCi37OXxF8YeFdN+Hn7Knw6+HXwk8L/wBj/EOwT4z+JfH/AMILN9X8IeFkm1CTwvoFt8QvHMuh67Br2o3UNzrd94alvtP/AKGv2mPjV+1B8ONL8YfEH4M/Db9n7xB8Gfht8I7r4r6747+Lnxq17wc3jibTrTxFrOq+DvCNv4U8A+L7DwvZad4c0Ow1Ob4k+LNRuNGnn8Tadaaf4avrXTtX1O1+PwuP9zFPEOTWGr8nMoQnNU3h6Vfnq/V3KkuW9Vc0LRajGNva3i+CDk58t+ZunTnFNR5m5znTaioOScbxi05WklO8m42m/t+vzL0z9v79kP8A4JofFD4+eBP2s/jboXwO+HXjbx5onjP4T3Ou6L4r1XT77W/E/hwav4z0iwi8JeHtflsls4/7HFvFcRW1t5NpIIWaRXB+7Pg58Rrb4w/CL4WfFyz0LW/C1p8Uvhx4I+I1r4Z8S24tPEfh228beGdM8SwaFr9qvy22taTFqa2GqQLlYb63njBIUGv5qP8Agrj/AMEif2kv+CzvxV8R6P8As3/EH4JeA9K+AnjbSLTxPq/xi1nx1pdrq+qXPgiDSBpvh1vBHgHx01zdaRf2etJra6iumC2WXSxbm7ee4Fv9hh1Cpwb4k08R/ui4Zy3FLm+GOZ4fi/hujl04br6w44nG4aPL7zw2Ixdvc52ddKUZ4DMm3em8JQqxfT2n1vDKk9dpWqTW1+VzTtqfs1/xEb/8ET/+j+vht/4Rfxk/+dtXz7+yV8U/BH7ZH7V/7W37avgnxDB43+HmpS+A/g/8BPFNvb39vYS/DHSPD1nreoX+j22r2djqdnZeLb5tG8TiG7s7S6jl1C7EsMf2h41/lZ/4gof+Ck3/AEcp+w9/4WHx6/8Aof6/ow/4I6/A7xz+xh4e+N/7Cnxd1PwxqXxU/Z+1L4XSa3qHhG51O58NeIbHXPhroun2eu+GZ9c0vQtYvNGns9C024E97ounzxHUoI7i3hkkVK28DFCnw/4z4rD2/tSnwTkeGi4/xaWSY3jzhilnNWl9qKnXjlOCxE4WbwuNr0Z3pVqif4b4jPmzPgKjW/3SXEOY1eV39nPMKHDmbzwEZ9HKMHjK9JS/5e0YSj78IMpf8FRfDn7dPxK8K/tDt4B+JviP9kz9lX9nH9mz4ifHEfFL4OeP5NG/aB/aM+LnhX4ceLPFnh3wBpGs6BLBrHwf+FXgfXNE0+58f3Ymi8SfEIS2+gaPNDod/ql5pv3N/wAE9PFPizxt/wAE/P2KPGvivX9X8ZeOPFn7Iv7PPibxF4n8W6zqOsa74o8U638IfCep6rrniTxBqL6hq2p6rrOq3M99q+r3sl9qF5dXFxeXDXFxI5fxL/gp1+1f+y78Mf2Vf2u/g18SP2jvgV4A+L3iz9kn45xeFvhb40+LPgPwv8Q/Ecvir4W+N9F8MR6F4M1vXrLxFqz+ItXik0rQ0sNOnbVdRjeysRPcKYxy/wDwSc/as/Zh8c/sQ/sZ/CHwT+0V8D/GXxZ+Hf7FfwGl8ffDDwp8VPBHiP4h+Ck8G/CnwPovi1vFXgrR9cvfEmg/8IxrM0Ok6+NT022Ok6nLFYXwgu5EhbyqE6FLOMbBYvndTCUZz9piIycayxGMUqcIpqNP2NKEY8kYRahBTqc03Ocu+rGrPL8LP2HLyYipCPLRaTpqjhWpylZyn7WcpScpSacpOMOWChCPzP4//wCCef7Rr/Ab4xftNftOf8FHP2ofBn7Wvh/wx8Ufirba18APjr4l8Bfsm/BpfCtvr3iLwf4W8K/B+90bR9F8Q/DfRtC0zSrXxo/jrTm1/wAX2/8AbEmqalb3VwL4fot+wH8VvGX7Wn/BP/8AZs+K/wAdtBtf+Ew+NvwG8O6j8R9Nl06Ow0/xHJr2jSadqWsrpMccVvZ6X4408jxJbWFtGtlBYa7HBaD7KsRr8WfiH+3t+yv/AMFTvGmqeBPiR+2z+zp+zJ/wTa8GeJzZeJfBHjD9oX4Z/Db9oT9uXVfDWqJI2neIvDuteLNK8XfBn9mZtSs1dtP1Wz0n4h/FCxijne18P6TqVrPpH9HHwb8f/Bj4jfDPwx4o+AHjP4beOvhBHYPofg7xF8JfEPhvxL8PF0zwrLJ4dk0nw7q3hK7vfDv2Pw7Ppc2iPZadceTpc1hLpzRwvatCjyapRWKniMuruFGNOiqFsROdevWpVHL6/wArm6lN3lThTrPlq15XqySh7CU4zGNR0I0sXS5qjlV9qnRjGjTp1YQSwmkVCXKozc6avTpL93G8nVUcb/gjX4g1Oz/Zy+JvwK1m/m1C4/Zh/aR+LnwW0i4uGMlxL4X07U7TxFpEskhUFkN5r+s29qpJENpawQII4Yook/XB2CqxOAAD16dPqP5iv5v/APgnx+wL+yN+2n4Y/aK/aU/aD+Bfhf4qS/EX9q34yXXwy1zxDPr0LD4cW9/p7Wb2H9k6vp1vLbXGv3OvJJI8cjfaLWVFkCrtH6At/wAEXf8Agl0VYSfsafCy4TBzFdSeK7uBiOV8y3ufEksEm1gGTzI22uA64ZQw4PpB06NPxo8QuSMYVa2e/WszhCMYqnnuMwWExfEUOSNowqQz6tmUKkPd5akZRajblXT4YTqS4A4Y5m5Qhl3scJKTcubLqFevRyuSk3eUXl1PCuEr+9FqV9T4j/4J+XJ+J4/aW/ap1cm78SftD/tC+OtQs7+X55bb4e+Db59C8D+H4ZGG8WmhxNqdlAMgNaxWaOpa3Vj+Un/BaaX/AIKGr+z/APteftLL8a/Hv7HvwT/Zak8E6T+zf4I/Z7+KepaB8RP2gdd8V/Ez4deDte+Mvxp8deDbzTtR0XwHb6D4r1jSfA3wdtLqC9GuRTeJPFsivpWkw6r+qv8AwTKtz4Q+CvxE+CN+v2bxH8Afj/8AF34Y67p8ny3MElj4kl1K3uXiJL/Z7lr+6ht5iPLmeyuBGziJmPwT/wAHAv7WH7Lsv/BOL9sn9naL9o74FSfH5LL4S2D/AART4s+BG+LaX1v8aPhV4ouLNvh0uvHxct1B4ajk8QS250gSx6Kj6o6CyRpx+sePsaVPjbjanSryo4DL688Fw9Tp1fZUpZDlmW4bB8KKhbllPD0chw+WywdOElT9mqUlCSjC3xvhdzTyLh2U6aqYjFRp181qTp8845jjMbOvnbqc14wqVMxq4uOInJcyk6seZNyP3m1608S6r4I1mx8I69ZeGvGGo+FtQtfDPifVtFbxNp2geJLvSZYtG13UvDw1PRm8QWel6nJb395o39saWdVggksv7SsvP+0x/wAzf7bPwI8XfsVfs56z+0B4U/4Koftb/EH/AIKJ+F9U8GN4c8I6l8eovEvgf4+fGLXfE2h2V58HtD/Y0s4Lvw/J4R8QDUtQi8O+A/D2hSXnhfT7e01a+u72y0nUJJv3E039vT9kvXPhF8Vvip8J/jd8P/2jNH+A/gQeNfiPoH7NHi3wz8d/G2kaRFp+oXNrF/wivw61jW9RS91ZdG1VNLjvVsre4OnahNJdQWmn39zbfh5/wUA+JH/BILxX+zx8VP20f2Wfi58D9P8A28/F+jxeMP2dfiR+zn8QotN/aw8T/HzWUsrDwR4fufAvhPWE+IOryeIdRa08L+PvBXjPwjcWSeHrrWLPxHpNq8O+D8xzuph506lWnWoutSw06sJRxc4V6dPnlargaMH7KtipTpyhScpQ5qsYUpS5G4v6zKoVoyo06lOqoSqU4yhKgnTnU5IN08XUlHnp0eWcZVLKTVNyqRipJSP6HfiB4Aufjp+zx4h+H3xD0W00rWfiN8MDp3iHR0kW8tvDvi3U9BjuP9DuCZFmk8MeJ/KutOuw0mLjTre5UsQCfYP+CUnxa1D4sfsD/s+634kvRN4h8N+HdV+HGrvczK10W+G3iPV/BektdO5DyXU3h7RtIuLiV9zyzTPJI7uzO3kXg3xv4r8N/s4eFPiP8c7a20HxzoXwT0Hxp8YLOAQ29po/i3TfA1prfj+0gVHa3it7DWYdWghVJGiSOJFV2UAn5W/4Juf8Erf2HvjV+xz8JPi9+0z+yB8Dfip8WPiSnizxZqXi34g/D7R9f8RXOg6h4z19fCEL6jfwSXD2A8Lw6Vc6chYotpdJs4Ir7fi1Qq+BGfvFr/c/FTgiWR33jiMx4V4+jxDTw6drQq4bLMgnjXFfFhctVTemfOZHeHiPlioX/f8ABmfrMLXtKlhc54beWSqaO7hVxWZKhd3Ua2Jt9pn7p/Fz4jaZ8Mfhd8SPiJdXFnLH4B8A+L/Gsts9zGv2iHwt4e1LXHhIVjIRMtg0fyAtzwCeD+Jn/BNjwhcaH+yv4U8b63M+oeOfjdrfiv4zePtdnCm713xB40128ngv7qRRl5H0O20nzAWKm5NzNGqeeyj6S+KP/BGP/gmz/wAKs+JNt8Mf2Ev2YfDPxGuPAvjCPwB4p0f4ReELfxH4b8ay+HdQj8La3oGrtpzXumarpGu/YNQ0y6tJ4pLO+giuoWjlXzK8J/4JzeL7Lxh+xj8DZ7ZwLnw74ZuPBOrWjfLcafqng3VtQ0Ca2u4id8E0lvZWt8scgVzb3kEu0LItcXhgo0vBnjurhLrE4nxF4FwmcygvfjltPh/jXFZRRm17yw2Jx8cwr1Iu1OpiMvwk5qVShRt0cYtz4+4bhXV6VHhbiOvgFJPleLnmnD9HG1I96tPCyw9NPSUKWIrJe7UmfjB+2vN/wUQ0f4q/skftR/Gf42+Pv2ctB8Y/8FO/2W/2a/hn+x38DPipqdr4EX4C+J/iNrY8UeKf2h/EfhG8sbD4weO/ivb+FtLmh8OTGbwd4J8FXs2hGyvNW1zXYNO/pzvLu1sLa6vr65t7KysoJ7u8vLuaO3tbS1to2muLm5uJWSGC3ghR5ZppGSOKNGd2VVJH853/AAWM/bU/Y78RWv7EHg/w/wDtWfs4654s+FH/AAVd/ZD8TfFDwzpHxs+G2o+IPhz4c+Hvi3xdbePdf8daPaeJJtQ8J6N4Kuf9H8V6nrtvYWXh6b91q01o/wAtfYH7dnjHxl+3j+x5rXgv/gmz8QfgV+01pni34seFvh5+0E/gL9ofwrpWnXHwSGn3fiH4qfDzTPij4Q/4TOz8J+LfHWl/8Iz4L1ESadeapZeCfHGtanZ2QuDY3C/J4bEU8K82WGqzxtSFWlOnD2rxFWtOeGwvPNxp80uV1pylU9jT5aceZU6aUY0171elKu8vdaEMLCdKcakvZqjTpxhiMRaPvuMef2UFGmpzUqj5eeblJzf55+OP2h/2kfjv+2d+wh+1x4X+MnxZ+HH7Ivxn/bdsP2a/2fPgt4Z8YeI/Cfgv42/A/wAJfDv4sa74w/aB+KfhSwvbS18XR/GD4gaHaN8LrHxHZiLS/hf4Y0bVv7Okn8WG7H7e/t+/Da1+Jv7JPxmsXVk1bwh4UvfiZ4Yv4TsvtM8RfDqGTxXaXOmzqRJbXl1a6dfaR50TJILbU7iNXTzNw/AX9tb4kf8ABSHSfib/AMEtvD3iH9gb9nT4Vw/Dz9rzw/Z/AXwX4N/auh1zw74k8RaL8F/iHoui/Dy/ltvhHo0HgDwvY+FVvp7TWobLVorVtKs9Lj0wLcrND/QD+058QNY8KfsP/Fjxp8SdJ0vwh4wvvgJqdj4j8OadrI17SNB+IPjbwqnhz/hG9O19rXTv7dsbLxhrsWkWeqLY2TarBHHdLZ2zTiBPuPCbFZhh+OuGpZU8ZUzahxvw7Uwc6uHr051sbVr5M4QjTqxStWxMpqWEV4KjVjBw9jUhzfOcb0cNV4czT66qEcFU4czOOIjTq05xp0accwTlzU5e9KlR9mlX+KdSm5N+0jK36Y/ssfG/TfjB+zd8CvihrevaPHr3jv4UeBPEniKOTUbKF4/EepeHNPm8QRGJpIjH5esm+RV8tPlUfIowK5z9r745aF8Ov2ZfjZ4s8N+LtCbxJY+BNW07QDp2t6dcahba54hMXhvSr20hguJZXuNPv9WgvUAjYK1vucBAxHxZ+yl/wSa/4J86j+zR8BtU+NP7A37H3j34sax8JfAWt/EPxb8Qf2aPg74p8a614t1rw5YaprU/iXxDr3g2+1jVtVhvLuSzuLvULy4uHNsFaQhVqX9rL/gmL+wn4H/Zu+MXjT4FfsQ/sn/Cz4p+D/Bd94o8MePfhl+zt8JfBXjrQk8PSW+ra9/YXifwz4R03XdOk1PwzZ6xo18LC9he+0zUL3TpRLb3c0Mn4DxtQy3C8Z8XYXJeT+x8PxPn1DKvZ2dP+zaOa4ungfZuOjp/Vo0uRq65bas/S+HamLrcP5FVx3N9eq5PllTGc/x/Wp4KhLEc3972znzedyr+z74Js/h58F/hx4WtIUhe08K6Ve6mVUAz63rFumra3cMQAWMuqXt0ULlmWERR7isa17FXn/wn8RWni34YfD7xLZSJLb614N8OXwKEMI5pdKtftVu+Cds1rdCa2nTOY5opIzypr0CvmD2AooooA+Sf2x47zQPhvoHxh0H914u+BvxB8FfEPw7dxnZMHt/EOnadeWLSYJ+w3Qvbe4voCDHOlhEJUkVNjfsXafHr4KXOmWGqN8WvhraW99aWt1EL3x14WtZEW7gSeOKZJtVQxzBGw8TYdWVlIBU1+PH7bF/In7P3iPw5ZRm413x7rng/wT4bsFx5uo6zqvibTbpbOBMgvNJY6ffNGq5O5NxG0Gvu3Rv+CXn/AATlstO01NR/YI/Ys1fWIdPtIdT1q/8A2W/ghe6jq9+lvEt7qV/e3XgaS6vLy/uVku7q5uZJJ7ieV5pneVmYgHl3/BRv48+B9X/Zj1vwF8OPiZ4K17xL8VfF/gj4ci38LeLtB1vU4NK1vXIbvWZpLTS9QubhbG60/TJtJvZXRYPJ1MwtIrzR5NB0TTvDWh6P4d0e3W10nQdLsNH0y2QDbBYabaxWdpEMAA7IIUUnHJBJ5NeO/t4fsP8A7KvwO+ANz8Zf2ev2Uf2ePhB41+GfjnwF4p1PxJ8Hvgd8NPh34qvvCcPiK1sNW0W51vwb4X0fVbjRHub/AE3VtQ0+W7Ngz6PbX9zGW0+GSP2vTdRs9X0+w1XTriO70/U7K11CwuojmK5sr2BLm1uIz3jmglSRD3VgaALtFFFABXy58dr5/h/8V/2UvjZpxaDU/CPx28N+DNUnhOyW48GfEVJ9I8TWkjAjzUewgntoEcOI21CZlAEku76jr5Y/aJtJPGfjj9lv4R6fmXVvHP7Q/grVpoI18yWPwt4Nlk1DxRqOwZPl6baXsF5IxG3yoZckAMygHvX7ePwz8TfDL4heGP20Ph7o13rtl4e0IeB/j/4Y0qHzb/U/hz9oFzYeMrWBdnn3nhOY51GRmLLYW2kSTyWujadq1xHa8JeLvDnjvw7pfivwlq1pregaxbLdWGoWb7o5Ebh4pUYLLbXdvIGgu7O4SK5tLiOS3uIo5o3QfqfLFFPFJBPGk0MyNFLFKgeOWN1KvHIjAq6OpKujAqykgggkV+YPxK/4J7at4b8Sat4//Y/+Ilv8G9W1u5a/174V+IbKXV/g3r965UvNa6fAlze+D5ZTu3vpVlqMUERS00i30W2UowBpUV4a/h7/AIKG6E5sNR/Zd8AeOZ4zs/t3wb8ZfC3h3R7kg48+LT/F2onV4424bZMiSY/hB4Gjp37Pv7fnxadbDxJefC79mTwtcMseo3mk6gfiR8RxbScTLpbWE8vhhH2ZRbhdT0i8t5CJbedio2gHnnxz8b+I/F2r6d+zL8FQNZ+M/wAUkOk3klq7tZ/DnwbeIE1/xh4mu7dZG0pINLllNmDtvESUX1uj3P8AZVpqf7DfBj4V+Hvgh8K/A3wo8Kq39i+CNAtNHguJEWOfUbtQ1xqusXSIWRb3W9WnvdXvVjPli7vZhGFj2qPOf2cf2VfhX+zLomoWvgmzv9X8V+InFz40+I/im5/tbxt4wvTIZnk1TVXRfJshcM0sGl2KW9lHITczpdahJcX0/wBKUAFfjR+1l4P1P9lr4/3n7S+madd3XwM+NX9j6F8bY9Ntpbo+BPHVkFsNA8ezWtupkXSdZikS11CVEfOqT6mZmm1LVdDtJ/2XrL1vRNH8SaRqfh/xDpdhreh6zZXOm6tpGq2kF9pupafeRNBdWV9Z3KSW91a3ELtHNDNG8ciMVZSDQB+aum6np2s6fZatpF9aanpeo20N5YahYXEV1Z3tpcIJILm1uYWeKeGWNleOSN2VlIINXq4vxb/wT++Jvwq1O/1z9jn4padoHh2+up9Qufgd8Wl1LW/AUFxM7zTDwx4itRea/oUUrEKlk0TzTSnfeeIDCscUXn50j/goRp5Nldfsk+EdeuV+Q6zofxw8DaZpErDjzo7DWdSbVEhY/MI5WEwUgNzk0Ae6V8k/EhtZ/af+Iunfsk/Ci7mltr28stQ+P3jnTh52nfD/AMB2N5DPfaL9tQPbv4m1qSJLOHTt5zMY9Mu08i51aXS/XNL/AGVf22/jMy2fxU8ceBf2dPAtw2zVNH+GM9x4r+JeoWZA82xPiKWY6LpBnUmNdU0jVPNhyTLpt3Fuil/SH4Ffs/fC39nLwXD4I+Fvh6PSLBpFu9Y1W6k+2+IvE+q7NkmseJNYkVZ9Sv5MtsGIrKyjY22m2dlZhLdQD1Dw7oGkeFPD+h+F/D9lFpuheG9H0zQdF06Dd5FhpOkWUOn6dZw7iW8q2tLeGFNxLbUG4k5NbNFFAH4c/E3w9J+xX+0N4lTV4Xsv2bP2iPE9x4p8K+IwjDRvht8UtT/eeIPDGsTKBDpWk640bXulzSiO1g0+K0jg/caN4gurb6USRJUSWJ1kjkVXjkRg6OjgMjo6kqyspDKykhgQQSDX6BePvAHgz4o+EtZ8C/EDw7pvirwn4gtTaarouqwma1uI8h4pUZGjntby1mVLmxv7Oa3vrC7ihu7K4guYYpU/LXXP2Gv2i/glNKf2WfiroPjT4fI0ktl8Ifjl9ukm0GEncNP8LeNdKT7TJbqSyWVjf/2LZWkYDXU2o3LS3MgB6VSEgAkkAAZJPAAHUknoBXyB4++Jv7YXwu8R/CHwR44/Zg8NaX4n+O/xHuvhH8K7mH4w+GL7SfE/xAs/hv8AEL4t3GkGLT2vZ9Egj+H3wr8d+IP7Q8Q3Wlaa39h/2Ul+da1PSNPvvb9I/Yr/AGpvje8cP7R3xR8NfCn4dXH/ACE/hp8ETdXfiTXbQth9M1/xpqqSQ6fHLHujul0uXXNOvYmaOSwjZlkhAPJ9J0GT9tr46aB8LPDKnUP2ffg94j0/xb8bfF8QaTQ/FviDSpGm0L4aaRdJ+41SK6uFY6y0Mxh+yG7vopI5dM0ttU/dgAAAAAADAAGAAOgAHQCuA+GHws8A/BrwZpPw/wDhr4a0/wAK+FdGjK2mm6ej5lmfH2i/1C7meW81LU7xlEl7qV/PcXt3Jhp5nwuPQKAK17ZWmpWd3p1/bQ3ljf209ne2lxGstvdWl1E0FzbTxOCksM8LvFLGwKujMrAgkV+EvhzTrz9jz4t6r+zL4+nmtfhv4l1jU/EX7OHjnUXYaXqOiatetdXfw+v9TlIgh8QaFf3fkrHcOkt5d3JlxFDrOgQ3X7x15R8Zvgl8Nfj94Iv/AIf/ABS8NWniPw/ekT25k3Qalo2pRo6W2s6FqcJW70rVbUSSLFdW0i+ZDJNaXSXFjc3NtMAfE1FeU6t+yF+2L8E3e1+CPxH8IfHj4fWxC6V4R+MMlzoXj/R7FWYQ6bY+LbEx6ZrHkQhIlvdXvNOt4lCx2ujQRIFrAGl/8FB7o/Y4f2Q/C2mXBwn9sal8dPAN5pKN0857HT9TGptED8xjRjKVIUfNk0Ae3XV1a2NtcXt7cwWdnaQS3N3d3U0dvbW1vAhkmnuJ5WSKGGGNWkllkZUjRWdmCgkeEfs7+Frv9sD9ovQfi19kuB+zl+znq1zd+DL+6hlhtvid8Xk2LBrOnxyLGZ9F8HMkOoWl5y0V/bWUah01nUrbT+/8N/sE/Gr4xXtpfftefFbSIfBcM1veP8Efgr/ael+H9WaJ1nS28WeL78W+tXturoiXOnWq3i7x5+l63p8yLM/6oeFfCvhzwP4d0jwl4Q0TTfDnhrQLKHTtH0TSLWKy07T7OAYSG2toVVEBJaSRjmSaV5JpneWR3YA364v4jeA9A+J/gPxf8PPFNsbrw94z8P6p4d1aJSFmW01S1ktnntZGDeTeWrOt1ZTqN9vdwwzp88amu0oqZwjUhOnUipwqRlCcZK8ZQknGUWuqabTXVM6MJi8VgMXhcdgq9XC4zBYiji8JiaE5U62HxOGqRrUK9GpFqUKtGrCFSnOLTjOKkndH4kfBvUR4PuPEH7DX7TGl6Nq2u+G9PudD8HjxbplnqHhH41/CW4EsWi/ZrLWIrjTNXNtpkbadeaFcR3JaytWspop73SNaWD1f/hi39jk8f8Mm/s0en/JCPhb/APMrX3B+0H+zR8LP2lPDNvoHxD0q5XUtImN74U8ZaFcjS/GPg/UyY2F/4f1gRymDc8MMlxY3MV1pt3JBby3NnJPbWssPwnN8Ef2/Pgv/AMS/wd4g+HH7T3g22Pl6cvjO7m8C/E6G1Rf3NvdanNdJoN80a4jfUdR1bVL67kBlkS3UhF+NeGx+T/7P9XxOPy+n7uFxWEXtsVRope5QxeFUvrFSVGP7uGIw8a7rQipVadKpdz/quOe8E+Kkv7bWd8P8F8b4z97xFw7xLUjlHDuaZpP3sZnPC/EFSk8ny6hmde+MxWQ55iMphlmKrVaWV4zH4L2VLC+33nw2+HeoeBP+FXX/AIB8F33wzGiW3hkfDq78LaHc+Bf+Ecs4Yrez8P8A/CIzWL+H/wCxLS3gggttK/s/7BBFDFHFAiRoF4rwj8Of2e/2XPA+vH4d/Dr4SfAL4e2Rm1/xDafD7wT4T+G3hkTRx7X1G+03wrpekWFxfSLiCKRreW8uJHjt4RJJIkbef/2l/wAFDdX/ANB039kvwP4SupDsXW/FPxq8Ja5o9uxwPPm07w5qUOqTRKTkxwOZSAQBnBrsPCX7Bnjr4ma7pfi/9sv4n2vxGg0i8j1HSPgt4BgvND+E1heRENDLrM062mr+KvLJZVivbS1lA3W9zqOo6dPNZMo4nHYm9PAZdjnVna9TH4avl2Epu69+vLFwpVqsY78uGo16kmrWim5x0q8P8I8PcuYcacecHYfA4dcyy/g3Psk494mzGEbP6nlVDhnG5jk+Cq1kuRYnPc4yrB4dXqN4iUY4arz/AOx/4R179oj426l+2L4t0q90f4e+FtK1LwL+zhoeqQSW95fWN401r4n+JE9tIR5D6tDJd6VYOquJ7e8urZmcaJZXt3+sVVLCwstMsrTT9OtLawsLC2gsrKxs4Y7a0s7S2jWG3tbW2hVIbe3t4USKGCFEiijRY41VFAq3X0mV5estwvsXUdevUqTxGLxDjyPEYmrb2lTkTahBRjClRp3fs6FOlT5pcvM/wPxE43q8d8Q/2pDAwyjJ8vwOFyPhnIqdaWIp5Jw9l3tPqWBeJlCnLFYurVrYnMc0xrp0vr+b4/H472NFYhUYeFftKfBHSf2ifgv42+FGqzJZP4h05ZdD1ZkZ20PxPpk0eo+HdYUJiUx2eqW9ubyKF0kutPe8sw6rcMa/NL4R+KvDvxo8Na5+zV+1F4G8Laz8WPhvLa6T4/8Ah18SNB0fxNpHjCPQZYZNG8eabpXiC0vdL1+0vUSx1Y38FvMlvezQapaiGxv9Mmk/aKvlT9o/9kX4b/tGJpWt6jPq/gf4neF1LeDfiv4KuBpni/w/IhklgtpZ0Ma6vo6XEjytpt26yQma6OmXumT3lxcPw5tluIqV6eZZeoSxlKmqFfD1J+zp47DRm6lOHtLSVLE4epKpPDVZJw/eVaVS0aiqUvsPDXj3IsHk+N4B45eLpcLY/MZZxk2e4HDfXsZwhxBWw9HBYzGPLuenLM8izrB4bB4bP8BRqRxkXl+XZll/ta+CqYDMfkr/AIYt/Y5P/Npv7M/r/wAkI+Fv5/8AIq/5x7V3Hj39nr4BfFTU7LW/ih8D/hB8SNa03TItE07V/Hvw08GeMNU0/Rre4ubu30iyv/EOi6jdWmmQXV7eXMNhbyx2sVxd3M6RCWeVn86m+HP/AAUR+FLf2ba6X8Jf2m/D9uzR2GtR6zH8NPHdxbo22I6zBqk1n4aimMYBItH1SVmy01/M5O6IP/wUU8TsunaR+zP8M/hpNM3lnxD47+LWieK9Lswx2md9P8GXx1OQIMuojt7k8DMMn3G8j+0K0bQqZbnUK1/4Sy3F1kpLSyxGHhWwbte3OsRyW15kj9MjwTltWH1jA8eeE2LyuouZZhLj7hrKpSor3ozqZDnuJyriqnJL3vq1TIFilL3VRc7Im1H4bfsi/stadqHxisPg38EPhPdaDYXVunifwX8LvAnhXxRcC9iMT6Fo99oWiadqt1d6wF+yrpltcgXYyJ1FvHLJH6F+wp8LfGHiDXvHf7XnxX0i40Lxf8YbS00T4deFb1ZBd+Cvg9YyQ3Wk286vsMN94omtrHVLyMwpujtLbUlEL6xc2kFn4XfsF3V94u0n4qftW/EF/jv460aVbvw54QjsV0v4R+DLsP5gl0zw2VjXXrqFo4vKvtUsrGCYpG9/pV7dwW95F+j6qqDCjAHQDoPpXfgMBjMXiqOPzGk8NRwjlPA4Gc4VK3tpRlT+t4t05TpQnTpzqRw+Gp1KqpurKrUqOqqcaXx/GfG3C/DXDWbcE8CZjHP8z4kjRwvF/GOFwmJwGUxynDYmhjP9WeFqOOoYXMsRhcbjsJhMTneeY3CZfPG08Hh8swGCWXyxeKzF1fI37aPwA1T4/fCCSx8H3S6X8U/h/renfEX4U6z5qW5tfGXhwyTW9g9w5VYbfWrV59OMkzfZba9ksNRuEkSwCn65oPPHrXv4vC0cdhq+ExEXKjiKcqU+V8skpLSUJfZnB2lCS1jNKS1R+LcL8SZrwhxDk/E+SVYUc0yTH0Mfg5VaarYepOjK88PiqEvcxODxdJ1MLjcLU/d4nC1q1ConCpJP8dvh54h+DP7YfgiHQvjJ8K/Afifxv8PtTa18d/Cz4peCtB8TXHgjxrZJPpV/f2eg+LdO1A2lvdt9shsdSigFxHBLcaXczrdwXkNd1pH7In7J/h/VtM17QP2YP2eND13Q9RstX0XWtH+Cvw20zVtH1bTbmK907VNL1Ky8NQXmn6jYXcMN3ZXtpNDc2tzFFPBLHKiOPev2h/2KfBvxm8R23xP8GeJNZ+DHxy0yFY7H4n+DEXztVjiRIorDxnohntbbxRYCBEtv3txaXptUgs57240yBdOb5lk8M/8ABRr4dsNMvvhp8IP2grKABLbxH4T8Z2vw81m8jGQs2r2Xih9M0yK8fgyxaXpq2kZyscso+cfJt5nl37nGYbF4uEHanmGX0Z4lV4pWjOvhKHNiqGItpUVOjUw7knKnVimqcf6VhT8PuPJf2vwnxDw3wzjcVarjuCON83wuQV8mxM/eq0Ml4nzp4bh7OskjU5v7Pq4vNMuzmjQ5KGNy+pUp/XcV2Piz9lz9mXx74g1Lxb45/Z0+BPjPxVrUkU2seJvFnwj+H/iLxDqstvbQ2cEupa1q/h+81K+kgs7a3tYZLq5laO2ghgQrFEirwXisfs1fsW+D9f8AF3gr4U/DL4c6r4lFppll4b+F/gTwr4N1/wCI2uWX2n+wdD+z+F9IsLnVRa3OoTlbi6iuoNHhvrudVVrgxXHnvwZ+KP7aX7W/w58M/Er4HfC/4S+Afhz43TVf7D+Injvxlea6ZINH1rU/DuqXFl4d060tNbgubPV9I1C1iTWPDpguHthKsb2c8Vwfsb4FfsMaJ4F8ZWvxi+NfjTVPj18bYFRtP8S+IrWKz8LeC2yZBF4G8JxyS2WmSW8ruYNSceZE/wDpWmWOj3E1wJCM8yxy9jl+DxWH5lyyx2Y0KmEoYeFl78MLiFTxWJqpX9nSVGFGUlFVK8I7urgeAODZLNuNeKeG87nh37ehwhwJnWX8T5xnlaOscLieIsjnj+HOH8BVlaGOzCrmuKzSjQlN4DJ8bW1p3v2FfgX4u+GvgrxX8TvivFs+NXx616Pxx47tmVlbw3p0cc8fhPwSqO7tCPDun3dw09ufmsrq+m0ovPFpsEz/AHTR04FFfU4HB0cvwtHCUOb2dGLXNN3nUnKTnVrVJac1WtVlOrUkkk5zk0ktF/OHGPFWZ8bcS5txRm6oQxua4iNT6vhKfscFgMJh6NLB5bleAotydHL8qy7D4XLcBRcpypYPC0acpzlFyfw/+2p8H/FnivQ/B3xl+Fdobr4t/AvVLrxHommRrIZPF/ha9iSLxb4PKQ4luJtQsIBLZ26eZNcBLzTbNFutVSReP+HPxE+Hv7Qnw7k1Kwt9O1zQtbsbjRfF3hDXrS0v2sZbu2a31jwv4o0W8jlgmjeKWW3mgu7eSx1SxkE0azWtwM/ogRkYIyDXw18Yv2LrDxJ4tvfix8DvGd98D/i1e7pdY1DSLSK/8G+NZdzSkeL/AAtIyWs9zcTEPPqVuj7pXkv7zTtT1DZcJ+0cJ8V5Nj8lwvCfFeLeWPLJ4n/VviSWHrYvC4LD42tPE4rJM7w2Fp1cbLKJ4ypWx2CxuCo4rE5di8VjYzwWLw2M5sHx4PF0KlCGDxdR0XRlJ4XFcspxpxnLmnQrRgnP2XO5VIVIRnOnOU/clGfu+b+Gv2Uv2XPBng/xJ8PfB/7NvwD8KeAPGN7a6n4u8DeGvg78PNC8HeKtSsZhcWOoeI/DGl+HbXRNbvrO4UT2l3qdjcz28wEsMiOA1fHP7bnhGP4nJq/wm8b/APBN3xH+0/4Z0bwktz+zt8SfAXiX4EQL4Q8fappctldQSah8RPiB8LPG/wCzxr3hjU9M8P32kePvAh8T2r6TBb6pp2sWHiTS7fwvJ9Vtbft8+EWOn6r8D/hj8WPJykev+B/iNYeD4rtFA2zT2XjGeCdZ5OWkENjbQKx2xxKgXc5PC/7fXxBY6dbeCPhT8BLCZdlzr3iDxRB8QdetI2wpl0iz8Ptf6RLdoCzJFqdotuxADTR4y30lfhTB1KLdTi7gHD4Bxjz42nxfkFe9JR0ayvD1sVxBeHNzwpwyf61CaSVK94PqWFhFqX1zLYwW03iqE0o3i2vYxcq0k7Lmg6N5a+7zWZ5jp3xG+Jf7PX7MfwE+HPxQ8QwfGD9r+8+E/wAOPAepR6GJNRufiH8ZLTwno+ieLPGIhFvZ3MuhXXiuLUNWmvri0046n5qwLFZT3LLa/f8A+yh8D5vgN8IdM8MazdLqnjjX9Qv/ABr8RtaEhnOq+NvETRz6q63J5uIbCKK10qC4wn2uOxF8Y45LqRRgfAT9kbwX8GdYvPHmuazrHxT+MOsRNHq/xO8YlZdSijlQxy2PhnTvNuIPDemGEm38m3nubw2xNm9+1gIrSL60r5HjPizKJZTDhLhWriMXlrxtLMc9z7EUJ4SpxBj8LTq0sDQweDq/7RhMjyyOIxM8LTxfLjMfiq8sdjKGGdLCYTC8OLxVCOHhgMHKdSjFwnXxFRcssTOnHlpqMX70aNJOTip+/OcnOajaMYlfin/wUd+GHjT4FfF/wR/wUS+FPh+/8Taf4S8OH4a/tTeCdDh83U/EHwce8W8sfHljaJsFzqXgS6Im1GaR966fZ6FNdTWfh7SNbuY/2sqKeCG6hlt7mGOeCeOSGaGZFkimhlUpLFLG4KSRyISjo4KspKsCCRXieHnG+K4A4mw+e0sFSzbAVsLjMo4gyLE1Z0cLn3D2a0fq2a5VWrU1KeGqVqLVbA46nCdXLczw+CzKhCVfCU0fEcU8O0eJ8oqZdPEVMFiadahjsszGjCM62XZpgqirYPGQhK0asYVE6eIoSlGOKwlXEYWclCtJn4zWnw+/ZM/an0jQPjLc/C74H/Gu18Q6LaRaP428UfDjwV4w1ZtKt3neLR5tQ8Q6HfatYPpV1PeQ3Oh3bwTaVfte21xaW9z56V2ngn9nj9n/AOGmq3Ou/Dj4GfB34f63e6Zc6Leaz4J+GXgrwpqt3o17JBNeaTdahoWiWF3caZdy2trLc2Esz2s8ltbvLE7QxleZ+KH/AAS98U+APGOu/FT9gD4u2/7PeveJLyTVPFXwS8U6dNr/AOz34t1KQoZLi30W3ju77wHcT4cSXGh6bqkdrCUsdAtvD1krI3lhvf8AgrH4XJ0vW/2IvhR8TbuE+UfE/wAO/wBoTwf4Q0C8YHb9qg0jx3qk2uwwvw/l3CxSgZyiH5B/Q1DIOCOJbZlwLx3wfLCV/wB5/Y/HefZHwFxTlDmuaWDzGpxNisr4ezSdK/JHMMgznHUMXCKrVMNl9Wc8DR/LamZcQ5R/snEfDee+3haDx/DmXZhxJk+O5WlGvhY5VRxWZ4SM7KX1XMsDQqUH+7VbExgq8/SP+GNP2QP+jU/2bT9fgZ8MD/PwvXzX+0X4utdDsdA/YD/Yw8I+FtJ+NHxfjvNDi8N/D/RdM8OeEvgj4B8RSy3PjT4heJLTw1Z21h4ZeSwvr++tvKtodQM17L4gVJr5tJtda9VtfgT/AMFWPj4/9keJrv4JfsW+CLtlh1bU9A1Rvi98YEs5crcJokun3Vx4NjmMW5Eu01Pw/qNpKyz2l4XUbP0Z/ZK/Yk+C/wCx9oOrW/gGz1bxH498WyLefET4veOL0a78R/H2pNIbiabWdbkRTb6f9rZri30awS3sUlY3d0t9qst1qVzM814B8LJrPcfnfDPHPF2C/e8P8IcLYinnuQ0cyhaeEzHjDiXBx/sLEZTgcRCGK/sLIcbm+JzqpRhgsdXyrBVamIqNYLibjKLy3DZfm/DuRYlezzPPM5pTy7Mp4Ofu4jC5HlNd/wBoUsbiaTlRWY5lhsDRwMKkq9CnjK8I016x+zr8EPCv7N3wR+GvwP8ABas3h/4deGLLQobyWJIbjWNR+e817xDexRs0cd/4j1661LXb9Iz5SXmozpCFiVFHtB6H6emaWiv5QzLMsdnGY4/N80xVbHZlmmNxWY5hjcRLnr4vHY2vUxOLxVaf2qtevVqVakvtTm31P2vB4TDYDCYXA4OjDD4TBYejhMLh6atToYfD040aFGC6Qp04RhFdEkfgp+2L4Y1n9hn9q69/bF0rStQv/wBmX9oyPw/4U/aWg0ezmvW+GfxG0wDTPCXxUmsLRGkGi6xFKtjq00Ub7tTutaM5uda1zw5Zz+t3n7Pn7KHxfnHxN1P4G/s+fEy88Z29nrJ8e6p8MPh14vvfE9tLZwR2GpS+Jb3Q9QudXjaxitoba5kvJ8W0MMSOI40Vf128R+HNA8XaFrHhjxToul+IvDniDTrvSNc0LWrG31LSNX0u/he2vdP1LT7uOW1vLO6gkeGe3nikikjYq6kcV+Mvin/gmf8AHP8AZ/1nVPEn/BPj426X4X8IanfXGq337M/x2XV/E3wpgu7iSW4uB4M8T2X27xP4WindlVbBYjdXMxD6h4pNrHDbQf0lw5xpwj4gZFkuScZ5xhOFON+HMuwmRZbxNnFDFV+GuKsiy2lDC5Ngc9xWCw+NxmR5/k2Bp0cpwebVMHXyjMspwuX0Mzr5TiMBPHZl+S5rw/nnC+ZZhmGQYCvnXD2a4qvmGLynAVKNPNsmzHF1PbY6vl1CvVw9HMMtx+JlUx2IwcK9PG4TGVcRUwlPGUsQqGG9g+HvwV+Dfwkk1WX4U/CX4Z/DKXXUs49bl+HvgPwt4Lk1mPTjctp8eqv4b0rTW1BLFry8azW7Mwtmu7kwhDPLu5fQf2X/ANmjwt8QLn4s+GP2ePgZ4c+Kl5c3F3efEvQfhL4B0f4gXd3dh/tdzc+MtO8P2/iO4uLoSSfaZpdSeScSP5rNubPjA1v/AIKtaV/xLtR/YH+H/im9T923iHwx+0p8O9E8PzuBg3MOk+IdVn1uK3dgWWGeYTKpVWbcCauWn7KX/BS/9pAjS/jL8SPhj+yB8ML1mi1rQvgtcXnjj4y6ppzD9/preLp7p/D+hG5RjCmteHtahuLcljcaRfQBoJ/o58F5NgIxxee+IfhTlWVUX7T69guOeHeLcWqfxSeDyDgvF8QcQVMROP8ACpVMtwsXUcYYith4uVSHlLiDMMS5Uct4W40xuNqWh9XxHD2aZJQ59Elicyz6jl2WwpRv7044qs1BOVOFV8sZeU/tF+INe/bH+KOm/sAfAPUZrkaxf2GpftU/EvR8XOkfCj4W6Zf291qfhs6jFvtpPGXiOeGPTk0gyczGLQb9PI1HWptE/oK8HeFNB8B+EvDHgjwrp0OkeGPB/h/R/C/h3SrcEQaboeg6fb6XpNhDuJby7SxtYIE3EttQbiTk14x+zP8Asr/Bb9kn4fQ/Dr4L+Fl0TT5Zkv8AxDr1/N/afi3xnrfllJdf8Xa/IiXGranLufy1C2+nafG7WukWGn2QS2X6Kr8c8UvEHK+JaeS8K8I4fHYPgfhaeOr4CeZQpUc24jzzM44Wnm3FOc4fD1a9DCV8XRwOCwOWZVSxGKpZPlWDoYf61isZXzDGYr7zgzhfGZRLH51nlXD1+Is5jh6eJhhJTngsqy7Ce1lgsnwFSrCnUrU6NTEYjEYvGTp0Z47GV6lT2NKhTw1GihGeDX88vj3T2/4JwftZ+MrXxLFJpv7G/wC1z4zuvGvg7xgUf/hHvg18c9WHmeKPCfiGdQLfRNA8VNEdQ0q5mWGys9MttPS322fhzxTe239DdcB8T/hd4A+M3gbxB8Nvif4T0bxr4I8UWbWGueHtctvtFldwlhJFMjK0dxZ39ncJFd6dqdjPbajpl9DBfafdW13BDMnneGHH9DgnMszwmd4CvnHBvFWAhlHFWVYWrTo494eliKeMy7OcmrVlKhQz7IcfShjcunXj7DE0njcpxUoYLNMVJdfGPDFXiLCYStl+Jp4HPsmxMsbk2NrQlUw3tZ0pUcVgMfCDVSpluZYeTw+KVNqpSmqGMpKVfCUov8rb79k39kzxFe3niDUf2Z/2dtd1HXrq41nUNbvfg18NdTvdZvdTle9utVvNSn8OTz6jdajPPJd3F9NNNLdyzPPJLI8hY+n+Afhd8M/hTpl5onwu+HXgX4baNqF+2qX+keAfCOgeDtLvdTe3gtH1G7sPDun6daXN+1ra21s15NC9w1vbwQmQxwxqvztqX/BPj9sT9mKaZf2JPjj4a+IvwmieWbTf2ff2mP7Rum8L25IYaX4H+IuiKt+bNCzpp2l6g3hzTbKMCS/n1e8ea7l8X+JX7Q3/AAUQ+Dt18MdB+Iv7DfgvStY+MXxQ0X4LfDrWrb9obwXf6F4h+JPiLRPEniHR9HOn6c+oappNvd6P4S8QX/8AaGtXOnaZbpp5tbnUYry6sobj9zocJcN5oljuEPETw4zPLanvU5Z7xTkPh9neFpuzdLMsk40x+TVoYql8NeOUYrO8DKcW8JmGLpuFSX5zUzvNsG/q2ecLcV4TGR0lHLsnzLibL60kl7+EzDIcNjqcqM96f12lgMSov99hqU1KK/QrW/CnhTxHdaBqPiTw14e16+8JasPEHhe/1vRtN1S78M64lrcWY1vQLq/tp5tF1ZLK6urQalpz214LW5ng87yppFb8+dWtD/wUi/aV8Mfs++AydX/ZV+APi/SvHf7S/wAQbXdL4c8d+KtCmefwz8GtAv4j9l1qC7uklPiCS3meD7MbzU7aSObQNJfWvXbL9hX9u39p4pZftafGrwb8BvhBe8a38Hf2aje3njDxRp7uFm0XxT8Rdc+0RaZDPCXhvl0a58R6PqMDPDNpETSLJb/r78F/gl8Lf2e/h7ofwt+D3g7S/BHgnQIitnpOmJIz3FzIF+16pqt/cSTX+sa1fuiy6hq+p3N1qF5IFM9w4SMLx5hxnwp4V4bF4vIeIct4x8Sq+GxOEyfEcOuvieF+B6uLoSwtbP6ud16GHo5/xNhaE5LIaGSwxWT5Zi5Uc3r5viMVgaGWy6MNkGd8Z1cPQzLK8XkPCVOtSr4+lmqhSzfiGFGoq1PLIZfCpVqZZlNarFPMqmPlRx2KoqWCpYKlSr1cSvU0RY1CKAFUAKoGAoAwAoHAUdgOAOBUF7Z2uo2d3p9/bw3djfW09neWlxGstvc2tzE0NxbzxOCkkM0TvHJG4KujFWBBNWaK/kq5+3H4N+HtNu/2Ofi5qv7NHj2aa0+GninWNT8R/s4eONQd/wCyr3RtVvTdXvw81DU5m8mHX9Dv7sRRx3DpJe3dyZz5cWuaDDcfWlfbfxk+Cnw1+Pvgi/8Ah/8AFLw1a+JPD16wngEheDUdH1KNJEttZ0LUoSl3pWrWglkWG8tZFLxSTWlylxZXFzbTfmfq37IP7YfwTd7X4H/Ejwj8dvh7bHbpfg/4yPc6H4+0eyDEQ6bp/i7TzHpus+RCqRpe6xeaZbRJtitdFgiQCgD1WoLq6trK2uLy9uILSztIZbm6urqWO3tra3hRpJp7ieVkihhhjVpJZZGVI0VmdgoJrxIaX/wUHuT9jh/ZE8LabcnCf2xqHx08A3ekox485rCw1Mam0QPzGNHMpUgDLA12nhz9gr42fGS8tL39rv4raTbeCop4Lx/gl8FP7S0zQdWaNxMlt4s8YagINavLdXVFudOtVvkLKZtM1rTp0WdgDz/9nvwvdftg/tF6B8VVtLg/s5fs46xPeeEtRuYZYrX4nfGCLyxbappySBBPovg1xBqNtejJjvLezjAkj1u+g0/9sK5/wp4U8N+BvDuj+EfB+iab4c8M6BZRado+iaRax2WnafZwj5Ibe3iARdzFpJXOZJ5nknmeSaWSRugoA5rxn4R0Hx/4R8TeB/FFkmo+HPF2hap4c1yxfgXOl6xZTWF7Er4JikME7mKZMSQyhJYyrorD8P8A4b3+v/s0+Opv2TPjTePBcaTNO3wM8fX4Fto/xI8Ay3Df2RpsV45FtD4k0dHXTZNL83KSRjSIN7W1hPq37y1458b/AICfC39ojwbN4H+Kvhi28QaV5jXOmXis1prnh3UimxNW8O6xBtvNK1CMABnhc293EDa6hbXllJLbSAHxlRXmmp/sYftg/Cd3tfgf8b/Bfxa8G24P9meGPj5YapZ+J9MtVJEVhD4u8Nxzy67JHHsVLjUZ9EtI1URwWECKA2ND8Jv+CkGtyLp6eCv2b/Bm/KS69q/ivxLrFtCuMGa2stHe/ufMGcxJcWcyFlAkAU5oA7/xf4x8M+AvDupeK/F+sWehaBpMDT3uoXsmxFAB8uCCMbpbq8uHxDaWVtHLdXc7JBbQyyuqHO/Yc+GHib4ufE3VP2zviNol7oGiyaHceD/2dPCmrxeVqGn+D7t3/tf4g3ttyLa+8UQyz2mmSb2afS7/AFNkNzpR0G+m7H4af8E67W/8R6V8QP2q/iTffH/xPo86X2i+Cv7Oi0D4Q+HbxSrB4/CsLFfEcsRRUFxqcVhZ30IMeraLfkJIv6ZRRRwRxwwxpFFEixxRRqEjjjQBUREUBVRFAVVUAKAAAAKAH0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFeOfF79oL4L/AAG0yPVvi58RfDngqC4jeWxs9RumuNb1NIziRtI8O6dHea9qwibAlOnabcrESokK7hQB8c/t4/8AJw3/AASN/wC0ivib/wBdw/8ABQWv0pr8Ev2ov23PhP8AGX4t/sJeOPht4a+Lfibwp+zT+1nrPxw8e61a/DnVorbUfBl/+yT+1P8AAuCPwql1LBcahrP/AAmHxq8JXj2epQ6PbLoFvrV79tN9aWumX/6Q/Cj9v79lX4v6vB4a0H4mWvh7xbcSJBD4V8f6dqPgfV5rqVtsVlaSa/b2uk6lfyt8sVjpmp3t25wBDkjIB9mUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUVWu7y1sLa4vb64htLO0hkubq6uZUgt7a3hUvNPPNKyxwwxRqzySyMqIiszMACa+F/HX/AAUi/ZT8G6vP4f0vxpqvxM1+2Zkm0r4VeG9T8Z/MjYPk6xax2/hy7+b5T9k1qfaeH2muTF4/A4CMZY3F4fCqbah7etCk6jW6pxnJSqS/uwUn5H1HDHBPGHGuIrYXhHhjPeJK2GjGeKjk2V4zMIYOnK/LVxtXD0qlHB0nZ2q4qpSp6fEec/8ABG//AJRt/s1f9eXxP/8AV1/Eiv03r8Gf+CeH7ZXwi/Zc/ZM+DPwF+Oll8RfAXibwTF4xttX8Qaj8PfEVx4Pmk8RfEXxd4rsDYahZW1xqsqJpuvWSXLTaJAY7pZ40WWGNbh/2p+HnxS+HXxa0GPxP8NPGnh3xtoUjCM6h4e1O21CO3nKhzaX0ULm4069RSDLY38NtdxZHmQqTWODzbLMfN08Hj8LiKkVzSpU60HWUf5nSbVRR/vONvM9Difw08QOC8PSxvFPB3EWR4CvU9lQzLHZXiqeV1q2/saOZxpywFWt3owxEqi6xR3tFFFeifDhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUZoAK/Mb/gpH/yNv8AwTN/7Sc/Bb/1Sf7R1fXXx4/an/Z6/Zk0aLXPjt8WPCfw7trqKSbTbDVr2S58RazHCdszaD4V0qHUPEuuCFvlmOlaTdrCxAlKZFfht+2B/wAFLvgX8ffEX7HurfCPwN+0F428N/AP9sv4e/H7xh4n0z4O65Fouo+BPCvw7+LfhLUU8NPe3FtfX2tvqPjrRp7Sy1Gw0m1lso72WW/hmhhtrj9C4Z8JvEzjLALNeGOBeJs4ylzlSjm+GynFLKalaLcZUKWaVoUsBVrxkmnQpYidVPRwufL5vxtwjkOJ+p5vxHlGAxvKpvBVsbR+uRpuzVSeEhKeIhTaelSdOMH0kf0kUV+e/wAEf+Co/wCxP8dteg8HeHfjBa+EfHVzPFaQ+Cfino+rfDbXp72ZtkFhZS+J7az0LVdSnchYdN0jWb++lbaEtyWUH9BwwblTkcHPbn0r5/iXhDirgzHRyzi3hvPOGswnT9tTwme5Xjcrr1qLdlXoQxlGi6+Hldclejz0Zppxm00enlGe5Ln+HeLyPNcuzfDRlyTr5djKGMp06i3p1ZUKk/ZVV9qnU5Zx6xQtFFFfOnqhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRQTjmgD4Z/bN/am1n4K2Phj4Y/CbTbTxP8AtB/Fhrm08DaNdYl07wxpEG9NU8e+JI8FU0rSQk32GC52wX93bXcsguLLSdRt3+Ivh5+zf4e0XVrj4g/FHULj4yfGXW5FvvEHxA8bAaw8N8cMLbwzpt8JbTRNOsD+404wQLdwW6iGCSzshDp9tV+GepN8Y/2h/wBpb9oXVWN5t+IGp/Bj4dmUl00rwL8PmgtZJNPVsiCLxFdG01S7VORqAv2Df6TNv+naAADAAAwBwABgADoAK85+Ivwk+HPxX0uTSvH3hLSPEETRNFb3txbLFq+n7s4k0vWYPK1PT5FY7s2t1Gr8rKkkbMjejUUAeIfAn44ePv2Q/iD4U+DHxg8U6l46/Z18e6nB4c+F3xM8RzfaNf8Ahj4iuPl0zwX4v1NgBc+HLvH2fTb+42xabGq3FubLSLLULDTf2fzX5A/Gb4c6f8WPhj4x8B38UTtrejXSaXNIoJsddtkN3oeoRt1RrPVIbWVtrL5kIlgdvKlkB+wv2EPizqXxn/ZU+EvjDXriS68TWui3PhHxPcTu0l1ca34L1K88MT3187/M19q1vplrrF2x+9NqDMAAQAAfXlFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWZrWs6X4e0jVNd1u/ttL0fRdOvdW1XU72VYLPT9N062ku729u53ISG3tbaGWeaRyFSONieladfnD/AMFKfEer3Xwx+HHwM8P38unan+0V8VvDPw91O7t2KXFr4MgnXVfFFzEy/MUDRaVbXsWCk+nXd5byBkmZG4cyxqy/AYrGcntJUKTdOle3ta02qdClfp7WtOEOb7PNfW1j7Hw+4Tlxzxpw7wr9aWAo5vmEKePzBw9ostynDU6mNznMvZf8vf7OyrDYzG+yVnV9hyJrmufNep6t44/4KDa9e+IfEmp+IPA/7IekarcWfgnwHplxc6LrXxml0q7khm8TeMLuLyruLw891Aws9MVsW/l/Z7TydTtbjWpvrzwZ4B8FfDvSItC8DeFdC8K6VCqKLTRNNtrFZWjXaJruSGNZr26Ycy3d3JPczOWklld2Zj4D+0p8XNS/ZK/Z6fXvhL8BfiD8d/FOkt4U+G/wl+Cvws0qW4vtd8U6/cW/hvwdY6/rrRS6X4C8B2V41tP4y+IfiJk0jwxo0Vxf3AvL57Owvfz2/wCCbn7Qf7dvir9sn9tj9mb9t34g/C/xn4h+Cfw2/Zg+I2k6N8J/A1p4W8JeAdZ+POmeP/FHiHwNo+tyNN4j8Z6T4StdO0Tw3Y+IvEdy99qh0qfUzFC19Jv+bwOXyXtcZiJxr5hOPPicXV/iVJKMZTo4ZNSlRw1JSXscPDlpU4OLk/azlKf73xPxrDE/U+FshwuIyHgjAVfY5Bwxg5OOCwtL3o0syzypB04ZtxFmKoe2zPN8SsRjMRieeFFYbL6OFw1D9rrm1tr23mtLy3gu7W4jeG4trmGOe3nikUq8U0MqvHLG6kq6OrKykggg18ceOv2adS8C6/J8Z/2TdSj+E3xb0wG6uvDembbT4d/Ei0iYzT+G/EnhtWj0q3OoYZLa4gitrNLtxcTJbXpg1rTuW/a38H/8FBvib46+H/w9/ZL+MHwo/Zg+E114b8Ra58U/2iNc8B2Pxt+Lun+J7K+sLXwz4C+H/wAIvFn9lfD6Gw1ezurzVNU8Z+I9S18xLZzWcOiaZPZWg8UfOP7B/wC0N+1hYfth/tUfsAftYfEXwV+0dr/wC+HXwi+L/gv9pXwT8OrD4U6j4g8L/FP+1LU+DPix8P8Aw/qGpeD/AA745sLvTTfaL/wjElraavoEd1qU1ohkhjt9q+X0cdTXtOX2tNTrUZxlKniqDpN3rYetBXo1IKLnH34ynGL92UHaXBkXGub8KY6UMvdZ4HHuOBzPL8bRpYzhzPMPWp888rzrKa9SVHM8DiKd6c41sLOFKpadGtQxNKFal+2v7K/7R+i/tKfDZfE0WnS+GfGvhzUrjwr8S/A16XXUfB/jLTfkv7CSOZY7h9PuSDdaXcyRq7wGS0uAmoWN/BB9MV+RHg24/wCFJ/8ABQPwfNppFn4U/at8DeIdC8R2Clo7N/iF8ObI6zpuvGNSsf2240w2+kRfKTJca1qU7l57sun675zXp5Jja2LwtSnimpYzA4ieCxNSK5VWlThSq0sQorSLr4avQqzjH3YVJzhHSKR+b+L3CeVcM8SYDG8OUamG4X4xyLB8W8P4OrVniKmV0MZisdluaZI8RP8AeYiGScQ5VnOVYXEVm6+JwOEwmKxH76vMKKKK9k/KgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr83/wBv39svxN8AbTwT8FfgPotj42/as+O013pvww8OXm2XSvB+jWqyprfxP8YRHKR6B4fjjuXsorwx22oXdnfXEq3Gm6Hq8B/R9s4OP68+w5HPp+Vfz5fs13TfH/8Aat/bK/a417/iYG2+KWq/s3fCFpyZE0L4b/Co2tvfT6QjZFvD4uv5dP1i82YZdS/tYBsXlwrftXgvwtk2Z4/iLi7ifA0814e4CyvDZm8lruawvEPEWZ4+llvDWSY505QqPLJYmWKznN6UKlKeMynJMdl9OrRqYyFan+feIGc4/CYbKsiyjEzwWacS4yrhFmFLl9vlmVYPDyxWbY/Dc6lFYtUvY4HBTlGSoYzH0MS4TjQcX0vwU/Yg8D+D9Zn+K/xw1Gf9oz9ozxFJHqfiv4rfEpB4gW01QhXFl4I0TVFn07w3o+lH/RtIkhtRqVvar5FrNp2m/Z9IsvuAAKAqgAAAAAYAA4AAHAAHAA6V/PR/wVK/bn/4KA/DnwN+1F8Qf2TvCMHwB+C37FOk6dc/EH43fGv4bx61rH7Q3xG13U/Cuk2Xw/8AgR4M8SpHZ/8ACtPDVj4vt9a8T/GLULW4ttf1mC20HwZDLZ2WpahqX70HxC9l4BPivUJED2ng/wD4SG+m2qke6DRf7SuZNgwqJlHbaMKo4HAr7TOuNs24wzDFYzOsdjMbWwNChGjGrCnh8BhMB+/pYfCZLl9F08JluWYZYOpQwuBweGweDo0adNYWl7B05P5/LuHcDkWGw+Hy/D0KEMVUm6koSlWxNfEr2MqtfMMVPnrYvGVfrFOpWr161evOc5e2n7VSiuJ+Mf7PXwZ+P2hTaB8Wfh94e8XQPA1vaald2UcHiLSAxZhNofiS08jXNHmR23hrC+hSQ5SdJomeN/nP4E/HH4pf8E8/iv4H+AXx18baz8TP2PPilrUHhH4LfGPxbcfavFPwV8W3Yb+x/h34/wBZKot54TvVT7NpOqXIittMt4/ttn/Zei6Zq2lab+dP7HPhX/gr1+1n+y58DP2lbn/gqB8Nvhk/xs+HuifEOPwG3/BPf4ceLj4Zs/EEb3Wn2H/CTP8AGXwudZBsTb3AvToGl7/P2C3ITzJP2A+OPwOHxw/Zx8V/BnxzqFp4n1/XPAkWnHxR/ZMGjRT/ABA0rTobjSfGFppEVxdxaL/xVNpb6sNMt7yeO2tpJdM+1TW7O8n0PCXFWFzXBR4K44oY7GeHWc1KdLF4THSw+Ir8NYjGfuYcWcJtYjESynPMoc44upGi8PQzrDU6mU5nTxWDxM40/LzzJauCr/6w8O1sNQ4oy+M50a+FVWlSzWnQ5ZzyXOlKlRjjcvx0U6MJT9rPAVZQxuElSrUo8/7HqwIyOnY+tLXwR/wTG+N+s/H/APYk+CHjbxTczXfjPStDvvh94znunaS+uPEPw61e+8HS6hqUjks+pa1p+k6frt+zYLXOpyNgZxX3vX8wcWcOY/g7ijiPhPNOR5jwznma5DjpUrujPFZTjq+BrVKMn8VGrUoSqUZ/bpShJaM/YckzbDZ9k2VZ3g1JYXN8uwWZYeMvjjSxuHp4iEJ9qkI1FGa6TUlpYKKKK+fPUCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKQ9D9DS0UAfg1+x5DJpngj4keF7wGPWfB/x0+KXhzXIZBtmj1O01mKabzUOGDbbhEyVHzRsuMoa+ta8D+OuiP+yr+1prfjDUkFl8D/2qrqzvZNdYeXpXgz40adA8d/a6pcEeTYW3i+Ez6ubu5eMXV3eXMhdLHw9eyx++ZoAKKKKAI5ZY4IpZ5nWKGGN5ZZHYKkccal3d2JAVUUFmYkAAEk4rU/4JWWlyv7J9lrckTw2Pi74mfE3xLoyONv8AxK5vEs+lIUXsn2zSbwAcgkFgSCK+UP2kPGeuXdho/wABPhjH/a/xm+OEp8I+G9KtpCZdD0DUxJbeIvF+rNEryabpWnaUuobdQk8vyGjutSiLw6Pe+X+wnwa+GOi/Bj4V+AfhX4fPmaX4G8MaXoEV0YxFJqNzaQA6jq08akql1rGpPd6pdKpKi5vJdvGKAPS6KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvy//b/ifT/jN+wx4qusroth8X/E/hi5lb/VJq/jLSNEttDVycKrvJpl35RLA/LIQG28fqBXyh+2j8Cb/wDaB+A3iPwp4cdbfx94fu9P8efDa9LrE9r438KvLd6ZFHO+Et31W1kv9CW6ciO0OqC7kO2Ag+RnuGrYrKsVToRdSvD2GKo01vVqYLE0cZClG+nNVlQVNX6yR+oeDGfZbw74lcNY7OcRDBZTi5Zrw9mePqX9nluA4tyPM+FcXmdW3veyy2hnM8dV5Lz9nh5cilK0XjV+Kn7KGP8Ah9p/wVsx/wBEQ/4J9Z+v/CB/Ej169vzHavsePQvgh/wUV/Zp1j4T/Hzwhca9pN3eaJo/xm+F/wDwkvjPwFreieN/BeuWWsRW9zqPgrXvC3jDSLQeIdDt9UsFtdXtEu7eKTStSEzQarYL8nRf8G/X/BJCC7ub+H9lbU4r68WBLu8j/aO/asS6uktgy2yXNwvxxEs6W6u6wLK7rEHYRhQxz52CxWHr0Viac5TpV6MlSlCMZe7UULOXNODUotSjOm1eMlZtSTR9zxPkefZHnFfJMdgqNDH5NmDhjKWJxFSk/bUeeFqTpYXEU62GrU508RhsXTm6WIoVI1aSqUpwqy+2vj/o/wAFP2oZPFv7HN9+0R42+G3xTstB8I/FLX9C/Z9+Nt78Jfj/AKB4Nk1+6g0XXoNU8M3SeKNO8La1qmk3Gl6o0UP2W7t5IbW+McOpWRufzE/4J4eHLT9jv/gpP+1n/wAE9fAvie9+NHw4vfgH8P8A9rzVPjJ49h8Pa9+0D4Z+JHifxpc+Bb74UfHT4uaJpOk6z8WLzUNEkt/HXw91P4hRT+MfD3hOeTR11HVNJa1uI/0b/aV/4J0fscftcf8ACCXXx0+Dtv4g8SfDHS10PwB4+8N+L/Hvw4+JvhbQ1iMJ0LT/AIl/DnxR4V8czaG6PM0mi6hr15pclxcXN69ob24luG6j9m79kD9lD9hLwT4w0/4B/Dbw78JtB126fxZ8R/FV/rOu+I/FPiq702C5kOuePviP471nxB4y8R/2ZBPfyWZ1/wAQ3lrpKXd+dOhtFu7oS7wqU6UKj5qijKFRTg1FQm2kqdSc3O9NUuWnVlFc15w5FLklJnlSwWMxWPws4UKHtI4ikqVWjOtUxUoyXI8JHDqi41Z1p1JUoyVRXjNTjSVVRiq/xYVtZ/bE/YZ8OaeDJqlt4w+JHiq6CffttG0TwvY3d1JL12RXMVndxocbZHt2jBDlQf2CXoP/ANdflJ+xZoWpfHn45ePf2xNXsLm18CadpFx8I/gDBqFvLBLqOg2l9JJ4r8bxwTJG0Y1HUEuLCxnCbjHf6zpk+H0qNn/Vyp4ci50Mdj7NU8yxzxGHumubC0cNhsFRqpPXlr/Vp16ctp0alKSVnrfjziKeDzXg7gpTjPHcBcH08nz9Rkp/VuI83z7PeLM0yyUotxVfJFn2GyXHUotqhmmAx9JvmjJIooor6M/CAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBrHAzjOD0/z74r+eX/gmqj6T8KvjR4JvgY/EPw//AGpvjh4U8TW8ny3MWr2ut2VzKZ0IVwStysYcooLwyIBuicD+hzr1FfgF8cbP/hhb9vPxH4811f7L/Zm/bju9LuLzxPL+50H4c/tF6NbSw3MOtXTL9n0uw8e2z3OryX93JEt3f6jd3MkkOl+FNQmi/orwKrLN8o8SOAcP72dZ/luR8UcP4VP97m2YcD4jMquOybCwXvVcbW4dz3PMzwuHipTxVXKFhaMZYmvQhL8q8SKbwOO4T4mqaZflmLzHJ8zqu/Jg8NxFTwlPDY6s9oUKeaZdl+Eq1JWjSjjvbTcaVOpJfP3/AAXnBP8AwSM/bZA7/D3wuP8AzKPgOv0a8SJ4Vl+A+vQ+OvEUPhDwTL8JNTi8YeLLjUrDRrfwv4Wk8HTJ4g8RT6vqqS6XpUOi6U13qUuo6lFLYWSWxubyN7eORD8WfHz/AII/f8E7P2oviX4x+MHx0+AN5488ffEKTS5/F2rv8aPj94e0/WX0fRtL0DTWbwx4S+Keg+FLNbfSdG0y38vTtEs4p5Lb7ZcJLezXFzL65+y7/wAE8v2QP2Mrrxvd/s4/Ca48CS/EfS9L0Txomp/Ej4sfEW11vStGk1CTT7JrL4n+OvGdlYwxNql+Jf7Mt7J7yOfyb1riKKFI/NjhsdPF42tVo4ONDGYWhhbfWa9WcVh3jpQlOn9UoqSq/W0qkI1ounGMuWc20dkquGVDDQhUruph61WtrRhCMnX+qKUYz9tNxdNYduEnCSnJpSjBe8fkD8bv+CYf7BPgD/gnfrn7TPwh+O3xpuPGnwE/ZYufGH7N/wC2rB+0549/4SLRdI+GXgJrv4RWXh+z8Ja/4b+D8XhaePSNB8Kf8Iz4Y+HWiS65HdTDnxzqc+uzftV+xT8TfHfxW/Yw/Zc+L/xgRbD4i/ED9nX4R+PviJJPax6Ug8S+Ivh/oeueINRlsFjgi0tLu8urjUHsVihj09ZzbCONYdo+WI/+CKn/AATLi8ZL4wX9mLSTAnij/hNI/hy/j/4rSfA2PxP9rN6NTT4CSeOm+Daxi5JddH/4Qj+wVHyLpQQBR6z+258VtcsvDOg/srfBKCPWf2if2lM/DrwN4b01gsnhXwlq8c2n+KvHms/ZgW0PQNG0GPVIbbVHEK2kkd1rFuJLTw5qnkfQ8DcIZhxDxHhcqw0cHl0Md7JYytGtJ5flmX4FV8VnHEOZ4ipSw8MPg8sy5VsbjsRUi1TwmEnOrUm1FLy+I89w2V5TUxlWWIxcsM6roQqQisXi8TiXRo4HKsHThUqyrV8VieShh6MX71atGNOnCPNJ/Rf/AARQtLlv2Kf+EoaGSHSvH/xt+M3jHw4HUqG0O58WSaNGY1IysYv9E1BQMn5lYg4NfrlXjP7O/wAF/D/7O/wQ+F/wT8LsJtH+G/g7R/DUd75SwSatfWkHmazrtxCmUju9f1ma/wBavEQlFur+YJ8oFezV+SeKfE+D4z8SeOuK8ujUhlufcVZ3mWWRqpxrLLMRj68su9spaqv9S9h7a9n7Xnulsfb8GZRXyDhLhzJcU08XluTZfhcW4u8PrdPDU/rXI1o6axDqKnb7CiFFFFfAn0wUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB578U/hZ4F+NHgbXfhz8R9BtfEXhTxDbeRfWNxuSSKWNvMtNQsLuIrcafqen3AS6sL+1kjuLW4jV43xuVvya134Aftbfsts9h4B0x/2qfgjY/LomnvqVvo/wAZ/BmkxkLBpbpOhtPF1pYQlYLNdMhvb66EYSGw8PWEcdsn7T0UAfgdqf7ZPhjwzd6bo/jj4P8A7QPgfxJq+oNo2leHfEfwzubHU9Y1qPT77VpNK0SGbUY5NUvl0vS9T1IW0Ea3J07Tr6+MC2trPLH1mmeKf2rPjWyaT8DP2bvFngezvQEf4mftAW3/AAg2h6Pby/J/aFp4bc3Gqa/tyZIG0ptW2OqtNpdzAXUfTn7eP/Jw3/BI3/tIr4m/9dxf8FBT/Pn61+lNAHxj+y3+xz4d/Z+uNY8e+KPEV58U/jt4ygWPxj8UNcgWKVLZjG58PeE9OLSpoHhyBobdfJhb7Re/ZrfzjBY22naVp32dRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFB/zmiigD8+v2hP2MdX8ReN7j49fs4eLrT4U/HKSBY/EVveW7zfD/4o2kQXFj410y2imaC+dI40XXLWzupiY45JrX7elrq9j83z/tE/G74YbtN/aC/ZT+LOkXlntiuPFvwn0qL4j+Br87Ri9jvbK8SPSIZ/9ZHY3GqajfQr8k2Jg8SfsrSYB6gH8K8DE5DTlWqYnAYqtl1WtJ1K9OnCnXwdarL4qs8LVVoVZ7zqYaph5VJe/V55+8fteQeNGMw+V4DIuNeG8r49y3KcPSwWUYzH4vH5TxRlGAoJRoZbg+I8uqc+Ly3DQvTweCz7A51Ry+lajlqwVCPsn+Kui/txaJ4/sbef4N/Ar9oH4sT36SnTpfDvgMjQJmimktnNz4ht7/Ube1t47mKS3nuktrmK3ljlSUh4ytdxoX7LX7RP7Ueo2N/+1JNZfCD4M215b6hH8BfBetDUvE3i77PItzbQ/EHxdp8ht4LFXWJ3tNLmE0mwqNN0HVIIdUXvP+CN/wDyjb/Zq/68vif+nxr+JFfpvWMOHnWa/tPMK2OpKzeEpUqeDwlW1tMRCDqYitC+9KWJ9jPapSnG8T1cT46U8rpzl4ecEZZwdmkoyjT4nx+aY3ivibLuZWc8kxOMo4DJsoxVm/Z5nhshecYSfLUwGY4OrHneRoGg6N4W0TSvDnh3TLHRdC0OwtdL0jSdNtorSw07TrKFYLSys7aFUiht7eFFjijRQFVQOuTWvRRX0kUopRilGMUoxSVkklZJJaJJaJH4FVq1K1SpWrVJ1a1Wc6tWrVlKpUqVKknKdSpOTcpznJuU5yblKTbbbYUUUUyAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAryr41fBT4a/tCfDbxN8Jviz4YsfFngjxXafZtT0y7DRywzRt5tlqmmXsJS70vWdLulivdL1Sylhu7K7ijlikGCG9VorrwOPxuV43CZlluLxOX5jl+JoY3A47BV6uGxeDxeGqxrYfFYXEUZQq0MRQqwhVpVac4zpzjGUZJpMxxOGw+Mw9fCYuhSxOFxNKph8ThsRTjVoV6FaDp1aNalUUoVKdSEpQnCcXGUW000z8Bb74C/t6/sOb9F+GmjH9uP8AZp0smPw3o8+s2vh39oj4c6FCQltom65iaw8dadpcBW20+HS7bUtRu0gSG00zwnpUEVonH6n/AMFMPh74SlsdL+JX7Pf7Wvw08T6hqMOiWPhrxZ8F7iw1DVNeuIZriHR9FE2txHUr64htbya0tljhurmC1nmS2Ecbsv8ARV+FfmN/wUj/AORt/wCCZvH/ADk5+C3/AKpL9o6v36j475bm0fb8eeG+TcQ5y9cTxDw9m+N4JzHNaujeJzjB4TDZrw7XxlR3liMXl2R5VXxc5SrYqdbEynXl+Yz8NsXgW6XDfFmPyvAX/c5ZmmBw/EGFwUOlLAYivWwWaU6EVZU6OKzHG06MVyUY06ajCPxfafG/9tr9ogroH7Lf7HXjz4c2Wpqkb/Gb9qu0X4b+GfD1rOfLOrWXgzzLvWPFPlBvOtm0W51ry5FR7jQ7+281B+gP7Gn7A/h39mfUfEPxY8f+MdR+OH7T3xDtwnj74z+JLdYZYLNxCx8J+BNIJki8L+E7YwW0PkW7Lc6glnaLILLS7TTNC0v9CMY6D9KK+c4r8ZsyzjJsbwvwtkGU8BcNZnGFPOMNk1bMMdnfENCnUhWpYXiDiTNcTiMwxOAhWp06zyjLYZRklatTo4jE5XXxNCjWh6uS8A4TAY/D5xnOZ47iXN8G3LAVsfDDYbL8rqSi4SrZblWDpU8NRxDptwWNxUsbj6cJTp0sXTp1JwZRRRX4yffhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXzX8e/2tvgX+zfDbQ/ErxeieJNRjSTRvAnh61l8QeONa81ikBs/D9jult4LmRXit9Q1aXTNMmmRoEvjMPLrz/wDbU/aY1b4C+DfD3hj4c2Nvr3x0+L2qTeFPhZoc6xy29jcqkJ1jxlq8Mv7o6N4Yt7mCaQT5t5b64sxdqdMi1Oa3+JPhD8BdH+H1xeeNPFeoT/ET4zeJZH1Hxn8T/EbPqOtX2pXSYubbR5rzfJpWkQqfssENsIZri2ihW7JiitrW1APXJ/8Agor8Wdaka5+Hv7EPxQ1nRWy1veeO/HPh74Z6jPATlJTpF7o2ulS6fMqpezKRt2yMGDDR0r/gptovh24gi/aA/Z8+MHwS0+aZIZPFqWcPxB8D2Du23Oo67oVtY3iL3RbDRtRnfBIgA5rSqKaGG5hlt7iGKe3njeGeCaNZYZopFKSRSxOGSSORCVdHUqykqwIJFAH6DeBPH/gr4neGdO8ZfD7xRovjDwvqqF7HWtBvob+ylZcCW3d4WLW95bOfKu7G5SG8s5g0F1BDMjIOvr8E9V0zxR+xt4suP2g/gDbXA8BG5iufjn8EbSRk8N+IfDKuBfeKfDGnkm20PxBoMDyXcUlrHHbWkCPIqJpC6rpmo/uB4E8beG/iR4N8MePfCGox6t4Y8XaJp+v6JqEY2+fYalbR3MPmxk7re5iDmC7tZMTWl1HNbTqk0ToADrKKK/Ov9t/9o/xt4U1Dwp+zf8CLuK2+N3xVsbjUL7xMyiWH4WfDqKSW11LxlcDDCPVLySG6s/D/AMrsktreTxbNS/saO7APWfjx+298A/gBqsfhTxDrup+L/iNcbRa/DH4caW3i3xvJJIgkijurG3mgsNHkljZJYYNb1LTrm5gcT2lvcxgsPmST/goZ8cNRY3Xhb9hfx9e6OTuiuPFXxR8N+CtYaE5IaTQbzw1qE8cpXaTD9qfaSV3kjJ4H4RfA7wR8HdNlTQ7aXVvFOql7nxV481xvt/i3xVqdzJ597e6nqtwZblYri6LTrYRTC2jcmWQT3bz3c/slACeGf+Cm3w8sdSstG+Pnwo+Kv7PVzfzpbW3iDxVoreIfAUlw5CrCPFWhwifeWI3zf2H9igTMt1d28asR+jWg+INC8U6Np3iLwzrGmeINA1e1jvdK1rRb621PStSs5hmK6sb+zkmtbqCQfdlhldDgjOQRX5r6ppema3p93pOs6dY6tpd/C9vfabqVpBfWF5byDDw3VpcxywTxMPvRyxsp7ivl7wx4k139gTx3YeMPC11qmo/soeNNftNP+J/w+llutST4V6nrFwlra+PvB4laee200XMkcer6epf7WhWwkFzcTaFPooB+8FFVrK9tNSs7TUbC5gvLG/toL2yvLWVJ7a6tLqJJ7a5t54maOaCeF0liljZkkjZXRipBqzQAV8O/GX/goH8BfhN4juPAWkS+J/jH8TLdpYZ/APwf0Y+LtV0+5iJSSDWNQjnt9F06a3lBjvrNb+61awIJuNLUlQ3hX7Znx18efEH4kr+yB8DNfuvC13HpNtrnx9+JumOVvvBXhfUo45NP8H6Dcxsklv4n8R2U8VxcSRPFcQ6feWcdvKIX1qWw5/4ZfCbwF8IPD8PhzwJoFrpNqFjN9fFVn1jWrlAd19rWqOoudQunZnYGRhBbhzDZwW1sscCAHjnxr/aG+Mnxw8efsv8AxEf9jP4i6VZ/svfHnUfj34et2+K/g2w1DxTqWofAL44/AR9C1nRL7wpNe2VlHo3xx1jX1ayuWvDqmh6baFvs1zc4+w/Af/BSz4Naprth4R+MXhX4g/s5eJ9RkENkfipoptPCF/OW27bDxlZtJYrbq2Q+oaxaaNpqYAN3uYLWNXP+KPCnhrxrol74c8W6HpviHQ9QjMd3puq2sd1bScELIqyAtBcRE77e6gaK5tpQstvLHKquAD9SbW6tr22t7yyuILuzu4Yri1uraVJ7e5t5kEkM8E8TNHNDLGyyRSxsySIysjFSDU9fiZ8CPiT4j/Yp+Knhb4T+Jtd1HX/2V/ixri6B4D1LXbqS7vPgr471GRnsPD0up3DM3/CG65KzJElw6xWT+Zqu62ksNduNb/bOgApkkiRI8srrHHGjSSSOwRERAWd3ZiFVVUFmYkAAEk4FPr8aP2mvir4s/at+LXin9m/4eeItR8M/AX4YXi6X8dPGGhzm11Px/wCKwzC6+GWjX8eWj0nSzHLZ+ImxsmvIb6O9hmtYdKj1UA+jviR/wUi+CHhfxDfeCvhho3jf9ofxrp7PFe6Z8ING/tvQtMnVim3VPFs0kOkiDeCkl3ow1yCCQNHcNE6SKnmA/wCCg/x/Qi6n/YS8Xro+dxng+Mfhi41nyc53Dw+vhRbjztuD5H2nO7K7+MlngzwP4R+Hmg2nhnwV4f03w5odkoEVjp0AiEkm1Ve5u5zuub69mCg3F9ezXF3cN8880jc11dAHd/Cf/gon8CPiF4js/AfjO38X/Aj4iXrxQ2nhP4yaKfC6ancSsEjj0jxAZp9FufPlZIbFNQudJvNRlkSKxsp5GVT965r8lviD8NvBHxT8P3Phjx34esNf0qdX8tbqLF3YTsu0XmlX8ey80y+QY2XVnNDKVzG5eJ3jal+yN8aPGvwJ+Kmk/skfGHxFfeK/BPiy0u7j9nH4ka3Lv1QJpqeZd/C/xJfPhbq8sLbaPD8zMHQ/ZNMtx9k1bRdK0YA/Xaiimu6orO7BEUFmZjhVUDJZieAAOSTwByaAKWqappmiadfaxrWo2OkaTplrNfalqmp3UFjp+n2VshluLu9vLqSK3tbaCNWkmnnkSKJFLuyqCa/Ojxf/AMFM/hX/AGvfeHPgb8PfiZ+0Zq+nTNb3mp+ANFay8C2lwh2tDc+MdVRUIJOYbyy0m+0u5T95b38iMhf5X+JfjnWv29viNrlmNW1HTP2QPhr4hl0XStI0u7uLB/jr4s0eZftuu6nd2rxTyeDLC6VDpMKSASRfZ7iHyNXnvG0T6I0LQdE8MaVZ6F4d0nTtD0bTolgsdL0qzgsbG1iX+GG2t0jiTJyzsF3O5Z3LOxYgGcn/AAUK+PFm4ute/YV8b22jg7pJ/D/xa8M+J9ZEWMkpoFt4Xs55JcdIRdKxbC7gTX0V8Dv28PgH8cNeTwPbalrvw3+JpcQ/8Kz+KukHwf4rnuP+ffTFmnudJ1i4Yh2isNO1OfVmhRp5NNhiVmXxyvKfiv8ABjwF8ZNEOk+MNJRr22Bk0PxNYbbPxN4bvVPmQX2i6uifaLZ4Zwk7WrmWxuXjT7VazBV2gH7DUV+Zn7Ev7QvjuLxbrn7J/wAfdYOt/ErwZo41/wCG3xAucxy/Fb4cRyfZ0uL1pnd7jxXoGPK1JzJPd6hbQ3s1293d6NqWsan+mdABXK+NPHHg/wCHPhvUfF/jzxLo3hHwxpEXnajrmvX9vp2nWysQsaNPcOivcTyFYbW1i8y5u53SC2ilmdEax4u8V6B4E8LeIvGnirUYNI8N+FdG1HX9d1O5LCGy0vSrWW9vbhggaSQpBC5jhiR5ppNsMKPK6Kfw2tI/Ev7bXi6L48fG61vIfhJZ31xJ8CfgjeSMuiW2hxSvDbeNfGVgj+RrOt61GpmCXPnW00DsiedoLWFtIAfVmsf8FN/Dev3Vzbfs/fAX4vfHSzt5pIF8WQ6engPwLeSRsUIsfEGvW13enBHzpfaHp8qghhG4BIyof+Cifxe0eRbnx7+w/wDEzSdGU7p7vwN4+8O/EnVYoerSLotloeiM7qmGMbXsQHzBpFClq3ra3t7O3htLSCG1tbaKOC3traJILe3giUJFDDDEqxxRRoAkcaKqIoCqAABU1AH0n8BP2wPgP+0d9psfh54tMPizT43k1f4feKbSTw5470kQkC5NxoN6xN9DaMyJd3uiXOq6fayyJDPdxzMI6+na/FX4v/AXw98S2tPE+jXdx4D+LXh2SO/8F/FDw08mm+I9G1S0G6yF7dWTQT6ppgcCOS1uJGlggeb7BNavLIZPsj9ib9pfXvjZ4Z8T+APipbWuj/Hz4N39v4d+I2nW6Jb2viC1nRzoXjzRoEWOL+zfEVvC0lwtpGlrDeqbi3gtNN1PSoKAPuKiivKPjf8AF/wp8B/hd4v+KnjOV00Twppj3RtYGQXmrajO6WmkaJpyyEI9/rGpT22n2u8iKKScT3DxW0UsqZ1atOhSqVq0406VGE6lWpN2jCnCLlOcn0UYpt+SO7LMtx+c5jgMoyrCV8fmeaY3DZdl+Cw0HUxGMxuMrQw+Fw1CmtZ1a9epCnTit5SSL3xS+L/w1+Cnhifxj8UvGGjeDfD0BMa3mq3BE17c7GkWx0nTrdJ9S1jUHRGePT9LtLu8dFd1gKIzD4Muf+CjGt+L3M3wF/ZV+MnxQ0Viy2vivxBJp/w08M6muSFudI1HVbXWftVtJt+V54rO4X5RLbRMcV4v8L/hD4l+OPiO2/aV/amt4/EXjTW1Go/Dr4Yagkk/g74SeF7orc6VZQaFdZtrjX5bfyLq7m1CCSe3uDHcXqvravLafbaqFAVQFVQAqgYCgDAVQOAAOABwBwOK+TeY5rmP76hV/snBy1oRVClWzCrTdnGtWeJjVw+F9pH3lhvq9apBNOpUhPmpR/pejwP4a8C/8Juc5Y/EzinD/u85rTzrMMp4Gy3Gw0r5ZlMcgrYDPeInhKl6NbPHnWV4DEVqdRYDLsThFRx+J+Af2Tfj743/AGKvgF8PvgX44/ZN+OT+CvhzB4jUeN/DuseGfiNqTW/iLxb4g8YXd1qmmaDp+hWVrBYT67cW+8XkYFrbRSvmVyD+qXwQ/aT+DP7ROjy6v8KPGlh4gkslQ6zoUyy6Z4n0B3JUR6z4e1BINTtEMqvDHeCCTTbqSOQWV7cqhavLK+TvjT+zm2s6vF8Y/ghqA+GP7Qnhhm1LQvFWiCOwsvFskX7yXw941so1Flq9lrCKbKe8voJ3COkWoC+01HsyLGZzgbVXiFm9COtXD1qGHw+NcFa8sNWwsKGHnUiruNCrh4qq/d9vSdm3V4W8KOMF/Z8ckl4XZvXtTy7PMqzfOs84ShiZWjSp8RZRxFis6z3DYGrK0a2bZVnlWpl0ZTryyTMYx9nH9eaK+Xv2Sv2i7X9pD4WxeJL3TR4b8f8AhfU7vwd8UfBzh45/DPjbR9seowJbzM9zHpt+CL7TDM8rxRyS6fPPLe6fdkfUNfU4XE0cZh6OKw8/aUK9ONWnKzTcZK9pRdpQnF3jOEkpQmnCSUk0fznxFw/m3Cme5rw5nuElgs3ybG1sDjsM5RqRhWoytz0q1NypYjDVoONfC4qjOdDFYapSxFCpUo1YTkV4l8bP2ivg7+zzoSa/8WPGum+GorrzF0rSz5t/4h12WILvh0TQLCO41TUSjvHHNPDbfY7RpY2vrq1jcSVzP7VX7Q2lfs2/CfUfG0tg2veK9TvrTwr8OvCMQdrnxZ441nzI9G0tI4f37WsXly6hqTQYn/s+0nitd99NaQy/CHwa/Z5vhrcnxw/aDvE+JH7QXiYx6je6nq4jvtH+H0UmZrTwx4L05/M07TU0ZZDb/brKIGKQTRaW8FrJPJe+Rmea1qVdZfl1OlVxvs41q9WvzPDYGjUclTnWjTcZ1q1Zwn7HDQnTcoxlUqVKdPkdT9O8P/DbKszyWfG/HWNzDL+E446tlmT5Xk/1enxDxjmmFhRq47C5ZiMZSxGEyrKcshiMMs24gxWEx0aNfE0MDgMuzDFyxCwXokv/AAUI+I/io/avg/8AsY/F/wAX6FJ81prXjnXNF+FsGoQnlLmyjv7HXkntpgUkglS6JdD8yIwZA6D/AIKKeJfCDfaPjp+yX8ZPhvoaH/TPFHhi50z4naBpMZKg3Oq3mmWuhraWcecyyRC5mwMRW0rgrXulIQCCCAQRggjIIPUEHqDXl3zn41ndbn35JYDLnhb9vZxw8cTyeX1xS/v9T9DcfCiS+qy8IMthg7cv1uhxnxvDiNR/5+LH1s4xOQfWLfbfCjw3Nr9Ut7r94+E3xp+F3xy8Mx+LvhV4z0fxjobFY7iXTZnS90y6dQ4stZ0m7jt9U0a+2HzBZ6nZ2tw0ZWVY2idHb1Gvxj+KvwT8R/CzxHL+0f8AsspF4T+KHh9H1Dxd4E06J4fCHxe8PQH7Tq2h6voFq0dqdZuIUlmsri0jhnu7797E8GuPZ6rb/pv8AfjZ4W/aF+FHhP4reES0Wn+IrI/btLnkWS90DXbKRrTWtB1DaE/0rTL+KaES+WiXlt9nv4F+zXUDN62V5rVxNaeBx1KFHH0qXtoyouTw2MoKUYSr4bnvUg6c5QjiMPNylQlUp2qVYVI1H+aeInhvl+Q5ZhOMeDsfjc24MzDHLK8RTzSnQhn3CudzoVMVRyXPvqijg8XTxuFo4jEZLnmDp4bDZvSwmOhPA5djMFicHD2Wiivi39tX9pfVfgJ4K0Dw38O7CDX/AI5/F3VZfCfwr0GZUlt7S7VITq/jDVoZCIzo/he3uYJ5BMfIlvrmxW7UaYmpT2/uH4+d/wDHv9rX4F/s3QWsfxL8YRxeItSjWTRfA3h+2l8QeN9a8xjHAbLw/Ybpre3uZVeG31HVZdN0uWdGgW+M48uvj+f/AIKK/FjWnNz8PP2IvijrWiud9ve+PPHHh74Z6jPAeUl/si90bXipdPmVUvZlORtkYEGvIvhD8BdJ8AXN5428W6hP8RfjR4mkfUfGfxO8Rs+o6xe6ldIBc2uiy3m99I0eAf6Lbw2ywzT2scKXJ8iK1tLT6AoAzdK/4KbaN4euIYvj/wDs9fGD4J6dNLHDJ4tS0h+IXgjT3c7c6lrmhW1heRrnOxbDR9SuHAyIAOa/RLwJ8QPBPxP8Mad4z+HvijRfGHhfVUL2WtaDfQ39lIy4863keJi9teWzHyruxukhvLOYNBdQQzKyD8+5oYbiGW3uIo54J43imhmjWWGaKRSkkUsbhkkjdSVdHUqykhgQcV8j6vpXij9jnxXcftCfAC2nXwMLiK5+OfwQtJHTwz4l8MJJ/p/ifw1YZNtoXiHQbdpLuKW0jjt7SCOSVETSl1fS9UAP3sorkvAfjjw18S/Bnhjx/wCDtQTVfDHi/RdP1/RL5BtM1jqNulxEs0RJa3u4N5t7y1kxNaXcU1tOqzROo62gAr5G+PP7bvwE/Z+1NPCviPXtS8XfEWfYLT4YfDnTG8W+OJnljEkMd1YW00Fho8k8bRywQ63qWm3F1A4ns4bmMEjyb9t/9pDxr4Rv/Cf7OPwJuorf44fFiyuL+78Ruolg+Fnw7hkltdT8aXQIYR6leSQ3dn4fyjlZrS9miH9orpEF58+fCL4G+CPg7p0y6JbS6v4q1UyXPivx7rrHUPFvirU7mT7RfXuparcNNdJDc3TPOthFMLaN282X7RePcXc4B38v/BQ344ag5ufCv7DHj690cndFceK/ih4b8E6w0J5VpNBvPDeozRSlSpMP2tyGJXeSuT0vhr/gpt8PbDUrLR/j58J/it+z1cX86W1v4h8UaK3iLwC9w5CrAPFehw/aC+4qGlGhmzgQma6ureJWYLVHU9L03W9Pu9J1nT7LVtLv4Xtr7TtStYL6xvLeQYeC6tLlJYJ4nH3o5Y2U9xQB+k2geIdB8V6Np3iLwxrOl+IdA1e1jvdK1rRb621PStRs5hmK5sb+zkmtbqBwDtkhldSQRnIIrYr8HvDfiTXf2BPHVl408KXGqal+yn4y160sPil8PJJLnU0+F2o6xcR2lr4/8GiVpZ7WwW5kii1bTlZlvEMenSC4nm0KfQ/3Xsb6z1OytNR066gvtP1C2gvbG9tZUntbyzuolntrq2njLRzQXELpLDLGzJJG6ujFSDQBaoor8q/2zfjt488e/EeP9kD4F+ILnwtf/wBkW2u/Hv4maYxF94H8KalGklh4S0O5jZJLbxR4lsp4biWSJ4riDT72xW2mWKbWJ9OAPc/jN/wUC+Avwk8Rz+AtKm8TfGL4mW7yQz+APg/ox8X6tp9zG2ySDWL+Oe30XTpreT5L6y/tC41axwTcaYvyhvzq/aV+Pfx//aK1j9mbXtL/AGQvGHhjR/2df2n/AAV+0f8A8TX4heGZdZ8YW/hDwT8R/B58I/2JLpun3Hh+41BfiAdRGrmXWvsp0n7F/ZFwb8XVl7/8MvhL4C+EHh+Lw54E0C10m2Cxm+vyqz6zrVygIa+1rVGUXOoXTszsPMYW9uHMNnBbWyxwJ6PQBseBP+Clnwb1LXbDwl8ZfCnxB/Zx8Tak6w2T/FPRTa+D9QnZtu2x8ZWRksUt1OfM1HWLTRtMQDm8yQD+iFpd2t9bW97Y3MF5Z3cMVza3drLHcW1zbzoskM9vPEzxTQzRsskUsbMkiMroxUg1+XHifwr4b8aaLe+HPFmiab4h0PUIzHd6bqtpFd20gwQsirIpMNxETvt7qBo7m2kCywSxyKrjxn4F/EjxF+xN8U/C/wALPEuu6jr37KvxX11dA8EX+uXUl5efBTx3qMjNYaDJqdwxP/CF65MzIi3EiRWJ83VSbeTT9cudeAP21ooooAZJIkUbyyusccas8kjkKiIoLM7McBVUAlmJAABJOK/Pv4lf8FIfgd4V8Q3vgn4Y6R43/aH8bWDvDe6X8H9F/t3Q9MnRipGq+LZZYtIFuGDJJdaN/bkVvIrR3HlSJIqfOP7TvxW8WftVfFrxR+zb8OvEWo+GfgR8MrpNM+O/jLQpzban488UlmFz8MNEv0y0Wl6aY5rPxGwUpLewX8N9FLaQaZBrHdeC/A3hH4d6DaeGfBPh/TfDmiWagRWWnQCLzZAqq1zeTtuub+9lCg3F9ezXF3cMN00ztzQA8f8ABQf9oBWF1N+wl4vGj53GeH4x+GJ9Z8nP3v8AhH18KLcedswfIN0CWyu7jNexfCj/AIKKfAj4g+I7TwH41t/F/wABviHetFDaeFfjJov/AAi8ep3ErBI49I8QedPotwJ5WWGyXUbnSbzUJnWKys53ZVPC1w/xA+G/gj4peH7nwx478PWHiDSrhX2LdRAXdhOylReaXfx7LzTL6MH5Luymhm27o2ZoneNgD9aAcgEcg8g+oor8if2SPjP40+A3xV0f9kn4v+Ir7xX4F8X213P+zj8R9cm36pH/AGcge6+FviS+fCXV1Y221fD87MrKxs9MtVNrq+kaVon67UAFcz4x8aeE/h74b1Xxh448RaT4V8MaJbm61XXNcvYbDTrOEEKvmTzsqtLNIyQ21vHvuLq4kjt7aKWeSONt+5ubeytri8u54rW0tYZbm5uZ5Figt7eBGkmnmlchI4oo1Z5JHIVEUsxABNfhLrOv3/7eXxMvviV4wa8/4Zk+H/iC+0n4NfDyXzrfTPiBqmkTTWOofEnxZaEp/aEE06ywaVp9wnl28Bl0iSOJbbXh4gAPo/XP+CkWveN7q5tP2W/2ePGHxZ0mGaS3T4j+M9Sg+GngS5eJwr3Gjf2xbSajrluv3ZIJn0LUYySWs8BRJzsf7Xv7eVg/2zUP2cPgxrtkp3vpGhfES90rWGj6mJNR1e+utNEuBgP9mdckERv9099b29vZ28FpaQQ2trbQx29tbW8SQW9vBCgjhgghiVY4oYo1VI441VERQqqFAFTUAdN8Jf8Agop8MvFvifT/AIdfGPwn4p/Zx+JOpukGmaR8RhE/hPXrl3ESQeHPHlvDa6VfF5iIYpdRtNGt7u4aK2sJru5lWCv0JBBAIOQeQR0Ir8m/iB8O/B3xQ8NXvhPxxodnrmjXqt+7uEAubK42Mkd/pl4uLjTtQt9xMF5ayRzKCyEtFJJG9j9ib4xeMfhj8Sbr9jb4u6/e+JoE0W58Sfs8+PdWcyaj4i8H6ajtqPgXVbk7jcaz4WtIJriw3Euml2F/FmHTo9Bt2APM/E18/wAUv2+vjr4q1Fhc6d8BvCXgn4U+C4ZAWis7zxHpsviPxRqEC42R3y6hLq+mSTr+8k0+8SGQlFQL7zXz3otu3hX9tX9s3whqH7q81zWvh38RNGDgg3+jaz4ZDXtxbk8vDp99f2thKw+VLgvGMFcV9CUAFFFFAENzbwXlvPaXcMVza3UMtvc286LLDPbzo0U0M0bgpJFLGzJIjAq6MVYEEiof+CYmsXWjeC/jh8CLmeae0+Bnxo8QaX4W8+UyNbeCPFxfXdBtPm+fd9ui129diSrNfbVA8slrlfH37Mv7FfwC/bI8aftN/FX4zeG/Guv6Vp/xpvfBHge78IfGv42/CW3dfDOlWsXiC4ni+EHxG8CweIIrs3OjSWd1rkWptZqsyabLai5v0lAP3xr8MvhHft8Tfjz+1d8dNTb7Veal8XNX+FHheWT5jYeCfholrpdhHZ/w28OrINPu76GL5JL6yMzbpWkkf6V/4c9fsD/9E++M3/iZf7af/wBEJXyV+yX4esfhwfj78F7eOe1l+Ffx+8daLaWd3eX2o3o8MztZxeF7+41DVLi81PUP7QstOnkj1DUbu7vr1YvtN1czzySSMAfXtFFFABXN+MfC2l+N/CniLwfrcKz6T4l0bUNFvkKhiINQtpLczRbgdk9uzrPbSjDwzxxyoVdFYdJUNxcQWlvPd3MqQW1rDLcXE8rBI4YIUaSWWR2wFSONWd2JAVQSeBQB33/BNPxxq/jD9k3wbpHiGeS61/4Xa34o+E2pzyOXLL4M1RodFhUn5glj4bvNF05A2SVtA3G7A+6tT1C20rTdQ1S9fy7PTbG7v7uTGdltZwSXE74yM7Yo3bGR061+EX7F3/BPP9mH9p74N3Px1+OHw/8AGGu+I/iD8RPiFqug3mj/ABr+Ovw5tU8Iw+I7qx0+B9A+GvxL8IaBJMmq2utO2pT6U+p3MckUc93Na29kkX1RqP8AwR3/AGCzp9+NI+F3xAs9WNndDTLuf9p/9q29htdQMD/YrmazvvjbdWV3FBc+VLJbXltcWs6KYriCWJ3jYA+Xv2P/ALZ4o8C+K/jdrw83xb8ePiH4x8fa3cyEvPHa/wBv6jpelaSshAI0/TFtbyTToABHbw3zRwqkWxF+tK+T/wBia/M37O/hHRLmM2+seDdT8W+EfEFi+BNp2r6Z4o1Wd7O4UfcnWyvbKWRT0MvUjBP1hQAUUUUAeK/tFeBbT4i/BT4i+GbiFZbh/DWo6ro74HmW+vaFA+saLPE+N8Tf2hZQQytGVd7aaeEkpK6t+hn7IfxJvfi5+zL8FPiDqk73Wsa54D0mHXLyRt8l7r+hiTw9rt9I39+91fSb26YfwtMVycZPxF8UdftPC3w18f8AiO+dUtdF8HeJNRkLEDebbSLuSKFc/eluJQkEKDmSWREUFmArzX9lf/glX+x78SP2d/hH8QfjJ8Jdf134jeNvB9j4p1/Vbb4zfHXwrDeQ67JPqWgsmgeEPiZoPh3TvL8N3GkQtHp2k2YmaNrm6SS9muZpAD9Wvj58QJvhV8Efi18SLUI194J+Hfi7xHpiSBTHLq2maHe3GkwyBgVKTaklrE+VYbXOVbofye/ZP8Hp4P8AgN4CMpefWPF2lx+P/EeoTs0l7qeteM0TW5bq/mcmSe7isrmxsHlkJkZLKPezOGY9f8d/+CSv7F3hP4K/FbxV8K/g94j0z4jeGPh94t8Q+DLyT43fH/xCsev6Jol5qVgn9ieJPilq+ham1xLbC2jtNV029s5JJV8yBsDFf9nbX7TxN8CfhJq9k6yRv4A8M2ExQgql/o2mW+japCCP+ffUrC7gI4IMZBAIIoA9looooAK+V/2xNEu5/g1feONDlNj4x+EeveHvid4P1aIYuNM1bw1q1rLPPHIPnCjTpLuby8+W9zBaySA+SpX6or5u/a81628P/s4/FS4uWUNqPh4eH7SM8yT3viK+tNGgihT70kim9acqgLLFDLIcLGzAA/ZXwF4qt/HXgbwZ42tI/KtPGPhTw74ptYg24R2/iDSLPVoU3cbtkd2q574r5d/4KD/EjUvhd+yD8ZvEGiSywa3qug2fgrSpYJGiuYZ/HWsad4Turi1kT95Hd2el6tf3trLGRJHPbxtGyOFdfmzwL/wR5/YQu/BHg268f/ASfUfHdz4V8PT+NdR/4Wz8btON/wCLZtIs5PEd6bDSviVZaZZG61hryf7Jp1naWNtv8i0toLdI4k8C/bS/4Jk/skfAz9nDx/8AFv4DfBmbwx8Q/AjeG9atdU/4WL8WPE2zRR4p0a08RqdK8W+O9d0WSNNFury6nmm06SaCG2kkt3jlCtQB7f8ACvwNY/DT4c+DPAmnxRxw+GtA0/Tp2iAAudRWES6tfttABm1HVJby+nYABprh2AAIA7+svQ9YsvEOiaPr+mSibTdc0vT9Y0+ZSGWWy1O0hvbWQFSVIeCaNgQSDng4rUoAKKKKAPlD9pe/k+HGv/AX9oXS2NrrPwi+L/hldTuoyY3u/Aniy5Gj+LdHmkTDNDqNu0Fn85KxQXl7sAadt37vA8e/evwT/bRtT4j+GfhT4aWqmbWfiv8AFn4deA9GtI8mee71HXYrrKIp37FFmsTyDAR54VLBpEz9af8ADm3/AIJsNzN+zNp1y+BmW8+JfxovZyB0DXF18RppmC9FBcqo4UAcUAWf+CoGuX178J/hb8F9Pu5bP/hfXxs8F+Cdflhdo5R4PsJ5Nc1sxupDApfWmiPIOVktxPC4KyEGrY2NppllZ6bp9tFZ2Gn2tvZWVpAgjgtbS1iSC2t4YxwkUEMaRRoOFRVUcCvkf9qn9hn9lz9jbUv2dvjF8BPhPYfDaBfj14U8L/EDU7TxF4111H0LWrbUJLK5vF8U+JNdgs7XT7mwncz20VtI8txFFJK+6NK+wqACiiigAr59tNQf4V/t0fs4ePdMLW1n8YbDxX8FPHMcJEaakjWUOq+D5J1xtluY9fNgTNIDILTSYbZWC7cfQVfIHx4+HHhT4/8Ax8/ZU/Z98XaJH4n8NeLvFfjDxD440Fru+so7nwX4c8Om71O3u7zS7uw1Kyg1S3iv7WK4s7y1nMsDRwTCcxggH731+W37ecp+Ifxy/ZG+AFyRL4Y1fxR4o+LXjWwfLQ6jafDvTBP4esbyMfLNYX1zLrVpcwSAxyGWFvvRKRof8Oa/+Caf/Rr2hn2PxA+LxB9iD8QSCPUEEHoa+ZPG37J37PP7E/7W37L958Bvhjovwr8E/FGz+JnhfxBDpN5rl7aXfjCDQ4E0KW5m13VdWliu9QGpWum2kUMsUcnlyERlldx4HEt3lbi/4VTH5VSxHZ4epmeEhVjL+5Ui/Z1L6ck5J6XP2z6PyjHxGWJhrmGX8GeJGZZLb4451l/h/wASYrLq9Dr9awdal9ewbinNYvDUHBOVj0j9tTUP2w5PhtoPgj9ijw94Nj+KXxO8W23gjWPjJ8QNS07/AIRT9nDwVe6Xqd7rvxjuPBdy41D4l67pCWUWkeD/AAXp0clrd+LNY0e+8RhvDNjqsM356/8ABHKX4ueGPip/wUu+BHxS/aJ+OH7Sdt+z1+054I+Hvg/xr8d/HWr+N/E6WE/we8N67rbWZ1G4ms/D9jq3iDUL7U10PRYrfTrBZorWITCATyfr58Xfjn8E/wBn7wza+Nfjz8Yfhb8EvBt9rNt4dsvFvxd+IPhL4beGbzxBe2l/qFnoVrr3jLV9F0q41m7sNL1O9ttMiunvZ7TTr+5igeGzuHj/AJ//APgmj+29+xd4f/bG/wCCs17r37Xn7L2iWfxg/bP8E6t8JbvV/j/8KNOtvihpc3wj8J6FFqXw7nvPFsMXjawk1tH0eO78NPqUD6ojaekhuwYhWGUpQxcFT5r4W6kouUnNYzLowhF62apyqNRjZyU5uXMrWeYSo0sflVWeJ5ZfXJQlTnXjCnToPK80k5SptxUlUrwot1KnNadOlGDi9Jfql/wUF/aN8e/CPwB4N+DP7Pa2Oo/tf/tX+Jrj4O/s36Zep9psvC+oy6e1/wDEH46eKbRY7iQeAvgH4KN9498RTtaXNveapB4Z8MPE8/iW2Rvl3/giNq/xTb4O/tl/D74s/G/4s/tB6t8B/wDgo9+1F8A/DfxG+NPjLWfG/ji+8F/C2D4faHodvd6rrV7fS20DyfbtVOmWUkWnWt/qt+9rAnnyFvKPEfh3/gqR4D/b6/aL/ae8P/sMfCD9pPTtU0vS/gx+zT4o8R/theH/AITR/DD9nvRZYNZ1fS9H8FXHwy8Z3Np4q+K3jgN4w+IniG+1OO/vYtL8I+F7a1s9J8Lwi+87/wCCD/xC/ap1zxn/AMFCNC+JP7OPgzwF8NdW/wCCiH7ZvjXxx4+0n44WPjHVvCH7Qt94m+HEXiP4H6d4Oh8G6TN4m8L6DZS3l3afFmLVtOtNYktY7dPC9objfHpQjFYXEaU3OWGjVlNyhzQksThnTppStKDhT51JtRc61V0lzr2SOepiak83wjqQxdOMcTiMLSp/V8TGi6aoVlKs5qHsantqsYzUlOUaeHpUpvkbqn7O/BuY/Cv/AIKG6/4e07Nv4a/aN+Dh8T31jEfLtn+IHgG+miN+sIwnmN4eg1KW4ZR5k93q008hJzu/Wivw7+JHwL+Ff7W/7b/gX4NfFrwXp3xE+HXgn4IeIPGfjfw7qNzqNrYPcahrq2Xh6C6uNIv9Ovorm11OTR9VhijukMkckbukkHmAfRX/AA5m/wCCY/8A0aR4F/8ACg+IX/zY1zcN3VHM6a/g084xaoW+FRqU8PXrqNtEljauKTS2lzLdM9Hx7jGeb8A4yr/yNMf4XcL1c3b1qzq4PFZzlGTzrP4pTnwtlvD7hKXvSoexldppnL/tBSt8Uf8AgoB8MfA98RceGfgJ8IdQ+KYsXBa3k8ceLNaTRLGeaP7jz6fYxaHqmnSv88FxazNEV3uG8X/bg8Oftr/Fq4+HP7Pv7Kuq2XwR8CfE5dfl/aB/a+j1rS5/Hfwc8DaO+kwt4P8Agr4Jkk/tG7+L3xJi1K8tPD3j28j/AOEf+HmnaTrGrlv+Ekk8PSW7/Bv7P/wf/Y+/bnvPhb8HfA+m/Df4c/Eb9n9de8LaDplzqt1Yv4l0/wAWZ8QQW9xrF/qV691NZ6RcarcxNdFI4/LZEQMor6Q+M37TX7N37OSeHpf2hf2gvgh8B4vFz6onhST4zfFfwH8L08TvogsG1pPDz+N9f0NdafSF1XSzqi6abk2A1KwN2IheW/mebg23jM1qSip1nm+KjUjJN8ypQo0sMpJWbisNDDyhBvlknqpRnNS+84thTp8MeGGBo1ZUMoo+GPDdfBzpzVKCq5ni8wzPiCdOe0alXiTFZxQr1Yv2qqU3BTjUpQ5Pzh/4Ib+N/iR43/Yz8Xv8Ufil8S/jF4g8H/tX/tRfDnTvG/xb8Z6z4/8AHN34W8BfFLVPDnhqy1XxNrtxcX179g0uyhiRQYraNjJ9nt4I2Ea/E/xX03wd8av29P8Agotqf7TP/BUX9qT9hr4KfAn4g/sw/CP4QaR8Of22NH/Ze+GF5r/in9mnwh8Q/HlsbXxrHd+HtQ8QXms63a3gg0drC8Z5b24vIbuS5SSLtP8Agg/+1t+ylbfs/eMfhBP+03+z3D8WfHP7bn7W2p+CvhfN8aPhvH8RPGGm+KvjDr2q+F9Q8LeCX8SL4l8QWXiTS2XUtBu9J0y7g1iwZbzT3uLciQ/QGo6t/wAETLv9rT9ri0+N3h/9mvwx+09Z674eb44L+2RaaTpEviuwPgDwvaad44+FmmftFXknhafwHf8AhnTtE8O674h+FOnaXpGvXHhSwn8QpqNlD4Y1fUPZlzRrzk4Sd8JQceWOqmoYJzmlorJe1hKSvyzqptPVH5bScK2W4GEcRh7U8dWjUjXxElGcUseqdFyhJzc03SrQpuUeaFFrmWh+hX7Hnwb8NfBX4M2Og+Dv2kfjh+1Z4X8Taze+OND+L/x7+Mtr8d/FWqadrljpdtb2GhfEGw0/TbC98GW6ab9s0a0s4p7eG61DU7iO6lF3hN79iW4/4Vv+03+1h8C7XMPhbVJvC3xw8I6erbbfT5vFFvHZeM1tYAAkUE2qXGlW8EUWyOCDTEQLyAv5T/8ABCiw0C18K/t3XXwKS7h/Yc1H9uP4l3P7GUO29XwrJ4HXRvD0HxAvfhSL/wCcfCK4+IkWrReDv7OxopubXXWtFF6dSZ/tfQ/2V/gD+2x+2Z+0BZ/Hr4W+G/i38P8A4Q+CfhzoFnp3iMXr6bZ+OtXgmv0vbY6ffWMzX1jpqa9pU6tJIkW+ZJUV2hNeZjE6eb5HKLbqyx0Yq6SqKjiMpxNSvRqRVtadJJz6KpQhK11FH6Hw3OGL8NfF7D4qnCnlkOBaGMmlKVShTzXLPEDhTDZLjMPVlq6lfE4mthMNUfvzwWaYqmvcq1L/ALpV+LHiy/b4pft+/HHxLqLfadN+AXg3wR8LPBsMnzQ2l/4o02bxJ4m1KCP7sd+t7Lq+ky3C4klsLiOGQlEjWP2z/hzF/wAEuf8Aoy/4Sf8AfvxJ/wDNBXyX8G/hT4E/Zu/ac/ai/Z/+H3hjTvA/gnSv+FaeLPh14X0tZ00608Jaj4ellvY9N+0zXFw9ppuraullI0k0hF08qBsDFfXH8uH1/RRRQAVFcQQXUE1rcwx3FtcxSW9xBMiyQzwTI0csMsbgpJHJGzJIjAq6sVYEEipaKAKP/BMXWLjQ/CPx1+A1xPNNafA740a7YeFRPMZGtfBHjEPrmg2Q3fNkX0GuXrtnDSX7AABct+nu5R1I/OvwQ/Zm/Yh/ZW/bR8dftP8AxU/aM+A/gD40aZpPxluPA3w8v/Gultqa6V/wjekW0XimTR3juYQttq7T+H5ppAGWf7JBtbMbgfXX/DmX/gll/wBGN/AX/wAJib/5OoA+avhPft8Tvj/+1f8AHPUmN1dXvxb1X4R+FpZfm+weC/hnHaabaR2Q6W8GsL/Z19exR/JJfWjTNumMsj/TdfIX7JnhvS/hlN+0F8E9O0+30WL4U/tAeONG0vRLWPyoLDwfcfY4PB720RJZLG403S5Rp+4km0gj5yDj69oAKKKKAOd8XeGNL8a+FvEPhHW4RPpPiTR9Q0W/jKgn7PqFtJbPJHuB2TweYJreUYeGeOOVCrorD1X/AIJo+OtV8W/soeEtE8RXRude+FWv+KfhJqM8sm5mj8G6mV0aFd3zqlj4cv8ARtOjDZPl2atxuwOHnnhtYJrm4lSC3t4pJ55pWCRwwwoZJZZHYhUSNFZ3ZiAqgkkAV8mfsV/8E6v2L/2pvg7f/Hj9pD9lr4QfF7xf8QfiT8RNU8N+KfiF4O0/XNct/A8PiGex03R4bq6Uyxabaa1a+Ibq3t+FWe+upVGJtzAH7s6jqVnpmn32pXcyR2un2d1fXL7lOy3tIHnmfGRnbHGx6jpX4UfsgG88V+CfGHxx15TJ4t+PPxG8Y+O9YuZSXnhso9e1HStJ0dHIBGn6V9lvm02AARwQXhjiVYgiL9Vah/wRn/4JfGwvhov7C/7Nuk6ybS5Gk6ra/DjSIrnTNTML/YNQt5VTdHPZXXlXMUi/MkkasORXyz+xLftL+zx4V0G6ia21nwVq/i/wh4hsXwJtP1jTfFGq3L2c6j7kyWV/ZPIp53SZ5BBoA+sqKKKACvGP2h/Atp8Rvgt8RfC9zCsk83hrUdT0hyPnt9e0SB9X0WeN/vRkajZ28crRkM9tJPFkrIwPs9cN8TtftPCvw48eeJL51jtdD8H+I9TlLkAP9k0m7lSFQfvSTyKkEUYy0ksiRqCzAEA+1P2P/ibdfFv9mL4J+P8AVrs3Ws614F0u21y7mlDTXuvaA03hvXL6Uk58y+1bSLy7cHo0xGTjNdz8ePiG3ws+CnxY+I9o8L33gj4eeLvEumxuyMk2q6Tod7d6XAwbIKz6jHbQsCrDDn5W6H8qf2UP+CUf7AnxN/Zz+EXxE+Pf7F37O3xN+K/jjwja+KfE/jnx38LPC3iDxXr0GuXN1qHhuXVtX1GwnvbtrLwpPoemWfnys0Gn2VpbKFSFUXrvjt/wSK/4J2+Evgr8V/FXwc/Yb/Zr8FfFTwz8PfFviHwD4p8IfCTwlpHijRvFGi6JealpNzoWp2enw3VlqbXNskFrPBKkiSSjDCgDhf2TfB6+EPgN4EedpLjWvGOmr8QfEmpXDNLe6prXjRU1t7u/mfMk13FY3NhYPJIWkKWSeYzuGdvo6vGP2dNftPE3wI+EerWTrJE3gHw1p0xQgql/ommQaJqkII/54alp93Dg4IMeGAIIHs9ABRRRQB8sftiaHdXXwX1HxpokrWPjD4S634f+J3g/V4fludL1fwxqtrPNcxSLhwF06S8lEYOxriG1kcEwoV/aT4f+MbLx14D8E+N7Voobbxj4S8N+KYIRKp8qHxBo1lq0UWScny0vFXJ5OM1+Of7XWvWvh79nL4q3N0yg6h4cbw/axnl57zxHd2uiW8cScs7hr4zEKCVjiklOEjYj2n4e/wDBHf8A4JqXngHwPd/Ev/gn9+yL4r+I914Q8NXHj/xR4m+AHw21bxH4k8bT6LZSeKte8QarfeHp73U9b1fXWv8AUNV1C8mmury+uJ7ieR5ZGYgHuf8AwUa+IF94C/Y4+Mt9odyser+IdJ0rwLaGKULIYfHGv6X4Z1cRsp3K50HUtU2MCpV9pyOteBfD7whY+APA/hPwVpscaWfhjQNL0ZDGu0TSWVpFFc3b4A3TXt0Jru4kPzSzzySPlnJrxv8AbJ/4JdfsMfBz9m74mfFL9mr9i79mv4Q/FnwJp+leJNK8bfDH4M+BfBviyw0PTfEGlTeL4bfXNA0Oz1KCyn8KjV21CGO4SO4tonimzGzV7p4T8RWPi/wv4c8VaW4k07xJoela7ZOrB822q2MF7CCw43qkwRxwVdWVgCCAAdBRRRQAV8lftYXr+BrL4QfHTTj9n1z4LfGPwV4iS7XiSXw9qWpwad4i0d2GGNpq6/2fDeRgkS28TxEYcsv1rXyN+2Lav4r8EeAfhHYKZ9c+Mnxf+HvgbS7SPmVkn1yC9urwr1FraNbWqXMxBSH7VE0m1CXUA+n/ANv/AOF/ifwh4n8D/tkfDfR7rXNS+GelXPhL4y+GdOV3vfEnwgvLl72TU7aJCPNufBt9Pd6nJuVgsEsGpXbpp+gTI1HwZ4z8M/EHw1pXi/whq1trXh/WbdbmxvrZsg9pbe4iOJbW9tZQ0F5ZXCx3NpcJJBPGkiMo/VZ0SVHjkRZI5FZJEdQyOjAqysrAhlYEggggg4Nfl58T/wDgn5r/AIX8Uax8R/2O/Hmm/CjV9cuX1DxJ8I/FNpcX/wAHfEl85DSXFla2MNxfeDbiXD7v7Ks7qBAyWml/2DYrJG4Bq0V4Bc3H7dXhciy8S/sdR+KrhGMY1z4f/Fjwq2j3xGB50GmXp1HVrGFiQVXUJElC53KNpNXrD4d/8FBPipIunad8Lvh9+zfo91hbnxX468Y6b8QPEFrbsQHm0bQ/DKXVr/aKqd0Vtrumx2rMPLkuYM+coBjfHv4rar4ZttK+GPwztZPEvx2+KEg8PfDzwtpxWW9tJtQL203ivUxkpp2kaJELi8W8vfLtXmtJJJmGnWOq3Vn+nn7MHwM039nL4IeB/hPYzx397oWnvd+JdZjVh/bvi3V5n1LxHqu6RVnaCbUriaDThc5ng0q3sLWRmMANeefsz/safD79nWfVPF8+qat8TfjL4ni2eLPi34x2za9fRv5Rk03QbQyXMXhrQi8MZGn21xdXcyR28F/qd7b2VhDafYNABX48/tmeDNW/Zz+O1t+1roenXd/8J/iTYaL4I/aDtNOt57mXw1q+n+Vp3g/4jva24dnsxara6JfyLCRA8MkK+dqPiO2Ef7DVm6xo+leINK1HQ9c02x1jRtXsrnTdU0rU7WG+0/UdPvIXt7uyvbO5SS3urW5gd4Z4Jo3jljdkdSpIoA/NHSdW0zXdMsdZ0W/tNV0nU7WG907UbCeO6s720uEEkNxbXELNHLFIjBldGIIPrkVoVw3jD9gf4q/CDVdS8QfsbfELSLLwrf3U+o3nwE+K76lqPg63uZmeaceDfE1t5+r6L5znbDp900KvKfM1DxBPAkNvD5tNqv7cGiOthrn7E+parfD5BqHhb4u+C7vSLpgSPOTEd9JYxPjcsd3cGVVK+ZtY4oA+gq+VPjj4k8RfE3X9M/ZR+DTjUfih8T0Fh4s1G2DzWHwz+HVwEHiTxL4juITtsmm0uVoLa0d0u5be7Btwt/faHDqHoWnfBP8Ab7+Mkg03UtH+H/7K3hS6ITUdZudetPib8Rls5PllGhW+gzN4fjuChYZvptDvIGKy219DLGA36Dfs3/ssfDD9mTw/f6f4Lt7/AFjxT4jlW98b/EXxPcDVPGnjLUtzytcarqjIpis0mllktdLtFis4HkkuJVutRnvL+6APWvhl8PvD/wAKPh74M+G3hWA2/h/wT4d0vw5pgcJ580Om2scD3t2yBVkvtQmWW+v5gAZ7y4nmPLmu5oooA/En43+HZ/2O/wBpTxH4wv4Xtf2cv2mdf/tubXFR/wCzPhv8ZrlXfWIdXdd0VhpfjBhNqiXkoij+Zo18qy8NXksn0HHLHNHHNDIksUqLJFLGyvHJG6hkkjdSVdHUhlZSVZSCCQa/Qfx14E8IfEzwnrfgbx54f07xR4T8RWb2Or6LqsHnWt1AxV0dSCs1td20yR3NjfWskF7YXkMF5ZXEF1DFKn5Va7+xN+0l8Bppz+y78QNC+JXw0WSSWx+Dvxjubi31jw5A7hhp3hDxtaiOKe2TLLaW2sTaPZWUIBmj1O8ea7mAPUaK+fG139tm0kGn3v7DuvT6nwnnad8YfAs+jyPwA41GOC4toI2JU4kuHKDcGc7WI6LSv2aP23vjkwsPiNrXg79l34f3LFNW07wbqieOfitqFm2DLYwa5Yzv4d0lbiPMQ1PT9RtL20clpLDUIS9qwB5b43stQ/ay+K2j/sp/Dy4muPCmn6ppviH9o3xppzk6f4X8JaRfR3aeDYtQj3Qt4l16+tUtktYy8lteQwxzxyW1n4gGnfutpunWOj6dYaTplrDZabpdnbafp9lboI7ezsbKFLa0tYI1+WOG3gjjhiRcBURVHAryX4FfAH4Yfs5+CLbwF8LdAXSdLWT7ZqupXUgvdf8AEurMgS41vxHqzRpNqWpXAGM7YbS0i22mnWllYxQ20fs9ADXRZEeORFdJFZHR1DI6MCrKysCrKwJDKQQQSCCK/CW10ST9jP43698AvFm/Tvg58Sde1Pxf+zv4sui6aPZnVrlZdZ+GN5eyk29pfaRfzpHp0csqPcmaC8lPm+IrOCP93K8s+MfwX+G/x78Dal8PPij4ctvEXhzUSsyK5aDUdJ1GJJEtdY0PUosXWlatZ+bIILy2dS0Uk9pcpcWNzdW0wB8RUV5Dq37KX7ZPwHdrL4NeKvC/7R/w2tjs0jwp8StQXwp8TtEslLeRplr4qd7fw/q8NtGqQrf6peQDGyKz0Sxt0VU5oa9+2xJMdOj/AGG/EC6nkp5s3xi8CpoyuOC/9qm1SzeIEFvluBvXG1+QSAfQRIAJJAAGSTwAB1JJ6AV8y+CNBb9tH9onwv4c0JDf/s7/ALPviay8ZfEbxOgL6L47+Immb5PDfgbSLgAwapZWMpa61iSIvay6e+oF2QTaBc6h6Ho37HP7Vvx8ZLf9ojxx4d+CPwxuCBqvw1+Ed42s+OPEVpnE2leIPGk/2nStNtpo2aOd9HuNXsr2HfBdaMCY7hP1K+GXww8CfB3wZo3w++G/huw8LeE9CgMNhpdgjYLud1xeXtzM0l3qOpXkuZ77Ur+e4vrydjLczyOc0Ad9XPeLvC2ieOfCviTwX4ls11Dw74t0LVvDeuWLkhbvSdasZ9O1C33DlDLa3EqK6/MjEOpDKDXQ0UAfg78IbvXf2f8Axvqn7IXxaunh17wnLc3Pwb8U3ym3sviX8Nbm4uJtFOnzyfuH1nR4llsrnTIZGa3W2m0yASvotzNL9ZV9Y/tDfs0/C39pjwlD4X+I2l3Au9Lne/8ACni7RJ103xf4N1YhMal4e1gRStbuzRQtc2VzFc6bfGC3a8s5pbW0kg/OjU/gB+3j8FZP7P8AC58C/tV+Crc7NMuNS1mD4c/FKG0jAEcOrXOs3A8O3rRodv21r/WtSvnRp52hZhDQB7NVa8vbTTrS61DULq3sbGyt5ru8vbuaO2tbS1t42lnubm4mZIoIIYlaSWWR1jjRWZ2CgmvBYta/bc1R2sNK/Yh1my1A/J9r174v+B7TSLdv+erXEsNml3EpIJS3uUdxnY2Riu98M/sJ/HD433tlqH7XfxC0bRPAMFzb3p+BPwdn1C2sdZMEizRW3jXxpclL+5hV40W7sNLk1CKU/wCk6Tq2i3SiSgDl/wBlrwrfftWftF2H7QU9ncp8BPgFLq2lfCie9glgi+IXxLvUFpq3i60gmVGl0bw1Cq/Ybh1BTVLfSXgIul1uys/2erC8M+GfD3gzw/pHhXwno2neHvDeg2MGmaNouk2sVlp2nWNsgjhtrW2hVY40VRk4G53LSSM0jsx3aAPEP2j/AIKaN+0P8FfHvwj1qVbRfFWkFNJ1RozIdF8SadPFqfhzWQiFZHTTtZtLOe6gjeNruyW5sy4S4fP5V/AP4na3qK6t8GvixA/h748fCh/+Ef8AGmhag+25161sBHBYeNNHkfauraZrVm1peT31nvgea6ivYwmn6npjz/uHXyP+0x+x38O/2jxpXiKe/wBX+Hnxa8LR7fBnxa8Gutp4l0baZJI7DUkV4E8QaF50skj6ZdTwTwia7XTNR037dfNcgHg9FeIX/wAM/wDgoH8J3bTrz4dfDz9pfQ7XItfFHgzxbp3w68U3NspYJLrmjeJVttP/ALQZFDSW2hWN1CrMEF5csTJWdbXf7dHiY/YfDn7Gp8NXLkRnWfHfxZ8JxaPZMcr501hbf2dqd9CpBZhYSmUoBsUllNAHr/izxZ4e8D+HdV8V+K9VtdF0DRbV7vUdRvH2RRRrwsaKAZLi5uJCsFpaQJJc3dzJFb20Us0iI0P7BHw08R/ETxz4x/bP+IGj3WiReMdFj8D/AAI8OapHsv8ASfhdb3YvLnxRcwPu+z3Xi69jjuLF1ZX+xyarPbPcaNrOnyvY+G//AAT98VeNvEmj+P8A9snx9pfxKn0S6TUvD/wX8F213p3wi0W+QlobjWPt0VvqXjGWLOPI1G1gjIElnf3muaVM9mf1Lhhit4Yre3ijgggjSGGGFFjihijUJHFFGgCRxxoAqIoCqoCqAABQBJXyT+2j8AtT/aA+DV3o/hO4XTfib4I1nTfiL8K9YMi27WXjbwwZZ7K1NyxVYItYtZLrS/Olb7Pa3dzZ6jMkgsFWvrag8gj1rnxeFo47DV8JiIuVHEU5UqiTcZJSXxQktYTg7ShNawmoyWqR7vDHEeacI8Q5PxNktWNHNMjzDD5jg5VKaq0J1MPNSlQxVCXuYjB4qnz4bGYapenicLVrUKicKkk/x3+H+v8Awc/bK+G6eGPjT8LPAfjDxL4I1mGP4ifCL4q+CtB8VxeDfiBo8N9o8uqJ4Z8XabqUNsZBcavDpGqra/abe2u9R0mS4S6j1GAb9l+w/wDsWaZe2mo6d+yD+y9p+oafdW97YX9l8APhRa3tle2sqT2t3aXUHhKOe2uraeNJre4hdJYZUSSN1dQR9E/tE/sU+Hfi34og+LXw28V6p8FPjzp8CwwfETwxBHPZeI7eFESLTfHfh5ngtfEVp5UMVsLmSSO7+zRwW97/AGpY2drp6fM8rf8ABQX4altO8U/s++BvjpaWv7uPxd8L/H+n+E5r2NcBZ7vQPE8QvmvJAQZ0sNHsrRJA/lL5YVm+T5syy39zjsPi8RGDtTzHL8PWxMMRFW5Z18LhVUxOGxFkvapUJ4eUrypV7P2UP6XhhOA+P3/a/BuecNZDi8WlUx3AvGed5dw5jMkxM/eq4TJeIOIa+ByDiDJY1HNZZVlmuGzuGG5KGYZZ7WH1rFfWFeGeNfEfwb/Zh8D+MvG8mheFfA2la14i1fxhrdj4V0PR9C1Dx/8AEXxEFm1DUZbTTLeyPiPxv4omtITqWtXwuNQultzfavfC0spbiHgIvE37enjULY+EP2SdE+Hbzny/+Em+KXxQ0S+0uwLfL502g6GNN164WLcH/wBFiuC21l8liMH2P4O/sLXUfjXSfjH+1H48Pxw+J+jOt14X0KKy/s74WfD66EiSpJ4d8OSRQrq2oWssUb2+ralZWI8yOG7l0qTVbW21NJjWx2NfsstwWKjKaUZYzH4XEYHC4eLcX7R08VChiMU42ThQoUpQqNJTrUYe+bVsq4P4SSzPj7i3h2vQwr9rS4V4K4iyXi7iXO6sVeGCp4zh3FZtkPD1Ct/DxWZ5xmVOvhKEp1sHleZ14wwlS/8AsGfB7xlomleO/wBof4uaa2mfFj9oTU7LXZtDuEYXHgn4f6bC8Pgzwoyyos9rdCykW71G3kEc4hTR7bUYY9T0+6UfoRSAYGB0FLX1WAwVPL8JRwlJymqak51Z29pXrVJyqV69VpJOpXqznVm0kuaTSSSSX838bcXZhxzxPmnE2Y0sPhauPnQp4XL8GpxwOU5XgMLQy7KMnwEZylOOBynK8LhMvwqqSlUdHDwlVnOrKc5fAv7ePwW8YeM/DHgr40/CSyN78Y/2fNbufF/hzTIklabxd4WvIYovGngsJARNcyatp1rFNa20e+e7+y3Wk2SLc6sHHg+j6b+zD+214F8K+MvGnwp+FPxdttE+3RW2ifFPwB4Q8d6n8Pte1COx/wCEi0VbPxTo+qNol7M1lYC9ls0t4tXtrPTrtHubVbNx+uJGRg9DX55/Gv8AYZbVvG+pfGf9mzx1J8DPi9qjPP4jgishqHw4+Ic5Z5XPi7wyEkitr66mZpLjWbG1u900k+oyaRcavcSaifFzLL8XQxdTM8upfWFiI01j8Cpxp1ak6UY06eMwc6koUvrCpKNGtSqTpxrUoU3GpGdLlq/q/AXG/DWccM4Lw+47x6yOWTVsZU4K4vrYXE47Lsvw+ZYiWNx3DHEuFwVHE4+OR1syqV81yzNMBhMbiMozDGZjHEYHFYPMXXy7zjwt+x7+yR4G8Q6T4u8E/st/s5+D/FegXaahoXifwr8Efhp4e8Q6LfxhljvdJ1rSPDNnqWnXaK7BLmzuYZlDMFcAmtv4t/sx/s2fH+60W9+O/wCz38D/AI13vhvP/CPXfxb+E/gL4kXWg5lac/2NP4x0DWZdLzMzTH7C8H71jJ98lq8+l1/9vjwKGsfGH7KXh34mm3PlDxR8K/ibpGmadf7MqJ49A19NQ1+IShfMJmtbQAsF8mMnYjorr/goH8RtuneE/wBnHwV8FILrMb+Lvip8RNO8TLYI3ytcQ6B4Xjj1UXMQy8C3OlX1s77PNiZNwrz/AO0rtRWDzl1ltSeU5lGalpp7WeHjhlfT33XVPrz21PuV4fxjTdafFnhVSyiVpzzP/iJnAlTDOmrNTeXYfO62e1JpO/1OOTzzC94/VOf3X03xl+LPgn9mz4cafZaJounJrE1tb+E/hJ8LfDGnw2smtauscNhoeg6D4f0mGMWmi2EklnFcLYWqQWdqYbO0he8udPs7n6L/AGI/gJrnwM+Ek0vjyVbz4ufFDxBqHxK+Kt9mOVl8T+ICsq6Ks8WUeHQLMRWciwSy2Z1STVbiyb7NcpXNfs+fsSaF8NfFp+MPxb8Yal8cPjxPD5cXjXxDaR2mh+EYZFk32HgPwyrS2eiRos8sAvh/pAieX+zrbRYry+tJ/uwcAD04r08ry/FTxX9qZjBUakKc6WCwXPGrLDQqtOtXxFSDlTni6yjGny05Tp4elGUYVakq1Vr8+8ROOeHcLw4/DzgTG1M3wGLx2EzLjDi6WFr5fQ4ixeWxqrKsoyLBYuFHH4fhjKqletjHWzKhhcdnWZyw+Lr4DA0MtwFFlflx+3/8L/FHhTxH4G/bF+G2j3Wuar8MNLuvCnxh8M6cjve+Jfg/e3L3s2oW0UZHm3Xg2+nu9UYMrBYJ49SupFsdBkjf9R6a6JIjRyIrxupR0dQyOrDDKysCGVgSCCCCDgivoz8GPyp8F+NPDPxC8M6V4v8ACGrW2taBrNstzZXts2evEttcxHEtpe2soa3vLO4WO4tbiOSGeNJEIrqKy/ih/wAE/de8M+KNY+JH7HnjzTvhPrOuXL6h4k+Evie0uNQ+Dvia9dg0lxZ2llDcX3g25lO/cdJs7uFFKWmlroVmJEk8UuJ/26/Cx+xeJf2OovFlwjeWNc+H3xY8KnSL5hgebBpd9/aOr2MLH5l/tB0kCn5kBUmgD3+vnX49/FjU/Ctppfw1+G1rJ4l+OvxPkHh74deFdN2zX1tcagXtpPFWpLkpp+kaLGLi8W8vfLtZJ7R3lZdPstVurLZsPh5/wUE+Kbrp2m/Cz4e/s4aRdALceK/HnjLTfH+v2tuSBJNo+h+GI7q2GoqhLQ2uu6ZHasw8uS5hyJl+3v2Zv2M/AH7O1zqnjG51XVvid8ZvE8Rj8V/Fvxhtm1y8jcR+ZpugWZkuY/DOhkxR4sLW5uruaOOC3vtSvLazsILQA9D/AGXfgXpv7OPwP8D/AApsriPUL/RrCS+8Ua1GG/4nvi/WZn1LxHqu+RVneCXUZ5bfTvtGbiLSrawt5WLQ5r6AoooA/Hv9s/wZq37O3x0s/wBrbQtNvL/4VfEXT9G8DftC2mnW81zN4d1PTzFp/g/4jtbW4ZpLWO1Frol84ixAYDAvnX/iKBovRNJ1bTNe0yw1rRb+01XSdUtYb7TtRsJ47qzvbS4QSwXFtcRM0csUqMGVlYgg+uRX6X6vpGl+INK1HQ9c06y1fRtXsrnTdU0rUrWC+0/UdPvIXt7uyvbO5SW3urW5gkeGeCaN4pYnZHVlYivyo8Y/sDfFP4Q6rqXiL9jb4haTYeF7+6n1G9+AfxWfUtS8FwXMzPLP/wAIb4ktjPq+iecxCxafdGIPKfMv/EMtskNrAAdxRXz7Nqv7cGiOLDW/2J9R1W+B2DUPC3xe8F3ekXRBI86MLHfS2UT4LKl5cGVFK+ZtJxWzp3wV/b7+Mcg03UNF+H37K3hW6ITUdZvNes/ib8RUs5Btl/sO30GV/D8dwYywzfS6JdwMVltb+GaNcgHn3xz8TeI/iRrum/sqfBp11L4p/FCP7B4nv7ffLY/DT4eXAQeJPE3iS4gyLEy6XK8FtasyXclvdB7ZRf3miQ6h+z3wv+Hfh/4S/DvwZ8NPCsJh0DwT4d0vw7p28KJ7iLTrZIZL67KAK99qNwJr+/lAHnXtzPMRlzXk37N37K3ww/Zk0C/sfBlvf6z4r8RyreeOPiN4ouBqnjTxlqW95Wn1TU2RTBZJNJJJa6VaLFaQs73Ewu9Rmu9QufpWgAr8Svjl4dm/Y8/aU8ReNb2B7b9nP9pnXV1m81tEf+zPht8Zp1kbVl1Z0DRWOleMW87VPtkoiQs8iL5Vn4buXm/bWuT8ceBfCHxK8Ka34H8eeH9N8UeFPEVm9hrGiarB51pd27MrocgpLb3NvMkdzZXtrLDeWN3FDeWc8F1DFKgB+fEUsc0cc0MiTQzIksUsTLJHLHIodJI3QlXR1IZHUlWUggkEGn15fr37Ev7R/wABp52/Zb+IGh/Ef4arLJLZ/Bv4yXNzBq/h2B3Df2d4P8b2ojjmtkJdbS21eXR7Kyiw06areNLdTcY2u/ttWcq6dffsO69NqfCefpvxh8C3GjyScfONQiguLa3iYkH95cv5YyGclTQB9B18l+OrPUf2sPippH7KPw6uJp/DNnqmneIP2jPGenMTp/hXwhpF/FdjwhFfx7oW8S69e26W0drGzSW95FDDOkltb6+NO9S0v9mn9uD45OLD4iaz4O/Zc8AXJ2atYeD9Uj8dfFbULNjmWxt9csJ28O6Ss8f7sanYalZ31o53vY38JktW/Sr4E/AD4Yfs5eB7bwH8LtBGlaaJBeavql3KL3xD4n1do1SfWvEerMkcuo6jPjjCQWdnFttdNs7KyjitowD1rTNNsNG03T9H0q0hsNL0qytdN06xtkEdvZ2FjBHa2lrBGOEht7eKOGJBwqIo7VcdEkRo5FV0dSjo6hldWGGVlOQVIJBBGCODTqKAPwjg0OT9jL446/8AAbxUG074M/E7X9T8Y/s9eLLkumj2EurXKS6z8Mb29kzBZ3uk3s0cempNKhuBLb3kref4htoYvqyvt74xfBj4cfHrwNqfw8+KHhu08SeG9SxKkcu6C/0rUIkkS11jRNSh23elatZ+bJ5F5ayIzRST2lws9lc3VtN+YerfsoftkfAdms/gx4s8L/tG/Da2O3SPCXxMv18K/E3RbJS3k6ZZ+Ky9voGsRW8QSFb/AFa9tgBsis9EsrdMKAevUhIAJJAAGSTwAB1JJ6AV8+jXv22JJjp0f7DfiBdTyY/Ml+MXgRdHWTpv/tQ2yWjxAgt8twNy4AfkE9Vo/wCx1+1d8fGS3/aG8c+Hfgf8Mbggat8NvhHeNrPjnxFZkgTaVr3jSf7TpOmW80bNHNJpFxq9leQl7e60Y7knQA878G6A/wC2j+0P4Y8L6Eh1D9nn9n/xPY+MviX4oQGTRPHPxB0wtJ4b8CaTOoMGqWVnKWn1l4ne1l0+TUGd42fQJ9Q/c2uA+GPwu8B/BvwXo/w++G3huw8L+FNDhMVjptijEvJId1ze311M0l3qOpXsuZ77Ub6e4vbuZjJPPI3I7+gDM1rRtM8RaNq3h/W7KDUtG13Tb7R9X066QSW1/pmp2stlf2VzGeJILq1nlgmQ/ejkZe9fhX4Th1T9kH4l3f7L3xSuriHwTqOo6hqv7OvxG1Q7NK8SeGL+8a5PgvU9TcR29t4n0K6uxbNbzGIS3M3kQLBZXvhpNR/eevK/jF8Ffhp8e/Bd94B+Kfhey8T+HbxhPEk+6DUNK1BEeO31bQ9UtzHfaRqtsskixXtlNFI0Mk1rP51ncXFvKAfEdFea6n+xR+1j8IGa2+APxt8J/E/wPbZGmeCPj7Z6lFr+j2aALDp9j4z8NwPPq3lRhY7f7Z/YOn2sapFDYqqsZMGL4b/8FHdTkFhF8KvgB4bkc+Wdd1nx1qupaXDkYM/2DRrqfUyq53BPJlbIwY26UAeo69r+i+FtH1HxB4i1Sy0XRNJtpLzUdT1GdLaztLeMfNJLLIQASSEjRcySyskUSPK6IfP/ANjzwDrf7SPxtg/az8VaRfaV8JPhxaax4c/Z30jV7U29z4l1jUN1h4k+Jk1ncKSln5Cy2GkMUw90trJE8V34emku+78D/wDBOzW/GWt6X4s/a/8AivJ8X20q6j1DTPhP4RtJ/DHwl069hJMT6lCFttU8WrFk+W19a6RJJGXtdRbU7GWW2b9QbCwsdLsbPTNMs7XTtO0+1t7KwsLG3htLKys7WJILW0tLW3SOC2treCNIYIIY0ihiRI40VFAABbooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAP//Z" + } + }, + "cell_type": "markdown", + "id": "f4d882fa", + "metadata": {}, + "source": [ + "We will use the [ffsim](https://github.com/qiskit-community/ffsim/tree/main) package to create and initialize the ansatz with `t2` and `t1` amplitudes computed above. Since our molecule has a closed-shell Hartree-Fock state, we will use the spin-balanced variant of the UCJ ansatz, [UCJOpSpinBalanced](https://qiskit-community.github.io/ffsim/api/ffsim.html#ffsim.UCJOpSpinBalanced).\n", + "\n", + "As our target IBM hardware has a heavy-hex topology, we will adopt the _zig-zag_ pattern used in [this paper](https://pubs.rsc.org/en/content/articlelanding/2023/sc/d3sc02516k) for qubit interactions. In this pattern, orbitals (represented by qubits) with the same spin are connected with a line topology (red and blue circles) where each line take a zig-zag shape due the heavy-hex connectivity of the target hardware. Again, due to the heavy-hex topology, orbitals for different spins have connections between every 4th orbital (0, 4, 8, etc.) (purple circles).\n", + "\n", + "![lucj_ansatz_zig-zag-pattern-rsz.jpg](attachment:lucj_ansatz_zig-zag-pattern-rsz.jpg)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dd69a86c", + "metadata": {}, + "outputs": [], + "source": [ + "import ffsim\n", + "from qiskit import QuantumCircuit, QuantumRegister\n", + "\n", + "n_reps = 2\n", + "alpha_alpha_indices = [(p, p + 1) for p in range(num_orbitals - 1)]\n", + "alpha_beta_indices = [(p, p) for p in range(0, num_orbitals, 4)]\n", + "\n", + "ucj_op = ffsim.UCJOpSpinBalanced.from_t_amplitudes(\n", + " t2=t2,\n", + " t1=t1,\n", + " n_reps=n_reps,\n", + " interaction_pairs=(alpha_alpha_indices, alpha_beta_indices),\n", + ")\n", + "\n", + "nelec = (num_elec_a, num_elec_b)\n", + "\n", + "# create an empty quantum circuit\n", + "qubits = QuantumRegister(2 * num_orbitals, name=\"q\")\n", + "circuit = QuantumCircuit(qubits)\n", + "\n", + "# prepare Hartree-Fock state as the reference state and append it to the quantum circuit\n", + "circuit.append(ffsim.qiskit.PrepareHartreeFockJW(num_orbitals, nelec), qubits)\n", + "\n", + "# apply the UCJ operator to the reference state\n", + "circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(ucj_op), qubits)\n", + "circuit.measure_all()" + ] + }, + { + "cell_type": "markdown", + "id": "db11bf6d", + "metadata": {}, + "source": [ + "## Step 2: Optimize for target hardware" + ] + }, + { + "cell_type": "markdown", + "id": "0760b3f3", + "metadata": {}, + "source": [ + "Next, we will optimize our circuit for a target hardware. We need to choose the hardware device to use before optimizing our circuit. We will use a fake 127-qubit backend from ``qiskit_ibm_runtime`` to emulate a real device." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "53a039d8", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_ibm_runtime.fake_provider import FakeSherbrooke\n", + "\n", + "backend = FakeSherbrooke()" + ] + }, + { + "cell_type": "markdown", + "id": "057ebbf6", + "metadata": {}, + "source": [ + "Next, we recommend the following steps to optimize the ansatz and make it hardware-compatible.\n", + "\n", + "- Select physical qubits (`initial_layout`) from the target harware that adheres to the zig-zag pattern described above. Laying out qubits in this pattern leads to an efficient hardware-compatible circuit with less gates.\n", + "- Generate a staged pass manager using the [generate_preset_pass_manager](https://docs.quantum.ibm.com/api/qiskit/transpiler_preset#generate_preset_pass_manager) function from qiskit with your choice of `backend` and `initial_layout`.\n", + "- Set the `pre_init` stage of your staged pass manager to `ffsim.qiskit.PRE_INIT`. `ffsim.qiskit.PRE_INIT` includes qiskit transpiler passes that decompose and merge orbitals resulting in fewer gates in the final circuit.\n", + "- Run the pass manager on your circuit. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7d554aa5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gate counts (w/o pre-init passes): OrderedDict({'rz': 7421, 'sx': 6016, 'ecr': 2240, 'x': 324, 'measure': 32, 'barrier': 1})\n", + "Gate counts (w/ pre-init passes): OrderedDict({'rz': 4155, 'sx': 3186, 'ecr': 1262, 'x': 210, 'measure': 32, 'barrier': 1})\n" + ] + } + ], + "source": [ + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "spin_a_layout = [0, 14, 18, 19, 20, 33, 39, 40, 41, 53, 60, 61, 62, 72, 81, 82]\n", + "spin_b_layout = [2, 3, 4, 15, 22, 23, 24, 34, 43, 44, 45, 54, 64, 65, 66, 73]\n", + "initial_layout = spin_a_layout + spin_b_layout\n", + "\n", + "pass_manager = generate_preset_pass_manager(\n", + " optimization_level=3, backend=backend, initial_layout=initial_layout\n", + ")\n", + "\n", + "# without PRE_INIT passes\n", + "isa_circuit = pass_manager.run(circuit)\n", + "print(f\"Gate counts (w/o pre-init passes): {isa_circuit.count_ops()}\")\n", + "\n", + "# with PRE_INIT passes\n", + "# We will use the circuit generated by this pass manager for hardware execution\n", + "pass_manager.pre_init = ffsim.qiskit.PRE_INIT\n", + "isa_circuit = pass_manager.run(circuit)\n", + "print(f\"Gate counts (w/ pre-init passes): {isa_circuit.count_ops()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0cc1edef", + "metadata": {}, + "source": [ + "## Step 3: Execute on target hardware" + ] + }, + { + "cell_type": "markdown", + "id": "cbf7ef9f", + "metadata": {}, + "source": [ + "After optimizing the circuit for hardware execution, we are ready to run it on the target hardware and collect samples for ground state energy estimation. As we only have one circuit, we will use Qiskit Runtime's [Job execution mode](https://docs.quantum.ibm.com/guides/execution-modes) and execute our circuit.\n", + "\n", + "**Note: We have commented out the code for running the circuit on a QPU and left it for the user's reference. Instead of running on real hardware in this guide, we will just generate random samples drawn from the uniform distribution.**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3da09100", + "metadata": {}, + "outputs": [], + "source": [ + "# from qiskit_ibm_runtime import SamplerV2 as Sampler\n", + "\n", + "# sampler = Sampler(mode=backend)\n", + "# job = sampler.run([isa_circuit], shots=10_000)\n", + "# primitive_result = job.result()\n", + "# pub_result = primitive_result[0]\n", + "# counts = pub_result.data.meas.get_counts()\n", + "\n", + "from qiskit_addon_sqd.counts import generate_counts_uniform\n", + "\n", + "rand_seed = 42\n", + "counts = generate_counts_uniform(10_000, num_orbitals * 2, rand_seed=rand_seed)" + ] + }, + { + "cell_type": "markdown", + "id": "6df05b6e", + "metadata": {}, + "source": [ + "## Step 4: Post-process results" + ] + }, + { + "cell_type": "markdown", + "id": "851bc98e-9c08-4e78-9472-36301abc11d8", + "metadata": {}, + "source": [ + "### Transform the counts into a bitstring matrix and probability array for post-processing\n", + "\n", + "In order to speed up the bitwise processing required in this workflow, we use Numpy arrays to hold representations of the bitstrings and sampling frequencies." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7a102a7f-aae6-4583-ab82-ae40fcb5496a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from qiskit_addon_sqd.counts import counts_to_arrays\n", + "\n", + "# Convert counts into bitstring and probability arrays\n", + "bitstring_matrix_full, probs_arr_full = counts_to_arrays(counts)" + ] + }, + { + "cell_type": "markdown", + "id": "eb704101-0fe8-4d12-b572-b1d844e35a90", + "metadata": {}, + "source": [ + "### Iteratively refine the samples using SQD and approximate the ground state\n", + "\n", + "There are a few user-controlled options which are important for this technique:\n", + "- ``iterations``: Number of self-consistent configuration recovery iterations\n", + "- ``n_batches``: Number of batches of configurations used by the different calls to the eigenstate solver\n", + "- ``samples_per_batch``: Number of unique configurations to include in each batch\n", + "- ``max_davidson_cycles``: Maximum number of Davidson cycles run by each eigensolver" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b72c048e-fe8e-4fc2-b28b-03138249074e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting configuration recovery iteration 0\n", + "Starting configuration recovery iteration 1\n", + "Starting configuration recovery iteration 2\n", + "Starting configuration recovery iteration 3\n", + "Starting configuration recovery iteration 4\n" + ] + } + ], + "source": [ + "from qiskit_addon_sqd.configuration_recovery import recover_configurations\n", + "from qiskit_addon_sqd.fermion import (\n", + " bitstring_matrix_to_sorted_addresses,\n", + " flip_orbital_occupancies,\n", + " solve_fermion,\n", + ")\n", + "from qiskit_addon_sqd.subsampling import postselect_and_subsample\n", + "\n", + "# SQD options\n", + "iterations = 5\n", + "\n", + "# Eigenstate solver options\n", + "n_batches = 10\n", + "samples_per_batch = 300\n", + "max_davidson_cycles = 200\n", + "\n", + "# Self-consistent configuration recovery loop\n", + "e_hist = np.zeros((iterations, n_batches)) # energy history\n", + "s_hist = np.zeros((iterations, n_batches)) # spin history\n", + "occupancy_hist = np.zeros((iterations, 2 * num_orbitals))\n", + "occupancies_bitwise = None # orbital i corresponds to column i in bitstring matrix\n", + "for i in range(iterations):\n", + " print(f\"Starting configuration recovery iteration {i}\")\n", + " # On the first iteration, we have no orbital occupancy information from the\n", + " # solver, so we just post-select from the full bitstring set based on hamming weight.\n", + " if occupancies_bitwise is None:\n", + " bs_mat_tmp = bitstring_matrix_full\n", + " probs_arr_tmp = probs_arr_full\n", + "\n", + " # In following iterations, we use both the occupancy info and the target hamming\n", + " # weight to refine bitstrings.\n", + " else:\n", + " bs_mat_tmp, probs_arr_tmp = recover_configurations(\n", + " bitstring_matrix_full,\n", + " probs_arr_full,\n", + " occupancies_bitwise,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " rand_seed=rand_seed,\n", + " )\n", + "\n", + " # Throw out samples with incorrect hamming weight and create batches of subsamples.\n", + " batches = postselect_and_subsample(\n", + " bs_mat_tmp,\n", + " probs_arr_tmp,\n", + " num_elec_a,\n", + " num_elec_b,\n", + " samples_per_batch,\n", + " n_batches,\n", + " rand_seed=rand_seed,\n", + " )\n", + "\n", + " # Run eigenstate solvers in a loop. This loop should be parallelized for larger problems.\n", + " int_e = np.zeros(n_batches)\n", + " int_s = np.zeros(n_batches)\n", + " int_occs = np.zeros((n_batches, 2 * num_orbitals))\n", + " cs = []\n", + " for j in range(n_batches):\n", + " addresses = bitstring_matrix_to_sorted_addresses(batches[j], open_shell=open_shell)\n", + " energy_sci, coeffs_sci, avg_occs, spin = solve_fermion(\n", + " addresses,\n", + " hcore,\n", + " eri,\n", + " spin_sq=spin_sq,\n", + " max_davidson=max_davidson_cycles,\n", + " )\n", + " energy_sci += nuclear_repulsion_energy\n", + " int_e[j] = energy_sci\n", + " int_s[j] = spin\n", + " int_occs[j, :num_orbitals] = avg_occs[0]\n", + " int_occs[j, num_orbitals:] = avg_occs[1]\n", + " cs.append(coeffs_sci)\n", + "\n", + " # Combine batch results\n", + " avg_occupancy = np.mean(int_occs, axis=0)\n", + " # The occupancies from the solver should be flipped to match the bits in the bitstring matrix.\n", + " occupancies_bitwise = flip_orbital_occupancies(avg_occupancy)\n", + "\n", + " # Track optimization history\n", + " e_hist[i, :] = int_e\n", + " s_hist[i, :] = int_s\n", + " occupancy_hist[i, :] = avg_occupancy" + ] + }, + { + "cell_type": "markdown", + "id": "9d78906b-4759-4506-9c69-85d4e67766b3", + "metadata": {}, + "source": [ + "### Visualize the results\n", + "\n", + "The first plot shows that after a couple of iterations we estimate the ground state energy within ``~200 mH``. Remember, the quantum samples in this demo were pure noise. The signal here comes from *a priori* knowledge of the electronic structure and molecular Hamiltonian.\n", + "\n", + "The second plot shows the average occupancy of each spatial orbital after the final iteration. We can see that both the spin-up and spin-down electrons occupy the first five orbitals with high probability in our solutions." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "caffd888-e89c-4aa9-8bae-4d1bb723b35e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Data for energies plot\n", + "x1 = range(iterations)\n", + "n2_exact = -109.10288938\n", + "y1 = [np.min(energies) for energies in e_hist]\n", + "yt1 = [float(i) for i in range(-110, -106)]\n", + "\n", + "# Data for avg spatial orbital occupancy\n", + "y2 = avg_occupancy[:num_orbitals] + avg_occupancy[num_orbitals:]\n", + "x2 = range(len(y2))\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Plot energies\n", + "axs[0].plot(x1, y1, label=\"Estimated\")\n", + "axs[0].set_xticks(x1)\n", + "axs[0].set_xticklabels(x1)\n", + "axs[0].set_yticks(yt1)\n", + "axs[0].set_yticklabels(yt1)\n", + "axs[0].axhline(y=n2_exact, color=\"red\", linestyle=\"--\", label=\"Exact\")\n", + "axs[0].set_title(\"Approximated Ground State Energy vs SQD Iterations\")\n", + "axs[0].set_xlabel(\"Iteration Index\")\n", + "axs[0].set_ylabel(\"Energy (Ha)\")\n", + "axs[0].legend()\n", + "\n", + "# Plot orbital occupancy\n", + "axs[1].bar(x2, y2, width=0.8)\n", + "axs[1].set_xticks(x2)\n", + "axs[1].set_xticklabels(x2)\n", + "axs[1].set_title(\"Avg Occupancy per Spatial Orbital\")\n", + "axs[1].set_xlabel(\"Orbital Index\")\n", + "axs[1].set_ylabel(\"Avg Occupancy\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/index.rst b/docs/tutorials/index.rst new file mode 100644 index 0000000..ba7fbd6 --- /dev/null +++ b/docs/tutorials/index.rst @@ -0,0 +1,10 @@ +######### +Tutorials +######### + +This page summarizes the available tutorials. + +.. nbgallery:: + :glob: + + * diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..2e33465 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,150 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +name = "qiskit-addon-sqd" +version = "0.3.0" +readme = "README.md" +license = {file = "LICENSE.txt"} +classifiers = [ + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: Apache Software License", + "Natural Language :: English", + "Operating System :: POSIX :: Linux", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering :: Physics", +] + + +requires-python = ">=3.10" + +dependencies = [ + "numpy>=1.26", + "pyscf>=2.5", + "jaxlib>=0.4", + "jax>=0.4", + "scipy>=0.13", +] + +[project.optional-dependencies] +dev = [ + "qiskit-addon-sqd[test,nbtest,lint,docs]", +] +basetest = [ + "tox>=4.0", + "pytest>=8.0", + "pytest-cov>=5.0", +] +test = [ + "qiskit-addon-sqd[basetest]", +] +doctest = [ + "qiskit-addon-sqd[basetest,notebook-dependencies]", + "pytest-doctestplus>=1.2.1", +] +nbtest = [ + "qiskit-addon-sqd[basetest]", + "nbmake>=1.5.0", +] +style = [ + "ruff==0.6.4", + "nbqa>=1.8.5", +] +lint = [ + "qiskit-addon-sqd[style]", + "mypy==1.11.2", + "pylint>=3.2.7", + "pydocstyle==6.3", + "reno>=4.1", + "toml>=0.9.6", +] +notebook-dependencies = [ + "qiskit-addon-sqd", + "matplotlib", + "ffsim", + "qiskit", + "qiskit-ibm-runtime", +] +docs = [ + "qiskit-addon-sqd[doctest]", + "qiskit-sphinx-theme~=2.0.0", + "jupyter-sphinx", + "sphinx-design", + "sphinx-autodoc-typehints", + "sphinx-copybutton", + "nbsphinx>=0.9.4", + "reno>=4.1", +] + +[tool.hatch.build.targets.wheel] +only-include = [ + "qiskit_addon_sqd", +] + +[tool.hatch.metadata] +allow-direct-references = true + +[tool.mypy] +python_version = "3.10" +show_error_codes = true +warn_return_any = true +warn_unused_configs = true +ignore_missing_imports = true + +[tool.pylint.main] +py-version = "3.10" + +[tool.pylint."messages control"] +disable = ["all"] +enable = [ + "reimported", + "no-self-use", + "no-else-raise", + "redefined-argument-from-local", + "redefined-builtin", + "raise-missing-from", + "cyclic-import", + "unused-argument", + "attribute-defined-outside-init", + "no-else-return", +] + +[tool.pytest.ini_options] +testpaths = ["./qiskit_addon_sqd/", "./test/"] + +[tool.ruff] +line-length = 100 +src = ["qiskit_addon_sqd", "test"] +target-version = "py39" + +[tool.ruff.lint] +select = [ + "I", # isort + "E", # pycodestyle + "W", # pycodestyle + "F", # pyflakes + "RUF", # ruff + "UP", # pyupgrade + "SIM", # flake8-simplify + "B", # flake8-bugbear + "A", # flake8-builtins +] +ignore = [ + "E501", # line too long +] + +[tool.ruff.lint.pylint] +max-args = 6 + +[tool.ruff.lint.extend-per-file-ignores] +"docs/**/*" = [ + "E402", # module level import not at top of file +] + +[tool.typos.default.extend-words] +IY = "IY" diff --git a/qiskit_addon_sqd/__init__.py b/qiskit_addon_sqd/__init__.py new file mode 100644 index 0000000..f823093 --- /dev/null +++ b/qiskit_addon_sqd/__init__.py @@ -0,0 +1,31 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Primary SQD functionality. + +.. currentmodule:: qiskit_addon_sqd + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + +Modules +======= +.. autosummary:: + :toctree: + + configuration_recovery + subsampling + counts + fermion + qubit +""" diff --git a/qiskit_addon_sqd/configuration_recovery.py b/qiskit_addon_sqd/configuration_recovery.py new file mode 100644 index 0000000..b8a9147 --- /dev/null +++ b/qiskit_addon_sqd/configuration_recovery.py @@ -0,0 +1,297 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Functions for performing self-consistent configuration recovery. + +.. currentmodule:: qiskit_addon_sqd.configuration_recovery + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + post_select_by_hamming_weight + recover_configurations +""" + +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np + + +def post_select_by_hamming_weight( + bitstring_matrix: np.ndarray, hamming_left: int, hamming_right: int +) -> np.ndarray: + """ + Post-select bitstrings based on the hamming weight of each half. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring + hamming_left: The target hamming weight of the left half of bitstrings + hamming_right: The target hamming weight of the right half of bitstrings + + Returns: + A mask signifying which samples were selected from the input matrix. + """ + if hamming_left < 0 or hamming_right < 0: + raise ValueError("Hamming weights must be non-negative integers.") + num_bits = bitstring_matrix.shape[1] + + # Find the bitstrings with correct hamming weight on both halves + up_keepers = np.sum(bitstring_matrix[:, : num_bits // 2], axis=1) == hamming_left + down_keepers = np.sum(bitstring_matrix[:, num_bits // 2 :], axis=1) == hamming_right + correct_bs_mask = np.array(np.logical_and(up_keepers, down_keepers)) + + return correct_bs_mask + + +def recover_configurations( + bitstring_matrix: np.ndarray, + probabilities: Sequence[float], + avg_occupancies: np.ndarray, + hamming_left: int, + hamming_right: int, + rand_seed: int | None = None, +) -> tuple[np.ndarray, np.ndarray]: + """ + Refine bitstrings based on average orbital occupancy and a target hamming weight. + + This function makes the assumption that bit ``i`` represents the same orbital as + bit ``i + # orbitals`` in all input bitstrings, s.t. i < # orbitals. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring + probabilities: A 1D array specifying a probability distribution over the bitstrings + avg_occupancies: A 1D array containing the mean occupancy of each orbital. It is assumed + that ``avg_occupancies[i]`` corresponds to the orbital represented by column + ``i`` in ``bitstring_matrix``. + hamming_left: The target hamming weight used for the left half of the bitstring + hamming_right: The target hamming weight used for the right half of the bitstring + rand_seed: A seed to control random behavior + + Returns: + A corrected bitstring matrix and an updated probability array + """ + if hamming_left < 0 or hamming_right < 0: + raise ValueError("Hamming weights must be non-negative integers.") + + # First, we need to flip the orbitals such that + + corrected_dict: dict[str, float] = {} + for bitstring, freq in zip(bitstring_matrix, probabilities): + bs_corrected = _bipartite_bitstring_correcting( + bitstring, + avg_occupancies, + hamming_left, + hamming_right, + rand_seed=rand_seed, + ) + bs_str = np.array2string(bs_corrected.astype(int), separator="")[1:-1] + corrected_dict[bs_str] = corrected_dict.get(bs_str, 0.0) + freq + bs_mat_out = np.array([[bit == "1" for bit in bs] for bs in corrected_dict]) + freqs_out = np.array([f for f in corrected_dict.values()]) + freqs_out = np.abs(freqs_out) / np.sum(np.abs(freqs_out)) + + return bs_mat_out, freqs_out + + +def _p_flip_0_to_1(ratio_exp: float, occ: float, eps: float = 0.01) -> float: + """ + Calculate the probability of flipping a bit from 0 to 1. + + This function will more aggressively flip bits which are in disagreement + with the occupation information. + + Args: + ratio_exp: The ratio of 1's expected in the set of bits + occ: The occupancy of a particular bit, based estimated ground + state found at the end of each configuration recovery iteration. + eps: A value for controlling how aggressively to flip bits + + Returns: + The probability with which to flip the bit + """ + # Occupancy is < than naive expectation. + # Flip 0s to 1 with small (~eps) probability in this case + if occ < ratio_exp: + return occ * eps / ratio_exp + + # Occupancy is >= naive expectation. + # The probability to flip the bit increases linearly from ``eps`` to + # ``~1.0`` as the occupation deviates further from the expected ratio + slope = (1 - eps) / (1 - ratio_exp) + intercept = 1 - slope + return occ * slope + intercept + + +def _p_flip_1_to_0(ratio_exp: float, occ: float, eps: float = 0.01) -> float: + """ + Calculate the probability of flipping a bit from 1 to 0. + + This function will more aggressively flip bits which are in disagreement + with the occupation information. + + Args: + ratio_exp: The ratio of 1's expected in the set of bits + occ: The occupancy of a particular bit, based estimated ground + state found at the end of each configuration recovery iteration. + eps: A value for controlling how aggressively to flip bits + + Returns: + The probability with which to flip the bit + """ + # Occupancy is < naive expectation. + # The probability to flip the bit increases linearly from ``eps`` to + # ``~1.0`` as the occupation deviates further from the expected ratio + if occ < 1.0 - ratio_exp: + slope = (1.0 - eps) / (1.0 - ratio_exp) + return 1.0 - occ * slope + + # Occupancy is >= naive expectation. + # Flip 1s to 0 with small (~eps) probability in this case + slope = -eps / ratio_exp + intercept = eps / ratio_exp + return occ * slope + intercept + + +def _bipartite_bitstring_correcting( + bit_array: np.ndarray, + avg_occupancies: np.ndarray, + hamming_left: int, + hamming_right: int, + rand_seed: int | None = None, +) -> np.ndarray: + """ + Use occupancy information and target hamming weight to correct a bitstring. + + Args: + bit_array: A 1D array of ``bool`` representations of bit values + avg_occupancies: A 1D array containing the mean occupancy of each orbital. + hamming_left: The target hamming weight used for the left half of the bitstring + hamming_right: The target hamming weight used for the right half of the bitstring + rand_seed: A seed to control random behavior + + Returns: + A corrected bitstring + """ + # This function must not mutate the input arrays. + bit_array = bit_array.copy() + + np.random.seed(rand_seed) + + # The number of bits should be even + num_bits = bit_array.shape[0] + partition_size = num_bits // 2 + + # Get the probability of flipping each bit, separated into LEFT and RIGHT subsystems, + # based on the avg occupancy of each bit and the target hamming weight + probs_left = np.zeros(partition_size) + probs_right = np.zeros(partition_size) + for i in range(partition_size): + if bit_array[i]: + probs_left[i] = _p_flip_1_to_0( + hamming_left / float(partition_size), avg_occupancies[i], 0.01 + ) + else: + probs_left[i] = _p_flip_0_to_1( + hamming_left / float(partition_size), avg_occupancies[i], 0.01 + ) + + if bit_array[i + partition_size]: + probs_right[i] = _p_flip_1_to_0( + hamming_right / float(partition_size), avg_occupancies[i], 0.01 + ) + else: + probs_right[i] = _p_flip_0_to_1( + hamming_right / float(partition_size), avg_occupancies[i], 0.01 + ) + + # Normalize + probs_left = np.absolute(probs_left) + probs_right = np.absolute(probs_right) + probs_left = probs_left / np.sum(probs_left) + probs_right = probs_right / np.sum(probs_right) + + ######################## Handle LEFT bits ######################## + + # Get difference between # of 1s and expected # of 1s in LEFT bits + n_left = np.sum(bit_array[:partition_size]) + n_diff = n_left - hamming_left + + # Too many electrons in LEFT bits + if n_diff > 0: + indices_occupied = np.where(bit_array[:partition_size])[0] + # Get the probabilities that each 1 should be flipped to 0 + p_choice = probs_left[bit_array[:partition_size]] / np.sum( + probs_left[bit_array[:partition_size]] + ) + # Correct the hamming by probabilistically flipping some bits to flip to 0 + indices_to_flip = np.random.choice( + indices_occupied, size=round(n_diff), replace=False, p=p_choice + ) + bit_array[:partition_size][indices_to_flip] = False + + # too few electrons in LEFT bits + if n_diff < 0: + indices_empty = np.where(np.logical_not(bit_array[:partition_size]))[0] + # Get the probabilities that each 0 should be flipped to 1 + p_choice = probs_left[np.logical_not(bit_array[:partition_size])] / np.sum( + probs_left[np.logical_not(bit_array[:partition_size])] + ) + # Correct the hamming by probabilistically flipping some bits to flip to 1 + indices_to_flip = np.random.choice( + indices_empty, size=round(np.abs(n_diff)), replace=False, p=p_choice + ) + bit_array[:partition_size][indices_to_flip] = np.logical_not( + bit_array[:partition_size][indices_to_flip] + ) + + ######################## Handle RIGHT bits ######################## + + # Get difference between # of 1s and expected # of 1s in RIGHT bits + n_right = np.sum(bit_array[partition_size:]) + n_diff = n_right - hamming_right + + # too many electrons in RIGHT bits + if n_diff > 0: + indices_occupied = np.where(bit_array[partition_size:])[0] + # Get the probabilities that each 1 should be flipped to 0 + p_choice = probs_right[bit_array[partition_size:]] / np.sum( + probs_right[bit_array[partition_size:]] + ) + # Correct the hamming by probabilistically flipping some bits to flip to 0 + indices_to_flip = np.random.choice( + indices_occupied, size=round(n_diff), replace=False, p=p_choice + ) + bit_array[partition_size:][indices_to_flip] = np.logical_not( + bit_array[partition_size:][indices_to_flip] + ) + + # too few electrons in RIGHT bits + if n_diff < 0: + indices_empty = np.where(np.logical_not(bit_array[partition_size:]))[0] + # Get the probabilities that each 1 should be flipped to 0 + p_choice = probs_right[np.logical_not(bit_array[partition_size:])] / np.sum( + probs_right[np.logical_not(bit_array[partition_size:])] + ) + # Correct the hamming by probabilistically flipping some bits to flip to 1 + indices_to_flip = np.random.choice( + indices_empty, size=round(np.abs(n_diff)), replace=False, p=p_choice + ) + bit_array[partition_size:][indices_to_flip] = np.logical_not( + bit_array[partition_size:][indices_to_flip] + ) + + return bit_array diff --git a/qiskit_addon_sqd/counts.py b/qiskit_addon_sqd/counts.py new file mode 100644 index 0000000..b4063e1 --- /dev/null +++ b/qiskit_addon_sqd/counts.py @@ -0,0 +1,158 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Functions for transforming counts dictionaries. + +.. currentmodule:: qiskit_addon_sqd.counts + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + counts_to_arrays + generate_counts_uniform + generate_counts_bipartite_hamming + normalize_counts_dict +""" + +from __future__ import annotations + +import numpy as np + + +def counts_to_arrays(counts: dict[str, float | int]) -> tuple[np.ndarray, np.ndarray]: + """ + Convert a counts dictionary into arrays. + + Args: + counts: The dictionary to convert + + Returns: + A tuple containing: + - A 2D array representing the sampled bitstrings. Each row represents a + bitstring, and each element is a ``bool`` representation of the + bit's value + - A 1D array containing the probability with which each bitstring was sampled + """ + if counts == {}: + return np.array([]), np.array([]) + prob_dict = normalize_counts_dict(counts) + bs_mat = np.array([[bit == "1" for bit in bitstring] for bitstring in prob_dict]) + freq_arr = np.array(list(prob_dict.values())) + + return bs_mat, freq_arr + + +def generate_counts_uniform( + num_samples: int, num_bits: int, rand_seed: None | int = None +) -> dict[str, int]: + """ + Generate a bitstring counts dictionary of samples drawn from the uniform distribution. + + Args: + num_samples: The number of samples to draw + num_bits: The number of bits in the bitstrings + rand_seed: A seed for controlling randomness + + Returns: + A dictionary mapping bitstrings of length ``num_bits`` to the + number of times they were sampled. + + Raises: + ValueError: ``num_samples`` and ``num_bits`` must be positive integers. + """ + if num_samples < 1: + raise ValueError("The number of samples must be specified with a positive integer.") + if num_bits < 1: + raise ValueError("The number of bits must be specified with a positive integer.") + np.random.seed(rand_seed) + sample_dict: dict[str, int] = {} + # Use numpy to generate a random matrix of bit values and + # convert it to a dictionary of bitstring samples + bts_matrix = np.random.choice([0, 1], size=(num_samples, num_bits)) + for i in range(num_samples): + bts_arr = bts_matrix[i, :].astype("int") + bts = np.array2string(bts_arr, separator="")[1:-1] + sample_dict[bts] = sample_dict.get(bts, 0) + 1 + + return sample_dict + + +def generate_counts_bipartite_hamming( + num_samples: int, + num_bits: int, + hamming_left: int, + hamming_right: int, + rand_seed: None | int = None, +) -> dict[str, int]: + """ + Generate a bitstring counts dictionary with specified bipartite hamming weight. + + Args: + num_samples: The number of samples to draw + num_bits: The number of bits in the bitstrings + hamming_left: The hamming weight on the left half of each bitstring + hamming_right: The hamming weight on the right half of each bitstring + rand_seed: A seed for controlling randomness + + Returns: + A dictionary mapping bitstrings to the number of times they were sampled. + Each half of each bitstring in the output dictionary will have a hamming + weight as specified by the inputs. + + Raises: + ValueError: ``num_bits`` and ``num_samples`` must be positive integers. + ValueError: Hamming weights must be specified as non-negative integers. + ValueError: ``num_bits`` must be even. + """ + if num_bits % 2 != 0: + raise ValueError("The number of bits must be specified with an even integer.") + if num_samples < 1: + raise ValueError("The number of samples must be specified with a positive integer.") + if num_bits < 1: + raise ValueError("The number of bits must be specified with a positive integer.") + if hamming_left < 0 or hamming_right < 0: + raise ValueError("Hamming weights must be specified as non-negative integers.") + + np.random.seed(rand_seed) + + sample_dict: dict[str, int] = {} + for _ in range(num_samples): + # Pick random bits to flip such that the left and right hamming weights are correct + up_flips = np.random.choice(np.arange(num_bits // 2), hamming_left, replace=False).astype( + "int" + ) + dn_flips = np.random.choice(np.arange(num_bits // 2), hamming_right, replace=False).astype( + "int" + ) + + # Create a bitstring with the chosen bits flipped + bts_arr = np.zeros(num_bits) + bts_arr[up_flips] = 1 + bts_arr[dn_flips + num_bits // 2] = 1 + bts_arr = bts_arr.astype("int") + bts = np.array2string(bts_arr, separator="")[1:-1] + + # Add the bitstring to the sample dict + sample_dict[bts] = sample_dict.get(bts, 0) + 1 + + return sample_dict + + +def normalize_counts_dict(counts: dict[str, float | int]) -> dict[str, float]: + """Convert a counts dictionary into a probability dictionary.""" + if counts == {}: + return counts + + total_counts = float(sum(counts.values())) + + return {bs: count / total_counts for bs, count in counts.items()} diff --git a/qiskit_addon_sqd/fermion.py b/qiskit_addon_sqd/fermion.py new file mode 100644 index 0000000..9ffeb78 --- /dev/null +++ b/qiskit_addon_sqd/fermion.py @@ -0,0 +1,452 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Functions for the study of fermionic systems. + +.. currentmodule:: qiskit_addon_sqd.fermion + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + bitstring_matrix_to_sorted_addresses + enlarge_batch_from_transitions + flip_orbital_occupancies + solve_fermion + optimize_orbitals + rotate_integrals +""" + +from __future__ import annotations + +import numpy as np +from jax import Array, config, grad, jit, vmap +from jax import numpy as jnp +from jax.scipy.linalg import expm +from pyscf import fci +from scipy import linalg as LA + +config.update("jax_enable_x64", True) # To deal with large integers + + +def solve_fermion( + addresses: tuple[np.ndarray, np.ndarray], + hcore: np.ndarray, + eri: np.ndarray, + spin_sq: int | None = None, + max_davidson: int = 100, + verbose: int | None = None, +) -> tuple[float, np.ndarray, list[np.ndarray], float]: + """ + Approximate the ground state given molecular integrals and Slater determinant addresses. + + .. note:: + The ``addresses`` are expected to be unique and sorted. While this will be handled + for the user automatically, this function could become slower if the input + addresses are not sorted or nearly-sorted. + + Args: + addresses: A length-2 tuple of 1D arrays containing sorted, base-10 + representations of bitstrings. The first array represents configurations of the + alpha particles, and the second array represents that of the beta particles. + hcore: Core Hamiltonian matrix representing single-electron integrals + eri: Electronic repulsion integrals representing two-electron integrals + spin_sq: Target value for the total spin squared for the ground state. + If ``None``, no spin will be imposed. + max_davidson: The maximum number of cycles of Davidson's algorithm + verbose: A verbosity level between 0 and 10 + + Returns: + A tuple containing: + - Minimum energy from SCI calculation + - SCI coefficients + - Average orbital occupancy + - Expectation value of spin-squared + + Raises: + ValueError: The input determinant ``addresses`` must be non-empty, sorted arrays of integers. + """ + addresses = _check_addresses(addresses) + + num_up = bin(addresses[0][0])[2:].count("1") + num_dn = bin(addresses[1][0])[2:].count("1") + + # Number of molecular orbitals + norb = hcore.shape[0] + # Call the projection + eigenstate finder + myci = fci.selected_ci.SelectedCI() + if spin_sq is not None: + myci = fci.addons.fix_spin_(myci, ss=spin_sq) + e_sci, coeffs_sci = fci.selected_ci.kernel_fixed_space( + myci, + hcore, + eri, + norb, + (num_up, num_dn), + ci_strs=addresses, + verbose=verbose, + max_cycle=max_davidson, + ) + # Calculate the avg occupancy of each orbital + dm1 = myci.make_rdm1s(coeffs_sci, norb, (num_up, num_dn)) + avg_occupancy = [np.diagonal(dm1[0]), np.diagonal(dm1[1])] + + # Compute total spin + spin_squared = myci.spin_square(coeffs_sci, norb, (num_up, num_dn))[0] + + return e_sci, coeffs_sci, avg_occupancy, spin_squared + + +def optimize_orbitals( + addresses: tuple[np.ndarray, np.ndarray], + hcore: np.ndarray, + eri: np.ndarray, + k_flat: np.ndarray, + *, + spin_sq: float = 0.0, + num_iters: int = 10, + num_steps_grad: int = 10_000, + learning_rate: float = 0.01, + max_davidson: int = 100, +) -> tuple[float, np.ndarray, list[np.ndarray]]: + """ + Optimize orbitals to produce a minimal ground state. + + The process involves iterating over 3 steps: + + For ``num_iters`` iterations: + - Rotate the integrals with respect to the parameters, ``k_flat`` + - Diagonalize and approximate the groundstate energy and wavefunction amplitudes + - Optimize ``k_flat`` using gradient descent and the wavefunction + amplitudes found in Step 2 + + Refer to `Sec. II A 4 `_ for more detailed + discussion on this orbital optimization technique. + + .. note:: + The input ``addresses`` are expected to be unique and sorted. While this will be + handled for the user automatically, this function may become slower if the input + addresses are not sorted or nearly-sorted. + + Args: + addresses: A length-2 tuple of 1D arrays containing sorted, base-10 + representations of bitstrings. The first array represents configurations of the + alpha particles, and the second array represents that of the beta particles. + hcore: Core Hamiltonian matrix representing single-electron integrals + eri: Electronic repulsion integrals representing two-electron integrals + k_flat: 1D array defining the orbital transform. This array will be reshaped + to be of shape (# orbitals, # orbitals) before being used as a + similarity transform operator on the orbitals. Thus ``len(k_flat)=# orbitals**2``. + spin_sq: Target value for the total spin squared for the ground state + num_iters: The number of iterations of orbital optimization to perform + max_davidson: The maximum number of cycles of Davidson's algorithm to + perform during diagonalization. + num_steps_grad: The number of steps of gradient descent to perform + during each optimization iteration + learning_rate: The learning rate to use during gradient descent + + Returns: + A tuple containing: + - The groundstate energy found during the last optimization iteration + - An optimized 1D array defining the orbital transform + - Average orbital occupancy + """ + addresses = _check_addresses(addresses) + + num_up = bin(addresses[0][0])[2:].count("1") + num_dn = bin(addresses[1][0])[2:].count("1") + + # TODO: Need metadata showing the optimization history + ## hcore and eri in physicist ordering + num_orbitals = hcore.shape[0] + k_flat = k_flat.copy() + eri_phys = np.asarray(eri.transpose(0, 2, 3, 1), order="C") # physicist ordering + for _ in range(num_iters): + # Rotate integrals + hcore_rot, eri_rot = rotate_integrals(hcore, eri_phys, k_flat) + eri_rot_chem = np.asarray(eri_rot.transpose(0, 3, 1, 2), order="C") # chemist ordering + + # Solve for ground state with respect to optimized integrals + myci = fci.selected_ci.SelectedCI() + myci = fci.addons.fix_spin_(myci, ss=spin_sq) + e_qsci, amplitudes = fci.selected_ci.kernel_fixed_space( + myci, + hcore_rot, + eri_rot_chem, + num_orbitals, + (num_up, num_dn), + ci_strs=addresses, + max_cycle=max_davidson, + ) + + # Generate the one and two-body reduced density matrices from latest wavefunction amplitudes + dm1, dm2_chem = myci.make_rdm12(amplitudes, num_orbitals, (num_up, num_up)) + dm2 = np.asarray(dm2_chem.transpose(0, 2, 3, 1), order="C") + + # TODO: Expose the momentum parameter as an input option + # Optimize the basis rotations + _optimize_orbitals_sci( + k_flat, learning_rate, 0.9, num_steps_grad, dm1, dm2, hcore, eri_phys + ) + + return e_qsci, k_flat, [np.diagonal(dm1), np.diagonal(dm1)] + + +def rotate_integrals( + hcore: np.ndarray, eri: np.ndarray, k_flat: np.ndarray +) -> tuple[np.ndarray, np.ndarray]: + r""" + Perform a similarity transform on the integrals. + + The transformation is described as: + + .. math:: + + \hat{\widetilde{H}} = \hat{U^{\dagger}}(k)\hat{H}\hat{U}(k) + + For more information on how :math:`\hat{U}` and :math:`\hat{U^{\dagger}}` are generated from ``k_flat`` + and applied to the one- and two-body integrals, refer to `Sec. II A 4 `_. + + Args: + hcore: Core Hamiltonian matrix representing single-electron integrals + eri: Electronic repulsion integrals representing two-electron integrals + k_flat: 1D array defining the orbital transform. Refer to `Sec. II A 4 `_ + for more information on how these values are used to generate the transform operator. + + Returns: + - The rotated core Hamiltonian matrix + - The rotated ERI matrix + """ + num_orbitals = hcore.shape[0] + p = np.reshape(k_flat, (num_orbitals, num_orbitals)) + K = (p - np.transpose(p)) / 2.0 + U = LA.expm(K) + hcore_rot = np.matmul(np.transpose(U), np.matmul(hcore, U)) + eri_rot = np.einsum("pqrs, pi, qj, rk, sl->ijkl", eri, U, U, U, U, optimize=True) + + return np.array(hcore_rot), np.array(eri_rot) + + +def flip_orbital_occupancies(occupancies: np.ndarray) -> np.ndarray: + """ + Flip an orbital occupancy array to match the indexing of a bitstring. + + This function reformats a 1D array of spin-orbital occupancies formatted like: + + ``[occ_a_0, occ_a_1, occ_a_N, occ_b_0, ..., occ_b_N]`` + + To an array formatted like: + + ``[occ_a_N, ..., occ_a_0, occ_b_N, ..., occ_b_0]`` + + where ``N`` is the number of spatial orbitals. + """ + num_orbitals = occupancies.shape[0] // 2 + occ_up = occupancies[:num_orbitals] + occ_dn = occupancies[num_orbitals:] + occ_out = np.zeros(2 * num_orbitals) + occ_out[:num_orbitals] = np.flip(occ_up) + occ_out[num_orbitals:] = np.flip(occ_dn) + + return occ_out + + +def bitstring_matrix_to_sorted_addresses( + bitstring_matrix: np.ndarray, open_shell: bool = False +) -> tuple[np.ndarray, np.ndarray]: + """ + Convert a bitstring matrix into base-10 address representation. + + This function separates each bitstring in ``bitstring_matrix`` in half, translates + each set of bits into integer representations, and appends them to their respective + lists. Those lists are sorted and output from this function. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring + open_shell: A flag specifying whether unique addresses from the left and right + halves of the bitstrings should be kept separate. If ``False``, addresses + from the left and right halves of the bitstrings are combined into a single + set of unique addresses. That combined set will be returned for both the left + and right bitstrings. + + Returns: + A length-2 tuple of sorted, base-10 determinant addresses representing the left + and right halves of the bitstrings, respectively. + """ + num_orbitals = bitstring_matrix.shape[1] // 2 + num_configs = bitstring_matrix.shape[0] + + address_left = np.zeros(num_configs) + address_right = np.zeros(num_configs) + bts_matrix_left = bitstring_matrix[:, :num_orbitals] + bts_matrix_right = bitstring_matrix[:, num_orbitals:] + + # For performance, we accumulate the left and right addresses together, column-wise, + # across the two halves of the input bitstring matrix. + for i in range(num_orbitals): + address_left[:] += bts_matrix_left[:, i] * 2 ** (num_orbitals - 1 - i) + address_right[:] += bts_matrix_right[:, i] * 2 ** (num_orbitals - 1 - i) + + addresses_right = np.unique(address_right.astype("longlong")) + addresses_left = np.unique(address_left.astype("longlong")) + + if not open_shell: + addresses_left = addresses_right = np.union1d(addresses_left, addresses_right) + + return addresses_left, addresses_right + + +def enlarge_batch_from_transitions( + bitstring_matrix: np.ndarray, transition_operators: np.ndarray +) -> np.ndarray: + """ + Apply the set of transition operators to the configurations represented in ``bitstring_matrix``. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring. + transition_operators: A 1D or 2D array ``I``, ``+``, ``-``, and ``n`` strings + representing the action of the identity, creation, annihilation, or number operators. + Each row represents a transition operator. + + Returns: + Bitstring matrix representing the augmented set of electronic configurations after applying + the excitation operators. + """ + diag, create, annihilate = _transition_str_to_bool(transition_operators) + + bitstring_matrix_augmented, mask = apply_excitations(bitstring_matrix, diag, create, annihilate) + + bitstring_matrix_augmented = bitstring_matrix_augmented[mask] + + return np.array(bitstring_matrix_augmented) + + +def _check_addresses( + addresses: tuple[np.ndarray, np.ndarray], +) -> tuple[np.ndarray, np.ndarray]: + """Make sure the hamming weight is consistent in all determinants.""" + addr_up, addr_dn = addresses + addr_up_ham = bin(addr_up[0])[2:].count("1") + for i, addr in enumerate(addr_up): + ham = bin(addr)[2:].count("1") + if ham != addr_up_ham: + raise ValueError( + f"Spin-up address in index 0 has hamming weight {addr_up_ham}, but address in " + f"index {i} has hamming weight {ham}." + ) + addr_dn_ham = bin(addr_dn[0])[2:].count("1") + for i, addr in enumerate(addr_dn): + ham = bin(addr)[2:].count("1") + if ham != addr_dn_ham: + raise ValueError( + f"Spin-down address in index 0 has hamming weight {addr_dn_ham}, but address in " + f"index {i} has hamming weight {ham}." + ) + + return np.sort(np.unique(addr_up)), np.sort(np.unique(addr_dn)) + + +def _optimize_orbitals_sci( + k_flat: np.ndarray, + learning_rate: float, + momentum: float, + num_steps: int, + dm1: np.ndarray, + dm2: np.ndarray, + hcore: np.ndarray, + eri: np.ndarray, +) -> None: + """ + Optimize orbital rotation parameters in-place using gradient descent. + + This procedure is described in `Sec. II A 4 `_. + """ + prev_update = np.zeros(len(k_flat)) + num_orbitals = dm1.shape[0] + for _ in range(num_steps): + grad = _SCISCF_Energy_contract_grad(dm1, dm2, hcore, eri, num_orbitals, k_flat) + prev_update = learning_rate * grad + momentum * prev_update + k_flat -= prev_update + + +def _SCISCF_Energy_contract( + dm1: np.ndarray, + dm2: np.ndarray, + hcore: np.ndarray, + eri: np.ndarray, + num_orbitals: int, + k_flat: np.ndarray, +) -> Array: + """ + Calculate gradient. + + The gradient can be calculated by contracting the bare one and two-body + reduced density matrices with the gradients of the of the one and two-body + integrals with respect to the rotation parameters, ``k_flat``. + """ + p = jnp.reshape(k_flat, (num_orbitals, num_orbitals)) + K = (p - jnp.transpose(p)) / 2.0 + U = expm(K) + hcore_rot = jnp.matmul(jnp.transpose(U), jnp.matmul(hcore, U)) + eri_rot = jnp.einsum("pqrs, pi, qj, rk, sl->ijkl", eri, U, U, U, U) + grad = jnp.sum(dm1 * hcore_rot) + jnp.sum(dm2 * eri_rot / 2.0) + + return grad + + +_SCISCF_Energy_contract_grad = jit(grad(_SCISCF_Energy_contract, argnums=5), static_argnums=4) + + +def _apply_excitation_single( + single_bts: np.ndarray, diag: np.ndarray, create: np.ndarray, annihilate: np.ndarray +) -> tuple[jnp.ndarray, Array]: + falses = jnp.array([False for _ in range(len(diag))]) + + bts_ret = single_bts == diag + create_crit = jnp.all(jnp.logical_or(diag, falses == jnp.logical_and(single_bts, create))) + annihilate_crit = jnp.all(falses == jnp.logical_and(falses == single_bts, annihilate)) + + include_crit = jnp.logical_and(create_crit, annihilate_crit) + + return bts_ret, include_crit + + +_apply_excitation = jit(vmap(_apply_excitation_single, (0, None, None, None), 0)) + +apply_excitations = jit(vmap(_apply_excitation, (None, 0, 0, 0), 0)) + + +def _transition_str_to_bool(string_rep: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Transform string representations of a transition operator into bool representation. + + Transform sequences of identity ("I"), creation ("+"), annihilation ("-"), and number ("n") + characters into the internal representation used to apply the transitions into electronic + configurations. + + Args: + string_rep: A 1D or 2D array of ``I``, ``+``, ``-``, ``n`` strings representing + the action of the identity, creation, annihilation, or number operators. + + Returns: + A 3-tuple: + - A mask signifying the diagonal terms (I). + - A mask signifying whether there is a creation operator (+). + - A mask signifying whether there is an annihilation operator (-). + """ + diag = np.logical_or(string_rep == "I", string_rep == "n") + create = np.logical_or(string_rep == "+", string_rep == "n") + annihilate = np.logical_or(string_rep == "-", string_rep == "n") + + return diag, create, annihilate diff --git a/qiskit_addon_sqd/qubit.py b/qiskit_addon_sqd/qubit.py new file mode 100644 index 0000000..853e66d --- /dev/null +++ b/qiskit_addon_sqd/qubit.py @@ -0,0 +1,220 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Functions for handling quantum samples. + +.. currentmodule:: qiskit_addon_sqd.qubit + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + matrix_elements_from_pauli_string + sort_and_remove_duplicates +""" + +from collections.abc import Sequence +from typing import Any + +import jax.numpy as jnp +import numpy as np +from jax import Array, config, jit, vmap +from numpy.typing import NDArray + +config.update("jax_enable_x64", True) # To deal with large integers + + +def sort_and_remove_duplicates(bitstring_matrix: np.ndarray, inplace: bool = True) -> np.ndarray: + """ + Sort a bitstring matrix and remove duplicate entries. + + The lowest bitstring values will be placed in the lowest-indexed rows. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring. + inplace: Whether to modify the input array in place. + + Returns: + Sorted version of ``bitstring_matrix`` without repeated rows. + """ + if not inplace: + bitstring_matrix = bitstring_matrix.copy() + + base_10 = _base_10_conversion_from_bts_matrix_vmap(bitstring_matrix) + + _, indices = np.unique(base_10, return_index=True) + + return bitstring_matrix[indices, :] + + +def matrix_elements_from_pauli_string( + bitstring_matrix: np.ndarray, pauli_str: Sequence[str] +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Find the matrix elements of a Pauli operator in the subspace defined by the bitstrings. + + .. note:: + The bitstrings in the ``bitstring_matrix`` must be sorted and unique according + to their base-10 representation. Otherwise the projection will return wrong + results. We do not explicitly check for uniqueness and order because this + can be rather time consuming. + + .. note:: + This function relies on ``jax`` to efficiently perform some calculations. ``jax`` + converts the bit arrays to ``int64_t``, which means the bit arrays in + ``bitstring_matrix`` may not have length greater than ``63``. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring. + The bitstrings in the matrix must be sorted according to + their base-10 representation. Otherwise the projection will return + wrong results. + pauli_str: A length-N sequence of single-qubit Pauli strings representing + an N-qubit Pauli operator. The Pauli term for qubit ``i`` should be + in ``pauli_str[i]`` (e.g. ``qiskit.quantum_info.Pauli("XYZ") = ["Z", "Y", "X"]``). + + Returns: + First array corresponds to the nonzero matrix elements + Second array corresponds to the row indices of the elements + Third array corresponds to the column indices of the elements + + Raises: + ValueError: Input bit arrays must have length < ``64``. + """ + d, n_qubits = bitstring_matrix.shape + row_array = np.arange(d) + + if n_qubits > 63: + raise ValueError("Bit arrays must have length < 64.") + + diag, sign, imag = _pauli_str_to_bool(pauli_str) + + base_10_array_rows = _base_10_conversion_from_bts_matrix_vmap(bitstring_matrix) + + bs_mat_conn, matrix_elements = _connected_elements_and_amplitudes_bool_vmap( + bitstring_matrix, diag, sign, imag + ) + + base_10_array_cols = _base_10_conversion_from_bts_matrix_vmap(bs_mat_conn) + + indices = np.isin(base_10_array_cols, base_10_array_rows, assume_unique=True, kind="sort") + + matrix_elements = matrix_elements[indices] + row_array = row_array[indices] + base_10_array_cols = base_10_array_cols[indices] + + col_array = np.searchsorted(base_10_array_rows, base_10_array_cols) + + return matrix_elements, row_array, col_array + + +def _pauli_str_to_bool( + pauli_str: Sequence[str], +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Transform sequences of Pauli strings into arrays. + + An N-qubit Pauli string will be transformed into 3 arrays which represent + the diagonal terms of the Pauli operator. + + Args: + pauli_str: A sequence of single-qubit Pauli strings. + + Returns: + A 3-tuple: + - A mask signifying the diagonal Pauli terms (I, Z). + - A mask signifying whether there is a change in sign between the two rows + of the Pauli matrix (Y, Z). + - A mask signifying whether the Pauli matrix elements are purely imaginary. + """ + diag = [] + sign = [] + imag = [] + for p in pauli_str: + if p == "I" or p == "i": + diag.append(True) + sign.append(False) + imag.append(False) + if p == "X" or p == "x": + diag.append(False) + sign.append(False) + imag.append(False) + if p == "Y" or p == "y": + diag.append(False) + sign.append(True) + imag.append(True) + if p == "Z" or p == "z": + diag.append(True) + sign.append(True) + imag.append(False) + + return np.array(diag), np.array(sign), np.array(imag) + + +def _connected_elements_and_amplitudes_bool( + bit_array: np.ndarray, diag: np.ndarray, sign: np.ndarray, imag: np.ndarray +) -> tuple[NDArray[np.bool_], Array]: + """ + Find the connected element to computational basis state |X>. + + Given a Pauli operator represented by ``{diag, sign, imag}``. + Args: + bit_array: A 1D array of ``bool`` representations of bits. + diag: ``bool`` whether the Pauli operator is diagonal. Only ``True`` + for I and Z. + sign: ``bool`` Whether there is a change of sign in the matrix elements + of the different rows of the Pauli operators. Only True for Y and Z. + imag: ``bool`` whether the matrix elements of the Pauli operator are + purely imaginary + + Returns: + A matrix of bitstrings where each row is the connected element to the + input the matrix element. + """ + bit_array_mask: NDArray[np.bool_] = bit_array == diag + return bit_array_mask, jnp.prod( + (-1) ** (jnp.logical_and(bit_array, sign)) * jnp.array(1j, dtype="complex64") ** (imag) + ) + + +"""Same as ``_connected_elements_and_amplitudes_jnp_bool()`` but allows to deal +with 2D arrays of bitstrings through the ``vmap`` transformation of Jax. Also +JIT compiled. +""" +_connected_elements_and_amplitudes_bool_vmap = jit( + vmap(_connected_elements_and_amplitudes_bool, (0, None, None, None), 0) +) + + +def _base_10_conversion_from_bts_array(bit_array: np.ndarray) -> Any: + """ + Convert a bit array to a base-10 representation. + + NOTE: This can only handle up to 63 qubits. Then the integer will overflow + + Args: + bit_array: A 1D array of ``bool`` representations of bit values. + + Returns: + Base-10 representation of the bit array. + """ + n_qubits = len(bit_array) + base_10_array = 0.0 + for i in range(n_qubits): + base_10_array = base_10_array + bit_array[i] * 2 ** (n_qubits - 1 - i) + + return base_10_array.astype("longlong") # type: ignore + + +_base_10_conversion_from_bts_matrix_vmap = jit(vmap(_base_10_conversion_from_bts_array, 0, 0)) diff --git a/qiskit_addon_sqd/subsampling.py b/qiskit_addon_sqd/subsampling.py new file mode 100644 index 0000000..67c1c88 --- /dev/null +++ b/qiskit_addon_sqd/subsampling.py @@ -0,0 +1,153 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Functions for creating batches of samples from a bitstring matrix. + +.. currentmodule:: qiskit_addon_sqd.subsampling + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + subsample + postselect_and_subsample +""" + +from __future__ import annotations + +import numpy as np + +from .configuration_recovery import post_select_by_hamming_weight + + +def postselect_and_subsample( + bitstring_matrix: np.ndarray, + probabilities: np.ndarray, + hamming_left: int, + hamming_right: int, + samples_per_batch: int, + num_batches: int, + rand_seed: int | None = None, +) -> list[np.ndarray]: + """ + Subsample batches of bit arrays with correct hamming weight from an input ``bitstring_matrix``. + + Bitstring samples with incorrect hamming weight on either their left or right half will not + be sampled. + + Each individual batch will be sampled without replacement from the input ``bitstring_matrix``. + Samples will be replaced after creation of each batch, so different batches may contain + identical samples. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring. + probabilities: A 1D array specifying a probability distribution over the bitstrings + hamming_left: The target hamming weight for the left half of sampled bitstrings + hamming_right: The target hamming weight for the right half of sampled bitstrings + samples_per_batch: The number of samples to draw for each batch + num_batches: The number of batches to generate + rand_seed: A seed to control random behavior + + Returns: + A list of bitstring matrices with correct hamming weight subsampled from the input bitstring matrix + + Raises: + ValueError: The number of elements in ``probabilities`` must equal the number of rows in ``bitstring_matrix``. + ValueError: Hamming weights must be non-negative integers. + ValueError: Samples per batch and number of batches must be positive integers. + """ + if bitstring_matrix.shape[0] < 1: + return [np.array([])] * num_batches + if len(probabilities) != bitstring_matrix.shape[0]: + raise ValueError( + "The number of elements in the probabilities array must match the number of rows in the bitstring matrix." + ) + if hamming_left < 0 or hamming_right < 0: + raise ValueError("Hamming weight must be specified with a non-negative integer.") + + # Post-select only bitstrings with correct hamming weight + mask_postsel = post_select_by_hamming_weight(bitstring_matrix, hamming_left, hamming_right) + bs_mat_postsel = bitstring_matrix[mask_postsel] + probs_postsel = probabilities[mask_postsel] + probs_postsel = np.abs(probs_postsel) / np.sum(np.abs(probs_postsel)) + + if len(probs_postsel) == 0: + return [np.array([])] * num_batches + + return subsample(bs_mat_postsel, probs_postsel, samples_per_batch, num_batches, rand_seed) + + +def subsample( + bitstring_matrix: np.ndarray, + probabilities: np.ndarray, + samples_per_batch: int, + num_batches: int, + rand_seed: int | None = None, +) -> list[np.ndarray]: + """ + Subsample batches of bit arrays from an input ``bitstring_matrix``. + + Each individual batch will be sampled without replacement from the input ``bitstring_matrix``. + Samples will be replaced after creation of each batch, so different batches may contain + identical samples. + + Args: + bitstring_matrix: A 2D array of ``bool`` representations of bit + values such that each row represents a single bitstring. + probabilities: A 1D array specifying a probability distribution over the bitstrings + samples_per_batch: The number of samples to draw for each batch + num_batches: The number of batches to generate + rand_seed: A seed to control random behavior + + Returns: + A list of bitstring matrices subsampled from the input bitstring matrix. + + Raises: + ValueError: The number of elements in ``probabilities`` must equal the number of rows in ``bitstring_matrix``. + ValueError: Samples per batch and number of batches must be positive integers. + """ + if bitstring_matrix.shape[0] < 1: + return [np.array([])] * num_batches + if len(probabilities) != bitstring_matrix.shape[0]: + raise ValueError( + "The number of elements in the probabilities array must match the number of rows in the bitstring matrix." + ) + if samples_per_batch < 1: + raise ValueError("Samples per batch must be specified with a positive integer.") + if num_batches < 1: + raise ValueError("The number of batches must be specified with a positive integer.") + + np.random.seed(rand_seed) + num_bitstrings = bitstring_matrix.shape[0] + + # If the number of requested samples is >= the number of bitstrings, return + # num_batches copies of the input array. + randomly_sample = True + if samples_per_batch >= num_bitstrings: + randomly_sample = False + indices = np.arange(num_bitstrings).astype("int") + + # Create batches of samples + batches = [] + for _ in range(num_batches): + if randomly_sample: + indices = np.random.choice( + np.arange(num_bitstrings).astype("int"), + samples_per_batch, + replace=False, + p=probabilities, + ) + + batches.append(bitstring_matrix[indices]) + + return batches diff --git a/test/README.md b/test/README.md new file mode 100644 index 0000000..5df046e --- /dev/null +++ b/test/README.md @@ -0,0 +1,104 @@ +# Test environments + +This repository's tests and development automation tasks are organized using [tox], a command-line CI frontend for Python projects. tox is typically used during local development and is also invoked from this repository's GitHub Actions [workflows](../.github/workflows/). + +tox can be installed by running `pip install tox`. + +tox is organized around various "environments," each of which is described below. To run _all_ test environments, run `tox` without any arguments: + +```sh +$ tox +``` + +Environments for this repository are configured in [`tox.ini`] as described below. + +## Lint environment + +The `lint` environment ensures that the code meets basic coding standards, including + +- [_Black_] formatting style +- Style checking with [ruff], [autoflake], and [pydocstyle] +- [mypy] type annotation checker, as configured by [`.mypy.ini`] + +The _Black_ and mypy passes are applied also to [Jupyter] notebooks (via [nbqa]). + +To run: + +```sh +$ tox -e lint +``` + +## Style environment + +The command `tox -e style` will apply automated style fixes. This includes: + +- Automated fixes from [ruff] and [autoflake] +- Reformatting of all files in the repository according to _Black_ style + +## Test (py##) environments + +The `py##` environments are the main test environments. tox defines one for each version of Python. For instance, the following command will run the tests on Python 3.10, Python 3.11, and Python 3.12: + +```sh +$ tox -e py310,py311,py312 +``` + +These environments execute all tests using [pytest], which supports its own simple style of tests, in addition to [unittest]-style tests. + +## Notebook environments + +The `notebook` and `py##-notebook` environments invoke [nbmake] to ensure that all the Jupyter notebooks in the [`docs/`](/docs/tutorials) directory execute successfully. + +```sh +$ tox -e py310-notebook +``` + +## Doctest environment + +The `doctest` environment uses [doctest] to execute the code snippets that are embedded into the documentation strings. The tests get run using [pytest]. + +```sh +tox -e doctest +``` + +## Coverage environment + +The `coverage` environment uses [Coverage.py] to ensure that the fraction of code tested by pytest is above some threshold (enforced to be 100% for new modules). A detailed, line-by-line coverage report can be viewed by navigating to `htmlcov/index.html` in a web browser. + +To run: + +```sh +$ tox -e coverage +``` + +## Documentation environment + +The `docs` environment builds the [Sphinx] documentation locally. + +For the documentation build to succeed, [pandoc](https://pandoc.org/) must be installed. Pandoc is not available via pip, so must be installed through some other means. Linux users are encouraged to install it through their package manager (e.g., `sudo apt-get install -y pandoc`), while macOS users are encouraged to install it via [Homebrew](https://brew.sh/) (`brew install pandoc`). Full instructions are available on [pandoc's installation page](https://pandoc.org/installing.html). + +To run this environment: + +```sh +$ tox -e docs +``` + +If the build succeeds, it can be viewed by navigating to `docs/_build/html/index.html` in a web browser. + +[tox]: https://github.com/tox-dev/tox +[`tox.ini`]: ../tox.ini +[mypy]: https://mypy.readthedocs.io/en/stable/ +[`.mypy.ini`]: ../.mypy.ini +[nbmake]: https://github.com/treebeardtech/nbmake +[_Black_]: https://github.com/psf/black +[ruff]: https://github.com/charliermarsh/ruff +[autoflake]: https://github.com/PyCQA/autoflake +[pydocstyle]: https://www.pydocstyle.org/en/stable/ +[pylint]: https://github.com/PyCQA/pylint +[nbqa]: https://github.com/nbQA-dev/nbQA +[Jupyter]: https://jupyter.org/ +[doctest]: https://docs.python.org/3/library/doctest.html +[pytest]: https://docs.pytest.org/ +[unittest]: https://docs.python.org/3/library/unittest.html +[Coverage.py]: https://coverage.readthedocs.io/ +[Sphinx]: https://www.sphinx-doc.org/ diff --git a/test/__init__.py b/test/__init__.py new file mode 100644 index 0000000..75efffe --- /dev/null +++ b/test/__init__.py @@ -0,0 +1,10 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/test/test_configuration_recovery.py b/test/test_configuration_recovery.py new file mode 100644 index 0000000..74d0e73 --- /dev/null +++ b/test/test_configuration_recovery.py @@ -0,0 +1,19 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for configuration_recovery submodule.""" + +import unittest + + +class TestConfigurationRecovery(unittest.TestCase): + def test_configuration_recovery(self): + pass diff --git a/test/test_counts.py b/test/test_counts.py new file mode 100644 index 0000000..a48f446 --- /dev/null +++ b/test/test_counts.py @@ -0,0 +1,148 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for the counts module.""" + +import unittest + +import pytest +from qiskit_addon_sqd.counts import ( + counts_to_arrays, + generate_counts_bipartite_hamming, + generate_counts_uniform, + normalize_counts_dict, +) + + +class TestCounts(unittest.TestCase): + def setUp(self): + self.max_val = 16 + self.counts = {bin(i)[2:].zfill(4): 100 for i in range(self.max_val)} + + def test_counts_to_arrays(self): + with self.subTest("Basic test"): + bitstring_matrix, probs = counts_to_arrays(self.counts) + self.assertEqual(self.max_val, bitstring_matrix.shape[0]) + self.assertEqual(4, bitstring_matrix.shape[1]) + self.assertEqual(self.max_val, len(probs)) + uniform_prob = 1 / bitstring_matrix.shape[0] + for p in probs: + self.assertEqual(uniform_prob, p) + with self.subTest("Null test"): + counts = {} + bitstring_matrix, probs = counts_to_arrays(counts) + self.assertEqual((0,), bitstring_matrix.shape) + self.assertEqual((0,), probs.shape) + + def test_generate_counts_uniform(self): + with self.subTest("Basic test"): + num_samples = 10 + num_bits = 4 + counts = generate_counts_uniform(num_samples, num_bits) + self.assertLessEqual(len(counts), num_samples) + for bs in counts: + self.assertEqual(num_bits, len(bs)) + with self.subTest("Non-positive num_bits"): + num_samples = 10 + num_bits = 0 + with pytest.raises(ValueError) as e_info: + generate_counts_uniform(num_samples, num_bits) + self.assertEqual( + "The number of bits must be specified with a positive integer.", + e_info.value.args[0], + ) + with self.subTest("Non-positive num_samples"): + num_samples = 0 + num_bits = 4 + with pytest.raises(ValueError) as e_info: + generate_counts_uniform(num_samples, num_bits) + self.assertEqual( + "The number of samples must be specified with a positive integer.", + e_info.value.args[0], + ) + + def test_generate_counts_bipartite_hamming(self): + with self.subTest("Basic test"): + num_samples = 10 + num_bits = 8 + hamming_left = 3 + hamming_right = 2 + counts = generate_counts_bipartite_hamming( + num_samples, num_bits, hamming_left, hamming_right + ) + self.assertLessEqual(len(counts), num_samples) + for bs in counts: + ham_l = sum([b == "1" for b in bs[: num_bits // 2]]) + ham_r = sum([b == "1" for b in bs[num_bits // 2 :]]) + self.assertEqual(num_bits, len(bs)) + self.assertEqual(hamming_left, ham_l) + self.assertEqual(hamming_right, ham_r) + with self.subTest("Uneven num bits"): + num_samples = 10 + num_bits = 7 + hamming_left = 3 + hamming_right = 2 + with pytest.raises(ValueError) as e_info: + generate_counts_bipartite_hamming( + num_samples, num_bits, hamming_left, hamming_right + ) + self.assertEqual( + "The number of bits must be specified with an even integer.", e_info.value.args[0] + ) + with self.subTest("Non-positive num_samples"): + num_samples = 0 + num_bits = 8 + hamming_left = 3 + hamming_right = 2 + with pytest.raises(ValueError) as e_info: + generate_counts_bipartite_hamming( + num_samples, num_bits, hamming_left, hamming_right + ) + self.assertEqual( + "The number of samples must be specified with a positive integer.", + e_info.value.args[0], + ) + with self.subTest("Non-positive num_bits"): + num_samples = 10 + num_bits = 0 + hamming_left = 3 + hamming_right = 2 + with pytest.raises(ValueError) as e_info: + generate_counts_bipartite_hamming( + num_samples, num_bits, hamming_left, hamming_right + ) + self.assertEqual( + "The number of bits must be specified with a positive integer.", + e_info.value.args[0], + ) + with self.subTest("Negative hamming"): + num_samples = 10 + num_bits = 8 + hamming_left = -1 + hamming_right = -1 + with pytest.raises(ValueError) as e_info: + generate_counts_bipartite_hamming( + num_samples, num_bits, hamming_left, hamming_right + ) + self.assertEqual( + "Hamming weights must be specified as non-negative integers.", e_info.value.args[0] + ) + + def test_normalize_counts(self): + with self.subTest("Basic test"): + counts_norm = normalize_counts_dict(self.counts) + uniform_prob = 1 / self.max_val + for prob in counts_norm.values(): + self.assertEqual(uniform_prob, prob) + with self.subTest("Null test"): + counts = {} + counts_norm = normalize_counts_dict(counts) + self.assertEqual(counts_norm, counts) diff --git a/test/test_fermion.py b/test/test_fermion.py new file mode 100644 index 0000000..e41c5b9 --- /dev/null +++ b/test/test_fermion.py @@ -0,0 +1,19 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for the fermion module.""" + +import unittest + + +class TestFermion(unittest.TestCase): + def test_fermion(self): + pass diff --git a/test/test_qubit.py b/test/test_qubit.py new file mode 100644 index 0000000..dde3c5b --- /dev/null +++ b/test/test_qubit.py @@ -0,0 +1,19 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for the qubit module.""" + +import unittest + + +class TestQubit(unittest.TestCase): + def test_qubit(self): + pass diff --git a/test/test_subsampling.py b/test/test_subsampling.py new file mode 100644 index 0000000..174715d --- /dev/null +++ b/test/test_subsampling.py @@ -0,0 +1,275 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Unit tests for subsampling module.""" + +import unittest + +import numpy as np +import pytest +from qiskit_addon_sqd.subsampling import postselect_and_subsample, subsample + + +class TestSubsampling(unittest.TestCase): + def setUp(self): + # 4 qubit full sampling + self.bitstring_matrix = np.array( + [ + [False, False, False, False], + [False, False, False, True], + [False, False, True, False], + [False, False, True, True], + [False, True, False, False], + [False, True, False, True], + [False, True, True, False], + [False, True, True, True], + [True, False, False, False], + [True, False, False, True], + [True, False, True, False], + [True, False, True, True], + [True, True, False, False], + [True, True, False, True], + [True, True, True, False], + [True, True, True, True], + ] + ) + self.uniform_probs = np.array( + [1 / self.bitstring_matrix.shape[0] for _ in self.bitstring_matrix] + ) + + def test_subsample(self): + with self.subTest("Basic test"): + samples_per_batch = 2 + num_batches = 10 + batches = subsample( + self.bitstring_matrix, self.uniform_probs, samples_per_batch, num_batches + ) + self.assertEqual(num_batches, len(batches)) + for batch in batches: + self.assertEqual(samples_per_batch, batch.shape[0]) + with self.subTest("Test probability specification"): + samples_per_batch = 2 + num_batches = 10 + batches = subsample( + self.bitstring_matrix, self.uniform_probs, samples_per_batch, num_batches + ) + self.assertEqual(num_batches, len(batches)) + for batch in batches: + self.assertEqual(samples_per_batch, batch.shape[0]) + with self.subTest("Full sampling"): + samples_per_batch = 20 + num_batches = 1 + batches = subsample( + self.bitstring_matrix, self.uniform_probs, samples_per_batch, num_batches + ) + self.assertEqual(num_batches, len(batches)) + for batch in batches: + self.assertEqual(self.bitstring_matrix.shape[0], batch.shape[0]) + + with self.subTest("Non-positive batch size"): + samples_per_batch = 0 + num_batches = 10 + with pytest.raises(ValueError) as e_info: + subsample( + self.bitstring_matrix, + self.uniform_probs, + samples_per_batch, + num_batches, + ) + assert ( + e_info.value.args[0] + == "Samples per batch must be specified with a positive integer." + ) + with self.subTest("Non-positive num batches"): + samples_per_batch = 1 + num_batches = 0 + with pytest.raises(ValueError) as e_info: + subsample( + self.bitstring_matrix, + self.uniform_probs, + samples_per_batch, + num_batches, + ) + assert ( + e_info.value.args[0] + == "The number of batches must be specified with a positive integer." + ) + with self.subTest("Mismatching probs"): + samples_per_batch = 1 + num_batches = 1 + with pytest.raises(ValueError) as e_info: + subsample( + self.bitstring_matrix, + np.array([]), + samples_per_batch, + num_batches, + ) + assert ( + e_info.value.args[0] + == "The number of elements in the probabilities array must match the number of rows in the bitstring matrix." + ) + with self.subTest("Empty matrix"): + samples_per_batch = 1 + num_batches = 1 + batches = subsample( + np.array([]), + np.array([]), + samples_per_batch, + num_batches, + ) + self.assertEqual(num_batches, len(batches)) + self.assertEqual(0, batches[0].shape[0]) + + def test_postselect_and_subsample(self): + with self.subTest("Basic test"): + samples_per_batch = 2 + num_batches = 10 + hamming_left = 1 + hamming_right = 1 + partition_len = self.bitstring_matrix.shape[1] // 2 + batches = postselect_and_subsample( + self.bitstring_matrix, + self.uniform_probs, + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + self.assertEqual(num_batches, len(batches)) + for batch in batches: + self.assertEqual(samples_per_batch, batch.shape[0]) + for bitstring in batch: + self.assertEqual(hamming_left, np.sum(bitstring[:partition_len])) + self.assertEqual(hamming_right, np.sum(bitstring[partition_len:])) + with self.subTest("Zero hamming"): + samples_per_batch = 2 + num_batches = 10 + hamming_left = 0 + hamming_right = 0 + partition_len = self.bitstring_matrix.shape[1] // 2 + batches = postselect_and_subsample( + self.bitstring_matrix, + self.uniform_probs, + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + self.assertEqual(num_batches, len(batches)) + for batch in batches: + self.assertEqual(1, batch.shape[0]) + bitstring = batch[0] + self.assertEqual(hamming_left, np.sum(bitstring[:partition_len])) + self.assertEqual(hamming_right, np.sum(bitstring[partition_len:])) + with self.subTest("Empty after postselection"): + samples_per_batch = 2 + num_batches = 10 + hamming_left = 0 + hamming_right = 0 + partition_len = self.bitstring_matrix.shape[1] // 2 + batches = postselect_and_subsample( + self.bitstring_matrix[1:], + self.uniform_probs[1:], + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + self.assertEqual(num_batches, len(batches)) + for batch in batches: + self.assertEqual(0, batch.shape[0]) + with self.subTest("Negative hamming"): + samples_per_batch = 2 + num_batches = 10 + hamming_left = -1 + hamming_right = -1 + with pytest.raises(ValueError) as e_info: + postselect_and_subsample( + self.bitstring_matrix, + self.uniform_probs, + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + assert ( + e_info.value.args[0] + == "Hamming weight must be specified with a non-negative integer." + ) + with self.subTest("Non-positive batch size"): + samples_per_batch = 0 + num_batches = 10 + hamming_left = 1 + hamming_right = 1 + with pytest.raises(ValueError) as e_info: + postselect_and_subsample( + self.bitstring_matrix, + self.uniform_probs, + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + assert ( + e_info.value.args[0] + == "Samples per batch must be specified with a positive integer." + ) + with self.subTest("Non-positive num batches"): + samples_per_batch = 1 + num_batches = 0 + hamming_left = 1 + hamming_right = 1 + with pytest.raises(ValueError) as e_info: + postselect_and_subsample( + self.bitstring_matrix, + self.uniform_probs, + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + assert ( + e_info.value.args[0] + == "The number of batches must be specified with a positive integer." + ) + with self.subTest("Mismatching probs"): + samples_per_batch = 1 + num_batches = 1 + hamming_left = 1 + hamming_right = 1 + with pytest.raises(ValueError) as e_info: + postselect_and_subsample( + self.bitstring_matrix, + np.array([]), + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + assert ( + e_info.value.args[0] + == "The number of elements in the probabilities array must match the number of rows in the bitstring matrix." + ) + with self.subTest("Empty matrix"): + samples_per_batch = 1 + num_batches = 1 + hamming_left = 1 + hamming_right = 1 + batches = postselect_and_subsample( + np.array([]), + np.array([]), + hamming_left, + hamming_right, + samples_per_batch, + num_batches, + ) + self.assertEqual(num_batches, len(batches)) + self.assertEqual(0, batches[0].shape[0]) diff --git a/test/test_workflow.py b/test/test_workflow.py new file mode 100644 index 0000000..ab616e7 --- /dev/null +++ b/test/test_workflow.py @@ -0,0 +1,19 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Full test of workflow on minimal N2 example.""" + +import unittest + + +class TestSQD(unittest.TestCase): + def test_sqd(self): + pass diff --git a/tox.ini b/tox.ini new file mode 100644 index 0000000..0508dd3 --- /dev/null +++ b/tox.ini @@ -0,0 +1,67 @@ +[tox] +minversion = 4.0 +envlist = py{39,310,311,312}{,-notebook}, lint +isolated_build = True + +[testenv] +passenv = + SSH_AUTH_SOCK +extras = + test +commands = + pytest {posargs} + +[testenv:style] +extras = + style +commands = + ruff format qiskit_addon_sqd/ docs/ test/ + ruff check --fix qiskit_addon_sqd/ docs/ test/ + nbqa ruff --fix docs/ + +[testenv:lint] +basepython = python3.10 +extras = + lint +commands = + ruff format --check qiskit_addon_sqd/ docs/ test/ + ruff check qiskit_addon_sqd/ docs/ test/ + nbqa ruff docs/ + mypy qiskit_addon_sqd/ + #reno lint + pylint -rn qiskit_addon_sqd/ test/ + nbqa pylint -rn docs/ + pydocstyle qiskit_addon_sqd/ + +[testenv:{,py-,py3-,py39-,py310-,py311-,py312-}notebook] +extras = + nbtest + notebook-dependencies +commands = + pytest --nbmake --nbmake-timeout=3000 {posargs} docs/tutorials/ + +[testenv:coverage] +deps = + coverage>=7.5 +extras = + test +commands = + coverage3 run --source qiskit_addon_sqd --parallel-mode -m pytest test/ {posargs} + coverage3 combine + coverage3 html + coverage3 report --fail-under=100 --show-missing + +[testenv:docs] +basepython = python3.10 +extras = + docs +commands = + sphinx-build -j auto -W -T --keep-going -b html {posargs} {toxinidir}/docs/ {toxinidir}/docs/_build/html + +[testenv:docs-clean] +skip_install = true +allowlist_externals = + rm + mypy +commands = + rm -rf {toxinidir}/docs/stubs/ {toxinidir}/docs/_build/