From b8779ee14a5525eac8cbd54a495b08c23d5276cf Mon Sep 17 00:00:00 2001 From: trungtd-2436 Date: Thu, 9 Sep 2021 15:56:36 +0700 Subject: [PATCH 01/17] chore: create project structure --- .gitignore | 142 +++++++++++++++++++++++ .sun-ci.yml | 42 +++++++ LICENSE | 191 +++++++++++++++++++++++++++++++ MANIFEST.in | 16 +++ pyproject.toml | 7 ++ requirements.txt | 0 setup.cfg | 5 + setup.py | 27 +++++ table_reconstruction/__init__.py | 7 ++ tests/__init__.py | 0 tests/test_package.py | 16 +++ tox.ini | 48 ++++++++ 12 files changed, 501 insertions(+) create mode 100644 .gitignore create mode 100644 .sun-ci.yml create mode 100644 LICENSE create mode 100644 MANIFEST.in create mode 100644 pyproject.toml create mode 100644 requirements.txt create mode 100644 setup.cfg create mode 100644 setup.py create mode 100644 table_reconstruction/__init__.py create mode 100644 tests/__init__.py create mode 100644 tests/test_package.py create mode 100644 tox.ini diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2b14ebe --- /dev/null +++ b/.gitignore @@ -0,0 +1,142 @@ +# 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/ +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/ +cover/ + +# 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/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .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/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# Editor config folder +.vscode/ +.idea/ \ No newline at end of file diff --git a/.sun-ci.yml b/.sun-ci.yml new file mode 100644 index 0000000..093865d --- /dev/null +++ b/.sun-ci.yml @@ -0,0 +1,42 @@ +stages: +- Check source code πŸ”Ž +- Release πŸ”– + +jobs: +- name: Lint and Test with Tox + stage: Check source code πŸ”Ž + image: python:3.6 + script: + - pip3 install tox + - tox + coverage: + type: cobertura + path: coverage.xml + artifacts: + name: coverage + paths: + - htmlcov + expires_in: 3 days + cache: + - key: + files: + - tox.ini + - setup.py + paths: + - .tox/python3.* + - .tox/.package + except: + messages: + - '/\[ci skip ci\]/' + +- name: Check Typing with mypy + stage: Check source code πŸ”Ž + image: python:3 + script: + - pip3 install mypy types-setuptools + - python3 setup.py develop + - mypy table_reconstruction + allow_failure: true + except: + messages: + - '/\[ci skip ci\]/' diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..b70e4ca --- /dev/null +++ b/LICENSE @@ -0,0 +1,191 @@ + + Apache License + Version 2.0, January 2004 + https://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 + + Copyright 2013-2018 Docker, Inc. + + 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 + + https://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. \ No newline at end of file diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..0057544 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,16 @@ +include pyproject.toml + +# Include the README +include *.md + +# Include the license file +include LICENSE + +# Include setup.py +include setup.py + +# Include requirements +include requirements.txt + +# Include source code +recursive-include table_reconstruction *.py \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..f6bbbc3 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,7 @@ +[build-system] +# These are the assumed default build requirements from pip: +# https://pip.pypa.io/en/stable/reference/pip/#pep-517-and-518-support +requires = ["setuptools>=42", "wheel", "setuptools_scm[toml]>=3.4"] +build-backend = "setuptools.build_meta" + +[tool.setuptools_scm] diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..e69de29 diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..80d43f7 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,5 @@ + +[metadata] +# This includes the license file(s) in the wheel. +# https://wheel.readthedocs.io/en/stable/user_guide.html#including-license-files-in-the-generated-wheel-file +license_files = LICENSE \ No newline at end of file diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..ecd4830 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup +import pathlib +import sys + +home_page = "https://github.com/sun-asterisk-research/table_reconstruction" +assert sys.version_info >= ( + 3, 6, 2), "table_reconstruction requires Python 3.6.2+" + +here = pathlib.Path(__file__).parent.resolve() + +long_description = (here / "README.md").read_text(encoding="utf-8") + +setup( + name="table_reconstruction", + use_scm_version=True, + author="Sun* AI Research", + author_email="sun.converter.team@gmail.com", + setup_requires=['setuptools_scm'], + description="A table reconstruction package", + long_description=long_description, + long_description_content_type="text/markdown", + url=home_page, + project_urls={ + "Bug Tracker": "{}/issues".format(home_page), + }, + python_requires=">=3.6", +) diff --git a/table_reconstruction/__init__.py b/table_reconstruction/__init__.py new file mode 100644 index 0000000..839f5f1 --- /dev/null +++ b/table_reconstruction/__init__.py @@ -0,0 +1,7 @@ +from pkg_resources import get_distribution, DistributionNotFound +__version__ = None +try: + __version__ = get_distribution("table_reconstruction").version +except DistributionNotFound: + __version__ == "0.0.0" # package is not installed + pass diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_package.py b/tests/test_package.py new file mode 100644 index 0000000..7f97f6c --- /dev/null +++ b/tests/test_package.py @@ -0,0 +1,16 @@ +import unittest + + +class TestModule(unittest.TestCase): + def test_module_exist(self): + exception = None + try: + import table_reconstruction + print(table_reconstruction.__version__) + except Exception as e: + exception = e + self.assertIsNone(exception) + + +if __name__ == '__main__': + unittest.main() diff --git a/tox.ini b/tox.ini new file mode 100644 index 0000000..262e6e2 --- /dev/null +++ b/tox.ini @@ -0,0 +1,48 @@ +# this file is *not* meant to cover or endorse the use of tox or pytest or +# testing in general, +# +# It's meant to show the use of: +# +# - check-manifest +# confirm items checked into vcs are in your sdist +# - python setup.py check +# confirm required package meta-data in setup.py +# - readme_renderer (when using a ReStructuredText README) +# confirms your long_description will render correctly on PyPI. +# +# and also to help confirm pull requests to this project. + +[tox] +envlist = python3.{6,7,8,9} +# Define the minimal tox version required to run; +# if the host tox is less than this the tool with create an environment and +# provision it with a tox that satisfies it under provision_tox_env. +# At least this version is needed for PEP 517/518 support. +minversion = 3.3.0 + +# Activate isolated build environment. tox will use a virtual environment +# to build a source distribution from the source tree. For build tools and +# arguments use the pyproject.toml file as specified in PEP-517 and PEP-518. +isolated_build = true + +[testenv] +deps = + check-manifest >= 0.42 + # If your project uses README.rst, uncomment the following: + # readme_renderer + flake8 + coverage +commands = + check-manifest --ignore 'tox.ini,tests/**,.sun-ci.yml' + # This repository uses a Markdown long_description, so the -r flag to + # `setup.py check` is not needed. If your project contains a README.rst, + # use `python setup.py check -m -r -s` instead. + python setup.py check -m -s + flake8 . + coverage run --source table_reconstruction -m unittest discover tests + coverage xml + coverage html + +[flake8] +exclude = .tox,*.egg,build,data +select = E,W,F From 8c41e65bcd990c498c05bf9353b978542f59acab Mon Sep 17 00:00:00 2001 From: trungtd-2436 Date: Fri, 10 Sep 2021 23:28:31 +0700 Subject: [PATCH 02/17] chore: update tox and CI config --- .sun-ci.yml | 18 ++++++++++++------ example/.gitkeep | 0 setup.py | 6 ++++++ tox.ini | 6 ++---- 4 files changed, 20 insertions(+), 10 deletions(-) create mode 100644 example/.gitkeep diff --git a/.sun-ci.yml b/.sun-ci.yml index 093865d..9b8c8d2 100644 --- a/.sun-ci.yml +++ b/.sun-ci.yml @@ -3,12 +3,19 @@ stages: - Release πŸ”– jobs: +- name: Check code format with flake8 + stage: Check source code πŸ”Ž + image: python:3.6 + script: + - pip3 install flake8==3.9.2 + - flake8 table_reconstruction + - name: Lint and Test with Tox stage: Check source code πŸ”Ž image: python:3.6 script: - - pip3 install tox - - tox + - pip3 install tox opencv-python-headless + - tox -p auto --parallel-live coverage: type: cobertura path: coverage.xml @@ -23,8 +30,7 @@ jobs: - tox.ini - setup.py paths: - - .tox/python3.* - - .tox/.package + - .tox except: messages: - '/\[ci skip ci\]/' @@ -33,9 +39,9 @@ jobs: stage: Check source code πŸ”Ž image: python:3 script: - - pip3 install mypy types-setuptools + - pip3 install mypy types-setuptools opencv-python-headless - python3 setup.py develop - - mypy table_reconstruction + - mypy table_reconstruction --install-types --ignore-missing-imports allow_failure: true except: messages: diff --git a/example/.gitkeep b/example/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/setup.py b/setup.py index ecd4830..94cd3a1 100644 --- a/setup.py +++ b/setup.py @@ -10,6 +10,9 @@ long_description = (here / "README.md").read_text(encoding="utf-8") +with open('requirements.txt') as f: + requirements = f.read().splitlines() + setup( name="table_reconstruction", use_scm_version=True, @@ -23,5 +26,8 @@ project_urls={ "Bug Tracker": "{}/issues".format(home_page), }, + include_package_data=True, python_requires=">=3.6", + install_requires=requirements, + ) diff --git a/tox.ini b/tox.ini index 262e6e2..bcfa0c4 100644 --- a/tox.ini +++ b/tox.ini @@ -23,22 +23,20 @@ minversion = 3.3.0 # Activate isolated build environment. tox will use a virtual environment # to build a source distribution from the source tree. For build tools and # arguments use the pyproject.toml file as specified in PEP-517 and PEP-518. -isolated_build = true + [testenv] deps = check-manifest >= 0.42 # If your project uses README.rst, uncomment the following: # readme_renderer - flake8 coverage commands = - check-manifest --ignore 'tox.ini,tests/**,.sun-ci.yml' + check-manifest --ignore 'tox.ini,tests/**,.sun-ci.yml,coverage.xml,.coverage,example/**' # This repository uses a Markdown long_description, so the -r flag to # `setup.py check` is not needed. If your project contains a README.rst, # use `python setup.py check -m -r -s` instead. python setup.py check -m -s - flake8 . coverage run --source table_reconstruction -m unittest discover tests coverage xml coverage html From c9da96ed9098dd8fa34a99ce6b4c3bd59eaa2b99 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tr=E1=BA=A7n=20=C4=90=E1=BB=A9c=20Trung?= Date: Fri, 10 Sep 2021 23:42:46 +0700 Subject: [PATCH 03/17] chore: fix tox command in CI config --- .sun-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.sun-ci.yml b/.sun-ci.yml index 9b8c8d2..533302c 100644 --- a/.sun-ci.yml +++ b/.sun-ci.yml @@ -15,7 +15,7 @@ jobs: image: python:3.6 script: - pip3 install tox opencv-python-headless - - tox -p auto --parallel-live + - tox coverage: type: cobertura path: coverage.xml From 0ef9ebdbe18c268c6ccad454e4292708e4dc85b9 Mon Sep 17 00:00:00 2001 From: trungtd-2436 Date: Mon, 13 Sep 2021 17:54:53 +0700 Subject: [PATCH 04/17] fix: missing submodule when installing manually, update config used by CI tools --- .flake8 | 3 +++ .sun-ci.yml | 2 +- pyproject.toml | 3 ++- setup.py | 13 +++++++------ table_reconstruction/__init__.py | 1 + tests/test_package.py | 3 ++- tox.ini | 4 +++- 7 files changed, 19 insertions(+), 10 deletions(-) create mode 100644 .flake8 diff --git a/.flake8 b/.flake8 new file mode 100644 index 0000000..e0ea542 --- /dev/null +++ b/.flake8 @@ -0,0 +1,3 @@ +[flake8] +max-line-length = 88 +extend-ignore = E203 \ No newline at end of file diff --git a/.sun-ci.yml b/.sun-ci.yml index 533302c..3cf593a 100644 --- a/.sun-ci.yml +++ b/.sun-ci.yml @@ -41,7 +41,7 @@ jobs: script: - pip3 install mypy types-setuptools opencv-python-headless - python3 setup.py develop - - mypy table_reconstruction --install-types --ignore-missing-imports + - mypy table_reconstruction --install-types --non-interactive --ignore-missing-imports allow_failure: true except: messages: diff --git a/pyproject.toml b/pyproject.toml index f6bbbc3..b148f9f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,4 +4,5 @@ requires = ["setuptools>=42", "wheel", "setuptools_scm[toml]>=3.4"] build-backend = "setuptools.build_meta" -[tool.setuptools_scm] +[tool.isort] +profile = "black" diff --git a/setup.py b/setup.py index 94cd3a1..37717f6 100644 --- a/setup.py +++ b/setup.py @@ -1,16 +1,16 @@ -from setuptools import setup +from setuptools import setup, find_packages import pathlib import sys home_page = "https://github.com/sun-asterisk-research/table_reconstruction" -assert sys.version_info >= ( - 3, 6, 2), "table_reconstruction requires Python 3.6.2+" +assert sys.version_info >= (3, 6, 2), "table_reconstruction requires Python 3.6.2+" here = pathlib.Path(__file__).parent.resolve() long_description = (here / "README.md").read_text(encoding="utf-8") -with open('requirements.txt') as f: +print(find_packages(where=".", exclude=["tests"])) +with open("requirements.txt") as f: requirements = f.read().splitlines() setup( @@ -18,7 +18,7 @@ use_scm_version=True, author="Sun* AI Research", author_email="sun.converter.team@gmail.com", - setup_requires=['setuptools_scm'], + setup_requires=["setuptools_scm"], description="A table reconstruction package", long_description=long_description, long_description_content_type="text/markdown", @@ -29,5 +29,6 @@ include_package_data=True, python_requires=">=3.6", install_requires=requirements, - + package_dir={"": "."}, + packages=find_packages(where=".", exclude=["tests"]), ) diff --git a/table_reconstruction/__init__.py b/table_reconstruction/__init__.py index 839f5f1..29e3a5f 100644 --- a/table_reconstruction/__init__.py +++ b/table_reconstruction/__init__.py @@ -1,4 +1,5 @@ from pkg_resources import get_distribution, DistributionNotFound + __version__ = None try: __version__ = get_distribution("table_reconstruction").version diff --git a/tests/test_package.py b/tests/test_package.py index 7f97f6c..9f33293 100644 --- a/tests/test_package.py +++ b/tests/test_package.py @@ -6,11 +6,12 @@ def test_module_exist(self): exception = None try: import table_reconstruction + print(table_reconstruction.__version__) except Exception as e: exception = e self.assertIsNone(exception) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tox.ini b/tox.ini index bcfa0c4..c915af0 100644 --- a/tox.ini +++ b/tox.ini @@ -32,7 +32,7 @@ deps = # readme_renderer coverage commands = - check-manifest --ignore 'tox.ini,tests/**,.sun-ci.yml,coverage.xml,.coverage,example/**' + check-manifest --ignore 'tox.ini,tests/**,.sun-ci.yml,coverage.xml,.coverage,example/**,.flake8' # This repository uses a Markdown long_description, so the -r flag to # `setup.py check` is not needed. If your project contains a README.rst, # use `python setup.py check -m -r -s` instead. @@ -44,3 +44,5 @@ commands = [flake8] exclude = .tox,*.egg,build,data select = E,W,F +max-line-length = 88 +extend-ignore = E203 \ No newline at end of file From a91a89421b8994ced35dedaa2cf2f567e5e4d414 Mon Sep 17 00:00:00 2001 From: trungtd-2436 Date: Tue, 14 Sep 2021 14:59:19 +0700 Subject: [PATCH 05/17] feat: define package output --- requirements.txt | 2 + setup.py | 3 +- table_reconstruction/__init__.py | 27 ++++++++++- table_reconstruction/output/__init__.py | 0 table_reconstruction/output/cell.py | 42 ++++++++++++++++++ table_reconstruction/output/element.py | 59 +++++++++++++++++++++++++ table_reconstruction/output/table.py | 29 ++++++++++++ 7 files changed, 160 insertions(+), 2 deletions(-) create mode 100644 table_reconstruction/output/__init__.py create mode 100644 table_reconstruction/output/cell.py create mode 100644 table_reconstruction/output/element.py create mode 100644 table_reconstruction/output/table.py diff --git a/requirements.txt b/requirements.txt index e69de29..e825368 100644 --- a/requirements.txt +++ b/requirements.txt @@ -0,0 +1,2 @@ +numpy>=1.18.5 +Pillow>=8.2.0 \ No newline at end of file diff --git a/setup.py b/setup.py index 37717f6..69ccfe3 100644 --- a/setup.py +++ b/setup.py @@ -1,7 +1,8 @@ -from setuptools import setup, find_packages import pathlib import sys +from setuptools import find_packages, setup + home_page = "https://github.com/sun-asterisk-research/table_reconstruction" assert sys.version_info >= (3, 6, 2), "table_reconstruction requires Python 3.6.2+" diff --git a/table_reconstruction/__init__.py b/table_reconstruction/__init__.py index 29e3a5f..cb46a9b 100644 --- a/table_reconstruction/__init__.py +++ b/table_reconstruction/__init__.py @@ -1,4 +1,11 @@ -from pkg_resources import get_distribution, DistributionNotFound +import os +from typing import List, Union + +from numpy import array, ndarray +from PIL.Image import Image +from pkg_resources import DistributionNotFound, get_distribution + +from table_reconstruction.output.table import Table __version__ = None try: @@ -6,3 +13,21 @@ except DistributionNotFound: __version__ == "0.0.0" # package is not installed pass + + +class TableExtraction: + def __init__(self, line_segment_weight_path: str) -> None: + if not os.path.exists(line_segment_weight_path): + raise ValueError( + "Could not find weight files at {}".format(line_segment_weight_path) + ) + + raise NotImplementedError("Line Segmentation model was not defined") + + def extract(self, image: Union[ndarray, Image]) -> List[Table]: + if isinstance(image, Image): + image = array(image) + elif not isinstance(image, ndarray): + raise ValueError(("Input image must be Numpy array or PIL Image")) + + raise NotImplementedError("Extracting methods were not defined") diff --git a/table_reconstruction/output/__init__.py b/table_reconstruction/output/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/table_reconstruction/output/cell.py b/table_reconstruction/output/cell.py new file mode 100644 index 0000000..d182b40 --- /dev/null +++ b/table_reconstruction/output/cell.py @@ -0,0 +1,42 @@ +from typing import Tuple + +from .element import Element + + +class Cell(Element): + def __init__( + self, + coordinate: Tuple[int, int, int, int], + col_index: int, + row_index: int, + col_span: int, + row_span: int, + ): + """The constructor of objects of class Table, this function accepts column + number, row number, table coordinates and information of cells defined within it + To handle the cases where cells are merged together, the cells to be extracted + are defined as connected regions surrounded by straight lines. + For example, in the following table, cell has been marked (*) has col index is 1 + and row index is 1. It spans 1 unit in rows and 2 units in columns + β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” + β”‚ This is a cell β”‚ This is a cell β”‚ This is a cell β”‚ + β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€ + β”‚ This is a cell β”‚ β”‚ This is a cell β”‚ + β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€ This is a cell * β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€ + β”‚ β”‚ β”‚ This is a cell β”‚ + β”‚ This is a cell β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€ + β”‚ β”‚ This is a cell β”‚ This is a cell β”‚ + β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ + Args: + coordinate (List[int, int, int, int]): A list that contains 4 integer values + ​​defined as x_min, x_max, y_min, y_max respectively + col_index (int): The ordinal number of the column in which this cell starts + row_index (int): The ordinal number of the row in which this cell starts + col_numb (int): The number of units that the cell spans in cols + row_numb (int): The number of units that the cell spans in rows + """ + self.coordinate = coordinate + self.row_index = row_index + self.col_index = col_index + self.col_span = col_span + self.row_span = row_span diff --git a/table_reconstruction/output/element.py b/table_reconstruction/output/element.py new file mode 100644 index 0000000..9ee6e74 --- /dev/null +++ b/table_reconstruction/output/element.py @@ -0,0 +1,59 @@ +from typing import Tuple + + +class Element: + def __init__(self, coordinate: Tuple[int, int, int, int]): + """The constructor of objects of class Element, this function takes 4 integer + values ​​defined as x_min, x_max, y_min, y_max respectively. + These values ​​are used to determine 2 points: top-left point (x_min, y_min) and + bottom-right point (x_max, y_max) + For example: + (x_min, y_min)──────────────────────────────┐ + β”‚ β”‚ + β”‚ β”‚ + β”‚ β”‚ + └─────────────────────────────────(x_max, y_max) + + Args: + coordinate (List[int, int, int, int]): A list that contains 4 integer values + ​​defined as x_min, x_max, y_min, y_max respectively + """ + self.coordinate = coordinate + + @property + def x_min(self): + return self.coord[0] + + @x_min.setter + def x_min(self, value): + self.coordinate[0] = value + + @property + def x_max(self): + return self.coord[1] + + @x_max.setter + def x_max(self, value): + self.coordinate[1] = value + + @property + def y_min(self): + return self.coordinate[2] + + @y_min.setter + def y_min(self, value): + self.coordinate[2] = value + + @property + def y_max(self): + return self.coordinate[3] + + @y_max.setter + def y_max(self, value): + self.coordinate[3] = value + + def __repr__(self): + return f"{self.__class__.__name__}({self.coord})" + + def __str__(self): + return f"{self.__class__.__name__}({self.coord})" diff --git a/table_reconstruction/output/table.py b/table_reconstruction/output/table.py new file mode 100644 index 0000000..c111f36 --- /dev/null +++ b/table_reconstruction/output/table.py @@ -0,0 +1,29 @@ +from typing import List, Tuple + +from .cell import Cell +from .element import Element + + +class Table(Element): + def __init__( + self, + coordinate: Tuple[int, int, int, int], + col_numb: int, + row_numb: int, + cells: List[Cell] = [], + ): + """The constructor of objects of class Table, this function accepts column + number, row number, table coordinates and information of cells defined within it + + Args: + coordinate (List[int, int, int, int]): A list that contains 4 integer values + defined as x_min, x_max, y_min, y_max respectively + col_numb (int): Number of columns detected in the table + row_numb (int): Number of rows detected in the table + cells (List[Cell], optional): List of objects of class Cell containing + information about detected cells in the table. Defaults to []. + """ + self.coordinate = coordinate + self.col_numb = col_numb + self.row_numb = row_numb + self.cells = cells From 888486bcdc65ccdcc18682b86f579e87eeaa58c3 Mon Sep 17 00:00:00 2001 From: Do Dang Hung Date: Fri, 10 Sep 2021 17:16:12 +0700 Subject: [PATCH 06/17] wip: add line segmentation module test: add notebook for testing --- example/example.ipynb | 158 +++++++++ example/table.png | Bin 0 -> 266241 bytes requirements.txt | 2 - .../line_segmentation/__init__.py | 0 .../line_segmentation/dataset.py | 75 +++++ .../line_segmentation/line_segment.py | 106 ++++++ .../line_segmentation/unet/__init__.py | 0 .../line_segmentation/unet/dynamic_unet.py | 225 +++++++++++++ .../line_segmentation/unet/repunet.py | 317 ++++++++++++++++++ .../line_segmentation/unet/resunet.py | 104 ++++++ .../line_segmentation/unet/unet_model.py | 37 ++ .../line_segmentation/unet/unet_parts.py | 77 +++++ .../line_segmentation/utils.py | 32 ++ 13 files changed, 1131 insertions(+), 2 deletions(-) create mode 100644 example/example.ipynb create mode 100644 example/table.png delete mode 100644 requirements.txt create mode 100644 table_reconstruction/line_segmentation/__init__.py create mode 100644 table_reconstruction/line_segmentation/dataset.py create mode 100644 table_reconstruction/line_segmentation/line_segment.py create mode 100644 table_reconstruction/line_segmentation/unet/__init__.py create mode 100644 table_reconstruction/line_segmentation/unet/dynamic_unet.py create mode 100644 table_reconstruction/line_segmentation/unet/repunet.py create mode 100644 table_reconstruction/line_segmentation/unet/resunet.py create mode 100644 table_reconstruction/line_segmentation/unet/unet_model.py create mode 100644 table_reconstruction/line_segmentation/unet/unet_parts.py create mode 100644 table_reconstruction/line_segmentation/utils.py diff --git a/example/example.ipynb b/example/example.ipynb new file mode 100644 index 0000000..950cb79 --- /dev/null +++ b/example/example.ipynb @@ -0,0 +1,158 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "import cv2\n", + "import torch \n", + "\n", + "from table_reconstruction.line_segmentation.line_segment import LineDetector\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.figsize\"] = (20,10)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "img_path = \"table.png\"\n", + "img = cv2.imread(img_path)\n", + "plt.imshow(img)" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 3 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "line_segmentation = LineDetector(device=device)\n", + "mask = line_segmentation.predict(img_path)\n", + "plt.imshow(mask)" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 4 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 10, + "source": [ + "(img.shape[0], img.shape[1]) == (mask.shape[0], mask.shape[1])" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 14, + "source": [ + "img.shape[0:2] == mask.shape[0:2]" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ], + "metadata": {} + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/example/table.png b/example/table.png new file mode 100644 index 0000000000000000000000000000000000000000..cf86fa250749f8abadda4d333e8b297cc5771379 GIT binary patch literal 266241 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 z zG?T!g>hmSZRqV2}qJEFYhlymP*o!v(8ifK?tB zhn3N!e}Rb*ekVbG!-}Z|rnD}uO^)unpBG^JJK@xuGGS?HxO&A~NR62g1_z%Dcbf&r zt&AXl42mGcc#XrO#9%qZFoDYOqF@k>BtzVORknkWiFM74w>ZeZrxmeU{ZGN7PUX`&Q%=IQ|zt|54;6a{FuP%_*6K@b5C#&(QB!Yqu^bX<@-0V+ykpD4jjmur7CMT2C{94wLNneQJvL8JNmB|+tlflNF6o5})qZr}wL0?+>@W$gem&;94}I0S01YHPHksKiCpiR9L-sE5(^hlue|&c!sQQUS#l%n_zoOQapmB-# zcxi1X>9-)4eY-qsZ$o|pY;ERNH(;%(Sax>v1Xz+Q zX?UOEF?Ii=`XMXF;Ms*e4?!_WwY7aRPRA$S_Sv}u{|AX9rRC*S#utGfVms|I6CNED zUN_tNum^0z@#V+_8nM83!{EIlHZ{NQ94BCCTUAq&pMUM+y@ia|dzF;ZqYdk5KzbYF z>7~jl{dyNN1H5R00lVVx=qRWFk+?}EnTj)*K~ucP(hy;h~iwlkxTOHopRw zba|^=7=Hy5MayluPP9Ae@;`sxwDBKa*dxGA2WpaGg0~M%OtYsSk$Odxr(^2dkgThr zsi}sO6dFp(bnAN;R;rQSEq~n`Q5L!gea^2tbs+Izen_x_y87)~&Ewx+VGkhHOH7{A zVaWkby^~{%l)oggNm`62-uOFlmdCTX<@Cxz_VL}$7k~QFTR^9N3jwtBqrT=;i&$bM zJnGwR*_LBYpck^~>*9;l%d`P4lEB^awM6Djy(R2yVuy!;q&YnU&eFQ|JBf4vmvNUg zHHdEnfM1x|_zD`=OS>yf@!;Uj&-mcK0YjBQ7=lt&akPeZaf%c@W zzmsS&&8JnZeO6KxCVM0>oGJBti+Al~N%WykhwcsM_F{>$++EQjP|6pf4 zWcs=PK`S5w;uPL&Bn03l88toH0DGcC!v_Ym$U1Cn@4&uGNHk_LoBs9Y#G(x*I?yH8 z2O7wNs=sn`+J!eODOy`~iQjzYt98D34WYM}1($<@=yfo3_ROkSwlnoaBFN$8VF>9_ zoAyegXQut^-ef2yNU`sNhqupAVLwa(7Q>ADnw-}Wq>BnWfBZrq(bUrF*o^m}4hVkOt+;NU0X6YjCWk zX**;H!9k&+*l4UpNJ=uX7cI)qf9%=>1=t!4zX)VxQsfMx7OHo6Y3vYGe)2MdV?%>E zLJTM%Brw=fh~purfLG=YLDhTU$zrIQER`=t)aw_Yr?Op`R>zzpNm3Gx04;U_v=#2G zfPvw*oja>S?wp;YUlAQN5X;e%m$79-cnQ{ftFa{Hd^@mIMUujs%$$d906CiJ2p8XA zQ`96%OjKRP{@=e96**=BptG|lRWI~Xz(%0fA=9zDw1nNXoCdEmZG+yv{T3T60lFEW zf+RkkX!KrYC8!tKW_n2Wure<# zOTguR37c(DXMX)+A0O2DDO4f@;wlBoDnYBBQe0g~$U+=b%xzH%TKQn03G4BX9)Z*( z8(nt^9Ap}1fnx}(pO9&>UUMU{C7*hG`uVgd+mWFb+f*LSfqI(Vpm}=r2@O>iJTJfs z=VCwmAP^wtXS`+n`Gi@za|$-IfSBgJ(=Nki&!Iz6usp!w>jov4IC8}2dKVoH{3|9b z?3G^{2k-b-d?gahvfXzHl$RBxpbMOuWmkS>Ug!t)0o;FFH7eAl1CFhsz$iO7Sj&5- z7_ujPTK!eDwlB4bnwXqVjdZ-rcPXpTvdfIb^rWXgG2cC06v{jYROFM%u{|{vu-m}M+1_@a47_vr=-3g79qH$wJ)3Z;jhmix98KBIAzu2SBN-pZ*tatS znw5_H3IOU7!(eVx(+d_>7gJGiatiV3UR6dv0G{d$c)(%jK^j9j4Q@5Jda+n3c)K?9 zh2iIY1D+eUbvkdx-&RN|rkv^V@?{kwF`|1`i+=m(k=Jlr4G<>Hu2Htt(QUTPlcokx ziyE+G#Lqv_mL5JO)s-3*uoi$^qo1p+7eN*5p_&KL#Jnm}4blh>ql~{G4)j_v35n3a z6!YZwO^QwXgS+}$0wF?;dmhfUchkCqhYlZZOwi8-ts4V0rX5^H5s8Vek&y>h13Hen zvUaG!^K&6hPaprak9R#BzYyeJy|PgK^7sdm#6!e$OPGMOzt@#~kU6Ayr8--Jtiqih z6#X?|sR|p_mU`@wG9GHay0yCy!2MGQZ_-**dp1AnWro|_@yzIvKQf_U9xZiD`N%J&~3nzn_& zJz!>1`)Qn?$S4VljU7g13}yYhPoLJl1#OllUCCnaIP1pX^Sg;=y`MUPS!Y5Tq0%ab zEi|^JNKLwpUu|c`G(i0i2)Hq8GJu_W(IFuYKXKzae<*!|(G?i`z9VgN%tKmqjIOK%Gp$ zrm&Z3HcbtcFCGnxMuFdmM+sk=vWlv{o43k?j+0t308}u=ufWbYA(Oc)*RRt#Ab?=6 zdl>P;DI?%phzK>L+1gq~1GMPs>Vo?CE&QO+DIvGWz64(tBQ19ZQO(kzU}tA%ApZ;7 zA@h`bS=&l@kuFTo11if|!nZHE>$2p&C* z7Zep0L2iNa`O(|s%RUeP4Ks`my+*fL@p)03IE;!Suxtx3H|$B@C!N$*$P|G_M7`$y z10u_6?+kS+L>B`OMnKT><1(&CCCU8upMCJ518i*P&IyOSf3K@n-96yT|Ni}EGHM2{ z{64A5n@eeEle36?(&oG+fvi}o48lB(^Fr>#z5%6=_eks@n%XxcO1NlkW{ot z$_yDv%P5ty6UtuMt7Sw~ilmGrlt{=P5waC!?}+TZ`QG37ob&md>zwne>s;6E_WR@d zt6S%Mdh>q0p5yVjKkftmdZ4r5GLnAoOvaZ5>h_5fl+X2-MO6PDE?NizCOtRfi}v?( z%9#juDYvNCufxigKb&awz_y$|^6zKT?qZzFPnqc2@Jmn?)#o2eh9WS!z8DH1AjIG7`LA&krGx1ghlxZ#3E9yPzw&}zyDXM`L5RPZ$FH>}YaQj5mo|RTXYysQ zi+@jgeqO$87eRak)0)3hM@fweEqW^~{${`Va;D3n3$X$Z5ur(9*^mGnk=AgU+OGdh z#d-Ggi>vfTMlA00#E=V|m|(f1SzE~#j%ESpG`QbqQ9#28L+E#YOU1h|1`>VZ=l6J{ zGs^xq5hjLzZ~>MSC9eufh+bQ(SEFDFI#^$c0rLDad+UMsuzVN*+E7lEHR-jZn2(A& zYQ?!j75a!pG11z@yxt3}JQ^E(?;O``kw*YZt}}tJzScX-ZtN%gZv1#?^X<`+KA70v znC9G!>`f3Z>F9Q8>w@MBrZkI?e${Zthqdsua9eU5__YQ8N+@e~*aBK5MxIV6QCBSK z+CnygTBsW5Fcp3xYyE}|D?pkjB327!;4|%AMTI(N^Kl4!Frz&eO_BeDeK(&)fp?$y z!mI^RWl@t%bgiyhQysg&ZyZfcC>K%({52G;c>460$`>LoAicAk5ci(Ab(<({fOlsP z0wxQ5m^?xi^rAk=ftEOJ&U6%OFhl5ISYNPmu zW$6Fnnipr0RbQhv?s z!^nPlBK0em%O6|&Yr<1X#vP~3SN_Q&B{H|$1LQHqP^f#9m!Q@sve1_} zQ0^B$lv&+)sha^-0Dgr@6Vwl?mI;=XFZaS64NGKU{qG!3kuOn;eE?hB46)4)1M{Nze8 zTH-_l`9bi0nZNK`8~>E=UzBUssa7yGxA68)o4HH@b}dOHt{FRE=Q=taL}6(YV0Bb9 zFpOY_%nPA{Teem`#ntrS!8$ZPTc^c)KaeXu{E^DvGIO0NdsXW8S{dydTz6L8*t_9v zuBOKg_cdRhQ|#i;mQ?(p{yfJ$W9zx>Cdx~fKDbhRklwl>I*xAZ^DP`5Q{@Y94jQyR zIJVE;oS(d@Cub&R2dBL~E%{r=qtTBZF>C`x7bUIqEuV>&4|5iJ zVeJp|E=<2ZG@pfj-@o{~x#;Yp8#iXrleUT@7!Hf>lBTAMcwWiUe=2E<0+BKV)n$cO z01A7!@U4_sn}Fj+OP4}&Oh)?NKE5KU5~@;nigmiKA>hEkFJEcNY)NUy;@_^Q*x9AJ z&Fmw5{>3wZ9{*z=s`)kLXeck^J!S%X0=IcZZFwxg=14;}M-dkJ{F)%*=tc z7M)DY%wbfIjwjk$jJ8U-0ZXN%Y~H}Y;Ao`N(TzUYe{YfOsf-P5jQ;oTVI$}nHx2g& z@Zp3h`Shuxy4u=&)B4TpcKH?#vf-78zIATyZ%i9#EJlcUBq052Vx4Q!_C{EqissjE%*{r?9%fU=C?O(76c+2%O&)rjSomh(@bl z8}DU8xA*j^I2F~XkzuOWCefGZvAN*QIFUW?IF!~_T3Y(3h>PMz2*CfTKZ%E;#DqD4=aAr1~(FSZ||v>QslB|3iPxaJpv#X60{k- zhdGs0>GEqnbEdN5p5~d#m$tUHz-tH?W~J>_Ns>4fe%jV&vLEz!N=C=#tOWvL$Se-i z`IT$wq7sq@s9W^S&80s+Ks?UjcOW+Ta>^OjzyJF2MIm}2TucP7K~^C+eaxys&%Jsu zcoGylNH2i*2#br08|IImiC9NPO)YT5gkQj9b>Y|VmrVv*3GWBoMJ+lDApAuxv8dB1 z7bhoqHhgaL-TOBx04~V3aB-ot(?GKh>x#yaV~iww zE+&{3j2m&s#C-S=irCz}2d^~Udq(EZdR%(o#{&I!mR)5MKv3 zcO_I+b(Qj>S|EkiL7Z$-9ulY97rPR=rQA|WsAx}|JcPYX$d(IL*cBFH1%pr?`H2S) zzLfH+JP|O7IUR+71KY`pP>dA%#ZBKrc|`!FNYB-6`;H*&3xZ~Z0@owOwPX^QoMKOJ zQ8FQ}gRny%ODa%CW82p)b_kMZ7iF!II*V22jrYiWvQMTZUCY8Ua>|Y79v24(4eOy~ zyV5$MYp8{tn|8a&MjS zP_SU`oE|B!M#x<}z-;#r?}o{#OXcZP)H)E3whZ0_wP%YJpO2O~yF^MgXQ_4a}U17>Ev_)aL= z_U+rJ5Tz96;CT8>EYqe{#^Rw1X(zM@&%?AcyDQ*RV%d6Q>e#U# z)h0DnVCpzzW3wX*G4;q^jh()QTM7#cyFX{_c4@h%Kuaqxt6NHioH8E|kHS`tf)IZD zZzZDkRtsqoH$Q%43-Po0siYYq?o#L*LB-Zeorsa-$$&$v4;vb$-wxj{*3>FR9&w8D z8lI=g{EA4-8pgVs4&pdAYv=K15hwX$XYZIMpPcr-Q3pYLgj@iXW_i;b_(v|=b|VEV zRNTc~Hax@8Br;0r)p%bWp{uFgdDO6Zo*CMA*qyVkUQM%Nust9?KR@`ed2h|E!cE!rVI6o zbJ8vg7LR!S+Pqk#kBu`L+75zv4!^oK$50uO_h^P>597Q3+54sVYTM=X{P_=a(+{v zKtsJc#hS;Uahe)mJme5@*MdkqJvsT@%gRV4%YLHFx~j{AevW;r<43Uno(qR6x}B+R z)U^#T;y6l#@cT!ZhRem%Uu?5@!$^9Y;;S3dw^upM9n|i+_kjS(n@MFjrC3n?zUpA- z%*?Ktyk@6*Hl53j8G)AUQ5Jdze0+Sef30S!Vl?Eft(jM8&bi)wCZZzs;1NuHD%cK7 zzxdLWDNv=f>+Fn`5rJ&wZ5umV3D{gVTn%Lpc5V{HaTz%`*-lH(=|ygeJZiKb67ery zj5uk_I1lCdAN655O00(pyjged;$4oaAGKhQ4Yj`c66d&=rWxuj$Mo4jX zku6X0XtBqps6%vTf2$Z(_8o@T5UE%#e3+Y?q5TH)p-svc6IMVY*45tbx!*8a1b{g5 z9s~|@ZNy}Mrx0#9NBfCwoScjsHo(qtyIL|?B8+UjhsQ|35mvVt@l!xNy18W+?H2v1 zJL(yRL-*IL85Xhr3G_5oNcRNlj~4mAlt{ZHb#!%UtgKeNy_ENgRn%Vc-@cif#P_XN z-p?i%Tvl4T@~z2&1m5)(Okd)J>?#FVgrza6iHEg-H%r}XrCp5YtC{$6hBD8`ny1w$ zlM)N4IY0`r|t5$s{UR7oRr8SEvZQJLj9Vw~z?7c|TU5pM59br;46h{AE zlv~LsD7an+opgU4LzeaoKP6?cma(y()2vys-$tC;FDU&(P|@WnW{MH425JqAo7U-r zk>E`;N3zHBqOpO2n-8*zMBPZ5SJWh2wQ%!h8H)Ia%|T4&`BX@ExM~<_WVQeH6||Ci zM93L6BuKn`-P740%2`cGHA?=+d*HwJ^E-WkPm)2km~Qd8E92h_O)~lz2n~&*l9Cav zq@tnj@==Cs2^KC+$7)~I#h;|7MWUEr9KL{ zx_ETiXaJ;y^qyWWsH-v}*7LPNMb%CwCZ_+vml3U+BD~eSJ0p4z%q#jtE~!AwIQ-}B zkXmEuH1_jRnwy@iELWA&@e`CZK`@?5&}`j`MM!`MrRm*vq~UUP=WLI}MA__NEUinU z{rHo>q+1uyA(TtXnNa-PufDFXl>-F7V%v(t1dAV~Y=RZ5oqy_^ze}1hCDdDgym;Y) zL?5W#H=k}^eu3o2mj5-~{p0pCO$ukCl=|vn9kqUaTX)Cp{m>7>9MR#&cwa!gE=Bt3@qlzoM{0`d$Bl9)HMhhhjynaDfx|m*GTibn3_vPXd73ziimS^5c z5fSIQB@}%7Ur}c3bhY3oh}@Qp@{(jKE0asw&)4^#mIgnWnQ1LpE-EMtg6&z5H^9Gt ze-8OS*({B@eA~9Ie}E%t`YsdPVcKhw)i6VLy^M*E%KMLq6#h3ymga>ja}^a4hZn#a zcJ|sKro{9qEDFR1Aps{4nhptDb zSwjl%I6fLBsYThco6<8mS#8oKEY~GEI_=yW6_7vZopmt2FMfC*koO1n&>cHYp*l!H zLK|-W(m?Sn-O`IT!SV5xZ%R%szK$DpaDc3izR(E2fxHublBNF}uL@OMtCD2Si(@1N zL&MZ)_4sq(3=hO7TvR85g&;IKm`_`6z2Cy zh90nGJDzH~S|5N53UgA;iJ*+m&b^_2OZRs6yT}gA_9t!B(ue`j-y#)9J{I0`p6k)D zX`X22866zNpoh-obzxysQ!a^NGo68s&dNj#rD)B~$=>eKPkHl(Wt$JHSTDlU;S=LG z-d#_tzw6N}$25MzAC(kJHPE!+u>^=@!QfJFD`tvY>rhZIPd~2hTr;o86E1S*r5C_P$86L1KIV(Qs8udwUPt zTK9;=0UZJ6_w>|ws|37XaMt<$->!dRz zqkZ)zLl45aI7CGq3m*)?YU$5ibmF^rH|n5UBo`7|p}Zln;oCQw2cTtz*(Y%mZrqSO zl#w1Xj;VXSy6AFADfvd;B##(-Y|<>U_4Mk*c)c<&Ht`MFK^ZeR!bwWupVJU)VxkK{ zSbYj#%$BJ!n)%rOz!zu6Ow|`fhH|i`W0NBH_HR zZ$^e2sdAE2SYjd)tsksoV;gvge9}GBPD4q}<8F1R`|A>os5NtLd4$RMNHFn#dj*i6)82!9^BMNxs&&x;wcV8-B=htn zAM*z0f4+_lfm4@J#C05Od+y@0<=KW20X1zfu#B3PSw9xC|+uxH4DGEBLhvc zG(Q!F(CR(>M!;6&qzM?dY$yq~?kLhBNU5pj=H!HS{uCa~=gF#yQJbk~4GVS{UhM({ zF}GV};R~bmE+D-j)1@sU;Xoj_T8P9I*}?l9ZX~lk8VgT&Inw>#?4{GuZSqo19W4#4 z7SV3MW@$;BLJJ9xA||bQp)uscby7F|>KN)ol(Z#JnfjL&e^y)9zAd|Z`lByc2wVMB zLa`$%I=2uC8XYxiMtjhzSViq(lvCC`06D;$xrbcy*2E{or;%!QqQOQH09x+Ps;Cjy zyMgQ0$q~_>k6PJDU=j6v4*PNE(d#V~H^$d4_QR1)L|{b5);%DUX|ZKaSX8#&dbMaH za;s=@B1mRbpXpdX;kjW2#p-9B{rx0`@e%S2YgCZH=ur5DLPSJF)@iE4Un@q6L{NzO z37<7lqnh zl~Z2nmOddWM-$Cgx`5k8y|IOm2qB4^D;eoV1b$7fre|mB{0S|-IBCV_&$StP8i3S> zBCPuE1dHhLR{_v{6dX*O{q{sG3;L*T2f zsM0+dY&F6*}&u+2ZygRlwI zOn(_^um>;If7^>Iaqq5OD-=M214T)Q+T5@3vi(G_m|5E-&P|d}m)}7sI?(o0|LWAW z!`UAzJv{E6eA+c2qJLn%$fLbr0|>nZY|e*Ihsm507tdV+yPy(i`$|VAJh$Bt;L&(SDKyNhTEKQ;|8NF2)2myWsW;s!r5I=m zE9mSx1uRk;i%0Arm-6}Z*8lY1Vuf7)jTJH*jPNWp(PPusf>LaYF_4iQMm800S*Qp% zJD-4OCv60MVA4K~mtKZ-(X|hEo>3&hsh0NS>Fj82C8~V5T7IagSi2DS{JAwF4<=$$ zja3O(aZD3H(C%%{iUqC(Sf_;)F;fs<$Uiy2%gaAc_5hOtfJ=yWJu0ENN;4+cAaTYF>6 z?8xsx%^{tKuC$;avx6*D;&p#hMmyY@we_CDBBJOF#a1guc0r=EB2cyAV^ zp@x;_%y^u*>EK(ueKLv22KSqHWk3DF1^5lDoB*3--u+v*?mt~S>B+O@%2#kykNOOM z{`~nuocUQy6o#&YN_>ivnimn1y)|ZQ$wI#@p%T9a6Mb!(wYBKkxXF8S_Zj4)P}G6d z%=be=&ek@TUA#uft|HaCa+!LG|m?EKEPv?pm65{MwL{0zX6Y_HR5k`~WN= z5Qc#D{Tlj&FR_J!;kVW^enx1{?`$pN&rpJs(=X2fh!5)4n%`NR|MxO}b)@!xFXMl0 zXUvnrSQ>Zy1_H~MIQ_;a?pr8wnjiQ*Dbgh9>X!CYMUhHGM*qgf$#F*bro~6dL|2e< z+WL%M-$LPB3|nJWHCIB{w~U$Lj@{R;U1O(sgzTYT-dmHjHg>5C5B)mZehO>L2$D%m zrup&s)V+0Tgg}EK!}bIS1Ng|_*{+jm#H?v`Q8b`U+JMb)6I0w6v=$PkQixh(-Rp&f z4l%M&^WWLe&efn)z^FOicEk@O<-==lW%a<9v)?%P{Xk7EM1&NQ;YW!y5wc&qgy&-* zd7|C)T{X+e5x*Oo;G=t*hK3CMk}ndIqPo zsQt83OvHJ7{%kCUBNz@FetpHTD-NFJ^q(Vwoz_T1KL3q(&oJ243OZE0qE>3^ez^A& zAd^h9%0sOm3H2T1`q@V>zMGu!@?s{q(!%^YjC`J?#GzI4w1X-X1A3e%M<*~g$RifL zoh5@gIZ0$s_#IslQE)43JBSN>BRh&v9*>TV8hni*2FUzGaN#An?b|ksIIYhXXtp%9 zuqY5GI?v9gSm5V!Zhsam#!-@&$1vb|w=uwUn2aEDJ0mTPd|tb@wicG!XaOhKgoL85 zc2CN>(Xuooneezk)a=9B?gsXuM)JM&Y>WsQtzAt&=jh;|sAcdiI`i6Y`s{t@lW15( zB-id*A8GAnf)*la+`jvaZ!3#!NVnRYfgvOhhT|8lY=d%W}%_i0TfNIyx9!3-BMk5VSNtJ5^~Or*F%UvP^r0g@MBeJyh_p27n@AYi zfuwhc#@F6D{u}j$BFXjZ^Qh@5XjUio8>+pwGD3a;0ZjRcckc*KquB@^4Cl zhtoXXqx~&C1sqM(ks~7`?QPacXav}}xIXzWINPnAFBWR*0MRzhU%587oU&*C{CnPLD@lA ze&V#V^D_g+xvIfpj^?8^Lp+(2>)65&fP&Wvpqxt^31oWZPeB_aF5QhF4>hLN;dSf% zC`-=QaJc@D--Nf{I0l()0b-(tQ+FcmF`bcM4^mg3Jbd+PHx>v`0(Oc85Y~RRD)d^j z@nBKG)s_%6?x9}Sy=icUlH4=jdkPvTeQYgK7V^#F_cdWhm;F@-xjX{VMuy+s)Vuib zg5H3I-RpH1myX!{F)-^`L=woCr?qPyiyCy|nBsU;OhrY7u+g_s{ zso!U^!BBW5vS+%L86YY6lzv1Kk#9^s`|=YBd_L~*4(2l+S_*Q09w#cTFRocM=ka8 zi4xuARc;0bM0e#&qdVTPNM`vj-$2l+x9d)aVvm5KenYaEgoIO#7ZdRRLw3E=5L7LW z(iwSz(o#~S*3N@W^2?+mhJD7pj~RBK@9F9a`G*It18cpzEFwf#1VZM>@X1pdx<=aZ z#*M2SsL0*s@82)dEiD2;M{LA-xHQsNY-g(WkK81 z*@&kXpZZQ8Y1Ek7F$D4R%ku1*Lx&os$7a6amE9O@{*B%s(q(xg+B6?N>V|TFAe-X% z66e8w%ts9_)qVUF$?Zayn*mH>c^R+S&Bc`rX-jxV^`wT@)z54G_EZs_jEnz8SlG=8 z0F_WyKlj>sW=HTLGl!)S8P1DkpgP&!#`V@M$(#3DLhz3WlSMgOxs4f#uzoP?#4#dl zcf>}*BPNFRo@@9s&Z^4`Gg4bkN{j zamR2~f~A8OE(Gh|n$-)t|2}2R)3Aj;HYO$}G?cx`|Is5Ief>N8VMo=~YkcbFQ|KcGZ ze1Dy!7=D88t=nnI$!(;6|Nj)VFf^qe42FDq^U|{@QqIutcyjP{hq*~S)eI+rE>!U5)P(XB#LYX~3|fL0I*+9ht4aZs#bqibdL z9=4>CS_1-B(f1YA2>2bol?*;_yA=5~O0B-KN94?zGqNZh@sY}^r&ojw{Ro~RCzFha z5296%KB=aRa&}U@@l0noLX+w!C+ZzR-_yxLrl@^d)~94 znn6+fjNdW;t(Ng*_Sf&<-QBkn1;&>#V&{~9TJzrMHTdP29AKV8vawav94slW-2aqw zUG}UVLzCh@l_U)NR%l{k89YDJOaPx78A#e7&v4hSi)V6?)MATLT_s^YZF$LML7LFd z8U$zh3PS+nug||BQ^?933W)!)<(RCX(6yq=l$4&Z!~>)}0nIplzE7I%NcD!jB`7nA z@ti0?&+H(7`QioP?c28vsYYq4+((%}URt?oT0{sSEUka>SO_sHGVNL-$v%!f4QO@r zSFh#-$rE(DIQ_9YVBv^PHO!eb6EK;tdw$zib(R|=8)`&jmp`3~OHQ^Kj}9PAPq0TU8Vqb36HG{$M_Gm2M#9xA3lDBWyW@9V}N&rf-k2xX-y`FRsLuN#{aw5kKZrS`JZ}Cp_O z&qRrK`)LJ$NGmuvI2@pwRzNz){{5FwU=lEI)~|UR z+FWBMBO?QzH%Qnx9N^`}t(qPk5kY>CxV42XyRK-4ux$`~O|18}ZuQGI^j@`=nb}0^ z>gr=BOFG@dPl(M#Yvn{qN2X9)%uW610hhHFr)kxL2W2yNnW&e^I$Z4tzSN$}U(d)` z9+;K=*=)t$(|koo=Qb_qi6|(J$jBIa)KZ0@F@wR=D6>e}r%#bM z=O4z(L-Pg+3|Jz#?L%}?_8rDpk(z2WH%IT_l?uXP>5pF?mwqN((r(|oXD@pSOuSwf zuO%ReiAdzxhSm=~3W^?on5^&H=OP_`I?<$h)#3li>mP5vwX8;2yInq{v!!A|{hZ&M zH+}CS859Ed>kJpt6WwF1T3Xm2hI)Cqdp9A=^atD8$s_GN!YV3AJCch3cqW2qx&|W% zok%vD5!WzovOoyp; zhq1Ztdi{Lv#p~pBbCr-(-x333%Q3-6MEak`GTS)M(|^3Ln)U(mrGVj)J{HyM50NNS z@N7y@jPfEg{oWPFlXXCXiNn?Y;Cx##Sifzt>3=Dr*=>i~ZX3n25;pLt*ClC)%fhk6 zeyo>9bNp!ver~(`G98}c8Gj?O4UAS#G{+e(ouE_vo+xiO>TeJN`vAQ&k7_zqB2t)b zEq)LLt>-1t=!N(_v}`gdxk7-zN#laDWxwHEtn(b@lkGvm3>&*>HHW|N%spx&)rUNF zM3Svo-oJ|*94GdMM2GN`J8pub9C36ahHyhlQuNRvcA=&1=fYP0^dNCo2|JTjt>bW~lE0qK^dUI6FZB8~UgGz|ahocqR41nmwpY0LPenzBa$!>fNkCqCY? zGV@2O^Xx)$xM-ibt95LHtK5ou=`H+8oVEM@_7RTQo>1|Q)-o7Wt>(kV| z(x|6z-txM|B|le z9Nsj)rDHr+8L?M2Ipp}GT^D9(Pm`hlzqyKr@a@IRsi}k6-JU#hqh0e`_gVL+yPSJt zs^1XFzLtfanThGP=Sv@PqBuHop464*ZvOC8*8EtR$eC2jIq}ri108)ye%xy4eBwE^ zdF1~1(3pBSfO`%d{ZeV2FHO5L$NtF2yu9|Nezi1LDkiV(92OejP+mVq&-qkzX6{9y z$@$mksEZ%%K7aAh6xqGUg2K^y@=s%sHnYBF9wsA1d4KW{z3DWJdBFNM?s!FuxZ{s( zg~i1NmBO%OwL6KBBRSt4a)S2bGsk?JW6r(Vx!rOzxBqEv%Gf#-3hPmDAsvUguL3g-2;Cq z()hZ48+2)B4v)8P=HcOK=&Fyfwz9G+c5!+5a4Ol|!|5R0S#Za(#T?7M3TyfL_r_7M z2*c%KcK?85UCwRFS4vS25*M}{x%VhB)>&!WAKwf$E&GRO*O~a54Vp7acBzvxX z2{am0x{BdK6iXBRb6menQpR3=`HLT#DuG-n4v=>7@a)`tNByjNNXntiF% znVFdzowtcP>YW@_*phx;8rE9(^!?qp?U4NNk8bGAop&zUBt9*~G$pNkEp0LQH^frcP+mz93gCK)Z1 z5YS7%*BR;L)5|1nqhHrIZtCQp+j`|&!s@lb_pT(lwO=ahy--+aVaQ*9|7lpV@_WPX zdXrPD#@PgwQp|PsK<4>mpVQ{IoZ7KIKD2*Z(2KjI#pkk4Uk@9@>ZPUNat82@tf`)6 ze#t~#(tyjKUp-lZ!!Xe~&pvB(+Wr3ePK^a&zbC1kzN4c+?N%668zCGbugz5O$w8wP zOW$*2e&dd<%1R8mT#K*%^hU+A4Qg7p*Z$xF(9`X~i*Jx7Q#kAO1q`{fd0en|QaC&R ziktldD)bfaXn)w)+P2Cxi)F;e$E&O&d-0;A;E18&Xc>#h&+3U2r&K&E2U~OB8#SIz zGR}b0R@>IA(+RgJ8I__=Z#P(wxU*%qfyP3ltmY~GC&3z|Pf^)Q-4G!iD0^HRDz)X$ zumAI|ki75{{&q*Cy*4xXc%p4{o@@ni#*bgWDmkJtv!_xXibf^)hLvPo5QL_KYLg&A zInDTHY%EVc+cEiOCVJ8J6ax%&jEp|^XPN`v*$i!k+nIATm~@Psa!(%%nDm3FgH-Dv zr|E8QiR*_QB%e33dV3;%-CKesMk9-L!#6&&sw>&8rU@n!Rd2O&Q!@s)9=Yf5U;XkL zVW0l!W2BPyTOwHlGJ>E(w)+np=*5(yf8%citWCw0L`^bvv|7@K>S{*MKQCA9 zjn<1t09BYFaRnULl0IuDFa0)hmy8)b-Qlym$3^H!lo-Oc(cv#suTyW40qI`zNen&< z9k-bsXGY7)%8Z%T-g~g0jWI6nvxs%C%?l?G?5+t?vxymk!-cwAB}#MJHC5uo=Q!!PQ)oZJT|uSWhS4_P}`BOug(@X1m6DR*(LVyPfkx?n!P_d`i%Fp z)b&AiIv6-7SI^}!X3h>%YQk>&rUuiEyjIhbfzxGA4zkg(&K_@e;<2}}`Tj%0X#S)4 z^~H1YsYu2_+b`H>heSn_jG7hWJ4M+X6U@GRTpjF?nszDg&Uy)uN&~-r^?jS`9Sd@`K62DhqcgVZ{1UY1RT*;_JZ7rNNV&OJ}`B1e^0@=$VKJ=n2&AqRI!WkB)kGeTC06md~9X(088dA!t^0 z@gj>s8JHrj`M1u_-yX-AKqWBY&>$=fg7d&WOwbtF+W#OCu8>R`SOvvoP1gmM0A_UtZ6Bab-fXW%p^DSa)D2#P|vpkyZ1f z?LHhbACHXo->s~&ez`|IJ@R6ret>%J1&3w@l5<=P>PeCR>)d~HdPXwAb_Vo2VyPp!PnqsazJQBn_eSRVm# zNxj3cyX;s{eNy=ejG8dcWIf{hms?~{RFpxJgLZUMlC?}{rg=w^R$+No-K>Z6ilq}G ztGLzlfI%JE(jqbA)fOG$Q}%t*`Jwn884G z>C{w~@wRbeU%`Xr|BF%e7wj(^<%!w zKto*n{pqpFFW*`ZXyqh-eSPlin~T>pzLBV=^IDxmk6)@Q^1$NZ)=&Sfua!+J{rs8ZeB{dP)iz+)X89I!3(c8V|Pk8sYf_VV%^_`3T>^CWr;lsm6q z;qE%hIy9&GdEK2oe?1^%e2#-a^32DlJjg3U5R?7Ii|D@DP=?)+!8GHh^dTGH0+-fU zADixQvE;{m_UFupHwTtlZTrE+eJ)yA%=U}4=0N6LQ&W>NvXg`zY7CZ71VJQZnl*f) z%SN!o+}zyM@75IS7k2?`F`qp7Gg15Z+6562r{r_4PQ<85xl*kwmd;^);9a29aT)KU;mh?)eAl{`i}I>%aeVhz45s1lMI`Nb3A!gh|iiD ze|M)7Fm8H$z|8zv>NVay%mRk8C%wp*`c;bv)SDjkoQCzOE3bTuzVIcDXaeJ134;Vi z$G2-A`yNUn&gO7S>@>-G=I6I2efnp`Jn1Tcs-ltFNBc)F8kTso)L-9u=B1V0_=P*Y zL>^FY1&zC>JO%B*ZJoM=C{HnEiV_?@h3rAf_{uHY{bp?vtV_Wf;VSgA?3zSFFFW-}boW(Xq_=wMQ zi5YL(rb~^kxKnk9f>Sp6$ux40d>TqB_P$ylMUazzfqc9*({+Kr+#!vRiQ5ca)8Xta`5` z8S|VBV53yb`+&qd5{S6`l>jjMQzN7z0^On@Bgyg zdXZ>Q`7WNeuPG5M&J)T|`?9PcWg8mn6W83r-C2HuND9kZm^0afMPdB;9mG$ccUt&P zu+;=RcCFoj8WQfMKPSw$`Oy-Co}a|LazV|~6YE1k-4n0`>9E?ge1JC1vhN$Z@Sn+M zh?5CFu>mGV-8e}OhaZ0=e9i8?K@#JkLx;Ycu7)VD1324C{4K~n#zNMgTP4Zxn7n+J zX)EI%6cz((H`cuGgXv5mll?gMVv=$la!V3>D6e0?PTck_!V4oG- z4OT|9_lKLSbT9WtDaV~|i&SK1SK}%fc^2GP!M<y>ZZ5T0i% zx3t?Zso8oXfKLyn2Vs7G9?lQZuqD8v=i5K76s^3|tSa)}J?_~U;KVexI;QICLBRX7 zC2od2pT_jm$mn8SQ$~QY{@2vlQ}z5vP7$*lY$4X_z@N{q)c+REw7!aWJW-2b_c<~e z7U9vN7K!SZ4sF|^y#Cc59thL`n&^V^(o|MfS-ISe)o!DJT+pEu%fdDs8jb0;^pOB) zBIL@g`o?cy)m{Ag1e7D9N4bleTY*LSHJa`(Iz4`SVI#rFJ$oZuEo~f&ss6p=uI<}} zw9A8_hTU)?5b`4{NA`XD27z#|9x{V~X{Gdwk&*I(0!~=c_t(mmt0tSa!rwPA=s-L1 zLMAf9*kh^6ii<}^M>h*zF;!A>rfTn}Bcf1R4~>Xm|Nr+a@5C(TLxI-hO4&LZ=t;T8Bdd`8a5u2qxK4PE%2xqw)%i(hZWv^dPqCvc~fkL+PW(vFgltV%%#;vVUf?M;h>miWn^Mv za;F6qA#l!#W@lnYzrcu}I}X)gvTb`D@lFVJyUyk$=A&@c@aZ!57q|VsB7Wi{Sudl+FtPaStru7XBNLX8$#ulP5I=q2os<9f=>G|H|9_AE zUt`%gHva#$>J?Xf-z@Z;tEFc~7HBrF*MsA~v8Ef0;8j3N*+-Lbwce_;sgU-3`op7aj+U+Dp1aS!x~26{^Eb|@c4NxbPED=JnGSicz^&EXxc!$0 z3wRmHuQR7Q15NGAb&Ah}J;t2NHS`-NQodTE_RKi+$NaXlW>oFYq`&&jhnua@&;&b8 zM?p?9oAn4*@fnHzZiXlxyf8we))2Ix50&vsF6@b)xOn| zI{p^_{FwCo{6v=a#_)%~dY$dO!Po3)J?}rV{sM}B)P>m?NdYn#D_}Enh(6|v;p*(M zfs?i~$h|roEH+msHn#qV1&ZapD*VpLc3)u- zTI=12cGZWbw%;Ba92^`TeWe;+gqzn|US9r=ZozmT=A0|$r^-2d$4%!cA!vRCje;9n zOj${Z?B;{Q2M&0NyirZLH1qz=VNHdC!9n#|4H4)0*}8&aB0dCJ|Mh*|DCNT zdYo80LRx<0*4CQ90MujT z(CQFV+};{a9d~wizH`jU$!Uc12}z=UW0GTmoL8GE&`nbE@nAtGhr$PWaGLxWC3$-d zh+i21VBz89axt-g#JOal+q*mgvuWTz$!1t4KY|>I?L6vYqxO6sR+~YIJ6}=P?>M<} zVk%243!IogMuXo?1*gXxyU}A_}AB2O-&bE zN4&i}O=_R(bnH4?-KFYfHjvd_m7MwkO0Y?tIqPy2s|(sXp&htMQlI8R~HD@ zukSC>Gfdc94F2A}SIz*?o;z>P|_tz0?X<}-kFLa|@$=)^?Cy|q6mLI)4(AK{@_>QTwyc(x>!dtc4UEf7jI1GiN{zki++c3XslcQ|lPyxSOfVe) ze0~R2Ha9pR>Gsv!OVFruJ`O{;L;~sm2@68vTbnnKdn!m**M4Ma$av@Z>LfRSEZn?i zqa_o%4$lHbE=j9O4>Zl@g8&a~zYQZ7t%k*(g!dQfwQ!2*37_7&aFqzX;JhRL_gWwg zBdK+>0NQ6N>^$$_fA2?xHh(N=lT2PK*f8!s7Zalxw#xYnM2c?d z`ze&)JA`LtiRUk@f&^%jP}{X-euFh2r*W)D-Sj{*bTOG2@PGuATnU1zy`{4jFr6fX z37l{7^UYbe=i*pDjkBoL78~Zsm{DVdCtvH~wWgMJ$ zUO@KGTmgBl(`TyFr}C9Ua2UKk=M0}@(ZyMVtgQbIA93%>`MC=to#7?HSs^$P*1x7? za&CK0^4X2O6QAj|AU-(V3<19FIx$Pb3UTf4?$s)Z`eP2J z6bm|7vf~R!IhI$UxH(LXv|{tphdL+i`%}mxwx8JG?A&=$vW=_1>b3tIy4(2QePBzQ z$iBbouTRUt&-YB4TpuJ3q<C_S?2D!H`8k)z%mYofj{(cKja`wja3MhL?N^D97JzM7s&}Qjap4j zotuH-BrI)Td|DzwB`@)j7$IspE*GR7Uki#rt?Ur{P2SG-`P&{vKX~b4R>JB zl|m%O;953~1LCu~y&!Lq$n(z#F8``2`S+xj=dUn|#TuBkeU*B(vVdWi5>##$b;N{NXY*{zdQol(y1#!B6s$+ zl1JCvX{_J3y_n>Hvi9MPN;c_4GaC!NCsx#-cS{~*zK{mn_jV})5MOk|zre>8*$)27 z>$9)D?NI`049?Hmj+}u2s^RK&r6Q^1CJ>k>)21o^$8x|n{es0XiNE!dm<&%SB*yxL^Gx6`Fw{6+dQffvI z#Io?27$*D-#s0*44ip)%xf~{2>(o-M?z(qDmuO3b%_y6K#ZAl&R199FcqB{zzA@<|->=5YWnUX0e`<(DgZecf5Di5;q66g6V)e%&Y06zN-M2{}D zv(oPJfel60yYhn;UbuUDQ0Chzxv8%XJbQPPSMBc|F$+&I-8;&cbx~` zs@9V^LtHI5JFia-@YoC&Zcv6aV8fJoGm!D+(Xb|tFnA_`V@l$;S3_tQ?>q|D)oXqV zigv3xwO4$&S@|-<0?%m=SW;jjrdoDCKxZ?DvKr1jRHJTG3f$-yOd-t@-B!%O0W%>EamX7OeKYyqe`fjj>d$Wa;B| zZ!_oA^Sd9NU)5Kek%j>XcqJe6UU<--i&0fXWpu>Tza&@y9=l>GhEqkj;#>1WZ<5c9 z^^hh|Q4EebBGCE#Zly>ZNT3z63Ypi`*V|)~$sfq+cV3+-0kCFE%RLX@9oqP;<2~p0 zg4*;P2c__VO+-5{{8A#TR&H3|Kt;9Y`0*##JwZmn-Tey7_s*l;Jzq!ixZW){pQe+8 ztpR*ZD}}8bgwxOSs5XF@?2OadtS+IuJ^4Pz+umYf1rT{rN}`PF!y7<;MNRmL^Lv(A z-kqh+Sw}qml(8lpWCuqexWmfv1u@hj0&C>d(|uxdzG_WPO|vmLeE8pxx+sPf+;Vl* zN8KZi2=$mJ6dB7Yw4-Lm6Pq=Az0ydq61EA@ZKH(=>qVKAf1c?4W_TDnA%6(fO zerTl?kq`t6m!N=vbfbVusemX_ihv*>-61JTCvyunE}t!|X#mQB^{M5xmpSf9uIf7s)NMg+>wd z@GwGu(){WI6R-uze=v82GEH4(GH97k-IF$%odBBa>l%mt{{EPLH0uWjIFRIVkYgQz z{OB#G)m}aW6dP1SdB9!XN%$HWc?^mQG|dmht{CQPwCyW9xRl~5^3CQ7R&kr(%4;l@ zNNSH%wSw^Oi}~i-{D+3w;x=O;%n5P1Y3UvuEI@4D+{W`}RZegPD&v2#gnp-}-c-?$ zbc5YTpvzP@zpzm1SLkG~udm^?1WzFWuZAkK@`0WA&^S za0Lc``)t{8QRBf<0w^nhl1Cwm(tZ+h1}?w{bFdeop2hK!t~h^Tx#Avlg{c%wgsWvmZ-1>OG|6{sp@`m&F z_c8LB7~HpVVO|~#JFtdNNvQs?$RwzLyc?NpK=BTlSc3yE&l68^$0j-pDKp~hIyPfvnj5pF08Ed z<(Y~p{51{y=uvyIu7oR34xZUr$toJ`17`K@J8=)eK5!LGgX1BufShTC{)73*q_p3m zVKhzlCD=A|>(wowP{rnhrJnI!nS|0`KCezvKfK%gHeguV9}(@%fJ{w?5BK}>??LnN z5DfA}P{nxvTQpBv{+By2t_(PLFU@k|-)Tg=$q%Dlk#}*LNXYu6H<{a86S3nAkKkjH zMntC0)_S{)?|sl^DfDVN4np5Q-Z4LMuQ}*JW5#6^sM~NcOGNuX;?GpyEG%>JPUY90 z>jm~!+CbUWuXh%^x6lo{unbV1;Dd^yI6uf=@HPkuGIxO20arS3jPN51x7Viz#$wcS zCd+{CGA{#Y$A8HHyqe*-t&84r1_B3^VP5dt*v>>d;>yY~Ft(+i{9DT2X*JY#-o@sJ zAPa$V|KCu2e^Q3HHq&TDjyG;y(4OtF!-0UBKhvb;nOvq}(O%giB4woa8v)56Oku%! z7TAbK6#$>CY`E@?>@pA!{-jjloW%@Teu*b@-D>Y%aML~T)QP{Mx|)P#o`$?9NLk>y+_ee1YWZKiAf5Og8m*Wv=&Ox0|_1{Urh?0X&<@}$Y#-uPCD zt%_(rv;JHL{h#9F-zYx*M=jfLsXPXD4}K`m0GtkJ2H&sNWTQQtcSao`$Ef%-xFph? zwsiq?xn8*W6wm4VbIRkA@?^VY&aLA|WBci4(QOf2dAO2;F(*jf-V? zo0(1uT>}{)K99*}0GO-{f&zmIngS8K1ziJ!j%G!%-m`yD?owr+LD_mXp$tlevQm3U zJR##}@L!pUrsut{mPMoa`e$X&mneV)&qBsG1owdCRb*?anb940R|U{N@@FB{~tNhh0VJ9Kb~BAG~6gb2B^o6bdh2rSxw-EMn4OkRf}6>Z@t$QLB<{ zx=JTcqQprccY_|k! zHb}>~7JmVdvV$z^tQ$RfHm14{P}7}_woT6>BkQkTOG-{smN*ts6)t^Vj^G0ucOF+#+_+*OD4Dz+|efMhZ%{rtJ`KkZNixgE&WEBBa);bYiVKOeMMS&y(-}P5;*n( zzXMZ1v=tc~L$TTh^;_4M0r=<3Q%TaZZ2>ca=QV&YYT!HaAm9Kff% z3?&)`W8KGeBXIMby$dm5cBd6%m0pt10=8)_cEVKv^m_RCrLw7@-Eazw-u_(f6I3eg zVqk2napU{Tc6C!+VBxF0a|7dAd#C!t>^rhKGxvm6cu^JQ*JOM{C%B zU)Urd0m(Mbw~vQ)T5TL6(D7VALL!wQ&lkCQOKfnVE9GdkNgf; ztm(uP8l10U&P{D?2c=IcFvL)b9u~LvYWp8;e-7*eI1Vpg$%ztp)KO7due-aur2<1E zgzOg1BY9luP!AEqo|x+_BY8Zs~3C*5NLdl(H0zO1%26@pbX}^W`na1O!&d$!{97_`ZtMgP6E@ zX!RlczKX~S5OtsuX+ zi%#p>UH8N&CW!DInjMT)Jy~21n#969%S!BVpp@!=ScJ=X@&F=n3$~JhG74{wLCowucuqW3RuvszZj0F6>6@ntH2c%NNnmKA z7RVwrI=HT8&|EhW7 zR`4Z176O)|N8cWA zxHu|b2={f$_eRvBo{o=>lE<~@7T{`6etLBF&X>~jT6bf>Kbydh)c^5guX2m06);H# zU!wy>m&oGsdwPI)fcv#U50V$f!PO^@?^Z6}3jsFsmIS3er9Vu@hA~EMh7g;J^*vYW z$7CuRjAMR$IF5exU^2G!UCqshneC^Uo0uSA785gt)((M-6$J03NKL-eMrO96swi~ZHglq$?o0@(Ux$M1K0#N z5+Yt7Ez+7u1^jceIPj0~JJf_6KjG4q+TV@9&5*RYb|;w^uULjjo{mpccnqZz@DOkQ z^~Anrb8~V$wH&TGBb0VaC(uZHdi!uFsTrvb@azx##owdTcZj_%fJtm+aWRI^1;@2E zf|tPC15r!X3=Urp%gC^rZy(dS4YYlxR5fyDzPU9Z$P)pBwSV1@mR!5$#YZUl!~-3s zJ6NqYS4Tz=QJ*KPOG~9%U{dk*)4OZPbVnFEhov;()6xQ`784Rv{@KCaUIK07f7sNL z2-PTa?Ta6U_ue-~bB`Yr@35ru9x+=Un9@ zGCPF$9W`zxO?T52|JBDAr`$e)HL?7)3StBzoTR+-D{2t9&uu6uTHd~YZ`dHd3ggC4 zru{ngeNOV>JP*sYIrGJ8#^5bq|KmW8-S^svEZ1)pOfC!y(bvIH7a#@j3k9?>+G4H2 z)u!*9uyZ7cYKp;Ho_t2ACXyOmQ7!VC$UX@O!21A>TCshioDh4XXxVZf862cyk>B1U ze&NDr2X_&$y8{t1b3FhS08TdY^-o$2mhx%Q&{XTD0XrS6!)hankYYG4w(DH8mhGLu ze<`Z3IkY4M!YP)vQTr&PHNPc=p|uKu>MA_?SPf_rtNn5-a&BoW%>wta$x5}EaQof2L`Xl zHaC;QdA={ul7%?`-~v>~!IccCsScPygDnl%8gV*$^h3V1j^N zqS3*#4fXX*#jkw^AsiYpH}@Cq&phJ`_g3EJM1rT`xr51?1S&vDdCoI7_8T$*}5m{A=MR}2CZe!PM2 zW8L-}Ydvctp>QM>>};df*7y+x1qD^rw#y;xKuI8RWmXx0_B1&;*~!UUBhR_E?9R)W z7%}`oElI2y^siiewwLm(?^)%h+vV6%Q?D|A%nZrN$?LY65j1h+mwTPm&LC_%kT+N8 z{#re&eLXu@A&g69@!rBjs=`!Vv}bu^BieLi$@>m-=hKk)s;Rg25c3?zwxqAF#S|@x zL(NTBwd~&&6cz1!SnW4$eSfYd+j4%$i|igSp6oZ*&LW<#a=g90V`7TnWY8N;0g}@W z;HXGa@?BUGjC2gQO-)@OF({!k9r_f!fua}}=h;X*K#e+{hU6Nm2=9BRERlXxU;W07 z6DLnH3Is0pzPbD~A6^7UYRN+;N93Yq%QQswAszX5)!|q_($Wd`y*rM>UrgB@EoP@u z=ZT0tOTT;>1+s$EjMZ4Qh&{RO7^A1;!>;?Xmm%Q>Dr*GNENRYYb^& zp1ufgT*zvY$4nB;=)MzQSnLq6fcf2gJj`GD?3&8qe1NK+$FZ~=to|6`CJ0q^SopSA z7S`C{%(khwx1un_7k<2>by(QeH4LYtv(wI&)c1v`RICyLRxi^4^Syu1dW7z5DF+Mh zN@8kZIHhPG1nhKIoa98glQU|1p*>@}@+TIzHdf(or$tXF3-Spm99*(9GBS9NZ9!@b z90Ed!kXa+b}2xQ#C!m&1`RZlO39! zo!y2b_{Devyf<9tS4X70rDZB^-Z)1$Jz@uk0m!9vf&~Y`tJw3~=64IwhUZ(1DL_wJ zc2bT($eIC)HK|`;vmb;(WwQlK|C@Zo%Iq+h(HS9HE?ZV3?nF+vG<^2#xWf9e{}4G30RO= zt2m@om|$&zc}&n(SsZV94QBu*J7*ait>uM@*22Gx%^Gh|>xKNcm)_kc%@WrkY7elK zTx^VPLpJ(D_;yipmkDEB8(a7=IWP3soR`zs7+uLb(3NdW)oM8`PcCciEcd7D)nz+v zw82OSofM+~>(?o%gaMC23_Gw9q-5b-*y;E3iz!;4OhjjUU~_!;_+c!m63EVS*I-J0 zNvC7b$&<#$Vt$kaVv=QGy200Mhq|@373wJak>KmvB~Xez05?F8V@Ocav;X=v zAkDZ5`V2moJRiaIv@|fNBSf?OISM;+Z0cuc+1X*}5Z!c=O^p3i4#Lc1X$h_mN_<7z z>xrrnv9+?P2?_ibnUrpKH*&MHy^K&q^5JTgBl6UbM~%Ba-D`YBF!?q=-?26v9|4n~ zo=5=;bWsEp49EG;{#zR>%SJPnz{TH9;G0f(Bdx_~(X?G1Hx$kSMFJhla0 zE%{5(N~9L7*hA^scZlm-n11v_yTRcK@FB$w1i+qRc}1e&{kwNQzL8dg5j&ep&58)2 zojnBF4^ya~*2)CsGE!l_2-1fE7j4J{pg7ErirI-IVh*arJR?s}uW`#~(*)BUJAXRnFux|zP$j3#ZrpCrw&}!gp^`|6cV`mt)^maKp zFg3KawpNhu{sXM*d06Dbp`w8-`MSt69w-+Hz?#hNR3NtVpK01tE`uEX8lcLEvZ`wI z_er*7-eY{Lw65SREmP-DFW7P@L%?q6yzLr)Flz!lHvJEQkQrB~qN1{_ zvSPP1-pH(&3dTm85>{5r&jVP%u)SXE!-MiYV#0pm;o*Sk0`6Q~4q)!0xdl2@WnMto z5AqRVG!bJr8fM&Wo!?R@vV9hirNa$7GmjrTU{^=(-m3(fMb09;)+R&Y9&^>zV8;ly zrYIt4s3Eu=K=FsnYRK>GO5a0#dN1ZSG~J2HJW>N}ZrnJ9Xy|;r#qQk*=b@96*I|C! z4tT}l+OGXTqQU~iigyOxzJuDnC(~&R@GS56rOK)RKI8RUu}YBw>U#!v+yKS_wxA1w z9Ug2CfJh2m5WDP%x}s2fgIHWVPO4nLUL;my1Lg`;C*=trY}z`vOm{*i4H&h27Avl{ z7*G`3;`!Rl#?F2?0}y^nVXpD-na1tOm%lUv&-H6+QJ>N~H|?YBvqANICSbu1usn)q zWv-v*5LHlk$jX;PA}9(HQdAzW8Zh&Wm*nstvsljRI9-~&%u%3xbvt~0uQCbd7DE#!l2jq?=CNcf`h31Bhu<&_dK zQ)Sr)SFXfjp4dRDu;bc;FTiCx$Zpd7mduyeczqMRF?@ZZ+)w&3yaUoNIIQe()5iIY zd)Mm0bVn$3*6h*WriL|CRf)x~tDO$5))|@_8uE`4gmh4PaW#WS3h@>ytmn|DE#!aP zxG`arTHs%F;_TTYcMGKdvC04$dt+p}yU1!9^mI?FaZlr?`hk3U|M)IJq)&d4ji zq6Q3=jN9Y}XJ^S5_ft__Z8O5&2~Rl}L4ik2Ot7u2qC$;$O5!ZOfB*gfF@cA@3cOLv z8M5NO5{blG4?4Kc!5C_LqJjy>!^1b6THuh2l8Op}c&ySu4ECi6{@8c#-{Zbi`a?+{ zXz$H$opm{B|7r?;1)w0w*y4Wkm71`*RL8j~p(MaK*RH|gmGbT#geyIzB_$lC4@)|= z&HSgw_v1SeF1}Apgpe};F&iPpI6xyDSHo>me~u%6wwzGYC?zi#YBn?y54J&HoPK9#^|U(Z0KP-?$4G zfGwlW5D?QUFHS8im?tMC0hrgD6n5*~w2+Boc0qwijRQb3llrHo+Kmhi4H13;fs8o- zbufJZo!m@{c5jO~t;NYn`1FM024)-U#Da?W1=OrxcHca~nvSrRN!?oEt%v?c-p z>57K&cyD|?#2JBY3?9|Lf33pz=K4f{h>nJr00Rf0$?5xuKj78`MBZvQZs4G?rhoOt zAXG}^Hwx*0MWOgoUhdDx{Wk2?4GYg9boB-&#mcOZHViT<;dcARHw3uk96)9#*c|wL zodJVuxKe_)gz8Kid0VUQuKW-d>e-JLqHE#=+&}jE1--V}Mx8it!6l~x7t^ev;o$T5 zl~Dgc`twnVSyNa^}juf-FcSKvHhy?BCCztf7&vGdu<>*1o`bu=Klw^_=P- z;re=avy9rwivcNZnOr*)!H1qs5Ro57-x6|Yz)(x;IuTLD@~IfGv`SyQ_S1T^1U@FL z{K?61vO{87Sy}B<%Oo^){pk)_l8wULYG3)S^Vu9buFhJO_2k5PHmix(gu{=##O$0$V!>~nBj{rqbCoQUol8|!=m z58-5WUWliui)K6nW%HBAP<5hU_C-YKOev(#?g~Pg(b2=OX@JW>#HstWK@&{fY;(%0 zq03<2vvc^@Yq&4{BR}1w(wOTLa)&M_swT%@kb`NMkn84VJ{&U03sEQOj&TYdo_kFm zo1lY=%G13&=j8+ZsQdke$uOWgB-Z~t&3Oy@o31n~2lxfr(zkC*R@ut~c0Du0*wfPs z__?~eI+Rj2AY6kqD%>9vQ=m|M8ym56*f_0`$q)z&dv$8ckdyX{{~@uvRm!xG9cQ$* zQD)M+UfXWdF?8bckrwaNCr^yB-=?LRORm`>=%%c)=?!ONuF8}`6i|r3LCDI%206ah z$EeS#ovauRz=g$y`~s&Cc6IVf*g6}_R_AC*?|}CcI)MpF;5cal7mZu@jn4?FJh&OF zR9p^7voMjJL7U6y+S^;TIei)VoU5L{ zTf6oXyF%`GvU)^hq^_}X@^p7Q44$&GDE4U-IoI}^mczhhec3_i)c0$&#y#0bL}#gx z?-hz&U0tPrjG+d>d9p?qp^-@v z%`HcRAw(1-pI~3^$FOsh+1L`BwW5r{f$E=_A|<$#0BHlz{6D4$X>@0D-0v>z1qk0a zzrfp3OLG>>>hRU8iv+P12yQSdYnLYkK}8Bt2OGEFtiZft#9W}}GUf{X2$7Nbcc-AX zBmcp3_>i716lnngOgOftAKEFzZY^U6>%Lz3V^$z$IwDm7LK7S+cwI%-GvRPU?UP8L zkm_56M`cFV4&y@_1WtS7u1y-b?A%;-wd_68ut+E8rEO#(s9<(x7;m7UL=%i0TI=gw z`ZftT=@+8gVQAn@x(tdG0^jY$n8o)LxHzZPJ{YV$+J~lm&A=mHoe>j1zsB~{LAKPV zoeCG$&S?NZ2$4uvr^oNGRX_~B{ zhF1yYN}QeyF7P)%L_!z{o2b@5l0bXsp%h2K(*FPWI{85*TU#?bsTe&zJCtU(s7eb~ zCZGkwgX+1ms*j9nQe__OLC>gXp5}KVw0ipD#nUv+I81k59t6kxIE=55Oi<)cPm^l5 zvm0Bh!o0N;juZE1{f`D|IGlwZ47^-ZG2FA0|8ql-h~0o0_cWrDdrW+*cwF*~lYbUt;pT4}JOy`W#W9 zeqr(tJ9w5+8e0M#Bvv{2gA0JEaxUS554!UASWWNMu&D(tcsoDK;FJdTUyYCI=dRniIba*UA zeL)OtiLG?x60U!afAc2uerMXi5?zY~=7RCV_P>gPw%R*MH@I<5-^w1}8a#%24HwB= zZ~93#p+)F~3EfMuL_t)2VnTva?h2tcmZF>wV@A=2GR8o^7*hz}JsEAev%OW|u%dfc zUo+RXQJWKTB7t7Yd1aS^E2{aua-d{R0(|a5x!=kFJ2(}r@DuR<+#M#=!uD95?FNWa}FQ1qBCF zp)(4dO~w21igC6!(Dx*k_{~X7Le@B8i9vpFsi6O|TpGUuSvDL^840z3dx;)9wpAS` zgJHW|*Ruu|1-in)teF4w>%=kw%^p0cX_$3utO?@=5qm?9MQGA=FK4VKbxcS|7o_&N zHR~%8!Sw&s)H!0$p_)!f;fY-uFsFs;w}dOPoVj+3dawl`BN_r`iT9BDMxIOm2N(Rm zz0+Op+lS0dQM0s{P@Vkk-!Be=%q0%TMR~L&{H`9=K3Cu`fSE&vqLKG;LWSV1{3E=0}g-A@H4`W)*NdeJ$ifcStNr45m7QPl{DBO z@LQrl7OVmE*)o6-9B(yolws%H8kIv;uuGq7W@;3`~Uo^jpRPF^xbud=;l3 zs#z%PQX&Z=5CjWV%F1Ysm`6vNsJ>c87U6=vw0R#$U zL7UmY;DSReSQZnUVmBVFlTI@K32}RLGB`x@@aPmC^GJG2U%>`~?fxsPjZjsJL)r)a zEbI8^t?XM>b&0|TCM*s}OCnWoZ|{+d80g@y{&I29i%yUvRPcM`Z4B`Ddq*@ImYnbVFA4L%OWXf|{09Js|E}2p zE*?;e!RcyvR%AnaSF-^pDO^ua1pf?V4PDf7wzHgk9sp>fPY?mn=;RzKgZs|Ywo?Boe)NYw543uZYwIJRZvR*RcyUbApKm$sqxX8dzI{861+!V8Vb68!yox|o4Z*b!bwhdYfB^^M zKQh|g*;(@A`dvFJQdT)Z{rl%LcIWB>Vh*)I!D3yWk5OCc9~^u(3*UVHGbePwYQw?; z*S{BJgq*&C4iVCiwi{J0xz71fds{e}R|=y`lKQ6;8k~w|dOqG!Hs}Cs6Ztz*zK09C z*8%w%@&UvCzY+l>;+k*)JXb&YMABq^Kev7wwGY=B9LK%%0iENG)7;7A7aE1%XF|u@KB$9v59x zRn=>q!9x~D3GD3cB+6X3tpN~)j9Qo`CUBa$UDwll>z53gFa{oc!u9y$CvB!%PMtLq zJ1*tTFKml~oKRU^WggZ@0Vn%)OEJWOYSm`4Wp7|pQ)q8;F3t;Xo4yJrMOWsQ-BV!_ zLrb_qcU#W@tK^!*D!Gg?N-jxx42f;$d0g25kojf)d234RRK~U7UN3W&Zw)VY#tE5e?QVM`HU-!FFHENe0&^Ygq=wTS|)fPpm`Ih z_^K7gzR6le+n?vS!12PH7rt&O9OOSuRday+rJ36Hp8N(AOO(6K;P*xVcwe@6+9TNq z*3~MEA1huG931DzPlcKI#=_mpIN7=WPt-n8n%-Xf5W70JBW!>g;3!nXyLhuJ?4ENW z!lJOQ+m_Ucys)eApGg$ex^eSnSA2j~&)c=vuc`d~rCw^-B&NVGPe~a*dhj&<2dnCX ziX0q>)_IxF6{bzCt+lz~cx3&K>C5Sg*AadvmI4@dJl#Z<$+v%G!a=P>Pcu>Oshqe5 z=<2b#(Gi?AN0o04v1KS5ViFQ#<8=g`unB6$*pie~c~~s`d>3qO@maIks3D{n`+dB< zkR3YUVY9q_3#4GL^RcuxTN`r_d1yJ_eGEvHcxbE=pP;t7(4M+Dvn8zeo;{Rzt(w8HWRGqFEdFnU0jZ+!(Z z(tZpjHOQ;D>lD@x#P4e6+ny~q`v9r2&2MM2yaUh?#er#QX=mf2p!rBlO?6q9yXj6y zb|lATXZ!2EGQheZmW97gz7e99zP+Zxn4-0gr@VnlW zeoP9Yt>121QhEWbH4eL01VAL$_k7#=+jnj`0)_R+sne$!&N>=MNZ`0a9C-MP7m>nY z>pH1@u#{ZRv0Y{fTAne2L~aK3H-@rRE@qTu0Q{*gUlbvTU7zkNFhY0O;k@U_BhMvD z5v2nb6%tyszFe6KwnqF9P{kapb5oO5k&#h)H81Yn?;)j!7bQc=1lBQ#Hl%g4u&|s| zeCynixVk*muT@(G3NWXQF34+>Ij#1n{ax$i5r22^2V0$%=i$o|4+dI$jk9U% zbC>1tDVd6L02qJzJTx?b_Uv@%#wt#BwlDA5vpJx{NxXh{xaSKIVGVx6s|(fO3y|%5 z7)Y)Z1~%W#M?C@x5Z}X#jYFR=D-8~o5tVt9IYDX_xN;TtrBMgMqaih8NP;NTPxm%v z29E*q=KdNcoizqy09;Q_O~r@?wY`*(LOve44b%vdmv)N>73%5~4~x}RRvzXajr;ml z1v!2Cw56pbgbB12IuRkWmo6wM_@|_#JgFWhqG00Z=g-accW2Ju9kl$?31@21UszsK zb6H;@=G19NLZ6hB`(UZXSX=W}Zuy~Cw%DjiSIS52I`_aunmNJ`qcj2Mie3A*|jaQyQ(pxhyufph30SY1{l-~}` z$+25KEHXVq1V;RM2{j<)aT~2yd8dr@8TAPZpMJIDiW5OK6!+?=kL)|k7$MU_e}D3A z7+HH}nQVP9-cV5P9Q9Z$lOgXfv?2*i>CNq2&WM;CCK>3-v5;5T%pm4G4YqMl)oxmU%={Q8&@5&xRpa@DhKobPt-Pn_cE<;uAklf}?+bTjA2a}X zhC|u-^-7$ZyOfpXBpDMg57@;4-RVkWB08l)*4#WTUUBi-J7owf5-oHFjO-zEz6!SN z{-x!2t{yn;7UpRq_V!Lm#*kQya|;H_*$H2}zIZ)Cu>eQo0T=+6mX^X9vohY84ik|C zxr-MoA*3Ybx?)97&nFU)$uvd7m!iI;3x5<>C z{GMd2zUZ`5XR>-0)NnYqOXE7At0{iyKG~icKtBKn0L5Wpp0oG#;rt7Pu>_!L`Z_vC zf+i%S;2#2KN9g0hWRZD~>24ZwE{4mc3EED^-1^+P*X3@wO>zG#cOB{ zhW~lVoTlZgBZH4+>W0Nkdodr66(pE57(R?rFGhQr0DnTbr4lfn3sRJmUQpw?6OnB~ zIt30~q^51t0uVQYgZ@R2e(M+cI;=W(6`97!u^i%c^mzB~6wuB47_fYkUwb`hF8J>~ zRQL;$!B~cCLO1$bO5c4H7R!kFN8e-hyi5&ro1 zzJ#8v!X++V-pt89MmHt*-#9imH-HNa!PU174T&WZ-W(RQKi=GI)b;7q_Ay{y!JsM` z3ePw~v{-Uq0o00=9$lWl{?X!yXLmLioBN|*RY84@wh$SB8XoF;!OfXi6IIoZAI)r~ zVp2E3v1|%qk$chNQjF}$xOwGDW3sx~ORn79TyqgS@LlV3TGaqsWMz5tt4)n}WDv(S z9ga6mj5}^XVR{q)2FB)W$Bv2cobIWWf7lMhFp-IJGsK;dp|@8A<+1_>j7~ldtJA%U z4$j-bN%!+(O(__AvN-lZnnK$(C&zgX?a_37ZtIzzFn}1o$hnx#RVJjpc(Dw&+_;>Y zvD2-2eE6}_M~}+BpmS5gn4b7nQF2QOVVE<@SdpHg5JszKi1EBga6^4)0Lg7!l`dCj zaMJW6)CWkhhesiT@MZ#7Xl6?VLm(&Pt$-N9XlipSV~&I*24@dRzyphG16GC^_D$sh7Ut%1a^P4b=(`hfM!itfdAcLR zNC3fnP?ZEXOSW(>?0*8Sr z7F6y;q{~HzA3KUwG5+EMDi+_d(66tfAkO@ld9NeknZJSvLhRYyn=cGD7h_9Hx=6Gb zN3Qjmu_xmRU|V-;$`Cp_lY93jT(`G~Nn$!Xx}YN%l*htaMPNOt5I8$e>W|O_6PT}e7i-cZ1+|IH#Y>PMk7{(ig z_I+=5ofWEiDANn|W+wCOKqZ2P`34mM*@zKyG11mWBy2DL#n>fEYqAQ-k98JQ*EO!&bC7}>jbKC$Q#Aq+TI zKTn>sw%$VJLXq!lv1RZ%J_c5BOcWA!ZSTCWbjwl>}blK>_W^9Qu}%%_D*VZ&B! zg1RL7@Fga#qP~DIoli!?52gh%7dlxXMpILLc9e`w$040*s67alG&d@#6(xuqy5c4eytlS1j|bL zrNUCVghwnUW2&tkpeXuVkx}LrbI8~HNLXvJM~)utsW-g|Qg0kbP-Bl&-94lZY774S zy(iN5A7iun$);Bcf(*XA$VED==uS*hmVio)7P)Ein3sG zw?=GQS|%mnxV8uV(AttUs1D^xumovTR(*+hA!Z6}WG5K`fnhCG;5#qlT}HNX9`^MG z&D(%8mR>!vTDHMOuqap30n2Ka92c?UJfx|MC?#?xQOS3f-pu*C1|7dt{-`{dY`N&L z@z6HvN%}RDSw^$ku)Sb2S5`2GQ|3agIv(3G`>ZG2${JsbyS<(Tg%hkZ=iIW8RHqg*v+UnUZ;6*LG zDBE^k5=gr!rpC`{+{lirI9vd0Laf1;WMnGf2uuZHHTSu5o?gHgWe4IW|8eEtelR=F ze|jLFUhtQ&adS6gci(0TRMvuvmx2L9x*`l-!vh0^>B8GTzJFriruN*w_ z&DKy^@U*n=-SZ)a^^dMrP)yIl!}kw}QMu-M>nka7egg5!E;fpjq_HuAI5_0{hdp`n zWEoCXF1qb=tikVNqR#9tqHT}=`cLntq5p+PUR6~EQlH>UHU?@tBe`%9a)nJ_Qsrd@ zs8mu*i)rWUo4LZgjb;s+&_)0_)-H2s<~KkxL1W{?^U11H6BGOPZNGkUSATb%9XWO8 z3;_tbUiN~!DxA&$*s7&!ifmSb%Ny>d{`25q@UdYHo~882^7!@AVmQX!%(|+!0FQam zJOo5U2dPfl-qq9V!rTj6V0EG8xX)>`qY>~$K&|hUxOp-;Hc$tSCwv7wsfd+>r~&Q- z0gF+|G@~(p$U4YJ|6k%-{asypefa{&ZQk;g86$5oup_Mm+*npY!L7V4(=_gj9}cOR zCG6x)jb$P3?a<`pneoOu%-=0PFKqTNhRqk9K6A#U(8d&8y4Tm&FIK(-4@so7Op=13 z10-XN={j+MqJ7;5+WiQEwLgNc~YE&)=4-ZE>%}4#hS%QM{6=ggojH8Mm~QY9)5LYk{SeLH@_3% zO9};FYOSw3D6VGf5fOn)4?K9VcY7KX1@K6WsFUIS`_lsh<5OepuYHbuVmo!pr~g2f z*`51#b^-_q$rE0HZpM4_vJ$8Gkw5PhFmb&6sQ(lA&&4ao@ERL3P|}VManT0?Gc`Re z<#|Hu)6+LUWrIyI!VaWxppXGNEem0<1;V{yc1^DparJAx4#LE?FT+Cr>eVLyD52Wg zGj)-o1z?p8Ex^~2g~qsw8VcgJ)>cn1_K+x?H6na_2gSnWGKwpW&uHpmP99ZP?*?ac z`a_3?tsn*}~TAf))jM0F*lhLk9u>hZ?tXiew@5IEh2_&yu=(5h={k{6ejzLM{@ zM(kH-XC?*7-B2+Xu)3>XX;tPGbNGcuM*DD{+6i1{50wH-NOX~8eBW3~Qu3sOLwkE_ zzqr;8L=_+aU6C^h=)uUL67r3P1g&eJb^~qegMon~%4=X}!Qwb=2crz|5;pG4t<`u3 zp`jOK4La85FKt#v35hvF;DA_PVZq(%b_Avb-)9}>aDbJl4~6)(z#u%lEu23N3`>=j zUK#AlVBk;;NK4~_<8}p)NZP|2r^97H+nZbudoOzEf;I_mAc?imH*eqKuhruNsf_Nx z0n(YL+1QfUHb-wH&>U_(+MaK9v&Qh zEA9zXE{n06%uk;-&9?}pq{?9D)xQvh;9V2zN!>z=b`uQ^4TCF6N)OhT-ocRP0tpR5 zD`2iXC+dWJGU`r=2&Q&j)=GKebAuzOlB+J70u}QtBBJ}%-D-8QO#mKonN6-aLJ9vA z&ZW|gARicOAx%y7^mKF*uT&GIq@)xW#0b%I)KW=zm-UI0pc6K>j)a5+M=o-yGU-NoZ0znC_V(@D5{X55`EDA}&!TI12uNSE zuU0i!TWY56F6^9qt5g%ibULUqE#+1iZ|y3icq{$!#oNmh4+0#(jZFE*jZX9x@5>B=x}uLTwPe_{;^S&lcn_R$d^K2!~u#QjtR(?@l$l@&w zhd?sn<^^=J*^Z9|usyY$3Qj;33Q0Xq>Bcg^Pk(tqS~@qiUK!a~VdCNDcK7Nlus=vc z!-iRGu{xigG@})0Xg{R*GisDDd5u?jcIByDIL{y`l*7U^`wR3_;S@&A{lUr#3M3)~ zxYL^H>m&%k?%=!kGFBzA4HQW1tPBF?{07^?vUO2K9oc5X08!$tuX3Dr%+#IWg8SsD zuI}rNbvc3$XH9}KGRTetbl=i>PgzGthmS20Fy%oju*lNNw7fW3*-S`CxOVxc%k21@ zHylJub6RR^_bZ$3va`n>sr)Ltx*SHVeW!=T$mr1KiHw`Q>E6_?15cGOrIJeyJBwZc zjEZ2S3F8F?g}U=gs6ltLlshpZ4tg*vbgCg#UYks;eU>On^fbh|?d#V))PX^PdbPv| zC1Zgg2M6DgBcj&BZ=nGhQiKx+CK}*=Rk*9g(b6^9@wE6)fv*Wr_aJLo_V z^!4T8Vav!EMMA@Yj&9%o)A#wk!gll8Pwhd&?IHYBxY)pH)1?1nSw}ViKcYGZ&Hwb<9Y<7y9y0~zQ2%3kNI^r&Q z(4BhTb~I4q=lP?8Ek&dH>^bAPw@PX+)YYu!{E1;&p9Ah~#_cIk!BK9X0}DP>i~yDR z#Y&RkO9U|1C6o`Rm2?kCoqKVXDYmrJmy{{y)YIc9;$cv<0KyGMo(G64h?2+-i82Jj ztwjE5jsikePTcw8=s~=9KH^ne9Ks-K4l&}^4QRT=6t6MV1a3ufSKqC7cJ6j{;tOE? zNKVg>6juc&qFbj*h-xG1S|$2mFdumKj%caY)x=g22Q{2MR?Klm}!X zmBFYDhu>=5_oErNEZWV~rSBFZ6A)$4n|toKVMeY#1shUwB=*u9A^gEJztNnp#sA#q zeExIE-Y~#zRRwdp-lU{VlU^@ki_scUvrRQ%vy(Fjr$Yrk zKP1_}d@fdJu;C>`YPR*6iazIo@Qf)KkNsTk=W)j?D#pwbU9|rq07p3j9;i;JfzS~) zQ6o@4AFq!Q%bIN_5jQZ%zP)Ly45yActuP8sURn|R8j$>483YA`LY(w;M^1NB(|#A3 zpKm5O2}NyD)eF=y=;3N0H1F!GU?R!GbL*_L@OI$MFaB$74r^R!OZB3`+poi^?m0pEJ&2IA&`W>{UZXy zVT0~04pz&L)1Ni!X-$G~jY-QKZ5 z+o(DI!-t0Iso|W((KxR5l#%J)yfIxvLo~I-X@ep>EDT+uIIMiYrDWLuUO88avTr|D zhxcpDnX1p7r}$RMU2CdunCCFul#3h)4hy??#|RvPiO3#4+&)!ViLTw`d%XYmHmC{! zx8RtKSWYaItS}124g#_THGH;TuzK4dFSKl!(5(Ynij;&tNJq#4B zdf=uy8uu{)_or4RHP3AL3mPTs%^ewiOUtGE2u9%O&NHDSP=tX4=`oU=%So+niP z^(p*8-}Du*y|(KB8h9(WLb&^9R^Uzu2>Ico0K)=?k+kQ3wI5zyg_&*eSr<`Dkz!)B zsh2M*^c`S|PmGJRTx|%NARt`F+wIZ+_l{j?v|<7yd%(rDynHKxQ@?JSsv-c+g2Cbv zsRl|$>aeGj{Rvm%7HJBlsDIQ@raKbc+}sAV4gKt5Vp_4ZO!NoI$*Sfb8?~DQ^&{m* z9(k#H@Xy$R1>;5|g;)>%z|_pX!S&ZN{YdQ&#JkTl%9GvzrV_=Yq zDN&7&j-UX8!bjow30MFdE8S9XSc}+A`W6<7z8C-L;3deo$(S>_2+6=3-{m9tC#Wm?sHO{Tqj`hKmhwy>t(JMg5{2y*0ni8W3O;bCD| zQZm5eq2e3GbV$C$iqXP*$)jDyDwt?a--0kbZ3HmgXwhDZ-Li)H%Ac!&BYRBu{`xTd zi`dA}^z#S@BJt6Y)8K@DhD8BYRa5inV}_rfpSu_IQ_xj`Kg9`_S((2qxz?a}j4DDg zzGpsmthZgC^~Zs-%M2y{yw>pHfq|0$^;>x%cTB||)OJ}>_PuXud5-LaAyA9EySc@F z1|6b^$a4hVntzO}2?#e`p_7E0i-tWiK~|B zzyH6z-~ovhSebNub!UWcZG&dIW`iIGsoc9g_D8a z-r?YxTiV*%PovFJpz(NmfQDvycKOI|JLIze@Im{5VrM6(t>v?aSQOTP6DS3Dzj!Oq zdYr8@kHgj7{s@+ z>p$VafAa0tDa3(=1rBzqvfDQOqkj77?W*Nk&Zk5P!DZw)yLrJtEt~o1S+i6*mb}1V zKURL5m1&^2;Y@cGWItUrq*r9PULjASX>DZG2YN*$*@quHBg>ihv zbVeaJ6Na6P#Y9YwsMdD%yIgd~2X$hhLFVJ)x^!9W2_VFnqgvZp>4UfT$?b1Y6GO=o z)>-`WVuin6L{XO;E0EOw3od8gOF<&?K)VP;WN@S^|G~~a**hhLEV{di2n)}LUb?Jh zoi$0QUDsoWCKA!NVcTcS_aP$#Fac~)>0F@!qJ>GA`Hyxcov*Q{2bUVKdj=kt!>*>8 zGvg2`@ISbIEml#a#Kc~@FR+?&w%^Ywk{nRoSBP*5|5v~ByNIKFLYKi;6D+>v{?x+*vZ_mQ6; zydnZ6P0hoH@{XJ}n*+uoPNZOz-u?T&MHWDHRirqv+o0xWXODL@-eK}%B+(xAoq(#o zrQP)D^T^u<273mec~SfHpycxt8e(GN-4SiOQ-**J=xU|B$s(XDC@n&#>BYvD?4INE zg29(E?sqmpDS$H$Y2QmUM!?~_a)isg^?C#qk`&Mhd}j)AGqc93deO^rJtW#+e8aB2 zT|a*EgaE(bkX1S^USLoVl5{J_umd%ikOsKp_^+qPB)gSF9!0r`!ulzj8Hw^q@O z=+ewHVDsaE-M5yT+vr`b0tgTaF%`6)v^>XFooT9tfDQsQ1i%qSbNP!wt{_~H55^cb zeuKlY^R>W1%#U8c4IDjWQV;(>_P#nQ>wJ6nB?M6r5CoA@KtL%$Qd&WjM(Gw1kQ9(k z5hMjgxvoXa1UTUf=f{pU?j6{p@Ey z&-{p6Ba&C{J+2L@ZHiRCIWA?oQZ@w*1ZCa3yu;u>tfh6h9+3}u$ZboQAAUpq60AD7 zOnRP1MVISM{JqD!dpkQY(k4RC;Qq#r&6P-_Es8gLhsk!kLqgTIDiAcqY~OiUE` zB7^9|4Udb}(Dn)@6}F>XN^oZ22SLI2QrO%4rw3P*VzTZXn@k0-DWhg_Vs`Ab!{yg>0cWfzIS$7TafIJjG{q% zM5)^Xk+Qx0E;$(m+BK#_iKnhJD&tkKu;L3j?M-Taa=i0EQ&T{vCP!;=7)18j`f6%^ z0$np(Gvt*ODdoi*1VS)Aw7Wht&gSq8*y-_uFL7A4KB%45-u9Iddu4gsv)Zc?=UgPN z_N;u|%uW5p@Jr7SW;8KJnC1>0`Jv{>g7Joc$>ML48RQ>7g;CUP}{s&bdSH8KHj{aow&D2&x zB7qkoN=lqCkP@J;4?AAy4p5xN>jMWXoJr41G%-Wh|E9rCy_t8()0NwkAnhI=rG^ci zxgT^xuT7-A0|Nq%1?RzG(9Cz`7}Wvzl>~Z7)2zCY?5s7zNa!P#Av8=`b>VkifRGRl zQ=@Xbh9JPL?mSRb5gEC&z4I#A8uPWa)vM<7=M`5Ra!#@;ptQpn5{T-dzyUQkcC|@TN^0N9`A2*E`Ua`TOHUr& zvJsa5N8EMjNc5FX%z^AtaA+thAh4fv9#xA4Zr@W<;<8wZg*UkmM$QPB-VpP@I5R(H zx!051(b2KDH+(s_h>{!L`@ueDO$G1G9&JHavuwXz?G!#J}XQ z%RasyGTTij1LqvHrI$Wu?X30@3m zdM>D?je&Pz&B*mLW1hNYvm?X9Aj_<8>emT4BrUYWpEsTg8(=u4Zh=WC)uzrs+;KjS zk@y}?(_E;$ds$)?HX7fOqs!FObFtx$UWw6Xhg&i4$yA011^p;A<;BIt<$mr*49coS zez=0_WvT_UHwMb>Z!#@>(GBF+XN!>YsMX;C;Vv{>K3OogqPJ%8K8;P2AiqsZb>p>& zg$K<%0sh5%w?jDbQH0KCyeGg%&?H3rcq1-jB@-@xejfqO-pb{A*Mc9+3Z6%PFnv`@ zMEkPO*y;N{bnp!x*G;KV-Du=h=%^6)Zu1ZzzePO65kUC)o`k`99(+)_W&F?nvc&z} zO^pi65}5r3-%;143Id1yoq__&`a9Q>4@mK!Kc@-4J}iQc5kw#G+QXR&743f74_f4} zhgc&oCHN)~`;j-ewortLi9?2X5fwFa=;x!+nI=a~pWNX}jlAp!6H(q(Lg#DogK}ix zey|k!M9>lU(>_XzAYOY|(jI-$bysk%BWcUSypITBa1^`S;+!FRmOeQc4f*4;8BWLt zm&kql{H71`iHb)dADTj!&uK)EY>No;dmc>uC>o|1hznkKg^{?0zAW*O>$2k4>i_l| z2!0^WBZ<7chJcSiov&peJn{^o=v^4j6T9yC5eJ`Q??3gi{ZkzK*s zJ-XCnDdg2$pF8@P0TuFDU4u`bJ9_hf=Y_(jEyIz&D;{Ew`~^a>dtU^Q7bO4WXu&kz zLcaIL2$&xTf*VW@uKwGP2tG}QT#A3|jXV&)HgV(ct^jy=*SwBi&EHw<|9#YdT>Sri z)CvDx)&C73|8D~bGIYYmOAh`RcoOS{e*2RLn{Q4|Yh<85`e38LUmt=04S@f29RK&M z`D302YwQ2#W4$pGCIE)YtqFuSW`Ds5>Dh^pf1A_&eyqvccUEXbNrW-)k5hIEXco0} z7tuB{{QV>=&2k0=(mpw!vU5=M)+i_iQWSmtzs*YjXG=CFm%PCTjaN`CHyZ4t{2S@$ z|6F>>y5*Gg{?4gSJAKCVzy6aSjRU5t$zbVYXgJHd{n^8M00X1e+p7~^lr9&OLAO~g zqR6b%VOcmh`hPObJ#%rH%IU>LxdJ1FG{-9p3`hl6>)DRy4;x!s1+8c0t6$=bhQqtr z+1de~((RBSc+5Uuk#NW1YQ0kL3M!-mjh4bw%U@o`$^Q{b{uPSQ&d$nH{ zV;^D=U_RE9+Db|zh^{HG3p@~Tz}jONJ{@eh@6 zgRHdNc_2di`Jcv=&6`A9l8Km|oP7Di2DFN$NCkVB8(z+Jf4G`T_5yA4+ks(cMvoVT zgW-4z6Bxm5#lUO?h-{-6{wTiR=Jx!l8N7`+JWc^RI#Q~$M2s2Axl{*tX~4@w=(f|| z!Tx>oPy9x(RGvzLfZ5N6w~V1=&;45+fHgJ1=z{HUriosGizVXd0Kmt>s+c3R*7+aG$-UJINUQ`snN4 zrD{R7%rCCf0eZA(n8G2*KlZ8YhB+bv+XdA!8!3H#T5L136tJ}0;&0ypPsG|mXut*G zQO3Q-a~-e4LE!Q&3&nAv4%<=RprYcVb-3#Gq}|}zTo-vI!FfI)EsI>N^OBnG%;bvh z0V*l5&9Fz>TMI#mkyP3Qd~abgMoOX#5g!sae6+yw1b3c7=K;p)jk~~UILTVBPcd7w z092g7C?4%bgk;0D`Vlux6n@vOQFOPMGMn!ADg?H9%8V?wF4w53$=$q7w)7tE?`(_? zY|amnlkuIYn&%m1DPN{KV4j&FHfWBH2nupqo0LK%-NnQu<31grQes&<@b&b?Qd`%@ zv-vZ{Vn8^r3m~yt)td!DVFWt*`kAO3_!CvBab~<=wKzS3M`!_BA0s1j78b@UVcS=k zOzZq-K>uW@*aA(+aGH022lF#403Y@%o?ry-lndmXWuClWF1f9GY@^vn*oCg9T}3sF zbYXZEtgfk*KI1tsU;=I^sIh~l4T6uKAD3Lv(RqyxON6*E6SPb9;S zQdM8iW$}w5xbSa0hLxiJJV)E7%k+r6DUZtKFMj{L-bO$?LWXaprt)xq3HtN=n?1Tn z2(Qw$veW34Y_fO=s9SLwwjnZ(R}4C4;LhY+cD+A&cgACeY~KsOghoCiKG#Jux9oFH zx|~snfs(h@&_jb`M(}XYs_|Dn7@W(-_Lvk-#cs5IE1y_es-!o~s4 zg>(H2Tmg?^a1M=Pb?(cqJh&xb@}(MA(Em8{fgZk0<&RI9;2OG&Zw>%`y9p;s4~%1O zS?HpyFYHcwzoA9}8Vo4rnDmxkV>a7}|9of2#gR}R3kg>g6NATXSZsEs&F-ctkf19e ztUl|p-C7=vKQQmg*wA+RvI92GXfTxovjO68({z=Bwe9T$wi40;JNm;_i-TI}8fBY6 zbY)P;Sl`}^85$aTs^1{i zKYu3i+Rodprl%$*>5i_$z$GgeTjImiFo8Wo&I3*8d(Cg}7$fe!I!D3%6psukt`Tc7Cn`+eHL?gJpe=Yk{7h0`KnN2fH^X~k@ zHR>-U7w=D4ssKRsQIlfUOX#-^tH5}ad`DvLcpV)b1PUj;Z#XH*qg>Vc z0CG%)+elz=@r~!%NfwP#bfLMf13AC2s)}q}vWvH#Ehnbc9vrleRbJ_37}=nUwOfs` z9Y%Y))s|p8i~}P5#PtEBxO6~nBkeepA|~$cv@jl7M|Ie|CnaS%F;(jO|wL^ffo*xF(&1EbZe1<}=E}p*SZnHS_*jLP0_CJl7tB=6LN4KtANmkbFcA&t{bVjG~b)^sfmC7K?(#{l% zj(2HCy7EAnJ|RBd1zwB&&P?c*8WQ0g4TmV1Yu}`(H5^I*3=XNoE*C^3`;(oOQai$x zjpu0iZ$@Dm)*Tl2QaTqqY+RR-X}#kWm`DSWA9Z;8VRgO1_r%(#v@q^7(^b&)^VjfF z&x$?5xU0sqHG23O~OE$0PDi5x}#5vZ zts8gi1Dq=@+KITe`@6D$Px`_OTQmV07J(#di#1qpXZco7N5lAa_mExEFX%aCC}y3R z+Js06@hWR?4`k%edDV(!mp|KH1zk<;VN&z;#g3U|kVGAkQ7+a#fc#sM_Mv4X>mJWd z14-A#5>EJAveUc4!C$|6PcSG(HtTb9MKyDR3}C_?uL8pr_Jh075owO(#JB;$2UK~M zhxc}e4+DHOc_5a*Z9u;RBM=?emUedqcXd*wi*5V(rd;8GadXprL_nK3a8FtQ27^~0 zrn*1~Lu$0a0dXBRd}VBN=x*y|Alhjh=Txo3%fU6cbkfnctY3IrKX zY*V8*%ow+&253JwI@+&0PL>dThAOL^=J@fr)FnY+wK&|iRg@d zXnPG)+`?$Uhq5So=e!#We#mJ@C$hzoKc(PiyJ9`Nk~Wvj5^(|z-P?hZNtwwHG-Bb*UAd90J0~)MV~g?Vg8k$Z=oj3 zp}um(WhXx!4110q%I%IsP_q(?kWBd*th;4(lHM2hLswp1y{5nHO!N@6cU|^3x*>ZR zUFv*iap$+x?ywmq*&gKSL&zf@0C#jNC>1|{YX7ic1)=TS>FEockElAd7@?E4JuZdf z@v@>FN(AvS_#hM$X|f5Z2h7Nx19z2C0p!2=&~Bqg8UY<-?IXY(WPRLvrC9Apg>$RG zFS3LB<~TufkVA%^qt`h~(S{fhldIUxkk3>km!^iE7&5&n8-&$UD_Z_3GhX)g?Y;FU z59?py&LKmr4y0T=8{JwUVCeDB(c^7c7-kj3(#kww7k6tq;s}Au5EQxzNALU~%}k># zn%@zl>P^x$sI+oe7#Lvc_v}kh(t`Chre|QFkT&9ZNKZ#sZ^BttTKYx1K($#v&wE6$ zv7rHCx|x~Tmfxv=ToV^fI7x-xHem1G(>E}PYSxF%wQEv1;Eq~aR+i*}Y~}39`S_IG zzT=L9ehLSubDqvHz()JF0WMMqG`V_B?pnaGgq4*QjMzM)Y?z-nVPRn*{HV+bA%80n zI6{n}(Pu7{kE|oVYk*hqz;1PeA{%9SV*{r6!@%gu#bBH+&T0KSrj}C#WObfpj|~jU z;GfdcL~f|lA-7JKPY?3*J9|JK#ni3elnL)Dx^?u9SIePOg<8>~ejbS^Y}%3%PWa*A zSa)|+SOJ8MEiE75gTC#RTEo<00r|(7H#SX{Vy2guvN8I(-*f>m=V2V6wWVbf$Z{4I zpOxSYoFur3JgcbYUOC(UgMd#cxK|~Pdf*PFBQNeQ_7IXviUhV zshZUVEw|4B(a~giz4NoPXI^v~aYQv!xjWYAH#IjG00lo`{pZi0;m!I=N=g^sD`xhZ z5aI7hzpcYT@xMgQ_jKek@--k%p8bG&R9G1Cd=tE}sAd@Yx}ltBjWSF`l{{r7~ueG6GR*qn)TwGRG{W>g6j3``Ee@_lBwVBfV%w_iV7?=GQ+BwRM`gy%@L~Vj$qk(~e zqrH7eadFkTsAff3*%5GDy90DG6>YYN6)|KBY()&Y=>H*PZuXiK!dw-!j}h?ARAXQ| z^ZO#5hVXNNK~W?D9vdW&dt53iDi^NH}{`wvZ&3@%-Bya%U!&u%1DI#0Eh$d zAj_rSSJ@s1Xa;DcKe*Zh1DD1Hs*tXG4BrAYk!Elu3uonLeq7B0}KQ;p;WA{MmsvK#{y^n7-WYVzI_`gG@S#$ zp@70pTdpGrsdE|4x&TB|=OH`YZ{Zg7`Mj(a8hiCqEwRmwja1t;1Tq!)7q`CM%(5tg zgA;3I1seQwW8 zcjw_GpX*3}K?O4t1*UUd9v;@#vwUo>pTEFIm{g0k`wO#R5d`wBPQPn-d$`@|I%-?7 zx9Zmu9u6Q|<4{Ozw7~w?q(BUe&8&x0_z0@y%@1P}6Q_=P&110+dFI-dt8$1pR#O1f zQB=0CZFFDadUDHRjE2wx(qj*gE!fZRhjVh__lx^s?4tX<53dCnZMszSnwUX3rba#d zVK^RT5m`qOe6obh51@-?h$NbycA8jhN!XqldY;jwFX;)NrhM>F?(5IVu8)s1nKjD3 zAk%Ld!CiJ#Zkj7( zsTPO@c6(uy8v*-5vt zSDQ6d`gjdgLhd;@Is!~^milgm0>HY2;?e?Gj0zMpaMKCBzPsOusc-zTIM`x^bYYPL1LZT0*^^8UV z-ULU1GJv?g^;p1>U)&F>9brrwmY{S1^?wAUEpOkh{g8;^tsJP;V?%jrZIM1Yj^+i0 zO{i{eyeur>Qdkyyafcp{;B1Cj=$_Cp%y>}mG_UBzeF?YobkTp&&jVvUx+_-> zkZ8Kqav2DPau|<|DQ35Py_XFj-q)g`#qZT|`vjaMnsF&LNs zqpgb|@_Rf1Lr$SgO!V}KC@U*#YmdNboNxvS3T`EpS}#~`&XXX-0#YF5Nje?Wo+8~_ zVpR_q1j^R#?l0_V4u_6@&M2IhFNP_gMUmKP6vOvK=fRH(fVc~dy8~b>!Dk6hXwaX6 zUF=UviBSzn=$C4P)RdGjIiqi1mDw!%`>6qPSPj@SOthh_<6go$f8Li0b_Dvyk^x(k zQkHKSv~o}&Zuz|Oxr-mgX%6KKv$)Lf2e>1~`WY+=QxKP{@$h-;u!${{P*bA;L15)8PZ&td#;)7bU?*0zW7(o|UnH|x_^;^PSMyixGS*-{>%{yu`&;p{NH zcf&0{9tDOIi;-}epTGass29PF_bO$~R8B3whEoY4;Gf2x-yI6iMX>#7hhptbT->kE zUU{HC5eF(S4jaHpBMz5LfoD;^{=fi1lPYcRI@LlB**QuZFvq`tz5?9LhE^7+q`p8V zaStlt(X|EMOohysR8-Vol9H4H&YdHM~+;eM~trGR2w?l zmmdBY%aAG6)O@HLbm6v0RLYJe{TP9@ zGM6F~hjE#Y>LUPZa+du?t`$1l9|7{Ne#*YR`}qY1RG;Xgup(KMFHXR2zrDY^!EgEV z9)n=z%6K&f4%zhRjNIpTP-HC;-k{4Og(Nt*)k&3zC475lfNX&J#odWyZeU+9Z8R8oXha0JaE8%nAW+ zhYmH6`P*38;NNJMA@Vy_wR(Xe&ZYD!b}s987?myweuGlg-@jYcjVXupl!T|Np7gSH zdgL{76kNc`ZuOlH;7A-sTQylKYDsrrRePQD^lFuslJb01O-E|GFhD|F1ileo?d>f3 z`ueETll0pg8sW?y zPJ-5qf%EbscxGt#ytTNTci0i5_;1L01#m~;Qb$MgpfmWWXStzHgVz?aoevtjqwDK_ zNEwLSN$V=(z5f&jD!M0g~` z`^3&yIWE0|1w$@q_C7FB2JFV~-o52k_bTeWpNvq$#KZ)LYxy-~YXNXqSZBBKq4rZR zbP@%uQ*QbNu0F`Yb>F4a;JXDii37_Xze{b6WfdppiP#oA89 zqd^aRfG+V^)<9U2{d&A_9u5Cq<(Akt6+&+cTqW>DpUtlSz@&7cp}MgL(a0HX_vaKb z1j7u7gK!|RJzh=iFSK`1>?wb249*wGHkec_y9MZYL0ymJ6yTBY;2wUTigV?>!pO+d zilGg2weZ0^`0y~zx;IO}GqpLEz>FLmaTC2EmB1mrReTpG z4#GKrc(UM2O2BWQHt%)ht<&w~XmysX{ zlDW`PQ|s2PKe>N@_a3U<(x+U3ii+`iSQaY{@C3fz!)z`9z6Ei9tXnEh07uA9M6W)e740%~b~Y_^>yal@IG3w%f8m0xh>MGhP;0mA_Epoz z&rBeyEKeaj0KYSkw+KLdq+)-wU$;Jh!))NOSoX=qokKG=7@R2w69|WYXwGR>_=;*>GNG(e|V2p zBOsjUY%Sv>7>WFPO#-}6Yh55kiwC#0iV85&4qV>cEL3I$F>?^P2lbP!ohb8W{hQdZ z%=jJ3ca|QerbxzYHZo*?fgV9y)?5<^dbmQf?{0uoQ*CVlAbyan)AK)n?hFtvv>*#J zGyCH|zfjA!yS3JprI4x1Wjb)WsA6bQ}u?KlQO6W${zKW4$>g2NVxJD;qHzBBkW^lP$&Xk zcb4dzR)xtmH=Bii!8J*6B5^jG{5CV3`p$`+cdvmiF2C0V1tt3s^4Qck=S6^aJ&(gm zS#dF=T1BF$Un&YfkZO#f0pxuuSzS=6I@sBrBNf=2NmWC=*H>iz^Xn+$uD_Ep3??Gs z5mp+#{J_AafS599D?ZwS1z#6nj|)CWlzg&l&kr+KTq`O#Mvr*s0}lbaVyRemLhe3@ z={@nEb?J40Q!wQ!KuKIgsQe-#oVm$sFCFO9ZMGY*9AMYjs}HCKtLy8h^qNrI(p&zXB!&Rk z9&#?D;R?+CCj}F1H%`+&kQ{_X@uk1N zUnduvg8jzTtG(6L<8$T}0Ge*y0VDSVr}|AIzvMe!0r+pMEQ-LWJN(V+FZ_&vOZ=Uq_URKCuMSxEWSa9%~Y@IeYH}|V$ zvumpg4%WlP4a~0G?lR#_l0|~Ad>is-adCh7ydBDxOTutlUgm-H2GNxzVL0#(3ma&2 zqgML6TU)e?LoaT_{YGW2ab)NA=sxTRjqMo$o zJx7U7Ft7636^yi@DadHLE(2q^pqIe!U^)o+y8W6fac8X?9PI%7YtehmCHIpwjNYD4a{9M;IH|W@-g>#zD?s#nV=1r9^>i`H)Dfpyj`4Iv{w^%{I7SY?Q zqMx@LTNBdIQK$UX@yfNqVoz2c>M6vdsl8r`)$7C%D-v zs8;+`*vyRC4X6*lX4WvUA-(U93+_mk=q9;o@cAj!rCqK0NUJG!yRZG`f$mozHv-FZ zU9U}h`@&7~TM&<`T?r@z=s0OFRZTLfQ99={`@)RZ)`L{yqNN^%q`Nq9U%j+%(;+lL zmG%83!KW7#6ijm!#P{*hxJq>ctV4G~76bYv@q+DpGSc&7vcLBL~XMvk8F3d0K&WwrkD z1$$D`vdy*DO2q5n@XK$0BEG))3DfmB!O_uZ4flQGoK~MmnUWi-L>1(-~!5l3qri<-QBwc!V(e$OAReQ+S&}ct@VM*v{klZ7aOLkRv)m> zR~f$ys-DD#;N%(vI0tE)pVe-kWI9XCjJoi7 ze>Wh&1d$l7%-l_|FM@}T2%=$?<>2Uq-T}hNdH)MF)%P$M*7kgljd8;~)@m;ReZA0D zrcgQhmT}koyPq+#Yd}_nX9tsdP{Ngfz?|5dB~=^PO7D4?R)>|oe)-5D#XNv5J_5sV2A|YVkf4@=ZG&| z!rK6xIz)(meMkAyF9^X+BbfnVA z{}-H*k@Vf21CbG+5J=8T6bx;_Cl8xZymfR+)McF9{0C=1j2d0|9*zCv!xT4QjZXdu z(s6cnwr^KSQ>ipF6&2-q@!2q#L5NpT;VPcUZZ*ker-Pt`8Q5(b4@y6c*a-`(R+aKG}*kVpRWXr zKQqX3nkloqyrA9Ds%&jdCzP3)g@cQG3Xgo)KB=FA=pmD~wDf)X5`!LwiC5OvN;>+^2oVxAO*o)(JFI)( zP(_UBRi{I0`22x_HM?pKhEQkjEYOGCSI26t7$nXjHaE}lKD2paWaPdIip^@I3rXP3L}D=*s=`Xd6I8A~lvk(9))Oiq=j`fVjB-OgqA#gtzeHD(sgR2`L+6q5{Ll zHQxBJI0?{EI2hbtv_$h{B_vqntS-Z55c27-$jZqPx^stGEXY7#AEU1;D@wxG&kLKx zvSNbD@X3=g{$3Su-Q;&%IV2TUe~f-ZUs|ht3DjQ4HL= z2_|0Q6E!n4Gw`Tz&jz|huCuSOR2~F{hhuZhb!TOz(Hng1MR5Mc1-NnXmE|eJ`iu;8 z_q2KbUGVFR*9SMb?(9SK5yQ@0fD2KD0CLYypG1hT=Bj_7JNV{D+?vJ6gy`w#otNxQ zPEW^b1Srqc^gTjELPop+#lONKAW%!y{flCpP5;`7>o?O z4(0BgL~gSW%s?waZ?jBLP*Wpy9$hO}Rbx?AR@FCH5;cd&0qgDfp-g9e_`u9(!hv9+ zV7aA=F0MNsF%mC?c>I9G?=gB`prEE&sUEA_`}h2zii+{~Xn5}XU?BpOx?MJV4dTi9 z9YiiNAznvCnF~BVb7007JC)p}2wQiML`AlJaKG+N^%G-9kTOl;?th<ITf2d__ zZa$T>0R5}1&HcCWDY?11J6o&>=-~|&KUo8eJ1dJ({<^}x&r2XRo;GTURTwC@(2ZSl0v|eT zdF7tjozl|LYOn6&@20;V(%A4OCOnwWdY1iPoIt_%A2WvH8!Bb1-;{@;jFr%thw=^kD{}Yfrr3kz zn|9YgeSFN8=3CShc6{!N1tu-=SRzjMwo-W<(v#V_^Kj<{MyAgPrrrdLSEMfvI4md3a8y(gm~2j9$xw_ zXE=?1n<5UE-#XqgM;w1u_EL`6-3xjE++f z4vqq5brW)SL%aj(TyE>7SQAj9o?IhtQ&XPK*x7MFY@ZSZVLc34P3BBKyQi-%_kpBa z{#8F>@E;A7md*>ZO%ZB7-Z++INeYb(*vY`gd6D=aJ({f7=Y9jE z$S)!n`U{CJTwuHCf42lRzpBcOwuFz?CJUlX2jH^@PW!jqw#cy{6F`HP6v^31=0;B& z+O$y<2gUT!e+pgxxw0*L)2faOn8VQ0f};vCF&o0*v}I&vy{g!&BO2wMZ#x-TPdtdh zz+?v2N#bZ&z`=o!{|I48Qvy$`diYiST6ssGk*;nYT<|B;-tzSPd~_j&&XwFa*MK3g z7KoLkg*0^o#@0}eBTjrlQIVSJH}uQCJ`B9S@@{VJM#<= z%+Jl?#HST^zza2kE_uz`80tOoAs*u{lXXQUHBt(SGga;F67;?(p2yd4a!{nDeVrYz z$Hq~4pu%HlQ^;v*Dg$mTY;1Y)`p=`9z;YA>yK@hB(YB_p96h=%Okh%3J-N^77IGyM zKo?;PE9+d)zw`F4;RP??FSnJ@=(E%G*dpTJtCKkGbX?;qIt5)hVJ+B)k>k^L0IFX2 zEQ~I!elU7n7;meLBaU}!Y6=bbPu#>xO0tlJ1Loeua6KXA-8;Lv&}IZgBCu_8`$I5F zV1a2wQ$ubQ=C_>Cy0@`8UVmsIF(JV4z!+)lG@fQUISXFCiXvjsMD-2is!UF<{qlp2 z*O8^e!}CK%b~cFcU1xfmzyjyy<&e;rv~1UdJs!7JUvb*ESmJ+3b_9g#7S};SnTaXO zFDop8R#4Df%!v$y^jg5Ci!gs{tJr;y597smdL_5x!!`h(&gu2$#ylR0L^toBg6FwNm^vKFz}7g?Kpbq8W<0Dbxqcei;DTR$sGSL zAw9j|qCgf0s|dj*xOFH&K4c2|*#4(qhA!-OJBS8j7TV~XU7-j`Ny)Q*zAF^8bp$7s z;_ZJQEtI260X+cb(U{52j^JQI^TCfKLT|?gKrc!NrgT@ga&;j^n2J<`Jl7P`Mp02u z2ynz|EV!50PanQH{_6n&(repirx&(zGdPSB5dhcOgCyHDQjlB>jG&ZNEcR35IEYJ<(47eAQP((4wm0L)jZV#C^e#|kg27%^FnZGU!TAKIxO^cB1%f7*Kzg7 z84HY2L0+EArg!0ag^Ef)ct>FUQ_k;yd{$n@J8kbI(9zSYT2xSAzhd|OJ5~8Out{)m z=$an?n4Fw!X^}qK4MNR+#4K=HfD<14OK*+^0X-atRyjreA=e8F3TlU+Up_5+FGxh| zbP&yo%kjhBSpw<`$o+x*8u)fqAC|wkd>Vm-qXyJ9fW3$nKXE&=u#j_SY`oe0$rH#r zdt=_5;;1}yF%Nx9jgXOHNubAA%E>D*13L*YGI~2kMt?@MeHGz)lITZ1NPlK+fswEjaoW&mnM&8!I$N zlYMYKhTDS55Ga!Ud33;poofm$fi`PX!yB~Y?A*O;XvpjdE5Y$`Cn5;P5#T%6@={XP zdLrBiEv?FB?|bVLPF8skhTIaz9)N*RTKapwVopvBp+;s_uWDg)@#G(!wIpsY(0CQ1 zG0p@|*{2tD4h;!Mho0jAyY9~VK&cz-!421i{Cxe>J_rav$MP*sDhCILa9)0R@6Zqh zS-DPaBi`@W(y6lc_RaZ*I^HvW;xN|XfqQar{a#m&wxoRKiiJ(Zcon- zkSZJ{`zjypzQbTf_;qQkr`qHDC%buM6;}xp=aR=E>hXbki8PAvLYUh}zN)}x3-!Wp zdzKfEqg-Q4qoj-s+S7?yj&&Qbp9x`b z2l9~E*3R~elQ*A}|E*={EC=9-fQGz$$(a70>{DlF*J6LA(!)D1=4LpQjh`Zsm%kCv zQ*v@Ho9%KUq2Kt$r^k5GB{@r3nGl(GgdmUjCm3V5|cBzM?zou$B!U5d31FNaG8rnf8O_@@jAZf zYlKowXnQCp#lZ1Os`?-gta@QrdHLXMts5Q4y(Z`Ap#pzqWsQPI&a^(ZBHYy4G?+`RDJGUW z+Cc&p6!uq`(T*YOh1gu*%|bn${?E)T*&~@N<0}CWkeqja85tQq<^P0XjB^e^ zsFQUkcMSfZqh1MY^}58XHV0c@h9y>({)pjAr30nb?L9s3(u&c8Cs15W0>(c+ zUY!2RB`x=dWar>dqx{h$`is>eWDdAB4`xMoN5?HqjhhbZh6v1xVJ&(2XXT~(ZSlfe zynt~-N%D|{>kg-{Z~&)hc0#8rH+Mtb%i&@Uy+2RbS$GcX|G?6l9$!NGe=vpM_# z2O%fP7&eEc>gZUOTr2r+`U-2!%@q|x2wz_b5R(VX+J^h$l8BrqYoS09Pbi|3q3G}L zMGfb*9SZOek+tJ%mB`8h+;S}cS(=Zp?|T6k6ZeD!Nkx=CfC%Orte58J2lAh+0jMwh zB&Z31mAioyObmj6KrFW&!(%JN-nHqDzx2k*MQfA6kadd}{SgK>_0bRXT1RF*~>%sps_^Y zZ=T@T+Y8-VAP1uEI`;0vqHNl=YuAAEe$%bp;3t3+@f@77Sm(~5%hHDAD&Lj0N-yBJ z74<?Vwb-e2rC@s^QTwg8Q!z zk~YfWrQxukj|4)heW38*_{WSsUIWgm0L`TA)*cFC5O6@Dxk?KV=)Vp8hH$4}NACc$ zRn)##7#bL|<>kd;EE>N4{;QiSwV2*V$w`a$jaeCXXoiM`HG$0d-u^G1=>-7)sN~k0 zNx3*p25R)J5Ya}4r?FH};>#0*8uZ)&X86`DiE;wjKwAX9J64k~LDu89hQM+2@VlCc z|8!eIBY=!)2O?QRk+o+2bnRhCm6P%Q2MN4Gseq)$)sk>G_P0#LBZ`24M>MqW>uH zoHU#k`ZxlTbj8K5cYvwm$kbf-3HWa;?&}BMPpHSm*3Tj>SB=tV7W+PLOH1#3S95Yw z7j~gIE&#zj)8|tRjvL%50l~vPu|MvWn}1ej&D0W{5&f&>B4iE&A2yahVW7+L=+w9$ z1Va!iIoiTit3rEH|9hu7Q4nCW$L8jhdJRE9*BNmg`dcYK?&7fRGd;9$Jrhtb^0h54 z{ibx?T#EB%Q!5L)=$}=h$Ek`T++%;CS$Y~h*G(>5EENuUTSGayM+%+atKvuE$*B3 z2xx_aymDLrNgHJglMxpO2kp=B8rqAO8uc#7wmU7VOZw+zEj%$)?tzXzocuQ*iS2pg zQwP~DUV=XR!5etmLP0bK?!(YHTKrUI=aoM5GvSWc*izdux?4q~JO1sPN#P5P)fPfW zN6hu)iV9}NXB;P4voBruJ}6af>F=yBRkjLi#R|G23k_)a)p~m%3QYzlCkqiv#m>8% z#9B_QhHaOz<;BD>`#UAm^BUT7XDBP~4(FrdxCt#!o*56Z2Z^br781H>$3Y{ExC zMtJ%+w17Smy39~{sL88mq^4quKhSX(393G-OtIx{6k!DLk{g3kc0$p~`7e~g-Te7E z&OZS=US3_DUDC&ek^R>4m2TbM_S9B!@g~6T5RLzL4hG<@-L&>4al629$Nh!U2sum~ z!I}b?_D_MH<8VGwt@rrxqO=V4=`paQ-NAOI6Ki>sR1c(}QygbRA3l{G>B-fFelln+ z3qeZo`u95MPthKYbR7t7k;u>l;_(LuD6+bbw-=zq=KExKJK;2;XW}((`ls_fxp3&i zb;bY9V7^0r0&E>s!+}FR=WM{D!}1u_|3CfGf4AS9!p{<`mRF9W0kL<^{nXjP!7yOS z@$fXeM}lLRC4VS*N56lUZ}P57?u397;->?n%C*|gHjIeNb_3RdF%)dA6l1b>Bc zCLtY#4w`1U-b_=N>wI5`<@c#i1lKt1~989KCq&P5-LFp9(&>$~~xOUP8scY#f&B|(S_oE~96_Wdl zU0tpVgK|(2!>k;SriSBqT`RPP3ashw29WtwV*T$8;JwFCK?6tZa5Bog(0n-H&|dIg zFp`e3-nu${+q*;#<2ehI0#0erqEE?v(v$OOy7}|aCQLN|7fqAmBKn_#`N!pa8Z@L_ zc2??P`fu=)tvQ~s6RTNtOw2ym{jO+L{{a}XnfHd8H;PqvvSNQ24d@@7rUUWW*{<-D zQ2WF`dsZIFx=(si8{}_p+DQ0CoSYcQvhxVvGBV1brv8GmwX@?XCX&c96&2;|{0Rl{ z6tGgh(+pZsZ03t(2q5-fXTEmFymHU7-X82EOG>tpyq7P>ms4bmmzsP>N?u-XV@3Bk zJx&9v&vR|54kzOOMca4BbKS51e`K}L5S5jNQDjBRjHb*~6e1%lWQ2@pDl;LZj3k64 zDtja$2^ksLd+)t|&ks7^bD!^h?)!VbkMHlVbJyvOyr#`Ah!&&z*yaxiPI)eDJN zP@qB}c57pK=a9lNV$r1{Xu$fL3$S~*MDp>=7`IX4fY{qZ&p>uLukzE#z#x=oeEj<5 zuox0wm9ve5aiN6I2OgJWsX5-%SN*um8hTNCuVi(2A0m<;*y^Z;Uor=+RaoMHh zBlyXas)Sa-({wzdk9KX7STG(tzu(8S`Ym&I;r(*ZgvjDn`lCPiqrJ4-9@ib~*I}%?b;&7K zO4RCZj#lVLX+J-l6vh)L2>(7UAG(Y>qov?-%-Q-z$4;@HaIc%m4u@{&udTr9FX2Px z%;L7oaH|362>)BaD3V@*gO;T09}I$}^tbe%DiP;biU+u9hA5Ydv`|hz85MecLfRQH za4F}_SKznmnwrRn!Q*CEDbpZl$8Bk&nPx5K930Hd&i*}@l4c2`q2&IbRU@G&eW$zg zS=i;CT1_@&93dOdOEw2P4nX~v#>>mhlLO{0pFM(v;?*~*E33tWU?RB8=IHNd`fS)8 z`uu-aFVwXhTZa|DoV#_;X({qL8{|9%!ECw4E|nKNaQAL3;qS4hmG)v35SbcPwN<=) zeB4}nzt{(CRUlhtPq{S+U!6t#!l`*?coq9Hw%P&qcEr>N=IQ(?DQ@kgiyWx;iHnSk z6s}t@xMxqE+Q+LDJIoHp#K+TIw3%e^RxHrvUvnD+;SbSGb<@)|*2fNYx2zSK5TLc` zIr1^C=)-fg@Ro>(i$p;@tkM9-a%%R!!$qGp%WG=TIL0&OpmQ7c{PE)l8q$~n zZFVC3js({O3&;ovg*{c7-g();)1Z%s}5a_($d=4Bk|T`3Qi zNqzsOJUFMq;^pd2_y_aH%yeRWoI>%ex)D}XH7vtG1aN1!!&gQfx-s&(=Nzl1!*Cul zNXgb^)T&P8LHUm`w!M4b%}gb%xqqMk0=WT7=1alMptwOEHh0l!g=DHjOTWdW?gP2+ zqetg%9m%ovnwd$(Lc!l~2@u~m7vFEnhBD3G!s2;|w;r*F9K_cxISu0C0{S;kKW@V^ zdW`e0)0)5Uarz0@z3mTocOsxFDH#u41|iLJG(Cmj?jd)7eVOeYJTX#~-p%!!&LdfL?>z1#3c4c&)z3|JjMMCG*bM&2 z=V4~PsG=s4Q>w@oL(rSx%D0~!Kn5w(5V)##CFg(nZY{PHE2gG3%JLl~UBOoWmCy6< z(V)^zo1u3jLr}eV@nQK7FmKmi1n_I)5a05c9~J*!IryBrWw+thx_WyBw&or*shukx z>sGW}To{!1WF#ac^kU4M?{e|Jv}q0|b0D9YHMCbR6GO@ph>tkaVr=1qQqb|GSSSA#$0g$*1!@ z&lwvUHfKq)`GE?^?3|GB@csL7S3lM+lfQaV|2C)mmkw`*=#7zpey#X8v6ns737~(H z1c((4W0B%AoyB=2xD%pdKb4klp#2}g0^fy7Hf( zA0A%ru&~OmF7>+QDf3~Q263Ds0^{pgcaJS3!m2k6=BDD0sC}>+#&mG?)rmJ12mS@{ z_n#jrVgeDAWGh3^`fV>9cd*ktKJ@b1S5Ts}3hrq=hhnPtu4#maA^^0Vx zn4bbwg4uas;GpuiV#3k5jSiE~5B>%8?>sx{WMk1rc;KPYInYdUaj85HkB{duJM5OZ zoK8Vr*%2+o*#vK01 zom;g1%32gzL6W=Hg>+Wd+L`xM7#@18K86`W!5pnq(F|-&P z6N$4sR?i(=o-*L(;!aGQl#*LwaYy--$F@D^4BgGn-p)A1EP4FOllSkboIO2N)`(aa z=$;`g*A!>flv}&n$eO?wo3IulRIPq7JvUhTo4Rv-NGmV(eFEWEy_ojTH`1CQMv_g< zl2m6cW{+(XD6Io>a^sTvc=`kP2`c`A2;bps<~=$p`DwgYVc7 z$L5gr|DFtxK@U_!`LWqPzm?x0m096j%L)njoE$lD-~i!3hzL9FTFh|7Mn_+7*6w{? z_tCxp61P`gguF}SFE1}A&~EYD8WiAMRbSuV!;e*cjqBFBLECWk(`D=`;LvCtYGi4- zB?{aO4;cHUVY@<;(|G15D`QYvK*x?r(1_L<#<%v~?IQpEBn8FAAzB8u=(mH(o=rPi z2!scLP9y8`F6Z=L>dYZt3w3_);KCiju#NM->HHLWD@?=YgzfUrxAAF{89@AFFE{r# zypeu0mDrO7-Uv$>R7vj zj}x;2he9!{b)|<^V8wXJ1OZ=SKGA=_rRGOdF&MWe#?MItu3lmDZZkA6AQ*_-$aBy_ z*g;iUx%X3EmB>f4$wy+EPQ|hD@$1%UP=zMHyb97&=x==D^UF4jl7)s?56FrS&EF)T zD$QCHN1xi+0t>^)P2a?8+F+tdSN94@S65d6AG8b#uUy%5Di~CM=MKxxyHYu59xpQ+ zGc0GVX=)&D_3ba876(wPr|qA&30O`-K$(4Bvl zmPSR#EkYclG$?KMhm&RokVl)Yp)w%)B+2%ZZxlI_9lAF;|N1qDj0!VH+;OqBb#>g_ zS5`f6zu4N}Pbye-o~|TBLNoQ7V}0s)7yEK}`Q5GuS7aX-*NVq<{lEE!m01NW>dUA} zWF$e#KA!Vcx~m9;tYWqx!s@kaFKv6bHUqT5v{YdU5XZ;zSy)7EPbw(TBv}Mn<=!6$ zTnNx`rFQM^>JkbuyY+M#wtTZmF(*|NnSSq`bN<4gt8MS_FF{LY;_NgnOKaQ19~Z$N2%y_jXk zNBhZs)N}J~oju53|&AS`QhK7ZuVbUeR zA~dykW+ye&JF;%plW5%zyL__XHK+0`YfyrpnaOX7gr1&R$L*6>t<@ zvojV3qK}QSlvSY-?G6QBw_Lf>5#4eCAFa6mQu+{62&E(r%<$ug?RO}i3oEf~cuN$M z2kjEBvI1Ctg2C`6bg~GbxMR;d0lN);rR(kc2bOhoXR~*%3*oKm@nd;=;3RENC@D2h zn5eCwTP;kOTo^X5BO&9WQBUDNDlJW#4WVtFqo1;~LqVOC1T!cp;e*|LYAc>KS9}yE zV~M~lw|bYgS~MfS?nz7?VTy)aul;LNd8B;ULF8a)Yup?ujHIKZySYGu%y-IVg|f;H zVMO0H#%mT&{n7=<2mMp`={06%5YU_m8f;lx3n_%mR(qh#v>8+^;^|SzR^I~nLXRyW zMCA8&tVZZV)V#f8(HoKZKw z*U;Nag7|b>d7yxPDz_@H-q*8)g`1h^8j|zkaIQNY!?Ir!v4DB9-9KVa9)XLC`&|9& zq_KJcM_rLC*j7h}^1I2t%Ca(&J$#o>n7%p6;W|7vwyGaVI}#Y27RdMTP_rCD?Yu+r z?B2>xP=P5F)zlV;*+ZN^T+U6k2wb0yC6=#B z0!W@NGbsp0M!mRM!iF8_%%rQu8)nLv`pC`LOQ3#;z#Y;BL<57hC3&3 zlJ*|F$|z#ZNGl&A-k$i4!8tLpXpVe9>lZHUX)!IKs%mppESjgIoqOoQkAH0+LD}JQ z;^=KY`zOls-?tF%-@pIr%KWHV{o|9nQ<)AkdU%j%8C_xXJ83geTiiK{`JhDmpYnu1 z|CXtv+6mQVmpl6FrU^;!)k>ajOje0=2--FwI zeJshH!@|O%FD%ZfecZk2p{Wb?2^}3mz|+7}dwxLkVRU*9GLU@@?>A@9P%#ko*6*R$ zIL$Rm(bU(+?{rIKE6|wtfrq!TC@Ht1XuIB9W%8q~kdz{zb@XceyXmGJ2!Wg+GpY0R zy4zQuXpC!*yJ+aeAhDolXn1oWZp~&k3JOzl0N*9e*GQ}4pm;g@-uMQ!KtGA9LO}AB z;)@)jPM7#=wS8sTX50NQQSJ&Kde~->GEGQ?1g)Up0$dVTzUQvH1keT`+7uqsn|{M| zG;G5=n-XYNk|Y^Lh?&k!`A0-dPk%&1Z|m0NEzX&l;x4&Vsvn6;MnB)QANrO=sU>!~ z<*A@?*wEaKLIXD?{=hzeO*Zmh%*)zh(~_LEC__-+&m+j40eQtKB0()S z?h7gJfdlUDhhty9yh{V!2jdB@6W%9vjjqsbO_qa`k_6s_4$F_hDwBLqjlFyKDh9N- z1q20=?%?JQ_xm73J2$WL`MEGjlcYhw!&92r6!MAmqiK$dudi=KWo3|%3A8jb7#U$x zJ$JLNcPUo9@?apW->Nl`Wpo{SawNW)h#kSF&z-BxoDV~(q%{YzWCY;7Se?sj(G~?| zif3X$!^SK=NLDdUbtk`dd{83v#%RaBc@>hVsHm-?1?pUMIQ$Efca_!m(~my^&j3?) z5CaK*`Xr}ySTSguz*V#Q^ffyKxi!?%1ZmGGD?j0ycwE#z^(f3+$<~(4D{}q4?hiuX z3#;${`SojR+l|7Z=3Q(G!M6{qr#j}yN0?|iPEq|Jdhj`IIM4D%G?uOZ*oPyhZo7on{V7u5h&4L z7*{#86*F92Z!g=e%2C&+=jf~6=&>Kcx!6jk%(FcE9A(-CKgjsa3)y^xF-RqSmF@7mL}s^XDh( z1~j6hIWgo)qT_q--uv;RP}r(qU?n3&(1t`|5`X8;xdxC!Ox0ba5Jv3B2Tb$?!*JVL z#2pmi;y`^2mAF;_w!YjLpN+jcF=wje z0`V9Yk()guZ z6R&{b;ygTN=)L%L3luFBOMm`sOg20XZ=`fbmaPt(*KJh;&h8}%Kew;nZ(#w>C;V1H z`v_n7i3=A!uS1;vI#wCHt`q(FdN1o%bi*dbN1+#Oe%-vPqJr_@&2*3Aq>29PIkuqj zM7r1?$st8hGWx#%4H)#WY4{>t{tF@EY-*%;uqxrU0{x0_0o(nM!06ngFlh$CAKxJD zT9eok(NM(2oiBA6kD{&ZCD8oaC~8Y?zIugt&1yfXUYPROW_<5fjkF#$RaN2Qr(gl} z_a<`f*|Uwn`q`pSl?7UPCk&JFqEK-qnbsdRP`d{Iol{VfCD>@vfFtbd=cl3GSsW-p zAHpFhxM$$=LpS=woYE>&6Y*#Mh7Yj0nkS6RV z+aM-f;966tUXerSweFTYY{&NV^_9Hb#^F{O^D`F9oc`J-$|VBr)xfNi8*s2GH=DV{6{ zUU%Wbv17-GmTO=lW{zGhQk&7SYdjpb1W6=#HF-#ZI3*++FTZ*&%hp?-uWPJTiss~t zoiuE0!QLl#6Q&$8@8ucvuGyTTKJc(LAL$KzG~rsxFFqZv$lB_$K0{{(r3)8Qtc!aD z^yQ_)CgZbARkP6FGIUy)jtsou#1Ldi`mGqx5Jh)Kck?C1A%Zi~*F?9N@Ni{_CFjbD z1j<%LdKFe>hpNP1I(Cd%R#tSE_esLgv;(ZWYBQTf%CF7&UVGTt&z(I>XtGGr`JyWS zKB2p&oFI8tS68cvE>QOV;aJsf31or}_gh+8VAxE;8>(<%Sfby&nHawS`Q-J^8?+Bu zLrjjvCHz3Gb_G~s&~#!-;!c*PtT#CVDA6!pGmAp!^8@cY6f{ByS(5d!8l3)}tE+4F zR^Ds}_lWiYz9&<(?d^J$)Qr&XQN?qOIbUmMce|wpx(S)K!#|GPp$xwd#7i?okCU^I zu$uLWPX5f)l)11Be0m0!a3lI3sk<#=Ra#F+>l++AF*9z=d)$5NA%h_;%h6l*6LU`- zS!1H2R=bmse#=+A=($bjq1~>f_!_ycA+x{G=M!wVu-$?eq4%@1JMtMjv#^1*GwDY%IxzoLp;ephO1)2LJj56;hgx zv|={bc8lwloBAbs@QW{w zY?R6l^?f09_l#@m(vP<*OKrrr>HX#ctY#%}L`+cw?!l{Y(N0K~>lG5CT90~csAlJ< z+=aPO1%3LTKb;mXT)MQ7Ig$}2vwM>p4qdRnFV+cs)g2iPyfC$jBZ8cqhFQ#k!~5jL zkA~$jDm=^z+ukE_pKbNZhr$xnlgYzVQ)d?DXPFLL!BUQrvfd?x`nHJd@GpX&P*PX_ z)^34i@;@`|Y4+^d;}8sC0xQk8TDf05_I}-K)|e3!HFcVU*7ev<5c!BIz@42TA~x1} zGK+u-TI{7(lSp#r*|2f)m1&O|I0R$8UwxL1!cM=nWRQ)r+a#qJG&1t;*Rx+ESzqg* zixi_`#_Z)n;pcDj9!gxeK_(uH6`2DI%*%t}r<<#* zt!S`!n74eI^_2Bz?P0$nf7s~V!v(tUK7IP+>Y4>h?;M@hqNS%-Id=|yhvu~1K7|-w z+P8P1r}kV(N#`9rQT21@A|Rv?k4UGF0QKnPZWPUkWu(H_`E#cHFX4zCqxy^6`X9f3 zQKU0qMI5aUmf+#!ywMPL$8@xVJDX$QKKq%ZlbV_#`O05ZSiR3eH7X`~iqj>x``3li zIJJXPtBsH(o;p=HO3h@2mr8Q{!UeGTj^Q#zgZVReORe6DoR9_B@EE}E1l3=!t_KBE zP{6FGM9)N57?*uQtf8Q|57dI2hlhUcy`4&aCwK3~t_+Z1Fporg-XM`Fmp(Y8TQk81@IJGB&P$JJoKUK_dX(SXg-9>DYe% z#$@x1sHg||t=qP3?@lsyseN$t1zrRUY3Ya|LH_gC5=QMtZyz1~`VEz;%l+f4N$#9+ zt=%BQ*|YTH+Vj#Vgm4BYG+enep5M z7$N5Ot{98xw7fhOm8%_p3@7Ot(xt}DQmY9voHrFCA|hmDWQe;3vS-+lzVy|i4(u11 z%ziC*`EoO4UsREiV7S|@6OgAsTQo$<3b{LZYEn2%(8#Ca(Xjp`H^Y>sJ zp2EQ3?gn0th$yNs-xsD!KWYgcSiVT%JcSVX04+VkLsd?dMis0Qi&dDe)7JKEVaGS% z40{=j?_DGg6N&lPfYnx!lXv4y|5!I-!LZn}%QyiEthNlRhmRls_^y#QJIO+*YFt~B zrvDS0M@<`3D639X#jktdDgFccv#sncSg=M?MgR6!$wAiU$tT=u%n}>%I&~ZxpUh6P z?Vf8uDS_Vt^5cz!5#SQzEkuV2&C>F$iz*U`}i_*m{?o7kF3So-aX`zU%~XF zP5qP;gT^)Q^lYb&Jh$#2@&?P{#+&aAMGmsEGryk#&57Nc0>`?!{o(Wjdj|%Ntj;;H za~I7O&~tYjaNlryaLw|^?F`Xt0BW;}*W_tje51wNg(~%rPJO%u=UwH$S;OLKTM zGs!m4COJ+$*r?@5@@ig|m@z@awItTb$)QnpHt;O+7_1-+xv;n}wLT}Oj;62iCmzbs z(4E8mwavR=Rio<9GyJCm0>;RDXIJc?%zfL3kERWMbssf{JfAy=v#=BvrKM`;jpVw7 zqYPeKHQ5OX^v>^B3_hBgX#be(C}zN{FvfUZTiMt$0zvsfYIf5j_%o1SmYn^b7TY=>l3bV=pr$y zHd3wF6gIfz=1P$qfGn%_*w$Urxvu1dTiEIx zi3`w2>-q71-_7kSPUY^Wuk~rxd0)Of$kTR+GAw^JA;5IyyA{&fsf7(opK#~#$=4*G zT8Fb=2O)k8I)&KUB_o;<0tAgG){D$y_XaV~IVXMYoZo8{Y-F)K$2n+6rXA+IHmtn| zyP#q{$gW@Xq?m^JSN@4_-)4B!lcP@me52*4u#5!kdg03~wmr?J#0&}V7Z=1mKfm!+ zHeTqFIge*pX!0)pN=ekh466}le?*ySG%5bA?Wi0%k^{sPKJay3%kigAfv-3s^RG{( zy2-zMzsa~?2-ncl()#-QnWy~1295E)vhspz)e9H4HSSw-QK}LN4~E_%J8YJ2jf=%* znbmY|<6E#zNFBmC*#3Kw%k*V*G}`(&cU5t9&g1i}OF6OEX*M5?qM|g*&WVut#g`VZ zE0Yr>Lnje)jEKhLh)nu{hX*H`PK(YY=%VKOAN@B0;r4j=Qee0}zU=XC=V>RXa-Gju zPT%roQvM{RTQX~{`L5;vB|coFbz1l{I=6FX%Pu(K=CUvT6StfR5&BDF_UG553X>z+ z8S#X|UBxPlVOCqe#FZo}I=Z{pM*7Z9V#KnUZ z>2KbuN<2g3yEs6cD!cS@?(N$j_QBxrNVczDb{(-H%Rb~!+=wGWT-m!>-%JBAeU93)eYEC*xat&vffdaR}qIB;M+m7AiH5{X-$wjkrO z8&{QB_UC`%+8e*;^mv#c!7@XDkz~E;cgK#wf^cYJ+F+JJGQe7iWk{4k5}%)^&kH>q__Ny+ViRy zm=i84Y##FN0)}&k_^c3qh;H_;o|Qh-IGBTjk$I_VZd!T$2^i;~QBXiKPds<92(Bux zJ$%EmaPi0`a$uJ$zWlE~nWqEtDtq@5p(*m-pd|}xQO4BunNz2t0nHjHLLp8?Ny(%( zi8J#(Jx?%B3g%{M8}WXLHW+fenZ+sThiM)$Vfl>Xi|YMilEE#W&>=4ghy)Ucck`PUFD!N+KEGo_(=L=9urrF#ur~=t zP@4X;x2LykaoV_Nk3?4c^TXG_NO%{u*VNGC^D-dbcddCR zf3l4H;=@g_Ab5zpu_ITQfciV6p!I zs<{zPWs~!%HuiG2t6&1B?5y#(?^v1@<4tpP4CszLBOwQ1_ znz+eR?v*?&R^g!D$Y;>yZMuI5^6zy8#!0_{F94Z&FedIK_^}fA1pPf6()Q|5_jA{c7=bC9zT}MM%6- zTX#WCp|rA+in^g8N-136VIj0%ryi;AcUoM?fFxsPKxrvy-A8f{X0a=fQT=V^5-aT@ zXaAqtFq#S!=r$xfH9Bma4Q%Zt+}9 zB|wBQtXU~e`k443I5Z}PfiXP;)C>JhKJSx~hFDY77Z&F25pw4CEr*A-VQ(K#E^@T8 zPhfWCvNR>CR?)*924Gzc>0!Jo6Z|fKjxQf>W|MtpU@XEE(u|H3aR^^{#rBm78pN>R zAnDz^OAK$R$E_y^G=idiNNjI#TVJ!1nlEU#z<)LZpt>43_`&3eLI@qVW`ae}Sq6vQ zNK^3J^RjXp>gr{sFVA$}AMX_vrSE9h(8&0@*q0&;kKl9~@npNf!cWciS68mEvd+Q- zW(xjoXwYPeuzFhT+mPX;k*>?>9FvlA`iZT_cD;me`SdI@3JTco8WGoT<#1}>lUY68 zm--sXxX|HUOP=z@P4tFlpU$maF)H!A!nbj>?mcqppEi^|%gbm+G?#NbvX8RSmd@TDw8JtZI zMf8XV58gK3tSiEoZ{rsb=uAsl_4~n=9SDj>em6VeGGZ%Qp$07i zlFcY88X8WY=hCdf{;CRIo%{Wmw!3N)*?Jl+Siq6i=H`NY-EJ%!mtx2GF7LC8+E>Yb zKRcysL)M;;f1t%X)o8`f8kRJcN9-&SDYA9;g+Ky{eY@>fzP$yB*&T0W#V#wP3VV#iR{3Qgx1>Xt%TLo zgD2;89M(R3IYY0ri*V_Z8x!MmMH(P~kMk}WlU9K-OuJsj(4gzqJDWi|o(rz=1K<1W zpq{;%UG9^9kfE8){EVQoK;olE^GN6#|2~q(zlrL~>aXi2$1Wl|DxU~?@5-w~Up zreMMElZD zdm7Z+)<*cp(?PhkNKq$-m6Ln@wli!a42@juBZg6I?C}834R)9~5gJR-IpJ^}T0!8@ zwTwN==eQGD;@NdYr;_;vTXKX^*qp^=@u+C@|waA@QDBdw7ue&8R#0^rChk5nA{xnRZ;OcuSWSbR_lBir@5(WxY%^DxP!a z$dO_6{B4FY=L6Y5;C*LY7ri!s&thpaNoYmRxs1+`3?=`%G5X7@_C4t}!Gi~}sbbfz z`L2Y`FjE$pQ>U;_smJuzfKNrRN zOU_N_PVL@ADlIJ{G7CugwzqFUfVmLqTE;yQ0H|wg>h7@80?VX$;_pwogN&LQTERB? zldems$c(p4#Fyg~1mH{}!iOVXz3Q7bnFL0bq8^Otz@0qt=!Xu6p&(^CNVh&sYI>#rxp2MsRR$sUf7%Bh!CG8>$YiXHb=fD8T7wG*; zOVa?JCT%iL8SO{`(n;B5WNLc#s_gOOGi5sLWUENTeIGw|0I#8c&Hn3 zvcA7f>}_-+7y;JCZQ2 z=z|H1gk1$PBy^H9=VwTEkiC9w1V5f9!MT5b1O2|DJ7#1F2kv2T_-Py9c3_xws39ouHTnO%P8 z-KG$fIu<2nX#xTzmcq}F(%>)$1dfOF_PxLuJo&?;*m}pzz@UugSVYkwia=$S=uEWXC8zB^c*n$jNwdYYU zcpV!{`|v1;Z^7cZrY)aO-QD28!7V6wxZ@;hDL9HVGWL@T*Y7{qSX>}gr1@u$76~eW zSXTedxhX#XB7uVkHQU-NiQeC$bE3bX;Eqas2PBwO&YwrRkXLKh(#EL_CubD(=8gPm zDBe80G4gUqYGO}?0u-w=A7!932F8Qy(HDpU3L%#dnzsPdHzM*!!5$0|=Wek`K`N1& z$`l(Lhi3`An>JXS`>@?u*Wj=@meX2KOkf|~+J;Oq5fL>uA1tjk1Du0RjFMFU90!OQ zo#X6>wwIrgqh##Y083}v)~&!z9FP5N%G}co$aG*}RP)J`RYODS!uAu46=+I5XJopR z$>nj_>LtiGsGe?rG;<>ICzj*eTK>SRSP_X%=7j`{h_JBBN=jwGvEOubAX`I%Usv%B z#YZ1DXF-f^e6JG$n6li=1bJxPrJn`WTUj`{xi#qD3JHvgM$l&eh$uoCi^lM)xHxXw zwWm*O5-@?RZzan``&m1|r}f+1+#D6dL9ippH!y5w+VGZ6Qmga>;Kfy;zHEE;%y5l9 zfseXv(+A!phtZ=#T_NR2T6zg8Dz~nN43SKorL$Mzb#||y5I+HRlqv`9K+PzFQE6#u z^~Xg?0QQPlDu9iTO3Efz(=!}xMH@VNf7bs}-?w+~)vK?jxiv|STTk4Bhhq^&u*>tY z>L4Ymo;{m%b3PT$2@!+{4hstG+qX}|Y2g_(S2Mn{I7hUr`eZtibba_K$S?FIa>r7? zB!t+kgh6>Ri@UpvuGY#~HMy8{bxo*7nl(w*x`VX^6%&2p;@=i56=eeG70NB zGD3oCUzWwOD;?7)4$(>EFpC{?9y2DE6_MB0_qqEbjI=S$N1(!2+nL0ba zC#<^j0qZ3;3Bu>iOxf1e)PNdz0Nsi&Zuf= zP-#t?*?%jhl=>$R19B_9W7{?TTTK_thtZcK2#chB(`@pzJNeglBz=U7ZZ=-sJMhL$ zlk6GLb&E^*nUO#@+wmK}=5m^@Gi|qxKYH@C zr?u5YUthv_f{}{KYNP{7e{Sorse0A`R@*}q zMn|C7Y8(e)Yj^v-C=cMF`7dwKw9;mpOq%~&cF5TNTsRS20kiz4L`^IW*Nj$@yg z=XO1kP^4q$&Rx%)xsF#y_?*YSnrsyZ8Ks$o^??a+{xCK|DZP7>2aEnRXn(jd_Q;pf z-~nxL%geCeMmjV+p7{Q`XX>elGb!pfr$^eSP2UhG*7N!o>fO9qg!-LE3pF1l&2hp5 z;jK03ggzi$v-q0}utH}nt1^B5^a(Y2ouLrgDtPiIjxpW;G+}ZC`4pkA&M8z=LfOHf z?ZM^nd{ta@%PiWN|5QRCaRI({-7<)$w0w5Zhy6(1DnP{~p`d%+^6(lWW zE&@o*uBM~iN=Ns#`P!Q{w5-pOBZrK5{W|sXd}>$ME<#JoX5<~)<^TUaFsFOVnO5QV z%qF6E?|$(kJ2nuITM&wiih@M+g`APJ2^m!sm`%GP#J0A`3m-1FxOR=~t#$uX;BRUl zt}^NIZC{JD%5+qnB>B5#(7_TaXGPWM*jWDZo5w*ddb+*w^XHcU|AAh#4cj8)3A!Q> zfiR)K;sdd84k9=_^>=3^&37+L*``up{%nS^9DG{QmHi&DGPP3JMAc8{Q2%qkZ24QP-z_frm_gOjQW%@AS&IpXjRr1c5m2I1_-WJn0orLS%&Ak~CYG zBS*rconSlgtOi|TC}oO<1m?AJwwkrKYdmjnBXSs@z9&%}8dH7b?M<>nw~++t4KF|} z%L77JuwpHo>$o)QzJ28;!TSh5!4~dFX*Pp-6RXv~H8tL)e%r)Te!U)7zXe6x@gBd* zsRR^wxKzf~RA{rHOC`!&V*RujEi!;oM8_?GR_5WNLUXuTL1WU;rtX9tyLORE7G#pX zdi9Ec!DwTF>-^4bzDYo-ofEh@c)7TIbDKdH#C`7dlWDh@#w-^RJONWnoy~uGn%nH> z8!_i)fR$uNiYblpnsdi}30_B!mq-HUlT}dXTCK93JSQSApxW15_qVwH zOqj1HoIzXRW>V5SxhJ$0rNK;>(8TsEE07xQDYI{OaCBVpBfKc!VNwHK2a0lYHw!{! zxLNTmt@F8%3IwL8sCB|M3{7!etA@3tZbwwR%>Rs*6M)*K(F0yd>z zY#}Ru$^s4Vc&)16W@no)Qd7FaZC^-aBzlbO<*M8nOg^5`OKY2cO@Hes zR&(|au>E4+y$MsEoapc=63Hyk-;`WVOLG5zJ&k3AvO>Xnf}E(Fv62Q#g_XWkFe8{; zx7xHx9(1Sh`wTzh>*`7js$y$WMlammP{CVL+5YJs7q!c%{U=WFM|p)}HEl2$LG7~H zocC)%!RoanB*xl0+Nk2=J2YHAA+MRZ*LO}uCF`-}7QyPeVl17p`}t-j-!mk;5iIW3 zFP@xx_sYnhGA@5bMZ3&DCwU7gywgPqg!9w!qUJ5hZ{7?#sSMnPiT zef9k;2d!n5l$4g;Zs@YBSm(T)S{|$a;{L&QCdmNR2Ds)&axC1BL4~-z+8iRwcRv9P z#R%`W=4(5tkHb=ru

