pax_global_header00006660000000000000000000000064146207657040014525gustar00rootroot0000000000000052 comment=3b8efff7a10965453feb95e34dbb12299bedcf57 autoray-0.6.12/000077500000000000000000000000001462076570400132775ustar00rootroot00000000000000autoray-0.6.12/.codecov.yml000066400000000000000000000003071462076570400155220ustar00rootroot00000000000000codecov: require_ci_to_pass: yes coverage: status: project: default: informational: true patch: default: informational: true changes: false comment: off autoray-0.6.12/.gitattributes000066400000000000000000000001671462076570400161760ustar00rootroot00000000000000autoray/_version.py export-subst # make autoray appear as a python project on github *.ipynb linguist-language=Python autoray-0.6.12/.github/000077500000000000000000000000001462076570400146375ustar00rootroot00000000000000autoray-0.6.12/.github/workflows/000077500000000000000000000000001462076570400166745ustar00rootroot00000000000000autoray-0.6.12/.github/workflows/pypi-release.yml000066400000000000000000000052431462076570400220220ustar00rootroot00000000000000name: Build and Upload autoray to PyPI on: release: types: - published push: tags: - 'v*' jobs: build-artifacts: runs-on: ubuntu-latest if: github.repository == 'jcmgray/autoray' steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - uses: actions/setup-python@v5 name: Install Python with: python-version: "3.12" - name: Install dependencies run: | python -m pip install --upgrade pip python -m pip install build twine - name: Build tarball and wheels run: | git clean -xdf git restore -SW . python -m build - name: Check built artifacts run: | python -m twine check --strict dist/* pwd if [ -f dist/autoray-0.0.0.tar.gz ]; then echo "❌ INVALID VERSION NUMBER" exit 1 else echo "✅ Looks good" fi - uses: actions/upload-artifact@v4 with: name: releases path: dist test-built-dist: needs: build-artifacts runs-on: ubuntu-latest steps: - uses: actions/setup-python@v5 name: Install Python with: python-version: "3.12" - uses: actions/download-artifact@v4 with: name: releases path: dist - name: List contents of built dist run: | ls -ltrh ls -ltrh dist - name: Verify the built dist/wheel is valid if: github.event_name == 'push' run: | python -m pip install --upgrade pip python -m pip install dist/autoray*.whl upload-to-test-pypi: needs: test-built-dist if: github.event_name == 'push' runs-on: ubuntu-latest environment: name: pypi url: https://test.pypi.org/p/autoray permissions: id-token: write steps: - uses: actions/download-artifact@v4 with: name: releases path: dist - name: Publish package to TestPyPI if: github.event_name == 'push' uses: pypa/gh-action-pypi-publish@v1.8.14 with: repository-url: https://test.pypi.org/legacy/ verbose: true upload-to-pypi: needs: test-built-dist if: github.event_name == 'release' runs-on: ubuntu-latest environment: name: pypi url: https://pypi.org/p/autoray permissions: id-token: write steps: - uses: actions/download-artifact@v4 with: name: releases path: dist - name: Publish package to PyPI uses: pypa/gh-action-pypi-publish@v1.8.14 with: verbose: trueautoray-0.6.12/.github/workflows/tests.yml000066400000000000000000000023671462076570400205710ustar00rootroot00000000000000name: Tests on: workflow_dispatch: push: pull_request: defaults: run: shell: bash -l {0} jobs: run-tests: runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest] python-version: ['3.8', '3.9', '3.10', '3.11', '3.12'] env: [base] include: - os: macos-latest python-version: '3.11' env: base - os: windows-latest python-version: '3.11' env: base - os: ubuntu-latest python-version: '3.11' env: torch - os: ubuntu-latest python-version: '3.11' env: jax - os: ubuntu-latest python-version: '3.11' env: tensorflow steps: - uses: actions/checkout@v4 - name: Install micromamba uses: mamba-org/setup-micromamba@v1 with: environment-file: ci/requirements/py-${{ matrix.env }}.yml environment-name: test-env create-args: >- python=${{ matrix.python-version }} cache-environment: true - name: Test with pytest run: pytest --cov=autoray tests/ --cov-report=xml tests - name: Report to codecov uses: codecov/codecov-action@v4 with: token: ${{ secrets.CODECOV_TOKEN }} autoray-0.6.12/.gitignore000066400000000000000000000024731462076570400152750ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST _version.py # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ # IDE .vscode/ autoray-0.6.12/.readthedocs.yml000066400000000000000000000002551462076570400163670ustar00rootroot00000000000000version: 2 build: os: "ubuntu-22.04" tools: python: "3.11" python: install: - method: pip path: . extra_requirements: - docs formats: [] autoray-0.6.12/LICENSE000066400000000000000000000264461462076570400143200ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. autoray-0.6.12/MANIFEST.in000066400000000000000000000001011462076570400150250ustar00rootroot00000000000000include README.md include LICENSE include autoray/_version.py autoray-0.6.12/README.md000066400000000000000000000102551462076570400145610ustar00rootroot00000000000000![autoray-header](https://github.com/jcmgray/autoray/assets/8982598/c5cb89bf-cc16-4345-8796-e0bd98dc2a15) [![tests](https://github.com/jcmgray/autoray/actions/workflows/tests.yml/badge.svg)](https://github.com/jcmgray/autoray/actions/workflows/tests.yml) [![codecov](https://codecov.io/gh/jcmgray/autoray/branch/main/graph/badge.svg?token=Q5evNiuT9S)](https://codecov.io/gh/jcmgray/autoray) [![Codacy Badge](https://app.codacy.com/project/badge/Grade/ba896d74c4954dd58da01df30c7bf326)](https://app.codacy.com/gh/jcmgray/autoray/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade) [![Docs](https://readthedocs.org/projects/autoray/badge/?version=latest)](https://autoray.readthedocs.io) [![PyPI](https://img.shields.io/pypi/v/autoray?color=teal)](https://pypi.org/project/autoray/) [![Anaconda-Server Badge](https://anaconda.org/conda-forge/autoray/badges/version.svg)](https://anaconda.org/conda-forge/autoray) [`autoray`](https://autoray.readthedocs.io/en/latest) is a lightweight python AUTOmatic-arRAY library for abstracting your tensor operations. Primarily it provides an [*automatic* dispatch mechanism](https://autoray.readthedocs.io/en/latest/automatic_dispatch.html#) that means you can write backend agnostic code that works for: * [numpy](https://github.com/numpy/numpy) * [pytorch](https://pytorch.org/) * [jax](https://github.com/google/jax) * [cupy](https://github.com/cupy/cupy) * [dask](https://github.com/dask/dask) * [autograd](https://github.com/HIPS/autograd) * [tensorflow](https://github.com/tensorflow/tensorflow) * [sparse](https://sparse.pydata.org/) * [mars](https://github.com/mars-project/mars) * ... and indeed **any** library that provides a numpy-*ish* api, even if it knows nothing about `autoray`. Beyond that, abstracting the array interface allows you to: * *swap [custom versions of functions](https://autoray.readthedocs.io/en/latest/automatic_dispatch.html#functions) for specific backends* * *trace through computations [lazily](https://autoray.readthedocs.io/en/latest/lazy_computation.html) without actually running them* * *automatically [share intermediates and fold constants](https://autoray.readthedocs.io/en/latest/lazy_computation.html#sharing-intermediates) in computations* * *compile functions with a [unified interface](https://autoray.readthedocs.io/en/latest/compilation.html) for different backends* ## Basic usage The main function of `autoray` is [`do`](https://autoray.readthedocs.io/en/latest/autoapi/autoray/autoray/index.html#autoray.autoray.do), which takes a function name followed by `*args` and `**kwargs`, and automatically looks up (and caches) the correct function to match the equivalent numpy call: ```python from autoray as ar def noised_svd(x): # automatic dispatch based on supplied array U, s, VH = ar.do('linalg.svd', x) # automatic dispatch based on different array sn = s + 0.1 * ar.do('random.normal', size=ar.shape(s), like=s) # automatic dispatch for multiple arrays for certain functions return ar.do('einsum', 'ij,j,jk->ik', U, sn, VH) # explicit backend given by string x = ar.do('random.uniform', size=(100, 100), like="torch") # this function now works for any backend y = noised_svd(x) # explicit inference of backend from array ar.infer_backend(y) # 'torch' ``` If you don't like the explicit `do` syntax, or simply want a drop-in replacement for existing code, you can also import the `autoray.numpy` module: ```python from autoray import numpy as np # set a temporary default backend with ar.backend_like('cupy'): z = np.ones((3, 4), dtype='float32') np.exp(z) # array([[2.7182817, 2.7182817, 2.7182817, 2.7182817], # [2.7182817, 2.7182817, 2.7182817, 2.7182817], # [2.7182817, 2.7182817, 2.7182817, 2.7182817]], dtype=float32) ``` Custom backends and functions can be dynamically registered with: * [`register_backend`](https://autoray.readthedocs.io/en/latest/autoapi/autoray/autoray/index.html#autoray.autoray.register_backend) * [`register_function`](https://autoray.readthedocs.io/en/latest/autoapi/autoray/autoray/index.html#autoray.autoray.register_function) The main documentation is available at [autoray.readthedocs.io](https://autoray.readthedocs.io/en/latest/). autoray-0.6.12/autoray/000077500000000000000000000000001462076570400147635ustar00rootroot00000000000000autoray-0.6.12/autoray/__init__.py000066400000000000000000000037161462076570400171030ustar00rootroot00000000000000try: # -- Distribution mode -- # import from _version.py generated by setuptools_scm during release from ._version import version as __version__ except ImportError: # -- Source mode -- try: # use setuptools_scm to get the current version from src using git from setuptools_scm import get_version as _gv from pathlib import Path as _Path __version__ = _gv(_Path(__file__).parent.parent) except ImportError: # setuptools_scm is not available, use a default version __version__ = "0.0.0+unknown" from .autoray import ( do, get_backend, set_backend, backend_like, infer_backend, infer_backend_multi, get_lib_fn, shape, ndim, size, conj, transpose, dag, real, imag, reshape, to_backend_dtype, astype, get_dtype_name, get_common_dtype, to_numpy, register_backend, register_function, # tree utilities is_array, tree_map, tree_iter, tree_apply, tree_flatten, tree_unflatten, compose, # the numpy mimic submodule numpy, ) from .compiler import autojit from . import lazy # useful constants from math import ( e, pi, inf, nan, ) __all__ = ( "do", "get_backend", "set_backend", "backend_like", "infer_backend", "infer_backend_multi", "get_lib_fn", "shape", "ndim", "size", "conj", "transpose", "dag", "real", "imag", "reshape", "to_backend_dtype", "get_dtype_name", "get_common_dtype", "astype", "to_numpy", "register_backend", "register_function", # tree utilities "is_array", "tree_map", "tree_iter", "tree_apply", "tree_flatten", "tree_unflatten", "compose", # the numpy mimic submodule "numpy", # abstract function compilation "autojit", # lazy array library "lazy", # math constants, "e", "pi", "inf", "nan", ) autoray-0.6.12/autoray/autoray.py000066400000000000000000002000771462076570400170270ustar00rootroot00000000000000""" AUTORAY - backend agnostic array operations. Copyright 2019-2023 Johnnie Gray Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import contextlib import functools import importlib import itertools import math import threading from collections import OrderedDict, defaultdict from inspect import signature def do(fn, *args, like=None, **kwargs): """Do function named ``fn`` on ``(*args, **kwargs)``, peforming single dispatch to retrieve ``fn`` based on whichever library defines the class of the ``args[0]``, or the ``like`` keyword argument if specified. Examples -------- Works on numpy arrays: >>> import numpy as np >>> x_np = np.random.uniform(size=[5]) >>> y_np = do('sqrt', x_np) >>> y_np array([0.32464973, 0.90379787, 0.85037325, 0.88729814, 0.46768083]) >>> type(y_np) numpy.ndarray Works on cupy arrays: >>> import cupy as cp >>> x_cp = cp.random.uniform(size=[5]) >>> y_cp = do('sqrt', x_cp) >>> y_cp array([0.44541656, 0.88713113, 0.92626237, 0.64080557, 0.69620767]) >>> type(y_cp) cupy.core.core.ndarray Works on tensorflow arrays: >>> import tensorflow as tf >>> x_tf = tf.random.uniform(shape=[5]) >>> y_tf = do('sqrt', x_tf) >>> y_tf >>> type(y_tf) tensorflow.python.framework.ops.Tensor You get the idea. For functions that don't dispatch on the first argument you can use the ``like`` keyword: >>> do('eye', 3, like=x_tf) """ backend = _choose_backend(fn, args, kwargs, like=like) func = get_lib_fn(backend, fn) return func(*args, **kwargs) # ------------------------- efficiently dispatching ------------------------- # def _default_infer_from_sig(fn, *args, **kwargs): """This is the default backend dispatcher, used if no global backend has been set. Hot swapping this function out as below avoids having to check manually for a global backend or worse, a thread aware global backend, on every call to ``do``. """ return _DISPATCHERS[fn](*args, **kwargs) _global_backend = None _inferrer_global = _default_infer_from_sig # this is the function that autoray uses when `do` is called without an # explicit like/backend argument. It is set to `_default_infer_from_sig` by # default, but can be set to `_always_the_same` if a global backend is set e.g. _infer_auto = _inferrer_global # if a thread that isn't the 'importing' thread tries to set a backend, this # by default turns on thread aware dispatching, but once such custom sub # backends have been reset, the global values above are used again. _global_backends_threadaware = {} _inferrers_threadaware = {} _importing_thrid = threading.get_ident() _backend_lock = threading.Lock() def _default_infer_from_sig_threadaware(fn, args, kwargs): # check for a thread aware inferrer, default to the global inferrer thrid = threading.get_ident() return _inferrers_threadaware.get(thrid, _inferrer_global)( fn, args, kwargs ) def _always_the_same(fn, args, kwargs, backend): return backend def get_backend(get_globally="auto"): """Return the universally set backend, if any. Parameters ---------- get_globally : {"auto", False, True}, optional Which backend to return: - True: return the globally set backend, if any. - False: return the backend set for the current thread, if any. - "auto": return the globally set backend, if this thread is the thread that imported autoray. Otherwise return the backend set for the current thread, if any. Returns ------- backend : str or None The name of the backend, or None if no backend is set. """ if get_globally == "auto": get_globally = threading.get_ident() == _importing_thrid if get_globally: backend = _global_backend else: thrid = threading.get_ident() backend = _global_backends_threadaware.get(thrid, None) return backend def set_backend(like, set_globally="auto"): """Set a default global backend. The argument ``like`` can be an explicit backend name or an ``array``. Parameters ---------- like : str or array The backend to set. If an array, the backend of the array's class will be set. set_globally : {"auto", False, True}, optional Whether to set the backend globally or for the current thread: - True: set the backend globally. - False: set the backend for the current thread. - "auto": set the backend globally if this thread is the thread that imported autoray. Otherwise set the backend for the current thread. Only one thread should ever call this function with ``set_globally=True``, (by default this is importing thread). """ global _global_backend global _infer_auto global _inferrer_global if like is None: backend = None inferrer = _default_infer_from_sig elif isinstance(like, str): backend = like inferrer = functools.partial(_always_the_same, backend=backend) else: backend = infer_backend(like) inferrer = functools.partial(_always_the_same, backend=backend) if set_globally == "auto": set_globally = threading.get_ident() == _importing_thrid if set_globally: _global_backend = backend _inferrer_global = inferrer if not _inferrers_threadaware: # only revert the actual function if no subthread backends set _infer_auto = inferrer else: thrid = threading.get_ident() _backend_lock.acquire() if backend is None: _global_backends_threadaware.pop(thrid) _inferrers_threadaware.pop(thrid) else: _global_backends_threadaware[thrid] = backend _inferrers_threadaware[thrid] = inferrer if _inferrers_threadaware: # a subthread backend has been set, so we need to be thread aware _infer_auto = _default_infer_from_sig_threadaware else: # no subthread backend has been set anymore, so we can ignore # threads and just use the global inferrer _infer_auto = _inferrer_global _backend_lock.release() @contextlib.contextmanager def backend_like(like, set_globally="auto"): """Context manager for setting a default backend. The argument ``like`` can be an explicit backend name or an ``array`` to infer it from. Parameters ---------- like : str or array The backend to set. If an array, the backend of the array's class will be set. set_globally : {"auto", False, True}, optional Whether to set the backend globally or for the current thread: - True: set the backend globally. - False: set the backend for the current thread. - "auto": set the backend globally if this thread is the thread that imported autoray. Otherwise set the backend for the current thread. Only one thread should ever call this function with ``set_globally=True``, (by default this is importing thread). """ if set_globally == "auto": set_globally = threading.get_ident() == _importing_thrid old_backend = get_backend(get_globally=set_globally) try: set_backend(like, set_globally) yield finally: set_backend(old_backend, set_globally) _CUSTOM_BACKENDS = {} def register_backend(cls, name): """Register the name (and by default the module or submodule) of a custom array class. Parameters ---------- cls : type The array class itself. name : str The name of the backend that should be used for this class. By default this wil be assumed to be the location of the relevant functions for this class, but this can be overridden. """ if not isinstance(cls, type): raise TypeError("The array class itself should be supplied.") global _CUSTOM_BACKENDS _CUSTOM_BACKENDS[cls] = name @functools.lru_cache(None) def _infer_class_backend_cached(cls): try: import numpy as _numpy if issubclass(cls, _numpy.ndarray): return "numpy" except ImportError: # numpy not installed pass if cls in _CUSTOM_BACKENDS: return _CUSTOM_BACKENDS[cls] lib = cls.__module__.split(".")[0] # check if lib should mapped entirely to another lib backend = _BACKEND_ALIASES.get(lib, lib) return backend def infer_backend(array): """Get the name of the library that defined the class of ``array`` - unless ``array`` is directly a subclass of ``numpy.ndarray``, in which case assume ``numpy`` is the desired backend. """ return _infer_class_backend_cached(array.__class__) multi_class_priorities = { "builtins": -2, "numpy": -1, "autoray.lazy": 1, } @functools.lru_cache(None) def _infer_class_backend_multi_cached(classes): return max( map(_infer_class_backend_cached, classes), key=lambda n: multi_class_priorities.get(n, 0), ) def infer_backend_multi(*arrays): """Infer which backend should be used for a function that takes multiple arguments. This assigns a priority to each backend, and returns the backend with the highest priority. By default, the priority is: - ``builtins``: -2 - ``numpy``: -1 - other backends: 0 - ``autoray.lazy``: 1 I.e. when mixing with ``numpy``, other array libraries are preferred, when mixing with ``autoray.lazy``, ``autoray.lazy`` is preferred. This has quite low overhead due to caching. """ return _infer_class_backend_multi_cached( tuple(array.__class__ for array in arrays) ) # the set of functions that create new arrays, with `dtype` and possibly # `device` kwargs, that should be inferred from the like argument _CREATION_ROUTINES = { "empty", "eye", "full", "identity", "ones", "zeros", # TODO: should these be included? # "arange", # "geomspace", # "linspace", # "logspace", } # cache for whether backends have a device attribute _CREATION_INJECT = {} def register_creation_routine( backend, fn, inject_dtype=True, inject_device=False ): """Register a function that creates a new array, with `dtype` and possibly `device` kwargs, that should be inferred from the like argument. This is not necessary for array creation routines that don't accept either. Parameters ---------- backend : str The backend to register the function for. fn : str The name of the function to register. inject_dtype : bool, optional Whether to inject a `dtype` argument based on the `like` argument. inject_device : bool, optional Whether to inject a `device` argument based on the `like` argument. """ _CREATION_INJECT[backend, fn] = (inject_dtype, inject_device) def _maybe_inject_dtype_device(backend, fn, args, kwargs, like): try: inject_dtype, inject_device = _CREATION_INJECT[backend, fn] except KeyError: # default to just dtype (e.g. for numpy) inject_dtype = True inject_device = False _CREATION_INJECT[backend, fn] = (inject_dtype, inject_device) if inject_dtype: kwargs.setdefault("dtype", getattr(like, "dtype", type(like))) if inject_device: kwargs.setdefault("device", like.device) def _choose_backend(fn, args, kwargs, like=None): """Private function to choose a backend based on function name and signature, which passes args and kwargs by reference for performance and also to allow injection of dtype and device arguments for array creation routines. """ if like is None: # infer from function call (or global backend) return _infer_auto(fn, args, kwargs) elif isinstance(like, str): # explicit backend return like else: # explicit example array backend = infer_backend(like) # check if we should set some extra defaults based on the example array if fn in _CREATION_ROUTINES: _maybe_inject_dtype_device(backend, fn, args, kwargs, like) return backend def choose_backend(fn, *args, like=None, **kwargs): """Choose a backend based on function name, arguments, and the ``like`` keyword argument. The default, if ``like`` is not specified, is to infer the backend from the function call, the default of which is simply to use the first argument, if no custom dispatcher is found. Otherwise the backend is chosen based on the ``like`` argument - which can be an explicit backend name or an arbitrary object. """ return _choose_backend(fn, args, kwargs, like=like) # ------------------- importing and caching the function -------------------- # # lookup for mapping entire lib to another _BACKEND_ALIASES = {} # global (non function specific) aliases _MODULE_ALIASES = {} # lookup for when functions are elsewhere than the expected location _SUBMODULE_ALIASES = {} # lookup for when functions are simply called something else _FUNC_ALIASES = {} # custom wrappers for when functions don't just have different location or # name. For example, when kwargs need to be translated or results modified _CUSTOM_WRAPPERS = {} # actual cache of funtions to use - this is populated lazily and can be used # to directly set an implementation of a function for a specific backend _FUNCS = {} # these are functions where a default implementation can be constructed # (composed of other functions), but this is only done lazily _COMPOSED_FUNCTION_GENERATORS = {} def import_lib_fn(backend, fn): # first check explicitly composed functions -> if the function hasn't been # called directly yet, it won't have been loaded into the cache, and needs # generating before e.g. the ``do`` verrsion will work if fn in _COMPOSED_FUNCTION_GENERATORS: return _COMPOSED_FUNCTION_GENERATORS[fn](backend) try: # submodule where function is found for backend, # e.g. ['tensorflow', trace'] -> 'tensorflow.linalg' try: full_location = _SUBMODULE_ALIASES[backend, fn] # if explicit submodule alias given, don't use prepended location # for example, ('torch', 'linalg.svd') -> torch.svd only_fn = fn.split(".")[-1] except KeyError: full_location = backend # move any prepended location into the full module path # e.g. 'fn=linalg.eigh' -> ['linalg', 'eigh'] split_fn = fn.split(".") full_location = ".".join([full_location] + split_fn[:-1]) only_fn = split_fn[-1] # try aliases for global (not function specific) modules and # submodules: # e.g. 'decimal' -> 'math' # e.g. 'cupy.scipy' -> 'cupyx.scipy' # we don't do this if the function location has been explicitly # give in _SUBMODULE_ALIASES, as that is already a full path for k, v in _MODULE_ALIASES.items(): if full_location[: len(k)] == k: full_location = full_location.replace(k, v, 1) break # cached lookup of custom name function might take # e.g. ['tensorflow', 'sum'] -> 'reduce_sum' fn_name = _FUNC_ALIASES.get((backend, fn), only_fn) # import the function into the cache try: lib = importlib.import_module(full_location) except ImportError: if "." in full_location: # sometimes libraries hack an attribute to look like submodule mod, *submods = full_location.split(".") lib = importlib.import_module(mod) # also need to handle nested submodules for submod in submods: lib = getattr(lib, submod) else: # failed to import library at all -> catch + raise ImportError raise AttributeError # check for a custom wrapper but default to identity wrapper = _CUSTOM_WRAPPERS.get((backend, fn), lambda fn: fn) # store the function! lib_fn = _FUNCS[backend, fn] = wrapper(getattr(lib, fn_name)) except AttributeError: # check if there is a backup function (e.g. for older library version) backend_alt = backend + "[alt]" if backend_alt in _MODULE_ALIASES: return import_lib_fn(backend_alt, fn) raise ImportError( f"autoray couldn't find function '{fn}' for " f"backend '{backend.replace('[alt]', '')}'." ) return lib_fn def get_lib_fn(backend, fn): """Cached retrieval of correct function for backend, all the logic for finding the correct funtion only runs the first time. Parameters ---------- backend : str The module defining the array class to dispatch on. fn : str The function to retrieve. Returns ------- callable """ try: lib_fn = _FUNCS[backend, fn] except KeyError: lib_fn = import_lib_fn(backend, fn) return lib_fn # --------------------------- register your own! ---------------------------- # def register_function(backend, name, fn, wrap=False): """Directly provide your own function. Parameters ---------- backend : str The name of the backend to register the function for. name : str Name of the function, e.g. `'sum'` or `'linalg.svd'`. fn : callable The function to register. wrap : bool, optional Whether to wrap the old function like ``fn(old_fn)`` rather than directly supply the entire new function. """ if wrap: old = get_lib_fn(backend, name) _FUNCS[backend, name] = fn(old) else: _FUNCS[backend, name] = fn # ------------------------------- tree utils -------------------------------- # TREE_MAP_REGISTRY = {} TREE_APPLY_REGISTRY = {} TREE_ITER_REGISTRY = {} def tree_register_container(cls, mapper, iterator, applier): """Register a new container type for use with ``tree_map`` and ``tree_apply``. Parameters ---------- cls : type The container type to register. mapper : callable A function that takes ``f``, ``tree`` and ``is_leaf`` and returns a new tree of type ``cls`` with ``f`` applied to all leaves. applier : callable A function that takes ``f``, ``tree`` and ``is_leaf`` and applies ``f`` to all leaves in ``tree``. """ TREE_MAP_REGISTRY[cls] = mapper TREE_ITER_REGISTRY[cls] = iterator TREE_APPLY_REGISTRY[cls] = applier IS_CONTAINER_CACHE = {} def is_not_container(x): """The default function to determine if an object is a leaf. This simply checks if the object is an instance of any of the registered container types. """ try: return IS_CONTAINER_CACHE[x.__class__] except KeyError: isleaf = not any(isinstance(x, cls) for cls in TREE_MAP_REGISTRY) IS_CONTAINER_CACHE[x.__class__] = isleaf return isleaf def is_array(x): """An alternative leaf tester for addressing only arrays within trees.""" return hasattr(x, "shape") def identity(f, tree, is_leaf): return tree TREE_MAPPER_CACHE = {} def tree_map(f, tree, is_leaf=is_not_container): """Map ``f`` over all leaves in ``tree``, returning a new pytree. Parameters ---------- f : callable A function to apply to all leaves in ``tree``. tree : pytree A nested sequence of tuples, lists, dicts and other objects. is_leaf : callable A function to determine if an object is a leaf, ``f`` is only applied to objects for which ``is_leaf(x)`` returns ``True``. Returns ------- pytree """ if is_leaf(tree): return f(tree) try: return TREE_MAPPER_CACHE[tree.__class__](f, tree, is_leaf) except KeyError: # reverse so later registered classes take precedence for cls, mapper in reversed(TREE_MAP_REGISTRY.items()): if isinstance(tree, cls): break else: # neither leaf nor container -> simply return it mapper = identity TREE_MAPPER_CACHE[tree.__class__] = mapper return mapper(f, tree, is_leaf) def empty(tree, is_leaf): return iter(()) TREE_ITER_CACHE = {} def tree_iter(tree, is_leaf=is_not_container): """Iterate over all leaves in ``tree``. Parameters ---------- f : callable A function to apply to all leaves in ``tree``. tree : pytree A nested sequence of tuples, lists, dicts and other objects. is_leaf : callable A function to determine if an object is a leaf, ``f`` is only applied to objects for which ``is_leaf(x)`` returns ``True``. """ if is_leaf(tree): yield tree return try: yield from TREE_ITER_CACHE[tree.__class__](tree, is_leaf) except KeyError: # reverse so later registered classes take precedence for cls, iterator in reversed(TREE_ITER_REGISTRY.items()): if isinstance(tree, cls): break else: # neither leaf nor container -> simply ignore it iterator = empty TREE_ITER_CACHE[tree.__class__] = iterator yield from iterator(tree, is_leaf) def nothing(f, tree, is_leaf): pass TREE_APPLIER_CACHE = {} def tree_apply(f, tree, is_leaf=is_not_container): """Apply ``f`` to all leaves in ``tree``, no new pytree is built. Parameters ---------- f : callable A function to apply to all leaves in ``tree``. tree : pytree A nested sequence of tuples, lists, dicts and other objects. is_leaf : callable A function to determine if an object is a leaf, ``f`` is only applied to objects for which ``is_leaf(x)`` returns ``True``. """ if is_leaf(tree): f(tree) return try: TREE_APPLIER_CACHE[tree.__class__](f, tree, is_leaf) except KeyError: # reverse so later registered classes take precedence for cls, applier in reversed(TREE_APPLY_REGISTRY.items()): if isinstance(tree, cls): break else: # neither leaf nor container -> simply ignore it applier = nothing TREE_APPLIER_CACHE[tree.__class__] = applier applier(f, tree, is_leaf) class Leaf: """A singleton object to use as a placeholder in a pytree, for unflattening. """ __slots__ = () def __repr__(self): return "Leaf" LEAF = Leaf() def is_leaf_placeholder(x): # don't do `x is LEAF` to allow pickling / unpickling return x.__class__ is Leaf def tree_flatten(tree, is_leaf=is_not_container, get_ref=False): """Flatten ``tree`` into a list of leaves. Parameters ---------- tree : pytree A nested sequence of tuples, lists, dicts and other objects. is_leaf : callable A function to determine if an object is a leaf, only objects for which ``is_leaf(x)`` returns ``True`` are returned in the flattened list. get_ref : bool If ``True``, a reference tree is also returned which can be used to reconstruct the original tree from a flattened list. Returns ------- objs : list The flattened list of leaf objects. (ref_tree) : pytree If ``get_ref`` is ``True``, a reference tree, with leaves of ``Leaf``, is returned which can be used to reconstruct the original tree. """ objs = [] if get_ref: # return a new tree with Leaf leaves, as well as the flattened list def f(x): objs.append(x) return LEAF ref_tree = tree_map(f, tree, is_leaf) return objs, ref_tree else: tree_apply(objs.append, tree, is_leaf) return objs def tree_unflatten(objs, tree, is_leaf=is_leaf_placeholder): """Unflatten ``objs`` into a pytree of the same structure as ``tree``. Parameters ---------- objs : sequence A sequence of objects to be unflattened into a pytree. tree : pytree A nested sequence of tuples, lists, dicts and other objects, the objs will be inserted into a new pytree of the same structure. is_leaf : callable A function to determine if an object is a leaf, only objects for which ``is_leaf(x)`` returns ``True`` will have the next item from ``objs`` inserted. By default checks for the ``Leaf`` object inserted by ``tree_flatten(..., get_ref=True)``. Returns ------- pytree """ objs = iter(objs) return tree_map(lambda _: next(objs), tree, is_leaf) def tree_map_tuple(f, tree, is_leaf): return tuple(tree_map(f, x, is_leaf) for x in tree) def tree_iter_tuple(tree, is_leaf): for x in tree: yield from tree_iter(x, is_leaf) def tree_apply_tuple(f, tree, is_leaf): for x in tree: tree_apply(f, x, is_leaf) tree_register_container( tuple, tree_map_tuple, tree_iter_tuple, tree_apply_tuple ) def tree_map_list(f, tree, is_leaf): return [tree_map(f, x, is_leaf) for x in tree] def tree_iter_list(tree, is_leaf): for x in tree: yield from tree_iter(x, is_leaf) def tree_apply_list(f, tree, is_leaf): for x in tree: tree_apply(f, x, is_leaf) tree_register_container(list, tree_map_list, tree_iter_list, tree_apply_list) def tree_map_dict(f, tree, is_leaf): return {k: tree_map(f, v, is_leaf) for k, v in tree.items()} def tree_iter_dict(tree, is_leaf): for v in tree.values(): yield from tree_iter(v, is_leaf) def tree_apply_dict(f, tree, is_leaf): for v in tree.values(): tree_apply(f, v, is_leaf) tree_register_container(dict, tree_map_dict, tree_iter_dict, tree_apply_dict) # --------------------------- composed functions ---------------------------- # class Composed: """Compose an ``autoray.do`` using function. See the main wrapper ``compose``. """ def __init__(self, fn, name=None): self._default_fn = fn if name is None: name = fn.__name__ self._name = name self._supply_backend = "backend" in signature(fn).parameters # this registers the fact that when `get_lib_fn` is called, the # function can be created even if it doesn't exist for a specific # backend yet. _COMPOSED_FUNCTION_GENERATORS[self._name] = self.make_function def register(self, backend, fn=None): """Register a different implementation for ``backend``.""" if fn is not None: register_function(backend, self._name, fn) else: # wrapper form def wrapper(fn): register_function(backend, self._name, fn) return fn return wrapper def make_function(self, backend): """Make a new function for the specific ``backend``.""" if self._supply_backend: # make sure it inherits __name__ etc fn = functools.wraps(self._default_fn)( functools.partial(self._default_fn, backend=backend) ) else: fn = self._default_fn self.register(backend, fn) return fn def __call__(self, *args, like=None, **kwargs): backend = _choose_backend(self._name, args, kwargs, like=like) # `get_lib_fn` will call `make_function` if the function doesn't exist fn = get_lib_fn(backend, self._name) return fn(*args, **kwargs) def __repr__(self): return f"Composed('{self._name}')" def compose(fn, *, name=None): """Take a function consisting of multiple ``autoray.do`` calls and compose it into a new, single, named function, registered with ``autoray.do``. This creates a default implementation of this function for each new backend encountered without explicitly having to write each out, but also allows for specific implementations to be overridden for specific backends. If the function takes a ``backend`` argument, it will be supplied with the backend name, to save having to re-choose the backend. Specific implementations can be provided by calling the ``register`` method of the composed function, or it can itself be used like a decorator:: @compose def foo(x): ... @foo.register("numpy") @numba.njit def foo_numba(x): ... Parameters ---------- fn : callable The funtion to compose, and its default implementation. name : str, optional The name of the composed function. If not provided, the name of the function will be used. """ if fn is None: return functools.partial(compose, name=name) return functools.wraps(fn)(Composed(fn, name)) # ---------------------- special top level functions ------------------------ # @compose def shape(x): """Get the shape of an array as a tuple of int. This should be preferred to calling `x.shape` directly, as it: 1. Allows customization (e.g. for torch and aesara which return different types for shape - use `@shape.register(backend)` to customize the behavior from this default implementation). 2. Can be used on nested lists and tuples, without calling numpy. Parameters ---------- x : array_like The array to get the shape of. It can be an arbitrary nested list or tuple of arrays and scalars, but is assumed not to be ragged. Returns ------- shape : tuple of int The size of each dimension of the array. """ try: return x.shape except AttributeError: # want to handle builtins / nested stuff if isinstance(x, (list, tuple)): d = len(x) if d != 0: # NB: slightly different from np.shape, as we do not check for # ragged arrays, but that behavior is seemingly deprecated return (d,) + shape(x[0]) return (d,) return () @compose def ndim(x): """Get the number of dimensions of an array. This should be preferred to calling `x.ndim`, since not all backends implement that, and it can also be called on nested lists and tuples. Parameters ---------- x : array_like The array to get the number of dimensions of. It can be an arbitrary nested list or tuple of arrays and scalars. Returns ------- ndim : int """ try: return x.ndim except AttributeError: return len(shape(x)) @compose def size(x): """Get the size, or number of elements, of an array. This should be preferred to calling `x.size`, since not all backends implement that, and it can also be called on nested lists and tuples. Parameters ---------- x : array_like The array to get the size of. It can be an arbitrary nested list or tuple of arrays and scalars. Returns ------- size : int """ try: return x.size except AttributeError: return math.prod(shape(x)) def conj(x): """Array conjugate.""" return do("conj", x) def transpose(x, *args): """Array transpose.""" return do("transpose", x, *args) def dag(x): """Array Hermitian transpose.""" try: return x.H except AttributeError: return do("conj", do("transpose", x)) def real(x): """Array real part.""" return do("real", x) def imag(x): """Array imaginary part.""" return do("imag", x) def reshape(x, shape): """Array reshaped.""" try: return x.reshape(shape) except AttributeError: return do("reshape", x, shape) def to_backend_dtype(dtype_name, like): """Turn string specifier ``dtype_name`` into dtype of backend ``like``.""" if not isinstance(like, str): like = infer_backend(like) try: return get_lib_fn(like, dtype_name) except ImportError: return dtype_name def get_dtype_name(x): """Find string specifier ``dtype_name`` of array ``x``.""" try: return x.dtype.name except AttributeError: # let modules provide their own return do("get_dtype_name", x, like=x) _COMPLEX_DTYPES = {"complex64", "complex128"} _DOUBLE_DTYPES = {"float64", "complex128"} _DTYPE_MAP = { (False, False): "float32", (False, True): "float64", (True, False): "complex64", (True, True): "complex128", } def get_common_dtype(*arrays): """Compute the minimal dtype sufficient for ``arrays``.""" dtypes = set(map(get_dtype_name, arrays)) has_complex = not _COMPLEX_DTYPES.isdisjoint(dtypes) has_double = not _DOUBLE_DTYPES.isdisjoint(dtypes) return _DTYPE_MAP[has_complex, has_double] def astype(x, dtype_name, **kwargs): """Cast array as type ``dtype_name`` - tries ``x.astype`` first.""" dtype = to_backend_dtype(dtype_name, like=x) try: return x.astype(dtype, **kwargs) except AttributeError: return do("astype", x, dtype, **kwargs) def to_numpy(x): """Get a numpy version of array ``x``.""" return do("to_numpy", x) # -------------------------- some common wrappers --------------------------- # def svd_not_full_matrices_wrapper(fn): @functools.wraps(fn) def default_not_full_matrices(*args, **kwargs): kwargs.setdefault("full_matrices", False) return fn(*args, **kwargs) return default_not_full_matrices def svd_sUV_to_UsVH_wrapper(fn): @functools.wraps(fn) def numpy_like(*args, **kwargs): s, U, V = fn(*args, **kwargs) return U, s, dag(V) return numpy_like def svd_UsV_to_UsVH_wrapper(fn): @functools.wraps(fn) def numpy_like(*args, **kwargs): U, s, V = fn(*args, **kwargs) return U, s, dag(V) return numpy_like def svd_manual_full_matrices_kwarg(fn): @functools.wraps(fn) def numpy_like(*args, full_matrices=False, **kwargs): U, s, VH = fn(*args, **kwargs) if not full_matrices: U, VH = U[:, : s.size], VH[: s.size, :] return U, s, VH return numpy_like def qr_allow_fat(fn): @functools.wraps(fn) def numpy_like(a, **kwargs): m, n = shape(a) if m >= n: # square or thin return fn(a, **kwargs) Q, R_sq = fn(a[:, :m]) R_r = dag(Q) @ a[:, m:] R = do("concatenate", (R_sq, R_r), axis=1, like=a) return Q, R return numpy_like def tril_to_band_part(fn): @functools.wraps(fn) def numpy_like(x, k=0): if k < 0: raise ValueError( "'k' must be positive to recreate 'numpy.tril' " "behaviour with 'tensorflow.matrix_band_part'." ) return fn(x, -1, k) return numpy_like def triu_to_band_part(fn): @functools.wraps(fn) def numpy_like(x, k=0): if k > 0: raise ValueError( "'k' must be negative to recreate 'numpy.triu' " "behaviour with 'tensorflow.matrix_band_part'." ) return fn(x, -k, -1) return numpy_like def cholesky_lower(fn): @functools.wraps(fn) def cholesky_numpy_like(a): return fn(a, lower=True) return cholesky_numpy_like def binary_allow_1d_rhs_wrap(fn): @functools.wraps(fn) def allow_1d_rhs(a, b): need_to_convert = ndim(a) != ndim(b) if need_to_convert: b = reshape(b, (*shape(b), 1)) x = fn(a, b) if need_to_convert: x = reshape(x, shape(x)[:-1]) return x return allow_1d_rhs def scale_random_uniform_manually(fn): @functools.wraps(fn) def numpy_like(low=0.0, high=1.0, size=None, dtype=None, **kwargs): if size is None: size = () x = fn(size, **kwargs) if (low != 0.0) or (high != 1.0): x = (high - low) * x + low if (dtype is not None) and get_dtype_name(x) != dtype: x = astype(x, dtype) return x return numpy_like def scale_random_normal_manually(fn): @functools.wraps(fn) def numpy_like(loc=0.0, scale=1.0, size=None, dtype=None, **kwargs): if size is None: size = () x = fn(size=size, **kwargs) if (loc != 0.0) or (scale != 1.0): x = scale * x + loc if (dtype is not None) and get_dtype_name(x) != dtype: x = astype(x, dtype) return x return numpy_like def with_dtype_wrapper(fn): """Add ability to handle `dtype` keyword. If not None, `dtype` should be specified as a string, otherwise conversion will happen regardless. """ @functools.wraps(fn) def with_dtype(*args, dtype=None, **kwargs): A = fn(*args, **kwargs) if (dtype is not None) and (dtype != get_dtype_name(A)): A = astype(A, dtype) return A return with_dtype def translate_wrapper(fn, translator): """Wrap a function to match the api of another according to a translation. The ``translator`` entries in the form of an ordered dict should have entries like: (desired_kwarg: (backend_kwarg, default_value)) with the order defining the args of the function. """ @functools.wraps(fn) def translated_function(*args, **kwargs): new_kwargs = {} translation = translator.copy() # convert args for arg_value in args: new_arg_name = translation.popitem(last=False)[1][0] new_kwargs[new_arg_name] = arg_value # convert kwargs - but only those in the translation for key, value in kwargs.items(): try: new_kwargs[translation.pop(key)[0]] = value except KeyError: new_kwargs[key] = value # set remaining default kwargs for key, value in translation.items(): new_kwargs[value[0]] = value[1] return fn(**new_kwargs) return translated_function def make_translator(t): return functools.partial(translate_wrapper, translator=OrderedDict(t)) def complex_add_re_im(re, im): return re + 1j * im def allclose(x, y, rtol=1e-05, atol=1e-08): return do("all", do("abs", x - y) <= atol + rtol * do("abs", y)) # ----------------------------- Custom dispatchers -------------------------- # def wrap_args_kwargs_from_raw(fn): """Take a function with signature ``(*args, **kwargs)`` and wrap it to accept a single tuple of args and a dict of kwargs. """ @functools.wraps(fn) def wrapped(args, kwargs): return fn(*args, **kwargs) return wrapped def register_dispatch(fun, dispatcher, raw_signature=True): """Register a new dispatcher, a function that takes the arguments and keyword arguments of a function and returns the backend to use, when the backend is not explicitly given. This is useful in case the backend to be used by a function cannot be inferred from the first argument. Parameters ---------- fun : str The name of the function to register the dispatcher for. dispatcher : callable The dispatcher function to use. This should take the arguments and keyword arguments of the function and return the backend to use. raw_signature : bool, optional The ``dispatcher`` has signature ``(*args, **kwargs)`` if ``True``, otherwise it has signature ``(args, kwargs)``. """ if raw_signature: dispatcher = wrap_args_kwargs_from_raw(dispatcher) _DISPATCHERS[fun] = dispatcher def default_dispatcher(args, kwargs): """Try to infer backend from first argument passed to function.""" return infer_backend(args[0]) # lookup of custom dispatcher methods, for cases when backend cannot be # inferred accurately from first argument. _DISPATCHERS = defaultdict(lambda: default_dispatcher) def join_array_dispatcher(args, kwargs): """Dispatcher for functions where first argument is a sequence.""" try: return infer_backend(args[0][0]) except (TypeError, ValueError): # user passed an empty sequence, or something non-iterable # try to infer backend from first argument as fallback return infer_backend(args[0]) # List of functions listed in numpy API as array joining operations register_dispatch("concatenate", join_array_dispatcher, raw_signature=False) register_dispatch("stack", join_array_dispatcher, raw_signature=False) register_dispatch("block", join_array_dispatcher, raw_signature=False) register_dispatch("vstack", join_array_dispatcher, raw_signature=False) register_dispatch("hstack", join_array_dispatcher, raw_signature=False) register_dispatch("dstack", join_array_dispatcher, raw_signature=False) register_dispatch("column_stack", join_array_dispatcher, raw_signature=False) register_dispatch("row_stack", join_array_dispatcher, raw_signature=False) def einsum_dispatcher(args, kwargs): """Dispatcher for handling einsum. einsum can be called with a str equation as the first argument, or with 'interleaved' inputs. This dispatcher handles both cases and also takes into account all arrays. """ return infer_backend_multi(*args) register_dispatch("einsum", einsum_dispatcher, raw_signature=False) def binary_dispatcher(args, kwargs): """There are cases when we want to take into account both backends of two arguments, e.g. a lazy variable and a constant array. """ return infer_backend_multi(*args[:2]) register_dispatch("tensordot", binary_dispatcher, raw_signature=False) register_dispatch("matmul", binary_dispatcher, raw_signature=False) register_dispatch("multiply", binary_dispatcher, raw_signature=False) register_dispatch("divide", binary_dispatcher, raw_signature=False) register_dispatch("true_divide", binary_dispatcher, raw_signature=False) register_dispatch("add", binary_dispatcher, raw_signature=False) register_dispatch("subtract", binary_dispatcher, raw_signature=False) # TODO: register other binary functions? # --------------- object to act as drop-in replace for numpy ---------------- # def _get_mimic_function_or_attribute(self, fn): # respect all 'dunder' special methods and attributes if (fn[:2] == "__") and (fn[-2:] == "__"): return object.__getattribute__(self, fn) # look out for certain submodules which are not functions if fn == "linalg": return NumpyMimic("linalg") if fn == "random": return NumpyMimic("random") # if this is the e.g. linalg mimic, preprend 'linalg.' submod = object.__getattribute__(self, "submodule") if submod is not None: fn = ".".join((submod, fn)) return functools.partial(do, fn) class NumpyMimic: """A class to mimic the syntax of using `numpy` directly.""" def __init__(self, submodule=None): self.submodule = submodule def __getattribute__(self, attr): # cache the correct partial function (or special method/attribute) d = object.__getattribute__(self, "__dict__") try: pfn = d[attr] except KeyError: pfn = d[attr] = _get_mimic_function_or_attribute(self, attr) return pfn @staticmethod def __repr__(): return "" numpy = NumpyMimic() # --------------------------------------------------------------------------- # # specific functions # # --------------------------------------------------------------------------- # # ------------------------------ standard-lib ------------------------------- # _MODULE_ALIASES["decimal"] = "math" _MODULE_ALIASES["builtins"] = "numpy" _builtin_dtype_lookup = { int: "int64", float: "float64", complex: "complex128", } def builtins_get_dtype_name(x): return _builtin_dtype_lookup[x.__class__] _FUNCS["builtins", "get_dtype_name"] = builtins_get_dtype_name _FUNCS["builtins", "complex"] = complex # ---------------------------------- numpy ---------------------------------- # def numpy_to_numpy(x): return do("asarray", x, like="numpy") _MODULE_ALIASES["numpy.scipy"] = "scipy" _FUNCS["numpy", "to_numpy"] = numpy_to_numpy _FUNCS["numpy", "complex"] = complex_add_re_im _FUNCS["builtins", "to_numpy"] = numpy_to_numpy _SUBMODULE_ALIASES["numpy", "linalg.lu"] = "scipy.linalg" _SUBMODULE_ALIASES["numpy", "linalg.expm"] = "scipy.linalg" _CUSTOM_WRAPPERS["numpy", "linalg.svd"] = svd_not_full_matrices_wrapper _CUSTOM_WRAPPERS["numpy", "random.normal"] = with_dtype_wrapper _CUSTOM_WRAPPERS["numpy", "random.uniform"] = with_dtype_wrapper # ---------------------------------- cupy ----------------------------------- # def cupy_to_numpy(x): # pragma: no cover return x.get() _MODULE_ALIASES["cupy.scipy"] = "cupyx.scipy" _FUNCS["cupy", "to_numpy"] = cupy_to_numpy _FUNCS["cupy", "complex"] = complex_add_re_im _CUSTOM_WRAPPERS["cupy", "linalg.svd"] = svd_not_full_matrices_wrapper # ----------------------------------- jax ----------------------------------- # _JAX_RANDOM_KEY = None def jax_random_seed(seed=None): from jax.random import PRNGKey global _JAX_RANDOM_KEY if seed is None: from random import SystemRandom seed = SystemRandom().randint(-(2**63), 2**63 - 1) # inclusive high _JAX_RANDOM_KEY = PRNGKey(seed) def jax_random_get_key(): from jax.random import split global _JAX_RANDOM_KEY if _JAX_RANDOM_KEY is None: jax_random_seed() _JAX_RANDOM_KEY, subkey = split(_JAX_RANDOM_KEY) return subkey def jax_random_uniform(low=0.0, high=1.0, size=None, **kwargs): from jax.random import uniform if size is None: size = () return uniform( jax_random_get_key(), shape=size, minval=low, maxval=high, **kwargs ) def jax_random_normal(loc=0.0, scale=1.0, size=None, **kwargs): from jax.random import normal if size is None: size = () x = normal(jax_random_get_key(), shape=size, **kwargs) if scale != 1.0: x *= scale if loc != 0.0: x += loc return x def jax_to_numpy(x): return do("asarray", x, like="numpy") _BACKEND_ALIASES["jaxlib"] = "jax" _MODULE_ALIASES["jax.scipy"] = "jax.scipy" _MODULE_ALIASES["jax"] = "jax.numpy" _SUBMODULE_ALIASES["jax", "complex"] = "jax.lax" _SUBMODULE_ALIASES["jax", "linalg.expm"] = "jax.scipy.linalg" _SUBMODULE_ALIASES["jax", "linalg.householder_product"] = "jax.lax.linalg" _CUSTOM_WRAPPERS["jax", "linalg.qr"] = qr_allow_fat _CUSTOM_WRAPPERS["jax", "linalg.svd"] = svd_not_full_matrices_wrapper _FUNCS["jax", "to_numpy"] = jax_to_numpy _FUNCS["jax", "random.seed"] = jax_random_seed _FUNCS["jax", "random.uniform"] = jax_random_uniform _FUNCS["jax", "random.normal"] = jax_random_normal # --------------------------------- aesara ---------------------------------- # @shape.register("aesara") def aesara_shape(x): return x.type.shape _MODULE_ALIASES["aesara"] = "aesara.tensor" _FUNCS["aesara", "shape"] = aesara_shape # -------------------------------- autograd --------------------------------- # _MODULE_ALIASES["autograd"] = "autograd.numpy" _CUSTOM_WRAPPERS["autograd", "linalg.svd"] = svd_not_full_matrices_wrapper _FUNCS["autograd", "complex"] = complex_add_re_im # ---------------------------------- dask ----------------------------------- # def dask_to_numpy(x): return x.compute() def dask_eye_wrapper(fn): # Make M work as positional argument @functools.wraps(fn) def numpy_like(N, M=None, **kwargs): return fn(N, M=M, **kwargs) return numpy_like _FUNCS["dask", "to_numpy"] = dask_to_numpy _FUNCS["dask", "complex"] = complex_add_re_im _FUNC_ALIASES["dask", "abs"] = "absolute" _FUNC_ALIASES["dask", "identity"] = "eye" _MODULE_ALIASES["dask"] = "dask.array" _CUSTOM_WRAPPERS["dask", "linalg.svd"] = svd_manual_full_matrices_kwarg _CUSTOM_WRAPPERS["dask", "linalg.cholesky"] = cholesky_lower _CUSTOM_WRAPPERS["dask", "random.normal"] = with_dtype_wrapper _CUSTOM_WRAPPERS["dask", "random.uniform"] = with_dtype_wrapper _CUSTOM_WRAPPERS["dask", "eye"] = dask_eye_wrapper # ---------------------------------- mars ----------------------------------- # def mars_to_numpy(x): return x.to_numpy() _FUNCS["mars", "to_numpy"] = mars_to_numpy _FUNCS["mars", "complex"] = complex_add_re_im _MODULE_ALIASES["mars"] = "mars.tensor" _CUSTOM_WRAPPERS["mars", "linalg.cholesky"] = cholesky_lower # ----------------------------------- ctf ----------------------------------- # def ctf_array(x): return do("astensor", x, like="ctf") def ctf_to_numpy(x): return x.to_nparray() def ctf_count_nonzero(x): return (x != 0).astype(int).sum() def ctf_get_dtype_name(x): return x.dtype.__name__ _FUNCS["ctf", "array"] = ctf_array _FUNCS["ctf", "complex"] = complex_add_re_im _FUNCS["ctf", "allclose"] = allclose _FUNCS["ctf", "to_numpy"] = ctf_to_numpy _FUNCS["ctf", "count_nonzero"] = ctf_count_nonzero _FUNCS["ctf", "get_dtype_name"] = ctf_get_dtype_name _SUBMODULE_ALIASES["ctf", "float32"] = "numpy" _SUBMODULE_ALIASES["ctf", "float64"] = "numpy" _SUBMODULE_ALIASES["ctf", "complex64"] = "numpy" _SUBMODULE_ALIASES["ctf", "complex128"] = "numpy" _SUBMODULE_ALIASES["ctf", "linalg.svd"] = "ctf" _SUBMODULE_ALIASES["ctf", "linalg.eigh"] = "ctf" _SUBMODULE_ALIASES["ctf", "linalg.qr"] = "ctf" _SUBMODULE_ALIASES["ctf", "linalg.norm"] = "ctf" _FUNC_ALIASES["ctf", "random.uniform"] = "random" _CUSTOM_WRAPPERS["ctf", "random.uniform"] = scale_random_uniform_manually # ------------------------------- sparse------------------------------------- # def sparse_array(x): return do("COO.from_numpy", x, like="sparse") def sparse_to_numpy(x): return x.todense() def sparse_transpose(x, axes=None): return x.transpose(axes) def sparse_reshape(x, shape): return x.reshape(shape) def sparse_sum(x, axis=None, keepdims=False, dtype=None, out=None): return x.sum(axis=axis, keepdims=keepdims, dtype=dtype, out=out) def sparse_prod(x, axis=None, keepdims=False, dtype=None, out=None): return x.prod(axis=axis, keepdims=keepdims, dtype=dtype, out=out) def sparse_conj(x): return x.conj() def sparse_real(x): return x.real def sparse_imag(x): return x.imag def sparse_count_nonzero(x): return x.nnz def sparse_random_uniform(low=0.0, high=1.0, size=None, dtype=None, **kwargs): def rvs(nnz): return do( "random.uniform", low, high, (nnz,), dtype=dtype, like="numpy" ) return do("random", size, data_rvs=rvs, **kwargs, like="sparse") def sparse_random_normal(loc=0.0, scale=1.0, size=None, dtype=None, **kwargs): def rvs(nnz): return do( "random.normal", loc, scale, (nnz,), dtype=dtype, like="numpy" ) return do("random", size, data_rvs=rvs, **kwargs, like="sparse") _FUNCS["sparse", "array"] = sparse_array _FUNCS["sparse", "to_numpy"] = sparse_to_numpy _FUNCS["sparse", "transpose"] = sparse_transpose _FUNCS["sparse", "reshape"] = sparse_reshape _FUNCS["sparse", "sum"] = sparse_sum _FUNCS["sparse", "prod"] = sparse_prod _FUNCS["sparse", "conj"] = sparse_conj _FUNCS["sparse", "real"] = sparse_real _FUNCS["sparse", "real"] = sparse_real _FUNCS["sparse", "imag"] = sparse_imag _FUNCS["sparse", "complex"] = complex_add_re_im _FUNCS["sparse", "count_nonzero"] = sparse_count_nonzero _FUNCS["sparse", "random.uniform"] = sparse_random_uniform _FUNCS["sparse", "random.normal"] = sparse_random_normal _FUNC_ALIASES["sparse", "identity"] = "eye" # sparse uses numpys __array_func__ interface for f in ( "log", "log2", "log10", "exp", "sqrt", "sign", "sin", "cos", "tan", "arcsin", "arccos", "arctan", "sinh", "cosh", "tanh", "arcsinh", "arccosh", "arctanh", "tensordot", # NB put tensordot here, as sparse.tensordot can produce dense (numpy) # arrays but errors when both inputs are dense - we want nested calls to # tensordot to handle this ): _SUBMODULE_ALIASES["sparse", f] = "numpy" # ------------------------------- tensorflow -------------------------------- # def tensorflow_to_numpy(x): return x.numpy() def tensorflow_pad_wrap(tf_pad): def numpy_like(array, pad_width, mode="constant", constant_values=0): if mode != "constant": raise NotImplementedError try: if len(pad_width) == 1: pad_width = pad_width * ndim(array) except TypeError: pad_width = ((pad_width, pad_width),) * ndim(array) return tf_pad( array, pad_width, mode="CONSTANT", constant_values=constant_values ) return numpy_like def tensorflow_where_wrap(fn): @functools.wraps(fn) def numpy_like(condition, x=None, y=None, **kwargs): return tuple(transpose(fn(condition, x, y, **kwargs))) return numpy_like def tensorflow_split_wrap(fn): @functools.wraps(fn) def numpy_like(ary, indices_or_sections, axis=0, **kwargs): if isinstance(indices_or_sections, int): return fn(ary, indices_or_sections, axis=axis, **kwargs) else: diff = do( "diff", indices_or_sections, prepend=0, append=shape(ary)[axis], like="numpy", ) diff = list(diff) return fn(ary, diff, axis=axis) return numpy_like def tensorflow_diag(x, **kwargs): nd = ndim(x) if nd == 2: return do("linalg.diag_part", x, **kwargs) elif nd == 1: return do("linalg.diag", x, **kwargs) else: raise ValueError("Input must be 1- or 2-d.") def tensorflow_indices(dimensions): _meshgrid = get_lib_fn("tensorflow", "meshgrid") _arange = get_lib_fn("tensorflow", "arange") return _meshgrid(*map(_arange, dimensions)) _FUNCS["tensorflow", "to_numpy"] = tensorflow_to_numpy _FUNCS["tensorflow", "diag"] = tensorflow_diag _FUNCS["tensorflow", "indices"] = tensorflow_indices _SUBMODULE_ALIASES["tensorflow", "log"] = "tensorflow.math" _SUBMODULE_ALIASES["tensorflow", "conj"] = "tensorflow.math" _SUBMODULE_ALIASES["tensorflow", "real"] = "tensorflow.math" _SUBMODULE_ALIASES["tensorflow", "imag"] = "tensorflow.math" _SUBMODULE_ALIASES["tensorflow", "power"] = "tensorflow.math" _SUBMODULE_ALIASES["tensorflow", "count_nonzero"] = "tensorflow.math" _SUBMODULE_ALIASES["tensorflow", "trace"] = "tensorflow.linalg" _SUBMODULE_ALIASES["tensorflow", "tril"] = "tensorflow.linalg" _SUBMODULE_ALIASES["tensorflow", "triu"] = "tensorflow.linalg" _SUBMODULE_ALIASES["tensorflow", "allclose"] = "tensorflow.experimental.numpy" _FUNC_ALIASES["tensorflow", "sum"] = "reduce_sum" _FUNC_ALIASES["tensorflow", "min"] = "reduce_min" _FUNC_ALIASES["tensorflow", "max"] = "reduce_max" _FUNC_ALIASES["tensorflow", "mean"] = "reduce_mean" _FUNC_ALIASES["tensorflow", "prod"] = "reduce_prod" _FUNC_ALIASES["tensorflow", "concatenate"] = "concat" _FUNC_ALIASES["tensorflow", "clip"] = "clip_by_value" _FUNC_ALIASES["tensorflow", "arange"] = "range" _FUNC_ALIASES["tensorflow", "tril"] = "band_part" _FUNC_ALIASES["tensorflow", "triu"] = "band_part" _FUNC_ALIASES["tensorflow", "array"] = "convert_to_tensor" _FUNC_ALIASES["tensorflow", "asarray"] = "convert_to_tensor" _FUNC_ALIASES["tensorflow", "astype"] = "cast" _FUNC_ALIASES["tensorflow", "power"] = "pow" _FUNC_ALIASES["tensorflow", "take"] = "gather" _FUNC_ALIASES["tensorflow", "identity"] = "eye" _CUSTOM_WRAPPERS["tensorflow", "linalg.svd"] = svd_sUV_to_UsVH_wrapper _CUSTOM_WRAPPERS["tensorflow", "linalg.qr"] = qr_allow_fat _CUSTOM_WRAPPERS["tensorflow", "linalg.solve"] = binary_allow_1d_rhs_wrap _CUSTOM_WRAPPERS["tensorflow", "matmul"] = binary_allow_1d_rhs_wrap _CUSTOM_WRAPPERS["tensorflow", "tril"] = tril_to_band_part _CUSTOM_WRAPPERS["tensorflow", "triu"] = triu_to_band_part _CUSTOM_WRAPPERS["tensorflow", "pad"] = tensorflow_pad_wrap _CUSTOM_WRAPPERS["tensorflow", "where"] = tensorflow_where_wrap _CUSTOM_WRAPPERS["tensorflow", "split"] = tensorflow_split_wrap _CUSTOM_WRAPPERS["tensorflow", "random.uniform"] = make_translator( [ ("low", ("minval", 0.0)), ("high", ("maxval", 1.0)), ("size", ("shape", ())), ] ) _CUSTOM_WRAPPERS["tensorflow", "random.normal"] = make_translator( [ ("loc", ("mean", 0.0)), ("scale", ("stddev", 1.0)), ("size", ("shape", ())), ] ) _CUSTOM_WRAPPERS["tensorflow", "clip"] = make_translator( [ ("a", ("t", 0.0)), ("a_min", ("clip_value_min",)), ("a_max", ("clip_value_max",)), ] ) register_creation_routine("tensorflow", "linspace", inject_dtype=False) # ---------------------------------- torch ---------------------------------- # @shape.register("torch") def torch_shape(x): # torch returns a Size object, we want tuple[int] return tuple(x.shape) @size.register("torch") def torch_size(x): return x.numel() def torch_to_numpy(x): return x.detach().cpu().numpy() def torch_transpose(x, axes=None): if axes is None: axes = reversed(range(0, x.ndimension())) return x.permute(*axes) def torch_count_nonzero(x): return do("sum", x != 0, like="torch") def torch_astype(x, dtype): return x.to(dtype=to_backend_dtype(dtype, like=x)) @functools.lru_cache(None) def _torch_get_dtype_name(dtype): return str(dtype).split(".")[-1] def torch_get_dtype_name(x): return _torch_get_dtype_name(x.dtype) def torch_real(x): # torch doesn't support calling real on real arrays try: if x.is_complex(): return x.real except AttributeError: pass return x def torch_imag(x): # torch doesn't support calling imag on real arrays try: if x.is_complex(): return x.imag except AttributeError: pass return do("zeros_like", x, like="torch") def torch_linalg_solve_wrap(fn): @binary_allow_1d_rhs_wrap def numpy_like(a, b): return fn(b, a)[0] return numpy_like def torch_linalg_eigh(x): return tuple(do("symeig", x, eigenvectors=True, like="torch")) def torch_linalg_eigvalsh(x): return do("symeig", x, eigenvectors=False, like="torch")[0] def torch_tensordot_wrap(fn): @functools.wraps(fn) def numpy_like(a, b, axes=2): return fn(a, b, dims=axes) return numpy_like def torch_pad(array, pad_width, mode="constant", constant_values=0): if mode != "constant": raise NotImplementedError try: # numpy takes pads like ((0, 0), (1, 1), ... (n-1, n-1)) # torch takes pads like (n-1, n-1, n-2, n-2, n-3, n-3, ...) pad = tuple(itertools.chain.from_iterable(pad_width))[::-1] # a single tuple was specified ((a, b),) - use for all axes if len(pad) == 2: pad = pad * array.ndimension() except TypeError: # assume int pad = (pad_width,) * 2 * array.ndimension() return do( "nn.functional.pad", array, pad=pad, mode=mode, value=constant_values, like="torch", ) def torch_split_wrap(fn): # for torch >=1.8 we can use tensor_split instead, but in current stable # release this function has not been added @functools.wraps(fn) def numpy_like(ary, indices_or_sections, axis=0, **kwargs): if isinstance(indices_or_sections, int): split_size = shape(ary)[axis] // indices_or_sections return fn(ary, split_size, dim=axis, **kwargs) else: # torch.split doesn't support empty splits if len(indices_or_sections) == 0: return (ary,) diff = do( "diff", indices_or_sections, prepend=0, append=shape(ary)[axis], like="numpy", ) diff = list(diff) return fn(ary, diff, dim=axis) return numpy_like def torch_zeros_ones_wrap(fn): @functools.wraps(fn) def numpy_like(shape, dtype=None, **kwargs): if dtype is not None: dtype = to_backend_dtype(dtype, like="torch") return fn(shape, dtype=dtype) return numpy_like def torch_eye_wrap(fn): @functools.wraps(fn) def numpy_like(N, M=None, dtype=None, **kwargs): if dtype is not None: dtype = to_backend_dtype(dtype, like="torch") if M is not None: return fn(N, m=M, dtype=dtype, **kwargs) else: return fn(N, dtype=dtype, **kwargs) return numpy_like def torch_indices(dimensions): _meshgrid = get_lib_fn("torch", "meshgrid") _arange = get_lib_fn("torch", "arange") return _meshgrid(*map(_arange, dimensions), indexing="ij") _FUNCS["torch", "pad"] = torch_pad _FUNCS["torch", "real"] = torch_real _FUNCS["torch", "imag"] = torch_imag _FUNCS["torch", "astype"] = torch_astype _FUNCS["torch", "to_numpy"] = torch_to_numpy _FUNCS["torch", "complex"] = complex_add_re_im _FUNCS["torch", "transpose"] = torch_transpose _FUNCS["torch", "count_nonzero"] = torch_count_nonzero _FUNCS["torch", "get_dtype_name"] = torch_get_dtype_name _FUNCS["torch", "indices"] = torch_indices _FUNC_ALIASES["torch", "array"] = "tensor" _FUNC_ALIASES["torch", "asarray"] = "as_tensor" _FUNC_ALIASES["torch", "clip"] = "clamp" _FUNC_ALIASES["torch", "concatenate"] = "cat" _FUNC_ALIASES["torch", "conjugate"] = "conj" _FUNC_ALIASES["torch", "expand_dims"] = "unsqueeze" _FUNC_ALIASES["torch", "linalg.expm"] = "matrix_exp" _FUNC_ALIASES["torch", "max"] = "amax" _FUNC_ALIASES["torch", "min"] = "amin" _FUNC_ALIASES["torch", "power"] = "pow" _FUNC_ALIASES["torch", "random.normal"] = "randn" _FUNC_ALIASES["torch", "random.uniform"] = "rand" _FUNC_ALIASES["torch", "split"] = "tensor_split" _FUNC_ALIASES["torch", "take"] = "index_select" _FUNC_ALIASES["torch", "identity"] = "eye" _SUBMODULE_ALIASES["torch", "linalg.expm"] = "torch" _SUBMODULE_ALIASES["torch", "random.normal"] = "torch" _SUBMODULE_ALIASES["torch", "random.uniform"] = "torch" _CUSTOM_WRAPPERS["torch", "linalg.svd"] = svd_not_full_matrices_wrapper _CUSTOM_WRAPPERS["torch", "random.normal"] = scale_random_normal_manually _CUSTOM_WRAPPERS["torch", "random.uniform"] = scale_random_uniform_manually _CUSTOM_WRAPPERS["torch", "tensordot"] = torch_tensordot_wrap _CUSTOM_WRAPPERS["torch", "stack"] = make_translator( [("arrays", ("tensors",)), ("axis", ("dim", 0))] ) _CUSTOM_WRAPPERS["torch", "concatenate"] = make_translator( [("arrays", ("tensors",)), ("axis", ("dim", 0))] ) _CUSTOM_WRAPPERS["torch", "tril"] = make_translator( [("m", ("input",)), ("k", ("diagonal", 0))] ) _CUSTOM_WRAPPERS["torch", "triu"] = make_translator( [("m", ("input",)), ("k", ("diagonal", 0))] ) _CUSTOM_WRAPPERS["torch", "clip"] = make_translator( [("a", ("input",)), ("a_min", ("min",)), ("a_max", ("max",))] ) _CUSTOM_WRAPPERS["torch", "ones"] = torch_zeros_ones_wrap _CUSTOM_WRAPPERS["torch", "zeros"] = torch_zeros_ones_wrap _CUSTOM_WRAPPERS["torch", "eye"] = torch_eye_wrap _CUSTOM_WRAPPERS["torch", "empty"] = make_translator([("shape", ("size",))]) _CUSTOM_WRAPPERS["torch", "take"] = make_translator( [("a", ("input",)), ("indices", ("index",)), ("axis", ("dim",))] ) _CUSTOM_WRAPPERS["torch", "expand_dims"] = make_translator( [("a", ("input",)), ("axis", ("dim",))] ) # for older versions of torch, can provide some alternative implementations _MODULE_ALIASES["torch[alt]"] = "torch" _FUNCS["torch[alt]", "linalg.eigh"] = torch_linalg_eigh _FUNCS["torch[alt]", "linalg.eigvalsh"] = torch_linalg_eigvalsh _SUBMODULE_ALIASES["torch[alt]", "linalg.qr"] = "torch" _SUBMODULE_ALIASES["torch[alt]", "linalg.svd"] = "torch" _SUBMODULE_ALIASES["torch[alt]", "linalg.norm"] = "torch" _SUBMODULE_ALIASES["torch[alt]", "linalg.solve"] = "torch" _CUSTOM_WRAPPERS["torch[alt]", "split"] = torch_split_wrap _CUSTOM_WRAPPERS["torch[alt]", "linalg.svd"] = svd_UsV_to_UsVH_wrapper _CUSTOM_WRAPPERS["torch[alt]", "linalg.qr"] = qr_allow_fat _CUSTOM_WRAPPERS["torch[alt]", "linalg.solve"] = torch_linalg_solve_wrap for f in _CREATION_ROUTINES: register_creation_routine("torch", f, inject_device=True) # ---------------------------------- mxnet ---------------------------------- # def mxnet_to_numpy(x): return x.asnumpy() _MODULE_ALIASES["mxnet"] = "mxnet.numpy" _FUNCS["mxnet", "to_numpy"] = mxnet_to_numpy autoray-0.6.12/autoray/compiler.py000066400000000000000000000213231462076570400171500ustar00rootroot00000000000000import functools from .autoray import ( do, infer_backend, backend_like, tree_map, tree_iter, tree_flatten, tree_unflatten, is_array, ) from . import lazy class CompilePython: """A simple compiler that unravels all autoray calls, optionally sharing intermediates and folding constants, converts this to a code object using ``compile``, then executes this using ``exec``. Parameters ---------- fn : callable Function to compile - should have signature ``fn(*args, **kwargs) -> array``, with ``args`` and ``kwargs`` any nested combination of ``tuple``, ``list`` and ``dict`` objects containing arrays (or other constant arguments), and perform array operations on these using ``autoray.do``. fold_constants : bool, optional Whether to fold all constant array operations into the graph, which might increase memory usage. share_intermediates : bool, optional Whether to cache all computational nodes during the trace, so that any shared intermediate results can be identified. """ def __init__(self, fn, fold_constants=True, share_intermediates=True): self._fn = fn self._fold_constants = fold_constants self._share_intermediates = share_intermediates self._jit_fn = None def setup(self, args, kwargs): """Convert the example arrays to lazy variables and trace them through the function. """ variables = tree_map(lazy.array, (args, kwargs)) if self._share_intermediates: with backend_like("autoray.lazy"), lazy.shared_intermediates(): outs = self._fn(*variables[0], **variables[1]) else: with backend_like("autoray.lazy"): outs = self._fn(*variables[0], **variables[1]) return lazy.Function( variables, outs, fold_constants=self._fold_constants ) def __call__(self, *args, array_backend=None, **kwargs): """If necessary, build, then call the compiled function.""" if self._jit_fn is None: self._jit_fn = self.setup(args, kwargs) return self._jit_fn(args, kwargs) class CompileJax: """ """ def __init__(self, fn, enable_x64=None, platform_name=None, **kwargs): self._fn = fn self._enable_x64 = enable_x64 self._platform_name = platform_name self._jit_fn = None self._jit_kwargs = kwargs def setup(self): import jax if self._enable_x64 is not None: import jax jax.config.update("jax_enable_x64", self._enable_x64) if self._platform_name is not None: import jax jax.config.update("jax_platform_name", self._platform_name) self._jit_fn = jax.jit(self._fn, **self._jit_kwargs) self._fn = None def __call__(self, *args, array_backend=None, **kwargs): if self._jit_fn is None: self.setup() out = self._jit_fn(*args, **kwargs) if array_backend != "jax": out = do("asarray", out, like=array_backend) return out class CompileTensorFlow: """ """ def __init__(self, fn, **kwargs): self._fn = fn kwargs.setdefault("autograph", False) self._jit_fn = None self._jit_kwargs = kwargs def setup(self): import tensorflow as tf self._jit_fn = tf.function(**self._jit_kwargs)(self._fn) self._fn = None def __call__(self, *args, array_backend=None, **kwargs): if self._jit_fn is None: self.setup() out = self._jit_fn(*args, **kwargs) if array_backend != "tensorflow": out = do("asarray", out, like=array_backend) return out class CompileTorch: """ """ def __init__(self, fn, **kwargs): import torch self.torch = torch if not hasattr(fn, "__name__") and isinstance(fn, functools.partial): # torch jit.trace requires fn.__name__ and others functools.update_wrapper(fn, fn.func) self._fn = fn self._jit_fn = None kwargs.setdefault("check_trace", False) self._jit_kwargs = kwargs def setup(self, *args, **kwargs): flat_tensors, ref_tree = tree_flatten((args, kwargs), get_ref=True) def flat_fn(flat_tensors): args, kwargs = tree_unflatten(flat_tensors, ref_tree) return self._fn(*args, **kwargs) self._jit_fn = self.torch.jit.trace( flat_fn, [flat_tensors], **self._jit_kwargs ) def __call__(self, *args, array_backend=None, **kwargs): if array_backend != "torch": # torch doesn't handle numpy arrays itself args = tree_map(self.torch.as_tensor, args, is_array) if self._jit_fn is None: self.setup(*args, **kwargs) out = self._jit_fn(tree_flatten((args, kwargs))) if array_backend != "torch": out = do("asarray", out, like=array_backend) return out _backend_lookup = {} _compiler_lookup = { "jax": CompileJax, "tensorflow": CompileTensorFlow, "torch": CompileTorch, } class AutoCompiled: """Just in time compile a ``autoray.do`` using function. See the main wrapper ``autojit``. """ def __init__(self, fn, backend=None, compiler_opts=None): self._fn = fn self._backend = backend self._compiled_fns = {} if compiler_opts is None: self._compiler_kwargs = {} else: self._compiler_kwargs = compiler_opts def __call__(self, *args, backend=None, **kwargs): array_backend = infer_backend( next(tree_iter((args, kwargs), is_array)) ) if backend is None: if self._backend is None: # no backend specified anywhere, use the array backend backend = array_backend else: # use the backend specified at init backend = self._backend # work out which compiler to use for combo of backend and array backend try: key = _backend_lookup[backend, array_backend] except KeyError: if backend in _compiler_lookup: key = backend else: key = f"python-{array_backend}" _backend_lookup[backend, array_backend] = key try: fn_compiled = self._compiled_fns[key] except KeyError: if "python" in key: backend = "python" backend_compiler = _compiler_lookup.get(backend, CompilePython) compiler_kwargs = self._compiler_kwargs.get(backend, {}) fn_compiled = backend_compiler(self._fn, **compiler_kwargs) self._compiled_fns[key] = fn_compiled return fn_compiled(*args, array_backend=array_backend, **kwargs) def autojit(fn=None, *, backend=None, compiler_opts=None): """Just-in-time compile an ``autoray`` function, automatically choosing the backend based on the input arrays, or via keyword argument. The backend used to do the compilation can be set in three ways: 1. Automatically based on the arrays the function is called with, i.e. ``cfn(*torch_arrays)`` will use ``torch.jit.trace``. 2. In this wrapper, ``@autojit(backend='jax')``, to provide a specific default instead. 3. When you call the function ``cfn(*arrays, backend='torch')`` to override on a per-call basis. If the arrays supplied are of a different backend type to the compiler, then the returned array will also be converted back, i.e. ``cfn(*numpy_arrays, backend='tensorflow')`` will return a ``numpy`` array. The ``'python'`` backend simply extracts and unravels all the ``do`` calls into a code object using ``compile`` which is then run with ``exec``. This makes use of shared intermediates and constant folding, strips away any python scaffoliding, and is compatible with any library, but the resulting function is not 'low-level' in the same way as the other backends. Parameters ---------- fn : callable The autoray function to compile. backend : {None, 'python', 'jax', 'torch', 'tensorflow'}, optional If set, use this as the default backend. compiler_opts : dict[dict], optional Dict of dicts when you can supply options for each compiler backend separately, e.g.: ``@autojit(compiler_opts={'tensorflow': {'jit_compile': True}})``. Returns ------- cfn : callable The function with auto compilation. """ kws = dict(backend=backend, compiler_opts=compiler_opts) if fn is None: return functools.partial(autojit, **kws) return functools.wraps(fn)(AutoCompiled(fn, **kws)) autoray-0.6.12/autoray/experimental/000077500000000000000000000000001462076570400174605ustar00rootroot00000000000000autoray-0.6.12/autoray/experimental/__init__.py000066400000000000000000000000001462076570400215570ustar00rootroot00000000000000autoray-0.6.12/autoray/experimental/complexity_tracing.py000066400000000000000000000145551462076570400237500ustar00rootroot00000000000000""" Functionality for tracing through an autoray.lazy computation and estimating the cost and scaling. In the following there are ``cost_*`` functions that estimate the total cost of a given operation, including sub-leading factors. There are also `cost_scaling_*` functions that only consider the leading factor of the cost, so that we can prime number decompose it and extract the scaling. """ import math def cost_tensordot(x): x1, x2, axes = x.args shape1, shape2 = x1.shape, x2.shape cost = math.prod(shape1) * math.prod(shape2) for d in axes[0]: cost //= shape1[d] return cost cost_scaling_tensordot = cost_tensordot def cost_qr(x): (A,) = x.deps shape = A.shape m = max(shape) n = min(shape) return 2 * m * n**2 - (2 / 3) * n**3 def cost_svd(x): (A,) = x.deps shape = A.shape m = max(shape) n = min(shape) return 4 * m * n**2 - (4 / 3) * n**3 def cost_eigh(x): (A,) = x.deps m = A.shape[0] return 8 / 3 * m**3 def cost_scaling_linalg(x): """Here we only care about the leading factor of the cost, which we need to preserve so that we can prime number decompose it. """ (A,) = x.deps shape = A.shape m = max(shape) n = min(shape) return m * n**2 cost_scaling_qr = cost_scaling_svd = cost_scaling_linalg def cost_matmul(x): A, B = x.deps return A.shape[0] * A.shape[1] * B.shape[1] cost_scaling_matmul = cost_matmul def cost_einsum(x): eq, *operands = x.args lhs = eq.split('->')[0] terms = lhs.split(',') size_dict = { ix: d for term, x in zip(terms, operands) for ix, d in zip(term, x.shape) } return math.prod(size_dict.values()) cost_scaling_einsum = cost_einsum def cost_linear(x): return math.prod(x.shape) def cost_nothing(x): return 0 COSTS = { "qr": cost_qr, "qr_stabilized": cost_qr, "qr_stabilized_numba": cost_qr, "svd": cost_svd, "svd_truncated": cost_svd, "svd_truncated_numba": cost_svd, "svd_truncated_numpy": cost_svd, "eigh": cost_eigh, "linalg_eigh": cost_eigh, "tensordot": cost_tensordot, "matmul": cost_matmul, "einsum": cost_einsum, # other cheap ops "mul": cost_linear, "sum": cost_linear, "add": cost_linear, "neg": cost_linear, "sqrt": cost_linear, "cupy_sqrt": cost_linear, "pow": cost_linear, "truediv": cost_linear, "log10": cost_linear, "cupy_log10": cost_linear, "norm": cost_linear, "linalg_norm": cost_linear, "reshape": cost_linear, "conj": cost_linear, "conjugate": cost_linear, "cupy_conjugate": cost_linear, "clip": cost_linear, "transpose": cost_linear, "torch_transpose": cost_linear, "clamp": cost_linear, "getitem": cost_nothing, "None": cost_nothing, } def cost_node(x, allow_missed=True): f = x.fn_name if f in COSTS: return COSTS[f](x) elif allow_missed: return 0 else: raise ValueError(f"Cost for {f} not implemented.") def compute_cost(z, print_missed=True): C = 0 missed = {} for node in z.descend(): f = node.fn_name if f in COSTS: C += COSTS[f](node) else: missed[f] = missed.get(f, 0) + 1 if missed and print_missed: import warnings warnings.warn(f"Missed {missed} in cost computation.") return C COST_SCALINGS = { "qr": cost_scaling_qr, "qr_stabilized": cost_scaling_qr, "qr_stabilized_numba": cost_scaling_qr, "svd": cost_scaling_svd, "svd_truncated": cost_scaling_svd, "svd_truncated_numba": cost_scaling_svd, "svd_truncated_numpy": cost_scaling_svd, "eigh": cost_scaling_linalg, "tensordot": cost_scaling_tensordot, "matmul": cost_scaling_matmul, "einsum": cost_scaling_einsum, # other cheap ops "mul": cost_linear, "sum": cost_linear, "add": cost_linear, "neg": cost_linear, "sqrt": cost_linear, "pow": cost_linear, "truediv": cost_linear, "log10": cost_linear, "norm": cost_linear, "reshape": cost_linear, "conj": cost_linear, "conjugate": cost_linear, "clip": cost_linear, "transpose": cost_linear, "getitem": cost_nothing, "None": cost_nothing, } def prime_factors(n) -> list[int]: fs = [] if n <= 1: return fs while n % 2 == 0: fs.append(2) n = n // 2 for i in range(3, int(math.sqrt(n)) + 1, 2): while n % i == 0: fs.append(i) n = n / i if n > 2: fs.append(n) return fs def is_prime(n: int) -> bool: for i in range(int(n**0.5), 1, -2 if int(n**0.5) % 2 == 0 else -1): if n % i == 0: return False return False if n in (0, 1) else True def closest_prime(nt: int) -> int: if is_prime(nt): return nt lower = None higher = None for i in range(nt if nt % 2 != 0 else nt - 1, 1, -2): if is_prime(i): lower = i break c = nt + 1 while higher is None: if is_prime(c): higher = c else: c += 2 if c % 2 != 0 else 1 return higher if lower is None or higher - nt < nt - lower else lower def frequencies(it): c = {} for i in it: c[i] = c.get(i, 0) + 1 return c def compute_cost_scalings(z, factor_map, print_missed=True): counts = {} missed = {} for node in z.descend(): f = node.fn_name if f in COST_SCALINGS: CS = COST_SCALINGS[f](node) else: missed[f] = missed.get(f, 0) + 1 continue # group operations key = (CS, f) counts[key] = counts.get(key, 0) + 1 if missed and print_missed: import warnings warnings.warn(f"Missed {missed} in cost scaling computation.") scalings = [] for key, freq in counts.items(): op = { "cost": key[0], "name": key[1], "freq": freq, } pf = frequencies(prime_factors(op["cost"])) for name, factor in factor_map.items(): op[name] = pf.pop(factor, 0) if pf and print_missed: import warnings warnings.warn( f"Missed prime factor(s) {pf} in cost scaling computation, " f" for operation {op}." ) scalings.append(op) scalings.sort(key=lambda x: x["cost"], reverse=True) return scalings autoray-0.6.12/autoray/experimental/complexity_tracing_example.ipynb000066400000000000000000046470071462076570400261640ustar00rootroot00000000000000{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "This notebook shows various ways to introspect a `autoray.lazy` traced\n", "computation, including scaling analysis. The basic steps for that are:\n", "\n", "1. Choose prime numbers for all possible dimension sizes\n", "2. Trace the computation with `lazy.array`\n", "3. Call `compute_cost_scalings`" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "%config InlineBackend.figure_formats = ['retina']\n", "\n", "import quimb as qu\n", "import quimb.tensor as qtn\n", "\n", "from autoray import lazy\n", "from autoray.experimental.complexity_tracing import (\n", " cost_node,\n", " compute_cost,\n", " compute_cost_scalings,\n", " prime_factors,\n", " frequencies,\n", " closest_prime,\n", ")" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# all dimensions on intermediates must be different primes so that we can \n", "# decompose the costs for scaling analysis!\n", "p = 2\n", "D = 3\n", "chi = 5\n", "\n", "factor_map = {\n", " 'p': p,\n", " 'D': D,\n", " 'chi': chi,\n", "}" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "psi = qtn.PEPS.from_fill_fn(\n", " lambda shape: lazy.Variable(shape, backend='numpy'),\n", " # (could also call lazy.array on actual data)\n", " 10, 10, D, phys_dim=p\n", ")\n", "norm = psi.make_norm()" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "Z = norm.contract_boundary(\n", " max_bond=chi,\n", " cutoff=0.0,\n", " sequence=['xmin'],\n", " layer_tags=('KET', 'BRA'),\n", " # layer_tags=None gives the single layer\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# basic introspection" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "$W$ is the maximum tensor size or 'width':" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "13122" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "W = Z.history_max_size()\n", "W" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "becase its a single tensor we can analyse its scaling:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, 3, 3, 3, 3, 3, 3, 3, 3]" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "prime_factors(W)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'p': 1, 'D': 8, 'chi': 0}" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "max_size_scaling = {\n", " name: frequencies(prime_factors(W)).get(size, 0)\n", " for name, size in factor_map.items()\n", "}\n", "max_size_scaling" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "$M$ is 'peak size': maximum concurrent size of all intermediates." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "27018" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# this is a sum so we can't decompose it\n", "M = Z.history_peak_size()\n", "M" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Which is the peak of this graph:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 591, "width": 2061 }, "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Z.plot_history_size_footprint(log=2)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "$C$ is the estimated total flops:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "56272536.0" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# similarly for the total cost\n", "C = compute_cost(Z)\n", "C" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAGD0AAASfCAYAAACqzNCRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAFxGAABcRgEUlENBAAEAAElEQVR4nOzdeZykV10v/k9V9TIzmUwy2VlCAoQEQiDhElAWA4mi7HqviMtPURQ3xAUXVFyOB1FQFFGB676CiutF4OIVlRBl34LsEBLW7Jlss/VWz++P6hkmmemq7pqq6p6Z9/v1qle/0ud7zvk+tTz1nKcz59tqmiYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABr1V7vBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCOTogcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQFD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGougBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFEUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAoSh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCiKHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiKogcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQFD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGougBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFEUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAoSh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCiKHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiKogcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQFD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGougBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFEUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAoSh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCiKHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiKogcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQFD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGougBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFEUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAoSh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCiKHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiKogcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQFD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGougBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFEUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAoSh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCiKHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiKogcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQFD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGougBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFEUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAoSh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCiKHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiKogcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQFD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGougBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFEUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAoSh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCiKHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEOZWu8EAI4WtdZ/TnL/QzR9ppTy9EnnAwAAAAAAAAAAAAAAAAAAAAAAAAAAAADjpugBwOjcP8n5650EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExKe70TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjkxT650AADAZtdbTcujv/sVSyo2TzgcAgKOb608AACbJ9ScAAJPk+hMAgEly/QkAwCS5/gQAAAAAAAAAAIbVXu8EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAI5OiBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFAUPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIai6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAURQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIChKHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRdEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgKIoeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ1H0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIqiBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFAUPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIai6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAURQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIChKHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRdEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgKIoeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ1H0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIqiBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFAUPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIYytd4JAGw0tdZfSlLWOw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Oja650AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwZFL0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIqiBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFAUPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIYytd4JAGw0pZRfSvJLa+1Xa/1okvNHnQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAbFTt9U4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Mk2tdwIAwPq47/HXnnjP43Y8dPP0wlkffe3X7lwxsOluabo5K+3WvZputmehdWK67U3Z1D3wOmIxrWYhTdNptVqbmm4z21pqz6bb6mS2uUuRpabJYppu0k6abpP2YidpWu1DxbUWmqZp0qTVtFpznSYzmTrcuHTTatpNMt9JazoHzZum6WYh3XSTA+PmpjqdvZlqtWcW21ML7XZrbytJumnS7R1/FpPWYpq7PX+tLDZNa0+S3XOL07v2LswsdJpupjcvLqbd3NgsdK7dPdte6LZbZ2zeu3TqdJZOOLD7XHdqarFpbZ2ZWtq873fz3U57sd2emd280J5ZWkx7rt3a19ZOs7gw32mWFjtpH7e02CTdA/vMbFnIzNJiq7O33T6wz+J8Z2Gx22m3Ny91D+zTdFtTmzYtdFqdpRzYZ7Hb7s7PTS9NtbrdA/ssdDLVarWnZxaWWp1Wt5Vmf2pZWGovLKadqeluN00W9/9+X5/5pabTajoH5jXf7SzNL3W6MzNL2TfH/qe2nT1pNTvTbe0fq5Nmbt/zuthq39Cdbu0+sM/0aXuu2vbgHe+96JwrdgQAAAAAAAAAAAAAAAAAAAAAAAAAAIDDpugBABxjHnvGhx69bdOeVy2d3T2t2b6UdrvJwqaFg+Latyedz0xl6dRuOje1052eTvvzs1l85M40py4OHdc9IK6zQtz0+2fS7J5Oa3YhuWFrutuaLD7qznWJu+68Tj6/45RccMYXsm3XXKbfdXzaN0+v6Tm/YXZLrtmyLeef+KUcf9n1++e9bcfWbL6hlZP/ezrtW6fTvm0qSWd/nxvPaeV+j7omrVN6r89N12/PF645PRec8YVs3tVdzmXT/nl2TM9m+t67suWyW/bPMWyfOz5wcs5duiW5z95Mv/fLfQ48lhMPcSyn7T+WLz9HhzqW1fS5/hB9RuX9H770+s7mpW+96JwrLh/54AAAAAAAAAAAAAAAAAAAAAAAAAAAAMeQ9nonAABMzmPP+NCjT9i0++8WH7ZwWrN9acW49u1J5xNTWbr/YjrXtrN0cjtTHz4uC0+57eBCBiOOm3nHTHLbprQ7C8kXTkja7Sw8/dZ1ibv2kcknv3BmHn7fq7KpvZDZN540VMGDj2w7OY84/nOZ+ua7Fgk46c75bHvnpkxds3m54MGX+3z+vKnc/2mfukvBg0995OwVc9kxPZsT7nFHOt98w12KFwzT56Z33DPn33Zbmofuyuybv9xnVMcybJ9R6mxeOiPJW6+86pLHj2UCAAAAAAAAAAAAAAAAAAAAAAAAAACAY4SiBwBwDDlxZuevLJ7dDIyb+myyeE6z/+fMW07M/BNum0hc69MnpjnrjrQ+fWJa8+11jfvw+87NQy7+VDLby3kY79t+ei6+9YaD5p2aXsrMW3pzHarP+Y+86i6/G5TLdNM9aI5h+1x40y2Zf8JtB/UZ1bEM22dMXjmpiQAAAAAAAAAAAAAAAAAAAAAAAAAAAI5Gih4AwDHi3BM+v72V5txm+1L/wIWktbuVZttS7+eWJq2d7TSnLo49rn1HO007ae9uJ0vttPa21i1ubluyd89sts3uTrOpSfvm6f7P2yHMtdvZ257Ktqk9d5l3fq6TrVNzad3ZTvu2qYP6LG1u0jpl4YD4qb65zLVa2Tq1925zDNenu3MqU3uSZmv3Ln1GdSzD9hmjB1951SUnTWoyAAAAAAAAAAAAAAAAAAAAAAAAAACAo42iBwBwjNg+e+dpTWvwV39rIWla7S//3NlOs7U7kbjMt5MTFpP5dprN3XWN27tnNps2zyV7ejkPY297Kpu6iwfNOz8303seNh+cz972VI6f3X3X3w3IZb7dOWiOYftsm9qTZmv3oD6jOpZh+4zZPSY9IQAAAAAAAAAAAAAAAAAAAAAAAAAAwNFC0QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAoih4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDUfQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYiqIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAUBQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhqLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBRFDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKEoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxF0QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAoih4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDUfQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYiqIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAUBQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhqLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBRFDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKEoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxF0QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAoih4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDUfQAAI4Rt84df2Or6Q6Ma6aTVtP98s+t3bR2HnzJMI64zHST26eSmW5ae9rrGrdp81z27plNNvdyHsam7mL2tqcOmndmdr73POw5OJ9N3cXcObflrr8bkMtMd+mgOYbtc8fi5rR2tg/qM6pjGbbPmF036QkBAAAAAAAAAAAAAAAAAAAAAAAAAACOFooeAMAx4lO33+fWJq1PtW7t9A+cTpotTVp3dHo/d7d6G9TfNDX2uO62blrdpLulm3S6aTY16xY3e8dyEYC5LWntbaV7ykL/5+0QZrvdbOou9goJHDDvzOxSdi7Opjm+m+6Jiwf16exppbl5+oD4xb65zDZNdi5uutscw/Vpb13M4uaktbN9lz6jOpZh+4zRRy8654odk5oMAAAAAAAAAAAAAAAAAAAAAAAAAADgaKPoAQAcQ26d3/rCqc+2BsYtnp1MXdXa/3P+Cbdl5i0nTiSuecBtaX1uW5oH3JZmpruucQ99xCfz3+89L5nr5TyMi2+9Ie/bfvpB8y4ttDP/hN5ch+rzsXefc5ffDcplodU+aI5h+1x56imZecuJB/UZ1bEM22dMnjepiQAAAAAAAAAAAAAAAAAAAAAAAAAAAI5Gih4AwDHk7ddf+M7b9m55xtQHpm9s3dpZMa57QrL0wMV0PjOVpXt207mlm8WH7Mr0m05M66apscbNP3o+OXFvuovTyZm3J0vdTP/z9nWJu8e7W3ngfT6X91/zgOztTmfuqTvSPWVhTc/56XO7c8Edt+S9d56VhdedsX/eE07alVuPn84dj9qbxfvuSffExbv0uc+nFvOZfz433ZunkySnnH5bHvjQq1fM5aSFudx+3bYsve70/XMM2+f0x3wxH9u+Pa0PHZe5J3+5z6iOZdg+o7S0p3N9kksvOueKy8cyAQAAAAAAAAAAAAAAAAAAAAAAAAAAwDFianAIAHA0efv1F74zycPuu+PaE+953I6Hbp5eOGvr7O6dK8V3vtTd0nRzVmu+e6/u9j3b2x+bOjHdmU3Z1N1/HdFNFltfaha6TdNpzXc3dbfvnu18Ymo2H5vuZLbZX2SpSdL6Yha7TTeZX8rS9l3pfHwq+dh0+8C4pS1Js3lpsbXQapr77GrSalqdK6ebzExPHW5cztzVatpN2h+aTmv64HmzebGbhVY3Z+5K025y+hc6OWP6s+25azudOzLbal+4uz210G639rZ6h96km2QxrSwmrcU0d3sCW1nc1Oze86DcvHtucXrX7e8+Y6HTdDO9eXGx025unF/oXPuF09sL3Xu0zti8d+nU6SydkCTtzOeMJLe975Spxaa1dWZqafNUkvtlR2771Antm9vtmdkHLrRnlvamPddu9SabT5Nmcde7T26WFjtpH7e0OJV0D+wz86CFzCztbXX2ttsH9tn97pMXFruddnvzUncq6Z48dUeua29uN1/aMrXp/gud1rl709nbbrczn/vntuzutru3veOMpalWt9vevNRtku6eJHecmqnWae3pmYWFVqfVbaVp7T+WO9570sJi2pma7nbTZDFJ7tJnfqHptJrOvuO/Z5rFO9930tL8Uqc7M7OUJune5altZ09azc50W/srJnTSzKXd3NgsdK5dbLVv6E63dh/YZ/q0PVdte/CO9z78IW/dsdJ7HgAAAAAAAAAAAAAAAAAAAAAAAAAAgNVT9AAAjlHX3HnP2665855XJFkspdy43vkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR572eicAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcmRQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhqLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBRFDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKEoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxF0QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAoU+udAACwvh6w7QsnfvQvv/qi7J2+MEvt05ut3a2HM16zqbkuaX26tbvzrgue9aarR5Un7FNrPemMe9903tkn3HDB1l2L503tat3lPTu3Z/r4pbRPbx+3OLua8Tpp5tJubmwWOtcutto3dKdbu/e1bZ3ee+vmM++8pnvW/CcvOueKHaM+FgAAAAAAAAAAAAAAAAAAAAAAAAAAgCOdogcAcIx67BkfevS2TXtelS2d03LtcVl85M40py6OdI4PvefShc7Vm15wwbe8+RUjHZhjUq310tPuefOfPOnRV529eVc30+86Pu2bN+1v3zE9m+l778qmy24a6Xu5u/zzyo897rOZaZ590TlXXD6ywQEAAAAAAAAAAAAAAAAAAAAAAAAAAI5w7fVOAACYvMee8aFHn7Bp9991T22dNvWxLVl4ym0jL3iQJM1JS9OLF+/6rY/8zZN+bOSDc0yptV56yuk7/uPRD/ro2ZvaC5l940lp3zy9v33H9GxOuMcd6XzzDWN5LydJZpqzk7z1yqsuefx4JgAAAAAAAAAAAAAAAAAAAAAAAAAAADjyKHoAAMegE2d2/sri2U1mrtiWhcfdPvb5lu6396Vjn4Sj3SsfcvGnktkmM2858aDG6aab+SfcNrFcJjURAAAAAAAAAAAAAAAAAAAAAAAAAADARqfoAQAcY+53/Je2t9Kc22xu0trdTnPK4tjnbE5amv3IXzzlfmOfiKNSrfXk6ZmF87fN7k6zqUn75um7tM+1Wtk6tTfNqeN/Ly978JVXXXLSpCYDAAAAAAAAAAAAAAAAAAAAAAAAAADYyBQ9AIBjzEmzd5zatNpp7Wqn2dKd3MSd5oLJTcZR5oxNm+eSPe20dh58+Trf7qTZOsH3cs89Jj0hAAAAAAAAAAAAAAAAAAAAAAAAAADARqToAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBRFDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKEoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxF0QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAoih4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDUfQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYytR6JwAAAAAAAAAAAAAAAAAAAAAAAAAAwLGp1vr4JG/tE3JpKeXyiSQDAADAUNrrnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHBkUvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYytR6JwAAAAAAAAAAAAAAAAAAAAAATEat9bNJzlpl+M+VUn51jOnst4q87ltK+ewkcgEAAAAAAADWpr3eCQAAAAAAAAAAAAAAAAAAAAAAG9ILaq3b1zsJAAAAAAAAYGObWu8EAAAAAAAAAAAAAAAAAAAAgCNHrbVZ7xzg7koprfXO4Sh1QpKfTvIz650IAMBaXHnVJdYtbDgXnXOFdQsAAABw1FL0AOBuaq2/lKSsdx4AAAAAAAAAAAAAAAAAAACwAfxIrfW3SynXrXciAAAAAAAAwMbUXu8EAAAAAAAAAAAAAAAAAAAAAIANa3OSX1jvJAAAAAAAAICNS9EDAAAAAAAAAAAAAAAAAAAAAKCf59Ra77/eSQAAAAAAAAAbk6IHAAAAAAAAAAAAAAAAAAAAAEA/00nqeicBAAAAAAAAbEyKHgAAAAAAAAAAAAAAAAAAAAAAg3xrrfUh650EAAAAAAAAsPFMrXcCABtNKeWXkvzSWvvVWj+a5PxR5wMAAAAAAAAAAAAAAAAAAAAbQDvJryR5+nonAgAAAAAAAGws7fVOAACYrB1z225qNd00x3XT2j3BS4Gl1kcmNxlHmev37plNNnfTbO0e1DjTXUpr58Qva6+b9IQAAAAAAAAAAAAAAAAAABvA02qtj17vJAAAAAAAAICNRdEDADjGXH3nvW5t0vpUa08rzZZuWjdPjX3O1o7O3AXPetPVY5+Io1Ip5ZaF+emP3TG3Ja29rXRPWbhL+2zTZOfiprRuGv97edlHLzrnih2TmgwAAAAAAAAAAAAAAAAAYML+34D2X51IFgAAAAAAAMARQ9EDADgG3Tq/9YVTn21l/pI7Mv22E8Y+X+fqTT8z9kk42v3Qf7/3vGSulfkn3HZQ40KrnZm3nDipXJ43qYkAAAAAAAAAAAAAAAAAANbBi5Ls6dP+uFrr100qGQAAAAAAAGDjU/QAAI5Bb7/+wnfetnfLM9o3Njcunr870286Ma2bpkY+T2tHZ2Hqfcc9/4JvefMrRj44x5RSyuW33Lj90nd8/MGf3dudztxTd6R7ysL+9pMW5nL7dduy9LrTx/JeTpLMtz6b5NKLzrni8vFMAAAAAAAAAAAAAAAAAACwIVyb5JUDYn611tqaRDIAAAAAAADAxjemHWEBgI3u7ddf+M4kD3vAti9svfCUa86e+sjMhVnadHqztbv1cMZtNjXXJa1Pt3Z33nXBs950dR45ooQ55pVSLk9y31rrSWfc+6bzzr74hgu27tp73tSu1tYkaWUui0l2vePU45fSPr193OLsasbtpJlLu7mxWehcu9hq39Cdbu3e17Z1eu+tm8+885ruWfOfvOj8t+0Yy4EBAAAAAAAAAAAAAAAAAGw8L03yfUlOWKH9fyR5RpK/m1hGAAAAjEWtdXuSs5NsS28duC1JO8nuAx43J/lsKWXnOqXJUaLWeq8k5yY5McnxSRaT3Jnks0k+VUqZW7fkAACAw6LoAQAc4z59x5m3fdvz/+hfk/zreucCq1FK2ZHkncsPAAAAAAAAAAAAAAAAAABGrJSyo9b6G0l+uU/YL9da/7GUsjSpvMat1tpJcnGSx6ZX2OH+Sc5MsjXJcUkWkuxKckuSq5N8Msnbk1xRSrlhPXJeq1rrA5I8LcnDk1yQ5Iz0NjSdSu/YbkxyTZL3J7k8yX+UUhbXJdlDWH6NHpbkMem9RvdLcp/0juG45bBdSXakdxz7XqPLSynXTjxhAAAmrtY6leRRSb46yflJzktyWnrX9ZvTu168KclnkvxYKeXjhznfmemtIb4yyQOS3DfJKeldn84k2ZNkZ5LPL8/53iT/meT9pZTmcOY+jJzPSvItyzlflF7Bg9X2vSW9a+0rk7wrybuTfKyU0h11nmtVa70wyVPSWzOcn+TU9Io4tNJ73a9Lby33niRvTfJf6/UaJEmtdTa9tdmDkjxw+bFvfbMtvYIATZK9SW5P8qUkn0vyoSTvS/KfpZS9k898bWqtW9MrnPj0JJdl5QKLSbJUa31nkjcl+bNSyvUTSHFVll+vi9Nbj16Y3nr0wHsGS/lygZCrk3wsX16P3rIeOQMAwKQpegAAAAAAAAAAAAAAAAAAAAAA3N0rkvxwepuDHsp5Sb4ryR9PKJ+xqbU+MMkPJvnmJKf3Ce0k2ZTk5CTnJnlikh9N0q21XpHkz5O8tpSyMKY8z05vc9GVPLuU8meH6DeV5JlJfjK9zT9XcsLy4wFJvjbJzya5pdb6B0leXkq5ebjMD1+t9eFJvie9jTJPHRB+4vLjfultdPvcJM3ya/THSf56IxVyAADgrmqt35XkT/uE3LeU8tlD9Ds3yfOSPCv9N1Xft6H8/dO7/l9z0YNa60lJvju9wgEPHxC+dflxRpJHJvnW5d9/rtb62iS/O6mN3Wutz0zyA0ken14hgGGcvPy4OMlzln93U631H5P8bZK3TbI4Xq11U5JnJ/nxJOf0CT1x+fGg9Aoj1CRfqrX+TpJXl1J2jjfTpNbaSq8gx2VJLk3y6PTWmIPMpPeePTO9QhXfvPz7PbXWtyT5gyRvHmfhiVrr49MrFLGSS0spl9+tz3FJXpDe5/KkVU7VSa+IyGOTvGj5M/Jz61nErtZ6aXr3P74hvddhJVNJZpNsT29d/XVJnp9ksdb6r0l+P8kb1rPQBgAAjFt7vRMAAAAAAAAAAAAAAAAAAAAAADaW5Q0ff2VQWK11dhL5jEOt9axa698k+WiSH0n/ggf9tNPbNPRPk1xVa3328maW667W+pVJrkzy2vQveLCSk9MrfvCpWuuzRpjaqtRav2J5E8/3pVeYYlDBg5W0kjwuyV+kdyzfOKIUAQBYZ7XWE2qtv5te8YIfTv+CB4c71/Za628m+XySl2VwwYN+zkrywiTX1FpfXmvdOoocD6XW+qBa61uTvC69zfZHvV45Ncn3J/n3DF5Hjkyt9SlJPpXk1elf8GAl90rya0k+Xmt90ihzO1Ct9RG11pcn+UKStyf55fQKH6ym4EE/m5M8Pckbk3y41vrUwxxvZGqtlyT57yS/mNUXPLi76fSKDXyq1vq9I0pt1WqtT6y1vifJf6RXTKVfwYN+ppI8Ocnrk3xouYAEAAAclRQ9AAAAAAAAAAAAAAAAAAAAAAAO5feSfK5P+5lJnjuhXEaq1vpD6RU7+OaMdg+W+yT5kyT/UWu9zwjHXbNa68+lt6Hmg0cw3PYkf15rfWWtdex71tRaj6+1/l6Sdyb5mhEPf98kf19r/ada69g2xAUAYPxqrQ9Nb2P152XMeyvWWr8tySeS/HiS40Y49KYkz0/ysVrrY0c4bpKk1vrd6RVCe/yox17B1LgnqLVO1Vpfld5m/2eOYMh7J3lTrfVnRjDWXdRa/yDJe9J7je816vEPcH6SN9RaX1NrHXZz/pGotX5Hkn9Lcr8RDXlckj+otf55rXUS76/Ta61/n+TNSR4x4uEfkuSttdbfO5KLSAIAwEoUPQAAAAAAAAAAAAAAAAAAAAAADlJKmU/ySwPCXlhrPX4C6YxErXW21vpnSV6Z0W5UenePT/LecWxaOkittV1r/dMkL87o95f5ofSeu7GptT4ovU1Bvz9Ja4xTfUOS99RazxnjHAAAjEmt9fHpFfkaa7Gx5TXE7yd5bZLTxjjVmekVT3vOqAastf5gkj9OMjOqMddbrXVzkjdl9AX4WkleUmt9wYjHnXQBgv8vyX/WWs+Y8LxJklrrs5L8eZLpMQz/rCT/WGsd2/u51vroJB9I8o3jmmPZ9yd5W6311DHPAwAAE6XoAQAAAAAAAAAAAAAAAAAAAACwkr9M8vE+7ack+fEJ5XJYaq3TSf4+yXdOaMrTkvxrrfWyCc23z6uTfNcYx//BWuv3jWPgWuujkrwzyQPHMf4hnJvkcoUPAACOLLXWhyZ5fZKtY57nuCRvTjKW699DmE7yB8vFCg5LrfWrMuaCZZNWa51K8ndJvnaM07y01vp1Yxx/Eh6a5K211hMnOely0b8/zHiL1z0tyR+NY+Ba6zckeWuSe45j/EP4ivQKnSh8AADAUWNqvRMAAAAAAAAAAAAAAAAAAAAAADamUspSrfUX0isWsJKfqLW+qpRy86TyGtJfJnnqKmObJB9K8p4kn0lyR3obkJ6a5MFJHp/kpFWMsznJG2qtjyulvG+tCa9VrfWnknx/n5Ad6W3i+IUkNya5LcnJSU5P8tgkF61yqt+qtb65lPKFoZO9m1rrVyb5f0mOX2WX+STvTe91uiW9Y1tKr9jE6Ukek+T8VYxzryT/Umt9RCnl1rXmDQDAxG1N8n+SbOsT84kk707vWv7WJIvpXWeeld4171cm6fSbpNa6Kb2CB1+1htyuSvKOJNend316R3rrhtOSPCjJJUlmB4zRSvKqWuu1pZTXr2Hu/ZaLA/xJkvYqwj+T5F/Se76uSvK5JLuWH9NJTlh+nJTeWuihSR6S5JFJtgyT32H47SRP6dN+XZLLk1yb3npnZ3pruDOSXJrkvFXM0Uryp7XWc0spOw8r29W7JcmHk3w6ye3Lj9vSW5fue/7vn+Ti9N7Dq/HAJH+d5EkjznUlW5O8KsnMCu0fS/K6JG9L8sn0Ph+tJNvTe10en+Sb0/ucDPIdtdYPl1Jedpg577dc8OBv03vPr8auJO9Kr0jkLcuPTnqf9XskeVyS+65inAuSvL7W+vhSyvwa0wYAgA1H0QMAAAAAAAAAAAAAAAAAAAAAYEWllH+otb4vvQ0WD+X4JD+b5Ccml9XaLBcD+OZVhO5N8jtJXlVK+Xyf8Trpbbb5wiRfMWDMLUn+vtb68FLKLatMeRhfmeR7DvH7JsnfJHllkneXUpZWGqDWeu8kP5/ke9N/g9QtSV6S5NuHzvau856Z3sa1gwoeNOltPPvbSa4opewdMO59knx3eu/NrX1C75/kNem/gSoAABvDy3LozcTvTPK7Sf64lHJ1vwFqrSenVyzsjj5hf5zVFTy4OsnLk/xjKeW6AfNuSfLkJCW9zc5X0kryF8triKtWkcPdPSvJOQNi3pXkF0op/9YnZjHJnvSKOCTJO/c11Fo3J/maJE9L8vXpbfY+Tt+Y5Lkr5Pj76b1eV5ZSmpUGqLWel+TFSZ4xYK57JPmZ9NZG43B9kn9O8sYkHyylfHG1HWut90jyHemt/c4dEP7EWutzSil/NHSmq/fLSe5ziN9/JsmPl1L+eYV+1y8/3pak1lqfnuS3ktxvwHwvrrW+pZRy5ZD57ldrvSjJazO44MFikr9Lr7jDe0opCwPGPS+99+wPZOViEEnyqCSvyKHf3wAAcERR9AAAAAAAAAAAAAAAAAAAAAAAGOSFSf61T/tza62/tZbNGiel1vrQJL+6itB3JfnWUspnBwUuFw7451rrG9LbmPA3k8z26XJWkldndYUXhvX9h/jdB5J8Xynl/asZYPn1+4Fa618meVOSE/qEf0ut9YX9ikOsRq11Ksk/JDl9QOi7kzynlPKR1Y69nNsv1Vpfnd7z/419wp9ca/2uUsqfrXZ8AADWxRMP8bs3JPneUsoNqxlguRjZimuEWuuPJvm2AcPckeRHkrymX2Gxu827O72CaP+YXqGx38nKm6FvS/KHtdbL+m3kv4LnDGh/ZZLnl1IW1zjufqWUPek972+otT4vvefr+cOOtwrPO8Tv/i3Jc0spn17NAKWUTyb5plrr/0ry1+m/Ef0P1VpfUkrZtfZUD2lPkj9Lr9jaO4d4TZMky4U1fr3W+hvpvf9enOS4Pl1eWmv9m1LKzmHmW4OLDvG7/5PkWaWUO1c7SCnln2utlyf5yyRP7xM6k97n45HDPpdJUmvdtpznlgGhb0ryvNXcL9hn+f32o7XWV6T32l/SJ/wHa61/V0p562rHBwCAjahfNW0AAAAAAAAAAAAAAAAAAAAAgJRS3pKk3+Z7m5KUCaWzarXWVpLfSzI1IPQfkzxuLRsYJkkppSmlvCrJ1yUZtBnmM2uth9qgdVz+Jb1jWlXBgwOVUt6e3jHt7RPWyeDNVFfjBUkeMSDmN5N81VoKHhyolHJjkm9K8rIBob+xvOklAABHjt9M8vWrLXgwSK31/hlcNO0DSf5HKeXPV1vw4ECllG4p5feTPCHJjj6hj0/yrWsZu9Z6UpKv6BPyr0l+5HAKHtxdKWW+lPJnpZQLk/z6qMYd4M+SPGm1BQ8OVEr5xyTPTNJvs/wTM5qidTcleVGS+5RSnltKecfhbNK/z/J76BVJLk5yfZ/Qk9Mr1Ddpf5fkGWspeLBPKeWO9ArW/dOA0IuTfPsQuR3oN9IrUriSxSQ/leRpa71fsE8p5Zr0PuuvHRD66lprZ5g5AABgo1D0AAAAAAAAAAAAAAAAAAAAAABYjZ8d0P7sWuu5E8lk9b4hyaMGxFye5FtKKfPDTlJKeVt6m+p3B4S+dNg51ugt6W3KuHPYAUop707yawPCvmnY8ZOk1npmkl8cEPbiUspPllIWDmeu5QIVL0jyB33CTk7yI4czDwAAE/Wny9eKh72J/AF+N8mWPu0fSXJZKeUzhztRKeWKJF+fpF/hhF9c40boF6f/PpO/OOLn6y6WC46N25+WUp59OIUbSimvT/IXA8IOa72zPM8Pl56bD3esFcb/RJLLktzWJ+z7xjF3H1cm+c5hCoLss/zafnuSDw8I/fnlYodrVmt9ZJLvHRD2A6WU3zjcz8zy/YbvSK844UoemDUWOQEAgI1G0QMAAAAAAAAAAAAAAAAAAAAAYKDlTfBf3yekk+SXJ5TOav3cgPbb0yt4cFgb6idJKeXNSX5zQNiFtdanHu5cA9yU5FmHswHoAV6a5Po+7Q+std7nMMb/hSSzfdpfU0r5hcMY/1B+NL1NOFfyI7XW6RHPCQDA6H0hvWu7kam1PjrJk/qEXJfkyaWU20c1Zynlv5L8fJ+Q85I8bQ1D3q9P2w3L67oj2SeSPG9EY/10krk+7Y+vtc6MaK6xKaV8PL211Uruv/zenoQmvUIBew53oFLK7iQ/OCDs3CTDrrFfPKi9lPLHQ459kOXCCd+R5It9wn5yVPMBAMB6UPQAAAAAAAAAAAAAAAAAAAAAAFitn0vS7dP+TbXWh00qmX5qrY9I8vABYaWUcsMIp31RkmsHxAzatPFwPa+U0q9QwaqVUvYm+ZsBYY8dZuxa6xlJvqtPyM0Z3Wam+y0f04/3CTk1a9tUFgCA9fHcUsqdIx7zZwe0/2Qp5QsjnjNJXpbk6j7t372GsU7s0/b5NYyzUX3n8mb4h215LfjmPiGbklw8irkm4H8nuapP+xMnlMdrR1lYo5Ty9gxek67l85EkqbU+PMkT+oR8PEld67iDlFJuTvKLfUIurLX+j1HPCwAAk6LoAQAAAAAAAAAAAAAAAAAAAACwKqWUjyZ5bZ+QVpJfnVA6g3zHgPaPJ3nVKCcspexM8tMDwr5uecP/cfhMkr8f8Zh/PaD9wiHHfXaS6T7tv1hKuX3Isfsqpbw1yXv6hDxzHPMCADAyHyylvHGUA9Za753kSX1C3p3B18ZDKaUsJfmNPiFPrLUev8rhWn3aplaf1YZ0eSml33X8MMa13pmo5ffQP/YJuWwCaTRJfn4M475weeyVPKnWesIax/y+Ae0/UUpZXOOYq/WaJF/s0249CgDAEUvRAwAAAAAAAAAAAAAAAAAAAABgLUqS+T7tT6y1XjKpZPr4+gHtvz+mTQxfl+TmPu2dJE8dw7xJ8jullO6Ix/xA+r/eDxxy3O/s07YjyR8NOe5q/WGftq+ptdqbBwBg4/rTMYz57eldq6/k10sp/TZeP1x/npWvu6ez+k3rd/RpO7fWunlNWW0svzWGMd81oH3Y9c56eHOftgtrrf0KYozCFaWUz4160FLKNUne0SdkNsnXrHa8WutMkm/pE/LhUkq/5/KwlFIW0vu8r+TrxjU3AACMmz+sAAAAAAAAAAAAAAAAAAAAAACrtrzhYL8N45PkJZPIZSW11vOS3KdPyGKSvx7H3MsbGP7NgLBVb8i4Rv806gGXC0N8vE/Ivdc6Zq31/knO6xPyj8vP4zhd3qft5CQXjHl+AACGs5jktWMY9yl92nYm+b9jmHO/UsruJO/tE/K4VQ51Y5+245I8e9VJbSx7039T/6GUUj6f5LY+IWte76yjfgUHtiY5e8zzj2WNveyvBrRfuoaxvirJtj7tr1vDWMO6vE/bhbXWEyaQAwAAjJyiBwAAAAAAAAAAAAAAAAAAAADAWr04ye4+7Y+utT51UskcwlcNaP+3Ukq/zUAP12sGtA/KbxifL6V8YQzjJskn+7SdNsR4TxzQ/g9DjLkmpZSrklzXJ+SicecAAMBQPlpK2THKAWut25I8qk/Im0ope0c55wr+s0/bRasc4z0D2l9aa33MKsfaSN4zxsJon+rTNsx6Z73cMKD97DHPP/IifAcYtEZ89BrGWvf1aJJ3JFlaoa2V5MIJ5AAAACM3td4JAAAAAAAAAAAAAAAAAAAAAABHllLK9bXW307ys33CfqXW+qZSSjOpvA4waIPA/xrz/O9LsifJ5hXa71lrPaWUcvMI53znCMe6u9v7tJ0wxHhfMaD9/UOMOYzPJ7nHCm0XTCgHAADWZhzXihcn6fRpf98Y5jyUz/VpW9X1aSnlS7XWTyY5b4WQ45P8e631ZUleVkq5Y405rpcjab0zlFprK8k9k5yR5NQk25LMJplJbyP8w7XS2mcUvjTOwoKllBtqrddl5WN4UK21U0pZqZDAgfqtR3emf9G/kSil7K613pzk9BVCLkhyxbjzAACAUVP0AAAAAAAAAAAAAAAAAAAAAAAYxq8n+YEk21dof2iSb03yVxPL6MsGbQj6wXFOXkpZqrV+OMkj+4Q9JMlbRzjt50c41t3d2adtdojxHtan7aZSyk1DjDmMW/q03XtCOQAAsDYfGMOY/a5Pk+RjY5jzUPpdn55aa50tpcytYpw/SfJrfdpnk/x8kufXWv8qyeuSvK2Usrj6VCfuSFrvrEqt9dQkT07ymCSPSK9QxUqF80bh5DGO/aExjn3gHCsVPdiU5H5JPt1vgOXCEv2KJH58goUbb8nKRQ+sRwEAOCIpegAAAAAAAAAAAAAAAAAAAAAArFkp5bZa668neUmfsBfVWv+ulLIwqbyW3WdA+5UTyOGD6V/0YFCOa3XriMc70M4+bTNrGWh5k8lz+81Va33OWsY8DKf0abvXhHIAAGBtxrH5/QMHtP+PWus9xzDv3Z0/oP2eSa5ZxTivTvJT6X+9myTHJfne5cettdZ/T3L58uNjE9z8fTWOiPXOILXWqSTPSPL9SS5J0h7l+AOMs6DCf49x7H0+lOSJfdrvnQFFD9L7DG3rFzDB9Wi/ghrWowAAHJEUPQAAAAAAAAAAAAAAAAAAAAAAhvU7SX40yRkrtN8/yfck+b2JZdRzjz5te0op104gh9VstjhKO0Y83oFGudnp6em/ceh9k/zhCOcbVt+NMAEAWDe3j2HMMwe0//IY5hzGqq5RSyk7a63PTvLPSVqrHHt7epvxP2P5v2+ttb4ryTuS/FeSd5dS9qwx31Far/XOap+/gWqt35jkpUnOGdWYa9Rvk/3DNYk19nUD2vvdB9hn0Gf9EcuP9WY9CgDAEWmSVd0AAAAAAAAAAAAAAAAAAAAAgKNIKWV3Bm8A+gu11s2TyCdJaq3HJek33zg2ST2UOwa0nzri+eZGPN64jLrYw7hM7D0LAMCaDLrOHsZRd41aSnljkp/K8AXMtid5Unrrvbcm2VFr/X+11ufWWlcqejdOR8p65yC11uNrrX+b5O+zfgUPkqQzxrHH8blc6xwnr2KMo+6zDgAAG4miBwAAAAAAAAAAAAAAAAAAAADA4fjDJFf3ab9nkh+eUC7J4M0BJ7EZYzK4uMKxuonh8eudwCrNrncCAAAc0jiu54/Ka9RSym8m+aYkO0cw96YkX5vkVUm+WGt9Y631iSMY96hWaz0tyRXpvQ5Hs41Q9GDTKsY4Kj/rAACwUSh6AAAAAAAAAAAAAAAAAAAAAAAMrZSykKQMCPvpWusJk8gngzc63ChFD1azIePR6Egp9tBa7wQAADik7hjGPGqvUUsp/5DkwUn+IqN77jpJnpLkzbXW99VaHzeicY8qtdYtSd6U5KJ1TmUS7pzAHIPW8qspFHDUftYBAGAjmFrvBAAAAAAAAAAAAAAAAAAAAACAI95fJfnpJBes0H5Skp9K8vMTy2hlzYTmsUnhoU2vdwIAAHA3R/U1ainl80m+s9b6siTfn+Tb0lujjcLDk1xea311kueXUuZHNO7R4DeSXLzK2KUkH0jyviSfSHJ1khuS3JRkZ5JdSRaXiw6uqNY6qfXu3U3iMzRojtUU9TiqP+sAALDeFD0AAAAAAAAAAAAAAAAAAAAAAA5LKaVba/25JK/vE/ZjtdbfKaXcOOZ09g5oP2HM8++zbUD7oDyPVnPrnQAAANzNMXGNWkr5SJIfrrX+RJInJXlCksuSPGgEwz83yQNrrU9S+CCptV6c5AdXEfq+JK9K8k+llNsPc871LLw3aP07iTlWs8Y+Jj7rAACwXhQ9AAAAAAAAAAAAAAAAAAAAAAAOWynln2ut70zyqBVCjkvy80l+ZMyp7BnQPonNGFczz6A8j1a7B7T/dinlxyaRCAAALOt3jXp7KeXESSUyCctFCV6//Eit9YwklyR5zPLjoiSdIYa+LMkfJXnWSBI9sv3igPbFJC8opfzWCOecVIG/Qzl+AnMMWmPvWsUYg9ajzy+lvGJ16QAAAHfXXu8EAAAAAAAAAAAAAAAAAAAAAICjxgsHtH9/rfWscSZQStmV/gUFJlX0YNCGkzdNJIuN55YB7fedSBYAAPBl/a5RT6i1bp9YJuuglHJ9KeVvSyk/Wkq5OL21zJOSvCzJR9c43HfUWp858iSPIMtFJJ48IOyZIy54kCTr+T6dRMGFQWv5G1cxhvUoAACMkaIHAAAAAAAAAAAAAAAAAAAAAMBIlFIuT/KvfUJmkvzSBFK5rk/bluVNKMftnAHt104gh43o8wPa7zeRLAAA4Mtcox6glLKrlPIvpZQXlFIuSHJukhel/zrrQLXW2hlfhhveU5P0O/4/LKX80xjmPWkMY67WAyYwx7kD2lfz/vRZBwCAMVL0AAAAAAAAAAAAAAAAAAAAAAAYpRcmafq0f0et9UFjzuFzA9ofNub5VzPHoM0Wj0qllF1JbuoTcr9jfINUAAAm75oB7ZPY0H3DKqV8upRSkpyd5CeS7BnQ5YFJLh13XhvYVw1of9mY5l3PDfsv3ABzfGYVY3wu/e9XHNOfdQAAOFyKHgAAAAAAAAAAAAAAAAAAAAAAI1NKeX+Sf+gT0kny4jGn8ZEB7ReNc/LlTfsfMiDsw+PMYYP7YJ+2LUkePalEAAAg/a9Pk+QJE8ligyulzJdSXp7kKUn2Dgg/lp+zfkX+riylfHpM8z5mTOOuxkNqrWPb33R57Av6hNxUSulXXC9JUkrZmaTf839erfXMteYHAAD0KHoAAAAAAAAAAAAAAAAAAAAAAIzaLyRZ6tP+v2qtjxjj/B8a0D7uzSAflt7m/Su5tpRy85hz2MjePaD9qRPJAgAAegZdnz651tqaSCZHgFLKW5P82oCwr5pELhvUWX3aPjbGedez6MFxSS4c4/iD1thXrmEs61EAABgTRQ8AAAAAAAAAAAAAAAAAAAAAgJEqpXwiyZ8PCPvVMaZwxYD2r621njzG+b99QPvbxjj3keDfBrQ/fSJZAABAklLK1Umu7hNyRpKvmFA6R4r/naTp036PSSWyAW3r03b9OCastd4ryUXjGHsNvmWMY3/rgPa1rLEHrUe/fg1jAQAAB1D0AAAAAAAAAAAAAAAAAAAAAAAYh5pkrk/719RaLxvHxKWUTyf5XJ+Q6STfPI65a62dDN7scdAmi0e7/0pyU5/2B9ZaFT4AAGCS/s+A9hdMIokjRSnlhiRX9Qk5ZVK5bEAzfdqWxjTnDyWZGtPYq/UttdbWqAddHnPQ+v0/1jDkG5Is9mn/2lrrhWsYDwAAWKboAQAAAAAAAAAAAAAAAAAAAAAwcqWUzyf53wPCXjLGFP5pQPv31VrHsf/KM5Kc3qd9MckbxzDvEaOU0k3yNwPCXjSODTMBAGAFrx3Q/j9rrQ+fSCZHjpv7tM1OLIuNZ0+fttNGPVmtdXOS7x31uEO4T5InjWHcpya5d5/2LyZ512oHK6XcmuTNfUJaSX55teMBAABfpugBAAAAAAAAAAAAAAAAAAAAADAuv5pkZ5/2R9Zav2FMc//lgPYLM+KNIWutW5K8bEDYv5RSbhzlvEeoVyZp+rRfmOQ5E8oFAIBjXCnlA0neMSDs5bXWqUnkc4Q4pU/b7RPLYuO5qU/bI8Yw34vT/7WYpJeN8jNSa53O4DX260op/daWh/K7A9qfVmv92jWOCQAAxzxFDwAAAAAAAAAAAAAAAAAAAACAsSil3JTk5QPCXpwx7IOyvGnpewaE/Uqt9aQRTvtzSc4cEPPqEc53xCqlfCrJPw0Ie2Wt9dGTyAcAAJK8dED7JUleMYE8Nrxa68lJzu4TcvWEUtmIPtOn7fxa67mjmqjW+vgkzx/VeCNwfpIfHOF4z0tyXp/2bpLfW+ugpZS3JHn/gLC/qbU+YK1jAwDAsUzRAwAAAAAAAAAAAAAAAAAAAABgnH4zyS192h+cwYUChvUrA9pPTvKXtdbD3oel1vrVSV4wIOyDpZQ3H+5cR5GfTrLQp30myT/VWvttcjlStdbHjbgQBgAAR4hSyhuSvHVA2A/VWie2yXyt9Yxa66PWEP8jtdZ7jzOnZd+TZLpP+/smkMNG9d4B7S8exSS11rOSvCZJaxTjjdBLa60PPdxBaq0Py+A1/etLKVcNOcVPDGjfnuQNtdYzhhx/zWqtTx/F/QkAAFgvLmYBAAAAAAAAAAAAAAAAAAAAgLEppdyR5CXrNP0bkvzXgJgnJ/nzWmtn2ElqrY9J8o9JpgaE/vSwcxyNljenHPTeOC3Je2utzxxXHrXW9vLmkpcnuTyJogcAAMeu5yXZMyDm5bXWP621bh5XErXWc2utv5vkmiRPWUPX707ymVrrH9ZaHzKm3B6WpA4Ie+M45j5C/L8B7d9Ua/3uw5lguTDcfyS51+GMMyZbkry51nrusAPUWh+Y5P8m6fcZW0zy88POUUp5W5K/GBB2XpIP1lofP+w8g9RaZ2qt/1+t9YNJXh/7xAIAcAQb9EcyAAAAGIlPvOaSk3LzpvOamdYF3enuednbuUezKac3m5vZu0Y2U635bE63tSXt7pbMt6cznZnMNnf9g0zTdLOQbrpJ026S+U5a02kPH5elLGQp3bSadtOkabUy07RardbUsHHNYprWUtJ0mmSplcw2WUvcXKvTmu92Ou2ltNqtpDXX6s3fTjdNFpLWQpq7PdGtLDZpLSTNrqS1c25+es/CwlR7evPiYrtp7lxa6HzpztbsjYut9mlbN+2511R78fjO3tb+12CuOzW1MDe1ebq1tKm9eWl/rgudTLVa7emZhaVWp9VtpflykfeFpfbCYtqZmu5202TxoD7zS02n1ez/n33baRbnu52l+aVOd2ZmKU3STZL5bqe92G7PzGxZyMzSYquzt90+sM/CfKdZWuykfdzS4oF9ut3W7KbZxVZ7arE5sM9it92dn5temmp1u+3NS90D+zTd1tSmTQudVmcpB/ZZWGovLMxPdzut7mJ789KXj3GNx7K/vZXFJrkzyd59v+ukmdv3WixOtT/XnW7tPrDP9Gl7rtr24B3vveicK3YEOGyffNFT7tfd3v3K7uzSOWla9+1uaU5Nq3XCQYHz2dTqto5Pu7spTTY1M830OM7tB8W1mm66TZN2Wk03TXup3Uq31bnL99Ta41ppJ023SXuxkzStg773miaLabq5e9zcVKcztzDV6kx1O+12Wq297SZpmrSymCZLaVoLudu5LkmaVubStPamnTv3Lk7tmluc6U5PL063l5o72p3ceEcze8PuqemprZt332Pz/OLpB373JMnC3NSmbtM6/sDvnvU+x+/rc/fvuH3fV7ObF9ozS4tpz7X3fyn2+77q9x23ON9ZWOx22od7LEnvu6fVbvZ2kz3ptvZ/L+97LRY67c8upXPzgX22Tu+99bj2/LsueNabrr77awus3Sdec8lJS830xWm1Lmy6OSsLnXul2zr+UGufNM3WVivHNd1mtrXUnj3o3J6Vz9mHE9daaJqmSZNW02rNdZrMZOpw45bXSGtem81NdTp7M9Vqt7vtzt602k2rlaSbJt0ki2llMWktHnLt07T2JNk9tzi96+Ljt6TVNK3p2aXFpt3csrQwdf3emfZiOs0pl7/6mcdPZ+ku3/9z3ampxaa1dWZqaf//8LgRzvErfcdthDXZoY5l/8vRzp60mp0Hfvd00syl3dzYLHSuXWy1bzhw7bN1eu+tm8+885ruWfOftPaBw+e+29F9320U96rcd+tx3w1Gy3039932z+G+m/tuMCHH2n23w12bjeq+296FmYVO08305sXFffd6ds+2F7rt1hmb9y6dOor7bqO6V3U033f7ylOmW01arSTpNJnbdw90qdW64d//8Ftv2hfvvhuMlvtu7rvt+737bu67AQAAI/eqJD+W5N6TnLSU0tRafyDJB5NM9wn99iT3rrV+eynlS2uZo9b6fUl+O8mmAaF/XUp5y1rGPka8KMkTkjyqT8zxSV5Xa31Skl9ZLpZw2Gqt56T32n9nkrNHMSYAAEe2UsrHaq0/md4app/vSnJxrfXnkryhlHL3v4itWa11a5L/meRZSb46Sat/jxXNJHlOkufUWv8zyZ8n+bvlgnSHm+P/TPJn6b/++XySfz3cuY5gVyT5QpIz+8T8Qa31uFLK76518Frrd6a3Br37/7+7lGToYn6Hqcld36/3TPLOWut3llLWVACj1vq09N6z2weE/u9SysfWluZBnpfkMUnu3yfmjCT/Vmv97SS/WUq59jDnTJLUWi9Mbz36HUlOH8WYAACw3hQ9AAAAYKw+8ZpLLs0ts3/SbY47uzW7kNywNdnWZPFRd6Y5df+/CU/79mT6/TNpdk9nX1x3AnFJMvWxmbQ/uSXde+9N+4ubsviQ3WlOXkyzfWld4m5tNmfzDa1svbqTmXvPZfq9x6d9c7//l/ZgO6ZnM33vXTn+slv2H+9N12/PHR84Iecu3pLcZ+/yuL1//3nD7JZcs2Vbzj/xS5m+7Lr9fW7bsTWbb2jltP+eTvvW6bRv+3IeN8xuyY3ntHK/R12T1ikL+38/qM/1d+tz0/Xb84VrTs8FZ3whm3d1M/2u49O++ct/2953LFsOOpaTc+7Sgcey6aBjOfGy69fcZ/qAPms9llF6/4cvvb6zeelbLzrnistHPjgcAz5Znvb8pS3tX+s+YGG6/cVNWXrAQpqTlwaci2eXz8WD4g7/O6B9e9L5zFS6p3bTuamd7vR0Op+fzeIjdx70fTaJuOvOmcrtnzkx5y7dkpn958i1ffcc+L1w/CHO8ffef47/8v4P+87xWy+7acOd4+/+HTfs99W4vuMOPJZRWExy5XsuW5i6evYFF3zLm18xsoHhGPKJ11xy6VJ7+q+W7tU+o3NTk+70VNp9zsVLB5yL+8WN8jtgPdZcK8Vdd14nn99xSs7fdl22f6Sd9q2zad+2tj9dHnhenHnMDVk6qfd9e8dtx2XLTa2c9vGpdG6fypZbO9n3/2keCef4Ew/j+2o1fUaxJhuFfTvoXPmxx302M82zrX1g7dx3O7rvu43iXpX7bofmvhscHvfd3Hdz321t3HeDw+e+2/redzv+EOf4k/ef46dyOPfd1nMdc6Tdd9u0dzrd7sH7F7TbTWY33XXd5L4bHD733dx3c99tOO67AQAAq1VK2VtrfVGSP1iHuT9aa/3pJC8fEPr4JJ+stb4ivc0TVyx+UGttJ3lSkp9L/83697kmyQ+tKuFjTCllqdb6jCTvSHLWgPDvSvKsWus/pbfR6n+VUm5b7Vy11u1JvjK91/rJSS5Ye8YAABztSimvrrVelOR7B4RekOT1ST5Ra/3dJG8ppXx6tfPUWqeSXJjksUmemN516qBiamv1VcuPV9daL0/yf9PblP+/SylL/ToekOdxSb42vUJ2l6yiyy+uduyjUSmlu7xB/m/0Cesk+Z1a6zck+bX03jsrFs6otW5K8g1JfjLJw1cIe0mSnx8m5xF4dQ5e856U5A211tcn+bVSyjv7DVBrfVSSn07y9auY71NJfmaYRA9USrmz1vr1Sf4ryYl9QjtJfjzJ82qtr03yV0neWUrZtdq5aq2np3f/4LL01qP9Ci0AAMARSdEDAAAAxuYTr7nk0tw68x/N3Gzam/em+cIJyaYmC0+/+S5x7duTmXfMpNmzaaJxSe8fYnau3Jali+5I58ptmb/stjRnHPyPyScVd9uOrTnpzvlMf3BbFh5zRzb99amreq4PtGN6Nifc447MffPN2ffXzJuu356b3nHPPGzvDVl4zK67jHvD7JZ8ZNvJefzmq+7SZ38u7zwhnRtn7jLHDbNb8vnzpvLgJ3/8Lr9fa5+brt+eT33k7Dz2gg+nNdfO7BvveryjOpZJHf8odTYvnZHkrVdedcml/iEorM0ny9Oe3+1Mv7z7oI1xbr+79u1J5xNTWXrgYu/nGe1Mv/24zH3bwd9nk4j74mVLuekdpx/yHLlaR/s5fthjmcTxj9RJi9OLJy3+1kf+5kmxARuszSdec8mlS62p/1g6b2FDnNsPFbcea66V4q595FI+9ZEz81UP+Gim//3gc/Fq3P28OLd3Oum2csdtx+XEnQuZfv/xad88k3aaJEv7+xxJ5/iNuiYbuZnm7Fj7wJq573Z033dbz3XMRlyTjZr7bjA8993cdxvUx323FbjvBkNz323977uN6xy/nt9x7rsB/bjv5r7b3fsczWuyUXPfDQAAWKM/TfJTSR4w6YlLKb9Va704ybcNCD0uvUIGL6y1vj/Je5NcneTOJNNJTk3y4PQ2Iz15ldPvTPKNpZRbh0j9mFBKubbW+sQkb0ty2oDwdpJvXH50a60fTvLBJLck2ZFk3/O8Kcn2JGekV0zhgUnOTHJwtVkAADjYD6Z3zf+/VhH7wCSvSpJa63XpFfS6Nr1r0x1J9qR3fbo1yelJ7pnkvPTWRqMucrCSmfQKF3zt8n/vrrV+PMknk3wpyY1Jdqf3D7K2LOd6dpIHJXnYGvJ8c5K/GFnWR65XJvmBJOcMiLts+XFdrfUdST6a3vtmT3rr03sneUiSR6f3uqzk/UlelPUrevD3Se6RQ39evj7J19daP5femu+T6R1jK70123lJHpfkPquca3eSby2l7D7cpJP9hRKfluRf0nvO+5lJ8uzlx+LyfYOPpPc537ce7aT3eTk5vfXofdM7R9xjFPkCAMBG1l7vBAAAADiqvbL16RPTnHVHWp8+Ma35duafcNtBQVOfTdYjLkmm/+PEzD/htv0/M3vof04+qbip6aXMvKX3u5m3nHjIvoNMN92DjvfD7zs3F950yyHHfd/203PxrTcc1GdfLq35g28fvG/76Tn/kVcd9Pu19vnw+87NQy7+VDLbHPJ4R3Uskzr+MXnlpCaCo8aOTS/ZSOf2u5v6bLJ4TrP/577z/nrF9TtHrtbRfo4f9lgmcfzjsHS/vS8d+yRw9HnlRjq3HypuI63N9p0jVzoXr0bfc/wV29JaOPLP8Rt1TTZG1j6wNu67HcX33dZzHbMR12Rj5LsH1sp9N/fdBvRx360/991gKO67baT7biM8x6/nd5z7bsAA7ru573aXPkfzmmyMfPcAAAADlVIWk/zCOqbwXUnesMrYVpKL09vo9GVJfi/J7yb5xfQ2219twYM9SZ5WSvngmjI9BpVSPpHeRp6fWUO3dpIL03ttfyLJryR59fLj5em93743vY1d7xMFDwAAWKVSylKSZyb54zV2vUd6a4YfTm/98Iokv5/kt9O7Xv2RJM9IbyP7SRU8OJQtSR6eXmG4n0pv3fOq9NY+L09vA/3vTvKorD7Pjyb59lLKof/4eAwppcwl+Y4kB1eeP7R975tfTPJb6b0Ov5nk+Um+Jv0LHnwuydNLKQtDJzwa352kXzX2s5I8K19et70qyYvTe55WW/Cgm+T/K6V84DDyPEgp5b+SXJrkpjV0m0ryFUm+J73P0EvSe91eld5r98L0npNLo+ABAADHCEUPAAAAGItPvOaSk7PQPr9pJ+3d7WSpndbeVppT7/a3uIWkfUc7E49LkjvayWI7zWy393PrUprtS+sWNz/XydapubR2ttNs7aZ983T/J/kQ5lqtbJ3ae5fjnZ+bSnfnVKb25KBx59rt7G1PZdvUnrv1Wc7lznbat03ddY52O0ubm7ROuevfOtfaZ35uKnv3zGbb7O40m5qDjnd0xzKZ4x+jB1951SUnTWoyONJ98kVPPSdNa3ajnNsPspC0drfSbFvq/dzS9M77h/g+m0Tc3LaseI5craP9HD/ssUzi+MelOWlp9iN/8ZT7jX0iOEp84jWXnNw0rfM3yrl9w6y5Voib25blc+SeQ56LV2Ol8+LCfCdbOvNp7WqndfuRfY7fqGuyMbP2gVVy3+3ovu+2nuuYjbgmGzPfPbAG7ru57za4j/tug7jvBmvjvtvGue828nP8un7Hue8GrMx9N/fd7t7naF6TjZnvHgAAYLX+NsmV6zHx8gaQz0jyZxOa8sYkTyilXD6h+Y54pZTPJPnKJG9c71wAAKCUslRKeU6SH00yt975bHDvTfLVpZQd653IRlFKeVd6m96PswjEF5M8sZRy7RjnWJVSyu1JnpLk82OaYiHJt5VS/s84Bi+lvDfJI5O8cxzjAwDAsUDRAwAAAMbljMy3kxMWk/l2ms3dNFu7BwW1FpL1iEuS9u3L/9hy+Wf2HHqZPKm4+bmZ/f8AtLVzuCX7fLtz0PHu3TPb+0eOhxh3b3sqm7qLB/XZn8vmg5+7ve2pHD+7++C519hn757ZbNo8l+xpH/J4R3Uskzr+MVOxHVaryfkb6dx+d62FpGm1v/xz+by/XnH9zpGrdbSf44c9lkkc/1h1mgsmNxkc8c7YSOf2Q8VtpLXZvnPkSufi1VjpvLgwP53WrnaaTUf+OX6jrskmwNoHVsd9t6P4vtt6rmM24ppsAnz3wGq57+a+24A+7rutkvtusBbuu22Q+26jPsev53ec+27AAO67ue92lz5H85psAnz3AAAAA5VSmiQvXMf550spz07y3CQ7xzjVW5NcXEp5+xjnOCqVUm4upTwtyfcnuXnC03eT/GsSG7UCALBfKeV30tsM/R3rMP1n/n/27jxOsqsu+P/n3qrqZTL7JJkEAlmYkBBCCBh2GEgU2RdRZBFQfBQVcEF9BH0eORzUB8ENFXdF1Iggq0Dkp2AIYYcAAZKQgZCFQDKTZTL7dHdV3fv741ZPema6lq6utfvzfr3q1TN1zz3n3Orqc+75dtf5Ap8fQrudqgJ/CGwPIewadmdGTQjhX4DnAXv7UP2XgEeGEK7vQ91dCSHcBDwW+HqPq74DeHoI4d09rvcoIYSbge3A/wUO9rOtRcwB7wfqA25XkiRJ6hmTHkiSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEkamBDCR4FPDbkPfwU8GHg3xUb3vfJd4KdDCJeEEG7tYb2rTgjhb4GzgTfR/yQE3wReB9w/hPCUEIJJDyRJknSUEMLXQwiPA34c+Gqfm9sL/D3whBDCthDCR5Zw7kuA3wa+QG/XOov5OPDQEML/DiHM9LmtsRVC+CDwCODLParyEMX65bEhhNt7VGfPhBC+DzwK+AN6s4H/+4ALQwgf70FdbYUQaiGE36NYj/4V/U9+8CXg1cCpIYQfbSSLlCRJksZSedgdkCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkrTq/Cbw6WF2IITwXeCFMcY3AL8AvADY2kVVGXAl8A7gnSGEaq/6uNqFEPYAvxVj/B3gRcDzgUuAiWVWfQ9wBcUmrR8PIXxrmfVJkiRplQghvAd4T4zx8RQJBp4DnLLMauvAVTTuT4HPhhDmuuzfNcA1wO/GGE8GngI8HngscB6QLrOvtwL/CvxLCOG6Zda1aoQQvh1jfATwTOC3gEd3Uc33gb8D/jqEsKtJmVaJFW7ros2uNJJg/EaM8e+BXwd+AlizhCrqwGXAH4QQhhI7aCSUeGWM8beAlwI/BjwOKC2z6l3A5RQ/6x8zYaIkSZJWEpMeSJIkSZIkSZIkSZIkSZIkSZIkSZIkSZKkjoUQkmH3QVL3QghnDLsPACGEzwAjMZ6EEK4HfjnG+KvARcATgIcDDwDuB6wDpoEacAi4C7gJuB74DPDJFhtO9rKfNzOk1yyE8AbgDcNou9H+YeDtwNtjjOuARwGPAB4CnA6cBqyn2ESzBBwA9jcee4AbKb5f1wPfBL4ZQsgGexWSpEG6cNuVI3GfIWnpQgjvoEgoNtIaG7F/Osb4C8AFwCMp1hFnUdyjbqG4P50CZrj3/nQfxebz1y94fCOEsK8PfbwD+JfGgxjjeor76HOAbRRrntOBDRTrnrUU99P7gb2Nvu4Cvg58tfH4Zggh70Nfr2B4652fAn5qAO3kwIeBD8cYHwBc3HicQ/F+mX/PHKL4Hnwf2AF8jWKD/K+1e+1DCBf17QK60Egw94oY4y8DP0RxvQ8GzgY2UbznahTXewtwHfBJ4D9DCDuH0uljNJLx/Tnw5zHGzRQJKx5JkUTkdOC+FNexhuI9fIDiZ2c/RcK9G7j3Z/26EMK3B3wJkiRJ0sCY9ECSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnSqhdCqANfaDw0okII+yk2/Pz4sPsiSZIkNTah/1rjMdIaiRX+p/HQEIUQvgN8B/j7YfdlEBqJ7D7ceIytEMJu4D8bD0mSJEnHSIfdAUmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSNJ5MeiBJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkrpSHnYHJGnUxBjfAIRh90OSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEkademwOyBJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJksaTSQ8kSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSVJXTHogSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZK6YtIDSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZLUlfKwOyBJoyaE8AbgDUs9L8Z4LXBer/sjSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkjap02B2QJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnjyaQHkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiSpKyY9kCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJXTHpgSRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ6opJDyRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJUldMeiBJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkrpSHnYHJEmSJEkr1k4mMthbhjMyksMpJMcXyiswjHIA2YaM5EB65CvT2VDLTUzOkVdykgMp+drFz21nIqsXdS4wNT3Lvtr0ovVOZTVm0vJx5xzpy+Hj8yVOZTX2z645vu0lnjM1PcvM4UmYzsgX+Sb16loGdf19dvugG5TGVsJ1ozS2HyuvQJJn935dmxw3Bg2yXKsxslMrfYzv9loGcf19VU+uGVxj0tjbOUpj+2LlRmltNj9G5muzRcfiTjQbFysTVfJyTjIz/mP8qK7JBsC1j9QZ424rOO42zHXMKK7JBsC5R+qUcTfjbm3OMe7WIeNu0lIYdxuRuFuvx/hhznHG3SS1YdzNuNtR56zkNdkAOPdIkiRJkiRJkiRJkiRJkrQKDfyv5SVJkiRJq8O5L7nybirZdUkG2ZoMShn5VE5y5zH59yqQrc8YeDmA9RmUM5LZtPh6oERyT2lo5SYm6xyoNTYhOJCSnVht/SIvYjLPOVCbOup6JyZrpGtr1KY5rt7JLGMqqxUfkjzqnEZf1mVkG2tHt5FllA4n5HdVjnp+qedMTNaKD2jOriGZSY673t5dy2Cuv4+uvXDblbsH1Zg07s55/UduIMlnR2VsP04F8jU5yb5S8fVQUoz7i8xngyg3uY+mY2SnVvoY3+21DOL6+yXZXZo9/2WX3dj3hqQV4tyXXHl3kuTXjcrYPjJrriblJvc1NmqZnV50LO5Es3GxMlHnUH2C/ISMfMN4j/GjuibrM9c+UoeMu63suNsw1zGjuCbrM+ceaQmMuxl3a3+Ocbd2jLtJS2PcbXTibj0f44c6xxl3k9SccTfjbsees5LXZH3m3CNJkiRJkiRJkiStQCGEK0IISYvHFcPuoyRJkqThM+mBJEmSJKmfXpWfvYfklvXkZ+8hn8iY+NjG4wrVzoBhlAOoXrKHiY9tPPKV2WSo5erVlLknF8/NPXnPoue2U03S4673gkfs4OqTTly03ovu2cVVm7Yed858X/KJ7Lg2LrpnF9d9Ydtxzy/1nAsesYOvf+kcmE0Wvd5eXcugrr9PXj2ohqQVY/PM60ZpbD9W7Qwo35Ac+To/7g+rXKsxslMrfYzv9loGcf39ULpx6nV9b0RaeV41SmP7YuVGaW02P0Y2G4s70XKM376PvDL+Y/yorsn6yLWPtDTG3VZw3G2Y65hRXJP1kXOPtFTG3Yy7tTnHuFtrxt2krhh3G6W4Ww/H+GHOccbdJLVh3M2421HnrOQ1WR8590iSJEmSJEmSJEmSJEmStEoleZ4Puw+StCLEGK8Fzlvk0HUhhAcPuj/SsWKMJwPlRQ7VQgh3DLo/kqTV4/pLtz+Juyf/McvKZyRTVdi5lmxDTu0x+8lPqh0pl+6FypcnyA9WGGQ5gPJ1E6Q71pCdNkP6vSlqFxwi31Qn31wfSrk9TDG1K2XtjSWy+81S+eI60rsqS3rdd1cmqZx2kPIldx+53rt2bWTvV07igdW74IyZo+rdNbmGm9as50Ebv8/EJXcdOWfv7hOY2pWy7usV0nsqpHvuvZ3YNbmGOx6QcOZjbyI9sXrk+aWec9eujXz3xlM5/5TvMn0wo/L5o6+3V9cyqOvvlfrh0s7SdP1FF2678oqeVz4A3n9q2HaEZ/1KfU36luz+hyujMLYfWy7dC6XvlKmflFG6MyWrVEi/O0ntkQeOm88GUe72bSX23rh50TGyUyt9jO/2WgZx/T1zd7lavmnyN85/4Uff2tuKpdXh+ku3P6meVP6tfp/6KaMwti9Wbhhrrmblbj8n5bu7T+a89bex/prScWNxJxaOi/nj9lJvzLf796xh8s6Utd8sU9pbZs09yVHnjNMYP6prsp6aS25mIn/5uK59pGEy7ray427DXMeM4pqsl8Y97qbRsJrjn8bdjLsZd+uCcTdpWYy7DTfu1s8xfphz3LjF3WZnKmTZ8ZuQp2nO5FSTdZNxN6lrxt2Muxl3645xN2nlWM3xT0mSJEmSJEmSJEmSJEnLsyqTHsQYXzbsPoyRz4QQvjPsTkjjwKQHGnX+0bEkadiuv3T7Zu6aOiefSM7PKtk5zJROzafYmk/nk0eXzMvJHNNkyRrSbA1zaYUKE0zm6dHF8owqGRnkaQ5zJZIKafflqFOlTkaSp3lOniRM5EmSJOVuy+U18qQOeSmHegKTOUspN5uUkrmsVErrJGkCyWxStJ+SkVOFpMqxy/qEWk5ShfwgJAdm5yqHq9VyWpmu1dI831+vlr6/P5m8o5akJ6+dOnzfclpbV5pJjnwPZrNyuTpbnq4k9al0un6kr9US5SRJKxPVelJKsoT83g/TV+tptUZKuZJl5NSOO2eunpeSvDT/fEpem8tK9bl6KZuYqJNDBjCXldJamk5MrKkyUa8lpZk0XXhOda6U12sl0hPqtYXnZFkyOTVZS9JyLV94Ti1Ls7nZSr2cZFk6Xc8WnpNnSXlqqlpKSnUWnlOtp9XqXCUrJVktnb73Q7tLvZYjxxNqOewHZuafK5HPzn8vauX0lqySHFp4TuXkwzesf/DuL1247crdjDHvPzUqdrzxGWdlm7JHZ5P1beTJmdma/CSSZMNxBeeYSrJkHWk2Rc5UPpFX+jG2H1cuyTOyPCclyTPytJ4mZEnpqHlq6eUSUsiznLRWgjw5bt7Lc2rkGceWmy2XSrPVclIqZ6U0JUlm0hzynIQaOXXypMoxYx1AnjBLnsyQsn+mVj44W5vIKpVaJa3n+9ISd+zLJ3cdKlfKa6cPnTo9V9u6cO4BqM6Wp7I8Wbdw7hn2GD9/zrFz3Px8NTldTSfqNdLZ9Mik2Gq+ajXH1eZK1VpWSpd7LVDMPUmaz2RwmCw5Mi/Pfy+qpfTmOqW7Fp6ztjJzzwnp3OfPf9llNx77vZW0dNdfun1zPa9cRJI8NM84nWrpvmTJusXWPuT52iThhDzLJ5N6Onnc2E7zMXs55ZJqnuc5OUmeJLOlnAnKyy3XWCMteW02Wy6VZignaZqlpRmSNE8SICMnA2ok1CCpLbr2yZPDwKHZWuXg3tk1JHmeVCbrtTzN765XyztnJtIapfzETbWZdRXqR83/s1m5XMuTtRPl+vT8c6Mwxjeb40ZhTbbYtRz5dqQcJskPLJx7SuSzpPkdebV0Wy1Jdy1c+6ytzNwzfb/9N2Wnz+0Y97WPNAqMu63suFsvYlXG3QorJe6m0WD807ibcTfjbkeeN+4mDcxqi7std23Wq7jbTHWiWsozKtO12nys59BkWs3S5JTpmfpJvYi79SpWtZLjbjPVSpKTJAClnNn5GGg9SXZNT1fvnC9v3E3qLeNuxt3mnzfuZtxNWm2Mf0qSJEmSJEmSJEmSJEnq1mJ/eLQavAOO+zNZLe5nAZMeSJIkSVq2c19y5W7gc42HJEkDcc7rL7sRcEMpSdLANNY+/914aECObLpw4LhDbrogacUz7iZJGgbjbpKkQTPuptWs5aazv2T8U+oX426SJEmSJEmSJEmSJEmSJEnS0qzWpAfzkmF3YMSZGEKSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS1NRqT3rgpv7NmRBCkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJktTSak964Mb+izMZhCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiSprXTYHZAkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSeOpPOwOjJh82B0YomTYHZAkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkjReTHhzNjf8lSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSeqQSQ8gp0h2kAOvA/59uN0ZigS4kXtfC0mSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS2jLpwdHuDiHcMuxODEOMcdhdkCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiSNmXTYHZAkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSePJpAeSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJKkrJj2QJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEldMemBJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnqikkPJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElSV1Z70oN82B0YQb4mkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkqSOrPakB5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkqUvlYXdgSL4L5Is8v3/QHRkhviaSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSpCVZlUkPQghnDLsPo8bXRJKkwbn+0u2buWvqnLxUOjPbXN/U0Ul5tibPOJ00PWmRo4cguTlJ8rs6PqeS3wncktSSQ0c9f5At5MmZ+Qn5muPamMjvJmfXUefk2RoOJ1vJ0i1LOWcg19JCtqV+Q31b9UsXbrtyd6fndCrGuPmU0+48Z8tJexa7viMOH5pcm+fcd/qEmQ2tys0cnrgrz9LKqJbLsmSuVi0zMVmdaFWuMlHbm8D3q3OVA63Kbdi8/86TTrlnRz++N5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZJ6b1UmPZAkSRqG6y/dfjF3T749m914RvUJB8hPmml7TroXSt8pUzs9J99S76idbs4pXzdBumMN1ccfID+p1lEblS9PkO9ZQ3Ets33pVzfnLMXV1zxxJ1P5iy7cduUVy60rxnjxyfe56+0XP+OGM9ZvPNi03J07N3HrTVvZ9qBbWQ3lunXVNy++uVypv7wX3xtJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ/ZMOuwOSJEmrwfWXbr+YeyYuz/euO2PueXs6TixQur5M9eG1pSUJWOI55esmKF29nrkf6bxfE5+dgJ3rGbVrWbKp/BTgE1ffsP1Jy6kmxnjxiVt3X/6Yi7/WNuHBt645g4c/5vq2CQVWQrnlKFfqZ9CD740kSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKk/jLpgSRJ0mC8Lfn2RuaevKfjE8o3Q21bvqRGujmncvnS+zWq17IMb1vu+Q+56FttC33jqgeymsr1yHK/N5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZL6yKQHkiRJfXb9pdu3UE3PI0vJT6p1dlIVkkMJ+ZZ65w11c86+FGpL61e6L2Ukr2V5Hnz1Dds3d3NijHFLZaJ63vqNB1uWm5stM3N4ktVSroe6/t5IkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ6j+THkiSJPXfKcyl5Guzjk9IqpAnS7tV6+acdO/S+zWq19IDp3Z53ilT07NtC80cnmQ1leuxbr83kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkvrMpAeSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJKkrJj2QJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEldMemBJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnqikkPJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElSV0x6IEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSulIedgdWixjjOuBhwFnAfYATgAlgFjgA7AJuB24CbgohzA2pq5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkdcSkB30UYzwd+CngOcAFQNLhqVmM8Ubg6yGE5/epe5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkLYtJD/ogxngW8CbgeUBK58kO5pWAs4FtPe6aJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEk9Y9KDHosx/hrwu8AERyc7yJdY1VITJUiSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSNFAmPeiRGOME8C/Aj3FvwoJjEx10mshgqQkSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEkaOJMe9ECMsQx8EHgKRWKDhUkLjk100CyhQacJESRJkjRkO974jLOyTdmjs831TY8+Zcup1x4+bfGC+xOSfSnMQHpPi1vvXperAfshOZiS7G5xm9nHcsxAcrgE1YS5pMTsXJlyAmmek8x1duublyjukudK7/rUx3707tnaRFap1CppPd+XlrhjXz6561C5Ul47fejU6bna1tJMMrnw/OpseSrLk3XpdP3IizWXldIsSyanJmtJWq7lpZk0PdL9LM3mZiv1cpJl6XQ9yyGbPyfPkvLUVLWUlOosPKdaT6vVuUpWSrJaOl2/t+0S5SRJKxNz9byU5KX551Py2lxWqlfzNC1Xsoyc2nwbtTSdmJyuphP1Gulsmiw8pzpXyuu1EukJ9drCftXSdGJiTZWJei1Z2K+UvFabK1VrWSldeC0AaUItSfOZDA6TJbUjzzde12opvblO6a6Fr+Xaysw90/fbf1N2+tyOC7ddubujb6Cknrr+0u2b63nlItLS2S0L5tmaPON00uS+ecYmqslGsnSKqezoiSPJ58hzkiSZyrN8Mqmnk2RJick8Paq6nBp5BinkWU5aK0GepIuVS6p5nufkJHmSzJbyZ5xaqeQTHFcurWX5N/7hydl8OSYoN6uPjCRPc5grkVQ4rl3yPKNKRgYLy82WS6UZykk6UUvL1TRNZhKAjJwMqJFQg6S2SLrKWp4nh4FDs7XKwZnqRLWUZ1SmazXS/I68Wrrt0GRazdLklOmZ+kkV6hsWnj6blcu1PFk7Ua5Pzz83qDG+1XzVbI47Ml9V60kpyRLye+foaj2t1khZOF8ddU6TOW6uXsomJuosnHsAkpTDJPmBhXNPiXx2/nWtJemurJIcWnhO5eTDN6x/8O4vOfdIw3H9pds3c9fUOXmpdGa2ub6pacE8W8PhZCt5cmpeYiuz6Ya8wrrj5h7yLJlLauRJmTRbw1xaocJEp2P78eWoU6XemCty8iRhIk+SJCl3Wy6vkSd1yEs51BOYzFlKudmklMxlpVJaJ0kTSGaTov2UjJwqJNVF5x6SKuQHITkwO1c5XK2W08p0rZbm+f56tfT9/cnkHbUkPXnt1OH7ltPauoVrn9msXK7OlqcrSX1q4dqn3RjfzTrm2DG+3XzVbI4bxJoMirVPDvuBmfnnSuSz869rrZzecuzcs7Yyc88J6dznz3/ZZTciaSgWxt1aFjzIFvLkzLycn0SWbMkms7VJkkwfU6pGlSzJkjJpPkHOVD6RV5Y1ByR5RpbnpCR5Rp7W0+S4tdTSyyWdrLkWW5vNlkul2Wo5KZWzUpqSJDNpDnlOQo2cOnlS5Zh7c4A8YZY8mSFl/0ytfHAlxN3mzzl2HWPcTVI74xh3axVPa1eu8zVXm7hbmqWlGZI0TxJWadztCVvKabWeZo35KkunsiyHLCHnY3/7/MS4m6RmjLsZd5t/3ribpEEy7mbc7UgbKzDultXTu49d+xh3k4bPuNvKjbt1s47x790kSZIkSZIkSZIkSZIkafUw6UFv/CXwVIqEBvN/PrhwJ9fj/6TwaM0SISxJjPEngFcCX1nwuDaEUGt5oiRJkjqyIzzrNfU16ZurTz5cyU8qbrGm9+yBTx+d9KB83QTpjjVkp82Qfm+K2kMOkZ+cwU76Wi7dC6XvlKmflFG6MyWrVCjdvJajt5seTLn0u5Pcvq3M3ls38sD63Uzef4bKl9aR3lVZwisOuybXcMe25PyzHnMT606sAnDnzk3cetNWzj/lVk47mFH5/DrSu+79/OfuyiSV0w6y9pI7mf8+3blzE/u+soUH1u+GI32ZOtLGTWvWc97G77Pxkp1LPqey4Jw9u9cyvSvh5K9XSO+pkO6pHHUtO7clnPWYm0gWuZbpI9cyddy1rLnk7qP6tdRzemH+kzxXX/fEm5nIX37htiuv6Fnlkpq6/tLtF9fTyjtrZ5dOybdUgeqi5ZqNxbVHHjhqLFhquWzhHNCkXOXLE+SHKiSTVdi1lmx9Tu0x+6mvq5FlRQgk3Q+Vr0+QHy6TTtYp33nCkXKd1tdJudvPKfHd3Sdy/im3sv7gbGOMXPrcMz/Gr1tkjN9yZIwvA6Uj59wxpDG+mzmu3Xx17LV0cs6xc1wvffkbF+8sTddf5NwjDcb1l26/mLsn357Nbjyj+oQD5CfNLFru+LG4P2P7seWgyRppS418U30o5e7Jp5nelbD2xhITp812tfaZH+PXHTfGb+CBtYVjfLH2OXpNcnvHY/ww1zGDWJP1Qg24+ouXVMs3Tv7G+S/86Ft7VrGklhaLuy3m6LF4kvpDDpFvqbcZsycbY3a7cs3ngKWskQZR7vZtZfZ+p4i7TSwv7sZKibsNa03WC8bdpOEY57jbMMrNx93OW387m65JSe+ZbMTHOrfS4m63nLCBs9fvpPy4O8i3FOfs23MC03fBid9MjLtJOo5xN+Nuxt2Mu0nDYNzNuJtxN+Nu0qAZd1u5cbdhrmP8ezdJkiRJkiRJkiRJkiRJGh9p+yJqJcb4o8DPcHSyg8USHsw/vwv4EvCfwEeAzwD3HFO2W+8BzqRIfPD3FEkP9scYr4ox/t4y65YkSVrVdoRnvSYrVf547kfvafsB0NLV68nOOUTp22upPuYA2bY58vVZX8ule6F0fZn6A2qUbkupb0kpf+MEatv3D6XcbT+QcMe1Wzlvzx7yCw4y+dHNXX0A9LvnlHnAs7511IdjvnXNGfzAmTcwlVaZ/MjR9e6uTLLh1H2UXrDrqA/H3PnZ+yzal12Ta7hm/RYese4Wyi/Yuaxz9uxey+b9c6z/3BTlm6aP+tBRL69lqef03ER+BvCJq2/Y/qT+NCBp3vWXbr+4npQvrz6yekq+pd60XLOxuPqMPcd/sLPH5SY+OwF7pkhLVbh1A6Qp1Wffc3S5/TBx1QTsmyQt1eD76xYv12l9Tcrd9kjYcev9mo6RnRi3MX4Q81W35/RSabp+Cs490kBcf+n2i7ln4vJ877oz5p63p+k95XLH7G7LQYs10iKb6Qyi3D35dDFGfnWS+vmHulr7DGqMH+YcN4g1WU9trlVqFx38k2ve9bRf6X3lko617Lhbn+eAYa65jLuN9pqs54y7SQOzYuJuAyo3H3e76D43suELE8eNxZ0YtzG+k/nqwhO+R+nZRyc82HigyrqrJo27STqOcTfjbsbdGoy7SQNl3M24m3G3BuNu0sAYd1u5cbdhznH+vZskSZIkSZIkSZIkSZIkjReTHixDjHEa+JMFTx2b7CBvPHcn8DrgvBDCfUIIjwohPDOE8OwQwhOA1/aiPyGEOeBPuTfBQgJMAg8HXhtjvH8v2pEkSVqVdk+9ae7Je9oWq1y+kbkn7znylcnF81r1ulz5Zqhty498nfhYo/yQyn3jqgfy0DvvZu7Je5j42MZF+9zOVZu2ct4jbzjquW9c9UAectG3YDJftN5Knh3Xz1Z9uWrTVi66Z1dPzilX6kx8bCPJ3PHLrF5ey1LP6aO3DaohaRV7W21b+/yIw5wDkm9vJD99H8m3i/Fv0XK3QnLjevL77ie5cT1JtUm5TutrUq7dGNmJcRvjBzFfdXtOnzj3SP33tuTbi4/7Cy13zO62HAxvzdWs3PwYuZy1z6DG+GHOcYNYk/VD/ayZ3+97I5KMuxl3a3vOqK7J+si1j9R/KyPuNqBy82Nks7G4E+M2xncyX1WfuPf4a7myiH92ci1HzjHuJq0Wxt2Mux11zjityfrBuJs0IMbdjLu1OWdU12R95NpH6j/jbis07jbMOc6/d5MkSZIkSZIkSZIkSZKk8WLSg+X5GeA07k1uMG/+/wnwVuCsEMJbQgjXD6BPfwns5d6kC/N/LZoALxhA+5IkSSvOjjc+cxt5MpmfVGtdcF8KtZR8Miu+rq2Tb6r3v1wVkkMJ+fp68XVNTnIg5bj+Dqjc7HrIDpQpH4Z8bUZ6V6X167aI2TSlPp2TnFg98tzcbJmZw5OsnzxEPpUfV+9skrC2PHNUP+dmy037MpumzKRl1pcP9+CcEmvLsyT7U9I95b5dy1LP6bMHX33D9s2Dakxaba6/dPuWPE/Oy7csMu4vNMQ5IN2XkqeQHkqhnpLMJMeXq0G6v1HucApZk3Kd1tek3Ox6Wo6RnRi3MX4Q81W35/SRc4/UR9dfun0L1fQ8skXG/YWWOWZ3XQ6Gt+ZqUu7IGHkg7X7tM6Axfphz3CDWZP2Sb65PXvPPzzir7w1Jq5hxN+Nu7c8ZzTVZn7n2kfpoxcTdBlTu3rjb4UXH4k6M2xjf8Xx14r3nVOdKrCnNkRxMSfcad5N0NONuxt2OPWec1mT9YtxN6j/jbsbd2p8zmmuyPnPtI/WRcbcVHHcb6hzn37tJkiRJkiRJkiRJkiRJ0rhZ+l/EaaFXc29SATg6wUAGvCKE8PZBdiiEsD/G+H7g5Qv6M5+E4cXAHwyyP5IkSStCznn52qxtsXRv4wP3ja8cTmH6+A/v9LpcUoU8SUmq9eLrgYTF+juocjOHJ4sPnazNSA50l2dtJi2zbvLQ0c8dnmRqehYOpyT15Lhz5tISlbVzx53TrC8zaZmprHbctXVzztzsBJOzVfLpjGS21LdrWeo5A3AqsHvQjUqrxCl5kgKtPwQ6zDmAuRQ21GAuJZ/OFo0yJVWgmsL6GlRT8qkMSvni5Tqtb5Fy7cbITozbGD+I+arbc/rMuUfqn1OYSxcd9xda7pjdbTkY3pqrWbkjY+Qy1j6DGuOHOccNYk3WV6X8fODGwTUorTLG3Yy7tTlnVNdkA+DaR+qflRN3G0C5+TEyOZAuOhZ3YtzG+G7mq+pchYnZWhH/nD3+HONu0qpn3M2421HnjNOarK+Mu0n9ZdzNuFubc0Z1TTYArn2k/jHutkLjbsOc4/x7N0mSJGm4YoxPAj7RosjFIYQrBtIZSZIkSdKqEmO8GTi9yeF/CiH81OB60xsxxiuAJzY5/MkQwpOWUfcbgNDseAihu004MD6g3osxHr/pzILDIYQ3DKovkvqnn3OTpPHQ3V9kixjjBcDZjf8uHCwTiiQDbx50woMF3n9Mf+ZdEGPcNujOSJIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZJWJpMedO+Hjvl/zr0JBq4F/u9gu3OUjwEHGv8+NpPVJQPuiyRJgp1MZCQHOr/1yiuQ5NmSGunmnGzD0vs1qtfSA7d3c9LU9CwzhyctJ0mSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJGlVMulB9x7Z5PkceFMI4dhkAwMTQpgD/pN7kzAstH3A3ZEkadU79yVX3k0lu440I7mz3NlJFcjX5CR3lzpvqJtz1mdQXlq/svUZI3kty3Pthduu3N3NiROTNaamZ9m35wTLSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSVp1THrQvQcu+PfCBAeHgH8fcF8W81/H/D+nSILwhCH0RZIkwavys/cw8bGNHZ9QOwPKNyyWw6i351QvWXq/RvValuHVyzn5gkfs4OtfOsdykiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJklad8rA7MMZO4+hkB0nj/58NIdSH06WjfGHBv+f7BnBajPH+IYTvDqFPkiStWue+5Morrr90+8VJtv8fJ9638Yzq9gPkJ9VanpNtAM6tUflKmdrpOfmW9rcY3ZxTO28O2MfEBzZSfXxn/Zp77ByVL+9j4n0bGaVrWbKZZCdT+Ysu3HblFcup5sStezj3ghv5zjdO40EcGni56752Fg9Nbhm5cpIkSZIkSZIkSZIkSZIkSZIkSZJWphhj3r6UNFghhGTYfZCWK8Z4BnBTiyIvDyG8YzC96b2Vfn2SpNGy82/udN2ikXPKz53kukVaYWKM7wB+ssnhW0IIZwyuN5IkSZI0XCY96N7aJs9fPchOtPBN4DAwxdHJGQDOB0x6IDURY3wDEIbdD0krz7kvufIK4MzrL92+efILU+fkpckzs831TZ2cW/52tibfUTqdND1pkcOHILk5SfK7Oj6nkt8J3JLUkiM76uf3maH8jfIW8sqZ+Qn5muPamMjvJmfX/DnZCcCaQ2vK15S2klW2dHLOoK6lnWxL/Yb6tuqXLjz/k7s7PaedE7fu4eS5A3Dz5oGXO2ndHvh6aSTLSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSVrZTHrQvUqT5+8eaC+aCCHkMcYbgIdwfNKDbUPokiRJajj3JVfuBj7XeEiSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSNLbSYXdgjB1q8vzegfaitW83ed6kB5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKkZTPpQfcONHl+4yA70cbtTZ436YEkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkadnKw+7AGPs+cCqQH/P8iUPoSzN3LPJcApwy6I5IkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJGm0hhCso9ieRJEmSJEnLFEJ40rD70A3jA5IkSeqGSQ+6dxNw0SLPP2DQHWlh3zH/zykWDeuG0BdpbIQQ3gC8YannxRivBc7rdX8kSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKkUZUOuwNj7Npj/j+fUOAJQ+hLM7NNnl870F5IkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJklYkkx5073ML/p0s+PfmGOOFA+5LM1mT5016IEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElaNpMedO9zwFzj3/kxx352wH1pZkOT56cG2gtJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ0opUHnYHxlUI4UCM8XLgqdyb9CAHEuAnY4y/HULYPbQOFjY2eb46yE5IkiQNw443PuOsbFP26GxzfdNy60o2lM9MD/eiV5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZK0spj0YHneQ5H0AIpkB/PJD6aBNwC/NIQ+LXRKk+dnBtoLSZKkAdoRnvWa+pr0zdUnH67kJ9WWXd+dOzdxYP96HoRZDyRJkiRJkiRJkiRJkiRJkiRJkiRJ0uoTY5wCzgZOB9YBE8ABYC9wA3BLCCFvXoMkSZIk9U+MsQJsA84C1uOaZVWIMabAA4AtwAaK7/0JwCxwqPE4ANwK3BZCyIbUVUmSJElaNUx6sDzvBv6IYpE7H8jIKRIgvDLG+P4QwhVD6hvAI7m3XwvdNeiOSJIkDcKO8KzXZKXKH8/9aG9ud+7cuYlvXXMGTzjnG3Dz5p7UKUmSJEmSJEmSJEmSJEmSJEmSJEmSNOpijKcDPwk8DXgEUGpR/GCM8VPAfwD/HkLY3aTOKeDxLeq5NoRwe5dd7liMcRK4CHgc8FCKjVHvB6yl2CCzTrE55l3AjcB1wGeAK0IId/e7fxotMcYTgEdTvF/OB84E7kvxflkDVIGDwB0U75dvAJ8Grgwh7B9GnzsVY5wGfhC4BHgw8ECKfXTWATPAPcAtwBeAK4CPhhDqPWj3fsCzgB+g+Bk8pdHuNMVreTuwg+J1/HAI4frltilJklaeGOMm4KXAs4EnUCQ6aGZ+zfIh4N3N1iyjKsZYBh5Dce92HnAOcDLFPen8PdSdwHeAXwkhfHNIXe2rxuvwVODpwMOACyjuyTsxF2O8FfgWxf3tF4AvhBDu6UdfR02M8YEUr9e5jcfZwCaKRBHrgEmKNcAhYCfwPYq18FeAT4YQvj+EbnclxvgQivfIhRQ/L1sprrMC7KdYu30TuIpijfOV4fRUK9lKiD014iE/1Hg8hCK50Pza/QCwD7iJou+fBS4bt/l13DTmwScCT6YY08+hGMvXATXuTfTzbeBzwP9nTGXwGnGvZ1LsCX0exc/+OmCKIiHXbuBa4PPAh3px3xZjTCjGmx/k3vlvE/ful70PuJkibnl5o92RjVvGGLcAz6C4/30wRTx2PrnVYYrX8dsU1/Mx4PIQwsHh9LbQWJtcxL33WudSxDzn77XWUsSRD1O8B75HMf5/leK+9CoTdGklMenBMoQQDsUY/wH4Ne5NdpA3HinwTzHGR4UQdg66bzHGdcCDjnl6vn99/wWvJEnSUOyeetPci3sXr/vGVQ/kosdfU4SqJUmSJEmSJEmSJEmSJEmSJEmSJEmSVrjGRoj/D/gRir0zOnECxcaTTwX+MMb4d8DvLrJJ2ykUmxA183LgHUvq8BLEGC8Gfgp4LsVmQ82UKTZ83ESxEeRTgNcAtRjjfwN/Q7ERe77M/ryDIrHEUvxjjPEfu2zylhDCGe0KxRifBHyiRZGLQwhXdFDPOxjB6+tEjDGl2JT/pRSbZU63KF6i2LRsC8VeL89oPH84xvgR4C9CCJ/sRb8W6edPAa1erzNDCDcvct7ZFPvlvJTmm8SubTzuR5Gs5NeA22KMfwH8UQhhtov+Phf4deCxFPvgLGZ943EOxQbGb4kxXgn8dgjhyqW2KUmSVp7GhqKvB15B5xveL1yz/EFjzfI7x27OHGM8g2ID52ZeHkJ4Rxd9/im6u297IPBq4GUUm9Y2M38P9QCKDd5XVNKDGON9Ke4jX0yR7KEbExSvzwMokvsB5DHGzwD/Dry3XRK+Dt4fizk9xrictWO377n7Az8MXNx4nNrBaSc0HidRbHA+/zoRY/wa8M/AO0ZxU/NGksWXU6zdz25RdFPjcQ5FbOB3Y4zfBP4C+LsQwlyf+ncFxUbli/lkCOFJ/Wh3uXoVH1hCfYPW1c9XK6MWe+pGjPEsijH3pRRxgcVsaDzuB2wHfh6oxxgvA94cQvjsIPo6bmKMbwBCs+MhhEVjJTHGU4BfBn6O4j2zmDJFfOpEisRAPw78SYzxK8BbgPf0ekP1ft03ddj2G+jiteyw7itY4pjdSDrwbIqfnVZJf7c0HmdTjBO/H2P8NBBDCB/voq8bgF8Ffho4rUXRkxqPRzTKHmzEbn8nhLBrqe32S4zx8cBrKe5BmiVhno9Z3hd4EvCLwP4Y4z9TxCyXeq/WlUYy2Uu4917rQtr/PmU+jryJ4p70iRT3LwB3xhg/APxVCOHqPnRZGiiTHizfmymCHms5PvHB/YCPxxifOIRsWc+lGOwW9mneDQPuiyRJUt/teOMzt5GvmcxPqvWkvrnZMjOHJ1m/8SBZmpIcaP93edmGjORAeuQr04vHd3pdLq9Akmf3fl2bLNrfQZWbmp5lX22a5EBKvra7GNdUVmP/7NG/V5yanmXm8CRMZ+SL/B3TRFY/rp+t+jKV1ZhJyz05Z2JyjrySkxw+/nXq5bUs9ZwBMKGa1D87k7z9GDrMOYCJDPaW4YysGP8WCfXnFaCSwb4ynJaRzKQk5Bz7G7Ul1bdIuXZjZCfGbYwfxHzV7Tl95twj9c9OJrK295TLHbO7LQfDW3M1K3dkjFzG2mdQY/ww57hBrMn6qp5cM7jGpFUo4TrjbsbdWp0zqmuyAXDtI/XPyom7DaDc/BiZr80WHYs7MW5jfDfzVWWiSl7OSWaMu0lalHE3425HnTNOa7K+Mu4m9ZdxN+Nubc4Z1TXZALj2kfrHuNsKjbsNc47z790kSZKGI8ZYAn6LYvPQ5exHcgLwK8CLY4w/H0L4QA+6tywxxqcCb6TY1Gk5yhQb4D8d+EaM8ZeWsrmfxkOM8cXAbwPnLrOqaeD5wPNjjJ8CfjGE8LXl9m85GhuBvoFiA7ZmG4e1ch/g94CXxxh/KoTwmQ7bfSjw98BFXbQJxQaKn2xsTvwrIYRDXdYjSZLGXIzxOcA/UGwW2635NcuLGmuWD/agaz3V2MD2d4FX0nkyuhWnsU79JSAC6/rQREKxMfHjgbfGGNeN871mjHErxSbXLwQeQ/NEY914KPBHwBtjjH8EvCWEcLCH9XctxvjDwN8B9++yigcBbwN+Jcb46hDCf/Wsc1o1VkLsKcY4QREz+FWKhAxLVaLY9P3ZMcb3Aa8apc3Ux1FjHnwNxTzY7S+8Hw68C/ilGONPhxB29Kp/KsQYz6WIez2uyyoeD3wsxvhu4BUhhH0dtvsq4HdongijlROAV1HE8H8uhPCeLuromUZij7+kSMTcjXUU1/MzMcY/BN7Yj0RGMcYKRVKpFwHPoXlimG6cRLG/+StijB8FfiOE4N/ca2yt2kVsr4QQ7qJIfLBwUbfw3+dRTB73G2jHisG2mW8MrBeSJEmDknNetx84XMzM4UmmpmeL/6zPoJyR3Nnmb/Tmy82mxdcDJZJ7Fvl7n16Xq0C+JifZVyq+HkqKD8Ec298BlZvcB+naGrVpig+xnlht/botYjLLKB1OyO+qHHluYrJWfOBldg3JTHJcvZN5zoHa1FH9nJisNe3LZJYxldWKD9As+5w6B2qT5Osyso1HJ97o5bUs9Zw+u/bCbVeOXOZtaaU49yVX3p0k+XXJ3W3+bnSIc0C2PiPJIFuTQSkjn8qPL1eGbF2j3HQGaZNyndbXpNzkPlqOkZ0YtzF+EPNVt+f0kXOP1EfnvuTKu6lk15G2Wfssc8zuuhwMb83VpNyRMXJt1v3aZ0Bj/DDnuEGsyfol2V2aPf9ll93Y94akVeyc13/kBpJ81ribcbdhz1fG3aTVY8XE3QZU7t642/SiY3Enxm2M73i+uuvecyoTdQ7VJ8hPyMg2GHeTdDTjbsbdjj1nnNZk/WLcTeo/427G3dqfM5prsj5z7SP1kXG3FRx3G+oc59+7SZIkDVqMcT3wXxSbs/Vq0X4y8P4Y42/1qL4lizFujTG+F/goy9907lgPAT4RY/zrGGM3G8FpxMQYt8UYPwH8K8tPeHCsJwBXxcJQ9vuJMZ4GfAF4Ld0lPFhoG/A/McYXdtDuqxrtdpvwYKGfpdjHp5vN3CRJ0piLMb4J+CDLS3iw0FaKNctre1RfT8QYLwC+DryaVbxXZIzxJOBTwB/Tn4QHx0oZ49c7xvgE4PvAnwGPpbcJDxY6gSJZ4tdijI/sUxsdizH+P4p4RrcJDxbaBnw0xviWYa3bNH5WSuwpxngG8FngN+ku4cGxfhS4Jsb46B7UtSo15sFPAn9A9wkPFnos8IUY45N7UJcaYow/DnyV7hMeLPQC4DPt9q+OMW6KMX6IImHPcmNkm4B/jzG+bpn1dC3G+FjgGrpPeLDQJPB/KF7HM3pQ37GuBT4C/AS9TXhwrKcBX4kx/kaMsV/3dFJfeTPdG28Brm78O298TRr/zoELKQaLpwyiM412Htloe7HB6fOD6IckSdJKUr1kDxMf29hxuSPlZxdfK/a6XO0MKN+QHPk69+TF+zuochc8YgdXn3QiEx/byNyT9yza53YuumcX131h21HPXfCIHXz9S+fAbLJovdUkPa6frfpy0T27uGrT1p6cU6+mzD15D/nE8ck3enktSz2nj149qIakVexV5RvaxxyHOQfkZ+8huWU9+dnF+LdouftBftY+ku+vIz9rH3mlSblO62tSrt0Y2YlxG+MHMV91e06fOPdI/feq/Oz2a5/ljtndloPhrbmalZsfI5ez9hnUGD/MOW4Qa7J+KN04NbRfzkuryuaZ1xl367yccbf+XYtxN2lVWRlxtwGVmx8jm43FnRi3Mb6T+aryyQ3HX8v2Iv7ZybUcOce4m7RaGHcz7nbUOeO0JusH427SgBh3M+7W5pxRXZP1kWsfqf+Mu63QuNsw5zj/3k2SJGlwGpuHXwH8YJ+a+L0Y4xv6VHdTjc2SvkKxyVo//RzwycZGZBpTMcbnAF8GntTHZsoUm4P+R4yxF5vVdSzG+ECK/WYu6GG1k8C/xhif2aLd36PYgK2XmzM+luI1NNmIJEmrRIwxiTH+DdCPvztJgN+PMf7fPtS9ZDHGJwGfoTcbuI+tGONminXqY4bclXFyAstPbrYUDwCujDH2YoPiJWuMC2+n2KC9lxLgfwPvijEOLJu2xtNKiT3FGB9MkfDgB3pc9YnA5YPah3cliTE+gCKBZC820l9oA/ChGOMTe1zvqhRj/EXgXcBUD6s9H/h4jHFjkzZPorhHelYP2wR4U4zxlT2us60Y41OBj9O7pGbzLqJIfPDgHte7vsf1tVIB3gxc6j2JxpFJD3oghFADXgIcbDy1MPHB/P+3AJfFGP8mxnhyv/rS+GXyPyzoA8f8ex/wxX61L0mStFLVzpujfuE+Jj6wkeTOctty6Y411M8+QOVza0m/M0Gyu9TXctkGqJ9bo/SdMvX7ZJTuzqg95CCVy47u76DKnXoVbH3w7Vy3aRPJ105g9um7yU6sLuk13zp7iPt/q8Z3PvRAsruK9faJW/dw7gU38uWbzmYmqzD7zKPr3VydZe/t66m/e+uRfp64dQ9bH/e9RfuydfYQ5++7my/tP53qu09Z1jkbNh/knnUV9j1mhtqZh8k21vpyLUs9p+fmkpuBiy/cduUV/WlA0rxzX3LlFaW8dnHlC5Wdyd3Nf7c8zDlg7rFzsHGGrFaB++2FekblQ5uOLrcO5i6ag/WzZLUy3Hf/4uU6ra9JuVO/kHDu/W9pOkZ2YtzG+EHMV92e00v1w6WdOPdIA3HuS668gk1zFycb9t888b7ma5/ljtndloPhrbmaldvITDFGPmyW0jVrulr7DGqMH+YcN4g1WU/dXa6WrzrhNee/8KNv7X3lko51TvzwW9N69TUT79tUNe5m3G2c1mQ9Z9xNGpgVE3cbULn5uNtVtz2AvY+aO24s7sS4jfGdzFdXHzyN2odOJrm7OGfdxkPsXVtm/0Wzxt0kHce4m3E3424Nxt2kgTLuZtzNuFuDcTdpYIy7rdy42zDnOP/eTZIkaTBijFPAh4CH9bmpEGN8cZ/bOCLG+FzgE8B9BtTkoyg2cTPxwRiKMb4K+ACD27TqmcBHBpX4IMa4Ffj/gPv2ofoUeGeM8ZxF2v094Lf60CbAE4A/6FPdkiRp9PwO8Io+t/HGGOOP97mNlmKMFwD/AawdZj+GLcaYAP8GnDfsvqitSeA9McZnDKHtNwIv72P9z6dY67TP/K5VaaXEnhqb638COLWX9S4wTTFOPKRP9a84Mcb7AB8DzuxTE1PAexvtqEsxxhcAf8q9+0730gOBdx87BzUSIXyC3iY1XehPY4yP7FPdx2nc+76HYpzoh/sAn4gxntWn+gflxcA/D7sT0lIleZ63L6WOxBifRfFLrPmJYWHSg/n/58AB4C3AX4UQdscY/xfwd41jycKvIYSOM+bFGNcCHwaeuKAOOLrefwkh/FQ31yeptRjjtSweJLsuhNDrDE/SkjWS7iz2iaBaCOGOQfdH6rUd8ZnPzg9P/cfMz/Tm7bxvzwlc9enzueSZXzj+4P6EZF/aPoXYIUhmUqjlJHMpeSknOSY+kSdANSeZKd2SAORM5RN5JUmSo39ec+p5jTypQ17KoZ7AZM6i5ZI8I8tzUpI8I0/raUKWlJjM02WUS0ghz3LSWgnyJD2qHJDn1Mgzji03Wy6VZqvlpFTOSmlKksykOeQ5CTVy6uRJFciOffnyhFnyZIaU/TO18sHZ2kRWqdQqaT3fl5a4Y18+uetQuVJeO33o1Om52tbSTDK58PzqbHkqy5N16XT9yGs0l5XSLEsmpyZrSVqu5aWZ9Mg11LI0m5ut1MtJlqXT9Sxv9GkuK6V5lpSnpqqlpFRn4TnVelqtzlWyUpLV0un6vW2XKCdJWpmYq+elJD9yT5+S1+ayUr2ap2m5kmXk1ObbqKXpxOR0NZ2o10hn02ThOdW5Ul6vlUhPqNcW9quWphMTa6pM1GvJwn6l5LXaXKlay0rpwmsBSBNqSZrPZHCYLDnyKZ7517VaSm+uU7pr4Wu5tjJzz/T99t+UnT6348JtV+4+9nslqf+uv3T75npeuYi0dHbLgnm2Js84nTS5b56xiWqykSydYio7er5I8jnynCRJpvIsn0zq6eRxcwDNx/bFyiXVPM9zcpI8SWZL+UypUsknOK5cWsvyybSazZdjgnKz+shI8jSHuRJJhePaJc8zqmRksLDcbLlUmqGcpBO1tFxN02QmAcjIyYAaCTVIahwbFkuo5XlyGDg0W6scnKlOVEt5RmW6ViPN78irpdsOTabVLE1OmZ6pn1ShvmHh6bNZuVzLk7UT5fqRYPqgxvhW81WzOe7IfFWtJ6UkS4obk0K1nlZrpCycr446p8kcN1cvZRMTdfJj5vYk5TBJfmDh3FMin51/XWtJuiurJIcWnlM5+fAN6x+8+0vOPdJwXH/p9s3cNXVOXiqdmW2ub2paMM/WcDjZSp6cmpfYymy6Ia+w7ri5hzxL5pIaeVImzdYwl1aoMNHp2H58OepUqTfmipw8SZjIk8XWSJ2W63jN1aTcbFJK5rJSKa2TpAkks0nRfkpGThWS6qJzD0kV8oOQHJidqxyuVstpZbpWS/N8f71a+v7+ZPKOWpKevHbq8H3LaW3dwrXPbFYuV2fL05WkPrVw7dNujO9mHXPsGN9uvmo2xw1iTQbF2ieH/cDM/HMl8tn517VWTm85du5ZW5m554R07vPnv+yyG9HYMf65Mux44zPOyjZlj2459wAcZAt5cmZezk8iS7Zkk9naJEmO/aOWGlWyJEvKpPmEcbcF9a3AuNv8OceuY4y7SWpnHONureJp7cp1vuZqE3dLs7Q0Q5LmScIqjbvNZuW0Wk+zxnyVpVNZlkOWkJNO1BLjbpKaMe5m3G3+eeNukpZiufFP427G3Y60sQLjblk9vfvYtY9xN2n4jLut3LhbN+sY/95t/Pj7d0lLEWN0owKNnBCCG9EtUYzxb+h889CvAe8FPgV8C7gHqFNsFP8Ais3Xngk8mcU3e9oPPAO4skUbLw8hvKPD/iyqsencvwOdZrs6CHwe+CZwd+NRAk6m2PDtiXS+ydjngCeFEOY67Os7gJ/ssO5euCWEcEa7QjHGJ1FsoNXMxSGEKzqo5x2M4PUtFGN8NfDnSzhlL/Bp4AZgN8X7ZYri/XJf4BI63yjwfSGEH1tC28eJMf4U8I8tijwA+Cfg8U2O1ynet18HdgF3UfxMnww8muLnut0nqgEuDyH84IJ+vQB4V4vydwCXA99rtHsY2AqcATwV6GQTxxx4QgjhMx2UlbRK7fybO123aOSc8nMnuW5ZgkYignd3WPwW4J0U97LXUdyr1YGNwNkUiZOeD/xAk/P3AU+nuN9rpqs1Swf3bQ+hSEjXau1xPfAF4DsU67EasA44HbiQ4v6tRIf366Oqg9dq3gzF+vJjFOu5b1Pcox8CZilemw2Nx+kUGwRfADwc2NakznUhhAMt+nYGcFMHfeuljt5zMcanAh9tU2yO4rW6huLef2/jcYgi2cYGivvyh1O8Jyc67ON+4KIQwrc6LN9SjPFmiu/ZYv6JIjbx4RZVHKJ4b3wduJ1ivbGW4ufrB4BH0tk6B+D3Qwi/2WHZpmKMV1DEFxbzyRDCk5ZR9xuA0Oz4cuJlvYoPLKG+Qet2TH8uYxJ7aiXGuIFiXjkukWETeym+f9cAd1KMKespxtRH0Xoj9psoxpWmYywQQwhv6LAvY6ndzytFjOlztE5Qe12jzB0U34c6xXvpdOCHG//uxEdCCM/qsOyiOpgXlx3rbdH2G+jf2HcFLcZs4JeAL1Ik/1nMHuDjwHcp4l4HKWJd96P4Hp3WYVdeFkL4l0afEoq5r1Wioa81+rWr8ZiimNcfCjyJzsasbwIXhBBqbUu20MF7fR3wDYpYYDNfoxijbqC415igeH+fT3E9G5qeebTrgUeHEPZ2WL6pGONOite0lVsp+n4r995r7aXo/waKtcmDKe5Jtiyh+d8MIfz+ErssDc1if3ikLoUQPhxj/BmKBAYp9yYbmE84MP//dRTZ4f5PjPG9FBPSsjQm+/dRBB0WJjw41j8tty1JkqRVb11Ovq7evhzF5+w7U33GhduuvLb7TkmSVrJzX3LlbuC/G4+x4IfeJGm8NeaezzUekiQNxDmvv+xGwA0QJUkDM45xN42G4+KfB4/8y/inpJaMu0mShsG4myRp0Iy7SZIkSeOjsUFbJwkPvg68JoRweZPj85u1fRH48xjjA4G3AM85ptw64G3d9bYzMcYLgX+l/QZONeA9wF8AXwwhVNvUew7wSuDnab3p42OAtzbKduLtHL+h6hag1eZF/wh8tsP6j7W/y/O6NdLXF2N8GvCnHRSdAd5BsZ/M1SGE4xKjHlPvhcCvAS+m9UaaPxpj/I0Qwls66nB3XsfiCQ++T7H3zftCCHc3OznGuJVig7Kfo/W1XBJj/JEQwgdijOcC/9Ck3LsoXvMvNnsdY4wpxWbDfwqc1aLNBPgD4LEtykiSpDEWYzwN+OsOiu4CXgtcGkJYbKOXOxuPzwJvjjFeTHGv8ZBjyq2nz2uWFv6AxTe83k+RpOsfQggtf/cfY9xCcd+2r/fdG4zGvWCrDXKh2MD+D4A/DSG0Ska8h3v3ePw6CzbJjzGeDTy78XgCzfdtPNZdwM8u8vzLaX5fejfFfXm3lpPka44i2dgHKd7/17db/86LMU5QbKz8v4Cn0Xo9sA74+xjjE0MI/U44tJ7m48LNwO8C7wwhHG5WQYzxFOAXKNZtJ7Rp77UxxstDCB/roq863g4W/xnqhx+giOP01BjGnlr5SzpLePB14PeA97faCD3GuA34FYq56Nj9Zs4E3tRdN1eVP2TxhAe7KeJp/x5CuKXZyY2N8Z/UqOfhbdp6Zozxh0IIH++yr6vVJHApiyc8+G+K79On2vysPJ7iXrTd9+jNMcb3hRAOAf+HxRMe3EPxs/VvIYTvtWhzA/DrwG/Qeox5EPDTwN+26dty/T6LJzyoUoxNfxpCaJpQI8ZYAZ5H8boce09/rHMpxuKXdNXT9q6juNf6b+BrIYQ9nZ4YY3wIxev9UtonQIgxxg+FEK7rsp/SQJn0oMdCCO+IMe6lyPQ4weKJD2j8fwr4iQWnLzkTUIzxfsBrKBZOEwvamZcveO4rIYRRymwmSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKkAYoxrgH+rIOifw38cghhrtO6QwjfAp4bY3wFxWZCC/c2uWBJHV2CGON6is2F1rQpehnw6hDCzZ3WHULYAfxyjPGtFJvfb29R/BdijO/pZH+PEMKVwJULn4sxnkHrpABXhhDe0a7uUTDK1xdjvD/wb7TeuBOKJAyvCyHc0WndIYSrgZfGGP+AYv+ZB7co/sYY43803mP9sNhmkm8GfieEcLDdySGEXcArY4zvp9gkdqpF8V8DPgD8DcdvHPpN4KdDCJ/voM0M+EiM8X+A9wNPbVH8MTHGx4cQjk2uIUmSVoY/Aza1KfMZ4Ecb9y0dCSF8Isb4COCvKDarX+jCJfWwdxa75/kw8LOdXlsjmdX/62mvBu+HWHwD3Hm3Ac8MIXx1OY2EEL4N/BHwR42kXa+h2Gy23XkHgL8/9vnG5sXNkh4cCCEcd06ffYpiw+D/DCF0lQSjEQf4APCBxs/L39N6Tf8E4AUUic766bksvmfnXwC/HkKYaVdBCGEnEGKMf0exLlwsUdy8BPjHGOO5je+/liGEcDuL/Az1WozxdOB32hQ7AHxpifWOXeypmRjj8yiSNbaSUSSieVOTpEJHCSHcALw6xvg3FAkfjk2o8Kpu+rrKvHqR5/4MCJ1spN5IPDN/n/Mmig3uW3ktYNKDpXn0Is/tpLhn+0gnFYQQPh1jfCTF3PVzLYqeCrw4xvhp4LcXOf524DdaJTRd0OZe4LcbMb7LgY0tiv96jPHv+pzIaLHELdcAPx5C+Ga7kxuJZN4dY3wf8FsUY1WrOO9PNBJIfKCr3h5vJ8X3792N+8quhBC+AbwmxvgGikTSP0vzvckngD+mdaxUGhntfvGiLjQGsadTZENamOxgPvkBTZ47Tozx/THGN8cYfynG+JMxxp+NMf5WjPFtMcZrKDLK/TJFlp9kQZ2L+a1lX5wkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZLG2a8C92tT5o9DCL+wlIQHC4UQ/hZ4IcUGaYPwh8DpLY7XgP8NPGspm84tFEK4CXgy8K9tiv5ljLHUTRsamL8DNrQ4fhB4aQjhp5eS8GChEMLXgccB/9Oi2CTw593U34UMeEUI4XWdJDxYKITwcYqf51YeF2P8E47fmPGLwBM6SXhwTJuHgR8FrmpT9BVLqVeSJI2HGON24EfaFPs08JSlJDyYF0KYDSH8NEXig1H0R8Bzurm2Mff0Fscy4IXLTXhwrBDC9SGEn6NYIx/uZd0DVqdIGvboEML2EMK7uk14cKwQwpeAiyg2MW/lt2OMTffV7JHF6n9NCOHVnSQ8WCiE8D3gEorkDq3cF/jNpdSt4YkxbgT+EzilRbE6xcba1y6x+hURe4oxTlJcSys14AUhhN/tJOHBQo1NvB9FEQ9YyP2Pl6YO/HwI4Zc7SXiwUAghCyG8FviTNkV/KMb4gG47KKDYE/rxnSY8mNf4uXolxdzdyqsoEhNPHPP860MI/6uThAfHtPtV4BkUP+PNnA1cvJR6u3DsfP5p4DGdJDxYKIRQCyG8kSKJS7ux6o8a499yXAf8DHBGY3zsOuHBQiGEvY370R+n9ffmKY2EGdLIc9Lvk0bWq4cDn+foRAewePKDhZIFX58D/DrFzcLbKSab3wF+AThvQV0LkyjMyxcc+7cQwsd6cGmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEkaQzHGaeCX2xT7L4q9LpYlhPA+IC63nnYaG/38bJtiPx9C+MMQwrF7fCxJIwnES4H/r0Wxc4EXLacd9U+M8ceBH25RpAb8WAjh0uW2FULYCzwT+FqLYk+OMT5+uW114BdCCH/X7ckhhP8A/qNNsV855v/XAj+41A3YFrR5iGJzt1Y/t8+OMVa6qV+SJI2017c5/j3geUtN5rSIXwQuX2YdvfaPIYRfX+7aZUy12sT1v0MIn+pXwyGEu5e6sfcoCSF8LITwoyGEL/Sp/irFhsKXtSh2HjCItc1CbwohvLXbkxvX9ULgs22K/mqM8eRu29FgxBgnKDYQP69N0VeGED66xLpXUuzp54Az25R5VQjhvV3WPx8PeRpwY7d1iP8VQvibZdbxOuBbbcr82DLbWM3upEj0+Z1uTg4hZBT3oodaFLsQeOIxz8UQwu9002aj3c8Cf9um2CDfFzuAZ4QQDnRbQQjh3bT/nceZLDN5agjhkhDCP4QQZpdTT4v63wu8rE2xn+tH21KvmfSgj0IIt1Jkn34zRcaXhckJ4N6EBa0y0iUtHixSHwuen7cD+Plur0OSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEkrwkuAE1scn6HY/K1XG2z+PsW+F/30u+2OhxD+oVeNNV6bl1JstNrMspNGqPdijCntE3H8fAih1caCSxJCmAGeD+xvUazf75f/CCG028ysE/9nCWWrwEuWs2EZQAjhi7ROtrABeMxy2pAkSaMlxvhQ4AfbFPvVEMKdy22rscn9zwFzy62rR26l/YatK9lZLY61S8ClPgsh1Cg2fW+1tnnpgLoD8BXg/y63ksYG8y8EDrcoNkWRkE2j7R+Ai9uU+f0u18crIvYUYyxxfMLCY32wFzGEEMJu4CdonchQi/uXEMI/LbeSxvj2G22KPWW57axirwghtPoZbSuEcBvwl0s45fNA1wkPFngDReyumaf2oI1OZMCLQwj7lltRCOEvgI+0KfaaRnx4ZIUQ/g14X4siz48xTg2qP1K3RvoHbSUIIdRCCL8JPAz4FMcnK2h3A5a3eSyWOGFhEoTvAk9f7i+AJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSNPbabUD4ByGEG3vVWGNzrV/sVX3HijH+APDkFkW+SftN7pcshHAX8PoWRR4aY3x4r9vVsv0IcG6L4x/r5SaF80II3wb+pEWRZ8QYt/a63YYDwCt6UVEI4Vrg2g6LvyWEcHUv2gXe1eb443rUjiRJGg0/3eb4p0MI7+lVYyGEG4A/7VV9y/TKEEKrDeVXuo0tjn13UJ1QcyGE24E/bFFkUJskA/xKCCHrRUUhhFuBt7Qp9nONDeM1gmKMv0OR6LOVdwG/1UXdKyn29HTgzBbH5+hhYsYQwueBd/aqvlViF71NsnIZ0CpR1KNijOUetrda/HsI4YM9quvdHZbLgJ9qJO1alkbysP9pUeTMGOOpy22nA/8YQvhKD+v7NVoncziTYhwcdb9O8/3K1wGPHWBfpK6Y9GBAQgjXhhCeCPw4cDVHJypolQAhafNYaGEdCfB14IkhhJt7dR2SJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEkaP42Nih7fosgc8NZetxtC+BjFXhv90G4z918LIdT61PalwPdaHP/xPrWr7rV6v9SBX+1j238GHGpyrEyRkKEf/imEcEcP6/tAB2XmgD/vYZuXNeps5sIetiVJkoYoxpgCz29TbMkbVnfgd4GDfah3Kb4aQvjIkPswbMfurbiQGzKPjlZJR+4XY9w2gD68L4TwqR7X+RbgthbHtwKX9LhN9UCM8aeB/9um2KcoNgtvtol0Kysp9vSiNsf/PITwnSXW2c5rgcM9rnMl+6teJkBqvDff26LIGuDsXrW3irRKALQkIYSrgFs7KPqREMKOXrULvL/N8Qt72NZiDgL/p5cVhhC+BfxFm2LtxsGha+wj/qUWRbwf0chz8TZgIYT3Au+NMT4N+BWKgWI+Y1urxAeLaVa2TjHI/mYIwZs7SZIkSRI73viMs7JN2aOzzfVNHZ2QZ2s4nGwlS7fkJ+Rrjjl6iIn8bnJ2JbXkUMfnkNycJPldx7aTZ5xOmp50XB8q+Z3ALUe1AXCQLeTJmYu0sfg5o3Atzc5p4a7JNbu+W9+8b3p6bqpVucOHJtfmOfedPmFmQ6tyM4cn7sqztNKuXJYlc7VqmYnJ6kSrcpWJ2t6snszV66XFrpcHPKiyJs+TtFTO9mf1ZC7Pky0ASZJn7/nQTxz3x7nt6uumXALfr85VDrQqt2Hz/jtPOuWeHRduu3J3q3KSlu76S7dvrueVi0hLnf+Cc6ljfOtzhjvGj8K1LHZOCznpPTvLa7+/Z3qq5VwBkOVsTZL89FZl+jG2zxya3DM3W9nYaj7rdTnofB7N8+S7acLOVmUA6ll6zQue+883tisnaWnOXHfbxlNq+x4wVa7fL9lQ2wiQJln92n/94eb3hN2M8b1dx/RujB/+tTQ/p4mc9J5dUyfcdVttA71Y+/RjbB9WuaWszVz7SMNl3M2426DjbqNQzrlHGi7jbiNwLcbdjLtJq8z1l27fzF1T5+Sl0plLWfsYd+vdmuwpZ00eqGal26ilR302oFn807hbc8bdpPFh3M24m3G3xTn3SJIkqUd+kNabSH40hNCve85L6fFGSTHGCeCFLYp8I4Tw0V62uVAIoRpj/Ceab870FOB1/WpfSxNjvA/wQy2K/GcI4Zp+tR9CuDvG+AHgJ5oUeQrw131out1GX0v1lQ7KvDeEsKtXDYYQDsQYvwWc36TIOb1qS5IkDd0PAKe2OH5zHzY6J4SwL8b4H8CLe133EvzjENseFbuBU5ocuxD40OC6omZCCN+MMd4CNPt7x4cBN/S5G3/V6wpDCIdijP9M63X8jwEf63Xb6l6M8cnA37QptgN4bghhtov6V0zsKcZYAZ7VpljP4xIhhO/HGD8EvKDXda9As/RhfAM+D/xCi+PnAt/sQ7sr1RdCCK02pO/GV4H7tSnzth632S7Gdw7Qt/EN+EAv44cL/BXFft/NPDvGWAkhVPvQdi99FHhkk2MPG2RHpG6Y9GBIGjemH40xbqW4iX0+8AigckzRZokQFpr/hXIV+Hfg90MI1/awu5IkSZKkMbUjPOs19TXpm6tPPlzJT2qfFDrdC5UvT5DvWUP1CQfIT2r/+5puzyl9p0zt9Jx8S72jaylfN0G6Yw3Vxx9g3K+llTt3buLWm7ay7YxbecjG5r/HPVLuQbeyfuPBgZUD2LN7LeVKnbXrmudanJ2pHCm35oSZI8+nac7k1NEx307qW0q5blz1zYtvLlfqL79w25VX9LxyaZW5/tLtF9fTyjtrZ5dOybdUKcKWrS11jO/mnFGdr7o5p5traWd+jD1x3R2c2EG5Xo3ZnZYb1ry3lPlxqT79lafM3nH7ltc97xnvfGtPK5ZWoesv3X7xs9evfUc2N33/6iMPkm+5dyxN05zq1PFzUTdj/CivY0bxWto5MsaefisP2Xhn+3IjOgeM09wDrn2kXjLuNprX0spKibsNs1w3nHuk3jHuNprX0o5xt+WV64ZxN6l3rr90+8XcPfn2bHbjGcW4ONP2nFGNVY173C2ZqVPOjt+DbrH4p3G35ZXrlmsfqXeMu43mtbRi3G355brh3CNJkqRlelKb45f2se13Am8B0h7W+QRgfYvj7+5hW81cQfON5x4aY9wQQtg7gH6ovafR+v03qPdLs6QH2/vQ3vUhhF5vWtdJff/R4zYBrqN50oP796E9SZI0HE9qc/xdfWz7nQwv6UEN+NchtT1K7qB50oOfjjH+YQjhUJPjGqxWSQ/OB97Tx7Z3Uqyt+uFfab2B/CV9alddiDE+BHgvrffVvQN4+jKSfK6k2NOjgLUtjn8phNCvhCXvxKQHnfh0COGOPtT79TbHT+tDmyvZB/pQ5zeBZ7c4fgC4vA9t5jRPktzveNu/9aPSEMK3YoxfAR7epMhaimQCn+lH+z10S4tjzWKk0sjo5S8C1YUQwq4Qwp+GEB4PbASeDLyBInnBV4H9FBPAYo85iqxh/wy8HNgaQnipCQ8kSZIkSVB8ADQrVf547kfv6fgDoBOfnYCd65l73p6OP2jZzTml68tUH15b0gdAS1evZ+5H+tuvQVxLK3fu3MS3rjmDhz/m+rYf2BxGOSg+iLlx84G2H8Tce88JrN948KiEB8upr9Ny3SpX6mcAn7j6hu1P6ksD0ipx/aXbL64n5curj6ye0q8xvptzRnW+6uacbq6lnV6Pxb0uNw7zYzfWrj88edY53/uT91/24l/peeXSKnL9pdsv5p6Jy9m39v5zT9t7VMKDZroZ40d5HTOK19LOqI/to15uOVz7SL1h3G00r6WVcRjbR31t1i3nHqk3jLuN5rW0M+pj+zjMj90w7ib1xnzcLd+77oxxj1UZd7OccTdpfBh3G81raWUcxvZRX5t1y7lHkiRJy/SwNsc/2a+GQwi3A9/qcbVPbXP8fT1ubzGfBZottBLgoQPogzrT6v1SBT40gD58qsWxzTHGXm8m9rke1wfwnSG122rjxY0xxlabXEqSpPHxuDbH+7HJ7Lz/Avrzi+X2rl3GhtwryRdbHDsdeLv3fSNjZ4tjZ/S57feEEJb/C89FhBCuAa5pUWRbjPE+/WhbSxNjvC/wn7ROSHAYeFYI4cZlNLWSYk9PbHO8n4mFPgrc08f6V4p+bcK+o83xk/vU7ko1jHjbF3s99zUSSd3eoshJvWzvGLuB/+5j/e9sc7zdeDgKWt1rnRZjLA2sJ1IXXLSNkBDCYeB/Go8jYoxTFJlgTgCmKZId7A8h3DnwTkqSJEmSxsfuqTfNvfjujouXb4bk2xuZfVHnvwvv9pzqtrzj8gCVyzcy84L+92sQ19LKN656IBc9vtXvP4dbDqBc6fCDu5Wsx/X15XfOi3kbZrOVluNttT6P8d2cM6rzVTfndHMtbevs8Vjc63LjMD8ux8mn3v37wFv73pC0cr0t+fZGqs/b2/EJ3Yzxo7yOGcVraWfUx/ZRL9cjrn2k5TDuNpLX0so4jO2jvjbrAeceaXmMu43gtbStc8TH9nGYH5fDuJu0bG9bKbEq426WM+4mjRHjbiN5La2Mw9g+6muzHnDukSRJ0pLEGFPgQS2K3D6AfSy+Bpzbw/oe1eLYAdpv6LVsIYRDMca7gK1NipwPXNnvfqgjrd4v3woh7B9AH25pc/x84Ls9bO/zPawLgBBCNcY4C0w2KXJbCOHWXrcLtPr+JBQbXbpRsCRJ469V3LsOfL1fDYcQajHGbwCP7lcbLXx5CG2Oov8BfqbF8RdQbDr/mhBCq4RiaiPGuB64P3AisIXi/n4S6HQD3dNaHDt1eb1r69N9rv8ztB6LHgrc1uc+qIUY4zrgMlq/DzPgxSGEVslUOrGSYk8Xtjnet5+tRizhS8AP96uNFaIfm+kTQjgcY6wClSZFNvSj3RWqDlzVh3rbxSV7HuProN1+vi++EEKo9bH+dglE+p6ouJGo63SKpCInUuwpPkHxc5h0UMU5LY6lFHOC9yMaWSY9GAMhhBlgBrhr2H2RJEmSJI2HHW985jbyNZP5SR3G9qqQ7kshS+n3OcmhhHzLEj7Qty+FWv/7NZBraWFutszM4UnWbzw4kuWKsiXWrjvcUbkT1h4my1rHV5dSXyfleuTBV9+wffOF2670D1ylJbr+0u1b8jw5r69jfDfnjOp81c053VxLG70ei3tfbvTnx+Vau/7w5Ls/+LKzXvDcf76x741JK8z1l27fQjU9jywlP7EGbe4/ge7G+BFex4zktbQx6mP7qJfrIdc+UpeMu43otbQwDmP7qK/NesS5R+qScbcRvZY2Rn1sH4f5cbmMu0ndOyruNu6xKuNuljPuJo0N424jei0tjMPYPuprsx5x7pEkSdJSnQpMtzh+9QD6cDXFJpXLFmNMaL050TdDCL3L/tba3TTfeK7VBnwakBjjFuB+LYpcN4h+hBBmYoyHgDVNivT6/dKP5ANQbOzYLOnB9/rYZivN+iNJksZEjHEKOLNFkR2NPfn66WsMJ+nBV4bQ5ij6MHAncFKLMj8AXBlj/CrwduCDIYR+3YOuCDHGCvBE4GKKDdwfQrEBb79s6WPd0MfkJx3Wfz7w0T73QU00NpH+d9pvWP2rIYQPLrOtlRZ7enCLYxlwzZJ6tHRfw6QH7fQyEeax9gObmxwzptK5u0MIh/pQb7u41zDibf18X/R7Lv8GkNM8uUCr5EZdiTGeAzwVeAzF/eoZ9Hff9y2Y9EAjzKQHyxBj3BZCuGHY/ZAkSZIk6Tg55+Vrs46LJ1VgLmUQ5+RJSpG0tjPp3sH0axDX0srM4UmmpmdHthzA3OwEE5OdfGhzgspE+w/TLqW+Tsr10KmAHwKVlu6Ufo/x3ZwzqvNVN+d0cy3t9Hos7nW5cZgfe6GUZucDbr4mLd0pgxjjR3kdM4rX0s6oj+2jXq7HXPtI3TDuNpLX0so4jO2jvjbrIeceqTvG3UbwWtoZ9bF9HObHXjDuJnXNuNsIXks7oz62j3q5HnPtI3XDuNtIXksr4zC2j/rarIeceyRJkrQU92lz/NsD6MO3eljXfYD1rQrEGH+mh+210moDqPsOqA9q7dw2x9cN8P1SbXGs1++Xe3pc37yDNN/ItJ9ttjLRp3YlSdLg3AdIWxzv9+aoUGzIPAz93OR4bIQQDsYY/wj4/Q6KPwz4c+DPGgkQLgeuAD4dQtjbv16OjxjjQ4FXAi+kzfq5x1olXFyuw/Q/ftFuHHhAn9tXa39Jsal0K28NIfxpD9paabGns1ocu6FPG7kvNKw5dpz0K6YCxeb2zZIeGFPp3LDiXsNot5/vi76OB417yu8A25oUaTUedizGuAl4OfAzwIN6UecS9PN+S1o2kx4sz7dijPsoMsl/mSJL4leA6weYcUuSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElq5eQ2xwexKeS+HtZ1vzbHH9F4DNsgN5ZUc+3eL0+l/aaJg9Dr90u/NkRrta/OMNoESPrUriRJGpxT2xy/bQB9GEQbi3GT/nv9CfAs4HEdlk+Ahzcevw5kMcbrgM8CnwE+FUK4qR8dHVUxxrOAPwCeN6QutNqcfbm+E0LoTab35tolbDylz+2riRjjbwE/26bYB4Bf61GTKyb2FGPcTOufzV4mKh1mG+Nudx/rbhVXMabSuWHFvYbRbj/fF4Mac5olPZiKMW4MIezppuIYY4XivvO1wIbuurds/bzfkpbNpAfLtx54QuMxb3+M8bkhhCuG0yVJkqRVKOG65ECrZN1LMzU9y8zhga7nbh9kY5IkSZIkSZIkSZIkSZIkSZIkSZIkaVVZ0+Z4LxMSDKKN+/Swrn6aHnYHBKze98tsj+sb1TYlSdLKsKXN8XFbs4xDuyMnhDAXY/wx4Erg7C6qSIHzG49XAMQYvwN8FHgfcGUIIetRd0dOjPGngT8DThhiN0p9rHsQCUL2tDm+dQB90DFijC8GfrdNsS8AP9HDn/GVFEto974dxM+WCX7aCCEYUxl9w/oerbT3xiiMOVtpP+cfJ8Z4DvBu4KFd9KmX+nm/JS2bSQ+WL+f47DPrgQ/FGH84hPD5IfRJairGOAk8EDgNWEfxhwmHgP3A94AdIYS54fVQkqTunPP6j9yw4xefP5vcWZ7MT6otu76JyRpT07Ps23MC6zce7EEPW7r2wm1X9jPDpiRJkiRJkiRJkiRJkiRJkiRJkiRJWt0m2xzfP4A+9HIjz3U9rKuf2r3uGgzfL5IkSaNvqs1xkx6sEiGEnTHGRwLvBJ7WgyofALy68fhejPHtwNtCCHf2oO6REWP8PeC3ht2PPut77CKEUI0xztJ8fTbMhBKrUoxxO/CPHL/v60I3As8KIRzuYdMrKZbQLhnquMUFJY23URhzljyfxxgfDVwGbO6qR9IqYtKD3sgXeW4t8NEY48UhhKsH3B/pKI2J8bkUgZsH0zojTz3GeC1FRsoPmrhDkjRWNs+8buJjG/9k9sV39aS6Cx6xg69/6Rwe/+SvLF5gf0KyLyWvQ1JNu24n3V/6zjVfeNof5pPZrmxr7ev5qdUvmQRB/RBj3Hzuutsu2rph90Mr5drW8sFk7fyxw/XK5OxMZeNEWl+XnlDr6I/i0nq+Ly1xR7WU3lyndNQP3trKzD0npHOfP/9ll93Y6+uQVrUa/gpHYyXGuPmU0+4854wNu85fe7B2zsK5B2D2cGVdnXRrp3NPiXyWNL8jr5ZuqyXprqySHJo/trYyc8/0/fbflJ0+t8N7KamHapDsS0juTot0v9IYePcHX3bW2n31R6/fN7dtIq3fZ+Gxw/XKZJX0pIlKbUMndZXIZ9M831+vlr5fK6e3LJx7AConH75h/YN3u46Xem1/QnJH9/E2adCMu0krgHE3jRnjbtIKYNxNY8i4m7QCGHfTmDHuJq0Axt00Zoy7SZIkAYvvndFrWQ/rmu5hXf3UakM+DY7vF0mSpNG30hK1LUUv10orQghhT4zxGcBPAL8LnN6jqk8DXg/87xjjnwL/L4QwiPdWX8UY/zcrP+EBDO5ndB9wUpNj7RK0qIdijOcCHwQmWhTbDTytD4lMVlIsYTUnFpI0ekZhzFnSfB5jPAcTHkgdM+lBbxx7k5c3HhuA/44xPjGE8M3Bd0vdiDEmFBkZHwFc1Pj6MIpEFs3cEkI4o/+9W5oY4wuA3wAevoTTSsAFjcdrY4xfAd4SQnh3H7ooSVJPnRM//NYd4VlMvG/TW6rb91fyk2rLqu/ErXs494Ib+crnHsS2B32X9RsPAlC+boJ0xxpqDzlEvqUOm+rk1Ltup0712cc+d/V1T9zJRP6iC7ddeUXXFUsNMcaLz11z2zuft37nKdx/hsqX1pHeVcRbdk2u4aY16zlv4/fZdMltLPfnZqEacPUXL6mWb5z8jfNf+NG39qxiaRVK90LpO2WySoXyTevAPQg04mKMF598n7ve/rTH3nDG9MGMyufvnXsAdlcmqZx2kKlL7uzp3DP/1zxXX/fEm5nIX+69lNS9dC9UvjwBt60lW5/Dw+eG3SWprfdf9uLX3Le+980PubZSSe+pkO4pM/+rsF2Ta7hjW8JZj7mJ5MRqz9v+8jcu3lmarruOl5ZpYdzNP/3UODDuJo0/424aN8bdpPFn3E3jyLibNP6Mu2ncGHeTxp9xN40b426SJGmVmW1zfBDpmjtKoNuhSg/r0srn+0WSJGn0tdv4fxD3dN43jpAQQg5cGmN8D0Xyg58GHtej6qeB1wEvijG+OITw2R7VO3AxxscAb1rCKbcAXwS+BnwH+D5wB8XmwPuBOaDaeP2btfkO4Ce77PJy9P4P1ZbeTmlAfVj1YownA/8JbGpRbBZ4TgjhW33owkqaE9r95n4QP1uD+vmVNPpGYczpeD6PMVaAd9N5woODwOeBrwLfBm4GdgF3N44dAuohhKZ/hBJjfBLwiU77KI0akx70R8K9iQ9OBD4WY9weQrhxuN3SYmKM9+fe5AYXNR4bh9mn5WpkpPtr4Ik9qO7hwLtijL8A/HwI4foe1ClJUt+cEz/8VuCtO974jLOyTdmjs831VgHLtk5lhlPSW+7ZdcsJd33jO6fyoFvv+fHJQ8n/mrtkD/kpvfvAwnEm8lOAT1x9w/aL/fCCliPGePHZ0zsvv+DwnVQfd5Cpf7s3ifSuyTVcs34LT5q+gdkX3EXT3zQtx+Zapba59ifXvOtp+EFQqTvpXihdX6Z+SkrlMydQe/p++PSweyU1F2O8+MStuy9/7IOuJZlNmfzISUcd312ZZMOp+/o39wBM5GfgvZTUtXQvTHx2gvz2DTCVU332XeT7pofdLaml91/24tdsm7rjjyv/s4HSHRNHHds1uYbvnlPmwU/vX37q0nTddby0TOXrJihdvZ75uFu+ZyX9PaBWIuNu0vgz7qZxY9xNGn/G3TSOjLtJ48+4m8aNcTdp/Bl307gx7iZJklahQ22Oj1vSg3ZJHKSFfL9IkiSNvlFI1DaINrREIYRZ4O3A22OM24DnAJcA24G1y6z+dOATMcbnhRAuW2ZdAxdjTCj2HGy3ce89wF8Cl/ZoL8GkB3V0Y92A2mk1FswMqA+rWoxxDfBh4MwWxXLgJ0MI/fqt9EqKJbS7lkH8bDnHSpq3juLepJ/ajTlLmc9/CXhomzI58EHgb4HLQwhzS6h/McO615J6wqQH/bMw8cF9gP+JMT4hhPC94XZrdYsxbqVIbjCf4OARwEktTxozMcbnAf/E8oMwx3oi8KUY48tCCB/ocd2SJPXcOa+/7EagZ0mnzm983fGLz//QzIvvhnLfPrJwrLctaF7qxtseeufdzD1vD5P/cXSSyKs2beXxd32fuWfv6Xsn6mfN/D7w1r43JK1A5Zuhui1n8gMbmX3ObmBy2F2S2nnbQy76FuQ5Ex/ZeNzBSp4x9+Q9A+sL3ktJS1a+GZJvb4SJhNln3T3s7kgdOfnUu9808e8boXb8726v2rSVJz3yC4PqinOP1KXK5RuZecHuQcbdpOUy7iaNOeNuGkPG3aQxZ9xN48i4mzT+jLtpDBl3k8accTeNIeNukiRptbmjzfFx20C0XRKH14QQ3trD9jTe2r1ffiSE8MFBdESSJElNHWxz3A2ZRQjhBuCPgD+KMZaBHwCeADwOeCxwchfVTgDvijE+PoTwtZ51djB+BLigTZn/Bl4cQujlHy/2MqnhUvT9ZzTGmAIntChi0oM+a3wP3gk8sk3R14UQ3t3Hrqyk2FO79+24xQUljbf1jEnSgxjjJPDaNsXuBF4YQri8kzo7NKx7Lakn0mF3YIWa/0RAsuD/p1MkPtg6iA7EGF8QY/xEjPGtMcaXxxgf3hgoV7v/osjY9nrg6ay8hAevAt5L7xMezFsLvC/G+Mo+1S9J0kjb8cZnbiNPJvO1dfJN9UE1++Crb9i+uX0x6Xgxxi0nlGbOKx+GfG1GelflyLHZNGUmLbO+fJj8pFrf+5Jvrk9e88/POKvvDUkrTRWSQwn5mpzkQDqQn1dpOWKMWyoT1fPWTx4in8qPmnsAZpOEteWZQb6XvZeSlqoK6b4U6inJTOLco7Hw7x982ba1ldnJZH9KuufofN+zaUp9Oic5sTqo7jj3SN3Yl0ItZcBxN6lrxt2kFcC4m8aMcTdpBTDupjFk3E1aAYy7acwYd5NWAONuGjPG3SRJ0ip1e5vjZw+gD71so91mjWf2sC2NP98vkiRJo29Xm+OD2PjTDZnHSAihFkL4QgjhD0MIPxJC2AqcC/wC8EHgwBKqWwv8a2Oz9XHyv9ocfz/wtB4nPADY1OP6OjWIn9F13LuP6GJ6/VrqeH8CPKdNmb8OIbylz/1YSbGE3W2Om/RA48b9lcfbKIw5nc7nz6b13tV7gEf1OOEBDO9eS+qJcVtUjZNjEx9A8cvXj8cYtwyg/bXAE4FfBP4e+BKwP8Z4zQDa1hDEGH8S+HNaL5J7IQHeFmN8WZ/bkSRp9OScl6/N4PDAb6NPHXSDWjFOWV8+TL42Izlw9Pt2Ji0zldXI12aD600pP39wjUkrQ1KFPEmLD4AO8udV6t4pU9OzcDg9bu4BmEtLw3gvey8lLUFSBeZS8unMuUdjI02z85IDxfv2WDNpmXWThwbdJeceaYnSvY01z+DjblK3jLtJY864m8aQcTdpzBl30zgy7iaNP+NuGkPG3aQxZ9xNY8i4myRJWo1uA2ZaHL9wAH3oZRvfbXPcpIZayPeLJEnS6BuFRG0PHEAb6qMQwo4Qwl+HEH6EYoPa5wGXce/ekK08GHhhP/vXSzHGNcCTWxTZCbwihNCPX3gMK5HzfQbQRrvf1+wcQB9WrRjja4BfalPsMuDVA+jOSool7KT1ODgKP1saP+3m1n7ujTuIfZ3VP8MeczLgjg7raZeE51UhhJs6rGsphnWvJfWEf73eO/mCr3dTTK4LEx/M//vBwH/FGAeZZSppPMrAgwbYrgYkxvgI4O/o7KbusxSLtIdTTGKVxteLKBZ4n++gjgT4u0a7kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRphDU2OfxmiyL3iTGe1OduXNjDum6h9cZag9gQVeOj3cZTvl8kSZKGbydwsMXxhw6gD4NoQwMSQpgJIXwghPBM4ALgUx2c9so+d6uXHkWxj2Az/xBCuLvXjcYYS8Dpva63Q6cMIHbRbhy4tc/tr1oxxucBf9im2FeAF4QQ6gPo0oqJPYUQarRO2HF+jLGfG9SDc+xKVGtzfE0f23ZD+PF2QT8rjzGmwPktiuxsjIudeEKLY98D/q3jji3NOCXWkY5j0oP+CMB/0zzxwcOA/2xkxxuEnM6yC2oMNRJovJvWQQeAbwM/FEJ4XAjhL0IIXw0h3BNCqDW+fjmE8OchhMcAPwx8p019E8C7B5zAQ5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkdeerbY5v71fDMcZTgAf2qr4QwgGKfRSaOSfGeL9etaextwM41OL4E2KMU4PqjCRJko4XQshpnajtlBjjyX3uhhsyr1AhhGuAHwQ+0qboo2KM6wbQpV54UJvj7+lTuw8Bhvka9fvntF391/W5/VUpxvho4FJa75H7XeCZIYRWCXJ6ZgXGnlq9d9cCD+hz+86xK89sm+P9nCtO62Pd6r9+jwfbgBNaHO9oLo8xngDcv0WR9zbWMP3wuD7VKw2ESQ/6YxZ4LnAliyc+SIDHAB+KMU4OoD/9zpi1kuUUC40rh92RFt4InNmmzMeBR4QQ/qeTCkMIHwMuAi5vU/RM4A2d1ClJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkobqk22Ov6SPbb+I3u9z8oU2x5/Z4/Y0pkIIdeDLLYqsAS4eUHckSZLU3NVtjvdt889GQoWz+1W/hi+EUAV+CtjdoliZYp/IcXB6m+Otkogsx7A34X3YkOv/Rp/bX3VijA8APgRMtyi2F3h6COH2wfTqiJUUe7qmzfF+/2w9vM/1a/D2tTm+sR+NNhKX9vv9qv4al7m8VcID6FMipEYCrof0o25pUEx60CchhBngGcAXaZ744GLgfTHG8lA6qcXcTJGV8LUU2Rg3hRAeCIRhdqqZGON5wKvaFPsc8JwQwt6l1B1C2AM8m+I93MovxhjbZXqUJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnD9XHu3f9iMU+PMW7qU9sv7UOdH29z/Dl9aLPf6m2OVwbSi/4Z5vWtxPeLJEnSStMuUdsL+9j2C3BvxhUvhHA38K42xU5dYrWt1jn9XOOsb3Fsdwhhrk/tDnuT9x/pV8Uxxo20Toi3D7i2X+2vRjHGLcB/Aie1KFYFnhdCGMZrv5JiCZ9tc7yfP1sPAs7pV/0ajsY8s6dFkX59zx8BTPSpbg3GeTHGB/ax/ue1Od5uPJzX6l4LYGeH9SzV03FdojHnG7iPQggHgacCX6N54oOnAe+MMfq9GLzvAx8E/i/F9+nEEMKZIYQfDyG8JYRw+VITBQxBoMgI2cxu4AUhhENdVV68h3+c1jeSZeD13dQvSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIGI4RwG/CZFkUmgF/qdbsxxh8EHtbreoEPA7UWx384xvjQPrTbT+02pZweSC/6Z5jX94E2x18aYzylj+1LkiSpvctpnajtWTHGtX1q+8V9qlejp9W6GODEJdbXap3TzzVOqw2f2yWc60pjg+Kn9KPuJXhMjPGMPtX9o8Bki+OfCiH05bVdjWKMkxT7gbbb+PpnQgiX979Hi1pJsacr2hx/doxxTZ/a/ok+1avh+26LYxf0qc2+JejQQL2oH5U21gqtEjTltE+0Nq9dco1+3RP8cp/qlQbGjfb7LPz/7N13vGRlffjxz8xt2ysLCyq9rIBSxK4r2A32EksISjRqxCSa6i8aH7+axJqICZqoiaJu7DVKNKKAaxcpKuAuIKwgfXu/beb3x5nL3l3unZk7c6bcez/v1+u89u6cp525M+c55ztzn29KW4GnAOsqD02U+OAFwMfbPrjZ6d+AZwErU0oPTCk9L6X0jyml/6tkXpw2IuJostdONW9JKd3WTD8ppd+SJVeo5kURcVQz/UiSJEmSJEmSJEmSJEmSJEmSJEmSJEmSpJZbU2P/3+a5eGBE9JGt9ZC7lNIW4JtVihSAd7Si7xbaUWP/oraMonU6dnwppV8Bv6xSZB7wd63qX5IkSbVVErX9tEqRucC5efcbEacCj8q7XXWtjTX2V1v0fiLV7nMWRERhiu3Va0+VfcsjoqcFff4Z2b12p7VqAfVzauz/Rov6nXUq74tPAI+rUfStKaVPtmFIE5pJsaeU0j1Un2Pn04LF5CvnIhMLzVzrq+w7KiIOybOziFgEvDLPNtUxL2vRNdILyOK8k/lZSuneOtuqdq0FcHCd7dQtIs4AHp13u1K7mfSgDVJKG4EnAxsqD02U+OCciPj39o9udkkp/VdK6Rsppbs7PZYcnA9UCybcCHwkp74+BNxcZX8P8Lqc+pIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSa3xKWBzlf1zgQ/muODQ3wAPzqmtidRKqPCsiHhqC/vPVUppN7C7SpGj2zWWVuiC47uwxv7XRMTJLR6DJEmSqvtMjf1vi4jFOff5gZzbU3c7qMb+bVNsr9rCuX3Ag6bYXh79FoHT8+wsIk4DXp1nm034y4hYlmeDEfEU4MwqRUaAL+bZ5yz3LuDFNcp8PKXUDQkFZlLs6XM19r8tIvpz7vOPgaNyblPd45oq+wrUfp9P1Z8w/ZPCKnM88Io8G4yIAeCtNYp9dgpN1kqO8PAptFVTJUlMrfi1NC2Y9KBNKpkjnwTcUXloosQHr46I93VgeJpmIqIIvLRGsfenlEbz6C+lNELtgNzLKuOSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEldqLLo/L/WKPZ7ZIvPNSUingu8vdl2qkkpXQJcWaPYZyPiuFaOI2e3Vdl3YttG0TqdPL41wO1V9vcDX4+IWougSpIkqXU+Aeyssn8FtRczrVtEvAhYnVd7mhYeVmP/zVNsr9o9DrTuPuc3NfY/L6+OImIO2f1UX15tNmkpEHk1Vllk+P01in09pbQxrz5ns4h4LVmSzGq+A7ymDcOpaYbFnv4bGKyy/1jgT/PqLCKWAN2QuEKt84Ma+1+eV3LdSqLSt+XRlrrGP0bEghzbeyPVk+oOAp+eQnu/o/o581kR0TuF9mp5C/DIHNuTOsYFytsopbSBLPHBPZWHJkp88MaIaOkHtpoRnggcWmX/XrLAQJ4+QfXJ9jCqZyeUJEmS1E4Fri/srP+2v9wH9JdoR51CuVR3eYDS4vaMqx3HUs2cuYPs3TPQteUA+geGurpcju5sd4fSDHFXq8/xjdTp1vmqkTqNHEst3X5unw7zYx5GS8Vr29aZNLPc1Y5zfDffx3TjsdTS7ef2bi+XM+99pEYYd+vKY6lmOpzbu/3eLEfOPVJjjLt14bHU0u3n9ukwP+bBuJvUMONuXXgstXT7ub3by+XMex+pEcbduvJYqpkO5/ZuvzfLkXOPJEmSGvU+qi/8DvA3EXFhRDS0oGFEvBL4Au1Z2+Qva+xfSraQ/co2jAWAiHh2RDR67Ouq7Ht4RKxosN1u0bHjSyntAd5co9iRwFciYlGrxjFeRPRExLPa0ZckSdJ0kFLaBvxnjWJ/HhFPbbaviDgS+Pdm21HzIuKMiHhhXgsjV+lnIXBOlSJlai9ufqBq9zgAZ0+xvXpdUWP/6yPikGY7qfxOPkz3JeF7bUQ8Jqe2/hY4qUaZf8mpr1ktIn4PuLBGsV8BL0gpDbdhSPWaEbGnlNI9ZIkPqnlrRBzb+Mj28y+AiSVntp8AW6vsPx04t9lOKgvjfwaY02xb6iqHAu/Oo6GIOJ7acd81lfNgXVJKo8DVVYo8CHh1ve1VExFPJ0t6IM0IJj1os5TSDcBTgS2VhyZKfPDmiKiVeUyzW60PKy9OKe3Is8NKEPBbNYr5IaokSZLUJU546zduolAeLNxbZyLQPigtKkGxRKvrlOeVKWzqqa88wKIS9LZ+XG05lir6B0aYM3eQ7Vvnd2W5rOwoO3fMravcrp31lau3vXrK5eS6U49du7ldnUkzyapz1m4qFMrXt/Qc30idbp2vGqnTyLHUkPe5OP9y3T8/Nmvn9rmDL37uJ29ueUfSDLTqnLWb6CtdT7FEYWMLz/FdfB/TlcdSQ7ef27u9XI6895EaZNytS4+liulwbu/2e7OcOPdIDTLu1qXHUkO3n9unw/zYLONuUuP2i7tN91iVcTfLGXeTpg3jbl16LFVMh3N7t9+b5cS5R5IkSQ1LKe0C/ryOoucDP4uIM+ttOyKOjYgvky1SeuCNyy/rbWcqUkrfAz5Zo9gJwNVTOZapioj+iPiDiLga+BqNr+vy0yr7isCbGmy3W3T6+D4JXF6jzOOAn0fEQ1s1iIhYEBF/AqzHhXYlSZIO9E/A9ir7e4AvRMSjG+0gIh4AfBtY3mgbytUDyRLnXRsRr4yI3Bc1rize/xHg4CrFrpjKYrgV1wK7quw/t/J6y1VKaT2woUqRhcCaiOhvtI9KIsSPkcOC1S3QC3wpIo5pppGIeB7wjhrFLksp/aCZfgQRcTrwObJz+GTuAH4vpVRtDmi7GRZ7eidQLaHEIuBrEdFUsoKI+CvgvGbaUPdLKQ2RvRareW8z5+pKAp/LgZMbbUNd7XUR8bpmGoiIg4H/ARZUKTYMvKuB5v+vxv53RsSpDbR7n4h4DvBl7v95ijRtmfSgA1JKvwKeDowtSj9R4oN3NnvS1Yz25Br7L25Rv7XafUqL+pUkSZLUiGV739R/yZK6i48cCeXjttKOOr03FeouDzD8xPaMqx3HUs1DH76eX15xQteWAxgdri+cNDpc3/NSf3ttC2O9vl0dSTPU+a0+xzdSp1vnq0bqNHIsteR9Ls673HSYH5txz53Lp/sfHEmddn75uK30fW9x3RUaOcd3831MNx5LLd1+bu/2cjnx3kdqhnG3rjyWaqbDub3b781y4NwjNce4WxceSy3dfm6fDvNjM4y7SU07f6bEqoy7Wc64mzSNGHfrymOpZjqc27v93iwHzj2SJElqSkrpS2QLF9ZyKnBZRFwdEX8XEasjYmVlkbXeiFgWEWdExPkR8S2yBdyfN0E7O4A/ze8I7uf1wG9qlFkJfCci/jkiDsur44g4JSLeC9wKrCF7zprxnRr73xAR74qIpU320ykdPb6UUhn4Q6BWIrnjgJ9ExFvyHEtEPDYi/h34HfAhoKkFOiVJkmailNK9wNtrFFsEfDciprygckQ8niwZ13EH7CpNtS3l7kSyJHq/i4h/jYgz8mg0IpYBXwVeUqPoR6badkppBPhelSJjr9XVU227Dp+usf/JwFcaWbw8IlYBa4FXTLB7dKrttchK4HuNvk4q54/PUX1d1hLwF420r30iYiXwDaovSL0DODul9Lv2jGrKZkTsKaV0E3BhjWInkr23phyziIhCRLwNeG8Dw9P09B819q8ALo+IKX+RLyKeBPwYeFgjA9O0cWFE/L9KgqopiYjjyJJi1Hp9/Vvl/DdVn2HfuuETWQT8XyMJbyJiTkS8myzhwdwDdnfLtZbUEDN4dEhK6ecR8UzgW2QnlrFkB4z7+V8jYndK6aLOjFLdKCIOJbsJqKbWB7yNuqTG/pMiYmVK6a4W9S9JkiRpCk6Ir1+wPj2L/i8tfc/w6h195RUjVcuXFsPQY4bou3I7/V9awvDqnbSqDqtG6Luql5EjypSX146vjZw4BGyn/ytLGH5c68bVjmOp5qBDtrLqoTdz1Y8fzLEPvpXF/bvqKrdoSXvKASxetottm+fT01tiwaI9k5ZbtHT3feXmLdjbdHv1lmvUyHDPht6+0fNOPXbt5bk3Ls0iq85Ze/m6NavP4qd9nxk5trSyFef4Rup063zVrmOpZfw5dmFv8+fivMt1at6byvzYiJ3b5w7ec+fyNz3/7E9fkGvD0ixz39wzsvMT/f+7+PDhR+6ivDz/c3w338d047HUcuA5dgmDdZXrtjlgus094L2PlBfjbt15LNXMpLhbp8o1yrlHyodxt+48llqMuxl3k6azsbmnUNrx8f4vLTlyOseqjLvVLtdtc8B0m3vAex8pL8bduvNYqjHuZtxNkiRJM8brgVXAY+ooeyrNLeb/J2QLs1VTbfGgqlJKOyLiOcAPgCVVivaQLVb4+oj4b7IFIn+cUqo7eBQRhwCPBp4I/B45L1qfUroiIm4Gjp6kSBH4W+CNEfED4FrgdmAXTBIczOxIKX0uz7E2ohuOL6X0u4h4Idm6L/1Vis4F3gH8bUT8J/Al4GcppaF6+gGIiMPJXi9PBp4BPKDeupIkSbPc+4HnAo+rUmYu8LGIeDnwT8AllSRXE4qIU4C/Av6Afev+jfchTDrcLZaTJc7704jYAHwduBT4QUppY72NRMSDgZdV2lpco/gNwCcbGm22cP7vVdl/AtkC4rcAP6n0tY3sPqdaso3vpZRurLL/g8BfAgNVyvwe8KuIeBfw8ZTS9ipliYiHkd3Dv5yJ1yu9AfgF8KJq7bTIr4CT2D9JwQOAH0TEe4D3pJR21mokIo4E3kN9x/DPKaVrpj5UHWAVcGiNMhcDZ+SV7KQOtd5f+5lJsScgkc2xR1UpcyJwVUS8Ffj3emIhlXn2A8ATJth9Dc0nClUXSin9JCK+x8S/9zEPBH4REe8D3p9S2jRZwYjoBx5Pds329AmKbAO+Bpzb+KjVYdew//mgQHYt/6SIeENK6dpaDUTEANn1ytuBhTWK3wy8rZGBppTWR8TFwDOrFDuYLMHVx4ALUkrXVWszIlYA55Bdw00UKy4D7wLe3MiYpW5g0oMOSin9ICKeS3YT3c++ZAflylYEPlpJfPD5jg1U3eYRNfbfllK6rRUdp5Q2RMQdQLWscQ8ne01LkiRJ6gInxNcvAC5Y//azjy4tLT2qtGx0aa06pfnAvN3zeq/tOYRS3/Ly/PK8A4rspr+8iTJ3F0YKu+uuQ2FDoVDe78Pj3htL88rre46gWFxxv4H0le8FfjvWB0D5sL30/qp3OeW+oybo4351uuZYJqkzkUPZy6HFW9i4Yd7ddw3NXfogtnxkonIHHbKVgw7ZytBgL9u3zaNYmPi7F3PmDnL8SRsYHurl7juW0NMz2efdJQ4/+naG9vZwy5UP/PTI3MIt1cbZ1z+y7Z47lw6NjvZMdLwM7u2bVy4Xij29pR2l0cJQuVxYDlAolEsDc4Z3H1i+VnuNlCvA7cNDfVU/kF68bMe9K1ZuWX/Ggy/bXK2cpPqtOmft5cCh69asXjZ6Q98ZFHuOq6feVM/xddTp2Dm+a47lgDrVHMQoZYpbdhYW9A2w96LJyi1eln2XYmiwh6HByf+uo6c3m2+2blrAyEhx0nKZMls3LWDr5oUfHh7unXSuXLZi67Y7bl2xdcONhy2ZO3/vpF8sy7vcwsU7+e1vVm4sl4p91coBlMuFW4sFaiaFHS0Vr33xcz95c61ykuqz6py1l0fEw49aeMdBK6/oP2ZO7+iDCotHlgAUC6XRBQO7J70mbOQ6Puf7mNzO8V1wLBPWmcyh7GVl8bdb7v7t/I3bb53/6IMm+bJIq+59Bvf0sP62w/+52FOeNEtbvXNAK8rd+bvlQ7fdcgj9A8PV/pDSex+pg4y7dcmxzMK4WzeUc+6ROsO4Wxcdi3E3427SLFGZe45at2b1soGfzjmh3DNwVD33PtAVsaoZFXfbWx7YOVLquYOR4n4rJk8U/zTuZtxNmu6Mu3XJsRh3M+4mSZKkWSWltCcink22cORDW9jV21NK/11ZVLCaprKDppSui4hnkS1kP79G8X7gvMo2EhFXki2uv7mybSFbpG4O2WKbK8kWgqtnkb48XAD8a40y/WSL3z2xzjZ/S7YQZze4gA4fX0rpsog4h2zxwVpr8CwA3lDZ9kbET4H17Hu9bAP6yF4vK8heL8eQvV4OqndMkiRJ2ielVIqIPwCuIFtItJonVLa7IuJy4NfAJmCUbGHq48iSJxxfpY2fkV2nmvSg+xxJJQECQETcBlwHbADuILse30t2DzGf7B7uBLL73CPr7GMEeGVKabjBMX6ObHHaWveLR1F9kfEDnQdMuih7SumOiHgv8JYa7awke32/KyKuIHtf3U323PWT3bccDzwWeFCVdoaBPwReV+f483YV8F2ye7PxBoC/B/48Ij5LFhf4JXAn2WtjAdlr4Qzg2WQLF/fU0d811H5ulZ+XVLZ2qfr+mshMiT1VEjicA3yP6jGRRWTnjr+LiE8Dl5Adwz1k54NFZPGPRwHPB86apJ0R4JXAlXmMX13pjWRzS7Vz6wDZIu5viogfV8rfQzYXLSW73jua7HW0oEo7f0yWAEfT16uAn3L/18uTgF9GxHeBr1TK/AbYQXZOXQE8BHgK8FJq3yNAdv75w5TSjibG+9fA08jiv5Mpkh3XqyJiPfAj4Bayc/0o2fnySOBhwOlUf6/8G/AdTHqgacykBx2WUvpORLwY+CLZCefAxAc9wKcqiQ++0bmRqoucVmP/VS3u/0qqJz04DZMeSJIkSV3nhLdefDNZxlFNI+vWrD6pVONz0v6BEfoHmvo+9/2s/G3pcyc/+3//p5k2IuJgJo49jaSU7mmmbUnTw6pz1m4Gvl3ZNE2sW7P6pHo+OugfGKV/YE/NclOxZPnOfzv12LVVM5ZLUjW37Dhs6y0cdiVwJfu+duD1Z5c7GVgfz5xTZk7Vcq2491lx6PaPO/dIapZxt+lpOsfdJMm42/Rk3E3SdFaZe35c2dQBjXz+btxN0nRn3G16Mu4mSZIkTV8ppU0RsRr4KnBmC7r4+5TSP1R+nluj7KQJNeuVUvpBRJwFXEy2CFI9eoFHVrZu8R/Aq8lCfjNRVxxfSukLEbEL+AJw/6SFE5vDvkV1JUmS1EIppVsj4jlkidpq3U9AtmB0Iwtm3wm8kPoWQVfnPYjqC/M34vUppR80WjmlNBgRf0mWVK3d3gE8g2wR3VrmAI+vbFNVBv4opfSziOhU0gPIFgB+AhOvybiI7F7z1Tn0cyfw7JTSUA5taQaZKbGnlNKPKu/lj9RR/GD2JYNsxFtSSldFRIPV1e1SSldHxD8AqY7iPWTJqB7XQFdvrsTzTHowjaWUroyIvwf+aYLdBeDJlS0Pf5JS+lEzDaSU1kXE/wPeV2eVEypbI74J/CWNvT+krlHs9AAEKaX/IctYV648NJb4YOznPuDzEfGkDgxP3efUGvt/2eL+f1Fjf62kDJIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkqUuklLaRLSIUQF7ZyjYCLxqX8ABgSY06TSc9AEgpXQE8gmmc0DWlNAy8ALi302NphW46vpTS/wKPBdZ1eiySJEm6v5TST4DfA3a2qIvNwLNSSre1qH11txHgtSmlDzfbUErpM8AHmh/SlPsdAp4L/LaF3ZSAP08prWlhH3VJKe0GngXc3sJu7gWe4XlBk5kJsSeAlNJHgbe0uJuLUkrvbnEf6g5vB77UwvbfmVKaaJF8TUMppXcCn2hxN29OKf1nHg2llP4ZyKWtKi4n+0wlr89opI4x6UGXSCl9DvjjcQ8dmPhgDvC1iHhsu8emrnN8jf03trj/39TYf1yL+5ckSZIkSZIkSZIkSZIkSZIkSZIkSZIkSTlKKY2mlN4GPAT4CtmCho3YA3wQODGl9MUD9i2pUXdTg33eT0ppA7CabOG2XXm1W6ch4MvAaDONpJRuAB4F/DSPQXWbbjq+lNI1wMOA9wPDbe5+F/DVNvcpSZI0raSULie7vr8556Z/CzwupXRlzu1qergWODOPhAdjUkpvAP6K7N64bVJKvyNL5vajFjS/E3h+SunfWtB2Q1JKtwOPpzXrLm4AVqeUftGCtjWDzITYE0BK6R+BP82jrQn8B/CqFrSrLpRSKgEvAz6bc9PDwGtSSn+Xc7vqvFcCH2lBuyPA61uQJOM1ZImjyzm3C/Ax4KkppXbPJ1JLmPSgi6SUPg78GfuSHcD+iQ/mARdHxMPaPTZ1lSNr7L+pxf3Xav+oFvcvSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZJaIKW0LqX0fOAY4G3Az6i96Nku4NtkC6QdnlJ6fUrp3gnKLa3Rzl1THG5VKaWRysJtxwH/TusXoLsCeD1waErpBSmlphc/SindDDwaeAnwA1qzoFLHdNPxpZR2p5T+AjgJ+DStTX5QBi4DXgGsTCm9voV9SZIkzQgppauB04GP0niStvE+BpySUvp1Dm2peZcALwY+BWxscV9bgb8ATksp/TDvxlNK/wysAj5A649lfL+3A2cCF5Df4uVfB05KKX0tp/Zyk1K6BXgM+SaR+yLZ62Jdjm1qBpsJsSeAlNKFZOePW/Noj+x5eH1K6U9SSq1IpqAulVIaSim9FPhz8nk/XAk8PKXUioXx1WGVRMyvIVuLe3dOzf6WLKnVB3Nq7z4ppVIlcfTZwN05NXsb8NyU0itTSu1Oxiu1TG+nB6D9pZQ+GBELgHeSfUBVqGzlyrYI+L+IODOldG3nRqpOiIiVwNwaxW5v8TBqtT8vIg5OKd3T4nFIkiRJkiRJkiRJkiRJkiRJkiRJkiRJ6oCUUqHTY5DUWimlDUAAERFzgeOBI4CFQB+wE9gG/Aa4pc5F1k6psq9EzkkPxqSU7gReFxF/B/wh8ELgsUBPk03fDVwKfAe4JKV0W5PtTajy3H4O+Fxl3YmzgIcDJwCHAyvI1iMZAIqtGEMrddvxpZRuBP4gIv4SOA94PvAwsvVfmvFb4Ltkr5fvui6HJLXeytes8L5FmmFSStuAV0fEB4G/Bl4E9E+hiWGyRc3fk1K6Jv8RqlEppV3A54HPR0QReBTwJLIkaY+idhK9WkbIkvWtAb6aUtrTZHtVpZRuBd5Qua94JNk96EPJEgyuBJaTrSnYS/P3GuP7HQbeGBEXAn8LvJypvUcABskSCXwgpfTjScrcQrYQ9UTumGJ/DUspbQSeFxHPB95K9bhDNdcAb0op/V9eY9PsMt1jTwAppR9ExCrgb4A3AEsaaGYE+Czw95XYomaplNK/RsQXya7XzgMWT7GJnwPvBb6YUsoj2ZW6WErp3yLiYuAdwO/T2HrpW4F/Ad7Xhuu8b0bEkcCrgL8i+9xkqq4GPgj8d0pp7wT7dzD5tdbYfqlrmfSgC6WU3h0R84G3MHHig2XAJRGxuvJBmWaPw+ook1e2n8nU8yWBwwA/XJUkzTwFri/sLMLctsc/7mx3h5ox7to+MpfCziLlBfu/bueURthb7KWws43fXxwtmLhNmrq7CuUS5QUF36+aLu7au2cA5pYoT/Ddiv7SaHtfyxmvpaSpuYv+EoU9xRy/IlU3369qSKlUvL68oPK6PcCc0gg7Bue1e0i+lqWpMu6m6ce4mzT9GXfTdGPcTZr+jLtp2jHuJs0Axt00/Rh3k6Y/426aboy7SZIkTUFlkaBfVLZmPLLKvlsmWdwnNymlrcC/Af8WEcvIFs58BHAi2cJEDwAWAPPIPtnZCWwnW0BoC3ATsK6yXd+JNT9SSncBn6lsrerjcjrxyRbtOb4pjuWdwDsryRgeTZaMYRVZMobDyF4vc8nWg9kxbtsE3MC+18t1KaXftmCMFwEX5d1uHf0e2YE+L6IDxypJkrpTSukXwDkR8WfA04EnAicBR5ElzOpn/0Rt1wHfB76VUtregfFehNcydassbvyjykZEFMiuw08BjiVLHHAMcAhZYr6x+7hBst/59sq/N5ItKHs1cFXlnrCtUkqjjDuWNvb7G7IEIX8FrGZfcrmDyRIuLCFLArKT/e9f1gKXV5JQVGs/yBIltmLsRzZQ58vAlyPiiWSJ654BHF2j2m+Bb5EtNvz9qfY5xfGd2cK23wa8rUVtX05O8YFOxhraabrHnioxwIiI9wEvBZ4HnFkZ72QGgSuArwOfqZaYYbYnU27l+7WOvo/sQJ93kCXieRPwVLL56HSy67UVZDG1YbLX/x1k12tXAF+vzGPV2n4brTv3ndmKdmv0eTkdOEe26lgb+f2klG4mS0T7d8BLgGeRXbtUS960C7iMLFnTZ1JKuxsYbkMqn2VcGBEfAk4ju9Z6AlnceHll66mMcTtZwqj1ZAk9/q+SIKta+1cCZ7TsAKQWM+lBl0opvbWS+OCNTJz44BDgO5XEB7l/qKWutbzG/u0ppcFWDiCltCcidpLdLE2m1jglSZqWTnjrN25a/6cvGizs7Blgb5ny0tF2dHvdqceu3dyOjjTzpJQ2RcT1I3M5sbCzSOmgYYob+wAYKJWYUxph+8hc+u/tpbxipKVjKWzuGTz53Itvbmkn0gy06py1m9atWX19YXfxxPKCEgXfr+pyY3PP9sF5Jy4u791v7gEYKJfZMTKH3ja8liu8lpKmaGzuoad0Yrm/0Ja5p8L3qxr2+8/95E0/uOppg3MWlgbKc8sUt+77+GugVKJnT4Hyxj4KBw23Yzi+lqUGGHfTdGPcTZr+jLtpujHuJk1/xt00HRl3k6Y/426aboy7SdOfcTdNN8bdJEmS2i8ieqi+SM917RoLQEppM/C/lU2qqpIA4SuVTZIkSV2icl3/6cqmGSqlVAZ+Xdk0BZUkH9+obDNeSulS4FKAiFgEPJh9yTF6yRaYvwdYl1K6t1Pj1OwwnWNPlcQn/wn8ZyWmdwxZ0pnFwAD7FvHeANxUSfAiTaiyRu7XK5tUVWWN7XcD746IXrJzz5Fkic3mAXvJklvdBNzc6fNPJVnXlZXtfZ0ci9RNTHrQxVJKf1lJfPBqJk588CDguxHx+JTSnZ0bqdpoWY397coeup3qSQ9qjVOSpOlr2d439V+y5P1DT9zarh5f366ONGOdf82Kgy47/ZIRhp6ylTmfWXHfjjO23M3Plx7CmZfsYPBlG1s6iJ6b57yJR7S0C2kmO7/3psJlQ0/ZSv8lS3y/ajo4/5dXnHDZ4x/yy/vNPQDDhSLz2vBarvBaSmrM+eXjtl5WvnNxW+aeCt+vaso9dy5/06Kn3PP+vu8uvt++M7bczfU/PZaTzm7L9xl9LUuNMu6m6ce4mzT9GXfTdGPcTZr+jLtp2jHuJs0Axt00/Rh3k6Y/426aboy7SZIktddzgPlV9v+kXQORJEmSJEkzWyXhw087PQ5puqssKH5DZZOktkkpjQDrKpukaaRQLpc7PYZpKyJK7EtGMP7fP04pfSzHfj4F/MG4Pqj8TOX/vwbOHJ8tLiJeCXx0ovGllHryGttsERFnApdVKfLblNKRbRjHa4F/r1Lk+pTSSW0Yx6+BVVWKvDal9OFWj6NeEXE+8Lo2dHUMWea5A60HVrehf6mWg4CJ5oBRoC3fvpZmiqeXrnt139zRt46evLuvvHiU8tL8k/yVB4v3bN89/zU/vvS0H+XeuGajxxw7964PH1+852AOH6TvqvkUN/cBcG//XG6dt5DjFt1J/+M2Uz5oJN+eN/cOj9wy/+3f2XDKR/JtWJpdnnDo1Y9ZOLD3w6V5vQcXf9fP6Gm78n+/bukZHrl5QZ7vV68/Z7fHLD9k0wdOedAth8/ZXabvyn1zD8CWvn76Dt1N7+O25P9aBsqDxVu3757/515LSY17wqFXP2bxrqEPsHXe4aWFZUbP2On7VV3vuBNvefUDi1veuuDXfX3Fbb0Ut+3L/X1v/1w2Hlng8IffSnH5cO59j+zpvWfX3rnex3eW158zgHE3TUPG3aRpbprG3dQdOnX9adxNmuaMu2k6Mu4mdYWmrj+Nu2kaMu4mTXPG3TQNGXfbn5+/a9ZLKd3T6TFI0kwVEZcBZ1Yp8piU0o/bNBxJkiRJup+IOBK4pUqR81JKF7VnNJIkSZIkTT+9tYuoC7wcmAc8j33JC8YSGQA8GPh2RJyVUtrakRGqXebU2L+7LaOAXTX21xpnu60ATuxg/wU836o79DD5a9HXqDQF3yqe9DEG+dgpV956+LKFO04vLh4+qljgkGbaLFPYNdrHxj0LitffsXP5L269+bCtlV2+P5WHn920Z+VpN7FyyQM3bHrowUdsOan/mJGDevcwH3ZyODvZXurtH/7pYYv7iqPzi/NGJkrkdD+FUXYUimwcKvb8bqTcu3n8voGe4a27hwauunbL4bdWHvK1LDXhe3ee9jPgtKMW3rHksPmbHzrnugUnFcscxLzS/GbaHe3nnpHR3ps3b1vUiver15+z28823b380ZfevXzJ4mXbj3ngifeesHBw+Jhs7gHYwwgFhq84eEGJwkH1zj09ZQbLxfKm0eHeu4bp2VjqLewZ2zfQM7y1vGTktruHF//GaympeZW559FHLb5jycqR7cfM/fGSE3oWjhzT7NxTprBrpNR7864FxXW+X5W3G68/6mM3ctTHVhy66fBlK3afvmjP4FEDxZHK/fpODgK2XL2if4TC8v6+kUX1tNlTZrBQLu8aGem9c6jYc/v4uQegvGj0lq3M9T6+O3j9OQMYd9M0ZNxNmuamadxN3aFT15/G3aRpzribpiPjblJXaOr607ibpiHjbtI0Z9xN05Bxt/35+bskSWqJiDiD6gkP7gWuaM9oJEmSJEmSJEmSJLWCXzCaBlJKpYh4CfA14OncP/FBATgF+GZEPCWltLNjg1Wr9dfYP9KWUdTup9Y4JUmaEX7B4beyg1vZ0emRSHXb+rs9y9f+bs/ytVVLtSuVlqQpu2XHYVtv2XHYWiB7H2/q7HikOmzdtnnRlds2L7qyaqm85p67c2pH0n1u2XHY1ls47ErgSjbh3KNp4d47l996L8tvrV0yBxvb0os06xh30zRk3E2a5oy7aRoy7iZNc8bdNB0Zd5OmP+NumoaMu0nTnHE3TUPG3SRJklokIuYDa2oU+0JKqV3rJUiSJEmSJEmSJElqgWKnBzBDlFvdQUppGHg+cDn7kh1wwM+PAL4REXNaPR51jEkPJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElS14uIAvAfwAk1iv5XG4YjSZIkSZIkSZIkqYVMetC8QmWDFic/SCntBZ4F/JSJEx8UgMcDX8FF52eqWu/Z0baMonY/PW0ZhSRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJalhE/GdEnNmCducDXwLOqVH0kpTSVXn3L0mSJEmSJEmSJKm9THrQnD8BPgz8BNjN/gkQWiKltAt4OnANkyc+eCrw9laOQx0zUmN/b1tGUbuf4baMQpIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkNePJwGUR8eOIeEFEzGm2wYh4IvBj4Hk1ipaANzfbnyRJkiRJkiRJkqTOa9cC6TNSSunDYz9HRAE4FjgVWNfifrdFxFOAtcAq9iU7GJ/4YHmleEuTMKjthmrsb9d7uq/G/lrjbLd7gevb0M8xwMAEj5epnbBCaofRKo/7GpUkSVLevP6UJElSO3n9KUmSpHby+lOSJEnt5PWnJEmS2snrT0mSZrdHAV8EtkfE1yo//yiltLGeyhFxMPBE4M8rbdXj31NKVzQyWEmSJEmSJEmSJEndxaQHOUkplYEbK1s7+tsUEU8Gvg8cxf0TH4AJD2ai4Rr7+9syimmW9CCl9EHgg63uJyKuA06cYNdoSumeVvcv1RIRMPHcP+JrVJIkSXnz+lOSJEnt5PWnJEmS2snrT0mSJLWT15+SJElqJ68/JUlSxSLgDysbEXErcCVwK7AF2Eq2psCyyrYCeDiwaor9XAX8dS4jliRJkiRJkiRJktRxJj2YxlJKd0bEk8gSHzyAiRMfaGbZWWP/wraMIvuSQjW1xilJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkrrf4ZUtT7cAz00p7cm5XUmSJEmSJEmSJEkdUuz0ANSclNJvgScBd1ceGkt2UOjMiNRim2vsb1fSg1r91BqnJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmafa4HVqeUbuv0QCRJkiRJkiRJkiTlp7fTA1DzUko3RsRTgMuBZWSJD0x6MDNtqrF/STsGASyusb/WOCVJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ0uzyceD1KaXdnR6IJEmSJM00EXEc8IROj6NOO1JKn+v0ICRJ3S8iVgPHd3ocdbohpbS204OQJKmTTHowQ6SUrouIpwPfARZh4oOZamON/QMRsSSltLVVA4iI5UB/jWImPZAkSZIkSZIkSZIkSZIkSZIkSZIkSZIkqft9HTiXbK2KVvkJ8NcppR+0sA9JkiRJmu0eC3y004Oo028Bkx5IkurxR8DLOz2IOn0CMOmBJGlWK3Z6AMpPSulK4JnAWEb78rhNM8OtdZQ5pMVjqKf9esYpSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZI6KKX0p8AK4FnAfwE35NT0vcDHgUenlB5twgNJkiRJkiRJkiRpZuvt9ACUr5TSDyPiucBXgfmdHY3yllLaGREbgYOqFDsCWN/CYRxRY/89KaVdLexfkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiTlJKU0BHyjshERy4FHAycBRwJHAQ8CFgHzyNaz6AOGgD3ARuB3wM3A1cDPgCtTSqV2HockSZIkSZIkSZKkzjHpwQyUUvpuRCwGHgycXtkeBpwCLOjk2JSLW6ie9OA44Nst7P+4GvtvaWHfkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiSphVJKmxiXBEGSJEmSZoOU0gag0OlxSJIkSZI0Xc3KpAcR8WngF2NbSunODg8pd5Vs99dVtk+NPR4Rx3dsUMrLdcDDq+w/ocX913oNXdfi/iVJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiR1iVmZ9AB4CfDisf9ExCbgl4xLhABcn1Ia7szwWieldEOnx6CmXQ28osr+01rc/+k19l/d4v4lSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkdYnZmvRgTKHy70HAWZVtzDAwp+0jkmq7qsb+UyOiJ6U0mnfHEdELnFKjmEkPJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJKlNUkoXARd1eBiSJOUqpfQK4BUdHoYkSarTbE96UB73c+GAfX21KkfEQ4C7Ukr35joqqbqfA3uZPCnHAuBhwM9a0PcjgHlV9u8FrmxBv5JydNTCO5asHNl+zMCewnKAHkqj6+OZ28b2b2begs3MX9rXNzRvLkOH9A4VFkzUzl56B3aU5lLoHd010DM4v2944vPDKMWRQfp6y72l7f2F4d5uLVcolkb6i8P0jEx8fdRHaXcP5cHSaHHnaKF4d6nI7uGR3uW7RweOGiz03td2sVzeXaQ8ODrSu3MP/XcPF4u7J2pvzHChOG+4WFzcUy5vGy72/HJr/5zfHbx31wMO6tlxytw5exZPVGew3DtnL333/V6Gy8WBwkhhyQL2LpzbN0SB8vB94ymU9xaK5a27Sv27dpfn9B5YZzF7+gb6hnrGt18slPfuLfdt3Mmc/RLoDJeLA/3lkRVLinvmjO+jWp3CMAsHGD7kwHEBFHrKW/aU+jaPH1e1Oo0eS6FY3jpSLm4qlXv2HvhcDjC8ra9Q2u93tKCwd8uC8tBPVr354psPLC9JkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ2t9sT3owluigTPUECJN5D/DUiLgDuGr8llK6PbdRSuOklPZGxA+AJ1cp9hRak/SgWp8A308p3W9BaUnd4QmHXv3YRbuGP1DcsPBB7NmX26dIkUJpIXcPzOPnSw9hzsJdPKL/ZhbcMkBh9/1zAM22cvsU7/tpc18/2/r6uX7RQWyfM1ClztQcvHcXz9p9HfOO3gjzR+4/5j1Luere49k+vGC/Oo8sbahdZ7S+OhP1AXB88Q4efsgN9MzfL29B28bVaJ1m/PojTxwubB74m1Vv+uYFuTYsSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSTPIbE96MGZ8koPypKUmr/sA4DDgmWMPRsRG4Gr2T4Rwc5PjlMZcQvUEBM8H/rEF/b6wxv5vt6BPSTlYt2b1WUv2zP8yvz5owv13D8zj0oMP5+A5mzlr3nUUf7HCcpPY3DfAcLGHnyx/QN116nHw3l08cfgmyqdunHD/3XuWcvkdp7e0zkTlIUt4cNpRv+7YuBqt06zCvJE+5o28f927noGJDyRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRpYrM96cFUExxUa6dwwGMrgKdUNgAiYjv7J0K4GliXUsprHJo9vgi8u8r+0yPihJTS+rw6jIiTgIfUKPalvPqTlLsLCzcvmnTi+/nSQwA4fcUNFK5ZMmkjs63cRPrKJX689LAp1anHGVvupnza1kn3X3Xv8S2vM1F5gIcefFNHx9Vondws2/su4ILWdyRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ089sTXpwPXA89z/+ZpIPTFT3wEQIi4EnVLYxuyPil+xLhHAVcF1KaaSJsWiGSyndHBE/Bh5dpdifAq/Psds/q7H/hymlW3LsT1JO1q1ZvZzh4omFPX0TTlaDxSLb+wboLw6zuLCHwu4lE7Yz28pNWLdQoL80yva+gbrr1KN/dJRF7KE8f+Lpf3C0l+3DC1paZ6LyAAvKe+mZP9yxcTVaJ1fzRgfW/ePZR69688U3t74zSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZpeZmXSg5TSyRHRD5wEnAKcWvn3ocDSBps9MMFBmfoSIcwHHlXZxgxFxHXsnwjhFymlwQbHppnp41RPenBeRPxjSunOZjuKiAcC59YodlGz/UhqmZUMFSfdOVjsAWBOzyDVyu0t9s6qchMZKvZQKkytTj3mlEagvzTp/r2j90+ykHedicoDLCru7ui4Gq2Tu0L5ZMCkB5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZJ0gFmZ9AAgpTQEXF3Z7hMRDyJLgHDKFJscS3BQOODfA8vUkwhhADgdOA14ZeWx0YhYx74kCFcDV6eUdk5xnJo5PgX8A3DwJPvnAe8CXp5DX+8G5lTZf3dlPJIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZJmkVmb9GAyKaXbgNuAb0yh2ljSglpJDaaaCGF8+V7gZOAk4A/H6kbEb9iXCOEq4KqU0pYpjF3TVEppb0R8APjHKsXOjYivppS+0mg/EfEi4GU1il2QUhpstA9JkqR6rVuzetloue8Mij3H1V1pF8spF44qzy/Pu9++vvK9wG8LI4XdddbZTX95E2Xu3q9OuTSPPYVDKBWXT1iHwoZCobxxv0fLpXnlEkdQLK6YYNQT12nHsVRRpriltHLkltIRQ+tPPXbt5nrqTMXnvnru0T3F0sm1ypXKHFIolI+oVqavf2RbabQwNDraM9Hzu1+5vbsHtg4N9i2ZO3/v4naVA9i7p39juVTsq1WuXC7cWixwV7UyAKOl4rUvfu4nb65VTtLUrFuzehkb8E5+kQABAABJREFU55xQ7uk5qrRsdGldlRo5x1er0675apI6bTmWKkrLR28aPXb4ilbMPRGxbOUD7z1h+YqtVeeLPbsHFpTLPCCvc3unypVKhaGR4V76B4b7q5Xr6x/ZVoDbh4f6qiZcXbxsx70rVm5pyXWBNNutf/vZR5eWlh41lbmnkXN8rvcxU5+vJq7TrmOpokxxC6M9Pzn53Itzv77Oe+6Zyrm93nukTpVz7pE6y7ibcTcw7jYZ425Sa0z3uNuTHzS/WCoXewAKlOYWB8sHFcssLcwrzbl2zVMHJ6pj3O3+jLtNzHsfqXWMuxl3M+42MeceqXWMuxl3A+NukzHuJrXGdI+7+X23ye9vJrufGRrsnVMuF5YPzBmeNzzU018uFxb29w8PlMvMKcC8kdFiqVQq0t83UhwZ6ekplQr9ff0jvRTLI4VyYYgyo/sNoFgePu6kvuFyqVACdpQp7CoWy3sos6VULuz56rdefOfYfYbnckmSJEmSJEmSJEmSJEkHMulBc94IPA44vbI9BJh7QJlWJkIoAMcBxwK/P/ZgRNwKXM3+iRBqfmFY09IFwGuAw6uU+URE3J5S+tlUG4+IRwEfq1HsVuADU21bkiRpKtatWX3WaLHv0yPH9awsLx8GhmvW6b2+n+L6eQw/biflFSN19TPVOsVt0HdlP+Wt8xh+/E7KK2rngSpug57f9DJyRJny8tGa5RsZV6N1puKa65+wgf7yeaceu/byZtv68sUve+PBh2565wkn7xmoVm7r5gX09o2yYOGequ3VW+7eu5Zy2y2HcOyDb2PRkl1dV64RP7jqaYP33Ln8Tc8/+9MX5NqwNAutW7P6LDYNfKw0uOTI7By/t2adRs7x7ZgX2jVfNVJnKq659gl3Maf80jzmnog46+DDNn7srLNvOrIb54DpNPcA/PzXZ23o7RvN5bpAmu3Wp2e9cXRe8d3DT9nT18pzfDfex7TrWKbiFz87a7jn5jl/c/JLvnlBs211au6B/O+l8i7XCOceKT/G3Yy7gXG3ehh3k/IzU+JuvXtLsK1A3y/7KW+fy/AjdlFePkKhWGZkzuTzqXG3TLfPFd0w94D3PlKejLsZdzPuVh/nHik/xt2Mu4Fxt3oYd5PyM1PibmN9zMbvu012fzPZeXj844N7++/7uVQq0Ns3yp5dcybcX8+5fHBvH6XS/f/stVgsM3BA/NNzuSRJkiRJkiRJkiRJkqTxip0ewHSWUlqXUvrPlNLrUkqPAhYCDwVeQbYI/PeBnexLVjA+aUF5gm3MgeWr1SlPUPYI4DlAAF8Hbo+IOyLiGxER+T4L6qSU0m7gL2sUWwh8OyKeNZW2I+I5wP8BC2oU/YuUUv5/OSVJklSxbs3qs0YLvZcOP2J45VT+OKbnmkUMPW/rlP5ocip1itug/0f9cNcihp5ff52edb0Mnz4ypT/0afWxNKS/fCRw2TU3rT6zmWa+fPHL3nj0Cb/7lwWLav8B6JJlO+v6A9B6yt1711JuuPZITn/0upp/sNmJco1asGjPwNEn/O79X774ZW/IvXFpFlm3ZvVZbOm/tLxt4ZGtPMe3Y15o13zVSJ0pm1NeSQ5zT0ScddAhmy999Fm/qLn4TTfPFd0y9wD09o0eSQ6/G2m2W5+e9cZST9+/DL1gS90LrzVyju/G+5h2HctUlZeN9o2csev91372GW9opp1OzT2Q/71U3uUa5dwj5cO4m3E3MO5WL+NuUj5mVNxtO/T/vB/uWcDQM7ZRXt49xzJlxt1aWq4Z3vtI+TDuZtzNuFv9nHukfBh3M+4Gxt3qZdxNyseMirvN0u+7TXZ/M9l5ePzjg3v77/u5VCqwZNlO9uyaM+F+z+WSJEmSJEmSJEmSJEmSWq230wOYSVJKJeDayvbJsccj4jjg9HHbacCyA6ofmPhgTOGAfw+sM/7fieqNWQn8HvAMIE16ELNARKwGjp9itRNq7F8QEa9qYDjfSynd2EC9+6SUvhgRnwZeVqXYYuBrEfEZ4B0ppXWTFYyIE4G3Ai+uo/v/Til9aUoDliRJmroLR46d6JJ3cn2XLmHvize3tE7vBijcuITBl06tznAXHkuTLgRObrTywYduemc95Xr76vzjqDrL/ernx3PG467t2nLNOvjQTe8CLmh5R9LMdWE7zvHtmBfaNV81UqcJTc09wIUPOeOGmoW6fa7otrmnotnfjTS7bZ7zzqGXbaq7eKPn+G68j2nXsTRq9Oi9zV5fd2TugfzvpfIulwPnHqk5xt2Muxl3myLjblLTZkzcrec2KNy8iMHnbm3puIy7Tf9yOfHeR2qGcTfjbsbdGuHcIzXHuJtxN+NuU2TcTWrajIm7zeLvu014fzPZeXj84+N/HptXJtvfSp7LJUmSJEmSJEmSJEmSJIFJD9qisqj9jcDnxh6LiMPZPxHC6WSJCcabLBECZEkNJkqEUK3eZOVnmz8CXp5zm8uBjzZQ7zyy10azXkP2GlpVpUyBLDHCyyLiauBHwC3ATmAhcBTwWOCUOvtcB7y20QFLkiTVY92a1cvL5cKJ5eVT+KPt7UUYKVJeMdK6OsNQ3F6E0tTqFHYX6Lpjad5J19y0etmpx66d8l+dfv6r5x57/Ml7BmqVGxrsYcHCPTXbq79cL3v3DLBoya6uLJeHBYv2DHzuq+ce/eLnfvLmlncmzTDr1qxeznDxxJaf49sxL7RrvmqkTnMannsiYnlf//CJ3ToHTOe5p6Lh3400261/+zOPpTxvoNXn+K68j2nXsTShvGx04NpPnn30yedePOXr607NPVnZvO+l8i2XE+ceqUHG3Yy7gXG3Rhh3kxo34+JuO4pQLlJe3mXH0hzjbl0491R47yM1yLibcTfjbg1z7pEaZNzNuBsYd2uEcTepcTMu7jYLv+822f3NZOfh8Y/v/3M2r0y2v9U8l0uSJEmSJEmSJEmSJEkCkx50TErpVuBW4Ktjj0XEIcDDgNPYlwjhiAOqlg/4d7zCAf9OVE8zUEppZ0Q8Dfg+cHgdVU6rbI26FXhaSmlnE21IkiTVY2W5UATq/6OS4rYi5QWlKXUy1TqFYWBo6nW68Vhycigw5T8CLRZLJ9ZTbmiwn/6Bev64s75ye/cMMGfuYNeWy0tPsXQy4B8OSVO3sh3n+HbMC+2arxqpk4OG5h5gZTfPAdN97qlo9HcjzW5lTmzHOb4b72PadSxN6yk3en3dkbkH8r+Xyrtcjpx7pMYYdzPuZtytQcbdpIbNqLhbeahIeV73HUsOjLt14dxT4b2P1AjjbsbdjLs1w7lHaoxxN+Nuxt0aZNxNatiMirt167HkoNrcM+H9zWTn4fGPj/95bF6ZbH87eC6XJEmSJEmSJEmSJEmSZNKDLpJSuhv438oGQEQsZV8ChLHtWO6f2KBM9UQImuFSSrdGxJOAbwHHtLCrm4CnVxJ3SJIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZrFTHrQ5VJKW4DvVjYAImI+cBr7J0JYxf1/n5MlQtAMlVK6KSIeDnwGeFoLuvgW8LLK61KSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnSLGfSg2kopbQL+EFlAyAiBoBTyBIgjCVEOBkY6MQY1TmVhARPj4iXA+8BDs6h2XuAv04pfTKHtiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiTNECY9mCFSSoPAzyobABHRC5xElgBhbHtoRwaotkspfSIivgi8HHg98OAGmvk1cCFwUUppd57jkyRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkjT9mfRgBkspjQC/qGwfB4iIQkcH1QVSSq8AXtHhYbRFSmkX8CHgQxFxPPB0suQXJwEPABYC84DdwA7gd8D1wFXAN1NKN3Zi3JIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKmB5MezDIppXKnx6DOSCndANzQ6XFIkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJmjmKnR6AJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmankx6IEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSGtLb6QFMZxHRC/wz8AvgSuDalNJoZ0clSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSVJ7mPSgOWcCfwqUK/8fiohfkSVAuAr4XEppe4fGJkmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElSS5n0oDnPq/xbqPw7ADysst0FXNSBMUmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS1BYmPWjOc4DyAY8VKo9dkFIazrvDiDgIWArsATamlPbm3Yckaca5i/7SpDsHSqMA7B0doFq5OaWRWVVuIv2lUShMrU499hZ7Yag46f45PYMtrzNReYDtpXkdHVejdXJXLlzbvs4kSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkafow6UGDIuJY4DCyBAdjiQ7GbAP+Pce+ng28CjgTmD9uVzkibgN+Avwv8MWU0p68+pUkzQyrzlm7ad2a1deX5w6fyJ7+++0fKJVYNDzI9r4BtpXnsmTeMIXdfbO+3EQGymV29PTeVz8vQz09bGcuC3f1wvyR+/fbM8Kivp1sH17QsjoTlQfYWZjD6K4+eubfP5dTO8bVaJ1c7e4ZXPXmi29ubSeSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSND0VOz2AaezREzw2lvzgaymlnc12EBFLIuIS4CvA2cCCSh9jWxE4Avh94CLg9oh4W0TMa7ZvSdKMc3756O2T7jxjy90AXHnvCZSP22q5KoYLxfvq5+nnSw+hcOOSSfc/bMX6lteZqDzAL+85tqPjarRObjbPeVPrO5EkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKk6cmkB42bKOnBmK8023hELAF+ADyRfUkOypNsY/uXAH8P/DoiHt/sGCRJM8eqc9ZevnXuwPNKD958G3OH77f/kMHdPPGeWxnaMY9Ld5/MjpN2Up5nuYksGx6krzTKozbdzuLhwbrq1OOeOfO5tO9Ydv1qJezqvd/+g+du5azDrmRR386W1ZmoPMANpcO4+pYHM7qrryPjarROs8q7e4f53fw3rnrTNy/IvXFJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJmiHyXx129njYuJ/L437eDfxfDu1/BDiRfYkNxhQm6PfA/Q8CLo2I16WUPprDWCRJM8D37jztR8CjjjrijiUrR7YfM7CnsBygh9LoADu3HcwOnsHdbN47b8Fdew9a2rdyaN5chg7pHSosGN9OLzt4JDvYu6d34PZdB1M4aHTXQM/g/L5h5u3f425O4RZG9xRH7tqzvLd8cGl7f2G4t1vLFQ4qjfQXh+kZmfj6qI/S7h7Kg6XR4s7RwtDdA8Wh3SeN7F2+e+/AUYOF3vvaLpbLu4uUB0dHenfuof/u4WJxd7Xfy3ChOG+4WFzcUy5vGyr2/PIbc0763cEbdj3goJ4dp8yds2fxgeWP414Gi1vm7KUv+73Mg1+VVwwUbj94yQL2LpzbN0SB8n0ZHIqF8t6Tinds3dXTv2t3eU7vgXUWs6dvoG+oZ3wfJxbu3Lu32LdxJ3NGxx4rUeSKu1cN9JdHViwp7pkzvo8J68yDdSyncPvyhQMMH3LguAAe3HPnlj09fZvHj6tanUaOpVgo7y0Uy1tHysVNpXLP3gOfzwGGt/UVSvv9jhYU9m5ZUB76yYPffPHNE/zKJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnjmPSgcUdz/2QDZeAnKaXBZhqOiCcBLxzXfmGSogc+Pj5BQg/wHxExkFK6sJnxSJJmllt2HLb1Fg67ctxDIymlezo2IE3kOuDbnR6EJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEm1FDs9gOkoIhYCyyv/PTDxwC/y6GLczxMlPChPsI2VLYwrUwDeHxHPzmFMkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiTtx6QHjTmqyr6mkh5ExCOBx7AvacGBDkxwMD7Jwfh9Y4/1AB+PiAc1My5JkiSpQ+4qlEtTqlBaXKKwc2q3OlOtU+4D+qdepxuPJSd3NlKpVCpeX0+5/oGhutqrt9ycuYPs3TPQteXyMloqXtu2zqSZ5a52nOPbMS+0a75qpE4OGpp7gLu6eQ6Y7nNPRaO/G2l2K3B9O87x3Xgf065jadpoodHr647MPZD/vVTe5XLk3CM1xribcTfjbg0y7iY1bObF3XZ337HkwLhbF849Fd77SI0w7mbczbhbM5x7pMYYdzPuZtytQcbdpIbNvLhbFx5LDqrNPRPe30x2Hh7/+Pifx+aVyfa3g+dySZIkSZIkSZIkSZIkSSY9aMzyKvvq+hJzFa+d5PGxpAYFYDPwYeBdwKeBe9g/0QHsnzBhKfAfTY5LkiRJartV56zdVCiUry9s6qm/0qIS9JYo3Nvbujp9UFpUguLU6pTnlem6Y2nedaceu3ZzIxV//7mfvGnn9rmDtcr1D4yyc8fcmu3VX26EOXMH2b51fleWy8PO7XMHX/zcT97c8o6kGWjVOWs30Ve6vuXn+HbMC+2arxqp05yG556U0qbhob7ru3UOmM5zT0XDvxtptjvhrd+4iUJ5sNXn+K68j2nXsTShsLln8ORzL27o+rpTc09WNu97qXzL5cS5R2qQcTfjbmDcrRHG3aTGzbi428ISFEoUNnXZsTTHuFsXzj0V3vtIDTLuZtzNuFvDnHukBhl3M+4Gxt0aYdxNatyMi7vNwu+7TXZ/M9l5ePzj+/+czSuT7W81z+WSJEmSJEmSJEmSJEmSwKQHjar2La8tjTYaEXOBF7AvccGYsWQHAN8Cjkkp/UlK6e9SSucADwLOA7aPK0+lztjPT4+IZzQ6NkmSJKmDzu+9qVC71DjDT9xK/yVLWlpn5EgoHzf1Ot14LE16fTOV77lz+ZvqKTc6XN/ta73lHvrw9fzyihO6tlyz6n1eJU3q/Hac49sxL7RrvmqkThOamnuA87t5Dpiuc09Fs78baXZbtvdN7TjHd+N9TLuOpVE9N89p9vq6I3MP5H8vlXe5HDj3SM0x7mbczbjbFBl3k5o2Y+Juow+C8tHb6V+7qKXjMu42/cvlxHsfqRnG3Yy7GXdrhHOP1BzjbsbdjLtNkXE3qWkzJu42i7/vNuH9zWTn4fGPj/95bF6ZbH8reS6XJEmSJEmSJEmSJEmSBCY9aFS1pAdbm2j3mcCCys9j35obS3hQBq4EnpdS2j6+UkppJKX0CeBhwK3j6o1XAP6+ibFJkiRJHbHqnLWX95RHzur7ad9dhU09ddUZOXGI0VO30/+VJRTu7W1JndJiGHrMEKzcTv+X6q8zumqEvqt66aZjachQYQNw1qnHrr28mWaef/anL7h5/QPfuHP73MFq5RYv28W2zfPZuX1u1fbqLXfQIVtZ9dCbuerHD2b71slv8TpVrlE7t88dvHn9A9/4/LM/fUHujUuzyKpz1l7O0qGzCot3bGjlOb4d80K75qtG6kzZ3sJd5DD3pJQu33TP0rN+fNkpG7pxDphucw/AyHDPBnL43Uiz3Qnx9QuKo8Nv7P/S0uFWnuO78T6mXccyVYXNPcO9P5//xpNf8s0LmmmnU3MP5H8vlXe5Rjn3SPkw7mbcDYy71cu4m5SPGRV3WwRDZwzBwTvp/9/FFDZ1z7FMmXG3lpZrhvc+Uj6Muxl3M+5WP+ceKR/G3Yy7gXG3ehl3k/Ixo+Jus/T7bpPd30x2Hh7/eP/A8H0/F4qwbfN85swdnHC/53JJkiRJkiRJkiRJkiRJrVYolw9cG1+1RMQrgI+xf0KCsX/7U0qjDbb7GeDFB7RH5ecR4PSU0rU12ngI8AP2T54wvr3HpZR+3Mj4JFUXEdcBJ06w6/qU0kntHo90oIg4GJjoG98jKaV72j0eSWrEujWrl42W+86g2HNc3ZV2sZxy4ajy/PK8++3rK98L/LYwUthdZ53d9Jc3Uebu/eqUS/PYUziEUnH5hHUobCgUyhv3e7RcmlcucQTF4ooJRj1xnXYcSxVliltKK0duKR0xtP7UY9durqfOVHzuq+ce3VMsnVyrXKnMIYVC+YhqZfr6R7aVRgtDo6M9Ez2/+5Xbu3tg69Bg35K58/cublc5gL17+jeWS8W+WuXK5cKtxQJ3VSsDMFoqXvvi537y5lrlpHaZKdef69asXsbGOSeUe3qOKi0bXVpXpUbO8dXqtGu+mqROW46litLy0ZtGjx2+ohVzT0QsW/nAe09YvmJr1fliz+6BBeUyD8jr3N6pcqVSYWhkuJf+geH+auX6+ke2FeD24aG+ndXKLV62494VK7e05LpAmu3Wv/3so0tLS4+aytzTyDk+1/uYqc9XE9dp17FUUaa4hdGen5x87sW5X1/nPfdM5dxe7z1Sp8o1O/fMlOtPqVOMuxl3A+NukzHuJrXGdI+7bds1v1gqF3sACpTmFgfLBxXLLC3MK82Z3zc4OFEd4273Z9xtYsbdpNYx7mbczbjbxJx7up/xz+nLuJtxNzDuNhnjblJrTPe4m993m/z+ZrL7maHB3jnlcmH5wJzhecNDPf3lcmFhf//wQLnMnALMGxktlkqlIv19I8WRkZ6eUqnQ39c/0kuxPFIoF4Yos//fwhbLw8NDfcPlUqEE7ChT2FUslvdQZkupXNizYNGeO8fuMzyXS5IkSZIkSZIkSZIkSTqQSQ8aEBF/AHyKiZMezEspDVapPlmbPcBGYFHloQPbvSil9Mo623oD8C+TjO8/UkrnT3V8kmoz6YG6zdgf6Y4uHT0Wiodt3LNg8a6ROff7o6EC5fKc3uGqc1eZ4u6RHjbtntt3wx3blv1q493L1qeU/APHCdz3B2qFwiljX3zfO9I7f3Ckt+of+Eym3MP2Url4z3BPccOekb4bF47uveWQeVvWrzrHPzCVJEndzUUXJEmS1E5ef0qSJKmdvP6UJElSO3n9KUmSpHby+lOSJEmSJEmSJEmSJElSoyb64pFq21Nl33xgykkPgMcDi9mXoOBA751CWxcC5wNHV9pjXLvPr+yTJM1Q69Oz3jg6r/jukUcM9pWXj3LP4CJ+9fPj2bFtQa79/MM//v2G0ZHe81JKl+fa8DS1bs3qs0aLfZ8efUBxZc+9ZUaOKLFt+1zm3j7Kwt6dLMjjqqtn34+/+uRZG/qKo+etOmft5Tm0LEmSJEmSJEmSJEmSJEmSJEmSJEmSJEkNiYhXAB+vUuSolNKG9oxGkiRJkiRJkiRJnVDs9ACmqU1V9i1ssM1nH/D/sSQFZeCnKaV19TaUUhoB/pN9yRPGJ1E4OCJObnCMkqQutz49642lnr5/GX7sjr7SsUPcM7iIH3339NwTHgCMjvQeCVwWEWfm3vg0s27N6rNGC72Xjp4wvLLnjiLDp4+wbftcDr57Jwt7q+VKalxfcfRI4LJ1a1af2ZIOJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmqg0kPGnNXlX3HNNjmc8gSHExkTQPtfXpcewe2+9gG2pMkTQeb57xz6ClbYSA79f/q58e3o9cL29FJl7tw5NgyvRtg5NjsuZ97+2jb+m5XR5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkHai30wOYpn4LlIAC908osAq4dCqNRcTxwFGVtgoTFPmfqQ4wpXRbRNxSafdAD5lqe5Kk7rf+7c88lvK8gfKCUZhbZmiwlx3bFrSj65MiYllKaXM7Ous269asXl4uF04sLxqlsLtAefkow7t6WNi7p11DOGndmtXLVp2zdlY+/5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkaXqJiDOBy6oUOSuldHlbBiNJUhtFxOXAEybZ/b2U0pntG42kVvF6V7NVsdMDmI5SSnuBWybZ/YgGmnz2Af8fn/zgVyml3zXQJsA1TJxE4YQG25MkdbMyJ5YXlGBPNr3v3TPQzt4PbWdnXWZluVCkMAzlQvbcD+3sb/cYZvPzL0mSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnqoN5OD2AauwI4hixBAexLVPCMBtp6/iSPl4FLGmhvzPoJHisAhzXRpiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJM05EnAlcVqXIWSmly9syGEmSJEmSJEmSphGTHjTue8BLKj8X2Jf84KCIeGJK6dJ6GomIE4FHsS9pwoGqfQBSy7YD/j/Wx8FNtClJkjRrrVuzehlwaB1FFwEr6ii3F5iTY7l7K//W6ruT5bbXKANw56pz1m6uo5wkzQo5zz9tmwOeeNjixaPlnh6AoVLvJoD+4sjynsLo6Lo1qw+MWUy1X5ja/Oj8I0lT0KG5B/K/R+pUOeceSZoi4265lHPukaQpmq5xtxaXA+99JKlljLs1Xc65R5KmyLhbLuWceyRpioy7Tcp7H0nSjPSi0rfKtUtJ7fWF4tMnWrNBkiRJkiRJkiRJktQGJj1o3MXsS3Rw4Bcy/g6oK+kB8BcH/H98W6PA2qkP7T6TfcFxXhNtSjNeRLwNSJ0ehySpe6xbs/os4ELgxE6PZbZYt2b19cD5q85Ze3mnxyJJnTLd55+FfbspT5DfsXC/MEr3cP6RNNtN97lnOnLukTTbOfe0n3OPJDn/dILzj6TZzrmn/Zx7JM12zj3t59wjSc4/neD8I0mSJEmSJEmSJEmSJEnqNiY9aFBK6XcR8SPgsWSJCgrj/j0rIp6XUvpKtTYi4sHAudw/acJYWz9MKe3MffDQ34I2JUmSZqTKH+DUm9BK+TkRuGzdmtVn+Yc4kmYj55+Ocf6RNGs593SMc4+kWcu5p2OceyTNas4/HeP8I2nWcu7pGOceSbOWc0/HOPdImtWcfzrG+UeSJEmSJEmSJGmai4iLgJdPsvu3KaUj2zcaSdNBRFwOPGGS3d9LKZ3ZvtFIkiTdn0kPmvMhsqQH440lPviviPh1SmndRBUjYg7wKbLfwVidA32tyfHNm+TxwSbblSRJmk0u7PQAZrkLgZM7PQhJ6gDnn85y/pE0Gzn3dJZzj6TZyLmns5x7JM1Wzj+d5fwjaTZy7uks5x5Js5FzT2c590iarZx/Osv5R5IkSZIkSZrEukufU+70GKQDrXri1yZab06SJEmSJGlGMOlBcz4PvB04mn2JC8qVbQnw44h4dUrpC+MrRcRy4DPA6eyf8GB8gLQMfKXJ8a2c5PGdTbYrSZI0K6xbs3o5cGKnxzHLnbRuzeplq85Zu7nTA5GkdnH+6QrOP5JmFeeeruDcI2lWce7pCs49kmYd55+u4PwjaVZx7ukKzj2SZhXnnq7g3CNp1nH+6QrOP5IkSZK6QkrpIuCiDg9DkiRJkiRJkiRJHWTSgyaklEYj4k3AF9iXsGB8AoPFwGcj4p+A7wG3Aw8CngcsmqTZscQJ30kp/bbJIT5oksdNeiBJklSfyZJIqb0OBfwjHEmzifNPd3D+kTSbOPd0B+ceSbOJc093cO6RNNs4/3QH5x9Js4lzT3dw7pE0mzj3dAfnHkmzjfNPd3D+kSRJkiRJkiRJkiRJkiR1nEkPmpRS+lJEfIUskUGZfUkPGPf/Y4Cjxz1eOGD/RD6Yw/BOPOD/Y31tyaFtacZKKb0NeNtU60XEddz/fSdJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiTNWMVOD2CG+GPglsrP5cq/4xMbjCU3GNvGP8a4cmP7rkgpfb2ZAUVEP7Bq3HjG93PL/WtIkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkjQ1Jj3IQUppM/AMYGPloQMTHYx/7MCkCLB/YoIy8Bc5DOsRQN8EfQHcnEP7kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkqRZrrfTA5gpUko3RMRjgW8BRzN5goNqysA7Uko/ymFIZ1bZ95sc2pckSZI0A61bs3oZG+ecUO7pOaq0bHRps+2VKW65q3fB7Vvnzlmcx/gWL9tx74qVW9afeuzazXm0J0nqDuvffvbRpaWlR+U199w9Z/7GO0YWM3fu0Jxm23PukaSZad2a1ctGy31nUOw5Lo/2Ng7Mu/vW0WXb85h7AEZLxWtf/NxPmsRakmYQ426SpE4w7iZJajfjbpKkdjPuJknqhDzibjuG5s7bUew/pG/e0JxCb2lvqcDdpZGe3WP7e0uj83rLo/ebj4rl0pyecmnBgY/3l4bvnFMe3QhsAXZO0OW9wPYJHr9z1TlrN69bs3oZcCjAIw9euaxYKC3pL44sBygWSvN6CqUlPYXS6Lo1q3cC84Cxsc0B7jeeyhj2Vn7eBuwet2/8GA8c152rznHelCRJkiRJkiRJkiRJkqYrkx7kKKV0U0ScBvwb8IdkyQ7GJz+opgB8OKUUOQ3nWVX2rcupD0mSJEkzxLo1q89i08DHSoNLjhx+/E7KK/bWrlTD1s0L6O0b5aCF93BQDmMc7+e/PmtDb9/oeaceu/bynJuWJLXR+vSsN47OK757+Cl7+sorRppu7967lnLbLYdw7BG38ZAl9+Ywwn2ceyRpZli3ZvVZo8W+T48c17OyvHwYGG6qvfvmniNv4yFLbspnkBU/uOppg/fcufxNzz/70xfk2rAkqa2Mu0mSOsG4mySp3Yy7SZLazbibJKkT8oi7jd3vPPjoDTxg4xaKe4DBfMc5VevWrB4EBsb+v3LuJsoU7leuUNefyeYynuuB81ed47wpSZIkjRcR84ETgAcCC4EeYAdZYrEbUkp3dHB4kiRJkiRJkiRJgEkPcpdS2gG8IiIuBN5Elnyg74BiZdjvW18bgbeklD6Sxxgi4oHAGexLtjD+22SjwJV59CNJkiRpZli3ZvVZbOm/tLxtIUMv25hLm1s3L2DJsp25tDWR3r7RI4HLrrlp9Vn+IagkTU/r07PeWOrp+5ehF+Qz99x711JuuPZIHvvkq3Np70DOPZI0/a1bs/qs0ULvpcOPaG7BtTGtnnsWLNozsGDR797/5YtfhguwSdL0ZNxNktQJxt0kSe1m3E2S1G7G3SRJnZBH3G3sfufxD7+a/l/nOLjmDdQu0lYnApetW7P6LBMfSJLUfSLiwcCjyNazOAY4AjgImEd2XbGbbBH27cDvgF8D1wPXAFeklEbbONYlwOOBxwEPBo4GDgbmV8a6B9gJ3A7cUhnj94GfppQ6nJqqtojoBZ4APAV4KNli+EvJFsMfITu224AbgR8D30oprevMaNWoiDgROBd4GnAKTJChbF/ZrcClwNeAL6WUdk1SbinwsCrdXplS2tLomKupJG44g+w9uaqyPQBYVNkWkK2LswfYyv7vzyuAH6eU8vlQagaqnPceAzyW7Dk+CjiU7Lw3FxgCdgF3AjeTPa8/AL4/Hc57kiRJkiRJkqTpwaQHLZJS+jnwwohYRvYh4aOA48k+BJ1D9uHKBuDbwFcryRLy8gdkH1SVD/gX4PqU0u4c+5IkSZI0/V1YuHEJgy/dnFuDvX1t+/7phcDJ7epMkpSjzXPeOfSyTbk196ufH88Zj7s2t/aqcO6RpOnrwpFjy7VL1aldc8/Bh256F3BByzuSJLWCcTdJUvsZd5MktZ9xN0lSuxl3kyS1Xw5xt7H7nd4N+QxpFnDelCSpS0TEScAfAc8HjqxRfGFlO4xsMfMnj9u3NSK+A/wv8IWUUu4ZCCOiCDwXOI9skfi+KsUXVLaVZAvAv3DcOL8M/EdK6Yq8xzhurG8D0mT7U0oTLm4fESuBPwdeQ5bkYCK9ZOuaHAScBvw+8P6IuAp4D9nzX2p48JOIiGcAb65S5IUppbsabHsDWZKNiXwipfSKRtqto98zgcuqFDkrpXR5C/p9OPBO4ElTqLaE7H36fOBfIuJC4D0TrDFzCnBJlXbOAi6fQr+TGpec46zK9nCqvy8he/0OkB3PkWQL+J9T2bc9Ir4BfDiltDaPMVbGeXllnFNxWUQ02uX3UkpnNlp5vIjoA15MttbQk6m+ltTcynYQ8BDgOZXHt1XOe/+aUromj3FJkiRJkiRJkmYvkx60WEppM/C5ytYuryBLdHCgMvDTNo5DkiRJUpdbt2b1coaLJ1IqUl4xkkubQ4M9LFi4J5e26nDSNTetXnbqsWvz+wtWSVLLrX/7M4+lPG8gv7mnl717Bli0ZFcu7dXg3CNJ09C6NauXl8uFE8vL81mwpp1zz4JFewY+99Vzj37xcz95c8s7kyTlxribJKkTjLtJktrNuJskqd2Mu0mSOiGPuNt99zvzd1Fs27Qz7Z20bs3qZavOcd6UJKlTIuIRwNvJkgfkYQlZYoEXAh+IiM8AH0wp/TKPxiPiOWSLxD+4yaaWkCV5+KOI+D/gr1JKbckUX01E9ABvBAKY12AzpwOfBf4sIv4opbQ+r/FVHEK2QP1k5uTc34wTEXOA9wGvAyZMfFGn5WRJNc6JiPNSSt/PY3z1qCQfWQ28FHhBZSx5WQS8DHhZRPyY7P35oxzbnzYq54TXAn8LPKjJ5haTJYs5LyL+B3hDSumWJtuUJKltKkmAjiVLCraIbG6bC+wFdle27cCtwN0ppYnW55MkSZIkSTkx6cEMExFPAU4gS3Aw0QdYs/LDGkmSJEmTWslQkfKCUm4NDg320z/Q1r/GORTwj1kkaTopc2Kec8/ePQPMmTuYW3t1cO6RpOlnZblQBPJZfK3dc09PsXQy4OJrkjS9GHeTJLWfcTdJUvsZd5MktZtxN0lS++UQdxu73ykM5zSm2cN5U5KkDoiIpcC/AC+nuUXXq1kIvJpskfznNtNQRCwDPkK2uHrengY8MSLeCURKKb+gxBRExArgK1RPKDAVjwF+GhEvSildklObalJEHAb8L3BKjs0eA3w3Il6VUvpkju1W8y3gKW3o59HADyLi/cD/SykNtaHPrhARDwP+Ezi1Bc0/G3hyRPxVSunfW9C+JElNi4i5wHPIrjlOBU4G+uusvjcifgusA34C/BS4IqW0swVDnZEiYiXwDOAJwInAEWTJJnqAHcAW4EbgOuC7wKUppbZ+GVXtFxHHkN1Dnw4cDxxJdu+/ABgGtgIbgDUppQ91ZJDTVEQsInvPrSY73x1NltxlHllyl23Ab4HrgR8CF6eU7unMaCcWEQuBR1W2k8jOGw8ie33MI1s3dQdZgpotwHrg12TH9IOU0t1tGufxwEOBVZXtOPYl1FkIDLAvoc5dwO8qY7wK+F5K6fZ2jHM6iogC2e/+ccAZZK/jI8mSj84jm0N2kb2eNwA3AD8GLk8pdcV3PCvJBx8NPJ3sXHcCWaLHBWSvi+3AHWTz31XA17tl7DNZRJwCnA2cRnZdsoLsHFkge03dSfY94Z8Bl5GdU0yA1UYRsZjsGmE12XlgbB5bQPY72kz2O/oJ8B2y933Tv6PKOf2ZZK+Nh7LvtdEP7CQ7h68D1gJfSynd2myfrVJJlPvEynYS2bXWErK5aYRsDt1ANiddDnyrXXPnZCJiAHgYWZLqsXn1cLI5dWxeLbPvWuZ2suuZXwA/B76fUtrb/pErTyY9mHneUGP/t9sxCEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJE0PEfEI4PNki891vYg4EfgfsoXdW6UPeCvw8Ih4aUppWwv7up/KwpGXAEfl3PRi4H8i4ukppe/l3LamKCKOJFt47cgWNN8HfCIielJKH29B+wda1IY+xhSAvwBOjYjnzIbFiiPiNcC/Uv/Czo2YB3woIk4HXptSyicDuiRJTYqIVcBfAi8iu55txByyRYpPIEucADASEd8luxf6SkppS41xXEu22OhESsCRKaXbGhzflEXET4BHVilyXErpphz6eTzwV2SLxxYnKbassh1Dtij0XwI7I+Ii4J9TShuaHcd0Vrnuv2WK1Y6IiGYW/j0vpXRRrUI1+oiU0tsmqDMfOBc4n8nfE5CtdzqXLNHxDcCESQ/qeH7qOpZGRMTbgDTZ/pRSw0khI+JysiQhE/leSunMSeo9FPhb4IVMfv0/v7IdRrYY+yuB0Yj4X+CfUko/aXTczaosdvwS4MXAk6h9D7O8sh1FtqD8mHJEXEO2huoXUkpX5jjGw4GnAmdVtkPrqDb2nK8AHkKWkGKsvV8AnwQuSinlktQ7Is4kixdMxROaPG+clVK6vIn694mIE4BXAb9Ptth1NYsr2+Fki6O/qtLGz4GLgI+llPbkMa6pqCTt+FPgT4AHTlJs7HVxKNki3+cCF0TElcD7yF673lsfoI7X94SvxcoC8OeRxYSOrVJ/SWV7MFlihABuj4h/BT7UijhSRGxg8tj6J1JKr8i7z0q/Z9LAc1ln22+jgTmyElf6a7JkxX2TVB9bAP9IsgX9/w74TUT8M/DhqSYhriQnORf4M6onC11S2U4mm2cvqMydb0kp/WIqfbZSRBxNdj39crJzzET6yK6zDgYeAbyC7Frg62TX3z9ow1DHkts8muz3eBZZ4uU5dVTtJ3sNPIgsOdKLK4/viYhLyBJef7NTCanVnMluGjUNRcRpZBe+YxeZ5XE/A/wqpXRn2wcmSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKkrhQRzwS+x/RJePAQYC2tTXgw3jOASyKibQu6R8RhtCbhwZg5wBcr/ahDImIZ8C1ak/BgvA9HxGQLbU53TwQujohWJgLouIh4N/AftDbhwXivAj5ZWTBOkqSOiYi5EfEPwC/I5qdGEx5Mphd4GvBfwK/rKP+JKvuKwDl5DKoeEXE81RMe/LDZhAcRcWhEfJHs/uvZTH3tygXA64EbI+LtM/2abbaIiJcAN5IlMKiW8EBTFBFLI+K/yM55L2Pq1/89wLOAH0fExyMi73NmVZVz9puBW8kWqn8Gzd3DFIDTyBJA/Dwifh4Rr64kVWhkfIdExJ9GxA+BDcBHyZ7nehIe1HIK8M/ArZGZbIHqGS8iVlXmjuvJEubUSnhQzRnAhcAtEfGaysLabRERf0h2rvtHJk94UM3DgM8AV1UWgFeTIuJs9iXQqZbwYDIPAN4N/DoinlGrsKYuIpZU5rEryZLfTJbwYDLHkP1+r4iIB0+h37OA64CPUT3hwUSKZIm9royId3Q6FhYR/ZX7n/XA65g84cFkeoDnAt+PiM9HxMqch3ifiHh4RPwLcBvwQ+AdZLHaehIeVDOX7N7jG8CvKp9faZox6cHMcgbZSXaU7AJ9/FYm+5BLkjRTFbi+sLMIc7NEVHPmDraz99mcVOeuQrlEuQ8K5ey5718w1O4xzObnX5IkSZIkSZIkSZIkSZIkSZIkSZIkSQ2KiOcBX2FqC9HcWanzPrLFy/4EeAMQwL8BXwPuyHWgFRFxBPAdYHmdVXaRrbfxHuCNwGuBvwT+lWwhnpE623k42cLqU12oacoqi/d9g+oJD64nW5j1ncBfAH9OtgjbGuCeOrs6CPhw4yNVMyoL9X0aOKHOKj8E/hp4LHAIMED2vj0EeBzwN8CPJqnbB3wKWNjEkPNyN/Btstfee4A3ky2E+2fA35OdV77B1P6GfjXZe3pGioj3kv1+63UP8GXg/cBbyBZI+xuy5/YLwOY623kZ2e9IkqSOiIhjgKvJrhfasVh+bx1l1pCt8zeZc3MaSz1q9VUtQUNNEfEk4BrgBc20U9FLdq33o4g4JIf21AERMSciPkO2iHcei8RrnIg4A7gW+KOcmnwF2XvuyJzaqyoink2WPOYfgINb1M3DyO4l614Ie0xEPB64neze8TFka7S2wnzgrcAvIuIRLeqjK0VEX0S8gyxpxwvId73jQ8gSAa6NiAfk2O79RMS8iPgU8MlKv816KPDTiHhtDm3NShHRGxEfJIsXPSiHJh9IFud9Uw5tqSIiTiZ7/+cxj51ONoedVaPPYuW88x3qj7FOpocsjvbFRpPrNKuSoOAnZPc/9dyb1PIi4JrKdX2uIuIjwM/IPnNp5Xn5RODrEbGmnUmp1bw8XsDqEimljwIfrWQxfAhZdpmx7aHANzs1NklS653w1m/ctP5PXzRY2NkzwN4y/UtHWLh4Jzu2LWh119ellOr9UHvGWXXO2k3r1qy+vrC958TyvFEKm3roWz7KjpG5LOzd044hXLfqnLWz9vmXJEmSJEmSJEmSJEmSJEmSJEmSJElSYyLi4cB/U9/6I1vIFhf775TSdXW2fyjweOD3gd8D5jY41LH25gBfor7F824gSwLw+ZTS3iptLgf+mGxB8KU12nwc2SLir69rwI17H3DaBI9vBt5Fdky/naxyZTH9MyvtnF6jr2dGxJNTSt9pcKxq3J8DT6uj3FrgjSmlqybZf09l+yHw3oh4GNnr9PEHlHsQ2eKT7XYLWSKUbwJXp5TurbdiRBwNnEe2WOcDaxR/TUR8KaV0yRTH916yxYvHO4Esoctk3gesn2I/Y6aSzIGIeHWNsYzZRrb450UppV/XaLMIPBr4f8DZNdr9i4j4aUrp8/WMV5KkvETEUcD36bKF1VNKd0bEJcDTJymyKiIekVL6WSvHUbnm/8MqRfYCDc/fEfFisqRZeSd9exjw44g4q9o9jbpPRCwkS172qE6PZSaKiGeSvWebiptM4ETguxHxuJTSlO5F6lVZ+/S9ZInsutl8sgWt2+UYsgX6X5pS+kob++2IiDgM+CLZvWYrPQ64MiKe3Yq5trKg9je4f0ylWb3Av0fEwSmlt+fc9owWEXOBrwJPzbnpAvDOiCillEz42KSIeAzwv8DiHJtdQpac4vEppSsn6LMHuAg4J8c+AZ4LfKJy/i7n3PakKkmKLgOOzLnpQ4BvRsQ5Ocf32p2A4A+Ah0TE01JKd7W5bzXApAczUEppCLiyskmSZpNle9/Uf8mS9w89cSsAD334en74nYe1utdWfylnOji/96bCZSOroHddgeHlsPeBRRa253LY51+SJEmSJEmSJEmSJEmSJEmSJEmSJElTEhFLgK9Qe0G9EeACIFJKO6fSR2VBvc8Dn68skPh84K+Bk6Y63oogWySzmjLwT2TjHa5jjJuAd0XER4GPAc+uUeX8iLg4pfTNegbcoIn+fvhfgZRS2lqrcmUxpssqSS3eSZbQoZq/BUx60EaVhCDvqKPoW4F/mMoCWymlKyPizErddMDuh9bbTpO2ki3A/9mU0jWNNpJSuhn4+4j4B+DvyV7L1Rbe/UBEnJxSKk2hj4sPfKzy/FVLNHBxSunyevtoVEScAVxYo1gZeA/wTyml7fW0W3l+fkiW9GQ18GngAVWqfDAiLk0pbaynfUmSmhURA2RJk7oq4cE4n2DypAcA5wItTXpAluTs8Cr7v5pS2tZIwxHxXLLrg2Ij9etwFPCNyuK4mgYioo8sAaEJD1qgcv/xRWCgRV0cDXyukmxkNM+GI2IeWWwp78XIZ4oB4AsR8ZyJ7j1niog4HriU6veVeToEuCQinppS+mlejVaSrX4TaOX8FBFxW0rp4y3sY8aIiF7gC7T2HPOuiPhFSun/WtjHjBYRq4Cvk2/CgzFzga9FxGkTJFL9BNlC+K3wYrLr+X9pUfv7GZdw5cgWddEHfCYiBlNKX2tRH+3wULLPPR5dz+ck6iyTHkiSNIOcEF+/YH16Fn0/XPiekVN39a1YuoPHPvlKfnnFCezYtiDXvnp6RzaMjvSe144P47vdqnPWXr5uzeqzWNf3mdHDRlf2XdXLoiP2ci/zmfO7Egt79+Te53CpZ0NfcfS8VeesvTz3xiVJkiRJkiRJkiRJkiRJkiRJkiRJkjTT/Ru1FyO7F3hhSmlts52llHYAn4iITwLPAx4ylfoRcTLwFzWKjQB/mFL6bAPj21RZ3PMDwJ/WKP7BiDgppZT/HxHf3yhwfkrpw1OtWFnY/G8rC1S+sUrRJ0fEMSml3zQ6SE3ZO4BaCwD8WUrp3xppvPK7f1tEbKNNi3NV3EqW6OSjlfd8LlJKg8BbIuKbwLeY/Ll7MPDCyhimtYjoBz5O9SQP9wLnpJS+3Wg/KaW1EfFI4GLglEmKHUSWTObVjfYjSdIU/T/qu1/YQbbI8neB9cBvyJIv7SK7N1hEtvjqYuAYskUyHwKcATyoifF9FdjG5Au7viQi/iKlNNREH7W8vMb+TzTSaEScDvw39Sc8uBVYC6wDtgAFYCmwiiwxw2T3nCcD/wV8qJFxqu3+CXhKlf2byJJqrQPuBPaQLVJ8ENnv+vHAshaPcVqKiGPJkrxMlvBgBPgJcC1wT2WbCxxM9j57EjCvjq4eD7wB+OfmRrxPZYH4/wMeN4Vqw8BVZMezgexcOgwsITt3HER2rn4o0J/XWKdgCPh1ZXwbK+PbBuwmuw9dTLbg/ulk80k9Y+whW2j6jJTSDa0YdCdVXsOXU3+iolHgGuBKsud4EzAIrCB7XT+C7Pkt1GhnEXBx5XndMNVxT+Lj1J/wYIjsvHcNcBvZa2QeWUKi0yrtTHY//+GIuLqpkc4eHwDOrrL/TrLX3x1k58edZK+llcBZwAl19FEAPh4Rx0814a8gIuaTJTyYbJ4fAr5Hdq1+F7CZ7Hy/EljN5LGo8R4AvAt45bh+/5bqCQ9uY//XxgjZ+ftY4GnUl6DhHyPiq5WkrK32X1RPFH0b+57HLZXHlpK9xp9Affc2ReDTEfH4lNJVTYx1KjYBvwJuZN+cupUsiev4+7QzgCPqbHMV8BngGTmPVTkz6YEkSTPMCfH1C4AL1r/97KNLS0uPWrl077ErD/rVYRvnL1i8a2TO/YJTBcrlOb3Dg9XaLFPcPdLDpt1z+264Y9uyX228e9n6t7z5HZtbdQzTUSX5wKHr1qxeNlruOaP3xuIpS0vDR9BbXLFzZMH8wZHehrLPlXvYXioX7xnuKW7YM9J348LRvbccMm/L+oece5nPvyRJkiRJkiRJkiRJkiRJkiRJkiRJkqYsIh4PnFOj2N3AmSmldXn2nVIqA1+ubFPxj9ReJ+V1jSQ8GFMZ259FxEHAS6sUPQp4LfD+RvuaglemlBpasHScN5EtEHZ8lTIvBN7dZD+qQ0Q8ADi3RrGPNJrwYLyU0vsj4iHAec22VWd/v9/i9n8YEWcD32HyxQNfwwxIekC2IOnJVfbvAJ6aUrqm2Y5SSrdHxJPJFmucbGHiV0TEO1NKtzTbnyRJ1UTEYmonO9tMtgj7f6SUdtUoN7ZGzzXAl8b1cwrwbOA5wMOmMsaU0t6I+Dzwx5MUWU52/f2VqbRbr4iYB7ygSpE7gUsabPez1LeA+v8A70op/bhGm48nS2Ix0aKkLyJb/Ha22MjEr5nzmHyR7U1k93ON+mETdcc8GnjyJPsuBi4ALq0kXptQRPQCTweOzmE8M0k/2Xtu0QT7fg38A/C/KaWtkzVQSTzwUrJz4soa/f19RFyUUtrU2HD367cAfJL6Ex5cCnwU+HqN8/ZY+/1kiQ+eBbyY+hYub8RQZWxfBX4ErEspDddTsTLGs8kW4X4G1ZPFLAT+MyKeUIk91Ws9E583/prJYzw3AO+dQh8T9VmXypz9depLePBDsqSMl9RKkhgRBwMvA/6ObAH7ySwHvhIRj2w20VBE/DHwkjqK3gu8E/hYSmlblfaWAq8iO4cfuBh8H/AxskQJmtwLgNdN8PgI8GGyReKvqfaeiogTyM6lL6zR16Fkv6u3NDbUWe39ZIkEDrQeCOAb1d7zEXEUWUKDWjHF8yLigymlqyLiCWSfFRxoBPgIWVz1F1X67CN7v7+PLNnKZOaQvX5eVmNszXohk79Gv052zf2jag1ExGOBvyWbN6uZR5aI57SUUivOQXeR3Sd8A7g6pfS7eitGxKHAH5LNq9U+xwB4ekS8KqX0nw2PVC1n0gNJkmaoE9568c3AfZnBKjfxE839Iymle9o2sBlu1TlrNwPfrmySJEmSJEmSJEmSJEmSJEmSJEmSJElSt3lXjf0l4AV5JzxoVGXR9loL9nwupfTRnLp8Fdmik0dUKfNXEfGhlNJgTn1O5FM5JDwgpTQUEX9DtojfZJ6GSQ/a5XVMvmA/ZAvo/W2O/f0V2YK+y3Nss2NSSmsj4l+Bv5ykyFkR8cCpLKrVbSJiIfA3VYqUgBfmkfBgTEppY0S8BLiMidel6AP+nCwZgyRJrfRissWhJ/Nr4OxmE/FUFkL9BfCOiHg4WaKFM6fQxCeYPOkBZEmuWpL0gGwR4AVV9q9JKY020O67gONqlNkCvCKl9D/1NJhS+j7w/Yh4IdnixAcu7n7+lEc5TaWUdgL3W5g1Ih7H5EkPdnbBYq5PneCx24HzUkp1JddIKY2QLX6r/T16gsd2k93rfLSe93FKaS/w8Yj4Etk554lVii8mS+A40ULRU/VXZIlLarke+JOU0tqpNF5ZwP7nlS1FxKnAnwCvIEsW0azvAx8iSyqxvZEGKmP8Ctmi+w8ne38/tEqVx5PNcXUn60wp3cnE541zmHxB6DvbeN74OLCqRpkbgD9KKdWdhKWyJuIFEfFfZHPTRAvfjzmVLDnC2+pt/0ARcTj1JTb9EvCqaolIxqSUtgDvjYiPkT1PB8Y1TyO7t9fkXj/BY98hS3p7Yz0NpJTWAy+KiOcDn6H6+eP8SrLHmolZtJ8Dr4eHyRJe/Ws9SWQq1/QvjohvABcxeQKZAvAXEfFKsiQ6PQfs/xHwxyml6+vocxj4VERcTPaaOq1K8d+PiP+XUvptrXabMNE5bqrX3D8Enh0RzyU75yypUvx4suQtfz61YU5qD9nvbg3w4ykm97lPZc57T0S8D/gzsoQT86tUeVdEfLZyja0uVC0blCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkqQZIiIey+QLKo55z1QWI2uD15ItbDSZnUy+APqUpZR2ky16Ws1hZAvJt8rd5LsA6MVki+lP5pERMdFC58pRRBSAP6hR7E31LKBXr5TSZrLFxmaSACZbmLLAxAuzTievpnqSiv9KKX07705TSj8APl2lyB9ERB4LjEqSVM3vVdm3C3huswkPDpRSuiKl9FLglCnU+SFQbcHdsyOiVUmnzq2xf8qJ0yLiRLIFxau5C3hMvYuvjpdS+iLwOGDjAbtcC3P6uRZ4RL0JDzQlG4EnppT+Y6qJSyoL9z8LqBXLeXXlvrRhEXES8I46in4COH2qCQ8mklK6JqX0GuBo4AJgbwPNjAJfBh6VUlqdUvpsowkPJhjfFcAZwBdqFP37Zp//bhERLwOeV6PYfwMPazTGmFLakVI6n2xh7moJAv5fRBzVSB8V76L6wtoAF6SUXjjVeE1KaRPwHOA/JtjtHDg1FwHPqDfhwXgppS8Dvw9UW4x9CVliEjVuD/C8lNI/15PwYLyU0qeoHY9/EVmCkgOTdH0DeHI9CQ8O6HMzWSLgagkNeoBXTqXdBhw4LzRzzf1V4LHAPTWKvi4iHjzV9g9wL/B24PCU0utSSj9qNOHBeCmlUkrpArJ59a4qRZdTPSmOOswPm9qkkkH5NLIL5cPILmr6gUGyD0/vBu4EbgFuqWTukiRJUmdVu9lR+9zZ6QFIUps5/3QH5x9Js4lzT3dw7pE0mzj3dAfnHkmzjfNPd3D+kTSbOPd0B+ceSbOJc093cO6RNNs4/3QH5x9JkiRN1Wtq7L8eSO0YSD0ioo/aC069M6V0e579ppS+HBHfBZ5UpdjLqb2gXaP+/f+zd99hjlxV/v8/UueZnuxJznmMbbAxNsGA8ZBzDgaMTV7ifjHssrDAHg4LS1rAsCbujzywmGCiSQbbmGTAOIdxwDlNztNR0u+PUnt6uqUqtVRJ6vfrefTMtO6te6+kqrpVR933mNmOuBozs3F3/77qL2Q6R8GCUTfE1Sdqerikg0LK16mJRWob8FVJH5K0NIG2U2dmO9z9lwoWrKvl8ZK+kuKQ4va6kLIdkt6XYN8flfQK1U40s4+C9/aXCfYPAMDDQ8q+aWY3JdWxmUUtDjrVN1R/4e8eSS+VdE5Lg5rC3fdXMB/X83czu66Jpj+o8HUphyQ93czWNtG2JMnMrnH3Z0r6naS+ZttBpu6V9GQz47up+O2S9LiZLtg8mZntdvdXS7pGwTqntRyo4Dz7l2b7kfRpRR/DZ5vZWS30UVM19tNUu9VEHYkl6zCzsWoigDmSnlGn2tEKEsD8PqlxpMHdBxUsPB7mm2YWlaSnIWb2GXefK+m/6lTplfQeSa+dadvufpyk0yKq/V8r+7OZVdz9TZKWKzpRBGr7qpm9upUGzOzH7v4NBfHcel6k9o4nZaki6flm1krM6DMKPp+H1inv1fTY9m8UJFoYb6ZDM9vg7v8q6bsh1V4o6T+aab8JcVxzX+/uz1Aw1/TXqdat4Pr/BS3089Zmt22w/bXu/nhJf1KQlKSW10v6WJLjQPPI7JMgdz/I3c3dL5e0RdJFkr6sIEDxLgVZZN6t4Euh/09BVvTrJe1y9xvdPakvNgEAANCAo06/ZJOC6zNk57qjTr9kc9aDAIA0Mf/kAvMPgFmFuScXmHsAzCrMPbnA3ANg1mH+yQXmHwCzCnNPLjD3AJhVmHtygbkHwKzD/JMLzD8AAACYEXfvk/T8iGqfMrPRNMbToMdKWhJSPibpSwn1HbVA6ZPcfU4C/Y5I+nwC7V4aUX5UAn1ib0+KKP+OmZXi7rS68Ne5cbebsV+ElNVbHC333P2RklaFVPmama1Lqv/qIqt/CqnylKT6BgDA3QckrQyp8uO0xtKgbypY4LWeWBZ7nuJ0ha8fOeMEWu5+uKTnRFR7t5ldMdO2pzKzvyhHSfYwY28i4UFi/rmVhAcTqolhPhdRrelrend/ksKTQ0rSr5JIeNAOqvfer1OQrK6eV6Q0nCT9s6RlIeUXSXpNzH1+ROFxgDPcvZlEj+9Q7aR/E+5ReGLChphZRdIrJc00wRKktZLeElNb/6Yg7lrPqe5eL2kMwn2mxYQHE8fJTBJ9bpH0ymYTHkzq93uSwq5zH+TuB7bSxwzEdc19maT3RlR7rrsf1mpfSTKzGxS+Txzm7ienNR7MDEkPEuDuh7r7uZJuUZCN5XgF73WhwUeXguznUV8UAwAAIHlvznoAs1xcwSYAaDfMP9li/gEwGzH3ZIu5B8BsxNyTLeYeALMV80+2mH8AzEbMPdli7gEwGzH3ZIu5B8BsxfyTLeYfAAAAzNRqSXNDyrdK+nY6Q2lY1CLxvzCzjQn1/XNJYYnGeiWdkkC/fzCzJBZBuzqifP8E+sTeTo0oX5Ng399MsO0s3BFSdmQbL1L3jIjyNJJXXBxS9rgU+gcAzF4LIsrvTGUUDTKzOxQ+b57k7g+KuduwRApjkv6viTbfqPA1KddK+mwT7dZztqR/xNge0vEDM8tb4pFO8Qsz+0qM7X0tovwxLbT9zojyzZJe3UL7ba+aGOS/Q6o8Na2xJKGaUPXtIVVGJL3WzMbi7Le6GPpbJdVLFNmjGSaUcPclkk6LqPYuM9s1k3brMbPtkt4TR1uzzJlmtjuOhqpJJMOSZ/RLOjGOvmaZOyS9K6a2fq0gmUEj3mlm98TUb1S87dEx9RMm7mvuz0i6OaS8qOA+IO8+r2B993rael7tZCQ9iJm7v0PSdZJeqCB5wUTWpsoMHwAAAMiBo06/5GIFv8R3XcZDmW2uk7S6+v4DwKzD/JMZ5h8AsxZzT2aYewDMWsw9mWHuATCrMf9khvkHwKzF3JMZ5h4AsxZzT2aYewDMasw/mWH+AQAAQLOiEgisiWsRqRg9NqI8sSQNZjYq6bsR1aLG14w/JtCmJN0YUb4soX6xx/EhZTsl/T3Bvi+TlLfjuxX3h5R1S9ovrYHELGyhrvsk/SmFMfw+pOwYd+9JYQwAgNmpEFHencooZubrEeVhSQpmxN1PkhSWROH8mSaEc/eCpJdEVPtXMxufSbthzGxE0r/G1R5S84GsB9DBPhpnY2Z2laQbQqoc10y77n6YpCdEVPtnM7u3mfY7zPdCyg5w98NTG0n8ni9pSUj5p83s1iQ6NrN/SPpBSJUXz7DJFyhIllDPZZK+NcM2o3xF0pUxt9nJLjazv8bcZlSCqKbOkbPcOWY2HEdD1YQp5zdQdYPiTfB6XkT58TH2VU/c19xjir7mfkn1fiC3zKyk8M/n8WmNBTOTx5v3tlTN7vxNBckOJic6mKzRA5mkBwAAADlS/UOQY9euOWWxpJUNbDJf0tIG6g0ryOwYV70N1X+j+s6y3vaIOpJ031GnX7K5gXoA0NESmn9SmwN2jM1ZUKp0dUnSaLl7kyT1FseXdBVKpf7ubdta7Fea2fzI/AMADch47pHiv0fKqh5zDwA0iLgbcTcAyEK7x90Sridx7wMAsSPuFls95h4AaBBxN+JuAJAF4m6RuPcBAABAnpwYUX5RKqOYmQdHlP8h4f5/L+kNIeVJLIT15wTalJkNufuY6i/otiCJfhFw9xUKXxjwGjNLbM0ZMyu7+zWSHpFUHzPh7kVJB0haruD+elBSn4L9s5E1esLeSymIUdzWyhjT5u59Cj+nXJ7kPjLJHSFlvZKOkHR9CuMAAMw+UbHv4yVdncI4ZuIHkj4raW6d8tPd/T1mVo6hrzMjyqMSMNTySIUni7pLjS08O1M/lnSvpH0TaBvxu9zM8nbsdYorzOx3CbR7qeonSVnm7ovMbMsM23ypwu/V7pT0nRm22ZHM7AZ3v0PSQXWqPFTSLSkOKU5hc1FJ0icS7v9/VT+5wUkz3LdfEFH+hbjvwauxmS9K+nyc7XawTyXQ5qUR5Ucl0GcnG5L05ZjbvFzS6RF1/reaSCsWZnazu29X8PtMtayKq686krrm/qmke1T/en9/BfcDiXwfEaNfSHpnnbLj3L2QUswUM0DSgxi4e7ekH0l6ioIL8ck7+tQL83oHQa4zmwAAALQrd18sadX+A5uOXTF/86r+7rEl5V3dC0ujWtRfGZ83WunqGh/v7u8pjvd2zSlFXB+vVEEaL6i8q1Ao7CyrsLmiws5CT3mDunVHWV27B3uGt8wtjl567Bnn5/0GLhfcffGK/TesWrJ06+Q/9jns2p9ExRtqK5WL177kud9IJNMrAGSl+oeJbffHiee6L1Pt2NO4ma1PezwAgMa169wDAGhfzD0AgCww/wAA0sbcAwBIG3MPACALzD8AAABAWzg+ovwvaQyiUe5+kOovNCRJG8zsnoSHcUVEeVRShmbcmUCbE3ZIWlynrC/BfiEdFlF+ZQpjuFIZJT1w9wMlPU3SyQoSsByuYAH9pEQlRcijY1U/KYmUXqKBTRHl+4ukBwCABJjZSMRio29y9zUxJRCIhZntdPcfSDqjTpX9JT1e0m9a6cfdeySdFlJlo5pbKPUJEeXfSWIB0eqiz+dKOivutpGIr2U9gA52XkLtRiWp2F/STJMePDOi/AtmVpphm50sLOnBsZK+l+JYYuHucySdGlLlohTWk/mTpHoJPYuSHivpJ1GNuHuvpMeEVBlVcsfn9yR9RuH3/5CGFSx0Hiszu9Pdt0paWKfK/nH32eF+10QSnSg3NFDnxzH3KUlrJT28TtmBCfQ3WdLX3G8PqfZ45T/pQViC1kFJB6vNkt/OBiQ9iMfnJD1VQUKDiZPE5CQGU08cjSZCmBF3f7mkNynISjPxuM7MxuNoHwAAoJ24+2pJXzli4P6DH9xzr3TgsDb/fYU29/bryJW3aeOcQd1x54E6un+deh5/vypL47tkGpd05V8fP9Z9a987jz3tF2fH1nAHcffVy/bd+JXVz7jl4PkLd8Xa9h8uf8rI+vuWvOv5z/j22bE2DAAAAAAAAAAAAAAAAAAAAAAAAABAm3L3pQpPIHB3CgkEZipqMaErUxjDjZJ2S5pTp3w/d++KeWG/uBeKmmyn6ic9SHIBekj7RpTfnMIYbkqhjwdUF0R8uaTXK0h0kKaBlPuLw1ER5Svd/bUpjKMrony/FMYAAJi9/irpiXXKHiHp45Lekd5wGvJ11U96oGpZS0kPFCw2HpbU6f/MbKyJdh8XUf6dJtps1LdF0oN28fusB9DB/phQuzdGlC+bSWPuvkDSSSFVypK+PJM2Z4H7Q8oOTmsQMVut8ISZP0h6AGa2293/LumRdaocrwaSHijYn+vF+iTpVwks5C5JMrNN7v5rSc9Iov0O8tcmr20acZPqL24/o/MjElks/x8R5cOKTlTcjFtUf79YmkB/kyV9zR2W9OBxkj6UYP9xWBdRfrBIepA7JD1okbu/QNJrVTvZgWo8f7+kuyRtUHBxvkjSgxR8IVipsf1MfE9BMGbyBdiou1+n4KLpPS20DQAA0DaqCQ8uPGLgfj10eJ3GHrZL2847SPeu6NZDD7lB64YW6fpbV+nUgVs08pKN8WSgmmrxeM/44vFPXfudp4nEB3tz99X7LN984aNWX5VI+4Pzh/oG59/9qfPOf5lIfAAAAAAAAAAAAAAAAAAAAAAAAAAAgCTpgIjyqAXxshC1SPwtSQ/AzMrufqukY+tU6VKwGNZ9MXa7Oca2pgr7s9pW1jxBtKhF07alMIbtKfQhdy9Iep2k90tamUafNYQtxJhXUefp06uPrIUl0AEAoFW/Vf2kB5L0dnc/TtLbzezqlMYU5SJJd0g6qE758939TWa2s4U+wpIqSEHihWYcH1K2S8kmmrtc0pDaM1nVbDIi6bqsB9GhSgoSvSQh6v5ywQzbO0FSMaT8OjNbP8M2c83d5ytIxrmPgqQzfdVHVJK4CfuHlGV1n9yqR0SUX5bKKII5t17Sg3rxu6mOjyj/Q8Ojac4fRdKDKEkspj8h7Bw50/PjbHdpAm3uiCi/PKGEGGH9JrlfJH3NfYXCkzofl2Dfkh6IFe8raYWCBBLzFcypvYrnO4l2nVc7GkkPWuDuA5I+NempyQfK5GQH6yV9UtJPzGxtjXZeI+l/Wx2PmY26+6clfXjS030KbhKOd/cvmtmdrfYDAADQBs6RpOM2bNLo87eq78eLddmi5Xrysr9Iki7fcKQes2WdRp+9NfGBlA4d/oiksxPvqL2c8+ATb0q8k2UrN/HeAwAAAAAAAAAAAAAAAAAAAAAAAAAQWB5RvjWNQczQPhHlaSwSL0UvFL9UMSY9MLORuNpCrtRbWGpCGgkJEu/D3VdI+rak1Un3FaHRhSjzJCrRS16wMDEAIElrJLmCBTDreYKkq9z9Eklfk/RTM9uYwthqMrOKu39T0nvrVJkr6QVqMjGBuy9R+MLI15nZ35tod5nC77muNbPyTNttVDXB3LWSTkqqD8TimoQWFoa02cx2JdR21ILRM00S99CI8r/MsL1ccfceSY9TcB/7CEkPVnTiwlYsSbDtJIXtBxVJN6Q0jk0hZWHJJiY7JqI86cRKVyXcfidIcu3ksHNkOybRzNJdCbQZlSjs7gT6jOo3yf0ijWvu61T/mnuZuy81sw1x9enuSyU9XdKjq/2uUrLxxHadVzsaSQ9a81oFFzUVTU94MPHz2ZLea2a7UxrT5yS9S3tnRC5UHy+R9PGUxgEAAJCJ6hc1R8/tGlb3kDQ2WNbY5j6V962oa+6YRkrdGh4e0PzuIQ0tHU98PJXFpb5rv/GMQ4894/xbE++sDbj7kp7esaPnL0wq3r7H4PyhvnN/dMahL3nuN3jvw92v3rIKO8OSKc9Mb99obG01KLZfBgUApKSg6+Oce/oHRjQ8lOr3Rsw9ANB+7i9U4vuuN+25p1QuXptaZwCAuBB3AwCkj7gbACB9xN0AAGkj7gYASF8McbeJ+51KT0xjmj2YNwEAiF/Ugutb0xjEDEUthJPGIvFSdHIFFgBHI6K+CIlalDIOiR4z7n6EpAskHZRkPx1sXtYDaBALAAIAEmNmd7v7VyS9oYHqp1QfJXe/VNJFki6W9OcU1/2b8A3VT3ogSWeoyaQHkl4qKSzC3Gy7h0WUp7Eg81Ui6UHeJbno9Gy3JcG2oxaMDkssU0vU+eLSGbaXC+5+nKQ3STpNe6/fmrR2jSMdFVK2Q9JL3T2NcRwcUrZfg21kPQeS9CBaVufImZ4fZ7skPqeoBQqT2jfC+k1yv8jDNfdhklpKeuDu3ZJeKOmfFNyjxfdLntHadV7taGnuAJ3oLQoSHEyoaE/Cg7Kk15rZ29MMfJjZDknnqXYShpelNQ4AAIAMrZCk+d1DqgwGf9g2XOzW/GJwSTZc6lN/eVyVwcSS2k3XVTk2vc5yb0X/wEhqnXUVy7z3EY46/ZJN6ilfr2JZhQ3x5MXr7Stp547UYgDXHX/4JZvT6gwAEI9V//GzW1SojMQ394yrf2BE27fOjaW9CMw9ANCGjjr9kk2FQuX6wqauWNpLc+7ZuX1ghIR+ANB+iLsBALJA3A0AkDbibgCAtBF3AwBkIY642wP3O7vmqsyfWjfquqNOZ94EACABUVcjW9MYxAz1R5TnJelB1DiBRlSiq7QssT+wdvdlkn4lEh60ol3uGgvRVQAAaMm7Jd08g/pdkh6tIOnAbyRtc/fL3P0z7v5id1+ZxCAnM7ObJf0ppMpqdz+wyebPDCkrSVrTZLtR78tNTbY7E2n0gdZE3Q+jeUl+DxJ1fznTa/oDIspvnGF7mXL3Q939B5KulPR6pZvwQGrfRHL7h5TNl/S/KT2eHjGORoTNgTvNLNHk7GZ2j6IXdp/tsjpHEvOYmdgTEJhZ1ByWVNKDNGKzteThmntFK427+wsk3SDp/ySdqvTXu2/XebWjkfSgSe7+EElHVH+cPCkVFJyoPmpmX0l9YIHzpoxnwkPc/fC0BwMAAAAg995cOWKrei9YGFuDpbHUbjffklZHAICYLR5+V5xzz0NOulFX/21VbO2FYO4BgPb15u5b4vs9g7TmnvX3LXlX4p0AAJJC3A0AkD7ibgCA9BF3AwCkjbgbACB9McTdJu53xg+OZUSzAfMmAADZyGpRn1akNWYWu0IcRiLK01hkcUGCbX9V0iEN1h2R9AdJn5b0ZgULFj5MQcKEfRQs/t9jZoV6jxn01U56sh4AAAB5YGZbJT1H0romm+hWcG3xVknnSrrX3a9194+6+0nxjLKmr4eUFSSdPtMG3f1Bkk4MqXJBCwszL48oT2OxexbUz7+0kg3ORlH3iHkSdb7YmsYg4uDur5Z0taTnZziMrgz7boq7L1Z7JP1sNJlg2D6d1tzE+TVcO50jZy0zy+Jz6rR9Iw/X3FHzfE3uPs/dvyvp+5KyXO+87ebV2YCkB8174pSfK9rzJeV1CrI9ZuUCSTur/5/6Be3jUx4LAAAAgJw76vRLLtai0dWFBTtu7/3BQhU2dLfc5oLFu7Rt81zt3N5oHHhmxse6bpe0+vjDL7k4kQ4AAIlb5T89u1gaO6v3B4vG4ph79lm+VUc95FZd/ucHafvWuTGMcG/MPQDQ/o46/ZKLuyrjq3v+0nN/YVPr31smPffs3D4wcuuN+5/1/Gd8++zYGwcApIK4GwAgC8TdAABpI+4GAEgbcTcAQBbiiLtN3O9cdv2DtOWAfpWTmXaakbcFAa6TtPqo05k3AQBIyFBE+aJURjEzwxHlSS7gPlnUYvRR4wQkaXdEedsmPXD3FyhIXBDlQkkvlLTYzB5rZm8zs8+Z2S/M7HIzu9PMNpnZsJmNR7TViclI8naPBgBAZszsBgWL/f8tpiaPkfROSX919xvd/R3uPi+mtiecq/B7gzOaaPPMiPKwRAtR5kSU72ih7Uax4HP+8RlBij5fbE1jEK1y9w9J+rKk+H85sfPFPWcmpa/BemH7dBrzn8T5FUAgD9fcM54X3X2ZpEskvaipEaHjtf6bvbPXw+s8X5H0YTPLLIO9mY26+88lvVjTkx6cIulL6Y8KAAAAQJ5V/yjkkLVrTlnc95f+VZWuvkPKi0st/ZLqPiqpouKW+7uX3bN1oD+WX4RbsHjHhqUrttx44oMu2hxHewCAbK3yn54t6ewbP/CMQ8uLyo9sde5ZqWGtKN6xZd0dczde84+VGhgYbTlTPHMPAHSW6r3PyrVrTllcuqnnRBW7jmilvZUa1sribdp4+5x115RWbo9j7pGkUrl47Uue+41b42gLAJAt4m4AgCwQdwMApI24GwAgbcTdAABZiCPuNnG/s+PWgTn3FBcs75kz2l/oLg+XC1pXHu96YPHT7nJpTnelNG0+KlbK/V2V8uDU53vLY/f1V0obJW2RtLNG1xtU+4/Y7zvq9Es2r11zymJJKyXp/qEli4uF8sLe4vgSSSoWynO6CuWFXYVyqb97bKeCBUAmxtYvadp4qmOYWNhrm/Ze2HXyGKeO676jTr+EeRMAgGTtiihfmMYgZigqUUMai8Q30k/UOAFJWh9Rnsb+nFQf/xFRvkvSa83sOzH2mVbSkzRFJcZ4qJldmcZAAADIAzO7290fLekNkt4naWlMTR8p6b8lvdfd/0vSp81stNVGzWybu/9Y0kvqVFnl7o8ws7800p67FyW9PKTKNkk/mtko9xL1OzlpLMbMgs/5V856AMiFqHTeW9MYRCvc/V8l/XvW42hj+UnpHo+wOTCtuYk5EICUj2vuGf2uvrvPkXS+pOObHRA6H0kPmnfkpP9PTiywW9J3Ux5LLb9SkPRgQkVBhurHZjMcAAAAAO2g+kcif64+YnFsXA0BADrWqv84/1ZJsS0ww9wDAIhSvff5dfUBAEDiiLsBALJA3A0AkDbibgCAtBF3AwBkIe64Wx5U59TNknSu+zLV/tvjcTOLWqAVAADk37qI8oVpDGKGNkaUp5X0IGpx9Q2pjAJp64u5vfsiyltKLN2g2Ptw95MkPSSkypikx5vZX2PuuqVEqDm1KaL8EElXpjAOAAByw8zGJP2Pu39N0qslvUrScTE1v1DSxySd7u6nmdkNMbT5ddVPeiBJZ0hqKOmBpCdI2j+k/FwzGw4pj1KMKB9roe1GpdEHgORVoqtkx90fJenDM9jkDkl/lXSVpH9IukdBIsPtknZIGpU0ZmZ1X3d13jqzySHnUU/WA4hZ2ByY1tzEHAhAysc1d9cM2/tvSSc2WLck6XJJl0laq+D3bdYp+E5lp4JkuePV+7663D3X1xqYjqQHzdtfe19cF6o//8nMStkMaS+TAxoTY5Ok/d39QDO7M4MxAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIH13RZQfmcooZubeiPLDkh6AuxcVLDReT0nRCSXQmrAFjQoJ9rsk5vaiEqgdH3N/afXxnIjy9yeQ8ECSFifQZtai1gM6NJVRAACQQ2a2Q9KnJX3a3Y+T9ExJj5d0sqT+Fpt/iKQ/u/sTzOzvLbb1awXJrlbWKT/N3c8ys9EG2jojovzrMxrZdCMR5fNabL8RaSWyA9CaoYjyRQoWLc4ddy9I+oKiF3TeIulzktaY2doYuk4yXpGFqDmj3YxIGqhTlsb8JzEHAgjk4Zq74URq7n6ipDc2UPUySZ+V9EMz29Zo+3X67LQ5dVYg6UHzBus8f2Wagwhxg4Kbg35N//LuWEV/yQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAOYGYb3X2bpAV1qhzg7vuaWVSigTTdEVH+0BTGcKSkuSHl95hZOYVxzGbjIWVzEuw31kX1zexed98c0u5D3L1gZmFJHppWTeDx4ASafmxI2bCk/0mgT6kzEwDcFlF+RCqjAAAg58zsKklXSfqQu/dLeoSkx0h6tIIkCPXuecIskPRTd3+4md3dwthK7r5G0r/WqbJYQcKG88LacfdBSc8PqXKLmf2puVE+IGpx0zQWY2bBZ6A9RCU0WCip6XNnwp6nILlNmF9LepmZbYqx32bmojzbHVH+YzN7bhoDicmw6ic9SGtuYg4EIOXjmrvhpAeS/iOifFzSO83sUzNoM0qnzamzQjHrAbSxnjrPx3mh2rTqF1i3qHaGr8NTHg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACydUVE+SNTGUWDzOxOSdtCqixz95UJDyMqscI1CfcPaSSkbF6C/e6fQJtXhpQNSjohgT4nPEzhCTya9aCQsl+a2Y4E+pSCRY07zeUR5U9KZRQAALQRMxs2s9+Z2YfM7OkKkgocL+ksBYtYh11LTrVS0pdiGNbXI8rPaKCNFyo8wVdUH43YHFGehwVYgTT0ZT2ANrAuonxhGoNo0msiys+T9LSYEx5I0qKY28ta1JxxSCqjiE/Y6yHpAdoN81h7y8M1d0NzoLuvkPT0iGovjjnhgdR5c+qsQNKD5tXLNBX2ZWnabq7zPEkPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZpfLIspPTWMQMxSVVCDphc+j2r8q4f4RvpbLwgT7PTmBNn8XUX56An0m1ra7z5G0NKTK9XH3OUkSn0+mzOx+SXeFVDnU3cOSTAAAMOuZWdnMrjKzs83sKQquVV4h6fcNNvE0d2/pOsPMrpP095AqT3f3fSKaOTOkrCLpmzMe2HT3RZTvG0MfUZJOYof2UYkoLyTY95IE2+4UYfcpknRkKqOYoeo9a1jyuPslvd7Mygl0vziBNjNjZrslbQyp0m5JD8LmwIXuPpBk59V9k6QHnSdsLmMeQz15uOa+v8F2nimpK6T8f83shw22NRMdNafOFiQ9aN7OOs8vTHMQEepdSJH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYHb5dUT56Ukv6tWESyLKX5ZUx+7eLenFEdWiFrFH69aHlK1KokN375V0UgJNXxBRfpq7hy0c1ZTqvnxa3O1KmhdR3uiCWTPi7o9QeLKFVpUiynsS7Ps3EeXPSbBvAAA6jpntMLM1ZnaKpMdIuraBzd4UQ9dfDynrkfTSeoXufqCkx4Vsf7GZ3dHswCaJWsT8ITH0EeW4FPpAexiPKJ+TYN8spBvtHxHlj0xlFDP3CIXfv33ZzDbF3Wn1vv6guNvNgdtCyua5+4rURtK6sDmwKOnYhPt/sFgPuhOFzWXMY6gnD9fcUfcFEx4bUf7xBtuZqUMTahcJYpJr3j2qnSknKnNimmp9aVeQ1E4XgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGjd7yTtCClfpASTCDQpapH4Z7j7ooT6fqrCF1YfkfT7hPrGHneGlC109wMS6POpkvoTaPdShS8itULS6Qn0e6akZQm02xtRHpU8oFn/L6F2J4xGlCeZHOaHEeVvdfck9k0AADqemf1R0qMl/S2i6hNj6O7bksZCys8MKTtDtdc4nBCWUGEm/qHgnqaeNBISkPQAE8L2RSk64Vor9k+w7U5xeUR5XpMePCii/HsJ9ftgJbvPZuWKiPInpTKKeFwfUZ70/MT815nC5jLmMdST9TX3sKRbG2wnbF690sxubnxIM/LohNpFgrqzHkAbu03SiTWePyztgYTYPuXnioIgRideAAMAAADI2No1pywuVXpO1HDPcSoVl1cGy4OttFfpr9wnFW4u7O669Ngzzm80KDLrrF1zymJt7F9V6S0cW+4pr1K5uKQyt9JKZtfdUuF2FQo3q8R73yx3X7xi/w2rDl6w7tjBXeOruncV9joeRoZ65pVUXF6cO97XSHtdqoyoWFlfGeu6d7xQXFfuKeyeKBvsGd4ycMCO28oHjd54/OGXbI77tXSaic9mydKtYb9w3rAFi3dsWLpiC+99Rh44B472HFueX1nV6tyjQmGnKoWbyitHr+GYCnfjB55xaHlR+ZHlvtLhqhQOaXnu6a1skoo3lZeUeO9bcO6Pzjh0cHvpkfO3jx7eWyztO7lsqNTTN6bi0t6e8QWNtNWlykixUtlRGuu6Z7y7eMfkuUeSepYN3TL/mM1/47NqzLk/OuPQrmL52DjaYu7J3sQ5sLSodLhU3Dd6ixCFws5KX3ldefn41ZWVYxxTIR645ywUjquUdZCKxb2u5556YF9fuVKY9su8xUKlcu2aJ0//JZGeygZJd1QWlK8uHc573yx3X3zUvHtPXL5g83E93ePLJ9/7DJV6+kaGexb2FkvzGr33KZYq24tdWj/WVby9pK6Nk8sGe4a3zC2Ocp/aoLjvfUrl4rUvee43eO8zQtwtG8Td8om4W34Rd+ssxN2yQ9wtn4i75Rdxt85C3C0bUXG3GSPuFoupcbdTFvftU64UipI0Uu7uHRvpXtBTLM3tmjPW+7svvChsgQRJxN3iRNytsxB3ywZxt3wi7pZfxN1mj7VrTlksaWWNovmqvcDuoILFiGvZImlnjec3aPrfnE6476jTL9m8ds0pix+xbMWqUrnY1dM1Pq+3OL5kokJPcbx/7ZpTuqo/zpE0EQ/pr45nqp0K/jh+wjZJk2Mhk8c5eWz3HXU6+ygAAEkys1F3/56kV4dUe5u7f8PMIuNPKfmDgmuGetfGvQpezycS6PvNEeW/MrOhBPrF3m6MKH+UwhMJNOPtMbcnSTKzirt/S9K7Qqp91N1/ZGbb4uizmhTkw3G0VUPU/h97ogV331fSC+Nud4qw5DBScL+WlF8r/Jy3r6Q3SfpkgmMAAKBjmdl2dz9d0rWSeupUW+7uR5rZTS30s8ndz5f03DpVHubuR5tZrUWXXxHS9C5JP2h2XJOZWcnd16r+Iqj7ufsyM1sfR39TufsK1Y6NY3aq9x3GhIVJdFpNKPbQJNruMFcoSGrXVaf8GHdfamYbUhxTIw6KKL8hoX47dXHmv0h6fUj5MyV9M6WxtOraiPKkzwsnJNw+shEWy1uYYL8nJ9g2kpf0NfdyhV9z32BmjSauDZtXo5LJtKJT59WORtKD5l0n6UWTfp5IKPDYbIZTU70sP639ESoAAAAATLJ2zSmrS8Web5fnDqwo3tmn8YfvVGXpeKx9XPXX1WNdt/a/89jTfnF2rA23sbVrTlmtTX1fKVfmHlzoG1NlxxyNP3anKkujkpfPDO/9zLj76mX7bvzK006+5eCBXWX1XDpPxY39D5Rv7ulTz/671P/4DbEeJ+Xqv1de/7jb1Vt51fGHX3JxbI13iInPZvUzbjl4/sJdsbd/2Q2rb+/uKfHep2TiHFjZsvjg8vyKxh+7I/a5R+KYquVGe9ZZpTnFj5aPGOsp3t2v8RNHeO9z4LzzX3bWfqVtH33wdT09xS09Km7t1kT4f13fHK0/vKBDH3WbCvvE/zdHf79m9f1dA6WX8lnVdt75Lztr2cpNH1517FBDCz/MBHNP+ibOgeMPH+mpLCmpsqjR724bd+X1j7tfvRWOqUkm7jlL+xVXdG2oaPygsipLarz3wyWpPC3ngVSsaLw/+vx35bWPu1/9vPeNcvfVR82599vPn3//Ch04rJ6/7bn3Wdc3R7fNma+jF96jRY+/N9ZrhXFJV/718WPdt/Zxn1pHkvc+f7j8KSPr71vyruc/49tnx9ow6iLulg3ibvlE3C2/iLt1FuJu2SHulk/E3fKLuFtnIe6WjYbjbi0i7jYz9eJuw8Uure+bozsHBnXk/PvV/egNqiwZV7FYUV8D8c8oxN2iEXfrLMTdskHcLZ+Iu+UXcbfZY+2aU1ZLOkfS0TkYy4ikvhUDm1TR9O/fC6qkOZbrJb35qNPZRwEASNAXFZ704FhJJum96QwnnJmNu/t3JL01pNr73P2bcS4M5O7PkvTUiGrfiKs/hLoyovw0Sd+NqzN3f4Skx8XVXg2fk/QOhSyyK+kjkt4YU38fU/0F9Fu1RUGoud4aRicl0OdnVP+9i0vUQp2HJtWxmY24+/9K+veQau929++Y2b1JjQMAgE5mZje5+wWSnh5SbaWkppMeVH1N9ZMeSNIZmpIMy90fJenIkG1+YGa1Et8260+qn/RACsb/pRj7m+z5CbXbbsJ+aSfp697cqCZp3Kr6i0KvSqjrkxQkU0SIasKYv6j+wtpFSa9RcC+bJ2EJ6zab2WhC/T4zoXYnZHXe+E1E+VPcvc/M4v1lkGT8KaL8Oe7+VjMrR9SbMXcvSnp23O0iF8Ji04nMY+7eq2Tib0jXc5XdNXfU+XCysHn1/hm00zB330/S8Um0jWQVsx5AG/vzpP9P/g2uxe5+fMpjqafeBRJJDwAAAADEYu2aU1aXCt0XlpYXVnRfM1djz9iayAIslcWlnvETd33q2u887W2xN96G1q45ZbW29F5YGek7uNg1Jm2Yr9Hn895nzd1X77N884UnP+i6g/uLY+r72WIVN+75LmhzT58WrNyurpesS+SzkiT1Vg6WdNGVt5xyajIdtKeJz+ZRq69K5A9AJam7p3SweO9T8cA5cN38g1UsauzZWzimUnKjPeusclfPJ8sP2tXTdfOgRp+XzNwjifd+Bs47/2VnHd6//pPzL+3v6b5toLrwWmBd3xzduapbhz3rpkQWXpOkroHSCvFZ1XTe+S8769BVd39ycH78C69JzD1pmzgHjj16R0/58NFEFl6TJPVWOKYmeeCec9XYiq57ixo7YTyRhdckSf28941y99VHDNx/4UOGNqyoPGSX+n6x595nXd8cXTt/iU6ad4e6X3J/MtcKi8e5T60j6XufwflDfYeuuvtT553/srfF3jimIe6WDeJu+UTcLb+Iu3UW4m7ZIe6WT8Td8ou4W2ch7pYN4m75FBZ329A7oLWDi3T83LvV9ez1qiwh7pYm4m6dhbhbNoi75RNxt/wi7jZ7VBMeXKgcJDyoSuReu0lHS7po7Rr2UQAAkmJmf5V0cUS1d1UX28yLL0ihmZgWKMaF9dy9X9KnIqrdLemncfWJUJdJGg4pf7q7L4ujI3efI+nrcbRVj5ndJelbEdXe4O4tJz1w97dKem2r7dRjZiVJd4RUeby7L4irP3c/U9IL4movxEZJQyHlSd/LnSMpLDCwj6QfuftAwuMAAKCT/TGifJ8Y+vi5guuKek6vLnw82RkRbcZ9rXpRRPlLY+5vspcl2HY7CVt0fbZd790ZUvaQhPp8XkLtdqKfRZS/ocY5LWthCS0S+aU5dz9S0lOSaHuSTM4bZnanpMtDqiyQ9E9J9R+nauLU60Oq7CfpsQl1/3gFyZXQecLmsYXufkACfT5VUn8C7SJdWV5zXzyDtlKfVyW9WfUT7iLH8nZR2E7+rD0Xe1O/GH1dymOpp96XPkxIAAAAAOJyzvjhFfVesFCjT9qaeGelQ4fzltE5K+cUbl6oykHbVbiZ9z5HznnwiTdJfcExMVVPpZzKZzUxlrQ6ahPBZ5NSX2l1NIudU7h5oQqjRY6ptG3u//Dok7aq58J05p4q3vsIy1Zu+nDvBcExMdVli5br6IffktZQ+KymWLZy04dT6or3Pg3Vc6D6wv5WLlZ8roFzxg+vqPt2afxw3vscOee4DZs0+qSt0+59Llu0XCduWcd9anZSufdZtnIT7306iLtlg7hbPhF3yy/ibp2FuFtWiLvlEnG3/CLu1mGIu2WFuFs+1Y27XblwqY7btkGjp2xPfBDcp9ZE3K2zEHfLBnG3fCLull/E3WYP3v9ovEcAACTr3RHlXZJ+4O5HpDGYKGZ2vaQfRVR7lbvHtTjQ5yUdFlHn42YWtsgcYlJ9n8MWY+2T9NGYuvuspFUxtRXmvQpf1F6SPuvu/+7uhZk27u4Fd3+fpM80NbqZ+VtIWb+k98TRibs/VOm8HplZRVLYDfqT3T2xxbbM7D5JH4+odpKkb7h72GJjsXH3fnd/Whp9AQCQkrBkBFIMiWLNbEzSt0Oq7CfpCRM/uHufpJeE1L9T0UkKZurXCl88+xR3PzDmPuXuh0o6Oe5229SOkLLBZu4H2tiNIWWHuPvyODtz9/mSXhNnmx3u25LKIeUHKfwcloWwZHZL3L0rgT7/WVLSx23YeWN+wn1HJXF8dzWhZDuISmZ6ekL9viKhdpG9sHlMkpJIMvz2BNpE+pK65j5Y0qNDqoxIumAGTYbNq7EkJZ6smvA1L2u8Y4ZIetAkM9sp6ULtfUFZqf58prsvzmRge1tY5/mxNAcBAAAAoDOtXXPKkkqlcHRlTkWFnUVVlo4n3mdlcanv2m8849DEO8qxtWtOWaKx4tGVolTcXZTKvPd54O5LenrHjp7ft1uV/oqKG3v2Kh8pFDTYPZzKZ1V1zJW3nJKH2ETmHvhsFkb9DnBseO8TNHEOVKmownCBYypFN37gmYerUuir9JWl8XTmnqpZ/96H+e6Pzjh8sGekr7CjqOLWvX9XfqRYVGmgosI+qYWD+awm+e6Pzjh8cP5Qy7/U2CDe+4Q9cA4cLKmyKKkE89PM+s/1gXvO+SUVdhdUWcJ7nwfuvmRu1/DR3UNSZbC8173PSLGo4WK35ncPcZ+agTTvfQbnD/Wd+6MzeO8TRNwtG8Td8om4W34Rd+ssxN2yQ9wtn4i75Rdxt85C3C0bxN3yKSruNlLs1rzuYVWWcJ+aNuJunYW4WzaIu+UTcbf8Iu42e6xdc8oSSUdnPY42cMzaNeyjAAAkxcwulfS1iGorJf3e3WNdiLK6GPvz3N1muOl7Fb1exlfd/dlNDk2S5O7/LemVEdX+IelLrfSDGftuRPmZ7v6cZht39253/6qiP/tYmNk9kqKOgYKkD0n6bXXB/4a4+wkKFsP9QI3iqxseZON+FVH+Nnd/SisduPujFCzIm/TijZP9JaRskaQ3Jtz/xyStjajzQgXn6YOSGoS7L3H3f5N0m2JKYAEAQE7sE1G+LaZ+vh5Rfsak/z9LwXVGPd+sJmeKjZltk/TLkCpFSf8ZZ59V/6XkFwVvFxtCynokHZDWQHLgypCyguJfUP+NSvceo62Z2R2Kvv/7jLuvSGM8DQo7voqSToizs+q9++vjbLOOsNd1YELJHCZ8ReFJHFeofe4dz40oP9Pdj4yzQ3c/RtLL42wTuXJlRPlpcXbm7o+Q9Lg420Rmkrrm/pDCr7l/Wb0faFTY/HPSDNpp1AcVfd+GnCLpQWu+N+n/kw/iAUnvT3coNdW74B9OdRQAAAAAOtWKSqEY/AHoYFgi5ph1VY5Nr7NcWqHRorRgXBrlvc+RFf0DI9JQcExMNVrsSvezCqxMu8OcCj6bdPHeJ2eFRouqDJQ5ptJW0dGVwbKK21KeewKz+70PUSyWjy7sDI6JqYaL3ZrXtzvtIfFZVRWL5bT/KJ33PknVc6CGUv9abbZ/rsE955hUKfDe58iK+d1DqgyWp937DBe71V8e5z41O6ne+3QVy7z3ySLulg3ibvlE3C2/iLt1FuJuWSHulkvE3fKLuFuHIe6WFeJu+RQad+srj6syh/vUjBB36yzE3bJB3C2fiLvlF3G32SNPi73kHfsoAADJepukuyLqLJf0O3f/sLvPbaUzdx909zMlXSPpPEkNL+IuSWZ2vaT/jqjWJ+k8d//3mS7w5u6L3P0Hkt7RQPU3mRlrd6Tru5I2h5QXJH3X3Z8704bd/QgFC72+sqmRNe+Tki5ooN5qSZe7+yXu/nZ3f6S77+PuPdXHUnd/lLu/w93/IOnvqr3g2d2S3hfj+Cf8SFLYF6k9kn7g7i+aacPu3uXu/6IgicPUBa6Szu78m4jyj7v7v7R6bqzHzIYkvVTSaETVhyvYP97i7nPi6Lv6vj/Z3b+hYL/5iLiXBQB0nodFlN8aRydmdrmka0OqPN/dB6v/PyOkniR9I44x1fCViPJXuHtsi5i6+6MV/+L17Szqvnw2JVH+Q0T5me4eS7IMdz9W+VgvtN18NKJ8H0lfTmMgDfpHRPnz4urI3fslrVFwD5y0sPNGj6QjkurYzLZK+mJEtXe7+wuTGkNczOwKhS9S3yPpEzF3e7akJJNSIFuXKXy956e7+7I4OqrGgKKSa6G9xH3N/SgFscUwUfcBU4XNq0fHmSjG3U+VdFZc7SF93VkPoM2dq+AiZIGkicyHFQVfhL3J3c8zs4szGpsUfClRKyPjxrQHAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHwws23u/nxJl0gaCKnaLeldkl7n7l+Q9C0zu6GRPtx9paTHSHqxpGdE9NNQk5KeKCls8Z8uSR+S9DJ3/5CkH5hZ3UXD3X2xpNdI+jdJSxoYw6fN7NeNDxlxMLPd7v4/kiykWq+kH7r7dyW9z8xuqlexulDmcZJeJ+n1qr0GzzmS3tL8qMOZWcXdXybpT2psQcLHVh/NGJP0igbq1VqnJpSZbXX3ryj8vZqrICnFDyT9t5ldGtamu89TsBDuv0qqt1jWhyW9d6bjnYGfS9opabBOeZ+kj0t6v7v/XtJ1ktZVtxkLafc+Mzu/kQGY2ZXu/hoFCxyHLe66WNL/SDJ3/7ykn0i6wswaTgxRTf5xsqQnSXqqGjsfAgAQK3d/sqSKmTWSGKqVfvaX9MyQKtsl3Rxjl19XcN1QyxxJL3T38yU9LaSNP4dd37bopwpeb71r0oKkL7j7o1tN/lZNGPWFVtroQGsjyp+hIEnbbHCppK2SFtYpP0FBcpCWFnmuJhr5P0n9rbQzG5nZ79z9V5KeElLt6e7+cTP717TGFeJvEeVvcfdPm9m6Vjqpxhi+qPSSlDRy3oiq04oPKkgcubhOeUHS1939PjP7Y4LjeIC7Hy9pm5ndNsNNP6nwpELPdPcXmdn3mh5clbufoSCuiQ5lZqPufpHqX9P1KUge86oYuvuspFUxtIP8iPOae0DS5xUeT7xZ0s9m2PTfJD0hpPyDCr4Laom7H6QgkVAsya6QDZIetKD6hdiXFWRpn0h2UKk+igoutB5hZvenPbbqlzcPmvL0xPjuS3s8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyA8zu8zdT5d0rqLXIFki6T2S3uPud0v6q6RbJN0vabeCRZsWKVjw7CBJJ0raL+bxjrj7C6t9L4+ofoykb0va6e6/k3SNgvU2hhUswH6gpIdJepQaX3/ldwoWYUc2Pq4gQcX+EfVeLOnF7r5W0sUKPveNCj73ZZL2lbRa0sqQNj4n6QdKMOmBJJnZRnd/anWcByTY1RvM7GJ3PzWi3niT7buklys4B4R5gaQXuPvtkv6oYHGtLZJGFSQXOEhBMopHKEhiUc9PJH1ZCSY9MLNd7v4lSW+PqDpXQZKApzbY9O8kNZT0oDqONe6+VMFCjFH2kfS+6mOnu/9J0q2SNlcfOxS8rwMKjoWVkg6XdJSkBY2OCQCABB0t6VPufqmkT0k6z8yavT6pyd17FdwnhF1r/DLmftdI+oiCBG21nKlgLg67L2lpkfcwZlZ29w9G9HGCpK+6++kzSaw0mbt3K3gvjm1m+w52raRdCq4raznD3T9iZvekOKZMVBeL/rGCY6Kej7v7H8zsH8304e7LFVyPsx827/9JulLhSSP+xd0XSXpTWCLKmXL3fSX9i6QvmVnkov5mdmP1/vPgOlXmSVrj7s9odpzu3iPpSwoScqTlLxHlb3X3L5rZziQ6N7Mt7v4vkr4SUm2OpIvc/V/M7DNJjEOSqnGOsyQ9W0ESv5kmPfiOgthCvYSLkvQVd7/DzP7azBglyd0fqyAxBjrfdxWeyOpMd/+Rmf24mcar11P/qyDxCDpPHNfcXQqSuRwXUfWDZlaeYfO/UpAgu54XufurzSxsfgjl7qsUJKON9bslpK+Y9QA6wEcVBPSlPYkPJv5/gKTfuHsWmYufqz2f79TMJLekOxQAAIBU3S9J28cHVNhZVGWwrP7yuLaX50iS+rtGNFzsVmFnipfCpcK16XWWe/cPD/Wl1lmpXOS9BwAAAAAAAAAAAAAAAAAAAAAAAACgDjM7T8Ei8TNZ3G1/Sc+X9E4FC3F/QdKnJb1f0j9Leo4SWpTGzO6U9AQFi9g3YlDSMxQsxvNpBQuMfVLS2yQ9Vo0nPPiLpGeZ2dhMxov4mNkuBYtfNroY01GS3qBgQf7PSvqYgsURX6bwhAc/V7CIYyrM7FZJJytIzBG3cUmvmrTQ1EBE/eFmOjGzjZJeP4NNDlaQJOH9Co7LzytIavEWBcdl2CLEV0g6vZlxNuGDktal1FddZvYpSa+VNJPFzgYlPVnBMfDvkv5bwfnvf7TnWHi5ggQTJDwAAOTNIxUkZrvd3f/L3Y+Ko1F3P0BBsqnHRlT9Uhz9TTCz+yX9OqTK4xR+/Tmi4P1I0jcl/T2izmmSznX3wZk27u7zJf1QwfqImKSaYON3IVXmS/qtu5+S0pCy9oWI8qWSLq4uiDsj7v4ESX9WkAARTTKzGxUkxYzyGkmXufujW+3T3Y9z9y8oSOp2lsITLkz17YjyJ0r6obvv08S4jpJ0iWovPt7UYtWNMLP7JF0fUuUgBevgRi143coYvirpexHVeiR92t1/4u4Pjatvd9/X3f/F3a+VdJGChAdNqcb5ohKcDkr6tbs/pZk+3P3ZCmJNM9lv0b6+qyDxZD0FSd919+fOtGF3P0LSL0XCg07XyjX3PEnfl/TCiKp/V3D9P1OXSLoros6X3P2tTbQtdz9Twfcwh04pSmxORXIa/eINdVQzZn9UwZcUlerThUn/P1rSBe7+HDOLOjDj9OaQsiS+5AIAAMgFM9vk7tfvKvUfPT4gFXYW1bN4RMXxgkq7etQ3d0z9/UPaPj6g3g3dqiyNNaH3NIXNXSPHnnH+rYl20kYmPp/tW+cePX/hrkT72rl9YOQlz/0G7z0AAAAAAAAAAAAAAAAAAAAAAAAAACHM7IfVxf/OlbRv1uOJYmbXVRd8/Imkw1Po8ueSXmpmO1LoCyHM7EJ3f7uksxPq4jeSXmhm4+6eUBfTmdnd7v4IBQk53hBTs7crSHhw8aTnFkZs01TSA0kys++7+/sk/WezbTTgWklPM7Md7r4kwX4kSWa2xd1foGCR4jlJ9xcxli+7+20KFiTL/XkaAICY7Cfp3ZLe7e43SPqpgsWN/2Rm2xttxN0fJukMBUmaohYcvsjMftvkeMN8TdLT6pQVJB0Ssu2PzWxr3AOazMwq7v46BYuM9oRUfYGk49z9bWZ2flS77l5QkBTvUwoSX011paTjZzreDnSupKeHlK+S9Lvq9eClkm6StE3SLoUnhfudmd0c2yhTYGaXuvvvFCQDqWd/SVe5+39L+pSZbapX0d17FSQ6+RdJT61RZZukHys4R6Bxn1KQQO3FEfUeLOkP7v4bBQllfmZmQ1GNVz+3h0h6pqSXKEhq2KzPSnqHpL6QOk+XdI27f0TSV6PmmOq88kYFiRlrrel7k6SrJL2oqRE35lwFSR7reYSkK939ekmXSbpF0nZJu7Vnrdxazq8mVWjEayQdJumEiHrPkvSsSfvB78xsfYN9qLrw90mSTlHwWZ2kYO6MhZn9xN1/oGCOq2eBpJ9Xk29YNfljKHdfriBG8lpNH+8uSfcpnbgmUmRmu939fyRZSLVeBclWvivpfWZ2U72K1Wup4yS9TsG1bK1zzjkKEomiPV2p6dfDE9fcZ5nZzxppxN2fqSBmflhE1VFJrzWzsLmgJjMru/unFSRXradL0meqiT0+KumCsL7cvV9BYrR/Uf3EVB+W9N6ZjhfZIulBPD6mIIvJcQou4AraO/HB8ZIud/fTzexXSQ+mmgHq4ZPGMtWlSY8BAAAgY2+WdNGVS/fRCReMa/RJW3Xieet0dd/heughN+hhS2/UZTuO0qkX7NDIyyJjRy3purX/XXp4ol20ozdf/bdVFz3mSZcn2sn6+5a8K9EOAAAAAAAAAAAAAAAAAAAAAAAAAADoEGb2B3d/qKTPKXyRr1wwsxuqi8R/UcGaH0kYlfRfkv7TzMIWkkSKzOzT1QW/PiGpGGPTX5b0RjMbi7HNhlUXfnyju39V0kckrW6yqa0KFnX8iJntnFK2MGLbuouFNsLMPujuGyV9WsECbnH6uaTT0k4+YmZ/dPfHSvq2gsVmM1NN+vEQBckxXqEYF3lswGYFnwEAAFl5UPXxTknl6uLv10u6U9K9knZIGlGwqPWgpGUKFsk+TtLKBvvYIemf4h32A36s4DptYRPbfj3WkdRhZle4+3sVLE4a5nBJP3P36yR9R9LvJN0oaYuC65NFCt77UyWdpvqLld8p6X0KklnMducquAeI2lcPUXiCjKleJamtkh5UnSXpbwoWza2nT9J7JL3L3f9crb9eQRKDRQrOAYcquK8aDGnndZKOiWHMs0o1UcorFSSneXQDmzyx+hh1978rSGh3u4JF+McVLCi/SNI+CpIdHKeY7inN7F53/7iiF0teoWCx6I+4+98U7FPrFOxTvdWxHang9R4Q0s6Ygvu1N7U28khfkPQuSQMR9Y6uPhq1WsFi/JGqCQmfLukSBe9NlIn9QO5+o4L3eIOC+83NCpK49CmYK1coeJ+PUnDeizP+U8vrFSSK2D+kTlHB5/rqapKE8yVdIeluSUMKPosDFCSBeKak56l+so1/l/R8kfSgU31cQVKQsP1JChLHvNjd10q6WMGxt1HSXAXz2L4Kjsmw64PPSfqBSHrQzv5DQSx36txyuKSf1rjm3lotX6QgVvk4BdfcjZ7r32tmV7Yw3nMUJO2NOn89vvq4z93/JOk6BfcLQwr28f0VJEc6WeHJZv8u6QMi6UHbSXrinhXMbFzS6QqyJUl7kh0UJv28RNL57v5Fd1+W1FjcfZGCL9EmZzGZ/P/tkv6aVP8AAAB5YGYXS1p9y9Dy2y/vX6HCVXO18Al3a7+hYd1wy5FaUt6lYw5dq7+O7aexc1eosCGBXGCbuse6L5t71rGn/eLs+Btvb2Z28ab1i1b/+aLjbt++dW7s7e/cPjBy6437n/X8Z3z77NgbBwAAAAAAAAAAAAAAAAAAAAAAAACgQ5nZejN7oaQnS7o0oW7WK1hE86xWGzKzzWb2IknPUbDgaZx+JekEM3MSHuSPmZ2tYD+9PYbm1kl6kZm9NquEB5OZ2V/N7PGSjlWwSNrV2nvtmFq2SfqRpFdLOtDM3lsj4YEULIZVT1nBYoMtMbMvSHqMpFtabatqs6TXSnpm2gkPJpjZ5QoW3ny9pCuzGMOksWwyszMlnSTpZwo+t6SMK1iE+IWSVprZfyXYFwAAM1GUdJikZ0l6s6QPSfqMgoRon1GQuOxtkp6qxhMejEl6mZklskC8mY0oWNh+pu5XcG+SCjP7mKRvNVj9GEn/qWCx63UKksaNKBjzxZLer/oJD0YVrN1Y65p11qnuH+/Iehx5YWZXSPpgg9W7FNx/nCXpwwoWf/6QpP+n4BwRlvDgPWb2vRaGOqtVE/c9VcHx3qheSY9SkGziQ5L+R9LnFST9+DcFi4SfpPiT6P2ngkWTG9Ev6bGS3q4gfvUFBXPLfyhYVDos4UFF0qvNLPH1Xs1svYLXlSkzW6fgGPzbDDddpWAeOEvB6/isgn3hbAXzxxskPUPBfJ/4uslmtlnSs9XYvNQv6eUKkiPeoCBp0nj13+slrVGwr9RLePBzBYuGo0OZ2S5JZ6rxmM1RCvZ5V3AsfEzSv0h6mcKvZX+uYL5De9uh4HxYLy499Zp7RHuuuX+nICFAowkPvmlmH29lsNXr1lcoOO81YqWCJNv/IelTCubVTyg4/z9R4QkP7pD07DzE7DFzCazuOjuZ2fXu/nJJP1SQ7KBS/Xfi/xUFF0uvlXSau39M0uerFzexcPdBSecpyMYz0f+EiXH8mC9TAQDAbFBNfHCIuy++RctX7X/LpmNXHLh51fzu4SX37lqxsDSqRQfNWz9vS6W7a/zC/ft7iuO9XXNKkdfHBWm8oPKuQqGws6zC5ooKOws95Q3q1h1lde0e7BneMrc4eumxZ5x/qx6R/OtsV5M/nxX7b1i1ZOnWpXG0WyoXr33Jc79xaxxtAQAAAAAAAAAAAAAAAAAAAAAAAAAwG5nZBZIucPfHSHqVpOdKWtxCk/dK+rWCBbp/amajLQ9yEjP7ibv/VME4X6NgMfyeJpraqmDdjs+b2WWxDRCJMLPfuvsxChai/3+SDp5hE3epujhuVovphzGz6yS9U9I7q2vKHCVpf0nzFKxhs0PBPnuTmd3dYLPHhZTdb2al5ke8h5n9zd0fJOmlkt6lxhfemuxmBQsefsXMttUoH1H4opUbm+izrup5638l/a+7HyzpVEknSjpSweeyj4LPplfpLMj4d0nPcvfDFJynn6fm3uepbpL0m+rjwjrvPQAAnWaXgoQHP0u4n69L+qcZbvOtuK7RZuDVkhYqWGw6Kf9kZr9391MT7KOtmNn/ufsjxOLFEz6gIBHcCxJq/8Mk9Wqdme1096cpSF7w2qzHU4+Zjbr7cyX9QdJBCXVTlvQ2M1uTUPu1fFRBkojnpdjnNGa2oXo+/x8Fc0hbMrMr3P35CpJKhi3C3YqrJZ1mZmV3T6gL5IGZXejub1eQyCMJv5H0QjMbZ19qf2Z2ibv/k6SvJNjNzxTTXG1ml7r7qxXc3xSi6jfpbklPNbN7E2ofCSPpQYzM7Kfu/loFX1AUVTvxQUHBFxQfkPQed/++gi+QWlL9MuQHko7X9IQHk3291b4AAADaSTXJ1J+rD+TMpM8HAAAAAAAAAAAAAAAAAAAAAAAAQJv4XvGpSS1iASBHzOwPkv7g7m9QsLj3yZIeKukQSQdKmq9gEbCKpJ0KFmHfLuk2STdUH383s2tSGGtF0g8l/dDdF0l6rKTHKFgE/FBJyyTNVbAg+XB1vPdIulXSlZJ+L+lSMxtJYazvl/T+pPup0/fBWfSrYB+JnZntlnS2u39a0iMlPVHSwyUdJmlfBZ95RcG+uUnS9Qo+719I+mt1v6nX9sVKbtGmGTGznZIuqz5a8YiQshtabHsvZjYu6ZuSvllNTrFaQaKAQyUtqT76FCwyvFPSHZJulHSFpF+b2Y0R7d+n4LyUOjO7XdLXqo9Mmdk/JL1X0nur6w89UnuSMRwoaYWC42BA0riCY2HisUHBe762+rjGzO5P+SUAAJC1P0h6QzXhVKLM7M/ufpOCebpRqa8bWF0c/HkKFl09PebmxyW91sxYD7EGM3ubu98l6T8VXL/NWtUFwV+m4Bg4LcamxyS9xcy+FGObs5qZDUt6nbtfqGBx72XZjqg2M7vb3R8t6bsK4ltx2inpdDP7cczthqoeJy+S9GFJb5fUlWb/U8ayW9Jr3P18SZ9ScD+apj9Jur3VRszsAnd/ioLEB0tabW+KSyU9M4+JN5EMM/u0uxckfULxJsj8sqQ3mtlYjG0iY2b21WoCiy8p/vXivynpNXHuM2b2TXffoSA+uiCudqv+Juk51fgv2hRJD2JmZl9z922Svq3gi85aiQ9U/blf0ssnbT7jL7rc/QBJZ0l6Y7W/iX4mVCY9d7mZXTTTPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA7VRfD+XP1kXtmtkXST6oPpKMnonw0yc6ryQvaZh/NgruvkHRQSJXEFvqtLiJ8naRzkuoDDyRjuF3Sd7IdCQAATfu6pK2SninpSQqSrCXlPknvMrNvJNhHLd+Q9MEG616RRgK5Wqr3gK9w9z8qWKh3TgzN3i7pVdXkYqjDzD7h7t9TsID5yyXtk/GQMmNmo5Je6u5/lvRfCpJ5teLvChb8varlwWEaM/s/d/+5pPdIeoOkeTF3UZF0oaQvSLq2mQbM7B53P1XSxyS9VfEkCfipgkQad8bQ1oyZWUnSO939a5LeIelFiv+9n8l4zqvuB/8s6f8pSEiZlDsULOT9dTO7Ja5GzewP7n68pG9JOiWGJisKFjE/y8yGYmgPbcTMznb3ayT9f5IObrG5dQrON99veWDIpWrigzskfVXxJI/ZJekdZvbFGNqaxsx+5O4nSfo/SQ+Locndkj4g6RPVhLpoYyQ9SICZ/dDdn64gi9cS7Z3oQJqe/KAudz9P0s0KssNvU5DYYKmCi7dTJT2oRtv12vz3mbwOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgwEFE+nMooEOZlEeWXpjIKAACAOqrJy74m6Wvu3qNgoeHVkh4l6eGSBlvsYljB4tTflPTL6sL+afumgoU8iw3U/XrCY4lkZl9w959J+pCC68lm1q7cKumzkj5iZjtjHF7Hqi6e/jZ3f4ekR0h6tKSHSDpM0goF61sOKPg8Qtey7ARm9hl3/76kf5X0KkkLZtjEZZI+Lun7ZlaOe3zYw8y2KViA/0MKPqvTFOzDzRpXcK/6S0nnxrGwffXcf5a7nyPp3ySdqWCN15kYkfQjSZ82s3rJF29TkGijlntn2F8kM7te0mvc/U0KzhknSzpGwXljuaTFkvoUnbQyjrEMS/qYu39S0vMU7AdPUeuJS3ZJ+r2k31QfV1eTYMbOzO6uJsh4mYJ5+9Amm7pE0vvM7JKYhoY2ZGa/dfdjJL1eQTKQg2fYxF2SPiPpi2a2I+bhIWfM7EJ3P1bSuyW9STO/7pGkMUnflvQeM7snzvFNZWY3VxMfPFPBuuePbKKZeyT9r6QvmNm6OnXqzalSAvMqWkfSg4SY2UXufoKkcxUccBOJDgqKTn5QmPTvc0K6mbxNrXYm+qtI+j8zu2CGLwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiwMKStL2pbSOFCDuxcVLJIV5uIUhgIAqTrq8T/u+IWggU5VXZT6t9WH3L1L0oOrj8MkHa5gAeKlCpIhDEqaI2m3pO0Krj+3Slor6YqJh5ntSvN1TFVdzL4ryzHMlJndLelMd3+3gkXMnynpJIW/jm0Kri9/Ium79ZIdmNnFmgWL9jfLzEqS/lR9JNlP7j8DM7tXwUL175L0ZAVJUU6QdIiC88CAggV+dyhY+PY6SX+T9FMz+0dE2++X9P6Exn1qEu020O/tyvDYqiY/OFvS2e6+r6THKFiTdZX2fGZzFSzCP6Tgc9shaYOC8/ZaBZ/hH8xse0Jj/Iek17v7v2hPkp2TJC1TkFhkoYJ9aqekTZJuqo7rEkkXR80nZuaSPImxR/Q7IunC6iNTZjYu6XuSvufu/Qre34crSOJysKQDFLzPcxQkY9ilPfvCNkm3a8/+sFbStWkmLKomVPiWu/+fpKdJeomC5A3LQjYrS7pB0vmSvmdml4W0f2p8o20/WV4DmNkrJb0y5T53KzgnflrB+fCJCo6HwyTtq+CcWFGw/2+SdL2kKyX9QtJfwxJ8JPleJjlHRvSb+r6R1Gtt5vOpJrf4d3f/sKQXS3q2pFMlzQ/ZrCTprwqSvH3NzO5rZrzNqO6fP5X0U3c/TMGculrBvL+k+pi4V9uhIMnBjZKuUpDE5qqoJDZmdmJiLwCJIOlBgszsLnc/RdJ/SnqHgvd7cnKCRk46UXUmH5S1kiBIwYH8hgb6AiDJ3d8vybIeBwCg/bj7YkkrG6g6X0HgNcyG6r95rScFGcz7G6i3QcEXghPmLxodPmRwbHS/0WLXAxkEu1TeVqxUdjfQniRprFCcM1YsLhgudt+5u6f3GklaNDp8yMrC1v0G+oemZSYcqXT3D6tnr6ztY5ViX29lfOnC4lB/QZW9AprFQmV4uNKzcaf6S41uU+iqbBkq92zeXenf616rMKZ5fRpbPtAzqka2GasU+wrjhYWDGp43dZtioTJcKFa27ir37qq1zQIN9fT1jO71xWAzr6VYqAxXVLhnXF1bp76XktSnsW2DcxcvWLC0/u8Zjo50a3ioL3idpYqK47VjCmNj3RoZCZIAF8tldZXrJ8UeL3dr5+b5z7v6U69ZNad7uGYGypIKo2PjPb2SVChWRvuKYzWzKTdar6drfFup1KXd430L0q7XWxjfLUmjle4tY+WenbvH+wbnlA561FGD4ckzR0e6NbKzt+Z7Pvn9njA+3qXKji71jZam1ZekUpdUUreG7hx841X/+canSzPfr8O2aXa/Hi107d5Z7hstq2tk8jZZHNdHF/oG79Kimu+fJI0VinXLWjH5OJvqzltXHvbjbz3w/Vcjc4/U+Lm9kXoLFHyBN7Veyd2nnjzi7Ffae+45rIH6Dan1fpd2dKm8pUddlT3nruE7B9/6s12v3ChNn3/yco6vtU0ejutCsbJ1vFLcVK50DWuKibln0Zzw76QnPqewuUfacz4Mm3t6esZVrnRpZLRHO++b88bbf/HyrTXrNTEHjFZ6tnUXSqo1n8VdT9oz70XVm5h/Js892tW934ry/JP31WjN90kKn3uk6fPP+HiXSjt71DtSVpemzz8VSWOFbqko7bp33n9cN/zGLVy7TX8tvYu0rKGze4xyPvdI2d5LPXCCOujwOQdE1G9Irfd7bLRL5a3d6hnac7yFzT1SPs7xebp2m7pNuVK4t9bcIwXzz6JC72GDtQqr4rz3mTz3bLl3wauu/+lr1rV6bs+6nhR9zzX13qeys2d5rw44+ZD97621yQNGd3VpbGfQ7OhojyqT3vqxsW6NjnarUAjeV0kq7+5SYUdXzbmnu6uk8a6iRks9e809XLvt/VqOLvQNblHYEZGMevPP1m1LD/iB+zGTnprNcbfE7n3GRrs0vr1X3bsrD9z79NxefPnPPvjKh0vE3Yi7NV+PuBtxN+JubVmPuFt1v35IYXSetPeFZbGgkZFK98Zv/ecb9/rjhTwc18TdkqknEXfr1Gs34m41EXcj7kbcLWf1pHTiblPVuvch7kbcrYq4WwTibsTdiLvV12lxt3rHQp6u3Yi75a4ecbc2unabuk1Y3K2nUN7rd+MHC8NbBiujlx71nvNvnVofAAAA6BD7hpRtNLP6gRSk4fkKv++8Ms2FsAAAAGaquvj7ldUHMlBddP5Dkj7k7gMKFjE9UMF3O10KFjDdKulmM7srq3Gis1UXdP9p9YE2UD13fLf6yJ1qUoWfVR9IiJkNS/p99dFWqjGt86sPufv+CubAxQoWqh/RnkW815rZUEZDRRuoLuz+5+oDCFVNfvDl6kPufoCkIyQtUpD0bVzB+ecOSTdWz7WZqiYV+oek/y/rsSBbJD1IWDW71LvdfY2kz0l6rIK/HayXrGCq0EwjdbadnFjhTklPr5fhEAAAAK1z99WSzpF0dNZjybtlw7t0yK5tumH+Et01Nyxh4MzbfUT5ds05dKM0d3yvsnVDi3T5hiO1fWzvPww+snivTlp+k7rmTk/e2tI2pT3bhI0rrW2aeS0zUa6ReH3D/Yt0zWVHase2QS3r36wTlt6kBb3T81lMHtueetOTGNeo98oG6zXaXs16k+v2d42mWq/Wdmvv2k87ywMqzhlVvT8C3XD/It1z1XI9aOAuLZ3Sdti+8JBltwT7wpS/U6yxzVPbdb9O+rjeNjpXd22f/keg6/rm6LY583VYZcO0slZMPs5C/DjWTtvU4pHdajVNd633O3S/Xrrln9YNTt/n8nos5OG4npFdtUOaE5/TwMho3bln8tgaOWdftuFBD9Q7cM7mN2tOa+3FOU8lMe9N3e6OO5dp2bZR3TB/iXZ1D2hf3T2tXtjcM7X/CXv2hfWN7tcv5tqt9mvZ3j0wrU9J2tzTp5EFLRxnNTD3zMzIfbU/m0bVe7/3unabLKW5p5lt8njtNmO7uqXbFk97Ool7n8s2PGhyvXcsWJqfuSLpuUeStty/RNvvWqDr5+0jzRnTIaq9+Nr22wY1cE9J87uHJAW/+zM8Pq6KCtowvFDXbDpUO8fnPlC/4f16zz734rweC1kf19tG52rL+lXT2+ibo7uX9gS/GhGjBuafc+LtsX2lfe+zYvmWF+f5HJ/XOW4miLslU6/WdsTdGnstxN32wr2PiLsNj/eoMunXtva6Dq0kM65mt2kYcbdE6tXajrhb+tsQd+scxN1q1M/RtduMEXdLpF4trcTdavU/gbgbcbfZgLhb+tsQdyPuVut1T0bcjbhbp5vtcbe6feTo2i0ON3zp8WOFcvf3NRjzhR4AAACQvemBzj1I/pUhd1+pYM2bMN9OYywAAADoDNUFna8USSgAALOMmd0t1fgjAABIWDWxGMnF0BZIepASM7tO0uPc/YWS3i3podWiqAQIYQkRppraztWSnmNmd8xwuAAAAGhQNeHBhVmPox0sG96lY7dv0oXLDoy93ceP3aLK8Runla0bWqSL7z1h2vNHFu/VQw+5oWZ7cW0TNq60tmnmtbRqw/2L9KffBn0u69+s1ftdUbPe5LHlsd7kumnXq7Xdlbc/SFt7B6Quab5Ga9bbcP8i3fLHg2u2Pdv367Re/7Q2+ubo2vlL9PixW7T94BHp7tYWYZkw+ThDuGXDu3Twru26Ydm8ptuo9X530rGQh9cSh4nPKa/n9naY96Zud/2tq/a6dhusTF/QIWzumdr/hHY9x+f1uN46MlfLtXWv5zb39GnR3O3aeuSQtHlJze1mirlnZhaODmnXgt6mt6/3fs+W/Tqra7eZ6pR7n7zMPVKw8Nr4bYt16bL9JEnz6yzlsf22QS1bt7Pmt5wbhhfqz+sevNdz+3TQsZCH43rT8PQkluv65ujuFd06dL87dP+t0xcqbBbzT+OyuPfJ8zk+r8d1qzpl7plcl7jbHu26XxN3m72Iu015LTWuQ/PwWuJA3I24W6vb5OFYIO7WOYi7hddv5rU0sw1xt3zXqyWOuFunHwt5eC1Rcbd7ibtlgrhb+tsQd2u+3uS6xN32aNf9mrjb7EXcLf1xNbtNqwpzxnskvTSRxgEAAICMuHuPpBNDqiQT4EEkd++V9C1JS0OqjUhak86IAAAAAAAAAABAJytmPYDZxsy+b2YPk/QMSRdIKitIUDCR3KBS41FPrXqFapufkfQoEh4AAAAk7pysB9AuTtyyTpctWp5Iu5UjttYsu3zDkTWff8iyW+q2F9c2YeNKa5tmXkurrrlsT58nLL2pbr3JY8tjvcl1065Xa7vxQldkvWsuO7Ju27N9v07r9U912aLlM96mEZOPM4Q7ccs6XTe/tYWHar3fnXQs5OG1xGHic8rrub0d5r2p2zVy7RY290ztf0K7nuPzelz/Y/t+057rqZSZezLWyLVbmHrv92zZr7O6dpupTrn3ycvcI0m9/xhsKG4wcE+pbtk1mw6d9txx2zZ0zLGQh+P6+i0HT3vuskXLE4k1MP80Lot7nzyf4/N6XLeqU+aeyXWJu+3Rrvs1cbfZi7jb3mpdh+bhtcSBuFtr9WptR9wt/W2Iu3UO4m7h9aV8HNet6pR7n7zMPVI8cbdOPxby8FqIu+UTcbf0tyHu1ny9yXWJu+3Rrvs1cbfZi7hb+uNqdhsAAAAANT1V0mBI+V/SGkg7cvfvuXvsWQPdfZmkCyWtjqj6DTO7L+7+AQAAAAAAAADA7NOd9QBmKzP7haRfuPtySadJepGkkyT1TKkalfhA2pMwYUzSdyV9xMyui3G4AAAAqMHdl0g6OutxtIPeUkn95XFt7+mLvd35GlJl7vi0spFSt7aPTf8ducHKsLrmjtVsL65twsaV1jbNvJZWjY50a8e2oM/e4pgW9O6qWW/y2PJYb3LdtOvV2m5oeEBjPeF/BDo60q2RHX1asM/0tmf7fp3W6x8t7f0ZjRSLGi5279lma83NZmzycYZwE3PPrp5ezdNoU23Uer876VjIw2uJw8TnlNdzezvMe1O3Gx4eiLx2C5t7pvY/oV3P8Xk+rodK/Xs/VyhoUMNBH6PxXHsz98xMT6mknTHPPdLs2q/TOK5b1Sn3PnmZeyRpZLhHvaVyZNxgbFeX5nUP1SwbLXdr5/jcvZ7rKZU0T8NSBxwLeTmud43P0fyukT3PFYsqd1eC1zLaW7OfZjD/NC6Le588n+Pzely3qlPmnsl1ibvt0a77NXG32Yu42/Rtpl6H5uG1xIG4G3G3VrfJw7FA3K1zEHcLr9/Ma2lmG+Ju+a5Xc9sY4m6dfizk5bUQd8sf4m7pb0Pcrfl6k+sSd9ujXfdr4m6zF3G39MfV7DYAAAAApnP3OZI8otpv0xhLG3uhpBe6+68kfUrSb82s6RsTdy9Iel61rQMjqu+S9MFm+wIAAAAAAAAAAJiMpAcZM7N1kj4t6dPuPiDpZEmPVrB47hGSDpM0v87mI5Juk/RXSRdJ+rGZbU16zECnM7P3S3r/TLdz9+vEwtcAMNusyHoA7aK/PK7hYvy3H/3lcam3XLNsuFT7D7bnF3fXbS+ubcLGldY2zbyWVg0P7emzf9IfYk+rV8p3vcl1065Xa7veckljXeF/BDo81Fe37dm+X6f1+kfKey8yMFzsjtymGZOPM4SLY+6p9X530rGQh9cSh4nPKa/n9naY96Zu18jxEzb3TO3/gXG06Tm+nY7r0WKXenub+8P3uv0w98xII9duYeq937N5v25mm7TmHimf5/a816tldLhfauDabXRnr6Tai68Nl6Yv/NVXHpd6OuNYyOtxPVzsTiTWwPzTuCzuffJ8js/rcd2qTpl7Jtcl7rZHu+7XxN1mL+Jue5u6jyYxrma3aRVxt9bq1dqOuFv62xB36xzE3cLrS/k4rlvVKfc+eZl7pLjibp19LOT1tRB3yx5xt/S3Ie7WfL3JdYm77dGu+zVxt9mLuFv642p2GwAAAAB7c/fjJX1B0kNDql1lZrekM6K295TqY4O7/0DSeZL+ambbGtnY3Q+U9CRJb1fja1+838zubGawAAAAAAAAAAAAU5H0IEfMbEhBdvK9MpS7e7+kQUlzJQ1IGpW0w8w2pD5IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALOCuz9D0koF69QskHSApEdJOqGBzT+f4NA61VJJb6g+Ku5+i6TLJd0raYukrZLKkhZXH8sVfB4Hz7Cf8yV9IpYRAwAAAAAAAAAAiKQHbcHMhiUNS9qY9VgAAAAAYLJCpazKYEGFncWshzJrDJf6pN6ytK1bOrjMe58TfcUxDQ/1SQNlVVSYVt7bP6zCzrkZjAySgs8GnaO3rMJQUTUONSRouwZU2FlUeQFzT54MD/WpMlg9Jqbo7xrRjpE5GYwKEnNPx+mtnvsGylmPZFYZLvUF95w9wb0n8mP7eHBdUBnc+3Pp7xrRcLGba4UMMf90FuJu6SPulk/E3fKNuafDEHfLBHG3fCLull/MPR2GuFsmiLvlV1jcbaTYrcJurhWywvzTWYi7pY+4Wz4Rd8s35h5gmvuyHgAAAAAkSf8q6XFNbHerpK/GPJbZpiDpiOojTn+X9HIzq8TcLgAAAAAAAAAAmMVm5W+KuvtR7s6fZwIAAABAiwqFigq7C8GiH1u6sh7OrDBa7tG2yoAKZak8pywVee/zoLdrXGOjPdo+MkeF4YLKi8b3Ku/rH9POUp8KG8g/mYWx0R5t38of4XaMnrLUVValv8IxlaKdhX6VC1JhpCh1M/fkRTD3DKgyr6zywilzT9e4ugrjqmzsyWh0sxtzT4fpqV537+zi/Jei0XKPto/NUWF7lypzKips4r3Pi12lfo0PKFiYddK9T1/XuPr7h4LF2bhOywTzT2ch7pY+4m75RNwt35h7Ogxxt0wQd8sn4m75xdzTYYi7ZYK4W36Fxd36+oa1Y7xfhU1cp2WB+aezEHdLH3G3fCLulm/MPcBerjvq9Es2Zz0IAAAANK0s6XVmNpr1QDDN7yU9wcy2ZT0QAAAAAAAAAADQWWZl0gNJ10va4e5/cvdz3P017v5Qd+ev0AAAAABghrpvKWj0SVvV86d5WQ9l1vj7hlWqHLFVhTvmq3IE732eXP23VdJIQWOP2jGtbOzwHeq9YGH6g4Kk6meDjlE5YqsqvWWOqZRduXgf9V6wUGOPZ+7Jk6v/tkqjTwqOiaketvRGXf+XwzMYFSTmnk5TOWJrMO+MkFM7TX/fsErdtxQ0fnBw74n8uHJp9bpgyr3Pw5beqMsWLec6LUPMP52FuFv6iLvlF3G3/GLu6SzE3bJB3C2fiLvlF3NPZyHulg3ibvlVL+523JJbdNWCpeq9ZH5GIwPzT2ch7pY+4m75Rdwtv5h7gAe8JesBAAAAoCVvNbMLsx4E9lKS9BFJjyfhAQAAAAAAAAAASMJsTXogSXMkPULSGyV9SdJlChIhXO7uX3b3N7v7ye4+J9NRAgAAAEDOdVXG1XV/WaUjh7IeyqyxYXiRLtx9rHb3FFQe75EW78p6SKjatH6Rfn/NQzRS6Z5WtnD5Zm2bW1bp3OUqbJhejmRtWr9If7jgBG3fOjfroSAOi0ZVWLlNKpXVfRELe6TlpuJyXVlaocL1c1U+aHfWw0HVpvWLdMlNx2rbI0ZVWj62V9myga06YM59uuWXh6m8kZy/aWPu6TCLRlVYtF09fxxU8S6Op7RsGF6k3939EI1dN1elfcvqvnU2f7WZL7cMLdfl/StUuHFgr+eXDWzVMYeu1V/H9tPYuSu498kA809nIe6WPuJu+UXcLb+YezoMcbdMEHfLJ+Ju+cXc02GIu2WCuFt+1Yu77dO/TasOukVXjK/U+E+WqbCJe5+0Mf90FuJu6SPull/E3fKLuQfQdZJWH3X6JRdnPRAAAAA0Zbukl5jZ57IeSBv5oaSkA1a/knS8mb3bzMYT7gsAAAAAAAAAAMxSs/k3DiuSClOe65V0vKTjJL1yop673yzpcklXTPxrZlvSGSYAAAAA5F9XZVzdQyNZD2NW2TC8SD8bPlG9xTENVEZm9x1+zmxav0h/WL9I8zX9mFi4fLMkaeS6Ho2VBqW+8ozaHh/tj2WMs9Wm9Yt00fmPVE/vmPoHos9ZpRKLe+TaolEVFm1W165BiXXAUnNTcbluGlmugdtH1NM7Fr0BUrFp/SL9av2JWlzYpSfr1r3Klg1s1bKBrRq5sVsj181Voasyo7aZe1rD3NNhFo2quGhUPesHsx7JrLJheJF+dtsj1XvHmFb0b9KjVl6X9ZBQdcvQct2i5dq3sHmv55cNbNWyVVs1UurWyNX9wRey3PukivmnsxB3Sx9xt/wi7pZfzD0dhrhbJoi75RNxt/xi7ukwxN0yQdwtv+rF3fbp36Z9DtumkVK3Rm/oU0F9KvSVVOxqPGEI809rmH86C3G39BF3yy/ibvnF3IM29V1JE397u1PS8KSybdo76rilWkeSNihYGFeS7jvq9Ev2viAGAABAu9gl6WuS/tPM1mU8lrZiZs9397mSninp2ZIeLemgGJq+S9KPJH3RzPgyAAAAAAAAAAAAJG62/4porb8yK2jvZAgFSaskHSnptIkn3f0uTU+EcG9yQwUAAAAAYLrRco9G1aP5D/zND9pBX/+Y+jTzRYvK5an5G9GMsdEejY02vvADcq5nZgtJIR5DhT71NHEeQ7LGS/VD/n1d4+rrGp9xm8w98WDu6TDMPZkYLfdo6xgL37WTvq5x9c1t7l6V+ScezD9Aa4i7tSfibtli7ukw3PtkgrhbPhF3yy/mng7D3JMJ4m7tp69rXH1zgrmnoIr6uxu/dmD+iQfzD9Aa4m7tibhbtph70GY+cNTpl7CQKgAAQOcrKUhwtVHSHZKulPQ7Sb82M276m2RmuySdW33I3VdKepSkB0k6WNIhkvaXNChprqQ5CtYNGlGQYGyDgiQHtyhYB+cvZnZNqi8CAAAASJG7v0TSvKzH0aDfmdnNWQ8CAND+3P0ISY/LehwN2mFm52Y9CABA+mZ70oOpvzlZUe1ECLXqHijpAEnPmXjC3TdoUhIESZeb2a3xDBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0mNmp2Y9htnGzO6TdF7W4wAAAABy7KOSDsp6EA16lSSSHgAA4vBoSf+b9SAadIeqCT4BALPLbE96MJHgoDDl31p1aiVDmFp/maQnVx+SJHffriAr+eRkCDeYWbm5IQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkA+zOenBRMKCisITGtRKhNDIdhMWSDql+pgw7O7XaO9ECFeb2WgD4wYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBdma9KDMySdUH0cL2n+lPJGEhrUSobQaCKEAUkPl3TSpOdK7n6D9iRBuFzSlWa2s/ZLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW7My6YGZrZG0ZuJndz9ce5IgnCDpoZKWTNksiUQIk+t3S3qwpGMVJGWQpIq7/0N7kiBcIelyM9tU84UBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCiWZn0YCozu0XSLZK+O/Gcux+ovZMgnCBp5ZRN6yU0kPYkNGglEUJB0hGSDpf0oklju0d7kiBMJEK4u844AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIBEkP6jCzOyXdKelHE8+5+zJJD9OeZAgnSDpoyqb1kiBMNpNECLXq7y9pP0nPmjS2TZqUBEHSFWZ2cwNjAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyD0zOzjrMQAAkDYz+5qkr2U8DAAAQpH0YAbMbL2kX1QfkiR3X6S9kyCcIOlw7UlgUCvBQS31EiFM/jes/j6Snlh9TIxtp6SrVE2CUP33ejMrNTgmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADqIulBi8xsi6TfVh9y9xWSPi7p5ZqerKBW8oJ6CqqfMKFSp62p9edJenT1MeEvkk6ewTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKiJpAcxcvd/kvTfkuYoSEpQ0PTkBPUSGUxWK6lBoc7/w7apVZfPHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCxbAj4G7d0taI+lF2jvJwEQSgonnhiVdKekqSZslbZU0KmmupAWSDpR0sKQHK0icMLmdyQkNaiU9mEkiBAAAAMTj/qwH0C6Gi93qL48n0q5GizXL+rtGaj6/vTyn5vNxbhM2rrS2aea1tGpyn8OlvratN7lu2vVqbTda7Gqobr22Z/t+nefX34x6rwfTZTH3SO11LOThtcQhq3P2TOtF1c1y3pu6XaPHT6P9P1B/Fp3j83pcN4O5Z2YavXabqdm8XzezTVpzj5TPc3ve69XS2z+sYstzz+i050aK3dJYZxwL7XpcN4v5p3HE3dLfhrhb8/Um1yXuNqn9Nt2v8/z6m8Hc0zjibnvrK06/Ds3Da4lD1vE04m7R/T9Qfxad4/N6T9YM5p6ZIe4WXl/Kx3Hdqryf2/Ner5Z44m6dfSy062tpFvNP44i7pb8Ncbfm602uS9xtUvttul/n+fU3g7mnccTd0h9Xs9sg0n1ZDwAAAAAAAAAAAAAAAABAdvjtqxa5e4+kH2lPwoPKpMfEzz+X9GxJ883sZDN7o5m9x8w+bmafNrP/MrN/M7OXmtmjJM2TdIykt0j6saTd1bYmEhs0msxg8jaT/w8AAIAYmNkmSddnPY52MNrVpeFit+aPxfvHS6NdXdquAWnX9HxufV3jmt+zc9rzOwv9Ku3qqdleXNuEjSutbZp5La2a3OdouUfbRue2Zb3JddOuV2u7gf4hDY5NXzRpqnptz/b9Os+vvxn1Xg+my2LukdrrWMjDa4lDVufsmdaT8jvvTd2uv3+ooeOn0f4fqD+LzvF5Pa6bwdwzM2NdXQ1du83UbN6vm9kmrblHyue5Pe/1am7bP6bRrmJLc09vcVyD3bv2em6sq0s71N8Rx0K7HtfNYv5pHHG39Lch7tZ8vcl1ibtNar9N9+s8v/5mMPc0jrjb9G2mXofm4bXEIet4GnE34m5xbJPnWANzz8wQdwuv38xraWYb4m75rldz2xjibp1+LLTra2kW80/jiLulvw1xt+brTa5L3G1S+226X+f59TeDuadxxN3SH1ez2yDUdUedfsnmrAcBAAAAAAAAAAAAAAAAIDskPWjdJyQ9vfr/yYkICpJukfQ4M3ummf3MzMYbadDMKmZ2g5l9zsyeJ2mZpJdK+uWktqf2N9Xk5AsAAABIzpuzHkC7uGzRcp24ZV0i7RZuXliz7GFLb6z5/NXrD6/bXlzbhI0rrW2aeS2tmtzn3zesatt6k+umXa/Wdt2VUkN167U92/frPL/+ZtR7PZgui7lHaq9jIQ+vJQ5ZnbNnWi+qbpbz3tTtGj1+Gu1/wmw6x+f1uG4Gc8/MNHrtNlOzeb9uZpu05h4pn+f2vNerZezwHS3PPQ9Z8o9pz121YGnHHAvtelw3i/mnccTd0t+GuFvz9SbXJe62R7vu13l+/c1g7mkccbe91boOzcNriUPW8TTibtH9T5hN5/i83pM1g7lnZoi7hdeX8nFctyrv5/a816sljrhbpx8L7fpamsX80zjibulvQ9yt+XqT6xJ326Nd9+s8v/5mMPc0jrhb+uNqdhvU9ZasBwAAAAAAAAAAAAAAAAAgW4VKhTXxm+XuT5N0vqYnO5CkP0p6qpntirnPIyS9U9KZkron9V2ou9He4/u7mT08zjEBCLj7dZKOrlF0vZkdk/Z4gKncfZmCuWOqcTNbn/Z4gE7i7qdKOkcS5/sIy4Z36eBd23Tj/CXa1tMXa7sPL9+uuYdulObunWts/dBC/X3DKm0fG9zr+SOL9+ohy25R19yxae3FtU3YuNLappnX0qp7tu+z+dKNx2wfr3QfvLR/ix629EYt6J1+azR5bHmsN7luX9dYqvVqbXf9XYdrV3lAO3t6Q+vWe02zfb/O8+tvRr3Xg+mymHuk9joW8vBaWlXZ3T128/qDvnRF6eBTl/ZvOSaP5/Z2mPembnfbnQdp2bbRyOOn0f4nzKZzfF6P62Yw98zMwtEhjRe6Iq/dZmo279dJvP5W3bdjyf1/2nDscLvf++Rl7pGkresWa9udy3TDvH1mPPcMj/eoooI2Di/Q1ZsO087xuQ+UddKx0K6vpVnMP40j7pb+NsTdiLtN7Xu27td5fv3NYO5p3GyPu01cf07I63Voq4i7EXfL6zk+r/dkzWDumRnibuH1m3ktSbz+VhF3y1fcrVb/EzrpWMj7azlyyR0qzpneR0EV9XfPPAbB/NM44m7pb0Pcjbjb1L5n636d59ffDOaexs32uFsW42p2m1ZUdnePFUaLX9LC0VOVw79BmBr/nBBy/XmdpLccdfolFyc8NAAAAAAAAAAAAAAAAAA5R9KDJrl7UdLVChY4n5x4oCLpekmPMrOdCfZ/pKRPSnq6piddqEj6hqTbJZ0k6URJy6rll5H0AEgGSQ+QdyQ9AJLn7oslrWyg6nxJSyPqbKj+m9d6kjQsqb+BehskbZ/08/xFo8OHDI6N7jda7Fow8WSXytuKlcruBtqTJI0VinPGisUFw8XuO3f39F4jSYtGhw9ZWdi630D/0IKp9Ucq3f3D6tnrr2TGKsW+3sr40oXFof6CKnv9BUaxUBkervRs3Kn+UqPbFLoqW4bKPZt3V/r3Ot8WxjSvT2PLB3pG1cg2Y5ViX2G8sHBQw/OmblMsVIYLxcrWXeXeXbW2WaChnr6e0a5WX0uxUBmuqHDPuLq2Tn0vJalPY9t6CuW9Pq++OUO3LFq6+W9HnX7JZmnvY2K/ORvm7zOwteZ+tXu8b3BovG+RJA10jcyZ0z087fOTpJIKo2PjPb2jlZ5t3YWSoupJUqFYGe0rjtX8q8lG6/V0jW8rlbq0e7xvQdr1egvjuyVptNK9Zazcs3P3eN/g6M6+w4ujxX0n6nWpvLNLlWFJGh3v2TZW6tk9VijO6eobXT63d2jaXwiOVbr6xipdc4qFyu5SV2GTurWuVClobmn0oAWVoZqf0Vi5e/twpW+v/Wem+3XYNs3u16OFrt07y32jZXWNTN6mXY/r8UpxU7nSNawpah1vg4XhLYOV0UvPHX/4VsU390iNn9sbqbdA0liNeiVJ2xLsV5o+92jZ8K79+kql4+KYe7oqlW1jxa6rt/b2371seNd++3TtOK7W3CNNn3/yco6vtU0ejutmj4Wj3nP+rRPPTcw/YXOPtGf+CZt7kpwDwuazuOtJjc+jE/PP5LlHu7r36xrR8pFJ+/LE/NPI3CPtmX9KXYUNxZ7KHaVKQd0jWr6gPLykr2dkztT6ZRXHh0q9HXOOz+txXa4U7q11vEnTj7nBwvCWwXk7bru6vP+6G7YeMlBrmymymHukbO+ltk95bv68sZFj54yPHzTxRCtzz+6unnt29fTeJkkHFDYdu6y4/aBa29S698nDOT7P127NHAtaNHpjEvc+SZzbs64nRd9zTb33qezsWT66u3dVrblH2nPv0903uqSnb2TfYNuufqlQnKg/Xin2jle6BoqF8u7unvLaSndlY/ewlswpjR1Sa+7pLpR3j5R6au7X7XiOz+tx3Wys4dx/PEEi7lavTeJubXjtRtwtQNyNuBtxt7asR9ytul8PFEbnKYh1TtpGIyOV7o1jhe69VmnMw3FN3C2ZehJxt6zP8Xm9JyPuFns94m5teu1G3C3ZelI6cbepJt/7qFu3E3dL57jeXe5e0KPSPvMLw30FVR5YcbcgVQaKY9uJuzVUTyLu1vHXbsTdAsTdso+71TsW8nztRtwt83qJx90m7n2WDe+al+e4W7tdu8URd1u75pR6f4NQ7zgYlLSoxvOTr8cnPt/+av2Jv3MdlNQ3qe5uSSOaYsfoQKlU6RqTpLIKOyqVwlC1aPOS/u33au999r6JuRQAAAAAAAAAAAAAAAAASHrQJHd/rqTzFCQYKEz5d7WZXZLSOE6T9FlJCyc9XZBUlvQ+M/twtd6BChIg7GNmX0xjbMBsQ9ID5B1JDwAAAJAmrj8BAACQJq4/AQAAkCauPwEAAJAmrj8BAACQJq4/AQAAAAAAAAAAAAAAADSr1i8eoTGvmPT/yQkPfptWwgNJMrPvuPulkr4v6YTqGCqSipI+6O49ZvYBM7tT0p1pjQsAkHsLJS2r/r/k7kvr1JsvqV7ZZMOS+mOst6H6b1TfWdbbHlFHku4zs80N1EMbeVH5l4slrWygaiPHT6P7nBT/cZZVvYaPn+8Vn8rx02HcPYvjJ+/1pASOH+afzhLz3COldO0258yjFxTGy10TP3cNjW+SpPF5vQtfVP7ltpm212I95p5ZKqO5R8r/NRlzDyJldO+T93oS9z6IEPPcIxF3q4e5pwMRd2u5HnPPLEbcrS7ufRCqXeNuOavH3DNLtcG9T97rMffMYsTd6uLeB6HaYO7J+3HG3DOLtcG9T97rMffMYsTd6uLeB6HaYO7J+3HG3AMAAAAAAAAAAAAAAAAAaFuFSqWS9RjajrsXJG2VNDjp6YmkB/9sZp/NYExzJP1Y0hOq45g8preY2efTHhMw27j7dZKOrlF0vZkdk/Z4gKncfZmkUyR9SNKRGQ9nNrle0pvN7OKsB4LWvKj8y9WSzlHtcz2Scb2kN3+v+NSLsx4IWuPuHD/pY/7pAO0+93TtGlOhPD3uVCkWVJrbk8GIGsLc0yGYezLB3NMh2n3+aVPMPx2AuScTe8091fhnrYTv42a2Ps2BYWaYezLB3NMhmH8ywb1PB2DuyUTHzT2z9fqTuScTzD0dgvknEx03/8xGzD2ZYO7JoWauP5l7MsHc0yGYfzLB/NMBmHsywdyDRMzW+CcAAAAAAAAAAAAAAACA1hWzHkCbWiVpXvX/hSlll6Q8FkmSme2W9ExJf9GeMVWq//+Uu5+UxbgAALnyaEnfEwkP0na0pIvc/dSMx4EWVP8I50LxRzhpO1rSRS8q//LUrAeC5lX/AJTjJ33MP22OuSczzD0dgLknM8w9HYD5JzPMP22OuSczzD0dgLknM8w9HYD5JzPMP22OuSczzD0dgLknM8w9HYD5JzPMP22OuSczzD0dgLknM8w9HYD5JzPMP22OuSczzD0AAAAAAAAAAAAAAAAAgFwh6UFzDg4puy+tQUxlZiOSniNp3aSnK5J6Jf2fu/dlMjAAQF58OOsBzHLnZD0AtITPL1u8/+2Nzy9bvP/ti88uW7z/7Y3PL1u8/+2Nzy9bvP/ti88uW7z/7Y3PL1u8/+2Nzy9bvP/ti88uW7z/7Y3PL1u8/+2Nzy9bvP/ti88uW7z/7Y3PL1u8/+2Nzy9bvP/ti88uW7z/AAAAAAAAAAAAAAAAAIBcIOlBcxaFlG1ObRQ1mNl6SW+WVJhSdIikf01/RACAPHD3JZJWZT2OWe4Yd1+c9SAwcy8q/3KJpKOzHscsd8yLyr/k+GlD1fmH4ydbzD9tiLknF5h72hRzTy4w97Qp5p9cYP5pQ8w9ucDc06aYe3KBuadNMf/kAvNPG2LuyQXmnjbF3JMLzD1tivknF5h/2hBzTy4w97Qp5p5cYO5pU8w/ucD804aYe3KBuQcAAAAAAAAAAAAAAAAAkAskPWhOV0jZvNRGUYeZnSfpz9qT+KBS/f+/uXtYwgYAQOdakfUAIElamfUA0BSOn3zg+GlPHD/5wPHTfjh28oFjpz1x/OQDx0974vjJB46f9sOxkw8cO+2J4ycfOH7aE8dPPnD8tB+OnXzg2GlPHD/5wPHTnjh+8oHjp/1w7OQDx0574vjJB46f9sTxkw8cP+2HYycfOHYAAAAAAAAAAAAAAAAAAJkj6UFzdoSU7ZvaKML9d43n5kh6TdoDAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0JpIeNOf+kLLj0xpEhPMlbZ/0c0VSQdI/ZTMcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECnIelBc9aGlD0ltVGEMLNRSX9UkOhgskPd/agMhgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6DAkPWiCmW2T9I/qj5VJ/xYkPcvd+zMZ2HRX1Xk+F4kZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADtjaQHzfu1giQHmvSvJC2U9LrUR1Pb+jrPPzTVUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOhJJD5r3gxrPVRQkQPh3d1+Y7nBqGq7xXEHS0WkPBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQeUh60CQzu1DSrdUfJ5IdTFgm6ey0x1TD0ik/V6r/7pf2QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnYekB605W3snOyhoTwKEV7j7P2cxqEkOqPP8vFRHAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADoSCQ9aM0XJd1Z/X9l0vMTiQ8+6e6vS31UezxJe49rwkDaAwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdB6SHrTAzMYkvVVBgoMJheqjouD9/YK7f9jdU32v3f2Rkg6aNKbJhtIcCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgM3VnPYB2Z2Y/dfdvSXq5gkQHEwkGCpN+fqekx7j7a83sxpSG9t8hZetTGgMAANjbfHc/Zib1JS2tU7ZB0vY22iav45pmvzkb5u9f2XLIvPLo4XMXDC0747AVS7/xxBdGbYYYLNq8Vfuvv0+Ld23Roh3bVSiPqTJcVm95XPts3vyNP45/bnejbVUKGqkUCzvKleI9o11dd4yMd90zrzR82/I5W2486vRLNif5OgCgGTd+4BmHlheVH1laVDr8jGUHHsPck46BkSHtu/E+Ld+6QQt2btPc0WFppKTicHnGc48kVbq0vVwprh/rKt4+NN5zM3MPgDxbu+aUxaVKz4ka7jlOpeLy0w468LDvPOW5WQ+r4w2MDGmfTZu1bPNGLdm5WXOGR1q+9ymXi+tLleK9I6Xem4ZL3feXK8Vrn//Wb9ya5OsAgGasXXPKYm3sX1UZ7Tm2PL+y6oxD9z2Ae590EHcDMJsRd8sGcTcAsxlxt2wQdwMwmxF3yw5xNwCzGXG3bBB3AwAAAAAAAAAAAAAAAADkHUkP4vF6SQ+uPiYnPtCknx8t6Up3/4Skj5lZ5IK7zXL3d0s6ucZYJhIx3JRU3wAAINSfsh4A6lvWv1kP771Vc7Z1qTy/ovFH7dD60jxddev+kdvOvX2bFl96v+46bVUu60nSwD07NLTfvNTrNeLkP1+hJ/75Lyrst1vFu/t179Hduvv2ffSggbu0oHdXUKlbJ7R099K157/XfGP17T3F0quOOv2Si1sZNwDE4UZ71lmlOcWPjj98pKeypKT1I/MbmnvQmkPW3a4X/ul89S/eoa4NRY0fVNG2nQMauKeked1DQSXmHgAdau2aU1aXij3fLs8dWFG8s0/3Hd6tq28+TBtuq5c/DnE4ZN3tev4vLtD87btV6BtTZccc3XtMAvc+VX/7ylNG7hta8q5nv/nbZ7feGgC0Zu2aU1ZrU99XKlsWH1yeX9H4YxuPu6E1xN0AzGbE3bJB3A3AbEbcLRvE3QDMZo9ZcdXJi3cPf6Jyy+IDibuli7gbgNmMuFs2iLsBAAAAAAAAAAAAAAAAANpFMesBdAIzG5L0HEl3V5+qVP8taE+iAUnqk/RuSbe5+3+4+7K4x+Lu/ybpQ5qe8GCyP8fdLwAAQDtb1r9Zq+dcpzkbeqViUWPP3qL1pXn6029P0K6dc0K3nXv7Nh3yzbXq2zqSy3oTdff76W2p12vEyX++Qk/97d9UOHKnum4e1D2PKujmaw/QIxes3fMHoDHrKZYOlnTR2jWnnJpIBwDQoBvtWWeVu3o+OfboHT3lw0e1fmR+Q3MPWnPIutt15oXfVf/B29R1b1FjJ4xr2/YBLVu3c88fgMaMuQdAXqxdc8rqUqH7wtLyworua+bq3ocV9MfLjtOObYNZD62jHbLudr36+9/Xgo0jKnaNSRvm656Tk733mdc71Hfkgrs/9ZPPvuxtsTcOADOwds0pq7Wl98LKuvkHzzTuhtYQdwMwmxF3ywZxNwCzGXG3bBB3AzCbPWbFVScvHh7+njYMHkjcLV3E3QDMZsTdskHcDQAAAAAAAAAAAAAAAADQTkh6EBMzu0PSakn3VJ+qTCqeSHwwkYhgkSSTdIe7f8fdn+3uPa307+6HuvuvJf1XA9V/1kpfAAAAneaEpTepcPNCFUaLGn3SVknSNZcd2dC2K39xR67rZd13lCd//0qNPmmrei5cqNEnbdU1lx2pE5beFFv7Ec5JqyMAqGlz/4dHn7RV6gtCCI3OPWjNMy/7tcYPr6j7dmn88OC9H7inlFb3zD0AsnbO+OEV9V6w5/obyXvmZb9W4eaFqhy0XYWb0733WTmw6SOJdwIA4c5pNu6G1hB3AzCrEXfLBHE3ALMccbcMEHcDMJst7N35ocKt81UYI+6WNuJuAGY14m6ZIO4GAAAAAAAAAAAAAAAAAGgnJD2IkZndKulRkq7S3okOVP1Z2jv5QZ+kF0n6oaSN7v4jd3+Tuz+skSQI7r7U3V/g7j+VtFbSEyb1W5hUtTLp+avM7IrWXikAAEDn6C2OaUFhSCoVVRguqLJ0XKMj3dqxbTBy267dY+rfOJTbeln3HWXx5i3qHquo0leWxosamS+N7OjTgt5dsbTfgGPWrjllcVqdAcBkN37gmYerUuirDJZUWVRqeO5BawZGdmvp1k2qzC+psLugypKSxnZ1aV53PHNbA5h7AGRm7ZpTllQqhaMrcyoq7Ayuv5l7kjcwslvLNm5WpSgVdxelcrr3PvN6h/rO+58zDk28IwCoYe2aU5ZorHh0M3E3tIa4G4DZjLhbNoi7AZjNiLtlg7gbgNns0Hn3LCqO60iVibuljbgbgNmMuFs2iLsBAAAAAAAAAAAAAAAAANpNd9YD6DRmdo+7P0bStyU9W3snOZia+ECTnpsn6VnVhySNufudkm6XtFHSrmrdBZIWSjpS0v6Tup7c9uSEB1P9ZxMvCwAAoGP1d41Io0VVBsoPXB0PD/U1tG33zrFc18u67yjL1m9RZbCs4raiKoNlDQ/1BZ9HulZK2px2pwCgio6uDJaloaI0UGp47kFr5g3tUqVQVGGspEqhKKmk0Z29klL7I1CJuQdAdlZUCkUVdhYeuP5G8uYN7ZJGi9KC8eDeM4N7n2KhfKykW1PrEAD2WNFs3A2tIe4GYFYj7pYJ4m4AZjnibhkg7gZgNlvct32pxoqq9JelruBPEph/0kHcDcCsRtwtE8TdAAAAAAAAAAAAAAAAAADthqQHCTCz3ZKe6+5vl/QhSb3aO8lBreQH0t7JCnolHS7psDrdTE1sMDWJwuTnC9V/f2lmP2zwZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEKqY9QA6mZl9UtJJkq5W7UQHBdVOgjD5UajzmFpPqp8IQZLukPTK1l8VAKBN3Z/1AIB21b1zjHot1MOsx/yTD/dlPYD/n707D5PsKgs//q3ee/Yls2XfJ2QhIYSwhwzIJov+2MGAoghiQImiogKHF5RNRNSIooiIYYkBZIsggRBC2BMIZJ0Qkglkmcy+9971+6OqMz093VXV3VV1a/l+nqee6al77jmnb906772nus6r2XGMlebF2NMYjD1NyPgjzZmxpzEYe5qQsUeaF+NPYzD+NBljjzQvxp7GYOxpQsYfac6MPY3B2NOEjD3SvBh/GoPxp8kYeyRJkiRJkiRJkiRJkiRJ0gSTHtRYSulm4JHAa4GtTJ/8AA5PasCUcjMlOZhuH6aUuRd4Rkpp6/x/I0lSM0opbQc2Zt0PqRl1DYzSu/WA5eZYTu2tGH9uzbofbe6WlNKOrDuh2XGMlebO2NMQjD1NyvgjzY2xpyEYe5qUsUeaO+NPQzD+NCFjjzR3xp6GYOxpUsYfaW6MPQ3B2NOkjD3S3Bl/GoLxpwkZeyRJkiRJkiRJkiRJkiRJ0gSTHtRBSmk8pfQh4BTgHcB2Dk9+UC4JwnSP6UxNivB14LEppTuq9ftIkprWm7LugNSs1n15k+XmUU5t7+KsO9DmXpd1BzQ3jrHSvBh7smXsaWLGH2nOjD3ZMvY0MWOPNC/Gn2wZf5qUsUeaF2NPtow9Tcz4I82ZsSdbxp4mZuyR5sX4ky3jT5My9kiSJEmSJEmSJEmSJEmSJDDpQV2llPamlBJwLPBa4GYOT2IwNQlCfpqqKFM2BxwAXpdSempK6b4q/yqSpOb0HeAFwMasOyI1m0X37OX4j91K75YDlptDObW3lNI1wAbgloy70m5uATYUj7+akGOsNHfGnswYe1qA8UeaG2NPZow9LcDYI82d8Sczxp8mZ+yR5s7YkxljTwsw/khzY+zJjLGnBRh7pLkz/mTG+NPkjD2SJEmSJGm+IiJf4vG2rPsnSZIkSZIkSZIq05V1B9pRSmkQ+BDwoYg4DXgR8DzgLA4mP5hQLvEBU/b5GfAvwEdTSjur02NJUgv5LvBkYBmwuvjcGLBjhvJLgFUV1DsI9FWx3Nbiv+XazrLcnjJloHD8vlNBOTWBRffs5ZQP3cRoXyeji3sAyI2ON3S56crWq1wl1g1tm1V5Na/iFxHPjIgVwLoKdqkk/jRDrKikHMwuPlYSfx5IKc0U29VEZjvGjvV2Mrqg/FTPzkesfvW+U5c/WEEX5nXt1rt9cGludLxz4v+dA6PbAUYX9yw7sLB792zrm2e5PQCPuOunJwGfL1NeLSDj2APVv0fKqpyxpw3VIv507R9hx3lrfmP3w1ftK1Ndy127GXvaR41iDzjvNhNjTwvJOPZA41+Tzfra7dHX33QhcGkF+6jJOe9Wlvc+mlazz7s1WDnn3dpME937NHo5Y08bct6tLOfdNK0mij2N/j4z9rShJrr3afRyzru1IefdyvLeR9NqotjT6O8z590kSZIkSZIkSZIkSZIkSU3LpAcZSyndDrwdeHtELAMeV3ycDpxYfCyaYfdh4H7gB8D3gO+klH5Q6z5LklrCruIDYDSltCW7rrSuiDgj6z6o+roGx+gaHLDcHMtN1p0fnlV5Nb/iFxP9cqI0S3MZY0tZeseu76SUbqlahTOI/4zVTD/3lNn15+23v5NxOssXVMsw9khzV+34s/C+u37y4XNeXvP402huv/2d+FFMezH2SHNn7KmejXdfelK+ojV91CqMP9LcNOu8WyNy3q39GHukufPepzqcd2s/xh5p7rz3qR7n3dqP8UeaG2NP9TjvJkmSJEmSJEmSJEmSJElqNn7jp4GklHYB/1t8PCQiFlBIfLAQ6AH2ALtSStX7C1BJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkmbJpAdNIKV0ADiQdT8kSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZrMpAeSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJKlit192QT7rPkhTnXbRtbms+9AMIuJC4BslimxIKV1Tl85IkioSEccDd5co8sqU0kfr0xtJkiRJkiRJkqZn0gNJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkqQqiohSiSMjpfS2evVFkiRJkqRaM+mBJE0REW8DUtb9kCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkhpdR9YdkCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJzcmkB5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkaU66su5AO4qIhcBSoB8YAgaAPSmlkUw7JkmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnSLJj0oMYiogt4CvB04NHAacCyGcpuA+4FNgI/AW4Evp1S2lePvkqSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnN7iVb/ymfdR+kqT616uJc1n2QJEmSJEmqFZMe1EhErAL+CPhdYPmkTaUmm1YVH+cALy4+NxYRNwBfBT6TUvpp9XsrabKU0tuAt812v4i4BTi92v2RJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSGpVJD2ogIv4YeAuwmMOTHJTL/Jqbsk8XcH7x8eaI+DnwH8CHU0pbq9NjSZJUI5uz7oDKGxzrhZ5xcgMdD12F9fUPZdupNrGHfnL7OhhfOk5uXwd9/UOF16O+Hqh3g5IEQI5bc/s6oH8cqHvsaeexb3MuP06+G3L5wrHvWTRc7z608/GXlK3CGLgo99D1d5216/i3mZ5x2N0Fx2dz7zOe77i5bo1J0qE2Zzzv1q6x56F7TufdJLUl592y4rybpHbmvFs2nHeT1LZ2DC3ZeuTiHeQGO8iRJ4/3PnXjvJukdua8W1acd5MkSZIkSZIkSZIkSZIkNZWOrDvQSiJiZURcDbwXWEJh+Y78lAccTGww9cE05fNTypwM/BXwy4j4SEScUPvfTJIkzUVKaTtwa9b9UGnD493szvdD5zj5vjy5rV309I6yeOm+rLvW8vbl+hjPQW6oA7rG6d0DvYuH2D28sF5duOW0i67dUa/GJGmy9W/90p3k8kO5fZ3kdnbWM/bcklJq27HvtIuu3Z7L5W/N7ekkvyBPbnsn3QvH2DvaX68uGHskZeahMfBAjvyiwvV3He972jb+nHbRtdvpHr81Nw7jC8aho773PnuH+4ee9/qP3VXzhiRpGhNjYEbzbm0be2DSPafzbpLakPNu2XDeTVI7c94tG867SWpnd+09aud4F3fQ4bxbvTnvJqmdOe+WDefdJEmSJEmSJEmSJEmSJEnNxqQHVRIRxwLfAZ7EockOYPrkBtOpNBFCDugBfhO4PSL+PiIWVfP3kSRJVXNx1h1QeTdsXU/+lF3ke8bpuWoZAA9/1MZsO9UmblxxBD1XLWPkybvouWoZD3/URm7Yur5ezb+uXg1J0rRWDL6p56plMFS4/a9T7HHsg4u77swxejx03Vk49oNH122KzOMvKWsXd92ZY/ipB6+/66Tdx7+L86fsInfPEvKn1Pfe54GBlW+qeSOSVNrFGc27tXvseeie03k3SW3JebesOO8mqZ0575YN590kta2dw4v+In/iHvLdzrvVnfNuktqZ825Zcd5NkiRJkiRJkiRJkiRJktQ0THpQBRFxBHAVcAoHEx7A9EkOpiYwmOnBlDqmS4KQA7op/AHhzRHxlGr+XpIkaf5SStcAG4BbMu6KStg6uJyrD5zJgVXDMDZO9xeWs6pjH4//lRtYvHRf1t1raXd0rOHGsbXkbl3I2Cn7OPI7cOqZ9/C93Q9j9/DCmrQ5Mt65Cdhw2kXXXlOTBiSpQuvjix/oGBu5pPvbi0c6ft7Dqu69NYs9nV2jm4ANxWuTtnbaRdde05kf3dB5e/fmsSPH6f5RF0sWD7J17UL2jvbXpE1jj6RG8dAYuDm/efSs/ay7Hh5/3o21vO+5BeMPp1107TUsH96Q6x3aND7aDav2cOR1tb332TvcP3TH7qMvee7Fn/hA1SuXpFl4aAxcs2dTPebdvPc5aOKes+O2hSPOu0lqN867ZcN5N0ntzHm3bDjvJqmdfXvz2d/d3tf3Albt+4XzbvXlvJukdua8Wzacd5MkSZLUyCJiUUScHREXRMSzI+JlEfGbEfGi4v+fXNy+LOu+SpIkSVlKKeVKPN6Wdf8kSZIkSaqmrqw70OwiIgd8kkLCg8nJDibLT/n/1O1TTU18MHmfqYkPJp47FvhKRPx5Sul9FXRdkiTVSfHLFmdGxApg3Sx2XQKsmmHbVmBPE+3TqP06uHFwOV8aPI+jFm1dcvTozhMWf7Pn5COWDqx+2hE3dR1Y1tO7b6RvwUz7Thga6+oZHO3pm/xcno7B4bGu+/Z29tyza2jhfQf2Lbi7uGmmfk42CPSVLVV5ua0Vtl2LcjMe+zs61nDH0BqecMfPeo5csf1h6+4bPHld16YTDnR0L9sysGJxZ268t0z9h8nnGMp35PaO5zvuG+7svGdotPO+xWODd69ZsHPjWa/4xo7Z1idJtbI+vvgB4AMb3/6sE8eXjz9m7fLBk9cecdORlcae6eTpODDayfYD/d133L97xU3bHlyx8c1/+Q7HvkmKX8Zcd/tlF6wYy3ee1/WzjrOXj48cR1fHqn2jixYOjXYtnUu9+U72jOc7tox0dmwaGO3+mbFHUiM6ZAxcMXreuvu7z17Xd8ua/cu6Vs419gCMdeW2Do9137Ntz9Kfbtq7+l7ggZSS419R8bifcPtlF6xgW996Fg+due7+8fXrug6snO+9z/h4x5axfMf9Q2M9dwyOdW0ez3fc/LzXf+yu6v8WkjQ3k8fAzm196zu+1X/muiWj69cecdOi+d77jIx1bdrb1/2zLYNL7vbe53CH3nOOPMZ5N0ntxHm3bDjvJqmdOe+WDefdJLWzb28++7vAo158ytdHnXerL+fdJLUz592y4bybJEmSBMVF8x8HPB54GHAChe/rLgT6gWFgP/AAcBdwI3Ad8K2U0lD9e1y5iOgCngQ8FXg4sB5YDiwGRoF9wC+BnwHfBb6SUro9o76uBl5C4XU4h8I6K+XWT5nYdzewCfgp8D3g+8BPUkqjtejrDH3oBM4DngCcC5wEHAMsonAujVA4j7ZTOI82At8Grk0pPVivfs5HRJwJPA04GziVg7/fIgrfRd5B4XX4h5TSp+fRzkLgV4qPs4CTgaUU3o/7KHyn+G7gVuA7wJXN8DlnRPQAjwGeSOEYnggcReH4LQCGKJwjWyicI7dSOEe+lVLamUWfJUmSJEmSJElqNLl8fura+pqNiPgD4ANMn/Bg8sGdeH4P8BMKC7/uAg4AvRQWqT2Cwgerx1H4EHKy6eqa7vk8hSQMv1XPD/ckQUTcApw+zaZbU0pn1Ls/0lTFPySZLuHRaEppS737I0mSpNbm9ackSZLqyetPSZIk1ZPXn5IkSaonrz8lSZJUT15/SpqN2y+7wIUK1HBOu+jaihZgbycRcQ2FRfXr5ZsppQvnW0lEdAMvBn6DwsLq012jlLMb+CyFBd5vnG+fphMRbwPSTNtTStOekxGxFvhD4DUcvr5IOT8C3gtckVIan+W+sxYRTwNeDzyDub0OM9kDfAG4HPhqSmm4inU/JCJOA15L4XxaM4cqxoFrgf8EPp5SGqli9x4SEcdTSBQwk1emlD46zX4rgN8Ffg84vtLmUkpvm10PISJOBN4IvJxCIoBKjQFXAu9JKX1nhrpLXVfMqb+ViohHUTh+zwOWzaGKEeD/gP8A/ielNO9rpIj4KPCb861nFu5JKR1fx/akunnJ1n/yvkUN51OrLva+RZIkSZIktaxqfpjUdoof/ASlEx7kKGRN/zDw3ymljRXWfSSFrM9PAp5MIVv4RL2T685NeT4HvBRYEhHPr9WHZZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSVK1REQnhcXH/ww4Zp7VLQVeCbwyIr4AvCGlVGpR+Zor/n6XUFirZMEcqzkX+BTwBxHx25WuYzJbEXEU8AHgBbWoH1gCXFR8XA68pJqVR8RxwHuAFwId86iqA7iw+IhioouPVmNh+/mIiA7g94G/onCu17KtHuBtwB8BvXOoohN4LvDciPgMcHFK6cHq9XBuIuIs4H3A0+ZZVTfw7OLj1oj485TSF+bbP0mSJEmSJEmSmtF8PpRR4cOfiQ9+pks+MAL8OXBCSukds/mgMKV0f0rpyymlN6WUzgdOAN4M3DtNW1PbzwHPAv6nmL1ekiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJakgR8UjgeuBS5p/wYKrnAjdHxGurXG/FImIV8E3gb5h7woPJHgd8PyKeWoW6DhERzwRuo3YJD6bqqmZlEXExcAvwYqq7ts6xwEeAqyPi2CrWOysRsRy4CvhHap/w4HjgOxTWz5lLwoOpnk/hvfiYKtQ1JxHRGREB3MD8Ex5MdTrw+Yj4dESsqHLdkiRJkiRJkiQ1PJMezM9rOJh0AA5NQLAPuCCl9J6U0vh8G0op3ZNSeidwIvByYBOHJjqYaDfHwcQHzwT+ab5tS5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSbUQEa+hsLD6OTVsZgHwwYj4t4jorGE7h4mIk4DvA4+vctVLgS9ExJOqVWFEPBv4ArC4WnXWS0T0RsRHKSTOWFjDpi4EfhgRT6hhG9OKiCMpnEtPrkNbZ1B4Xz6yylUfQSFxxNOrXG9ZEbEU+BLwVqC7hk09n0JSktNr2IYkSZIkSZIkSQ2nqpmu20kxY/RRHEwwMDnxwDjwwpTSD6rdbkppDPh4RFwB/AnwFgofokz0Y6IPE///nYi4IaX0oWr3RZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZqriHgP8Kd1bPJVwIKIeEVxDY+aKi5SfxVwQo2a6AM+HRFnp5Tun09FEXEK8CmacD2aiOgGPg08u05Nrga+GhHPTildXY8GI2IJ8L/AKXVo6yTgG8CqGjXRD1wREY9PKd1UozYOUTx+VwGPqkd7wMnANyNiQ0rp5jq1KUmS1BYiIgccR+G6fCmwhELithHgQPGxD7gPuDelNJpRVyVJkiSp7TTdh0wNZMM0z00kG/h0Sun/atl4SmkY+OuI+ALw38B6Dk18wKT//31EXJNS2ljLPkmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmViIi/Ad44i122ANcB9wDbgR3AIgoLXR4HPAVYUUE9LwM2A388m/7OVkT0Al+idMKDW4HvUvjdtgJjHPx9nlb8uZwjgA8Bz5lPf4F/BRZWUO5+4CvAt4GfAZuAvRQWFs1RWHR0KbAcOA14ePFxfvH5WvgvKk94kAd+AvwA+DmwB+imsMD/GcCFVHYe9QNfjIgnpZSun22H5+DDwNkltj9A4TW5g8L5NEjh9VwDnAU8kcL7paSIWApcSeUJD3ZTSJBwM4VzeJjCorMnA4+m8NpPZzHw+Yg4q8J25qyYFONKKk94MEbh/LiBwvm9j0KCkbUUjuWTqOBYUnhvfj0izk8p3TPLbkuSpFkoXnufBzyewjXTicAxFGL2Qgrx/QCwDbiLwnX4t4FrUkrbs+hzI4iIo4HnUrhWPxM4isK1XC8Hj9fdwI3At4D/SykNZNDPHIVrsF8HHgGcU+xnJcYi4l7gTgrXeN8Dvp9SerD6PVVEHEPh3ux84HQK78PFFK6nd1O4j7+FwuvwhZTSbVVoM0fhvf8UCufG6RTuR5dSuP/bQ+G6/ibg6mK7e+fbriRJkqTpmfRg7kp9iBH16kRK6aaIeDRwBfBUDiY6mEjAANAD/DPw5Hr1S5IkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZn6G+CyKc+tp3SigfcBG+fY3gOVFoyIV5fpx4TdFBb0/2i5xRAjogN4LPDnwLPK1PtHEfH9lNJ/V9LfOXofhQU5p9oBvBv471ILoRcXbrywWM+5Zdp6dkT8Skrpa3PpaEQ8udhWKbcCCfhMSilfotyW4gMKi4pOtNENXEBhUdVfB46dS1+niog/AV5cQdFB4B+Af0op/aJEfZ0Uzp+/oLBofykLgE9HxCNrvFjui4FnTPP8OPBJ4NKU0vdKVRARfcDzKaxJU8oHKYwT5fwU+Gvgsyml0RLtngy8AXgNh691dALwrgramq8PAE+ooNwuCuPmv6WUts5UqLio8guBv6SQ2KOU1cBnIuLxKaWhinoLH6GQ4GWylRTGjZn8B/CdCuufygVfJUlNKyI2AL9F4fqy1CL4XRQW8l8OnAI8HbgEGI2Ir1K45/himevcufaxVJ2RUnpbPesu3mf8KvCnFK7PZ7K4+DiBwhqGfwTsi4j/At5d6pq6WiJiWbHdV1BIDDcXncV9JxLlTdT9Y+ByCvdld8+hb8dTSAgxk1emlD4623orbPttFO7NppVSKnfNX6ruaygkmJjON1NKF06zT47Cfd4bKX3dvbL4OIXCe/bdEXEdhXN11veyxYRtfwT8NnB0iaKrio9HFcvuj4iPAu8w+YUkSZJUfSY9mLuTJv08+YZ/UzUyxs1GSmlPRDwb+B8KkwhTEx/kgCdFxItTSpfXs2+SJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmqv5TSlVOfi4gLKZ1s4MqU0jU16tJEH84DLi1TLA+8F3hnSmlPJfWmlMaBb1NIAHAB8AngqBK7/FNEXJ1S2lZJ/XPwumme+wcgpZR2ldu5uODqNyLiURQWhv/TMrv8GTCnpAfAq8ps/wzwipTSgTnWT0ppBPg68PWIuITCIpeXcOi6LbMSEQ8H3llB0e8BL00pbaqgn2PAFyLii8DvA39LYYHcmRxHIVFAJYkX5mq6hAe3AS9PKd1QSQUppUHg46XKRMTzgJeVqWqcwgKr7yoeq3Lt3gm8LiI+BFzB4QkVLi5Xx3xExDMpvI7lfBH47UrGg2Lygssi4nLgLRSSH3SU2OWRwNspvEfLSildC1w7+bniorqlkh5cW6tFdSVJakQR8QwK8fVR86yqi8Lafb8K3BQRf1Dr+6EsRcTDgH8DHj/HKhYBrwV+KyLeCvxtLRJFAETEyykkgFtdi/opJKh7BIWF90+v9/qRrSIiTgM+zNzPqScAVxWvrV9d6f1/RFwMvINCIpPZWkjhPuRlEfGalNIVc6hDkiRJ0gxMejB3R3Hoh2YTCQa+kUVnUkojxQ+OvkVhAmYi2cGEHPAmChkFJUmSVBQRK4B1Ry3YuuTo/M4T+g7kD5vIPkD3gv30Li1XVzdju7tz4wcAhod6d27OL7l7S9/C6SbSH0gp7Zh/75vb5GN/RP+uVfOtb3nP3q1rFuzcAzxw2kXXtv3xldQcNr79WSeSz51Zlcr29mzN7erdeOqHP+kYWIHbL7tgBbCuStUZeyQ1jdsvu2AF2/rW53b3zPsaHIBc/ub1b73yrqrU1eKqHHvA+COpSVQ99njvUzFjj6R25rxbdpx3k9SunHfLjvc+ktrVCYvvX3b02K7jN8azq/OdEO99KmbskdTOnHfLjvNuraMRryWm9unRq9euGBvv6JxarrNjfOz2yy6oZO7Dc0ySJJUVET3AfwDdJYptBS5KKX11ru2klK6NiEcDVwJnz1DsCAoL5r96ru3MwhhwcUrpQ7PdsZjM4c8ioptCkoCZ/EpEnJRS+vls6o+IDqZfVH/CTRRej8HZ1FtK8Xf6LPDZiJjTIqYRkQP+hfLr53yWQsKD4Vn2MU8hMcbNFM6jhSWKvygi/iOl9JXZtDEP3wB+vdIFQSsREb0UFpUtZZTCsfz0bOtPKd1UfE9+FTh/0qZSyQLmJSL6gX+qoOg/An842wV7i4k83hoRtwL/Relz8Y8i4rKU0k2zaUOSJB0qItZQiO/Pr0H1Z1FIOvYhCtcGQzVoIzMR8VsUrp9LJfSqVD/wN8BjI+I3qnmvEBELKSSwe2616qzAYfPiKi8iXgT8J9BXhepeDJwREb+aUvpliTaXF9t8ThXaXA78d0T8eUqpVIIxSZIkSbNg0oO5m+mDqPvq2otJUkrDEfF84EYKN1ETiQ8m/n14RDwlpfT1rPooSZLUKCJiA3Dp6r4dp5/fcxeL7u4ld+DQv497sHcB1y9fw57uOXxWU2aX4h+vXNzK2b1nMvnYn7vqDpb27K96G7dfdsGtwMWnXXTtNVWvXJKqYGN6ziXs6HtXbmBJNf4g4NC6X/PiTbmxjlee+uFPXlPtulvB7ZddsAG4FDi9yvUaeyQ1tNsvu2AD23s/kvv56uOn3vvM18bXv3CIFYNvWh9f/EBVK24RtYo9xbqNP5IaVi1jD3jvU4qxR1I7c94tO867SWpXzrtlx3sfSe3qCWt/8rjlB4be37Fp8TEdA93kxhdXtX7vfWZm7JHUzpx3y47zbq2jEa8lZurT2v7t5MkdVj5H5et+eo5JkqQKvAEolVRtL/C0lNKN820opXRfRPwKhXU4jpqh2G9FxLtSSnfPt70yfiel9J/zrONNwLOAU0uUeQHwnlnWezKFdUpm8tfVXMR0qpTSljnu+uvAY8uUuQZ4SXFx+jlJKX0zIl4IfInSC/S/G6hH0oObgOemlPZVud7XACeUKXPxXBIeTEgp7Y6IZwI/BE6caz2z8HuU/50+nlL6g/k0klL6VEQsAUolNekC/gr4tfm0JUlSO4uIxwFXAEfWuKnXAOdExHNSSltr3FZdRMTbgbfUoOrnUVg0/nkppdH5VlZMxHUl8KR590w1FRGvB/4epvlQYe7OBL4WEY9OKe2aps1VwNeAh1exTYB3RcSelNIHq1yvJEmS1JZqlum4Dcx07DKdnEgp3Qv8BTPfAP52HbsjSZLUkIqL7l+9um/H6RsW3MLiWxZNm/Dg6tXHzi3hQWVOp5Dd+8JaNdCIDjn2R/24JgkPik4HvnH7ZRdcWKsGJGmuNqbnXJK7b9H7cwNdNQkyubGO44Fv3PGql15Yi/qbWfELeldTgy8NYuyR1MBuv+yCDezsubrjpiNqsuh0bqCrN3ffor/bmJ7zhqpX3uRqHHvA+COpQdU69oD3PjMx9khqZ867Zcd5N0ntynm37HjvI6ldPWHtTx63YnDwio7bVhzDgPNu9WTskdTOnHfLjvNuraMRryUasU+SJKl9RMRi4E9LFBkHXlCNhAcTUkrbgJcAMy3A2Q38YbXam8F/VSHhASmlYUofP4Cnz6HqUovP54EvzqHOevjLMtt3M8+EBxNSSl8G/rZMsbMj4tnzbauMMeCV1U54EBGdFBKSlPK5lNK/zretlNIO4DdgFtnV5iAieoA3lim2CfjdarRXPDZXlCn2nIio9gKtkiS1hYj4deAb1D7hwYRHA1cXF1lvahHx59Qm4cGE5wBvr1Jd/4gJDxpeRLyY6ic8mHAqcHlEHFJ3RCyjMAbU6nr67yPi/BrVLUmSJLUVkx7M3d4Znh+vay+m92/AHcWf85P+zQHPiAhfd0mS1O4uBTh31R3kfrZs2gLXL19T1760kYeOfT3bk6SGsqPvXXVqyTHwcPU4Jh53SY3o0pnufapqR9+7a99I06lXXDD+SGo09Yk9xbbq1VCTMPZIal/Ou2XJeTdJ7cp5t+x47yOpLS3r2ffXubuW1Ks5x8BDGXsktS/n3bLkvFvraMRriUbskyRJah+vBlaW2P7vKaWvVrvRlNJ1wCdKFPmN4gLptfAgcHEV67sS2Fpi+6MjomuWdS4rsW1bSunALOuruYh4FPDIMsVSSunBKjb7duD+MmVeW8X2pvOBlNINNaj3V4ETSmwfpnwCgYqllL5H6fdkNfwa5RdFfkNKaaCKbf4xUOr9kgNeU8X2JElqC8WEB/8NVHrNvh/4OoU5ygD+ALgEeBfwUeDuCus5E/h8De8Vai4iXgS8s0SRfRSSnP0D8Gbg94G/AD4AfIfK11X8s+I1+pxFxIVUlpBqFPgWhf7+OnAGsAZYBHRRuL85FjgLeAaFxHGXATfPp38qKCbx+k9mTniwC/g08H7gz4DXUXgffgS4t8JmngZcNKnNHIXX8IwS+/yEwhqcfwW8HvgT4H3AVUAlifC6gI/O4X5akiRJ0hReVM/dHmD5NM8vq3M/DpNSykfEB4APcjDZwUTyg2XA44DrMumcJElSxiJiJXB6T8cIS3MD5A4sO6zMUEcHe7p769WlMyJiRUppR70azMohx75nf72aPeP2yy5YcdpF17b88ZXUHDa+/dkn5wYW1yvInHHHq1664tQPf9IxELj9sgtWAqfXoSljj6SGcvtlF6xkpOP03IHumreVG+jq3fj2Z524/q1X3lXzxppAHWMPGH8kNZB6xp4i732KjD2S2pnzbtlx3k1Su3LeLTve+0hqVycuvm95xyinMuC8W70ZeyS1M+fdsuO8W+toxGuJRuyTJElqO6UWsNwLvKWGbb8HeDnTL8x4BPBk4Cs1aPefU0p7q1VZSmk0Ij7NzIvrLwBOAW6bRbUzLVYJjbs2zcvLbL8N+KdqNphS2hcRfwb8V4liT4+ItSmlzdVsu2gEqFXS9JeW2f6PKaWfV7nNPwOeB/RXud4J5c6Rq1JKn69mgymlX0bEu4B3lCj2koi4JKU0XM22JUlqVRFxDvBxoNwH5qPAFRSuAX+QUiq5yHlErKewwP/vUTqZwmMpJAD4/cp63FBOBN4ww7b/o7Ag/LWlrksi4ggKCSP+GCj1uVEH8HfAE+bU04K3l9k+RmFtxfemlEotnr+7+PglhUQH/zexISKOBp4LPAf4FRr3fqdR9VJIPjDdufBVCvcr30opjc5UQUQ8Afh74Nwybb0nIj5TTML3l8Czpimzk0Iyk0+WOiciYimFJG5/Sun3+8OA3wb+tUzfJEmSJJXQkXUHmtgWpv/Q7th6d2QGV3AwO2J+yrZH17kvkiRJjWQtQF/nEAxPfzk82FH3zyPW1bvBjBw89vXVLsdXUjPI1+1LYhMcAw9aW8e2PO6SGsname59aiKfO7N+jTW8esYeMP5Iahz1jT0FjoEFxh5J7ct5tyw57yapXTnvlh3vfSS1pRW9e1Yx4rxbRow9ktqX825Zct6tdTTitUQj9kmSJLWJiHgMsL5EkY+mlB6sVfsppVuB75Qo8vQaNDsE/HMN6v1eme2nzbK+UomqlkdEo6ylMtmvldn+oVILbc7D5cC2Ets7gWfXoF2AL6aUSrU9JxHRTWHR11L+pdrtppTuA75Q7XoBIqIfeFqZYlVNijHJhygsujyTFcAFNWpbkqSWEhFLgM9RSOxVypXAKSmll6WUvl0u4QFASmljSukPKVw7X1um+GsjYkMlfW4wLweWTnnuLuBXUkrPSCl9rVwippTStpTSXwLnAKUSDQA8PiIeP5eORsSpwBNLFNkLPCOl9AdlEh6UlFK6N6X0wZTSMykkhXgfsGuu9bWhxwBnTXluM/CclNLTU0rfKHcfllK6DjifwnVzKeuAl0XEaUyfIPEjFN73f1PunEgp7U4pvaXY/11l2n1jRJRKDChJkiSpDJMezN0t0zyXAx5R745MJ6W0Hbie6RMz+OU3SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk1cuzymy/vA59uKbEtifVoL3rUkpbalDvT8tsP3qW9ZXr4+tmWV9NRcR6oFQihlHgk7Vou7iA7qfKFPuVWrQNfLRG9T4aWFRi+w9TSnfWqO1P1KjeC4DeEtu3A/9bi4ZTSluBr5QpVqtzRJKkVvM+4LgS20eBP6Gw4PqmuTSQUrobeCrw8TJFPxgRnXNpo4HcADw2pfT12e6YUrod2ABsLVP0NXPpGPCrZbb/Xkrpa3Ose1oppV+mlP4EOIZCMgjN3ibgCSmlL81mp5TSGPD7wGfLFL2YQgK2ninPvzWl9DvF9TZn0+6PKcxNlErMcAqFc12SJEnSHJn0YO5unvL/fPHfcyJiRb07M4OfTPNcDji93h2RJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElS23pGiW0PAN+pQx++VWLbGRHRXeX2vl3l+iZsLLN99Szruxk4UGL7JRHxvFnWWUtPLLP9azVKNjHhsjLby/Vvrkqdv/NRLuFHuSQP8/FlYGcN6i33GlxRTGBRK1mdI5IktYyIOB/43TLFfi+l9L6UUr5MuZJSSsPAyymduOg04KXzaSdjNwEXzuc6uZgI60/LFHtuRExdoL4S55fYdltKqVbJskgp7Usplbof0vS2Ak9MKf18LjunlMaB11P6XvQcDr9fiZTSO+bSZrHd7wD/WqbYC+ZavyRJkiSTHszHdyf9nJv0cxfw/Dr3ZSZTswZOTMrM9sNJSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkadYiohc4u0SRH813odIK3VNiWw9wSpXb+275IrOXUhoASi3YvnSW9Y1QekH9LuCKiPhgRKyZTd01UupcAriuxu1fDwyU2H5kRBxR5TbvSintqnKdE84ps71mx7N47v2wBlVnfY6US1Dx8IjIlSkjSVK7+6ty21NK/16txor3Iy8H7i1R7I3Vaq/OBoGXppT2VaGu/wR+XGL7UuAxc6j3xBLbvjCH+lR7r04plXq/lJVSuh/44Cx2+R4w54QHk7yN0vfUpZI2SpIkSSqjK+sONLHvU8gwdwQHkwlAIQHCJRHx4Tp9oFrKnhmeX1zXXkiS6mrj2591IvncmVOffwqLlo7R0Tn1+U7GxzbGs3dPW9nenq25Xb0bT/3wJ3fUoKst5fbLLljBtr71ud09q6pSYS5/8/q3Xjk1gZEk1VVErDhizc7zVnbuO3v5gYHj+jtGV40OdS4cH86t7Ooa7RnOd3aOd+YW9HSP9lVSXy6XH+wgf4Cxjt1jHbkdnZ3juzq6x7ePdnQ8OE7nge7VA3cuOWPHD885+VrjTgUu/9wrTuzsGD8s5s/F0hV7t65au3Ojx15S1iJiBbD+6P7tZ65dsmN9X9fIyvH9XcvGhlnelx9dPJzv7Bwd7err7hjt6VwwVnZuMwejOcb353K5fePkduTJ7ct1j2+li3vG6TywqHtw58KO4e+d+QqvvSsRESvWHr11/cpVu6py3zM23nHzi3/9Yx57SZmLiBOXrtjzmGOWbz152eDQCeP7u5YND3Yt7h0bXdjVNdozOtLRk+/ILaw09nR05Ichv3d8vGN3ntzezs7xXXSyabSrc9ui7sGd/cfsvXv8uGGvvyswm9hz/Cl9S/Pjh89/5jrGxz79hYt2g/c+khqH826NzXk3Sa3IebfG5rybpFblvFvjqnbs8d5HUqNw3q2xOe8mqRVVMu/WkVu35OgjH8i6q5IkSY3iTKC7xPZb69SP7WW2H011+/KLKtY11V5gxQzbeudQ30eAp5fY3gG8FvidiPgs8AngqpTS4Bzamq9y8wylFmGdt5TSWETcBJxfothZwDeq2OyPqljXVGeU2DYO3FzDtgF+AjytynVmfY7cHxFbgNUzFFkEHA/cXct+SJLUrCLikcBTSxS5DYhqt5tS2hYRb6VwbTydsyPi3JRSLa/NaiGllG6pUkX5iPhP4BElij0BuHaWVS8rsa2W91Wam/9OKX2uSnVdTmUJRcaB30opjc23wZTS1oj4OjMnNzghItallPyQR5IkSZoDkx7MUfGm+3+B36SQ9CA36d/1xec/mlkHC2Z6fU16IEktaGN6ziXs6HtXbmDJtH+EsqSjk3Fyhz3fQQe58dKhYeNrXrwpN9bxylM//MlrqtLZFnL7ZRdsYHvvR3I/X3187kCpv7WavY2vf+EQKwbftD6++IGqVixJZUTEhtXrtn/i6efcvXbJzZ107Oxm1/6F9C4Zpv/ErTzYsZhtwys48ZG/IHdEqcTVc3PDTRs2d/aPvfSck6+9puqVt4DPXvmyS1av2/6u9WcOzOUPT0u6/rYNm7q6x17psZdUbxGxAfjIKf2bjz+r+344dpAdN6xlR08fp667m20LFnHPL47l9L4H6X7yZvKrRqvW9ihw4w+ePNJ1V++fnvmSL3+gahW3kIjYsPrIbR/Z8Kw7j1+ybH9V677uR08f2vLAyjc971mf+EBVK5akCkTEJUes2fGeZz7uju7+/ePs+MFa7hk5kjM77mPBiQ+wc+9Seoa76Hry1qrGnvHivzfe+qRN9OS9/p7GXGLP0GA34+PTzH925OntO/Te1XsfSVlx3q2xOe8mqRU579bYnHeT1Kqcd2tctYw94L2PpOw479bYnHeT1IpmM+/W84St8Muse3zQZ6982SXrTux99/K7hrLuiiRJak+nldm+LiJeVYd+dJbZflSV29tZ5fom28fMSQ965lDfpykkfDi9TLke4CXFx/6I+AZwTfFxYzUWoKzAsWW231iHPvyY0kkPyvVxtmq50OuJJbbdmVI6UMO2oZD0oGoiIkchgclMBoCN1WxzBj+mdCKRYzHpgSRJM3l1me1/nFKq3h+eHOoy4O3MfD3xImqbkKra9gD/XOU6PwX8HUyzmFXB2XOoc6a6wPUyG9H7qlVRSun6iPglcEyZol9KKVXzOv6zzJz0AOAcwKQHkiRJ0hx0ZN2BJvev0zw3kfjg/RFR6gOQejhihufzde2FJKnmNqbnXJK7b9H7cwNdVf8yCEBurON44Bt3vOqlF9ai/mZ1+2UXbGBnz9UdNx1R9YQHALmBrt7cfYv+bmN6zhuqXrkkzSAiNhyxZsfVjz/p1rVLv99D19397Nq/kOUL99B/1oM82LGYewfWctLTf16TL4ACdPaPrQW+ceOdF1xYkwaa2GevfNklJ66/9/2LllT/C6AAXd1jx+Oxl1RnxS+AXn1K/+bjHzH4IPmH72fX1Udzf38fDzv5DrZ1LOLWu9bzqO776HpxdRdee8iK0e7R8/b/3c2feuYbql95c5u4Nnjshp/UZPGbRUsGek9cf+/fffbKl72h6pVLUgnFhdfe/4Qzb+ru6xhh11VHc2t+DY/O38OCszazc+9Slh3I0fmiB2sTewB68sfj9fdhah17wHsfSdlw3q2xOe8mqRU579bYnHeT1Kqcd2tczrtJalXOuzU2590ktaJZz7str8dar5WZGJcXLBqay+K3kiRJ1VBu8cKLgH+rw+NfyvRjyex+rbJ2VLm+yUqtHVJqwdBppZTGgVcAg7PYbSHwbAoLXl4P7I6IqyPiHRHx9IhYPNt+VGhdiW0DKaX7a9TuZD8rs/3IKre3u8r1ARARK4BS8zd31KLdGrexmtIL426qU3KOep8jkiS1hIiYSLI1k5tSSl+uVfsppRHgP0sUKZXUqBH9e0ppbzUrTCk9CGwqUaRc0rvplLp3OmcO9al2vp9S+mGV6/xxBWUurXKb5ZKXrK9ye5IkSVLbMOnBPKSUvgt8v/jfiS7melUAAP7gSURBVGQHE5YBn46IBfXu1yQzZZCvzTdVJEnZ2dH3rjq1VO2Jv2Z3ae5ny2rfyo6+d9e+EUl6yKVnnXcHPVctIzdcuGXszo+TP2UXAD/aeiqnn39n3fpSr4aaxep12435klrRpQBnb93O8FN30XPVMq5fvoaHry7Emx9tPZXzdj7I8FN31bwjYycOeu19uEvPOq/2f5++et12j72kenvXWefdAb35h2LPeTsffOjep+fni+oSe4q8/j5UXWLPRFv1akiScN6toTnvJqlFOe/W2Jx3k9SqnHdrXM67SWpVzrs1MOfdJLWohpl3m606jsuSJEkzaZbFvfurWVlKaaia9dVaSukG4LeAuWaQXAhsAN4MfAXYERHXRsSfRMQJ1ehjRCyk9OtUk+QA09hTZvuqOrc3V2vKbK/H8ax2G0fUub2Z1PsckSSpVTyR0snILq9DH64pse3siFhahz5Uy2drVO9PS2w7eg71bSmx7fkRsXYOdao2/qcGdd5WZvs+4OoatFkqmeCxVW5PkiRJahsmPZi/d3JosoMcB29gHkUh8UFP3XtVsIFDb6Ym+vlABn2RJNXIxrc/++TcQFdvnZo7445XvXRFndpqaLdfdsFKRjpOzx3ornlbuYGu3o1vf9aJNW9IUtuLiJXdPSOnL+kdILe3g45dXQzlcixiEBaOMjTWxVi+i9wRc/17xVk748Y7LzDuFP33515x8qIlA3WL+R57SfUQESuB0xd2DtI1APlF44zs6GW8K0/nwhGGxroYHOxnSdcA+VWjNe9PfsVY780f89p7wkPXBstqn0N10ZKB3ss/9wqPvaS6iIiTu3tGepf0HiDfl2dkRy+DHV0sYaBw7zPYzaLOobrEniKvv4vqGXuKPPaS6sJ5t8bmvJukVuS8W2Nz3k1Sq3LerXE57yapVTnv1ticd5PUihpt3m026jwuS5IkzWRx1h2oUNtfN6WULgeeQulFRyvVRWHR2vcCd0XENRHx4ojonEed5RJT1Co5wFTlFs6vagINavd7LSizfW+N2p2s2r9bu54jkiS1imeU2f6ZOvThO8DYDNtywNl16EM1DAPX16jujSW2LY+I2S7K9IMS25YAn4qIRbOsU7Xx3RrU+fMy23+QUprpPTknKaUDlF6T0yRlkiRJ0hyZ9GCeUkpfBP6XQ5MdTPycA54OXBURy+vZr4h4GDCR5XxyUoY8cFc9+yJJqrE8p9e5xXV1bq9RrWW4jpdS+dyZ9WtMUhtb29c/RG5fB/n+cQCGOzqhp/Dz4Fgvi3sP1LtPxp2ijo5xY76kVrQWKHzJc9E4uX0dhcVvOgrxZnCsl77xUfKLxuvXo868194Hre3rH6pbY50d4x57SfVyel//EAx0PBR7+sZHH7r3GR7sq2/sKfD6u6CusafIYy+pHpx3a2DOu0lqUc67NTbn3SS1KufdGpfzbpJalfNuDcx5N0ktqvHm3SqUwbgsSZI0nWZZ3DtXvkjrSyl9Czgd+HsKC6VWy5OATwG3RcT/m2MdfWW2N8qC9uX6OVu1utlohONZ7TYa4XeC+p8jkiS1ikeX2LaP0ovtV0VxMfRtJYo0y9/l/TilNFijuktd6+SYfeK7r5fZ/iTgxxHxnIjwvi07Y9QmkUa5ZGvfq0Gb5dpdWqM2JUmSpJZn0oPqeB0w8ZfQ0yU+eALwg4h4VB379JYS22qVdVGSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmarDvrDmh2UkrbU0pvANYD7wbur2L1pwCfjYhPR8SSKtYLB9d9qbVWWWi13NpDI3XoQz3amMxzRJKkBlVczP7sEkVuSynVK5ZvL7Ht6Dr1Yb5+UcO6yy1S3zvL+r4P3FKmzMnAF4CNEfFnEXHKLNvQ/G0vJgWptn1ltt9bgzbLtTvbc1iSJElSUVfWHWgFKaVNEfEa4L849IONyYkPTgKui4j3Au9NKZW7WZ+ziHgq8GJm/pDl2lq1LUmSJFXb0FgXg2Oz+xxgeKyTofEeAO7cffSFl0ecNGnzVmDPNLstAVbNUOVs96lHG7XY59wZ9qm54aEuBgcOf51/cde6kz7/8Zj8VKnfbbJBoK8Fyj30eh138oJjKih/iJmOaykjw50MD/Vw9x1HX/j5jx/y3jmkP5M0+nndUO/rJ+WXHHNkhX8TOdTRwWBH+amb4VwHQ52d02772aLlF36yMAZuLT5V7v1TzXJLgV3Fn1dOen4sInbPsV2Yw/sH4OyVx5502rLK/y5jtvGnAWJPNfdp69iza/eqYz4Tccakp7KKPVm8byfKTbxeU+NAWfOJPff9YtX5ETF1c9OM8Y26z9krjz3ptO7KvltSjdhzPyvO/1ThdazF2N7o5eoae2BO8afhztEa7VOu/PkztFNzVb73yTJWVFIOZv/+mXXsgcJx3bt7Afn84d8LyuXyDA2OHvLcROwBprv3adTzeqZ9Gq5f9Y49cMi9Tytdk1VartFjD3jt1pD3Ps67Oe/WQPs479YY5aBB730aIPbMtM8KYBmHzn3CwfnPrN/XDRd76jDv1ujvM+fdatNGZvs471bXcs1w79Nw52iN9nHerTHKQR3n3WYTf5x3q+k+K3YMLTn+yL5dMxQ9lPNuVSnX6LEHvHZryHsf592cd2ugfZx3a4xy0KD3Pg0Qe6q5T0vFnpley8mv2WQj452MjHUxOt7ByHgXv9i/9vWXR+wDFnFwoZ5FK45YdfLJp9dybStJkqSKDGXdAc1NSmkT8OcR8WbgycDTi/+ew/wXdX8+sD4inphS2lXhPoNlti+dX5cqVi5ZQ7l+Nopy783FdehDtRNfeI5IktS8jqRMDI2IV9WpL6Um3o+qUx/ma2cN6y63SP3hk9olpJTyEfEO4FMVFD+FQmK2d0fEbcDXgWuAa1NKW0vtqHmr1Tm1vwHbndU5LEmSJOkgkx5USUrp4xFxHvCHHEx0AAcTH0Ah8/xfAL8XEe8BLk0pVfUDiIg4H/jMpKcmtw+wDfhmNduUJEmSauHBgeX8aOup7BlZNN+qLq1Gf1QbWzcv56brT2Xv7hlf58/Xsz+NbMfWyv+OroLjWgnfOzXwM1ZzJA+WLPNg7wKuX76GPd1VSfzu61h09551VPIl0CrFH497A6tgjPT1m4MqxZ6/rFZ/dNDde9Zx2srSi69VOfb4OhbVOfaA41dD896nNrz3aUwZxB7wdQSMPTqUsadyzru1BufdsuO8myY471Ybzrs1LufdsuO9jybz3qc2vPdpTFsGlkFf6fHPebfaMPZoMmNP5Zx3aw3Ou2XHebf2U8VriddM9+TIiF8lliRJDeFAme2PSCndWI+OaG5SSmPAVcUHEbECeELx8XjgkZReGHYmZwKfiYhnpJRGKig/UGZ7tRfQn2s75frZKMqte1OP41ntNjxHJElqXuUSaz+q+Mhava4n5mtHDesulzl71gnSUkqXR8TzgRfOYreHFR+vA4iInwHfBa4Drksp3TbbfqikWiUfKHc+ZdHufJP8SZIkSW3Lv1SqrjcCR1PIJD5d4oOJ51YC7wHeGBGXA5enlL4zn4Yjogv4cwpJFXqntD+5Dx9NKZW7sZMkSZIy9eDAcq65/9ysu6Ea27p5Od/5uq9ztXlcm9uDvQu4evWxWXejbRl/Wp9jZG14XJubsSdbxp724DhZGx7X5mXsyZaxpz04RtaGx7W5GX+yZfxpfY6RteFxbW7GnmwZe9qD42RteFybl7EnW8ae9uAYWRse1+Zm/MmW8ad1+FpKkqQ2sr3M9hOAG+vQD1VJSmkH8IXig4joBR4DPBl4JnAelS8S+WTgEuC9FbS7PyIGgP4ZitRrAdpyWR+31qUX81duIdxmTHqwrc7tzaRVzhFJkurpyKw7UKGZrkUbzVDWHZiDV1JIfvGYOe5/SvHxCoCIuB/4CvBZ4KqU0nA1OtnGsjqnmvFcliRJktpWR9YdaCXFrOQvAT7DoYkO4OAHcZOTH6ymkBnwWxGxKSL+PiJeGBHHVdJeRHRHxHkR8V7gl8DbOJjwYMLknweBv5/L7yZJkiTV04+2npp1F1QHN13v61wLHtfmdv3yNVl3oa0Zf1qfY2RteFybm7EnW8ae9uA4WRse1+Zl7MmWsac9OEbWhse1uRl/smX8aX2OkbXhcW1uxp5sGXvag+NkbXhcm5exJ1vGnvbgGFkbHtfmZvzJlvGndfhaSpKkNvKLMttPrEsvVDMppaGU0jdTwfnAscCfAHdWWMWfRsTiCss+UGLbgohYW2E983Fyme3316EP1bCZQ9emmaoeCw+vq3J9W4DREtuPj4jOKrc5nVY5RyRJqqdKrwez1pt1B1pVSmk/cCHwH1Wq8kjgt4EvAfdHxPsrXedRkiRJkjQ3XVl3oNWklMYi4iXAhyjc5E5OcjA18QGTnjuWQgKE1wFExAHg5xQ+aNtGIWHBOIVs0UuAo4CHcfA1nFz35P9P/JwH3pNS8gMPSZIkNbShsS72jCzKuhuqseGhLvbu9nWuNo9rcxvq6GBPt3/fkBXjT+tzjKwNj2tzM/Zky9jTHhwna8Pj2ryMPdky9rQHx8ja8Lg2N+NPtow/rc8xsjY8rs3N2JMtY097cJysDY9r8zL2ZMvY0x4cI2vD49rcjD/ZMv60Dl9LSZLUZu4us/2UuvRCdZNSuhd4X0S8H3g58H5gRYldVgIvBj5cQfX3UDpRxiOAL1fY1bl6RJnt5RJ9NISU0mhEbGbmxANnRkQupVQqMcJ8nV3NylJK+Yj4JXDCDEUWAKcCt1Wz3Wm0xDkiSVKd9WfdgQrlyhfRXKWUhoDfjohPA+8GzqpS1SuBS4DXR8RHgLeklLZUqW5JkiRJUlFH1h1oRSmlsZTSq4A3AGPFp6cmOpiaAGFyYoQcsBB4OPA04GUUEii8CngR8Izitu5J5adLpJCf9O/1wDur91tKkiRJtTE45heg2sHggK9zLXhcm9tgh7kps2T8aX2OkbXhcW1uxp5sGXvag+NkbXhcm5exJ1vGnvbgGFkbHtfmZvzJlvGn9TlG1obHtbkZe7Jl7GkPjpO14XFtXsaebBl72oNjZG14XJub8Sdbxp/W4WspSZLazI/KbH9qXXqhukspjaeU/hN4ErC9TPFKz4Oby2w/p8J65iQiOim/8OpNtexDld1aYtsi4KQat1/VpAdFWZ8j64A1JYrsBTbVsg+SJDWp7qw7oMaRUvpfCtdtLwK+AoxXqeou4NXArRHxa1WqU5IkSZJUZNKDGkop/QOFD9R+yeFJDuDQJAeTt81UplR5ptk28dx9wAtSSqNV+tUkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKkslJKmymsvTGTEyPiYfXqj+ovpXQz8MYyxZ5YYXU/KbP98RXWM1ePABaU2H5/SmlbjftQTeUSBDyixu2fW4M6sz5HytV/U0opX6aMJEntaCjrDqixFJOoXZFSeiZwLHAx8FlgRxWqXwn8T0S8ugp1SZIkSZKKurLuQKtLKX0zIs4A3gn8HoUsklMTFUz+d8LkMqVM3W9i34ltvwSemlIq9eGvJElSO9kMMDjWCz3TJ3DuG697rqgH6t1gRg4ee0lqU3voz7oLbcv4I6ldlbr3UW0ZeyS1K2NPdow9ktqZ827ZMf5Ialfe+2TH2COpXQ2N9UC3sScLxh5J7cx5t+wYf1pHvjvrHhwugz61y/clJElqNmNlttfqquFrwCtLbP814LYata3G8HHgA8DSGbaviYiOlFK5CdFry2x/WkSsTCltn20HK3RRme3frFG7tfId4A9LbP9/wBW1aLiY7GR9Daoud468MCLekFKq1ZfKa3GOZDV2S5JUTwfKbL8kpfSBenREjSeldB/wQeCDEdEBnEUhcdrjgScAR8+h2hzwTxGxKaX01ap1VpIkSZLaWEfWHWgHKaX9KaU/BB4GfJLChwgTyQryTJ/gIFfhY7KpyRSuA85PKd1Rzd9HkiSpmRX/QOnW4fFuduf7yS8YOaxM7/g4S0bqlvz7lpRSNbJHN7xDjv3wwqy7I0mZ2JfrY6y/3N8WqhaMP5LaVal7H9WWsUdSuzL2ZMfYI6mdOe+WHeOPpHblvU92jD2S2tVIvps99EG/safejD2S2pnzbtkx/rSQbhhvtPwh9e3TLadddG1bfF9CkqQmNFxme62uGP6nzPbXR0RfjdpWA0gpjQA/KFGkA1heQT0/A+4pUaQbePHseleZiOgEXlKm2Ndq0XYNXVNm+3MjYkGN2v6NGtX7LWCwxPbVwNNq0XBErACeWabYXM6RrMZuSZLqqVzSqhPq0gs1vJTSeErpJymlS1NKL00pHQMcTyHR3ieA2cxNdwGXRcSiGnS1VsygLUmSJKlhmfSgjlJKd6WUfgM4EXgPsJlDkxfkZ3hMZ6ZyOWAXcAnwpJTSg1X/RSRJkprfxQA3bF1P/pRd0xY4b2fdLqNeV6+GGsRDx16S2tWNK47Iugtty/gjqV2VuvdRbRl7JLUrY092jD2S2pnzbtkx/khqV977ZMfYI6ld/XT7SeRP3JN1N9qSsUdSO3PeLTvGn9YxenzWPThcHfvUbt+XkCSpmewts31Jjdr9KrC1xPYjgd+vUdtqHNvKbK908c5ySTReHRG1WFfnBcCaEttHgS/VoN2aSSltAb5foshC4P9Vu91iAomXVbtegJTSIPCVMsVeW4u2gd8Fekps30YhKcNsZTV2S5JUT78os/3EuvRCTSmldE9K6aPFtR7XUEhy9SkK1+jlrAL+YJZNzrRG5IRcme3zsbKGdUuSJEnSvJj0IAMppXtTSn8OHA08BfgXChnEc1MeE0olQphc/h7gzcCJKaW/TymVuxmWJElqSymla4ANWweX33L1gTPZe8Y+8gtGDimzZugAT97yC5aODNWqG7cAG4p9aRuHHPv7zmX38MKsuyRJdXdHxxpuOGo5Y/1jWXel7WwdXI7xR1I72jq4nJnufVRbxh5J7crYkx1jj6R25rxbdow/ktqV9z7ZMfZIalc7hpZx3cB69q/fD/3Gnnoy9khqZ867Zcf40zrGl8Lww2C8P+ueHFTrPuVz3AlsOO2ia6+pTQuSJKkKSiUegBotJJpSGgL+rUyxP4+II2vRvhpGuQx7uyus57/KbD+bwuLzVRMRC4C/KVPsK8UkAs3m8jLb3xYRpRbyn4vfBU6ocp2TlTtHnh0RT69mgxGxDvjLMsU+lVKa9UR/SukAcKBEEReBliS1gnsovZD8KfXqiJpbSmk0pXRVSumlwMnA5yrYbbZJ+MolU1gwy/pmY0UN65YkSZKkeenKugPtrJiU4BvFBxFxMvAE4JEUPjw7AVjH9MkpxoD7gZ9SyJb9lZTS9XXotiRJUksoLr5/ZkSs+NLgeeuOOmbrkqPzO0/oO5BffrDUAOewiQP57gX76V1ars5uxnZ358YPAAwP9e7cnF9y95a+hXumKfpASmlHlX6VpjP52H/ll49Zd9SCrUuO6N+1amL79sElxwCXZtZBSaqDOzrWcMcRa1iYH2QpAwCMmJuyLrYOLucrv3wMPR0j9HUeTG40lvf4S2ptWweX86XB8+hZNcJiBugdGzP21ImxR1K7MvZkx9gjqZ0575Yd44+kduW9T3aMPZLa1Y6hZXxtaBndK0dYxCD946PGnjox9khqZ867Zcf40zrGl8Lw2cAo5IYPPj+8B/hlg/VpCMbHDy/f0QG53vL15nuALn79nJOvvaVafZUkSTWxDRgAZkqDdHoN274U+ENgpgxfRwCfi4gnpZQGatgPZSAiuoCHlyiyJaW0v5K6Uko/iogfAOeXKPbXEXFFFb/T+5fAMWXKfLBKbdXbx4F3ATNd+Z8MvB7422o0FhHLgHdUo64SvgTcCxxdoszfR8TDU0rDJcrMxvuAxSW254F/mUf9vwTWz7CtlmO3JEl1kVLaFxE/A06docj6iDgmpZTRzKqaUUrpHuD/RcQ/A79XouhREfGwlNJtFVY9VGZ7qevC+Sp1jStJkiRJmTLpQQNJKd0J3Al8dOK54gd2Kyh8YNsLjAD7KXxQN82fjkmSJGk2in+oNPHHSt/Nsi/tZsqxf0hEnJFBdyQpE/tzfeynL+tutKXh8W6Gx7uz7oYk1d3weDfb6YZc1j1pP8YeSe3K2JMdY4+kdua8W3aMP5Lalfc+2TH2SGpXI/ludtLNTmNP3Rl7JLUz592yY/xpIV2Qn/St3ny1ltScj6l96oD8NN9czXdA3iFAkqSWkVLKR8QdwNkzFHlaRHSllEZr0PYDEfE3wNtKFHsU8LGI+I0qLkQ+o4joAzaklL5c67YaVUT8DnBdSmljjZt6HrCmxPbrZ1nfXwOfL7F9JfBfEfGc+a7REhFPAf60TLEfN+t5lFLaEhEfB367RLG3RsTni+vjzNf7KSQ5qZmU0nBxvPn7EsXWA/9A6cVvKxIRvwm8rEyxz6WU5pMk7nZmTnrwqIhYlVLaOo/6JUlqBN9n5qQHAM8G/rlOfVFr+UPgKcApJco8Eag06cGeMtuXVVjPrBTvYR9Ri7olSZIkqRo6su6ASkspjaaUtqSU7k4p3Z5S+nlKabMJDyRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkjQH3y+xbTnw2hq2/V4KC3eX8gLgWxFxXK06ERErI+LPgLuBv6xVO03iOcCtEXF5RDyuFg1ExLHApWWKfWmW1X4RuK5MmV8F/jMiOmdZ90Mi4vHAZ4GuMkX/bK5tNIh3ASMlti8BPh8R80pWEBFvBF45nzpm4V+Bn5cp85qIeOd8GomI5wH/VqbYCPDm+bRD6bG7A3jTPOuXJKkRfK3M9l+rSy/UcopJ9cpds62bZX27ShSZKVnVfD0K6KlR3ZIkSZI0byY9kCRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJktpHuYVE/yYi3hgRC6vdcEppAHgpMFym6PnAjyLidRGxoBptR0RnRDwtIj4G3Au8G1hbjbpbQAfwIuDbEfGjiPiDiFhVjYoj4onA94BS9e0HPjGbelNKeeD3KL1QP8BFwNci4qjZ1A8QEa+m8H5ZUqboJ1NKV822/kaSUrqT8okpTge+GREnzbb+iMhFxNuAv5lD9+YkpTQI/H4FRf+8mPRj2Wzqj4iuiHgLcAXQXab4+1JKt86m/mmUG7vfEBHvjojl82xHkqQsfREYLbH9aRFxdr06o5bz7TLbZ5vg6xcltj18lnVV6v/VqF5JkiRJqopyGaQlSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIktY7/BfYBi2bY3kthYfK3RcS3gFuAB4v7lFpg/oGU0pXlGk8p3RgRvwN8DMiVKLoC+EcgRcQ/A18AfpxSGivXxoSIOAV4HPBU4BnAykr3bWOPKD7eHxHfBb4EXAvckFIql6wCgIjoATZQWHD+uRXs8jcppd2z7WhK6ZaI+DPg/WWKXghsjIgPAP+cUrpvpoIR0QE8E/hL4LEVdONu4OKKOtz4EvDrwAklypxOISHJWykcy7LnRHFh4r8HnjTN5huBc2bb0UqllL4aEf8A/EGZoi8CnhwR7wX+PaW0Y6aCxfP7+cCbKRyPcn4IvK2yHs8spfTDiLgLOHGGIh3AnwGXRMR1wM3AfRSSigyVqHpvSuny+fZPkqRqSCntjIgvA8+ZoUgOeAeVXWNKU20rs713lvVtZObkBidExJqU0oOzrHNGEbEE+J1q1SdJkiRJtWDSA0mSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJKlNpJT2R8S/An9UpuhCCokCnlFh1d8EyiY9KPbhsohYRfnF6gGOAN5SfOyLiO8AdwE7io+9QA/QD6wG1gEnA6cBSyvsuw7XCTyh+AAYjoiNwG3AvRQSYeynkAhjAYUkGkcDD6OQNGFxhe3cCLxnrp1MKf1dRJwHvKxM0YUUEhn8RUTcQGEh+rsonD/dwCrgDAoJEipNjrEPeH5Kaeccut5wUkp7I+IiCu/lUusSLQE+QOFYfgK4isIC+1sonA9LgJOAxwDPo5AAYzqjFBZtvaEa/S/hjRQSK1xQptwRwHuBd0bE94v9uofC69wHrAHOonCOVHp+bwZeUGnCkAp8APiHMmV6gCcXH5W4BzDpgSSpkfwjMyc9AHhORDwtpfTVenVILeOIMttnm4jtRuCFM2zLAS+m/LXbbLyWwrW2JEmSJDUskx5IktTsctxa5xYfqHN7jWozPeP1ay2Xv7l+jUlqZ4MDveQXjZMb6ACgZ3wMhgs/93UOsXdoQZbda2uDA7NNCC9JzWPPaD+5fR3kF43TNz7KnvFCvOnrHGKwo4vcvo6Me9i+jD+SWtXgQC/0j5MnR9/4KIMdXQ/d+/T0DZLbtzDjHrYvY4+kVuW8W+My9khqZc67NS7jj6RW5bxb4zL2SGpVzrs1LmOPpFbWjPNuGYzLfvdIkqTm8VfAb1BYxDsTxcXq9wAforDAfiUWAU+rXa9UQg+FBd/PqmKd9wPPSykNzrOe36KwCH2pxXEn5IDzio/5GACek1L68TzraSgppe9ExO8D/1pB8dXAG4qPuXhzSulHETHH3SuTUhqJiOdQSM5wfgW7dAGPLz7mYxvwKymlX8yznsn+BXg1cGYV65QkqaGklK4qJql6ZIlin4qIR6eUflavfqkllDqnoJAUbTauK7P9NyPiH1NK+VnWe5iIOBN423zrkSRJkqRaa7y/npIkSbOy/q1fujPfPzpUp+ZuOfXDn9xRp7Ya2mkXXbud7vFb8wtGat5Wvn90aP1br5zthLgkzcnIcDd7hvrJLx5nfNkovfk8++iD/V30do7SmRslv6076262pZHhbvbscgEISa1p/1gfo/2Q29dB94ohOkZzjO3vprdzlL6+gcKXRLeavzULxh9Jrapw77OA3GCO7hVDhUUI6C/c+/SNsG+s19iTEWOPpFblvFvjMvZIamXOuzUu44+kVuW8W+My9khqVc67NS5jj6RW1ozzbnUel2855+Rr/e6RJElNIqW0E3g+cCDjfvw7hSQG92fZD2XiTmBDSunu+VaUUhoBXgB8dL51VWgL8NSU0jV1aq+uUkr/Bry5xs18NKX0nhq38ZCU0h4KY82X69TkncAFKaVbqllp8Vx/PrC1mvVKktSA/rjM9uXAFyNibT06AxARz40I126ssog4ISJeFRE1/XA3IjqB3y1T7PpZVvs9YFeJ7ecCr5hlnYeJiEXAJ4G++dYlSZIkSbXmjbMkSa1gxeCb6tTS6+rUTrO4OH/Krtq3Ur/XV5IA+OkP1zP81F3ke8YBGMl1kPvZMgAeuWojt37/5Ax7195++sP1WXdBkmrmxlVH0HPVMoafuovzdj7IT7cU4s0jV23k+uVr6LlqWbYdbGPGH0mt6qc/XA9DuYdiz/XL1zx07zNy8l5jT4aMPZJalfNujcvYI6mVOe/WuIw/klqV826Ny9gjqVU579a4jD2SWlkzzrvVcVz2u0eSJDWZlNK3gScCGzPux9XAw4GPAfk6N78D+N86t9nu8hSSE5yfUrqjWpWmlIZTSq8Efh/YV616p/EN4Lzi+6dlpZT+Gng9MFaD6v8FeFUN6i0ppbQbeDYQwEgNm7qCwvl9Wy0qL75vHgN8vxb1S5LUCFJK36Rwf1DKeuDHEXFhrfoRET0R8RsR8WPg87h2Yy0sBf4N+FlEXBIRS2vUzjuBs0ps3wzcMJsKU0rDFM6LUv4mIk6aTb2TRcQa4BrgzLnWIUmSJEn15I2zJEktYH188QP5o/Zdku8fHapF/fnO8U3AhlM//MlralF/szrtomuvYfnwhvGztm3KL6j+3zTk+0eH8kftu2R9fPEDVa9ckkrYvmU5195xJrsfPczoCQMsW7ifnfuXMHDTGlaP7+OYBQ9w51dOYnxbTZOkaxrbtyznuqvOZc+uhVl3RZKq7s6BNfyoby25nyxk2VPu5aiBQW6781RWju/njBNv5wcjRzFy+VpyW7uy7mrbMf5IalXbtyznWzc9nMHxbpY99V7OyD3I93PHsf+mtSxbtIfdC8cZu3yNsScDxh5Jrcp5t8Zl7JHUypx3a1zGH0mtynm3xmXskdSqnHdrXMYeSa2sGefdaj0uj450bgI2nHPytdfUpAFJklRTKaUfUUg48Grgxgz7sT2l9JvAo4AvAeM1bG4U+CLwAmBdSumdNWyrGfwR8EYKC2mO1ritG4DHpZRemVLaWYsGUkr/DJwBXE51z6NfAL+dUnpySumXVay3YaWULgUupPC7V8N+4HUppdemlGqRTKGslNJ4SultwLnA/1W5+luB56aUXlSr83tCSuku4LHAS4DrqH/CGEmS6uF1wM/LlFkLfC0i/jYijqxWwxFxdkT8DYXroMuAc6pVt2Z0HPB+4N6I+EhEPCkicvOtNCIWRMSHgD8tU/TDKaW53D/8S5ntq4BrImLW2Ykj4inAd4FHzqFfkiRJkpSJxvmLqRYWEb3ASqAb2AXsSSn5QYEkqaqKC+N/YOPbn3Ui+dxhWVn3sGjpGB2dU5/vZHysl327p610b8/W3K7ejes/dPmOqne4RZx20bXXACfcftkFK/Lb+tbndvesqkrFufzN69965V1VqUuS5mD7luX835bz6O4ZYfHaAZaMD7Cws4v8rmV0j47R1znKL75xDHTk6e0p/TeMPR1jm3PkR3K5/GAH+QOMdezeOb5gBHhKfX6b1rJ9y3K+ceVj6O4Zoa//0HxHY2PmNpTU3O4cWMOdrGHBrYOsWLmX/u5hbtp7Eh1jY6xcuJv78gsY/9rx9HSO0tlf+u+aezrGNneQH8gxvj+Xy+3bNbpgGLigPr9J65kp/hh7JDW77VuW8+UthfFt+Zq9LM3t52fDy8jvWEb/+ChdnaOMf/0YOjryFceejo78MOT3jo937N49ugC895kT730ktSrn3RqXsUdSK3PerXE57yapVTnv1ri895HUqpx3a1zGHkmtrBrzbgfGeura51Lj8oTx8ZnXj+romP5rsQsXDzzuNb9z6Xer0klJkpSZlNIw8G/Av0XE8RQWOT8POBU4GjgCWAz0ADW9qUsp3QA8JyJOAl4J/D/g9CpUfQfwteLj6pTS9N+vbkPFxdP/FvjbiFgKPA14IoUF1c+msF7KfGylkIDgv1JKP5hnXRVJKf0CeElEvA14LfBiYM0cqhoHrgU+CnwipTRSrT42i5TSdRFxGoVFYt8ALJtDNaPAp4C3pJQ2Va1z85BSuhl4RkScR+EceR5z+91GgK8C/w58rp5rChXbuhy4PCLWAhsoJI5ZDxxLYYHdJUAvNR67JUmqhZTS3oj4NQoJfpaVKNpJIZHX6yLi48AngO+mlPZX2lZErKFw/ftk4FeBk+bab83bIgr3gq8EHoyILwFXAdellO6rtJLive0LgT+m/L3ADuDv5tLZlNL3IuKbwJNKFDsa+ElEvA/4u5TS9pkKRkQPhfuxNwLPmKbIbuDzwCvm0l9JkiRJqrVcPu/a+9UWEacDz+fgBwELpim2E7ibwoeiNwM/AX6UUtpcr35Kqq6IuIXp/1ji1pTSGfXujzRVRKxm+oRHoymlLfXujyTNJCLOoHCNrNZxZkrplslP+DpLkurgkPhj7JEk1YH3PpKkejP2SJKy4LybJKnevPeRJNWbsUeSpNk7LH5KkiRVW3GxysdwMBHDscBaYCHQT2FB9b2THluBjcDtxcdNrucxNxHRT+G4P4zCwq8nA8cDyyksRrqYQlKEvcCe4mMbcBPw4+Lj5pRS6WyUNRYRnRR+jycC51L4XY6h0P+Jc+gAhb7fTeG8+TbwzZTSg1n0uRFFxELgpRSSkVzI9GvqTBgCfgh8EfhkSumXNe/gPBQXl30shXPk4RTOkaMonOf9wDCFc+RB4C7gVgrnyLUppZ1Z9FlSeS/Z+k8usKaG86lVF8+ceVTTiognAF+hcP1fqVHgBgqf8+0oPnZSSJDQB6ykcE9xAnAasK7Certne20bEaXGokgpvW029dWr7jLt/hbwHyWKnFBpsquIOIfCfUMlNgO3ULgeu5/CazpI4XVdRCE5xqnAmRQSQVXqpSmlT82i/CEi4hEUrn07Kyg+Bny3WH4LhSQGy4HVwIkU1q9cVGL/FwFnAGmmAimlOY8zEXENMydw+GZK6cK51l2izQuBb5QosiGldE0N2r2GOv+ukiRJUjuYbuFjzVExK/VfA78GTNzszXTTt6L4OHdKHVso3Hj/aOLflNLdNemwJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS1MCKi2VuAua8CKXmJqU0AHyr+GhaKaUx4PvFh+YopbQf+DDw4WIiiYlEGEuBXmA/hcQXm4A7i8e9KaSUhoFvFh+SJKmBpJSui4gNwJXAqgp36wIeXXyodawtPp5SxTrfNZ+EBwAppR9HxF9RIhHBJJ3AE4qP2frLlNIVEXHGHPaVJEmSpLow6UGVRMTzKWQcXMihiQ5KZUDMcXhShDXA04uPibr3ADdyMBHCj4HbUkrj8+64JEmS1Hg2Z90BVd0D0zzn6yxJqrWp8cfYI0mqNe99JEn1ZuyRJGXBeTdJUr157yNJqjdjjyRJszdd/JQkSZLU4ooJDe4oPiRJkmoqpfTDiDgf+ATw2Kz7o5bxjpTSW6tU19uBM4HnV6m+qd6VUnpnjeqWJEmSpKrpyLoDrSAifhP4b2ARhSQG+UkPOJjcYPKDKeUmP6aWXQpcALwB+E/gp8DeiPheRPxzRPxuRJwXEb21/U0lSZKk2kspbQduzbofqppbUko7pj7p61xTQ1l3QJIawGHxx9hTU8YeSfLeJwvGH0ntzthTf8YeSXLerd6MPZLkvU8WjD+S2p2xp/6MPZLU/GPhtPFTkiRJkiRJkqotpbSJwnp8bwb217n5YeCzwFid21Vt3AP8WhUTHpBSGgdeBnyqWnUWjQCvSSn9RZXrlSRJkqSa6Mq6A80uIh4B/DMHkx1MyE2/R9ntk5MllCrfD5wPPGrSc2MRcRvw4+LjR8CNKaW9ZfoiaZKIeBuQsu6HJElt7mLgG1l3QlXxuhLbfJ1r403A32XdCUnK2Ezxx9hTG8YeSfLeJwvGH0ntzthTf8YeSXLerd6MPZLkvU8WjD+S2p2xp/6MPZLU/GNhqfgpSZIkSZIkSVWVUhoF/joiPgK8BXgFsLCGTf4Q+E/gkyaArZlbgOcCzwaeBRxVw7YGgb8F3plSOlDtylNKw8BLI+K7wDuZ/7l5A/A7KaWfzLtzkiRJklQnHVl3oAV8EOjjYKKCHIcnKMhX8GDK/pMfM9UxtXwXcBbwcuD9wDXAroj4WURcHhFvioinR8Sy+f7SkiRJUi2llK4BNlD4YErN6RZgQ/G1nJavc9VNHPMP4HGV1L5Kxh9jT9UZeyTJe58sGH8ktTtjT/0ZeyTJebd6M/ZIkvc+WTD+SGp3xp76M/ZIUvOPhWXjpyRJkiRJkiTVSkrpgZTS7wNHA38AXAuMVaHqB4FPAr8DHJtSOj+l9E8mPKidlNJISumLKaXXpJSOBs4F/hT4HIXXY77yFM6P3wXWppTeXIuEB5OllP4BOBX4ALB7DlVcD7wYON+EB5IkSZKaTS6fz5cvpWlFxAbg6xRuZqcmOoBDExOUMtOLUGq/2e4zuXyklN5epk9S24qItwGpilXemlI6o4r1SXMSEaspJMiZajSltKXe/ZGkSkXECmDdLHdbAqyaYdtWYE+N96lHG42wz0wemO0HtrN4nUv1c7JBCgnqmr1cpcd+2mNep/dPI5+jzf6+rub5vrX4b7n6qlluKbCr+PPKSc+PcfgH85W2C/N//0w9rnN5nabbN+tztJr7NGq/yplV/GmC2JPF+3aiXKPHnmrvk/V53Ujv6yxiT6X1NUO5eseecvs02xjfqO/rUrK+98kyVlRSDup773MG0DnNPmPA1H2yPkeruU+j9qvSfRr9Pr/R32f1iD1T98/6/GmG87oa+8wk69gDjX9N5rxb8+3jvFtjlIPGvffJ+hydaZ8VwDIOnfuEg/Ofzfa+LqVZ5t0a/X3WDLGn2vtkfV430j2Z827zK9cM9z6Neo5We5+GjD3gvFuZOusZf7I+R6u5T6P1awUH5z8Xc/A6dOrn7867Va9co8eeau/TbO/Rue4zk6xjDzT+NVmjxh5o/jG+Vvs479YY5aCx7n0aKfZUc59G7Vc5sx0LZ2p/EbAcWEDh7zahcM4tAvZNKtNbLANwABiapq59FM7ZBcB+YKD4/K7iPluAe0r1X5IkSZIkSZKyVJxjfQxwPnA6cBxwFIV50gUU1ujbR2FOdy+wE7gTuL34uDWl9LP691ylRMSJwCOAk4uPkyjMpS+m8NouAoYpvK57KPwtxd3Aj4EbgRuyXF8rInqBpwEXUEjocAKFOf9+YITCuXg/hWTDPwS+mFL6eTa9lSRJkqT5M+nBPETEJ4CXMH3Sg8nP3QB8FdhE4WZ4KXAMhQx8pxUf3dPsP525JEKYvF8ekx5IJZn0QK1ghj9yXjGwqv+o4eW9Jx7ybEdubKy/a9/kp8Y7cyvHezqPfOj/3R37xrs6Bw8p09+xm9H8cMdIvuQfxs+mXNeekV2dA6PLRpb0Lq1XOYCu/cPbcmP57nLlcuR/QS63ecZ69gwv6t4zvLxn99CdCx7Yf2+puirkH4Fn4IXjX5nLF6Zm8sAVHc/wNaxAlY87eOzrbo5fNizFMbBCVT72HvcMtOoY2OhJt1r1uLcbx8BsGPebn2NgdrznbH6Ogdmo8LhPXvRrsumSHnjcM+AYmA3jfvMz9mTHe87m5xiYjXY57o0+/zlfjoHZMO43v3YZAxuR95zNzzEwGx735lHq+vPmtzx6FMfAujPuNz/HwOx4z9n8HAOz4XFvbRGxYs+py9fvP3bxId+76dozvIh8/qip33XpHBjty42Prxxd2L2AKfJduQP5zo6hjrHxfYxy+PeAyN3XOTh2yHeIOkbHb/7gk37nrol+DC/uPrlr/+jizoHRZaMLu/pHFvUs7hge64X8suGV/R0dQ2M9XQOjfWO9nd1j/V29HUNjXbnx8f6xvq5DviOb72AkR26APKP5DoZysJdxhvNduQM52D7Rv8n9Gly7YOv+E5buwXNUkiRJkiRJkiRJkiRJakomPZiHiLgPWFv87+SkAhM/bwJelVK6ukw9XcDDgEdSyCR4LnA2hcyBk80lEcLk/XKY9EAqy6QHamYRsQG4lEKm4YfsO24JWy48iuHlfYftk+/IMbaw8HfFfZv3Md7TxfCKw8tNVu1yCzftZulPtrH9cesYWnXY31xnXq6chZt2s+7L99C3bWDOdZRwK3BxSumaWlSug144/pVp3z9VcCtw8RUdz7imyvW2hBoed/DY18VMsadKHANLqOGx97jXSauPgY266FerH/d24RiYDeN+83MMzI73nM3PMTAbHvfW4BiYDeN+83MMzI73nM3PMTAb7XbcG3X+c74cA7Nh3G9+7TYGNhLvOZufY2A2PO7NZ7rrz3tedOrjBo5c+Feji3vWV7k5x8ASjPvNzzEwO95zNj/HwGx43FtbRGzYe/LSj2z+lWOPn/ydlpm+61Kt78BMtXDTbpb9eGt+2xOOzHXtH2HdlZsY6+/iwScfTdeBERbfuoOd562hc2CUNdfcx+jCbh545nF07R+pSX8m8RyVJEmSJEmSJEmSJEmSmoxJD+YoIk4Afs6hSQ4mJxf4OfDElNLmOdafA06hkADhXArJEB4BrJhStNJECBP9NOmBVCMRcQvT/xGxSQ9UF8UvghyWaGffcUvY9IqH0bl/hNz44WFjIulB3+Z9DK6dmm/ncNUut3DTblZdez+bXvGwhixXzsJNuznhv26fVx0V2uCXcWqn+GWQkomqqmCDf2x/qDodd/DY18xMsacGHAOnqNOx97jXUDuMgY246Fc7HPd24BiYDeN+83MMzI73nM3PMTAbHvfW4BiYDeN+83MMzI73nM3PMTAb7XjcG3H+c74cA7Nh3G9+7TgGNgrvOZufY2A2PO7Naer1ZzHhwRUTf/9ZI46BUxj3m59jYHa852x+joHZ8Li3tojYsO+4JVdP/U7LTN91qdZ3YKaaXO/E92P2H72IX77gFBb8cg8rv/cgv3xh4edjP/Pzh76jVKv+zMBzVJIkSZIkSZIkSZIkSWoS033xUpU5esr/Jyc8GAcummvCA4CUUh64o/j41MTzEXEcheQHk5MhrJumL2azkKT2c+l0Tz7wzOMq2nm8p7LLgmqXW/fle/jlC05u2HKV1FMnlwJn1quxNjTt+6cGbfgaHqoex32iHY99bfgaZsdxq/n5/smGx701OAZmw/dP8/M1zI7jVvPz/ZMNj3trcAzMhu+f5udrmB3Hrebn+ycbHvfW4BiYDd8/zc/XMDuOW83P9082PO4tYHDtgr+uQzO+hofz/dP8fA2z47Vb8/P9kw2Pe2u7dLrv+8z0XZdqfQemVL0T34958CnHALD66vu4/9nHP/QzHPyOUq36MwPPUUmSJEmSJEmSJEmSJKlJdGTdgSa2cprnchSSDXwtpfT9WjSaUronpfS5lNJbU0rPTikdBawFngW8GfgscE+xL5MfYCIESWpZEbESOH3q86P9XQytWlB2/44DIwyv6Kt7uc4DI3TtHynbx6zKldN5YIS+bQPzqmMWzoiIFfVqrJ28cPwr075/auCMF45/xdewqI7HHTz2NTFT7KkRx8BJ6njsPe414hiYDY97a3AMzIZxv/k5BmbHe87m5xiYDY97a3AMzIZxv/k5BmbHe87m5xiYDY97a3AMzIZxv/k5BmbHe87m5xiYDY97a9jxiFXL8x25U+vQlGPgJMb95ucYmB3vOZufY2A2PO6tLSJWjvZ3nT71Oy0zfdelWt+BmWpyvRPfjxnt72JoZT+dAyN0DYwwXPy5b+cgo32dD5WtRX9K8ByVJEmSJEmSJEmSJEmSmkRX1h1oYktKbPtU3XoBpJS2AF8uPgCIiGXAI4Bzi49HAKdiogtJalVrp3tydFF3RTt3DowyvqB82WqX69o3UlEfsypXST11tg7YUe9G28C0758a8TU8qJ7HHTz2teBrmB3Hrebn+ycbHvfW4BiYDd8/zc/XMDuOW83P9082PO6twTEwG75/mp+vYXYct5qf759seNxbg2NgNnz/ND9fw+w4bjU/3z/Z8Li3gIF1C1fVsTlfw4N8/zQ/X8PseO3W/Hz/ZMPj3trWTvedlpm+61Kt78CUqnfi+zET/+/cP8rogoM/A4wu7D5svzryHJUkSZIkSZIkSZIkSZKagEkP5u5AiW3fr1svZpBS2gV8o/gAICIWAOcA+7PplSRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiSplZj0YO72lNh2f916MQsppQPAd7LuhyRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiSpNXRk3YEmtqnEtn316oQkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSVkx6cHc3QkMFn/OT9m2os59kSRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiSp7kx6MEcppXHgx0Bums2r69wdSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZLqzqQH8/O/Mzx/bF17IUmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElSBkx6MD9fmOH5X6lrLyRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJyoBJD+YhpXQT8D0gN+npHPCMbHokSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSVL9mPRg/v5p0s/54r+nRcQjs+iMJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEn1YtKD+fskcOs0z0e9OyJJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJUj11Zd2BZpdSGo+INwL/C+SLjxzwzIh4fErp25l2UJIkSZJqY0md2zspIh5IKe2oc7uSpMZSz/hzUkQAGH8kqb157yNJqjdjjyQpC867SZLqzXsfSVK9GXskSXUXESuAdUct2Lrk6PzOE/oO5JcDrO9cdNpPOPmw8r0jQ9PWM9Pz/UMDLB7YN+t+5QbH6Ng/Rv/2/bPet5S59mc6e/sXMdDbX5W6JEmSJEmSJEmSJEmSJNWPSQ+qIKX0lYj4GPAKDk18cFlEnJdS2p5pByVJkiSpSiJiA3ApcHqdm/58sf1bgYtTStfUuf2GUDz+/5Z1PySp3ibiz4qe3afvGF5ar2Y/P6n9to0/xh5J7cp7n8ydn3UHJKnejD3Z8t5HUrty3i07xh5J7cp7n8w57yap7Rh7suW9j6R2NRF/VvftOP38nrtYdHcvuQPdbF7ZxQ1L1rFndOEh5U94cBPPvv6r9G4d4HNsqPj51bu3zapfDw4s50dbT6Wvc5hzV90BcEi9lTpq+/3T9n+2/Slny9Ij+OJ5T2fTmuOqWq8kSZIkSZIkSZIkSZKk2unIugMt5HXAXVOeOxb4eETkMuiPJEmSJFVV8Qs4VwOnr+jZnVU3Tge+EREXZtWBrEwc/xU9u0/Kui+SVE8T49/qvh2nn993Z1bdaMv4Y+yR1K4m3/scP17dL+TPQlvGHnjo+H8k635IUj0575Yt730ktSvn3bJj7JHUrpx3y5bzbpLakfNu2fLeR1K7mjzvtmHBLSy+ZdFDCQ++seDkaRMe/PbXP3FYwoDZPl/OgwPLueb+c+nrHGbDUT9mac/+Q7ZPTWSwbueD0/58woObeN73r5x3fyqxevc2fufrH+f4B++pet2SJEmSJEmSJEmSJEmSasOkB1WSUtoHPAvYUXwqD+SApwKfjoierPomSZIkSVVy6cQPD1uxKcNuAJP60kYuhYY49pJUb5cCnLvqDnK/WNwQfWkjxh5J7eqh8X797l0ZdgNov9gD7fk7S5Lzbtny3kdSu3LeLTvGHkntynm3bLXj7yxJzrtly3sfSe3q4Lzbz5Y99OQNS9ZNW/jZ13+1Ks+X86OtpzLRr+lceMu3D/n/Yzf+cNqfp7Y/1/7MxrOv/7+atyFJkiRJkiRJkiRJkiSpOkx6MA8RsTQilk/8P6W0EXg2sI9CwoOJxAe/Dnw1IpZm0U9JkiRJmq+IWAmcDtDTMcJiBjPuEWdExIqsO1EvE8e/p2OExd0DdWt3df+OJXVrTJKmMXn8W5obIDfQlXWX2ib+ZBV7JClrk+99FuUH6RzM/KO0tok9cPD4d+VGsu6KJNWN827Zct5NUrty3i07zrtJalfOu2XLeTdJ7ch5t2w57yapXR0273agG4DBbtgzuvCw8v1DB1i9e9u8ny9naKyLPSOL6OkYYWnP/mnrXbFv16T/D7DswG4A+ib93JsbPqT9ufZnttbs3sZp997hGC9JkiRJkiRJkiRJkiQ1gcy/MdLkLgS2RcQdEfFfEfE6YBx4KvBAscxE4oMLgFsj4nmZ9FSSJEmS5mftxA99nUMw0hC3k+uy7kAdrYXisa+j5T17V9W1QUk63MHxb7ghYg+0T/zJJPZIUgN46N5nCQ2z+GS7xB4oHv/eThdfk9RWnHfLlvNuktqV827Zcd5NUrty3i1bzrtJakfOu2XLeTdJ7WraebfBvunj0OKBwxMQzOX5cgbHenmoXxXUu3DwwEM/L5r0c19uuCr9mYvjtvzSMV6SJEmSJEmSJEmSJElqAl1Zd6AF5ICTio+XFZ8bBrYVt+U5mPhgHXBFRFwJvCOl9MP6d1eSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSpOow6UH15Cb93AscOeX5/KT/Pwt4VkTcAFwKXJlS2l6XXkqSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSVCUmPaie/JT/56b5f774mNh2HvAfQD4ibgK+Dnwb+FFK6Z4a9lWS1Ho2T/dk176RinYe66/skqDa5UYXdVfUx6zKVVJPnT1Q7wbbxLTvnxrxNTyonscdPPZV19c5nHUX2lZf51Dd2jqif9fWujXWXhwDs+FxbwF946NZd6Et1TP2FPn+qT7HwOx4z9nkjD3ZyDFe7yZ9/9SGY2A2jPtNznm37Djv1hIcA7PhcW8B3vtkw3m3luAYmB3vOZucsScbzru1hv4H9m/de+ryejXna3iQcb/JOe+WHefdWoJjYDY87i1uuu+09HUOzer5+Zpc78R4PfH/3o5hug4c/Bmg88AoLKldf0o5cudmx3hJkiRJkiRJkiRJkiSpCXRk3YEWkpv0gMOTIEwuk5+0PUfhdTgbuAT4NHBXRGyLiK9GxLsj4kURcXJNey9Jamoppe3ArVOf7xoYpXfrgbL7jy/opmfHYN3LjS3oZnRhd9k+ZlWunLEF3Qwe0T+vOmbhlpTSjno11k6u6HjGtO+fGrjlio5n+BoW1fG4g8e+Jno7RlkyUveFWAT0do6ypHtfzdtZ0r2Poxdu21PzhtqQY2A2PO6toXd83PiTgXrFHoCO3Nid3vtUn2NgdrznbH7Gnmx05DD2tADHwGwY95uf827Zcd6t+TkGZsPj3hq898mG827NzzEwO95zNj9jTzacd2sNK368dWduPH9HHZpyDJzEuN/8nHfLjvNuzc8xMBse99bXNTBK985Dv3fT2znKitFdFT8/X5PrnRivuwZG6d5d+P+y0T107R6it3OURV376Rgaq2l/SjnxwXsc4yVJkiRJkiRJkiRJkqQmYNKD6pmayCBXouzU5AdT98sBK4CnAH8CfBLYGBG7IuIbEfG3EfEbEfGwiCjVjiSpvVw83ZPrvrypop07hscyKffAM4+vqI9Zlauknjp5Xb0aalPTvn+qzNfwcPU47uCxr5nzdj6YdRfa1iNXbWyJNtqcY2A2PO4twPiTjXrFhaMWbPvrujTUnhwDs+M9Z5Mz9mTD2NMyHAOzYdxvcsae7Djv1hIcA7PhcW8Bxp9seO/TEhwDs+M9Z5Mz9mTD2NMa+jbv/4s6NOMYeDjjfpMz9mTHebeW4BiYDY97i1v1rfsOe+6RqzbO6vn5mlzvxFi68nubAXj4yp+z8vsHf65HfyRJkiRJkiRJkiRJkiQ1N5MeVMfkJAf5aR5z3S835bEEuAB4A/Ax4GZgT0RcFxH/EBG/FRFnRURn9X41SVKzSCldA2wAbpn8/KJ79nL8x26ld9tAyf0H1y6kb/N+enYM1rXc/uOXsPWCoznyCz+nd8uBhitXzv7jl3D3yx/G4Kr+OddRxi3AhuLrqxq5ouMZ1zDN+6dKbgE2FNvQJDU+7uCxr7k1Qwd48pZfsHRkKOuutJ3V/bvYcOQNLOneV/W6l3TvY8ORN7C6f1fV69ZBjoHZ8Li3BuNPNmoZe+Bg/Hnc2pt/WJMG5BiYIe85m5+xJxvGntbgGJgN437zM/Zkx3m35ucYmA2Pe2sw/mTDe5/m5xiYHe85m5+xJxvGntZw3H//7Lv99+97QW48f3sNqncMnIFxv/kZe7LjvFvzcwzMhse99S24f/9hz63u38WFo4dfTs/0/HxNrndivD5i+zYAjujbzePGbnzo53OP2DjtfpIkSZIkSZIkSZIkSZI0oSvrDjS5bwO/C5wLPAJ4OLBgSpmZEh/kZvh5NvsBLAQeW3xMGIqIm4AfFR83ADellEam/zUkSa2iuDD+mRGxAlg38fyie/ay6GO3rRhY1X/U8PLeEw/ZqSM3Ntbfdcg3SMY7cyvHezqPfOj/3R37xrs6D8leMN7fsXvBz3cNd4zkV5XqU6XlDhyzaPfi23bsWvajLctGlvQurVe5wSMWsPQnW7flxvLdpcoB5Mj/glxu83Tbdp69iq49w4u69wwv79k9dOeCB/bfW6quCj2QUtpRhXpUgeKXNc584fhXDnn/zNMDV3Q8w9ewhBodd/DY182aoQP86ua7GeroYLCji71d3Xxr1TFZd6strO7fxTOP/T5DY10MjvVWpc6+ziF6O0erUpfKcwzMhse9NUyOP1t7+o09dVKL2APGn3pyDMyO95zNz3ufbMwm9gyNdZGf5iO3HPnD4oyxp74cA7Nh3G9+xp7sOO/W/BwDs+Fxbw3Ou2XDebfm5xiYHe85m5/3Ptkw9rSG4/77Z98FnnTzWx49imNg3Rj3m5+xJzvOuzU/x8BseNzb08q+vbN6vprtre7fxZLu/Q99/r689+DXjSb/XMv+SJIkSZIkSZIkSZIkSWpeJj2Yh5TSNuDfiw8iIgecRiEBwiMoJEM4B1g+ZdeZEhrAwaQG80mE0Ac8Cjhv0nMjEXErhSQIH0kpfWeG9iVJLaC4UP4hf4AeEav7tw78vH/rwLVTio+mlLbUr3dSYyt+ecMvcNSZx7359Y6P0zs+nHU32lJv56hf3GxyjoHZ8Li3ht7xcRaPmuez3ow9zc8xMDse++bnvU82Kok9g6PdMyY96OvyeqEROAZmw+Pe/Iw92fHep/k5BmbD494anHfLhrGn+TkGZsdj3/y898mGsac1OAZmw+Pe/Iw92TH+ND/HwGx43CVJkiRJkiRJkiRJkiRJzcCkB1WUUsoDtxUfn5h4PiKOo5AAYXIyhHVTds9P+XeyuSZCmFy+h0IChrOBXwAmPZAkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkzYtJD+ogpXQPcA/wPxPPRcQqCskPJidDOJHDExuUSmow+d/Z7CNJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ0ryZ9CAjKaWtwP8VHwBExBLgHAoJECaSIZzG4a/TXBMhqAVFRNav7VNTSl/LuA+SJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSMmDSgwaSUtoDXFt8ABARvcDDKSRAmEiGcBbQN2X3cokQJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmqKpMeNLiU0hDww+IDgIjoAB5GIQHCRDKEc4ClU3afKRGCJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnzZtKDJpRSGgduKT7+a+L5iDiRQgKEyckQ1mTRR0mSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElS6zPpQQtJKd0F3AV8ZuK5iFjHwQQIE8kQ8pl0UJIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZLUUkx60OJSSg8ADwD/O/FcxP9n777jZD/LuvF/9uSkh4QECCEIhBJAWmgiSO+goDw+FoTggyIdVBR9FMvFZUMFBAWVokhVBAs+gPgThBB6ByFIJxAgQEhCejs5+/tjZslmszuzZXZmd8/7/Xp9X2f2e99z3dfMzu7Mzp69Pz03u44AAAAAAAAAAAAAAAAAAAAAAAAAAAAAANgphB7sg6pqftY9MDVvTPL/NnmNT29yfQAAAAAAAAAAAAAAAAAAAAAAAAAAAABgixJ6ADvbR6vqb2bdBAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwM+2adQMAAABsC99cuHDx5QcmB+xddtJBe/dMraEkp09zsRn7ZjK876drX7qPga3piu9/W+O5J9l3vjd67gH2Vd/72efcHLziJD/7bJpZPP/sS/cvsDV53222/OwD7Ku87zY7nnuAfZX33WbL+27Avsj7brPlZx9gX7Xs+24HXbz889C0vk8etN8lU11vk/geDwAAAAAAAAAA24DQAwAAAMaqqjOTfDpJLt27f86ZPzjzh1x2lXkH7t2bwy+7ZBotnVJVZ01joa1g4f6/dO/+OefSQ6e17Ck3P/HkfeY+BramK33/m/1zT7IPPf947gH2VYt/9jl/7qBcfvDly87zs8/mmMHzj+ceYOa87zZbfvYB9lXed5sdzz3Avsr7brPlfTdgX+R9t9nysw+wr1rpfbeDLksO333BVeZP6/vkgfvtyeH7nz+19TaB7/EAAAAAAAAAALBNCD0AAABgtZ68cOEjZ9ws88d/d9lJdzz7W9Po5SnTWGSLeXIyuO+nZF+8j4Gt6Xvf/2b83JPse98bPfcA+6rv/ezz8aOuueIkP/tsmmk+/+yL9y+wNXnfbbb87APsq7zvNjuee4B9lffdZsv7bsC+yPtus+VnH2Bftez7bnc49/RlJ0/r++QdrvXZqa43Yb7HAwAAAAAAAADANiH0AAAAgFWpqpOS3DvJKWdcfGTefuGtct4tz8/8IZddad61L7kw9/n2V3PEZZdsRhunJLn3sJd9ysL9f8bFR57y9q/fPudceuhmLXVKknvf/MSTT9qsBQDW4krf/2bz3JPso88/nnuAfdXin30+t+va+ch1j8zlB19+lXl+9tkcU3r+8dwDbCned5stP/sA+yrvu82O5x5gX+V9t9nyvhuwL/K+22z52QfYV630vtsxZ+7JvS/8Qg7ffcGV5p9x8ZHZ5O+TSZKjD/5u7n3sR3LJ5ftPZb0J8T0eAAAAAAAAAAC2mbn5+flZ9wBsQHeP+iLuqnrmtHrZ13X3KUlusczQp6vqltPuB5bq7qOT7F5maE9VfXva/QCwvXX3UUmukyTXPeSMw79v/uwbHnTh/JFL512Y/Q+5IAceMa7e/rn8nP3n9l6YJGflkC98KUd/bZlpp1fVWRvtfSdYuP+ve8gZh1/z4O9eayO1jjzgvDOufcjZ5w4/PP3mJ57sPmYivP5kMyz+/jfJ555LLznw7G/OH/7lbx906LnLTPX8k8k+9yRXev7x3ANsaYt/9rlFvnHda82fd/xy89b6/OO5Z3XW8vxz/mUHHTE/v2u/pefn5vZeftj+F5/juQfYLrzvNlt+9gFWa6e9/+l9t9nx3APsq7zvNlub9H8OPPdsop32+hNmwftus+VnH2BftdL7bpfsnrvGpbt3Hbt0/u799hy4/+49hyw9v2vX5QccuN9l2W9u/tIkmZ/PhXt3z505t/vy7JrbmwP3u+xbB+++7MJlWjg7yflLT37roqtffPoF1zzo4P0uPuyQ3ZccmSS75/Ycsmu/vdk7v9+FF+3Z/1q75/Ze/Xvrz+09cL+5vYfOzc3vPWz3RfO75vYekiRzmT9gbm7+oP3m9l68/37zlybZk8Hr1guTLE4TOj/JxcPL5wzHl+vxjCT+TzMAAAAAAAAAAGxjQg9gmxN6sHUIPWCr80dvAABMk9efAABMk9efAABMk9efAABMk9efAABMk9efAAAAAAAAAADAeu2adQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMD2JPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYl92zbmAWuvtnVxh6T1V9carNbBHuEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1mqfDD1I8vIk88ucf2ySfXWD/5fHfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwBrsq6EHC+YWXV5uw/99kfsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBV2TXrBmZsPjb2X8p9AgAAAAAAAAAAAAAAAAAAAAAAAAAAAADAquyedQMzNhcb/C/lPtmhunv/JDdOcv0kRyU5KMllSS5K8t0kX0tyWlVdNKseAQAAAAAAAAAAAAAAAAAAAAAAAAAAAIDtZV8PPYCd7hbd/adJ7p3k1kkOHDN/b3d/LslHkrw1yVuq6tub3CMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsE0JPYCd7SfXOH9XkpsPj0dmEILw/yX56yRvqqr5CfcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxju2bdALCl7Ury4CT/L8lHuvv+M+4HAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhChB4Aq3W7JP/Z3S/r7sNn3QwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHu7Z90AsO38XJI7d/dDq+qLs24GAAAAAAAAAAAAAAAAAACYrs/9ws/Mz7oHWOqmf/MPc7PuYTvo7nsleceIKfeuqpOm0gwAAAAAAACwY8zNz+97/5egu/cmmU8yt+Tf9yb5/Axbm6VHZ/n75LFV9bIZ9sUY3T2rL+LvJLlXVZ0yo/VXrbufnORJU1jqxkkOXOb8Z5PcYwrrwzjXTLLfMucvz+BrGgAAJsnrTwAApsnrTwAApsnrTwAApsnrTwAApsnrT/Z5VfXtWfewXQg9YCsSerA6Qg8AAAAAAACAzbB71g1sAXOL/v2h4bGv8gv8neVTST6S5JPD47Qk5wyPS5McleQaSY5OcucMNuW/a5LDV1n/mkne1t13raovTbb1ibtWklvMcP25+H7L1rBfVn4seowCADBpXn8CADBNXn8CADBNXn8CADBNXn8CADBNXn8CAAAAAAAAAADr4j8YXZlN/9nOLk/yH0nelOTNVXXamPnfGh6fTnJSkj/u7oOSPDrJ05PceBVrHpPkn7v7LlV18Tr7BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2KaEHVzY/6wZmSODD9nV6kr9J8uKq+vpGCg2DC17U3S9J8otJ/jTJ/mOudtskf5TkVzayNgAAAAAAAAAAAAAAAAAAAAAAAAAAAACw/Qg9uDIb/7MdXb+q9kyyYFXtTfL87n5vktclucGYqzy1u/+uqj45yT4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgK1t16wbmLF5x7IH28ikAw+W1P5gknsk+eqYqbuT/N5m9QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbE27Z90AsLVV1Ve7+38leU+Sg0ZM/dHuPr6qPj+l1tbijCSfnsI6N05y4DLn55NsWjgFrMHlI857jAIAMGlefwIAME1efwIAME1efwIAME1efwIAME1efwIAAAAAAAAAAOuyr4YefDWDTcgZ77xZN8DsVdVHu/uPkvzeiGm7kpyYpKbT1epV1V8m+cvNXqe7T0lyi2WGLq+qb2/2+jBOdyfLP/fv8RgFAGDSvP4EAGCavP4EAGCavP4EAGCavP4EAGCavP4EAAAAAAAAAADWa58MPaiq42bdA2xDz07y5CTXHjHnJ7IFQw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgM2xa9YNANtDVV2c5EVjpt2iu4+eRj8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOztnnUDwLbyuiQ1Zs5dkvzbFHoBAAAAAAAAAAAAAAAAAAAAYB/V3buS3DjJNZIckeTwJIcmuSTJhcPj/CSnJflGVe2dUaur0t0HJ7l5kutkcFsOyqD/7yT5bFWdPsP2drzuPjrJ9TK47xceT/O54rF0YZJvJflKVV00qz4BAAAAAGCrEnoArFpVfbq7v5Xk2iOm3TxCDwAAAAAAAAAAAAAAAAAAAIAJ6+6rJblPknskuVmS45McmeRqSfZLcl6SbyT5YlU9bAPr7E5yQpJbZrCPws2T3DCDTdAXjrkkFy9a86tJPpnkI0neWVXnrnf9aevu45M8NMkdktwqyTEZ3MbdSS5I8u0kX87gtp2U5O1VtWcGfe5O8qAkP5zkdkluk+SQVV790u4+Lcnnknxg4aiqszej19Xq7tsn+ckM7v/vT7JrxNxvJvmPJP+Y5P+rqvmpNDlGd980g6/JH0xykyTHJbl6Bp+buQweQ+ckOTXJF5K8P8m7quqz0+/2Ct39/Ul+OskPZPB4us4arvutXPE18f4MHkuf34w+x/RxYJI7JrlrBt+zbpRBcMNhGQSAXJ5BWMN3knwpyaeTvCfJSVV15rT7BQAAAABgZxN6AKzVx5M8cMT4cdNpAwAAAAAAAAAAAAAAAAAAAFhJd5+U5J5rvNo7unu9S76zqu41pqeXJ/k/Kwx/paqOW+F690ry1Aw2ht9/xBJHDY9bjex0+TVum+R+Se6d5O4ZBCmMs/9w3rEZbDz+48Pzl3X3yUn+Jsm/VNWla+1ntbr7uAw2X1/Jz1XVy5e53u4kP5Xk6Rls+L6SI4bH8UkekOQ3k5zZ3S9J8mdV9Z31db563X3dYZ+PSHL0OssckOTGw+PBw3Pz3f2eJK9L8k9Vdfo6+zspK3+tLft10d13T9IZPN5W65gkjx4eX+ju36mq166l10np7mskeXySRya5xZjpVx8eN8jgfnrMsMank7w6yYur6qzN6nWx7t5vuP4vZBB2sF7XHh53TvLkYe3Tkrw+yeuq6gMbbHWk7r53Bo+Dh2UQULKS3UkOzCAc5vgM9ox5WpI93f2fSV6c5I1bJUADAAAAAIDtTegBsFanjhlf7y+HAQAAAAAAAAAAAAAAAAAAAL6nu49P8pdJ7r9J9W+R5GeS/HQGG4JPyv5J7js8Tuvu307yqq2ysXh33zmDQIZbrrPENTIIP3hCd/9yVb1yYs0tMtyg/hczCAdYTQjFWs0ludvweH53X62qLtyEdb6nuw9O8uwkTxquv143SfIP3f24JCdW1Tcm0d843X1Ikt/OIITksA2Wu0WSP0ryjO5+QZI/2Mz7f/i4/+skt92kJa6X5FeS/Ep3P7GqXjTpBbr7QUl+LxsLbEgG+0798PD4ZHf/YlWdtMGaAAAAAADs43bNugFg2zlnzPghU+kCAAAAAAAAAAAAAAAAAAAA2LG6++FJ/jubF3jwjCSnZLCB+yQDD5a6XpJXJPmP7j5mE9dZle7+rSTvyfoDDxY7MskruvuF3T3RfWy6+1pJ3pXkz7I5gQdL7com78XT3UcleVuSJ2djgQeL3TvJJ7r7hyZUb0Xdfa8MvmZ+MxsPPFjssGHNT3X3PSdY93u6+3eSvDebF3iw1O5JFuvua3f3PyV5SzYeeLDUrZO8o7tf1N0HTrg2AAAAAAD7EKEHwFpdOmZ8/6l0AQAAAAAAAAAAAAAAAAAAAOxI3f1rSf4hyUGbuMzhm1h7OQ9I8sHuvtmU102SdPeu7v67JH+Qye858+QkL5xUsWE4wElJ7jKpmrPW3YcleXuSzQgnuGaSt3b3fTehdpKku5+S5K1JjtusNZLcMMnbuvvJkyza3X+c5PcyuaCJqRoGWnw0yf/e5KUen+Sdw8ARAAAAAABYM6EHwFodPGb8oql0AQAAAAAAAAAAAAAAAAAAAOw43f3oJH866z42yfUy2FT8+jNY+6+SPHoT6z+xux+30SLdPZdB4MUtNt7S1tDdu5K8NskJm7jMIUne0N0TX6O7n5HkBUl2T7r2MnYneWF3/+YkinX3I5L830nUmoXufliSdyQ5dkpL/mCStws+AAAAAABgPabxiwRgZzlmzPj5U+kCAAAAAAAAAAAAAAAAAAAA2FG6+7ZJXjJiymVJPjo8Tk1yXpJdSQ5PctMkd8pkN8s/N8mnknwmydlJzhkelyU5YnhcP8kdkxyfZG4VNa+d5I3dfaequmSCva6ou38tyeNHTDkrg43VT0vy7STfTXKNDHq9W5LbrnKp53X3W6rqtHU3m/yfJA9YxbyLk5yc5K1J/ifJ5zO4HRcmuSTJ1XLF5+gGSW4zPG6f5CYb6G89npLkR1YYuyTJvyR5c5KPZfA5uDCDEIPrJbnd8Lo/nuTAMescluRN3X2bqjp7An2nu5+Y5A/XcJWvJHlXks9m8DUzn+TIDL4+757khqus80fd/d2q+us1rH0l3X1kkheucvopSd6SwfeWzyf5WgafhwuSHJTB4+jwJNdKcusMHku3TvIDSfZfb4+jDAMPXreG+hckeX8GXw9nDo/9khyd5DpJ7pnV3f+3SvJv3X2vqrp0jW0DAAAAALAPE3oArNWNx4x/fSpdAAAAAAAAAAAAAAAAAAAAAKM8O8mrl5y7WZKnj7jOczLYrHw9Tl/n9Rbsn+QVWX6D71OT/GmS147bzL27b5rRt3GUszPYfP7/JflIki9X1fxqrjjcYP1nkjwmg431R7lNkt9J8tvr7HMt7pxBT0vNJ3ltBpvCf6CqLl+pQHd/Xwa9PjaDkImVHJLkWUlOXE+j3b0rSY2ZdlEGj+0/r6qzRsz77vBIkv9O8sZF6xyf5EeHx92zurCK9bpulg8NmE/y4iS/W1VnLDN+XpJPD4/XdPfRSX4vyeMyut/vS/KiJD+9kaaTpLt/KMmfr3L665M8p6o+OKbmHTL4+nz4Kmr+eXd/vKret8oelnpaBoELo7wlg8/Bh0fMuWB4fCODAJR3LQx09+FJHpTBY+khGYQjbNgwAOY1GR94sCeD+/4vk3ywqi4bU/dmSZ6U5AlJDhgx9S5Jnj+cCwAAAAAAqyL0AFi17j4ggwT4Ub48jV4AAAAAAAAAAAAAAAAAAACAlVXVm5ee6+57ZXQgwJur6qRNammcY4fHYnuT/HGSrqpLV1Okqj6Xwcbwq7UnyeuS/F2Sk6pqzxquu3jds5P8VZK/6u5HZrBh+DVHXOXXu/slVfXV9ay3Bo9f5txHkzyuqj6ymgJV9bUkT+juV2UQCjFqY/eHd/cz1nm77pfkuBHj30jykKr62Dpqf09VfT7Jc5M8t7tvnsHm+I/aSM0RbrLMufOSPLyq/n21Rarq2xl8Dt6U5B+SHDZi+k9196uq6k1ra/UK3X1IVrfp/ulJHllV71hN3eFj7me6+0VJ/j5X/ZpfbP8kf9/dt6yqC1dTf0F3zyX5+THTfqOq/mQtdZeqqnMz+P7xuu4+bLjmL22k5jBI4Q0ZhIiM8uYkT6mqU1dbu6o+m+SXuvv5SV6e5B4jpj+xu1+/2s8tAAAAAACMSs4GWOp+SQ4cM+e/p9EIAAAAAAAAAAAAAAAAAAAAsKNdluSnquq3Vht4sEbnZRBMcOOqemRVvW29gQdLVdVrktw6yWdGTNs/yW9MYr01+o8k91xt4MFiVfWeJA9McvGIafsl+YV19vbDI8b2ZhAUsKHAg6Wq6jNV9fgk10ty0SRrr+DCJA9cS+DBYsMggwdnfK/P6e7d61lj6HczOoAiST6b5AfWsyl+Vb0zyQ8Ma4xy3LCXtTohyXVHjL90o4EHS1XV+VX1F0mOT/LaDZR6TpIbjBjfk+TXkjx0LYEHi1XVl5PcP4Ngi1H+qrv3W88aAAAAAADse4QeAGvxs2PGL0vy4Wk0AgAAAAAAAAAAAAAAAAAAAOxoj62qf96s4lX1h1X1tKr66ibV/2aS+yQ5dcS0E7v7kM1YfwVvzWCj9PPXW6CqPpBk3GbxP7nO8ncaMfafVfWuddYdq6rOrKrLN6v+Io+pqvdtpEBVvTvJ48dMu1mSn15P/e4+JskvjZn2rST3r6qvr2eNJKmqb2Sw8f63x0z9pe6+zhrLj3osXZ7kmWust2pVtbeqvrOe63b3nZI8dsy0J1TVc6pqfj1rLBiGyTwqgyCUldw8yc9sZB0AAAAAAPYdQg+AVenu45P8xJhpJ1fVNFLrAQAAAAAAAAAAAAAAAAAAgJ3rDVX1ilk3sVFVdXqSp46YcrUkD5tONzkjyc9W1Z4J1PrjJN8cMX7z7r7+OureaMTYv62j3lbz71X12kkUqqpXZRBiMcqvrLP805McNGbOo6vqtHXW/55hjZ8bM+2gJL+6xtKjHksfHgYubEV/MG68qv52UosNgxMeleRrI6Y9fVLrAQAAAACwswk9AFbrL5LsN2bO66bRCAAAAAAAAAAAAAAAAAAAALBjnZvkKbNuYlKq6k1J3jFiyoOm1MpTqmpUUMGqVdXFScZt3n+3dZS++oixr66j3layJ2vfuH+cpyW5fMT47bv7hLUU7O4DMj6E4A1V9R9rqTtKVf17kjeOmfbz3X3gGspefcTYlnwsdfcdktx/xJT/SdKTXreqvpPkd0dMOaG7bz/pdQEAAAAA2HmEHgBjdffTM/6X5Ocm+ccptAMAAAAAAAAAAAAAAAAAAADsXH9bVV+fdRMT9voRY/eZwvpfTPJPE675D2PG17TZ/tDciLHd66i3lbyyqj4zyYJVdUqSV4+Z9vA1ln1IkqNGjF+aQdjCpP1ykstGjB+Z5KFrqLcdH0uPGzP+q1W1Z5PWfnWSr40Y/6lNWhcAAAAAgB1E6AFsQ919++4+eEpr/Z8kf7KKqX9dVedsdj8AAAAAAAAAAAAAAAAAAADAjvZ3s25gE7xlxNh1u/tam7z+X1TV3gnX/GgGG+Cv5ObrqHnWiLHbrqPeVvKqTao7LvTgIWus97Ax4/9eVaeuseZYVfWlJP8+ZtrD1lBy1GNpPYEcm6q7D8jogIpPVtWo7yMbUlWXJXnFiCkP3Ky1AQAAAADYOYQewPb0s0m+2N2/2N2HbsYC3X1Adz8/ycsz/nvFt5L88Wb0AQAAAAAAAAAAAAAAAAAAAOwzPlpVn5x1E5vgtCSjQgdutcnr/+ukC1bVniT/M2LK962j7LdHjP18dx+yjppbwTeSnLxJtd+e5PQR47dcY6jG/caMv3INtdZqXDDEfddQa9Rj6Ubd/cNrqDUNd09y+Ijxf5xCDyeNGDuhu4+YQg8AAAAAAGxjQg9g+7pOkj9Pclp3P6+7J5Yi3t33SvLuJL+0yqv8UlV9d1LrAwAAAAAAAAAAAAAAAAAAAPukd826gc1QVZcn+c6IKcdt4vJfrarTNqn2Z0eMHb2Oeh8cMXaDJC/r7t3rqDtr/1ZVo0Iv1m1Y9/+NmDKX5C6rqdXdN8lgP5OVnJPkzavvbs3eNFxjJcd09/GrrDXqsZQkL+3um62y1jQ8aMz4P0+hh/cmuXyFsbkkE9vbBgAAAACAnWk7/hIHuLIjk/xykl/u7s9l8Au8tyd5X1Wdtdoi3X1MBmnrT01ypzWs/4KqmkYaOAAAAAAAAAAAAAAAAAAAALCzfWTWDayku6+d5Ngk10pyRJIDkxyQZNcqS+w3YmzURvMb9b5NrD1qg/oj1lHvv5L8wojxn05yk+5+WlVtp4CMj864/q0yOhhhwbhN7T9UVZeurqW1q6pLuvuDSe4/YtoJST6/inIfTHJ+ksNWGD82yQe7u5K8qKouXlOzk/eDI8bOz+iAkYmoqgu7+ztJrr3ClFslOXmz+wAAAAAAYPsSegA7y02T/MrwmO/u05J8JsmpSb6Z5OwklwznHpnkGkmOzuAXX6tNMl/sDcO1AAAAAAAAAAAAAAAAAAAAADZqszeHX5XuPiLJA5PcPcmdknx/kqtt4pLX2MTaX93E2ueNGDtwHfXemOSMDIIlVnKHJCd398eSvCzJG6rqa+tYa5o+MeP6t1xlnVuNGf/YKutsxMcyOvTg1kn+aVyRqrqsu1+V5Ikjph2e5HlJfqe7X5Hk9UneX1Xza+h3w7p7LqMDJ/5nij2dmZVDD75vSj0AAAAAALBNCT2AnWsuyfWHx2b4xySPqqo9m1QfAAAAAAAAAAAAAAAAAAAA2Lds5gb9Iw03Hn9wBpukPzDJ/lNc/uBNrH32JtY+f8TYAWstVlUXdPdzk/zxKqbfLskLkvzFMADh7UlOSvLuqjpnrWtvor1JPrXJa3xyuM6uFcZXu1n9uD1KPr7ahjZgXLDCWvZR+eMkj8n4x+JRSZ42PL7Z3W/L4LH0zqr6whrWW69jMwhgWFF3/8IU+khGh5Vcd0o9AAAAAACwTQk9ANbq8iS/XVWr+QUxAAAAAAAAAAAAAAAAAAAAwGrszehN9DdNd987yXOS3H4W62f0RuMbddYm1p7fhJrPS/LQJHdd5fy5DD5vt0/y9CR7u/vTSd6b5D1J3lVVX96EPlfru1V10WYuUFUXdve5Sa6+wpTrrLLUsWPGpxEA8Pkx4+N6/J6q+mp3/0qSF65h/WOSnDg80t3fSvK+DB5L707ykaq6bA31VuN6Y8Z/YHjM2shgBgAAAAAAEHoArMWHkjyuqj4+60YAAAAAAAAAAAAAAAAAAACAHeW8qtqMTfRX1N37J3lukqdksHn+rOy3ibUv2cTaE1dVl3b3TyQ5Ocnx6yixK8mthsfjkqS7v5jkLUn+OcnJVbV3Qu2uxrlTXOfqK4xdY5U1rjlm/JxVd7N+4+6va62lWFX9ZXffLMlT19nPtZM8bHgkyXnd/fYkb0jyb1V19jrrLrbqIIcZO3jWDQAAAAAAsLXtmnUDwLp8LMmXprjeR5P8RJIfFHgAAAAAAAAAAAAAAAAAAAAAbIJpbQ6fJOnuQ5L8ewaboc8y8IAlquqbSe6UQVDBJNw4g2CLdyT5Sg+safP8DZhm6MFKDlpljXGb2k/jtowLVljzxvtV9YsZfJ1ftq6OruxqSX4syd8lOb27X9vdd5lAze3gwFk3AAAAAADA1ib0ALahqnpFVd04yfWT/J8kL0vy35nML9cWfCHJ85PcsaruUFX/XFXzE6wPAAAAAAAAAAAAAAAAAAAAsGDvtBbq7l1J/jHJ/aa1JmtTVd9N8iNJHpXkKxMs/X1JfjeD8INndfdmbzh/3ibXXzAqkGC1m9WPC0fYCqEHqw1wuJKqemGS2yV503quv4IDk/x0kvd291u7+4R11llzkMOMCIcBAAAAAGCk3bNuAFi/qjotySuHR7r7gCS3SnKbJDdMcr3hcd0kh2fwS65DMvil2aVJLs7gl32nJ/laks8k+WSS91XVV6d5WwAAAAAAAAAAAAAAAAAAAACm5OlJHrLKufMZ7MXw4SSnJPlSkm8m+XaS84fHZUn2VNX8SkW6+9QkN1h/y/ue4f356u5+fZJHJvn5JHedUPmDk/xGkp/p7kdU1XsnVHep/Tep7lrWmVSgyIqP7+2gqk5J8tDuvkuSxyX5ySSHTqj8/ZJ8uLt/P8nvj/pesIxpPUYAAAAAAGBTCT3gKrr7ehlsmP89VXXyjNphDarq0iQfHR4AAAAAAAAAAAAAAAAAAAAALNLd103Sq5j6uSR/keT1VfXtCSw9N4Ea+6SquiTJy5K8rLtvkuTHktwnyT2SHLbB8jdI8o7u/vGqevMGay3n8E2oudZ1Ll5ljXHzjkhy4SprrdcRY8ZXe1tWVFXvS/K+7n5qBuEn90ty3yTHbbD07gy+txzf3T+7huCDSza4LgAAAAAAbAlCD7ao7v6hJA9LcrckxyS5dga/dDk9yZeTvCXJG6vqtE1Y/meT/N6ij+fjsQIAAAAAAAAAAAAAAAAAAADA9vd/kxw0Zs5zkvxGVV0+wXXHbebOKlTVF5I8N8lzu3t3kjskuXuSuyb5oSRHr6PsAUle2913q6pPTKzZgatNuN5KRoUeXLDKGhetYo3TV1lrvcaFRIzrcdWq6vwkrx0e6e7jMngs3S2Dx9Mtsr6wkhOTnJrkd1Y5f1yQxNOq6vnr6AMAAAAAAKbKRvZbTHffO8mfJ7nlotMLv/w4OMmRSb4/yQ8neUF3vznJ71bVxyfcinR4AAAAAAAAAAAAAAAAAAAAAHaM7j4gySPHTJv4BuPdvSvjN3NnjapqT5IPDI/nJEl33yzJvZM8MMn9khy2ynKHJXlNd9+mqvZOsM1phV2Menx9e5U1vrOBNSZl3P11xmYtXFWnZhBW8Kok6e4jk9wzyX0z2OvnRmso99vd/caq+uAq5p45ZvyGa1gXAAAAAABmRujBFtLdL0zyxOGHi0MH5hddnlsy9iNJHtzdL07y61U1Lrl5LeYj/ABg2+juo8696ZE3u+D6V7vWcuP73+HoI+b2zu+39Pz8rrnLn/Cevztn6fmLjznkjAtueMRnX7/rQWdtRr87yZPe+bc32rt7160mUcv9DgAAAAAAAAAAAAAAsLNsxb89Wa6ntf790aR7AgCYknskOWrE+H9OOvBg6MjYw2MqquqzST6b5EXdfVCSByd5TAab1o/7HNwyycOT/P0EWzqsu4+pqm9OsOaVdPexSQ4dMeX0VZb6xpjxGyf50CprrddNxoyP63FiqursJG8YHk/t7hOS/GySn09y9VWU+IMkD1jFvK+OGV9L2AIAAAAAAMyM0IMtoLv3S/LyJI/IFb8cm19h+tLzc0n2yyAs4UHd/fCq+vBm9AnA1tTd9z7vJke87JtPuPVxl1zrkBXn7XfBZZnbe9Wnl/ldc7n80P1XvN5PX/TmU/ceuN/PvX7Xg06aRL87yePf//KnnX+Tqz/r0rtf98BJ13a/AwAAAAAAAAAAAAAAbG9b8W9PRvW03r8/2mhPAABTdvcx48/epHVtWj4DVXVxkn9N8q/dfaskf5Xxj4EnZbKhB0lyQpJNCz0Y1h/li6us85Ux47dL8tpV1lqv240ZHxcQsGmq6hNJfrW7K8lvJvm/Gez7s5L7d/dNquoLY0p/JYM9hVYK5Th+zc0CAAAAAMAM7Jp1AyRJKskjh5fns3zgwVyW/8XEwvy5DH7B+a7uftxmNAnA1tPd9z7/Boe//Ss/c/ORgQcbsffA/Y5L8o6f3Psf99qUBbapx7//5U87607H/NmlRx008f90nrjfAQAAAAAAAAAAAAAAtrOt+LcnW7EnAIAZ+P4RY2cmeccmrXvXTarLKlXVp5LcN8mbxkz9we6+2oSXHxdKsNn1T1llnU+NGb/tKutsxLjQg09OoYeRqur8qvqtJI/K8vsELXb/1dRL8vkRU27W3ddbQ4sAAAAAADATQg9mrLvvlEFy88IvMBYHGywEHZyW5INJPpzk7CwfgLAQfnBgkr/u7t/fxLYB2DpeePqDbzC1taa10HZw/k2u/qwpLeV+BwAAAAAAAAAAAAAA2Ga24t+ebMWeAABmYNQfZ3+2qi7fpHWFHmwBVXVZkkcnOWvEtN1J7jLhpTf78z+u/sdXWecTY8Z/oLv3X2WtNRvW/oEx08b1ODVV9Q9JXjlm2t1XWe4DY8Yfsso6AAAAAAAwM0IPZu/5SfZb9PF8BoEG5yX5rSTXr6rjqurOVXWnqrpmktskeU6Sc7N8+MFckmd0919udvMAzE53X2PPwbtvccm1DpnWkrf8yb3/cdS0FtvKnvTOv73JpUcddOCUlnO/AwAAAAAAAAAAAAAAbCNb8W9PtmJPAMDMjNvUf9M2NN8iDh8x9s3NWLC7D05yn82ozdpV1ZlJXjtm2nUmvOyDuvvqE66ZJOnuI5M8YMSUC5N8aDW1quqLSb4+YsqRSR68+u7W7EeGa6zk9Kr6/Cauvx7j9vdZ7WPpbWPGf2yVdQAAAAAAYGaEHsxQd98hyZ0zCCpIBmEFc0k+meSWVfWsqvra0utV1aeq6teT3DjJi5cpvRB88ITuflV3+zwD7EzH7Dls6v9naNL/OWNb2rt71y2mvKT7HQAAAAAAAAAAAAAAYJvYin97shV7AgBm5tIx4wdPpYvZOWDE2LhAiPV6VBKhUFvLe8aMX3PC6x2Q5McnXHPBT2b04/rdVXXZGuqN23z/xDXUWqtxtcf1Ngsfzujvq6t9LL0xyZ4R4w/o7hNW3RUAAAAAAMyAzfBn6wnLnPtSkntU1ajU6yRJVZ1VVU9Mcv8k38og6CDDfxeCDx6R5PXdPfVdsQEAAAAAAAAAAAAAAAAAAADYUs4bM374VLqYnYtGjB096cW6ey7JUyddlw37zpjxAzdhzcdPuuDw8fW4MdP+aY1l/3XM+EO7+7prrDlWd18/yUPGTBvX29RV1XySM0dMWdVjqarOTvKWEVPmkvz+GloDAAAAAICpE3owW/fKIJwguSKo4MSqOmctRarq7Ulul+TduXLgwcK/D0vy/7r7oIl0DQAAAAAAAAAAAAAAAAAAAMB2dMaY8RtNpYvZGXX7b9vduye83lOS3GrCNdm4a44ZX9PeL6t0p+5+xIRrPirJHUaMX5rkn9dY898zehP/g5I8Z401V+N5GR0QcFaSN2/CuhsyDJ44asSUtTyWXjBm/KHd/YA11AMAAAAAgKkSejAj3X2tJDcefrgQUPC2qnr/eupV1beS3CfJ3y2ql1wRfPCAJG/p7sM20jcAAAAAAAAAAAAAAAAAAAAA29Z3klw0YvwW02pkRr44YuyIDPbumIjuvnmSP5lUPSZqVFBAknxpk9b94+4+ZBKFhnvIPGvMtNdW1VlrqVtVlyX52zHTHt7d91xL3VG6+/5JfnzMtL+pqksnteYE3SqjwxpW/Viqqrcm+ciYaa/t7uNXWxMAAAAAAKZJ6MHs3HaZc6/bSMGq2lNVj0nyzAyCDhYsBB/cI8lbu/uIjawDAAAAAAAAAAAAAAAAAAAAwPZTVfNJPjdiygO6e/e0+pmBD40Z/73unhszZ6zuPjKDfUQO3mitfUV337G7f2IS9/+Yda6W5MQRU+YzfuP59bpekhdPqNZLkxw7Ynw+yZ+ts/afZXQ4SpK8sruPXmf97+nuY5O8fMy0i7PG29Ldv9HdR623rzV44pjxD6+x3q+OGT8yyRu7+5g11l237v7R7rZPFQAAAAAAY3kzeXauscy590yicFX9XpKnLDm9EHxwpyTv6O5rTmItAAAAAAAAAAAAAAAAAAAAALaVD4wYOzLjN/Hezv5zzPgPJnnmRhYYbkb+1iS33kidfdD3JXl9kk9192O6+6BJLzAMVHhJklGb9X+oqr496bUXObG7n72RAt39vCQPHzPtH6rqE+upX1XfyviQgesneetGgg+GXyv/mdHhDUnyZ8Oe1uI3kpza3c/t7huuq8ExuvuHkzxhzLQ3r6VmVb0zySvHTLtZko91973WUnstuvuA7n5kd38syb/FPlUAAAAAAKyCN5NnZ7kk6NMnVbyq/irJzya5fNHpheCD2yY5qbuvPan1AAAAAAAAAAAAAAAAAAAAANgW3jZm/Nnd/fTuPnQq3UxRVX05yXvHTPvd7v7D7t691vrDTdA/kuQOywxfvsw5ruoWSf4myde6+y+6+46TKNrdRyV5Q8aHBbxkEustMr/Muad39z929xFrKdTdV+/u1yf55TFTL0jym2upvYw/TPKlMXNuk+SD3f1Day3e3XdL8sEktxwz9UtJ/mCt9YeuluRXknyhu9/c3T/d3Qevs9b3dPdcdz8hyb9msJfPSt5dVZ9exxJPSfLFMXOOSfK2YajDuNCIVevuE4ahHF9N8uoM9ikCAAAAAIBVWfMv15iYw5Y5d8EkF6iq13T3BUn+IckBw9MLwQe3SHJyd9+3qr42yXUBAAAAAAAAAAAAAAAAAAAA2LL+Pcn5WX7viyQ5MMmzkzyzu9+V5JQk3xpe57IRdU+vqjdPstFN8mdJxm3S/owkD+ruP0ryhqpaMbBgGI7wwCRPS3LfFaa9Osndk9xg7e3us66R5KlJntrdpyZ5Y5K3Z7CR/HdWW6S7vz/JI4a1xoUMfC7JK9fV7crem+TQXHXz+J9Kcq/uflaSv6uqc1YqMAxH+PkMggyutYo1f7mqvrq+dgeq6qLufkSSk3PFvjXLuUGSd3f33yf5s6r66Ki63X27JL+awedkVGBAklya5BFVddHqO1/WriQ/PDwu6O63JvmPJO9K8j9VtVwwxVV099WTPCTJ05OcsIqr/PZ6mq2q87r7x5K8O8nVR0zdL4NQh6d092uS/H2S91XVqvcw6u5rJ7lLkvtkcP/ceD09AwAAAABAIvRgls5f5tw1k3xzkotU1RuGv8T4lyQLSdMLwQfH54rggy9Pcl0AAAAAAAAAAAAAAAAAAAAAtp6quqC7X5LBZtmjHJrkQcNjNd6ZZMuHHlTVPw/DHO4+Zurtk/xTkrO6+71JPpHkrCQXZLCHx7FJbpHkrhm9MflXkzxleH3W57gMAxCSpLtPyyCM49Qk30hyTpKLM9ic/9AMAhNuluQ2w+uuxp4kj6mqUcEe67EnyS8keX+uutfP0Umel+RPuvvdST6W5GtJLsrgMfZ9SW6X5G4ZHTyw2Gur6m8m0Heq6gPd/dQkLx4zdS7JI5M8sru/lMFm/Z9N8t0M9rm5epKbZvA1t5ZN9Z9aVR9YY9vjHJrkYcMjSc7t7k9nEHjxjSRnZHD/780gGOZqSW6U5PszCK5Y7X5NL66qd663yao6pbsfmkE4w6Fjph+Q5OeGx57u/kiST2Xw/eqsJGdnEJBwUAZfG8ckuWGSmye5znp7BAAAAACApYQezM53lzl37Uw49CBJquo/u/uHM0gsP2x4eiFh+rgMgg/uV1WfnfTaAAAAAAAAAAAAAAAAAAAAAGw5f5DBJuXXnnUjM/LoDDaYP3wVc49K8pDhsVbfTfIjVXVOd6/j6qzgesNjkp5SVe+ecM0kSVV9pLuflOQlK0w5IMl9hsdGvDeDje8npqpe0t1HJvnjVV7lRsNjo/5vVa10f03S4UnuPDwm5aQkv7TRIlX17u6+dwZhMtda5dV2J/nB4QEAAAAAAFO1a9YN7MO+tsy5m27WYlV1cpIHZJBMvth8kusmeWd332qz1gcAAAAAAAAAAAAAAAAAAABga6iqs5P87yQXzrqXWaiqLyX58SSXbOIy303ykKr61CauwcbtSfKEqnrxZi5SVS/NIGxks7w7yYOr6uJJF66qP0ny5Azuq822J8mTqupPp7DWZnhLkodW1US+t1TVh5LcKcn7JlEPAAAAAAA2k9CD2TllmXP33MwFq+oDSe6b5MwlQ/NJjk7yju6+w2b2AAAAAAAAAAAAAAAAAAAAAMDsVdV7ktw9yWdn3cssVNV/ZbAPxzc2ofwXktx5eB+zdX0qyb02O/BgQVX9TpJfTrJ3wqVfneSBVXXuhOt+T1X9VZL7JfnyZq2R5EtJ7ltVf72Ja2yWC5L8RgZBJ+dPsnBVnZrkHkl+e7jONF2a5F+SXD7ldQEAAAAA2IaEHsxIVZ2Z5FvDD+eTzCW51xTW/ViSey9ae8F8kmskeVsG6c4AAAAAAAAAAAAAAAAAAAAA7GBV9dEkt0nyuCQfn2030zcMJbh9krdOqOSeJM9OckJV7ZNhEhvw1iQ/neRVSb6zyWt9N8mvJLndtIMpqurPk9w1yf9MoNy3kvxsVT2qqi6cQL2RquqdSW6V5FlJJrmx//lJ/ijJravq5AnVfFAGfX5yQvVWMp/kdUluXlV/UlWTDrRIklTVnqr6wyTHJ/nrbH74wYeSPCXJdarqf1fV/CavBwAAAADADrB71g3s4z6Q5Ecz+OVFknx/dx83TFfeNFV1SnffK8l/JTl20dB8kiOSPGQz1wcAAAAAAAAAAAAAAAAAAGD7uunf/MPcrHsAJqeqLk3y0iQv7e7jktwryR2T3DTJ9yW5ZpKrJTkgya7ZdLl5qupbSR7Q3fdI8owkD1xHmbOS/F2SF47YN+S/s/Jm/l9ex5o7SlVdkMHm8a/r7l1J7pzkvknuMrx85AaX2JPkP5O8OskbquqiDdZbt6p6f3efkOQRGYQv3GaNJU5L8qIkL6iq8ybd3yjDcIVndPdzMwhLOTHJLdZZ7tMZfD5eXFVnTajFJIP7OMn7M+j1+hl8Xd81yQ9lEBywUZ/JoPdXV9VXJlBvVarq9CRP6u5nJHlUkp/I4Hbtt8HS30ry9iRvS/LWqjptg/UAAAAAANgHCT2Yrf/KIPRgsUdkkDy9qarqc8Nftv5XkhssGppP4j+YAAAAAAAAAAAAAAAAAAAAAOxjhhv2v3x4bEb9Ryd59GbU3qiqOjnJyd193ST3Hh63SnKN4XG1JBcluSDJ6Uk+m+RTGezd8cGqunxM/aV7jEyq71Mzo71CquqZSZ65CXX3Jnnv8Eh3zyW5eZITktwkyY2Hx7Uz+LwcluSQJJckOSfJucN/P5/kY8Pjo1X13Un3ul5VdVmSVyR5RXffNMmPJLlDBgECx2Zwuw7M4PF2ZgaPt48m+Y8k7x33eNtsVXVmkmcleVZ33yzJPZL8YAaBAsclOSLJocPpFyb5bpJTM/icfCDJyVX12Sn1+tUMg12SpLuvkeROw14XHk/XT3J4Bo+lq2WwB895ueKx9I0kn8gVj6UvTqP3lQwfyy9I8oLuPiqDYJA7ZfD4uUGS6+aKr4u5JOdncFvOS3J2ki9kENzwmSSfrqrPT/kmAAAAAACwAwk9mK3/WnR5IWzgcd39rKqa3+zFq+rL3X33YR83HfawuBcAAAAAAAAAAAAAAAAAAAAA2GdU1deTvHp4sAUM92H5n+Gx41TV55J8btZ9rNcwvOCzGYYKbHXDwIa3DI9tr6rOSvLvwwMAAAAAAGZm16wb2JdV1aeTfGXJ6esl+Ykp9vD1DJKyP5krgg4EHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJbQg9l7Xa4IGZgf/vtb02ygqr6d5J5JPjzsZX5RLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsKzds26A/GOSX8sVwQdJcuvufmRVvWZaTVTVd7v7PknelOQe01oXtqLufmaSmnUfAAAAAAAAAAAAAAAAAAAAAAAAAAAAALDV7Zp1A/u6qvpokl9N8puLjmck2TuDXs5P8qAkr0zyzkXHydPuBYBV+ebu8y+b9pqnT3vBrWjXnr2fnvKS7ncAAAAAAAAAAAAAAIBtYiv+7clW7AkAAAAAAAAAANg5ds+6AZKqet6se1hQVRcnefSs+wBgvKo6s7s/feAZF97ikmsdMo0lT3n9rgedNY2Ftrq/uudjvvDI77zhkkuPOujAKSznfgcAAAAAAAAAAAAAANhGtuLfnmzFngAAAAAAAAAAgJ1j16wbAAA25MnXecup01rrKdNaaDs47Avf/Y0pLeV+BwAAAAAAAAAAAAAA2Ga24t+ebMWeAAAAAAAAAACAnUHoAQBsY1V10mFfOe/eN/j7z5x64Lcv3JQ1dl1y+alJ7v36XQ86aVMW2KZefOdHP/+oD37zaQecedElm1Hf/Q4AAAAAAAAAAAAAALB9bcW/PdmKPQEAAAAAAAAAADvD7lk3ALDVVNUzkzxzrdfr7lOS3GLS/cA4VXVSkht291Hn3vTIm11w/atda7l5+5998RFze+f3W3p+ftfc5ZcdedA5S89ffMwhZ1xwwyM++48H/8hZk+96Z3jxnR/9/CTPf9I7//ZGe3fvutUkarrfAQAAAAAAAAAAAAAAdoat+Lcno3pa698fTaonAAAAAAAAAABg+xN6AAA7RFWdleR9K41399FZ/rl/T1V9e9Ma2wf81T0f86UkX5p1HwAAAAAAAAAAAAAAAGw9W/FvT5bryd8fAQAAAAAAAAAA67Vr1g0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADbk9ADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgXYQeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6yL0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWBehBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLoIPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANZl96wb2K66+5gkD5h1HyPMJ9mT5OLhcWaSbyb5ZlVdOsvGAAAAAAAAAAAAAAAAAAAAAAB2gqq616x7AAAAAAAAmDWhB+t3yyQvzyBcYDvZ291fTnJKkvcnOSnJh6pq70y7AgAAAAAAAAAAAAAAAAAAAAAAAAAAAABg2xF6sHFzs25gjfZLcpMkN07yo8NzZ3T365K8rKo+PqvGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYXnbNuoEdYH6bHnOLjqOTPDnJR7r7Ld19+wnfRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7EBCDyZjbhsdC1YKQXhgkg90959394GTuoMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANh5hB7se1YKQlgIP0iS/ZI8Jcm7uvu6U+8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBtQejBZMwvc6x1/lqOSdVesDgAYWFsLskdk5zU3dcZsyYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPsgoQcbN7fCsZxRYQOrOVaqs5p+lqu1XJ3FY0ly4yT/X3cftMJ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADso3bPuoFt7N1JbrjM+esleWGS22QQHDCXKwIEFgIF9ib5XJJPJPn48PK5i469SY4YHocnOT7JbYfHTXNFWMXSAIX5JP+d5KlJThuePzjJ1YfHkUlOSPKDSe6Y5NAldeaW/LvQ/y2TvCDJY5e/KwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2BcJPVinqrokyVcWn+vuhyd5UZKr5YoggYXggGQQcPDqJH9fVd9cz7rdfe0kj0hyYpLbLVknGYQtvCnJE6rqtcuU+IdhnV1JHpbkKUnuNbz+4l6TK4IU5pL8fHe/rKret56+AQAAAAAAAAAAAAAAAAAAAAAAAAAAAADYeYQeTEh3V5LfzRWhAQshBHNJPpvkqVX1to2uU1XfSvK8JM/r7vsmeUGSmy9Z7/Akr+num1bV761QZ2+Sf0nyL919xwzCGG6aqwYfLJhL8uwkd9vobQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGfYNesGdoLu/s0klUEwwHyuCA6YH56/zSQCD5aqqv9Kcpskv5MrQg8Wr1/D3sbV+XCS2yd5zaK+Fyz++C7dfafJdA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHYn9GCDuvthSf4wV4QNJIOggMuS/FRV/X5VXbZZ61fVnqr6wyQ/keTyRUMLwQd/0N3/axV1LqyqRyV5Q64afLDYYzfWMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO4XQgw3o7qOSvGjJ6YXAgCdX1b9Mq5eqekOSJw7XX7AQfPCi7r7GKkudmORTi66/tNZDN9YpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7hdCDjfntJEfninCAhcCDf6uqv5l2M1X1t0nekCsHHyTJNZP87iprXJjkl5fUWHz5Wt19h/V3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAADATiH0YJ26+8gkj80VgQcL5pP8+vQ7+p5fT7J30cfzGYQWPKa7j1pNgap6e5L354oQh6XutNEmAQAAAAAAAAAAAAAAAAAAAAAAAAAAAADY/oQerN9PJTl00ccLAQFvraovzKalZLj2W4f9LHZwkoevodRfjBi73Vr7AgAAAAAAAAAAAAAAAAAAAAAAAAAAAABg5xF6sH4/tsL5N021i+W9cYXzD11Djf8aMXajNdQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCHEnqwfndPMr/M+Q9Mu5FlLO1hPslckruutkBVnZHkM4uuv7jO9220QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtj+hB+vQ3TdIcujww7klw1+ccjvL+dKiy4v7O7S7j1tDnQ/lqrcvSa65nqYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhZhB6sz01GjJ07tS5WNqqHG6+hzhkrnD94DTUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANihhB6szxEjxvabWhcrG/V5HdX7UmetcP6ANdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCHEnqwPoeNGDtyal2s7KgRY6N6X2ql0IPL1lADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAdSujB+lw6YuymU+tiZaN6WEtgwQErnL9gDTUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANihhB6sz3kjxu4+tS5WdrcRY6N6X+rqK5y/cA01AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYoYQerM9XVjg/l+QnptnICn5yxNhKvS/nyCUfzw3/PXdt7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsBMJPVifzye5fHh5PoMwgPnhxyd09z1n0lWS4dq3XaavZNDz59ZQ7vrLnJtPctp6+wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYOcQerAOVXVJkg9lECqw1FyS53X37ul2lQzXfN4yQwvhBx8Z9r5ad8iVQxMWfHkd7QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsMMIPVi/tyz5eCFYIElOSPL8qXYz8Lwktx32sVwgw7+vtlB3XyPJ9YcfLq116jp6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAABghxF6sH6vSLJ3eHkh7GAh+GAuyRO7+0+n1Ux3PyvJk3PlwIP5RVP2ZtDzav3QiLFT1tYdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7kdCDdaqqryZ5Q64IGFiwOPjgV7v7zd193Gb10d3X7+43Jvn1FaYs9PNvw55X6ydGjL1vDXUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANihds+6gW3uN5P8aJL9ckXQQXLl4IMHJTmlu/80yZ9X1XcnsXB3H5HkF5P83yQHL1kzw8sL9iR5xhpqH5jkxxbVWFzrc1V19jrbBgAAAAAAAAAAAAAAAAAAAAAAAAAAAABgBxF6sAFV9fnu/v0knSsHAyRXDiE4OMnvJvmN7n5LklcneWdVnbmW9br7GknukeTEJD+c5IBcOeRgbslVFnr4w6r63BqW+pEkhy+qufjfd62lZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdi6hBxv3h0numeQ+uWrwwEJQwMLlA5P82PBId5+e5ONJPp/knCTnJjlveJ3DFx3HJ7ltkmOX1M6S+llybj7JSUl+f4236enL1FrwhjXWAgAAAAAAAAAAAAAAAAAAAAAAAAAAAABghxJ6sEFVtbe7/1eSd2YQTLBS8MFy4QTHJrlOkgevYqm5JR/PrzC2eJ1PJHlYVS0NLlhRd98zyZ1z1bCDZBDK8J+rrQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwM62a9YN7ARVdV6S+yR5T64acpDhuYVggvklx9wqj6XXW1o3S86/N8l9h72txYlJvpLkq0uOryR5VVXtWWM9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2qN2zbmCnqKrvdvf9kvxFksfmquEEi/9dsDQcYZyl119cZ/H4y5I8paouXkPtJElVPXat1wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYN8k9GCCquqSJI/v7rck+fMk18tVgw3mVri8VkvDEuaSfD3JL1XVv2ygLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArMquWTewE1XVG5LcPMnvJjkzg0CChYCD+SXHai13vYW6Zyd5ZpKbCTwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBads+6gZ2qqi5K8gfd/Zwkj0pyYpK75Yrwg2TtwQdLr/vuJK9O8qrhegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDVCDzZZVV2c5KVJXtrdxyS5b5J7Jbldku9PcvAqS12c5H+SfCzJO5O8rapOn3jDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwSkIPpqiqvpnkNcMj3T2X5DpJjk1ydJJDkhw4nH5JkguTfDvJ6Um+UVXz0+4ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWIvRghoYhBt8YHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsK3smnUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA9iT0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWBehBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLoIPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANZF6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAuu2fdAMBW093PTFKz7gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtrpds24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYnnbPuoF9XXfvTnKdJMcmuVaSg5McNBy+OMlFSc5I8o0k36iqy2fRJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCX0YMq6+0ZJ7pfk7klOSHKzrP7zsKe7P5vkE0nemeRtVXXqZvQJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADjCD2Ygu6+ZpL/MzxuuWhobo2l9k9yq2GNRwxr/3eSVyR5ZVWdtfFuAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABgdYQebKLuPjrJbyZ5bJKDs3zIwfway84tqXNCkucm+f3uflGSP6mq76yjXWCoqp6Z5JlrvV53n5LkFpPuBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2ql2zbmCn6u7HJ/lMkl9MckiuCCqYX3IkVwQZjDtGXf/QJL+S5DPd/ZjNul0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAALBg96wb2Gm6+/Akr0zy0Fw5qGDB3FWutHrLXXdp7aOSvKS7H5zk56rqvA2sBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK9o16wZ2ku6+TpL354rAg/lcEUowl5VDC9ZyLLW47sKcuST/K8l7u/vaG71dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwHKEHE9LdxyY5OcnNc0XgQbJ82MFyIQZzY45R1126zkLwwS2TnNzdx6z3dgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEp2z7qBnaC7D0zyhiQ3zpXDDhZbGnCwYG+Szw+Pc5OcMzzmkhw+PI5IcpMkN82VgyqWq7k0+OD4JP/a3fesqkvXeNMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBFQg8m43lJ7pjxgQcL5z+V5NVJ3pXkE1V14WoW6e6Dk5yQ5K5JThxeXqi/EHKwYG7RuTsleU6SX1zdzQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPGEHmxQd981yeOzfODB4nN7k7wsyQur6hPrWauqLkry/uHx3O6+ZZKnJPmFJPvlqsEHWXTuSd3991X1/vWsDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASwk92LhnZxAqsDRwYHHgwQeSPKWqPjLJhavqlCRP7O4XJXlhkrsu6WOhryTZleQ5Se42yR4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAANh37Zp1A9tZd98nyZ2zfODB3PB4VpIfmnTgwWJV9YmqunuS38uVgw6y5OO7dPe9N6sPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2LUIPNuaxy5xbCDyYT/JrVfVbVTW/zLyJq6pnJvmlXDX4YLFfmEYvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsfEIP1qm7D0ny0Fw5XGBx4MFLq+q50+6rql6Q5K9z1eCDhd5+tLsPnnZfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsPEIP1u+uSQ4ZXl4aMPD1JE+bekdX+NUkpw0vL4QdLDgkyd2m3hEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADuO0IP1u/sy5xbCD/6oqi6acj/fU1UXJ/mjXDnsYDGhBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbJjQg/W71aLL84suX5LklVPuZTmvSnLx8PL8krFbT7kXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2IKEH63ejJR/PZRAu8O6qunAG/VzJsId3ZdDXYnO5au8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAALBmQg/W75gMQg6W+viU+xjl40s+Xuj3OlPuAwAAAAAAAAAAAAAAAAAAAAAAAAAAAACAHUjowfodusL5r0+1i9FW6mWl3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYNWEHqzfwSucv3CqXYx20QrnD5xqFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7EhCD9ZvpUCBQ6baxWgr9XLJVLsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBHEnqwfhescP56U+1itO9b4fxKvQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwKoJPVi/05PMLXP+tlPuY5TbLvl4od/Tp9wHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7kNCD9fvSko/nMwgVuGt3HzqDfq6kuw9JctcM+lpsPlftHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1kzowfp9atHluUWXD0jys1PuZTknJjloeHluydh/T7kXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2IKEH6/fuZc7NZxAw8IzuPnjK/XxPdx+Y5BnDfpbznim2AwAAAAAAAAAAAAAAAAAAAAAAAAAAAADADiX0YP3ek+TC4eWFsIMFxyZ53tQ7usKfJrn+8PJcrhx+cGGWD2wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA1EXqwTlV1YZI35cphBwsBA3NJHtvdT5t2X939+CRPzVWDGBZ6e2NVXTTtvgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2HmEHmzMS5Y5tzj44Dnd3dNqprt/PclfDtdfyUun1A4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADuc0IMNqKq3J/ng8MPFQQOLgw9+u7vf3d0nbFYf3f393f22JM/KFZ/TuUV9LfTz/qp6x2b1AQAAAAAAAAAAAAAAAAAAAAAAAAAAAADAvmX3rBvYAX4tyUnDywsBA8mVgw9+KMmHu/tvkvxVVX1yEgt3982TPDHJEzL4XC5ec6GfLLr8a5NYFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEqEHG1ZV7+rulyR5fK4cMpBcOYRgvySPS/K47v5kktckeXeST1TVhatZq7sPTnKbJHdN8ogkt1u0TpZZf3EPL6qq9672dgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDhCDybjaUnumOQOuSLkYMFC6EAWnb9NklsPL8939xeSfCHJOUnOHR7zSY5IcvjwuHGS45PsWlIry9RffG4+yYeT/Mr6bhoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxP6MEEVNXF3f1jSd6V5LisHHywOJxgbtHlm2YQaDDK3DLn5lcYX7zOF5L8WFVdOqY+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsya5ZN7BTVNU3ktwzg5CBpSEHyRVBB4vHFh9zY45x11mwOPDgM0nuWVXfnOiNBQAAAAAAAAAAAAAAAAAAAAAAAAAAAACACD2YqKr6WpI7JXlzrggiWBp+kKwcVjDqGHXdpevMJfm3JHeuqtPXf4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBlu2fdwE5TVeckeWh3PzHJHyU5IlcNJFhs6cdrtTQQ4ewkv1FVL91gXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGGnXrBvYqarqr5PcLMkLklycQSDBXK4IQFh8rNZy112oe1GS5yW5ucADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmYfesG9jJqurbSX6pu38/yc8lOTHJrZdMW2vwwdySjz+e5FVJXllVZ66zVQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWDOhB1NQVd9J8uwkz+7uGya5f5K7Jzkhyc2S7L/KUpcl+UySTyQ5Oclbq+ork+8YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGE3owZVX15SQvGR7p7v2SXCfJsUmumeTgJAcNp1+c5KIk30nyjSSnV9Xl0+4ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACWI/RgxoYhBl8bHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsG3smnUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA9iT0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWBehBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLoIPQAAAAAAAACA/5+9e4+27KrrRP89j6QeVBJISCS8TIxCrPgICAy92gpBRqtXBLFF5N6B2tfbCBGH3bb9tJ1MbIc019vikIcRtQUfF1pRUBF5SHtbr9AqaNOdGORNBAIFeVaqKlXn1L5/1ElMKuectfc6e+2919qfzxg1amTPOdf8/ag59/5R49T+AQAAAAAAAAAAAAAAAAAAANCKpgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEArmh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtaHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0oukBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQiqYHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAK5oeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArazPO4B5qLU+b94xzFMp5XXzjgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgP5byqYHSX4lyWjeQcyRpgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOzZsjY9uMfKvAOYg2Vu9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwBQte9ODZWsAsIxNHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6MiyNz1YpiYAy9bgAQAAAAAAAAAAAAAAAAAAAAAAAAAAAACAjq3OOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCf1ucdwJyN5h0AsHhqrS9OUuYdBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsumVuerAy7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDPlrXpweXzDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPpuKZselFI+Pu8YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg71bnHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBP6/MOAGDRlFJenOTFk66rtV6f5PC04wEAAAAAAAAAAAAAAAAAAAAAAAAAAACARbU67wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB+0vQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoRdMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgFU0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVjQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaEXTAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoJX1eQcAAHTv5uuOXHjNBU997KnRxtrZY+esrG/efN2Ri7f+8/wkF589Zxsnkuyfw7wjW783xTiLeYeSPOSsebcmOXrWa4eSPGTznJsPbu775AVJkpWTt49WTh5b2TxwcOX0gy4YrZy6Pasbx5Ikp/cdXDl94IIkOb122/7T59xy6L4PWzm9vrFyev/6ymj/0ZXT+06cWXPO/pXRvkOba7dsnN535Kz67tTRldE5Wd14aO6dv+uaU0ezeurEyubB/fdbszV/lM2jp8+5JfeP68weK5uHDm0X17TXTCuXJNlpzZn/rQ/cvnJ6/71/Tklyvz+rLaPV47eOVo8dXdk4/9D6iSuytnHJ2WfgvsY9c8n87tks5nV6f7a7O9uenzHOwrzvQt/u9X3vz+qph+Seu5Psfn/Wj115Yv3kFzadp0X6DNjLvKT9/dnu7iQPvD8PvDvJzvdnD58983uP32FNw72e5efVpPc6q6dObPfZkzzw/kz42ZPM6TPgmx78LRsbo421fav7Lrrv62tn6s/b7/OS2u1ei/sev6j3Wu2mdrtn/iLchb7da7XbWPMStZvabUlqtyzWfWz12fOsR3/FwVOju+86nZPHV0f7D6yNDp63mVN3rq6ePvqJX3/rUbXb/O+12k3tds/8RbgLfbvXarex5iVqN7Wb2m0e85b2792+/VFfcWBz/bbz7lkxyqm7VkbrWR8dOvCJX3vb5/p+r9Vuard75qvd9la7TXJ/1G5jz1O73c+w7rXarfN5S1u7DeHv3b7z0ic/9HRGq5urt22cPvfWe9esrmzc+dHffM2tZ/63Vrt1OE/tNuaavt1rtdtY8xK1m9pN7TaPeWq3s/boU+02yd+73fdpo7Wjt47W7rrfn/Hmvk8c2Th44x1b//npK6958y0BAAAAAAAAAABYYJoeAMCA3XzdkackeUWSw48891E5ndED5qxmZeZxLZNTB27M8Yt/I6f3fere19aPPTYHjjw3aycfMZU1pw7cmGMX/9L95ne1putcZpn/2XucrSlOutfmLBy/5HVTOQvzvgt9u9fj7sdsLOq5brNmGT6vxs2rjy4555Le1Z+LfK6HfhfUbv2nduvPvR53P2ZjUc91mzXL8Hk1bl7Mxtl/rpsn17N+7Iuz//PPzNqpS++dt5qVnHvq4LZrkmG9xy/qvT6b+zN/arf+3Otx92M2FvVct1mzDJ9X4+bFbCzyuW59F1Y+m4zO/F3n2vEr7q1DV7OSc9cO9iZ/tdviU7v1s3Yb5xl0a1HPdZs103yPn3f+ard+WORzPfT/H7PbmvVz359jF/52Rud+5n6vj1ZGufvcjbHipHtqt/7c67O5P/O1qOe6zRq1G7O2yOd6mWu3cT572rrxXc+4Icm1V17z5j+e+sMBAAAAAAAAAACmQNMDABiorYYH75p3HMvs1IEbc9cjf/p+r60fe2wOffJHp7Zmu/mzWjPtXNqsmWb+k8RJ95b5LvQtl0nW071FPddt1ixDLpPsSff6dK7brFnku+D+9N8y34W+5TLJerq3qOe6zZplyGWSPenetn+ux6/IgZtfMNmaAb3HL+q9nmQ9s7HMd6FvuUyynu4t6rlus2YZcplkT7rXp3M90ZqTZ37sbu34FXnQFOvQNmvUbsPVi7swxvw2a/qWyyR70r1FPddt1vTtLvjs6T/nenHzP3bJqzLaarq1Hfdn/pb5LvQtl0n2pHuLeq7brOnbXVC79Z9z3a/8p+hwkv9y47ue8RSNDwAAAAAAAAAAgEW0Ou8AAIDOvGLeASy74xf/xgNeO3DkuVNds938Wa2Zdi5t1kwz/3HXMxvLfBf6lssk6+neop7rNmuWIZdJ9qR7fTrXbdYs8l1wf/pvme9C33KZZD3dW9Rz3WbNMuQyyZ50b7s/p/2f/46J1wzpPX5R7/Uk65mNZb4LfctlkvV0b1HPdZs1y5DLJHvSvT6d6zZr9n/+mTvO32nNIuc/7npmo093YZHP9axrt3GeQbcW9Vy3WdO3u+Czp/+c637lP+56ZmOZ70Lfcpn0GXRrUc91mzV9uws+e/rPue5X/h3w74UAAAAAAAAAAICFpOkBAAzQzdcduSjJ4XnHscxOrx7N6X2fut9rK5sPytrJR0xtzXbzZ7Vm2rm0WTPN/CeJk+4t813oWy6TrKd7i3qu26xZhlwm2ZPu9elct1mzyHfB/em/Zb4LfctlkvV0b1HPdZs1y5DLJHvSvZ3/XB/WYs0w3uMX9V5Psp7ZWOa70LdcJllP9xb1XLdZswy5TLIn3evTuW6zZuX0gaydunTb+TuuWeD8J4mT7vXqLizwuZ517TbOM+jWop7rNmv6dhd89vSfc92v/CeJk+4t813oWy6T7En3FvVct1nTt7vgs6f/nOt+5d+Rq2581zMunNVmAAAAAAAAAAAA49L0AACGaedv+GImRuu3P+C1lY0Lprpmu/mzWjPtXNqsmWb+465nNpb5LvQtl0nW071FPddt1ixDLpPsSff6dK7brFnku+D+9N8y34W+5TLJerq3qOe6zZplyGWSPelen851mzWLfBfcn/5b5rvQt1wmWU/3FvVct1mzDLlMsifd69O5brVm4/wd5++0ZpHzH3c9s9Gnu7DI53rWtds4z6Bbi3qu26zp213w2dN/znW/8h93PbOxzHehb7lM+gy6tajnus2avt0Fnz3951z3K/8O7dyRFQAAAAAAAAAAYE40PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhF0wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAVTQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBWND0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABa0fQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoRdMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgFU0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVjQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaEXTAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBVNDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFY0PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhF0wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAVTQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBWND0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABa0fQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoRdMDABimm+cdwLJb2bjgAa+N1m+f6prt5s9qzbRzabNmmvmPu57ZWOa70LdcJllP9xb1XLdZswy5TLIn3evTuW6zZpHvgvvTf8t8F/qWyyTr6d6inus2a5Yhl0n2pHt9Otdt1izyXXB/+m+Z70LfcplkPd1b1HPdZs0y5DLJnnSvT+e61Zr1O3acv9OaRc5/3PXMRp/uwiKf61nXbuM8g24t6rlus6Zvd8FnT/851/3Kf9z1zMYy34W+5TLpM+jWop7rNmv6dhd89vSfc92v/Dv06VlvCAAAAAAAAAAA0ETTAwAYoIc9/+LPJ7lh3nEss9XTh7J698Pv99po7a5snvvJqa3Zbv6s1kw7lzZrppn/JHHSvWW+C33LZZL1dG9Rz3WbNcuQyyR70r0+nes2axb5Lrg//bfMd6FvuUyynu4t6rlus2YZcplkT7q385/rzn1gh/4ev6j3epL1zMYy34W+5TLJerq3qOe6zZplyGWSPelen851mzWj1ePZPGfn7xXrW/6TxEn3enUXFvhcz7p2G+cZdGtRz3WbNX27Cz57+s+57lf+k8RJ95b5LvQtl0n2pHuLeq7brOnbXfDZ03/Odb/y78j1V17z5ltmtRkAAAAAAAAAAMC4ND0AgOG6dt4BLLsDR577gNeOX/wbU12z3fxZrZl2Lm3WTDP/cdczG8t8F/qWyyTr6d6inus2a5Yhl0n2pHt9Otdt1izyXXB/+m+Z70LfcplkPd1b1HPdZs0y5DLJnnRvuz+nExe9ceI1Q3qPX9R7Pcl6ZmOZ70LfcplkPd1b1HPdZs0y5DLJnnSvT+e6zZoTF71px/k7rVnk/Mddz2z06S4s8rmede02zjPo1qKe6zZr+nYXfPb0n3Pdr/zHXc9sLPNd6Fsukz6Dbi3quW6zpm93wWdP/znX/cq/Az84q40AAAAAAAAAAAAmsTIajeYdA8Ag1FqvT3J4m6EbSilXzToeSJKbrzvy5CSvSHLV8c1jOZ0Hfu6vZiUH1g7OOrSlcerAjTl+8W/k9L5P3fva+rHH5sCR52bt5COmsma7+bNaM+1c5p3/uOuZjWW+C33LZdz9mI1FPddt1ixDLuPm1Ud9rD/7dK7brFnku+D+9N8y34W+5TLufszGop7rNmuWIZdx82I2zv5zOnFyPavHvjj7P//MrJ269N55960/h/4ev6j3+mzuz/wt813oWy7j7sdsLOq5brNmGXIZNy9mo0/netw1x1Y+m9FoJUmydvyKe+vQ7f7+s2/5j7ue2Vj0u9CXcz3r2m2cZ9CtRT3Xbdb07S747Ok/53ox87/j3Pfn2IW/ndG5n7nf6ysro+w/d2OsOOneMt+FvuVyNvdnvhb1XLdZ07e7oHbrP+e6X/lPyfVJfvDKa978x108/B611kuSrG8ztFFK+WyXewMAAAAAAAAAAP2m6QHAlGh6wCK7+bojF37w+AeuOjXaWDt77JyV9c0vOfDYW7b+8/wkF4/xyBNJ9s9h3pGt35tinMW8Q0kecta8W5McPeu1Q0kesnnOzQc3933ygiTJysnbRysnj61sHji4cvpBF4xWTt2e1Y1jSZLT+w6unD5wQZKcXrtt/+lzbjl034etnF7fWDm9f31ltP/oyul9J86sOWf/ymjfoc21WzZO7zty1g+Wnzq6MjonqxsPzb3zd11z6mhWT51Y2Ty4/35rtuaPsnn09Dm35P5xndljZfPQoe3imvaaaeWSJDutOfO/9YHbV07vv/fPKUnu92e1ZbR6/NbR6rGjKxvnH1o/cUXWNi45+wzc17hnLpnfPZvFvE7vz3Z3Z9vzM8ZZmPdd6Nu9vu/9WT31kNxzd5Ld78/6sStPrJ/8wqbztEifAXuZl7S/P9vdneSB9+eBdyfZ+f7s4bNnfu/xO6xpuNez/Lya9F5n9dSJ7T57kgfenwk/e5I5fQZ8/MTHNjZGG2v7VvdddN/X11bWNy8999Lb7/OS2u1ei/sev6j3Wu2mdrtn/iLchb7da7XbWPMStZvabUlqtyzWfWz12XP7yeMHT43uvut0Th5fHe0/sDY6eN5mTt25unr66IX7Dh5Vu83/Xqvd1G73zF+Eu9C3e612G2teonZTu6nd5jFvaf/e7dbRpw5srt923j0rRjl118poPeujQwcuWL/gc32/12o3tds989Vue6vdJrk/arex56nd7mdY91rt1vm8pa3dhvD3bnee3Hjo6YxWN1dv2zh97q33rlld2bjz/P259cz/1mq3Duep3cZc07d7rXYba16idlO7qd3mMU/tdtYefardJvl7t/s+bbR29NbR2l33+zPe3PeJIxsHb7xj6z8/feU1b74lM6DpAQAAAAAAAAAA0NZ2P3gEAAzMw55/8S3X1Vd9IDv80PE/+OGv80PHnbs4yZfPOwjoKfcH2nF3mK/r6qt6/I/e3B9oz/2BdtwdaO/M/fGlC9CGzx9ox92B9oZzf35Z/cnMDef+wGy5O9Ce+7NI/P1n37g/0I67A+25PwAAAAAAAAAAACyG1XkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9JOmBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCuaHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK1oegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSi6QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCKpgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEArmh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtaHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0oukBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQiqYHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAK5oeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArWh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtKLpAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0IqmBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCuaHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK1oegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSi6QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCKpgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAr6/MOAGDR1FpfnKTMOw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHSr8w4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADoJ00PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVjQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGV93gEALJpSyouTvHjSdbXW65McnnY8AAAAAAAAAAAAAAAAAAAAAAAAAAAAALCoVucdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0E+aHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK1oegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSi6QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCKpgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEArmh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtaHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0oukBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQiqYHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAK5oeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArWh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtKLpAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0IqmBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCuaHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK1oegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSi6QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCKpgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEArmh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtaHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0oukBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQiqYHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAK5oeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArWh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtKLpAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0IqmBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCuaHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK1oegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSyPu8AgNmrte5L8pgkj0xyXpKDSY4luTPJ3yX5QCnl5PwiBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6QNMDWBK11q9O8swk35zkqiRru0zfrLVen+StSd5USnlP9xECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH2j6QEMXK31u5L8iySPn2DZWpKv2Pr1L2ut70vyslLKGzoIEQAAAAAAAAAAAAAAAAAAAAAAAAAAAADoKU0PYKBqrVcm+fkk3zCFxz0+yetrrS9I8gOllBun8EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOdW5x0AMH211mcl+YtMp+HBfX1Dkr+otX77lJ8LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPSQpgcwMLXWa5P8VpJDHW1xKMkba60v7Oj5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBPaHoAA1Jr/Z4kP5dkpeOtVpK8otb6vI73AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWmKYHMBC11icmeU3Ga3jwZ0l+MMnjk1yY5Jyt35+Q5IeSvGeMZ6wkec3WvgAAAAAAAAAAAAAAAAAAAAAAAAAAAADAElqfdwDA3tVaz0/yhpxpXrCbDyZ5QSnlj7YZuzXJe7d+/Vyt9WlJXp3kil2ed26SN9Rary6l3DF55AAAAAAAAAAAAAAAAAAAAAAAAAAAAABAn63OOwBgKl6S5PKGOe9M8sQdGh48QCnlHUmekORdDVMvT/LicZ4JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyLpgfQc7XWw0mubZj27iTPKKXcPsmzSym3Jfm2JH/eMPVFtdYvneTZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED/aXoA/VeSrO8yfkuS7yqlHGv18FLuSvLsJLftMm09yY+3eT4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA0F+aHkCP1Vq/KMl3NEz7sVLKTXvZp5Ty8ZxprrCb76y1Xr6XfQAAAAAAAAAAAAAAAAAAAAAAAAAAAACAftH0APrt2iRru4x/MMkvTGmvVyX5yC7ja0leOKW9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAe0PQAeqrWuprkuxum/UwpZXMa+5VSNpL8bMO0527FBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAV9ODv11TZJLdxk/keTXprzna5Pcvcv4w5M8ecp7AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAALan3eAQCtPb1h/C2llDunuWEp5fZa6x8mecYu056e5F3T3BcAAAAAAAAAAAAAAAAAWEzPOfLKC5NcOsVHfvr1F197yxSfBwAAAAAAAAAAdEzTA+ivb2wYf0tH+74luzc9eFpH+wIAAAAAAAAAAAAAAAAAC+I5R175lCSvSHK4g2ffkOTa11987R9P+9kAAAAAAAAAAMD0rc47AGBytdZL0/xDgO/saPt3NIxfVWt9WEd7AwAAAAAAAAAAAAAAAABzttXw4F3poOHBlsNJ/stzjrzyyR09HwAAAAAAAAAAmCJND6CfntQwflMp5aYuNi6lfCzJpxqmPbGLvQEAAAAAAAAAAAAAAACAhfCKge0DAAAAAAAAAADsgaYH0E+Paxh/X8f7v7dhvCk+AAAAAAAAAAAAAAAAAKCHnnPklRclOTyj7a56zpFXXjijvQAAAAAAAAAAgJY0PYB+urph/P0d7//fG8Y1PQAAAAAAAAAAAAAAAACAYXrYjPe7dMb7AQAAAAAAAAAAE9L0APrpMQ3jH+x4/w83jH9Jx/sDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtA0wPop8saxj/U8f5Nz7+84/0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAWg6QH0TK31YUkONEz7ZMdhND3/YK31ko5jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADmTNMD6J+HjzHnMx3HcPMYc8aJEwAAAAAAAAAAAAAAAAAAAAAAAAAAAADoMU0PoH8uahi/o5Ryd5cBlFKOJznaMK0pTgAAAAAAAAAAAAAAAAAAAAAAAAAAAACg5zQ9gP65sGH8jplE0bxPU5wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQM+tjEajeccATKDW+gNJXr3LlBtKKVfNII6/SXLlLlN+oJRyXddxjKPWem2SF85gqyuS7Nvm9Q8k+foZ7A9NHppkbZvXN5N8bsaxAAAwfOpPAABmSf0JAMAsqT8BAJgl9ScAALM0Vv35yaceeuxdjzr3v84qqAfddPLrH/FHRz8wq/1YbqWUz847BgAAAAAAAACAPlqfdwDAxPY3jB+bSRTJXQ3jTXHO0sVJDs9x/5V4v2UxrGXns+iMAgAwbepPAABmSf0JAMAsqT8BAJgl9ScAALM0Vv25ujFaWxmNZhPR1n5R/wIAAAAAAAAAwEJbnXcAwMTObRjfmEkUzfs0xQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9JymB9A/mh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtB0wPon6Z7uzmTKJr3WZtJFAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA3Gh6AP2z0TC+PpMomvc5NZMoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC5mdWXowPTc7JhfFb3+pyG8aY4Z+lIkhtmsM8VSfZt8/oozc0qYBY2d3ndGQUAYNrUnwAAzJL6EwCAWVJ/AgAwS+pPAABmaaz68/T6yuZoZWU2EW3tF/UvAAAAAAAAAAAsNE0PoH9ONYyfO5MoetT0oJTyyiSv7HqfWuv1SQ5vM7RZSvls1/tDk1prsv1n/4YzCgDAtKk/AQCYJfUnAACzpP4EAGCW1J8AAMzSuPXnc4688uKZBZXkjsfuv+UXvu5H1L8AAAAAAAAAALDAVucdADCxow3j580kiuT8hvGmOAEAAAAAAAAAAAAAAAAAAAAAAAAAAACAntP0APrnlobxWTU9aNqnKU4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOc0PYD++XzD+INnEUSSCxrGm+IEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHpO0wPon881jO+rtT64ywBqrRclObdhmqYHAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBwmh5A/3xijDlf0HEM4zx/nDgBAAAAAAAAAAAAAAAAgH65ecb7fXrG+wEAAAAAAAAAABPS9AB6ppRyNMnnGqZ9YcdhND3/s6WUuzqOAQAAAAAAAAAAAAAAAACYsddffO3nk9wwo+2uf/3F194yo70AAAAAAAAAAICWND2Afvpow/iXdLx/0/Ob4gMAAAAAAAAAAAAAAAAA+uvaGe3zgzPaBwAAAAAAAAAA2ANND6Cfrm8Yf2zH+z+mYbwpPgAAAAAAAAAAAAAAAACgp15/8bV/nOQp6e7fE16f5Clb+wAAAAAAAAAAAAtufd4BAK38VZLv3WX8cR3v//iG8b/qeH8AAAAAAAAAAAAAAAAAYI62GhJ82XOOvPLCJJdO8dGffv3F194yxecBAAAAAAAAAAAd0/QA+ul9DeNX11rXSimb09641rqe5Csbpml6AAAAAAAAAAAAAAAAAABLYKtBgSYFAAAAAAAAAACwxFbnHQDQyl8mObHL+KEkX9XR3k9KcnCX8RNJ3tvR3gAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAtH0AHqolHIiyZ82THtaR9t/Y8P4n2zFBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMnKYH0F/vaBh/Vkf7/qOG8bd3tC8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAsGA0PYD++q2G8cfXWh87zQ1rrVcl+fKGaW+c5p4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOLS9AB6qpTykSTvbpj2oilv+0MN4/9fKeWjU94TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhQmh5Av/2nhvHvq7VeOo2Naq2PTPK8hmm/Mo29AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB+0PQA+u1Xk3x2l/GDSV46pb3+Q5L9u4x/ZiseAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBJaHoAPVZKOZHkZxumPa/W+u172afW+p1Jntsw7eWllLv3sg8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA0C+aHkD/vTzJJxrmvLbW+qQ2D6+1fnWSX26Y9ok0N18AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZG0wPouVLKsSQ/0jDtvCRvr7U+fZJn11qfkeRtSQ41TP1npZTjkzwbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOg/TQ9gAEopv5XkNxqmXZDkzbXWX6+1XrnbxFrr4Vrr65O8Kcn5Dc/99VLKG8cOFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYjPV5BwBMzfOTPD7Jbg0NVpI8N8lza61/leTPknw0ydEk5yW5PMnXJvnKMfe8MckPtA0YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOg3TQ9gIEopR2ut/zDJnyR59BhLHrf1q61PJPmHpZSje3gGAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBjq/MOAJieUsonkjw1yYc73upDSa7Z2g8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFKaHsDAlFI+lOSJSd7W0RZ/mORJpZSuGysAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtufd4BANNXSrk1yTfVWr8nycuSXDKFx342yY+WUl43hWcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOwOu8AgO6UUl6b5IuSXJvkb1o+5m+21l+u4QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcF/r8w4A6FYp5a4kr0ryqlrrY5J8U5LHJ7kqySOSnJfkYJJjSe5M8ndJbkjyviRvLaV8cB5xAwAAAAAAAAAAAAAAAAAAAAAAAAAAAACLT9MDWCKllL9N8rfzjgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIbVeQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD0k6YHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAK5oeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArWh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtKLpAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0MrKaDSadwwAg1BrvSPJedsM3Z3kwzMOB7azlmRlm9dHSTZnHAsAAMOn/gQAYJbUnwAAzJL6EwCAWVJ/AgAwS+pPuL8Pl1K+bd5BAAAAAAAAAAD0wfq8AwAYkHN3eH1fksOzDAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZmF13gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9pOkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQiqYHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAK5oeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArazPOwCAAbktyYO3ef1kkptmGklyeJvXbphxDCyeK5Ls2+b1u5N8eMaxsFi8Z7ATZ4PtOBdsx7lgO+pPduI9g504G2zHuWA7zgXbUX+yE+8Z7MTZYDvOBTtxNjib+pOdeL9gJ84G23Eu2ImzwdnUn+zE+wU7cTbYjnPBTpwNzqb+ZCfL+n7h3AMAAAAAAAAAjGllNBrNOwYApqzW+oA391LKyjxiYXHUWq/PDj9cWkq5atbxsDi8Z7ATZ4PtOBdsx7lgO+pPduI9g504G2zHuWA7zgXbUX+yE+8Z7MTZYDvOBTtxNjib+pOdeL9gJ84G23Eu2ImzwdnUn+zE+wU7cTbYjnPBTpwNzqb+ZCfeLwAAAAAAAAAAaLI67wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB+0vQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoRdMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgFU0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVjQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaEXTAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBVNDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFY0PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhF0wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAVTQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBW1ucdAACdqPMOAOgV7xnsxNlgO84F23EugEl4z2AnzgbbcS7YjnMBTMJ7BjtxNtiOc8FOnA1gXN4v2ImzwXacC3bibADj8n7BTpwNtuNcsBNnAxiX9wsAAAAAAAAAAHa1MhqN5h0DADADtdbrkxzeZuiGUspVs44HAIBhU38CADBL6k8AAGZJ/QkAwCypPwEAmCX1JwAAAAAAAAAA0NbqvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6SdMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgFU0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVjQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaEXTAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBVNDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFY0PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhF0wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCV9XkHAADMzKuSXLzN60dmHQgAAEtB/QkAwCypPwEAmCX1JwAAs6T+BABgltSfAAAAAAAAAABAKyuj0WjeMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD20Ou8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAftL0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaEXTAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBVNDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFY0PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhF0wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAVTQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBWND0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABa0fQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoRdMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgFU0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVjQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaEXTAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBVNDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFY0PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrR9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhF0wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAVTQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBWND0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABa0fQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoRdMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgFU0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVjQ9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaEXTAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBVNDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFbW5x0AANC9Wuu+JI9J8sgk5yU5mORYkjuT/F2SD5RSTs4vQgAAujTEelBOAACLa4h1jZwAABbXEOsaOQEALK4h1jVyAgBYbEOsbeQEAAAAAAAAAADDtDIajeYdAwDQgVrrVyd5ZpJvTnJVkrVdpm8muT7JW5O8qZTyns4DBACgU0OsB+XUj5wAgO3VWs9JcmWSL8uZz/0vy5l/6P7grV8X5Mzn/fEktyb5VJKPJnl/kr9I8u5Syt2zjntcQ6xr5NSPnACAB6q1riS5LMlXJPniJI9O8qit3y9M8qCc+bKlg0k2kpxIcluSm5N8PMkNSd6X5E9KKbfONvrxDLGukVM/cgIAltMQ6xo59SMnAGB5DbG2kVM/cgIAAAAAAAAAgL3Q9AAABqbW+l1J/kWSx+/hMe9L8rJSyhumExUAwGLb+hKwK5I8MckTtn5/XJJDuyz7eCnlsu6jm8wQ60E57WihcgIA7q/WupozNeU1SZ6a5Oty5stl2zqW5O1JXpvk90spG3sOcgqGWNfIaUcLlRMA8PdqrZcl+dqtX4/LmQZbu/3d5rhGSd6T5D8neV0p5ZYpPHNPhljXyGlHC5UTADB9tdaHJPmbJF8wxvTXllK+t9uIHmiIdY2cdrRQOQEAf6/WOu9/APu0Uso7Z7XZEGsbOe1ooXICAAAAAAAAAIBp0PQAAAai1nplkp9P8g1TfOz/m+QHSik3TvGZAABzV2t9dP6+ucETtn49eMLHLFTTgyHWg3Iam7odABZErXU9ZxocPDvJM5Nc2NFWH03y0iS/VErZ7GiPXQ2xrpHT2NSfALAgaq3/V5LvTvKIGWx3PMkvJ3lJKeWzM9jvfoZY18hpbOpPABioWusvJ/m+MafPtOnBEOsaOY1N/QkAC2ZZmh4MsbaR09jUoAAAAAAAAAAADIamBwAwALXWZyV5bZJDHTz+aJLnlVJ+p4NnAwB0rtb6BTnT3OCeBgdPTHLxFB69ME0PhlgPymli6nYAmKNa61VJfjjJtye5aIZbvy/J95dS/mqGew6yrpHTxNSfALAAaq1/meSrZrztnUl+tJRy3aw2HGJdI6eJqT8BYGBqrdck+aMJlsys6cEQ6xo5TUz9CQALZBmaHgyxtpHTxNSgAAAAAAAAAAAMwuq8AwAA9qbWem2S30o3PzSbree+sdb6wo6eDwDQtbcl+b0kP57kWzKdhgcLY4j1oJxaUbcDwHw9Pcn3Z7YND5Lk8UneXWt9/qw2HGJdI6dW1J8AsLzOS/LztdY31loPdL3ZEOsaObWi/gSAAdmqI39h3nFsZ4h1jZxaUX8CADMzxNpGTq2oQQEAAAAAAAAAGARNDwCgx2qt35Pk55KsdLzVSpJX1Fqf1/E+AABMYIj1oJz2RN0OAMtpX8586exLut5oiHWNnPZE/QkAy+1ZSf6o1trVFzwNsq6R056oPwFgOGqSK+YdxNmGWNfIaU/UnwBA54ZY28hpT9SgAAAAAAAAAAD0nqYHANBTtdYnJnlNxvuh2T9L8oNJHp/kwiTnbP3+hCQ/lOQ9YzxjJclrtvYFAGDOhlgPyqkfOQEAU7GZ5P1J3pDkpUn+eZIXJPmnSf59kl9K8oEJn/nvaq3/appB3tcQ6xo59SMnAGDPTif5WJK3J3l1kp9K8q+TXJvkRUl+LMnLkvxOko8mGU3w7K9J8tu11qn/DNoQ6xo59SMnAKBbtdbH5czfgy6UIdY1cupHTgDA8hpibSOnfuQEAAAAAAAAAABdWhmNJvl3qgDAIqi1np/kr5Nc3jD1g0leUEr5ozGe+bSc+ZKLKxqmfjTJ1aWUO8YIFQBg7mqtf53kKzt49MdLKZd18NxGQ6wH5dSPnACA7W01G/iphmk3Jvm9JG9N8t9KKcfGeO6lSf5JznwZ7UVjhDJK8q2llD8YY+7YhljXyKkfOQEAu6u1/mWSrzrr5U8n+dMkf7L1+w2llLsneOYlSZ6b5B8n+fIxl/14KeUnxt1jjBgGV9fIqR85AQDdqrWuJfnznPkC0Em9tpTyvdON6Iwh1jVy6kdOAMB4aq27/QPY30vyux2H8AellE9N84FDrG3k1I+cAAAAAAAAAACga+vzDgAAaOUlaf6h2Xcm+UellNvHeWAp5R211ickeWOSa3aZenmSFyf5Z+M8FwCgh0ZJPpQzXw729XOOZSdDrAflNIYFyAkAmMxtSX4lya+WUt436eJSyqeT1FrrTyd5eZLvb1iykuQXa62HSym3TbrfLoZY18hpDAuQEwDQ7HSS9yR5c5I3l1I+sJeHlVI+m+TltdafzZn686VJLmxY9m9rrb9aSvnYXva+jyHWNXIawwLkBAB060eyc8ODjyT5ohnGcl9DrGvkNIYFyAkA2Lv3lVJ+cd5BtDDE2kZOY1iAnAAAAAAAAAAAoFOr8w4AAJhMrfVwkmsbpr07yTPG/aHZe2x9Edq3JfnzhqkvqrV+6STPBgBYYB9L8ptJ/mWSpyZ5SCnlMUnKPIPayRDrQTn1IycAYCIfSvL8JI8opfzTNg0P7quUclcp5f9M8j1JNhumX5ozte1UDLGukVM/cgIAxvLvkjy8lPK1pZSX7bXhwX2VUkallNckeVKSmxqm70vyY9PYd4h1jZz6kRMA0K1a6xU584Wd2/mzJL82u2j+3hDrGjn1IycAYHkNsbaRUz9yAgAAAAAAAACAWdD0AAD6pyRZ32X8liTfVUo51urhpdyV5NlJbttl2nqSH2/zfACAOftkkjflzBdwfVOSh5ZSLi+lPHvrS8HeNek/PpqDIdaDcpr04ep2AFhUf5vkf09yZSnlF9p+1u+klPK6JC8aY+qLaq3nT2vbDK+ukdOkD1d/AsBCKqW8tZTymY73+HCSb0hyZ8PU59Raz5vGlhleXSOnSR+u/gSAIbouyYFtXj+VMw1kR7MN515DrGvkNOnD1Z8AwGwNsbaR06QPV4MCAAAAAAAAADBQmh4AQI/UWr8oyXc0TPuxUspNe9mnlPLxnPkB3d18Z6318r3sAwAwIz+X5OlJHlZKeWQp5dtLKT9ZSnlbKeXz8w5uEkOsB+XUnrodABbKZ5K8MMlVpZRfL6VsdrVRKeXVSV7XMO1BOfOP4/dkiHWNnNpTfwLA8iqlfDTNdcCDkjx1L/sMsa6RU3vqTwAYjlrrP87OteL/XUr5n7OM5x5DrGvk1J76EwCYhSHWNnJqTw0KAAAAAAAAAMAQaXoAAP1ybZK1XcY/mOQXprTXq5J8ZJfxtZz5IjcAgIVWSvmlUsrvl1I+M+9YpmCI9aCc9kbdDgALoJTyn0opry6lbMxoy3+d5FjDnGdOYZ8h1jVy2hv1JwAsr1ckubVhztfvcY8h1jVy2hv1JwD0XK31kiQ/vcPwR5K8ZIbhnG2IdY2c9kb9CQB0bYi1jZz2Rg0KAAAAAAAAAMCgaHoAAD1Ra11N8t0N036mlLI5jf22vqDtZxumPXcrLgAAOjbEelBOe6duB4DlVEr5VJL/p2HaP1DX3J+c9k79CQDLq5RyKskfNEy7su3zh1jXyGnv1J8AMAg/l+QhO4y9sJRyfJbB3GOIdY2c9k79CQB0aYi1jZz2Tg0KAAAAAAAAAMDQ+EEXAOiPa5Jcusv4iSS/NuU9X5vk7l3GH57kyVPeEwCA7Q2xHpTTdKjbAWA5/X7D+PlJvnAPzx9iXSOn6VB/AsDyenfD+MP38Owh1jVymg71JwD0VK31W5M8e4fhN5RS3jbLeM4yxLpGTtOh/gQAujLE2kZO06EGBQAAAAAAAABgMDQ9AID+eHrD+FtKKXdOc8NSyu1J/rBhWlNcAABMxxDrQTlNgbodAJbWfx1jzhft4flDrGvkNAXqTwBYap9pGH/QHp49xLpGTlOg/gSAfqq1npfk1TsM35bkh2cWzPaGWNfIaQrUnwBAh4ZY28hpCtSgAAAAAAAAAAAMiaYHANAf39gw/paO9m167tM62hcAgPsbYj0op+lRtwPAkiml3JLkZMO0B+9hiyHWNXKaHvUnACynOxrGj+3h2UOsa+Q0PepPAOiflyZ55A5j/7qUcvMsg9nGEOsaOU2P+hMA6MIQaxs5TY8aFAAAAAAAAACAQdD0AAB6oNZ6aZLDDdPe2dH272gYv6rW+rCO9gYAIMOsB+U0dep2AFhOn2sYP9DmoUOsa+Q0depPAFhOlzSMN9Wn2xpiXSOnqVN/AkCP1Fr/lyQv2GH43Umum2E4DzDEukZOU6f+BACmaoi1jZymTg0KAAAAAAAAAMAgaHoAAP3wpIbxm0opN3WxcSnlY0k+1TDtiV3sDQDAvYZYD8ppitTtALC0DjaMn2j53CHWNXKaIvUnACytRzaMf6Tlc4dY18hpitSfANAftdZzk7wmyco2wxtJnl9KGc02qgcYYl0jpylSfwIAHRhibSOnKVKDAgAAAAAAAAAwFJoeAEA/PK5h/H0d7//ehvGm+AAA2Jsh1oNymj51OwAskVrreUkuaJh2a8vHD7GukdP0qT8BYPl8U8P4n7R87hDrGjlNn/oTAPrh3yY5vMPYfyyl/I9ZBrODIdY1cpo+9ScAME1DrG3kNH1qUAAAAAAAAAAAek/TAwDoh6sbxt/f8f7/vWHcD84CAHTr6obxPtaDVzeMy2ly6nYAWC5XJ1lpmPPhPTx7N32sa65uGJfT5NSfALBEaq2PSvJ1u0zZSPLOlo+/umG8j3XN1Q3jcpqc+hMAFlyt9XCSf7XD8MeS1NlFs6urG8b7WNdc3TAup8mpPwGAabq6YbyPtc3VDeNympwaFAAAAAAAAACA3lufdwAAwFge0zD+wY73b/pytC/peH8AgGU3xHpQTtOnbgeA5fK/NozfkeQTLZ89xLpGTtOn/gSA5fLyJGu7jL+xlPKpls8eYl0jp+lTfwLAAqu1rib5xSTn7jDlhaWUYzMMaTdDrGvkNH3qTwDomVrrOUmuSPLoJBcm2Z/kVJLjSW5L8ndJbiqlHJ9DeEOsbeQ0fWpQAAAAAAAAAAB6T9MDAOiHyxrGP9Tx/k3Pv7zj/QEAlt1lDeN9rAcv2+OeeyUnAKC3tr5A7NkN0/60lHK65RaXNYz3sa65bI977pWcAIDeqrX+cJJn7TJlI8lL97DFZQ3jfaxrLtvjnnslJwBg1q5N8jU7jP3nUspbZxlMg8saxvtY11y2xz33Sk4AwLwcrrW+LMlTknx5kn0N80/XWv82yXuTvCPJW0spn+04xmSYtc1le9xzr+QEAAAAAAAAAAALaHXeAQAAu6u1PizJgYZpn+w4jKbnH6y1XtJxDAAAS2mI9aCcOqNuB4Dl8Yw0/2P2323z4CHWNXLqjPoTAAau1npOrbUm+ZmGqT9VSvnrlnsMrq6RU2fUnwCwoGqtj0rykzsM357kh2cXze6GWNfIqTPqTwDoh+9M8qNJnpDmhgfJmX9Pe2WS/y3JryT5dK31D2qtT6+1rnQR4BBrGzl1Rg0KAAAAAAAAAEDvaXoAAIvv4WPM+UzHMdw8xpxx4gQAYHJDrAfl1A11OwAsgVrrWpKXNEw7meQ3W24xxLpGTt1QfwLAQG01O3hGkr9O8uMN09+W5Cf2sN0Q6xo5dUP9CQCL61VJztth7N+UUj49y2AaDLGukVM31J8AsBxWk3xzkt9N8t5a69M62GOItY2cuqEGBQAAAAAAAACg9zQ9AIDFd1HD+B2llLu7DKCUcjzJ0YZpTXECANDOEOtBOXVA3Q4AS+P5Sb6sYc5rSym3tHz+EOsaOXVA/QkA/VdrXau1PrjW+uha69fUWl9Qa/3FJJ9K8qYkhxse8fYkzyylnNpDGEOsa+TUAfUnACymWutzknzrDsP/LcnPzzCccQyxrpFTB9SfALCUHpfk7bXWX661nj/F5w6xtpFTB9SgAAAAAAAAAAAMwfq8AwAAGl3YMH7HTKI4s8+hXcab4gQAoJ0h1oNy6o66HQAGrNb6hUle2jDtVJL/sIdthljXyKk76k8AWGC11i9O8sEOHr2R5CeT/EQpZXOPzxpiXSOn7qg/AWCB1FovTPKzOwxvJPknpZTTMwxpHEOsa+TUHfUnACyn70vy1bXWp5dSPjyF5w2xtpFTd9SgAAAAAAAAAAD02uq8AwAAGj2kYXyWPzi7Gz84CwDQjSHWg3LqjrodAAaq1rqa5FeSnNcw9eV7/OKFIdY1cuqO+hMAlssoye8meWIp5cVTaHiQDLOukVN31J8AsFj+Y5JLdhj7mVLK+2cZzJiGWNfIqTvqTwBYXl+a5D211qum8Kwh1jZy6o4aFAAAAAAAAACAXlufdwAAQKP9DePHZhJFclfDeFOcAAC0M8R6UE7dUbcDwHDVJE9umHNTkp/Y4z5DrGvk1B31JwAshw8k+Z0kv1ZKuX7Kzx5iXSOn7qg/AWBB1Fq/Mcn37DD88SQvnl00ExliXSOn7qg/AWCx/c8k703yP7Z+3ZTk9q1fJ3Pmy+EvyplGXV+d5OuTfG2S88d8/kOTvLPW+rWllI/sIc4h1jZy6o4aFAAAAAAAAACAXtP0AAAW37kN4xsziaJ5n6Y4AQBoZ4j1oJy6o24HgAGqtX5Lkn/TMG2U5P8opdy5x+2GWNfIqTvqTwAYvo0kH07yd2n+sqU2hljXyKk76k8AWAC11oNJrttlyrWllFl9IeikhljXyKk76k8AWCybSf4wye8neUsp5aaG+Z/Z+nVDkj9O8tJa6/4k35vknye5Yow9H5bkjbXWrymlnGgZ9xBrGzl1Rw0KAAAAAAAAAECvaXrw/7d398G2XnV9wL8JSTCvgJGgjbwIJlEQgaBQlGIgoaKtceKE1lINSZXBmZrEQVr74mTlBx0GYYZeKI4IDiZVilAQLChvVpoKxqIiiiIaMDGAGF6khLeEvNz+cS61ae49z9nPfp599l7785k5f6111lrfv8537uy7fwCw/nxwFgBgu/XYB2Waj94OAJ2pqocmeXWSowe2vrS19o4Jruyx18g0H/0TAPp3TJLvPfTzkqr6tSQvaK397kTn99hrZJqP/gkA6+E5SR58hLXXtdZ+fZWPWVCPvUam+eifALAePp7kF5L8fGvtY8scdGhwwcuq6uVJLkvygiTHDvzaI5M8L8mzRl7bY7eRaT46KAAAAAAAAAAAG23oy1EAgP039Pf6jpW8Yviee6zkFQAA26fHPijTfPR2AOhIVd03yZuSnDKw9feSPHuia3vsNTLNR/8EgO1ydJILklxbVf+lqu4z0Zm72cReI9N89E8A2GdV9egkP3GE5ZuTXL6614zSY6+RaT76JwCshwe01q5YduDB/6u1dmdr7UCSxyf5qz38yqVV9fCR1/XYbWSajw4KAAAAAAAAAMBGM/QAANbf7QPrx6zkFcP33LaSVwAAbJ8e+6BM89HbAaATVXVidgYePHhg66eTPLW19uWJru6x18g0H/0TANbbJ5I8Y5efy5JckeRFSf5r9vblXl/xz5K8v6oet+Qbe+w1Ms1H/wSAfVRVxyT5hRz5Szb/XWvtr1f4pDF67DUyzUf/BIA10Fob6gbLnP2eJE9IcuPA1mOSPGfkNT12G5nmo4MCAAAAAAAAALDRVvVBGwBgvKEvK1vV3/NjB9an+lI1AADuqsc+KNN89HYA6EBVHZfk9UkeO7D1S0nOb60t8uW0Q3rsNTLNR/8EgDXWWrs5O19Ku2dVdd8kFyR5ZpKzB7afnuRtVfU9rbV3j3tll71GpvnonwCwv56d5JFHWHtPkp9b3VNG67HXyDQf/RMAtkBr7caquiDJu5N81S5bz6+qM1pr1y14RY/dRqb56KAAAAAAAAAAAGy0o/f7AQDAoNsG1o9bySt8cBYAYL/02Adlmo/eDgAbrqqOTvJLSb57YOttSS5srf3OxE/osdfINB/9EwA601r7ZGvt5a21Ryd5UpIPD/zKyUneWlUPHXllj71GpvnonwCwT6rqG5NccYTl25M8s7V25wqfNFaPvUam+eifALAlWmvvTfK8gW1HJ/mhEcf32G1kmo8OCgAAAAAAAADARjP0AADW3+cH1k9eySuSUwbWh94JAMA4PfZBmeajtwPABquqo5K8PMk/Gdh6Z5KLWmu/McMzeuw1Ms1H/wSAjrXW3pnkW5O8cmDrSUl+uaqGvozpcHrsNTLNR/8EgP3z8iTHH2Htxa21963wLcvosdfINB/9EwC2ywuT3DSw58IR5/bYbWSajw4KAAAAAAAAAMBGM/QAANbf3w6sr+qDs0P3DL0TAIBxeuyDMs1HbweAzfaiJD+yh30/1lr7lZne0GOvkWk++icAdK619sUkP5rhwQePSvJTI67osdfINB/9EwD2QVX9SJInHmH5r5K0FT5nWT32Gpnmo38CwBZprd2S5GUD2x5aVacteHSP3Uam+eigAAAAAAAAAABsNEMPAGD9fXpg/d6reESSew2sD70TAIBxeuyDMs1HbweADVVV/yHJT+xh60+21l4x41N67DUyzUf/BIAt0Fo7mOQZSf7HwNbLq+r4BY/vsdfINB/9EwBWrKrul+SFu2z58dbaF1b1ngn02Gtkmo/+CQDb57V72PO4Bc/ssdvINB8dFAAAAAAAAACAjWboAQCsv08NrN+zqu495wOq6tQkxw1s88FZAIB59NgHZZqB3g4Am6uqfirJv9/D1tZae9HMz+mx18g0A/0TALZLa+3OJJcmuWOXbV+T5KIFj+6x18g0A/0TAPbNS5Pc5whrr2+tvXmVj5lAj71GphnonwCwnVprH0hy08C2b1rw2B67jUwz0EEBAAAAAAAAAOiBoQcAsP5u3MOe+838hr2cv5d3AgCwuB77oEzz0NsBYANV1WVJnr+HrS9srT1n7vekz14j0zz0TwDYMq21P0nymoFt5y94bI+9RqZ56J8AsGJVdX6SC4+wfHOSy1b4nKn02Gtkmof+CQDb630D6w9a8Lweu41M89BBAQAAAAAAAADYeIYeAMCaa619PsmnBrY9cOZnDJ3/idbaF2Z+AwDAVuqxD8o0G70dADZMVT0jyYE9bP3Z1tq/nvk5SfrsNTLNRv8EgO30xoH1x1fVnj+T1mOvkWk2+icArN6Ldln76dbaX6/sJRPpsdfINBv9EwC21w0D66ctcliP3Uam2eigAAAAAAAAAABsvGP2+wEAwJ5cn+Rrdlk/I8nbZ7z/jIH162e8GwCAPvugTNPT2wFgg1TVDyd5WZKjBra+Msml87/oLnrsNTJNT/8EgO301iR3JjnSYINTkpyV5M8WOLPHXiPT9PRPAFi9I/3tvznJrVX1oxPedfbA+hl7uO+a1tp1e7irx14j0/T0TwDYXp8dWD9hxJk9dhuZpqeDAgAAAAAAAACw8Qw9AIDN8KdJvn2X9bNmvv/MgfU/nfl+AIBt12MflGl6ejsAbIiqemqSX8yRvyj2K16d5BmttYPzv+oueuw1Mk1P/wSALdRa+1xVfSrJabtsOy2LDT3osdfIND39EwDWxylJfn7Fd37HoZ/dXJJkL0MPeuw1Mk1P/wSA7fXlgfVjR5zZY7eRaXo6KAAAAAAAAAAAG2/oi1QAgPXwhwPrj5r5/rMH1ofeBwDAcnrsgzJNT28HgA1QVecneVWSewxsfUOSi1prd87/qrvpsdfIND39EwC2100D66cueF6PvUam6emfAMBUeuw1Mk1P/wSA7XX8wPqXRpzZY7eRaXo6KAAAAAAAAAAAG8/QAwDYDO8dWH9kVQ19SdooVXVMkkcMbPPBWQCAefXYB2WakN4OAJuhqr47yWuTHDuw9S1JfrC1dvv8rzqsHnuNTBPSPwFg6908sD70pWD/vx57jUwT0j8BgIn12GtkmpD+CQBb72sH1j8/4sweu41ME9JBAQAAAAAAAADohaEHALAZfj/JLbusn5Tk0TPd/ZgkJ+yyfkuSP5jpbgAAdvTYB2Walt4OAGuuqs5J8oYk9xzY+ltJfqC19uW537SLHnuNTNPSPwFgu504sP6FBc/rsdfINC39EwCYUo+9RqZp6Z8AsN0eMrD+sRFn9thtZJqWDgoAAAAAAAAAQBcMPQCADdBauyXJuwa2PXmm688bWP/tQ+8DAGAmPfZBmSantwPAGquqxyV5U5LjB7a+K8n5+/13u8deI9Pk9E8A2G73H1j/zCKH9dhrZJqc/gkATKbHXiPT5PRPANhSVXVckkcNbLt+0XN77DYyTU4HBQAAAAAAAACgC4YeAMDmeMfA+g/MdO+FA+tvn+leAADuqsc+KNN09HYAWFNVdXaStyQ5aWDre5L8o9baF+Z/1Z702Gtkmo7+CQBbqqpOT3LqwLa/HHF0j71GpunonwDA1HrsNTJNR/8EgO11XpJ7Duz545Fn99htZJqODgoAAAAAAAAAQBeO2e8HAAB79rokP7PL+tlVdVZr7c+nurCqHpbk4QPbXj/VfQAA7KrHPijTBPR2AFhfVfUt2fmP5/ca2PpHSZ7SWrt5/lftWY+9RqYJ6J8AsPX+4cD655J8dMS5PfYamSagfwLA/mmt3XtVd1XVlUnaLluubq1dPOGVPfYamSagfwLA1rtoYP22JL8/8uweu41ME9BBAQAAAAAAAADoydH7/QAAYG9aa3+Z5NqBbZdOfO1lA+vvbq1dP/GdAAAcRo99UKbJ6O0AsIaq6swkv5nk1IGtH0jy5NbaZ+Z/1d712Gtkmoz+CQDb7eKB9Xe11g4uemiPvUamyeifAMDkeuw1Mk1G/wSALVVVZyS5cGDb/2ytfWnM+T12G5kmo4MCAAAAAAAAANANQw8AYLP84sD6JVX1dVNcVFVfn+SigW1XTXEXAAB71mMflGkJejsArKeqelCS/57kfgNbr0tyXmvtk7M/apwee41MS9A/AWC7VdUTkzxhYNvblriix14j0xL0TwBgZj32GpmWoH8CwNZ7SZJ7DOx57ZJ39NhtZFqCDgoAAAAAAAAAQG8MPQCAzfJLST6xy/oJSZ4/0V0/k+Srdlm/6dB7AABYnR77oEzL0dsBYM1U1d/LzsCDrx/YekOSc1trH5/9UeP12GtkWo7+CQBbqqpOTvKKgW23J3n1Etf02GtkWo7+CQDMqcdeI9Ny9E8A2FJV9ewkTxnYdnOS1yx5VY/dRqbl6KAAAAAAAAAAAHTF0AMA2CCttVuSvHhg20VVdcEy91TVU5M8bWDbgdbarcvcAwDAYnrsgzKNp7cDwPqpqvsm+c0kDx7Y+tEkT2qtfWT+V43XY6+RaTz9EwDWR1WdU1X3WuF9JyR5Q5KHDGz9ldbabl8Etasee41M4+mfAMDceuw1Mo2nfwLAeqmqs6vq+BXd9fTsfPH8kJ9rrX12mbt67DYyjaeDAgAAAAAAAADQI0MPAGDzHEhy48Ceq6vqMWMOr6q/n+SVA9tuzPAHeAEAmMeB9NcHD0SmhejtALB+qureSd6e5JsHtv5NknNba9fP/qhpHEh/veZAZFqI/gkAa+fiJNdX1U9X1clzXlRVZyZ5Z5JzB7beluTKCa48kP56zYHItBD9EwBYoQPpr9cciEwL0T8BYC1dlOTDVXVZVZ04xwVVdVxVHUhyVYb/n+1NSZ4/0dUH0l+3ORCZFqKDAgAAAAAAAADQK0MPAGDDtNa+mOQnB7adnOTtVfV9i5xdVd+f5G1JThrY+qzW2pcWORsAgGn02Adl2oxMAMCRVdVJSX4jySMHtn4qyXmttb+Y/VET6bHXyLQZmQCAQfdJ8twkN1TVi6vqO6vqqKkOr6qTquq5Sd6fZC9f2vSc1tqHl723x14j02ZkAgC2U4+9RqbNyAQA7MnXZecL3z9SVf+xqh4x1cFVdU6SdyW5fI+/cnlr7X9PcXeP3UamzcgEAAAAAAAAAACrcNTBgwf3+w0AwAhV9aokTxvYdjDJq5M8t7X2wV3OemiSK5L80z1c/arW2g/t+aEAAGugqp6Q5MwFf+2sJM/eZf3TSf7NiOdc01q7bsTv3UWPfVCmzcgEANxdVb0pyT/ew9afTfK+eV9zFx9vrf36FAf12Gtk2oxMAMDdVdVVSZ5+mKWPJXldknck+d3W2qcXPPfkJI9P8s+TXJDkhD3+6juTPLm1dsci9w28pbteI9NmZAIA9kdVXZmk7bLl6tbaxTPe312vkWkzMgEAh1dVB3L4gQR/keTNSX4rybWttb9d4MyvTXJekkuzt0GvX/GfWmuXLbB/r+/prtvItBmZAAAAAAAAAABgTsfs9wMAgNGemeTsJN+0y56jsvPh2qdV1R8m+Z0k1yf5fJKTk3xDku9M8og93vnBJD829sEAAPvoX+TwXwK2jFOTvGLE712SZOmhB+mzD8q0GZkAgLt7+B73/ctZX3F31ySZZOhB+uw1Mm1GJgBg707PzheBXZ4kVfXRJH+e5IYkf5OdQa63Jrk9O3/3T05ySpIHZOdv/0Oy0xUW8f4kF0w58OCQHnuNTJuRCQDYTj32Gpk2IxMAsJgzkzzr0M/BqvpIdv5e35CdfwP9THb+DTRJ7pOdz3meluSxSc4Ycd8bD901hx67jUybkQkAAAAAAAAAAGZz1MGDB/f7DQDASFX1gCS/nZ0voZjbjUn+QWvtxhXcBQAwqaq6KtMPPRjrktbaVVMc1GMflGlpejsA7IOquiHJA/f7HYdxTWvtnKkO67HXyLQ0/RMA9sEa/Xvnu5N8X2vtM3Mc3mOvkWlp+icAdKqqrkzSdtlydWvt4pnf0F2vkWlp+icA7JOqOpBDw1330WuS/HBr7ba5Luix28i0NB0UAAAAAAAAAICNdvR+PwAAGO/Qh1jPTfLhma/6UJIn+dAsAMB66bEPyrQUvR0AmFWPvUampeifALC9DiZ5SZJz5xp4kPTZa2Raiv4JAMyqx14j01L0TwDYXnck+bettR+cc+BB0me3kWkpOigAAAAAAAAAABvP0AMA2HCttQ8l+fYkb5vpircmeUxrbe4P5wIAMEKPfVCmUfR2AGAleuw1Mo2ifwLA9vqj7Aw7uLy1duvcl/XYa2QaRf8EAFaix14j0yj6JwBsr99L8m2tteev6sIeu41Mo+igAAAAAAAAAAB04aiDBw/u9xsAgIlU1dOTvCDJaRMc94kk/6q19p8nOAsAYF9V1VVJnr7f7zjkktbaVXMc3GMflGnQWmQCgG1XVTckeeB+v+MwrmmtnTPX4T32GpkGrUUmANh2VfWoJE9L8j1JHraia/9XkgNJXttau3NFd95Fj71GpkFrkQkAmF9VXZmk7bLl6tbaxat5zY4ee41Mg9YiEwDwf//GX5HkwSu68r1JnpfkV1tr+/YfbnvsNjINWotMAAAAAAAAAAAwFUMPAKAzVXVidr7Q98eTfPOII/4syUuTXNVa++KUbwMA2C/bMvQg6bMPynRYa5cJALbZtg49SPrsNTId1tplAgB2VNUDkjwlyXckeWySs5IcNcHRdyZ5f5L/luR1rbU/nuDMpfXYa2Q6rLXLBADMax2HHiR99hqZDmvtMgEAO6rq/kmemOS7knxbdv7WHzvR8R9K8uYkv9xa+4OJzlxaj91GpsNau0wAAAAAAAAAADAFQw8AoGNVdWZ2vuDi7CQPS3J6kpOTnJDki0k+l+SjST6Q5L1J3tJau25/XgsAwNR67IMybUYmAGA79dhrZNqMTADA36mqeyV5dHaGH3zDoZ8HJfnqJCcmOSnJ8UnuSHJrdv7+fzLJTUluyM4XLf1Jkmtba59d7esX02OvkWkzMgEA06uqc5Kcs8uW97XW3riKtxxJj71Gps3IBAD8nao6Lsm3JPnW7Pzb5/0P/Zye5JTs/NvnCUnumeTLSW5J8tkkH89OB/hgdoa9Xttau3HV719Uj91Gps3IBAAAAAAAAAAAYxl6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjHL0fj8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYTIYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoxh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIqhBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCiGHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMYegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxi6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCKoQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAohh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjGHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMYugBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiqEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAKIYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoxh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIqhBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCiGHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMYegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxi6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCKoQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAohh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjGHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMYugBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiqEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAKIYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoxh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIqhBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCiGHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMYegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxi6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCKoQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAohh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjGHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMYugBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiqEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAKIYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoxh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIqhBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCiGHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMYegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxi6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCKoQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAohh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjGHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMYugBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiqEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAKIYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoxh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIqhBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCiGHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMYegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxi6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCKoQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAohh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjGHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMYugBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiqEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAKIYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoxh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGLoAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIqhBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCiGHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMYegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxi6AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCKoQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAohh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjGHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMYugBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiqEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAKIYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoxh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjPJ/AOh00olBAo3oAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 591, "width": 3102 }, "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# history by size out\n", "Z.plot_history_functions_scatter(log=2)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/mnt/ntfs/Sync/dev/python/autoray/autoray/lazy/draw.py:852: RuntimeWarning: divide by zero encountered in log2\n", " return np.log2(orig_fn(node)) / np.log2(log)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 602, "width": 3102 }, "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# history by cost\n", "Z.plot_history_functions_scatter(log=2, fn=cost_node)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 522, "width": 1767 } }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# combined cost into pie chart\n", "Z.plot_history_stats(fn=cost_node)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# scaling of every computational node" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "For actual complexity we need decomposed scaling of every node:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[{'cost': 354294,\n", " 'name': 'qr_stabilized_numba',\n", " 'freq': 14,\n", " 'p': 1,\n", " 'D': 11,\n", " 'chi': 0},\n", " {'cost': 354294, 'name': 'tensordot', 'freq': 7, 'p': 1, 'D': 11, 'chi': 0},\n", " {'cost': 236196,\n", " 'name': 'qr_stabilized_numba',\n", " 'freq': 2,\n", " 'p': 2,\n", " 'D': 10,\n", " 'chi': 0},\n", " {'cost': 236196, 'name': 'tensordot', 'freq': 1, 'p': 2, 'D': 10, 'chi': 0},\n", " {'cost': 65610,\n", " 'name': 'qr_stabilized_numba',\n", " 'freq': 7,\n", " 'p': 1,\n", " 'D': 8,\n", " 'chi': 1},\n", " {'cost': 65610, 'name': 'tensordot', 'freq': 7, 'p': 1, 'D': 8, 'chi': 1},\n", " {'cost': 60750,\n", " 'name': 'qr_stabilized_numba',\n", " 'freq': 112,\n", " 'p': 1,\n", " 'D': 5,\n", " 'chi': 3},\n", " {'cost': 60750, 'name': 'tensordot', 'freq': 56, 'p': 1, 'D': 5, 'chi': 3},\n", " {'cost': 43740, 'name': 'tensordot', 'freq': 1, 'p': 2, 'D': 7, 'chi': 1},\n", " {'cost': 39366, 'name': 'tensordot', 'freq': 8, 'p': 1, 'D': 9, 'chi': 0}]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "scalings = compute_cost_scalings(Z, factor_map)\n", "\n", "# these are sorted by cost\n", "scalings[:10]" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "If assume some relation like $\\chi \\sim D^p$ then you order all nodes. Or you\n", "can plot the scaling of each like so:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 241, "width": 557 }, "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "\n", "with mpl.style.context(qu.NEUTRAL_STYLE):\n", " plt.scatter(\n", " x=[s['D'] for s in scalings],\n", " y=[s['chi'] for s in scalings],\n", " c=[s['freq'] for s in scalings],\n", " s=400, marker='s', clip_on=False,\n", " alpha=1.0,\n", " )\n", "\n", " plt.xlabel('$D$ scaling')\n", " plt.ylabel('$\\\\chi$ scaling')\n", "\n", " plt.xlim(-0.5, None)\n", " plt.ylim(-0.5, None)\n", " plt.gca().set_aspect('equal')\n", " plt.colorbar(label='Repeats', shrink=0.6)\n", " plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "numpy", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.9" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 } autoray-0.6.12/autoray/lazy/000077500000000000000000000000001462076570400157425ustar00rootroot00000000000000autoray-0.6.12/autoray/lazy/__init__.py000066400000000000000000000036741462076570400200650ustar00rootroot00000000000000from . import linalg from .core import ( ascend, descend, compute, get_source, Function, LazyArray, Variable, shared_intermediates, array, transpose, reshape, tensordot, einsum, trace, diag, matmul, kron, clip, flip, sort, argsort, stack, concatenate, split, where, take, # binary multiply, add, floordivide, truedivide, # unary sin, cos, tan, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh, arctanh, sqrt, exp, log, log2, log10, conj, sign, angle, real, imag, # reductions prod, ) from .core import abs_ as abs from .core import sum_ as sum from .core import min_ as min from .core import max_ as max from .core import complex_ as complex __all__ = ( "ascend", "descend", "compute", "get_source", "Function", "LazyArray", "Variable", "shared_intermediates", "linalg", "array", # basic and shape changing functions "transpose", "reshape", "tensordot", "einsum", "conj", "trace", "diag", "matmul", "kron", "clip", "flip", "sort", "argsort", "stack", "concatenate", "split", "where", "take", # binary functions "multiply", "add", "floordivide", "truedivide", # unary functions "sin", "cos", "tan", "arcsin", "arccos", "arctan", "sinh", "cosh", "tanh", "arcsinh", "arccosh", "arctanh", "sqrt", "exp", "log", "log2", "log10", "conj", "sign", "abs", "angle", "real", "imag", # reduction functions "sum", "prod", "min", "max", "complex", ) try: from opt_einsum.backends.dispatch import _aliases _aliases["autoray"] = "autoray.lazy" except ImportError: # pragma: no cover pass autoray-0.6.12/autoray/lazy/core.py000066400000000000000000001424111462076570400172470ustar00rootroot00000000000000"""Core lazy array functionality. """ import operator import threading import functools import itertools import contextlib import collections from ..autoray import ( shape, astype, get_dtype_name, get_lib_fn, infer_backend, multi_class_priorities, register_backend, register_function, tree_flatten, tree_map, tree_iter, tree_unflatten, ) from .draw import ( plot_graph, plot_circuit, plot_history_size_footprint, plot_history_functions, plot_history_stats, ) _EMPTY_DICT = {} get_depth = operator.attrgetter("_depth") get_data = operator.attrgetter("_data") # ------------------------ traversal and computation ------------------------ # def is_lazy_array(x): """Check if ``x`` is a lazy array.""" return isinstance(x, LazyArray) def to_queue(lz): """Parse a pytree of lazy arrays into a queue of nodes, sorted by depth. This is useful for traversing the computational graph of multiple outputs in topological order. """ if isinstance(lz, LazyArray): return [lz] queue = tree_flatten(lz, is_lazy_array) queue.sort(key=get_depth) return queue def descend(lz): """Generate each unique computational node. Use ``ascend`` if you need to visit children before parents. Parameters ---------- lz : pytree of LazyArray The output node(s) of the computational graph to descend. Yields ------ LazyArray """ queue = to_queue(lz) seen = set() while queue: node = queue.pop() nid = id(node) if nid not in seen: yield node queue.extend(node._deps) seen.add(nid) def ascend(lz): """Generate each unique computational node, from leaves to root. I.e. a topological ordering of the computational graph. Moreover, the nodes are visited 'deepest first'. Parameters ---------- lz : pytree of LazyArray The output node(s) of the computational graph to ascend to. Yields ------ LazyArray """ queue = to_queue(lz) seen = set() ready = set() while queue: node = queue[-1] need_to_visit = [c for c in node._deps if id(c) not in ready] if need_to_visit: need_to_visit.sort(key=get_depth) queue.extend(need_to_visit) else: node = queue.pop() nid = id(node) ready.add(nid) if nid not in seen: yield node seen.add(nid) def compute(lz): """Compute the value of one or more lazy arrays. All nodes that are computed clear any references to their function, arguments and dependencies, and store the result in their ``_data`` attribute. Parameters ---------- lz : pytree of LazyArray The output node(s) of the computational graph to compute. Returns ------- array or tuple of array The computed value(s) of the lazy array(s). """ for node in ascend(lz): node._materialize() return tree_map(get_data, lz, is_lazy_array) def compute_constants(lz, variables): """Fold constant arrays - everything not dependent on ``variables`` - into the graph. Parameters ---------- lz : pytree of LazyArray The output node(s) of the computational graph. variables : pytree of LazyArray Nodes that should be treated as variable. I.e. any descendants will not be folded into the graph. """ variables = set(tree_iter(variables, is_lazy_array)) # must ascend for node in ascend(lz): if not any(c in variables for c in node._deps): # can fold node._materialize() else: # inherit variable status variables.add(node) def get_source(lz, params=None): """Write the source code of an unravelled version of the computational graph, injecting required runtime objects into ``params``. Parameters ---------- lz : LazyArray or sequence of LazyArray The output node(s) of the computational graph to write the source code for. Their corresponding label is ``f"x{id(node)}"`` in the source code. Returns ------- str The source code of the computational graph, suitable for ``exec``. """ if params is None: # locals space mapping LazyArray names to values params = {} delete_checked = set() s = [] # source code lines for node in reversed(tuple(ascend(lz))): # when *descending*, the first encounter of a node is the # *last* time it is referenced in forward pass -> delete, # need to do this for GC since running in single big function for c in node._deps: if c not in delete_checked: if c._deps: # is an intermediate - safe to delete. While we could # delete input variables, we want to keep input *constants* s.append(f"del x{id(c)}") delete_checked.add(c) if node._data is None: # create the array via computation s.append(node.as_string(params)) else: # inject the already computed data as constant params[f"x{id(node)}"] = node._data # reverse (ascend) into source code return "\n".join(reversed(s)) class Function: """Get a compiled (by python ``compile``), function that performs the computational graph corresponding to ``inputs`` -> ``outputs``. The signature of the function is ``func(input_arrays) -> output_arrays``. As an intermediate step, the computational graph is traced to a flattened source code string. Parameters ---------- inputs : pytree of LazyArray The input node(s) of the computational graph. outputs : pytree of LazyArray The output node(s) of the computational graph. fold_constants : bool, optional If True, fold constant arrays (those with no dependence on ``inputs``) into the graph ahead of compile. See Also -------- get_source, compute """ __slots__ = ( "_in_names", "_out_names", "_out_tree", "_source", "_code", "_locals", ) def __init__(self, inputs, outputs, fold_constants=True): if fold_constants: # compute everything not dependent on inputs compute_constants(outputs, variables=inputs) # write source and populate locals mapping that function will run # under, locals will include the functions and other constant objects self._locals = {} self._source = get_source(outputs, params=self._locals) # compile source self._code = compile( source=self._source, filename="", mode="exec", optimize=1, ) # get names to inject and extract arrays into and from locals self._in_names = tuple(f"x{id(v)}" for v in tree_iter(inputs)) outs_flat, self._out_tree = tree_flatten(outputs, get_ref=True) self._out_names = tuple(f"x{id(v)}" for v in outs_flat) def __call__(self, *args): # this allows any matching zipped tree for name, array in zip(self._in_names, tree_iter(args)): self._locals[name] = array # run the byte-compiled function with the updated locals exec(self._code, None, self._locals) # remove inputs from locals for name in self._in_names: del self._locals[name] # pop outputs from locals outs = tuple(self._locals.pop(name) for name in self._out_names) # return the outputs in the original tree structure return tree_unflatten(outs, self._out_tree) def __getstate__(self): # can't pickle the code object -> recompile in setstate return ( self._in_names, self._out_names, self._out_tree, self._source, self._locals, ) def __setstate__(self, state): ( self._in_names, self._out_names, self._out_tree, self._source, self._locals, ) = state # recompile the source self._code = compile( source=self._source, filename="", mode="exec", optimize=1, ) def print_source(self): """Print the source code of the compiled function.""" print(self._source) def __repr__(self): insig = f"{len(self._in_names)} input(s)" outsig = f"{len(self._out_names)} output(s) " return f" {outsig}>" # --------------------------- computational nodes --------------------------- # class Placeholder: """A singleton object to use as a placeholder in a LazyArray.""" __slots__ = () def __repr__(self): return "Placeholder" PLACEHOLDER = Placeholder() class LazyArray: """A lazy array representing a node in a computational graph. Parameters ---------- backend : str The backend of the array were it to be computed. This can be ``None`` but this may cause problems when propagating information about which functions to import to child nodes. fn : callable The function to call to compute the array, presumable imported from ``backend``. This can be ``None`` if the array already has data (e.g. is an input). args : tuple The positional arguments to pass to ``fn``, which might be ``LazyArray`` instances. kwargs : dict The keyword arguments to pass to ``fn``, which might be ``LazyArray`` instances. shape : tuple The shape of the array that ``fn(*args, **kwargs)`` will return, or the shape of the array that ``data`` has. deps : tuple, optional The ``LazyArray`` instances that ``fn(*args, **kwargs)`` depends on. If not specified, these will be automatically found from ``args`` and ``kwargs``, specifying them manually is slightly more efficient. """ __slots__ = ( "_backend", "_fn", "_args", "_kwargs", "_shape", "_data", "_deps", "_depth", ) def __init__( self, backend, fn, args, kwargs, shape, deps=None, ): # info required to perform the computation self._backend = backend self._fn = fn self._args = args if kwargs is None: self._kwargs = _EMPTY_DICT else: self._kwargs = kwargs # resulting array information self._shape = shape self._data = None # lazy arrays this ``LazyArray`` depends on if deps is None: # automatically find them self._deps = (*find_lazy(self._args), *find_lazy(self._kwargs)) else: # manually specified (slightly more efficient) self._deps = deps # tracking depth helps when ordering the computational graph if self._deps: self._depth = max(d._depth for d in self._deps) + 1 else: self._depth = 0 @classmethod def from_data(cls, data): """Create a new ``LazyArray`` directly from a concrete array.""" obj = cls.__new__(cls) obj._backend = infer_backend(data) obj._fn = obj._args = obj._kwargs = None obj._shape = shape(data) obj._data = data obj._deps = () obj._depth = 0 return obj @classmethod def from_shape(cls, shape, backend="numpy"): """Create a new ``LazyArray`` with a given shape.""" obj = cls.__new__(cls) obj._backend = backend obj._fn = obj._args = obj._kwargs = None obj._shape = tuple(map(int, shape)) obj._data = PLACEHOLDER obj._deps = () obj._depth = 0 return obj def to( self, fn, args=None, kwargs=None, backend=None, shape=None, deps=None, ): """Create a new ``LazyArray``, by default propagating backend, shape, and deps from the the current LazyArray. """ return LazyArray( fn=fn, args=args if args is not None else (self,), kwargs=kwargs, backend=backend if backend is not None else self._backend, shape=shape if shape is not None else self.shape, deps=deps if deps is not None else (self,), ) def _materialize(self): """Recursively compute all required args and kwargs for this node before computing itself and dereferencing dependencies. Note using this to materialize a large computation from scratch should be avoided due to the recursion limit, use ``x.compute()`` instead. """ if self._data is None: # materialize any actual array args args = (maybe_materialize(x) for x in self._args) kwargs = {k: maybe_materialize(v) for k, v in self._kwargs.items()} self._data = self._fn(*args, **kwargs) # free any references to deps self._fn = self._args = self._kwargs = None self._deps = () return self._data descend = descend ascend = ascend def compute(self): """Compute the value of this lazy array, clearing any references to the function, arguments and dependencies, and storing the result in the ``_data`` attribute as well as returning it. Unlike ``self._materialize()`` this avoids deep recursion. """ for node in self.ascend(): node._materialize() return self._data compute_constants = compute_constants def as_string(self, params): """Create a string which evaluates to the lazy array creation.""" # name function and store in locals fn_name = f"{getattr(self._fn, '__name__', 'fn')}{id(self._fn)}" params.setdefault(fn_name, self._fn) # string of args and kwargs str_call = ", ".join( itertools.chain( (stringify(x, params) for x in self._args), ( f"{k}: {stringify(v, params)}" for k, v in self._kwargs.items() ), ) ) # assign function call to new variable return f"x{id(self)} = {fn_name}({str_call})" get_source = get_source def get_function(self, variables, fold_constants=True): """Get a compiled function that computes ``fn(arrays)``, with ``fn`` describing the computational graph of this ``LazyArray`` and ``arrays`` corresponding to the downstream ``LazyArray`` nodes ``variables``. Parameters ---------- variables : sequence of LazyArray Input nodes whose data can change between calls. fold_constants : bool, optional Compute all intermediates which do not depend on ``variables`` prior to compilation. Returns ------- fn : callable Function with signature ``fn(arrays)``. """ return Function( inputs=variables, outputs=self, fold_constants=fold_constants ) def show(self, filler=" ", max_lines=None, max_depth=None): """Show the computational graph as a nested directory structure.""" if max_lines is None: max_lines = float("inf") if max_depth is None: max_depth = float("inf") # ┃ ━ ┗ ┣ │ ─ └ ╰ ├ ← ⬤ bar = f"│{filler}" space = f"{filler}{filler}" junction = "├─" bend = "╰─" line = 0 seen = {} queue = [(self, ())] while queue and (line < max_lines): t, columns = queue.pop() prefix = "" if columns: # work out various lines we need to draw based on whether the # sequence of parents are themselves the last child of their # parent prefix += "".join( bar if not p else space for p in columns[:-1] ) prefix += bend if columns[-1] else junction if t.fn_name not in (None, "None"): item = f"{t.fn_name}{list(t.shape)}" else: # input node item = f"←{list(t.shape)}" if t in seen: # ignore loops, but point to when it was computed print(f"{line:>4} {prefix} ... ({item} from line {seen[t]})") line += 1 continue print(f"{line:>4} {prefix}{item}") seen[t] = line line += 1 if len(columns) < max_depth: deps = sorted(t.deps, key=get_depth, reverse=True) islasts = [True] + [False] * (len(deps) - 1) for islast, d in zip(islasts, deps): queue.append((d, columns + (islast,))) def history_num_nodes(self): """Return the number of unique computational nodes in the history of this ``LazyArray``. """ num_nodes = 0 for _ in self.descend(): num_nodes += 1 return num_nodes def history_max_size(self): """Get the largest single tensor size appearing in this computation.""" return max(node.size for node in self.descend()) def history_size_footprint(self, include_inputs=True): """Get the combined size of intermediates at each step of the computation. Note this assumes that intermediates are immediately garbage collected when they are no longer required. Parameters ---------- include_inputs : bool, optional Whether to include the size of the inputs in the computation. If ``True`` It is assumed they can be garbage collected once used but are all present at the beginning of the computation. """ delete_checked = set() sizes = [] input_size = 0 for node in reversed(tuple(self.ascend())): for c in node._deps: if c not in delete_checked: # last time a dependency is seen, subtract the size if include_inputs or c._deps: sizes.append(-c.size) delete_checked.add(c) if node._data is None: # this is a new intermediate, add the size sizes.append(+node.size) elif include_inputs: # this is an input, size is added at beginning input_size += node.size sizes.append(input_size) sizes.reverse() return list(itertools.accumulate(sizes)) def history_peak_size(self, include_inputs=True): """Get the peak combined intermediate size of this computation. Parameters ---------- include_inputs : bool, optional Whether to include the size of the inputs in the computation. If ``True`` It is assumed they can be garbage collected once used but are all present at the beginning of the computation. """ return max(self.history_size_footprint(include_inputs=include_inputs)) def history_total_size(self): """The the total size of all unique arrays in the computational graph, possibly relevant e.g. for back-propagation algorithms. """ return sum(node.size for node in self.descend()) def history_stats(self, fn): """Compute aggregate statistics about the computational graph. Parameters ---------- fn : callable or str Function to apply to each node in the computational graph. If a string, one of 'count', 'sizein', 'sizeout' can be used to count the number of nodes, the total size of the inputs, or the total size of each output respectively. Returns ------- stats : dict Dictionary mapping function names to the aggregate statistics. """ if not callable(fn): if fn == "count": def fn(node): return 1 elif fn == "sizein": def fn(node): return sum(child.size for child in node.deps) elif fn == "sizeout": def fn(node): return node.size stats = collections.defaultdict(int) for node in self.descend(): node_cost = fn(node) if node_cost is not None: stats[node.fn_name] += fn(node) return dict(stats) def history_fn_frequencies(self): """Get a dictionary mapping function names to the number of times they are used in the computational graph. """ return self.history_stats("count") def to_nx_digraph(self, variables=None): """Convert this ``LazyArray`` into a ``networkx.DiGraph``.""" import networkx as nx if variables is None: variables = set() elif isinstance(variables, LazyArray): variables = {variables} else: variables = set(variables) G = nx.DiGraph() nodemap = {} for i, node in enumerate(self.ascend()): nodemap[node] = i variable = (node in variables) or any( child in variables for child in node.deps ) if variable: variables.add(node) G.add_node(i, array=node, variable=variable) for x in node.deps: G.add_edge(nodemap[x], nodemap[node]) return G plot = plot_circuit plot_graph = plot_graph plot_circuit = plot_circuit plot_history_size_footprint = plot_history_size_footprint plot_history_functions = plot_history_functions plot_history_functions_scatter = functools.partialmethod( plot_history_functions, kind="scatter" ) plot_history_functions_lines = functools.partialmethod( plot_history_functions, kind="lines" ) plot_history_functions_image = functools.partialmethod( plot_history_functions, kind="image" ) plot_history_stats = plot_history_stats plot_history_stats_counts = functools.partialmethod( plot_history_stats, fn="count" ) plot_history_stats_sizein = functools.partialmethod( plot_history_stats, fn="sizein" ) @property def fn(self): """The function to use to compute this array.""" return self._fn @property def fn_name(self): """The name of the function to use to compute this array.""" return getattr(self._fn, "__name__", "None") @property def args(self): """The positional arguments to the function to use to compute this array. """ return self._args @property def kwargs(self): """The keyword arguments to the function to use to compute this array. """ return self._kwargs @property def shape(self): return self._shape def __len__(self): return self.shape[0] def __iter__(self): import warnings warnings.warn( "Iterating over LazyArray to get the computational graph nodes is " "deprecated - use `LazyArray.descend()` instead. Eventually " "`iter(lz)` will iterate over first axis slices." ) return self.descend() @property def ndim(self): return len(self._shape) @property def size(self): return functools.reduce(operator.mul, self.shape, 1) @property def backend(self): return self._backend @property def deps(self): """A tuple of the dependencies, other LazyArray instances, of this array. """ return self._deps @property def depth(self): """The maximum distance to any input array in the computational graph. """ return self._depth def __getitem__(self, key): return getitem(self, key) # this makes numpy operations delegate to __rmatmul__ etc. __array_ufunc__ = None def __mul__(self, other): return multiply(self, other) def __rmul__(self, other): return multiply(self, other) def __add__(self, other): return add(self, other) def __radd__(self, other): return add(self, other) def __sub__(self, other): return sub(self, other) def __rsub__(self, other): return sub(other, self) def __floordiv__(self, other): return floordivide(self, other) def __rfloordiv__(self, other): return floordivide(other, self) def __truediv__(self, other): return truedivide(self, other) def __rtruediv__(self, other): return truedivide(other, self) def __pow__(self, other): return pow_(self, other) def __rpow__(self, other): return pow_(other, self) def __matmul__(self, other): return matmul(self, other) def __rmatmul__(self, other): return matmul(other, self) def __abs__(self): return abs_(self) def __neg__(self): return self.to(operator.neg) def __ne__(self, other): return ne(self, other) def __gt__(self, other): return gt(self, other) def __lt__(self, other): return lt(self, other) def __ge__(self, other): return ge(self, other) def __le__(self, other): return le(self, other) @property def T(self): return transpose(self) @property def H(self): return conj(transpose(self)) def reshape(self, shape): return reshape(self, shape) def astype(self, dtype_name): return lazy_astype(self, dtype_name) @property def real(self): return real(self) @property def imag(self): return imag(self) def __repr__(self): return ( f"<{self.__class__.__name__}(" f"fn={self.fn_name}, " f"shape={self.shape}, " f"backend='{self.backend}')>" ) register_backend(LazyArray, "autoray.lazy") def ensure_lazy(array): if not isinstance(array, LazyArray): return LazyArray.from_data(array) return array def find_lazy(x): """Recursively search for ``LazyArray`` instances in pytrees.""" if isinstance(x, LazyArray): yield x return if isinstance(x, (tuple, list)): for subx in x: yield from find_lazy(subx) return if isinstance(x, dict): for subx in x.values(): yield from find_lazy(subx) return # --------------------- recusively evaluating 'pytrees' --------------------- # def materialize_larray(x): return x._materialize() def materialize_tuple(x): return tuple(map(maybe_materialize, x)) def materialize_list(x): return list(map(maybe_materialize, x)) def materialize_dict(x): return {k: maybe_materialize(v) for k, v in x.items()} def materialize_identity(x): return x _materialize_dispatch = { LazyArray: materialize_larray, tuple: materialize_tuple, list: materialize_list, dict: materialize_dict, } def maybe_materialize(x): """Recursively evaluate LazyArray instances in tuples, lists and dicts.""" try: return _materialize_dispatch[x.__class__](x) except KeyError: _materialize_dispatch[x.__class__] = materialize_identity return x # -------------------- recusively stringifying 'pytrees' -------------------- # def stringify_larray(x, params): name = f"x{id(x)}" if x._data is not None: params.setdefault(name, x._data) return name def stringify_tuple(x, params): if not x: return "()" return f"({', '.join(stringify(xi, params) for xi in x)},)" def stringify_list(x, params): return f"[{', '.join(stringify(xi, params) for xi in x)}]" def stringify_dict(x, params): entries = (f"{k}: {stringify(v, params)}" for k, v in x.items()) return f"{{{', '.join(entries)}}}" def stringify_identity(x, params): if isinstance(x, (int, float, complex, bool, slice, range)): return f"{x}" if isinstance(x, str): return f"'{x}'" name = f"c{id(x)}" params.setdefault(name, x) return name _stringify_dispatch = collections.defaultdict( lambda: stringify_identity, { LazyArray: stringify_larray, tuple: stringify_tuple, list: stringify_list, dict: stringify_dict, }, ) def stringify(x, params): """Recursively stringify LazyArray instances in tuples, lists and dicts.""" return _stringify_dispatch[x.__class__](x, params) # --------------------------------- caching --------------------------------- # _SHARING_STACK = collections.defaultdict(list) def currently_sharing(): """Check if we are currently sharing a cache -- thread specific.""" return threading.get_ident() in _SHARING_STACK def get_sharing_cache(): """Return the most recent sharing cache -- thread specific.""" return _SHARING_STACK[threading.get_ident()][-1] def _add_sharing_cache(cache): _SHARING_STACK[threading.get_ident()].append(cache) def _remove_sharing_cache(): tid = threading.get_ident() _SHARING_STACK[tid].pop() if not _SHARING_STACK[tid]: del _SHARING_STACK[tid] @contextlib.contextmanager def shared_intermediates(cache=None): """Context in which intermediate results are shared. Note that intermediate LazyArray instances (which can reference actual data) will not be garbage collected until 1. this context exits, and 2. the yielded cache is garbage collected (if it was captured). Parameters ---------- cache : dict If specified, a user-stored dict in which intermediate lazy arrays will be stored. This can be used to interleave sharing contexts. Returns ------- cache : dict A dictionary in which sharing results are stored. If ignored, sharing results will be garbage collected when this context is exited. This dict can be passed to another context to resume sharing. """ if cache is None: cache = {} _add_sharing_cache(cache) try: yield cache finally: _remove_sharing_cache() def maybe_id(x): if hasattr(x, "shape"): return id(x) return x def hash_args_kwargs(fn_name, *args, **kwargs): hargs = tuple(map(maybe_id, args)) if kwargs: hkwargs = tuple(sorted((k, maybe_id(v)) for k, v in kwargs.items())) else: hkwargs = None return f"{fn_name}-{hash((hargs, hkwargs))}" def lazy_cache(fn_name, hasher=None): """Decorator to mark a function as being lazy cacheable. Parameters ---------- fn_name : str The name to use for the function in the cache. hasher : callable A function with signature ``hasher(fn_name, *args, **kwargs)`` that returns a hashable key for the cache. If not specified, the default is to use ``hash_args_kwargs``. """ if hasher is None: hasher = hash_args_kwargs def wrapper(fn): @functools.wraps(fn) def wrapped(*args, **kwargs): if not currently_sharing(): return fn(*args, **kwargs) cache = get_sharing_cache() key = hasher(fn_name, *args, **kwargs) if key not in cache: cache[key] = fn(*args, **kwargs) return cache[key] return wrapped return wrapper _DTYPES_REAL_EQUIV = {"complex128": "float64", "complex64": "float32"} _DTYPES_COMPLEX_EQUIV = {"float64": "complex128", "float32": "complex64"} @functools.lru_cache(None) def dtype_real_equiv(dtype_name): return _DTYPES_REAL_EQUIV.get(dtype_name, dtype_name) @functools.lru_cache(None) def dtype_complex_equiv(dtype_name): return _DTYPES_COMPLEX_EQUIV.get(dtype_name, dtype_name) @functools.lru_cache(None) def _find_common_dtype(array_types, scalar_types): import numpy as np return np.find_common_type(array_types, scalar_types).name def find_common_dtype(*xs): return _find_common_dtype(tuple(map(get_dtype_name, xs)), ()) @functools.lru_cache(None) def _find_common_backend_cached(names): return max( names, key=lambda n: multi_class_priorities.get(n, 0), ) def find_common_backend(*xs): names = tuple( x.backend if isinstance(x, LazyArray) else infer_backend(x) for x in xs ) return _find_common_backend_cached(names) @functools.lru_cache(1024) def find_broadcast_shape(xshape, yshape): xndim = len(xshape) yndim = len(yshape) if xndim < yndim: xshape = (1,) * (yndim - xndim) + xshape elif yndim < xndim: yshape = (1,) * (xndim - yndim) + yshape return tuple(max(d1, d2) for d1, d2 in zip(xshape, yshape)) # -------------------------------- interface -------------------------------- # def Variable(shape, backend=None): """Create a ``LazyArray`` from a shape only, representing a leaf node in the computational graph. It can only act as a placeholder for data. """ return LazyArray.from_shape(shape, backend=backend) @lazy_cache("array") def array(x): """Create a ``LazyArray`` from an input array, representing a leaf node in the computational graph. """ return LazyArray.from_data(x) @lazy_cache("transpose") def transpose(a, axes=None): a = ensure_lazy(a) if axes is None: axes = range(a.ndim)[::-1] if all(i == ax for i, ax in enumerate(axes)): # no transposition required return a fn_transpose = get_lib_fn(a.backend, "transpose") oldshape = shape(a) newshape = tuple(oldshape[i] for i in axes) # check for chaining transpositions if a._fn is fn_transpose: b = a._args[0] if isinstance(b, LazyArray): axes_prev = a._args[1] axes_chained = tuple(axes_prev[k] for k in axes) return b.to(fn_transpose, (b, axes_chained), shape=newshape) return a.to(fn_transpose, (a, axes), shape=newshape) @lazy_cache("reshape") def _reshape_tuple(a, newshape): a = ensure_lazy(a) fn_reshape = get_lib_fn(a.backend, "reshape") # check for redundant reshapes if a._fn is fn_reshape: b = a._args[0] if isinstance(b, LazyArray): a = b return a.to(fn_reshape, (a, newshape), shape=newshape) @functools.lru_cache(2**14) def find_full_reshape(newshape, size): try: expand = newshape.index(-1) before = newshape[:expand] after = newshape[expand + 1 :] d = size // functools.reduce( operator.mul, itertools.chain(before, after), 1 ) return (*before, d, *after) except ValueError: return newshape def reshape(a, newshape): newshape = (newshape,) if isinstance(newshape, int) else tuple(newshape) newshape = find_full_reshape(newshape, a.size) if shape(a) == tuple(newshape): # no reshape required return a return _reshape_tuple(a, newshape) def getitem_hasher(_, a, key): if not isinstance(key, tuple): key = (key,) hkey = tuple( str(k) if isinstance(k, slice) else id(k) if hasattr(k, "shape") else k for k in key ) return f"getitem-{hash((id(a), hkey))}" @functools.lru_cache(2**12) def get_sliced_size(d, start, stop, step): return len(range(d)[slice(start, stop, step)]) @lazy_cache("getitem", hasher=getitem_hasher) def getitem(a, key): a = ensure_lazy(a) deps = (a,) if not isinstance(key, tuple): key = (key,) nexpand = a.ndim expand = None for i, k in enumerate(key): if k is not None: if k is Ellipsis: expand = i else: nexpand -= 1 if expand is not None: # ellipsis somewhere key = key[:expand] + (slice(None),) * nexpand + key[expand + 1 :] elif nexpand: # need to pad trailing dimensions key = key + (slice(None),) * nexpand adv_idx_shape = adv_idx_loc = None adv_idx_locs = [] shape = iter(a.shape) newshape = [] for i, k in enumerate(key): if k is None: # (newaxis) -> new dimension of size 1 newshape.append(1) # don't want to iterate shape continue d = next(shape) if isinstance(k, slice): # range of values newshape.append(get_sliced_size(d, k.start, k.stop, k.step)) elif hasattr(k, "shape") or isinstance(k, (tuple, list)): if adv_idx_shape is None: # first advanced index adv_idx_shape = _get_py_shape(k) adv_idx_loc = len(newshape) adv_idx_locs.append(i) else: # check if broadcast shape matches adv_idx_shape = find_broadcast_shape( adv_idx_shape, _get_py_shape(k) ) # advanced indexing location is only retained when # all advanced indices are adjacent -> need to track adv_idx_locs.append(i) if isinstance(k, LazyArray): # add to dependencies deps += (k,) else: # else assume integer -> doesn't contribute to new shape, # but does count as an advanced index when it comes to # determining the location of the advanced index shape adv_idx_locs.append(i) if adv_idx_shape is not None: if not all(i + 1 == j for i, j in zip(adv_idx_locs, adv_idx_locs[1:])): # 'move to front' advanced indexing newshape = (*adv_idx_shape, *newshape) else: # 'keep in place' advanced indexing newshape = ( *newshape[:adv_idx_loc], *adv_idx_shape, *newshape[adv_idx_loc:], ) else: newshape = tuple(newshape) return a.to(operator.getitem, (a, key), shape=newshape, deps=deps) @lazy_cache("tensordot") def tensordot(a, b, axes=2): if isinstance(axes, int): axes = (tuple(range(a.ndim - axes, a.ndim)), tuple(range(axes))) newshape = tuple( d for i, d in enumerate(shape(a)) if i not in axes[0] ) + tuple(d for i, d in enumerate(shape(b)) if i not in axes[1]) backend = find_common_backend(a, b) fn_tensordot = get_lib_fn(backend, "tensordot") return LazyArray( backend=backend, fn=fn_tensordot, args=(a, b, axes), kwargs=None, shape=newshape, deps=tuple(x for x in (a, b) if isinstance(x, LazyArray)), ) def _basic_einsum_parse_input(operands): # handle the basic, fully specified equation format eq, *arrays = operands lhs, rhs = eq.split("->") return lhs, rhs, arrays @functools.lru_cache(None) def _get_parse_einsum_input(): try: from cotengra.utils import parse_einsum_input return parse_einsum_input except ImportError: pass try: from opt_einsum.parser import parse_einsum_input return parse_einsum_input except ImportError: pass import warnings warnings.warn( "Could not find a full input parser for einsum expressions. " "Please install either cotengra or opt_einsum for advanced " "input formats (interleaved, ellipses, no-output)." ) return _basic_einsum_parse_input @lazy_cache("einsum") def einsum(*operands): lhs, rhs, larrays = _get_parse_einsum_input()(operands) size_dict = {} for term, op in zip(lhs.split(","), larrays): op_shape = shape(op) for i, char in enumerate(term): size_dict[char] = max(size_dict.get(char, 1), op_shape[i]) eq = f"{lhs}->{rhs}" newshape = tuple(size_dict[char] for char in rhs) backend = find_common_backend(*larrays) fn_einsum = get_lib_fn(backend, "einsum") return LazyArray( backend=backend, fn=fn_einsum, args=(eq, *larrays), kwargs=None, shape=newshape, deps=tuple(x for x in larrays if isinstance(x, LazyArray)), ) @lazy_cache("trace") def trace(a): a = ensure_lazy(a) return a.to( fn=get_lib_fn(a.backend, "trace"), args=(a,), shape=(), ) @lazy_cache("diag") def diag(a, k=0): a = ensure_lazy(a) if a.ndim == 1: new_d = shape(a)[0] + abs(k) new_shape = (new_d, new_d) elif a.ndim == 2: new_d = max(min(shape(a)) - abs(k), 0) new_shape = (new_d,) else: raise ValueError("Input must be 1- or 2-d.") return a.to( fn=get_lib_fn(a.backend, "diag"), args=(a, k), shape=new_shape, ) @lazy_cache("matmul") def matmul(x1, x2): backend = find_common_backend(x1, x2) shape1 = shape(x1) shape2 = shape(x2) if len(shape2) == 1: if shape1[-1] != shape2[-1]: raise ValueError( "matmul: Input operand 1 has a mismatch in its core dimension " "0, with gufunc signature (n?,k),(k,m?)->(n?,m?)" ) newshape = shape1[:-1] elif len(shape1) == 1: if len(shape2) > 2 or shape1[-1] != shape2[-2]: raise ValueError( "matmul: Input operand 1 has a mismatch in its core dimension " "0, with gufunc signature (n?,k),(k,m?)->(n?,m?)" ) newshape = shape2[-1:] else: if shape2[:-2] != shape1[:-2]: raise ValueError( "operands could not be broadcast together with remapped " f"shapes [original->remapped]: {shape1}->({shape1[:-2]}," "newaxis,newaxis) " f"{shape2}->({shape2[:-2]},newaxis,newaxis) and requested " f"shape ({shape1[-2], shape2[-1]})" ) if shape1[-1] != shape2[-2]: raise ValueError( "matmul: Input operand 1 has a mismatch in its core dimension " "0, with gufunc signature (n?,k),(k,m?)->(n?,m?)" ) newshape = (*shape1[:-1], shape2[-1]) return LazyArray( backend=backend, fn=operator.matmul, args=(x1, x2), kwargs=None, shape=newshape, deps=tuple(x for x in (x1, x2) if isinstance(x, LazyArray)), ) @lazy_cache("kron") def kron(x1, x2): backend = find_common_backend(x1, x2) shape1 = shape(x1) shape2 = shape(x2) ndim1 = len(shape1) ndim2 = len(shape2) diff = ndim1 - ndim2 if diff > 0: shape2 = (1,) * diff + shape2 elif diff < 0: shape1 = (1,) * -diff + shape1 newshape = tuple(d1 * d2 for d1, d2 in zip(shape1, shape2)) fn_kron = get_lib_fn(backend, "kron") return LazyArray( backend=backend, fn=fn_kron, args=(x1, x2), kwargs=None, shape=newshape, deps=tuple(x for x in (x1, x2) if isinstance(x, LazyArray)), ) @lazy_cache("clip") def clip(a, a_min, a_max): a = ensure_lazy(a) fn_clip = get_lib_fn(a.backend, "clip") return a.to(fn_clip, (a, a_min, a_max)) @lazy_cache("flip") def flip(a, axis=None): a = ensure_lazy(a) fn_flip = get_lib_fn(a.backend, "flip") return a.to(fn_flip, (a, axis)) @lazy_cache("sort") def sort(a, axis=-1): a = ensure_lazy(a) return a.to(get_lib_fn(a.backend, "sort"), (a, axis)) @lazy_cache("argsort") def argsort(a, axis=-1): a = ensure_lazy(a) return a.to( fn=get_lib_fn(a.backend, "argsort"), args=(a, axis), ) @lazy_cache("stack") def stack(arrays, axis=0): arrays = tuple(arrays) newshape = list(shape(arrays[0])) newshape.insert(axis if axis >= 0 else axis + 1, len(arrays)) backend = find_common_backend(*arrays) fn = get_lib_fn(backend, "stack") return LazyArray( backend=backend, fn=fn, args=(arrays, axis), kwargs=None, shape=tuple(newshape), deps=tuple(x for x in arrays if isinstance(x, LazyArray)), ) @lazy_cache("concatenate") def concatenate(arrays, axis=0): arrays = tuple(arrays) newshape = list(arrays[0].shape) newshape[axis] = sum(shape(a)[axis] for a in arrays) backend = find_common_backend(*arrays) fn = get_lib_fn(backend, "concatenate") return LazyArray( backend=backend, fn=fn, args=(arrays, axis), kwargs=None, shape=tuple(newshape), deps=tuple(x for x in arrays if isinstance(x, LazyArray)), ) @lazy_cache("split") def split(ary, indices_or_sections, axis=0): ary = ensure_lazy(ary) d = shape(ary)[axis] num_subarrays = len(indices_or_sections) + 1 div_points = [0] + list(indices_or_sections) + [d] sub_arys = [] selector = [slice(None)] * ary.ndim for i in range(num_subarrays): st = div_points[i] end = div_points[i + 1] selector[axis] = slice(st, end) sub_arys.append(ary[tuple(selector)]) return tuple(sub_arys) def where(condition, x, y): x = ensure_lazy(x) condition = ensure_lazy(condition) return LazyArray( backend=find_common_backend(condition, x), fn=get_lib_fn(x.backend, "where"), args=(condition, x, y), kwargs=None, shape=find_broadcast_shape(condition.shape, x.shape), deps=tuple(a for a in (condition, x, y) if isinstance(a, LazyArray)), ) def _get_py_shape(x): """Infer the shape of a possibly nested list/tuple object.""" if hasattr(x, "shape"): return tuple(x.shape) if isinstance(x, (tuple, list)): return (len(x),) + _get_py_shape(x[0]) return () @lazy_cache("take") def take(x, indices): x = ensure_lazy(x) if isinstance(indices, (list, tuple)): new_shape = _get_py_shape(indices) else: indices = ensure_lazy(indices) new_shape = indices.shape return LazyArray( backend=x.backend, fn=get_lib_fn(x.backend, "take"), args=(x, indices), kwargs=None, shape=new_shape, deps=tuple(a for a in (x, indices) if isinstance(a, LazyArray)), ) def make_binary_func(name, fn): @lazy_cache(name) def binary_func(x1, x2): x1shape = getattr(x1, "shape", ()) x2shape = getattr(x2, "shape", ()) newshape = find_broadcast_shape(x1shape, x2shape) return LazyArray( backend=find_common_backend(x1, x2), fn=fn, args=(x1, x2), kwargs=None, shape=newshape, deps=tuple(x for x in (x1, x2) if isinstance(x, LazyArray)), ) return binary_func multiply = make_binary_func("multiply", operator.mul) add = make_binary_func("add", operator.add) sub = make_binary_func("sub", operator.sub) floordivide = make_binary_func("floordivide", operator.floordiv) truedivide = make_binary_func("truedivide", operator.truediv) pow_ = make_binary_func("pow", operator.pow) gt = make_binary_func("gt", operator.gt) ne = make_binary_func("ne", operator.ne) lt = make_binary_func("lt", operator.lt) ge = make_binary_func("ge", operator.ge) le = make_binary_func("le", operator.le) def complex_(re, im): newshape = find_broadcast_shape(shape(re), shape(im)) backend = find_common_backend(re, im) fn_complex = get_lib_fn(backend, "complex") return LazyArray( backend=backend, fn=fn_complex, args=(re, im), kwargs=None, shape=newshape, deps=tuple(x for x in (re, im) if isinstance(x, LazyArray)), ) def make_unary_func(name): @lazy_cache(name) def unary_func(x): x = ensure_lazy(x) return x.to(fn=get_lib_fn(x.backend, name)) unary_func.__name__ = name return unary_func sin = make_unary_func("sin") cos = make_unary_func("cos") tan = make_unary_func("tan") arcsin = make_unary_func("arcsin") arccos = make_unary_func("arccos") arctan = make_unary_func("arctan") sinh = make_unary_func("sinh") cosh = make_unary_func("cosh") tanh = make_unary_func("tanh") arcsinh = make_unary_func("arcsinh") arccosh = make_unary_func("arccosh") arctanh = make_unary_func("arctanh") sqrt = make_unary_func("sqrt") exp = make_unary_func("exp") log = make_unary_func("log") log2 = make_unary_func("log2") log10 = make_unary_func("log10") conj = make_unary_func("conj") sign = make_unary_func("sign") abs_ = make_unary_func("abs") angle = make_unary_func("angle") real = make_unary_func("real") imag = make_unary_func("imag") def make_reduction_func(name): @lazy_cache(name) def reduction_func(a, axis=None): a = ensure_lazy(a) fn = get_lib_fn(a.backend, name) nd = a.ndim if axis is None: return a.to( fn=fn, shape=(), ) elif not hasattr(axis, "__len__"): axis = (axis,) axis = tuple(nd + i if i < 0 else i for i in axis) newshape = tuple(d for i, d in enumerate(shape(a)) if i not in axis) return a.to(fn=fn, args=(a, axis), shape=newshape) return reduction_func sum_ = make_reduction_func("sum") prod = make_reduction_func("prod") min_ = make_reduction_func("min") max_ = make_reduction_func("max") # # XXX: still missing # allclose, complex, diag # dot, vdot, kron, inner, outer # pad, eye # squeeze, expand_dims # to_numpy # ---------------------------- autoray specials ----------------------------- # def lazy_get_dtype_name(x): return x.dtype @lazy_cache("astype") def lazy_astype(x, dtype_name): x = ensure_lazy(x) return x.to(fn=astype, args=(x, dtype_name)) register_function("autoray.lazy", "get_dtype_name", lazy_get_dtype_name) register_function("autoray.lazy", "astype", lazy_astype) autoray-0.6.12/autoray/lazy/draw.py000066400000000000000000000623731462076570400172640ustar00rootroot00000000000000"""Visualizations for ``LazyArray`` computational graphs. """ import itertools import functools import importlib.util COLORING_SEED = 1 # 8, 10 def set_coloring_seed(seed): """Set the seed for the random color generator. Parameters ---------- seed : int The seed to use. """ global COLORING_SEED COLORING_SEED = seed def hash_to_nvalues(s, nval, seed=None): import hashlib if seed is None: seed = COLORING_SEED m = hashlib.sha256() m.update(f"{seed}".encode()) m.update(s.encode()) hsh = m.hexdigest() b = len(hsh) // nval if b == 0: raise ValueError( f"Can't extract {nval} values from hash of length {len(hsh)}" ) return tuple( int(hsh[i * b : (i + 1) * b], 16) / 16**b for i in range(nval) ) def hash_to_color( s, hmin=0.0, hmax=1.0, smin=0.3, smax=0.8, vmin=0.8, vmax=1.0, ): """Generate a random color for a string ``s``. Parameters ---------- s : str The string to generate a color for. hmin : float, optional The minimum hue value. hmax : float, optional The maximum hue value. smin : float, optional The minimum saturation value. smax : float, optional The maximum saturation value. vmin : float, optional The minimum value value. vmax : float, optional The maximum value value. Returns ------- color : tuple A tuple of floats in the range [0, 1] representing the RGB color. """ from matplotlib.colors import hsv_to_rgb h, s, v = hash_to_nvalues(s, 3) h = hmin + h * (hmax - hmin) s = smin + s * (smax - smin) v = vmin + v * (vmax - vmin) return hsv_to_rgb((h, s, v)) def rotated_house_shape(xy, r=0.4): x, y = xy return [ [x - r, y - r], [x - r, y + r], [x, y + r], [x + r, y], [x, y - r], ] def count_around(c, layout): if layout == "wide": # just count upwards yield from itertools.count(c) elif layout == "compact": # count backwards, then forwards after reaching zero yield from range(c, -1, -1) yield from itertools.count(c + 1) else: # 'balanced' # count backwards, then forwards, alternating step = 0 # start by stepping to side closer to zero sgn = (-1) ** (c <= 0) while True: cm = c - sgn * step if step != 0: # and (cm >= 0): yield cm yield c + sgn * step step += 1 def get_default_colors_dict(colors): import numpy as np colors = dict() if colors is None else dict(colors) colors.setdefault("None", np.array([0.5, 0.5, 0.5])) colors.setdefault("getitem", np.array([0.5, 0.5, 0.5])) return colors def rotate(xy, theta): """Return a rotated set of points.""" import numpy as np s = np.sin(theta) c = np.cos(theta) xyr = np.empty_like(xy) xyr[:, 0] = c * xy[:, 0] - s * xy[:, 1] xyr[:, 1] = s * xy[:, 0] + c * xy[:, 1] return xyr def span(xy): """Return the vertical span of the points.""" return xy[:, 1].max() - xy[:, 1].min() def massage_pos(pos, nangles=180, flatten=False): """Rotate a position dict's points to cover a small vertical span""" import numpy as np xy = np.empty((len(pos), 2)) for i, (x, y) in enumerate(pos.values()): xy[i, 0] = x xy[i, 1] = y thetas = np.linspace(0, 2 * np.pi, nangles, endpoint=False) rxys = (rotate(xy, theta) for theta in thetas) rxy0 = min(rxys, key=lambda rxy: span(rxy)) if flatten is True: flatten = 2 if flatten: rxy0[:, 1] /= flatten return dict(zip(pos, rxy0)) def layout_pygraphviz( G, prog="neato", dim=2, **kwargs, ): # TODO: fix nodes with pin attribute # TODO: initial positions # TODO: max iters # TODO: spring parameter import pygraphviz as pgv aG = pgv.AGraph(directed=G.is_directed()) mapping = {} for nodea, nodeb in G.edges(): s_nodea = str(nodea) s_nodeb = str(nodeb) mapping[s_nodea] = nodea mapping[s_nodeb] = nodeb aG.add_edge(s_nodea, s_nodeb) kwargs = {} if dim == 2.5: kwargs["dim"] = 3 kwargs["dimen"] = 2 else: kwargs["dim"] = kwargs["dimen"] = dim args = " ".join(f"-G{k}={v}" for k, v in kwargs.items()) # run layout algorithm aG.layout(prog=prog, args=args) # extract layout pos = {} for snode, node in mapping.items(): spos = aG.get_node(snode).attr["pos"] pos[node] = tuple(map(float, spos.split(","))) # normalize to unit square xmin = ymin = zmin = float("inf") xmax = ymax = zmaz = float("-inf") for x, y, *maybe_z in pos.values(): xmin = min(xmin, x) xmax = max(xmax, x) ymin = min(ymin, y) ymax = max(ymax, y) for z in maybe_z: zmin = min(zmin, z) zmaz = max(zmaz, z) for node, (x, y, *maybe_z) in pos.items(): pos[node] = ( 2 * (x - xmin) / (xmax - xmin) - 1, 2 * (y - ymin) / (ymax - ymin) - 1, *(2 * (z - zmin) / (zmaz - zmin) - 1 for z in maybe_z), ) return pos HAS_FA2 = importlib.util.find_spec("fa2") is not None HAS_PYGRAPHVIZ = importlib.util.find_spec("pygraphviz") is not None def get_nice_pos( G, *, dim=2, layout="auto", initial_layout="auto", iterations="auto", k=None, use_forceatlas2=False, flatten=False, **layout_opts ): if (layout == "auto") and HAS_PYGRAPHVIZ: layout = "neato" if layout in ("dot", "neato", "fdp", "sfdp"): pos = layout_pygraphviz(G, prog=layout, dim=dim) if layout != "dot": pos = massage_pos(pos, flatten=flatten) return pos import networkx as nx if layout != "auto": initial_layout = layout iterations = 0 if initial_layout == "auto": # automatically select if len(G) <= 100: # usually nicest initial_layout = "kamada_kawai" else: # faster, but not as nice initial_layout = "spectral" if iterations == "auto": # the smaller the graph, the more iterations we can afford iterations = max(200, 1000 - len(G)) if dim == 2.5: dim = 3 project_back_to_2d = True else: project_back_to_2d = False # use spectral or other layout as starting point if dim != 2: layout_opts["dim"] = dim pos0 = getattr(nx, initial_layout + "_layout")(G, **layout_opts) # and then relax remaining using spring layout if iterations: if use_forceatlas2 is True: # turn on for more than 1 node use_forceatlas2 = 1 elif use_forceatlas2 in (0, False): # never turn on use_forceatlas2 = float("inf") should_use_fa2 = HAS_FA2 and (len(G) > use_forceatlas2) and (dim == 2) if should_use_fa2: from fa2 import ForceAtlas2 # NB: some versions of fa2 don't support the `weight_attr` option pos = ForceAtlas2(verbose=False).forceatlas2_networkx_layout( G, pos=pos0, iterations=iterations ) else: pos = nx.spring_layout( G, pos=pos0, k=k, dim=dim, iterations=iterations, ) else: pos = pos0 if project_back_to_2d: # project back to 2d pos = {k: v[:2] for k, v in pos.items()} dim = 2 if dim == 2: # finally rotate them to cover a small vertical span pos = massage_pos(pos) return pos # def get_nice_pos(): # """Get a nice layout for a graph. # """ # # compute a layout for the graph # if initial_layout == "layers": # for layer, nodes in enumerate(nx.topological_generations(G)): # for node in nodes: # G.nodes[node]["layer"] = layer # layout_opts.setdefault("subset_key", "layer") # layout_opts.setdefault("align", "vertical") # pos = nx.multipartite_layout(G, **layout_opts) # if layout_opts["align"] == "horizontal": # dag_spread = 1 / dag_spread # for k, (x, y) in pos.items(): # pos[k] = (x, dag_spread * y) # else: # if initial_layout == "spiral": # layout_opts.setdefault("equidistant", True) # pos = getattr(nx, initial_layout + "_layout")(G, **layout_opts) # # further spring based refinement # if iterations: # pos = nx.layout.spring_layout(G, pos=pos, k=k, iterations=iterations) def plot_graph( self, variables=None, dim=2, layout="auto", initial_layout="auto", iterations="auto", k=None, use_forceatlas2=False, color_by="function", colors=None, connectionstyle="arc3,rad=-0.05", arrowsize=6, edge_color=(0.5, 0.5, 0.5), edge_alpha=0.3, var_color=(0, 0.5, 0.25), const_color=(0, 0.5, 1.0), root_color=(1, 0, 0.5), node_shape="s", node_scale=1.0, node_alpha=1.0, show_labels=True, label_color=(0.5, 0.5, 0.5), label_alpha=1.0, font_size=8, label_rotation=45, figsize=None, ax=None, show_and_close=True, **layout_opts, ): """Plot the computational graph of this ``LazyArray``.""" import numpy as np import networkx as nx import matplotlib.pyplot as plt if color_by not in ("id", "function", "variables"): raise ValueError("color_by must be 'id', 'function' or 'variables'") colors = get_default_colors_dict(colors) G = self.to_nx_digraph(variables=variables) created_fig = ax is None if created_fig: if figsize is None: w = h = (G.number_of_nodes() + 1) ** 0.5 figsize = (w, h) fig, ax = plt.subplots(figsize=figsize, constrained_layout=True) fig.set_facecolor((0, 0, 0, 0)) ax.axis("off") ax.set_aspect("equal") node_colors = {} node_sizes = {} node_labels = {} node_markers = {} for i, data in G.nodes(data=True): # set node color if data['array'] is self: node_markers[i] = "X" if color_by == "variables": if data['array'] is self: node_colors[i] = root_color elif data["variable"]: node_colors[i] = var_color else: node_colors[i] = const_color elif color_by == "function": if data['array'].fn_name in colors: node_colors[i] = colors[data['array'].fn_name] else: node_colors[i] = hash_to_color(data['array'].fn_name) elif color_by == "id": node_colors[i] = hash_to_color(str(id(data['array']))) # set node size node_sizes[i] = 6 * node_scale * (np.log2(data['array'].size) + 1) # set node label and marker if data['array'].fn_name == "None": node_markers.setdefault(i, "o") node_labels[i] = "" if data['array'].fn_name == "getitem": node_markers.setdefault(i, ".") node_labels[i] = "" else: node_labels[i] = data['array'].fn_name node_markers.setdefault(i, node_shape) if initial_layout == "layers": for layer, nodes in enumerate(nx.topological_generations(G)): for node in nodes: G.nodes[node]["layer"] = layer layout_opts.setdefault("subset_key", "layer") layout_opts.setdefault("align", "vertical") if layout_opts["align"] == "horizontal": layout_opts.setdefault("flatten", 2) else: layout_opts.setdefault("flatten", 0.5) layout = "multipartite" elif initial_layout == "spiral": layout_opts.setdefault("equidistant", True) pos = get_nice_pos( G, dim=dim, layout=layout, initial_layout=initial_layout, iterations=iterations, k=k, use_forceatlas2=use_forceatlas2, **layout_opts, ) # draw edges! nx.draw_networkx_edges( G, pos=pos, ax=ax, edge_color=edge_color, alpha=edge_alpha, connectionstyle=connectionstyle, arrowsize=arrowsize, arrows=True, ) # draw nodes! for node in G.nodes: ax.scatter( *pos[node], s=node_sizes[node], facecolor=node_colors[node], alpha=node_alpha, marker=node_markers[node], ) if show_labels: # draw labels! text = nx.draw_networkx_labels( G, pos=pos, ax=ax, labels=node_labels, font_color=label_color, font_size=font_size, alpha=label_alpha, bbox={"color": (0, 0, 0, 0)}, ) for _, t in text.items(): t.set_rotation(label_rotation) if (fig is not None) and show_and_close: plt.show() plt.close(fig) return fig, ax def plot_circuit( self, color_by="function", colors=None, layout="balanced", linewidth=None, linewidth_scale=1, linealpha=1.0, fontsize=None, fontsize_scale=1, figsize=None, ax=None, show_and_close=True, ): import matplotlib as mpl import matplotlib.pyplot as plt if color_by not in ("id", "function"): raise ValueError("color_by must be 'id' or 'function'") if layout not in ("balanced", "compact", "wide"): raise ValueError("layout must be 'balanced', 'compact', or 'wide'") colors = get_default_colors_dict(colors) nodes = list(self.ascend()) steps = {node: i for i, node in enumerate(nodes)} rails = {self: 0} edges = [] active = {0} for node in reversed(nodes): if color_by == "function": if node.fn_name in colors: c = colors[node.fn_name] else: c = hash_to_color(node.fn_name) else: c = hash_to_color(str(id(node))) colors[node] = c # free up the column active.remove(rails[node]) # want to plot in same order the computational graph was created deps = sorted(node.deps, key=lambda x: -x.depth) # get the 'nearest columns' that are available for children close_rails = ( c for c in count_around(rails[node], layout) if c not in active ) child_rails = (next(close_rails) for c in deps if c not in rails) for child in deps: if child not in rails: # place the node rails[child] = next(child_rails) active.add(rails[child]) # add connector edges.append((node, child)) created_fig = ax is None if created_fig: if figsize is None: w = h = (len(nodes) + 1) ** (2 / 3) figsize = (w, h) fig, ax = plt.subplots(figsize=figsize) fig.set_facecolor((0, 0, 0, 0)) ax.axis("off") ax.set_aspect("equal") if linewidth is None: linewidth = linewidth_scale * 8 * (figsize[1] / len(nodes)) if fontsize is None: fontsize = fontsize_scale * 40 * (figsize[1] / len(nodes)) # draw the edges for a, b in edges: xya = steps[a], rails[a] xyb = steps[b], rails[b] if b.fn_name == "getitem": color = colors[b.deps[0]] else: color = colors[b] path_opts = dict( edgecolor=color, linewidth=linewidth, alpha=linealpha, facecolor="none", zorder=9, ) if xya[1] == xyb[1]: # straight line xy = (xya[0], xyb[0]) patch = mpl.patches.PathPatch( mpl.path.Path( [xya, xyb], [mpl.path.Path.MOVETO, mpl.path.Path.LINETO] ), **path_opts, ) else: # right angle line patch = mpl.patches.PathPatch( mpl.path.Path( [ xya, (xya[0], xyb[1] + 0.25 * (-1) ** (xya[1] < xyb[1])), (xya[0] - 0.25, xyb[1]), xyb, ], [mpl.path.Path.MOVETO] + [mpl.path.Path.LINETO] * 3, ), **path_opts, ) ax.add_patch(patch) # draw the nodes, and figure out plot range xmin = ymin = float("inf") xmax = ymax = float("-inf") for node in nodes: xy = steps[node], rails[node] xmin, xmax = min(xmin, xy[0]), max(xmax, xy[0]) ymin, ymax = min(ymin, xy[1]), max(ymax, xy[1]) if not node.deps: # make a square patch centered at xy with radius 0.4 patch = mpl.patches.Circle( xy=xy, radius=0.4, color=colors[node], zorder=10 ) elif node.fn_name == "getitem": # make a small circle for getitem (since not really a node) patch = mpl.patches.Circle( xy=xy, radius=0.15, color=colors[node.deps[0]], zorder=10 ) else: # make a 'rotated house' shape patch = mpl.patches.Polygon( rotated_house_shape(xy, r=0.3), color=colors[node], zorder=10 ) ax.add_patch(patch) # draw the labels for node in nodes: name = "←" if node.fn_name == "None" else node.fn_name color = colors[node] ax.text( steps[node] - 0.25, ymax + 1.0, f"{name}{list(node.shape)}", ha="left", va="bottom", color=color, fontsize=fontsize, rotation=45, ) ax.plot( [steps[node], steps[node]], [ymax + 1, rails[node]], color=color, linewidth=linewidth / 2, alpha=0.25, linestyle=":", clip_on=False, ) # set plot limits ax.set_xlim(xmin - 0.5, xmax + 0.5) ax.set_ylim(ymin - 0.5, ymax + 0.5) if (fig is not None) and show_and_close: plt.show() plt.close(fig) return fig, ax # a style to use for matplotlib that works with light and dark backgrounds NEUTRAL_STYLE = { "axes.edgecolor": (0.5, 0.5, 0.5), "axes.facecolor": (0, 0, 0, 0), "axes.grid": True, "axes.labelcolor": (0.5, 0.5, 0.5), "axes.spines.right": False, "axes.spines.top": False, "figure.facecolor": (0, 0, 0, 0), "grid.alpha": 0.1, "grid.color": (0.5, 0.5, 0.5), "legend.frameon": False, "text.color": (0.5, 0.5, 0.5), "xtick.color": (0.5, 0.5, 0.5), "xtick.minor.visible": True, "ytick.color": (0.5, 0.5, 0.5), "ytick.minor.visible": True, } def default_to_neutral_style(fn): """Wrap a function or method to use the neutral style by default.""" @functools.wraps(fn) def wrapper(*args, style="neutral", **kwargs): import matplotlib.pyplot as plt if style == "neutral": style = NEUTRAL_STYLE elif not style: style = {} with plt.style.context(style): return fn(*args, **kwargs) return wrapper @default_to_neutral_style def plot_history_size_footprint( self, log=None, figsize=(8, 2), color="purple", alpha=0.5, rasterize=4096, rasterize_dpi=300, ax=None, show_and_close=True, ): """Plot the memory footprint throughout this computation. Parameters ---------- log : None or int, optional If not None, display the sizes in base ``log``. figsize : tuple, optional Size of the figure. color : str, optional Color of the line. alpha : float, optional Alpha of the line. ax : matplotlib.axes.Axes, optional Axes to plot on, will be created if not provided. return_fig : bool, optional If True, return the figure object, else just show and close it. """ import numpy as np import matplotlib.pyplot as plt y = np.array(self.history_size_footprint()) if log: y = np.log2(y) / np.log2(log) ylabel = f"$\\log_{log}[total size]$" else: ylabel = "total size" x = np.arange(y.size) if ax is None: fig, ax = plt.subplots(figsize=figsize) fig.set_dpi(rasterize_dpi) else: fig = None if isinstance(rasterize, (float, int)): # only turn on above a certain size rasterize = y.size > rasterize if rasterize: ax.set_rasterization_zorder(0) ax.fill_between(x, 0, y, alpha=alpha, color=color, zorder=-1) if fig is not None: ax.grid(True, c=(0.95, 0.95, 0.95), which="both") ax.set_axisbelow(True) ax.set_xlim(0, np.max(x)) ax.set_ylim(0, np.max(y)) ax.set_ylabel(ylabel) if (fig is not None) and show_and_close: plt.show() plt.close(fig) return fig, ax @default_to_neutral_style def plot_history_functions( self, *, fn=None, log=None, colors=None, kind="scatter", scatter_size=5, scatter_marker="s", lines_width=5, image_alpha_pow=2 / 3, image_aspect=4, legend=True, legend_ncol=None, legend_bbox_to_anchor=None, legend_loc=None, rasterize=4096, rasterize_dpi=300, ax=None, figsize=(8, 2), show_and_close=True, ): """Plot the functions used throughout this computation, color coded, as either a scatter plot or an image, showing the size of the that individual intermediate as well. """ import numpy as np import matplotlib as mpl import matplotlib.pyplot as plt if fn is not None: ylabel = "custom" else: ylabel = "node size" def fn(node): return node.size if log: # wrap the function to take log of values ylabel = f"$\\log_{{{log}}}[{ylabel}]$" orig_fn = fn def fn(node): return np.log2(orig_fn(node)) / np.log2(log) colors = get_default_colors_dict(colors) xs = [] ys = [] cs = [] ymax = 0 for i, node in enumerate(self.ascend()): xs.append(i) y = fn(node) ymax = max(ymax, y) ys.append(y) try: c = colors[node.fn_name] except KeyError: c = colors[node.fn_name] = hash_to_color(node.fn_name) cs.append(c) if ax is None: fig, ax = plt.subplots(figsize=figsize) fig.set_dpi(rasterize_dpi) ax.set_ylabel(ylabel) else: fig = None if isinstance(rasterize, (float, int)): # only turn on above a certain size rasterize = len(xs) > rasterize if rasterize: ax.set_rasterization_zorder(0) if kind == "scatter": ax.scatter( xs, ys, c=cs, s=scatter_size, marker=scatter_marker, rasterized=rasterize, ) elif kind == "lines": lns = [((x, 0.0), (x, y)) for x, y in zip(xs, ys)] ax.add_collection( mpl.collections.LineCollection( lns, colors=cs, zorder=-1, lw=lines_width, ) ) ax.set_xlim(-0.5, len(lns) + 0.5) ax.set_ylim(0, 1.05 * ymax) elif kind == "image": ax.axis("off") ys = np.array(ys) ys = (ys / ys.max()).reshape(-1, 1) ** image_alpha_pow N = len(cs) da = round((N / image_aspect) ** 0.5) db = N // da while da * db < N: db += 1 Ns = da * db img = np.concatenate([cs, ys], axis=1) img = np.concatenate([img, np.tile(0.0, (Ns - N, 4))], axis=0) img = img.reshape(da, db, 4) ax.imshow(img, zorder=-1) if legend: legend_items = [ mpl.patches.Patch(facecolor=c, label=fn_name) for fn_name, c in colors.items() ] if legend_ncol is None: legend_ncol = max(1, round(len(legend_items) / 6)) if legend_bbox_to_anchor is None: legend_bbox_to_anchor = (1.0, 1.0) if legend_loc is None: legend_loc = "upper left" ax.legend( handles=legend_items, ncol=legend_ncol, bbox_to_anchor=legend_bbox_to_anchor, loc=legend_loc, ) if (fig is not None) and show_and_close: plt.show() plt.close(fig) return fig, ax @default_to_neutral_style def plot_history_stats( self, *, fn="count", colors=None, rasterize_dpi=300, ax=None, figsize=(2, 2), show_and_close=True, ): from matplotlib import pyplot as plt stats = self.history_stats(fn) colors = get_default_colors_dict(colors) if ax is None: fig, ax = plt.subplots(figsize=figsize) fig.set_dpi(rasterize_dpi) else: fig = None xs, labels, clrs = [], [], [] for fn_name, cnt in sorted(stats.items(), key=lambda x: -x[1]): xs.append(cnt) labels.append(f"{fn_name}: {cnt}") try: color = colors[fn_name] except KeyError: color = colors[fn_name] = hash_to_color(fn_name) clrs.append(color) ax.pie(x=xs, labels=labels, colors=clrs) if (fig is not None) and show_and_close: plt.show() plt.close(fig) return fig, ax autoray-0.6.12/autoray/lazy/linalg.py000066400000000000000000000043761462076570400175740ustar00rootroot00000000000000""" TODO: lstsq, pinv, eigvals, eigvalsh """ import operator from ..autoray import get_lib_fn from .core import ( shape, ensure_lazy, lazy_cache, find_common_backend, ) @lazy_cache("linalg.svd") def svd(a): a = ensure_lazy(a) fn_svd = get_lib_fn(a.backend, "linalg.svd") lsvd = a.to(fn_svd, (a,), shape=(3,)) m, n = shape(a) k = min(m, n) lU = lsvd.to(operator.getitem, (lsvd, 0), shape=(m, k)) ls = lsvd.to(operator.getitem, (lsvd, 1), shape=(k,)) lV = lsvd.to(operator.getitem, (lsvd, 2), shape=(k, n)) return lU, ls, lV @lazy_cache("linalg.qr") def qr(a): a = ensure_lazy(a) lQR = a.to(get_lib_fn(a.backend, "linalg.qr"), (a,), shape=(2,)) m, n = shape(a) k = min(m, n) lQ = lQR.to(operator.getitem, (lQR, 0), shape=(m, k)) lR = lQR.to(operator.getitem, (lQR, 1), shape=(k, n)) return lQ, lR @lazy_cache("linalg.eig") def eig(a): a = ensure_lazy(a) fn_eig = get_lib_fn(a.backend, "linalg.eig") leig = a.to(fn_eig, (a,), shape=(2,)) m = shape(a)[0] el = leig.to(operator.getitem, (leig, 0), shape=(m,)) ev = leig.to(operator.getitem, (leig, 1), shape=(m, m)) return el, ev @lazy_cache("linalg.eigh") def eigh(a): a = ensure_lazy(a) fn_eigh = get_lib_fn(a.backend, "linalg.eigh") leigh = a.to(fn_eigh, (a,), shape=(2,)) m = shape(a)[0] el = leigh.to(operator.getitem, (leigh, 0), shape=(m,)) ev = leigh.to(operator.getitem, (leigh, 1), shape=(m, m)) return el, ev @lazy_cache("linalg.inv") def inv(a): a = ensure_lazy(a) fn_inv = get_lib_fn(a.backend, "linalg.inv") return a.to(fn_inv, (a,)) @lazy_cache("linalg.cholesky") def cholesky(a): a = ensure_lazy(a) fn_inv = get_lib_fn(a.backend, "linalg.cholesky") return a.to(fn_inv, (a,)) @lazy_cache("linalg.solve") def solve(a, b): a = ensure_lazy(a) b = ensure_lazy(b) backend = find_common_backend(a, b) fn_solve = get_lib_fn(backend, "linalg.solve") return b.to( backend=backend, fn=fn_solve, args=(a, b), deps=(a, b), ) @lazy_cache("linalg.norm") def norm(x, order=None): x = ensure_lazy(x) fn_inv = get_lib_fn(x.backend, "linalg.norm") newshape = () return x.to(fn_inv, (x, order), shape=newshape) autoray-0.6.12/ci/000077500000000000000000000000001462076570400136725ustar00rootroot00000000000000autoray-0.6.12/ci/requirements/000077500000000000000000000000001462076570400164155ustar00rootroot00000000000000autoray-0.6.12/ci/requirements/py-base.yml000066400000000000000000000002771462076570400205060ustar00rootroot00000000000000channels: - defaults - conda-forge dependencies: - opt_einsum - numpy - dask - scipy - sparse - numba>=0.56 - matplotlib - networkx - pytest - pytest-cov - coverage autoray-0.6.12/ci/requirements/py-jax.yml000066400000000000000000000002441462076570400203500ustar00rootroot00000000000000channels: - defaults - conda-forge dependencies: - opt_einsum - numpy - matplotlib - pytest - pytest-cov - coverage - pip - pip: - jax[cpu] autoray-0.6.12/ci/requirements/py-tensorflow.yml000066400000000000000000000002751462076570400217740ustar00rootroot00000000000000channels: - defaults - conda-forge dependencies: - opt_einsum - numpy - scipy - matplotlib - networkx - pytest - pytest-cov - coverage - pip - pip: - tensorflow autoray-0.6.12/ci/requirements/py-torch.yml000066400000000000000000000002771462076570400207130ustar00rootroot00000000000000channels: - pytorch - defaults - conda-forge dependencies: - pytorch - cpuonly - opt_einsum - numpy - scipy - matplotlib - networkx - pytest - pytest-cov - coverage autoray-0.6.12/docs/000077500000000000000000000000001462076570400142275ustar00rootroot00000000000000autoray-0.6.12/docs/Makefile000066400000000000000000000011721462076570400156700ustar00rootroot00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= SPHINXBUILD ?= sphinx-build SOURCEDIR = . BUILDDIR = _build # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) autoray-0.6.12/docs/_pygments/000077500000000000000000000000001462076570400162345ustar00rootroot00000000000000autoray-0.6.12/docs/_pygments/_pygments_dark.py000066400000000000000000000124621462076570400216210ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Pygments version of the sublime Mariana theme. Pygments template by Jan T. Sott (https://github.com/idleberg) """ from pygments.style import Style from pygments.token import Keyword, Name, Comment, String, Error, Text, \ Number, Operator, Generic, Whitespace, Punctuation, Other, Literal BACKGROUND = "#1a1c1e" CURRENT_LINE = "#4e5a65" SELECTION = "#343d46" FOREGROUND = "#d8dee9" COMMENT = "#5a6272" RED = "#ec5f66" ORANGE = "#f9ae58" YELLOW = "#fac761" GREEN = "#99c794" AQUA = "#70c2bb" BLUE = "#6699cc" PURPLE = "#c695c6" class MarianaDark(Style): default_style = '' background_color = BACKGROUND highlight_color = SELECTION background_color = BACKGROUND highlight_color = SELECTION styles = { # No corresponding class for the following: Text: FOREGROUND, # class: '' Whitespace: "", # class: 'w' Error: RED, # class: 'err' Other: "", # class 'x' Comment: COMMENT, # class: 'c' Comment.Multiline: "", # class: 'cm' Comment.Preproc: "", # class: 'cp' Comment.Single: "", # class: 'c1' Comment.Special: "", # class: 'cs' Keyword: PURPLE, # class: 'k' Keyword.Constant: RED, # class: 'kc' Keyword.Declaration: "", # class: 'kd' Keyword.Namespace: PURPLE, # class: 'kn' Keyword.Pseudo: RED, # class: 'kp' Keyword.Reserved: "", # class: 'kr' Keyword.Type: YELLOW, # class: 'kt' Operator: RED, # class: 'o' Operator.Word: "", # class: 'ow' - like keywords Punctuation: AQUA, # class: 'p' Name: FOREGROUND, # class: 'n' Name.Attribute: BLUE, # class: 'na' - to be revised Name.Builtin: BLUE, # class: 'nb' Name.Builtin.Pseudo: RED, # class: 'bp' Name.Class: ORANGE, # class: 'nc' - to be revised Name.Constant: RED, # class: 'no' - to be revised Name.Decorator: AQUA, # class: 'nd' - to be revised Name.Entity: BLUE, # class: 'ni' Name.Exception: RED, # class: 'ne' Name.Function: AQUA, # class: 'nf' Name.Function.Magic: BLUE, # class: 'nf' Name.Property: BLUE, # class: 'py' Name.Label: BLUE, # class: 'nl' Name.Namespace: BLUE, # class: 'nn' - to be revised Name.Other: BLUE, # class: 'nx' Name.Tag: AQUA, # class: 'nt' - like a keyword Name.Variable: RED, # class: 'nv' - to be revised Name.Variable.Class: "", # class: 'vc' - to be revised Name.Variable.Global: "", # class: 'vg' - to be revised Name.Variable.Instance: "", # class: 'vi' - to be revised Number: ORANGE, # class: 'm' Number.Float: "", # class: 'mf' Number.Hex: "", # class: 'mh' Number.Integer: "", # class: 'mi' Number.Integer.Long: "", # class: 'il' Number.Oct: "", # class: 'mo' Literal: ORANGE, # class: 'l' Literal.Date: GREEN, # class: 'ld' String: GREEN, # class: 's' String.Backtick: "", # class: 'sb' String.Char: FOREGROUND, # class: 'sc' String.Doc: COMMENT, # class: 'sd' - like a comment String.Double: "", # class: 's2' String.Escape: ORANGE, # class: 'se' String.Heredoc: "", # class: 'sh' String.Interpol: ORANGE, # class: 'si' String.Other: "", # class: 'sx' String.Regex: "", # class: 'sr' String.Single: "", # class: 's1' String.Symbol: "", # class: 'ss' Generic: "", # class: 'g' Generic.Deleted: RED, # class: 'gd', Generic.Emph: "italic", # class: 'ge' Generic.Error: "", # class: 'gr' Generic.Heading: "bold " + FOREGROUND, # class: 'gh' Generic.Inserted: GREEN, # class: 'gi' Generic.Output: "", # class: 'go' Generic.Prompt: "bold " + COMMENT, # class: 'gp' Generic.Strong: "bold", # class: 'gs' Generic.Subheading: "bold " + AQUA, # class: 'gu' Generic.Traceback: "", # class: 'gt' } autoray-0.6.12/docs/_pygments/_pygments_light.py000066400000000000000000000124731462076570400220110ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Pygments (light) version of the sublime Mariana theme. Pygments template by Jan T. Sott (https://github.com/idleberg) """ from pygments.style import Style from pygments.token import Keyword, Name, Comment, String, Error, Text, \ Number, Operator, Generic, Whitespace, Punctuation, Other, Literal BACKGROUND = "#f8f9fb" CURRENT_LINE = "#b7c0c8" SELECTION = "#d0d6dc" FOREGROUND = "#161c27" COMMENT = "#8d95a5" RED = "#e7323b" ORANGE = "#f79626" YELLOW = "#f9b52f" GREEN = "#70b069" AQUA = "#3d8f88" BLUE = "#407fbf" PURPLE = "#b474b4" class MarianaLight(Style): default_style = '' background_color = BACKGROUND highlight_color = SELECTION background_color = BACKGROUND highlight_color = SELECTION styles = { # No corresponding class for the following: Text: FOREGROUND, # class: '' Whitespace: "", # class: 'w' Error: RED, # class: 'err' Other: "", # class 'x' Comment: COMMENT, # class: 'c' Comment.Multiline: "", # class: 'cm' Comment.Preproc: "", # class: 'cp' Comment.Single: "", # class: 'c1' Comment.Special: "", # class: 'cs' Keyword: PURPLE, # class: 'k' Keyword.Constant: RED, # class: 'kc' Keyword.Declaration: "", # class: 'kd' Keyword.Namespace: PURPLE, # class: 'kn' Keyword.Pseudo: RED, # class: 'kp' Keyword.Reserved: "", # class: 'kr' Keyword.Type: YELLOW, # class: 'kt' Operator: RED, # class: 'o' Operator.Word: "", # class: 'ow' - like keywords Punctuation: AQUA, # class: 'p' Name: FOREGROUND, # class: 'n' Name.Attribute: BLUE, # class: 'na' - to be revised Name.Builtin: BLUE, # class: 'nb' Name.Builtin.Pseudo: RED, # class: 'bp' Name.Class: ORANGE, # class: 'nc' - to be revised Name.Constant: RED, # class: 'no' - to be revised Name.Decorator: AQUA, # class: 'nd' - to be revised Name.Entity: BLUE, # class: 'ni' Name.Exception: RED, # class: 'ne' Name.Function: AQUA, # class: 'nf' Name.Function.Magic: BLUE, # class: 'nf' Name.Property: BLUE, # class: 'py' Name.Label: BLUE, # class: 'nl' Name.Namespace: BLUE, # class: 'nn' - to be revised Name.Other: BLUE, # class: 'nx' Name.Tag: AQUA, # class: 'nt' - like a keyword Name.Variable: RED, # class: 'nv' - to be revised Name.Variable.Class: "", # class: 'vc' - to be revised Name.Variable.Global: "", # class: 'vg' - to be revised Name.Variable.Instance: "", # class: 'vi' - to be revised Number: ORANGE, # class: 'm' Number.Float: "", # class: 'mf' Number.Hex: "", # class: 'mh' Number.Integer: "", # class: 'mi' Number.Integer.Long: "", # class: 'il' Number.Oct: "", # class: 'mo' Literal: ORANGE, # class: 'l' Literal.Date: GREEN, # class: 'ld' String: GREEN, # class: 's' String.Backtick: "", # class: 'sb' String.Char: FOREGROUND, # class: 'sc' String.Doc: COMMENT, # class: 'sd' - like a comment String.Double: "", # class: 's2' String.Escape: ORANGE, # class: 'se' String.Heredoc: "", # class: 'sh' String.Interpol: ORANGE, # class: 'si' String.Other: "", # class: 'sx' String.Regex: "", # class: 'sr' String.Single: "", # class: 's1' String.Symbol: "", # class: 'ss' Generic: "", # class: 'g' Generic.Deleted: RED, # class: 'gd', Generic.Emph: "italic", # class: 'ge' Generic.Error: "", # class: 'gr' Generic.Heading: "bold " + FOREGROUND, # class: 'gh' Generic.Inserted: GREEN, # class: 'gi' Generic.Output: "", # class: 'go' Generic.Prompt: "bold " + COMMENT, # class: 'gp' Generic.Strong: "bold", # class: 'gs' Generic.Subheading: "bold " + AQUA, # class: 'gu' Generic.Traceback: "", # class: 'gt' } autoray-0.6.12/docs/_static/000077500000000000000000000000001462076570400156555ustar00rootroot00000000000000autoray-0.6.12/docs/_static/autoray-header.png000066400000000000000000000637021462076570400213050ustar00rootroot00000000000000PNG  IHDRe0sBIT|d pHYs77tEXtSoftwarewww.inkscape.org< IDATxyE>o,$a!a'l!AeFTY (8 ﺀ L@De5QEPG F(%l&섐}ںz7a~>Ov>]uow:"?+\1+F3^D$` & DKx1 O } DŽ{}3h}Pf xq_ ĒqӤ-N #7JlY F9 GrX;]7_ojww!)5l'AGi]=1uh7CڡuAlM-QdѾtȬ3,'83}]_aЮekٕo'?P% #N>0-ߝ=?5m mqͧ=Koc3.3vV`Օ#uCiO*g+ )6Me1 ?w^l7/K/[*(#鬳uX(8MU̲UϴbonNbf@QD@`b$"9G8<a3. 'up)oe69 $I$}1IdF_^S*3f$nO$R3A$L;:z6 02^LX0"#<7cgZ>slu.SDMNDFew;ODdZFup83A- 1~c?!>֑herJ I9޽ߔ6{/$0·@$|C"I X0q l*"ٗH;2 Z싫 x zE>bE!63y<Hܞ&ۙc@%5ʶPZx?4ƶ ` " ϝ;H4Ƕp/5&9`3_rRQkHu S b^P06̀_-6fO$55IB7,M* $埮LGԟʞ:^6娋fUsoQ.+'xGo9 ϒ}M&ɛ*oc};8򯳷:f;AH2!d\^6Z]O~>@,flɻ |寃{~NR-Oe_9OC7N[\rZtma>.ߒޒ;l2 pN/#p6 NuzŐ-UAsq]T$gw`ּy?ID~"aZT6B<>vo^/{ۙ}z8k~Fc>~ H'vՔqɖ0gwThK,_1N]Zd4x.ւycTb!k)>恺,OR_ŷ%rIcaS8]$O )p~nΝ0'(DыgCpfۦSM.Dϝ:ƌI؞ ȅ2p\>ƦI-N-5~tgđz '^tek/?+`4@8u<#2F=%;⌐S(',}~>38Êx1X[0NEDM4>TsfAf9/nG]{x` X#I5aNKl^Ïpb^FM{4yYͨs=oֱOS1O[t/~k<Ng&2y/SōD 0ıӬz1!5;mS,e&ʜS3:hD>f(σa@],d<cdݲUǏNK`'YkW3 =Sa9Oc.?yQ[q'*6Y6yF;؝knj9^sK0nĻsrF ;JcHNBO$FHr*G#?MYPs t>9G_`0:)۩c;+6zC&ֳy "gW)ɓp4HșY3u8c~Ëֹb3K"âkx$y_N3޶}.,nN/ԏ;j$9[5y}j~/cDJ3eҦH^8|WM4̖CJ;yO˟TDzH+GϧCs {  |9-:*k$߰p\ۄ j׆B+>Z mb( 7|/j¶{mǘ Kt{ؙ{Zu$=0W_ ީuc>`dvtrwH]d*Img_(Z'^ZQ$7k16th` {"F|N3=Yu"cI^ <8E/W|5'o$]f$ʟCg˵[:k=׫&%@tjIM\3SAv;͞=ɰD̒ɉ>t7|2;&}Sx4_3.p$Ǿ#aF]YP!+%M2t^A|0̐<I'&('$9^!$̴lW\QJfǤ֝Oewy=ιm773noGoMf `wH7)lk NGw>CX9tտTS?5evF&)z65FvAc1yU$GJ)HﲻzNro}:$~L3HsKn?ۊ*ϕd.QqT/l&{ 2ʷ3cu} t*/ʫ{_|ڸԏq`mn ɰi֓]$>gGs|Πon$|H !yL#p_g iy-|3$2=*8&*Òd`gN1^F՜Mb0ϴ,&uruWΫ{7# = &yĞVV=)co>|Ǫ1ǾlUnNƎ{1cMQ> L->ܤ3HrL't3$9}#pNc\DnvJc).g8+?}ҙl)1lcR"OCSQiXbLr`J^{ARǢz>YH#J9] \wުHUINj}sG3Wm:!JRWz~јhtԅ8hZ=YuűrWJoLt_Irqv$9nwHD ‹$gDԢ,aHr:$9Qp;0Y8 <\w5Pk1?OdWrkJ2铛 p$WVW\qv5wb 8Hgs:c#uGVx&QޘS3dE-gMyʗ\uoNdD-zQ/WVRb^L: ɑxyjThLDS{ZUGgWʕY$W- J }]޴D=o?DOQǐUArXd|r|Sc)R NBfsr/< [g9 K?/dsc'nq32i]fq&R#˸[Q @n \\ծfq N[[I}`d(u<.P8Fh @Pwl6#3ي1} ^䙧\ۘkg|k9nAE?h栌]|v^:h H:|w/-yEӴ3^,4peLJ;F4';"zv Tf.:0SqફSԙiN.ұFY$i9t:TDp@2sͱ>o$'>;S:#l$L{ Gj /-B>$9K'&`_,9tgl4d Ool(Cq+hn !S_Iܵ p?u}utٹ)WS̩㷗(ylxψz)|#}mU; 5'<c]+61_}ն*Yq@k\VtnzC'ScL]NW+&ɑKLxhvN}5WwASnZ[4ϢP5ΫBߣGF_Au8,Ei/eY5e}lHrɸd.2[}zW|{T%RZN~H3Ok2%zVzdM6 KY,]yѳarA4hL" b,栺Sgä.Cb ifL:n:y\ Ev ,yk>O_w%6r`svז~fi^U<~nYu^ۼϞgT^b6pdJ[8{L[ yRu& 'K l]rgDV|goON-ˑvMl5߉ΪT]w /5cq15k$D|wӦ 2tf:yIfk!>yXS.ey'/6rKbF\N Ԭx㒕59I`meլ}t{vI}Szn?kZEU6byH>{oefꄽ6]vيSxms;̸,쏷?eHr*DIn˸~E͐2'Ӂ@#Ɂ3I{!U'!I:p?h-kc" ^N_:ܳ[Hˌd"v:ul^jg"mҝJ+OZ+541$ FR4lo vw\&Jԥ,Z|SvDXNW_:vOgM zk>l$9Հvrt\q$nwhK5/-~ xIX؂m<$bIr+WT鳧R >3UKoOg <LeN/$|ׄ0XrHu<SX~v֖_X^ʩgotf++ݩC`N`HRтi!Q‚.D+3) ;U`5;0鹨^'$' 2:]5Idޭk;yBgChDH{WӼθ^H}¹rTg4U#%va@.iY|e#;Wz @bj?4{vJQ$B>H2%9Zȓr7?o6+a:Y3Nݩ`N{ίf]3ߣ?%Hr@ߧ붪NAlc D3$9kj>EP_ƢC, ə֥XҲzO 2Lլ:y28M[TL_g19=suHX۞Vr/ XOnkHspō}Q!Rw##^m-@zpDNufDg:]֫S@&Zc@NcXxzASE*^n&9_ffcLrt_/dWHZ#xt? I#5)hs[8V/}&X^$MHr)R\"[D3!iF'o0{o>!Nݗٞu ǘp_$7bfug/c^Ʋ9u(sCVg+$O>MUUfͥB7Wt,pH#LrGJf?Qxu=N89?=o=_7+4}֏ϼޡCvm%əOoΕ |aX/N}A $&k"iX~l:@yRFus3EBO$$I0=B>9ۊ%u!$!??+njiڔQ֫uJ (A¸֣{$WlMƍ9uv bt0*B'Õ/z,(=,hYn/ȊxLI><3 y!]qS^xi5*$9feW1&&i(~'2̯H)'s 1PalZ:i $=Ͻ!&$z{J#{tIxnepuGk_n#DѲjoMuRzFx˩ꬄeX>"X#Vgp~M`:ޮ=HHy"11y'n䜦lW2 ֮Y_IgJ=ڬa zpɔ@nSV&+bt;ccm=>dW$$grk$G~j3`'-L1آˎ2~X)IΒ5t/7CK9N*qʗIr| sEHu(i-7Ij}aV{ il4I.^M0C2FщIrInbLI_MC"XC$9Flt Ir,Ad$9N$qG]U=~sEM@^ Ud^7ZWEݩwE$Ma Q It7uMV=y2n1Il1+lbY@ ɁI.IAOE\9sfc)lzQ3IrZmdxVo>-kx| 6 EYĵ[d]r/,;SZ]Q]Y.#;׌Wur6V+:ʷo&|>kO)CZv s'>^#cqڑ&ިJskazبp&2 D$fEneY?NfAqTT:V 3ܿ-Y0 I8uhuѮxAw&?CNk/Aarc|uAt1|?|=Uӭ7:u sy1T# %ykZm!}nMD[Hryt9h&&6Vy}#u%3vJ$9Bf#ⷕvtsF~ՀjSum2~\!Ϭ~JM: JE//Q9={A6¦FR Y^0UO77]~00mRؿG_olEߜ] ߒIȖ(X+Ǒ$g=^ې:!J4k ^޺Lrڋ &)Tv[>N:#$9 IH&)H*Sfk:ః^oy'ocF(ϓ(w?\v53?) 5Zkh[&6~_RD3:W'ͭf85EnS]ީA.6u"9/{D/<w[1!p|&)q{S῟<2YhϕoSwVYD]"&Mj>$9#L-kIrXmx$3roM^L?ICRyShY08E f#]\۩33KW?^BSܞs'"s !̈"<3NnVHsNwpҥɅ>9u&+t,u_o9@b+!=L~3ɑ៫>f͛EvQv#W@)I!ٕ k璬 |YPe֝zws{#l6MVVw7*ۖEg\a+o)箯ߠ0I>Yϱ#u!N+9f~y'e^Zv趢: B=HrlA!Xx=leB>˶I6SNLiǘV|;e&y7rчI֏>L7/=Sj$Ӥ[ 2߻ƲϟS,'=lsD%*\(^dm* S18vtL,UYw.6,zԏ}7a0-n"H >Rd3f1L)-GIB#5La'$'̬[6 C6GVJss5#ZΠrCu}eTRe?B܆Ӫ]t,ٮW6:_[gHq|ÿcsn76@J2.g+?fsN,FDqG=W0zV=h>ltƚP;jF11ks1bҴ$W85Zٲf/c6!c'ůyMa ӹO_s]Xl xA @V(4;pVdeLrMR;u^޴Trmyv?U?Sv`Inǫ`IPuL={حr9L|fQnl}gMrIpaKKd%'uI8^mj$}E;TMGv ScVYpU .N3DN'] ЖfIֲ!M2ǬJe ??X>$OfmI73rO@ʓob) x~ Z7]~juqgux_i^Eu qV/1^j&NrIrcЊYHx#dz>$9|3Q9+=-ϊZCrâ F^'>cŮ7F?xu)DCzy K6j|@HI.F4!ÕٌC!o6o'Vk”3y8*+p!u}@9˹nO[W\|lSz @~*]q/Y7i.t!)zVf:ĝ1%G,GJ+Au%"ٛ"'IihzXRHr`$L"I;Ir]ړpth&R?oJ[GH/}!G$9.ԉg/ǵG2נ//.rf 9@<Lj84z1y wuW+_tDX3O5lW$ʅX ?[U1cgc3WS5LY棦 'e( ֟䂈8iQ6L1e_>x۩1Lr)̣Hd8r#3\}z^%SQMdy-Nkd}&F \Rr$y *">5Dt2mwF q"ܯ?M~% ^uCPz(7#6|OXsY}x|w6=w:Y_ݵB3 r%Վ|IIN0qӐ|Y2*uE}$ɑ@~>-A`x=#ɁɦpU wײ͎}luRY%˹#WNͦ|?xøGŨC'x^ڂv c<:DחohĆ:z]o0I: OO-zIDF$9۾uǜ `.xd2:/UItB͐ .r Zs$WdWq+ҋuzIc\d2A㟳{b=F <0m놂} ptdv4 L\K}В7SxY[0}Oh@S_إݲ.gU~_7yCLe4wx.ծB$^3$9Iy=sGV ̨ Q~Hrx^@K9&@M/glwߛ4SKwlA4lt'41RXL'PJ/8jg}3EzS)ݟ;jgV=zԙ'EĆsUb#vI.;ݶ l ,77E@S` Ʌ-$b$#`l3k9)ժUSؚsE292eܥx13zDu6ҕ/iBt/gmsw6noò,6ܱ.BѸS5=hW{yE<>l>DIVx̬m[{N_2IΫVӱ\d/cYIrQg7:CXz6/_oμV]b7hܩtd.jOz$pS%CX*G ˪N G=Hٝ^T|]y"hh&6` 2֤bĭQ0@$'>7!(zzELџ01(sq@6'jY.)W? v?{idd=:)~5-Nl~}\/3t=Y=Hd3 a5FSx䮊 ֖/؞~'=!1qniϫpз O\`|VC•;&m\cƝ߸'I'y~.nxEڕjʑ~i33TS v(O(x)*0ל_+ܦ_O7/+&M^hԩ;t*э m_ai֬yƃDSo.Ö.kb1 [M_$ZIs!O{_HY#)_&NtZ<-Lag;%ӻB_M/?$5U&ƅ!0};O}3M9;e81Sg=Xʪwxse?kɫqf?gs~#¥LXth٨t3D1w 7˲7f\u q*M#ܾ-љ+y m$3AГḨ~6iJrxiIH#U?WYg 0Jy'g1VU$>v9秾'TMλBmGoD(wÍ?k˕tEZ4Ϛ5/`cRǫLҟEUlduc +2d yECiN=X+k$݋zWƐ;Vg/ztȪ$Nȼ_㰧0ɄInddLGF̊{e2fYsQnAw=u9j%arRTK^1tȠ^.Dmx;L/",]FCM@MqU~*g&'m;B%EQRC$x`o!ɑ wMO:Od>ZC˷9dm&eSqz0~WOXFXd42tk!$ƒ%׌YU{:{hsl8$w| /lʶ_5*k> Uؙo/gUИS'Asrv!I FU;lBS9{52$DIlY<]twcּy)j[^I$BNc$#c^M@P'ZR*ZK"IΕֶ[q݉*/>~ϳz7FE85&Gc:g[4ԏ?-|1@srh5zN4PqlV<"QҔ@T'1R%c?lF+ A\BF~m3?sGf,tan{Hk+czC\@cTuA2EGVr@!H4NB4̭BA?UqP?:@Љ`wSWuf$9lFv@jL>8c Rc.̸_Ohĩ3x R1hc''TM`D;jUn{f-ܞ ϫOH> $'ڷV3Ƈkh.̐QtbYʌASIqEN1h ;wM7}Ȗ/fU!¢VmE棕q?Hj M::5ڶ1ml9-k^ Qo"PB '{%>Ӟ+T)] qzcY^8%cحHj^>\z|at$S2f(IrZm7tX2T^-2ɐ%J[9o9'+N؅[1c׈snïNlTeҗ/k\Q۩97wVu}0oHp&2 D# m6|IrdgCIrIl*o uOSYY3f\ 9X3<DIa\|ɒkrpkUs 06S'no=9lrc*sN30'R$9mӬ'=u&9$ərG(Lme$t)h?$@#,5#>O(IE Gcg$ӟkX;!ڟ9ae` ~hWh$,I[~B?^> KFz|m/3+_pB۾} ~*;\;^P+R?yƗ'2ӑiby-Zo+:v[&3k#ɩ58M!Cg IDATG%Ir}8L9 ;%>r݂zGYYyNTMgh>R'aMo_? 1\|]jf&#j8zb:-2`n$OJ+;Zt tm1oޱ&\[ɶ>SG<9Î]&<y ͚p{BoHr@9OCUơPHr$3)&iP28xUFoft5zr' @;ySrFnR>]OWty0tlEA0k lFLH dM:v!΢vz(ZNsҼ rΑWqW "(\n5Mn^ol񨇑N:abQ+K֖84(X^~{%IilcȒԹuV-e:INE9YjkH#nؓ6ߍ\)j{C Dt6U̸xUC+-D¢}3F7tc$C{"Lr2>p&$92swL/+ח FhSd?7;V6%pX\ xpUIrfk$gu3^N7rg ;4t'ص }ؖ/Ms8ڎ]saCCe.I??I.{R IN]͐5PbΘ!alNbG#4z'fK INV^}!`Ad6§#$V&,ޚ4Řp1\?ZT'7\1f? ~nw@0u(*۠˦ԕ/+:p:m~z10h.޼ʓzXus 3x+\|24HL 9MIή[/t5a]v|v kT\ړe^Bn[dhsL^ g&n:P62~neظvܪv9i#Wqϴ'83I.ZsF3ik#{jǎ,,׫_a0,Ry¤I ';wv#\D#z3Ѿ\Vd%? I#ɉ aI҉IrĽI.2Q.^,F:x&?Gqԙ6d'I.Uĩ6RƽqwzL(aՉFS#~qn{!ߙ-_owT{[z I.SjA ڬφZJӓخgεgc>SVǾށ N}+ |pSU$gy( uN; 2V&/qΰ&}h$%ڗ  edO'yx"r)B7eo/Irdv'x `Ћo06̔â}S $9{c=,vێ L'+Յ(4AP7y߁0Tpꢅ1PHrvBLE{]'c{c?9ӁKe$ Q_ ;S>8O{bRmNNtiD^ń-Ud!O|w֧g2$G7/<W$gDd9-ndzε(d!D{$G[Irn1a+Oa5if>xoM6b11$9R4Xהg`¢OeE]|I.95OwQ<7c|mrvJY֊ iQkK@#5g*fͤ+9zz;zӴcw\1m @z5WFi#EġLRAwq䂽9dKf@SM.+cI $㮺BУB-\ ը'Vu^~/h9$r97mW\-ss*\IѶoOfvR!;SPrA&>Ak5"ӏD7:tӦ9Ag 92.HIaaA5kDS&sܡhS۩u{"+-\M:{I,JLsk ӋOL/n&ơL :Ͳb]HU;8ɀI.-a1\BSOTğK.IM߁Hd~D".!84^븪N=t{Ln$+ۂq͑Y05_IN}mSWlK_̃&tYv\'h\$?ty]/ Yumtz 3=nEzI.;p+ cCuvã7`Ym'i+XtXkWR&>$FŔm%gOٝFx肩'Mz.quL2c8N/`st:^M OJ[ R󰮏uVko"c$9]C22%a`m\sǷ4ʦwp:o_-k#iWZwVQ P~0q&4DʂMNI$cylmmYȈ5~2\z*?+QrXqu^e>jެ(&ͨsHuqRrmyT-;>ҧ͆i ʓ#hTM/$YnF Ļt&2Cx@i]|1ʼnӌ$-WEz[yGnuSWr~Ir1Z-_Uz ha/\q je,Z!e3!ꌩWu\ԗ{(;{e^ͩqf@!kP$p17*V$Y҈O.W d"a F1?k/kXʒB EГQq͕?١Y"78-[2˭pʌ?^TlN&>k'tȇm̋C1u*$_Zî˩)9Y$Lc׌ҧ`#=%_['q8c"eESc?n#{K,7}cSN%$<̷?cc aIy IΪFzŞ$cxy.^xb^ poW~I[:>~ m_VOr|E3=$5YJ@Yw;u.Ő~ۄ G䥦(00a8e8[)ץ0d44j e1^DIlpů"PզI@Gc$XMӞefW=W?pi*,)!&pܱ͘Z7"e*CKϓL=YӶݜ_d t̫5[ (ژ:wf$\?I ">zw8@ <~% NM`0J&i%3<]߾dǑgm-q6;y;ʚ2f̪! r~NI.vLsӇPcPI^)\v9RQ1?S:;o8ޥC3¶)\]5^}ҙC$9˯aP:%GnQn4h B{{ˑ +Tc"2o>'tieqǗ Vg@ȓ+}mI.XIrl93'(xa~ǂk̸]zmOcGvz2n9'_$YW8^X~~=-/a`t6(\IgOHr@Sg"AN0V$'GWD08Z:1ԙ_7(]Z#`zϿ-= ]KS;]$;ڣw;\ڱ(82 ~b]f?~n1ΰ}cO7}U3gaL,_DY AdviS. |Y$/u-ѧît *~nI.dԧ/fuFY{|Cjl=S ;KBm=ȸVxK%?H$9S&|-Ē~u)O] w% ;RJxy|X$7";0QYLny^&O\%Cv%2s["h'_yGķHH:0s gK玥h&$4=K@;é}vnJAIp﹦'ަ +܆q 5US /52+t,N}Hx,[RVriq&s-NSAzPJue6=l<ؘ/@tp䇗a9 ڤ!PX5ҍf̝ݗ8s$ Ygl!nrH3Kn7f! TzZb~-!D"K-]vXeO|=1<2Pg4vUHr,S<l xQ{ؼ8/:>(H|>:Z$g[š~'dM/E3߫`c)c: /B-ԱvRGmOĮQh+ğiN[Fy1f^PJ`clڅ1NL?3i P/*։bV̒N~|̙o]{#_\]cq,gys*9UJ6vqYͯ [n5 79q{!CT A׵wLE;!Y:&RVOϟey6]=DS+EHo/T{a!%$9Z?)` Yg.tE|ZDyΔ?C!ղU%ɅWftqbW'|}[a\H;^4]|K۳at]'ɰާȐCp'EAcyg<\%əc~VINsWVPL0JlHr˗+ˡ35>I.wl a0 IkQ#,.V*%/]-$Ke>zé_I,Ep{ >܃$jm֪FG<Ʀ 2$d&"+#|I tN \,Vsk+m$1{U-C&)ʯn^%GZ|ݳt?2erGev.53 ȏy)Y4ÝZ]ٗ(nr~ k k(9鸗[#$CB6ԦSIσ$:Zxc\܃v\DQxoMN;&YjrY oo+Hr4Hr.-N>E*LfIr |˔9hI"Ukd;@viBSnfdWBtiOzV.7BIr6\S?a/M%t$6L󢘛x'މ`l$rE[-0H`\]TXx/wH \HLrvt 5S@<^MwQВ_ps"=wjYD:e[|;$7jU =ޙ]o!mC pHӻ 5Ljډ6>̮[x7'B9ֳ!F۳O]hΗ.O/u5Si:}I$7W3d7N80 ^mգ7 r4عغp+]^hm?o{t ѡI**&1M<* ] ҁN*ʭ0nPamgcȭG ̴W;EZTV/IȜւ NZWA\&ͧ6Nr!KQ[ӳ ?6=IR\P$Wa9k:ɹ9f1V*dh= Ifgh?:q$W៷8[vJ.P2^@A[TO[7oQJr&|vv~ n>o{9hxX>4=9ԤRAv;V\q4x'~+|/{`-K$G@IAc¸;׀}}z2 9s@KD >oE]uaoZ+ĸ;/'y>7~`Śp Ȝ|O%IDATyjct.a#$צW~G9.;`6_GɌeean I.5r%'< C7 'KfU1/ :q8MKuyH߳{Jad%Ta+5h73|RK֯!I.* ΒX",[>hmu7ʂ Z\{TQwjdv͆}$gh7ʛȝ:1t;Y&ַ3?I~ⱇV<~+xqz)L[8eF+pc=;eĻR[i<wN/hnFD@?\;#t;^ajn8~3Q(FٷĢ V$> )uFē@YzH_;f ՁNغe=2^.a'5ؾ R;,zfz 0ܐ/6ȼ`$>:Y)(E˒`4f?XAz$5yzfpK h/~R)U?'9~\6%zPz%|BMڐy̘:_ ẜ2f`ڔhx0n "OZ$~@Q!<Ǵ\%}Y\Ir=PEȚ2;[%"`f߁9I&ta((2q˞Yx.Et>H&J R*gռPć2 ES/NC;.t{_# |*bcͷ/;#k_37Ĩoؿ] ?XDjiLMEsXx-k-] V'†RoDoï÷9w        °Cnk<>YJu'S̱Vej̺mgY텸pi 4f/K!i|ǽh2Np hNtS;NÐ;MɷvL%o.1a̹s:5.YEÒU.g2' [ws5iq~7J$P1id2:?y,=0JulCho`;nȷ-}2J\vxP!YZ?YAWFWjq{ބޏߙ{wSBYCYEXFWIVŸFOhkq{݅ޏߙߣ~YGWIVKVLUMUOTOOfhkq{݅ޏߙߣ_LVOUPUQTSTUSVRWOƼdfhjq{ބޏߙeSTTTVSWSXR[R[P^PWOɴbƽdfhkq{݅ޏߙߣkXRYQ[Q\Q^P`PaPbOeOiO̬`ɵbƽdfhkq{݅ޏߙߣq]Q_P`PbPdPgPiPlQoQuR{Oϣ]̬`ɴbƼdfhjq{ބޏߙwdPePhPkPoPrRuRxS{T~U݄UۃWӚ[ϣ]̬`ɴbƽdfhkq{݅ޏߙߣmQpQsRvSzT}TۀUڃVهV؊X׎W֒YӕWՒYқ[ϣ]̬`ɵbƽdfhkq{݅ޏߙߣLjxS{T~UۂUڅWوW׌X֎YՒZԕZӘ[Ҝ\Т\ىWՒYӚ[ϣ]̬`ɴbƼdfhjq{ބޏߙÒڄVهV׊X֍X֑YԔZӗ[Қ[Н\ϡ]Ϥ]ͧ_̪_܀U؉WՒYӚ[ϣ]̬`ɴbƽdfhkq{݅ޏߙߣ֏YՒYӕZҘ[Ҝ\П\Ϣ^Υ^̩_ˬ`ʯaɳaȶbxS܁U؉WՒYқ[ϣ]̬`ɵbƽdfhkq{݅ޏߙߣҚ[ѝ]Р]Τ^ͧ_̪_ˮ`ʰaɴbǷbƺdždeoQxS܀UىWՒYӚ[ϣ]̬`ɴbƼdfhjq{ބޏߙΦ^ͩ_ˬ`ʯ`ɳaȶbǹcƽcĿeefghgPpQxS܀U؉WՒYӚ[ϣ]̬`ɴbƽdfhkq{݅ޏߙߣʱaɴbǷbƺdždeffghijkbPhPpQxS܁U؉WՒYқ[ϣ]̬`ɵbƽdfhkq{݅ޏߙߣƼdſeefghhjjlnqu\PbPgPoQxS܀UىWՒYӚ[ϣ]̬`ɴbƼdfhjq{ބޏߙʜfghiikmpsw{݂XR]PaPgPpQxS܀U؉WՒYӚ[ϣ]̬`ɴbƽdfhkq{݅ޏߙߣӞijlnquy|ހބވތߏTSYR]PbPhPpQxS܁U؉WՒYқ[ϣ]̬`ɵbƽdfhkq{݅ޏߙߣۡpswz~ނކމލߑߕߙߜPTTSXR\PbPgPoQxS܀UىWՒYӚ[ϣ]̬`ɴbƼdfhjq{ބޏߙߩ}݄݁ވތސޔߗߛߟLVPTTSXR]PaPgPpQxS܀U؉WՒYӚ[ϣ]̬`ɴbƽdfhkq{݅ޏߙߣފߎߑߕߙHWMVPTTSYR]PbPhPpQxS܁U؉WՒYқ[ϣ]̬`ɵbƽdfhkq{݅ޏߙߣߗߛDXHWLVPTTSXR\PbPgPoQxS܀UىWՒYӚ[ϣ]̬`ɴbƼdfhjq{ބޏߙ@ZDXHWLVPTTSXR]PaPgPpQxS܀U؉WՒYӚ[ϣ]̬`ɴbƽdfhkq{݅ޏߙߣ;[@ZDXHWMVPTTSYR]PbPhPpQxS܁U؉WՒYқ[ϣ]̬`ɵbƽdfhkq{݅ޏߙߣ7\;[@ZDXHWLVPTTSXR\PbPgPoQxS܀UىWՒYӚ[ϣ]̬`ɴbƼdfhjq{ބޏߙ3]7\;[@ZDXHWLVPTTSXR]PaPgPpQxS܀U؉WՒYӚ[ϣ]̬`ɴbƽdfhkq{݅ޏߙߣ/^4]7\;[@ZDXHWMVPTTSYR]PbPhPpQxS܁U؉WՒYқ[ϣ]̬`ɵbƽdfhkq{݅ޏߙߣ+_/^3]7\;[@ZDXHWLVPTTSXR\PbPgPoQxS܀UىWՒYӚ[ϣ]̬`ɴbƼdfhjq{ބޏߙw)g~.g2f7e;e?cDbIaM`Q^U]Z\^[cYgYmYvZ~\׆^ԏ_ї`Ϟb̧cʯeƷfĿghikqz܄܍ܙg:hIpQxX`gnv}÷ůȧʟ͗ϐшԁyqklnpsīTT``ggppyyߚߍ݀rjgžeɳbͨ^ϟa^^kkss||ߖމ|oifƻcʰaΥ^ҙ[֎Yggvv~~ߠߒޅxmhfǸc˭`Ϣ]Ԗ[׋Wق[qqߜߎށtkgdȵb̪_џ\ՓZوW}TsXߘދ~qigŽdɲaͦ_ћ\֐YڄVySnQdPߕއzmifƺcˮ`Σ]Ҙ[׌XہUvSjPbP_W~ޑރvjheȷb̫`Р]ԕZ؉X~UsQgP`PZRXYsߚލrjgſeɴaͨ_ѝ\ՑYنVzToQeP^PYRSTOVjߖމ{nifżcʰaΥ^Қ[֎YۃVwSmPcP]QXRRTMUJ]c|}}zzwwߒކxlhfǸc˭`ϡ^ԖZ؋WUtRiPaP[QVSQTKVEXB_Wssppnnߜߏ݂tkgeȵb̪_О\ԓZ؈W|TqRfP_PZQUSNUIVDX>Z9\Nieeeߘދ~pigƽdɲaͦ^қ\ՐYلVySnPdP^PXRSTMUHWCY=Z8\4crG^ZߔއznifǺcˮ`ϣ]ӗ[׌XہUuSjPaP\QVRQULVFWAY;[6\0^~,eg;autoray-0.6.12/docs/_static/my-styles.css000066400000000000000000000026221462076570400203370ustar00rootroot00000000000000@import url('https://fonts.googleapis.com/css2?family=Atkinson+Hyperlegible:ital,wght@0,400;0,700;1,400;1,700&family=IBM+Plex+Mono:ital,wght@0,400;0,600;1,400;1,600&display=swap'); h1, h2, h3 { font-family: 'IBM Plex Mono', monospace; font-weight: bold; } h1 { font-size: 2.0rem; } h2 { font-size: 1.75rem; } h3 { font-size: 1.5rem; } .toctree-l2 { font-size: 0.85rem; } body { font-family: 'Atkinson Hyperlegible', sans-serif; } article { font-size: 0.9rem; } code, kbd, pre, samp { font-family: 'IBM Plex Mono', monospace; } /* code.literal { color: hsl(191, 85%, 50%); } */ div.cell div.cell_input { padding-left: 0em; padding-right: 0em; border: 1px rgba(127, 127, 127, 0.1) solid; background-color: rgba(127, 127, 127, 0.1); border-left-color: green; border-left-width: medium; } .cell_output .output.text_plain, .cell_output .output.traceback, .cell_output .output.stream { border: 1px solid rgba(127, 127, 127, 0.0); background: rgba(127, 127, 127, 0.0); margin-top: 0em; margin-bottom: 0em; margin-left: 0.5em; box-shadow: none; } .cell_output .output.stderr { border: 1px solid rgba(127, 127, 127, 0.0); background: rgba(127, 127, 127, 0.0); margin-top: 0em; margin-bottom: 0em; margin-left: 0.25em; box-shadow: none; border-left-color: #cc7766; border-left-width: medium; } .cell_output { padding-left: 1em; padding-right: 0em; margin-top: 0em; } autoray-0.6.12/docs/automatic_dispatch.md000066400000000000000000000252201462076570400204170ustar00rootroot00000000000000# Automatic dispatch The primary function of [`autoray`](autoray) is to enable writing high level array / tensor code that is agnostic to the backend arrays being supplied. It does this via ***'automatic dispatch'***, which has a few notable differences to other approaches: * It is automatic - generally neither you or the backend array library needs to implement any dispatch logic, instead [`autoray`](autoray) finds, if neccesary 'translates', and then caches the relevant functions when they are first called. * It is specialized for array functions and treats [`numpy`](numpy) as the reference interface for call signatures of 'equivalent' functions, although it doesn't rely or numpy or require it to be installed. * Despite this, there is no fixed API as such - if a backend can be inferred, and the relevant function imported, a [`do`](autoray.do) call is valid. ## Basics The main function of [`autoray`](autoray) is [`do`](autoray.do), which takes a function name followed by `*args` and `**kwargs`, and automatically looks up (and caches) the correct backend function. There are four main ways that the backend is inferred: ***1. Automatic backend:*** ```python do('sqrt', x) ``` Here the backend is inferred from ``x``. By default dispatch happens on the first argument, but various functions (such as ``'stack'`` and ``'einsum'``) know to dispatch on other arguments. ***2. Backend 'like' another array:*** ```python do('random.normal', size=(2, 3, 4), like=x) ``` Here the backend is inferred from another array and can thus be implicitly propagated, even when functions take no array arguments. Some creation routines such as ``"eye"`` and ``"zeros"`` will also set the default ``dtype`` and / or device to match ``like`` in this case. ***3. Explicit backend:*** ```python do('einsum', eq, x, y, like='customlib') ``` Here one simply supplies the desired function backend explicitly. ***4. Context manager*** ```python with backend_like('autoray.lazy'): xy = do('tensordot', x, y, 1) z = do('trace', xy) ``` Here you set a default backend for a whole block of code. This default overrides method 1. above but 2. and 3. still take precedence. The argument to [`backend_like`](autoray.backend_like) can be a backend string or an example array. ````{hint} In all the above cases `do(fn_name, *args, like=like, **kwargs)` could be replaced with: ```python from autoray import numpy as np np.fn_name(*args, like=like, **kwargs) ``` ```` ### Manual dispatch functions You can manually break the process into two steps with the following functions: * [`autoray.infer_backend`](autoray.infer_backend) - return the backend name for a single array. * [`autoray.infer_backend_multi`](autoray.infer_backend_multi) - return the backend name based on multiple arrays. * [`autoray.get_lib_fn`](autoray.get_lib_fn) - return the actual function for a given backend and function name. If you know you are going to use a function repeatedly, you can thus avoid the (albeit minor) overhead of dispatching each call separately, for instance: ```python def matmul_chain(*arrays): # if the arrays might be a mix of backends, use infer_backend_multi, # but here we just dispatch on the first array backend = infer_backend(arrays[0]) fn = get_lib_fn(backend, 'matmul') return functools.reduce(fn, arrays) ``` ### Other special functions There are a few high level functions that might be preferred to attribute access, for reasons of consitency: * [`autoray.shape`](autoray.shape) - return the shape of an array. In most cases `x.shape` is fine, but this ensures the output is `tuple[int]` and also works for builtins without calling `numpy`. * [`autoray.ndim`](autoray.ndim) - return the number of dimensions of an array. * [`autoray.size`](autoray.size) - return the total number of elements in an array * [`autoray.dag`](autoray.dag) - return the adjoint of an array, i.e. the transpose with complex conjugation. Functions for dealing with dtypes: * [`autoray.get_dtype_name`](autoray.get_dtype_name) - return the name of the dtype of an array as a string * [`autoray.to_backend_dtype`](autoray.to_backend_dtype) - turn a string specified dtype into the equivalent dtype for a given backend * [`autoray.astype`](autoray.astype) - cast an array to a given dtype, specified as a string. And for converting any array to a numpy array: * [`autoray.to_numpy`](autoray.to_numpy) ```{hint} All of these can be called via [`do`](autoray.do) as well, e.g. `do('shape', x)`. ``` ## Backends In [`autoray`](autoray) a backend internally is simply specified by a string. By default, the `backend` of an array is name of the library that the class is defined in, and the relevant functions are assumed to be in the namespace of `backend`. If that is the case (e.g. `cupy`), then that library is already compatible with `autoray`. Note all backend lookups are cached on `obj.__class__` for speed. `autoray` also handles common cases where the functions are in a different library or sub-module (such as `jax -> jax.numpy`). This requires a simple mapping to be specified, which `autoray` does for various libraries. You can explicitly register a backend name (and thus default location) for a specific class with the function [`register_backend`](autoray.register_backend): ```python register_backend(mylib.myobjs.MyClass, 'mylib.myfuncs') ``` Now when `autoray` encounters an instance of `MyClass` it will look for functions in `mylib.myfuncs` instead of `mylib`. You could also use an arbitrary name for the backend, and then alias it to the correct location separately. ````{note} `autoray` is aware of the `scipy` namespace and relevant submodules for `numpy`, `cupy`, `jax`, for example: ```python do('scipy.linalg.exp', x) ``` ```` ## Functions Once a `backend` is inferred and the location of the relevant functions is known, `autoray` tries to import and cache the relevant function from that namespace. Many libraries (e.g. `cupy`, `dask`, `jax`, `autograd`, `sparse`, ...) actively mirror the `numpy` API, so there is little else to be done. Some other libraries (e.g. `tensorflow`, `pytorch`, ...) diverge from the `numpy` API more, and yet have largely equivalent functions, simply defined in slight different places with different names and / or signatures. `autoray` has a simple translation mechanism for: * when functions are in a different module (e.g. `'trace' -> tensorflow.linalg.trace`) * when functions have a different name (e.g. `'sum' -> tensorflow.reduce_sum`) * when functions have a different signature (e.g. `tensordot(a, b, axes) -> torch.tensordot(a, b, dims)`) If you want to directly provide a missing or *alternative* implementation of some function for a particular backend you can swap one in with [`register_function`](autoray.register_function): ```python def my_custom_torch_svd(x): import torch print('Hello SVD!') u, s, v = torch.svd(x) return u, s, v.T ar.register_function('torch', 'linalg.svd', my_custom_torch_svd) x = ar.do('random.uniform', size=(3, 4), like='torch') ar.do('linalg.svd', x) # Hello SVD! # (tensor([[-0.5832, 0.6188, -0.5262], # [-0.5787, -0.7711, -0.2655], # [-0.5701, 0.1497, 0.8078]]), # tensor([2.0336, 0.8518, 0.4572]), # tensor([[-0.4568, -0.3166, -0.6835, -0.4732], # [-0.5477, 0.2825, -0.2756, 0.7377], # [ 0.2468, -0.8423, -0.0993, 0.4687]])) ``` If you want to make use of the existing function you can supply ``wrap=True`` in which case the custom function supplied should act like a decorator: ```python def my_custom_sum_wrapper(old_fn): def new_fn(*args, **kwargs): print('Hello sum!') return old_fn(*args **kwargs) return new_fn ar.register_function('torch', 'sum', my_custom_sum_wrapper, wrap=True) ar.do('sum', x) # Hello sum! # tensor(5.4099) ``` Though be careful, if you call [`register_function`](autoray.register_function) again it will now wrap the *new* function! Note you can combine [`register_backend`](autoray.register_backend) and [`register_function`](autoray.register_function) to dynamically define array types and functions from anywhere. See also [`register_dispatch`](autoray.register_dispatch) for controlling which arguments are used to infer the backend for any function. ### Composing new functions Sometimes you want to define a function that is composed of many array functions, but you want to dispatch at the level of the whole block, not each individual call, or indeed use a completely different implementation. For instance, you might want to use a [`numba`](https://numba.pydata.org/) or [`pythran`](https://pythran.readthedocs.io/en/latest/) compiled version for `numpy`. The [`autoray.compose`](autoray.compose) function allows you to do this. You decorate a function, that forms the default implementation, then you can register alternative implementations for specific backends. For instance: ```python from autoray import compose from numba import njit @compose def my_func(x): # get how many elements are needed to sum to 20 return ar.do('sum', ar.do('cumsum', x, 0) < 20) # register a numba implementation @my_func.register('numpy') @njit def my_func_numba(x): s = 0.0 i = 0 while s < 20: s += x[i] i += 1 return i - 1 # any calls like this now dispatch to my_func_numba do('my_func', x_numpy) ``` ### Deviations from `numpy` As stated above, `autoray` does not have an explicit API, but where there exist equivalent functions, `autoray` uses the call signature of `numpy` as a reference. The following are deviations from this: * `do('linalg.svd', x)` - `autoray` defaults to `full_matrices=False`, since this is generally always desired, and many libraries do not even support `full_matrices=True`. ------------------------------------------------------------------------------- ## Comparison to alternatives * The ``__array_function__`` protocol has been [suggested](https://www.numpy.org/neps/nep-0018-array-function-protocol.html) and now implemented in ``numpy``. This will hopefully eventually be a nice solution for array dispatch. However, it requires the backend library to implement the protocol, which has not been done for common libraries yet. * The [uarray](https://github.com/Quansight-Labs/uarray) project appears to have similar goals but is still being developed. * [`functools.singledispatch`](https://docs.python.org/3/library/functools.html#functools.singledispatch) is a general *single* dispatch mechanism, but it is slower and requires the user to explicitly register each function they want to dispatch on. * [`plum`](https://github.com/beartype/plum) is a general *multiple* dispatch mechanism, but again it would require registering every function for every backend explicitly. autoray-0.6.12/docs/compilation.ipynb000066400000000000000000000070211462076570400176100ustar00rootroot00000000000000{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Compilation\n", "\n", "Various libraries provide tools for tracing numeric functions and turning the resulting computation into a more efficient, compiled function. Notably:\n", "\n", "* [``jax.jit``](https://github.com/google/jax)\n", "* [``tensorflow.function``](https://www.tensorflow.org/api_docs/python/tf/function)\n", "* [``torch.jit.trace``](https://pytorch.org/docs/stable/jit.html)\n", "\n", " ``autoray`` is obviously very well suited to these since it just dispatches functions to whichever library is doing the tracing - functions written using autoray should be immediately compatible with all of them.\n", "\n", "**The `autojit` wrapper**\n", "\n", "Moreover, ``autoray`` also provides a *unified interface* for compiling functions so that the compilation backend can be easily switched or automatically identified:\n", "\n", "```python\n", "from autoray import autojit\n", "\n", "mgs = autojit(modified_gram_schmidt)\n", "```\n", "\n", "Currently ``autojit`` supports functions with the signature ``fn(*args, **kwargs) -> array`` where both ``args`` and ``kwargs`` can be any nested combination of ``tuple``, ``list`` and ``dict`` objects containings arrays.\n", "We can compare different compiled versions of this simply by changing the ``backend`` option:\n", "\n", "```python\n", "x = do(\"random.normal\", size=(50, 50), like='numpy')\n", "\n", "# first the uncompiled version\n", "%%timeit\n", "modified_gram_schmidt(x)\n", "# 23.5 ms ± 241 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "\n", "# 'python' mode unravels computation into source then uses compile+exec\n", "%%timeit\n", "mgs(x) # backend='python'\n", "# 17.8 ms ± 191 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", "\n", "%%timeit\n", "mgs(x, backend='torch')\n", "# 11.9 ms ± 80.5 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", "\n", "%%timeit\n", "mgs(x, backend='tensorflow')\n", "# 1.87 ms ± 441 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", "\n", "# need to config jax to run on same footing\n", "from jax.config import config\n", "config.update(\"jax_enable_x64\", True)\n", "config.update('jax_platform_name', 'cpu')\n", "\n", "%%timeit\n", "mgs(x, backend='jax')\n", "# 226 µs ± 14.8 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", "\n", "%%timeit\n", "do('linalg.qr', x, like='numpy')[0] # appriximately the 'C' version\n", "# 156 µs ± 32.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n", "```\n", "\n", "Here you see *(with this very for-loop heavy function)*, that there are significant gains to be made for all the compilations options. Whilst ``jax`` for example achieves fantastic performance, it should be noted the compilation step takes a lot of time and scales badly (super-linearly) with the number of computational nodes." ] } ], "metadata": { "kernelspec": { "display_name": "numpy", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.9" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 } autoray-0.6.12/docs/conf.py000066400000000000000000000066771462076570400155460ustar00rootroot00000000000000# Configuration file for the Sphinx documentation builder. # # For the full list of built-in configuration values, see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html import os import sys sys.path.append(os.path.abspath("./_pygments")) # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information project = 'autoray' copyright = '2019-2023, Johnnie Gray' author = 'Johnnie Gray' try: from autoray import __version__ release = __version__ except ImportError: try: from importlib.metadata import version as _version release = _version('autoray') except ImportError: release = '0.0.0+unknown' # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ 'myst_nb', 'sphinx.ext.intersphinx', 'sphinx.ext.extlinks', 'sphinx.ext.napoleon', 'sphinx.ext.linkcode', 'sphinx_copybutton', 'autoapi.extension', ] nb_execution_mode = "off" myst_heading_anchors = 4 myst_enable_extensions = [ "amsmath", "colon_fence", "deflist", "dollarmath", "html_image", ] # sphinx-autoapi autoapi_dirs = ['../autoray'] templates_path = ['_templates'] exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', '**.ipynb_checkpoints'] # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output html_theme = 'furo' html_theme_options = { "sidebar_hide_name": True, # "light_css_variables": { # "color-brand-primary": "hsl(72, 75%, 40%)", # "color-brand-content": "hsl(238, 50%, 60%)", # }, # "dark_css_variables": { # "color-brand-primary": "hsl(72, 75%, 60%)", # "color-brand-content": "hsl(238, 75%, 70%)", # }, "light_logo": "autoray-header.png", "dark_logo": "autoray-header.png", } html_css_files = ["my-styles.css"] html_static_path = ['_static'] html_favicon = "_static/autoray.ico" pygments_style = '_pygments_light.MarianaLight' pygments_dark_style = "_pygments_dark.MarianaDark" def linkcode_resolve(domain, info): """ Determine the URL corresponding to Python object """ import autoray import inspect if domain != "py": return None modname = info["module"] fullname = info["fullname"] submod = sys.modules.get(modname) if submod is None: return None obj = submod for part in fullname.split("."): try: obj = getattr(obj, part) except AttributeError: return None try: fn = inspect.getsourcefile(inspect.unwrap(obj)) except TypeError: fn = None if not fn: return None try: source, lineno = inspect.getsourcelines(obj) except OSError: lineno = None if lineno: linespec = f"#L{lineno}-L{lineno + len(source) - 1}" else: linespec = "" fn = os.path.relpath(fn, start=os.path.dirname(autoray.__file__)) if "+" in autoray.__version__: return ( f"https://github.com/jcmgray/autoray/blob/" f"HEAD/autoray/{fn}{linespec}" ) else: return ( f"https://github.com/jcmgray/autoray/blob/" f"v{autoray.__version__}/autoray/{fn}{linespec}" ) autoray-0.6.12/docs/development.md000066400000000000000000000020631462076570400170740ustar00rootroot00000000000000# Development ## Contributing ## Testing ## Building the documentation ## Minting a release `autoray` uses [`setuptools_scm`](https://pypi.org/project/setuptools-scm/) to manage versions and [github actions](https://github.com/jcmgray/autoray/actions) to automatically publish to [PyPI](https://pypi.org/project/autoray/). To mint a new release: 1. Make sure all the [tests are passing on CI](https://github.com/jcmgray/autoray/actions/workflows/tests.yml) 2. Tag the version like `vX.X.X` (e.g. `v1.2.3`) 3. Push the tag to github, which will trigger building and uploading a package to the [PyPI **test** server](https://test.pypi.org/project/autoray/). 4. If all goes well, create a release on github and publish to trigger building and uploading a package to the [PyPI **production** server](https://pypi.org/project/autoray/). 5. The [`conda-forge/autoray-feedstock`](https://github.com/conda-forge/autoray-feedstock) repo should automatically pick up the new PyPI release and build a new [conda package](https://anaconda.org/conda-forge/autoray). autoray-0.6.12/docs/images/000077500000000000000000000000001462076570400154745ustar00rootroot00000000000000autoray-0.6.12/docs/images/autoray-readme-pic-0.png000066400000000000000000001611551462076570400220400ustar00rootroot00000000000000PNG  IHDR]k~#B9tEXtSoftwareMatplotlib version3.5.3, https://matplotlib.org/+ pHYsnu>IDATxixy^6Hظ(RAŒ[8d&L&q;$mܛs$,3"'qD$ƎWYŲK7H hBXjtWC]]u^TW΢1!B!B!!B!B!DHU!B!B!B$IW!B!B!$]B!B!"DtB!B!BIU!B!B!B$IW!B!B!$]B!B!"DtB!B!BIU!B!B!B$IW!B!B!$]B!B!"DtB!B!BIU!B!B!B$IW!B!B!$]B!B!"DtB!B!BIU!B!B!B$IW!B!B!$]B!B!"DfY֦E[X;7(au?r !B!B!e&]àVaն?Ϻ[kW!B!Bat?"O/0p{.ׁʯq%B!B!B p&|?p:5罙淪t(%NZB!B!!Z-];9¦ۀj%ScM74fFn lK^1 nAc/1J|%{qķLw2Cw{펛 0?wBR]my<8|s }45t]뺯h|7pzg/g]jȀ`r,:fLƯw,*vAc/1J|%{qķ;\jrȘCtEueDR]UT=RB!B! 텸G+anIع\'Iũ~_ݻ:_~eB!B"> yۛ`3 % :YV'IlV|븵D8B!B,Z`6p{z_B JA+>d:"P]s]J)UBQ4bH)5ҶmG6}\}5tu]kB\υh+pϞ=}اq`T*H=F/}qQ⋾ 1J|5 Jގ lat&S׍1y/%ĎTWʟ86ƽK /D-Acu|nݶCg;KRtRd_|iw;{sm]ɉB!BzM0?(=וRt&RoyfS!T,t^@)Up3c3{&MɆ?Hĸ{gV?~|ѣM)XT?%fO}qQ⋾(E_c{|%|Od.rpsU# \a9aT(9/}-}+v]dF[^D|?d0Ɯt}j~`n( a$]c .GTNV}qQ⋾(E_c{|%L8)Nc0;oE O`nﹽ5rY+ه 1=yP9C&0o;dnf9Wb> / B!B,B+al5M4,f;6`8 !D:1OŪW&<0JwvZ$]B!B aC%la1@ ؈M !Ddc:0Wzϝ) $]#Fk_]ه{-Q9@A @qQ⋾(E_c/1=>-߹Υs.{]߽+Ҫs.䶔rTW't׻L1kJf[: J[`i-H⋾o|OvEI8twc.g)xYI;R)S\"*t+B!B!bw3mٳ7<<6݇ Ɵ~?srX}#O󦼭A1Wʩ^ζĘ1-(=/L_^BӣYpLWRI:~3I=^B(i1Yk8pG3{T?%FO=F/}qQ⋾ 16%Stۍ1}1@1w| ˿o 뽬 xujd?g{/_ߋێn{{ gӍ_𧖳}ck|.z?q'f~џ|F-Acm|} ҔrLqo `9o&^|u7Lkxd2Sy*vAc/1J|%{qc3Jo Ws{~處nO?7ՙJŠŰ`^.\*wLUpaVc3ql@&y`EA!h{|wk@%2 Y( \r Aۻ\^^.ל} I !B!XZwIkIKIn~?H'֙QdJ?V2IU!B!DC܊qlJqܛf[I\AzUc ~ 6Z¶r lHc[kyqc31a0)ky4`X!B!lx; x#8 < (=\+ᤝy3ryNao&}ٰf+oo8NHJo~^ۚ\!:03؇L4\-OB!B!FبIGI9269Z7c$e^S¶Ž#+uGe'ha 8k|O! ppߒtB!BY[7S>M֦X~ka ':D-C1`4@ ;Tia3u)RֱYK؞[B!B!0v>8l+CZ]˭bTbb] @uVۈmخǃ&=:*FYǷ$]B!BܒqےQQҵ& P+G5.Jbۊws4ء֕_Ih!ZR\^iZlvDx鴓f6N' wOK{_=F/}q1Ac =k Ƙ! k͌1*Gu!;Z{s&cӥRJ(GUF(ǵ^qd٧BXmd>= PM`0(cTz5ّov^$RR1UTPH5bՕ}gϞ>j#)*Yi(E_c/1J|?lܦMy䋉Dw0x^sTgtsmiӒ;'=-⎠6m][gzk!1r5G3×V|FgemQSĥtq{#(pvE&e{|cos3bw#TΥGR-Nw.q|> mE^@!B!Dh&M$gfߏw΅G)e3~#==$L9IgL5qUR8)g,(1α;kvVscRmᤝ1PQ{S֧>Ժ"X SvcLR9uZ?kĸ{gVǏ=ZXI(1yZ4Gc/1J|%{qc}m:P)M`zP{]1R:[,}mkm'?Sy-72As[•rγn;uߩݶUF3ɷ~s~cLC3J)1'1(J{ޡ>>筑o?XG,\*Lc'L.f=p|J5F< 2L 8(U(E_c/1J|?ư󦼃@ _f`=g\N.Vz#;Q)U) i+.b09ww߹5F3:~f\< 4{n5+Ack|vIh=y]nsa(dx!B!Jwag!vKX069W~_+mpsj@ }Yzs!Du`'AL(UekB!B&G /9Z^g0wV!nQưZXDJ ,03gubbIWXǷ$]B!B%cXIJ!lu].^Hoǖ40r/WrNB{Z蠜t]AKWXǷ$]B!BVz-Wb[Iځu~+׊Q ;nl[iB>?bk- -DtPʡ[B!B!0mPKƕN2튟~Q+`o}\Ďw8Jw6<&/ɛ@Z2 [<%*B!bE-xKƕ&涒ڃm:MFep[ `[hnq0u[''I!❄"* /1]a ߒtB!BR; A`[2DT7o%5\~'ᷲm m!_Z4h)a? > !S^Լs`TY3vHN6M,d8>pl3(qQ⋾(E_c/1=>+I97txVpw>1"&#]?TmP@qzQr/WfL`P ).~?,O~FSݩřb(ƔRz^ƘQ PltΑl6uZ8=>O%T Lt]ys5sVQC!I׈Z?;WW={h:U?*H=F/}qQ⋾ 1(OOuvT)Τ JphgMlMg#Q鶞oر-lMɎUVJumWcL#ʶ|פg7u_=F/}q1Ac\I|Z$Z@åU?a1&]{_ P"ƴj~cL[BP&y7gT+CF a.0a߾oZ"0 [cc|_܆*e0!G:;=BWd> $]ZkU6u]=܌a x뺟oPQB! Bo m _>Ʊ ҟsqf|(ap'XBe $ 'B^K1]h_cyO[tIk!u+ΐ)B!VnxޔPgp̣'V[m378+6?eyJzfı i4&(")[ʴؿy+7^vP~} !Y!B!itd\Q`/]m7( XMZ~7ٮ?ܶ{bОH%>>lZ;s\N z=y9gІ}_}߱eG<؞ 7VYC3!o餥_n]jau*-~u\4~CkeB!BfdDZ7ɀU~Lyl"bV{ҽZM~:7;]vL-2x#۵KgЍMO(6n}\by:mوWopttۀ.s*Kef?|t],~i%B!BJ'%*6ɕLUF$o:ZN;`[.=f_X]uCNl:VoJ/{v&^WƘ¥w\ Bt`$]'}tRHVXj,c*xu݇[?~*B!]ؤJ[2v&lF ׍ZV-/1*GMC;'&]z,p 6 Nl}+elv&j. 1SyJZ z:M6_yTy+k~LW[Zoۉ, kK,5[R!B!ZJuKF pJḃancRFq*ў,͔Lvh򸬇09{W_r vFd}]Q`{P z/ 'MW/Ј(\VyP4k:骵^Qp].1OזȻ}yA޺"Co鴓f?f[d;lei(E_c/1J|?ƺ}M9j1f"Jէ*SN떳1fuQiPaYg3a9RSRT";PC87YGљ喡m}.ﲗ1 aUi14k(.xY6v_RIeK@>9cL6(~޿pMw c?c7Z1cJN44<3bH)5`^xr& C> ŚNMZ>H gUV%=jujE={QxQ`gDXMqQ⋾(E_clX|\zw|mܻ݃ 1=>uŗhKرz[URM:S]-(Tۺ+ccVL`fN%'ۓmA1)KM`s!іxI:9DfJJlraK;}6喡{stq؛HKs[|/NҹlOM`Tw(VIJmU4r1.ڬY{d2k*R9Y.>_=F/cJw`'Bߜ/}y-xKaVq?z|e t#pW ict[W cSgf2/׻t v6 #5dT0?N9_ʕ7(Le2C[ys J]/9F˓~{L' iytAcw|هXs hw; ~ʷԐ-5B!jKgN쬱B1/ž'qe籽:Z끝avI9Q1C>tےo'jNUޅvbu|Ŗm Щ7,si]NV>ݺyR,!B6`E^tk¢BU[^lgR-B)U4L``V6Z\&qθWlnBo*f%s!5Z}`4=_^IJZS5,߉빪]կ?_B!J+ \!&Obu+hazE,a8m6LIת}kKfNcE0k[n |knx -Z pQB!atw;QbZ$G ERݓ3U5mV骻\$uC5s~ѥWJ)\)C&iI-VK%dC^s-]]I'[Fk[[\׽w:.瀽Zou]y̶tuݨ .B*b:c2/r]^j^)-h7&|"=IP;m4x co7tˤ(mkrVbubs^bۚ8vWqۡ~DkQb?)X*//Bl[c2qN! c'F\QJ+ R+`5u[32;r2r-[z-]{8Ƿ$]ux@kZ? s{->ݨU{_=F/ch͌emQTWRtצ2[2_]1Ac\4/淖rTWjI:ݫ[QJumWwƘ͵PL䶶umo)/:R{{O8]Τ=T~T"ؑJSgrcEzhlM֕t'8NjGM`u|WV(Iy[oձ5/ \pXl^k<E3ْ LtMyIw^I5F< 2r<Jd 1J|%{a7>fM,3l8l.{2^ 1=> W v5a4]+61qL¢13 {nk+ !t/;q4l+yx&0&0o=7R.bVVϣQT>csdϣ~|ه=+B!Z0;b=c.bLjJwBلi;;7ZQ& 5@\Yݢ&ua-='b[B!1`/\"W_&,+alku,o&]+,hc6n7Mm*[4I%ayIW-IW!B;pHm ,Ei+--%Ǜ["BɓA`Vms d9[)l"rrLvە8yl';M։m o WߑPKB!;rd%BvONd(6WٖdQ6LoLV5wd *Nl6hv9B0pf,K=F/}-{ZML7ÜpK'/%m_WW|N9z:P1fCbH9]/vӖ ?+qCQ1CQ9l7RRr;FE1z&0P )L`PuU 5AR]lZߠ{~D uU瘈Z3Q"r?HRJ5<0ts~ueٳ׎X4q551J|%kzN&/pŋ7k~ CZ=zwۙt3Ǻ{ۇ37&՝Rn8]2ٖΤ'fg( cx%{{{SP"8lO}h5J)ն274B=1r)_.і ~W+5$ϵli-Օ<|jQ ۛ.p/znw"c?J]5s-l|v)Jt&ݦhyt92T0W(B!+w{&͛vO?-am ѯP.& xף?ڻ}'(3Vg#+3fo_JP)>DTgpRUBM9I'2I:R/厅]{DK{~_RawzߢRЎ)/>PJkĸ{gVǏ=1 E{_=F/v `1NE1?rϯ3FWyrNp_ʗxColؽǧ􃧷ߴc8]\M1f 63'3+|F/Act_>=2M=dꮰܔ bҵ1_Ƕ:B˷Rg9EL)|vFѹˬV}@qX4,9g(ZѲHw%"D~ Z>|v L p2NJWXdPc|#6Rt(gBB!5J ; pJ( <\z@܊nڴQE_9 l׀6F2 c 6bjM1?u>6 bgnxyB44^6kzMyl* <'sėOCoDZih~M.\tkܖGtB!XV]+vM瀯co(_^ Jw~u9$`o>Y..ແGe0 !b}h Lnwk(6ɘ%MN*C.X?Sg|H-P%snrY$-]B!Pmb,OJτN9Jy!*ZJ 5WSϣˬz"і Ae+c16q#lV[C!I׈Z?;WW={ lj}XРQ%{_cfK6 ޔ7hOlKv׻gKtwzc[/sKwvX)Vh[VcLSgh~4SڞLm8mi^:yڎ^ֻF9jo|-ݝ7x~E*e{|N9;T.n7$;;s^LؔRΣW3t&]PJt5WSϣˬzbލ.8]LRi'tCc1~qhTBHuJ>s?wz! B!D)gzdz_QD*18i =&jz?&>'L(ZI:Y娼_ ;}XW˴?y~P :M`:3検&0A)L Q};RD:17LB4$wm|N JA1yg5L󑖮Ꟶ[SǏ?zh~00JD-!1J|% 5;ncOqczy/i2Ɯt}j~`n9"$W ?OU^MLKƘSfJ/އV|F?}i…AcLô{ M1ԜF&e{|_ Go0Ƥmɗ 3r SuW8q .͔ ZBմ zĢBE Jهqx1Ɯ0+O?xz+2􆩒tL&qP*'Q⋾(E_1z@WvL`2ޔw(^s?0R [12̃R 1jہY=TsLgBՂ=UowE\BrzĥJAv"-T9ns pà)wd+C! !Bi;7MpaYwiB{cԪr%l\Z&g cgMvƛ^,.]-{7ֳxB&&sb$’;ڤOg( /y9knqfIU!I"(29ƶ&Z^onqW 6{S}16MBgYHQR/KT[=ڰ|Ld “Nl6hv9B0pf-UqQ⋾(EߊcL7f=ccF1PR uC6=7v娽Ƙ! E*?+^,ǵ^qd٧\EKF=SN!Ji^Ƙqx5Ց:fc AヘxϯޓP uf)UgV*Aclf|˭ьB뵪ѐzDHu" ,!Ե{ꉟTja($1Zg>ܳgOnvU{_=F/V䫓7g;|O3R;"1e='JHuOl`xNرzTR:S]SJumU1am%18URŧxz<|Ug{S3c3Cdgl"Xtqg3(p1qb}^ֻF9*JuBgV*Aclf|˭ьB뵪ѐzD&{Y/HٿY1\_3鳝ֹ><Vdx!Bi5iAp&-!B2Nҙ~ L}h7ŗ.zcL*NDe+R8Ig,^c~(#SDiQ }qQ⋾/F$P,JSo1f_xuG˯]^g`=tn.\ܔ ZeA9\!qm;uj}{~Fo~&5}61a+{^nCҲ0DS񩎋/^(o|?S9D<qc[N]fŷ^v ~F8y/(Rӕך} h/?z𣉟}gJ5F< 2r<Jd 1J|%[IZ.Ã@w `ǥތ[KӢy`àȝ}k3?! ) #u|6F&0KҡSom-cZy%1{~fN{yfE?&ǷMowV<V}{_s[{PO^y ܿ[D1#7Ƥffe2Sq> ŚLj{nn`/>:3?|5Îau?߀B؋]q9l+o[њx>#ؙcܴtqUM}g埍͗al(E7B4f l&:u` z { *ji`kuLכO z~6Ǵ߹JJk!?CZ떛M!@s}埇U~a؋D˳Ri#^#zp0b[UbBKh^'%kbPۣij8"/7? ܉Q}?j/p#؄o7B!X9I,c)a/ױV3"ww=o~G{?-_vI6tj饯Gao_Ʀ+7:;E $Byi.T+VIBk{҃ҵ3Pt^,j{lUW h~??Gk ~Ckqu_1!BLuU5ؖ㫼F0.l7|xSݩ/Lvs7Y5oJx5R7co A ?wɵXuì, !.J߁{Z?] aK=~?6?VKq m(l5ItCZ\׭5uu`uE~٤,~i9eB!DZ 1݂щx]hrD@q{cXJoްv/>{h)2\.:V6(>`b%HB!,7sr?1i!nB>PzV_i74v8t5}85lM&]Pf^*xu݇{s/~U!h;hnyUv#-ynJ;1{iHP 6cWm xʿ~B+e7VL3_{ޓKCBH}&Eo*'76 g$tU _ ;hS+¦*1! 6Z^`IZ}s`XװV ޫP!+PxIe)(vv^q؍ Klàk7+]c̹IQm&ڻZoƽP~^X}M+Hy~[\K9 qpBKop;) vޜxv]/V; 6<- ]n´MMpA+[YY5t&S;^k)Yt_KQ>$*B4U-!UfFߎ?w{΢8lOõ̎'6foR7)c~Z (mVqd|Gem~0>!SZސB[}7Ķ"76 }%]c{_Fʶ ؄Z{gjvtwډ]'/mUߟ^bx_M[XdM:vlK̬"a0l6̲4Jc_'71ƸøuƘN/B12ؖ-I9J)TfƘQ ;R(~Cl$`'Ѕ<6 ,W"y.u&0(^XL=?FouSWnZ>T ufCb0Ɯvb lERj=o k(6ݝ* L Ei߯U>0Ɯǰ Šrԑ>}ێ.އXIE< 뺏Z%3]}2qjE={8>{_ĝT?RԵ{ws.ScܦL'ٙ|-J,~^5J)նX]ƘORLyY=ٞF%L)_n|ӣr=yI:JR6(ҙh;lDtq_L:/<~ߩP۝s:і8e-Tb$ّ Ƙ]Lz$Օx GoƿqK?N/|ܹgugۍoL;s<#AcVG=w3˦dӽ6E(J{:6vyYoJl35حgRp/]c|sD%T6ٖ<餜;Ce[n޴u왱Lr#ٞL%ڮ>nh)o&ݝξtK7l;"WR+k&i?`n~{x!Z<艹a$g ,Օz|6D:1fIEŗ..{L`ڂR$ Լ7>Q~#y*ݝ~B%Մ_wxY[0$3ϕH%U7dOesq鵷<^cN[a/! '(W{nlP 2&0NjḜ3NKv&Š3Ń|iӅ8dMKR m(B%R1㛶^gs|KWu'ɪ_=|Zkn]Z{G2MKl FԐC9~ѣG6#iQ"Ъ`q?5Օj JA+?o ~&5/c骻p&rS&Fc3؉DQϻ\u|63eoG{X_CdiT~hĎv96rJ% _P1xNMdm;5DwVsNo5iDqHT3{|%Sk==S&OvN4oƐ=l ϦC TWou8z#x&0RW[3Zc 9/םoWmu S|u!e.u+'V1K5[;um֬yA&Y!qP*'Q6r`+1qFݟdz%c)W:!a$*]*41Q>~b+` ۍ1Υf2{٨V؅$byR?N9_ʗv/e2LZ1]/N1ownu{%]K҃c`aftD35{|%USs=ǢRVq5f;zbvw?GY`&eCLK/T&7X }FcoN<'wCzvPΪW'B} !DRdcƘؙB~ze&V>7 u'\@cZT$R=e c۽H"XbYDjF칼$vA`Vk;f%4 tb;V^aIW/6p=۴acfl.חl-B+1(Pa+-Z%.D+:$!YpU}27mJI:=.jJRi4{{` 'CW W!DIJRƵ*Vz;\uCp>X{:MfLײIOB-]hhR;jR}bkܶ:n-8NbU\BeI83a#vhi*"* 1$!`XV!ܤ4TyZlyVL#Ķ7\qS įŒuŲƵw FHme異q$t(ZaxVF󇪾뺆١jͻJK׻B:1d3H'*.CB4ӕhu|CAttj'\ƶ+_&a{S7Į -x!b-7dUVPej6S2@\G/ VH:OjۗX旁*x"l?Zwy'K"m؇FC@I93';WB!Vh.kb~|5w/ߤb7) (窶hC}3\Ž (,SډwuСCqb^? R^~uݫAp] x@k_pCy H!µҊJ)R_1a?I0v!Z$!"k2s/MJ#0g il+Q`swY;Fm YqGX{^ Ϯp]05n&? #ؿGwr7&[?|x}_&\OB;?+iGrمц Z}[D~lbIBD$]kҚnͬ6DZ9 Wb9ׇ 1e!DMٖ ió!= WYil0X`JDylryՆ[-]۰Aӊ< ?ߺή{-f܄`&_??5.i'&Vk{aဓfYF{_q=Q;1CrQSJn'0 p2ՙڟf2PqI:AІbT)񈕣TʉVkX|Ƙ^N'e[;j Vsc4ƌbإvRΑl6fq=ֵ]er23;C&bP)'ksE`-g"1J|Ѳ@hs-QHus6Q{Q.~NT7d.ѝW&0)탘|FK&0P )εk6͞zzbM&]]}; BZυh6/Ӈ!N)ql%9w1zTgm][gWʖfJSM}G,ۇs=>X$ƧxPqOuL!BT(T1hĜlq+ّھ-n6TRjV?^:і؞Τߜ{#uL[GdGX",K}ߑN}Yis;ّ\3q%hY~yL`W\Oto~Kn"8SIu^sRΊY1/9TbG+B`wl;eI9Sq-J{龮M]bǘamo-/ bb.CI;K:I'U~RaDZk#=758:IgOy8I'5Lqӣ?;r/LJA1-J 娒t.Š?(m.S~t[B(9)gr2tbMڟNBZs~p/QyTtPJNҙJAMus)L: &8)ܞOopykk{gVǏ=c,GQZUA!=M\Ӄa,(Gr)cy ÖL)şP3˽Bڇ{|@;هn3DqXhNoc RcNbUʕmWn~O̥W.c2.Ւ GOb8|O>yN3C1WЃT{i3{~OqoxO&jls|w=_8{_SP'nDWY^Q=_.L`2(^ Te>R*|կvk;.rqm3j9 ޴;f~K7L]뻴7-o?,y^df#LqP*'Q⋖3W*JS+d27+}8Wヅc܂}ĐhOXY".~/Wϼ;ql"8io8[l{nOƍ0QgC:%ad31#1(ɼBשϥ XX{_\U=ێnrJ=y a[FCcL9 ;]^yZʕڨ BێgtD@Oqx(< C y~;{) ^BJ' Xp;Vz%n@;wz%vA`U3oR`oؒDk?At_s>`; Ƀ ΢uBZwT^8u) p (vJQF^7J4jCNB4u wg wŶ9آ Qr QlµL@ ѸFڱ_4coubobS0 @BZ޴w{>'* zi\zXeֽEֆŒСidBzO*V@K96ZiQIBKeVZAVn [3rj5A`g#[Zr+n"GwQ(Bߕfı$@~2/wYc5B[A^Sq&]$-kؘ~QB.tp=5:Zj >U'!^nrYʃ `V9IjkQ`+"6[TTĎ%W$vsrJ["!ʕsyືێ ^zvaWjQF0 h1: ]igQZ% !8h+NlE-DKJB QCF-1a7yHҢ 6lzZ_Vwk[!V˕{v`Wǩ]aL7o[SPUOJK׵ʵb;CJU! ~[9a[5lBԫ^LI".yffV&[Z `4t1+j5B<Ѝ[!V CK=w#1E+E[b7"4k1ZIBӡ_s4lxc YuZo~07 !ҽ5~qW<r0I0^FʷջIiJwJKs-ΊƶĎWOW<&v[ GCB4a1欗cY]:߿o(0}0څ}ypMVupy:07а+psJko\],KHN6M4!smd~[EcZ\=q$ LJ)G^3a fϬVC}U1~OnT 4鹟Yz3ƜǰERjfWQyt nQ|=Br~C@=n6'ܐf5H=Z\T]9D_csiJfJ ` RoCg7j's$^-10Q )woo̔2Ƥ13Z8{B[I׊ki/u*l/ִՕ}gϞ>uq`U{_܅/}e1Fx!ՑZlٗ;'tӦ3oo+g1W/m/KJeRm][ggcUc)N}TߍN>w%Tg뼬)NJ'xo[zT+uR8Is-1S&0פ3ɳ}~u|y̖̥Xryp'_׿y1x7KۃR@***?&09oK%҉tiݛ}r݇n*͔R7r(E_qXP %ٞL'Tgߵm=m7+7WE뭧>Ժv?՝2֗U)fo;;/ޔץKu-C\?zN"؞NN^z5s0s:FlSZ~uK]!h \/}K<|V?|}|_|響pcctK#Ë|{fE_%%Pu?QJ$1o18~}ˏD>O]xF N"ovD3 rTN%t'匕rA)~`Ѥ)o-x㯽q"Lr'~(=oݞ_}OJAJ4Q*9 bP Rp>}ߎw~蝯,;|^0x_OF-I9c(GĮStWumI`c-qz5;f%҉tq((NDPJ'7>keW#ow_ZkuXmǎZoN?~|ѣqzQB"1tןn)\,ـZ/^F!>vc/g _ʖWz}?&=}SP J&0(yuUwMLƘr\ gێn #հ?1[o:; h8a@m`1&Dq/jj l J/^<|j]_,f{\NhkZ`n90VZcn E}GO5pDkC~s"pNx׋`[]9-a7S؛>Vrtb+A`ޠV[${Ct˷RcAVqFPw[IBDU&;kbo&&!s3֠`obaVt`ǘM0_ԙ}Ƙ~[>+I T%`JK3Ƙc뻝MYCCZ釀\nxCB3{S?[rcC,]7h9*8&k5 \xFl=JYzp3 G?eB0sEK`| x{3VI7C֩C+,0zleQQ$?7`ϻ?^ 65]ҽZf#ƞnm7k\iMo&q u O+ݶ2 c楹x*[&0?u2\Ķ],A 6 !uE+݋}:TeGغk~c7J~¬Bb4(1N~"^jm{]y-t-~ Ū']\}xWGZ7LB\w]2wT-*7bViu; ۝k)yf[DUZ15&Hyݬ J?Vf'>Ov& ;}G"FodvG5Q`[b[_IpS对.b=dL`n*w a.(I!VmtR`d\ ;PbaB!Vfp/3Z7L[?+(Foa4)IWux¶zDkYBz^0ޜ>}X+J7튘Xfvc\ a[.֥"vIћ7naWZ7 ח\n2ae'bHCIBD^;7k'Y?It_mKEJP Ń: 1+I~`8얣3}p|6+afr|u|-pRH~!hJt.]vR{L>] ٖ+ִkw`oD_&^kM3%woA_'ob[J ۵d2t20MuR{<9Ij+o*TZ[qݑNa*IA/1I$ !ףkZWƃvh׻93*j;twK(mJA[C\Ra؃EZnFu{> ]1t? C/!hɎK1j%l B7= 3,b^!7 ߴdPu*E+݉jTk#ftmcAl+5nt?bЯ5 !RžKsuo0]nWqUJ%ƔRelw)V8mn2 QǏp;VLBrzf6^Z" ? OfK!N=O_vᨴwLVm f<>Z4V$dX_!ւQl^FW$ck%ư7x 5ϘPIZ{VaPBB!D5^#ۙW,!N;l61Z'6,c_;A)H$d L]7Ƙ^Mv$fo^' `#j= *VNm0ƌbءtΑl6F-$F-٥u1fC(ؤ;O7ROijàBd[r4SZWr({|1L`&Q )wlؚf{~J&0C+_`0u*՝>kvHg{!N1˨ +u+l6rӾ}GRa]^U&_C0Ac/1J|1BrIWuZ w5XKR-ݷ3{:6vyYoJl3չՈ/Li[+5y+%ito>:3>3T.Kv&$zc,&;[7ZvytߪMy}ɎD:j0Ac/1J|1`H o޳F/;6D\׽ ^ hB2:YTQGhKL-g=*rA1󦼭O}uŻ_oh.QEP~=]tĥ}A1؀!餝D*1 bnO sg|A&ّwx!b)JL73:wTMύ JA LrJpNҹ/OwWf/dZRt.-g=NҙQ AqOOs{|GQrRjB!25:.a+\׽jVO͏?>~ѸT}0JZhU{?gɤ3eo&72AO1'1(J{ޡ>;Gta(Dqذ,^uzb,ǵ?ooyUgx`ztӃa"(&0xY/Iܫ?Ou1xNM LkO.Yʕo{Xy*=zP{'q 1J|%P}uK/ Ʉ$b?ƸWʕ@I91kvy=wwzi\5wGH1 ̀nqK+:7u[n^{`kiMe2+Nz x׋0JTz: a4܎V2 vX\HB!*hxrh຅Y[2=#g?_V{&`;Fl\48 ;b+IMK$t\2MU'!>,LbϿ_dlQP;'BZoee۩e!G! ְ?ըu !D3h۰!nɸ\5nz.HqZ~׸cM.S# c'IYjbnafLKBōb?vſ5nL268v\!`VsqW0.V3}bť$CkܩESh. BQ !DTZ2`o~OrS5}(6+~ev(ve˴qj$kf>'fRݩřb(ƔRe+͈&*s+Yt XO@cs!օqS:f[<)n K++0Ac/1J|1BIW 6w \}k)Z]={a[4ĉmP3/GcE|of{gۍoTw(Rm][ge9cYl=^Q9j{+Ux{/x{s~_MyCtD=ٽ*c5 7n;Tx\}F"o)\.\Sʗ:Rݩ)',L`N%37.Xgg87w:=:_.&;D7mU_53FcLzD*#Օ*MƽKCGsMřbO3ZfgSEj{3U:~k|c9>\)0 Rݩ@)u##o7Υ;z;n,EIg-a(E_cb*J)?ʆ /Z-"] |x/v|6UZH)x3$RI:lp⤜6$^ 95unj}tbao 'do>zvÃBicP UB]vNa(G3d[o:uA1GQrRd$D('Lе>sp/QyTkI:cA)hqSgxf1 JA*ɗ?u#=&0ɠ[!b hdK۰cDy.ܧU?bǘ`[~Jk}u5?Zo8~ѣG6R Z{}8٭&0|(Npu׊Dn+g9as_oؑuy=1=JQb4`ؚr}mW}>q$( L~_pbjƘy?~LW( )yzP{+IFD⋾fX> %Ͼ/R ~u_fW/r\No>~V __B OVOsu E(NfJ+?hg?F/rB?mdk;Eߺk~ +oX0aLa/KgͨBΗzŻ^ܓd˳ϨV:2a6@fxf=׸c8]< ܿsÖ"E_c `WP &;I1 >׸u5@Jau|bO|-x+UYl/g0Ac/1J|0BIal2K,UJuݜIك1骵"G]׽xp3v1Qî~>r !b;*msž.eۻa KSvAUQ{4D9 { -D 8l^g% B`{.Na/. n4}`Y+U B!銽xjeZs_t]Î:V_Î#׭؄J N/.O[RZsv7!bܒfTVC%7Ty{ɮU*7CZL˳R@wk9ûb$_% 4,BD6{[|Vu l?oh|ׇ=a!kV#[w—Z \]h܄o߼˱YN>&ߗy7ooY`[V{'P~} ! Xa[,%JF%R;>z{`-oJo䁯 WO哗7kYVo,:.]޳uӝIEFtDEGEtqTFu f2 3.Dǀ"$B$$NwzOWUW]M{nUg?Q=WQB\^a=&ńK.mI{1QXH4F~,fW GK .›fLB+v43~މHF8t#E_شs.j~vv_v}0s2Tι+UKupa_wvy3.r]Kx{ ߃_H rg\o ^kq}nไsθWM{6xkҖQs*B/P?/!]/' {3̙b{ L!Sn WEޕ7~jM_n ( ,A‚Y5LLgtpDDD$9ǀ^ik_6b>g}j4F.%6ͣyZR&憽ccAx'}3žDYD1Fإ~'!Lh\OC2܃ 6>LV4*10|.{qwwYoyNi\:HUZ&FCkp6~~`,`sNJ”9U O"|F^›F+ogߟmX?asQ!Ɨ_+\gp÷1xaXg ڡ҈ROiOmVkBp<>&<ۀ G1ݞ)k}7)`1xo"wo؛V1s}0*Fq$W x{ϥ. [0|`֛C0\Z(ʅ~z2\ {e_4rΪ#ac_9½o؛Us`E=Ց6z1ͯj|6^+t6\|Ѝ^~S{!~sMs#mq-6ruR{~|ٗ%_mv^o,c~P.նFLgv2kcʽՑfS4'KݥTϙr% /QrSJ.ilگ&0gIY[͙&o%\V QkT }57\~sf-/Q~o}[?zW| xR'UW@T(6sjJ}cBHu}wx[VRp}I_|싏W/pesR_Ѩ]L]zSXpe_}BQ):c.8B=7Gq=^S JpbW:RW^q__xe]]EL8u{DDE$B}2RYPݍbwROຬJ3Vޗ ~jXk~,=Xkߓ|\|ι<4v6m6tikMmdp/CN߿k7(ys>V{Ws??2>D{~ϖc%}ؙmb谏_;3z[oj3{?ghegؖ;pb!kWި/:V9_0CaT򚸬6ZWꇍ1#x+s)Y;pc[|Ǫՙ{{>^z?vv{{:rǑqw1d%yS'l?VK6k V36\ǀ{sЙ=}}}wfgZBa<ó'P/QG_㓶r6f|8 TKw2:m|ʗ}yϨ|g9w)aՄUL_gc4D2۔=M۳ME 2P V 7g\C:DŽӥ.0գy&L=_$Eƨw>셴y.4{o򼫒6 P \Ͳ/)hў"(+8DZ끏%7w:箟ygbǒlj"Dr¼eP@(>.oy+}`[)2S"L1@Qzv? b)ќ"""""qe9W> ܐ|]C%vuMz.Zȼ4!xf8a_ZP+-E˳'6HvcN; E~Z+2b=x8|!aL*.uȇKxsn W&Z{9?w9xu9>V49,EL\ )rL:3q 3Y  q_~+ v"rc>` a.Vhh̿\ގ{ #[lȒX?ܴr,Osox7S^`!#iE`baEEo]~%|O\ |w"sטjP4\d\󅶽;NA?G{z  0q^EDDDDD2b-Z?FONfb\.GCCC,^ELL -e[eڌ=&2Wx/3)cӣxXkheyS0| '311}M4drϘ&2Q1zД#6߳=kLdx\r͗b: ƕcãs}ϡ[0I>U[}7`86,s˾g{>F˾gT{FKEYt֦~Dǝ9wO=}wرpigDˆ8ߴt=smPeST,v{软V*&*FJ=eK-Vhٟ?]*ÕƘ RaJYcLʎm}Z}G+ÕR\^)ׇ wc^g==7T/TWV+ʅ#Пk`uJ*ÕZg[iI/=5=vflˑ;[f|̗kj9 RPUdy! >g\>WL3P|ZIeU<ȸ>ˆvpuv;ffН)oS䈈EJEWiE pPTZlm[@(fik #~&b)?\ Zoޔw?a딋9~5›L""""""2!v1"qBai.JXKl[#8θ^95% ~2t""̩O"kEDDDDD"yKi^>8_<0:#$#N~'' -FRj}/(]_sE+q=S쳏0zs#"""""hTtY~:&\;@ryi5ds87@&N-{qZb.I1\H _ ѵ{tƭ _OxCs*Hn*|ECɹ8}˖[w#w̵>1 ҞÅR{ƼgT{F˾gT0ɿ1ι'}scǎuU17cCj{kc{~jϧ^/Lm]v{]sbΰ{Wt6V*B;箍׫M}Ov ڂ#̛>='}Rw/ܷa߆R6wcM#HuMxP.`1+;>V.YXoJQ>^/Ld6:Z>v})+ .f{DDDDDDc|98pСSۼxH׏o_{ ;;_C?yO<_/{}ZZ<0=5Z?哥O}wٗ^W5q7v_8}k C0c^UWznykƃosy0V9_S>>?O,>Ж[=W:Z'f#c;hb谏_3z<}Ʀ7cԿo N]_WbXY,^q%~b||,0xR_Q[2Tc߃g^?^5Ֆ;|ٗyϨ|ٗʗ}yϨ|9`(G(իrUt͑J7zHlZWpf`kry< ~m꾾{ZmO&RCxzz-+n6b0džuxN8\8˽c}\ U\S{_3ij]TG4.hf;7mvƭ^NX Xc_-vT*GKr5q<ƿ?i[?pO5dΛe_3=?e_3*_=eI5[8^AX{10P-]#@ N(~l%w}Cookqq*yL+NW6p7`"ߘ2D[>+_k3@w?96g\V?߮igo.|#0Robn40J""""""3nQk EB@R*0D(mtƭ.R|g@r~)Bq!-Qx>YuŊwIת*%`bĽ@)ǫ G N(L_\G:錻v.5@8m8bܿo&|_#|k]13"b(&|'Z9&RRUrW~M(@\_%X'L+k #i Fɾg|*jtCw\ZtuE^}? *Ϙpt (P@u}z{ &F!_j F7F/&ѷt!wDDDDDDh]D2Es ~ S\!oE}Iqnޒ"5\0k* #= t?:R"0 "Dr~jg\9eˇ´{Tחb{6 " +d@7F_Ex]0)Jڡ1!"""""FR,PX#'f]:@}MDAd&{1J9PxLK%NjiЃ7*EcS*"v |VG.&\'|{fÄGO2a""""""&_O2Q .Bqn!cE=oy[ZUc{:@'rޅ7g\PFZ!+.t=bLE(0m]KvRU1q:-]w%o,r3gڴxr~Rg܊YOՄlNc3e("i 0aq=cLI iH\ KݎEL9 M}5~K)k|x {Kݥ5zJ{EF5&2V_yb"pohhKi?dQ165tȜoWtD9CCCn=h> ߝkcF>A3*_=e_3=?e_3*_=IHE׌q?SO;v#\'aUx=r]+C&2åR|^.ԶKt뺑y\3гئj_XTzXcXݸOu5W]֎GJ]45{#m>r_7heR. ʽ=еkA_÷\Hu{\M\1̦o9{F˾gT{ƼgT{F˾gTjR}, c5‰'vǵǾ+*E'r Ȍ׫ Oo?=sy܁XQlWMdFM,B4n f(k㵵__{={xMTN.dPL-*Dgj>=wڞWwS5ntkι$+:t*{L1CPهnWO,Ϧڅ;dݳ=_}GRx}>kӣ>N#ayc_>Ǿ O>^6Z{z|yó>^o;//M8;],8YQ//1 /Q// U<9RT⾾\-(Nɯ< (!ķ48~mmvM__ggk@B{ߦo^'+|oYq?[oSvm_~1{|hO{qk̈́ *E8K./Q/Q//Q2K HehVOθYH(2瀱]j"\ަtVxB lOXG 9QU20NjP-v3Inǁ^Bu\+{J=u'9NfmNF!%6*"""""""DEWɺ?h\㌛$Ek*2Jz33_ t'?1}p5[5n!k@eEDDDDDDDҡdV2qdl\Oz4] t%$"c;yhaB.ן^&FҦ9wp s>XF"RUl+81(2f7/ן3 p.*ABu/)֞P #oEDDDDDDDe+H>ӄK]θ;"Sdl!`k3nuJMaHcEmcv^Y,"""""""9d"d] ɗⷳnQ\&iϨQ̭ng"""""""3*JV]E( F2mx.ow }=s\&θ5EN 3"w0JVDDDDDDDdr M[ʨ7QJb02ƴT8~(c̥tٯS5&2[xF0&2xc \k: =Ѓ: ω+q~&-R{O79R-]544T;}?cxm4[Q//1 /Q//L/E*fsIzرc.&4Fd6ć>vsuv_[czSj}S|{CK{z/}qBueerI\8R,ӱq{ M}7[qUu2TZu&zH+_R6zJob==7RuzJQ1jka)b{F˾gT{ƼgT{F˾gTjR},%a4d΁؉Q1:΁Q9:W珜:Ze艡jOT(N(*Eg0j}ȉ=znA#h^WM3ֆPW΍]vÝ^xpTFhkXkw7vm:t6l#_<}'>^:R?Q*Cl~Vyha/;FpWjx?1Z\@}\?R.>[o/{jk&O]1#g\E8u< |ǁ>kj{ijOօ'ep.yXQ//1 /Q// O.ڢ+)83 6?sV{Q.}@ XwyEDDDDDDDXd.W'7Zk<~Ln&yܲ%7W#k86.f{N|D~#=-X1O|Ӝq~0z{aËg$Z; V%sghGR¥ k%(.> t=vgܷYo϶1wWzK,Ha%xv;A(o \HfgZ{^ek痤aݘzC^M&"""""""dTt]]Mgٷ]d躏p y eQ ]θ{/X?􃧯fb$IJW0b0w3$¹"(j~P\Ju›R6JDDDDDDDTtmŖ =GyܬsgeQ.|?[w޺Dfϐ(`S%x0t`xv];~h=WZmCWb2db01<&Z\xvtxVoų axxԹ]xXOb6kgT{F˾g{>F˾gT{FK ״=<˾#M۽|#رcabKz7W*ÕK c6>^X/3Q9:R(?#/_}7{ZmG":/*ύoJѱb׳ړiӱq{苔y*CBT^,j㵁z0RXp3oyk7Ǐ{Ņ[3*_=e_3=?e_3*_=倧Tci{BxvWڒ3fJ} ”ԋ]#Lќ/ W6|폿SqS;jU_R_֞KƘ8*Fj_<>^׋]'b!*FZ6ǫRtr$"""""""ڊ,v4myf`СC}UWޯs|:vn;XoOONcJGe[+qCGOxi1s p8ƣ |w_r)/Q/Q//QrPJQ5Cp͗v9sOlSV+m85r1+ٞLi Kq &6v6iz=wU3*_=e_3=?e_3*_=eI5Xbl]5VW&R_N ەSkz'V/""""""""pi9˾?ІeP"]O)h~rg\,r<=q5^Ƙ֯ui3]QXY)xx] J>`a ;l 5)ǾG$HV@Z|,9wT%otXe0Ju0ju! ^K S 8:jQ):c,&][Nܧvu5ߙ~wr\%N]GB(؞~g(ƘeY X*ι+>i ־1sxppsGˁ_kCH3F#&xa.x{@P.hjɌ <3wC7 sP`)y/_E3@:bX8I(ho:>k\θ6TLEs1]Sas}x#|ˆSYk?m)Pa+tW2ƘR?as|#snOgڸ}כv-K&25cF˾gT{F˾g{>F˾gT{FKE[t־x}7>9ܱc:2 v2\VKLoWk<:Z{] XWXݸ{]1&/Q//1 /Q//߻)CQ//Q/Q//QrPJQ5C#J%8hg\'p%a*)?l$fUuzM__fiOEX礏oc314?/Q//1 /Q// O4jD(rB/.+WU>NcbBgT1 cvا~lsMs㫼xΚTc"c1v.gT{F˾gT{ƼgT{F˾gT0ɿ1ι'}scǎu@eUG|>W1*FՑbwXTmg{ц է|o)˽om2\YW,>Txf{1ceGw/V{K3*_=e_3*_=cA3*_=e_3*_xJZ>VO*^>l=7FkJ}M}Df,*FO-f; ©j^:ݧ~© ;: Yc|98pСSza[uÅ^cǯs9 cv0J}E|e_ח+J G*c'?yaݔgT{F˾gT{ƼgT{F˾gT0RTM*HRθ Tu!Y<,hx{X&`Љt?e_3*_=e_3=?e_3*_=eI59?q'[q`p/Lpn $""""""""]sdo %lZq,0@(n ODDDDDDDD$Tt͓ ہuz8 ԖIvm]#pEDDDDDDDDRkԸxxpru0"R)6GDDDDDDDD$=*,a """"""""+*R9ɕh """""""""''LdR7#M&2Ƙ)oQ//Q/Q//Qr$Rk8aQ^W]&1tnlO;=e_3*_=e_3=?e_3*_=倧TcDDDDDDDDDDRc|98Pԇam> /Q//1 /Q// O4HTtI"""""""""")RUDDDDDDDDD$E*HEW*"""""""""R7@RdD,u3d"c !/Q//1 /Q//L/E*fsIz;uEnR[cLʎm_C3*_=e_3*_=cA3*_=e_3*_xJZ>VO퐚^@DDDDDDDDD$E1ͷs#xL}xI&GO8=e_3*_=e_3=?e_3*_=倡jT5O<cQ//Q/Q//Q2KE9onlE9]S✻8 V|9wҵPDDDDDDDDD)p#f]  ϓݮ>]FȢx'adk >kMs!Eo, tmsKTpm[sh,>][jkm ers5EZ][?8|uhھ}kv%fBZ-pu뒛O̴sn96ϲ˦VGKz,xSuxGMJ]3*_=e_3*_=cA3*_=e_3*_.8犳 hEi{x7x#s󧹑N]PMhgT{F˾gT{ƼgT{F˾gT싉 Wf\9^5Msy'Y4ҵ5cM9ߑ|s6Vdz<K>~ϒ1{Ǘ-sʗuC?9{>wƋB!(_] 00 1kk2e@Oq.S`q8s"\ fZdY39ߤ>x<!/.~x\|g e/s|Д\A Z;Jnθsn5E׹*"""""""""kH>^᜛i)#"""""""""9k뾘|7~/iھkڽDDDDDDDDD$ӌ~ېiι$7Z Sv jJϿ yn H}Pd,-A~(e*"kW;?{ """""""""4/ >=ޘwKBYkׁw3 7[k"""""""""(4ks^o6a6[k/,aDDDDDDDDDd*""""""""""M/ """"""""""]EDDDDDDDDDRHTtI"""""""""")RUDDDDDDDDD$E*HEWpι80[k/,aD29\~`ǀ/9x#`=p pS^$so~S/>cDZ[x5p98 Y(ι2Sk}G}s8HBxXk_?ǜs/@YkOdy0n,sfு .^D9wpv 2~NVF,2>>fEW?t8^ NcLxErm![eT}H}Pdjι^s.ǜsUO̥]|hz J[BuMvq\4R$6%~n勀HUag9gׁ%z]rBEr9~s|Hs? zp#\ef3QwQ_Y\g\'N}#}o4R |l},?'v^L j?9.D45s^ Ԁ&_UMkmH69 K##\ʵ#MSM5xP$/on:B?i}$8"{ aANrHs,vw>5;婮P_Y8ܿ>ܼ?wSJY`t4sZ;<=i1o6kwLE|筵/{RYj1ι 斜jIoqΕm"YgAkNUpM?Jӧ~dCˠ79M"7Z$ǒK+#~vJ&"{7z 3L(p74mTZkJa坓vQ Z;aZcI旓j9z7˒7\$#Tt͞4mT;Xkch=?_&\Tnoھ|ɼ>Nnnq&7_8fiW?I8Vuk9>TOu'ps7@sulU_i͇; wp=Xk7ݭ>(^i9'4Ff%7i_kY& v\,Ub6c?%9D.vo/11\c] Zow;6Nq E$o6%zss;^ᜳQqetAJ5nXk8s3)ˆ״=<EF!xAQk}S3~:Ҵ~*8n~/Xk<'Һ5ǝ/_6O&nKޔl("kG p7›'=\}Pç3qd*ξ,#MsYy<Ն\Ts/ yTOǛO+_o"I>vu'-rs ?b¢nG}QEɪ?sq~ui?>>>AJ53TǑeJ#]ei<^CGsn7QUZk}>S &yv%O{O 曬#3? ? 1?>9NsG 7?c4/̟nJZ*gs'2筵}E+>8|;SG)]3Z;;EXLkL:V3)̴L-YFoHךID3S9\Jx@sǧgO˝s?&EZ?!,ds[daf" 3&7M*>Z[sak<"V{x![5bZ㜴֎ϰ,#*f~ \Z[f#"[GXSoOb׸d2Cs/%,.'ҺZeU_Y~&,~i/WZ};nYS8C1=_L>ϛa4mվsn%ɧf?s|d%3ecGFHд}{7&N51 4Sig:uL\ɬN=ߴSNn>&ssOxk>霻~繞w=?}IX 3>2VDf'kI+ S \d~yC/,sՄ%JO_Ns~i+?;-1ksfAtoy'Upt06/7 0p𿭵y"㜛7?4Op/gO."tm_Oι!! 3k P_YZeVF' lsU~%IENDB`autoray-0.6.12/docs/images/autoray-readme-pic-1.png000066400000000000000000003023761462076570400220430ustar00rootroot00000000000000PNG  IHDR p.]&9tEXtSoftwareMatplotlib version3.5.3, https://matplotlib.org/+ pHYsnu>IDATxyxce?m}PX7nȪh4aqXhKݕ*EdaYeOiIҤyx&I7眷 SSS!B!B!B!B!XoB!B!B!B!B !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! !B!B!B!B! Ɏu6!DtBEB!1!B!EEgB,0ce:_Zo[ !QDO!(B!Bh\PTt&:QSc/EB|B('BQ_ !B!4.*:b`Jnz/pb>BEB!1!B!ajj6!fu{)`jDu3PBEB!1!B!B΄9ٱFSnvNDUB9B>G!DQB!/DŽB!u:bl|;jU !!QDO!(B!Bh\,Tt&!;ֹU:{h۾rB9F>G!DQB!/DŽB! bcDnrc\s|B('BQ_ !B!4.&*:"dd:^N~Q9rB!#"( !BcB!B Oc BTOvs{ϲcot"wnvNNώud>B, sBD?!B|L!BqA8Pљ!:~õ/*!QDO!(B!Bh\Tt&DȎuĴxO:ȹ !A>G!DQB!/DŽB!  pc1'+zrBJ!"B!EB!B3!"jShΎun5 ʹ !* #"( !BcB!B BFTmBLCvsk#8ċfq}!LkG0Dϳ6ZZsBD?!B|L!BqAP3!B@:{3Gx.pzs|B('BQ_ !B!4.*:"$q1uY--9B!B!D}Q>&B!и C >1@:G?!‰|w4@: cB@%Hh tz lL'r5I'rהN[cn:{..SC!8+T,[g&D>G_9( N代tY(B/@:G и LQTO6WnL'rs\}vȩF{}dإHlJsh D;Hh 1!| s4@: *:"d:| @̾I\98W3bh0  < ow)9BtBh t~ ! ŗh tYѸ 4!Ćd:>o^|r4b[ͻ&;ֹ_8;F{T@uaTD<@zhpj]! @: ?!ƒ|w4@: ?DŽsK4@:G,h\P|Wf|W&6EEgbA>ٱ0 t"wi:,}8xx3pv}!ٱ΃7G!zNnHb=v|T/!#QC:G, "/!tYh\0 w_2۞JhyMz\=x1p88N(Xt"nOb*~I'rkh'}/87i}#l@1Mx}{.`s|#(tB(F`"t|L0|Q s44.(G+sp}{p`s }N䦦q>9W: :ax W(\?ݱJ9bS#(t6Blb 9Hg|L|Q s4B゚x89>)p p1(/g*:u݁7۷= Ɏu6ip -⫁wٱc8S5*81U)>/=qoI'rυĩ0T!w0CSC6@>Gl*tBG1Z;Hh I1bBTEŗ #t9h\P_ّ0KdkqM@n8k]uݳ)X뀇0=n@+t"gJ;*^{G8ӧ4% 6ȄYTR sĦD~qk/  %Ps4!(r1!CR| (9Hh +8;X ZᙊD |^~} T{zg:_N.&c r8sUx8"9 gֵTI]jhp\Q)_`">Blbw s4J>\LP1/D:G s4и`z ξg783>L3@Q4 sq~pu= ܓ<>=Y_:L`~{)o1>ztL5ކqF@l KК`^fx׽賻^t v!*##6%_ 9( !9H|Lӣ||#:64o>;*>>ϼ˳84PXLmklLvq2{:p4f-/'Sz'Sj_<L|1wF~Q~1HHg'b|w@: ?ǔ 1=_t9HgGT(8;;vme|kpVT^6$LϢMO(lLdgaR쇙$]9bMbАEO Q9Hh|LQ4s4@:G u߱N']w?m2'2/ʔm >ˆg2|~+^{eu_ 3!8=1`{G|nt`q̎ux f,Ɏu>x',ЖN~7];b|!Ӟ\{+1-%_BD[͇Y(b_$i?Ĵ3$S9'Lc5ocbMT,2J=EŠ"-Ts4$r1!GKP@:GM4.[%`kQo`f޲;0KlWtG{'>3ڕ:2͘6vDq]Eo]1u]whm޾K<8õ~X8.`/VF W\҉sGôeLKOiN-Ngqhp(p3K>L5JD} EŠ"Q*9HR|L|Q%Hh t.TG+2L]}j?yo2^w.>S)Tj\bvFLu)O; '4hp@J&cqx-80uSmH'rev?͎uup#tFgj>4Ϣo_.?ic`ؾߨm+|// ]h@!t6ǔ 1c/*  s4Fwew22oa}5`ۀ7c+xpa+_gәX6N`8ۙ1?t;j{vj1s'ӵkv]cLώuiz뫸/J'r=vFޣ0O:6rݗ?8aaz -E>LŞsW1ǫ_sĦD~Q~1hH'Ć(Fw  sr1!fEŗ!t9h\Plm+fb)"p`w=X) { 8'>rKl2b =*:uuq|8ot; pYy{vTžqԮn d1?8#QM`1 0g8N~^^-=G/a~ ~ ݃i&u_¬7uLUTj'1/b@EODuג(9Hh1bB 뮥Ps4@:G LSeI2V8o 0b-$>\]:7EhyMq]hu(d8s;O07a>?2qg]mkt>BL{A0?ýeLi |f҉ܣ7`yNʎudOe:k' 84<;YZxHjB,&Sg1S ~144Pغk= | ؞ c0@>G5%%PstQQD1t9l|L|_t9HhqAu±`j`̳fKyٗ`L (weym3P3 q]> g:3Q8o1?ہ; L&q4<8tmclH'r}c:WڪX#ӉyרT[>z$]y֑1Sq uBx(,JbkC300lTi~g2lg1a?L)u 1?, 7:W~1$H煉XbFw ¥r1!jCF* s4  ݘ"wZ&9ˠt&6 ~ 3pc}3o~1@`78(q WZ{?9G14czǖ-guǰޱ~8X=9;<;x'{G>;;ޑ{G^]-a~a]Tl@ɾe&_ch8 @aW{C1ܣJ6 9 E0 >bcÀt9%S.&D(_T| 9Hh ^@:>?ʔu;k>* @&uO=i5L~뺭@X8̚y3n!:sm=Wk_x=pd78qMDnLz+1;7(p|KOMEdSKO{aAK<<\~M W> MšBC2 0-l(ĒX.5d*?X\$S_ E7>SE笻9a@~Q~1HhbAG:G):/* s4A2 t:ktf65*:%;Ou9vj1vaZ*8gc{S}f80Ɇ D'rbZ l li [vdž#-=_׭hi/p 84PhLbCW`f  ܚL>UC>3`-&Ho$}ܽgcjt(Fw stZ>\LQts4@:G 6w @/p [;6ӡ31JLx#ov @̾g'S{qf[t?%׊d*5{: ѽCs€b@o{+ @1@#tAǔ Q_t9Hq۸,ߕ(;۾;>؟+{rQљw\}\׍c ݔr볹Gv݀nbt"G/Nbxl::~ &0N䞨Ş g=0-=l[R[E|f Z a{}0U܆ /aښh2?9(~^~ >LŮ(39 E "h "t&Aǔ Q_t9HhqAEnv/PKk†-ǹ XK_8k\]T\m~>f=hoionlΎu`Z~iS0Y#k/X^t"(LQMT{G>8;z6Xm?^ |X |s#E-=y{o%w$K&xS?Ybp9h2~2Kb`O5Cm~iyЩd.8c0 (DsP[h "tǔ 1s/* s4CX+m+b>ߩeMSƠ:M/1G3o\=SM{89v_8kgcov LvЙNS큯ﶛ>NR]Ӊu 8S{zKO+{5ᖞ\}xȁw1:\~J{G^_徃0gK >Jbcv%p!k"d*^*ܫ!) [P>' /nt/:!)P^uB:GMꕏ)bnPѽ_t9Hhq2.we^){5f ۿ_o4Ll2ǹYμq]uݗ{% [6g`?:t"=tvvs=jjCu%Ʊ>TXaase[B{˓vFիmiu!%@aJ%`Ĵ 'poM_c0mi94PxGѵ{o+ 9 EMt%PSPTHh E6y>\LC˦B:G (o\){ @Egb3Y{w%v0g`*@'DR }Y]gw:DY_3y#G1v{ൔƬC D>=l84P8yh]{ ?%SgK%c@ܿus€o(⟘h1Hh E6i>\LGos4@: h\P']`g}A.8:0U't86Ebv_SsӉ\u^-xNq 򱡜9?nߗt-=C x ga~gnhĀݴwg&u?o(l'|b΢?!jC1Z9HgQzcń?/B:G ('>?4﫛aU 3`1p8;3'WiX=[wkYs콮1k? fwUzNk9yf g9684P 0,U*KbT߮衁^=ml1Dgd*tEAC~Q5YBOQstYNr1!b@:G,ʡqA0z7JL9}\]W ;8Sӽ lE_kcqzc?~#M-=GOyvxȶ37Zz'j=T9Z,}ΥDR74Ph(,h7m ;PNaM"E Ez E9Xb|w=@:Jl|LCK=@:G,*q%.]}]QEEgd6Au&q&]uC\=uuxm}3gfy&ZDݟN҉089;邩UdRv-=8X봧α?/!b2{i:.Tyo *Z;n{5TRljM|N4|N__'9z()Q'9Hh|L3GK=@:GM4.2 vc@w+SrY1 SS$\"kFqj]*؁Zu_\i͹mF5/oŬ g`qt]w8k7“5nN'r}^i y/=n;'t"wgY;9;3E(L {Gj7;v|ZKO{Zm 2ax [lsd*?{LS2[;4Px/U`KL׀o%S 퀏ad2 {̐ω AA:G??Q=AA:G)6/* s4A`qLׁ3Eu: ^| Vucu6j\m݀0I{V@0uݸUͼw&}ȩ}pv t"\v3n_S ?py= Njֱ6EexHlwPpFC#,ºco6A2[k1&{x*+CV`{{ۀ .T2W_s __ y }P9Hh|LXmt*|Q%HHh tL?.PpLgգNguA=j0 gn \[!@Sx3p1kyӄ= q[k i_|ٷiLu6ppz:ʎuӉ\wq{LONI'r;j)U;ޑ0/~Ygv_?|x3p 0*GgqhАLŦ,F ,.)| y/Nn^yf^%S~'s`c%tW F:G) 8{n_5(_T|79Hh ӏ ]RM +*: g`7BVx0UsoPtb[0UN;D-6f: |˾ 38{ x;%Wi{~agD/}-=}sRrw-=meuǾ)5fA} Tlrh*L0f qR%p0uYm_LbW՗&s`t//=6AZt91S.VqݾjQROs4@:G J f[pV\PVn+_p u0gqu4&М|޶gnpg83ut{ pq~\mٱFL .{ϦG|>s-1҉ܣ몆kew-kinwdQKO8Z ~2c ȃ,f ͘ ;1k]o lyVYj׿~w03ٖ1-QL*#9op0X B:G ſC8bKm }-]/s4#rꐍ'ՂEŗz!t9zh\P~ (R` =+8+ѥ;R1ߕ9 *: < |q)uwލDu0p2lOm 0An{e8MU)cMDn0'҉HL־kX z~Ӿv17z6F 1C"B6 ڳ14Px5oZ THnDMj|Nmj__'yaWa-A1Պb|w=@:/|”)ٸ勊/D:G Gwet{Fʼx/8YkˍOZ63ߕ^ퟀcAqC|n#8W8/w!:̠@ y0uce.p]s]wu[\ӊYA\q)[ lqq&}˝rK |sٱγcaf9U{ܚXg}}L{}WYǹ&;T^s5;2w2 6`<M曀pl3gY(4 ☀uTvV"d*v |ھy qLE@xLl*:#̒20 sԹu&qֺG+j.Lƃ+].g 5s]ws8]`6ٱ1{_Nk%;ֹw֭ƹ͎u.3Vƍ-=c`kuຣ5iɎ0yE`Ł7M^k1Aao||IZԮZzUfSJ __ A|7=a-A1UB1Z1:hEgt!ǔW tA|"O|n88+ߕ,>_weN,y({K0h 6䟿nJ goGmu?S G0ovN1Ep sS?'; Κ0><x@:{| w{׊uk0L<]xZ[t֩͘&zUGw볾}b'@0=ja]ܜLzIbO?M/ U] [-[r↥+'ΨA>g0Xb//Auu?{]?W ߆ Z:GCg|Ll}PX;-t|Q:GCg֠qA50,>%LQˀS0we0E^x b6|WfkCZ+m\4LM %b:\mǫ)3 ^g79S{{՝-0;Bq{N8%<8qΥٱ́0Nb'҉?ʜn b:{פ̥~l+1N1UYhZoi=uV=}{)s 8Z'gԚC}d*]un0mo$=V=V/&p&,`%~e K/[0XrJD}+ښelY> ((Xo3[\ ??bcPSV7At^K|L̑')_TXosmHh9:Cx.LC|ʾn-. 8 ޯgqAY+s4p}{`4%;t}%pd|:m|gg}ʪ(l¥6]0QL[q9 ^{\m787y߽fub  ]+Q{.fv}}1Be#o* =;Ο-ۂ<3, @СE]O`P0 ,(`Q/+0H^P=V/=icīz$Xrby3/_r0X E 4!ZUR()1O6ݾjPVAt^K|LA6.|A kC:G#_«u)4.x\\ʼ+O: 1Ng/Qp.pݴ{=}]`Υ Tt6 ΎiZk_6}C1铎q5nfm slU u)zf<iUX;׾!p:p`:[묨xFswY,?F{G^_|4vۀ}-=y&f|=*}b= óhg ؿbkc= 0RKTr,/Yk?" ҕރIn̒&t99aA!:C@PSnt(F+F Z:GCgG>\lvƅot(_TsmHh9:Cx. ]obͼ*ߕ g2WXv3`|Wf=}Ki >kh-$ ξg7_ ͤBdzy)s`~se`3VqP05UÛ2g\{g nr0k 0n`*|_qKӹ~4cq.溸l::T:Ukޑf/-=텢~o17wܢ5 뿀7e9Lǁ7 _ifM:[KVVbot/LU' 8:/N%]#}hp*ӓc¬NHb7vVg'SK5;W^ִdV/{>fk/]9ѰyjʉW7hk^t"ࣘ$`=4$939a _ NLP ^l A Ns4tk=#S.ps0tjAE[ /Jh z&Di\ʼSpp`s:B++@ݘ`_g{ݰNgs-&;gYWp+(u{p]xuWifJgc:ف"qTzկ뾡y3ofw:[fCUgT{ޑoᖞox#1:fiKOY[3xf=00;{ 036;#\o-K536L ?CL 1egA04Pwhd*^Lwݽ;&{ %sC%TW^%YzYEn9o&6f9Ms`c//Rgaahdg_bKm }b40L|L`cQ!7A9:C)QY& >9pݼ/fԳ|jͼawc: f\p*:s\}rq&E(b0cYjw]=USxv .MwOqXe9뾦]71=zPƹjw);j>޾ޑC52;YKO{awd쩯V|x%| p@7ߏQ/otYxԽJsd*QA5&SǀOc|9cL}W2 ֵ-YUZU&YM-]9`[1D()b}NlEE3[P Fl AV V.tΰഞs)[w܂`c Nles4tXe2`³L ]&o|Wf o}u7Z^sq]|q{}|qwot*-o)И8uVv8/sFKz\IQ;cK'rtx?žߠmx11U6yE <1-K_0k6: 3k'L;ttk3S^ksٽƎ֊Ag\>v&A m GO}vR4'iCETlo[cы9 dǫZ.]9`EuE[ӝg]-lss`c1s3[녦lQl AъѾsK#3,ؿڥ6]`T+sp8&`@=/w]wnC ǹu07c:T[NbN~8{79lx ƉWnq[`ԭjdDXgc:+{G0AnyKOv{]0]6r# ~G9;+ƹ~_-=L@{k9ݭO.&;['F_ | H`3{kl8ut:,H0reTbW eo-Y\oN:_"緯8wE[sX |Ne|Nl,bm/3[녪lQS+ecbtmo݊"7:oA WRK>\,Xl }PX-#s4t`k-7:oA Wٲ'1³|WMg畘#]p*:s*h*5q,:w13G+̊i.ô{~X853C=89t9l1;2]Y–F`s#<el{8ȴߑco޾+p-0YڼvĎ?6xȋnp끯JYyc VJjL"w9pL9u$+}Xybڟ[B'}Nl_ @Qcu`kfic+F16!ܾ yn)V.n_1kC%ytld!Zk\0q+V|Obvg?ވqm|30K;9&;p/`gur?8ο#1{3frg}yً0O^qY/"q`nk_մd:<0Wҩ60=dõ RDow$Ӿvw̽liű6pbfowĴ>xp f=a̎a՟}~8;iď"tZΎc @1EZ so+$rXzYê}+ڰdN/]\Pk"~ & s ~kC~qtlJ!ZYg?ſztJ]An=­uP1b`c+PlF!3[k !Zk\P-we ,we"`}1Ń|WfQ|2ߕ)l2Mc ?+8kPA2Lp0yˀtq.~'8s_583n0ո6kW{KvК7;stvTKvT t"MQ[}6Sߙ^Ťߪm=NGwp葘ya᯵}vݭk|l<twt^[pVivݭ?R|NE@ak`[kT>{\S2[k_`*3Ur6/k%rc,^^L ܹ+ښg<^{Y>' 6b/Ο_ lì?ſzt(FF6wIg9:C|LXr0t(_ Ŗh9:C­ jwe<}s]`5v88N?8u03j0v࿖138@^owǹVJ &<t"ϨOju;[//^n@fρtGw_K\uroXLut3-:[4@, @UYq{#p&y ۷Wg-Yo]"jbʷރrkq%i%%rʼnDwLC |E/Qgaُ(͉Ab|Z h ߴ cl.nE勁-Y:[/j\)!ܿi?Tv&[Sb{#&ϻө/{e]jSlLc X-&̛klRxKmbZ>f_?R5=3Xy>G){q]w3M߀ |J\<<\|a:vٱ}co?.10-%?>;r7 pK|:[;b~~ /u];oF?}ۗtjAɡ0SY`$cvYv gveaxOȫc7c*O~|ve(7`Ɇ-l?xV/KϵI1OK} vKWNtDjʉ󖮜8aʉ7tFQQ ~栅|Nm`Em__ ::+Նߜt+Wm\s4tj|L؂`cS|1E:Kg/j\`^5.|W惶oK?`}Ip4p.pFW(l]LRNˁ1] jm}{0۶?/+/{ݵ&\ҕ0oъI1~RӘ'KWN|sʉ`}VlSrL:Jɏ|9?NFEE/~1:C@Ίu1M۱B1zFoC8}wuj-3Sc\.nE/=HgtV©Ց\vDT%fj*<'emYc]kt/8I[εV/^8ο}= 7q]wVn;WYp)F}14x @aaݪee4Zxp1p&Y$^KA̳8y̲${xUy$6{l/$t_x_} } tlҕ,yg0o0+'>`+لiE[s%/.]9ҕms0kmb"Kg֡YOoSﰆ  ߆ns4ti|L`ctV|~E "3Lk 2,}~u³|W!ߕ xTf&g=9,t]wm<]2׋{W4xs6뷯V[ĞS=s+Ʃq@L{h9WTqL'r#ZNT{ p/7'r)v 6 Yw`m;LUqGw:[`}o$(kott>5gkm%Td*= ӾˀO 6Kbkk٤rLH,Y|jeObZ~ %V/[\d"=K/Xd1ߧ>y˲j0I,^~Wq+ښLn:8K薮H`f>T_rZ%#$]m[Qa-vs`c5//RG¡utVS۔6ݾZPVF1z# t.)[8Xl }|Q"#6@:f Z:GCgT7.߆) %)Qxf;5a.Y暵we&6ajJM=q]ɛmw8峽뺛;lѶ/{y뺟S7]H:Li13%;O'r;a* D|*:Nt"wwc{G^ 8ag[zڟ@oTKO}NZ[_Z}oq F/nphcGw묋FjnNnu& ۳04P} XL!bh9 Kb*qܶTq1ie%ٿ5[SL}&olb&u8hZߖ1z?hrL&& U`m#fÙd_ҶKWNyZm%YX>' 6_\wb"_gaYOoStJ8n|s4tk|L`c+u)_ Pl\tt&t~5.L+z2[^).Nawev5Os`}}ML0] ,?3Q B1 Ύ<^^Y5}7zm9{?p]gt]|cVӖ&;٘ n9X"t"p:>pvWfQ[SmSYk༖[c]dKO-=흘` -%oTs޾r` ݭ?Tt Nf Z{n EB |5=(E2ܼc^^}+ ή❫V/۷1a@q"g 3e{S9{'3خ8X|F3_|m=۰tDÊm^w==ъIf6Y>' 6//B8Gu`kv6AO1Z1=3[k ! cŀƠۧ|Q"#xHΕD/_ָqA|[2>CR)6_ϴ,YQ+'1ztDW"{F/hk~wTQ{ٻYRw7bʉm^!">' 6//_z ::+)ڧG1:tt1b . OE?#G:GCg9:C鸠3{= ;3zyw?{I`viNlu'gubٱcǥiޖ "ٱXADn^sΘ֍d:wd-+}0֖f$9S1Uɞ]VqKj=7zpx@>i^LkJEݭ=v_SvAk!M&S';TsLŦ ^}ǁǒXٖXzٍON_xuK/<ۄ,^vee%,^^mzbe a`VTh)K$&LP +LOa~;/pIݾy5!_z ::+)Ơ]btet|P>\,ĹXl }/<<9:C³k^ޓ/we^ʼ8ߕy|Wf|W]wuX}8(>_S(:8f&˙@qº4,c~}03mvTǹwN+0?F3뺋]Mc=q uX1%䵘*СXf-B4UYXgsk }&Uv- ;X`Zj ?;{\Uto ݭSZހk'ƹ nWÀ}?<+WLN,@עvҾ`hO󒩘Ķ>Kueo`߮v=iYx,^ĪKW^v' 6z/)b-SgAYP Ah@1zKds4tk1b!`c+F"|qGlt^ǂt|5.Ѿ!p. ώwe1b>Y7%ot3qfKWB׫:TtVG6vk7T;h h -~q(:gu&,{v{0 8Nv866MS׀igrվpye:S+fwz+d:ff {a@rwdrb?S{G^V=|SVTS ʆNLݭaڞNvt^l_@y³k+:*:#Z*%'(n8Î|3zڢ S.6CɎ|8NYv!=| SWsչcQ#pXEފf z9mc-֖痷0O#9] dOU}:[/ĬSJ{;[S!ݭY,@"p5bhpd*Ӧ4 34Px:.Y0mpie c-KM]z#;|q%u)-]9 +ˊZrbo൘{q KD!ZZg?ſ dKD!ZKg"3\녔) w.lEA-w DBgs0.-2; 0ߘ߉!ފYmkx׬_.hb۞rI̺?93VG̏sL1~\V͓ 0է58W";h 88xt"]{\`3`{"t"w ޚ1~N̎uvc҉YsǾ}Y:[W1;>Uρr[z7;rpKOZIځF 8qؖݭS}o 9|,/;AY34PhLbCK06d*G߱^w |WLOVGbTXrJ2{V^˟,^>j-1\UGkm{ڪi_p}+ҕ/.Ĭpe;C`,]9-pp6{Nhkq,\@E?A£uuVS AO1Z1n 4!8ΧI`Fafμxp?f yڜiLc뇁ۄ #DKٱ=1ճ~N*cw N䪩^]iI cw[z#qof}蓁3Zz/u-x@<7'y'}j$hYK$S'3|mSo^d*6_9{V^\dkL%_f7NcʉŘ߀ _IBtĢmkcLuʊ檓bs`"ؿ߭ɢg߳2M:7Ib6H 0 Lbk}۷v0Ad*6QZŬZ,vgLBw<$tb0-M]x*Dc ҕMp92`kamWcf|B9aQ~Q~Š ::_l }ъwEg9:C`cŢƠا|Q"-Y:+_  !Z5}YE2{aW>Pji ϮsK]8Cs|&qbu,n\u.{'k{kpMDnMvskَTzӾCDV_ 1Nh1<}=Jރc:3yߌnbbvZ>m/LT~~3,}MݭkbroA cݭgqh́#TlM1a큻_&SWyi$]1}& ]UkZlL_T9H^ ޾lE['r9 F Η__ ~_l }aZ:GCgAǔE3 AO+_T !ZKh CLc|2ߕ9U*<S`Q#j#REg Λm3ur>}N[&k.>,~Q(qg\mދq碹ף֪^ycы0U?O'r9́T"u1; RwKZzڟiTx ~'9;zL+6L{-oSZŕښ uVvt~{, >i/d*vvZ;c=T.if@9lv,99/ { /pm +ښ$0̞0((HbtkD(͞Ŗ0D ~su]g~)f.hE,HG:WGصv!ZѸv]cxG|)| Mbz"St+8;ӊ |ǔ,**mU;0gbM-_ _t̹sx%^W\҉ܴN);ֹ%fKpQ:tx.7#g(0A koT;;Ӿ~NԲj@>vcbZl 14P8&.T^Pl40 -@g2\ڤnk8Y~0(8s7֬A¯uPtV[^/ 6>v A¯t :rba1)_9-]kAyk-H!ZK5.f`x>`]`iN_c`s16{-9O4ۀM(]\+8k L뺯u]u`i-s0;ǻ29s _ 4ykcf| 3f0AT`H}N1=\ \zcvt"7e?X1-qjME V0;rƱ> رLomn577z p8soo`OPaďa~+pe@@졁e?Hxed*v3 :sh K/S~<vsl"`m֧ǯZl빶m:hXּ3pJg,]9ZYK"'s`t/V p:CxΊPAO1Z1z:+8!ZKPC)[Xl }/NGcK"k#ZKP5.f9.4;`:5̞G+|Wf`sf Up6Dٱw6:/lA;wc6Sy869C1/Jگ8*[8zkq5:uLO:s~Ͷg1AO^kRk: ߾O'3@KOCs:up306 < vtam`&ݭ?m3j:cgY,@s|nYkL{گw0mL0>:}.)fg[ܚ^%ҕ͘ |=;ֹuݣTURyje;)~:;Dx^ac+~F>}ú\8?VY~ymTl*=y'=dnhq?&{(-V/k9IMwcɥ+'mo0kw \rcKWNl0KWNTR9 TԺ((duXuVS A/hVagto:r,\, 6>[@:K` ߴJ?EްY9]o/OEi" u1?|u8Ϲ^ .L_aν1?`LO'YqgT*LUɸaf88x1} p\hMȩ|z~`EsN&s]3MUoG:Vx)po:ئRx#_Nr-=u|0 vO0-Rx_ Lgtt~˞3`:[_=Cd*654P}>0LŞZ/($S}74P Sߎ)FMO%Skj%OZl;q_6eLk,^TcXr⧘U^Byo1U[S?Mu+ښ,vU3 |jZ\]s /EgaYO/h6>hhâ3Ck !Z-S.s04/*_$E:Kg?:C0«s7.(&ߕiO2n_]0'aj>rDљ?w]=L٥}dc7ǹw~3cWX~%1m/f`!1Kz3t r 6h~w+8#l4]w0Nkw8\8ΩU읷u-G;qUqfٱηa*ô2t"7\ 07`f =) pp^xpj:LUntmw=t{xpC#8LKOgbo@}QGw;X,`{jLGwת+LϢoRJSy J\ǟ̽&H'SV/ ]|'t`ڱx8hw{6,]9q(=nfmB| ~hk^cm^Y3~~|fE[ Zf&}o瞲T>g0((HbtkF() ۧM|wtk-3Sk?AǔE# AOE[tZKh ڏb+;)>ؿ־~ }VLWUlZfIKr&XouG]}?ٷEc U@ݵ缂3{sEބY_w-ph3n#m^wrbҙĴ~{J}^p`9t6JvCt" qXguӉ/c5?x!E#Ĭ7ki=iwd08L\:['F_07'ƹw7utnL[0e})`𢣻LU/=}Uc[E%ccˬyLȡ–e394Pbhp&S}\l9LWwbK`Vk= OV5~=K-5k0͗5hkZ|'&q쳗|-pҕ[yf/$rט̐ 0((Hbu:kF=icSV&`;:btozZ)F.nE,HgL0u ~ӢqA 2w2W2weL >Sb_y~ܚ Shb:;!nqr%w<{/\;ݬuabrgv=8v7LEKf8CP:b|޹pQ ٱC0H'r8f:Zߤ7f:,7*{{JU6Poo e-ji_3;bm<X|VKOOJLv-=W=qOYQutfFm|pfRL0VYmh$oIL2T,?4PxU{=6Ld*:cOǬOd*Ǭe0[V^+g=LZfܰd'/Y.1KAq)Y Ӣv5+ښˮytSV5_^8Lomw_ tê3O0Gov=Ơ(FwUgPF:7= AǔE# A/|1E:K   j÷=0<LXlSt0Ei__Llct:s]JLٳ[+xv%fpp'J u7/]3Y zn85< yfWeew7DW֩x7LKL0qoLU.9m >mwe-=kbb'W|mwޑw\Iδ9V:x& .´厷瀳x&ر);ɾ_ItNث!Іk/$#Ǭ~w2a?; S~6A2{S%= (Fӣ-cXعXl }>/|PQ A~ӣqAgpnohv智Sv4|Wf`ט̓0Ŏb& \)uĴ^l>]̛Ŏ|7;ֹ p(pS:{n)` 8,=댥BvsLޘ _`t"\a駀c즯_*{1qL*'Y_Y8-=WKo\ }c¬Y &}2甛 8֫^(`eGw!gKl݁03%sEli~ g=#=iz}rZZLo*nIk]w^9f ؇`ZނyX>ҕdE[Se{튶?MwR,\_\H:CPSAO1Z19C149:r9S.s0t/*_DyĜ ˳t !.$1u2{sLA$>T+9ϴLjet:Hg @+Gw8_- v 3i'ہO8qkL3u}i #^:{,;U1NGSmL'r{Σ La))։.c7oi feLm08.ݭcfE]i گ93ؿ)/<7w óhÀ[1ndwȶȆd*ym9@yӱd`f\b7U3<̳R=vZfg!c+fʉ}y=o=?Dsfk_|Nl__$ ~1 :CPA-a1)F+F!ZKh ׺Aǔ < AOE[t|s4tk] 'ߕy!Sp]LNf^1K|G `xVweydL,3q ۾3+j Ϫb3|{6l c,@=Pp'q3 ;Yҡ^k7ǀ?}>SvsgD1Zzd;;TKO1`O0pnԯ>?7 z8z:[7x,jWo۞o-[14PjlmU%;&tl¶ %/7S[K$t~+'v58ߛ ibʊ窵O>g0((DHuhtjcPSV&:Cxγ#,:Cc>\lba1()_T؂tF:ώ ZY o|'t8{;f?tY{5+[x&ߕY_:Sh/YLf'pڹ}kmo?u`/ϱ8,lnrg;G`Z*0Wvu \ʴ|^8#.NĬd?9XgC:+p ]lܿN_s ƙJ'roΎunN)^XWޑciKp3F:[̫Io70}9[ֿVׂuҿw;[(FR YkkMb}e N`}ۻ0mlKbkJS+V/; n_xmUp>pCLZm'h[%h\hRYg9:CS>\laba1)_TR ,3Sk !Zk\Yw?g1 ^Lǹ5\&ZsǢTÞ8@bZxb.?~'|9UH'r8n gӉXgMWt"XgS:y&{Goi[Zᕶ .n]c_8pT; o 7_=Y,fhK `҇Uv_n pb2vJØV^xX/b釘dմ+'~f2 ݁ӗbô7NJ}S{;W5&v A9aQ~Q~1(~ ::+ A-a1b4сYg9:Cpz>\l-\, 6>PĖbs4tjqweSv˭0fG;nx3`X+_ʜom.`85h `n \S{*p0Q<|p6F0!fm5fv;ft8cEvOaɺ6@)V{c`yjXŘ`mAGJ'rŶb{G|J?&@nYZ0]L3! b9$ud*o}d*չcebVLSOӷ%K/lUoEif,$twc࿘VbcV5ggb|t _,Gu`jT憠ǖ0t@1Z1.Gu`j-3Wcdcm }|Q"R<3s4E !Zk\P劾]`d+c|_Y3}|Ͼc?)(| 86>[F;+ܽ.r;/U`Xo q\msd`q tq1kؾ@NMn |nN:ǹqc0nfI80o2*}1Na{n d:ˎuzv`Fp)Ʃ> 7e4lw \0;>5;Rwgt&7!UY;#1ח7 oz'L"zϕ}gqhPRd*fh}݅iوY3;34P8p'y@aN|-YqLG4_iU˻`0ԬY&)? \tDkLbxx)-1p,&wyҕ59' >' 6//F!ZUgſtnbb4at\)A1y(_TH@bts uj-3Wk 'ߕ52;mC]N0->?ǻƋ0Zmknތ80`ΠdWU`x03{n @GYty|T^忆oLQϬfd:l~ ݽ$fdSOf:9Dg3Ӊܭj6{~Ʃ>iq.`x*9ؖ5wq]?#ے-&"_II)R @)F,ۛE%,* TFB$P(Hd'NK5?DI3s_,Ͻ3}k?sn]+g<LoU5=o$Z'4:0с ׈//b$,524idhydhA#CU{ldh.M6޶ܤXEji;>9ݻ0Bt̄Mӽ{ƾ>/^|YI|~)JKLM40Gg(Ѹ:`'RGQH9a!#h\̼FSZ[s.ùzFrstIPk93جu.1Ūc.CFribIQg֪s5]gY\.X^౹]{6z sU7<7pW=/۵.yv|~u׉jԺ>VZ+4TޚfEڼ7bb K5a> 8u̵hќ?x潗,ݿ3i_:|;w75g?/~@i/yD~0QW]e* Yrz=v#|KJ5}[K?'.ii_M|F"h~ѽvt7vt`D'ueo'Z껫S;ǯ N:oDV?#C5] #C}ƞH49|vgWXήڣ%_|?mK.c[r/mi웟B4/9N~ZN??hUGG3ޚƾ'pҲM,a{%eFoExIf 12j\,E_ RuZF2t.o6}3Wkչ8l|Lsꚋz KsKu#T3Wkչ8lZ* ↯/O }nx]{|߁ vx&0JwivYiL۵\' ~+5VDcdxVLO!Or^@Om{Yꂨ{\i߉mDOݴxauKBU{E o0)t\xƾޭD &tݜLJMJн|s~ so!#h\,E_ BuZFr]<_m1vRg֪ZgQk1Ūk.CFriX<[c:WGZΫkFu]Puܮ=Etγ&>)f=uÃ[O3["֤uÃWOUtroYi~݅jӡ p]xѭ>jOpΠ2w3j  2IƯܵ/0?VChIs8d3cM-D 3c~N!FD?8:0n1Ҥ!Z F6˖g?`/ЙryMXd_#}hrr/ps-} L2KζMnȷ}Ѳ_$Z>+X~ wMn^QDNcNDcAbQ4.n\\̗:Z[g/Eh No[xXyp]|2?{_D]_oi>>xLع =LWLةDD]G?R =n%Zr8Ŏ;s7vt7s~%хvfn$l.G͟Vx2)DL tv^Uήڷ}SnuO,1k<24-}އE40~$Wg&tMZwQH ;~4}l?^61{VLG41hB%&t5Z֝hјmFиX+`Vf/E:n{9Zu:Z<\*b>d/Eй:suZu:Z뺠<-.heD\qFoƿ%Һ^KYsMgaB?axV*Y7dpDѐgiۃ>[?BݿDݯo^wέKt^ @-ŻyB-'63? =3 =' mi_3Ct{L}fO\?-kZcDNP~c܋g#/rFkFkc?uv2~~Et{agW׉'u_|"ήK 09{:_@l!Zy-7O{&{_'M~ԙiD/4 (x= ҶeLҾDgx:2N?ىIE9=QJ`f4Ohu.ZQgQk_c-5|h*拚/jQչ: vk:WGFu]P낺]{.M9lځsU7uFRY\uk|LsS5OE<3UQg]kչ: Z.)5Jx<vRO۵'U7^[cY, !o]]iNvM^U~|a𸑡{B 2e^DMvc̃ӽZ nCKc߱ƾ_4[Kc[uR%L h){c ]IN߿ x_i̩1LJ5.X_ k_t[?2t9Ke֪su4[5\̇eh"GBu./u۵VΠU~]nxNeW7<8\Ϻj<˳rUuÃ_nx7mLSÙDYNYpo<1~{eƳx6{>hI߯"C} l?K4gƮ0 85o.~{:e ػViߧv7d/CE<yk`֪sulZn vIſ:kv7'3RPܮ=vYꖚJ~nQY3Qٓ V|+>Ho?7kev@ԨvR&U/W<^G͛4?CDq. ^~ݿs='w7}}.Mݿ3{?w> >&'n%^s\K hgniL؃~|p =Zi`\ý| SM ZFycSg?Ϳ}MV.PKŜVG쪽!~^U}IgWFMR]x2x1xPgW=vŝ{M6DtS֟FTt,wޗYW4g~ňUn=>\b>d4_DE#VIu:ZQgSk]d_uAXznמY1x_g?Q`nxƜ}Y7<8u_^7pܥA?ss6T+`thŒ4<@ ;'':AmAП~ݿs;rwii$Z? 3czڏmiU񽊿~S<؎L6o+Bπ&lGwwjo=@;JtA<~bY, ͯ[8W:jO gήC#Cg? ZslLף& z:jߗ~.g"(p4[>u4  6{Mz=9-5?N&fIL2Zש-9e}!ETx\`V_yY?z>9u.ZQgSk1Ū{.CF@E4_\|X@]] =nLM9;h9Tx`gKcx"bL&fM|xkԢM膀ET7-A?EcNXs|ȨqQ" ov-Y~n!|s4:G]˵V`>4ι|QUR`֪sulZpX/'l&>W7?wyO}h+zg*/ۀuy JtQ6Z 3W͗.I>#Cչ9yQEC_}bήڹx3WM@::j?RBLN/N2oo [6.н-},&W7 |^`|Hes&t"Z VP<5#@cNu9>dԸq"]gYkkuO?9Z"X TA^}i.v7U5!|"/jJsulZu`ֺ.(]{I/nxx*ht۵qD=3˿nxpo!Uta"|i@ V_ܼh`xmߌ/|j 8\}o.^{s^+1  c9(gwӾ9A5D%:=e;<#Dj;nڗ޻g*gߟ5hΝ@;WȱDR宁 5 =?%wONbW5d)2ϲF2ǢxI_!|D~/ѷ$V,>y\[,Vsdd024_#Cm#C;jǟAK2xWsۈ&r_^o{D'ڿz'{/8ՠoar&=S3O䚈FK/xE;F4!}TJHtD\[tei̩1LJ1 km:g5|st{u^˵V`֞4kyDT3خ\u{u{sN7 , pKg&ќqhDsǝj8[t/:_AIiAܺh{2ak xem% wZy ] Mw73c3y+zs2 ٛji/g`t`-DGwt7_Wj:uDK :xbY, /Yή.7wIWMAtf&  :]]Ǿv(~^MgWarԖƾ['{?N4x9|hwhW7 ߧ\tI;U=ϼmblڡہcP6DOtZƜs|ȨqQbR/u?jm:g5|st\:b>d4_]j\u?j:WGnu]PUʞ|8F$/p9ѭ7o_7m%Zc-v5Aet(3hu> g7n?tM~KoʄaX!PW_{m'olwӾyD]b GOLNzNg,ٛvٛ _Vq!/k;ǁut79M?]9_zMD~-޿< RxW'{C IWƾ[~`}lj:ِ|M^61M4A%m9ȁƜjs|ȨqQ"$;.Rg&2Z:G90Zu:Z[i.V]s12Z/jXy(/SҨn1_T`ֹt]P]{wzB~zD=<9Ru,WFG_75.&0)[aeaxr (G}DKn\t߹?~4zڿ|3?R_[~ᒳ4>LQsG{g6[ήڼu?&h#C_kVwZ \]cF}r%s|%ls?~2d9>QE}3xSkuΥ_鬟[|h=stc/uoj:ȓ:Z8\Le4_|1s\"Oj:ȓ:ZuAqv|%:n@7Q^S7<nxpXB*dl[ ?ljXYQA?Dt&%֥჈u|jWo7= h)G ?' =z xILX*3gkixXCO;mN,-uD߲z6=с@;x.seX,vv쪝[I|*#C#Cvv_,4JNom!޼<뉎ǜo%r?MDψ; [_9Zi_~u|4CFnh\,/u\\:ŇѮXK~Ug7l:bh)|+:FuvGuvzUg7l: Vnx0zx yzn  `nמ}8v7.7]Gz-|p]i/0< ^S'~ƻtaxv9r1>;sՊgLCv`}La,^-yT}Gwszt`*p:xO?ݼ]ON!7ᑡhGxdGki 09ݛ;[?61;ik#+*C4CFӸ::Ň.x0n'c:VI4SF ]йչdZuv:'uAnxi_Ǻ ]{ .?OԀxT 9IINTDd9#~V<[G' E2 ! MD=o$&N? DӞH)+nʺ~i߷]޷x%3cC%Z'D xۋzڇ* `t`^Z]DNt}Q7^OőUչbu8&DKoKc_ޓw9Yj_&f}axk9o?|Om?~o\јSc5.qu:ŇѮXr~Ug7bʘtF@EWtnqGu.ZnX3Sk]ܮ=g9 .d~N4O&jgʝOl2tV0 SA$?6oy[Am xSs_LtۀAPo fpĪ f㟟2/5Ay+ђoDY3[ή\}%y&t^2$M̦[m5 }K"ƜXs|Ȩq X3Qk_i[|h=61v[3Qkչt>bʘtF@EWtnqGu.\:j:·:u g'*ºU:a,, u@:*$l+ :D ރ6 .y=OApI%.13Mn_2?@D'ӌU^xr-)с Dѭ^X׀vt7؅8Y_Ν])YbB |҄Ixk}:DtwC$9>Qݱ\g_i[|h=/6-\_ km}>2&z>|[QPKKURg_k]3kOѭ:~%uÃ{m'&|әo07VlT?A|>ާ&n{ݹ?AJږgp=^ea)3cہP7>x{=MX?n)ާ|G淓Ν]_'2%'t~`iB61[CC/dtvq-\: ~|Ls1ez>|[QK:·ZΥGu]P]{N @=ںx70\pP}+3cgG =G]T0˟El;jƏ%:iif2ܣwfoD.CcNyYsQbq4.e`>YvnzFt.qnvUgw,1GKg1ѹ-չ8;k:cWu]P]{K[a`_Uv5UE[2=5 'CD>.KgwӾynڷVq =75965v:ZX3UkcFKg=h-nQݱ\kuj D+] !,3Jgᣉ0>Oi$sݿ3i_z5Y,&[>pMn#.o??ȽW1G,ҸzZTgDsY:˵Vݱ\g֚M/-Auk:cWu] ▚*$ {B6`xU%GMNֵ4?X_Ob4.VZDst4nWպ:""iX<[\=T:Ej:7-oApS‘J("rwEDDl9ZDDDDHrjP 0LA=GϢi\IhY"""""3Y) Γߙ͸iɌ3cٌ =2Leut7~|G;jMffli3mb6o\>Иqz>иҩnXnp~z>9nX3د:Zk.?2jX:[ܰ^g_k uVݰ^gmuܮ=ٌuÃ&3Vc[~ etzF@]z>PFWgetzF@]etzF@]z>PFWgetzF@]z>#kHtKe etzF@]z>PFWgetzF@]z>PFetzF@]z>PFWgetzF@]z>PFWg(Fi}NDDDDDDDDDDDDDDDDDD0LMg""""""""""""""""""R05H'`9a>1n!kΓߙ͸iɌ3cٌ =2Leut7~|G;jMffli3mb6o\>Иqz>иҩnXnp~z>9nX3د:Zk.?2jX:[ܰ^g_k uVݰ^gmuܮ=ٌuÃ&3΀S?IY2a=|Xh=(+3Z2b=|Xh=( 2b=|Xh=(+3Z2b=|Xh=(+3Z~d#t{M)~t(3Z2b=|Xh=(+3Z2`=(+3Z2b=|Xh=(+3Z2b=|GF1"N """"""""""""""""""5EDDDDDDDDDDDDDDDDD`j:O:r0Le~}@}ȸwlMLffli7qt`*\>824Uk2to6cKcm|W;EW4.NuvzusÇ.hvz~Ug7Zs17|GXh=Q:ZnX3د:k vf4Q0tPFWgetz>PFWgetzF@]z>PFWgetzFbn)""""""""""""""""""Иqz>иҩnXnp~z>9nX3د:Zk.?2jX:[ܰ^g_k uVݰ^gmuܮ=ٌuÃ&37ax*RvN\ ]ƈ+hŸ`2QY2b=|Xh=(+3Z2`=(+3Z2b=|Xh=(+3Z2b=|GF1&70s+7|~pPDDDDDDDDDDDDDDDDDDKd0 Oqrہ09@ Hr(cetzF@]z>PFWgetzF@]etzF@]z>PFWgetzF@]z>#J+9 ρoO 2HիhYm6Z !"""""""""""""""""R*tEoA{TJI2 g+^""""""""""""""""""U"+aot'ArA D{ A̔󽊵wlMLffli7qt`*\>824Uk2to6cKcm|W;EW4.NuvzusÇ.hvz~Ug7Zs17|GXh=Q:ZnX3د:k vf4QX_7ðSY‡0_G&XetzF@]z>PFWgetz>PFWgetzF@]z>PFWgetzFbDٛΈ*r<:&""""""""""""0 w;f ApSDDDDD$6aXt= 0 ?A#s Etd2z>PFWgetzF@]z>PFWg@]z>PFWg0'e0 ? \*ni"2b=|Xh=(+3Z~d#Rt>'a/A """""""""""" V DDDDD_ e%H ðM%"""""*[Y)\JO:dpq.""""""Ukax>p]Y^\DDDDDDD8t1G!F˂ 8t)e|EDDDDDDĦSDDDDDzuambpa~bdh>dlƖ>sUg7Zuvzߙ͸i3c| =ړX7PFWg(F,H9""""CT˯~'pBYDDDDľpZϝw$zӦkeiueg""""Ⱳ5a{첽A>s 9 ߀App"K p11 Py2$v><[DDB0|x2o9ZDDDD08w>o Ly \/_A0Y_ 0L^nj<Y# Se~Bp5;;O̳D"nj|>QR|8nY⿌/R}_rHApxevޢsz?bk"Kb- &/'RR:O_.{,ALIx BNjWV{\yw>gDzzenxWzƤ[Abivz~Ug7Zs17GzF^0 BŅsWIAPL+xJmx&<$}n)dų4^}/-y :b֪ |.۵'nxdF+#}8\Xpxcy s|teXϘhW<;sc*H 3ZIxxc 3Z2b=cBV<{їfCP]PF7getzFX 9."Z1qh83Y:}goK1rH`R~cGWdfgetzFbDY΂ 8 |Q]QgOޠ[mJ9x$uզTKDDr l< x"""" A4`7ѿ<OoVhPFWgetzFp A_A A xRyVjǀ.[m܌!"߆$б.ǃ 7&EDD*, ÍgVe Ψ`$U U@K/`$_ev;3*IDDDDԪ\W߮{eeH♈H(p3W<1kd%x&""""HY l෕x?kxƳE x6t rnH:%pYDDDDD7(>i<&,""""FV:#_ o5<=rAxvG^_Pq>""L1&n<+uHK%tEDDDֈ| ~cX 9yһݔt|fDzzen6#CUk8NNf34617Zo.hqc=/4.·qQuvzusÇحq uVݰ^g_kaa=|GF)hQ:sP]^k u>\ړX7PFWg?2JTg7|83Z2b=|GF1Mg0m@K/5Ao)"""""""""""""""""Ri:{@k^< 8^|heV]VYh=/|83Z‡h=|Xh=(+3Z z>PFWgetzFR: 2b=|Xh=QHvFa h SZ(p#0LAǤ2fax5Дg T:T0 .ȳ6c#"0 _ 6$GDDD"aᛃ 8#<"""""Uy6K/t_aMy6M#""""Ktł H&GDDDDDDDDDDDDDDDDDDI:CMg""""""""""""""""""R0Sהػ}ݴIg,\сlfs|124=]&to6cKcm|W;Bb|Ug7Z?7|8Xh=/ݰ^g_k u\ 3Z~dpn>Vݰ^gmuܮ=ٌuÃ&3j:jXg>GetzF|qz>PFWgh=(+3Z2b=|GF)zF@]z>PFWg(F""""""""""""""""""R0tV~JaAa=|8Zh=(+3Z 2b=|Xh=/G@]z>PFWg?2JTg7|83Z2b=|GF1"NsR0 lJy6ApyDDu>$򈈈H$ Û=|sg$GDDDDd50*Ϧ %0 <6Ϧ3 yDDDDxLK9yq$/ غ~?w\䎹灅2&Z61J}kR]jsPx""""R&ZLDDDDDDDDDDD?DR S- dJlZWSGmPFWg>GetzF@]z>_X?2b=|Xh=(+3ZϷXL+{,R+Zo=mI:">z>PFWg?2j:NjPFWg[JL,MYfѶ5=qI?3Z2b=|GF1"N0 lJy6A`VDl08ǃ MS5/ Û=|sg$GDDDwS%Ux624K~px69 kxƳn^x&""""K5EDDDDDDDDDDDDtC,]f3jSDDD055Ng""""ƭO:;k3?n7de368:0l./FDZqfli3mb6o\>Иqz>_h\,Z[ k:a`֚GetzF|qz>PFWgh=(+3Z2b=|37xV-M:~kKm|p}CSJC_&{;SJSt*$2fla\TF7g?2j:6SǓS6[Ժr3G [_̋>8I59-ɏS~;t7u+wM:x%$DDDD*OMgDzF|qz>PFWg>GetzF@]z>_X?2b=|Xh=(+3ZWStmm[ԒڷṅqQݰz>PFWg(Ft@SM 8R{;jMlƖ>s&f[9Xw0.nXnp~z>_X5na`֪ k>#goz:I)ۈe@[gWužGtOki+;E:I?m)}K>e/~4ȫmbUxs|E u>\ړX7PFWg[h8+*䆳 pp0Zn}yۥ:,|pBMw[mπ?tUaVYňj8+ppˁ,[×YXגkKe+0PFWgj8+(KYF!+ݱ!}?|W##;x x+[ne,|Xh=QH# ë<6A`y.kLTJIZ/zx#"""0 oN_A Yԫw;|ɪl8hE&7MN6?tzmbxף g&fSXVe7%M>OoNRH""""""""""""խ* gnT &y|U661ʥrSәHRYpFE2 l<{DxƳ%rSәHZ>>pV* g#pd4>R~{?Q}?O:O>3cٌ =2Leut7狑q5y'{[elo74b}ܱKø:a:zF|a}ָ:ZnX3دbn0z:q}{o8q Mgl鶉W/M2jXG_61Ig)nX/nX3ؿ6`nמlƺA5U`=|8Zh=(+3Z 2b=|Xh=/G@]z>PFWg:!]͋3w>5'jβ  g9(qǧhRY5?g߶H5}T gwyKspeݼ5e 3EPFWgetzƊnB6wIzw+Bc'`&|8X:@]z>#Jbax5Дg T:T0 .ȳ6c#"0 _ 6$GDDD"aᛃ 8#<""""d*Z#"""eR5uEDDDDDDDDDDDDDDDDDdmPәLMg""""""""""""""""""RIۻ# v7~yfli7qt`*\>_ gcgW89ݛg.cl6xk|1|иX:E /3Z cm7Zuvz~5sÇy<:ݰ>_Tݰ^gmuܮ=ٌuÃ&3j:,zF|qz>PFWg>GetzF@]z>_X?2b=|Xh=(+3Z'"kƝp t2b=|GF1BizF|qz>PFWg>GetzF@]z>_X?2b=|Xh=(+3Z'"kƝp t2b=|GF1"N0 lJy6ApyDDu>$򈈈H$ Û=|sg$GDDD]\g9 =7T:Ly6]>Z<>jT:&f7p)^SDDDDDDDDDDDDDDDDDD 3)Hݿϻݙde368:0l./FDZqfli3mb6o\>Иqz>_h\,Z[ k:a`֚<G6\_|H"RVj½nߐ.gދ*V=h4YnX/nX3ؿ6`nמlƺA5UGjL&e)3Z 2b=|8Zh=(+3ZqetzF@]d?,yD$NjhSixæ̖m`c*sne~$2b=|GF1BqGj""Mn;oJ:239{Ϥ@6-""^n*zF@]z>_pgetzF|a8Z2b=|1iLdMMx6LYq ^61kN\>[t2b=|GF1"NW>kMWMy6mHH Z% X$- =|< IH7/z H"rF \>\6gǮ.γ霆*Gc <.mitKFH\;j I&{露k)pqKcߍ"Mqs{}s[;x-IPMDDDDDDDDDDDD(x&vll|ųbų' x&"""3Qڡ37x&""LDDDDDDDDDDDx&v 5xN'*wγݴ3?n.T6_Gw|ήZqr7\ƶlzs@c+|qt>k>_gnnX3د:Zk.2 xviGw|aD$Ƴ'vv~;0K4]wcamb9Ǔ狪 |.۵'nxdFCMg~D-VzF@]z>_pgetzF|a8Z2b=|q%j<Y;xFҍg>[t2b=|GF1BjSdЭ6Э6EDD<wu5wuZe=|8Zh=(+3Z 2b=|Xh=/G@]z>PFWg2iсÕxm[GOzҕ wnͩ^ǯ_wG~80"ٱi6o-׫o924PJ]g?vԺ-@wӽEig-nSNٟ:~__jSF_&ҏwNlyNA*?&V=+Dgm=(+3Z~d#R鴮%@SM 8RZqΉ?q¡n]=\@8el([әg?)cY~3ҤcHrx^B@t{MYʳ""KMg"""""""""""""""5ݨLDDDDDDDDDDDDDDDV3ɠ ݿ@ HnӤ3?n.T6_Gw|ήZqr7\ƶlzs@c+|qt>k>_gnnX3د:Zk.2NH$ۀ y6R)қS<~|"CRKpi5;̲cmPFWgetŇ6M_3cW/~asACO ~+?~?/^:@$3FPFWg(FLDDDDDDDDDDD*p&"eWrYpV!8Zz!*_pgetzF|a8Z2b=|j8Y;pӆ3k&f/aƳ?Kn-[&!_IDATf_v3D"Y=>! ?2tZbax5Дg T:T0 .ȳ6c#"0 _ 6$GDDD"aᛃ """"z(pM^:n kK^]t{M gӽ帽2^yYهta)WߵMd32*Qt*DpFY Z i]_nrxk`hݞ|mbVwZ"j:)/5j8s gj<+DD$5D5QϾ61rƳU&$M]U`pawӾrkd3cٌ =2Leut7狑q5y'{[elo74b}ܱKø:a:zF|a}ָ:ZnX3دbn0!cj8Y;pF2[m 8#.[ M2KٗĿZb+P.puؿ6`nמlƺAtV6g‡h=|Xh=/|83Z2b=|~etzF@]z>PFW|ȘeQÙZalíV٭IX%S翜>tU0u nXh=QPәCg8DFp&&o8xV'5&nZ< xROXt>o[9 jlie61h۬i8h< Zb&f |!ϦT:Tc|ct}*ODLy;vYo1ɪI:C+Uwn&Z28iIg,\сlfs|124=]&to6cKcm|W;Bb|Ug7Z?7|8Xh=/ݰ^g_k u\ >dq͇u.puؿ6`nמlƺA5UfUɄ,zF|qz>PFWg>GetzF@]z>_X?2b=|Xh=(+>dqMp ?2L+UCՉj!lg<|8xa;(+!lg<|vC!lg<|8x@]9팇ѕCx@]9"""BR1<2pa;QH3x) ë<6Apyzax-pAMAtaxpA!<""" &EIqer<.kiT3?vpqM4PX a\Tݰ^kb=|>vkvz~Ug7Zs17|GQDD5 `낹]{Mf;tVC`uPz>_pgzF@]z>PFWg֏|Xh=(+3ZEDD\t>CetzFbDDDDDDDDDDDF^l\׺O$""4B}iϞ_x*m'*gty|Z{`}Mvr;ئpxÄs, 3v>_q<ѕx|q 3v>PFWb;Alet 3v>_q<|vƃAlg<|#pZ; mY#.o{w>RƳ/SƳ*>t\82 ňT:I10hʳisG*GWTJIZ/zx#"""0 oN_ADItp'qh3cWtYCO*'1;J)eKzG+Gc Wlc|6˭s0LN~^~Wyi=NiMg>ZlWyDDĮ)G" ""vp-O͖ [[&{_tR㙈NxVLDdͳ|G`ÅM~t|fDzzen6#CUk8NNf34617Zo.hqc=/4.·qQuvzusÇحq uVݰ^g_kxi<{JGw$FDD֌#C=t%orƾ'd Ƴ'/ .puؿ6`nמlƺA5UӉ,zF|qz>PFWg>GetzF@]\0 7/ټ= W [㸈|Xh=(+3ZXnj<rPY40QF7g(F"""""""Ra | x..mߌ)n)""[mNY,ŝI(@ֈI(@ p 8tH: $`8tH: $PI(@ p 8tH: $ # S)`&+a>.[˛ I(@ p +8tH:@$I(@Њg""RZtIxv \I(@Vp 8tG*N'Ka^MmHH Z5M~ -u_)ŒMge;sNsmZ̺3nf\߿oض5}fo9Zq[6p)~ݙo2D&qԅ#wmzθ#LV,֟xϓc) or]p姧q';_p׫Fi{""5EDDDDDDĵ3p?Asc{ 1 7LDD ļNiR[-ȰeNn JZ"e̘X,TҤ8g9()*r$ηmY_en3)HEj"""""""RUt-aM6ƳG%DDΪ;C`i߷ΓLX6cCOS|bdh>{;jMlƖ>s&f[9Xw0.nXnp~P>}CXqtvAuvz~5sPFWg>GetzF@]JlH8TϬ|eLʝrI N6xv`_Tf%c {L-,5t 'tY_VS7-tt74?v9pEM5_l:J<ϦKzG+Gc Wlc|e|žt׀ǻtWtsqʻ 뤀7[f/N8x~DԼ6[mV:x `s1)0h|ggA2e^ Kx&""5H(Jn87;k l}>pZbg:wmbxo3j """""""kO?It[ <3k˜kSB:s0 W> (_izaL*QÙ376//Y&f [wdUT"5HYA2}hD&5Hg""bDD55,CgnLDA ݿs[MnK2RfDzzen6#CUk8NNf34617Zo.hqc=/4.·qQuvzusÇA0 < A2}- ç6&ѿ~] T4\,A-V׭ ost鬟Auvz5sM3Z䥶G]/GU:bTDDDDDDDUxųsw։C4,4Ța~7loV8+Lt9},i}DDDDDDDDDDD|ضN'nL{Hwr!Re&"""wxa~lZq45l~to&PSPJg1Z?:إ3'Lco9]>t4C!m(o[[x_Ϊ; HML. ;?n.T6_Gw|GONf34617Zo.hqc=/4.·qQuvzusÇ>>9tϠ:b֚yHr|.k vf4QPYu Aa3v>_q܁;ѕθ|q3v>PFWv`;lete3v>qc ;w`;lete3v>PFY4sal?25IhpIY‡h=|Xh=/|83Z2b=|zF@]z>PFYbnX?5UM~t4l:/:jǖ>[M9Xw0.nXnp~z>qÇq:GTgWZs174I>~muAbn)""""""""""""""""""SәLMg""""""""""""""""""RIۻCݴGIg,\сlfs|124=]&to6cKcm|W;Bb|Ug7Z?7|8Xh=øKg +kG$LJX6`nמlƺA5UD-$c9۱q;b;vlg܎|lv?۱q;2c;(+۱q;Q]؎c;(+۱q;2򶣹 ۱}c;Q5EDDDDDDDDDDDDDDDDD`Z:\tXh=/|83Z‡h=|Xh=(+3Z'nnpgei.h=QPYݴ3tƎf|Uk848Zo:hqc=/4.·qQuvzusÇK%3L] ^m"? 8k{zﳿo3ӽ>V?|a&fxu!n?vT:~mN9z[9MY??Zk.vс7)⩿^83#Co/dߎc]wG=DeMN>xNOx)PcۀW=%֯ |;ںA*r"{j<6a՜–~Pe Hu~to{Kc ǹmorM>gLDd k˽F<2#ys8}n]gݹ/J4ݗb.(!"k\MDDDDDDDĹsoL? >;}S!#C󩤳,a069Ԥ,en_4fv61{#x&"""kRB߼odhIgYgj<nfػg Q}Ig,\сlfs|124=]&to6cKcm|W;Bb|Ug7Z?7|8qLnY tvզG,JfYxlxkuI]~~\l2gզ)5N:24ή%g ƳJjXMo/=K a낹]{Mf;ҙڦx=ZT"j<ӊg""Њg"""Vm%j<ӊg x&RtVg‡h=|Xh=/|83Z2C|xJġ?3Z3Yx憥3nbD*xW0hʳisG*GWM6 @':a^AlH"HF.>eTխ6G'ڜ=8Xr;8fsZ9~ զZ3:05<7P[m=fMiiJfYLy6]Jg*l ZbAt o'>]Mtv-}Ms[%&?9nXwv0 _ 6$g9Kø:a:aQɌS({߭ @SNli5^N XO5|ԕp'|1Omqom~~\^kN6:05GetzF|qz>PFWg2F PKW[}⺵ۓ(+7-Pjr)KyI={s6+E*/ ײJr > Ekt_.j]̇2DDDDDDDDDKƳū 2gg$DܴYu#wuZe=|8Zh=(+3Z 2b=|QDĵVd#RtE\s0hʳisG*GWTJIZWa8$򈈈kt`2I݉-PSt%;=ޤc,ke1ĆKjSD t,'n8?g&dg.:ם-5&ѓf9k9'9y>׭O5+HbƓfYWw]\Cj \tW'=~tù $#n tem9om;& W1R$DDDDDDDq6`-#D,ہJe,4p+p'(yS,e?' ,v _R+HuS?νWSM'?.~X y k{.XUR7}?~7s-1 YvO$etRa*;T( [ .jTj!ypO^T/r".b ,w; 4))A-Ț3}:%F s;j?U LN_ypYž'fD'.J}ٍg'-˙7ؗ61D?=HGt?b 'n}ڊ'4?vpv74xi ŏ/׵&I` W?^pCz_2HR3cDut7_@$3FL-:j[ LN@.I>\WtC'fǁVgNwx&iy6]?a]_1&f|5I)7}EDDDDDDĞh8+*䆳 pp0Zxev61/o2,:OlmE:TLDDDJn8*Yxk~D+ j\j x!K i<;rDO+Uw Mnw04 ~04'A`i5248vvL6M~ӽ;34L6&fwo?l4a}ܱKø:a:ŇPYpӆm`z6O Otcm+}mbY-As1W4+sLDDD*5,c~YzųmW/vl5$pm0ZYXfų GuYۍuܮ=;]&FJgπ_z>_pgzF@]z>PFW|ȸ5N gn,ώO??-91FľM^me,|GƕLDDD*5QBV< >qѿy"]G/;;uC*lUµTDDDDDDDJ37pQH.;tͥxVWYp&"""k(kYJgimqSX,KY_[ڔ@׬ ^0 ˰z>_pgzF@]z>PFW|ȘJ37*pQȭ6oٸ*iL9jom1xEpX:KQÙUj8s" g+j3jpU7W: |v SYݴ3tƎf|Uk848Zo:hqc=/4.·qQuvzusÇPYpFE2 i<^3KMmW0֊4sCs0[DDDdRÙm8X R[g4ʍgCf૕̵A_]$U^5|YxvpBn)++V"LDDD* g |5-k[mZҭ6E|35hQsbj8+;.?\m-i)(`rxMWtQeYP68XwVʊbؑW@*A p@Жm1&3|w|<(w3}[7 gӛP<;eKb^];E & g^}G}ųkΑKxsNt@=Fj^/ g8վQ8. y:,٩FwpJ/ g~\_d{W# g=2y:~RюMY"?CpaoLa3ik3^+WL+_zZgwcPˌn|400W鍂Ar0=h3/Mhz>v1=$2ŵmMHzʼXuNr6?\U^gȥaNI̛#~f=-{ I.됌3=rƶΦ[7Z\U5h47y@VMLRgMR- +78Yy,0=h3/Mhz>v1=$29:$cL'##Q:+0`8dtƶ&U5Ư5Fgi7:6.owLl"=L?dP:6c1{0+b0y˸&2Jg˸fk/v4vz%D,>1qM: Ǖj\7ܰƸzZ'ͱal_k?MXŊ燱 \q{{D.Yh dt>Xܰ=-Fb]u5?{a⇌JѦc,fbX fv#]`XF `dEI].h9X*ࡏJ4js$J2׾h;{%D,>1qM: Ǖj\7ܰƸzZW%if) \(Pa D,y]=Ls?dP:6c1{0+b0pu]fv#],H:-Lhz>z4=&/龮Fp'b^|~hzFIdM'.~t)!gz>QD,>S s(X< RsJ]`3ٙ2xC gw g_IH\^\l:Hg4=_a=|.tR+]dХ6MM~Xg4=DF|⇌JۜaxyP8,l{\M(s6`޻2Jge{ dt>Xܰ=-FˁYL/.E^g{Z3涇/~tam:b`,Vz4=D,/ G$ i'b6.gNG!RU"QT1a=QqkGe%x-߃IIFII{rpDթs;19Wnx-ャe\Qm:ZƘOHII%b /2j+`BF׋9e-X|IणL:$>VsyLZv9ʰfXZ{ұNx". w?rw7y)^[ƬÉL}'R͌ݟY6sJh\ Kr=IfKLϓԐI%}:F?@A2݉X8WgKzo'k x3L/v5 6' xcIH9םSwDl/GtuuS_g&bݎ)mq)(@Ҧ]Jƹ͛ѫ`VKz4aM~KaMF0L13i}:WR7jz:BIdo~5Jd;rrTf?T%GgH4Uv[2Pcw7Mn3^!L}'4XW^G(Es$}xyߚu^Ζt!%ugخLSw.DSk2wyD,~A0Qb?;wf Lhz>z4= 4': ^9M9gx<tV:s^pmMF󋕫j_ kRot>Ѳfv#ǣaYfx /Jg@yxpyMI:X<9?K< ˱kY,[~ʽJ{4RB(1A1(%U3L4rJJN H"d{W}F$͞:=GE2L YTKaAI{܍IۦL+ö[8,ML&$V3$]a+r8k ӿ.і2c汒>yzYIzDSm9YSϸSg"̖ae 46P:+]}g*u~^$g Ceܰvx&uq#ͫ3671.ckoxz㿕tMy&-`8k;,-epVӷ;&>+؉Ӓp0u`lWs"t,TH_xÍ2usëK"?RN2KáL?P7ág$bk$ݔk-n񫃽$͝8mwM͖`8tO3%!,*:}t$<ǝp~oz)+`,Vz4=$2á!IKUn(ȘU0zQpOgRRw",^I?1[X}6!gz>`8t(UNt@#{XD +Z<;ax˥v/@Z<[?6Qώov/RexvRz4=(٘`8-_ MLs^]r~MhzFIg CCX͌ڬ;=~t֗/~%˛鯵$2N+W(6+$}qn:&LUKme?zK/_+)azFIá[Rcuʚ/9tJge{ CFgll2:_\UczlnXctƞzYP1RRug %[Γ/`X^p3#:ЦJɧOs:N] N`X 7nYyدYFM~Xgt;Hʌ=?vh(IJҎѣ 6I3LΞ,0v{یze,G8VL_(O~طx(0`8dtƶ&U5Ư5Fgiw5_Gc32{;'`8;+}p`X<֌`7?LsK:?(,tp^W_aݯx'D,>1qM: Ǖj\7ܰƸzZˇvl^g?0fm/a,f[b,f?pRgdg4=_a=|(.L_(O~طx˸&2tV^kߢ3M~Xg4=z4=$dף$2ʓ-d,$d2Jge3L'|~rU뱹a{Z·vl^g?0fm/a,f[b,f?XF `3eU^Oh~<$bpьn'<L|u6m?_7xy>lW$rUͫ+$.a[{K:1χ-KXOK=ņHjacu6H~%eJvJYqu.e뱧޸ȘnIgZ9YAU*T4XnxI̻ʱʤvՌ:lW)fXPUkT9Pd4IRkoLIgXhcWgtz](7b]}$>{qS*/<χ-4,qSbYy8\ڍJ2 736IlMu6ȧ$[I$_}V'|s$]cz~a$޵awu6slAvKVosfⓒ:|Iw;[{Rob~`z4=DvϕXf #[(f^?%uarM#卬]>~rqp2Vxdf*w]}-m̓{%}~GGl'&HmM^:I7_7Xvr۸y"po:4LWoԵa&++3$Ik7n^= 9[ͭ.pފzrU9R]b{otjvHo~F{q/] ή^ÉX$Cgt9IPL@\)gŚ'~1xqY<8dGIdފzꈏoX%9T*^]~;ΒH^9 7n^}Yw^ri~ط^M)%bI%r',ۼ0`8d|I. k7]6 6OE+W$gP gţxfg 3tP<3`LY(xRH&^gh4{ID"F9kn#X|0q[Θn#$9aްRn7u΂:b0ϒ]3Q7y+믜wЋLud/fBr' JmsF yoi]Rx^s4u,6Q@eTHfps,~Rcl' )ޥ G?wj=n;Ūt4yR]mS3LYI>|H *OGI~6v0}G]΂U+u|- ^U긐+OJ ˏ}gnDS/zl)']pvC'&bG%a`8x9Y!L=50#@1.\9h@pUJ*Qp峼ÔE,t )2v1߿g'" i~N]ť;)םM$qϸFupph*If滱|#ۻu.?͝/UWw~PP!ҘK}y|M4b+[XU>:N7p2XnO8&_qyئNӌ+ $]u[z0gFIot7MfKcޱ/9p4*%փeppR@a.: G͕D,(J3gޡxl5@W_ .ɕh:O&X|)iiQIK8mMXP4z׳=tjri]nO.I\USPynKzDS*5=5T+QNG:nIwWg=aòm|ޥn<}}$q)%7}x-nluzAX&O?e`8ˇ;5͜3Ir3 gR0z8_ų #K؇Y(كLAxΊHlLOK.Q,tkoiN,I\Ro\_%;P8J3{^8R2KO Rү%ݐc3r%s((kpaIJqJg=(™=(ΊGxP<+3 g@pf gc(Lg@`/Jg@(™=(ΊGxP<+3 g@pf gc(ċg`gK༮%Fzx`8dd,(™=(ΊGx?{$0bIwK:\~R?yf[ٮItscM:̘3tP8k1=-ϵftGko1=-/ˊWxiO>},ERL'd gA0z8_(>I sZ{` tV$T~8Q83Y(+p6Ǘ,,A (zl3UKu+OY<㙉cL.%)3qdE (P8+2pVq^8_np=/Ί38c /l$ g/zU83x6e?PP8&NܣG~|QY9,]<3Y2ڋP:(٘ty0n~:G!H &nn8Yk^xY@/ zSu8O^gN02>*-u _ڦvܮ^y cHpRJΖ13M%xm ۿc/MG) C[L>NRǘmMgLp g0pG k3鑁wԫY(xW$]3v̏=| P(Y| ({la}).(X\*Le12ം(? t7(U0huLx`8ddF ذvxƶ`Wְ@<,Q+I~p凌@6~ϒ35qX@6~ϒ3C t4v:tlsۣحa ?;\^`3eUyk?GhGcoΓI" dØnddFq_s(JpuY2`&w( k7H2%I=oj5T4XnIMV=k̹#$`eRONKٸy*I򒚅[4~z,:h:IZ,'Yny>l%q 6JʼΟuTk4 =>@NKٸy%ÖK.vɤZIuf]tȤ= )le jO8ip-'iNEŗKzy?R䬭3gXT{jjJ+ktyg/>j FR,.ԀQ:+:~E+3nՎR1 oQ3$ot>ۋ*NdIL7Hݠvk,p0$V>?)u7gV፛WaM@%-qxP,KT=%UO>9s=*m :,XY~~}׻Qu\Z{?'^Mu8{]}o:K65O=D,nfL٢Uzf2`KYp6R2P1K)%2x&黆fKYɣx]u2pQ<+Jx.$c\.u\Uk$krlrI\< (Rmϐ`ڱdk~΂Y,}ߥ8epGK-3]UtފYN/ߊ߷`(y`Ri'޶ݛD_́L^[hh7"dGX>m/Vr^d/fyq\#5A>쬯ϯ zȬ_BLTj=%`9zZ{b̆6KzË#ieq[,H2.ꈝ3#KFv'I+uvPGUKqMj$~ g6HKE t;_%b%ppeXIp_á nPD,^̟!fT_Am[RP\{#M11=sYFvIW̸F>,CU^TXLp1c %3W5r$G/Mj3X4ߍe湱|k;YflY!Ij:@ +_ؘgr_N-Kg$HI:2x9^0E2~`9:yp+cɤ+'":ƴNt )3lISHIJ]/q4pu2~RdGcK^$g CFf4ı^(|T(G17k(('ʔ+_玗tB_S! ( gcųc < gљ*q'Jgu(FC @9zRҊݸ pgM*+}&W%-:C ' H%͘zOraoMr2뷻$ʰO*9$i ^S'K:~ɤG:I3{~I҈]*x\/Ҿ8 H[I$-72tRsTjXJΑT3N+(>n+cA{T*5-hzT`Rc؋?HVTKko)J+G2Y+i2+mux902 hH$r ~[?_Ik"Me8쪥t'U,##qD"A X[gS J!OBt#tѻtSmM= 4I4=Z!nil؃HS$b+ax/DSEw*ӟ;%H7N-wJک{I\UjOq?H:žHS|SRGsÚĶ&ruRu~hsUHw盒:mXVJ R<+1-nl*w$bHj<ᗚcD5n< n ?*ixIҊjXl%9yIoonXSp-[$--T_de,|+>8_ >LWep Vi ge?_YppHg" %D,5ʁH$<@\+p\х3U8sAR҇zZӮ'l+I+C'JIi bZ{W(ufigFs3݊.GE\%IaE`UQ3]8s3dE"Hz]&nH";#p gųp&I=-C.!lWIߓTԿ,iYf+9y7Q8؍™=( gţpI_D"$IKv헒D~Z0np gsp6Q(FQ88.YOh~<$bpȌD"OKzo4=JH:FRG"GQ΀Ax_RW \ګ˽8RL&o菟>?q¿vpf gY(bl`?d4R$yA5΀AxX)HkI_md,xz/R|Ep3{P8ΊG SpyMP:(٘<.y+2R@oHvpf gY(!#JgI52(Y<)X< 'ig3(ك?pV(! .Y:wya:p! g@pVYx:ldFf2[W(@(if}}JY`.tF%u6}0 .J g=$S.ΆTv[=-ߵ3 [I/O7SEr69p9o p*l1$\*=)gl{/Wтet<~I_p%~h$TWT8{N3̚fO\ÏhUP (࠶ΦZ+W$&sܰ^gȥ~.ΦZ/zrZ.Iwy#57Hʼ;%r6T=-u{ 9^gqۍߒ-+4D(5@W_J5RG;:O&X|0D,~.sD,~{< g(pRmxc϶ d`$2Kҽ44paI\<&yX4I!.;$}HD,~ +W }G%bq3ºlcD풎rIz(/s-`%ݪ셳:D,ȭP%(X|$pҬ,g'(]8{$bq#?G+%r^t;qP*(YFgHh=Oo엻=hH$`J` Cp/ϢIW>z_zlK~;ίzёWntp;Lc]}$'yVݲ:~&X(.U~u"Uu'ęca`o{@f)u.põ3kZ">6Gh,U*ApRPdL#J̵p߽tf+3>P83ҙ5^(g}6*=(hU^PBƊgF"&á=fs^+(؃lA̚_KzRIzLRl^UP1S*^8t-3aIV-0ZQ'iS e()iP8e2_Gje>7(i,^P6 n:J3 "H2~]W|H$NdF$+ YfY&_"gh4zIIZngE"h4%iMD"s"S)HWHu*;WOJ{gO; I%IW! > -]CHH)]Wá[#/iE C/H7H\> 6-ӷZ7%2H ;EHd:`Mh2L'<*BI۲2V<;׽Tt1>LVх3P89Q:(NY+(H$Ù,髟JW_{KW_Nj_cX%oHdZOD8 2pJR\jSһ] 8(IJ♧,pJ.gzp3P(^|P8%`%}ǍJK$\^ g`Ǖ*+ݥT u\^`3eQ:XF `3eQ:XF `3eQ:XVu䧫>I-ͷ;C1p%OICV`Ɂ nr/c0 g:J+?*O-<9Urhh1c"Orί\ .dPJgejΠI]}KΒMr.ZD,Y  g1h0ńQYfH&V䘍"bBlqYHJ~C|QI-.II+:D,P`%yfJ1ތfHv0I59&iKYl^W:NRmR8xIrܿY&tYQkHz}k 0lI7lFg\(I7$ˑ.m`' g(m)DIp3\C Et g3Q8m$%4\s,) `o%%zJۈ^K(m;$=uK`8kC4P:D{%]B '%C[\,&]8s3c Q8`3P8`F @^(/ gFik', U, sn, VH) # explicit backend given by string x = ar.do('random.uniform', size=(100, 100), like="torch") # this function now works for any backend y = noised_svd(x) # explicit inference of backend from array ar.infer_backend(y) # 'torch' ``` If you don't like the explicit [`do`](autoray.do) syntax, or simply want a drop-in replacement for existing code, you can also import the `autoray.numpy` module: ```{code-block} python from autoray import numpy as np # set a temporary default backend with ar.backend_like('cupy'): z = np.ones((3, 4), dtype='float32') np.exp(z) # array([[2.7182817, 2.7182817, 2.7182817, 2.7182817], # [2.7182817, 2.7182817, 2.7182817, 2.7182817], # [2.7182817, 2.7182817, 2.7182817, 2.7182817]], dtype=float32) ``` Custom backends and functions can be dynamically registered with: * [`register_backend`](autoray.register_backend) * [`register_function`](autoray.register_function) --- ## Advanced details ```{toctree} :caption: Guides :maxdepth: 2 installation.md automatic_dispatch.md lazy_computation.ipynb compilation.ipynb development.md ``` ```{toctree} :caption: Links :hidden: GitHub Repository ``` autoray-0.6.12/docs/installation.md000066400000000000000000000035471462076570400172630ustar00rootroot00000000000000# Installation `autoray` is available on both [pypi](https://pypi.org/project/autoray/) and [conda-forge](https://anaconda.org/conda-forge/autoray). While `autoray` is pure python and has no direct dependencies itself, the recommended distribution would be [mambaforge](https://github.com/conda-forge/miniforge#mambaforge) for installing the various backend array libraries and their dependencies. **Installing with `pip`:** ```bash pip install autoray ``` **Installing with `conda`:** ```bash conda install -c conda-forge autoray ``` **Installing with `mambaforge`:** ```bash mamba install autoray ``` ```{hint} Mamba is a faster version of `conda`, and the -forge distritbution comes pre-configured with only the `conda-forge` channel, which further simplifies and speeds up installing dependencies. ``` **Installing the latest version directly from github:** If you want to checkout the latest version of features and fixes, you can install directly from the github repository: ```bash pip install -U git+https://github.com/jcmgray/autoray.git ``` **Installing a local, editable development version:** If you want to make changes to the source code and test them out, you can install a local editable version of the package: ```bash git clone https://github.com/jcmgray/autoray.git pip install --no-deps -U -e autoray/ ``` ```{note} **No-install version:** The entirety of the automatic dispatch mechanism is contained in the single file `autoray.py`, which you could simply copy into your project if you don't want add a dependency. ``` ## Optional plotting requirements The [`autoray.lazy.draw`](autoray.lazy.draw) visualizations variously require: * [`matplotlib`](https://matplotlib.org/) * [`networkx`](https://networkx.org/) - for computational graph drawing * [`pygraphviz`](https://pygraphviz.github.io/) - optional, for better and faster graph layouts than `networkx`. autoray-0.6.12/docs/lazy_computation.ipynb000066400000000000000000027706661462076570400207230ustar00rootroot00000000000000{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Lazy computation\n", "\n", "Abstracting out the array interface using `autoray` also allows tracing through\n", "computations lazily. This is useful for a number of purposes, including:\n", "\n", "1. Investigating the computational graph, including cost and memory usage, \n", " of a calculation ahead of time.\n", "2. Doing basic computational graph optimizations such as **constant folding**\n", " and **intermediate sharing**.\n", "3. Extracting a flattened list of operations that can be compiled or \n", " translated to other libraries.\n", "\n", "This is implemented in a very lightweight fashion in `autoray` using the array \n", "backend found in [autoray.lazy](autoray.lazy).\n", "\n", "---\n", "\n", "As an illustration first let's define a simple autoray function:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%config InlineBackend.figure_formats = ['svg']\n", "\n", "from autoray import do, shape\n", "\n", "\n", "def modified_gram_schmidt(X):\n", " # n.b. performance-wise this particular function is *not*\n", " # a good candidate for a pure python implementation\n", "\n", " Q = []\n", " for j in range(0, shape(X)[0]):\n", "\n", " q = X[j, :]\n", " for i in range(0, j):\n", " rij = do('tensordot', do('conj', Q[i]), q, 1)\n", " q = q - rij * Q[i]\n", "\n", " rjj = do('linalg.norm', q, 2)\n", " Q.append(q / rjj)\n", "\n", " return do('stack', tuple(Q), axis=0)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "This function automatically dispatches based on ``X``. Let's start with a\n", "`torch` tensor:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[-0.5805, -0.4512, -0.2807, 0.3313, 0.4838, 0.1920],\n", " [ 0.3426, 0.2975, 0.3121, 0.3296, 0.7331, -0.2251],\n", " [-0.3725, 0.1051, 0.3351, -0.7794, 0.3566, 0.0568],\n", " [ 0.6077, -0.3415, -0.4634, -0.3796, 0.3007, 0.2547],\n", " [-0.0159, 0.5119, -0.0306, 0.1317, 0.0139, 0.8481],\n", " [ 0.1933, -0.5641, 0.7042, 0.1128, -0.1033, 0.3538]])" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# input array - can be anything autoray.do supports\n", "x = do('random.normal', size=(6, 6), like='torch')\n", "modified_gram_schmidt(x)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "If instead we wanted to run the function lazily, we first call \n", "[`lazy.array`](autoray.lazy.array) to wrap `x`:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from autoray import lazy\n", "\n", "lx = lazy.array(x)\n", "ly = modified_gram_schmidt(lx)\n", "ly" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "[`LazyArray`](autoray.lazy.LazyArray) objects simply stores the following:\n", "\n", "* The function to be called and backend it came from\n", "* The `args` and `kwargs` to be passed to the function\n", "* A tuple of which of these are themselves `LazyArray` objects, known as\n", " *'dependencies'*\n", "* The shape of `fn(*args, **kwargs)` were it to be computed\n", "\n", "If a lazy array is an input (as with `lx`), or has been materialized / \n", "computed, then it simply stores the result and shape of the computation, and \n", "has no reference to *how* it was computed. This means you should do any\n", "inspection of the graph before performing computation." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Inspection\n", "\n", "For speed and simplicity, there is not an actual graph data structure, instead\n", "the `LazyArray` objects simply track their dependencies (and not their \n", "'children'). However from this we can still traverse the nodes and extract an \n", "actual graph if so desired. Useful methods are:\n", "\n", "* [`LazyArray.ascend`](autoray.lazy.ascend) - generate every unique node\n", " in the graph, yielding dependencies before their children (i.e. a topological\n", " sort). This is the computational order. Nodes are also sorted by their \n", " *'depth'*, i.e. the longest distance to an input.\n", "\n", "* [`LazyArray.descend`](autoray.lazy.descend) - generate every unique node\n", " in the graph, starting from the current node. Use this if order doesn't \n", " matter.\n", "\n", "```{hint}\n", "Both these can be called as methods but also have top level function versions \n", "that also accept a sequence of `LazyArray` objects - i.e. multiple outputs.\n", "```\n", "\n", "You can also extract an actual graph using the following method:\n", "\n", "- [`LazyArray.to_nx_digraph`](autoray.lazy.LazyArray.to_nx_digraph)\n", "\n", "\n", "Some built in graph inspection methods are illustrated below:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0 stack[6, 6]\n", " 1 ├─truediv[6]\n", " 2 │ ├─getitem[6]\n", " 3 │ │ ╰─←[6, 6]\n", " 4 │ ╰─linalg_norm[]\n", " 5 │ ╰─ ... (getitem[6] from line 2)\n", " 6 ├─truediv[6]\n", " 7 │ ├─sub[6]\n", " 8 │ │ ├─getitem[6]\n", " 9 │ │ │ ╰─ ... (←[6, 6] from line 3)\n", " 10 │ │ ╰─mul[6]\n", " 11 │ │ ├─ ... (truediv[6] from line 1)\n", " 12 │ │ ╰─tensordot[]\n", " 13 │ │ ├─ ... (getitem[6] from line 8)\n", " 14 │ │ ╰─conj[6]\n", " 15 │ │ ╰─ ... (truediv[6] from line 1)\n", " 16 │ ╰─linalg_norm[]\n", " 17 │ ╰─ ... (sub[6] from line 7)\n", " 18 ├─truediv[6]\n", " 19 │ ├─sub[6]\n", " 20 │ │ ├─sub[6]\n", " 21 │ │ │ ├─getitem[6]\n", " 22 │ │ │ │ ╰─ ... (←[6, 6] from line 3)\n", " 23 │ │ │ ╰─mul[6]\n", " 24 │ │ │ ├─ ... (truediv[6] from line 1)\n", " 25 │ │ │ ╰─tensordot[]\n", " 26 │ │ │ ├─ ... (getitem[6] from line 21)\n", " 27 │ │ │ ╰─conj[6]\n", " 28 │ │ │ ╰─ ... (truediv[6] from line 1)\n", " 29 │ │ ╰─mul[6]\n", " 30 │ │ ├─ ... (truediv[6] from line 6)\n", " 31 │ │ ╰─tensordot[]\n", " 32 │ │ ├─ ... (sub[6] from line 20)\n", " 33 │ │ ╰─conj[6]\n", " 34 │ │ ╰─ ... (truediv[6] from line 6)\n", " 35 │ ╰─linalg_norm[]\n", " 36 │ ╰─ ... (sub[6] from line 19)\n", " 37 ├─truediv[6]\n", " 38 │ ├─sub[6]\n", " 39 │ │ ├─sub[6]\n" ] } ], "source": [ "# print the lazy computation graph\n", "ly.show(max_lines=40)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'stack': 1,\n", " 'truediv': 6,\n", " 'linalg_norm': 6,\n", " 'sub': 15,\n", " 'mul': 15,\n", " 'getitem': 6,\n", " 'None': 1,\n", " 'tensordot': 15,\n", " 'conj': 15}" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# how many times each function was called\n", "ly.history_fn_frequencies()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:32:55.014587\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# the counts as a pie chart\n", "ly.plot_history_stats(fn='count')" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "36" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# the largest node encountered\n", "ly.history_max_size()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:32:56.250746\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# the sizes of all nodes encountered, in log 2\n", "ly.plot_history_functions(log=2)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "In all the above you can also customize the function that is computed for each \n", "node, for instance to estimate FLOPs." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "72" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# the peak memory required for all intermediates when \n", "# traversing the graph in computational order\n", "ly.history_peak_size()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:32:57.302700\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# the total memory required for all intermediates when\n", "# traversing the graph in computational order\n", "ly.plot_history_size_footprint()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:32:57.847914\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# plot the graph as circuit diagram\n", "ly.plot_circuit()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:32:58.803755\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# plot the graph in using networkx or pygraphviz\n", "ly.plot_graph(layout='sfdp')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Computation\n", "\n", "When you are ready to actually perform the computation, you can call \n", "[`LazyArray.compute`](autoray.lazy.LazyArray.compute) on output nodes:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[-0.5805, -0.4512, -0.2807, 0.3313, 0.4838, 0.1920],\n", " [ 0.3426, 0.2975, 0.3121, 0.3296, 0.7331, -0.2251],\n", " [-0.3725, 0.1051, 0.3351, -0.7794, 0.3566, 0.0568],\n", " [ 0.6077, -0.3415, -0.4634, -0.3796, 0.3007, 0.2547],\n", " [-0.0159, 0.5119, -0.0306, 0.1317, 0.0139, 0.8481],\n", " [ 0.1933, -0.5641, 0.7042, 0.1128, -0.1033, 0.3538]])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ly.compute()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "```{note}\n", "[`LazyArray`](autoray.lazy.LazyArray) objects clear references to their \n", "dependencies once computed and simply store the result and shape. This is to\n", "aid garbage collection and reduce memory usage.\n", "```\n", "\n", "The computation is done non-recursively. You can compute multiple outputs at \n", "once with the function [`lazy.compute`](autoray.lazy.compute):" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(tensor([-0.5805, -0.4512, -0.2807, 0.3313, 0.4838, 0.1920]),\n", " tensor([ 0.5805, 0.4512, 0.2807, -0.3313, -0.4838, -0.1920]))" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lazy.compute([ly[0], -ly[0]])" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Sharing intermediates\n", "\n", "A basic computational graph optimization that `autoray` can do is to \n", "automatically cache [`LazyArray`](autoray.lazy.LazyArray) objects that are\n", "computed with the same inputs. This is achieved with the context manager:\n", "\n", "* [`lazy.shared_intermediates`](autoray.lazy.shared_intermediates)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "with lazy.shared_intermediates():\n", " ly_shared = modified_gram_schmidt(lx)\n", "\n", "# reconstruct the non-shared lazy graph\n", "ly = modified_gram_schmidt(lx)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "In this case you can see a slight reduction in the number of unique nodes:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(80, 70)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ly.history_num_nodes(), ly_shared.history_num_nodes()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:33:02.444819\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ly_shared.plot_circuit()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### `Function`, `Variable`, and constant folding\n", "\n", "Sometimes you may want to think of certain input nodes as variables, which \n", "might change from call to call, and any other inputs as constants. One option\n", "is to create 'empty' \n", "[`LazyArray`](autoray.lazy.LazyArray) instances with \n", "[`lazy.Variable`](autoray.lazy.Variable), which just \n", "takes a shape and optionally backend, and uses a placeholder for the data." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:33:03.688854\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lx = lazy.Variable((6, 6), backend='numpy')\n", "\n", "ly = lazy.array(do('random.normal', size=(6, 6), like='numpy'))\n", "ly += ly.T\n", "ly **= 2 \n", "\n", "lz = ly / (lx + 3)\n", "\n", "lz.plot_circuit()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "If we tried to call `lz.compute()` now, we would get an error relating to\n", "attempting to use the placeholder data, we would need to substitute it in \n", "first.\n", "\n", "However we can compute all the nodes that don't depend on the variable like so:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-03-22T19:33:04.656028\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.0, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lz.compute_constants(variables=[lx])\n", "\n", "# now all that remain is parts of the computational graph that depend on lx\n", "lz.plot_circuit()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "If one wants to extract the function that the computational graph represents, \n", "in order to call it repeatedly with different inputs, then one can create a \n", "[`lazy.Function`](autoray.lazy.Function):" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ " array_like>" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f = lazy.Function(inputs=lx, outputs=lz)\n", "f" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "```{hint}\n", "By default, [`lazy.Function`](autoray.lazy.Function) will compute constants, \n", "as we did above, this can be disabled by passing `fold_constants=False`.\n", "```" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1.60841992e-04, 8.12123221e-01, 1.97831460e+00, 1.13263167e-01,\n", " 2.33488356e-01, 4.08718533e-03],\n", " [2.18269736e-01, 1.04576049e+00, 5.29610184e-01, 6.86544110e-01,\n", " 4.30559858e-03, 1.45473766e+00],\n", " [3.47257338e+00, 1.07335438e+00, 1.32390470e-01, 7.11823564e-01,\n", " 1.11092912e-01, 2.23358234e+00],\n", " [1.87099522e-01, 5.45491213e-01, 7.87780835e-01, 1.07803626e+00,\n", " 5.32992554e-03, 9.09088651e-01],\n", " [2.97641208e-01, 3.39287590e-03, 5.68403161e-02, 4.84043497e-03,\n", " 9.40752758e-01, 2.27492826e+00],\n", " [2.94115949e-03, 1.52417836e+00, 1.55115629e+00, 6.83576849e-01,\n", " 5.76864117e-01, 1.09412185e-03]])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# create a numpy array\n", "x = do('random.normal', size=(6, 6), like='numpy')\n", "\n", "# now we can call it on a raw numpy array\n", "f(x)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "```{note}\n", "Such a function is created with the backend specific functions injected in, see\n", "[the compilation](compilation) section and [`autojit`](autoray.autojit) for \n", "creating such functions just in time for the right backend.\n", "```\n", "\n", "You can view the function's source code using\n", "[Function.print_source](autoray.lazy.Function.print_source), or extract it \n", "from [`LazyArray`](autoray.lazy.LazyArray) objects yourself with \n", "[lazy.get_source](autoray.lazy.get_source)." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Comparison to alternatives: \n", " \n", "The main difference to other approaches is that `autoray` is super simple and \n", "lightweight, and is not concerned with complex optimizations or modes of \n", "execution. \n", "\n", "As demonstrated below, the dispatch mechanism in `autoray` is compatible with\n", "tensors objects from both these libraries, so it is not an either/or situation. \n", "The comparison is only with regard to when you might want to use lazy \n", "computational graph tracing.\n", "\n", "\n", "### `dask`\n", "\n", "There are many reasons to use [dask](https://dask.org/), but it incurs a pretty \n", "large overhead for big computational graphs with comparatively small \n", "operations. Calling and computing the ``modified_gram_schmidt`` function for a \n", "100x100 matrix (20,102 computational nodes) with ``dask.array`` takes ~1min \n", "whereas with ``lazy.array`` it takes ~0.2s:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import dask.array as da\n", "\n", "x = do('random.normal', size=(100, 100), like='numpy')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 58.5 s, sys: 315 ms, total: 58.8 s\n", "Wall time: 58.2 s\n" ] } ], "source": [ "%%time\n", "dx = da.array(x)\n", "dy = modified_gram_schmidt(dx)\n", "y = dy.compute()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 204 ms, sys: 12.1 ms, total: 216 ms\n", "Wall time: 208 ms\n" ] } ], "source": [ "%%time\n", "lx = lazy.array(x)\n", "ly = modified_gram_schmidt(lx)\n", "y = ly.compute()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Moreover `autoray.lazy` can also lazily wrap around more backends such\n", "as `torch` due to the [automatic dispatch](automatic_dispatch) mechanism." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### `aesara`\n", "\n", "[`aesara`](https://aesara.readthedocs.io) is another nice library, and the \n", "successor to [`theano`](https://github.com/Theano/Theano). It is much more \n", "heavyweight than `autoray` with a focus on optimizations, symbolic \n", "manipulations such as gradients, and compilation to \n", "specific targets (`jax`, `numba` or `C`). It also supports dynamic shapes, \n", "whereas `autoray` restricts itself to static shapes.\n", "\n", "`aesara` is indeed quite compatible with `autoray`, but the fact that \n", "it often falls back to dynamic/unknown shapes occasionally makes things \n", "tricky.\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "import aesara\n", "import aesara.tensor as at\n", "\n", "# create equivalent of a Variable\n", "ax = at.tensor(\"float64\", (10, 10))" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 175 ms, sys: 0 ns, total: 175 ms\n", "Wall time: 174 ms\n" ] } ], "source": [ "%%time\n", "# construct the computational graph\n", "ay = modified_gram_schmidt(ax)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Join.0 (None, None)\n" ] } ], "source": [ "# aesara falls back to dynamic shapes quite often, which can be tricky\n", "print(ay, shape(ay))" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# # if you want to view the graph, you could use pydotprint:\n", "# aesara.printing.pydotprint(ay)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Actually compiling the graph can take quite a long time for anything but\n", "quite small graphs (similarly to `jax`/XLA):" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 5min 53s, sys: 189 ms, total: 5min 54s\n", "Wall time: 5min 54s\n" ] } ], "source": [ "%%time\n", "f = aesara.function([ax], ay)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "However, the function produced, should be heavily optimized, and ought to be \n", "much faster than a pure python function for computations not dominated by large\n", "linear algebra operations." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0.08811928, 0.45177107, -0.23512127, 0.56826279, -0.10209893,\n", " 0.04483325, 0.00321893, -0.06721217, 0.23305057, 0.58194387],\n", " [ 0.20286314, -0.16805831, -0.22599417, 0.12787872, -0.0876818 ,\n", " -0.34810252, -0.36127286, -0.46075707, -0.61894859, 0.09165501],\n", " [ 0.13412721, 0.36994813, 0.700074 , -0.06636773, -0.23315896,\n", " -0.44683645, 0.13946412, -0.26698148, 0.07190328, -0.02673288],\n", " [ 0.1407475 , 0.29877271, 0.14226686, -0.02852857, 0.04154398,\n", " 0.75386262, 0.07329936, -0.44735181, -0.25730248, -0.16773645],\n", " [ 0.04966494, 0.17005891, -0.26316584, -0.51207777, 0.319918 ,\n", " -0.1089547 , -0.302915 , -0.43376454, 0.48719139, 0.07516769],\n", " [ 0.02527629, -0.27882853, 0.49141276, 0.35693951, 0.63621879,\n", " 0.07151982, -0.34254243, -0.019437 , 0.0824143 , 0.13538384],\n", " [ 0.76372311, 0.15424796, -0.13639341, -0.06633823, 0.40270286,\n", " -0.13394064, 0.31463354, 0.2651581 , -0.12780612, -0.06467988],\n", " [ 0.46141628, -0.31660808, -0.04249231, 0.30744742, -0.37957198,\n", " 0.08494901, -0.18073615, -0.13298267, 0.46522187, -0.41527374],\n", " [-0.27891892, -0.11882063, -0.1926552 , 0.33001037, 0.3000039 ,\n", " -0.2147232 , 0.58955971, -0.43279871, 0.09319829, -0.28700755],\n", " [ 0.19026913, -0.54471619, 0.12261167, -0.24092508, -0.14976652,\n", " 0.14350703, 0.39536722, -0.21896414, 0.07494096, 0.58403977]])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = do('random.normal', size=(10, 10), like='numpy')\n", "f(x)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Hopefully `aesara` will be another possible target for \n", "[`autoray.autojit`](autoray.autojit), eventually." ] } ], "metadata": { "kernelspec": { "display_name": "numpy", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.9" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 } autoray-0.6.12/docs/make.bat000066400000000000000000000013751462076570400156420ustar00rootroot00000000000000@ECHO OFF pushd %~dp0 REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set SOURCEDIR=. set BUILDDIR=_build %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.https://www.sphinx-doc.org/ exit /b 1 ) if "%1" == "" goto help %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% goto end :help %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% :end popd autoray-0.6.12/pyproject.toml000066400000000000000000000007761462076570400162250ustar00rootroot00000000000000[build-system] build-backend = "setuptools.build_meta" requires = [ "setuptools>=45", "setuptools_scm[toml]>=6.2" ] [tool.setuptools_scm] write_to = "autoray/_version.py" [tool.pytest.ini_options] testpaths = "tests" filterwarnings = "once" [tool.coverage.run] omit = ["*/autoray/experimental/*"] source = ["autoray"] [tool.pylama] ignore = "C901" max_line_length = 79 [tool.ruff] line-length = 79 target-version = "py38" ignore = ["E741"] [tool.black] line-length = 79 target-version = ['py38'] autoray-0.6.12/setup.py000066400000000000000000000031171462076570400150130ustar00rootroot00000000000000from setuptools import setup, find_packages def readme(): with open("README.md") as f: long_desc = f.read() # strip out the raw html images? return long_desc short_desc = "Abstract your array operations." setup( name="autoray", description=short_desc, long_description=readme(), long_description_content_type="text/markdown", url="http://github.com/jcmgray/autoray", project_urls={ # Optional 'Bug Reports': 'https://github.com/jcmgray/autoray/issues', 'Source': 'https://github.com/jcmgray/autoray/', }, author="Johnnie Gray", author_email="johnniemcgray@gmail.com", license="Apache", packages=find_packages(exclude=["deps", "tests*"]), extras_require={ "tests": [ "numpy", "coverage", "pytest", "pytest-cov", ], 'docs': [ 'sphinx>=2.0', 'sphinx-autoapi', 'astroid<3', 'sphinx-copybutton', 'myst-nb', 'furo', 'setuptools_scm', 'ipython!=8.7.0', ], }, python_requires=">=3.8", classifiers=[ "Development Status :: 3 - Alpha", "License :: OSI Approved :: Apache Software License", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", ], keywords="array agnostic numeric numpy cupy dask tensorflow jax autograd", ) autoray-0.6.12/tests/000077500000000000000000000000001462076570400144415ustar00rootroot00000000000000autoray-0.6.12/tests/__init__.py000066400000000000000000000000001462076570400165400ustar00rootroot00000000000000autoray-0.6.12/tests/test_autocompile.py000066400000000000000000000045631462076570400204030ustar00rootroot00000000000000import pytest from autoray import do, autojit, infer_backend, to_numpy, shape from .test_autoray import BACKENDS, gen_rand from numpy.testing import assert_allclose BACKENDS = [ p for p in BACKENDS if p.values[0] in ("jax", "torch", "tensorflow") ] def modified_gram_schmidt(X): Q = [] for j in range(0, shape(X)[0]): q = X[j, :] for i in range(0, j): rij = do("tensordot", do("conj", Q[i]), q, axes=1) q = q - rij * Q[i] rjj = do("linalg.norm", q, 2) Q.append(q / rjj) return do("stack", tuple(Q), axis=0) @pytest.fixture def mgs_case(): x = gen_rand((10, 10), "numpy") y = modified_gram_schmidt(x) return x, y @pytest.mark.parametrize("share_intermediates", [False, True]) @pytest.mark.parametrize("nested", [False, True]) def test_compile_python(mgs_case, share_intermediates, nested): x, y = mgs_case compiler_opts = {"python": {"share_intermediates": share_intermediates}} mgs = autojit(modified_gram_schmidt, compiler_opts=compiler_opts) if nested: mgs = autojit(mgs, compiler_opts=compiler_opts) y2 = mgs(x) assert_allclose(y, y2) @pytest.mark.parametrize("backend", BACKENDS) def test_others_numpy(backend, mgs_case): x, y = mgs_case mgs = autojit(modified_gram_schmidt) y2 = mgs(x, backend=backend) assert infer_backend(y2) == "numpy" assert_allclose(y, y2) @pytest.mark.parametrize("backend", BACKENDS) def test_autodispatch(backend, mgs_case): x, y = mgs_case x = do("array", x, like=backend) mgs = autojit(modified_gram_schmidt) y2 = mgs(x, backend=backend) assert infer_backend(y2) == backend assert_allclose(y, to_numpy(y2)) def test_complicated_signature(): @autojit def foo(a, b, c): a1, a2 = a b1 = b["1"] c1, c2 = c["sub"] return do("sum", do("stack", (a1, a2, b1, c1, c2)), axis=0) x = do("random.uniform", size=(5, 7), like="numpy") y = foo((x[0, :], x[1, :]), {"1": x[2, :]}, c={"sub": (x[3, :], x[4, :])}) assert_allclose(y, x.sum(0)) def test_multi_output(): @autojit def foo(a, b, c): a = a - do("sum", b) b = b - do("sum", a) return a + c, b - c a = gen_rand((2, 3), "numpy") b = gen_rand((4, 5), "numpy") x, y = foo(a, b, 1) assert_allclose(x, a - b.sum() + 1) assert_allclose(y, b - (a - b.sum()).sum() - 1)autoray-0.6.12/tests/test_autoray.py000066400000000000000000000655401462076570400175500ustar00rootroot00000000000000import importlib.util import pytest import autoray as ar from autoray import shape import numpy as np # find backends to tests BACKENDS = [pytest.param("numpy")] for lib in ["cupy", "dask", "tensorflow", "torch", "mars", "jax", "sparse"]: if importlib.util.find_spec(lib): BACKENDS.append(pytest.param(lib)) if lib == "jax": import os import jax jax.config.update("jax_enable_x64", True) jax.config.update("jax_platform_name", "cpu") os.environ["XLA_PYTHON_CLIENT_ALLOCATOR"] = "platform" else: BACKENDS.append( pytest.param( lib, marks=pytest.mark.skipif(True, reason=f"No {lib}.") ) ) JAX_RANDOM_KEY = None def gen_rand(shape, backend, dtype="float64"): if "complex" in dtype: re = gen_rand(shape, backend) im = gen_rand(shape, backend) return ar.astype(ar.do("complex", re, im), dtype) if backend == "jax": from jax import random as jrandom global JAX_RANDOM_KEY if JAX_RANDOM_KEY is None: JAX_RANDOM_KEY = jrandom.PRNGKey(42) JAX_RANDOM_KEY, subkey = jrandom.split(JAX_RANDOM_KEY) return jrandom.uniform(subkey, shape=shape, dtype=dtype) elif backend == "sparse": x = ar.do( "random.uniform", size=shape, like=backend, density=0.5, format="coo", fill_value=0, ) else: x = ar.do("random.uniform", size=shape, like=backend) x = ar.astype(x, ar.to_backend_dtype(dtype, backend)) assert ar.get_dtype_name(x) == dtype return x @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("fn", ["sqrt", "exp", "sum"]) def test_basic(backend, fn): if (backend == "ctf") and fn in ("sqrt", "sum"): pytest.xfail("ctf doesn't have sqrt, and converts sum output to numpy") x = gen_rand((2, 3, 4), backend) y = ar.do(fn, x) if (backend == "sparse") and (fn == "sum"): pytest.xfail("Sparse 'sum' outputs dense.") assert ar.infer_backend(x) == ar.infer_backend(y) == backend def test_infer_backend_multi(): x = 1.0 y = gen_rand((2, 3), "numpy") z = ar.lazy.Variable((4, 5)) assert ar.infer_backend_multi(x) == "builtins" assert ar.infer_backend_multi(x, y) == "numpy" assert ar.infer_backend_multi(x, y, z) == "autoray.lazy" def test_raises_import_error_when_missing(): with pytest.raises(ImportError): ar.do("anonexistantfunction", 1, like="numpy") with pytest.raises(ImportError): ar.do("ones", 1, like="anonexistantbackend") @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize( "fn,args", [ (ar.conj, []), (ar.transpose, []), (ar.real, []), (ar.imag, []), (ar.reshape, [(5, 3)]), ], ) def test_attribute_prefs(backend, fn, args): if (backend == "torch") and fn in (ar.real, ar.imag): pytest.xfail("Pytorch doesn't support complex numbers yet...") x = gen_rand((3, 5), backend) y = fn(x, *args) assert ar.infer_backend(x) == ar.infer_backend(y) == backend def modified_gram_schmidt(X): Q = [] for j in range(0, shape(X)[0]): q = X[j, :] for i in range(0, j): rij = ar.do("tensordot", ar.do("conj", Q[i]), q, 1) q = q - rij * Q[i] rjj = ar.do("linalg.norm", q, 2) Q.append(q / rjj) return ar.do("stack", Q, axis=0) @pytest.mark.parametrize("backend", BACKENDS) def test_mgs(backend): if backend == "sparse": pytest.xfail("Sparse doesn't support linear algebra yet...") if backend == "ctf": pytest.xfail("ctf does not have 'stack' function.") x = gen_rand((3, 5), backend) Ux = modified_gram_schmidt(x) y = ar.do("sum", Ux @ ar.dag(Ux)) assert ar.to_numpy(y) == pytest.approx(3) def modified_gram_schmidt_np_mimic(X): from autoray import numpy as np print(np) Q = [] for j in range(0, shape(X)[0]): q = X[j, :] for i in range(0, j): rij = np.tensordot(np.conj(Q[i]), q, 1) q = q - rij * Q[i] rjj = np.linalg.norm(q, 2) Q.append(q / rjj) return np.stack(Q, axis=0) def test_numpy_mimic_dunder_methods(): from abc import ABC from autoray import numpy as np class Base(ABC): pass assert isinstance(np, object) assert not isinstance(np, Base) print(np) dir(np) @pytest.mark.parametrize("backend", BACKENDS) def test_mgs_np_mimic(backend): if backend == "sparse": pytest.xfail("Sparse doesn't support linear algebra yet...") if backend == "ctf": pytest.xfail("ctf does not have 'stack' function.") x = gen_rand((3, 5), backend) Ux = modified_gram_schmidt_np_mimic(x) y = ar.do("sum", Ux @ ar.dag(Ux)) assert ar.to_numpy(y) == pytest.approx(3) @pytest.mark.parametrize("backend", BACKENDS) def test_linalg_svd_square(backend): if backend == "sparse": pytest.xfail("Sparse doesn't support linear algebra yet...") x = gen_rand((5, 4), backend) U, s, V = ar.do("linalg.svd", x) assert ( ar.infer_backend(x) == ar.infer_backend(U) == ar.infer_backend(s) == ar.infer_backend(V) == backend ) y = U @ ar.do("diag", s, like=x) @ V diff = ar.do("sum", abs(y - x)) assert ar.to_numpy(diff) < 1e-8 @pytest.mark.parametrize("backend", BACKENDS) def test_translator_random_uniform(backend): from autoray import numpy as anp if backend == "sparse": pytest.xfail("Sparse will have zeros") x = anp.random.uniform(low=-10, size=(4, 5), like=backend) assert (ar.to_numpy(x) > -10).all() assert (ar.to_numpy(x) < 1.0).all() # test default single scalar x = anp.random.uniform(low=1000, high=2000, like=backend) assert 1000 <= ar.to_numpy(x) < 2000 @pytest.mark.parametrize("backend", BACKENDS) def test_translator_random_normal(backend): if backend == "ctf": pytest.xfail() from autoray import numpy as anp x = anp.random.normal(100.0, 0.1, size=(4, 5), like=backend) if backend == "sparse": assert (x.data > 90.0).all() assert (x.data < 110.0).all() return assert (ar.to_numpy(x) > 90.0).all() assert (ar.to_numpy(x) < 110.0).all() if backend == "tensorflow": x32 = ar.do( "random.normal", 100.0, 0.1, dtype="float32", size=(4, 5), like=backend, ) assert x32.dtype == "float32" assert (ar.to_numpy(x32) > 90.0).all() assert (ar.to_numpy(x32) < 110.0).all() # test default single scalar x = anp.random.normal(loc=1500, scale=10, like=backend) assert 1000 <= ar.to_numpy(x) < 2000 @pytest.mark.parametrize("backend", BACKENDS) def test_tril(backend): x = gen_rand((4, 4), backend) xl = ar.do("tril", x) xln = ar.to_numpy(xl) assert xln[0, 1] == 0.0 if backend != "sparse": # this won't work for sparse because density < 1 assert (xln > 0.0).sum() == 10 xl = ar.do("tril", x, k=1) xln = ar.to_numpy(xl) if backend != "sparse": # this won't work for sparse because density < 1 assert xln[0, 1] != 0.0 assert xln[0, 2] == 0.0 if backend != "sparse": # this won't work for sparse because density < 1 assert (xln > 0.0).sum() == 13 if backend == "tensorflow": with pytest.raises(ValueError): ar.do("tril", x, -1) @pytest.mark.parametrize("backend", BACKENDS) def test_triu(backend): x = gen_rand((4, 4), backend) xl = ar.do("triu", x) xln = ar.to_numpy(xl) assert xln[1, 0] == 0.0 if backend != "sparse": # this won't work for sparse because density < 1 assert (xln > 0.0).sum() == 10 xl = ar.do("triu", x, k=-1) xln = ar.to_numpy(xl) if backend != "sparse": # this won't work for sparse because density < 1 assert xln[1, 0] != 0.0 assert xln[2, 0] == 0.0 if backend != "sparse": # this won't work for sparse because density < 1 assert (xln > 0.0).sum() == 13 if backend == "tensorflow": with pytest.raises(ValueError): ar.do("triu", x, 1) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("shape", [(4, 3), (4, 4), (3, 4)]) def test_qr_thin_square_fat(backend, shape): if backend == "sparse": pytest.xfail("Sparse doesn't support linear algebra yet...") x = gen_rand(shape, backend) Q, R = ar.do("linalg.qr", x) xn, Qn, Rn = map(ar.to_numpy, (x, Q, R)) assert ar.do("allclose", xn, Qn @ Rn) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("array_dtype", ["int", "float", "bool"]) def test_count_nonzero(backend, array_dtype): if backend == "mars": import mars if tuple(map(int, mars.__version__.split("."))) < (0, 4, 0): pytest.xfail("mars count_nonzero bug fixed in version 0.4.") if backend == "ctf" and array_dtype == "bool": pytest.xfail("ctf doesn't support bool array dtype") if array_dtype == "int": x = ar.do("array", [0, 1, 2, 0, 3], like=backend) elif array_dtype == "float": x = ar.do("array", [0.0, 1.0, 2.0, 0.0, 3.0], like=backend) elif array_dtype == "bool": x = ar.do("array", [False, True, True, False, True], like=backend) nz = ar.do("count_nonzero", x) assert ar.to_numpy(nz) == 3 def test_pseudo_submodules(): x = gen_rand((2, 3), "numpy") xT = ar.do("numpy.transpose", x, like="autoray") assert shape(xT) == (3, 2) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("creation", ["ones", "zeros"]) @pytest.mark.parametrize( "dtype", ["float32", "float64", "complex64", "complex128"] ) def test_dtype_specials(backend, creation, dtype): import numpy as np x = ar.do(creation, shape=(2, 3), like=backend) if backend == "torch" and "complex" in dtype: pytest.xfail("Pytorch doesn't support complex numbers yet...") x = ar.astype(x, dtype) assert ar.get_dtype_name(x) == dtype x = ar.to_numpy(x) assert isinstance(x, np.ndarray) assert ar.get_dtype_name(x) == dtype @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("real_dtype", ["float32", "float64"]) def test_complex_creation(backend, real_dtype): if backend == "torch": pytest.xfail("Pytorch doesn't support complex numbers yet...") if (backend == "sparse") and (real_dtype == "float32"): pytest.xfail( "Bug in sparse where single precision isn't maintained " "after scalar multiplication." ) if (backend == "ctf") and (real_dtype == "float32"): pytest.xfail( "ctf currently doesn't preserve single precision when " "multiplying by python scalars." ) x = ar.do( "complex", ar.astype( ar.do("random.uniform", size=(3, 4), like=backend), real_dtype ), ar.astype( ar.do("random.uniform", size=(3, 4), like=backend), real_dtype ), ) assert ( ar.get_dtype_name(x) == {"float32": "complex64", "float64": "complex128"}[real_dtype] ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize( "dtype_in,dtype_out", [ ("float32", "float32"), ("float64", "float64"), ("complex64", "float32"), ("complex128", "float64"), ], ) def test_real_imag(backend, dtype_in, dtype_out): x = gen_rand((3, 4), backend, dtype_in) re = ar.do("real", x) im = ar.do("imag", x) assert ar.infer_backend(re) == backend assert ar.infer_backend(im) == backend assert ar.get_dtype_name(re) == dtype_out assert ar.get_dtype_name(im) == dtype_out assert ar.do("allclose", ar.to_numpy(x).real, ar.to_numpy(re)) assert ar.do("allclose", ar.to_numpy(x).imag, ar.to_numpy(im)) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize( "dtype", ["float32", "float64", "complex64", "complex128"], ) def test_linalg_solve(backend, dtype): if backend == "sparse": pytest.xfail("Sparse doesn't support linear algebra yet...") A = gen_rand((4, 4), backend, dtype) b = gen_rand((4, 1), backend, dtype) x = ar.do("linalg.solve", A, b) assert ar.do( "allclose", ar.to_numpy(A @ x), ar.to_numpy(b), rtol=1e-3, atol=1e-6 ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize( "dtype", ["float32", "float64", "complex64", "complex128"], ) def test_linalg_eigh(backend, dtype): if backend == "sparse": pytest.xfail("sparse doesn't support linalg.eigh yet.") if backend == "dask": pytest.xfail("dask doesn't support linalg.eigh yet.") if backend == "mars": pytest.xfail("mars doesn't support linalg.eigh yet.") if (backend == "torch") and ("complex" in dtype): pytest.xfail("Pytorch doesn't fully support complex yet.") A = gen_rand((4, 4), backend, dtype) A = A + ar.dag(A) el, ev = ar.do("linalg.eigh", A) B = (ev * ar.reshape(el, (1, -1))) @ ar.dag(ev) assert ar.do("allclose", ar.to_numpy(A), ar.to_numpy(B), rtol=1e-3) @pytest.mark.parametrize("backend", BACKENDS) def test_pad(backend): if backend == "sparse": pytest.xfail("sparse doesn't support linalg.eigh yet.") if backend == "mars": pytest.xfail("mars doesn't support linalg.eigh yet.") A = gen_rand((3, 4, 5), backend) for pad_width, new_shape in [ # same pad before and after for every axis (2, (7, 8, 9)), # same pad for every axis (((1, 2),), (6, 7, 8)), # different pad for every axis (((4, 3), (2, 4), (3, 2)), (10, 10, 10)), ]: B = ar.do("pad", A, pad_width) assert shape(B) == new_shape assert ar.to_numpy(ar.do("sum", A)) == pytest.approx( ar.to_numpy(ar.do("sum", B)) ) @pytest.mark.parametrize("backend", BACKENDS) def test_register_function(backend): x = ar.do("ones", shape=(2, 3), like=backend) def direct_fn(x): return 1 # first test we can provide the function directly ar.register_function(backend, "test_register", direct_fn) assert ar.do("test_register", x) == 1 def wrap_fn(fn): def new_fn(*args, **kwargs): res = fn(*args, **kwargs) return res + 1 return new_fn # then check we can wrap the old (previous) function ar.register_function(backend, "test_register", wrap_fn, wrap=True) assert ar.do("test_register", x) == 2 @pytest.mark.parametrize("backend", BACKENDS) def test_take(backend): if backend == "sparse": pytest.xfail("sparse doesn't support take yet") num_inds = 4 A = gen_rand((2, 3, 4), backend) if backend == "jax": # gen_rand doesn't work with ints for JAX ind = gen_rand((num_inds,), "numpy", dtype="int64") else: ind = gen_rand((num_inds,), backend, dtype="int64") # Take along axis 1, and check if result makes sense B = ar.do("take", A, ind, axis=1) assert shape(B) == (2, 4, 4) for i in range(num_inds): assert ar.do( "allclose", ar.to_numpy(A[:, ind[0], :]), ar.to_numpy(B[:, 0, :]) ) assert ar.infer_backend(A) == ar.infer_backend(B) @pytest.mark.parametrize("backend", BACKENDS) def test_concatenate(backend): mats = [gen_rand((2, 3, 4), backend) for _ in range(3)] # Concatenate along axis 1, check if shape is correct # also check if automatically inferring backend works mats_concat1 = ar.do("concatenate", mats, axis=1) mats_concat2 = ar.do("concatenate", mats, axis=1, like=backend) assert shape(mats_concat1) == shape(mats_concat2) == (2, 9, 4) assert ( backend == ar.infer_backend(mats_concat1) == ar.infer_backend(mats_concat2) ) @pytest.mark.parametrize("backend", BACKENDS) def test_stack(backend): mats = [gen_rand((2, 3, 4), backend) for _ in range(3)] # stack, creating a new axis (at position 0) # also check if automatically inferring backend works mats_stack1 = ar.do("stack", mats) mats_stack2 = ar.do("stack", mats, like=backend) assert shape(mats_stack1) == shape(mats_stack2) == (3, 2, 3, 4) assert ( backend == ar.infer_backend(mats_stack1) == ar.infer_backend(mats_stack2) ) @pytest.mark.parametrize("backend", BACKENDS) def test_einsum(backend): if backend == "sparse": pytest.xfail("sparse doesn't support einsum yet") A = gen_rand((2, 3, 4), backend) B = gen_rand((3, 4, 2), backend) C1 = ar.do("einsum", "ijk,jkl->il", A, B, like=backend) C2 = ar.do("einsum", "ijk,jkl->il", A, B) if backend not in ("torch", "tensorflow"): # this syntax is not supported C3 = ar.do("einsum", A, [0, 1, 2], B, [1, 2, 3], [0, 3]) else: C3 = C1 C4 = ar.do("reshape", A, (2, 12)) @ ar.do("reshape", B, (12, 2)) assert shape(C1) == shape(C2) == shape(C3) == (2, 2) assert ar.do("allclose", ar.to_numpy(C1), ar.to_numpy(C4)) assert ar.do("allclose", ar.to_numpy(C2), ar.to_numpy(C4)) assert ar.do("allclose", ar.to_numpy(C3), ar.to_numpy(C4)) assert ( ar.infer_backend(C1) == ar.infer_backend(C2) == ar.infer_backend(C3) == ar.infer_backend(C4) == backend ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("int_or_section", ["int", "section"]) def test_split(backend, int_or_section): if backend == "sparse": pytest.xfail("sparse doesn't support split yet") if backend == "dask": pytest.xfail("dask doesn't support split yet") A = ar.do("ones", (10, 20, 10), like=backend) if int_or_section == "section": sections = [2, 4, 14] splits = ar.do("split", A, sections, axis=1) assert len(splits) == 4 assert splits[3].shape == (10, 6, 10) else: splits = ar.do("split", A, 5, axis=2) assert len(splits) == 5 assert splits[2].shape == (10, 20, 2) @pytest.mark.parametrize("backend", BACKENDS) def test_where(backend): if backend == "sparse": pytest.xfail("sparse doesn't support where yet") A = ar.do("arange", 10, like=backend) B = ar.do("arange", 10, like=backend) + 1 C = ar.do("stack", [A, B]) D = ar.do("where", C < 5) if backend == "dask": for x in D: x.compute_chunk_sizes() for x in D: assert ar.to_numpy(x).shape == (9,) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("dtype_str", ["float32", "float64"]) @pytest.mark.parametrize( "fn", ["random.normal", "random.uniform", "zeros", "ones", "eye"] ) @pytest.mark.parametrize("str_or_backend", ("str", "backend")) def test_dtype_kwarg(backend, dtype_str, fn, str_or_backend): if str_or_backend == "str": dtype = dtype_str else: dtype = ar.to_backend_dtype(dtype_str, like=backend) if fn in ("random.normal", "random.uniform"): A = ar.do(fn, size=(10, 5), dtype=dtype, like=backend) elif fn in ("zeros", "ones"): A = ar.do(fn, shape=(10, 5), dtype=dtype, like=backend) else: # fn = 'eye' A = ar.do(fn, 10, dtype=dtype, like=backend) assert shape(A) == (10, 10) A = ar.do(fn, 10, 5, dtype=dtype, like=backend) assert shape(A) == (10, 5) assert ar.get_dtype_name(A) == dtype_str @pytest.mark.parametrize("backend", BACKENDS) def test_get_common_dtype(backend): x = ar.do("ones", (1,), like=backend, dtype="complex64") y = ar.do("ones", (1,), like=backend, dtype="float64") assert ar.get_common_dtype(x, y) == "complex128" @pytest.mark.parametrize("backend", BACKENDS) def test_backend_like(backend): assert ar.get_backend() is None ar.set_backend("test") assert ar.get_backend() == "test" ar.set_backend(None) assert ar.get_backend() is None with ar.backend_like(backend): assert ar.get_backend() == backend x = ar.do("ones", (2,), like=backend) assert ar.infer_backend(x) == backend assert ar.get_backend() is None def test_nested_multihreaded_backend_like(): from autoray.autoray import choose_backend from concurrent.futures import ThreadPoolExecutor def foo(backend1, backend2): bs = [] bs.append( ( ar.get_backend(), choose_backend("test", 1), ) ) with ar.backend_like(backend1): bs.append( ( ar.get_backend(), choose_backend("test", 1), ) ) with ar.backend_like(backend2): bs.append( ( ar.get_backend(), choose_backend("test", 1), ) ) bs.append( ( ar.get_backend(), choose_backend("test", 1), ) ) bs.append((ar.get_backend(), choose_backend("test", 1))) return bs b_exp = [("A", "A"), ("B", "B"), ("C", "C"), ("B", "B"), ("A", "A")] with ar.backend_like("A"): b = foo("B", "C") assert b == b_exp b_exp = [ ("A", "A"), ("B", "B"), (None, "builtins"), ("B", "B"), ("A", "A"), ] with ar.backend_like("A"): b = foo("B", None) assert b == b_exp with ThreadPoolExecutor(3) as pool: b_exp = [(None, "A"), ("B", "B"), ("C", "C"), ("B", "B"), (None, "A")] with ar.backend_like("A"): bs = [pool.submit(foo, "B", "C") for _ in range(3)] for b in bs: assert b.result() == b_exp b_exp = [(None, "A"), ("B", "B"), (None, "A"), ("B", "B"), (None, "A")] with ar.backend_like("A"): bs = [pool.submit(foo, "B", None) for _ in range(3)] for b in bs: assert b.result() == b_exp def test_compose(): @ar.compose def mycomposedfn(x, backend): x = ar.do("exp", x, like=backend) x = ar.do("log", x, like=backend) return x x = ar.do("ones", (2,), like="numpy") y = ar.do("mycomposedfn", x) assert ar.do("allclose", x, y) y = mycomposedfn(x) assert ar.do("allclose", x, y) mycomposedfn.register("numpy", lambda x: 1) y = ar.do("mycomposedfn", x) assert y == 1 y = mycomposedfn(x) assert y == 1 @mycomposedfn.register("numpy") def f(x): return 2 y = ar.do("mycomposedfn", x) assert y == 2 y = mycomposedfn(x) assert y == 2 def test_builtins_complex(): re = 1.0 im = 2.0 z = ar.do("complex", re, im) assert z == 1.0 + 2.0j assert ar.infer_backend(z) == "builtins" def test_shape_ndim_builtins(): import numpy as np xs = [ 1, 4.0, 7j, (), [], [[]], [np.ones(3), np.ones(3)], np.ones((5, 4, 3)), ] for x in xs: assert ar.shape(x) == np.shape(x) assert ar.ndim(x) == np.ndim(x) @pytest.mark.parametrize("backend", BACKENDS) def test_scipy_dispatching(backend): if backend not in ["numpy", "cupy", "jax"]: pytest.xfail("backend doesn't suport scipy.") x = gen_rand((3, 3), backend=backend) ar.do("scipy.linalg.expm", x) def check_array_dtypes(x, y): assert x.dtype == y.dtype if hasattr(x, "device"): assert x.device == y.device @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize( "dtype", ["float32", "float64", "complex64", "complex128"] ) class TestCreationRoutines: def test_empty_passes_dtype_device(self, backend, dtype): if backend in ("tensorflow",): pytest.xfail(f"{backend} doesn't support empty yet.") x = gen_rand((1,), backend, dtype) y = ar.do("empty", (2, 3), like=x) check_array_dtypes(x, y) def test_eye_passes_dtype_device(self, backend, dtype): x = gen_rand((1,), backend, dtype) y = ar.do("eye", 3, like=x) check_array_dtypes(x, y) def test_full_passes_dtype_device(self, backend, dtype): if backend in ("tensorflow",): pytest.xfail(f"{backend} doesn't support full yet.") x = gen_rand((1,), backend, dtype) y = ar.do("full", (2, 3), 7, like=x) check_array_dtypes(x, y) def test_identity_passes_dtype_device(self, backend, dtype): x = gen_rand((1,), backend, dtype) y = ar.do("identity", 4, like=x) check_array_dtypes(x, y) def test_ones_passes_dtype_device(self, backend, dtype): x = gen_rand((1,), backend, dtype) y = ar.do("ones", (2, 3), like=x) check_array_dtypes(x, y) def test_zeros_passes_dtype_device(self, backend, dtype): x = gen_rand((1,), backend, dtype) y = ar.do("zeros", (2, 3), like=x) check_array_dtypes(x, y) # def test_arange_passes_dtype_device(self, backend, dtype): # if backend in ("sparse",): # pytest.xfail("Sparse doesn't support arange yet.") # if backend == "torch" and "complex" in dtype: # pytest.xfail("torch.arange doesn't support complex numbers yet.") # if backend == "tensorflow" and "complex" in dtype: # pytest.xfail("torch.arange doesn't support complex numbers yet.") # x = gen_rand((1,), backend, dtype) # y = ar.do("arange", 1, 10, like=x) # check_array_dtypes(x, y) # def test_linspace_passes_dtype_device(self, backend, dtype): # if backend in ("sparse", "tensorflow"): # pytest.xfail(f"{backend} doesn't support linspace yet.") # x = gen_rand((1,), backend, dtype) # y = ar.do("linspace", 10, 20, 11, like=x) # check_array_dtypes(x, y) # def test_logspace_passes_dtype_device(self, backend, dtype): # if backend in ("sparse", "tensorflow"): # pytest.xfail(f"{backend} doesn't support logspace yet.") # x = gen_rand((1,), backend, dtype) # if backend not in {"dask"}: # y = ar.do("logspace", 10, 20, 11, like=x) # check_array_dtypes(x, y) # def test_geomspace_passes_dtype_device(self, backend, dtype): # if backend in ("sparse", "tensorflow"): # pytest.xfail(f"{backend} doesn't support logspace yet.") # x = gen_rand((1,), backend, dtype) # if backend not in {"dask"}: # y = ar.do("logspace", 10, 20, 11, like=x) # check_array_dtypes(x, y) creation_funcs_with_args = [ ("empty", ((2, 3),)), ("eye", (4,)), ("full", ((2, 3), 7)), ("identity", (4,)), ("ones", ((2, 3),)), ("zeros", ((2, 3),)), ] creation_builtins = [ (float, [np.float64]), (int, [np.int32, np.int64]), # np.int32 on Windows and np.int64 else (complex, [np.complex128]), ] @pytest.mark.parametrize("fn, args", creation_funcs_with_args) @pytest.mark.parametrize("dtype, expected", creation_builtins) def test_creation_with_builtins(fn, args, dtype, expected): x = dtype(4) y = ar.do(fn, *args, like=x) assert y.dtype in expected autoray-0.6.12/tests/test_lazy.py000066400000000000000000000516241462076570400170410ustar00rootroot00000000000000import functools import re import pytest from autoray import do, lazy, to_numpy, infer_backend, astype, shape from numpy.testing import assert_allclose, assert_raises from .test_autoray import BACKENDS, gen_rand def test_manual_construct(): def foo(a, b, c): a1, a2 = a b1 = b["1"] c1, c2 = c["sub"] return do("sum", do("stack", (a1, a2, b1, c1, c2)), axis=0) x = do("random.uniform", size=(5, 7), like="numpy") x0 = lazy.array(x[0, :]) x1 = lazy.array(x[1, :]) x2 = lazy.array(x[2, :]) x3 = lazy.array(x[3, :]) x4 = lazy.array(x[4, :]) y = lazy.LazyArray( backend=infer_backend(x), fn=foo, args=((x0, x1), {"1": x2}), kwargs=dict(c={"sub": (x3, x4)}), shape=(7,), ) assert y.deps == (x0, x1, x2, x3, x4) assert re.match( r"x\d+ = foo\d+\(\(x\d+, x\d+,\), " r"{1: x\d+}, c: {sub: \(x\d+, x\d+,\)}\)", y.get_source(), ) assert_allclose(y.compute(), x.sum(0)) def modified_gram_schmidt(X): Q = [] for j in range(0, shape(X)[0]): q = X[j, :] for i in range(0, j): rij = do("tensordot", do("conj", Q[i]), q, axes=1) q = q - rij * Q[i] rjj = do("linalg.norm", q, 2) Q.append(q / rjj) return do("stack", tuple(Q), axis=0) def wrap_strict_check(larray): fn_orig = larray._fn @functools.wraps(fn_orig) def checked(*args, **kwargs): data = fn_orig(*args, **kwargs) assert shape(data) == shape(larray) assert infer_backend(data) == larray.backend return data return checked def make_strict(larray): for node in larray.descend(): larray._fn = wrap_strict_check(larray) @pytest.mark.parametrize("backend", BACKENDS) def test_lazy_mgs(backend): if backend == "sparse": pytest.xfail("Sparse doesn't support 'linalg.norm' yet...") x = gen_rand((5, 5), backend) lx = lazy.array(x) ly = modified_gram_schmidt(lx) ly.show() make_strict(ly) assert str(ly) == ( f"" ) assert isinstance(ly, lazy.LazyArray) hmax = ly.history_max_size() hpeak = ly.history_peak_size() htot = ly.history_total_size() assert hmax == 25 assert 25 < hpeak < htot assert ly.history_num_nodes() == 57 assert len(ly.history_fn_frequencies()) == 9 assert_allclose(to_numpy(ly.compute()), to_numpy(modified_gram_schmidt(x))) with lazy.shared_intermediates(): ly = modified_gram_schmidt(lx) make_strict(ly) assert ly.history_num_nodes() == 51 assert len(ly.history_fn_frequencies()) == 9 assert_allclose(to_numpy(ly.compute()), to_numpy(modified_gram_schmidt(x))) def test_partial_evaluation(): la = lazy.array(gen_rand((10, 10), "numpy")) lb = lazy.array(gen_rand((10, 10), "numpy")) lc = lazy.array(gen_rand((10, 10), "numpy")) ld = lazy.array(gen_rand((10, 10), "numpy")) lab = do("tanh", la @ lb) lcd = lc @ ld ls = lab + lcd ld = do("abs", lab / lcd) le = do("einsum", "ab,ba->a", ls, ld) lf = do("sum", le) make_strict(lf) assert lf.history_num_nodes() == 12 lf.compute_constants(variables=[lc, ld]) # constants = [la, lb] assert lf.history_num_nodes() == 9 assert "tanh" not in {node.fn_name for node in lf.descend()} lf.compute() def test_history_fn_frequencies(): la = lazy.array(gen_rand((10, 10), "numpy")) lb = lazy.array(gen_rand((10, 10), "numpy")) lc = lazy.array(gen_rand((10, 10), "numpy")) ld = lazy.array(gen_rand((10, 10), "numpy")) lab = do("tanh", la @ lb) lcd = lc @ ld ls = lab + lcd ld = do("abs", lab / lcd) le = do("einsum", "ab,ba->a", ls, ld) lf = do("sum", le) assert lf.history_fn_frequencies() == { "None": 4, # the inputs "tanh": 1, "matmul": 2, "add": 1, "absolute": 1, "truediv": 1, "einsum": 1, "sum": 1, } def test_plot(): pytest.importorskip("networkx") matplotlib = pytest.importorskip("matplotlib") matplotlib.use("Template") la = lazy.array(gen_rand((10, 10), "numpy")) lb = lazy.array(gen_rand((10, 10), "numpy")) lc = lazy.array(gen_rand((10, 10), "numpy")) ld = lazy.array(gen_rand((10, 10), "numpy")) lab = do("tanh", la @ lb) lcd = lc @ ld ls = lab + lcd ld = do("abs", lab / lcd) le = do("einsum", "ab,ba->a", ls, ld) lf = do("sum", le) lf.plot_graph() lf.plot_graph(initial_layout="layers") lf.plot_graph(variables=[lc, ld], color_by="variables") lf.plot_circuit() lf.plot_circuit(color_by="id") lf.plot_history_size_footprint() lf.plot_history_functions_scatter() lf.plot_history_functions_lines(log=2) lf.plot_history_functions_image(rasterize=True) lf.plot_history_stats() def test_share_intermediates(): la = lazy.array(gen_rand((10, 10), "numpy")) lb = lazy.array(gen_rand((10, 10), "numpy")) l1 = do("tanh", la @ lb) l2 = do("tanh", la @ lb) ly = l1 + l2 assert ly.history_num_nodes() == 7 y1 = ly.compute() with lazy.shared_intermediates(): l1 = do("tanh", la @ lb) l2 = do("tanh", la @ lb) ly = l1 + l2 assert ly.history_num_nodes() == 5 y2 = ly.compute() assert_allclose(y1, y2) @pytest.mark.parametrize("backend", BACKENDS) def test_transpose_chain(backend): lx = lazy.array(gen_rand((2, 3, 4, 5, 6), backend)) l1 = do("transpose", lx, (1, 0, 3, 2, 4)) l2 = do("transpose", l1, (1, 0, 3, 2, 4)) assert l2.args[0] is lx assert l2.deps == (lx,) assert l1.history_num_nodes() == 2 assert l2.history_num_nodes() == 2 assert_allclose( to_numpy(lx.compute()), to_numpy(l2.compute()), ) @pytest.mark.parametrize("backend", BACKENDS) def test_reshape_chain(backend): lx = lazy.array(gen_rand((2, 3, 4, 5, 6), backend)) l1 = do("reshape", lx, (6, 4, 30)) l2 = do("reshape", l1, (-1,)) assert l1.history_num_nodes() == 2 assert l2.history_num_nodes() == 2 assert l2.args[0] is lx assert l2.deps == (lx,) assert_allclose( to_numpy(lx.compute()).flatten(), to_numpy(l2.compute()), atol=1e-6, ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("dtype", ["float64", "complex128"]) def test_svd(backend, dtype): if backend == "sparse": pytest.xfail("Sparse doesn't support 'linalg.svd' yet...") x = lazy.array(gen_rand((4, 5), backend, dtype)) U, s, VH = do("linalg.svd", x) assert shape(U) == (4, 4) assert shape(s) == (4,) assert shape(VH) == (4, 5) s = astype(s, dtype) ly = U @ (do("reshape", s, (-1, 1)) * VH) make_strict(ly) assert_allclose( to_numpy(x.compute()), to_numpy(ly.compute()), ) @pytest.mark.parametrize("backend", BACKENDS) def test_qr(backend): if backend == "sparse": pytest.xfail("Sparse doesn't support 'linalg.qr' yet...") x = lazy.array(gen_rand((4, 5), backend)) Q, R = do("linalg.qr", x) assert shape(Q) == (4, 4) assert shape(R) == (4, 5) ly = Q @ R make_strict(ly) assert_allclose( to_numpy(x.compute()), to_numpy(ly.compute()), ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("dtype", ["float64", "complex128"]) def test_eig_inv(backend, dtype): if backend in ("cupy", "dask", "torch", "mars", "sparse"): pytest.xfail(f"{backend} doesn't support 'linalg.eig' yet...") # N.B. the prob that a real gaussian matrix has all real eigenvalues is # ``2**(-d * (d - 1) / 4)`` - see Edelman 1997 - so need ``d >> 5`` d = 20 x = lazy.array(gen_rand((d, d), backend, dtype)) el, ev = do("linalg.eig", x) assert shape(el) == (d,) assert shape(ev) == (d, d) ly = ev @ (do("reshape", el, (-1, 1)) * do("linalg.inv", ev)) make_strict(ly) assert_allclose( to_numpy(x.compute()), to_numpy(ly.compute()), ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("dtype", ["float64", "complex128"]) def test_eigh(backend, dtype): if backend in ( "dask", "mars", "sparse", ): pytest.xfail(f"{backend} doesn't support 'linalg.eig' yet...") x = lazy.array(gen_rand((5, 5), backend, dtype)) x = x + x.H el, ev = do("linalg.eigh", x) assert shape(el) == (5,) assert shape(ev) == (5, 5) ly = ev @ (do("reshape", el, (-1, 1)) * ev.H) make_strict(ly) assert_allclose( to_numpy(x.compute()), to_numpy(ly.compute()), ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("dtype", ["float64", "complex128"]) def test_cholesky(backend, dtype): if backend in ("sparse",): pytest.xfail(f"{backend} doesn't support 'linalg.cholesky' yet...") x = lazy.array(gen_rand((5, 5), backend, dtype)) x = x @ x.H C = do("linalg.cholesky", x) assert shape(C) == (5, 5) ly = C @ C.H make_strict(ly) assert_allclose( to_numpy(x.compute()), to_numpy(ly.compute()), ) @pytest.mark.parametrize("backend", BACKENDS) @pytest.mark.parametrize("dtype", ["float64", "complex128"]) def test_solve(backend, dtype): if backend in ("sparse",): pytest.xfail(f"{backend} doesn't support 'linalg.solve' yet...") A = lazy.array(gen_rand((5, 5), backend, dtype)) y = lazy.array(gen_rand((5,), backend, dtype)) x = do("linalg.solve", A, y) assert shape(x) == (5,) # tensorflow e.g. doesn't allow ``A @ x`` for vector x ... ly = do("tensordot", A, x, axes=1) make_strict(ly) assert_allclose( to_numpy(y.compute()), to_numpy(ly.compute()), ) def test_dunder_magic(): a = do("random.uniform", size=(), like="numpy") b = lazy.array(a) x, y, z = do("random.uniform", size=(3), like="numpy") a = x * a b = x * b a = a * y b = b * y a *= z b *= z assert_allclose(a, b.compute()) a = do("random.uniform", size=(), like="numpy") b = lazy.array(a) x, y, z = do("random.uniform", size=(3), like="numpy") a = x + a b = x + b a = a + y b = b + y a += z b += z assert_allclose(a, b.compute()) a = do("random.uniform", size=(), like="numpy") b = lazy.array(a) x, y, z = do("random.uniform", size=(3), like="numpy") a = x - a b = x - b a = a - y b = b - y a -= z b -= z assert_allclose(a, b.compute()) a = do("random.uniform", size=(), like="numpy") b = lazy.array(a) x, y, z = do("random.uniform", size=(3), like="numpy") a = x / a b = x / b a = a / y b = b / y a /= z b /= z assert_allclose(a, b.compute()) a = do("random.uniform", size=(), like="numpy") b = lazy.array(a) x, y, z = do("random.uniform", size=(3), like="numpy") a = x // a b = x // b a = a // y b = b // y a //= z b //= z assert_allclose(a, b.compute()) a = do("random.uniform", size=(), like="numpy") b = lazy.array(a) x, y, z = do("random.uniform", size=(3), like="numpy") a = x**a b = x**b a = a**y b = b**y a **= z b **= z assert_allclose(a, b.compute()) a = do("random.uniform", size=(3, 3), like="numpy") b = lazy.array(a) x, y, z = do("random.uniform", size=(3, 3, 3), like="numpy") a = x @ a b = x @ b a = a @ y b = b @ y a = a @ z b @= z assert_allclose(a, b.compute()) def test_indexing(): a = do("random.uniform", size=(2, 3, 4, 5), like="numpy") b = lazy.array(a) for key in [0, (1, ..., -1), (0, 1, slice(None), -2)]: assert_allclose(a[key], b[key].compute()) @pytest.mark.parametrize("k", [-3, -1, 0, 2, 4]) @pytest.mark.parametrize( "shape", [ (3,), (2, 2), (3, 4), (4, 3), ], ) def test_diag(shape, k): a = do("random.uniform", size=shape, like="numpy") b = lazy.array(a) ad = do("diag", a, k) bd = do("diag", b, k) assert_allclose(ad, bd.compute()) def test_einsum(): a = do("random.uniform", size=(2, 3, 4, 5), like="numpy") b = do("random.uniform", size=(4, 5), like="numpy") c = do("random.uniform", size=(6, 2, 3), like="numpy") eq = "abcd,cd,fab->fd" x1 = do("einsum", eq, a, b, c) la, lb, lc = map(lazy.array, (a, b, c)) x2 = do("einsum", eq, la, lb, lc) assert_allclose(x1, x2.compute()) def test_tensordot(): a = do("random.uniform", size=(7, 3, 4, 5), like="numpy") b = do("random.uniform", size=(5, 6, 3, 2), like="numpy") x1 = do("tensordot", a, b, axes=[(1, 3), (2, 0)]) la, lb = map(lazy.array, (a, b)) x2 = do("tensordot", la, lb, axes=[(1, 3), (2, 0)]) assert_allclose(x1, x2.compute()) def test_use_variable_to_trace_function(): a = lazy.Variable(shape=(2, 3), backend="numpy") b = lazy.Variable(shape=(3, 4), backend="numpy") c = do("tanh", a @ b) f = c.get_function([a, b]) x = do("random.uniform", size=(2, 3), like="numpy") y = do("random.uniform", size=(3, 4), like="numpy") z = f([x, y]) assert shape(z) == (2, 4) def test_can_pickle_traced_function(): import pickle a = lazy.Variable(shape=(2, 3), backend="numpy") b = lazy.Variable(shape=(3, 4), backend="numpy") c = do("tanh", a @ b) f = c.get_function([a, b]) x = do("random.uniform", size=(2, 3), like="numpy") y = do("random.uniform", size=(3, 4), like="numpy") z = f([x, y]) assert shape(z) == (2, 4) s = pickle.dumps(f) g = pickle.loads(s) z = g([x, y]) assert shape(z) == (2, 4) def test_where(): a = lazy.Variable(shape=(4,), backend="numpy") b = lazy.Variable(shape=(4,), backend="numpy") c = do("where", *(a > 0, b, 1)) f = c.get_function([a, b]) x = do("asarray", [-0.5, -0.5, 1, 2], like="numpy") y = do("asarray", [1, 2, 3, 4], like="numpy") z = f(x, y) assert_allclose(z, [1, 1, 3, 4]) def test_lazy_function_pytree_input_and_output(): inputs = { "a": lazy.Variable(shape=(2, 3), backend="numpy"), "b": lazy.Variable(shape=(3, 4), backend="numpy"), } outputs = { "outa": do("tanh", inputs["a"] @ inputs["b"]), "outb": [inputs["a"] - 1, inputs["b"] - 1], } f = lazy.Function(inputs, outputs) a = do("random.uniform", size=(2, 3), like="numpy") b = do("random.uniform", size=(3, 4), like="numpy") outs = f({"a": a, "b": b}) assert_allclose(outs["outa"], do("tanh", a @ b)) assert_allclose(outs["outb"][0], a - 1) assert_allclose(outs["outb"][1], b - 1) @pytest.mark.parametrize( "indices", [ [0, 1], [[0, 1], [1, 2]], [[[0, 1], [1, 2]], [[1, 1], [2, 2]]], [[[[0, 1, 2, 3]]]], [[[[0], [1]]], [[[2], [3]]]], ], ) @pytest.mark.parametrize( "shape", [ (4,), (4, 5), (4, 5, 6), (4, 5, 6, 7), ], ) def test_take(indices, shape): a = do("random.uniform", size=shape, like="numpy") b = lazy.Variable(shape=shape, backend="numpy") np_shape = do("take", a, indices).shape lazy_shape = do("take", b, indices).shape fn = do("take", b, indices).get_function([b]) lazy_func_shape = fn([a]).shape assert_allclose(np_shape, lazy_shape) assert_allclose(np_shape, lazy_func_shape) @pytest.mark.parametrize( "indices", [ [0, 1], [[0, 1], [1, 2]], [[[0, 1], [1, 2]], [[1, 1], [2, 2]]], [[[[0, 1, 2, 3]]]], [[[[0], [1]]], [[[2], [3]]]], ], ) @pytest.mark.parametrize( "shape", [ (4,), (4, 5), (4, 5, 6), (4, 5, 6, 7), ], ) def test_getitem(indices, shape): a = do("random.uniform", size=shape, like="numpy") b = lazy.Variable(shape=shape, backend="numpy") np_shape = a[indices].shape lazy_shape = b[indices].shape fn = b[indices].get_function([b]) lazy_func_shape = fn([a]).shape assert_allclose(np_shape, lazy_shape) assert_allclose(np_shape, lazy_func_shape) def random_indexer(ndim_min=0, ndim_max=10, d_min=1, d_max=5, seed=None): """Generate a random shape and valid indexing object into that shape.""" import numpy as np rng = np.random.default_rng(seed=seed) ndim = rng.integers(ndim_min, ndim_max + 1) # if we have a advanced indexing arrays, the shape of the array adv_ix_ndim = rng.integers(1, 4) adv_ix_shape = tuple(rng.integers(d_min, d_max + 1, size=adv_ix_ndim)) def rand_adv_ix_broadcastable_shape(): # get a random shape that broadcast matches adv_ix_shape ndim = rng.integers(1, adv_ix_ndim + 1) matching_shape = adv_ix_shape[-ndim:] return tuple(rng.choice([d, 1]) for d in matching_shape) shape = [] indexer = [] choices = ["index", "slice", "ellipsis", "array", "list", "newaxis"] i = 0 while i < ndim: kind = rng.choice(choices) if kind == "newaxis": indexer.append(None) continue d = rng.integers(d_min, d_max + 1) shape.append(d) if kind == "index": ix = rng.integers(-d, d) if rng.random() > 0.5: # randomly supply integers and numpy ints ix = int(ix) elif kind == "ellipsis": # only one ellipsis allowed ix = ... choices.remove("ellipsis") # how many dims ellipsis should expand to i += rng.integers(0, 4) elif kind == "slice": start = rng.integers(-d - 2, d + 2) stop = rng.integers(-d - 2, d - 2) step = rng.choice([-3, -2, -1, 1, 2, 3]) ix = slice(start, stop, step) elif kind == "array": ai_shape = rand_adv_ix_broadcastable_shape() ix = rng.integers(-d, d, size=ai_shape) elif kind == "list": ai_shape = rand_adv_ix_broadcastable_shape() ix = rng.integers(-d, d, size=ai_shape).tolist() indexer.append(ix) i += 1 if (len(indexer) == 1) and (rng.random() > 0.5): # return the raw object (indexer,) = indexer else: indexer = tuple(indexer) return tuple(shape), indexer @pytest.mark.parametrize("seed", range(1000)) def test_lazy_getitem_random(seed): shape, indexer = random_indexer() a = do("random.uniform", size=shape, like="numpy") ai = a[indexer] b = lazy.array(a) bi = b[indexer] assert bi.shape == ai.shape assert_allclose(bi.compute(), ai) @pytest.mark.parametrize( "shape1, shape2", [ ((3,), (3,)), ((3,), (3, 2)), ((6, 5, 4, 3), (3,)), ((7, 6, 5, 4), (7, 6, 4, 3)), ], ) def test_matmul_shape(shape1, shape2): a = lazy.Variable(shape=shape1) b = lazy.Variable(shape=shape2) np_a = do("random.uniform", size=shape1, like="numpy") np_b = do("random.uniform", size=shape2, like="numpy") lazy_shape = (a @ b).shape np_shape = (np_a @ np_b).shape assert_allclose(lazy_shape, np_shape) @pytest.mark.parametrize( "shape1, shape2", [ ((3,), (1,)), ((3,), (4, 3)), ((3,), (3, 2, 1)), ( (2, 2, 3, 4), ( 1, 2, 4, 5, ), ), ((6, 5, 4), (6, 3, 3)), ], ) def test_matmul_shape_error(shape1, shape2): a = lazy.Variable(shape=shape1) b = lazy.Variable(shape=shape2) def f(x, y): return x @ y assert_raises(ValueError, f, a, b) def test_pytree_compute(): x = do("random.uniform", size=(5, 6), like="numpy") lx = lazy.array(x) lu, ls, lv = do("linalg.svd", lx) lresults = {"u": lu, "s": ls, "v": lv} results = lazy.compute(lresults) assert isinstance(results, dict) assert infer_backend(results["s"]) == infer_backend(x) def test_kron(): x = do("random.uniform", size=(2, 3), like="numpy") y = do("random.uniform", size=(2, 3), like="numpy") xy = do("kron", x, y) lx = lazy.array(x) ly = lazy.array(y) lxy = do("kron", lx, ly) assert lxy.shape == xy.shape assert_allclose(lxy.compute(), xy) x = do("random.uniform", size=(3,), like="numpy") y = do("random.uniform", size=(3, 4, 5), like="numpy") xy = do("kron", x, y) lx = lazy.array(x) ly = lazy.array(y) lxy = do("kron", lx, ly) assert lxy.shape == xy.shape assert_allclose(lxy.compute(), xy) x = do("random.uniform", size=(3, 4, 5), like="numpy") y = do("random.uniform", size=(3,), like="numpy") xy = do("kron", x, y) lx = lazy.array(x) ly = lazy.array(y) lxy = do("kron", lx, ly) assert lxy.shape == xy.shape assert_allclose(lxy.compute(), xy) def test_concatenate(): x = do("random.uniform", size=(3, 4, 5), like="numpy") y = do("random.uniform", size=(3, 1, 5), like="numpy") z = do("random.uniform", size=(3, 7, 5), like="numpy") xyz = do("concatenate", (x, y, z), axis=1) lx = lazy.array(x) ly = lazy.array(y) lz = lazy.array(z) lxyz = do("concatenate", (lx, ly, lz), axis=1) assert lxyz.shape == xyz.shape assert_allclose(lxyz.compute(), xyz)