diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000..a8700d9 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,15 @@ +# Contributing Guidelines + +Thank you for considering contributing to this project! Please follow these guidelines to ensure smooth collaboration. + +## How to Report a Bug +1. Search for similar issues in the existing issues list. +2. If the issue is new, open a bug report using the provided template. +3. Provide as much detail as possible, including steps to reproduce the issue. + +## How to Submit a Pull Request +1. Fork the repository and create a new branch. +2. Make your changes following the code style guidelines. +3. Run tests to ensure everything is working. +4. Open a pull request with a detailed description of your changes. + diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 0000000..82c7e15 --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1 @@ +github: ipazc diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..37e27f7 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,29 @@ +--- +name: Bug Report +about: Report a bug to help the project improve +title: "[Bug] Your bug title" +labels: bug +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior, numbered if possible. + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Environment (please complete the following information):** + - OS: [e.g., Windows, macOS, Linux] + - Python version: [e.g., 3.9] + - Version of the project: [e.g., 1.0.0] + +**Additional context** +Add any other context about the problem here. + diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..50ea99c --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,21 @@ +--- +name: Feature Request +about: Suggest a new feature or enhancement +title: "[Feature] Your feature title" +labels: enhancement +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex: I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. + diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..ad6ee16 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,26 @@ +# Pull Request Title + +## Description +Please include a summary of the changes and the related issue. Please also include relevant motivation and context. + +Fixes # (issue) + +## Type of change +Please delete options that are not relevant. +- [ ] Bug fix (non-breaking change which fixes an issue) +- [ ] New feature (non-breaking change which adds functionality) +- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) +- [ ] Documentation update + +## Checklist +- [ ] My code follows the style guidelines of this project +- [ ] I have performed a self-review of my code +- [ ] I have commented my code, particularly in hard-to-understand areas +- [ ] I have made corresponding changes to the documentation +- [ ] My changes generate no new warnings +- [ ] I have added tests that prove my fix is effective or that my feature works +- [ ] New and existing unit tests pass locally with my changes + +## Additional Information +Add any other relevant information, screenshots, or details about the pull request. + diff --git a/.github/SECURITY.md b/.github/SECURITY.md new file mode 100644 index 0000000..8d5bc56 --- /dev/null +++ b/.github/SECURITY.md @@ -0,0 +1,5 @@ +# Security Policy + +## Reporting a Vulnerability +If you discover a security vulnerability, please do not create a public issue. Instead, report it via email to [ipazc@unileon.es]. + diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml new file mode 100644 index 0000000..4100a43 --- /dev/null +++ b/.github/workflows/pylint.yml @@ -0,0 +1,25 @@ +name: Pylint + +on: [push] + +jobs: + build: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.10", "3.11", "3.12"] + steps: + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install pylint + pip install -r requirements.txt -r requirements-tf.txt -r requirements-dev.txt + - name: Analysing the code with pylint + run: | + pylint $(git ls-files '*.py') + diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..7ed0a11 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,90 @@ +name: Build and Release + +on: + push: + tags: + - 'v*.*.*' + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: Check out the code + uses: actions/checkout@v3 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.10' + + - name: Build the Python package + run: | + python setup.py sdist bdist_wheel + + - name: Upload artifact + uses: actions/upload-artifact@v3 + with: + name: python-package-artifacts + path: dist/* + + + release: + needs: build + runs-on: ubuntu-latest + + steps: + - name: Download artifact + uses: actions/download-artifact@v3 + with: + name: python-package-artifacts + + - name: Create GitHub Release + id: create_release + uses: actions/create-release@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + tag_name: ${{ github.ref }} + release_name: Release ${{ github.ref }} + draft: false + prerelease: false + + - name: Upload artifacts to release + uses: actions/upload-release-asset@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + upload_url: ${{ steps.create_release.outputs.upload_url }} + asset_path: dist/* + asset_name: $(basename ${{ asset_path }}) + asset_content_type: application/octet-stream + + + publish-to-pypi: + needs: release # This ensures that this job runs after the release job completes + runs-on: ubuntu-latest + + steps: + - name: Check out the code + uses: actions/checkout@v3 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.10' + + - name: Install dependencies + run: pip install build twine + + - name: Download artifact + uses: actions/download-artifact@v3 + with: + name: python-package-artifacts + + - name: Publish to PyPI + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }} + run: twine upload dist/* + diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 0000000..ddbb130 --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,26 @@ +name: Run Tests + +on: [push, pull_request] + +jobs: + test: + runs-on: ubuntu-latest + + steps: + - name: Check out the repository + uses: actions/checkout@v2 + + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: '3.10' + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements-dev.txt -r requirements.txt -r requirements-tf.txt + + - name: Run tests with coverage + run: | + pytest --cov=mtcnn --cov-report=xml --cov-report=term + diff --git a/.gitignore b/.gitignore index 351166b..cc0dc6f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,19 +1,13 @@ +# Ignore the /debug folder and all its contents +/debug/ + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class -# C extensions -*.so - -# Customized -test.zip -benchmark/ -debug.py - # Distribution / packaging .Python -env/ build/ develop-eggs/ dist/ @@ -25,14 +19,14 @@ lib64/ parts/ sdist/ var/ -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. +# 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 @@ -43,66 +37,81 @@ 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/ +coverage/ -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ +# Jupyter Notebook checkpoints +.ipynb_checkpoints -# PyBuilder -target/ +# Jupyter Notebook temporary files +*.~nb -# Jupyter Notebook -.ipynb_checkpoints +# VS Code settings +.vscode/ +*.code-workspace -# pyenv -.python-version +# PyCharm project files +.idea/ +*.iml +*.iws +*.ipr -# celery beat schedule file -celerybeat-schedule +# Spyder project settings +.spyderproject +.spyproject -# SageMath parsed files -*.sage.py +# Eclipse project files +.metadata/ +*.pydevproject +.project +*.pycproject -# dotenv +# Virtual environments +venv/ +ENV/ +env/ +.venv/ +env.bak/ +venv.bak/ + +# macOS +.DS_Store + +# Windows +Thumbs.db +ehthumbs.db +Desktop.ini +$RECYCLE.BIN/ + +# Anaconda environments +.conda/ +*.condarc +*.conda +*.env +*.envs .env -.idea/ -.idea +.envs -# virtualenv +# Environments variable definitions +.env +.env.local .venv -venv/ -ENV/ -# Spyder project settings -.spyderproject -.spyproject +# IPython history +.history -# Rope project settings -.ropeproject +# MyPy cache +.mypy_cache/ -# mkdocs documentation -/site +# Pyre type checker +.pyre/ -# mypy -.mypy_cache/ \ No newline at end of file diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..59fe01f --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,9 @@ +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.3.0 + hooks: + - id: check-yaml + - id: end-of-file-fixer + - id: trailing-whitespace + - id: detect-secrets + diff --git a/.pylintrc b/.pylintrc new file mode 100644 index 0000000..115353e --- /dev/null +++ b/.pylintrc @@ -0,0 +1,653 @@ +[MAIN] + +# Analyse import fallback blocks. This can be used to support both Python 2 and +# 3 compatible code, which means that the block might have code that exists +# only in one or another interpreter, leading to false positives when analysed. +analyse-fallback-blocks=no + +# Clear in-memory caches upon conclusion of linting. Useful if running pylint +# in a server-like mode. +clear-cache-post-run=no + +# Load and enable all available extensions. Use --list-extensions to see a list +# all available extensions. +#enable-all-extensions= + +# In error mode, messages with a category besides ERROR or FATAL are +# suppressed, and no reports are done by default. Error mode is compatible with +# disabling specific errors. +#errors-only= + +# Always return a 0 (non-error) status code, even if lint errors are found. +# This is primarily useful in continuous integration scripts. +#exit-zero= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. +extension-pkg-allow-list= + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. (This is an alternative name to extension-pkg-allow-list +# for backward compatibility.) +extension-pkg-whitelist= + +# Return non-zero exit code if any of these messages/categories are detected, +# even if score is above --fail-under value. Syntax same as enable. Messages +# specified are enabled, while categories only check already-enabled messages. +fail-on= + +# Specify a score threshold under which the program will exit with error. +fail-under=8 + +# Interpret the stdin as a python script, whose filename needs to be passed as +# the module_or_package argument. +#from-stdin= + +# Files or directories to be skipped. They should be base names, not paths. +#ignore=CVS +ignore=CVS, __pycache__, .venv, .tox, build, dist, tmp, .ipynb_checkpoints + +# Add files or directories matching the regular expressions patterns to the +# ignore-list. The regex matches against paths and can be in Posix or Windows +# format. Because '\\' represents the directory delimiter on Windows systems, +# it can't be used as an escape character. +#ignore-paths= +#ignore-paths=(^|/)\.[^/]+(/|$) + +# Files or directories matching the regular expression patterns are skipped. +# The regex matches against base names, not paths. The default value ignores +# Emacs file locks +#ignore-patterns=^\.# +#ignore-patterns=^\.* + +# List of module names for which member attributes should not be checked and +# will not be imported (useful for modules/projects where namespaces are +# manipulated during runtime and thus existing member attributes cannot be +# deduced by static analysis). It supports qualified module names, as well as +# Unix pattern matching. +ignored-modules= + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +#init-hook= + +# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the +# number of processors available to use, and will cap the count on Windows to +# avoid hangs. +jobs=1 + +# Control the amount of potential inferred values when inferring a single +# object. This can help the performance when dealing with large functions or +# complex, nested conditions. +limit-inference-results=100 + +# List of plugins (as comma separated values of python module names) to load, +# usually to register additional checkers. +load-plugins= + +# Pickle collected data for later comparisons. +persistent=yes + +# Resolve imports to .pyi stubs if available. May reduce no-member messages and +# increase not-an-iterable messages. +prefer-stubs=no + +# Minimum Python version to use for version dependent checks. Will default to +# the version used to run pylint. +py-version=3.10 + +# Discover python modules and packages in the file system subtree. +recursive=no + +# Add paths to the list of the source roots. Supports globbing patterns. The +# source root is an absolute path or a path relative to the current working +# directory used to determine a package namespace for modules located under the +# source root. +source-roots= + +# When enabled, pylint would attempt to guess common misconfiguration and emit +# user-friendly hints instead of false-positive error messages. +suggestion-mode=yes + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +unsafe-load-any-extension=no + +# In verbose mode, extra non-checker-related info will be displayed. +#verbose= + + +[BASIC] + +# Naming style matching correct argument names. +argument-naming-style=snake_case + +# Regular expression matching correct argument names. Overrides argument- +# naming-style. If left empty, argument names will be checked with the set +# naming style. +#argument-rgx= + +# Naming style matching correct attribute names. +attr-naming-style=snake_case + +# Regular expression matching correct attribute names. Overrides attr-naming- +# style. If left empty, attribute names will be checked with the set naming +# style. +#attr-rgx= + +# Bad variable names which should always be refused, separated by a comma. +bad-names=foo, + bar, + baz, + toto, + tutu, + tata + +# Bad variable names regexes, separated by a comma. If names match any regex, +# they will always be refused +bad-names-rgxs= + +# Naming style matching correct class attribute names. +class-attribute-naming-style=any + +# Regular expression matching correct class attribute names. Overrides class- +# attribute-naming-style. If left empty, class attribute names will be checked +# with the set naming style. +#class-attribute-rgx= + +# Naming style matching correct class constant names. +class-const-naming-style=UPPER_CASE + +# Regular expression matching correct class constant names. Overrides class- +# const-naming-style. If left empty, class constant names will be checked with +# the set naming style. +#class-const-rgx= + +# Naming style matching correct class names. +class-naming-style=PascalCase + +# Regular expression matching correct class names. Overrides class-naming- +# style. If left empty, class names will be checked with the set naming style. +#class-rgx= + +# Naming style matching correct constant names. +const-naming-style=UPPER_CASE + +# Regular expression matching correct constant names. Overrides const-naming- +# style. If left empty, constant names will be checked with the set naming +# style. +#const-rgx= + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +docstring-min-length=-1 + +# Naming style matching correct function names. +function-naming-style=snake_case + +# Regular expression matching correct function names. Overrides function- +# naming-style. If left empty, function names will be checked with the set +# naming style. +#function-rgx= + +# Good variable names which should always be accepted, separated by a comma. +good-names=i, + j, + k, + ex, + Run, + _ + +# Good variable names regexes, separated by a comma. If names match any regex, +# they will always be accepted +good-names-rgxs= + +# Include a hint for the correct naming format with invalid-name. +include-naming-hint=no + +# Naming style matching correct inline iteration names. +inlinevar-naming-style=any + +# Regular expression matching correct inline iteration names. Overrides +# inlinevar-naming-style. If left empty, inline iteration names will be checked +# with the set naming style. +#inlinevar-rgx= + +# Naming style matching correct method names. +method-naming-style=snake_case + +# Regular expression matching correct method names. Overrides method-naming- +# style. If left empty, method names will be checked with the set naming style. +#method-rgx= + +# Naming style matching correct module names. +module-naming-style=snake_case + +# Regular expression matching correct module names. Overrides module-naming- +# style. If left empty, module names will be checked with the set naming style. +#module-rgx= + +# Colon-delimited sets of names that determine each other's naming style when +# the name regexes allow several styles. +name-group= + +# Regular expression which should only match function or class names that do +# not require a docstring. +no-docstring-rgx=^_ + +# List of decorators that produce properties, such as abc.abstractproperty. Add +# to this list to register other decorators that produce valid properties. +# These decorators are taken in consideration only for invalid-name. +property-classes=abc.abstractproperty + +# Regular expression matching correct type alias names. If left empty, type +# alias names will be checked with the set naming style. +#typealias-rgx= + +# Regular expression matching correct type variable names. If left empty, type +# variable names will be checked with the set naming style. +#typevar-rgx= + +# Naming style matching correct variable names. +variable-naming-style=snake_case + +# Regular expression matching correct variable names. Overrides variable- +# naming-style. If left empty, variable names will be checked with the set +# naming style. +#variable-rgx= + + +[CLASSES] + +# Warn about protected attribute access inside special methods +check-protected-access-in-special-methods=no + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods=__init__, + __new__, + setUp, + asyncSetUp, + __post_init__ + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected=_asdict,_fields,_replace,_source,_make,os._exit + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg=cls + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg=mcs + + +[DESIGN] + +# List of regular expressions of class ancestor names to ignore when counting +# public methods (see R0903) +exclude-too-few-public-methods= + +# List of qualified class names to ignore when counting class parents (see +# R0901) +ignored-parents= + +# Maximum number of arguments for function / method. +max-args=9 + +# Maximum number of attributes for a class (see R0902). +max-attributes=18 + +# Maximum number of boolean expressions in an if statement (see R0916). +max-bool-expr=5 + +# Maximum number of branch for function / method body. +max-branches=12 + +# Maximum number of locals for function / method body. +max-locals=22 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of positional arguments for function / method. +max-positional-arguments=9 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of return / yield for function / method body. +max-returns=6 + +# Maximum number of statements in function / method body. +max-statements=50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 + + +[EXCEPTIONS] + +# Exceptions that will emit a warning when caught. +overgeneral-exceptions=builtins.BaseException,builtins.Exception + + +[FORMAT] + +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +expected-line-ending-format= + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines=^\s*(# )??$ + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren=4 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string=' ' + +# Maximum number of characters on a single line. +max-line-length=150 + +# Maximum number of lines in a module. +max-module-lines=1000 + +# Allow the body of a class to be on the same line as the declaration if body +# contains single statement. +single-line-class-stmt=no + +# Allow the body of an if to be on the same line as the test if there is no +# else. +single-line-if-stmt=no + + +[IMPORTS] + +# List of modules that can be imported at any level, not just the top level +# one. +allow-any-import-level= + +# Allow explicit reexports by alias from a package __init__. +allow-reexport-from-package=no + +# Allow wildcard imports from modules that define __all__. +allow-wildcard-with-all=no + +# Deprecated modules which should not be used, separated by a comma. +deprecated-modules= + +# Output a graph (.gv or any supported image format) of external dependencies +# to the given file (report RP0402 must not be disabled). +ext-import-graph= + +# Output a graph (.gv or any supported image format) of all (i.e. internal and +# external) dependencies to the given file (report RP0402 must not be +# disabled). +import-graph= + +# Output a graph (.gv or any supported image format) of internal dependencies +# to the given file (report RP0402 must not be disabled). +int-import-graph= + +# Force import order to recognize a module as part of the standard +# compatibility libraries. +known-standard-library= + +# Force import order to recognize a module as part of a third party library. +known-third-party=enchant + +# Couples of modules and preferred modules, separated by a comma. +preferred-modules= + + +[LOGGING] + +# The type of string formatting that logging methods do. `old` means using % +# formatting, `new` is for `{}` formatting. +logging-format-style=old + +# Logging modules to check that the string format arguments are in logging +# function parameter format. +logging-modules=logging + + +[MESSAGES CONTROL] + +# Only show warnings with the listed confidence levels. Leave empty to show +# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, +# UNDEFINED. +confidence=HIGH, + CONTROL_FLOW, + INFERENCE, + INFERENCE_FAILURE, + UNDEFINED + +# Disable the message, report, category or checker with the given id(s). You +# can either give multiple identifiers separated by comma (,) or put this +# option multiple times (only on the command line, not in the configuration +# file where it should appear only once). You can also use "--disable=all" to +# disable everything first and then re-enable specific checks. For example, if +# you want to run only the similarities checker, you can use "--disable=all +# --enable=similarities". If you want to run only the classes checker, but have +# no Warning level messages displayed, use "--disable=all --enable=classes +# --disable=W". +disable=raw-checker-failed, + bad-inline-option, + locally-disabled, + file-ignored, + suppressed-message, + useless-suppression, + deprecated-pragma, + use-symbolic-message-instead, + use-implicit-booleaness-not-comparison-to-string, + use-implicit-booleaness-not-comparison-to-zero, + no-member, + no-name-in-module + + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time (only on the command line, not in the configuration file where +# it should appear only once). See also the "--disable" option for examples. +enable= + + +[METHOD_ARGS] + +# List of qualified names (i.e., library.method) which require a timeout +# parameter e.g. 'requests.api.get,requests.api.post' +timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request + + +[MISCELLANEOUS] + +# List of note tags to take in consideration, separated by a comma. +notes=FIXME, + XXX, + TODO + +# Regular expression of note tags to take in consideration. +notes-rgx= + + +[REFACTORING] + +# Maximum number of nested blocks for function / method body +max-nested-blocks=5 + +# Complete name of functions that never returns. When checking for +# inconsistent-return-statements if a never returning function is called then +# it will be considered as an explicit return statement and no message will be +# printed. +never-returning-functions=sys.exit,argparse.parse_error + +# Let 'consider-using-join' be raised when the separator to join on would be +# non-empty (resulting in expected fixes of the type: ``"- " + " - +# ".join(items)``) +suggest-join-with-non-empty-separator=yes + + +[REPORTS] + +# Python expression which should return a score less than or equal to 10. You +# have access to the variables 'fatal', 'error', 'warning', 'refactor', +# 'convention', and 'info' which contain the number of messages in each +# category, as well as 'statement' which is the total number of statements +# analyzed. This score is used by the global evaluation report (RP0004). +evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)) + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details. +msg-template= + +# Set the output format. Available formats are: text, parseable, colorized, +# json2 (improved json format), json (old json format) and msvs (visual +# studio). You can also give a reporter class, e.g. +# mypackage.mymodule.MyReporterClass. +#output-format= + +# Tells whether to display a full report or only the messages. +reports=no + +# Activate the evaluation score. +score=yes + + +[SIMILARITIES] + +# Comments are removed from the similarity computation +ignore-comments=yes + +# Docstrings are removed from the similarity computation +ignore-docstrings=yes + +# Imports are removed from the similarity computation +ignore-imports=yes + +# Signatures are removed from the similarity computation +ignore-signatures=yes + +# Minimum lines number of a similarity. +min-similarity-lines=4 + + +[SPELLING] + +# Limits count of emitted suggestions for spelling mistakes. +max-spelling-suggestions=4 + +# Spelling dictionary name. No available dictionaries : You need to install +# both the python package and the system dependency for enchant to work. +spelling-dict= + +# List of comma separated words that should be considered directives if they +# appear at the beginning of a comment and should not be checked. +spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy: + +# List of comma separated words that should not be checked. +spelling-ignore-words= + +# A path to a file that contains the private dictionary; one word per line. +spelling-private-dict-file= + +# Tells whether to store unknown words to the private dictionary (see the +# --spelling-private-dict-file option) instead of raising a message. +spelling-store-unknown-words=no + + +[STRING] + +# This flag controls whether inconsistent-quotes generates a warning when the +# character used as a quote delimiter is used inconsistently within a module. +check-quote-consistency=no + +# This flag controls whether the implicit-str-concat should generate a warning +# on implicit string concatenation in sequences defined over several lines. +check-str-concat-over-line-jumps=no + + +[TYPECHECK] + +# List of decorators that produce context managers, such as +# contextlib.contextmanager. Add to this list to register other decorators that +# produce valid context managers. +contextmanager-decorators=contextlib.contextmanager + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +generated-members= + +# Tells whether to warn about missing members when the owner of the attribute +# is inferred to be None. +ignore-none=yes + +# This flag controls whether pylint should warn about no-member and similar +# checks whenever an opaque object is returned when inferring. The inference +# can return multiple potential results while evaluating a Python object, but +# some branches might not be evaluated, which results in partial inference. In +# that case, it might be useful to still emit no-member and other checks for +# the rest of the inferred objects. +ignore-on-opaque-inference=yes + +# List of symbolic message names to ignore for Mixin members. +ignored-checks-for-mixins=no-member, + not-async-context-manager, + not-context-manager, + attribute-defined-outside-init + +# List of class names for which member attributes should not be checked (useful +# for classes with dynamically set attributes). This supports the use of +# qualified names. +ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace + +# Show a hint with possible names when a member name was not found. The aspect +# of finding the hint is based on edit distance. +missing-member-hint=yes + +# The minimum edit distance a name should have in order to be considered a +# similar match for a missing member name. +missing-member-hint-distance=1 + +# The total number of similar names that should be taken in consideration when +# showing a hint for a missing member. +missing-member-max-choices=1 + +# Regex pattern to define which classes are considered mixins. +mixin-class-rgx=.*[Mm]ixin + +# List of decorators that change the signature of a decorated function. +signature-mutators= + + +[VARIABLES] + +# List of additional names supposed to be defined in builtins. Remember that +# you should avoid defining new builtins when possible. +additional-builtins= + +# Tells whether unused global variables should be treated as a violation. +allow-global-unused-variables=yes + +# List of names allowed to shadow builtins +allowed-redefined-builtins= + +# List of strings which can identify a callback function by name. A callback +# name must start or end with one of those strings. +callbacks=cb_, + _cb + +# A regular expression matching the name of dummy variables (i.e. expected to +# not be used). +dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ + +# Argument names that match this expression will be ignored. +ignored-argument-names=_.*|^ignored_|^unused_ + +# Tells whether we should check for unused import in __init__ files. +init-import=no + +# List of qualified module names which can have objects that can redefine +# builtins. +redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 82e0c0e..0000000 --- a/.travis.yml +++ /dev/null @@ -1,20 +0,0 @@ -language: python -python: - - "3.4" - - "3.5" - - "3.5-dev" # 3.5 development branch - - "3.6" - - "3.6-dev" # 3.6 development branch -# command to install dependencies -before_install: - - sudo apt-get -qq update - - sudo apt-get install -y libglib2.0-0 -install: - - pip install -r requirements.txt - - pip install nose coverage - - pip install coveralls -# # command to run tests, e.g. python setup.py test -script: - - python3 setup.py nosetests --with-coverage --cover-package mtcnn --verbosity=2 -after_success: - - coveralls \ No newline at end of file diff --git a/AUTHORS b/AUTHORS deleted file mode 100644 index 14713e3..0000000 --- a/AUTHORS +++ /dev/null @@ -1 +0,0 @@ -Iván de Paz Centeno \ No newline at end of file diff --git a/LICENSE b/LICENSE index aee4bfc..3907cda 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2018 Iván de Paz Centeno +Copyright (c) 2019-2024 Iván de Paz Centeno Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. \ No newline at end of file +SOFTWARE. diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index 3a098b1..0000000 --- a/MANIFEST.in +++ /dev/null @@ -1,3 +0,0 @@ -include mtcnn/data/mtcnn_weights.npy -include requirements.txt -include AUTHORS \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..2e3b108 --- /dev/null +++ b/README.md @@ -0,0 +1,122 @@ +# MTCNN - Multitask Cascaded Convolutional Networks for Face Detection and Alignment + +[![PyPI version](https://badge.fury.io/py/mtcnn.svg)](https://badge.fury.io/py/mtcnn) +[![Documentation Status](https://readthedocs.org/projects/mtcnn/badge/?version=latest)](https://mtcnn.readthedocs.io/en/latest/?badge=latest) +![Test Status](https://github.com/ipazc/mtcnn/actions/workflows/tests.yml/badge.svg) +![Pylint Check](https://github.com/ipazc/mtcnn/actions/workflows/pylint.yml/badge.svg) +![PyPI Downloads](https://img.shields.io/pypi/dm/mtcnn) + + +## Overview + +![Example](resources/result.jpg) + +MTCNN is a robust face detection and alignment library implemented for Python >= 3.10 and TensorFlow >= 2.12, designed to detect faces and their landmarks using a multitask cascaded convolutional network. This library improves on the original implementation by offering a complete refactor, simplifying usage, improving performance, and providing support for batch processing. + +This library is ideal for applications requiring face detection and alignment, with support for both bounding box and landmark prediction. + +## Installation + +MTCNN can be installed via pip: + +```bash +pip install mtcnn +``` + +MTCNN requires Tensorflow >= 2.12. This external dependency can be installed manually or automatically along with MTCNN via: + +```bash +pip install mtcnn[tensorflow] +``` + +## Usage Example + +```python +from mtcnn import MTCNN +from mtcnn.utils.images import load_image + +# Create a detector instance +detector = MTCNN(device="CPU:0") + +# Load an image +image = load_image("ivan.jpg") + +# Detect faces in the image +result = detector.detect_faces(image) + +# Display the result +print(result) +``` + +Output example: + +```json +[ + { + "box": [277, 90, 48, 63], + "keypoints": { + "nose": (303, 131), + "mouth_right": (313, 141), + "right_eye": (314, 114), + "left_eye": (291, 117), + "mouth_left": (296, 143) + }, + "confidence": 0.9985 + } +] +``` + +## Models Overview + +MTCNN uses a cascade of three networks to detect faces and facial landmarks: + +- **PNet (Proposal Network)**: Scans the image and proposes candidate face regions. +- **RNet (Refine Network)**: Refines the face proposals from PNet. +- **ONet (Output Network)**: Detects facial landmarks (eyes, nose, mouth) and provides a final refinement of the bounding boxes. + +All networks are implemented using TensorFlow’s functional API and optimized to avoid unnecessary operations, such as transpositions, ensuring faster and more efficient execution. + +# Documentation + +The full documentation for this project is available at [Read the Docs](http://mtcnn.readthedocs.io/). + + +## Citation + +If you use this library for your research or projects, please consider citing the original work: + +``` +@article{7553523, + author={K. Zhang and Z. Zhang and Z. Li and Y. Qiao}, + journal={IEEE Signal Processing Letters}, + title={Joint Face Detection and Alignment Using Multitask Cascaded Convolutional Networks}, + year={2016}, + volume={23}, + number={10}, + pages={1499-1503}, + keywords={Benchmark testing;Computer architecture;Convolution;Detectors;Face;Face detection;Training;Cascaded convolutional neural network (CNN);face alignment;face detection}, + doi={10.1109/LSP.2016.2603342}, + ISSN={1070-9908}, + month={Oct} +} +``` + +You may also reference the original GitHub repository that this project was based on (including the networks weights): +[Original MTCNN Implementation by Kaipeng Zhang](https://github.com/kpzhang93/MTCNN_face_detection_alignment/tree/master/code) + +And the FaceNet's implementation that served as inspiration: +[Facenet's MTCNN implementation](https://github.com/davidsandberg/facenet/tree/master/src/align) + +## About this project + +The code for this project was created to standardize face detection and provide an easy-to-use framework that helps the research community push the boundaries of AI knowledge. Learn more about the author of this code on [Iván de Paz Centeno's website](https://ipazc.com) + +If you find this project useful, please consider supporting it through GitHub Sponsors. + +[![Sponsor](https://img.shields.io/badge/Sponsor-GitHub%20Sponsors-brightgreen)](https://github.com/sponsors/ipazc) + +Your support will help cover costs related to improving the codebase, adding new features, and providing better documentation. + +## License + +This project is licensed under the [MIT License](LICENSE). diff --git a/README.rst b/README.rst deleted file mode 100644 index bf13b15..0000000 --- a/README.rst +++ /dev/null @@ -1,124 +0,0 @@ -MTCNN -##### - -.. image:: https://badge.fury.io/py/mtcnn.svg - :target: https://badge.fury.io/py/mtcnn -.. image:: https://travis-ci.org/ipazc/mtcnn.svg?branch=master - :target: https://travis-ci.org/ipazc/mtcnn - - -Implementation of the MTCNN face detector for TensorFlow in Python3.4+. It is written from scratch, using as a reference the implementation of -MTCNN from David Sandberg (`FaceNet's MTCNN `_) in Facenet. It is based on the paper *Zhang, K et al. (2016)* [ZHANG2016]_. - -.. image:: https://github.com/ipazc/mtcnn/raw/master/result.jpg - - -INSTALLATION -############ - -Currently it is only supported Python3.4 onwards. It can be installed through pip: - -.. code:: bash - - $ pip3 install mtcnn - -This implementation requires OpenCV>=3.2 and Tensorflow>=1.4.0 installed in the system, with bindings for Python3. - -They can be installed through pip (if pip version >= 9.0.1): - - -.. code:: bash - - $ pip3 install tensorflow==1.4.1 opencv-contrib-python==3.2.0.8 - -or compiled directly from sources (`OpenCV3 `_, `Tensorflow `_). - -Note that a tensorflow-gpu version can be used instead if a GPU device is available on the system, which will speedup the results. It can be installed with pip: - -.. code:: bash - - $ pip3 install tensorflow-gpu\>=1.4.0 - -USAGE -##### - -The following example illustrates the ease of use of this package: - - -.. code:: python - - >>> from mtcnn.mtcnn import MTCNN - >>> import cv2 - >>> - >>> img = cv2.imread("ivan.jpg") - >>> detector = MTCNN() - >>> print(detector.detect_faces(img)) - [{'box': [277, 90, 48, 63], 'keypoints': {'nose': (303, 131), 'mouth_right': (313, 141), 'right_eye': (314, 114), 'left_eye': (291, 117), 'mouth_left': (296, 143)}, 'confidence': 0.99851983785629272}] - -The detector returns a list of JSON objects. Each JSON object contains three main keys: 'box', 'confidence' and 'keypoints': - -- The bounding box is formatted as [x, y, width, height] under the key 'box'. -- The confidence is the probability for a bounding box to be matching a face. -- The keypoints are formatted into a JSON object with the keys 'left_eye', 'right_eye', 'nose', 'mouth_left', 'mouth_right'. Each keypoint is identified by a pixel position (x, y). - -Another good example of usage can be found in the file "`example.py`_." located in the root of this repository. - -BENCHMARK -========= - -The following tables shows the benchmark of this mtcnn implementation running on an `Intel i7-3612QM CPU @ 2.10GHz `_, with a **CPU-based** Tensorflow 1.4.1. - - - Pictures containing a single frontal face: - -+------------+--------------+---------------+-----+ -| Image size | Total pixels | Process time | FPS | -+============+==============+===============+=====+ -| 460x259 | 119,140 | 0.118 seconds | 8.5 | -+------------+--------------+---------------+-----+ -| 561x561 | 314,721 | 0.227 seconds | 4.5 | -+------------+--------------+---------------+-----+ -| 667x1000 | 667,000 | 0.456 seconds | 2.2 | -+------------+--------------+---------------+-----+ -| 1920x1200 | 2,304,000 | 1.093 seconds | 0.9 | -+------------+--------------+---------------+-----+ -| 4799x3599 | 17,271,601 | 8.798 seconds | 0.1 | -+------------+--------------+---------------+-----+ - - - Pictures containing 10 frontal faces: - -+------------+--------------+---------------+-----+ -| Image size | Total pixels | Process time | FPS | -+============+==============+===============+=====+ -| 474x224 | 106,176 | 0.185 seconds | 5.4 | -+------------+--------------+---------------+-----+ -| 736x348 | 256,128 | 0.290 seconds | 3.4 | -+------------+--------------+---------------+-----+ -| 2100x994 | 2,087,400 | 1.286 seconds | 0.7 | -+------------+--------------+---------------+-----+ - -MODEL -##### - -By default the MTCNN bundles a face detection weights model. - -The model is adapted from the Facenet's MTCNN implementation, merged in a single file located inside the folder 'data' relative -to the module's path. It can be overriden by injecting it into the MTCNN() constructor during instantiation. - -The model must be numpy-based containing the 3 main keys "pnet", "rnet" and "onet", having each of them the weights of each of the layers of the network. - -For more reference about the network definition, take a close look at the paper from *Zhang et al. (2016)* [ZHANG2016]_. - -LICENSE -####### - -`MIT License`_. - - -REFERENCE -========= - -.. [ZHANG2016] Zhang, K., Zhang, Z., Li, Z., and Qiao, Y. (2016). Joint face detection and alignment using multitask cascaded convolutional networks. IEEE Signal Processing Letters, 23(10):1499–1503. - -.. _example.py: example.py -.. _MIT license: LICENSE - diff --git a/docs/ablation.md b/docs/ablation.md new file mode 100644 index 0000000..d678734 --- /dev/null +++ b/docs/ablation.md @@ -0,0 +1,73 @@ +## Ablation Study of MTCNN Components + +An ablation study is a crucial method in machine learning research that allows us to evaluate the individual contributions of different components within a model. In the context of MTCNN, this study focuses on examining the behavior and impact of the three key networks —**PNet**, **RNet**, and **ONet**— independently. Understanding how each component works in isolation helps improve performance, optimize the pipeline, and fine-tune the model's efficiency. + +In this section, we will describe the purpose and functionality of each network in detail, and provide links to Jupyter notebooks that you can run to explore each network separately. + +--- + +### 1. PNet (Proposal Network) + +**PNet** is responsible for generating initial face proposals. It processes images at different scales and identifies candidate face regions through sliding window detection. Its main task is to provide a set of bounding boxes that roughly represent areas where faces might be located. It operates quickly, but with less precision compared to the subsequent stages (RNet and ONet). + +In the ablation study for PNet, you can explore: + +- The architecture of PNet. +- How face proposals are generated at different scales. +- How bounding boxes are refined before passing to RNet. +- Non-Maximum Suppression (NMS) behavior specific to PNet. + +You can explore the detailed workings of PNet using this Jupyter notebook: + +[Explore PNet Ablation Study](notebooks-docs/pnet_ablation.ipynb) + +--- + +### 2. RNet (Refinement Network) + +**RNet** refines the bounding box proposals from PNet by performing a more detailed analysis of the candidate regions. Its goal is to reduce the number of false positives and to improve the precision of the bounding boxes. RNet also applies Non-Maximum Suppression (NMS) to filter out overlapping boxes and outputs the refined proposals that will be processed by ONet. + +In the ablation study for RNet, you can investigate: + +- How RNet refines face proposals from PNet. +- The architecture of RNet and its role in filtering false positives. +- How NMS behaves differently at this stage, refining the detections. +- The effect of adjusting the NMS threshold and classifier confidence. + +You can explore the detailed workings of RNet using this Jupyter notebook: + +[Explore RNet Ablation Study](notebooks-docs/rnet_ablation.ipynb) + +--- + +### 3. ONet (Output Network) + +**ONet** is the final network in the MTCNN pipeline, and it performs the most precise face detection and landmark prediction. ONet refines the bounding boxes and detects five facial landmarks (eyes, nose, and mouth corners). It produces the most accurate face detections, but is also the most computationally expensive network. + +In the ablation study for ONet, you can explore: + +- How ONet performs both bounding box refinement and landmark detection. +- The architecture of ONet and its multitask learning setup. +- How different NMS thresholds and confidence scores affect the final output. +- How facial landmarks are detected and aligned with the final bounding boxes. + +You can explore the detailed workings of ONet using this Jupyter notebook: + +[Explore ONet Ablation Study](notebooks-docs/onet_ablation.ipynb) + +--- + +### How to Use the Ablation Notebooks + +Each of the ablation notebooks (`pnet_ablation.ipynb`, `rnet_ablation.ipynb`, `onet_ablation.ipynb`) provides a detailed, interactive environment where you can: + +- Load and preprocess test images. +- Run each network individually. +- Experiment with different configurations, such as Non-Maximum Suppression (NMS) thresholds and scaling factors. +- Visualize the outputs for face proposals, refined bounding boxes, and detected landmarks. + +These notebooks allow you to better understand the contributions of each network within the MTCNN pipeline. For each network, you can adjust parameters, observe the intermediate outputs, and gain insights into how PNet, RNet, and ONet work together to produce the final detection results. + +### Conclusion + +The ablation study is a powerful tool for understanding the internal mechanics of MTCNN. By exploring PNet, RNet, and ONet separately, you can develop a deeper intuition about how each component contributes to the overall performance of the model. The provided Jupyter notebooks will guide you through these individual networks, offering hands-on experience and detailed insights. diff --git a/docs/css/custom.css b/docs/css/custom.css new file mode 100644 index 0000000..71cfd52 --- /dev/null +++ b/docs/css/custom.css @@ -0,0 +1,3 @@ +p { + text-align: justify; +} diff --git a/docs/images/ivan_detection.png b/docs/images/ivan_detection.png new file mode 100644 index 0000000..f75f2e8 Binary files /dev/null and b/docs/images/ivan_detection.png differ diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..f2c6079 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,15 @@ +# Welcome to MTCNN Documentation + +This documentation provides detailed information on the MTCNN package, its usage, configuration, and training steps. + +## Sections + +- **[Introduction](introduction.md)**: Overview of the MTCNN project. +- **[Stages and Networks](stages.md)**: Understand the PNet, RNet, and ONet stages and network architectures. +- **[Basic Usage](usage.md)**: Learn how to use MTCNN for basic face detection. +- **[Advanced Usage](usage_advanced.md)**: Discover how to process images in batches. +- **[Parameters Usage](usage_params.md)**: Fine-tune detection thresholds and settings. +- **[Ablation Study](ablation.md)**: Investigate how each component of MTCNN contributes. +- **[Training Guide](training.md)**: Learn how to train MTCNN models. +- **[References](references.md)**: Learn about MTCNN scientific origins. + diff --git a/docs/introduction.md b/docs/introduction.md new file mode 100644 index 0000000..35e7d9e --- /dev/null +++ b/docs/introduction.md @@ -0,0 +1,40 @@ +## Introduction to MTCNN + +### 1. History of MTCNN + +![MTCNN Pipeline](https://kpzhang93.github.io/MTCNN_face_detection_alignment/support/index.png) + +*Figure 1: The MTCNN Pipeline for face detection.* + +MTCNN (Multitask Cascaded Convolutional Networks) was first introduced in a 2016 paper titled *"Joint Face Detection and Alignment Using Multitask Cascaded Convolutional Networks"* by Kaipeng Zhang, Zhanpeng Zhang, Zhifeng Li, and Yu Qiao. This work was published in the *IEEE Signal Processing Letters* and later presented at the *2017 IEEE International Conference on Computer Vision (ICCV)*. + +The method quickly became popular due to its ability to perform both face detection and facial landmark alignment in a single pipeline. It was designed to efficiently detect faces at different scales and orientations while also predicting key facial landmarks such as eyes, nose, and mouth. This multitask approach reduced the computational cost compared to running separate models for face detection and alignment. + +### 2. The MTCNN Method + +MTCNN uses a cascaded structure of three convolutional neural networks (CNNs) that work together to progressively refine face proposals and detect key landmarks. The networks are: + +- **PNet (Proposal Network)**: This network scans the image at different scales to generate candidate face regions (bounding boxes). +- **RNet (Refinement Network)**: RNet takes the candidate face regions from PNet, refines them by filtering false positives, and regresses the bounding boxes. +- **ONet (Output Network)**: The final stage, ONet, further refines the bounding boxes and detects five facial landmarks: the eyes, nose, and the corners of the mouth. + +The overall process is hierarchical, with each network focusing on more precise tasks as the proposal gets closer to the final face detection. This cascading structure helps balance accuracy and speed, ensuring high performance even in challenging conditions like varying lighting, pose, and facial occlusions. + +Here’s an illustration of the architecture: + +![MTCNN Architecture](https://www.researchgate.net/profile/Alem-Fitwi/publication/341148320/figure/fig3/AS:887674495844353@1588649500279/MTCNN-Stage-architecture-of-the-model-used-for-face-detection-and-landmark-extraction.jpg) + +*Figure 2: The MTCNN architecture consists of three networks (PNet, RNet, and ONet) that progressively refine face detection and alignment.* + +### 3. History of This Package + +The original implementation of MTCNN was released in 2018 as an open-source project based on the original paper. Since then, it has been widely adopted in various computer vision tasks involving face detection and alignment, with many libraries and applications using the MTCNN model. + +In 2024, a major refactor and optimization of the MTCNN package was undertaken to modernize the codebase, making it more robust, efficient, and compatible with the latest versions of TensorFlow (>2.17). Key improvements include: + +- A cleaner project structure with modular components for better maintainability. +- Support for batch processing to handle multiple images at once. +- Removal of outdated dependencies like OpenCV, switching to TensorFlow for image processing. +- Full documentation and optimized performance through matrix-based operations. + +This version of MTCNN retains the simplicity of the original interface while providing more flexibility and support for a broader range of use cases. diff --git a/docs/notebooks-docs/onet_ablation.ipynb b/docs/notebooks-docs/onet_ablation.ipynb new file mode 100644 index 0000000..a9eebab --- /dev/null +++ b/docs/notebooks-docs/onet_ablation.ipynb @@ -0,0 +1,484 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "78ccfbad-54da-4945-b4a3-45b0eb9fc364", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"..\")" + ] + }, + { + "cell_type": "markdown", + "id": "6e7e7c7d-0cf2-48fc-a6e6-fba3d6a647f2", + "metadata": {}, + "source": [ + "# MTCNN ONet\n", + "\n", + "This notebook demonstrates the ONet architecture and its corresponding weights.\n", + "\n", + "ONet is a fully convolutional neural network (CNN) used in the third and final stage of MTCNN. This network further refines the bounding box proposals generated by the previous RNet stage and adds facial landmark detection. It produces three outputs:\n", + "\n", + "* Regression of the bounding box coordinates to fine-tune the proposals.\n", + "* Classification of the proposals into two categories: no-face or face.\n", + "* Detection of five facial landmarks (eyes, nose, and mouth corners).\n", + "\n", + "The outputs are generated for each bounding box proposal, providing more precise detections and facial landmarks.\n", + "\n", + "In the following sections, we will run the MTCNN model, focusing solely on the ONet stage. We will examine the intermediate inputs, observe the output shapes, and visualize the results." + ] + }, + { + "cell_type": "markdown", + "id": "40cf365e-e8d3-481c-8b02-64b9cc6e7f8b", + "metadata": {}, + "source": [ + "## MTCNN on ONet Stage\n", + "\n", + "MTCNN can be configured to run up to the third stage, which will provide the direct output of the ONet stage, including refined bounding boxes and facial landmarks.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3431815e-6a07-4a8b-8a2d-d454d4a3a4b9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:09:18.307684: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-10-02 19:09:18.317665: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-02 19:09:18.330214: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-02 19:09:18.333978: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-02 19:09:18.343225: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-02 19:09:19.020016: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "from mtcnn import MTCNN\n", + "from mtcnn.utils.images import load_image\n", + "from mtcnn.stages import StagePNet, StageRNet, StageONet" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8f9b8423-64ec-4f23-91f7-9dcd85e85682", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:09:19.755678: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 45287 MB memory: -> device: 0, name: NVIDIA RTX A6000, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2024-10-02 19:09:19.756115: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 7363 MB memory: -> device: 1, name: NVIDIA GeForce GTX 1070, pci bus id: 0000:17:00.0, compute capability: 6.1\n" + ] + } + ], + "source": [ + "image = load_image(\"../resources/ivan.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "85710efe-fac4-472f-91b7-dceb211d9965", + "metadata": {}, + "outputs": [], + "source": [ + "# This is the default configuration of stages, aliased as \"face_and_landmarks_detection\"\n", + "mtcnn = MTCNN(stages=[StagePNet, StageRNet, StageONet], device=\"CPU:0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1516fdd4-794e-4e81-bcdd-6be6a45cb570", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 590 ms, sys: 270 ms, total: 860 ms\n", + "Wall time: 466 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "result = mtcnn.detect_faces(image, postprocess=True, threshold_onet=0.85)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "57c31ee3-ef28-4010-a903-38173ac9364a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'box': [276, 92, 50, 63],\n", + " 'confidence': 0.9999972581863403,\n", + " 'keypoints': {'nose': [304, 131],\n", + " 'mouth_right': [314, 141],\n", + " 'right_eye': [315, 114],\n", + " 'left_eye': [290, 116],\n", + " 'mouth_left': [297, 143]}}]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1e361a8b-ea17-41b3-950b-8a30c89040db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mtcnn.utils.plotting import plot\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.imshow(plot(image, result))" + ] + }, + { + "cell_type": "markdown", + "id": "820648d8-bc52-44c4-9000-12ebef684ffc", + "metadata": {}, + "source": [ + "As can be seen, the ONet is not only refining proposals by discarding those that do not match the thresholds and adjusting those that matched, but also proposing landmarks in the accepted bboxes." + ] + }, + { + "cell_type": "markdown", + "id": "b2f0227a-4437-4e07-8661-9239ae88988d", + "metadata": {}, + "source": [ + "### Accessing ONet's model\n", + "\n", + "The network can be accessed by instantiating StageRNet and reading the attribute `model`, which is a TensorFlow model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "85692cac-f01a-4e51-812d-6697c4b4eb95", + "metadata": {}, + "outputs": [], + "source": [ + "stage = StageONet()\n", + "model = stage.model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b5b0d71f-c4f4-4df2-89dd-66091cd3f9fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"o_net_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"o_net_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv1 (Conv2D)                  │ (None, 46, 46, 32)     │           896 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu1 (PReLU)                  │ (None, 46, 46, 32)     │            32 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling1 (MaxPooling2D)      │ (None, 23, 23, 32)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2 (Conv2D)                  │ (None, 21, 21, 64)     │        18,496 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu2 (PReLU)                  │ (None, 21, 21, 64)     │            64 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling2 (MaxPooling2D)      │ (None, 10, 10, 64)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv3 (Conv2D)                  │ (None, 8, 8, 64)       │        36,928 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu3 (PReLU)                  │ (None, 8, 8, 64)       │            64 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling3 (MaxPooling2D)      │ (None, 4, 4, 64)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv4 (Conv2D)                  │ (None, 3, 3, 128)      │        32,896 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu4 (PReLU)                  │ (None, 3, 3, 128)      │           128 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ permute (Permute)               │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten4 (Flatten)              │ (None, 1152)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc5 (Dense)                     │ (None, 256)            │       295,168 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu5 (PReLU)                  │ (None, 256)            │           256 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc6-1 (Dense)                   │ (None, 4)              │         1,028 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc6-2 (Dense)                   │ (None, 10)             │         2,570 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc6-3 (Dense)                   │ (None, 2)              │           514 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m896\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu1 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m32\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu2 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m36,928\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu3 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling3 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv4 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m32,896\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu4 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ permute (\u001b[38;5;33mPermute\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten4 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1152\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc5 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m295,168\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu5 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc6-1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m1,028\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc6-2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m2,570\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc6-3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m514\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 389,040 (1.48 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m389,040\u001b[0m (1.48 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 389,040 (1.48 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m389,040\u001b[0m (1.48 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "c6719b2c-432a-498e-ada7-c9ea962a93c7", + "metadata": {}, + "source": [ + "### Loading ONet's weights\n", + "\n", + "The model weights are stored within the folder local `mtcnn/assets/weights/` under the filename `onet.lz4`. It can be loaded with `joblib`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cfe6688e-1bc8-46ad-920a-7c338419e4a2", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "onet_weights = joblib.load(\"../mtcnn/assets/weights/onet.lz4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "79400bef-8b41-481a-b375-3179732f8263", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "21" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(onet_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "27d8782a-4dfd-4bde-8006-51b9124fda9e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(3, 3, 3, 32),\n", + " (32,),\n", + " (1, 1, 32),\n", + " (3, 3, 32, 64),\n", + " (64,),\n", + " (1, 1, 64),\n", + " (3, 3, 64, 64),\n", + " (64,),\n", + " (1, 1, 64),\n", + " (2, 2, 64, 128),\n", + " (128,),\n", + " (1, 1, 128),\n", + " (1152, 256),\n", + " (256,),\n", + " (256,),\n", + " (256, 4),\n", + " (4,),\n", + " (256, 10),\n", + " (10,),\n", + " (256, 2),\n", + " (2,)]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[w.shape for w in onet_weights]" + ] + }, + { + "cell_type": "markdown", + "id": "14a82ac3-d289-4cbb-9cc4-58603dc6c543", + "metadata": {}, + "source": [ + "Further stage ablation can be performed by looking at `mtcnn/stages/stage_onet.py`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f96a7b5-f738-4b04-afcc-025129b14ca0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (mamba3.11)", + "language": "python", + "name": "mamba3.11" + }, + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks-docs/pnet_ablation.ipynb b/docs/notebooks-docs/pnet_ablation.ipynb new file mode 100644 index 0000000..9eb1982 --- /dev/null +++ b/docs/notebooks-docs/pnet_ablation.ipynb @@ -0,0 +1,642 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d5a329e6-de92-4f55-bd24-ed7eddacf86c", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"..\")" + ] + }, + { + "cell_type": "markdown", + "id": "3036aa7d-338b-4bfb-b3ce-8f846b884c5c", + "metadata": {}, + "source": [ + "# MTCNN PNet\n", + "\n", + "This notebook demonstrates the PNet architecture and its corresponding weights.\n", + "\n", + "PNet is a fully convolutional neural network (CNN) used in the first stage of MTCNN. This network processes inputs of variable size and generates bounding box proposals. It produces two outputs:\n", + "\n", + "* Regression of the bounding box coordinates within the convolutional receptive field.\n", + "* Classification of the receptive field into two categories: no-face or face.\n", + "\n", + "The outputs are generated for each receptive field, meaning that with every convolutional pass, a corresponding output is produced.\n", + "\n", + "In the following sections, we will run the MTCNN model, focusing solely on the PNet stage. We will examine the intermediate inputs, observe the output shapes, and visualize the results." + ] + }, + { + "cell_type": "markdown", + "id": "371e7036-e5fa-4be6-a684-a44b108abb87", + "metadata": {}, + "source": [ + "## MTCNN on PNet Stage\n", + "\n", + "MTCNN can be configured to run only up to the first stage, which will provide the direct output of the PNet stage." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d04a7b43-d6e1-4a9e-9d7f-2db3068a0ff3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:38:21.331861: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-10-02 19:38:21.342042: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-02 19:38:21.354494: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-02 19:38:21.358349: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-02 19:38:21.367690: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-02 19:38:22.024220: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "from mtcnn import MTCNN\n", + "from mtcnn.utils.images import load_image\n", + "from mtcnn.utils.tensorflow import set_gpu_memory_growth\n", + "from mtcnn.stages import StagePNet" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f62dad3d-2a1c-4d66-90ce-ce486b430752", + "metadata": {}, + "outputs": [], + "source": [ + "# To avoid using excessive GPU memory (In case of using GPU)\n", + "set_gpu_memory_growth()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "82387e10-293f-44d2-b1f3-108018f5d41d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:38:22.806604: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1312 MB memory: -> device: 0, name: NVIDIA RTX A6000, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2024-10-02 19:38:22.807033: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 7363 MB memory: -> device: 1, name: NVIDIA GeForce GTX 1070, pci bus id: 0000:17:00.0, compute capability: 6.1\n" + ] + } + ], + "source": [ + "image = load_image(\"../resources/ivan.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c80dcac6-ddbf-4a3c-b896-61fa81f7f558", + "metadata": {}, + "outputs": [], + "source": [ + "mtcnn = MTCNN(stages=[StagePNet], device=\"CPU:0\") # other devices: GPU:0 , GPU:1 , ..." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "36b38d7a-6241-467a-b09a-5ce9dac91d23", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 413 ms, sys: 111 ms, total: 524 ms\n", + "Wall time: 310 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "result = mtcnn.detect_faces(image, postprocess=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6b77291f-c123-4a81-aa18-3da6d9b5f190", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'box': [270, 89, 61, 61], 'confidence': 0.9999668598175049},\n", + " {'box': [271, 89, 71, 71], 'confidence': 0.9997212290763855},\n", + " {'box': [490, 209, 54, 54], 'confidence': 0.9992153644561768},\n", + " {'box': [187, 243, 38, 38], 'confidence': 0.998630166053772},\n", + " {'box': [480, 285, 57, 57], 'confidence': 0.9982782602310181},\n", + " {'box': [296, 100, 32, 32], 'confidence': 0.9957242012023926},\n", + " {'box': [192, 43, 108, 108], 'confidence': 0.9916715025901794},\n", + " {'box': [101, 408, 42, 42], 'confidence': 0.9912404417991638},\n", + " {'box': [97, 405, 52, 52], 'confidence': 0.9852192401885986},\n", + " {'box': [11, 180, 43, 43], 'confidence': 0.9849668145179749},\n", + " {'box': [8, 386, 31, 31], 'confidence': 0.9844192862510681},\n", + " {'box': [394, 399, 48, 48], 'confidence': 0.9816769361495972},\n", + " {'box': [14, 313, 40, 40], 'confidence': 0.9804034233093262},\n", + " {'box': [184, 59, 18, 18], 'confidence': 0.9791208505630493},\n", + " {'box': [495, 143, 58, 58], 'confidence': 0.9790045022964478},\n", + " {'box': [286, 218, 62, 62], 'confidence': 0.9768547415733337},\n", + " {'box': [344, 132, 20, 20], 'confidence': 0.9743143916130066},\n", + " {'box': [403, 394, 41, 41], 'confidence': 0.9722734093666077},\n", + " {'box': [180, 241, 46, 46], 'confidence': 0.9710206985473633},\n", + " {'box': [496, 214, 41, 41], 'confidence': 0.9705135822296143},\n", + " {'box': [275, 104, 30, 30], 'confidence': 0.9698752164840698},\n", + " {'box': [144, 391, 78, 78], 'confidence': 0.9693538546562195},\n", + " {'box': [4, 176, 54, 54], 'confidence': 0.9685015082359314},\n", + " {'box': [187, 140, 40, 40], 'confidence': 0.9677426218986511},\n", + " {'box': [283, 99, 45, 45], 'confidence': 0.967420756816864},\n", + " {'box': [534, 382, 20, 20], 'confidence': 0.9653154611587524},\n", + " {'box': [271, 99, 45, 45], 'confidence': 0.9631991386413574},\n", + " {'box': [101, 509, 17, 17], 'confidence': 0.9630200862884521},\n", + " {'box': [499, 289, 39, 39], 'confidence': 0.961385190486908},\n", + " {'box': [290, 124, 32, 32], 'confidence': 0.9606941938400269},\n", + " {'box': [334, 128, 28, 28], 'confidence': 0.9601700305938721},\n", + " {'box': [250, 104, 21, 21], 'confidence': 0.9600563049316406},\n", + " {'box': [182, 98, 19, 19], 'confidence': 0.9569499492645264},\n", + " {'box': [338, 152, 19, 19], 'confidence': 0.9563547968864441},\n", + " {'box': [8, 235, 58, 58], 'confidence': 0.9557236433029175},\n", + " {'box': [1, 386, 40, 40], 'confidence': 0.9545572400093079},\n", + " {'box': [513, 371, 39, 39], 'confidence': 0.9491947293281555},\n", + " {'box': [322, 191, 27, 27], 'confidence': 0.9456313848495483},\n", + " {'box': [470, 50, 53, 53], 'confidence': 0.9440603852272034},\n", + " {'box': [100, 411, 30, 30], 'confidence': 0.9404458999633789},\n", + " {'box': [31, 341, 32, 32], 'confidence': 0.937527060508728},\n", + " {'box': [323, 188, 20, 20], 'confidence': 0.9356555938720703},\n", + " {'box': [489, 434, 29, 29], 'confidence': 0.9347164630889893},\n", + " {'box': [355, 260, 18, 18], 'confidence': 0.9298021197319031},\n", + " {'box': [1, 396, 21, 21], 'confidence': 0.9291993975639343},\n", + " {'box': [270, 56, 147, 147], 'confidence': 0.9255051016807556},\n", + " {'box': [476, 270, 73, 73], 'confidence': 0.924798309803009},\n", + " {'box': [506, 294, 22, 22], 'confidence': 0.9207442402839661},\n", + " {'box': [73, 58, 225, 225], 'confidence': 0.9173569083213806},\n", + " {'box': [262, 71, 101, 101], 'confidence': 0.9164451956748962},\n", + " {'box': [13, 72, 31, 31], 'confidence': 0.9129998683929443},\n", + " {'box': [26, 340, 39, 39], 'confidence': 0.9100756049156189},\n", + " {'box': [239, 97, 31, 31], 'confidence': 0.9052125215530396},\n", + " {'box': [148, 405, 36, 36], 'confidence': 0.8971834778785706},\n", + " {'box': [445, 379, 43, 43], 'confidence': 0.8947854042053223},\n", + " {'box': [446, 215, 22, 22], 'confidence': 0.8917657136917114},\n", + " {'box': [239, 233, 81, 81], 'confidence': 0.8911052346229553},\n", + " {'box': [220, 287, 20, 20], 'confidence': 0.8855998516082764},\n", + " {'box': [36, 341, 24, 24], 'confidence': 0.8843594193458557},\n", + " {'box': [481, 198, 76, 76], 'confidence': 0.8838769197463989},\n", + " {'box': [17, 390, 21, 21], 'confidence': 0.8799570202827454},\n", + " {'box': [4, 303, 55, 55], 'confidence': 0.8785687685012817},\n", + " {'box': [430, 217, 19, 19], 'confidence': 0.8763736486434937},\n", + " {'box': [206, 79, 23, 23], 'confidence': 0.8737393617630005},\n", + " {'box': [7, 73, 42, 42], 'confidence': 0.8733800053596497},\n", + " {'box': [174, 127, 72, 72], 'confidence': 0.8731698393821716},\n", + " {'box': [280, 106, 22, 22], 'confidence': 0.8657463192939758},\n", + " {'box': [523, 456, 21, 21], 'confidence': 0.8632909059524536},\n", + " {'box': [62, 349, 28, 28], 'confidence': 0.8600795865058899},\n", + " {'box': [476, 63, 28, 28], 'confidence': 0.8581259250640869},\n", + " {'box': [489, 434, 35, 35], 'confidence': 0.8565669059753418},\n", + " {'box': [24, 367, 20, 20], 'confidence': 0.853937566280365},\n", + " {'box': [3, 176, 72, 72], 'confidence': 0.8522983193397522},\n", + " {'box': [0, 297, 20, 20], 'confidence': 0.851826012134552},\n", + " {'box': [42, 358, 78, 78], 'confidence': 0.8504625558853149},\n", + " {'box': [342, 102, 23, 23], 'confidence': 0.8466385006904602},\n", + " {'box': [335, 148, 26, 26], 'confidence': 0.8402417302131653},\n", + " {'box': [374, 395, 77, 77], 'confidence': 0.837632417678833},\n", + " {'box': [293, 160, 30, 30], 'confidence': 0.8371832370758057},\n", + " {'box': [107, 369, 150, 150], 'confidence': 0.8341783881187439},\n", + " {'box': [283, 148, 31, 31], 'confidence': 0.8329155445098877},\n", + " {'box': [18, 72, 23, 23], 'confidence': 0.8310617804527283},\n", + " {'box': [533, 271, 20, 20], 'confidence': 0.8309110403060913},\n", + " {'box': [2, 314, 43, 43], 'confidence': 0.8295050859451294},\n", + " {'box': [2, 247, 40, 40], 'confidence': 0.8290241956710815},\n", + " {'box': [136, 387, 97, 97], 'confidence': 0.8286371827125549},\n", + " {'box': [301, 220, 49, 49], 'confidence': 0.8285456299781799},\n", + " {'box': [22, 184, 31, 31], 'confidence': 0.8255282044410706},\n", + " {'box': [143, 419, 28, 28], 'confidence': 0.8249657154083252},\n", + " {'box': [10, 74, 22, 22], 'confidence': 0.8228946924209595},\n", + " {'box': [190, 2, 22, 22], 'confidence': 0.8213641047477722},\n", + " {'box': [424, 483, 34, 34], 'confidence': 0.8204600214958191},\n", + " {'box': [201, 205, 22, 22], 'confidence': 0.81780606508255},\n", + " {'box': [189, 120, 30, 30], 'confidence': 0.8163595795631409},\n", + " {'box': [10, 132, 29, 29], 'confidence': 0.8141602277755737},\n", + " {'box': [39, 217, 23, 23], 'confidence': 0.8135595321655273},\n", + " {'box': [185, 128, 58, 58], 'confidence': 0.810321569442749},\n", + " {'box': [173, 424, 20, 20], 'confidence': 0.8083855509757996},\n", + " {'box': [435, 212, 33, 33], 'confidence': 0.8042281866073608},\n", + " {'box': [206, 62, 21, 21], 'confidence': 0.8023461699485779},\n", + " {'box': [498, 152, 30, 30], 'confidence': 0.8022951483726501},\n", + " {'box': [49, 377, 56, 56], 'confidence': 0.8021646738052368},\n", + " {'box': [511, 33, 40, 40], 'confidence': 0.8009828925132751},\n", + " {'box': [31, 341, 79, 79], 'confidence': 0.7994623184204102},\n", + " {'box': [455, 401, 79, 79], 'confidence': 0.7946075201034546},\n", + " {'box': [153, 112, 102, 102], 'confidence': 0.7888069152832031},\n", + " {'box': [188, 96, 60, 60], 'confidence': 0.7880174517631531},\n", + " {'box': [191, 121, 21, 21], 'confidence': 0.7873377799987793},\n", + " {'box': [103, 53, 170, 170], 'confidence': 0.7869991064071655},\n", + " {'box': [161, 31, 154, 154], 'confidence': 0.7862122654914856},\n", + " {'box': [339, 172, 28, 28], 'confidence': 0.7811397314071655},\n", + " {'box': [194, 135, 26, 26], 'confidence': 0.7713541388511658},\n", + " {'box': [524, 267, 28, 28], 'confidence': 0.7680309414863586},\n", + " {'box': [319, 164, 19, 19], 'confidence': 0.7631727457046509},\n", + " {'box': [236, 101, 37, 37], 'confidence': 0.7625581622123718},\n", + " {'box': [2, 1, 57, 57], 'confidence': 0.7596020698547363},\n", + " {'box': [278, 136, 46, 46], 'confidence': 0.7581404447555542},\n", + " {'box': [284, 153, 24, 24], 'confidence': 0.7557078003883362},\n", + " {'box': [221, 212, 150, 150], 'confidence': 0.753204882144928},\n", + " {'box': [513, 368, 30, 30], 'confidence': 0.7531015276908875},\n", + " {'box': [464, 454, 21, 21], 'confidence': 0.74482661485672},\n", + " {'box': [499, 148, 39, 39], 'confidence': 0.7422949075698853},\n", + " {'box': [277, 135, 56, 56], 'confidence': 0.7366361618041992},\n", + " {'box': [304, 28, 59, 59], 'confidence': 0.7317830920219421},\n", + " {'box': [503, 293, 30, 30], 'confidence': 0.729342520236969},\n", + " {'box': [486, 333, 23, 23], 'confidence': 0.728617250919342},\n", + " {'box': [189, 142, 29, 29], 'confidence': 0.7246003746986389},\n", + " {'box': [356, 387, 21, 21], 'confidence': 0.7240045070648193},\n", + " {'box': [184, 205, 23, 23], 'confidence': 0.723656177520752},\n", + " {'box': [334, 99, 38, 38], 'confidence': 0.7213565707206726},\n", + " {'box': [501, 27, 51, 51], 'confidence': 0.7170071005821228},\n", + " {'box': [273, 266, 38, 38], 'confidence': 0.7144962549209595},\n", + " {'box': [252, 493, 40, 40], 'confidence': 0.7130072116851807},\n", + " {'box': [453, 215, 20, 20], 'confidence': 0.706762969493866},\n", + " {'box': [63, 396, 43, 43], 'confidence': 0.7053548693656921},\n", + " {'box': [313, 189, 39, 39], 'confidence': 0.7040255069732666},\n", + " {'box': [15, 241, 31, 31], 'confidence': 0.6972864866256714},\n", + " {'box': [219, 161, 18, 18], 'confidence': 0.6943190693855286},\n", + " {'box': [43, 9, 31, 31], 'confidence': 0.6927041411399841},\n", + " {'box': [303, 5, 27, 27], 'confidence': 0.6924176812171936},\n", + " {'box': [301, 259, 53, 53], 'confidence': 0.6918803453445435},\n", + " {'box': [478, 319, 40, 40], 'confidence': 0.6887754201889038},\n", + " {'box': [67, 508, 58, 52], 'confidence': 0.6868264079093933},\n", + " {'box': [184, 112, 43, 43], 'confidence': 0.6865329742431641},\n", + " {'box': [334, 135, 18, 18], 'confidence': 0.6855722069740295},\n", + " {'box': [36, 350, 23, 23], 'confidence': 0.6833070516586304},\n", + " {'box': [177, 95, 25, 25], 'confidence': 0.6830892562866211},\n", + " {'box': [159, 420, 38, 38], 'confidence': 0.682868480682373},\n", + " {'box': [318, 138, 19, 19], 'confidence': 0.6816803216934204},\n", + " {'box': [263, 423, 29, 29], 'confidence': 0.6813008189201355},\n", + " {'box': [284, 199, 20, 20], 'confidence': 0.6787427663803101},\n", + " {'box': [67, 352, 21, 21], 'confidence': 0.6717443466186523},\n", + " {'box': [481, 23, 74, 74], 'confidence': 0.6704385876655579},\n", + " {'box': [523, 452, 31, 31], 'confidence': 0.6700493097305298},\n", + " {'box': [243, 334, 76, 76], 'confidence': 0.6653152108192444},\n", + " {'box': [454, 338, 29, 29], 'confidence': 0.6650230884552002},\n", + " {'box': [49, 95, 22, 22], 'confidence': 0.6635971069335938},\n", + " {'box': [321, 84, 55, 55], 'confidence': 0.6603143215179443},\n", + " {'box': [480, 325, 31, 31], 'confidence': 0.6586322784423828},\n", + " {'box': [294, 135, 24, 24], 'confidence': 0.6576036810874939},\n", + " {'box': [60, 347, 39, 39], 'confidence': 0.6554562449455261},\n", + " {'box': [458, 406, 21, 21], 'confidence': 0.65467768907547},\n", + " {'box': [342, 138, 23, 23], 'confidence': 0.6540101766586304},\n", + " {'box': [540, 441, 20, 22], 'confidence': 0.653633713722229},\n", + " {'box': [300, 127, 25, 25], 'confidence': 0.6521259546279907},\n", + " {'box': [170, 133, 54, 54], 'confidence': 0.6484688520431519},\n", + " {'box': [20, 192, 22, 22], 'confidence': 0.644957959651947},\n", + " {'box': [518, 296, 28, 28], 'confidence': 0.6440291404724121},\n", + " {'box': [245, 522, 43, 38], 'confidence': 0.6340025067329407},\n", + " {'box': [436, 367, 58, 58], 'confidence': 0.6332893967628479},\n", + " {'box': [234, 233, 108, 108], 'confidence': 0.6274054646492004},\n", + " {'box': [28, 85, 53, 53], 'confidence': 0.6244142055511475},\n", + " {'box': [254, 502, 30, 30], 'confidence': 0.624413788318634},\n", + " {'box': [319, 182, 37, 37], 'confidence': 0.6236416101455688},\n", + " {'box': [29, 21, 31, 31], 'confidence': 0.6222331523895264},\n", + " {'box': [9, 182, 33, 33], 'confidence': 0.6211090683937073},\n", + " {'box': [17, 248, 21, 21], 'confidence': 0.6192639470100403},\n", + " {'box': [141, 398, 54, 54], 'confidence': 0.618570864200592},\n", + " {'box': [74, 386, 30, 30], 'confidence': 0.6184467673301697},\n", + " {'box': [198, 203, 28, 28], 'confidence': 0.6183221936225891},\n", + " {'box': [336, 103, 22, 22], 'confidence': 0.6169424653053284},\n", + " {'box': [253, 530, 30, 30], 'confidence': 0.6161786317825317},\n", + " {'box': [199, 58, 77, 77], 'confidence': 0.6141642332077026},\n", + " {'box': [510, 87, 41, 41], 'confidence': 0.6061983704566956},\n", + " {'box': [23, 212, 39, 39], 'confidence': 0.6061719655990601},\n", + " {'box': [292, 267, 63, 63], 'confidence': 0.605388343334198},\n", + " {'box': [446, 25, 112, 112], 'confidence': 0.604427695274353},\n", + " {'box': [342, 147, 20, 20], 'confidence': 0.6038945317268372},\n", + " {'box': [33, 249, 30, 30], 'confidence': 0.6038562655448914}]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "markdown", + "id": "70b577d0-a8e1-4bee-afab-a088a7ae06dd", + "metadata": {}, + "source": [ + "The output of the processing is a set of bounding boxes along with a confidence score. We can see a plot of the output in the following cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7bf61a0e-951f-4739-9b40-b5f1f65d10dc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mtcnn.utils.plotting import plot\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.imshow(plot(image, result))" + ] + }, + { + "cell_type": "markdown", + "id": "cff2a205-6ae5-484c-a152-fbff0c0d4323", + "metadata": {}, + "source": [ + "As can be seen, the PNet is proposing several bounding boxes, which must be \"refined\" to discard those that do not fit. This is part of the RNet functionality." + ] + }, + { + "cell_type": "markdown", + "id": "4ff0002c-4075-488f-a61b-d1ca0f8af5f7", + "metadata": {}, + "source": [ + "### Accessing PNet's model\n", + "\n", + "The network can be accessed by instantiating StagePNet and reading the attribute `model`, which is a TensorFlow model." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e9d020f1-f6b0-4dc6-aed0-06deefb4b6ed", + "metadata": {}, + "outputs": [], + "source": [ + "stage = StagePNet()\n", + "model = stage.model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c54f29b1-e00c-4631-bfa4-c2b5b119c260", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"p_net_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"p_net_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv1 (Conv2D)                  │ (None, None, None, 10) │           280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu1 (PReLU)                  │ (None, None, None, 10) │            10 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling1 (MaxPooling2D)      │ (None, None, None, 10) │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2 (Conv2D)                  │ (None, None, None, 16) │         1,456 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu2 (PReLU)                  │ (None, None, None, 16) │            16 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv3 (Conv2D)                  │ (None, None, None, 32) │         4,640 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu3 (PReLU)                  │ (None, None, None, 32) │            32 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv4-1 (Conv2D)                │ (None, None, None, 4)  │           132 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv4-2 (Conv2D)                │ (None, None, None, 2)  │            66 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu1 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m10\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m1,456\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu2 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m16\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m4,640\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu3 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m32\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv4-1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m132\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv4-2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m66\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 6,632 (25.91 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m6,632\u001b[0m (25.91 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 6,632 (25.91 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m6,632\u001b[0m (25.91 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "4dec95d0-7e60-445d-8eaa-7d0253317923", + "metadata": {}, + "source": [ + "### Loading PNet's weights\n", + "\n", + "The model weights are stored within the folder local `mtcnn/assets/weights/` under the filename `pnet.lz4`. It can be loaded with `joblib`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e2f87908-6030-4d15-8b2c-958eb14a9224", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "pnet_weights = joblib.load(\"../mtcnn/assets/weights/pnet.lz4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0d971b38-2bbc-4f02-b512-329fd57c43ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(pnet_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "69ba99a3-efe9-4792-a968-15e5d73e4457", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(3, 3, 3, 10),\n", + " (10,),\n", + " (1, 1, 10),\n", + " (3, 3, 10, 16),\n", + " (16,),\n", + " (1, 1, 16),\n", + " (3, 3, 16, 32),\n", + " (32,),\n", + " (1, 1, 32),\n", + " (1, 1, 32, 4),\n", + " (4,),\n", + " (1, 1, 32, 2),\n", + " (2,)]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[w.shape for w in pnet_weights]" + ] + }, + { + "cell_type": "markdown", + "id": "533da567-99e6-4c0b-beab-93a58c6d0e4c", + "metadata": {}, + "source": [ + "Further stage ablation can be performed by looking at `mtcnn/stages/stage_pnet.py`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3fb18783-1d83-4544-9c94-b3807be4b12b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (mamba3.11)", + "language": "python", + "name": "mamba3.11" + }, + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks-docs/rnet_ablation.ipynb b/docs/notebooks-docs/rnet_ablation.ipynb new file mode 100644 index 0000000..226b08f --- /dev/null +++ b/docs/notebooks-docs/rnet_ablation.ipynb @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "78ccfbad-54da-4945-b4a3-45b0eb9fc364", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"..\")" + ] + }, + { + "cell_type": "markdown", + "id": "ef4362f8-1bbb-46c5-b5f7-b5186b392051", + "metadata": {}, + "source": [ + "# MTCNN RNet\n", + "\n", + "This notebook demonstrates the RNet architecture and its corresponding weights.\n", + "\n", + "RNet is a convolutional neural network (CNN) with fully connected layers (FC) used in the second stage of MTCNN. This network refines the bounding box proposals generated by the previous PNet stage. It produces two outputs:\n", + "\n", + "* Regression of the bounding box coordinates to further refine the initial proposals.\n", + "* Classification of the proposals into two categories: no-face or face.\n", + "\n", + "The outputs are generated for each bounding box proposal, refining the results from the previous stage. \n", + "While RNet has the same functionality as PNet, it processes each proposal individually, with a fixed-size input, using the crops from the output of the previous stage as input.\n", + "\n", + "In the following sections, we will run the MTCNN model, focusing solely on the RNet stage. We will examine the intermediate inputs, observe the output shapes, and visualize the results." + ] + }, + { + "cell_type": "markdown", + "id": "b43678c3-225a-4f03-84c4-130c4c62a2bb", + "metadata": {}, + "source": [ + "## MTCNN on RNet Stage\n", + "\n", + "MTCNN can be configured to run up to the second stage, which will provide the direct output of the RNet stage." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3431815e-6a07-4a8b-8a2d-d454d4a3a4b9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:09:03.399323: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-10-02 19:09:03.409085: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-02 19:09:03.421049: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-02 19:09:03.424652: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-02 19:09:03.433483: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-02 19:09:04.112111: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "from mtcnn import MTCNN\n", + "from mtcnn.utils.images import load_image\n", + "from mtcnn.stages import StagePNet, StageRNet" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8f9b8423-64ec-4f23-91f7-9dcd85e85682", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:09:04.860887: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1044 MB memory: -> device: 0, name: NVIDIA RTX A6000, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2024-10-02 19:09:04.861271: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 7363 MB memory: -> device: 1, name: NVIDIA GeForce GTX 1070, pci bus id: 0000:17:00.0, compute capability: 6.1\n" + ] + } + ], + "source": [ + "image = load_image(\"../resources/ivan.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "85710efe-fac4-472f-91b7-dceb211d9965", + "metadata": {}, + "outputs": [], + "source": [ + "mtcnn = MTCNN(stages=[StagePNet, StageRNet], device=\"CPU:0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1516fdd4-794e-4e81-bcdd-6be6a45cb570", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 614 ms, sys: 163 ms, total: 776 ms\n", + "Wall time: 415 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "result = mtcnn.detect_faces(image, postprocess=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "57c31ee3-ef28-4010-a903-38173ac9364a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'box': [269, 92, 67, 67], 'confidence': 0.9900748133659363},\n", + " {'box': [478, 280, 60, 60], 'confidence': 0.9535849094390869},\n", + " {'box': [100, 407, 42, 42], 'confidence': 0.9220193028450012},\n", + " {'box': [9, 72, 30, 30], 'confidence': 0.9089504480361938},\n", + " {'box': [486, 205, 61, 61], 'confidence': 0.8844603896141052},\n", + " {'box': [7, 71, 43, 43], 'confidence': 0.8773281574249268},\n", + " {'box': [187, 119, 32, 32], 'confidence': 0.7967076897621155},\n", + " {'box': [305, 181, 48, 48], 'confidence': 0.7636563181877136},\n", + " {'box': [279, 104, 50, 50], 'confidence': 0.7341133952140808},\n", + " {'box': [176, 134, 58, 58], 'confidence': 0.7229615449905396}]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1e361a8b-ea17-41b3-950b-8a30c89040db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mtcnn.utils.plotting import plot\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.imshow(plot(image, result))" + ] + }, + { + "cell_type": "markdown", + "id": "820648d8-bc52-44c4-9000-12ebef684ffc", + "metadata": {}, + "source": [ + "As can be seen, the RNet is refining proposals by discarding those that do not match the thresholds, and adjusting those that matched." + ] + }, + { + "cell_type": "markdown", + "id": "b2f0227a-4437-4e07-8661-9239ae88988d", + "metadata": {}, + "source": [ + "### Accessing RNet's model\n", + "\n", + "The network can be accessed by instantiating StageRNet and reading the attribute `model`, which is a TensorFlow model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "85692cac-f01a-4e51-812d-6697c4b4eb95", + "metadata": {}, + "outputs": [], + "source": [ + "stage = StageRNet()\n", + "model = stage.model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b5b0d71f-c4f4-4df2-89dd-66091cd3f9fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"r_net_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"r_net_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv1 (Conv2D)                  │ (None, 22, 22, 28)     │           784 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu1 (PReLU)                  │ (None, 22, 22, 28)     │            28 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling1 (MaxPooling2D)      │ (None, 11, 11, 28)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2 (Conv2D)                  │ (None, 9, 9, 48)       │        12,144 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu2 (PReLU)                  │ (None, 9, 9, 48)       │            48 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling2 (MaxPooling2D)      │ (None, 4, 4, 48)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv3 (Conv2D)                  │ (None, 3, 3, 64)       │        12,352 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu3 (PReLU)                  │ (None, 3, 3, 64)       │            64 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ permute (Permute)               │ (None, 3, 3, 64)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten3 (Flatten)              │ (None, 576)            │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc4 (Dense)                     │ (None, 128)            │        73,856 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu4 (PReLU)                  │ (None, 128)            │           128 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc5-1 (Dense)                   │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc5-2 (Dense)                   │ (None, 2)              │           258 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m784\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu1 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m28\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m48\u001b[0m) │ \u001b[38;5;34m12,144\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu2 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m48\u001b[0m) │ \u001b[38;5;34m48\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m48\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m12,352\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu3 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ permute (\u001b[38;5;33mPermute\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten3 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m576\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc4 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu4 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc5-1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc5-2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m258\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 100,178 (391.32 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m100,178\u001b[0m (391.32 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 100,178 (391.32 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m100,178\u001b[0m (391.32 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "c6719b2c-432a-498e-ada7-c9ea962a93c7", + "metadata": {}, + "source": [ + "### Loading RNet's weights\n", + "\n", + "The model weights are stored within the folder local `mtcnn/assets/weights/` under the filename `rnet.lz4`. It can be loaded with `joblib`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cfe6688e-1bc8-46ad-920a-7c338419e4a2", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "rnet_weights = joblib.load(\"../mtcnn/assets/weights/rnet.lz4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "79400bef-8b41-481a-b375-3179732f8263", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "16" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(rnet_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "27d8782a-4dfd-4bde-8006-51b9124fda9e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(3, 3, 3, 28),\n", + " (28,),\n", + " (1, 1, 28),\n", + " (3, 3, 28, 48),\n", + " (48,),\n", + " (1, 1, 48),\n", + " (2, 2, 48, 64),\n", + " (64,),\n", + " (1, 1, 64),\n", + " (576, 128),\n", + " (128,),\n", + " (128,),\n", + " (128, 4),\n", + " (4,),\n", + " (128, 2),\n", + " (2,)]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[w.shape for w in rnet_weights]" + ] + }, + { + "cell_type": "markdown", + "id": "14a82ac3-d289-4cbb-9cc4-58603dc6c543", + "metadata": {}, + "source": [ + "Further stage ablation can be performed by looking at `mtcnn/stages/stage_rnet.py`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f96a7b5-f738-4b04-afcc-025129b14ca0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (mamba3.11)", + "language": "python", + "name": "mamba3.11" + }, + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/references.md b/docs/references.md new file mode 100644 index 0000000..9cd40b6 --- /dev/null +++ b/docs/references.md @@ -0,0 +1,58 @@ +# References + +This document provides a detailed list of references, including the original research papers and projects that served as the foundation for this MTCNN implementation. Additionally, it includes information on how to properly cite this work if used in your research or projects. + +## Citation + +If you use this library in your research or projects, please consider citing the original paper where the MTCNN model was introduced. This paper presents the Joint Face Detection and Alignment using Multitask Cascaded Convolutional Networks, a groundbreaking approach for face detection and landmark alignment. + +### Original Paper: + +- **Authors**: K. Zhang, Z. Zhang, Z. Li, and Y. Qiao +- **Journal**: IEEE Signal Processing Letters +- **Title**: Joint Face Detection and Alignment Using Multitask Cascaded Convolutional Networks +- **Year**: 2016 +- **Volume**: 23 +- **Number**: 10 +- **Pages**: 1499-1503 +- **Keywords**: Benchmark testing, Computer architecture, Convolution, Detectors, Face, Face detection, Training, Cascaded convolutional neural network (CNN), Face alignment +- **DOI**: [10.1109/LSP.2016.2603342](https://doi.org/10.1109/LSP.2016.2603342) + +```bibtex +@article{7553523, + author={K. Zhang and Z. Zhang and Z. Li and Y. Qiao}, + journal={IEEE Signal Processing Letters}, + title={Joint Face Detection and Alignment Using Multitask Cascaded Convolutional Networks}, + year={2016}, + volume={23}, + number={10}, + pages={1499-1503}, + keywords={Benchmark testing;Computer architecture;Convolution;Detectors;Face;Face detection;Training;Cascaded convolutional neural network (CNN);face alignment;face detection}, + doi={10.1109/LSP.2016.2603342}, + ISSN={1070-9908}, + month={Oct} +} +``` + +### Abstract of the Original Paper: +The paper presents a multitask cascaded convolutional network (MTCNN) for joint face detection and alignment. This method integrates the detection and alignment process into a unified architecture, which significantly enhances the accuracy and speed of facial landmark localization. The system uses a three-stage network to predict face locations and landmarks iteratively, improving the results progressively across each stage. + +## Original MTCNN Repository + +This library is based on the original implementation by Kaipeng Zhang, who made the pretrained networks and the code available for the research community. If you are using the models or weights provided in this library, you may also consider citing the original GitHub repository: + +- **[Original MTCNN Implementation by Kaipeng Zhang](https://github.com/kpzhang93/MTCNN_face_detection_alignment/tree/master/code)** + +This repository includes the source code, pre-trained weights, and additional information related to the original MTCNN framework, all released under the MIT license. + +## Related Work + +This project also draws inspiration from the **FaceNet's MTCNN implementation** by David Sandberg. This implementation is part of a larger face recognition framework called FaceNet, which uses the MTCNN architecture to handle the task of face alignment prior to recognition. You may also want to refer to this project if you are using concepts from this work: + +- **[Facenet's MTCNN implementation](https://github.com/davidsandberg/facenet/tree/master/src/align)** + + +## About this project + +The code for this project was created to standardize face detection and provide an easy-to-use framework that helps the research community push the boundaries of AI knowledge. Learn more about the author of this code on [Iván de Paz Centeno's website](https://ipazc.com) + diff --git a/docs/stages.md b/docs/stages.md new file mode 100644 index 0000000..83f05f2 --- /dev/null +++ b/docs/stages.md @@ -0,0 +1,121 @@ +## Networks and Stages in MTCNN + +MTCNN (Multitask Cascaded Convolutional Networks) is a powerful framework for face detection and alignment, built around three main networks: **PNet**, **RNet**, and **ONet**. These networks are organized into distinct *stages*, each refining the output of the previous one. Together, they enable MTCNN to achieve high accuracy in face detection and landmark alignment. + +### Overview of Stages and Networks + +The MTCNN pipeline consists of three stages: + +- **Stage 1 (PNet)**: The Proposal Network stage, where initial candidate face regions are generated. +- **Stage 2 (RNet)**: The Refinement Network stage, where these proposals are refined and filtered. +- **Stage 3 (ONet)**: The Output Network stage, where the final bounding boxes and facial landmarks are predicted. + +Each stage includes the following key operations: + +1. **Image pyramid scaling** (in Stage 1 only). +2. **Face detection and bounding box regression**. +3. **Non-Maximum Suppression (NMS)** with thresholds to filter out overlapping and low-confidence boxes. +4. **Landmark regression** (in Stage 3). + +Now, let’s break down each stage and its corresponding network. + +--- + +### 1. Stage 1: PNet and Image Pyramid Construction + +#### Function of Stage 1 + +The first stage of MTCNN uses the **Proposal Network (PNet)** to scan the image at multiple scales. Since faces can appear at different sizes, the input image is **scaled down progressively** to create an *image pyramid*. This allows PNet to detect faces at various sizes across the image. + +At each scale, PNet slides over the image and generates **bounding box proposals** for regions that might contain faces. These proposals include: + +- **Bounding Box Regressions**: Initial estimates for the bounding boxes. +- **Face/Non-Face Classification**: A score indicating whether a region contains a face or not. + +#### Image Pyramid and Proposal Generation + +1. **Image Pyramid Construction**: The input image is scaled down multiple times, forming an image pyramid. Each scale produces a resized image, and the smallest scale ensures that even small faces are detected. + +2. **PNet Processing**: For each scaled image, PNet scans regions using a sliding window, proposing candidate face regions and outputting bounding boxes and confidence scores. + +3. **Scale-Specific NMS**: For each scale, PNet outputs a set of candidate regions. These are processed with **Non-Maximum Suppression (NMS)** to remove overlapping boxes that likely represent the same face. A **threshold** controls how aggressive the NMS is at filtering boxes. + +4. **Aggregate Proposals Across Scales**: The candidate boxes from all scales are combined into a single list. NMS is applied again to merge overlapping detections across scales, ensuring that only the best bounding boxes remain. + +#### Strengths of PNet +- The image pyramid ensures detection of faces at multiple scales. +- PNet is fast and efficient, generating many face proposals in a short amount of time. + +```text +Input Image -> Image Pyramid -> PNet -> Scale-specific NMS -> Combined Proposals -> Final NMS +``` + +--- + +### 2. Stage 2: RNet (Refinement Network) + +#### Function of Stage 2 + +After the proposals from PNet are filtered through NMS, they are passed to the **Refinement Network (RNet)**. The purpose of RNet is to further refine these bounding boxes, rejecting **false positives** and improving the precision of the face regions. Like PNet, RNet performs: + +- **Bounding Box Regression**: Adjusts the bounding boxes to better fit the faces. +- **Face/Non-Face Classification**: Classifies whether each region contains a face or not. + +#### Key Operations in RNet + +1. **Input from PNet**: The refined proposals from PNet are cropped from the original image and resized to a standard size before being fed into RNet. + +2. **Bounding Box Refinement**: RNet processes these regions and further refines the bounding box coordinates, producing a more accurate estimate of where the face is located. + +3. **Face Classification and NMS**: RNet classifies each region as face or non-face and applies another round of **NMS** to filter out overlapping or low-confidence detections. This stage also has a specific **NMS threshold**, which controls how strictly overlapping boxes are filtered. + +#### Strengths of RNet +- RNet provides more accurate bounding box predictions and reduces false positives. +- The additional round of NMS refines the proposals from PNet, resulting in better precision. + +```text +Refined Proposals -> RNet -> Bounding Box Refinement -> NMS -> Refined Detections +``` + +--- + +### 3. Stage 3: ONet (Output Network) + +#### Function of Stage 3 + +In the final stage, the **Output Network (ONet)** refines the bounding boxes even further and detects **five facial landmarks** (eyes, nose, and mouth corners). ONet provides three outputs: + +- **Bounding Box Regression**: Final adjustments to the bounding boxes. +- **Face/Non-Face Classification**: Classifies whether a region contains a face or not. +- **Landmark Regression**: Predicts the positions of five facial landmarks for each face. + +#### Key Operations in ONet + +1. **Input from RNet**: The refined regions from RNet are again cropped and resized to the appropriate input size for ONet. + +2. **Final Bounding Box Refinement**: ONet produces the final adjustments to the bounding boxes, ensuring maximum accuracy in detecting the face regions. + +3. **Facial Landmark Detection**: In addition to bounding boxes, ONet predicts the coordinates of five key landmarks (left eye, right eye, nose, left mouth corner, right mouth corner). + +4. **NMS with Landmark Consideration**: The final round of **NMS** is applied, but this time the landmark predictions are also taken into account when merging overlapping boxes. The NMS threshold is tuned to preserve the best bounding boxes and corresponding landmarks. + +#### Strengths of ONet +- ONet provides highly accurate face detection results, as well as landmark predictions that are essential for facial alignment tasks. +- The final NMS ensures that the best bounding boxes and landmarks are kept while filtering redundant detections. + +```text +Final Proposals -> ONet -> Bounding Box Refinement -> Landmark Detection -> NMS -> Final Bounding Boxes + Landmarks +``` + +--- + +### Thresholds and Non-Maximum Suppression (NMS) + +Throughout the MTCNN pipeline, **Non-Maximum Suppression (NMS)** is a key operation used to filter overlapping bounding boxes. Each stage of the network applies NMS after detecting face proposals. NMS removes redundant boxes by keeping only the box with the highest confidence score when there are multiple overlapping boxes representing the same face. + +At each stage, a **threshold** is applied to control how aggressively NMS filters the proposals: + +- **PNet NMS Threshold**: This threshold is more lenient to keep as many proposals as possible in the early stage. +- **RNet NMS Threshold**: A stricter threshold is used to discard false positives and refine the bounding boxes. +- **ONet NMS Threshold**: The strictest threshold is used to produce the final high-confidence detections. + diff --git a/docs/training.md b/docs/training.md new file mode 100644 index 0000000..3b09e8f --- /dev/null +++ b/docs/training.md @@ -0,0 +1,349 @@ +## Training MTCNN Networks: PNet, RNet, ONet + +MTCNN consists of three convolutional neural networks: **PNet**, **RNet**, and **ONet**, each responsible for different stages of face detection and landmark prediction. In this guide, we will explain the following: + +- The architecture of each model (PNet, RNet, ONet). +- How to generate a dataset to train each network. +- The process for training the networks. +- How to save and load the trained weights. + +### 1. Model Architectures + +The three networks that make up MTCNN are progressively more complex, each building upon the output of the previous network. Below are the detailed architectures for PNet, RNet, and ONet. + +#### PNet (Proposal Network) +PNet is responsible for generating initial face region proposals. It works by sliding over an image and outputting bounding boxes and a face/non-face classification score. + +``` +Model: "p_net_1" +┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ +┃ Layer (type) ┃ Output Shape ┃ Param # ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ +│ conv1 (Conv2D) │ (None, None, None, 10) │ 280 │ +│ prelu1 (PReLU) │ (None, None, None, 10) │ 10 │ +│ maxpooling1 (MaxPooling)│ (None, None, None, 10) │ 0 │ +│ conv2 (Conv2D) │ (None, None, None, 16) │ 1,456 │ +│ prelu2 (PReLU) │ (None, None, None, 16) │ 16 │ +│ conv3 (Conv2D) │ (None, None, None, 32) │ 4,640 │ +│ prelu3 (PReLU) │ (None, None, None, 32) │ 32 │ +│ conv4-1 (Conv2D) │ (None, None, None, 4) │ 132 │ +│ conv4-2 (Conv2D) │ (None, None, None, 2) │ 66 │ +└─────────────────────────┴─────────────────────────┴───────────────┘ +Total params: 6,632 +``` + +The tensorflow model can be directly loaded with: + +```python +from mtcnn.network import PNet +import tensorflow as tf + +inp_layer = tf.keras.layers.Input((None, None, 3)) +out_layer = PNet()(inp_layer) +pnet = tf.keras.models.Model(inp_layer, out_layer) +``` + +#### RNet (Refinement Network) +RNet refines the face proposals generated by PNet and rejects false positives. It also outputs refined bounding boxes and face/non-face classification scores. + +``` +Model: "r_net_1" +┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ +┃ Layer (type) ┃ Output Shape ┃ Param # ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ +│ conv1 (Conv2D) │ (None, 22, 22, 28) │ 784 │ +│ prelu1 (PReLU) │ (None, 22, 22, 28) │ 28 │ +│ maxpooling1 (MaxPooling)│ (None, 11, 11, 28) │ 0 │ +│ conv2 (Conv2D) │ (None, 9, 9, 48) │ 12,144 │ +│ prelu2 (PReLU) │ (None, 9, 9, 48) │ 48 │ +│ maxpooling2 (MaxPooling)│ (None, 4, 4, 48) │ 0 │ +│ conv3 (Conv2D) │ (None, 3, 3, 64) │ 12,352 │ +│ prelu3 (PReLU) │ (None, 3, 3, 64) │ 64 │ +│ flatten3 (Flatten) │ (None, 576) │ 0 │ +│ fc4 (Dense) │ (None, 128) │ 73,856 │ +│ prelu4 (PReLU) │ (None, 128) │ 128 │ +│ fc5-1 (Dense) │ (None, 4) │ 516 │ +│ fc5-2 (Dense) │ (None, 2) │ 258 │ +└─────────────────────────┴─────────────────────────┴───────────────┘ +Total params: 100,178 +``` + +The tensorflow model can be directly loaded with: + +```python +from mtcnn.network import RNet +import tensorflow as tf + +inp_layer = tf.keras.layers.Input((24, 24, 3)) +out_layer = RNet()(inp_layer) +rnet = tf.keras.models.Model(inp_layer, out_layer) +``` + + +#### ONet (Output Network) +ONet is the final stage, responsible for providing the most precise bounding boxes and detecting facial landmarks. + +``` +Model: "o_net_1" +┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ +┃ Layer (type) ┃ Output Shape ┃ Param # ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ +│ conv1 (Conv2D) │ (None, 46, 46, 32) │ 896 │ +│ prelu1 (PReLU) │ (None, 46, 46, 32) │ 32 │ +│ maxpooling1 (MaxPooling)│ (None, 23, 23, 32) │ 0 │ +│ conv2 (Conv2D) │ (None, 21, 21, 64) │ 18,496 │ +│ prelu2 (PReLU) │ (None, 21, 21, 64) │ 64 │ +│ conv3 (Conv2D) │ (None, 8, 8, 64) │ 36,928 │ +│ flatten4 (Flatten) │ (None, 1152) │ 0 │ +│ fc5 (Dense) │ (None, 256) │ 295,168 │ +│ prelu5 (PReLU) │ (None, 256) │ 256 │ +│ fc6-1 (Dense) │ (None, 4) │ 1,028 │ +│ fc6-2 (Dense) │ (None, 10) │ 2,570 │ +│ fc6-3 (Dense) │ (None, 2) │ 514 │ +└─────────────────────────┴─────────────────────────┴───────────────┘ +Total params: 389,040 +``` + +The tensorflow model can be directly loaded with: + +```python +from mtcnn.network import ONet +import tensorflow as tf + +inp_layer = tf.keras.layers.Input((48, 48, 3)) +out_layer = ONet()(inp_layer) +onet = tf.keras.models.Model(inp_layer, out_layer) +``` + + +#### Feeding the networks + +You can try to feed the networks with random inputs and check the result tensor shapes: + +```python +>>> import numpy as np + +>>> # PNET +>>> dummy_input = np.random.randn(1, 100, 100, 3) # batch of 1 image with 100x100 pixels and 3 channels +>>> result = onet(dummy_input) +>>> print(result[0].shape) # BBOX regression +(1, 45, 45, 4) +>>> print(result[1].shape) # Face classification +(1, 45, 45, 2) + +# RNET +>>> dummy_input = np.random.randn(10, 24, 24, 3) # batch of 10 images with 24x24 pixels and 3 channels (crops, fixed-size) +>>> result = rnet(dummy_input)) +>>> print(result[0].shape) # BBOX regression +(10, 4) +>>> print(result[1].shape) # Face classification +(10, 2) + +# ONET +dummy_input = np.random.randn(10, 48, 48, 3) # batch of 10 images with 48x48 pixels and 3 channels (crops, fixed-size) +result = onet(np.random.randn(10, 48, 48, 3)) +print(result[0].shape) # BBOX regression +(10, 4) +print(result[1].shape) # Landmarks regression +(10, 10) +print(result[2].shape) # Face classification +(10, 2) +``` + + +--- + +### 2. Preparing the Dataset for Training + +Each network in MTCNN (PNet, RNet, ONet) requires specific formats for the input and output data. Below, we describe how to structure the dataset for each network, including the expected shapes for the bounding boxes, classifications, and facial landmarks. Additionally, we explain the preprocessing steps required to prepare images for each network. + +#### Input and Output Formats + +- **Bounding Boxes**: + + - Format: `(x1, y1, x2, y2)` + - `x1, y1`: Coordinates of the top-left corner of the bounding box. + - `x2, y2`: Coordinates of the bottom-right corner of the bounding box. + + - Shape: For each image, the output bounding boxes are structured as a 4-element array `[x1, y1, x2, y2]`. Hence, expected result is a vector of shape (batch_size, 4) + +2. **Classifications**: + - MTCNN uses a **multiclass classification** output with 2 categories: + - `0`: Non-face region. + - `1`: Face region. + - The classification is encoded as a **one-hot vector** of two categories: + - For non-face: `[1, 0]`. + - For face: `[0, 1]`. + - Shape: For each image, the classification is a 2-element array, `[non-face, face]`. Hence, expected result is a one-hot-vector of shape (batch_size, 2) + +3. **Landmarks** (for ONet only): + - Format: `5` landmarks, where each landmark has two coordinates `(x, y)`. The order is: + 1. Left eye. + 2. Right eye. + 3. Nose. + 4. Left mouth corner. + 5. Right mouth corner. + + - The predicted landmarks are structured as two consecutive arrays: first the `x` coordinates, then the `y` coordinates. + - Example: `[x_left_eye, x_right_eye, x_nose, x_mouth_left, x_mouth_right, y_left_eye, y_right_eye, y_nose, y_mouth_left, y_mouth_right]` + + - Shape: A 10-element array for each image. Hence, expected result is vector of shape (batch_size, 10) + +--- + +### 3. Dataset Preparation for Each Network + +Since each network (PNet, RNet, ONet) performs progressively more refined tasks, the dataset and preprocessing required differ for each stage. Below is the dataset preparation workflow for each network. + +#### A. PNet (Proposal Network) + +**Task**: Generate initial face region proposals from multiple image scales. + +**Input**: + +- **Images**: Input images are resized to multiple scales (image pyramid) to detect faces of various sizes. +- **Labels**: + - **Bounding Boxes**: For each image, annotate face regions with bounding boxes in the format `[x1, y1, x2, y2]`. + - **Classifications**: For each bounding box, generate one-hot encoded labels `[non-face, face]`. + +**Output**: + +- PNet outputs: + - **Bounding Box Regression**: The predicted bounding boxes for face regions. + - **Classifications**: Whether a region contains a face (one-hot encoding). + +**Preprocessing**: + +1. **Image Pyramid**: Scale each image to multiple resolutions (typically downsampled by a factor of 0.709) to create an image pyramid. +2. **Sliding Window Detection**: For each scale, PNet slides a window over the image, generating bounding boxes and classifications. +3. **Dataset**: + - Prepare multiple scales of each image. + - Annotate each scale with the corresponding bounding boxes and classifications. + +**Training**: + +- Input: Image scales. +- Output: Bounding boxes and face/non-face classifications. +- The network learns to propose candidate face regions from different scales of the input image. + +--- + +#### B. RNet (Refinement Network) + +**Task**: Refine the bounding box proposals from PNet and reject false positives. + +**Input**: + +- **Cropped Face Proposals**: After PNet generates bounding boxes, use them to crop the face regions from the original images. +- **Labels**: + + - **Refined Bounding Boxes**: Provide corrections for the bounding boxes proposed by PNet. This involves calculating the difference between the proposed bounding box and the ground truth bounding box in the format `[x1, y1, x2, y2]`. + - **Classifications**: One-hot encoded labels `[non-face, face]` for each proposed region. + +**Output**: + +- RNet outputs: + + - **Refined Bounding Boxes**: The improved coordinates of the face regions. + - **Classifications**: Whether the refined region contains a face (one-hot encoding). + +**Preprocessing**: + +1. **Cropped Face Regions**: Use the bounding box proposals from PNet to crop the face regions from the original image. +2. **Scale and Align**: Resize the cropped regions to the required input size for RNet. +3. **Bounding Box Regression**: For each cropped face, calculate the adjustment needed to align the PNet bounding box with the ground truth bounding box. +4. **Dataset**: + + - For each cropped region, provide the bounding box adjustments and the one-hot encoded face/non-face label. + +**Training**: + +- Input: Cropped face proposals (resized to the input size of RNet). +- Output: Refined bounding boxes and face classifications. + +--- + +#### C. ONet (Output Network) + +**Task**: Further refine bounding boxes and predict facial landmarks. + +**Input**: + +- **Cropped Face Proposals**: Similar to RNet, but the crops are passed from RNet’s refined bounding boxes. +- **Labels**: + - **Final Bounding Boxes**: Provide final bounding box corrections based on the ground truth in the format `[x1, y1, x2, y2]`. + - **Landmarks**: For each face region, provide the coordinates of the 5 landmarks (left eye, right eye, nose, left mouth corner, right mouth corner) in the format `[x_left_eye, x_right_eye, x_nose, x_mouth_left, x_mouth_right, y_left_eye, y_right_eye, y_nose, y_mouth_left, y_mouth_right]`. + - **Classifications**: One-hot encoded labels `[non-face, face]` for each proposed region. + +**Output**: + +- ONet outputs: + + - **Final Bounding Boxes**: The precise coordinates of the face regions. + - **Landmarks**: The `(x, y)` coordinates for the 5 key facial landmarks. + - **Classifications**: Whether the region contains a face (one-hot encoding). + +**Preprocessing**: + +1. **Cropped Face Regions**: Use RNet’s output to crop the face regions from the original image. +2. **Scale and Align**: Resize the cropped regions to ONet’s input size. +3. **Bounding Box Regression**: For each cropped face, calculate the adjustment needed for the bounding box. +4. **Landmark Annotation**: Provide the coordinates for the 5 key facial landmarks. +5. **Dataset**: + - Each image must have final bounding box adjustments, face classifications, and landmark annotations. + +**Training**: + +- Input: Cropped face regions. +- Output: Final bounding boxes, face classifications, and landmarks. + +--- + +### 4. Training Process + +Once the dataset is prepared, the training process involves: + +1. **Loading the Dataset**: Use the prepared dataset (images, bounding boxes, classifications, and landmarks). +2. **Model Compilation**: Each network is compiled with appropriate loss functions: + - **Bounding Box Loss**: Mean squared error (MSE) or smooth L1 loss for bounding box regression. + - **Classification Loss**: Categorical cross-entropy for face/non-face classification. + - **Landmark Loss** (for ONet): Mean squared error for landmark regression. +3. **Training**: Call `.fit()` on the model, passing the input data and the corresponding outputs. + +--- + +### 5. Saving and Loading Weights + +After training, you should save the model weights in a compressed format using `joblib` with LZ4 compression. Here’s how you can do it: + +```python +import joblib + +# Saving the weights +joblib.dump(pnet.get_weights(), "pnet.lz4", compress=("lz4", 1)) +joblib.dump(rnet.get_weights(), "rnet.lz4", compress=("lz4", 1)) +joblib.dump(onet.get_weights(), "onet.lz4", compress=("lz4", 1)) +``` + +To load the weights into the models: + +```python +from mtcnn.stages import StagePNet, StageRNet, StageONet + +stage_pnet = StagePNet(weights="pnet.lz4") +stage_rnet = StageRNet(weights="rnet.lz4") +stage_onet = StageONet(weights="onet.lz4") + +from mtcnn import MTCNN + +mtcnn = MTCNN(stages=[stage_pnet, stage_rnet, stage_onet]) +``` + +--- + +### Conclusion + +This guide covers the preparation of datasets, the specific formats required for each network, and the training process for PNet, RNet, and ONet. Each network performs progressively refined tasks, requiring different preprocessing steps and annotations. By following this guide, +you can train MTCNN models on your custom datasets and use them for +accurate face detection and landmark prediction. + diff --git a/docs/usage.md b/docs/usage.md new file mode 100644 index 0000000..e676baf --- /dev/null +++ b/docs/usage.md @@ -0,0 +1,105 @@ +## Usage Guide for MTCNN + +This guide demonstrates how to use the MTCNN package for face detection and facial landmark recognition, along with image plotting for visualization. In this example, we will: + +- Load an image. +- Detect faces and landmarks using the MTCNN detector. +- Plot the results, including bounding boxes and facial landmarks. + +### 1. Importing Required Modules + +To begin, we need to import the MTCNN detector, image loading utility, and plotting functionality: + +```python +from mtcnn import MTCNN +from mtcnn.utils.images import load_image +from mtcnn.utils.plotting import plot +import matplotlib.pyplot as plt +``` + +### 2. Loading an Image + +We load an image from a file using the `load_image` utility function. In this example, the image is located in the `resources` directory: + +```python +image = load_image("../resources/ivan.jpg") +``` + +This will load the image as a tensor, ready to be processed by the MTCNN detector. + +### 3. Initializing the MTCNN Detector + +Next, we initialize the MTCNN detector. You can specify the device where the models should be loaded. In this case, we are loading the models on the CPU: + +```python +mtcnn = MTCNN(device="CPU:0") +``` + +### 4. Detecting Faces + +Once the image is loaded and the detector is initialized, we can detect faces in the image. The `detect_faces` method returns a list of dictionaries, each containing the bounding box, facial landmarks, and confidence score for each detected face. + +```python +result = mtcnn.detect_faces(image) +``` + +The `result` will contain the bounding box and facial landmarks for each detected face, similar to the following format: + +```json +[ + { + "box": [277, 90, 48, 63], + "keypoints": { + "nose": (303, 131), + "mouth_right": (313, 141), + "right_eye": (314, 114), + "left_eye": (291, 117), + "mouth_left": (296, 143) + }, + "confidence": 0.9985 + } +] +``` + +### 5. Plotting the Results + +To visualize the results, including the bounding boxes and facial landmarks, we can use the `plot` function from `mtcnn.utils.plotting`, which overlays the detection results on the original image. We then display the image using `matplotlib`: + +```python +plt.imshow(plot(image, result)) +plt.show() +``` + +This will display the image with the detected faces, drawing bounding boxes and marking the facial landmarks. + +### Full Example Code + +Here’s the full code for loading an image, detecting faces, and plotting the results: + +```python +from mtcnn import MTCNN +from mtcnn.utils.images import load_image +from mtcnn.utils.plotting import plot +import matplotlib.pyplot as plt + +# Load the image +image = load_image("../resources/ivan.jpg") + +# Initialize MTCNN detector +mtcnn = MTCNN(device="CPU:0") + +# Detect faces and landmarks +result = mtcnn.detect_faces(image, threshold_onet=0.85) + +# Plot the results +plt.imshow(plot(image, result)) +plt.show() +``` +![Detection result](images/ivan_detection.png) + + +### Conclusion + +In this example, we have successfully loaded an image, detected faces and their landmarks using MTCNN, and visualized the results with bounding boxes and keypoints. MTCNN provides a simple and efficient interface for multitask face detection and alignment, with easy-to-use utilities for image processing and result visualization. + +For further customization, you can explore additional options such as adjusting detection thresholds or using different devices (e.g., GPU) for faster processing. diff --git a/docs/usage_advanced.md b/docs/usage_advanced.md new file mode 100644 index 0000000..4ddf316 --- /dev/null +++ b/docs/usage_advanced.md @@ -0,0 +1,147 @@ +## Advanced Usage: Batch Processing with MTCNN + +MTCNN supports batch processing, allowing you to detect faces in multiple images at once. This feature is especially useful for speeding up detection when processing a large number of images. In batch mode, MTCNN handles the padding and justification of smaller images internally, allowing the user to input a list of images directly or load them from URIs. + +### Key Differences in Batch Processing + +1. **Image Loading and Padding**: Images are passed as a list and then internally padded by MTCNN to match the size of the largest image in the batch. By default, smaller images are **centered** within the padded tensor, but this behavior can be customized using the `batch_stack_justification` parameter. +2. **Batching Across Scales**: When processing multiple images, MTCNN applies the same set of scales across all images in the batch. For example, if there are 10 images and 5 scales, MTCNN processes 10 images at a time for each scale. +3. **NMS and Postprocessing**: Non-Maximum Suppression (NMS) operates on each batch of images independently, filtering overlapping and low-confidence detections per image. Postprocessing ensures that bounding boxes are correctly adjusted to account for the padding added during tensor construction. + +### Workflow Overview + +1. Load a batch of images using `load_images_batch` or pass a list of image URIs directly to MTCNN. +2. MTCNN automatically standardizes the images by padding them and applying justification. +3. The detector processes each batch of images through the three stages (PNet, RNet, ONet) while applying NMS after each stage. +4. The final results include face detections and landmarks for all images in the batch, with postprocessing to adjust bounding box coordinates for padding. + +### Example: Detecting Faces in a Batch of Images + +In this example, we will: + +- Load a batch of images from disk. +- Detect faces and landmarks across the entire batch using MTCNN. +- Plot the results for each image in the batch. + +#### 1. Importing Required Modules + +First, import the necessary functions for loading images in batches, initializing the detector, and plotting the results: + +```python +from mtcnn import MTCNN +from mtcnn.utils.images import load_images_batch +from mtcnn.utils.plotting import plot +import matplotlib.pyplot as plt +``` + +#### 2. Loading a Batch of Images + +You can load multiple images into a list using `load_images_batch`. This function simply reads and returns the images without padding or standardizing them: + +```python +image_paths = ["../resources/image1.jpg", "../resources/image2.jpg", "../resources/image3.jpg"] +images = load_images_batch(image_paths) +``` + +At this point, `images` is just a list of loaded image tensors, with no padding or justification applied. + +#### 3. Initializing the MTCNN Detector + +As in single image processing, we initialize the MTCNN detector. The detector will automatically handle batch processing if you pass a list of images: + +```python +mtcnn = MTCNN(device="CPU:0") +``` + +You can specify `"GPU:0"` or another device if you want to leverage GPU acceleration. + +#### 4. Detecting Faces in Batch Mode + +The `detect_faces` method supports batch input and performs all necessary padding and justification internally. You can control how smaller images are aligned within the padded tensor using the `batch_stack_justification` parameter. The default is `"center"`, which centers smaller images within the padded tensor. + +```python +results = mtcnn.detect_faces(images, batch_stack_justification="center") +``` + +MTCNN will: + +- Pad each image to match the size of the largest image in the batch. +- Group images by scale and process them through PNet, RNet, and ONet. +- Apply Non-Maximum Suppression (NMS) after each stage. + +The `results` will be a list where each element corresponds to the detection result of one image in the batch. Each result will contain bounding boxes, landmarks, and confidence scores, as in single-image detection. + +#### 5. Plotting Results for Each Image + +To visualize the detections for each image, you can loop through the results and plot the bounding boxes and landmarks on each image: + +```python +for i, image in enumerate(images): + plt.figure() + plt.imshow(plot(image, results[i])) + plt.title(f"Results for image {i+1}") + plt.show() +``` + +This will display each image with its corresponding detections, including bounding boxes around the faces and landmarks for each facial feature. + +--- + +### Using URIs Instead of Loading Images Manually + +MTCNN also supports passing image URIs directly to the `detect_faces` function, bypassing the need for manual image loading. This method is especially useful when you do not need to manipulate or plot the original image tensors. + +Here’s how you can detect faces by providing image paths or URIs directly to MTCNN: + +```python +image_uris = ["../resources/image1.jpg", "../resources/image2.jpg", "../resources/image3.jpg"] +results = mtcnn.detect_faces(image_uris) +``` + +In this case, MTCNN will automatically load the images from the URIs, standardize them (by padding smaller images), and perform face detection. However, since the original image tensors are not returned, plotting the results using the original images won’t be possible without loading them manually. + +### How Batch Processing Works Internally + +The following steps describe the internal workings of MTCNN during batch processing: + +1. **Padding and Justification**: After loading a list of images, MTCNN pads them internally to match the size of the largest image in the batch. The smaller images are aligned within the tensor according to the `batch_stack_justification` parameter (default is `"center"`). + +2. **Image Scaling (Image Pyramid)**: MTCNN applies a set of scales to each image in the batch, creating a pyramid of resized images. The images are processed in groups by scale, with the same set of scales applied to all images. + +3. **PNet Stage**: For each scale, PNet processes the batch of images, generating bounding box proposals and confidence scores. After this, **Non-Maximum Suppression (NMS)** is applied to each image independently to remove overlapping or low-confidence proposals. + +4. **RNet and ONet Stages**: The bounding boxes from PNet are processed by RNet and then ONet. For each batch of images, the networks refine the proposals and detect facial landmarks. NMS is applied after each stage to refine the results. + +5. **Postprocessing**: After the final stage, MTCNN adjusts the bounding box coordinates to account for the padding applied during tensor creation. This ensures that bounding boxes are accurate relative to the original image dimensions. + +--- + +### Full Batch Processing Code Example + +```python +from mtcnn import MTCNN +from mtcnn.utils.images import load_images_batch +from mtcnn.utils.plotting import plot +import matplotlib.pyplot as plt + +# Load a batch of images +image_paths = ["../resources/image1.jpg", "../resources/image2.jpg", "../resources/image3.jpg"] +images = load_images_batch(image_paths) + +# Initialize MTCNN detector for batch processing +mtcnn = MTCNN(device="CPU:0") + +# Detect faces and landmarks in the batch +results = mtcnn.detect_faces(images, batch_stack_justification="center") + +# Plot results for each image in the batch +for i, image in enumerate(images): + plt.figure() + plt.imshow(plot(image, results[i])) + plt.title(f"Results for image {i+1}") + plt.show() +``` + +### Conclusion + +Batch processing in MTCNN allows you to efficiently detect faces and facial landmarks across multiple images. By passing a list of images or URIs directly to the detector, MTCNN handles padding and justification internally, making the process seamless. This feature is ideal for applications that require large-scale face detection, such as video processing or image batch analysis. diff --git a/docs/usage_params.md b/docs/usage_params.md new file mode 100644 index 0000000..d43be47 --- /dev/null +++ b/docs/usage_params.md @@ -0,0 +1,178 @@ +The `mtcnn.detect_faces()` method in MTCNN provides a powerful and flexible way to detect faces and facial landmarks. While the method is easy to use out of the box, it also offers a variety of parameters that allow you to fine-tune the detection process based on your specific needs. This guide explains each parameter in detail, how they influence the results, and the impact of adjusting them. + +--- + +## Key Parameters + +### `image` (Required) + +This is the primary input to the method. You can provide: + +- A single image. +- A batch of images (as a list). +- URIs or paths to image files. + +The `mtcnn.detect_faces()` method is capable of working with individual images or batches of images, allowing flexible input types. + +### `fit_to_image` (Default: `True`) + +This option ensures that the detected bounding boxes fit within the boundaries of the image. When set to `True`, any bounding box that extends beyond the edges of the image will be adjusted to stay within the visible area. This is useful when faces near the edges of the image are detected. + +**When to adjust**: Set this to `False` if you want to allow detections that might go beyond the image (for example, when faces are partially outside the frame). + +### `limit_boundaries_landmarks` (Default: `False`) + +Similar to `fit_to_image`, but specific to facial landmarks. When enabled, landmarks (like eyes, nose, mouth corners) are adjusted so that they remain within the image boundaries. + +**When to adjust**: If you're working with images where facial features could be near or beyond the edge of the image, set this to `True` to ensure all landmarks stay visible. + +### `box_format` (Default: `"xywh"`) + +Determines the format of the bounding boxes in the output. You can choose between: + +- `"xywh"`: `[X1, Y1, width, height]`, where `X1, Y1` are the top-left corner coordinates and `width, height` represent the size. +- `"xyxy"`: `[X1, Y1, X2, Y2]`, where `X1, Y1` are the top-left corner coordinates, and `X2, Y2` are the bottom-right corner coordinates. + +**When to adjust**: Change to `"xyxy"` if you need to work with absolute coordinates for both corners of the box instead of width and height. + +### `output_type` (Default: `"json"`) + +This defines the format in which the detection results are returned. You can choose between: + +- `"json"`: The output is a list of dictionaries, each containing: + - `"box"`: The bounding box coordinates. + - `"keypoints"`: A dictionary with the detected landmarks. + - `"confidence"`: The confidence score of the detection. +- `"numpy"`: The output is a NumPy array with structured data. + +**When to adjust**: Use `"numpy"` if you are processing the results programmatically and prefer working with NumPy arrays. + +### `postprocess` (Default: `True`) + +Enabling this option ensures that several postprocessing steps are applied to the results: + +- Bounding boxes and landmarks are adjusted to fit within the image, based on the `fit_to_image` and `limit_boundaries_landmarks` settings. +- Padding from batch processing is removed, ensuring clean output for images of different sizes. + +**When to adjust**: Set this to `False` if you want raw outputs from each stage of the network without any adjustments. + +### `batch_stack_justification` (Default: `"center"`) + +When processing a batch of images, smaller images are padded to match the largest image in the batch. This parameter controls how these smaller images are aligned in the padded tensor: + +- **`"top"`**: Aligns smaller images to the top edge of the padded area, centered horizontally. +- **`"topleft"`**: Aligns smaller images to the top-left corner of the padded area. +- **`"topright"`**: Aligns smaller images to the top-right corner of the padded area. +- **`"bottom"`**: Aligns smaller images to the bottom edge of the padded area, centered horizontally. +- **`"bottomleft"`**: Aligns smaller images to the bottom-left corner of the padded area. +- **`"bottomright"`**: Aligns smaller images to the bottom-right corner of the padded area. +- **`"left"`**: Aligns smaller images to the left edge of the padded area, centered vertically. +- **`"right"`**: Aligns smaller images to the right edge of the padded area, centered vertically. +- **`"center"`**: Centers smaller images both vertically and horizontally within the padded area. + +**When to adjust**: Use different justifications if you want to control how images are aligned during batch processing. + +--- + +## Fine-Tuning Parameters for Each Detection Stage + +MTCNN detects faces through three stages: **PNet**, **RNet**, and **ONet**. Each stage has its own set of parameters that you can adjust to control detection sensitivity, scaling, and thresholds. + +### StagePNet (Proposal Network) + +**PNet** is the first network in the MTCNN pipeline. It quickly scans the image at multiple scales to propose candidate face regions. + +- **`min_face_size`** *(Default: 20)*: This controls the minimum size of the face (in pixels) that the detector will consider. Faces smaller than this will be ignored. + - **When to adjust**: Lower this value if you're working with images where faces are very small, or increase it if you want to ignore smaller faces for performance reasons. +- **`min_size`** *(Default: 12)*: Defines the minimum size for the smallest scale in the image pyramid. Smaller values will lead to a finer scan at smaller face sizes. + - **When to adjust**: Lowering this can detect smaller faces but may slow down detection. +- **`scale_factor`** *(Default: 0.709)*: This controls the scaling factor for the image pyramid, determining how much the image is resized at each level. + - **When to adjust**: A smaller value creates more image scales, leading to more detailed detections but slower performance. +- **`threshold_pnet`** *(Default: 0.6)*: The confidence threshold for accepting face proposals from PNet. Lower thresholds result in more proposals, while higher thresholds discard more uncertain detections. + - **When to adjust**: Lower it to catch more potential face candidates (at the cost of more false positives). +- **`nms_pnet1`** *(Default: 0.5)* and **`nms_pnet2`** *(Default: 0.7)*: These are the IoU (Intersection over Union) thresholds for Non-Maximum Suppression (NMS), a technique used to remove overlapping bounding boxes. + - **nms_pnet1**: Applied per scale. + - **nms_pnet2**: Applied across all scales. + - **When to adjust**: Increase if too many boxes overlap, decrease to retain more overlapping proposals. + +### StageRNet (Refinement Network) + +**RNet** refines the face proposals from PNet, removing false positives and further improving the bounding box quality. + +- **`threshold_rnet`** *(Default: 0.7)*: The confidence threshold for accepting face proposals in RNet. Higher values make the network more conservative. + - **When to adjust**: Lower if RNet is rejecting too many proposals, raise if it’s accepting too many false positives. + +- **`nms_rnet`** *(Default: 0.7)*: The IoU threshold for NMS after RNet processing. + - **When to adjust**: Adjust as needed to control overlap in bounding boxes. + +### StageONet (Output Network) + +**ONet** is the final stage of the MTCNN pipeline. It provides the most refined bounding boxes and predicts facial landmarks (eyes, nose, mouth corners). + +- **`threshold_onet`** *(Default: 0.8)*: The confidence threshold for face proposals in ONet. Like the earlier thresholds, higher values make the detector more conservative. + - **When to adjust**: If landmarks are too sparse, lower this value. If you're getting too many incorrect faces, raise it. + +- **`nms_onet`** *(Default: 0.7)*: The IoU threshold for NMS after ONet. + - **When to adjust**: Fine-tune to remove overlapping boxes while keeping enough valid face detections. + +--- + +## Practical Examples + +### Adjusting Detection Sensitivity + +If you're looking to detect smaller faces or fine-tune the detection sensitivity, adjusting `min_face_size` and the stage thresholds can help. + +```python +results = mtcnn.detect_faces( + image, + min_face_size=15, # Detect smaller faces + threshold_pnet=0.5, # More proposals from PNet + threshold_rnet=0.6, # Loosen RNet filtering + threshold_onet=0.7 # More final faces accepted by ONet +) +``` + +### Batch Processing with Custom Padding + +When processing a batch of images, you can control how smaller images are padded relative to larger ones. + +```python +results = mtcnn.detect_faces( + images_list, + batch_stack_justification="topleft" # Align smaller images to the top-left +) +``` + +### Disabling Postprocessing + +If you need the raw output directly from the network stages without any adjustments, you can disable postprocessing. + +```python +results = mtcnn.detect_faces( + image, + postprocess=False # Get raw detection results +) +``` + +### Changing Bounding Box Format + +To return bounding boxes in `[X1, Y1, X2, Y2]` format instead of the default `[X1, Y1, width, height]`: + +```python +results = mtcnn.detect_faces( + image, + box_format="xyxy" +) +``` + +--- + +## Summary + +- **Single Image**: Returns a list of detected faces, with each face represented by a dictionary containing the bounding box, landmarks, and confidence score. +- **Batch of Images**: Returns a list of lists, where each sublist contains the detections for one image. +- The default parameters provide good results in most cases, but you may need to adjust thresholds, face size settings, and scaling factors depending on the specifics of your task. Fine-tuning these parameters will allow you to balance detection accuracy, speed, and sensitivity. +- Increasing thresholds generally makes the detector more conservative (fewer false positives but potentially missing some faces), while decreasing thresholds makes it more aggressive (detecting more faces but possibly increasing false positives). +- Adjusting the `scale_factor` affects the number of scales in the image pyramid and can impact detection performance and speed. +- When processing large batches or high-resolution images, consider running the detector on a GPU for better performance. diff --git a/example.py b/example.py deleted file mode 100644 index 6cf1478..0000000 --- a/example.py +++ /dev/null @@ -1,30 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- - -import cv2 -from mtcnn.mtcnn import MTCNN - -detector = MTCNN() - -image = cv2.imread("ivan.jpg") -result = detector.detect_faces(image) - -# Result is an array with all the bounding boxes detected. We know that for 'ivan.jpg' there is only one. -bounding_box = result[0]['box'] -keypoints = result[0]['keypoints'] - -cv2.rectangle(image, - (bounding_box[0], bounding_box[1]), - (bounding_box[0]+bounding_box[2], bounding_box[1] + bounding_box[3]), - (0,155,255), - 2) - -cv2.circle(image,(keypoints['left_eye']), 2, (0,155,255), 2) -cv2.circle(image,(keypoints['right_eye']), 2, (0,155,255), 2) -cv2.circle(image,(keypoints['nose']), 2, (0,155,255), 2) -cv2.circle(image,(keypoints['mouth_left']), 2, (0,155,255), 2) -cv2.circle(image,(keypoints['mouth_right']), 2, (0,155,255), 2) - -cv2.imwrite("ivan_drawn.jpg", image) - -print(result) \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..fed6dad --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,44 @@ +site_name: MTCNN Documentation +site_description: "Detailed Documentation for MTCNN Package" +site_url: https://mtcnn.readthedocs.io/en/latest/ +repo_url: https://github.com/ipazc/mtcnn + +theme: + name: material + +nav: + - Home: index.md + - Introduction: introduction.md + - Networks: stages.md + - Usage: + - Basic Usage: usage.md + - Advanced Usage: usage_advanced.md + - Detection Parameters: usage_params.md + - Ablation Study: + - Ablation Overview: ablation.md + - PNet ablation: notebooks-docs/pnet_ablation.ipynb + - RNet ablation: notebooks-docs/rnet_ablation.ipynb + - ONet ablation: notebooks-docs/onet_ablation.ipynb + - Training Guide: training.md + - References: references.md + + +plugins: + - search + - mkdocs-jupyter + +markdown_extensions: + - toc: + permalink: True + - pymdownx.highlight: + anchor_linenums: true + line_spans: __span + pygments_lang_class: true + - pymdownx.inlinehilite + - pymdownx.snippets + - pymdownx.superfences + +extra_css: + - css/custom.css + +docs_dir: docs diff --git a/mtcnn/__init__.py b/mtcnn/__init__.py index 1efe223..1c0bffa 100644 --- a/mtcnn/__init__.py +++ b/mtcnn/__init__.py @@ -1,27 +1,25 @@ -#!/usr/bin/python3 -# -*- coding: utf-8 -*- - -#MIT License +# MIT License # -#Copyright (c) 2018 Iván de Paz Centeno +# Copyright (c) 2019-2024 Iván de Paz Centeno # -#Permission is hereby granted, free of charge, to any person obtaining a copy -#of this software and associated documentation files (the "Software"), to deal -#in the Software without restriction, including without limitation the rights -#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -#copies of the Software, and to permit persons to whom the Software is -#furnished to do so, subject to the following conditions: +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: # -#The above copyright notice and this permission notice shall be included in all -#copies or substantial portions of the Software. +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. # -#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -#SOFTWARE. +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from mtcnn.mtcnn import MTCNN -__author__ = "Iván de Paz Centeno" -__version__= "0.0.8" +__all__ = ["MTCNN"] diff --git a/mtcnn/assets/weights/onet.lz4 b/mtcnn/assets/weights/onet.lz4 new file mode 100644 index 0000000..62d25c1 Binary files /dev/null and b/mtcnn/assets/weights/onet.lz4 differ diff --git a/mtcnn/assets/weights/pnet.lz4 b/mtcnn/assets/weights/pnet.lz4 new file mode 100644 index 0000000..a526512 Binary files /dev/null and b/mtcnn/assets/weights/pnet.lz4 differ diff --git a/mtcnn/assets/weights/rnet.lz4 b/mtcnn/assets/weights/rnet.lz4 new file mode 100644 index 0000000..7dc7a97 Binary files /dev/null and b/mtcnn/assets/weights/rnet.lz4 differ diff --git a/mtcnn/data/mtcnn_weights.npy b/mtcnn/data/mtcnn_weights.npy deleted file mode 100644 index 340f605..0000000 Binary files a/mtcnn/data/mtcnn_weights.npy and /dev/null differ diff --git a/mtcnn/exceptions/__init__.py b/mtcnn/exceptions/__init__.py deleted file mode 100644 index fa0cbd9..0000000 --- a/mtcnn/exceptions/__init__.py +++ /dev/null @@ -1,29 +0,0 @@ -#!/usr/bin/python3 -# -*- coding: utf-8 -*- - -#MIT License -# -#Copyright (c) 2018 Iván de Paz Centeno -# -#Permission is hereby granted, free of charge, to any person obtaining a copy -#of this software and associated documentation files (the "Software"), to deal -#in the Software without restriction, including without limitation the rights -#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -#copies of the Software, and to permit persons to whom the Software is -#furnished to do so, subject to the following conditions: -# -#The above copyright notice and this permission notice shall be included in all -#copies or substantial portions of the Software. -# -#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -#SOFTWARE. - -__author__ = "Iván de Paz Centeno" - -class InvalidImage(Exception): - pass \ No newline at end of file diff --git a/mtcnn/layer_factory.py b/mtcnn/layer_factory.py deleted file mode 100644 index 0f147da..0000000 --- a/mtcnn/layer_factory.py +++ /dev/null @@ -1,217 +0,0 @@ -#!/usr/bin/python3 -# -*- coding: utf-8 -*- - -#MIT License -# -#Copyright (c) 2018 Iván de Paz Centeno -# -#Permission is hereby granted, free of charge, to any person obtaining a copy -#of this software and associated documentation files (the "Software"), to deal -#in the Software without restriction, including without limitation the rights -#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -#copies of the Software, and to permit persons to whom the Software is -#furnished to do so, subject to the following conditions: -# -#The above copyright notice and this permission notice shall be included in all -#copies or substantial portions of the Software. -# -#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -#SOFTWARE. - -import tensorflow as tf - -__author__ = "Iván de Paz Centeno" - - -class LayerFactory(object): - """ - Allows to create stack layers for a given network. - """ - - AVAILABLE_PADDINGS = ('SAME', 'VALID') - - def __init__(self, network): - self.__network = network - - @staticmethod - def __validate_padding(padding): - if padding not in LayerFactory.AVAILABLE_PADDINGS: - raise Exception("Padding {} not valid".format(padding)) - - @staticmethod - def __validate_grouping(channels_input: int, channels_output: int, group: int): - if channels_input % group != 0: - raise Exception("The number of channels in the input does not match the group") - - if channels_output % group != 0: - raise Exception("The number of channels in the output does not match the group") - - @staticmethod - def vectorize_input(input_layer): - input_shape = input_layer.get_shape() - - if input_shape.ndims == 4: - # Spatial input, must be vectorized. - dim = 1 - for x in input_shape[1:].as_list(): - dim *= int(x) - - #dim = operator.mul(*(input_shape[1:].as_list())) - vectorized_input = tf.reshape(input_layer, [-1, dim]) - else: - vectorized_input, dim = (input_layer, input_shape[-1].value) - - return vectorized_input, dim - - def __make_var(self, name: str, shape: list): - """ - Creates a tensorflow variable with the given name and shape. - :param name: name to set for the variable. - :param shape: list defining the shape of the variable. - :return: created TF variable. - """ - return tf.get_variable(name, shape, trainable=self.__network.is_trainable()) - - def new_feed(self, name: str, layer_shape: tuple): - """ - Creates a feed layer. This is usually the first layer in the network. - :param name: name of the layer - :return: - """ - - feed_data = tf.placeholder(tf.float32, layer_shape, 'input') - self.__network.add_layer(name, layer_output=feed_data) - - def new_conv(self, name: str, kernel_size: tuple, channels_output: int, - stride_size: tuple, padding: str='SAME', - group: int=1, biased: bool=True, relu: bool=True, input_layer_name: str=None): - """ - Creates a convolution layer for the network. - :param name: name for the layer - :param kernel_size: tuple containing the size of the kernel (Width, Height) - :param channels_output: ¿? Perhaps number of channels in the output? it is used as the bias size. - :param stride_size: tuple containing the size of the stride (Width, Height) - :param padding: Type of padding. Available values are: ('SAME', 'VALID') - :param group: groups for the kernel operation. More info required. - :param biased: boolean flag to set if biased or not. - :param relu: boolean flag to set if ReLu should be applied at the end of the layer or not. - :param input_layer_name: name of the input layer for this layer. If None, it will take the last added layer of - the network. - """ - - # Verify that the padding is acceptable - self.__validate_padding(padding) - - input_layer = self.__network.get_layer(input_layer_name) - - # Get the number of channels in the input - channels_input = int(input_layer.get_shape()[-1]) - - # Verify that the grouping parameter is valid - self.__validate_grouping(channels_input, channels_output, group) - - # Convolution for a given input and kernel - convolve = lambda input_val, kernel: tf.nn.conv2d(input_val, kernel, [1, stride_size[1], stride_size[0], 1], - padding=padding) - - with tf.variable_scope(name) as scope: - kernel = self.__make_var('weights', shape=[kernel_size[1], kernel_size[0], channels_input // group, channels_output]) - - output = convolve(input_layer, kernel) - - # Add the biases, if required - if biased: - biases = self.__make_var('biases', [channels_output]) - output = tf.nn.bias_add(output, biases) - - # Apply ReLU non-linearity, if required - if relu: - output = tf.nn.relu(output, name=scope.name) - - - self.__network.add_layer(name, layer_output=output) - - def new_prelu(self, name: str, input_layer_name: str=None): - """ - Creates a new prelu layer with the given name and input. - :param name: name for this layer. - :param input_layer_name: name of the layer that serves as input for this one. - """ - input_layer = self.__network.get_layer(input_layer_name) - - with tf.variable_scope(name): - channels_input = int(input_layer.get_shape()[-1]) - alpha = self.__make_var('alpha', shape=[channels_input]) - output = tf.nn.relu(input_layer) + tf.multiply(alpha, -tf.nn.relu(-input_layer)) - - self.__network.add_layer(name, layer_output=output) - - def new_max_pool(self, name:str, kernel_size: tuple, stride_size: tuple, padding='SAME', - input_layer_name: str=None): - """ - Creates a new max pooling layer. - :param name: name for the layer. - :param kernel_size: tuple containing the size of the kernel (Width, Height) - :param stride_size: tuple containing the size of the stride (Width, Height) - :param padding: Type of padding. Available values are: ('SAME', 'VALID') - :param input_layer_name: name of the input layer for this layer. If None, it will take the last added layer of - the network. - """ - - self.__validate_padding(padding) - - input_layer = self.__network.get_layer(input_layer_name) - - output = tf.nn.max_pool(input_layer, - ksize=[1, kernel_size[1], kernel_size[0], 1], - strides=[1, stride_size[1], stride_size[0], 1], - padding=padding, - name=name) - - self.__network.add_layer(name, layer_output=output) - - def new_fully_connected(self, name: str, output_count: int, relu=True, input_layer_name: str=None): - """ - Creates a new fully connected layer. - - :param name: name for the layer. - :param output_count: number of outputs of the fully connected layer. - :param relu: boolean flag to set if ReLu should be applied at the end of this layer. - :param input_layer_name: name of the input layer for this layer. If None, it will take the last added layer of - the network. - """ - - with tf.variable_scope(name): - input_layer = self.__network.get_layer(input_layer_name) - vectorized_input, dimension = self.vectorize_input(input_layer) - - weights = self.__make_var('weights', shape=[dimension, output_count]) - biases = self.__make_var('biases', shape=[output_count]) - operation = tf.nn.relu_layer if relu else tf.nn.xw_plus_b - - fc = operation(vectorized_input, weights, biases, name=name) - - self.__network.add_layer(name, layer_output=fc) - - def new_softmax(self, name, axis, input_layer_name: str=None): - """ - Creates a new softmax layer - :param name: name to set for the layer - :param axis: - :param input_layer_name: name of the input layer for this layer. If None, it will take the last added layer of - the network. - """ - input_layer = self.__network.get_layer(input_layer_name) - - max_axis = tf.reduce_max(input_layer, axis, keep_dims=True) - target_exp = tf.exp(input_layer-max_axis) - normalize = tf.reduce_sum(target_exp, axis, keep_dims=True) - softmax = tf.div(target_exp, normalize, name) - - self.__network.add_layer(name, layer_output=softmax) - diff --git a/mtcnn/metadata.py b/mtcnn/metadata.py new file mode 100644 index 0000000..4f3196e --- /dev/null +++ b/mtcnn/metadata.py @@ -0,0 +1,23 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +__version__ = "1.0.0" diff --git a/mtcnn/mtcnn.py b/mtcnn/mtcnn.py index 3ddb75d..3b0a6a6 100644 --- a/mtcnn/mtcnn.py +++ b/mtcnn/mtcnn.py @@ -1,603 +1,188 @@ -#!/usr/bin/python3 -# -*- coding: utf-8 -*- - -#MIT License -# -#Copyright (c) 2018 Iván de Paz Centeno +# MIT License # -#Permission is hereby granted, free of charge, to any person obtaining a copy -#of this software and associated documentation files (the "Software"), to deal -#in the Software without restriction, including without limitation the rights -#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -#copies of the Software, and to permit persons to whom the Software is -#furnished to do so, subject to the following conditions: +# Copyright (c) 2019-2024 Iván de Paz Centeno # -#The above copyright notice and this permission notice shall be included in all -#copies or substantial portions of the Software. +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: # -#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -#SOFTWARE. - -# IMPORTANT: -# -# This code is derivated from the MTCNN implementation of David Sandberg for Facenet -# (https://github.com/davidsandberg/facenet/) -# It has been rebuilt from scratch, taking the David Sandberg's implementation as a reference. -# The code improves the readibility, fixes several mistakes in the definition of the network (layer names) -# and provides the keypoints of faces as outputs along with the bounding boxes. +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. # +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. -import cv2 -import numpy as np -import pkg_resources import tensorflow as tf -from mtcnn.layer_factory import LayerFactory -from mtcnn.network import Network -from mtcnn.exceptions import InvalidImage - -__author__ = "Iván de Paz Centeno" - - -class PNet(Network): - """ - Network to propose areas with faces. - """ - def _config(self): - layer_factory = LayerFactory(self) - - layer_factory.new_feed(name='data', layer_shape=(None, None, None, 3)) - layer_factory.new_conv(name='conv1', kernel_size=(3, 3), channels_output=10, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu1') - layer_factory.new_max_pool(name='pool1', kernel_size=(2, 2), stride_size=(2, 2)) - layer_factory.new_conv(name='conv2', kernel_size=(3, 3), channels_output=16, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu2') - layer_factory.new_conv(name='conv3', kernel_size=(3, 3), channels_output=32, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu3') - layer_factory.new_conv(name='conv4-1', kernel_size=(1, 1), channels_output=2, stride_size=(1, 1), relu=False) - layer_factory.new_softmax(name='prob1', axis=3) - - layer_factory.new_conv(name='conv4-2', kernel_size=(1, 1), channels_output=4, stride_size=(1, 1), - input_layer_name='prelu3', relu=False) - - def _feed(self, image): - return self._session.run(['pnet/conv4-2/BiasAdd:0', 'pnet/prob1:0'], feed_dict={'pnet/input:0': image}) - - -class RNet(Network): - """ - Network to refine the areas proposed by PNet - """ - - def _config(self): +import numpy as np - layer_factory = LayerFactory(self) +from mtcnn.stages import StagePNet, StageRNet, StageONet - layer_factory.new_feed(name='data', layer_shape=(None, 24, 24, 3)) - layer_factory.new_conv(name='conv1', kernel_size=(3, 3), channels_output=28, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu1') - layer_factory.new_max_pool(name='pool1', kernel_size=(3, 3), stride_size=(2, 2)) - layer_factory.new_conv(name='conv2', kernel_size=(3, 3), channels_output=48, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu2') - layer_factory.new_max_pool(name='pool2', kernel_size=(3, 3), stride_size=(2, 2), padding='VALID') - layer_factory.new_conv(name='conv3', kernel_size=(2, 2), channels_output=64, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu3') - layer_factory.new_fully_connected(name='fc1', output_count=128, relu=False) # shouldn't the name be "fc1"? - layer_factory.new_prelu(name='prelu4') - layer_factory.new_fully_connected(name='fc2-1', output_count=2, relu=False) # shouldn't the name be "fc2-1"? - layer_factory.new_softmax(name='prob1', axis=1) +from mtcnn.utils.images import load_images_batch, standarize_batch +from mtcnn.utils.bboxes import fix_bboxes_offsets, limit_bboxes, to_json - layer_factory.new_fully_connected(name='fc2-2', output_count=4, relu=False, input_layer_name='prelu4') - def _feed(self, image): - return self._session.run(['rnet/fc2-2/fc2-2:0', 'rnet/prob1:0'], feed_dict={'rnet/input:0': image}) +COMMON_STAGES = { + "face_detection_only": [StagePNet, StageRNet], + "face_and_landmarks_detection": [StagePNet, StageRNet, StageONet], +} -class ONet(Network): +class MTCNN: """ - Network to retrieve the keypoints + MTCNN class for detecting faces and landmarks through configurable stages. + This structure allows skipping certain stages to optimize performance based on the user's needs. + + Args: + stages (str or list, optional): Defines the pipeline stages. It can be a string to choose from predefined + configurations or a list of stage classes or instances. + Options: "face_detection_only", "face_and_landmarks_detection". + Default is "face_and_landmarks_detection". + device (str, optional): The device where the model will be run. Can be "CPU:0", "GPU:0", "GPU:1", ... + Default is "CPU:0". + """ - def _config(self): - layer_factory = LayerFactory(self) - - layer_factory.new_feed(name='data', layer_shape=(None, 48, 48, 3)) - layer_factory.new_conv(name='conv1', kernel_size=(3, 3), channels_output=32, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu1') - layer_factory.new_max_pool(name='pool1', kernel_size=(3, 3), stride_size=(2, 2)) - layer_factory.new_conv(name='conv2', kernel_size=(3, 3), channels_output=64, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu2') - layer_factory.new_max_pool(name='pool2', kernel_size=(3, 3), stride_size=(2, 2), padding='VALID') - layer_factory.new_conv(name='conv3', kernel_size=(3, 3), channels_output=64, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu3') - layer_factory.new_max_pool(name='pool3', kernel_size=(2, 2), stride_size=(2, 2)) - layer_factory.new_conv(name='conv4', kernel_size=(2, 2), channels_output=128, stride_size=(1, 1), - padding='VALID', relu=False) - layer_factory.new_prelu(name='prelu4') - layer_factory.new_fully_connected(name='fc1', output_count=256, relu=False) - layer_factory.new_prelu(name='prelu5') - layer_factory.new_fully_connected(name='fc2-1', output_count=2, relu=False) - layer_factory.new_softmax(name='prob1', axis=1) - - layer_factory.new_fully_connected(name='fc2-2', output_count=4, relu=False, input_layer_name='prelu5') - - layer_factory.new_fully_connected(name='fc2-3', output_count=10, relu=False, input_layer_name='prelu5') - - def _feed(self, image): - return self._session.run(['onet/fc2-2/fc2-2:0', 'onet/fc2-3/fc2-3:0', 'onet/prob1:0'], - feed_dict={'onet/input:0': image}) - - -class StageStatus(object): - """ - Keeps status between MTCNN stages - """ - def __init__(self, pad_result: tuple=None, width=0, height=0): - self.width = width - self.height = height - self.dy = self.edy = self.dx = self.edx = self.y = self.ey = self.x = self.ex = self.tmpw = self.tmph = [] - if pad_result is not None: - self.update(pad_result) + def __init__(self, stages="face_and_landmarks_detection", device="CPU:0"): + if isinstance(stages, str): + if stages not in COMMON_STAGES: + raise ValueError(f"Invalid stages option: {stages}. Must be one of {list(COMMON_STAGES.keys())}.") + stages = COMMON_STAGES[stages] - def update(self, pad_result: tuple): - s = self - s.dy, s.edy, s.dx, s.edx, s.y, s.ey, s.x, s.ex, s.tmpw, s.tmph = pad_result + # Instantiate stages if necessary (can pass already instantiated stages too) + self._stages = [stage() if isinstance(stage, type) else stage for stage in stages] + self._device = device + @property + def device(self): + """Returns the device where the algorithm is executed""" + return self._device -class MTCNN(object): - """ - Allows to perform MTCNN Detection -> - a) Detection of faces (with the confidence probability) - b) Detection of keypoints (left eye, right eye, nose, mouth_left, mouth_right) - """ + @property + def stages(self): + """Returns the list of pipeline stages.""" + return self._stages - def __init__(self, weights_file: str=None, min_face_size: int=20, steps_threshold: list=None, - scale_factor: float=0.709): + def get_stage(self, stage_id=None, stage_name=None): """ - Initializes the MTCNN. - :param weights_file: file uri with the weights of the P, R and O networks from MTCNN. By default it will load - the ones bundled with the package. - :param min_face_size: minimum size of the face to detect - :param steps_threshold: step's thresholds values - :param scale_factor: scale factor - """ - if steps_threshold is None: - steps_threshold = [0.6, 0.7, 0.7] - - if weights_file is None: - weights_file = pkg_resources.resource_stream('mtcnn', 'data/mtcnn_weights.npy') - - self.__min_face_size = min_face_size - self.__steps_threshold = steps_threshold - self.__scale_factor = scale_factor - - config = tf.ConfigProto(log_device_placement=False) - config.gpu_options.allow_growth = True - - self.__graph = tf.Graph() - - with self.__graph.as_default(): - self.__session = tf.Session(config=config, graph=self.__graph) - - weights = np.load(weights_file).item() - self.__pnet = PNet(self.__session, False) - self.__pnet.set_weights(weights['PNet']) - - self.__rnet = RNet(self.__session, False) - self.__rnet.set_weights(weights['RNet']) - - self.__onet = ONet(self.__session, False) - self.__onet.set_weights(weights['ONet']) + Retrieves a stage by its ID or name. - def __compute_scale_pyramid(self, m, min_layer): - scales = [] - factor_count = 0 + Args: + stage_id (int, optional): The ID of the stage. + stage_name (str, optional): The name of the stage. - while min_layer >= 12: - scales += [m * np.power(self.__scale_factor, factor_count)] - min_layer = min_layer * self.__scale_factor - factor_count += 1 - - return scales - - @staticmethod - def __scale_image(image, scale: float): + Returns: + The matching stage if found, otherwise None. """ - Scales the image to a given scale. - :param image: - :param scale: - :return: - """ - height, width, _ = image.shape - - width_scaled = int(np.ceil(width * scale)) - height_scaled = int(np.ceil(height * scale)) - - im_data = cv2.resize(image, (width_scaled, height_scaled), interpolation=cv2.INTER_AREA) - - # Normalize the image's pixels - im_data_normalized = (im_data - 127.5) * 0.0078125 - - return im_data_normalized - - @staticmethod - def __generate_bounding_box(imap, reg, scale, t): - - # use heatmap to generate bounding boxes - stride = 2 - cellsize = 12 - - imap = np.transpose(imap) - dx1 = np.transpose(reg[:, :, 0]) - dy1 = np.transpose(reg[:, :, 1]) - dx2 = np.transpose(reg[:, :, 2]) - dy2 = np.transpose(reg[:, :, 3]) - - y, x = np.where(imap >= t) - - if y.shape[0] == 1: - dx1 = np.flipud(dx1) - dy1 = np.flipud(dy1) - dx2 = np.flipud(dx2) - dy2 = np.flipud(dy2) - - score = imap[(y, x)] - reg = np.transpose(np.vstack([dx1[(y, x)], dy1[(y, x)], dx2[(y, x)], dy2[(y, x)]])) - - if reg.size == 0: - reg = np.empty(shape=(0, 3)) - - bb = np.transpose(np.vstack([y, x])) - - q1 = np.fix((stride * bb + 1)/scale) - q2 = np.fix((stride * bb + cellsize)/scale) - boundingbox = np.hstack([q1, q2, np.expand_dims(score, 1), reg]) - - return boundingbox, reg - - @staticmethod - def __nms(boxes, threshold, method): - """ - Non Maximum Suppression. - - :param boxes: np array with bounding boxes. - :param threshold: - :param method: NMS method to apply. Available values ('Min', 'Union') - :return: - """ - if boxes.size == 0: - return np.empty((0, 3)) - - x1 = boxes[:, 0] - y1 = boxes[:, 1] - x2 = boxes[:, 2] - y2 = boxes[:, 3] - s = boxes[:, 4] - - area = (x2 - x1 + 1) * (y2 - y1 + 1) - sorted_s = np.argsort(s) - - pick = np.zeros_like(s, dtype=np.int16) - counter = 0 - while sorted_s.size > 0: - i = sorted_s[-1] - pick[counter] = i - counter += 1 - idx = sorted_s[0:-1] - - xx1 = np.maximum(x1[i], x1[idx]) - yy1 = np.maximum(y1[i], y1[idx]) - xx2 = np.minimum(x2[i], x2[idx]) - yy2 = np.minimum(y2[i], y2[idx]) - - w = np.maximum(0.0, xx2 - xx1 + 1) - h = np.maximum(0.0, yy2 - yy1 + 1) - - inter = w * h - - if method is 'Min': - o = inter / np.minimum(area[i], area[idx]) - else: - o = inter / (area[i] + area[idx] - inter) - - sorted_s = sorted_s[np.where(o <= threshold)] - - pick = pick[0:counter] - - return pick - - @staticmethod - def __pad(total_boxes, w, h): - # compute the padding coordinates (pad the bounding boxes to square) - tmpw = (total_boxes[:, 2] - total_boxes[:, 0] + 1).astype(np.int32) - tmph = (total_boxes[:, 3] - total_boxes[:, 1] + 1).astype(np.int32) - numbox = total_boxes.shape[0] - - dx = np.ones(numbox, dtype=np.int32) - dy = np.ones(numbox, dtype=np.int32) - edx = tmpw.copy().astype(np.int32) - edy = tmph.copy().astype(np.int32) - - x = total_boxes[:, 0].copy().astype(np.int32) - y = total_boxes[:, 1].copy().astype(np.int32) - ex = total_boxes[:, 2].copy().astype(np.int32) - ey = total_boxes[:, 3].copy().astype(np.int32) - - tmp = np.where(ex > w) - edx.flat[tmp] = np.expand_dims(-ex[tmp] + w + tmpw[tmp], 1) - ex[tmp] = w - - tmp = np.where(ey > h) - edy.flat[tmp] = np.expand_dims(-ey[tmp] + h + tmph[tmp], 1) - ey[tmp] = h - - tmp = np.where(x < 1) - dx.flat[tmp] = np.expand_dims(2 - x[tmp], 1) - x[tmp] = 1 - - tmp = np.where(y < 1) - dy.flat[tmp] = np.expand_dims(2 - y[tmp], 1) - y[tmp] = 1 - - return dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph - - @staticmethod - def __rerec(bbox): - # convert bbox to square - h = bbox[:, 3] - bbox[:, 1] - w = bbox[:, 2] - bbox[:, 0] - l = np.maximum(w, h) - bbox[:, 0] = bbox[:, 0] + w * 0.5 - l * 0.5 - bbox[:, 1] = bbox[:, 1] + h * 0.5 - l * 0.5 - bbox[:, 2:4] = bbox[:, 0:2] + np.transpose(np.tile(l, (2, 1))) - return bbox - - @staticmethod - def __bbreg(boundingbox, reg): - # calibrate bounding boxes - if reg.shape[1] == 1: - reg = np.reshape(reg, (reg.shape[2], reg.shape[3])) - - w = boundingbox[:, 2] - boundingbox[:, 0] + 1 - h = boundingbox[:, 3] - boundingbox[:, 1] + 1 - b1 = boundingbox[:, 0] + reg[:, 0] * w - b2 = boundingbox[:, 1] + reg[:, 1] * h - b3 = boundingbox[:, 2] + reg[:, 2] * w - b4 = boundingbox[:, 3] + reg[:, 3] * h - boundingbox[:, 0:4] = np.transpose(np.vstack([b1, b2, b3, b4])) - return boundingbox - - def detect_faces(self, img) -> list: - """ - Detects bounding boxes from the specified image. - :param img: image to process - :return: list containing all the bounding boxes detected with their keypoints. - """ - if img is None or not hasattr(img, "shape"): - raise InvalidImage("Image not valid.") - - height, width, _ = img.shape - stage_status = StageStatus(width=width, height=height) + for stage in self._stages: + if stage.id == stage_id or stage.name == stage_name: + return stage - m = 12 / self.__min_face_size - min_layer = np.amin([height, width]) * m + return None - scales = self.__compute_scale_pyramid(m, min_layer) - - stages = [self.__stage1, self.__stage2, self.__stage3] - result = [scales, stage_status] - - # We pipe here each of the stages - for stage in stages: - result = stage(img, result[0], result[1]) - - [total_boxes, points] = result - - bounding_boxes = [] - - for bounding_box, keypoints in zip(total_boxes, points.T): - - bounding_boxes.append({ - 'box': [int(bounding_box[0]), int(bounding_box[1]), - int(bounding_box[2]-bounding_box[0]), int(bounding_box[3]-bounding_box[1])], - 'confidence': bounding_box[-1], - 'keypoints': { - 'left_eye': (int(keypoints[0]), int(keypoints[5])), - 'right_eye': (int(keypoints[1]), int(keypoints[6])), - 'nose': (int(keypoints[2]), int(keypoints[7])), - 'mouth_left': (int(keypoints[3]), int(keypoints[8])), - 'mouth_right': (int(keypoints[4]), int(keypoints[9])), - } - } - ) - - return bounding_boxes - - def __stage1(self, image, scales: list, stage_status: StageStatus): + def predict(self, image, fit_to_image=True, limit_boundaries_landmarks=False, box_format="xywh", output_type="json", postprocess=True, + **kwargs): """ - First stage of the MTCNN. - :param image: - :param scales: - :param stage_status: - :return: + Alias for detect_faces(). """ - total_boxes = np.empty((0, 9)) - status = stage_status - - for scale in scales: - scaled_image = self.__scale_image(image, scale) - - img_x = np.expand_dims(scaled_image, 0) - img_y = np.transpose(img_x, (0, 2, 1, 3)) - - out = self.__pnet.feed(img_y) - - out0 = np.transpose(out[0], (0, 2, 1, 3)) - out1 = np.transpose(out[1], (0, 2, 1, 3)) - - boxes, _ = self.__generate_bounding_box(out1[0, :, :, 1].copy(), - out0[0, :, :, :].copy(), scale, self.__steps_threshold[0]) + return self.detect_faces(image, fit_to_image=fit_to_image, limit_boundaries_landmarks=limit_boundaries_landmarks, + box_format=box_format, output_type=output_type, postprocess=postprocess, **kwargs) - # inter-scale nms - pick = self.__nms(boxes.copy(), 0.5, 'Union') - if boxes.size > 0 and pick.size > 0: - boxes = boxes[pick, :] - total_boxes = np.append(total_boxes, boxes, axis=0) - - numboxes = total_boxes.shape[0] - - if numboxes > 0: - pick = self.__nms(total_boxes.copy(), 0.7, 'Union') - total_boxes = total_boxes[pick, :] - - regw = total_boxes[:, 2] - total_boxes[:, 0] - regh = total_boxes[:, 3] - total_boxes[:, 1] - - qq1 = total_boxes[:, 0] + total_boxes[:, 5] * regw - qq2 = total_boxes[:, 1] + total_boxes[:, 6] * regh - qq3 = total_boxes[:, 2] + total_boxes[:, 7] * regw - qq4 = total_boxes[:, 3] + total_boxes[:, 8] * regh - - total_boxes = np.transpose(np.vstack([qq1, qq2, qq3, qq4, total_boxes[:, 4]])) - total_boxes = self.__rerec(total_boxes.copy()) - - total_boxes[:, 0:4] = np.fix(total_boxes[:, 0:4]).astype(np.int32) - status = StageStatus(self.__pad(total_boxes.copy(), stage_status.width, stage_status.height), - width=stage_status.width, height=stage_status.height) - - return total_boxes, status - - def __stage2(self, img, total_boxes, stage_status:StageStatus): + def detect_faces(self, image, fit_to_image=True, limit_boundaries_landmarks=False, box_format="xywh", output_type="json", + postprocess=True, batch_stack_justification="center", **kwargs): """ - Second stage of the MTCNN. - :param img: - :param total_boxes: - :param stage_status: - :return: + Runs face detection on a single image or batch of images through the configured stages. + + Args: + image (str, bytes, np.ndarray or tf.Tensor or list): The input image or batch of images. + It can be a file path, a tensor, or raw bytes. + fit_to_image (bool, optional): Whether to fit bounding boxes and landmarks within image boundaries. Default is True. + limit_boundaries_landmarks (bool, optional): Whether to ensure landmarks stay within image boundaries. Default is False. + box_format (str, optional): The format of the bounding box. Can be "xywh" for [X1, Y1, width, height] or "xyxy" for [X1, Y1, X2, Y2]. + Default is "xywh". + output_type (str, optional): The output format. Can be "json" for dictionary output or "numpy" for numpy array output. Default is "json". + postprocess (bool, optional): Flag to enable postprocessing. The postprocessing includes functionality affected by `fit_to_image`, + `limit_boundaries_landmarks` and removing padding effects caused by batching images with different shapes. + batch_stack_justification (str, optional): The justification of the smaller images w.r.t. the largest images when + stacking in batch processing, which requires padding smaller images to the size of the + biggest one. + **kwargs: Additional parameters passed to the stages. The following parameters are used: + + - **StagePNet**: + - min_face_size (int, optional): The minimum size of a face to detect. Default is 20. + - min_size (int, optional): The minimum size to start the image pyramid. Default is 12. + - scale_factor (float, optional): The scaling factor for the image pyramid. Default is 0.709. + - threshold_pnet (float, optional): The confidence threshold for proposals from PNet. Default is 0.6. + - nms_pnet1 (float, optional): The IoU threshold for the first round of NMS per scale. Default is 0.5. + - nms_pnet2 (float, optional): The IoU threshold for the second round of NMS across all scales. Default is 0.7. + + - **StageRNet**: + - threshold_rnet (float, optional): Confidence threshold for RNet proposals. Default is 0.7. + - nms_rnet (float, optional): IoU threshold for Non-Maximum Suppression in RNet. Default is 0.7. + + - **StageONet**: + - threshold_onet (float, optional): Confidence threshold for ONet proposals. Default is 0.8. + - nms_onet (float, optional): IoU threshold for Non-Maximum Suppression in ONet. Default is 0.7. + + Returns: + list or list of lists: A list of detected faces (in case a single image) or a list of lists of detected faces + (one per image in the batch). If the stages are `face_and_landmarks_detection`, + the output will have the detected faces and landmarks in JSON format. + In case of `face_detection_only`, only the bounding boxes will be provided in + JSON format. """ + return_tensor = output_type == "numpy" + as_width_height = box_format == "xywh" - num_boxes = total_boxes.shape[0] - if num_boxes == 0: - return total_boxes, stage_status - - # second stage - tempimg = np.zeros(shape=(24, 24, 3, num_boxes)) - - for k in range(0, num_boxes): - tmp = np.zeros((int(stage_status.tmph[k]), int(stage_status.tmpw[k]), 3)) + is_batch = isinstance(image, list) + images = image if is_batch else [image] - tmp[stage_status.dy[k] - 1:stage_status.edy[k], stage_status.dx[k] - 1:stage_status.edx[k], :] = \ - img[stage_status.y[k] - 1:stage_status.ey[k], stage_status.x[k] - 1:stage_status.ex[k], :] - - if tmp.shape[0] > 0 and tmp.shape[1] > 0 or tmp.shape[0] == 0 and tmp.shape[1] == 0: - tempimg[:, :, :, k] = cv2.resize(tmp, (24, 24), interpolation=cv2.INTER_AREA) - - else: - return np.empty(shape=(0,)), stage_status + with tf.device(self._device): + # Load the images into memory and normalize them into a single tensor + try: + images_raw = load_images_batch(images) + images_normalized, images_oshapes, pad_param = standarize_batch(images_raw, + justification=batch_stack_justification, + normalize=True) + bboxes_batch = None - tempimg = (tempimg - 127.5) * 0.0078125 - tempimg1 = np.transpose(tempimg, (3, 1, 0, 2)) + # Process images through each stage (PNet, RNet, ONet) + for stage in self.stages: + bboxes_batch = stage(bboxes_batch=bboxes_batch, images_normalized=images_normalized, images_oshapes=images_oshapes, **kwargs) - out = self.__rnet.feed(tempimg1) + except tf.errors.InvalidArgumentError: # No faces found + bboxes_batch = np.empty((0, 16)) + pad_param = None - out0 = np.transpose(out[0]) - out1 = np.transpose(out[1]) + if postprocess and pad_param is not None: + # Adjust bounding boxes and landmarks to account for padding offsets + bboxes_batch = fix_bboxes_offsets(bboxes_batch, pad_param) - score = out1[1, :] + # Optionally, limit the bounding boxes and landmarks to stay within image boundaries + if fit_to_image: + bboxes_batch = limit_bboxes(bboxes_batch, images_shapes=images_oshapes, limit_landmarks=limit_boundaries_landmarks) - ipass = np.where(score > self.__steps_threshold[1]) + # Convert bounding boxes and landmarks to JSON format if required + if return_tensor: + result = bboxes_batch - total_boxes = np.hstack([total_boxes[ipass[0], 0:4].copy(), np.expand_dims(score[ipass].copy(), 1)]) + if as_width_height: + result[:, 3] = result[:, 3] - result[:, 1] + result[:, 4] = result[:, 4] - result[:, 2] - mv = out0[:, ipass[0]] - - if total_boxes.shape[0] > 0: - pick = self.__nms(total_boxes, 0.7, 'Union') - total_boxes = total_boxes[pick, :] - total_boxes = self.__bbreg(total_boxes.copy(), np.transpose(mv[:, pick])) - total_boxes = self.__rerec(total_boxes.copy()) - - return total_boxes, stage_status - - def __stage3(self, img, total_boxes, stage_status: StageStatus): - """ - Third stage of the MTCNN. - - :param img: - :param total_boxes: - :param stage_status: - :return: - """ - num_boxes = total_boxes.shape[0] - if num_boxes == 0: - return total_boxes, np.empty(shape=(0,)) - - total_boxes = np.fix(total_boxes).astype(np.int32) - - status = StageStatus(self.__pad(total_boxes.copy(), stage_status.width, stage_status.height), - width=stage_status.width, height=stage_status.height) - - tempimg = np.zeros((48, 48, 3, num_boxes)) - - for k in range(0, num_boxes): - - tmp = np.zeros((int(status.tmph[k]), int(status.tmpw[k]), 3)) - - tmp[status.dy[k] - 1:status.edy[k], status.dx[k] - 1:status.edx[k], :] = \ - img[status.y[k] - 1:status.ey[k], status.x[k] - 1:status.ex[k], :] - - if tmp.shape[0] > 0 and tmp.shape[1] > 0 or tmp.shape[0] == 0 and tmp.shape[1] == 0: - tempimg[:, :, :, k] = cv2.resize(tmp, (48, 48), interpolation=cv2.INTER_AREA) else: - return np.empty(shape=(0,)), np.empty(shape=(0,)) - - tempimg = (tempimg - 127.5) * 0.0078125 - tempimg1 = np.transpose(tempimg, (3, 1, 0, 2)) - - out = self.__onet.feed(tempimg1) - out0 = np.transpose(out[0]) - out1 = np.transpose(out[1]) - out2 = np.transpose(out[2]) - - score = out2[1, :] - - points = out1 - - ipass = np.where(score > self.__steps_threshold[2]) - - points = points[:, ipass[0]] - - total_boxes = np.hstack([total_boxes[ipass[0], 0:4].copy(), np.expand_dims(score[ipass].copy(), 1)]) - - mv = out0[:, ipass[0]] - - w = total_boxes[:, 2] - total_boxes[:, 0] + 1 - h = total_boxes[:, 3] - total_boxes[:, 1] + 1 - - points[0:5, :] = np.tile(w, (5, 1)) * points[0:5, :] + np.tile(total_boxes[:, 0], (5, 1)) - 1 - points[5:10, :] = np.tile(h, (5, 1)) * points[5:10, :] + np.tile(total_boxes[:, 1], (5, 1)) - 1 - - if total_boxes.shape[0] > 0: - total_boxes = self.__bbreg(total_boxes.copy(), np.transpose(mv)) - pick = self.__nms(total_boxes.copy(), 0.7, 'Min') - total_boxes = total_boxes[pick, :] - points = points[:, pick] - - return total_boxes, points + result = to_json(bboxes_batch, + images_count=len(images), + output_as_width_height=as_width_height, + input_as_width_height=False) + result = result[0] if (not is_batch and len(result) > 0) else result - def __del__(self): - self.__session.close() + return result diff --git a/mtcnn/network.py b/mtcnn/network.py deleted file mode 100644 index 824d38e..0000000 --- a/mtcnn/network.py +++ /dev/null @@ -1,111 +0,0 @@ -#!/usr/bin/python3 -# -*- coding: utf-8 -*- - -#MIT License -# -#Copyright (c) 2018 Iván de Paz Centeno -# -#Permission is hereby granted, free of charge, to any person obtaining a copy -#of this software and associated documentation files (the "Software"), to deal -#in the Software without restriction, including without limitation the rights -#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -#copies of the Software, and to permit persons to whom the Software is -#furnished to do so, subject to the following conditions: -# -#The above copyright notice and this permission notice shall be included in all -#copies or substantial portions of the Software. -# -#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -#SOFTWARE. - -import tensorflow as tf - -__author__ = "Iván de Paz Centeno" - - -class Network(object): - - def __init__(self, session, trainable: bool=True): - """ - Initializes the network. - :param trainable: flag to determine if this network should be trainable or not. - """ - self._session = session - self.__trainable = trainable - self.__layers = {} - self.__last_layer_name = None - - with tf.variable_scope(self.__class__.__name__.lower()): - self._config() - - def _config(self): - """ - Configures the network layers. - It is usually done using the LayerFactory() class. - """ - raise NotImplementedError("This method must be implemented by the network.") - - def add_layer(self, name: str, layer_output): - """ - Adds a layer to the network. - :param name: name of the layer to add - :param layer_output: output layer. - """ - self.__layers[name] = layer_output - self.__last_layer_name = name - - def get_layer(self, name: str=None): - """ - Retrieves the layer by its name. - :param name: name of the layer to retrieve. If name is None, it will retrieve the last added layer to the - network. - :return: layer output - """ - if name is None: - name = self.__last_layer_name - - return self.__layers[name] - - def is_trainable(self): - """ - Getter for the trainable flag. - """ - return self.__trainable - - def set_weights(self, weights_values: dict, ignore_missing=False): - """ - Sets the weights values of the network. - :param weights_values: dictionary with weights for each layer - """ - network_name = self.__class__.__name__.lower() - - with tf.variable_scope(network_name): - for layer_name in weights_values: - with tf.variable_scope(layer_name, reuse=True): - for param_name, data in weights_values[layer_name].items(): - try: - var = tf.get_variable(param_name) - self._session.run(var.assign(data)) - - except ValueError: - if not ignore_missing: - raise - - def feed(self, image): - """ - Feeds the network with an image - :param image: image (perhaps loaded with CV2) - :return: network result - """ - network_name = self.__class__.__name__.lower() - - with tf.variable_scope(network_name): - return self._feed(image) - - def _feed(self, image): - raise NotImplementedError("Method not implemented.") \ No newline at end of file diff --git a/mtcnn/network/__init__.py b/mtcnn/network/__init__.py new file mode 100644 index 0000000..51fec9d --- /dev/null +++ b/mtcnn/network/__init__.py @@ -0,0 +1,22 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + diff --git a/mtcnn/network/onet.py b/mtcnn/network/onet.py new file mode 100644 index 0000000..5defaf7 --- /dev/null +++ b/mtcnn/network/onet.py @@ -0,0 +1,157 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# pylint: disable=duplicate-code + +import tensorflow as tf + +L = tf.keras.layers + + +class ONet(tf.keras.Model): + """ + Definition of ONet (Output Network) for MTCNN. + + This network takes as input an image of size 48x48 with 3 channels, and outputs: + + * The regression of the bounding boxes (x1, y1, x2, y2) with a linear activation. + * The regression of 5 facial landmarks (10 points total). + * The classification of the area as a softmax operation ([1, 0] -> Not face; [0, 1] -> Face). + """ + def __init__(self, **kwargs): + super(ONet, self).__init__(**kwargs) + + # Defining the layers according to the provided architecture + self.conv1 = L.Conv2D(32, kernel_size=(3, 3), strides=(1, 1), padding="valid", activation="linear", name="conv1") + self.prelu1 = L.PReLU(shared_axes=[1, 2], name="prelu1") + self.maxpool1 = L.MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same", name="maxpooling1") + + self.conv2 = L.Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding="valid", activation="linear", name="conv2") + self.prelu2 = L.PReLU(shared_axes=[1, 2], name="prelu2") + self.maxpool2 = L.MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="valid", name="maxpooling2") + + self.conv3 = L.Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding="valid", activation="linear", name="conv3") + self.prelu3 = L.PReLU(shared_axes=[1, 2], name="prelu3") + self.maxpool3 = L.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="same", name="maxpooling3") + + self.conv4 = L.Conv2D(128, kernel_size=(2, 2), strides=(1, 1), padding="valid", activation="linear", name="conv4") + self.prelu4 = L.PReLU(shared_axes=[1, 2], name="prelu4") + + self.permute = L.Permute((2, 1, 3), name="permute") + self.flatten = L.Flatten(name="flatten4") + + self.fc5 = L.Dense(256, activation="linear", name="fc5") + self.prelu5 = L.PReLU(name="prelu5") + + self.fc6_1 = L.Dense(4, activation="linear", name="fc6-1") # Bounding box regression + self.fc6_2 = L.Dense(10, activation="linear", name="fc6-2") # Landmark regression (5 landmarks, 10 points total) + self.fc6_3 = L.Dense(2, activation="softmax", name="fc6-3") # Classification (face or not) + + def build(self, input_shape=(None, 48, 48, 3)): + """ + Build the network by defining the input and manually creating each layer step by step, computing output shapes. + This method mirrors the layer initialization in the functional API. + """ + # Build conv1 block + self.conv1.build(input_shape) + output_shape = self.conv1.compute_output_shape(input_shape) + self.prelu1.build(output_shape) + output_shape = self.prelu1.compute_output_shape(output_shape) + self.maxpool1.build(output_shape) + output_shape = self.maxpool1.compute_output_shape(output_shape) + + # Build conv2 block + self.conv2.build(output_shape) + output_shape = self.conv2.compute_output_shape(output_shape) + self.prelu2.build(output_shape) + output_shape = self.prelu2.compute_output_shape(output_shape) + self.maxpool2.build(output_shape) + output_shape = self.maxpool2.compute_output_shape(output_shape) + + # Build conv3 block + self.conv3.build(output_shape) + output_shape = self.conv3.compute_output_shape(output_shape) + self.prelu3.build(output_shape) + output_shape = self.prelu3.compute_output_shape(output_shape) + self.maxpool3.build(output_shape) + output_shape = self.maxpool3.compute_output_shape(output_shape) + + # Build conv4 block + self.conv4.build(output_shape) + output_shape = self.conv4.compute_output_shape(output_shape) + self.prelu4.build(output_shape) + output_shape = self.prelu4.compute_output_shape(output_shape) + + # Permute and flatten + self.permute.build(output_shape) + output_shape = self.permute.compute_output_shape(output_shape) + self.flatten.build(output_shape) + output_shape = self.flatten.compute_output_shape(output_shape) + + # Fully connected layers + self.fc5.build(output_shape) + output_shape = self.fc5.compute_output_shape(output_shape) + self.prelu5.build(output_shape) + output_shape = self.prelu5.compute_output_shape(output_shape) + + # Outputs (classification, bounding box regression, and landmark regression) + self.fc6_1.build(output_shape) + self.fc6_2.build(output_shape) + self.fc6_3.build(output_shape) + + # Call the super build to finalize the model building + super(ONet, self).build(input_shape) + + def call(self, inputs, *args, **kwargs): + x = inputs + + # First conv block + x = self.conv1(x) + x = self.prelu1(x) + x = self.maxpool1(x) + + # Second conv block + x = self.conv2(x) + x = self.prelu2(x) + x = self.maxpool2(x) + + # Third conv block + x = self.conv3(x) + x = self.prelu3(x) + x = self.maxpool3(x) + + # Fourth conv block + x = self.conv4(x) + x = self.prelu4(x) + + # Permute, flatten, and fully connected layers + x = self.permute(x) + x = self.flatten(x) + x = self.fc5(x) + x = self.prelu5(x) + + # Outputs + bbox_reg = self.fc6_1(x) # Regression of bounding boxes + landmarks = self.fc6_2(x) # Regression of facial landmarks + bbox_class = self.fc6_3(x) # Classification (face or not) + + return [bbox_reg, landmarks, bbox_class] diff --git a/mtcnn/network/pnet.py b/mtcnn/network/pnet.py new file mode 100644 index 0000000..f3134ec --- /dev/null +++ b/mtcnn/network/pnet.py @@ -0,0 +1,101 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# pylint: disable=duplicate-code + +import tensorflow as tf + + +L = tf.keras.layers + + +class PNet(tf.keras.Model): + """ + Definition of PNet (Proposal Network) + + This network takes as input an image with variable width and height, and generates two outputs: + + * The regression of the bounding boxes (x1, y1, x2, y2) with a linear activation. + * The classification of the area as a softmax operation ([1,0] -> Not face; [0,1] -> Face) + """ + def __init__(self, **kwargs): + super(PNet, self).__init__(**kwargs) + + # Definir las capas + self.conv1 = L.Conv2D(10, kernel_size=(3,3), strides=(1,1), padding="valid", activation="linear", name="conv1") + self.prelu1 = L.PReLU(shared_axes=[1, 2], name="prelu1") + self.maxpool1 = L.MaxPooling2D(pool_size=(2,2), strides=(2,2), padding="same", name="maxpooling1") + self.conv2 = L.Conv2D(16, kernel_size=(3,3), strides=(1,1), padding="valid", activation="linear", name="conv2") + self.prelu2 = L.PReLU(shared_axes=[1, 2], name="prelu2") + self.conv3 = L.Conv2D(32, kernel_size=(3,3), strides=(1,1), padding="valid", activation="linear", name="conv3") + self.prelu3 = L.PReLU(shared_axes=[1, 2], name="prelu3") + self.conv4_1 = L.Conv2D(4, kernel_size=(1,1), strides=(1,1), padding="valid", activation="linear", name="conv4-1") + self.conv4_2 = L.Conv2D(2, kernel_size=(1,1), strides=(1,1), padding="valid", activation="softmax", name="conv4-2") + + def build(self, input_shape=(None, None, None, 3)): + self.conv1.build(input_shape) + output_shape = self.conv1.compute_output_shape(input_shape) + + self.prelu1.build(output_shape) + output_shape = self.prelu1.compute_output_shape(output_shape) + + self.maxpool1.build(output_shape) + output_shape = self.maxpool1.compute_output_shape(output_shape) + + self.conv2.build(output_shape) + output_shape = self.conv2.compute_output_shape(output_shape) + + self.prelu2.build(output_shape) + output_shape = self.prelu2.compute_output_shape(output_shape) + + self.conv3.build(output_shape) + output_shape = self.conv3.compute_output_shape(output_shape) + + self.prelu3.build(output_shape) + output_shape = self.prelu3.compute_output_shape(output_shape) + + self.conv4_1.build(output_shape) + self.conv4_2.build(output_shape) + + super(PNet, self).build(input_shape) + + def call(self, inputs, *args, **kwargs): + x = inputs + + # First conv block + x = self.conv1(x) + x = self.prelu1(x) + x = self.maxpool1(x) + + # Second conv block + x = self.conv2(x) + x = self.prelu2(x) + + # Third conv block + x = self.conv3(x) + x = self.prelu3(x) + + # Outputs + bbox_reg = self.conv4_1(x) + bbox_class = self.conv4_2(x) + + return [bbox_reg, bbox_class] diff --git a/mtcnn/network/rnet.py b/mtcnn/network/rnet.py new file mode 100644 index 0000000..6b1b6ea --- /dev/null +++ b/mtcnn/network/rnet.py @@ -0,0 +1,137 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# pylint: disable=duplicate-code + +import tensorflow as tf + + +L = tf.keras.layers + + +class RNet(tf.keras.Model): + """ + Definition of RNet (Refinement Network) for MTCNN. + + This network takes as input an image of size 24x24 with 3 channels, and outputs: + + * The regression of the bounding boxes (x1, y1, x2, y2) with a linear activation. + * The classification of the area as a softmax operation ([1, 0] -> Not face; [0, 1] -> Face). + """ + def __init__(self, **kwargs): + super(RNet, self).__init__(**kwargs) + + # Defining the layers according to the provided architecture + self.conv1 = L.Conv2D(28, kernel_size=(3,3), strides=(1,1), padding="valid", activation="linear", name="conv1") + self.prelu1 = L.PReLU(shared_axes=[1, 2], name="prelu1") + self.maxpool1 = L.MaxPooling2D(pool_size=(3,3), strides=(2,2), padding="same", name="maxpooling1") + + self.conv2 = L.Conv2D(48, kernel_size=(3,3), strides=(1,1), padding="valid", activation="linear", name="conv2") + self.prelu2 = L.PReLU(shared_axes=[1, 2], name="prelu2") + self.maxpool2 = L.MaxPooling2D(pool_size=(3,3), strides=(2,2), padding="valid", name="maxpooling2") + + self.conv3 = L.Conv2D(64, kernel_size=(2,2), strides=(1,1), padding="valid", activation="linear", name="conv3") + self.prelu3 = L.PReLU(shared_axes=[1, 2], name="prelu3") + + self.permute = L.Permute((2, 1, 3), name="permute") + self.flatten = L.Flatten(name="flatten3") + + self.fc4 = L.Dense(128, activation="linear", name="fc4") + self.prelu4 = L.PReLU(name="prelu4") + + self.fc5_1 = L.Dense(4, activation="linear", name="fc5-1") + self.fc5_2 = L.Dense(2, activation="softmax", name="fc5-2") + + def build(self, input_shape=(None, 24, 24, 3)): + """ + Build the network by defining the input and manually creating each layer step by step, computing output shapes. + This method mirrors the layer initialization in the functional API. + """ + # Build conv1 block + self.conv1.build(input_shape) + output_shape = self.conv1.compute_output_shape(input_shape) + self.prelu1.build(output_shape) + output_shape = self.prelu1.compute_output_shape(output_shape) + self.maxpool1.build(output_shape) + output_shape = self.maxpool1.compute_output_shape(output_shape) + + # Build conv2 block + self.conv2.build(output_shape) + output_shape = self.conv2.compute_output_shape(output_shape) + self.prelu2.build(output_shape) + output_shape = self.prelu2.compute_output_shape(output_shape) + self.maxpool2.build(output_shape) + output_shape = self.maxpool2.compute_output_shape(output_shape) + + # Build conv3 block + self.conv3.build(output_shape) + output_shape = self.conv3.compute_output_shape(output_shape) + self.prelu3.build(output_shape) + output_shape = self.prelu3.compute_output_shape(output_shape) + + # Permute and flatten + self.permute.build(output_shape) + output_shape = self.permute.compute_output_shape(output_shape) + self.flatten.build(output_shape) + output_shape = self.flatten.compute_output_shape(output_shape) + + # Fully connected layers + self.fc4.build(output_shape) + output_shape = self.fc4.compute_output_shape(output_shape) + self.prelu4.build(output_shape) + output_shape = self.prelu4.compute_output_shape(output_shape) + + # Outputs (classification and regression) + self.fc5_1.build(output_shape) + self.fc5_2.build(output_shape) + + # Call the super build to finalize the model building + super(RNet, self).build(input_shape) + + def call(self, inputs, *args, **kwargs): + x = inputs + + # First conv block + x = self.conv1(x) + x = self.prelu1(x) + x = self.maxpool1(x) + + # Second conv block + x = self.conv2(x) + x = self.prelu2(x) + x = self.maxpool2(x) + + # Third conv block + x = self.conv3(x) + x = self.prelu3(x) + + # Permute, flatten, and fully connected layers + x = self.permute(x) + x = self.flatten(x) + x = self.fc4(x) + x = self.prelu4(x) + + # Outputs + bbox_reg = self.fc5_1(x) # Regression of bounding boxes + bbox_class = self.fc5_2(x) # Classification (face or not) + + return [bbox_reg, bbox_class] diff --git a/mtcnn/stages/__init__.py b/mtcnn/stages/__init__.py new file mode 100644 index 0000000..65bcddf --- /dev/null +++ b/mtcnn/stages/__init__.py @@ -0,0 +1,27 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from mtcnn.stages.stage_pnet import StagePNet +from mtcnn.stages.stage_rnet import StageRNet +from mtcnn.stages.stage_onet import StageONet + +__all__ = ["StagePNet", "StageRNet", "StageONet"] diff --git a/mtcnn/stages/base.py b/mtcnn/stages/base.py new file mode 100644 index 0000000..b202ac8 --- /dev/null +++ b/mtcnn/stages/base.py @@ -0,0 +1,91 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from abc import ABC, abstractmethod + + +class StageBase(ABC): + """ + Base class for defining a stage in a processing pipeline. + + This class serves as an abstract base for stages in a model's processing pipeline. Each stage + is defined by a name, an identifier, and an optional model associated with it. Subclasses must + implement the `__call__` method to define the specific functionality of the stage. + """ + + def __init__(self, stage_name, stage_id, model=None, **kwargs): + """ + Initializes a StageBase object with a name, ID, and optional model. + + Args: + stage_name (str): The name of the stage. + stage_id (str or int): The identifier of the stage. + model (object, optional): The model associated with this stage. + *args: Additional positional arguments. + **kwargs: Additional keyword arguments. + """ + self._name = stage_name + self._id = stage_id + self._model = model + + @property + def model(self): + """ + Returns the model associated with this stage. + + Returns: + object: The model associated with this stage, or None if no model is set. + """ + return self._model + + @property + def id(self): + """ + Returns the identifier of the stage. + + Returns: + str or int: The identifier of the stage. + """ + return self._id + + @property + def name(self): + """ + Returns the name of the stage. + + Returns: + str: The name of the stage. + """ + return self._name + + @abstractmethod + def __call__(self, *args, **kwargs): + """ + Abstract method that must be implemented by subclasses to define the functionality of the stage. + + Args: + *args: Positional arguments for the stage's functionality. + **kwargs: Keyword arguments for the stage's functionality. + + Raises: + NotImplementedError: If the method is not implemented in a subclass. + """ diff --git a/mtcnn/stages/stage_onet.py b/mtcnn/stages/stage_onet.py new file mode 100644 index 0000000..ab8b9cf --- /dev/null +++ b/mtcnn/stages/stage_onet.py @@ -0,0 +1,105 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# pylint: disable=duplicate-code + +import numpy as np + +from mtcnn.network.onet import ONet + +from mtcnn.utils.tensorflow import load_weights +from mtcnn.utils.images import extract_patches +from mtcnn.utils.bboxes import replace_confidence, adjust_bboxes, pick_matches, smart_nms_from_bboxes +from mtcnn.utils.landmarks import adjust_landmarks + +from mtcnn.stages.base import StageBase + + +class StageONet(StageBase): + """ + Stage for running the Output Network (ONet) of the MTCNN model. This stage refines the bounding box proposals + generated by the RNet stage, adjusts the bounding boxes, predicts facial landmarks, and filters the results + using ONet's output. + + Args: + stage_name (str): Name of the stage. Defaults to "Stage ONET". + stage_id (int): Unique identifier for the stage. Defaults to 3. + weights (str): Path to the weights file to load the model. Defaults to "onet.lz4". + """ + + def __init__(self, stage_name="Stage ONET", stage_id=3, weights="onet.lz4"): + """ + Initializes the StageONet by loading the ONet model and setting the specified weights. + + Args: + stage_name (str, optional): The name of the stage. Default is "Stage ONET". + stage_id (int, optional): The ID for the stage. Default is 3. + weights (str, optional): The file path to the weights for the ONet model. Default is "onet.lz4". + """ + model = ONet() + model.build() # Building the ONet model + model.set_weights(load_weights(weights)) # Load pre-trained weights + + super().__init__(stage_name=stage_name, stage_id=stage_id, model=model) + + def __call__(self, images_normalized, bboxes_batch, threshold_onet=0.8, nms_onet=0.7, **kwargs): + """ + Runs the ONet stage on the input images and bounding boxes, refining the proposals generated by the RNet stage + and adding facial landmarks prediction. + + Args: + images_normalized (tf.Tensor): A tensor of normalized images with shape (batch_size, width, height, 3). + bboxes_batch (np.ndarray): An array of bounding boxes produced by the RNet stage, each row representing + [image_id, x1, y1, x2, y2, confidence, landmark_x1, landmark_y1, ...]. + threshold_onet (float, optional): The confidence threshold for keeping bounding boxes after ONet refinement. Default is 0.8. + nms_onet (float, optional): The IoU threshold for Non-Maximum Suppression after ONet refinement. Default is 0.7. + **kwargs: Additional arguments passed to the function. + + Returns: + np.ndarray: A numpy array of refined bounding boxes and landmarks after ONet processing, ready for the final stage. + """ + # 1. Extract patches for each bounding box from the normalized images. + # These patches are resized to the expected input size for ONet (48x48). + patches = extract_patches(images_normalized, bboxes_batch, expected_size=(48, 48)) + + # 2. Pass the extracted patches through ONet to get bounding box offsets, facial landmarks, and confidence scores. + bboxes_offsets, face_landmarks, scores = self._model(patches) + + # 3. Adjust the landmarks to match the bounding box coordinates relative to the original image. + face_landmarks = adjust_landmarks(face_landmarks, bboxes_batch) + + # 4. Replace the confidence of the bounding boxes with the ones provided by ONet. + bboxes_batch = replace_confidence(bboxes_batch, scores) + + # 5. Adjust the bounding boxes using the offsets predicted by ONet (refinement of the proposals). + bboxes_batch = adjust_bboxes(bboxes_batch, bboxes_offsets) + + # 6. Combine the facial landmarks with the bounding boxes batch tensor. + bboxes_batch = np.concatenate([bboxes_batch, face_landmarks], axis=-1) + + # 7. Filter out bounding boxes based on the new confidence scores and the threshold set for ONet. + bboxes_batch = pick_matches(bboxes_batch, scores_column=5, score_threshold=threshold_onet) + + # 8. Apply Non-Maximum Suppression (NMS) to remove overlapping boxes based on the refined boxes, scores, and landmarks. + bboxes_batch = smart_nms_from_bboxes(bboxes_batch, threshold=nms_onet, method="min", initial_sort=True) + + return bboxes_batch diff --git a/mtcnn/stages/stage_pnet.py b/mtcnn/stages/stage_pnet.py new file mode 100644 index 0000000..0138886 --- /dev/null +++ b/mtcnn/stages/stage_pnet.py @@ -0,0 +1,108 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# pylint: disable=duplicate-code + +import numpy as np + +from mtcnn.network.pnet import PNet + +from mtcnn.utils.tensorflow import load_weights +from mtcnn.utils.images import build_scale_pyramid, apply_scales +from mtcnn.utils.bboxes import generate_bounding_box, upscale_bboxes, smart_nms_from_bboxes, resize_to_square + +from mtcnn.stages.base import StageBase + + +class StagePNet(StageBase): + """ + Stage for running the Proposal Network (PNet) of the MTCNN model. This stage takes images, builds + image pyramids for different scales, and runs PNet to generate bounding box proposals, applying + Non-Maximum Suppression (NMS) to filter overlapping boxes. + + Args: + stage_name (str): Name of the stage. Defaults to "Stage PNET". + stage_id (int): Unique identifier for the stage. Defaults to 1. + weights (str): Path to the weights file to load the model. Defaults to "pnet.lz4". + """ + + def __init__(self, stage_name="Stage PNET", stage_id=1, weights="pnet.lz4"): + """ + Initializes the StagePNet by loading the PNet model and setting the specified weights. + + Args: + stage_name (str, optional): The name of the stage. Default is "Stage PNET". + stage_id (int, optional): The ID for the stage. Default is 1. + weights (str, optional): The file path to the weights for the PNet model. Default is "pnet.lz4". + """ + model = PNet() + model.build() # Building the model (no need to specify input shape if default is provided) + model.set_weights(load_weights(weights)) # Load pre-trained weights + + super().__init__(stage_name=stage_name, stage_id=stage_id, model=model) + + def __call__(self, images_normalized, images_oshapes, min_face_size=20, min_size=12, scale_factor=0.709, + threshold_pnet=0.6, nms_pnet1=0.5, nms_pnet2=0.7, **kwargs): + """ + Runs the PNet stage on a batch of images to generate bounding box proposals. + + Args: + images_normalized (tf.Tensor): A tensor of normalized images with shape (batch_size, width, height, 3). + These images are padded to match the size of the largest image in the batch. + images_oshapes (tf.Tensor): A tensor containing the original shapes of the images, with shape (batch_size, 3). + min_face_size (int, optional): The minimum size of a face to detect. Default is 20. + min_size (int, optional): The minimum size to start the image pyramid. Default is 12. + scale_factor (float, optional): The scaling factor for the image pyramid. Default is 0.709. + threshold_pnet (float, optional): The confidence threshold for proposals from PNet. Default is 0.6. + nms_pnet1 (float, optional): The IoU threshold for the first round of NMS per scale. Default is 0.5. + nms_pnet2 (float, optional): The IoU threshold for the second round of NMS across all scales. Default is 0.7. + **kwargs: Additional arguments passed to the function. + + Returns: + np.ndarray: A numpy array of bounding boxes after NMS and resizing to square, ready for the next stage. + """ + # 1. Build the pyramid scale for every image based on the size and scale factor + scales_groups = [build_scale_pyramid(shape[1], shape[0], min_face_size=min_face_size, scale_factor=scale_factor) + for shape in images_oshapes] + + # 2. Apply the scales to normalized images + scales_result, scales_index = apply_scales(images_normalized, scales_groups) + batch_size = images_normalized.shape[0] + + # 3. Get proposals bounding boxes and confidence from the model (PNet) + pnet_result = [self._model(s) for s in scales_result] + + # 4. Generate bounding boxes per scale group + bboxes_proposals = [generate_bounding_box(result[0], result[1], threshold_pnet) for result in pnet_result] + bboxes_batch_upscaled = [upscale_bboxes(bbox, np.asarray([scale] * batch_size)) for bbox, scale in zip(bboxes_proposals, scales_index)] + + # 5. Apply Non-Maximum Suppression (NMS) per scale group + bboxes_nms = [smart_nms_from_bboxes(b, threshold=nms_pnet1, method="union", initial_sort=False) for b in bboxes_batch_upscaled] + + # 6. Concatenate and apply NMS again across all scales + bboxes_batch = np.concatenate(bboxes_nms, axis=0) if len(bboxes_nms) > 0 else np.empty((0, 6)) + bboxes_batch = smart_nms_from_bboxes(bboxes_batch, threshold=nms_pnet2, method="union", initial_sort=True) + + # 7. Resize bounding boxes to square format + bboxes_batch = resize_to_square(bboxes_batch) + + return bboxes_batch diff --git a/mtcnn/stages/stage_rnet.py b/mtcnn/stages/stage_rnet.py new file mode 100644 index 0000000..4a3b296 --- /dev/null +++ b/mtcnn/stages/stage_rnet.py @@ -0,0 +1,97 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# pylint: disable=duplicate-code + +from mtcnn.network.rnet import RNet + +from mtcnn.utils.tensorflow import load_weights +from mtcnn.utils.images import extract_patches +from mtcnn.utils.bboxes import replace_confidence, adjust_bboxes, pick_matches, smart_nms_from_bboxes, resize_to_square + +from mtcnn.stages.base import StageBase + + +class StageRNet(StageBase): + """ + Stage for running the Refinement Network (RNet) of the MTCNN model. This stage refines the bounding box + proposals generated by the PNet stage, adjusts the bounding boxes, and filters them using RNet's output. + + Args: + stage_name (str): Name of the stage. Defaults to "Stage RNET". + stage_id (int): Unique identifier for the stage. Defaults to 2. + weights (str): Path to the weights file to load the model. Defaults to "rnet.lz4". + """ + + def __init__(self, stage_name="Stage RNET", stage_id=2, weights="rnet.lz4"): + """ + Initializes the StageRNet by loading the RNet model and setting the specified weights. + + Args: + stage_name (str, optional): The name of the stage. Default is "Stage RNET". + stage_id (int, optional): The ID for the stage. Default is 2. + weights (str, optional): The file path to the weights for the RNet model. Default is "rnet.lz4". + """ + model = RNet() + model.build() # Building the RNet model + model.set_weights(load_weights(weights)) # Load pre-trained weights + + super().__init__(stage_name=stage_name, stage_id=stage_id, model=model) + + def __call__(self, images_normalized, bboxes_batch, threshold_rnet=0.7, nms_rnet=0.7, **kwargs): + """ + Runs the RNet stage on the input images and bounding boxes, refining the proposals generated by the PNet stage. + + Args: + images_normalized (tf.Tensor): A tensor of normalized images with shape (batch_size, width, height, 3). + bboxes_batch (np.ndarray): An array of bounding boxes produced by the PNet stage, each row representing + [image_id, x1, y1, x2, y2, confidence, landmark_x1, landmark_y1, ...]. + threshold_rnet (float, optional): The confidence threshold for keeping bounding boxes after RNet refinement. Default is 0.7. + nms_rnet (float, optional): The IoU threshold for Non-Maximum Suppression after RNet refinement. Default is 0.7. + **kwargs: Additional arguments passed to the function. + + Returns: + np.ndarray: A numpy array of refined bounding boxes after RNet processing, ready for the next stage. + """ + # 1. Extract patches for each bounding box from the normalized images. + # These patches are resized to the expected input size for RNet (24x24). + patches = extract_patches(images_normalized, bboxes_batch, expected_size=(24, 24)) + + # 2. Pass the extracted patches through RNet to get bounding box offsets and confidence scores. + bboxes_offsets, scores = self._model(patches) + + # 3. Replace the confidence of the bounding boxes with the ones provided by RNet. + bboxes_batch = replace_confidence(bboxes_batch, scores) + + # 4. Adjust the bounding boxes using the offsets predicted by RNet (refinement of the proposals). + bboxes_batch = adjust_bboxes(bboxes_batch, bboxes_offsets) + + # 5. Filter out bounding boxes based on the new confidence scores and the threshold set for RNet. + bboxes_batch = pick_matches(bboxes_batch, score_threshold=threshold_rnet) + + # 6. Apply Non-Maximum Suppression (NMS) to remove overlapping boxes based on the refined boxes and scores. + bboxes_batch = smart_nms_from_bboxes(bboxes_batch, threshold=nms_rnet, method="union", initial_sort=True) + + # 7. Resize bounding boxes to a square format to prepare them for the next stage. + bboxes_batch = resize_to_square(bboxes_batch) + + return bboxes_batch diff --git a/mtcnn/utils/__init__.py b/mtcnn/utils/__init__.py new file mode 100644 index 0000000..02a9a4b --- /dev/null +++ b/mtcnn/utils/__init__.py @@ -0,0 +1,21 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. diff --git a/mtcnn/utils/bboxes.py b/mtcnn/utils/bboxes.py new file mode 100644 index 0000000..f97d111 --- /dev/null +++ b/mtcnn/utils/bboxes.py @@ -0,0 +1,565 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import numpy as np + +from mtcnn.utils.landmarks import parse_landmarks + + +def generate_bounding_box(bbox_reg, bbox_class, threshold_face, strides=2, cell_size=12): + """ + Generates bounding boxes for detected objects (e.g., faces) based on the class and regression outputs of a model, + supporting batch input. + + Args: + bbox_reg (tf.Tensor): Bounding box regression predictions with shape (batch_size, height, width, 4). + This contains adjustments to apply to the initial bounding box positions for each image in the batch. + bbox_class (tf.Tensor): Class predictions (e.g., face/non-face) of shape (batch_size, height, width, 2), + where the second channel corresponds to the probability of a face being present. + threshold_face (float): A threshold between 0 and 1 that determines if a detection is considered a face or not. + Bounding boxes are only generated for detections with probabilities greater than this value. + strides (int, optional): The step size (in pixels) used to slide the detection window over the image. Default is 2. + cell_size (int, optional): The size of the sliding window (in pixels) used to detect faces. Default is 12. + + Returns: + np.ndarray: An array of bounding boxes for the entire batch, where each box is represented as + [batch_index, x1, y1, x2, y2, confidence]. + The `batch_index` indicates which image in the batch the bounding box belongs to. + """ + bbox_reg = bbox_reg.numpy() + bbox_class = bbox_class.numpy() + + # Create a mask for detected faces based on the threshold for face probability + confidence_score = bbox_class[:,:,:,1] + + # Find the indices where the detection mask is true (i.e., face detected) + index_bboxes = np.stack(np.where(confidence_score > threshold_face)) # batch_size, y, x + filtered_bbox_reg = np.transpose(bbox_reg[index_bboxes[0], index_bboxes[1], index_bboxes[2]], (1,0)) + + # Extract the regression values + reg_x1, reg_y1, reg_x2, reg_y2 = filtered_bbox_reg + + # Convert strides and cell size into arrays for easy broadcasting + strides = np.asarray([[1], [strides], [strides]]) + cellsize = [np.asarray([[0], [1], [1]]), np.asarray([[0], [cell_size], [cell_size]])] + + # Calculate the top-left and bottom-right corners of the bounding boxes + bbox_up_left = index_bboxes * strides + cellsize[0] + bbox_bottom_right = index_bboxes * strides + cellsize[1] + + # Calculate width and height for the bounding boxes + reg_w = bbox_bottom_right[2] - bbox_up_left[2] # width of bounding box + reg_h = bbox_bottom_right[1] - bbox_up_left[1] # height of bounding box + + # Apply the regression to adjust the bounding box coordinates + x1 = bbox_up_left[2] + reg_x1 * reg_w # Adjusted x1 + y1 = bbox_up_left[1] + reg_y1 * reg_h # Adjusted y1 + x2 = bbox_bottom_right[2] + reg_x2 * reg_w # Adjusted x2 + y2 = bbox_bottom_right[1] + reg_y2 * reg_h # Adjusted y2 + + # Concatenate the bounding box coordinates and detection information, keeping batch index + bboxes_result = np.stack([ + index_bboxes[0], x1, y1, x2, y2, confidence_score[index_bboxes[0], index_bboxes[1], index_bboxes[2]] + ], axis=0).T + + # Sort bounding boxes by score in descending order + bboxes_result = sort_by_scores(bboxes_result, scores=bboxes_result[:, -1], ascending=False) + + return bboxes_result + + +def upscale_bboxes(bboxes_result, scales): + """ + Upscales bounding boxes to their original size based on the scaling factors applied during image resizing, + supporting batch input. + + Args: + bboxes_result (np.ndarray): Array of bounding boxes, where each box is represented as + [batch_index, x1, y1, x2, y2, confidence, reg_x1, reg_y1, reg_x2, reg_y2]. + scales (np.ndarray): Array of scaling factors used during image resizing, typically one scale per image or detection. + The shape of `scales` should be (batch_size,), where each entry corresponds to the scale applied to an + image in the batch. + + Returns: + np.ndarray: The input bounding boxes, but with the coordinates scaled back to the original image dimensions, + adjusted for each image in the batch according to its respective scale. + """ + + # Broadcast the scales to match the shape of the bounding boxes, ensuring the correct scale is applied to each batch entry + scales_bcast = np.expand_dims(scales[bboxes_result[:,0].astype(int)], axis=-1) + + # Scale the bounding box coordinates (x1, y1, x2, y2) back to the original image size + bboxes_result[:,1:5] = bboxes_result[:,1:5] / scales_bcast + + return bboxes_result + + +def iou(bboxes, method="union"): + """ + Computes the Intersection over Union (IoU) for a set of bounding boxes based on the specified method ("union" or "min"). + + Args: + bboxes (list or np.ndarray): List or array of bounding boxes, where each bounding box is represented as + [row1, col1, row2, col2] (coordinates of the top-left and bottom-right corners). + method (str, optional): Method to compute the IoU. Options are: + - "union": Computes IoU based on the union of the bounding boxes. + - "min": Computes IoU based on the minimum area of the bounding boxes. + Default is "union". + + Returns: + np.ndarray: A matrix of shape (N, N) where each element [i, j] represents the IoU between the i-th and j-th bounding box. + The matrix is symmetric, with diagonal elements equal to 1 (IoU of a box with itself). + """ + + # Convert the list of bounding boxes to a NumPy array + bboxes = np.stack(bboxes, axis=0) + + # Calculate the area of each bounding box + area_bboxes = (bboxes[:, 2] - bboxes[:, 0]) * (bboxes[:, 3] - bboxes[:, 1]) + + # Expand dimensions to compute pairwise IoU (N x N matrix) + bboxes_a = np.expand_dims(bboxes, axis=0) + bboxes_b = np.expand_dims(bboxes, axis=1) + + # Calculate the intersection coordinates + row_inter_top = np.maximum(bboxes_a[:, :, 0], bboxes_b[:, :, 0]) + col_inter_left = np.maximum(bboxes_a[:, :, 1], bboxes_b[:, :, 1]) + row_inter_bottom = np.minimum(bboxes_a[:, :, 2], bboxes_b[:, :, 2]) + col_inter_right = np.minimum(bboxes_a[:, :, 3], bboxes_b[:, :, 3]) + + # Calculate the intersection area + height_inter = np.maximum(0, row_inter_bottom - row_inter_top) + width_inter = np.maximum(0, col_inter_right - col_inter_left) + area_inter = height_inter * width_inter + + # Compute IoU based on the specified method + if method == "union": + # Union: Area of A + Area of B - Intersection + area_union = area_bboxes[:, None] + area_bboxes[None, :] - area_inter + iou_matrix = area_inter / area_union + elif method == "min": + # Minimum: Area of the smaller box between A and B + area_min = np.minimum(area_bboxes[:, None], area_bboxes[None, :]) + iou_matrix = area_inter / area_min + else: + raise ValueError("Method should be either 'union' or 'min'.") + + return iou_matrix + + +def sort_by_scores(tensor, scores, ascending=True): + """ + Sorts a tensor based on an array of scores, either in ascending or descending order. + + Args: + tensor (np.ndarray): Tensor of shape (N, ...) where N is the number of elements to sort. + scores (np.ndarray): Array of shape (N,) containing scores associated with each element in the tensor. + ascending (bool, optional): Whether to sort in ascending order. Default is True (ascending). + + Returns: + np.ndarray: The tensor sorted according to the scores. + """ + + # Get the sorted indices based on the scores + sorted_indices = np.argsort(scores) + + # Sort the tensor using the sorted indices, reversing if descending + sorted_tensor = tensor[sorted_indices[::(-2 * int(not ascending) + 1)]] + + return sorted_tensor + + +def nms(target_iou, threshold): + """ + Performs Non-Maximum Suppression (NMS) to filter out overlapping bounding boxes based on the IoU threshold. + + Args: + target_iou (np.ndarray): A square IoU matrix of shape (N, N) where each element [i, j] represents the IoU + between the i-th and j-th bounding box. + threshold (float): IoU threshold above which boxes are considered to overlap too much and will be suppressed. + + Returns: + np.ndarray: Array of indices of bounding boxes that are kept after NMS. + """ + + # Step 1: Create a mask for allowed comparisons (upper triangular part of the IoU matrix, excluding the diagonal) + allowed_mask = np.triu(np.ones((target_iou.shape[0], target_iou.shape[0])), k=1) + + # Step 2: Create a mask for failed comparisons (IoU above the threshold) + failed_mask = (target_iou > threshold).astype(int) + + # Step 3: Combine the masks and get the indices of the remaining boxes + result_indexes = np.where((failed_mask * allowed_mask).sum(axis=0) == 0)[0] + + return result_indexes + + +def smart_nms_from_bboxes(bboxes, threshold, column_image_id=0, columns_bbox=slice(1, 5, None), column_confidence=5, + method="union", initial_sort=True): + """ + Applies Non-Maximum Suppression (NMS) to a set of bounding boxes grouped by image ID. + + Args: + bboxes (np.ndarray): Array of bounding boxes, where each box is represented as + [image_id, row1, col1, row2, col2, score]. + threshold (float): IoU threshold for NMS. Bounding boxes with IoU higher than this value will be suppressed. + column_image_id (int): Column position in the array indicating the image id. + columns_bbox (slice): Slice of columns containing the BBox coords. + method (str, optional): Method for IoU calculation. Can be "union" or "min". Default is "union". + column_confidence (int): Column containing the value of confidence for each bbox. + initial_sort (bool): True to sort bboxes by confidence value. False otherwise. + + Returns: + A np.ndarray containing the filtered bboxes, image-wise. + dict: A dictionary where keys are `image_id` and values are arrays of indices of bounding boxes that are + kept after NMS for each image. + """ + # Step 0: Sort if required + if initial_sort: + bboxes = sort_by_scores(bboxes, scores=bboxes[:, column_confidence], ascending=False) + + # Step 1: Get unique image IDs + image_ids = np.unique(bboxes[:, 0]) + + result = [] + + # Step 2: Apply NMS per image + for image_id in image_ids: + # Filter bounding boxes for the current image + target_bboxes = bboxes[bboxes[:, column_image_id] == image_id] + + # Compute the IoU matrix for the bounding boxes + target_iou = iou(target_bboxes[:, columns_bbox], method=method) + + # Perform NMS and get the indices of the boxes to keep + target_indexes = nms(target_iou, threshold) + + # Filter the boxes for the image + target_filtered_bboxes = target_bboxes[target_indexes.astype(int)] + + # Store the result + result.append(target_filtered_bboxes) + + result = np.concatenate(result, axis=0) if len(result) > 0 else np.empty((0, 6)) + + return result + + +def resize_to_square(bboxes): + """ + Adjusts bounding boxes to be square by resizing them based on their largest dimension + (width or height). The bounding boxes are resized by expanding the smaller dimension + to match the larger one while keeping the center of the box intact. + + Args: + bboxes (np.ndarray): An array of bounding boxes of shape (n, 5), where each row + represents [batch_index, x1, y1, x2, y2]. + + Returns: + np.ndarray: An array of bounding boxes adjusted to be square, maintaining their center positions. + """ + bboxes = bboxes.copy() + h = bboxes[:, 4] - bboxes[:, 2] # Height of each bounding box + w = bboxes[:, 3] - bboxes[:, 1] # Width of each bounding box + largest_size = np.maximum(w, h) # Largest dimension (width or height) + + # Adjust x1 and y1 to center the bounding box and resize to square + bboxes[:, 1] = bboxes[:, 1] + w * 0.5 - largest_size * 0.5 + bboxes[:, 2] = bboxes[:, 2] + h * 0.5 - largest_size * 0.5 + bboxes[:, 3:5] = bboxes[:, 1:3] + np.tile(largest_size, (2, 1)).T # Resize x2, y2 + + return bboxes + + +def replace_confidence(bboxes_batch, new_scores): + """ + Replaces the confidence scores of bounding boxes with new scores provided. + + Args: + bboxes_batch (np.ndarray): An array of bounding boxes of shape (n, m), where each row + contains the bounding box coordinates and the confidence score. + The confidence score is expected to be in the last column. + new_scores (np.ndarray): An array of new confidence scores of shape (n, m), where the + confidence score is also expected to be in the last column. + + Returns: + np.ndarray: The bounding boxes array with updated confidence scores from `new_scores`. + """ + bboxes_batch[:, -1] = new_scores[:, -1] + return bboxes_batch + + +def adjust_bboxes(bboxes_batch, bboxes_offsets): + """ + Adjusts the bounding box coordinates by applying the provided offsets. + + The offsets are applied to resize and shift the bounding boxes based on their width and height. + + Args: + bboxes_batch (np.ndarray): An array of bounding boxes of shape (n, m), where each row contains + the batch index, bounding box coordinates [x1, y1, x2, y2], and + potentially additional data such as scores. + bboxes_offsets (np.ndarray): An array of offsets for adjusting the bounding boxes. The shape should be + (n, 4), where each row contains offsets for [dx1, dy1, dx2, dy2]. + + Returns: + np.ndarray: The adjusted bounding boxes with updated coordinates, maintaining any additional columns + beyond the bounding box coordinates (such as scores). + """ + bboxes_batch = bboxes_batch.copy() + w = bboxes_batch[:, 3] - bboxes_batch[:, 1] + 1 # Calculate width of each bounding box + h = bboxes_batch[:, 4] - bboxes_batch[:, 2] + 1 # Calculate height of each bounding box + + sizes = np.stack([w, h, w, h], axis=-1) # Stack width and height to match bbox_offsets + bboxes_batch[:, 1:5] += bboxes_offsets * sizes # Apply offsets to the coordinates + + return bboxes_batch + + +def pick_matches(bboxes_batch, scores_column=-1, score_threshold=0.7): + """ + Filters bounding boxes based on the confidence score threshold. + + Only bounding boxes with a confidence score higher than the specified threshold are returned. + + Args: + bboxes_batch (np.ndarray): An array of bounding boxes of shape (n, m), where each row contains + bounding box coordinates and confidence scores. The confidence scores + are expected to be in the column specified by `scores_column`. + scores_column (int): The index of the column that contains the confidence scores. Default is -1 (last column). + score_threshold (float): The minimum confidence score threshold to select bounding boxes. + Default is 0.7. + + Returns: + np.ndarray: An array of bounding boxes that have confidence scores greater than `score_threshold`. + """ + return bboxes_batch[np.where(bboxes_batch[:, scores_column] > score_threshold)[0]] + + +def to_json(bboxes_batch, images_count, input_as_width_height=False, output_as_width_height=True): + """ + Converts a batch of bounding boxes and facial keypoints into a JSON-friendly format. + + This function processes the bounding boxes grouped by unique image IDs, and formats each bounding box + and its associated keypoints (facial landmarks) into a dictionary structure suitable for JSON serialization. + + Args: + bboxes_batch (np.ndarray): An array of shape (n, 16) where each row represents a bounding box + and associated keypoints in the following format: + [image_id, x1, y1, x2, y2, confidence, left_eye_x, left_eye_y, right_eye_x, + right_eye_y, nose_x, nose_y, mouth_left_x, mouth_left_y, mouth_right_x, mouth_right_y]. + images_count (int): Number of different images composed by the batch. + input_as_width_height (bool, optional): True if format of input bounding boxes is [x1, x2, width, height]. + False if format is [x1, y1, x2, y2]. + output_as_width_height (bool, optional): True to format bounding boxes as [x1, x2, width, height]. + False to format as [x1, y1, x2, y2]. + + Returns: + list: A list of lists, where each inner list contains dictionaries for bounding boxes and keypoints + for a specific image. Each dictionary has the following structure: + { + "box": [x, y, width, height], + "keypoints": { + "nose": [nose_x, nose_y], + "mouth_right": [mouth_right_x, mouth_right_y], + "right_eye": [right_eye_x, right_eye_y], + "left_eye": [left_eye_x, left_eye_y], + "mouth_left": [mouth_left_x, mouth_left_y] + }, + "confidence": confidence_score + } + """ + single_element = len(bboxes_batch.shape) == 1 + + if single_element: + bboxes_batch = np.expand_dims(bboxes_batch, axis=0) + + #unique_ids = np.unique(bboxes_batch[:, 0]) + + result_batch = [] + + # Loop over each unique image ID + for unique_id in range(images_count): + result = [] + bboxes_subset = bboxes_batch[bboxes_batch[:, 0] == unique_id] + + # Loop over each bounding box in the subset + for bbox in bboxes_subset: + row = { + "box": parse_bbox(bbox, + output_as_width_height=output_as_width_height, + input_as_width_height=input_as_width_height).tolist(), + "confidence": bbox[5] + } + result.append(row) + + # If the stages combination allows landmarks, then we append them. Otherwise we don't + try: + row["keypoints"] = parse_landmarks(bbox) + except IndexError: + pass + + result_batch.append(result) + + return result_batch + + +def limit_bboxes(bboxes_batch, images_shapes, limit_landmarks=True): + """ + Adjusts bounding boxes so that they fit within the boundaries of their corresponding images. + If any bounding box exceeds the image dimensions, it will be corrected to stay within the limits. + + Args: + bboxes_batch (np.ndarray): An array of bounding boxes of shape (n, 5), where each row + represents [batch_index, x1, y1, x2, y2]. + images_shapes (np.ndarray): A tensor of image shapes of shape (batch, 3), where each row + represents [width, height, channels] of each image in the batch. + limit_landmarks (bool): A flag to specify whether the limit should also apply to landmarks or not. + + Returns: + np.ndarray: The adjusted bounding boxes where no coordinate exceeds the image dimensions. + """ + bboxes_batch_fitted = bboxes_batch.copy() + + # Get the original shapes (height, width) for each image in the batch + expected_shapes = images_shapes[bboxes_batch_fitted[:, 0].astype(int)] + + # Adjust x1 and x2 to be within [0, width-1] + bboxes_batch_fitted[:, 1] = np.minimum(np.maximum(bboxes_batch_fitted[:, 1], 0), expected_shapes[:, 1] - 1) + bboxes_batch_fitted[:, 3] = np.minimum(np.maximum(bboxes_batch_fitted[:, 3], 0), expected_shapes[:, 1] - 1) + + # Adjust y1 and y2 to be within [0, height-1] + bboxes_batch_fitted[:, 2] = np.minimum(np.maximum(bboxes_batch_fitted[:, 2], 0), expected_shapes[:, 0] - 1) + bboxes_batch_fitted[:, 4] = np.minimum(np.maximum(bboxes_batch_fitted[:, 4], 0), expected_shapes[:, 0] - 1) + + if limit_landmarks: + # Adjust x1..x5 of the landmarks to not surpass boundaries + bboxes_batch_fitted[:, 6:11] = np.minimum(np.maximum(bboxes_batch_fitted[:, 6:11], 0), expected_shapes[:, 1:2] - 1) + + # Adjust y1..y5 of the landmarks to not surpass boundaries + bboxes_batch_fitted[:, 11:16] = np.minimum(np.maximum(bboxes_batch_fitted[:, 11:16], 0), expected_shapes[:, 0:1] - 1) + + return bboxes_batch_fitted + + +def parse_bbox(bbox, output_as_width_height=True, input_as_width_height=True): + """ + Parses a bounding box from different formats (dict, list, or ndarray) into a standardized format. + + Args: + bbox (dict, list, np.ndarray): Bounding box in one of the following formats: + - dict with key 'box': [x1, y1, x2, y2] + - list: [x1, y1, x2, y2] or [x1, y1, width, height] + - np.ndarray: Shape (4,) or (5,) where the first value might be an index. + output_as_width_height (bool): Whether to return the bounding box as [x1, y1, width, height] (default True) or [x1, y1, x2, y2] if False. + input_as_width_height (bool): Whether the input format of the bounding box is [x1, y1, width, height] (default True) or + [x1, y1, x2, y2] if False. + + + Returns: + np.ndarray: Parsed bounding box in format [x1, y1, width, height] or [x1, y1, x2, y2]. + """ + # Extract box if input is a dict + if isinstance(bbox, dict): + bbox = bbox['box'] + + # Parse list format + if isinstance(bbox, list): + x1, y1, width, height = bbox + + if not input_as_width_height: + width = width - x1 + height = height - y1 + + x2_or_w = width if output_as_width_height else x1 + width + y2_or_h = height if output_as_width_height else y1 + height + + return np.asarray([x1, y1, x2_or_w, y2_or_h]).round().astype(int) + + # Parse ndarray format + if isinstance(bbox, np.ndarray): + offset = 1 if bbox.shape[0] > 4 else 0 # Handle optional first element + + x1, y1, width, height = bbox[offset:offset+4] + + if not input_as_width_height: + width = width - x1 + height = height - y1 + + x2_or_w = width if output_as_width_height else x1 + width + y2_or_h = height if output_as_width_height else y1 + height + + return np.asarray([x1, y1, x2_or_w, y2_or_h]).round().astype(int) + + raise ValueError("Invalid bbox format. Expected dict, list, or ndarray.") + + +def fix_bboxes_offsets(bboxes_batch, pad_param): + """ + Adjusts the bounding boxes and landmarks by subtracting the corresponding padding offsets applied during image padding. + + This function corrects the bounding boxes' coordinates and facial landmarks after padding the images, ensuring that + the boxes and landmarks are aligned with the padded images by subtracting the appropriate offsets. + + Args: + bboxes_batch (np.ndarray): An array of bounding boxes and landmarks of shape (n, m), where each row represents + [image_id, x1, y1, x2, y2, confidence, landmark_x1, landmark_y1, ..., landmark_x5, landmark_y5]. + The first column (index 0) corresponds to the image ID. + pad_param (np.ndarray): An array of padding parameters of shape (n, 2, 2), where each entry represents the amount + of padding applied to each image along the width and height dimensions. + + Returns: + np.ndarray: A modified copy of `bboxes_batch` with updated bounding box and landmark coordinates adjusted for padding. + """ + bboxes_batch = bboxes_batch.copy() + images_ids = np.unique(bboxes_batch[:, 0]) # Get unique image IDs + + indexes_bbox_x = [1,3] + indexes_bbox_y = [2,4] + + indexes_landmarks_x = [6, 7, 8, 9, 10] + indexes_landmarks_y = [11, 12, 13, 14, 15] + + + # Adjust bounding boxes and landmarks for each image based on its padding parameters + for image_id, pad in zip(images_ids, pad_param): + selector = bboxes_batch[:, 0] == image_id + + # Adjust the x-coordinates of bounding boxes by subtracting width padding + bboxes_batch[np.ix_(selector, indexes_bbox_x)] -= pad[1, 0] + + # Adjust the y-coordinates of bounding boxes by subtracting height padding + bboxes_batch[np.ix_(selector, indexes_bbox_y)] -= pad[0, 0] + + # If stages combinations contain landmarks, we adjust them too + try: + # Adjust the x-coordinates of landmarks by subtracting width padding + bboxes_batch[np.ix_(selector, indexes_landmarks_x)] -= pad[1, 0] + + # Adjust the y-coordinates of landmarks by subtracting height padding + bboxes_batch[np.ix_(selector, indexes_landmarks_y)] -= pad[0, 0] + + except IndexError: + pass + + + return bboxes_batch diff --git a/mtcnn/utils/images.py b/mtcnn/utils/images.py new file mode 100644 index 0000000..ffd36f2 --- /dev/null +++ b/mtcnn/utils/images.py @@ -0,0 +1,404 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import tensorflow as tf +import numpy as np + +from tensorflow.python.framework.errors_impl import NotFoundError + + +def build_scale_pyramid(width, height, min_face_size, scale_factor, min_size=12): + """ + Builds a scale pyramid for detecting objects (e.g., faces) at different sizes in an image. + + Args: + width (int): The width of the input image, in pixels. + height (int): The height of the input image, in pixels. + min_face_size (int): The minimum size (in pixels) of the object (e.g., face) that should be detectable. + scale_factor (float): The factor by which the image is downscaled at each level (e.g., 0.7 means 70% of the previous scale). + min_size (int, optional): The smallest size (in pixels) to which the image can be downscaled. Default is 12 pixels. + + Returns: + np.ndarray: Array of scales to apply to the image at each level of the pyramid. + """ + + # Find the smallest dimension of the image + min_dim = min(width, height) + + # Calculate how many scales are needed based on the smallest dimension and the scale factor + scales_count = round(-((np.log(min_dim / min_size) / np.log(scale_factor)) + 1)) + + # Calculate the base scale value (based on the smallest detectable face size) + m = min_size / min_face_size + + # Generate an array of scales for the pyramid + return m * scale_factor ** np.arange(scales_count) + + +def scale_images(images, scale: float=None, new_shape: tuple=None): + """ + Scales the input images either by a given factor or to a specified new shape. + + Args: + images (np.ndarray or tf.Tensor): A batch of images or a single image. The expected input should have + the shape (..., height, width, channels), where the last three dimensions + represent the height, width, and color channels of the images. + scale (float, optional): A scaling factor to resize the images. For example, a value of 0.5 will reduce + the image to 50% of its original size, while 2.0 will double its size. + This parameter is ignored if `new_shape` is provided. + new_shape (tuple, optional): A tuple specifying the new shape (height, width) to resize the images to. + If provided, this will override the scaling factor. + + Returns: + tf.Tensor: The scaled images as a tensor with resized dimensions, determined either by the scaling factor + or the new shape provided. + """ + + # Extract the shape from the images + shape = np.asarray(images.shape[-3:-1]) + + if scale is None and new_shape is None: + new_shape = shape + + new_shape = shape * scale if new_shape is None else new_shape + + # Resize the images using the specified scaling factor + images_scaled = tf.image.resize(images, new_shape, method=tf.image.ResizeMethod.AREA) + + return images_scaled + + +def normalize_images(images): + """ + Normalizes the input images to the range [-1, 1]. + + Args: + images (np.ndarray or tf.Tensor): A batch of images or a single image. The expected input should have + pixel values in the range [0, 255]. + + Returns: + np.ndarray or tf.Tensor: The normalized images, where pixel values are rescaled to the range [-1, 1]. + """ + # Normalize the images to the range [-1, 1] + return (images - 127.5) / 128 + + +def pad_stack_np(images, justification="center"): + """ + Pads and stacks a list of images to ensure they all have the same size, based on the specified justification. + + Args: + images (list of np.ndarray): A list of images with varying shapes. Each image is expected to be a NumPy array. + justification (str, optional): Specifies the justification (alignment) for padding. + Available options are: "center", "top", "topleft", "topright", + "bottom", "bottomleft", "bottomright", "left", "right". + Default is "center". + + Returns: + np.ndarray: A stacked NumPy array where all images have been padded to the same size, based on the chosen justification. + np.ndarray: A stacked NumPy array of each original shape. + np.ndarray: A NumPy array containing the padding parameters applied to each image. + """ + + # Stack the shapes of all images into an array + sizes_stack = np.stack([img.shape for img in images], axis=0) + + # Find the maximum shape along each dimension + sizes_max = sizes_stack.max(axis=0, keepdims=True) + + # Calculate the difference in size for padding + sizes_diff = sizes_max - sizes_stack + + # Calculate if any padding size is odd, to adjust padding + sizes_mod = sizes_diff % 2 + sizes_diff = sizes_diff - sizes_mod + + # Justification masks for padding alignment + justification_mask = { + "top": np.asarray([[[0, 1], [0.5, 0.5], [0, 0]]]), + "topleft": np.asarray([[[0, 1], [0, 1], [0, 0]]]), + "topright": np.asarray([[[0, 1], [1, 0], [0, 0]]]), + "bottom": np.asarray([[[1, 0], [0.5, 0.5], [0, 0]]]), + "bottomleft": np.asarray([[[1, 0], [0, 1], [0, 0]]]), + "bottomright": np.asarray([[[1, 0], [1, 0], [0, 0]]]), + "left": np.asarray([[[0.5, 0.5], [0, 1], [0, 0]]]), + "right": np.asarray([[[0.5, 0.5], [1, 0], [0, 0]]]), + "center": np.asarray([[[0.5, 0.5], [0.5, 0.5], [0, 0]]]), + } + + # Justification adjustments for padding if needed + justification_pad_mask = { + "top": "topleft", + "bottom": "bottomleft", + "left": "topleft", + "right": "topright", + "center": "topleft" + } + + # Get the correct padding mask based on justification + pad_mask = justification_mask[justification] + mod_mask = justification_mask[justification_pad_mask.get(justification, justification)] + + # Calculate the exact padding parameters + pad_param = (pad_mask * sizes_diff[:,:,None] + mod_mask * sizes_mod[:,:,None]).astype(int) + + # Apply the calculated padding to each image and stack them into a single array + images_padded = np.stack([np.pad(img, pad) for img, pad in zip(images, pad_param)], axis=0) + + # We keep the original faces to return as extra info + original_shapes = np.stack([img.shape for img in images], axis=0) + + return images_padded, original_shapes, pad_param + + +def pad_stack_tf(images, justification="center"): + """ + Pads and stacks a list of images to ensure they all have the same size, based on the specified justification. + + Args: + images (list of tf.Tensor): A list of images with varying shapes. Each image is expected to be a TensorFlow tensor. + justification (str, optional): Specifies the justification (alignment) for padding. + Available options are: "center", "top", "topleft", "topright", + "bottom", "bottomleft", "bottomright", "left", "right". + Default is "center". + + Returns: + tf.Tensor: A stacked TensorFlow tensor where all images have been padded to the same size, based on the chosen justification. + tf.Tensor: A TensorFlow tensor of the original shapes of each image, for reference. + tf.Tensor: A TensorFlow tensor containing the padding parameters applied to each image. + """ + # Stack the shapes of all images into a tensor + sizes_stack = tf.stack([tf.shape(img) for img in images], axis=0) + + # Find the maximum shape along each dimension + sizes_max = tf.reduce_max(sizes_stack, axis=0, keepdims=True) + + # Calculate the difference in size for padding + sizes_diff = sizes_max - sizes_stack + + # Calculate if any padding size is odd, to adjust padding + sizes_mod = tf.cast(sizes_diff % 2, tf.float32) + sizes_diff = tf.cast(sizes_diff, tf.float32) - sizes_mod + + # Justification masks for padding alignment + justification_mask = { + "top": tf.constant([[[0, 1.], [0.5, 0.5], [0, 0]]]), + "topleft": tf.constant([[[0, 1.], [0, 1.], [0, 0]]]), + "topright": tf.constant([[[0, 1.], [1., 0], [0, 0]]]), + "bottom": tf.constant([[[1., 0], [0.5, 0.5], [0, 0]]]), + "bottomleft": tf.constant([[[1., 0], [0, 1.], [0, 0]]]), + "bottomright": tf.constant([[[1., 0], [1., 0], [0, 0]]]), + "left": tf.constant([[[0.5, 0.5], [0, 1.], [0, 0]]]), + "right": tf.constant([[[0.5, 0.5], [1., 0], [0, 0]]]), + "center": tf.constant([[[0.5, 0.5], [0.5, 0.5], [0, 0]]]), + } + + # Justification adjustments for padding if needed + justification_pad_mask = { + "top": "topleft", + "bottom": "bottomleft", + "left": "topleft", + "right": "topright", + "center": "topleft" + } + + # Get the correct padding mask based on justification + pad_mask = justification_mask[justification] + mod_mask = justification_mask[justification_pad_mask.get(justification, justification)] + + # Calculate the exact padding parameters + pad_param = (pad_mask * sizes_diff[:,:,None] + mod_mask * sizes_mod[:,:,None]) + pad_param = tf.cast(pad_param, tf.int32) + + # Apply the calculated padding to each image and stack them into a single tensor + images_padded = tf.stack([tf.pad(img, paddings=pad) for img, pad in zip(images, pad_param)], axis=0) + + # We keep the original faces to return as extra info + original_shapes = tf.stack([tf.shape(img) for img in images], axis=0) + + return images_padded, original_shapes, pad_param + + +def ensure_stack(images): + """ + Ensures that the input is a properly stacked array of images. + This function should be called to format the input for a given model. + + Args: + images (list or np.ndarray): A list of images or a NumPy array of images. + If it's a list, images will be padded and stacked. + If it is a single image, the image's dimension will be expanded as + if it were a list of a single image. + + Returns: + np.ndarray: A properly stacked array of images, ensuring they have the same shape. + """ + + # If images is a list, pad and stack them + if isinstance(images, list): + images = pad_stack_np(images) + + # Broadcast to ensure the images have a consistent shape (batch dimension) + return np.broadcast_to(images, + [(len(images.shape) < 4) + (len(images.shape) >= 4) * images.shape[0],] + list(images.shape[len(images.shape) >= 4:])) + + +def load_image(image, dtype=tf.float32, device="CPU:0"): + """ + Loads an image and decodes it into a TensorFlow tensor, optionally normalizing it. + + Args: + image (str, np.ndarray, or tf.Tensor): The input image. It can be: + - A file path to the image as a string. + - A TensorFlow tensor or a NumPy array representing an image. + dtype (tf.DType, optional): The desired data type for the decoded image. Default is tf.float32. + device (str, optional): the target device for the operation. Using CPU most of the times should be fine. + + Returns: + tf.Tensor: The decoded image tensor, with shape (height, width, channels) and dtype `dtype`. If + `normalize=True`, the image values will be scaled to the range [0, 1]. + """ + + with tf.device(device): + is_tensor = tf.is_tensor(image) or isinstance(image, np.ndarray) + + if is_tensor: + decoded_image = image + else: + try: + if isinstance(image, str): + image_data = tf.io.read_file(image) # Read image from file + else: + image_data = image # Assume image data is provided directly + except NotFoundError: + image_data = image # If file not found, use the input directly + + # Decode the image with 3 channels (RGB) + decoded_image = tf.image.decode_image(image_data, channels=3, dtype=dtype).numpy() + + # If dtype is float, adjust the image scale + if dtype in [tf.float16, tf.float32]: + decoded_image *= 255 # Convert pixel values to [0, 255] if using float data type + + return decoded_image + + +def load_images_batch(images, dtype=tf.float32, device="CPU:0"): + """ + Loads a batch of images into memory. If the images are not already in tensor or NumPy array format, + they are loaded from their file paths. + + Args: + images (list of str, np.ndarray, or tf.Tensor): A list of images, where each image can either be + a TensorFlow tensor, NumPy array, or a file path (string). + dtype (tf.DType, optional): The data type for the loaded images. Default is tf.float32. + device (str, optional): the target device for the operation. Using CPU most of the times should be fine. + + Returns: + list of tf.Tensor: A list of TensorFlow tensors representing the raw images. + """ + is_tensor = tf.is_tensor(images[0]) or isinstance(images[0], np.ndarray) + images_raw = images if is_tensor else [load_image(img, dtype=dtype, device=device) for img in images] + return images_raw + + +def standarize_batch(images_raw, normalize=True, justification="center"): + """ + Pads and stacks a batch of images to ensure they all have the same size, with an option to normalize them. + + Args: + images_raw (list of tf.Tensor or np.ndarray): A list of raw images, each either as a TensorFlow tensor or + a NumPy array. + normalize (bool, optional): Whether to normalize the images after stacking. Default is True. + justification (str, optional): The alignment for padding the images. Available options are: "center", + "top", "topleft", "topright", "bottom", "bottomleft", "bottomright", + "left", "right". Default is "center". + + Returns: + np.ndarray: A stacked array of images, padded to the same shape based on the chosen justification. + np.ndarray: An array containing the original shapes of each image before padding. + np.ndarray: The padding parameters applied to each image. + """ + images_result, images_oshapes, pad_param = pad_stack_np(images_raw, justification=justification) + + if normalize: + images_result = normalize_images(images_result) + + return images_result, images_oshapes, pad_param + + +def apply_scales(images_normalized, scales_groups): + """ + Applies scales to the normalized images based on the largest group of scales. + + Args: + images_normalized (np.ndarray): A normalized image or batch of images. + scales_groups (list of np.ndarray): A list of different scale groups, where each group contains multiple possible scales. + + Returns: + tuple: + - list of np.ndarray: A list of images scaled according to the largest group of scales. + - np.ndarray: The largest group of scales that was applied to the images. + """ + # Select the scale group with the largest number of elements + selected_scaleset_as_index = np.argmax([x.shape[0] for x in scales_groups]) + largest_scale_group_set = scales_groups[selected_scaleset_as_index] + + # Apply the scales from the largest scale group to the normalized images + result = [scale_images(images_normalized, scale) for scale in largest_scale_group_set] + + return result, largest_scale_group_set + + +def extract_patches(images_normalized, bboxes_batch, expected_size=(24, 24)): + """ + Extracts patches from a batch of normalized images based on bounding boxes, and resizes each patch to a specified size. + + Args: + images_normalized (tf.Tensor): A batch of images or a single image, normalized, with the shape (batch_size, height, width, channels). + bboxes_batch (np.ndarray): An array of bounding boxes of shape (n, 5), where each row represents + [batch_index, x1, y1, x2, y2]. The coordinates are in pixel format, and the first + column indicates the image index in the batch. + expected_size (tuple, optional): A tuple specifying the size (height, width) to resize each extracted patch. + Defaults to (24, 24). + + Returns: + tf.Tensor: A tensor of extracted patches with shape (n, height, width, channels), where each patch corresponds + to a bounding box in `bboxes_batch`, resized to `expected_size`. + """ + # Get the shape of the input images + shape = images_normalized.shape + + # Normalize the bounding box coordinates to be within [0, 1] relative to image dimensions + selector = [2, 1, 4, 3] + + bboxes_batch_coords = bboxes_batch[:, selector] / np.asarray([[shape[selector[1]], shape[selector[0]], shape[selector[1]], shape[selector[0]]]]) + + # Extract patches from the images using the bounding boxes, resizing them to `expected_size` + result = tf.image.crop_and_resize( + images_normalized, # Input image tensor + bboxes_batch_coords, # Bounding boxes in format [y1, x1, y2, x2], normalized to [0.0, 1.0] + bboxes_batch[:, 0].astype(int), # Indices of the images in the batch corresponding to the bounding boxes + expected_size # Size to resize the cropped patches (height, width) + ) + + return result diff --git a/mtcnn/utils/landmarks.py b/mtcnn/utils/landmarks.py new file mode 100644 index 0000000..9af0539 --- /dev/null +++ b/mtcnn/utils/landmarks.py @@ -0,0 +1,92 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import numpy as np + + +def adjust_landmarks(face_landmarks, bboxes_batch): + """ + Adjusts face landmark coordinates to align them with the corresponding bounding boxes. + + The face landmarks are scaled and shifted based on the width and height of the bounding boxes + to ensure that they are correctly aligned with the face locations. + + Args: + face_landmarks (np.ndarray or tf.Tensor): An array of shape (n, 10) where each row represents + the normalized coordinates of 5 facial landmarks + (x1, x2, x3, x4, x5, y1, y2, y3, y4, y5). These + coordinates are normalized between 0 and 1. + bboxes_batch (np.ndarray): An array of bounding boxes of shape (n, m), where each row contains + the bounding box coordinates [x1, y1, x2, y2] and possibly additional + columns (e.g., image id, confidence score). + + Returns: + np.ndarray: The adjusted face landmark coordinates, now scaled and positioned relative to the + corresponding bounding boxes. + """ + # Convert face_landmarks to a NumPy array and make a copy + face_landmarks = face_landmarks.numpy().copy() + + # Compute the width and height of each bounding box + w = bboxes_batch[:, 3:4] - bboxes_batch[:, 1:2] + 1 # Width + h = bboxes_batch[:, 4:5] - bboxes_batch[:, 2:3] + 1 # Height + + # Adjust the x-coordinates of the landmarks + face_landmarks[:, 0:5] = w * face_landmarks[:, 0:5] + bboxes_batch[:, 1:2] - 1 + # Adjust the y-coordinates of the landmarks + face_landmarks[:, 5:10] = h * face_landmarks[:, 5:10] + bboxes_batch[:, 2:3] - 1 + + return face_landmarks + + +def parse_landmarks(landmarks): + """ + Parses facial landmarks from different input formats (dict or np.ndarray) into a standardized format. + + The landmarks can be provided as a dictionary or an ndarray. If a dictionary is used, it should contain + a 'keypoints' field. If an ndarray is used, it should contain either 10 or 16 values depending on the + number of keypoints and format. + + Args: + landmarks (dict or np.ndarray): Facial landmarks, either as a dictionary with key 'keypoints' or + as a numpy array of shape (10,) or (16,). + + Returns: + dict: A dictionary containing the facial landmarks with keys: 'nose', 'mouth_right', 'right_eye', + 'left_eye', 'mouth_left'. Each key corresponds to the (x, y) coordinates of that keypoint. + """ + if isinstance(landmarks, dict): + if 'keypoints' in landmarks: + landmarks = landmarks['keypoints'] # Extract 'keypoints' from dict + + if isinstance(landmarks, np.ndarray): + offset = 0 if landmarks.shape[0] == 10 else 6 # Handle different landmark formats + landmarks = landmarks.round().astype(int) # Round coordinates and convert to integers + landmarks = { + "nose": [landmarks[offset+2], landmarks[offset+7]], + "mouth_right": [landmarks[offset+4], landmarks[offset+9]], + "right_eye": [landmarks[offset+1], landmarks[offset+6]], + "left_eye": [landmarks[offset+0], landmarks[offset+5]], + "mouth_left": [landmarks[offset+3], landmarks[offset+8]] + } + + return landmarks diff --git a/mtcnn/utils/plotting.py b/mtcnn/utils/plotting.py new file mode 100644 index 0000000..3dc6f49 --- /dev/null +++ b/mtcnn/utils/plotting.py @@ -0,0 +1,173 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import numpy as np + +from .bboxes import parse_bbox +from .landmarks import parse_landmarks + + +def plot_bbox(image, bbox, color="#FFFF00", normalize_color=False, input_as_width_height=True): + """ + Draws a bounding box on the given image. + + Args: + image (np.ndarray): The input image on which to draw the bounding box. + bbox (list, dict, or np.ndarray): The bounding box coordinates in one of the following formats: + - List or array [x1, y1, x2, y2]. + - Dict with a key 'box' that contains the bounding box. + color (str): The color of the bounding box in hex format (default is yellow, "#FFFF00"). + normalize_color (bool): True if color should be in [0..1]. False to make it between [0..255] + input_as_width_height (bool): True if input `bbox` parameter follows format [x1, y1, width, height]. False if follows format [x1, y1, x2, y2] + Returns: + np.ndarray: The image with the bounding box drawn. + """ + color = parse_color(color) # Convert color to RGB + color = color if normalize_color else (color * 255).astype(np.uint8) + + # Parse the bounding box coordinates + bbox = parse_bbox(bbox, input_as_width_height=input_as_width_height, output_as_width_height=False) + + image = image.copy() # Copy the image to avoid modifying the original + + # Draw the vertical sides of the box (left and right) + image[bbox[1]:bbox[3], bbox[0], :] = color # Left side + image[bbox[1]:bbox[3], bbox[2], :] = color # Right side + + # Draw the horizontal sides of the box (top and bottom) + image[bbox[1], bbox[0]:bbox[2], :] = color # Top side + image[bbox[3], bbox[0]:bbox[2], :] = color # Bottom side + + result = image if normalize_color else image.astype(np.uint8) + return result + + +def plot_landmarks(image, landmarks, color="#FFFF00", keypoints="nose,mouth_right,right_eye,left_eye,mouth_left", + brush_size=2, normalize_color=False): + """ + Plots facial landmarks on the given image. + + Args: + image (np.ndarray): The input image on which to draw the landmarks. + landmarks (dict or np.ndarray): The facial landmarks to plot, either as a dictionary or an array. + color (str): The color of the landmarks in hex format (default is yellow, "#FFFF00"). + keypoints (str): A comma-separated list of keypoints to plot (default includes all facial landmarks). + brush_size (int): The size of the brush used to draw the keypoints (default is 2). + normalize_color (bool): True if color should be in [0..1]. False to make it between [0..255] + + Returns: + np.ndarray: The image with the landmarks drawn. + """ + keypoints = [k.strip() for k in keypoints.split(",")] # Parse the keypoints list + color = parse_color(color) # Convert color to RGB + color = color if normalize_color else (color * 255).astype(np.uint8) + + try: + landmarks = parse_landmarks(landmarks) # Parse the landmarks + + except IndexError: # No landmarks available + return image + + image = image.copy() # Copy the image to avoid modifying the original + + # Draw each landmark as a small circle + for key in keypoints: + if key in landmarks: + x, y = landmarks[key] + image[y-brush_size:y+brush_size+1, x-brush_size:x+brush_size+1, :] = color # Draw the landmark + + result = image if normalize_color else image.astype(np.uint8) + return result + + +def plot(image, detection, input_as_width_height=True): + """ + Plots a single or multiple facial detection results on the given image. + + Args: + image (np.ndarray): The input image on which to draw the detections. + detection (list, dict, or np.ndarray): A single detection or a list/array of detections to plot. + Each detection contains facial landmarks and/or bounding box information. + input_as_width_height (bool): Whether the input bounding box format is (width, height) instead of + the default (x1, y1, x2, y2) (default is True). + + Returns: + np.ndarray or None: The image with the detection(s) plotted, or None if no detection is present. + """ + if len(detection) == 0: + return None + + if isinstance(detection, list) or (isinstance(detection, np.ndarray) and len(detection.shape) > 1): + return plot_all(image, detection, input_as_width_height=input_as_width_height) + + return plot_landmarks(plot_bbox(image, detection, input_as_width_height=input_as_width_height), detection) + + +def plot_all(image, detections, input_as_width_height=True): + """ + Plots multiple facial detection results on the given image. + + Args: + image (np.ndarray): The input image on which to draw the detections. + detections (list or np.ndarray): A list or array of detections, where each detection contains + facial landmarks and/or bounding box information. + input_as_width_height (bool): Whether the input bounding box format is (width, height) instead of + the default (x1, y1, x2, y2) (default is True). + + Returns: + np.ndarray: The image with all detections plotted. + """ + for detection in detections: + image = plot_landmarks(plot_bbox(image, detection, input_as_width_height=input_as_width_height), detection) + + return image + + +def parse_color(color): + """ + Parses a color from a string in various formats (e.g., hex, RGB) into a normalized RGB array. + + The color can be provided in the following formats: + * Hexadecimal string (e.g., "#RRGGBB" or "#RGB") + * Hexadecimal string with prefix "0x" (e.g., "0xRRGGBB") + + Args: + color (str): A color string in hex format (e.g., "#RRGGBB", "#RGB", "0xRRGGBB"). + + Returns: + np.ndarray: A numpy array of normalized RGB values (between 0 and 1) representing the color. + """ + if isinstance(color, str): + if color.startswith("#"): + color = color[1:] # Remove '#' prefix + if color.startswith("0x"): + color = color[2:] # Remove '0x' prefix + if len(color) == 3: # Short form hex color (#RGB) + color = np.asarray([int(f"{color[0]}{color[0]}", base=16), + int(f"{color[1]}{color[1]}", base=16), + int(f"{color[2]}{color[2]}", base=16)]) / 255 + if len(color) == 6: # Full form hex color (#RRGGBB) + color = np.asarray([int(f"{color[0]}{color[1]}", base=16), + int(f"{color[2]}{color[3]}", base=16), + int(f"{color[4]}{color[5]}", base=16)]) / 255 + + return color diff --git a/mtcnn/utils/tensorflow.py b/mtcnn/utils/tensorflow.py new file mode 100644 index 0000000..6df2b1e --- /dev/null +++ b/mtcnn/utils/tensorflow.py @@ -0,0 +1,80 @@ +# MIT License +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import os +import importlib + +import joblib + + +def load_weights(weights_name): + """ + Attempts to load weights from a user-provided file path or, if not found, from the package's assets. + + Args: + weights_name (str): The name of the weights file to load (can be a file path provided by the user + or just the name of the weights file for fallback). + + Returns: + The loaded weights if found, otherwise raises an exception. + """ + # Define possible paths: first check user-provided path, then fallback to package assets + paths = [ + os.path.abspath(weights_name), # Check if it's a user-provided file path + importlib.resources.files('mtcnn.assets.weights') / weights_name # Fallback to package's assets + ] + + # Try to load weights from the first valid path + for path in paths: + if os.path.exists(path): # First checks the local filesystem + return joblib.load(path) + + # If no file is found, raise an error + raise FileNotFoundError(f"Weights file '{weights_name}' not found in the system or in the package assets.") + + +def set_gpu_memory_growth(): + """ + Configures TensorFlow to allocate only the required amount of GPU memory instead of + allocating all available GPU memory at once. The memory usage will grow dynamically + as needed during model execution. + + This should be called before any TensorFlow or Keras operations are initialized to + ensure proper memory management. + + Raises: + RuntimeError: If the GPUs have already been initialized or if memory growth cannot be set. + """ + import tensorflow as tf + + # List available GPUs + gpus = tf.config.experimental.list_physical_devices('GPU') + + if gpus: + try: + # Set memory growth for each GPU + for gpu in gpus: + tf.config.experimental.set_memory_growth(gpu, True) + + except RuntimeError as e: + # Error occurs if GPUs have already been initialized + print(f"Error setting memory growth: {e}") diff --git a/notebooks/onet_ablation.ipynb b/notebooks/onet_ablation.ipynb new file mode 100644 index 0000000..1f7d9a5 --- /dev/null +++ b/notebooks/onet_ablation.ipynb @@ -0,0 +1,484 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "78ccfbad-54da-4945-b4a3-45b0eb9fc364", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"..\")" + ] + }, + { + "cell_type": "markdown", + "id": "6e7e7c7d-0cf2-48fc-a6e6-fba3d6a647f2", + "metadata": {}, + "source": [ + "# MTCNN ONet\n", + "\n", + "This notebook demonstrates the ONet architecture and its corresponding weights.\n", + "\n", + "ONet is a fully convolutional neural network (CNN) used in the third and final stage of MTCNN. This network further refines the bounding box proposals generated by the previous RNet stage and adds facial landmark detection. It produces three outputs:\n", + "\n", + "* Regression of the bounding box coordinates to fine-tune the proposals.\n", + "* Classification of the proposals into two categories: no-face or face.\n", + "* Detection of five facial landmarks (eyes, nose, and mouth corners).\n", + "\n", + "The outputs are generated for each bounding box proposal, providing more precise detections and facial landmarks.\n", + "\n", + "In the following sections, we will run the MTCNN model, focusing solely on the ONet stage. We will examine the intermediate inputs, observe the output shapes, and visualize the results." + ] + }, + { + "cell_type": "markdown", + "id": "40cf365e-e8d3-481c-8b02-64b9cc6e7f8b", + "metadata": {}, + "source": [ + "## MTCNN on ONet Stage\n", + "\n", + "MTCNN can be configured to run up to the third stage, which will provide the direct output of the ONet stage, including refined bounding boxes and facial landmarks.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3431815e-6a07-4a8b-8a2d-d454d4a3a4b9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-07 10:22:05.056123: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-10-07 10:22:05.066533: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-07 10:22:05.078993: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-07 10:22:05.082641: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-07 10:22:05.092892: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-07 10:22:05.763878: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "from mtcnn import MTCNN\n", + "from mtcnn.utils.images import load_image\n", + "from mtcnn.stages import StagePNet, StageRNet, StageONet" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8f9b8423-64ec-4f23-91f7-9dcd85e85682", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-07 10:22:06.564155: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 46865 MB memory: -> device: 0, name: NVIDIA RTX A6000, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2024-10-07 10:22:06.564560: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 7527 MB memory: -> device: 1, name: NVIDIA GeForce GTX 1070, pci bus id: 0000:17:00.0, compute capability: 6.1\n" + ] + } + ], + "source": [ + "image = load_image(\"../resources/ivan.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "85710efe-fac4-472f-91b7-dceb211d9965", + "metadata": {}, + "outputs": [], + "source": [ + "# This is the default configuration of stages, aliased as \"face_and_landmarks_detection\"\n", + "mtcnn = MTCNN(stages=[StagePNet, StageRNet, StageONet], device=\"CPU:0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1516fdd4-794e-4e81-bcdd-6be6a45cb570", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 653 ms, sys: 230 ms, total: 883 ms\n", + "Wall time: 473 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "result = mtcnn.detect_faces(image, postprocess=True, threshold_onet=0.85)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "57c31ee3-ef28-4010-a903-38173ac9364a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'box': [276, 92, 50, 63],\n", + " 'confidence': 0.9999972581863403,\n", + " 'keypoints': {'nose': [304, 131],\n", + " 'mouth_right': [314, 141],\n", + " 'right_eye': [315, 114],\n", + " 'left_eye': [290, 116],\n", + " 'mouth_left': [297, 143]}}]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1e361a8b-ea17-41b3-950b-8a30c89040db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mtcnn.utils.plotting import plot\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.imshow(plot(image, result))" + ] + }, + { + "cell_type": "markdown", + "id": "820648d8-bc52-44c4-9000-12ebef684ffc", + "metadata": {}, + "source": [ + "As can be seen, the ONet is not only refining proposals by discarding those that do not match the thresholds and adjusting those that matched, but also proposing landmarks in the accepted bboxes." + ] + }, + { + "cell_type": "markdown", + "id": "b2f0227a-4437-4e07-8661-9239ae88988d", + "metadata": {}, + "source": [ + "### Accessing ONet's model\n", + "\n", + "The network can be accessed by instantiating StageRNet and reading the attribute `model`, which is a TensorFlow model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "85692cac-f01a-4e51-812d-6697c4b4eb95", + "metadata": {}, + "outputs": [], + "source": [ + "stage = StageONet()\n", + "model = stage.model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b5b0d71f-c4f4-4df2-89dd-66091cd3f9fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"o_net_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"o_net_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv1 (Conv2D)                  │ (None, 46, 46, 32)     │           896 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu1 (PReLU)                  │ (None, 46, 46, 32)     │            32 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling1 (MaxPooling2D)      │ (None, 23, 23, 32)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2 (Conv2D)                  │ (None, 21, 21, 64)     │        18,496 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu2 (PReLU)                  │ (None, 21, 21, 64)     │            64 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling2 (MaxPooling2D)      │ (None, 10, 10, 64)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv3 (Conv2D)                  │ (None, 8, 8, 64)       │        36,928 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu3 (PReLU)                  │ (None, 8, 8, 64)       │            64 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling3 (MaxPooling2D)      │ (None, 4, 4, 64)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv4 (Conv2D)                  │ (None, 3, 3, 128)      │        32,896 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu4 (PReLU)                  │ (None, 3, 3, 128)      │           128 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ permute (Permute)               │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten4 (Flatten)              │ (None, 1152)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc5 (Dense)                     │ (None, 256)            │       295,168 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu5 (PReLU)                  │ (None, 256)            │           256 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc6-1 (Dense)                   │ (None, 4)              │         1,028 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc6-2 (Dense)                   │ (None, 10)             │         2,570 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc6-3 (Dense)                   │ (None, 2)              │           514 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m896\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu1 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m32\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu2 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m36,928\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu3 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling3 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv4 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m32,896\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu4 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ permute (\u001b[38;5;33mPermute\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten4 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1152\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc5 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m295,168\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu5 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc6-1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m1,028\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc6-2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m2,570\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc6-3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m514\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 389,040 (1.48 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m389,040\u001b[0m (1.48 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 389,040 (1.48 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m389,040\u001b[0m (1.48 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "c6719b2c-432a-498e-ada7-c9ea962a93c7", + "metadata": {}, + "source": [ + "### Loading ONet's weights\n", + "\n", + "The model weights are stored within the folder local `mtcnn/assets/weights/` under the filename `onet.lz4`. It can be loaded with `joblib`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cfe6688e-1bc8-46ad-920a-7c338419e4a2", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "onet_weights = joblib.load(\"../mtcnn/assets/weights/onet.lz4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "79400bef-8b41-481a-b375-3179732f8263", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "21" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(onet_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "27d8782a-4dfd-4bde-8006-51b9124fda9e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(3, 3, 3, 32),\n", + " (32,),\n", + " (1, 1, 32),\n", + " (3, 3, 32, 64),\n", + " (64,),\n", + " (1, 1, 64),\n", + " (3, 3, 64, 64),\n", + " (64,),\n", + " (1, 1, 64),\n", + " (2, 2, 64, 128),\n", + " (128,),\n", + " (1, 1, 128),\n", + " (1152, 256),\n", + " (256,),\n", + " (256,),\n", + " (256, 4),\n", + " (4,),\n", + " (256, 10),\n", + " (10,),\n", + " (256, 2),\n", + " (2,)]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[w.shape for w in onet_weights]" + ] + }, + { + "cell_type": "markdown", + "id": "14a82ac3-d289-4cbb-9cc4-58603dc6c543", + "metadata": {}, + "source": [ + "Further stage ablation can be performed by looking at `mtcnn/stages/stage_onet.py`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f96a7b5-f738-4b04-afcc-025129b14ca0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (mamba3.11)", + "language": "python", + "name": "mamba3.11" + }, + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/pnet_ablation.ipynb b/notebooks/pnet_ablation.ipynb new file mode 100644 index 0000000..c3abec7 --- /dev/null +++ b/notebooks/pnet_ablation.ipynb @@ -0,0 +1,642 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d5a329e6-de92-4f55-bd24-ed7eddacf86c", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"..\")" + ] + }, + { + "cell_type": "markdown", + "id": "3036aa7d-338b-4bfb-b3ce-8f846b884c5c", + "metadata": {}, + "source": [ + "# MTCNN PNet\n", + "\n", + "This notebook demonstrates the PNet architecture and its corresponding weights.\n", + "\n", + "PNet is a fully convolutional neural network (CNN) used in the first stage of MTCNN. This network processes inputs of variable size and generates bounding box proposals. It produces two outputs:\n", + "\n", + "* Regression of the bounding box coordinates within the convolutional receptive field.\n", + "* Classification of the receptive field into two categories: no-face or face.\n", + "\n", + "The outputs are generated for each receptive field, meaning that with every convolutional pass, a corresponding output is produced.\n", + "\n", + "In the following sections, we will run the MTCNN model, focusing solely on the PNet stage. We will examine the intermediate inputs, observe the output shapes, and visualize the results." + ] + }, + { + "cell_type": "markdown", + "id": "371e7036-e5fa-4be6-a684-a44b108abb87", + "metadata": {}, + "source": [ + "## MTCNN on PNet Stage\n", + "\n", + "MTCNN can be configured to run only up to the first stage, which will provide the direct output of the PNet stage." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d04a7b43-d6e1-4a9e-9d7f-2db3068a0ff3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-03 01:12:14.796761: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-10-03 01:12:14.807198: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-03 01:12:14.820051: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-03 01:12:14.823925: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-03 01:12:14.833451: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-03 01:12:15.534870: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "from mtcnn import MTCNN\n", + "from mtcnn.utils.images import load_image\n", + "from mtcnn.utils.tensorflow import set_gpu_memory_growth\n", + "from mtcnn.stages import StagePNet" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f62dad3d-2a1c-4d66-90ce-ce486b430752", + "metadata": {}, + "outputs": [], + "source": [ + "# To avoid using excessive GPU memory (In case of using GPU)\n", + "set_gpu_memory_growth()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "82387e10-293f-44d2-b1f3-108018f5d41d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-03 01:12:16.346034: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1312 MB memory: -> device: 0, name: NVIDIA RTX A6000, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2024-10-03 01:12:16.346452: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 7363 MB memory: -> device: 1, name: NVIDIA GeForce GTX 1070, pci bus id: 0000:17:00.0, compute capability: 6.1\n" + ] + } + ], + "source": [ + "image = load_image(\"../resources/ivan.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c80dcac6-ddbf-4a3c-b896-61fa81f7f558", + "metadata": {}, + "outputs": [], + "source": [ + "mtcnn = MTCNN(stages=[StagePNet], device=\"CPU:0\") # other devices: GPU:0 , GPU:1 , ..." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "36b38d7a-6241-467a-b09a-5ce9dac91d23", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 440 ms, sys: 92.9 ms, total: 533 ms\n", + "Wall time: 311 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "result = mtcnn.detect_faces(image, postprocess=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6b77291f-c123-4a81-aa18-3da6d9b5f190", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'box': [270, 89, 61, 61], 'confidence': 0.9999668598175049},\n", + " {'box': [271, 89, 71, 71], 'confidence': 0.9997212290763855},\n", + " {'box': [490, 209, 54, 54], 'confidence': 0.9992153644561768},\n", + " {'box': [187, 243, 38, 38], 'confidence': 0.998630166053772},\n", + " {'box': [480, 285, 57, 57], 'confidence': 0.9982782602310181},\n", + " {'box': [296, 100, 32, 32], 'confidence': 0.9957242012023926},\n", + " {'box': [192, 43, 108, 108], 'confidence': 0.9916715025901794},\n", + " {'box': [101, 408, 42, 42], 'confidence': 0.9912404417991638},\n", + " {'box': [97, 405, 52, 52], 'confidence': 0.9852192401885986},\n", + " {'box': [11, 180, 43, 43], 'confidence': 0.9849668145179749},\n", + " {'box': [8, 386, 31, 31], 'confidence': 0.9844192862510681},\n", + " {'box': [394, 399, 48, 48], 'confidence': 0.9816769361495972},\n", + " {'box': [14, 313, 40, 40], 'confidence': 0.9804034233093262},\n", + " {'box': [184, 59, 18, 18], 'confidence': 0.9791208505630493},\n", + " {'box': [495, 143, 58, 58], 'confidence': 0.9790045022964478},\n", + " {'box': [286, 218, 62, 62], 'confidence': 0.9768547415733337},\n", + " {'box': [344, 132, 20, 20], 'confidence': 0.9743143916130066},\n", + " {'box': [403, 394, 41, 41], 'confidence': 0.9722734093666077},\n", + " {'box': [180, 241, 46, 46], 'confidence': 0.9710206985473633},\n", + " {'box': [496, 214, 41, 41], 'confidence': 0.9705135822296143},\n", + " {'box': [275, 104, 30, 30], 'confidence': 0.9698752164840698},\n", + " {'box': [144, 391, 78, 78], 'confidence': 0.9693538546562195},\n", + " {'box': [4, 176, 54, 54], 'confidence': 0.9685015082359314},\n", + " {'box': [187, 140, 40, 40], 'confidence': 0.9677426218986511},\n", + " {'box': [283, 99, 45, 45], 'confidence': 0.967420756816864},\n", + " {'box': [534, 382, 20, 20], 'confidence': 0.9653154611587524},\n", + " {'box': [271, 99, 45, 45], 'confidence': 0.9631991386413574},\n", + " {'box': [101, 509, 17, 17], 'confidence': 0.9630200862884521},\n", + " {'box': [499, 289, 39, 39], 'confidence': 0.961385190486908},\n", + " {'box': [290, 124, 32, 32], 'confidence': 0.9606941938400269},\n", + " {'box': [334, 128, 28, 28], 'confidence': 0.9601700305938721},\n", + " {'box': [250, 104, 21, 21], 'confidence': 0.9600563049316406},\n", + " {'box': [182, 98, 19, 19], 'confidence': 0.9569499492645264},\n", + " {'box': [338, 152, 19, 19], 'confidence': 0.9563547968864441},\n", + " {'box': [8, 235, 58, 58], 'confidence': 0.9557236433029175},\n", + " {'box': [1, 386, 40, 40], 'confidence': 0.9545572400093079},\n", + " {'box': [513, 371, 39, 39], 'confidence': 0.9491947293281555},\n", + " {'box': [322, 191, 27, 27], 'confidence': 0.9456313848495483},\n", + " {'box': [470, 50, 53, 53], 'confidence': 0.9440603852272034},\n", + " {'box': [100, 411, 30, 30], 'confidence': 0.9404458999633789},\n", + " {'box': [31, 341, 32, 32], 'confidence': 0.937527060508728},\n", + " {'box': [323, 188, 20, 20], 'confidence': 0.9356555938720703},\n", + " {'box': [489, 434, 29, 29], 'confidence': 0.9347164630889893},\n", + " {'box': [355, 260, 18, 18], 'confidence': 0.9298021197319031},\n", + " {'box': [1, 396, 21, 21], 'confidence': 0.9291993975639343},\n", + " {'box': [270, 56, 147, 147], 'confidence': 0.9255051016807556},\n", + " {'box': [476, 270, 73, 73], 'confidence': 0.924798309803009},\n", + " {'box': [506, 294, 22, 22], 'confidence': 0.9207442402839661},\n", + " {'box': [73, 58, 225, 225], 'confidence': 0.9173569083213806},\n", + " {'box': [262, 71, 101, 101], 'confidence': 0.9164451956748962},\n", + " {'box': [13, 72, 31, 31], 'confidence': 0.9129998683929443},\n", + " {'box': [26, 340, 39, 39], 'confidence': 0.9100756049156189},\n", + " {'box': [239, 97, 31, 31], 'confidence': 0.9052125215530396},\n", + " {'box': [148, 405, 36, 36], 'confidence': 0.8971834778785706},\n", + " {'box': [445, 379, 43, 43], 'confidence': 0.8947854042053223},\n", + " {'box': [446, 215, 22, 22], 'confidence': 0.8917657136917114},\n", + " {'box': [239, 233, 81, 81], 'confidence': 0.8911052346229553},\n", + " {'box': [220, 287, 20, 20], 'confidence': 0.8855998516082764},\n", + " {'box': [36, 341, 24, 24], 'confidence': 0.8843594193458557},\n", + " {'box': [481, 198, 76, 76], 'confidence': 0.8838769197463989},\n", + " {'box': [17, 390, 21, 21], 'confidence': 0.8799570202827454},\n", + " {'box': [4, 303, 55, 55], 'confidence': 0.8785687685012817},\n", + " {'box': [430, 217, 19, 19], 'confidence': 0.8763736486434937},\n", + " {'box': [206, 79, 23, 23], 'confidence': 0.8737393617630005},\n", + " {'box': [7, 73, 42, 42], 'confidence': 0.8733800053596497},\n", + " {'box': [174, 127, 72, 72], 'confidence': 0.8731698393821716},\n", + " {'box': [280, 106, 22, 22], 'confidence': 0.8657463192939758},\n", + " {'box': [523, 456, 21, 21], 'confidence': 0.8632909059524536},\n", + " {'box': [62, 349, 28, 28], 'confidence': 0.8600795865058899},\n", + " {'box': [476, 63, 28, 28], 'confidence': 0.8581259250640869},\n", + " {'box': [489, 434, 35, 35], 'confidence': 0.8565669059753418},\n", + " {'box': [24, 367, 20, 20], 'confidence': 0.853937566280365},\n", + " {'box': [3, 176, 72, 72], 'confidence': 0.8522983193397522},\n", + " {'box': [0, 297, 20, 20], 'confidence': 0.851826012134552},\n", + " {'box': [42, 358, 78, 78], 'confidence': 0.8504625558853149},\n", + " {'box': [342, 102, 23, 23], 'confidence': 0.8466385006904602},\n", + " {'box': [335, 148, 26, 26], 'confidence': 0.8402417302131653},\n", + " {'box': [374, 395, 77, 77], 'confidence': 0.837632417678833},\n", + " {'box': [293, 160, 30, 30], 'confidence': 0.8371832370758057},\n", + " {'box': [107, 369, 150, 150], 'confidence': 0.8341783881187439},\n", + " {'box': [283, 148, 31, 31], 'confidence': 0.8329155445098877},\n", + " {'box': [18, 72, 23, 23], 'confidence': 0.8310617804527283},\n", + " {'box': [533, 271, 20, 20], 'confidence': 0.8309110403060913},\n", + " {'box': [2, 314, 43, 43], 'confidence': 0.8295050859451294},\n", + " {'box': [2, 247, 40, 40], 'confidence': 0.8290241956710815},\n", + " {'box': [136, 387, 97, 97], 'confidence': 0.8286371827125549},\n", + " {'box': [301, 220, 49, 49], 'confidence': 0.8285456299781799},\n", + " {'box': [22, 184, 31, 31], 'confidence': 0.8255282044410706},\n", + " {'box': [143, 419, 28, 28], 'confidence': 0.8249657154083252},\n", + " {'box': [10, 74, 22, 22], 'confidence': 0.8228946924209595},\n", + " {'box': [190, 2, 22, 22], 'confidence': 0.8213641047477722},\n", + " {'box': [424, 483, 34, 34], 'confidence': 0.8204600214958191},\n", + " {'box': [201, 205, 22, 22], 'confidence': 0.81780606508255},\n", + " {'box': [189, 120, 30, 30], 'confidence': 0.8163595795631409},\n", + " {'box': [10, 132, 29, 29], 'confidence': 0.8141602277755737},\n", + " {'box': [39, 217, 23, 23], 'confidence': 0.8135595321655273},\n", + " {'box': [185, 128, 58, 58], 'confidence': 0.810321569442749},\n", + " {'box': [173, 424, 20, 20], 'confidence': 0.8083855509757996},\n", + " {'box': [435, 212, 33, 33], 'confidence': 0.8042281866073608},\n", + " {'box': [206, 62, 21, 21], 'confidence': 0.8023461699485779},\n", + " {'box': [498, 152, 30, 30], 'confidence': 0.8022951483726501},\n", + " {'box': [49, 377, 56, 56], 'confidence': 0.8021646738052368},\n", + " {'box': [511, 33, 40, 40], 'confidence': 0.8009828925132751},\n", + " {'box': [31, 341, 79, 79], 'confidence': 0.7994623184204102},\n", + " {'box': [455, 401, 79, 79], 'confidence': 0.7946075201034546},\n", + " {'box': [153, 112, 102, 102], 'confidence': 0.7888069152832031},\n", + " {'box': [188, 96, 60, 60], 'confidence': 0.7880174517631531},\n", + " {'box': [191, 121, 21, 21], 'confidence': 0.7873377799987793},\n", + " {'box': [103, 53, 170, 170], 'confidence': 0.7869991064071655},\n", + " {'box': [161, 31, 154, 154], 'confidence': 0.7862122654914856},\n", + " {'box': [339, 172, 28, 28], 'confidence': 0.7811397314071655},\n", + " {'box': [194, 135, 26, 26], 'confidence': 0.7713541388511658},\n", + " {'box': [524, 267, 28, 28], 'confidence': 0.7680309414863586},\n", + " {'box': [319, 164, 19, 19], 'confidence': 0.7631727457046509},\n", + " {'box': [236, 101, 37, 37], 'confidence': 0.7625581622123718},\n", + " {'box': [2, 1, 57, 57], 'confidence': 0.7596020698547363},\n", + " {'box': [278, 136, 46, 46], 'confidence': 0.7581404447555542},\n", + " {'box': [284, 153, 24, 24], 'confidence': 0.7557078003883362},\n", + " {'box': [221, 212, 150, 150], 'confidence': 0.753204882144928},\n", + " {'box': [513, 368, 30, 30], 'confidence': 0.7531015276908875},\n", + " {'box': [464, 454, 21, 21], 'confidence': 0.74482661485672},\n", + " {'box': [499, 148, 39, 39], 'confidence': 0.7422949075698853},\n", + " {'box': [277, 135, 56, 56], 'confidence': 0.7366361618041992},\n", + " {'box': [304, 28, 59, 59], 'confidence': 0.7317830920219421},\n", + " {'box': [503, 293, 30, 30], 'confidence': 0.729342520236969},\n", + " {'box': [486, 333, 23, 23], 'confidence': 0.728617250919342},\n", + " {'box': [189, 142, 29, 29], 'confidence': 0.7246003746986389},\n", + " {'box': [356, 387, 21, 21], 'confidence': 0.7240045070648193},\n", + " {'box': [184, 205, 23, 23], 'confidence': 0.723656177520752},\n", + " {'box': [334, 99, 38, 38], 'confidence': 0.7213565707206726},\n", + " {'box': [501, 27, 51, 51], 'confidence': 0.7170071005821228},\n", + " {'box': [273, 266, 38, 38], 'confidence': 0.7144962549209595},\n", + " {'box': [252, 493, 40, 40], 'confidence': 0.7130072116851807},\n", + " {'box': [453, 215, 20, 20], 'confidence': 0.706762969493866},\n", + " {'box': [63, 396, 43, 43], 'confidence': 0.7053548693656921},\n", + " {'box': [313, 189, 39, 39], 'confidence': 0.7040255069732666},\n", + " {'box': [15, 241, 31, 31], 'confidence': 0.6972864866256714},\n", + " {'box': [219, 161, 18, 18], 'confidence': 0.6943190693855286},\n", + " {'box': [43, 9, 31, 31], 'confidence': 0.6927041411399841},\n", + " {'box': [303, 5, 27, 27], 'confidence': 0.6924176812171936},\n", + " {'box': [301, 259, 53, 53], 'confidence': 0.6918803453445435},\n", + " {'box': [478, 319, 40, 40], 'confidence': 0.6887754201889038},\n", + " {'box': [67, 508, 58, 52], 'confidence': 0.6868264079093933},\n", + " {'box': [184, 112, 43, 43], 'confidence': 0.6865329742431641},\n", + " {'box': [334, 135, 18, 18], 'confidence': 0.6855722069740295},\n", + " {'box': [36, 350, 23, 23], 'confidence': 0.6833070516586304},\n", + " {'box': [177, 95, 25, 25], 'confidence': 0.6830892562866211},\n", + " {'box': [159, 420, 38, 38], 'confidence': 0.682868480682373},\n", + " {'box': [318, 138, 19, 19], 'confidence': 0.6816803216934204},\n", + " {'box': [263, 423, 29, 29], 'confidence': 0.6813008189201355},\n", + " {'box': [284, 199, 20, 20], 'confidence': 0.6787427663803101},\n", + " {'box': [67, 352, 21, 21], 'confidence': 0.6717443466186523},\n", + " {'box': [481, 23, 74, 74], 'confidence': 0.6704385876655579},\n", + " {'box': [523, 452, 31, 31], 'confidence': 0.6700493097305298},\n", + " {'box': [243, 334, 76, 76], 'confidence': 0.6653152108192444},\n", + " {'box': [454, 338, 29, 29], 'confidence': 0.6650230884552002},\n", + " {'box': [49, 95, 22, 22], 'confidence': 0.6635971069335938},\n", + " {'box': [321, 84, 55, 55], 'confidence': 0.6603143215179443},\n", + " {'box': [480, 325, 31, 31], 'confidence': 0.6586322784423828},\n", + " {'box': [294, 135, 24, 24], 'confidence': 0.6576036810874939},\n", + " {'box': [60, 347, 39, 39], 'confidence': 0.6554562449455261},\n", + " {'box': [458, 406, 21, 21], 'confidence': 0.65467768907547},\n", + " {'box': [342, 138, 23, 23], 'confidence': 0.6540101766586304},\n", + " {'box': [540, 441, 20, 22], 'confidence': 0.653633713722229},\n", + " {'box': [300, 127, 25, 25], 'confidence': 0.6521259546279907},\n", + " {'box': [170, 133, 54, 54], 'confidence': 0.6484688520431519},\n", + " {'box': [20, 192, 22, 22], 'confidence': 0.644957959651947},\n", + " {'box': [518, 296, 28, 28], 'confidence': 0.6440291404724121},\n", + " {'box': [245, 522, 43, 38], 'confidence': 0.6340025067329407},\n", + " {'box': [436, 367, 58, 58], 'confidence': 0.6332893967628479},\n", + " {'box': [234, 233, 108, 108], 'confidence': 0.6274054646492004},\n", + " {'box': [28, 85, 53, 53], 'confidence': 0.6244142055511475},\n", + " {'box': [254, 502, 30, 30], 'confidence': 0.624413788318634},\n", + " {'box': [319, 182, 37, 37], 'confidence': 0.6236416101455688},\n", + " {'box': [29, 21, 31, 31], 'confidence': 0.6222331523895264},\n", + " {'box': [9, 182, 33, 33], 'confidence': 0.6211090683937073},\n", + " {'box': [17, 248, 21, 21], 'confidence': 0.6192639470100403},\n", + " {'box': [141, 398, 54, 54], 'confidence': 0.618570864200592},\n", + " {'box': [74, 386, 30, 30], 'confidence': 0.6184467673301697},\n", + " {'box': [198, 203, 28, 28], 'confidence': 0.6183221936225891},\n", + " {'box': [336, 103, 22, 22], 'confidence': 0.6169424653053284},\n", + " {'box': [253, 530, 30, 30], 'confidence': 0.6161786317825317},\n", + " {'box': [199, 58, 77, 77], 'confidence': 0.6141642332077026},\n", + " {'box': [510, 87, 41, 41], 'confidence': 0.6061983704566956},\n", + " {'box': [23, 212, 39, 39], 'confidence': 0.6061719655990601},\n", + " {'box': [292, 267, 63, 63], 'confidence': 0.605388343334198},\n", + " {'box': [446, 25, 112, 112], 'confidence': 0.604427695274353},\n", + " {'box': [342, 147, 20, 20], 'confidence': 0.6038945317268372},\n", + " {'box': [33, 249, 30, 30], 'confidence': 0.6038562655448914}]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "markdown", + "id": "70b577d0-a8e1-4bee-afab-a088a7ae06dd", + "metadata": {}, + "source": [ + "The output of the processing is a set of bounding boxes along with a confidence score. We can see a plot of the output in the following cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7bf61a0e-951f-4739-9b40-b5f1f65d10dc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mtcnn.utils.plotting import plot\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.imshow(plot(image, result))" + ] + }, + { + "cell_type": "markdown", + "id": "cff2a205-6ae5-484c-a152-fbff0c0d4323", + "metadata": {}, + "source": [ + "As can be seen, the PNet is proposing several bounding boxes, which must be \"refined\" to discard those that do not fit. This is part of the RNet functionality." + ] + }, + { + "cell_type": "markdown", + "id": "4ff0002c-4075-488f-a61b-d1ca0f8af5f7", + "metadata": {}, + "source": [ + "### Accessing PNet's model\n", + "\n", + "The network can be accessed by instantiating StagePNet and reading the attribute `model`, which is a TensorFlow model." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e9d020f1-f6b0-4dc6-aed0-06deefb4b6ed", + "metadata": {}, + "outputs": [], + "source": [ + "stage = StagePNet()\n", + "model = stage.model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c54f29b1-e00c-4631-bfa4-c2b5b119c260", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"p_net_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"p_net_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv1 (Conv2D)                  │ (None, None, None, 10) │           280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu1 (PReLU)                  │ (None, None, None, 10) │            10 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling1 (MaxPooling2D)      │ (None, None, None, 10) │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2 (Conv2D)                  │ (None, None, None, 16) │         1,456 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu2 (PReLU)                  │ (None, None, None, 16) │            16 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv3 (Conv2D)                  │ (None, None, None, 32) │         4,640 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu3 (PReLU)                  │ (None, None, None, 32) │            32 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv4-1 (Conv2D)                │ (None, None, None, 4)  │           132 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv4-2 (Conv2D)                │ (None, None, None, 2)  │            66 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu1 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m10\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m1,456\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu2 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m16\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m4,640\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu3 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m32\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv4-1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m132\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv4-2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m66\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 6,632 (25.91 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m6,632\u001b[0m (25.91 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 6,632 (25.91 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m6,632\u001b[0m (25.91 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "4dec95d0-7e60-445d-8eaa-7d0253317923", + "metadata": {}, + "source": [ + "### Loading PNet's weights\n", + "\n", + "The model weights are stored within the folder local `mtcnn/assets/weights/` under the filename `pnet.lz4`. It can be loaded with `joblib`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e2f87908-6030-4d15-8b2c-958eb14a9224", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "pnet_weights = joblib.load(\"../mtcnn/assets/weights/pnet.lz4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0d971b38-2bbc-4f02-b512-329fd57c43ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(pnet_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "69ba99a3-efe9-4792-a968-15e5d73e4457", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(3, 3, 3, 10),\n", + " (10,),\n", + " (1, 1, 10),\n", + " (3, 3, 10, 16),\n", + " (16,),\n", + " (1, 1, 16),\n", + " (3, 3, 16, 32),\n", + " (32,),\n", + " (1, 1, 32),\n", + " (1, 1, 32, 4),\n", + " (4,),\n", + " (1, 1, 32, 2),\n", + " (2,)]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[w.shape for w in pnet_weights]" + ] + }, + { + "cell_type": "markdown", + "id": "533da567-99e6-4c0b-beab-93a58c6d0e4c", + "metadata": {}, + "source": [ + "Further stage ablation can be performed by looking at `mtcnn/stages/stage_pnet.py`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3fb18783-1d83-4544-9c94-b3807be4b12b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (mamba3.11)", + "language": "python", + "name": "mamba3.11" + }, + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/rnet_ablation.ipynb b/notebooks/rnet_ablation.ipynb new file mode 100644 index 0000000..226b08f --- /dev/null +++ b/notebooks/rnet_ablation.ipynb @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "78ccfbad-54da-4945-b4a3-45b0eb9fc364", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"..\")" + ] + }, + { + "cell_type": "markdown", + "id": "ef4362f8-1bbb-46c5-b5f7-b5186b392051", + "metadata": {}, + "source": [ + "# MTCNN RNet\n", + "\n", + "This notebook demonstrates the RNet architecture and its corresponding weights.\n", + "\n", + "RNet is a convolutional neural network (CNN) with fully connected layers (FC) used in the second stage of MTCNN. This network refines the bounding box proposals generated by the previous PNet stage. It produces two outputs:\n", + "\n", + "* Regression of the bounding box coordinates to further refine the initial proposals.\n", + "* Classification of the proposals into two categories: no-face or face.\n", + "\n", + "The outputs are generated for each bounding box proposal, refining the results from the previous stage. \n", + "While RNet has the same functionality as PNet, it processes each proposal individually, with a fixed-size input, using the crops from the output of the previous stage as input.\n", + "\n", + "In the following sections, we will run the MTCNN model, focusing solely on the RNet stage. We will examine the intermediate inputs, observe the output shapes, and visualize the results." + ] + }, + { + "cell_type": "markdown", + "id": "b43678c3-225a-4f03-84c4-130c4c62a2bb", + "metadata": {}, + "source": [ + "## MTCNN on RNet Stage\n", + "\n", + "MTCNN can be configured to run up to the second stage, which will provide the direct output of the RNet stage." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3431815e-6a07-4a8b-8a2d-d454d4a3a4b9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:09:03.399323: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-10-02 19:09:03.409085: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-02 19:09:03.421049: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-02 19:09:03.424652: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-02 19:09:03.433483: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-02 19:09:04.112111: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "from mtcnn import MTCNN\n", + "from mtcnn.utils.images import load_image\n", + "from mtcnn.stages import StagePNet, StageRNet" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8f9b8423-64ec-4f23-91f7-9dcd85e85682", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-02 19:09:04.860887: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1044 MB memory: -> device: 0, name: NVIDIA RTX A6000, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2024-10-02 19:09:04.861271: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 7363 MB memory: -> device: 1, name: NVIDIA GeForce GTX 1070, pci bus id: 0000:17:00.0, compute capability: 6.1\n" + ] + } + ], + "source": [ + "image = load_image(\"../resources/ivan.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "85710efe-fac4-472f-91b7-dceb211d9965", + "metadata": {}, + "outputs": [], + "source": [ + "mtcnn = MTCNN(stages=[StagePNet, StageRNet], device=\"CPU:0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1516fdd4-794e-4e81-bcdd-6be6a45cb570", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 614 ms, sys: 163 ms, total: 776 ms\n", + "Wall time: 415 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "result = mtcnn.detect_faces(image, postprocess=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "57c31ee3-ef28-4010-a903-38173ac9364a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'box': [269, 92, 67, 67], 'confidence': 0.9900748133659363},\n", + " {'box': [478, 280, 60, 60], 'confidence': 0.9535849094390869},\n", + " {'box': [100, 407, 42, 42], 'confidence': 0.9220193028450012},\n", + " {'box': [9, 72, 30, 30], 'confidence': 0.9089504480361938},\n", + " {'box': [486, 205, 61, 61], 'confidence': 0.8844603896141052},\n", + " {'box': [7, 71, 43, 43], 'confidence': 0.8773281574249268},\n", + " {'box': [187, 119, 32, 32], 'confidence': 0.7967076897621155},\n", + " {'box': [305, 181, 48, 48], 'confidence': 0.7636563181877136},\n", + " {'box': [279, 104, 50, 50], 'confidence': 0.7341133952140808},\n", + " {'box': [176, 134, 58, 58], 'confidence': 0.7229615449905396}]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1e361a8b-ea17-41b3-950b-8a30c89040db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAGiCAYAAABd6zmYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9SZNtWZbfh/3W2nufcxt3f1302VZlFQoqggQEkqgPIJrBTJpAIwxpHMoMnJQmxECAYSJMNMAA/AKaUQOZNKFxgjFMoABKhEhWX5kVkRHxeu9uc85ulgbrnOvN8xfxIiMyM6LyrbAXfv366c/ee3X/9V9iZsZbeStv5a28lbfyLRT9dV/AW3krb+WtvJW38jp5q6Teylt5K2/lrXxr5a2Seitv5a28lbfyrZW3SuqtvJW38lbeyrdW3iqpt/JW3spbeSvfWnmrpN7KW3krb+WtfGvlrZJ6K2/lrbyVt/KtlbdK6q28lbfyVt7Kt1beKqm38lbeylt5K99aeauk3spbeStv5a18a+XXpqT+6//6v+bHP/4xi8WCP/iDP+Df/Jt/8+u6lLfyVt7KW3kr31L5tSip/+a/+W/4wz/8Q/7pP/2n/Lt/9+/423/7b/P3//7f58mTJ7+Oy3krb+WtvJW38i0V+XUQzP7BH/wB/+l/+p/yL//lvwSgtcYPfvAD/sv/8r/kv/qv/qtf9eW8lbfyVt7KW/mWSvxVn3AcR/7tv/23/ON//I8P36kq/9l/9p/xr//1v75zn2EYGIbh8HtrjRcvXvDo0SNE5Jd+zW/lrbyVt/JWvlkxMy4uLvjoo49QfX1Q71eupJ49e0atlffff//G9++//z5/9Ed/dOc+//yf/3P+2T/7Z7+Ky3srb+WtvJW38iuUjz/+mO9///uv/fuvXEn9IvKP//E/5g//8A8Pv5+dnfHDH/6QHz28x9npOSIRawoWACbvykAAFRAwDMEIQYmHf4JgiEAIQt83QhRSDKSuI8YAZhjt4LGZGQ2jacCaIqifQjNmI13sEFtycdp4/nTDPhdMPKIqZgggBkxRVrXpuCIYQmuGqiDin/1+OJxfRGjm9yb+P/8JcMupFAM10NnbvHaMwzaH75o/MxQRQVC/zmaoBmQ6i03n9m2n34Faq9+PKqrXjiGCaaOwx6TQdXDveMH9VUdnlbbdsugSH3z0PicPj4l9o+SRepmRC7DLyO5s4PTikl0b0M44urdg/XBNf69n/XBJTMK43xMK1POM7Iy8yeyHTG1GSsHfd6fEXonLxOJkweLeEaNlXr44R6qyXi9ZLCJdH2m1MGz3SAEb1f8VsGVmddLTpQ6ast8OnJ1eYK2wOllydO+YbpGwZoxDo9aGhYZEATWsVcZhZHu2YXe5A4OgbbquBf1qRep7NCVE1cdJM1qtmGVy2bK/yJSNorUjEtHUWBwFuuOOFgNVFVPDqAgQDMQEqUCuWGl0Guk0YqUhptQo5B5qL0gSEtCZEJpgBgWhSGYYtwyne9pFRrYNMiy6Hj2KxHs94V6HLhSpDQbQmoh0PlaokAKt6znbGH/56XN++hdPef7pBUqg65a0pli7GqciYDTMCiqJ1gwzI4Tw2vXCxPzfre/9eK+PvAhXQ/uw1fTZuHm81x1nmhW0110bTGuK/6zUwxy6nnl55fhq0zpy866sNRA5eCJGQ1Pmo+/f4/d/7/s8OglQLml1T+qWNFny6WcX/NGffcznTzZY62m1EUKE1tAgSIMYAq0YmLFc9Tx8r+Od9xZ89N59Ht1fEKWg2jCETW4U6dll+OzxGX/+p5/x7OcDkTUahW3bsC3GbgjQCj/+/oq//R8cM+SR/8v//X/k+Pj4te8Efg1K6p133iGEwOPHj298//jxYz744IM79+n7nr7vX/leQ0UUFKGJMg8zf7+CiNGa0uaFVxpWjFwqTQt0gRiFFAIpBRbLQAgQQiBGRTXQakUkEEKcJoaRW6bUEU09mC/eqpEgkFJPGZRWRmqp6DVsiogvFsg8hG36bJMScKWj4tc7b3d9cvnib4fPd/28EkO/ZLur76brua6kAMT8emYlBYj6trPC8p+T0hU9XL/gSt9EUFtgAnUY2FnlSJXjdaJ/kDhedyzvJfojgdqwsSCbQtomdK9oS9SUEDKWKn1SuigskrIIARVhuToiNaFJJoeRwSCIkHNGkqCdkFaR5bpnuV6wXC5IKmy3mYvLHXm0aQHsSYuI9oku+nPQFpEWsWbkmEl9QHKjbjI6DKRh70vYoNS9UuOS2HWsU0+pBZNCk0pphVwHlELXQxeX9GlB6hXThilIUDQZom2CNQlmggTFLNItl6wWK8KDFZEF0kC0IF3BYiOLkXGjR8QXcjUhmhJFSRIIIqQQUQWKsZQlI42NZvahYGpoq8QGkQAo2swNmRBJLInLFV1WKD4qshZqrEiopIWiJugi0MmSqEvEFAQ2Y+F8M/Dzx+f89GfPePlix6LrEVOiBpopmiKttVtKCoRAm8Zd0PDKGD6M+tcoqbvnyLW/8fWV1DyLbhuMwCvKqGEEEz/2tb9dP/bhe9o0Se2wHpgZNs+1+XdApcOyEExZLhJUX180ZNCejz48Ybd7lzrCxUWmiZJSworRrIE0+gD9OnDv/or33rvPg0cd66PAyapntQgECbgZFAiLjssBnjx/wbPHL9lebEm6JFqklkKXlLE1ogoQWcTEetmT4pc/S/g1KKmu6/iP/+P/mH/1r/4V/+Af/APAc0z/6l/9K/7RP/pHX/FolauFPnA1zObhZEA7fKcCMQgxRpbLjr4LpE7oUqDvAqYDPggiqhEhotNkaBXGYWQcR6oM9KtIUsNMoBliBoh7LeaWr/pHbBqxYtP1mYC1w8I+uSxg3zTY8vqz+OZlnhivG2TNCtIaJhGxjhA6WlXGXeYyFHoV1g96jh/eQ1ZGCZW2z9hQSWMgDIEwCl0TYhSwQtWCdpC6xCL1JCJ5zIQQialDl5FOEypCSoXdECjaoBdk3aHHS8KiA4Fxt2c8u6Rd7BDrGGWHtUJIvsDGRURVMVUwaE2oKlQqNQ8wjJAzfUxoVKo19sOenKALRtRCowGNZoVcM5WG9pFF36OS6FI/7ZuprQJtGiKN1iomChKQlBCNIBC7RKhLtEWCKCZQ2shoIwUwCzT1d6NNCChBFQi+qMXAaJVSCsGUOu4pGPtUGaR5xMHqZJy4VPXZpn3HatmzlJ6YoY6FUiuJTA4V+mnYScNEqDSMQq3GMGY+/fw5P/3kGZ98uuPsQuh1CVYwc6WkYTKIrhtSPtjeeCiLCHerqF+RvGGaXJhuy27OpetRG5fpp9mNY9+pzExQIrtN5fRsw4MHQh8NDUazDG3H0foBv/3jj1guVvz8k6ecnW6mQ0diCKzXPV0v3HuQePTumgcPViw6JaoRBIIKQRNoomRlsy188vlL/uQvfs6Tx8+pg6AE93wtQ2sIzY19nZwAjZDe7B39WsJ9f/iHf8h//p//5/wn/8l/wt/7e3+Pf/Ev/gWbzYb/4r/4L77ikeaX54u/qnp4BSNGQBpqRhBDFRZ9YrVK9H1iuYiTJm9ABS00KyCKiiCaCNqjIbLdbLm83LDdbihlpFsaqe+xsCAGD2+VXDEFa36uGAWhTJ6WohrdIkZBobZbCspdkju9nLtue/7LjS3uAGredYwvUiy/qKjqYaJcDyEaFSyCKZaVwAIhsLnc0ofGojdOSiPiljTqlrsgWGm0MnluZjQKmiD1kb6PJI1oCwwXl4wyoGtYpIT2gSULbAl9rWSptE4Jy46QlCZQWqWOA8Nuh9WCoZgptVZ2w54++XU2qYdwaxMYLXtIVgxRIS0SfeoIMVBiY9AKURnbSJMwPWuYYsp0iwWtCbkKIpEWE5WGxISYolZJgisomzyCOVw9vTeNidAv6HTBuN8ylpHCSLaRZgqitGY0mocDTT0cHiKtwlArjUqj0USQWqhByFYZc8aC0Qd1A8MKMST3gg0QDye2FCEJ2QraR6waMUWIDYkQEKQp0oySB8ahcnZxyeeff8ZnP3/GsF2y0PtIC0CZwtvt4P29Tm5HFebxfP336Zc31RXfuMgda68d/nd9zsorIT4z41XA9Zy+eNXovD2PVQRryjgaZ2dbxnFN13XUlln0HbUKtew5Wq/5yW+9z/vvnXB+dkkefTwGjayPe0IsLFaNblERGXwcSfQUhCSQnjErF5cjH3/6kr/42Wd8/tkpOYM2JZhHOKIGis3ug/kSZYBdpTO+TH4tSuof/sN/yNOnT/kn/+Sf8Pnnn/N3/s7f4b/77/67V8AUXy6z5+Shvtp8EocoiGZaG9117RProzVH6yV9H1FtBC2oGK0VzCqiiohbm32/oktrhr1xdrrn9PSS3W5HqZmgwnKd3N1tjVorEhSm3BS41dL3wnKhDLkxjAOtFSBhFlxR4SGZw23cNJLuGKiv3vVtRXXX0IYvd6e/CZkn2NXvYKZXitc8tyEmqEVEOjbbgVr3SIq81z+i6yMxGNIZlioleKhsbI2BgRaF1XHPvYdHnBwfYybsLgfOXlwSgyJV4HhJ1ylxHaEpwYQQGhYVkiIKLWd2uz152JFpdKsFabEmLhJ0Cp1iQaiTAeF5SwUx8phRDaRFTxcX9DWg0/qRaTRGrIMqjVyLL7woGgMWE9uxQujRfkXTSEVpYsQAWjOh7LFWoFRCcA/OQ1eGiXC0PubhvXd5cPI+URMvXzzlydMdVhS1CM1zm6ri+Ypq9LFHS2DzckfeD+RSaFJIXaDrEuvQoX1COyWESJN2GDyzgjUzqgkp9tx7+IgHJyeEBmcvXnJ29oLcKkECNNDqOQ3VABL9+SAc24qPPnyPWhOPPytsN4Fap2C3yGRj+Somtxbk+e9fGGZ7A+PrldDgG1fgTErvF51KZjeU0/TlnXmzV3NTHqUx7r6/G9+ZUWrFxsbpy0tevFhzcvwADRFrjahK6jpoRrY9D+8HHty7j0iHSqQ2o5FpVpFQEC00G6mmBO3QmDBZsNnB02eX/OyTJ/zs48c8f7khF+i6tac5LE4esfrYrQWrgjWopZBzYT8Or9zLXfJrA078o3/0j36B8N5t0aufU6gsBEG0YDaisbFaJo6PV6zXK/o+gRVazQRVzOqUkIUUg08CTUBgtyucvdzz8uUllxdbX2xUWSzc2kgaUQm0KjTmfAyIGKqNxUK5d3/Jbr+nne9p1UCUWmyydv3KbYr+3ekZvUZE5HDn1+PRvy7L8fUy5QmnATvFPvFlScmjMI6Z9ukZ9D1myr1VIi2MttzDkZBbZRwzFaFbLVidrOmXPRqE3eXI5nxD3o+YBra6A6n060C/TEiYQmRRIYiH3mql1kylIovEqn9AFxKpW6BRaVEo2mjaKNYQM88rmoeWk042oTRqiLQ+kVKHBmUctpT9SLVKax6uq62iBIIlTBMtdOyastlkLvY7htLIVolSWUjlnWXi3aMFi06hXXlx5ugcRHoWyxPWx/fBhLg58/yTKlE6WoNa1KeDBLQJdaxcPt/w7NNnbM43U56sETql6wMPTo5YPzgi6RG2dGVsBqqBINENjmbE0HFy/JB33/uIeycnlGFgN46UsxdUQMyw2rAKgzBFJNw7kqgsjzo+WrzP6ughi/6CTz/ecn62JxdfhP/ayOv03uusyG/69K1Sa+P0LPPxxy+5d3zCo4f3kZA9nC1CSp4tz3VPUEW10RCaZTQorY5Ya4QYSdpTxo7aFkDi9DTz80+e8cnPn/P4ySmXl3uQSESx7OFGplwmABPYxcwQ87HUSqOV+kb3851A971WLPg/3JMJqoi44gnRWB8njo9WLPrFlNOoWGsHDe/hf0NFCNoRAQkd283I82cv2ZwXSlGsdYAh1oA05aqULi6ohMl1bbixXREafa/E0HN0klitIrko4+Ducc4e4LMJc3jTL/pyue4hXQ99/Brqsr9AXDnN70YMZMI8qUKtRkw9SGCzKTz+5BIhkj464t46Ee43JCl0ARsCSxKsA/cfrohdZL/fsrnYMWxGgkWkQcuVIe8hB6zzcJyIEfB3bbW5RauQVguiuucQDPI4uJWhgapGMc8laVOYEKCY0aGUWhlLwbrA0cmK4/sP0BioZy/YvMy0sqfV5iAIASRRJVBMOR8qP3vygicXI+djpWqHqCF1z0oK+d0TjvueZZ+mUeEhuSCCiRLDApGOnI2SR7bDOIWOPYEecI+j1opGH+dnz894/lcv2Dzb0mtPLxHUqPtKHjIX9QztlPRwRQwJQkBbIYgSENqEi4ka6dIKDT2lCftSGFqjioNjPCYoNGvsBVBDQ0MVJExowy5w/90jTI4Y8hMuNlsov54R+qsUsTt01AGU8U2eCJDmnv1ofPbpOVE+47d/60O+98F9lj1Qt7SSUYEuRI8kWSYoECvDmN1zCgvUligdQuDps0uePXvC48/PefL4lN2uMY6GtAWp66i10moFVYSAWJgcY/eOVYUgSgyBqIG+exUMd5d8t5XUbKlPGlsEmlVCgKPjnuOTjsWiJ0giiDjyLDqc2hO1ECSiIigJlcZ2O/L8+SVnpwNWe4TOJxlCs4LVAC1MLlCgVSZARiCKL2yeE+tIMRBiYrXuqCXx8uWe3a6QS7sGAZom95vKZHRej7h/MwrqTafLq1bvnXvN92czoGXOvTVP7qovoKIO995fGi+fbhyB9OGKh+uO1AViasQRQjPoA2kRGPKW7cWOPLrB0aee1WpJ6AVZVDQ1CNAiDsWWNkHx56SAeyYjuEGDkTpxGL0wJcGEhjggxpNCqIFZg9pQVfr1kvW7D1g/fESzRmp7wv6CNFaovo/vHhmbMmZ4cbHjs2fnXLRI6dYUSWhoBIxiSqOjNKEUo1dFppXsUKJQGiUbu93AftizudzClPN0vJUSRRwRhzl8vTTUlD50aFEUdQ8tCKaQghJjJE6lBq01FCWIIiZYbdOC6mUXtcI4ZLa7Pbv94KFyDSiet7IGLUXajMATcwNF6/RUAyUIJWQKI4c58BWmwRduOoVff0WOy51y+1x3+Yr2uj98kRhXNzfHH2/ADt0IbK2RQmIcG598/JK8b+Rd5nsf3uP+SU8IQh73voOoz8fo3nCzjmAd2IL9JrDbZ07Pzvj4k8c8fXLKxUWmZEXpqaU5unr0sRZTpCGo3QSAtFrBHCkcNKAzeOIN5DutpGqrnvAmoKJARSTT97BadSz6RBIhKHjNTgARamu0Jo54El8wQcmDcvp8w9nLLWU0gkaa7fFShFkhBkqBcQyUMZNLpYuBxcI9BogeUrRCSoFKI3a9W+iteby4MeWlhBnNJTYjAyfPaLrH1q7H5+Xgfc1z2gf6tcTxXUnbO2L1r3xn/gxExK9lugpRP4vg19fmlZfZEzzkQacExuTh4ffk+Zw5FOkLZ7NGCP48aOLvZBw4fb5nZIF1HaZLHiwT3VEjjJmuVAj+BIaaabGxetgTwxIlkZKH60xHKjvMyqQXjUJBJ+vSJ4xBi0TtMAuU3GgVSjUsVEwLREOTIl0gi8N/xRo6jqQQkS6hXaBpIIvQTCasqTnOVAzVSjVoqmgVyti43O8Za6Oa1/WVasSSWapxslhyvFyTYg+hYhNYY/7nuaaeGBMhBlJV+pQosZvemYfpLHpIxap7rsv1kvawMsRA2RVa9itd9x1xuWT1aMHqwZpFv0RCoFqF1rAWqAi5NRCl61d0q2Nit6TWgTwMjNstoRkRme5baSI0UwYLnKPsqxuIawnc0whD4/TlKWfn54ylEkiT4TiPcAcSXQ1PN3aup6nmMXZrfZ7Gsr93X8NvAShuGXPzGL6eL7qx/dXUe+1cuktemYbyyqmn+9DDcV/Z8KC3PbzMnFi4MflvKXdjKh5pKBGjMY6FTz55ysuXz/nk5yf8+Mfv8847x6QEMVWvFxVo1SgVhj3k3Nhutrx8vuPZsw3PX+y5uBypJdGs89q66u6hBoUpjzmjNBGjCdQpflKLj0dJPv+bGGN7Mxf6O62kimXMZKoVUBAP83WdOrrOPHlsVtzdMWEsxjCOpBSZa44c9grnLzMXp5WWxWtIJKNaprqgQJAOlcZuN1DaDmiINRaLRGPBahnpYofG6KozBsyEMRvn55ecX2wopfmEQ33/yZs6/HcbVnpt8B4W2cli1nkCzqgv0asxO5lpdS78vWbVXIe6Hs7X5pl4dR2HhcAcvq/qq6XVNi2a0+J5XUFNl6vT9cp1qNOkRK1N9Rjzbq1Cy4xDJZ8qlnZUSwwnhftdZaEVjSASqM1NxXTU0a06JpeA3JQUOw/rlRGsIU1xfGFFtHq+MggpJixH2k4YN5mLFxvyxkE2FirWZdb3l9x79wRZBKpWTL1eaWFKihFipJkw5katgkpESQQiIgGVAgckoL8rFSNF4d7xEtmDhca66+gkcK9T3r93zPv3j1h2ShSbxt30MoO/j9Qn+kXHcuVqIaUpzG0+5vxuC9EEo0M7Id6LxAj5fqKOBWoliLJaLumXC2wZsOB7kyuzWVLUHDGrSuoSq/snnLzzDuuTNcNlowtKp0axSpzqFa1LmAmtwsuLHX90vuVJbfRd5N0U+K3FknRZ+Oxnzzl9saNaJBCYS0jMZuAEh/E4r8J6NcyuhpTNIfOrR+Wh+ashdxh6dyiJxlUg47X1htf0wHUk4Z2oQrgDDjGd+9ZhDUEt+DXYXEw/VyReKag5cnL9Pq/uRQ4/ZdpOEcI0rxRAA7kIpxcDm/1Tnp5uOD5acnws3L8fPGIRAkKgNWUcXFGdnQ6cvdxzcbFnHHvM5vCcG54qHtJGmud7VcAqQcy/U6MYNPMCba2CBkeuFqns8rccOPFNiC/K1UMbraGh0XWBfpGIMVwNcfFtm8HmcsPlZsvxyRFxsSRFz2kNQ+H05Tm73UiIwZUUUy3TpCzahFKpQ2M3Vo/lSmPIiVwypay8hmSZQGHMMIyF07NzTl9uGXZeaIcGrN0cijc/3ZRXck+/xGf6RdfxSzuGCAXQEBnHHc8fX2L5GfLOknBvQTxa0KXeFa4ZmgJd30Py4NFquWK9fkQgMuwu2W48T1NEKVOxpJpMNUNCaJHxLHP62Tm7sx37TXZLj0ZmT1zCUgP9g0gcPYZuk0e5SAtQYayKtoBKh5CoudCKopYwK77QmKKtUs3RoKsI3394j+NFZlcMCwkJkS6uOFkE7q0W3OsCoQxo2RPF2UVkCt9IENLCCItK6hv7caCyozEwF4WbNEwqTbw2C1XCUjlaLpG2gNqI4oW9qoqoMKqDN5oVB2DE6Mq9NZp4XVq36lkug9fcULE6ksc9rRYvPHaLZDK+lGEYeX56wefPznhhgRQD2dzP1PORZz/fsB8iKayQWuFgoF0t0rdH1M1l+mrsvKp9rnys697VneE25jXiNQrqVyq3z31NAWFudL+qP7ny/q6vJXZjfycbUITG2emO87MtUTq0RQ/1Rp2QnJBzpWaoRYCIhjWqI40NdogATUtjm88b/acUIAOTl2p2YMiZ2WiQOULzOl6Om/KdVlLXX4rhlEd939H3MzvEPOC9hmocMxcXF2x3IyEmlmnJctHTWuXiYsM45inkoLRWaC2jwT2Iq7BX89BOMw8famAsRr7YMwyFRd+zWHaoONRyc7lntxuxFohhBeqUOTetrderndfVhPx1EgNqiEhsdAJd17i3aNxfBZYLryvLVicWBQEVioK1SrfoOXn0gEcPPoQGZy+FfTmjDCN1UlLuucoVNdBgjKc7ds/OYQ9Li2QqpkqwxLJLPFidsKRDqyLqeZgJBUHGMI2kfslyfcRysWbYbFGLROnIxceREj1E2BwVGBTSQrjXRZqI50eDgxiiQCeFVAZCKURraPHwXRNoKrQGF6ePsbbjbNGz327ZbC4m61Umei5o5grDSWsqqkYKkaiRIEKUgJhRshcYG40UprySTjB9PPw5R6CVAnlH2Z6zz3uGyzPG3QaxSgzBQz3iOeFqjUKjmdEF5TguUBJ9Ey5Pt+SnAyV3RJZIC4i0q2X2NSFrF3nFk3pdKPtNxUNT1z5/y+Vu9X37b9cZbQCmOjlVL2sguU1RV+TdgirKIBUoIJUQOg7P2oRaKpJG0NGZQyY0tc0pFIQZwOaGRJnwEhOqbwKraQgH+iYVj2i8iXynldTB3cYRRGmC1MYYJpj2HLby2O8wjGy3I4ay32V2KRMkYbVwcb6l1jnM4En+EKeiXJ0MRYzWqlMtVYFmBAk0hVYbuRQ2u0K8HFAVWqnO99YiKolqSi11Ag4c7uIL7/E239ivvZr+lyCGQOoYbcu9hfKDDx/y/e8ds15FCG4QlKlIOqjSZIrNqxD6RLdaoCk6o4cq1YyK0wqpeZjOJ12A1igtsx8HchlRc3BCtkKMgdVywcmjNcf3jugXCQuGhIBN1r5NoAsNgZQiSoVWsFKgZMJcpwJUEZCISEPFFZHVzEJ8f6EgU9GuiBBaI9RKr4FOOlouNIMmrn1qEPabHRf7PfuYKGNGDaIoQRw5hTkzRgwTf19rSAW1hoh5qFWDo6yMid5GJ/ou9bzEWFCMJOIFugYMleH0nNNdo4uRcdgw7i6dOikFV1BTXVkzY7nuOVr3rDYbxuxhT7EFw9YY90JkgZpTTX05vRe3vrcb391WSq8L7b1OZNrpLgaHb4vMUaHbl3VQUJPzeHUL04aT6xVDDxitGM2u2Ei6LnlK5OCnCrkMxDgrFPO6PQ9OMqN1kauyn0M81K6dd74K8/EATJyeevi8WvwGoPvmtL2nYowQnD5nDtWJxGuuvDGOmVKM1EX2u8zLcsn2ckCBy/M9Ih0hQExCTD3LVZyKf/1MrTVKaZSiDFnYXG6cWiaESfEkcq2UJoTgMMxOI2b4fq063ZJcd3WvckFfJq9F8X2hBXgrLXzrGFdxdb5MX946rIFeWbZfa0qLUEToYuLddxZ89N4Ri1ipVoCOooF2yJc1rBX3UkTJzRkilsuColQxJCghTkwGUwjMUXJ+zdaE+KBj0Y7A01fEuKDrI+vjBUcPVvQPFtQwIQODUstMV+SGitAY9+dcvIB8ecH+csvu4gIpmUhFgrCzTIjBkXHNUIRlSESZgD6tTQl+L1+ggI3moAVRaDopUQEUAnRpYkzTQhsLQQJyoFPSye2qWGgQHHLfbAJUqNJFT6YjvgipzJX/V8jU0KZ8YfS6QA0Ouy+7PTsdKUGxVlErjubaF4gggSn3BiE03nm4YozCy13j4rwyvBwZ9+Xg2WKVoDf9gC+fBa+OtFc9qa8+/r6OvC439QZ78mV3fIig8AWrhBkzjMQV7jTW3ZKbj0RrjqwNIeErZqa0ZziB9uxVNoIaaJ4Ul01RpB5avHr65paAHXLLBlK5zktqNjNMXK0x1x9Rzb8BwAmYb7ohah4PFfVq6Snk4WHAQKle5awq5LGi2rHfZ8rYUFHMAiaF1EVSpxyfLFmve1LnlnZrjjgqpZKzscge393v9iBKKVckmCqRPDqCrZgTPaaYptTWjIeDG0PvDhj6axF5NjEQ2JWnddfgncfHDLg4uNozY/K1UIlw5aHNLOZ2zQI6bH/t6gXQENxzqQVFrhjX77j+699ft5pFfIns+p7VsqdLgdAFsgpZe6oEVBrasjM2J2czMHGvZRzz4f2oKv1iQSkbQtkRxYlb52LYgtIWEB51HJ88cKbn6vD01WrBYpXoFsHh0VYJIXqtT+doJmmFONWDlJzZ7ncMBFouSLPJOzGqFYfPR6FmL1psGZIlpHroTqpgFVoZsTxSS6ONXpulOHvETG4M7qlYnKxabZQhU9ro+SWUau69l5JpWgmduLc3I8ioXOYtAIvUTaEYo48TR6VAqV4IqlGJXcdeN6TUISoMdeeFzikSopMwhy4S57GN0NQI0kCNR0duvd8/ijxlz6cv9uxqm4AzZSqmn63raS7IVU7qurK5zUDxZfImzBMik5cKr6z+rwshXu97NFM5Xd/+TRXVvIDbNEFvA5tuXudkpEyG7TxX76ZQmhTWLY+qTcAoVSctcA+2gG7AjBCTo5kb1AJCvHZ9AatraouTUmpTkbZhljGuEIJm9U4r4TqGsjXHEJQxv9Gz+m4rKYOp74WHgoIePCkRX7B0ejjW3O2UKYnoK5dgUx2PL6471kc9xydLFstElxSjOGQ6qjNNpEBKBhZYLRIXF5fsdiN7Gjk7Sayqt4bwNP0sM9XMIdt4NZBm4tk3sCOv73b1HG74+Te2u/71N8XZNyvK+Zhf04/Cn79iVlCNaOoZmnFpyvnoNT8Pl5F1J2gdqXgYC51YDaZ7Wq9XSMuM+1PGoKgZOhXDVjGqNJBI0EBIEZk/m/PUpahowBnJrU6vq7nHY4I2IxYhVA8bghFKBsuEOofdlFYqYx6wVLDY0cZCHY22a+yzQlEsg2Wj1YbWPbQRqmA1uPdEJWgiKtQp34oa1So1Z8p0niCCpOSLhBllbITqUQVNQgizV4+P/+q1SzE6T6GZYWqE6ES1UryVh0SF5GHVEkZMYMgbZ5ifwuhd19MtevrVAkkQ+kiauDFjbERtdOsVQ4uU54XP94U2NOaWOkEKDpzvvub4+fXJ18mHvalcn2MHnXpt2l3BJuTGNlfrzWwEzB7zrMSEAxtMS5h1WAsTnajTvgGoJkwSaHCPiebM/i1PBi3YRBIcgtyETB5uYjJqVSeGC6Vbvtl7/04rqatwn1czpxQIUVG9bpX5ls1sMkQmqKUpSsCqYuI1U8tlx9Gxw3tDAI3mhLXNLeHZ+glipGB0Afp0xHY78PzFOVYKxSZ6pBCml9WuaYvrA2WWr6agfJcr4LqTkL6eTPM2GvCbmEQz1PXgD34Dx1Tc49hsdrw4E85q4VmGlxn6FOg/OOHRkTMcHZjnUdSAZnTRqaqsVg8jNHMwwURWKzaVJEx5G8FhusEgIkSLhCYeKZGJwSQoVoJ7O556IlkglILNxYq1TmHgyn70z+N+ZLffEZKz/pdsWDHqUGnZx51aIOAKMqki5vV+QTswR38m6fDEdUZmAB2ROnjRcbAw3aPQqS8uVrO35iBCsalFh0/zWit16g8WW8ByhSbEqKQQsGbUEULz0GsiUa1BwYuVi5LoKKVSx4KkSrkcyDJCgrCI9OtEWEXiyYKQGktVpFQ431POM5YD0jrQNpESz9Drb7e8UW3ULQ/o657rQHd2iHZwyDtdRTNuRiXmpeRG+k58jfR9r8JxYorKCu8dFzCLiAUPZ+s0w6Wh0es+rTVqmwtg/LgzYq9UwWwmVZg00uSJzTmpQ9TH2RFI6TcAOAEcknUh6KSgrvI9B5d6KiaVKZTgjNfuQtuEUlEVjo6V1Mnkwjq+370yncISM0lqxeoACKvFij4dUcYRKzv2Q52okSa4qNzmp5o9qmshvkOhxpvd8m2VNPeR+TLyyW9mEk2TwqqHU+e489cSj37nMfP8xY6h7DhFONUVG+04IbLPUMaBJIUQe0SnYuxmlGFge3HJuBk4e/mC3W47ISjVkW4IKmFiUYgEc+LZaErEGZtng8JorpHw99xqpRZoxRXNrmTGYU+rlRTi4Zm25q0oQMmlkXeFe/2KECNSm3t8Fq9sFgSdyWupTlRshsbk1flN6XoPr5RhRPBC9GIBaxC6CBgt50nxJA8CWfZ6LFWHrRtT7ZYXv9cyErrJgjVXdjrNGy80r1OfUIfkW6sY5mwcY6WXSKqBUiOLuIIybVkbdawM2y01gB3tSMcdi/WSfDly+dkF+aKi9ZhmkVozXexobeTNGNy+nfLLoiN7dd4asw66vY0vJ9dh6NfjpDDPL8SuKS/zcLL3H5jmcfVyAtsTOiGmhoSCqud5y5STb1WAQKuOGvRS7inP1eqhGeJ0oqvwn/jItwlcVNv4Rs/iO66k9MqikEmDT7HaOQTaaGhzCh5Vr1pvkztq0/6KIBqIac5rCSEmwA6x3Hl4yGzO0IgaUKloFzk6XrPdZoaxYdUtF7n2om4OY7vmDl8d+zDYb8fHuV31MF2IfRmp7LVrtltX8eU525vbXr9Uu5ogBq+dpG86eQWQ5s96uy+0JIyLFaMFkETqeie99HkF6n2HdFJS427H45//nKSJPGwRKomAZV/IVZRIQlGiBbQYDBUbBnJ2oAvV4dN+zb64t+r0Rq1OCMEmSIpYhlYalmYDxq89WEfsOmiZmo1el8SilJIntJS5V34AcoBIdbomxQEdAkW8sWZrI2KNVgcsJgeKZEcOhhhorTDWAdGAaYfQqDIgQZEQ0damdzVzD7oSkrlQ2PUemsCiUVuhSCHFSIg4lxvOGNBEkCwEcyJRbZlUvTWOasBiAJ2UamsMJbG/gIvTcx4/O+PZZ2fUfSTE3os7rSGSUDFqu6I1uzEubwwfu3IlXjdMf9kOmRz+d+Ok1xXVVd74rgu8GX7/oujHXafWW7/f3n6Omthhi+uh+OnzYcfZNXcS41YrRiEEWJ8o9+53PHi4YHUU6ReBMTud27DPnJ3tODvds9tk8hhpxQiyBKJ3NZgAVTIha6eg4WE9tNo8arLfvuYJ3JTvtJISTYhO5HkqbglMyDrn1VNaLcQ+kmLn9RyGV2JLoOFMAiUoJTZyzfQS0GBARaWnmLC93JO6gIaRGD1OH+SImBQJkOuE4pJEGSsh9lhTZ7Kw2+E9eEVDiB28IZhc+Gtbwjy43ZSaX/fsGd7pFd12zqZBc+MKrhk4NiHNECcUVfWzzKwWc/s7QTwExKygDvryjeUmaGI6fvH24NmMmgPaNZZc8KAbeWdxRJ+E3Hc0hZAqXQBt3jctjQPRChTomuf8ai4wRkIL7tlahepQ6DIWajbyUBj2I8GEVezoemewaG3iFiTQJpi3GHQxIi0h1Wgt0reEilJrYTcMaIx0qWfcj9CMLSMxBMY60seeEJTtbqTrO0JQSs5EjSxVsAIxJG+pUMcpN1YZa2GUimo6RAncVmgEq+4NTZRItXiDuRADsQFZiF2ka4FcC6EJSbyFiUhExYt466SwiuKhbxPSCAkDVfJUBoAGCs40EZJSyg4VoQs9eUJcxtSTVRi042w38NnzMz59uuHlHlpKSMhoduqoZpFWPSzrYFE3Jpu55zlTTMzz4c3yn6/+/XaN4QGMIK/4HW981NszbvaOZy0kt7Yzrs4H/pxV3AOfW3DMCu4uMMbtO5drYKbrNuRVf7q7ntV15ak0LVRGoiRoxmrZ8ej+iu9//z7vf3jC8cnCaz4VVEen+SrGfig8eXLGJx8/4/PPLnn5codKAkvel6oa0gRMEUmYzZ5aJIUFQTKL2DF8Se+wWb7TSspswvabv0SVMC2+DpoY9oX9fsAadH3CzMEPNK+lcYNnqtA386T9lAh0t1TYbgYuLgaOjxNd796Ij/VANVBzSyROZLKqBSFcGx43baCryfYl93b9l1sjfp4Qd1lTXyhybaJeP+S18XyjLuvwQ2789Ml2lZWa4a+vnO4NQ4oiQtJABfIUEksIJ53ywYMV7z464rgPxADBhN6ga4HUAqEYkittP9Ky50rKWBhzxUpEm1MM9UG9DgnDqmGmlLGS9wWNiZgiwQKlOY8fQaYcj4cVgwhJ1ENTzbw+yXRaE7z7bRQlmBEweqA3Q6sT0i4MpBilwCJ6e/VQlWRKAiiBKIEwIf6MSeGWRlehm3iosjlXWoxKZQ4pOxtKwz0ygjAqlCTEJNQkFIRh4hfsg5JpDM0h4NEEqRWr1YuPgShCbD7Hqk33LDM/YEWCk4mGlBhKoYVAWPXUFNjWyifPn/PJizM+f3HKJjdqWJCtIG3viqgZ4yhgjW6KWhxK76+Nxdn78EX8yxgKvngMvjoe31RFXTvDbePvsPuVEppTMrfPdPv3dgjh3co93RFCvF50fJdcD/3ZHQrqrrloiNfSUUm98uidNT/6wSN++P0T1sdKiBUNI2aQQkWlEZJxtF7xzsMTPvrgPZ482fLxx2f87KcvuDjfEON0b80Rv7lkrNkEe/dSjlaNKIFVv3z9DV2T77aSwutAZqikajiY9KpKznvOzi/Yj5muawxD46p9BAdSTqkNU6NWBXM2aFdyjf0uMw6FujToJuYC9bqU1tqUAA50KZJSdHQLr9JWfutFrikhZi/tdZtOcHWZP70mvPEVxEQnwmDQZixS4r1H93j33pqTEFiasURINSB7HDE3DJShYvtCGTLBhJILpVQHP0RhKHtCF9GuI4misxcoylBGrFZityBFz9u0UqmlYExAhNaQECb+PSdPlSnkGKOPt1IyMwfkdDf0Glk3hWKkIhxVpZVGyLAIHHICYWLOMKCLgk4ADYLQVXHARRP6JtQpzKwhemuQ5hGEJkKZLGpTpamwjcZOjNQZyx7nUZvqoPqkjnathWXoWBrUXBmK56gsCHnmYzOvUVMVooHOVGExUFJgjEpbr9grbKzw9PQFj1885/npJZe7kSwBuiVjK4y1ONegONI2iCvrrz14vtNyk0Xj1e7Ws9H45c/oyxTZq6JYBe3gvXeP+a2fPOLD91ccnxQaW3IrU5okkWTpKZBaKTXTrNAvA9//wTs8ePgu771/zs9++pgnnz/l4nxHs4SGHorXABqTsTFFaGwqLn8T+U4rqTn/5P908qzmF+uJ4zFX9nUg7cBsqiXxMo6pSE3BGlKNYVsZFpGu6wghUsvgrQkKbDcDzYQl6o3vgvP2eXzfa0xEnXjRbKplOdR/fPsVliAHi/XKk7pb+czW35wpm/e7e9ub932XF2kwMcQ3iII1o5PISb/kWDuOgJU15HLPeDZgWyXvMqGaewHFWGgkamIcRqRkUt/RDGreE2KkQ0niDAuIUCu0XLDiXHYzK7sndOuUVJbDvc5XOnvCingR91TaMNehmTX/HNUZxes4jY1Am9qkq3gYWt21JbcC0dGEDSgBNAhVjSxGVby9+wR716l4/YoomAOKyseik8W6kvHCYzVzjw2hBw/tVmNlQt8gY94tIChlBlJ4xxOIiqBQG8X8fqoaOxvZjnsuhsrT7ZYnlxecjXvG1oiA9RFJPdr1xCpYFQ+55+o5L2nYCFa/48vQLyzTu7sV7rvL+3udonqFrQPuKrm8U5x8Vjk+7vn+D+/zvR+sWPYjsXdQg7VKbRBD9OaHqQdGSsueUpHGOG5YrBf85Hfe5fg48ad95s/+9JzhYucIZ6m0VjFxFqAYAiJeizeMvwHACbO5J67HP1u7igvPmP2YOnYZxjGj0hGJB02uU8kAU1w4j8bm0lF76/UK1Y4QGuN4yTBcsBiEEFd0y86L2dQmdgsvirRmvsDhA0XUv/tK/aK+DXJrotyxAd4jaIapfpVDvxrKcMNCcVZodTqgoaIjpAwyZjaXZ5SLC/JlRsuCYIGu64mm1LEQktfIjblSh0zSwKLrGZuHs6KBViZPd4r7l0pE6LvOJ3drU1X+pKznn+oKuE1tP2odMVGMSrNKKSNtYn2orVFrRvuO3QKGydsPC2No1UNynVGoBPU6up1VNCnW+bPZG2h09pRdNUYE64WaDc0QaoNcIPv1BwOpDTGnRgqmhGzEXOlbYCXNO0JXUFMWpSENoirdlPupIlhKrhiDUEJAG1gDk8bYjBKMbOZ9pErhIhcuS2EMkcvW2PYdenzC/dWK9URi22LCNFLMjQOpQM6E1hg3W04fn2O7b78R98uS2+G+2z99my/2pF6BoL9BGHPebL1KfPjhCe+9v+TouJGCF6k3i2y3xsuXl8RoPDxJPHzQEWNEpdAomDZCYmJgKTx8R/n99BFmmT/+kxfsxjIh/dpUBC3UOnVAuJZ7+zL5TispDmg+X+RqbTB1zRXEC3BjpA0FE+/CavUqw2IYMiPkrDHsC5UyWcZCij0le66qteIeW5u9DSOEiZ1avEfRHGaq1dB4PYb+9SbgK96HXAEnuPbzq8rtSTCDMGZv4co2u+Oamh1qkA8W4I3tb+53FxT+RkgjRLRVWsukGLAiDJuBjTVy3lFOz5A8kCSBTIzKQbFq1JYp06JbyFTJaFoi2GERTxJQa2h1OG1TnYAkdq2vmF4rYFQOPYmYE9T+jEqppOjPqtZKKd4KRr3lMOAoxKJGCf6ssho5uLeTw/R9cKTTSGOZApIieRxpgnt24h2CNXo7B8xQayQRKAVtzeuj4FAXJhYcPNSgb5HYAqF4aLugSFJyUCQKJUARGNTIApuo7IJRggBeb5bHTBFjbI2tjezqwFAqphFZ95BOCLHjJPWchA4LCQ2BTowuRUgdxYRcvCxDamMdI5HGxbNnbM82jPsr4M1chP/KePsGisZvj7vZyJ0jjt9EoTtMOaHrebU3uK67qMpuKqw3OK/nPUBmRhq78TxvK4UQjfU68ujRgpN7EWMECQgLxr3w5LMzfvrTDfvhBfeOP+f3fu8HvPveA9ZHnQORrCJqRHHUaorK/fuJ3/rJBzx/mfnsyQ7beV89j140r6dT96oWi9+AYt4r1NwEEbaZ9NBj6F03ce/tMpYLJjNvWDiESAzvleRwdqc32m72DPs9TP1V3Lp2zr+ZDiZGneoKvE38kL3dB3bNGqIivDrhflHxwTtnZ2+5+XclRu8Ird3e7katxa2/f5F9O9O5+Odr+16DGr0uq3X7mg3IY55qmzwsu7nc87hV6rrnXlRSjcQGLTo2WtUo0QhitMT0r5El00LFYqMWR+YFfKJK9fco86Ig04SZJo0xTWSdFNDEYD4r7Dm0NhusZs3rhzBCjM7s0BwenwQWNtGJm7KYavNKg9h8EQvN22HEZqyasqqC91sMJAvUXGnF4eaxQm2ChOCtZMRZ1FUizarzCIjSJoQeUbEYsRCpfaQqjDQsBZoKVaHgSr7LlWyNy9rY1ErBu/nW2rzBcBeofWQfIoMsMXX2do0dSGQ/NCZ3DIpbzi/KjqYgIVDMKKUhOIHu+/fvcX/RoT1o92oe5ZtSFrfluncyo+IOKbFDhPsbqHt6xaZ8s2Pevr67ParX7+sbXY3tu+b69TKXoMbROnLvpKNLbqyVMXH6THny+chf/Wzk8dOAkRj3G773vZGTe41u4eUKKh5NEvO8vDe7rNx/0PO9Hzzi+dknaGjYNO8CbnzJxHoR02+EkrrK97TqYbU2obMqjro7Wi8oFS7Otw7tlc5zRe2qWdoVYFOwaozN+aisCSodrQkpKcvlgn6RvO22QatGv+gRAhcXW/a7TKs6caU531+wX1xJ3TXI3E3/6xUamRwyZ+4mgVX2w8iLYYShYKsFRxrpzBGVQcTbDqgRW6MFQ/tAU8PCVX7NC1O9JUBQr6RnMjZLdQMjdf1UPiBeuNsaYWp7bs0X6hacNdzDKYYGQRRKya4I1cOIzkU3MfJrYG2KjqAxsGpOGFtMidXZ2Z3iTpCmxGxoqKRqXmBcoVQvKA9NCFUoooyxkYOTftapct+ItCCHHKsJlNQhXXTW9hjIauxbYWeFjFHEqLjHf5w9JDkEoUryZ9a58q5B2cXJ21JhRBlyYT9kdhcXlLF55MCU4BVUCMKolaLmSm4yriKNUDPrZWKZzJuW0pgyX284Ur6eArmZ87Fv4IhfV66u4Pq1fdUoyXVEbrObdGF3GqvTHDk6WnJyckQMjaiRiw189smen/3FhifPRoYxsVwn7j845sHD91iujiYib0MkU/N+uno3/rBGiMY775zw4OExLy4uCVXIxdDgvIFjzuRcvDniG8h3WknNCDoBSm0TeML/1qozIqyXnSeoa2XYFw8P1QwhIVOh2RxJUI2ea9GpBfLESJEkcHS85uRkRYqNWgtBlRh7NCQ2FwPPn50yDhUsenGleUuOb0puJ1T/OokAXYhUa1QrDnkmkaVxPhitZPYxskqJlSrLTogh0vBaN1+ckxcV4r3EZGIL0eTtJg7PTmXqe9TQFOmWC0SV1lxBCXh79hCw4HRHZh4idE/RiYODXHnYc/iiTFx4Mcarc0ZBotK00SKQIjUIzby9RTUg9ZQ+MSSl1oSoYCnSakPq1DVXg4cbg1GjhyfbFAkwCVfetfr3Zeq51QQmrlrGJuSmFDyM2HAl6Z2pjVzbAV4/5pFiRlskxnXPqWRe7DLbPQylkptzIqJTXyEnGSNMC3+LkSLMDc+9FkocGdjUvdSxZkotvKmSkkO+5aa8cdH4XQv/L70C+IvlJjBn/k5e+Tx78K8/zjUUoKivY9MOrbVXQqjz+iamBE1Yq2wvG5/9/JKPf7rh6ZNCs0RMjdAVjk9OWK0fElMCRoahEbQeDPL5vQgNsz2L5Zr3P3jIn/3sY8yqd48WN+7zOLLb7pDfCBb0wwATWm0M40AaoOvi1O7ciBEWfeD+yZKha4wZNpcjEsKhr0qbLIDaBiAjViZiTqHvlywXa1brntQJot6DKKZEiolhyJyeXbLZ7DHrpkZ3Tg8iql/NTJvf9a042w0L61uUYP6yW3vTdLhNUG+sTtB2pQmIBIbavP4pwJiVsRZKU1h4vjFIcm666h2Rel0SVJwXLwhoRdXbyM9dbkV9xocUCV2ktjp1hzV/rykRY3TWiVyu4vpTNFNVpqaaIMEVpqk6QCIofeyIy549jaKdF4sn925acMh4mxZwL1wNtNhNytJbg0gIk9Lz7rmqjtgL85AyXKlPoJ+KTXmx4P23aqOU6Z5FnTE+F3b7HYIrstoqrTYuqnuMZcgwFsJoTN2uiA+P6VdLCB0lVxjdY6oYTcx7ZgVnbilz/MwM2hR9F4fXtAlAwnStZeozNHdtfTORVxbqr9rg8Kahd4cfZbd+Xt/09jav+/0ryRU68/o13g7z+cc7TnQt7C6ToeJkzTN7ynScKRR//fYVxYpCi6TYc3p2xtMnZ7x4sWccEv26J9uesV1yuUm8fHmOyJr793tS7D3nPuXBhIkTcwoBajBWK28Ae3a5QYMceoeFGDGMYb97oyf03VZSzJxUFauw3ezAIKYFi4VDy5sJqes4SUeUNQx7I4QdOXv9SWvOsIB5QzvVSOo6+j7R90ticFqelCYKpKm7qUlkLMLzlzueP9+QM8z9qwC35Oe+Oa+7+usDcwJyXHV/mQfVdASHwB1CY78suZ5rOgApbiWV3XqfrtMOVWc357FHxt5QhFYiopEQKiIFcHqpVr1sYDCfeNuy5XQcOBqWnCyWHHcLVjGy0kQS0GUkhkBV6Fpz9B/mxarz823ebiAFSNLARqwVJDSSKrHz4l1BDg0CTYUxGHur5OB1RwLUENwYiepexeRxDYvI3gbqQidGFKNqIkugTrF7WiaqF6Rf4OULHneewDjanBVFGiFOSMqcsWIeOswO1lFxJoimzulXaqVuBmRv5JKpVii1UGomBM/DBXHDrtRK8UYpMPb0bcXKIEpmsB1qmYV4jqzVkbE5aMLXJIcSH8aJysSKEaZH3JAwWfbWeahUK0JGCVDVk4l3RBxexzP5i+aLbueF3Cu2aw0w5vF6FQK8CgpejWW5fX67vu/0+da5v/iaPUym81nNy2OMK6VyOLbcmmMTOEJnJWbNOy/HRpUdpQ40Iq2uMLrJABwRKoqSc+bFyzNevhjo4ju8fHbB4883DLlAqtTobDpU46d/9TEXF2fcv3efn/zkx7z/0QnrdaDZGVZ3CAlqwvKCNghme6QbuPfoiKenW7QKYkYQSCmSljpRKX25fKeVlFibIhzVIcGm5ALDYCyWnpDNrRCjU3vEyUqJaU0ZK615AzxfUaGKogn6viOljqDqrL/miyaiiCVQZaxwebHjxcst252hYUnLYDKhrJiS5no3MufVivJr7FZy6+dt3Nwti+i1z+cNwRTX/3a7iFDRA1AA3Pqv17qpGjeve7bcbLrgu5T0q7VTgC68oaBtJuLJihCdDkg81DVaoYVMlT3n48iLumFdFqxix8lqSVLoYyCFQKdKVyvrENjRCMU74/YTv1wOXstUkrMuSKw0VUwjOYQJ+ReIYQFRyV1g0Mq2miMDRUAD1QINQ2PEJuACIjStFG1Yrd5UW2HfjBGF4InoVAdWodJIXuiqHWpCGb3XklulFWKjiwGsstlvqEMl1ETZGWVotOY1VdIpq3srMplyfkm6NBoFYiN0IH0jLSKLRcdyuUDFGTNqHihDz/ljgSEhrRDiQBdHzLbU/Q4JJyAdQ9g5AGlaGDvxguYrY8oZKWLraFQKI9AjrNzyDjta2yIEbAxoXVCpk3K7OQZvj5kvZ5x4dYx9WYhcZmjTbbDDXZ+/QNfcOMtXCMvLBKKZj++I45vHPcz+G+efajKb596leUubGAM//P59Qh94enbB+WZgu+kx65zEWLbEkJEWqWXk9GLHJ5+cUfbHPH8K20uhMmKpMLRMCwnkmLGMPH1yzuPHmZenid/eFH7nb6w5OoJq+6kpUYe2FZp7jM9IyxG6iuFzOGLexQAvyVh0vxHAiVlkAk0IeahsN5mY4Pgo0aWISaW07GG6rqNfRGoWRCak3zQMMkZIgRijI7FKcabrZoh4XQ7Afhi4uLjkxYtzNpcjZpE4xWbnfitXDV/eNOh1TQl9yc9vk3xh8OSOaMrdYqB7KpnGhqZ7n6zqzfaIwVnuQ4K0xrol4m0BqSZsTai5kBRizYTRQBoSIEmkk0gXdPrnaE7pA6mLxM5JToMKGchTeXxqoJ1ChaqNHCp7K4QoUNVzVOqdgdFA7BK1QcFDcK0J1RK1zKFkY98q+5ZBjbYf6NvAihEbG3kwAhMsvjWWfUe/jMTO6PrIIgVyyf68mxPclqEw7iqlNAjiSg4Oi24thaaVvuu4984RJ++ccHRvxXq9YtH3BA3UXKi18OzzDXl7wVAaVhpNK6YNCZ5Ts2mNtNmmmz1prkb4jbEwewHTVq4K7CqhbxP57Q1f5ma461cl34Z5df053lgxpl9ed41Xz8rbFcUY+OjDd/ngB9/j6ekRf/mzJ/zsZ408DG7wyEiQDDhb+TCO/Plf/JTPPj6ljTCOhpN8TcrTIZpI64kxsh8Cn3/2krioPHrnffqFTYas53pV5WBcSWjoTAZtnq+aB9FXydf/9VBSU9sNTJ0AcVcJUelCRwiChKmVh6gzTlOQUBGmlho2sZ1r8zh9rlOexOuhRJygViRwebnlxYtTLi4u2WxGIJJCmvKV0+Kos9r79SZlvzMihuhAa66g4lLQLhHighRXdGnBqoukBBagqRLnNuwGUo1AI0hFKYgVjMKojUGh08giRKoGRgHB2SFiF30RFkghsG+VoRZqrYQqdHhH4EJjEKMkYZVW5L3X0jWEoRo1j9S9Aw1q9YLebMJQBasFz4gpYwsUEhoKsVSOFApG3GXYFIoZMUSOlgveOTnm3oNjLGZCZ8RlIOfE/dUDQkvsz0ee5GcwOMmrqZDw56HNm0LmifE8pMT6+IgPPnqfk/tHXt9XHfmYg1F2A9vxkqFtqFFI2hjrSJNG1ymS3GArrfiCeSu3c5fXMm9z4zs8ZxbCNaWkV7V5b+Xri6owDFuW/ZIf//BDFosVw+YJjx/vMWt0vdH3AWmRUgKbobK53JI1IDVNEJjkKNUmE52xUkuiWkcf3PO9OLvk/HTNu++sCMkbxxqGacHUw+cOlJmMFZlrUq+Un9e1frl8x5WUTIlD/ywSgUDNme1FI1imVqNbemvyEOOUQJxyQQoqjVYbSPXkHuqWgAREo4clTBn2me32krPTC84vLilFEDoPJRImV3p6GTLTI8FNgv23cpcYDY2VqEZad/QnC6TrkLgk6AKVSJXmVe4GzRJjnUJuDawZUcRJYFXpu44uLTiaimujCX2IEy2Sv/+SM+OYJ4aQSpeEoVXGatQMoQpj9nByS2CrSLx3xEYij7dbhjzSDMZcsAkZZwe0qFElYboGCwQxQggUUXJzRoilNs9jAVorsbrBFIDOhIUqR4tEt15ArBCN2vX0umZzuuN8c87+ckfeDm6VNiAJWue8RGQMhSqVfd5zvr3g4XCPRYlobeQ80HcdpRVeXrzg5eYFJVR02VFrIYmCJlpQhlYYqkPGD0l4XlVK1z9f/2cmB2Nw/udF0HPB6VVY+K8zivWbFzmAeubX0lr1tIZl+lT5wffus78M9PqcZpUHj+5x//6KKEsuNo0//6tPeZovEBLWvH28iqAzu/5E4h3jPcYxAw2JjZozdchQBI0RRKdWNyPV9jTKBEzz+kBfEz0X7PDa+JsBQb/uBAsg4kWOrXlx6OayUmol7oy+N1aLBYs+TcSg4ol6FYIawQpD2SMBQoi0JpTRETLDUDk/23B5saVWQ+i9P5BMldzViTtlDvddR9v8gs7U7WTxq3mc19OoXN/m9jFfH0p5FTnllz8ndV8vr21LbzfBIV8kpWZCUhbrBWnVs62NYRgndJogVoDBk+22mLjAEqrOSBeDIM1DGcteOWqBh1kI2wGmPFI5INqqszNP/zWrDJapE0u4mLdwp4AEQXslPFiyOoq8DIGzobKfWExqA9FIseahqylf1SRSzKdXk0ZBJyScV99rE4fIl4bkSqoe0mxlZH9+wctQSZ3x3vpdUtdj0b398Xzk459+zPPPXmADLGNPa0a2ijQHiGh0Uk8i07U0hrJnn3cMJdGniAQmSq9GSIHFUUe/7OlliY6FThqb/YatBgYBid4c0SF8X00OoUHxNjoaFCcunUs97h6/v0y5i+HhLoDGm4A23uS679xXDv/7heW6kjJzWi+H9TdiaPR94PvvnxCKEpPwznsL7t1bAwuevSy8vNjy/MmOdqDN8iLxafJ652uD3DznFCNIqCy6SJ+SA8QOiOZGtUxjpJpD2LHAvJKIekG3mkB1ANqbyHdbSZmgYq79EY/BTzkmkehdJLcgA+w0s+9gsWx0XSSquOvbTewTwFhlalborR7225HtdiTnRi3OeFPrtCgjNLnqlhlUrgEa3HKcZ+frwuuvSxB/qYJieu1foKC+SK7vcwVtv3mhN2Grt42BiQX9S+RNs3ECqHQev9YVu6Fwuh+x0HtLFWv00b2g1hwVZ+Ls5EE8JDGUQhAHx2A4w8M2U59tsNYIql53NHErhilCPFsS3j5AnT7LAqFBZwoBhloIi8ZaOi6kJ7dAtbkrbyKPFcTrnmjeBXhmxfA8DA6gMV9I1AxtmVgLoWRSc047p5aJmBQuLy9ZnPcc704Iy2NElGG/48Wzl7x4+oI6NvqwpAzViyRr9Q6rzVuDdH1g/f59RCEsIK2Exar3RofB28OrQojKYrXk0XtCl1b0oSMUIDf2P/8cNcVCRESxNiDXGo0exskdUqvntOwO4FDQ4OUbWmi1Oux+DpDPbCC/gHwZI8P873aR66/Lc7M3nSB3yTUL+Mo7LfR9h4kcOCStCffurYnyELPC0T0IYQAUlQLSSCkgsWc/ddwtLU9Tww7dow0j9Qnani5mPvrgIe88OHGKruqoVg2ONi1WnMC5JWqNWAuUklkvFFojhY46emXdm8h3W0kxF5LBFUhhBi0AeFfVVo3RjHE/st16DZQK9F2k6+LE3dbI7GlTC45xrN6io0znsakznPNfT9/ZtXNdB0nMObLJgrg1EO9UKl8FsfcNpLpeCdV8iaK7C8L7zSW3BTGvOG3NvVhojCMOZAkCbQCppACq9dCAr9TshonOyf25m45OXXy9An/ilfVC35nbjJkpHJA4FcUqDWcBd27gicsuOLCiTC3ZFT14eYGAM967F+UN6ZRqDTPvwyPmRa/NDDUjWiOZ0TUjmLOzq7hiMwlkK1xsdrw4veQsZzKNcT9y9slTdtuB0KJnuqbGcaJX7265WHD83hHHR0c0MgQjs7+iIJLZxHCPpouJ5dLoekdGSobNiz27YWSUntJ5sXxrjnC9a2zcOV4ORpBcs1jmbe3wrr726PmKBtoXjd1fNWjjq8jN+7RDtuMQMhWvf8vNS2RUM7VmgjZWi8iYs3syQREarWVKHiZATqFpIujcEl4xmpcRWEEUctmT4sDDd5Z8+MExx+vkeWALMJWINPPIgkrHuIf9DlqLU6jP12drYFUY9/WN7vuvgZKalJIZTrE8Fy6AKwj1ojUmlFUxWplqXHKeWCJwpue6wyZ3SCQg1nlS2mDut+1qRyd0it36N8ms0ESBwjeiVa7JPFT/usTvZUJn0hy236aunjG6xxvFOFpG3n3wLo/uHdGKcXYx8PIy83JTJroVR5AJTjeETWU4OoVhp/YW1RwFdVg3xd9lq4LJRExsE8rOoEkla6BGZSuNoeZpsca13xQmlWl8CYqaIbQpBGOHtVmnYcrEM6k2IfokICFgVC/QlUYV5WI3svn5Y7alsC2FqMJin711giRa9aEvTrk/WTlC1yf6dWJ54p1+tRN2WZAAEmbbSTAmDsCJDDZGp7sppbAbduz2Iy0tkBamPlxvGu6aFPWkqGBOHd8KKRuvDzP8EuRG5OCWN/Wm+3+TCuxQqvE15brRW6ux21eGAo1AqQNJKl3XkUuh1RFvydlorSCWEfUeapVAriOqhkpznzngZLJUggzcexD4wQ+PeO+9nsXCpqbo3qjU6+7ALDKOyunLgcuLSivJQ9ATZZi15uww4TfBkzrw4k0Kym5SdFwpLJm6is4D1OaQKzkXrHnlv2nwhUrnCe9ktR5am+fU3O559qIc0TcV+1z9s8nbYlKc36QukXnC35xw32VxA7963Yc1oGKtYVTuPzjmb/2N7/G7P36fdx8cU3Pj08en/NnHz/ijP/+MXa44EJaJD2+2V64bEJ60ba0615zHGA/Fp7N3fPjPZLqO+eq8Zm60TGVqDihtWviu+QTzQBEv5p4ZF7xsNIC6QrVqtKbUFgFjarzrOcCYWB0d02Lg6cUZL7ZbdqWx7hNJlWXqIU8dfMU7B8+1fijkWhjzHolL0qKD2IgIJjY5QkIzne43eB1yVCQ2QnDuyv24J2dnYA8SCdKmJ3zrvd01Bm0GTVxR4cyPUeb4OPNc+tXL15kvv+i+d+53FbH7WmI2967zMOvFxY6Ly4F7D4WkHvrzntLeyLLWQgiGU1RWrHnBt3YrJ7eSilEwriIHZgMPHyR+8OP7fPS9Net1I4YykWE5HV1tnteqTbncZF683DEOgkiHyFz7d6WkUkxvdH/fbSV1QxnNK9M0keY2Hsyx36nVPEwIFo+ty6R0XCl1B/CFb2fXwmBysIinLAbX6ztuXpMcFqerGXlzi7sMshux/i+861uhum9CZLZ2X72mXzR0/ub7eAgMGmZ58j4K0oxFv+DH33uXv/O/+h1OVrC/fIkS+fCdExqBp8/PefJiR65+RkGRKYQWm08IbY2EQKsEYWK9dyvW2pwg9nel5saMQ7knhylCaCDVqN7MxcOBzb2lueTA5rJmlclDU4yAycSvR0Clg+a1V4VCrjpRAzlEN4bA8mjF8v4J5+PAthoDgREhNmWohd4CkoVOOsLUUdicBh0R2O13tPOB+49WpMXUiFEaGlwR22R8MXH+BXEGd9OMiFFLZdiP5FyJnREORVJMUQsOXtvV4JlGi1x5lxyey7URMXswh1f/q1FTX9uge91+X9ETu7HrHZ9eL7OhdbWO+bc2rUUOnmjNON/sObsceL8sSb16k0ILU21fpBmkoKzXC06OV6TwgtIqq6Ml3eoYi1DbnjJuaeOelkdOTo74G7/1iJ/8+CH3jyCEgkxhbDfMBGtKqcp+X3lxuuXFi0uGcQUWD8aK4AXIrbVrTsYXy3dcSc3u+m2L+ZqXA9NLVWzqMyVAad4ZVUVhIgh1BItMbeXlmkKaQkazsTwdWw7Lt07fM8X762Q7C2L1xmIthz1vDsz5yudzilxt67/frDv5OpUlt5FNM/nkzGlntxYSJ369dRPcnPjXe9XIQUFzw4mclfx8+nnOKkI6sHpUqhRMRoIo91LiBw8ecpI6Lp78nD/+X/49R+tjfvST3+PhuufdB8c8Px+4qIKQ6Iheo5ENQiQHAQoWM90CYlSCCmV0bjuVhDWhjoU1HWKuiGoUxlLoBGJ1sIN/FyD01DLQqUIth1YFGnsygTIxgotVSjCqGqlV+io0KzQVSqgUKagWLBRGq8Tc6FpCK+zGkWf7Dc/ajss6oBrpDFAl10aSMA3zhrVCH4VkEKYw/3BZGTbKatVRbUfXLTANNBK5RdJUN2aWUfHuxOiC1ow67imDj/cgU3dfMaI2glWaBVoLPp+0I0qg1j1BGyqehyua3FMVORA5i0AWY5TmhZ+HcVKZjbur0XK7F9scqXijEX5gp/gmvKa5ULXa7Tk4NTWFGywR9gWh0ZtX+SV/vw7yYADJaFhQm1INRI2gjUij1T1RIzF27DeN508HLj9a0i8CTfdUqzQVaIkUhFa3HK+X/PaPPuLl83M+fnwJ3Z62uscYF5gsEVuwtIGl7Hj/nY4ff/+I791T+mBctsQOI6ZKV/dQItiKbV7w2bOn/Pzzgednl2zzhqgrh5yHDpUGMmAsyeU3gWCWyfqfx7YJh4TENAREgnMTmHneYdrP0XkKopOrPNe4uHvbpgl0vYJ/OqPzd02jUua/XVvYBcOk0pi6pt66Zl+sb1tVk9q6a07dEfP/xuVaGGb2Omel0uxq+Zjs5Dsv4QYg5FYo47D5DaV1Ndnn0FpTh2zbxAKxXq65f3QPKXB2esnTp6cEXbFariE3rOzI45a+v89uV6nmrCGtjQwlU6OxXC949M4RH7z7gJPjFWKw3wycn+85fXHJ82entJpZqtJJIpsxClgwOnM8WwiKpUAwYxUBaywVjo56Fn1H1y/RbsVnzy94fjkQg+Bd6B0FauZ9pOYGiKZ+j54trRges2fM7M8v2eYdG7KjG4PSqRIxxgnFqBIo1hy5KFfgnKCJOrWrKftGy4W0CGiAIVc0JKfimUM6LftLsTiBV8Cq0EpzTjlxo0wOvb4Ez38FmkEulabOBO+9jJxdvYkAjTkqrpNJ5wFcDpGGOSB+bRS9MiwPo24ekF8id6K9Xwfu+BJY+dV+0/yWearMuWruoCn75sEXDoyYsHYTrNukUm2gWwjLFNDWyMM5Y2s8eTrw6WewXD9kuVCwgpUyzevOqbcoPHx4n9/67Y/Y1Z9xXreELiNpydCEloXQRRbH97j3XuLoONKRnWIsrb1dDTuCDQjCblf4/PORn/7VGc+ejeQCGgyVgrBA6aZRMAATheYbyHdeSbnIlANi+jnfvdFqpDZHX+mUm0KY2n17C4M5kR6D3BhtwqzzrgJet9be117OF311O3z264jL35Zra8HN769f3DQZfxnX22QmYo2Yeo+ikhtjhaHBaIH1g3f44d/4W7z/wfcJi2OePf4pl+fPWcbCYFskeWNEd259dVydLPmd3/0Rf/d//be4d7Iij3uohrVAzcqzJ6f86R/9KT/7kz8n7wysMWI0DZ6DqTY1toyICilf8G5fOb634mQRuXe0ZLVYonHB5WC8fP4CGbdYxCfltUXN814zwMObv8kUYowoXQzeRypXimWQypJAFwJRlNiMFhoWIoQOM6UVbxfimiBA33lHgO2G/W6D1Y4YAlH8z1gBq2g2RAoqFXD+QVrzEotWabUceOE8kVUxixjBFad6yVejMNbGInUUi5QiGGlCkM0F7pOJ8+aMw8CriuJwnGvydZXB65gz3vi4ciOoP13T17qk15ym87WnRBw+roe8372Tnt/68bscrwPD/pK/evwZpxcvefK44/1H77J45xjVDegFZltEIiJLhhyQGPjRjz6iX/Z89mLP831hs32BpBWx7xiBs1zJ9BDS5AWVQ6NQsQgW2W72PH264dOfb3jy+Us224Lqwrn6xoiEHqFDaFO+K/GmnvF3W0nJ9ZDADFuCq2XUcLKYNKG1ZsADXvg4Ib7UmCz3OYt18/BXMeBvBo3zbRedldVrPKFv3pGbvFr1mLmp+fvoE0MLfP78gtV6yYOH7/LD+++zWNzj+elT/urjT9icPuO4W/GD9+/TrR9w+vKCl0+eUqgsTxb8h7/7N/kP/sO/ybvvPqDWEdsr0gIxLlmkI5b33yFLYLPbcfrnn2K5UoPSdAI8TBX4mJGHPbq/4NEq8b1HJxz1gSSNoAOlNZ6fXVK2Z3QyhXzkQL07hUA9L+UB4oBIQwme+2ogJh5yNee4S2IsRZzQFkWs0IKSY3D29ClnFiVgapCUMSiFSFWH4GtM5JoprdKlbsrR4e1oGImRidVdJgjx5NtMIBamnB0IQTui9FjdodqI0f2ijFvoSI/ENSkuyHkPjNPrncEjX2FE3IHEu2vgfVOIu19IQc1XdHuu3KFMv64I8fAMVbwg3GOoRtcJ739wxAcfLBBd8uHlgj/5459z+nzP408vWfUn3Lu3pu8yre6oraKTwZHNKeJ+9P2HfPhB4GdPN4yfnPIiD5QQGS1xVoUn5wM/PBbePXIGlYZQm1MojYPx+edP+NlfXfLkqTHsDCsCUZGmBO28DlISftGRuUP6m8h3W0kxzVILPHigfPg9u7YoTApozvYYjlqZ2iBomAeYedGlQJ3yWVcw4ZkIccrZTK3pwUM156fCZ5++aVfRb7mYOzIyhzC4Oc0O+bhfzqk9gycOx0am+qUWeH56wZ/85cfsxi0ffu8R2i/Z7s745M/+PWef/QUfvXufv/F7f5MPf/S7WLfmf/7jv+B/2p7BOPDgnfv88Cc/5MG7DxioEJVwdIRVobbAGJVwtOLBB+9x751HPP+LT9HgFffjxLA/P4RaKrvLDZb3hFLRsiOl5MXBNYAuqGV03r/Q0yR4Z2ccQyfX/ptbm+gEm0eUSmVnBZGARcXilHNq7m2FFAmLROoTQT1yYCZINSw4Q8AY4Kx4rUrRjouqnI7GIroX2CwSTAgKWo2gEU0y1ZgZVkFoKM19PjNsKrb1dhsNKXvWPdw/6VgsobaR/Qib7ch2EISeajMVkh3Gkoey32zhfj3dEtxe/H8ZntQvcJQbt+YpiG/2Ok0qJt7g07kPhVIGNDSiKj5cdoS458GDjj/4g/+IP/1fHvOXf/aXBMn88EfvcHKyIKXkMXWMppUqRqgD2hr3FyvChyu2rbH99ILTVhhiTwgdL7YbLvaVfBQJQK0NI1EKlG2mFVgse+7fn8igNxtebjfs9yO9HKGhTh7cDPRwtvw3ke+0kjLqoY7pf/sPRv43f7/yv/vfD+ib5lffQP7b/4fy7/+H5Ggt5kSv0S0aH3xo/B//D+uD9XW7++UBjswvurj7ueYeT4eBf0jEfX25zjhxHdY+X7tcC2fMi00DR6S9Rmza11PdX16b4kqqoerNA90wiJgkmkU+f37OJm/56ZOfk00pWWmXT/joeMHf+v3f48c/+iFHD+9xmZU+CUEcamtWePr0c9Ii8vC9h6S+p5RCbt6mA4WwSPRHKzQoIXmjQ1WFaQIdWAqAUgqiyn7Mztm3TMQQnIRTA6FbQFqQc6RZIE6pUTE71F2pOH2MYBAmAE6M3qcKQyKQFLrkeaKSfWFaLEh9YrHq6VNHMMFqhdKIwdk0qlUGvGHiLsBfvrjkSd5zfNJx//6Kk2Wg156EEU1ZdpFmikmjmHkh5zQOVFy1Hq4VYxEavRrvPljx/e+dcHKsDOOGi+3I508Hnp4aQ4Vdyc7cMtduzXnIa+997mp8ezzc5cl8UU3T117835B1Yu4CfpfcDPW9ek+3/3Zzx9fMiRvPBEQyFvYENRZ9DwTG/UhQIWlyr0R8xnWhRzXwWz9+iNU9n3z852w3L/jJb/+Yd9498VYdmgnByxhCbGgdkNZY6JJ1anTB28ygkV01Lk3YFGFo3oOtSSUE70bQr+7R/2DJyfuJDy8jz5/v+fT5c376+WeMj7ckMqLj9G4LGgrNBuA3AILuXpFOCV34b/+fPfud8C/++RokYy0jUglqxKh0faLrEjGpNzFUI6aAqneNzLkxDJn9PpNz4+/+vcIwGP+3/2sCTWAzjKJxfK/yf/o/76breA090bze87rh/SUy5TL4BaliXjfxbluP11ksDs7DQUk5zf78t8OHWwjB62IHLPtVju+LLFYzD+/JpAVnJgclENOCcdhxua+cjxtMA4nEe8fH/P7v/4Df/Z3fpV/0zllWKhenF7TSiCHy/MkT/rLu6RcLju6fQEyUiZ8vxECuzmY+5D373d5pkSblFDQcKJQAuq5jddRRilLLAN2KpgmTRi6VIpBNqdpRQoe1nmTmeRnm4t7m3sihfMHZykeqFwpHsB60D6zXK04WKx50iSbCtmT2eWRfjX3ds1ouWPY9436gitAvVyy6/qBAJawo1ni8PeV/+flPSUF4dP8hD47usQyBXgsna+G9d4945+EKxPtSKUIUZ5gPM12HuRGx7oX7q8QPP1rz8ERYpMyojQdpwYKOMux4cTnQVNmLXesGMBsihxd+qDe8LV/EU/nLlNvK6i5GmC+SL+P4u/s73nBhEBojIey5/2DBBx8cc7Q6Ztg2Pv/0ObvNltMXG+4/vA/RsNpjtbE+En782yfUcsmnHz/nj/fC9gcf8v5HCxbrPRaVoAvKsGcVGlEDuRVSNFIU2liw5NjmsSm7Atk8LzqXIlgTUlzQrxK2COgislollveN7qQSYmV3WpFhh03GY5RCs5G7S3hele+0knpFzDg/g7/4M/Mgv1VCKCwWDsVdr1csFj0hzoSMBQ1ctQK3yDgUNtuB/S7z7PGWew8yc7HmHGtu7aYjcxcXmE5wd1r9diAjvkhuKaGZwAN4VUF9gVyf4F9pSZGr8Kx7MO2QQ8y1UUyJEsgI0Sq9Kr/94x/xH/6tv8X65AgRYZuFx4+f8vnnz8hjZdlFxss9z4eB7fc3tOygAI0zs0KiDiNiMO63bM7OaLmgFQhGCEIQN0hUla7vWB0dcbnznlMWe6q4wkMFk+CcZSY0Cf5dq1Oy6Vru1Dw0FNRzoFAY68geYwjCgLPBNyucnT733FUMtD5CDCxSYrnoqTXz5PyUFAKlFMazU45WJ/T9is02MxhYjFhcsn74ARcXZ/zl5y950o2cLFf0ofDO/cT64QOOaqCPnXMHSkDYT8Sh3ltrhnN3qfHug8iHjxZE28K4ZQWMEjlZdHS6oeQtkhJ3jYCDz34DnHRTKbwOyHD189XjflXWiC/7251IQHjtPL6LceP2xnd7iL7tvLbc1Y3YjUgAby3z7nvH/OQn7/Lw/gmWOz545z5/8ed/xfNnz7n/KPDwnZ6UIiEUSt3zzqMV/e//mIf3trx4NvLk2RMkLXi/c0SqtDqBGWzKcAj9YkXXjei2oa0QxSMDg8FghareLfpgyM4s51ogFDQMrI8q78mKs4sVH58/m7zqqXB9wjKH8JsAnLglHndv5LIjpspyKazXS9bLjsVyQd/13rRuGkSl4vA+mQaDFVaLSIqRYVFZLLyORSauM1FXUDYF/ub94PagusqLfVdknoSzA6Rc5afgrqXh1v53JLrlDRubeX8ntxex6hPHrjq+ptSBQmnGKik/ePc+/9Hf/AnvPLxHbZXYr3jy+AX/r//3/8TLl1ukKtqUpSTK5pKL52dsz7YcL1aEKBOzs0/OmgfOXjxld3qO5kq0QK0+gaK4Z9GsUSd2hNrEW3KbOqM6dWoR17CSoVUvFrYGLUMrXhU8hftEnIZItaIy9Xua0Hv7aBQ1TCH0Petuxe7ikouLS3YXlRaU9XqFnBlHR0sIwsW4BxPGXKibDd0I45AZWkO7gCY4O79gzIV79x5hRchNnXz5dMO95+dEMU5WC9axpzWlDEbLBm2u0fOUlMSK6Mg4brA6EM3QkAgSaQUPe6ZAkYbZHdz504J7veZPXjOH7hpXv2A84saxvuxvrw0tvqp3rrafIx43jvXl3qBNx71Lod84vwgiPUEjq9UxR8eRvt+TFnDyu+9zdNTx9OUT9sMluRh9ELrUkbPXA65XS374ozXf/75SavVwG3v224Km4CUSCI1Ak0joV6RuT5AtrXm42YBhYlxp4shTswrVaySNTLFKaxWrA1YLMTROjpcslz1lmIFDTIZP+k0BTsD1bMncxylEYbmK3DvpWa8SfReJcSKStTn8pigJUUUdm0urW1IMdJ134V2ttqC7Q1xdxQtdZ4aK29REr0yyr+tB/Yo9sLuWgtufv+ySbhQbv8kOk6g4X1gzp0VSc3htFxPNjFIHNAQ+/OAhf/dv/i4//t77BFWqKU9fXPL/+f/9KX/5V5+TJLGQQGiKFKFuM48/+Yx3P/qI9YP79MuFsxNhiBpD3vL8yWPyZseiQZx6M5k5CfFs4bbWyKVM/afwnIsZUY0gDquljqhlolQM8RqRAKaOIA0z2xZe8GpWnSfNGiU7lLt0ESuF3XYLLbCOC1b3V1xKYWdlIr1tVHB6my7RqvHpkycs+xW/9zvvk1Iln5+y256jwVj1iTIOnJ2esejW1DpytPJc2uVmz2lKjLtCvN9Rx8ywL5TszBMJIYSATnVdVZxfMIgiEtHQoyyoVsgW2LfGzgoa0iuLi3DlZR/my6ys7shd3hhPr1FUXzUM/mWK6s6wPZOXf/dON3O5h3N8uUK98ixvKrHrn+dnY9bTiqAsCKqIOGgCIt///gOOHwQy52gaQfe0BlHXWHZ2E9EdKRWWqSPoklbX7GtlXzfuy4lSJVItToTN3kqjtoKKGyBjhVwzTaq33Wg42qp6VKrZSG1ekG8tU0shBGXZL9iIgUVPmVjAaqLWN3t3320lZQ7p9dfdMHPusfUKTk4WHK0XdEEJZqgVpmwErSn7PZhFNHiho6qRQg8i1DbSddD1Sq6TV9umU1nxSWZzO+wyeQCGaufft/nhT+G/1wzYm3HwSdEyAxWu9hKuTdav+8juCCkc/jafaz6TTAnjyQMwP8CNfWY9NBc8z/uLTJ7YLZDHnWEP5oZo6h4KkSJOt6J1cMJW2/POvRW//+Mf8Dd+6yP6BPthx74I//3/93/mf/ijPyMTwSBOL6uPEQmJzdklF6fntFxRkwlkUGilcn52ydPHn3tbgzn8YEZqTtUkzajJb0aaF7gGMXoxFsHo1dF5Qw3U5rQ0Xv+U6WIhpYaERheVqA7xtlZRa0gziggtBawVghjHy57Q9yxDT9eUcfTmcYv1gqPlPfal8PzFM3IurFYrYohstjtO7t9nc77lT/7iz3h4/xHH90+4fHzO06dPUXVvbdWvaXnHsB9QWTCMhZIHLs/OSbWwuf+SfjDyyx37y0JtkSg+RyLetbjRE/seqXtqqYg0RgPigqY9RUHCAponyW0iK3VGEh/fQbxJg7Z2rfHHDK++IxR4p/n05vJFYbzroxBmnsG7rKtpDDD/yaZ14NZlvXbdvSME6Bd1tat5nF1Frj2Vwx8nCiKlVaNaBVVCGChjpe8LR4ulEySZg3y6boVKYMgbNECTzJBHuuT0XKJgs6IwddSfxQmVGpyRh0azgpK8tpDO32ITEs0rf1qmNKMWpTWoAi0YxRolV8TS5JX3gLlCo07cgV8u32klZZbwpwSeOyikKKzXxtEqsuw6yM2tXQZsamx3eQnnZ4FaF95VMmQWC+HeUY8Eo9qA2IiE7PRIJkgL0AxjdNbf6jX0KpkYK0GUJEbN3ptIRGitYBIPjfCuI39eXaiZmd+uFJVcTVOnWJoq97/hMOIMWJjDlyYTnQ1XE8eu/e64CDlM2IjQ6gQQEJkKDed3dKWIv2iRaK0QJJEtMErHiD+vqIVFgI7KT969z+98+C7LBHncMZTGn/zsM/7HP/4TTncDXTrytu7WKGRKyWC+EKo1KIWWC2WKircCu21hux0gGPvYMIVYhFRAasPr8v1nrA2plRAhSqNX6KKyK8q+BvYtkpt6oatWHt0LPDhZskxTTi0LFzvj9GyH5EhqlVEDu2iMrbBYLLh3/xgNnYcVK2iK03M2xu1u6psVuTzbMWwyy9WKru/54P0PearPyKXy7OwpTY3F8oijo8x+c46USrZLgnoX6bOLEQmRlxeN7W7L/SD0F5l7WZGtYXRIWJItTn26jHE0xBJmRggV1YFqRpOOKsGXbXGSZuZWJlRMM2bZR7gJKfQTF+JIoIE6e4XOxM7taomWyUCaATXT17fG75UHdH1u3Qwryp1jsNZ2gIzfhI7fHqt2UKDzuPefzWnE5Cq86TMj3DrE3eCnV8/CASV82N4M1UwIjVI7htyxsEBpDXQPU7G2Fe/LVQlIiBQbvREhmVJAdEkIwWmVGGg2s4h49wHqRIPclIg6EeykSZJFpEVMe0QKYYTYMqNl9rIhKzQWnke2gSLe/+FyuycXgdqh2gMDtY1UAYnrV57HXfKdVlKHFz/FdVOKpE44OlrR9x1RAxYElXp4+ePY2GwGLi8gl4zGBCGz2zdoa1Qd6usLrkN7p+zgZM3MiC0BvEndgwdHnKyPsdrx9PEZ+5IJ4q0f3hzB4/fjLRQmd/8OqPlXiKC9sfzC6MMvONjheF+inOZdTMS5xTw5NU1MQ8lQMx9++Ii/+ds/4uHDBwytYrXx2eOn/Ov//t/y8mKPhKUbA82I6rVA1SqVxr17xzx69x26vieXzExKYWOljx0nRyfkeEYtlTyj+yZF22ZPJwaI0fnvpE335WNPA0hpYIWkDUKhj/C9d+7z/qNjejXMhGKR002j5Mbm9JLWjBASpQphuXDm89oYhi0qgVwqKoGUkocbx8KiP+LBo4cMw8DzF895+fgFuRSOj49JU8GnirA9v0Aw7q9WjGKMww6R5v2sEHbDQC6+wOWxIuslD5awVEjR09uhF+iFWjNNGzEkwlz1JTgpsBgJQ2tG2kC0jKEg3lTRyOTq7APNIqNVdtXBFlkDNejcdu0L5SrW8OUyT503kTetk/Kc9fUoBHcSaFx5Wm9w7tdsehfAQhByrpydXbLdLjk+6SnVozgye39e4Hlo+dWYq8Rh7ugwt3Ofa0dpYVrLmq9rkpHQeah6ToVInHgcQYIg6sXkIpFSK2ZOcdSaQguUccFmXzg/y1xc7NntlCBpuhZfIGo1RH5jclJXFpOqK6KUnHW3Nq+aN3HW6hgWpAQpCTFVSp1bHleaFTaXe2IUHi3WpBRpdfRuruALEm2qy6rEBF0XePjoiEcPTzhaHXNxlqlT8aNpnPZ58+Xf5jDCtbj43AX4uyhvWtBoQFOdrHAP/SnmodqaWS0Cv/vbP+S3fvQ9QkyY9Hz66Wf8u3//xzw721ClRzR5GEIaUcSr4gV00XH/3Xe49+gh/3/y/jTWtm2768V+rRdjjFmtctdnn3Puuede+7rCZTDwzBPEfgEjEUBIkRPriSgIP6E4EuIDEgog4YeEgkiETJAsRU8iLwEpiRRZCR/8xIOnGBHnxr4xfuZyueWpd7nKWY2iV/nQx5hrrrXXPmedW9gcbj9n7TnXXHOOOcacvffW2r/927+J0bnxm1JYleGMWTlif7rLWXrce5aKgOq1G/N5RS1EZQiiiKJQKhuv1MtpaS0YHalMZH+S1R+MRCYmMDMJo7LH7kUwCkjZWGTRUtDFiMIKISkW53NSjOxMp1Q25wWq0mCM7r3hCWU1zn2eusCzdUfsOuqTef4c+5xZIGCs4FqFIjK1BmPzZ7RqOrou4lJEK8uq8RzFll1TMpuNqMYZMipKQ5pqnEmEmCD1/ba4UIsXclGmSoFCHGPV0Qp4AiIdIo4YhURAROFToA3QGkunDV58/tt3YO59WAR13fO3b198wosr+eOe83XHTlv/vvx12cD4ruP8rGY+bzg8rLK4lvSq/cMJDlHhoFY/RHUburfaQnSyPFd+WsoRr3Qk0URchvqjIonui8o9KuX9L6FyI88kxJQNaLNuWc4Nz45bns7nHJ2fc3rSIF2F1fRGMDvi3uV6x5uMT7yRSn0YLn1vIK1yszyRPqenspcuugApUFpTlhpjakR8DzXnpnfrxpPOa6pqREqwWnbk9h8R8BmrVYkoHltCVVlu354wqiwpeVarFW3XAaZf1LwQCX301bB53e9Ffch3flw1VNd8JDLQthVJCYqASR4VAtPK8j1vPOT7vucNdnfGLNrA2arhv//qO3zlnccEVRIwIDZ/5jGiTM4neZWYjCeM92Y0wdOdnoASSluQtEH5SLeqccsG7YQUNFqbC6dAhrycJkbBuayErSQr6ieVshxRDCgSt3YKDvdnKG1JvuFwrJmabHCjUjQJUuhIyWOMRveQMLroGz0nRqMxo8KyMx5BzGoC+YPzWJMpvGG9oigK7u3vUcTAyckJXdcxGo1yD64YqdsFo8oyHo+YTSZMpzNG4wkBxdHpOU+Ojzk6nbN2nmK0S5c8xy6yr+HW7R12x2UmZRQjFsmynq/pGr/pvKXJ4smQSL5D+0CZ1pSpJjrByg5GAtVIo3TBuoUmRAIp99IyQhRDkGED/fbiA9cZqOvX0oVaxIc9b7PfDzeD/3nDkO36Yw5w3pXHr6Oio4mxoF6vmZ/VuHYHq7N5UirPJfqu4ql3qAe1nDyfs8h2ioO17RmYUfrcviOJJ0pHVIokjix+lI2RxmN75ysFTwyGlCI+JLrOcXx0xgfvLHj+NLGqLUerOauuxrnEWIGovIfStxXxTtN+d3Tmvag/yV9l35I65WhG6wwdJQEfhHbl8D5Q14G28zjXobTp63MVrstf7ulZw3LZcP/Vlv19zXhckPuQZyMYgdlEUxaJ2axCRNHWgbqpSQmMKQgxZIkcoy5yOx8xtmtgr9/NP3r83hi2mx7/sgd78RlcMVxknbmcg8uxjMFR6cTDu3f54R/8Hm7f2qPrGpZ14Lf/3Vt88avvgBnTNB3J2mzUBxWDlOdA0sJod8bO4T66tIjJ0JkRhVa5X3NoWtrFCt0mVMxtPATQKddzCIKKKcsPub6Ls+pZniIMqvtWwd6kYDydIQhd7ZnohPJ1Jgeoom8i7YnR5+hdslhr5yO1CxRGMTaa6DqW5w3TqmS2t5edLgRjS7pO6DpPVeZrmdp97h9O8S4bsbPzM5QIbVtw/8FdXnvtNUbVGKUMpihpXOD52Zz950e8/cEjHj07whcVMQVWbsFR1/Hm3phb9/axWgiqxHSaky7SNes+vze0icw5piQwLTV3ditsJbQJQldglGd3r6SophydCUcLR+0jRYyYCCr23vjHmHkDkeeFxz9ifV1H2Bke356PL1s7L8B7/e8fByu5qbrF8NzLRlYhWIIXmtrhXCJv3xolGqX7jY6QJa7Y8Du2YLWB4tSnSQYjlnpNEUmbxpii816XenJaIYHKSBbh7j+AIQepdQEIq/Wao6OWxaJiHRNB5yL7EEHKBLi8ryUhBk2K3xWKExcyM0jCGE1KmeUnqr/ff2GujazXga5NzBcN3vv8xfZSIiIaFxw6ahbzjkSgqT2Th2P2D6Z9jkIjSRO8ZW8PkiwIoaMsKnzwdG2H1gbnfJaysfai/fzmnF+iHpHSBnuGy17dIC20oepCXiRblNXt8dJaj29iiAiqZ72JCEapLDl0ZbMQkR4a3TaSCbZw55ciKf3iyPhaQOuIEs/OqOKHPvcZXn1wD5Wg6zreeucxb7/3mPNlg7WaYjyl84oQElZpJHiUZCNlCoOdjpns7bJ364CYyASPPsFslWZxPmd1vkBcyLi7UjkC9x4lCpOEzkdKFM5FfHAUk4oQY9a8S5miO6kKxsqiJEdV05FBRQ+uRVud++jE3KbbdV2fAVB0wdOlSBc9RiyrZsXtvSkW2JuOeOPhA/YPDijLCh8iIcXNPFADYSBGgvPEEDh+9pzOOY6Pj3nllXv8wOe+F2srmjo3MWx9ZDSaMhmPc80V8Oh8iZ1MadeBtSSWMRJMYlwIEh1FYVB9zxm1Na9iyOuvNJZZKTy8vcdB8vgE2s2Ibk1VOYzRqKXHxRYTHVWIFN6TMNSJzA68Zt5l83FBIrrpfJYNE+iy0zb0PPsoaO+699loIwxkpq3c63b+VdFDwS+DtvvzUUptGI9X94Sr93NzTc3QfTfGDB/HEHMUJAqtMkPUB0g6k1EG4zNEWzFGYggba5tI6F6pUchakAEhJo33qd/vclG3TolpVWF1XvfGFMRgScEjxnDn7l26uuDs6BGLhScEwYWs4ZiKjGzF6HJrGVsgGG5K7/tEG6kNoYEL6z7QbgYPSRloO8/ZvGE5jwSvc1tspZCh91Qit40XQ0oK7wfk3VBWBdNZgTUKowokWVwnlLa54FNE6FpP8InI0IJeNnLiL4ukNsaEYUlJ//+VRbS9li6g52uPt+2tfVuM1Na5bKI84Gq2+3o4Qy5Ril82Bl204CN6ZFDBYZTwqQf3ePXePSRB3Xaczde89fZ7nJyeIaJRSmfoKFwojmcEPif3UQpbFAQSy9Wqj7YSEiJdSHTnSx4/fsx8PmccBVGKgCeknHAWUT2rUWfjic2zQl2wH4dShDzbUl7yKZAlY3N/JeciziVqp3A+5J5EvZqvtppKWYxUFBI5PJixN7LsT0d85tOf4tWHrzKezrBFlYkhtm/hKTnqyxp74DvH6fEJdw5mvPWNt0hpl1cePmA2myIYrLKEAHXnsaWjKA1FaVgszmiCw4zHzHWk8yuOFzWNC8xsIkVPDAofsuMmfad6FwMqQGk00UcKZdkbjZjZBFpThil0BlGrrNCyW2FFMW8F0R1FhBg68O5DZ18/uTa/fdS8/7D5eD1J4sV81bWvhWtZtQPz8Jsdm7P4UIdTch4Tn+eXFpQGYzTG5o3e+4gSKGxBNCEbm6BIUUPSKGXxvmO1qnG+o6osVZXz5qawEALOC2JHxFhCcv1Wmuf7yFRoNHiPLgwKk3P6SF/6A4cHu3z6DWHVPGV9vMYHg9EFWnQPPfYOaYo453Ln8xuMT76R2rodvk/pXR2RiI+BZb1muXS0bYmSrOobUw3EfpL1HoPOHJcYFEaBUn07Bd2hjWC1QiWLxmBUD8GYApKmawPeZ8x3qL1KEm8qT/Uf77jRPBS0ZCKDTonOO+49uM3nPvMm41GFEs18teYrb73HO+89om0Eo4eyNZ+9Mvp2VEqhVMwRkdLs7u4yGo3ouo4u5mjJiqISzXK94nx+jksBX/WQYeZGo1JevCkmoko4CWCysKtVmVKeuy7nsvCUMplAkzC90fWiMswnOT+QlCZJRBtNFM2nP7Pm3p01LiWq8ZjKKnaqiIQldw40Dx4s2N15hCiDMhZlNElnpGCjqZci0QeC8+jdht3OofefUlQjDm4/oyqXPcyYa1jaztF5j4uOV4Lj1mtLXn3nDFW2dAnW64bdsubOg5ZbU4OIYi8a9J0V9bpGzUcos4uKFmJAlEUli2BzpJUcKURM6rBFrhcLIXH3YJ+d/V3m3YTGLWjOPGvV9fWLN2zjMThK3+K4Wd3U1Rd9G974+pO5RJS6eHg7lwYQialDGygrnaW9bE8Yk1ybGWOv3DLA5ipLEUWvWC5rzs/OaNqa8bjI4rCS86nZzy9IwdCEgs6VhJjLBnxwmTShNIUYSq3QkhmqXefxMauzx+gx2nDv/g7ztmXu1rSnjpRKoCDGRBb7ySiHc92G5PNR45NtpIYW8XJxf+OZqOwFxBBp2haXifn4oIGsZn0RrvfN3nt5kMEnHuCcmBqA7A2kgZHSJyxVQdME2rUnRMkevVKbLyPdsLHXf3xjO7r98BUuKXuB1mTPbncy4bOfep3XHz7EiIEkPH12ype/9i5N6yl0iVYZPkuA0qZn9vVsJ1EopRiNKm4dHnLr8BaBlL1/EawoLEJ9vsBWJaO9GamO1K4FHTE2kwM6lRCtsUUJlSboiISUX69ULsiVrIyB6MFcoXILQURblMkqKBZhZAvKpkXMmhQSf/Q/e8Y7X1bslHfY298jdA3das6dg12+57NvMB1PMLYkosAURFHUXZO7D4vOCiohUFQVbWooK0Ndn3JweIeDO7dz/VHIRaBacsSjtCBtvo6yMqi7u5wfvc95s2Q8PsDoPcL6jPOzFVMpGI9LjFYYk/j+H51z+taK9jhuSiyciz0LUWdlAslSUVkhpAMaYoqgxhitMx3fCKGGogJTCk13s8zOJp7aeuo3q9t3U7bfxXtfJ4f7rY+rBvOS0sTmh57E4KkqzXhSZAOlspMiYggxq5YoSWiViJIQDClC3bQcH52yWCyoKst0NmM0GkEKmana5ULbroPjecvjlWexjMShFhRP6CJt3dE1iViBSZlkVJiIKIt3AYejqAz3HlQ8Ph2xrGvqlQd9sWfm8XKB4evGJ9tIbYCyK7DAkLvpWX8wkBJMH9mkHoobXjtIj1xAhZuoTGU1ivx71pZLvXSOoEhBsTibc3a+gNSzCnv5hdj3AhogoRfP/WK8DMr4vRgf20m8wYl+nIQy9BykFKms5cFr93njtdeobEHoAs+eP+N3vvjveXZ8ji4qUugLdCVriMSYZVrU1ncuyjCbTpiOx2jIhY/94ui8J4qiHI945bVXOdg7pKs7js9PEZuYTCpUDJgkTMYz1GjMPEbeOT4iuVyHZWQors6dnQcjmVPRQ6fhAtEJCLkQVTRJMqwpvRP0pd+5g+IuXdeS2sBYj/ijf/CHKF77Q+BGBG2JqkQVI7qYMuPOO5TSGG2Inaeta86OT2iblq5p2N/bpz3RBAXRJwplSWKp1zW+6+h8y7KeIzoyX5xy9I2O3/7KezC7RVQj2uOCz94yuPsVO7OCta346vMlpmzYG1U0kvBRUGLwIbEOHUaDsr36iwJdKsRotLIkH3DBk2gR5VA6q3BgEqpX87h2eVydQN9iNHM1YhkKeG/62ps8OcHHWsyyQX7yC1+ELvuUQb+vVCObjZTJ0JnSiuAj9brFuY6yUOhxH5umzLw7PZ2zWCypqhGHh3uMqlF/LTmSUUqxXHS8/2jJu8eO503BWlWgDUoCMXR0XeIbX3nK6lnL5964y539cZ9X833UlXv1IZFy7Hjl1T2Wa8PjxmVYeuOsZmKGMn2d4Q3Gx3bzf/3Xf50//af/NA8ePEBE+NVf/dVLf08p8bf+1t/i/v37jEYjfuZnfoavfvWrl55zcnLCz//8z7Ozs8Pe3h5/8S/+RZbL5cc9lZ7bQk+wykrUGSOVXJuRQEtFpacUGKoUmWqhUlm7LSUhJMmSHVFQqsyRlHIktUZpn72YpCFVkHLLbnQkFTk52TrLYhlpO4e2HWXVUhUhJ+bTFKHskRlB9KDEkFs2ZJHToTHj9V/YJYO7lcN64TlXPLEs+sgLP0PQudlge3v9Uet/U80f08Vrrrwu5+GkV1NOg6bqFZbS1rH6n0j2/GKfqzncP2A6HlGva9brhq9+422+/u4jOl3hTEWDofGKEAwGTQlYcaTUEHSgUUJrLKUtqBDq+TnNcs56MWe1nNOGji46Uqm588ZDvufHv5/v+8nv43N/8HP8wE/+MD/4kz/G9/7ID/OZH/xBvvdHfpjv+dEf4fYbr6FmFWLAqoSKHTq26NShQ4OODSq2aBV7yEWTYoWPGkdHVA2iPBaDcZYilRgxVJOKZ6fPee/RB3SuYW825v7dO5TVGDEjsDN0OUObksqWFEVBVVQU2iIxETuPQme1jtZzcHiHnb1DEhpjCoqyxFQFyYBYIRnQhaaoSlJSWDNib/8eRTXJTT9NoiXhTYUdHaD0GJuE2xPL/thS2NwVNiShw+BMgVMKpxNeRYIkPIILjs5FvKsgjtAkSmmZapjqEcIYR4nXpp9EeU2olMsHDGkjmyQkYgqX8q3Xs0aH3y8IBy9bH5fIPVutU3KagBd+FDCIsA0Ne7bn/maNbQCEuHXcHqJlmBv5FUqBIqJyBikLBcSU11UchANykbhQotnN3ZFNIqkG0R6UxgXDuk50DtA6R/ghYDCslh2LZYutxkz3ZoxnRd+A0CF0hLimC5HHR2u++vYxT56vcK3DBs+Ejol32LrFnz/n8dff5cu/e8Tv/PYJ735Qg9ZY64l+jVEaEQti0Fqxu1Owv68Yj2qMWqEJWWKLgoRGW4XWH7Xr5PGxjdRqteKHf/iH+Uf/6B9d+/e/9/f+Hr/8y7/Mr/zKr/D5z3+eyWTCn/gTf4KmaTbP+fmf/3m++MUv8s//+T/nn/2zf8av//qv8wu/8Asf91RQxD4CyvdSzAbKBwgx4H2EKFTlmFk1opKIjjWSOhK5o6mYAmULjDFkCE+BOGJaY2zCGIPRFYoKRQFictW1hRDh7HzN2WJNURXsH1bcuTPi1u0xk6pAY3KhXZ/ozO25AxD6PEVeICIvN1LARXR3BTp7mfzLtQrOcs1DV43McHsF6tjO/F3Enpd/ts8jP/fym344vJLwIfeXsbagHI1JYlitW772jXf42ltvEUlMxiNGo4LRuOpFgQUluROoEIkEkkp4SURtMNWILnrOzs9p2jYz0aqK8aiCFAnBM5mOObxzwPRgwu6dPe6+cpc79+6yt3/AdLbHeLrDbHeXyc4MsaYvNs5WWjZS8QnRQlIKn8CRFaXV0NRNeUR5tAoUCGNToVyOxpVOnJydMJvNePjwFV59+AqHtw5IojMeVkxQxRhlSowtUErl6xUyLT5GmuWa5WLJ3fsP2N07wMXIZDrLcPTQlVciSYOyCtEKo3M7b2NGTHdvsX94h8a1rJsV1WSEKceYaoeimDIpS27NSnZGFhUdOgUkZXBTaY0qBDEpb34q98tKKRKDEJwl+Cyaq1yL8Q7lBWJBVAVRmwtnJmWDNBgC2QLfh/9eNm6SX/qowt7rjNN2pCPb/20fZ2shbCKpa459cQ7DcRMiWf9wuNaLgwzXn3mgJEGJpTAFRaGxPdxXNx3n52uaLmLKkmpUYZTGmorFsubo5BRlNNOdMbYSULmzg9VgjSalxPHpig+ezjk6dXhnKHXBiEjVtei6RpY17dkppVTEdpcv/7sFX/ziE54dnSEaysL0n0mG3bU2FIUwGcNkFCmMRxHQKZPRYv953LBTx8eH+372Z3+Wn/3Zn732bykl/sE/+Af8jb/xN/gzf+bPAPBf/9f/NXfv3uVXf/VX+bmf+zm+9KUv8Wu/9mv85m/+Jj/xEz8BwD/8h/+QP/Wn/hR//+//fR48eHDjcxkYI/Rh+8YzTylrgfVeTFlq9O6IVWxwyzazrowg1qBMiUoFOmkqBc43pCQYbbCFZmghH2Nu2CX9wjdG4bpTzueniAQOD/fY26uYjCuSLwjdnK6pqd0aU/X1VT5T4mPKkM8GU7yJLsx3eEi/ci4laz/GKb2Y9OXG8MywIRkBZTTrzvHo+Smnz57x1X//FZq25Qc+8yZ7d++StOL87JSjJycszte4kIgMRaEBQWESlEpR7Ixpy9yeYGdUMZlOsMYSOkdYd4wxHBQTSlUw7zzRObTKdF6tFEVRUCpDYUtmZUWR+poSrUnGErVkNiAadEXjE94HCi2UWrAqU+nj0NCRLLZqdELrbOxG4zF7e/u89vA19vfGHN7aZzKd0AVPoRQYlYVvVR8hkNmBm0hBwKXI/q1DZru7oBRekVuIaH0BackAGSmiylCj1hoTDaNxyZ07h7x3Pqf2HZXJRl9rcitwYyhtgbWGJIGCQIhZo1JJoCrK3H9LZUMSU8T1ws8SEylkoxVCh0uOdiNG2hJDdhgl15P0jtjv31r4dtUYvuDoXVOg2/925efKtachv92CZFJWjtINXSN0TeLsdIG1lqKo0EbRdgalC87Oj2ldw+7+iNFEU1gQIipptDKIWLqm48njE549PqdZgR1BahMBjw9dhpDrFvEaHzSSLMFp3n/3hGLU8ON/6BXGkwnrtkYbhQ6J5BNKFGVZUlYV3quMLEpm16aYNnv2Tca3NSf11ltv8eTJE37mZ35m89ju7i4/+ZM/yW/8xm/wcz/3c/zGb/wGe3t7GwMF8DM/8zMopfj85z/Pn/tzf+6F47ZtS9u2m9/n8zmQFadzQZlsYKPhumWoa1JZlqbasRA9Tjw+QieKaLIQY1IqJ7/bFtetGFWK3b0dRqWj75KTWTRa546tStOuFzRtjfeaw8MZhwc7aO0wRnChg7RGmZqDHcNoWmK0pV53rNcNTeMIPsckw/nf+Bv7Do5LHmL6Nhiqj3jO1oMUKqFTYLlc8eWvv4NoRbOYI53nc595kx/90R9ksjsmiWe12uG9vTFf+soj3j9a4zB4pTBEJHlsiox0ImqIlaXUI0a7U7QyhM5RzxfEumV//5CZrVita0IIORKXLIyqjUF8yN97TOAjEjxWK4xRiM5agwFLFEPSJWfLFfPFkr3ZhFszS4VDeip6JOOjVkdSbCgKC2RFjDc/fQuVFEfPj3nj3kHOs5EIg3KARGIPieUmIJkNFwXEFOwdHGCsxYeIVgY7UrRtjdZkUeSNtJbq1QgGDCsbqt2dHQ4OdqgKzbprEa1IqUUlnyeAThlS1JmooYLrj6nQCHi/+SpVH0Vlg6ZQIT8vRUVMAjFlwVojqBSIvtuc38X8u/mc+3aMb4rt9y28xzb9vcdCruG3b8ORkMSBisRU4jqFb0e4CI8/OOPk6Jx792+hVK5virLL0fGCx89OsKViPFaMqt4JTKCTQmMIXrFcKJ4/q1meR0KT4aFlt4Lksiycz7VVVgqIJUomVKXFtXPee/uMV17d5ZXXx8QkWXRYB0IbCEHyXLRFhpE3+bZMTB0cppuMb6uRevLkCQB379699Pjdu3c3f3vy5Al37ty5fBLGcHBwsHnO1fF3/+7f5W//7b/9wuNpSFNLBgQ6F/j+H3L8rb97vqkhQYYi2RzJdD7hIrg+T4SAlswKSz5TKa3VFIXj5Ejz//i/7GKNxWqTC+YSdI2jXS0gJabTioP9CdbG3JJeIjG22NJz+/aIncMp1ahExLI4r3n82FGvmz6iyrTptDFW34Yv4ZscVzeHb8ZAvdh65GWwyouPq+iRpFnVDcdtR1SaQuCzDx/wA9//OT798A5dO+d8fsR+aSlfu8P5vOPp4ilNsngUWgJCb6RUYlwWHOwcUJUllS3o6oa27iDAqBpnDTyy2Oq6c2AtYi1N8PjoMZKIOtFFR9M1hOSpCqE0oFMgRU/SGh8Tdd3w5OiU4+Mj0oO77E3GiPJI8kj/RUtKFFZTWlg2DSE4fNtRFnucnc6hXjMeT0gIxWhEoC9Gl9jvYYkY+3YWohCdI3olmrpuMUWBJxFSpKgqguvya2OEQaWcrLW2kcxRmtGoZH93h92dCUdnJyhTYAZYM/UCoopswNHEmNlkMUhfE9hXpkmWDRNSpt/39YKSv2CMBhB0qhh1WccwxdCjFVfmx7fotMnW7UtilEtz8cNgwI/93h8CI1wibQzG6RJPon9MhrMf/pgLyc9PAx+8N6deJUIHT5/Oca3j3t0KUpWJEueed989YVnXvLK3y2gsFDYiQXqY1iBeEYKmaRWrZcJ3fXbXKULnoHewDAorBcEnrJ1AKrMyjyroWs3pccPh7RFFZYnSgmSHJYRcZ2hMJl9kIzWI3PYOjr6Z+flEsPv++l//6/zVv/pXN7/P53NeffXVLbpBhhaOnif+J//jETsTy6QqsT0F2OhcU03SLDvN8RpOmkQTc4vvsU3MCmGMUChhNhthjNB1NSlGyjLTzUNMtG3NelWTpMMWht2dimo0dFtVeNfhuoaygnFVMJoIxmZD6UcWa3umX4KhZbNwjSPVj0zVHBotciHNIi8+7+r4KDuzyS9dWZzbkVSGYi4fL5/Ty983H6M/xb6T8VW443I+DZCU4QJt8QmSKpDCsHdwyO7uLq5Z8c7X/x1Pn77L65/+NNOD19jdmVKUZ0iXv/9EhBCxOlIRmaGZYSmixi8bfF2TWs+oGjEqSqLVtCrREOlCpNyZIGWJ6zpaIoUCryGqSJs8KKgsjJWnSAmTPFpJT/dNdF1N29RooNCK1BdEpqgzTwbBaMV4ZFjVDaTI+ck5y9ZwenrGQZUXt/MNav+/QVtDMgWidP48U66FEZGsTBuzQob3gdFOLkb2MeSeV0qwMfaea8Q6T+FzxX/wAe99LyOV628mr3mq+8949/0jSgW3JhW3tDB/925v1BQhCVFP6NSE2nesljWkrBBSFoaqzPNbqYS2gjGZYjAUfCJZXzNEkw1nIssnYK7d0y9F5lv/vux5F+y9izmspGeWDcjANWvgZaHb5dqllyy8l4wPg/sufh+Ms9rczwjQZqVxQRuIBA9npx1Nc8qjYk30uZ2L1sLZcaQqG5xb8tb7C84X59x7Zcze3oyqzK1lYhCIBrQG0YQgeG9wnSK6gE02Q4kpklBoyXVySizJalqXSKFDKZPljnzCdQKpyM52WpMIOTDsk3NK9ZJNw7X2nSVihEFB46PGt9VI3bt3D4CnT59y//79zeNPnz7lR37kRzbPefbs2aXXee85OTnZvP7qKMuSsixf/IOo3IxQ8v0QIk0DhdWYQb4j5XJLnzJ0E1C0LuFDgY8aUgdkmG5kCspepDZHV5qoQKEIIbBa1azXa1wX2NsvsSZlpk1q0aYg+YDvcoHndDKmqiza5LyEiM55CHI/pqHGN3+X6SMsSm9O0s2Cmwvywoc/O/X6gBesOzZrcPBmpY/wNp5pShen0y+86/UCLxb3CzyOazaF/JkoksqtAzxZWTm3fdCs1ktOT8+ZL1c0zmNax3pd535A/UJWJIgORcI3NfXxGfWTI/R0Ruc6UsiSReWkwFQlQQsuBWrnMjRhivyJaYXvLWxHRCWPS45AwKrESEGpQG/a3EdUyo38rOSmi65rUCJoUyCq6I2MASKjUUFlFUqE42cnPDpe4LxnfG+X1XpNOTIU+7+NP/s5QsgRUG4/onNbd6VIPnfHDSF/Rz72oEqfh3KN6+nxiug9wXt85+jalq5p8T2NPSYPqcFJAjfh8bunSNeg71l+7Gff4Yvv3kMpQ0gJF4SnZzVfeveYs+NzTo7PiCGiRDEelezuTJntjKkqw3SkGFUFhany56B1Rhq0wXlo2o6UMoHDDc0EGRyaC+dpQ9aRD9f4uwTZpX4uyKDUnueo2hiA4b24lCLYPtbLjMpNhmyioOvPczj+0JstHx/ou1HnFie9vJukjaEYeud1a6FbaVSve6jE8e5bx5wcn7Kqz1l2mnIsTCdTxqMCLbmdR3BC8pCsIqmcy4wpS4jE2Nf3xcw0VNKv/V5ayccsXquNIOJQ0jCeaMaTirKsiNHl/TixZXjjBsZV/d8E2cg6pZd55lfGt9VIvfHGG9y7d49/8S/+xcYozedzPv/5z/OX//JfBuAP/+E/zNnZGV/4whf48R//cQD+5b/8l8QY+cmf/MmP9X7DxB28+xAjnQs0LRRaY5TFaJur/VNDTIHOJ5ou4Xym4BqlKXVgVAgjk7AimUYMWC2kpBFyXmy1WmWvtRqzMysxuqMoBKU8MUBwCu8S1lSMKotonzXbiGils3yNj33b5F4+ScjKFBsj9fuI+d109J7edZXyV57ITa4nIQRl+/bVqo8u0+Y7bV3AloadO69Q7u8xPXjA2TLy6NkJddOSJEcOWoX8neFZrxre+eo3CMuOW7dvUxQFKMFWJcFUBDShyOoWvnWMxDCRApMUwQ0RmUFrnfNDISs4a21QKnerTSGQkkF0SegC0WcKcfKeGBO+GNGFuGmCOfQnG49GKDkjhcBqvuKD99bYScVOJbRdl41PO6E++Sy6mlIUBVp63UEsWgpSCJnlHBLBe0JK+JQQo3OONSVEKeq6oa5rXNdxcnzC6ekpR8+e0TYBo2Fnd8rtW3dJhWV+dMi7X3+H7uyY0XKPEJ4TY6JeO947PsbcOeLffqXh87+VqFct3iWMylGRSMIYoSg0VaGZjhKj0jKZ7LIz22G2M2YyLaiqiuA1i7WnaVMugP9OECV+/1O8Nxvp+jWyzeTNn1DPeUxZ5miIvozO0dTZacPZmcO5BsqCg8M99nZ3ct2UhOwgRQ0UJDE4AhiwpcYWBms7dKA3Uqk/rV6oVnI0bmxC6TUh1RRl5NbdHfYPx2gt+Ngb0uSJIW4McOy7VRvJzufQZDLGSNd2N/qIPraRWi6XfO1rX9v8/tZbb/Fv/s2/4eDggNdee42/8lf+Cn/n7/wdPvvZz/LGG2/wN//m3+TBgwf82T/7ZwH4vu/7Pv7kn/yT/KW/9Jf4lV/5FZxz/OIv/iI/93M/97GYfcAFbttb+xgizkfaDrqioPSRaDQKTcL1lfAJ5yMxZmzWECiUUOmIFp+lkFIkBAgDXBJzLqAsSyYTTVWM0SYbFqUiSuVvY9hArLYYrbLWluQKC0Hhug7XhU0+YBjZ0GZP7RNgojae4nbPq5c+70O8yu0nBrH4np5Kyn27JEaOnh/x1jvv8frrd5ndfkgRPSet56tvvc+TowVEjVYBpRQmOayGorCkznG+OGexWDF6+21GZUVZFIzGY8bTCcWoopiOMWUB3rE7HlNUY4yytJ2jcBFrwMbcBlv7QImiHO3QYTlbO0KdIUApC2oniJ1SjQMhas4XLauuZb5Y0TYtVVWxM51QjYoMQfW5mkKVkFpaH1g3DdPZjKIoMFpTKE2zWqNDxGhFaDuSBhcc0YXMoKpGIDrDjt71BhGc8ySl8SHy/OiIb3z9G3z5y1/m9Oh4U/TsnGN3Z8r3fd/rPHj9dcbVBC2G0pRURZVnY1ScLRZ85WtvY+485uhYOD1VCCaLjCZBG0MMAR8CyoNTwvmi4+SsJoY52lis1Ywnlv29XaaTfSSNabuE80OE8m20KgNUnbhUZnG1dlQYIO3/EMZF9iyvqUHNZIi+4laebvi8ckmLKL8RoS2LHZKJ7MzGjCubZaeSgligKBFTZccpdeiioqwM43FftJsaClsSehHaKJkv26N0aO1QtqGwNbfvTnntUzvs7ReISrlnfLKkmAluec+MlyLQlMA7n61Ogs59mG7jxfjYRuq3fuu3+ON//I9vfh9yRX/hL/wF/vE//sf8tb/211itVvzCL/wCZ2dn/NRP/RS/9mu/RlVVm9f8k3/yT/jFX/xFfvqnfxqlFH/+z/95fvmXf/njnkqGs5HNbphptRlaUENRaVLkNvM2F42S4SGjClK0eWMb8guie2kelSOeSE/1Tb3MzqiXIhngiYhIyKrZSQEGa0q0GEjZ6zZKiFERXGIxX9N1Hq0sMecSNwYqbUEe/6GPAQK82ZMv7wLXQn0ISQqCmCyh0+syF1o4PTnmS1/xLNuaamfMunU8eXbC4w+e06w9urBZ5JQOowKTScHOtMDUgi4q5qcr1os55nyOChGdehhTKarJmNFoxKQseXB4SJyv0TtjglW5XmtqqTx4JYzR7BRjOhTvPT9jefKcZrkAURSTfYrJDlqNUEXkyfM5X3/7Ec/O1tRtIEXYmUzZ2xlx63DGdFT2ivGSC3qrEavUIqI4ODgEhOADsXMUqsCvah4/fsTjR49pk6VtXRZ1NQW3b9/m/oNX2Ds4xChNoM9rtR2Pj4740pe+xO/8zu9wcnzM7s4uD199lVcfPmR3Z5eubVmvl6wWxwSfGI8n7Ex3WK2XWFMg5NrD5bLm9GxO03SoVFIYQ2FHaG1p100Po4I1lqq0jKoSpKKuG1rvaFug85wuVxydrjjY7Tjce4iPhhCFj9es4+ZjM9M2mOHlafsfhnGCLTPKhaHKwrFZBLs3ShK2SBWJhCPRMqjgKEokGcqxZlJZrAKJEaJBURKDRcQgOuLxEBu6rgZxFEVGLWLsEJ169qhkFCEljHjGU82tu7vsHuxy596Eg8NdRpX0ihOQosJ7UKKJ0eF7REGp3Ggxhoj3vZGS7yBx4o/9sT/2Us85f6jCL/3SL/FLv/RLL33OwcEB//Sf/tOP+9YvjCxFk4AMq1mrKEtFWRqstX0/qbTx+LVYclYq5V4pJPQgYx6HCvXUe2GBGHzfVVQwxlAUBT56oou9JywItge3c8sEpQAJJBKFtqg+X9a5yHrVZAl8ZXPiuyclCKqvSN+KpbY385QNcY7Ac9fNnE7aSkgi1666gXDRPyMfKl3OI6WUGFqCw+BxXrAlXlAvGdYMw9rP94ZpIVc2gxuxpi4Z7Hy9LkYWrce5E85rB1aofWLZOFKXGNmSFDoKEzA6Mi0Ndw92uLU7ws0N3dkZYWxQk1EufF0sUS6CE0ILresI84ZOAs3jJzz+4H30eMTk4ICDW7extxKl1zgTcKs10XUcnTd8/e33OXn6iOhdjhLKJboYY61FfEdoFjRtg0OjVK7BOztfcXZ2yslpwa39XXbGMwQoJbI7Lqnrhq5taZs2a+wJ6BB49uwJjx8/4fnTp6zWDafLlrrucK1DIhwe7PPGm8d86tOfzr2nygoXAsvFOV/+91/kK1/+Cnu7u3z6jTd5+MpDRITz83NOzs7YnU6ZznbY252SVeQT+7Mditaxu3OA6HdIClrfZtFlXaJFsNpQaINSmjaRVUiUyoT0ZIghswF9EiBDo0iu20pE1m3HbogoTKZVpO35sqWStwmytmCva6bSC9lQyXsDcjGX6F97dSq/EJx86FT96Hm8DdDdbGznyLb3gLRZeNLD3xmUyBFU/j1kTnkv0SaorOAfFVoUSiu0yRql67rl0eNzQqyYHIzpoqNzS46PVqy7Nbu3ZljGnJ0saVqfnfuB9KIi1Vi4/9oen/3sbfYPhbLo0DobyuATpNxZ2vlI6zvatqZZO1wbCD73UhsMHtBrdX4XtOoQNNpEvK8RPIUpGReakTUZgsODdLmbbkwYU+G7FVoJIdV9kaTrGx9aEr7/EFP/gQ7aVjnh7X2HCOi+uh6y9E1MA0MtEmWdDZjKStekzFirmzXrts09jVJmvUgECRHde0aRYVJeVLbrPvUrsYcHRTb6g9sL8Ho7kCf0VV5SHCZ8X/isenhEJ+nlji7rmyFbJAnypnTdW73guV4zBqma4dgZu479jyGKIimLFyECpR0RRJivPZGIV4IoSzHSaImUSqi0Z1YpKh04GFt2dyY04jlbHdGUkVpb8IE9MUxcIqwVzo8AhQ4rkl/TxsD5owVRSkZP5hyNTzjaP+Lw7gF+FDhLS45OjnjrnSccP1vSNgFrS2JUrJcNiab/jLMDpExBIjEZV1jRdE2HC4n5uqMYOSZllsGZqsBMJ5qRpbSaZ0+PUD/4BilETp495htff5tqusMP/fiPIbak9YrF+Rq/drimoSoErTyaBvwSNHRrz/r0mGmR+PE/8H2MJvs0XaIa7fDlL3+Ff/2v/xW3Dve4fWuPe/fu8srDhwQiO7MKqxL3b73GrcNDQvoCjTiijjifiFGhkmFUTCnLEU3T9olyhagCpSuKckpKAc8qtxZJCUJCFxoxQqBDTCLFBu09lWRmpSTNUFCeBgi5n0eDk7RhiQ3rpEdRtp1mnZWls1YiOWJOWm+K/F8c/TzvIxTZsmSy5fhlWsyLZCTpz2dwLjcO29V3kevVLmK82l8ubM5TyMr1aSBUXHb9AEvyqndg+3IAEiSNSIG2Fi81UUWWbeCdD55z/DQxHu8RkqNLK+btGaPS8Nqn7rI3O+Str37AO994RggapUtiCqjU0sYFs8N9Du6M2Z8oVBJ8uyJEj48J36MgnkAbVyQJ+K4ldYJKmqgMJIhaMpEsdbkh2Q3GJ9pI5d0zIgLrpeZ/8V94/mf/eW6tIdLTT4dC3QSiFE3r6ULPJEPQkig1FFayjpbKEyn2bJbhfTayRP08CV74v/+f7uTJsYlM+h81GI88rUKIdF0Of3PQcxHeS5KLCGcA07dH2jJEqIsIZmvCvzxSCcOn9LJPb2OENr9zeSF9WM5p+9gf5Td+1HGUpPxD7KmpOuuc9QwmSeRGktFDaLHVBFONEWvpUuC4WXJrBJXVHI6ExieOywmLo8CztsWoHOlWRjPa26U0+7mAtxPocsG26jzBQdO2hPaU8+dHPHkyprg1xk0V7z96zPOnJ3RdbuOi+qZtw3VlmHlwJmAyGfW5JYvRmrpVNG3IZI9ZwmhNaBukU+xPx7T1ktOzU5armiJ4Gtdw6/Yh9x68Bqpg2TqWyxVHR6c8ee8pdw8P2b1/yK1btyhHWdC1rEqcy0W2h/u7rJtA13Xcv/car77+JvPzJUo09+7epSoU87NzXv/UG5RV/n72dneQVcn+/i3KsqIYFSQFtqwQqREViKnFh0RKHqUCoS+TCBF8MBtIPMZEin0XX2VABRCNsSb3QjIWayyOi0L97RkiW//2M/Ny5lYuIwKbx/qjbNm5K+tua6TL78A19/PT0ksfv2yg+td/BAV9e2xT5weEJA1GdouR+OLZX/48NvuTREJ0xFAhUtI1nsXCsVxETk4azk48MXmcrIm25ZXPvc79B4dMyhHL8xEfvNfhO5d7VinBRY+gefL4lPu3bnEwPoTkMqlMAiIB5xtciIiCGDXrVY6kUqowqiAERej1F4dc24AefdT4ZBupQf5Iaf7bX7P8v3+9oCg1hVVZ0kUJ1liKoszRhxgeP19y3im6ZElKU+nA4RgOp5qRidgibzJt1+E6B33Uo5TpDV7eUK3N1fq5Q/3QDXjQc1P96eUiyhA8Ibg8oV+6WX8MhFy4gYG68pK0fSsbSG5jmD5kgb1wrGuu4aOM0Icej0wZ1img0eiUc3S5xoWe9p4neKkC4yKhRoZaGR7Pa87P50xNYH92QFUZirDApBUjPaJerTk6q7GFILQknRhVljSegIbRyLI73aNKhtB2xKaFuiN0DkkO14E0hjVZKdq5nKAejNFgmLz3eO8xxlBVFba0KKNo6pqAyzmenopdFgVlVaGNQWvhzVdfpSsKvvaNr+CdI6ksD7VzeMChGRGd8NV//zVsOeLuG59mdbbmt7/wW9y9fZsQPkdUt3nwyh1m0zGmKFFNburpG4dJitnuLtNRhRHhwd07/Ngf+CHu37uNlpBrqLShKHI5xmw643xeM6pGGGsoyzJD50b3SfqMImRD1RKToxqVuclqcviwhCAE1XeOBXLna0UiImKzMnoUvAt4993dcG2bIXv19qqz+LLXD7fZ4YwkHBCIUZHChPVixZMPzjk/cXQNZO1QT9SR8WTE7YN9ZhPLuIT790acvDrl8Qdz6nqOqILSCkpVPHs85/2d59zZ22U6tiCWmGKOfPEolbC2IIWK9XxJswKJFiFr+8UYiSkzp5UIRn8XwH0xRrTqQTGVBWIvUzrTRa5HhJAGxkkf/fT/yVAtr9XFZruV83khVB+8NcmNFUUiqq9FuAi2LlhLItKrWFjqLUmkPjn0sa9741FeMVQvK+jlkoG6UHC+uK4LQ3Vjo/cxPMWbDE1CS9yof0RSZsYksFojRhMloHG0Tc18XrNMJedO0bYto1nBbDZhXGkIC0rlGZkJpS4wyhGjZ9nVxNiRVp5mEZGqZDry7Fphpg070x2mO4JerWA+Jy1d7rcTIs3KE1wucPR9hF2W5YYQ1HUdbdtmlfKqQjTMVwu69ZpSWWbTbLyK0jAaVZs6mc997/fxk3/oz3JS1/yzX/t/spwvslq+VtjpGJzi2QfPqBc1rz98g9nOLikExuMRb3z6DV5/43XGE81oOiYpaLoWnwJFUaBiorCWe7du0/nE43ffQRP5gc99jma9RAhUoxJrLFrA+Zip+tSICN57nHO51ooMlxVF1rT0bmCWRYpSYYzGuUCIHT4EohJS1H2HrYRzHqUTZVlQVWOMKXNtV/i9oy9cP7fTjfzDl62Lb3XeX7eOrhqel0lFXX0u5HVtbKQoDSka1gvh+dPA0w9a2rroDUPfHVo8pakolEZSR1lE7t2tUD/0kN3ZEc+frWlaSKKzzqmdMJ1OQMD5XsBbZwWTrGgScV1ieQ7np4FmrahUkWWQyEhGirktve7rpm4yPtFGKsWAaJu/oL7zaIxsDNAlBFfI5IgUyVvi1uTsIxPVT4ZLbY1l88/mOLllhWxCc6V6mZle8FO2WtqnnuVXViVVVbJcRtzm2+kB960T/fC6o+3r+ZiRVH+reiu6iaASGXKUF3HzYSO97n2vjo9arB8Kd6QcSamUyCGvQm2SxsJP/4+O+dSba0LKvW28a2h8IIpBdC6UHVvh1dtr7u2NmEiHTpFbC3j1P22Y+0iUhHYNKji64Gho+N//H+/z/KShwrM3Tuw7z+2R5dAKs90JxgjRJ5L02nNRoZRFUodSWUBziKK01kynU6y1OOdYLpe0voUYCSnQtW2uNSn0pc/59q1D7h4c8upsB9eu+Ne//RvUbZu9U23AQ1FU7O/uY8XQrVbcuX2Ln/7p/yF7e3ughcnuDFQu6NU6F4177zF9bZ6SxM5swtHRGcl3jMsSQ3asirJkVJYEWmIIGGOY7eSmeN57WucwZW75UVYVWilcl6jrNhsepQghtzJXknDe4Z0n6JzfVGhSTPjOoxSUo4LCVhSmyjI6LzS9+NbGt2o0vp3jskzYzcZVROJiPV6/L7xgqIRcWJtgtYzUq5a3vnbK4/dXBD8ml+tEtAFRGrxgRGOIaNViCs8rD6bsziYsl8Ji4Wg6h64M092KcaWwpUN0X56DxnnwUWjbjvOzluOnHefHjuSKjFqEft/pc89DZJXidwHcJ2qA1Xql8pApszGQufta0FoRgsfYiuRDb8mFFGIvN5OPkUNRUOnyhNjGhLelTFwMmT24GYnUq3BfTLHh/OgxeENWiQ49FJJzVptmiz1VMxtMtTnXfB6yie7SFaP20s9nA+hdNM7YvHQI5kQ20VYiR5o3FX584f2u8fxSzDSN6wzgcJthoHw+KWZBVQGKssKtWn7kx4/4r/6rHc6WiaBGRD3GSuDe3oR7exUzE5kWgj3co55NKIwieE+7mHPuNOtyF10WsDzl/PkJ33i84k/9T4+Z7VacLwRjI89qx9I5ThaBV0aG16YTbu3uolzEi6YUTVlWrDJeQlEUG4MUQqCqKsqyZLVasVgsCL3CidIaLRrvPXXbIBoKo2E2Jfa5yug9VmneeONT/Obv/hat8yCKcjyhGFeYNGZkFsxXa5r6nIDm7v272LLIBbLjEl1qQogYLVitqGxBqzOzrlmviCisVezMJqidWa880QzTA0lkGNIWHL52n/Fk3Gc0++9JCcYUdJ1ntfSEkCEghRCDQUmBLkpSaolJ40NNTJklRspQn/c5P+a9R5V9G5GXRAh6M4GA3oG8br5tz6Xt+6IuowJa60uknZfN3avH+ahxtaB9QzS6SrB4CUT+sjDu6rW9zM5db7jg5OQc1ylOjlc8fbQmxRFayh6aC5AC0YPvYL1s6FqhrT2zqSGkwO7uiOms4vYdDVoT9ZooNUKHFpdhaUk4J3TBQhxRr5acHC04O3YkX6EpIA2Ej0wUMrpnMl9HtXzJ+IQbqT6bEYXgAQLGsFGJyLpkMdctkaumBx05a4te/dz30VCW8ciEiYuGaVn1IOtS55zUAIvpTNMcPu8enSqsQZIh+PwlaJO1+qy1jMcjjF1B0xMapNfFk2sIE1u/vhg1yQWayIvP24xNkDa8nots8vC213E1ronmPgxSfPm45iSvHG/D6OpPSpsMSTQB6sWKZlnTdp6vvWU4W0CrFHZU8sbdHXbLA17bGbFvPdo36LVh0RRIOSEBE18wFkWQfSQVFLoimiklNdG1EBUiJS46QgxEH2mcI7oW1zri/j57xYiyGlHEQFUVFK0lqfx9ppQjlhDCBu5r2zYbeq02c815R5SIGI1InltDicR8PqcaVUQSB4eHHB4e4toue5kRdGEop1nYU61rklsQRaF0bj0ynRVoGxBcVrxIEZ0SVuf23iiF9w4dHKKGKD9RFDYXAIdI1Jo2ZgM6Ho85mB5s8mdKaVwIxBjxwdO1gRgKVK+e4WNAJNE2jrIsMbogpkQKKzJTLRfNJ0K/HrOIc7rK7JLrNtyLqH9jTa/Mn5eNm0cvl6G0q0ZnGB9FfPi457RttK7LR930Gl48T2hqx/vvHmHNmrYRulYhYvvUQu5dlR1Hi3NwcrTklQfTzEJeN1RlmZGp5HPHa+MxRY2Pix49KpAkBK9wUeOc4ezc8ej9FU8+WDA/7/BesDYTY3TSuK4jpbBBcLIE1HdBTko2woxZ5y2jbb2igwhaXUQRsVePEJHM6pIsTxSIpKiuRABpY7hiSL3Ruugkq8RQlSNiEKKWXuk5f/x17VAClR2jVUFKLhtKXVBWBUZLHzn0MIdcXM137nPqb7fX2Xb+7OW25Ds+RASUIsRMHza2oEPR1C2r5RpXO0JMdFFwojFKuLM74bMP7/HqrTF7ZWCUHFVliSg6FEkZfC/HokzfPsK3FAoOdifcqyuKwuBdi9EVklyGPrSii4GT4HDrDmVqOBxzfzZBtzXaJKqqQIUcFXddR13XxBhp25YQwmbepN4hssaQYiDEgEm5KZTp60O01jx6/Jiz9ZKD3Rl2NObOnTu06zobDx+h1OiqxBrNeDphJFO8i0QySy7piDKKFBKSQu7IGgWjNMZaXPDUrsGmEcoYJCliAFsWlGVJ13ZEUXinaDpH2zQ8Xz/H15F7D3LU7ryj8466bghBwSAWqxWiwPuOps35qdw8NGAsqKQwWqFiXh9e9ZukTsilJqC/NxDdt0Lu+U6Nlxmo4W/bt1c/p+uvR4jRsjj3QJMLzHsnPUluPZRhk+zopBR4+vyce0c77O0dUhiL81khJ6SUXyMpE7+SIBhiMjRtZL5MLOYtxycLHn0w5/GTE87OGnyXdU+N0sQYiKFvLx89pKyhSBpUFT96fKKNVM4rSW948k7bth4kYUvD5vL6L1lJZvvR5Ygpqb7yYCvUHzaZ7UmTO6EmnHN0XZdVpqkQSWgFSgnKaHSC5XoJyWNmI4rCIhJQKm3sgNK5qV5IA1XhokjvO6E5IVduL2pALoSZLsGAv4fjgpEkIBrRBRFF4wJ15/BJEFOQlCaqHMFMCs+nZobX9ydMbVY/91IRdFa0D86jVcPIWKyZ0gTFYpnbXYwqRWUNZenQChJdNtSxQ6EJSRNNSZsMhMAH65bxzHNoMpTmU8OmKDUlmqah67oLiLbvz5RJOjlaqoxBWejaDhdyEaYxdlOOcHx8zBe//CV+6vWH+OCyMLNa5Qg3ZPaqVwpfGqKB6HJTTm0sxlqUcrkmxefiXpUSKmYgWXRWTvFtwzgFrLG9RFhEmVyBh1OZxdo7Zlopksu6aiKgrUFbi+icxzVWUCZuSEvaKLrWEZPD+0gii9Zqk1BJMAnUoAwDaJNVu1Xu5PF7Pu9eRBt+P43W9YSIS8/Y7EvXRU3Xnbsgqey/ywolFh8y2w/pHYKUSzxiUngXODuveeedZ8wmFa+9djd3dNaCEodPNUkcKZRIrEhoGpc4O1nz9PmSZ8+XPHm84PnzJXUdiEETXMBa05PaIimFnrLuyXWEmpRkU9j7UeOTbaRycx1EFDGF3pPNLd/LvltoignRGeJQfbdV3ToieUEiER8CTRuRGCkLvTFQ3nu00tgi02atzSSNrkm0rQPJzDNrcysFYzVlVbGad5ydLQlBM5kkRCU617FcrnCdZ7Mv96wXuTE8eyXk2X7Ry+HtDYHpItROm8fl2ijqw1bOh73R9ms/Gvq49KMU2mhciCzWNXXnUaI3izgkQClmhXB/5BnFFSdHDcckSltwe3+HnapEscJ0a0ZYalfy9uMlX356jC7ge+/vcG9/j7XzhBTRNuLSmoKASWWWwVKGoDQpBZYpcto51smjJBB8Q9u0+GRJJNq2RUR6RtxFEzcR0KakHFdZsDjmMga/WpH6tvV5oWYiz+e/8Fv8oT/5nxF84M3PfIbzsw/yRxwSMQa8ijglRGUoTUXoPNLnm4JvicnjO587B0MWuY2xVy4PtM7lokzdIwxoQorZgIUMv/ngabsWrQ13792hKmoGKZuhhqcoDIjHFAZtLFVVMR5XjEpLUWiUEZQ2Gda0oJLGJouKmpASQed8o9UFxgn0bR028PVLRp8J/tD5dJNxneee5IbsPm62Rm/6vEuvuRRNbT+ejzjsF/0Zv/C6q2eQokVEEbzk7g8qISoAfRPLlJnQMSaSEkLUPHp0RvKO5aLh/v27jMaGoooE5QipwcY9mrUwX6x4fnrOk6cnPDs652zesl4Hui6zOb3P6RJhqFMFZRStz3M5n7fq4cLvgmJeSX3sESGFSKRlMjZUpcEqi0YjWc0s0yTJhsYqn4UOe6H+tY+kdWSvSoDO+YYsMU3sdbFEFEWhUFJhJNLUEe8izhVYrzEFJO2oJpqmUZw8X9B1JZ0rGI1KmtYzP29oGwdxaCGQZ17sW0TT6/cNkKNSkqEV1KXZvzE2140tyCAlIYraok8Mr09bBktyi1fVV65vNSZ72bj+T1fjsv5nYERsHrrIp6XeOxQFJno0eUNd+QaPUESF7aMDg0cZhSojqRAenx/z3pMjzuYr9nb3+dynX+dTt/cZJ2GkQLzjvFa8//yEt999H0xelCd+xOPTFd/rHCSfE/RaE3IAjg25vQtJ5TYeRFbeMUkJCZG2rXEqL67Yw1va9moJCLFn2NmqQpsSn2JuGFglVHQk70g+MDIFxJyTPH32DEIm3VTTCY2fZyjM1eBGIKCKEm0tKq7RheR8poScc2oF7wVjC4IoOt3hdSLL2mSqrxKV65NSPu8Ys35bUJ6oPM5F2k5RL2vSTsd0rIkJbLJMizF393fZ310S7lhe+9xr6Oke48mUvZHhVgGVinijqU1FrUeQDJaA9jUmJFwHprC0bsV6dYo7d3hy5CX9+hpyqCLSCwQNKEOevcN8yXMwXbp94X6IGweIOLTISZsZSj//L/l5Kb8nw+32nCfvNy+shXjxPsO5J3IkPaxF6QWw+3zDxVpM/dlsva9sX9vWOQ5LZ1j3Fy1NLpOcBIi9GG2KWZ4t7zUKxORrVNITGmKvGapxTeDxozmL846njxfs7IyY7pRoEwnJ4eqW9TJyNp9zer5gvqxZ1Y7OQ4pZ+iuERPQdSmfVFZME0zdaRFQWc5JspOgdqZuMT7aR6idxFnxNaBUpC8GanlqNJStSBJS2tF3EtxHlIybAMCucz+KKYV2zNjAeF31xI0NdLiIRrSym0GgiITb4LtA2OUlubG4pnkRoupbzZW6RsFp7ylFL23rOzxqiz0234xDFbCi4KXdy3WL8XEznbSAwT6qrOMHw26a9lgghSd6kJEt8bZBtIbd54KI2atD+IvXtQ65ZqJtHrrNSm4e2DdTWifXu4OA4b5+4IJgYwXnqrqENnigWSVAk0AkMAdGRdYi8f1azbs54dnxK03UEW7J0HV4iQQUSARcDdYJ1WBHimrY1fP3pnHeWwtmq4Y83HhGD0WWG1IygU99hNuXv0YWWs/WaJyen3CkzDT2ESOczw68sK8rS5r5MvW5jbuUhxBComyVREsZm+ERXBtVFxlXBuLQoIISA9x1PP3jEq59+k4jCAyF4mnqe652sYHQkSQDpewzhc2+gEHNhbNA4JagCQgFSGWxVUsRA13liyM0eAjGvCRKIJ+DoUodLCW1KQlyxWp+gworpYUvoArPxHq8+VNy6VTPSh5zH15mngjYK866hOTlGuYZVglM94kxGaG+pWKP9KSOtcU2JMgVaO2YTz0ib3KY+5rma8xQDxNDPscGfuTHSsDUdBwNB7z6l3EblYtbTO4WX2bIZXbhG1uiax/pDbKKGSwXxKTuJG0ctDSZHhmnPAL2lbXSDC+O7UZDo16JcOU/651xlJaph3amLY27W9yUgJmZyBIKiIIXEYh44P30fazVlmck1GVUSvE/4EHKHCBQqVuiYNfuiSyQf+73JZ+3JpLBR96cvRHpnuOcKcJ282jXjE22khk88e+MZdimKYpMX2HgaoklRs1rVnJ93eKfzh5mJ/jkKk8SqDjQp0DXCzq6lKnLDNiUWJQatDRIFKQKjpFmFkBPm0SNSsmNKSIb1+owYhbqrabsVnMdeATiilCbFy1OVS5P041z5TR7fLIeXvmbbsGxj4Ned0svhjG8ejklkmK0Lkbbz+BAR1bdfIRuMIIKPwvk68Y3VmhA6oGBUGFT04FekNCHpli51GMiqB7KiKCNKGRrXcnp0zNrlxmtaj4mpxPnMfAsiSFLZeUiCaMuy7jg5X1PtjOjEonWB9R5RwqTI3Z9FBNEGUXmzdd7R1OvMZpMEusDaAilyp9qyNCTJivymtKxXkW+89wEPPvO9hOCpRlMS0DlP5xqMHaHE0/m48WlEshefQsgq5JI3J6MFrKKwmpA8znWgskxOCF3v2fcFhTG3t8+beCAlR9vOefbshFW55FNverro8Bi6lCGbp6envPeOZ+UTLiSUi5R9twCvDWvlCUVL0UWq0hPSnJqCtk0kBaYM2DJR9mjBlpzsteOjmG7bkdV197ch5c07XYpIXlwX1yPgL1sQVwr9r7x446ddIUZsWlhsn8vwGNsEiu28VXph/V09TxkilY8aQnZIh31QeqdZDKWtSES6JpeCiMrq5jFm1GdjfOnPfXNCWXFnWAeDOlzs809DRK96r+OmaiOfaCM1FOTmJKGmKDJUd5EbEJQuCR4WqzUnJ0vWy4A14/xFDo7bUDgaJtmDRSitpjRlr45OX7yb+nxDYqQ1wQtLF5ifd7SNp2snKA3rJSgpiCr39Ykx96kyxhJCJMR4JUzfhFW/r+Om1NdvP0Mq51tcUDiXP+sB8gm9gx3IkSFpRB0rkl9xsGM52BEOZ3Bnb0KhMoTndQKtKZPiU6/d4+6DByw7zdfeP6U+rnNBrmhS0ASvM2SjY++55gWoACMWkxIpKVwUOmVwMaERqrJiVFakGOm63LzNGotYycLBKWI1GA1VqRmPc47UyoRyOqaTRBRh9+49ZDXlG+884sdcYmdvH+0iXmlEK4J3pHaNNiNEFeRiTOkNKZAiRoNLnqPnzwneU9gC10XeevsbLBZLbt++BSni2qavF0rZCw8BFSMxBIiBFFu67pzg5wS3RlRELLRt4mhec3uxZt6UKFruzbK00fnKULsxXo1JRhO6OWX0PNwp+Myrt3Fpj+cnNY+eC3XI/a1aFwk610IZLbiXmKmrtUvDY9fNxZex4y7V58nWxjq85pr3vjl9/cU1sw0pXv0ZkIT8vhn1iOmyeszLj3+51nH4+l9yVi9Yr5f2fOtRmY3TnMC5kGXgJNdtBp9LeRDJQVB/FlkYIZcWZGWfrF1qlMqq+GqjbYOPIUudqV5SLEXa5jvU9PA/tDFw4vKHwibEH0ZMisV8xenJOV0NRJ1bbRAYap5Ub/JDyNi494H1yjGqsrZaLjgdqLKJiAMJVOMS1ykWc0fbOBbzOVor1qvUFwoPrK9cNJxSFv5Nkb7G6+IqvpVI5NsxrjNQ1xcKfozzHBzXl4RfQg+XKPgv/tfPsFNYOEdHAtGoJOgEP/7jNX/nbz2jjSAYLIYUHbOxZWdiGZfCpFpiVIKUowpE8En1nX4NdRs4Ol2wrDtC1PzoD9ccHrzDus4EBiT0i3WAPzOlmwj/5//DG0BCjwqK6YTKGKazGaOqyh14g99o8hlj++82gkqIEarxiHJUkSIE7zFRaNB4bYizGaJ2+fdvvctv/pt/y4/+D36MSZkNifOeRCCGFnyNWIVg+xxD3iBU771aI6yXC06OjhiPx5TlhPn8jPl8zt7eDl3XoCRllXAy+y/FSPKe4F2elNFBrDHWIdKAJJIKBDEkXRLFgjHcvbXDpw7H1LXja086jk8N6zTGaI2Whv0K3rg94Xvu79KkMYWtOZ6vWNWCLQzFWCgBR0v0juu2oY+ahy/728vo3NvP7TGDzf1rYbyXHPcm57B5/JrnXXruJoq6voHopWiQIdL58PfJO0n66O1kK9Ww/R9AjDniR+n+gAHd5wuycHAu30lDWJ9cv4ZyUb5SCq0GEYQMp8aYezwM5TqSrij7fMj4xBsp4AK73WYW9KPrPOfna1YrR6HHGK0gkHvg9KG0xAvPQ+m8QYXoepZMRvJFZYUKiKTUEaLH2pKqsmilaTpwbdbyQ0qUjpmGq0yun02px981Wm8g6jw2SufbkJtcQARXrnZ44VXZlaGO68PrQbYn8EsWscjmWB93XDJ2w7kPyMY1FfcZQ08c3g/8b/7LVzhar1nFSESBT1hR/Jd/x/O//d8dsmgTPgkWy24Jbz7Y480HU26NocAhRMrRBFtOqBvHatVkJ6UNvP/kiA+eR5owJaqC/+X/6oj/2//1Nk+fKXSMjIxCrEGsQRtNgWKUEr/wV97izds76GJCc1CxvncHbTKsrJTaKHQYa9FKbRae0orOd1kvUitWCToXaNYdXdMSWsdPrVu++PiIZ4+eUTcdX3zvEX/wCz/Bj/3w6/yhP1qzWjXMxiO0AmILsUB01X9/uTBSScJ1LeOq4O6tQ+g6BMV0MubBvbu5IadrWZ6fkcYTTC+Ia43JKIH3Od+SIil0maxBiy1z7isER+cUPiZCgt29XW7r23x6T3F2tuTpsaOoxpx1Bd5FxjEw1YFX90puj4VaND7u8N4OnDbr3qhHPLl0w1pLdJfn8Qsz9iMKXK9u7DeVFhum5sve8yaPXfs+6cL4XfprT5wYXqdiwm8968brLV38iLz4ug8HUPtzFjaEhv5RBqOVmadsyESgCcmBRAb6et5HEgOxKweqES05Qh7aiiSBEHOnrLgFYwpgrb3R5X7ijdS2gUp9cnMIKVNKrNcdzTog5GZsxNSLLOaeKENSNSVQBmJyKOWyUoTyueg3esCitCIOBZuSvyhbCLbIfVy0KshMvIDQEqPLkzUN3tJmjl5Jgg64Y39F2/h22pLBve61wyG2jMpm0n7IOt1A4tdAKh/O7Hs5NHP1/tWodvsYw99iCJAy5j0/TaxrcEmyiGtMBBFiB2mh0E5hC4OxCuUci6M5z7o1tU0o7yjLEbv7U9Dw/HjN8myOEkXjI+d1oEgzxuUIXRaMzZLboxlqoikDTMUiZQFVgdKKIiYK5xmrglemI0JRMkfBaEwdYBUCwTnarrtEpR1UJlISAj0lN/XQToy5kDxEok/UAU6dME+gK8vRcsGv/Xf/HV/4/wnf+wcS89Wa2/s7VErwwYP2xJDhFa0CfR9etETq5Qrfthh0bo8Rhfu375Jc5PTkhKO6Yz1eMZlMUCJMpzOsyZuRKMF1bZ+jTYiH5LJgso6ZcKEFhERpNSOrMKllf2w4mFXoc49VCa0SkwS7I8WkAJM6rCQKhEqD8h1YQfXtVxI9ZV2FDWx/1cH6sMjoJmP7FZfW1cccL5v31z7eExpU/16y9Vxhy4lM9JDZy9/zBYdza51vHMAt5xQlmTknl51XuCY6JPb7mep/8qag+vKI7XOHSIihP1bOw6Z40XojN5FVJPzG+Y+AVorgu95YZcgw+oA2/RNuMD7xRmp7yCDzEmOunHaBpm5wLqtKqB66C8GjxNB3L9pM2phaEkMzLrtpRZ9xVw0YUkyEAEly10ttwNgE0gGW7I0kLijZF+y9PK6b7L//cB+8fDL/Xgwl5M1PMvHF6ByhGq3ZHS/5/vt38M6gS4UqArFbUqQW6ztSSJn+ilCfd7gkuGWiihajFKUWptMRurQoY0AiO8bwsBRmhaL0MA7gU6R1DcEFtAvodYtqW/RqSQAW7ZJ3TxuWXhFCyEXf5MUnkrs3K8lySDFmuNGHtMHyU8+2RGcHNipFZwyhzHV+DsBHVp1ntWp5+vSY1+7eypqTSpDgiMqhtORo3Du6Zkm3WjE/PSM0gUIZEkK7bCm05bU7rzAtxswXC1JMrOdr6q6jaT17+3ugcnGvd5kavzpvsGXEFgWqZ2fpFLDiKXQ2OCOjsJKVUyoVsN2aXWNJ0VGxZGwsRmUnpJBIIYEqNYxVR0ygUyagoDSRoaSdS3Pv6ly8zpn6qDHkoS5eO+SwuQS63GTlvQyduO6cPhzJuPLcrWt/+Xv3d661h5ed041e9Q0+q5xfJ6clkieEmEsolL4wTv17JvEgoFQWdM4ydAOqk/robTDOF+BhVuZMfbFPH0H2kdZNv87/uIwUkhlV/aYRY8APnoLKDMD8heaPLvbGJEdj20W/9KoTGqOq3HUUm+tROkgYtFVZbkQljA1EapIUSNKXzigL+/Vf5hZ759KM+w+ANJEge4BbC+zDvNePA3288LytXFW/JaEEdsaWyowYDZpfvbjvpLA8GBV4VFY26Jqe8quRvtjUaEuzblkuniJSoHWB9i2E3A7C+4gTnbFyEnG5wj16jnuq0F7ovKEthdqAJ6KcZxQgtB3dssaZimXT0XSRGC0hJEQbtDEbGi9Rb3bAhALJcLEIaBGSBIxSNM06e9Ap55O8CnjfEkWjtSJKpG5ajk9P8V2EXkU6lw3E/hoCbVezmJ+xOj8jNJ5JucO0mKKkoFm3rFcrYoyMTIXZMbgYaLuOLkQ6H+hiQhFogwOy/uXqvMPYyH5ZoJJQisGmDvFrdHIUyWPJhCRFy6TQ3JsqTtpzkMDhTLMzMShjCDGhdKJSiYORcGdWsI4dOmWHLqJyi/ktQsH2/LtJnvSj5uGl+xvU5UNBhmvHx8lJbaKQLWT9Iuq5+D31d15a87h17MGUpwFKTP0BN9Bfb30j9K2+P9KopxRIyaO0QilBq9yJwOrQG5BcyxRjymhSr+6jxKCNyqo5vkf9NmtaNm45/Sn29IpcCiM5X6UAc0Mh6/+4jNRm10sbQ2WURlLsWzJHlBo24tjDcDB8pBJj367DkJIieE3XCFoXpE7Rth0pwGhSobUipQDKU1QJbTzRd5CKzfEuelsN0VU/bgDH/Z6PfpJ/dE7rY2Dn/bh6mRsUfsDV+xWtcUjb4VchOxD9+/h6xerRe8SlIuKJ2oMRfHD46LPga2nQSmGNRonO0U27xopgdIlKBt8KKip0UkgXKBeR8UJRBrAxZPXuIs8h4xWqi1lJJihCsiQ9wmiP0RVdzLkfFYQUEsbazJWQXrtPa9rY5zxTQJEp3zoJs9JQVSVVoSmUx1rBIaCF5IQuBpzzrJc1ddPiXMDqqocKHUHlJnNdW7NeLYghUNoCozSL+ZLlWQ1B8K5jXa9pnCNIIgiYsgBlaF1gta6JQiYCKcVq3nB+vAKV2NEe3wVC3WFjYFrAtDLYNmJEQApsabh/e4wqEk+O52ASd26P2R0rxpMZaIfRsDexvPFgQjl2PD4/pu6WSIok0UTRSK96v5kvV4zMh+WjPmyuXheFDfNug/wNm/1HzeGPE0n1t8M8lyt/G4zMRRzy8vfc3G4bt21DtW0h0kU2avuaX/b5KJ1JY1mtPiFEREVQKqNIRlCSc+mdTzgXib7L9ZepYGBIp3S5b99ASAM2fchif27Ss/6EhNLfDUZqM8F6z5++ch2V225oxWRSASq3BPcBH4aeT7qfPXEzAcrC5IZ7MdI1gbPTNXPTURiLEk29qjHacKgLlMleotKqr88y+NaDODLsl6fg5cqGq5MlXb7XL57BKbo0geWFOx8xpI+Mtl6V2JzP8PhQ/Lt95G+WYj6YY7ZuP+xsL21GCWLnqRcLqFsKJT0GDr5tCYslqtZoUs7bWrA6MZmOGU0qykmFtTCdVFSVhuRRncOiUCjqlef0eM3yzBGagISEdprSa0wik1pcPnRQkEJuey4iEATnEw6D8w6rwGrDaDTC2oLlaoULGZ9XKrfi0MYiIeFSzMScXtizsoaHD+6zuztjNn4b8R5JOsMkfcSvlCamROsDTdvRdd2F6rrSJBRKAj76LDcUE6eLBbFZoH2BSgarLVU1pihHLFZLlvUaHyMJRVFWrF3HqnW44CitUCnL6uiU1ck5piw4KhqadcvZ8zPS2LJTKHYnJVW5Q+crQvIoFJOR4ZWiZFwalIb9/Srny6QgRg8hMtKa27szpNK0yvH0bAUuorXC6Cx4cjUn9TLDdJ3D87K5JbxYZHs5EvnwKObquK79xnXn9VGrJw0hVG/GXrjCrQc2ed3+6cNLB1AmDY/1m0bedfoSHHrHXHKONG2JuopE6CMpLQlbaMbjirKyTCdF35yzoDC5+LZuWpbzhsW8Y7VM1HUktYGBZQqJJNJfT875p7zRMrANc1WWXIpobzI+0UYqI5uRLH2UI6CYLIgmikGpSDnuENUwGinaGtbL3DogxkyDVCo3CbMWbu9VGGNYrDrmS8cqeEQrYmiIMWBEURRwdn6GtiVKlxSqwqoSYY1IItBmLwHTT4zMiskLcMCP00tm8sUCzfULWcFARPUV+XDRfTg/H9jM3KvfuyBbReeb2dy3F5HczK//gQtse6gz+zAPdWAdbof10u8AfSrgwl298trhdvhRKIgaaQuUM+joKUSIFCAKlVqKpLFa04aOZDSiOsZTzRtv3uLg1j57B/uZ7j21SOEJyZFay1hbTOrwdcOTRwve+sYpj95fZRWz0hBNoEuOhMYky6gzGGPwxhNjAylQeI8NCicChcV1HePK8uZnXmMy2+Erb73H8+NTYgxYC3f2R6SUeD73+Bg39SaIpSjHzHYOiSnnNrVUiIcy9UzBmNvbR+BktSYaQ9fVTIpEZUuWneCizioWZkRQFUEpxrMpo90RFRUScyPG0H+nUWui0pgYMFVBk3Lk0kpk2XZMaqEMHf79J9j5nHB7h9Ok8Si800yTZrxj2Z+WtE2BD44yOTSwWjcsgydpg9GCahwmtARToA2o0BFDR9dpWpmwJNAaGKuAlRpLjcP0G9xFjmV7flzM52vmYkobnGLj1PXRhSi1JXUkm3WSttaN2mzpF+M6Zmsi5cJsGaC3fsS0Wc6X/EiRSw8k+rqiNIhX96CwqB7lGdYHA7DHJrPTX1gkXRyzt1yicm+8/NoscEwyuXxC1iCOGAXFiJTKrKunOrR1KO3RWtjZmbJ/MOX2nT329ivGE0NZacqqZyITaZqWtvE0q8D5ScvTR2c8fjLn2dGKkEAXBY3P6icETdK234NzbVzqIpUYVFLEIDhNztfeYHyijdRVPZNM847kRmuBpLIkjVFjJBW4QiGhoa0jwQ/eWsQYzd6sYm+3RJusNND6Fes6i2/GKH0oHTY4rqiGHbfDdFqipGRUzVgvF1xgWP3C2FRdXhkv9SQuEN3LZkc2k5tr//riMS8W7ta9a05le4F93PqUCyO1tdC20Uz18mNcOh69ikv/0anYN37EIOQq99DrsSGR6U7F93zuFd78zCtMp2OS0qjS0iVHGzvQClMVGGtQXcu0sDy0h6BKQjrDVmcklfJGTswt231CpV7MdoCEBDSxN/aCC3mDt0WGu1rXsWoa2pBVwUfjEbPZlLZpcL7GB9837MtbY9N2vPPeu3Rdxx9ZrUBNkBQZlRXedYiKeL9mOp1iSksxqpgv50yKzJTyvqZZBWxVYGw23JPZjLEZob3CrTLs7JNn3bW4rsM5R1EZSjOi9i63fidldCEmVm1Hc3TC2fFTjA4oE9GFRhude1btjWmnoIunyNqhksNqcF3geL7kpGlZOkVlDLfGhp1CmB5qbBFou0S9qjlaC09D4HTZ0nrFCEMKAQk36ym0PU+2x3bO55KhSNcsvbgNxF3E+i/O8xfXbNby3P77ZeN53RE2Oal+G5Ao/dtuV2ldP+TK8S8jKluvG0LDrejk4ujCRh0iZcJCwhPjmnEp7B1U7OxMuHPvkFu399jbG1OOFEp7jEloA0jI+VcjVKOCg/2Ce3cUd+/ucuvRnLfeeca7j044PlsRoqKyE1TIFxxjJPheKkwGOsXAArx514dPtpHaTI+8ccXke/wzkmToegtCiTUjJGmUisTQ5HbX/RdbWGE8GTOaaLSBpCzzdceqroGsnq6w2fDFSNfG3NjLrXGtxdiA99tgV9+z5dt9jZen67d1vAz7v+pRbuPcHyNiv8FIIB4k5BxF73HG1HdOTrn4VAoBFdg9mPDq63fZ2bO4sCJiUGnM6XzB2WKBJ2BVwf1be8yKhNYwLQyvqD3QJbv7j0kq4EKgtCWx55ltrjmlDXtv6M4sSpFUpngv1g1f+8ZbdD5xtmxAFVnJvagQU+BjQyDldgTqwrFeNzXL5aK/pkRZlewfVIwmJSkEVvM53XrJ/Qf3+P4f+D4QOJmfU9m0kYhKPtC4Gm0UJgWs0miJWYk8apbNmvP5OeuuzrRfJG8UMRLomVYJFoslTedw6yXp+RPOF6ckOoQaqyMiEWUhFgVnoWPWdLBeEN2MoC0BA3bCehV4/3hBRFHfPuSNh3dIGrxpGZsRnTecLxWPj5ccrxqKyhBlTOpsT0PuuNG8fslTLtb5kKe5MFCy9ferxuXDxgsw41Ze6IU3v+bcto3mtgOoZPsRNlv11ee+8NoBorhqPK95780ZJNufSO/g0WCKwM5+yb1Xxjx4ZY879/aYzsYUVhNpeyIFoHpqWd8LTSmTuwTQoAvFbB9erabMDkqmh2O+9o1nPD9aElxNUcywRY4eG+fwvievIQhZgX3TLfYG4z8SI5VnZIyhb27YY7CAlgKtK0iatmmp6zXeu5y0U8KoKphMCkaT3IYgIehCowwgfUKwl6JRg+0RQ3CwWkR8u0apjq5z0De1yzMrbf18nGuBq8W9lyG+7+y4WtD7suLJASu/WFTfivHM2Dl4hKwnJ5LVsemFcGMP15TWMD0c8/D1u+zsFyTT4GJNkorlecv7T05Y1o7aOUZVgUhgdH+KWCGFmmpWcO/hhN29imIMQSJKF6TYXfIB0ta/g8SLUgrRucygcTX10+coY8GMcqF33yfMxVxqq7RGjGxgpySxV5zPCWsRofMdZbXDg/v3MAK/+zvPuXV4wO3bt9k/OOCrb32DO7tTHh+dslg3HO49wGpF4xpcG7GFpRAgtESVhZJPF8ecLc9RVjIDURsSkS46gihCCqzXdSZZrFfUq3PM4pzOd1Q6UZjIpEio5CG2ND7wvO4YLxp2woRkKrypiKagmEFYnNOlNS4KT5cOfVqzZy0TBRNtaYLiWRN4tvTUXaIoLSoVSFQoOrKR+ughV26Hr2jbQL2ALvTPycHGYGg+fC19GBnixcflMrK3ecu0/ct2oNOj4BfR9WVj9OLtZdN0xXhuOYsXx0l5L8L0+0YkRo8tHLfuTHnzew94+PqMnT2NLcGYpt9lLkhlbFITEVE5PxtDJKYObYXCQNSJfav4lNlHNNhCcfxsSXINzgdsMUYk95MSGdrIZxHrfNbfBZ15t6ExyNhpSpLba0AfUhogEWJH0y1BWqY7NtOCFeztl0ynFVUpaNNXRfcqvYlcd5DZwtn4aZGsy+fJ3V99Qinf5y2zIkUe32w0NRiq/n5SWw9LP+m+E9HURQ7go6r7r8sTfGtnNLi9DiFcLMy+I7I2if/0P8/J9mKs2DlM3HvlhPHkFKV9D9hZ5gvH+NOOopwgxrBaH5H8u0xv7TCbWogOEct+LAnRMJ6MMOUcn65Gj/k6t3MFWiuMstkRSorClkAEUcS+g1+IiflyhU0O79sMdSohST7DXGSZcjPCnpkI4J3j+fNntOs1isRP/Sd/GPga9+7f57/5wudZ3T5kWloWdUfXKApr0QZsYZAYSdYixqIM6EKY7IzBJlrfsG5aQoyYosqFsxHc2nN0csRqsWBd1xRKEVzI9WGVQnxHmQwSA9I2tI3nvA4s6oirE6uVYhIt67bjyfMznp2uGY8qdnb3WS2XfO3td7DnFbt7BSp0nD1bcz4v6YIBnZvhqZgVLZT+eM7XRz57gJoH2HgreNJqa79IH553/VgnlK7U/KQMG28OLT30dyWSyny6m73/xsheepuXvXa4aLU5n9HYcO/BlDc+e8jD10fs7Atl1bP5iL1cmyDJYnTBUJQeYyDFlLtBB9BWISYQQoeXjqg05Uhx/5Upk+mIZwcLjh+dcXZe5xpUuZCHuygaVkD87hCYzRvr8EXEntOfWSzDppt7QjVAoqwS6qDAKk1RWMrSUJQaoz3KRJKA1gX1OuJDIsUscyNpKFHrI7YAEQNI/37bEYi6IEjcsKHaMDKLMydDElyCLCP9wtt4YS85xlaNiUDuazMclusn+/ZrB+r+jQonB2ppD4+lHiJTgwr9Sy7+WuMniUTu8aUkqxLElCVa/tk/PGDnVouWjjsPdtid3SI2U87Xc0xhiEnRecuTZyvaMGF3/y6qKJivTnj25C3qs8SbD2dIrKmqghgtz94+QMkCU2lCncVWQ0gYsSjFBu67MN4K0QlTlHiXEALG5g670XdgFCFBmxJnoSWGXFSc7VR2LiJZfVwJm8ZwKUXOz89Zr+aoFBlXFX/kj/wnxPhVQkz8wB/4Ef7NF34TBdw9OKRZBSZVRVkaJuOSsszV/5PJNEeEStCjkpHJ7EVPYlV3ONciCRoXWDc15+fnLJdLgg/cv3vA2bMTOvL1WD0CF8F7aNqeZm9xQfPo+Yp33j7mYD/g2pbjp0+YjSpevXeLV+7d5uzM8PV3FnzwvOb5vIPo6GpNChVKCZVuUdJl+TEd8LG5kaG4GnFcPD6syiHi6O/1TuUgWwX9Z75x9tJL5/m1xAnJNT5xSyZBpCdfDQw8Ltbf9jEuYiY2c4lEhoITl1tWXA0FUw+s0M+jS+fIhrhBSogemICJEDJ7MoZIEsfu/phPvXmLBw+njCaZNJELqw0xKFLMhIvOCTEIMea1rUSjlCYET4xdVvMXR0wepTXKJLQJTCaa0o6ZVRWz0vLOe09YrR0SIs53DD35+k8BJdJD0R89PtlGajM78/QNfdFm8IkYFUZ0n1NwaK2YWouSIheTiVAUJuuikdCSEJU97OViwXrlSEkjyWw8JZEcXucNX2/gA+ktST6VtHVyLxqVm1Sjp97rGo6yQQ+/HWMwpt/C8YZr+GiE/2Ze8lCtPjCachFBH0WK8MFXDY+/HjAm4r93wrjcpYgzXFDYShGiZtUWvP2O4WQRePNzD6lmUx4fWT5454zVxLAT7jApO1oTiWiIlsN7iuVp4uTxOWlgGsk2/t+fX0qbn5gSzjmCqynFZw08AR8DhS2QFOi6NkeEyqBS3BxbI5jS9sK0kdIWuYbPJ1qX/eqf+OEf4fXXXscWH3Dvjf+W+28k9u4f8cH777O7s8OsGjGpSrRWaIHRKDNSTVWiihJCYrTvGfcQ6l5fdtE6T920rOqW8T3PzsM1TdtijeH23hnzP/Cc+rjGGpjMoCojz/7djFIKwCIRYjKcu5JvnHgeLefY5FCN58GtklcPR9zfEfZ0werE8mQZaNoSVEUwFZEKSS2VBLRuUQqS9gRym/rtJXE1J7pRjkjXzNtNjdClCdWvRXlpLumjCELXrtFhbrzkeJvXXH3tdj4s9T0Huehz9dJxYXk3t5tTTRdQ34aolCR3vCXkdIZEEM/ufsHD13a5+2DEZObRJmCMzvmhWOG7xHLRcXJ8zuK8oalj7vyQcuNVrRVFKSgTme4UjGeGcjwCXYJ4rA10TUdZKG493OP24Yxyovna1x6zqtcYq3AuIxAxZegxSvru6MwLPQ6dIKFwLrdHNiZSFBZrDFHl5J82OQ9gTZbaCSH0k0f1EYGgpWR+XnN8vKJpEilZRAxDHJVFlLaMkQxhftrcXvx8M+Nqd9ur94ffP/7xr8m5fnvHsIi42Bw+nmK69IvsYrEppGcOB6LymEoY7xSUI5UFL1GkVOCDYblKnM5bPAVoRVCB6cEe08Vdzo+ec7aAsZ3hwxpUpKgMd185pF1qlmdLujZ7ypDN5cX557xk7CvvgQy3obHRU2gYVxVNyEni3GQzYfv8VELQxjCqSqqq5NbhAcF71qslVVny4O49mnXNfL5gMh7x6iuvMz/pOD36n6Mk51hfefXHsOVzvv61r/H1rz7l+NkTbh8ecLi/S6GFg709dnd3EKVpW0c5GjEbjXBdS+cdKMPZcsGTZ89ZrRrm5wtOTgI7s0N+8Ad+gA/efsrv/n8fMyseZEi7dOxWEXl3xN190zv6gihNVJaOkraNjEXYLypmI8uOTUhzxtQI+xOL9mtAEYuSpAqCWFTM+oBGEloyUhD6hM6N5k1KLxipIYqX/v5wO0Q3+bhbc5OLjV7k5ZJEL9ZnffOw5MvuX76Qy08YEI+Bgp5FyPsmjcM1D5AmeR8cdo+UAsYYQuhQxnPn7g4PXp0w2wso06G0RqsRwVvWK3j8wTGPH53y5NEZ9TrStX2Ko9/XlIJEh+jAZFYy2x9xeHePW3d2sYWFkCiNobCCsS1FWfLmZ++hjcWF93n8wSI3BFV9A3DFBgK8yfhEG6kLD7enWiaDd56mDigVAE1Vaipb9EoSAklD0mhlgL6mgKwasFxHnj9bMD/vEEpIOmv+qVwVP5TCJXLCfRNdbWjW2wbq403qF43SFqb8wvNuvvlvJsIlL+w7ldOiN9xD1flN6RTDiWVXIC++DLXlTyCgdGQ8Ldg7GFOUWfIqicYHS9Mojo4XuGB4/bOfYbo3JZrErDhgfLLg2eNz6nVBOthBiyZKTSIx3q3Yvz2lHGm6s4HNlz/f7SLQIUeVYobrMswSqKzm/v07HN65z+Pnp7z9wePckZTc8G00GhF8ZoRKTMTOsV4saNbrbAyUMJtM2d+puHV4j5/8iR/ltYcP+N3//kvcvfMauzs7lKMRx0cNr7z609y91/GF3/z/8I23/1989WvvU8gps1HFrb2Cu3em7OzuoJTBliWTokDHRBToYuDR88C7jyyLZcvRM8+4usP9H/0xVie3+eK/Pedf/SvH9775KVadp+OM1w41r1eRWI3wAl30OfMnkXFpcCH1Le8jlsjICoVJJJXrzPbGgncNqxRJsSSlXIycHRADlP3iiSDtZk5+mKEaWqZfN14QV946lvRIy9X7H2d83Off+LhbWYEhKtqWQtq+vWAo0v9+3YeRox+lEzF5JlPD7XsVu4dCUTWICpTFGC0TVqvAo/eP+eLvvs2zp3PqFVg9g2Q375U5pREXNM55jo9qeG/FeGfBvQcr3vj0He7eniFqCSkjVj50lKOCV1+/xfmy4+h4QVN7EA3ichkP8t3RquNiYgJIbosBmWlHR4yJFCxSKZLVGK1IxmwYWsElIooYEl3reX6yZL7oSNEgyiJZ34BNUR29iZBMz912yzJkcZ2BuqFR6a/hWgxtA2mq6//+siEXE3xzJt8RA3XF87v8jjc/QtKkrc64w6oVQBvFaFox2R2hDITk///s/XmsZNl93wl+znaX2N6SmS+3ytqLO6USRUqkqYW2JKpt2j222QsGaI+NsTEDNy3AFmAYBgzDCwwB/sf9R8uemYYhuRsjeEbdVrstqwUt3aIWkpJIU+K+FItVWZV75ltivfeebf4458aLl/WymMUi5S5xTuHVexlx494bEeec3/b9fb8oWeKdpmkixox461uf4sozT+JVh5OWuY0oVVGUW4Q4YLlU1LVGFYnBXqqIMBCET96qlBkkk5os10SZKc9L74QoKTFGUxawPR4xqAqC61AkwTffNjjnWM1XBB+wzuK7Du8dSknKwjAeDenalrq8yXgcWDYWwTbL1QG2WRG5gvVDxtU5Lu4O2T2X0nPvfv8jlKO38unfn3Pv5jWknzHt7uLvvczS7zKebGFiQdMKdARVaLwAywGoW8hixaNPlTzx6B5PPKbpulsMzhxw6S2a4YUG6SVtgGo7MB5LhtsezJRJuUQrS2wDyq4IUVCoSF1oSt2jWjU2CnRVsT1WrGYLmrbDqwHGjJCo5HZ4RaQEYRLoiOOG9zSNTs7Z9YivnP6nsv+T6alg/R0ijuUjjs8r1sSnr5iN94MUXnHUaYvw2NEUOdJZL928tnswRw6GTrimp13/5H0cG+kHrmOR04nRoY3k7N6Ys3tDBsOILhxCyMxzGbhxbZ+vfPkq16/dQ1ChZIF3WYoj9g3+nojHqBFR1rgYsJ3l3u2Oo8NbrBYd4u2XObMdKQaCwoAy0C0bysqwt7fNuXM7zKe3U0Yi9pkJcN8J6T4lSJrGMnloiYcq9dbYEInOEruIqyJlUWAKQ2kUVmWQhU+qu7a1rJYNh/OGgEr9MDFzpCuZoZmQQJoJNhlfkQDoARSSzeglIcCOj3pVI7GR5urD+P7lieI/5HCfV8zqU+HiEeKpfPjrvByb0V/fm9SnNzcP3RyB9HnnVx0fFFOX/xpYm1fphu+39tCkTA19iOM0jSClf6z2CG+zGGX61LXSFKamMAUytgQHUhpan1B1Z/fO8sSb30wxKZi3Dhugu9eyHYeE3UeYygK3WHAmLjmvAwWRQiXBwtZaRASvI9ZZYgTjoJZF4jTRYHVDVMkbFLEmypK5bfn6tTuYW4cczeboGBA2EKxNEu0iICUYkwAgIQhmsznWtgyHQ77ylcu883tu8dR8iRKac3v/gWeefpqjoyO0fp66rpic2WZrd4sQPAMTqUeaM+c6vuvZmrt3xigU3arh9s1bzKfPQ2Y4KUyFMan2hQ9cmggef3PFuXNnGYwGKLWPVEd01lKdP+A9H9hj2d6msUkOJHQNO4OCydaSbSPQh/f40ld3+NpzOwi3YiAj5ydDzo+HnNvbJmpFR2J6OXf2LLoqGd3ZJ9yYca9zdHFFUJZOaDoqfKyIsUVKSxARmVO96wnT11n6edWnHE/14OL62LQO+uktT0RPMfYu532u0ylr8hVGA4GIkrXcRv73mmgo9kz3qTduk4+l3xfS3zGlTzecWrmRcxAb73LtGK/vX/Rl8BP7yGaRQSAIsSD6jqpy7J4zTLYlWvvU6xk0voP5dMq1a3e4dn1O08H2doEUivl0gYgOvEFS4B1IYXCOpJpNmVR7aXFdy9e+/DKxhXe/+wnGW5HGHSVtNR0RumNrR3HmXMX1axLbkNUNJCYjqR9mvKGNlETAWoo9JkqOGBFIogcXBE0IONfSSJcKzLJLyBIX1qJf3jnaxhJlouEBkhBcKrFn1ulMZSL0qeifNPoU3Wb673iiHb/ulcakr8P0BkJEcZwC6c+aUwHJ+ztOWdyf4jg+7cn6WLryxuoXvZeX0zBCZKY7cbxJsEGtxHHKJQrWzdDpawj0AJaNuzlOmOdfPbR1HdWtUxsJmuqEQxmP0hGjTdKbch4hUjOhdx6t0oYvpQE0xUBz4ZELDCclXbTpPE1AzDwjNaY7u8U9O+PQHRGaBRcmJbpzIBNvXkRgTMDqDlcICmkwjUMHlTgFC4krIi40KFkRXMyqvwY7s4iwSgqzwSFCqluGGBK/XUaWaaPQugIBq1WLi5Hf/M0t9vcji8MFu5MzbG/v8mf+zI9RVTXWdeyemfCWtz9NYXYoK4VQCu8NAkfbfp3rVz/H3eu3GZcjfON47ouf46UXv8RyuQ8UmHJC8IHRYMgjlx/h0qVLxP09ykGNDR4XA/uHU55/4To75y8hByN++xO/h20ttQDRzhkPFE88c4mXb73Ey/sL2qgoC8PIOB7ZrXji8g474wIlBVpCDB6jQW0NsShuTeGw7UA2BBlxUeFiTYwa4Q9QcZkVZ3uU7skZ1P8ZicgsuLdOf5FrM5szLs9nZFy3AJDRdJHjc4nNk983TuQC+tRjBKI8BiuQyIqTFHpcO3cZw8nxXfXAj0TG6nOds68t9X1Wm1ddG6r12sj/FyJ3oLySETSK1IKXXmeQylMNYLwFpkzzUIs6pfK8olkdsn9wwLKVmHrA3uUd9s6NWRwtuHb1HrODGcLXaFmkdLVIPYLeKmJsELKl0IFmJbl2dcV4fJd6e8KZCxIfLEKC93NUoRmNFXVtcE2EHN/KzM35MOMNbaTWDaWvUuT0PuCcR+KQ0qFk9pp9zNx9iT2bKOnn4vEGzckZu7E8HnBHD3gsnnzJqS+/z0fMtkzc9++11/gNrnrq6FOKYsPw9Xn7U5qFc7btxDVOS2g+cORI7dUag8n30Bf4VCGZjEq2q4pBMcC2gaNpwNLS2gWLdsmQArTBC48cVOyOzrF97hwuGmzQuFBwNE8y9AsjmcXIPAI+sHSRzimqADEIYhcgOhh0lGPF9s4248GYOLcsb82IhcBJg1RjaAJ0AR39sT8ePMT0451NhC8Z4RdFROtjp0YpR10N0Kqg6zpefvka0+mU0HnqsmJ1a8W//19/kUcuX+HNb34zTz/zOOPxFnU9IoSOtrUEIShLw+UrVyi14Xdnv8sXP/tlnnrsaT70n36YZnmPq1e/wmLZUlRjRsMho2pAVZRolchpO2dBCIJ3eGsRIjAeD3jX+97H0WLB5z77OSbVgP0bU7745eexsaEalUg9IIaaVTtlUpXs7u6yOxlSyw4TVhgX0BGazoHZQmtDVVYo0aKiR0nQMYk16uDQwaGCI6BPzKfNNNirjvU6Eqc9eP8sOznf7p9/J67/AOOVnbC1UXrQfF5HUf2iPXntE6m8b0X6vTdO+W8pU2PteFIxmlRoLZEqRZVSppaN4B0+tEQ8ulCcObvNm9/yOMFazuze5rkvvcTBnQZ8oF05QtbKS+hliYiKru1Qoma18nz9+ZvsnLdMdrYpiwBYrEvgpsGwYjAsWc0tKZsS8EEQvxP6pDa/5FOLrRGETDj/PgqJIUVFRiuCD+s+gCSY2It39VEFr5r2eugRZZ6z92/1r288jOHYvJLY+N37fes+j/t+vhW32V+nX6o9xLyvXfWGa93/oSRbZyY8dmWbva0hA1PhHdy6fZeXblzDxhU2Opyos4ccKCvFZHeEx9NZRxTJsB0ewGzRcNR1HIXAKjSMlcBUQ1ZdZMtUqFBydO86uojsXpxw6anLDM9uU9YDVCu59bXblOO7eKWRoaZygcovECTQTAiJiquzDcFZBJGma+jaFh+SgnNRJOmWEDxgsZ3HmCL1NUlN13aIIrJ/eAdjCvwNx9dfeJ47927xgz/0JxgMxrQrR1EaCq3piLRdixKRnbNnufzY43ziY3/Az/38/8x7vudZPvgjP8A7nn0fKAgZhIIP+LYjWJeUd4WglIIwm9Es5gwHJdYuWa6mvPs9z3Lvzm0GynD57A6PP3op9TLpSJjPiRiQNVEmRoOjwxlRrdgpA0YFDJ7FasF0CTeOBPP5CiU10gVETCALHTxKSGT0EMPJyIlXGo1XzuDXMSdPAU6cRv31oExJr177qr2E4qTLedqxr9Yw/1pG36uVllWfDuxAdNR1RVUbUl03K4xHh1Qlk60xVx69xKK9x9HRXZrVIVp7BuOasrhIjI4vdi8y21+iCoOPIEIqOaRRZOfMYFSJ7Rxf+8odHntil7291ObjfarNmkIxGFYcGZdrXAqiSJmvhxhvaCMFp0+AE2MtOgh9k29EEmMq4saYG3LDhoGiz4aJdTSx3uDja927Nz2q/sWvbxH2AdWJKOsUI7rpaG5GRH30KcTJz++VC+c1v9lX3mt2JNaf7MZNbrJdI1IP0dZuye65McNKYKRHywKKLaxaMVvOkqx8LNDKIJQCHMHNCb5AxAE+SJbTFcvDGfNmxsq3RCWpTWRnWLE9qtCiwSM5PNhnvjjikUcv8viTZxhfGLESLVFbBjtj9sRZylFJVAHROsoWKhfxwhKiT4wM0WMkUCQZDyGgKA3K1Hl+pffZdZHlcgWkhkhtCoqi5Nz588xnhwnEgWC5mgOCP/jMH/BvfuHf8Nf+7/83tkZDpKjoXIsZKKxNDZJt0zLZOcsTz7yVL37hJT756S/x5NPP8N3PvgVlIiF6NAJtQAmFDQ1tl9JrConvOuxqRVmXGCM4OLzDhUce48d//Ec5M9pmIDWFliyaOY1r+OgnP8tHf/czJLJfwdev3iCeq1FD2KpLgnIEIYnGMJ16bu43HC0dgQpiYhKRItdgoiTEnmz0dID3K9b1Zo7rm52LnJzzp0X4D+6RYl0X4hsYl9OM0olG+/7nm3srJ867rmj11xSOEC3a1Bid1kjs3e2ctJhMxjz5pGG2crTtbaJoEdIhlcCUlouXx9y+VbFcLBFWI10E6UGGXJ5IqtdSlLSNJwbF3VsL7tzo2N4yqMJAbPHeIYSgqnRiVPeBviQSezadbzDe0EbqYcLl46d7UEAm548SIUhRFIIgAiLTKUHuS9i0ApsJYF6LOckxxIbFeKXndvz4wzE99Eb0gW82vQc4waIk+kKtkOvI8ji6On0BP+gGHjpLsVFX24z4IsfX76+pjUYXkohnOp8ivKMsBhTViAuXzsBdz3LeMLvXsr1bUAwUwbY00zt424AYYG1Bd7hCuyO2hKVSHlEZTCXZGWm2jGVkapaHh7x47SqqEjzx+COc3Zpwd/8Ot+e3KScGfRaKQYFUoFSHcAtMazE+AROc7ehch9KKyfaEQOT23TtpUaokfFiWg5TClDLTO805PDpiOZuxalqGgxEXLlzgsSce5/btGzTLBkFqj2ibjn/zC/8TFy9e4r/4z/8LorfIytA0y8RODUznC4Qu+O53fR+2LZBIdvYexYqK7d0JR/P9JD0fIlKDLgLeWly0BO9pVw2+66hGFefP7fL0U48jiproYX5vyp39GUZJOtexd/kiP/z+H2LVBn7jf/8V4mCLe4cNO5MRo/GAhR7QxgYjAjNpuLlo2V96Fh04SeIQFD6lehB4oXDC4Hsg0jcwFt9oXZw89pXz9XjmnRwP28/Xp3d7rNH9Z1pD57Nru6699o8/xNp+8PsVJxfQA+8x7wtSkNo2eo7IVO+VSqGiIsaAkILBULKzo9g9UzOZlGgT8WGF1J6tHcP5i1vs31uwf9slCaQTVG8GZyNlmWRzpNTYruClFw+58uiAWiuk0AjRJaVzFTK5d6ovC+BUTNcp4w1tpIATk6D/98mRc6i9gRIp1AwhIDlGmEkEQYgTlIexb5jrT0P/uZ6e+0uS86+YvmuPIfYpx0zZcnzsaRbnIcb9k/b+bKfYYCpfG6p+Q0g3JDP7Rl+oPXH/4vSVcRr249XuT/SRVDz2+ASgpKLnQ4w5Vx1Del6pgq5xrBYztnZKxtsTGtuxOJozvbNgUo4QIqC0xfkWt5yB0PioKaPg/BgqUeG9QpQKVKDSjjJ6Yme5e+8Oy3bO5cee4szuDtNbC15++QZqLBmPR9SxZNUmOiFiQ6k6dgcSypplhDB1zOcN5bBGCJjP5jjXIZRksVywWK4Qcs5oNEEIsY6exuMJbXsPHyKrNknEjyZDLj1yBWctRweHNKuOUTliejjjX/9//jVvecvbePe7vx9vLcWgYLE8YjafYjuHUgOch/H2WQSCr1+9zpee+xJ/+s/9KbZ3znB45w6ttYyKitBatCkQMbJqlrTtComgNIZnnn6Kui45WjWAZzQa4JcdBCi0ZjZfUY8kP/ID38dnP/nbzGdz6qrgpbtLrCqYERgPB9h2wZ07S64dWCwaVEKzaSXWa8mHQCfBqRKLQsZwqqbT8TTMDtR90+5BzlTvwB3vDf2kTYzwx7puDx4nYPBiAzwhjoEO64rTxrrvrxmyCOb9Y1OrrXfSXu1e0p5C2rM2XyeyKoAQhP4xKbLjLdcArRT5KbQq0jlyROu9Z7k8RKoVly5vc+H8LmWhAU+UKXU+2R5QVSWIJtfsAzG6tJ8FhZQG51ZI3ZJQxJrpoWW58KhKADI3wQeE9BSlpPWJsNY5h39IGZ83vJF6uLGxQ5NQaN6Hfsc+Zjq4b6X0iLp+9IvkIR2A1zw24bLrvx8AjxUbhiK/jVceF/s6UH5VPBZ4kxu1IPGwRuch7v/Ee4mvlPPY3GgSzWT6twSkiDTLltnBiq2qYD5dcPfWIauF4pnxLrtbZ4htoF00rKZLRoNttDCsljOkBqEEhVJUhUaUBmMtla4J0eJiR3QeCMyOpkwP5zxy5VEuXbzA9PaU5z53lelsztu+6xl24hYcCm5ev8nWd3cIpSiqgnFlcFbRzJcIJRkMhwQis+mcoiy5cOESAZjNZuzvH3Bv/4CDgyOGwxFVWTMYDKiqAdvbgdWqQSnFYrHg+ee/zlve+gzVYMit23cJMSAi7O2d497te/y//4f/gWeeehOTrTG261jOFyymcwpTsZyteOHFl/iF//l/4Yd+6If53d/9HV6+9jymhr/4F/4snQ1ID23XURQlwTmi0bSzDus9piqRSEbjCT5GJuMRdRlopw1qdwvbBRarligVzWrB3tkJTz1xhc98/gu4AI2PHKwc43sLtiY1zi6Zzee0TVKoLlSJRhBji8JRKZIMCKnROIpXn3ivt2bzx2fclxp8QJkjRkHXWcq6oGsiwaeoxVqP0RJF1sXDYkrP+fMDlDzLzvYZtBK0nUOqQFFohJSEqIEKSFER0icx86iT0606hJxhyhFQMp+2HB4sqMdbSdgz+NTjWBeYoqFb5T1XqIcGjXxnGKneOG1si4mWY8PrghN5guM6VFxHQOmQb4Twe8XFX+Wx+5Nt+V/i4RbnRuXo1Kv0PUnkBMQ6WmLD06RPUzz8EKfmGo+fO/6sWNfwHpStOP4sIyJ4ZgcLXpwtGGrD6mjJfL7CdTN2d6dsnxuys7PFXB5xuDhETyWTyRDvNVJKfPAE79AqoLSnC57YtfiuYVAZhJAcHM6YzVomwz0u7T2KW1ie++JXuXXzEOEDd1+8h507pu2C5+/e5rEPepwacPvgkDvTBQeNYNo6nHcopbOsO2wNR5zb2yNEmM6mCGFoOsd8scB5z2K5RCqNMVBWNaumxVqHNobFsuG5519k98wOZVXilGBU1exsn+HCuT1efOkF/sef///yX/2l/4r9e3eIwtOtWqKDGAzPPP003/d938fVq1d58k1PUo8kjz/2OLa1HNw74PLeebrlnLIokVoTMsgkEBMHG4JmseLiU09iASENcTuiKJjeO+RjH/9dFp3l7LkRnTU8/sSj/IfPfJYQLZ2PKFOwWlmmRwdsT2pwnpH2SalXqUR8KpN0eCkFYy2QrWNFixL+1Bl8ep30O9tgnUiPP7CZV6BVTQgrDg8XrFaW0aQCJZBCZxJuj9IwnpRJ7sbXSKEIIaFRV+0SJUuSYGKBoMiurltvkTFGtJbsnhvhxYKumxKaIdaVdG1gLSEfA0JGqspgCokQyVFMrCP/fyO1MTKyIEsrpDRXbww22+6O/1rLF8a4nhBCyo3jvrVGCo6N02Z96NRUwP27fuTBt9NHUxtNxms0HyeZlR92CPHKy92f7hDrgx66eEVwluZoxaK13GsjMmjKYkQzhZdfuIVQ5zh3aYiXirv3DljdbNhenaWua4QIRFLeO/VZObrQIKOnJLBsYTVbsVoGtrYusj3ZY3Gv4+pXnuPFrzxPiJoial746guUV4fMnGOqFM4pXryz5OX9FUvviaqgHI3YGQ7XsvDWWZyP3L17wGw2p+sS28lksk3IDk7XWY6mUyaTLYaDIUVRsFiskuRGWeOD5N69Q7Ym6bm7+/c4ODjgkQuPsL094dd+/VeYTEZ8/594F61dEqwjCE1ZDjmzs8df+2t/ma+/cJVf/rVf4k1vfRM7Ozsc7R/hOo+zjrKoWazmSALeRzpvQUuMKmgaxxc/9yVG585TTUbM5jOUF+jQslzOUhpJwuFsCrJltL2FJzI9PGI8HrOazTBec+X8FltDRVVUjIxHikgkyYhoJSA6VAjooFnte1ayRWGzosBp8+w+A/Valt0ft5ELTusd4wGRFBFiUDgHB/sLbt3YZzzZoyqrZIiIIAJKicT2LwOqKMAbnE+ObVGU2A6Wyw7bSbw3xNAjcSM+6+xVdcEzbz5PMRxy7do1br1MZmxReJ/SkN47nCPXaZOzkhSSs1bfQ4w3tJFKDa3HgLljFuKcMkNspPg8GUqQ5rvIKS/ZN6+K3GiX14IQ61Tfpk14VS8G1o2q9Gd6DTZgbaDWxuoUY5Af29TJeWUKMq7/f8wifXyNSG+ENzaBB4oqnlZ0FmuPqn/6BKnnGnSSdZTuu/eT5w7rv2PwBBcxvkAnXBoKQ7NsuX1zn8HYMN5V6FqhK8Vq0cJ8SaBCGwMiIZlwDqTHmwg4jHOs7h1il45zO5fY2doDq3nhi1/j2nPXCU3A6hYtE3P+atagigFClUQ0t2aWWSxQlWEwGKC1wsfMvCEkShcYUyYIuZ9ycHAIUlLUJYPBCACjHW3X0XUdSmqKolozTccIbWuZjAfYztJ6S1nVNMsV125cZ+/MBaIQ/Pv/9Zd49PFL7J7doioG3L67z9akYGuskEozHA04d2aHVXPEc1/+PHQdjz7yKNF7ll1HWZQQHDJEtDHUdU0IDlBcfuRRlvMFB9Mj5qslq6MFtR4homE83mJ3UOBlBzLy3Kc+w2y+4mg6Yz6fcW5rxIABNJrzFy9ydremEg1KBIRQeTP1iWoqgusUd5crtPRIfG6ZPznWjtr9aa7XMjZKx72/tAY+nJ5JP56n8ZWPnXbcab9POMUnSKNfyzh5tp6wgAx6SBv8fSsqkwGEAEZXeDvn6ou3mWyVVGWZmB5UYt6P0RGCR8pI8BZih5QFShR01jM9nHPn5hHLhQVKEiYagowQbFrZASZbAx5/ZsKZswO+Vh1x9+YSrdN9CSnQ2uA9EB2IDNoSiX7sOyLd50VFFB6BBeEJwmemBo2gQGAQwmJElwgXQ4cQAaNTQ6TM27WWBdY6uqiwPhJ9ZA2hSHTNCR0jZfIO8ubUy1UkCiUQoV8VIkcr4B/ue0gj9ulHsa7T9AutT5310zJs2L8sWns8ZWO/TAJR5b/6JjxSA3PY2AR6AyXye1kHaFnv5WQqMtG/wKZT0HOkgQiZ6ThEAp6AS59HlIlGRggIEEQgxpB+KxBSIHWB9AptofACpSCEFmRHu2g4uL7PzlbBI0+dZXB2xA13B20USrjk6SmFUBqEBhGRrkFKyWoVuXcUuHD2PJevPA7WcfX553nxuRdwc0mlzqJiS2sDIUoqCugEyghc8EwLSVAVZSdYTVf5fhOLgVSSwhSURcVgMEApxfb2NovVCtumtIaSCpObWp1zLOcrtDZIoWjbFuECVV0nJJ5QxJBrA7ogCsmd6RFlUUNUfPTjn+BDH/qzNJ3nS1+7yc6Ox4ohW5Mtrt94kfnsgEJ5/PQuZweGLeWwyzlC18xXgbqqE2OJg4qIVDC1cwaDitgJCJ5ueYSPARsUoStRDFFhBSJgym1u3Z6yajw+SqbTGYvlEscu0SgOlw3f/6638ebzu8TlAZXWFCoghce5FT4IlrHAFAWqHuNUAyrxZ8rNtDr9RA9ZLJCcfjo50nI7duj6daNE0n2VoV88sDYY8XhdPXAp3rduI4nrYr1m6HXCssOYeg2IIRDxpH6iCPj0irXgH0gpjs/fe9gbK/iYzik/F8GH7HiLnrkmpd5C8ImjNytzpKbxSLSRGGvuXGu5WjUMdKC8UmMGkYhF5fOLAFJFYlgghCX4gtWR4uCm5OhuoF0uCbYlugFCBpRuiapFaEMQNc2qwagzXLq4Tang+XJOUa0oqi1aG1PvaTBIDCI0KAnRK0I8nbDttPGGNlLp+4vHM1r0BgUIiQVYhA6vO3ShqGpNWSqqUlOXZWa9Tkaqs55p62haR9cmiK73IIKEkJA1vRe2nr+b4XZfezkRdj04Q3FaM5/Y+DkVuSc2E5Ibf6yDneQexvsejqKPrDY6UvKJTitcJ0N3fAOb6UfWqb7+XMfRZx9BCdLCDcRMxpu/F8jMFjGff9PjTA/JkGoXMkaC6xKvm0k6Tsv5ksO7U7bODdne3uHc2XM0rU39FxKEjFkGQCV+2qASrRUFZ89d4sKF8wijePnFr/P1F79Gax1ajwGFDB5FQKJBa7xQrEQgSJF6PlagpaYsSoI+prhSSlFVFcPhcJ2CkVLmqMoRQ/ocisJQ12m5tW1LLxDZM1IQAs6mPiulktfsnMN7i1YQoqTpWj756U/zzu/5XhaLlojmcLbia1/7OhcunOPzX/wcV1/8Ome2R5RDye6FRzECnHV43yGkJliHCElKJIrkkY+GNdPDI84PdjmYzqlrg/ctZVlxMPN0XSCIhnvTu2zvpTSlNIawWmLKihgs+4ep5uUDfOozX+Hs972JS5Mx2I7SaHy3opQCKwRahOz0ibS7PmCVHEuz5brq6QtpPed7Z45+nm2smeM/xOkLcnP+n2LAjhMXJ9ftZhS1ZqwhckxIvHmGk1tG/8rjqG4jPZKfi+usRAB8/rxitkiBHha+hsgT0VIAGh8qbOt56YV9nHU463jksR1MaSAGtC7S6bxDiIhEYVvB0T3HzZfnTPc7ZJRIeqSiyuoEqZ7f2Y7FcoW3nmooOHduQAhn0UWJlCl7pY3GOYUPKfJK7zf1pIbvhEgK0a7nghAqeyieEBxSBozWVKWkKiuqWlMPCuq6oDCaQmUJDiRGGToXKG1H50KKqhrPct7SNR5vA8EHiBopU8EvhIeVoTjltsXJvonj+s3/0YbYSI9sAixe280+7NEiJOMlsyeZREcDQiWCVhcds+Wc23cP0HVNWQ1o3QKlNTFvelIdpyK9SK/rlGc8GiELw7VbN3nxxjVaAjsX93BLw+poATZSBIGUCmc0M6NZ1JogBXuTbeJ4xNHdA47ms8xsnGC8MUaGwyGDwQApJUWRKI+klBRlgfN+fVxRFFRVRV3XrFYrmiYh/CB5wNb6FFFKjRDQth3L5Yqq9IzHBiklh4f7/Hf/3f+TJ558M0888WYqabh2/Rr37t3ht3/rt1jOD7hdF4jHLjP83vfg0XjrcN5SliX4FiUjw0GJYEhnJSo03Lp+g62tPUbjMYNtwaUrI6LdYVBHnnvuy9y9c5vBpMC5huvXXkDLSGEMxIgyiuVqybVrN/HdLm655CtfG3DuXW/Fe4d2ErxEK50MN5FCC+pSU5eK1eLhONz+OI6H7aFCOBDtsWLiWoXhfoMY014lElDC6JrVcsHXnrvOdHbEjRtnOXd+xM7ukPFkSFFkEyACbdNx9/aUrz93yPWX5izmHinKFJm5MmVfooFQITDEkNZAiEl+oygMe3vnCIDDEkLi2Ywx0HUpi0B2GyM+s7B84/GGNlJCWJJ1F8mVjjExOIcOU2qGY83WpKauJEpBUWiMEQhcAkHI3AGvAyp6SukoaokgIVSMCiyVZ7WM2Db18IQYc3b2teaY77/3+zyyB4Vc/zGHIBPPbjz0TdznQ31SkdyNnsUHRZLEQEd0ISnrIUUBui5ZWMfdoynDgSd4jylLpIgomeyHWEfXCV2mVJK/vnewz3x+xGB7xGCwxVCdoVtIQoTV3RWVVyAVcy25V8DN0GIF2NmKo+kcKyWqNGilEprQe5xzOOdYLBYZ8ZSWlFKpFmOMIYSAz8YKYDAYZDBFh/c+p45D5plMch7GaKqqpGlSHattO6qqQgrB3bt3ODxcsL19jq38/dy+fZObt25hpGc1O+QdTz/N+bf+PKaYphSUDyilMt+q4FzwqajtfZIS8YLx1jaTszsoE5Ha4K1mtC1RwxtMp7fZ3p0gpOG//q8/mxJZPtBZh5IiX8NRFjNKozmzdR25jBy98AR0oIKizKGQlCrx+AmXGLdf51p6o49NQ/VgCQ4HojuOPPuokLz30f+AkKovX6FUmdLTomD/7oqjgxfZ2hmwvT1ga3vMZGucmmyDYz5ruH1zwf5dh20LRKizsYuZ889DLHKq1BAzP5/zSU4eqSmKAhdd4pmMnkiSsu/aDuctPTF2jP47AzgBNv/WyCiJwaGVohrVTCYF40nJoDZp0yKgTUoJxeBzeL0BfxUOhEXIiJKGgZIYWTIaFSxnjnmWVfbWZ4DF6//oTiDi1uH+/8HGOjt4IrHxmk7xjY5eZy1zMbWX6IgyIrWkHg3ZOTeiKEHVEl8JFq3FhgWjQaqxKNJrRQzrmpkSMmeKBCvbIkTE1CXbu9uEJkJb4QgsXEvmnschmUm4rSNTKem8p4iSi2fPcGM5ZT6fp8goNyn20VOMkf39fay1LBYLqsGQEFNjpVIqR0qWpmnWUdVkMmE6neJcSn9BUv91zufzVkwmgunRnPl8kdKDKjKZTJjNGj796U/xgz/8I2ipiTFQ1xWr+QG10Tz15rdhhp/mq7//1yi8RXQrcB1KCXRZoodDPIrOOWy74s7dGf/ul36ZZ95xkfd84FmWrUPpPb7whev8wi98nqP5y7zn3e9gZ/sMv/LrhsFwjFCGrvMQsuK1lLTLJb5d8vij9/gv/8vf57d/55Are9s8fnmbrYGg1BqkRioQmeUledffmYbqfgP14IhqMz2e89s95VuMyXjFBPsOPsnHp4hKrevzeInzloO7noO7R5higdF3UDrigyN4SdtIZBwTQ5mFYQPedyB82kejhGgQaGJ0WNsSQovWqUbnfMBnVpYeRRxjwDqXnbTM/7duPfjG4w1tpIQImYW6ZzCP1JVmPDZsbRcMBhIlIeV2JUqrxHLgzdshGgABAABJREFU028p+47vVADXSJRJX7IgUg1MkkQWCi0kR6xY+JboFFGkhRVC+jL6es+6+zxmYMEpc+7+ptf0x4PeY9/XtAk5Pf3gUzvv+0xiZAPAF9ef1yZQYvN6ffgkNmoB63Rf/5oeDdnXBE4ssFSbiULmOmGGg8Qs6yGPj+uh/an5N3fLR782VMJIBpOaeqBxyuG0IDNbIZXK67Rf4MdSCgGBcx6XI56yLhKvnk61SB9g5VasbEsRAlZoOq05jIF9H5j6dI7Z0Yzp4ohZEShMSWEKgHVNSWtNWZZYa9dpPB/BmCrLePt11GWtXb/OGIPWmq5rUEqngnn+Hr0PKJUcJiHUOqKSpWI2O6Kut7h+/Rqf+9zneOfb387W1oRze2d57uAmo3rM3oXzBCSdG+KbJZOiYj7dT6wCoibIkg6NUIpSjxkPtjjYj3zxC9d59w//AMvlFF0YnnvuLi9ePcJFx9ef3+dgS3Lj5QU754YUhcJ6idElIhZEpfC+4GjmaMOQ63cO+PXf+RTjUvF93/0mnn3H45zbGaKjxwaZ99i4nru9jtvpG/W66rR+/tsm4CnSuu7rhutrfZN2dLMto69ZxrwO7u/BXF9r43Wxb36lSNIyUSMy96iSEo9FIJPoa/T40OJjAn8JoSHqlFqLZTIuPiRUnxWsWo+QATAIYVBUEGu8A1VIYuyy8w4xWqSMCKeIPgHJTCEJ0aY6cBKuThmqXLvyPuJcyDXp1IvVr9OHHW9sIxUzAi+zKReFZDQuGY8Nda0oizwZPBlqXhAc2C4QRIJIKiHwKv2NNMioEdKlVFMAjMCMCwpt0gbrPWEZsP4kXf+JjT7/Xq+h1+Ekbhqp/mQiIxQ2F/NpNDLH23X2wPI6Py7GptdFIU69xfV1xeZb6I1aXL/J+7Ai+R6OFxlCrLWyXvFhCHIUkY6ROcXea00FEfB4oo7IQiJkciSESGKISI4NboJs5PvIBVpJeo1SaKMxxXGDYVTgQ+LaC0qxiJKFhCMiHSpvDAKhNdVQQyWoioq6SAapj4gGg0FmO4f5fI61ls55hiNNVRnKssQ5R9u2eO9p2zal3qREKc2xBtnx5yOESPWqCFobiDYteG9BSJx3DIYDnn/+OZbzGW9/65v5ru96J4uju+Ath7N7SbKh0mhds1jOKSdjbNMkiQUkg8mA1jqcjwyGI8qyYtUsKaskWrd/7xaLxQwpUlS6s72NyGTMEkXTtCxXHUp3FGfOMCiTHMiqWRF1ixeBTlZc3z/i1z72h3z95Zf5E+95J09cuUKz6Fh0jphTU+tJE49nl9iYyyfWwwPm/cZBpGb9h1t49x93Giv6mhrlIcemo9ev1Vf0Nq3X3UNcP5pcZlCIoIk5knLOHnuhOBBJi43o87Vcqp9nI5GVrNL/Q0qNJ4FOgQiKGAuICqXAh5aiclRFxNol7WKWHfoB0iuiDGgdkSq19/gAiTg4gSSCB2cDtgt4lwKF2Ctun/SaX3W8sY1UMEjAR4vUgsmkZmtSUZQiffAIlNQED13nab2l6zzdqstaUhKtJForpBZInRij64GhqDURh3MJrlmWism4IobkqbhFugel1Bqq/cYb4iQ90mkL6duUgewhtuutua//bjwfMgrIiwRVDyo1YWuTOBej71FCIdeTRUKsIQlCpJYE8mYvBFrr1GAaI0JElMhqx0IQjKFRmqNCsowRETUmM2e13jNvLY21LJgzrFJNyXtPXddUVQWQUX0mpQPX18nXzVFC1/dKKcVwmBp3pVydAKf0n7kQEqVS1IUQOOuoqpTaWy4WjLfOEKLk+vVrXHvpBd72lmd43/vey+c/+wfcvv0yh0f73D28zeOXH0GOBswPjzDlkOAS64DrOowyeCRbW2fRZcGtuy9zdLSP8x23bh1x7/atJOQYPSJCs+owSiMRLOZLVk2H1BZnLVVRYLRMBXJd4oWFchtNSWvnPH9jSveJz/Lc12/w1JWnkOWQxu/nrMS3fIat59E36yWeWAuvMxvZo/dOSN3HvFE/1LmzIxMT8KBnz+nXA6Ij0CFVIOKy8xdS7UfItZGS4thIxNxak24oOXiJ19RjCon1S86d3+L8xRHOt7x03XL33iGrVczChh2mAJPUaFJSK0gCZNXz1A/lrKVrAyEIQCdDFQXhO6EmFZ0BFUC01JVhPDGUpcgbj0KJCqKiaxsO95esVhbXgesc0UekEklRVEmkEuiiQBnB1lZiBTZFv8nI5JGPDIgBTStoOo+1eYPjuGfijTOykZByzZxw/FT28L6N6ZR+ofQRF5D0amKO/fLCDaRWAk8AGZEq9YGE3JNCTEwTEU1AEpCkPDy44BO4XUjEmtY+IIkZYAE6JpfPK027NWBVGPyqo3SSSpUYoQmFhuiphECSjMtwOFwDHzaVmnuSYevcuhYVMhGo1hrnXE7nJRBFVZUZ9dbTVqU0SfJCfWIGEIoYIk3bMBjUlHWFD4Kjo0NG421GoyGCwJe+9AVKE7h44Ty3b73E4eE9/tv/x3/Dn/zAj/HoI0/yxJUnQZWE1ZJSCXAdhRK0StF4RzkY0HnHdD6jrGseu/IIVy8e8vKLL+DDkNKUHK1mlEWNs4nJQklJPRhgraXtWmKQqYETAbLA6yHWpvUVTMXdhWf6wnXmjebC2cvIoiaQxPC+tXNsM40GIF7TdD6dlun132PvIPV/P7z161Mg5PvwCOGQukPIDqFWCNWl2pDSiKjxPqQskhIED967lGqPApXRzcefSQ+TDgiZdNKkWrF34QJvftsFQlxQTubw3JLrL3coIxlv12xtV5iij1yzAY0yRVJB4l2kbSJN4/BOoFCZlUJ+ZwAnYtCgHFIIBoMSYyDSIYXCqAJnI/PZnMPDJbPpCmehl0/u1XkdASsSCkWbhPiLPmLblsmWYTgsktdpk2aKMVCUGmMkXdesNyGl9SlMFBuTMHLyN7wiR/awS+C1TO0Hn+E4hXh/jUwc/+Nbsndspgr7mkKiahIb7yWlI9eJyhxe9XSYkdTtrkTMXn1PqxLWmYMoRNIzErlpuPcoeyqWkHhfZIy5MVOsxci9kKyMZFlIfKeog6aMConAElg5i+haiBLnElpPa732to1J/U7GGCaTCfcODlMNKaP8VGZe2ARSOOcoc7+e9y4Z02xIQ0g1LNGLcgqBs5a2bRiNh5SqYrE44uBgn8lowng0YPfMGT75yd/nve95F6vVnHpQ8viTF/nEp36Pr798h6vXD3jve97Lma0dlG1RShJcB0XFrXt3QeU6UQwE7zg8uMdqMcd3FqUlo3rEHbGkKocslh3EBNlvmgapJGVVQbR0rsX5QBQSYSqEF0QpWMUZRiqMLnj+5VscHlkuDy+86hQ7LY3+MPPtRFZgYx7ff61T09z3rYeHqX09zDLZjKIe1mAem8Yc1uNJ8PPUlBviEq1aJjuaM2d3GI4qBDXNKnBwb8bR0QJnPT3PfJLxEJBpxBJLy3H+X/S1ZDqGY814S1GPPKZQPFGcwXnL4eFNrPPs7IzYPTNBqTbNbaHwUWbwT1JEb1vPctnRtZ7gFUr2dbeH38He0EaKnOIRSqFrjTARj0Wriggc7S+4c/eQtvF0nUCJCiUrEAEtIxGXIu4YEEITrCbiWc4ctu1QCgZ1RQgC5xxFISlKw6h1HMxWiFVLDFXGhfWl+uQ1CykIISavPtdYUtf8MVBhnYiIm++nz2fnmtKJWlNuez01DX/aYkreUV+jOS6WpXNJwXqT7hfmcXVErOtNJ64TM7lUfk+nkzdtKs/02lUpvSGAmGuJEUeUjihg66zj/X/+iLBsKISCEIky4nSgnER29+5SjQqkDDlq9YSYgAxKaSQppdZLG6T3kDw1GwIhBrSWKBlQMSCjIlrF6NE5W88c0caCeb1iriRd56kwhM5z445CFgVDYWClcT7QWcvh0SFFYdA69XwMhjVKa+rBgIkNLBvHYrnCFCVFWYJIMG1Emq8uBDrnEvOEUmB78s5sfEUP/Q9Z00rhfFIz7RqHKS2jYcFstmT/3g3Go8cYjsacu3CZ3/v0Z/ngj72b3d1dfvRP/jC/9sufoPA1L1+b8b/5T/KDP/hOtmSktpKtco8b3Yz9+ZTzVy5x9fZzXLr4JHvnznHz6seJdsa5cUnXrqhCYCgtkxLmRwuUKggSTFkhBGhjkEISnGM8VEiOELFDSY+NHqlLpk1Lq2BUTVgIw0HTMpYSRQAfU/OolHgRcbknSNIX4l99pCglqWCHNQAo/29jKcVstB5mm9wEMfTNuiI/nmLe48pvpnzoY5LNk6ydsle/WPrVHyVPOG2BIDpiSGw6EQ+iQxcdWzuSx544yxNPPsJ4PEJrw2q54tq127zw9dvcu21plp6gPEon8lfvUhlECEdEIVF5XQpEzk6d3RuyvWsoSksQC0ZDySNXznD92iGFCVx+ZMxoOEg7XwigLSF02HaZG9E1zSqwWgScTRGczAhWkMiHTPO+oY1UZqZBSEWUkiCTTHIQgdWqYzZtaFeOpMphiNEQokiy8coRaNFaoGWBFAXBazrrsV0iRlwtLcErvAz44InCI42kqDxKzVMKyRu0qFCozMHiUlOpyL0KRHrFZYlIBI8hrr273gwIQKjEetv3EsAJ+3WimHwqQpBjY3XstfUv2pj8pAUgM1BBhp6KBXpmiHTNtebnyc8dgU/Ec4lHbOO5kwtU5tpgzMi9FPIk+WiyJ+cJRH7x/3UOERbELmJwaVMKEqENtDWtGSCjQWqQURFCSxQeSoOSmXYFmWpNymM0GJv0dAKCjkAoBIWC6BwyCIJTrOaKu0eKlRjiloqFt8w7T4fFVDW/8b/s4a2kQOBVwHmHkJFAwEeHtxY76xhNxhBVmmtSMx5v0x0e4kJEZ6+xj/ICgugjrXUonRp4ySwMZPJOJRVK92nYiNIC7RUChW07isJQakGjPd5bDg9vE6NDSEM53OYzX3qBEOHZd7yD/eePeOEFx72l4ksvvExbH/ChH3wvo7CNXdWgLY88/ijFyPDrv/HL3Lx+iG8EJkaknxGbI568eJm3XnmUx/a2+YMvfIWjw3s0AtRgQONC+t4zkCRIiRYeo2BYCqxK2QnnPEZXiLJgJSStC6jYUoiaUkiUB4NECo2LPn9e2QREASmJeOo4iYhLDl4yVGvCrp7XNE/unhTtlXIy96+p/t+945Xmcb8yfLpCjvz7xtoTUKQ1sOHhxvEdZ681RtCOJAuvUMLgXSAKx9a25rEntnnqmQtcvLAHQiJVw2AcKAZDTLGHCDP2760oyogpLaulYzXT+GiIdMQgCFFlZvJADB2DieLi5S3G2wahulQBC4HRuOLy5Qk7u4FHr0yoTJHX4wqhWoJZ4bolQZQ4Z5hNG5bzQHACJQNRWJyLeBcR4uHMzxvaSPWbb/oekwx8VVa4LrJ/6x7zA4fNuX9EygXH4BAyeRRGCybjEaPhhOAltpPcu3cP51epABk9LlhkBG0UxiiUElRVSVVVzERK9yFB5OLk/bcXMw3Q+pn7vKVXG6dO69eX53vwy9fW7Pj3t6UilQ0huWbQf2Rf/P0Rdu6JjaeMAhUVIkhEoRntjbj09A6j8yVSSSQmcfoJS12XKGkg9r892gSqErTzxKhYhkgXA0WpqQ1I78BB50teeHmfz3xZctAWLL2niZJWFlgJuqoRQqIzUsxogzElNnp8cMSYgDUhBObzOYt5Q9s6QFIUNaPRiM5ZaBuqqlojFoUQuJDg6NZYQGS0n0LJuJ5HydnRWJvqWFprdIaqEyNKSeq6orMdR9NDnI/s7u5RlhV37+6zaloG4wkf+JEf4MYNuHoQ+PKtq1x9+Q/4jd/4GH/uXT+CEQ2FiZy/fIHF/B5loRiUFUZoBmXJxb2zfP87nuV7n30XRSEYblW843vezSNPfYpf/ugnOFxZlFK5CN4TNieASkIoSmJUaJ3SSkImsxBiMlzLYJk6wUQYCmVQUSJCQEeBQxwjT1/PvBcb9aiNbMJrHae95DhDkde5YC1Ps3n9TSTba4XQC1J9B6GTMyYk5D1se7fm4uUxu+cUupoSQgIXhdCwfUZTVedQoubWjSmT7ZLRRHPz+iFXn18xPSDpRQmIMUHRpfKUA8cTT+3x2OMXGI8lUjZ0ToBIjexPPfUYPkqKskabnj1CIUTEO0mMBmcls6OGw3sLmqXPkVpMvJ0hQdOjergv9eFE5vP4qZ/6Kd7znvcwHo/Z29vjz//5P8+Xv/zlE8c0TcNHPvIRzpw5w2g04sMf/jC3bt06cczVq1f50Ic+xGAwYG9vj7/9t/92psx4baNPIRGz+m1UaFXSdZHFPIXGRpcJaq4yzXxokdJhSjhzdsLumQlnzm5xbm+bqpYgO0Js0UVC+SmV0oJaC7RJ1DtFUSbCT+RxCuGEtDKkqfX6mSn+KMcJ5NG3cfQ9U+u6wWt4beKbk5BZ0kETgsYHiXOSxdKxbAKdk7RC0ymFF5oYNTJqgpVAhdcjlnLAXW84koZWwLJraZ1NHrdIPriRilIb6qJkPBhRD2qGwyHj0YjRaMTW1oTxeIzJ9amu65jP57Rdm6KKEOi6bj2/+/6oY/VUqOuK0WhEXddrJGAPQU9/53/r45Rm+hyhKArG4zFCCJbLZYa3a6SqOTic8ZnPf4Hhbs3Fx7f5wQ+8h//8P/vPeOdbv5cXn7/Ol5/7EjYeMqgEW4MK4TuwHXdvXOfWjZepC8Nf+HN/jv/Tn/0znNvdxmjFYrZgd3eH97///fzgD7yf8XDIzvaE4aBGK7kWuuvVp/vvu6/FbUb6IQZWruPQtzTC47PKqAgRFSIq1w+/VSuoB1Nszr1vxUnvr3/d3xd1/0+/Jzz89QVCGAQJMGNdIsoejgyXHznHufMTytoT5SGqmBNFi5AOqRqqYcvFKwVPv3WbJ5/Z4omnU9S1e3ZICI4YZJ5TDmlWFIOGJ57e5omndpnsGKTKkX5WNQ/RM5gUjCYGIRsiLZ3riFEiYkUMA2Ic0KzgYH/F7LAhWBIHapQIFFpqtCoSM8ZDjNdkpD760Y/ykY98hE984hP86q/+KtZaPvjBD7JYLNbH/K2/9bf4d//u3/HzP//zfPSjH+X69ev8xb/4F9fPe+/50Ic+RNd1fOxjH+Nf/at/xc/+7M/y9//+338tt5KG6IlJZd64VNJBmbc4C1pVuRmSXEwJSBWph5rJVsXumRHjrZKqlghpWTUHQMNgpBmPCwbDAql6pEvmkwsxFbJPIGO4D6mSO01f28f7H3X0G8f9P9+OcbygWW8Yr+U+E8opgoxEkRCAzkf2D4/42gtXuX7zDovGYgW47MRKEhBUOTCiAFFw0HhuLDsOQ2TmOloZCToZg6IokrSBVMgAruloFku6pl1TIXVdt27Oreqauq4xRtO1HW3bZmFEhfee1WoFpNpSb3wgoQGrqqKqasqyWBspKWVqPN+EsYvjZtDjJs9EvVTXNVIqlsslq1XDeHKO+XzFv/43/5abhzcY7EDr9zm3u8XTV97KlUtPc/vuDW7c/SoyrnDNjOXRIaWERy9d4t3f9V1819veypXLFwne4l3HeDhEao2zjug9b3/Lm6kLzc5kxHhQpxqd0kilyaHyCQPVG+Ye7RhjpCWwkJ6F9LQq4HroPmwYqePfr3Pmnfh135/f3BlzFPWqhooNA5nTka8V2p4gPiY3zDqEDFRVxXi8hdYl3sXsCHmMNhSFQemALjp2z2kuXakYbTuKumWybRgODULE9H3JiC49kx249GjFM285y97FCl2kRl7nMoqViDIRUziKymKqjiiXRCxKGZQaEH2FbQru3Wm4feOI2WGD74AgkVGiEn10Jj14uP3xNaX7fvmXf/nEv3/2Z3+Wvb09PvWpT/FDP/RDHB0d8S//5b/k537u5/hTf+pPAfAzP/MzvPWtb+UTn/gE733ve/mVX/kVvvCFL/Brv/ZrnD9/nmeffZZ//I//MX/n7/wd/sE/+AfrpsiHGiKsw+gYBDEo2sayWDR4D0GmPGqIMRXcZcQUgtGoZLJVUJSgTSpAHs0OWLVTqoFkZ3dEPTBUlUaIVE+RGRWTusQFMeTegzwJ04YRNiadyIbq9fdQvdo8/saG5JXPvyJ2OWFsH4ai5cHjNfeViFP+eToWIw9PFBYh00JFOCIC6+HO/j2+9uLXOXdui+2zQ6rBMHH6ESEGigCFgEIKltZzNJszb1tiUaCFRviCrBuaLhVC7p4H5zzRe6wDWRqK0jCshpRlQVmWDIcjghfMZksSD58nWpsZJVJvVNJv6h2reOIzvn+zU0qlel+mSNJK0QV34jMOMebGyUBV1RgNLqReLOYNEcnLN+7yiU9/kj/zn5wnRMNqccSVvct8mZIzuwVbuwWDSnJ45ybL6QE74zEqBHxrGRQVy/kcHQSjQcXdw328hKZZcXh4wJe/9GWCa/G2xbuO4ANK6nzvCWHZG6eeeaN/75AMdCc9rYisZGRFoBTJoxCxVzDihETNaeO1OlMiG9D04ledbA+4HhsGU5w6108017/igD41KDIzeDz9uI3UYQiBgM8M+WnYLnLv9pKiHDLZ1oy3SlRp8E4SaJE6pB6q4NBCJO49kZhctJZoo7HWIkTDsA488ug2jz25w/YZQTlw6MQfzGzeEaJCaXJmqUkSSTq1UrigMTESLCzmgTu3lty4NmX/9pLQaaqyzPVtv3ZSrAP0tyHdd/84OjoCYHd3F4BPfepTWGv50R/90fUxb3nLW3j00Uf5+Mc/DsDHP/5x3vnOd3L+/Pn1MT/+4z/OdDrl85///KnXaduW6XR64gcghkjfCh580i7pbNIW0lqCSEVlKXsvzmOMoKiSbAfSUpYSIT1NMyPSMdmqmWwNGI0rtAHvO4rSpJ6CINCqXBuotKnInNMNGTHXN8SRjVl6D/2Xc9ro0YAPeJL70wNyDVV+5Xn6Edcb2PF1+7SRzBvIOmLiZOT0jdJ+/ea6iSjcTJ+c2hS8fnGKpp1PXF79vUkhE5OBTFQviQ1cHtfwhIAYM5Flh1AWoSwoT5QeG1tWdsXKNuxPD1m0K2KwaDyFjJQiYHAY4QndkkJC8Jaqqtje2aUcDFCFpqwqpJLEEGiWK6bTKZ3tgIg2muFwuI6Y0meRDNJyuaQsyxwNmRMppZ50tmmavCkkZ6fn/vPer2HmSqnU0pDZ0RMSKiHn+rphCIlmSZAis6JIhrIoC5RSdNZirUVrQ1Fv81sf+32uXr+KECuWhzfYKgqeuPQIVy5f5MKlXYJvUHgef/QR/q9/+f/CI5cuU5UV0+mM4NJ3vVotUUqxWC75+Mc/wSc+9jv877/+awTbsZwdIoJP6b4syZBSfjG/t+P0pTHmRHQYpcCqSCMsKyytCjQGWhXoZEhtBxKMUifmUz+PN+fpN3Kq1vP5m0zzSdnP6Vev1/ZO63q9v8r1XsEuARtp3rxWs7qDEKlmJFWCoE+PWr78hVv84Sdv8rlP73PnumZxNCL6AYUZIWWRUmwisYRolZrDE1WYA+EwhWV7V/PkM+d501svcemRLUYTjZAdMSb0s9ElptAgPQGb0H/S46Ojsw4fIp2NHE6X3Lp9xAsv3OXGtUPmU4eMJdEJhI9oIRMZMRGt1UN/Dd80cCKEwN/8m3+T97///bzjHe8A4ObNmxRFwfb29oljz58/z82bN9fHbBqo/vn+udPGT/3UT/EP/+E/fOUTIrIpRRayJo/zFq1LamNoWrDeEkO/UDRFkbwCrQXOd3grKArNaFQxHBqqSiVWgxgAjVaGxDuV+LFCELRtKngjjrm4jqOmnGOKkkRie99tn/rtnGJ0Nv7Y7Gna1IV62D6OV1z7deQ57r/mN5vb7z3a4+beV44eNdajBqVMP851eBxSG4SsCNHTuZCkVgJ0LjUyRhHz1xJSY7CQiTBT10Tv6RYrgqyZLxcYYyiqEiElrrNEF7Gd42g2gxBQUqLaEmlUlsNOi80Yw2g0YVCniGpru2E6WyBspMzMEl3XsVqt1htXb4TSRpTkDNLGlNKBdV1vGPuYiJOrCqMFxiiKQicwghI471MaWqS6K9Fju4YYQcoR+wdTfvO3Ps5/+qd3aadziB1PPXKJC3uRopizmncIIXj80UepBkMEEts5ClNhm4bWeYJzzBZzfv+Tn+LTn/40FkEMiZzWtoJqNElNvDGhU/seMvL316c9+8f659Nm7vG6YOkteE+JppAKI6ESWSwzQ7433bxvNh2dgtbXtm5eF+Li1c66uXZOC+oEx9GeiCkSIhBDJHjN4b7nYP+A+lpkOfc8+71v4tx5g1CRKFN/WvQ9V2AEEvu9tS1RLJlsFTz59CUee+IMZ8/XlHXuw0IngIMDKRKq1oUUqTsfiWiCjxACzQru3D7k1o0pL1+7x80bU2YHFu0HmKKkVAUhNEjiWn4nZKXehxnftJH6yEc+wuc+9zl++7d/+5s9xUOPv/t3/y4/+ZM/uf73dDrlypUrwEmkjMwbR1FKRuWAYTHg8HCFW+TmOSHQOiGNQrBEUhpHUDCejDCFoq4LTJGQSDGCUhqlSqRUEFNeuGtbVss2FwI3I4ZNCFFfk/o2ACfiSV/utRqq1zu+FUXnTQPVe8SnHAQkjzRmyDtREoMEUrTig0pULEHRtoK209S+xFqDc4YuJrCFlAKpASWwLoKUOB9ZzlbEQcFoOKRpW6ZHU5SUVEVJUVS0bcdqucLaxGvRtS3CCUyRDEWMIrObr+haT9taBvWArvM0rmM2mzEej6nrel3HOvaQj993It5Mf/dCis45pPSZbFZRlhKFR2mF1jo144qYnaSAlAKtyc3GySBKBiixwx/+hy/wJ9/3Hs7WZyldw+7OEM0K23q00hRlIsMlgCpKQFNUyZPGOoLzCKm4cuUKW2fOUNQ1X796jd/62O9y6+AwpVSzMrXSJhPmihPRlJSSEMIaOBJCZiSVgihh6T1L16CRVLJgIAzbQmCiQDuR9mh5vN435+PmvHzQ1Ly/uXftHP3RLZ0H3hf09dkHHdVHkrkJF9b7UQyGEDw3ru9z4fIdts+cQQZLonbQxKDyXpUo5FbNDGUcjz6xw8XLIx5/4jzbOzXauEwkq0AovHNYG1AqOeYhSKIvsC7mJl3Hwf6KW7dm3Lp5xL17M+bzhtUqEINGyyq1etgkTNo77DE6QpTH3KvfYHxTRupv/I2/wS/+4i/ym7/5mzzyyCPrxy9cuEDXdRweHp6Ipm7dusWFCxfWx/ze7/3eifP16L/+mPtHSqOUpz4ncg47NctFTCETh99wAC7lQRPXVUruZhRw4uuTScxQZjjvcFin5szc15AKvianYjRSFDRNx8H+lLa1SQAxpImVisEcT/r47TNS96c3Xiuk9fWM++tV31AH5xXjuBbTp0cfbPByA2VOWUZIETEGrQ1BBmIssFazagLOVxTFDsqMaLqC+VLQKsBIdKlxUmBlJGoQwhAo8F6zmjUUo5LhYICWHVIk+Y2mtQmhBwhradoWmeHiWhvKssj0MgkQ0LQNXeewXUBIwaAecDSbslgsTqR6nXNrnSlrLSJLXVjb4YPdQO8dgyQQaYNOUiR9TSrg1tFJrwiscS7SreY4a5nPOiajs0wP7nLtxRd4/NktKmuJncRbTz0aUdVDIhqpS5AF1nq6ziGloSgGoBzBB1yYcenyJS4Iyd17+7z5madBan7lNz5K5wXWO9AFx/Ln+T4zUAKOaaP6IfuMgBIIpfFC0ASfoPtKM9YC6QTK9YI7x3PwtHXQp+Nebf729T9e9cg/mnH/Ghac3h4vUKTtOvVifv9fuME7/uQBrlUJ0CAjQjl2dr/O1k6F0p5EnaQgZiALnohl53sdb24SMMcUgqL8bK65J0epZ8SIoVfPFfgQ048LOBewLuBspLOernU4F9alBR8CRQm//2/hM/9+kktPLhvNQIyWkNlcHma8JiMVY+QnfuIn+IVf+AV+4zd+gyeeeOLE89/7vd+LMYZf//Vf58Mf/jAAX/7yl7l69Srve9/7AHjf+97HP/kn/4Tbt2+zt7cHwK/+6q8ymUx429ve9lpuh/4rjSQmX+c7tPSUtaasDLODFcvVkhgTXBwRiDHkDzTVsQQCZVKhVysBMq4VI7Uu0KYgQc0VPggO9hfcvHk3aQBJs679rKn817MrHkvJfyvHKSCHbzyO61oZsZ9OI775Rfpw4IpNq33as8dIp7U0Ti6TJjb03NsWAyFmQIMwBF+yWnYsm4bWLVktI0dTz8FBg3OG1TLy0kv7zA+OUCogKk01LKiq1MxbFTVVbeiCoigHzOYrhkozHA1YiCWLxZLpdEpEMhyNGZUlnXP46RHNssnqsj7JFqRSGcYUTMY7DIeS27f38d6jpGRra4vFYsF8Pmc0Gq1lO3opiK7rMJVmMBixXHpCgKqukULgI2tUaQwJXSWVXG/0MQSCCwglc302cVEqKSBafHDMpnOGZQ2x5PaNW8jvtng7oxCCyWSErgNBJoZtFyA4j9IFRdQEFQhKo0TAaMm0mbNsV7TWYbRGGcW5c+coi4K2sQiRjKSP8QTpcs+0oWTPF5fWixSSUhcImf4OUrKSgWW7oogaQ4ETfXNHlk4XIpH30tNiHS+xjYoVvVMq+qhpPeNOASg85JAxxTH9f/ndnbhySkuLzX+cqEmt2Veyx5yyeek9iY3Xbd5hIlpOzbYCSyQyPtvwS//tFa5/6SzeW3TRUE9WPPuuK7z92YvUQwvCo+UQwgiBpnUHhDilawW2GTGoh6hiSVVVCKHxLhKDwHtomo62sXSdZdV0zJaOg6OWu3dm7N9dMp062kZhrcBZECoRKzftAh9b3vbuFW/7ri59R6pv3k+fTYoB4kNvPq/JSH3kIx/h537u5/i3//bfMh6P1zWkra0t6rpma2uLv/pX/yo/+ZM/ye7uLpPJhJ/4iZ/gfe97H+9973sB+OAHP8jb3vY2/tJf+kv803/6T7l58yZ/7+/9PT7ykY88MFp60IiuQBiJjBZChwiRskqbnCey7DxIgYzdGtaa+EQjTSuopEbpgItd6u4XCh89QpK1fgwg8V7hOphNl9y+s2Cx8niReAykTCzSieJDJ5JUQGBB2sQn1yMQ7y+SviISSv/rvZl+E197m5y+5T8ILi4QCJUK7gGRjWafosxaTyIF4SJ/PqcBIDbPfdq1To2keiuYyWM2U6F9Idd5SyESc8PKS7zUiBgQPmJCRIpAEht3zGxHtyrwStMsVuzv73N4dMh8vsDZlDu3NqXGVlYwWx7ycpmY/4SSVGXJsCoptKauBgxGK1onkaKl0I6iVLS2ZbGc01qLlIK6rBAEnHV45xhWFZXRLJfLLNVxrN9QV5LiTElRlFy5UvP811/kaDZHZbBFHzX1tZlNQEEUAaFTvUHIyHhQEaOn1BLvLUIEUBmKbSRCZYmPEPGB1AArQGmJVJICDUxQ8jYhTCEUmCiYVJfw7ZjKaOoiUBapdcQFRRA6NRMLRcr5JfYWXSa9LKU1W9028xtTtAAfBfPlik//4WeZtpZOpFohMVAKuWY00SjCRtpvHVWFZMiM0KgIwUEnHLO2YbFasVUMEiGqiXTRoUiMHEHKRMOYtzvlBWo99XrMXepxU1m1u98UhYjgSUwlcCwJ8w3qq/0xKkaiSMwzQabzSSHBRYqiwgZwMeK6Nsk4SgVCQ2YbT3jF1N3nXNrAo9EEKbDeo1WSyYg+oEJaM9FkppOg0CFBTaPsAEekxdoWrQpikCiZZGO0FhAVkooYKggKKTVGjXBeUNeOwUAgWILwON8RXKottY1gMbPMZg2zoyWz+ZzDoxnTpWc661guHMEagi8IQac0oo8E64jBYaJGOlC+QwpPVIkSK32sBdZ7us4ShKZQ34Z037/4F/8CgA984AMnHv+Zn/kZ/spf+SsA/LN/9s+QUvLhD3+Ytm358R//cf75P//n62OVUvziL/4if/2v/3Xe9773MRwO+ct/+S/zj/7RP3ott5JG7NFfKYzsN8AQBJ2NtF1Kh+DdOkXStIHpVCPVEK1VapBUiXaGKBOLlZRIpXEZMdisGo4OO44OVkynDT4o0LnJMouPJY4msab/EVn1N1H1bEYyp6fqYDPe2fg7O2onvcWNB151pPx7JBmhmKlgUsSycU8nzn3KWR6QznvoKK7vtl8jIvuHjs9pRNpWUl0499PIgNeCVXAc3N2nXRzSOmjnntUyiQs66yAm5FDviMgo8VHQOUeUEY1kueg4ijOCjyhlKOsaU5bowqDLGgBrLYjEKCJlQvhZ67HWretCdZ0QfG3bJXFDF1K9kp7fsaCqSgaDmkXTJnn2DEWvqiqRsWZIdvpcA0onDSbnOuqiTBF95qortCZWApnh26WR6EygHFwkKJFlZ1LKUOmEoHJyjNIKYzzBTXns4nmeuvI0pRqgdaIFiwKE0CShyX4+kjbPmJo4tU7yDtZ7WtslwEoXuXH9Dp/4D5/hdz/zefTOVppbOeKTCJTIonjarJGMfdpWquQgCSmI3qWKvEgIwrZZUeoCIyQmgM5dHXnqELN5WvvlMa+xnCEIpMikp6JCiEz8LI6Dns2p/BoAQD03ZxC5P08kirVCKIIPzJdLVFURCEkdV6gMGjEUJqE4rbcgFV7mdK2wLKzDDAZ0wRNbx0CapCodbKI/KkRyol2A3CSRskK9I5maqMejIcNhnVN3OT2YwVt9q0JqypVI5Uipd0HbNizmHYf7LYu55+DeisODJdOjFU3jaJqOZSdo2tTmo6RODOc273UxZbJEiMgoiFEjUQjpcyYkgThAJuBEVCkqfshm3tec7vtGo6oqfvqnf5qf/umffuAxjz32GL/0S7/0Wi59+hCJgibGlA8Va50V8DbQtQ5iSjOILCVuO89i0aaFEkugSr5NTE2RPV9W23hWy4blsmN21DKftnQtgEHrEhddLkZmwT76jaXPnMucEuiL4w8X2x6j715HLu70Mx//mdMJm0C/VPY4CR1/veCIB96J6Kluck9QhNpFbOsT6aVOi7iTnqUKTNuW/dtHzIUnhkjlC8oiNb4qqfDWoTbvNXvpSivQCf8pQ9pQINWE3HKJtB3VYMh4OCaEkCHiHUql3ibb9X0didswhIAyCtkj7Ywh+OOay3K5BEDKDCOXCuc9XZci+QRdN+tUX4/sk1Iyn80otGR7ewujJSHLKhRFgS4EdUxpbRld4rGLIjVEqtTEqYREK0PMfTRK6OP+pGbJM4+9k0f3dqh0ROJxURCjQYmS0BP+9i0J6zpj+qxs1yYWjbalrGrm7YKXr13jS1/6EoPhECt6EEh+TfD44DP9jT9xzk04egiB6DzRB0IboLXUUjOuR+jOU0aJCSIZqyjWyD6Z18WJ/qm8XPrG7fVc4+Qyun9G35+2fnB9NzHup0cze0JMjCSh7RAqMB4OCEawbDyqEEQfKJCYrDytCsOitXitiaWhCyCN4PLlRykmE+7uH7E4mNMsErK0FgXSdkTrEtdolnEhs+sQFb3khdSBs3tjhpNiI40eEKJLO1IIpLxE0qCSWWg0knqfilIwHCdWnXowYjTWHB4Yjg5XHBx4vPT46LE2CRxKVRCCwDuBXFM+iXVtvt9HZOJoSs5yrnP1zuTD7i9vcO4+l2oY0WevIoEVpJQ4J/A+IqWBkOHIMSFUbAuzowbbebo2UA0MUkJRHGv9dK1lsVwmBvU20LUBQZG8lEjqFEYRsxJsJLGK92MzUnmot7JhnPq8+bfCRogTXmOGcpwSiG3m6b9dxilfKF8trq2kEALdeaL1WCmIpWElI/MQOPSOw7blCIs3Eh0ktRKUZZkWng9459bwZtlvmELig8N3IQksS4XRBiWTzk5UgoDE+wRyaNomS7+3QOrNi0FkT1hTlhVSSqyz+LYFBEVREIlrEcPlcpmpkJI+UtqokwGz1gLJietpkoTI5wgB11kmoy1GwyHOtpmhOm10PkSsT4u7NiKLFgZ8lLgY8UiUKRCmyp9p4gAUQjGsKraU4pnHLjIsIia2hAg+GEI0BMrkwIVjAEwP8vA+yS0EHynKgrNnznL7rmMxbXjXu96Nrrf4xGc/x7Wjw+QZk6JZT0ybESd773qAyWYfXSSJbjrnGZYVpiwolSF2DQaZ3M6Yjgmij5RJahU9E1lMSixRHBuu1zQl73PMHtgfKEJGgysESbMphEipa7xfsVrNKYoSWSYdsxhDQk5KwWw2RxSGrfNn2O8WrKTnsaef5kc+8EM8893voNiacO3mHX753/0yX/zdP6S5ewRCMzQG2QaCt/mNJXh4ipIMwQuCcmyNDWf3RtQDkb4KRCK8Fg6BJ+Ig+uwUFQih1yAyY5JmXlWrpDvlBBcubeNazeHBips397l5d8bde3OOjpbYtk0On0hKv84mmHoSGhU51ZkFVeUxe3xOYPJQjPAb4w1upI6790Mu+DmbkHqJJiQtFhECSiZYrLWeEAS2SxtH2wTKUq9nvHOOEJLRCz5LeISU40WI7BnmfLeQKNHzLPcRFJxcJg8fDvURxjrS+FZFUn3k1F8nT871gl7bx5PQ8m9bJJVOnmvK2etTklBIvBS4UjB1jqNgOew6lt4TdYlyAkWgqFPt0nufIiql6FbNcVopp0EkKdrQUlHpisok2QwXAh5BFzzaGKpqwGHT5MZYkzNAadfrZeKttSm6mqXNoiwTz15VVgzqQTZOka2tLabTWWpdkImtvf9cm6bBGAOwpgpKaT+o65q6qgk+EJwDn+RFbGtprMNmiHqJSRDzIAgoQswkrNIgVA9KkGvXSUs4vzPhsUtn0aFBBYOQBlRBVDVeDlAxQmYDgONoKhmrZFwKXaCKChc62pVlOl3ypre8mZcOjnjp8PDYSVtHyZwwRv1c6iMrSN69Cz61B8iUehcy8R8WKnn6QQqcBukFLi8KGVMasM/ye0nmWzw5zx9qLj7kfE+pxJDqa5AzKIrgHUon6ZXRVsWzf+JZxue2OJjO+OrnvsydF28iDYy2hjQxsL884tLbn+a9/8mP8M7vfxe7VUETPYfWMXniEh/48IeY7OzwuV//Hdob9xihMFLhosfnWhrBrA2llAKlPGfODtneLSlKzzG60iGEA5HqmkqkjE8iYjYpGpQChCPQYaQlmoBzEe0jVWWoBhNGk4rzlz1Hs4aD/Sl3b0+5deuAxawFFM5lULww63LE8fcuU/QmMqlwX3fnVVpP7htvbCNFWKfFBJKQ5QCkLOibBIkRpaCqDGUxxFrHYr7Cu9TWkZriUu+BtQ1kK5888mKNRulz9UBq6hQphJe9OxdSmkdkrZTgI0omZmAy2eZmPep+poYT3fDZxRH0aYfjqOr+9MXmeEXaIh6Tc0qSenCvfUVGIwpO9z7vh5i/qof5WqDvG+WBXDIjCmhLwbITrGTECsdhaJjahs4HJJoiaGQQaJUaW/v0HBHqsqQcj2nblma1wjufAABCoKViUNXURY0Ukq6zdCGgiwJjDIPxiLKuaI+O8CFiTLFOxwXPeiEpldJnhShytCJS5LXq1vUmnesvfZ+TKVaIRqyZJaSUtO2x0UoGK6UTB3VNWRRJ7bezxODxIWRmCZEZF46L+JEc9SCSAnEMeJck4UWMqX8qRooYeOzSec5tTyhVqk8IUSCkJoiCiEJGf+L77lOcm8N7j+8CUcqkf4Wg6yyz+QyX601kCqm4liKPr5jnIb+nnmy2zfXiejDAx0DXdggSP6aVgoX0BKEwMrnjJgp0wnWkNS/AkYyU6Of5xlp6WJqvb+SQresqIl1FIIk+sUCgEnDl+3/w+3j3D7+bmV9xse0Yj2o+Pv8Y3bzDR8HFRx/jPT/2Ad75p95PeX6HJnasrKUTntZ4Vn6FmQx4+/c+y/LaHb5y9/cRQuGbFqES7VrsywpR5dpSRKqOrZ1tBsPEntNzmaa5mGV4IGedDDGURG8SOYGQKOPRUqeEZugoTCBqmZ30SFmD0Jrx1g4XL25zcGHO9ksVL1874PatBas2kyXIpFFFTI3lfZoxxU+bFHJpI5Df4DPvxxvcSB2X/NcLY52PjQjhUUYwrAvG4wF1OWS56FguV0QvEKRGUGdF/vIzVUdM8N+eV0tmdmapoCwNlSmRGXMXY2Il6DpLJMknK5lrFfneHuqd9Iuoj8HjK9U7X2tk09cV+skhNyZK34/RR1WvuI9vcN7+2G9m9B57b6mChDthxZQVDoH1kaN2ifMBLTQqCIyN1KrAVAqtc9rN+2yoInVRril3uqZNIodKUdcDqqLEu8BytaSzDqE1QiXEmi4KiqpkMBzSNC1aa9q2I4SQWhC0XgMj+trSyfeSNt2E3NMnntdKr1V4+/x827ZUVbWOKJx1FDqTyYaQUpEh5NRsqqcikuIwMRWpyZyRUSRdKlMaYrDYxqJiQEuBCB5FYKtUPPXYFULwdCFS6AKkJimySmJIdScR+16m4xrqMdjBrx9brRpAsH9wyKc++0W++tWvZUXfY7RoJPS+4wOBQjEm2Q6UJBqNN0nx2EnQSoEu6AIchI55TOTApTIMo0JLSZQC6bPgcv6RG9mB+4mLXm+dVeQ0qg8RqQXWriikoqgUXjTsnt/m7d/3XUwu7uKXU5Z37zLcHVNuD6iHQ37sx/8sjzz1BFsXz6NrxXx5iFORZdPglcDKFA0rJdjeGvPkE0/w0qc+h192GejUoz4UPSVb0mJbUg48WzuGemCQKlF49SlvIfK8cgEpKiQDXKtZLjzNqs2tNA5TRqpaYYoKpcKaGkyISFlInOuQGoaDirIcY6rAYFyhzR06d4/V0hKDTjypqI09LDvKcVNjK8+Jh/zs3+BGKhcQAd8jh2TyThEBpSNVodg9U7O9NcboOvW4RL/OyYKkb3zXOinzxpijIpE1fSQoDUWpGI1rxnVNoRRKSHwILBcL5vPAamEThF0opMpqla85Q/7Nj1c0BvYR0gZ8T24YpROpxf+IIwg4Ch2HsUWpInGBBU/wDkmkEIZaG4ZFga40TWhpmmZt7LocPdRVnRtyFavVCikUVVGhhGQ+n9E0LUIkLWLhbI52qqSci8gs0smYlGWJQK2NyTrykaylC9JICNO+ltlz6XXWrUECPbO5c+4EL5vIOfuyLFGZigkp0ELmzv+YIoYoiFIlD9V7pEwCikrIRPsUU7OtEYJKCaK1qOgoleSZKxd59JFLSTxSK6KpEKpCKpPeawz4jbrRegPJ9+ejx7kUWTbLFWVVoXYMt+/8Ab/5W79Dsb2T0nRKo6RGEpH6lVRgp9JoxcSHKKqCLjPLRwEuBiyBIKDLdSghoRIJulAKzSAj2jwRryReslaNlpE1gORbl7KWyUApcMES6RIllYi40PA973wHZx/dQ24NGA4UxbCmroe890++nyevPMWVJ55GlwX7iynuoMGVAiczXVTUOO/xoUO1Atk6DGke2ODQxuBch1ij9bKhp8UUir0LE87uTajqAoTPWl6BmBkpvBP4LuJCSbOM3L51j3t3pizmHc4GApaqMpw9N2F7Z8DO7oCylkRSr5WQEa0CQnqk6qgHsCMKTLkLUtI6z7WXZ8xnS6IosuaVON5o0heRalMxuw9C8LA7zxvbSMVeEiPibVJ8FLm4qJRgMCoZ1ZrRRFMNgOgRMuVokwFJ3mQySIq+2VcqiVYypz48utCMRiWjSclgUDCqDGU+RghJ0yoWi5K7t6fMpi1Eh6QgxtOVbb9dY3NBpo11ow4F6+bilM4Ua+mHV0sh/lGMCNgYaINnIAUyRrSIBAGFlgzKEiMNQQTa0LJcLmma5hjGHSJd263ZK4qiSEV6AfhI060yg4JCaZM2NpcjIOcQSHZ3djNtUao9hRAgyszcLRJpbB8eBJEj9XUGHmAt4bFmOqcX/lPHNEAcy3UYYyjLiqqsIKRerKIwaJPSxta5ZAqzVxxFTCjGrOwcpUCEAN5RKIHyFtFZRsZw6ewOe2e2+fEP/AB7585Sj4YInXrRpCyQSFT0603D+dRj1tsSpU5uDTFm1V0V6VzLm978Zp550zNc2z9KqTul0+e/ESFv1h02EX5iXdtN39tqMSf6gFFqDVAJ3iOUgkLlnjqPFR7hYYQk5FS6jxEvUl1KZTCFilmVd0PS5PVPUoF3CeLv3JJ3veed7OyUHO7fYGtnzPt+9PuxlWDhWs6ePUt7NEOpkuFkm1JVLNwCIy2T7QFOBO4d7dO5lliUyLJGCZ34JBaem89d5fO//x9YTmfUusATCEEnteoooNeuky2m0pw7P2CyVaJkUtiVKqH4wEAY4DvF0b0V9+5MuX79Ljeu32U+a/AOvE/RtNaKwXBGPdCc2xtx4fKE8xfHjCaGiE9s6iIQY5NYKIRFF3Dm3ICn/SM4f5NVczcrIuWGc3onuM/rb8wDvkOMVJLKSOkU38NdIes/GSaT5NXoIuLCEhE9ZSWZbA2YTRtiyCmCPrKQES1EpmFKUZdzLXVtGE9qRhNDWSlKHSlEYrNWOsk2DOoCYqTrHM3SI4iJCSDnX7/d4350Up/qe9C1T6T8vlUL+ZscAog+Eq1DuIDwARMFpqpSlKEVrbPMbUfofG6ETCmNkGs0xMQyDlCXVY56BG3Tslqm2pVI3aYp9+4DnbWsVg3zxYLVKqH7rM0efa5J9ZGQz1ByXWikyvUAmTZlYwrquk5imGWZEYIC705KUxhjUs1pg/1dKUUEvHOI4JEypZJ9sATvE5Bizb6dU3yQPFEhkCKT7nqHcC1bdck7nnmaZ9/6FHtnbnP2LU/ReI+qBnTOo2SRepRiRASHILOWe58NLOt7jpF1NkAIgdSa+XJGXQ8YDIdcufIo1w4+m+iaNj0i8uYkxTrduQm7jzGujXmwjgJBUVSUmc1dK51g7DHQeY8LHhs8pixYxUCLx0uD0hJyyq+fvTJHUz07xYM8sNc824WkripEGdnaq/gzf+7H2NuruHPnZXRdcOaRs+zHAFXB0WpBKSTVeIwNYAOsXAvLFeeqbQqjGMqEC759dISqHFKVLKcNL33xBb72yc9z87mryAjWWWShUyTtVZ9DzbfkGE9qds8OKQpBiAEhdRIqFILgNO0qcvvGgqsv7nP95X3u3jmkaTI5dtQISmTU+E5y1HgO7rbcuHbEyy/f5omnt3nmzefZPlMmlQJSlIYMaB3BOnSh2LuwzWIROThYMtuPSJcc4DRH04ctRJ+Ejeu69MMGuW9oI9VXV1KuWOG8IOb0n1SBwVBRlRIRE4uzVgXDYcnumTFta3Fd7hXoZTV8wJjIeFyyvTNKrL3BoZSkLCWFERgV0SZJz/uQmyhNorIfdwFzd8pylZQzRdQZnXHKvZ/yDcUNwMRxkfG+3Do9EdTp5zyRVuFkJHW/47JO7jykgTq1FtUvmPuO6X/LCDFT20gZECGkniWZJqwjRQdKRkyM6Jj6OCgU2iTUZevaJD8RHDLmHighc2uBz55ailScs3RSonxCFS0Wc6LzFGVJjBkSLlMPW2cDnYO29TifNtGely/GiHeRzlraLsHFkRLrPDiXitH5Jxk2z9a2xrnU/Nt2FhtCYl3PEb9ROkcaMqFNhcJIjXeOtmvQUuFyhGtj6nGNMbEPSOkJUdKJGpvToDJ6ZOxQwTKuSy5feZR3PvMmvuft7+DCzhglf5G2i8iiQsiSoDwRgcy11/679zGR/Qgp0DKlup0L+M6l/SQmJgvXdAxVwXQ65+aN27SdoywHtN4nmDgigTDw6w2oR2+GzKDQZ4FChucrpRjWNbpX7fWJ3kwVBttZbNemmMBolEpQ9YUQLGXqi4zklKhP/TpBSLyQ66yY7NfFBn9gP3tjvyjiySpWT3q0mWWIwWO7fXxwXHriUca7Fd5Ezjx2kUXb8PLBbcozZ9jaGdPOG2KurephBRG66YzFbEawLed2dhnIms5b6kKyXE3Zv33EVz/zHF/4+OdY3ZpzdrCDNgOO5kdUOnGPShnx/lgyRJvII1fOsXd+m7JOdVMRNcElUtjoDdOjhue/do2rLxxyuN/RNgJjBkDEWvBOImSX66maENP93rgxZ7bosF7zzFt32N4SGBMQMuaSSMilkOTUnz13ht0zhyyO7iF85Lj3ReSu0fRRB0gZANG7i994vKGNlFZpI0q9jZpVG+m6VFgPcUWhHNErIgatNVoKXAyUVWI7n1mbvMUoUUKjlMdoy2goGI98Yu6NKjV1eouKhlIpjBGgQAaDDyWulXRdS2MdAU/AIUk9JptNbQ8ixex/hywH0acpeiMlxHGNQAix/v5PMxqbKZXQgzDy6Jt1IbclxmPRyPvh5/04DSba31fcMFCiJ0UloQhTelFkiDQEmTYpFZP3rqLE59qDkAopAlUpUSIk7SSZpdetpbUW532qeWSPXsDx55WNs5SSQKSxXXrbwSFEaqyUMjV2CwRKGaIpaRwYVeO8pO0sLqToQWuJ8442z4/IsYR7Snnc5yRIwappqFrLqmkTHY4UBJX6mAQCicZ5iRQFoUuUSL512MISQ5OkC7TGQUJmSU0XOzSRykg0Ho/gnhN0HioRIK4oaLl0doe3PfMMb3vTW7hy6VEG5QDrPbU0qGqCE9B5gVRFiuLyNyUjSXbGJfaB/tsPITEodtYm1oQQIGjoHM1qwd07+9y4cZsbt+6xbBxCKZQg92b51J9DSp0jQp6LyShpo9KaJVCUKRoSSmQ298yjKQSd7bCuQxIpjUEqhW1b2qblKBgqI/GqpgygnUCGhLgLStGpNOdUNkKSuJ6f/diMvhDJSe15+frfCrGG1UdhuXi5YGfvLPfmt/j8F/6A7/2h9+ELgZmMKLsGLwKuXVBUNc3KIURqVfBtiykkhVbMpwu6uePy+cuUZkIRb+OsZUtL7N0DxFHDmWqC7FKpYVwOCC5A6JDa0HWOoigRUlBVBTvbY6paIWRIzdwxwdOJCYiyXDZMpzMW8wZnNZK+Ab1DygFRFQR5i6gF3lUIkaiLBBMO9yNf/UpHPV5SVxVFmQ1kADKTjhSKKCRlqdk9M+bmy/sEmzJJKYTqN4jEdO+JCC2JKv39MOMNbaTSiMScCgkhYq0nRo2WhkRN1D8X8MEjpKGuS86c3cJ2B7SNR2lNDA4pYTAsGQwrjJEoLRBRpn4MAUYnAbIQIs6DbdOinR41rFYNbdswmy1T/li+Ngb009BPrztL+KqXP84J/9EAJ/oYf+PfAqRSKGNQvsIEhzapuTT4FgcIXVCoArPecECL1Pu0lm0IMSH1tF6z2CfGCYkkEb0WOoHvQxREWSBNTeMi1WDAarXi4PAAH1I3vXPNOs1VmCJzOPZd++FEP1Y/v1TWlRK5k98oRSkdXexQPvG+SZF6ojyOYC1t7JCxpTSBsoBKmTWXYYwRZQqil7Qx0vqAFFDGFTq2FM6yOyl56soTPPv2t/D040+wPdlGRIEULu3QIkVJPuS+Kt/XiCLBpbrcmqYoHhP59hwqSmmMLvCtx7YdB4f7HE2PuH77Hn/4uc/y8s1bUNbriHzNj0lcs8P3Dlr/+W2S667rdZukuXCChDfRTFVraL4AnIjMXIsUgrEoqJXOoPDM/5JwU+uMX39/68yfyGSx+cCY5W8lveOV3odWZOJemOyM+T//lb/Ahccu8Osf/d9QVYkwBlMVxOjZHo6YLxfMjxaMJiVGl6yWC0QIyZkOgbos0V5ycOeAlzvPxUcuMRmOsU3HYLLDm598hntfuUt7ZHP9OK7BT1IkRCsCfGjxvuPc3iXObG1RVhIpA5Gk3IzsUEYjbGQw1IzGA6RaZKQmWSKjyEmehjN7NUorDvcDXZM5JUnraDptuH6t4dFHH2Mcy9SkHQTgiCFpT0nRooxjMLIMRpHlKq+9vD61Nsnwx7hWk34tW9sfAyN1PGKEpu0YWEFhci48e0Mp5RRSWqlQjEYlZ/e2ODxYslx0iXkgeJQcJFXfHKSmxZaoIRMNj8AHQbPy7N9bMJs6pocLrEuF7wgYrRPCL0dPD2ttTgAf+DYaD9HD9DdN1R/9SJuUxBiDqc5Qu8kaade0NhkNIRFSJYqd3PdWaIMxel2TCj7BzY0xqGyknHNIndJBRklKrVLKIfb8bpo4X+GDXavODkfDnPbo7y8BapQ8RuQ577DOrgEWzvkkLR+PGRrS9+gphKMUCfyQGiljNmKBGBzRCUKicqOSikoJCg2dD4SYjpUmec0+R+e1nVGXcOHsNm990+O84y1PceHsLgoIqyl1PUkNsS6lUzyLBNEOqcdGCoOI4K1Lwo4BVFWua1wpWIy5TzAghKWzC6bTKddvX6MYVnz1pa/y/MtfxQwnqErShoRkVDJxuKWd0OH9yR6x3kj1Nb/N/rs+Ku8NVNu26/6zvrVAyVFiM7AB2wXm3oKQRCWpEciQDI0KCRJFFMljF+mnHypv/DqAV4Egfa5rpu/IAAiS5HquoYxGAy4++TjSRH74gx/kaLUgIFOaU2pElGyNtjg6mjHbn1EPJgQXaVuLqUu2RmNWszloh1KRq1efR6jAzqPbjOsxrvUEl6PPGO7LgKS+Me8CSkGILQjHmTNjhqUB0ueJlClVLhsCAlNU7OxO2N6ZUlYHNCbxDSZEcwL/DMeCJ586j9KGr4V73Lm5ShY+piyKtS3zeYKXQxIXTdRGiZtUqkAUDVJ3DMeeyZaiPTje8/rvv6ev63/IMevDjD9WRgqgXVnaWlNVBeTcZ7/RJYp/jxQCYwTnzk4wSnGo5ywWDcF5ED59eH1hT6TUhCBmVBYEp1gtArdvzrGdwnYFUKBU6p4X5Jy+A6VeWzS1Cc/9dmEZetAEmzDQ/wjACSkkSuvUm1EX6BDRxqReizrkVFuqN3kf6FxCZQoliTIxYgNr8lyXH49AUJEmQIgRFQVtSCRWIoac9oxYHyiNZHtnQlGfJZJEMJumxVrLbDbH2cRB10PLR5MxdT2gLEMmmW2TobKeNYYjhkQdYzuILjUCE9cNus4nZ0ZqgzIVysTc+Z8MrAgemVOxwSWDFUNgUGoeOTfkmccv88yTj3Hp/Bkqo1DeMRlvIZRJEjRCoIzAu23qx/6b4/RsOG7sTMwWmVNNpo1WaZ0qntloeO+JIaC7jqprGb5pxeFsxnvP7PP9f1og9GFeGce1p1zg5e7div/+v39ibYx6h62PQvtoqh9rRGQ+fjKZ0DN9JCJfz6As0ntRAl9qVi7ivcVHiLJACUHhJTpGdBAEQXpOJPRfJAMrcslE5WSFz+FKIkglSZx7wAe0VKlJ2jlWXUNV10lEM5a0zhKWjsn2dnpv1jMqhxy1K2b7MwSB4DpEZ9kaDqgKQ2w7lvMjlIrcvHmNVVgyHk64c/UOz3/1a8ynM0xM8kAbVeOUBQgRqSIhrihLyXhQYgKEYHPbQmpPSH1cCVHSdZ6yrDh7dpvg5yznFmcdSirqoeHSoyMef2oHKUuOjiyLmWOxcsQQUyqvd9SVTg5B9BmslHr4CgOds8TYMBwpdndrZjc9Ia5yXSozl0idSysxR2AP77z/8TBSMc264AONb2lWikFtUFEhtTj+kHNKIwqP1hJBYDIpMGZEYSLTqc0hs8+w4bThhMzs3KOYfID5zDKbWv5/7P3Zj29Zlt+HffZ0zvkNEXHjjjlnTdnVxep2kxTFwWqbomCLIiiLNi34QYAkP1oAXwi+85HUPyDRMAwbfDIFAhIguP1gDbRpk4TYIru7qqtr6Mqhcrp5h7gx/IYz7GH5Ye3zi7g3M6uy2E2RqfJJRN57I37xG8/Za6/v+g7BdThTc6XKqPCCKMatEeGf/WH8NCX8ATb5jJ/9M7w59c8X7ucG8magQqZf8B7/oAWtdnBAdZx3DBGGlDFTIWXV7lhb3ZKRGvCn8dNWrgXbyiKyNbNI9SFQFx8btJMWIUgd6mcVu3oLUTIni5ZuuaCPI+MwaBJvPzCOI6U8bxEUY2RzdUVo2gPN3VmPDR7vpHZbqofq+4lhSsQMxmkEeskwTUkLp3PgGly7IHthQJDsIOl5bEoiCEiaaLzl9t1T3nj5Hn/0l17jpbunLBrPomtYLTpyysRSBek2aHigZPqP/g+HwiRFSFPCisUbz9RPjP0IVot7t1qzXh3jXCAnYb/fs9lsmKaR8/NnXF5e8Lu//0P+n//g/0sfX8K1S/xiRR8zWFfteeqcs2S8DepjZ+Nnnj8vUtLnY+5Yc85cXl5SSmG9XrNaLXFAipPmbHnHJJkha75SsJZWLC0ZyTNgWffrpuZA3TznD7N9gxiPKbV4QXXyLlDAu0CSwjhFhjzhbccwTaxPjtj1Pc41nD15ynq1ogkteYp4cVxsLjGScUbY7DaEkilx4vL8jO3mijwlnDW88/23mYbEO99/l4fvfEwwLS44JJb6/KS+ZwZnHT4kHMJyFViHBgaqobg5mA5IaUljod8Knzx8Sr/LvP7GKyyX5zx6/ISxTzRNx917t3jlzRNu320YRwhBrx/V9GlBMah+1LqM2IiUCMxdlFpDmajz3sZrcOhiNQIzseLahBsqSa2+rC+6inypi9SMp4MWn5x1KL/dDjhrKcuWtnPgAh6Ps4JIopRE8AFDYrlwBN8Q/Jqm8WAjuQxgOoyFnG6wkqgQSk2hDF6zWmIUhZmK0/H2c8y8z98xvChwfLFozTtQc+Pn2gU8/7s3tSgv3v/NEqUY/fWiIDcwxeeIGT+jYP3BilQNmnSOVGGKnAqbmBgqw24uTmJ0p2+sYIwH69XPrjxPSDG1UDETTGqXOBmHsR6Mii6tFCwOb4VxGmg71eTsd1uGFNlst4zjVKM51KPRcJ28G2NU4atRhwhNbS7sdup+3nVLUkqMw8SUCpN4JDgm8RXjN+ymSNMEQmgQG8jUzKGg1PYyRRrJLGyhs4WT045XH9zh29/8Jm+88Rq+cYQmaLx9CHgXdHNWKlBlAjkboKghKgJZ1Kg2ale265WSP8VEkYJdeozLxDLRTxPONDx5do5znk+ennF58Yzvfu+7/H/++9/kbN+zOrmFaQKpZJyzdYOjxVV38h7vwsGfcO6c5vdxhv+MUQG1tZbFYnH4ft/3bDYbvPcsl0s1E86ZNBOdjGGSTHECXhiAXjJ+GpRiLw5rO7KBaKje33Kd6HNjllgISrjIRWedxlJSVGcPKxTrSMD55op//E9+k//5//LXwSrTbrFs2e8Hzp8+o7WBhgAxk4eRNIxMw57TW2sWiwX9dkOaRp4+fqKdhBTyNHHxyQXvvv0TLh5f6KYao3IEeS5fgVIE7x0xbzg6gdU6sPCOcZLqE6mbcGMcmwvDxZnwzo8f8ujhFaUUvv2rv8S3fuUVXrkKpJQJYcHR0Qm+y4RuJIvH2EwqCUUOPdNUWCwDp3cXuDaRZESAWGL14fOYSsTwqO3YauFo22f4oFEjzjssnilX9xKpXbRRpuAXOb7URerGKBQA50MN74oY2ZPHrAmsqRBTpmsdbbCEyjBSRwNHCI7gWsBSiDSt2oEUSZQyz6eU2q6Lo1rFFMmV4mrJSanNPDcU/PSH8Cma+E8pCNc/+/RtPpfC/qm/f7Hp1j9Lv/bP1uWZ5x/MzOi0ygc0rlpF1jnX7kj0PQfIRmGxORcHox3EASW9xmnrDs4iNTZFUPafOiyoYLTf7RnGnlHywal8dojQJ6dat5sw1W63Z7/raZqOpmlompZxHLm6ujrAg9OUiEVNNb1zWKym++Y6q8kGxOCtQYzmX0nRM7B1cGvR8MbdW3zrG2/wza+9we2TI7JA7FZY1ygyYB0RtRUyWMR6xHldiOnxyp1AkjD1E7lkHI79MHJ1tcM6r0iD79k+ueT09CV224h3C/op8vTsEe+9/y7/6B/9A97/4H1SCCyOb2GbFjGu0sqVeGAqmjG7/6eStam6AePNHenNwEclm5iDW0ff91xdXRFCoKs6Ob3mrH7ulQWIqfE83hBz4WraU/A473QGhRY/KlvWU1OHBY06MTV8Qyw5eyi5atA0Y8l5y5gGhmnCLQLbvOO73/0tfvVf+WWOb5+S00RoWtaLjnS05vHDh3RNy8nxCf12g0wjwRicqFmaMYYY1Tg4j1G76pR49wfvcnF2hSlG2bBFAVRDZX3UTR2i81DjE8enLcvVQCOGEjwgxAnarmWaMk8+GXn7R2d88N4z+n2m6QwlJ9bHlqPTdc3xsvjgiDlj3eyOUsdh9bpxzlDKwNHRmrYL2JCJk8J91umII0VDjpGSNc6xCQXvDMbM8zU5ICci5jBWMPW6/yLHl7xI1cPc6CExSDFMY6ZMA/thoh1Huq2n6yzLTqHAZRd0oB0MwVnwlqPjJYWI9SPGPs9CmpkqxkBoPIulV+1KUtuS8pzHGXV1+PwP4eYC/4dl3TIXpptwyr8wVsRPOZRlV4nQ1d6G6tsNVA84U79X/QcPxWfeA89Wufa5vcCsZJ8jIJAq2MbW7yqTk7qAxjp3CU0gzlTsyjrzvqmJy9dzGmM90xQZhpFhGNnvh2t6OoaSt5W4kasWSDBOKtQ40rnCwheWvtCaia7sacIaHLgycnsV+NorL/HWay/xtVcf8PLdW1iEnBKL9QnSLBAbMMZRcAojokWuiAZ+5qILRJasmpU8JwJYxlLYT5mzzZ4swra/YsgPiWngJz854/69V7g4H9nuJu4/eIVnz8747d/7Pk0TWK2P8YsVWZkY+m4bVSvdfO8t5nDtiMjBGQQ0WHIuSMBB7DuLezebDcaYT2Vvee/JUiNFLFgslqIEj8aSDWyGiSkm1m7BrdDQWENjLF7AZc2kUlQCCkZPDKcmq9aDoyjxwgkx99hOEF8YzcjXfvl1fu1PvoWRiTz1LBYN1ERbRyGOPcN2Sx5G9v2kcJYkhl0msMAZQ0mJOE5cXmxYLdd88P777J7tCaUh+ECKkVxqiGadk81bTO89oHKK09sd7WJLvBp0TmVDLQAtF8+e8t47Z/z4h0/odwHvFiSrEHbKO1brgve6PjobwEExSbsio4zOnC2lOKyBOI069sACGkOTi1HXEqv/TjFqtlaA5SLQdlY38lWGUL30D8iOdRUN+oJr0/84ilQ9cs4gHKAGyYVpVOV6nCJDL/StsG8tqy6wWi4I65WG7JVY7ZFqYuicTmqMUmSr5byIYr/dwhIa2E894LHGo67sFeyWa6POF4/P0kjBH8Ks58X7EDks7P+yHYfib2Zp8gvPU1C9GEZ3w8YdLlqYF6l5SbzeD8w9lM4WBEw53JZKmJAsM6zODMf2+z39MJCzLhKKyxescfW80OeXoxI6FotlXTh0hxxjZBoT2+0O7wNN54lDJhjwecAUoZXIatVwtAgsG08IsGgzPoyc3r7NG6+8xJuv3OeVe6fcOzmm9fqaV0fHNO2C/RjJMou5Z7p3Lb9mfi2pLg6ibMMxUWIhj8qIO7/Y8JMPPuI7v/cDzi6vaBaGf+vf/lXOzh7yO9/7Lb71rcRv/Mbf55d/+X/CH/tTf5qrfs+QM8vViVoRoSw9Xd+r6e0BMtb5g6126DdJE4f374YX4k3yxMHVHjg6OjoUqDl3y86EGIqSGlAdkzOQUmQ3DuRpYuEbbLdEJLKyhpWxuGywRVl/Fp2/FquwYa7CVG+0qBRJYCeSGzCNYX13zVu/+iv88re/wS+99Ro+OIYYGbZXuKajH0b63Z7bt46JY4Ri6FrPFCf6vmc37XGSWLRK3x72IyVl2tCx3w5YqfHyopoj42vKcOW+Wa6h+VIyXWM5Ol7QNI4JFUM721GK5fJix4cfPOKjjx7rjMmv8W5BKToHVRGwRhUhlXEpGgcRY6wmtAEpcz6fwQfPOEWmwWGMZ79NDENmuYSm0Q645JEQHF3noTi6hebzzRfkbCdWZuPkeXbyi9FJ1XlR/Zete7pS7Y6sVTNRa4xSlL0QnEZ3aOHR+yglIxliGTEOLMryM1TxmrO6mErRkDGBprUcHbfEKWq7+6kCo5fU57UyLxaoP5R34wW474sBff9ijptGk9QeB26Ck7Ui2RfmZHVRtCgMaKXexwwj1Puf4UG9Z7l+BClIyUoJF8MUM1OODGUCzMFtQqPg/XOfj4gSNaaUGPqhLp4B64Pqu6zHOUuaJmK/5bgzNN5hSsGkQtsETlYdqyawXniO1wvu3zvlwcsPePnll3jp7h2OViqBcMZifUOzWJPEMUwO13RYxtoZohBVEawPB8aalUoPFs1YS1Nme7Xn6mLDxeWW7//obX7/nff44dvvshtHvv7W67z1R97ia/lVnpzv+OThjjEa3vrWL/Hqm6/w4/ffwTQN59sdr919iSg6+9N0VypRYp6Cl/mbGPd8HM2LUJ9z7qCFOqT0irBer/HeP3dba201YM2kCrlqErF66e2ngQK0xyuyCE+mLW2euBWWGL+goaEx15sXFf+bKjAvIBnjLJSRwkS7dCyWC17+2gO+8au/xFe+9XVObx/TipBTxFsY8wTF0QbP5NUNw3cNrnbadshMI8Rpot8LeRrpdyNt2/G1r/0STx8/Y3O5RZKyArXg2oowfJqaLXUD3HXqmuO80Zl5LkjOIJaLZxuuLndA5tbpCf3GME0D1iVyEkQcyOzU7zDWql4MwzhN7PcatgnKEo0xYm3kw/c/oltYukXH2dljrCm88WZLEzpyjmASoTW0i4w1ga7ziKvC+QPKkCmSkDqztzXZ+IscX+oiZZzueo04XXyowWRlothCu2hofUPbtKzXDW0HIWSCLywXTc0c8uQc6oI4Uox2S46WWRlYykiRCVsWSG4oxeJ84PjWkt3unF3u8e6YFBtKARH94KxNGHxNBZbPJTjc1Ip81hzqZh27CeG9qDN50dVCu7/Pee9ukDustc8/yI3jp3V3cuM2Ssy44ZZhZqxCYbrD66qdUzEabpyNQCkkgUz1ppM5RtIc8PjDo5lCMVJnPU29vT42VgWaYvRCEBe08zAGJ5mOTGsiguqjpmKJrgXf0pWeUvIhOr7xqouj7igxps4hE8FkvHXqHuEDA8IuTZQycHvlaV0mbi5pcuJ0fczRYslRt+T20S1unxyzXi44OTri9PQWt++csly3tJ2SIXwIWOspxiJ4Eg7jG7zx2jUV9Ygs1oJDxbpS85wE1doUIe178jSyvdrwybNnPD6/5Ie1OF1te6I1+HZBweG7E27fusu3/sgf5x//g/87jV1yehLI5mPwW0YMTbsm1vnabHIbo8ZCKF15dkOZs6iunVJSTU6eC85NOrr6IgrTGAkh0ATVyYnkCrVqHcxFSSAppSra1kJmROiWa5pK7Z/GEVvUWy66zGXe4x1ka1kER8DoXKpkgnXYVjenSSKhE7pV4M5Lp3zjj3yN17/+Jrfu32J16wgXPOOux3tPaANdExiTsv6aRWDqIyRwrWd1a4mMChOGyZPGxDBlplhIEXbTyIfvP2R72eNpFf6anV9QBGd26qjfQYgYN3F0vKRpQy23BWMj4Mgp4YNw594tTm+9Rhwa3v/JYz784BNstZMiHyEp4dsB60ZsuGCKe6BBss6XEI8pvlqODcR+z9OHAvEZkNnsH7M4Eu7cPWF93NZUCbQLFHA2s1wJoxOCCTQ2ECWR3ZYcrihjj8kL/LQkfMEN+pe6SM223gaDEacCySJ4b1kfNxwdtSy7jmXbsug83gvGRqxRb7EQFLNFPCUL1k4UYzEoxis5E/OAiAoLMYWc1czWGMty1XJ00hDTiKSMocYyGw9mwNjpszZFX7h7uu4gDqyA+SeHBeCn3e8MG3zOvX+h5/DiMfsL1n9cf//mPdZF/aZiXur/xNx8GVqU1KLGkus9zLmy9ZXeeIwKc1kVm6ooVrtVLZRSLXmqC4k1GBNq2KOFkiAlLIlUIlE8k9ENytI1GBLTOOF90IU15YNbuQpKC/thi6s2WkYaRuPAFlKZFP7dPuXIwbe+/jJf+dpLvHzvLqfHt1h3S44Wa0zt1rxv8MHTtC2hsbhG3S1saJUSLbPnnwY3qgtHAeMQQzW5NQiZKUbSpFoZayy7zZa037M5v+Djs6d8cnXB9955j++9/TZDFo7WJ7Ri2V3u6IeICcecnN7m1ukFu03meLnmzmnH0TrxxhsnOA+h7ZhionHqVFBEKgvMVSuwCrFWEHIu7jc3UbP26uZRciFOqWrRvBIk0Pt9nqquhW12kFfWpz2kEV9tNvR9z61bt2hCYL/dYRB8t+Iyj+xT4iQs6MTSOUuwFiOJcdrSLA3tomF5q+Ob336Lt779FsvjFe26Y7Fa0XQdl+fnNAi2CRijhsBYr+d9Lby5ZOIU1WVk4bl95w67ix3RZIqBRx9+wO/+9vd49viS3WaHy/o5G0wFXeRAMFDiRN3AImhYZaJpHcGHw9WmPnojGMfRyYLVeoE3t9hcZS6vznn0OCNZIelSLCVXwoudiHkg5QlTOtqu48HLJ+y3V5w96cForDy5YdhYHu1GxEyMsudeaAA1v1UY0eNswFuPbx2373Sc9zoDdtJQTERMopgRIWGLw5Ultjx/Lnze8eUuUs8d1zuQrms4PT1mtW4IPtGGiPO627N1vmHEYGb6qUh1XVbq8+xEDZFCxliNZJ6V1iKC9bBYBU5vHzP0l1xdjIhpMKIOBWI02ts8v3z//4/r6qMdTu2+vujvSjWg9Q5MTgSrbg4lR0zJOlSviQY5jYjryKYF68kCYwGPxXrPwrUEvC7+RQ5RG011454jNubB/zyvckGDEHMEJEOOkHtWXWC5bPn1X/tVfu2bX+X4dMnRak3jPBKVWbdoNMHXOCWFGGtxjcM1DuMCuIAx/jDbETHkLFhnEGupAxlFDkQZa7YIJheGaaBkYXN1xeb8kt2u5+xqx/d++Da/88Mfct4PLI6Osb6lW3r6faKfIldXO3J6idffeIvT0yWrxW3+9X/9z/Da1+/y9bd+hX/8m+/w//r7v8Odk9eI00SshWaG7T6t57vR+d44ZreJw61M9eiLmZs5WzfRgOvbXhMz5nmW6tF6xnEkhMDt27cB9eVb3DrGY9kOPVMsnDQtO7YY32CCxQZP4z0vnTzg6GjBvZfu8ta3vsbx7WNMMLTLrsK4Hdig5r5poBihsyvEWEJjaV1HkZEcR6YhMpWICZaFLCm50JSOLjg+efSYd77/Hh/8+EOCaVm6Fft9j5eiJI7DxVHtbc2NVaMiEsZYtaqqjEjVplmkKBISgsKNJRl2GyGOhhw79cAcJ2AEOyES66Z+SetPQFqOTwLf+KZju7vganuh+j5pcWVFHNW6ygRAWhaLY7p2renmWTkATWgIQSNlFivHZBucVUg8RUOhpeS2Jpg3dTOS+CLHl7xIzR+j4rjGFhrvWCxbuq5Rwa4ZwUxgO8S0YBqMNOQobPpMThulSmJ0P2gbmtDShkBoPI3XN76gJqfeet1hmIJ1npPjBfvtRL/d6s4iGwyqecnZ/EtLXPgXd8x5MrZeZA7rPUxf9NcVWrQ5QhrpWk9rCk0LSCQ0TjUaqEeYaVvOx8Q2Kfyn8AlYRoI1kCP7YeDq6hwR4e7duwco6UV4VgR1PC8CSY2HMxYXYO2gSQPffP0V/sL/4s9y1DqyM5qxVNBOyQUMEHyjr9lYnYU4wNaMJDxinHZTxlMKFPXKUNPU4MhZtX45ZuIwUZJGemwvrzQ9uMCYhSebLd/90Y/57e/9kM00YULHlAyb3YBBN1L9lHn2bEdJKy6efkJoE9/+la/wlW+8hjURExL/+3//f8Xv/tYPcUVhs/mYC9PM1PtZx1ygbhainBXW8v46xXieRz1/1lwP4EEL3m63Q0RYLBbEqG4kt27dYj/07KeJ7ByNyzQenl495vay42tvvcUbLz/geL3k9PiYLrTcv3OP0zu3KCYjTmiXHe1ygWtaBEdM0K2OKSPEcYRholusmPqMEUsaCuMuIUnTg2UShrORq4sNZ4/OuLrY8v67H/DRex+zYIkkS+4zC7tUVt78Cg3wIryt71jtJA3OenxoDgiLlKo7MzXvjIJxE6lMDL1Q4gpM1uRws8f6iHVgbUdJHkxbO9TCnfst918OfPjhjv1OSMlCXmHNCmd1E9ctj7h96x6LxRGp7Cil0HqHD0ooMzazWAnJO2KZSGnE2g5SR46dyiysx9oa/vUFji93kRLDtSV4wZhC2wUWy0aTcSVhXcEFZeiVZJlGZWjtrgamcSLGQfFvp8UIG2h8YbXILFeetsuE1ii8AoedeqFgTGK5arlzd800wNPHUUkYUllONoB8cY+qX7TjwNqqGo0v+jvOCEYSq9bx2t01C5tZBoESaVtP23pEVLEv7TE/etKzu5wQ1yIukHLCyoSJkdgPDNsdi65jtV4zDAOXl5fcvn2bpmmUtVczoFJKCCo2Liq2p208i2VHExZ0jPzRb/0Sr79yn3G/JYdWZ0Qp4bC4WiRdaHEhINaA0Sh0waB7GgfGYUxQUz9QiA+r+WYyUnJEspCnRBw1Nh6Bvtdzuh9GPj674Ld/74f8k9/5HvucaFZHJNRB/XK7Z9EusDXxFRpKarl1+yXEjty645E0EFZrhu0zvRaC0DinG7kK480+e59dpD7dSc0zqKZprgW+xqhjR+1WX7RLmj9zXZMNi3aBiBwK1Ozr13Udi8VCu6t9j/EeciZ4Sxy3vPLaHf78n/t1vvXWV+kai5RM4yxHy1u0vkOk4IJmw9nglfw5O47gaJolm/05237P/skz7t17ma5ZcfnskqvzDcOuxxtPalqceB59/ITf/c7v8u47PyGNmcZ3NLQM+wkLtG6hZBCbKlPzhdf8wt/Vpb1eM9U+6xrMLwf43xghloFpGul3iTQ2GJvoh5GUezQcx2PNCiMNpThiivT7nlIMzgYMNcpFVM4TQiClHWPZcv/2EQ9euoMPMA2TSnYcmLnoWPUD9KsFT8+fIowY0yKiHZ+IwbqCceMvRpGanZuVCBYxJrNYLOg6jzEqyMU6UhZEPMM2s71M7DeFsc+UpPTTIqkaMxoKSdk7SxhGx2JZODqGxcpUHz71C1OtneB8Yb0O3Lm7Ynt1SY5JrXKsw4r9VIF6Ucz7RY9rdhuHC/bFn33R+712wpjdOirz7TMqxYtQzs/z/A3XMyjle1yzvbCanGvqXOqnP9eb39DFI3jD3dMlX3/9Hkc+4/MOK4k2WI36EJ2H7Wh4/8kVVoQk6jxgqhi4lEjjDCdHK0zbcvbsHGstd+7coW3bA/w3TdrmLWrukaAmsL4Ii7Zl0VgaEkfO8Mtf/SrBguk6BtSQ2DVGh8o4ioBrW3U4dwZjPblaPoGyzozxFOPqJqyKkYuor2Dak+Oo13cS0pSJU0IKxFwYUubdjz7iN7/zfX7w3gfsc2F5fItEtdUxmRgzxnraZcd+mzh7ck7wHY8fPsbYzNe/+SbNcqkUehtYNpZf+/Y3+eTM0++etzm6yby8eR6qvxvPfR90Dtw0zYGKbp3Du+e7qJv3fdOZYg6c3O/3lFJYLBa0bcv5+Tl3794F4JNPPuH26SnBOCQOxO2Or75yl3/vf/e/5quv32e18Eie8M7QdR1IixSHd5amDWAMWQTv1T8vZ4UYs6itesrCBx98zDu//yG3ju4y7iL91V6p5VHnmNvzLR/95CGX51f62gikQf0aO79AslBGfZ3JR8ohPEWLsaO6eMwXjgjFKHPymjelm6XgPbN5q75nAGrvVsRgTKsQYN4xjmMtPIB11Q9z5NnZFR99+IRx79hcFtJ4jBFRB3wyYjZYu2O1El55/YR7L62wfgQ7Yuy1+4SSixI+FBbrJWNu8O3Ert8eZo0a5TJh3J5ivhjM/yUvUkAdKopEnDc0rcc6tT8yxmJNyzAoFffq2UC/hWEvBLcAcTjbUPJYC552QSkL+11kmnqGPhNCR9s16sFWd3sz/6xkzS5aLi3rtWfsJ6W0CtRo109dxD/vcdglHf79aRjx5y18VT9bJa564t9cZF4sTJ83K/is53BYuAw3aKZygDaMUR/EXB9HyQ/2U/f1Iv175pBIfQHeCJ0rLH0i2Eww6nJvUcNZYxyXuy3Dfot3a0bJGrlSTX+996wWC/px5MnVhqZpODk5oW1bQJN+h2FguVxydHTENE3EcSKVTAKarsW3nmBgaR13jpa88uAlcB7nAkGcRnMbR0k1VylmoqiMQc2u1WFfZ3T1PTBztIUu2sYoLKZMKn0fSyrkKROHSIqFzXbP5W7PJ0+e8k9+9/v88CfvM2Hpjo6xTYstwhTzAV4DQ9ctyGnkv/wv/kt+9N13efjx+7z08st861u/xjQIrV9hjeP+3df5c3/u3+A/+y/+/qEDmg91yo4aIV8/r1JKXUmvvflmgfTx8THWWna73XPFqtwIJXzxfItV4hGMZ7vdMgwDi8UCgM1mw2q1wlrL+fk5bduyaFr8FBn6nlfu3uLf+bf+TX75a2/ShYJ34NtFXVCrD0moZAx7LYXIuTJEq6vGFEeuthsen53x5MkzPnz3E4iOMgp5SORJbZviOBKHBLE6SIgCzA7ddMRJha+IZmilksgmH3wEnbGKDpUKFdfrU4uTJSWpRUGLp75vVNd6mHNKikSM0UyrIplxiGyuRu4+OFKxMA5jEylv+eTRQ374/Y/otyvIR/SbBWnS2a/4gcIl3SJy/5UFL726ZLkuZPYYO2Ft/YwJOBvIZcAaoW0bVkcty5VjTFkTt+3MWpzAeP36AseXukgZozk+OScwhbZr8d6gojy96CUHdpvIxfkVu81EcAucD4gkpfTikGLqptVgjNPslhhJOZHLxDRWm/pStdNGxaGS1X+q8R679Ny5vWS/ifS7AWxTh9zP08L/MAS7P9+bVAuQvmE3dr4zlHGTP/c//CGVJabvy6e7wxcPYzRHqpSBPA3ktAeXCEwEI/UiNxQ0UmXXT6pb8Tp1NCKUrFqXNnSMQ+Ts/AobPLdOb6mnYEpst1umaeL4+JgQAtvtVqtjdZJwi4ZmtcBZi8SJNE587dvf4uT0HuIBa3DFkaNmmplqcmwkqXWRD+B0DkWpERf6Cqu/nFLzpQYxlpyJaWLT7zV6JmbymBn2E9vdwNOLSx6enfHff/e7vP3++9h2gQ8LjLUUlMKdc6KkTBMChqIs2OWSy/MLvv97v8Vq3fDOux/wn/wn/zf+1J/8dY5Wx6Rp4rd/+7f4nd/+EfvUVXeDazdza+1zeqcDtTxcB0XOn+U0TVhrWS6XB1r6MIwE37xwPmhhmtl8pRRW69XBemqO79jv9xhjWK1WXFxcYIzh9PSUxlpIE41k/uyf+VP8+p/6EwSXsWoiVUWzHmNrx1qZgmrOWtQhPidKUnp3ScL5xTMePv2YD97/gA8/+piSHUyG3bM9ZczMOjGJYCqsRUV6irFYo04ZRYp2UvV9msyETja1CEmFdjEO43Q9midURYScMjlLLT41UZl66VRncSlCLhExPa5pkAz9PrK9gpLWiBUSEecLoSlAphQY9oU8CnGySIHETgvUsnDvpRO++o07vPTKCt9E0jSoD1+2GLsgpyVx8GAaUsmYMtG1C5bLjvPNniLUvLZSQ0FnI8WffXypixSo2DZnzVlZLBp8sIp1mgLGkxLstoW+17nT+qhFBIb9oK4DttojWYNrPDEKViylgLOBrvUazdB0wIhIQZNaHVJUJ+KDDn5vnTouL0amcYuUqFHLcs3Uvlmo/jBFvJ97HBhRcyf2vDD2IPj9KTqpf26HXC9I6jZeoYwXnt/zvzIXVPX1S3mi5AiSsVZdEIyxaquEo7iWIQ9KbnCOYFSMKWWklMzlZmLcjRTjuXfnDs47zs/PDy4Hi8WCcRzJOWt3JZDyQNs0NEdHtEcr8jCQ+oQRy9e++g265RHRxGvLlxm1MWCMV0jJWoxvEKcED0Rd9hUmK4drV0ohx0TJpc5/Es54NbHdT6Qxsbnc8eEnT3j/k0f88Cc/4cOzM+z6CNc0lKysVYkaBZ9iQgWWBrLmU+EMMmbu31+zWDVcbZf8/b//Pb7znY9YLJbstgObqx1HJwuObunsdf5s5vnRzMyb9U83xbs3jWVzzjx58oR79+7RdR3b7fYwi7rJ7Js7NWMMwzDQti273R5BQxBDCFVoajk+PibGSIyRBw8eaFFLEVMSD+7f4V/9E3+U5bKl769Yda0u6cZjXIvzrdJojBYJKUlZkzkTx8g0RiRbhv3Eoycf89HTh3z48UMuLzYch9ukUZj2iTLm2nFlUpp0Hmpc5UJcJ/46UzccRXTTIJkpT0idKTnUTgjjqrWUQWwlRojCvjHp53gToakljDq9ohSduYUm0i0NQy/EKXPxLNNvG7o7HpEJkQnnDffunfLmVxwfMXLxLIGFnCewe0InPHjpiK+8eZdXXz+hXQgpVzsmWsY+cfl4r+eTWA04NMKDaUdYRYZe5QUlqwJESsDSoqLiL7bmfKmL1IzPCkLTeNrK6NO0SHWIiFNhGFTftFx6VseOnKPSRqeCtYVAQ9d2rI6WnD29Io0KPwnQdQtC06mLhVVGmhrReIzRxdE5XTyXq5bbd47YbgbGQTHkEufn+tOhsn9eh7neZh0aFWVJ1epZYcR/Ed2U7g6LpuV+wU5KDNXdwxwgUCOax2TUZqTCCIFYGsaigtiUEmILbfDkqTCmkTRm2m7N3VvHpLzn2bNnh1lHCOFADFgsFjRNQ79XMWe3Ujst2gAl4UJg5Vpef/2rYBpMUCzflqjuJlXjJNbifaNDeauzuJQzthRdJEWQrJlTUnTXPI2jZpPlTCyJyQjTMNUZSOGTJ2e8/d77/NbvfZ8Pz5/Rnd6mWM+420OMVWhrD44U3vrq1qFM2CSRu3fv8u//+/8ur3/lVf4v/+f/nB987zc4ubWiXZ3iQmC7f0IfNyxtwRj/HIT3IkQ3H0VyXZDLoUCFEBjHkfPzc5bLpRaZoyOmKR2YlHOHNXv5hRAOYvOm61gYathkOsgEttstJycnLJdLdrsd5Iwl881vf5NXv/I6UQrNYgFh1he1FNuCazASMTIxL/Lzc84pMvU9w37k8mLLk8ePeHL+hKvNhuVyjS+Bs2dPiUPGZRWsYBwOR5RMKjNdtaIzNuOyU7ZmdQIvUkgmIkZwonZsugW+pkSIaHcnRtePoR/p+/6QGPzpKwqkGJarBa+/eZfT05ZHH2958njg4UdXvH/3Gd3iHos1GCs4PPfv3yX4U1bLS54+7pVwkT0uNKyPAq++dpe7d1Z0S8h5JFMoxZImx/nZwEfvXjBsLXHI2mkbw9d3l7z21o7N1RpEnfpzUsjTmkUtUr8AFHQNsdSi4b3De6d6EqHawAsxJcZhJGfVvxwddxjjWHSZNKkAN7gFq9UxIo6zswtSSVjT1oGtsLkcyMmwWFqatuZM2VITW13tqgTvCut1Q9d5xmFEhb0chpo/z/HcGi31pDWq6JdPUVTrzW50ajMZotyA++ZOar7PqoX+QgXqcwvsje+/MCU7DHgBjLj67/rcTalCREGKOaSnakZUFa1Slfii3zNUZwVTcEY0i8rY+hnMz8FePxONxMUYD9ngcDjR1NhFaxDbEcISGzz77Y7t9orbt+8QQqDve0JoWK1WOGeZxh7n1FeuWSxI3jPGDMkQXGB9tObk9ikZiwktJJ1VamyF090vlQhRIR8phRITkhKSi866ciKXGnSYC9M4kKOmtqackMbS73ecX2x5+uSc3/yn3+UnDx/zycUlpltw2ffEPrNqWzSoE7o20IZWnVmqb5up0Og4Tdx+9R4v338ZS8Mrr3yFJqyYRrXamWJisTzCtY59n7C2RYzVyPXagBcRyKrbQtRjbj5fo+hnKlIw48CRtbgYGbZ7/HJFtkXDFo3R0EHA5kJjHVMurFZLtrsd3XKJ1AI1DANNCLRNy263xRrD6fEJeYoVggeC5Y1vfAXbWMQmvUaNwZgGMQExjjwjCcbgxNQoD0FSJg4D+/2Oi4tLzp5ecHZxxjREbh2dMl0kHn74kDyALVYlAKIdWUwjiaSWSzMygFqvpUoZ10wlNWBF1NRYqlGypkEf2BGHZGABcjH0/cB+36sdUp1TIQEpvs5hwXvH3bsNq9UR/bbBmqfsdxOXF3t+8u4jbt9dcM+0+C4gVgiN5+49x2LR8NobiaHXuBrrdPN/fLIiNEIse/WzdAskCdurkaePep4+6iEtyKNBKOSS2V6OxKlUjZTOn7NIXQcaTPFfGLz5UhcpJw1kSzANwbtqLAsxZQxqjyMGsiQwistjwAfP8fGaxjpK1lTSRddytdXZViGDTUhx7PtCTAPHUwMEBEPbCcVOWN9hqeydpE4Wy6VhddRwcTmRYlAXjLlo1E/lpv7m5k7UzTT3mSQxw4R6Yw5SigPV4dPHTQqvIOp5a9S/0M2/peuLfk9+6t19irzA/JxvdIY3f/VQEEVnQJBxWMpBQF3AFsRWeKQIsViidUQD1mRwghWDM0Eh2Zw07M2OGNTnbOEynW+g5npZYo0uF70Pa7Bmh5UdC2PBrrBtyzg9YxEyYkb6NNKGYzabC/q45+T2EWKFzXaLt0FNgwV2myuMLZzeOiEsPEk0m8nhMEXjH05vn9AugkaJEEipICXijcG4gNQwUkWFtEAhgi8FYqHkSCqJUTJDSRqhUBeuHCM2C3kcmKaJ/XbPhw8/4Xd+7x1++MFH7BO49THiLZ1J+BxxIhyt1lgr+GAJoWUaICVDTuopuGhWTHbLyy894P23H/PkbMOr996g8bDsAsHDag0XV+cMO8Ptey+RxCJ2ADTkMKeoThFQ5zAoylAixVtKNcl1RrjbOMIwkseJdHKbrQlc9FG9DBuPlYJLQomqe3xw55TN2CMOhpJoxR+6q0Xb4a1lv93x4P594jQpdFgKgqFYxytvvgZOXb9dLngJGpFiBeMzmUi0KPwas3aew0gZJ8a+Z7fbcLnf8mj7jG0cCDRYHGdPH7K/6Amx0eeaC84AVj0/i2RSvTa8dWBKdaafGZx1dmSkkrbQzYtvKxJQ41sqRbtgcabFmcJut+PqaqudefEYOpAG0I0YVnDeYJsdfjlgQ8T6nhgn+l3io/cfc3TsseVr3Ll/i7DOFIlAYrmGxcqSkkPEVicJTxEYSs827jE0+LTk6mLg8UcjZ5/07DdqfOt9oOSMsUlxKFF9V0yJTKQwVaJahTTdLwBxwln17DMGurbVHCCjQWyaN8PhjZqjNvT3DK1v8c5hiuoO2jZQruLBdwx0UY5TIqcIJlLynuNbLW23qvoMiLEQLHjnyTnStI26FLcDwxAPjcaLcMgXOf75zq3+APf9AhHkpz/PA3fwxlcN4zPX87DZBPbQeVGgJAKaAdZ6oWstXauJuAububVqaC2YnLluoOaeUbB54HRp+NrLJ0R7gm8bDJZ+nxgHeGoT2/5KXak7jeXo+x5nGpbLFU3TMA57Usrcf3CH5aJlyokkQq52NjZpx/Pmm2/oJsM6xqwOJbamCqdDl6HFKaVUvfaEkjM5RqSoe3nOmRIzaZqUgGAc05SQGsR4tr3i3Q8/4h/+5u/w5LKHpmOxbBHrEFsQk/T9TWB9W2MnRnJJiASGqahTddfimxYbAu998JC/+G+/xlt/5HX+q//675EwZBsQFyhUNmLxlGKwNoKMOGsI3pOtupBrplf9LOd5IzWCXjI+TRy3DUfOsdnsudjusKIUfSmG1foUmwtn+y1h0dI2DcVaphgxzrJs1cw0pUTbNBwdHdH3PcvK8tNZVD7MYBfditu3buusLynsKfZ6QDwzRUEoSZQQkxIpTkzDwLYf2Gz37DZb4n7CJoOJhrNPzrg8u0L3vRo5ozKYSkBAjXBzff36WOW562S295qnrKrIsNX/8MYcGVOfqKgeyYo62T/rGYaCz+onacyo144JzNlpuSQgEVNhGEbiJAS3JKUdb//+R0x7w2tffZnju4H1ccdi0YFRohhidTZXHEW8OvLkQM4dcbTsN3s+fPspH7z7lIuznpwcxc3wb03inaUTOD0fKxo0E5NvXus/6/hSFyljCrlEmkDVOMjBS6pIUijQzGGF1Q+usv7mbkUjwPU2ylK6bivmMIRShKHviXEkS0u3EKxb0DULnNFQPGsFV232u0UgNAZMhJrTcpOe/WU+5tPqRcbiF35dM1JZf8dVIa+hYEW7ICtWTRhyZtm0PDg94mTR0YaJ5aqt9O6JlSt03sx+DIeyO5/+TjLHnWG97MB5vBWCdwzDijEv+H465+pyg7MLjPMMvTLNTo5PMQKbzSXGwP3792mCJ8VcFwDRBGYBqcapr73yClJm2nK6ds2fCQalIFm7p5yz/h31gJumUcGfUpiGgTjGOrMQoskIsIuRq92WH7z3Af/db/5TLrYj3fFtJBlKhbIyKo3QTVoLqBzDWxj6nmmYMDQslx1HJwtsEJJE3vvoQx5fXvLqV77Jex99zCiAD4RuybDfIdbhasHzbmLdFvbDSBxhTkQGV8kiihLkUjRgMhXIEZsikhO3VmtutR3lfEMZ9tjViv040Pcbjo9PCEdLcsmMBiRN4B3rbkGKkd1uS2gCoWkOpIrFYkHOmaZpauJswCE03rLqVlUqMsNiWhpKhZXFCCYVbCzkrGqlCIxS6GPi8nLL5bMN02bAFMP2as+zh+eM2xEvDVOeKFlNbg0FYzIJ1T0dwO7PYPXedDAxlWbujK+pDbrbOsxbD7+j50hOwsVZZL8tHOEoErE2gYvAGpEWqVEtRQz9LrPbZFL0eNvhvWW/veTt33/E46c7bt3vuHP3hNPTI5Zr/YytQxmE5LqmFvpSuLgaeXa25fzJnscfXXDxtEdyQ+M7pLgbOXABwYNEimg2lY4obE0HV5TrM41NP+P4UhcpIeGssFi0NK2rb7CyjKbE4Y3RRVRx4Vw0FrwUPSmNVfV2zpmclFmlVV/xY2UDJ7AFS2GcBq42G5rW04UVtqrtiwjeq34leKsQg9ddWinPd1L/rILef1mOFy+8n6fwzrvDWfekRqkaMWGZI94FVwoOWFjP/aOGB7c7PBu6RrsVSQaXEy4nxbftix0blJKQOLJctLTeYEl4mVg3iV48rkykEjHNkpwzfd9zfNwyTgPDbg8YXn3lZUJwmmI6ZlLOCK5CqTprOT455vT0ljIHRQCnJsRJs3pSjNo/FmWO5VwOcF/JmSGOurdOhWk/Qi4sfCBjGFJmKsJHZ89498MP+Ef/9Ds8enLBrdv36LNCQXoOK73eGjT2wVuFBnc7nJ0wOdF6hzOCNUKcJqYxslwkJBi226eInRimK2BEGDBmomvh+LhhGDJpumC5zDjZYcqANQHnO2Kp6QMidYGEbJIuWgVMigQRVsHj8oQXeP14RTNEPrx4AouGZ2cjxWToPCUbpimCCE1o8N5x+eSclDOnt09pmuZAxmjblqHvq5t6JniPxeLEEoeIPVGIztbWSaiswyzqyxkLjJlSIjFn+mniat9zdrnh2cWG1Bf85Ih95Pyjc/rLAZOtMifTVCvNnKab6+uuBrFwYC3eTCi++eec6+SsSl/sYQN9g5giUEikMoIEtleOzWWk7UDKhPU9xiaQFkpX2YKGHC2XFyP7bcHZJTlZch6wfgGl5eKs8PTZGR8sLlksGparhtA4mtZRcjp0gjlndjlyebXj8mLPuC9IdJBaGr/E2w6D0ywqyXXOrcVWinZiuRgO3Cgrtev/BeikrBVCgNW6oWkcYmMlKaiv2jQVSqLSYKXqH6rWqQbZuUMnNVOA4VpYOnuLqTjt+LgjNIUQ/IE0cU2dnmEPT9N6fFBYS9fkn81a+6zjp3Uo/yI7sxeZij/3c6lwEMZWh3K0OM2FS7QzapzDlgmb9yzw+LInFIuRVin+ZcIbT/CBa1sZc/jTGE/OO4xEliFiZcSVxCSF8z4x5oxfLJlw7LY7QD/DzdUV6+WKl19+WSHfFHVHWVDSwI05njHCndu3WK8WWCOk6kYyjRM+JyRnxnHUgLmcSTFRqq7IFF1ox1IdTDJQhNa1BBfY9ANTTjy6POc7P/gBP3j3PR5d7uhO7pBcQz8l2q7Vc74omcQKmCJQ9gRG2nbCmR58oms6cox4HzF2Q5m2WCamGPHmkmAuID+lC1saG3A0LBvLqw9apAQ8kWUoHC8s2Iar7cijp+d4F0iipIMkRWHLyrA1BVwRGmtpnSGYQpBM13i8DfRpYMoDo1geP/qY5ekpy6NjxOq8NO9Hdts9Uz8QFh3eeyWcmPJcaq+1FuOpUgNb51U93FsDugZoSKMSO3IyZIn4SShDZEoj+9RzcbXh2bMLnjx5xtX5jjY5psuRs0/O2F/skVEwOGKMdSHWGbZusgpZdS2oIePndVDXw2YtRw5rPBU/4DrQU2+kM+VMLBFkybj3bC4nVjnTWqMQrzGoYasg5Hq+GbabyDRanOkQk6vptUeTHywZyy4l9tvE+VnEOr2fnObwTN2YRQNJDCV5JDs8TZ1ZdWp3ZAzW182ZkQr11a/K3p2BfFOhUT3hf/bxpS5SYjJNG1iuWkIDU8yYmqi630fGQVlR3mtSZtN0hxMk54ILMxRXqtlpAFH7GGPU0r4JGuXcto67d29h3MRypeazKUWwGWcsTUAp0EUIYfYn2xyo1Z+l//lpBUjkulTOOhKgxm9cF7Av4gTx4jGTMyqw8NPf4xvPdSZOzLT15+7zxmvT7CCDLfPsae4g9fGssYidlfO6YbBoEOE8TzJGab0lR/LUQ27wdmJhA9ZrHlXKuRJD5tdxzewTEWK2FAkY7yiuQHXbjskitmE7PmMvnr5o1+1cqGLRltu3b9E0jqEfDouJFIWTfdMwTtoVWRHu3rmNkUJJkw6Z01R36kp6QISS1JEgpXT4e07K5MNrFpbEzKI6WW/3I5t9z8fnz/jtH/2A3/7+D9hMEd+tScYjWHzbMaaRrmkBJY2Y2pHBjq++fsz/9i//b7h3u4M8sttsaMMS61TLgk+M456cLV//xjGNP+ff/Xf+DP/mn/sjrI87Qmdpm5YQVlg6hcRSwtqG5a17fOc7P+D/+H/6v/Lo7EpF0nU+o5+5diwNHi8WW7TL842lKQXJIy8dHbN+cJvpow94stvjvWN3fs56fcTJ0TH9do/YyH5/hQ8OH67p733fa0dVCuv1+rrjyBkXFLp99uyS/MZ9Wq90ZymZFCvLzgtjHsmDIENiGHs2w5ariyvOn16yudghgzDsRnZne3bnPWSDKZaUlJWaZMJYozIDb2oHcZhoM298b17DN4lNera72ul5nPP4StaZbzBHn1hrKCnjTEBKoO8jO1Oqo7vFOZ29OVuqMFzI2RInQ5wqYcdkmgZyiaRkwCxBAs6qRyXOVfutiVIqwmHBSK5aPQ2UpViKaFJvnITGg2993eQnnIZJIKXonNJackEDMZ0yAK/fo599fKmLlPOwWHrazmGd4MRoaN1Y2O8mdttRK70IzjqWy2XVVtjDABVTA7uMraJS/ea8S4J6cXlHt2jxwbFYeoSMsZqiM88erAjGOix1Z/cZoYM/q5j8FKJdhcrmW/0BuqnD3fx8Xd3N5yd8NmypRecGDfx6Vl1nRTfjxq/dLw7lyVQKhbFkMcQiyta0Bu+sdlDZ4wxq0IrOP+a54vU00YA4rGv0IsGQjaOUQHYt+yjsomMSz5ALcYqQ1cvxwf373Ll7m77vKZJBzIGEo8LETEwZbxqmYeDundt4ZylJY7opuj9Ok+5IReRakBv1e7PLd/Be59TWoKZ/nv0Uebq55NGzc3737Xf4zg9/yKOzcxbHJ2BUaG5KwXlD8FahPkq10REomZL3vHT3AX/yj71F6weCyTTd12AUcEHDPV1hmHZ434LtsNMZrz1YYl9ZsVw1mDoP0+iaDtyCKQoxGrrjU9762lscrY559GSDlPkz1K1CMQZTDA6DLw5bFGpLFJzV4u7MxO3VLX7p9Vfof/Rjcil417B99JSp68lqU0BBWB+taher5JNhGBARlsvltT6qqLA4NC3OBH789jv8T//UrzLsn+FEaHyoXabq39I0MPaR1Ef6cWC/27K/2DFe7ij7TOoz/fmOYTPhpCEVZeKV2i0WKdVWrL5yqdfUDfuvz7qGDrD/3EURtFDhK9lm3kReEyhy0Q5IilT6ueX1P/VbtGFJ01aTVxqgqR2KcDwJzVf2fOVfi5QUdH7lqthYAphAruvdTVsqkVpID0W3dsgiBwanFaOby0r2cFafq0YbQR4sv/X/eBkxRa+B+eKss0Ax18SSn3V8qYtU21pW647QGIrJCrWgVTulQpwEcUIuGR8sbdtWSx3F5edTxXtHzsI4TsyeWPoTozMsEkW0o9I5iu4ULfNwcV51qbulmvEiNxbrX4DjubmbfqP+ZO70qgOH1a7TOs2pKYqj1VmV/jXjKTU2fMhCwWFDg5QRqAF5TYc1Gn9tqZ5n6OTBSKF1DtqW4BxiLWI7Ug4ku+bZ9oIhVgd2XYopJbFaLbl//z7eW2KctGOdTTlFF6Q5SiIE9WZ7cP8+IoVxGKuvn0NMqLHqQk7qVp5SVFPjupu2Rp0wihRiTEwxsSkj2/3AB08e8d0f/JDf/r3vEwWOb90mZsEUjTvPMQEeH1Sc65zVpNM69wpNS2jUg9AaQ46RMWaC7ZBiSAgSIGWDs8LH773D6enLXF3uWK2XLJeNit5LwWEwTnUtTbMkdAsojpOju3ThqKJM+j56A8UaVJ5scdlpuF0xDCmxsZHkEp23ZJdwZeB0EXjzzm0+OdsQkpIDpn5HWHaERQdGafm+RtLHaVIWptNE2tlxovHhsDlslh0/+PHb/OTDj7h/0iKl4MhIEsiasJyGkX0/0G979rs928srrs7OGZ5tyVcju7Md/WVPjiDGk8tQ05mzwo1GCRJz7pcViy1qIvxZpskveltaDK4EnFHo0+k7rdcGKhuxpm6oxePdqpplR/7R332F7/+/e/7on3iTX/72A0I7Yb3OSDMTzjn6reP7v/OU3/un55QcsG6LbS5YLhsW4TbjtOD8YmAYEwaHsx05i6IAh+eqHfIoI0l0nm/E4q3DG4uzBmsEZ9AOymWMz8TesH3cIqRqUlsRGGu0o/pFYfcpYcJjjGBMwc7VWSzOBtR4dmbwKblhGid1Dq4mo1J3ECklxmHSnT9UDEluLLymsoNmy5ZcB5xKb7cHlpqj5EJKiv/eBAD+x3y86EJgZipy/bnUN/Zm4+VcDYgs+XDKijFkox1Fto5kE/sk7GJhufC0VtTKynl1pTeos4c5cLhQy9bCwlia4PXCMJCcJ6bAbhDOznaQDd5kghHGop3I8fExi0XHfqc5Y9qsKdXYyPUQvFTSw8nxMSfHx6rPKYl5OlxKwhRDyRo4Nw4Dkgtt04BzqicRkKR08ylF9nHiyWbDOx8/5Ls/+n1++ON32I0TR8eneBdUiFwtdBT1z3jj8M7ROI8zljxlsimIWbAdLZ+c7TlZCK1z2KLwYzHoDKkxjKlQpkuOjl5iNxh8e8p2N3K5fYTzonOzuCElRzYNQgBaHrz8Jt3iji7gSQuU1S01TkTd6MTpe1YsBcMo0JOxQWiDw7QGTMZlWFvDiXWkoqLhtu0IvqU7PqGVjkfnjzHVxy9WN4rZ12/OksLAOI6MYyTYhttHnu9873v82T/9R5XSPxZyrGnAJTIOe3Z9z8V2y/b8kv7ZFftnG6bLgWkz0V/uKMmCCTViPpNLIpM0wc4owVpE1IVNLDbrZ/MiSPEiE1bn4R6PVxeQ6hlqDDgz09HrNWTASMCZQDYTxiWmwfDxu4V1O3HnaM3pXYtvd9gQEePABlIfGK8Gds96hiGzPgncP77Nq6/c5/bx61xeBrYXP+HZxQUiDopnmnT9LGo5CSjhbCATQcchxhOsxxuLr3CnmYXJtmB8QrLFMWGsZk1VVbeuk3Y27v1ix5e6SK3XS5omYKw69jZNIGUtSl23oA912I2QcuLq8pJ+n/HumGa1AJlp54VpmjQwjrn3uZ736L9uFCxjlMViqwbLGazXXU8RFRNPUyYnwdl/MUXq533EnwYz/rzH/B5xY8Mk9UGuZ3Tqu2isQeaYigpu6N7dEUXhkN0YebbZsmo9vjV4o/CdNdqNiVFasa3d2nwvvhSCozo5OErR2JZnz7Y8enSmF8o00fhGF1ir8Q0pRaZxqF2z7pJLrmahQKw+emPsufPSa5U0M+GKdjSpFJ19TIUUE2Pfk2JSXV59j3IpTMPINOrXZr/n4bMzfv/jj/nB+z/hh++/z26INO2Cst3htyNt0yCS8CHggsMWwdugbFLnIEslZYC4hh+995T/7D//r+kvP4a4p0yZRXtMloZJDNJYYh7YXz0lTonj1R2G3cRuv6NbOI6P1f3dmY6hz6QsNIuOnCx//F/51/jmN38N71pFDSga514EnMaSCOo5pyJmg2kb7Npi24JrGrUl8hYfC0wTK9FZBwViMshU2G+27EPGNIGm6aplkVLNQ82makJgu9mQZrmJhaZtESv83vd/wIPTJW++9BKNONKgG8gxDVxtL3iy3/H08pLt2QXlYk/ZTsTLkf3loHx0MSo4F/Xay5Vgrv+peay6RVR3lGIw5sUu4YVZNKbqolwNAHR6Ldxg9Vlrr69HESUBpaK6KBu1czMNTx8PvP2jM37J3eb0vsVa7fKMitWw1tK0lsWy4c2v3+bNrzfcu3/CItzh0SeZn3zkefRkhKz5ZXYuIEYOG8oi1R3DqCmCjpl0djxDeMZkmuBpFh0mWJx4JAX2vSHuKyJR59F6reXnd6w/5fhSFynfdDjvKDJgyFhXSMOI90csusClEVKxpGxx3rLZDDg3crQKnB4ttUXF4EUgphoPDUYMVrTLEhLWTvX9LMq7yYEZFBQrFJfVksR5JFnilElxwluN/5gX59kCEtDWdyYgyDU6aw4/4/MrjTwPp83CWBGVyRaRGT27/hVzbZF0eC7GVLqsHjNN9sVE2pvHc4/7AvvwprmoufELGnjmAMGIijuNySC+Oks4hIQaqMwouBArEWAfR3a7iXKyxASvFFaSOvxQwASsCcSUCE5wRjudVD3rbAGfKlRnHB8+e8h5HBiwZCPYomLe2bVgHHriOKFOasoWxRiKNYxG2KZIFyzx6pL7p9/E5kl9IJ2ah05Ru/JpyMQpEocBI4amXTDu9hQpDHHiarejH0b2SXj340f88O0f8/GTM863OyR3BBMok5DqDjWnSZmlIWiMvVW6NUVfZJZCKpFsMo0LlGx5/OgKmSZsFlKfuSo7jIMxFxYnR2x3id1FxGJosKQY2F4lnj3dsj8t+NdusV4ukTwR44hvNdLiR2//HqvjI8TG6tDi1SXDqMWQNYFcMjYUUpz0HF2vae6usL6QXSE7QyyQh1GnMmPCZljZwMZkRgae9Rv6ZDi+d5db7Yomw87rbKYJDavlCmcsy2bBsl2yXCxqKGlmc3HG988/xprCv/E/+3WO2gUSM9Nux7DbcbW94Gy/5dnlBcNlj+2hbBPj1UQaQbLC/SlN5ByJtYfKMttz6QluDgwDKG6Wql9D2DNXTx1BNXnBiatAoavFylVtnfqa55npahSMLiVDzcyTyrKzpmV7YXnv7afcOvWsb3lcO2CcwnfBrQjeslhn7t5b8Y1v3uXBKy0heHIsTGnPNPXklDHS1pl8NT02NdwSRykGUxqszwg9yATmGEyDmAncnmZZuHv7lPv3Tjk6chhr2e8LH32y5zKO0BdsMvjSYEvEugGRXwDHiWFQF1/MiAupamXAGmHRBbrWEpMGqzkLkPH14p5zYpzzkIRpP5LSQCGAzLoHASJYzbORkrA0WAmo0WbGGKUnq8gTpCidOceEt4aY5jYfKLrbhJnZ89nkg/n4XEKEzNlKc5HSv4tR1lsx152JgUPw4OHX5696H5+ne/pMCvyNmdNnPe+ZaSjmuiDrzdz8JoBkTE1Spu6whFmQq5h3NkIGkoWxFMYJSgRXLKZkjFN4p5h6UU/g8ZistNkmWHINGWxECNUfMJXMs37L6DRiXVBGWDHgvMU5FdimGA/UGVBz2CSGnkIStd3yErm3XtCicE/MmSlHtkPPfhiZBmXxBePpfHOYpWz3Pfs40qfIdhj57jvv8+OPHzGOEdyC0FjW0jFNIzFrkmvjHdZbusWKtu3wIRx23oio/EHUcqqURC6aDJ1SQaJAzKRJyFOm6+rMNAWMtFhZYUSY+oL3gcYvSRPEwbPfCFYS4xgZY8L4SOg8Q9yBjyzWnmKqsWipjt+V4ZlSJDlDMhORxK4UfDSEbHX25jPr4MBWxp0YvDiKCKZEpqFntJEYHZsnlknOuX98i36352h9xEsPHiC5MI6R5XKNKbDb94zTjv1wARUe/e9++3d59OySP/Yrv8KtRYeNkbjfc3X+jMfnT9ns9jAZQmrIu0IaCqaYA/uy5KTGqqLnyWxKo2B//QyMnivFVuIBNaJFdHOmHpNWWXxGC5OSJmpHZRw3r9LrhALdugkJTKpSGgvSIDTk7NhtCu+985DTe6c8WNQOp565x8ctr76+5P7LS27fCzUlwtZCrrM8TXXwUEJ9CnUTebhmDc62xLjBdz1t45EUKeIITeH2/cDrbxzxyiuvcPv4hGUDrjHsponlvRYWlv13niBnBS81ajVnyi9CntSz83O2O8HaTGhhtVrQNC0ihrb1rI4adsMVkg2QsTbTLQJNE3Q3YjT/ZD8Unl3tq32NLqKFjDeai9N1oRoo5+v5lxOcq8N/C8ao31URy9VlT4x1V3JQsP1LdvwP+ZRudIXzmM5UqG7u/D4LcDRWSQVJHH1MDKk6nEvElIJxOjdMWdjt9pjsMGTWa0/TqAOJGvLq7jNLYT8MTDHqhW+sJq6KbjKCr8LsmoKrM7WZbShMSZ3InYUUB5bFsWqWpD5SSmIYeoZpZDPs2U9TzRGy2Lahz4V+rzqcfpwYSubs8oofvv0273z8CdF6los1IagBctNkUuoYxh5jCk2jJAnfNISm+VSSrVR7sNAEXTBzZrfbs2wKnTV0bUdwhhw83rc442m7Dhss3hjiOOKbhqZp6VIhizovbvYDSSDGRJZCd7RmigkXHItFVxNx9cP13iMmKSkhJyWEZN045VwQY9hstjgSgUhqQNYt1hcGL0RfyQTGsbRa6AyBfoLd5TlXaWLjHtO0LZuLC7bbHUdHx9pIOss0RbabLftxi9h4mJPlOLL54Q94+PFD7p8cc9w0uFzoLy4Z44TzgYA6VjACxVCSkLO+5iSZLNfiVrgxg63/lirNsLVjOtDZZqsoY3HWY2pBssbijFP384NE45poxKf+ZtCioYxjjK5TAkxj5sMPLji5M9G09zi5vUaczuTvPehYH7/E8a0Vy2WgiMa1iFH5zAw7GlHNZymaKCCieqZZB4qdMLbn/r0Vt06PuXia2W8nbt1e8pWvrvn6N+5x9+4dnDSYFLFthIVwzxYGMZxvCu+lLcSCZYHkpXafX+D4Uhepq80WZ8E6CMEh0nFyHBAHzhe6paHrMjkbvIOua7l1vGDRLbCuxbqOqXieXVzx9Hyn8JIRxBREEi4Yjo8XnNxaE8JEaCzGFopMKgK+kaNj6kB57IWrq4EUjYrcblAHfhGPOnvlxh/6p7X4xted6Y1L8UC2UEGkANm07GJhM+nGwsmEkYzFk4shxcxuN/Dw48dYhF/6pTdZLjsMSU1Qc8E4dcTf7gb6YSTjycaQCkBRpxJgnCYcM+UcvUix5GIYo2DEEryBYSRYB8lwcXZFnnS2NFQCxJAjNA4fAlf9OVdXO3Zb7bD6mHjvo4/5yYcfYULAth2tmfOYVATraiGa89FUIKlQaZrULkgtmDQ+Y97xUgSKEKdINoWUAm4VWK8WmOxJk0NoEedZHq2JJWKsp+/3OqO1DgktzZFTN/PQMOHYx5GxH/ChZXXcEmMihIajo5UGK5aC9bpJA4PzBmMdSRI2BIzJPHhwn3G/Ybe7UmjcOqIPFCamAMlBW1C6eMzc7lpOrGGKhcF49qslg834tqUfes4ffcL26pLQdaxPjjHO41YtoSls9peo3ZB2Ipe7nthPPP3oE3zM3F2uuX96ijctLjlMscQxIVPRIlVytXZSgW5GpQSUayh7NmmeUQV7IDnYA0ricNo5Ve3lQRNlVLLrnFctUd3JfVah0n+q27kGqeqXcepTmnPCRs/bP3yGNQ1vfesNjk8ajB1pVyO+S3RdAuOVgOEt5BHnM66eR5QqxXGGLBozoh2hQuql7Hj5lTV/9I+/zp27J3zw3jlnj7e8+uodvv7WCce3LC5ETFYhdZKRxBVhueX0/sDrX7M8e9qzfQqWY6xZExm/0BrypS5SpQgUp9hmsew2grOJ5cpjbKLp4PTOEpMdIXja1rNYtDjfkIpj2md2mz1PH1+yH1A3ZKvYmDEF5x2LZeDW6QLnPG3rMKKplwFX8TplMUlRYduzsy373URJNXOK53dgv3CHvNAfmetuynmvl9uLUSYVrlTY34FtmMrEPlkKDdYOFRY0ytiMhc1u4KOPn2CM8Oobr3GcDcEotFFIFHQArkUikqsZZ6ppvZ5CzJntZotZFVIRFVaiXyLaDWAKaYrIlOgNPD2/pDEWivq/RQpTyuxTZL+5JEthGCJX2x273cgnj5/y+PyCKQnNco1rWvr9BmuUJNE0DcYkclYNDtUmp0isrLSJUv0CndMibid3mCPmqscyxrJYtnTdAmMzuRhW3ZI//af/DLfuvETC0CxbihXGfiLF2TJMU3FTjAzDiPeeEALD0PPBuz/hu7/zWzQLTyHxycOH6pVnDVNUt3uYGVyOLIVp1Nwqazxvvvkacb/h4ccfcnlxwWbIhKOW4Ot1h4AUbNZCZaaMt4amWNa24zKPHC8W9FOkcQ2TEa42W8oUkZTwiw7jlHW2aJfsd1ulqpdChyHFyHG34Na64zi0lL2K+AuVjZtKtbrShTmLWvcUW3VD6Xq3ZQ+zpgr4yYwF6Mxp9gd1zuOduokb/GEG5WydTrk5m+Am1H5NWnj+wrH1fFQ4z5h0CJREGjYXmfd+vGPRDXz1G0uWx5HQZEweEeMpJSBFpRbCSLcwdF1z8OoDsDUZAmaLK9WDhU74+jde5qtfv8dqHegaz907a+7fO+b2PYu1exVbW4vJhlIiKU3ErH8uOke3cEzB1jmqrtFf5PhyF6mskJDkQMqG3aZgTMQHp7sEZzg6WuDw6ulllU0To5IitpuBZ0+3bK407n3WyxhrcUajCCARgsUHj/MoE03UaFR3sBZBT4B+nzh7ckUchVLU4gRU7Dsfn0U2gOcQsZ/ruNYfff5vf87e7NO3e2H+9Fn/nkkR8jm3e46y/0ILZQ7QGRr6Zw3FUudo5qYOssJ0lWpiPZnAlB1J5g6rwnXZMKXCMAnbPmGtYR+FiNJ6iy1kdIFICP2U1N7FGGVmiakBfYKkxK5XiMgZpyJXYw7DZBFLzBPTuEOmkakU3n30ELzFz8xOgc2+Zz/t2faXPD074+zikqurLRebHTHD8ekd/GJJNJbV6oimDZTY03UtbdPhXAQM0zTpuYom8npv6ceBXCIxVpIKULLUcEBHyYLzHu8dbdthrSb5RieYZcuv/rF/la//8q+o5j+A8Yaadw8zfCiANcQpYo3BN6r5+v53fpd3fv8dxmGkjCMffvghr732VYzjsIArsVNnHpKFYi3ZOjyR1199idPFq/yoE37ne1v2SQjNgjYlkp4EuKx2UY2zTDkiBZxtcBju+I5+P9FZhzhLXxKLZqkzy01P2g+INSR0NnTsG+wiYFLGTJFV6zmygUW2hGx0uTdCKkppN3Zm79Z4d1Og5tKZmQsudRIl87luawTNNTvPVnTA1awzZ0MtUtdECWfmQmY/de2KPL9OfP1PPGNxMurMTzIaFlg0tNB5JWWUigbYHfb4Au7coblb6JYjmIw1HUa66iSRMDby4K7lV5s9t77+jKm/JCWF/bAqp5jz3lLOdKvCH/m1BQ9eHrAuc+erDXEUusU5abdgvOxwNpBTVh2kMRBXpMHTX3mmfcLLMcEpTT+Xqc7tfvbxpS5S88DP2EApkLLQD5Gw1eJlvYrMvHcU1Msq95EYC/0+sdskdruJnC1WDMZ6ZhzZGEuRyDglSlmiOslST0ZthfXf4IwjJcN+G7m67FVzgKkxBTOJ4XlSAlyfiD+v4ey8OF2/Dz/9tjerlPAZZIh6vJhzZT8DM56zpG6+lpt/PofVy/NFWCn7dR9o0B7TGmXp1SA9gZpFVbCzc7LowidZIbdBLGI18mI/ZXYDDMkgtsW1gX4sbPrIaCE3HiseQXOghqnU8+WaESlFuzlrLQVhihOtb4k5MpvFxgxFMlOaiKKq+l2c+NEH7yFBZwz7/cBuGHn05Ixdv+Xq8inDMJKKYLxHrKddrynOUQwsF0tNop0GyJEYJxbdChEl9ITgSWl87vPoWqWcl1zq3ECV/87NhcZorpLVP4dppLHCFIVxKgxZSDHTrBaMMiI51+DQFxbKXKp5siHlgnee1fqY4BcMcSB0aqXTtq0WdTc7JSjLzaDz27ZtkbpgLwLcOWm5d9LSNTBZhymFReaQzmxyAbEkUxAP4nRDYaVgYmFJDQ0swsJ6JuuJRqOUxpIZU2TMmSQFkRFrDJ0LtLZl5QJtga4YggiuQDaFXMWzpRSKQdmjRjBWC7YGb87QvUUOLNS6bpiZPjGvDbNThMMZf/hSKZc9/K5uYD99PR5szur18+v/3nv8k994QCna8Uh11jHoZltnvAHJgZws52cDw/gRr39lyb2XWlbrpgZLOnU4QSgSCd5y+86K82cbzseIs65aXym8nKutkZRC8I5bJ2ucjwRfGOKepl3QHl2wvPsBT3/321o863UcR8/msuHpmeXJY3j2pGe36chTwriM96JuLl/g+FIXKbjuVkC5+9M4cXE+EqO2lz44BjthrSPFQr+bGPtInIBsITuCCzjnKglaFJM2hWmK5GwOTB3QXctMlgCjgXtmyX478fHHT9nvI1KUon7wMftFPUzdWVPrmugQ3RmDsRbrHJOo7mQW4+qvFfXymy9nyTiEHCfOL3Zcpit2wyX91LOfMsNk2e6ESTwUx/sfPebs4hnOWm4drbi1bjk6WjOKV98+sVDqYlNqAKGxCLlSyCdNyvUJZxoET0wKB6Y0kPKIQz36fvz+T/jk7AnGWLa7gVSMOkMYQ5kmHZp7D9aRgcYa2lYJCqYkco7cu3ObnCeuLjeE4AnhmGFQZw3rLCWpng+T6RqHDtB15mONZ87wCaHRePosDFETbC2Gk9snTP1IysK4H7C+oRhbc7GyDu8/i0lzg+UpCOujE46Ob9E/vaKUzOPHT7j/4Jk6xEeFhXS+ISCJ2csjpsTx0rPuLCs38eC05ZUHR0znI8YIXtCiUS+VYoRiIVv901plT4YsuIOGRzO9yBWubRuObEP0jmQL1rvDYu+s1flhzAQxNMbgxWiWFZVtVsk8Yqs7Qi0SRrQQUdS5Rl+bvjXzymPrBmJWNs2U9OsuKuCsw5sZClRmnx6fXh90I3e94YuT47v/zT3iVIiT5m8pWiQYG9U9x1QHdPFkttiw4d2XDW/98h2+8c0HHJ8sD8XQuowwMkXH/szy5EcLfv8HZ+wuHc4u9NwzOv8Ewzj2vPTagjdvf407D0ac39PvofXHSH/B0ZvfUwdCG8Bapjzx9MmeH7/d85P3Io8fT2yvevpd5HjhcUGQMmF+EXRSBad7GlMQUyioM0CeCmUj7PustPR6Fko2SBIVRqM2JM7Og8NS7Tpmi/lcQ+jUK00OOyZlkEHRqALXMewLT59c8uzsijgJ3hmsUxfnUmnOv4i1at5PzsWnApOV2WexzuoMBSjVs8xV+j9SMDmq/QoZk0a2FzvevhjY7y/YDVeMadKAvhxIyetnuh+4ujrH+YS4hvVyyZ2jjju3b9GsTtjuI4ag2qyiq01EdSmI+rKlUihGffwIqrmJORFTwpKwKYEUFo3TXX9KyrhrGoUJRaMcxDn165NCFurcRaGUzi9wwDSMdMFjOs/V5YZ+2BO8+kuWoi79pVp5FdEiOsNMatOkXY7Oghze+2oQmhmnEWcdq9WazVQoYtn3E8Z5UpHa4c2c6ufngsbMXcEhGYnVYsXR+haPn3xETpHHjx/z8OFDgvf0Zrq+hEQwJVVPTMgp04TAooHWTbx8d8kbr93m0fCILBHdWxiyBWN1HpONkK9PHWrFOMQ7zA4mvp5nJmYlUM1zyFyH/jN6UHIlOtRO3tXzs6icQ5v2Utv4uUChBbzUuJ8ZDaFSyo2uH866mqp9De2bGeoz/sDk0/ejunBou/k53cQNe7EDg1B1UpgANJUurjlWKrLNzJEh1oAUz7PHE+/YDUfru3RtQ7dM5LxHELwPQKHpEvdfWvPsac+w35PjhLE6i7LO1BRdJRIN/QRiSCnjbMDWTSizj58Epmh4dr7hx7//lN//0Z5PHjm228I09DgzzychFXVw+SLHl7pIab5BddWtamg9BR0xGYZR2TkEQCweS7CB4BwOp15bIlDmLBzdnRpz8B/X3VjdPR0+DGPq7iUwDomzp3s+efiUacwY46tZY8WxfxGr041jdqcGDhCGmTsp71XFL2ryw41FwFAI1uERytCz258zjpeMw5aIEgiwBaxHqt7EVIcJEKYhEXFc7TY8O7vg40+esTg6IYc1+GW9fcIBqdQOD12siujc0Rg1LhZJFFHfNi+ggImwWizpFkqq8V3H1W5gGDMxwzhGhQhtIqcJDDRNSxsCt0+OaK3l6uyM49UaWxKPzp6x221Zr48ZxkGTZEVdpQ+sL9E5lZIZHN6r7gYUsiwlM03aQQ3TqESLSaFD6zxXmx2PH59RjFLMqd2rrXDXZx/VXUEKTdOwWh3hfEDMxGa70yLVeAxzlpZ+3sGqm3dwgeQSi+DpPLi8Z90WTo4CzidSdkRrmIJh8hq4pzpYvXasGHxBN3wKfNSiqpC7sdoVlVK0qDh9PaoZs4iz1cJINXIyJ8YazdGlFmKZWb31cU31qLPFYoqDIlhTdMkBrLF479XQ1is5whijmrv6PmiI4fyfFi1EN8XXS8NnT6MNN+e71CKk8LMSKGY9Z6xzwAI2I8ViXUEIWFlx9ijx8U8m7t4VlmvV2uWUqktIZrGEV147JY0tcXzKk0+2iBhiKkpMqhEnIoZpSFjTEfNsrD3DlxYjVbO1TXz84Z53f3zG2VNLigtU3jzgfVIH/mKqxZj71Ov+rONLXaRmi1c9dMCgGxmjsyp06EwRPYlwSIVjxAiOAlKtMI0ujOop4au4bgJJ17sj9EPBGIoRxjGxuxp58njD5fkWUxrAHjKo6jYDPmMB+LnSbA+vV2bi2+ff4jADe/5RP/VIN5/e593b54mMP+d2nyX8Pdj4SnWJnzO2qtFkTjqQLkaudUmiabtSIiVGxs05brjCx55pihTvEKv+iyJqKNxUL8Z2saRbeOI0kIaJGCf6LExpYpe2hLXDLRssXj0D5VqcWazCMGJVEKxzHVCr6ExBvfmCBe8aFqGlsQHjPaFpSFdXxBRpmiXeLdhJweOw0ZBRptqybWl9oIwDkhK3T0949Y03eHJ1Sd/3hKBx8cPYI6hI9/pzNbjQaPdvHVLnZcE7jFcHg1RtvnLJ4FQHlrLag52fX/Do8ScapdI0+lpFdFYoHOA9fbz5LJr734K1nq5paUNLQs2ct9ud+i+arFuLujsW9LFlPi9E865KGigpkqcISTDOKlXeCckJzmaM6OLuiqtLoG5cioE842yiJ68UFd4eEBGkZnXV9NK5qjCbFwscjGFnIW5tmz7jDJf62AK6sarzJmetzpqsfoUDgcGq6BcwxaiGspjaYupr0c2a+dwQghnue/6aU8NevXCzdk+Aelj461ubjHWe/b7HNI5hP/Dxx085vW9olitObivzcqbYWiscHbe8/uaScVDbok8eXhCjGjeLGKz19LuBq8ueFJfkokS0+dzQ5+bJRSOSnjzac3a2J05LIBPjllx2ZIEUFcUIttNO+QscX+4iZS1SC48TrcpWZrhAb+OMA0mYrM7Yppo4Qh2UZ41XMOqdQ4oR71Y4Or0/dpQc8Vbp5N6siUUH52OfefLkgvOzHpLDmwYRi7EVmpH8qZPt847Pi72YE2yV56aU65sEB2tnbzQd8s7iTm3Ra/Bc7f5mP9a5flqp1w4vgj2f8V5/znO7eTxn918XFKnWR00xIFlhVMkU25AEiqjHm1rrqIWVLQYvE770jPtz0v6SKWU14wwdQUYyhilZirEa2yGDwitNQ/bHJAML85Q4bMiuJduGfZ/oZMdSBN8tMMayL5CMwxRI2SEhqJ1V6okxsWo9nXPsjMLGkanSh1tKDpQSwDhcY2Fp8d5hJUPKNAvtcJx3pCR0beDerVs0zvFs12N84GKzwz5+xHZ7yWq9IOWJcRwwVs2QU0q6Q6++gKU4xlxwRbWBzlmMbzSAs6hbxryYh7bFW8OujzTNgik+4ezsE8Z+xyI4vG0YIoi3B+LI7Cw+z2gU3tYjpUicxupPF2ibtc7qykQyE65dkDIUPIMB23akSXAYJCad/TmLdx1xNHTmiFIswewUuLdJ29koBLPQxU9ArJDsHBNRu5M67FSCQz3fqQu/GA5gSKnzHaA1SgQxYg71uBKtFYJGiRwKrkiVnEXtJI1BbIBa2mzd0Dg8Xjy2BC2m4jB1Y6s6KTVjtVhKUputWRd1DYK/eK3V/vXGRtawxEgLpsf6Lcb3KK2yA+n0vUHNYMsUar7XQLsYudw85f33L1kdv4rzdwiNwZiI90ogMr5wcgde/2oDZkVMA8+eWnabhDUBTGYY9myvEuNugQlrbGMxTp99KpYpWzCJPu15dtkTi24m1BJM8HiC8VizoBRPEs2U+yLHl7pIcYD4KrY8t85GOyMd+9UuSGY0UKt/qgt401i8sxhn6cuITKI6AiuQtdW1tsY/F1EjWQLjMHF2tuXp00vG3hL8Qmdeh5PvD+kl3uxOzOF/n3m8WDQO6OeN78zP7kb/+Tm93mc/j5+HhTjTRubdp8w7L3NNn5bq+OBsIZWMKTXqOyXG/ZZhtyHFAYohWzub11PEYlwgNA3eWVxJGNFOwzZLTAJbGqzzFKOdlxFNxx33vboUtAucWHLKagRsjA5zRcHHVdeyCF7nVUV3jKlANEIwBUzWjB4E51us1XA6IpgCTQi1mHskB1ZLZYnGGLHeVcf1BVNMdZ40G41WDSByyJ2KMekGyykLs20tIeguFzSIT02Sk4ZBIof8n/2u56uvv87bP/4xZ2dPDo/hrSW4BlfNRCXrZkeKQmYlq+sCqGO9d4HVesnlxSXrWwtKhv1+0M/YupoFpnBpKgmbVQjtsGw2Gy43PbfurTAeVscnNM2OlMEXj+RSO1vVENlr5LBu+kVhrkPHdz2zmZOJZmRZ69f1vOP6XL95/s/nX9YiVebz+/rnGFFkbfYV03ZKPwer9kbOKmx1TUVXz74DyHeIg//sa+xngBmHQ50frO56bHW+sQ7rHDkajfews7ZJrdywE9aP+CYR857dbsM4rvGhq0iPzrFKHjEucPteQwh3sTbw7ttPePzJFTFOTNNAKQOPnzxks7nNnQcNxqjzvM6YHeBJeSLGpN6ladabUcHOOXnYXX9QX3Cl/JIXKfVQm0+ow0KKtujX3mvXMAaAMYp9ey+c3OroOo9xwnYULpko00ARCCHRtA7rvN6/DTjfME3CxcWGhx9fsNsmnCwoxVSs+PpxuPFs/mCv0/zUE/36ka53Xwea+h/iSOxwv+Vn9V0vPCeuodI5Z8caJfNSEh5DZ2AqEV9VTTn2DPsdaZyggK8XoUKyTp0nwoJmuaIJFpsi0zhRROPdlajgqks1mFKwGg/KmCIpQSOBRati0lIm9V0jYkvBEbG5YMUqJJlFU1Ftq6SENLEMnuXSQZOwMmJFaG0LeMQK2aUD8cAEw2q5VJf1mBiniZIL4zQiVudJqmuyhBAQiQeHfpg3B3LoImbHE2PMIU9pHKcDsaJtGgpC13Xqat51vPHGGzw7f8Y0DcjeQdOCsUxTwlWGWsmgLMyZcF0tfNCB93K94tnlOe3aE2NkM+wIXaPdfV00S4GSeoQJaxc4Cex3hQ8fXvHGK19hO12xGUamMrLq1piNIU2FUsyB0j1fw9r5zHvL+t2fY6P0s8/P+X7nb5gKhc9yCb2m1QVQC5SzTgk97qbN0dxxXl8bGt9zY670B36mVZ+pgCMGT8l6bjQ+ICYiZLIMhLawXMOde6e8/NrrnN5pOb3TsV53hMaqm4hE/Z3qo9l0hpPbgW+EU45veR590nF5seHqqpCSpbBjPzzjnruNqwkT83zOWkdOUk1qzeFLdxjuMOu/HjEchnI/8/hSFyk1KZ3PMXWrvpYF1VG8XM9F9JcUHvC1SB0dd6xWAeMyYRQMjs15JA4jTTCEpsM7j3U655piYXM18vjRnquLiKfDmlZjOYy5gW3/wS+ka4bP4RufW6TmyPnD786/+Ae8oG8WvZubgC9yaMbOfOvaqRidI6qzR4aScGJoslLNTZ4oKTHtt8RhoKRygCmlTGQK1jWIDfh2RdutCd4QWiHFC1IBVwXZxQaKcZB1wGwF7aaiMI0DMcFitSS0DlxGnK1dU6ExmdYaFl5NNm0BnW/oLlKkZ7kU7t/rmMjsY8QJeNdSrFIrstR8KWOqlsipMHLR0S06hn4gbifwhtA0tG2rbMAyu0aYg/WW99X5POjCF5qGOdsqxlxvz+H26uaRaIKnlMz55QWvvPYqH3/8Mdvtlpdu3caEViGtpJDcvL46pwLgOWutkElFIe/b927jg2e72zGlGc5W+nsRozHhknFOqlFsRtNiOz54eEX2J+x2PWeXW6Y4ctwdaXzGUCqLjllX/Py5jHbmcwH5Z5npfur8ZF5kb5zbctgKcNjqGr1NqfpHWz0ZjTFanKy7jimxlpmWqBq2n++a+fyjVEr4dW8yz6msZrwzjjvEDPg2c//BCa+8dspLrxxz937HYgW+KbhKLLJWZTa++o8ilpwiWSZsEF5+veH2vTtsrpbsdsdI8ez7K5ZrSy57hfGNP1zTKo1WAXzXLfFuy5SUgarjuGsXjuuC+wvQSanWoA59iw42rymbdQ9vqGe87qLnBruIGmH6kGlaCzZxq1uwaDtat+fs7BLnDT4s8F7TM2O27LY7Hj7ccPZkT5o81nqmVC10fhYT4Z/lNZrn1ezPJQm+eDx3ZZsvrEP4uZ5LZTD9zNsCUh3PwdeVRplVBnX0sAg2R7XTyUrvTtNAv9sxbnsogrMtwYKzukMsUsA6jG/xzQIflhhTKHlimDKOiVVXsF69FHEaDeDrW+FswDQWiYnYj5iU6BYW04ku2gXISSnopsUsu4Pdj2AoSTU3XWs5vRV4cK9jO4yki4kgBm88Mbs649EZ4rwYGqN5Vc45YkqkkjUHqnY8Xad5SU0IB1jKuVzD/dRdwPraSVU22SwYd87VDsyoMWqOhMYxjSOrruXRk09Ip7dZrlb8N//tf8NXv/FLHJ3cVqFutkzDyHa7BWC9XmuKdZ1Lee/U8gbDk6dP6FZLjBeMeMo0ME4atFdEBcZFMt4JtggxTiCO4Ff8/nuPeXJZSKnB+gXr5RKTMnGfyQOYopAsMwrA87D0/M3nImH+QIVq/v1Si4kyAbVz0w7AHqBFi7PzoluvxapVM1Zp79qEFcTUlaYu4H8Yx5xgdY0G6WOaWkSFiHETJ7caHry65o0373P/wTGrI4dvI9alAxztvacUg0jSTXzRKJ2S1Tzbh0jOW0IHt4JjuV6pY4VdE9qIsZOmPotndpeZ3TO6tmV9tKgEoGvGtLIa5/W3GmP+8yhSf+tv/S3+1t/6W7z33nsAfPvb3+av//W/zl/4C38BgGEY+Gt/7a/xd/7O32EcR/78n//z/Kf/6X/KgwcPDvfx/vvv8x/9R/8Rf+/v/T3W6zX/4X/4H/I3/+bfxPufv16aMg8gq2ywKrIxBlvZJ7no4LNIriQCNWQUSYSlI4tGfjceQtseFohp2mCtYbFoyNmQsydH4emTK87OtkyDxdIieU7UrJkxlehgrEXqbljqoPZnXVDPz5+u8XNFOuqsDW0rbkIes2BYBYWHK1nfB3td5PR+ufHva/y9yAtQ4Q3G3heZR82OCC9aJDlrIVeorw6goS6q1mJy3bGXTJx6xnHDsN9SIni7ZL2+pd1A2qibwKj5XKFpcU1HLnqBDIN623kRpOiMaRADNiAyEqzu0pumw7sOYkJ2l5AGZBJiyRQzqghTClEmJibScoENKw0/zBZjBGeha2HVCYuQGYeETBONbShFRcopRkpWrZULgaZpqnWRPbxXzjlc8BhnODo6AswB4jPGEEJ1xkAdxueW2jldPHPOdWb1vK7GWjWmbVpNPY4pEktmfPwQaxxP/tv/ivAP/yFNs8AYz8J19Ls9H3/8MdZa7t27RymFzWbDZrPh9PSUpmkQKVxcPGPf7zi5dUTKSunOKddVWUXujfVgHDFp3InkSDaWR2dX/O6PPsC7gbGHzjQsTUs/OUgqCSlZDmOL+ezWjsWC1bDIm+fliwSeF91YftYxXwEqM6mWUDJfz6qFOhQDKlFjdo0oOvwXUBlFzkoExR4QlcM1xRffvs6vxzr7wrVXbnzWej7bmlmX8p7V2vDq67f46lt3OT5pWB5BuyiajGvqOYQyEBFPHAtiGgwtcTLVmzIR00guqcLJCvM6r3NQ6wUhknPC23DzWauUwQtNY26Y30acbZnFydboe3OdfPCzj5+rMrz22mv8x//xf8xbb72FiPC3//bf5i/9pb/Eb/3Wb/Htb3+bv/pX/yq/8Ru/wd/9u3+Xk5MT/spf+Sv85b/8l/kH/+AfAKqa/4t/8S/y0ksv8Q//4T/k4cOH/Af/wX9ACIG/8Tf+xs/zVOr9iZIejFFFeKWKO6cD1pILRTLGc9AsIFS9Qqr46ewwrXTf4C3Hx4FpXEKBpvFY0zCNlqePL3jy5IJ+bxCp7KMDNCA3vq5Pfj2peG7R/8zjhc7H3LztZ32W84/m6eR8H/OFC9ej47k+mZvF6fmC+Hmw4IvWRz+XfdPhhdQLtn7DWkcpiTT1jMOWfpyQJMS4J5UdJY9YuyA0C5rmiKbx5FCI4w6J6pw8RwzMg+4csw6iSqGkCUpDEocNCxi2mBLxrqVddES/YhojMmwpKRHHSIoFvOiFLIkUe5LV+7LtGuvVZNYZQxdg1RhaF7FpwKSEyUbdKYyrQm5DgycmOeD23nu89+pY4pRokEVorKNt20qOqJONoqamc8FS8S41KVhIJYOYalBq6211wTJGWX4TSenpVTiNqJtDihNjTGD2GOM5XZ8wjhP92GONoR/2pJS4vLrg6dkZQtFZWo5stxsVeZqqLyuQiw6NjC2oHRIoPT5hmHVmFmzgO7/3Nt/+5pvsLiNrt8TsM2Uw2BK0MP3/2PuvWFu2NK8X/A0XEdMts705NvNUuqpMCgpTeaGlvnQBom+jphu16BdAVzwhxAsvCIkHjBASL4gHxBNC6m6hlqCF1EJIhZHgGlVhO6uKrKqsNCfz2G3WXm66iBiuH74RMefa5px9sjIr69yscTTPWntNEzEjxhif+3//vx56mWBcS4UyiRetnb2x72i93CTNY5Q2rFx5v9R8JEIwe6s8F2CE2VsTYgSknTLvlRx23+E3P67uK+KzZlLyKO2ZHyjuv3aNL/7UPQ6vOWyVcZVICmWkdh9DImcr9HAxEWNFiNC1mr7VxeELKKuJKeGcw+oJJGnXUCqjtVCMpSjcm0P6Tu5xR84tVZNoJrDZ9GitRbV62DdGZ/3lr8snMlJ/4k/8iSv//tt/+2/zD//hP+QXf/EXeeWVV/hH/+gf8U/+yT/hD//hPwzAP/7H/5gvfvGL/OIv/iI/+7M/y7/6V/+KX/3VX+Xf/Jt/w+3bt/npn/5p/tbf+lv8lb/yV/jrf/2vU1XVJzkdqiozqx1GSfomBVnciSAZTy1UpKn0eJBEtsFZJfnzkCFL0S/nMPZLaQPzRUX0kp/vO1gu1zx8tGS7iaAadtMwS/GFoXCyf4a/uZz5p39Il/4V862UIO5SJPiMip7QbghtJMaWbDtJrFlN1UzBTEA7jPXgJd2pVJJ04WBbUyaHCDGSfU/0W5QXlnNXTYXNInRYO0FZR9QVyRnMpEGnJUSRZyCCMorKWJSqGLR7tNVoa4g+Y3NgURvuXJtzbVFRayXQeCxGVQStwEa0ljRajLK9GWMKw/luw9VaY53om1WVI4Qdu3nfe0IIhCDoulyQenHg5iuME2ZgtRhBFoOEjFRWrJGm35zBB0/0vaR3si4GxdBPpiJFoRJJS08XkqEhqUTWGe2KJI1VJVlT7mPfkyhK1gO4QUFIVrIXGVFjJhJS5sMHj/nSW29x5+g+ernkyZOH+E3CUoEGbUVWXJWZIw3NUbImLzA8z3BIfoIZOuYqSrSUR1aZHX3RkCXZV87dpfJ2Dl9SYrB+uKteDd5ekXHPKOO5cWvO65854toNg6kixiqc0xgLFAqm4BVky2btOT9bs9n2XK62rC4NKTQiT88a7ZZM54qqmjKpLfPJTRaHBkVHCpk0MPUgwBGJjHpiatG25+i64/h6w9nZBVU9pY1pd5XKRrCfyfm48X3XpGKM/NN/+k9Zr9d89atf5b/8l/+C956f+7mfG1/zhS98gddee41f+IVf4Gd/9mf5hV/4Bb785S9fSf/9sT/2x/gLf+Ev8PWvf53f/bt/93OP1XUdXbfTHrm8vARgcWA4njdYbVAx4duObduyaVtiDFRNhbKOTdcTY8BkR4y5UHo4tMpyCbKGrKUXqtDyTCeO6ERU+2zpefxoyWYjRWA14AavRCXlofb/vsMX/viOfas9XCMJrqxRTOuKzWbDQL49SNxrbdCuIamaUNJAfaG60QqMlr4vES1MEII0cEZP7jty5cE0GCcINpWF8iYB0VowDhMn4DW0GZKj74SyqJpaGtdglB+bjpNVBCJTC9cPau7dmnJtlsgRdDTobNG6JsdAUC1J92TP2LbgrGVSN1L8V0p0fIJEQMIgUZHSZoychihqgKAXZDw5SFRjrSOnXIyYHiMIIaZ16BLVhOjpfcCHHh+CpIiyQ2uLMXIdQ+zpk6dPHo0m5NKbpYQeKulMEZgV6QoJJgppqcYMMGutpTFYK3K0JDJWeSCIIlOMxNjwjV/9Fr/71dfpTnvSMkGvcbomZ9GkGpvncyzlC8mA7KHKnxlPG6qXddQHgMSQQpOE+p6BwiAq3Pu1lKfmM4M7Nvz8YZmppzf2jLHQzCyvvHad+68eot0KpS1aO/bLYapwPC4vez54/5QP3j/hydkZq/WW7bpGpQW+T2jb0cy23H3liO1mSeiW3LwOd+5NuXbTsDicYm2R4vCJCkXOsbCai0L60XHDjVsz3n3nlHbborQrtcahNDFA81/uW39iI/Urv/IrfPWrX6VtW+bzOf/8n/9zvvSlL/G1r32Nqqo4Ojq68vrbt2/z4MEDAB48eHDFQA3PD8+9aPydv/N3+Bt/42888/fpVDGba5wxOOWIXtN2mnotBJvCpzYhnSU2ay+biEYWlqmoKoVWAuMcaE1EpwVcZfBdZLm85PTUs1p5UjQobeUyl+gpDxHU0+wXMIQOvPSK+d/cePZ755wJPohkABprFTl4ChGFPDQoY9DGgXIkBW0b6YPkuZUqpJ6qpD2SAIQNUtsieVQOhU/MiqevFSF6UujJFShrsHVNqiuit6QoPVSBSNcmMIFJDb3vMaXhO6mMUQmrIk6XY0WLVQKsUcoSc0+fOiAUMtEBDVYiKK1ESsM5jPfEFKWGZMwYOYmCq0RJgwKv1rqopopBijEyKMAYI+kpeb3DmIL4Spm+7+hjT0phTGklwayNKeWsESOSPQYLBmISob9U6IISsTAppLE+KhL24qXLPZF7l5VGQAcJbSLKSETkk8cHT9cGNudb2pM1fumxqkD2U0BbRcxCGiuNuEnqRU9t/LvtWo1JDNQuitm94wVrbw+ZsQ9OGiKq0UBRkHslnyeZzTSmI6+iEIW0+OXG/r7w9M+Pes/ukXIkhMDBwZzjaxOqJpJVj7GmoJHzLgKPiW6TeOd7D3j04AKtaipXE8IlXZsJnSFGxdFxzWuv3ubGrQXf+fY7fPjBGU8eah4+1Lz6xoLXP3OLo2sVxso55NLPJwzoEWMTk6nhzt1jrt+8YHW5Yugt232HT5by+8RG6vOf/zxf+9rXuLi44J/9s3/Gn/tzf45//+///Sf9mE80/upf/av85b/8l8d/X15e8uqrr1JVGes8ziWc1tSNoplVTKbQtg3GOLCWttvSr33xIB2EjNbQ1BVKq3FaJXqsNaAd7TZxerrl5KRls8qEsJeHHvKwDGJtA4pLjSqzRR7nmVrPCxFJewVgVTbfgVV6FFT7OETTM5/x8gia/c9+EfvF+DvSsJn2jrX3QcOpkJWFQdZACdpLRJcioU3EKSid8bnDk8hGpBL6pKi0IypQSoASqRf1UWMM2UxIykkRXQG5Q4UtRvWobNDRolPE5AApkm1FiJUwZq8vUNlSNTNQlr66QagM+DVGeUxOJB9p+0jGUPWRJkoaudKKRGDdZrathWlN1VTYVhNzR0YTY19oliT0yUqY9UOM+BDKfEGi/8zYbxN9IvRB+Oes8MGlAisXslIlxltLdB5jKj1VlaTHVMZajXMltRMCfd/Rti0hhBGWrpUWQ2YlI6C09P3kmNGILMOQQlRZkJwKJZIiSYhyhZhXmFWU1aRQoj3UuO/YskwUCmWcNDcbS/KBdrnhnfX7zDYJlRzkXtJpYySjymavhXuTNEqr6CGBnHJhPJKwTqudgyNP5307VJbs1Tk91KhVQZ5pZVFZoNSqEMgKzLr0SukkmX1UYVISEjWVB401iepVjuShBDCchRqWR9mwsy7GbmCh2F9Ce2stDyhlWUMZcd600aBbmnnixp2ao+sVKI+xxXHIQ0oyk7PBtzWXZ/D+2wkfDZ//0jVedTMePV7w6MGazRrquuHmrUPuv3YToy0ffnBJjD2nF1tOL9ecXD7m8dklP/G5+9y+c8jioC6xZbk3ykh0bjNHxxNu3T7iwfutIAdDLuT9GQrRwotooZ4en9hIVVXFW2+9BcDP/MzP8J/+03/i7//9v8+f/tN/mr7vOT8/vxJNPXz4kDt37gBw584d/uN//I9XPu/hw4fjcy8adV1T1/UzfxdG45JLFwy65OtrkYM2qiJq4VpTWXj9DE7qTzpS1bbceJmwSQWy0rR95uzMc/KkZ71WxGB21ZWRWsmUKEpg8DkNUstQpitXGllfpujLvkmRfw2GRtbYyxmdAU30SRONTyPznnuOOV957L/2aX8wUWCySrYbRUKnTOwz3Tpgpwp3UDE/nvIknAnuQRmC0lS2IpKwqhPQeoqYII3V2s2hmpCUEdh62BLDFqMEDFPYVmmsImdDqqeCMsoe/JrGW2yl2VKR9QLdKFS7QXmPIg40a4QEfVS4pEg+oKN06G98ZNX29KmW+aMDWbUCrDBgCwQ95iz0UDnR+Z5tu5X56QX1RjEIlTLiOBWdIDPcvwIv11phrBb4fSEu1qWp1DmZi0MtixzZbrdsty0xCiOA1lVBBErKJydNDIqQE7Uuc79oRqWUhCE+Ci2T77yQ3caBF1OTNWgrkZ/SatQBgz21pBzIWchWNVK3yEmi327b0ZuKOpaUZzE6ek+Xadj4lC5rO0fGloYMQ4evZNZ381CV7IUwLxQjNkZKO0b3HYzcoHFikLRDDfI/uRgpLRG/mBLRMRvYKRQlesypGNmMIgopsEpl7g9E0/uADD3uJ2qP2X380KfWm3yFPISLSC0IEp5mpjg41rhGzjAlW5hLBvJWYeyPXnN+Ak8eOQ6Opxxdq5gdGY5vHHL7zpq27ambhtl8gnWWdgPWNWjTiIxOrrlc9nz7OyfEDD563qhvUQ02WCuMqcjJE5Ga2OJgwmxeEUKmC0l4GhnIt0Wx4mXGbxrEn1Ki6zp+5md+Bucc//bf/tvxuW984xu88847fPWrXwXgq1/9Kr/yK7/Co0ePxtf863/9rzk4OOBLX/rSJz528BofCqmjqJVJTr6qBJWnVVmYtvRvCALFVoHJTDGZKowtJLPaoJSj7+H8bM3jR2dcXmzxfRxhwCB1guelH36cxn5z7wuRVAqGKmne/2Np/As+020iBMe1xU0W0wOslsbbyjic0Rgj6CS0J6qepDxJZzCiz5SUoQ+J9Va4/GI2xRTaIpcdiVH6kVJZHCn1+LAhxi05dxibaCaOelqjayPwZ733IJODL43GsvF2wbPetqy3PT4mjLOkHPC+xWpFjoHow2jEc5baUdu2dF0nkuZGZDWE4qgWJFX5946zcc9lGVjRS41KUnu69Ekl2rbj9PSUBw8fcHLyhM1mC0BTN8xmcyaTKVUlzBAxCoXSAMoYztFaOzqDOWfW6/Vo/CaTSUEnCgBEUIVXI+zdkHUifVN5LCmJXK8gD33wu3WVhziqsDdgsNphjcOZSh62EqVbNfQpwaiUmxFhwlIykusnEVgeItrSJTwIEQ77gtGiweVsjTVOnARtxlSr1ro81Ecs+bz3+IRjSMyUes3LoGdjioSSwp1Oa46PD8hESfPpvahbJTI9MbfEvGW5OmOzXkoNngprKubzCXfv3eS1N+5x6/Yxs1lNXRusVdS1o6ptaQDWkA2r5YrHJ8I1GUJLzD2oJDVi4zDGCcE2mfm85uBwSsZL1D3e6zHh8lLjE0VSf/Wv/lX++B//47z22mssl0v+yT/5J/y7f/fv+Pmf/3kODw/583/+z/OX//Jf5tq1axwcHPCX/tJf4qtf/So/+7M/C8Af/aN/lC996Uv8mT/zZ/i7f/fv8uDBA/7aX/tr/MW/+BefGyl93NhuM85AZS3aFa9d29LdL4hkYxxGT9Bqg3BaBZqp4+jalMlMuK6EQdmQomG12vLk8YrVskOpWiTIr8ybYSL9+BqqpyOu56UH9y/PQG8j01R4vlIwdFvQq0yzOOD2dUV1+YTT1QUYjVEJCKB7UvJE1RJ0Kxx5zoyAhpASbd9RKyXcccqSjciLS61G9sakpZagdKb3G1JrcHNdpAs8zbQieEPyJWWbwWpQJFTomRiFcppIoOs6Hp92uNgxqWt8bnhyseaydyg3JaQkMtpDv025XlprqqoixohzrnDt9dR1PfYJirFwo6JtHwIxSu3BFyMJYJ0tkQ8F2ZfLMSzT6Wzsy3JOSFGl3uXpOi81WCsAi6ZpRq97eH3Omb7v2W63TAuVk3AM+rFf67n3/OokKWAKMT9ZFYmKRMk6pDH78PTcGgiU98EQI3AhDpu5pHr1FdBfyYsXh4Qx8yBGcKDogaHupDF6UDwYWMZLP48eohH9fdifwers15D2znEAXY0oxr1nX5DOH3unRCxKZGMcLA5mzBdTUuoYtnNJESdQwlKRVRCnLm+IqadtLetl4ODYoY2AL3TWJfosbTs6MplZmolBKdGRyhEmkwlvvPYK9+7fpKozGl+MjlzLjCZFL2uqsRxfm/DuO49RyolBLtfnkzRhfyIj9ejRI/7sn/2zfPjhhxweHvKVr3yFn//5n+eP/JE/AsDf+3t/D601f+pP/akrzbzDMMbwL/7Fv+Av/IW/wFe/+lVmsxl/7s/9Of7m3/ybn+Q0xrFcRsieqqqw1o2FTynsitZMRpfuatCm3NjDmtkio20viCJtiTHTbSPnp1tWy040T0prrFLDghk++/vwmP43Mp6uXX3ka/cvU3lpzooQAetIPbSX4Ixh2iywR1okLzTgJN9tVCDrCCaiq4yrVfH0AJ0xVgzPuDHpjLbSfKiVEki5M0SvhQlfD3n6Ho0X791E7HyC4gBCLamqmGjqmlkzwVqDs4ZpDaqakUONDhuWK89q2dPGNW0vbQ3ddkVVTzDG0HWBIek6RB5DxNQ0zVgv2rs8I3cfSohoB+DEwIaf84B27UcDBDCbzZhN50VGXvSUUkr0vfD5eR9K1KVGIzhEbqb0GrrSdBxjZLVa4b1nsVgUQ6YlFWiM1CNTGnu5nr3xYkiGqoxG0kEDjFt63IpHnYSDJOcCMGGQaS/RkRoMl0LhGGTec2kPGEvEe4Yqo6QmVCItrUSmRxfdMV0kNgQUsZcZKOdxpdCf98ERL7vuX2Sg9tZCcXRVaRW4UvN9nqF6KrWuTaaqNUdHc6rKlHlNOe9y5XMeDVbKHTG1oCLLyzXnp1vuvjoFFYpWTbnGWtH7gNKR2dwxnVmMTSQvRn0xm/Paa69y7XiCyuvRQdDKkNVQVdTE1DKZTLl1+5DDw5rTPoxfW2Xke6eXu56fyEj9o3/0jz7y+aZp+Af/4B/wD/7BP3jha15//XX+5b/8l5/ksC8cm01CK89sGmkmTshFhwVactojEoqENtBMNLOFxlShqGIaoCb4xPJyy2bdk6I0X/rQQxZPS7q/MyEM9Eplwy4InxG99dTYn2ovtbGPz3/yKC2/4PcxqhkaInPe+3h15dUvjIyee44vrl2Nh85FJ2rwahUYW6G1k1TxsofUcnhsmS0OaJoGrxJ9hs4jjAYpM20qvGuoK43VApAAg9GBqsrUKQvKT4shqyopNFttqecLVGMwqcMocJUTPaVqinK18PxFj5/NhEuQRI4Bayx11aCMIysjKUWXCUFjOouLkZSEp26+qDDZ0p5viH0A5SArYtoxSMQYr6D1huhpACUMqb99CLpCoh7rHC5XgtIDYkxUVT0anMrVQvIZB6mJSAi+GBO5FyP6Tw8RFqMUyP5jMG7OORaLBZPJ5Jl7PsDjn+/1Q8iS7tO5QB9yErYBCmSdIU03xDnCIq4Lzc/YxMzAci4baMoSzY6Eu6Xms5utI/d+KcxLLU5IcisxUErozHTp8WGUzxAnahcJ7ebwsM6vrJXdBbm6PoAdBdszr96r5Q5/36WFXxhJ7R1KmmoTdW2YLxqJhKwa2e0z0mQtDPlOrmACY+X51arlycma7eaAeu6LgVEjYEOpiDaZZmKZzhzWQd9nSBpnayo3wZoa6IrKsEZlkUwiU64xuInixs0p12/MuDw9L6TSGpVFJflpIMuLxqebu0+LDPam7VkE6Z6ORVdlqH4H78lZPIOqdkxnFdZpFAFjyo0UGBlKK6azCc7VBJ/xfSYG6PtQUEOZmHq0rhma+VJMpQBuxwmWFQy9HuzBYl/WQA3Ah+GdAzx2WLQvHPtghvJv1CBJkMfFNDBS7Iq3ajzPlzGkz4uknve+Ma2TVfGadlpAOYkj4FRNv+pYq4CiYrKo0FbQmrOqFuOQAwcTS0irMfJNSppJlWu40dzChi059mTlMJMD7FRIMTWKysyoVcQScUYVBKchm4qsLVlrgve0eo3vtuQobNI5Zfwmlp1UIogWST8aH/Feal2p0fgUyE4znU5Znrc0TY1zitRLzXZouK2qSlJ33o89UFppnJOl2DQN23Y7XlNj7Y50NkX63mNtRdNI1CN0RUrOJe0YK4S/LxRDYkoE54oBSyPiT2mRA1dKjX+r65qUEpPJBOdciQqlT3FbWk8GeifhFUxXGdvJsi5K8eEKk3tBwjEgPZ+a+4NxeppBXDbwIWUnm+1Q81JFsFSOLcZh4NxTWuTaJYoqDqe2wrVZ0Llq0AUpK2fYO1WhHlJ7kc+4rw6p7Kfn/AB02nMCh6ZfMXRx/Pf4HYbI8Znvu9OO260nYdnJRJpJRV0L+fVgaHPOmMJmn3MlLTOFMUKrQIqglOXxozMePay4W0+ZzWpiLghDJS0DKBH9rBtbUqqK4DPbTeB73/4Q0hEHR4pqoYXBIihU1oQ+QNbUtSMkT13DZCoclFZprKpIUTSm8ksCJz7VRirFTAyRvsgUVHURHUQmVlKJkFqyaplMDNeuH3J4MKGuElpLwW+YPJBZHEylsBuFjSIEUd/dbjr6zrNtPVontMr44FFGCRJL7YkN/s7YGzJxh+I5WShvhh4J8ZxFgbVd9eS0xfc9plIo69BGYV3DpGowzpHVhEwvm3IWKK4zE6q6YaIXEAMRgzdTopmQs8ZiqAzUOmMRVu7kIzFlfOwJsSNlRR8C2/Ua33fC7RgDXdeKISmbaUyBYASabYLGJIg6s7U9+rCiOj4ixow2jr6PNNN6dBBijJyfnzOdTlFKcfPmTc7OzphMJsQUaZoJ0+kUYwyz+ZzNZsNmsxkBFzEJUq6uG+q63qXgInSd6PjIpiaclfK7KZu9GQEZKYmRiLFEazGNsvMDUW0odbCmaZjNZuN7QajG9r39EMKY9huBIkhPWUlmDCK6z8QVoyDu02lhBcqoIk6oRjDEkAoU7SThgMulR27/Q7JKRCUyK6O8+VCDUnasQash2tpZpR/InN9/FLtcnMsdAEvGJ5C8SYmYgpBdG4W2wita1cIugh5SlJLiW687crDM5wfEVOHblsuzM2IQAc2LiyVnpxNuvzope5fcDAGGFWESLRIeEDE4UjJcPNnya//tHR4/fMzNW1N+ylUcv2HI3lE1lq73kBRGC/rQ2MR8pmlqS+72HO5PUOj7VBspFKW5UGCfKRli0hJWFnZpVMd0ppg2C6azifROUeCuOTAkG9CKyubC9mwIIREDpFST4ozNxnN+dslyuaZrPTmJzLjSIlSXQuJlopAfp7Fb//u7VCHJzIWoMyO8ntrSt54QWoxJKG2xNmBMkr6hWqQGlEqEGMimAmsJOpKCJ6UOTSYqS09HmyPOWYzOtCmhU4QYhD4rRnJS4gFm6eRKpfE1hqIcnES4LRUGEq0UMSVSDugEOVQkLMlmvM2YJpO7ns5b6vqQnAwhCNBg0H3SWsT/tNbcuHGDrutomoau6+j7foxYYhKDtlqtuLy8JKZE3TRMJ5LeG4hCY5B+KWlOl6U8gCCkDht3xX/2ah17DSqj8SlOlrV2rJNNJmI4ByOrlBoBF0ONamBhv8KUMbQokAdaYfaRNPsJ7ReuljFFPbx2IJPd/VspDSUND0MqTAyD8EwPgPYBbs4I3R+MRi7NEeMxr/4ypCReOjUl17Q8Btn4zJhWLGHZMynCjx+7LEsuMPe6cSXSydIzVtKHIUZOn1xy9njF8ZGmqixPTjpOHm2BipwiTd2wODgo/JcwwOVzGkh8C2FsaTGI0ePcBGsb2rXn/e2ai7OW6TXHG7/HoGjwfY8zjk71SDtfR4iJqs5MpxXrrrTkKA0qfHRWaG98yo2U9K1kpUCXPHxUOGOFsoWEUpG6yWgsRkMhJCMGhNG4sFprjYiFGYfRVtI4ZCpd48yUybShaSqs1Tx+vCr8Z+OJ/Agvwm/nURbWCEMu5DEl/60U0jAK5GzIhdHbYFHJkPssbAk5o03G1RmlhOpHuYS2QEoQWhqCwL81dMrTk9Fmg9ERo0BnMDGTQiyNq1aosUpTbfYeE6VekZHepuDXZV/JKAMmg44RHRQ6OsgVMSeslZ4YkpJIx87JUdPFFSEIyebx8THz+XxMtbVtO0LB54dT1us13ns2mw2r9Zonp09IKaGNYTKdUtVV2UjEoPpeINypFL2Hn6PqcYk+9lNtYijtOG/3wQ/Da/fTbYNxjTEWUUUxoM650SBZK+KHV1O/7AjFh3pk3vUDjRFUmSNa7YEltHrGuAy9QlrLmpaIby8iVzsDJYGXRkUFpZA/nlqJIod0+gvX734BaIzSXt5IgSKnIe0/HGdw0sb84f5F+PhP1EMKVEoJWmXm8wlVZcmEwmMp9fKcYLsJfPtbTyAuRfhy1fP44QbyhJRbbt66ye3bt2hqSbuF4FERYWUpkiujqkHOkkpM0vajECWBzWXgve+dsjy3LC9a6knA1SB8qCDCnT11Y5hOazbnea8GmYGPl/yBT7mRStlDTigMZGl+TEFBSXNgwVYWpzW+lYufcma98UIfogLagDMZowOmEu0jpaW/QPLnBq0jk6ZhNplSW0PoYbXM5JDHGyirBBiXG4Dc4KHu85FsEZ9wqB0OQcYnzFjkzAB++kTjeYCKp7/XfmJD5avHyHsNlWNUhbwoRwWlATgXzjaddUF/pUIhpNE0BK9IWiJiHR0JTVKKpCxJG/GQbULpiNLlM5KW+sTAYp01KhVEkqrRKjJwAOQUsFQkFDlFyKk0g0udiyxCcSTQ2ZID1K6hWRzhO8O26wUsoDVN0zCdTrHW0nUd3nuePHmC90Iiq46v8fjkEb339L2n7zuM0VR1hSqwdWMtKQtKz9qqGBG5jrt60BDJ77Oip/E6S9oujTdEDF4sFEsF5t53AtQwGnIixUCKgRgCwfcoBKE4GNjBqA2ft5sHe+3smbGWVGYBRZ1LoiCtGXpV9WC0CuBmTJuVz8nlO+WoQBWDaoZ0XqHKQhVJmJL6Z4BfhIIq3Bkd+f/Q+Pqcuf6c9bH789NP7kVkz1tX+9Hh08/np17z9CcXA6x0Ksg+y3wxR2tXjHgsMkESBTtb0W0DZydnWFsTgyF4TVM7lDYcHh5gtKXvO0nZZqgbaWCOKUg6dDD8pYSSUhQX0tSQDCn19J3h5OSc0w9PeO0zh/S9SCMNjdBGG6bTiqoW4dFdNDlA/j9+fKqNlDaSTqiUxWERpLLZbWxKsD4RhXKKrt+y3nZ0WykQk5NQyRhB/k2bCpJmNleigeN7am2o1ASTPVaDO7SkWzPe2Zyx7TNWz6QDXWsynkQiZoEji25L2ktHfLRFuLrZ7y38IY+7D5wYFnGJEmLO5ALnHSa8RhVkXSIbWZqxIMZSiW6kw17e9zzU3nNRfmM+Y7CMxdvi6vpSZS+XeTl4xZIizbp4lEO9IWfhv0uGHIYc/p6HjYI0iKcpKhQkXXwDB6oqfpnGZdGqSsGhlB3ZBcbvl/e2qax2Ud64iYsacOMcOemSSg5kNIEKr5EmqpzJOmONhWy5Pr1FlxXrtKHLLcRUGM17gLHfaTqd8ujRoxFFt2k3bPuNpKKcIneRpnEMsHNSgCjOkC6SHWNzqpLvbIzUWHb3TPjzUhIAyABWydmTM4VJvaD0fEdTGdrNkugtoYfKKkLfipjkZk30W3IOuKoBYLPZjI3BOxLcPAJ0pKk5F4dA781dBSojAnyRkBJrnVAZKjRV1uQQMUpEpZJWCFVughwKyEHqzQqKBpUqxf2ddI7OeSz4yxsgpmK89hxKeXiGFTMsvRG4gDgjuTislPLCYEuEsFpSj6pszknvRWxX1nOZ7+XQ4qblZx3FvDdfyxKzVuNDIqseZRLT2YTZbEGOE1SqMa5F6SXGBnyqMdZSNZDxdG1FChprKjbbcyaLhEKzXSsuVi2rdctifog6qqknGq06lOokndwHTK5J0UvfIRlXadptLyAQ3XB69j7f/u773H5tirY9YInRQJriTI1zGetWuNpD35O9IkU30qp93PhUG6khV6y1KKJqkhRb07ChD4qTNd4nlpcbtqtIjuKpxxhxVhdqGTiYTgk+oo3DGnBWS6qoFBGtjhgy85llMatot1tUSZNoU3LmQyU4mV0IkRmjqZceatioP+Zlxasbfu7S6k8d7+n5UKKowvBSPNudYfrYZs39sYcc3Pv43SEVe5939XVDNDf0TAwSFFc/b3ifPPQYCVCyJwO571h9kJpX1uX5YbN49noOjsxAjzWesipSIIqyyRphQx+89Dx0AkmdxGRL46a0YYOPHcokUhSmiQEBtw8tH6DfTdOU661xlTCBS10oIogtOeeUktAPFeVbBgPGrqF1jBEyY8plqB3JQ1CFACkHlALTwXxiqZxFK9hu1tJYn5PI23etMKUXOLsqKb6qqlgul89E0SPXXBLUq2z0w4Yr1yrlLIS2Q6Q3+DtlIo8MFWr/ru9MilJDvmL/uMMTpT0k53FNDDPo6vwcmmgH0MDwu3r2xbs3PRs7vWBeDc89a6j2x35o9bzndweOwaKYktMl0HJ8fcbiMOGqrpDJAohTZU3DfA4HBzMeGU/ymhTF2FrbQPKcPN7Qx8By85jVesWbb77K4dFr5BzQyhJjIng5tRB8EdlMaB1QKqB0j7WaqtYoDY+fPOKdd2tee6MQiGdh95DUfsRY4XrMKkLpW/uxiKRAcrXSR6JFO6p0Y8eYpEM/VYTecXG+ZLOK9G0Sck8EGYU24i3HwGVoCaHHVRNm04xzRnirlMDTUQnjYLGYcu165vyik3RI6aV6dnJ/kjz2s2MfTv4x2YDf9Bg2iU9soH6QJ/Cc4/5WAVEGO7vz9oV1QAySwIZVHjpwSnSapXshpUjOUpQPMRGiRIsw9FGZ8XtVVTVKz1RVxY0bN0qB2oxpNGPESI31HErNCEmUKR0KIGIwzEN9Jo3fJec4Gj8haJXU4nAeA9y866BtK5pGGCouL5dYK6wVq9WKDz74gOPj44Lq28nmDKwUQ/1qGGIMJQVJzphiPIb0mBDkakKEoDM2KSqRsxVmkD2rJDXLspVlAUN8kvT0firyhzme9gWf47P9pkeONYYFIbcYd8mNO4bZ0RI37dGmAuUgNaQkDsV02nDn7m1OHiXOHimi1iU9XdFtE+9+74LqoSYkT+vX3LnbUdWlzWKr8G3N8rxjtdyScg9UY20t5ZajaxWf+ewr3P/8itt3Trhxc856sxF+xkEMsawnpVSh5NoSGYz3yzPyfcqNVJEhd4KwyzGVPLwR8EPWpKC5PFtxcdZJEx+7omDtDLPZBEVis94QkqLrEt02ULkirzDsBWSREFBCSXNwOGU2r7k89xjjnhsljPTlv+lvWaKc7yci+yTH+REZCBhSID+648v2r8vCErRnSkOTdmHZLt55JJNTHCtqSUnEtN0KVFxpXZoj5fz3ue7m8zmr1WoEHcxmM7bbzS71VtByT4MeoJgghSATk6TYUtot+sHADsZNRPFMqQwNKFghQ41RIrkYA0tjgDnW1eS8xPvIfD5nMpnx+PETMpLajDFyuVnj3OOROWM4z/2+plFhegh9ciINRXijQRkC4BNYraj6AfVVItuyf2kl1SKVwKRd1P/Sd3RI2Q3H/iGMMVIaHIo8xns/4CNVqDzBmIqDwxnH12u0W6FtEELbPEfTlMxRizGKGzcOuHlzzcXpGdprUhT+PUVN7DNt0oSUmB4uODhoSHlNyh6tGlSqOD99wOnJanTCFFIHDWnL0bUZn//SHY5eecTxzQWf+8Lr5NyR827ej3U02PFGwh4g4+W++afaSCkFzhmsM6UAS0GqRPo+0vaBy4sNm2VPZWpcZenaNYqAVpHpbMLh4YTgPavVJdAQQsYHRcwCTR060DOid6OSLPjJtGFx2HBxvsU5Q++FcmbMQf2AxmD8BlboH04c9ewxf9BAj5c46A/e/Xy5A+899sEHBc6dd8ZLVGYzJmdRsC0INqMNnfcsL5ekicbZij74UieSBl3nhGGjruuxLjWfzzHGFHScwftI23bEuF9vYu9nFm0m2EvhDSwFo0LUrjbErhl0oArTA5I1CSIx5cDF8pKsYLFYYCtHHwObruXazRssN2uenJ1S1zXG1RitOTs7wzknfH59P246AxlrzgJokT5EqZVmhKYsKQgKOhJWQYXB7tVpkioJuLKMDIxoQI1Eri99Z4ux/GHO4+c28/4QbJRSiZh7XGW5c/sOx0fXsDqSsyFKJw3aQCbiaoih4/jGlDc/e5O2TTz8YMPyYg2lwTdFUTuezWrefGvB/dcWdP4EpQx9O+P8SeThhy2rZZb3KEuIGZcVKfXEvKaatMwOApOZ5u69Y/pe5vH+GhpS/a5QcMmf1ChZ8zLjU22kUkzCq+aE3kRrIAscd7vtWK23LJdrvI9MJjWTSeG1yoG6rjhcOA4PK9pNwuhEyhofI30ofSZYUIaY85g9jSkJLsUEmsZgjHSR6+J5cwXo8ExwMI6n89X76TzGxTX8MZfc7s5jGw0Ju39L3WL3+cNnPc+T3MFwdwYp7z33PEO131Oz37z5kSCLvef3Xzd89yFaEGG5lx/P5vtfbjx9znIV9iOW8nzeYcJUWWgqZVGLBQyarA06ZVSWFHLfdeAasBlSLrdtB+UdDMuQ1js+Pi7XkpHR/OnvtP89syo5fYbrJ57tyFwxMqg///vuN+Xuk7gK0z+Axria7WZDynBweMR0Ome5WpLajpmtmUymtF17Bd3Xtu3YPzV8dkxRrtdgyUsqNNPjKk1jLX2GPiSq4bwKFHS45oAoDuyXbPbmt2aIHof5vJtfz6uVPTMPiiHMY8ZjcDD33vfUe/Y/Z3/djH1cSM3to9Dlu6bnK4f6yKFNkWc3gao6RnMNvw3021AorDyzWYt1GW08mUSlA3dfmeH9NazNvP/eGetlS04a7QzTxYT7rx/w1ucPmMx7Ej05Vmw3kQ8/WHL2pCf6mhg8KQq3Y8oeVzlCbPFxhTYdWkesSyhVkaL0cUGZB6GIz5odG0oeHZeXc+Y/1UaKXPolNGQCMOT/NSEkNpueru2AjHWO+VwzmdZo5aibikllmc2lNqV0JHnZRKSZTbSLlDaSY1e5UK0YjIVEoKqV5HGDdPfnXGhU9kzO8+bg/sYz1n/GFEmJKEoENS6EvcWxs127zx9v+Ed4cc96lHtGg2cN0/M80E9aq3qeEXne56rxO+/+/bIG6Pv1ksWQC/PFfpJG7mHZEXMqDkJR0yOXCGEQu9OoJHVRfAYfKTy3I0hhgJ0PqadXX32Vvu85PDzk/PxcRAdTJoQotZ9i4IQZoRg5rYs2lVSztcpF0n3XIzXe+Eyp/eQrnn3OmRhCSa0NRlGjtQgyamOo65rVakW/3rDZbKnqmjmwWq2IKVJPalLeAT9msxkhhPE7DulKVBHGSCUC1YqgwRsj2lG6ImWD08IIovLQOAoqFq7yUuBJiMMn/XRPUXLtG2TJhz9jSODqnHtm/o1rZrd4rq7LPWTi3rhibPbX71Nz7Mp8u/L8R6+lK+epWzAdIXgePVhiTYPWCe972n7J0TXH628ec3yjxjgRwIyhZ7rQvPL6nHqSuXazZnXZE7zC2objGwtu3Z0yOWjJ2aOUo+ssH35wzsMHWzbrSApOwKUxiSMeFQpHTpmUPIJoDoS0JaeGlHYSLqPjPDrZe9dNvXx0+6k2UkprrC0d5zmNjYCg0MpgdSU1gzSIHIowl3WZyhpI0hSXcxrpXlCy6FMeKGAUwtumEHJMJb0KSoyUqzRtGFiZxzP7EV2R3xnf39iPY5824gqy5PIhkcbGU/H6lVLYQkCcsyZ4gVMbrYhKld4maYQdoo1r167R9z3r9brA0yXKCj6MgAlVakvDfFYFWqbyU7B8JfDk4TXGWKwVVpVdSnA3N5NNY/TTBzEq1jq223ZE7Q0bad/7sXY2NPcOPwfQxGw2I8bIcrkUAcfCou6DFxFHLcD4kKRRO5LZ+g6tEuiK2ijWWWMTVFphE5iUsSWoUUjqL6qrxmd0rIZ6bbl9H+Wd70eV3w8w6Bnj+IJlrp567cdlGj7+wCD8o4EYE48eXHB5HkpLQSakNUfXFa4yTKa3iuSKlu5zEotDg7YTDo4qfK8Ivca5hmZWoVwHypHSnMuLLQ8/XPLtbz7i9FGi7yyKCVpV5LwtYBgNuYIcILvybSM5B1KKpKQwZr9Ngit9fOxd+x8LI6VNESODku7To/U2xnGwOGCzDfizc8FAKdk8KiOtfzFlUoTQZQw1ASVQcgXK6NJACUKEoKQXKhWWdeWxzlBVmvXSFwdK/Y59+tSOF20ge7UeBH6elCrwdomkRA9P4ftA7z3eKpLVtIQxglmv1zRNw8OHDzk5OeH8/JwYI4vFgphkkx+IaHc1Mf3Uxjbw8KnxnACCFwOgjcPaiqqqJSrJqbCiS0pRF9YC4fnTdJ0XwuQsMX/Ku4c2jqpuCDHR+xYfCmqxNCB778di+H7qcOi/0sagUqZSGqsNIQa8Bq+E9aMNQSIsJb74VBvmSmMRTsRhY4oaQkH9iTDxnqEqabpcIkZpFH+xAXomQzCk/F5mPLW0B1b059a79lKSV7Il3+/IkLNB5QalEn0X8H1PigZnHUrPOHu84e3fWOLMjNfeuMbBUY2xipw9MXegWxaHFeCIQfrtIp7eR0JXc3aq+dZvnPLgwwuBp3cRRYPVlRDyGoNSWpDMNKgUIUlWSiFzK+vS/qOH/swSQXvPdrMtc9uOKdGXvSafaiM11l3GHPYQYgIqF15QU+hUpG9JHLRhgVti0HTbjFKV+GRKONt67+n6zCZsqfWEpprQ1JZkhkmeqSpLVTmgZVe8/k1Mxu9j/NYe7eoxP8KZ/P7GUBL4rRwvdTy1+6kKsWkBApBkPkQfCTHic090GjWtkchLGl9TTLhqV7NRSlHXNZeXl2w2WzabllDSg0OKTzjySuqvUFH6EBiK0YzQczEUCpFL8L1AzWMKJffP+Llk4dYTNmwz9sRMp1O897RtO37rqqpYr9dsNhthx/ABpbWkLgfk4R6VEjASlCZEOkUbw6RpUMbQazFI3nty2+P7yCr0BBJZV9RKtiOTwRY0X0QiqaBBpSyt56ORGW7hLtW2S8A9f2ZeabFQHx15PTMLnoqkXvze/SiK8ee4KT93nj/vs/ZShVSAhexRtGUHE+eDZPFtzcnDRE6n5KS5eWfG4dGEydSUjHVG6cTQuLxt16zWPdut5vEDePRB4v13OtYbRYgSOSkTyPTElIsKhIKkyUkMXfBGiIoZmOPlOwwtQDEGUkx0fc96sxbqJdXI61MuCucfPz7dRqpcnJQSGEMaGjKtpvc9l8uW9WYjIIikC9+e5P8jUmfw3tP1kus1Show2zWcP4msl5GcPItphpmitlN0ElYEox3ZVtS1I+dNIWq0QuGWROpBqaG599ki/8t4Efv592dqQ+yW4kD2n9XVqa7G/73k9XxB+P1MEXr4b6ifyYuufhZXz+XKs/vHUSUFUK7TPm3SiAXaS5tkBAIuW/N+jPPRrc/PA4Dsn6t++g/k4roP3ziVc5O/JxJJC4VSTAmjwZBQMdBMJ7jZhPniOikpvPfi+eaAIrBeb9msNjT1DGsa+ugJ2RPDIONA0aESd7SupeFXG02OAW209PchciU+RGKIWD3Q+8h3ldrqvuRF6ceyjlhqBZLGTlR1TVvqSsCoIdW2LRcXF9RO5NtzzOSYMdrgjCPFzHa1IXoRz0uDo5bFW05OY6oK19TUVqirovcE1xG2Hf1mw8Z3WDIzZQlaY/SO1S1nVW7DcIf36rxjHancocJCMbRrwIvrqvvAmbyHcpDnxg9/6n17hmnvNUN6b3hCFfVpofiKKC2KylklUAaSkX0oaxH0JJUajQh45qIBJgwjVbl/AtBKwRKjQ1mJjrLqCMFi7YQUDY8frvBhw7UPHXdfmXP77gJjB6fEkaKi3facnZ7y4OGa0xO4PFO0G8d2nUnZoHQj4pSo0u6QCDFjdCabHp8CXUhs2x7vDSkJUCbrSyKG7Kf4GOn6QB8SfR9Zb3pC0phsUVSiNJF/DJp5BwbtlBUJqU0lMiFl1usNl8sVXZcAETlT2hViSin6VtbRtQFlEsZEUgjkpAmpYXmhUUYIaisTybOIVlnIa8koAlYLF5bId2hCALKRyZT7QrII+x2I+ymcK7lZdXWTHTIRKclnP73B5pxJajBSjJDdIeuIOPkY9t6379Y9fS0/BqgwHlfJ8dLuiUJBo58xkMP3ugIMUcNWc/XYkj0rhko+GEqKlpJOG4AOaWRiUHv/DZRQ5TMyV67ZPpLw6rV/epPZe16lnQ0uf9cpE3Mi6kzUQs+TCpVSzhFjFDEHQrdlGzyz+REhGWJSosOkOubzCj+bQ6oJ3lCbSNAC5bbWivfZ+dI3lairhrbrICUqa2n7Dlc74SpEM5k0pBAxSkFMqCQRnC/RvUQdQ3o7kZQiK4N1FmM0xoJxlt7LOUynUxbzOe12y2a1RqXMfDbDWScpcB9JSlEZR+wlWtO5WBa1m5/aGLS1ZGehMKdXWjbwhCPqimWKdERCivQq4i3opNEJVBLErABR9u71eM/27nGR3RlYx9UeVv1p4NHTY6ht7U3pZ5dIhkwaJ4IaNvG8i9p2c6rQdwEQycqDDiJfUSLYpOy4LhRZKIc0oMQB2s3/Ygi1l8iJBVpNRUbDLVG6B9UAmhAU6Ja+t2SkLul9x3YbuTiLnD9ZsV0r1uuWs7MT1htF8of4ADG0Yx+eUo6B21L+HYkxE+moJ5FgNgStWbUXhOjI2Ylzotd4IiTR9gNLTIHWJ7ZdIFMRE1jtpHVC/zgYKXZh9KCT0/WR1WXLxWlL3+XxZoUYxgbI0f9OInvcNFMq5+m98E7lpOnaSEwttupAV1gHSXly9ugCWdIKJhPLZGrZblsy1bi56SJT/psZO/RQHheaLpvvx3Xe/8BTcftjsDI/tAN8wizcb9UZKMTjLeik4TpopfCdB6tQxjCbHfDl/+738WvvvMvjx+ccHV7j3r3P8ejhuywWh7zx2qukkLl963UqO0dVmqg92mi2m5aTkxOePDmjbTsePzphtVphXUOOkdh31HWFdRWhOGQpQtNMUCgqrSBl+tBT2+IkpCHjkIkxiXR6kWg4OFhgnWK5vCSGgFF61LV6/PgxT06fcO3ouDBjCOKVLIwVVVXR933hLrzqDOSUMK7IepRGZtmQEcCTcyKREqfURsPGSwpIZ7S14AfHqxidvST9C8cPdT685FAgfJ1Brj1K+CihpMAS1mS0ETYSZSDEKGrgGIKX6NdaB0rTB0FLai2vi8Ejkg8dlY3cvX8Nqw+4PO9puw1H12a8/uZ17r96zGQKrlZcnnvOT0/41jcuODvxKCqMmZKVxRd9qf10nTh5O8ObcgTdoqzn7v1ruMYwP7AY1xFTRvR2Z8SYSbEleo8PEWNE8fzk0QV915OywqgWrHCu6ti91CX9VBupIeTOuRA9Kkvwgc3a07YRlaXTP8SeEKS7PmfLQBjZ+UBl5xweNCzPW3KK4kUUaXOtMlZnrAXjsoTtqpflohJZB6qJYTp3bLatACvy0McyMEB//ytniG70XspP55dLFf7O+GGMwt6tpFduuLVaGyJCABqAg6PrfOELP8m7T07pfebVV17l+rVrnJ4+4vf9vj/Az/0f/vds1i2+V/zKL3+TbdeSbUbHzGR6yOc+f4fKVcznC6x1LJcr3nv3Pd55513OT085Pz+XBlwD55cXwlBuhCtPW0tlRapGVrcqMjZ5pKtRIFxqSjOdTej7lpQSVVVhi4LAar3m0aNHVFXF9evXi2yHLqAkMwIkAGaz2Qg/31fpda66IuuhSi0uF1h/VVXoPCOi8G1Ch5LqKpIT+0ltldVvDyP0sSODDmAUWTvIloQmZ4mcjBGp95R6IlusqSAFUtJoXeNsLYhKY8gqknNLTon/+9/+JTEmyZUoNTCZwuLwDKMcXR+I0VPXhunsHUH3lWu33UZufnXLV5aB4BXCcK52zu+Ygtn5nuMOk4VqLiZP1RiuXXuCsVke5jvodMDjr/8BVJ4UCKYmpNKQnhtWl5GzJ1tCl2R/1R0oL3Mz/hhIdZSMjxSJQyKoTLvtxUBRoXVTAvlIjJRISgTjlLL0PhB9h9VTUIZYmnEldZMwFqpKY3SU9J612FqTTSTEANlQT2uObx6yaQObTSSHUkTMiHZRNs/Lrn3Sb/rU9x7SWr8zfstHIRAetOxQkorSyhJDTz2bsmk9/9P//L+yXF9SVw3Xjq/jQ+Tg4JjZ/JBHJ2dEn/jWN9/h61//FspqtBNJDu8j2+2WlDLz+QKtLUeHR9y6fZuf+7kv88Uv/CQPHnzIr37j6/z7//nfsf3mN9ANpBjIGbyPxJBQhaph10ApQ5p/RW11NptireLyUpBXRmuME3n7JycnpJQ4PDykrmupqwVhxBig6ufn5yOib0ilDunsqqqYzqZMplNcXWGHRt9y0azSWBS584QuoZPCUpjc9wvqav/sPx1DaSkhSCTlIDlyViVd19P3G7JqcQ1M5pCzoe8UoY+Ak/sYe7QJ2Lrn//O3fwJUoO8U0R+QUuTWPcVP/75bfOatG1gzYbsJ+LhmdpCJU9F+MKrh4izwtf/yLr/xq2csTytUPoBc0/eBpDzKCtFwpkgdDcCScj9TzvS+pfXnfPYLN/nZP/h57r5SkfWanCMKi9VNidgdYMi6B1Wx2UTOHvf0G0fyBqPsuF8PDt/LjE+1kULtvmjK0tex2bR0rceqCrLQvsBAI4P8rRRi+y6wvFhitKijUrxFQZ0knIHZtKKpDChJ8WWVCSERCq+baxoOjw3LVUffr4ixNIcWlOHz7NNHQVKffr0gpxjztynvePx2Lx48IvmdjwERvCjp/vQpPX2eVxoT2U8O/OBd3JfqoSjXYFcIH+pRL0/rNJQUPsk3UCXVpyiM7DFTVzU9GZ+gVobTyxXaKqwR4tjVasN8dsjh4TWmswWTyZy6OeLOnTfpQsBWDuccm82W1WrNZr3h7Pyc7aZlu/W8+86H9D30wfGNb/w6X/jiW7z12c/zve9+F20yPicmkwnBi/R7Nlng5arUOorHbLQpEgmZyaRmAFnogtqbTUTe3nvPtWvXaBqR5qjrmra9pG1bFosFSik2mw3WWi4vL0eEn6gGQ9u2hBjYdi3KGIwxNJMJs8mEpuhhhd7Tb7aETYsNGauN1HyzoixbSREq6YYiD/IyLzM1JDq4Arp5QX/ORyP81O7H8zLAqjSpXimyRnmMrOrCQK50RilPNoHDY8etO4cc31qglePsSc+DDy5ZXmwBMC6xOLRcv3nEZAp9H3n0Ycv5iZBcHxw2HB7VVE1Cq57DpkLpKcqsQHtCkIj09PSMk8cnQGQ6ryEl2s2GlD1ZiZzKUDeOMY2R8rDsU8rEAIqG7RoePzrn7iu3MUZ6RKWdoUVRgQpkPD5uCBEuLxKnj1vCphbdNm1ENSKXe/PjIHoI7MgtYYQ0WmupbU0Khj70DDDdFCFnTYqRGD2b7Zb1ZiMyxz4XrRktSrAk6lozbSyzaYMz4i0rVdFFCAmsKnRMxnF0dMzyvKdtt4LyQ2O04M+GG76/SJ5hXGBv0y8Tfyhp5f33PvU5AjXeoyka+8au0sSgnl2cV6+jRAf7YINhwl45zyF8HYrXMIIarqIXZfG/jLF53rXYfU75rnofPFLOD4T1QQ2MEXIVX9ZAlSPsUCovMVIenIBBUK/A0ZXGuRpVOwELKMVkOuG1V9/ktddfZ3n561wut2QcX/ulX+WVV17lv/23b3D6eEnnPdoZDg4OmU5nVFXN9Ru3uHPvVYyxKKXpup4bN26RVMX04IgQM6v1hoPDA6zKbLaan/u5P8Lb3/oOv/aN3yAkjzWSOjJa0QcvDlip8UjqSXgDh8bcDKNqMEpkRGazGbPZjOVyWRp/rRjDUpMa+qW892Oqbxh939MHT0gJpTXpyRNIiYPpnFndkENkmjRHbopRiRqzxzKBZDT2nSc1AF/UlXn67BxSLzQoz979/ML6qh7Wb3o+c8zTnzsAhVACqNGqoBRLNGhMIqsOVwXuvX6TNz5zk+u3pmhd8eRRS8pbNttTckjcvHuNN968yf1Xj2immc060VQXnJ++Q+c7jq9dp6ohsUWrKDpbuiexhZQxqqJrJe1699517t5tSKEhxZrL847333vC+XlHTNV47ld4Hve+V0oZo+acnngeP1xzcb7l4FrC5AhKav2VAx07+s0FkUDvExfnLcvziI4zbNaoWPanrCA7yJuPuKq78Sk3UgMIWZA3SsNsPmHSOJyasVr2xE2PoiIngUL6PhXWdIHehdBBLoI8Wrr5tdU01jCfVhwuJtSVE+l55eh6uLjwbLYd1kYmtcBEMxpV+NdyUhgtXirsgpZ9OPlzIeV76LMXjxe4dHvPDHWHj3jps+99zip82Y7w30wg9VEe7kedu1LSMPjS57j3vt/cKOwOWaHTkBqWhlrtNMoaJospv+urP8PN20dM6gNy0TPrusjb332XX//1r/Pf/+EDHjw84cnJhQAFgOVqg0KPUHCtLU09YTKZYLTmp3/m93J04w637t7i5p3rbLYrUvTUswk3b77O//VP/p/5X/7X/8RmG3j3/XdwteZyeSkI2KSYz6asNxtCiNS1JaVM13UjK8WwSbWt1EEGiZFBnLH3vSDX2PE3Du8Z6lTikccdX2EuWYzSpJxC4Pz8nCUwcTWz6WFhmdBYNTSBFqOg0l5a+/n37UWG5+no/oUG6iM+T+bmR0yFF4xcBCel7zIDUfKcJqBtx+37B7z51i1u351h6h5tFDddzaZf8PjsHayp+OwXrvPa69eZzjPaBlxdsTismM4tto9Mpo56YoBQjHdBBGYAS84Waypu3brFjesaYxx9l4ne8vhhS9utuFxtif3Q37kzVE+jIeX5ihwNDz644MP3p9STOcMmoxT0fkPvWxIB3yuenKx5/DASe0PoRU1YAGUGVEPwhvAy2x2fdiNVnOCcEllHck5UlaGaTVFJGhFDFCnkmDPtNtBPI85alMrUdU0zcfRdj/ep2CpLZWoWs4bDoylNY8VvVhU51ywvA48ebbi43KKUwtmVoJuSKrBhsMahsfggE3CIYj6qT+oHAYYYoezDz0/27o89x98u44rnyg/C8Lz0kSV1Q9kX1ACMkXaGVbvk1pt3+Onf/3t5dHHCL/3yf6RpFlw7fIXLyxUhSjtEM5kRs6IPkWY2ByAlqXk2zYT5YkHbdvS9Z7VcsdmIx7lar/iNd/8D52dP+NxnX+eDD94lhJ7VKvD7fub3UrkpYKjqGfP5EZ/7/Gf5z//lP9N1WxSW9bobtAhRStP3geVyM0Y/rjBIDFHRGKkXRWGhSDLPENUOEfe+blaMURy+QpWUQdCDzuGUIfWF5y9ENGCTwuiBMDYzgsL3UtovvCtPzVl19Y2/9SMPgqeaTASVUDqibM/BkebV14+4cWuCtj22ymQ807nl5u2G67crDhYH3Ht1zuE1izY9qESOEW08qA5tgiCM96DqcswEOLS2gCOhqWtdBFl7XC2USPHDViivkiosEFfX0j6VliA1JeVqtOHy8pzzszV9e4A2kqLWFnq/xfuenAztFp48WnNxmlC5RuuAMR3aeqyrqCrHZpPJoX+py/npNlJDsiUnyBFNwjqDc0K9Ik10SXRUULTbwGbd46zF2Mxk2oA6ZLtds922OANoy9RWHM4a5rOKSWOonUEZx3YdePRoyZOTlt7L4iRvkW4VxolptChkKmEAHSfBvhF4xkj9QC7H1ZoRnwRg8RxD+ttx7EeL/FCqYR83NGPrb1GVJQV8DNS1w1WW7733Nu+fPuDOzWu89upPUNkjPvjgl/FBomzras4vljx4+AhrGo6PjwqRscCSp9OGyWRKzpnj42Nyylwul8QUOL88w00s1cTgas001UxcxZe/8lMiRpjgcrnh7r3XuHXrHrPpgspN8KFneXkhhkOJl+19pO89IXicE0TgEB3t60MNRswaW/Tb3JgihGfn9khPVh6qpKSNtSJ1EwqTvDZoNCYqDBqDHtGru1lbfvsE8/ITZG9/SMMUZ6Yg7FQgs8W4yL1XbnH/1es0M9BaACYhSqp9tqh44807LBZzFocVyoiiLThi9PR+RUpd4U9EPpvCK6lsuVRO+POULTRYikxPSj0pw9nZmnffOeHsxGPUDOd2RLADKnM/mhrJYLVHaYXWGe8T3humNFJ/j4kUEsFv8Z1iu7YsL7fE4Ig+kvOWrC5YHFtu3VlweHidxyc922+dvNTV/JQbKRkSTRXqZCIh9kQfSdmXIrfoAvVdYL1usVYzm1nqaYU2MyZTRwieFtHYaXTNrKqlUztFvE+ENnJ61nHyeMVmDahGyGkBchTqlj5CNtIvkAKuctJbxdW4dlfkL4+BgywPVZ59w1Imorxz70OuXoOhpnAlpfjxV45dQv7ZVz/PYH3ixf8cI/lR7A9jqucjjjh8t9FMqecfB15YbniJ05T7cPXvSlLDTyEtjMRLXuMAAQAASURBVLV4H0g5s14tmaYb/OzP/gF0Ssxmx/jOEmNkNpuTM9y8eZuLi0ucrVDW0fY91soHtl2HrSqcFaTe4eGRXBNjODg8oO83hJB5/OgBq/WS1LXcuXmLL//UT/HNb73DdtsRfOLw4IgPPnwAGKbThkePHlI3UyaTWorexdCkCG3blfS39OIopbBF1FAiq56c02i83N5zV5rLS/QlAAojAotaC4+fkteEECAmrNaCdQuerGoMQoekciYWYI8algcIK8Tz5uNgHIepXO76cN9lTeyn9l7ktL3MLNlrY396Yo0ptwKWQBxWeS6C9kxnljv3Djk4dMS0pqotGTXWfV2luHPvOlobqloL9x6ZnBUhJLZtS0geZyv0FSMlhkrKjVrulRIwmTUi4Bn7zOmTFd/+5jnf/c6S8zOHtQa0R+uMNhSuP11aBCSCShlsVkR6+hSoCOLYdAmjGlSCGD0xWHxvWS4jDz5suThNGGbEuME5z/1XZ7z+2UNe+8xrOHdM97V3cI1/iWv+qTdSqqQh5GvEGHC2AgqTeWEJFpE3AU1suwjLLZkJISVhRncGZw2VmpRp5cmqI6rM2gdMcGzXiccnG7ouY1VT7IogeEQfxWBMLRQhgLaZyJacQtnoChGngpQjzoE2EaMj0LPe9mSmWFsRYsBZIyF+Vuis9wr1WoTh1LD49kbOEMty1EL7pCmEjxoY+eYG71SPCy0rSINnzFUjd2X5fsKQ7/uJEPc3GPY2waFGsLsWJZWaQSmzix7Lz4HGKJf0p947mb1vKsml/IIE+d7x5WMlrZyAbGQT6foe4yrabsVPvfEW1++/xi//11/nyek59++/Rl3P6MKWV269StYwnx9ycnLC/HBB00zofcA5ob+pqppmMqOua3KGqqpp2w7jKpq64bN3b5FST2g7lM801YL/4//wfyHheHK24p33P8DVlsPjA77+a9+j9S1ZZTrfM1vMMa5hOpkSYsQ4x/E1i3/0Iav1lqqSeZcQSqXJtCHFgM8B7TKhjyglhfahT0opNQIwYOAlhJyLMbKGEHpqK/RNaER2JGXa4OlcwxbPAYYqCNVUqxPZGuoAVSHy7dVVu5CH/6XyS6krK4rDZgYGlL2oLKdhsozzpyQteWqWX52NKpHxZNal3uSASuahyuS8k6wAaV9pqgkpKHlthsk0cefegqPrFuwGV0lrTPItrqplb6g0RlelZCAaZWSF0oauU6w2ij6AMVtSXpVMzoSspBcL3ZF0J+elLYaart9SNdD1hg8/UHznm4rz04qsE9otBXChAq7KLA4brJO+Px80lxct241nvY10qSLmTO1q+s6To6cikHIkxJYQPX3OXC4j5yeJzQoam9E2c3St5stfeYV7r86YzOa0W02/aTmY1y+45lfHp9pIDUVbQDbfwgWltSx252qU8qATGkE2xZDZbHpCDEx7y3Re0TRGxBPRxSHLZJ3wWmCZOXnaTjYnYxQpR1TyGJdxlSWmSLuJZCzKCFw95JZMj1LCx6ZwoDxZJZTKTKcNR8dzqirTh0vseWJ5GfFxi7NOwvSoruzYqiwYxojrI8bz6s3j74O3t+9+6r1DFc7AvTer8TO/v8TkiyKnF40MO3Tj04ZiDzBxJV7cM1Dj5+xHlHvpz+GvuhT3c9YvuKT7HrgIHKLSaNSTTmStWG3WuEmN7wL/v//0NZbRo3VNM5HoqZnUxCzM+WdnZ7RtS4qREDx939F7jzW21IykDuRcRQyRru/RSrNZLXn8wXv87p/+Ct/73jvMpjPeeOMtfvfv+X18+OCEs/NLfv0b3+De3XuEFHj4+CEpJ1abNYlM1/U4V+NjJiWF1hV1U3H9euT09AmXlxuaxuG9KP5eXi6xRhNiIb7VAiM2xghzhTGEEEqEtUOBppwhZbq2ldeGiNGWMGhqKUE/ojXb6OltQ06ieAyabDSp3Hxd6s5PuxCjsSpOi8yLMmf3EKjD/RvSVvL0vuHaxeTPH8N8oWRl8vjnXIrieaD8LitIKYQZIjucs4TUMZ1W3LlzxGxuMUZqMTkptEaENFOGHKV0oIrrtIMF03aRzTZLvyeZnKKgcUuJYXDKspayR4iBHCtyNvS95+Txhu9+55xHDzzeG0y1RTlPU1tefe02N28fcHx9gjJSSwxBc37W8eTJinfefcyHp4HYSy9p32qS1ygCWm8gtcQE243i9DRyfrpFofD9BdeOKz7/pde4dfuQugZrDA8efMjl8oS796694JpfHZ9qI5VSIoaM7z3ojLPSA5W1aJoYI2i9AaasS94/eMhZ8q+9jzinMEZR24DRCghAwFqoa0vTNCzmmmmj8D6xvuzoNpHZQgwNKM7PN5w8XouMgoYUinKvFsh7TpHoA9Y4ppOao+OGu3eOmUw1fZgwX6x58GDD40cX5GyIPqOSK4J8xXQUCO6AHvqd8SMYQ+TJkGaWuot1ji5G3n3/PfqJJRiFVqJ3dnLyhO12w2a9FpRp11E5kThoW2E/7/tesgIF1OBchbXCcWaN5bXXXqdvtyyXKx48eMhyteLGjVv8j//jnwHg7bff5hf/wy+SUuLe/ft86+3fIJd0W7dtaZoJXdfTti3O1VjjMMaScuTo6BqVq3j0+CEAB4sjQpiAspxfXEJO1HXFZtNCdngf8F40ywWEId732DqhDSFkFofHhfFFWA7qekKKoq+Vci4eexA0MgPZ7eA45PEi5+F3tXcDfsuHhlwzymMq6TNKDOKMRTadAdGXUToLRNy23L57k5u3D6lqv2MUV1dVmwfBSD0CSGTEKPpfm01H8JoUHMEblBLqpJ0BLX5YCoSwQSWHsTWbjef99855+OCUEBqMA+M6btxu+Oxn7/PGm/eYzR3KeHzsyIDvFdN5zdH1ObbR5HcuOHniyZ0nhQlGT8gEfLooiL6KkweBx+/3AoF3PU53vPbmEW++eY353GGdYrvtOb94xOIoc+eV2Utd+U+1kRpoWmLMuKwKPFaNHfWQRkG4WIqTWlvRkPIimR28MEtolVnSCwwWSeUZrThYTJncqlksZlROKJY20xbfwmRecXAwBaWoG8Nms6HtWpTW1I3i+vUD5nNH6Du2m47T0wty6pnMag6PK6ZzRV3DRNc0U4utGkLoWV4IjNPpGqQvH1SQKExYPH+EV/13BlBqiANlTKT3HjNt6EMgZI2rG4k8VKbdrmjbNVplgu+5fu0aj09OBOqdM227kajKB5QS5gmVNCpROBg0msjpyWM2my0HB0dkDP/D/+mrzBZH/Oqv/jr/+T//Zy4uLrlz5w4hRk5OTpnOFqxWSzIKW1Ws1htoe+omYmwltQovvJez+SHXY6brW2aThrp2rNdL5tMD6qbiO9/+NmDZtj2r9RZtLNvWF1j5bk4KSa7B2Ibe95gM2jjQhm67JYZA1/fS5Fw5tDVkLcZOAFBDDnun1zRkN56Km3+Lh0blGnIEPJm+BOXCaC6ErHK3coriBOeOrDxHx4Z7r8yYzJMQT2fZu7R2ewYqjSltgWnvjpxSpO980XiqyBH6TpNTkSAaEgiUVCcRlEfIDiyri8zD9zesl4G+X+NquHNvwU9+5Q6vvnqNxYEm6y0Zj0pBmHhCRrua+UHNrTsLHl/0nJ97tn3EaIdxjpg3JNWhtKLdJE4feVbniZwDWl9y5/6Uz7w1Z7bwoAzWTFlvLpkf1BzfvE09cy915T/dRgqDCLtBzoYUFWbU+4k0TcXhkcb3sFoV0S0p0QKaHEutKgnSJsRWlESVSIJrpbiMHbNJR1NVWO2pa0VTTYuXkrBVAq0wtmG1mvHBh0+IMTOtG65fW7BYWKQvIGGtZ73eslho5nOFcwFUxFjFxGru3FmgInz3249ZBoXOlpwd5DRGUZIf37Ex/874rR07aMsAdpH6TEwJHwNH8xnz+zd5+8P3uXnjBtvNkhh7jIaqMqQY0KoWctESgVnVSI9jIYCNMRJDT8wR7wOVq5jWjuNrx/z+3/8H+Kkv/zT37t8ho/m1X/sGP//z/5rvvfse12/c4DOfeYuvfe1rHB0fcnb+BK1FEj54YbLWWnqjlNJMp8Lf54wFpZjOD4krRdsFUIaqmuKc5c033uSD9x/hCrXRdLrgzp27wLeZz+e8++67xJhED0tBXTdUTUMk89ZnP8/bb3+HP/SH/iDf+ta3+NY3v0kzrZg1E3JOzIxBKSuSEMhiTCU8U7kAV9Twkx+hf6ZRVCh6oPDPQQE7VeRkRwObspfkuWo5vl7x2c9f5879Ka4KZCJameJQi2JCzjvI905Eci+SGqIsQKsGMvSdIQYn56UKK4dSyN6mcM4S+0S79Tz8cMPjhz0xWLLqOLo24UtffoXP/sR16mnEmFZAZhqSj4TWY0xFTrDZbLm4uGB1sWW73JJzx/wIqtoTUkfCsG3h5OGas8dLcohUdeTmnSlf/Mmb3L6nmTQeQ0OKmbpquH37CNP0bPyPAXDCe6G/D0F0VrBifJSIOlHVorNycbFFa4UPqeg+KYy2o8dGGpgErHgxWRFiwCgkvbfeMJsa6spRYXBOo1JEmSgyHdbiXM3ioMI8jOL7qoyrDMZmnNPoiSWnI1ZLw6RRpedBCeGkgozCmcy161NWl4csL89LYVS8dWsklk/Fo3weKu4ZRgu19zt7NZ3nXMtdjn7H2JDLe3RBDg7/GzbpQf5jAFr8IMau1sTY3DwATkYU1wvG03RIkuplrFGNYIznHvjlzm+E5qpEQGpHvu/JCt76/Bf5o/+3P4m7ecT/4//9/2IysSyX59SVRSvFpKmZTmq877h98ybttsW5ihQ6nCkQb2uwxlFVDdPZDKU0i/mCL3zhi9y4eYODoyNCjDx8+Jh//z/9e371136N773zLjdv3eaLX/pJvvvdd3j0+BEHh3NB6mlNTJmYMtpYlNH0Xtgn6qZBa2HobrueqnIcHhyxWa/ZbrcsFjMuL5cslxtu3LzDo0eP2WxWVPWUg8Njrt+4xec//wVOTy+IUWpn3vcYV9PMDpkcXGN+cI03P+s4vn6H/+7WfZ48OS8MBa6wrkOKIjuDKozcGjKJkYlbqVJ22dVopZn7KTTF7ibJj90frsyP/b/ultFTzxW04lj3zoqcCl2QkmhB3lsJb2MGrcHoRIoB4yKzheX1zx7zmZ+4znQBxkZxiodTLkZYGqMTorpc6uplHhsjgKABsae1wXeR6A3RD3D/QMpSWhB+cYGfR5UJPnF6smGzkl7Pqm55862b3HvlkHqSqSrwwntEiBnvwXtNSpquzTx+vOTttx9wdiLxvK63HFxrqecbMokUZmwuAycPHrNdnVNXFbfvzPjiT17jlVcrptNMXSVygBgS88WEpAJ9bsG/XDfvp9pIyc3VxCAd9boIje0aDZGaUCECkw27iDyVguluYiaUduMWrI2lcorZxNLUFdboUa8nq4jWGaUCSosYmFKWqpLalipGJMeEIqNVwhjLweGEuhrIG6VvQeFKJjuB9sxmU+7eO+LywnNxFvFdhzIaZZTQyyiZjDHtFt2LDMQnSo7sFX4FBn5VY6e8iIFiaaxkfx9NKc929b+IwmgoRKuP/S7PGKhh93kaOPICKzVC2fc+72nABmVDGT4kZeFHS2RcVXFwdERW8N9+7eus2zWvvXKLL3/5p/jpn/49+JBYLI6pqprNtmM+P+LxyROapsH3WyqrqVwl0G5jCnJM9KVyUrRdx+nZGe+89wEfPnzIL//Kr/Deu+/hg+dLP/lT3Lp9m1/65V/ivffe5/D4qGQTFCEmQohoY0YIgC78fTHKfEoIyeTAvu0qQfCtlhuqquHR4yccHd3k0aNTtKnofeLBwxPmiyO6PnDz1l3e/+ADMgZtKrSpmMwOsHXDN771XX7XV77M13/tm/zv/tAf5I033+K73/k2oMlJ0eeAV4qgckn7FeHCBGP4pAoARsnauWponr2h++nB/fu5P6d2vz/9t2fnwNCTNxjN3RGEqDqGsiBUTx+XYHqu3TzkM2/d5M2fOOLGrQplOqRHzYz1qIzsD0MUtaMgE+dPmmjlta5SuEpAYSlY+k7AL0pBLkZT1B00ORph+oievtcsL3t8b/C+Y7qwvPraMQdHFcYO4opCup1TImeH0ZrtJvH+e2e8/fZDPnjvknZ1APTcuKm5+6rBNRtUatgsDQ8+uGSzarlzb8Lduze4e/cG915pqOs1VgfEAfBSAy1fPydNij8GRgo0MWZCkEfOgwciU85aLT1OpYN+VCl9RmtriEAqQgo4o5jNKw7mjsXMMZ9aJrWRbTtpRo0GlccakVLiHdZVxXaTyEnj+zIBc8JqhasdTitC6Cn4inJ4ySNnEqiOyaTi3v0DuvaxSG0rR8KRMhhjS5H22cX59Ob/aS9dPW2cdj1UP/gvti9XcOXvVwxVSfEVNNdwFsbIpv/g0UOenJ3xwYMHZCUUXVqJUnOMkbPTx1jXEKNIy9RVhdGKXHqKEtD5QLdc07YCpFit1oV0dsWjR49574OHfPjoIVVVUTcTPv+ZL1FPJvzSL/0Sq9WKw8MDiW61Lvo+ucDbhbJL9AcdMWXJRBhLyKH01QhxclWJxI3WmvOzM5ytaNuO115/k++8/R1iyrz/wQO+8pWv8N77H3L77n2++857hVFDgTL0AeykQpmaJ2dLwPLuex9y/5XXeXJyyuXFuTT7pozXmZD16Pfs90eNZkENZuGprMEnmAu5OKfDMskDKA/GPq6PzwgMzhyQDZqanCW7EvIl1q25fmvO575wm7e+cJvFUUSZlpQCWkl6bozzVNw7/lUF5f15p4Bm4nB1QqmEtQJiyQV+rzVj43RKGnIj3SgpsN0GNptu3GPu3j/m1t0DXCWfHQva0sdM7zV9D12rOXl8ydvfOeGD95f0rcMZRUwb7t5bcPP2DLRHMaHrZU989dXb3Lo75dadA2bTKdb26GxFiTcZtM5E1YnxzZnoHTG8XM3iU26kICdpdOs7T18L5DPnhDLSH5RSkHRgGjRqxncyTrayGlLWpAzawGRmODquJc1nFU4ptDIYLAaNymHsuxmmde0q6qphvdxCgm4bUcmMzysEcmpN6V+iGLys0NpSVRnfJ+omcvfeghB63n33lMuLDT7WGCPd5M9bRs/jwPvtzh7x8eN5nvBuk/mBjvycuHFvoxjlBQaWCY0YA6Uw1tInqRlM5zOReVeQUyQlz7e++Rv8xm98i/WmK2mZCmMdlROgRVUVGQutMdrgQ6TrOvquZ73aEFOiqmrpbaoaPve5L9A0DZPJhF/7xq/zvXffpWnk+dx3zGYzeu+JOZFQaCeeckKRtUIZS84BHyMmRqpK5iWFDkcZQ904tIZFmGGcZdNu+cxnPst7771PDJmu7Wm3Hb6P1FVNU09os/QtgiFmTVaWxeE1Hp2c8dr9+/zyL3+dn/k9v4vrN26RQuT8/ByjFH0KxKxIaUCqqR38+ul79Ew7wss7Y4JC32vQHmzN3rp5cYtEBgq7+RDhZUeMGmccsEWZDa+8PuVzX3qV+69dZ34QiOlSdOlsDakiYRHwRQ8EctYFLLEjeC1hLWNWQyuaiWE606B7dK7YbLZFwyuXRnBp+s3ZYVWF1gHYsO029J0g9rRO3Ll7KGUJE0lZo0iElAgBcnb4LvHgwQXf/I33ee/dJ/jeoLCgVty/P+XzP/EGh7NDlusLcs5UNbz25jUO5g3zuUKZFqXXJJ/RqkElAZJQJ5Tyco5Jk0ND8OF5F/qZ8ak2UpISEd6zrvN0Xc9kUu1tYoXqY29WSq45Fqg5O7cNJQZAaxKB3m/wMQGVhMNKxBLJwtOn9EDDXwxClqZGaxwxbIhkum0oImVJGHS0HEcrI+AMNCQRPtc6Q46kHFAqU9WWO3cPZJOxF6yWsXhJuhRIn6W5f5qmZrhKn9YhweDT6cyyeNll734Q3zA/9UHPpPqunMFeba+gszKZxWLOyZMTHjx6xNBTp1Xm/OwJ7733Ln2fqOs5xlWkpAurkrA7pCIEWFcNSolUhrWO2/fucbA45PDwUBB1nefJyQnf/e73ePj4EdvtFuMsbdtST2qstQJnj4JeNXZY4gPceZf2y4APgboq9F1aIZ6+gHN86Ll56xar5YrFYs5yueTu3Xs8ePAQrS0XF5ccHByyWm0ARQgRYUeIZBQxKY6Or3OWMh98+ID79+7yX//r1/hdX/kp2u2Wbdvi+xUhRkLSJBTmk8RG+fnpvo96Qx4NwHCfr95vuaUvSD0PhLcqQ5I2kBQNaENMgYNjxxufvca9V+dM54nEBm0DdVNDcqRcoTCMeMU8oCLVGEkNI6YStZea8HRace3GgoffuyRsEt73bNstITTYaucIa2Ug1dLtn8H7nhB6cs7UjeXweIbSUdj1cyQSxfYqie5PT895++33eOedB1xeBJr6iJxhtgh86ctv8Mor90XdIfZCBTY1HDjLpE5YI7WzrDpIFUrXhF7q7yp1JN2CMmQm5Dwh/TiwoGulyybh6GNm62EaoXKAjiWFJt7s4DbJxJCG2lzEDZU0OqCx0vQbEptN4nKpqCqDsxqjhWAzxUzUVqZWrhhJHkuTrkKTo9Cd9KEjpUFaW5agtVYYoRlIVGSCZhI+iuaP1Ic988WE+/oIaw2PHqxYXkqfBNGSGNQ1ZUNJKqCJSN+EcIcNHfFPb+UjCGIEFQy9WEDp0/jItZ/lPAfgxNXcPs/5/ePH08ZgSOs9ly1+Lw+0b6j22a/V3nmp55zOsLmlYaN7al8aoMHDuQ2RlPjT4o2bXNJNxkKKnD55wsMPPiR2PQfTORcXa07PVty7d5///g//EbrWk5WhqiakBNttS+UastYl7aKp64ZMpu9EJny7FTn5b3/nu1xcLlmt1wD0Y6+RSMJYY+jbnja1gjbMaYxKBo/caIMuDc1aCYo1l7puTglrrehNxUTXdsxnC07PzljM5yg0IUZeffMNHj95gtaatu24e+cubddhjMUYSz2ZYCoHKmFMQuvEwWLG6cmGBx+8z1ufeYO3v/0tjg8X6OT54J1zXAj4pPCVI/QRg8FFhYvCNJ+UxiRZQ5Lj2tWHFJL9GNPbeW9qv2CuXQUSqY94jr3fM+BhhJ5LLsRVFm0Sxinu3b/D7bvXmUwN6BZtM03doDB0fcQaSfGpsmcM2nVDCWKv13z0mga2+aapuHFtznS24nLbk6Jiu1YEL710xg4s6AbwxOSJSdF34CMoo5guHNOZIaWWnGtSytLkpTwxwfJS8+47W979bsflWSlRqC31pOKLX7rLW5+7g60UbRtIUeO7wHRqmE0rrLbEkOm7ni6A3xqcsiiVmC50qTVaUBUqW5QKVC9pfT7dRipDSoasDD4lumjZ+IRtNBhPVh5jNSm2AvnM4tnKxp2AgFIJY0QSXNgEHDEaordstpblGumUthmtOlABpR2ioDktDegdWfWgMjEpuREkYmoJ0ZKTEcHFItmtBgJHMjFHtNIkpQgxl8WXUASgY9pU3Lk1Z1Y5Ls7XnJ9upI8qiTxIJpNUIqlWvq82qDRBJ2Q3N7lElkOKIpf8tGzQKumxOLsfTgy0SM+PJIbNIo+bwq6CkLi68J/dBEb04AtTKyWj9jQopGxEqWRFnk7ePh07iiMBZLkGg+ro8Hr5eTVFOn7eU6k+eSSSHq5bxmSwSuFDZLGYslmuOV4c4h5+gO8zMTmWa88v/IevFUHOLd4HJpMJN2/eZjqd8uTkjOWmFfaKOByTIkAH3vvR0IQQUFooi5RW5JLGbrdtIR01WG3JMeODxyiZZ1pL76DKEH0gBfGknbHsAHMKskZljVZKDHECoww5KrTVaOuoJhOMszglTBK+9zhj0UqjnSWpzMFiRjYZ319ycbahtjWGxMnDx0ws3Lp5nbMnj/iJt96kCRu6x4/RMRPqmnTZUveZaTTYWOjAssZECu1QaXQtvGBjQ22Zw6ncT71XeN4HQFyp21I+o0yGId02OCdX038RRQfZQ8yFPBqU6vCxZ3akuXPvFtPpDFcH4cRTRtRqtcE5RU6F0ZxYrrclE9FaQF6ohKL0eSpxqHMqSsfGcHww4eaNhs3lihA0m7Umhgkp9VjlxTlNisSGmHpiUHhf4YPF5w5sQtuArRpy9qhsBPqfe7Zd4P0PMg8/MFw+meGIVPYJRp3x1uuf5Qufv0/VKKwV5eiu25BiwtkJipqUDSF6Hp1sefDwnM3FFq221BPPjTtw807DbHqANVNy6tDqHGt/DEQPh701DYvYR/o+EEMFzqGUTFbnRABMRN8EURNCS1Vr6kYe1mp0dmQc21aE39qt50J31G5CY6ciyQGyQRBLwkSYjgctFq0K2SNpxyycd5vyPpJniERiSoLGYVdAhUxMHpUydV1R3zzgYDHj8GDD6ZMtjx+vWW62KOWEya6kDXdF2VQoUz6d42PP/OkM4G9ifBxV02ikhteqXSpSqyKfnjN1M5EILArjd1XVLJcb3nnnPfq+Z/CMHz8+4f33H3Dzxk3u3X8FrGG9aTm4dkhVVRJFKcVmvSUEATdY64gpsW1F/ymEIHWrvhdwTfkOg+dNzkWiocCUdUGGpbBHZYR8bmwRBpYMZqcNFYIYVLJwCHbBc7m8RGuh2rl+bcJyueTw8JCMSN9UTUNMkW27IeVEZWsOZ4c0TcO1a8ecnp2x2Sx57f5dHj16xJ/803+au9eP6TYbrIfz737Iv/2n/1/ieVcQf5neJLwFHcUx+NEMDVgoEarMgUhSa4zrWRxNOboO9Uwc2ZwkZafII2O58GYGRINM0HmowYlkTO/tp+1zGpy6wLVrc9566z6b1fs8/PAJy9UFPhxijKFtNzR1hdGOVPb+lMQJS0kAGsJiXzgHs9TsfYi0reXsJPDNX/+ADz+UkkPTeCaN5jOfeZOf/soXmB0abGXwMbJer+hDy2w6YTozOBcJviPkDdv+gg/ef8DD9zMpNEzncP0U1ptr3L8/5+igJkWP0WDMy+1Pn2ojhQ7iJWNwRpNDwG+hrw2NcyPJpLMNm7DCWkZBNmMVs7ljOnM0E01VO3SqUKpi23nOzwOr9QXLc09tA0fzKRNXE4MnpohRkJEi8QhtV4OMQ0lH5F3k8PTDGDNuKKMBI+9uXM7kHEo2TWGsZjI1WDtlunDoqid+uGG7zaXx2IkXmZHwIYcSRnw66JN+1CCP50aMT0V7o4HKMKQitVIoa/AAWnG5XBJSxGBZrtYsDg6o6nqsXW02LcY4QPHo8Qnnl5dM5zOChGfMZnNWqw26RGjbzRbQVJVDKUMfdkzjdV2PbOQxRvq+Hw1XThlt9FiQV1bhrClclLGk/STRq5UipCzcekE2ydrV9D4wn07RyoyihSDRne86Fos5m/WG2Wwm/TzK0EwalutlUQIG7eQ91lqsqzg/O8P3HR8+fMj9e3f5f/6zf8bNu7f4iTfe5NbkANZrmoMDNpePACGc7Q30BurCwPGjGQpV2F+UkjIBSprxbdVTTSyu2QocHIfIqatCF1UkOxhozSTRP/ZrFtTx6AQVcNDY7gEkPMZZbtxe8PqbN+n6FevNE7abY5Q6LA64NP7mpEFZhHFHoY1QNRnjMKaCQoKQciDEyHZV8eDdDeslhLjEVGtsnfncF17nS1/8DIeHE7q4JXhFjJ6260X9vHZSm1cd2kbqJjGfO6bTOTGuaTeR7dazXresV571RcNbby04uj4BpT/WORzGp9pITWZCceRDJCZh5O3byHatqZ1F1yLjXtcTct6gtSXQ4yrLZFpzcNjQTBXWBZzL1KYiY5nODZPJIY8fe1aXS9aXLcuLjombiP7N0FGO8JcN4IuchpxyMUZ7iJ1BSGxgj4ad7s7gpQvNE5J6JKM0OKNJKULuMM5hnaaeJTAVkQnvvrOh3UDOxdMbalA6lLzURzE8//Yde2WnH8m4mubbQ5XtnZsuUG9ljKjBAI/PnjDgSK1zYkBSEmSeNiwWB0UcMzNpGibTCcoo1stzvvfOubBLTGfMZnO8D7jKjBx+Xbtl24cyz3Zpyn3Z77qumUwm9L4n5lCUovPIDzgIGk6aiXybQuskNQMlUPiUpO0H0ZKqmprtdsv86JDttpWoMIsW0vnZOTlnDg4OODk75eL8gqqppB4bIzEluq4TklnrODq+xuXlGetty9vfe4fr9+/wrUeP+ZXf+DbX7YRX6zn9+RmTnDFkkooEDUFlnNYQf1ROlxJYh4qAFhFDlYrDKWs2hB6tRasrp7rUCjVKJ2L0EtHsyX1IJmiQGtmvheW931UBT0S0genM8fqb1/Fhxdn5Q9puTd9PhQ0kU7S/DMZorOmoJ5a60egViFKAI0WNSgmMnMnJw8j3vrVleRpIecn1W4G3PvsqX/zcGxwfLahcwrcJHwK+94QIxji0rgUR6ANaKeq64uio5sb1mvfqB4RWE2Ngu848+iDRLk+x+pTPNddp5s/0Ab1wfKqN1I0bR6SYWa22XF6syCkRfaLfevom4bTBaEm7SArDEKPCOUPTVDQTR1VFsopkAq5a4H2Hs5rmWo1WR1hgebni8qLlYJ6oG4HxCj+WIH0K54J0yw81EJ1LnjlfkecWj3MvL34FhZdJhSZF66HnywPiDemSz86sObxmCfmIs7PAtvVSm0uy6TDU3EbwwFOgCZ5jAD6q0vxbOMbrsd8nsv+3p4reQ+9Meff3fdz947zIw8u5MFMPm0v5eypQb6UVm80WpRW993jvCSGWplklnqx1WFsV+HAiRaHwunZ8jNKK9XpLyoGu30oEk1RBCmpcZdh28j6Beu8JDO6pqYoelKZqHDFKyggkmtlut8JMngJd19J3sO3XKJ2pXEVlRT6h7Tpmk6lQNJWH1oZ33v4OMUYmVU1V1dR1Tdd1pU7RYevSkOyViCp2HQRomglYTUZRNxPaviWjeP/hY9K04Y23Pg8XK9ImoAbuugQqJyGIRn1sWvdlPfPvb+RxXSk1Vr4ga3IybNaKJ489de3Q1yzWCOpPa03KRYWYVIBbQAFMjW0o+2t0BIfk8nshl1YJbTWH1+a8/uYN5qei+Nt1Hc5NS61Sk7NFq4S2Uk+vG/bQyIYBf6IMLJdbHnyYWV2K3t6N2w1f+T3XeOuzr1MZRz0RMoQ+9pA1IQh/oFJTQpixXTm8l3OuK0e71cRgaTeBvrM4N8HZihQC50/gnbfPOThS3Hmtf+nV+qk2UtOZwSpHXQkB5/n5JSkm+i6zXQvaaFpLdFHVFu87ybVHD9TEGKT7Hsndd6Gnqgxa9VhruH48IfWRzbJnuw20faCa2jGPLNLZZWEo8fAGwTClEpOp1MUGMbihCF7XshE8HVHFNKRUisFKAZ+hrhqsUeQkdTBrQRvFbFYzn884P1/R9woYBMsQpOGLZkHOEgG8RIrtKiOEkqjuOW/b3+B/UKm7IdsxRJryx7LAtDBlD5RNP2j7mnMeFWl30W4eQRgDck4AKGIqc05ko6ibKatui3aOTduKfEtWVJOpzJmYsQVqLsZG0fUdi8UBN27MuLi4KD0kAun23uOceKyq1JIGHr1Y0nDDHAohEGOg6xPbLQV1ZwhetKKsNuSY8F0PLtN2LVlFYg4il6Ek0o9Roj9yxuheUog5s16vmU6n6AwHBwuenJxgjGG9XuOcMKvHFMWoOisksxjRyWoa6rqi7yva1qFUJjvLatPz+MPH/NTrb3IzGd7+4KRkFhROGVBSbX1RPWow0i9mLRnm8fPf/3IyMoOmlCdTKJGyJcWK5CvOH3e8bVu6rePm7SWLQ0vdGA4Opwh6TgRYZb8o/KDYkqYTAuzduQypwbx75BKNW4ui5/qtCbODO3i/LSARUX4IPpJThXEa6FGmZTIT7bqcYyHfdpADKSmW657Tsw1t13N4WPHlL7/JFz4/YzoxaGXwQSDsCcV63bFZ9SzPW3JoaSov4I+Yy1ptySny6NE5fS8sPGAIPqHVDJUdJ4+2fPBe5vrdZpS1+7jxqTZSIbY0E83cOHSeYVViud4Uz07TTBrUtGE6dSwOJlycr/AhYLPh8nJJSI6ca1ytmUysAN+yqGganbB1xbWjI5bngdVqw2qzoTmYUOWAY5fao0B4ZWF7UAlXK+pG45ykCAZPd39DGeoJsJ+LFmNQzJcwEmQIMaGzEWqRZAlJE2Pp1UgDIGP/ru/JnH/E+CQG5WVfOdAqDcvtNzvG46p9b7NQN/0AjeL+Zz+vT+oKenBI0yglzbtQ6Ks0PkUiMJnO2G62AoxXolBb1w0p5SLLkambhpgCPrScn19yeHjErZt3aFuR1dhu2yIoWNRZt32R89jNo31nxxgjIpdEUvT4vsVnJcrBoadyhd8SiQo10nGXszBQ9LovUhGadrvFaI1WQlK72WwETdh13Dg6Frn6nGlbSQFGMpVWNLbBB9k0K9dwMDvk+vXrzOcHeO+5vDgnhEDvO0yEAzehW6/41f/2dQ6TxvoeZy0pRImkYsYOWlHfh0fyUU26u6nzcR+aGZt5kVYTMKjckEJN8PDog8D56UOOb/a8+RML7t2/RQgOpX3JqAzsNBqlhPNvlyQoJYM8RFKD80u5t2WrzgmlgjjT2oqkCpkQRHLIWoPvwIeerHqqJlJPEkr3km4semWSnswslz2nFw/IGn76Z77ET/7kEdP5iuB7fNgSY03nI10LDz644IP3Tjh5tCb2lsYeoqhIUYk8h7FoHdhsz+hahbOQcyClAKomB80mtpyfJ7yv0dXLpW4/5UZqS86OylXoeYXVM5xTXK4QAbDSlOus4vCoIQTP8nJDzrDdCAAiJ5jOKqyxZJulHyptMWisrZg0BxzMj1itOjrfE7IlpEBWlhgZjUhOMlH6viUTmUxqFgc1deNQWcsijlFgxHubyr5w40CkKmM/jQgqKyEIVQ6yottGVheZrk1FgVgiOCE9E4ThIIb2aR47wtlnU5Y/jLGPwnx2YysOhCpA6FKTSlqTVGI+nxEVbNotzWKOdRUnT94nhMhicYD3AWtTWcwZHwW96X0oIoSGs9Nz2q3n+vXrHCyO6L1ns97Qth2buBUCU3bgiSF6Gq6VMQZTmLCTSqhYCFyTSIEIC0bE94XdQQsCVmWJBEMIIg9vjKSsSkR569YtHpycEGNkvVryxZ/4CX7jm9/k1fuv8O1vf5u+75kfHjA/WDA/WHB4NCeEHt8nFJrNtqPtTvG9lwbTDCFl+tUai2YyqQl9x5PtkpnO1JWsiypkdBCI9o92Jg+gJ1lSJR4S5G7SaD3BdxvatmdxrJjNZsxmU7SGkAKVMyUxXSIo3OjcDl9siKKGuSfC2QPDiiZlSekrE9AGKWeYuhid4WOkrBBzRKmeuknM5hpXZwZVaUE4R/pe8eRkhdKXfPHLr/CTP3WD6TSRvKbvpLQQQ2R5Gfj22494++0PeXKyInQWnStam7F7qe+cenJuSSlTuQlKQUxbQuypbYOx0tDcbjtCn6mqHwN0nxrkNRCZ9aZSqIOGqjb4DNpqsvIorWmqCQeHM3wf2WwCSjmCz2w34nEqPIsDR12rEb2Ts6TXJpMprqoJsScRSVmQOSmAdrKYYgyE4EnJ0zQ1h0dT5otauvlLT8WQMokx4r0f+dEG4TMJfPYjKUWOkIsXGRJ0bU+IcH7uefKkY73yBWZc9HjGLbwII/42qTV9P+MKvVNBSv6wUPX7vVtPgyV25yI1sSHVp7Qu6TeJaq5fv04/dYRguf/aawBMmimKllSojfq+p64l5VvXDaCYMOXs7Ak5K6qqoet6lpdrwiQzmUyYzw9E2t01TOcyd6TeFf7/5P1ZrG1betcJ/kY3m9Xuvc/epz+3iwhHhDuFySzKUWRKpcRglH4pYaleEFiIJ8sgC/NgWUIleiNe4AEjIYR4KmSJV0ACg0BIEIAxqcQ4HOEbcdvTn92vbs45unr4xlz73BthO0yarAx5Xu17zlm7W2vNOcc3vv/3bxiGYf/cR2p6yokUe1Ic0GUuImyxRIyBGMfXB8YZMHwiaE8pSQGIITBpWwDquma1WpFz5uDggHv37nNx9l+5c+cO/+k//Scmkwm3b9/GNTXaCFmEJF3WdtejLlbU9YS6riWQ1FakoccPQbRmBiKJXieiTlQAFjQWGzNjuuL///Zcwu7bS/BVsW7KobB8JT+qaS337h1xfHKrdDsJqzTaSCeslcZoh6IGNMaOUR2xfITx1zFCfXIZ6uLCLrBdVqO8QFifxgAqEKIvhC0FRGyVWBzULJdtcUmXeXdOia6D7TaxPNJ8/vvnTBYbCJboHSpXxJS5uFzx/vuXvP/eOS9fevzQYGlJ2eGzXDvOZtCRlDpi7IsjjwIGbBVxlSL6HmEra8KQ2e08uvrOyBPf1UXKOV1ydzJWC6Ol1hpTNfgMKSu0jkI4yIHptJXWNG/YbQPRQ58zwUfIHmOgqkBVimwio9i3nbQ4V+GHrcyFFOLiSyrtuS4EjhUQWR60LJYtWge0tnJRlrsrhHCzoPiI1kUIqRVZjV5WpVCN+qok3dSu33F9uWWzTVxeejabTLcrprdFtyXXtmLMzPrdLFCvF4j8Gpb37TqbvH8dr3/FiLHrT31KnDNGQgI5FxbUa53gzVbxUz/v0+SQT/MCP/01v/mz3f/rtSL1aZLL6E4hMz3RxTltIHtUcRCvbWYxX7K6XNG2LZO2xVjHpJ0weNEo1XWNs3WBgKFpGjabTckaklln33u8l0wpVRJYtdY456iqqsxE056x93oHGGLH0G8JXmjG4jGoAUeMEqkBYLNDW4Wyel/MyJmmadhudsymM0KIXF+vOD09JWvNF77/8+ScuHPnDo+fPMZYjasqgvdsux0+eowReHsYhF0oRCD25BdXVdSxga5n2G0wOqImFaHWoDNXnZckAm3RPsOQfwdiihu6983pLTTwrNhHwL8+8/mECF29drHnglAAuRSp1+yRlIoCpdGRWXNwNOPuvUPqWuY5rnZYLbZTzlVijxQ13gdiSBgbywy7XOpKie0QCbFJE8KFpiozrNLJZblOBfIt7vG6GPCmWLowcFZzdLTg1rFnt/ZAwJgGHxObjeSKvfXZO5zcq0jpGsUBKWhSsmy2K549f8V7773k1fNEt7UYXYNqSElhrCJr2ZhbE6gnAY2GWJOioEcoYV5ro0mD5GmFGAnhJon5tzu+q4uU1U6w1ZixzkhmjtZk7yElnBUnMF3iMDCZybQq3cyKwQsTZugVWlkJNKwtVeWIaU1QO1y1RQ8VVleEocImS2U0KjsUmZy9+PNFTYqBtvUcHCRmM6iKHiblhNJgnSakTAwSkRCTIYYKlSuxVrHl4irwi1IarBSonBShjwxDz+n5lqtrIE/IqSaHAYERxANQGyeOy0XM950AZFpJAqxC7uHXd6zj7CXnDEZmYHtOnVZkpcmjTqwo/dO+YFJu8oAU/VzIA5qcDSQrjCQlwY5JlWKbKT6GGqNKBEtSRALohDZlmpLHTaf4Ko7O6SprlBpJLGo/R/p2h6ydN93I/jXz6WG6/OyMImmDxlAF0cQ1TcPaS2FRxnH18pLZbMpHp++XmPbRLV0gubppmE5nTCYTyImmEYuts9NzQow4WwFjdyfFNQShAefC4hozh0IheOgC92ljhCJsGzQBZzIoB8qy2WxxTgktPCZchhg9OimqtiXGgaayxGGgdhWPHr3JvXsPUMrw0UeP8b7n+77web7267/O8fEx7777G4QwEFPAOkM7ndC2LdpY/OAxamDjt0Q/gHOSBGBkUXUAbUWvevrYo3rZAHqduFQDk3nDepfIMdIaVa7LG63h61D5J90kApkdgiRUkGspMFkhWVAeSa4VizRh9yaMFoeIECyKSjYMxpPVlpQjUbfEBDHLHFp8+DSx31E1A9pumS5q6jZgbYt1NUYbrKvp+4GUNUOXRDe0Guj7Ae97jDG0bSt/Tmpm8wpjPeiANgFjIiSJjRe3m3KNK4Foxy5frhNLyj2EjMoLdEzMGrhz4lhVPUZ3aBY4PaXfveLoMPHWw0dY1Qga5HdElUg60g0bQhiYNIrZPNF366Jwcaik0SRy2qHcwO3bc5aHC2azihg9r55veP6sR+UFOTpQU9CZENdkDTHWoKvfdl2C7/IiJTtLUfsPUZhMPiV8kItda7XfUCkjym9jFdZWpNRwdrbFDxltamLMrK+2qFxR1zMm85rAFqsGlBbfPZ0dKqkSpCcsK2NlVyOpp4qDw5bDo5qmVqXQGGTgWtZwlYUOqqXAxVTgGpWJQRJcx920puyYkuDfVaNZHk7ZRcNqu6LbdlhdYbURrYIuS6hCIMvfQRe1h7C+7SfVJ7+w/EUMqPdbwJtPFnhOeqZxlyoFIzOyxoT5IzeaKlEMRSQ5doVaCmfMWexe0rgLliBIRcYZgdyIZbBdnqP4Fqb91/9WUNFvVsK//cBdTmRSslDZAscaLF1MXGy2mAx5O3Dw+c+gge1mQwjy3IYg/orG2r2mqW0b2rbBuYrFcs56vWa320JBuUbZQoyZWKyQXl+kQ3Gc2Fv/aIm9CFlmoGEQeFBiO2qsFsLOMAhrz9iEsoYcPBoY+oEUB9549BZ37txhNluQIsync/7n/+kP8bWvfhU/DDRNLR6C5XxlFalqS1VVVK6l0wOkLYP1BL8j+J4YLEYXxmvOZJXp0sAw9JgYqOoK4wyT2SHNZMa0B3u2xqw9Ovzm2PXrMzo5p+W6e71Z2p/tUIrUIDv8LEGFcXS4V+LwEJInpw5te5RV5Oj3mymyEJMEaqsliiIJXFvXFcbKZmzoA36wrFeRi/MVL59fcfpqxfVVRz8MjFqrum6pXMV8MeHk9pJbJy23Tloms4YYt6SgigBb7y2hoBCI1Hitlqw8JZCuyjU6ZVrnuX9nxnqqmLSaHCWl2bnMvbtTZpMJKThJgdAdmZ6qqjjSR1TVkoNlx8vnKz5qLjh/FYhdAqPReOZzw+17R3zxi484vDWlriNDXHF0a4I2Vzz7CBTTYsTbk/WOdj5ntlii7e+BPKmcJbnSaMPQR4Y+iD9aGGRoqQyZgFIDRhm0AW00rlIcHE4YwsB6NRBDIASFDprNJtF3DZNZRQw7khoJDmICKfixdGXjPGmcM1VVxXw+Zz6fknO5EV+3KkKVizkS046cO3EM1o0Mu3MuA3QlA0k9Dmdlx2etZumm6GbCtg88f3xNjGthlcVeBLwjeULJTvwmPOvTsFj+1J+/26OrsTiMmGCBH0u3opUVUkgWHN4HLx1SgYVEpB8ZbazGAEClLBlT2H3SYcaYiidjAjWA7hEI0aJ+JyDRt8yiPlmgxGECstLF4uaGgp4omyLEhHjIHjLMZjN8iHutno95n/2jtSaEwNXVFZeXF0ynM46Ojjg5ub0n2fgh0nUdm82Wvh9KftqNRup1OHLsAkkSxJiUUNS7rrvxAEwZo9RrcGEAFagqQRicrfA+MJ0u+NKXfojnz19w794Dvva13+Cdz77N//a//29sthv+0B/6Q/zHX/5lLldXZCNwn3GOkBKpFwPUYQh7AbsY0nb7YjLOY6uq4rA6kiKlFK6uUFbTVI648/QhEYOnMRqVxnvqtzsMJJn3yU5NXuO+o9c94EEFUqqJUTonlWRmo/RAzlucM6JvyhqVK0aXCaUiFAYkyqJUBVGR85xu3XJ1EaiaRF03bDY9F2drnj+75NWLFRdnPd1Oo3IDtKC7Mvvu0XrgtNrx4tk1t+/OeePNE+49OKCdHqCNrAHf4ZWMJAfLNVbVluOTQ6bThqqq9obb88WceirZYaFs7E3Z9BkNVWVZLKcYPWdSn0A8Y7d+wmaQRHKlPce3D/nc99zlwaNbVDVo42nzgtreIvpDLl59xG5bLMHYYt3A4VFL06oyQ//tj+/qIpVQiCGsZtd5Nmu5ma2zNE1FiFZYQcqXoaRCWDIZVxtu35lTVyuurtZstwMxtmw3ifW1ZzZvqBoxcRWISj5uRiRqvyiNg8+mES0IQErxNThC2gqtNdY5MjLAFnmDJ6MI2cluA9kNWwPWCKacFAWfTmhjmC0r7tybs15tOH+1QuHQdoQxKPMb/VsUqNET4dMZW7/Lh5KuSIpTiTrZlw3Z6Y66k7pxoDQqx1JsApWVFGKVRTMWoydEgWQUFmtqxJ3boy2Qhf6flSephM6T/e/8LY897TeVwfRIP7+B/oQcUbRxusCfpXlMZNCgrUUT0TmhlUCATdOg1PX+Z1pj9goYWay1FN4stkanp6dFTyTf29QTJpMJbTsRQsVqsy86Md50VZ8osEpJpdefDM/LKYtUohQz2WQ5tBHq+jB4yWYbIj/wA59BKc2XvvQl/vN//hU2mw3n56c8fOM+f+R//CN85Sv/no+fPkZbSwweZSxJKTZ9Txw8OYo57UiLr6qKEAJN07BYLJjP56Sc2HVbtsOaGAZSlPlZ9JGrbYfqenI0TFOmj4E66+9oI5WzgezKv0b7Io/Ssfw9lMezwHa5xtoJKWZ8uMJUG6azyOHRgr6ruTjN9L0h65KcgMDQFJukYQhU1mLtIa+eB75mT3nxMqMVrNc7rq5WrK46gleQaybtlMpK7lg7RayLyoxz8D0hdmw3W549e44yA3fvHzKbj4kLv+2rL8W4FB1tStERREd+T6JyjjlTMJqY5LqxVsYMzrjCVO7JyUgBR8scPiVSCigdaSfw8NERj968RTtNxLTDWIPOhsVixr17Lcuj52y3K5LKaDNw+/6Mh28c0rSZ7eC/g9fzXV6kFJrgM5vNjovzDUOfiNHQNFNUbghDEhd0I6m6KLEpAVlE2tZh1IKmNlxcrNiuFEOX2G4D3S5TN5L/EnMQfLi4SJjXOqjX4SARM8oSLH9mYhqA13YpqoZs0CpC1qSo6H0WrYqSC0YTMTZjTcI5sFoX3y3ZwYccsVaII0qDivm1XYnaQxE38Nvr79qn4KtPkBF+t6mA45C5PJdSqPa+ZzpibMSqRMwbnDPMZg2z6Yx24mgbKxT/lOi6nt12x3Yb2W4Ghm5AkTC6BWPFlUCNljPxW1/nb3GMsSO/lZjzE7OQPcQpyAtaOgnX1FQJlArYLCQE730RHCucczIsLqzAsZsQA9BSzAHvA31/zfX1NXXVlq8zNE3LZDJju93SdV0R7sZ9sQpBOpeUc3EHl/dk9IkchgGrDanIIJQScXYs8R7OOpy1HB4s+AP/j/+JlAqEfbDg7t3b/P4f/h/ofMe/+jf/iiePn9JMWs4vLnB1hXYWZQTqs9MZR/NDZpPp/vduNpu924W1VtCHEPGhsBT7gW67Y/A9kcTgB6baErTGThpC6jFRXPF++xOqSuc+wr0yD5VNE6WAKUgaZSpSVsQgFj6oxNGx49E7S05ODrk4hdB3hEEYvOWCEZBCCSSdfem2lGaz2fH4w55XLyPaZKpKM5nOefTGLSaTmtl8SlWJ52LlLK5SWCfkKescfuhZb66JaYcynnYykLgkxAnW1Hxn92csG2pV/hTihzYimZGOW9zXYyEuWWswFsKQypghk7MmBug6z7NnK548fk7X9YyF8OhowZ17C9oZ2MrjNBgDMWh01mR2GDeAXmOt4uh4wue/+ICj4wale4z6PVCkwLDZ9lxeblmvPCnKYp6Cpe/HziKidLGVceCsEhV+U5Njpq4MlbVoDMSd5EUF8IMCHCnKSU5ZmCrj6EUVVkAqLhFSgG4SNpWSMMasBmL0BbtuMaomImSP6BXDkOi7gZ33+DwQU4ScMFo8wSpnaOqa6bSlbiqMll370CdS0hhdkYIlpxJjoGTnk8dBsZYuz5SdWhrNRdUIxd1AW6/7wb1+fDvLoNFpW43d4v59eZ0hlUuuUX7tV4kNUM4DKvc4l2hazeJgTtNalvMJ80XLdFpRVwZbDHeD9/Rdz3YzcHGx4eXzFdfXKxnI05CzIWeF1TUkQ1YRubxvisvrz/+TMwx5L/I+Gyy/9nh5TVJbMChG4CVrTdaZqGDTdzTDgMfjshRW5yratuXi4nK/OO+6YU98GB0tUoqEIIJd50YmqKKpm5u5UwhFTyUQnnOOyUQ820IINwWqfAwx0Pkyc1K6fL8UhDyy/YxBKXDOFji12tPgLy6u0Fpzfv6KFy9eMPiel195QUxRRMmThsvLK+aLOTFDUzdMplMm0yltM0HHXIqgFKndbsdmsylUfHlftNYMcRBxs4+EUD6yuHYnpdiFQK5bbKtRvkPFb91IfPp6Hen2N9C3vJ9aVWIRlV25txXJ71Bm7LA8B4c1b392yWe+MGc2a6iqxKtnivUqMWwtOYuebcyVUkhuljJ9uebEFms+X3Jy+4CjWxOWhxWTqaJqMq6SoplV3K9FcoozWgdCSCyCQ2mDNiLczQS0CijVfMtr/ZZ7srx+rdW+SAkhKJeRRRYpd457tqjMwBXjZtr7gPcJ7xXdJvDi+ZqPPnzFq1fXeJ9kLdGJ5eGE2cKh9ACqx5jxPtOEsOP88ildf0o96bn34D5vv3OfN96+RTIr0D2SHvzbH9/VRSoE8e3bbot3XTbEpNluBwY/kLKorJU2wqhyjrp2EtedMpWFutZYU3N46AhBCW03eGLIpAhRRwyRGHuMKTk1GUaa9LjQaT0ugiNsBJIvNRCzx6qWjCEGQ7eFzTqyWffstpG+D3S+Y8jCIpJbSqDFpnbUlWM265m0rTgam8z19ZZ+hww8o0FljQQ8QvCFHQhgo0CLWZzfR1GkrLsjqaH4vxVG3rcrUuORil5lnAndfH70mBi/P0PJWRXsPpPSIDMmHbEuUNVZNBwHDccnU9pGU9cGV2Xq2lO5iC1O3iRFCJZ4ZDg+cRwfV5y96njxfMvV5QpSS4oWRSOwqQJM3A+Vvx0J4vXCNUK2r73qEoY5BtKVgvXa59GqNImSvxRSJJCwWTEMnqurS5ktxcikbpjNZrhakqLj3msvE0IRCGtxdnCuKs+rCG2VzI6GYSCE9AmYTykpbONrGzt8YA+zWX0z/wmDOJgLu0/eH3JEqTIr84HZbMG7v/FN3n7nLd7/4APefffXaZqa+XJGyOJUoJRiNp0yDJ7K1Rgj4Z7D4IlhQ2Msvr+xU7JW7Jm893Rdt3+OXejoY0/sB3IptCFFqqYiZej8wFoPqKSYKHCvn6F8Mxfen1OEhKR0YA99IRvOHEUbmZMTKjWarDYY5zFKsTioeOd7bvPZz7ccHAWMVcznlukMlB7QuiYESUDYXwOAsZmUd8SwZnlkeeOtY956+za3TpY0jUbbAKrHOkXOA5DQRklxI5aCoguMFjBWOjRhauqy6RRTgE9cga9dz58gjIwM1xGWTjduFzkntLGFsn7jdiPp0gGlDH7Y0feJoXOcn+744L2XPH18wdApwKKtoqqEKV1VBmOiIEdqlEEEVpstIa65/+iQ+fSAO/fucHRrjq09m27Ah474HY7YvquL1DAEdrsBP2RyNhhTFUpuIOZAyr2EEKKARKcjlQtUbiD5zGLe4LTGOkVTWe7eOyAlxeVZTz/0eG+pKs3gd6Q00E5bjLEFl85lAbmZB3yLf12Wm8Zah9WOMGSur7ZcnvdcXXasrnv6TmZlEY9yQykiCooyPOw8Ww2bqx1V5aQLspnBZ4bOQq4R76+bhRTFvptDS3dFzkITtrZwGT5NovjO4bHv7BjZRqp0KWNXG6gbWBxUHN2ac3Q8Y7lomUySWFMVlxBtKBCUEGMUeh+1UteZ5XLJw4fHPHuy4sMPznj2dE3fWbKyKF0RQsaoxG9m+Dbe1GPnEWPYF6nX/QrHjrk0U5/oyka7X58TtpIcpZACQ8i4rJlOpyV/SdP3PZvNhul8id7TxE35XMduty1Bh+IaPhah4NN+E5BSfk2Im/fFasyTGhl/0knJc4kpkUIs7L4k8R5lYe/7nhCG/XUw9BKvsVwc0vXS/XzwwQc8ePCAzfaabreRbczIblSyCQneF1lPRg8BjWGXE7FkXllri/egOLGPz1kXp448wqjWYZWj0pmqrSFGfL/iutuhs6H5TqAulQvDbYR8ZWefs8YPsiHTCjJB/PTcFuN6bt2qeOczR7z1mUMOToK4OihN3RrqSSDrS0KaiJTEamIUA11bif4spYCpPG++fYsv/uABRycB5y7JOe43Dlq7ommsMKoWn8TxeSfIMUnApK5LirIuALAiEfmEXdJveeeNoMW49nFD5Cp2/THJ9RNVYh/dkSIxRYYhM/SKfqf4+MMzPvjmKf3OYm1bNqJxf4+E4IkR6lo0ZCHIczQmcf/hMW+9PWUyWZQReSLkAesMOlcM/v+E0MO//tf/Oj/3cz/HT//0T/O3/tbfAqDrOv7cn/tz/OIv/iJ93/OjP/qj/J2/83e4c+fO/vs++ugjfvInf5J/9a/+FbPZjJ/4iZ/g53/+57H2d/Z0QoTBJ2KWwaAASxHBW+VfemRlIoakfT8w9AkVA1YnjJKhoNYaWweOjqd0u0jfd2QmGKPZ+R1KR+rGISFipQNRRcnP6FYss4e874USWouZ7NCLm/rZqzWXF1t22yDQSiMLVSajncUYjdYGVYaZGll0hFMc8Sni+0BIhhyLoFRrkpbdsHVj55FIMZGyLz9Ths7CrLvpev57HloV7F+JuNPViaqGg6OG23cXHN2a07YOa8GogLMSG0GSRTeZXO4zUyAJgzaqxB4EJq3jjbcWLA4aDg4v+PCDC7bbjWiktP1tX+HrAtjXbZBuumO9//d+HrWn6Zc+VEGIEdvUbLwnqoj3kaBkjmSMwQ8D7WRK3/covcHVNdqYPfNOCqRcD0ApQKXTyno/5xRSw42t1vi1rzug713R5Ynvi578nljUdPJ9Avc5fJD3e9d1LJdTQBF84L33PsAPA69evWDw2+KGoNHK4lwli24pVlFHhs4TM6SQ6LstVSWi4zFA8XXqvDFGZri1RTlD6ntyFNeFoVDnm6omN57uekNHRVLf6frw2qYrF489ZIYrgvk1SkecSyyPHPceHvLwjRNu353RtD0o8UcMSfgnk1lidtDTh4EQIGsHyWKNJQYp0q5SLA/mnNw5YHnQ4KoOVEDljLEyhx5znhQ1RjUYZcn0ZMocERFtKIpLTUnOHZO0f7Mi9QnBOXI+8r5A6VKAkJ+lZHOVy/oi3RaoPM5GKWQJx+VFz5OPLxm6CqsnVLYlRg+pxw+R1fWGrvMs1aQ4q5syAxPi2fKwISdN122wxmGMIgxCEMqI48V3cvw3F6lf/uVf5u/+3b/LD/7gD37i8T/7Z/8s/+Sf/BP+0T/6RyyXS/70n/7T/NE/+kf5t//23wKyE/6xH/sx7t69y7/7d/+OZ8+e8Sf+xJ/AOcdf+2t/7Xf0HGLMe8YeypDiKJo1uAqyMoSQCDGQQpI47CJY7fsdXaeYTEDpqmTv7JjPD1kup3R9V6Bs0d80bUXbNGX2M7KzKNsWKVI34WbjbleRoyGGzGbTsV7tSkaQDNqrytI0roSSgatqWUT0KELWsjMpLsMpZoZhYDXsWG8DfURIHcpgbdk9qkAupAlVClMIAaM11Tjv+N1umn6zI5tygw1Yl5ktKpaHirv3lxwetUym4oSdYkCXoZXRmso6corkpMhZ9GlGVxTwnoSni1tSGmgax917LdNZha0NH75/xeX5JSk3N0VyPGHf7il+ijDxaaHoJ6BPVUDN/VtYvldr2knLZQyYymCUbARSSux2O3RJYQ4hsOs6ElDV9R6C6/skupbSmYsX282cQWZOkjqttflE5/5JEevNS5VQu7yfCe1dKWLaF1r5GWOXJrEhi/mSrhMngg/ef5+u67her2nbiqHvmDQTlM6kEOS2KzrFzvcEn0qEmeZguWS+mDKZCDsxRokdH58HjEzJTBd6EYRFESv3YQCn8MFTNTVOGaoho7aw18J98iR+4hzdHDcEopwh0xHTGmXXLA8cDx4e8ebb9zm+M2e2AFfvUFrmxylW5NxSN4aHbxyhneKjj685fbVidbUh+QpjlhhqYhDN0XRqaZoWq6cYJqWoJ0iSvn2zPoiJtTKJlHZCmlEZtDACJUBVpBaiNNSFWPP6RTyyN177+/4wBQFQN0SlLO+BUjfFS+ydEPJHokCDCqUcKRjOTtdsVhGr54AVW6YkqAFq4Pp6zeXFNYulxei2XIuRTCzp5R60oW41g+8wtsJVDusdq+s1T5+sv/Vcfpvjv6lIrddr/tgf+2P8vb/39/grf+Wv7B+/urri7//9v88//If/kP/lf/lfAPgH/+Af8MUvfpF//+//PT/8wz/MP//n/5yvfvWr/It/8S+4c+cOX/rSl/jLf/kv87M/+7P8hb/wF6iq70yFDAWqiQaV66KAHqiqyGxumc0nGKPo/cB6vWV1nRiGBNpgK0U7UVRNwNoBrQwxRLQFbTKzuQgttZIdhzGGyQRcJTqZ0RNvVH2Px82Cl8tuHMiKGMQaxlnDwcFE8Hlrig2TxlhAaYypIcuFajQYpYmhuJ9rBxEGH9mEwOnVlpfPV1xd9pLqSkZrGZhXrmI6nTCdTFBacXFxifcRpWQwTlbFIeI1mx+V0ZRd+n7hE0HyDY1bldc+LhTSUYplz0jXHnVJoxmnuIHcOqq5/2jK4bGlnWbqBoz2ZIRmjxJdj0KjbU0YBtGuYbBKXr8qbMiUDM4msDuS2QCGZlLxxe99yOHiiK9/9TGnL9ekOIEyC5T7OIHy5BzK5qIqfmiS15P31PKbbklehymvUVGimTC53OYqi06orbH0VFVNCuIIvd3tuL5eUzctMUassWy3W3Zdh3WOyjmss7RNzWzSFHKNISXwweN9KDMo+aiqSMjsNVQgBUEYfenmjORM1hIHkQtVfUzrlbXrphBrJRZFvR9wreXg1iGJwHK25PzyjLrWzBaHhNjT1guGPtD3g9gtpYxWRvKxgsx+F4sly8NDptNJ0UdBCH5f1Ec38HEmllQmqiTvZ7H3ISWSz6zWG2aVUPEzCd/3BBNQWe4NtXdzL7MVhUDM5dzl/Lp/ZQ96w60jxZ0HJ9x7sOTBw2NmixZtA9ruMNUAZFLQKIRcUdeGO3cPWRxOuHv/Dqev1jx7cs2zx1ecvbwqHa8j9BXXVwOXFxvu3LmFsxOU6dBmhzEyhySrooPMZTMp12ImkRhQJqHU6BzhUDSQC6Mv24ISpQLrp/06I24s4z1nQEnEi0B+mZSLXEezv+9lbjV2XPLzRA4yoJSmHzzr6x5yTQymzEnleWuTiTlycb7l/W++wtqKN9+c0U4sOW8xVmOssCVDFHsra43M+LOj2xo+eP+c//rVl9/ROv/fVKR+6qd+ih/7sR/jR37kRz5RpH7lV34F7z0/8iM/sn/sC1/4Am+88QZf+cpX+OEf/mG+8pWv8AM/8AOfgP9+9Ed/lJ/8yZ/k137t1/ihH/qhb/l9fRn0jsf19TUAmgShwuSZ/N1smM8ji2VmNpUdTcqGaR2pqTkbIlpXWDcwmUfmBxmtO6DGqgk5DvS7jrpRNLXCGEUKQpSoalAIhVZu9jLr4QYq2s+BuGHZkBMqR2qnaOvJftdnrRVHhcIIzFqDtSiV0CpgdMCoSN0YTI7onNGFlTShwU1rQvRsh2uGTSAlTWUrkpcOCpVZLGoWBxZjNpydDaASMRhQFpQmKiWMpBzEjUMJvJFURmcpEAJRlEU6yQ2fR2Hk/iaRuULMCasseU8z9xjjmU4MR0c1t2/PmMwSdSueZ5SihFJsg7AaSaqkwhb3+KAwZQ5glBESjKrwbMm6x9jCnETjNDy4s8SlxNfSN3j2sifmiSw4GYFxEJsbpTQmW8hTYvRENexvXtlbSFHS6mYmllGEUnirLHvcXiV6B8kqWu2oqprLzY7pwZJtPxCywgcxlx0dxgFyjPgsuqXQ7cgpYq2lbScYW6FR1FVD7RQxI4UqJfqUZA42DGWoXuZjSYL4tFYlaDHsu6mqqfHFeSJ4KRhWy3UcciJXmYTCWMPycM7qesU3Pvw6MQ94jySy+k5mpyEXiFlgamlWMvOF2CFNp1PaiSPmUsTQDN1NJzeaK8c0nn8wWaFSljlyDOgExEiFYrdd0283LOuWynpMFnp/kzUajc6qyId0WYwNWclGb1yAY+qo2p479yxvf3bJo7dusTyYCexoe0yB5iTKwpCCkSKoIaYBazOVS9w6alhMZxwuZhwsNd9wH3P67IIQjzFqyeriJa9eXvDgwSFto6gmG5S5BJPQ1BAXeO9QyoHK+DyQQ4UxmhQTVgtVPkXZUJIrcpgQvJN5qe5ADWgbsXbUEyKwIKbAbUY0oTkxRviMuU1ai4QlMcLBMiPLDNLZ6S2JnhgtIVghyGD3kSJZ7bDVjkQPOhKGiicfDjTOM6k9R8fi36dyLNo52QSF4MmppusSm3Xi6bOB997tefrxfyd23y/+4i/yn//zf+aXf/mXv+Vzz58/p6oqDg4OPvH4nTt3eP78+f5rXi9Q4+fHz3274+d//uf5i3/xL37rJ5Roj9Iglix1Y5jPHNOJKW0zOGOYT2ssE7rtFu+hctBOFc4FRmDNmIrIGAmdb/zrUhHEOXCVzIw+gSjkG4hodJYWNCOWWZjGOIera5yVQDgZdCfJ/TG2OGmb/S5Hfp5BkW4iIdRrjD0ik6ljvmjgSRYxXtRkJUnECsmxWiwbbt9uqGqh0V9d9pAdMaZSSBBKqhFoMWdFiAmVi8mlKp2jEhNMdC+FpMz99ia2aFKUv8UU9ti5NpHlYcWDh7c4uTNhOjVoE6Xr2nvqZTKalBxXVxtJWA5QactyPmM+EzdmH3ZgwWhbyDCZEAyRhHNO3KVtoD2cMGluY7QifPUFj59cY/SUys3wXhZyVUw5BZgor+1mxvwaeDKe6eKjSOGB7M99cY6wFldXuDzg+4GmaTg+OSkZP25/bbxOEQf2jDejtWRKeaFjGzuQ0cSE+DDqYjoLJYoDtGOvr/m0Ca78Dpnv9NahYsIqU/RIPevra4bgqVwldlwpYZ1jMVsyDAPT2ZR3332XYegJKpWcIocxDoXDOfkYnSRGw9vxMVtZdNaFtCNO/irJcDgjsoRQ5k/l3RW+A2UumLNkSZXU6xgjq82auba0GRF3Z8QPsXy/7P2KvVYWv0tthDzVTAP3Hsz44vff5/7DBZOZFhadUaQyg9EGwAhcqVTZAIh5bFYDWQ+QIm07p7m/YDIDpXuiP+XyVQ84QhJiiXFrlEli3KsaUlD43qCwWOvQNhIR14sEODNFx5ZuE4hBs914fJ8JYcPQr/Be4udRwvwzNhW0qEYbaJoKazXoQELEtqWxEpbgiAjsSRSj600mFWRE5Ygki8vXWqtkY247TCVM5rpOuFrOTwhANOy2kW9+4ynr9TkP35zx4MGCtpb7oWoqEtD3nu3Oy4zryRWPH5/z8eNLdttvu9x/y/E7KlIff/wxP/3TP80v/dIv7Z0V/s84fu7nfo6f+Zmf2f/7+vqaR48elQUzEVOHKWm1ztVYo8VLj4Qy4OoKY6a4ZqD3nXj99YlYaax1hAApeEzDvruRInVD69XqRhU+zk9GRwLKjhvYY7/jDEnrDLnsPI2RHWSBPZRGBMImlUWo0EeVKzduhj2OTdF6ZkgR73u6bktKSixbkoNciS4iSXRAVYG1PbdPWtr6HudnO85Ot6w3vjC/iu0/GVItA13jMMqKm3HO7C1ltMABECAZqeCjaDgXkoKKpOSLODQzXdTcvT/l3oMp07nGVhF0FGq3GruwLEVRTei2O55+dM3qaoNTloODOffuHXLnzlyU7IWuC+CHTEotmhlJg7WZGHfEBE275N79W+ySZju8z+XZipx1GWlVAocVy6WUhwKjfJuhlbrZgIxaqXEGOS64OcscLSVZeL2KWFft51Gjy8L4M7bb7b5gQSkqCshRnoESTztrDdZZUpYZlfcDISXQYrMVvCd4e0PyGK/PkVacEikEfO/3c6hRhO7qmq7rWO22co2bRNcNtM2Mi4sLcpZYmbpqqJyinVQlvNOg1Oja/+3NXWOMpCGjrEDXI3MypEjMkViExlkjBKNYUIjSVo3eg3Bj82SMwSKedTnJpkZ+gHS36hPx67lckxDzmvlB5MEbM9757G3u3z+gnVTA6PYySCefa3IMoKIQlXD44oaQVU9mRyZgrCHFLWCYzTUPHs7pdpFv+i3r6wsmk8jhrRnzg0jVbkmpIQ0NRs8wmGI0HYEB8BiTMZViu92wvlZcXyguTz3bjdi7rbeXdP0FKXeA+C5OZy1VZZjOKpYHE5YHLfNFpp2IeFhQAMNYvuU8jVRzyOmGFUqWEUEucz6dK6zSBKWorGE+10xnQmi6feeYxeGEycRhleL01YrnTy7ptpHdxvPxhxsuLl7x4umSg/mSdtLSTBoSmV3X8+r0is02cn624/xiR7+rxt38b3v8jorUr/zKr/Dy5Ut+3+/7ffvHYoz8m3/zb/jbf/tv88/+2T9jGAYuLy8/0U29ePGCu3fvAnD37l3+43/8j5/4uS9evNh/7tsdkr1Tf8vjxmqqOhOGQbqSgucqDFpJh5ARLzVZYMQ0kiGxWkUq11DNRPgqO2WNViL8pTD4hC0jg8sQgjDlrBSOjAwkBbIab1a5QaSjKkmcSD2VXfy44MnuXUjMquDSFlVEqVkZEhqdFGnsZHIk60BIHVdXa87PzghDRDMhF8YQqQOTBC60XpzVFRwcNhweHHPnTuD6upMsrb5ju92w3e3YrHcMg0eliqRqMpJTo5WBLEUP5QvUF0vxHJ2lBYZTDKAGrBtYHMgM6t7Dltkyo/UgN6iW793PvArcpzFM6jlWzditOnZJs1vtGHaQY8aaGdZqsutIDPjQ0G0nuGrGRBuy3aLdBu9X6Gyo2ykPHs3Y9Ed87dees766xOgZikLbLwzCzEDW8Vtr1J4kcWNMO0Z1yH9qvwjnnNlut/TZk6x0xtvtluPjY54/f85ut9u7XM/n8/1Mab9YaEVdi6+a0uVaVOKYrnLxjERBSqXTHS8wKfbOWDFKTQnfyayHLNTzoe/pdzuGMsNydUXdNqzXay6vr6Sj8ZHlwQF3794l+sirV2diftvUWJ3RhqLT6tEqMjJKx05wnI/FKHoZky0hdvvE3xHm21s3FR7b6GEoTFbK/StQhHx9xBatV43C9EngcEQXqG64iuWk3bD6MtBMMm+80/C5L845uW1p6/HzhrqqSKonBrFFSlnu8Zw0wYsXaM4ZYzXKWDGNNY6QNcEHjEscnbR4n7m6GFhvz5nOHEe35iXNIKHynJwWxNgQ4oBxopcSvWJNjIqrs0sef3TOq2eeyzPNxWkiBi2zH9vRzhSLZct01jKfHTCfL6irGuuMuM5UYp+mVETriDIQ4xiw+ElCzUj02ROFVCFs5ITKGo1sUFUOxNizODB8zxeOmE0PObl7i8m0xdkanSq+8e4zzl9t6bY9xtSobLm62LBdram0x1UOV1dklegHz64fiNHQ9xD6Rq7dPHzb9f7Tx++oSP3BP/gH+dVf/dVPPPYn/+Sf5Atf+AI/+7M/y6NHj3DO8S//5b/kx3/8xwH4+te/zkcffcSXv/xlAL785S/zV//qX+Xly5fcvn0bgF/6pV9isVjwvd/7vb+Tp0NVV8yXihS7veq+63QRFxbuf5ScFdmpBlIODDGSt4G6stQWKgVVZaRjGAuNSjdsmKJJiSmTkkBqo8npeCGMZp9KFRhNppYSrZCF9qmt+OkpIzMbKYOpMGuQLiNbUCOObEhKoXIkq0BSHkUgK4/Wmdlc8yf+zAayWOZLqJnH6EjbaI6OeppWdkxKidddSqKpylmo02OA3jAEvM8iYk7i0yVFSgFj5k3kH/9/a77x6+NlU15/1mVBFyiinmiOb7fcvjsR1lTlhZhhFGnffen9BgDE0HIxn3KwWPLSbPBe44Pi1fOe6M9RCrQ+YGFBmUAI8OzphhACd+7NuXU3s5gblErkMKBNTVV73nnniPXVig/8mjBEcrSQnVBy8SS8bBSK5uf143X3jG9R+hf25liohn4gWTnfpsydptPpJ0gOMUam0+me1Sc/RvwCq8rRti0+iUxCAjTHXbFi1LmE3qOAFKOE6WmNKmzAHBJhGIQEpFQhIHh8P9D7YQ+zWefICupJixoGkod7d+/zxqM3+ca736Db9SiE7YfW1HVVtEEJrS1DPxQh8Cfflz3FnFwMWMveUGu0MfuvDSHsZ3+MXWAumWJFLO6cw2iBEY025F4cw2XcWpiNpVixd0Mc2YqZqjbcf7DkM9/TcueBwtiVEG7MLXJS+NCR9Q5FI6BAgvWq5/KiY30d2W0yKUFVa1ydmC8c84WibYQ1qrKIcxfLinv3D3j14pqqlgQFjSFHRd9rwi5hXUJZj7I7MAM5N1xfwtlpx+P3T3ny+BVXFx7fOyo35+jWIfNlzfLQcXTsmC00zUQJpd9NcK5FZRkdZHzJs9qQUtjbIY1t/6e9Gz8ptcjE1Je33EK570PocZXmjbdOMNowm81JRdbT7zq2m57tRlAcsmXoM9ZUaCxEzdBDv8soK0UwJEA1DCERvFzLMQRS+Dboxbc5fkdFaj6f8/3f//2feGw6nXLr1q3943/qT/0pfuZnfoajoyMWiwV/5s/8Gb785S/zwz/8wwD84T/8h/ne7/1e/vgf/+P8jb/xN3j+/Dl//s//eX7qp37q23ZLv9VROYeaKvpdz66ThXS73VE5xXw+Q6DAjNGWvu+ISXY4OUMIcHm5Y9osqCaWIfQY49FJgxlFujLYMtqiNIRBZkkhClFBTtINdTgXqE9EmhZFInR9MfSUKA2xT5IIaSmiZSaksnQsKpUYChEeJmXI2ZOjxzpQRFxVsZzXaAUHRxv+1v9nTgpidtk2idk0cHJS8/DRgsl0wFmDtbWo7LMhhExTT4T9VUSXIXuGGFhdDZyfec5edVyc9WhqjBFH9S//kXMevKV479c1PgXsHvKROV7KHVUNJ7fn3L67YL50KC2UeKH1GsAJw0nZPUVeBv4eYzWL5YSmcvTrhMo1Q5c5TRGjN1gzZzKbUplI32tevVxxdnpF13u0qzEqMm1llpezxxpP0yQevXnE+dmW87MB66YMfXFxyImsBkp4lSxzZdGUQXza213tj5zZ09DL95CzzDBUKjtuzWaz2TsrjF51Simur6/38xuxSiowcE6stptyzZUBd3Gk2HcdZZ6llcIWAk+IAZ/9jSh51H7lDDEWZmDcL04xRtk4KQhJ/m5L0fzqV79K8Im33nqLly9e8OLlM+bTls12LFSWqmr2Lg/y7+o10pAUl7ptyLZCFSuoMWokZ5FQiIhYOskcRzafBPzFEIjeA4lJW5NzZr1e44ceWxnaClInHduw2aFUhTUWyDhr6WNPZmC6aHn01gHHdxTtpCMmD1GMUbWyJBJaK2LwslDHxNnZivfefcnLZwPbtUbRYowq2j7HbJm4e0dx795d6olYI1mXWR7MmM8XhJDIYY7lkN31hidPzyHvuPvgkLbtMHZbfAIrHn+w4/1vXPPs4y2bTaJuXHE+v8uDR8fUNdSNoW6NkIx0h3XieqOy3BtESfvt+wFlsjCStSJE9oXq0zrA19n6+4QBFDkmUoSUFFYrJvOWybQRg+vcs/Mduy7R9zXPnm356KNnrK53xOAKyUlmp6RMDJ1sX7Mia0VMWTZGKZRuWWba45z3tzt+1x0n/ubf/JtorfnxH//xT4h5x8MYwz/+x/+Yn/zJn+TLX/4y0+mUn/iJn+Av/aW/9Dv+XT54qqrh6NaUwdfkGLEmU7mqdDQZrSxQ0fU7GUwjquuMIXgRR8Ymooy4SDCeyDzOnTLKaGGtpSwXdYx4LzlQWo0amCKEy4oUQSld6KnFAkfasnIz5z1ZAiDEYvhoIsZkrBGPLaUUGENOIvYMsTABvWLSLKjriqF7xtmLcf6VOFw6FtMZhoZ+bfF9FiNLVxXorlBWh3FYLVqkhAdjqM2U5VST+sjues3pqx2+Vxhds1tNSWEgJYFYtFbFtTyjjKIymaNbMx4+OpIsnInQ2nMyxGDJ2aEwIogs768xWpiFtcIZQ9tU1E1FSjsMCmsmEDOX55nHH+6YTuHewwnBWzbrC1arnidPztG2QqsJ9qTFaUVlFJWxGAsHB5nlQcXFxRbvOzItedSfcONmTv4kYeLbQX3jIbDVOKLK9F3POvU0RuOqmqqqmE6nWGv3XcfrItaqqlCF+RSTbFRGKDglYV8prQkxiTi4LOpKaXSBjscFaCz0eyhHhg+kGBmCMOlijMQsBQsldkumhFVWznF1dU1OUNmaruv5oR/6ffzH//DvIIsRqZja9ijEc9Bay2QyoWkaptMps9ls78dHhhwFKs+IH588T4lnMCiMdWRjCV7IHEqpwqKUTimEgX4YGFdVpWE2t3zm7jEfv/eYuNpS1RWx67FWvBIlKcDjGrh9r+bWSUvdRFLuyLlsBJUf360yU81iQ4RhNl1SVzs2qzM213Yv2M14ri93VO2G0+cQ+glvfWaJqR1VpWnbTNO0bNeJYddwfdbw9Okp33jvMXfuzbn7cCoxOii2m8yTD1/y1f99xbPHA75TzOYHfPZ7Tnjj7Tm3biumc8n4EmFvhVYVrmoI+Rrfr7EGYvCsVjt224GqstSNI2gjbEf97TsU6aRGLz8Y2WE5jc4rckXXjRV7MpuL9+hADDt8UJyf7Xj/vVPOXm3ISeywFAaSBJkqbkIYhQdWmMtQyDyJmLzYv30ajfxNjv/DRepf/+t//Yl/N03DL/zCL/ALv/ALv+n3vPnmm/zTf/pP/4/+aoaho55apvOK2puCUYtruC7wGVj8oFmtdnTDAMqUYaslpoFdP7DIAaOKDX++wbhH/FxRXM2t3PyS1VIEiUZgojKHJPhIHz0xZrwPDKHHR4H8ZIgpRWI0HK3rRqxqjCMlkRonlYWEkCMpFKafrvA+i/VT0FgcdWMK8UJmcvNpzb37M26ftCzmCusUSbUkrMy7AFQW/RdBOjYlQZAaUAbsRNE2jvmspW3kJnz2dMPQA0oVKLAqjKpMzJ0UTpVYHrbcubfk6GhOXcsuNSWB1/yg2awkv6vvQ6Eki7C5qjWTmaKqWrZrpJDmQO87wcC1ZbMZePVyy2yhaaeHDJ3BBzlTFxcbct5gdKZ2E24dNqVDFMf6xbzl7r0DXr3ccnG+g1yTsiWhSWiyGhU3lNniOMBX+y4Z2BMlII0jS9DiZFIZzbSdgjEMw0BVVdy/f5/JZCKx8K8RDfbx8c7R9R273QYfRLuVkzDOlBE6ew5l86QU2o6bDPapvGS91z+pQupIKZWcrUgyStilSmFzxkk7Dgi1PBcN33q1pnI13/fF7+e//Jf/Kp58VU3fbZm0U1JTU1U9u22378y22y3r9ZqzszNh9ZUgx6ZtUdrhXEXdNDcicpDutXCiUxLxrojtBRrKKRJ9IISBurLMZjPqqmYTeqom8PbnbqHShqdffwZDwlgD+MIMhJw97dRx54Hj8KjG2USOQbYjygoqUeQTKVkk3VnsfJaLA954NOHFY0u/7vChQrsKlCMFGDrPy2cdtXvFbG65dVehrcI5yee67Ds+ev+Ml082nL56yfn1NQdHDSkmwmCJvubpRxd8/dde8fK5J0TH8cmSN98+4vPfe4uD44CqzjFuEONgr8lRo3VLCpYUp+QYOL9a8+zpc1arNdPplOPj27RtjVZOSDwq3DAlyzEyFiEXY+MsDhQYUhRmn0D6mrapcZUD0t7Kyg+B7QZePF9z+kIKlHMTYpCfJdeeSHCULrdGYQinUgRjjPgYipt8xprvLOvtu9q7D0ByYjTaIBh1KkwWpKD4kNisB1arHSEkjLMIn8FAFndomUmUi3xciMr5HWdHWmuULRBdMWwMobCDkK7JD5G+92K9NASGwZN1IqRQ3NRNwWNLuKGS+IX5fMGknTJpxBvL6Ch0bxWFfmwqYrBcXm2JvmcxWWAwmKqYMOmepnbcvjPhzt0ZbSOOyjEbUC0hygJsdMYUL7tYZiEi4hWxrEYxJI/WkXZiuHXi0GbJ4D0vnu9I2Zc5VS0WVElcml2lmc0td+8fcvv2IXXj0EqgzO265/L8ktXVwOras91Ehj4WgWfAOqgqha2gbVpyqug2YkSrTQBjUEa0ANuu48VzTeUavJfZjbGKOMB2A08/3nK48CxnBs2ALTCls5mDgylNq8m5QyyIrLDECtWfIuAdOynpksc5482Wb+xYVMqFVSYLwGQyZXm8YNUPbHe7sngc0zQNXdftPfXG8D/vvWiK2pbpbCLEmRQJPuGjFEGBSS22uoFp+m4QmHQk4GQEMixd+bgYhOAZ+h7dGax1xBgkGsN7gdRKgSJEjHMYY4kxcXl5TdtO6bqe27fv8PFHHwgsk2AymVBXwuodLcxGR/bRj2+kuSsVSSFKCmyBNlOUmZgABGY/AdRay+2YI3E/4zXiPtH3tG3LYjFjOt9weMvhPn+f4fKalx9fYk3DPhtNyTownRlh2DUZTUPOVphvucxwSsZZjlZMTrVA+iiHUkG85Qyk3Ik7vfZkNVBpS4qWZ0/OOTo2LI5n1DZhnaWuHcFvefL4lOQTIfRkk+l2A0NnmLRHXJz2vPe1Zzz5aMt262naikdvH/PZzx9wdNui7RZTKdAGreWcGDNB0TDsDKuV5smTj3jy9AMGv+H+gxPu37/PbDYV2DXJJrkkzO8765HoklPpsEcYOSthTEaAhDWiDa1rjdaSkzV0Hu8zUBGGwHadiL6C3JKijAuUSuKWMd5BcTRnhnE2lpKsezHKxsoajb5x6v0tj+/qIhVCZPAySNZKrHRSgUJEL+DZdZGrq8h22wnMoTXeJ5w2jKGAwp4a6ZAF5uOGYp4LnquUonKOnBXRFxdpPErZ8lyEvKGUoa4sztWYWqyLUpIimpMqqaWZrhtYbwZW61OsWjFvFyyWNYtDUyjblojCJIPvDWcvO66uBpazgTvHt7jlHDknXAXHt6ec3JkymWqckWgOHyI+ZolrJ1BXUhDqSi5GyJgRMkoWpR06SSaMMpGqihyfNOy6JZtth1ID2rSIF5pF6YG61hweNty7f8jde4fUjcH7gavrDavLNVenW16+uKbbKlKsSN4W2x+F0kaSZ7fCpHKuI+ce78X5QluAjqyCdIVkrq92fGN3SsoD226NtlKIht5wce55/nTF8XHLyUmF0bUsxjoymzcsli0vnq/2QleR44qAeuxCoHRS8C0FSi6GGwZaLszEFCObzRpXawZkBrVcLgt555Pmw6OWKITAdiuO+82kpp1IGKCrG7mhoxSpmDIhjAUgElLau1vvoWlGOFIG0t4PqEHmhqmXGPkxKj7HRBwGIRRlYQYqpfE+UFfNXgN1dXnJ/ft3+PD9b1LXNV0nQuSmtuXeC/t520gEGf+utcYPkRhkJpaLY0YIgb4YzFptMNaICLx4TY6dVIoRazVD71mv18QYmTcaVwljb2LnxC++hYuPOXu6IsVQoHRxopjMLZOFKrYgNVbNBJlgKzlNJIHpkyYFZFMQElcX53z4wSmr60uyCrhaY10gph3kiPcN1lQMXswFlJpJMoJJhf4tVP7QR5yTc3J1teXp4xWb6zmPP9ry8fsDvndos+PW7YqHb2mO7nhsHQShSU6s1HJFThZlGvpd5ulHa95/75yPHz9mMtW88fbbvPP2fSYzMXaFXIxbhQ2c8muQtBrXtREiLh9RNuM5gzIK4wyukkKfY2LoPP3Wk7JGOYerGioXC2vakpUUM8iQIjl51CjvSGVum1URSGdiECRGGY1zFUr/d6Cg/1/tWK8kWrqdaNraokoaZVaaFCP9kFhvPVebHTFHuSGDp9EgLglBFrmqIhtDVDuiGkTgSZYLEPGeI4GzVZmpRNII32iZExk0FRrrhKpqrRQQZQbZoWWDoYIkUdVkSx8il+sNZ2dnXF92DCvYbhzeTzBmQqMsKfQ4FwlRsqdW1z2bVU+KDaY5IGVFUzuOjgz1xJOoyFRyw/Q7zi5WDL0Mp5UKzCaG+/eW1EYVN2wgiihWxIIGUxYNp8GZzK3DCctFC3olLvDRkvOAVgOTCRweKY6Pa+paEWJks9vx4tUZZy8vuHzZs9soKrMUVl0IWCviYoVGhZacDUPeMMTRPd4WVqPk3hCiZNVo8D4y9B3iHCGFVudCSc6K1VXH5UXP0a15IcpEtFXUTcNiucS4Nbn3kIMITpNGl7kDI2tMFScQVSQIe4aziMZDjkVnk4hKi7p+CGwuL3GLOdGCa6q9HdE4jxoZqMaYPUkopchut2HwO/q+YzJd4FyNUhIiKCy9iB8GhsGz81tZdZKQKWIEax2jMDrlRAiDzDC9F5JC2TwNw4DK7OE6XSCglGXoPhbOk5NjTl+9YrlcUNWVIAaaTxAkXvc2fD18saoqJtMJ88OGnDLD4Om6nqEXgar4vxl531IJ3VPFBkwL9Iy2DENEaYdSEFGsuy3dkDC6wejIo4dH6I3HX+64ugiyIUmJZHtMs8DbCZ1xUBU7q2QgTyFVmBhQMdBvO7p14vpSPl483/Hi5Ypt1wk93QxoMyVmg2ZOCo6sMllt8LliCAtsrMjZiAYs9aUV10Qvs+/NKvON33iJ1YlXzwdW12AqQzvT3Hs4Y3lkMNUOtMaqStiGOhHzCnRH11s+ft/z1V99wbPnL2gnibfefsgbbx/hKnEYyRms0zI7yoGkDDEl8fVE3EVQMt/MSuEjpKhJw4ZKe3G0Ny3ZtijriD6SB09ce/ImUDVzgmpwkwo73eEODKE1dEOGZNAhYfsBFzs0EFQEZWUjQE1C44eBFBsyXlxcTCVz8O/g+K4uUtfXA8OgCVEXRstIGRcb/a7z9EOiCz1KayZNQ6VFC+XDQMrgHKAUkaKBUUmcH14bkqcUxB5JFzdu9H5WMTqYo4QSr5TCGKEgex/2ruQ6aRkYY1BJdr2TtmUyrWhbx2W75eJ5x247cPoy4EPH4tCyPKhxxfcqxUQoL/TFy+vS7RmqyuEqobpa2zAMhs36mvPLK16+3BIGaes1gdu3Z9w5Ea+vrDIqW4x2BccOxGhIAZm9KRkqTycVy+UMa8/3XRA5UjeJk5MJD+5POToUr8Nd13F1dcXp6Snnlyt8dOhqiQ+OHDV1VQM70X5ljcoiQo7Kk7O4dJMpBYgCY2VyKmwhdCGhyPfmKMVMa43JiW7n2awDftDUtkebQNbilVi3NdqqAvl4dHaoKGy+wE0ch+Z1t/MiRSizyTF3S3buQpvOEfLgmczmWOvY6cz5xTn/7itf2cdueO/3XdQIyYljOZBHE1kPSWaZIQa0jqQIvY/0nTwWky/XnlyHRokbvswXZTefU8b34n7BKDzON3Og8ZAZ3E3B0VpzeXnJ4eEthn4QxwxriTHQtA2UAjd2S2OXOLpqjOnAq/UaG3pc29DOJkwOFuSs2G53bDc7QpCQw2HwqJBxxhDDjpjWhBQQ7aGwxYzTpOzZDhtUdqi8Q+meydJx760p1+tb7H7jnMt1TzWvWZ4csHh4h9m972F6a4qrFcPQS2J8sIRtwG93XF++4L133+PVs2vWl45+O2HoahGJa0/V9swXBqMsV+eKFBxOt4R4TtV2zJaGumkAx+BFC+SDWApZ0xaSSGTYRc6GjhyvWV8pYtZolzk8nHH7zmGB6l6bh+eKnAOuatjtVnz8wVO+/us9H3/0iqr1vPnOfR6+ecTBYV3GAaC1Q+ZCEbKXU65k1ppTZgiyufAh44fM4IsEJCm0Djg3IVctyk3FHiv3DJsV/XaL0Y6mnbKbzLm+6tk5hb5VYUKDGiRKhl1PXgVUGtAx8bqLezEMFNIEQtqxTqF1STz4Do7v6iLlfSRnGcRttwZrRyq4YLPeR/HySgIDtG3LYtKii61PImBrS2UyIcfCULFk4zBIyytBgJIZZFRCWaGXWzVCgLqsA5mhD4UhEyRx01h8KJHzResS04AiSLelNdO6oqoPWUyXuHzKs+ev2O16+hdbuqEBJMBvt4v0fSwUd1GpX1xI5k3bTIWFlCy+15yf7Xj18oyLqzP6AXKSgXtlwTqHdhYMJBWIe+2JFMIcZbG2xmD0uAhZprMW5wwxeWyVsAoODltOThYcHkyojBBKmgqOj6bU9V0OD6c8fXbF9fkGpSqUafA5ocr8BKUEz06RFMXhIhU6+xjOKBEAkAvRQXSuqcBxQp8V12dNTJG+64vTgy+wmMx6lDJCo3YlVpxi71QEjUVyvWf0fRLkKzAgMv0w4yxKvgOrwfc9y+aEnQ8MyfPeN75B8GIqO9J/q6raz6bGBV5rJVqkpmI2m1NVFUMhM8Sc6HuPD2n/tU7bgk/rPbS9f5ZlpjpCa2Nhkmy04qDwGst0HGwXIGg/L2vblpgiq9W1zNT6DU1bf+p3fWt+2kirz8DgPX0M9N1A00xomlYc7quKpnE4WzrJmCWI0W/wweJ9Tw5ZrIQG6c5CHrAqcfekoq2vCKEn2YbqbsNyOGKhQHead774WT73/e9w59EddFWXTKiOmYo47VDBMWwju/WOVa7oJmc8D5ecbi/JPlEZg2mgrWveeOOEh/duEXaKd3/tOZvrRExrYMPxyZR7dw/FGBklydrbniHIhoWsy5RMl/DUTIoerUUbl1JgOpszaadY20AuUJlWoCJDn4l+zounPV//tWc8/via3m958NYJb79zn8WyBRULnIwwiL3HVeOsskgqkiEGTU4OP2SurzpWqw3j1T2tE3beUrsFyrUyg409Ydiw3l2ySx3N/IhdDR+vN3zt4zNOV1t6UzFkS5xKt4y1GCWqw7iNpFCjsik+gaW7Y01WO4EU67oY6fweKFJKOTHo9HJjDoQCwKpCL7UoFDrHAttk6rqistA0hqxF3KtNgBBIWIgGghH7mWK7pBBoxUexoHeu0HcTezJEiooYJZJjt+2wpmI6X4BxVLVl0jiyFnzbqMImFBiexlRUMwcPFqy2l1xfJVLUrK4y0a/ZrBXDENlufGFzJYx1e5sma1ussYTBcHW14fmTFVdXPf0AsaCSRmkSipjFsNSXIapXHh/UPq+JDCaPRikZTCYTqSqDtQqlPIkV85ni7t0Fx8dTagfWBHleSlM5zXw64/ikYbGseP+9ay5edQwdWNOSshjbSgeaUMoXyA4kHXQgU3bU2aByg1IVRsnNmdndzI1Qhfwgzhg+xOKBN+YupdIxiNWQMRrGAPgSGT5yYffe599uFjVec3sOaTFGVRIgt11viL3HNBVOG3abrbiDJ78X8X4690lmOBL2N51OcK5is9kQYkYZJ/DetieOkeUqo125vosAFq3KNSjQaBrZf+Xnd123z3Iy2pBLjMhrN1GZwIqiXGI9euq6Yr1a8+DBQ7729a+y23b7RVG9VuRGWv1YFLWWGBpXKULOBR4PXF5e0e06YsxYW9M2UTZyytA0DfNFjTELUgrECN3GC5Fn2LHdXYAfeHD7RK5N6+iMJc5nHH7vQ374B46ZzG5zdHKMMplt32OqCX64YlJB7TJx8KiUqdoFbnqb+vgRtz//Jf5v3QXffPc93v3qE159dIEeeu7eus33fM9d7ixnXD6/4sNvPOU6XZNU5OjY8vnP3+fe3SOMzvR9Zn21Zbfx5CTkC7lHkb+jycVFRiJ5EkmnYjBtIRlSUKBkvACBys15+UTxjV9TfPxeYNt1HB5XvPHmMbeOZxgbSiioaA43G2HYOkRTmbK406tsWV8FXr1YcfrymqurDReX5zgHmcjbbx1TtSdUqpX7L0ZivyXsrgWKm1QMk5oX6zW/+mTHe883kGq0bemxZFtBTNg2ofJEdGjeo30t91ISj0Ifd0Q2GBdwtUPbYnjwHa7z39VF6sY7DtmF57FtRqAQUxZdpckpsN3s6KYNxlhCjNRWGEUU/7KUhLEWQ8S4wuzKouPROpEQrYnFMnqMSeemi95HmGTb5LnabLm86nGTBe1kQpjDdCJZSVoFocIK566wyCKzueL4ZMFue8nQW3yXuewiXbfFhwHvk3i5EUXVPgqJMUBFDHBxtuXyoiN6h9ITlAqIb50j5chqM3B+saEPYHTEFFcJazK1a6idhJMpPCn7MsuS1NzKabSJ2Hrg4GjKreOGydTgXMQIYEZWGuMknDAA7sGC1s34erzgxdMBa2Z4X4SGSkwzs8r4GGQGVgeMkY8cIYdECgZiJVoYPXY94yVeClQRDN9oNMpdMM6V5IIpU2IpjoK1xcLsG10zfutbZ7RPpMzlM1A7J2EL2x1VU2MyxH4oZrg3Me97GyTYC2GVUsQsjFA/CMEgFwcOYzTaCKRnrJy/IUp6ri6CX42RnXQUtmaIvriIFAZfziJ2LfeI1mPaKzfuA2WwHqNHZc3FxQVHR0dcr9Z8/ns+g/1mmcPmTPAy53jdFmn0JhwTgimkGLQWE1xtGIZun6k0FjaBPqHrenyIWFe6eoStOGlaYujRiFvCYnaPnB3NdEpoJqT2gNod4uojnJ2CthAiu9Wax9/8GrvNcxq95s5BzdF0zq3lPbJ2+GiIukJPpkznFT9wdIsf+H1/gPXZls3FGdavaG2H9jts1zG/tyA6aFvNw0cHPHrrGFcJY63fBi7PN6VIGcAKA1brAr2WdOQYhPJtI8ZoIcYkyz4GxiS0DcQw4IeWD9/rePJ+Yn1lcNPMwzeW3Lm3xLqINomqKvf7+ZrT0wuOj4+w1pCxJCLd4Dl/teOj9655/5vnnL3akJLi+vqSdqrQJnDv/jE4h3ISeEjs8dst0QewNVHXXHnH11+c8/6pZ5tblKqFFaldgRkj2ESuEtE5UEnSCnIUGy88MfeiX6tFlkDSZU36PcDu09rsw+VylDj3kZWXx+mCknlCzopd13F5fYV1M5RR2GRwFqwTpbWPicGLcDZlMGXmgFIoA+RAIhNSxpaUUDX6qGvRF0zaObPpAefnV7x8ec6rl5cYt+V67jg8qDg6bGiqjM4BlxMmaqwByLhacet4zulL8awjW2IQ2qePopAfZyGjTkkpjTHCOOx7z+q6o9slaRSsJhtNxhCyCO2uLnd8872O2UxhbBIzWeWwxjKbTDg6POBoMcVZ8eJTSAFvGhHGGhs5ulVxfHvCbGYw2pOiqPjlfVAYLWJkV5IczEGLf6gJm0suL7ZYNSEqGfqm3Atho4rMZxWHhw2L5Yy2lcj73Sazuoxcn0eG3U5mUirvKbVCjy49lUI800xEqSgwr5MB/b4+KRFTy1G6qTEvS92YyX476rnKN45oozu9BsIQCDlwfXXN8cESZ8we5hvnPWOn8Xr6rynpvJIZFTEm0TQTlLaEKDIHrceuBXLKhfqtSDFLom8c86akO7wpUgO+kDZGx4u+73HGCnvOmP1sTGnFyGrVRuO95+GDh3z1xQsUYtocY7hJc1Wvu/7LPG0kVMQYCTHQ2hqfEt4P4p6uFM66PTTe9wPeB7Sy1K4ClRiCWOnrLIzGvNtxdXGOH1bcOZpx++4XmCwa3HJBbCakuiFqJ84Lmw0vnzzj2Xsf8OLVM4IdePhgznIWsKsr/PacF69e0qUJZnLC/O4j3HxOThHjKupmQls3HB9PcHogxzXD5or6+Ig4n7E6u2SiA4dLy2Sm6P2O7A3XVwNXFz3dLsuoIAMpYXIGo0qHL677Shd7MQ3bdU+/Ez1bJpOTJ6WOfuh5+mTHN9/tuTivyGgOb1W8/dkjDg4rlCkWWyFzcb7jN772MWenV9Tfv6B2E7TTJAIvnp3x9a++4KP3NlydK/pdgcT9hBSgqjLT+RLXCqIUfUT1gX4XiV4x6Jqtm/N8Y/joZWbnJ7hmSQqaoaQTJ23KTVXmX+jieBbJSQJYU06SWqAc1kwwqsUPWYgVvxfYfYKjyywFhO4IiCXReN8BPnqJbshwvdkwXzTUjWMIfh93kAmi5E5e6NVZBLkKRS44u1KFMVOom1pZsor7uYg2Eq09nwt0k7Kie3bGZrchxkLBTgMHy4b5tCLrzBAGrBVRIErYgZPJhKvzHVpJBEVMXlJmyw5eKbPfgY2LntGGnAcG32OMFfjAWRaHc7Sp2K57vO+JwdPvfLH7ieQUSqxJYL3yDANUrmI5dxhtQHl5TzQYm5hOHScnU24dtVS1FCOdZQcnF55BGfk+lRI6JSZNxZ2TlvMXA5vLNX23E21KndAq4kpQ5fHJlFvHLQfLirYVRw4/KLbX8PJZx/MnV1xdeVLSGCUMRsm/EtGu0hnrFHVt0EZcPoyxDFGiHWIEKS9Fh5TF1zHlSFbCpNvHooxF6jVm3/jnWLpUIVekFOU8DR4/DMRKdtKurvf+iCNhYrQmGjuRGGX+ZCvZaHRdj9JCNdfaFljIlN83inhvnDBGqxuZVRoM0qFYI9llo8PE+FyrqmK32YiTSXH9EPp6sU5KYpZrrXgGxphYLA64urqQLuc1qO/1Yv66/VOKic1mTVYaa6vSWSgRiGZBHkaKvy5MUts4bEkJSJESnSHzUT903Dm5z/TWbdy0RbUTTNWwG7ZcXj3m2Qff5Ozj9wnnV4TLawBuv3Gbh9MZ8yrg8g6bZd52efqcy+FDDi/PmNw6xjYz6nZOqDuapqVuJW/NhxrtllTzKcezlsnlIeniFVn19CqQkiF0cHq64fpyIA5GoLso3blWQhggmQKlFqq2SkU8PbBeBYYhYassJAij6DrPs2fnbLeGEBumM3jw6IDDWw3GlU2LsvhBcXnW8dEHZ+y2kc1Ks5hXmJS4WO34+INznn58xeoKfC/FIYSAs6DxtHXNdDpBmUjXb0mDwq8Hrk8H+t3ANif8fMlZb+iHBSRNHICssWhCzMQ4oHMi+0DqA8YnVE5EtaNMR0ukihFmdK4xagJWdGk+rb6jVf67vkiNHlUx5Ztsnf2EV+YRWWuSLrx9k+lzxqNRRWlulS50yZ6mkvTMlBJEU2IDxK0hlpyerBPGFcjltd+Zc2Q0M3GV5u7dWyij+OjxEzabLddKaMF+SChVsZg5lPb4NOAKs8dZi7HCDEpxhE9KdSquzzkFYs6lOIsqzFiFMYmcezIBVznmc8s7b99mNj3g7PSSV6enpNRzeNQwm1c4ZzG6IkbL9XrL2dk528enNFVFXR1S1RGnstBGraFtHUe3GsL9I6ZThWIoiaAVqJqYHTEZdISklMCiOaO1YzqvmSwsyvTU7UygDxVIKuJs4MGDJSe3JxwctkynFm1SgWorbp/MeHBP8+4s8eu//oKrK0WIEqgn700ipIEcdkwXisnUoLRHa0cMSLBb0vRdoO8iIchgeSRCyID3W2dReV+QSpfFfqm5IQ1AyaeSVOTBe6LOkiRRFu7RConyfePGYhiG/VW6LzIiUhMnCIQkY50tMS8WH3uMqTDakbMmBkpXIia+kjCRxK+yk6gQSvdS1/XeBHbseow1hDgUMa2iritWqxWbzbZ0PJ7l8oDTV6+YTEXIK9C22Reqvbv52CmWt1Bo7wFjSjeFlg0UEg1vdMI2pRArwBRXBA3R33RuRM9bbz7EzDQrVmyvrnhxes4HH77Lxen7zGzP3Znj3mcXVP0Rz5++QsUrbGepnMJoKQwxKTbbNattQtUNu35LFyxJ1dRtxfxgweJgQTNpUE50Q7p2NHVDtZiyqRKrV8/x0aBSxauX5zz++JLrq0AOlUCvRBQikkfJaxU2sJi/ZpXJWbPbJp49ueaNhwuaVmZWKTiuzgMfffiSzbYmYHjw5gHf84UjJhMn3XTOKO24vur54L1Tnj3eQq748L0rnF1Qt4p33zvl3a+dcn7qIc3FM3PUtBmZfTVNS1016OwBx/p64ONvnvHk/af4HrZZkxeRYXYLaCDKvTqyXo3cEqic0DGA9+TBk32Pj31xs5DZXMqmmFuDD8J2RSnaye8BCro4/t6o3/O4YSkY+/7/WpN1Bp3JVjHkTNKWrEexpGgJlJVFYggKlRzGtGLg2EG0gKrKkD4L9dKUCy97ci5GtMogSR8Z6+D+vTk5H/DkaWS1HsQFmIBzEo5XTTSRLaSIoS4b9oxYvfDaUFs6KGGyWVJUolnKBfbJA1UN84OKrtswhDXaTZhMO46PYdLOWSxklzeZWdqpk4tU1WzWnpQtFxc7rq+3XF3vuD0ssC6PSYZAxFWG6bRm2hicDqSQSMoSlSPHin7QdCESlCfkXrw4shLbJtXhrSc3Ed/1oAQ+bNuao5MZB7capjOFNjL8N1kWwJQ8KaxoZzPeeueQ7S7wta9dMgwDWltA2G5GK2IOtNOKybTCVXITSTfsIBthTQUKNXaEB8f8ok8ZyVKYcK+x/sZCVVjyJWBP3Dt8CmjbYOsKn0XYfbXZ0rbtXuQ6FommkViOkZouN+xEjGdtjbamkHQ0zkq0xuia3oceMMQIfefpdl6o2sYUf8ehXBOfNJYdTV5XV9dM25aTkxPeffddtNXle0tshhICRuUqJpMpz5+/4M6dY0ASfxm3Ya9R118Pc5SOTbz5tBUZxqiVSlEykYypyEntZ3LGWmylMa2k6/Z9xKutoAFaQ0pUzvDi4jGX1694/uyCi/MVk1rz6N4tHt1uOawzabND7RLzwxmDT5K5RUtUDq8UO1vTu8Cge653Hp2uUHYKJjOkjq1fcXrxUkSrbct0Pufo+IB2UoNNLO48YLXtWF1c0F/t+OCjc16+2tDtFFpVhXVZqOCjgWp2ZUkSA+JissbQZ14+X/PkoxWumtHOHduQePJRx/oqM4Q1hycz3vncIYdHM5nXKTG1Dl5xfrrh2ZMrom8hVXz84SUxGIyLfPT0jKtzSKGRTi6LRtJYgzJZTLaJhD4Sd4b1JvCNd0/54BtnXJ9HUsh4rVBhQ6VnuIkrRVeBHpm1Y5EK4i0avWRy5UBW4hyikFm4QTZbiZ6Qr3BV5s69Qx69eQ/+y2+/zn9XFymlMzEFFLJj+Va+SHG2NkoG7kaTrSykOx/QykgXtU+jdShlZb5Fy9BpVutemDk6oS1UtaFtErZKKCuu5sKsyjIcjklYcFrmYZWDe3fmaGX46PEl601mu4Xzi47pvKad1kiCh4Zk2HVDiQYX4WjyY8TyCPno8noL1JkS292afgjM5w0PHx1jtGN1fclkGrH2CqUsi+WU+WLKGOtuKzAmEcPAdnvJ6ek1m62nHzKbbU+ICW1cYb8ltM5UzqCzE68ya8l6vOHg8mrN+eXA+WrDNmwIeDEvrWrqWkIJ+z6QJpkheqKP6BRxztIsJiwOJsymZj9Qt+PsxGpyimg9MF9q7txd8OxZz/n5mpIWJsUMcZI+PJwzmYr7espG4gPQ7HYD6/WWGMWdRMSGoEuul+Z1+Ip9tyMF6iZ2IuvR5S+TVNFJKaGRO+cw1tJtt2z9QD+E4nDiy8zoprtaLBYsFguapsFYW+BhgcpCSgwhoI3AJE3bUtUVmcx6uyZncU0Rsodlt+v3BWnvhh78fu41vqe73Q6tNcvlkul0un8+IFZfWluGoWfSLhi8Z75Y8OTjD/nc5z7DdDpju1thzE0nOL5fI3twnMGNdHRbidGz95EYZQ4lRshiNOychHsOw0DMisrWaGcFtq1qVC9OD5UzXF9d8OtfP8dWiqqac/toQWMVsyYw9DtebTdMqimT+YI6LDGba7qUUN4yRMN20FxtFZcsiDOFd6UwuhqMRVnZxEZER7W67rg+27C9WHPv/gkHxwfEScvJW5/lSfcuHz57wkdPLwk7RU4VRjlyECNhU8wCbpCeghaPIarKkdGsrxPvf/OMyczwsJ5ytdrw9CPP+krRNJa3Prvkzv1GusukwYhh9mY98OrFdengGnKsOX/Vs1k9IZuBPmjJbCqdtswlJakYNZDxrNdXPP3oBd2m4fHTa9795imbtaWujhniDqUS+ISKO2wqYnQjGXcgqdYpQ46eFDp08BAjKqWRo4PkxlmUyfiwAb3i4Fjx8I0F3/f9d1ksFt/ROv9dXaTqxuB75ASOw+9CGdeIOFXKvSFpjSRaG7oEl7seoTUbjJE3XAVVcoUAFKvVlrPTFbFoeIzN1K1jPjekuSZPxTlhFGVeXW7YbQdytEynNVWNCCEnijv3loSsefz4ml3nWV0Fzl4ppu2U2TygqfB94vq6Y73dMMSOmA1x1PAoRN+lBFIUjYzMHLbbnu1GM21blouWpqrZbmrqZqCdQMrbQg1vGPwOYxPaGFKO9IPh/OKSs7M1IdQYXRF8lEEqBaLRMvx1zmKUoa0dSiV228jqesPpqx2n5z0XK8/VdkPUgWbqmBwccnjvAXfuHbJcNswmM4E0TgfOX11z+uoFg7/CziuMs1hXYU2ZhSUIQ8RUGpVFnKq1YjqpmE4rri6F8SUJx1J4Zwc1t24fMJkJVZ1kUNpBsmy3G65XK0L0aGHK7Jl+WSmSFj2cbNxvNgC6dFwokfNKoqzMJNXIEExR4r2DL5ZLGWMt87oVo9AQGHyP946mbdh1G1698vR9x3J5wPLgUOCwJNEJ2kJGifkq4l8XQySrXJhygW7Xs932dLuB3W5boMPijYYWr0i0aHBiQplMt93RNC2urjk9OyMlTxhkBoRWTOqaYfDQJl6+eMbxrVvUtXRwTVPT9Rt5v/cw9014JdxEuKMUfgh76nzO4KyjcgL5aG2pq5aqqqhMRU6Zzm+IyZOjSDNijITeE2JiOpugjAjXo5eutzFTyInr1YoVEWdrNlWLURbCFOcUu2GNXsEuRVZ9JOoJqWolbkQlTCXsyUgkKoFXNTILtXWNwbC6XOO0oWkn2MMZxs1YHj/k8Pia93lFygmNg0JkwcSiLxzjdmI5D6aQJDRKObRSxBh4+eKa+uuZ9WrO9dWWs5dis/bOZ2/xuc8fM1vIBibjiQS0qth1gfUmEIKgPlYJXNr3PdpaUqoYuo6Uh+LFZzEmgpZo+ZwC2/XAB++/4OnHlut1pN9WKFWz6+T5qhjJXUfe7nDOYF1FUAqIYhKcs5yrIRB7Txy8sAKTiPJzriQbzyiUCjjXc3hs+b4fvMfbnzlmPrck/juEHv5f7bAuMHQKrVpysoU4UZhd2ZNVhzEV0ViyMQRjGFColBiGCKbHWIfVmRwHGjNBFxNWrQOwY+g3+KGCLG4BQxfp1pluVXPnnsWYjKsS3S5zdZpZXSlsAntHMpI8EV1pqqni4ZsTch54/nhFHAy7847twjJvZTgegmG96Vl1G3ZpQLsWbRyTyUTw+ZjoumuSt6K90B0pJ3bbxO66Ii0a2omhngUOli0xgakdyk1A1ySgaiwhrkAZfFRsB8vz04D3rUCcOhKGgB8ChBq0EYf2XGYRBYLbbTsuLgYef3zB8+cr1rvAZDbnzu1jHr51ly983+d48Jl3mJ2cMJ02Qo8t5pbOVRhl2WzXnJ69YHt9wfDqMQw7SZONgRQCOcHp6SXTtuZguSSFyKRRNHXG6My6G3CNw9hM1QQmJy31ssa2c3HTQLrTmLTAmOtrurQGNaC0QVLsMzELCzKmxKRu2azWzNopQz9gMLhssVqTtRERdIx7BpfOCpMCs9rSp4jOiaauMUDMiqZpGHyH94Heb3C1PGa0oh92dH2N3dT0fdq7a4xdkdJGdqa6MDtR+Bhf43AIC06hscbRDx1+CIh2bkLoMmG3xcTAsO5FoO1qsnFsujOcyVQ6EHSNjxk/DFjjiL5DEXhw/zYfffANTl+9oG0azs8z1jrQFp8QxEErSZC2Fh88ymhQEnvfbXv6ridnaNsJk8l0D03OF1MW8yVtNSHHxGp7TraRPkau+g6yaANjTtRTx/SgQpFxpsWWDj8DSVX4kNkOiYtdJuedsDCTQukFeifJutoZrLagDUYbjHF79q5RGqUrTNmIJK0ISfa+yjZcDQFzdsmj5RSlHLPlXY5u98yWzzl7+QybMqQBYwLJJrJR6GyIsRcERjWobNFMRGMXPFl3aCXu4h+/v+HVU80wDCSlJO7+8zMObmmsSxgDfepIaofODu0maDtniBciiXGZ5AUe9j4xDBmVEsul4c69OQeHE7TWDH3k+mrLarWmHxTnZwMpKQYf0EaTc49WY/yLhg78y44mTjk8atigiHSSuhwjKhrYZeJ1wGx7ct+RQy8u87misq1Ig9KKw2PP//33v8k7nzmhbVqSV3j1e0DM20xahs4TfMTYihhFWBlku1aiuCWSXWFRyLA5pyjGpkBvINYGq2t6nyRKnITOCe00prKEKN+fR61LyGTf4+yAs61kLW0819eJvrNcXASi8tzWNa6ZYJJBO0VbNTy6f0CrO54+PmO9umZ1BfN5TW8TXb/man2GspE337nP7XsPuXf/IbP5Aq1gt11z9vIVjz8+5cWLM5LZkPH0YcvltWaxdrTTOaqk6FZNTY6pxObI0BYiKmXCEDBaM2x74uCBiqxHXUeQ3byKAqdqg3UOY2DXd5xvt7x8cc7p2YbdoJjfucX3vf053nrnM9x/eIc79084vLVEV46gx8F6YhRHu6qiqoRMcXS8RMXIcPkW2+tL1tcr1qsVF6ev+PCDD3j59CnOWj7/2YbFfM7Kb/AOBptJrcPMp0TlmZzMWNw/oj05xiymQrEOYu3Te3DLOW9872e53Yn/W1vPWExnTJoJtq6p5zNx+XY1X/3VX+Xq/JLLiyvSEMViqBvwwRMVlAtNCurgCTkTkgWtqWpL7ju6YcCY+hPWL0op+r7DWYtrZB4zzmxilK5EHBnaPRswhFASvpPA1Yyu1mNir0w89hBL+TPESExRFp9kSrRIpmkbmrrm+voakOyq/fVRfk9KkdXqCh/8fs7UlkiZhMy7lBIrMSk6tnxdMQ5Vmn4ootLSkXof2O12ewp913VUVYNVjqaqWSwWRBNgt6NpEiYlQuVYx8Dh0QHkhNFVEZ1TXLa1zJGL392YoyRIyk044ziPG8/BjRD5NZlKiWWRd1N8Io22JCCkzGa7xfsdddXiJjVHx0fcvXeXq/dfQT/IfVXGCyFo9Gs6oJg8KWVCzMWJJpUooYSxER+37K46nNM8eGPBF773hAcPplSNzBczoXhFivuMddBMHE3T0G+SxOhgMTqQ8g7sBQ8fzfieL97j0VtHTGeWGDJ+gM3ac3l5zYsXL/joowsuLqKslcqIUS+S66WVIcZM6ALbixVkg2kNxgasCsSQSD6TNpm89uhdwIQsSFRd0XuJsFE5YG3g+3/gHd56+4TZ1JICEpX0ndWo7+4itZwtIHasrwWXzkmJUarRaNMQkkWPMeg4lHKya85GdgxDpFsrtoMmash6oFFQ1UJLV3VFMpqBgFEWU8SHJkH0kcuzLVWdyNmwug50vSakisu1Z+M7TG25d2eOiZqYBHefNC337i+pqjmPHz/l4mpN1pnpQhNSx8O37vLwjbd5+7Nf5ODohLadYq2jrhwqJ4a+5/Tskm9+8wPOzr/BZPYfaBeGy805POvR1R0ODiY0VYO2ApUZVaGyKU7FYIouKkRDbR21tVynAWWdOEHYTDaKqKGqHT54QpQk1y4mLroIswWfuf8Odx+8ydtvf4758ojpfEndToQxFgLrbsPV5SXPnj7l9PQVu26HNZpHjx5yfHLMyckxk8kErR3twR3c5JCDuxC95/TlS5qDu8yPH/P+N7/J+y+v+ez8hOb2jB+6/xZ/+P/9NtotaaeH4GA+h/mhYzbVOJUxWjGsT9FkXDUlZodxLXU1Q2FlBpXGhUtCB733aKV56zPH5JghQRwCQ9fT73qGwdP7wK7v2a3XrC6uuDy/5Px6xfm24zJE+jjgk6eqa2IQv0WhZlucFedvY0YRp/jvBR9QytI0DU1T34h8o/iyjUw6Gbur/Uxsz6jjJhZcKVWYbJ4h9uJZWC/YbtYQAifHt0gxsrpas5g0KKsKWifknJQzMQTZbfc9AF3XMZ/OxHGiBNeNhrnjzGuctY00dPIYrneTa2St5ENNp3Mmk4kU7W6HH3pMlclGhNeTScsudGgdyHng+NYhMWZMbbgRA0ux01rsu0Znb4ogxL5GkX+dhQh8gkI/irm11kJMKO8BCDFJeEOJYRjYbq+piwt83Rjm85a9C/goQ1EKrRqIQvVGdaTcYasKsQEKiB+kvDY/XFHVmpPjOfcfHPPW2/e5dTzFWQVJo+wgc+EMOVUkAsrsaCaRqlaQHGGoqCpNDOeEdMXDd1q+9D/c4zOfO8HVAzFvhSyUag6C5Y5fcutOoJ1rPv7Q8/z5FSkkYYwmW3xKNWSR3HS7FYSEriuRjRiJ4cm9Jm0SbAMmaWrlSEYJBKkd5IDSPbfvzHj4xgnT+YSUe+n+s6Xrfw90UtOmpjaO2m65vN7S95HYZ5Sp0KYmJOmsrM0CU+3p6hpNIgTYDZGER+cBbEe91RzemjObzXCNw9Zb2BanYCIxR0xZBLt+4PT0im0X2WwUiZqkHClnej9wvvIslz3z1pDVgA891BGsY3ni0PUxF5eW2bzl0ZsnHN9ecnL3Nse379FOF4SE5FN1AznX1FVF1dQ8ePMutx8ek9I73H3zjP/1//Ulnj19zNnpC15dbtj6xOHhjPm0AR+orcEqsdHRymBsjaVi12mqasF8seF0fc566GgrRT2boVxFUhafMxGDNRW2bjlo5nzxSz/I8vAW9x/cp5m0oAzGVaAN637L6mLH2ek5L5484ez5M16+fMl2uyGJsRnfePcb3D455s7dO8znczknGLHNCUE0bX5gt91x5+4bzG/d5cXz57xc7cBZfv///D/yB/6fP4ZSU3Ku5CpWO1AdOe1KyB3sVi3Rb9G6QgVIGAY8KQwYbUR0qzQoUcab1qBcRdBbum5H9JIia1vHfFqjzYRuEAcBq25TGUuOENBc95Ff+fV3+Q//9Wt0mwGrRdgZY8RVYpaqyw5VHhd7IucKMaKqqesaYzShdDAj4WGkr/sodHLpsOINLMjYAZVoGcA5Q926vUPGzos27u7xLd5//31qK9EsWRuhRxc3irE7qyrR6C0WC2KM3L59mw8ff0TwqeSICWFi1ICNMfIpSWbUED2huLfI5x11XdO2E5bLJW3botBEHxm6jj4MRJWEjJIgpQHvV7S1YTppxcHgNVah1mYv/UiKG3p2GezrQqh5Xc/1uhD55rGySRm1cYj3nVG6+BCqki3Vk5FC3G0k3dc6ITDlDCoZgTrRaNUSoyfrgbrO+LgDtSX6TMoid6kqh6thMpuxPHQ8eHjE/Qe3mE4d1mjIFpUlvDXna3GoUDWJgaw6bLVF6YGcW7SaoHX6/5H3J7+arXleL/Z5mtW9zW5iR8SOiHNOZlZmVhVFFQbutaGwhSxzkUo2A0v8ASBZ8qAkJogB0yohUTOPLAaWEIwQEmMmqCQsy1D4Iu7FoirJyqxsThv97t5mNU/z8+D3rPfdcc7JylO+gHRUS9oRO3bst1vrWc+v+zbEpOCiP/tr3+Bb336EryemeEe3qEF0xmtSpm4cjx6f4usF3XJPSD03bwPTYBDx6hOVVcbJ2oyRAPseMwSoRTsuySDBYSaHj57GGWqXySYg1uCqmpwCxvY8fnLJyWkDJhJiJKWKqZ94/vLNV9rnv9ZBqjGZ1crTNR1tE7ndDuSbgSlEUlIkjHGodbMNReHgnppAssQy68khYb2w2W0IMZOTo/KWVJxSkWLd7VVRoXEO49YkCdz2gTF4IjCJ2hVk23AXEvuwZ7lqsFUk2QljJ1xdsWhPuPjgIb+6/CUuLi45f3BO2zZ0iyVDiHz0/DVX17fc3t5xfXVDU9U8unjIs8tLVudL2lXL6uSEi0eX/O//h/8jfT/w+uVrPvnkI66u3vDm9Quu7kZq71nUjrauqF1F7cElS5wEY1qMWXLy8D2+e/YBn71+SVtlLi46xC3YTYntOOmmMMF+EKqmYpw8L17e8urtDVMc1Z5chHFKhU3eMA2ZcXuHjROLpuPB6TnWFmKyNYRx4tOPPqWqKgUk+KaQUlVCJsWAd6o0bYGQAQx17XFdo3wTSsWXE2IhR8HZBufVMTTbjklGrBg1Tiz6dbVXuSyTIkkUrIBVUVRvMomIbxy+9iWDhSBKfJbGQI7ELMBEdoaQDNFZAoHNfkNVNxhfMQxKaqwbVyoK9W2qa1HUXrtgtTyhbltSSgzDoJ5NrbbWUkoH8u/sF6WwerUAiTEcqoOZmFv+gTGZqtZq426zY4yBh6drbq9e8fGP/5C2cqhjqvKBnGScU9FaUM7WMAzFS2rg7Ozs3utoNTK/r5yzitIW4vIUAmMYVRbJVyyXS05Pz+i6jsVCwSRaubgijByQ6JTBK0LIEyIDIew4PWnpmorauoLA1ArU2sIZ5Big1LV4tll517DyfiX1RW3G+fujGrz3NRTFfWsNORqsabC2KW1QSjWnnRnVBnWq6o/BuszFwyXvf+sCsXeEuGcaVd+vqjpOTk5ZrVuWK2F1Cu0i0C0S1kyY3BGDXjsntiR3KhSQzA7jB3yzx/ge4xq8WEQmjJv44JvnvPfeM7p2hZgtbWuKKj4Y6ZDSWVp2p9T1hHW3jMNjPrS3vPg0gvEYqwmHJSo4iIgTg41ZgUFkJDuc1BganHd4D8ZMiMRyNid8HegWwsPHLb5OKiaQMhnP3XbD93/4h19pn/9aBylrAt6pasDZWU3dKrv7zds9OTsq7wkmIC6Bt0jx/8FajFObhnEI1M4g4sA0ZMnc3E0k2dA2mSmAWK83szN0XcdqVbPsanyt2fF+zNxuJu5e78mVZULJkXXVcDdlHjVrxGfahVfpo0cPOTl9wNnFU5r6nKY6ISdPPwVefbbl5es3PH/1gpvbW5W4GQNdbfn00w95eTny8NkZZ4/OODnJPH428eJtZL9LpHxKtfiAM/uIfjrBdyMhZcyiIZriQOyKvw6Gul4xTYnV5SO+efmM85fPSdOexqsT6W7YaguAhLGO/WgJ2z0/+qPnYARrM2L1eZVH5IFS5uOpbI31urFKpsxnVNfNO1UE987OewtYzaJjBhBWXcOw2wKZrq0KtDrSNo2ieS1k0cCDrYo7qGhr02as1DipqZWpiiHjJBdXXZlZuRR/41KxKMIzCUV6iSIbpOaGQgQHIU74tkVSwtU1eZ+JRKqmZhhRYqMIU5hoU61ctqxZvjGWtl2wWKxwriKnzDD0NE1N1zVFBFcKFL7Ys4DORKGIwE4aiHMucF9Tnnu2CdeKa4ywH9XN9/x0zbB5iws7RDzd6Sn7BKD/P7fLKIHn+voK7z0vX77i9vb2UCnNM565tTe3+g4W4SEQYqRuGtq2pes6mqahqirquj6aQSLEOCl1Q8D7hpwj3hr63JPzlvOzMxpv6ZpGnWq9x1kVptWgIiUo2wJ5tmV1F0tzjkFp5nXd/9kcmGaU4izErK1EFXMuzC+8WxAndfSNYdSgkTIOpYbMRoNZBly15/zhKd/5pQuaxYIsg/LspMbaGu9qnLcYO1J3oYB5RpzrSFPm7nbD+qRDpkCzcERRwQKskHOgbqBuwFht53kTaVrh/GJFt+jKeaiKf1jAGo+1bdHNQ6W48kTXZj54/wGhd9y+eUukYsquIFgjkmaOpqr3p5wRqx0ZMRZXOgZDHqmrhBSOWNM6FkvLt37hCZdP11ibCDFQ+QZvPdYPXD69+Er7/Nc6SAVJSMxY77BVxapZEk3NEAy3d4Ex9AQXC3xbUUgZxe7HFKhw4IUxRCyZPII1DXUF22jZxYkUHKbSm+30bMnpacv6rKFdVDhfsVicIaZhuwucv74jZjUgW64XOA+nzvPg0SXGwnK1oOk867MlxsIkK7Z3FTm1TENinAL7PrIbaqrlBzxcvo93jtVihclw/foabx2vr3Zc7+/o2p5vfXvL//g//ZT9bqSp24PdtmmesVrXjDliXSKGLRCZMCAadDMtwUWsM0y2YnH6iNu3r6DqECZSMgq2kIS1nmyuiNljcq1E6oxCnIukjnUeijUKRN3cnXrdSCH/CTpAnjfUhIEsWBMBgZQxSaGs3oJIJIRYNu5MioJJJSMWMGp5XIRwKQxbg8kOGy0MGdc4HCgCCg4q4Bqn9D2MSXX8Ykw42xBlou+n0qKz86RDb1KTsJUnGWHMUaV/KsMQRvb7nqo5VbSeMWW+AbN8kfcVbbOgaTqsqRiGCevV7G+2EpkljFKZ/6hXlG6oSj/Q1p7cm0vpRl2AAeWcjvs90TU03YI8DZytO8xuz5OzlqvNyBh6jOu0WihBw5SAHqNWa5ePL/n008/Y7/flhB31B+9v+nPrTyupCeeUvLxcLum6TsVyC4iB+TOIME0jIU7gGuVPicrpeJuxZuT8dIE3YPPcijvC3/W8Hqsg/TnMc6n7QWo+7ldW+vf8GUr7z1gFqhwKU20JOlfTNmtEPCpoLOz7rSLiHAo7J5PMSDYT1m0wleDbNeszi/Oz1mdVAoaSxENU0j+mpq5btreJTz/+iHGwVPUli0oT6BgywxRwtcXZBYvOcnqaed0G9tNAkonKqa2OchshMyrq0KsJbI5jqVYzWSKYgaoRzh8see+9mlefBd68TJhpdn6Yg7glFVkBMQbjHMZUCJ6xXO+qEYzPGEaWC/jFX3rGN775kMsnC3w9gBmZ1fqdMzx6coZffrXw87UOUhvj8Maz6k5wviFlS+cSZyxx61F5FVXGLD1V11I3LU2r/X/JsGwWrLolcZioXE1TneKdYbn0ZW81rFfnLLoTmrZhuaxoOoNvMlMY2W4DVbXGV2s1covqUmWMcHp+ijWWq0+uMKFiGoQshrtpYNpYYhrI2TD2yptI0ZKpMHZN9p2SCsOEb5ZIvWBzvSXZcwRDzGpMaIMlJk/IK0y9wncLhrQjGEe0NZgKcdCnLdMEi9pjksWblpAgTV7bZbHn1fUV69UJo4BMCW/AuZYkEcFhsyWKU9GXXAQzjQGq4wWxWqPlHFQlw6hbLlBueEGZ6xx4Fqag/iROBa6ai+jqhHVbck6kpAHPANkqIk7LL32+nAPYiEgJQmJALPvbPa8++QwrGXIkTL1OLEpwTBmiQBJhNwxkEe5u77i5ueX16zdstzuapqUta6brOqpGZz1N7VitOoYwUreJ3SDsdwM5CS5roNRhUfn4ZcPzrqKqGhU0nqJugBkWq4aq9sqvuSeUnOUIVDDWoOLSKio7G1DONuHzISLkaToGcNHAfPvmBWem56/+b36V/+e/+5950W+LSGg6oAQpG5G1ComeSb91XbNen7Adesizv9URkND3PSGUWZq1uGLwOAeD+b3mnBmG4dCem8IAkqicw7oaL4rOFZnwPnN2tsA5DTvW+KP0GebemnpXMUSD/Ltk2s+LBh8Dlzk8nym4QEqgKwu1zPi0yg7TxBR7Ut6zH15TtQOehNXlTtV4fCVUVcY3PTHdIXTKSyzJm8Y/TZ6dV55aSjWONW9eveKjj57z4PwB1kV85QmTZXMbuLrp8VVmuVgQhobaJ4x5C3YCJhBPv9fAb6zBW2EKYyGJO8Zhr3zH2uI8KiIQHbXrePhwyYOLO67fvMWYhBQpOES7U8rLNBjnVcAASyoiyLPwNHbi7EHFr/7KM37lV77JYunI0mOt+uE55/F1Q1U7smTqr0aT+noHqb/0f/o/413D6dlDvG3IScvQLIa6qVkuF0hlid5inLaZqrqirhtyFrqmwxvH7m6LwTOGSgVf60TOI1VVs+hOikgmYCZS7jE24cfE7uWGfqxwdoltKqTJWCJTGLgbDavVithNbPYT1q1xZkHIIzklhumOnBIpeZxdkCVhvWUIO6YYVaTVtjw6v+Tu6pbNPuFp6JpWkUxJM2zB4ZoT1osVp6dnLHZbvDflJnCEmBnHK26v99SVQIBKGtUlsxZTTUyi3Ieqe8DJo1M2b9+QcqJ2RltKkjDOEnJkSlphOuNQuSHty7vijIsZCSkgMqGO7LPL8ZyB57Lo0yHTlZwL+bRssFmVtDdjJGd9/QOcuPIMISG26E2YrHbuJmGIZU6hLZirt1d89vFnOCvU3mrbqGsxzlP5msrX5KKk/8BqG2u72/HmzVucNTxPke1+y/MXn7Hf7ZmmQBbLfr9DTOS/++/+PLfbW95c3ZBNy7a3eNsQx6iup46DwzBwCAQi0O97rK2LYaWhaZrDpj5v/HPAngMCh/NTNCTVtKi0ZuQA1IgxEPuB1it3ME6Bhw/Oqc2G77z/iO9+8Ii3N9/k9j9/SnZCzkaRjvO8FohRpYxmH6wYIyEGtbK51/abRXJnNQvnHHVT45qaqqAU5/dvS0sx51hADIoWnLUNZzi7kEmp5/SkZdF5LKLoWnsUVtbDHOZQh0BjzL1Wn/lCkJq/P/59//FqAjlbwWjwvy+eG8p72yN2x2IV+LP/q2e0U4QUMJWjXi/oFh2Vi7RdZH3iCgfJYU2lBFdjgFzmPYKvFpA7Xr8IfO/3P+Ht2zdcXmqQsqZimDz77cSHP7liGAKL5hSTF7x5FZgmpXU450mh5tVnE589vsH5U9YnFYaWEAIxCLc3eyQLZ+dL/ZzG4W1d9k2hbQzOTWosmgVtnltEKsTo+7UGrFhSVGoGGdYnHYkeayd+4Vvv86u/9pTFMmDdQE6R/X7AV41aKRmDcUIKPTmPX2mf/1oHqe/89/87QjAsmhOmCRxzKyGyWDYsFg04h/Ha3ks547wia5xz1FXLbrND6swYIHQd+8livcrYNE2NNP6QseXCTLcZrOuQRc0YIU06CMYkjGTqZk0fE42paS9WvNk8R0KFk5rsDKZWZJUTgwlq9jcOmjH7bsnSL8gSCHHA1i3Xu+es1qeYZBjHSKLCO4NxWWX1bIVrGqaUCJJ0IC4BSZPCzQ3EsacfJ2yAKQUsrbaH/EAyW3YpEV4kVouWKBOOyG4YscXZ1oolJg1SwWTSwcepUmUHmVU+RAfL0uutLse5hWalR0XouQUkWIKUXNYWVQcXEV8jKHE2FZBERhhSJBkVnsGiiuFunixlbNbvu8WCBxcPWS1bmsqx7Bq6RUvC4JsFtlkgrsKSqGRiGPaIecQvfOsD/tJf+u9JSXj9+jXX1zekmBhDJEalIbx89RknZ0tuNtf89KOPud1MfPLijrAzZCkabsybIcdzUGYdueghAlinLqYhhDK0V/+m+xDuA7xcZumj4/MB7wS1aZr0xk5ZaQP9wMnlEz44W/DNZyvC/pZf+OCSf/f9D8lxxPpar6Vo+8uV+UPOSYEt5fWHvj/C3sv7UcPDoDYgpXqqqkqND9uWpm4O9vJ6b6o1icLqTQlqCrCwxpWZqeC94eGzS832UfDC7CSsgahwmszxHMySVsfAw+Hn8/GFSupeUJqvF2Z2K1YYtojgKgs2Unkh5g0p33H6wPLo8TOWOWNyQlzGdhXONmpXZgaMHUv71SFzUmdATMCIgrXiBFevNEB9+OM31F2i7VTaSwQkVRg6tnfCZ59ssDlDHonBkIKbPxlx8ly9zvzkhzeEUbh8ekq3rEjJcH19y/PP3rJerzg/e6bQ+hCo66bw79Qyx7hYJAhVJQMsRjzqgp2wZCRlwhjIU1kDUlPV2jb8pe8+ZbmMdEtHP/T048A0CTIJdd0ChpQCKY/M1qo/7/haB6noz8FZctOBz/QhkER1/k1XQVfjssVlsMZReaGuVMfKKfmcSYDFmjwmZbgbAA+uw7oWMRW+qsg5YjLUriZOIyLCyckaYxJ3NxPGQFW3pAiu9oxpx11/x6OLU1zziiHt0V0AxgzDuKG2lhwNhsQoE2MeMGNGhoh3ltP1iqurV9zdXvHogwdYcTy/eo4xiSlGxGwLH6YnmwV9jGyHDd2iY8YFxDghCabosSlSA7b0o60xqLOgw7uWYTR8+9sf0NY1rRd2N2+JYSzQXkdXLzHiaKtOW3mlHYJkhdwSEVGtQSVPq5AlRrcAKRJPufhACRaKUaGxWhWUBx+g2qqLWL4AnA59jQVJoexHUgImGhysQbJ20ZtGb8JsYBLBI6pJWMAJkhMpi6L+mlbFRge9VtY4nK2oXEPlhEUHYz+xWKx5cL4kI3zw/vv86i//KtvdyO/+v/5H/uMffMRoDMkZLBFb9Npcafc4r7YvrvbobwTGJNAbKmvwzuB1GKcACJM0ubIOY46Z/bGSUs6NklvVlTilxKKyTLsd05iwJoDvWZ2dE21F0y2pzJ62hqo3Za5jOAY8ChQ+cXt7iyIU6wLImM0iVQnBWNHM24raazidXWAUZXcfKDFXZKnMFK3Ryskbj3WVIjAL7H/lFzxcL3C6GJAKxJkDQEJnJbpmjlVTIfgW1+vDnOmwY7z7OTEa5DIZxKkPmrGH1qyUOZ/EVCxhEkImTntsHvE20nSeZeXUokIyxk/qaos+98zr0o6Dg6Lz6StNwLJsubkz/PAPMx/+eMcwZh5c1rQrwdemzEAF5zJNDWkaGCejDuLSgBSHhqQk/H4MfPzhxGYzcPUmslovCWHk+vqa27sNv/iLF9T+XNXPzYBIKKoYgRwzxFZNOxnBjCAt5JWKc5sBccIUR/Zxj7E1TdOS2NM1kQ/eP+e9p0u65ciu35KSYQqWDz95ThbLd779LUwR5M5xJEx/ClTQjeswxjCWvqhGe8FYSzSZMSW6kpm2Vs0F60qoavBNRR8E4y3TZOmTmh3alA5q6tkKUSbwubSg1BXVGXAIlc9ULmDoSckR+x6RRMyCsYlhCGzuHKenZ1R+hy08Dodj0ZzRNZ3K7lQ1Uw4MDKxWC3IKeGPI48RnH33G6WrJet0x7SdOT1YkGYlZ4crPnt3yf/nb/w91vDSGmJSXkkomboxBUmQcekxpgx3l4gvmAJQp7h2LtqHfb7BGkBR1RlJu7E9+esG//3//WvEomspzHAcvxoAh443XlpBMJWiZ+1ftyHHBHLzAnJ37/3KoXFVVed7Qil26GKRwjAwJxJbPpBBlybHYTqhGmbXFFLPyGK8DYFXkUHFZawxii3CmyUjcY73asISBUiV6kIS3hqpzxHCHxeF9R4oZCYFahM5bRAKRiuw8VlLJxHOx4LA4r55JttKqMspUNNAMpqnwQE6xkEStWisYhYkb50j9VFx4ZydeRRxmicQUtDVrUCmmaYRUsahB0i1XtyNsOjo7klzAG8FlCMkcrqTqRGoikXJiHEeMMfpcRY/OGDCixnYhqGN13VbKB/MG4ykurAqnV5HddJyfzWAS5mRkrpBUcsokqMXTSoUTMN6QDq695nNgh89XSvNzfy4gHVb7vVkU6OZbKnxbghTZFDPVYk1hBO8d1lXkNJFDgpDYbzeExpKaGlcQhd5DJB5mi2A0cSbhvSDZEEPAiN6vV9d7fvyDHX/0A8v1daZd11xcdtStxVhHSBFXJdpF5vHjBW9eVrx9PRCDx9ta24hW23G+8JpS9Lx5OXJ79YaquiXlSIw7Ts4aVqtTrFUVC2dBkhKMp3Gg30ZkWmCSYOjBDlgqMsr9TEYJ4rthy0Ckaxv8wpNlz8l5zbd+4SGSt4QxMY2JGB2ffPKW7//wpzy5fIKAimebQJ7mJOvnH1/rIJXyiPeeMI6auYm225x11NlQJ4erDFQCTuXi68rSNBWu8kwxsVy2jCnQNJXeDG7OsjJNU9M0npQj3ldMkzLPV4uOHCeaqiGMhtVS9bK6xRpfWfb7O+rGMgx72qbh2eUzxv1AXTVq55ENw37A24o06aB5CAMjExcPzhn6PZ9+/BFtVWGtoWtbxmFgu93jq4phvyWmSAgt/7f/+/+V1XrN+uQU52uGEGjbBfvdXgezGOLQc/XqM2qbWbc1od8SpoEUIs57Qk5I3XF+eQlp4OUnP2JRC8QRMwcpsVBQTdoaUGKuHnPrxx5aOFlUe++IvoLjBnF8HPOGc5/nw33uD4dAJeV7Ja3Kcb59/zXK9/cwC7o27Az/NtzrA91ryRkFBpbXneWHji013chtadfZImhsC9opxkxbFVUBUfCMJLW/UP8cRbtZq5WUzpqyJi7OKQpQpARw0eAuarHhvNrHxySHNqBugPmgQK4VlCqfZ1El+8p4KucR9sh+x4cvX3OVG87WNU+/9Yz1es3z66wqLUaNM621VAVa7ooxo7VqGOi9tr6dWkkzhUmRgd6pJUml85a2bd71WoNDFTXP5A68Lj3hOpc02q5MKZZg5LBWibYYq84ChwrnOLv7Wcf9OdQf93vvrkldHrOOonq1eZpGLTFSiMTJMmxGtpueYbkgNK4QX7U9JklbkVhdp9rWUhK4NZ6qdqQY6fvID36/5w//047N9QnTOHD5wZpnTx+z6E5QkmfC2Im2s1w+fcDmdiKMV9xcZQxJ2/0oNH3mrmnVBmMSwjRibCDJwKPHD3h0ucD4HdaN5ByL35rh+mbP9c2OmDuSQLYWNY8t83zU8j0EISZD23S0bY0xmaZxPHvvkqfPLhG5ZdhPSDI427C53dFvR6pnjUohhcgUIzmKKlt8heNrHaRqr8oKVlaQMpX1eCyVsdTF1VS8hcZSV1C7TFcZqtqzGwYkJX2MFWqviyxpLosATW2pa0MIeiF0HhCpaujHRLOq2fuAQe2fT9cLlssFL6JWVIumZbnoePH8Odu7DZWvGPsJT0W/76msampVTqWHssnsru6IYeTVi+c8fvyYy8dPuHlzQz8MnJ6fgzjahWcYt8X1Es7Ozjh78ADrPNtdT103rBYd3lfEKRCGgbDf4tLIo0cX7G4rbq6vyBm6xZpps6HrFjgLtze31HWFYSLEqOZmmLKfSMm4MwV/Xq7EcV7iiyfXrAbwDsrtfiy5N2P5/EZyf0P5/M+kqC3Mj58z8C/bgg5QaTPzZO4N1w+zjXcH7+98prIhIuhjJZeVoRtmLvM1a3RCslx0qskmWaHU9967NRwMEIFSDYFx8+arnK/5tUVK4EQ36Jwy4zCRy+PAHKDowzCoxl85FzEGclGvj/3Ie0+X/B/+t3+WlQzYXgEd3YNTrsYlP/joR8zweGsEey8wza8BaqzYdR3A4TOEoHPeytQHeSRTwBPOKWDgfiCJUWcs1s5zFErLrXxm8gG5aGbIepErevd6lYfeq6A+f3yexPvH/e6XPPqdNemco207nGmIYcCKxxnPenmijthZuy4WUxB8yuNSu/ipzGE1qIgYvGt5c3XDj37wih/8QeLtq4qmNnTrzNP3Tzm/OMe5Fms94nti7kkIJ6cnfPeX3sOYlp/80RV31z1ET4yCJeOcwRiPZFeAHpGY9xgZuXi05Nu/+ISLRzXGbzC2J0UIsWN7N/H69Z7tVpG8SQKIL3e72tHHDPu+J6ShaCRGYtjStR3f/cX3+c4vvodxsVSf2tXICdKU6KqWh6cX1LZGYiJHyHFOfH/+8bUOUsva8OjBGme8yuBHZYJaDK44rwYSuWy2UbLyhMiQIMekumlZFSdSTKQY9P9NJriELr1UkHh7jIlYo0g8XzdM4ZopDOQM280N47Cj3+8xZFbLjjgFNrd3jMNI8rm09yqCD1gsqcB/c8pUvmJ3u2Pod5wsTrm72vCL3/0u169viEmKjbgliagqhugNPQwju82OlDP7vqdbaCWVs7Bolwy7Dbvdjjzs1O45TsSYFTafdcazXHZs764Y+g2NBQkZ7xzk2c/qHkSZQoY188/1Zp6rg/nX51nScd8v35SN6Rio/pigJHMr8T5AIJXn+uM3nvuPPVZSHH6mlZg5tLjmNzdXUhhl6wv3fIGy+kcJes00jOgmtFjUOGuwWQgpKjZqhmlzfF19b2oeaK2jrjzGKqgg51T8iGbBVznEzpQgxkQIiRCU0xVjLJu/tqRDGPV5sKRsWbYVT89qLmrB7HdUbkG2jv1uS9s0VN4ROV4i4BCowqQCp3WtZOSqqsq1e7dtNx8pZaoyf4opkketzma19vkaeH9f/QGsMzpjLKtrvra2zHOMVY3DQ+LzhXP5xRTly+Hmf7JjnqN5p2AQbxx90LXXVJ7m0TkLF3FON+3DvLDMt1SnL6DODGCwbLeJ3eaWP/zeJ/zw+2/ZXb1HihFpNzx93/PNb5+xWrc6YxXVKMwoxLuthbZdYq2nrmo+/vCat6/37LYDMUWsqM1QP6hai7GJurE8frLm29+95NHjFZkBiT1iesbJMPaOzz694dXLnmFAW88Cai1SCNe5p58m+umOTE9dZdq24vy85Tvfecav/eoHXDz0xHxHjHsqNwt7Zx4/uuD05JzHjy7wBsYYCi3F4L7idflaB6nGJMb9lrvdgGBxTiV2rLGaFZZhqncgYhEHrswurLHqxkuia1uEiWgN0eYCY9cWYFVZVQD3Dl9BlkTlazabyDgFhnEixshqfYpzlu12Q1PVVN5ydnrO69dv8FVNVTWkmLk4f8iwG5iu7zDZEqdItJlpnOjTSIyBaeppWs/Jeo2xjikkhnHkk88+w1lPij3TpBUTwG63wztP07YYybSVh7ZmmgL77R3bu1u6piGR2Pd7JE7UVQVWyXVN13F2uuL29iXkqOoI00jlKAtVK4ZcdghnKJv6vcB1QKKVzaigrmY+1TyEhrLx2p/dfvn8pnP/31nkaIleqph324Pz6+pm93mtNri3ad3b5Ow7A/Z3Xn1uCB6ceJn/LgACCgCjqTzOoLizolN4FDJ9N/AKWtm5meBqBZFUMtHjzEVkbjE6rPWEMDCOgWnSr4MahQghTEzTCIhqKU6CxJGTquLEJ3znkcljuiUpTqwXrc6ljEWyFNThcXY0V6yK8KNA5O8pNIhWVao5qJXTAShRnlMdlBWMMCuqHwIUc4VLAYUISGZmfR1h5cdW7f1K6vPH4fqWNfnz2n1fer2Fe2uZwzqyxiBpJIxbUtji6KnrTOUz1kQkT6o4YXTFZJk0kSOUhKRm6oXXz0c++XDLH31/y91VjUSL9RMnFz3f/jMPubi0uCphRO1xLAZftVin1h7WGR49qWm7R5w96Hj9csPrVzfc3t0RQySlxPrcs1wuWK06Tk6XPH16wYOHC5yP7Pd7nE+IMYw9XF/v+PjjK169HOl7B3kqAdUgeFJOTPmOKe8w1cCys5yeNbz/jQu++51n/MK3L2nbxDC+pO0sdeVwWGLM5DhydrqgqjpWyxrJgZSL8o2BWdT45x1f6yC1WnRM04hYg6laesmaz5ikw3GgBpbGESVjEkjSYW9TL5hCot+PJKdkREqrxHkV+aylLrYWmdT3NI1nmiLTNDImYdMPuLoGP3J28YBlt+LNm7fqPZSF/RCYIuzHQNcs1ALD1aQ8MkwJSUn3shyQBN5W6h1UNSzWK3xT46uG7/zid/nxjz/UbNQ4Kttxe3tF27ba6x8nrt9ecXJywjQN5OWSaRiYhpGUhGG/4+njC+6uR4Zdr5Wl0wF+joGm69jvN4oCk6BcCO8IY0/lXak9Z/SUaJDh/gLTIKWZslZU1nFQlZ6BEIdcWTKSpcxe7rfYzDtZ75dWWAjDOCoEPYkK43yh+uLghDtzc+7/H7ybhR9nJPoK8+aWS7VgrNXgq8MK/V0ztwAtRrRar7yjdgafhClKea4SBEuL7FCBmPuvk7StVQKgdUZ5Y+ZoGpiiws5jzMSgbSNtxZlDgIopaEVSPq+vLAwj56sH5HEDBWm5H0fEwarznC484yCMOdM6dwBKzIoWisbT4FnX9Tvq5yknurYpszZb1N2LvJStCOFIRLblvM1zqvuqFVqVRqIcRXLLUEfbnhRulNyHmH+xyj4GqeNa+mPbfWUWNjex768H1SU8rhft6SVy7oERw0CY7jC+zM1c+Z1Cjs4SoFwHyRVxcrz4bMdP/+iOTz7c8falBVngq4i4K558s+XyfUvVBqbYU7lKqSQkLDUik5J2bcZWmW5pefJew8mZ59kHa4Zh0kTDWbw3BwWTpm70MVaRsJIdKTQYWxHCyJurK1693rPbezK1godEncolRMawZZzusPXAybri/fce8f57F7z33jmXlwuq+oZsJlwTCFnNLbMoZSQbaBoNXJInTYCsYRgDVeNw7mcnHPePr3WQilG4nfZIsyClxC4GcEbh5UZLcAWvOJL3dM6DKcxvqyS6kAaMNVjnGcNA1VbKV6lqBEdIotBkAsOUqas1YxBMVePqJdlN+LZj2w/s9oEYhbe3Nzx7+oyf/uQnvH57RcqZMLyi8jU3t3vaesEUgaxadTq3VvHRECKLRUtIwu3rNxirFVkIkf1uoGs6dsMeg2W/69GVlwj9nhhGNpsNw36vLaCSyYewZ7fz9P0WEW1n9uOeLLA+aWm7htevXzAOd5ACY1R0YV3XGkjNvTqqVCtHesq7G8XxMCpzk7Qyc04VnWO6Dzv92dXU/az7nSzY6Mair/nlGfJ/q0M79tq6c9aw6jrOTlZcv97hrSflY6vR3gMRvNMizaquYZza2d+v3PQceJ1JZW2nmSKyihhSlELejffOQ1Y9RJuYtltOXOT8tMW5XlvX1YKmboGJxdhzsXS8GSaqqjoIyoYQlL9U13jv6bqOGCPdspjYST60GM0ctMsxf14xhqauSUnBRiqHc/TAOpCSEyQjChI4zA4tKRcrdufxvkKMQvZ/Xov3v8Shwc0S41RU7Bc4Z5A8qiGkTBgSTePVlt0ouCjjyUlIhzXrydFxdxt4/eKWD398zWcf92zvHMgKZxqS3HJ6nrl8uuDkrFV9QtMwDntNXrzDZofzS1LalbUflHfsM9YHTh/UPPRr5dthVAYtTYWLN3CwMUlFlsg2IIYQA7ebPZttpO8rJCtox9hMFvWOMzZw8aTl2TcuePLsnMcPH9LVjkUn+GqP9SPGJqzxZKkIUeenKYq2DI1qYQ7FjDMkyxQMvmkVF/IVjq91kLodArluiGKKoVilWVGYMASczVgcUTxjEgUBGEPMqrRsq1ZVzoO6wY4xsDpdM6UtUTJRCsLIL+gax83NDVW9IKRJtd6myO2+Z7PdcnW7pXYNKSTSlFlu9rx+uyGK4zvf/SU+/vAjUsxcbwbaGrJYBU6UDddVHlcbTFsjDvZx4m6/5/oHP+Ty4WMWixXbTc80TgVpZdltd1xcPMDiCdOoitV9r4Ekq2FhIoNoO8KYRNM4UlTUmXUV65MlWYS+30IaVANvhs/me1WGFWYwlhEpmn7zlZhvSq2SNLio3pkpG6xmTbM1AryL9LsPXuCLgen4KofZlwHdIPN/+yA1w5vlEFSKsC2ZRdeS0w3OlyA1owFL20+RflL4IkcCrhcFHcDcXtVj1qlL2ejNn2ZKwCyPNM+k7hEjTUbiyDTcsT45YbVsEduDb/HdGc1iQZU2pGniG5cnfP/1C5puyTSOBzmkruuwRgnGc8W+WCwOQAKtkNyBPJyzGhVqhWlxlaWqqlL9xUPb19pjUiNwkH1CiryWKW3hfJyNeVcRzVcbsv+XOoyZEZiiTsvWq9VGSEhUxX3valXsR/C2wtkaULUXIROD5fY68NMfX/HhT664eRvYboBcUxfupXWJ1cmC9ckpxiwYx4ZhHximDYulwdsFMXps7shZCGFEcmlH5kzbOXxRIdckJxPTSM4KfNJ7yxbe2Kw7SKlKLdY7hjGz6xPORFwVyXkiJ+VoXV6e8+f/10959NTRLSwSIE57jKmoa4f1MEVR52GzpJ8yQ5iIIWKTkKaMZcDgyUQ2u55tP3BOp5X+Vzi+1kHqJkwsVieMQUhRWz82R1orLJ2lwRBcxTYLYZx0cWn7n5wnFr5jdXrOlDMSapITTOWV+BkSqR85PX3AfhCa2rPZqlfO1d2O682G1XrNOGViURhIIWLFcvHokpevr7nb7rF1ja061eAzESbDmMAZD67WFoGBbB19HPHOMkwDZ6dLrDXs7m7Z9T1PL59xe3NHv93jvaplj8PEer0mTiNDr205a9SLKUwTIQwYm0hxIASnCzfp0N3X6v8kJK5vb8hpwpWZgHdOCX2xSBcZ0YBltTFyvzU2/30MLPcVCZQQa82ssM2h7fNuFfX5dosc2kTcez3tkxfAggjG2WKZ8V8/uz4eX5xdHdpXKbFaLrT6tKXaK95Hc6BKKap69ExiLp/PGCmWE0mFfbMASR2SoYAikvKyBJAj8g7UmE/ngcppCsMGG3uePf02TeMRZ6lXJ/jFOdWiw06B9bLi2+8/wn/vObthwBfQA2Xu551KHq1WK14+f8HjJ4+xRSnCe09VV8SSNEAxCyyJoBcl3M6zrvtt1ndNB8taEBXuna+/8+7gEGuMQv35QrX+X+eYaQfzumtb9b6KoyFNBmcajNRqY5/UfsLYCmMbxkkIk+Nus+P5Z294/skdr1/u2NxGcqrUJdyCcT1JAs5Ctzilri4YdhX9Hp4/f0692HNZ11SNgOno96ooYZ3HOZAcinTbjBaNJBTkNOuI5mwK96sQlkE7EZTKyqjXmYgjp3ljDGSZSMlinWWxarh4tKLu9mQCKQmVdyy6DudUpzNOADUiC66ut2z6gX7Xk8bEsB1JY6ZrlwxT5Ha3pZ8Gzt8Gzs5XX+l6fK2D1JANeVTYpISApMRJW/F4uebBsqGxwibDi75ns9szZc0sTLbEMWDchGtapnFPP07sh4F+HBj6Ae8rxiHTdonPPntBVTWM48QyCptdzxQUCu28Vz+eSkm6FkfTdtzefUq7WBFS5qc//ZjdZkdOQpySDqqTkGtIoYiMVo4ogVy01i7OH5JXEz+6vmM/jWx2O9quo6orhu2Wpq7x1jINE5syNNVEKuombqQMs4XiCo0g7MYRg4pLasYXCdNee+rpuFFmCuIqHxtQijSTw5xJydMAhRRr9MaYq4wsRkEqtiIlNYpTz6LALAAq5XH3OodfmDEdfl6CWb4ftCSDcWVIrb91/7mOxx9fcR0nXj/vOIzlD4/TCZ2As6zW69Iqiiq4W6DvuinrQNkboYyomGHjM0hgRi/mJOQM1umQO4RiVX+/tXcPECLzNbeWfpoIw8DKw5PLE6rK4G1D252RfYPxHhsNjTM8PF/w/pMLfvDpFb5ZKMow6ewtI4whsFp0WAvLxYK6qpiCKoM2TYOJyrWbBXBB10maIiFPeO8K4q9k7qgdhjOm0Bu01S2fq6KddxinKiWZufx+d355P7GZq/fjXEpb0rOlO3Lv2s6V/Bz3CtJSEZ3vVvLWGuqqKJh7teOYxsT+zZaJRGOFHDI5DcS0Z7sZub6+4+Z6y9s3W+6uJ3JusGahM1RriHEsMoGZGAzEjmFbcXu949WLK2Le8sFpi7VCDAGbAyF4hsGw32/JkmhqR117JFt8ZXDelgQnkaIh59I+LWrrGE0yVQJbkcHDNLHfB2JKGjiNFOWYpK1sq+3565trzr3DWGHaR1Z1S8qWGACj2n/TZNjc7fjRj5/z+uoNQz9iEoR9IAXBWVVMH0Ik5MTV1cTJefdz7zb4mgcpI75knRGXRjoTeHrygIt1xcX5A2IQFllYtw0/yROf3N7RLE8wAl3dEUKirXUZ3+5uMUaofcWE5Wx9zm474Kwnx8zV3RuWp2tud9cglnXTUEtmnHrOTxrGoS9KFA5Q5v/p+oxxP8CYWFULTOUIVi0NxjDgrBBkpFvUGBuY9jsuzh6xv8n0Vz219TSyxLqKlOHBk4dc377GDok09njj2d9NmFzhXcZ5g290YLrfDVSVWgJI3WJ9S7aZUTJdUzOkSOcE8kCcbvFGhSSNiaiQrqo5QIXJRRE5B1xlmKyo1YmBxhmsSPFaMmA80XgEh8mCd4a6XTCMExDJYY+TiLeRZC3Jeoxr1ERKlJtkD4gunfcop6hk5MaSks67RDSsWDNL9Sg03iT1jIohFlVuU1TDM6Zk5rm0NWf1bBEhSck3y0aVSxDFFCWPosRjjEeMQ8zc2BF825L6QNMt8FWNF0fIsbTkRKHEqdgeRIP3TmkTogZ7klUsF6v8kpw1oGPUJXUalRztjKH2jnHMVN4zjBOSMt5YbIY8RuyQsLGiWhhOTjOOgQVrmnBK1a2IeacITWfpWscHj1s+frEhp0CUFlevCRaG/Z4hTtghMwxbMFpZH6thnVumMqNy3uONtolMzjpXyroerbFqOZIzpIinwaGEZ+MrjKmIJfGJEsBlbGUIErC2wnqdw73DrZF7wIYScXT1iDr5Si6B/PDrx0B1GG+FQro16LjfYmzFGCN1XTMNe5Ztparn8pZgt9zdXPOf//338COQDCEKMRpSgqmPCsZKovNEWiRbYk4Kgiltt6D6Axibeftyyx/+/ic0XaBdJp4+OuXirKOrdMYVQk+QzJvdhp/+5BO2m5FFe8Kjh49ZnyxYLdS7yVgVt065KMnnTFXXxKCOuMYYUsx474kp8erVxKs3hn0YocoYatIUSwcjEnPk1ese//3Ao4sTvEtUHu6aniSJ8wfrAjJxXF1d89OfPOejD6+4vTaEKWFE5cYsBhH1QKu8xxlDuB142+++0j7/tQ5SIgo8yIA3QlM7Li5OaK3n7c0N/SAsmoqmsZydnfJ6mghG5yY2BSQH6rbh4uKMXdoTwsDJeo1kYblcMgyB7d2G9cmauqmY0sT52Qnb2x2rxZLTkyWfPf8IQ2LRNYz9xPrknI8//BREuLq+woshTSr6qgI+M5Q2M4WB9UnHk6eP2O42DOOOy8uH3OB4/fIlJs0dZZimATvBmEd6mXBNg9Q1YhsFhkyBsQ+EfaChxgXNfIY8MIWAqxP9FHlw8QRnhTjtePrkjDcvPkHChKl0mCpktYcuOnFgqVxLXdWEOJAI2KrYoCdF7FijHUHgkKWqerKqtNftkruxtBbGCVtQZs461KNJidJ8roK6L64Kc5YsKE1qLr8Oq+HwnRFt/f7cLmBJ0OU+jOt+sv6lh7n3NR+qn+eM0Fae9aJhf7vX7FWOJ0YRalpRHVpetmxWB8+qY7tpJhPPqhUpic48s/L2ZjJvzlldayWTQ0AlA4T1ckFdq5P0cnFC4xfaDk6RynumYhz4/nuXLH/4Y7aTeoOJEW2jWse+72mrJVWtFvBVVbHZbg/qBjmp4oQKxmrwmv23YggqAQQqj1QSDzdbuqPt0FkvL5fAllJUcIgxB/HdJIIVuD9r/9KGcZmVztW0fFmA+sK6KBXU4V8KDsnZUPmZ8ySMITEF4eXzaz768UtMLzhbk8SB8VjjIQo53/e8KglQjsRp0Hvsnju4sQMvXl7jm1O+/YuP+OAbJ6xOHMYEpqH4f2AJIfPq1YYf/egldzcjtd/y8XLHer3k7Lzj9KzC+okQ9uRSWU7TRE7COAXVuzQQQgJRvt3tduL19URIe5yrSVEHW7NnGiay6Uc+/mTL9duOykHTQtMKN9sVjx49wDnHNAWur7e8fv2WMUaa1SktThGrVpv0dVVhDayWi6J4D9FE+P5P/ribDfiaB6kkKvgoohlv3XWYquXN9Q0vX90wBMu6a3hyecri9ITq7o6+D6qRadWhdz9sOFtX1E5hvn2/RYgMw05VsbOyDBdtQxUtzx4+5rPpBbfXVxgTSSFy/uQxbdPy+uUblt2CHBMPzs8ZhwQxkQq6SdV81JjtvF5R1ZbT0xUXD89xb4VPnn/E9c1b5buEAaJQOccUem7vAlKvWZ0sGNOIXSwxPmFSRdqNODqWXUvaDXR2gSepntfKEncbuuWKYcycnp2zvb1hvTzFmYq76zu6uiVMBb6MFAizIRtLxuFci+vWWLNCJBAN+DAi4w6bR6yJZMKM8ytTG8HYiv2YaB6sqM5rhmmPc4KELSITlViseHK6R6Dl3XbfHKjugypiuq+N9rMPA8fN4JBR/y+ca3zu4bZsnuRERWbhMxfrluevXkG7PP7ivSB+bAGWKVuZ5VBg7wZKANNAkDIHx9sYVeUhpdmVt6jUl0H/FEa105hGHj14wmq5xNiIr2qsU2sMdZSuyOLJpsZXCqIxhSMYYyCmiHOevu/xD85ISdjv+qOyhCmt1tLiU6LvEZ0nSRiG4fDvmUtljHnHZ2o+pUkSKeUD5N1X6i7rnNrE55my8PkLMf91mFmZY8AxX5JzmM9/O1dnc9JjDvlKSoll2xzV12WJt2ds7hJ9D25SQeBsKFXihMkaeDG5AF0isXQC5uec0UMimaoWjO2pulNOHiyx3mhlmiI5JcAz9gNXN4lXz2+5ebtn6IVe9txejfjK4itwdaCqY1HISdRVe+g+GOOYxolc5oPOqQtEMpm2jayerTDJEwYFmuUsqhnZGCIjxmQa52irmuWq1kDVVZQ+BFXdcX7ecnr6GOtagi2AmaCcq6ap6ZqWMKqPmHfq2bUdv5qh1Nc6SGWUuzDf4IvVmoTlzc2Wm34k0jBsNtQLz8XZmWb/eYAM0Uy0VcsUBqZxx6r1ONew7wcWXUPKUXkGVcPmboOVTGMd42aDE6FtKob9XkU2x4kwBgyOl5+9ZNgPRbAWJERSjDjrCCEhor38s/MHtF1N01aEoMKy77//lHG3B4FHjy/IU8IZw26wUCWWq46n37wktULCU5uMHbVVVNWG9ekJsd+yqBZMKZBMItdQ58hyfcLN7Y7nz19RW8ODk3NeP/8MiULTNoQcMLZkkCIIDmyNdQuoFgxUhJCxtsLP3kA2kWMiSdQb3Ryh6Wqv4Mm2ItiW8/fe45OXn5CTR6xgRoMT8OJxSRBr30G1ff64D6jQDVrnZ/P/fRkP5j5p991A9b/wMIrkM2K0paFTURonVEQenXY0HmKR9tH3mEuF4DFOEX6YjGAUop9VIw05WmAYKAGJsoHrTCojZCXYAXJAoqVYxGdRQvd7Tx7TLWrlc1mH8wqgyAjjOOGbFc1ywYf/3/+ZYSqADaebSxaHM5YYAsvFknEYVRHdGNq2ZeZwGe+OgXeWeCrt0ZSUWzW3V733hy+YaQaUqgVS0SEUUZNFU9x2pQQOMXKYRx6vMQUpOM9CjzNRw7GSwtwPV+be3/e/5mBVfOlyoGmWWsll4e66p99Ebq56RFQVPqFWMTEF8hQx8xqVdJh5KXgBQgxFucMVgnTGeFHfqDqTTWQ3TGyHSXlWWCRb7m53vHq14e72hsXScnKywBp1MrbO0CwcvkpUjSpBuOITNauF1NVskZEOASpnQWwk2AlvairbkCcw4hinkUykXniSCcQ40ZiOxje0nSelgSkMqPCutmpznkhjIlswVWAce3bDFu8tzeqMUSY2wx39fke36Ojajs2+/0q329c7SElSTxaMoqicI2RhP00MCZI1DCEwFc5FZSwVlmQFrJBdonKWuobFYsHr6z1uUTFNwjROVN4S08R6tUCiSr5Muz0mRd57eonzltuba+IU8K7m/OSUD998xtn6DKgIY6SyhqHXDDQlFa09Pz9nuWzZbO4Yh57NZuDkbM3Z2Qm36ZbbzR3OqWIwIsQ8UTlHVVvOzk/4ZnfJGCKbq8i0gU0cGDcjV7srrve3yAqyEbIVAuqDdLvdktG2y+lygbeO7e2Gtq4Z9gO1r4h50krKGMRYrKtZrB6wXD4mZMO0uSEbIcREZRzWJjKBnMMBgo3RdpsxmSkkuvVjom/5xV/6NbonT3n56Y8Y3n5KjgKSqE2N+EwvIxzmUEdy8Pz9IUDFdE9+6ecTLQ7yR/qv/xKrDg5zDzlWUgi1ExqXefrwlEdna15P7sAjUph1wlqKOG1ExJagCzk5pAi3WmupKp235qgb+GwEKQcF+yOSTmHjIykGTPE+f/jglPcuHzANI6wqpKrUpysnnBcwDvENf/Txh/zBD37CFIVhUpubbFRFIpWgeLJeH9plM/y8rnWTzjnjKl+ul8NXvkClFeDRti1N0xyuxRykDlQCK9jsSEYKQlFbn7P3kGSD5Jkb9nkBp7koeTcAyeHv+9JX8/WfG4Pl+6LATkEj6u+qaHCaUNFcUTCIt56cM7d3N2z7LXkYadoaV3lsZWkaw7LuaFqPrUxR4Kho2qrMIBNZIm3X0Lb1AaWZ8sTDx2uq1hNlJKasig0pI2LBNjx8bHj4ZFUCgkekom0XTDFgXGKKezAT3aKmMhXjfmLoe6pacHYiRlWtcb6mbTvCNDHGyDRFIiP1wqrpar9nSpqw2mqBWEULkwBJiPXs91tubq/IOXOyPmO5PGW3G7m93RFJSBUIKbDf7VgsWk5XLdnAOOzYb29xJuER9rvtV7rjvtZBClRDy4ghhwEn0HhfRB8nJfbWyp0yOVNjYApUtRqPBUnFN2eisQ2NVfXf1nt2NmJMzXbTs99uOF2tmXZ7zk5OSDGQ4ohkQwqBEJREfDdsubm+xbsO0sTYTyCZMI76OilweXkJEvj0k5c8f/6CpqnZ7XZcvveYxekSDAxjj/OW7WZDTpFuqcoX+37L7e1bHj3uEEm8CTs2MdFXkR09r+92DLJl3I909YKYEnZSRv2+VwX1s7MzHp+f8+b5xzjvyeMeSQHn63JOS1sNNe/L2bIfAyEbcDU560bhAecqjFfTQ5Vb1XzWFSFXcR7ja5rFmtX5BQ8++ICYJl7vN8i+xxHL4p+V09M7VdEMsT4AG1IiSyaEUPTcdL6R8lGk9t1jJo5y1NCTe5XXYaJe1B8wqit2QJJ9+ZpTqw97AHhISnR1Tb+9U1kYJ6zXC95cTYfXimk2kxO8eG3RFSxALqTYuT3pCmRbivttjFo9WmMUmTWjsfIRWzijJ9VnKvHs8iGni466Sri6wVa1zhviSG3AGs9uzPzH7/2Yt3d7otFEb56GpViq5EmN8boZEFKqoIMeYgnAOmfQynEaR6ZpxLnqMLs6Kk7MRokKl3a2KIiL1SQHVFg1g3PltSh2HtZ9AX9pjHln7kR5/2LMPJ46cOkOMHaZ/89wgLDOSutF5WK26lCrdG2pZhkJcU/dGh49OeWka2m6BldU0JdNzbpb4D3gNZmovKOqPSLqbyaSaNtaVW0mtdWYwkDdeoZpYhg2qmZvLc5WhCkp7LsBXwnTtGe3nbC2KZ5PsLm75fbuLb6Ci4szOt9yc3V7cFau65bddse+Vym15WLJNEVuN3vudgNN1eGf1tSu4eb2htdv31C3NY/dJcbD7WaLCcKq7ehyyzCN7PYDKWa6TkjZMIbErh8RSVQtSEr4bKmzx0a9x2wQauOxyUBIdL76GffYu8fXOkhZ0QGxFWHddvgkxP2eVVPBWUX0xcbZC4wDS2NYWMMYI1SebIqOdcrYnHnv4gG7YSCKxWIZgqLT1qslYRpZLDrWyyVN2/Di6g1N0/Dk8pLXr95ysjzjzasbmqqlrRakCJVt1BW3m3SQGQYuHpzRNBVv3wTWqyVPnz7j7du3eO9ZrVasF2umXaAzLY2rC8Q6cXZ5QruuqZuGh2dLapNhl5B9z6Zx7GrDZtcTfWTMI8kKcYq0okKPOUXImnHf3l7z/MVn2DQqItErP+bYqjtu0FkyUz+QxFK1NdY7Fby0goy9EgZjoPZAyV11k7DK2nCWxWJF1yx4+vR99lev8dtr7votbO5AhKr1hGRmo9ovHJ8n986SNcAx0PwJjrlF9E4CDse4JD87RBlyQSvNFZXBGq+JTrugHhLG7nj0+CHP+yumXKojYw9VhqBEa5szVjzWep29WKsVaWkRzryjwwxKlDgsBc04k3lDVJ8z7Nw6S1ycrqhMxFcO4yukWIQYyUiOYCw//ug5P/zoFWOyiDdYq8N/QaWeaudIMdDv98SoAswnJye8ffu2VEHFn8u+e7bmislZfyDkzu6870oiHf8tMoMmZqHcSIxZr49VYn3KEXOQw73/mnKommZBWqT4j82/IUUCSe5RFAw4pzJU2pdzGsPE4Ky2WBFtQ8Y4EsIGYc/l01PMg45115BE+Um73YaYBqJEBOiHnt1mg3VwenqC845pGjEIXWoBYbPZcf1mAqOzaeuE7faGEEbWJ6e07YKrNzf0/cj6dMHp+ZIc4fp6xDthOVWEKdKPE31vqGtPX3mCzew2kFJN5WrS5Oh3jnGsyEFpMjlZdUgYRyQm9rsJaR0hRPphIhlLP0YcFUkqDIGQEmYKhKgVt1jLGDLVFDDOsVgu9PO1up7JQlV5Fn6BtVCdVrhzw3K5pOtaxpiB/8/PvV+/1kHKKZAfaxxPLy44bT11jjw9P4V6yS5bmgqqvKO14E9WeGP47OaGfoZ2FckabyzrusbGwHaK1FYYJYFJVE3LsN9TW0c/7EmSCNNA01ScrleM+4AzjrEfqazKt6QYkGwIGaZRnVNjVFv6zabn7dVbELXNfvToCc9ff8brN284W58TYiKOOzUGy4mq9bx69YYn3WNOTs9oKsdJ50mPW9pK6JoHPH3yjH1/h3UqaNl1C9IUWZhKbUzqDhHDarHiD7/3B8Q8YSVgTCLlCZc9c19eiuOps5a2rgmpIknhi5jMbghqOW00M/RVacXcq0jmwXUmE6aJ3fUdV+4lbz/+lM3L14T9Hi+BkBNTymT7xXnUz1KgkKzgDuPUgfdnqVwfR1I/Czzx86qmL3lOysZp1F9HrRc80zDgmwVT3iCuIpes3BSbDWPvEZSNki+ts/iZ1HtPNukQK0sSllPSIJFiCaw6k9KhfCBF9V+KSTfwpql5+OAMj8LvjXfgPSZDValzbV03/OSjF9xsA9l4TS2MPwzayVB5Dzkz7PeKCoyR5XJ5qIKqpj4658rReVdpAVo5hRC+AJQ4Vsv20HXLktRTqqAYh17905rK4ZNhUowrfGmQ0uM+H+2+2Ozhat9TJ5nRqDmDSUXtxMZDkqYuwGCdJSZVl49xT9/f0o+3TJstd5tMt2wRC7fbK2QasHJOTc1mf8eb6zeKK/GwXC51ThwT4vR99lNkP014XxOyihT3UyJGoUkGG2FKEMWRpCWkFZJRQ9HgcfsKS0Pnl3SrCypvaW2L5MSiWajCft2QstA1S7xVeHnrO2ztqOuJ1cmeGCaausU7TZSfeY+tPYvlClN5xDoIA5UxuMpTNR3dco1zNW27oG07vFNKiMlCW1U0da0oTrSz0jQ1ktROpK5rvLNs+uEr3XNf6yBlUZGPZV3x+PSULg9UacLUFlqPGRKNB0LCTj0r0yBNy6usfjVSBsrGqoW1T5nTpsEYh/MGVwvNYsXQT5y8/5SpH2mblu32jsePHpDF0O/3LJqWj376GW9fvyUnixFt9UnWdziNE9ZlMPFgDzL1E30/8vb1Nd/9zi8xpchmuqWqauq6YRiGA8pu7q9fX92y7wf6tGTcTFxvAjdXkU8/vWK3uWPY3WDNSJwG2qYlTSM59EzTBKai7yesdTy6OKPpKvrtHc4nrDNIMvenzBpmckJiwGRHjpn9uGNKA762JCxZZqtsdYmVAv22xqBCEJl+t6Ha3LJ7+4bdm7e8+KOfsH/9Gp8HXAW5UmLhl8kb3W/7za0/ObS0ZoTUsfL44mEObb37AerzqujIz0GdH55NW2tmnodJQUFiyXhCtiRTUS3WvL39jJiyWtUbe2h7ee8O8jX6pBlj770fmSnLcvy8heCrbsul9VQqjlntIaWgrqcIZ2fnnJ6sqJwGCFfVGO+RoIrjKUXwHa+v7rDNGpP2GJdUzcA6ymQQi/IGc4LFYoUxlq6AJg5zNqNBOhdEYUwJg6WyjbbtSkA6elS9C3SZA4HL6iprrYoS7/Z7bm+ERddShcyEzkDhXcvxOSDN7UenyHUS2gK2FGNKwNsC8z9cbFE+U56vQwabD90Aa12RdlJghEVNBHe7Lfu7GxZtc3CFn2KElAkpY2Ii46jaBd56jOuIuSZnyxRGGBxt01A3NSdnmmDUbYcx4KqWulbXhco3LFbnGBzNssM3DZKFB4+f4MRDgsbV1K6idhbnFDGaSWA5oCljTDirSWhOWYWArUVsJhvlL3lr8U41E4NkTOWxTY2tK0JMpL7H5lwQl6qn6Jwm5NbZg8hwTknPs7GH826MUYBbcXYWhBwztq35KsfXOkjlKeJqWNY1jbXkvsdbRTkJFp8tEjI2Bio8lYXWOSprS2vLlg1ETcwapzfPGDPZerZjr7I+zhFzom4bhnFkebJiP+wZ9wOrbk1OgncFtWQchgqLw4jDmpqpGjFW1dlP1qdUtePjjz9hmhIvXryk8i3L8xUywvX1Lbe3G3KfkCg8fviIt9evuXh6RmDk5au3nDxecne349VnW+5eRz796BX97R2xv8XlPbHfsagbcg4k2xNToumWxKSGc5utZbFsGQeD9WoslyeDRM1uzYxMQjTVzAGiDrmdEU5OVxgJpGyhdhBGBbHAMSCgG3OII2HY8+bTz7h5e8Vw85Y6iwrPmkgwEePNz1XtnwVnMUf+FGhL7GfBJ+YRxH3gxBHxN/98RoR9tUilPloKmpCy4QkWnEcMNMsTdtcv2PajBk9bqi3vNfgYvamdMwVerR2BqvJ457A5HTYXa1W1Awocv7Rt57mT5COJeQqTzuZAhV3DRO2dqtiXVt+sZgFCDIntbiQki/HHeVI5I1Tek2IuPBjV5gshgLGHuVRKSeeQzh7mhVMIeF9hvcf7+vg40M87JxaHdaIo9s8jL2NI9MOI9xYxnmAEa4sa8xeu8Qzp11adseryq/Mq5exZFIVnZrT/3NKdv7E6mzKH+aZQWw6q77P4834/gLEsV2tO1muaRYutLOv1CT4Jq6rB157zxiOiivBt05UWole+knVU5ZzPUP62rYu7r6GqPCFMGOMOsz7qjKmTztuD4MSSp4zL4HFU1uGNAUkkl9RM01AcAI7zvZSOAsZJhCiNrkGDtm0tRBF8UyPe4ZqGmAUZIzaK2pHk+ZQVoImZjTCVEG8KoAZEq2wEks4fXUlcsghu+FNg1RFSxOSJ2k5Y9oTcI02NZMcoiaQ7AGH2MbSOMWeSUX0+3UoFlyJNVeF9zXa/ZddPDAbeXm/ZjoFuseL5J5/w5NFD3rx4wbe/822ub24JU+Ty0VNub254+PCM3XZPDhaSilHGKAXplBGUHxFSpPZNsUPLpHHPRy8+4s+/9xd40D5mv9lTN4qIsmI5O7vg+uaGV8+veHB5zvZm4uUne95cbdhe94Sd7qyVc1jfYELG1Zau7bA2MUZDzImm6ohG2zCxD3zw3lM212+ovKHf36Faj0U7zVgkO8iWnIuSPOCMLrKwvUPyQA69DpULX80adCPxGYolSpYGCVuuXv6UzdUVtVG3UG/kAD5IIWuguT8sgENQ0rmcHPp39zXrkM9HFg0euikXDt0swUQCVCrGlJ/oAKqoS8xcLdGAJTI/va4UJIFRaZxkPYLHmIRJkcYKY7Gz+OjlGzZTJqMtDslC9mpDbo1RN2ivmaYTtXivnT1A+11RUMcayBZrU6lKIJQKSlLE5oQVFXodp0xbtcg0UDeW3f4N1j/A24ZKGlz2mnwA2TZEaQhZSDmouK2IXn+j8H6DxYnBFDHV7X7gtIBO5s3VO6et6Skw9APGKdTc+ZrKe7quRSTjnC0iqLqR5axk3aMhZIYkOBGsQhnVOSAbomRsThpo5V6IKohKY3Td5WxwNoNktUUpPLNjC1tdrA+z13mVGVPOs8HYsgMjmJSoFw0xaSIwTYmca6p2wfu/8E3OFy1ny7XO2nyFMRbvDNYIYsHVHl+CkbPaPvWuhmKRqUtMqLwCRnzZ5HPRzlRjz7nSF6gSrtWNfhpGckiYBA5N8CwWbwwiiSgRiolkFoUzuarSCeocnAupOIkmriqFdhyBuKbSTpNTdQqcLxNYUx4rpUotPzWAZKJ+0MP1mdErIgnvVA4rl/syyLtV8c86vtZBKhtPlgio10p2mb0k8DWvNz2bfuLJ5UOc94yTyv73Y2AUp8i+YuhnbcSbzLYf2IyB7FswasUx3F3TdA7rarbbHefn5+z3e4YhAIaffPhT+t3A+foB09TT300YaZhGVUZIEhinQVtTCC9ev+FChMXJms24B2OINrEddljnuLvdsN3t6cNAv+kZdgPjGBmnkU215xvf+AU+++EVNzcKOgjDQJrUMdg4CJM6+A6S8QIiHrIhjpkUMmJh2I6E80RFRxxHrGmAhMz9/uwwxQK7ru4hcEpLZbi7wsik7RkjSGULoVFRXN4mzehSwvsGCT37/Q0p7OhzpPFl+J/U8M9kASeHQYExFL8pA6YorpcRhpJ5S9S81/KbkWaHGHeArmckm1J9qD6bMbq5zcg4rR1EYfvFO8XOEUqjHRbdyLAVMRsSFWqjkTA5UrvEGAZC8ry8umUfwc6bfeE8OaOtJ2sszlSYbNSKXIAYdC5nFOIdorYSY5Li5aVVTtR3osEpB0xWfylczZQzlYEHZ2ucjxgXcaaikpYKjxCUY0WDq5YslyusuaKSTs+R1/aPzswcrVmQx4yzlWbT92ZPer61spyGkf12S1VXuuFVCmxpmpqq6N45N2sUAtwTI7ZCykUgOgk2ZkhZCa1G1AcuR7w4sjlia2aFEguKIoeyeVpsEkypbLX9NScj5rAudJ2Zgqq0h8RlRhjGaWK96uiHicZbxjHhbMuzZ+/Tvv+Yk9rQ4qh9h7U1xnmyzSQXyXZ2bDY4DK7Yqev7A7FWzTtToLKlqrbaPk4paTTFHdaeCCpgKxabDVXdQlXmsqLnwqCaiDlnqnllz4EKOfDGTC632r1Z3RwLcyFLh5QOSYSIaqfji1GK0efI5bWRhBX9jLOgcEqqFIKoNJO12v6XpPcY3B8t/Pzjax2koq1JttIvU4ij2WC9ckxCEBWyFNVs05sjauZirbZsckawDCGx394RrEWqij5NjCFRNR0vXr5luTyl39xycfaQMQwsVmvOz895/ulnLJdLqrrmg298wEc/eY43C+o6Y03FFEaWnGAMxKybtrWe9559wOnZA4ZxoKprjFiG3cjudodJhkW3xGfHy+cvAKFuHZvbawiJj3/8U6Yx4QxIDJAijoRMAyYF7EyqzbroU8rkGMqGqdp3n376KQ/Oz/n0sw9ZrTqG/Y1WM/cLE8nEMDD0EyEkrKvwlUVSQK0h5sw73YsNuWz0Bu+VkzaNe+LUE+OIJRGTYKwSeUEdXbM5OsLCcR71zvyo/F+YwheUKL70MMevr0bklXt/3v9RmRDJvSrtMJ9Sjb0QM65uuX1Z2rXJHzykvvQ9irZXbAFWhBCwNqPwdiEmJVSPY2QcwgHGXXlHFovMRGFRTlLXddy8ecWDizWkwKI9wTu1mDDmCP8WlGhrEZ49veA//eFPUCksQxKD2AoKmcB4x7RXHcrFouPq7RVd7RmLpcc8Dxv6ofDA9BylYmmvII6j0sT8Huwsl1NaXcp7M8fZY1HqTjkTUoIcScaosncx3jTltSgVvHcqwwMJQ8bYdHit+fj8TGyGrxurQsyumqkKuo6naWS325EqrV5MnDhpG066hqUXWhzeNFjTIM6RXSZZRfvlwp+zh2LdHgOGLRqDFkV4grbVC+/uUITcW8cakzMyy2nN/WrJKuRsTHnMvftF4+Lhc0qpUnPOzPRnTNJKvwTvGVEqOSJGJZJySpicS1wxmPL7zB09LOJ05jVJJlUVVdNgKMTwlMo10/uF8hph96eBzGtqraZMjZgaYyvIgjeeZddhTEXnnZbG1hSb51iiv1PFAKM9+T5lNlNgykIwiVEKbNfCrp/w1YL12SXbQUAsU4jEoJp822Fg6BPnJ4/IImz3Oyw1oSirx6R6aCklrm823N7tWK0XWO8x4uiaJbdXt7x5+YZhs8dkQzKBxleslgv6/YZpGPngG8/48Q/+kNwPmEkIKeAtmBxJccRKwBmVyKkoatnF+VYFUr0OzUUYxx6RBYvFkv1+izceK6G0IgRDIseRfpcKsVDVleNkcEX/EJOxJpVFP888ZB6TKAwV9Ruaph6ySi+lQhtILuONKiJoUWS+dFN/B+UHyojPmh//cRYO92/YI2jiq6+vuf0321fM++IcoCiBOhQAhfEtn734Efttj2/P7lVzRzKyc+9O0Kx173y+8jbLvzmYGs7qDMfHFfmh0v/abTecrpd89xe+QeyvWbRP8L7DulqH5LOrsqDttDjy5NEJ3k1EacDXRWasKGAAVKpCbi2cnpxwc3dd2nY6VxjHEaBUzEe4ufeKFhzHEe89i8VCh+qzzuA9grOg0kp6HrTaMdYxTgOVz3hriEYH7smYEqQ4brLo+6u84AuEXM/PrJGYDyfU3cvCZkRlRpGX3lhMoQvo7EyrgmmalHydkyKEUyDvJ6ITctUqUIIIc5BysbS4TAG8lHNekJ4JMF5gVt1ICYqLs2Q5rBl1aTaFKE7hGltFQBbUJyKlnTzzvEqSp0M+JW8bUwBiqpSfQpkvC0DSWXJ5zhmiT5kVSlZTTslK0XHlPemoWkqy4cjWIl5KtS9kf7RXEVFFfCQpqEoyKURiCIz9nwIyr3acy5Aei8PqsHkaWTirGmXTiJNcerSqkCA5quRQVWHqGrEVm7GHpiNNE0MQhpwZJqEfIu3ilO12pLItja/oew08n754xX67J4eMt4nK71mu1mw2V3gcU4hUvkVQ6aB5eL7fDUxTZH2yJgbomhWbtOPm1S1NVWMEbt5eIznx8PwM0sAUIg9O13zvD77HsjvBY5liwlsh50Dod5isn81ZIY+6iZu6hRkSb9RmHElYI2w2dyyXK25urjhZ1JATRnLp4AsSQ5E/UWncWRGAqimtufvpXtnAReakEGeELIGceiQP5XrpzZVFig6qxcg9yPC9IPXOgN0c7dLDNB05L+aL/k7zccRIaDmlz/vVo9Q7AUq0ZaKw8wzM9uKJbAzReN68ueM/fe+H9EPA2YmcbUFVcRiAv6NZdxj422OFcQ/tIYUfFUugCjGqssQ04iSSkujPxpGp3/Od977Jk4tTNi9vuDg7x/sW56qSUatosBFo65qRxPtPTnl4VnG1F0xTE4NRmR8zkETnQc5bck5qQ25UrmjmPM2Q85SSavdRDA+dKk+klBhHNeOsqupQeR3XS9nE502RuYNrGYapBClLdkqyzs6Sy/mzJeEwFHBAFrJTyP0sQ2TuR/zyevfP/YHA/fnM5V7CNAdTIxkz7REmxEeihe2+p3VLrGsVeOESYtRoVLI9VHvarnPYqtYa1RoMTlGwMR0Cwb0s6NiZMDpHwlmM1+ro+Hvlq3i9aWAp96gtIs+H30eReyGQQ8Tk0vIu1JFygkp/MBeax7HysaV9WZ5K36PoLNcYr8lGme8Z50ob9VjxpjHonC0rSVxigvCnYCbliTgxeCJWEjlHPNpuWLQLutpiUtScyxiyhWS0nVAZDWwGy36K3NzekZnIGJKpScCuH3F+QdzvSGK5urnTNpz1TFGoK89ieaIcgShMIfHg4SNurntycrS+YeyVaZ6SMu2dNYQwsdncMg6Bvlcr+O3NBpstcdAstq48Td0BicWiYUnN5uYWCZEoA8tmocTapFbv1ldz9Y+zgCj5s+4WivoqKyvGUDLaRIiRpVuyXK6RPB5QPweB2OIXlY1WStYLOvhNpS1VLsQ7fQlVplf2vmAkYnLAkjRTRu7NJSCLUycfObaE5uP+9/O/c6kK5+Hr5+3LP3/M4Iuf1XKT+f3Pu+S7j/7iQ0xRsS5wWsgEgV0Q/uCPPuRHHz8Hv9B5AceKIRarhM9XUp8PyoK2AWeLEtXkU3uXMAWGYSBPA94kUgiMIWCM4WS1YtnU3L19hZn2NF5FZI11YPNhBGCNJcXEFAcuL9b8+V/7Bf79779AKs+EIWRDstrUzKi23BQnckapE9PENE3qJTUHjBKY5r/ngHVfpX32wbr/e0CZzShsPWW1Xo8FOKHE51neqGy62BKcDLMElBKB51mjag5+eVX+xRayNUVv8F4CkcssReY1J1oB1GTSqL5wvqsV4JIiOQXVXUwJsUErOFOCFAU9KpBCIJYg5Z0nz53IEmjy4T6d322p/EswizFgnVMUqClqH3MlVRK2nLMCxrJBXGa2N7HGHQNLToqmlYQU8MKhMy7gSkXEvUCec1CXKaPXTLG8mjRadE+1Vsi2JFjI4R5VObNAGidymPDG0VQV+b4A8x9zfK2DVM2Ez4naLiAOSl4k01QOk+OBc5GoGTI6q7IW45wKemajjpEhcNOPYLJW0YCvPVXdsN3sWS6WvLh9xfnpOTe3G1arhu1+ZLV0SExcbe6QDJ4K7xaEJIx9T0qGYUjEKSM5YZ2uSmtVcX0YRoZh5OWL18iU8MWSOefI5eVDLi8f8oPvfw9vDZePHvHi+afFPDMw5r2qFkgCK4zjgPfqAdTUnhmJxqSgi3EYcA6mMFA5R0qale/3e5aLFXc3e1wJStZZFcUtmT6zxTc6v0skrC/tmTLAFlHvGGNs8U/SG0zSpBB2UVXnjGCLLJUu4Ii4+oDYs/eCzkEKqWx0anlQBtshFmmhn6OEPm9EZs6ujy2/I7pvnqfdIw0bbSXOauQGizUapLBgRVXPo8kEMUym5j/8/g+JUpMi+MoqFw/w3n9ho543RFfUGGYBWu+sqnncC27jNB1mPNYqfiOEyDSMasPiKqZhR1NZbB749jeeYlMu9AlT+DB6ri1OUWc2kYc7fuGDC3700xdc93tq2xCzw5pKXVclYE0ixBHfrMDYQ0U4juPBXn0OOnPFNLfSZsX0uWV5X7Nv/r+cRRGLAmKU3D70ZSZmXFlnqiBxGEMBanWqPzBl3VirzrWYGQF6DErzetJ/c/y/OWe4d+1TjCVx0iQB57WqyBPeZJzTQJZixJtKk0Ks8qzM8fmYix0EQYV9E5lKZkmpXAqXTAzh0O41lBlTSa4FveaRrL5rRhPRXDQsDaXiK9cjzys7Ac4WtOMRVXeo1KwBOSZNMz4pzWR5UXpEFtFWqy2QftFAlQHjTJkpK2lX5uQjH6khszQZhkNLuGlbRbB+heNrHaScCSrpg2C8B6kgpYMjbJKiP2cd2Ruiq5iMGucZTOlDw9XNHb5bUnnP69dvefrsMfvdyH6zIUfo45bVouPu9gZrHW/evMV54fz8Ec5avL/GCKRJe7vf/NY3+eTjF6QIdaMGYLmgXCxKvDTlopIFW7KoRdvivJqoBYnsxx1jmghRsN7T9xO1XzD0O3KOJSPSnnqSjCRUo805YhRtNYqlrht8ccQNcQCybl6iNuGLbklVN4Qw4awjpqjVl/cYM3N1DEeVaKCopc9oKM2etFXjfUF5SWkroCrhpY4qHLVZR+9ojfBlx+czYmPMYdObs8n/Fsfc5oiim4onYU3Sa1pVfP8Pf8KPPnvFGCzr9RLvPK6u3wlS1lrquj5s0FVVqfiqoRC35dASmTfNWEAIMUamMBEm9WiS8rMUM9O052TRYlKg313x7M++R+MVai8zZwgFK9jsSUFh4yaNrBv4M99+xP/0B59yvevx1QVDVBXvyIQzWcmhRrXkmqalqiqGYSCEcJhHzZ9lbgfOs82ZJ3UfFXifk6WwZ6vzklzg0s6TY2HllkpqBqxgZrIzh3/PFbAYRY0WLOa71+9LqvK5qfb5iksroXnGUpIZUaqFd2Dm5FdE/a6c+iMJpmgx6u8foe72ADrw1lM5hzOFpzQnYaViMqXqEmZcgtaRYjXwy71KUxGwOoI6VIQCsbTRlJOn6vemgGxU/WMGk4te2/lzi57tlPS9W2uK0khCbMa48h4o3CfmClR1FZU35ZQUXlq43nts10FVkeJEDhFvLVXdYMOfAp5UNhAEtjGyz4auUdmQLPdIkEkwriI6oU+wnSJjEqpkaJoWI4b9MLJ+8IDaN4jckiJY4xj6nkW3ZLfdU9ctJycLnj9/wXq9Ztfvef32GkmJ67dXVL4iDAErNzy7/IDrm2vCJExBSpBK2i+HIucfiTFoP1myDjOjYL0hxJEoA/20ZT/2PHv8hNdvr5jGRFM1WO8RowNaNSo1mLompUjdLrTVZitc3dA1HSkHRCzTFHFOb29bWgPTFFh0hrprmdKWbLW9kY3q7+ltomaN2lynLNG5JVJEYEsOaK0rg3NLjOmgFC6HQKc3re76SnTN+csBDV8GoDDoTTiFoAizL/m9/1LH/ZkUBUSRUdsGTASjfj9Tyvzhjz9kSJamXWNKteK8h3stPu/9PaJuqTSsnmNb/p7negKFRBqOGX7QajSlpJt6aR2RhEcPHvDo4oxzLGfLlllxXcr7FKPGfDkb5V5lAylS28i3Lpfc3Zzz8uVnYE7IU6CXnmgHaq+bqc4Z9NrWdX0ARcwV1Kx2Pn++Q3af86Himqsu7/1BWimrRMk77T1rS4A6BCn0/BsNRDN4WuZIVYLTIZEqwIVDE+vw/SGacTAfnJOueX2V15036DJ4hML3qn1D3VVUviInjzNLhaAbATNpsEGQ7A8zczsndxjEqWLDLO1V1RVU7pBsWfRczGWGwr6tSim5I2wc/dia5JZZpinzqyrV+mnn+ZB3BYZu1b0gi7b0jCFS+FjzOaAEW8mH8+FF1I7n0DYv9y9zF8McxlkaNY/Jo6sUSGMRJDXkYoLprKeoe/7c42sdpAYcFs/1kPjoakNX1XisCkuWLydQV8KNTGyIXO17kkDrampfc3N9y77vmW7vqFCbjhcvXrFaLHXA3O9ZLGo2mw1np+c8vDhjnPTkWutwvgKrBE9fNZBVlfvBxQVXb+9QBJwqfFuj5DuVB3Hs94m2q0trzWJSxlUW7IIHD89Yrhbs+h3dasVPf/ATjHimoPOFIY4KoS+96Kau9b04RwgZ33Tc7bb0+5GcRpwXUtIWjSuoH826Evv9nm7d4kJV+t6+kBKPi00OC1IQQsksc7k5y34yZ47F8jzPCAqZb675ZpjbL5Tf03X9swLVO5UURuczYdIgldPPnUv9/3scAsahFSQHSC8iB3Ls1U3PZ6/f0q7OaKoledgTQySaEV/aX8BhHnMIUM4VBXeFsavk0VxBJe7uNgxDj+Fob6EorJnPZQ7VWds1VN7yjctnNN7Q1r60BpX/pvtQURfH44wjh4BNIz5u+O77F/zH//ScaA2haUg5lI2PojyfGcfpMFszRjXY5tef23wHoIGbdQDNO1/3IeE5q8BzNrYoQ5RzW9Bps3XLfC3mKurYojUlOJU22zxLQSjQtrIBH9ff/fcxf753YNvlPThnjqTvsgFXbUNdQ7uoqeoWbxfk3JSWWUYYtMLKmSw68XamwLqkKNuXTTyjZGhb+cNszZTWoM8UAEThPznliBmrQUzbdsq7yzEdAhRoRd74BkSIzCT1Y+VlZeYfUlp3mhDMqisze1CMLQoUqohvxOHmZFMUKXhAWObjmswGstM01s5VnrWKHJWk6EwRyIFhGr/SffgnClK/9Vu/xW//9m+/87Nf/uVf5vvf/z4AwzDw9/7e3+Of//N/zjiO/MZv/Ab/6B/9I7WnKMdHH33Eb/7mb/Kv//W/ZrVa8bf/9t/md37ndw5SK3+SIxqLVA3bkPnpyyucUcFOJc7pHMFnofaWjQxMXrlKnavxVUMWw6s3bxFjGMeB7X6PJNjttoz9nmXXsp/2VE5YLmumsOeb33qP//yff0DOgcV6ibc1ze2OtqnJIRGnyJQnnn3wlM12V4ayCcnl5gDIikJKMbJYLtjvdqVNGYiTIRFphx3WCRcXj7i53ZBQ6ZJQFCWkwHVF1HOn7laslmt8kbN58OCCzz75mLurl4hVcVhhxCSQssjBIVnY7vasLh7im44xRqz3KPn+3ub8zpk/cjmAotF1rAQQOdiAHx84S+4cvxcx5GKb8GWTpS+HossB7WasQoN/9nGs3o7/hne8HQ6vIV/47c992sN7kJItZxGiCNe3t4QoNJ2uB4uipvphTyPdO59lDk5zFTJXo+/AspPOfG5vb5imSNutSkKfocgipayVlJSNYNk1tJVn0bVqI0Mu+q1zW6u0b7xFoiqO55iwArVNnC48Z+uGmylRO4upW1JWLUDnPdbbIzqsVEfzZziAIIqkkPOVbvBWJaCsU6iyr3yBmnOctZRERdtLFhG1Nz8iMQsJtlwvY47X6h2r+Pk6zVD7exdzvnrKL6K8NyWcinl3jmSMLUmXK98rQEMkkVIgBhgHSOKoKp14a1VWCOw5EeJETFL2I4NTXQhM1upGvdq8JqRCUbXnAFmnrIOcyvnMGalc0YgUYgiqwWdKsDAGKND0lEkFJJFE7XOyMQcelBNQxqQ6b6fD+SkwoBLXq6ZWZZyc2I8jLgQVPxBBkiAxKaLaOsiqfyhS8NOVFFrBMRkIadL1O6vAiDAO/xUDYHpaAACB9ElEQVSCFMCv/uqv8ru/+7vHJ7gXXP7u3/27/Mt/+S/5F//iX3B6esrf+Tt/h7/5N/8m/+bf/BtA+RR/42/8DZ48ecK//bf/lufPn/O3/tbfoqoq/uE//Id/0reCmaJWAwKmqtj2fSmvtedrjCMbz+wf02E4qRtiUI7DdRDc8pTL5YK2q/no1Rv6YQCBemlZrDzr03P1L3KOuu2Ibs+DJw3N3cirFx8zxo67bUTsRIobKp8wm08R+wHJbLm525GiUcHXmJlZ2d/9znd4+eoz6kXH2eMLfvrjH4AJVOYCZGS32TDtt7z3+Ff54Yffx9kE1UBTXzDtE1XuVIaGTK7Uu8k1LdfXt1SuwrmGB48uudqpOVm38MStIC5BVlM11XXzCI79ZEnVCbvQ83CxYnd7gzdQWZjFY+fKwlQaHDMOKxVkg/VG3UStxdYGxglMJqOBSHBkycqdyGUDs6psYZRpeGgn3OcVAe9kuTlnGqeWF7PA6X2ZpLklOCOdtG8/s+EpOA9VJtB4WswLTcYWbTzvbMlsFfCCSPGCynhTuCXWMcWEVB3ZeNq2YRBoKgeuJgWhEXDekCXStR0npysVD3UOa+cvVZY/2sFDikGh5sXkcL/fIAJNbUn9RB9GdlnwTcs0jTxcVrx/ueLJ+YIcIrlZkl1LRvBSY1OFzcVA0k1EP2GMYPY1liWekZASZ6cNr1/cUDVn7PcjTdVBSiyqjhwnWm9o64qm9ninGnPOeYxxVE17aM/1w4jLmapR1TxrjfLjUKCItWWG4Rw5gs+eKBGbJ7yDSSJGLIjXr7miSvnAG5rBDxp0Co1BPIhTWS80eRKnKiNS5jgKSlC6ikErBozgjVAXG5YoFu/bMmtKGBnwTMTbN1RtTQgdOTn8ClV5GffEscfmCSsTJiaVlMIc5LbmNSlZ1MHYe8SCrytt3c4gFAxRNBqbArnXmZXBVbWK2O4nmLRtpkaKGbFSCNmZcQzYErznQDsjRKJo4LdWBWZTjkcnOGsPLUKVq9EkMIcBxhEJQd+/MTqySDoaMFJARlIwmFNUGSavQXAqflxztSZQFO//K0HQvfc8efLkCz+/vb3lH//jf8w/+2f/jL/21/4aAP/kn/wTfuVXfoV/9+/+Hb/+67/Ov/pX/4rvfe97/O7v/i6Xl5f8hb/wF/gH/+Af8Pf//t/nt37rt6jrr6aKOx8niw5vtS+fczq4aNoZAorRi+yhSYILEx5P7Vvatub69lpdMMcBMZk49oRxoPGW9aKl8YbaO/yqYz+oZbIl0zWe6mTJi+cjw27ASkNdNVBnnBlJaCvs8sklKbxgtTqlaxd8+OOP2fc7hbFXhm7RYJyQZKKqYT8N1M6QQ2Iat5w+vGC33WrV4AIpb8mpI8eAk4Ai7RQZlUls+w1Xt29pfI39VDg5P2V1dsb19Sv6KZa+f8KXTJbS9vC+YRgTp48eE8ZMP2xp2wUmBeI0YHIs7Zb7cOnCT2Gu6Cze1bhKszrjipXGVKq9GeGjlD7yTKuYUbLumNB+2YzpPq9FkGMrEQ4tzy8eZQ4wjyLekWK5x68qGbpBFQLKtsahdTTPGRBIUVF+WdtUUQzDOLFYdExGCKPOgkwx8oOM9/VhXvN5SLq28BK5SFJJNhrYc4LCa0u51HI5smgcURp2faSfEglVrx42t0xNpro4xTiv43CjfBxk5rgImUC2s4q8Q7JXb6GUeXBxRn7+MSEM1LUS452xDPuRtnU4oyZ+99uW92dMMarCNtZSNeo9NnfdcBZXqxLB4UpbPdNEkJTIKZJQKokWRUY3SjMrSYh29gq4YL7kGtBsaSsXJ0mjbfF7DcLDkpD57/mrrAZHAZgYFTRKRZlfciCHnjztC7HYg1eNQ1AbjzQNmDThJBZS7nyvFFHWoraQc1KdvqizuzyptU4u3lWUIJWNIRW0nK0rbFXhrUOiEEMmDyoo7Izyn8RBcpDJ2DgdgqSSiA1K3C2KS9gC+BCEqF2PgtZT8q/FekfTtRjQyn0aYZoOFe+MBHRz8lhOsLar9flSKkASo9fazPdSua3e0eD8Y44/cZD64Q9/yLNnz2jblr/yV/4Kv/M7v8M3vvEN/sN/+A+EEPjrf/2vH373z/yZP8M3vvENfu/3fo9f//Vf5/d+7/f4c3/uz73T/vuN3/gNfvM3f5M/+IM/4C/+xb/4pa85juOB3Q5wd3cHQGWNas95xzQF6q4rldR8ecASMGLobMLniRbouoqp37K5eo3BsRsS09bQikoqna0WnHZLNrfXJAuPHq3IFg1gdYPxhq46IV1Elq0lTgYklYSvIrsFJjU8On/K5mZHVUHbObqlVi0p7fnkkx8zTj3D0HOyXnB5ec5dC+N2onZCu1jx+PKCH3//BcJIVRmsq7CxAC1yBqeyKlhwPnNyuuDuztPvtohdEdPIN7/xbbqmYdrfsE8TSTK1gWxzkcwBXzsiYMRxsjrjpu/B6oKrvS/VRwlGRlX+ZiKqc57aeQyC93qzj+NUqgCYt4fPKy7clzUyxik043NzgS/juswVUggT5Yl/ZpCaib7yzu98WTD76kfKKgqag7ZZcopcvX3NzfVbkj9hmiaWbYsRh2TtxdV1Tdu2+viUD2RnBRIYYgolSKGbbJnlLJdLYsikMguKU0+WEV+1POweMEZDv3WsFw1TP5HCRFVbrEtY/0ULk/vgBbl3LaaYwdZ4r5bm/TiwaJfqS9QtFU3YoZqJ955DQRLFQt55mrYpu77+3mFe1nYFuu6U0sCRvJytWkPMG9YRZJEOa+Tn8eC+iADlGMHKcX8Wdki0yhk35t5aQatmrEK6rbGQkvJ80IBgJR+ymnl0pgTeSIhTyWvuJVX3OgPFSKNA3AUby/uSQ12oSYpRsrsYoTbq8XXoZDiH8zW2qMcYO8fycu6LGPF81jQI69+pfD+PhwVTDCVzSYYMrvEKvPKNrktxTCkjSSdWTnQ2Zo0p5Oo5+s08P6eBOaoiOs4eE8Qyd8vZlKru5x9/oiD1l//yX+af/tN/yi//8i/z/Plzfvu3f5u/+lf/Kr//+7/PixcvqOuas7Ozdx5zeXnJixcvAHjx4sU7AWr+//n/ftbxO7/zO1+YhQE8WK3oUwSvHjiV0wtpmEtP1e0jq0p1ZUGtphzjPrDsOpq6I4dRM+RsaK3nweqU5aJl2O7U+XQUUoQUhP2mZzeMON9yc7NlczWQJyHHEWtS6XfXhDgx7msQePniU+q6IQTVDXQWUhwxOTDsblm2htPTp1r+xkxTd9RNxdu3b9n3dxgbS+Wg1heOAGaCmXuRNUsOSVtsvnZs+41mvK4jBWG3Hdnc7rUC8wZEiCaT80jMGfyCl8/fcHG25uzkjPz/a+/Poy05y/te/PMOVbWnM/bckrqFJkAIMQgQDRiwkTEC44k4mEscknBxcHCuHTu5y85EkvvLwiv5/ZJfkuvrldwkZuU6NsbGOI4BG1kYsAEJEBIgCc1Dt3qezjn77L1reIf7x/NW7dNC2OABSdZ5WM1R995n76q3qt5n+j7fbzND54bMQPCNlAXSZuFwqakLuc0p8oKmkfMneppWly5KuUHmYcK8YZ1431qnpbphlfkGsnVe6oKNSLdO6pspFcyzvq3zT396Uyn7aTfEkGbLAtPJGNPP0/HK6esUkbawc0HtCVdbCKpzmt4L5LvFDMQIxmYsLy+jMKyPx/jNCUpB1cyYzWaoQhNVHxMMOxd2sHs1Y3kxE+ov7TF2eAFXXVsya+fEglJkeU6eFVjbI5o+G5tnBOjhoJzNKKwlzy39YR+U6lgvmi0zPaSAxTmXSnEabTW9Xg9b5OR53r1utMzSbYWjOyeMBUoJyaoPsum2lEktenRLLvT1V+Xxjkq1rBPzgOeJfra3Q1dKJiY2+Pa+S0C1IKAnpQ1BCVu9SqAdq3WXjbUs66nskFB9qY8jJR7ACIWSEgCESQ7SdAjaLbN5ShGtQdtcZhBp7z2Z9YyJINun723BTUHJ2IFce3FEHbQ9JFJeNS8FaqWFVFoYeRktiSqw0RlBK/KihysLARwq0CYVS2NypK1jb4POzIJP69hRXila2Y4IaBM7BOOfZN+Sk7rxxhu7/7722mu5/vrrOXjwIB/84Afp9/vfykd9S/ZzP/dz/PRP/3T3942NDS655BKaqsZYieb6RYHRWbdD6JBuRFOAhp529MgxytA08OiRE9QhQ2mPr0t09MQATVOBVtR+gYClDoGjp84QlSLv97FZgSXHk1HHTeoguj1WG3SUggGmh1aWWeO54vKrGA4LgodePmBlaZnoI+fOniUGz2Tnbpm+rhW56bFjNSf4hszCZjmWco9zxLLGGkU1m5JRQqyISlP7iEfTHzaozRnTaUme5alRndEresx0hsJQZAN00HhfYnSSjfcelNDfoCyDfp9zG+dQUcorm7MJMbjE6xaFy42QmCsilTXUeSHnkMhRM23xqXGrtesGOrcyDrR8dJAelrhlXuMJo+MEPFGaJgSc++MAE/PPgXnJp41s/yxmtBVmE227/tX+Pbvo55ZJXaJN0TGpt9pLrZOWgec2Am/PT0h/0yxBKmfKpmOtYTgcUjUNs1mJKjIqBz446ukUV1cUESZrG4wuvpherol4TGZRJq1rV99qiVNbcIEmz3v0+kOKquLs+Qlnz60lMmJhuyjsEOcaFhZHzCopp7fDuDK3JfeAtQGTZYwWBhRFj95gwHBhgAueqhKGCoDgBSGo1Bw8EqNOnRuZ92tRYwLuaXXDYlca/WZs68B2a0+UScl6644GDNqirhyPtRqjIASR8inskDyz5IMR+aAQSLgWrr8sz4UpPBaorkIg11rmilUqvyaGcCQzVVGon6y2CfAlR4URTrygFTozqExmnYI1qH4PnRfExglTRRR1g5gGdoWouCWN3ZI9BSD15awW0EPUcvYSAFqU0dJfRHrHVlsWRov0s5zgapRSItyZMsQ2dujWVCGo4KRH0gYB7WwkSoIBHyN2Ov2mruefCYK+vLzMVVddxQMPPMB3f/d3U9c1a2trF2RTJ0+e7HpYe/fu5fOf//wFn3Hy5MnutW9kRVHI0OPjbNAfUQz7wumFwoUgkQZIZBIiThswloxa6JPQ1NGiikX6xZDGBfqjJUJTEUKDqkqmPjCwGS4LNCGisoLZbEZmM/LRgGrWUM482ahPXs8YmDwpT2eAxUeNcpHhQp/zaxucOTWmqRpUXOcR95g4w1kpgIQg2VXd1PjoKbKMuqpZWlhkZXkZmxrrURUEF+jnGToJDPooUVxmMozuoenhG03W67NjeSeZzanLivPnzlOXFb4R3SejDKhEWRN9agx5Fkd9JuN11tfO08sivp5gDThXpZKiZc7bEolBBko1HhVlViTPMvIsI4ZIE3yXOW2FHz++fActIWhbApPfabOvdnOSKX3fPRgtyewTWYdK3PIgtf8mJafWaWlEP+mJPyOmDZLUHJZejyEGaU7HGFheGDLsFWysV9iswPtGmuNqXtpsWcylLDpH8rWbtdUyVxZ82pBDoK5rnBNevCzL8Mrhs4wiWHyZ5q6qinMnjhGuXMXQR+uIyVrEXaKoQhG8bFjBh8SkYTA6UvQG2KLi7PkT1C7SuEQCC6gkUa+Vom4ahqMFlFIdB1+MkSzLGY0WGC0usrS0jHOezdmUc2tnBV0WBDFXFAW9os9WeXdBAhpcJcfkg7Bu+OARdnOVHFXLoP711+jxAc28xDaf83k8Z+L82iPoyqDAyO80riHPe0AQ6qKmJCNSWMMgG5DnOXl/gC2KBDpS6DynsCY5gIBB4NckpGBMJbw2qyEdk2scigarNFlyUtFHGQ/RmqiN8BZqLVRHgM4ytLHSE0paZRG63k8IAW3TGAMxQd5V4uML6BDJtOANY5SBZNL9oLRw7sV034Qo5b+elYwqhjk/o26zzxC6snJIsyROiXSHihHlEv/fluOU2a+Itd+GOanNzU0efPBBfvRHf5TrrruOLMu4+eabectb3gLAvffey+HDhzl06BAAhw4d4l/+y3/JqVOn2L17NwA33XQTi4uLXH311d/y9x89dppoDVXw+CDaM8JTJRFADJGaDPIcVU8xfsaw12NhZS/nxiXlWkXTePqZwdczgkps08ZgRouMp1OsNSgfUHlG5R3Ts6eZzBp0NmRaTTg/Oc/pWU2he8TGYHUhLN86sLRkeezwKU4ePY2Kmn4+gKAIjcNVQmGvk7SAEG1aacI2nk1XsndlSKZUkmPOcI3HmprgkpNyAR2NkIg6cVgmWnKdo7xUv8+cfYxyusGwn9OQo9E0VWIf1tLIbXxNngdUrNkcn8cqj9XgoiMGidx14qFTgMx5pUcvQoxOWD6iQiEib8IG8cRZ0eP5+UIa5NRmLinR2ly9NInt+dBtQm2frP3sGNopj3mZb+v3zMs4W5yk1oLge0KLXa9AAkGNiOvpednEN/SLjB2rS5zcOAFK4PfE2CnWCgGrfOLjB1tNYgTQFmFwcDJ06ULEuZAcgSACgzdo0yPPInUdsRqoSkYFDDLIrThAZSxoQbXOz789/RZIIptfludEk7NZeaKyKGOxttXTCjR1ycbGOufWNnGuYTKZ4JwTeZosh1TO3dwcc+r0aeq6QVuDyQxZIb24LJNh3zwvkjKrrEPTNFL69kJ26hNZrWsayUYVAirpqkL6goyova5b+1bz/uM3uKRwgfNCyXiGr0uKXo7HUZZTjB2hVUTHQKZlozTKJE6+SEyEzUpbDALuiClrCtGlztO8adU+McbmAhhRGhebJOiYCGwDBNfuBQJVj4nSSBmNtel72iwmkCoKMr8ksiOKOuk2BSMeQZPojEIUZ5V6X7El942xg6+jRGK+rVpKVh+6gLrjl0zVgMa7RBuWgpfMovp9rAHtAn5WEmoHPlzgTKOCaVl+44u0xb4lJ/X3//7f581vfjMHDx7k2LFjvPe978UYw9ve9jaWlpZ45zvfyU//9E+zurrK4uIif/fv/l0OHTrEy1/+cgBe//rXc/XVV/OjP/qj/Kt/9a84ceIE//gf/2Pe8573PGGm9CfZ+c2KJjXvAuDS4mqtybR47zJGgokUePIQmU3H6GKZfn9IvVlSV1OG+ZCs6DF1lYisKUMdDT5aooemKRn1csl6vCPMpvRMQTPbYO+eHRT5gEcfPk5hhxS6IDSbFNbRVxtsnD9FDAajM7yLQhMUVJIKiTLciwzLZSbH+ZJCW8pxyfjcOvt2LXHv1+5i2FvBVR5VTDGxoqkrBoMlxpOGiEE5T9HT7FxZppfnlJtjQnTkeUSpOkWpFaRSnc2SHAGCLstyqKt16mqMUjVN7dA6DRR2NfewZZgw0M2kxJCYzDWENnoWiHXk67OhrU7LOUeWGLNR4YIsCrhgDifGxLAQ6dBxW53S462rQHQO8s8OnBBl3pg4BKQ8ZTXs3rnKIyfP0wSfItAAQY6/aRqMkbKfVvLItcwN/X4fbcBkIjXunbBaNM5Ta4/RGU3KpoTJvsBmGmtmxGrGIA9cvHeZhaEmM5HM5ljdQ6vs6w9dpcFQ7+U5URprc9A5k2nDZFbhmpBKogHvaqZNzeZkk1k5o64rxuOxaCx5T103OB84e/Y8USkGgyG9okcTfKILk3PM80KuqZf5sVY7SrIZCSxCmquLBJxvBPocvECs2yyCNqN64mt4Ae/i4+6zb/T+VtgPhOLIlSXTpma4MMQoMEQIjqaeMXPQ1A5bObS2RNL6pRGHFsXnm5IQ6nS7GSKaoAxZXjAcZYKG9IGyqgn1GEOUGSQf8c5DQDIgpZJckJQvdcou27JhRKGV9KagDXgyGhWll5VbVGbEYXmPb2q0cwQ0WVCJk68Fp5Cysjb7hq1oWBWdULEl5F6LvHDeixNV6Zr2CoxV9FQPm7gPXVUJ6zmp4qilrNrM/gKc1GOPPcbb3vY2zp49y65du3jVq17FLbfcwq5duwD4t//236K15i1vecsFw7ytGWP4nd/5HX78x3+cQ4cOMRwOecc73sG/+Bf/4ls5jM5mjcKbDKzBR3BpwQ0GkfYGpa00+IJPMzqBydp5FlZ2MdnYYGgC1dppMqshGxK9xblIOfMU2YDJ5jqDImdy9jyDXLM86qENjE8fx8w2OXj5AU6cGbN3735CaVnMeugalnpTZhuP4Gdr2Gwn0dc410iWowAcOsqNrKIXwlvvxMH1hjgU504d48qrhlx1xW7Wz5aM6xmF2URRE13Dvt37ccfPE5THNxsyWGwdhIpqNgEdGK4sEWNJ8KLM6rxL+3SkcQ2Na8gKizGB6WQD7yZYIiHUaJVYJVpF1hhRQYujjYlRTXlUVEkkTXpPvnHQOq3H9RNah9NuHj4JokWEZaEFGMB8E+l6OluufV0L+3fwXsqQT2jzRvoft1l9a5akOqKULKJvqGdTlheH7NyxwqlzE2ZVQ2aFmqYt9dW11POLoi/gnuQwrLUYqzBZOk8LAYWqG5QO8vdZSZZlNE2G0QPqqiG4gKVmz44+lx3cwdJIk2cyj2fsAFTGFt4gtjpzYQ0QeiFjLFkxYDyrWB9PKWsF2oBriCpIz8wqRosjyqnpWCY2NzfJix6j0SILCzL02QJKRqMhUcXUj7PdNRfEp+3Kfe219R2rfeg2u5jGJXwI3XWLyndO6vFlvAv6l1v+vvWab4U8d/ejtvgUBKxvrHP05AlWdu4U0tQosPhmOqWabOALK/0Yk6GVTgCXpGOHZDghgvcl0VddFhWVIWhDL0CvN8RYcIlgOlYT6f/6QPQRXAoSlGQ/oZv5CukbWnaIxAiRytUa4cw0NsPbHF0U6Ex6uC3NUfCeUDcyfxwkOG3aGcg0UxhjoqVKAV3bwzUIKCoG39ElKqMEXZxKikL4K8GrMNFEgm8ITQ1be8hKWrChRej+CfYtOakPfOADf+zrvV6PX/iFX+AXfuEXvuF7Dh48yEc/+tFv5Wu/oZ3frMiGGcF7mpZbJyqMVmRGmnXe14LuyyL4CuMbzh4/IiSgvqQux+xbXeD4sePEhQKlCqbjTY5MHiPPLE25ybDQqGbK3gN7OfHQw9gImTIcWF3m3ju+hCpWmJYZqilYnx5nSW/w6tddw7C3kwceuYUzExkQzrREUaF2xFgRqZPEeCAGkxxshW8i/XwBV4+pZjPe9c638uu/+jHumzzIS196JQcu2sOvfeBDvPHGV3Ps5AYf+vDHMLbPqRMT6rIksxGiR1vFpF7HhRmjfBF8krYIUhbwqWejraFxM5yboFQtTjQIjYlkL7ZDyMWUOYnziV2T23uEBSM6NA1aZ93D1jqprRvLfOPyshFqicq2lsNaBFj7+zExWytUxzgRPd/Q+ai22vK4f/uzmFIQQ3K6SmZIZM0tuc26DCLLM7QSqqC2p9Qi2LYiz7Z+blfK2tKMjjF0RK7Bg6IQtgdjGBY5e/cusXv3AkUh93yR90Anqh611bFvKbW2ZVslDkvbjJAQhbnS+CCITm3mc1C5sRAio4UFer0eTdNQlWXiasxYWV1FKyPACKPJe3lCNsq5CwVS2w9UHZBk60/nHVoLqa4KLfO9TzN1WjJAPb+PtqI/5T5SW9LnC0u7rZtu78Pud3FYq5hNZ5w5e4rZdMq+Xk84FWMgujS/1TREa1IFNbFUBKSPrSEqI04l0klnbL2YGtWpBMQEBxQwQRTQVkJ9KqF6ISQgjZw8kJyEqDRoVAt6SKAYlCa49N1KkIA6lSdlZER3WaMKIQWaAa1CB4hqmVS8rzu+QZUANwSHCl54OFO5TkfT7Qk6JnYOo1DWoHRM61bj6grVpEwqlfu8QlTFvwl7WnP3TWvFal+hmxmDXs6UQMh7MjGtQPuGXEdsCNjyLLl2XH7VVVROc+rkKS5dzLnr0Qf4rjf+NW7+bMWJtTF5XmHDOuWmQ5khqq7ZmJzhyst2c93l+/nte+5itLgTjeeFV17E2dOPkOmKoTWo6FneXbBjuMDzLt/N/ffchfEzlCuxSmOxxCYjVDU2qWQaFXFuSmYyNAXoGdVsjcWhw5iGXn+BU6ce5f6HvojKFDt2DXjZy57PR3/7N3nwvjuw+QKDbEJZbqCUpWc11iiCb4gBct3DhSl4S12VwjCNQFm1ybA2YrWlms2Izs17TkYRHHTOSDmISnoVgmEEVJLFluZ2QKFiwIWAwRPwMqzsHEF5eUjTBt0ylWyFluPZokKrLnBUXd8hPRTtMK/i8T0uOq+kWuCEkk1OPJZBxjbFhOE7tmCktNHIUzj/WNk40FH6b0ifAt+gkmSDjuDrGqM0hTUYbbFZjlI2gQaKpA5tEtddTlHkGGvQen78Xd+oc/6uY5/w0VMjIouDwSIDO2VhVNAbGOk92B5G98TpK5/OTqUNFFSQvoIoK0dQBhcCAY2xhn7PkpmCadlQBo3t9ZnNKqIpaGaO2aykqmu0MYxGC6CERWR9PKZ0DRdfdAmXXnQxZVVSe0HeZlmOUoLm9JITdEGNcx6jJAvwrkm9QScoMlJ2hczTSHkrJEJVhU7EqiGIAoCV1DY53lZ3StaAKOVnhZ1z1AVHiDDzDXnQlGvHaDZOsW95mZ0ji1WBqDPqxAyCEjopwabJxk9CscUgcjmtk5QMKAFXukxI1tgYjTagnPA1OmcTyatce6Pn/aYY236QMMrEFnYeSaV0lfgFFRGNa4EqURTITfRShidKRqUtzhgaL7p6USlxjcmDt9XzVshTRSnGalQCYcQ5d6XWxMRZ2gIstNKAkT0hpHPPMigKnGpSYJQAMwq23vZ/nD2tndTAaorpeZico/YV+dISJ2tPPhrRMwrblDSVg3LGzl7JrJly99emYBdgOmXPkmGxPo1u1ikGhnzjHJPxOjmOpvGsZAdxdcWgp1lUm2SxIlQNG+szzp09StUcw4/P4M6dZWD3kJFx7vgRXvSd1+KbdX73d2+imVquOngprp5w7MgRRoMVlpZW2LG0yvHHjjEcGGrXcPElF/HAfYc5cOnlzGYTHnzwAYwJ7N59MdNyg4OX7eDIkUc5eNlFGK3Zt3cX5XSN4w/ch/brvPrQy3n+C17EF279Al+98y7yPOONb7yRZ11+gK989S4++Ye3kmUyjBrQZCYneMeov0jPZGxubqITM3TUGqMVyiqca5KT2gqWaKPQxAaQHpq2URxVxNPgoqNf9Kh9I+gpIlHLQyeEqm25Rmrxj6dCauHqWZZ1w9wxIcsEmdhuVF0RfU6ATTtz5FEIK7t8nyUkWQNxBKJJFVv2DER8z0RpIMt5yvtU4jwUQljpR2VGkFL1rCLUHqs0PqZhR6yUwBCkn1ZzccA8z5JsAmiTekA+oJXtei9S7pI+AICPjolfJ8sWMPRoyk20Bh8amligswUUObkRpWgREbTEdjQjeAg1mRXVaJ2if7QWdKmvMJnBZopoNc5kTJqKvLfArBxT5H0hVrU5ziUWdK3pmYzJdMqx48dR2lD0ekyrGdpoBgNFURRYk3URhPDT1XgX8PiEImzk/kpikt4LeMIrQe0KElA23KCiOFqdGv7BC4I/KKKP6KAJLmKziNbiqFTIqMtaZo6swqsKj6ckZ21jTL86w8EVze5dOTpuEvQAsiFlrdAKCqsxJt23Sgvdmsklq0j3ndFgrSKYHKd76Z4kbczi2Hx06TlrMBa0GuJcjteOdp7NKAEhxSABUDt7pOw8E8qUSQPZNqlcC29eJOIMKC1BYowtAVQqPdqMJpK4ROeSGluFtrO2yJcoKqQnbQkpOO1EHZXGxASxT0KO5BnCCaqJykKe5IJGqYKiVMcIFDfH39Q+/7R2Uv7IJ3nOi17Ai171Ar52732cXNtgf6+gN/AcfewxXvOKV/KZz97KtS96ATtXepw8d5yza1M2N0uc2+TF134Hz3/O5QzyjF4ouWhxyGu+/7uxmea3/+dNPHrPY7zpu27g6iv2Ma1OMHOBLOuxcX7C9dddz5698NWvfoG3/tA7iNWQTEU+9Jv/nZe99CVkVvHa134X6yHysld8B3U541d+9b/STEt+4sfegYkDHnrwHlZ35OzctYRSBUcfO8vqyiraKP7Lf/lPDId93vJDbyYvLFc/53Le/99+iauuvJJ+PuAV3/md7Nq1m0ceOYz+0pd5x4+9k7JqeN4LX8Av/z+/wuLiEt994+uZTk9z2ZU3MqlKbv7E5ygryHsLLCwssnb+PItLy1TTCd6LFIEEo6FD9sxr/m0rSzbTrX2BtoQzt7ksuLE5vb6iKptEXZUn5mZSJFnTsoC3/GIteKIrkaWNfWvGVNd1943faDizhSNvfX1r8PbE/622/O3rzwskCywnY0ZZj1lZUvQWWFs/R1nJILM1eSqXiLUS6+05ZVnWzU9J9BloGodznqJI6DcnfazJZIZrpMzZuBqVBmLHZzbI3RStlyVD06K+Kn1A15Vk236fnI1kntILsjQRlM05de4Ep8+tg9KUZUWTZGw2JxOKPKOazXB1ydLiqOsZ9no9QowU/T5Fb8BwNKKqa06fOcOePXvYtXs3ZVlK7zA5ae8jeZ5jraYqa+q6SpB3j9UeqwQ8Y42hyHKMigQnzCXKCPKNFlGqEicgEhD46FHBEdQcDm1sILcBgseVgcIO8OWMmStxYQK6xtuCvbt3cuVll7MjD/ig2NQZPqR+aQiMej1GvSV62mCyArQlKEPUmdBARdmptYpYI8cWLrhv6J4V31RELwzzo0EfF3O6Mdw4L8eaNAAbvG+Ta5QRyXkToEjlV0XKZBQdtVEVAWvIbCaZZRDvo43F5Ioik6Fzo+Y9p5bmSG5zefgjiacPgIYQE7ovZbatGGhMc2DGSAmyaqQ6oRBuwn6WtW3w7olSQP+bpMF7Wjupi4qzvOm117IxLnnT97yaL33xNs6fWePAxbv4xAP38NwdOzmzZ4VrLtuLHvRZ3LXM3vNrbJw6iaoW2L17D2fPn2PH0gp68xyvetErqU6fZKJrbjj0In5/7bNcd+1lHDtyH6u7BtTTwHRSM+qvMlAZF+1Y5vTqDpaGQx46cob9e3Zz6SUH+Modd/H851/NbFrx0pe/kDu+cAs7lnfzmkMv5VOf/j2Gw4y773iY6WyDldWcjfWaRx85zYte9FJu/fwtXHnlFVx22cVkmeHIkYf5o8/8IW/7kbeye+dOvvzlO7j8iudw06c/xfd+75sZrqxw7ctewvnpmN/80G/xnd/5XTz3hdewvrbBg4cf5Lc+9H7+1jvfxd79O8gKRd1IVlDOSnp5Dx0Ns0mZNkvf9QGE+Tkk/aLQqSdATKStF8outNZN70cBQmyOZ0lxNiNqeciimou1ZbnBWCXQ6TDvL7QDo1v7FlsBFeUW+OoFTipuGSDc0pDaOkPzZ7HgPTbv4ZXFx0gTDMr0WB/P8FE4CVso/VZrB5lbB9WxQcjORCvRoVsWAC0be/Btg18cWpFnuElJOZuQGdfJnOuEglQqcfS1iK202bTjba0abggRrKGsA5/4w89yen1Mrz8gakuWC3JtYWglO3EVytdo+sxmU6qqEgYV57CF9MgWFhZYtpb1jbFIzFc1KyureOeT9lSerqmnLEs2J2PKWQnaJjJSg0b6M4N+gTWR3Bq08hg07a0WEpZexYSSRZBv0cfE+i2u2UePm82IoZSxBRdRTlNoy2iYs3ulYM+enSzt3Ek/L+gxw4SGKuQoVaB1jg4KQ2RgNQu2IGY5tuihTC7lvLak5z0xDeaiIhZ1YQTU3gM+oBLQQGktDAwxoqzpeq8tryNay6hDCs6UTr2eSGLqNSnrlGOUayujEibNohGFhksAK8lppHJ4C/y4oFQutXOR9Uj3K1oTgk/XJiljd2hAgZ63Tst7J5l5iB07jU7n6rb0mts/s78ICPpTza6/7lpKpfml//ERXv2K19LLhmh/lmZjjGmC1LonY4ow4XNfups7vnYPb3zNIfT0LAf3H+CLt93GvQ8e5m1v/T5GfsaJe+/i7MYZVvaOuPSyK7nsoiV8eY6Pf+w3ufa657Pv0heS9RYoNyoyFXHlFDebUG1u8Lsf/Z+84XveyN49u/nafV/k0mcd5N577+P5L3oet3zyCxTZMn/jXW/ggf37mE08H/6NT3Dvfbfwvn/1bm7/4p3cf+9Rrr32eXzmM7/Pjp1DdqyO+PhNH6coXs2zr7ySfq9HU9ecOnmKPfsv4fCxw/QX+kyrGfsu2sPho4/y6c9+kseOHSHPCmbTGUXxct70fd/N0nKfWTlmVm7QhJzgLGGywc7V3aKnNZkxGFhAGpltqYnOQXjQslHIDTt3Tltv8q1zUCKJ7amaGU1Tk2cWiDSNo6krfFNhjMaHhryF6aaHo6qq7jNaIEXbp5IvEFkYVGKVTj2cLt3bivTagvL680D3KaVpak9mCpSBvNfjzNGjnDq3iSMTuQUf0FHjfcCmGacWyff4NcKlWv/WUpjSWJOR54osq3A+JM7AjMpNmYynGDS5tWRGykNCgdU25hPje3JYXaMuOUHnGyoX0JnhwUePcP8jj6GyAZVXBOdQKuJ8ZGm0gIqKYWFZPzPFqCXqup4TzBqzJTMzjBYWGI4WaJqGsixZ1Yasl3fO0hjDbDbjzJkzlGVJrzdguLBE3h9gYoOvNwiVo7ADMhPIU29Pei9JMVrQDwDoLguQoEcFQQiGKMrW3jucqxlYzcryEvuWd7HcH7I8sgzyhtxW5HFCmK4L5N32qHxgRqAoMmwE7Rz4ksZV1DFgjcbqVthRYPWxcQTXgJPN3LbI1y33TXtfyH2Yki8iDTIDpVMfPbROxFohaG7XN8uwGKJzhKphFiKxdgl4peaaUlr6TB1sIwFQBB2b0IGSJiXmh9C2w+h8a3Isea/AWEtTlSg3Q/kmIS9JwV9iNGn/pEzJqC2k0qQsLwFnhBVeruFfyJzUU82Wdl7GI+cdm/lOzjNiUTvorzLzGtUbMcUQNOjQsL4xRtkCawwDq+hbxWQyQ1lhchgaRe4c3/mKQwxWDZOyYXGQMV4/w9r5s9RNzayqQOVo4xkMclwzZdC3bGycIcQSYxVr400GCwNmVcXi0jJFVrBxZsbCaIV+b5EYLT4UnDvvyItVbD4khJzgM5qmFFkGXzObTnjOs5/Ni1/4YqEfKhuKfEBwUbSrQk2eKXw9pbDLnD59mlwHzp85TgiB13/36zn08usoy9OMpxsMR/0WBEQIgTw3GG3YWF+TIb6QtIZa8sx0M7fzRSrpw7RCbK093knNHUn7SMgMyWxW4lxNrydIr6qusEltVNSC532o9nMfjwrsMikizjVf991zPrn0b0+UNakLfvzJtvU7gF6eM5vUkgY6KB3c/8hRzq7P0P1cINMxojPJCLMtcvFbz61Fo4UgciuSuab5L42o4BpFluWUVQPRobSimk2oq4ZFu4g1mn6vwBoZYNdKQ5ehtQwH7TnMZ9tiEM61xkXuffARGoRA1AdH8AGrDb7x1CZncTRiZWmJo4cP0+sVjGezlO1KQatpHJEZzjmquuaiiy5mZWUFtMZmGZPJFOc86+vr3SAwRHbu3MFoNMLmfYFoNxFfR7yrMSaIJIi1WJOJ4wU8VjbV1APqYpJWVDM5/iYEQlT0rcY7Rd8aVheXGfYK+pkm8zVqtklgTOmFNDqajLWNkqa/k3xhKA4doGmoywkxlsRFTTQ5WgeMlp4YTSA2XiiKGgH91Elb6sL7bj5wHlqvTSoLKiWMDgl0gYKYFAMjYLOMbADBapqmpplOibUjlDV56u/oLvtODqIt03VBURp+j20/V0AWoQUNKToOQpTCZBaTWQIwrUrCdIz2dQdTh3YWTWi82/taR7Ad8zod+2IEgpqzTgD4vwgI+lPN7r7rOFe/+mpOn9kg6w3w0wm1Bz0saFTE9A1eOYzJqJuAtj0wPWYNRJUxqz2V89SuoXE1z33hc3nwwQdoHp1x8LIrqKqGvBjg0Swu78BmQ+pG5MOjjmAjVZgRTWBSbeJpRKMlRqLWlLWUOpQO7N67g1k9RReatckG5Brdt0xdyaSpiMagdEaW9QjRMFpa4aJLLuXhR4/ysY99lJ/4if+N5eVd5EUuUPKmoZ5s4qsZm+fPsDoaMLSaH3nLD1JksrmcOPIov/TL/zd/93/7aWxWkOd9ZrMGRRC0GR7XlAx7fepqmjbKOE/nt5TYLuhBRUFrbXUcW9nN20l+BTTeJSHGWjKj4MlSuauVCWqahizLu+/bOv+yFQVYlqUQyyqBoMeUXflEv5RQDUL/koARoLpSmPRt5jRNW3taUh0xEHUajpTzd86lUqjU9qt6RpblZNpS1Y7zm1Puuu9hnMoJLhKcJ+JRyoCecxa2a7P1JyTYuQZIzXWfnJwSAcAsyzG6IoRKFFJDYFDk1OMJSzuXGSTOzCLPZIYnZTjCegCtZESaliF6AVTYrM+p8YzT59cxWY9+ZihnUzBRyEFVpJxO2bm80vFyDgYDTp49i9aapmnIez1CDEynU7TWDIfDTm5nfWPM5uaE9fU1tNYdtdloNEoDvpJh+hhoXI2ODdE3ZAbyzGAV9Ht50kaTbMyrxKqXGLcVMmbSAnliEgx0KtLTkUgNFBgfmJUV58uA6hfkPegVHnyFaiaEUNHoIdEs46PBN45+ARmBxjfzwfaqJvgJyimKfIDREJwXRgXXzjo5fHD4TrE6lZjVvM8jQCO5F62TYEocFDI/FIMIMhITCW2GUVZwLz7ifZQ5OWOF7ipEGXgOXsJCbaR3nOb52jbrBc9yFMeVWCY7UcSg0rF1wVmUkmHjUG5+L8uHJiARc6orDQTXdFmdSiKPPsH2Q3quArGj1/qT7GntpNy4Zu+o4C2vfQnP3Tvg2AOnCCqwd88urnvhc1keKbSBMuQsLOygKZaodI8yW+Loes2zr76G0cmTDBYXcFkPs7DIsbNnefYLr8TbAQ8dOc2rvmM/L3/l63j2s1/IvUc2GE9KFnpDnMloVIPThipEGiVqprMGTL6AMiMeeOgoQUV+8C2vZ+9FV3Ds9EM8duoxKAJ6wYujGBaYkaFRNT5YNsYN0Me5GWWlGA5Xed3r3sTCwi6MHaJUxo4de/krP/Qj7Frdx4kjp7j37vt5yw/+EP/7P/g5Rv0BDz34IPWk5OBVV/DGG9/Czp2XMBptUFWePO/jatkIZtMNerlG63mZ7xtaeumbKZm1DkBphY4hOSMpyXjvyYzUy10jxLYxqK/7fbiQCb3TL1IaH0OHBqR1Tt/oOL7plOmJ3/j4T9ZJrrxqPHWAh488xrhyuHyANlliDxDFW5VmjC7oQW3ZKNqfLUxeSoIZKEPdeOpauBFNy6SuNELHH+hlOc86eAmj4QCtZ10/Kq10F73GVHpKuZX0y5zHo/Bozm9MiAmZ1Yt9lJcykrK5MKEXPU6dOUPtPEW/h/ftwLWUkmrnyLKC3bt3s7i0xMmTJzl9+gxl4+j3B4l1osdg0O/mpSCmzFITXUNGoKomuGqCCSK9U+QFuc3Q2qKVsIZrIRRMml8pa09BlUolpBjlGqkkfRIxaBPRXuGdYrNsoJoRhp5RLjIYdd0woaLpgzIZ1mhUrAmuoqlLXOPwQjeNseDJCeTCyO8Crm4IdY0KDhWFM8/r2AVqSrXzhXPeO+cD0XsKOZNOyVhurwiJ6UUh/He4AJlJziWmjEzu2xa31GZP3jfdM9Ei8WIMuET/ZdK96GOkaZVymUNsYozYmCWnI7RsPmV9nXow6Ssi0Lq6KCMoGpnLkoqgZIraJpn69CvyOd/ck/m0dlKPPvQwZx64g+954aU0fpMzbpNHTp/jNa/9Hpb37qUsN3Cq4NwsI5IJ20TosW53cPedD/LXf/g69l2yj3Mb55llA+4/eYLXfO+bOb1xmrHLWJtlfPErj/Gdr3sjR0+domxgtLTC5qTixEZDHCnGPuPM1LH74itZ26wZzxSPPbbBpZdqjh0r+exn7+S7X/9dlC7ykY/czpmNyKnphDAweDXgwSPrnJ8FNpvA8ZOblFXBsRNjjh8/y2TzMD/yI29ltLCHz91yB7MK7vvq3Tz3edfykpe9jocfeojxJnzik1/kqqtezDXXPJ+jjzzKR/7nH7Br5072XXwVu3dfzs0338JoYQeEgrryDPsjssxwfu0sWRbxzZQsM0DLe5bQO2iCkmHKtmfS/W8rYi5u+b0LUH9J4jpKOUspmZlSRYHWGXVdpkwodn5m62e0GcfWz9dGQ+MTA3cQgtJvcLe3To0tGeGfDTcRBS6uRLHX5j2OnzmLSw1ulRmsMmReYY00xFveva1zX1vPs8v41Byh54IMNjvnmEwmaJ2xsLBIr2+JrHH47AkypRkOBmgVKTJLls0d4dxBka7pHEqfvhylDY13jKelZMFG+h7ONzTOYbRh0B8yLUvGmzOCEhXnuq6ZTqcoJT2o0eIiWd5jbW2Nw4ePoI1hYWGR0XCBpaVllEJ6ST5gLegktVI3FSZoceqxppluEOsZ6Aark6qAFnb4oLTMrimNStmUDzEpwuoLAhGlwKiI0TqxNUgDRQfhEwxNLbB65zGZRib6FLXKhb1GgaXBRkN0Jd47QDZYnfgpY2xngyIeaGLERS+zP0rECh1S1lLMA6X2FoyhvR8jLjgZV4hagBB668B3e34CzsCJ2KBGYPAxRoHnp/u6dVI6Edt2z4GKSbU3cV5quf+CbqsGqussgYBwiiyjMIl5PSvQ/SHe5UkPLaSsMJUWQwJZBbn7YkJdBrUlGEvjCl1JEoj6GdCTMsNFjh25l1v+8Fd4/Zt+iMiAL919nPFv/CHT8hyGdY6fWePR859neaUPvYJP3fIVmmhxU83vfPz3WcobauXZeeAyvnb0GI+sn+aBRx/G6GXOzQyf/Oyd3PrFLzEp12h0Qe13EHXBrXfcz+DBdabT05w4fRs7Rs/iV379EygaqtkGjzz4PzF2H7/5oVu5867jTH3DyfFpsoVlfv3Dn2PSDPAx42M3PUAzGxOnjn//H97PubMzfuNDv8d0OqWqSu574DHKsmQ8HjMajZhOJ/zCf/plHnvsKMRAkRec39T84n/+IFb9BplWnDl5msXFNR549P9k0szY2JwwGC6hTR/nNimKXlJ8rdDa49wEY/vouFXXqc0ipFbQRYKPQ8g9UfY1dzRCmxRDRBkwUSeaG+E8c40IqkWv5oVqLtzAHz83ZUIg1DVNXQvzgvrGMNbHs1+3/bU/kwUvFEBI76AJAYwFq8HIohkF1syRWS0ApD2mrX22tjTaOhXvA3XjqKuapnFsbk4JAfKioChg//69bJ6dkVUZ/V7BcKAY9n0SFWwZK1LpJvWllPwfxPlsmdKGtfGYunE4B/hAoTOJ6LMcYzIisGfPRUzriqw/ZFrWTKczALLMEkJgVpYcP3GKqqpYWFxkcXGJPC9YWFhgOBxJ760pu2zSGIgxUQ4Fj9WRuhxTTzfQ1GmjZ85MIduucNjJyclGCwmxqBJilI6ZW6sWuCByFxEDOqNqIsFAzwyg76Ff42pQmcFkCzQmw3uHakqiCdBMpWTXG2CMIreS7eosI1gZ8PUGYm7B9EDH+TXo9Lvan7G7vjGEbmwA7+RYVRsWCpCi/W+tNcpIsRYfscqg8kKCBkgsLHRcfyhE+ZcLS/Vay7MXWjZ+JfNnPjFatFCoNgAt8lw+J0JuM+xoERnCjh2iNHnGhExNYp4Eoklld1Igka6R0QZrTEIfKqKdfFOP3NPaSekde3jxd7yEwVJg1yWXc+fJM/jly/jiIyVaWxb7A3zWZ+1sycquHfT6I9ZOnMQuLrO6bwVvzpP3NTt372Sw72IWd+/hyNGH2H3wch47PGawsovZWsO50+voHIIJzNyMXn8XjQusTTfRehHT282p85G1scU3JZkZUJcK3wwp8iu44/aT9FcHNNkeLr/0BZzfKDGZOIqNDU+mlmmqY6yfPI1WBafPTIU+iT6Hj57tKlrluQn9wYDxVFMzYmO8jo4VMQyZVDmFtRw7c4bVlX2sz6aUYYrSgbKE8fg8o9EivXxAZjI2N9dlEDQ2xOiQdF1ubpVCs8dnSwLfSY1SNS8itWUWpbY4KC0ZhzSQo5TJ0tAqQJblNLVLGVP7Lal4TuuU0gxWRDRqYpIWSL2iObgiHWN7rC04ItXE59aWvmhL6n8KSwPANscpKHqFqI9qnTYbybZsZmgSI3orEghc4HQ7CROjE+w3EJNYnfMe1ziszaiqmnPnzqN0w2hUc/FFF8EE9uzZjdXnRPfImHlGEYUJpD3BNsCIJPogkxNC4GRyLi7IRqOzQHSJw015FpdWuOjiS/jMrbfyghe/iAcffjhRJcmanzt/jrJuKIoeS0tLLK+sYm1GXhQMhgv0en2Cb7BGg2o5IGVTzLNcGPjLMZP1s1SzdfqFsBUEL+hA4cJL2ljaCs9c6kVpLXpIIUQZUlYKk+5ZrQJWdzckwhxuhEVFKXy0uMwQcint5XmPoPtUM8n0bSY9VLxDG0VeDClyyyBPpWebE1u+UAJBaUxRkFktDjZqshb5lkrOIQhXZpbNA6eoIj7W895vkKFco+VcglLYBCqKwUMtM2TWGFFqUFq4NbcALuR6h/YBoBVQtMYm5vl6rncVPKRhYU0KQBOwIoZANSulh+kD2qbBbwTUo5KDiimoIFXeg4o02qdWWBTJj/TZKCkXRievu+bbINXxZNuRE2e49d4xL3rJ27nz2JgHTjiCzTEosmyR9U3IhwZnp4zDkM1pRlkbhi4wCQ2TUUHdyzG9Ac10A7uQs7RzFTY8e/avcPakBxMZ7F7F+SnRwCAqGeiLfcrZgNGColcs8+BDR6nNsjwMyjCblfR7gdIF7GCRMgjVyMRVxFzhYkAXGl/XZJmmDqD1QAYWoyJ4iMoRkfJLCJYYM8JkQH+px2C4SK+3QPSBPCtoqgoVA3sPjFBEsuGQPIsYGvpNH62sPNCDHsRGKHKiZDVZ0UuFYpmHEhNnMJf7pnNKPmjQvTTfHlAq4EJMN1P7pLQUMjLYJ/pVXkAU3pEbGeps9YaaJulItclc8AmoFlPj2YCK1D4wyHNCXaO1wbsgsudIthBSs1nrSMwslXOMrCUDTBTmDNHnkpq5DvIARQMuzgdf23KOtTZR8YjkulaBzGpK51B9Q93UFAaCcmiflFaTgqvSyLAyUVgOgqJpZFBWxAJF8DBQE5TDuUgvW6CeNbjGE9F4L+BLbTJq5zg7rim8Y2c+YOP8GfavLlH0I0GDVw02aLSzGOUAR4gShXsF3kWyFPHkmcaqhlEuvZq6iVTVrNNRcD6we/8eTp05yaBfsLq8xFfuOIvNDT5GqnJK7Tx5LiSzvf4AbXOyokdWDCidxzQV2pXo0IAC7xXRZEStyZTGqsC4HLM5PUmIJdaOhKg4WPq9nMXFEf3BCB+hahybkwbfsoD4SEzUb1KCisQEww9RmE2CQlBzOqK0xwAxNrhYMauhn2dSkjORsS851wRMvgDRosmJTUkzmwE1CsO6SxmOLpOGkmy6KGFc8TYxMQTQQXdAgRCT21AKmxdkWY6PkbqW+bOYnEK7o0tHTUYrnNJYpbvgKmgt5TSjU6yYgrqY+lcRYXdRCofB5AO0MdRB+me+cZjQYKKTvldykD6Ciy1YyLePPyASJSrMsyzVbg9dUCAOKIZIA9RZyw4fiMGBl+DCxzljjSJS/0WwoD/VzNsRH/q92/m9zz7A8spOlld3gy2py5Joc2o9IPgGrGHDRRZGC+T9sUyxFwq9sIIbZJQolguBoepskRBmMqNgSnwemZYB73N0hH6/wIdKJLx9webmFEJJVTvKWibUHYasWKDyJ1FOcN9N9NjMoKzMGjkvyrjBeVwUglwfVRIWM8SgCFRELUJsvV5B0xick0ikqUqMMlRlTTkrUSGKlEjahBWBqvL0skDwgeASGiqRuWoVu8Yr2nSzC1uSmWQpkovz8l9ULUty26KXJm8bys97L5E2mtdGo31IPQlP0HPhPGnCp5JFnJcXDfMMziiLRyK9TGvwfguVi6EDuiam7KgktAsRVFSp95HIfFWrqKPESWnRhk1P3tzihf8RkYhW2wy0yGlMZzOIPj30RrJeNK51+kYjrNCKLLMUeS9pK7WS8oJ4jKKaSVQyzFlWNWVVoZRlOOrRC4HxBKaupqqnHD/xKA/1PVceuA7ICcqjlScq0RjTSL9HAz7K2WqTYYzMmCnVcPCSiyisgjrphvm5BpLWIgN/5LHDXPasK1g7d5Y8s9SuoawqvA/0+wOGo0UGgxHFYEBmC6zNyPICTCalpNCQ4yRyjhqUcPmFEFFNLdpmqiLLIs6VXLL/Ii7adzEHLr5Egg+lEt2PIsrjRfCBpvEdk0dTN5SVCER653FOdKpcDDQxodN8S+LqQHkar6m9ZjAcETSsnV9nfexYXB1htMWVjmZjQqimAsHwijqKwrXA/elQn23lQKU5NR2VACBStcFH8ERhTEdhlGTO9bTEhhq8DNGrBAARDkx5LkSGSJG1BLFGE43Ct+R3SgabjVKYVNWtcQSlcCon14VkQVGCFFc1hGYitFPB0+E0Yux4AUOgGy4XJyRy8C3LRLshtIPVIuYpPVdnDFENkbEvJUKeTdPxXIpAqvxePau+qX3+ae2k1us+g2FB0Jaq8TJDoSMxM9QKfC/HhZLFnkVYwhoqV5HpDO2hDIFx1bC6Y4VZUGye85xbqzh+bI3zZ0tOHFujLhV1GURgUCnyPKPoaapqk+lmQ1aM2bt7J7tXVzkxOStCdE3EN47gPFYXBLR8f5C5jehFwE6RQShAe0LUhJRxEIU8EgzRBwyB0EzIjUSqVtWMz5+mnFUUvT6zyYxeUUD0aB3RiVvOq0hoREsm+CjzJErT7+Xz8lOcU7Kg2rKd6pxD3Lprx9aPzUkpU7UvlRVUV7ponY+ALsL8Bk/lBO9858hCmmtRW/tSF1xplfZO1T0QPqQpf+bouMebNnoOH++qfLJxCBvFXJuoPV5Ssxs1P5cLKoRRIlxjLJtVxWQ6pYXtSyanO9RTDIG8sOg0/FkURSKXtZ1+WtMIvZPWJpVDxVn44BMcX5HnOVXdbsKOntbMZlOcKzFGdTpf887Cln5iqnpJvBCpXE2v6LNe1qJAqyzO1dIriRGS9EPwDVVVsTneRCnF8eMnCD7gmoZeUZDnPbSxkEhwvfMY7QnBiCNP+lcGmfORgU7p06EVMTT4ekamI4ujAYbI3p27ufzSyynyPsGLDpzSwreotcbrgE2Q+iKqJMgZOn2sFgod8XJO6Xo5LwwUwTUQG3AVJnqyXBOVp64r6hmYoBkpzSgGYjmhnmyQqQYdLaohoQolY6G9fyJdQKR0SIPZLdtJCoViTACISBZNAmUEjAfjpcynWyBIGyem8l975wViYltPYoZGpe+S7D225XelgHb4PmB9pCCVk30k+jTX5WUmTrKn9PCEKATvEUw3NAUQaKInaIUKav7MpedIbVFB9ulzhCM0SjBRNSh8YsiI6BS4Nt35/fH2tHZSMd+BwzMtpwwHOXU1YTJZI9gekyZi+wv0tKGpNpisK4ajEQaPd4EyBBq3wKlzY4bDnN07d7Cx6dic5JRlhnMNIcgObND0igGaXGYUSke16ehpYUteO/UoVx5c4bzepC7HKD8g1AWjYZ9ZlcoOiMqnQIINKsisUfSgsgxljJT3lKJjaw6K3ApJaQhTVJiRm4azp88Q3JQiM8RmglEOq7RoQMWY6uLyM4Y0vBfauRIR4dOpTBBDJOg5m7hSeu6g0v4c2+wm3dBzeiK56TrwRJsVxfnm35ZiRIEg4vEEEwhthqWldxKDmksPROaFbrb0uloYepr0D+1AbDsC/zhH1SKj0sFdgBxsKZO2OqStaVSLLowJydR+StsHUUrR1I1IU2jpe7TN76hSxtqxTOiOlUFxIWoRJXNcMnRDt/HGRF3knMNPPY1zeNeAC9T1DGsjK0tD6Vm0AzZKgpugJLDpHFV7AuJlCTFispzz62tMyjrpOdH1FaGNkhXLK8ucPHUShcJaw8pwEZ+CndgqHCkS+a5HG0RzKs+ILpCrHJTQXGkjQAYIRFfJPWwjfZszHPTZu3snaf/FuYaqaai9xwWFSuSyxugt1FJW5hXTtQ4hCr8cAWwk01ZKr7SD3u0cj+ixWQ1WRQqt2G9XcL5hsdfDVBXlbAPTTMkLLWAObcicRSFl5+QROl686CNBSbAQlQJj5vNvSACmg8Zg0AGUBxsN2qW4NLSgD9lzVHLC7b2o0ncFrSAJJJLmGrcO4kqJMxJtup+DJ9S1PC91RWiclO4S8XGqQ0pPqa2spO9X6ZkNUeannApdyW8evKoOcSi9MZsqMyrNRSam9RhkDUD+vuXnn2RPbycVNbk1jPKIchP2LO9kc2wZ7NrFhrOQD8ndJv0ahguLzMoxmSsxeYGKkenaGqvLfU6fOMOoN2KyGZhNGqqyoq5muGaCtFQMhemRK4uLoLUlG65QTjZYHfa4/NKLOHfyJAtFyXOufQ7HDk84dngD5WuCr3FGE1WN0ZHM1ASncUGiFaVFmp1YEnUtkWYQETWlAsZEiJ7nXXMl3/naVzIrS27+xKf4yp1fE3Xh2qFNwKqaoJ0gm1TAbOnlRC0PlWRSUm5sAQWtgJ/swnOGh9YxdU8AaSNMaJ6UKnRlthBbRyfXRmmNIUO7Rli8lTTNQ4RWEXgrk4T8CcTYUq2wxXEk5FOL+lN6jphTSrJEsxVzKNah+9osSU6RC965xbd12BDVDju248BzR6ytpWkCXs/58bTJ5MFM7OpGi+PJiyINOaco03vybD771dJAqdTvct4TnKD6tg4BN66mqoWIlyhAwl17Vtm7bwdGtySgBgG+KGAe0W95WoQAtZdT1Q2m6HPP/Q8yqx0t+GUrUbA1hl5PZN+JsLyyzJlzpzDZgMWFBYzNJftVBpvl4hxDxNcNvqhRSTKmsDmhqVKDX+OdI4YGqk2oNykyz9LCkJWlJayK+Lqkco7JtKaJpHm0ID2YKNIeQgElzPZaidMqin5HnGusxuZpHYImeHBeArDMWLTO0HmG0YbGeYIG2zPk1JjoaGZjYZhPDPmegDaW0MzBArKfp55Ul2EhpSwtHl+bxLTfAg5UJiV9H3GJgNmHkOicUmAXZZi3HShXSvTxhHBprjTQldG1XOe2hwpQ+Yg2KQBUAo7yMRKV3BcoRdDSu/Nm7kQlG1VEl5S2E2Q94AWFb+dgKkUb/KbjUGCUThpWLbOKPOsmy4leb8mi2mfpm0MuPa2dVO5L4rSkmY0ZjSKvuu45qLDGRr2BzftQaIwvefaBvezas5s/+PQXsOM1bNEXpI+f8orvuI4H7ruXo/c/yOmNwLRs2FxfYzbdxISa4D00ilk1gWyRehbR1oq2z2TCldddzGtecTW/9t8/zN6VITe+7iXc/sUjrJ/6EpvlGlpLs93m4OoNQr1MaDS5KohKURSa6eZ5ytlJMtswnTl6NiM6h1EBwoz9+5Z5y1veyPOeewUhBA4evJj/4//z86ydWyNEKLICV0/khiVJTOOFPdv0UNrKUKiWWTGrzZxlOaRSkZk7KGhLfinqja3TMMAcpk7qIcX0UMWOOaHd+TVGZwLZ9Q7wKVODeTaWfjJ3cPIpW011P4wxlK4SyMYFM0dtFqC6v7c9so67rJvvkE3kglIfrSRB2xNrP1ciV8nY5DDkMZMNxiXgR0wzTjo1tR/P3L6VOaMNBtr3CEeFFHXqKgkctv0Aowi1EP4Oh0MOXLyXzI9ZVJsMB5amnlL0FmUzVkaujvJpc9yyglGIQV3t0Lbg/HjCnfc8QO1FvkXWT6f1k7Xr9XqEsMZwMCTPRY5+Np1SzoR1Y3XnLlZXd2BMTt04NjcneNfQNDW2yKirmqEdYmwmUbq2VLMxKta4yRoLeUM/jywMeuRG6MvWzq5z/NhJit6Qoj+kGAwZ5AXKmoR0S6wdUfpowQdqr2jKTcqyoiwrCYp0SCwXPYzOiWiKvI/GYm2OtbkIBxqDLcSxFSYDIvmgRz3WKKfRRYYeCORbhxyNSfx488FXWS6NIdEeIdIhUbclWCXQt9ziNaAj0SjAoopclHnTvaGVluynZS5P6ESUJUTTARWi9wgLluqcY4xbWh65RRcF5IZolDiooKCwKJvuhwCtuKFGYUjl+EZKja2/tTGCCQQz58/c6qBAKNO0NqAtmLQuUdjcUXNuQp36pCgBanwz9rR2UvW5h1laKVgeQi+WFH5M4dbxa+vk/UU21xxmVmMXrmCH2U02Oc9SrFEuEJpATsYXb/59qrrER7nZQ+OoN87hy5JBUeCUwxQZriy5eM8Khx85itVL1D7HqsjiqMeoZ5munWZpV8YwNywvGur6LHlRsbQ04viZEzSzKYPFPuun7mXQX8E5w2xSUelAlkVWFzynj55lx8oepuMJvV4PoxzBTzn08ldy8MA+PvI7vw0oXvNd380rDl3Hxz/++wwGIxZHi5w9c4amqllZXWQ6G7O4MGRWVcxqL5lfbiQLEoZOkV038hCFICXJeclvq4toiyTzB64tv7VNqvA4xojWJJISye3aQ4x1appfeLNLn6n9HQEZd3BC+deuXNPKjXfgjFSibB1ZNwvVOqD0u53+VJsVxZYZfGtPSzE/Lflyk+ZL2uzLeZmRCjGyOZlS1TVB9cShJSobaPtv83Vp54SapiZGcbZ5LqjEuq6pvSNG4cTLbAY9Q0h6WwuMkoCgZePsGcZrZ1jeZVkY5uSZbDCi36MThD12mZQ429ihv9rS6LHjJzm3tkGZdop2Zqst+bWl1HatnfPCyp046Zx3nD93lslkysrKTnbs2sWg32c8nuBcw3S6iSZQFxkqROpaKLjKqiI3Du+m9Bcyhj1NL9NoPIaIr6b0DUQ3w08dlatwhciiq1zmrCCVl9I9KbInil7f4LJCdKhwZJkhMyCzeh5XOqLKmGxGZmWDi+CMolGB0UKPfXt2oHqGXr/HcMdOqklGPsjIF/sENLnro6LBq4hXCQiZ7qNMG3Il6sGSebTNJdXdz1pbdCYbdmald2cKhUprGpMDaimKpOqd7mWTST9IaXKjU79bYY2RYd10zXz01KECqzE2IyqNE2+Ezq0APKJNWY1GhwQj74QllSAnXeozoVFBAA8Bt+U5EJ7ClrVfpQpFRKeKCCnwk3NpJT+EZxBQisw+A6Q69i96Ltrd44d+4Ebq6jy5cRg/45rLL+LFL7meU2fO8eu//KvYA3sI0zXU9Bw/+oN/heXVVT73+Vt44IEHecHlz+Uzn/0jDlx2kFd+52upa8cHf+ODBG/4vu/9PqzO+fwtn2d5cYVD17+Cc2fP8su/+jFOrXlQDSoInNvGyHjtLK6ZEMOYpWXND/zwD3DJwQP8wac/ze/f/BF++M1vxtiMZ191DV/8wpf5+O/dxOLKkHf92DuwWvGhX/swBy6+DB1zPvbR3+UNN76O0UCxf/8Ojh8/yod/67epSs/q7r3s2LXC6uoif/tv/zgHL7mUT9x8Mx/5nd/mjd/7BnasLnH5FZcyK2v+f////4ujR09Q5AOpYyPRfeMdWou2UdNUtPMrMG+kyj6t6eqBXenviUKgeUmtpeIxqQQGEmkqDARF1PPfaedntpb4WhBDW1i4oIekVDfzwTc4ktbaB6frQ32L91eMsSvntFoXIbFx+hA4e+68EKzmEh22DrYtUoaEHDHGdpFn8A3OhY770HtP4yuR+MYQlSjB5rmhqh3T6YSyrpnONplNptTTKaY+zTUXX05mIyE2KfdL/ZLY8iC0VNXtKkp51hiDA46eOMnGdAb5AkaHbkg7VVAxme2cVItGlPUO2MSlV5UVVdlQ1w3r6+vsv+hi9uzdTV03VL6hKqecP3+OXt6n8TAuS1FqpsJoT241/cJgDeAbXBNY6GUs79vV3TNtihw1aN2yK6hET5X6e8FhkIhdZdITmlQ1NngsPvV5FBmaqp5SmB7DxT5NVHgbaUykdDVnzp8lLIzY0SvoDZYplAFdE1EdX6N3afO1orTbAhxaUJI1iTpIbyllpTJBjI3A07WcQ/sohdS/aZlH5ApuDR6UgCYyK04MoYgyasvvIb0oUORZryvxC6gkdEhYtjDFwxzZ51LvSQ5VpT6qhehpfI32CZWXglifKhNeXViySyFwKp3PgUfdTKCaIwTLZwIE/YXP2cPBZx1kZaXPqbNjVnfuYjze5JXXH+LwPV/l4IEDHHrx8yBWTKZnefZVF7N7R8Gjj36N73rVi3n4/jt43lUX87WvGl710ucxPfswRme84ZXX8eU77uLqAweYzSp4/nO5+OL9HDl8NwcPXMx1L76M3/69r6R0PHLRvn38vb/39wiNZ9/eFW6//cs87/mX8uLrruCB+x7lh9/8Rg7ffwdXHdjHpQcOMt6YcuOrX8qdt36K/+Vt38++RcvJ06f5a3/1Bzl+9DT791/EF275OM+7ej82C6zuWOXwo8eYzDzlNPJrv/Yhir7ita97LVc++0rWzq3x/T/4fRw9fpgdu3bwmte8khPHH2P30i7e8IbX82sf/BCulsK5d0nZ1ifVzo6VYb7di5PoXATz4lubsXy9a4itH9tSvlNamsTC+C36SNKbIslQz53I1o+U8qFqZ4ZpG0dtScRmUr5sB3svHNidW/fZasvPb8FVdTpWW9vEbfklaMabmwIGUKlR3Pb85LBopb9bZ6SUSg1ycVii7RTm/Y0QRM7dO5wLbE5mTKdTAuLUZEMO5MaysNBHaykDyvXTEBP4RkTjoc02ovhYURqOKKOpGwcmR+cFJooqbmw3UBSDfp+WYLdImlFGa0zUqOiJUXolSovyq/eBkydOMJvO2LFjFztWV6jqgtNpYDjqnODledkYr7HSc/TylAkqRdPU1JMZWRSQgnN1J0FijEHZVvqhLcMmZdj0UwWRN9FaE2LE5ib1SVzquUBUGuM8/cGQnXt30xuOcL6iwXF2WjJ1MBouYTF4N0VrT1M1uHpGljU4X+IDOAOmyLH9Atc4XN2gnKchKdXiiKodVG37PbJhN9pijO3uw5AYKGSWqnVSdOVEYwV8Ywd9soHMBdZlhQkpr4np4kqackGfNziRK2krDqRsOiaIeSudEUJMpWuR04jKYLMMmxU4L9RcmQftE4ioHbBnC0df+2wQCMF1e0RIm4GU/VKwmlhW6uoZwIK+Yyln164F/uiWz3D3/ffz197+dmZN4K6vfY0j99/DnsURe3YuMZ6VoGpOnHqUW2/9FOfOnefq513Gzp0DrG0oZ+c5fvQB7vrKbbzkxS9ldbSLoVJU59f5b+//ZZSOvPzQddz6+U/xpje/nh07cpRpMEjaboxl3559hKbB2posV7zghc/mvvu/wi/9x1/lf/97P8t3vPRlxLLkgTu/yk2/dzM/9mM/zkuueQ4X7V7h85/9BHd/7T7e9a6f5vjhI4yGhuEQdu0ecOfdt7O680WcO3eOyaRhuqm4++77GSzAX/nhv8rX7rmb/+e//TJ//2d+hhe9+IVkecbJkyf5j//pP/LO//Vd7N6zixgdVVVT5AOZCXJhXi5L9WSBlbcAgXlWNK/8bamvP6GjmiP72jo9yMMg8GbVlfVi66WQG/4C1oi0wYcYOwaBuTObZ1LOOVyKIi9EG20xNXdu8tctf/kmbGtW17XF0rFqY3FO6IiqOIfyJ8IeiYaTA2o3e/lMWet2883yLEXOHu8ivhKF3sb5riTokoS8MZq816evKgaDHsNBjiJIJK9lKqqNZNmyIuLnU+klUeHYvCDv9am1gdAK9tFtcotLS10JsN/vcf78muh/OSlVqqhonIPQMBotgDLkWY7WmvWNNSpfsri0wPLyEmvnNqhrR4jg6oa1tfPsOzhk2M/RyPxMXZVU5TQNe0dMEPCPIOEUODW/bxKtk9ItkACsLegniXcXArOmRiXqpVZnyto+i0WPEGasn3mM0Kyya2VEMSjYvXOVfGUfk1nksYceQ4ecTAesrmUg29VE70BpTKbRmZHswntiXeGrmuhEVFAbjzIxzQOl5yWInhRKBr11e58zd74xlcGUmaPeRAjUoIPM+fmmoZ5OMD4RzKbAA42IJxpBv0YfZB40kd5CO9clWaVqh4dj68Dkv2NE1I2VQltL8I66LAkuol0q3el5sCoZV8ueImCvGBra7m5LCxViyoK1JgZxWK5pvqnn8GntpKp6Ql4YTp06znQypiynVLOSPMt469v+F5YGPY4cP0YkUPmGSVXzvBe+iEFR0O/3MDHQVDO0iZw4cZy/+pYfJrc5J0+cZ3m0wPlz5zl6+CjaKLJX5vzNv/436PUVR888SvAl9czR1A2HH36M3/udm2jKCX/tHT+IVo6Foeahw0c4f/4UZ86fYt/+/dTVjGrm2NwsmU1Ldu7chVFww+tu4CUveRn9nuWB+x/ksisO8prvPMTy6gKfv/UurrriJcRoWBgVVNOK733zjZTNWRYW+tz16EMcPvwgjx15mMsuO8jJkycoq5K777qbtbV1KVNkOdo6Ifp0UerMCQgQfEQri9Keloyz7Uts7QmJBWhnpDpr4chbHsitpbsg/QBiUved/1r3PpGTaFE/qaQY0owMSmrnoskgmYMGF7ygoEjb8dbPjqCCRkUtGaGOKC2lxZi+PLTeV0u5pvPGF2R085mv7rBjlOlMDTFaUDkEYbPQwXf8ccGDr6tElySaWsZ48qKPAhoXQDnwSGRtrUjDG4XWkRBqUTS2BqPkHKJzqNBw0Z5dLAwGNGVNfzjEaEVQPpUaIzLJFVI2JWUlFTVKW5SKNIlBw2ojEvIkJ6tsKs1kFHmPpnadSvJ0NpEyYEKs+SDs7NZYQmxYGA4ZDPqgElKxLjl9akZRDNHZgOlknboq0XGCn62zNNpBURSSSWhDXTe4ugRVSD8MLT2ftInrCME5JKgyBB1QSmDt2hiBkxsl/ZngGWqFdxLVBy8bsdUNoQrYIpJjCZPznJmeRVnNplM02SN4NaScRQZ5IfRExmCCJjY1mTIdaEaHiPHJAYaAbzzaBZl3MgGM2/JESActa3t6waFSH7f0LYxczZnQo2obulLW84roNL5RuKbGV1OBrpOcjSLx/QVMNOAlEJ0P0LZIXxGCJY056OhE0iWmsRXAoXAqkKlIpqEhoEIj2WIjQWELuuoQr4mqaSuRsjwsc5QsKUsMsR381398rX6LPa2d1KwWBmHVVCxaTS86DuzdxbXXXMPnbv0CBw8eIO8P8OUUY/u88rVvoHQ5X77jy9zw6kPYoBlkPS7aczGvePlr+PIdd9MrclZ27mS9HEOm8Erx8utfzRWXP5+v3P45nnXpHkzUFFZRuqnMTgXNHV+5g8IEyrKisArlS4xX2B40usSaAeRDJmPH2iwQiyFVVKhiwB1338nZM6co8gf5wm1f5fpXHeJFL30Rm9Oak8dg45zlkv0HqavTHLz4Il79quuYuTWscWRZxBpPr6cxiXV8Op4wGiwSvMLHwGQ2SzdpxGYCyZUAXB4UrSwhJuaFVKayRicl0TnQAGQzU1vmmYTBQvSdlFG4IE1Yq5RwnwWPCi4p6Eo0aa3IL8zLjKrL4kRVNsF8Q5qNUipB6qM0cKMT0cPgiQpcaOYIsgDag/KgVEbjA9GCNgE6DJ0gpbyKGJPol7Y8TN3mTrzQUYWIigETFGVQOG+oKo8xFu0dWYxobUXSID3QMUJde6w1+KCIiFZQZhLgIYo+kIrIsK4PafDV07iapm5QWpFlGU4HQtygl62SoYm1JxtaVHSgZiiVJcBEBjTJUQlDSGyz1eAxWQ9XOUwMWOTSukZ6T66RnpNWBePxjBgUPjGZ+OAxVhSWfVPKtdABRYbCSW/ISqlI20DlFXUwnB1PKStPET3V2kkWVM3qsIfzkaxYoHQe7yM9YyjSFWh8JCoZxbBaZgwVSdlYC3cdSiUJj0TCqhOXHg7rHco7nJfAQZuMzGbiDKIncxW9TOONoUFhg2d67jRV3ED1lwkmp8xkRqqXOPlokMHbKB1A6wEfhR1GSxajotyfPrrkZ3QKzpTIy0ALDyWipPdkknPS4mjS4yAZivIy2xkbZo2wNzRNRagcRltMTKzpisTIEYm1I7pIwHe9pxYQZaJQgUUvusBROcn42+xUQWYtmRYcrw4yzVS7UoIkICbi2ZY30AQD0RKjaOJFY4kBMiXsHCGViuU4UiZsjDjzb8Ke1k6qVww4fvQEr3rFqzh/fo1dK7tYXlzGN4Ejh49y3XUvY7yxSYwFShciKbCxQYyO4aBHM5uQKw0eFkYrPPLYSQ4dOsSkmhKznCpGdl50MXbYRxcFX777Pp59zVXMjm6wsTHB2IJZ6UFZBqMdxGbCrIxMS8XJUxtcfvnzeemLj3LFZZfzR5/+HHt2XcR0UtLLBxRZwWOHH2P8vCs4c+o8n/vc5/iRt/01hgt97nvgHt549au59dYvsTmZcscdd/NDb3k1b3jDDexZPcBllz2LD3zoV3n+NRkX7b+E6657Kc961hXcd+99GGUIQTGbNUQvcyqj/pDxxiZapwelhSalzMkYjbE5EZegz6kJrVuC0nb4FCDBbON8yDXo2CHCYlsTR6K1Lu1PG/+FyEH5PKDdTi/49znjQxpEpiUXbTd315Xjnigoa+vfgdA52e6z08YRVQv0+OZMKaF6wSrOnjsvoAgf0nxai2ASpVUVk5PVrU6UFTAJMpjpnCdE2YC0th2Srv3ZynjENNTrXEOuAztWFtP0vsY1XhywFnLatpOY6oxIGbZNM6Wf5pyjKiuauiHYDEUky3LquiazBUophsMhk8kE7z27du3i6NEjwjeoNCH4LesfyLJcht+T0yNG6X0qzeZ0gvNSSppN1lk/e5LLDyyjEQ5Dk2fEWIpSrHcyEKsM2mR4GfYBJfyQqh16NkY2VaWEvcJoGhslOomRQEMdZK4sWmEHwQrhb0QGgnUW8MYTrZHgA481QXpCVtSSAwqlLTFkmCzH2J6sqdWQWYKRwd7ohd4q6kjUChcjQRuMtaLlBHgfcS6k4W55DhsfiJmRofNWlDMNfMf2udGGYA3RWqI16OgxhSaEkio5Am/EwcQ0FxVVJBpPULbLzkJM5cd2HipIMOORioQMVsl3K5sRdR+vCnSu6S1otM6JTSOdziTx0UrASB9N+CGjMURrRPkglWRtkXfML4LKF3Ya800+dE9rJ9Uf7uCLt32Nd7/7NVx8cWBjPOX+B47zvOe9jL/+jndz7tx5fBhQO0U1CRx76D5+4PvfxJXP2sd4c42V1RU2xxPKScPJY+u85a/+DSbllDheY9LcTzAFpzemfO3h47zytZq3/6/vJvgJK7sDxXCJs6fPUTpF5eD8hrALm2xIWfd44MuP8uyrX8rf/rGfZGNjnVs/9yW+73sPUE0a1s5u0JSeeua57davcOON381rXvVqJuWMjc11jhx9jKp2HD5ylKgjn//iLbz+DS/hb73zXTQlnB+P+dJtd3L61Do/81M/wxWXXY3RGV/60l0877nPY+eOEU2tyGyftY01yslMIqfgybTFNWlmKCnIahCS2iBw03azjamHodpaWqtt02GP6MpsWguktpXUAKDZ0qNKzunrndQWUxe6qRBTWSI9BEoLI12mM1xCKWqtWuDd15k2WxinaR3d/PsVfMPf/eMsRHHS6xtraK1xjSOk6oXIHklJKkuOKU80QiibOETbgWlhSfc+EnXqWYD0BoJPg6+S/UWliN5R5JblxQW8a1C9nJYBO87dE23bve11dI4qtn0CKS21fTMVPUVR4JoGrTWzWcnq6g42NzcByPNMxCqzbN5LTMrBTdMkfakMrTOIBmMCJhdYdDUrCUETfU0526SpZuxceRZaKazJxMlbQ5Fn9EwfG6XUZ4zQnaEUVnkZ4LYKjO6UllXXiJfoPLS0crlB20zwBGk0ACWifVJWM/hc01hQKoEF8CJ2qBXBpCBGWaztYYIjsxaUQYVA0IpgtMDQkfknbYQ0V6EwThAoWZZ3DPfeR7IUJESkfGkgOSW9BcHa9t7a7qYwsZBJ/1JbKNSIUNTChYnqnHcwUpkww4oYvQRnShG1BEUqRiwaqzUWTVRQOydBhNaAlDN9VGAyMBZrYGQXCP3luZiiUt29qlTbR5YAwClPSZ24JLTQM6HJbSZov+7+07hsy8zlH2NPayf1P3/3s6A07/s3/5myLBn0B6xvjPkP/+kDXHLxJTzw4IOsrK5yfjxmaedOzq2fZW32G2RhwuT0UXYvLNEb7uTsOc9/ef+H2XPgIPc+dD+rO1dY2xxzfnorE9/jq/cd5d/8X7/CNddcwVe+fCurey5mY1qT9Rf46t0Pcf7sJugRztV88EN/yPrGOrNyyn//tZu47NI93H3Xl3nooVPccuvdbKyPObdW85GPfIq77znC73/iD5lOAweetZ9Pf+aTnDp9jvHmjMZlHD12jhAiR44e41//f/8d3/vG1zLsL/Dxmz/JA/cd5ZGHT7Jn529w7fNfwD1fu4ffv+kP2VirOPrYacoy8OlPfZb+IE/1cIN3yemkzUrKEBG8TxFfQkZpgUzLXE0EtuzAQc/JYbuyGKDSA7fFGSmtksZMsvQQkt6/tdMln0fnqFoGAxSYVnYhgS8ynad+Q5ASiX9iTyMlhXmvqSXO6L5sfijfkmkt7OfOCcqtFZ6b85npORFnytRCopASR9tmNvMZrlYIr/1766DaHpd3DXVVkvcURWZQyMapE6npBeeN9M62liu740toSJMGurWWrDrG1rlqvK/JsoyyLMnznLW1NcqyxLROP8rMT4ykDM9RllPyrCDPhGXDOUfpKnHgwdCUY3w9ZXHUZ2lhiFEao2Ww1tUVWWbp5T2sqyXbNDlByfZklayZMxBsclIJIWaNQPZJGZJSCqzCqEx6mAnsE5TMMtGiAdtNPWV5RkfyXOOUzE35lsLMZMTYw9gcrAQP4gpiqhwgM0nGSP/XGAgGRcqetaLxARcFNOGDAB6CTqSxINkNbUn9wpuyDRCj0eK8tcb0CpQN6dhjRzorbZ5IrnuQqiJBzQMiEj1Z66iiEtRpbDyhy7BIYEFDjMLooS04ZYjaCmN7hIgwpbfIWoX0tIJukm/SkIiAQ/ToaDrGdelVhQ5M9CfZ09pJna96aJsxPj6VyGpc0u8tU09rztx3EmuXOXNsisp6nDkxpT9a5Pb7DnNwzwKTjYYbb/xu1GAnZyeGR45Oufex+2hCzbEzp5i5hvXpCbJ8mfOzM4wfOMVX7nmE/fuWeOzcowSVUdc1R46e5sjh42QocmP50lceIIRAVuSU/jSf+ORnUCrQ661y06e/RJHlNKHPR2++hfF4jYXFXfzKhz6O0QFUzQtfdB3f8R03MF6PnDtbUztF4xT33vMYDz/4S1SzKb3BAnUjU+gf+MBv8Vsf/lgavsy49ZYvccstt2Ftj4999OMMBlZgso0nsznRh3QTalHNTZBn7wPOBemJINLWLWxZeP8gtvDjxEtNyrKClpJbbkVyuvEuNdilh7WV+SCmSmMiiRZTQGr2t8CGdmBWvne+iRJUit6iDNYGcQBPFJN1WUb6zqi6L5Ot61so80FbQYsYa6nLBm0Nvp73ngJRShjpT4sEjFGypIj0ETq9K7XFIcUW8h7StXB0Srsh0DQNs+kENcrQ0dPLs44FIqbzbJnR5pNa8+OmW2/pH9ZJ48raDFqKKWRz6fV6SYF3xu7dO5lMpkm/y5DnNm2WJpV+5HOapqauK0JwKA2Nd0ynM7xTog812yA2M5YXBuSpDGZtQW5zyrBB0zicdhiijBikuR2dzl91NEACjiA1+1tqrhhCB6KIMVDHZs6CkEpu2qZ7gQAOHI30Pb18j1KWEBUuWEKUzCkogw+GgCG6mQzrRgmQRA9Jrq1HgfN4YzDRoLF4XRGAxgc8UbI7K7ycwQWa4IWFn60D8i23Y0uum6I5TULGQUi9pTYzoZVjCW3FIMqzpBTK6lQyRQaanadxjRDZGo1Tgbr2iVQ43adBIcOMSdpeCWOF964jPvbOdz2pdvZJa40zgWAdZBnBe1xZQu2JppLj3UL3tFk+A+akih0HmFUNmbVUITDo96mUwvRNl1IureRsTGf0R32aOGO0tIJdzFg/fo511+NL9xzh+LpiyjLaFMRYoa0InC2tHmQ8aXBUxCjyyxtlzt59FzOrj0GYYiIYk2OTtlHTSH3XOcOCHpCN9uK9o4wK1VvAG0NQNRPfQLGTiYuorIcPDcbPePnLv5PnP/8l3Hb7XZw62TCeeEy2gA4B72ZkhcUFRV4MJPomUtftzSJRfm5sl7Q0tQM0WrcIroQiQkmEkwg/y2qG6RWgFa5JDdLQkrICtHowpFIgaGsS24EDrWmCw+o0xZ6ciCh/zvtL7Ybpve9u7K5TjMwaeege2i6rIs2bKJnPAWGDCMFj9BPcxsk5bVXCbbM7jQD0QByVrECyLcHslo9K/5H6bFoxmU7lPMJ8DVGp7ETsIk5Uq1wqWaH3HrTq1Elp4/LgBRXnBIKulWRPkslsAIq6nJEpA01JbheB2LEKtD28OfBj3oaLKXo3CnzjqEMQ9vW2rIs40jZr6/f79HoFSsFwOKRp6lReExJXrY04oiagtcU5oXIqq1nauMTpVeWMSeVFRbnaJFab7Dywj9CUFNmKoAkxhCBExNO6whRWSlHa4J2IXGolXJJGKZRTaJ/4W5XqBkyJoJJUiZyRUBNpq5KyLUQnc2Wdaq5WNN0MX8TVM1z0xCzHUaFMQYiWJiiqxqN9g1URV6bh98YJjDqKHpNPG7ZVqhuB9+m5cQqMzRktLmCznKauaMoKG5NkTnfPzQmIWyfbOgKQ9fBRJOuJMZHmmU5DKqJopeVRCpNJuTl4Tzmb4asGfECFiI8NTrsOzCGkzRADgo5NA71WG4IKOF8nPa+2n9oSzkr1wBhDzBSmZ7HK4soGtznDuEgdK1SICaAk5+eeCXNSSzv3sayl5OF9IMvm/Gha665paUc1xWiILQy5dTz2yD1sTA3/9/t/E6MGjKeGYEfokGGUhRgZDAf0BktMyk2iyqi9x5iCqHKyos/i0iJNVREb323CSimUTcSNUVH7SH9xB7OyxDtPmhLCmkyQUkFUayOBHNDNhJt+/1Pc99CjPProKU6c2MQ5uemjz1FBYUyT9kLdNcq70l3bo+mkMhM8vD02pHzgfUDHealOEN8JJq4RXrEogAmt50zJ0pZKD0V6TfKf0JWQtNIX0Lq0jX+Yl8NayC0dak76X0oLSWU7O0U6N3kKpISmY5CNJH2WtRleqbmT2WJybimb6XK09v9jp9/z+GzqAoxF+/d2U0CcfVXXNM7NS5QJvBHS+yKJJ1DJLI1STpr2WgY5Y8dSGkXXx4ugn3eO4EUtNYZIXTmMVqyvrxNczY7FEYMio7AamwT+5PtUV1rsMql5pRPacpISpzWZTLoyUIiSwalUXltcXKSqKqy1LC8vc+bsyTTQK6wY6YJ1/ccQHEqB9w1lOWMw6AvHX1mmYdeK2EzJtcjFW63IrMDc0YI29R5MFP7BoAxKi/aSDhGjAsan+y8KoNsEGeQN3hNd6EiSpBqZxDuTp1DdLGsiWE0dvKACyuZgRJyyqSvq4Ahk6GyAUuJgpDcKWVQo71C1IzoPdYNyc9Vln/o/AvX23f0HyXlpsKFBu4iuZsRy9gR3LZA2/xR1Siao5vdpy+IAMrMWA0SXOpEBIqKcoLRG5Zmcg/OEWUWoG5SX2bpAjVelZPZexlFiAI0R5KDKhN0peBSe6MXBxSjwe7zr0INoCSyIhiwbYptAbAJZk2RIUgWnfX4ggnsGoPuapmQyrZLGU48QRMiLKJu4sQarItFVjM9tUgxGqF6BYcDSaC/WB6aTmoWFJWYVFBQQc+o4YTQsyCyMRjn79u1I0OkE9TZgVKTXy8gHPXABV9cYZVFG06RoWdnIMB9gtMF7R1FkGEXalOSPbNSeWHsGdoHJ7DxfuuNLrKwcJO+N8LGUOSFfoGOGthOcb1CJ2FQlAT+R6ZEat7YyT4RXoGxXdyeVpNCqK6WgQWUapYU52WiDNm0ZMAmapQhIHhzAqjR70ZYoZPYhyzK0klmOdsh2Dlxg7ii3ZDVyDnSljTZ78kFKZ4E5g4NCkFoBYWtoUk3buxRaP86U1sKyEeL8YUoOp9Ou6pzplp6NmkfnHUIuva6NJnpE3yn41OCPqWTTDhW32CzmaD0acQRZ2k6TYHErdkdqlss8mdrCUBGxRjPeWMfGyGhQ0Ms0mdEiy56YLoRiJ313bAdJL7S2fOpDYGNj3K21tRaPhyg9iqWlJdbW1siyjIWFBe5/4B75/RAw2kq0Tctibzqmd+caNicbjEYjJpMJZTmTHoyrwFXkNhJcheAfNHnex8WAd1DOHCZTOKdofMJyRpm/ybQiMwIuj6pl25b3GB3BBhL8IAU1kWgk47XGoLQVPj+fkKBtBhsVRT4kqEhVNzRVQ9nMaBpFPxthewugItpYARG5QF3VMq/lhL3chA5R3sYccpz4Lfd3ypq9p5nNZAjZe3rG4Jqqc3JbLSpQQRGj7vq0KXLsqhGRiHN0YxoqIUrlYRPWcRU0uEacqm9kRiumx5hIq0OFiiKwmLJ9YwzGypr6dvA3iNKuCEtKL7IL/pTCaw3eSnXFNISqJjYOkTRp2Vva4LF9GP9ke1o7qZwap2t0cMSqRluLTRudVkLhYqnRsUKTYxtLjJFnH7ic88ceg7piQ23ilaVXWPKkvFkrz+JSxsKCoj/ss7pzlIgRHSGW5JmhKYdEV2NTJ4DYwygNWmaTTGaxec50YxNfTvHB0XiZzSH65AQkEwohoIKhCoqqPIMtcsaTDXbt3cnGxpTYBLTvo2MkKouPmkiRKGHmkXOMIpFtrZEBzwjOi9hZywKumJd1VJT3ZllONIqsEKLUkKIln+YiVGhROckptUJ76XOcM1ityLNMCFl9RkxKqMHnHWS5y3B1y+e3BZKeyjeaRBXjnWgLQafLZK0FLYKAvZ7FO9995hPFZEqrLpMKj3NGbe2+LYuItWCDrX9rk6j0OKZpfB+kh2OsAZ+UcdQ8ym2h7ULoGkAJ60Zd1wQi2gjDuQ8uCdD5jvqoBU+0pUrnXLouwiCgVZSgJHVqYpuZqXnW940ef5X6kE3T0Dbr2+vdliB37tzBsWMn6ff7QKvY25Zq5r0TKSPHDijhvacsS6bTqXx+4o3DN2jlsRqaqpTf0RprLE3ddE4qR1PpQFSOJsjcV7AF2iiIAZ8h0unE1MshiQRqfEQYSuQsE0Ao9T5jTAAeLfdDulkCCldJj6aaTCmnEzarCpd5soVVqSoQJXNvKkJVUW9uyvUOUUpmTSOVE4mMBRKvPAKbV+mf0hMaPZOy6dZbRgy+/s7tgr82mGuflZbjckvqLyCcFOi0fTxruuFg7Q26sTjvaMqK6LzsWVEGwL0O3T3ufaJIchEXDS5pcwXvUcHjfZOus6Np3BYWdKnKaK2ItcPNKnmmnEf5KC2A9qC16pg1ps0zoNw3zBy7V1cIIcxLH9BJIECUyWllmNQKdEZwmtXeADMaUc9g98oSswAuymR5iA3YHtnQsLCaUXsFKkl9+woU5LaHjYpBkYNzUpIwQu7pgwerGYxGNE1NaSJqIZeILGXvMXipZYfYPfDea3yMDFcsVePQrKBNj+WV3fjaQ92HEPFMEJXvocw3pUwmBif9GSDLbCp9aqraSybhEtEkQZreCQxhM0ORSy/KWIk4nXMSESbwREcSmeqK3dxFug7O1WRGY4ywGBijaJoG72qZxk/zTK2DMk+U9RihVzEq1cZdIzD5ELBaMej3yLMMdKAJFT4h00LwbU739Z/ZQeYfX7+bv11KSHNnJK9dOMS7dV4rJF7BdpZJdT2EIDLjUSEChAI9DghVjyFJlKQSkgqggyIkxdILj1thrSXLMmazGUop9u3bx/GH1wlOUH3WWGKcl68iURg22v9+gudFki3ZiHQKRjAqOXudIPuahYVFqupRrLWMx2PyvGA63STLChQaa006P5Ly8lxl2bmaWTmhZcIW59uQR4/RKZMyugs6YinzfHXlaIyhUhEXa6IqQHl0cGgFja+pjKcxsjG3DkonIT2DEoelUo9PyVCsTkOyPrSBg9wPkp0rPBOapoZmTHRTyrpiSg39c/QWdpEVBk2kDo7ZbJPJxpqUrlxCyXYceOJAo1EtbJaORTxlfRaBqgffUoUFKbM/jqS1E+uUtLDrAaPmn8uW8r0MsUdo5TMyuc9i1weQjNw3DdEFslZWRIFAP+R59qnc5yNo7VCmTKw0AR080TVdRaRDpcY5elQCWA2ZFjBW48AHyXxpS6FpnZSirv8S0yK16fGOpYLRopBftkJ4QtWSBuJiSOwQlkFjwA5RWIZ9jV0dMt2sUSaSG0vQGcbnhGhxgO0rBj2N9bKwWim0yiA9IMPCYBf7GCB6KTHG4IUdObPkvZyygtxnZCpL/HhpF4wxzS2l2rmCEDO80qgcCtegyOjnfVArNLUHN5AybpwR6ggMulkRCCnK9hitKJJEeURRO5Fyds5BK0mODN+KDLqWoUOjUVZkMIhIJpbo+rvyUcoQVAtGSNfDu5rMyoCfMYY8E+LUpprh3VzAT7c8X0Ya/ekZFEtAF2M0RMmkQiNZhjWGfk/OSZmICw2zxAe4sTFOPSmFJfXlvBegia/ZnExR5YQsOHwA0yicssI2TsREKRk6wLkZ0KCJRK8ZT6by+ygUDSHMUEQqb5hOZ1Lnp6ZpWnlsQDmiSRP83gMGYzzWeiIGa7JE4pl46RSYlAVLxtnOnyhi9NSVIKAWl5Y47B2zJlA5KJ3HuUDU4A045WXDwpHHGoVHOgkGn9jRdQxEH5iWTjZu72XeKt2XIYizmk4nVFWJUn3OnDlFVZV47xJLSLpoyuNDI7RDqSrgvScEqKpaelGuofY1IXgskm1UwdOEQOMcVd1QliWzsqIsawpjIWhUJSwhEUdjHA2gfYMzHtf2mZBKgIpRHJVS2LRtRwJeCa1Ki+4L3SzQHPsYUTRREVyN8SXKVVSuYVzXNOYco9UxuRcqqFCVVJtTNjen4Dw4L0CM9FkBUa8lOcWWD1O+X3WlY4HLz7P5GJ+gBqDS07HlAWkdE6na0Gb/0XkM8n1pd8TPXCKrpUO3tmtFiAL2SutQRQ+peB9SJiUl9jIx0sgfk2b3WscviXXszqU9XpWUor1rCI3vrk9I7DDSu5LzcMlJPVG584LliH/SO56C9tBDD3H55Zc/2Yexbdu2bdu2bX9GO3LkCBdffPE3fP1pmUmtrq4CcPjwYZaWlp7ko3nybGNjg0suuYQjR46wuLj4ZB/Ok2bb6yC2vQ5i2+sg9lRfhxgj4/GY/fv3/7Hve1o6qbbxvrS09JRc/G+3LS4ubq8D2+vQ2vY6iG2vg9hTeR2+mSRD/4nv2LZt27Zt27Zte5Js20lt27Zt27Zt21PWnpZOqigK3vve91IUxZN9KE+qba+D2PY6iG2vg9j2Ooj9ZVmHpyW6b9u2bdu2bdueGfa0zKS2bdu2bdu27Zlh205q27Zt27Zt256ytu2ktm3btm3btu0pa9tOatu2bdu2bduesva0dFK/8Au/wKWXXkqv1+P666/n85///JN9SH+u9ulPf5o3v/nN7N+/H6UUv/Vbv3XB6zFG/uk//afs27ePfr/PDTfcwP3333/Be86dO8fb3/52FhcXWV5e5p3vfCebm5vfxrP4s9n73vc+XvrSl7KwsMDu3bv5gR/4Ae69994L3lOWJe95z3vYsWMHo9GIt7zlLZw8efKC9xw+fJg3velNDAYDdu/ezT/4B//gm5atfirYL/7iL3Lttdd2A5mHDh3iYx/7WPf6M2ENnsh+/ud/HqUUP/VTP9X92zNhLf7ZP/tnc6mb9Oc5z3lO9/pfyjWITzP7wAc+EPM8j//1v/7XeNddd8V3vetdcXl5OZ48efLJPrQ/N/voRz8a/9E/+kfxN3/zNyMQP/zhD1/w+s///M/HpaWl+Fu/9Vvxy1/+cvy+7/u++KxnPSvOZrPuPW94wxviC17wgnjLLbfEP/zDP4xXXHFFfNvb3vZtPpM/vX3P93xP/KVf+qV45513xjvuuCO+8Y1vjAcOHIibm5vde9797nfHSy65JN58883xi1/8Ynz5y18eX/GKV3SvO+fiNddcE2+44YZ4++23x49+9KNx586d8ed+7ueejFP6U9lv//Zvx4985CPxvvvui/fee2/8h//wH8Ysy+Kdd94ZY3xmrMHj7fOf/3y89NJL47XXXht/8id/svv3Z8JavPe9743Pe97z4vHjx7s/p0+f7l7/y7gGTzsn9bKXvSy+5z3v6f7uvY/79++P73vf+57Eo/qLs8c7qRBC3Lt3b/zX//pfd/+2trYWi6KIv/qrvxpjjPHuu++OQPzCF77QvedjH/tYVErFo0ePftuO/c/TTp06FYH4qU99KsYo55xlWfz1X//17j1f+9rXIhA/97nPxRjF2Wut44kTJ7r3/OIv/mJcXFyMVVV9e0/gz9FWVlbif/7P//kZuQbj8TheeeWV8aabboqvec1rOif1TFmL9773vfEFL3jBE772l3UNnlblvrquue2227jhhhu6f9Nac8MNN/C5z33uSTyyb589/PDDnDhx4oI1WFpa4vrrr+/W4HOf+xzLy8u85CUv6d5zww03oLXm1ltv/bYf85+Hra+vA3Ny4dtuu42maS5Yh+c85zkcOHDggnV4/vOfz549e7r3fM/3fA8bGxvcdddd38aj//Mx7z0f+MAHmEwmHDp06Bm5Bu95z3t405vedME5wzPrfrj//vvZv38/l112GW9/+9s5fPgw8Jd3DZ5WBLNnzpzBe3/BAgPs2bOHe+6550k6qm+vnThxAuAJ16B97cSJE+zevfuC1621rK6udu95OlkIgZ/6qZ/ila98Jddccw0g55jnOcvLyxe89/Hr8ETr1L72dLGvfvWrHDp0iLIsGY1GfPjDH+bqq6/mjjvueMasAcAHPvABvvSlL/GFL3zh6157ptwP119/Pe9///t59rOfzfHjx/nn//yf8x3f8R3ceeedf2nX4GnlpLbtmWnvec97uPPOO/mjP/qjJ/tQnhR79rOfzR133MH6+jq/8Ru/wTve8Q4+9alPPdmH9W21I0eO8JM/+ZPcdNNN9Hq9J/twnjS78cYbu/++9tpruf766zl48CAf/OAH6ff7T+KR/cXZ06rct3PnTowxX4dWOXnyJHv37n2Sjurba+15/nFrsHfvXk6dOnXB6845zp0797Rbp5/4iZ/gd37nd/iDP/iDC4TR9u7dS13XrK2tXfD+x6/DE61T+9rTxfI854orruC6667jfe97Hy94wQv4d//u3z2j1uC2227j1KlTvPjFL+6k5z/1qU/x7//9v8day549e54xa7HVlpeXueqqq3jggQf+0t4PTysnlec51113HTfffHP3byEEbr75Zg4dOvQkHtm3z571rGexd+/eC9ZgY2ODW2+9tVuDQ4cOsba2xm233da95xOf+AQhBK6//vpv+zH/aSzGyE/8xE/w4Q9/mE984hM861nPuuD16667jizLLliHe++9l8OHD1+wDl/96lcvcNg33XQTi4uLXH311d+eE/kLsBACVVU9o9bgda97HV/96le54447uj8veclLePvb39799zNlLbba5uYmDz74IPv27fvLez882ciNb9U+8IEPxKIo4vvf//549913xx/7sR+Ly8vLF6BVnu42Ho/j7bffHm+//fYIxH/zb/5NvP322+Ojjz4aYxQI+vLycvwf/+N/xK985Svx+7//+58Qgv6iF70o3nrrrfGP/uiP4pVXXvm0gqD/+I//eFxaWoqf/OQnL4DbTqfT7j3vfve744EDB+InPvGJ+MUvfjEeOnQoHjp0qHu9hdu+/vWvj3fccUf83d/93bhr166nNNz28fazP/uz8VOf+lR8+OGH41e+8pX4sz/7s1EpFT/+8Y/HGJ8Za/CNbCu6L8Znxlr8zM/8TPzkJz8ZH3744fiZz3wm3nDDDXHnzp3x1KlTMca/nGvwtHNSMcb4H/7Df4gHDhyIeZ7Hl73sZfGWW255sg/pz9X+4A/+IAJf9+cd73hHjFFg6P/kn/yTuGfPnlgURXzd614X77333gs+4+zZs/Ftb3tbHI1GcXFxMf7Nv/k343g8fhLO5k9nT3T+QPylX/ql7j2z2Sz+nb/zd+LKykocDAbxB3/wB+Px48cv+JxHHnkk3njjjbHf78edO3fGn/mZn4lN03ybz+ZPb3/rb/2tePDgwZjnedy1a1d83ete1zmoGJ8Za/CN7PFO6pmwFm9961vjvn37Yp7n8aKLLopvfetb4wMPPNC9/pdxDbalOrZt27Zt27btKWtPq57Utm3btm3btj2zbNtJbdu2bdu2bdtT1rad1LZt27Zt27Y9ZW3bSW3btm3btm3bU9a2ndS2bdu2bdu2PWVt20lt27Zt27Zt21PWtp3Utm3btm3btj1lbdtJbdu2bdu2bdtT1rad1LZt27Zt27Y9ZW3bSW3btm3btm3bU9a2ndS2bdu2bdu2PWVt20lt27Zt27Zt21PW/l/T9I55+Ho3RQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mtcnn.utils.plotting import plot\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.imshow(plot(image, result))" + ] + }, + { + "cell_type": "markdown", + "id": "820648d8-bc52-44c4-9000-12ebef684ffc", + "metadata": {}, + "source": [ + "As can be seen, the RNet is refining proposals by discarding those that do not match the thresholds, and adjusting those that matched." + ] + }, + { + "cell_type": "markdown", + "id": "b2f0227a-4437-4e07-8661-9239ae88988d", + "metadata": {}, + "source": [ + "### Accessing RNet's model\n", + "\n", + "The network can be accessed by instantiating StageRNet and reading the attribute `model`, which is a TensorFlow model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "85692cac-f01a-4e51-812d-6697c4b4eb95", + "metadata": {}, + "outputs": [], + "source": [ + "stage = StageRNet()\n", + "model = stage.model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b5b0d71f-c4f4-4df2-89dd-66091cd3f9fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"r_net_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"r_net_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv1 (Conv2D)                  │ (None, 22, 22, 28)     │           784 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu1 (PReLU)                  │ (None, 22, 22, 28)     │            28 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling1 (MaxPooling2D)      │ (None, 11, 11, 28)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2 (Conv2D)                  │ (None, 9, 9, 48)       │        12,144 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu2 (PReLU)                  │ (None, 9, 9, 48)       │            48 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ maxpooling2 (MaxPooling2D)      │ (None, 4, 4, 48)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv3 (Conv2D)                  │ (None, 3, 3, 64)       │        12,352 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu3 (PReLU)                  │ (None, 3, 3, 64)       │            64 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ permute (Permute)               │ (None, 3, 3, 64)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten3 (Flatten)              │ (None, 576)            │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc4 (Dense)                     │ (None, 128)            │        73,856 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ prelu4 (PReLU)                  │ (None, 128)            │           128 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc5-1 (Dense)                   │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ fc5-2 (Dense)                   │ (None, 2)              │           258 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m784\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu1 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m28\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m28\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m48\u001b[0m) │ \u001b[38;5;34m12,144\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu2 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m9\u001b[0m, \u001b[38;5;34m48\u001b[0m) │ \u001b[38;5;34m48\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ maxpooling2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m48\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m12,352\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu3 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ permute (\u001b[38;5;33mPermute\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten3 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m576\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc4 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ prelu4 (\u001b[38;5;33mPReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc5-1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ fc5-2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m258\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 100,178 (391.32 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m100,178\u001b[0m (391.32 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 100,178 (391.32 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m100,178\u001b[0m (391.32 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "c6719b2c-432a-498e-ada7-c9ea962a93c7", + "metadata": {}, + "source": [ + "### Loading RNet's weights\n", + "\n", + "The model weights are stored within the folder local `mtcnn/assets/weights/` under the filename `rnet.lz4`. It can be loaded with `joblib`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cfe6688e-1bc8-46ad-920a-7c338419e4a2", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "rnet_weights = joblib.load(\"../mtcnn/assets/weights/rnet.lz4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "79400bef-8b41-481a-b375-3179732f8263", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "16" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(rnet_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "27d8782a-4dfd-4bde-8006-51b9124fda9e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(3, 3, 3, 28),\n", + " (28,),\n", + " (1, 1, 28),\n", + " (3, 3, 28, 48),\n", + " (48,),\n", + " (1, 1, 48),\n", + " (2, 2, 48, 64),\n", + " (64,),\n", + " (1, 1, 64),\n", + " (576, 128),\n", + " (128,),\n", + " (128,),\n", + " (128, 4),\n", + " (4,),\n", + " (128, 2),\n", + " (2,)]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[w.shape for w in rnet_weights]" + ] + }, + { + "cell_type": "markdown", + "id": "14a82ac3-d289-4cbb-9cc4-58603dc6c543", + "metadata": {}, + "source": [ + "Further stage ablation can be performed by looking at `mtcnn/stages/stage_rnet.py`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f96a7b5-f738-4b04-afcc-025129b14ca0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (mamba3.11)", + "language": "python", + "name": "mamba3.11" + }, + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/readthedocs.yml b/readthedocs.yml new file mode 100644 index 0000000..d84aa2d --- /dev/null +++ b/readthedocs.yml @@ -0,0 +1,19 @@ +# Read the Docs configuration file for MkDocs projects +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Set the version of Python and other tools you might need +build: + os: ubuntu-22.04 + tools: + python: "3.10" + +mkdocs: + configuration: mkdocs.yml + +# Optionally declare the Python requirements required to build your docs +python: + install: + - requirements: requirements-dev.txt diff --git a/requirements-dev.txt b/requirements-dev.txt new file mode 100644 index 0000000..1c7f65b --- /dev/null +++ b/requirements-dev.txt @@ -0,0 +1,6 @@ +pytest>=8.3.3 +pytest-cov>=5.0.0 +mkdocs>=1.6.1 +mkdocs-material>=9.5.39 +mkdocs-jupyter>=0.25.0 + diff --git a/requirements-tf.txt b/requirements-tf.txt new file mode 100644 index 0000000..3d601c0 --- /dev/null +++ b/requirements-tf.txt @@ -0,0 +1 @@ +tensorflow>=2.12.0 diff --git a/requirements.txt b/requirements.txt index 09d7e0d..5ded03a 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,2 @@ -tensorflow==1.4.1 -opencv-contrib-python==3.2.0.8 - +joblib>=1.4.2 +lz4>=4.3.3 diff --git a/ivan.jpg b/resources/ivan.jpg similarity index 100% rename from ivan.jpg rename to resources/ivan.jpg diff --git a/result.jpg b/resources/result.jpg similarity index 100% rename from result.jpg rename to resources/result.jpg diff --git a/setup.py b/setup.py index 0f909c4..55c5ba5 100644 --- a/setup.py +++ b/setup.py @@ -1,69 +1,77 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- +# MIT LICENSE # -#MIT License +# Copyright (c) 2019-2024 Iván de Paz Centeno # -#Copyright (c) 2018 Iván de Paz Centeno +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: # -#Permission is hereby granted, free of charge, to any person obtaining a copy -#of this software and associated documentation files (the "Software"), to deal -#in the Software without restriction, including without limitation the rights -#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -#copies of the Software, and to permit persons to whom the Software is -#furnished to do so, subject to the following conditions: +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. # -#The above copyright notice and this permission notice shall be included in all -#copies or substantial portions of the Software. -# -#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -#SOFTWARE. - -import sys -from setuptools import setup, setuptools -from mtcnn import __version__ - +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. -__author__ = 'Iván de Paz Centeno' +from setuptools import setup, find_packages -def readme(): - with open('README.rst', encoding="UTF-8") as f: +def read_file(file_name): + with open(file_name, encoding='utf-8') as f: return f.read() - -if sys.version_info < (3, 4, 1): - sys.exit('Python < 3.4.1 is not supported!') - - -setup(name='mtcnn', - version=__version__, - description='Multi-task Cascaded Convolutional Neural Networks for Face Detection, based on TensorFlow', - long_description=readme(), - url='http://github.com/ipazc/mtcnn', - author='Iván de Paz Centeno', - author_email='ipazc@unileon.es', - license='MIT', - packages=setuptools.find_packages(exclude=["tests.*", "tests"]), - install_requires=[ - ], - classifiers=[ - 'Environment :: Console', - 'Intended Audience :: Developers', - 'Intended Audience :: Education', - 'Intended Audience :: Science/Research', - 'Natural Language :: English', - 'Programming Language :: Python :: 3.4', - 'Programming Language :: Python :: 3.5', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', - ], - test_suite='nose.collector', - tests_require=['nose'], - include_package_data=True, - keywords="mtcnn face detection tensorflow pip package", - zip_safe=False) +setup( + name='mtcnn', + version='1.0.0', + description='Multitask Cascaded Convolutional Networks for face detection and alignment (MTCNN) in Python >= 3.10 and TensorFlow >= 2.12', + long_description=read_file('README.md'), + long_description_content_type='text/markdown', + author='Iván de Paz Centeno', + author_email='ipazc@unileon.es', + url='https://github.com/ipazc/mtcnn', + license='MIT', + packages=find_packages(exclude=['tests', 'docs']), + install_requires=[ + 'joblib>=1.4.2', + 'lz4>=4.3.3', + ], + extras_require={ + 'tensorflow': [ + 'tensorflow>=2.12.0' + ], + 'dev': [ + 'pytest>=8.3.3', + 'pytest-cov>=5.0.0', + 'mkdocs>=1.6.1', + 'mkdocs-material>=9.5.39', + 'mkdocs-jupyter>=0.25.0' + ] + }, + classifiers=[ + 'Development Status :: 4 - Beta', + 'Intended Audience :: Developers', + 'Intended Audience :: Science/Research', + 'License :: OSI Approved :: MIT License', + 'Programming Language :: Python :: 3.10', + 'Programming Language :: Python :: 3.11', + 'Programming Language :: Python :: 3.12', + 'Topic :: Scientific/Engineering :: Artificial Intelligence', + ], + python_requires='>=3.10', + include_package_data=True, + package_data={ + 'mtcnn': ['assets/weights/*.lz4'], + }, + project_urls={ + 'Documentation': 'https://github.com/ipazc/mtcnn/docs', + 'Source': 'https://github.com/ipazc/mtcnn', + 'Tracker': 'https://github.com/ipazc/mtcnn/issues', + }, +) diff --git a/tests/__init__.py b/tests/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..57d0d35 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,27 @@ +# MIT LICENSE +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import os +import sys + +# Add the project root folder to the PYTHONPATH for relative opening of test resources +sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) diff --git a/tests/images/ivan.jpg b/tests/images/ivan.jpg new file mode 100644 index 0000000..401e3ba Binary files /dev/null and b/tests/images/ivan.jpg differ diff --git a/no-faces.jpg b/tests/images/no-faces.jpg similarity index 100% rename from no-faces.jpg rename to tests/images/no-faces.jpg diff --git a/tests/images/result.jpg b/tests/images/result.jpg new file mode 100644 index 0000000..96b8e40 Binary files /dev/null and b/tests/images/result.jpg differ diff --git a/tests/test_mtcnn.py b/tests/test_mtcnn.py index 1592dc4..1999699 100644 --- a/tests/test_mtcnn.py +++ b/tests/test_mtcnn.py @@ -1,89 +1,180 @@ -import unittest -import cv2 +# MIT LICENSE +# +# Copyright (c) 2019-2024 Iván de Paz Centeno +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# pylint: disable=duplicate-code +# pylint: disable=redefined-outer-name + +import os +import pytest +import numpy as np -from mtcnn.exceptions import InvalidImage from mtcnn.mtcnn import MTCNN -mtcnn = None - -class TestMTCNN(unittest.TestCase): - - def setUpClass(): - global mtcnn - mtcnn = MTCNN() - - def test_detect_faces(self): - """ - MTCNN is able to detect faces and landmarks on an image - :return: - """ - ivan = cv2.imread("ivan.jpg") - - result = mtcnn.detect_faces(ivan) # type: list - - self.assertEqual(len(result), 1) - - first = result[0] - - self.assertIn('box', first) - self.assertIn('keypoints', first) - self.assertTrue(len(first['box']), 1) - self.assertTrue(len(first['keypoints']), 5) - - keypoints = first['keypoints'] # type: dict - self.assertIn('nose', keypoints) - self.assertIn('mouth_left', keypoints) - self.assertIn('mouth_right', keypoints) - self.assertIn('left_eye', keypoints) - self.assertIn('right_eye', keypoints) - - self.assertEqual(len(keypoints['nose']), 2) - self.assertEqual(len(keypoints['mouth_left']), 2) - self.assertEqual(len(keypoints['mouth_right']), 2) - self.assertEqual(len(keypoints['left_eye']), 2) - self.assertEqual(len(keypoints['right_eye']), 2) - - def test_detect_faces_invalid_content(self): - """ - MTCNN detects invalid images - :return: - """ - ivan = cv2.imread("example.py") - - with self.assertRaises(InvalidImage): - result = mtcnn.detect_faces(ivan) # type: list - - def test_detect_no_faces_on_no_faces_content(self): - """ - MTCNN successfully reports an empty list when no faces are detected. - :return: - """ - ivan = cv2.imread("no-faces.jpg") - - result = mtcnn.detect_faces(ivan) # type: list - self.assertEqual(len(result), 0) - - - def test_mtcnn_multiple_instances(self): - """ - Multiple instances of MTCNN can be created in the same thread. - :return: - """ - detector_1 = MTCNN(steps_threshold=(.2, .7, .7)) - detector_2 = MTCNN(steps_threshold=(.1, .1, .1)) - - ivan = cv2.imread("ivan.jpg") - - faces_1 = detector_1.detect_faces(ivan) - faces_2 = detector_2.detect_faces(ivan) - - self.assertEqual(len(faces_1), 1) - self.assertGreater(len(faces_2), 1) - - def tearDownClass(): - global mtcnn - del mtcnn - -if __name__ == '__main__': - unittest.main() +@pytest.fixture(scope="module") +def mtcnn_detector(): + """Fixture to initialize MTCNN detector once for all tests in this module.""" + return MTCNN() + + +@pytest.fixture +def test_images(): + """Fixture to provide paths and bytes for the test images.""" + current_dir = os.path.dirname(os.path.abspath(__file__)) + images_dir = os.path.join(current_dir, "images") + valid_image_path = os.path.join(images_dir, "ivan.jpg") + no_faces_image_path = os.path.join(images_dir, "no-faces.jpg") + + # Cargar los bytes de las imágenes + with open(valid_image_path, "rb") as f: + valid_image_bytes = f.read() + + with open(no_faces_image_path, "rb") as f: + no_faces_image_bytes = f.read() + + return { + 'valid_image': valid_image_path, + 'no_faces_image': no_faces_image_path, + 'valid_image_bytes': valid_image_bytes, + 'no_faces_image_bytes': no_faces_image_bytes + } + + +def test_detect_faces_from_uri(mtcnn_detector, test_images): + """ + Test MTCNN detects faces and landmarks when given a URI of a valid image. + """ + result = mtcnn_detector.detect_faces(test_images['valid_image']) + + assert isinstance(result, list), "Output should be a list of bounding boxes." + assert len(result) > 0, "Should detect at least one face in the image." + + first = result[0] + assert 'box' in first, "Bounding box not found in detection result." + assert 'keypoints' in first, "Keypoints not found in detection result." + + # Check bounding box in 'xywh' format by default + assert len(first['box']) == 4, "Bounding box should contain 4 coordinates (X1, Y1, width, height)." + + +def test_detect_faces_from_bytes(mtcnn_detector, test_images): + """ + Test MTCNN detects faces and landmarks when given an image as bytes. + """ + result = mtcnn_detector.detect_faces(test_images['valid_image_bytes']) + + assert isinstance(result, list), "Output should be a list of bounding boxes." + assert len(result) > 0, "Should detect at least one face in the image." + + +def test_detect_no_faces(mtcnn_detector, test_images): + """ + Test that MTCNN returns an empty list when no faces are detected in a valid image. + """ + result = mtcnn_detector.detect_faces(test_images['no_faces_image']) + assert isinstance(result, list), "Output should be a list." + assert len(result) == 0, "Should detect no faces in the image." + + +def test_detect_faces_batch_from_uri(mtcnn_detector, test_images): + """ + Test batch detection when passed a list of URIs. + """ + result = mtcnn_detector.detect_faces([test_images['valid_image'], test_images['no_faces_image']]) + + assert isinstance(result, list), "Output should be a list of lists (one for each image)." + assert len(result) == 2, "Should return results for two images." + assert isinstance(result[0], list), "First result should be a list of bounding boxes." + assert len(result[0]) > 0, "First image should detect a face." + assert isinstance(result[1], list), "Second result should be a list of bounding boxes." + assert len(result[1]) == 0, "Second image should detect no faces." + + +def test_detect_faces_batch_from_bytes(mtcnn_detector, test_images): + """ + Test batch detection when passed a list of image byte arrays. + """ + result = mtcnn_detector.detect_faces([test_images['valid_image_bytes'], test_images['no_faces_image_bytes']]) + + assert isinstance(result, list), "Output should be a list of lists (one for each image)." + assert len(result) == 2, "Should return results for two images." + assert isinstance(result[0], list), "First result should be a list of bounding boxes." + assert len(result[0]) > 0, "First image should detect a face." + assert isinstance(result[1], list), "Second result should be a list of bounding boxes." + assert len(result[1]) == 0, "Second image should detect no faces." + + +@pytest.mark.parametrize("output_type, box_format", [ + ("json", "xywh"), + ("json", "xyxy"), + ("numpy", "xywh"), + ("numpy", "xyxy") +]) +def test_detect_faces_output_types_and_formats(mtcnn_detector, test_images, output_type, box_format): + """ + Test MTCNN with all combinations of output_type and box_format. + """ + # Detect faces using the given output_type and box_format + result = mtcnn_detector.detect_faces([test_images['valid_image'], test_images['no_faces_image']], + output_type=output_type, box_format=box_format) + + # General assertions: result should be a list or numpy array depending on output_type + if output_type == "json": + assert isinstance(result, list), "Output should be a list when output_type is 'json'." + assert isinstance(result[0], list), "Each element in the batch should be a list (bounding boxes for each image)." + assert len(result) == 2, "Should return results for two images." + assert len(result[0]) > 0, "First image should detect at least one face." + assert len(result[1]) == 0, "Second image should detect no faces." + + # Check bounding box format based on box_format + first_bbox = result[0][0]['box'] + if box_format == "xywh": + assert len(first_bbox) == 4, "Bounding box should contain 4 values for 'xywh'." + assert first_bbox[2] > 0 and first_bbox[3] > 0, "Width and height should be positive." + elif box_format == "xyxy": + assert len(first_bbox) == 4, "Bounding box should contain 4 values for 'xyxy'." + assert first_bbox[2] > first_bbox[0] and first_bbox[3] > first_bbox[1], \ + "X2 and Y2 should be greater than X1 and Y1 for 'xyxy' format." + + elif output_type == "numpy": + assert isinstance(result, np.ndarray), "Output should be a numpy array when output_type is 'numpy'." + assert result.shape[0] == 2, "First dimension of result should correspond to the number of images in the batch." + assert result[0, 0] == 0, "First index should indicate image 0 for the first bounding box." + assert result[-1, 0] == 0, "Last index should indicate image 0 for the last bounding box, as the second image is invalid." + + # Check bounding box format in numpy based on box_format + first_bbox = result[0, 1:5] # Assuming [image_idx, x1, y1, x2_or_width, y2_or_height] + if box_format == "xywh": + assert first_bbox[2] > 0 and first_bbox[3] > 0, "Width and height should be positive for 'xywh' format." + elif box_format == "xyxy": + assert first_bbox[2] > first_bbox[0] and first_bbox[3] > first_bbox[1], \ + "X2 and Y2 should be greater than X1 and Y1 for 'xyxy' format." + + +def test_invalid_image(mtcnn_detector): + """ + Test that MTCNN raises InvalidImage exception for non-image input. + """ + invalid_input = b"not_an_image" + #with pytest.raises(InvalidImage): + result = mtcnn_detector.detect_faces(invalid_input) + assert len(result) == 0, "There should not be faces detected in an invalid input"