3yDICB@}n}nS21}RI>@fiwfz1pMe(G({Ka?G>#~P84?~yk zNIh6h$q70r${s8K!16-Udst+c9j8XPx{~+&-7~9@TSkbs9=@uo)g%P7K8`FZ_JZd@ zvtNX!)?R%;!Px-wxsQ8*b9DNoa3v8O+^|IHTa7KT1moT{imEBvHyj+EJ$Z6|BClvl z%_7C&S2Z74lZBjy=sew$I(pO=_&Whwg}R1^=(4fS%>M=t`LzLuD?~2SNm468NH zpI_2K>zWs<=w_fHg{3JcOF#63hwl!45%qyVnw6ugc+KiM3>DQ-RZ zedN^TW=y+%q#PvspCt)(VB}%%1I><`zRN5r7q6irs5HFlpa4L(?a1Fb3UE~FogXiKgG&}T0F`{H#wlUUaR|u9?Gkz zu=v7wKR>_3E5#G)$*bKl?P*r?uIB5^;#0!C;vk{p$BqdZ{@C67=~xAt;=y1GSO`BW z*MD65!DQXNJ*U&}`uQOvb{k|~0bKoLJUrGDRseS@pqM^v7fE>q1=g*pp$Sb-|MpY= zLfwbMkgQM?wi$>;tBP<_LAWMbS)W+q@4wi#W;yhR9>J<@gVy`w1Z^+o!Kye0+H^W@ z+OF=Dstr@4CE;#d;;!n2gAK3uzXXr)vx4X7~gd_Hxcil*}>CK>?XU)NZ0zX z%VAu80h0lwcRn1syhLn?x_|#m`@WPYR{oKuC&fVo^|YJHAU(LF_L7&UCIH$NI&k2w z6o!1dKa~H@@+!DRW^c#1S)!#zrpq;evq6^>Uw~0 zA87_(WMEwf>6BQrE)cGqmBg5s)<4e>GwL!PG1k*-kG+s6M!)~|?eIH}mo5cI2VOW? zaI>PRMRc+y@9Hj{)~Kl5|5^04i;0b8R;-8R%}N zUN&my=A|UdP)`rTcxn}|Fwm5HpN8^Z&*!qU`+dP%4_wPe4R)ov=7#-j(=N<90aY+( z_w4NGa6P&c3oH8E{FS6{+?amQEPYR^89E3cuTiujHIk;Fsbx;rY0ADeHSlNHwSxgX zAf!AE!4R_ha>$`=qJNIayelq%7bV?59|B#f&_CQj=n|84d)OUvS~-|%2e>ppNBl}9Ug!c_jHQu))wJM@0A zSSra%Ljcwucq*g;8RTn^;*s`!!(l6l3EHaipXaH+crxY8PTn&xFi_8Y?6zH7M`u;l z8}Rj zqq}A2Q>csGU2Y=gqR{-=y$QT8J$CrA_UGa`Hckdl*O3XmlbSzpqi~TdbsO=6v z85b&+OcOO;T5yFLvUo7;+B)K=Ua{OIp>jU$Z@FF2i0n({FLicyN&-gq7`AVhLN8tG z$5CSfP!Hw1K>W#4lgoNCe9Ty35tL=oH>3T*!3TBYyVMrK(0O#0U;< zc$nO%bnw5bXf&F|5194^0Od@&TEj2a%IJ)oQZv&k8qCup3(~Igxkz z;zf^~6|4sh;2L_KRx`M0w9gl6BNbFt$;9(8jR^9zNRYP@sI@C*%ew5;xinHC$j>ae ze!FlJ%1}&p0W1O|;Gb}N!R4v~BR>*$ePpU!RX@SZzC+}@bpBiVt1=l`>_d--NK6Wa z?d4C$@Hx-VO08uU|CK7Zf#vHT3@Sj>umySgon@$N;mIEp))i>scVN3*noR;~c_0wb z8h)0F9h)A40Rf8o>l0qVIM?<%u=8rMH<*-6dp zz5>sXac8;@isRV)8DgLNRcgRKc`xr?kD1NBUy4Y3y*PHftgIrpxAf~i??Fy~HR zLx$a|YgUY%EW8ZyT}F+EczEKm_E^6}!`W`_y-!uI1PNwlEc7Y|&mPdZuYX4S1vFOf zxkVG~CVPgPa!9d)JfJ#ccr6RdVEBnmh_v*^WiQBgqhIRgUTvtYZ87uhP*S)jlO15X?X9SzcBZ$d|iW@~V2eEZd!G9uI$=*GGLn@>y`U< zN6FR*NJp6-C36lOw$X*uob8Y#K|tRwE!9J1ub<=W*u{5NNZ&NWUbMCC=24&_B$y9l zO7ig$(%D4}vI<=JX2l>u5`XT@nI99U)d(bso$gG%4-R6j@du$eqBMZWA(8NBZzi6P zj*KwoADW(}l-$!lq9>7c0V^|3`*Zsj>JrY!sbi_9_2$h!<@(>lUi|u%pJ6uvYL#c} zv$=WFfE1^!OlVUCPSx+8W7x2faOHR<2klz5peh2Kk-B=lV%f7AlG(|8r?IjVh55=m z3JVL@tR9*jo#?+YN-r!tM!3emC$HXduXA;>ZJ;cL-yd$IlDqZ$bBqA53OH0=S80-d zCc3XK^5^4-qS_DhYqwzL>&6W`2qd}TIv=gyUQLv{Rd7Wwr?cCS3B_9P=i^6a|0{Jcu4_FrJ3R}?e@onwUKwn*1*a=r;< z%%n6lXLvI^>zXxdsOxBrbakx;=8pMpW@378TP8)&{~nAE=KYs%-(JJt;@6pYwVK|w zOGutkR4h$X@dBCLq|Um!y0!&mX;B1lLF8t+RuqafopC3QPj=-&2i z+n$R!ZET0+75Am24cUQ-omhInI*lc&2M^K{HhQN)iz>_l#E&p(3Q|=D#+Ig1(jIj0 zceC#ad@6MKNdVb6B*XZO+O82uDX1@gxO(Uk-!;iB;L}0|rA<>0eH0Z|%)7t8wWa62 zYsWY0>MV(ca4&Hg@!(ZWz1Ak{)~%B;t>)$I7QU2lEr&S%P7t>38j1|LNl^$A(av4g zPXhv;iCa>~V^6#HGhbb!+AdY?O$`_*W8aZISW@?~vskkU*Ogu9OKUS3P0(&_!8Ggc zm6NQg>BO$D?^|A(X^A|sRhS(+{i2dng(F|RvQA1|M@1!lNZ^Vs+a9*3YO0?YEmeG+c)a#Xe_KEPVD+Xe_Z90OtR@Jwnr$EKu)~TMAh#^?!ge!bJTZ4} z-}G$sQo$AdlX(eyGC7X-RL0l7hjf_8US&l^#WZUZ0$39!SxMv@cccod3p|@>g;;C;IvL`ETo1e%&Hsef1z8-yz2i z#!CqX&9}wuU!ZZ|$tXu$Tj-08H9nq5U|AL^md*EH{F&u_73~&2wK}0@kzItgwl;Sr zfu2I2xh^q#YzbpM6!^GhKzz%JW0JA3cdkYb$AFE4aC298c~&g- z+L=Q)B`$emnxnm&WQWlHOKd(zT7<2~!12j4`f1u*)gL8$0RMn$UG>qUeYbb--YtApIm+9+EM=5lN#4q;0-B*D&kor)V7uO48fM+uneVBO zpFmy+lkvwfOi5JYubCX=xs+a!X{?f7_$%d>c>*6{lP9C`kC$sMd7F27UKs5l0K5^= z8+i#*{D5bzj;=0Q;U7;~$9F1sHxH6W*Vb5H1~vS9jc6|M*_LLzyNgr_ z32oe%78)!S_V&FY)rz0mQv9shFTnO&)d#t$@2d$20;x`m;?C>nm7!&$Sca_?;o&bH zbp5PogkC5slGO{kpXHamck}x{|9Z+tK0X50-=f$RM#3liz{zlF)0KgI(%BU^x#=&g z`Yh^p;KL%dHTUk{4|}#vK-6c`=3;IxZS9sFe;d;duDEd3tcA#o*$Jz6y`pyCwx;hq zbf~bXoOH!-br;f8`1ocCeZRID>KMDZg5G1@?>aQPj-dEIk81?Qy?z;X;{`Xy3NZd& zShHVS zqn*Vb4{Ip3I=`P}P*Xb#0tg1;?uKX*od469wq^WU*ApL~aH0%Dcj9}aN~vS@X*Ckq zZ!}}&HOMA+|E~|8#SKH}tSni!U5NVXj*jzm++6)>)`Gmel3TF0olElrt#eG>RG>hH zQW@%0Y&hSrRahnZ>_kuHuFkSu%dR>q_F{^5zGpu=6pE^BXv$InaTS0##r5q!DYojUaM)yQ<+y7mNJNECcmR^#^#q`jjLl`;FdM2(G zbDsNbMMls(?j}-Ua?13FZd9Zq$5oSyq(c)E=H}O>kL9{h$th%Y4~RSdXyYWz%{yQp zSCUtm{f>aWoP340 z^t3#C`n0y}`+f{Zw0{d|4)hH$FulBS^JdB;8ydFkynQ#2b+sVF#v`A;MXl!(s94G@ zrLONHdh0B7!eY%r8lcV(xQG5RzF%MLP6W&w)dM=&8_7@3OFw&iog&&$if&0UWzODY(5)4ctFz$@_j_#e^^ z3kypY5v##hF)=p6tYJ6jDF`!T1A)(<*T<*~hE^JfTCAj$j(p}2r&2s6FF!JZ>W_h* z$ER?J4(DmSzkIeim-77i^I(EKJe3a$&#>zsGSA1po7rDMekr>msmycensWJZMYI!w zgs!`~#Td^{FcAvcBTTNE5T?G3%ulG%|4uLUOP&QDFx=_fB{qwvt0*7y@@D-f2@A+B-gLAVNc8ml{zgLy+b1QDMW401VYi+^{8K~2 z0&WgjI)PVTzNw2(C-j|ByDO8(2YgP*A$#V>L|@li7ZeEYC_L#qgR)h7v9YeGT&H?y z-qK=cp+_OU@1f)TY>C>IRPa<@5swm>`$SmIoHm6v2^1OJ~)fJWJMz>1Xav~kY z;qI(U>0KQit9Iug?Fuo(r$Y>{-@&DNS?s%^M{q2ubDupK5+8TuH zEiDQ~i|mz=O=PB&%BYa+tdc?{Tc||#$llp|Wbga>;Cp`OdmiU>zUSQc{m1=y+~=SA z)`^ez`!$}=>$;xT^>4m4VY!f9HMKCCbshtqfdGGQ_75k(zdrQqdUsmxdw*`}yuAWu zYeH>#p$Y%Ge*JhKFTrH6p>}AW451Vglo!R{oG*iel2Ox~<}~G@8H}d-fC@Zuvj5mh z$<+s574|DSI`AA*P76b-kJCdq%lsOHnE39ePr^btii(1+S0OMg^WdV|p`W zgPQ8uKo^%a|JQ2Lq55?G!`1_|TO;pO{GkOP>^|jAu`%#bKK&U!A%ka>PQtd6R}~e- zu`a+MnvQld5qc|LbKUT_O&X-Yz&3D&hIc!{CcOu2A{r#E;7hcnIn`IXTI1-`&>3-B3Y)ln| z021TwNSkEZZgv8NQ`E=z36N=FOg>Q1Si~vl=TDqhQ-aH%8(mvqj{BN-8sDNJNZh_7 z<1Am`QNyWWPzrQ?mk97?;w-WkIEdt`TGX*-=H_U5hPy&0>A=M8<)g%M*thyW>%*EmoBe1C? zw+s!<5^2UG1Jaqw8MD=@QkNVSQVwS|4*~5UpiG&apEOSs|%DCVdRhq?o0k9idPUNP>~p$IEd|glFukJ9fU8S8Z-- zjeC87IH)1*dwA_*vtPb|mBh_pmXqg|NlL}Ys9yhalL8o<`;>I6)H*$oKdkQt{t4EUo{Ss=Ynd+a)) z1t-YDLdNCtastv)pDSHKV{cgf`Uh-$`UMinS_ZfZzJ1%?VKG?o9td-LRN3v@=AkQH z74A=}L>uz_kzawqfq@N(g<4#=L$&&+G7Av_a+ZtVym?QdTRs)nap9$_T!DAjs;t7P zS!h0N`790{IpV$qeMFrduHz2iy-xy)qBcwXPN*47kBozIg>8PV-d-823zdc+-5oKaW(y=!yK$qjEcQp`q069r zEh%vf^y2#C81R&vVb-OlC?E!Vpgf?=|NGSV4e50vq+STD&4B6vq+urj7^!xq*N`P0WMR* z^r=42p5^3xE70Op*k?W9Ulj0_0DRmK!+LTl@OVioZbR&c^F#gW*iVA`vgr0+th@wJ zUK!Imrzh_82MgO0b$*Uyn@QAk6pFBO1#2x84z#1~@2ih%jwG_2zKU0_%uROJYm!FA#IankJ=U)TO(T@Af2z&&ws12;D}LPT>qziF$r^r1J8ACF@UL2l;~(y)er zf^gHhbD^BZDr$yjH#%Wr++p6*_B0}Pc6`*|d$7E;6n<`RG5d(8pPHQP&u#2cO$^EV z!Iz7s@bPs$Jp+Axbl}gQKfgQVc8rVbj@B3JBy#Fv(szl8gV(Ej5abBiGLb=+JVnxd zUH8@FLsc=0Wm#D*a2}CqqetT{78V%^cee8vE@)_IY{}p%N7#BV*27!JOc5{;07nOZ zfRk&>^~%(r9LLC7Ih!i_*};m}=JPY-OSi}}fI!%@Zy)b5ZkPOYo7?X>I0!t(wKL<@ z11z-}Hw@%T4-%k|qT{=MQ~?{Fs%3~w4RVGb4X@e~@UT0N6?5!vqu8UUSm*Cg3nT?S z0)UL7!onA39r-@%+mtbHkH!*90BFgo#}1>NU~gdwEFn?Vhpgy?f4{Cg%&=F2g6MIM z)nm@iJyabx6zTAo-e(+hIJdukNjx^+zSWz{sG;VNo*uzt?>+!wUkr$ew0eP>CvzB1 zLp_Q~I}A*)5XflAWgM`r=UPeB%FM|vCIoN{njK>Wk4mKGKq zGN-p~_y){i5!p6qy1cz!ZQQsK_^_b(Z}DNzLO%uw4L;eQ;!_!!9lAUzd5VeeUFO@j z8(~qY-kdStkRy8?BfWe4{NVnu>Fl|4E)OFkJAN@;!jBY6%p6LV4e$>Mi3<3z_6Bm*SXk(@vT^`Fe2NL$n*&ub($uq?=o|#*3lMWUC|;go?hDVju_007Nr)~M zcNB5jK-ORATV>?{#?{%H1)yh0Fqj;Veo<-JTk-kO778YmGUjvHXOO}@XS>v56Fqp| zLE8P?-Zn(kvFTmt>y(tk5Rbf8fJc_qK-H!W?`O}7DTay68DSUgQ4=+>Ec$cj+#T#^ z+dDeok$ZjIzlA+xs&%qCZt#JJh>4mb=yU>{0Wm?F;vQ1^QBOX7jkyk)maeXG^Jb6B za|^ST!ewQ!;$sK9s&@T)O_H%_(#TeSxMiHt>HK74P6}KjR6|cMW$wO@j*iZOuHMQ+ zgFjwEAPh&nv%#E}t=U7vyqk%bx6cVcuBwR&p>h>(E<64VJ8?uQQIUF!U2FD(^z>_| z(F;IA&p(oOChEX^XVLU%mvY)f+WYsW*x@^l zX&B~}M?RX5$diXhu!#`=^!F#Lb=Jzosmx>h$e4$yKnQ>{XAOBLlh8XReFUhVlpNGA z`?4j@CnO|O?Q?p2#GWW%Y=^IY82ceBdM6*kYM7dr|1e$!N)X`1!#8j00q-eiSVAXn zP(9d(k{KqVq-U@oo!5*4uYRF{0ucVr$RgipY&Ow<)iLub4qSo=K;GfmlnLcDqxw|s z@m}U#w1QQp&*GY41J~B70rQ$QFuyvNYVjW5CLc(n$Nv3H{7Sa~A<@@!>!xx{v%f3vpYzL%7! zrdo`Y?LGyfD`O@)2!dk8x(?WX&df|#zqw3#5b|^(i{Tdb%s}UeGw|h@P@bPB9ahAn zAm33aEhFXpFu}bD@sy%SrHJ|qOI4>xL@EB3CC*KVW_*!r z-FPR$yo(L0PV2`(_U)&?Ae4?7%7BaaJs5y68lC=YXiy|R5{j;s^& zI%6hcvrl!`-<^nhE8Kg&vzJ&zYz$2$uG1XRr#^nutsSuQJv1lpxL`BuNypp1!R72e z7~pK*{Bt`@w4f$~$c2N4=VSubM8Ws(u&%rcJO;B+k1=Wkt)^cD z^5!1GNB$8Tk=OAHe-(ocUmH&hQZwAyhGk(cphWjL&Y6ZoPz1bWnDKjl;n}pO`+N(O zKE8wO!ui%e{k;G5$@L0jA=Z!QcWUTFog!W$cX3V-p6`^X zZ13!x=r0qt)0MKu@g=#;Z4~LOt$TKUO{Pr__ zRrA-YUvFKwL0lontwV^{NlxYuuz7J2kwh$xPb&zesmc@o83VPJ$tO?J`l@2c@$JN; z_WkzpIMWu(w6Uo!Y;t<`EK!1Gs6MIrq0gIPcFDhgNRy`!EjGoKrW` z=1JGv+k=gwqpdw})?0xC_IOncUJ4$aGqVEI?_jx&;+s5s2KUR*-;cOCBvSBf@kLCG zyCVzn;ZZg1Um}8svI}h|B#j$}<#BQxEU&6s=nP=_AuL2Zx0imZOaJDl!Z?YihsVM1 zB|{jf1C})$cjE7Vq9R~{Y>_Wj(k5ox8gk!ic_D+Db2KhvCOv~`;31a-!6^qumcWuW1s{t`gk)c1(nXWhjm9`|3#Bv|aamoADU zX%?)OU#3Rjsd@&?^nd;#CI&n`L%8-cAG|e$^aYZi3IFL&A+wq+uCk)kBxLZv`Nu~` zQT`A^hW_(!eDkQex;k9xSri^VdIU20g$f$^r9TM;#&egK$klEn9u!p3Zoi|(k582@ z)wY#F_A?fac6JtHMqKfoEPYj?aPi6=@0%F%be#UBJ=z&k62u#KE`a@f8Q>GE6DM_a zntqg*A3Shisy|+*dE?I3_I6|mt!EY%wnwBz;gn-<^_#ANw(yu3(lb|TUMeM(`;9EV zPfB9qGojKaES()ow?Y0APtROoNIcKNIkOApJeNLir91I{x=YDGycE*cbFp7Ly7>Lc zU21j}LU&b6TD6;>{HwDE56RQg(9DfrUdu&CLqjiM7vV5JBezV47M~A4H9NiLx`Bb} z!T{`1UkW)c*o}2_m}gMlZ3n~va$1bZZl@3_0!J-br8X zdk{Z+v|<1Avdl$?1VElxXW@Z8gFh}@kRdvGn_b?v2ktP16vM{l5qgjv$N^hP&b7En z5X~JjZkjWXx|ZtQ`zwaaDN@>Z6a6uogSaE_uZ|OTXpKOai2lZvW%UXASYPjLq*I7l z?5#E?h+8KC?Q$6F-b_IAP$KFZnqxi8JPX@#Br3WSvF*wAzpJS44TmnVX$Q^C%+99S zrL25%`eilQ;lqmkj~<-RM%Hw1hP|!l{{67JTM;ZB$gS0D=qSkK=Hi;2?wSWo`Phv{ zq#s3uy`4_zzLi~CAuT24&;QlS51!p3j-Mq!sdMXL~Jqvg(lA$UnJ zfB2g>Y1(~O1_lP{vVUdkDEN7KY1VZVtniKAn$=aX5}Yr^^;Ev$buvJ{lulvP@%vkeStJ#Eh^IIJ3xgAq{d4Nm zA5a+upXSF@Hi@|PWjJOwMaCaUaYKxgYqQV z%Mjr)!i9GUo*z3RCj?{L{yvVbp%FYc{8_a?25hfH6--t1r3T>G-f7c!y_ zpywnD4rq+q0t3%`(L-sR)m*X+bT*0pZ+~K_jdc5;pO+18KQ&ZqU}Qv*_b2_+L4l_x z)>Vg@2z}LyW7_qJjcK*)%Bkt6N`j-*mv5%Kyy`kbeq6wHbf;&C>@TLR0bqz`5-N_W zs4$`{b8sNBX8$XNSQO{}{kh;?(k%NJKNtz;kBp3n+}iWG;mfXl`zW^jM(%L@gjA%N z*rEfbF43+s9yO7xd0DEtWN!7hk9qI_D{JlW4^I^?9SN$Y^^q5LB4s40A*iak=1 zoYyO*j6<$sJNzH`tWSSO->JNZs&36_7s*i`9#ad8K!G9#Zpx(-i(3ggbDd6MTzB{! zR85+2m)pJj>z6O9hTg+5qqDvJIZ(hURm32$gn5e0tXq`dd2{gCu^ZRb)Lbdo{iX8) zQ(WI;#>UttCPWvKNjeIbL_Kf){Av;K!?IKOR{OX?HBjUUCccUn;-mz4!%R+2etPyUT(u0s^uReT^ovw18i&(K9xMLZ&ao8 zi%4R);DKvRZKmTQZn@n0o6||n5>;#Nr0D&S-NB~lmVb2gdD(8*B#D@mzQ8%!Hh>1! za3*hmR20k;aJdsrIc(!Teza&xPx34hCgFCTvKxb`DTpJHy*-d zV^>jt(zR=nFKW#*h+nfQ1p@-mw^1_I7;73pbAPY;p@#?7HI37qnxmxxmd}FDqn}1_&^&BM(yxvfT*Bqr%l&w`OwOMM_(aM79TcIX_2#sK}t3zvkX4CM) zKN#B;MJ0vqD^qBAabK>_uT8XkbUsEAY-hHualx}9gX*{Uw7x$MC8s`;Be*Tq^thB% zeu6Zj>&YWr`Pv6BmX_^!}0pscq zeHH7uw=5N>+ClvS6|d!Un;jG3tO;6P68RwAjc@ilu`4Dvq*~GublTyZFJQ^J$2z94 z!48ryy93}F9Og{tBP&$nl+#`!nZ>X%b>9554%Z)AfH$zImVu1L=4^-+NPh^aH!_K= z@_FFq#%H$Yb7duF4$0CPL}OKxG;=3_+AGD`b=oG-HlvNcSUMZE-*^s1hq+2Cz}jEM*3KE z3zV4QCn?DOwp73zI?VK(T6C(-oVV&ZE%61qA&fLLT)ecb(e;LYVdCPU%LG@~2E^^T zM=$GvrmDVORFXCr?K}!`4;ckxd1d7{AYZ@H3a>OoIZC4~;#O7@cL3qOQOzXT1HKIV z0=!Q`f~A}v^e_YUiHtIQQj$?mmV43JROR~QkTyDQ{f$2GjzO_Q_^4lbt9tN&w>hYC ztRSc*he>P@gbZ%*WvP2#l?$OJ)pC}ofKp~XY}a$F_9#2uDti{uqLJW9QfZZA% zxbo(QKH(bcK$oQwe@RxBooh7M_tpI;=VOM0He1hfat*O=(|&w+bsT`DTLQ|pkPVs_G#))cJY@@W+14EU6uA=hrQanI$X5$k{)H%1)H zX{?5i5)*kAp1_6~3U7EUeYjl02uvTZbRcoyr?mknW8OPt_FP)uvmZ2*@R_zw^%ESa zsjCq;@?rzB5;BddcR0POc0;IH7%_i#uBb(Pw6kQ0SYf)l27!lwupem>(z=4kVM}OA5Zthxh?PTp#}o)k zLuSTk6>J5P94liPnnF)eGNmT-<>q`t|JmXg5fyd4pz|Fx>5w$pvw5YYxFaTkw8<8E zEWi&7aLOhmBoO&P#bh-H5CQhH<6o7k@?yUN208CHHBSa!lz=0{puXw|j%|>!_lRHf zr}MOOYR%+8HKp+>h_i=Ogm>+_2^QRYG$#Isai((bbzN#)wbA^x6NXo=bSK^r9IgWD zo0`gZN^+2sOL6naj~>|vkyxsw zG+{-~bMQ*4mT7ftqd;A)IHpEAkcD*rMib=FcX-#Uq;(E{N;9Zh9UcfASe9l8J@b+v zESe}j3eISP6e;wnpN+AVlVfRb0+cTtO>}>yhHj$61V?K}&y(jC>EM{6UN7yi8}K|& z!LXircrw54GLfq^aq+Rt-Kw=wz4=9eQKhmV=rr z>HtbZu;<42Jv}GOcCTL^!Rh$ZOoC64sADV?G}Z^5y8zPf5mvU|SQ zJXwEpAQe*}`F|etI8Qv4hz*$nk@jdmqk{3vktXKfNlX4f;4G>yb`jRloG2+j$m78YiVlxNvr7TcSa=kKoJht(?oGd2we0-36LV{UTNf@#}$ltaj zId~37d&xZj6iXo}<=Qk7V?d_v- z3!!X6X4{k?9*2d61uk3`42NO>kY!iYWd()RVydc4y?^(G5&I%}_aS!au1zS)mWn>O z1wq;|ybmH~z1IyeV(vvWQsf1A^N>G~2vxhJZ_w8ga^av4(D1m6Z=PWs`{}nwVPRH~ zxMC3IZaxH_k&$L7=hC%5e>UK~e`D3MfK<){1K2R~Jtde1p~mUwDG?Ep$okd)19e+? zf*%l}>U#S6t>-|X<7aKn#K=CeXaBgo$L8dvB0s=W4j<}iSlBN7#0s$Pdkbq&{8*0i zMA4|wC!Mp;k8a+Qa*YDHuyk=3F&=v1!Udv0`5fped<1m3p25P^Z`YsX|Fh?J0OGnzu!gD_km68xPqt5`v^C+_|-{(*peeNGuX=pyagH218gU+0) zdE!mFOQ`+`YX7*r>Cygat4BM z#9w)1_-EMsn&DV*H-xuuuWogVo*qb&E<1l7=TAMu_R27qjy!Mg5C=uawwz7M%8jrp znwchpZYMMl|Jx)wZ~aRPt zaE?3Q8ETl8hn^m4CJ@tjxdh@QfFT9WF51nOy$v>>oll_1&TSq+#dR)}t|UmXI^s+l zrV@5+-;TgawX7`hy1F{TG45lu{{9kJNFQ$0SHVs*6W4Td@@Y2Tq{KukGqb^_Mv@K? zi1qPZi|@$x%W-$PFJ?7|@I=2cnBdIC@ENN*ZX+oBuDMH$69Cl=I0i>Y>S1vtggT894RdMIyqivJDlZUY^+Lsxf)0B z`b5JNlb;f{wwTu2S{2tkRe4!8R1j`)NVB+NIf@O@k1_jwvWfOk7s?ci@7>#xKDWwM z&&WtdN=nGCyA)p|z`rRWG0~%{!ot)v=vdx1w+2X6g9X-aKC^zkrR65-%a@PR(lzH~ zXM@!zFt0W;V#FCJu^)VJDyxR3g99VY%*@(Al~061LEH2jqKh^gOi?Bcb{W_GYY*EH8<{zI^SDX#?kFjuy^m7GY=5{Hq^vT zqF_)+qZ(o(keX^O>!6}?D<{|=2|u$FMg@wB) z=y*0Nhlj?lWmfySOI9{6I)ImVRFiE7^;QX3q*lk0!_Hh(0G6RL($Yoz*6?n(^}c{} z*xdZlv;#TDn;sQ2@SE{zwBf8>i;=&LrLdAll`^kGh;h%OFu)O5*Gg3&!(ZMq$C@B_DKrK6AKGkQT0^>iPHF2hR`>Zaj#fMW*9F0 zW{L{&rCrO;ZZkD2=?jC)w%VCq&-^hANs>b;IyY=!_r-~XbXa>S!=qL8vZ|`FRurY! zam}&dv5gjE5s6mVrMks|J2towR+0K*sqEP|2<0+C;o_;mg8a3m4GrnHD)Uj_-E}dB zr&pvm6hJXoKlNhf9xV-paw5GOfQ>T`9wa1qlEBHp>y-@q#^Fqd`Fl^FmIn!P<3=Jl zENBNjdBTw$D0KCm#hDkkZ>z&Qsl1%i-Q9S8u2Yqb^|otRSgXqy4U1DJPPmL3?kB1Q z+bk?fVeQcX)wS(R`+6rQmq$XvpO_Koaw|Cv`PqAJR0l(JMVbs%@tcDF2`lvrX8FTE zzXk*Zz#!j#s+0xMi=<@cYd6uZ29JDWJlY2_;1~%dBnvTyuxB-=T)VJk>sHJ88Ox&+ z+S(y}4njwcSaz2V=^HR*-WuQFl$IO#?GY&p^rXs{eQO5>zC^Tp!vlwxmlvJs%y8)O z4lZCQKGz z<44oX-bWXZN8scthixz++psgh&yVzlcV{Of`KI;6<+A#{snEl&5vkMc z_gqN7;(*2A#DEfBLE1%SsIphV5pyw)Y$IW~&9e@Y?zJt0ow&}UU&Uo&&X`@cB>01H zhn6-lG72$q@t@zz8laLUfSpqMq^~V5?w|>ma&z*6?rs{3O_AOu&4EucbjSS@Iy-l4 z*|H_?%mcdx9YWuiF9QRwBqCB$Z19$mOt_xBSxsMGinXYu1Ue&PM4wKPKSQb^|H9@! z9X;~LzZU3GP`tcmq^9-)&jbHQjj-?!A13Cphoyt10Ow<{>A<`y^Atp(=mj2lLC=*y3v4 z!K~X-Xk8eEtcQU!T#i$mZa*`CKhsOILUt}y5T9AQiIS4iTwFbFWj;Jdn644{e$lge zlC_wfd2s(eos)9f4`6;l8M>2{2M`%xPa~Ddw=KDC^L7G|Is6%~gM$3#R%j(q#)=TSvn-3Aynl&7c! z6ZW0s96+q>ukDADau-t_9TU@X>3Ml?64cfEFtQ?f;)K!_Me%m{>x_0yuNn^Gb!&MGzORUp&T>p?*vz+Y@V{VUSLW3V`TkE_t@m>{9r zRD=m#8GHbM_s)5x*_tm6XAf*kOv{54F*`fw;0%#eu>;7TACyzRm|&$` zQ}LQYZJo;(Rx2;q2y@At$}KUzefMqzYA|na1v9e?XD#5sZKmQtBB{gAukuOpHMh=L z#X2JbkS2`nCMVYzXRt$s8g8XN3$L7e8>e@OStw{pNf8YTE0`QBPEtp_8mfIK(g2_B z4;_b?FIbLtLaIsvmZYnLT5JzLKkGgL*rM~ZXA*YB2hzu>#8l97?K^UVS2A&!7oUkV zYvL}$)_vWfyUn>`eG<-zWl30kb|LSww@)YO7kwNa7Pg9G&?pwo4DP}^VH!g&k9HX7 z>5;(htAEZWgRq00!ea6{=}FL^sHlpp8xj*Qt(-PR6H}_ta`GD1@YPmPzytnvM$??RRUgKNdPZXBkZ{@DqM+*i3#!!d}uV& z(G^plIDf(J{oSuW#j+dcU!B(ve|C7&s_=w_$}-cOMu_s5_@mznt=ol^HXLg>-0HVl zb@zJYHkZj=CVdeeULUXP>GP&)BhCsjB+;2&*yS`fcGhy!rlWQB^}-FvGCz~YisAs% zNZgeU8zL>7gPTCI5Bn~^n!JvYDLazvmAdA|tGKu@&V~|WqVNNYy<;MCyRr=p7J<&h|>A=()SFzdp8?TJT zjE#-G9r_b12KyIdl@?}!BfmPN85kOa9-JYbqk=XcEal~Yyl>b_yamD&C*HfH_{klx zu$<5HF7WZ~a--o`_1BM;4OOp}W56Ai?d?B32^Ar1axb$j=Ne|g4WBAdN66SI#J9ie z9pH>?Z{?KM-rfcrbujVREWxZ399M!3g2Y(LPI^WGivu*EETGCwiiprMlk$J|Y=`8R zuhrT*T4VjSqh>wZU9-P^GxA)#h@6Vn$O5Xi-qvfEtWI3CY|nUWXrcP&ishX51wo|% z_$ax-NPjYTqbrb^)?eD8`+se~_xt=V@k6@fV$)a;*QFR0(#>=R1(1=~o=t2_=2)e1 z_(&m+{_jgKD)l9^sAE|efpGh_bVGwMvl+0wy|*8cM7+|CHn{GjenZ;^HpV?abl)m| zTDyy<>KQb%@qUJBrkblI9i}_FZe-4FWHvW`hS>s1GfxJPFRO?n^v1VEB~=g|$16^q z<-BIW{F8m@8fx|(wl>8im^`lf{zRYZ!J|iwjEiq@OkgSC({0M}uY3dK<{kyZt*P%E zu5Xp&1r8ZBJKZKF-ykC%5&ARob_S!+`Bm zfg#Luus(@B8|aX)k20n&iVN7CzW?^CzkgrW;D)n9+Q1;d_1qIG^OOj!V*1Ip{lC0@ z$U@24uJH}^wQW*cyiE_qp{walbCjDfd};CuZpvJ|O!Yn?Aw^zZQ(r&z1Qi*_vmH8E zn8%Xdxp{bqQw!NmmFCnT_6w)~dWm(Coh6gPHzy7|&CPj{`gjxm?V?G|tFM0(^-fMn zNsyI)dt-Z>aMHWsFR_h1(5q0PgSF7>>DViMC+l<#BNN@Bqr6G39<>`e&`ojiwpAg+ zc(jQ3lt(Aph*oyJs5c}>IXSmv8~NY?hNE1_uAve$IUN-rPfnAP>#=6dkq6Bg#{slx zyyQO{6P>!grTcvY%khj8UH@!zw=lgcEihn{^k6DcPTfN#c4^`^U<0Qo?}SBoE~yzA zZDxqysex`t*C;0@E^e_iz}SPHm_oi<6BdWKK%RMf!x$ARCg;=EQ>le+ZlHx!*gma# zf&+bEBokzaYP!Wv4R{|EaB`TP!KfI^YuQQu(7d_|MP~mhri3inq(5O&Zff{b#YzIrV_zvm+a}u zE;%t&Qp|5{q9^w*HB~_JrL1|f&FD=ouF>a3cCPP3G;C)lZm@agc9EBIV?1nfd}QrA z_Crb+E%!)5@si`#^Mf!q(`RK*N_zBnUkL6qIoXn=2M)#IDs}#jiad~Bmq3-BbIxCD z0|!nroM)o*?TK1?RH@8+_woxI+yX1pX-tede}_;R1(I)dXrR zE}nBa-Tu-QLTJ>|fr6^*o^*EV3^3&q)@|5;L4KF#BdKjflS5sPE+W5qQ$r)n%WF$Q zj@udOdUua6RWXfeyz(oz?!W$`9GMHL16?tuKx43w9k8CMuBIM)H!@Hk;yArs+5G1h z8&xJ_!YpMw3MetRv;bVZuY)rj?Ce%$Pg$27Ih_7txm@_;VXj=fB#!21HCkoJ?&}#; z#ol>-@18Gc4+c&xS3n0epT(s;83gl}&PV~M?5=z)WpavtByD1H;2$>Rwq)z`Doqc> z@2p+F+H|+V#m|7C__4u#b4i)EZ73>CmJJbFubgNHbKLF&00H1pNV5FcA7)1U4OL)w zoi=@YNm}|*^)+L-?Ho=2^y%RSa^EAWFo7oLzz{y;xsdfQo3Ee$*@fg*>yPY6z z*bs5%rP?rWE*kN66TWZM(#+sw_Z~Fc>eL+TjgbVWpIy8|{eE049b3H4cyxdNVOG{2 z{PmgBr(YDT7{1%rF8yYN1!?QJ_7J@8JpO*kdhzp2!^*GTOBSRfac|<{csVP`UW9Vo zlD)N7Ae8v?A2oRpkVcmMF)699_d2@X5(|rK?=`jy=wG+idl5&bHZ}aSc9s&}Y=>~f zmHae$$o@?1td7n}>ly*ViEqSN*flxjk+*ZrQ6Oj|Cvl4e^9OZ%>svF72-!ZQy&WY^ z_e-Subk)ibwrusv?dg6oOI($DVWud@yjdsIfA)RG{6&gS0uD5ttxVTbP<(6VXfri1V5*n3ypqJWks*eXvf%sa%S-oT)_pvG0HU`XtuCE8b4Fg? zYZ)nVMPS9zHa{L79+?0hdo;vq71h%cJ>$D6XFy}NDfe%oS zRTUKxA<@{e_AsB#ulDaxc25o#+@m2Qo9&H0xU&0hBjN)wdc^@lU44R-K?cUg)sAh6izkxfd#&c+% zuPHk!(r(*$FV@2fE5R;v&1xncwd-&SJYZq;EGVJY^bak7S6k&9pQTPptgz$h7D`H9 zLYmbp42ViZAVtUjj<8d5a>%)TGOOiOR0dmx$i*xQb*Q#?6<}I(vY1@D+b2a&zU^y-UAZd@fOHOEe~$)ko-h&~k5R z1oiRvu$;tkx|&Y7B)U1OIe%zpTA@!}~7?5UjMs#C00y&ZSUkY8YNYh6cj4?7m4^d}eZN2-eUg zXXfL}uKl)sS6cZ6-Wv}e`}hdMg#$W@Z1mIvjR7gPm;F;y?_rQvS0+T}%$Z9H3h8oJ zHa-DS&Y>7ivU-h6a&oGK+k^M&ASn!WeIGxTn~Q{ung;1_CQJMB#HqfoUpYC;Q5uc@ zA}>9U?gd*v?PlcbHwJt~{+3WLczbIhrIQ@d*9Z3P6X0h(FC{fI^&p*ubS>euRD)k| zu)~~WFsw~dJHNP$W{5NqCYZj%Tl6-~P2Or~p@i+{r>0iBUj2CB1*gk&_B>>LgQctIF3Tq|0H+&K0 zEXYH`i`4Qu==>ju3h$1^3>4Js39A*1aMkxb{$!15PQu)g_i%`2fLgkywvO=pSe^nE z9ob34x6JCc=%`sUuB_tl^V|7Ty^pYMhq8j49AP)tZp`~_6uVTlusJ%KYW=XPNpHoO z72<$wC60i7IdWO#uAEdE|MG4W!Db{NVmL%_<<~7szos%TZ5YO(GbJ^MQ1vj1{@3>& z(GjuJO^;x>uimJE=Jw>-#P_Lahc2tyTlS7!J*uI(W_^7dKfTPzw=J%Dg@x-VmB?Pa z>kdPHIt@xTF5RHw(0Onz{z0YLA$!D!j>`ynSo`Bw&}@xwA;BeH~RpmsPm)2OJMS zFa29dDD!sj-c9iKxeUNX{2%u2S+`9XI;Up{dKP!(K`a&pzu8pjW0vMYQImJ5&eZq> zOQH|3Q*ON0+BrzV(V-32SQ;feub~?;vzm%wyWi8NZytPKb|CAsYPj)54751 zHWrr9DQOH4+CB_A;)J<`IFq-y&Egl1w2A#mV2+ScAh z$;7csaF&qG$5(Ut@LB4xEl^^j8y5APPQ@mb+lWL>+fA&255}4zkc16wbFm4VDv}9R&b?&A+WOMm7RY=sEQ>I5U3`Ta**P1wB<3OxuJzGgDlb33&5Vf@V(MilAngK!NT*x;oETjT zGJtM3&ut>8W6otHEiHZF!o#ZP9NiTE#r=0@c9Kctmg}S&V+<=hyXWt=Awb%Wk+URj z7cQ54uX!|CQ!5kudiuD$G-?##-+gjdA&0pG2d?X#ut~Y|714XT={BRcz-Wfwr~LYr zmnPtO3)AaA;kpa2`56cI?)3#@(|6LDde=p{x;tQx_4fNWR)(FQ^%(GQm_!_C?L{$`)2mLWil)NkLpebW;^ zu9uC;rgxU>SELP`Jb99^(gdDfIgyVzUy+w*%YIHnS5;ZbFCc();4R8OK*)jWLB@ij zX3o^~k;lGXva-$Q{Wa%}nN*pWR9z7p_-lLwG=s^l92H_Z#S-HBVWn(@FvPu#b`$e~ z1KHmyw`(l#>*WR3$}Vg@oRwcrpEWhIb&FNMwW>U8LT_<>0ahu%Z5K+5q*ZzLef4KYJ zeLUtk)pGm8hhOM;?^30|0u@{HPF+^tz(z=(5MEKq#W~R`Y?bI`pubRBQC^2YsXsS? ziwd^3v!TcNmD)5G=SF1-2fiFtHA+`Pvi{19sS+vX24H-CL&vXz6l<+tCQ z=KXu;y8|OD*oKyl&fWVlq;gj*&Wnqa>>}n5ZctP_uQJ$j^hVv-PFRXJeQ;Uq{`qxy zcvH^4eck*15 z;=?GrJdtqPI864=vX6cC!vt+Noqzzpcp*;K{q`Y-Rj7M#CcH{KHZ z3-T{rWLW=S@4ROS8y%f&KIKk3J`AawL;+qTx$-VIOw zes56e85q!obJL2+$+UhCd*w zMKKTb*x7%t?GP&rJ3)dj?CUAF@5Len4ho71pctJyo)P67&MxHhvOBgBrnKwh5EIzl zUGdrrFW#T?8zZ6Gq7`~fw6!Iw2Vi7DE#QBwYznSA&uDY zU==FO7or&ER8NeTK7INCP1U7m__r8hQ!NhNjlR0OTTaFU6~Axp@qY@0E~_{8Nn%Qh zyRwO5r4h-356Ih?!z6CB+y{4?GYO>L9Ex>M*zQzOp{$wXvF0~Dl~_bV!ro(hz&*N9 z{X+1?)vH&5Fksu6nVEHq{1-b9?qlkPT7*C37=PFIS!`Q^RVdZIJ@nyX2x9Jp!s*sl zi^zxw55|Ivml#+7u4+DhVB5^>EQ}jYp7_?%_K(*bU{-1J(Ym@^+)tF4|6}Ldi)ks2 z`(|d(*eTbT9PKKdY+fX+Y?H4Q6&8<}DK!4_Jx4;HpLaDwXj|6jz~jx1i=>h|C?C)+ zqIo*v%;)+a+;m=n-pK}&u?-Dd!63e+C`13`}YxRKZ#MY!di2+iYgJFHd7L~m6n&~t>1+z3ANIO4I5leP>--IgN+CG z??qgiFT8>;ymCc(~dBBd~I0!-4N5Od=YRRud#Es1)Z4-|)wCLFf_} z=VV?%!SQzJ0AktV<$s{OYNQieZiAe*AG%a*Vd4B7tGw@ADF^|9TZb=SwW0d+&DOZB zC6n1C?Zra@q1i!Uh1C!l&6o1YXF!|2GXIqE6<*?}Y= zwXH)-C;XM~N!Yiu0b57AHI(rL72_dzpxefDer92oi5bnZ`~vx0#{5M6?o;M0TmBhp zh=-1*Aqy#Z3kwc72+yDAn4y;Ia7&5eEOs;El=v?={W>2sk%*@#7HGWUi8uh7F$%L2Me^ZpNCuOj6SmE#+s& z`^a)0Y|Zsu%~k~_dXHAE6N&0%KWlyXeYcMvH!g5RM*223I;^6~w7(x5%(y@*Xtifu z;xI|!^PXh0j)N8!aOj*KwIfNkExek}M@5J{22lnoGy{Xa<*KW&Ku}#rhvMFVRv%cz z=g-f&)z5IHcDCm^yO1mpI5{Wb1G-@sWCR~VG{~3_3gkd{kd9 zyIdw1na}EV{t11hYaAD*U!iBc9H)Y|BxBa-d0^l*=uow^wAQh7N4;X50$iBkg6pBS8mGG+%$e};Fz{PoL>y6Y-o z*Y0q*r$Hdn$yi|doM%&3|5XoIb1grht$$#mH^1Iv5U^OSVYpwZImJA8`SeqUCPhP+ zclsv`5>L9*CTMi%Bk~Pe$=0wi*K>6H&jo%wc7VnWkE*t|jyO(_NhvZ)##R$Ps@jmC z1fVmJCqlngYR|}M1QpG(gpV-ExnuN8wdED?;0y=S?8CzWjzEn878n}tBPA+MOoLCb z2Jx9*Fl@Nwx_;Ao5y*p!Zn_ihdD8ssN+QaTAS{w*_g$y423;m@>o)eHpuVfu6pmSRmxA9X;e#;^RCy@% zHo)d|#E+br+p_xkdrg)L7cX)beP$F>uyAv6*-HbG6-e%ZNMwmWbg$pQ5z6xUln1?s zr)=qu>ief9vvV5L%C)pRq}Y5V&fb~{-qiP%=wqLun(3ex$Y*MIrbQ!$LsLTH*(RD{ zOQP`W*7wuW1uY@F{&Vio$kD0_B?#g4nKMv|*o{|Swk|;+WdExglG2Kbv*+rMu&~_r zK=CQmmCVb{-2+i;_AnB?ouCr^l-}v4Apgj{u`c`+rEB4c2|H`bYG%>JcCo#CU6Ju_ z=4i#^#2~oU(lYlB0s*#dWpMF;S2%>H0Mi7m`aQ9Zzh*2lHhTLc7!UYY5}qAV{n>tu zeDU_o%&pj-Y%Gjr*uAt2U^Yq(l?=P}Sq%-XX+s%;Fd5}zXhaR;y0yopPOF+5UM=f7grCt8JXJG9M?Rr8!Tq+-+z`qRwE`0IFQeg zq~99Pugh=6MM5YnI)W9Sh8Z`6vV3xwSG2k62L~~{R!CYeLv5gz_cUv3t~p7BE-}&Z z{%LXX&tWbL1gKDEdiL|W68VE;9QwffmlZatEf{X~;Cj_23^5>zEmR9XUdr+wJGSbp zxkqlKG&Kp5d3t;36fP-zgk|geVA?0YorJNm@p{Gj*2IOw`}a@Q8%G+6rmT7w()-Rx znMM+0O2$jGTt1t%fyuG)jwxHQG7is`J z@)^kU4U9}18$)b%`mEG5A0L;~s1Up8CttqY2ZZ-IjR@32a!_^qRtG-O*MI+B2^Z9D zBXB11ACEfzibzC)m(BEkh?L40a7D_5h-`mnQWnS`47LEC*SM-Me^#Hyj=-$7Zs>_l z7&Z{H3}PqerX9e&5)g%%e)w2+eZ6i*^QyTZ03-bT#RN5DQA_13d`k~qPn~VshGkHS z<*DyYjh?4sp>nPsIEL`=BO|qkeOJ^}P7m@>+@4_BZd5}>!pzUgv2P!3*1b)1`|In( zK^J|+eka)3*>%kxar%y~3Y;aOg}d5z!A=z16ahzp$`0DrfdMW+)!G03zEWP&6e6bU z---+WM+NjmjeM~<$RF(qxr@Y6yfIxZt+%gU>8k6kL3A;DtHv6P=Ec6TrML%b&$nRI zzt7zx+NkLo*i+;Spz6r+n12tdFf~;lZFNS*DDIUk)N-OG%(D$C=4y7Jw@;qTX%fi* zL?nYb>p5$-$ZcW})Y%9%p{T%skdeN=Vwx3^o-BO;@lSu#%Ry0AWT$;()KS^BnlPqxi&S$Q(!68uSJ+-O}gyt@^Qk4-qiC3X8kh*Ay6a zsJ%K18HoM-3^zbPR;+G64-Z<}@JA0HN;vyMhC)h%5-5NB8=%5Zx7;*pqCdXQkK16P z{6$M^YZw6I{p1_6re^x$_MhXlG@p!$i)#+>J1_Tmac10rxNU`k{owpp^Ip`*{gE)F ziC@Vmvq~!&u=b)85;iT!DC+BasF-kJ^Ut`x_lcF_kh0+~5wXAtO%HFnH1dgS*D(h{$7GH5yvltMxTk zlONGIMqc)lW!6zHE7MJB?=U0<;Gm z-R*bTpdgvVVSVxP#oOZR{Df+)YJY79DAgU++gXGWLe(^@i{j$yxUiwmjDGXx<++fb zeS)&M2pUbnsJM*@W6T0VTD6T(89(RH1RRjLxIkuc&S}v(fY&iDCI-L?CNlL6j7x;A zET)DxgF}bwJSB&X&3>K}hI6AOqGXtTzHlyPVx$fAO3CDCd}88fReeJ{M6B8WYR^ke z?NU1%$OlaxHxJJP&t|KI2BL-VZFMa}L*t>W4zte(4j#UiWK;zGI5@lo+c`*5rKEZRUZ$kv;=bD?CM9(X z-?W%57NkDeZuX(Cep4*tW_4h~??saXF{Y{z>`BIUzXzECMc zt;{5GAhMf&nMh&+k3@igxrAZ)SK0MTzb>{xQh5<1VMBw^X`9D6-DPM^rb@7~*08B) z@oMLHm-z!fMC9XjLqkLTTh-_bOH1WObD5wx_Se#<-M;fXWtsiNcx&mO#Wg6R16=ZtmT`R|Mv~ z^|_PN@w#B}o<%CtMgVYTG->>1mUPiI{$pl=pH2@v=CwaxsDPjv5ToFzwzl69Q+ zn0*M}D*bGA{zU)I9T|*^3h?I*kqvR+HGB@0<$|Sm`J2m!0QMZ&y_?Ib{|dfxcLPc? zEMo{v$yh1NX@nIoUD~mD3UxrlTcK_oikK2WkKzOB_44J#pJdzZT;&cNW@on@Zn^F4 zUGbRZ_(}H*AZD{1z3}IU(#(dMgmKdzIT!Q!_`Mee2O{YuT6_P{0$^L<5N158Mp)p2 z_&7bC=-Gi25czC7xuujPBvvi@fg8&D_Nf2m*`30QqtGeh5rV5bcWwxe3Pg+k!c-e( zA-v9>3lGyM{p%w)YW7mgBRG~HQIB=L?1WUYTTK)40(`}xt@`eTZhXAIH_<;iA_Y`F1zTtZ>=lZ)VM1It6e!LnWd&m>?syw{hrwkuT z?#Czw2JpP(FZ>77K!5va4~VyeNohF<9~4vF7%LP+S-O)ZdG*^xRxD1~FgyfXS!qxe zwiQ|>I-a*gzNLiP(Yz3~9uSM$-+Hfqof$@FiBzYee3Adf-g}30{r~@?FBB!w&In~h zLloJov{N*RgeZGvWmiH2Z6v!=WM=OXvX#A8_LlLo&+UcIIq%Q;eZQyo`JHpF>s;6Q z%hl)o!OQdc829__ej6i@thIeL9;p2Rq8?gAXgGg7LW2qM`yoE#waNc}qwPOfTKW}U z3;7=YVC%dDPHc1LEN|rXq?=Pi;}A^UpO8Afvo?lZeHI7(ix(Fu=@{-$!SO`XFVYfZ z$%r8<+Y<{o;wnPU@7=Snzt5eQm-qL?sQZ)IYb}|C{Z~(3uXu!Ocr~1sxA}Q9NUrK`|!$68pO$}1jmNY%2AZH+$7yJpFsy?GpntzTjpU~pMKD~a_3L9OIEA8^MwhgOv*7^$A!r^j=y1V!{@Pu=gPlst5$@1!gv z5al3v!0^|p!)6TsdWNoellucEJ>dR%;(88dhq7YNrGf24DtOCMeOWxm>3IMpWOM4Y zSaWcsQIz(Nc1-Sx14P~tF}s;9^bqb~jEK(XLGH{moNE&UbuTyEFI)Y=Y`D2tHDR8F ztD14(3cdAso_x^}1jYcdfBzn==VCVPGazv=3_K}`)#di9SV7p}56l~tlSg9QFYbqy0eBLcC=a9M<;rOhY&{E6CH z(q`c)_2-+z&3pIeT0`oz&D8(L+bI!W}blddtKX zA}<(o0*5M%3=Nx?)pd%CJ`p#<-*x^%^fV%PLqC3`#4ozF)2Veanu=BJO3nNt(LXZh zV&#L_>z{>B@$Wr(ppn|pB;W(h*$TqRq>IMugfBcd)uVP_)%do3FO>|FuJ^h-zY6cY z-??*kdT~Lr#(ZJ>4b!JXOvC40raA(5tv$Y{?$|2E7u-*uIhnALuRqP5d+r$FnbXao zW2*?Kxj({l_n8xUW13A()dxGO?Vbn29 z>czQZ0lOY$uQ^T6#a8~z>0;y3XYD$_^uf<8{R3cqkt8ty@;QkGuA^Ng%={Ll=%7~) z;pnb#RnXv5KMs1uxAZ5UDcFslb4=Zds*5+7F43)(~FE7yG&rcCO8R1qJ^LVu;&}K14~6d(0LVHn&)HtQU9t<+w16NahF^ zpN22j?u?LQ413;3lv9jLnJanErI6PULG$L7FbRcT4RhAIp0Qvv(ML<1O0?;APq7(B z{l{?ch}}$L2UL+921p+m?Z}5^3MpOG?+7g7rbrU?oDzfTFCxV4qAfj6(Vt(l4%toM+~KeDTmG3f%i6?dZ781Hc4?8qEOb%uSJQDjAZ=yn4S}FR^#JFrC#t>kzLIx;jkLj+-lC`VzJmwMa=f#Skmm2gI;McmN1l$v z=`jlGUIv9tFkJb#QS(e5lTjU8BcXU(UBhp^jBDA#Ola_ZsJi4SeExtpKVr_F*zc%r+?erLt>z#y+;9k=TNZjGt zS`NDxIp0Gc&elXQizc?_A~Mp(>~bYyb}xTYjD|(`aK_?2*USM}>Xdr(>y7>T%qRBs zHf4fALuu0Sb@X$#GiKU7*;m3cV&dbSv(PY#nw!-{nY;`RX5VuBAp75L`vnopp*he7 zE`=+Z&&e1zCyrWIg|gibQAx9ogRWP8VI2%H06@{w((;K38D5XP8ZPQLi9+7@{J=nA zj#^`4^z2lwenWc2zkE6lCvV^W2s0Mc!vZ2Ab&hy_Z94FNfj!-aGq1B%q1@!Y68h?V z$b%#B)EiPsdACs3V3gyi2{MoOp<5$Dm|fs|lO^i8zPe|EJ_|n>M{hYE=8I{R=vEQ1%ScU4z4+lwTLvn?&G0h;>q=bV{CNv|NdtZT z5tKRxcKB`F7OxGBG$G!g z1!je7j$bHtC7q9tFUF9T$OZacYde;X_s2d<2V~>YX({^%|9BK6GTR@C8VP8?wCO0) zh_9lfa57pcTA6*SX!q#3U(61pb7+;U!0v}wVm$tWREz2b$yd zNk~ZW|Au2&sn~FO|DZ$^+>5wjz19y89<#7?u&Z`rn$`3n9>`1EW!hayTrHC)oHr*+|q28M-p-cyE4 zNv5yi;Dv_t1#vNLY^+El-wlt?`F2(4YtI9mFNjj`MehBPv!3)I(cBLYzx ztQVQ)OfG2H$S0-Qj2gTa)$(3$Mw%|1gkQ%!1q)1Oi-hVB+ptt2Sq~c;@v! zIhv73Y$YI;m>3X*Mbgst9HL&0I%Z~i`kkb?Zb|(JfPK>BFXe*29ioru9ymUFiBF{7 zhzg5}ZsvPoy(rtwc|0UawXFNoZF)5Ujs^{uZ}wi%tuAg&OjOh+-+g{;WW*`!9>uH_ zt59`8flk5CPN16^I3d1o%mF4QA9B9w`zLK2TZE*fB+_H}kH-fETfT#2JVZJE_M)LD zO5S3yeIweo4h2!*BRS!~ntn3a1*~Tt8?F1AK`y+F2?hsr7|U0~^m%Id30c(LqUvPx zmQ}{1?W?6!{n6eMM#d)n_;wNGd?fU`YE+HhVJ%y-T5cqJ_U_$4_v~r#X->GYTtXZ$ zeAi51nD?_GV{y7yZ|h!yc4bdm=#{Xe7hX9? z{q5E2z=;5vpFd3z)~){JD4E&N&kr|q&)D1N=o=WErd(ZGn<~PXNi{#Knq-T_soulz zi`&3tqwnR<>$pqC*`^kkugccD;TaS>|Aq};2)~B))_8@=|u70_W9Z7Re zUS18ngHzw!4xTaiSR<1$S)!X#*08`WkN0jEa$`9@yO-KA@2`YQ67-{OC`Az^bp z#UdQ8AFxub?A?$13BHdxIW-5oSTBCQ*hxV}mzAj@y{PISaVg`-0|b(if5+6UtPFOB zMAtTZk}I9Br#~Fmf9Y0*Qh2c*;$>soA#L?7`Gi~ZgRC#!S&%X{rMWb~WJit9t{z#0 z3AJ@~4-d>_|I7}$9j;_yVZp}+3qnm+jsF2=i|F+A8s8Vdqr+Tu z9TykZ3xdZE$wRk`xd~*OxnLH56nIio{5c<(Vg$5$qxy5+ec(WKSq)WY;gv8SAxr1o z|D$KX9Xza=ILtG37yXy(6lBY`TXV)r?kMEi~z=k=;GFi;h;DnH2&2#;sfmG8@UG4VvoAb7Ig#QaQ%kkeG9#XU{C@h zDaj}Rqt_|5@(*|N;l7)cn2f8qEeX+bP1a`c;F?LFrwY6Lnf$@XNZh(E7wEdQ45x-9 z2&6-%RXWmB)qZ;9xdz*Pa_8ykygZh#QBk$gcM={vpm-_<7tHcqtQ4-zsh#L9vRaFH zGZd3#`Z7 zano*hJ`fWd>(o^ywWwc_%;|VgBafDG?w|k)q;MrsEiEkvN&D=~d#u^52+@;qv88E! z!n-{|uZE=zIcB4QGLn=V((V@d7*#*W!Uv8v%{5)O?g{%z4a6YQJph#@G1-E!fzRZH ziwlaE@Vo40RQ z#_sa6n}z;L?b-9^%~-~0LMMCLD9;r)r{O$Mjy8?^`jwx0`Mt6s9#;d$746QI6&^n* zhQO#m?#B!p{}KC7x)`X1z- z3qOQFlXs=>L^-tN(%gQ@voLtFvu;b#Xe)0?+EBDbD0O@Z6m^3mkCZ|QS|AoA2^ zGB3apMQ)l+dO<;n`JH~i`)k#*iDkIZI@QNsi3wu8o}620{lLTXwfg zF-4ToV%FX(p_yuBenxX#PpP5|o17`vGabD%S)(d*v}>Yo-eD$Ft+`PIaNgI11gULI zbPrINOfeoN@Y$zkOl98V4!Bm4heDFoL0q%4=V19e*l$0Wnk8RD?N=A3U__5Z-VB-9 zc)|(yx$(`cs^SXAjuGdc-6c#8N-2Igvy~oPceh2SQ34zs%Msm4FK#{l>B?EHl>;YR z4c8>eROGEhO=&6ZTW~SDO5Q^Bq;qDGj6z;|_=X|8)GSQk;ITgEjzRMdW?>EMdCK*0 zgL4f5f=WrXn%s5i3JiSo_%RJF^(y22g3Zm%ER-fD(e~+*q_9b)gdrb3NI641BzLS) zgOXXI(K>slsA%7lsN*fnlDY;4>)kxc%AJVBM=y7K9#COi4QuY9i#OREMecM%BEl>U zmqPzYI?}~1Dk^&PUv#xW+Av>Ow9iNV#-wdE3cmAH{Pw3 zXq;7lSoJU*2TR@>(|f{eI<~+DJBbxZi+9H^i}P@HUMSjDN@%v~a0_p+$V`Oqa6l#l zLD1l_sr9S@{SI+swPLReglzWe!@A=ve$PEUEkT?yP)?W|$)Q8zfSbf*G++Ihk55AY z29|jqQ&TL$8&<~}RP04lR@7jV?L^Rqg;iH|Fw>vIga$+X%Fqw|j%~nNW@g%w;P!f- zT#HZ}yQi>sFhSjTB=g=ujT2;RJQQm_{jlMKjKiRsZmnS_S!&#K5o z&V(Mlw&15lTF23j`7|opWB>Rw9Cr%|B?RlaEFJG+PIjZ5G@E#DAhnUs@vvStlaS8+ z?qt(W(?~x7ED6$?Tm7Lw$IMf8|7I*TKL zZUpiPb8pCuuC=nUv7v`Q&CK)+p*HoFUQ@DBkfTPvJ1uJ$m0DJIISDBeM&C|BX&a?w zB#W{)5VIG(<}YgVbT|RU->P$PyZIZ<9-Wj&3J!5EyAs< zN_@nE9pep@IJvlNtnbdwQUy4|BY3D~`=zj}gUn)KR$HmGclHi{1nm+AE=#r!%u;_=XUZ!kXH$U3wWO%;L8;8=jdR z&LCZ=IOraCQ?D6Wyge0xy3(j2Jtr@Zk`cNxRr`gz1GOfs>lvSt+e_M6XFHWmSf^b3 z+AS<9O1@lvHbReZU_qD$akxyC4pfjnEi_Y51^wd>$y95I4@dJ79UBXBsZEJeT)msp-5lky_US=_=XLwizP!URiRf};_Y1A+|~;qbR+}tYHf4}>L>cukW_udA{mY)Syot9i8|+F(E^i@4-c! zp1BN!@sg%lUCgaO@1^eKZ|Y%g?K-nJC+!!eg&{rW zH5hNULE#1h7@Ej^G%$T)I{bxBt#)K1+SZY$==V@S0puWeMYh`S39=}I+4Cn)p5%Uf z^TglIgtnA`b}=(yP89{r1`y%}=?1~@7cXB*q@^NKRz4G=YxMP>uY^sy`=$hp`t#YN zyd&&aP7eZ-XH`!u%g_BbU>9l95vRv4?}%Xw8o>h*5zq)(MYu5u6?;pp%M8e3^mzC7NlY&zC?^Uz_NJeC;+J{GF%IoM99htB|v`9aTV4$$KMlq#E#1 zvYj&5#ip!4*i~=cds&(cfDyA;a$|~(<(!qn@I4B3;6*q7?hcVAld@f$kGXZ$dfYh0 zdQi#md@1mh>Y(FAqUQbW!>+DtGOXINaTy~%)4=zXIh6|x(XV`xCoB7B@ldW`7jrjn zT*o?1Qt-f$kcuNO(FMew*7z^(4m<0qIc(^{H#|1P@6iB|107+w-5MZG7+uRXZY?3u z5O3%$Xt38YIKTadbuZ_CTp;ZvjJqktJnio9Jh9=_3UuT^32ArCRsa0CX|-8@eJ7w$ z-i*1iQk53;=WTGX90D84+{AqKhX0rDk~?!&*<3O%gr3F^XHR`67cWVZi$vIZ$vcsT za4ot2*d1WbDWeBt(=jjrtLC|RU-iQyNV57=CTTw0fb2d&LOPL6zp8L6VYi&$*pWpt z?p6%!N=tm;Q#w?~1l)70xB{{MFq5F6>!Ug&VCx-2jnl!wVe4R;@Nt}#k3jibrtA1I zr~ZiDXQ@nR$^yX}?QTtn%LQ_-M)c zQ%XlB{2m|QA!xhGZ`&cGAs`$C;Iz}Zo=-s4QU{7Q*CrkL{Zq-UqBpCbZD1Yl;NK#B zdHfCRevbUB_M!CMbZ&(P!IATz0bI6&YqbtMTE}vO@Fqm#ft!lW^1e#g3 zMEH4jK!~yj zP-j_xmfF~BUvWmkQfiJBe;FHT2pZykptJC`j~MU!6K-!&*kV!yAcyUKHqhh%m4<49 zB&(EqYbIUbwJ0@vEGfd91Io>zSM&%B486FIk#e`r@j1KH{I~q6)_W8Y%wk77s)HNQ zoz=%1Om((%T1B+j&xS|Z3?pB`_q(?($%c06qh*3p-4HxgppyK;hG1Q#Y(N*11@REjLRQZ`7 zcOc+r#J0?hchIS;I+-K3=GS+*!0G93|Fkr50<3s5Fm}YJKWL-TI6L|9-wX#H|EZ5x z$}dVVO0`hw{QmvBA=V(pYV;!gGusT+7F>C?wY57$7?sh3YLjet%NwBZb%+EW4BuH4 zlk0c#@ECj>QO5u>dL}IHO4!xoWYAz6*2J4*>Ne3=WjW9Y^8cgmGw04tOpZa0K`nsS zzHM9bmoNLp#E>B;R1J@ON*tC&&pfCwy%tT-j#fLOjS_>5<3_45z(u3#u&LbbPe>EJ z>zD!cFCLK+4>r?L#Po$GL$lmpK-U#Qx&Sy9lDk9z*yDV z7%2PaS)YLZ6p!Kq-IpF(yY>ZJ*e@nEXgaC)nVS{(i zpWh3ClWhNlH5CXt5U=^k`NWe)nfe?+`Q}f*PyC#p#b_pexLn=-yZE2G3U`sA zM6ybTeG?+S!nJr^`l=k}M)OgOEKrD_@R-?>*&mtFoM`g$Mw$)GTGz-uab4rjdMFYz zJ9SmtN7*}sqZWUgXyDzC##;8*sHO-u78Wv+FwZwU@4%RV zobIiGXbs2_?tjFv1Rz#@>A5cl2#NAUi0V^&B{*QJxJsW696>nGZwW=_&R-H%Nc_Aek z9H>*Bu(r!_cEiWxRXH=zFl;B4p^o`8_x%Z^t151I;ps`m{!!L<5;9FfB2Xb*jOS!i z*94%CMRf|NLCHH^#V1*az;)YUojL-JZMoS%?PmiF29y)7#p~-_ zABYCxCQ}i5r5_VkOMpz7&`Zv9Jw*>0*SGXMo@^^UG?CMKINW;zY0 zUvj~ge_bZZEIMXUt33xdzQxgE-up9d(UHt5;>tdS{g_h=2~oX;4qVPhQlloq_kZi2 z=-|sO8GQlzZpiy{4rD*YHVE9-UE>m+!AO2;hEv?QdyVqjacA;T7x; z*4quc!7A+kw6Vf4?yEwG{+ssnN6uFb1+yCm3wI|l3) zFv@Lh=UF&7Ar^oCA>@`M+=&WpF=S>g;3{v8Hk8#LN%UPwYAcOlSiNN=ws` zgn=J|!gN6lf^=e=%kZ5$rY+%%hG10@R=V47T<^;JCzdL+wQENK;bFpzMl3!p~SATLfQt4XY(T8Z@me_NkHClT4m#tcK{CLi%E%(%^QzO%wuIEE$!7%}{ z-pYVk`euqbz3Nb;dm7WP5LnQeDW(Vp>Bi|=kp|o@)6=peblUZ?43HcB`qu@HYmicH(iIk8AIj%1VAnrU+20&XFcygh7$&@13Z6V?*mi{1Wo z;QyuE$)7~(38m~i4mQ4a@Q~S^XUU>sV)|;MFTMPD4q-yKq1Jl&^3HH`(@UxOSR>Wq z?hdYT%zP@o0(pu$9!Q{NnTx;q;SA9yeQxZ@>wRx1%6rWSr0aFG|2yhOl;gQeoV33o zf)zUSxeRB}t@XCVBwalC_>(svk$k?CaNtH1LJ>;oyr-HhTiO{=FtSLtU)sKX``l~R z^hHSy&1UrTBTvD>b7ztGc)lr_?;xm5=(U+eZW6&!Ax&+duY8o2mUccw=6Sek0&YW* z^2!Jmo9V|_@D?3|xC`$r(bN8dswux9_UO?g6dtK|vlbRtuZpClqew#v-RJ8`)C(?n z4O8=vHe(cwG=r~kadzQHA40EP_4$&*F?r4Z`a5NRqE;>S7jp@j80r{mZFOWrrc+C_ z2C5OyW<1b4o)LKI*of2n{+6Gz<@g0qWe@!=Spd7}anKg;zocTVCH?RVk7fV%R3QCu z?&BnS?ceYfF$Fq);T78w3HNWP!=xX6=J{X0Lei7@@cnP`BGM0kd{OiNf9(GU#`gdJ z*#8Tn{QtwN{W!2U6C9ER^1HLXmLR~Ogt$2N*H_@Hpp{`c8QAaRUoQlczMbu_ch9S! z(ccrW=pO{O4}S3RRoEY#FaG-6*mECa=&L-+0@}4CXCV-&aH{S3{MWnj%*KJH6s^w3 zTVYPQAAC}5<}-YMeaKy0h0@HduQ3Vibkgr#5c3N_MiXxn_>y^~)>lBNDSy%|-o<9APlRw>8tr{-URf~^1qBp5cRYiK;UX$~h6 zO!6QlU*;#}^P|VPE$criJa~{a5L5VkarNRI5S{GQ79|M>BACJ3QoD&Ds^H+@^t!Y# z^jqMeWw$(sUyH4ms=dA6YXs|-7gKNDD}4|dRq7zJ5_T}RcnRwq+LF8KZ`YmG!H=?j zu^RanTfAStuKHY&(W=`2y)9?sMm;17z4Y~6uXaf@_T|gXkGsmV9t59spxmjsaK97~ zJRil3gYo1*)qZexZS2 z56Y}>$ehm{7lNUW^(^y|%C1$Sz z_qVAgU#n)w2&++@k;F0i99-n==CcEgtydg>e~9I{WI&!M;aC07S4&Nt9`9v5tXEt2 z8ZUOVW34|8Gx?tv`w;>v@axhhs+IW|z!eWwj1GcHu^-%t;usI>X0~Fg%R(`epwl1- zb_#DZz8z!!oNqKU+N~Hf{Avu!eY`bHUel9z@wU<8Pw@9>HZSwp=$FZIvN`Zk-KP+t zucg59QT-o6j5DYIT0rCQNkJ}QpTYqOV(%{MmR`9o#E_bOHvL1cpws@>F&rn}$nVlzSD@7Nt6taZ z+%)6trbjbHX)R&%NKVdJv6Vx}MLx-}tK&^mf5^|QQ{NY2>P$oG` zv#14^*w=4j?%g9R%r1sp9=xB*ii#W;sOxi6_)0f4&4Oa;+wD~|}j(j@px@OaD z=be@Mq%`Z`{ojhYSvMZZF5a-0iIkhXriyv#%aygHFLQM3Ei4L)Q`bqG4?5#%NCsUE zEAu_u$hsK?mObY=^Qj^Kb@R4(Li2+OzS;3kObiT1#?GF|LzfqE;~Wyw5JbZ-B*c11 zv)1)FI}qyCJPz~b4sbg<`I9!H^bZ$+mi4W$Nlc1Mep8Br^A}ZrB$r(b8mdm4#mdDR zccS}T)dx+&4hcpDg&PTpiNv-XD%3>>A|3;MBP;(A2rvn%(7(DmUKj{aiHOMg2&(LUdE~6RdYe1*#(Z}cz-;@ttyB>{eQtJgXo$sbruN8L zSic|5_V()Ov6+fF!1W=(mTqB2ui~Ry--}J!m0`-3+22kB2)ob0XWRt+w^yKy!1sdB zT4gr~_?r_P9L9enCVsB?xNnOgu^jTr>;$JhulFG3l&ZWGfZLt>;E!@Zh04n8o&!sFWQ=l1B)!hAx@#a9YI@}>qJJ#9>z?XBPfoaQfRmk0jz zXdsRRgQjH8`Dz{tiU**23Fz0BXJwg;z1m}XSA_sU6mYBqSHl8Fy=A+G4%UDBw(5lw zzt*PBWua%!fM#58*7c>1NLtWQhi!|%<3$AoOGTvw!$HA9JJ8FIt#XUj5Wl?lHA)*R zVmx5Ta8*{@y$ioEYHRTF;k_0!?qgIh12a`35>hVSCaBtu=EA>u*P}=7$(Zr&;U}=m zXydiNoXM*D5`B{G_sCY#PStNX0`koQ9ejpXT@S)yDYoh}F{3InW%F9R1cY`PBj3b6zyCL4-_ck6f zv%z}vZ?4au?U1t9Z)r}$DpOTZ5W@KZPQn8h8WYQ@PglaW?d<{>uAGx_J>3?j){y}L z0l?A?gBxAeGo3#s=O^C0apP#;gx;wy;o+DqQlHKYeO(tB<2}lXJ5?j^>BIMliNXg* z^<`zphco8i1f^b7QcBj6)BH8m1k-}gsu>Hhz5K`{eB=SUkl{Av?4hQjnNXdI6x5}4 zT6qT!L^LH^Qb{}2$AN|x=@BE2%zN|9P$wt;XNt;G&+H}{2oH~rVk_;eB>W?6e%sC4 zuRL6Ls^4Do+Rc@~$M4kVzVs#3iS%W`g;GrH*6rri0m&9QnVAIE$B*k1^t#=F)|2rG z2s{bgL~rCQ6c@fF2>v~*96xks1O;gXdev zHu`si5y)%~3yoh8eslJ0U|UCjh0ybUtO6~`d|ih8XM9> z<0RrvBdHZ7jDZUt{BdDnp@?i1h_m4JCU*p$;Gh@ipcoD5zdo}%^XHgq3i}k|yN?vrIXS^=f|lWs*^l;Ih!u%k zn@Zn}j$UgW8ah~dCslU$*%Z@Tc+wyqmzF-5SNP(TS9_3U@9V=;9mf#206aww-j2-&zw_21??Z>zXI90= zVm08~oPT9z)xw(N_=zFIx|ph$Tpk#{kv*L^X~dru_!lp_jUC7$Y>gGds-$>S$kkdi zkEo=WQ~f<*H>A9`@`JCWI{P{&DLkeT~9sA z$YK3t;@5HO(6##4`!Mg=kC}}H%Rt6WPL7avITUJij!&M1wPYVJ|Ni~dlrigvt6>HP zvrdM!Yj*C{ZE<&X<&tBecvhhKsJpc6tw;wP0f9dzS@MQ``m`qVV~Kj2b)EFto9%G< z?1H@nKOgrgIXNjQDWm$>&k7Yk19o{9y?pVSy9l?@!dMZn!@_7j4tG*mXUFe6H!`!n zaTVb8|C4*Pu&k`6qQZwS>yr6IC~8xzV~Kn@?mZVG728xt($#Ffxx?oEo#<96hvvrT z><)^tR%-=N(o5FfB_)fenDx&5o?OFrF{}!vbZ0)8)>jq~tS1MqTvTfBP9WK*fb*{M zRj=keLCkV+sIpf~`^)t<)~#_ytvf@mgpmhCV@6V2`@l3w+{*5gVYt%nj~`8wc67?` zy|nx3)T(mSzJgub45<@N_&Y>gR6(F%D;6hVU;wjjI&8^O=6n6sf;wZJ-cDc3K|$aPtX;v9Ps4g+&5~8aadK&kMw|m%&e?~+*T5ju~t8h!g%la zlWi2-2M$mYv!~Z#f=S-GbY2``=M=g7^ZnX33PQd;v@GnUcOAY=1_ z@23(hjn~l9W^r|PclY))J)NX~?dNBxtzAjNza?y-;**t=8-^iL!~u4||H)>($r3lI zIC683ry1y*-f7uCrFzh6WW%W!FAm8032e-)HjuK!?<#dn+BU!g> zN!076CB(ysZ{oNbo-oJk?;?hY127lBK znFL^zH8_^Dh7fX|i)6|9Y!%h&6UX$yU%1-$ItbkolF`WzLUWe~k z--H@rBwR}Q+O;D;(MPAIif`Ypkn!+Iz^(6UAz(n)*H5l(irOd*BqTjOOWWfD6dN!m zSHUO!@wK}=Fb9)-P&az|4jsaceAY9ff!#v7qxU5j2G`u&+`SF z%)$~pI55~>`P|#bC)oD%X-_V>w`*F<+k`6d@|V54@UN$ffmx;Jy}d2TK1DR~@$pGt11yk2dboh5AfywHO+^Gu%al9L zEfbS`S=n=ew@!YW3;+)gua{)m@j}SR)LK!QEGlkr^On>b3JTj_pctwf?<4#3LP;n< z8Ov21%fHjMSy?@GKA{_Gn%XT)2xJn(lgZ*j1-LoShTLm7E;C0%K!8QcUcmI*2uWce zY$jY64@Xn*$!(!<1KzSgAz}&oN?y-}Y)XawViE_Y- zIibITDf8`ND0heH3P8-6sjVjvb?U|fWn7N1-<&PW$~r=D_ZO}UI(}9g9Z&GJ-`g;r z&X>BNq|_&%P4aY?^F2=l=_DW;VO5#tdSqXgFZ@$^?xXUbFQ0pBo5Z^}R6XZJxv?pu z74N>H(o#da@08kL8cmIVwz^bNeX`yC=viZVwPW8bmUhg8yyaVy+)K=|*(+M=Xa|PL zAXAZT*t%6?I@00D3xEHXuP(6M`(Yco8p|s1`PfOJ2JfwEyQmbbS_ z_JPH@ZJPnzj;FaTr_Usd-~D;)|CUCsFh*Ubr+S2kl9EzKArdYF(nTnY?Uj;`EuYtc zq$NH%bVW%?*U->}Z*l|2pT|^G)XhA0WTvSTO?n0qBlyP&U zbyqnl5m3dyneb80|Dbw1hwY1t-iOpvxg0JX)**e@pH6WAF(F<=-Vv(}mvMruL`ga%4`FBrUjxLaW?o+R!rGDyKd*EfktIs;+F*pt4^sZ7QTFie;PnYD_r$CefF&Nqj?6enX zvdxF9S3CN*upuB&8*alQwNrQDI1C#+Po624JT$5ADA&6_ZZ-np%zoNl zt|=ai=KYbL*A?GfVn0rDc#<`FM7#!Zk2JX+LwpNm9>#z>ieACnW8r4R+za5 z%QF%?%;k9w*~$f{4YTXU2stA{MM#+!pUEc4&rwk$Dd(BVh{TyaTMWyse(%n&$xqR# zxQz>~|~jqM}NmiN#`Xli9r6YVW0sva+%r?kqVc zooP)LVDdo5!5Q+s)12&6Ri8U^I$3LH=ipEq8Bdyl^=&OJ4^vCks7$IC5F?1JXC(YN z_}xI$@RRsLko6U`BXPhuJ{-E0Z6!yz@M9JRqk$xyeSDe?8NIM^d8lI*Q68C^fZFJC zS!Ch;%FX?(sPlBe8SS-8Me+Nk&L-$)-qXoMi*r?=m!j_7xRE2rnbuE0=kbGJ_E;#P zl$6aWR!XFpW1c?XD)o%iIW zcovj8R;T6P#txF?V<00?>t#L2AgnBhO^l2&26~AR5km#UOE{3%7QC$@13Tx5yNII$ z?rLM)j!>f?J2vpG0}3h)p8fSl*`dL&)7k0x ztb9EQfFT)3h8&?FfRkf6;L#BPMoh(5m#vNfRpj0ZF!*0qR3xf|xUXDrub>E@Z_T3U z-n1D-9$|;*4z1g_oyQQ1HRM{`oOIUH)zz0Mw)_@T5))^5uCL-jW%~4~nR0_9?&qWI z0s@*1)o6H8em!{O<)yvYSwwix9cepRr}eDZUux>IZE9d(+iQWX8;@voQZIh`WCwv( zvVF%JcXwJz*x!?OIN9>=r3~D?i&Ti*m;Z`4SNt?)1AnmXQXl^bXq%(=uFICoUpPr$ zE|B>kPd54R4%WKuTPq?|#4gvWX@wLQrw}gJ7}C?z2kiF|GN4)4ps%g%Wii1hSy}UA z0WB&FJRV7ytzsn^Yv62REfVEG(X&&g5V44l;O$J6h z&Dp8^fu_wmI@7!g58Jb+f1|Q{^*>s^U^5;z8rnhd$%#iY`?|~$CZVoUU%Q#&Ybq)# z+65&gaq)eWD|fBt@=+h$*tC8BNLI_r=^-Y(ipnK`{HTmfyuo_U0?ooo0c}*+ld9=7 z(xzuZqoWVT;)K%zEiz+qVU|uR5m8Y!KeAXHmmpF~9z@7nm_=cG882VK((3B!tPRb$ zp_oPWg%<*mD)0B$W4N+6#W%&GWB4g^N8rWJu=U8vNjOq8P{&`ko5RaTdB;Tg{zA0u|TwAwov# zIWsWF1kPRDEihY@%gwj!8*eIANg1{LZ|aK^+S=da!`qgx37&%oe=HPvlASt#8ZN=k z9J@seTO33jQCA{1Pa3g_z1^jp_Mi+w|C#qcRa{(_UjDtrQ