././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9586704 setuptools-59.6.0/0000755000175100001710000000000000000000000013374 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/CHANGES.rst0000644000175100001710000054000100000000000015176 0ustar00runnerdockerv59.6.0 ------- Changes ^^^^^^^ * #2925: Merge with pypa/distutils@92082ee42c including introduction of deprecation warning on Version classes. v59.5.0 ------- Changes ^^^^^^^ * #2914: Merge with pypa/distutils@8f2df0bf6. v59.4.0 ------- Changes ^^^^^^^ * #2893: Restore deprecated support for newlines in the Summary field. v59.3.0 ------- Changes ^^^^^^^ * #2902: Merge with pypa/distutils@85db7a41242. Misc ^^^^ * #2906: In ensure_local_distutils, re-use DistutilsMetaFinder to load the module. Avoids race conditions when _distutils_system_mod is employed. v59.2.0 ------- Changes ^^^^^^^ * #2875: Introduce changes from pypa/distutils@514e9d0, including support for overrides from Debian and pkgsrc, unlocking the possibility of making SETUPTOOLS_USE_DISTUTILS=local the default again. v59.1.1 ------- Misc ^^^^ * #2885: Fixed errors when encountering LegacyVersions. v59.1.0 ------- Changes ^^^^^^^ * #2497: Update packaging to 21.2. * #2877: Back out deprecation of setup_requires and replace instead by a deprecation of setuptools.installer and fetch_build_egg. Now setup_requires is still supported when installed as part of a PEP 517 build, but is deprecated when an unsatisfied requirement is encountered. * #2879: Bump packaging to 21.2. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2867: PNG/ICO images replaced with SVG in the docs. * #2867: Added support to SVG "favicons" via "in-tree" Sphinx extension. v59.0.1 ------- Misc ^^^^ * #2880: Removed URL requirement for ``pytest-virtualenv`` in ``setup.cfg``. PyPI rejects packages with dependencies external to itself. Instead the test dependency was overwritten via ``tox.ini`` v59.0.0 ------- Deprecations ^^^^^^^^^^^^ * #2856: Support for custom commands that inherit directly from ``distutils`` is **deprecated**. Users should extend classes provided by setuptools instead. Breaking Changes ^^^^^^^^^^^^^^^^ * #2870: Started failing on invalid inline description with line breaks :class:`ValueError` -- by :user:`webknjaz` Changes ^^^^^^^ * #2698: Exposed exception classes from ``distutils.errors`` via ``setuptools.errors``. * #2866: Incorporate changes from pypa/distutils@f1b0a2b. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2227: Added sphinx theme customisations to display the new logo in the sidebar and use its colours as "accent" in the documentation -- by :user:`abravalheri` * #2227: Added new setuptools logo, including editable files and artwork documentation -- by :user:`abravalheri` * #2698: Added mentions to ``setuptools.errors`` as a way of handling custom command errors. * #2698: Added instructions to migrate from ``distutils.commands`` and ``distutils.errors`` in the porting guide. * #2871: Added a note to the docs that it is possible to install ``setup.py``-less projects in editable mode with :doc:`pip v21.1+ `, only having ``setup.cfg`` and ``pyproject.toml`` in project root -- by :user:`webknjaz` v58.5.3 ------- Misc ^^^^ * #2849: Add fallback for custom ``build_py`` commands inheriting directly from :mod:`distutils`, while still handling ``include_package_data=True`` for ``sdist``. v58.5.2 ------- Misc ^^^^ * #2847: Suppress 'setup.py install' warning under bdist_wheel. v58.5.1 ------- Misc ^^^^ * #2846: Move PkgResourcesDeprecationWarning above implicitly-called function so that it's in the namespace when version warnings are generated in an environment that contains them. v58.5.0 ------- Changes ^^^^^^^ * #1461: Fix inconsistency with ``include_package_data`` and ``packages_data`` in sdist by replacing the loop breaking mechanism between the ``sdist`` and ``egg_info`` commands -- by :user:`abravalheri` v58.4.0 ------- Changes ^^^^^^^ * #2497: Officially deprecated PEP 440 non-compliant versions. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2832: Removed the deprecated ``data_files`` option from the example in the declarative configuration docs -- by :user:`abravalheri` * #2832: Change type of ``data_files`` option from ``dict`` to ``section`` in declarative configuration docs (to match previous example) -- by :user:`abravalheri` v58.3.0 ------- Changes ^^^^^^^ * #917: ``setup.py install`` and ``easy_install`` commands are now officially deprecated. Use other standards-based installers (like pip) and builders (like build). Workloads reliant on this behavior should pin to this major version of Setuptools. See `Why you shouldn't invoke setup.py directly `_ for more background. * #1988: Deprecated the ``bdist_rpm`` command. Binary packages should be built as wheels instead. -- by :user:`hugovk` * #2785: Replace ``configparser``'s ``readfp`` with ``read_file``, deprecated since Python 3.2. -- by :user:`hugovk` * #2823: Officially deprecated support for ``setup_requires``. Users are encouraged instead to migrate to PEP 518 ``build-system.requires`` in ``pyproject.toml``. Users reliant on ``setup_requires`` should consider pinning to this major version to avoid disruption. Misc ^^^^ * #2762: Changed codecov.yml to configure the threshold to be lower -- by :user:`tanvimoharir` v58.2.0 ------- Changes ^^^^^^^ * #2757: Add windows arm64 launchers for scripts generated by easy_install. * #2800: Added ``--owner`` and ``--group`` options to the ``sdist`` command, for specifying file ownership within the produced tarball (similarly to the corresponding distutils ``sdist`` options). Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2792: Document how the legacy and non-legacy versions are compared, and reference to the `PEP 440 `_ scheme. v58.1.0 ------- Changes ^^^^^^^ * #2796: Merge with pypa/distutils@02e9f65ab0 v58.0.4 ------- Misc ^^^^ * #2773: Retain case in setup.cfg during sdist. v58.0.3 ------- Misc ^^^^ * #2777: Build does not fail fast when ``use_2to3`` is supplied but set to a false value. v58.0.2 ------- Misc ^^^^ * #2769: Build now fails fast when ``use_2to3`` is supplied. v58.0.1 ------- Misc ^^^^ * #2765: In Distribution.finalize_options, suppress known removed entry points to avoid issues with older Setuptools. v58.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2086: Removed support for 2to3 during builds. Projects should port to a unified codebase or pin to an older version of Setuptools using PEP 518 build-requires. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2746: add python_requires example v57.5.0 ------- Changes ^^^^^^^ * #2712: Added implicit globbing support for `[options.data_files]` values. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2737: fix various syntax and style errors in code snippets in docs v57.4.0 ------- Changes ^^^^^^^ * #2722: Added support for ``SETUPTOOLS_EXT_SUFFIX`` environment variable to override the suffix normally detected from the ``sysconfig`` module. v57.3.0 ------- Changes ^^^^^^^ * #2465: Documentation is now published using the Furo theme. v57.2.0 ------- Changes ^^^^^^^ * #2724: Added detection of Windows ARM64 build environments using the ``VSCMD_ARG_TGT_ARCH`` environment variable. v57.1.0 ------- Changes ^^^^^^^ * #2692: Globs are now sorted in 'license_files' restoring reproducibility by eliminating variance from disk order. * #2714: Update to distutils at pypa/distutils@e2627b7. * #2715: Removed reliance on deprecated ssl.match_hostname by removing the ssl support. Now any index operations rely on the native SSL implementation. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2604: Revamped the backward/cross tool compatibility section to remove some confusion. Add some examples and the version since when ``entry_points`` are supported in declarative configuration. Tried to make the reading flow a bit leaner, gather some information that were a bit dispersed. v57.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2645: License files excluded via the ``MANIFEST.in`` but matched by either the ``license_file`` (deprecated) or ``license_files`` options, will be nevertheless included in the source distribution. - by :user:`cdce8p` Changes ^^^^^^^ * #2628: Write long description in message payload of PKG-INFO file. - by :user:`cdce8p` * #2645: Added ``License-File`` (multiple) to the output package metadata. The field will contain the path of a license file, matched by the ``license_file`` (deprecated) and ``license_files`` options, relative to ``.dist-info``. - by :user:`cdce8p` * #2678: Moved Setuptools' own entry points into declarative config. * #2680: Vendored `more_itertools `_ for Setuptools. * #2681: Setuptools own setup.py no longer declares setup_requires, but instead expects wheel to be installed as declared by pyproject.toml. Misc ^^^^ * #2650: Updated the docs build tooling to support the latest version of Towncrier and show the previews of not-yet-released setuptools versions in the changelog -- :user:`webknjaz` v56.2.0 ------- Changes ^^^^^^^ * #2640: Fixed handling of multiline license strings. - by :user:`cdce8p` * #2641: Setuptools will now always try to use the latest supported metadata version for ``PKG-INFO``. - by :user:`cdce8p` v56.1.0 ------- Changes ^^^^^^^ * #2653: Incorporated assorted changes from pypa/distutils. * #2657: Adopted docs from distutils. * #2663: Added Visual Studio Express 2017 support -- by :user:`dofuuz` Misc ^^^^ * #2644: Fixed ``DeprecationWarning`` due to ``threading.Thread.setDaemon`` in tests -- by :user:`tirkarthi` * #2654: Made the changelog generator compatible with Towncrier >= 19.9 -- :user:`webknjaz` * #2664: Relax the deprecation message in the distutils hack. v56.0.0 ------- Deprecations ^^^^^^^^^^^^ * #2620: The ``license_file`` option is now marked as deprecated. Use ``license_files`` instead. -- by :user:`cdce8p` Breaking Changes ^^^^^^^^^^^^^^^^ * #2620: If neither ``license_file`` nor ``license_files`` is specified, the ``sdist`` option will now auto-include files that match the following patterns: ``LICEN[CS]E*``, ``COPYING*``, ``NOTICE*``, ``AUTHORS*``. This matches the behavior of ``bdist_wheel``. -- by :user:`cdce8p` Changes ^^^^^^^ * #2620: The ``license_file`` and ``license_files`` options now support glob patterns. -- by :user:`cdce8p` * #2632: Implemented ``VendorImporter.find_spec()`` method to get rid of ``ImportWarning`` that Python 3.10 emits when only the old-style importer hooks are present -- by :user:`webknjaz` Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2620: Added documentation for the ``license_files`` option. -- by :user:`cdce8p` v55.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2566: Remove the deprecated ``bdist_wininst`` command. Binary packages should be built as wheels instead. -- by :user:`hroncok` v54.2.0 ------- Changes ^^^^^^^ * #2608: Added informative error message to PEP 517 build failures owing to an empty ``setup.py`` -- by :user:`layday` v54.1.3 ------- No significant changes. v54.1.2 ------- Misc ^^^^ * #2595: Reduced scope of dash deprecation warning to Setuptools/distutils only -- by :user:`melissa-kun-li` v54.1.1 ------- Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2584: Added ``sphinx-inline-tabs`` extension to allow for comparison of ``setup.py`` and its equivalent ``setup.cfg`` -- by :user:`amy-lei` Misc ^^^^ * #2592: Made option keys in the ``[metadata]`` section of ``setup.cfg`` case-sensitive. Users having uppercase option spellings will get a warning suggesting to make them to lowercase -- by :user:`melissa-kun-li` v54.1.0 ------- Changes ^^^^^^^ * #1608: Removed the conversion of dashes to underscores in the :code:`extras_require` and :code:`data_files` of :code:`setup.cfg` to support the usage of dashes. Method will warn users when they use a dash-separated key which in the future will only allow an underscore. Note: the method performs the dash to underscore conversion to preserve compatibility, but future versions will no longer support it -- by :user:`melissa-kun-li` v54.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2582: Simplified build-from-source story by providing bootstrapping metadata in a separate egg-info directory. Build requirements no longer include setuptools itself. Sdist once again includes the pyproject.toml. Project can no longer be installed from source on pip 19.x, but install from source is still supported on pip < 19 and pip >= 20 and install from wheel is still supported with pip >= 9. Changes ^^^^^^^ * #1932: Handled :code:`AttributeError` by raising :code:`DistutilsSetupError` in :code:`dist.check_specifier()` when specifier is not a string -- by :user:`melissa-kun-li` * #2570: Correctly parse cmdclass in setup.cfg. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2553: Added userguide example for markers in extras_require -- by :user:`pwoolvett` v53.1.0 ------- Changes ^^^^^^^ * #1937: Preserved case-sensitivity of keys in setup.cfg so that entry point names are case-sensitive. Changed sensitivity of configparser. NOTE: Any projects relying on case-insensitivity will need to adapt to accept the original case as published. -- by :user:`melissa-kun-li` * #2573: Fixed error in uploading a Sphinx doc with the :code:`upload_docs` command. An html builder will be used. Note: :code:`upload_docs` is deprecated for PyPi, but is supported for other sites -- by :user:`melissa-kun-li` v53.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1527: Removed bootstrap script. Now Setuptools requires pip or another pep517-compliant builder such as 'build' to build. Now Setuptools can be installed from Github main branch. v52.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2537: Remove fallback support for fetch_build_eggs using easy_install. Now pip is required for setup_requires to succeed. * #2544: Removed 'easy_install' top-level model (runpy entry point) and 'easy_install' console script. * #2545: Removed support for eggsecutables. Changes ^^^^^^^ * #2459: Tests now run in parallel via pytest-xdist, completing in about half the time. Special thanks to :user:`webknjaz` for hard work implementing test isolation. To run without parallelization, disable the plugin with ``tox -- -p no:xdist``. v51.3.3 ------- Misc ^^^^ * #2539: Fix AttributeError in Description validation. v51.3.2 ------- Misc ^^^^ * #1390: Validation of Description field now is more lenient, emitting a warning and mangling the value to be valid (replacing newlines with spaces). v51.3.1 ------- Misc ^^^^ * #2536: Reverted tag deduplication handling. v51.3.0 ------- Changes ^^^^^^^ * #1390: Newlines in metadata description/Summary now trigger a ValueError. * #2481: Define ``create_module()`` and ``exec_module()`` methods in ``VendorImporter`` to get rid of ``ImportWarning`` -- by :user:`hroncok` * #2489: ``pkg_resources`` behavior for zipimport now matches the regular behavior, and finds ``.egg-info`` (previoulsy would only find ``.dist-info``) -- by :user:`thatch` * #2529: Fixed an issue where version tags may be added multiple times v51.2.0 ------- Changes ^^^^^^^ * #2493: Use importlib.import_module() rather than the deprecated loader.load_module() in pkg_resources namespace delaration -- by :user:`encukou` Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2525: Fix typo in the document page about entry point. -- by :user:`jtr109` Misc ^^^^ * #2534: Avoid hitting network during test_easy_install. v51.1.2 ------- Misc ^^^^ * #2505: Disable inclusion of package data as it causes 'tests' to be included as data. v51.1.1 ------- Misc ^^^^ * #2534: Avoid hitting network during test_virtualenv.test_test_command. v51.1.0 ------- Changes ^^^^^^^ * #2486: Project adopts jaraco/skeleton for shared package maintenance. Misc ^^^^ * #2477: Restore inclusion of rst files in sdist. * #2484: Setuptools has replaced the master branch with the main branch. * #2485: Fixed failing test when pip 20.3+ is present. -- by :user:`yan12125` * #2487: Fix tests with pytest 6.2 -- by :user:`yan12125` v51.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2435: Require Python 3.6 or later. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2430: Fixed inconsistent RST title nesting levels caused by #2399 -- by :user:`webknjaz` * #2430: Fixed a typo in Sphinx docs that made docs dev section disappear as a result of PR #2426 -- by :user:`webknjaz` Misc ^^^^ * #2471: Removed the tests that guarantee that the vendored dependencies can be built by distutils. v50.3.2 ------- Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2394: Extended towncrier news template to include change note categories. This allows to see what types of changes a given version introduces -- by :user:`webknjaz` * #2427: Started enforcing strict syntax and reference validation in the Sphinx docs -- by :user:`webknjaz` * #2428: Removed redundant Sphinx ``Makefile`` support -- by :user:`webknjaz` Misc ^^^^ * #2401: Enabled test results reporting in AppVeyor CI -- by :user:`webknjaz` * #2420: Replace Python 3.9.0 beta with 3.9.0 final on GitHub Actions. * #2421: Python 3.9 Trove classifier got added to the dist metadata -- by :user:`webknjaz` v50.3.1 ------- Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2093: Finalized doc revamp. * #2097: doc: simplify index and group deprecated files * #2102: doc overhaul step 2: break main doc into multiple sections * #2111: doc overhaul step 3: update userguide * #2395: Added a ``:user:`` role to Sphinx config -- by :user:`webknjaz` * #2395: Added an illustrative explanation about the change notes to fragments dir -- by :user:`webknjaz` Misc ^^^^ * #2379: Travis CI test suite now tests against PPC64. * #2413: Suppress EOF errors (and other exceptions) when importing lib2to3. v50.3.0 ------- Changes ^^^^^^^ * #2368: In distutils, restore support for monkeypatched CCompiler.spawn per pypa/distutils#15. v50.2.0 ------- Changes ^^^^^^^ * #2355: When pip is imported as part of a build, leave distutils patched. * #2380: There are some setuptools specific changes in the ``setuptools.command.bdist_rpm`` module that are no longer needed, because they are part of the ``bdist_rpm`` module in distutils in Python 3.5.0. Therefore, code was removed from ``setuptools.command.bdist_rpm``. v50.1.0 ------- Changes ^^^^^^^ * #2350: Setuptools reverts using the included distutils by default. Platform maintainers and system integrators and others are *strongly* encouraged to set ``SETUPTOOLS_USE_DISTUTILS=local`` to help identify and work through the reported issues with distutils adoption, mainly to file issues and pull requests with pypa/distutils such that distutils performs as needed across every supported environment. v50.0.3 ------- Misc ^^^^ * #2363: Restore link_libpython support on Python 3.7 and earlier (see pypa/distutils#9). v50.0.2 ------- Misc ^^^^ * #2352: In distutils hack, use absolute import rather than relative to avoid bpo-30876. v50.0.1 ------- Misc ^^^^ * #2357: Restored Python 3.5 support in distutils.util for missing ``subprocess._optim_args_from_interpreter_flags``. * #2358: Restored AIX support on Python 3.8 and earlier. * #2361: Add Python 3.10 support to _distutils_hack. Get the 'Loader' abstract class from importlib.abc rather than importlib.util.abc (alias removed in Python 3.10). v50.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2232: Once again, Setuptools overrides the stdlib distutils on import. For environments or invocations where this behavior is undesirable, users are provided with a temporary escape hatch. If the environment variable ``SETUPTOOLS_USE_DISTUTILS`` is set to ``stdlib``, Setuptools will fall back to the legacy behavior. Use of this escape hatch is discouraged, but it is provided to ease the transition while proper fixes for edge cases can be addressed. Changes ^^^^^^^ * #2334: In MSVC module, refine text in error message. v49.6.0 ------- Changes ^^^^^^^ * #2129: In pkg_resources, no longer detect any pathname ending in .egg as a Python egg. Now the path must be an unpacked egg or a zip file. v49.5.0 ------- Changes ^^^^^^^ * #2306: When running as a PEP 517 backend, setuptools does not try to install ``setup_requires`` itself. They are reported as build requirements for the frontend to install. v49.4.0 ------- Changes ^^^^^^^ * #2310: Updated vendored packaging version to 20.4. v49.3.2 ------- Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2300: Improve the ``safe_version`` function documentation Misc ^^^^ * #2297: Once again, in stubs prefer exec_module to the deprecated load_module. v49.3.1 ------- Changes ^^^^^^^ * #2316: Removed warning when ``distutils`` is imported before ``setuptools`` when ``distutils`` replacement is not enabled. v49.3.0 ------- Changes ^^^^^^^ * #2259: Setuptools now provides a .pth file (except for editable installs of setuptools) to the target environment to ensure that when enabled, the setuptools-provided distutils is preferred before setuptools has been imported (and even if setuptools is never imported). Honors the SETUPTOOLS_USE_DISTUTILS environment variable. v49.2.1 ------- Misc ^^^^ * #2257: Fixed two flaws in distutils._msvccompiler.MSVCCompiler.spawn. v49.2.0 ------- Changes ^^^^^^^ * #2230: Now warn the user when setuptools is imported after distutils modules have been loaded (exempting PyPy for 3.6), directing the users of packages to import setuptools first. v49.1.3 ------- Misc ^^^^ * #2212: (Distutils) Allow spawn to accept environment. Avoid monkey-patching global state. * #2249: Fix extension loading technique in stubs. v49.1.2 ------- Changes ^^^^^^^ * #2232: In preparation for re-enabling a local copy of distutils, Setuptools now honors an environment variable, SETUPTOOLS_USE_DISTUTILS. If set to 'stdlib' (current default), distutils will be used from the standard library. If set to 'local' (default in a imminent backward-incompatible release), the local copy of distutils will be used. v49.1.1 ------- Misc ^^^^ * #2094: Removed pkg_resources.py2_warn module, which is no longer reachable. v49.0.1 ------- Misc ^^^^ * #2228: Applied fix for pypa/distutils#3, restoring expectation that spawn will raise a DistutilsExecError when attempting to execute a missing file. v49.1.0 ------- Changes ^^^^^^^ * #2228: Disabled distutils adoption for now while emergent issues are addressed. v49.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2165: Setuptools no longer installs a site.py file during easy_install or develop installs. As a result, .eggs on PYTHONPATH will no longer take precedence over other packages on sys.path. If this issue affects your production environment, please reach out to the maintainers at #2165. Changes ^^^^^^^ * #2137: Removed (private) pkg_resources.RequirementParseError, now replaced by packaging.requirements.InvalidRequirement. Kept the name for compatibility, but users should catch InvalidRequirement instead. * #2180: Update vendored packaging in pkg_resources to 19.2. Misc ^^^^ * #2199: Fix exception causes all over the codebase by using ``raise new_exception from old_exception`` v48.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2143: Setuptools adopts distutils from the Python 3.9 standard library and no longer depends on distutils in the standard library. When importing ``setuptools`` or ``setuptools.distutils_patch``, Setuptools will expose its bundled version as a top-level ``distutils`` package (and unload any previously-imported top-level distutils package), retaining the expectation that ``distutils``' objects are actually Setuptools objects. To avoid getting any legacy behavior from the standard library, projects are advised to always "import setuptools" prior to importing anything from distutils. This behavior happens by default when using ``pip install`` or ``pep517.build``. Workflows that rely on ``setup.py (anything)`` will need to first ensure setuptools is imported. One way to achieve this behavior without modifying code is to invoke Python thus: ``python -c "import setuptools; exec(open('setup.py').read())" (anything)``. v47.3.2 ------- Misc ^^^^ * #2071: Replaced references to the deprecated imp package with references to importlib v47.3.1 ------- Misc ^^^^ * #1973: Removed ``pkg_resources.py31compat.makedirs`` in favor of the stdlib. Use ``os.makedirs()`` instead. * #2198: Restore ``__requires__`` directive in easy-install wrapper scripts. v47.3.0 ------- Changes ^^^^^^^ * #2197: Console script wrapper for editable installs now has a unified template and honors importlib_metadata if present for faster script execution on older Pythons. Misc ^^^^ * #2195: Fix broken entry points generated by easy-install (pip editable installs). v47.2.0 ------- Changes ^^^^^^^ * #2194: Editable-installed entry points now load significantly faster on Python versions 3.8+. * #1471: Incidentally fixed by #2194 on Python 3.8 or when importlib_metadata is present. v47.1.1 ------- Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2156: Update mailing list pointer in developer docs Incorporate changes from v44.1.1: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * #2158: Avoid loading working set during ``Distribution.finalize_options`` prior to invoking ``_install_setup_requires``, broken since v42.0.0. v44.1.1 ------- Misc ^^^^ * #2158: Avoid loading working set during ``Distribution.finalize_options`` prior to invoking ``_install_setup_requires``, broken since v42.0.0. v47.1.0 ------- Changes ^^^^^^^ * #2070: In wheel-to-egg conversion, use simple pkg_resources-style namespace declaration for packages that declare namespace_packages. v47.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #2094: Setuptools now actively crashes under Python 2. Python 3.5 or later is required. Users of Python 2 should use ``setuptools<45``. Changes ^^^^^^^ * #1700: Document all supported keywords by migrating the ones from distutils. v46.4.0 ------- Changes ^^^^^^^ * #1753: ``attr:`` now extracts variables through rudimentary examination of the AST, thereby supporting modules with third-party imports. If examining the AST fails to find the variable, ``attr:`` falls back to the old behavior of importing the module. Works on Python 3 only. v46.3.1 ------- No significant changes. v46.3.0 ------- Changes ^^^^^^^ * #2089: Package index functionality no longer attempts to remove an md5 fragment from the index URL. This functionality, added for distribute #163 is no longer relevant. Misc ^^^^ * #2041: Preserve file modes during pkg files copying, but clear read only flag for target afterwards. * #2105: Filter ``2to3`` deprecation warnings from ``TestDevelop.test_2to3_user_mode``. v46.2.0 ------- Changes ^^^^^^^ * #2040: Deprecated the ``bdist_wininst`` command. Binary packages should be built as wheels instead. * #2062: Change 'Mac OS X' to 'macOS' in code. * #2075: Stop recognizing files ending with ``.dist-info`` as distribution metadata. * #2086: Deprecate 'use_2to3' functionality. Packagers are encouraged to use single-source solutions or build tool chains to manage conversions outside of setuptools. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1698: Added documentation for ``build_meta`` (a bare minimum, not completed). Misc ^^^^ * #2082: Filter ``lib2to3`` ``PendingDeprecationWarning`` and ``DeprecationWarning`` in tests, because ``lib2to3`` is `deprecated in Python 3.9 `_. v46.1.3 ------- No significant changes. v46.1.2 ------- Misc ^^^^ * #1458: Added template for reporting Python 2 incompatibilities. v46.1.1 ------- No significant changes. v46.1.0 ------- Changes ^^^^^^^ * #308: Allow version number normalization to be bypassed by wrapping in a 'setuptools.sic()' call. * #1424: Prevent keeping files mode for package_data build. It may break a build if user's package data has read only flag. * #1431: In ``easy_install.check_site_dir``, ensure the installation directory exists. * #1563: In ``pkg_resources`` prefer ``find_spec`` (PEP 451) to ``find_module``. Incorporate changes from v44.1.0: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * #1704: Set sys.argv[0] in setup script run by build_meta.__legacy__ * #1959: Fix for Python 4: replace unsafe six.PY3 with six.PY2 * #1994: Fixed a bug in the "setuptools.finalize_distribution_options" hook that lead to ignoring the order attribute of entry points managed by this hook. v44.1.0 ------- Changes ^^^^^^^ * #1704: Set sys.argv[0] in setup script run by build_meta.__legacy__ * #1959: Fix for Python 4: replace unsafe six.PY3 with six.PY2 * #1994: Fixed a bug in the "setuptools.finalize_distribution_options" hook that lead to ignoring the order attribute of entry points managed by this hook. v46.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #65: Once again as in 3.0, removed the Features feature. Changes ^^^^^^^ * #1890: Fix vendored dependencies so importing ``setuptools.extern.some_module`` gives the same object as ``setuptools._vendor.some_module``. This makes Metadata picklable again. * #1899: Test suite now fails on warnings. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #2011: Fix broken link to distutils docs on package_data Misc ^^^^ * #1991: Include pkg_resources test data in sdist, so tests can be executed from it. v45.3.0 ------- Changes ^^^^^^^ * #1557: Deprecated eggsecutable scripts and updated docs. * #1904: Update msvc.py to use CPython 3.8.0 mechanism to find msvc 14+ v45.2.0 ------- Changes ^^^^^^^ * #1905: Fixed defect in _imp, introduced in 41.6.0 when the 'tests' directory is not present. * #1941: Improve editable installs with PEP 518 build isolation: * The ``--user`` option is now always available. A warning is issued if the user site directory is not available. * The error shown when the install directory is not in ``PYTHONPATH`` has been turned into a warning. * #1981: Setuptools now declares its ``tests`` and ``docs`` dependencies in metadata (extras). * #1985: Add support for installing scripts in environments where bdist_wininst is missing (i.e. Python 3.9). Misc ^^^^ * #1968: Add flake8-2020 to check for misuse of sys.version or sys.version_info. v45.1.0 ------- Changes ^^^^^^^ * #1458: Add minimum sunset date and preamble to Python 2 warning. * #1704: Set sys.argv[0] in setup script run by build_meta.__legacy__ * #1974: Add Python 3 Only Trove Classifier and remove universal wheel declaration for more complete transition from Python 2. v45.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1458: Drop support for Python 2. Setuptools now requires Python 3.5 or later. Install setuptools using pip >=9 or pin to Setuptools <45 to maintain 2.7 support. Changes ^^^^^^^ * #1959: Fix for Python 4: replace unsafe six.PY3 with six.PY2 v44.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1908: Drop support for Python 3.4. v43.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1634: Include ``pyproject.toml`` in source distribution by default. Projects relying on the previous behavior where ``pyproject.toml`` was excluded by default should stop relying on that behavior or add ``exclude pyproject.toml`` to their MANIFEST.in file. Changes ^^^^^^^ * #1927: Setuptools once again declares 'setuptools' in the ``build-system.requires`` and adds PEP 517 build support by declaring itself as the ``build-backend``. It additionally specifies ``build-system.backend-path`` to rely on itself for those builders that support it. v42.0.2 ------- Changes ^^^^^^^ * #1921: Fix support for easy_install's ``find-links`` option in ``setup.cfg``. * #1922: Build dependencies (setup_requires and tests_require) now install transitive dependencies indicated by extras. v42.0.1 ------- Changes ^^^^^^^ * #1918: Fix regression in handling wheels compatibility tags. v42.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1830, #1909: Mark the easy_install script and setuptools command as deprecated, and use `pip `_ when available to fetch/build wheels for missing ``setup_requires``/``tests_require`` requirements, with the following differences in behavior: * support for ``python_requires`` * better support for wheels (proper handling of priority with respect to PEP 425 tags) * PEP 517/518 support * eggs are not supported * no support for the ``allow_hosts`` easy_install option (``index_url``/``find_links`` are still honored) * pip environment variables are honored (and take precedence over easy_install options) * #1898: Removed the "upload" and "register" commands in favor of `twine `_. Changes ^^^^^^^ * #1767: Add support for the ``license_files`` option in ``setup.cfg`` to automatically include multiple license files in a source distribution. * #1829: Update handling of wheels compatibility tags: * add support for manylinux2010 * fix use of removed 'm' ABI flag in Python 3.8 on Windows * #1861: Fix empty namespace package installation from wheel. * #1877: Setuptools now exposes a new entry point hook "setuptools.finalize_distribution_options", enabling plugins like `setuptools_scm `_ to configure options on the distribution at finalization time. v41.6.0 ------- Changes ^^^^^^^ * #479: Replace usage of deprecated ``imp`` module with local re-implementation in ``setuptools._imp``. v41.5.1 ------- Changes ^^^^^^^ * #1891: Fix code for detecting Visual Studio's version on Windows under Python 2. v41.5.0 ------- Changes ^^^^^^^ * #1811: Improve Visual C++ 14.X support, mainly for Visual Studio 2017 and 2019. * #1814: Fix ``pkg_resources.Requirement`` hash/equality implementation: take PEP 508 direct URL into account. * #1824: Fix tests when running under ``python3.10``. * #1878: Formally deprecated the ``test`` command, with the recommendation that users migrate to ``tox``. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1860: Update documentation to mention the egg format is not supported by pip and dependency links support was dropped starting with pip 19.0. * #1862: Drop ez_setup documentation: deprecated for some time (last updated in 2016), and still relying on easy_install (deprecated too). * #1868: Drop most documentation references to (deprecated) EasyInstall. * #1884: Added a trove classifier to document support for Python 3.8. Misc ^^^^ * #1886: Added Python 3.8 release to the Travis test matrix. v41.4.0 ------- Changes ^^^^^^^ * #1847: In declarative config, now traps errors when invalid ``python_requires`` values are supplied. v41.3.0 ------- Changes ^^^^^^^ * #1690: When storing extras, rely on OrderedSet to retain order of extras as indicated by the packager, which will also be deterministic on Python 2.7 (with PYTHONHASHSEED unset) and Python 3.6+. Misc ^^^^ * #1858: Fixed failing integration test triggered by 'long_description_content_type' in packaging. v41.2.0 ------- Changes ^^^^^^^ * #479: Remove some usage of the deprecated ``imp`` module. Misc ^^^^ * #1565: Changed html_sidebars from string to list of string as per https://www.sphinx-doc.org/en/master/changes.html#id58 v41.1.0 ------- Misc ^^^^ * #1697: Moved most of the constants from setup.py to setup.cfg * #1749: Fixed issue with the PEP 517 backend where building a source distribution would fail if any tarball existed in the destination directory. * #1750: Fixed an issue with PEP 517 backend where wheel builds would fail if the destination directory did not already exist. * #1756: Force metadata-version >= 1.2. when project urls are present. * #1769: Improve ``package_data`` check: ensure the dictionary values are lists/tuples of strings. * #1788: Changed compatibility fallback logic for ``html.unescape`` to avoid accessing ``HTMLParser.unescape`` when not necessary. ``HTMLParser.unescape`` is deprecated and will be removed in Python 3.9. * #1790: Added the file path to the error message when a ``UnicodeDecodeError`` occurs while reading a metadata file. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1776: Use license classifiers rather than the license field. v41.0.1 ------- Changes ^^^^^^^ * #1671: Fixed issue with the PEP 517 backend that prevented building a wheel when the ``dist/`` directory contained existing ``.whl`` files. * #1709: In test.paths_on_python_path, avoid adding unnecessary duplicates to the PYTHONPATH. * #1741: In package_index, now honor "current directory" during a checkout of git and hg repositories under Windows v41.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1735: When parsing setup.cfg files, setuptools now requires the files to be encoded as UTF-8. Any other encoding will lead to a UnicodeDecodeError. This change removes support for specifying an encoding using a 'coding: ' directive in the header of the file, a feature that was introduces in 40.7. Given the recent release of the aforementioned feature, it is assumed that few if any projects are utilizing the feature to specify an encoding other than UTF-8. v40.9.0 ------- Changes ^^^^^^^ * #1675: Added support for ``setup.cfg``-only projects when using the ``setuptools.build_meta`` backend. Projects that have enabled PEP 517 no longer need to have a ``setup.py`` and can use the purely declarative ``setup.cfg`` configuration file instead. * #1720: Added support for ``pkg_resources.parse_requirements``-style requirements in ``setup_requires`` when ``setup.py`` is invoked from the ``setuptools.build_meta`` build backend. * #1664: Added the path to the ``PKG-INFO`` or ``METADATA`` file in the exception text when the ``Version:`` header can't be found. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1705: Removed some placeholder documentation sections referring to deprecated features. v40.8.0 ------- Changes ^^^^^^^ * #1652: Added the ``build_meta:__legacy__`` backend, a "compatibility mode" PEP 517 backend that can be used as the default when ``build-backend`` is left unspecified in ``pyproject.toml``. * #1635: Resource paths are passed to ``pkg_resources.resource_string`` and similar no longer accept paths that traverse parents, that begin with a leading ``/``. Violations of this expectation raise DeprecationWarnings and will become errors. Additionally, any paths that are absolute on Windows are strictly disallowed and will raise ValueErrors. * #1536: ``setuptools`` will now automatically include licenses if ``setup.cfg`` contains a ``license_file`` attribute, unless this file is manually excluded inside ``MANIFEST.in``. v40.7.3 ------- Changes ^^^^^^^ * #1670: In package_index, revert to using a copy of splituser from Python 3.8. Attempts to use ``urllib.parse.urlparse`` led to problems as reported in #1663 and #1668. This change serves as an alternative to #1499 and fixes #1668. v40.7.2 ------- Changes ^^^^^^^ * #1666: Restore port in URL handling in package_index. v40.7.1 ------- Changes ^^^^^^^ * #1660: On Python 2, when reading config files, downcast options from text to bytes to satisfy distutils expectations. v40.7.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1551: File inputs for the ``license`` field in ``setup.cfg`` files now explicitly raise an error. Changes ^^^^^^^ * #1180: Add support for non-ASCII in setup.cfg (#1062). Add support for native strings on some parameters (#1136). * #1499: ``setuptools.package_index`` no longer relies on the deprecated ``urllib.parse.splituser`` per Python #27485. * #1544: Added tests for PackageIndex.download (for git URLs). * #1625: In PEP 517 build_meta builder, ensure that sdists are built as gztar per the spec. v40.6.3 ------- Changes ^^^^^^^ * #1594: PEP 517 backend no longer declares setuptools as a dependency as it can be assumed. v40.6.2 ------- Changes ^^^^^^^ * #1592: Fix invalid dependency on external six module (instead of vendored version). v40.6.1 ------- Changes ^^^^^^^ * #1590: Fixed regression where packages without ``author`` or ``author_email`` fields generated malformed package metadata. v40.6.0 ------- Deprecations ^^^^^^^^^^^^ * #1541: Officially deprecated the ``requires`` parameter in ``setup()``. Changes ^^^^^^^ * #1519: In ``pkg_resources.normalize_path``, additional path normalization is now performed to ensure path values to a directory is always the same, preventing false positives when checking scripts have a consistent prefix to set up on Windows. * #1545: Changed the warning class of all deprecation warnings; deprecation warning classes are no longer derived from ``DeprecationWarning`` and are thus visible by default. * #1554: ``build_meta.build_sdist`` now includes ``setup.py`` in source distributions by default. * #1576: Started monkey-patching ``get_metadata_version`` and ``read_pkg_file`` onto ``distutils.DistributionMetadata`` to retain the correct version on the ``PKG-INFO`` file in the (deprecated) ``upload`` command. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1395: Changed Pyrex references to Cython in the documentation. * #1456: Documented that the ``rpmbuild`` packages is required for the ``bdist_rpm`` command. * #1537: Documented how to use ``setup.cfg`` for ``src/ layouts`` * #1539: Added minimum version column in ``setup.cfg`` metadata table. * #1552: Fixed a minor typo in the python 2/3 compatibility documentation. * #1553: Updated installation instructions to point to ``pip install`` instead of ``ez_setup.py``. * #1560: Updated ``setuptools`` distribution documentation to remove some outdated information. * #1564: Documented ``setup.cfg`` minimum version for version and project_urls. Misc ^^^^ * #1533: Restricted the ``recursive-include setuptools/_vendor`` to contain only .py and .txt files. * #1572: Added the ``concurrent.futures`` backport ``futures`` to the Python 2.7 test suite requirements. v40.5.0 ------- Changes ^^^^^^^ * #1335: In ``pkg_resources.normalize_path``, fix issue on Cygwin when cwd contains symlinks. * #1502: Deprecated support for downloads from Subversion in package_index/easy_install. * #1517: Dropped use of six.u in favor of ``u""`` literals. * #1520: Added support for ``data_files`` in ``setup.cfg``. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1525: Fixed rendering of the deprecation warning in easy_install doc. v40.4.3 ------- Changes ^^^^^^^ * #1480: Bump vendored pyparsing in pkg_resources to 2.2.1. v40.4.2 ------- Misc ^^^^ * #1497: Updated gitignore in repo. v40.4.1 ------- Changes ^^^^^^^ * #1480: Bump vendored pyparsing to 2.2.1. v40.4.0 ------- Changes ^^^^^^^ * #1481: Join the sdist ``--dist-dir`` and the ``build_meta`` sdist directory argument to point to the same target (meaning the build frontend no longer needs to clean manually the dist dir to avoid multiple sdist presence, and setuptools no longer needs to handle conflicts between the two). v40.3.0 ------- Changes ^^^^^^^ * #1402: Fixed a bug with namespace packages under Python 3.6 when one package in current directory hides another which is installed. * #1427: Set timestamp of ``.egg-info`` directory whenever ``egg_info`` command is run. * #1474: ``build_meta.get_requires_for_build_sdist`` now does not include the ``wheel`` package anymore. * #1486: Suppress warnings in pkg_resources.handle_ns. Misc ^^^^ * #1479: Remove internal use of six.binary_type. v40.2.0 ------- Changes ^^^^^^^ * #1466: Fix handling of Unicode arguments in PEP 517 backend v40.1.1 -------- Changes ^^^^^^^ * #1465: Fix regression with ``egg_info`` command when tagging is used. v40.1.0 ------- Changes ^^^^^^^ * #1410: Deprecated ``upload`` and ``register`` commands. * #1312: Introduced find_namespace_packages() to find PEP 420 namespace packages. * #1420: Added find_namespace: directive to config parser. * #1418: Solved race in when creating egg cache directories. * #1450: Upgraded vendored PyParsing from 2.1.10 to 2.2.0. * #1451: Upgraded vendored appdirs from 1.4.0 to 1.4.3. * #1388: Fixed "Microsoft Visual C++ Build Tools" link in exception when Visual C++ not found. * #1389: Added support for scripts which have unicode content. * #1416: Moved several Python version checks over to using ``six.PY2`` and ``six.PY3``. Misc ^^^^ * #1441: Removed spurious executable permissions from files that don't need them. v40.0.0 ------- Breaking Changes ^^^^^^^^^^^^^^^^ * #1342: Drop support for Python 3.3. Changes ^^^^^^^ * #1366: In package_index, fixed handling of encoded entities in URLs. * #1383: In pkg_resources VendorImporter, avoid removing packages imported from the root. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1379: Minor doc fixes after actually using the new release process. * #1385: Removed section on non-package data files. * #1403: Fix developer's guide. Misc ^^^^ * #1404: Fix PEP 518 configuration: set build requirements in ``pyproject.toml`` to ``["wheel"]``. v39.2.0 ------- Changes ^^^^^^^ * #1359: Support using "file:" to load a PEP 440-compliant package version from a text file. * #1360: Fixed issue with a mismatch between the name of the package and the name of the .dist-info file in wheel files * #1364: Add ``__dir__()`` implementation to ``pkg_resources.Distribution()`` that includes the attributes in the ``_provider`` instance variable. * #1365: Take the package_dir option into account when loading the version from a module attribute. Documentation changes ^^^^^^^^^^^^^^^^^^^^^ * #1353: Added coverage badge to README. * #1356: Made small fixes to the developer guide documentation. * #1357: Fixed warnings in documentation builds and started enforcing that the docs build without warnings in tox. * #1376: Updated release process docs. Misc ^^^^ * #1343: The ``setuptools`` specific ``long_description_content_type``, ``project_urls`` and ``provides_extras`` fields are now set consistently after any ``distutils`` ``setup_keywords`` calls, allowing them to override values. * #1352: Added ``tox`` environment for documentation builds. * #1354: Added ``towncrier`` for changelog management. * #1355: Add PR template. * #1368: Fixed tests which failed without network connectivity. * #1369: Added unit tests for PEP 425 compatibility tags support. * #1372: Stop testing Python 3.3 in Travis CI, now that the latest version of ``wheel`` no longer installs on it. v39.1.0 ------- * #1340: Update all PyPI URLs to reflect the switch to the new Warehouse codebase. * #1337: In ``pkg_resources``, now support loading resources for modules loaded by the ``SourcelessFileLoader``. * #1332: Silence spurious wheel related warnings on Windows. v39.0.1 ------- * #1297: Restore Unicode handling for Maintainer fields in metadata. v39.0.0 ------- * #1296: Setuptools now vendors its own direct dependencies, no longer relying on the dependencies as vendored by pkg_resources. * #296: Removed long-deprecated support for iteration on Version objects as returned by ``pkg_resources.parse_version``. Removed the ``SetuptoolsVersion`` and ``SetuptoolsLegacyVersion`` names as well. They should not have been used, but if they were, replace with ``Version`` and ``LegacyVersion`` from ``packaging.version``. v38.7.0 ------- * #1288: Add support for maintainer in PKG-INFO. v38.6.1 ------- * #1292: Avoid generating ``Provides-Extra`` in metadata when no extra is present (but environment markers are). v38.6.0 ------- * #1286: Add support for Metadata 2.1 (PEP 566). v38.5.2 ------- * #1285: Fixed RuntimeError in pkg_resources.parse_requirements on Python 3.7 (stemming from PEP 479). v38.5.1 ------- * #1271: Revert to Cython legacy ``build_ext`` behavior for compatibility. v38.5.0 ------- * #1229: Expand imports in ``build_ext`` to refine detection of Cython availability. * #1270: When Cython is available, ``build_ext`` now uses the new_build_ext. v38.4.1 ------- * #1257: In bdist_egg.scan_module, fix ValueError on Python 3.7. v38.4.0 ------- * #1231: Removed warning when PYTHONDONTWRITEBYTECODE is enabled. v38.3.0 ------- * #1210: Add support for PEP 345 Project-URL metadata. * #1207: Add support for ``long_description_type`` to setup.cfg declarative config as intended and documented. v38.2.5 ------- * #1232: Fix trailing slash handling in ``pkg_resources.ZipProvider``. v38.2.4 ------- * #1220: Fix ``data_files`` handling when installing from wheel. v38.2.3 ------- * fix Travis' Python 3.3 job. v38.2.2 ------- * #1214: fix handling of namespace packages when installing from a wheel. v38.2.1 ------- * #1212: fix encoding handling of metadata when installing from a wheel. v38.2.0 ------- * #1200: easy_install now support installing from wheels: they will be installed as standalone unzipped eggs. v38.1.0 ------- * #1208: Improve error message when failing to locate scripts in egg-info metadata. v38.0.0 ------- * #458: In order to support deterministic builds, Setuptools no longer allows packages to declare ``install_requires`` as unordered sequences (sets or dicts). v37.0.0 ------- * #878: Drop support for Python 2.6. Python 2.6 users should rely on 'setuptools < 37dev'. v36.8.0 ------- * #1190: In SSL support for package index operations, use SNI where available. v36.7.3 ------- * #1175: Bug fixes to ``build_meta`` module. v36.7.2 ------- * #701: Fixed duplicate test discovery on Python 3. v36.7.1 ------- * #1193: Avoid test failures in bdist_egg when PYTHONDONTWRITEBYTECODE is set. v36.7.0 ------- * #1054: Support ``setup_requires`` in ``setup.cfg`` files. v36.6.1 ------- * #1132: Removed redundant and costly serialization/parsing step in ``EntryPoint.__init__``. * #844: ``bdist_egg --exclude-source-files`` now tested and works on Python 3. v36.6.0 ------- * #1143: Added ``setuptools.build_meta`` module, an implementation of PEP-517 for Setuptools-defined packages. * #1143: Added ``dist_info`` command for producing dist_info metadata. v36.5.0 ------- * #170: When working with Mercurial checkouts, use Windows-friendly syntax for suppressing output. * Inspired by #1134, performed substantial refactoring of ``pkg_resources.find_on_path`` to facilitate an optimization for paths with many non-version entries. v36.4.0 ------- * #1075: Add new ``Description-Content-Type`` metadata field. `See here for documentation on how to use this field. `_ * #1068: Sort files and directories when building eggs for deterministic order. * #196: Remove caching of easy_install command in fetch_build_egg. Fixes issue where ``pytest-runner-N.N`` would satisfy the installation of ``pytest``. * #1129: Fix working set dependencies handling when replacing conflicting distributions (e.g. when using ``setup_requires`` with a conflicting transitive dependency, fix #1124). * #1133: Improved handling of README files extensions and added Markdown to the list of searched READMES. * #1135: Improve performance of pkg_resources import by not invoking ``access`` or ``stat`` and using ``os.listdir`` instead. v36.3.0 ------- * #1131: Make possible using several files within ``file:`` directive in metadata.long_description in ``setup.cfg``. v36.2.7 ------- * fix #1105: Fix handling of requirements with environment markers when declared in ``setup.cfg`` (same treatment as for #1081). v36.2.6 ------- * #462: Don't assume a directory is an egg by the ``.egg`` extension alone. v36.2.5 ------- * #1093: Fix test command handler with extras_require. * #1112, #1091, #1115: Now using Trusty containers in Travis for CI and CD. v36.2.4 ------- * #1092: ``pkg_resources`` now uses ``inspect.getmro`` to resolve classes in method resolution order. v36.2.3 ------- * #1102: Restore behavior for empty extras. v36.2.2 ------- * #1099: Revert commit a3ec721, restoring intended purpose of extras as part of a requirement declaration. v36.2.1 ------- * fix #1086 * fix #1087 * support extras specifiers in install_requires requirements v36.2.0 ------- * #1081: Environment markers indicated in ``install_requires`` are now processed and treated as nameless ``extras_require`` with markers, allowing their metadata in requires.txt to be correctly generated. * #1053: Tagged commits are now released using Travis-CI build stages, meaning releases depend on passing tests on all supported Python versions (Linux) and not just the latest Python version. v36.1.1 ------- * #1083: Correct ``py31compat.makedirs`` to correctly honor ``exist_ok`` parameter. * #1083: Also use makedirs compatibility throughout setuptools. v36.1.0 ------- * #1083: Avoid race condition on directory creation in ``pkg_resources.ensure_directory``. * Removed deprecation of and restored support for ``upload_docs`` command for sites other than PyPI. Only warehouse is dropping support, but services like `devpi `_ continue to support docs built by setuptools' plugins. See `this comment `_ for more context on the motivation for this change. v36.0.1 ------- * #1042: Fix import in py27compat module that still referenced six directly, rather than through the externs module (vendored packages hook). v36.0.0 ------- * #980 and others: Once again, Setuptools vendors all of its dependencies. It seems to be the case that in the Python ecosystem, all build tools must run without any dependencies (build, runtime, or otherwise). At such a point that a mechanism exists that allows build tools to have dependencies, Setuptools will adopt it. v35.0.2 ------- * #1015: Fix test failures on Python 3.7. * #1024: Add workaround for Jython #2581 in monkey module. v35.0.1 ------- * #992: Revert change introduced in v34.4.1, now considered invalid. * #1016: Revert change introduced in v35.0.0 per #1014, referencing #436. The approach had unintended consequences, causing sdist installs to be missing files. v35.0.0 ------- * #436: In egg_info.manifest_maker, no longer read the file list from the manifest file, and instead re-build it on each build. In this way, files removed from the specification will not linger in the manifest. As a result, any files manually added to the manifest will be removed on subsequent egg_info invocations. No projects should be manually adding files to the manifest and should instead use MANIFEST.in or SCM file finders to force inclusion of files in the manifest. v34.4.1 ------- * #1008: In MSVC support, use always the last version available for Windows SDK and UCRT SDK. * #1008: In MSVC support, fix "vcruntime140.dll" returned path with Visual Studio 2017. * #992: In msvc.msvc9_query_vcvarsall, ensure the returned dicts have str values and not Unicode for compatibility with os.environ. v34.4.0 ------- * #995: In MSVC support, add support for "Microsoft Visual Studio 2017" and "Microsoft Visual Studio Build Tools 2017". * #999 via #1007: Extend support for declarative package config in a setup.cfg file to include the options ``python_requires`` and ``py_modules``. v34.3.3 ------- * #967 (and #997): Explicitly import submodules of packaging to account for environments where the imports of those submodules is not implied by other behavior. v34.3.2 ------- * #993: Fix documentation upload by correcting rendering of content-type in _build_multipart on Python 3. v34.3.1 ------- * #988: Trap ``os.unlink`` same as ``os.remove`` in ``auto_chmod`` error handler. * #983: Fixes to invalid escape sequence deprecations on Python 3.6. v34.3.0 ------- * #941: In the upload command, if the username is blank, default to ``getpass.getuser()``. * #971: Correct distutils findall monkeypatch to match appropriate versions (namely Python 3.4.6). v34.2.0 ------- * #966: Add support for reading dist-info metadata and thus locating Distributions from zip files. * #968: Allow '+' and '!' in egg fragments so that it can take package names that contain PEP 440 conforming version specifiers. v34.1.1 ------- * #953: More aggressively employ the compatibility issue originally added in #706. v34.1.0 ------- * #930: ``build_info`` now accepts two new parameters to optimize and customize the building of C libraries. v34.0.3 ------- * #947: Loosen restriction on the version of six required, restoring compatibility with environments relying on six 1.6.0 and later. v34.0.2 ------- * #882: Ensure extras are honored when building the working set. * #913: Fix issue in develop if package directory has a trailing slash. v34.0.1 ------- * #935: Fix glob syntax in graft. v34.0.0 ------- * #581: Instead of vendoring the growing list of dependencies that Setuptools requires to function, Setuptools now requires these dependencies just like any other project. Unlike other projects, however, Setuptools cannot rely on ``setup_requires`` to demand the dependencies it needs to install because its own machinery would be necessary to pull those dependencies if not present (a bootstrapping problem). As a result, Setuptools no longer supports self upgrade or installation in the general case. Instead, users are directed to use pip to install and upgrade using the ``wheel`` distributions of setuptools. Users are welcome to contrive other means to install or upgrade Setuptools using other means, such as pre-installing the Setuptools dependencies with pip or a bespoke bootstrap tool, but such usage is not recommended and is not supported. As discovered in #940, not all versions of pip will successfully install Setuptools from its pre-built wheel. If you encounter issues with "No module named six" or "No module named packaging", especially following a line "Running setup.py egg_info for package setuptools", then your pip is not new enough. There's an additional issue in pip where setuptools is upgraded concurrently with other source packages, described in pip #4253. The proposed workaround is to always upgrade Setuptools first prior to upgrading other packages that would upgrade Setuptools. v33.1.1 ------- * #921: Correct issue where certifi fallback not being reached on Windows. v33.1.0 ------- Installation via pip, as indicated in the `Python Packaging User's Guide `_, is the officially-supported mechanism for installing Setuptools, and this recommendation is now explicit in the much more concise README. Other edits and tweaks were made to the documentation. The codebase is unchanged. v33.0.0 ------- * #619: Removed support for the ``tag_svn_revision`` distribution option. If Subversion tagging support is still desired, consider adding the functionality to setuptools_svn in setuptools_svn #2. v32.3.1 ------- * #866: Use ``dis.Bytecode`` on Python 3.4 and later in ``setuptools.depends``. v32.3.0 ------- * #889: Backport proposed fix for disabling interpolation in distutils.Distribution.parse_config_files. v32.2.0 ------- * #884: Restore support for running the tests under `pytest-runner `_ by ensuring that PYTHONPATH is honored in tests invoking a subprocess. v32.1.3 ------- * #706: Add rmtree compatibility shim for environments where rmtree fails when passed a unicode string. v32.1.2 ------- * #893: Only release sdist in zip format as warehouse now disallows releasing two different formats. v32.1.1 ------- * #704: More selectively ensure that 'rmtree' is not invoked with a byte string, enabling it to remove files that are non-ascii, even on Python 2. * #712: In 'sandbox.run_setup', ensure that ``__file__`` is always a ``str``, modeling the behavior observed by the interpreter when invoking scripts and modules. v32.1.0 ------- * #891: In 'test' command on test failure, raise DistutilsError, suppression invocation of subsequent commands. v32.0.0 ------- * #890: Revert #849. ``global-exclude .foo`` will not match all ``*.foo`` files any more. Package authors must add an explicit wildcard, such as ``global-exclude *.foo``, to match all ``.foo`` files. See #886, #849. v31.0.1 ------- * #885: Fix regression where 'pkg_resources._rebuild_mod_path' would fail when a namespace package's '__path__' was not a list with a sort attribute. v31.0.0 ------- * #250: Install '-nspkg.pth' files for packages installed with 'setup.py develop'. These .pth files allow namespace packages installed by pip or develop to co-mingle. This change required the removal of the change for #805 and pip #1924, introduced in 28.3.0 and implicated in #870, but means that namespace packages not in a site packages directory will no longer work on Python earlier than 3.5, whereas before they would work on Python not earlier than 3.3. v30.4.0 ------- * #879: For declarative config: - read_configuration() now accepts ignore_option_errors argument. This allows scraping tools to read metadata without a need to download entire packages. E.g. we can gather some stats right from GitHub repos just by downloading setup.cfg. - packages find: directive now supports fine tuning from a subsection. The same arguments as for find() are accepted. v30.3.0 ------- * #394 via #862: Added support for `declarative package config in a setup.cfg file `_. v30.2.1 ------- * #850: In test command, invoke unittest.main with indication not to exit the process. v30.2.0 ------- * #854: Bump to vendored Packaging 16.8. v30.1.0 ------- * #846: Also trap 'socket.error' when opening URLs in package_index. * #849: Manifest processing now matches the filename pattern anywhere in the filename and not just at the start. Restores behavior found prior to 28.5.0. v30.0.0 ------- * #864: Drop support for Python 3.2. Systems requiring Python 3.2 support must use 'setuptools < 30'. * #825: Suppress warnings for single files. * #830 via #843: Once again restored inclusion of data files to sdists, but now trap TypeError caused by techniques employed rjsmin and similar. v29.0.1 ------- * #861: Re-release of v29.0.1 with the executable script launchers bundled. Now, launchers are included by default and users that want to disable this behavior must set the environment variable 'SETUPTOOLS_INSTALL_WINDOWS_SPECIFIC_FILES' to a false value like "false" or "0". v29.0.0 ------- * #841: Drop special exception for packages invoking win32com during the build/install process. See Distribute #118 for history. v28.8.0 ------- * #629: Per the discussion, refine the sorting to use version value order for more accurate detection of the latest available version when scanning for packages. See also #829. * #837: Rely on the config var "SO" for Python 3.3.0 only when determining the ext filename. v28.7.1 ------- * #827: Update PyPI root for dependency links. * #833: Backed out changes from #830 as the implementation seems to have problems in some cases. v28.7.0 ------- * #832: Moved much of the namespace package handling functionality into a separate module for re-use in something like #789. * #830: ``sdist`` command no longer suppresses the inclusion of data files, re-aligning with the expectation of distutils and addressing #274 and #521. v28.6.1 ------- * #816: Fix manifest file list order in tests. v28.6.0 ------- * #629: When scanning for packages, ``pkg_resources`` now ignores empty egg-info directories and gives precedence to packages whose versions are lexicographically greatest, a rough approximation for preferring the latest available version. v28.5.0 ------- * #810: Tests are now invoked with tox and not setup.py test. * #249 and #450 via #764: Avoid scanning the whole tree when building the manifest. Also fixes a long-standing bug where patterns in ``MANIFEST.in`` had implicit wildcard matching. This caused ``global-exclude .foo`` to exclude all ``*.foo`` files, but also ``global-exclude bar.py`` to exclude ``foo_bar.py``. v28.4.0 ------- * #732: Now extras with a hyphen are honored per PEP 426. * #811: Update to pyparsing 2.1.10. * Updated ``setuptools.command.sdist`` to re-use most of the functionality directly from ``distutils.command.sdist`` for the ``add_defaults`` method with strategic overrides. See #750 for rationale. * #760 via #762: Look for certificate bundle where SUSE Linux typically presents it. Use ``certifi.where()`` to locate the bundle. v28.3.0 ------- * #809: In ``find_packages()``, restore support for excluding a parent package without excluding a child package. * #805: Disable ``-nspkg.pth`` behavior on Python 3.3+ where PEP-420 functionality is adequate. Fixes pip #1924. v28.1.0 ------- * #803: Bump certifi to 2016.9.26. v28.0.0 ------- * #733: Do not search excluded directories for packages. This introduced a backwards incompatible change in ``find_packages()`` so that ``find_packages(exclude=['foo']) == []``, excluding subpackages of ``foo``. Previously, ``find_packages(exclude=['foo']) == ['foo.bar']``, even though the parent ``foo`` package was excluded. * #795: Bump certifi. * #719: Suppress decoding errors and instead log a warning when metadata cannot be decoded. v27.3.1 ------- * #790: In MSVC monkeypatching, explicitly patch each function by name in the target module instead of inferring the module from the function's ``__module__``. Improves compatibility with other packages that might have previously patched distutils functions (i.e. NumPy). v27.3.0 ------- * #794: In test command, add installed eggs to PYTHONPATH when invoking tests so that subprocesses will also have the dependencies available. Fixes `tox 330 `_. * #795: Update vendored pyparsing 2.1.9. v27.2.0 ------- * #520 and #513: Suppress ValueErrors in fixup_namespace_packages when lookup fails. * Nicer, more consistent interfaces for msvc monkeypatching. v27.1.2 ------- * #779 via #781: Fix circular import. v27.1.1 ------- * #778: Fix MSVC monkeypatching. v27.1.0 ------- * Introduce the (private) ``monkey`` module to encapsulate the distutils monkeypatching behavior. v27.0.0 ------- * Now use Warehouse by default for ``upload``, patching ``distutils.config.PyPIRCCommand`` to affect default behavior. Any config in .pypirc should be updated to replace https://pypi.python.org/pypi/ with https://upload.pypi.org/legacy/ Similarly, any passwords stored in the keyring should be updated to use this new value for "system". The ``upload_docs`` command will continue to use the python.org site, but the command is now deprecated. Users are urged to use Read The Docs instead. * #776: Use EXT_SUFFIX for py_limited_api renaming. * #774 and #775: Use LegacyVersion from packaging when detecting numpy versions. v26.1.1 ------- * Re-release of 26.1.0 with pytest pinned to allow for automated deployment and thus proper packaging environment variables, fixing issues with missing executable launchers. v26.1.0 ------- * #763: ``pkg_resources.get_default_cache`` now defers to the `appdirs project `_ to resolve the cache directory. Adds a vendored dependency on appdirs to pkg_resources. v26.0.0 ------- * #748: By default, sdists are now produced in gzipped tarfile format by default on all platforms, adding forward compatibility for the same behavior in Python 3.6 (See Python #27819). * #459 via #736: On Windows with script launchers, sys.argv[0] now reflects the name of the entry point, consistent with the behavior in distlib and pip wrappers. * #752 via #753: When indicating ``py_limited_api`` to Extension, it must be passed as a keyword argument. v25.4.0 ------- * Add Extension(py_limited_api=True). When set to a truthy value, that extension gets a filename appropriate for code using Py_LIMITED_API. When used correctly this allows a single compiled extension to work on all future versions of CPython 3. The py_limited_api argument only controls the filename. To be compatible with multiple versions of Python 3, the C extension will also need to set -DPy_LIMITED_API=... and be modified to use only the functions in the limited API. v25.3.0 ------- * #739 Fix unquoted libpaths by fixing compatibility between ``numpy.distutils`` and ``distutils._msvccompiler`` for numpy < 1.11.2 (Fix issue #728, error also fixed in Numpy). * #731: Bump certifi. * Style updates. See #740, #741, #743, #744, #742, #747. * #735: include license file. v25.2.0 ------- * #612 via #730: Add a LICENSE file which needs to be provided by the terms of the MIT license. v25.1.6 ------- * #725: revert ``library_dir_option`` patch (Error is related to ``numpy.distutils`` and make errors on non Numpy users). v25.1.5 ------- * #720 * #723: Improve patch for ``library_dir_option``. v25.1.4 ------- * #717 * #713 * #707: Fix Python 2 compatibility for MSVC by catching errors properly. * #715: Fix unquoted libpaths by patching ``library_dir_option``. v25.1.3 ------- * #714 and #704: Revert fix as it breaks other components downstream that can't handle unicode. See #709, #710, and #712. v25.1.2 ------- * #704: Fix errors when installing a zip sdist that contained files named with non-ascii characters on Windows would crash the install when it attempted to clean up the build. * #646: MSVC compatibility - catch errors properly in RegistryInfo.lookup. * #702: Prevent UnboundLocalError when initial working_set is empty. v25.1.1 ------- * #686: Fix issue in sys.path ordering by pkg_resources when rewrite technique is "raw". * #699: Fix typo in msvc support. v25.1.0 ------- * #609: Setuptools will now try to download a distribution from the next possible download location if the first download fails. This means you can now specify multiple links as ``dependency_links`` and all links will be tried until a working download link is encountered. v25.0.2 ------- * #688: Fix AttributeError in setup.py when invoked not from the current directory. v25.0.1 ------- * Cleanup of setup.py script. * Fixed documentation builders by allowing setup.py to be imported without having bootstrapped the metadata. * More style cleanup. See #677, #678, #679, #681, #685. v25.0.0 ------- * #674: Default ``sys.path`` manipulation by easy-install.pth is now "raw", meaning that when writing easy-install.pth during any install operation, the ``sys.path`` will not be rewritten and will no longer give preference to easy_installed packages. To retain the old behavior when using any easy_install operation (including ``setup.py install`` when setuptools is present), set the environment variable: SETUPTOOLS_SYS_PATH_TECHNIQUE=rewrite This project hopes that that few if any environments find it necessary to retain the old behavior, and intends to drop support for it altogether in a future release. Please report any relevant concerns in the ticket for this change. v24.3.1 ------- * #398: Fix shebang handling on Windows in script headers where spaces in ``sys.executable`` would produce an improperly-formatted shebang header, introduced in 12.0 with the fix for #188. * #663, #670: More style updates. v24.3.0 ------- * #516: Disable ``os.link`` to avoid hard linking in ``sdist.make_distribution``, avoiding errors on systems that support hard links but not on the file system in which the build is occurring. v24.2.1 ------- * #667: Update Metadata-Version to 1.2 when ``python_requires`` is supplied. v24.2.0 ------- * #631: Add support for ``python_requires`` keyword. v24.1.1 ------- * More style updates. See #660, #661, #641. v24.1.0 ------- * #659: ``setup.py`` now will fail fast and with a helpful error message when the necessary metadata is missing. * More style updates. See #656, #635, #640, #644, #650, #652, and #655. v24.0.3 ------- * Updated style in much of the codebase to match community expectations. See #632, #633, #634, #637, #639, #638, #642, #648. v24.0.2 ------- * If MSVC++14 is needed ``setuptools.msvc`` now redirect user to Visual C++ Build Tools web page. v24.0.1 ------- * #625 and #626: Fixes on ``setuptools.msvc`` mainly for Python 2 and Linux. v24.0.0 ------- * Pull Request #174: Add more aggressive support for standalone Microsoft Visual C++ compilers in msvc9compiler patch. Particularly : Windows SDK 6.1 and 7.0 (MSVC++ 9.0), Windows SDK 7.1 (MSVC++ 10.0), Visual C++ Build Tools 2015 (MSVC++14) * Renamed ``setuptools.msvc9_support`` to ``setuptools.msvc``. v23.2.1 ------- Re-release of v23.2.0, which was missing the intended commits. * #623: Remove used of deprecated 'U' flag when reading manifests. v23.1.0 ------- * #619: Deprecated ``tag_svn_revision`` distribution option. v23.0.0 ------- * #611: Removed ARM executables for CLI and GUI script launchers on Windows. If this was a feature you cared about, please comment in the ticket. * #604: Removed docs building support. The project now relies on documentation hosted at https://setuptools.pypa.io/. v22.0.5 ------- * #604: Restore repository for upload_docs command to restore publishing of docs during release. v22.0.4 ------- * #589: Upload releases to pypi.io using the upload hostname and legacy path. v22.0.3 ------- * #589: Releases are now uploaded to pypi.io (Warehouse) even when releases are made on Twine via Travis. v22.0.2 ------- * #589: Releases are now uploaded to pypi.io (Warehouse). v22.0.1 ------- * #190: On Python 2, if unicode is passed for packages to ``build_py`` command, it will be handled just as with text on Python 3. v22.0.0 ------- Intended to be v21.3.0, but jaraco accidentally released as a major bump. * #598: Setuptools now lists itself first in the User-Agent for web requests, better following the guidelines in `RFC 7231 `_. v21.2.2 ------- * Minor fixes to changelog and docs. v21.2.1 ------- * #261: Exclude directories when resolving globs in package_data. v21.2.0 ------- * #539: In the easy_install get_site_dirs, honor all paths found in ``site.getsitepackages``. v21.1.0 ------- * #572: In build_ext, now always import ``_CONFIG_VARS`` from ``distutils`` rather than from ``sysconfig`` to allow ``distutils.sysconfig.customize_compiler`` configure the OS X compiler for ``-dynamiclib``. v21.0.0 ------- * Removed ez_setup.py from Setuptools sdist. The bootstrap script will be maintained in its own branch and should be generally be retrieved from its canonical location at https://bootstrap.pypa.io/ez_setup.py. v20.10.0 -------- * #553: egg_info section is now generated in a deterministic order, matching the order generated by earlier versions of Python. Except on Python 2.6, order is preserved when existing settings are present. * #556: Update to Packaging 16.7, restoring support for deprecated ``python_implmentation`` marker. * #555: Upload command now prompts for a password when uploading to PyPI (or other repository) if no password is present in .pypirc or in the keyring. v20.9.0 ------- * #548: Update certify version to 2016.2.28 * #545: Safely handle deletion of non-zip eggs in rotate command. v20.8.1 ------- * Issue #544: Fix issue with extra environment marker processing in WorkingSet due to refactor in v20.7.0. v20.8.0 ------- * Issue #543: Re-release so that latest release doesn't cause déjà vu with distribute and setuptools 0.7 in older environments. v20.7.0 ------- * Refactored extra environment marker processing in WorkingSet. * Issue #533: Fixed intermittent test failures. * Issue #536: In msvc9_support, trap additional exceptions that might occur when importing ``distutils.msvc9compiler`` in mingw environments. * Issue #537: Provide better context when package metadata fails to decode in UTF-8. v20.6.8 ------- * Issue #523: Restored support for environment markers, now honoring 'extra' environment markers. v20.6.7 ------- * Issue #523: Disabled support for environment markers introduced in v20.5. v20.6.6 ------- * Issue #503: Restore support for PEP 345 environment markers by updating to Packaging 16.6. v20.6.0 ------- * New release process that relies on `bumpversion `_ and Travis CI for continuous deployment. * Project versioning semantics now follow `semver `_ precisely. The 'v' prefix on version numbers now also allows version numbers to be referenced in the changelog, e.g. http://setuptools.pypa.io/en/latest/history.html#v20-6-0. 20.5 ---- * BB Pull Request #185, #470: Add support for environment markers in requirements in install_requires, setup_requires, tests_require as well as adding a test for the existing extra_requires machinery. 20.4 ---- * Issue #422: Moved hosting to `Github `_ from `Bitbucket `_. Issues have been migrated, though all issues and comments are attributed to bb-migration. So if you have a particular issue or issues to which you've been subscribed, you will want to "watch" the equivalent issue in Github. The Bitbucket project will be retained for the indefinite future, but Github now hosts the canonical project repository. 20.3.1 ------ * Issue #519: Remove import hook when reloading the ``pkg_resources`` module. * BB Pull Request #184: Update documentation in ``pkg_resources`` around new ``Requirement`` implementation. 20.3 ---- * BB Pull Request #179: ``pkg_resources.Requirement`` objects are now a subclass of ``packaging.requirements.Requirement``, allowing any environment markers and url (if any) to be affiliated with the requirement * BB Pull Request #179: Restore use of RequirementParseError exception unintentionally dropped in 20.2. 20.2.2 ------ * Issue #502: Correct regression in parsing of multiple version specifiers separated by commas and spaces. 20.2.1 ------ * Issue #499: Restore compatibility for legacy versions by bumping to packaging 16.4. 20.2 ---- * Changelog now includes release dates and links to PEPs. * BB Pull Request #173: Replace dual PEP 345 _markerlib implementation and PEP 426 implementation of environment marker support from packaging 16.1 and PEP 508. Fixes Issue #122. See also BB Pull Request #175, BB Pull Request #168, and BB Pull Request #164. Additionally: - ``Requirement.parse`` no longer retains the order of extras. - ``parse_requirements`` now requires that all versions be PEP-440 compliant, as revealed in #499. Packages released with invalid local versions should be re-released using the proper local version syntax, e.g. ``mypkg-1.0+myorg.1``. 20.1.1 ------ * Update ``upload_docs`` command to also honor keyring for password resolution. 20.1 ---- * Added support for using passwords from keyring in the upload command. See `the upload docs `_ for details. 20.0 ---- * Issue #118: Once again omit the package metadata (egg-info) from the list of outputs in ``--record``. This version of setuptools can no longer be used to upgrade pip earlier than 6.0. 19.7 ---- * Off-project PR: `0dcee79 `_ and `f9bd9b9 `_ For FreeBSD, also `honor root certificates from ca_root_nss `_. 19.6.2 ------ * Issue #491: Correct regression incurred in 19.4 where a double-namespace package installed using pip would cause a TypeError. 19.6.1 ------ * Restore compatibility for PyPy 3 compatibility lost in 19.4.1 addressing Issue #487. * ``setuptools.launch`` shim now loads scripts in a new namespace, avoiding getting relative imports from the setuptools package on Python 2. 19.6 ---- * Added a new entry script ``setuptools.launch``, implementing the shim found in ``pip.util.setuptools_build``. Use this command to launch distutils-only packages under setuptools in the same way that pip does, causing the setuptools monkeypatching of distutils to be invoked prior to invoking a script. Useful for debugging or otherwise installing a distutils-only package under setuptools when pip isn't available or otherwise does not expose the desired functionality. For example:: $ python -m setuptools.launch setup.py develop * Issue #488: Fix dual manifestation of Extension class in extension packages installed as dependencies when Cython is present. 19.5 ---- * Issue #486: Correct TypeError when getfilesystemencoding returns None. * Issue #139: Clarified the license as MIT. * BB Pull Request #169: Removed special handling of command spec in scripts for Jython. 19.4.1 ------ * Issue #487: Use direct invocation of ``importlib.machinery`` in ``pkg_resources`` to avoid missing detection on relevant platforms. 19.4 ---- * Issue #341: Correct error in path handling of package data files in ``build_py`` command when package is empty. * Distribute #323, Issue #141, Issue #207, and BB Pull Request #167: Another implementation of ``pkg_resources.WorkingSet`` and ``pkg_resources.Distribution`` that supports replacing an extant package with a new one, allowing for setup_requires dependencies to supersede installed packages for the session. 19.3 ---- * Issue #229: Implement new technique for readily incorporating dependencies conditionally from vendored copies or primary locations. Adds a new dependency on six. 19.2 ---- * BB Pull Request #163: Add get_command_list method to Distribution. * BB Pull Request #162: Add missing whitespace to multiline string literals. 19.1.1 ------ * Issue #476: Cast version to string (using default encoding) to avoid creating Unicode types on Python 2 clients. * Issue #477: In Powershell downloader, use explicit rendering of strings, rather than rely on ``repr``, which can be incorrect (especially on Python 2). 19.1 ---- * Issue #215: The bootstrap script ``ez_setup.py`` now automatically detects the latest version of setuptools (using PyPI JSON API) rather than hard-coding a particular value. * Issue #475: Fix incorrect usage in _translate_metadata2. 19.0 ---- * Issue #442: Use RawConfigParser for parsing .pypirc file. Interpolated values are no longer honored in .pypirc files. 18.8.1 ------ * Issue #440: Prevent infinite recursion when a SandboxViolation or other UnpickleableException occurs in a sandbox context with setuptools hidden. Fixes regression introduced in Setuptools 12.0. 18.8 ---- * Deprecated ``egg_info.get_pkg_info_revision``. * Issue #471: Don't rely on repr for an HTML attribute value in package_index. * Issue #419: Avoid errors in FileMetadata when the metadata directory is broken. * Issue #472: Remove deprecated use of 'U' in mode parameter when opening files. 18.7.1 ------ * Issue #469: Refactored logic for Issue #419 fix to re-use metadata loading from Provider. 18.7 ---- * Update dependency on certify. * BB Pull Request #160: Improve detection of gui script in ``easy_install._adjust_header``. * Made ``test.test_args`` a non-data property; alternate fix for the issue reported in BB Pull Request #155. * Issue #453: In ``ez_setup`` bootstrap module, unload all ``pkg_resources`` modules following download. * BB Pull Request #158: Honor PEP-488 when excluding files for namespace packages. * Issue #419 and BB Pull Request #144: Add experimental support for reading the version info from distutils-installed metadata rather than using the version in the filename. 18.6.1 ------ * Issue #464: Correct regression in invocation of superclass on old-style class on Python 2. 18.6 ---- * Issue #439: When installing entry_point scripts under development, omit the version number of the package, allowing any version of the package to be used. 18.5 ---- * In preparation for dropping support for Python 3.2, a warning is now logged when pkg_resources is imported on Python 3.2 or earlier Python 3 versions. * `Add support for python_platform_implementation environment marker `_. * `Fix dictionary mutation during iteration `_. 18.4 ---- * Issue #446: Test command now always invokes unittest, even if no test suite is supplied. 18.3.2 ------ * Correct another regression in setuptools.findall where the fix for Python #12885 was lost. 18.3.1 ------ * Issue #425: Correct regression in setuptools.findall. 18.3 ---- * BB Pull Request #135: Setuptools now allows disabling of the manipulation of the sys.path during the processing of the easy-install.pth file. To do so, set the environment variable ``SETUPTOOLS_SYS_PATH_TECHNIQUE`` to anything but "rewrite" (consider "raw"). During any install operation with manipulation disabled, setuptools packages will be appended to sys.path naturally. Future versions may change the default behavior to disable manipulation. If so, the default behavior can be retained by setting the variable to "rewrite". * Issue #257: ``easy_install --version`` now shows more detail about the installation location and Python version. * Refactor setuptools.findall in preparation for re-submission back to distutils. 18.2 ---- * Issue #412: More efficient directory search in ``find_packages``. 18.1 ---- * Upgrade to vendored packaging 15.3. 18.0.1 ------ * Issue #401: Fix failure in test suite. 18.0 ---- * Dropped support for builds with Pyrex. Only Cython is supported. * Issue #288: Detect Cython later in the build process, after ``setup_requires`` dependencies are resolved. Projects backed by Cython can now be readily built with a ``setup_requires`` dependency. For example:: ext = setuptools.Extension('mylib', ['src/CythonStuff.pyx', 'src/CStuff.c']) setuptools.setup( ... ext_modules=[ext], setup_requires=['cython'], ) For compatibility with older versions of setuptools, packagers should still include ``src/CythonMod.c`` in the source distributions or require that Cython be present before building source distributions. However, for systems with this build of setuptools, Cython will be downloaded on demand. * Issue #396: Fixed test failure on OS X. * BB Pull Request #136: Remove excessive quoting from shebang headers for Jython. 17.1.1 ------ * Backed out unintended changes to pkg_resources, restoring removal of deprecated imp module (`ref `_). 17.1 ---- * Issue #380: Add support for range operators on environment marker evaluation. 17.0 ---- * Issue #378: Do not use internal importlib._bootstrap module. * Issue #390: Disallow console scripts with path separators in the name. Removes unintended functionality and brings behavior into parity with pip. 16.0 ---- * BB Pull Request #130: Better error messages for errors in parsed requirements. * BB Pull Request #133: Removed ``setuptools.tests`` from the installed packages. * BB Pull Request #129: Address deprecation warning due to usage of imp module. 15.2 ---- * Issue #373: Provisionally expose ``pkg_resources._initialize_master_working_set``, allowing for imperative re-initialization of the master working set. 15.1 ---- * Updated to Packaging 15.1 to address Packaging #28. * Fix ``setuptools.sandbox._execfile()`` with Python 3.1. 15.0 ---- * BB Pull Request #126: DistributionNotFound message now lists the package or packages that required it. E.g.:: pkg_resources.DistributionNotFound: The 'colorama>=0.3.1' distribution was not found and is required by smlib.log. Note that zc.buildout once dependended on the string rendering of this message to determine the package that was not found. This expectation has since been changed, but older versions of buildout may experience problems. See Buildout #242 for details. 14.3.1 ------ * Issue #307: Removed PEP-440 warning during parsing of versions in ``pkg_resources.Distribution``. * Issue #364: Replace deprecated usage with recommended usage of ``EntryPoint.load``. 14.3 ---- * Issue #254: When creating temporary egg cache on Unix, use mode 755 for creating the directory to avoid the subsequent warning if the directory is group writable. 14.2 ---- * Issue #137: Update ``Distribution.hashcmp`` so that Distributions with None for pyversion or platform can be compared against Distributions defining those attributes. 14.1.1 ------ * Issue #360: Removed undesirable behavior from test runs, preventing write tests and installation to system site packages. 14.1 ---- * BB Pull Request #125: Add ``__ne__`` to Requirement class. * Various refactoring of easy_install. 14.0 ---- * Bootstrap script now accepts ``--to-dir`` to customize save directory or allow for re-use of existing repository of setuptools versions. See BB Pull Request #112 for background. * Issue #285: ``easy_install`` no longer will default to installing packages to the "user site packages" directory if it is itself installed there. Instead, the user must pass ``--user`` in all cases to install packages to the user site packages. This behavior now matches that of "pip install". To configure an environment to always install to the user site packages, consider using the "install-dir" and "scripts-dir" parameters to easy_install through an appropriate distutils config file. 13.0.2 ------ * Issue #359: Include pytest.ini in the sdist so invocation of py.test on the sdist honors the pytest configuration. 13.0.1 ------ Re-release of 13.0. Intermittent connectivity issues caused the release process to fail and PyPI uploads no longer accept files for 13.0. 13.0 ---- * Issue #356: Back out BB Pull Request #119 as it requires Setuptools 10 or later as the source during an upgrade. * Removed build_py class from setup.py. According to 892f439d216e, this functionality was added to support upgrades from old Distribute versions, 0.6.5 and 0.6.6. 12.4 ---- * BB Pull Request #119: Restore writing of ``setup_requires`` to metadata (previously added in 8.4 and removed in 9.0). 12.3 ---- * Documentation is now linked using the rst.linker package. * Fix ``setuptools.command.easy_install.extract_wininst_cfg()`` with Python 2.6 and 2.7. * Issue #354. Added documentation on building setuptools documentation. 12.2 ---- * Issue #345: Unload all modules under pkg_resources during ``ez_setup.use_setuptools()``. * Issue #336: Removed deprecation from ``ez_setup.use_setuptools``, as it is clearly still used by buildout's bootstrap. ``ez_setup`` remains deprecated for use by individual packages. * Simplified implementation of ``ez_setup.use_setuptools``. 12.1 ---- * BB Pull Request #118: Soften warning for non-normalized versions in Distribution. 12.0.5 ------ * Issue #339: Correct Attribute reference in ``cant_write_to_target``. * Issue #336: Deprecated ``ez_setup.use_setuptools``. 12.0.4 ------ * Issue #335: Fix script header generation on Windows. 12.0.3 ------ * Fixed incorrect class attribute in ``install_scripts``. Tests would be nice. 12.0.2 ------ * Issue #331: Fixed ``install_scripts`` command on Windows systems corrupting the header. 12.0.1 ------ * Restore ``setuptools.command.easy_install.sys_executable`` for pbr compatibility. For the future, tools should construct a CommandSpec explicitly. 12.0 ---- * Issue #188: Setuptools now support multiple entities in the value for ``build.executable``, such that an executable of "/usr/bin/env my-python" may be specified. This means that systems with a specified executable whose name has spaces in the path must be updated to escape or quote that value. * Deprecated ``easy_install.ScriptWriter.get_writer``, replaced by ``.best()`` with slightly different semantics (no force_windows flag). 11.3.1 ------ * Issue #327: Formalize and restore support for any printable character in an entry point name. 11.3 ---- * Expose ``EntryPoint.resolve`` in place of EntryPoint._load, implementing the simple, non-requiring load. Deprecated all uses of ``EntryPoint._load`` except for calling with no parameters, which is just a shortcut for ``ep.require(); ep.resolve();``. Apps currently invoking ``ep.load(require=False)`` should instead do the following if wanting to avoid the deprecating warning:: getattr(ep, "resolve", lambda: ep.load(require=False))() 11.2 ---- * Pip #2326: Report deprecation warning at stacklevel 2 for easier diagnosis. 11.1 ---- * Issue #281: Since Setuptools 6.1 (Issue #268), a ValueError would be raised in certain cases where VersionConflict was raised with two arguments, which occurred in ``pkg_resources.WorkingSet.find``. This release adds support for indicating the dependent packages while maintaining support for a VersionConflict when no dependent package context is known. New unit tests now capture the expected interface. 11.0 ---- * Interop #3: Upgrade to Packaging 15.0; updates to PEP 440 so that >1.7 does not exclude 1.7.1 but does exclude 1.7.0 and 1.7.0.post1. 10.2.1 ------ * Issue #323: Fix regression in entry point name parsing. 10.2 ---- * Deprecated use of EntryPoint.load(require=False). Passing a boolean to a function to select behavior is an anti-pattern. Instead use ``Entrypoint._load()``. * Substantial refactoring of all unit tests. Tests are now much leaner and re-use a lot of fixtures and contexts for better clarity of purpose. 10.1 ---- * Issue #320: Added a compatibility implementation of ``sdist._default_revctrl`` so that systems relying on that interface do not fail (namely, Ubuntu 12.04 and similar Debian releases). 10.0.1 ------ * Issue #319: Fixed issue installing pure distutils packages. 10.0 ---- * Issue #313: Removed built-in support for subversion. Projects wishing to retain support for subversion will need to use a third party library. The extant implementation is being ported to `setuptools_svn `_. * Issue #315: Updated setuptools to hide its own loaded modules during installation of another package. This change will enable setuptools to upgrade (or downgrade) itself even when its own metadata and implementation change. 9.1 --- * Prefer vendored packaging library `as recommended `_. 9.0.1 ----- * Issue #312: Restored presence of pkg_resources API tests (doctest) to sdist. 9.0 --- * Issue #314: Disabled support for ``setup_requires`` metadata to avoid issue where Setuptools was unable to upgrade over earlier versions. 8.4 --- * BB Pull Request #106: Now write ``setup_requires`` metadata. 8.3 --- * Issue #311: Decoupled pkg_resources from setuptools once again. ``pkg_resources`` is now a package instead of a module. 8.2.1 ----- * Issue #306: Suppress warnings about Version format except in select scenarios (such as installation). 8.2 --- * BB Pull Request #85: Search egg-base when adding egg-info to manifest. 8.1 --- * Upgrade ``packaging`` to 14.5, giving preference to "rc" as designator for release candidates over "c". * PEP-440 warnings are now raised as their own class, ``pkg_resources.PEP440Warning``, instead of RuntimeWarning. * Disabled warnings on empty versions. 8.0.4 ----- * Upgrade ``packaging`` to 14.4, fixing an error where there is a different result for if 2.0.5 is contained within >2.0dev and >2.0.dev even though normalization rules should have made them equal. * Issue #296: Add warning when a version is parsed as legacy. This warning will make it easier for developers to recognize deprecated version numbers. 8.0.3 ----- * Issue #296: Restored support for ``__hash__`` on parse_version results. 8.0.2 ----- * Issue #296: Restored support for ``__getitem__`` and sort operations on parse_version result. 8.0.1 ----- * Issue #296: Restore support for iteration over parse_version result, but deprecated that usage with a warning. Fixes failure with buildout. 8.0 --- * Implement PEP 440 within pkg_resources and setuptools. This change deprecates some version numbers such that they will no longer be installable without using the ``===`` escape hatch. See `the changes to test_resources `_ for specific examples of version numbers and specifiers that are no longer supported. Setuptools now "vendors" the `packaging `_ library. 7.0 --- * Issue #80, Issue #209: Eggs that are downloaded for ``setup_requires``, ``test_requires``, etc. are now placed in a ``./.eggs`` directory instead of directly in the current directory. This choice of location means the files can be readily managed (removed, ignored). Additionally, later phases or invocations of setuptools will not detect the package as already installed and ignore it for permanent install (See #209). This change is indicated as backward-incompatible as installations that depend on the installation in the current directory will need to account for the new location. Systems that ignore ``*.egg`` will probably need to be adapted to ignore ``.eggs``. The files will need to be manually moved or will be retrieved again. Most use cases will require no attention. 6.1 --- * Issue #268: When resolving package versions, a VersionConflict now reports which package previously required the conflicting version. 6.0.2 ----- * Issue #262: Fixed regression in pip install due to egg-info directories being omitted. Re-opens Issue #118. 6.0.1 ----- * Issue #259: Fixed regression with namespace package handling on ``single version, externally managed`` installs. 6.0 --- * Issue #100: When building a distribution, Setuptools will no longer match default files using platform-dependent case sensitivity, but rather will only match the files if their case matches exactly. As a result, on Windows and other case-insensitive file systems, files with names such as 'readme.txt' or 'README.TXT' will be omitted from the distribution and a warning will be issued indicating that 'README.txt' was not found. Other filenames affected are: - README.rst - README - setup.cfg - setup.py (or the script name) - test/test*.py Any users producing distributions with filenames that match those above case-insensitively, but not case-sensitively, should rename those files in their repository for better portability. * BB Pull Request #72: When using ``single_version_externally_managed``, the exclusion list now includes Python 3.2 ``__pycache__`` entries. * BB Pull Request #76 and BB Pull Request #78: lines in top_level.txt are now ordered deterministically. * Issue #118: The egg-info directory is now no longer included in the list of outputs. * Issue #258: Setuptools now patches distutils msvc9compiler to recognize the specially-packaged compiler package for easy extension module support on Python 2.6, 2.7, and 3.2. 5.8 --- * Issue #237: ``pkg_resources`` now uses explicit detection of Python 2 vs. Python 3, supporting environments where builtins have been patched to make Python 3 look more like Python 2. 5.7 --- * Issue #240: Based on real-world performance measures against 5.4, zip manifests are now cached in all circumstances. The ``PKG_RESOURCES_CACHE_ZIP_MANIFESTS`` environment variable is no longer relevant. The observed "memory increase" referenced in the 5.4 release notes and detailed in Issue #154 was likely not an increase over the status quo, but rather only an increase over not storing the zip info at all. 5.6 --- * Issue #242: Use absolute imports in svn_utils to avoid issues if the installing package adds an xml module to the path. 5.5.1 ----- * Issue #239: Fix typo in 5.5 such that fix did not take. 5.5 --- * Issue #239: Setuptools now includes the setup_requires directive on Distribution objects and validates the syntax just like install_requires and tests_require directives. 5.4.2 ----- * Issue #236: Corrected regression in execfile implementation for Python 2.6. 5.4.1 ----- * Python #7776: (ssl_support) Correct usage of host for validation when tunneling for HTTPS. 5.4 --- * Issue #154: ``pkg_resources`` will now cache the zip manifests rather than re-processing the same file from disk multiple times, but only if the environment variable ``PKG_RESOURCES_CACHE_ZIP_MANIFESTS`` is set. Clients that package many modules in the same zip file will see some improvement in startup time by enabling this feature. This feature is not enabled by default because it causes a substantial increase in memory usage. 5.3 --- * Issue #185: Make svn tagging work on the new style SVN metadata. Thanks cazabon! * Prune revision control directories (e.g .svn) from base path as well as sub-directories. 5.2 --- * Added a `Developer Guide `_ to the official documentation. * Some code refactoring and cleanup was done with no intended behavioral changes. * During install_egg_info, the generated lines for namespace package .pth files are now processed even during a dry run. 5.1 --- * Issue #202: Implemented more robust cache invalidation for the ZipImporter, building on the work in Issue #168. Special thanks to Jurko Gospodnetic and PJE. 5.0.2 ----- * Issue #220: Restored script templates. 5.0.1 ----- * Renamed script templates to end with .tmpl now that they no longer need to be processed by 2to3. Fixes spurious syntax errors during build/install. 5.0 --- * Issue #218: Re-release of 3.8.1 to signal that it supersedes 4.x. * Incidentally, script templates were updated not to include the triple-quote escaping. 3.7.1 and 3.8.1 and 4.0.1 ------------------------- * Issue #213: Use legacy StringIO behavior for compatibility under pbr. * Issue #218: Setuptools 3.8.1 superseded 4.0.1, and 4.x was removed from the available versions to install. 4.0 --- * Issue #210: ``setup.py develop`` now copies scripts in binary mode rather than text mode, matching the behavior of the ``install`` command. 3.8 --- * Extend Issue #197 workaround to include all Python 3 versions prior to 3.2.2. 3.7 --- * Issue #193: Improved handling of Unicode filenames when building manifests. 3.6 --- * Issue #203: Honor proxy settings for Powershell downloader in the bootstrap routine. 3.5.2 ----- * Issue #168: More robust handling of replaced zip files and stale caches. Fixes ZipImportError complaining about a 'bad local header'. 3.5.1 ----- * Issue #199: Restored ``install._install`` for compatibility with earlier NumPy versions. 3.5 --- * Issue #195: Follow symbolic links in find_packages (restoring behavior broken in 3.4). * Issue #197: On Python 3.1, PKG-INFO is now saved in a UTF-8 encoding instead of ``sys.getpreferredencoding`` to match the behavior on Python 2.6-3.4. * Issue #192: Preferred bootstrap location is now https://bootstrap.pypa.io/ez_setup.py (mirrored from former location). 3.4.4 ----- * Issue #184: Correct failure where find_package over-matched packages when directory traversal isn't short-circuited. 3.4.3 ----- * Issue #183: Really fix test command with Python 3.1. 3.4.2 ----- * Issue #183: Fix additional regression in test command on Python 3.1. 3.4.1 ----- * Issue #180: Fix regression in test command not caught by py.test-run tests. 3.4 --- * Issue #176: Add parameter to the test command to support a custom test runner: --test-runner or -r. * Issue #177: Now assume most common invocation to install command on platforms/environments without stack support (issuing a warning). Setuptools now installs naturally on IronPython. Behavior on CPython should be unchanged. 3.3 --- * Add ``include`` parameter to ``setuptools.find_packages()``. 3.2 --- * BB Pull Request #39: Add support for C++ targets from Cython ``.pyx`` files. * Issue #162: Update dependency on certifi to 1.0.1. * Issue #164: Update dependency on wincertstore to 0.2. 3.1 --- * Issue #161: Restore Features functionality to allow backward compatibility (for Features) until the uses of that functionality is sufficiently removed. 3.0.2 ----- * Correct typo in previous bugfix. 3.0.1 ----- * Issue #157: Restore support for Python 2.6 in bootstrap script where ``zipfile.ZipFile`` does not yet have support for context managers. 3.0 --- * Issue #125: Prevent Subversion support from creating a ~/.subversion directory just for checking the presence of a Subversion repository. * Issue #12: Namespace packages are now imported lazily. That is, the mere declaration of a namespace package in an egg on ``sys.path`` no longer causes it to be imported when ``pkg_resources`` is imported. Note that this change means that all of a namespace package's ``__init__.py`` files must include a ``declare_namespace()`` call in order to ensure that they will be handled properly at runtime. In 2.x it was possible to get away without including the declaration, but only at the cost of forcing namespace packages to be imported early, which 3.0 no longer does. * Issue #148: When building (bdist_egg), setuptools no longer adds ``__init__.py`` files to namespace packages. Any packages that rely on this behavior will need to create ``__init__.py`` files and include the ``declare_namespace()``. * Issue #7: Setuptools itself is now distributed as a zip archive in addition to tar archive. ez_setup.py now uses zip archive. This approach avoids the potential security vulnerabilities presented by use of tar archives in ez_setup.py. It also leverages the security features added to ZipFile.extract in Python 2.7.4. * Issue #65: Removed deprecated Features functionality. * BB Pull Request #28: Remove backport of ``_bytecode_filenames`` which is available in Python 2.6 and later, but also has better compatibility with Python 3 environments. * Issue #156: Fix spelling of __PYVENV_LAUNCHER__ variable. 2.2 --- * Issue #141: Restored fix for allowing setup_requires dependencies to override installed dependencies during setup. * Issue #128: Fixed issue where only the first dependency link was honored in a distribution where multiple dependency links were supplied. 2.1.2 ----- * Issue #144: Read long_description using codecs module to avoid errors installing on systems where LANG=C. 2.1.1 ----- * Issue #139: Fix regression in re_finder for CVS repos (and maybe Git repos as well). 2.1 --- * Issue #129: Suppress inspection of ``*.whl`` files when searching for files in a zip-imported file. * Issue #131: Fix RuntimeError when constructing an egg fetcher. 2.0.2 ----- * Fix NameError during installation with Python implementations (e.g. Jython) not containing parser module. * Fix NameError in ``sdist:re_finder``. 2.0.1 ----- * Issue #124: Fixed error in list detection in upload_docs. 2.0 --- * Issue #121: Exempt lib2to3 pickled grammars from DirectorySandbox. * Issue #41: Dropped support for Python 2.4 and Python 2.5. Clients requiring setuptools for those versions of Python should use setuptools 1.x. * Removed ``setuptools.command.easy_install.HAS_USER_SITE``. Clients expecting this boolean variable should use ``site.ENABLE_USER_SITE`` instead. * Removed ``pkg_resources.ImpWrapper``. Clients that expected this class should use ``pkgutil.ImpImporter`` instead. 1.4.2 ----- * Issue #116: Correct TypeError when reading a local package index on Python 3. 1.4.1 ----- * Issue #114: Use ``sys.getfilesystemencoding`` for decoding config in ``bdist_wininst`` distributions. * Issue #105 and Issue #113: Establish a more robust technique for determining the terminal encoding:: 1. Try ``getpreferredencoding`` 2. If that returns US_ASCII or None, try the encoding from ``getdefaultlocale``. If that encoding was a "fallback" because Python could not figure it out from the environment or OS, encoding remains unresolved. 3. If the encoding is resolved, then make sure Python actually implements the encoding. 4. On the event of an error or unknown codec, revert to fallbacks (UTF-8 on Darwin, ASCII on everything else). 5. On the encoding is 'mac-roman' on Darwin, use UTF-8 as 'mac-roman' was a bug on older Python releases. On a side note, it would seem that the encoding only matters for when SVN does not yet support ``--xml`` and when getting repository and svn version numbers. The ``--xml`` technique should yield UTF-8 according to some messages on the SVN mailing lists. So if the version numbers are always 7-bit ASCII clean, it may be best to only support the file parsing methods for legacy SVN releases and support for SVN without the subprocess command would simple go away as support for the older SVNs does. 1.4 --- * Issue #27: ``easy_install`` will now use credentials from .pypirc if present for connecting to the package index. * BB Pull Request #21: Omit unwanted newlines in ``package_index._encode_auth`` when the username/password pair length indicates wrapping. 1.3.2 ----- * Issue #99: Fix filename encoding issues in SVN support. 1.3.1 ----- * Remove exuberant warning in SVN support when SVN is not used. 1.3 --- * Address security vulnerability in SSL match_hostname check as reported in Python #17997. * Prefer `backports.ssl_match_hostname `_ for backport implementation if present. * Correct NameError in ``ssl_support`` module (``socket.error``). 1.2 --- * Issue #26: Add support for SVN 1.7. Special thanks to Philip Thiem for the contribution. * Issue #93: Wheels are now distributed with every release. Note that as reported in Issue #108, as of Pip 1.4, scripts aren't installed properly from wheels. Therefore, if using Pip to install setuptools from a wheel, the ``easy_install`` command will not be available. * Setuptools "natural" launcher support, introduced in 1.0, is now officially supported. 1.1.7 ----- * Fixed behavior of NameError handling in 'script template (dev).py' (script launcher for 'develop' installs). * ``ez_setup.py`` now ensures partial downloads are cleaned up following a failed download. * Distribute #363 and Issue #55: Skip an sdist test that fails on locales other than UTF-8. 1.1.6 ----- * Distribute #349: ``sandbox.execfile`` now opens the target file in binary mode, thus honoring a BOM in the file when compiled. 1.1.5 ----- * Issue #69: Second attempt at fix (logic was reversed). 1.1.4 ----- * Issue #77: Fix error in upload command (Python 2.4). 1.1.3 ----- * Fix NameError in previous patch. 1.1.2 ----- * Issue #69: Correct issue where 404 errors are returned for URLs with fragments in them (such as #egg=). 1.1.1 ----- * Issue #75: Add ``--insecure`` option to ez_setup.py to accommodate environments where a trusted SSL connection cannot be validated. * Issue #76: Fix AttributeError in upload command with Python 2.4. 1.1 --- * Issue #71 (Distribute #333): EasyInstall now puts less emphasis on the condition when a host is blocked via ``--allow-hosts``. * Issue #72: Restored Python 2.4 compatibility in ``ez_setup.py``. 1.0 --- * Issue #60: On Windows, Setuptools supports deferring to another launcher, such as Vinay Sajip's `pylauncher `_ (included with Python 3.3) to launch console and GUI scripts and not install its own launcher executables. This experimental functionality is currently only enabled if the ``SETUPTOOLS_LAUNCHER`` environment variable is set to "natural". In the future, this behavior may become default, but only after it has matured and seen substantial adoption. The ``SETUPTOOLS_LAUNCHER`` also accepts "executable" to force the default behavior of creating launcher executables. * Issue #63: Bootstrap script (ez_setup.py) now prefers Powershell, curl, or wget for retrieving the Setuptools tarball for improved security of the install. The script will still fall back to a simple ``urlopen`` on platforms that do not have these tools. * Issue #65: Deprecated the ``Features`` functionality. * Issue #52: In ``VerifyingHTTPSConn``, handle a tunnelled (proxied) connection. Backward-Incompatible Changes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This release includes a couple of backward-incompatible changes, but most if not all users will find 1.0 a drop-in replacement for 0.9. * Issue #50: Normalized API of environment marker support. Specifically, removed line number and filename from SyntaxErrors when returned from ``pkg_resources.invalid_marker``. Any clients depending on the specific string representation of exceptions returned by that function may need to be updated to account for this change. * Issue #50: SyntaxErrors generated by ``pkg_resources.invalid_marker`` are normalized for cross-implementation consistency. * Removed ``--ignore-conflicts-at-my-risk`` and ``--delete-conflicting`` options to easy_install. These options have been deprecated since 0.6a11. 0.9.8 ----- * Issue #53: Fix NameErrors in ``_vcs_split_rev_from_url``. 0.9.7 ----- * Issue #49: Correct AttributeError on PyPy where a hashlib.HASH object does not have a ``.name`` attribute. * Issue #34: Documentation now refers to bootstrap script in code repository referenced by bookmark. * Add underscore-separated keys to environment markers (markerlib). 0.9.6 ----- * Issue #44: Test failure on Python 2.4 when MD5 hash doesn't have a ``.name`` attribute. 0.9.5 ----- * Python #17980: Fix security vulnerability in SSL certificate validation. 0.9.4 ----- * Issue #43: Fix issue (introduced in 0.9.1) with version resolution when upgrading over other releases of Setuptools. 0.9.3 ----- * Issue #42: Fix new ``AttributeError`` introduced in last fix. 0.9.2 ----- * Issue #42: Fix regression where blank checksums would trigger an ``AttributeError``. 0.9.1 ----- * Distribute #386: Allow other positional and keyword arguments to os.open. * Corrected dependency on certifi mis-referenced in 0.9. 0.9 --- * ``package_index`` now validates hashes other than MD5 in download links. 0.8 --- * Code base now runs on Python 2.4 - Python 3.3 without Python 2to3 conversion. 0.7.8 ----- * Distribute #375: Yet another fix for yet another regression. 0.7.7 ----- * Distribute #375: Repair AttributeError created in last release (redo). * Issue #30: Added test for get_cache_path. 0.7.6 ----- * Distribute #375: Repair AttributeError created in last release. 0.7.5 ----- * Issue #21: Restore Python 2.4 compatibility in ``test_easy_install``. * Distribute #375: Merged additional warning from Distribute 0.6.46. * Now honor the environment variable ``SETUPTOOLS_DISABLE_VERSIONED_EASY_INSTALL_SCRIPT`` in addition to the now deprecated ``DISTRIBUTE_DISABLE_VERSIONED_EASY_INSTALL_SCRIPT``. 0.7.4 ----- * Issue #20: Fix comparison of parsed SVN version on Python 3. 0.7.3 ----- * Issue #1: Disable installation of Windows-specific files on non-Windows systems. * Use new sysconfig module with Python 2.7 or >=3.2. 0.7.2 ----- * Issue #14: Use markerlib when the ``parser`` module is not available. * Issue #10: ``ez_setup.py`` now uses HTTPS to download setuptools from PyPI. 0.7.1 ----- * Fix NameError (Issue #3) again - broken in bad merge. 0.7 --- * Merged Setuptools and Distribute. See docs/merge.txt for details. Added several features that were slated for setuptools 0.6c12: * Index URL now defaults to HTTPS. * Added experimental environment marker support. Now clients may designate a PEP-426 environment marker for "extra" dependencies. Setuptools uses this feature in ``setup.py`` for optional SSL and certificate validation support on older platforms. Based on Distutils-SIG discussions, the syntax is somewhat tentative. There should probably be a PEP with a firmer spec before the feature should be considered suitable for use. * Added support for SSL certificate validation when installing packages from an HTTPS service. 0.7b4 ----- * Issue #3: Fixed NameError in SSL support. 0.6.49 ------ * Move warning check in ``get_cache_path`` to follow the directory creation to avoid errors when the cache path does not yet exist. Fixes the error reported in Distribute #375. 0.6.48 ------ * Correct AttributeError in ``ResourceManager.get_cache_path`` introduced in 0.6.46 (redo). 0.6.47 ------ * Correct AttributeError in ``ResourceManager.get_cache_path`` introduced in 0.6.46. 0.6.46 ------ * Distribute #375: Issue a warning if the PYTHON_EGG_CACHE or otherwise customized egg cache location specifies a directory that's group- or world-writable. 0.6.45 ------ * Distribute #379: ``distribute_setup.py`` now traps VersionConflict as well, restoring ability to upgrade from an older setuptools version. 0.6.44 ------ * ``distribute_setup.py`` has been updated to allow Setuptools 0.7 to satisfy use_setuptools. 0.6.43 ------ * Distribute #378: Restore support for Python 2.4 Syntax (regression in 0.6.42). 0.6.42 ------ * External links finder no longer yields duplicate links. * Distribute #337: Moved site.py to setuptools/site-patch.py (graft of very old patch from setuptools trunk which inspired PR #31). 0.6.41 ------ * Distribute #27: Use public api for loading resources from zip files rather than the private method ``_zip_directory_cache``. * Added a new function ``easy_install.get_win_launcher`` which may be used by third-party libraries such as buildout to get a suitable script launcher. 0.6.40 ------ * Distribute #376: brought back cli.exe and gui.exe that were deleted in the previous release. 0.6.39 ------ * Add support for console launchers on ARM platforms. * Fix possible issue in GUI launchers where the subsystem was not supplied to the linker. * Launcher build script now refactored for robustness. * Distribute #375: Resources extracted from a zip egg to the file system now also check the contents of the file against the zip contents during each invocation of get_resource_filename. 0.6.38 ------ * Distribute #371: The launcher manifest file is now installed properly. 0.6.37 ------ * Distribute #143: Launcher scripts, including easy_install itself, are now accompanied by a manifest on 32-bit Windows environments to avoid the Installer Detection Technology and thus undesirable UAC elevation described in `this Microsoft article `_. 0.6.36 ------ * BB Pull Request #35: In Buildout #64, it was reported that under Python 3, installation of distutils scripts could attempt to copy the ``__pycache__`` directory as a file, causing an error, apparently only under Windows. Easy_install now skips all directories when processing metadata scripts. 0.6.35 ------ Note this release is backward-incompatible with distribute 0.6.23-0.6.34 in how it parses version numbers. * Distribute #278: Restored compatibility with distribute 0.6.22 and setuptools 0.6. Updated the documentation to match more closely with the version parsing as intended in setuptools 0.6. 0.6.34 ------ * Distribute #341: 0.6.33 fails to build under Python 2.4. 0.6.33 ------ * Fix 2 errors with Jython 2.5. * Fix 1 failure with Jython 2.5 and 2.7. * Disable workaround for Jython scripts on Linux systems. * Distribute #336: ``setup.py`` no longer masks failure exit code when tests fail. * Fix issue in pkg_resources where try/except around a platform-dependent import would trigger hook load failures on Mercurial. See pull request 32 for details. * Distribute #341: Fix a ResourceWarning. 0.6.32 ------ * Fix test suite with Python 2.6. * Fix some DeprecationWarnings and ResourceWarnings. * Distribute #335: Backed out ``setup_requires`` superseding installed requirements until regression can be addressed. 0.6.31 ------ * Distribute #303: Make sure the manifest only ever contains UTF-8 in Python 3. * Distribute #329: Properly close files created by tests for compatibility with Jython. * Work around Jython #1980 and Jython #1981. * Distribute #334: Provide workaround for packages that reference ``sys.__stdout__`` such as numpy does. This change should address `virtualenv #359 `_ as long as the system encoding is UTF-8 or the IO encoding is specified in the environment, i.e.:: PYTHONIOENCODING=utf8 pip install numpy * Fix for encoding issue when installing from Windows executable on Python 3. * Distribute #323: Allow ``setup_requires`` requirements to supersede installed requirements. Added some new keyword arguments to existing pkg_resources methods. Also had to updated how __path__ is handled for namespace packages to ensure that when a new egg distribution containing a namespace package is placed on sys.path, the entries in __path__ are found in the same order they would have been in had that egg been on the path when pkg_resources was first imported. 0.6.30 ------ * Distribute #328: Clean up temporary directories in distribute_setup.py. * Fix fatal bug in distribute_setup.py. 0.6.29 ------ * BB Pull Request #14: Honor file permissions in zip files. * Distribute #327: Merged pull request #24 to fix a dependency problem with pip. * Merged pull request #23 to fix https://github.com/pypa/virtualenv/issues/301. * If Sphinx is installed, the ``upload_docs`` command now runs ``build_sphinx`` to produce uploadable documentation. * Distribute #326: ``upload_docs`` provided mangled auth credentials under Python 3. * Distribute #320: Fix check for "creatable" in distribute_setup.py. * Distribute #305: Remove a warning that was triggered during normal operations. * Distribute #311: Print metadata in UTF-8 independent of platform. * Distribute #303: Read manifest file with UTF-8 encoding under Python 3. * Distribute #301: Allow to run tests of namespace packages when using 2to3. * Distribute #304: Prevent import loop in site.py under Python 3.3. * Distribute #283: Re-enable scanning of ``*.pyc`` / ``*.pyo`` files on Python 3.3. * Distribute #299: The develop command didn't work on Python 3, when using 2to3, as the egg link would go to the Python 2 source. Linking to the 2to3'd code in build/lib makes it work, although you will have to rebuild the module before testing it. * Distribute #306: Even if 2to3 is used, we build in-place under Python 2. * Distribute #307: Prints the full path when .svn/entries is broken. * Distribute #313: Support for sdist subcommands (Python 2.7) * Distribute #314: test_local_index() would fail an OS X. * Distribute #310: Non-ascii characters in a namespace __init__.py causes errors. * Distribute #218: Improved documentation on behavior of ``package_data`` and ``include_package_data``. Files indicated by ``package_data`` are now included in the manifest. * ``distribute_setup.py`` now allows a ``--download-base`` argument for retrieving distribute from a specified location. 0.6.28 ------ * Distribute #294: setup.py can now be invoked from any directory. * Scripts are now installed honoring the umask. * Added support for .dist-info directories. * Distribute #283: Fix and disable scanning of ``*.pyc`` / ``*.pyo`` files on Python 3.3. 0.6.27 ------ * Support current snapshots of CPython 3.3. * Distribute now recognizes README.rst as a standard, default readme file. * Exclude 'encodings' modules when removing modules from sys.modules. Workaround for #285. * Distribute #231: Don't fiddle with system python when used with buildout (bootstrap.py) 0.6.26 ------ * Distribute #183: Symlinked files are now extracted from source distributions. * Distribute #227: Easy_install fetch parameters are now passed during the installation of a source distribution; now fulfillment of setup_requires dependencies will honor the parameters passed to easy_install. 0.6.25 ------ * Distribute #258: Workaround a cache issue * Distribute #260: distribute_setup.py now accepts the --user parameter for Python 2.6 and later. * Distribute #262: package_index.open_with_auth no longer throws LookupError on Python 3. * Distribute #269: AttributeError when an exception occurs reading Manifest.in on late releases of Python. * Distribute #272: Prevent TypeError when namespace package names are unicode and single-install-externally-managed is used. Also fixes PIP issue 449. * Distribute #273: Legacy script launchers now install with Python2/3 support. 0.6.24 ------ * Distribute #249: Added options to exclude 2to3 fixers 0.6.23 ------ * Distribute #244: Fixed a test * Distribute #243: Fixed a test * Distribute #239: Fixed a test * Distribute #240: Fixed a test * Distribute #241: Fixed a test * Distribute #237: Fixed a test * Distribute #238: easy_install now uses 64bit executable wrappers on 64bit Python * Distribute #208: Fixed parsed_versions, it now honors post-releases as noted in the documentation * Distribute #207: Windows cli and gui wrappers pass CTRL-C to child python process * Distribute #227: easy_install now passes its arguments to setup.py bdist_egg * Distribute #225: Fixed a NameError on Python 2.5, 2.4 0.6.21 ------ * Distribute #225: FIxed a regression on py2.4 0.6.20 ------ * Distribute #135: Include url in warning when processing URLs in package_index. * Distribute #212: Fix issue where easy_instal fails on Python 3 on windows installer. * Distribute #213: Fix typo in documentation. 0.6.19 ------ * Distribute #206: AttributeError: 'HTTPMessage' object has no attribute 'getheaders' 0.6.18 ------ * Distribute #210: Fixed a regression introduced by Distribute #204 fix. 0.6.17 ------ * Support 'DISTRIBUTE_DISABLE_VERSIONED_EASY_INSTALL_SCRIPT' environment variable to allow to disable installation of easy_install-${version} script. * Support Python >=3.1.4 and >=3.2.1. * Distribute #204: Don't try to import the parent of a namespace package in declare_namespace * Distribute #196: Tolerate responses with multiple Content-Length headers * Distribute #205: Sandboxing doesn't preserve working_set. Leads to setup_requires problems. 0.6.16 ------ * Builds sdist gztar even on Windows (avoiding Distribute #193). * Distribute #192: Fixed metadata omitted on Windows when package_dir specified with forward-slash. * Distribute #195: Cython build support. * Distribute #200: Issues with recognizing 64-bit packages on Windows. 0.6.15 ------ * Fixed typo in bdist_egg * Several issues under Python 3 has been solved. * Distribute #146: Fixed missing DLL files after easy_install of windows exe package. 0.6.14 ------ * Distribute #170: Fixed unittest failure. Thanks to Toshio. * Distribute #171: Fixed race condition in unittests cause deadlocks in test suite. * Distribute #143: Fixed a lookup issue with easy_install. Thanks to David and Zooko. * Distribute #174: Fixed the edit mode when its used with setuptools itself 0.6.13 ------ * Distribute #160: 2.7 gives ValueError("Invalid IPv6 URL") * Distribute #150: Fixed using ~/.local even in a --no-site-packages virtualenv * Distribute #163: scan index links before external links, and don't use the md5 when comparing two distributions 0.6.12 ------ * Distribute #149: Fixed various failures on 2.3/2.4 0.6.11 ------ * Found another case of SandboxViolation - fixed * Distribute #15 and Distribute #48: Introduced a socket timeout of 15 seconds on url openings * Added indexsidebar.html into MANIFEST.in * Distribute #108: Fixed TypeError with Python3.1 * Distribute #121: Fixed --help install command trying to actually install. * Distribute #112: Added an os.makedirs so that Tarek's solution will work. * Distribute #133: Added --no-find-links to easy_install * Added easy_install --user * Distribute #100: Fixed develop --user not taking '.' in PYTHONPATH into account * Distribute #134: removed spurious UserWarnings. Patch by VanLindberg * Distribute #138: cant_write_to_target error when setup_requires is used. * Distribute #147: respect the sys.dont_write_bytecode flag 0.6.10 ------ * Reverted change made for the DistributionNotFound exception because zc.buildout uses the exception message to get the name of the distribution. 0.6.9 ----- * Distribute #90: unknown setuptools version can be added in the working set * Distribute #87: setupt.py doesn't try to convert distribute_setup.py anymore Initial Patch by arfrever. * Distribute #89: added a side bar with a download link to the doc. * Distribute #86: fixed missing sentence in pkg_resources doc. * Added a nicer error message when a DistributionNotFound is raised. * Distribute #80: test_develop now works with Python 3.1 * Distribute #93: upload_docs now works if there is an empty sub-directory. * Distribute #70: exec bit on non-exec files * Distribute #99: now the standalone easy_install command doesn't uses a "setup.cfg" if any exists in the working directory. It will use it only if triggered by ``install_requires`` from a setup.py call (install, develop, etc). * Distribute #101: Allowing ``os.devnull`` in Sandbox * Distribute #92: Fixed the "no eggs" found error with MacPort (platform.mac_ver() fails) * Distribute #103: test_get_script_header_jython_workaround not run anymore under py3 with C or POSIX local. Contributed by Arfrever. * Distribute #104: removed the assertion when the installation fails, with a nicer message for the end user. * Distribute #100: making sure there's no SandboxViolation when the setup script patches setuptools. 0.6.8 ----- * Added "check_packages" in dist. (added in Setuptools 0.6c11) * Fixed the DONT_PATCH_SETUPTOOLS state. 0.6.7 ----- * Distribute #58: Added --user support to the develop command * Distribute #11: Generated scripts now wrap their call to the script entry point in the standard "if name == 'main'" * Added the 'DONT_PATCH_SETUPTOOLS' environment variable, so virtualenv can drive an installation that doesn't patch a global setuptools. * Reviewed unladen-swallow specific change from http://code.google.com/p/unladen-swallow/source/detail?spec=svn875&r=719 and determined that it no longer applies. Distribute should work fine with Unladen Swallow 2009Q3. * Distribute #21: Allow PackageIndex.open_url to gracefully handle all cases of a httplib.HTTPException instead of just InvalidURL and BadStatusLine. * Removed virtual-python.py from this distribution and updated documentation to point to the actively maintained virtualenv instead. * Distribute #64: use_setuptools no longer rebuilds the distribute egg every time it is run * use_setuptools now properly respects the requested version * use_setuptools will no longer try to import a distribute egg for the wrong Python version * Distribute #74: no_fake should be True by default. * Distribute #72: avoid a bootstrapping issue with easy_install -U 0.6.6 ----- * Unified the bootstrap file so it works on both py2.x and py3k without 2to3 (patch by Holger Krekel) 0.6.5 ----- * Distribute #65: cli.exe and gui.exe are now generated at build time, depending on the platform in use. * Distribute #67: Fixed doc typo (PEP 381/PEP 382). * Distribute no longer shadows setuptools if we require a 0.7-series setuptools. And an error is raised when installing a 0.7 setuptools with distribute. * When run from within buildout, no attempt is made to modify an existing setuptools egg, whether in a shared egg directory or a system setuptools. * Fixed a hole in sandboxing allowing builtin file to write outside of the sandbox. 0.6.4 ----- * Added the generation of ``distribute_setup_3k.py`` during the release. This closes Distribute #52. * Added an upload_docs command to easily upload project documentation to PyPI's https://pythonhosted.org. This close issue Distribute #56. * Fixed a bootstrap bug on the use_setuptools() API. 0.6.3 ----- setuptools ^^^^^^^^^^ * Fixed a bunch of calls to file() that caused crashes on Python 3. bootstrapping ^^^^^^^^^^^^^ * Fixed a bug in sorting that caused bootstrap to fail on Python 3. 0.6.2 ----- setuptools ^^^^^^^^^^ * Added Python 3 support; see docs/python3.txt. This closes Old Setuptools #39. * Added option to run 2to3 automatically when installing on Python 3. This closes issue Distribute #31. * Fixed invalid usage of requirement.parse, that broke develop -d. This closes Old Setuptools #44. * Fixed script launcher for 64-bit Windows. This closes Old Setuptools #2. * KeyError when compiling extensions. This closes Old Setuptools #41. bootstrapping ^^^^^^^^^^^^^ * Fixed bootstrap not working on Windows. This closes issue Distribute #49. * Fixed 2.6 dependencies. This closes issue Distribute #50. * Make sure setuptools is patched when running through easy_install This closes Old Setuptools #40. 0.6.1 ----- setuptools ^^^^^^^^^^ * package_index.urlopen now catches BadStatusLine and malformed url errors. This closes Distribute #16 and Distribute #18. * zip_ok is now False by default. This closes Old Setuptools #33. * Fixed invalid URL error catching. Old Setuptools #20. * Fixed invalid bootstraping with easy_install installation (Distribute #40). Thanks to Florian Schulze for the help. * Removed buildout/bootstrap.py. A new repository will create a specific bootstrap.py script. bootstrapping ^^^^^^^^^^^^^ * The bootstrap process leave setuptools alone if detected in the system and --root or --prefix is provided, but is not in the same location. This closes Distribute #10. 0.6 --- setuptools ^^^^^^^^^^ * Packages required at build time where not fully present at install time. This closes Distribute #12. * Protected against failures in tarfile extraction. This closes Distribute #10. * Made Jython api_tests.txt doctest compatible. This closes Distribute #7. * sandbox.py replaced builtin type file with builtin function open. This closes Distribute #6. * Immediately close all file handles. This closes Distribute #3. * Added compatibility with Subversion 1.6. This references Distribute #1. pkg_resources ^^^^^^^^^^^^^ * Avoid a call to /usr/bin/sw_vers on OSX and use the official platform API instead. Based on a patch from ronaldoussoren. This closes issue #5. * Fixed a SandboxViolation for mkdir that could occur in certain cases. This closes Distribute #13. * Allow to find_on_path on systems with tight permissions to fail gracefully. This closes Distribute #9. * Corrected inconsistency between documentation and code of add_entry. This closes Distribute #8. * Immediately close all file handles. This closes Distribute #3. easy_install ^^^^^^^^^^^^ * Immediately close all file handles. This closes Distribute #3. 0.6c9 ----- * Fixed a missing files problem when using Windows source distributions on non-Windows platforms, due to distutils not handling manifest file line endings correctly. * Updated Pyrex support to work with Pyrex 0.9.6 and higher. * Minor changes for Jython compatibility, including skipping tests that can't work on Jython. * Fixed not installing eggs in ``install_requires`` if they were also used for ``setup_requires`` or ``tests_require``. * Fixed not fetching eggs in ``install_requires`` when running tests. * Allow ``ez_setup.use_setuptools()`` to upgrade existing setuptools installations when called from a standalone ``setup.py``. * Added a warning if a namespace package is declared, but its parent package is not also declared as a namespace. * Support Subversion 1.5 * Removed use of deprecated ``md5`` module if ``hashlib`` is available * Fixed ``bdist_wininst upload`` trying to upload the ``.exe`` twice * Fixed ``bdist_egg`` putting a ``native_libs.txt`` in the source package's ``.egg-info``, when it should only be in the built egg's ``EGG-INFO``. * Ensure that _full_name is set on all shared libs before extensions are checked for shared lib usage. (Fixes a bug in the experimental shared library build support.) * Fix to allow unpacked eggs containing native libraries to fail more gracefully under Google App Engine (with an ``ImportError`` loading the C-based module, instead of getting a ``NameError``). * Fixed ``win32.exe`` support for .pth files, so unnecessary directory nesting is flattened out in the resulting egg. (There was a case-sensitivity problem that affected some distributions, notably ``pywin32``.) * Prevent ``--help-commands`` and other junk from showing under Python 2.5 when running ``easy_install --help``. * Fixed GUI scripts sometimes not executing on Windows * Fixed not picking up dependency links from recursive dependencies. * Only make ``.py``, ``.dll`` and ``.so`` files executable when unpacking eggs * Changes for Jython compatibility * Improved error message when a requirement is also a directory name, but the specified directory is not a source package. * Fixed ``--allow-hosts`` option blocking ``file:`` URLs * Fixed HTTP SVN detection failing when the page title included a project name (e.g. on SourceForge-hosted SVN) * Fix Jython script installation to handle ``#!`` lines better when ``sys.executable`` is a script. * Removed use of deprecated ``md5`` module if ``hashlib`` is available * Keep site directories (e.g. ``site-packages``) from being included in ``.pth`` files. 0.6c7 ----- * Fixed ``distutils.filelist.findall()`` crashing on broken symlinks, and ``egg_info`` command failing on new, uncommitted SVN directories. * Fix import problems with nested namespace packages installed via ``--root`` or ``--single-version-externally-managed``, due to the parent package not having the child package as an attribute. * ``ftp:`` download URLs now work correctly. * The default ``--index-url`` is now ``https://pypi.python.org/simple``, to use the Python Package Index's new simpler (and faster!) REST API. 0.6c6 ----- * Added ``--egg-path`` option to ``develop`` command, allowing you to force ``.egg-link`` files to use relative paths (allowing them to be shared across platforms on a networked drive). * Fix not building binary RPMs correctly. * Fix "eggsecutables" (such as setuptools' own egg) only being runnable with bash-compatible shells. * Fix ``#!`` parsing problems in Windows ``.exe`` script wrappers, when there was whitespace inside a quoted argument or at the end of the ``#!`` line (a regression introduced in 0.6c4). * Fix ``test`` command possibly failing if an older version of the project being tested was installed on ``sys.path`` ahead of the test source directory. * Fix ``find_packages()`` treating ``ez_setup`` and directories with ``.`` in their names as packages. * EasyInstall no longer aborts the installation process if a URL it wants to retrieve can't be downloaded, unless the URL is an actual package download. Instead, it issues a warning and tries to keep going. * Fixed distutils-style scripts originally built on Windows having their line endings doubled when installed on any platform. * Added ``--local-snapshots-ok`` flag, to allow building eggs from projects installed using ``setup.py develop``. * Fixed not HTML-decoding URLs scraped from web pages 0.6c5 ----- * Fix uploaded ``bdist_rpm`` packages being described as ``bdist_egg`` packages under Python versions less than 2.5. * Fix uploaded ``bdist_wininst`` packages being described as suitable for "any" version by Python 2.5, even if a ``--target-version`` was specified. * Fixed ``.dll`` files on Cygwin not having executable permissions when an egg is installed unzipped. 0.6c4 ----- * Overhauled Windows script wrapping to support ``bdist_wininst`` better. Scripts installed with ``bdist_wininst`` will always use ``#!python.exe`` or ``#!pythonw.exe`` as the executable name (even when built on non-Windows platforms!), and the wrappers will look for the executable in the script's parent directory (which should find the right version of Python). * Fix ``upload`` command not uploading files built by ``bdist_rpm`` or ``bdist_wininst`` under Python 2.3 and 2.4. * Add support for "eggsecutable" headers: a ``#!/bin/sh`` script that is prepended to an ``.egg`` file to allow it to be run as a script on Unix-ish platforms. (This is mainly so that setuptools itself can have a single-file installer on Unix, without doing multiple downloads, dealing with firewalls, etc.) * Fix problem with empty revision numbers in Subversion 1.4 ``entries`` files * Use cross-platform relative paths in ``easy-install.pth`` when doing ``develop`` and the source directory is a subdirectory of the installation target directory. * Fix a problem installing eggs with a system packaging tool if the project contained an implicit namespace package; for example if the ``setup()`` listed a namespace package ``foo.bar`` without explicitly listing ``foo`` as a namespace package. * Added support for HTTP "Basic" authentication using ``http://user:pass@host`` URLs. If a password-protected page contains links to the same host (and protocol), those links will inherit the credentials used to access the original page. * Removed all special support for Sourceforge mirrors, as Sourceforge's mirror system now works well for non-browser downloads. * Fixed not recognizing ``win32.exe`` installers that included a custom bitmap. * Fixed not allowing ``os.open()`` of paths outside the sandbox, even if they are opened read-only (e.g. reading ``/dev/urandom`` for random numbers, as is done by ``os.urandom()`` on some platforms). * Fixed a problem with ``.pth`` testing on Windows when ``sys.executable`` has a space in it (e.g., the user installed Python to a ``Program Files`` directory). 0.6c3 ----- * Fixed breakages caused by Subversion 1.4's new "working copy" format * You can once again use "python -m easy_install" with Python 2.4 and above. * Python 2.5 compatibility fixes added. 0.6c2 ----- * The ``ez_setup`` module displays the conflicting version of setuptools (and its installation location) when a script requests a version that's not available. * Running ``setup.py develop`` on a setuptools-using project will now install setuptools if needed, instead of only downloading the egg. * Windows script wrappers now support quoted arguments and arguments containing spaces. (Patch contributed by Jim Fulton.) * The ``ez_setup.py`` script now actually works when you put a setuptools ``.egg`` alongside it for bootstrapping an offline machine. * A writable installation directory on ``sys.path`` is no longer required to download and extract a source distribution using ``--editable``. * Generated scripts now use ``-x`` on the ``#!`` line when ``sys.executable`` contains non-ASCII characters, to prevent deprecation warnings about an unspecified encoding when the script is run. 0.6c1 ----- * Fixed ``AttributeError`` when trying to download a ``setup_requires`` dependency when a distribution lacks a ``dependency_links`` setting. * Made ``zip-safe`` and ``not-zip-safe`` flag files contain a single byte, so as to play better with packaging tools that complain about zero-length files. * Made ``setup.py develop`` respect the ``--no-deps`` option, which it previously was ignoring. * Support ``extra_path`` option to ``setup()`` when ``install`` is run in backward-compatibility mode. * Source distributions now always include a ``setup.cfg`` file that explicitly sets ``egg_info`` options such that they produce an identical version number to the source distribution's version number. (Previously, the default version number could be different due to the use of ``--tag-date``, or if the version was overridden on the command line that built the source distribution.) * EasyInstall now includes setuptools version information in the ``User-Agent`` string sent to websites it visits. 0.6b4 ----- * Fix ``register`` not obeying name/version set by ``egg_info`` command, if ``egg_info`` wasn't explicitly run first on the same command line. * Added ``--no-date`` and ``--no-svn-revision`` options to ``egg_info`` command, to allow suppressing tags configured in ``setup.cfg``. * Fixed redundant warnings about missing ``README`` file(s); it should now appear only if you are actually a source distribution. * Fix creating Python wrappers for non-Python scripts * Fix ``ftp://`` directory listing URLs from causing a crash when used in the "Home page" or "Download URL" slots on PyPI. * Fix ``sys.path_importer_cache`` not being updated when an existing zipfile or directory is deleted/overwritten. * Fix not recognizing HTML 404 pages from package indexes. * Allow ``file://`` URLs to be used as a package index. URLs that refer to directories will use an internally-generated directory listing if there is no ``index.html`` file in the directory. * Allow external links in a package index to be specified using ``rel="homepage"`` or ``rel="download"``, without needing the old PyPI-specific visible markup. * Suppressed warning message about possibly-misspelled project name, if an egg or link for that project name has already been seen. 0.6b3 ----- * Fix ``bdist_egg`` not including files in subdirectories of ``.egg-info``. * Allow ``.py`` files found by the ``include_package_data`` option to be automatically included. Remove duplicate data file matches if both ``include_package_data`` and ``package_data`` are used to refer to the same files. * Fix local ``--find-links`` eggs not being copied except with ``--always-copy``. * Fix sometimes not detecting local packages installed outside of "site" directories. * Fix mysterious errors during initial ``setuptools`` install, caused by ``ez_setup`` trying to run ``easy_install`` twice, due to a code fallthru after deleting the egg from which it's running. 0.6b2 ----- * Don't install or update a ``site.py`` patch when installing to a ``PYTHONPATH`` directory with ``--multi-version``, unless an ``easy-install.pth`` file is already in use there. * Construct ``.pth`` file paths in such a way that installing an egg whose name begins with ``import`` doesn't cause a syntax error. * Fixed a bogus warning message that wasn't updated since the 0.5 versions. 0.6b1 ----- * Strip ``module`` from the end of compiled extension modules when computing the name of a ``.py`` loader/wrapper. (Python's import machinery ignores this suffix when searching for an extension module.) * Better ambiguity management: accept ``#egg`` name/version even if processing what appears to be a correctly-named distutils file, and ignore ``.egg`` files with no ``-``, since valid Python ``.egg`` files always have a version number (but Scheme eggs often don't). * Support ``file://`` links to directories in ``--find-links``, so that easy_install can build packages from local source checkouts. * Added automatic retry for Sourceforge mirrors. The new download process is to first just try dl.sourceforge.net, then randomly select mirror IPs and remove ones that fail, until something works. The removed IPs stay removed for the remainder of the run. * Ignore bdist_dumb distributions when looking at download URLs. 0.6a11 ------ * Added ``test_loader`` keyword to support custom test loaders * Added ``setuptools.file_finders`` entry point group to allow implementing revision control plugins. * Added ``--identity`` option to ``upload`` command. * Added ``dependency_links`` to allow specifying URLs for ``--find-links``. * Enhanced test loader to scan packages as well as modules, and call ``additional_tests()`` if present to get non-unittest tests. * Support namespace packages in conjunction with system packagers, by omitting the installation of any ``__init__.py`` files for namespace packages, and adding a special ``.pth`` file to create a working package in ``sys.modules``. * Made ``--single-version-externally-managed`` automatic when ``--root`` is used, so that most system packagers won't require special support for setuptools. * Fixed ``setup_requires``, ``tests_require``, etc. not using ``setup.cfg`` or other configuration files for their option defaults when installing, and also made the install use ``--multi-version`` mode so that the project directory doesn't need to support .pth files. * ``MANIFEST.in`` is now forcibly closed when any errors occur while reading it. Previously, the file could be left open and the actual error would be masked by problems trying to remove the open file on Windows systems. * Process ``dependency_links.txt`` if found in a distribution, by adding the URLs to the list for scanning. * Use relative paths in ``.pth`` files when eggs are being installed to the same directory as the ``.pth`` file. This maximizes portability of the target directory when building applications that contain eggs. * Added ``easy_install-N.N`` script(s) for convenience when using multiple Python versions. * Added automatic handling of installation conflicts. Eggs are now shifted to the front of sys.path, in an order consistent with where they came from, making EasyInstall seamlessly co-operate with system package managers. The ``--delete-conflicting`` and ``--ignore-conflicts-at-my-risk`` options are now no longer necessary, and will generate warnings at the end of a run if you use them. * Don't recursively traverse subdirectories given to ``--find-links``. 0.6a10 ------ * Fixed the ``develop`` command ignoring ``--find-links``. * Added exhaustive testing of the install directory, including a spawn test for ``.pth`` file support, and directory writability/existence checks. This should virtually eliminate the need to set or configure ``--site-dirs``. * Added ``--prefix`` option for more do-what-I-mean-ishness in the absence of RTFM-ing. :) * Enhanced ``PYTHONPATH`` support so that you don't have to put any eggs on it manually to make it work. ``--multi-version`` is no longer a silent default; you must explicitly use it if installing to a non-PYTHONPATH, non-"site" directory. * Expand ``$variables`` used in the ``--site-dirs``, ``--build-directory``, ``--install-dir``, and ``--script-dir`` options, whether on the command line or in configuration files. * Improved SourceForge mirror processing to work faster and be less affected by transient HTML changes made by SourceForge. * PyPI searches now use the exact spelling of requirements specified on the command line or in a project's ``install_requires``. Previously, a normalized form of the name was used, which could lead to unnecessary full-index searches when a project's name had an underscore (``_``) in it. * EasyInstall can now download bare ``.py`` files and wrap them in an egg, as long as you include an ``#egg=name-version`` suffix on the URL, or if the ``.py`` file is listed as the "Download URL" on the project's PyPI page. This allows third parties to "package" trivial Python modules just by linking to them (e.g. from within their own PyPI page or download links page). * The ``--always-copy`` option now skips "system" and "development" eggs since they can't be reliably copied. Note that this may cause EasyInstall to choose an older version of a package than what you expected, or it may cause downloading and installation of a fresh version of what's already installed. * The ``--find-links`` option previously scanned all supplied URLs and directories as early as possible, but now only directories and direct archive links are scanned immediately. URLs are not retrieved unless a package search was already going to go online due to a package not being available locally, or due to the use of the ``--update`` or ``-U`` option. * Fixed the annoying ``--help-commands`` wart. 0.6a9 ----- * The ``sdist`` command no longer uses the traditional ``MANIFEST`` file to create source distributions. ``MANIFEST.in`` is still read and processed, as are the standard defaults and pruning. But the manifest is built inside the project's ``.egg-info`` directory as ``SOURCES.txt``, and it is rebuilt every time the ``egg_info`` command is run. * Added the ``include_package_data`` keyword to ``setup()``, allowing you to automatically include any package data listed in revision control or ``MANIFEST.in`` * Added the ``exclude_package_data`` keyword to ``setup()``, allowing you to trim back files included via the ``package_data`` and ``include_package_data`` options. * Fixed ``--tag-svn-revision`` not working when run from a source distribution. * Added warning for namespace packages with missing ``declare_namespace()`` * Added ``tests_require`` keyword to ``setup()``, so that e.g. packages requiring ``nose`` to run unit tests can make this dependency optional unless the ``test`` command is run. * Made all commands that use ``easy_install`` respect its configuration options, as this was causing some problems with ``setup.py install``. * Added an ``unpack_directory()`` driver to ``setuptools.archive_util``, so that you can process a directory tree through a processing filter as if it were a zipfile or tarfile. * Added an internal ``install_egg_info`` command to use as part of old-style ``install`` operations, that installs an ``.egg-info`` directory with the package. * Added a ``--single-version-externally-managed`` option to the ``install`` command so that you can more easily wrap a "flat" egg in a system package. * Enhanced ``bdist_rpm`` so that it installs single-version eggs that don't rely on a ``.pth`` file. The ``--no-egg`` option has been removed, since all RPMs are now built in a more backwards-compatible format. * Support full roundtrip translation of eggs to and from ``bdist_wininst`` format. Running ``bdist_wininst`` on a setuptools-based package wraps the egg in an .exe that will safely install it as an egg (i.e., with metadata and entry-point wrapper scripts), and ``easy_install`` can turn the .exe back into an ``.egg`` file or directory and install it as such. * Fixed ``.pth`` file processing picking up nested eggs (i.e. ones inside "baskets") when they weren't explicitly listed in the ``.pth`` file. * If more than one URL appears to describe the exact same distribution, prefer the shortest one. This helps to avoid "table of contents" CGI URLs like the ones on effbot.org. * Quote arguments to python.exe (including python's path) to avoid problems when Python (or a script) is installed in a directory whose name contains spaces on Windows. * Support full roundtrip translation of eggs to and from ``bdist_wininst`` format. Running ``bdist_wininst`` on a setuptools-based package wraps the egg in an .exe that will safely install it as an egg (i.e., with metadata and entry-point wrapper scripts), and ``easy_install`` can turn the .exe back into an ``.egg`` file or directory and install it as such. 0.6a8 ----- * Fixed some problems building extensions when Pyrex was installed, especially with Python 2.4 and/or packages using SWIG. * Made ``develop`` command accept all the same options as ``easy_install``, and use the ``easy_install`` command's configuration settings as defaults. * Made ``egg_info --tag-svn-revision`` fall back to extracting the revision number from ``PKG-INFO`` in case it is being run on a source distribution of a snapshot taken from a Subversion-based project. * Automatically detect ``.dll``, ``.so`` and ``.dylib`` files that are being installed as data, adding them to ``native_libs.txt`` automatically. * Fixed some problems with fresh checkouts of projects that don't include ``.egg-info/PKG-INFO`` under revision control and put the project's source code directly in the project directory. If such a package had any requirements that get processed before the ``egg_info`` command can be run, the setup scripts would fail with a "Missing 'Version:' header and/or PKG-INFO file" error, because the egg runtime interpreted the unbuilt metadata in a directory on ``sys.path`` (i.e. the current directory) as being a corrupted egg. Setuptools now monkeypatches the distribution metadata cache to pretend that the egg has valid version information, until it has a chance to make it actually be so (via the ``egg_info`` command). * Update for changed SourceForge mirror format * Fixed not installing dependencies for some packages fetched via Subversion * Fixed dependency installation with ``--always-copy`` not using the same dependency resolution procedure as other operations. * Fixed not fully removing temporary directories on Windows, if a Subversion checkout left read-only files behind * Fixed some problems building extensions when Pyrex was installed, especially with Python 2.4 and/or packages using SWIG. 0.6a7 ----- * Fixed not being able to install Windows script wrappers using Python 2.3 0.6a6 ----- * Added support for "traditional" PYTHONPATH-based non-root installation, and also the convenient ``virtual-python.py`` script, based on a contribution by Ian Bicking. The setuptools egg now contains a hacked ``site`` module that makes the PYTHONPATH-based approach work with .pth files, so that you can get the full EasyInstall feature set on such installations. * Added ``--no-deps`` and ``--allow-hosts`` options. * Improved Windows ``.exe`` script wrappers so that the script can have the same name as a module without confusing Python. * Changed dependency processing so that it's breadth-first, allowing a depender's preferences to override those of a dependee, to prevent conflicts when a lower version is acceptable to the dependee, but not the depender. Also, ensure that currently installed/selected packages aren't given precedence over ones desired by a package being installed, which could cause conflict errors. 0.6a5 ----- * Fixed missing gui/cli .exe files in distribution. Fixed bugs in tests. 0.6a3 ----- * Added ``gui_scripts`` entry point group to allow installing GUI scripts on Windows and other platforms. (The special handling is only for Windows; other platforms are treated the same as for ``console_scripts``.) * Improved error message when trying to use old ways of running ``easy_install``. Removed the ability to run via ``python -m`` or by running ``easy_install.py``; ``easy_install`` is the command to run on all supported platforms. * Improved wrapper script generation and runtime initialization so that a VersionConflict doesn't occur if you later install a competing version of a needed package as the default version of that package. * Fixed a problem parsing version numbers in ``#egg=`` links. 0.6a2 ----- * Added ``console_scripts`` entry point group to allow installing scripts without the need to create separate script files. On Windows, console scripts get an ``.exe`` wrapper so you can just type their name. On other platforms, the scripts are written without a file extension. * EasyInstall can now install "console_scripts" defined by packages that use ``setuptools`` and define appropriate entry points. On Windows, console scripts get an ``.exe`` wrapper so you can just type their name. On other platforms, the scripts are installed without a file extension. * Using ``python -m easy_install`` or running ``easy_install.py`` is now DEPRECATED, since an ``easy_install`` wrapper is now available on all platforms. 0.6a1 ----- * Added support for building "old-style" RPMs that don't install an egg for the target package, using a ``--no-egg`` option. * The ``build_ext`` command now works better when using the ``--inplace`` option and multiple Python versions. It now makes sure that all extensions match the current Python version, even if newer copies were built for a different Python version. * The ``upload`` command no longer attaches an extra ``.zip`` when uploading eggs, as PyPI now supports egg uploads without trickery. * The ``ez_setup`` script/module now displays a warning before downloading the setuptools egg, and attempts to check the downloaded egg against an internal MD5 checksum table. * Fixed the ``--tag-svn-revision`` option of ``egg_info`` not finding the latest revision number; it was using the revision number of the directory containing ``setup.py``, not the highest revision number in the project. * Added ``eager_resources`` setup argument * The ``sdist`` command now recognizes Subversion "deleted file" entries and does not include them in source distributions. * ``setuptools`` now embeds itself more thoroughly into the distutils, so that other distutils extensions (e.g. py2exe, py2app) will subclass setuptools' versions of things, rather than the native distutils ones. * Added ``entry_points`` and ``setup_requires`` arguments to ``setup()``; ``setup_requires`` allows you to automatically find and download packages that are needed in order to *build* your project (as opposed to running it). * ``setuptools`` now finds its commands, ``setup()`` argument validators, and metadata writers using entry points, so that they can be extended by third-party packages. See `Creating distutils Extensions `_ for more details. * The vestigial ``depends`` command has been removed. It was never finished or documented, and never would have worked without EasyInstall - which it pre-dated and was never compatible with. * EasyInstall now does MD5 validation of downloads from PyPI, or from any link that has an "#md5=..." trailer with a 32-digit lowercase hex md5 digest. * EasyInstall now handles symlinks in target directories by removing the link, rather than attempting to overwrite the link's destination. This makes it easier to set up an alternate Python "home" directory (as described in the Non-Root Installation section of the docs). * Added support for handling MacOS platform information in ``.egg`` filenames, based on a contribution by Kevin Dangoor. You may wish to delete and reinstall any eggs whose filename includes "darwin" and "Power_Macintosh", because the format for this platform information has changed so that minor OS X upgrades (such as 10.4.1 to 10.4.2) do not cause eggs built with a previous OS version to become obsolete. * easy_install's dependency processing algorithms have changed. When using ``--always-copy``, it now ensures that dependencies are copied too. When not using ``--always-copy``, it tries to use a single resolution loop, rather than recursing. * Fixed installing extra ``.pyc`` or ``.pyo`` files for scripts with ``.py`` extensions. * Added ``--site-dirs`` option to allow adding custom "site" directories. Made ``easy-install.pth`` work in platform-specific alternate site directories (e.g. ``~/Library/Python/2.x/site-packages`` on Mac OS X). * If you manually delete the current version of a package, the next run of EasyInstall against the target directory will now remove the stray entry from the ``easy-install.pth`` file. * EasyInstall now recognizes URLs with a ``#egg=project_name`` fragment ID as pointing to the named project's source checkout. Such URLs have a lower match precedence than any other kind of distribution, so they'll only be used if they have a higher version number than any other available distribution, or if you use the ``--editable`` option. The ``#egg`` fragment can contain a version if it's formatted as ``#egg=proj-ver``, where ``proj`` is the project name, and ``ver`` is the version number. You *must* use the format for these values that the ``bdist_egg`` command uses; i.e., all non-alphanumeric runs must be condensed to single underscore characters. * Added the ``--editable`` option; see Editing and Viewing Source Packages in the docs. Also, slightly changed the behavior of the ``--build-directory`` option. * Fixed the setup script sandbox facility not recognizing certain paths as valid on case-insensitive platforms. 0.5a12 ------ * The zip-safety scanner now checks for modules that might be used with ``python -m``, and marks them as unsafe for zipping, since Python 2.4 can't handle ``-m`` on zipped modules. * Fix ``python -m easy_install`` not working due to setuptools being installed as a zipfile. Update safety scanner to check for modules that might be used as ``python -m`` scripts. * Misc. fixes for win32.exe support, including changes to support Python 2.4's changed ``bdist_wininst`` format. 0.5a11 ------ * Fix breakage of the "develop" command that was caused by the addition of ``--always-unzip`` to the ``easy_install`` command. 0.5a10 ------ * Put the ``easy_install`` module back in as a module, as it's needed for ``python -m`` to run it! * Allow ``--find-links/-f`` to accept local directories or filenames as well as URLs. 0.5a9 ----- * Include ``svn:externals`` directories in source distributions as well as normal subversion-controlled files and directories. * Added ``exclude=patternlist`` option to ``setuptools.find_packages()`` * Changed --tag-svn-revision to include an "r" in front of the revision number for better readability. * Added ability to build eggs without including source files (except for any scripts, of course), using the ``--exclude-source-files`` option to ``bdist_egg``. * ``setup.py install`` now automatically detects when an "unmanaged" package or module is going to be on ``sys.path`` ahead of a package being installed, thereby preventing the newer version from being imported. If this occurs, a warning message is output to ``sys.stderr``, but installation proceeds anyway. The warning message informs the user what files or directories need deleting, and advises them they can also use EasyInstall (with the ``--delete-conflicting`` option) to do it automatically. * The ``egg_info`` command now adds a ``top_level.txt`` file to the metadata directory that lists all top-level modules and packages in the distribution. This is used by the ``easy_install`` command to find possibly-conflicting "unmanaged" packages when installing the distribution. * Added ``zip_safe`` and ``namespace_packages`` arguments to ``setup()``. Added package analysis to determine zip-safety if the ``zip_safe`` flag is not given, and advise the author regarding what code might need changing. * Fixed the swapped ``-d`` and ``-b`` options of ``bdist_egg``. * EasyInstall now automatically detects when an "unmanaged" package or module is going to be on ``sys.path`` ahead of a package you're installing, thereby preventing the newer version from being imported. By default, it will abort installation to alert you of the problem, but there are also new options (``--delete-conflicting`` and ``--ignore-conflicts-at-my-risk``) available to change the default behavior. (Note: this new feature doesn't take effect for egg files that were built with older ``setuptools`` versions, because they lack the new metadata file required to implement it.) * The ``easy_install`` distutils command now uses ``DistutilsError`` as its base error type for errors that should just issue a message to stderr and exit the program without a traceback. * EasyInstall can now be given a path to a directory containing a setup script, and it will attempt to build and install the package there. * EasyInstall now performs a safety analysis on module contents to determine whether a package is likely to run in zipped form, and displays information about what modules may be doing introspection that would break when running as a zipfile. * Added the ``--always-unzip/-Z`` option, to force unzipping of packages that would ordinarily be considered safe to unzip, and changed the meaning of ``--zip-ok/-z`` to "always leave everything zipped". 0.5a8 ----- * The "egg_info" command now always sets the distribution metadata to "safe" forms of the distribution name and version, so that distribution files will be generated with parseable names (i.e., ones that don't include '-' in the name or version). Also, this means that if you use the various ``--tag`` options of "egg_info", any distributions generated will use the tags in the version, not just egg distributions. * Added support for defining command aliases in distutils configuration files, under the "[aliases]" section. To prevent recursion and to allow aliases to call the command of the same name, a given alias can be expanded only once per command-line invocation. You can define new aliases with the "alias" command, either for the local, global, or per-user configuration. * Added "rotate" command to delete old distribution files, given a set of patterns to match and the number of files to keep. (Keeps the most recently-modified distribution files matching each pattern.) * Added "saveopts" command that saves all command-line options for the current invocation to the local, global, or per-user configuration file. Useful for setting defaults without having to hand-edit a configuration file. * Added a "setopt" command that sets a single option in a specified distutils configuration file. * There is now a separate documentation page for setuptools; revision history that's not specific to EasyInstall has been moved to that page. 0.5a7 ----- * Added "upload" support for egg and source distributions, including a bug fix for "upload" and a temporary workaround for lack of .egg support in PyPI. 0.5a6 ----- * Beefed up the "sdist" command so that if you don't have a MANIFEST.in, it will include all files under revision control (CVS or Subversion) in the current directory, and it will regenerate the list every time you create a source distribution, not just when you tell it to. This should make the default "do what you mean" more often than the distutils' default behavior did, while still retaining the old behavior in the presence of MANIFEST.in. * Fixed the "develop" command always updating .pth files, even if you specified ``-n`` or ``--dry-run``. * Slightly changed the format of the generated version when you use ``--tag-build`` on the "egg_info" command, so that you can make tagged revisions compare *lower* than the version specified in setup.py (e.g. by using ``--tag-build=dev``). 0.5a5 ----- * Added ``develop`` command to ``setuptools``-based packages. This command installs an ``.egg-link`` pointing to the package's source directory, and script wrappers that ``execfile()`` the source versions of the package's scripts. This lets you put your development checkout(s) on sys.path without having to actually install them. (To uninstall the link, use use ``setup.py develop --uninstall``.) * Added ``egg_info`` command to ``setuptools``-based packages. This command just creates or updates the "projectname.egg-info" directory, without building an egg. (It's used by the ``bdist_egg``, ``test``, and ``develop`` commands.) * Enhanced the ``test`` command so that it doesn't install the package, but instead builds any C extensions in-place, updates the ``.egg-info`` metadata, adds the source directory to ``sys.path``, and runs the tests directly on the source. This avoids an "unmanaged" installation of the package to ``site-packages`` or elsewhere. * Made ``easy_install`` a standard ``setuptools`` command, moving it from the ``easy_install`` module to ``setuptools.command.easy_install``. Note that if you were importing or extending it, you must now change your imports accordingly. ``easy_install.py`` is still installed as a script, but not as a module. 0.5a4 ----- * Setup scripts using setuptools can now list their dependencies directly in the setup.py file, without having to manually create a ``depends.txt`` file. The ``install_requires`` and ``extras_require`` arguments to ``setup()`` are used to create a dependencies file automatically. If you are manually creating ``depends.txt`` right now, please switch to using these setup arguments as soon as practical, because ``depends.txt`` support will be removed in the 0.6 release cycle. For documentation on the new arguments, see the ``setuptools.dist.Distribution`` class. * Setup scripts using setuptools now always install using ``easy_install`` internally, for ease of uninstallation and upgrading. * Added ``--always-copy/-a`` option to always copy needed packages to the installation directory, even if they're already present elsewhere on sys.path. (In previous versions, this was the default behavior, but now you must request it.) * Added ``--upgrade/-U`` option to force checking PyPI for latest available version(s) of all packages requested by name and version, even if a matching version is available locally. * Added automatic installation of dependencies declared by a distribution being installed. These dependencies must be listed in the distribution's ``EGG-INFO`` directory, so the distribution has to have declared its dependencies by using setuptools. If a package has requirements it didn't declare, you'll still have to deal with them yourself. (E.g., by asking EasyInstall to find and install them.) * Added the ``--record`` option to ``easy_install`` for the benefit of tools that run ``setup.py install --record=filename`` on behalf of another packaging system.) 0.5a3 ----- * Fixed not setting script permissions to allow execution. * Improved sandboxing so that setup scripts that want a temporary directory (e.g. pychecker) can still run in the sandbox. 0.5a2 ----- * Fix stupid stupid refactoring-at-the-last-minute typos. :( 0.5a1 ----- * Added support for "self-installation" bootstrapping. Packages can now include ``ez_setup.py`` in their source distribution, and add the following to their ``setup.py``, in order to automatically bootstrap installation of setuptools as part of their setup process:: from ez_setup import use_setuptools use_setuptools() from setuptools import setup # etc... * Added support for converting ``.win32.exe`` installers to eggs on the fly. EasyInstall will now recognize such files by name and install them. * Fixed a problem with picking the "best" version to install (versions were being sorted as strings, rather than as parsed values) 0.4a4 ----- * Added support for the distutils "verbose/quiet" and "dry-run" options, as well as the "optimize" flag. * Support downloading packages that were uploaded to PyPI (by scanning all links on package pages, not just the homepage/download links). 0.4a3 ----- * Add progress messages to the search/download process so that you can tell what URLs it's reading to find download links. (Hopefully, this will help people report out-of-date and broken links to package authors, and to tell when they've asked for a package that doesn't exist.) 0.4a2 ----- * Added ``ez_setup.py`` installer/bootstrap script to make initial setuptools installation easier, and to allow distributions using setuptools to avoid having to include setuptools in their source distribution. * All downloads are now managed by the ``PackageIndex`` class (which is now subclassable and replaceable), so that embedders can more easily override download logic, give download progress reports, etc. The class has also been moved to the new ``setuptools.package_index`` module. * The ``Installer`` class no longer handles downloading, manages a temporary directory, or tracks the ``zip_ok`` option. Downloading is now handled by ``PackageIndex``, and ``Installer`` has become an ``easy_install`` command class based on ``setuptools.Command``. * There is a new ``setuptools.sandbox.run_setup()`` API to invoke a setup script in a directory sandbox, and a new ``setuptools.archive_util`` module with an ``unpack_archive()`` API. These were split out of EasyInstall to allow reuse by other tools and applications. * ``setuptools.Command`` now supports reinitializing commands using keyword arguments to set/reset options. Also, ``Command`` subclasses can now set their ``command_consumes_arguments`` attribute to ``True`` in order to receive an ``args`` option containing the rest of the command line. * Added support for installing scripts * Added support for setting options via distutils configuration files, and using distutils' default options as a basis for EasyInstall's defaults. * Renamed ``--scan-url/-s`` to ``--find-links/-f`` to free up ``-s`` for the script installation directory option. * Use ``urllib2`` instead of ``urllib``, to allow use of ``https:`` URLs if Python includes SSL support. 0.4a1 ----- * Added ``--scan-url`` and ``--index-url`` options, to scan download pages and search PyPI for needed packages. 0.3a4 ----- * Restrict ``--build-directory=DIR/-b DIR`` option to only be used with single URL installs, to avoid running the wrong setup.py. 0.3a3 ----- * Added ``--build-directory=DIR/-b DIR`` option. * Added "installation report" that explains how to use 'require()' when doing a multiversion install or alternate installation directory. * Added SourceForge mirror auto-select (Contributed by Ian Bicking) * Added "sandboxing" that stops a setup script from running if it attempts to write to the filesystem outside of the build area * Added more workarounds for packages with quirky ``install_data`` hacks 0.3a2 ----- * Added new options to ``bdist_egg`` to allow tagging the egg's version number with a subversion revision number, the current date, or an explicit tag value. Run ``setup.py bdist_egg --help`` to get more information. * Added subversion download support for ``svn:`` and ``svn+`` URLs, as well as automatic recognition of HTTP subversion URLs (Contributed by Ian Bicking) * Misc. bug fixes 0.3a1 ----- * Initial release. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/LICENSE0000644000175100001710000000203200000000000014376 0ustar00runnerdockerCopyright Jason R. Coombs Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/MANIFEST.in0000644000175100001710000000105300000000000015131 0ustar00runnerdockerrecursive-include setuptools *.py *.exe *.xml *.tmpl recursive-include tests *.py recursive-include setuptools/tests *.html recursive-include docs *.py *.txt *.rst *.conf *.css *.css_t Makefile indexsidebar.html recursive-include setuptools/_vendor *.py *.txt recursive-include pkg_resources *.py *.txt recursive-include pkg_resources/tests/data * recursive-include tools * recursive-include changelog.d * include *.py include *.rst include MANIFEST.in include LICENSE include launcher.c include msvc-build-launcher.cmd include pytest.ini include tox.ini ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9586704 setuptools-59.6.0/PKG-INFO0000644000175100001710000000670400000000000014500 0ustar00runnerdockerMetadata-Version: 2.1 Name: setuptools Version: 59.6.0 Summary: Easily download, build, install, upgrade, and uninstall Python packages Home-page: https://github.com/pypa/setuptools Author: Python Packaging Authority Author-email: distutils-sig@python.org License: UNKNOWN Project-URL: Documentation, https://setuptools.pypa.io/ Keywords: CPAN PyPI distutils eggs package management Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3 :: Only Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Archiving :: Packaging Classifier: Topic :: System :: Systems Administration Classifier: Topic :: Utilities Requires-Python: >=3.6 Provides-Extra: testing Provides-Extra: docs Provides-Extra: ssl Provides-Extra: certs License-File: LICENSE .. image:: https://raw.githubusercontent.com/pypa/setuptools/main/docs/images/banner-640x320.svg :align: center | .. image:: https://img.shields.io/pypi/v/setuptools.svg :target: `PyPI link`_ .. image:: https://img.shields.io/pypi/pyversions/setuptools.svg :target: `PyPI link`_ .. _PyPI link: https://pypi.org/project/setuptools .. image:: https://github.com/pypa/setuptools/workflows/tests/badge.svg :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22 :alt: tests .. image:: https://img.shields.io/badge/code%20style-black-000000.svg :target: https://github.com/psf/black :alt: Code style: Black .. image:: https://img.shields.io/readthedocs/setuptools/latest.svg :target: https://setuptools.pypa.io .. image:: https://img.shields.io/badge/skeleton-2021-informational :target: https://blog.jaraco.com/skeleton .. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white :target: https://codecov.io/gh/pypa/setuptools .. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme See the `Installation Instructions `_ in the Python Packaging User's Guide for instructions on installing, upgrading, and uninstalling Setuptools. Questions and comments should be directed to the `distutils-sig mailing list `_. Bug reports and especially tested patches may be submitted directly to the `bug tracker `_. Code of Conduct =============== Everyone interacting in the setuptools project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the `PSF Code of Conduct `_. For Enterprise ============== Available as part of the Tidelift Subscription. Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. `Learn more `_. Security Contact ================ To report a security vulnerability, please use the `Tidelift security contact `_. Tidelift will coordinate the fix and disclosure. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/README.rst0000644000175100001710000000473100000000000015070 0ustar00runnerdocker.. image:: https://raw.githubusercontent.com/pypa/setuptools/main/docs/images/banner-640x320.svg :align: center | .. image:: https://img.shields.io/pypi/v/setuptools.svg :target: `PyPI link`_ .. image:: https://img.shields.io/pypi/pyversions/setuptools.svg :target: `PyPI link`_ .. _PyPI link: https://pypi.org/project/setuptools .. image:: https://github.com/pypa/setuptools/workflows/tests/badge.svg :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22 :alt: tests .. image:: https://img.shields.io/badge/code%20style-black-000000.svg :target: https://github.com/psf/black :alt: Code style: Black .. image:: https://img.shields.io/readthedocs/setuptools/latest.svg :target: https://setuptools.pypa.io .. image:: https://img.shields.io/badge/skeleton-2021-informational :target: https://blog.jaraco.com/skeleton .. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white :target: https://codecov.io/gh/pypa/setuptools .. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme See the `Installation Instructions `_ in the Python Packaging User's Guide for instructions on installing, upgrading, and uninstalling Setuptools. Questions and comments should be directed to the `distutils-sig mailing list `_. Bug reports and especially tested patches may be submitted directly to the `bug tracker `_. Code of Conduct =============== Everyone interacting in the setuptools project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the `PSF Code of Conduct `_. For Enterprise ============== Available as part of the Tidelift Subscription. Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. `Learn more `_. Security Contact ================ To report a security vulnerability, please use the `Tidelift security contact `_. Tidelift will coordinate the fix and disclosure. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8906698 setuptools-59.6.0/_distutils_hack/0000755000175100001710000000000000000000000016545 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/_distutils_hack/__init__.py0000644000175100001710000000725700000000000020671 0ustar00runnerdockerimport sys import os import re import importlib import warnings is_pypy = '__pypy__' in sys.builtin_module_names warnings.filterwarnings('ignore', r'.+ distutils\b.+ deprecated', DeprecationWarning) def warn_distutils_present(): if 'distutils' not in sys.modules: return if is_pypy and sys.version_info < (3, 7): # PyPy for 3.6 unconditionally imports distutils, so bypass the warning # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250 return warnings.warn( "Distutils was imported before Setuptools, but importing Setuptools " "also replaces the `distutils` module in `sys.modules`. This may lead " "to undesirable behaviors or errors. To avoid these issues, avoid " "using distutils directly, ensure that setuptools is installed in the " "traditional way (e.g. not an editable install), and/or make sure " "that setuptools is always imported before distutils.") def clear_distutils(): if 'distutils' not in sys.modules: return warnings.warn("Setuptools is replacing distutils.") mods = [name for name in sys.modules if re.match(r'distutils\b', name)] for name in mods: del sys.modules[name] def enabled(): """ Allow selection of distutils by environment variable. """ which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'stdlib') return which == 'local' def ensure_local_distutils(): clear_distutils() # With the DistutilsMetaFinder in place, # perform an import to cause distutils to be # loaded from setuptools._distutils. Ref #2906. add_shim() importlib.import_module('distutils') remove_shim() # check that submodules load as expected core = importlib.import_module('distutils.core') assert '_distutils' in core.__file__, core.__file__ def do_override(): """ Ensure that the local copy of distutils is preferred over stdlib. See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401 for more motivation. """ if enabled(): warn_distutils_present() ensure_local_distutils() class DistutilsMetaFinder: def find_spec(self, fullname, path, target=None): if path is not None: return method_name = 'spec_for_{fullname}'.format(**locals()) method = getattr(self, method_name, lambda: None) return method() def spec_for_distutils(self): import importlib.abc import importlib.util class DistutilsLoader(importlib.abc.Loader): def create_module(self, spec): return importlib.import_module('setuptools._distutils') def exec_module(self, module): pass return importlib.util.spec_from_loader('distutils', DistutilsLoader()) def spec_for_pip(self): """ Ensure stdlib distutils when running under pip. See pypa/pip#8761 for rationale. """ if self.pip_imported_during_build(): return clear_distutils() self.spec_for_distutils = lambda: None @staticmethod def pip_imported_during_build(): """ Detect if pip is being imported in a build script. Ref #2355. """ import traceback return any( frame.f_globals['__file__'].endswith('setup.py') for frame, line in traceback.walk_stack(None) ) DISTUTILS_FINDER = DistutilsMetaFinder() def add_shim(): sys.meta_path.insert(0, DISTUTILS_FINDER) def remove_shim(): try: sys.meta_path.remove(DISTUTILS_FINDER) except ValueError: pass ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/_distutils_hack/override.py0000644000175100001710000000005400000000000020735 0ustar00runnerdocker__import__('_distutils_hack').do_override() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/bootstrap.py0000644000175100001710000000022600000000000015763 0ustar00runnerdockerimport warnings msg = "bootstrap.py is no longer needed. Use a PEP-517-compatible builder instead." __name__ == '__main__' and warnings.warn(msg) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8906698 setuptools-59.6.0/changelog.d/0000755000175100001710000000000000000000000015545 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/changelog.d/.gitignore0000644000175100001710000000000000000000000017523 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/changelog.d/README.rst0000644000175100001710000000731400000000000017241 0ustar00runnerdocker.. _Adding change notes with your PRs: Adding change notes with your PRs ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ It is very important to maintain a log for news of how updating to the new version of the software will affect end-users. This is why we enforce collection of the change fragment files in pull requests as per `Towncrier philosophy`_. The idea is that when somebody makes a change, they must record the bits that would affect end-users only including information that would be useful to them. Then, when the maintainers publish a new release, they'll automatically use these records to compose a change log for the respective version. It is important to understand that including unnecessary low-level implementation related details generates noise that is not particularly useful to the end-users most of the time. And so such details should be recorded in the Git history rather than a changelog. Alright! So how to add a news fragment? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``setuptools`` uses `towncrier `_ for changelog management. To submit a change note about your PR, add a text file into the ``changelog.d/`` folder. It should contain an explanation of what applying this PR will change in the way end-users interact with the project. One sentence is usually enough but feel free to add as many details as you feel necessary for the users to understand what it means. **Use the past tense** for the text in your fragment because, combined with others, it will be a part of the "news digest" telling the readers **what changed** in a specific version of the library *since the previous version*. You should also use reStructuredText syntax for highlighting code (inline or block), linking parts of the docs or external sites. If you wish to sign your change, feel free to add ``-- by :user:`github-username``` at the end (replace ``github-username`` with your own!). Finally, name your file following the convention that Towncrier understands: it should start with the number of an issue or a PR followed by a dot, then add a patch type, like ``change``, ``doc``, ``misc`` etc., and add ``.rst`` as a suffix. If you need to add more than one fragment, you may add an optional sequence number (delimited with another period) between the type and the suffix. In general the name will follow ``..rst`` pattern, where the categories are: - ``change``: Any backwards compatible code change - ``breaking``: Any backwards-compatibility breaking change - ``doc``: A change to the documentation - ``misc``: Changes internal to the repo like CI, test and build changes - ``deprecation``: For deprecations of an existing feature or behavior A pull request may have more than one of these components, for example a code change may introduce a new feature that deprecates an old feature, in which case two fragments should be added. It is not necessary to make a separate documentation fragment for documentation changes accompanying the relevant code changes. Examples for adding changelog entries to your Pull Requests ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File :file:`changelog.d/2395.doc.1.rst`: .. code-block:: rst Added a ``:user:`` role to Sphinx config -- by :user:`webknjaz` File :file:`changelog.d/1354.misc.rst`: .. code-block:: rst Added ``towncrier`` for changelog management -- by :user:`pganssle` File :file:`changelog.d/2355.change.rst`: .. code-block:: rst When pip is imported as part of a build, leave :py:mod:`distutils` patched -- by :user:`jaraco` .. tip:: See :file:`pyproject.toml` for all available categories (``tool.towncrier.type``). .. _Towncrier philosophy: https://towncrier.readthedocs.io/en/actual-freaking-docs/#philosophy ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/conftest.py0000644000175100001710000000122100000000000015567 0ustar00runnerdockerimport sys pytest_plugins = 'setuptools.tests.fixtures' def pytest_addoption(parser): parser.addoption( "--package_name", action="append", default=[], help="list of package_name to pass to test functions", ) collect_ignore = [ 'tests/manual_test.py', 'setuptools/tests/mod_with_constant.py', 'setuptools/_distutils', '_distutils_hack', 'setuptools/extern', 'pkg_resources/extern', 'pkg_resources/tests/data', 'setuptools/_vendor', 'pkg_resources/_vendor', ] if sys.version_info < (3, 6): collect_ignore.append('docs/conf.py') # uses f-strings collect_ignore.append('pavement.py') ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8906698 setuptools-59.6.0/docs/0000755000175100001710000000000000000000000014324 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8906698 setuptools-59.6.0/docs/_ext/0000755000175100001710000000000000000000000015263 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/_ext/_custom_icons.py0000644000175100001710000000365400000000000020511 0ustar00runnerdocker"""'In-tree' sphinx extension to add icons/favicons to documentation""" import os from sphinx.util.fileutil import copy_asset_file IMAGES_DIR = "_images" # same used by .. image:: and .. picture:: def _prepare_image(pathto, confdir, outdir, icon_attrs): """Copy icon files to the ``IMAGES_DIR`` and return a modified version of the icon attributes dict replacing ``file`` with the correct ``href``. """ icon = icon_attrs.copy() src = os.path.join(confdir, icon.pop("file")) if not os.path.exists(src): raise FileNotFoundError(f"icon {src!r} not found") dest = os.path.join(outdir, IMAGES_DIR) copy_asset_file(src, dest) # already compares if dest exists and is uptodate asset_name = os.path.basename(src) icon["href"] = pathto(f"{IMAGES_DIR}/{asset_name}", resource=True) return icon def _link_tag(attrs): return "" def _add_icons(app, _pagename, _templatename, context, doctree): """Add multiple "favicons", not limited to PNG/ICO files""" # https://evilmartians.com/chronicles/how-to-favicon-in-2021-six-files-that-fit-most-needs # https://caniuse.com/link-icon-svg try: pathto = context['pathto'] except KeyError as ex: msg = f"{__name__} extension is supposed to be call in HTML contexts" raise ValueError(msg) from ex if doctree and "icons" in app.config: icons = [ _prepare_image(pathto, app.confdir, app.outdir, icon) for icon in app.config["icons"] ] context["metatags"] += "\n".join(_link_tag(attrs) for attrs in icons) def setup(app): images_dir = os.path.join(app.outdir, IMAGES_DIR) os.makedirs(images_dir, exist_ok=True) app.add_config_value("icons", None, "html") app.connect("html-page-context", _add_icons) return { 'parallel_read_safe': True, 'parallel_write_safe': True, } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/build_meta.rst0000644000175100001710000000616300000000000017171 0ustar00runnerdocker======================================= Build System Support ======================================= What is it? ------------- Python packaging has come `a long way `_. The traditional ``setuptools`` way of packaging Python modules uses a ``setup()`` function within the ``setup.py`` script. Commands such as ``python setup.py bdist`` or ``python setup.py bdist_wheel`` generate a distribution bundle and ``python setup.py install`` installs the distribution. This interface makes it difficult to choose other packaging tools without an overhaul. Because ``setup.py`` scripts allowed for arbitrary execution, it proved difficult to provide a reliable user experience across environments and history. `PEP 517 `_ therefore came to rescue and specified a new standard to package and distribute Python modules. Under PEP 517: a ``pyproject.toml`` file is used to specify what program to use for generating distribution. Then, two functions provided by the program, ``build_wheel(directory: str)`` and ``build_sdist(directory: str)`` create the distribution bundle at the specified ``directory``. The program is free to use its own configuration script or extend the ``.toml`` file. Lastly, ``pip install *.whl`` or ``pip install *.tar.gz`` does the actual installation. If ``*.whl`` is available, ``pip`` will go ahead and copy the files into ``site-packages`` directory. If not, ``pip`` will look at ``pyproject.toml`` and decide what program to use to 'build from source' (the default is ``setuptools``) With this standard, switching between packaging tools becomes a lot easier. ``build_meta`` implements ``setuptools``' build system support. How to use it? -------------- Starting with a package that you want to distribute. You will need your source scripts, a ``pyproject.toml`` file and a ``setup.cfg`` file:: ~/meowpkg/ pyproject.toml setup.cfg meowpkg/__init__.py The pyproject.toml file is required to specify the build system (i.e. what is being used to package your scripts and install from source). To use it with setuptools, the content would be:: [build-system] requires = ["setuptools", "wheel"] build-backend = "setuptools.build_meta" The ``setuptools`` package implements the ``build_sdist`` command and the ``wheel`` package implements the ``build_wheel`` command; both are required to be compliant with PEP 517. Use ``setuptools``' :ref:`declarative config ` to specify the package information:: [metadata] name = meowpkg version = 0.0.1 description = a package that meows [options] packages = find: Now generate the distribution. To build the package, use `PyPA build `_:: $ pip install -q build $ python -m build And now it's done! The ``.whl`` file and ``.tar.gz`` can then be distributed and installed:: dist/ meowpkg-0.0.1.whl meowpkg-0.0.1.tar.gz $ pip install dist/meowpkg-0.0.1.whl or:: $ pip install dist/meowpkg-0.0.1.tar.gz ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/conf.py0000644000175100001710000001575600000000000015641 0ustar00runnerdockerimport os import sys extensions = ['sphinx.ext.autodoc', 'jaraco.packaging.sphinx', 'rst.linker'] master_doc = "index" link_files = { '../CHANGES.rst': dict( using=dict( BB='https://bitbucket.org', GH='https://github.com', ), replace=[ dict( pattern=r'(Issue )?#(?P\d+)', url='{package_url}/issues/{issue}', ), dict( pattern=r'BB Pull Request ?#(?P\d+)', url='{BB}/pypa/setuptools/pull-request/{bb_pull_request}', ), dict( pattern=r'Distribute #(?P\d+)', url='{BB}/tarek/distribute/issue/{distribute}', ), dict( pattern=r'Buildout #(?P\d+)', url='{GH}/buildout/buildout/issues/{buildout}', ), dict( pattern=r'Old Setuptools #(?P\d+)', url='http://bugs.python.org/setuptools/issue{old_setuptools}', ), dict( pattern=r'Jython #(?P\d+)', url='http://bugs.jython.org/issue{jython}', ), dict( pattern=r'(Python #|bpo-)(?P\d+)', url='http://bugs.python.org/issue{python}', ), dict( pattern=r'Interop #(?P\d+)', url='{GH}/pypa/interoperability-peps/issues/{interop}', ), dict( pattern=r'Pip #(?P\d+)', url='{GH}/pypa/pip/issues/{pip}', ), dict( pattern=r'Packaging #(?P\d+)', url='{GH}/pypa/packaging/issues/{packaging}', ), dict( pattern=r'[Pp]ackaging (?P\d+(\.\d+)+)', url='{GH}/pypa/packaging/blob/{packaging_ver}/CHANGELOG.rst', ), dict( pattern=r'PEP[- ](?P\d+)', url='https://www.python.org/dev/peps/pep-{pep_number:0>4}/', ), dict( pattern=r'setuptools_svn #(?P\d+)', url='{GH}/jaraco/setuptools_svn/issues/{setuptools_svn}', ), dict( pattern=r'pypa/distutils#(?P\d+)', url='{GH}/pypa/distutils/issues/{distutils}', ), dict( pattern=r'^(?m)((?Pv?\d+(\.\d+){1,2}))\n[-=]+\n', with_scm='{text}\n{rev[timestamp]:%d %b %Y}\n', ), ], ), } # Be strict about any broken references: nitpicky = True # Include Python intersphinx mapping to prevent failures # jaraco/skeleton#51 extensions += ['sphinx.ext.intersphinx'] intersphinx_mapping = { 'python': ('https://docs.python.org/3', None), } intersphinx_mapping.update({ 'pypa-build': ('https://pypa-build.readthedocs.io/en/latest/', None) }) # Add support for linking usernames github_url = 'https://github.com' github_sponsors_url = f'{github_url}/sponsors' extlinks = { 'user': (f'{github_sponsors_url}/%s', '@'), # noqa: WPS323 } extensions += ['sphinx.ext.extlinks'] # Ref: https://github.com/python-attrs/attrs/pull/571/files\ # #diff-85987f48f1258d9ee486e3191495582dR82 default_role = 'any' # HTML theme html_theme = 'furo' html_logo = "images/logo.svg" html_theme_options = { "sidebar_hide_name": True, "light_css_variables": { "color-brand-primary": "#336790", # "blue" "color-brand-content": "#336790", }, "dark_css_variables": { "color-brand-primary": "#E5B62F", # "yellow" "color-brand-content": "#E5B62F", }, } # Add support for inline tabs extensions += ['sphinx_inline_tabs'] # Support for distutils # Ref: https://stackoverflow.com/a/30624034/595220 nitpick_ignore = [ ('c:func', 'SHGetSpecialFolderPath'), # ref to MS docs ('envvar', 'DISTUTILS_DEBUG'), # undocumented ('envvar', 'HOME'), # undocumented ('envvar', 'PLAT'), # undocumented ('py:attr', 'CCompiler.language_map'), # undocumented ('py:attr', 'CCompiler.language_order'), # undocumented ('py:class', 'distutils.dist.Distribution'), # undocumented ('py:class', 'distutils.extension.Extension'), # undocumented ('py:class', 'BorlandCCompiler'), # undocumented ('py:class', 'CCompiler'), # undocumented ('py:class', 'CygwinCCompiler'), # undocumented ('py:class', 'distutils.dist.DistributionMetadata'), # undocumented ('py:class', 'FileList'), # undocumented ('py:class', 'IShellLink'), # ref to MS docs ('py:class', 'MSVCCompiler'), # undocumented ('py:class', 'OptionDummy'), # undocumented ('py:class', 'UnixCCompiler'), # undocumented ('py:exc', 'CompileError'), # undocumented ('py:exc', 'DistutilsExecError'), # undocumented ('py:exc', 'DistutilsFileError'), # undocumented ('py:exc', 'LibError'), # undocumented ('py:exc', 'LinkError'), # undocumented ('py:exc', 'PreprocessError'), # undocumented ('py:func', 'distutils.CCompiler.new_compiler'), # undocumented # undocumented: ('py:func', 'distutils.dist.DistributionMetadata.read_pkg_file'), ('py:func', 'distutils.file_util._copy_file_contents'), # undocumented ('py:func', 'distutils.log.debug'), # undocumented ('py:func', 'distutils.spawn.find_executable'), # undocumented ('py:func', 'distutils.spawn.spawn'), # undocumented # TODO: check https://docutils.rtfd.io in the future ('py:mod', 'docutils'), # there's no Sphinx site documenting this ] # Allow linking objects on other Sphinx sites seamlessly: intersphinx_mapping.update( python=('https://docs.python.org/3', None), python2=('https://docs.python.org/2', None), ) # Add support for the unreleased "next-version" change notes extensions += ['sphinxcontrib.towncrier'] # Extension needs a path from here to the towncrier config. towncrier_draft_working_directory = '..' # Avoid an empty section for unpublished changes. towncrier_draft_include_empty = False extensions += ['jaraco.tidelift'] # Add icons (aka "favicons") to documentation sys.path.append(os.path.join(os.path.dirname(__file__), '_ext')) extensions += ['_custom_icons'] # List of dicts with HTML attributes # as defined in https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link # except that ``file`` gets replaced with the correct ``href`` icons = [ { # "Catch-all" goes first, otherwise some browsers will overwrite "rel": "icon", "type": "image/svg+xml", "file": "images/logo-symbol-only.svg", "sizes": "any" }, { # Version with thicker strokes for better visibility at smaller sizes "rel": "icon", "type": "image/svg+xml", "file": "images/favicon.svg", "sizes": "16x16 24x24 32x32 48x48" }, # rel="apple-touch-icon" does not support SVG yet ] intersphinx_mapping['pip'] = 'https://pip.pypa.io/en/latest', None ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8946698 setuptools-59.6.0/docs/deprecated/0000755000175100001710000000000000000000000016424 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8946698 setuptools-59.6.0/docs/deprecated/distutils/0000755000175100001710000000000000000000000020450 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/_setuptools_disclaimer.rst0000644000175100001710000000035000000000000025754 0ustar00runnerdocker.. note:: This document is being retained solely until the ``setuptools`` documentation at https://setuptools.pypa.io/en/latest/setuptools.html independently covers all of the relevant information currently included here. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/apiref.rst0000644000175100001710000027516100000000000022464 0ustar00runnerdocker.. _api-reference: ************* API Reference ************* .. seealso:: `New and changed setup.py arguments in setuptools`_ The ``setuptools`` project adds new capabilities to the ``setup`` function and other APIs, makes the API consistent across different Python versions, and is hence recommended over using ``distutils`` directly. .. _New and changed setup.py arguments in setuptools: https://setuptools.pypa.io/en/latest/setuptools.html#new-and-changed-setup-keywords .. include:: ./_setuptools_disclaimer.rst :mod:`distutils.core` --- Core Distutils functionality ====================================================== .. module:: distutils.core :synopsis: The core Distutils functionality The :mod:`distutils.core` module is the only module that needs to be installed to use the Distutils. It provides the :func:`setup` (which is called from the setup script). Indirectly provides the :class:`distutils.dist.Distribution` and :class:`distutils.cmd.Command` class. .. function:: setup(arguments) The basic do-everything function that does most everything you could ever ask for from a Distutils method. The setup function takes a large number of arguments. These are laid out in the following table. .. tabularcolumns:: |l|L|L| +--------------------+--------------------------------+-------------------------------------------------------------+ | argument name | value | type | +====================+================================+=============================================================+ | *name* | The name of the package | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *version* | The version number of the | a string | | | package; see | | | | :mod:`distutils.version` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *description* | A single line describing the | a string | | | package | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *long_description* | Longer description of the | a string | | | package | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *author* | The name of the package author | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *author_email* | The email address of the | a string | | | package author | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *maintainer* | The name of the current | a string | | | maintainer, if different from | | | | the author. Note that if | | | | the maintainer is provided, | | | | distutils will use it as the | | | | author in :file:`PKG-INFO` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *maintainer_email* | The email address of the | a string | | | current maintainer, if | | | | different from the author | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *url* | A URL for the package | a string | | | (homepage) | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *download_url* | A URL to download the package | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *packages* | A list of Python packages that | a list of strings | | | distutils will manipulate | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *py_modules* | A list of Python modules that | a list of strings | | | distutils will manipulate | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *scripts* | A list of standalone script | a list of strings | | | files to be built and | | | | installed | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *ext_modules* | A list of Python extensions to | a list of instances of | | | be built | :class:`distutils.core.Extension` | +--------------------+--------------------------------+-------------------------------------------------------------+ | *classifiers* | A list of categories for the | a list of strings; valid classifiers are listed on `PyPI | | | package | `_. | +--------------------+--------------------------------+-------------------------------------------------------------+ | *distclass* | the :class:`Distribution` | a subclass of | | | class to use | :class:`distutils.core.Distribution` | +--------------------+--------------------------------+-------------------------------------------------------------+ | *script_name* | The name of the setup.py | a string | | | script - defaults to | | | | ``sys.argv[0]`` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *script_args* | Arguments to supply to the | a list of strings | | | setup script | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *options* | default options for the setup | a dictionary | | | script | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *license* | The license for the package | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *keywords* | Descriptive meta-data, see | a list of strings or a comma-separated string | | | :pep:`314` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *platforms* | | a list of strings or a comma-separated string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *cmdclass* | A mapping of command names to | a dictionary | | | :class:`Command` subclasses | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *data_files* | A list of data files to | a list | | | install | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *package_dir* | A mapping of package to | a dictionary | | | directory names | | +--------------------+--------------------------------+-------------------------------------------------------------+ .. function:: run_setup(script_name[, script_args=None, stop_after='run']) Run a setup script in a somewhat controlled environment, and return the :class:`distutils.dist.Distribution` instance that drives things. This is useful if you need to find out the distribution meta-data (passed as keyword args from *script* to :func:`setup`), or the contents of the config files or command-line. *script_name* is a file that will be read and run with :func:`exec`. ``sys.argv[0]`` will be replaced with *script* for the duration of the call. *script_args* is a list of strings; if supplied, ``sys.argv[1:]`` will be replaced by *script_args* for the duration of the call. *stop_after* tells :func:`setup` when to stop processing; possible values: .. tabularcolumns:: |l|L| +---------------+---------------------------------------------+ | value | description | +===============+=============================================+ | *init* | Stop after the :class:`Distribution` | | | instance has been created and populated | | | with the keyword arguments to :func:`setup` | +---------------+---------------------------------------------+ | *config* | Stop after config files have been parsed | | | (and their data stored in the | | | :class:`Distribution` instance) | +---------------+---------------------------------------------+ | *commandline* | Stop after the command-line | | | (``sys.argv[1:]`` or *script_args*) have | | | been parsed (and the data stored in the | | | :class:`Distribution` instance.) | +---------------+---------------------------------------------+ | *run* | Stop after all commands have been run (the | | | same as if :func:`setup` had been called | | | in the usual way). This is the default | | | value. | +---------------+---------------------------------------------+ In addition, the :mod:`distutils.core` module exposed a number of classes that live elsewhere. * :class:`~distutils.extension.Extension` from :mod:`distutils.extension` * :class:`~distutils.cmd.Command` from :mod:`distutils.cmd` * :class:`~distutils.dist.Distribution` from :mod:`distutils.dist` A short description of each of these follows, but see the relevant module for the full reference. .. class:: Extension The Extension class describes a single C or C++ extension module in a setup script. It accepts the following keyword arguments in its constructor: .. tabularcolumns:: |l|L|l| +------------------------+--------------------------------+---------------------------+ | argument name | value | type | +========================+================================+===========================+ | *name* | the full name of the | a string | | | extension, including any | | | | packages --- ie. *not* a | | | | filename or pathname, but | | | | Python dotted name | | +------------------------+--------------------------------+---------------------------+ | *sources* | list of source filenames, | a list of strings | | | relative to the distribution | | | | root (where the setup script | | | | lives), in Unix form | | | | (slash-separated) for | | | | portability. | | | | Source files may be C, C++, | | | | SWIG (.i), platform-specific | | | | resource files, or whatever | | | | else is recognized by the | | | | :command:`build_ext` command | | | | as source for a Python | | | | extension. | | +------------------------+--------------------------------+---------------------------+ | *include_dirs* | list of directories to search | a list of strings | | | for C/C++ header files (in | | | | Unix form for portability) | | +------------------------+--------------------------------+---------------------------+ | *define_macros* | list of macros to define; each | a list of tuples | | | macro is defined using a | | | | 2-tuple ``(name, value)``, | | | | where *value* is | | | | either the string to define it | | | | to or ``None`` to define it | | | | without a particular value | | | | (equivalent of ``#define FOO`` | | | | in source or :option:`!-DFOO` | | | | on Unix C compiler command | | | | line) | | +------------------------+--------------------------------+---------------------------+ | *undef_macros* | list of macros to undefine | a list of strings | | | explicitly | | +------------------------+--------------------------------+---------------------------+ | *library_dirs* | list of directories to search | a list of strings | | | for C/C++ libraries at link | | | | time | | +------------------------+--------------------------------+---------------------------+ | *libraries* | list of library names (not | a list of strings | | | filenames or paths) to link | | | | against | | +------------------------+--------------------------------+---------------------------+ | *runtime_library_dirs* | list of directories to search | a list of strings | | | for C/C++ libraries at run | | | | time (for shared extensions, | | | | this is when the extension is | | | | loaded) | | +------------------------+--------------------------------+---------------------------+ | *extra_objects* | list of extra files to link | a list of strings | | | with (eg. object files not | | | | implied by 'sources', static | | | | library that must be | | | | explicitly specified, binary | | | | resource files, etc.) | | +------------------------+--------------------------------+---------------------------+ | *extra_compile_args* | any extra platform- and | a list of strings | | | compiler-specific information | | | | to use when compiling the | | | | source files in 'sources'. For | | | | platforms and compilers where | | | | a command line makes sense, | | | | this is typically a list of | | | | command-line arguments, but | | | | for other platforms it could | | | | be anything. | | +------------------------+--------------------------------+---------------------------+ | *extra_link_args* | any extra platform- and | a list of strings | | | compiler-specific information | | | | to use when linking object | | | | files together to create the | | | | extension (or to create a new | | | | static Python interpreter). | | | | Similar interpretation as for | | | | 'extra_compile_args'. | | +------------------------+--------------------------------+---------------------------+ | *export_symbols* | list of symbols to be exported | a list of strings | | | from a shared extension. Not | | | | used on all platforms, and not | | | | generally necessary for Python | | | | extensions, which typically | | | | export exactly one symbol: | | | | ``init`` + extension_name. | | +------------------------+--------------------------------+---------------------------+ | *depends* | list of files that the | a list of strings | | | extension depends on | | +------------------------+--------------------------------+---------------------------+ | *language* | extension language (i.e. | a string | | | ``'c'``, ``'c++'``, | | | | ``'objc'``). Will be detected | | | | from the source extensions if | | | | not provided. | | +------------------------+--------------------------------+---------------------------+ | *optional* | specifies that a build failure | a boolean | | | in the extension should not | | | | abort the build process, but | | | | simply skip the extension. | | +------------------------+--------------------------------+---------------------------+ .. versionchanged:: 3.8 On Unix, C extensions are no longer linked to libpython except on Android and Cygwin. .. class:: Distribution A :class:`Distribution` describes how to build, install and package up a Python software package. See the :func:`setup` function for a list of keyword arguments accepted by the Distribution constructor. :func:`setup` creates a Distribution instance. .. versionchanged:: 3.7 :class:`~distutils.core.Distribution` now warns if ``classifiers``, ``keywords`` and ``platforms`` fields are not specified as a list or a string. .. class:: Command A :class:`Command` class (or rather, an instance of one of its subclasses) implement a single distutils command. :mod:`distutils.ccompiler` --- CCompiler base class =================================================== .. module:: distutils.ccompiler :synopsis: Abstract CCompiler class This module provides the abstract base class for the :class:`CCompiler` classes. A :class:`CCompiler` instance can be used for all the compile and link steps needed to build a single project. Methods are provided to set options for the compiler --- macro definitions, include directories, link path, libraries and the like. This module provides the following functions. .. function:: gen_lib_options(compiler, library_dirs, runtime_library_dirs, libraries) Generate linker options for searching library directories and linking with specific libraries. *libraries* and *library_dirs* are, respectively, lists of library names (not filenames!) and search directories. Returns a list of command-line options suitable for use with some compiler (depending on the two format strings passed in). .. function:: gen_preprocess_options(macros, include_dirs) Generate C pre-processor options (:option:`!-D`, :option:`!-U`, :option:`!-I`) as used by at least two types of compilers: the typical Unix compiler and Visual C++. *macros* is the usual thing, a list of 1- or 2-tuples, where ``(name,)`` means undefine (:option:`!-U`) macro *name*, and ``(name, value)`` means define (:option:`!-D`) macro *name* to *value*. *include_dirs* is just a list of directory names to be added to the header file search path (:option:`!-I`). Returns a list of command-line options suitable for either Unix compilers or Visual C++. .. function:: get_default_compiler(osname, platform) Determine the default compiler to use for the given platform. *osname* should be one of the standard Python OS names (i.e. the ones returned by ``os.name``) and *platform* the common value returned by ``sys.platform`` for the platform in question. The default values are ``os.name`` and ``sys.platform`` in case the parameters are not given. .. function:: new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0) Factory function to generate an instance of some CCompiler subclass for the supplied platform/compiler combination. *plat* defaults to ``os.name`` (eg. ``'posix'``, ``'nt'``), and *compiler* defaults to the default compiler for that platform. Currently only ``'posix'`` and ``'nt'`` are supported, and the default compilers are "traditional Unix interface" (:class:`UnixCCompiler` class) and Visual C++ (:class:`MSVCCompiler` class). Note that it's perfectly possible to ask for a Unix compiler object under Windows, and a Microsoft compiler object under Unix---if you supply a value for *compiler*, *plat* is ignored. .. % Is the posix/nt only thing still true? Mac OS X seems to work, and .. % returns a UnixCCompiler instance. How to document this... hmm. .. function:: show_compilers() Print list of available compilers (used by the :option:`!--help-compiler` options to :command:`build`, :command:`build_ext`, :command:`build_clib`). .. class:: CCompiler([verbose=0, dry_run=0, force=0]) The abstract base class :class:`CCompiler` defines the interface that must be implemented by real compiler classes. The class also has some utility methods used by several compiler classes. The basic idea behind a compiler abstraction class is that each instance can be used for all the compile/link steps in building a single project. Thus, attributes common to all of those compile and link steps --- include directories, macros to define, libraries to link against, etc. --- are attributes of the compiler instance. To allow for variability in how individual files are treated, most of those attributes may be varied on a per-compilation or per-link basis. The constructor for each subclass creates an instance of the Compiler object. Flags are *verbose* (show verbose output), *dry_run* (don't actually execute the steps) and *force* (rebuild everything, regardless of dependencies). All of these flags default to ``0`` (off). Note that you probably don't want to instantiate :class:`CCompiler` or one of its subclasses directly - use the :func:`distutils.CCompiler.new_compiler` factory function instead. The following methods allow you to manually alter compiler options for the instance of the Compiler class. .. method:: CCompiler.add_include_dir(dir) Add *dir* to the list of directories that will be searched for header files. The compiler is instructed to search directories in the order in which they are supplied by successive calls to :meth:`add_include_dir`. .. method:: CCompiler.set_include_dirs(dirs) Set the list of directories that will be searched to *dirs* (a list of strings). Overrides any preceding calls to :meth:`add_include_dir`; subsequent calls to :meth:`add_include_dir` add to the list passed to :meth:`set_include_dirs`. This does not affect any list of standard include directories that the compiler may search by default. .. method:: CCompiler.add_library(libname) Add *libname* to the list of libraries that will be included in all links driven by this compiler object. Note that *libname* should \*not\* be the name of a file containing a library, but the name of the library itself: the actual filename will be inferred by the linker, the compiler, or the compiler class (depending on the platform). The linker will be instructed to link against libraries in the order they were supplied to :meth:`add_library` and/or :meth:`set_libraries`. It is perfectly valid to duplicate library names; the linker will be instructed to link against libraries as many times as they are mentioned. .. method:: CCompiler.set_libraries(libnames) Set the list of libraries to be included in all links driven by this compiler object to *libnames* (a list of strings). This does not affect any standard system libraries that the linker may include by default. .. method:: CCompiler.add_library_dir(dir) Add *dir* to the list of directories that will be searched for libraries specified to :meth:`add_library` and :meth:`set_libraries`. The linker will be instructed to search for libraries in the order they are supplied to :meth:`add_library_dir` and/or :meth:`set_library_dirs`. .. method:: CCompiler.set_library_dirs(dirs) Set the list of library search directories to *dirs* (a list of strings). This does not affect any standard library search path that the linker may search by default. .. method:: CCompiler.add_runtime_library_dir(dir) Add *dir* to the list of directories that will be searched for shared libraries at runtime. .. method:: CCompiler.set_runtime_library_dirs(dirs) Set the list of directories to search for shared libraries at runtime to *dirs* (a list of strings). This does not affect any standard search path that the runtime linker may search by default. .. method:: CCompiler.define_macro(name[, value=None]) Define a preprocessor macro for all compilations driven by this compiler object. The optional parameter *value* should be a string; if it is not supplied, then the macro will be defined without an explicit value and the exact outcome depends on the compiler used. .. XXX true? does ANSI say anything about this? .. method:: CCompiler.undefine_macro(name) Undefine a preprocessor macro for all compilations driven by this compiler object. If the same macro is defined by :meth:`define_macro` and undefined by :meth:`undefine_macro` the last call takes precedence (including multiple redefinitions or undefinitions). If the macro is redefined/undefined on a per-compilation basis (ie. in the call to :meth:`compile`), then that takes precedence. .. method:: CCompiler.add_link_object(object) Add *object* to the list of object files (or analogues, such as explicitly named library files or the output of "resource compilers") to be included in every link driven by this compiler object. .. method:: CCompiler.set_link_objects(objects) Set the list of object files (or analogues) to be included in every link to *objects*. This does not affect any standard object files that the linker may include by default (such as system libraries). The following methods implement methods for autodetection of compiler options, providing some functionality similar to GNU :program:`autoconf`. .. method:: CCompiler.detect_language(sources) Detect the language of a given file, or list of files. Uses the instance attributes :attr:`~CCompiler.language_map` (a dictionary), and :attr:`~CCompiler.language_order` (a list) to do the job. .. method:: CCompiler.find_library_file(dirs, lib[, debug=0]) Search the specified list of directories for a static or shared library file *lib* and return the full path to that file. If *debug* is true, look for a debugging version (if that makes sense on the current platform). Return ``None`` if *lib* wasn't found in any of the specified directories. .. method:: CCompiler.has_function(funcname [, includes=None, include_dirs=None, libraries=None, library_dirs=None]) Return a boolean indicating whether *funcname* is supported on the current platform. The optional arguments can be used to augment the compilation environment by providing additional include files and paths and libraries and paths. .. method:: CCompiler.library_dir_option(dir) Return the compiler option to add *dir* to the list of directories searched for libraries. .. method:: CCompiler.library_option(lib) Return the compiler option to add *lib* to the list of libraries linked into the shared library or executable. .. method:: CCompiler.runtime_library_dir_option(dir) Return the compiler option to add *dir* to the list of directories searched for runtime libraries. .. method:: CCompiler.set_executables(**args) Define the executables (and options for them) that will be run to perform the various stages of compilation. The exact set of executables that may be specified here depends on the compiler class (via the 'executables' class attribute), but most will have: +--------------+------------------------------------------+ | attribute | description | +==============+==========================================+ | *compiler* | the C/C++ compiler | +--------------+------------------------------------------+ | *linker_so* | linker used to create shared objects and | | | libraries | +--------------+------------------------------------------+ | *linker_exe* | linker used to create binary executables | +--------------+------------------------------------------+ | *archiver* | static library creator | +--------------+------------------------------------------+ On platforms with a command-line (Unix, DOS/Windows), each of these is a string that will be split into executable name and (optional) list of arguments. (Splitting the string is done similarly to how Unix shells operate: words are delimited by spaces, but quotes and backslashes can override this. See :func:`distutils.util.split_quoted`.) The following methods invoke stages in the build process. .. method:: CCompiler.compile(sources[, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, depends=None]) Compile one or more source files. Generates object files (e.g. transforms a :file:`.c` file to a :file:`.o` file.) *sources* must be a list of filenames, most likely C/C++ files, but in reality anything that can be handled by a particular compiler and compiler class (eg. :class:`MSVCCompiler` can handle resource files in *sources*). Return a list of object filenames, one per source filename in *sources*. Depending on the implementation, not all source files will necessarily be compiled, but all corresponding object filenames will be returned. If *output_dir* is given, object files will be put under it, while retaining their original path component. That is, :file:`foo/bar.c` normally compiles to :file:`foo/bar.o` (for a Unix implementation); if *output_dir* is *build*, then it would compile to :file:`build/foo/bar.o`. *macros*, if given, must be a list of macro definitions. A macro definition is either a ``(name, value)`` 2-tuple or a ``(name,)`` 1-tuple. The former defines a macro; if the value is ``None``, the macro is defined without an explicit value. The 1-tuple case undefines a macro. Later definitions/redefinitions/undefinitions take precedence. *include_dirs*, if given, must be a list of strings, the directories to add to the default include file search path for this compilation only. *debug* is a boolean; if true, the compiler will be instructed to output debug symbols in (or alongside) the object file(s). *extra_preargs* and *extra_postargs* are implementation-dependent. On platforms that have the notion of a command-line (e.g. Unix, DOS/Windows), they are most likely lists of strings: extra command-line arguments to prepend/append to the compiler command line. On other platforms, consult the implementation class documentation. In any event, they are intended as an escape hatch for those occasions when the abstract compiler framework doesn't cut the mustard. *depends*, if given, is a list of filenames that all targets depend on. If a source file is older than any file in depends, then the source file will be recompiled. This supports dependency tracking, but only at a coarse granularity. Raises :exc:`CompileError` on failure. .. method:: CCompiler.create_static_lib(objects, output_libname[, output_dir=None, debug=0, target_lang=None]) Link a bunch of stuff together to create a static library file. The "bunch of stuff" consists of the list of object files supplied as *objects*, the extra object files supplied to :meth:`add_link_object` and/or :meth:`set_link_objects`, the libraries supplied to :meth:`add_library` and/or :meth:`set_libraries`, and the libraries supplied as *libraries* (if any). *output_libname* should be a library name, not a filename; the filename will be inferred from the library name. *output_dir* is the directory where the library file will be put. .. XXX defaults to what? *debug* is a boolean; if true, debugging information will be included in the library (note that on most platforms, it is the compile step where this matters: the *debug* flag is included here just for consistency). *target_lang* is the target language for which the given objects are being compiled. This allows specific linkage time treatment of certain languages. Raises :exc:`LibError` on failure. .. method:: CCompiler.link(target_desc, objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None]) Link a bunch of stuff together to create an executable or shared library file. The "bunch of stuff" consists of the list of object files supplied as *objects*. *output_filename* should be a filename. If *output_dir* is supplied, *output_filename* is relative to it (i.e. *output_filename* can provide directory components if needed). *libraries* is a list of libraries to link against. These are library names, not filenames, since they're translated into filenames in a platform-specific way (eg. *foo* becomes :file:`libfoo.a` on Unix and :file:`foo.lib` on DOS/Windows). However, they can include a directory component, which means the linker will look in that specific directory rather than searching all the normal locations. *library_dirs*, if supplied, should be a list of directories to search for libraries that were specified as bare library names (ie. no directory component). These are on top of the system default and those supplied to :meth:`add_library_dir` and/or :meth:`set_library_dirs`. *runtime_library_dirs* is a list of directories that will be embedded into the shared library and used to search for other shared libraries that \*it\* depends on at run-time. (This may only be relevant on Unix.) *export_symbols* is a list of symbols that the shared library will export. (This appears to be relevant only on Windows.) *debug* is as for :meth:`compile` and :meth:`create_static_lib`, with the slight distinction that it actually matters on most platforms (as opposed to :meth:`create_static_lib`, which includes a *debug* flag mostly for form's sake). *extra_preargs* and *extra_postargs* are as for :meth:`compile` (except of course that they supply command-line arguments for the particular linker being used). *target_lang* is the target language for which the given objects are being compiled. This allows specific linkage time treatment of certain languages. Raises :exc:`LinkError` on failure. .. method:: CCompiler.link_executable(objects, output_progname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, target_lang=None]) Link an executable. *output_progname* is the name of the file executable, while *objects* are a list of object filenames to link in. Other arguments are as for the :meth:`link` method. .. method:: CCompiler.link_shared_lib(objects, output_libname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None]) Link a shared library. *output_libname* is the name of the output library, while *objects* is a list of object filenames to link in. Other arguments are as for the :meth:`link` method. .. method:: CCompiler.link_shared_object(objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None]) Link a shared object. *output_filename* is the name of the shared object that will be created, while *objects* is a list of object filenames to link in. Other arguments are as for the :meth:`link` method. .. method:: CCompiler.preprocess(source[, output_file=None, macros=None, include_dirs=None, extra_preargs=None, extra_postargs=None]) Preprocess a single C/C++ source file, named in *source*. Output will be written to file named *output_file*, or *stdout* if *output_file* not supplied. *macros* is a list of macro definitions as for :meth:`compile`, which will augment the macros set with :meth:`define_macro` and :meth:`undefine_macro`. *include_dirs* is a list of directory names that will be added to the default list, in the same way as :meth:`add_include_dir`. Raises :exc:`PreprocessError` on failure. The following utility methods are defined by the :class:`CCompiler` class, for use by the various concrete subclasses. .. method:: CCompiler.executable_filename(basename[, strip_dir=0, output_dir='']) Returns the filename of the executable for the given *basename*. Typically for non-Windows platforms this is the same as the basename, while Windows will get a :file:`.exe` added. .. method:: CCompiler.library_filename(libname[, lib_type='static', strip_dir=0, output_dir='']) Returns the filename for the given library name on the current platform. On Unix a library with *lib_type* of ``'static'`` will typically be of the form :file:`liblibname.a`, while a *lib_type* of ``'dynamic'`` will be of the form :file:`liblibname.so`. .. method:: CCompiler.object_filenames(source_filenames[, strip_dir=0, output_dir='']) Returns the name of the object files for the given source files. *source_filenames* should be a list of filenames. .. method:: CCompiler.shared_object_filename(basename[, strip_dir=0, output_dir='']) Returns the name of a shared object file for the given file name *basename*. .. method:: CCompiler.execute(func, args[, msg=None, level=1]) Invokes :func:`distutils.util.execute`. This method invokes a Python function *func* with the given arguments *args*, after logging and taking into account the *dry_run* flag. .. method:: CCompiler.spawn(cmd) Invokes :func:`distutils.spawn.spawn`. This invokes an external process to run the given command. .. method:: CCompiler.mkpath(name[, mode=511]) Invokes :func:`distutils.dir_util.mkpath`. This creates a directory and any missing ancestor directories. .. method:: CCompiler.move_file(src, dst) Invokes :meth:`distutils.file_util.move_file`. Renames *src* to *dst*. .. method:: CCompiler.announce(msg[, level=1]) Write a message using :func:`distutils.log.debug`. .. method:: CCompiler.warn(msg) Write a warning message *msg* to standard error. .. method:: CCompiler.debug_print(msg) If the *debug* flag is set on this :class:`CCompiler` instance, print *msg* to standard output, otherwise do nothing. .. % \subsection{Compiler-specific modules} .. % .. % The following modules implement concrete subclasses of the abstract .. % \class{CCompiler} class. They should not be instantiated directly, but should .. % be created using \function{distutils.ccompiler.new_compiler()} factory .. % function. :mod:`distutils.unixccompiler` --- Unix C Compiler ================================================== .. module:: distutils.unixccompiler :synopsis: UNIX C Compiler This module provides the :class:`UnixCCompiler` class, a subclass of :class:`CCompiler` that handles the typical Unix-style command-line C compiler: * macros defined with :option:`!-Dname[=value]` * macros undefined with :option:`!-Uname` * include search directories specified with :option:`!-Idir` * libraries specified with :option:`!-llib` * library search directories specified with :option:`!-Ldir` * compile handled by :program:`cc` (or similar) executable with :option:`!-c` option: compiles :file:`.c` to :file:`.o` * link static library handled by :program:`ar` command (possibly with :program:`ranlib`) * link shared library handled by :program:`cc` :option:`!-shared` :mod:`distutils.msvccompiler` --- Microsoft Compiler ==================================================== .. module:: distutils.msvccompiler :synopsis: Microsoft Compiler .. XXX: This is *waaaaay* out of date! This module provides :class:`MSVCCompiler`, an implementation of the abstract :class:`CCompiler` class for Microsoft Visual Studio. Typically, extension modules need to be compiled with the same compiler that was used to compile Python. For Python 2.3 and earlier, the compiler was Visual Studio 6. For Python 2.4 and 2.5, the compiler is Visual Studio .NET 2003. :class:`MSVCCompiler` will normally choose the right compiler, linker etc. on its own. To override this choice, the environment variables *DISTUTILS_USE_SDK* and *MSSdk* must be both set. *MSSdk* indicates that the current environment has been setup by the SDK's ``SetEnv.Cmd`` script, or that the environment variables had been registered when the SDK was installed; *DISTUTILS_USE_SDK* indicates that the distutils user has made an explicit choice to override the compiler selection by :class:`MSVCCompiler`. :mod:`distutils.bcppcompiler` --- Borland Compiler ================================================== .. module:: distutils.bcppcompiler This module provides :class:`BorlandCCompiler`, a subclass of the abstract :class:`CCompiler` class for the Borland C++ compiler. :mod:`distutils.cygwinccompiler` --- Cygwin Compiler ==================================================== .. module:: distutils.cygwinccompiler This module provides the :class:`CygwinCCompiler` class, a subclass of :class:`UnixCCompiler` that handles the Cygwin port of the GNU C compiler to Windows. It also contains the Mingw32CCompiler class which handles the mingw32 port of GCC (same as cygwin in no-cygwin mode). :mod:`distutils.archive_util` --- Archiving utilities ====================================================== .. module:: distutils.archive_util :synopsis: Utility functions for creating archive files (tarballs, zip files, ...) This module provides a few functions for creating archive files, such as tarballs or zipfiles. .. function:: make_archive(base_name, format[, root_dir=None, base_dir=None, verbose=0, dry_run=0]) Create an archive file (eg. ``zip`` or ``tar``). *base_name* is the name of the file to create, minus any format-specific extension; *format* is the archive format: one of ``zip``, ``tar``, ``gztar``, ``bztar``, ``xztar``, or ``ztar``. *root_dir* is a directory that will be the root directory of the archive; ie. we typically ``chdir`` into *root_dir* before creating the archive. *base_dir* is the directory where we start archiving from; ie. *base_dir* will be the common prefix of all files and directories in the archive. *root_dir* and *base_dir* both default to the current directory. Returns the name of the archive file. .. versionchanged:: 3.5 Added support for the ``xztar`` format. .. function:: make_tarball(base_name, base_dir[, compress='gzip', verbose=0, dry_run=0]) 'Create an (optional compressed) archive as a tar file from all files in and under *base_dir*. *compress* must be ``'gzip'`` (the default), ``'bzip2'``, ``'xz'``, ``'compress'``, or ``None``. For the ``'compress'`` method the compression utility named by :program:`compress` must be on the default program search path, so this is probably Unix-specific. The output tar file will be named :file:`base_dir.tar`, possibly plus the appropriate compression extension (``.gz``, ``.bz2``, ``.xz`` or ``.Z``). Return the output filename. .. versionchanged:: 3.5 Added support for the ``xz`` compression. .. function:: make_zipfile(base_name, base_dir[, verbose=0, dry_run=0]) Create a zip file from all files in and under *base_dir*. The output zip file will be named *base_name* + :file:`.zip`. Uses either the :mod:`zipfile` Python module (if available) or the InfoZIP :file:`zip` utility (if installed and found on the default search path). If neither tool is available, raises :exc:`DistutilsExecError`. Returns the name of the output zip file. :mod:`distutils.dep_util` --- Dependency checking ================================================= .. module:: distutils.dep_util :synopsis: Utility functions for simple dependency checking This module provides functions for performing simple, timestamp-based dependency of files and groups of files; also, functions based entirely on such timestamp dependency analysis. .. function:: newer(source, target) Return true if *source* exists and is more recently modified than *target*, or if *source* exists and *target* doesn't. Return false if both exist and *target* is the same age or newer than *source*. Raise :exc:`DistutilsFileError` if *source* does not exist. .. function:: newer_pairwise(sources, targets) Walk two filename lists in parallel, testing if each source is newer than its corresponding target. Return a pair of lists (*sources*, *targets*) where source is newer than target, according to the semantics of :func:`newer`. .. % % equivalent to a listcomp... .. function:: newer_group(sources, target[, missing='error']) Return true if *target* is out-of-date with respect to any file listed in *sources*. In other words, if *target* exists and is newer than every file in *sources*, return false; otherwise return true. *missing* controls what we do when a source file is missing; the default (``'error'``) is to blow up with an :exc:`OSError` from inside :func:`os.stat`; if it is ``'ignore'``, we silently drop any missing source files; if it is ``'newer'``, any missing source files make us assume that *target* is out-of-date (this is handy in "dry-run" mode: it'll make you pretend to carry out commands that wouldn't work because inputs are missing, but that doesn't matter because you're not actually going to run the commands). :mod:`distutils.dir_util` --- Directory tree operations ======================================================= .. module:: distutils.dir_util :synopsis: Utility functions for operating on directories and directory trees This module provides functions for operating on directories and trees of directories. .. function:: mkpath(name[, mode=0o777, verbose=0, dry_run=0]) Create a directory and any missing ancestor directories. If the directory already exists (or if *name* is the empty string, which means the current directory, which of course exists), then do nothing. Raise :exc:`DistutilsFileError` if unable to create some directory along the way (eg. some sub-path exists, but is a file rather than a directory). If *verbose* is true, print a one-line summary of each mkdir to stdout. Return the list of directories actually created. .. function:: create_tree(base_dir, files[, mode=0o777, verbose=0, dry_run=0]) Create all the empty directories under *base_dir* needed to put *files* there. *base_dir* is just the name of a directory which doesn't necessarily exist yet; *files* is a list of filenames to be interpreted relative to *base_dir*. *base_dir* + the directory portion of every file in *files* will be created if it doesn't already exist. *mode*, *verbose* and *dry_run* flags are as for :func:`mkpath`. .. function:: copy_tree(src, dst[, preserve_mode=1, preserve_times=1, preserve_symlinks=0, update=0, verbose=0, dry_run=0]) Copy an entire directory tree *src* to a new location *dst*. Both *src* and *dst* must be directory names. If *src* is not a directory, raise :exc:`DistutilsFileError`. If *dst* does not exist, it is created with :func:`mkpath`. The end result of the copy is that every file in *src* is copied to *dst*, and directories under *src* are recursively copied to *dst*. Return the list of files that were copied or might have been copied, using their output name. The return value is unaffected by *update* or *dry_run*: it is simply the list of all files under *src*, with the names changed to be under *dst*. *preserve_mode* and *preserve_times* are the same as for :func:`distutils.file_util.copy_file`; note that they only apply to regular files, not to directories. If *preserve_symlinks* is true, symlinks will be copied as symlinks (on platforms that support them!); otherwise (the default), the destination of the symlink will be copied. *update* and *verbose* are the same as for :func:`~distutils.file_util.copy_file`. Files in *src* that begin with :file:`.nfs` are skipped (more information on these files is available in answer D2 of the `NFS FAQ page `_). .. versionchanged:: 3.3.1 NFS files are ignored. .. function:: remove_tree(directory[, verbose=0, dry_run=0]) Recursively remove *directory* and all files and directories underneath it. Any errors are ignored (apart from being reported to ``sys.stdout`` if *verbose* is true). :mod:`distutils.file_util` --- Single file operations ===================================================== .. module:: distutils.file_util :synopsis: Utility functions for operating on single files This module contains some utility functions for operating on individual files. .. function:: copy_file(src, dst[, preserve_mode=1, preserve_times=1, update=0, link=None, verbose=0, dry_run=0]) Copy file *src* to *dst*. If *dst* is a directory, then *src* is copied there with the same name; otherwise, it must be a filename. (If the file exists, it will be ruthlessly clobbered.) If *preserve_mode* is true (the default), the file's mode (type and permission bits, or whatever is analogous on the current platform) is copied. If *preserve_times* is true (the default), the last-modified and last-access times are copied as well. If *update* is true, *src* will only be copied if *dst* does not exist, or if *dst* does exist but is older than *src*. *link* allows you to make hard links (using :func:`os.link`) or symbolic links (using :func:`os.symlink`) instead of copying: set it to ``'hard'`` or ``'sym'``; if it is ``None`` (the default), files are copied. Don't set *link* on systems that don't support it: :func:`copy_file` doesn't check if hard or symbolic linking is available. It uses :func:`~distutils.file_util._copy_file_contents` to copy file contents. Return a tuple ``(dest_name, copied)``: *dest_name* is the actual name of the output file, and *copied* is true if the file was copied (or would have been copied, if *dry_run* true). .. % XXX if the destination file already exists, we clobber it if .. % copying, but blow up if linking. Hmmm. And I don't know what .. % macostools.copyfile() does. Should definitely be consistent, and .. % should probably blow up if destination exists and we would be .. % changing it (ie. it's not already a hard/soft link to src OR .. % (not update) and (src newer than dst)). .. function:: move_file(src, dst[, verbose, dry_run]) Move file *src* to *dst*. If *dst* is a directory, the file will be moved into it with the same name; otherwise, *src* is just renamed to *dst*. Returns the new full name of the file. .. warning:: Handles cross-device moves on Unix using :func:`copy_file`. What about other systems? .. function:: write_file(filename, contents) Create a file called *filename* and write *contents* (a sequence of strings without line terminators) to it. :mod:`distutils.util` --- Miscellaneous other utility functions =============================================================== .. module:: distutils.util :synopsis: Miscellaneous other utility functions This module contains other assorted bits and pieces that don't fit into any other utility module. .. function:: get_platform() Return a string that identifies the current platform. This is used mainly to distinguish platform-specific build directories and platform-specific built distributions. Typically includes the OS name and version and the architecture (as supplied by 'os.uname()'), although the exact information included depends on the OS; e.g., on Linux, the kernel version isn't particularly important. Examples of returned values: * ``linux-i586`` * ``linux-alpha`` * ``solaris-2.6-sun4u`` For non-POSIX platforms, currently just returns ``sys.platform``. For Mac OS X systems the OS version reflects the minimal version on which binaries will run (that is, the value of ``MACOSX_DEPLOYMENT_TARGET`` during the build of Python), not the OS version of the current system. For universal binary builds on Mac OS X the architecture value reflects the universal binary status instead of the architecture of the current processor. For 32-bit universal binaries the architecture is ``fat``, for 64-bit universal binaries the architecture is ``fat64``, and for 4-way universal binaries the architecture is ``universal``. Starting from Python 2.7 and Python 3.2 the architecture ``fat3`` is used for a 3-way universal build (ppc, i386, x86_64) and ``intel`` is used for a universal build with the i386 and x86_64 architectures Examples of returned values on Mac OS X: * ``macosx-10.3-ppc`` * ``macosx-10.3-fat`` * ``macosx-10.5-universal`` * ``macosx-10.6-intel`` For AIX, Python 3.9 and later return a string starting with "aix", followed by additional fields (separated by ``'-'``) that represent the combined values of AIX Version, Release and Technology Level (first field), Build Date (second field), and bit-size (third field). Python 3.8 and earlier returned only a single additional field with the AIX Version and Release. Examples of returned values on AIX: * ``aix-5307-0747-32`` # 32-bit build on AIX ``oslevel -s``: 5300-07-00-0000 * ``aix-7105-1731-64`` # 64-bit build on AIX ``oslevel -s``: 7100-05-01-1731 * ``aix-7.2`` # Legacy form reported in Python 3.8 and earlier .. versionchanged:: 3.9 The AIX platform string format now also includes the technology level, build date, and ABI bit-size. .. function:: convert_path(pathname) Return 'pathname' as a name that will work on the native filesystem, i.e. split it on '/' and put it back together again using the current directory separator. Needed because filenames in the setup script are always supplied in Unix style, and have to be converted to the local convention before we can actually use them in the filesystem. Raises :exc:`ValueError` on non-Unix-ish systems if *pathname* either starts or ends with a slash. .. function:: change_root(new_root, pathname) Return *pathname* with *new_root* prepended. If *pathname* is relative, this is equivalent to ``os.path.join(new_root,pathname)`` Otherwise, it requires making *pathname* relative and then joining the two, which is tricky on DOS/Windows. .. function:: check_environ() Ensure that 'os.environ' has all the environment variables we guarantee that users can use in config files, command-line options, etc. Currently this includes: * :envvar:`HOME` - user's home directory (Unix only) * :envvar:`PLAT` - description of the current platform, including hardware and OS (see :func:`get_platform`) .. function:: subst_vars(s, local_vars) Perform shell/Perl-style variable substitution on *s*. Every occurrence of ``$`` followed by a name is considered a variable, and variable is substituted by the value found in the *local_vars* dictionary, or in ``os.environ`` if it's not in *local_vars*. *os.environ* is first checked/augmented to guarantee that it contains certain values: see :func:`check_environ`. Raise :exc:`ValueError` for any variables not found in either *local_vars* or ``os.environ``. Note that this is not a fully-fledged string interpolation function. A valid ``$variable`` can consist only of upper and lower case letters, numbers and an underscore. No { } or ( ) style quoting is available. .. function:: split_quoted(s) Split a string up according to Unix shell-like rules for quotes and backslashes. In short: words are delimited by spaces, as long as those spaces are not escaped by a backslash, or inside a quoted string. Single and double quotes are equivalent, and the quote characters can be backslash-escaped. The backslash is stripped from any two-character escape sequence, leaving only the escaped character. The quote characters are stripped from any quoted string. Returns a list of words. .. % Should probably be moved into the standard library. .. function:: execute(func, args[, msg=None, verbose=0, dry_run=0]) Perform some action that affects the outside world (for instance, writing to the filesystem). Such actions are special because they are disabled by the *dry_run* flag. This method takes care of all that bureaucracy for you; all you have to do is supply the function to call and an argument tuple for it (to embody the "external action" being performed), and an optional message to print. .. function:: strtobool(val) Convert a string representation of truth to true (1) or false (0). True values are ``y``, ``yes``, ``t``, ``true``, ``on`` and ``1``; false values are ``n``, ``no``, ``f``, ``false``, ``off`` and ``0``. Raises :exc:`ValueError` if *val* is anything else. .. function:: byte_compile(py_files[, optimize=0, force=0, prefix=None, base_dir=None, verbose=1, dry_run=0, direct=None]) Byte-compile a collection of Python source files to :file:`.pyc` files in a :file:`__pycache__` subdirectory (see :pep:`3147` and :pep:`488`). *py_files* is a list of files to compile; any files that don't end in :file:`.py` are silently skipped. *optimize* must be one of the following: * ``0`` - don't optimize * ``1`` - normal optimization (like ``python -O``) * ``2`` - extra optimization (like ``python -OO``) If *force* is true, all files are recompiled regardless of timestamps. The source filename encoded in each :term:`bytecode` file defaults to the filenames listed in *py_files*; you can modify these with *prefix* and *basedir*. *prefix* is a string that will be stripped off of each source filename, and *base_dir* is a directory name that will be prepended (after *prefix* is stripped). You can supply either or both (or neither) of *prefix* and *base_dir*, as you wish. If *dry_run* is true, doesn't actually do anything that would affect the filesystem. Byte-compilation is either done directly in this interpreter process with the standard :mod:`py_compile` module, or indirectly by writing a temporary script and executing it. Normally, you should let :func:`byte_compile` figure out to use direct compilation or not (see the source for details). The *direct* flag is used by the script generated in indirect mode; unless you know what you're doing, leave it set to ``None``. .. versionchanged:: 3.2.3 Create ``.pyc`` files with an :func:`import magic tag ` in their name, in a :file:`__pycache__` subdirectory instead of files without tag in the current directory. .. versionchanged:: 3.5 Create ``.pyc`` files according to :pep:`488`. .. function:: rfc822_escape(header) Return a version of *header* escaped for inclusion in an :rfc:`822` header, by ensuring there are 8 spaces space after each newline. Note that it does no other modification of the string. .. % this _can_ be replaced .. % \subsection{Distutils objects} :mod:`distutils.dist` --- The Distribution class ================================================ .. module:: distutils.dist :synopsis: Provides the Distribution class, which represents the module distribution being built/installed/distributed This module provides the :class:`~distutils.core.Distribution` class, which represents the module distribution being built/installed/distributed. :mod:`distutils.extension` --- The Extension class ================================================== .. module:: distutils.extension :synopsis: Provides the Extension class, used to describe C/C++ extension modules in setup scripts This module provides the :class:`~distutils.extension.Extension` class, used to describe C/C++ extension modules in setup scripts. .. % \subsection{Ungrouped modules} .. % The following haven't been moved into a more appropriate section yet. :mod:`distutils.debug` --- Distutils debug mode =============================================== .. module:: distutils.debug :synopsis: Provides the debug flag for distutils This module provides the DEBUG flag. :mod:`distutils.errors` --- Distutils exceptions ================================================ .. module:: distutils.errors :synopsis: Provides standard distutils exceptions Provides exceptions used by the Distutils modules. Note that Distutils modules may raise standard exceptions; in particular, SystemExit is usually raised for errors that are obviously the end-user's fault (eg. bad command-line arguments). This module is safe to use in ``from ... import *`` mode; it only exports symbols whose names start with ``Distutils`` and end with ``Error``. :mod:`distutils.fancy_getopt` --- Wrapper around the standard getopt module =========================================================================== .. module:: distutils.fancy_getopt :synopsis: Additional getopt functionality This module provides a wrapper around the standard :mod:`getopt` module that provides the following additional features: * short and long options are tied together * options have help strings, so :func:`fancy_getopt` could potentially create a complete usage summary * options set attributes of a passed-in object * boolean options can have "negative aliases" --- eg. if :option:`!--quiet` is the "negative alias" of :option:`!--verbose`, then :option:`!--quiet` on the command line sets *verbose* to false. .. function:: fancy_getopt(options, negative_opt, object, args) Wrapper function. *options* is a list of ``(long_option, short_option, help_string)`` 3-tuples as described in the constructor for :class:`FancyGetopt`. *negative_opt* should be a dictionary mapping option names to option names, both the key and value should be in the *options* list. *object* is an object which will be used to store values (see the :meth:`~FancyGetopt.getopt` method of the :class:`FancyGetopt` class). *args* is the argument list. Will use ``sys.argv[1:]`` if you pass ``None`` as *args*. .. function:: wrap_text(text, width) Wraps *text* to less than *width* wide. .. class:: FancyGetopt([option_table=None]) The option_table is a list of 3-tuples: ``(long_option, short_option, help_string)`` If an option takes an argument, its *long_option* should have ``'='`` appended; *short_option* should just be a single character, no ``':'`` in any case. *short_option* should be ``None`` if a *long_option* doesn't have a corresponding *short_option*. All option tuples must have long options. The :class:`FancyGetopt` class provides the following methods: .. method:: FancyGetopt.getopt([args=None, object=None]) Parse command-line options in args. Store as attributes on *object*. If *args* is ``None`` or not supplied, uses ``sys.argv[1:]``. If *object* is ``None`` or not supplied, creates a new :class:`OptionDummy` instance, stores option values there, and returns a tuple ``(args, object)``. If *object* is supplied, it is modified in place and :func:`getopt` just returns *args*; in both cases, the returned *args* is a modified copy of the passed-in *args* list, which is left untouched. .. % and args returned are? .. method:: FancyGetopt.get_option_order() Returns the list of ``(option, value)`` tuples processed by the previous run of :meth:`getopt` Raises :exc:`RuntimeError` if :meth:`getopt` hasn't been called yet. .. method:: FancyGetopt.generate_help([header=None]) Generate help text (a list of strings, one per suggested line of output) from the option table for this :class:`FancyGetopt` object. If supplied, prints the supplied *header* at the top of the help. :mod:`distutils.filelist` --- The FileList class ================================================ .. module:: distutils.filelist :synopsis: The FileList class, used for poking about the file system and building lists of files. This module provides the :class:`FileList` class, used for poking about the filesystem and building lists of files. :mod:`distutils.log` --- Simple :pep:`282`-style logging ======================================================== .. module:: distutils.log :synopsis: A simple logging mechanism, :pep:`282`-style :mod:`distutils.spawn` --- Spawn a sub-process ============================================== .. module:: distutils.spawn :synopsis: Provides the spawn() function This module provides the :func:`~distutils.spawn.spawn` function, a front-end to various platform-specific functions for launching another program in a sub-process. Also provides :func:`~distutils.spawn.find_executable` to search the path for a given executable name. :mod:`distutils.sysconfig` --- System configuration information =============================================================== .. module:: distutils.sysconfig :synopsis: Low-level access to configuration information of the Python interpreter. .. moduleauthor:: Fred L. Drake, Jr. .. moduleauthor:: Greg Ward .. sectionauthor:: Fred L. Drake, Jr. The :mod:`distutils.sysconfig` module provides access to Python's low-level configuration information. The specific configuration variables available depend heavily on the platform and configuration. The specific variables depend on the build process for the specific version of Python being run; the variables are those found in the :file:`Makefile` and configuration header that are installed with Python on Unix systems. The configuration header is called :file:`pyconfig.h` for Python versions starting with 2.2, and :file:`config.h` for earlier versions of Python. Some additional functions are provided which perform some useful manipulations for other parts of the :mod:`distutils` package. .. data:: PREFIX The result of ``os.path.normpath(sys.prefix)``. .. data:: EXEC_PREFIX The result of ``os.path.normpath(sys.exec_prefix)``. .. function:: get_config_var(name) Return the value of a single variable. This is equivalent to ``get_config_vars().get(name)``. .. function:: get_config_vars(...) Return a set of variable definitions. If there are no arguments, this returns a dictionary mapping names of configuration variables to values. If arguments are provided, they should be strings, and the return value will be a sequence giving the associated values. If a given name does not have a corresponding value, ``None`` will be included for that variable. .. function:: get_config_h_filename() Return the full path name of the configuration header. For Unix, this will be the header generated by the :program:`configure` script; for other platforms the header will have been supplied directly by the Python source distribution. The file is a platform-specific text file. .. function:: get_makefile_filename() Return the full path name of the :file:`Makefile` used to build Python. For Unix, this will be a file generated by the :program:`configure` script; the meaning for other platforms will vary. The file is a platform-specific text file, if it exists. This function is only useful on POSIX platforms. .. function:: get_python_inc([plat_specific[, prefix]]) Return the directory for either the general or platform-dependent C include files. If *plat_specific* is true, the platform-dependent include directory is returned; if false or omitted, the platform-independent directory is returned. If *prefix* is given, it is used as either the prefix instead of :const:`PREFIX`, or as the exec-prefix instead of :const:`EXEC_PREFIX` if *plat_specific* is true. .. function:: get_python_lib([plat_specific[, standard_lib[, prefix]]]) Return the directory for either the general or platform-dependent library installation. If *plat_specific* is true, the platform-dependent include directory is returned; if false or omitted, the platform-independent directory is returned. If *prefix* is given, it is used as either the prefix instead of :const:`PREFIX`, or as the exec-prefix instead of :const:`EXEC_PREFIX` if *plat_specific* is true. If *standard_lib* is true, the directory for the standard library is returned rather than the directory for the installation of third-party extensions. The following function is only intended for use within the :mod:`distutils` package. .. function:: customize_compiler(compiler) Do any platform-specific customization of a :class:`distutils.ccompiler.CCompiler` instance. This function is only needed on Unix at this time, but should be called consistently to support forward-compatibility. It inserts the information that varies across Unix flavors and is stored in Python's :file:`Makefile`. This information includes the selected compiler, compiler and linker options, and the extension used by the linker for shared objects. This function is even more special-purpose, and should only be used from Python's own build procedures. .. function:: set_python_build() Inform the :mod:`distutils.sysconfig` module that it is being used as part of the build process for Python. This changes a lot of relative locations for files, allowing them to be located in the build area rather than in an installed Python. :mod:`distutils.text_file` --- The TextFile class ================================================= .. module:: distutils.text_file :synopsis: Provides the TextFile class, a simple interface to text files This module provides the :class:`TextFile` class, which gives an interface to text files that (optionally) takes care of stripping comments, ignoring blank lines, and joining lines with backslashes. .. class:: TextFile([filename=None, file=None, **options]) This class provides a file-like object that takes care of all the things you commonly want to do when processing a text file that has some line-by-line syntax: strip comments (as long as ``#`` is your comment character), skip blank lines, join adjacent lines by escaping the newline (ie. backslash at end of line), strip leading and/or trailing whitespace. All of these are optional and independently controllable. The class provides a :meth:`warn` method so you can generate warning messages that report physical line number, even if the logical line in question spans multiple physical lines. Also provides :meth:`unreadline` for implementing line-at-a-time lookahead. :class:`TextFile` instances are create with either *filename*, *file*, or both. :exc:`RuntimeError` is raised if both are ``None``. *filename* should be a string, and *file* a file object (or something that provides :meth:`readline` and :meth:`close` methods). It is recommended that you supply at least *filename*, so that :class:`TextFile` can include it in warning messages. If *file* is not supplied, :class:`TextFile` creates its own using the :func:`open` built-in function. The options are all boolean, and affect the values returned by :meth:`readline` .. tabularcolumns:: |l|L|l| +------------------+--------------------------------+---------+ | option name | description | default | +==================+================================+=========+ | *strip_comments* | strip from ``'#'`` to | true | | | end-of-line, as well as any | | | | whitespace leading up to the | | | | ``'#'``\ ---unless it is | | | | escaped by a backslash | | +------------------+--------------------------------+---------+ | *lstrip_ws* | strip leading whitespace from | false | | | each line before returning it | | +------------------+--------------------------------+---------+ | *rstrip_ws* | strip trailing whitespace | true | | | (including line terminator!) | | | | from each line before | | | | returning it. | | +------------------+--------------------------------+---------+ | *skip_blanks* | skip lines that are empty | true | | | \*after\* stripping comments | | | | and whitespace. (If both | | | | lstrip_ws and rstrip_ws are | | | | false, then some lines may | | | | consist of solely whitespace: | | | | these will \*not\* be skipped, | | | | even if *skip_blanks* is | | | | true.) | | +------------------+--------------------------------+---------+ | *join_lines* | if a backslash is the last | false | | | non-newline character on a | | | | line after stripping comments | | | | and whitespace, join the | | | | following line to it to form | | | | one logical line; if N | | | | consecutive lines end with a | | | | backslash, then N+1 physical | | | | lines will be joined to form | | | | one logical line. | | +------------------+--------------------------------+---------+ | *collapse_join* | strip leading whitespace from | false | | | lines that are joined to their | | | | predecessor; only matters if | | | | ``(join_lines and not | | | | lstrip_ws)`` | | +------------------+--------------------------------+---------+ Note that since *rstrip_ws* can strip the trailing newline, the semantics of :meth:`readline` must differ from those of the built-in file object's :meth:`readline` method! In particular, :meth:`readline` returns ``None`` for end-of-file: an empty string might just be a blank line (or an all-whitespace line), if *rstrip_ws* is true but *skip_blanks* is not. .. method:: TextFile.open(filename) Open a new file *filename*. This overrides any *file* or *filename* constructor arguments. .. method:: TextFile.close() Close the current file and forget everything we know about it (including the filename and the current line number). .. method:: TextFile.warn(msg[,line=None]) Print (to stderr) a warning message tied to the current logical line in the current file. If the current logical line in the file spans multiple physical lines, the warning refers to the whole range, such as ``"lines 3-5"``. If *line* is supplied, it overrides the current line number; it may be a list or tuple to indicate a range of physical lines, or an integer for a single physical line. .. method:: TextFile.readline() Read and return a single logical line from the current file (or from an internal buffer if lines have previously been "unread" with :meth:`unreadline`). If the *join_lines* option is true, this may involve reading multiple physical lines concatenated into a single string. Updates the current line number, so calling :meth:`warn` after :meth:`readline` emits a warning about the physical line(s) just read. Returns ``None`` on end-of-file, since the empty string can occur if *rstrip_ws* is true but *strip_blanks* is not. .. method:: TextFile.readlines() Read and return the list of all logical lines remaining in the current file. This updates the current line number to the last line of the file. .. method:: TextFile.unreadline(line) Push *line* (a string) onto an internal buffer that will be checked by future :meth:`readline` calls. Handy for implementing a parser with line-at-a-time lookahead. Note that lines that are "unread" with :meth:`unreadline` are not subsequently re-cleansed (whitespace stripped, or whatever) when read with :meth:`readline`. If multiple calls are made to :meth:`unreadline` before a call to :meth:`readline`, the lines will be returned most in most recent first order. :mod:`distutils.version` --- Version number classes =================================================== .. module:: distutils.version :synopsis: Implements classes that represent module version numbers. .. % todo .. % \section{Distutils Commands} .. % .. % This part of Distutils implements the various Distutils commands, such .. % as \code{build}, \code{install} \&c. Each command is implemented as a .. % separate module, with the command name as the name of the module. :mod:`distutils.cmd` --- Abstract base class for Distutils commands =================================================================== .. module:: distutils.cmd :synopsis: Provides the abstract base class :class:`~distutils.cmd.Command`. This class is subclassed by the modules in the distutils.command subpackage. This module supplies the abstract base class :class:`Command`. .. class:: Command(dist) Abstract base class for defining command classes, the "worker bees" of the Distutils. A useful analogy for command classes is to think of them as subroutines with local variables called *options*. The options are declared in :meth:`initialize_options` and defined (given their final values) in :meth:`finalize_options`, both of which must be defined by every command class. The distinction between the two is necessary because option values might come from the outside world (command line, config file, ...), and any options dependent on other options must be computed after these outside influences have been processed --- hence :meth:`finalize_options`. The body of the subroutine, where it does all its work based on the values of its options, is the :meth:`run` method, which must also be implemented by every command class. The class constructor takes a single argument *dist*, a :class:`~distutils.core.Distribution` instance. Creating a new Distutils command ================================ This section outlines the steps to create a new Distutils command. A new command lives in a module in the :mod:`distutils.command` package. There is a sample template in that directory called :file:`command_template`. Copy this file to a new module with the same name as the new command you're implementing. This module should implement a class with the same name as the module (and the command). So, for instance, to create the command ``peel_banana`` (so that users can run ``setup.py peel_banana``), you'd copy :file:`command_template` to :file:`distutils/command/peel_banana.py`, then edit it so that it's implementing the class ``peel_banana``, a subclass of :class:`distutils.cmd.Command`. Subclasses of :class:`Command` must define the following methods. .. method:: Command.initialize_options() Set default values for all the options that this command supports. Note that these defaults may be overridden by other commands, by the setup script, by config files, or by the command-line. Thus, this is not the place to code dependencies between options; generally, :meth:`initialize_options` implementations are just a bunch of ``self.foo = None`` assignments. .. method:: Command.finalize_options() Set final values for all the options that this command supports. This is always called as late as possible, ie. after any option assignments from the command-line or from other commands have been done. Thus, this is the place to code option dependencies: if *foo* depends on *bar*, then it is safe to set *foo* from *bar* as long as *foo* still has the same value it was assigned in :meth:`initialize_options`. .. method:: Command.run() A command's raison d'etre: carry out the action it exists to perform, controlled by the options initialized in :meth:`initialize_options`, customized by other commands, the setup script, the command-line, and config files, and finalized in :meth:`finalize_options`. All terminal output and filesystem interaction should be done by :meth:`run`. .. attribute:: Command.sub_commands *sub_commands* formalizes the notion of a "family" of commands, e.g. ``install`` as the parent with sub-commands ``install_lib``, ``install_headers``, etc. The parent of a family of commands defines *sub_commands* as a class attribute; it's a list of 2-tuples ``(command_name, predicate)``, with *command_name* a string and *predicate* a function, a string or ``None``. *predicate* is a method of the parent command that determines whether the corresponding command is applicable in the current situation. (E.g. ``install_headers`` is only applicable if we have any C header files to install.) If *predicate* is ``None``, that command is always applicable. *sub_commands* is usually defined at the *end* of a class, because predicates can be methods of the class, so they must already have been defined. The canonical example is the :command:`install` command. :mod:`distutils.command` --- Individual Distutils commands ========================================================== .. module:: distutils.command :synopsis: Contains one module for each standard Distutils command. .. % \subsubsection{Individual Distutils commands} .. % todo :mod:`distutils.command.bdist` --- Build a binary installer =========================================================== .. module:: distutils.command.bdist :synopsis: Build a binary installer for a package .. % todo :mod:`distutils.command.bdist_packager` --- Abstract base class for packagers ============================================================================= .. module:: distutils.command.bdist_packager :synopsis: Abstract base class for packagers .. % todo :mod:`distutils.command.bdist_dumb` --- Build a "dumb" installer ================================================================ .. module:: distutils.command.bdist_dumb :synopsis: Build a "dumb" installer - a simple archive of files .. % todo :mod:`distutils.command.bdist_msi` --- Build a Microsoft Installer binary package ================================================================================= .. module:: distutils.command.bdist_msi :synopsis: Build a binary distribution as a Windows MSI file .. class:: bdist_msi .. deprecated:: 3.9 Use bdist_wheel (wheel packages) instead. Builds a `Windows Installer`_ (.msi) binary package. .. _Windows Installer: https://msdn.microsoft.com/en-us/library/cc185688(VS.85).aspx In most cases, the ``bdist_msi`` installer is a better choice than the ``bdist_wininst`` installer, because it provides better support for Win64 platforms, allows administrators to perform non-interactive installations, and allows installation through group policies. :mod:`distutils.command.bdist_rpm` --- Build a binary distribution as a Redhat RPM and SRPM =========================================================================================== .. module:: distutils.command.bdist_rpm :synopsis: Build a binary distribution as a Redhat RPM and SRPM .. % todo :mod:`distutils.command.bdist_wininst` --- Build a Windows installer ==================================================================== .. module:: distutils.command.bdist_wininst :synopsis: Build a Windows installer .. deprecated:: 3.8 Use bdist_wheel (wheel packages) instead. .. % todo :mod:`distutils.command.sdist` --- Build a source distribution ============================================================== .. module:: distutils.command.sdist :synopsis: Build a source distribution .. % todo :mod:`distutils.command.build` --- Build all files of a package =============================================================== .. module:: distutils.command.build :synopsis: Build all files of a package .. % todo :mod:`distutils.command.build_clib` --- Build any C libraries in a package ========================================================================== .. module:: distutils.command.build_clib :synopsis: Build any C libraries in a package .. % todo :mod:`distutils.command.build_ext` --- Build any extensions in a package ======================================================================== .. module:: distutils.command.build_ext :synopsis: Build any extensions in a package .. % todo :mod:`distutils.command.build_py` --- Build the .py/.pyc files of a package =========================================================================== .. module:: distutils.command.build_py :synopsis: Build the .py/.pyc files of a package .. class:: build_py :mod:`distutils.command.build_scripts` --- Build the scripts of a package ========================================================================= .. module:: distutils.command.build_scripts :synopsis: Build the scripts of a package .. % todo :mod:`distutils.command.clean` --- Clean a package build area ============================================================= .. module:: distutils.command.clean :synopsis: Clean a package build area This command removes the temporary files created by :command:`build` and its subcommands, like intermediary compiled object files. With the ``--all`` option, the complete build directory will be removed. Extension modules built :ref:`in place ` will not be cleaned, as they are not in the build directory. :mod:`distutils.command.config` --- Perform package configuration ================================================================= .. module:: distutils.command.config :synopsis: Perform package configuration .. % todo :mod:`distutils.command.install` --- Install a package ====================================================== .. module:: distutils.command.install :synopsis: Install a package .. % todo :mod:`distutils.command.install_data` --- Install data files from a package =========================================================================== .. module:: distutils.command.install_data :synopsis: Install data files from a package .. % todo :mod:`distutils.command.install_headers` --- Install C/C++ header files from a package ====================================================================================== .. module:: distutils.command.install_headers :synopsis: Install C/C++ header files from a package .. % todo :mod:`distutils.command.install_lib` --- Install library files from a package ============================================================================= .. module:: distutils.command.install_lib :synopsis: Install library files from a package .. % todo :mod:`distutils.command.install_scripts` --- Install script files from a package ================================================================================ .. module:: distutils.command.install_scripts :synopsis: Install script files from a package .. % todo :mod:`distutils.command.register` --- Register a module with the Python Package Index ===================================================================================== .. module:: distutils.command.register :synopsis: Register a module with the Python Package Index The ``register`` command registers the package with the Python Package Index. This is described in more detail in :pep:`301`. .. % todo :mod:`distutils.command.check` --- Check the meta-data of a package =================================================================== .. module:: distutils.command.check :synopsis: Check the meta-data of a package The ``check`` command performs some tests on the meta-data of a package. For example, it verifies that all required meta-data are provided as the arguments passed to the :func:`~distutils.core.setup` function. .. % todo ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/builtdist.rst0000644000175100001710000005502100000000000023210 0ustar00runnerdocker.. _built-dist: **************************** Creating Built Distributions **************************** .. include:: ./_setuptools_disclaimer.rst A "built distribution" is what you're probably used to thinking of either as a "binary package" or an "installer" (depending on your background). It's not necessarily binary, though, because it might contain only Python source code and/or byte-code; and we don't call it a package, because that word is already spoken for in Python. (And "installer" is a term specific to the world of mainstream desktop systems.) A built distribution is how you make life as easy as possible for installers of your module distribution: for users of RPM-based Linux systems, it's a binary RPM; for Windows users, it's an executable installer; for Debian-based Linux users, it's a Debian package; and so forth. Obviously, no one person will be able to create built distributions for every platform under the sun, so the Distutils are designed to enable module developers to concentrate on their specialty---writing code and creating source distributions---while an intermediary species called *packagers* springs up to turn source distributions into built distributions for as many platforms as there are packagers. Of course, the module developer could be their own packager; or the packager could be a volunteer "out there" somewhere who has access to a platform which the original developer does not; or it could be software periodically grabbing new source distributions and turning them into built distributions for as many platforms as the software has access to. Regardless of who they are, a packager uses the setup script and the :command:`bdist` command family to generate built distributions. As a simple example, if I run the following command in the Distutils source tree:: python setup.py bdist then the Distutils builds my module distribution (the Distutils itself in this case), does a "fake" installation (also in the :file:`build` directory), and creates the default type of built distribution for my platform. The default format for built distributions is a "dumb" tar file on Unix, and a simple executable installer on Windows. (That tar file is considered "dumb" because it has to be unpacked in a specific location to work.) Thus, the above command on a Unix system creates :file:`Distutils-1.0.{plat}.tar.gz`; unpacking this tarball from the right place installs the Distutils just as though you had downloaded the source distribution and run ``python setup.py install``. (The "right place" is either the root of the filesystem or Python's :file:`{prefix}` directory, depending on the options given to the :command:`bdist_dumb` command; the default is to make dumb distributions relative to :file:`{prefix}`.) Obviously, for pure Python distributions, this isn't any simpler than just running ``python setup.py install``\ ---but for non-pure distributions, which include extensions that would need to be compiled, it can mean the difference between someone being able to use your extensions or not. And creating "smart" built distributions, such as an RPM package or an executable installer for Windows, is far more convenient for users even if your distribution doesn't include any extensions. The :command:`bdist` command has a :option:`!--formats` option, similar to the :command:`sdist` command, which you can use to select the types of built distribution to generate: for example, :: python setup.py bdist --format=zip would, when run on a Unix system, create :file:`Distutils-1.0.{plat}.zip`\ ---again, this archive would be unpacked from the root directory to install the Distutils. The available formats for built distributions are: +-------------+------------------------------+---------+ | Format | Description | Notes | +=============+==============================+=========+ | ``gztar`` | gzipped tar file | \(1) | | | (:file:`.tar.gz`) | | +-------------+------------------------------+---------+ | ``bztar`` | bzipped tar file | | | | (:file:`.tar.bz2`) | | +-------------+------------------------------+---------+ | ``xztar`` | xzipped tar file | | | | (:file:`.tar.xz`) | | +-------------+------------------------------+---------+ | ``ztar`` | compressed tar file | \(3) | | | (:file:`.tar.Z`) | | +-------------+------------------------------+---------+ | ``tar`` | tar file (:file:`.tar`) | | +-------------+------------------------------+---------+ | ``zip`` | zip file (:file:`.zip`) | (2),(4) | +-------------+------------------------------+---------+ | ``rpm`` | RPM | \(5) | +-------------+------------------------------+---------+ | ``pkgtool`` | Solaris :program:`pkgtool` | | +-------------+------------------------------+---------+ | ``sdux`` | HP-UX :program:`swinstall` | | +-------------+------------------------------+---------+ | ``wininst`` | self-extracting ZIP file for | \(4) | | | Windows | | +-------------+------------------------------+---------+ | ``msi`` | Microsoft Installer. | | +-------------+------------------------------+---------+ .. versionchanged:: 3.5 Added support for the ``xztar`` format. Notes: (1) default on Unix (2) default on Windows (3) requires external :program:`compress` utility. (4) requires either external :program:`zip` utility or :mod:`zipfile` module (part of the standard Python library since Python 1.6) (5) requires external :program:`rpm` utility, version 3.0.4 or better (use ``rpm --version`` to find out which version you have) You don't have to use the :command:`bdist` command with the :option:`!--formats` option; you can also use the command that directly implements the format you're interested in. Some of these :command:`bdist` "sub-commands" actually generate several similar formats; for instance, the :command:`bdist_dumb` command generates all the "dumb" archive formats (``tar``, ``gztar``, ``bztar``, ``xztar``, ``ztar``, and ``zip``), and :command:`bdist_rpm` generates both binary and source RPMs. The :command:`bdist` sub-commands, and the formats generated by each, are: +--------------------------+-------------------------------------+ | Command | Formats | +==========================+=====================================+ | :command:`bdist_dumb` | tar, gztar, bztar, xztar, ztar, zip | +--------------------------+-------------------------------------+ | :command:`bdist_rpm` | rpm, srpm | +--------------------------+-------------------------------------+ | :command:`bdist_wininst` | wininst | +--------------------------+-------------------------------------+ | :command:`bdist_msi` | msi | +--------------------------+-------------------------------------+ .. note:: bdist_wininst is deprecated since Python 3.8. .. note:: bdist_msi is deprecated since Python 3.9. The following sections give details on the individual :command:`bdist_\*` commands. .. .. _creating-dumb: .. Creating dumb built distributions .. ================================= .. XXX Need to document absolute vs. prefix-relative packages here, but first I have to implement it! .. _creating-rpms: Creating RPM packages ===================== The RPM format is used by many popular Linux distributions, including Red Hat, SuSE, and Mandrake. If one of these (or any of the other RPM-based Linux distributions) is your usual environment, creating RPM packages for other users of that same distribution is trivial. Depending on the complexity of your module distribution and differences between Linux distributions, you may also be able to create RPMs that work on different RPM-based distributions. The usual way to create an RPM of your module distribution is to run the :command:`bdist_rpm` command:: python setup.py bdist_rpm or the :command:`bdist` command with the :option:`!--format` option:: python setup.py bdist --formats=rpm The former allows you to specify RPM-specific options; the latter allows you to easily specify multiple formats in one run. If you need to do both, you can explicitly specify multiple :command:`bdist_\*` commands and their options:: python setup.py bdist_rpm --packager="John Doe " \ bdist_wininst --target-version="2.0" Creating RPM packages is driven by a :file:`.spec` file, much as using the Distutils is driven by the setup script. To make your life easier, the :command:`bdist_rpm` command normally creates a :file:`.spec` file based on the information you supply in the setup script, on the command line, and in any Distutils configuration files. Various options and sections in the :file:`.spec` file are derived from options in the setup script as follows: +------------------------------------------+----------------------------------------------+ | RPM :file:`.spec` file option or section | Distutils setup script option | +==========================================+==============================================+ | Name | ``name`` | +------------------------------------------+----------------------------------------------+ | Summary (in preamble) | ``description`` | +------------------------------------------+----------------------------------------------+ | Version | ``version`` | +------------------------------------------+----------------------------------------------+ | Vendor | ``author`` and ``author_email``, | | | or --- & ``maintainer`` and | | | ``maintainer_email`` | +------------------------------------------+----------------------------------------------+ | Copyright | ``license`` | +------------------------------------------+----------------------------------------------+ | Url | ``url`` | +------------------------------------------+----------------------------------------------+ | %description (section) | ``long_description`` | +------------------------------------------+----------------------------------------------+ Additionally, there are many options in :file:`.spec` files that don't have corresponding options in the setup script. Most of these are handled through options to the :command:`bdist_rpm` command as follows: +-------------------------------+-----------------------------+-------------------------+ | RPM :file:`.spec` file option | :command:`bdist_rpm` option | default value | | or section | | | +===============================+=============================+=========================+ | Release | ``release`` | "1" | +-------------------------------+-----------------------------+-------------------------+ | Group | ``group`` | "Development/Libraries" | +-------------------------------+-----------------------------+-------------------------+ | Vendor | ``vendor`` | (see above) | +-------------------------------+-----------------------------+-------------------------+ | Packager | ``packager`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Provides | ``provides`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Requires | ``requires`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Conflicts | ``conflicts`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Obsoletes | ``obsoletes`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Distribution | ``distribution_name`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | BuildRequires | ``build_requires`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Icon | ``icon`` | (none) | +-------------------------------+-----------------------------+-------------------------+ Obviously, supplying even a few of these options on the command-line would be tedious and error-prone, so it's usually best to put them in the setup configuration file, :file:`setup.cfg`\ ---see section :ref:`setup-config`. If you distribute or package many Python module distributions, you might want to put options that apply to all of them in your personal Distutils configuration file (:file:`~/.pydistutils.cfg`). If you want to temporarily disable this file, you can pass the :option:`!--no-user-cfg` option to :file:`setup.py`. There are three steps to building a binary RPM package, all of which are handled automatically by the Distutils: #. create a :file:`.spec` file, which describes the package (analogous to the Distutils setup script; in fact, much of the information in the setup script winds up in the :file:`.spec` file) #. create the source RPM #. create the "binary" RPM (which may or may not contain binary code, depending on whether your module distribution contains Python extensions) Normally, RPM bundles the last two steps together; when you use the Distutils, all three steps are typically bundled together. If you wish, you can separate these three steps. You can use the :option:`!--spec-only` option to make :command:`bdist_rpm` just create the :file:`.spec` file and exit; in this case, the :file:`.spec` file will be written to the "distribution directory"---normally :file:`dist/`, but customizable with the :option:`!--dist-dir` option. (Normally, the :file:`.spec` file winds up deep in the "build tree," in a temporary directory created by :command:`bdist_rpm`.) .. % \XXX{this isn't implemented yet---is it needed?!} .. % You can also specify a custom \file{.spec} file with the .. % \longprogramopt{spec-file} option; used in conjunction with .. % \longprogramopt{spec-only}, this gives you an opportunity to customize .. % the \file{.spec} file manually: .. % .. % \ begin{verbatim} .. % > python setup.py bdist_rpm --spec-only .. % # ...edit dist/FooBar-1.0.spec .. % > python setup.py bdist_rpm --spec-file=dist/FooBar-1.0.spec .. % \ end{verbatim} .. % .. % (Although a better way to do this is probably to override the standard .. % \command{bdist\_rpm} command with one that writes whatever else you want .. % to the \file{.spec} file.) .. _creating-wininst: Creating Windows Installers =========================== .. warning:: bdist_wininst is deprecated since Python 3.8. .. warning:: bdist_msi is deprecated since Python 3.9. Executable installers are the natural format for binary distributions on Windows. They display a nice graphical user interface, display some information about the module distribution to be installed taken from the metadata in the setup script, let the user select a few options, and start or cancel the installation. Since the metadata is taken from the setup script, creating Windows installers is usually as easy as running:: python setup.py bdist_wininst or the :command:`bdist` command with the :option:`!--formats` option:: python setup.py bdist --formats=wininst If you have a pure module distribution (only containing pure Python modules and packages), the resulting installer will be version independent and have a name like :file:`foo-1.0.win32.exe`. Note that creating ``wininst`` binary distributions in only supported on Windows systems. If you have a non-pure distribution, the extensions can only be created on a Windows platform, and will be Python version dependent. The installer filename will reflect this and now has the form :file:`foo-1.0.win32-py2.0.exe`. You have to create a separate installer for every Python version you want to support. The installer will try to compile pure modules into :term:`bytecode` after installation on the target system in normal and optimizing mode. If you don't want this to happen for some reason, you can run the :command:`bdist_wininst` command with the :option:`!--no-target-compile` and/or the :option:`!--no-target-optimize` option. By default the installer will display the cool "Python Powered" logo when it is run, but you can also supply your own 152x261 bitmap which must be a Windows :file:`.bmp` file with the :option:`!--bitmap` option. The installer will also display a large title on the desktop background window when it is run, which is constructed from the name of your distribution and the version number. This can be changed to another text by using the :option:`!--title` option. The installer file will be written to the "distribution directory" --- normally :file:`dist/`, but customizable with the :option:`!--dist-dir` option. .. _cross-compile-windows: Cross-compiling on Windows ========================== Starting with Python 2.6, distutils is capable of cross-compiling between Windows platforms. In practice, this means that with the correct tools installed, you can use a 32bit version of Windows to create 64bit extensions and vice-versa. To build for an alternate platform, specify the :option:`!--plat-name` option to the build command. Valid values are currently 'win32', and 'win-amd64'. For example, on a 32bit version of Windows, you could execute:: python setup.py build --plat-name=win-amd64 to build a 64bit version of your extension. The Windows Installers also support this option, so the command:: python setup.py build --plat-name=win-amd64 bdist_wininst would create a 64bit installation executable on your 32bit version of Windows. To cross-compile, you must download the Python source code and cross-compile Python itself for the platform you are targeting - it is not possible from a binary installation of Python (as the .lib etc file for other platforms are not included.) In practice, this means the user of a 32 bit operating system will need to use Visual Studio 2008 to open the :file:`PCbuild/PCbuild.sln` solution in the Python source tree and build the "x64" configuration of the 'pythoncore' project before cross-compiling extensions is possible. Note that by default, Visual Studio 2008 does not install 64bit compilers or tools. You may need to reexecute the Visual Studio setup process and select these tools (using Control Panel->[Add/Remove] Programs is a convenient way to check or modify your existing install.) .. _postinstallation-script: The Postinstallation script --------------------------- Starting with Python 2.3, a postinstallation script can be specified with the :option:`!--install-script` option. The basename of the script must be specified, and the script filename must also be listed in the scripts argument to the setup function. This script will be run at installation time on the target system after all the files have been copied, with ``argv[1]`` set to :option:`!-install`, and again at uninstallation time before the files are removed with ``argv[1]`` set to :option:`!-remove`. The installation script runs embedded in the windows installer, every output (``sys.stdout``, ``sys.stderr``) is redirected into a buffer and will be displayed in the GUI after the script has finished. Some functions especially useful in this context are available as additional built-in functions in the installation script. .. function:: directory_created(path) file_created(path) These functions should be called when a directory or file is created by the postinstall script at installation time. It will register *path* with the uninstaller, so that it will be removed when the distribution is uninstalled. To be safe, directories are only removed if they are empty. .. function:: get_special_folder_path(csidl_string) This function can be used to retrieve special folder locations on Windows like the Start Menu or the Desktop. It returns the full path to the folder. *csidl_string* must be one of the following strings:: "CSIDL_APPDATA" "CSIDL_COMMON_STARTMENU" "CSIDL_STARTMENU" "CSIDL_COMMON_DESKTOPDIRECTORY" "CSIDL_DESKTOPDIRECTORY" "CSIDL_COMMON_STARTUP" "CSIDL_STARTUP" "CSIDL_COMMON_PROGRAMS" "CSIDL_PROGRAMS" "CSIDL_FONTS" If the folder cannot be retrieved, :exc:`OSError` is raised. Which folders are available depends on the exact Windows version, and probably also the configuration. For details refer to Microsoft's documentation of the :c:func:`SHGetSpecialFolderPath` function. .. function:: create_shortcut(target, description, filename[, arguments[, workdir[, iconpath[, iconindex]]]]) This function creates a shortcut. *target* is the path to the program to be started by the shortcut. *description* is the description of the shortcut. *filename* is the title of the shortcut that the user will see. *arguments* specifies the command line arguments, if any. *workdir* is the working directory for the program. *iconpath* is the file containing the icon for the shortcut, and *iconindex* is the index of the icon in the file *iconpath*. Again, for details consult the Microsoft documentation for the :class:`IShellLink` interface. Vista User Access Control (UAC) =============================== Starting with Python 2.6, bdist_wininst supports a :option:`!--user-access-control` option. The default is 'none' (meaning no UAC handling is done), and other valid values are 'auto' (meaning prompt for UAC elevation if Python was installed for all users) and 'force' (meaning always prompt for elevation). .. note:: bdist_wininst is deprecated since Python 3.8. .. note:: bdist_msi is deprecated since Python 3.9. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/commandref.rst0000644000175100001710000001103500000000000023315 0ustar00runnerdocker.. _reference: ***************** Command Reference ***************** .. include:: ./_setuptools_disclaimer.rst .. % \section{Building modules: the \protect\command{build} command family} .. % \label{build-cmds} .. % \subsubsection{\protect\command{build}} .. % \label{build-cmd} .. % \subsubsection{\protect\command{build\_py}} .. % \label{build-py-cmd} .. % \subsubsection{\protect\command{build\_ext}} .. % \label{build-ext-cmd} .. % \subsubsection{\protect\command{build\_clib}} .. % \label{build-clib-cmd} .. _install-cmd: Installing modules: the :command:`install` command family ========================================================= The install command ensures that the build commands have been run and then runs the subcommands :command:`install_lib`, :command:`install_data` and :command:`install_scripts`. .. % \subsubsection{\protect\command{install\_lib}} .. % \label{install-lib-cmd} .. _install-data-cmd: :command:`install_data` ----------------------- This command installs all data files provided with the distribution. .. _install-scripts-cmd: :command:`install_scripts` -------------------------- This command installs all (Python) scripts in the distribution. .. % \subsection{Cleaning up: the \protect\command{clean} command} .. % \label{clean-cmd} .. _sdist-cmd: Creating a source distribution: the :command:`sdist` command ============================================================ .. XXX fragment moved down from above: needs context! The manifest template commands are: +-------------------------------------------+-----------------------------------------------+ | Command | Description | +===========================================+===============================================+ | :command:`include pat1 pat2 ...` | include all files matching any of the listed | | | patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`exclude pat1 pat2 ...` | exclude all files matching any of the listed | | | patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`recursive-include dir pat1 pat2 | include all files under *dir* matching any of | | ...` | the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`recursive-exclude dir pat1 pat2 | exclude all files under *dir* matching any of | | ...` | the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`global-include pat1 pat2 ...` | include all files anywhere in the source tree | | | matching --- & any of the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`global-exclude pat1 pat2 ...` | exclude all files anywhere in the source tree | | | matching --- & any of the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`prune dir` | exclude all files under *dir* | +-------------------------------------------+-----------------------------------------------+ | :command:`graft dir` | include all files under *dir* | +-------------------------------------------+-----------------------------------------------+ The patterns here are Unix-style "glob" patterns: ``*`` matches any sequence of regular filename characters, ``?`` matches any single regular filename character, and ``[range]`` matches any of the characters in *range* (e.g., ``a-z``, ``a-zA-Z``, ``a-f0-9_.``). The definition of "regular filename character" is platform-specific: on Unix it is anything except slash; on Windows anything except backslash or colon. .. XXX Windows support not there yet .. % \section{Creating a built distribution: the .. % \protect\command{bdist} command family} .. % \label{bdist-cmds} .. % \subsection{\protect\command{bdist}} .. % \subsection{\protect\command{bdist\_dumb}} .. % \subsection{\protect\command{bdist\_rpm}} .. % \subsection{\protect\command{bdist\_wininst}} ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/configfile.rst0000644000175100001710000001364400000000000023317 0ustar00runnerdocker.. _setup-config: ************************************ Writing the Setup Configuration File ************************************ .. include:: ./_setuptools_disclaimer.rst Often, it's not possible to write down everything needed to build a distribution *a priori*: you may need to get some information from the user, or from the user's system, in order to proceed. As long as that information is fairly simple---a list of directories to search for C header files or libraries, for example---then providing a configuration file, :file:`setup.cfg`, for users to edit is a cheap and easy way to solicit it. Configuration files also let you provide default values for any command option, which the installer can then override either on the command-line or by editing the config file. The setup configuration file is a useful middle-ground between the setup script---which, ideally, would be opaque to installers [#]_---and the command-line to the setup script, which is outside of your control and entirely up to the installer. In fact, :file:`setup.cfg` (and any other Distutils configuration files present on the target system) are processed after the contents of the setup script, but before the command-line. This has several useful consequences: .. % (If you have more advanced needs, such as determining which extensions .. % to build based on what capabilities are present on the target system, .. % then you need the Distutils ``auto-configuration'' facility. This .. % started to appear in Distutils 0.9 but, as of this writing, isn't mature .. % or stable enough yet for real-world use.) * installers can override some of what you put in :file:`setup.py` by editing :file:`setup.cfg` * you can provide non-standard defaults for options that are not easily set in :file:`setup.py` * installers can override anything in :file:`setup.cfg` using the command-line options to :file:`setup.py` The basic syntax of the configuration file is simple: .. code-block:: ini [command] option=value ... where *command* is one of the Distutils commands (e.g. :command:`build_py`, :command:`install`), and *option* is one of the options that command supports. Any number of options can be supplied for each command, and any number of command sections can be included in the file. Blank lines are ignored, as are comments, which run from a ``'#'`` character until the end of the line. Long option values can be split across multiple lines simply by indenting the continuation lines. You can find out the list of options supported by a particular command with the universal :option:`!--help` option, e.g. .. code-block:: shell-session $ python setup.py --help build_ext [...] Options for 'build_ext' command: --build-lib (-b) directory for compiled extension modules --build-temp (-t) directory for temporary files (build by-products) --inplace (-i) ignore build-lib and put compiled extensions into the source directory alongside your pure Python modules --include-dirs (-I) list of directories to search for header files --define (-D) C preprocessor macros to define --undef (-U) C preprocessor macros to undefine --swig-opts list of SWIG command line options [...] Note that an option spelled :option:`!--foo-bar` on the command-line is spelled ``foo_bar`` in configuration files. .. _distutils-build-ext-inplace: For example, say you want your extensions to be built "in-place"---that is, you have an extension ``pkg.ext``, and you want the compiled extension file (:file:`ext.so` on Unix, say) to be put in the same source directory as your pure Python modules ``pkg.mod1`` and ``pkg.mod2``. You can always use the :option:`!--inplace` option on the command-line to ensure this: .. code-block:: sh python setup.py build_ext --inplace But this requires that you always specify the :command:`build_ext` command explicitly, and remember to provide :option:`!--inplace`. An easier way is to "set and forget" this option, by encoding it in :file:`setup.cfg`, the configuration file for this distribution: .. code-block:: ini [build_ext] inplace=1 This will affect all builds of this module distribution, whether or not you explicitly specify :command:`build_ext`. If you include :file:`setup.cfg` in your source distribution, it will also affect end-user builds---which is probably a bad idea for this option, since always building extensions in-place would break installation of the module distribution. In certain peculiar cases, though, modules are built right in their installation directory, so this is conceivably a useful ability. (Distributing extensions that expect to be built in their installation directory is almost always a bad idea, though.) Another example: certain commands take a lot of options that don't change from run to run; for example, :command:`bdist_rpm` needs to know everything required to generate a "spec" file for creating an RPM distribution. Some of this information comes from the setup script, and some is automatically generated by the Distutils (such as the list of files installed). But some of it has to be supplied as options to :command:`bdist_rpm`, which would be very tedious to do on the command-line for every run. Hence, here is a snippet from the Distutils' own :file:`setup.cfg`: .. code-block:: ini [bdist_rpm] release = 1 packager = Greg Ward doc_files = CHANGES.txt README.txt USAGE.txt doc/ examples/ Note that the ``doc_files`` option is simply a whitespace-separated string split across multiple lines for readability. .. seealso:: :ref:`inst-config-syntax` in "Installing Python Modules" More information on the configuration files is available in the manual for system administrators. .. rubric:: Footnotes .. [#] This ideal probably won't be achieved until auto-configuration is fully supported by the Distutils. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/examples.rst0000644000175100001710000002424000000000000023022 0ustar00runnerdocker.. _distutils_examples: ****************** Distutils Examples ****************** .. include:: ./_setuptools_disclaimer.rst This chapter provides a number of basic examples to help get started with distutils. Additional information about using distutils can be found in the Distutils Cookbook. .. seealso:: `Distutils Cookbook `_ Collection of recipes showing how to achieve more control over distutils. .. _pure-mod: Pure Python distribution (by module) ==================================== If you're just distributing a couple of modules, especially if they don't live in a particular package, you can specify them individually using the ``py_modules`` option in the setup script. In the simplest case, you'll have two files to worry about: a setup script and the single module you're distributing, :file:`foo.py` in this example:: / setup.py foo.py (In all diagrams in this section, ** will refer to the distribution root directory.) A minimal setup script to describe this situation would be:: from distutils.core import setup setup(name='foo', version='1.0', py_modules=['foo'], ) Note that the name of the distribution is specified independently with the ``name`` option, and there's no rule that says it has to be the same as the name of the sole module in the distribution (although that's probably a good convention to follow). However, the distribution name is used to generate filenames, so you should stick to letters, digits, underscores, and hyphens. Since ``py_modules`` is a list, you can of course specify multiple modules, eg. if you're distributing modules ``foo`` and ``bar``, your setup might look like this:: / setup.py foo.py bar.py and the setup script might be :: from distutils.core import setup setup(name='foobar', version='1.0', py_modules=['foo', 'bar'], ) You can put module source files into another directory, but if you have enough modules to do that, it's probably easier to specify modules by package rather than listing them individually. .. _pure-pkg: Pure Python distribution (by package) ===================================== If you have more than a couple of modules to distribute, especially if they are in multiple packages, it's probably easier to specify whole packages rather than individual modules. This works even if your modules are not in a package; you can just tell the Distutils to process modules from the root package, and that works the same as any other package (except that you don't have to have an :file:`__init__.py` file). The setup script from the last example could also be written as :: from distutils.core import setup setup(name='foobar', version='1.0', packages=[''], ) (The empty string stands for the root package.) If those two files are moved into a subdirectory, but remain in the root package, e.g.:: / setup.py src/ foo.py bar.py then you would still specify the root package, but you have to tell the Distutils where source files in the root package live:: from distutils.core import setup setup(name='foobar', version='1.0', package_dir={'': 'src'}, packages=[''], ) More typically, though, you will want to distribute multiple modules in the same package (or in sub-packages). For example, if the ``foo`` and ``bar`` modules belong in package ``foobar``, one way to layout your source tree is :: / setup.py foobar/ __init__.py foo.py bar.py This is in fact the default layout expected by the Distutils, and the one that requires the least work to describe in your setup script:: from distutils.core import setup setup(name='foobar', version='1.0', packages=['foobar'], ) If you want to put modules in directories not named for their package, then you need to use the ``package_dir`` option again. For example, if the :file:`src` directory holds modules in the ``foobar`` package:: / setup.py src/ __init__.py foo.py bar.py an appropriate setup script would be :: from distutils.core import setup setup(name='foobar', version='1.0', package_dir={'foobar': 'src'}, packages=['foobar'], ) Or, you might put modules from your main package right in the distribution root:: / setup.py __init__.py foo.py bar.py in which case your setup script would be :: from distutils.core import setup setup(name='foobar', version='1.0', package_dir={'foobar': ''}, packages=['foobar'], ) (The empty string also stands for the current directory.) If you have sub-packages, they must be explicitly listed in ``packages``, but any entries in ``package_dir`` automatically extend to sub-packages. (In other words, the Distutils does *not* scan your source tree, trying to figure out which directories correspond to Python packages by looking for :file:`__init__.py` files.) Thus, if the default layout grows a sub-package:: / setup.py foobar/ __init__.py foo.py bar.py subfoo/ __init__.py blah.py then the corresponding setup script would be :: from distutils.core import setup setup(name='foobar', version='1.0', packages=['foobar', 'foobar.subfoo'], ) .. _single-ext: Single extension module ======================= Extension modules are specified using the ``ext_modules`` option. ``package_dir`` has no effect on where extension source files are found; it only affects the source for pure Python modules. The simplest case, a single extension module in a single C source file, is:: / setup.py foo.c If the ``foo`` extension belongs in the root package, the setup script for this could be :: from distutils.core import setup from distutils.extension import Extension setup(name='foobar', version='1.0', ext_modules=[Extension('foo', ['foo.c'])], ) If the extension actually belongs in a package, say ``foopkg``, then With exactly the same source tree layout, this extension can be put in the ``foopkg`` package simply by changing the name of the extension:: from distutils.core import setup from distutils.extension import Extension setup(name='foobar', version='1.0', ext_modules=[Extension('foopkg.foo', ['foo.c'])], ) Checking a package ================== The ``check`` command allows you to verify if your package meta-data meet the minimum requirements to build a distribution. To run it, just call it using your :file:`setup.py` script. If something is missing, ``check`` will display a warning. Let's take an example with a simple script:: from distutils.core import setup setup(name='foobar') Running the ``check`` command will display some warnings: .. code-block:: shell-session $ python setup.py check running check warning: check: missing required meta-data: version, url warning: check: missing meta-data: either (author and author_email) or (maintainer and maintainer_email) should be supplied If you use the reStructuredText syntax in the ``long_description`` field and `docutils`_ is installed you can check if the syntax is fine with the ``check`` command, using the ``restructuredtext`` option. For example, if the :file:`setup.py` script is changed like this:: from distutils.core import setup desc = """\ My description ============== This is the description of the ``foobar`` package. """ setup(name='foobar', version='1', author='tarek', author_email='tarek@ziade.org', url='http://example.com', long_description=desc) Where the long description is broken, ``check`` will be able to detect it by using the :mod:`docutils` parser: .. code-block:: shell-session $ python setup.py check --restructuredtext running check warning: check: Title underline too short. (line 2) warning: check: Could not finish the parsing. Reading the metadata ===================== The :func:`distutils.core.setup` function provides a command-line interface that allows you to query the metadata fields of a project through the ``setup.py`` script of a given project: .. code-block:: shell-session $ python setup.py --name distribute This call reads the ``name`` metadata by running the :func:`distutils.core.setup` function. Although, when a source or binary distribution is created with Distutils, the metadata fields are written in a static file called :file:`PKG-INFO`. When a Distutils-based project is installed in Python, the :file:`PKG-INFO` file is copied alongside the modules and packages of the distribution under :file:`NAME-VERSION-pyX.X.egg-info`, where ``NAME`` is the name of the project, ``VERSION`` its version as defined in the Metadata, and ``pyX.X`` the major and minor version of Python like ``2.7`` or ``3.2``. You can read back this static file, by using the :class:`distutils.dist.DistributionMetadata` class and its :func:`~distutils.dist.DistributionMetadata.read_pkg_file` method:: >>> from distutils.dist import DistributionMetadata >>> metadata = DistributionMetadata() >>> metadata.read_pkg_file(open('distribute-0.6.8-py2.7.egg-info')) >>> metadata.name 'distribute' >>> metadata.version '0.6.8' >>> metadata.description 'Easily download, build, install, upgrade, and uninstall Python packages' Notice that the class can also be instantiated with a metadata file path to loads its values:: >>> pkg_info_path = 'distribute-0.6.8-py2.7.egg-info' >>> DistributionMetadata(pkg_info_path).name 'distribute' .. % \section{Multiple extension modules} .. % \label{multiple-ext} .. % \section{Putting it all together} .. _docutils: http://docutils.sourceforge.net ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/extending.rst0000644000175100001710000001076000000000000023173 0ustar00runnerdocker.. _extending-distutils: ******************* Extending Distutils ******************* .. include:: ./_setuptools_disclaimer.rst Distutils can be extended in various ways. Most extensions take the form of new commands or replacements for existing commands. New commands may be written to support new types of platform-specific packaging, for example, while replacements for existing commands may be made to modify details of how the command operates on a package. Most extensions of the distutils are made within :file:`setup.py` scripts that want to modify existing commands; many simply add a few file extensions that should be copied into packages in addition to :file:`.py` files as a convenience. Most distutils command implementations are subclasses of the :class:`distutils.cmd.Command` class. New commands may directly inherit from :class:`~distutils.cmd.Command`, while replacements often derive from :class:`~distutils.cmd.Command` indirectly, directly subclassing the command they are replacing. Commands are required to derive from :class:`~distutils.cmd.Command`. .. % \section{Extending existing commands} .. % \label{extend-existing} .. % \section{Writing new commands} .. % \label{new-commands} .. % \XXX{Would an uninstall command be a good example here?} Integrating new commands ======================== There are different ways to integrate new command implementations into distutils. The most difficult is to lobby for the inclusion of the new features in distutils itself, and wait for (and require) a version of Python that provides that support. This is really hard for many reasons. The most common, and possibly the most reasonable for most needs, is to include the new implementations with your :file:`setup.py` script, and cause the :func:`distutils.core.setup` function use them:: from distutils.command.build_py import build_py as _build_py from distutils.core import setup class build_py(_build_py): """Specialized Python source builder.""" # implement whatever needs to be different... setup(cmdclass={'build_py': build_py}, ...) This approach is most valuable if the new implementations must be used to use a particular package, as everyone interested in the package will need to have the new command implementation. Beginning with Python 2.4, a third option is available, intended to allow new commands to be added which can support existing :file:`setup.py` scripts without requiring modifications to the Python installation. This is expected to allow third-party extensions to provide support for additional packaging systems, but the commands can be used for anything distutils commands can be used for. A new configuration option, ``command_packages`` (command-line option :option:`!--command-packages`), can be used to specify additional packages to be searched for modules implementing commands. Like all distutils options, this can be specified on the command line or in a configuration file. This option can only be set in the ``[global]`` section of a configuration file, or before any commands on the command line. If set in a configuration file, it can be overridden from the command line; setting it to an empty string on the command line causes the default to be used. This should never be set in a configuration file provided with a package. This new option can be used to add any number of packages to the list of packages searched for command implementations; multiple package names should be separated by commas. When not specified, the search is only performed in the :mod:`distutils.command` package. When :file:`setup.py` is run with the option ``--command-packages distcmds,buildcmds``, however, the packages :mod:`distutils.command`, ``distcmds``, and ``buildcmds`` will be searched in that order. New commands are expected to be implemented in modules of the same name as the command by classes sharing the same name. Given the example command line option above, the command :command:`bdist_openpkg` could be implemented by the class ``distcmds.bdist_openpkg.bdist_openpkg`` or ``buildcmds.bdist_openpkg.bdist_openpkg``. Adding new distribution types ============================= Commands that create distributions (files in the :file:`dist/` directory) need to add ``(command, filename)`` pairs to ``self.distribution.dist_files`` so that :command:`upload` can upload it to PyPI. The *filename* in the pair contains no path information, only the name of the file itself. In dry-run mode, pairs should still be added to represent what would have been created. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/index.rst0000644000175100001710000000235300000000000022314 0ustar00runnerdocker.. _distutils-index: ############################################## Distributing Python Modules (Legacy version) ############################################## :Authors: Greg Ward, Anthony Baxter :Email: distutils-sig@python.org .. seealso:: :ref:`distributing-index` The up to date module distribution documentations .. include:: ./_setuptools_disclaimer.rst .. note:: This guide only covers the basic tools for building and distributing extensions that are provided as part of this version of Python. Third party tools offer easier to use and more secure alternatives. Refer to the `quick recommendations section `__ in the Python Packaging User Guide for more information. This document describes the Python Distribution Utilities ("Distutils") from the module developer's point of view, describing the underlying capabilities that ``setuptools`` builds on to allow Python developers to make Python modules and extensions readily available to a wider audience. .. toctree:: :maxdepth: 2 :numbered: introduction.rst setupscript.rst configfile.rst sourcedist.rst builtdist.rst examples.rst extending.rst commandref.rst apiref.rst ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/introduction.rst0000644000175100001710000002060700000000000023730 0ustar00runnerdocker.. _distutils-intro: **************************** An Introduction to Distutils **************************** .. include:: ./_setuptools_disclaimer.rst This document covers using the Distutils to distribute your Python modules, concentrating on the role of developer/distributor: if you're looking for information on installing Python modules, you should refer to the :ref:`install-index` chapter. .. _distutils-concepts: Concepts & Terminology ====================== Using the Distutils is quite simple, both for module developers and for users/administrators installing third-party modules. As a developer, your responsibilities (apart from writing solid, well-documented and well-tested code, of course!) are: * write a setup script (:file:`setup.py` by convention) * (optional) write a setup configuration file * create a source distribution * (optional) create one or more built (binary) distributions Each of these tasks is covered in this document. Not all module developers have access to a multitude of platforms, so it's not always feasible to expect them to create a multitude of built distributions. It is hoped that a class of intermediaries, called *packagers*, will arise to address this need. Packagers will take source distributions released by module developers, build them on one or more platforms, and release the resulting built distributions. Thus, users on the most popular platforms will be able to install most popular Python module distributions in the most natural way for their platform, without having to run a single setup script or compile a line of code. .. _distutils-simple-example: A Simple Example ================ The setup script is usually quite simple, although since it's written in Python, there are no arbitrary limits to what you can do with it, though you should be careful about putting arbitrarily expensive operations in your setup script. Unlike, say, Autoconf-style configure scripts, the setup script may be run multiple times in the course of building and installing your module distribution. If all you want to do is distribute a module called ``foo``, contained in a file :file:`foo.py`, then your setup script can be as simple as this:: from distutils.core import setup setup(name='foo', version='1.0', py_modules=['foo'], ) Some observations: * most information that you supply to the Distutils is supplied as keyword arguments to the :func:`~distutils.core.setup` function * those keyword arguments fall into two categories: package metadata (name, version number) and information about what's in the package (a list of pure Python modules, in this case) * modules are specified by module name, not filename (the same will hold true for packages and extensions) * it's recommended that you supply a little more metadata, in particular your name, email address and a URL for the project (see section :ref:`setup-script` for an example) To create a source distribution for this module, you would create a setup script, :file:`setup.py`, containing the above code, and run this command from a terminal:: python setup.py sdist For Windows, open a command prompt window (:menuselection:`Start --> Accessories`) and change the command to:: setup.py sdist :command:`sdist` will create an archive file (e.g., tarball on Unix, ZIP file on Windows) containing your setup script :file:`setup.py`, and your module :file:`foo.py`. The archive file will be named :file:`foo-1.0.tar.gz` (or :file:`.zip`), and will unpack into a directory :file:`foo-1.0`. If an end-user wishes to install your ``foo`` module, all they have to do is download :file:`foo-1.0.tar.gz` (or :file:`.zip`), unpack it, and---from the :file:`foo-1.0` directory---run :: python setup.py install which will ultimately copy :file:`foo.py` to the appropriate directory for third-party modules in their Python installation. This simple example demonstrates some fundamental concepts of the Distutils. First, both developers and installers have the same basic user interface, i.e. the setup script. The difference is which Distutils *commands* they use: the :command:`sdist` command is almost exclusively for module developers, while :command:`install` is more often for installers (although most developers will want to install their own code occasionally). If you want to make things really easy for your users, you can create one or more built distributions for them. For instance, if you are running on a Windows machine, and want to make things easy for other Windows users, you can create an executable installer (the most appropriate type of built distribution for this platform) with the :command:`bdist_wininst` command. For example:: python setup.py bdist_wininst will create an executable installer, :file:`foo-1.0.win32.exe`, in the current directory. Other useful built distribution formats are RPM, implemented by the :command:`bdist_rpm` command, Solaris :program:`pkgtool` (:command:`bdist_pkgtool`), and HP-UX :program:`swinstall` (:command:`bdist_sdux`). For example, the following command will create an RPM file called :file:`foo-1.0.noarch.rpm`:: python setup.py bdist_rpm (The :command:`bdist_rpm` command uses the :command:`rpm` executable, therefore this has to be run on an RPM-based system such as Red Hat Linux, SuSE Linux, or Mandrake Linux.) You can find out what distribution formats are available at any time by running :: python setup.py bdist --help-formats .. _python-terms: General Python terminology ========================== If you're reading this document, you probably have a good idea of what modules, extensions, and so forth are. Nevertheless, just to be sure that everyone is operating from a common starting point, we offer the following glossary of common Python terms: module the basic unit of code reusability in Python: a block of code imported by some other code. Three types of modules concern us here: pure Python modules, extension modules, and packages. pure Python module a module written in Python and contained in a single :file:`.py` file (and possibly associated :file:`.pyc` files). Sometimes referred to as a "pure module." extension module a module written in the low-level language of the Python implementation: C/C++ for Python, Java for Jython. Typically contained in a single dynamically loadable pre-compiled file, e.g. a shared object (:file:`.so`) file for Python extensions on Unix, a DLL (given the :file:`.pyd` extension) for Python extensions on Windows, or a Java class file for Jython extensions. (Note that currently, the Distutils only handles C/C++ extensions for Python.) package a module that contains other modules; typically contained in a directory in the filesystem and distinguished from other directories by the presence of a file :file:`__init__.py`. root package the root of the hierarchy of packages. (This isn't really a package, since it doesn't have an :file:`__init__.py` file. But we have to call it something.) The vast majority of the standard library is in the root package, as are many small, standalone third-party modules that don't belong to a larger module collection. Unlike regular packages, modules in the root package can be found in many directories: in fact, every directory listed in ``sys.path`` contributes modules to the root package. .. _distutils-term: Distutils-specific terminology ============================== The following terms apply more specifically to the domain of distributing Python modules using the Distutils: module distribution a collection of Python modules distributed together as a single downloadable resource and meant to be installed *en masse*. Examples of some well-known module distributions are NumPy, SciPy, Pillow, or mxBase. (This would be called a *package*, except that term is already taken in the Python context: a single module distribution may contain zero, one, or many Python packages.) pure module distribution a module distribution that contains only pure Python modules and packages. Sometimes referred to as a "pure distribution." non-pure module distribution a module distribution that contains at least one extension module. Sometimes referred to as a "non-pure distribution." distribution root the top-level directory of your source tree (or source distribution); the directory where :file:`setup.py` exists. Generally :file:`setup.py` will be run from this directory. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/packageindex.rst0000644000175100001710000000070000000000000023622 0ustar00runnerdocker:orphan: .. _package-index: ******************************* The Python Package Index (PyPI) ******************************* The `Python Package Index (PyPI)`_ stores metadata describing distributions packaged with distutils and other publishing tools, as well the distribution archives themselves. References to up to date PyPI documentation can be found at :ref:`publishing-python-packages`. .. _Python Package Index (PyPI): https://pypi.org ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/setupscript.rst0000644000175100001710000007520400000000000023577 0ustar00runnerdocker.. _setup-script: ************************ Writing the Setup Script ************************ .. include:: ./_setuptools_disclaimer.rst The setup script is the centre of all activity in building, distributing, and installing modules using the Distutils. The main purpose of the setup script is to describe your module distribution to the Distutils, so that the various commands that operate on your modules do the right thing. As we saw in section :ref:`distutils-simple-example` above, the setup script consists mainly of a call to :func:`~distutils.core.setup`, and most information supplied to the Distutils by the module developer is supplied as keyword arguments to :func:`~distutils.core.setup`. Here's a slightly more involved example, which we'll follow for the next couple of sections: the Distutils' own setup script. (Keep in mind that although the Distutils are included with Python 1.6 and later, they also have an independent existence so that Python 1.5.2 users can use them to install other module distributions. The Distutils' own setup script, shown here, is used to install the package into Python 1.5.2.) :: #!/usr/bin/env python from distutils.core import setup setup(name='Distutils', version='1.0', description='Python Distribution Utilities', author='Greg Ward', author_email='gward@python.net', url='https://www.python.org/sigs/distutils-sig/', packages=['distutils', 'distutils.command'], ) There are only two differences between this and the trivial one-file distribution presented in section :ref:`distutils-simple-example`: more metadata, and the specification of pure Python modules by package, rather than by module. This is important since the Distutils consist of a couple of dozen modules split into (so far) two packages; an explicit list of every module would be tedious to generate and difficult to maintain. For more information on the additional meta-data, see section :ref:`meta-data`. Note that any pathnames (files or directories) supplied in the setup script should be written using the Unix convention, i.e. slash-separated. The Distutils will take care of converting this platform-neutral representation into whatever is appropriate on your current platform before actually using the pathname. This makes your setup script portable across operating systems, which of course is one of the major goals of the Distutils. In this spirit, all pathnames in this document are slash-separated. This, of course, only applies to pathnames given to Distutils functions. If you, for example, use standard Python functions such as :func:`glob.glob` or :func:`os.listdir` to specify files, you should be careful to write portable code instead of hardcoding path separators:: glob.glob(os.path.join('mydir', 'subdir', '*.html')) os.listdir(os.path.join('mydir', 'subdir')) .. _listing-packages: Listing whole packages ====================== The ``packages`` option tells the Distutils to process (build, distribute, install, etc.) all pure Python modules found in each package mentioned in the ``packages`` list. In order to do this, of course, there has to be a correspondence between package names and directories in the filesystem. The default correspondence is the most obvious one, i.e. package :mod:`distutils` is found in the directory :file:`distutils` relative to the distribution root. Thus, when you say ``packages = ['foo']`` in your setup script, you are promising that the Distutils will find a file :file:`foo/__init__.py` (which might be spelled differently on your system, but you get the idea) relative to the directory where your setup script lives. If you break this promise, the Distutils will issue a warning but still process the broken package anyway. If you use a different convention to lay out your source directory, that's no problem: you just have to supply the ``package_dir`` option to tell the Distutils about your convention. For example, say you keep all Python source under :file:`lib`, so that modules in the "root package" (i.e., not in any package at all) are in :file:`lib`, modules in the ``foo`` package are in :file:`lib/foo`, and so forth. Then you would put :: package_dir = {'': 'lib'} in your setup script. The keys to this dictionary are package names, and an empty package name stands for the root package. The values are directory names relative to your distribution root. In this case, when you say ``packages = ['foo']``, you are promising that the file :file:`lib/foo/__init__.py` exists. Another possible convention is to put the ``foo`` package right in :file:`lib`, the ``foo.bar`` package in :file:`lib/bar`, etc. This would be written in the setup script as :: package_dir = {'foo': 'lib'} A ``package: dir`` entry in the ``package_dir`` dictionary implicitly applies to all packages below *package*, so the ``foo.bar`` case is automatically handled here. In this example, having ``packages = ['foo', 'foo.bar']`` tells the Distutils to look for :file:`lib/__init__.py` and :file:`lib/bar/__init__.py`. (Keep in mind that although ``package_dir`` applies recursively, you must explicitly list all packages in ``packages``: the Distutils will *not* recursively scan your source tree looking for any directory with an :file:`__init__.py` file.) .. _listing-modules: Listing individual modules ========================== For a small module distribution, you might prefer to list all modules rather than listing packages---especially the case of a single module that goes in the "root package" (i.e., no package at all). This simplest case was shown in section :ref:`distutils-simple-example`; here is a slightly more involved example:: py_modules = ['mod1', 'pkg.mod2'] This describes two modules, one of them in the "root" package, the other in the ``pkg`` package. Again, the default package/directory layout implies that these two modules can be found in :file:`mod1.py` and :file:`pkg/mod2.py`, and that :file:`pkg/__init__.py` exists as well. And again, you can override the package/directory correspondence using the ``package_dir`` option. .. _describing-extensions: Describing extension modules ============================ Just as writing Python extension modules is a bit more complicated than writing pure Python modules, describing them to the Distutils is a bit more complicated. Unlike pure modules, it's not enough just to list modules or packages and expect the Distutils to go out and find the right files; you have to specify the extension name, source file(s), and any compile/link requirements (include directories, libraries to link with, etc.). .. XXX read over this section All of this is done through another keyword argument to :func:`~distutils.core.setup`, the ``ext_modules`` option. ``ext_modules`` is just a list of :class:`~distutils.core.Extension` instances, each of which describes a single extension module. Suppose your distribution includes a single extension, called ``foo`` and implemented by :file:`foo.c`. If no additional instructions to the compiler/linker are needed, describing this extension is quite simple:: Extension('foo', ['foo.c']) The :class:`~distutils.extension.Extension` class can be imported from :mod:`distutils.core` along with :func:`~distutils.core.setup`. Thus, the setup script for a module distribution that contains only this one extension and nothing else might be:: from distutils.core import setup, Extension setup(name='foo', version='1.0', ext_modules=[Extension('foo', ['foo.c'])], ) The :class:`~distutils.extension.Extension` class (actually, the underlying extension-building machinery implemented by the :command:`build_ext` command) supports a great deal of flexibility in describing Python extensions, which is explained in the following sections. Extension names and packages ---------------------------- The first argument to the :class:`~distutils.core.Extension` constructor is always the name of the extension, including any package names. For example, :: Extension('foo', ['src/foo1.c', 'src/foo2.c']) describes an extension that lives in the root package, while :: Extension('pkg.foo', ['src/foo1.c', 'src/foo2.c']) describes the same extension in the ``pkg`` package. The source files and resulting object code are identical in both cases; the only difference is where in the filesystem (and therefore where in Python's namespace hierarchy) the resulting extension lives. If you have a number of extensions all in the same package (or all under the same base package), use the ``ext_package`` keyword argument to :func:`~distutils.core.setup`. For example, :: setup(..., ext_package='pkg', ext_modules=[Extension('foo', ['foo.c']), Extension('subpkg.bar', ['bar.c'])], ) will compile :file:`foo.c` to the extension ``pkg.foo``, and :file:`bar.c` to ``pkg.subpkg.bar``. Extension source files ---------------------- The second argument to the :class:`~distutils.core.Extension` constructor is a list of source files. Since the Distutils currently only support C, C++, and Objective-C extensions, these are normally C/C++/Objective-C source files. (Be sure to use appropriate extensions to distinguish C++ source files: :file:`.cc` and :file:`.cpp` seem to be recognized by both Unix and Windows compilers.) However, you can also include SWIG interface (:file:`.i`) files in the list; the :command:`build_ext` command knows how to deal with SWIG extensions: it will run SWIG on the interface file and compile the resulting C/C++ file into your extension. .. XXX SWIG support is rough around the edges and largely untested! This warning notwithstanding, options to SWIG can be currently passed like this:: setup(..., ext_modules=[Extension('_foo', ['foo.i'], swig_opts=['-modern', '-I../include'])], py_modules=['foo'], ) Or on the commandline like this:: > python setup.py build_ext --swig-opts="-modern -I../include" On some platforms, you can include non-source files that are processed by the compiler and included in your extension. Currently, this just means Windows message text (:file:`.mc`) files and resource definition (:file:`.rc`) files for Visual C++. These will be compiled to binary resource (:file:`.res`) files and linked into the executable. Preprocessor options -------------------- Three optional arguments to :class:`~distutils.core.Extension` will help if you need to specify include directories to search or preprocessor macros to define/undefine: ``include_dirs``, ``define_macros``, and ``undef_macros``. For example, if your extension requires header files in the :file:`include` directory under your distribution root, use the ``include_dirs`` option:: Extension('foo', ['foo.c'], include_dirs=['include']) You can specify absolute directories there; if you know that your extension will only be built on Unix systems with X11R6 installed to :file:`/usr`, you can get away with :: Extension('foo', ['foo.c'], include_dirs=['/usr/include/X11']) You should avoid this sort of non-portable usage if you plan to distribute your code: it's probably better to write C code like :: #include If you need to include header files from some other Python extension, you can take advantage of the fact that header files are installed in a consistent way by the Distutils :command:`install_headers` command. For example, the Numerical Python header files are installed (on a standard Unix installation) to :file:`/usr/local/include/python1.5/Numerical`. (The exact location will differ according to your platform and Python installation.) Since the Python include directory---\ :file:`/usr/local/include/python1.5` in this case---is always included in the search path when building Python extensions, the best approach is to write C code like :: #include If you must put the :file:`Numerical` include directory right into your header search path, though, you can find that directory using the Distutils :mod:`distutils.sysconfig` module:: from distutils.sysconfig import get_python_inc incdir = os.path.join(get_python_inc(plat_specific=1), 'Numerical') setup(..., Extension(..., include_dirs=[incdir]), ) Even though this is quite portable---it will work on any Python installation, regardless of platform---it's probably easier to just write your C code in the sensible way. You can define and undefine pre-processor macros with the ``define_macros`` and ``undef_macros`` options. ``define_macros`` takes a list of ``(name, value)`` tuples, where ``name`` is the name of the macro to define (a string) and ``value`` is its value: either a string or ``None``. (Defining a macro ``FOO`` to ``None`` is the equivalent of a bare ``#define FOO`` in your C source: with most compilers, this sets ``FOO`` to the string ``1``.) ``undef_macros`` is just a list of macros to undefine. For example:: Extension(..., define_macros=[('NDEBUG', '1'), ('HAVE_STRFTIME', None)], undef_macros=['HAVE_FOO', 'HAVE_BAR']) is the equivalent of having this at the top of every C source file:: #define NDEBUG 1 #define HAVE_STRFTIME #undef HAVE_FOO #undef HAVE_BAR Library options --------------- You can also specify the libraries to link against when building your extension, and the directories to search for those libraries. The ``libraries`` option is a list of libraries to link against, ``library_dirs`` is a list of directories to search for libraries at link-time, and ``runtime_library_dirs`` is a list of directories to search for shared (dynamically loaded) libraries at run-time. For example, if you need to link against libraries known to be in the standard library search path on target systems :: Extension(..., libraries=['gdbm', 'readline']) If you need to link with libraries in a non-standard location, you'll have to include the location in ``library_dirs``:: Extension(..., library_dirs=['/usr/X11R6/lib'], libraries=['X11', 'Xt']) (Again, this sort of non-portable construct should be avoided if you intend to distribute your code.) .. XXX Should mention clib libraries here or somewhere else! Other options ------------- There are still some other options which can be used to handle special cases. The ``optional`` option is a boolean; if it is true, a build failure in the extension will not abort the build process, but instead simply not install the failing extension. The ``extra_objects`` option is a list of object files to be passed to the linker. These files must not have extensions, as the default extension for the compiler is used. ``extra_compile_args`` and ``extra_link_args`` can be used to specify additional command line options for the respective compiler and linker command lines. ``export_symbols`` is only useful on Windows. It can contain a list of symbols (functions or variables) to be exported. This option is not needed when building compiled extensions: Distutils will automatically add ``initmodule`` to the list of exported symbols. The ``depends`` option is a list of files that the extension depends on (for example header files). The build command will call the compiler on the sources to rebuild extension if any on this files has been modified since the previous build. Relationships between Distributions and Packages ================================================ A distribution may relate to packages in three specific ways: #. It can require packages or modules. #. It can provide packages or modules. #. It can obsolete packages or modules. These relationships can be specified using keyword arguments to the :func:`distutils.core.setup` function. Dependencies on other Python modules and packages can be specified by supplying the *requires* keyword argument to :func:`~distutils.core.setup`. The value must be a list of strings. Each string specifies a package that is required, and optionally what versions are sufficient. To specify that any version of a module or package is required, the string should consist entirely of the module or package name. Examples include ``'mymodule'`` and ``'xml.parsers.expat'``. If specific versions are required, a sequence of qualifiers can be supplied in parentheses. Each qualifier may consist of a comparison operator and a version number. The accepted comparison operators are:: < > == <= >= != These can be combined by using multiple qualifiers separated by commas (and optional whitespace). In this case, all of the qualifiers must be matched; a logical AND is used to combine the evaluations. Let's look at a bunch of examples: +-------------------------+----------------------------------------------+ | Requires Expression | Explanation | +=========================+==============================================+ | ``==1.0`` | Only version ``1.0`` is compatible | +-------------------------+----------------------------------------------+ | ``>1.0, !=1.5.1, <2.0`` | Any version after ``1.0`` and before ``2.0`` | | | is compatible, except ``1.5.1`` | +-------------------------+----------------------------------------------+ Now that we can specify dependencies, we also need to be able to specify what we provide that other distributions can require. This is done using the *provides* keyword argument to :func:`~distutils.core.setup`. The value for this keyword is a list of strings, each of which names a Python module or package, and optionally identifies the version. If the version is not specified, it is assumed to match that of the distribution. Some examples: +---------------------+----------------------------------------------+ | Provides Expression | Explanation | +=====================+==============================================+ | ``mypkg`` | Provide ``mypkg``, using the distribution | | | version | +---------------------+----------------------------------------------+ | ``mypkg (1.1)`` | Provide ``mypkg`` version 1.1, regardless of | | | the distribution version | +---------------------+----------------------------------------------+ A package can declare that it obsoletes other packages using the *obsoletes* keyword argument. The value for this is similar to that of the *requires* keyword: a list of strings giving module or package specifiers. Each specifier consists of a module or package name optionally followed by one or more version qualifiers. Version qualifiers are given in parentheses after the module or package name. The versions identified by the qualifiers are those that are obsoleted by the distribution being described. If no qualifiers are given, all versions of the named module or package are understood to be obsoleted. .. _distutils-installing-scripts: Installing Scripts ================== So far we have been dealing with pure and non-pure Python modules, which are usually not run by themselves but imported by scripts. Scripts are files containing Python source code, intended to be started from the command line. Scripts don't require Distutils to do anything very complicated. The only clever feature is that if the first line of the script starts with ``#!`` and contains the word "python", the Distutils will adjust the first line to refer to the current interpreter location. By default, it is replaced with the current interpreter location. The :option:`!--executable` (or :option:`!-e`) option will allow the interpreter path to be explicitly overridden. The ``scripts`` option simply is a list of files to be handled in this way. From the PyXML setup script:: setup(..., scripts=['scripts/xmlproc_parse', 'scripts/xmlproc_val'] ) .. versionchanged:: 3.1 All the scripts will also be added to the ``MANIFEST`` file if no template is provided. See :ref:`manifest`. .. _distutils-installing-package-data: Installing Package Data ======================= Often, additional files need to be installed into a package. These files are often data that's closely related to the package's implementation, or text files containing documentation that might be of interest to programmers using the package. These files are called :dfn:`package data`. Package data can be added to packages using the ``package_data`` keyword argument to the :func:`~distutils.core.setup` function. The value must be a mapping from package name to a list of relative path names that should be copied into the package. The paths are interpreted as relative to the directory containing the package (information from the ``package_dir`` mapping is used if appropriate); that is, the files are expected to be part of the package in the source directories. They may contain glob patterns as well. The path names may contain directory portions; any necessary directories will be created in the installation. For example, if a package should contain a subdirectory with several data files, the files can be arranged like this in the source tree:: setup.py src/ mypkg/ __init__.py module.py data/ tables.dat spoons.dat forks.dat The corresponding call to :func:`~distutils.core.setup` might be:: setup(..., packages=['mypkg'], package_dir={'mypkg': 'src/mypkg'}, package_data={'mypkg': ['data/*.dat']}, ) .. versionchanged:: 3.1 All the files that match ``package_data`` will be added to the ``MANIFEST`` file if no template is provided. See :ref:`manifest`. .. _distutils-additional-files: Installing Additional Files =========================== The ``data_files`` option can be used to specify additional files needed by the module distribution: configuration files, message catalogs, data files, anything which doesn't fit in the previous categories. ``data_files`` specifies a sequence of (*directory*, *files*) pairs in the following way:: setup(..., data_files=[('bitmaps', ['bm/b1.gif', 'bm/b2.gif']), ('config', ['cfg/data.cfg'])], ) Each (*directory*, *files*) pair in the sequence specifies the installation directory and the files to install there. Each file name in *files* is interpreted relative to the :file:`setup.py` script at the top of the package source distribution. Note that you can specify the directory where the data files will be installed, but you cannot rename the data files themselves. The *directory* should be a relative path. It is interpreted relative to the installation prefix (Python's ``sys.prefix`` for system installations; ``site.USER_BASE`` for user installations). Distutils allows *directory* to be an absolute installation path, but this is discouraged since it is incompatible with the wheel packaging format. No directory information from *files* is used to determine the final location of the installed file; only the name of the file is used. You can specify the ``data_files`` options as a simple sequence of files without specifying a target directory, but this is not recommended, and the :command:`install` command will print a warning in this case. To install data files directly in the target directory, an empty string should be given as the directory. .. versionchanged:: 3.1 All the files that match ``data_files`` will be added to the ``MANIFEST`` file if no template is provided. See :ref:`manifest`. .. _meta-data: Additional meta-data ==================== The setup script may include additional meta-data beyond the name and version. This information includes: +----------------------+---------------------------+-----------------+--------+ | Meta-Data | Description | Value | Notes | +======================+===========================+=================+========+ | ``name`` | name of the package | short string | \(1) | +----------------------+---------------------------+-----------------+--------+ | ``version`` | version of this release | short string | (1)(2) | +----------------------+---------------------------+-----------------+--------+ | ``author`` | package author's name | short string | \(3) | +----------------------+---------------------------+-----------------+--------+ | ``author_email`` | email address of the | email address | \(3) | | | package author | | | +----------------------+---------------------------+-----------------+--------+ | ``maintainer`` | package maintainer's name | short string | \(3) | +----------------------+---------------------------+-----------------+--------+ | ``maintainer_email`` | email address of the | email address | \(3) | | | package maintainer | | | +----------------------+---------------------------+-----------------+--------+ | ``url`` | home page for the package | URL | \(1) | +----------------------+---------------------------+-----------------+--------+ | ``description`` | short, summary | short string | | | | description of the | | | | | package | | | +----------------------+---------------------------+-----------------+--------+ | ``long_description`` | longer description of the | long string | \(4) | | | package | | | +----------------------+---------------------------+-----------------+--------+ | ``download_url`` | location where the | URL | | | | package may be downloaded | | | +----------------------+---------------------------+-----------------+--------+ | ``classifiers`` | a list of classifiers | list of strings | (6)(7) | +----------------------+---------------------------+-----------------+--------+ | ``platforms`` | a list of platforms | list of strings | (6)(8) | +----------------------+---------------------------+-----------------+--------+ | ``keywords`` | a list of keywords | list of strings | (6)(8) | +----------------------+---------------------------+-----------------+--------+ | ``license`` | license for the package | short string | \(5) | +----------------------+---------------------------+-----------------+--------+ Notes: (1) These fields are required. (2) It is recommended that versions take the form *major.minor[.patch[.sub]]*. (3) Either the author or the maintainer must be identified. If maintainer is provided, distutils lists it as the author in :file:`PKG-INFO`. (4) The ``long_description`` field is used by PyPI when you publish a package, to build its project page. (5) The ``license`` field is a text indicating the license covering the package where the license is not a selection from the "License" Trove classifiers. See the ``Classifier`` field. Notice that there's a ``licence`` distribution option which is deprecated but still acts as an alias for ``license``. (6) This field must be a list. (7) The valid classifiers are listed on `PyPI `_. (8) To preserve backward compatibility, this field also accepts a string. If you pass a comma-separated string ``'foo, bar'``, it will be converted to ``['foo', 'bar']``, Otherwise, it will be converted to a list of one string. 'short string' A single line of text, not more than 200 characters. 'long string' Multiple lines of plain text in reStructuredText format (see http://docutils.sourceforge.net/). 'list of strings' See below. Encoding the version information is an art in itself. Python packages generally adhere to the version format *major.minor[.patch][sub]*. The major number is 0 for initial, experimental releases of software. It is incremented for releases that represent major milestones in a package. The minor number is incremented when important new features are added to the package. The patch number increments when bug-fix releases are made. Additional trailing version information is sometimes used to indicate sub-releases. These are "a1,a2,...,aN" (for alpha releases, where functionality and API may change), "b1,b2,...,bN" (for beta releases, which only fix bugs) and "pr1,pr2,...,prN" (for final pre-release release testing). Some examples: 0.1.0 the first, experimental release of a package 1.0.1a2 the second alpha release of the first patch version of 1.0 ``classifiers`` must be specified in a list:: setup(..., classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Environment :: Web Environment', 'Intended Audience :: End Users/Desktop', 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: Python Software Foundation License', 'Operating System :: MacOS :: MacOS X', 'Operating System :: Microsoft :: Windows', 'Operating System :: POSIX', 'Programming Language :: Python', 'Topic :: Communications :: Email', 'Topic :: Office/Business', 'Topic :: Software Development :: Bug Tracking', ], ) .. versionchanged:: 3.7 :class:`~distutils.core.setup` now warns when ``classifiers``, ``keywords`` or ``platforms`` fields are not specified as a list or a string. .. _debug-setup-script: Debugging the setup script ========================== Sometimes things go wrong, and the setup script doesn't do what the developer wants. Distutils catches any exceptions when running the setup script, and print a simple error message before the script is terminated. The motivation for this behaviour is to not confuse administrators who don't know much about Python and are trying to install a package. If they get a big long traceback from deep inside the guts of Distutils, they may think the package or the Python installation is broken because they don't read all the way down to the bottom and see that it's a permission problem. On the other hand, this doesn't help the developer to find the cause of the failure. For this purpose, the :envvar:`DISTUTILS_DEBUG` environment variable can be set to anything except an empty string, and distutils will now print detailed information about what it is doing, dump the full traceback when an exception occurs, and print the whole command line when an external program (like a C compiler) fails. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/sourcedist.rst0000644000175100001710000002301500000000000023367 0ustar00runnerdocker.. _source-dist: ****************************** Creating a Source Distribution ****************************** .. include:: ./_setuptools_disclaimer.rst As shown in section :ref:`distutils-simple-example`, you use the :command:`sdist` command to create a source distribution. In the simplest case, :: python setup.py sdist (assuming you haven't specified any :command:`sdist` options in the setup script or config file), :command:`sdist` creates the archive of the default format for the current platform. The default format is a gzip'ed tar file (:file:`.tar.gz`) on Unix, and ZIP file on Windows. You can specify as many formats as you like using the :option:`!--formats` option, for example:: python setup.py sdist --formats=gztar,zip to create a gzipped tarball and a zip file. The available formats are: +-----------+-------------------------+---------+ | Format | Description | Notes | +===========+=========================+=========+ | ``zip`` | zip file (:file:`.zip`) | (1),(3) | +-----------+-------------------------+---------+ | ``gztar`` | gzip'ed tar file | \(2) | | | (:file:`.tar.gz`) | | +-----------+-------------------------+---------+ | ``bztar`` | bzip2'ed tar file | | | | (:file:`.tar.bz2`) | | +-----------+-------------------------+---------+ | ``xztar`` | xz'ed tar file | | | | (:file:`.tar.xz`) | | +-----------+-------------------------+---------+ | ``ztar`` | compressed tar file | \(4) | | | (:file:`.tar.Z`) | | +-----------+-------------------------+---------+ | ``tar`` | tar file (:file:`.tar`) | | +-----------+-------------------------+---------+ .. versionchanged:: 3.5 Added support for the ``xztar`` format. Notes: (1) default on Windows (2) default on Unix (3) requires either external :program:`zip` utility or :mod:`zipfile` module (part of the standard Python library since Python 1.6) (4) requires the :program:`compress` program. Notice that this format is now pending for deprecation and will be removed in the future versions of Python. When using any ``tar`` format (``gztar``, ``bztar``, ``xztar``, ``ztar`` or ``tar``), under Unix you can specify the ``owner`` and ``group`` names that will be set for each member of the archive. For example, if you want all files of the archive to be owned by root:: python setup.py sdist --owner=root --group=root .. _manifest: Specifying the files to distribute ================================== If you don't supply an explicit list of files (or instructions on how to generate one), the :command:`sdist` command puts a minimal default set into the source distribution: * all Python source files implied by the ``py_modules`` and ``packages`` options * all C source files mentioned in the ``ext_modules`` or ``libraries`` options .. XXX getting C library sources currently broken---no :meth:`get_source_files` method in :file:`build_clib.py`! * scripts identified by the ``scripts`` option See :ref:`distutils-installing-scripts`. * anything that looks like a test script: :file:`test/test\*.py` (currently, the Distutils don't do anything with test scripts except include them in source distributions, but in the future there will be a standard for testing Python module distributions) * Any of the standard README files (:file:`README`, :file:`README.txt`, or :file:`README.rst`), :file:`setup.py` (or whatever you called your setup script), and :file:`setup.cfg`. * all files that matches the ``package_data`` metadata. See :ref:`distutils-installing-package-data`. * all files that matches the ``data_files`` metadata. See :ref:`distutils-additional-files`. Sometimes this is enough, but usually you will want to specify additional files to distribute. The typical way to do this is to write a *manifest template*, called :file:`MANIFEST.in` by default. The manifest template is just a list of instructions for how to generate your manifest file, :file:`MANIFEST`, which is the exact list of files to include in your source distribution. The :command:`sdist` command processes this template and generates a manifest based on its instructions and what it finds in the filesystem. If you prefer to roll your own manifest file, the format is simple: one filename per line, regular files (or symlinks to them) only. If you do supply your own :file:`MANIFEST`, you must specify everything: the default set of files described above does not apply in this case. .. versionchanged:: 3.1 An existing generated :file:`MANIFEST` will be regenerated without :command:`sdist` comparing its modification time to the one of :file:`MANIFEST.in` or :file:`setup.py`. .. versionchanged:: 3.1.3 :file:`MANIFEST` files start with a comment indicating they are generated. Files without this comment are not overwritten or removed. .. versionchanged:: 3.2.2 :command:`sdist` will read a :file:`MANIFEST` file if no :file:`MANIFEST.in` exists, like it used to do. .. versionchanged:: 3.7 :file:`README.rst` is now included in the list of distutils standard READMEs. The manifest template has one command per line, where each command specifies a set of files to include or exclude from the source distribution. For an example, again we turn to the Distutils' own manifest template: .. code-block:: none include *.txt recursive-include examples *.txt *.py prune examples/sample?/build The meanings should be fairly clear: include all files in the distribution root matching :file:`\*.txt`, all files anywhere under the :file:`examples` directory matching :file:`\*.txt` or :file:`\*.py`, and exclude all directories matching :file:`examples/sample?/build`. All of this is done *after* the standard include set, so you can exclude files from the standard set with explicit instructions in the manifest template. (Or, you can use the :option:`!--no-defaults` option to disable the standard set entirely.) There are several other commands available in the manifest template mini-language; see section :ref:`sdist-cmd`. The order of commands in the manifest template matters: initially, we have the list of default files as described above, and each command in the template adds to or removes from that list of files. Once we have fully processed the manifest template, we remove files that should not be included in the source distribution: * all files in the Distutils "build" tree (default :file:`build/`) * all files in directories named :file:`RCS`, :file:`CVS`, :file:`.svn`, :file:`.hg`, :file:`.git`, :file:`.bzr` or :file:`_darcs` Now we have our complete list of files, which is written to the manifest for future reference, and then used to build the source distribution archive(s). You can disable the default set of included files with the :option:`!--no-defaults` option, and you can disable the standard exclude set with :option:`!--no-prune`. Following the Distutils' own manifest template, let's trace how the :command:`sdist` command builds the list of files to include in the Distutils source distribution: #. include all Python source files in the :file:`distutils` and :file:`distutils/command` subdirectories (because packages corresponding to those two directories were mentioned in the ``packages`` option in the setup script---see section :ref:`setup-script`) #. include :file:`README.txt`, :file:`setup.py`, and :file:`setup.cfg` (standard files) #. include :file:`test/test\*.py` (standard files) #. include :file:`\*.txt` in the distribution root (this will find :file:`README.txt` a second time, but such redundancies are weeded out later) #. include anything matching :file:`\*.txt` or :file:`\*.py` in the sub-tree under :file:`examples`, #. exclude all files in the sub-trees starting at directories matching :file:`examples/sample?/build`\ ---this may exclude files included by the previous two steps, so it's important that the ``prune`` command in the manifest template comes after the ``recursive-include`` command #. exclude the entire :file:`build` tree, and any :file:`RCS`, :file:`CVS`, :file:`.svn`, :file:`.hg`, :file:`.git`, :file:`.bzr` and :file:`_darcs` directories Just like in the setup script, file and directory names in the manifest template should always be slash-separated; the Distutils will take care of converting them to the standard representation on your platform. That way, the manifest template is portable across operating systems. .. _manifest-options: Manifest-related options ======================== The normal course of operations for the :command:`sdist` command is as follows: * if the manifest file (:file:`MANIFEST` by default) exists and the first line does not have a comment indicating it is generated from :file:`MANIFEST.in`, then it is used as is, unaltered * if the manifest file doesn't exist or has been previously automatically generated, read :file:`MANIFEST.in` and create the manifest * if neither :file:`MANIFEST` nor :file:`MANIFEST.in` exist, create a manifest with just the default file set * use the list of files now in :file:`MANIFEST` (either just generated or read in) to create the source distribution archive(s) There are a couple of options that modify this behaviour. First, use the :option:`!--no-defaults` and :option:`!--no-prune` to disable the standard "include" and "exclude" sets. Second, you might just want to (re)generate the manifest, but not create a source distribution:: python setup.py sdist --manifest-only :option:`!-o` is a shortcut for :option:`!--manifest-only`. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils/uploading.rst0000644000175100001710000000034200000000000023163 0ustar00runnerdocker:orphan: *************************************** Uploading Packages to the Package Index *************************************** References to up to date PyPI documentation can be found at :ref:`publishing-python-packages`. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/distutils-legacy.rst0000644000175100001710000000336400000000000022452 0ustar00runnerdockerPorting from Distutils ====================== Setuptools and the PyPA have a `stated goal `_ to make Setuptools the reference API for distutils. Since the 49.1.2 release, Setuptools includes a local, vendored copy of distutils (from late copies of CPython) that is disabled by default. To enable the use of this copy of distutils when invoking setuptools, set the enviroment variable: SETUPTOOLS_USE_DISTUTILS=local This behavior is planned to become the default. Prefer Setuptools ----------------- As Distutils is deprecated, any usage of functions or objects from distutils is similarly discouraged, and Setuptools aims to replace or deprecate all such uses. This section describes the recommended replacements. ``distutils.core.setup`` → ``setuptools.setup`` ``distutils.cmd.Command`` → ``setuptools.Command`` ``distutils.command.{build_clib,build_ext,build_py,sdist}`` → ``setuptools.command.*`` ``distutils.log`` → (no replacement yet) ``distutils.version.*`` → ``packaging.version.*`` ``distutils.errors.*`` → ``setuptools.errors.*`` [#errors]_ If a project relies on uses of ``distutils`` that do not have a suitable replacement above, please search the `Setuptools issue tracker `_ and file a request, describing the use-case so that Setuptools' maintainers can investigate. Please provide enough detail to help the maintainers understand how distutils is used, what value it provides, and why that behavior should be supported. .. [#errors] Please notice errors related to the command line usage of ``setup.py``, such as ``DistutilsArgError``, are intentionally not exposed by setuptools, since this is considered a deprecated practice. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/easy_install.rst0000644000175100001710000014565200000000000021662 0ustar00runnerdocker============ Easy Install ============ .. warning:: Easy Install is deprecated. Do not use it. Instead use pip. If you think you need Easy Install, please reach out to the PyPA team (a ticket to pip or setuptools is fine), describing your use-case. Easy Install is a python module (``easy_install``) bundled with ``setuptools`` that lets you automatically download, build, install, and manage Python packages. Please share your experiences with us! If you encounter difficulty installing a package, please contact us via the `distutils mailing list `_. (Note: please DO NOT send private email directly to the author of setuptools; it will be discarded. The mailing list is a searchable archive of previously-asked and answered questions; you should begin your research there before reporting something as a bug -- and then do so via list discussion first.) (Also, if you'd like to learn about how you can use ``setuptools`` to make your own packages work better with EasyInstall, or provide EasyInstall-like features without requiring your users to use EasyInstall directly, you'll probably want to check out the full documentation as well.) Using "Easy Install" ==================== .. _installation instructions: Installing "Easy Install" ------------------------- Please see the `setuptools PyPI page `_ for download links and basic installation instructions for each of the supported platforms. You will need at least Python 3.5 or 2.7. An ``easy_install`` script will be installed in the normal location for Python scripts on your platform. Note that the instructions on the setuptools PyPI page assume that you are are installing to Python's primary ``site-packages`` directory. If this is not the case, you should consult the section below on `Custom Installation Locations`_ before installing. (And, on Windows, you should not use the ``.exe`` installer when installing to an alternate location.) Note that ``easy_install`` normally works by downloading files from the internet. If you are behind an NTLM-based firewall that prevents Python programs from accessing the net directly, you may wish to first install and use the `APS proxy server `_, which lets you get past such firewalls in the same way that your web browser(s) do. (Alternately, if you do not wish easy_install to actually download anything, you can restrict it from doing so with the ``--allow-hosts`` option; see the sections on `restricting downloads with --allow-hosts`_ and `command-line options`_ for more details.) Troubleshooting ~~~~~~~~~~~~~~~ If EasyInstall/setuptools appears to install correctly, and you can run the ``easy_install`` command but it fails with an ``ImportError``, the most likely cause is that you installed to a location other than ``site-packages``, without taking any of the steps described in the `Custom Installation Locations`_ section below. Please see that section and follow the steps to make sure that your custom location will work correctly. Then re-install. Similarly, if you can run ``easy_install``, and it appears to be installing packages, but then you can't import them, the most likely issue is that you installed EasyInstall correctly but are using it to install packages to a non-standard location that hasn't been properly prepared. Again, see the section on `Custom Installation Locations`_ for more details. Windows Notes ~~~~~~~~~~~~~ Installing setuptools will provide an ``easy_install`` command according to the techniques described in `Executables and Launchers`_. If the ``easy_install`` command is not available after installation, that section provides details on how to configure Windows to make the commands available. Downloading and Installing a Package ------------------------------------ For basic use of ``easy_install``, you need only supply the filename or URL of a source distribution or .egg file (`Python Egg`__). __ http://peak.telecommunity.com/DevCenter/PythonEggs **Example 1**. Install a package by name, searching PyPI for the latest version, and automatically downloading, building, and installing it:: easy_install SQLObject **Example 2**. Install or upgrade a package by name and version by finding links on a given "download page":: easy_install -f http://pythonpaste.org/package_index.html SQLObject **Example 3**. Download a source distribution from a specified URL, automatically building and installing it:: easy_install http://example.com/path/to/MyPackage-1.2.3.tgz **Example 4**. Install an already-downloaded .egg file:: easy_install /my_downloads/OtherPackage-3.2.1-py2.3.egg **Example 5**. Upgrade an already-installed package to the latest version listed on PyPI:: easy_install --upgrade PyProtocols **Example 6**. Install a source distribution that's already downloaded and extracted in the current directory (New in 0.5a9):: easy_install . **Example 7**. (New in 0.6a1) Find a source distribution or Subversion checkout URL for a package, and extract it or check it out to ``~/projects/sqlobject`` (the name will always be in all-lowercase), where it can be examined or edited. (The package will not be installed, but it can easily be installed with ``easy_install ~/projects/sqlobject``. See `Editing and Viewing Source Packages`_ below for more info.):: easy_install --editable --build-directory ~/projects SQLObject **Example 7**. (New in 0.6.11) Install a distribution within your home dir:: easy_install --user SQLAlchemy Easy Install accepts URLs, filenames, PyPI package names (i.e., ``distutils`` "distribution" names), and package+version specifiers. In each case, it will attempt to locate the latest available version that meets your criteria. When downloading or processing downloaded files, Easy Install recognizes distutils source distribution files with extensions of .tgz, .tar, .tar.gz, .tar.bz2, or .zip. And of course it handles already-built .egg distributions as well as ``.win32.exe`` installers built using distutils. By default, packages are installed to the running Python installation's ``site-packages`` directory, unless you provide the ``-d`` or ``--install-dir`` option to specify an alternative directory, or specify an alternate location using distutils configuration files. (See `Configuration Files`_, below.) By default, any scripts included with the package are installed to the running Python installation's standard script installation location. However, if you specify an installation directory via the command line or a config file, then the default directory for installing scripts will be the same as the package installation directory, to ensure that the script will have access to the installed package. You can override this using the ``-s`` or ``--script-dir`` option. Installed packages are added to an ``easy-install.pth`` file in the install directory, so that Python will always use the most-recently-installed version of the package. If you would like to be able to select which version to use at runtime, you should use the ``-m`` or ``--multi-version`` option. Upgrading a Package ------------------- You don't need to do anything special to upgrade a package: just install the new version, either by requesting a specific version, e.g.:: easy_install "SomePackage==2.0" a version greater than the one you have now:: easy_install "SomePackage>2.0" using the upgrade flag, to find the latest available version on PyPI:: easy_install --upgrade SomePackage or by using a download page, direct download URL, or package filename:: easy_install -f http://example.com/downloads ExamplePackage easy_install http://example.com/downloads/ExamplePackage-2.0-py2.4.egg easy_install my_downloads/ExamplePackage-2.0.tgz If you're using ``-m`` or ``--multi-version`` , using the ``require()`` function at runtime automatically selects the newest installed version of a package that meets your version criteria. So, installing a newer version is the only step needed to upgrade such packages. If you're installing to a directory on PYTHONPATH, or a configured "site" directory (and not using ``-m``), installing a package automatically replaces any previous version in the ``easy-install.pth`` file, so that Python will import the most-recently installed version by default. So, again, installing the newer version is the only upgrade step needed. If you haven't suppressed script installation (using ``--exclude-scripts`` or ``-x``), then the upgraded version's scripts will be installed, and they will be automatically patched to ``require()`` the corresponding version of the package, so that you can use them even if they are installed in multi-version mode. ``easy_install`` never actually deletes packages (unless you're installing a package with the same name and version number as an existing package), so if you want to get rid of older versions of a package, please see `Uninstalling Packages`_, below. Changing the Active Version --------------------------- If you've upgraded a package, but need to revert to a previously-installed version, you can do so like this:: easy_install PackageName==1.2.3 Where ``1.2.3`` is replaced by the exact version number you wish to switch to. If a package matching the requested name and version is not already installed in a directory on ``sys.path``, it will be located via PyPI and installed. If you'd like to switch to the latest installed version of ``PackageName``, you can do so like this:: easy_install PackageName This will activate the latest installed version. (Note: if you have set any ``find_links`` via distutils configuration files, those download pages will be checked for the latest available version of the package, and it will be downloaded and installed if it is newer than your current version.) Note that changing the active version of a package will install the newly active version's scripts, unless the ``--exclude-scripts`` or ``-x`` option is specified. Uninstalling Packages --------------------- If you have replaced a package with another version, then you can just delete the package(s) you don't need by deleting the PackageName-versioninfo.egg file or directory (found in the installation directory). If you want to delete the currently installed version of a package (or all versions of a package), you should first run:: easy_install -m PackageName This will ensure that Python doesn't continue to search for a package you're planning to remove. After you've done this, you can safely delete the .egg files or directories, along with any scripts you wish to remove. Managing Scripts ---------------- Whenever you install, upgrade, or change versions of a package, EasyInstall automatically installs the scripts for the selected package version, unless you tell it not to with ``-x`` or ``--exclude-scripts``. If any scripts in the script directory have the same name, they are overwritten. Thus, you do not normally need to manually delete scripts for older versions of a package, unless the newer version of the package does not include a script of the same name. However, if you are completely uninstalling a package, you may wish to manually delete its scripts. EasyInstall's default behavior means that you can normally only run scripts from one version of a package at a time. If you want to keep multiple versions of a script available, however, you can simply use the ``--multi-version`` or ``-m`` option, and rename the scripts that EasyInstall creates. This works because EasyInstall installs scripts as short code stubs that ``require()`` the matching version of the package the script came from, so renaming the script has no effect on what it executes. For example, suppose you want to use two versions of the ``rst2html`` tool provided by the `docutils `_ package. You might first install one version:: easy_install -m docutils==0.3.9 then rename the ``rst2html.py`` to ``r2h_039``, and install another version:: easy_install -m docutils==0.3.10 This will create another ``rst2html.py`` script, this one using docutils version 0.3.10 instead of 0.3.9. You now have two scripts, each using a different version of the package. (Notice that we used ``-m`` for both installations, so that Python won't lock us out of using anything but the most recently-installed version of the package.) Executables and Launchers ------------------------- On Unix systems, scripts are installed with as natural files with a "#!" header and no extension and they launch under the Python version indicated in the header. On Windows, there is no mechanism to "execute" files without extensions, so EasyInstall provides two techniques to mirror the Unix behavior. The behavior is indicated by the SETUPTOOLS_LAUNCHER environment variable, which may be "executable" (default) or "natural". Regardless of the technique used, the script(s) will be installed to a Scripts directory (by default in the Python installation directory). It is recommended for EasyInstall that you ensure this directory is in the PATH environment variable. The easiest way to ensure the Scripts directory is in the PATH is to run ``Tools\Scripts\win_add2path.py`` from the Python directory. Note that instead of changing your ``PATH`` to include the Python scripts directory, you can also retarget the installation location for scripts so they go on a directory that's already on the ``PATH``. For more information see `Command-Line Options`_ and `Configuration Files`_. During installation, pass command line options (such as ``--script-dir``) to control where scripts will be installed. Windows Executable Launcher ~~~~~~~~~~~~~~~~~~~~~~~~~~~ If the "executable" launcher is used, EasyInstall will create a '.exe' launcher of the same name beside each installed script (including ``easy_install`` itself). These small .exe files launch the script of the same name using the Python version indicated in the '#!' header. This behavior is currently default. To force the use of executable launchers, set ``SETUPTOOLS_LAUNCHER`` to "executable". Natural Script Launcher ~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall also supports deferring to an external launcher such as `pylauncher `_ for launching scripts. Enable this experimental functionality by setting the ``SETUPTOOLS_LAUNCHER`` environment variable to "natural". EasyInstall will then install scripts as simple scripts with a .pya (or .pyw) extension appended. If these extensions are associated with the pylauncher and listed in the PATHEXT environment variable, these scripts can then be invoked simply and directly just like any other executable. This behavior may become default in a future version. EasyInstall uses the .pya extension instead of simply the typical '.py' extension. This distinct extension is necessary to prevent Python from treating the scripts as importable modules (where name conflicts exist). Current releases of pylauncher do not yet associate with .pya files by default, but future versions should do so. Tips & Techniques ----------------- Multiple Python Versions ~~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall installs itself under two names: ``easy_install`` and ``easy_install-N.N``, where ``N.N`` is the Python version used to install it. Thus, if you install EasyInstall for both Python 3.2 and 2.7, you can use the ``easy_install-3.2`` or ``easy_install-2.7`` scripts to install packages for the respective Python version. Setuptools also supplies easy_install as a runnable module which may be invoked using ``python -m easy_install`` for any Python with Setuptools installed. Restricting Downloads with ``--allow-hosts`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can use the ``--allow-hosts`` (``-H``) option to restrict what domains EasyInstall will look for links and downloads on. ``--allow-hosts=None`` prevents downloading altogether. You can also use wildcards, for example to restrict downloading to hosts in your own intranet. See the section below on `Command-Line Options`_ for more details on the ``--allow-hosts`` option. By default, there are no host restrictions in effect, but you can change this default by editing the appropriate `configuration files`_ and adding: .. code-block:: ini [easy_install] allow_hosts = *.myintranet.example.com,*.python.org The above example would then allow downloads only from hosts in the ``python.org`` and ``myintranet.example.com`` domains, unless overridden on the command line. Installing on Un-networked Machines ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Just copy the eggs or source packages you need to a directory on the target machine, then use the ``-f`` or ``--find-links`` option to specify that directory's location. For example:: easy_install -H None -f somedir SomePackage will attempt to install SomePackage using only eggs and source packages found in ``somedir`` and disallowing all remote access. You should of course make sure you have all of SomePackage's dependencies available in somedir. If you have another machine of the same operating system and library versions (or if the packages aren't platform-specific), you can create the directory of eggs using a command like this:: easy_install -zmaxd somedir SomePackage This will tell EasyInstall to put zipped eggs or source packages for SomePackage and all its dependencies into ``somedir``, without creating any scripts or .pth files. You can then copy the contents of ``somedir`` to the target machine. (``-z`` means zipped eggs, ``-m`` means multi-version, which prevents .pth files from being used, ``-a`` means to copy all the eggs needed, even if they're installed elsewhere on the machine, and ``-d`` indicates the directory to place the eggs in.) You can also build the eggs from local development packages that were installed with the ``setup.py develop`` command, by including the ``-l`` option, e.g.:: easy_install -zmaxld somedir SomePackage This will use locally-available source distributions to build the eggs. Packaging Others' Projects As Eggs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Need to distribute a package that isn't published in egg form? You can use EasyInstall to build eggs for a project. You'll want to use the ``--zip-ok``, ``--exclude-scripts``, and possibly ``--no-deps`` options (``-z``, ``-x`` and ``-N``, respectively). Use ``-d`` or ``--install-dir`` to specify the location where you'd like the eggs placed. By placing them in a directory that is published to the web, you can then make the eggs available for download, either in an intranet or to the internet at large. If someone distributes a package in the form of a single ``.py`` file, you can wrap it in an egg by tacking an ``#egg=name-version`` suffix on the file's URL. So, something like this:: easy_install -f "http://some.example.com/downloads/foo.py#egg=foo-1.0" foo will install the package as an egg, and this:: easy_install -zmaxd. \ -f "http://some.example.com/downloads/foo.py#egg=foo-1.0" foo will create a ``.egg`` file in the current directory. Creating your own Package Index ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In addition to local directories and the Python Package Index, EasyInstall can find download links on most any web page whose URL is given to the ``-f`` (``--find-links``) option. In the simplest case, you can simply have a web page with links to eggs or Python source packages, even an automatically generated directory listing (such as the Apache web server provides). If you are setting up an intranet site for package downloads, you may want to configure the target machines to use your download site by default, adding something like this to their `configuration files`_: .. code-block:: ini [easy_install] find_links = http://mypackages.example.com/somedir/ http://turbogears.org/download/ http://peak.telecommunity.com/dist/ As you can see, you can list multiple URLs separated by whitespace, continuing on multiple lines if necessary (as long as the subsequent lines are indented. If you are more ambitious, you can also create an entirely custom package index or PyPI mirror. See the ``--index-url`` option under `Command-Line Options`_, below, and also the section on `Package Index "API"`_. Password-Protected Sites ------------------------ If a site you want to download from is password-protected using HTTP "Basic" authentication, you can specify your credentials in the URL, like so:: http://some_userid:some_password@some.example.com/some_path/ You can do this with both index page URLs and direct download URLs. As long as any HTML pages read by easy_install use *relative* links to point to the downloads, the same user ID and password will be used to do the downloading. Using .pypirc Credentials ------------------------- In additional to supplying credentials in the URL, ``easy_install`` will also honor credentials if present in the .pypirc file. Teams maintaining a private repository of packages may already have defined access credentials for uploading packages according to the distutils documentation. ``easy_install`` will attempt to honor those if present. Refer to the distutils documentation for Python 2.5 or later for details on the syntax. Controlling Build Options ~~~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall respects standard distutils `Configuration Files`_, so you can use them to configure build options for packages that it installs from source. For example, if you are on Windows using the MinGW compiler, you can configure the default compiler by putting something like this: .. code-block:: ini [build] compiler = mingw32 into the appropriate distutils configuration file. In fact, since this is just normal distutils configuration, it will affect any builds using that config file, not just ones done by EasyInstall. For example, if you add those lines to ``distutils.cfg`` in the ``distutils`` package directory, it will be the default compiler for *all* packages you build. See `Configuration Files`_ below for a list of the standard configuration file locations, and links to more documentation on using distutils configuration files. Editing and Viewing Source Packages ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Sometimes a package's source distribution contains additional documentation, examples, configuration files, etc., that are not part of its actual code. If you want to be able to examine these files, you can use the ``--editable`` option to EasyInstall, and EasyInstall will look for a source distribution or Subversion URL for the package, then download and extract it or check it out as a subdirectory of the ``--build-directory`` you specify. If you then wish to install the package after editing or configuring it, you can do so by rerunning EasyInstall with that directory as the target. Note that using ``--editable`` stops EasyInstall from actually building or installing the package; it just finds, obtains, and possibly unpacks it for you. This allows you to make changes to the package if necessary, and to either install it in development mode using ``setup.py develop`` (if the package uses setuptools, that is), or by running ``easy_install projectdir`` (where ``projectdir`` is the subdirectory EasyInstall created for the downloaded package. In order to use ``--editable`` (``-e`` for short), you *must* also supply a ``--build-directory`` (``-b`` for short). The project will be placed in a subdirectory of the build directory. The subdirectory will have the same name as the project itself, but in all-lowercase. If a file or directory of that name already exists, EasyInstall will print an error message and exit. Also, when using ``--editable``, you cannot use URLs or filenames as arguments. You *must* specify project names (and optional version requirements) so that EasyInstall knows what directory name(s) to create. If you need to force EasyInstall to use a particular URL or filename, you should specify it as a ``--find-links`` item (``-f`` for short), and then also specify the project name, e.g.:: easy_install -eb ~/projects \ -fhttp://prdownloads.sourceforge.net/ctypes/ctypes-0.9.6.tar.gz?download \ ctypes==0.9.6 Dealing with Installation Conflicts ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ (NOTE: As of 0.6a11, this section is obsolete; it is retained here only so that people using older versions of EasyInstall can consult it. As of version 0.6a11, installation conflicts are handled automatically without deleting the old or system-installed packages, and without ignoring the issue. Instead, eggs are automatically shifted to the front of ``sys.path`` using special code added to the ``easy-install.pth`` file. So, if you are using version 0.6a11 or better of setuptools, you do not need to worry about conflicts, and the following issues do not apply to you.) EasyInstall installs distributions in a "managed" way, such that each distribution can be independently activated or deactivated on ``sys.path``. However, packages that were not installed by EasyInstall are "unmanaged", in that they usually live all in one directory and cannot be independently activated or deactivated. As a result, if you are using EasyInstall to upgrade an existing package, or to install a package with the same name as an existing package, EasyInstall will warn you of the conflict. (This is an improvement over ``setup.py install``, because the ``distutils`` just install new packages on top of old ones, possibly combining two unrelated packages or leaving behind modules that have been deleted in the newer version of the package.) EasyInstall will stop the installation if it detects a conflict between an existing, "unmanaged" package, and a module or package in any of the distributions you're installing. It will display a list of all of the existing files and directories that would need to be deleted for the new package to be able to function correctly. To proceed, you must manually delete these conflicting files and directories and re-run EasyInstall. Of course, once you've replaced all of your existing "unmanaged" packages with versions managed by EasyInstall, you won't have any more conflicts to worry about! Compressed Installation ~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall tries to install packages in zipped form, if it can. Zipping packages can improve Python's overall import performance if you're not using the ``--multi-version`` option, because Python processes zipfile entries on ``sys.path`` much faster than it does directories. As of version 0.5a9, EasyInstall analyzes packages to determine whether they can be safely installed as a zipfile, and then acts on its analysis. (Previous versions would not install a package as a zipfile unless you used the ``--zip-ok`` option.) The current analysis approach is fairly conservative; it currently looks for: * Any use of the ``__file__`` or ``__path__`` variables (which should be replaced with ``pkg_resources`` API calls) * Possible use of ``inspect`` functions that expect to manipulate source files (e.g. ``inspect.getsource()``) * Top-level modules that might be scripts used with ``python -m`` (Python 2.4) If any of the above are found in the package being installed, EasyInstall will assume that the package cannot be safely run from a zipfile, and unzip it to a directory instead. You can override this analysis with the ``-zip-ok`` flag, which will tell EasyInstall to install the package as a zipfile anyway. Or, you can use the ``--always-unzip`` flag, in which case EasyInstall will always unzip, even if its analysis says the package is safe to run as a zipfile. Normally, however, it is simplest to let EasyInstall handle the determination of whether to zip or unzip, and only specify overrides when needed to work around a problem. If you find you need to override EasyInstall's guesses, you may want to contact the package author and the EasyInstall maintainers, so that they can make appropriate changes in future versions. (Note: If a package uses ``setuptools`` in its setup script, the package author has the option to declare the package safe or unsafe for zipped usage via the ``zip_safe`` argument to ``setup()``. If the package author makes such a declaration, EasyInstall believes the package's author and does not perform its own analysis. However, your command-line option, if any, will still override the package author's choice.) Reference Manual ================ Configuration Files ------------------- (New in 0.4a2) You may specify default options for EasyInstall using the standard distutils configuration files, under the command heading ``easy_install``. EasyInstall will look first for a ``setup.cfg`` file in the current directory, then a ``~/.pydistutils.cfg`` or ``$HOME\\pydistutils.cfg`` (on Unix-like OSes and Windows, respectively), and finally a ``distutils.cfg`` file in the ``distutils`` package directory. Here's a simple example: .. code-block:: ini [easy_install] # set the default location to install packages install_dir = /home/me/lib/python # Notice that indentation can be used to continue an option # value; this is especially useful for the "--find-links" # option, which tells easy_install to use download links on # these pages before consulting PyPI: # find_links = http://sqlobject.org/ http://peak.telecommunity.com/dist/ In addition to accepting configuration for its own options under ``[easy_install]``, EasyInstall also respects defaults specified for other distutils commands. For example, if you don't set an ``install_dir`` for ``[easy_install]``, but *have* set an ``install_lib`` for the ``[install]`` command, this will become EasyInstall's default installation directory. Thus, if you are already using distutils configuration files to set default install locations, build options, etc., EasyInstall will respect your existing settings until and unless you override them explicitly in an ``[easy_install]`` section. For more information, see also the current Python documentation on the `use and location of distutils configuration files `_. Notice that ``easy_install`` will use the ``setup.cfg`` from the current working directory only if it was triggered from ``setup.py`` through the ``install_requires`` option. The standalone command will not use that file. Command-Line Options -------------------- ``--zip-ok, -z`` Install all packages as zip files, even if they are marked as unsafe for running as a zipfile. This can be useful when EasyInstall's analysis of a non-setuptools package is too conservative, but keep in mind that the package may not work correctly. (Changed in 0.5a9; previously this option was required in order for zipped installation to happen at all.) ``--always-unzip, -Z`` Don't install any packages as zip files, even if the packages are marked as safe for running as a zipfile. This can be useful if a package does something unsafe, but not in a way that EasyInstall can easily detect. EasyInstall's default analysis is currently very conservative, however, so you should only use this option if you've had problems with a particular package, and *after* reporting the problem to the package's maintainer and to the EasyInstall maintainers. (Note: the ``-z/-Z`` options only affect the installation of newly-built or downloaded packages that are not already installed in the target directory; if you want to convert an existing installed version from zipped to unzipped or vice versa, you'll need to delete the existing version first, and re-run EasyInstall.) ``--multi-version, -m`` "Multi-version" mode. Specifying this option prevents ``easy_install`` from adding an ``easy-install.pth`` entry for the package being installed, and if an entry for any version the package already exists, it will be removed upon successful installation. In multi-version mode, no specific version of the package is available for importing, unless you use ``pkg_resources.require()`` to put it on ``sys.path``. This can be as simple as:: from pkg_resources import require require("SomePackage", "OtherPackage", "MyPackage") which will put the latest installed version of the specified packages on ``sys.path`` for you. (For more advanced uses, like selecting specific versions and enabling optional dependencies, see the ``pkg_resources`` API doc.) Changed in 0.6a10: this option is no longer silently enabled when installing to a non-PYTHONPATH, non-"site" directory. You must always explicitly use this option if you want it to be active. ``--upgrade, -U`` (New in 0.5a4) By default, EasyInstall only searches online if a project/version requirement can't be met by distributions already installed on sys.path or the installation directory. However, if you supply the ``--upgrade`` or ``-U`` flag, EasyInstall will always check the package index and ``--find-links`` URLs before selecting a version to install. In this way, you can force EasyInstall to use the latest available version of any package it installs (subject to any version requirements that might exclude such later versions). ``--install-dir=DIR, -d DIR`` Set the installation directory. It is up to you to ensure that this directory is on ``sys.path`` at runtime, and to use ``pkg_resources.require()`` to enable the installed package(s) that you need. (New in 0.4a2) If this option is not directly specified on the command line or in a distutils configuration file, the distutils default installation location is used. Normally, this would be the ``site-packages`` directory, but if you are using distutils configuration files, setting things like ``prefix`` or ``install_lib``, then those settings are taken into account when computing the default installation directory, as is the ``--prefix`` option. ``--script-dir=DIR, -s DIR`` Set the script installation directory. If you don't supply this option (via the command line or a configuration file), but you *have* supplied an ``--install-dir`` (via command line or config file), then this option defaults to the same directory, so that the scripts will be able to find their associated package installation. Otherwise, this setting defaults to the location where the distutils would normally install scripts, taking any distutils configuration file settings into account. ``--exclude-scripts, -x`` Don't install scripts. This is useful if you need to install multiple versions of a package, but do not want to reset the version that will be run by scripts that are already installed. ``--user`` (New in 0.6.11) Use the user-site-packages as specified in :pep:`370` instead of the global site-packages. ``--always-copy, -a`` (New in 0.5a4) Copy all needed distributions to the installation directory, even if they are already present in a directory on sys.path. In older versions of EasyInstall, this was the default behavior, but now you must explicitly request it. By default, EasyInstall will no longer copy such distributions from other sys.path directories to the installation directory, unless you explicitly gave the distribution's filename on the command line. Note that as of 0.6a10, using this option excludes "system" and "development" eggs from consideration because they can't be reliably copied. This may cause EasyInstall to choose an older version of a package than what you expected, or it may cause downloading and installation of a fresh copy of something that's already installed. You will see warning messages for any eggs that EasyInstall skips, before it falls back to an older version or attempts to download a fresh copy. ``--find-links=URLS_OR_FILENAMES, -f URLS_OR_FILENAMES`` Scan the specified "download pages" or directories for direct links to eggs or other distributions. Any existing file or directory names or direct download URLs are immediately added to EasyInstall's search cache, and any indirect URLs (ones that don't point to eggs or other recognized archive formats) are added to a list of additional places to search for download links. As soon as EasyInstall has to go online to find a package (either because it doesn't exist locally, or because ``--upgrade`` or ``-U`` was used), the specified URLs will be downloaded and scanned for additional direct links. Eggs and archives found by way of ``--find-links`` are only downloaded if they are needed to meet a requirement specified on the command line; links to unneeded packages are ignored. If all requested packages can be found using links on the specified download pages, the Python Package Index will not be consulted unless you also specified the ``--upgrade`` or ``-U`` option. (Note: if you want to refer to a local HTML file containing links, you must use a ``file:`` URL, as filenames that do not refer to a directory, egg, or archive are ignored.) You may specify multiple URLs or file/directory names with this option, separated by whitespace. Note that on the command line, you will probably have to surround the URL list with quotes, so that it is recognized as a single option value. You can also specify URLs in a configuration file; see `Configuration Files`_, above. Changed in 0.6a10: previously all URLs and directories passed to this option were scanned as early as possible, but from 0.6a10 on, only directories and direct archive links are scanned immediately; URLs are not retrieved unless a package search was already going to go online due to a package not being available locally, or due to the use of the ``--update`` or ``-U`` option. ``--no-find-links`` Blocks the addition of any link. This parameter is useful if you want to avoid adding links defined in a project easy_install is installing (whether it's a requested project or a dependency). When used, ``--find-links`` is ignored. Added in Distribute 0.6.11 and Setuptools 0.7. ``--index-url=URL, -i URL`` (New in 0.4a1; default changed in 0.6c7) Specifies the base URL of the Python Package Index. The default is https://pypi.org/simple/ if not specified. When a package is requested that is not locally available or linked from a ``--find-links`` download page, the package index will be searched for download pages for the needed package, and those download pages will be searched for links to download an egg or source distribution. ``--editable, -e`` (New in 0.6a1) Only find and download source distributions for the specified projects, unpacking them to subdirectories of the specified ``--build-directory``. EasyInstall will not actually build or install the requested projects or their dependencies; it will just find and extract them for you. See `Editing and Viewing Source Packages`_ above for more details. ``--build-directory=DIR, -b DIR`` (UPDATED in 0.6a1) Set the directory used to build source packages. If a package is built from a source distribution or checkout, it will be extracted to a subdirectory of the specified directory. The subdirectory will have the same name as the extracted distribution's project, but in all-lowercase. If a file or directory of that name already exists in the given directory, a warning will be printed to the console, and the build will take place in a temporary directory instead. This option is most useful in combination with the ``--editable`` option, which forces EasyInstall to *only* find and extract (but not build and install) source distributions. See `Editing and Viewing Source Packages`_, above, for more information. ``--verbose, -v, --quiet, -q`` (New in 0.4a4) Control the level of detail of EasyInstall's progress messages. The default detail level is "info", which prints information only about relatively time-consuming operations like running a setup script, unpacking an archive, or retrieving a URL. Using ``-q`` or ``--quiet`` drops the detail level to "warn", which will only display installation reports, warnings, and errors. Using ``-v`` or ``--verbose`` increases the detail level to include individual file-level operations, link analysis messages, and distutils messages from any setup scripts that get run. If you include the ``-v`` option more than once, the second and subsequent uses are passed down to any setup scripts, increasing the verbosity of their reporting as well. ``--dry-run, -n`` (New in 0.4a4) Don't actually install the package or scripts. This option is passed down to any setup scripts run, so packages should not actually build either. This does *not* skip downloading, nor does it skip extracting source distributions to a temporary/build directory. ``--optimize=LEVEL``, ``-O LEVEL`` (New in 0.4a4) If you are installing from a source distribution, and are *not* using the ``--zip-ok`` option, this option controls the optimization level for compiling installed ``.py`` files to ``.pyo`` files. It does not affect the compilation of modules contained in ``.egg`` files, only those in ``.egg`` directories. The optimization level can be set to 0, 1, or 2; the default is 0 (unless it's set under ``install`` or ``install_lib`` in one of your distutils configuration files). ``--record=FILENAME`` (New in 0.5a4) Write a record of all installed files to FILENAME. This is basically the same as the same option for the standard distutils "install" command, and is included for compatibility with tools that expect to pass this option to "setup.py install". ``--site-dirs=DIRLIST, -S DIRLIST`` (New in 0.6a1) Specify one or more custom "site" directories (separated by commas). "Site" directories are directories where ``.pth`` files are processed, such as the main Python ``site-packages`` directory. As of 0.6a10, EasyInstall automatically detects whether a given directory processes ``.pth`` files (or can be made to do so), so you should not normally need to use this option. It is is now only necessary if you want to override EasyInstall's judgment and force an installation directory to be treated as if it supported ``.pth`` files. ``--no-deps, -N`` (New in 0.6a6) Don't install any dependencies. This is intended as a convenience for tools that wrap eggs in a platform-specific packaging system. (We don't recommend that you use it for anything else.) ``--allow-hosts=PATTERNS, -H PATTERNS`` (New in 0.6a6) Restrict downloading and spidering to hosts matching the specified glob patterns. E.g. ``-H *.python.org`` restricts web access so that only packages listed and downloadable from machines in the ``python.org`` domain. The glob patterns must match the *entire* user/host/port section of the target URL(s). For example, ``*.python.org`` will NOT accept a URL like ``http://python.org/foo`` or ``http://www.python.org:8080/``. Multiple patterns can be specified by separating them with commas. The default pattern is ``*``, which matches anything. In general, this option is mainly useful for blocking EasyInstall's web access altogether (e.g. ``-Hlocalhost``), or to restrict it to an intranet or other trusted site. EasyInstall will do the best it can to satisfy dependencies given your host restrictions, but of course can fail if it can't find suitable packages. EasyInstall displays all blocked URLs, so that you can adjust your ``--allow-hosts`` setting if it is more strict than you intended. Some sites may wish to define a restrictive default setting for this option in their `configuration files`_, and then manually override the setting on the command line as needed. ``--prefix=DIR`` (New in 0.6a10) Use the specified directory as a base for computing the default installation and script directories. On Windows, the resulting default directories will be ``prefix\\Lib\\site-packages`` and ``prefix\\Scripts``, while on other platforms the defaults will be ``prefix/lib/python2.X/site-packages`` (with the appropriate version substituted) for libraries and ``prefix/bin`` for scripts. Note that the ``--prefix`` option only sets the *default* installation and script directories, and does not override the ones set on the command line or in a configuration file. ``--local-snapshots-ok, -l`` (New in 0.6c6) Normally, EasyInstall prefers to only install *released* versions of projects, not in-development ones, because such projects may not have a currently-valid version number. So, it usually only installs them when their ``setup.py`` directory is explicitly passed on the command line. However, if this option is used, then any in-development projects that were installed using the ``setup.py develop`` command, will be used to build eggs, effectively upgrading the "in-development" project to a snapshot release. Normally, this option is used only in conjunction with the ``--always-copy`` option to create a distributable snapshot of every egg needed to run an application. Note that if you use this option, you must make sure that there is a valid version number (such as an SVN revision number tag) for any in-development projects that may be used, as otherwise EasyInstall may not be able to tell what version of the project is "newer" when future installations or upgrades are attempted. .. _non-root installation: Custom Installation Locations ----------------------------- By default, EasyInstall installs python packages into Python's main ``site-packages`` directory, and manages them using a custom ``.pth`` file in that same directory. Very often though, a user or developer wants ``easy_install`` to install and manage python packages in an alternative location, usually for one of 3 reasons: 1. They don't have access to write to the main Python site-packages directory. 2. They want a user-specific stash of packages, that is not visible to other users. 3. They want to isolate a set of packages to a specific python application, usually to minimize the possibility of version conflicts. Historically, there have been many approaches to achieve custom installation. The following section lists only the easiest and most relevant approaches [1]_. `Use the "--user" option`_ `Use the "--user" option and customize "PYTHONUSERBASE"`_ `Use "virtualenv"`_ .. [1] There are older ways to achieve custom installation using various ``easy_install`` and ``setup.py install`` options, combined with ``PYTHONPATH`` and/or ``PYTHONUSERBASE`` alterations, but all of these are effectively deprecated by the User scheme brought in by `PEP-370`_. .. _PEP-370: http://www.python.org/dev/peps/pep-0370/ Use the "--user" option ~~~~~~~~~~~~~~~~~~~~~~~ Python provides a User scheme for installation, which means that all python distributions support an alternative install location that is specific to a user [3]_. The Default location for each OS is explained in the python documentation for the ``site.USER_BASE`` variable. This mode of installation can be turned on by specifying the ``--user`` option to ``setup.py install`` or ``easy_install``. This approach serves the need to have a user-specific stash of packages. .. [3] Prior to the User scheme, there was the Home scheme, which is still available, but requires more effort than the User scheme to get packages recognized. Use the "--user" option and customize "PYTHONUSERBASE" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The User scheme install location can be customized by setting the ``PYTHONUSERBASE`` environment variable, which updates the value of ``site.USER_BASE``. To isolate packages to a specific application, simply set the OS environment of that application to a specific value of ``PYTHONUSERBASE``, that contains just those packages. Use "virtualenv" ~~~~~~~~~~~~~~~~ "virtualenv" is a 3rd-party python package that effectively "clones" a python installation, thereby creating an isolated location to install packages. The evolution of "virtualenv" started before the existence of the User installation scheme. "virtualenv" provides a version of ``easy_install`` that is scoped to the cloned python install and is used in the normal way. "virtualenv" does offer various features that the User installation scheme alone does not provide, e.g. the ability to hide the main python site-packages. Please refer to the `virtualenv`_ documentation for more details. .. _virtualenv: https://pypi.org/project/virtualenv/ Package Index "API" ------------------- Custom package indexes (and PyPI) must follow the following rules for EasyInstall to be able to look up and download packages: 1. Except where stated otherwise, "pages" are HTML or XHTML, and "links" refer to ``href`` attributes. 2. Individual project version pages' URLs must be of the form ``base/projectname/version``, where ``base`` is the package index's base URL. 3. Omitting the ``/version`` part of a project page's URL (but keeping the trailing ``/``) should result in a page that is either: a) The single active version of that project, as though the version had been explicitly included, OR b) A page with links to all of the active version pages for that project. 4. Individual project version pages should contain direct links to downloadable distributions where possible. It is explicitly permitted for a project's "long_description" to include URLs, and these should be formatted as HTML links by the package index, as EasyInstall does no special processing to identify what parts of a page are index-specific and which are part of the project's supplied description. 5. Where available, MD5 information should be added to download URLs by appending a fragment identifier of the form ``#md5=...``, where ``...`` is the 32-character hex MD5 digest. EasyInstall will verify that the downloaded file's MD5 digest matches the given value. 6. Individual project version pages should identify any "homepage" or "download" URLs using ``rel="homepage"`` and ``rel="download"`` attributes on the HTML elements linking to those URLs. Use of these attributes will cause EasyInstall to always follow the provided links, unless it can be determined by inspection that they are downloadable distributions. If the links are not to downloadable distributions, they are retrieved, and if they are HTML, they are scanned for download links. They are *not* scanned for additional "homepage" or "download" links, as these are only processed for pages that are part of a package index site. 7. The root URL of the index, if retrieved with a trailing ``/``, must result in a page containing links to *all* projects' active version pages. (Note: This requirement is a workaround for the absence of case-insensitive ``safe_name()`` matching of project names in URL paths. If project names are matched in this fashion (e.g. via the PyPI server, mod_rewrite, or a similar mechanism), then it is not necessary to include this all-packages listing page.) 8. If a package index is accessed via a ``file://`` URL, then EasyInstall will automatically use ``index.html`` files, if present, when trying to read a directory with a trailing ``/`` on the URL. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/functionalities.rst0000644000175100001710000000265200000000000022363 0ustar00runnerdocker"Eggsecutable" Scripts ---------------------- .. deprecated:: 45.3.0 Occasionally, there are situations where it's desirable to make an ``.egg`` file directly executable. You can do this by including an entry point such as the following:: setup( # other arguments here... entry_points={ "setuptools.installation": [ "eggsecutable = my_package.some_module:main_func", ] } ) Any eggs built from the above setup script will include a short executable prelude that imports and calls ``main_func()`` from ``my_package.some_module``. The prelude can be run on Unix-like platforms (including Mac and Linux) by invoking the egg with ``/bin/sh``, or by enabling execute permissions on the ``.egg`` file. For the executable prelude to run, the appropriate version of Python must be available via the ``PATH`` environment variable, under its "long" name. That is, if the egg is built for Python 2.3, there must be a ``python2.3`` executable present in a directory on ``PATH``. IMPORTANT NOTE: Eggs with an "eggsecutable" header cannot be renamed, or invoked via symlinks. They *must* be invoked using their original filename, in order to ensure that, once running, ``pkg_resources`` will know what project and version is in use. The header script will check this and exit with an error if the ``.egg`` file has been renamed or is invoked via a symlink that changes its base name.././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/index.rst0000644000175100001710000000141700000000000020270 0ustar00runnerdocker====================================================== Guides on backward compatibility & deprecated practice ====================================================== ``Setuptools`` has undergone tremendous changes since its first debut. As its development continues to roll forward, many of the practice and mechanisms it had established are now considered deprecated. But they still remain relevant as a plethora of libraries continue to depend on them. Many people also find it necessary to equip themselves with the knowledge to better support backward compatibility. This guide aims to provide the essential information for such objectives. .. toctree:: :maxdepth: 1 python3 python_eggs easy_install distutils/index distutils-legacy functionalities ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/deprecated/python_eggs.rst0000644000175100001710000007433700000000000021522 0ustar00runnerdocker===================================== The Internal Structure of Python Eggs ===================================== STOP! This is not the first document you should read! ---------------------- Eggs and their Formats ---------------------- A "Python egg" is a logical structure embodying the release of a specific version of a Python project, comprising its code, resources, and metadata. There are multiple formats that can be used to physically encode a Python egg, and others can be developed. However, a key principle of Python eggs is that they should be discoverable and importable. That is, it should be possible for a Python application to easily and efficiently find out what eggs are present on a system, and to ensure that the desired eggs' contents are importable. There are two basic formats currently implemented for Python eggs: 1. ``.egg`` format: a directory or zipfile *containing* the project's code and resources, along with an ``EGG-INFO`` subdirectory that contains the project's metadata 2. ``.egg-info`` format: a file or directory placed *adjacent* to the project's code and resources, that directly contains the project's metadata. Both formats can include arbitrary Python code and resources, including static data files, package and non-package directories, Python modules, C extension modules, and so on. But each format is optimized for different purposes. The ``.egg`` format is well-suited to distribution and the easy uninstallation or upgrades of code, since the project is essentially self-contained within a single directory or file, unmingled with any other projects' code or resources. It also makes it possible to have multiple versions of a project simultaneously installed, such that individual programs can select the versions they wish to use. The ``.egg-info`` format, on the other hand, was created to support backward-compatibility, performance, and ease of installation for system packaging tools that expect to install all projects' code and resources to a single directory (e.g. ``site-packages``). Placing the metadata in that same directory simplifies the installation process, since it isn't necessary to create ``.pth`` files or otherwise modify ``sys.path`` to include each installed egg. Its disadvantage, however, is that it provides no support for clean uninstallation or upgrades, and of course only a single version of a project can be installed to a given directory. Thus, support from a package management tool is required. (This is why setuptools' "install" command refers to this type of egg installation as "single-version, externally managed".) Also, they lack sufficient data to allow them to be copied from their installation source. easy_install can "ship" an application by copying ``.egg`` files or directories to a target location, but it cannot do this for ``.egg-info`` installs, because there is no way to tell what code and resources belong to a particular egg -- there may be several eggs "scrambled" together in a single installation location, and the ``.egg-info`` format does not currently include a way to list the files that were installed. (This may change in a future version.) Code and Resources ================== The layout of the code and resources is dictated by Python's normal import layout, relative to the egg's "base location". For the ``.egg`` format, the base location is the ``.egg`` itself. That is, adding the ``.egg`` filename or directory name to ``sys.path`` makes its contents importable. For the ``.egg-info`` format, however, the base location is the directory that *contains* the ``.egg-info``, and thus it is the directory that must be added to ``sys.path`` to make the egg importable. (Note that this means that the "normal" installation of a package to a ``sys.path`` directory is sufficient to make it an "egg" if it has an ``.egg-info`` file or directory installed alongside of it.) Project Metadata ================= If eggs contained only code and resources, there would of course be no difference between them and any other directory or zip file on ``sys.path``. Thus, metadata must also be included, using a metadata file or directory. For the ``.egg`` format, the metadata is placed in an ``EGG-INFO`` subdirectory, directly within the ``.egg`` file or directory. For the ``.egg-info`` format, metadata is stored directly within the ``.egg-info`` directory itself. The minimum project metadata that all eggs must have is a standard Python ``PKG-INFO`` file, named ``PKG-INFO`` and placed within the metadata directory appropriate to the format. Because it's possible for this to be the only metadata file included, ``.egg-info`` format eggs are not required to be a directory; they can just be a ``.egg-info`` file that directly contains the ``PKG-INFO`` metadata. This eliminates the need to create a directory just to store one file. This option is *not* available for ``.egg`` formats, since setuptools always includes other metadata. (In fact, setuptools itself never generates ``.egg-info`` files, either; the support for using files was added so that the requirement could easily be satisfied by other tools, such as distutils). In addition to the ``PKG-INFO`` file, an egg's metadata directory may also include files and directories representing various forms of optional standard metadata (see the section on `Standard Metadata`_, below) or user-defined metadata required by the project. For example, some projects may define a metadata format to describe their application plugins, and metadata in this format would then be included by plugin creators in their projects' metadata directories. Filename-Embedded Metadata ========================== To allow introspection of installed projects and runtime resolution of inter-project dependencies, a certain amount of information is embedded in egg filenames. At a minimum, this includes the project name, and ideally will also include the project version number. Optionally, it can also include the target Python version and required runtime platform if platform-specific C code is included. The syntax of an egg filename is as follows:: name ["-" version ["-py" pyver ["-" required_platform]]] "." ext The "name" and "version" should be escaped using the ``to_filename()`` function provided by ``pkg_resources``, after first processing them with ``safe_name()`` and ``safe_version()`` respectively. These latter two functions can also be used to later "unescape" these parts of the filename. (For a detailed description of these transformations, please see the "Parsing Utilities" section of the ``pkg_resources`` manual.) The "pyver" string is the Python major version, as found in the first 3 characters of ``sys.version``. "required_platform" is essentially a distutils ``get_platform()`` string, but with enhancements to properly distinguish Mac OS versions. (See the ``get_build_platform()`` documentation in the "Platform Utilities" section of the ``pkg_resources`` manual for more details.) Finally, the "ext" is either ``.egg`` or ``.egg-info``, as appropriate for the egg's format. Normally, an egg's filename should include at least the project name and version, as this allows the runtime system to find desired project versions without having to read the egg's PKG-INFO to determine its version number. Setuptools, however, only includes the version number in the filename when an ``.egg`` file is built using the ``bdist_egg`` command, or when an ``.egg-info`` directory is being installed by the ``install_egg_info`` command. When generating metadata for use with the original source tree, it only includes the project name, so that the directory will not have to be renamed each time the project's version changes. This is especially important when version numbers change frequently, and the source metadata directory is kept under version control with the rest of the project. (As would be the case when the project's source includes project-defined metadata that is not generated from by setuptools from data in the setup script.) Egg Links ========= In addition to the ``.egg`` and ``.egg-info`` formats, there is a third egg-related extension that you may encounter on occasion: ``.egg-link`` files. These files are not eggs, strictly speaking. They simply provide a way to reference an egg that is not physically installed in the desired location. They exist primarily as a cross-platform alternative to symbolic links, to support "installing" code that is being developed in a different location than the desired installation location. For example, if a user is developing an application plugin in their home directory, but the plugin needs to be "installed" in an application plugin directory, running "setup.py develop -md /path/to/app/plugins" will install an ``.egg-link`` file in ``/path/to/app/plugins``, that tells the egg runtime system where to find the actual egg (the user's project source directory and its ``.egg-info`` subdirectory). ``.egg-link`` files are named following the format for ``.egg`` and ``.egg-info`` names, but only the project name is included; no version, Python version, or platform information is included. When the runtime searches for available eggs, ``.egg-link`` files are opened and the actual egg file/directory name is read from them. Each ``.egg-link`` file should contain a single file or directory name, with no newlines. This filename should be the base location of one or more eggs. That is, the name must either end in ``.egg``, or else it should be the parent directory of one or more ``.egg-info`` format eggs. As of setuptools 0.6c6, the path may be specified as a platform-independent (i.e. ``/``-separated) relative path from the directory containing the ``.egg-link`` file, and a second line may appear in the file, specifying a platform-independent relative path from the egg's base directory to its setup script directory. This allows installation tools such as EasyInstall to find the project's setup directory and build eggs or perform other setup commands on it. ----------------- Standard Metadata ----------------- In addition to the minimum required ``PKG-INFO`` metadata, projects can include a variety of standard metadata files or directories, as described below. Except as otherwise noted, these files and directories are automatically generated by setuptools, based on information supplied in the setup script or through analysis of the project's code and resources. Most of these files and directories are generated via "egg-info writers" during execution of the setuptools ``egg_info`` command, and are listed in the ``egg_info.writers`` entry point group defined by setuptools' own ``setup.py`` file. Project authors can register their own metadata writers as entry points in this group (as described in the setuptools manual under "Adding new EGG-INFO Files") to cause setuptools to generate project-specific metadata files or directories during execution of the ``egg_info`` command. It is up to project authors to document these new metadata formats, if they create any. ``.txt`` File Formats ===================== Files described in this section that have ``.txt`` extensions have a simple lexical format consisting of a sequence of text lines, each line terminated by a linefeed character (regardless of platform). Leading and trailing whitespace on each line is ignored, as are blank lines and lines whose first nonblank character is a ``#`` (comment symbol). (This is the parsing format defined by the ``yield_lines()`` function of the ``pkg_resources`` module.) All ``.txt`` files defined by this section follow this format, but some are also "sectioned" files, meaning that their contents are divided into sections, using square-bracketed section headers akin to Windows ``.ini`` format. Note that this does *not* imply that the lines within the sections follow an ``.ini`` format, however. Please see an individual metadata file's documentation for a description of what the lines and section names mean in that particular file. Sectioned files can be parsed using the ``split_sections()`` function; see the "Parsing Utilities" section of the ``pkg_resources`` manual for for details. Dependency Metadata =================== ``requires.txt`` ---------------- This is a "sectioned" text file. Each section is a sequence of "requirements", as parsed by the ``parse_requirements()`` function; please see the ``pkg_resources`` manual for the complete requirement parsing syntax. The first, unnamed section (i.e., before the first section header) in this file is the project's core requirements, which must be installed for the project to function. (Specified using the ``install_requires`` keyword to ``setup()``). The remaining (named) sections describe the project's "extra" requirements, as specified using the ``extras_require`` keyword to ``setup()``. The section name is the name of the optional feature, and the section body lists that feature's dependencies. Note that it is not normally necessary to inspect this file directly; ``pkg_resources.Distribution`` objects have a ``requires()`` method that can be used to obtain ``Requirement`` objects describing the project's core and optional dependencies. ``setup_requires.txt`` ---------------------- Much like ``requires.txt`` except represents the requirements specified by the ``setup_requires`` parameter to the Distribution. ``dependency_links.txt`` ------------------------ A list of dependency URLs, one per line, as specified using the ``dependency_links`` keyword to ``setup()``. These may be direct download URLs, or the URLs of web pages containing direct download links. Please see the setuptools manual for more information on specifying this option. ``depends.txt`` -- Obsolete, do not create! ------------------------------------------- This file follows an identical format to ``requires.txt``, but is obsolete and should not be used. The earliest versions of setuptools required users to manually create and maintain this file, so the runtime still supports reading it, if it exists. The new filename was created so that it could be automatically generated from ``setup()`` information without overwriting an existing hand-created ``depends.txt``, if one was already present in the project's source ``.egg-info`` directory. ``namespace_packages.txt`` -- Namespace Package Metadata ======================================================== A list of namespace package names, one per line, as supplied to the ``namespace_packages`` keyword to ``setup()``. Please see the manuals for setuptools and ``pkg_resources`` for more information about namespace packages. ``entry_points.txt`` -- "Entry Point"/Plugin Metadata ===================================================== This is a "sectioned" text file, whose contents encode the ``entry_points`` keyword supplied to ``setup()``. All sections are named, as the section names specify the entry point groups in which the corresponding section's entry points are registered. Each section is a sequence of "entry point" lines, each parseable using the ``EntryPoint.parse`` classmethod; please see the ``pkg_resources`` manual for the complete entry point parsing syntax. Note that it is not necessary to parse this file directly; the ``pkg_resources`` module provides a variety of APIs to locate and load entry points automatically. Please see the setuptools and ``pkg_resources`` manuals for details on the nature and uses of entry points. The ``scripts`` Subdirectory ============================ This directory is currently only created for ``.egg`` files built by the setuptools ``bdist_egg`` command. It will contain copies of all of the project's "traditional" scripts (i.e., those specified using the ``scripts`` keyword to ``setup()``). This is so that they can be reconstituted when an ``.egg`` file is installed. The scripts are placed here using the distutils' standard ``install_scripts`` command, so any ``#!`` lines reflect the Python installation where the egg was built. But instead of copying the scripts to the local script installation directory, EasyInstall writes short wrapper scripts that invoke the original scripts from inside the egg, after ensuring that sys.path includes the egg and any eggs it depends on. For more about `script wrappers`_, see the section below on `Installation and Path Management Issues`_. Zip Support Metadata ==================== ``native_libs.txt`` ------------------- A list of C extensions and other dynamic link libraries contained in the egg, one per line. Paths are ``/``-separated and relative to the egg's base location. This file is generated as part of ``bdist_egg`` processing, and as such only appears in ``.egg`` files (and ``.egg`` directories created by unpacking them). It is used to ensure that all libraries are extracted from a zipped egg at the same time, in case there is any direct linkage between them. Please see the `Zip File Issues`_ section below for more information on library and resource extraction from ``.egg`` files. ``eager_resources.txt`` ----------------------- A list of resource files and/or directories, one per line, as specified via the ``eager_resources`` keyword to ``setup()``. Paths are ``/``-separated and relative to the egg's base location. Resource files or directories listed here will be extracted simultaneously, if any of the named resources are extracted, or if any native libraries listed in ``native_libs.txt`` are extracted. Please see the setuptools manual for details on what this feature is used for and how it works, as well as the `Zip File Issues`_ section below. ``zip-safe`` and ``not-zip-safe`` --------------------------------- These are zero-length files, and either one or the other should exist. If ``zip-safe`` exists, it means that the project will work properly when installed as an ``.egg`` zipfile, and conversely the existence of ``not-zip-safe`` means the project should not be installed as an ``.egg`` file. The ``zip_safe`` option to setuptools' ``setup()`` determines which file will be written. If the option isn't provided, setuptools attempts to make its own assessment of whether the package can work, based on code and content analysis. If neither file is present at installation time, EasyInstall defaults to assuming that the project should be unzipped. (Command-line options to EasyInstall, however, take precedence even over an existing ``zip-safe`` or ``not-zip-safe`` file.) Note that these flag files appear only in ``.egg`` files generated by ``bdist_egg``, and in ``.egg`` directories created by unpacking such an ``.egg`` file. ``top_level.txt`` -- Conflict Management Metadata ================================================= This file is a list of the top-level module or package names provided by the project, one Python identifier per line. Subpackages are not included; a project containing both a ``foo.bar`` and a ``foo.baz`` would include only one line, ``foo``, in its ``top_level.txt``. This data is used by ``pkg_resources`` at runtime to issue a warning if an egg is added to ``sys.path`` when its contained packages may have already been imported. (It was also once used to detect conflicts with non-egg packages at installation time, but in more recent versions, setuptools installs eggs in such a way that they always override non-egg packages, thus preventing a problem from arising.) ``SOURCES.txt`` -- Source Files Manifest ======================================== This file is roughly equivalent to the distutils' ``MANIFEST`` file. The differences are as follows: * The filenames always use ``/`` as a path separator, which must be converted back to a platform-specific path whenever they are read. * The file is automatically generated by setuptools whenever the ``egg_info`` or ``sdist`` commands are run, and it is *not* user-editable. Although this metadata is included with distributed eggs, it is not actually used at runtime for any purpose. Its function is to ensure that setuptools-built *source* distributions can correctly discover what files are part of the project's source, even if the list had been generated using revision control metadata on the original author's system. In other words, ``SOURCES.txt`` has little or no runtime value for being included in distributed eggs, and it is possible that future versions of the ``bdist_egg`` and ``install_egg_info`` commands will strip it before installation or distribution. Therefore, do not rely on its being available outside of an original source directory or source distribution. ------------------------------ Other Technical Considerations ------------------------------ Zip File Issues =============== Although zip files resemble directories, they are not fully substitutable for them. Most platforms do not support loading dynamic link libraries contained in zipfiles, so it is not possible to directly import C extensions from ``.egg`` zipfiles. Similarly, there are many existing libraries -- whether in Python or C -- that require actual operating system filenames, and do not work with arbitrary "file-like" objects or in-memory strings, and thus cannot operate directly on the contents of zip files. To address these issues, the ``pkg_resources`` module provides a "resource API" to support obtaining either the contents of a resource, or a true operating system filename for the resource. If the egg containing the resource is a directory, the resource's real filename is simply returned. However, if the egg is a zipfile, then the resource is first extracted to a cache directory, and the filename within the cache is returned. The cache directory is determined by the ``pkg_resources`` API; please see the ``set_cache_path()`` and ``get_default_cache()`` documentation for details. The Extraction Process ---------------------- Resources are extracted to a cache subdirectory whose name is based on the enclosing ``.egg`` filename and the path to the resource. If there is already a file of the correct name, size, and timestamp, its filename is returned to the requester. Otherwise, the desired file is extracted first to a temporary name generated using ``mkstemp(".$extract",target_dir)``, and then its timestamp is set to match the one in the zip file, before renaming it to its final name. (Some collision detection and resolution code is used to handle the fact that Windows doesn't overwrite files when renaming.) If a resource directory is requested, all of its contents are recursively extracted in this fashion, to ensure that the directory name can be used as if it were valid all along. If the resource requested for extraction is listed in the ``native_libs.txt`` or ``eager_resources.txt`` metadata files, then *all* resources listed in *either* file will be extracted before the requested resource's filename is returned, thus ensuring that all C extensions and data used by them will be simultaneously available. Extension Import Wrappers ------------------------- Since Python's built-in zip import feature does not support loading C extension modules from zipfiles, the setuptools ``bdist_egg`` command generates special import wrappers to make it work. The wrappers are ``.py`` files (along with corresponding ``.pyc`` and/or ``.pyo`` files) that have the same module name as the corresponding C extension. These wrappers are located in the same package directory (or top-level directory) within the zipfile, so that say, ``foomodule.so`` will get a corresponding ``foo.py``, while ``bar/baz.pyd`` will get a corresponding ``bar/baz.py``. These wrapper files contain a short stanza of Python code that asks ``pkg_resources`` for the filename of the corresponding C extension, then reloads the module using the obtained filename. This will cause ``pkg_resources`` to first ensure that all of the egg's C extensions (and any accompanying "eager resources") are extracted to the cache before attempting to link to the C library. Note, by the way, that ``.egg`` directories will also contain these wrapper files. However, Python's default import priority is such that C extensions take precedence over same-named Python modules, so the import wrappers are ignored unless the egg is a zipfile. Installation and Path Management Issues ======================================= Python's initial setup of ``sys.path`` is very dependent on the Python version and installation platform, as well as how Python was started (i.e., script vs. ``-c`` vs. ``-m`` vs. interactive interpreter). In fact, Python also provides only two relatively robust ways to affect ``sys.path`` outside of direct manipulation in code: the ``PYTHONPATH`` environment variable, and ``.pth`` files. However, with no cross-platform way to safely and persistently change environment variables, this leaves ``.pth`` files as EasyInstall's only real option for persistent configuration of ``sys.path``. But ``.pth`` files are rather strictly limited in what they are allowed to do normally. They add directories only to the *end* of ``sys.path``, after any locally-installed ``site-packages`` directory, and they are only processed *in* the ``site-packages`` directory to start with. This is a double whammy for users who lack write access to that directory, because they can't create a ``.pth`` file that Python will read, and even if a sympathetic system administrator adds one for them that calls ``site.addsitedir()`` to allow some other directory to contain ``.pth`` files, they won't be able to install newer versions of anything that's installed in the systemwide ``site-packages``, because their paths will still be added *after* ``site-packages``. So EasyInstall applies two workarounds to solve these problems. The first is that EasyInstall leverages ``.pth`` files' "import" feature to manipulate ``sys.path`` and ensure that anything EasyInstall adds to a ``.pth`` file will always appear before both the standard library and the local ``site-packages`` directories. Thus, it is always possible for a user who can write a Python-read ``.pth`` file to ensure that their packages come first in their own environment. Second, when installing to a ``PYTHONPATH`` directory (as opposed to a "site" directory like ``site-packages``) EasyInstall will also install a special version of the ``site`` module. Because it's in a ``PYTHONPATH`` directory, this module will get control before the standard library version of ``site`` does. It will record the state of ``sys.path`` before invoking the "real" ``site`` module, and then afterwards it processes any ``.pth`` files found in ``PYTHONPATH`` directories, including all the fixups needed to ensure that eggs always appear before the standard library in sys.path, but are in a relative order to one another that is defined by their ``PYTHONPATH`` and ``.pth``-prescribed sequence. The net result of these changes is that ``sys.path`` order will be as follows at runtime: 1. The ``sys.argv[0]`` directory, or an empty string if no script is being executed. 2. All eggs installed by EasyInstall in any ``.pth`` file in each ``PYTHONPATH`` directory, in order first by ``PYTHONPATH`` order, then normal ``.pth`` processing order (which is to say alphabetical by ``.pth`` filename, then by the order of listing within each ``.pth`` file). 3. All eggs installed by EasyInstall in any ``.pth`` file in each "site" directory (such as ``site-packages``), following the same ordering rules as for the ones on ``PYTHONPATH``. 4. The ``PYTHONPATH`` directories themselves, in their original order 5. Any paths from ``.pth`` files found on ``PYTHONPATH`` that were *not* eggs installed by EasyInstall, again following the same relative ordering rules. 6. The standard library and "site" directories, along with the contents of any ``.pth`` files found in the "site" directories. Notice that sections 1, 4, and 6 comprise the "normal" Python setup for ``sys.path``. Sections 2 and 3 are inserted to support eggs, and section 5 emulates what the "normal" semantics of ``.pth`` files on ``PYTHONPATH`` would be if Python natively supported them. For further discussion of the tradeoffs that went into this design, as well as notes on the actual magic inserted into ``.pth`` files to make them do these things, please see also the following messages to the distutils-SIG mailing list: * http://mail.python.org/pipermail/distutils-sig/2006-February/006026.html * http://mail.python.org/pipermail/distutils-sig/2006-March/006123.html Script Wrappers --------------- EasyInstall never directly installs a project's original scripts to a script installation directory. Instead, it writes short wrapper scripts that first ensure that the project's dependencies are active on sys.path, before invoking the original script. These wrappers have a #! line that points to the version of Python that was used to install them, and their second line is always a comment that indicates the type of script wrapper, the project version required for the script to run, and information identifying the script to be invoked. The format of this marker line is:: "# EASY-INSTALL-" script_type ": " tuple_of_strings "\n" The ``script_type`` is one of ``SCRIPT``, ``DEV-SCRIPT``, or ``ENTRY-SCRIPT``. The ``tuple_of_strings`` is a comma-separated sequence of Python string constants. For ``SCRIPT`` and ``DEV-SCRIPT`` wrappers, there are two strings: the project version requirement, and the script name (as a filename within the ``scripts`` metadata directory). For ``ENTRY-SCRIPT`` wrappers, there are three: the project version requirement, the entry point group name, and the entry point name. (See the "Automatic Script Creation" section in the setuptools manual for more information about entry point scripts.) In each case, the project version requirement string will be a string parseable with the ``pkg_resources`` modules' ``Requirement.parse()`` classmethod. The only difference between a ``SCRIPT`` wrapper and a ``DEV-SCRIPT`` is that a ``DEV-SCRIPT`` actually executes the original source script in the project's source tree, and is created when the "setup.py develop" command is run. A ``SCRIPT`` wrapper, on the other hand, uses the "installed" script written to the ``EGG-INFO/scripts`` subdirectory of the corresponding ``.egg`` zipfile or directory. (``.egg-info`` eggs do not have script wrappers associated with them, except in the "setup.py develop" case.) The purpose of including the marker line in generated script wrappers is to facilitate introspection of installed scripts, and their relationship to installed eggs. For example, an uninstallation tool could use this data to identify what scripts can safely be removed, and/or identify what scripts would stop working if a particular egg is uninstalled. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8946698 setuptools-59.6.0/docs/development/0000755000175100001710000000000000000000000016646 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/development/developer-guide.rst0000644000175100001710000001121000000000000022453 0ustar00runnerdocker================================ Developer's Guide for Setuptools ================================ If you want to know more about contributing on Setuptools, this is the place. ------------------- Recommended Reading ------------------- Please read `How to write the perfect pull request `_ for some tips on contributing to open source projects. Although the article is not authoritative, it was authored by the maintainer of Setuptools, so reflects his opinions and will improve the likelihood of acceptance and quality of contribution. ------------------ Project Management ------------------ Setuptools is maintained primarily in GitHub at `this home `_. Setuptools is maintained under the Python Packaging Authority (PyPA) with several core contributors. All bugs for Setuptools are filed and the canonical source is maintained in GitHub. User support and discussions are done through the issue tracker (for specific) issues, through the `distutils-sig mailing list `_, or on IRC (Freenode) at #pypa. Discussions about development happen on the distutils-sig mailing list or on `Gitter `_. ----------------- Authoring Tickets ----------------- Before authoring any source code, it's often prudent to file a ticket describing the motivation behind making changes. First search to see if a ticket already exists for your issue. If not, create one. Try to think from the perspective of the reader. Explain what behavior you expected, what you got instead, and what factors might have contributed to the unexpected behavior. In GitHub, surround a block of code or traceback with the triple backtick "\`\`\`" so that it is formatted nicely. Filing a ticket provides a forum for justification, discussion, and clarification. The ticket provides a record of the purpose for the change and any hard decisions that were made. It provides a single place for others to reference when trying to understand why the software operates the way it does or why certain changes were made. Setuptools makes extensive use of hyperlinks to tickets in the changelog so that system integrators and other users can get a quick summary, but then jump to the in-depth discussion about any subject referenced. --------------------- Making a pull request --------------------- When making a pull request, please :ref:`include a short summary of the changes ` and a reference to any issue tickets that the PR is intended to solve. All PRs with code changes should include tests. All changes should include a changelog entry. .. include:: ../../changelog.d/README.rst ------------------- Auto-Merge Requests ------------------- To support running all code through CI, even lightweight contributions, the project employs Mergify to auto-merge pull requests tagged as auto-merge. Use ``hub pull-request -l auto-merge`` to create such a pull request from the command line after pushing a new branch. ------- Testing ------- The primary tests are run using tox. Make sure you have tox installed, and invoke it:: $ tox Under continuous integration, additional tests may be run. See the ``.travis.yml`` file for full details on the tests run under Travis-CI. ------------------- Semantic Versioning ------------------- Setuptools follows ``semver``. .. explain value of reflecting meaning in versions. ---------------------- Building Documentation ---------------------- Setuptools relies on the `Sphinx`_ system for building documentation. The `published documentation`_ is hosted on Read the Docs. To build the docs locally, use tox:: $ tox -e docs .. _Sphinx: http://www.sphinx-doc.org/en/master/ .. _published documentation: https://setuptools.pypa.io/en/latest/ --------------------- Vendored Dependencies --------------------- Setuptools has some dependencies, but due to `bootstrapping issues `_, those dependencies cannot be declared as they won't be resolved soon enough to build setuptools from source. Eventually, this limitation may be lifted as PEP 517/518 reach ubiquitous adoption, but for now, Setuptools cannot declare dependencies other than through ``setuptools/_vendor/vendored.txt`` and ``pkg_resources/_vendor/vendored.txt``. All the dependencies specified in these files are "vendorized" using Paver_, a simple Python-based project scripting and task running tool. To refresh the dependencies, you can run the following command (defined in ``pavement.py``):: $ paver update_vendored .. _Paver: https://pythonhosted.org/Paver/ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/development/index.rst0000644000175100001710000000265700000000000020521 0ustar00runnerdocker------------------------- Development on Setuptools ------------------------- Setuptools is maintained by the Python community under the Python Packaging Authority (PyPA) and led by Jason R. Coombs. This document describes the process by which Setuptools is developed. This document assumes the reader has some passing familiarity with *using* setuptools, the ``pkg_resources`` module, and pip. It does not attempt to explain basic concepts like inter-project dependencies, nor does it contain detailed lexical syntax for most file formats. Neither does it explain concepts like "namespace packages" or "resources" in any detail, as all of these subjects are covered at length in the setuptools developer's guide and the ``pkg_resources`` reference manual. Instead, this is **internal** documentation for how those concepts and features are *implemented* in concrete terms. It is intended for people who are working on the setuptools code base, who want to be able to troubleshoot setuptools problems, want to write code that reads the file formats involved, or want to otherwise tinker with setuptools-generated files and directories. Note, however, that these are all internal implementation details and are therefore subject to change; stick to the published API if you don't want to be responsible for keeping your code from breaking when setuptools changes. You have been warned. .. toctree:: :maxdepth: 1 developer-guide releases ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/development/releases.rst0000644000175100001710000000261500000000000021207 0ustar00runnerdocker=============== Release Process =============== In order to allow for rapid, predictable releases, Setuptools uses a mechanical technique for releases, enacted on tagged commits by continuous integration. To finalize a release, run ``tox -e finalize``, review, then push the changes. If tests pass, the release will be uploaded to PyPI. Release Frequency ----------------- Some have asked why Setuptools is released so frequently. Because Setuptools uses a mechanical release process, it's very easy to make releases whenever the code is stable (tests are passing). As a result, the philosophy is to release early and often. While some find the frequent releases somewhat surprising, they only empower the user. Although releases are made frequently, users can choose the frequency at which they use those releases. If instead Setuptools contributions were only released in batches, the user would be constrained to only use Setuptools when those official releases were made. With frequent releases, the user can govern exactly how often he wishes to update. Frequent releases also then obviate the need for dev or beta releases in most cases. Because releases are made early and often, bugs are discovered and corrected quickly, in many cases before other users have yet to encounter them. Release Managers ---------------- Additionally, anyone with push access to the master branch has access to cut releases. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/history.rst0000644000175100001710000000356000000000000016563 0ustar00runnerdocker:tocdepth: 2 .. _changes: History ******* .. towncrier-draft-entries:: DRAFT, unreleased as on |today| .. include:: ../CHANGES (links).rst Credits ******* * The original design for the ``.egg`` format and the ``pkg_resources`` API was co-created by Phillip Eby and Bob Ippolito. Bob also implemented the first version of ``pkg_resources``, and supplied the macOS operating system version compatibility algorithm. * Ian Bicking implemented many early "creature comfort" features of easy_install, including support for downloading via Sourceforge and Subversion repositories. Ian's comments on the Web-SIG about WSGI application deployment also inspired the concept of "entry points" in eggs, and he has given talks at PyCon and elsewhere to inform and educate the community about eggs and setuptools. * Jim Fulton contributed time and effort to build automated tests of various aspects of ``easy_install``, and supplied the doctests for the command-line ``.exe`` wrappers on Windows. * Phillip J. Eby is the seminal author of setuptools, and first proposed the idea of an importable binary distribution format for Python application plug-ins. * Significant parts of the implementation of setuptools were funded by the Open Source Applications Foundation, to provide a plug-in infrastructure for the Chandler PIM application. In addition, many OSAF staffers (such as Mike "Code Bear" Taylor) contributed their time and stress as guinea pigs for the use of eggs and setuptools, even before eggs were "cool". (Thanks, guys!) * Tarek Ziadé is the principal author of the Distribute fork, which re-invigorated the community on the project, encouraged renewed innovation, and addressed many defects. * Jason R. Coombs performed the merge with Distribute, maintaining the project for several years in coordination with the Python Packaging Authority (PyPA). ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8946698 setuptools-59.6.0/docs/images/0000755000175100001710000000000000000000000015571 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/images/README.rst0000644000175100001710000001112100000000000017254 0ustar00runnerdocker======= Artwork ======= .. figure:: logo-over-white.svg :align: center Setuptools logo, designed in 2021 by `Anderson Bravalheri`_ Elements of Design ================== The main colours of the design are a dark pastel azure (``#336790``) and a pale orange (``#E5B62F``), referred in this document simply as "blue" and "yellow" respectively. The text uses the *Monoid* typeface, an open source webfont that was developed by Andreas Larsen and contributors in 2015 and is distributed under the MIT or SIL licenses (more information at https://github.com/larsenwork/monoid) Usage ===== The preferred way of using the setuptools logo is over a white (or light) background. Alternatively, the following options can be considered, depending on the circumstances: - *"negative"* design - for dark backgrounds (e.g. website displayed in "dark mode"): the white colour (``#FFFFFF``) of the background and the "blue" (``#336790``) colour of the design can be swapped. - *"monochrome"* - when colours are not available (e.g. black and white printed media): a completely black or white version of the logo can also be used. - *"banner"* mode: the symbol and text can be used alongside depending on the available space. The following image illustrate these alternatives: .. image:: logo-demo.svg :align: center Please refer to the SVG files in the `setuptools repository`_ for the specific shapes and proportions between the elements of the design. Working with the Design ======================= The `setuptools repository`_ contains a series of vector representations of the design under the ``docs/images`` directory. These representations can be manipulated via any graphic editor that support SVG files, however the free and open-source software Inkscape_ is recommended for maximum compatibility. When selecting the right file to work with, file names including ``editable-inkscape`` indicate "more editable" elements (e.g. editable text), while the others prioritise SVG paths for maximum reproducibility. Also notice that you might have to `install the correct fonts`_ to be able to visualise or edit some of the designs. Inspiration =========== This design was inspired by :user:`cajhne`'s `original proposal`_ and the ancient symbol of the ouroboros_. It features a snake moving in a circular trajectory not only as a reference to the Python programming language but also to the `wheel package format`_ as one of the distribution formats supported by setuptools. The shape of the snake also resembles a cog, which together with the hammer is a nod to the two words that compose the name of the project. License ======= This logo, design variations or a modified version may be used by anyone to refer to setuptools, but does not indicate endorsement by the project. Redistribution, usage and derivative works are permitted under the same license used by the setuptools software (MIT): .. code-block:: text Copyright (c) Anderson Bravalheri Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. THE USAGE OF THIS LOGO AND ARTWORK DOES NOT INDICATE ENDORSEMENT BY THE SETUPTOOLS PROJECT. Whenever possible, please make the image a link to https://github.com/pypa/setuptools. .. _Anderson Bravalheri: https://github.com/abravalheri .. _Inkscape: https://inkscape.org .. _setuptools repository: https://github.com/pypa/setuptools .. _install the correct fonts: https://wiki.inkscape.org/wiki/Installing_fonts .. _original proposal: https://github.com/pypa/setuptools/issues/2227#issuecomment-653628344 .. _wheel package format: https://www.python.org/dev/peps/pep-0427/ .. _ouroboros: https://en.wikipedia.org/wiki/Ouroboros ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/index.rst0000644000175100001710000000114600000000000016167 0ustar00runnerdocker.. image:: images/banner-640x320.svg :align: center Documentation ============= Setuptools is a fully-featured, actively-maintained, and stable library designed to facilitate packaging Python projects. .. toctree:: :maxdepth: 1 :hidden: User guide build_meta pkg_resources references/keywords setuptools .. toctree:: :caption: Project :maxdepth: 1 :hidden: roadmap Development guide Backward compatibility & deprecated practice Changelog Artwork .. tidelift-referral-banner:: ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/pkg_resources.rst0000644000175100001710000027016100000000000017740 0ustar00runnerdocker============================================================= Package Discovery and Resource Access using ``pkg_resources`` ============================================================= The ``pkg_resources`` module distributed with ``setuptools`` provides an API for Python libraries to access their resource files, and for extensible applications and frameworks to automatically discover plugins. It also provides runtime support for using C extensions that are inside zipfile-format eggs, support for merging packages that have separately-distributed modules or subpackages, and APIs for managing Python's current "working set" of active packages. Use of ``pkg_resources`` is discouraged in favor of `importlib.resources `_, `importlib.metadata `_, and their backports (`resources `_, `metadata `_). Please consider using those libraries instead of pkg_resources. -------- Overview -------- The ``pkg_resources`` module provides runtime facilities for finding, introspecting, activating and using installed Python distributions. Some of the more advanced features (notably the support for parallel installation of multiple versions) rely specifically on the "egg" format (either as a zip archive or subdirectory), while others (such as plugin discovery) will work correctly so long as "egg-info" metadata directories are available for relevant distributions. Eggs are a distribution format for Python modules, similar in concept to Java's "jars" or Ruby's "gems", or the "wheel" format defined in PEP 427. However, unlike a pure distribution format, eggs can also be installed and added directly to ``sys.path`` as an import location. When installed in this way, eggs are *discoverable*, meaning that they carry metadata that unambiguously identifies their contents and dependencies. This means that an installed egg can be *automatically* found and added to ``sys.path`` in response to simple requests of the form, "get me everything I need to use docutils' PDF support". This feature allows mutually conflicting versions of a distribution to co-exist in the same Python installation, with individual applications activating the desired version at runtime by manipulating the contents of ``sys.path`` (this differs from the virtual environment approach, which involves creating isolated environments for each application). The following terms are needed in order to explain the capabilities offered by this module: project A library, framework, script, plugin, application, or collection of data or other resources, or some combination thereof. Projects are assumed to have "relatively unique" names, e.g. names registered with PyPI. release A snapshot of a project at a particular point in time, denoted by a version identifier. distribution A file or files that represent a particular release. importable distribution A file or directory that, if placed on ``sys.path``, allows Python to import any modules contained within it. pluggable distribution An importable distribution whose filename unambiguously identifies its release (i.e. project and version), and whose contents unambiguously specify what releases of other projects will satisfy its runtime requirements. extra An "extra" is an optional feature of a release, that may impose additional runtime requirements. For example, if docutils PDF support required a PDF support library to be present, docutils could define its PDF support as an "extra", and list what other project releases need to be available in order to provide it. environment A collection of distributions potentially available for importing, but not necessarily active. More than one distribution (i.e. release version) for a given project may be present in an environment. working set A collection of distributions actually available for importing, as on ``sys.path``. At most one distribution (release version) of a given project may be present in a working set, as otherwise there would be ambiguity as to what to import. eggs Eggs are pluggable distributions in one of the three formats currently supported by ``pkg_resources``. There are built eggs, development eggs, and egg links. Built eggs are directories or zipfiles whose name ends with ``.egg`` and follows the egg naming conventions, and contain an ``EGG-INFO`` subdirectory (zipped or otherwise). Development eggs are normal directories of Python code with one or more ``ProjectName.egg-info`` subdirectories. The development egg format is also used to provide a default version of a distribution that is available to software that doesn't use ``pkg_resources`` to request specific versions. Egg links are ``*.egg-link`` files that contain the name of a built or development egg, to support symbolic linking on platforms that do not have native symbolic links (or where the symbolic link support is limited). (For more information about these terms and concepts, see also this `architectural overview`_ of ``pkg_resources`` and Python Eggs in general.) .. _architectural overview: http://mail.python.org/pipermail/distutils-sig/2005-June/004652.html .. ----------------- .. Developer's Guide .. ----------------- .. This section isn't written yet. Currently planned topics include Accessing Resources Finding and Activating Package Distributions get_provider() require() WorkingSet iter_distributions Running Scripts Configuration Namespace Packages Extensible Applications and Frameworks Locating entry points Activation listeners Metadata access Extended Discovery and Installation Supporting Custom PEP 302 Implementations .. For now, please check out the extensive `API Reference`_ below. ------------- API Reference ------------- Namespace Package Support ========================= A namespace package is a package that only contains other packages and modules, with no direct contents of its own. Such packages can be split across multiple, separately-packaged distributions. They are normally used to split up large packages produced by a single organization, such as in the ``zope`` namespace package for Zope Corporation packages, and the ``peak`` namespace package for the Python Enterprise Application Kit. To create a namespace package, you list it in the ``namespace_packages`` argument to ``setup()``, in your project's ``setup.py``. (See the :ref:`setuptools documentation on namespace packages ` for more information on this.) Also, you must add a ``declare_namespace()`` call in the package's ``__init__.py`` file(s): ``declare_namespace(name)`` Declare that the dotted package name ``name`` is a "namespace package" whose contained packages and modules may be spread across multiple distributions. The named package's ``__path__`` will be extended to include the corresponding package in all distributions on ``sys.path`` that contain a package of that name. (More precisely, if an importer's ``find_module(name)`` returns a loader, then it will also be searched for the package's contents.) Whenever a Distribution's ``activate()`` method is invoked, it checks for the presence of namespace packages and updates their ``__path__`` contents accordingly. Applications that manipulate namespace packages or directly alter ``sys.path`` at runtime may also need to use this API function: ``fixup_namespace_packages(path_item)`` Declare that ``path_item`` is a newly added item on ``sys.path`` that may need to be used to update existing namespace packages. Ordinarily, this is called for you when an egg is automatically added to ``sys.path``, but if your application modifies ``sys.path`` to include locations that may contain portions of a namespace package, you will need to call this function to ensure they are added to the existing namespace packages. Although by default ``pkg_resources`` only supports namespace packages for filesystem and zip importers, you can extend its support to other "importers" compatible with PEP 302 using the ``register_namespace_handler()`` function. See the section below on `Supporting Custom Importers`_ for details. ``WorkingSet`` Objects ====================== The ``WorkingSet`` class provides access to a collection of "active" distributions. In general, there is only one meaningful ``WorkingSet`` instance: the one that represents the distributions that are currently active on ``sys.path``. This global instance is available under the name ``working_set`` in the ``pkg_resources`` module. However, specialized tools may wish to manipulate working sets that don't correspond to ``sys.path``, and therefore may wish to create other ``WorkingSet`` instances. It's important to note that the global ``working_set`` object is initialized from ``sys.path`` when ``pkg_resources`` is first imported, but is only updated if you do all future ``sys.path`` manipulation via ``pkg_resources`` APIs. If you manually modify ``sys.path``, you must invoke the appropriate methods on the ``working_set`` instance to keep it in sync. Unfortunately, Python does not provide any way to detect arbitrary changes to a list object like ``sys.path``, so ``pkg_resources`` cannot automatically update the ``working_set`` based on changes to ``sys.path``. ``WorkingSet(entries=None)`` Create a ``WorkingSet`` from an iterable of path entries. If ``entries`` is not supplied, it defaults to the value of ``sys.path`` at the time the constructor is called. Note that you will not normally construct ``WorkingSet`` instances yourself, but instead you will implicitly or explicitly use the global ``working_set`` instance. For the most part, the ``pkg_resources`` API is designed so that the ``working_set`` is used by default, such that you don't have to explicitly refer to it most of the time. All distributions available directly on ``sys.path`` will be activated automatically when ``pkg_resources`` is imported. This behaviour can cause version conflicts for applications which require non-default versions of those distributions. To handle this situation, ``pkg_resources`` checks for a ``__requires__`` attribute in the ``__main__`` module when initializing the default working set, and uses this to ensure a suitable version of each affected distribution is activated. For example:: __requires__ = ["CherryPy < 3"] # Must be set before pkg_resources import import pkg_resources Basic ``WorkingSet`` Methods ---------------------------- The following methods of ``WorkingSet`` objects are also available as module- level functions in ``pkg_resources`` that apply to the default ``working_set`` instance. Thus, you can use e.g. ``pkg_resources.require()`` as an abbreviation for ``pkg_resources.working_set.require()``: ``require(*requirements)`` Ensure that distributions matching ``requirements`` are activated ``requirements`` must be a string or a (possibly-nested) sequence thereof, specifying the distributions and versions required. The return value is a sequence of the distributions that needed to be activated to fulfill the requirements; all relevant distributions are included, even if they were already activated in this working set. For the syntax of requirement specifiers, see the section below on `Requirements Parsing`_. In general, it should not be necessary for you to call this method directly. It's intended more for use in quick-and-dirty scripting and interactive interpreter hacking than for production use. If you're creating an actual library or application, it's strongly recommended that you create a "setup.py" script using ``setuptools``, and declare all your requirements there. That way, tools like pip can automatically detect what requirements your package has, and deal with them accordingly. Note that calling ``require('SomePackage')`` will not install ``SomePackage`` if it isn't already present. If you need to do this, you should use the ``resolve()`` method instead, which allows you to pass an ``installer`` callback that will be invoked when a needed distribution can't be found on the local machine. You can then have this callback display a dialog, automatically download the needed distribution, or whatever else is appropriate for your application. See the documentation below on the ``resolve()`` method for more information, and also on the ``obtain()`` method of ``Environment`` objects. ``run_script(requires, script_name)`` Locate distribution specified by ``requires`` and run its ``script_name`` script. ``requires`` must be a string containing a requirement specifier. (See `Requirements Parsing`_ below for the syntax.) The script, if found, will be executed in *the caller's globals*. That's because this method is intended to be called from wrapper scripts that act as a proxy for the "real" scripts in a distribution. A wrapper script usually doesn't need to do anything but invoke this function with the correct arguments. If you need more control over the script execution environment, you probably want to use the ``run_script()`` method of a ``Distribution`` object's `Metadata API`_ instead. ``iter_entry_points(group, name=None)`` Yield entry point objects from ``group`` matching ``name`` If ``name`` is None, yields all entry points in ``group`` from all distributions in the working set, otherwise only ones matching both ``group`` and ``name`` are yielded. Entry points are yielded from the active distributions in the order that the distributions appear in the working set. (For the global ``working_set``, this should be the same as the order that they are listed in ``sys.path``.) Note that within the entry points advertised by an individual distribution, there is no particular ordering. Please see the section below on `Entry Points`_ for more information. ``WorkingSet`` Methods and Attributes ------------------------------------- These methods are used to query or manipulate the contents of a specific working set, so they must be explicitly invoked on a particular ``WorkingSet`` instance: ``add_entry(entry)`` Add a path item to the ``entries``, finding any distributions on it. You should use this when you add additional items to ``sys.path`` and you want the global ``working_set`` to reflect the change. This method is also called by the ``WorkingSet()`` constructor during initialization. This method uses ``find_distributions(entry,True)`` to find distributions corresponding to the path entry, and then ``add()`` them. ``entry`` is always appended to the ``entries`` attribute, even if it is already present, however. (This is because ``sys.path`` can contain the same value more than once, and the ``entries`` attribute should be able to reflect this.) ``__contains__(dist)`` True if ``dist`` is active in this ``WorkingSet``. Note that only one distribution for a given project can be active in a given ``WorkingSet``. ``__iter__()`` Yield distributions for non-duplicate projects in the working set. The yield order is the order in which the items' path entries were added to the working set. ``find(req)`` Find a distribution matching ``req`` (a ``Requirement`` instance). If there is an active distribution for the requested project, this returns it, as long as it meets the version requirement specified by ``req``. But, if there is an active distribution for the project and it does *not* meet the ``req`` requirement, ``VersionConflict`` is raised. If there is no active distribution for the requested project, ``None`` is returned. ``resolve(requirements, env=None, installer=None)`` List all distributions needed to (recursively) meet ``requirements`` ``requirements`` must be a sequence of ``Requirement`` objects. ``env``, if supplied, should be an ``Environment`` instance. If not supplied, an ``Environment`` is created from the working set's ``entries``. ``installer``, if supplied, will be invoked with each requirement that cannot be met by an already-installed distribution; it should return a ``Distribution`` or ``None``. (See the ``obtain()`` method of `Environment Objects`_, below, for more information on the ``installer`` argument.) ``add(dist, entry=None)`` Add ``dist`` to working set, associated with ``entry`` If ``entry`` is unspecified, it defaults to ``dist.location``. On exit from this routine, ``entry`` is added to the end of the working set's ``.entries`` (if it wasn't already present). ``dist`` is only added to the working set if it's for a project that doesn't already have a distribution active in the set. If it's successfully added, any callbacks registered with the ``subscribe()`` method will be called. (See `Receiving Change Notifications`_, below.) Note: ``add()`` is automatically called for you by the ``require()`` method, so you don't normally need to use this method directly. ``entries`` This attribute represents a "shadow" ``sys.path``, primarily useful for debugging. If you are experiencing import problems, you should check the global ``working_set`` object's ``entries`` against ``sys.path``, to ensure that they match. If they do not, then some part of your program is manipulating ``sys.path`` without updating the ``working_set`` accordingly. IMPORTANT NOTE: do not directly manipulate this attribute! Setting it equal to ``sys.path`` will not fix your problem, any more than putting black tape over an "engine warning" light will fix your car! If this attribute is out of sync with ``sys.path``, it's merely an *indicator* of the problem, not the cause of it. Receiving Change Notifications ------------------------------ Extensible applications and frameworks may need to receive notification when a new distribution (such as a plug-in component) has been added to a working set. This is what the ``subscribe()`` method and ``add_activation_listener()`` function are for. ``subscribe(callback)`` Invoke ``callback(distribution)`` once for each active distribution that is in the set now, or gets added later. Because the callback is invoked for already-active distributions, you do not need to loop over the working set yourself to deal with the existing items; just register the callback and be prepared for the fact that it will be called immediately by this method. Note that callbacks *must not* allow exceptions to propagate, or they will interfere with the operation of other callbacks and possibly result in an inconsistent working set state. Callbacks should use a try/except block to ignore, log, or otherwise process any errors, especially since the code that caused the callback to be invoked is unlikely to be able to handle the errors any better than the callback itself. ``pkg_resources.add_activation_listener()`` is an alternate spelling of ``pkg_resources.working_set.subscribe()``. Locating Plugins ---------------- Extensible applications will sometimes have a "plugin directory" or a set of plugin directories, from which they want to load entry points or other metadata. The ``find_plugins()`` method allows you to do this, by scanning an environment for the newest version of each project that can be safely loaded without conflicts or missing requirements. ``find_plugins(plugin_env, full_env=None, fallback=True)`` Scan ``plugin_env`` and identify which distributions could be added to this working set without version conflicts or missing requirements. Example usage:: distributions, errors = working_set.find_plugins( Environment(plugin_dirlist) ) map(working_set.add, distributions) # add plugins+libs to sys.path print "Couldn't load", errors # display errors The ``plugin_env`` should be an ``Environment`` instance that contains only distributions that are in the project's "plugin directory" or directories. The ``full_env``, if supplied, should be an ``Environment`` instance that contains all currently-available distributions. If ``full_env`` is not supplied, one is created automatically from the ``WorkingSet`` this method is called on, which will typically mean that every directory on ``sys.path`` will be scanned for distributions. This method returns a 2-tuple: (``distributions``, ``error_info``), where ``distributions`` is a list of the distributions found in ``plugin_env`` that were loadable, along with any other distributions that are needed to resolve their dependencies. ``error_info`` is a dictionary mapping unloadable plugin distributions to an exception instance describing the error that occurred. Usually this will be a ``DistributionNotFound`` or ``VersionConflict`` instance. Most applications will use this method mainly on the master ``working_set`` instance in ``pkg_resources``, and then immediately add the returned distributions to the working set so that they are available on sys.path. This will make it possible to find any entry points, and allow any other metadata tracking and hooks to be activated. The resolution algorithm used by ``find_plugins()`` is as follows. First, the project names of the distributions present in ``plugin_env`` are sorted. Then, each project's eggs are tried in descending version order (i.e., newest version first). An attempt is made to resolve each egg's dependencies. If the attempt is successful, the egg and its dependencies are added to the output list and to a temporary copy of the working set. The resolution process continues with the next project name, and no older eggs for that project are tried. If the resolution attempt fails, however, the error is added to the error dictionary. If the ``fallback`` flag is true, the next older version of the plugin is tried, until a working version is found. If false, the resolution process continues with the next plugin project name. Some applications may have stricter fallback requirements than others. For example, an application that has a database schema or persistent objects may not be able to safely downgrade a version of a package. Others may want to ensure that a new plugin configuration is either 100% good or else revert to a known-good configuration. (That is, they may wish to revert to a known configuration if the ``error_info`` return value is non-empty.) Note that this algorithm gives precedence to satisfying the dependencies of alphabetically prior project names in case of version conflicts. If two projects named "AaronsPlugin" and "ZekesPlugin" both need different versions of "TomsLibrary", then "AaronsPlugin" will win and "ZekesPlugin" will be disabled due to version conflict. ``Environment`` Objects ======================= An "environment" is a collection of ``Distribution`` objects, usually ones that are present and potentially importable on the current platform. ``Environment`` objects are used by ``pkg_resources`` to index available distributions during dependency resolution. ``Environment(search_path=None, platform=get_supported_platform(), python=PY_MAJOR)`` Create an environment snapshot by scanning ``search_path`` for distributions compatible with ``platform`` and ``python``. ``search_path`` should be a sequence of strings such as might be used on ``sys.path``. If a ``search_path`` isn't supplied, ``sys.path`` is used. ``platform`` is an optional string specifying the name of the platform that platform-specific distributions must be compatible with. If unspecified, it defaults to the current platform. ``python`` is an optional string naming the desired version of Python (e.g. ``'2.4'``); it defaults to the currently-running version. You may explicitly set ``platform`` (and/or ``python``) to ``None`` if you wish to include *all* distributions, not just those compatible with the running platform or Python version. Note that ``search_path`` is scanned immediately for distributions, and the resulting ``Environment`` is a snapshot of the found distributions. It is not automatically updated if the system's state changes due to e.g. installation or removal of distributions. ``__getitem__(project_name)`` Returns a list of distributions for the given project name, ordered from newest to oldest version. (And highest to lowest format precedence for distributions that contain the same version of the project.) If there are no distributions for the project, returns an empty list. ``__iter__()`` Yield the unique project names of the distributions in this environment. The yielded names are always in lower case. ``add(dist)`` Add ``dist`` to the environment if it matches the platform and python version specified at creation time, and only if the distribution hasn't already been added. (i.e., adding the same distribution more than once is a no-op.) ``remove(dist)`` Remove ``dist`` from the environment. ``can_add(dist)`` Is distribution ``dist`` acceptable for this environment? If it's not compatible with the ``platform`` and ``python`` version values specified when the environment was created, a false value is returned. ``__add__(dist_or_env)`` (``+`` operator) Add a distribution or environment to an ``Environment`` instance, returning a *new* environment object that contains all the distributions previously contained by both. The new environment will have a ``platform`` and ``python`` of ``None``, meaning that it will not reject any distributions from being added to it; it will simply accept whatever is added. If you want the added items to be filtered for platform and Python version, or you want to add them to the *same* environment instance, you should use in-place addition (``+=``) instead. ``__iadd__(dist_or_env)`` (``+=`` operator) Add a distribution or environment to an ``Environment`` instance *in-place*, updating the existing instance and returning it. The ``platform`` and ``python`` filter attributes take effect, so distributions in the source that do not have a suitable platform string or Python version are silently ignored. ``best_match(req, working_set, installer=None)`` Find distribution best matching ``req`` and usable on ``working_set`` This calls the ``find(req)`` method of the ``working_set`` to see if a suitable distribution is already active. (This may raise ``VersionConflict`` if an unsuitable version of the project is already active in the specified ``working_set``.) If a suitable distribution isn't active, this method returns the newest distribution in the environment that meets the ``Requirement`` in ``req``. If no suitable distribution is found, and ``installer`` is supplied, then the result of calling the environment's ``obtain(req, installer)`` method will be returned. ``obtain(requirement, installer=None)`` Obtain a distro that matches requirement (e.g. via download). In the base ``Environment`` class, this routine just returns ``installer(requirement)``, unless ``installer`` is None, in which case None is returned instead. This method is a hook that allows subclasses to attempt other ways of obtaining a distribution before falling back to the ``installer`` argument. ``scan(search_path=None)`` Scan ``search_path`` for distributions usable on ``platform`` Any distributions found are added to the environment. ``search_path`` should be a sequence of strings such as might be used on ``sys.path``. If not supplied, ``sys.path`` is used. Only distributions conforming to the platform/python version defined at initialization are added. This method is a shortcut for using the ``find_distributions()`` function to find the distributions from each item in ``search_path``, and then calling ``add()`` to add each one to the environment. ``Requirement`` Objects ======================= ``Requirement`` objects express what versions of a project are suitable for some purpose. These objects (or their string form) are used by various ``pkg_resources`` APIs in order to find distributions that a script or distribution needs. Requirements Parsing -------------------- ``parse_requirements(s)`` Yield ``Requirement`` objects for a string or iterable of lines. Each requirement must start on a new line. See below for syntax. ``Requirement.parse(s)`` Create a ``Requirement`` object from a string or iterable of lines. A ``ValueError`` is raised if the string or lines do not contain a valid requirement specifier, or if they contain more than one specifier. (To parse multiple specifiers from a string or iterable of strings, use ``parse_requirements()`` instead.) The syntax of a requirement specifier is defined in full in PEP 508. Some examples of valid requirement specifiers:: FooProject >= 1.2 Fizzy [foo, bar] PickyThing>1.6,<=1.9,!=1.8.6 SomethingWhoseVersionIDontCareAbout SomethingWithMarker[foo]>1.0;python_version<"2.7" The project name is the only required portion of a requirement string, and if it's the only thing supplied, the requirement will accept any version of that project. The "extras" in a requirement are used to request optional features of a project, that may require additional project distributions in order to function. For example, if the hypothetical "Report-O-Rama" project offered optional PDF support, it might require an additional library in order to provide that support. Thus, a project needing Report-O-Rama's PDF features could use a requirement of ``Report-O-Rama[PDF]`` to request installation or activation of both Report-O-Rama and any libraries it needs in order to provide PDF support. For example, you could use:: pip install Report-O-Rama[PDF] To install the necessary packages using pip, or call ``pkg_resources.require('Report-O-Rama[PDF]')`` to add the necessary distributions to sys.path at runtime. The "markers" in a requirement are used to specify when a requirement should be installed -- the requirement will be installed if the marker evaluates as true in the current environment. For example, specifying ``argparse;python_version<"3.0"`` will not install in an Python 3 environment, but will in a Python 2 environment. ``Requirement`` Methods and Attributes -------------------------------------- ``__contains__(dist_or_version)`` Return true if ``dist_or_version`` fits the criteria for this requirement. If ``dist_or_version`` is a ``Distribution`` object, its project name must match the requirement's project name, and its version must meet the requirement's version criteria. If ``dist_or_version`` is a string, it is parsed using the ``parse_version()`` utility function. Otherwise, it is assumed to be an already-parsed version. The ``Requirement`` object's version specifiers (``.specs``) are internally sorted into ascending version order, and used to establish what ranges of versions are acceptable. Adjacent redundant conditions are effectively consolidated (e.g. ``">1, >2"`` produces the same results as ``">2"``, and ``"<2,<3"`` produces the same results as ``"<2"``). ``"!="`` versions are excised from the ranges they fall within. The version being tested for acceptability is then checked for membership in the resulting ranges. ``__eq__(other_requirement)`` A requirement compares equal to another requirement if they have case-insensitively equal project names, version specifiers, and "extras". (The order that extras and version specifiers are in is also ignored.) Equal requirements also have equal hashes, so that requirements can be used in sets or as dictionary keys. ``__str__()`` The string form of a ``Requirement`` is a string that, if passed to ``Requirement.parse()``, would return an equal ``Requirement`` object. ``project_name`` The name of the required project ``key`` An all-lowercase version of the ``project_name``, useful for comparison or indexing. ``extras`` A tuple of names of "extras" that this requirement calls for. (These will be all-lowercase and normalized using the ``safe_extra()`` parsing utility function, so they may not exactly equal the extras the requirement was created with.) ``specs`` A list of ``(op,version)`` tuples, sorted in ascending parsed-version order. The ``op`` in each tuple is a comparison operator, represented as a string. The ``version`` is the (unparsed) version number. ``marker`` An instance of ``packaging.markers.Marker`` that allows evaluation against the current environment. May be None if no marker specified. ``url`` The location to download the requirement from if specified. Entry Points ============ Entry points are a simple way for distributions to "advertise" Python objects (such as functions or classes) for use by other distributions. Extensible applications and frameworks can search for entry points with a particular name or group, either from a specific distribution or from all active distributions on sys.path, and then inspect or load the advertised objects at will. Entry points belong to "groups" which are named with a dotted name similar to a Python package or module name. For example, the ``setuptools`` package uses an entry point named ``distutils.commands`` in order to find commands defined by distutils extensions. ``setuptools`` treats the names of entry points defined in that group as the acceptable commands for a setup script. In a similar way, other packages can define their own entry point groups, either using dynamic names within the group (like ``distutils.commands``), or possibly using predefined names within the group. For example, a blogging framework that offers various pre- or post-publishing hooks might define an entry point group and look for entry points named "pre_process" and "post_process" within that group. To advertise an entry point, a project needs to use ``setuptools`` and provide an ``entry_points`` argument to ``setup()`` in its setup script, so that the entry points will be included in the distribution's metadata. For more details, see :ref:`Advertising Behavior`. Each project distribution can advertise at most one entry point of a given name within the same entry point group. For example, a distutils extension could advertise two different ``distutils.commands`` entry points, as long as they had different names. However, there is nothing that prevents *different* projects from advertising entry points of the same name in the same group. In some cases, this is a desirable thing, since the application or framework that uses the entry points may be calling them as hooks, or in some other way combining them. It is up to the application or framework to decide what to do if multiple distributions advertise an entry point; some possibilities include using both entry points, displaying an error message, using the first one found in sys.path order, etc. Convenience API --------------- In the following functions, the ``dist`` argument can be a ``Distribution`` instance, a ``Requirement`` instance, or a string specifying a requirement (i.e. project name, version, etc.). If the argument is a string or ``Requirement``, the specified distribution is located (and added to sys.path if not already present). An error will be raised if a matching distribution is not available. The ``group`` argument should be a string containing a dotted identifier, identifying an entry point group. If you are defining an entry point group, you should include some portion of your package's name in the group name so as to avoid collision with other packages' entry point groups. ``load_entry_point(dist, group, name)`` Load the named entry point from the specified distribution, or raise ``ImportError``. ``get_entry_info(dist, group, name)`` Return an ``EntryPoint`` object for the given ``group`` and ``name`` from the specified distribution. Returns ``None`` if the distribution has not advertised a matching entry point. ``get_entry_map(dist, group=None)`` Return the distribution's entry point map for ``group``, or the full entry map for the distribution. This function always returns a dictionary, even if the distribution advertises no entry points. If ``group`` is given, the dictionary maps entry point names to the corresponding ``EntryPoint`` object. If ``group`` is None, the dictionary maps group names to dictionaries that then map entry point names to the corresponding ``EntryPoint`` instance in that group. ``iter_entry_points(group, name=None)`` Yield entry point objects from ``group`` matching ``name``. If ``name`` is None, yields all entry points in ``group`` from all distributions in the working set on sys.path, otherwise only ones matching both ``group`` and ``name`` are yielded. Entry points are yielded from the active distributions in the order that the distributions appear on sys.path. (Within entry points for a particular distribution, however, there is no particular ordering.) (This API is actually a method of the global ``working_set`` object; see the section above on `Basic WorkingSet Methods`_ for more information.) Creating and Parsing -------------------- ``EntryPoint(name, module_name, attrs=(), extras=(), dist=None)`` Create an ``EntryPoint`` instance. ``name`` is the entry point name. The ``module_name`` is the (dotted) name of the module containing the advertised object. ``attrs`` is an optional tuple of names to look up from the module to obtain the advertised object. For example, an ``attrs`` of ``("foo","bar")`` and a ``module_name`` of ``"baz"`` would mean that the advertised object could be obtained by the following code:: import baz advertised_object = baz.foo.bar The ``extras`` are an optional tuple of "extra feature" names that the distribution needs in order to provide this entry point. When the entry point is loaded, these extra features are looked up in the ``dist`` argument to find out what other distributions may need to be activated on sys.path; see the ``load()`` method for more details. The ``extras`` argument is only meaningful if ``dist`` is specified. ``dist`` must be a ``Distribution`` instance. ``EntryPoint.parse(src, dist=None)`` (classmethod) Parse a single entry point from string ``src`` Entry point syntax follows the form:: name = some.module:some.attr [extra1,extra2] The entry name and module name are required, but the ``:attrs`` and ``[extras]`` parts are optional, as is the whitespace shown between some of the items. The ``dist`` argument is passed through to the ``EntryPoint()`` constructor, along with the other values parsed from ``src``. ``EntryPoint.parse_group(group, lines, dist=None)`` (classmethod) Parse ``lines`` (a string or sequence of lines) to create a dictionary mapping entry point names to ``EntryPoint`` objects. ``ValueError`` is raised if entry point names are duplicated, if ``group`` is not a valid entry point group name, or if there are any syntax errors. (Note: the ``group`` parameter is used only for validation and to create more informative error messages.) If ``dist`` is provided, it will be used to set the ``dist`` attribute of the created ``EntryPoint`` objects. ``EntryPoint.parse_map(data, dist=None)`` (classmethod) Parse ``data`` into a dictionary mapping group names to dictionaries mapping entry point names to ``EntryPoint`` objects. If ``data`` is a dictionary, then the keys are used as group names and the values are passed to ``parse_group()`` as the ``lines`` argument. If ``data`` is a string or sequence of lines, it is first split into .ini-style sections (using the ``split_sections()`` utility function) and the section names are used as group names. In either case, the ``dist`` argument is passed through to ``parse_group()`` so that the entry points will be linked to the specified distribution. ``EntryPoint`` Objects ---------------------- For simple introspection, ``EntryPoint`` objects have attributes that correspond exactly to the constructor argument names: ``name``, ``module_name``, ``attrs``, ``extras``, and ``dist`` are all available. In addition, the following methods are provided: ``load()`` Load the entry point, returning the advertised Python object. Effectively calls ``self.require()`` then returns ``self.resolve()``. ``require(env=None, installer=None)`` Ensure that any "extras" needed by the entry point are available on sys.path. ``UnknownExtra`` is raised if the ``EntryPoint`` has ``extras``, but no ``dist``, or if the named extras are not defined by the distribution. If ``env`` is supplied, it must be an ``Environment``, and it will be used to search for needed distributions if they are not already present on sys.path. If ``installer`` is supplied, it must be a callable taking a ``Requirement`` instance and returning a matching importable ``Distribution`` instance or None. ``resolve()`` Resolve the entry point from its module and attrs, returning the advertised Python object. Raises ``ImportError`` if it cannot be obtained. ``__str__()`` The string form of an ``EntryPoint`` is a string that could be passed to ``EntryPoint.parse()`` to produce an equivalent ``EntryPoint``. ``Distribution`` Objects ======================== ``Distribution`` objects represent collections of Python code that may or may not be importable, and may or may not have metadata and resources associated with them. Their metadata may include information such as what other projects the distribution depends on, what entry points the distribution advertises, and so on. Getting or Creating Distributions --------------------------------- Most commonly, you'll obtain ``Distribution`` objects from a ``WorkingSet`` or an ``Environment``. (See the sections above on `WorkingSet Objects`_ and `Environment Objects`_, which are containers for active distributions and available distributions, respectively.) You can also obtain ``Distribution`` objects from one of these high-level APIs: ``find_distributions(path_item, only=False)`` Yield distributions accessible via ``path_item``. If ``only`` is true, yield only distributions whose ``location`` is equal to ``path_item``. In other words, if ``only`` is true, this yields any distributions that would be importable if ``path_item`` were on ``sys.path``. If ``only`` is false, this also yields distributions that are "in" or "under" ``path_item``, but would not be importable unless their locations were also added to ``sys.path``. ``get_distribution(dist_spec)`` Return a ``Distribution`` object for a given ``Requirement`` or string. If ``dist_spec`` is already a ``Distribution`` instance, it is returned. If it is a ``Requirement`` object or a string that can be parsed into one, it is used to locate and activate a matching distribution, which is then returned. However, if you're creating specialized tools for working with distributions, or creating a new distribution format, you may also need to create ``Distribution`` objects directly, using one of the three constructors below. These constructors all take an optional ``metadata`` argument, which is used to access any resources or metadata associated with the distribution. ``metadata`` must be an object that implements the ``IResourceProvider`` interface, or None. If it is None, an ``EmptyProvider`` is used instead. ``Distribution`` objects implement both the `IResourceProvider`_ and `IMetadataProvider Methods`_ by delegating them to the ``metadata`` object. ``Distribution.from_location(location, basename, metadata=None, **kw)`` (classmethod) Create a distribution for ``location``, which must be a string such as a URL, filename, or other string that might be used on ``sys.path``. ``basename`` is a string naming the distribution, like ``Foo-1.2-py2.4.egg``. If ``basename`` ends with ``.egg``, then the project's name, version, python version and platform are extracted from the filename and used to set those properties of the created distribution. Any additional keyword arguments are forwarded to the ``Distribution()`` constructor. ``Distribution.from_filename(filename, metadata=None**kw)`` (classmethod) Create a distribution by parsing a local filename. This is a shorter way of saying ``Distribution.from_location(normalize_path(filename), os.path.basename(filename), metadata)``. In other words, it creates a distribution whose location is the normalize form of the filename, parsing name and version information from the base portion of the filename. Any additional keyword arguments are forwarded to the ``Distribution()`` constructor. ``Distribution(location,metadata,project_name,version,py_version,platform,precedence)`` Create a distribution by setting its properties. All arguments are optional and default to None, except for ``py_version`` (which defaults to the current Python version) and ``precedence`` (which defaults to ``EGG_DIST``; for more details see ``precedence`` under `Distribution Attributes`_ below). Note that it's usually easier to use the ``from_filename()`` or ``from_location()`` constructors than to specify all these arguments individually. ``Distribution`` Attributes --------------------------- location A string indicating the distribution's location. For an importable distribution, this is the string that would be added to ``sys.path`` to make it actively importable. For non-importable distributions, this is simply a filename, URL, or other way of locating the distribution. project_name A string, naming the project that this distribution is for. Project names are defined by a project's setup script, and they are used to identify projects on PyPI. When a ``Distribution`` is constructed, the ``project_name`` argument is passed through the ``safe_name()`` utility function to filter out any unacceptable characters. key ``dist.key`` is short for ``dist.project_name.lower()``. It's used for case-insensitive comparison and indexing of distributions by project name. extras A list of strings, giving the names of extra features defined by the project's dependency list (the ``extras_require`` argument specified in the project's setup script). version A string denoting what release of the project this distribution contains. When a ``Distribution`` is constructed, the ``version`` argument is passed through the ``safe_version()`` utility function to filter out any unacceptable characters. If no ``version`` is specified at construction time, then attempting to access this attribute later will cause the ``Distribution`` to try to discover its version by reading its ``PKG-INFO`` metadata file. If ``PKG-INFO`` is unavailable or can't be parsed, ``ValueError`` is raised. parsed_version The ``parsed_version`` is an object representing a "parsed" form of the distribution's ``version``. ``dist.parsed_version`` is a shortcut for calling ``parse_version(dist.version)``. It is used to compare or sort distributions by version. (See the `Parsing Utilities`_ section below for more information on the ``parse_version()`` function.) Note that accessing ``parsed_version`` may result in a ``ValueError`` if the ``Distribution`` was constructed without a ``version`` and without ``metadata`` capable of supplying the missing version info. py_version The major/minor Python version the distribution supports, as a string. For example, "2.7" or "3.4". The default is the current version of Python. platform A string representing the platform the distribution is intended for, or ``None`` if the distribution is "pure Python" and therefore cross-platform. See `Platform Utilities`_ below for more information on platform strings. precedence A distribution's ``precedence`` is used to determine the relative order of two distributions that have the same ``project_name`` and ``parsed_version``. The default precedence is ``pkg_resources.EGG_DIST``, which is the highest (i.e. most preferred) precedence. The full list of predefined precedences, from most preferred to least preferred, is: ``EGG_DIST``, ``BINARY_DIST``, ``SOURCE_DIST``, ``CHECKOUT_DIST``, and ``DEVELOP_DIST``. Normally, precedences other than ``EGG_DIST`` are used only by the ``setuptools.package_index`` module, when sorting distributions found in a package index to determine their suitability for installation. "System" and "Development" eggs (i.e., ones that use the ``.egg-info`` format), however, are automatically given a precedence of ``DEVELOP_DIST``. ``Distribution`` Methods ------------------------ ``activate(path=None)`` Ensure distribution is importable on ``path``. If ``path`` is None, ``sys.path`` is used instead. This ensures that the distribution's ``location`` is in the ``path`` list, and it also performs any necessary namespace package fixups or declarations. (That is, if the distribution contains namespace packages, this method ensures that they are declared, and that the distribution's contents for those namespace packages are merged with the contents provided by any other active distributions. See the section above on `Namespace Package Support`_ for more information.) ``pkg_resources`` adds a notification callback to the global ``working_set`` that ensures this method is called whenever a distribution is added to it. Therefore, you should not normally need to explicitly call this method. (Note that this means that namespace packages on ``sys.path`` are always imported as soon as ``pkg_resources`` is, which is another reason why namespace packages should not contain any code or import statements.) ``as_requirement()`` Return a ``Requirement`` instance that matches this distribution's project name and version. ``requires(extras=())`` List the ``Requirement`` objects that specify this distribution's dependencies. If ``extras`` is specified, it should be a sequence of names of "extras" defined by the distribution, and the list returned will then include any dependencies needed to support the named "extras". ``clone(**kw)`` Create a copy of the distribution. Any supplied keyword arguments override the corresponding argument to the ``Distribution()`` constructor, allowing you to change some of the copied distribution's attributes. ``egg_name()`` Return what this distribution's standard filename should be, not including the ".egg" extension. For example, a distribution for project "Foo" version 1.2 that runs on Python 2.3 for Windows would have an ``egg_name()`` of ``Foo-1.2-py2.3-win32``. Any dashes in the name or version are converted to underscores. (``Distribution.from_location()`` will convert them back when parsing a ".egg" file name.) ``__cmp__(other)``, ``__hash__()`` Distribution objects are hashed and compared on the basis of their parsed version and precedence, followed by their key (lowercase project name), location, Python version, and platform. The following methods are used to access ``EntryPoint`` objects advertised by the distribution. See the section above on `Entry Points`_ for more detailed information about these operations: ``get_entry_info(group, name)`` Return the ``EntryPoint`` object for ``group`` and ``name``, or None if no such point is advertised by this distribution. ``get_entry_map(group=None)`` Return the entry point map for ``group``. If ``group`` is None, return a dictionary mapping group names to entry point maps for all groups. (An entry point map is a dictionary of entry point names to ``EntryPoint`` objects.) ``load_entry_point(group, name)`` Short for ``get_entry_info(group, name).load()``. Returns the object advertised by the named entry point, or raises ``ImportError`` if the entry point isn't advertised by this distribution, or there is some other import problem. In addition to the above methods, ``Distribution`` objects also implement all of the `IResourceProvider`_ and `IMetadataProvider Methods`_ (which are documented in later sections): * ``has_metadata(name)`` * ``metadata_isdir(name)`` * ``metadata_listdir(name)`` * ``get_metadata(name)`` * ``get_metadata_lines(name)`` * ``run_script(script_name, namespace)`` * ``get_resource_filename(manager, resource_name)`` * ``get_resource_stream(manager, resource_name)`` * ``get_resource_string(manager, resource_name)`` * ``has_resource(resource_name)`` * ``resource_isdir(resource_name)`` * ``resource_listdir(resource_name)`` If the distribution was created with a ``metadata`` argument, these resource and metadata access methods are all delegated to that ``metadata`` provider. Otherwise, they are delegated to an ``EmptyProvider``, so that the distribution will appear to have no resources or metadata. This delegation approach is used so that supporting custom importers or new distribution formats can be done simply by creating an appropriate `IResourceProvider`_ implementation; see the section below on `Supporting Custom Importers`_ for more details. .. _ResourceManager API: ``ResourceManager`` API ======================= The ``ResourceManager`` class provides uniform access to package resources, whether those resources exist as files and directories or are compressed in an archive of some kind. Normally, you do not need to create or explicitly manage ``ResourceManager`` instances, as the ``pkg_resources`` module creates a global instance for you, and makes most of its methods available as top-level names in the ``pkg_resources`` module namespace. So, for example, this code actually calls the ``resource_string()`` method of the global ``ResourceManager``:: import pkg_resources my_data = pkg_resources.resource_string(__name__, "foo.dat") Thus, you can use the APIs below without needing an explicit ``ResourceManager`` instance; just import and use them as needed. Basic Resource Access --------------------- In the following methods, the ``package_or_requirement`` argument may be either a Python package/module name (e.g. ``foo.bar``) or a ``Requirement`` instance. If it is a package or module name, the named module or package must be importable (i.e., be in a distribution or directory on ``sys.path``), and the ``resource_name`` argument is interpreted relative to the named package. (Note that if a module name is used, then the resource name is relative to the package immediately containing the named module. Also, you should not use use a namespace package name, because a namespace package can be spread across multiple distributions, and is therefore ambiguous as to which distribution should be searched for the resource.) If it is a ``Requirement``, then the requirement is automatically resolved (searching the current ``Environment`` if necessary) and a matching distribution is added to the ``WorkingSet`` and ``sys.path`` if one was not already present. (Unless the ``Requirement`` can't be satisfied, in which case an exception is raised.) The ``resource_name`` argument is then interpreted relative to the root of the identified distribution; i.e. its first path segment will be treated as a peer of the top-level modules or packages in the distribution. Note that resource names must be ``/``-separated paths rooted at the package, cannot contain relative names like ``".."``, and cannot be absolute. Do *not* use ``os.path`` routines to manipulate resource paths, as they are *not* filesystem paths. ``resource_exists(package_or_requirement, resource_name)`` Does the named resource exist? Return ``True`` or ``False`` accordingly. ``resource_stream(package_or_requirement, resource_name)`` Return a readable file-like object for the specified resource; it may be an actual file, a ``StringIO``, or some similar object. The stream is in "binary mode", in the sense that whatever bytes are in the resource will be read as-is. ``resource_string(package_or_requirement, resource_name)`` Return the specified resource as ``bytes``. The resource is read in binary fashion, such that the returned string contains exactly the bytes that are stored in the resource. ``resource_isdir(package_or_requirement, resource_name)`` Is the named resource a directory? Return ``True`` or ``False`` accordingly. ``resource_listdir(package_or_requirement, resource_name)`` List the contents of the named resource directory, just like ``os.listdir`` except that it works even if the resource is in a zipfile. Note that only ``resource_exists()`` and ``resource_isdir()`` are insensitive as to the resource type. You cannot use ``resource_listdir()`` on a file resource, and you can't use ``resource_string()`` or ``resource_stream()`` on directory resources. Using an inappropriate method for the resource type may result in an exception or undefined behavior, depending on the platform and distribution format involved. Resource Extraction ------------------- ``resource_filename(package_or_requirement, resource_name)`` Sometimes, it is not sufficient to access a resource in string or stream form, and a true filesystem filename is needed. In such cases, you can use this method (or module-level function) to obtain a filename for a resource. If the resource is in an archive distribution (such as a zipped egg), it will be extracted to a cache directory, and the filename within the cache will be returned. If the named resource is a directory, then all resources within that directory (including subdirectories) are also extracted. If the named resource is a C extension or "eager resource" (see the ``setuptools`` documentation for details), then all C extensions and eager resources are extracted at the same time. Archived resources are extracted to a cache location that can be managed by the following two methods: ``set_extraction_path(path)`` Set the base path where resources will be extracted to, if needed. If you do not call this routine before any extractions take place, the path defaults to the return value of ``get_default_cache()``. (Which is based on the ``PYTHON_EGG_CACHE`` environment variable, with various platform-specific fallbacks. See that routine's documentation for more details.) Resources are extracted to subdirectories of this path based upon information given by the resource provider. You may set this to a temporary directory, but then you must call ``cleanup_resources()`` to delete the extracted files when done. There is no guarantee that ``cleanup_resources()`` will be able to remove all extracted files. (On Windows, for example, you can't unlink .pyd or .dll files that are still in use.) Note that you may not change the extraction path for a given resource manager once resources have been extracted, unless you first call ``cleanup_resources()``. ``cleanup_resources(force=False)`` Delete all extracted resource files and directories, returning a list of the file and directory names that could not be successfully removed. This function does not have any concurrency protection, so it should generally only be called when the extraction path is a temporary directory exclusive to a single process. This method is not automatically called; you must call it explicitly or register it as an ``atexit`` function if you wish to ensure cleanup of a temporary directory used for extractions. "Provider" Interface -------------------- If you are implementing an ``IResourceProvider`` and/or ``IMetadataProvider`` for a new distribution archive format, you may need to use the following ``IResourceManager`` methods to coordinate extraction of resources to the filesystem. If you're not implementing an archive format, however, you have no need to use these methods. Unlike the other methods listed above, they are *not* available as top-level functions tied to the global ``ResourceManager``; you must therefore have an explicit ``ResourceManager`` instance to use them. ``get_cache_path(archive_name, names=())`` Return absolute location in cache for ``archive_name`` and ``names`` The parent directory of the resulting path will be created if it does not already exist. ``archive_name`` should be the base filename of the enclosing egg (which may not be the name of the enclosing zipfile!), including its ".egg" extension. ``names``, if provided, should be a sequence of path name parts "under" the egg's extraction location. This method should only be called by resource providers that need to obtain an extraction location, and only for names they intend to extract, as it tracks the generated names for possible cleanup later. ``extraction_error()`` Raise an ``ExtractionError`` describing the active exception as interfering with the extraction process. You should call this if you encounter any OS errors extracting the file to the cache path; it will format the operating system exception for you, and add other information to the ``ExtractionError`` instance that may be needed by programs that want to wrap or handle extraction errors themselves. ``postprocess(tempname, filename)`` Perform any platform-specific postprocessing of ``tempname``. Resource providers should call this method ONLY after successfully extracting a compressed resource. They must NOT call it on resources that are already in the filesystem. ``tempname`` is the current (temporary) name of the file, and ``filename`` is the name it will be renamed to by the caller after this routine returns. Metadata API ============ The metadata API is used to access metadata resources bundled in a pluggable distribution. Metadata resources are virtual files or directories containing information about the distribution, such as might be used by an extensible application or framework to connect "plugins". Like other kinds of resources, metadata resource names are ``/``-separated and should not contain ``..`` or begin with a ``/``. You should not use ``os.path`` routines to manipulate resource paths. The metadata API is provided by objects implementing the ``IMetadataProvider`` or ``IResourceProvider`` interfaces. ``Distribution`` objects implement this interface, as do objects returned by the ``get_provider()`` function: ``get_provider(package_or_requirement)`` If a package name is supplied, return an ``IResourceProvider`` for the package. If a ``Requirement`` is supplied, resolve it by returning a ``Distribution`` from the current working set (searching the current ``Environment`` if necessary and adding the newly found ``Distribution`` to the working set). If the named package can't be imported, or the ``Requirement`` can't be satisfied, an exception is raised. NOTE: if you use a package name rather than a ``Requirement``, the object you get back may not be a pluggable distribution, depending on the method by which the package was installed. In particular, "development" packages and "single-version externally-managed" packages do not have any way to map from a package name to the corresponding project's metadata. Do not write code that passes a package name to ``get_provider()`` and then tries to retrieve project metadata from the returned object. It may appear to work when the named package is in an ``.egg`` file or directory, but it will fail in other installation scenarios. If you want project metadata, you need to ask for a *project*, not a package. ``IMetadataProvider`` Methods ----------------------------- The methods provided by objects (such as ``Distribution`` instances) that implement the ``IMetadataProvider`` or ``IResourceProvider`` interfaces are: ``has_metadata(name)`` Does the named metadata resource exist? ``metadata_isdir(name)`` Is the named metadata resource a directory? ``metadata_listdir(name)`` List of metadata names in the directory (like ``os.listdir()``) ``get_metadata(name)`` Return the named metadata resource as a string. The data is read in binary mode; i.e., the exact bytes of the resource file are returned. ``get_metadata_lines(name)`` Yield named metadata resource as list of non-blank non-comment lines. This is short for calling ``yield_lines(provider.get_metadata(name))``. See the section on `yield_lines()`_ below for more information on the syntax it recognizes. ``run_script(script_name, namespace)`` Execute the named script in the supplied namespace dictionary. Raises ``ResolutionError`` if there is no script by that name in the ``scripts`` metadata directory. ``namespace`` should be a Python dictionary, usually a module dictionary if the script is being run as a module. Exceptions ========== ``pkg_resources`` provides a simple exception hierarchy for problems that may occur when processing requests to locate and activate packages:: ResolutionError DistributionNotFound VersionConflict UnknownExtra ExtractionError ``ResolutionError`` This class is used as a base class for the other three exceptions, so that you can catch all of them with a single "except" clause. It is also raised directly for miscellaneous requirement-resolution problems like trying to run a script that doesn't exist in the distribution it was requested from. ``DistributionNotFound`` A distribution needed to fulfill a requirement could not be found. ``VersionConflict`` The requested version of a project conflicts with an already-activated version of the same project. ``UnknownExtra`` One of the "extras" requested was not recognized by the distribution it was requested from. ``ExtractionError`` A problem occurred extracting a resource to the Python Egg cache. The following attributes are available on instances of this exception: manager The resource manager that raised this exception cache_path The base directory for resource extraction original_error The exception instance that caused extraction to fail Supporting Custom Importers =========================== By default, ``pkg_resources`` supports normal filesystem imports, and ``zipimport`` importers. If you wish to use the ``pkg_resources`` features with other (PEP 302-compatible) importers or module loaders, you may need to register various handlers and support functions using these APIs: ``register_finder(importer_type, distribution_finder)`` Register ``distribution_finder`` to find distributions in ``sys.path`` items. ``importer_type`` is the type or class of a PEP 302 "Importer" (``sys.path`` item handler), and ``distribution_finder`` is a callable that, when passed a path item, the importer instance, and an ``only`` flag, yields ``Distribution`` instances found under that path item. (The ``only`` flag, if true, means the finder should yield only ``Distribution`` objects whose ``location`` is equal to the path item provided.) See the source of the ``pkg_resources.find_on_path`` function for an example finder function. ``register_loader_type(loader_type, provider_factory)`` Register ``provider_factory`` to make ``IResourceProvider`` objects for ``loader_type``. ``loader_type`` is the type or class of a PEP 302 ``module.__loader__``, and ``provider_factory`` is a function that, when passed a module object, returns an `IResourceProvider`_ for that module, allowing it to be used with the `ResourceManager API`_. ``register_namespace_handler(importer_type, namespace_handler)`` Register ``namespace_handler`` to declare namespace packages for the given ``importer_type``. ``importer_type`` is the type or class of a PEP 302 "importer" (sys.path item handler), and ``namespace_handler`` is a callable with a signature like this:: def namespace_handler(importer, path_entry, moduleName, module): # return a path_entry to use for child packages Namespace handlers are only called if the relevant importer object has already agreed that it can handle the relevant path item. The handler should only return a subpath if the module ``__path__`` does not already contain an equivalent subpath. Otherwise, it should return None. For an example namespace handler, see the source of the ``pkg_resources.file_ns_handler`` function, which is used for both zipfile importing and regular importing. IResourceProvider ----------------- ``IResourceProvider`` is an abstract class that documents what methods are required of objects returned by a ``provider_factory`` registered with ``register_loader_type()``. ``IResourceProvider`` is a subclass of ``IMetadataProvider``, so objects that implement this interface must also implement all of the `IMetadataProvider Methods`_ as well as the methods shown here. The ``manager`` argument to the methods below must be an object that supports the full `ResourceManager API`_ documented above. ``get_resource_filename(manager, resource_name)`` Return a true filesystem path for ``resource_name``, coordinating the extraction with ``manager``, if the resource must be unpacked to the filesystem. ``get_resource_stream(manager, resource_name)`` Return a readable file-like object for ``resource_name``. ``get_resource_string(manager, resource_name)`` Return a string containing the contents of ``resource_name``. ``has_resource(resource_name)`` Does the package contain the named resource? ``resource_isdir(resource_name)`` Is the named resource a directory? Return a false value if the resource does not exist or is not a directory. ``resource_listdir(resource_name)`` Return a list of the contents of the resource directory, ala ``os.listdir()``. Requesting the contents of a non-existent directory may raise an exception. Note, by the way, that your provider classes need not (and should not) subclass ``IResourceProvider`` or ``IMetadataProvider``! These classes exist solely for documentation purposes and do not provide any useful implementation code. You may instead wish to subclass one of the `built-in resource providers`_. Built-in Resource Providers --------------------------- ``pkg_resources`` includes several provider classes that are automatically used where appropriate. Their inheritance tree looks like this:: NullProvider EggProvider DefaultProvider PathMetadata ZipProvider EggMetadata EmptyProvider FileMetadata ``NullProvider`` This provider class is just an abstract base that provides for common provider behaviors (such as running scripts), given a definition for just a few abstract methods. ``EggProvider`` This provider class adds in some egg-specific features that are common to zipped and unzipped eggs. ``DefaultProvider`` This provider class is used for unpacked eggs and "plain old Python" filesystem modules. ``ZipProvider`` This provider class is used for all zipped modules, whether they are eggs or not. ``EmptyProvider`` This provider class always returns answers consistent with a provider that has no metadata or resources. ``Distribution`` objects created without a ``metadata`` argument use an instance of this provider class instead. Since all ``EmptyProvider`` instances are equivalent, there is no need to have more than one instance. ``pkg_resources`` therefore creates a global instance of this class under the name ``empty_provider``, and you may use it if you have need of an ``EmptyProvider`` instance. ``PathMetadata(path, egg_info)`` Create an ``IResourceProvider`` for a filesystem-based distribution, where ``path`` is the filesystem location of the importable modules, and ``egg_info`` is the filesystem location of the distribution's metadata directory. ``egg_info`` should usually be the ``EGG-INFO`` subdirectory of ``path`` for an "unpacked egg", and a ``ProjectName.egg-info`` subdirectory of ``path`` for a "development egg". However, other uses are possible for custom purposes. ``EggMetadata(zipimporter)`` Create an ``IResourceProvider`` for a zipfile-based distribution. The ``zipimporter`` should be a ``zipimport.zipimporter`` instance, and may represent a "basket" (a zipfile containing multiple ".egg" subdirectories) a specific egg *within* a basket, or a zipfile egg (where the zipfile itself is a ".egg"). It can also be a combination, such as a zipfile egg that also contains other eggs. ``FileMetadata(path_to_pkg_info)`` Create an ``IResourceProvider`` that provides exactly one metadata resource: ``PKG-INFO``. The supplied path should be a distutils PKG-INFO file. This is basically the same as an ``EmptyProvider``, except that requests for ``PKG-INFO`` will be answered using the contents of the designated file. (This provider is used to wrap ``.egg-info`` files installed by vendor-supplied system packages.) Utility Functions ================= In addition to its high-level APIs, ``pkg_resources`` also includes several generally-useful utility routines. These routines are used to implement the high-level APIs, but can also be quite useful by themselves. Parsing Utilities ----------------- ``parse_version(version)`` Parsed a project's version string as defined by PEP 440. The returned value will be an object that represents the version. These objects may be compared to each other and sorted. The sorting algorithm is as defined by PEP 440 with the addition that any version which is not a valid PEP 440 version will be considered less than any valid PEP 440 version and the invalid versions will continue sorting using the original algorithm. .. _yield_lines(): ``yield_lines(strs)`` Yield non-empty/non-comment lines from a string/unicode or a possibly- nested sequence thereof. If ``strs`` is an instance of ``basestring``, it is split into lines, and each non-blank, non-comment line is yielded after stripping leading and trailing whitespace. (Lines whose first non-blank character is ``#`` are considered comment lines.) If ``strs`` is not an instance of ``basestring``, it is iterated over, and each item is passed recursively to ``yield_lines()``, so that an arbitrarily nested sequence of strings, or sequences of sequences of strings can be flattened out to the lines contained therein. So for example, passing a file object or a list of strings to ``yield_lines`` will both work. (Note that between each string in a sequence of strings there is assumed to be an implicit line break, so lines cannot bridge two strings in a sequence.) This routine is used extensively by ``pkg_resources`` to parse metadata and file formats of various kinds, and most other ``pkg_resources`` parsing functions that yield multiple values will use it to break up their input. However, this routine is idempotent, so calling ``yield_lines()`` on the output of another call to ``yield_lines()`` is completely harmless. ``split_sections(strs)`` Split a string (or possibly-nested iterable thereof), yielding ``(section, content)`` pairs found using an ``.ini``-like syntax. Each ``section`` is a whitespace-stripped version of the section name ("``[section]``") and each ``content`` is a list of stripped lines excluding blank lines and comment-only lines. If there are any non-blank, non-comment lines before the first section header, they're yielded in a first ``section`` of ``None``. This routine uses ``yield_lines()`` as its front end, so you can pass in anything that ``yield_lines()`` accepts, such as an open text file, string, or sequence of strings. ``ValueError`` is raised if a malformed section header is found (i.e. a line starting with ``[`` but not ending with ``]``). Note that this simplistic parser assumes that any line whose first nonblank character is ``[`` is a section heading, so it can't support .ini format variations that allow ``[`` as the first nonblank character on other lines. ``safe_name(name)`` Return a "safe" form of a project's name, suitable for use in a ``Requirement`` string, as a distribution name, or a PyPI project name. All non-alphanumeric runs are condensed to single "-" characters, such that a name like "The $$$ Tree" becomes "The-Tree". Note that if you are generating a filename from this value you should combine it with a call to ``to_filename()`` so all dashes ("-") are replaced by underscores ("_"). See ``to_filename()``. ``safe_version(version)`` This will return the normalized form of any PEP 440 version. If the version string is not PEP 440 compatible, this function behaves similar to ``safe_name()`` except that spaces in the input become dots, and dots are allowed to exist in the output. As with ``safe_name()``, if you are generating a filename from this you should replace any "-" characters in the output with underscores. ``safe_extra(extra)`` Return a "safe" form of an extra's name, suitable for use in a requirement string or a setup script's ``extras_require`` keyword. This routine is similar to ``safe_name()`` except that non-alphanumeric runs are replaced by a single underbar (``_``), and the result is lowercased. ``to_filename(name_or_version)`` Escape a name or version string so it can be used in a dash-separated filename (or ``#egg=name-version`` tag) without ambiguity. You should only pass in values that were returned by ``safe_name()`` or ``safe_version()``. Platform Utilities ------------------ ``get_build_platform()`` Return this platform's identifier string. For Windows, the return value is ``"win32"``, and for macOS it is a string of the form ``"macosx-10.4-ppc"``. All other platforms return the same uname-based string that the ``distutils.util.get_platform()`` function returns. This string is the minimum platform version required by distributions built on the local machine. (Backward compatibility note: setuptools versions prior to 0.6b1 called this function ``get_platform()``, and the function is still available under that name for backward compatibility reasons.) ``get_supported_platform()`` (New in 0.6b1) This is the similar to ``get_build_platform()``, but is the maximum platform version that the local machine supports. You will usually want to use this value as the ``provided`` argument to the ``compatible_platforms()`` function. ``compatible_platforms(provided, required)`` Return true if a distribution built on the ``provided`` platform may be used on the ``required`` platform. If either platform value is ``None``, it is considered a wildcard, and the platforms are therefore compatible. Likewise, if the platform strings are equal, they're also considered compatible, and ``True`` is returned. Currently, the only non-equal platform strings that are considered compatible are macOS platform strings with the same hardware type (e.g. ``ppc``) and major version (e.g. ``10``) with the ``provided`` platform's minor version being less than or equal to the ``required`` platform's minor version. ``get_default_cache()`` Determine the default cache location for extracting resources from zipped eggs. This routine returns the ``PYTHON_EGG_CACHE`` environment variable, if set. Otherwise, on Windows, it returns a "Python-Eggs" subdirectory of the user's "Application Data" directory. On all other systems, it returns ``os.path.expanduser("~/.python-eggs")`` if ``PYTHON_EGG_CACHE`` is not set. PEP 302 Utilities ----------------- ``get_importer(path_item)`` A deprecated alias for ``pkgutil.get_importer()`` File/Path Utilities ------------------- ``ensure_directory(path)`` Ensure that the parent directory (``os.path.dirname``) of ``path`` actually exists, using ``os.makedirs()`` if necessary. ``normalize_path(path)`` Return a "normalized" version of ``path``, such that two paths represent the same filesystem location if they have equal ``normalized_path()`` values. Specifically, this is a shortcut for calling ``os.path.realpath`` and ``os.path.normcase`` on ``path``. Unfortunately, on certain platforms (notably Cygwin and macOS) the ``normcase`` function does not accurately reflect the platform's case-sensitivity, so there is always the possibility of two apparently-different paths being equal on such platforms. History ------- 0.6c9 * Fix ``resource_listdir('')`` always returning an empty list for zipped eggs. 0.6c7 * Fix package precedence problem where single-version eggs installed in ``site-packages`` would take precedence over ``.egg`` files (or directories) installed in ``site-packages``. 0.6c6 * Fix extracted C extensions not having executable permissions under Cygwin. * Allow ``.egg-link`` files to contain relative paths. * Fix cache dir defaults on Windows when multiple environment vars are needed to construct a path. 0.6c4 * Fix "dev" versions being considered newer than release candidates. 0.6c3 * Python 2.5 compatibility fixes. 0.6c2 * Fix a problem with eggs specified directly on ``PYTHONPATH`` on case-insensitive filesystems possibly not showing up in the default working set, due to differing normalizations of ``sys.path`` entries. 0.6b3 * Fixed a duplicate path insertion problem on case-insensitive filesystems. 0.6b1 * Split ``get_platform()`` into ``get_supported_platform()`` and ``get_build_platform()`` to work around a Mac versioning problem that caused the behavior of ``compatible_platforms()`` to be platform specific. * Fix entry point parsing when a standalone module name has whitespace between it and the extras. 0.6a11 * Added ``ExtractionError`` and ``ResourceManager.extraction_error()`` so that cache permission problems get a more user-friendly explanation of the problem, and so that programs can catch and handle extraction errors if they need to. 0.6a10 * Added the ``extras`` attribute to ``Distribution``, the ``find_plugins()`` method to ``WorkingSet``, and the ``__add__()`` and ``__iadd__()`` methods to ``Environment``. * ``safe_name()`` now allows dots in project names. * There is a new ``to_filename()`` function that escapes project names and versions for safe use in constructing egg filenames from a Distribution object's metadata. * Added ``Distribution.clone()`` method, and keyword argument support to other ``Distribution`` constructors. * Added the ``DEVELOP_DIST`` precedence, and automatically assign it to eggs using ``.egg-info`` format. 0.6a9 * Don't raise an error when an invalid (unfinished) distribution is found unless absolutely necessary. Warn about skipping invalid/unfinished eggs when building an Environment. * Added support for ``.egg-info`` files or directories with version/platform information embedded in the filename, so that system packagers have the option of including ``PKG-INFO`` files to indicate the presence of a system-installed egg, without needing to use ``.egg`` directories, zipfiles, or ``.pth`` manipulation. * Changed ``parse_version()`` to remove dashes before pre-release tags, so that ``0.2-rc1`` is considered an *older* version than ``0.2``, and is equal to ``0.2rc1``. The idea that a dash *always* meant a post-release version was highly non-intuitive to setuptools users and Python developers, who seem to want to use ``-rc`` version numbers a lot. 0.6a8 * Fixed a problem with ``WorkingSet.resolve()`` that prevented version conflicts from being detected at runtime. * Improved runtime conflict warning message to identify a line in the user's program, rather than flagging the ``warn()`` call in ``pkg_resources``. * Avoid giving runtime conflict warnings for namespace packages, even if they were declared by a different package than the one currently being activated. * Fix path insertion algorithm for case-insensitive filesystems. * Fixed a problem with nested namespace packages (e.g. ``peak.util``) not being set as an attribute of their parent package. 0.6a6 * Activated distributions are now inserted in ``sys.path`` (and the working set) just before the directory that contains them, instead of at the end. This allows e.g. eggs in ``site-packages`` to override unmanaged modules in the same location, and allows eggs found earlier on ``sys.path`` to override ones found later. * When a distribution is activated, it now checks whether any contained non-namespace modules have already been imported and issues a warning if a conflicting module has already been imported. * Changed dependency processing so that it's breadth-first, allowing a depender's preferences to override those of a dependee, to prevent conflicts when a lower version is acceptable to the dependee, but not the depender. * Fixed a problem extracting zipped files on Windows, when the egg in question has had changed contents but still has the same version number. 0.6a4 * Fix a bug in ``WorkingSet.resolve()`` that was introduced in 0.6a3. 0.6a3 * Added ``safe_extra()`` parsing utility routine, and use it for Requirement, EntryPoint, and Distribution objects' extras handling. 0.6a1 * Enhanced performance of ``require()`` and related operations when all requirements are already in the working set, and enhanced performance of directory scanning for distributions. * Fixed some problems using ``pkg_resources`` w/PEP 302 loaders other than ``zipimport``, and the previously-broken "eager resource" support. * Fixed ``pkg_resources.resource_exists()`` not working correctly, along with some other resource API bugs. * Many API changes and enhancements: * Added ``EntryPoint``, ``get_entry_map``, ``load_entry_point``, and ``get_entry_info`` APIs for dynamic plugin discovery. * ``list_resources`` is now ``resource_listdir`` (and it actually works) * Resource API functions like ``resource_string()`` that accepted a package name and resource name, will now also accept a ``Requirement`` object in place of the package name (to allow access to non-package data files in an egg). * ``get_provider()`` will now accept a ``Requirement`` instance or a module name. If it is given a ``Requirement``, it will return a corresponding ``Distribution`` (by calling ``require()`` if a suitable distribution isn't already in the working set), rather than returning a metadata and resource provider for a specific module. (The difference is in how resource paths are interpreted; supplying a module name means resources path will be module-relative, rather than relative to the distribution's root.) * ``Distribution`` objects now implement the ``IResourceProvider`` and ``IMetadataProvider`` interfaces, so you don't need to reference the (no longer available) ``metadata`` attribute to get at these interfaces. * ``Distribution`` and ``Requirement`` both have a ``project_name`` attribute for the project name they refer to. (Previously these were ``name`` and ``distname`` attributes.) * The ``path`` attribute of ``Distribution`` objects is now ``location``, because it isn't necessarily a filesystem path (and hasn't been for some time now). The ``location`` of ``Distribution`` objects in the filesystem should always be normalized using ``pkg_resources.normalize_path()``; all of the setuptools' code that generates distributions from the filesystem (including ``Distribution.from_filename()``) ensure this invariant, but if you use a more generic API like ``Distribution()`` or ``Distribution.from_location()`` you should take care that you don't create a distribution with an un-normalized filesystem path. * ``Distribution`` objects now have an ``as_requirement()`` method that returns a ``Requirement`` for the distribution's project name and version. * Distribution objects no longer have an ``installed_on()`` method, and the ``install_on()`` method is now ``activate()`` (but may go away altogether soon). The ``depends()`` method has also been renamed to ``requires()``, and ``InvalidOption`` is now ``UnknownExtra``. * ``find_distributions()`` now takes an additional argument called ``only``, that tells it to only yield distributions whose location is the passed-in path. (It defaults to False, so that the default behavior is unchanged.) * ``AvailableDistributions`` is now called ``Environment``, and the ``get()``, ``__len__()``, and ``__contains__()`` methods were removed, because they weren't particularly useful. ``__getitem__()`` no longer raises ``KeyError``; it just returns an empty list if there are no distributions for the named project. * The ``resolve()`` method of ``Environment`` is now a method of ``WorkingSet`` instead, and the ``best_match()`` method now uses a working set instead of a path list as its second argument. * There is a new ``pkg_resources.add_activation_listener()`` API that lets you register a callback for notifications about distributions added to ``sys.path`` (including the distributions already on it). This is basically a hook for extensible applications and frameworks to be able to search for plugin metadata in distributions added at runtime. 0.5a13 * Fixed a bug in resource extraction from nested packages in a zipped egg. 0.5a12 * Updated extraction/cache mechanism for zipped resources to avoid inter- process and inter-thread races during extraction. The default cache location can now be set via the ``PYTHON_EGGS_CACHE`` environment variable, and the default Windows cache is now a ``Python-Eggs`` subdirectory of the current user's "Application Data" directory, if the ``PYTHON_EGGS_CACHE`` variable isn't set. 0.5a10 * Fix a problem with ``pkg_resources`` being confused by non-existent eggs on ``sys.path`` (e.g. if a user deletes an egg without removing it from the ``easy-install.pth`` file). * Fix a problem with "basket" support in ``pkg_resources``, where egg-finding never actually went inside ``.egg`` files. * Made ``pkg_resources`` import the module you request resources from, if it's not already imported. 0.5a4 * ``pkg_resources.AvailableDistributions.resolve()`` and related methods now accept an ``installer`` argument: a callable taking one argument, a ``Requirement`` instance. The callable must return a ``Distribution`` object, or ``None`` if no distribution is found. This feature is used by EasyInstall to resolve dependencies by recursively invoking itself. 0.4a4 * Fix problems with ``resource_listdir()``, ``resource_isdir()`` and resource directory extraction for zipped eggs. 0.4a3 * Fixed scripts not being able to see a ``__file__`` variable in ``__main__`` * Fixed a problem with ``resource_isdir()`` implementation that was introduced in 0.4a2. 0.4a1 * Fixed a bug in requirements processing for exact versions (i.e. ``==`` and ``!=``) when only one condition was included. * Added ``safe_name()`` and ``safe_version()`` APIs to clean up handling of arbitrary distribution names and versions found on PyPI. 0.3a4 * ``pkg_resources`` now supports resource directories, not just the resources in them. In particular, there are ``resource_listdir()`` and ``resource_isdir()`` APIs. * ``pkg_resources`` now supports "egg baskets" -- .egg zipfiles which contain multiple distributions in subdirectories whose names end with ``.egg``. Having such a "basket" in a directory on ``sys.path`` is equivalent to having the individual eggs in that directory, but the contained eggs can be individually added (or not) to ``sys.path``. Currently, however, there is no automated way to create baskets. * Namespace package manipulation is now protected by the Python import lock. 0.3a1 * Initial release. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/python 2 sunset.rst0000644000175100001710000000672200000000000020032 0ustar00runnerdocker:orphan: Python 2 Sunset =============== Since January 2020 and the release of Setuptools 45, Python 2 is no longer supported by the most current release (`discussion `_). Setuptools as a project continues to support Python 2 with bugfixes and important features on Setuptools 44.x. By design, most users will be unaffected by this change. That's because Setuptools 45 declares its supported Python versions to exclude Python 2.7, and installers such as pip 9 or later will honor this declaration and prevent installation of Setuptools 45 or later in Python 2 environments. Users that do import any portion of Setuptools 45 or later on Python 2 are directed to this documentation to provide guidance on how to work around the issues. Workarounds ----------- The best recommendation is to avoid Python 2 and move to Python 3 where possible. This project acknowledges that not all environments can drop Python 2 support, so provides other options. In less common scenarios, later versions of Setuptools can be installed on unsupported Python versions. In these environments, the installer is advised to first install ``setuptools<45`` to "pin Setuptools" to a compatible version. - When using older versions of pip (before 9.0), the ``Requires-Python`` directive is not honored and invalid versions can be installed. Users are advised first to upgrade pip and retry or to pin Setuptools. Use ``pip --version`` to determine the version of pip. - When using ``easy_install``, ``Requires-Python`` is not honored and later versions can be installed. In this case, users are advised to pin Setuptools. This applies to ``setup.py install`` invocations as well, as they use Setuptools under the hood. It's still not working ---------------------- If after trying the above steps, the Python environment still has incompatible versions of Setuptools installed, here are some things to try. 1. Uninstall and reinstall Setuptools. Run ``pip uninstall -y setuptools`` for the relevant environment. Repeat until there is no Setuptools installed. Then ``pip install setuptools``. 2. If possible, attempt to replicate the problem in a second environment (virtual machine, friend's computer, etc). If the issue is isolated to just one unique environment, first determine what is different about those environments (or reinstall/reset the failing one to defaults). 3. End users who are not themselves the maintainers for the package they are trying to install should contact the support channels for the relevant application. Please be considerate of those projects by searching for existing issues and following the latest guidance before reaching out for support. When filing an issue, be sure to give as much detail as possible to help the maintainers understand what factors led to the issue after following their recommended guidance. 4. Reach out to your local support groups. There's a good chance someone nearby has the expertise and willingness to help. 5. If all else fails, `file this template `_ with Setuptools. Please complete the whole template, providing as much detail about what factors led to the issue. Setuptools maintainers will summarily close tickets filed without any meaningful detail or engagement with the issue. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8946698 setuptools-59.6.0/docs/references/0000755000175100001710000000000000000000000016445 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/references/keywords.rst0000644000175100001710000003371300000000000021055 0ustar00runnerdocker======== Keywords ======== ``name`` A string specifying the name of the package. ``version`` A string specifying the version number of the package. ``description`` A string describing the package in a single line. ``long_description`` A string providing a longer description of the package. ``long_description_content_type`` A string specifying the content type is used for the ``long_description`` (e.g. ``text/markdown``) ``author`` A string specifying the author of the package. ``author_email`` A string specifying the email address of the package author. ``maintainer`` A string specifying the name of the current maintainer, if different from the author. Note that if the maintainer is provided, setuptools will use it as the author in ``PKG-INFO``. ``maintainer_email`` A string specifying the email address of the current maintainer, if different from the author. ``url`` A string specifying the URL for the package homepage. ``download_url`` A string specifying the URL to download the package. ``packages`` A list of strings specifying the packages that setuptools will manipulate. ``py_modules`` A list of strings specifying the modules that setuptools will manipulate. ``scripts`` A list of strings specifying the standalone script files to be built and installed. ``ext_package`` A string specifying the base package name for the extensions provided by this package. ``ext_modules`` A list of instances of ``setuptools.Extension`` providing the list of Python extensions to be built. ``classifiers`` A list of strings describing the categories for the package. ``distclass`` A subclass of ``Distribution`` to use. ``script_name`` A string specifying the name of the setup.py script -- defaults to ``sys.argv[0]`` ``script_args`` A list of strings defining the arguments to supply to the setup script. ``options`` A dictionary providing the default options for the setup script. ``license`` A string specifying the license of the package. ``license_file`` .. warning:: ``license_file`` is deprecated. Use ``license_files`` instead. ``license_files`` A list of glob patterns for license related files that should be included. If neither ``license_file`` nor ``license_files`` is specified, this option defaults to ``LICEN[CS]E*``, ``COPYING*``, ``NOTICE*``, and ``AUTHORS*``. ``keywords`` A list of strings or a comma-separated string providing descriptive meta-data. See: `PEP 0314`_. .. _PEP 0314: https://www.python.org/dev/peps/pep-0314/ ``platforms`` A list of strings or comma-separated string. ``cmdclass`` A dictionary providing a mapping of command names to ``Command`` subclasses. ``data_files`` .. warning:: ``data_files`` is deprecated. It does not work with wheels, so it should be avoided. A list of strings specifying the data files to install. ``package_dir`` A dictionary providing a mapping of package to directory names. ``requires`` .. warning:: ``requires`` is superseded by ``install_requires`` and should not be used anymore. ``obsoletes`` .. warning:: ``obsoletes`` is currently ignored by ``pip``. List of strings describing packages which this package renders obsolete, meaning that the two projects should not be installed at the same time. Version declarations can be supplied. Version numbers must be in the format specified in Version specifiers (e.g. ``foo (<3.0)``). This field may be followed by an environment marker after a semicolon (e.g. ``foo; os_name == "posix"``) The most common use of this field will be in case a project name changes, e.g. Gorgon 2.3 gets subsumed into Torqued Python 1.0. When you install Torqued Python, the Gorgon distribution should be removed. ``provides`` .. warning:: ``provides`` is currently ignored by ``pip``. List of strings describing package- and virtual package names contained within this package. A package may provide additional names, e.g. to indicate that multiple projects have been bundled together. For instance, source distributions of the ZODB project have historically included the transaction project, which is now available as a separate distribution. Installing such a source distribution satisfies requirements for both ZODB and transaction. A package may also provide a “virtual†project name, which does not correspond to any separately-distributed project: such a name might be used to indicate an abstract capability which could be supplied by one of multiple projects. E.g., multiple projects might supply RDBMS bindings for use by a given ORM: each project might declare that it provides ORM-bindings, allowing other projects to depend only on having at most one of them installed. A version declaration may be supplied and must follow the rules described in Version specifiers. The distribution’s version number will be implied if none is specified (e.g. ``foo (<3.0)``). Each package may be followed by an environment marker after a semicolon (e.g. ``foo; os_name == "posix"``). .. Below are setuptools keywords, above are distutils ``include_package_data`` If set to ``True``, this tells ``setuptools`` to automatically include any data files it finds inside your package directories that are specified by your ``MANIFEST.in`` file. For more information, see the section on :ref:`Including Data Files`. ``exclude_package_data`` A dictionary mapping package names to lists of glob patterns that should be *excluded* from your package directories. You can use this to trim back any excess files included by ``include_package_data``. For a complete description and examples, see the section on :ref:`Including Data Files`. ``package_data`` A dictionary mapping package names to lists of glob patterns. For a complete description and examples, see the section on :ref:`Including Data Files`. You do not need to use this option if you are using ``include_package_data``, unless you need to add e.g. files that are generated by your setup script and build process. (And are therefore not in source control or are files that you don't want to include in your source distribution.) ``zip_safe`` A boolean (True or False) flag specifying whether the project can be safely installed and run from a zip file. If this argument is not supplied, the ``bdist_egg`` command will have to analyze all of your project's contents for possible problems each time it builds an egg. ``install_requires`` A string or list of strings specifying what other distributions need to be installed when this one is. See the section on :ref:`Declaring Dependencies` for details and examples of the format of this argument. ``entry_points`` A dictionary mapping entry point group names to strings or lists of strings defining the entry points. Entry points are used to support dynamic discovery of services or plugins provided by a project. See :ref:`Dynamic Discovery of Services and Plugins` for details and examples of the format of this argument. In addition, this keyword is used to support :ref:`Automatic Script Creation `. ``extras_require`` A dictionary mapping names of "extras" (optional features of your project) to strings or lists of strings specifying what other distributions must be installed to support those features. See the section on :ref:`Declaring Dependencies` for details and examples of the format of this argument. ``python_requires`` A string corresponding to a version specifier (as defined in PEP 440) for the Python version, used to specify the Requires-Python defined in PEP 345. ``setup_requires`` .. warning:: Using ``setup_requires`` is discouraged in favor of `PEP-518`_ A string or list of strings specifying what other distributions need to be present in order for the *setup script* to run. ``setuptools`` will attempt to obtain these (even going so far as to download them using ``EasyInstall``) before processing the rest of the setup script or commands. This argument is needed if you are using distutils extensions as part of your build process; for example, extensions that process setup() arguments and turn them into EGG-INFO metadata files. (Note: projects listed in ``setup_requires`` will NOT be automatically installed on the system where the setup script is being run. They are simply downloaded to the ./.eggs directory if they're not locally available already. If you want them to be installed, as well as being available when the setup script is run, you should add them to ``install_requires`` **and** ``setup_requires``.) .. _PEP-518: http://www.python.org/dev/peps/pep-0518/ ``dependency_links`` .. warning:: ``dependency_links`` is deprecated. It is not supported anymore by pip. A list of strings naming URLs to be searched when satisfying dependencies. These links will be used if needed to install packages specified by ``setup_requires`` or ``tests_require``. They will also be written into the egg's metadata for use by tools like EasyInstall to use when installing an ``.egg`` file. ``namespace_packages`` A list of strings naming the project's "namespace packages". A namespace package is a package that may be split across multiple project distributions. For example, Zope 3's ``zope`` package is a namespace package, because subpackages like ``zope.interface`` and ``zope.publisher`` may be distributed separately. The egg runtime system can automatically merge such subpackages into a single parent package at runtime, as long as you declare them in each project that contains any subpackages of the namespace package, and as long as the namespace package's ``__init__.py`` does not contain any code other than a namespace declaration. See the section on :ref:`Namespace Packages` for more information. ``test_suite`` A string naming a ``unittest.TestCase`` subclass (or a package or module containing one or more of them, or a method of such a subclass), or naming a function that can be called with no arguments and returns a ``unittest.TestSuite``. If the named suite is a module, and the module has an ``additional_tests()`` function, it is called and the results are added to the tests to be run. If the named suite is a package, any submodules and subpackages are recursively added to the overall test suite. Specifying this argument enables use of the :ref:`test` command to run the specified test suite, e.g. via ``setup.py test``. See the section on the :ref:`test` command below for more details. New in 41.5.0: Deprecated the test command. ``tests_require`` If your project's tests need one or more additional packages besides those needed to install it, you can use this option to specify them. It should be a string or list of strings specifying what other distributions need to be present for the package's tests to run. When you run the ``test`` command, ``setuptools`` will attempt to obtain these (even going so far as to download them using ``EasyInstall``). Note that these required projects will *not* be installed on the system where the tests are run, but only downloaded to the project's setup directory if they're not already installed locally. New in 41.5.0: Deprecated the test command. .. _test_loader: ``test_loader`` If you would like to use a different way of finding tests to run than what setuptools normally uses, you can specify a module name and class name in this argument. The named class must be instantiable with no arguments, and its instances must support the ``loadTestsFromNames()`` method as defined in the Python ``unittest`` module's ``TestLoader`` class. Setuptools will pass only one test "name" in the ``names`` argument: the value supplied for the ``test_suite`` argument. The loader you specify may interpret this string in any way it likes, as there are no restrictions on what may be contained in a ``test_suite`` string. The module name and class name must be separated by a ``:``. The default value of this argument is ``"setuptools.command.test:ScanningLoader"``. If you want to use the default ``unittest`` behavior, you can specify ``"unittest:TestLoader"`` as your ``test_loader`` argument instead. This will prevent automatic scanning of submodules and subpackages. The module and class you specify here may be contained in another package, as long as you use the ``tests_require`` option to ensure that the package containing the loader class is available when the ``test`` command is run. New in 41.5.0: Deprecated the test command. ``eager_resources`` A list of strings naming resources that should be extracted together, if any of them is needed, or if any C extensions included in the project are imported. This argument is only useful if the project will be installed as a zipfile, and there is a need to have all of the listed resources be extracted to the filesystem *as a unit*. Resources listed here should be '/'-separated paths, relative to the source root, so to list a resource ``foo.png`` in package ``bar.baz``, you would include the string ``bar/baz/foo.png`` in this argument. If you only need to obtain resources one at a time, or you don't have any C extensions that access other files in the project (such as data files or shared libraries), you probably do NOT need this argument and shouldn't mess with it. For more details on how this argument works, see the section below on :ref:`Automatic Resource Extraction`. ``project_urls`` An arbitrary map of URL names to hyperlinks, allowing more extensible documentation of where various resources can be found than the simple ``url`` and ``download_url`` options provide. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/roadmap.rst0000644000175100001710000000024100000000000016476 0ustar00runnerdocker======= Roadmap ======= Setuptools maintains a series of `milestones `_ to track a roadmap of large-scale goals. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/setuptools.rst0000644000175100001710000001432200000000000017301 0ustar00runnerdocker================================================== Building and Distributing Packages with Setuptools ================================================== ``Setuptools`` is a collection of enhancements to the Python ``distutils`` that allow developers to more easily build and distribute Python packages, especially ones that have dependencies on other packages. Packages built and distributed using ``setuptools`` look to the user like ordinary Python packages based on the ``distutils``. Feature Highlights: * Create `Python Eggs `_ - a single-file importable distribution format * Enhanced support for accessing data files hosted in zipped packages. * Automatically include all packages in your source tree, without listing them individually in setup.py * Automatically include all relevant files in your source distributions, without needing to create a ``MANIFEST.in`` file, and without having to force regeneration of the ``MANIFEST`` file when your source tree changes. * Automatically generate wrapper scripts or Windows (console and GUI) .exe files for any number of "main" functions in your project. (Note: this is not a py2exe replacement; the .exe files rely on the local Python installation.) * Transparent Cython support, so that your setup.py can list ``.pyx`` files and still work even when the end-user doesn't have Cython installed (as long as you include the Cython-generated C in your source distribution) * Command aliases - create project-specific, per-user, or site-wide shortcut names for commonly used commands and options * Deploy your project in "development mode", such that it's available on ``sys.path``, yet can still be edited directly from its source checkout. * Easily extend the distutils with new commands or ``setup()`` arguments, and distribute/reuse your extensions for multiple projects, without copying code. * Create extensible applications and frameworks that automatically discover extensions, using simple "entry points" declared in a project's setup script. * Full support for PEP 420 via ``find_namespace_packages()``, which is also backwards compatible to the existing ``find_packages()`` for Python >= 3.3. ----------------- Developer's Guide ----------------- The developer's guide has been updated. See the :doc:`most recent version `. TRANSITIONAL NOTE ~~~~~~~~~~~~~~~~~ Setuptools automatically calls ``declare_namespace()`` for you at runtime, but future versions may *not*. This is because the automatic declaration feature has some negative side effects, such as needing to import all namespace packages during the initialization of the ``pkg_resources`` runtime, and also the need for ``pkg_resources`` to be explicitly imported before any namespace packages work at all. In some future releases, you'll be responsible for including your own declaration lines, and the automatic declaration feature will be dropped to get rid of the negative side effects. During the remainder of the current development cycle, therefore, setuptools will warn you about missing ``declare_namespace()`` calls in your ``__init__.py`` files, and you should correct these as soon as possible before the compatibility support is removed. Namespace packages without declaration lines will not work correctly once a user has upgraded to a later version, so it's important that you make this change now in order to avoid having your code break in the field. Our apologies for the inconvenience, and thank you for your patience. setup.cfg-only projects ======================= .. versionadded:: 40.9.0 If ``setup.py`` is missing from the project directory when a :pep:`517` build is invoked, ``setuptools`` emulates a dummy ``setup.py`` file containing only a ``setuptools.setup()`` call. .. note:: :pep:`517` doesn't support editable installs so this is currently incompatible with ``pip install -e .``. This means that you can have a Python project with all build configuration specified in ``setup.cfg``, without a ``setup.py`` file, if you **can rely on** your project always being built by a :pep:`517`/:pep:`518` compatible frontend. To use this feature: * Specify build requirements and :pep:`517` build backend in ``pyproject.toml``. For example: .. code-block:: toml [build-system] requires = [ "setuptools >= 40.9.0", "wheel", ] build-backend = "setuptools.build_meta" * Use a :pep:`517` compatible build frontend, such as ``pip >= 19`` or ``build``. .. warning:: As :pep:`517` is new, support is not universal, and frontends that do support it may still have bugs. For compatibility, you may want to put a ``setup.py`` file containing only a ``setuptools.setup()`` invocation. Configuration API ================= Some automation tools may wish to access data from a configuration file. ``Setuptools`` exposes a ``read_configuration()`` function for parsing ``metadata`` and ``options`` sections into a dictionary. .. code-block:: python from setuptools.config import read_configuration conf_dict = read_configuration("/home/user/dev/package/setup.cfg") By default, ``read_configuration()`` will read only the file provided in the first argument. To include values from other configuration files which could be in various places, set the ``find_others`` keyword argument to ``True``. If you have only a configuration file but not the whole package, you can still try to get data out of it with the help of the ``ignore_option_errors`` keyword argument. When it is set to ``True``, all options with errors possibly produced by directives, such as ``attr:`` and others, will be silently ignored. As a consequence, the resulting dictionary will include no such options. Mailing List and Bug Tracker ============================ Please use the `distutils-sig mailing list`_ for questions and discussion about setuptools, and the `setuptools bug tracker`_ ONLY for issues you have confirmed via the list are actual bugs, and which you have reduced to a minimal set of steps to reproduce. .. _distutils-sig mailing list: http://mail.python.org/pipermail/distutils-sig/ .. _setuptools bug tracker: https://github.com/pypa/setuptools/ ././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1639341979.89867 setuptools-59.6.0/docs/userguide/0000755000175100001710000000000000000000000016320 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/commands.rst0000644000175100001710000006536000000000000020665 0ustar00runnerdocker----------------- Command Reference ----------------- .. _alias: ``alias`` - Define shortcuts for commonly used commands ======================================================= Sometimes, you need to use the same commands over and over, but you can't necessarily set them as defaults. For example, if you produce both development snapshot releases and "stable" releases of a project, you may want to put the distributions in different places, or use different ``egg_info`` tagging options, etc. In these cases, it doesn't make sense to set the options in a distutils configuration file, because the values of the options changed based on what you're trying to do. Setuptools therefore allows you to define "aliases" - shortcut names for an arbitrary string of commands and options, using ``setup.py alias aliasname expansion``, where aliasname is the name of the new alias, and the remainder of the command line supplies its expansion. For example, this command defines a sitewide alias called "daily", that sets various ``egg_info`` tagging options:: setup.py alias --global-config daily egg_info --tag-build=development Once the alias is defined, it can then be used with other setup commands, e.g.:: setup.py daily bdist_egg # generate a daily-build .egg file setup.py daily sdist # generate a daily-build source distro setup.py daily sdist bdist_egg # generate both The above commands are interpreted as if the word ``daily`` were replaced with ``egg_info --tag-build=development``. Note that setuptools will expand each alias *at most once* in a given command line. This serves two purposes. First, if you accidentally create an alias loop, it will have no effect; you'll instead get an error message about an unknown command. Second, it allows you to define an alias for a command, that uses that command. For example, this (project-local) alias:: setup.py alias bdist_egg bdist_egg rotate -k1 -m.egg redefines the ``bdist_egg`` command so that it always runs the ``rotate`` command afterwards to delete all but the newest egg file. It doesn't loop indefinitely on ``bdist_egg`` because the alias is only expanded once when used. You can remove a defined alias with the ``--remove`` (or ``-r``) option, e.g.:: setup.py alias --global-config --remove daily would delete the "daily" alias we defined above. Aliases can be defined on a project-specific, per-user, or sitewide basis. The default is to define or remove a project-specific alias, but you can use any of the `configuration file options`_ (listed under the `saveopts`_ command, below) to determine which distutils configuration file an aliases will be added to (or removed from). Note that if you omit the "expansion" argument to the ``alias`` command, you'll get output showing that alias' current definition (and what configuration file it's defined in). If you omit the alias name as well, you'll get a listing of all current aliases along with their configuration file locations. ``bdist_egg`` - Create a Python Egg for the project =================================================== .. warning:: **eggs** are deprecated in favor of wheels, and not supported by pip. This command generates a Python Egg (``.egg`` file) for the project. Python Eggs are the preferred binary distribution format for EasyInstall, because they are cross-platform (for "pure" packages), directly importable, and contain project metadata including scripts and information about the project's dependencies. They can be simply downloaded and added to ``sys.path`` directly, or they can be placed in a directory on ``sys.path`` and then automatically discovered by the egg runtime system. This command runs the `egg_info`_ command (if it hasn't already run) to update the project's metadata (``.egg-info``) directory. If you have added any extra metadata files to the ``.egg-info`` directory, those files will be included in the new egg file's metadata directory, for use by the egg runtime system or by any applications or frameworks that use that metadata. You won't usually need to specify any special options for this command; just use ``bdist_egg`` and you're done. But there are a few options that may be occasionally useful: ``--dist-dir=DIR, -d DIR`` Set the directory where the ``.egg`` file will be placed. If you don't supply this, then the ``--dist-dir`` setting of the ``bdist`` command will be used, which is usually a directory named ``dist`` in the project directory. ``--plat-name=PLATFORM, -p PLATFORM`` Set the platform name string that will be embedded in the egg's filename (assuming the egg contains C extensions). This can be used to override the distutils default platform name with something more meaningful. Keep in mind, however, that the egg runtime system expects to see eggs with distutils platform names, so it may ignore or reject eggs with non-standard platform names. Similarly, the EasyInstall program may ignore them when searching web pages for download links. However, if you are cross-compiling or doing some other unusual things, you might find a use for this option. ``--exclude-source-files`` Don't include any modules' ``.py`` files in the egg, just compiled Python, C, and data files. (Note that this doesn't affect any ``.py`` files in the EGG-INFO directory or its subdirectories, since for example there may be scripts with a ``.py`` extension which must still be retained.) We don't recommend that you use this option except for packages that are being bundled for proprietary end-user applications, or for "embedded" scenarios where space is at an absolute premium. On the other hand, if your package is going to be installed and used in compressed form, you might as well exclude the source because Python's ``traceback`` module doesn't currently understand how to display zipped source code anyway, or how to deal with files that are in a different place from where their code was compiled. There are also some options you will probably never need, but which are there because they were copied from similar ``bdist`` commands used as an example for creating this one. They may be useful for testing and debugging, however, which is why we kept them: ``--keep-temp, -k`` Keep the contents of the ``--bdist-dir`` tree around after creating the ``.egg`` file. ``--bdist-dir=DIR, -b DIR`` Set the temporary directory for creating the distribution. The entire contents of this directory are zipped to create the ``.egg`` file, after running various installation commands to copy the package's modules, data, and extensions here. ``--skip-build`` Skip doing any "build" commands; just go straight to the install-and-compress phases. .. _develop: ``develop`` - Deploy the project source in "Development Mode" ============================================================= This command allows you to deploy your project's source for use in one or more "staging areas" where it will be available for importing. This deployment is done in such a way that changes to the project source are immediately available in the staging area(s), without needing to run a build or install step after each change. The ``develop`` command works by creating an ``.egg-link`` file (named for the project) in the given staging area. If the staging area is Python's ``site-packages`` directory, it also updates an ``easy-install.pth`` file so that the project is on ``sys.path`` by default for all programs run using that Python installation. The ``develop`` command also installs wrapper scripts in the staging area (or a separate directory, as specified) that will ensure the project's dependencies are available on ``sys.path`` before running the project's source scripts. And, it ensures that any missing project dependencies are available in the staging area, by downloading and installing them if necessary. Last, but not least, the ``develop`` command invokes the ``build_ext -i`` command to ensure any C extensions in the project have been built and are up-to-date, and the ``egg_info`` command to ensure the project's metadata is updated (so that the runtime and wrappers know what the project's dependencies are). If you make any changes to the project's setup script or C extensions, you should rerun the ``develop`` command against all relevant staging areas to keep the project's scripts, metadata and extensions up-to-date. Most other kinds of changes to your project should not require any build operations or rerunning ``develop``, but keep in mind that even minor changes to the setup script (e.g. changing an entry point definition) require you to re-run the ``develop`` or ``test`` commands to keep the distribution updated. Here are some of the options that the ``develop`` command accepts. Note that they affect the project's dependencies as well as the project itself, so if you have dependencies that need to be installed and you use ``--exclude-scripts`` (for example), the dependencies' scripts will not be installed either! For this reason, you may want to use pip to install the project's dependencies before using the ``develop`` command, if you need finer control over the installation options for dependencies. ``--uninstall, -u`` Un-deploy the current project. You may use the ``--install-dir`` or ``-d`` option to designate the staging area. The created ``.egg-link`` file will be removed, if present and it is still pointing to the project directory. The project directory will be removed from ``easy-install.pth`` if the staging area is Python's ``site-packages`` directory. Note that this option currently does *not* uninstall script wrappers! You must uninstall them yourself, or overwrite them by using pip to install a different version of the package. You can also avoid installing script wrappers in the first place, if you use the ``--exclude-scripts`` (aka ``-x``) option when you run ``develop`` to deploy the project. ``--multi-version, -m`` "Multi-version" mode. Specifying this option prevents ``develop`` from adding an ``easy-install.pth`` entry for the project(s) being deployed, and if an entry for any version of a project already exists, the entry will be removed upon successful deployment. In multi-version mode, no specific version of the package is available for importing, unless you use ``pkg_resources.require()`` to put it on ``sys.path``, or you are running a wrapper script generated by ``setuptools``. (In which case the wrapper script calls ``require()`` for you.) Note that if you install to a directory other than ``site-packages``, this option is automatically in effect, because ``.pth`` files can only be used in ``site-packages`` (at least in Python 2.3 and 2.4). So, if you use the ``--install-dir`` or ``-d`` option (or they are set via configuration file(s)) your project and its dependencies will be deployed in multi- version mode. ``--install-dir=DIR, -d DIR`` Set the installation directory (staging area). If this option is not directly specified on the command line or in a distutils configuration file, the distutils default installation location is used. Normally, this will be the ``site-packages`` directory, but if you are using distutils configuration files, setting things like ``prefix`` or ``install_lib``, then those settings are taken into account when computing the default staging area. ``--script-dir=DIR, -s DIR`` Set the script installation directory. If you don't supply this option (via the command line or a configuration file), but you *have* supplied an ``--install-dir`` (via command line or config file), then this option defaults to the same directory, so that the scripts will be able to find their associated package installation. Otherwise, this setting defaults to the location where the distutils would normally install scripts, taking any distutils configuration file settings into account. ``--exclude-scripts, -x`` Don't deploy script wrappers. This is useful if you don't want to disturb existing versions of the scripts in the staging area. ``--always-copy, -a`` Copy all needed distributions to the staging area, even if they are already present in another directory on ``sys.path``. By default, if a requirement can be met using a distribution that is already available in a directory on ``sys.path``, it will not be copied to the staging area. ``--egg-path=DIR`` Force the generated ``.egg-link`` file to use a specified relative path to the source directory. This can be useful in circumstances where your installation directory is being shared by code running under multiple platforms (e.g. Mac and Windows) which have different absolute locations for the code under development, but the same *relative* locations with respect to the installation directory. If you use this option when installing, you must supply the same relative path when uninstalling. In addition to the above options, the ``develop`` command also accepts all of the same options accepted by ``easy_install``. If you've configured any ``easy_install`` settings in your ``setup.cfg`` (or other distutils config files), the ``develop`` command will use them as defaults, unless you override them in a ``[develop]`` section or on the command line. .. _egg_info: ``egg_info`` - Create egg metadata and set build tags ===================================================== This command performs two operations: it updates a project's ``.egg-info`` metadata directory (used by the ``bdist_egg``, ``develop``, and ``test`` commands), and it allows you to temporarily change a project's version string, to support "daily builds" or "snapshot" releases. It is run automatically by the ``sdist``, ``bdist_egg``, ``develop``, and ``test`` commands in order to update the project's metadata, but you can also specify it explicitly in order to temporarily change the project's version string while executing other commands. (It also generates the ``.egg-info/SOURCES.txt`` manifest file, which is used when you are building source distributions.) In addition to writing the core egg metadata defined by ``setuptools`` and required by ``pkg_resources``, this command can be extended to write other metadata files as well, by defining entry points in the ``egg_info.writers`` group. See the section on :ref:`Adding new EGG-INFO Files` below for more details. Note that using additional metadata writers may require you to include a ``setup_requires`` argument to ``setup()`` in order to ensure that the desired writers are available on ``sys.path``. Release Tagging Options ----------------------- The following options can be used to modify the project's version string for all remaining commands on the setup command line. The options are processed in the order shown, so if you use more than one, the requested tags will be added in the following order: ``--tag-build=NAME, -b NAME`` Append NAME to the project's version string. Due to the way setuptools processes "pre-release" version suffixes beginning with the letters "a" through "e" (like "alpha", "beta", and "candidate"), you will usually want to use a tag like ".build" or ".dev", as this will cause the version number to be considered *lower* than the project's default version. (If you want to make the version number *higher* than the default version, you can always leave off --tag-build and then use one or both of the following options.) If you have a default build tag set in your ``setup.cfg``, you can suppress it on the command line using ``-b ""`` or ``--tag-build=""`` as an argument to the ``egg_info`` command. ``--tag-date, -d`` Add a date stamp of the form "-YYYYMMDD" (e.g. "-20050528") to the project's version number. ``--no-date, -D`` Don't include a date stamp in the version number. This option is included so you can override a default setting in ``setup.cfg``. (Note: Because these options modify the version number used for source and binary distributions of your project, you should first make sure that you know how the resulting version numbers will be interpreted by automated tools like pip. See the section above on :ref:`Specifying Your Project's Version` for an explanation of pre- and post-release tags, as well as tips on how to choose and verify a versioning scheme for your project.) For advanced uses, there is one other option that can be set, to change the location of the project's ``.egg-info`` directory. Commands that need to find the project's source directory or metadata should get it from this setting: Other ``egg_info`` Options -------------------------- ``--egg-base=SOURCEDIR, -e SOURCEDIR`` Specify the directory that should contain the .egg-info directory. This should normally be the root of your project's source tree (which is not necessarily the same as your project directory; some projects use a ``src`` or ``lib`` subdirectory as the source root). You should not normally need to specify this directory, as it is normally determined from the ``package_dir`` argument to the ``setup()`` function, if any. If there is no ``package_dir`` set, this option defaults to the current directory. ``egg_info`` Examples --------------------- Creating a dated "nightly build" snapshot egg:: setup.py egg_info --tag-date --tag-build=DEV bdist_egg Creating a release with no version tags, even if some default tags are specified in ``setup.cfg``:: setup.py egg_info -RDb "" sdist bdist_egg (Notice that ``egg_info`` must always appear on the command line *before* any commands that you want the version changes to apply to.) .. _rotate: ``rotate`` - Delete outdated distribution files =============================================== As you develop new versions of your project, your distribution (``dist``) directory will gradually fill up with older source and/or binary distribution files. The ``rotate`` command lets you automatically clean these up, keeping only the N most-recently modified files matching a given pattern. ``--match=PATTERNLIST, -m PATTERNLIST`` Comma-separated list of glob patterns to match. This option is *required*. The project name and ``-*`` is prepended to the supplied patterns, in order to match only distributions belonging to the current project (in case you have a shared distribution directory for multiple projects). Typically, you will use a glob pattern like ``.zip`` or ``.egg`` to match files of the specified type. Note that each supplied pattern is treated as a distinct group of files for purposes of selecting files to delete. ``--keep=COUNT, -k COUNT`` Number of matching distributions to keep. For each group of files identified by a pattern specified with the ``--match`` option, delete all but the COUNT most-recently-modified files in that group. This option is *required*. ``--dist-dir=DIR, -d DIR`` Directory where the distributions are. This defaults to the value of the ``bdist`` command's ``--dist-dir`` option, which will usually be the project's ``dist`` subdirectory. **Example 1**: Delete all .tar.gz files from the distribution directory, except for the 3 most recently modified ones:: setup.py rotate --match=.tar.gz --keep=3 **Example 2**: Delete all Python 2.3 or Python 2.4 eggs from the distribution directory, except the most recently modified one for each Python version:: setup.py rotate --match=-py2.3*.egg,-py2.4*.egg --keep=1 .. _saveopts: ``saveopts`` - Save used options to a configuration file ======================================================== Finding and editing ``distutils`` configuration files can be a pain, especially since you also have to translate the configuration options from command-line form to the proper configuration file format. You can avoid these hassles by using the ``saveopts`` command. Just add it to the command line to save the options you used. For example, this command builds the project using the ``mingw32`` C compiler, then saves the --compiler setting as the default for future builds (even those run implicitly by the ``install`` command):: setup.py build --compiler=mingw32 saveopts The ``saveopts`` command saves all options for every command specified on the command line to the project's local ``setup.cfg`` file, unless you use one of the `configuration file options`_ to change where the options are saved. For example, this command does the same as above, but saves the compiler setting to the site-wide (global) distutils configuration:: setup.py build --compiler=mingw32 saveopts -g Note that it doesn't matter where you place the ``saveopts`` command on the command line; it will still save all the options specified for all commands. For example, this is another valid way to spell the last example:: setup.py saveopts -g build --compiler=mingw32 Note, however, that all of the commands specified are always run, regardless of where ``saveopts`` is placed on the command line. Configuration File Options -------------------------- Normally, settings such as options and aliases are saved to the project's local ``setup.cfg`` file. But you can override this and save them to the global or per-user configuration files, or to a manually-specified filename. ``--global-config, -g`` Save settings to the global ``distutils.cfg`` file inside the ``distutils`` package directory. You must have write access to that directory to use this option. You also can't combine this option with ``-u`` or ``-f``. ``--user-config, -u`` Save settings to the current user's ``~/.pydistutils.cfg`` (POSIX) or ``$HOME/pydistutils.cfg`` (Windows) file. You can't combine this option with ``-g`` or ``-f``. ``--filename=FILENAME, -f FILENAME`` Save settings to the specified configuration file to use. You can't combine this option with ``-g`` or ``-u``. Note that if you specify a non-standard filename, the ``distutils`` and ``setuptools`` will not use the file's contents. This option is mainly included for use in testing. These options are used by other ``setuptools`` commands that modify configuration files, such as the `alias`_ and `setopt`_ commands. .. _setopt: ``setopt`` - Set a distutils or setuptools option in a config file ================================================================== This command is mainly for use by scripts, but it can also be used as a quick and dirty way to change a distutils configuration option without having to remember what file the options are in and then open an editor. **Example 1**. Set the default C compiler to ``mingw32`` (using long option names):: setup.py setopt --command=build --option=compiler --set-value=mingw32 **Example 2**. Remove any setting for the distutils default package installation directory (short option names):: setup.py setopt -c install -o install_lib -r Options for the ``setopt`` command: ``--command=COMMAND, -c COMMAND`` Command to set the option for. This option is required. ``--option=OPTION, -o OPTION`` The name of the option to set. This option is required. ``--set-value=VALUE, -s VALUE`` The value to set the option to. Not needed if ``-r`` or ``--remove`` is set. ``--remove, -r`` Remove (unset) the option, instead of setting it. In addition to the above options, you may use any of the `configuration file options`_ (listed under the `saveopts`_ command, above) to determine which distutils configuration file the option will be added to (or removed from). .. _test: ``test`` - Build package and run a unittest suite ================================================= .. warning:: ``test`` is deprecated and will be removed in a future version. Users looking for a generic test entry point independent of test runner are encouraged to use `tox `_. When doing test-driven development, or running automated builds that need testing before they are deployed for downloading or use, it's often useful to be able to run a project's unit tests without actually deploying the project anywhere, even using the ``develop`` command. The ``test`` command runs a project's unit tests without actually deploying it, by temporarily putting the project's source on ``sys.path``, after first running ``build_ext -i`` and ``egg_info`` to ensure that any C extensions and project metadata are up-to-date. To use this command, your project's tests must be wrapped in a ``unittest`` test suite by either a function, a ``TestCase`` class or method, or a module or package containing ``TestCase`` classes. If the named suite is a module, and the module has an ``additional_tests()`` function, it is called and the result (which must be a ``unittest.TestSuite``) is added to the tests to be run. If the named suite is a package, any submodules and subpackages are recursively added to the overall test suite. (Note: if your project specifies a ``test_loader``, the rules for processing the chosen ``test_suite`` may differ; see the :ref:`test_loader ` documentation for more details.) Note that many test systems including ``doctest`` support wrapping their non-``unittest`` tests in ``TestSuite`` objects. So, if you are using a test package that does not support this, we suggest you encourage its developers to implement test suite support, as this is a convenient and standard way to aggregate a collection of tests to be run under a common test harness. By default, tests will be run in the "verbose" mode of the ``unittest`` package's text test runner, but you can get the "quiet" mode (just dots) if you supply the ``-q`` or ``--quiet`` option, either as a global option to the setup script (e.g. ``setup.py -q test``) or as an option for the ``test`` command itself (e.g. ``setup.py test -q``). There is one other option available: ``--test-suite=NAME, -s NAME`` Specify the test suite (or module, class, or method) to be run (e.g. ``some_module.test_suite``). The default for this option can be set by giving a ``test_suite`` argument to the ``setup()`` function, e.g.:: setup( # ... test_suite="my_package.tests.test_all" ) If you did not set a ``test_suite`` in your ``setup()`` call, and do not provide a ``--test-suite`` option, an error will occur. New in 41.5.0: Deprecated the test command. .. _upload: ``upload`` - Upload source and/or egg distributions to PyPI =========================================================== The ``upload`` command was deprecated in version 40.0 and removed in version 42.0. Use `twine `_ instead. For more information on the current best practices in uploading your packages to PyPI, see the Python Packaging User Guide's "Packaging Python Projects" tutorial specifically the section on `uploading the distribution archives `_. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/datafiles.rst0000644000175100001710000001730100000000000021010 0ustar00runnerdocker==================== Data Files Support ==================== The distutils have traditionally allowed installation of "data files", which are placed in a platform-specific location. However, the most common use case for data files distributed with a package is for use *by* the package, usually by including the data files in the package directory. Setuptools offers three ways to specify data files to be included in your packages. First, you can simply use the ``include_package_data`` keyword, e.g.:: from setuptools import setup, find_packages setup( ... include_package_data=True ) This tells setuptools to install any data files it finds in your packages. The data files must be specified via the distutils' ``MANIFEST.in`` file. (They can also be tracked by a revision control system, using an appropriate plugin. See the section below on :ref:`Adding Support for Revision Control Systems` for information on how to write such plugins.) If you want finer-grained control over what files are included (for example, if you have documentation files in your package directories and want to exclude them from installation), then you can also use the ``package_data`` keyword, e.g.:: from setuptools import setup, find_packages setup( ... package_data={ # If any package contains *.txt or *.rst files, include them: "": ["*.txt", "*.rst"], # And include any *.msg files found in the "hello" package, too: "hello": ["*.msg"], } ) The ``package_data`` argument is a dictionary that maps from package names to lists of glob patterns. The globs may include subdirectory names, if the data files are contained in a subdirectory of the package. For example, if the package tree looks like this:: setup.py src/ mypkg/ __init__.py mypkg.txt data/ somefile.dat otherdata.dat The setuptools setup file might look like this:: from setuptools import setup, find_packages setup( ... packages=find_packages("src"), # include all packages under src package_dir={"": "src"}, # tell distutils packages are under src package_data={ # If any package contains *.txt files, include them: "": ["*.txt"], # And include any *.dat files found in the "data" subdirectory # of the "mypkg" package, also: "mypkg": ["data/*.dat"], } ) Notice that if you list patterns in ``package_data`` under the empty string, these patterns are used to find files in every package, even ones that also have their own patterns listed. Thus, in the above example, the ``mypkg.txt`` file gets included even though it's not listed in the patterns for ``mypkg``. Also notice that if you use paths, you *must* use a forward slash (``/``) as the path separator, even if you are on Windows. Setuptools automatically converts slashes to appropriate platform-specific separators at build time. If datafiles are contained in a subdirectory of a package that isn't a package itself (no ``__init__.py``), then the subdirectory names (or ``*``) are required in the ``package_data`` argument (as shown above with ``"data/*.dat"``). When building an ``sdist``, the datafiles are also drawn from the ``package_name.egg-info/SOURCES.txt`` file, so make sure that this is removed if the ``setup.py`` ``package_data`` list is updated before calling ``setup.py``. (Note: although the ``package_data`` argument was previously only available in ``setuptools``, it was also added to the Python ``distutils`` package as of Python 2.4; there is `some documentation for the feature`__ available on the python.org website. If using the setuptools-specific ``include_package_data`` argument, files specified by ``package_data`` will *not* be automatically added to the manifest unless they are listed in the MANIFEST.in file.) __ https://docs.python.org/3/distutils/setupscript.html#installing-package-data Sometimes, the ``include_package_data`` or ``package_data`` options alone aren't sufficient to precisely define what files you want included. For example, you may want to include package README files in your revision control system and source distributions, but exclude them from being installed. So, setuptools offers an ``exclude_package_data`` option as well, that allows you to do things like this:: from setuptools import setup, find_packages setup( ... packages=find_packages("src"), # include all packages under src package_dir={"": "src"}, # tell distutils packages are under src include_package_data=True, # include everything in source control # ...but exclude README.txt from all packages exclude_package_data={"": ["README.txt"]}, ) The ``exclude_package_data`` option is a dictionary mapping package names to lists of wildcard patterns, just like the ``package_data`` option. And, just as with that option, a key of ``""`` will apply the given pattern(s) to all packages. However, any files that match these patterns will be *excluded* from installation, even if they were listed in ``package_data`` or were included as a result of using ``include_package_data``. In summary, the three options allow you to: ``include_package_data`` Accept all data files and directories matched by ``MANIFEST.in``. ``package_data`` Specify additional patterns to match files that may or may not be matched by ``MANIFEST.in`` or found in source control. ``exclude_package_data`` Specify patterns for data files and directories that should *not* be included when a package is installed, even if they would otherwise have been included due to the use of the preceding options. NOTE: Due to the way the distutils build process works, a data file that you include in your project and then stop including may be "orphaned" in your project's build directories, requiring you to run ``setup.py clean --all`` to fully remove them. This may also be important for your users and contributors if they track intermediate revisions of your project using Subversion; be sure to let them know when you make changes that remove files from inclusion so they can run ``setup.py clean --all``. .. _Accessing Data Files at Runtime: Accessing Data Files at Runtime ------------------------------- Typically, existing programs manipulate a package's ``__file__`` attribute in order to find the location of data files. However, this manipulation isn't compatible with PEP 302-based import hooks, including importing from zip files and Python Eggs. It is strongly recommended that, if you are using data files, you should use the :ref:`ResourceManager API` of ``pkg_resources`` to access them. The ``pkg_resources`` module is distributed as part of setuptools, so if you're using setuptools to distribute your package, there is no reason not to use its resource management API. See also `Importlib Resources`_ for a quick example of converting code that uses ``__file__`` to use ``pkg_resources`` instead. .. _Importlib Resources: https://docs.python.org/3/library/importlib.html#module-importlib.resources Non-Package Data Files ---------------------- Historically, ``setuptools`` by way of ``easy_install`` would encapsulate data files from the distribution into the egg (see `the old docs `_). As eggs are deprecated and pip-based installs fall back to the platform-specific location for installing data files, there is no supported facility to reliably retrieve these resources. Instead, the PyPA recommends that any data files you wish to be accessible at run time be included in the package. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/declarative_config.rst0000644000175100001710000002446700000000000022677 0ustar00runnerdocker.. _declarative config: ----------------------------------------- Configuring setup() using setup.cfg files ----------------------------------------- .. note:: New in 30.3.0 (8 Dec 2016). .. important:: If compatibility with legacy builds (i.e. those not using the :pep:`517` build API) is desired, a ``setup.py`` file containing a ``setup()`` function call is still required even if your configuration resides in ``setup.cfg``. ``Setuptools`` allows using configuration files (usually :file:`setup.cfg`) to define a package’s metadata and other options that are normally supplied to the ``setup()`` function (declarative config). This approach not only allows automation scenarios but also reduces boilerplate code in some cases. .. _example-setup-config: .. code-block:: ini [metadata] name = my_package version = attr: src.VERSION description = My package description long_description = file: README.rst, CHANGELOG.rst, LICENSE.rst keywords = one, two license = BSD 3-Clause License classifiers = Framework :: Django License :: OSI Approved :: BSD License Programming Language :: Python :: 3 Programming Language :: Python :: 3.5 [options] zip_safe = False include_package_data = True packages = find: scripts = bin/first.py bin/second.py install_requires = requests importlib; python_version == "2.6" [options.package_data] * = *.txt, *.rst hello = *.msg [options.entry_points] console_scripts = executable-name = package.module:function [options.extras_require] pdf = ReportLab>=1.2; RXP rest = docutils>=0.3; pack ==1.1, ==1.3 [options.packages.find] exclude = src.subpackage1 src.subpackage2 Metadata and options are set in the config sections of the same name. * Keys are the same as the keyword arguments one provides to the ``setup()`` function. * Complex values can be written comma-separated or placed one per line in *dangling* config values. The following are equivalent: .. code-block:: ini [metadata] keywords = one, two [metadata] keywords = one two * In some cases, complex values can be provided in dedicated subsections for clarity. * Some keys allow ``file:``, ``attr:``, ``find:``, and ``find_namespace:`` directives in order to cover common usecases. * Unknown keys are ignored. Using a ``src/`` layout ======================= One commonly used package configuration has all the module source code in a subdirectory (often called the ``src/`` layout), like this:: ├── src │   └── mypackage │   ├── __init__.py │   └── mod1.py ├── setup.py └── setup.cfg You can set up your ``setup.cfg`` to automatically find all your packages in the subdirectory like this: .. code-block:: ini # This example contains just the necessary options for a src-layout, set up # the rest of the file as described above. [options] package_dir= =src packages=find: [options.packages.find] where=src Specifying values ================= Some values are treated as simple strings, some allow more logic. Type names used below: * ``str`` - simple string * ``list-comma`` - dangling list or string of comma-separated values * ``list-semi`` - dangling list or string of semicolon-separated values * ``bool`` - ``True`` is 1, yes, true * ``dict`` - list-comma where keys are separated from values by ``=`` * ``section`` - values are read from a dedicated (sub)section Special directives: * ``attr:`` - Value is read from a module attribute. ``attr:`` supports callables and iterables; unsupported types are cast using ``str()``. In order to support the common case of a literal value assigned to a variable in a module containing (directly or indirectly) third-party imports, ``attr:`` first tries to read the value from the module by examining the module's AST. If that fails, ``attr:`` falls back to importing the module. * ``file:`` - Value is read from a list of files and then concatenated .. note:: The ``file:`` directive is sandboxed and won't reach anything outside the directory containing ``setup.py``. Metadata -------- .. note:: The aliases given below are supported for compatibility reasons, but their use is not advised. ============================== ================= ================= =============== ========== Key Aliases Type Minimum Version Notes ============================== ================= ================= =============== ========== name str version attr:, file:, str 39.2.0 [#meta-1]_ url home-page str download_url download-url str project_urls dict 38.3.0 author str author_email author-email str maintainer str maintainer_email maintainer-email str classifiers classifier file:, list-comma license str license_files license_file list-comma 42.0.0 description summary file:, str long_description long-description file:, str long_description_content_type str 38.6.0 keywords list-comma platforms platform list-comma provides list-comma requires list-comma obsoletes list-comma ============================== ================= ================= =============== ========== **Notes**: .. [#meta-1] The ``version`` file attribute has only been supported since 39.2.0. A version loaded using the ``file:`` directive must comply with PEP 440. It is easy to accidentally put something other than a valid version string in such a file, so validation is stricter in this case. Options ------- ======================= =================================== =============== ========= Key Type Minimum Version Notes ======================= =================================== =============== ========= zip_safe bool setup_requires list-semi 36.7.0 install_requires list-semi extras_require section [#opt-2]_ python_requires str 34.4.0 entry_points file:, section 51.0.0 scripts list-comma eager_resources list-comma dependency_links list-comma tests_require list-semi include_package_data bool packages find:, find_namespace:, list-comma [#opt-3]_ package_dir dict package_data section [#opt-1]_ exclude_package_data section namespace_packages list-comma py_modules list-comma 34.4.0 data_files section 40.6.0 [#opt-4]_ ======================= =================================== =============== ========= **Notes**: .. [#opt-1] In the ``package_data`` section, a key named with a single asterisk (``*``) refers to all packages, in lieu of the empty string used in ``setup.py``. .. [#opt-2] In the ``extras_require`` section, values are parsed as ``list-semi``. This implies that in order to include markers, they **must** be *dangling*: .. code-block:: ini [options.extras_require] rest = docutils>=0.3; pack ==1.1, ==1.3 pdf = ReportLab>=1.2 RXP importlib-metadata; python_version < "3.8" .. [#opt-3] The ``find:`` and ``find_namespace:`` directive can be further configured in a dedicated subsection ``options.packages.find``. This subsection accepts the same keys as the ``setuptools.find_packages`` and the ``setuptools.find_namespace_packages`` function: ``where``, ``include``, and ``exclude``. The ``find_namespace:`` directive is supported since Python >=3.3. .. [#opt-4] ``data_files`` is deprecated and should be avoided. Please check :doc:`/userguide/datafiles` for more information. Compatibility with other tools ============================== Historically, several tools explored declarative package configuration in parallel. And several of them chose to place the packaging configuration within the project's :file:`setup.cfg` file. One of the first was ``distutils2``, which development has stopped in 2013. Other include ``pbr`` which is still under active development or ``d2to1``, which was a plug-in that backports declarative configuration to ``distutils``, but has had no release since Oct. 2015. As a way to harmonize packaging tools, ``setuptools``, having held the position of *de facto* standard, has gradually integrated those features as part of its core features. Still this has lead to some confusion and feature incompatibilities: - some tools support features others don't; - some have similar features but the declarative syntax differs; The table below tries to summarize the differences. But, please, refer to each tool documentation for up-to-date information. =========================== ========== ========== ===== === feature setuptools distutils2 d2to1 pbr =========================== ========== ========== ===== === [metadata] description-file S Y Y Y [files] S Y Y Y entry_points Y Y Y S [backwards_compat] N Y Y Y =========================== ========== ========== ===== === Y: supported, N: unsupported, S: syntax differs (see :ref:`above example`). Also note that some features were only recently added to ``setuptools``. Please refer to the previous sections to find out when. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/dependency_management.rst0000644000175100001710000002527100000000000023373 0ustar00runnerdocker===================================== Dependencies Management in Setuptools ===================================== There are three types of dependency styles offered by setuptools: 1) build system requirement, 2) required dependency and 3) optional dependency. .. Note:: Packages that are added to dependency can be optionally specified with the version by following `PEP 440 `_ Build system requirement ======================== Package requirement ------------------- After organizing all the scripts and files and getting ready for packaging, there needs to be a way to tell Python what programs it needs to actually do the packaging (in our case, ``setuptools`` of course). Usually, you also need the ``wheel`` package as well since it is recommended that you upload a ``.whl`` file to PyPI alongside your ``.tar.gz`` file. Unlike the other two types of dependency keyword, this one is specified in your ``pyproject.toml`` file (if you have forgot what this is, go to :doc:`quickstart` or (WIP)): .. code-block:: ini [build-system] requires = ["setuptools", "wheel"] #... .. note:: This used to be accomplished with the ``setup_requires`` keyword but is now considered deprecated in favor of the PEP 517 style described above. To peek into how this legacy keyword is used, consult our :doc:`guide on deprecated practice (WIP) <../deprecated/index>` .. _Declaring Dependencies: Declaring required dependency ============================= This is where a package declares its core dependencies, without which it won't be able to run. ``setuptools`` support automatically download and install these dependencies when the package is installed. Although there is more finesse to it, let's start with a simple example. .. tab:: setup.cfg .. code-block:: ini [options] #... install_requires = docutils BazSpam ==1.1 .. tab:: setup.py .. code-block:: python setup( ..., install_requires=[ 'docutils', 'BazSpam ==1.1', ], ) When your project is installed (e.g. using pip), all of the dependencies not already installed will be located (via PyPI), downloaded, built (if necessary), and installed and 2) Any scripts in your project will be installed with wrappers that verify the availability of the specified dependencies at runtime. Platform specific dependencies ------------------------------ Setuptools offer the capability to evaluate certain conditions before blindly installing everything listed in ``install_requires``. This is great for platform specific dependencies. For example, the ``enum`` package was added in Python 3.4, therefore, package that depends on it can elect to install it only when the Python version is older than 3.4. To accomplish this .. tab:: setup.cfg .. code-block:: ini [options] #... install_requires = enum34;python_version<'3.4' .. tab:: setup.py .. code-block:: python setup( ..., install_requires=[ "enum34;python_version<'3.4'", ], ) Similarly, if you also wish to declare ``pywin32`` with a minimal version of 1.0 and only install it if the user is using a Windows operating system: .. tab:: setup.cfg .. code-block:: ini [options] #... install_requires = enum34;python_version<'3.4' pywin32 >= 1.0;platform_system=='Windows' .. tab:: setup.py .. code-block:: python setup( ..., install_requires=[ "enum34;python_version<'3.4'", "pywin32 >= 1.0;platform_system=='Windows'", ], ) The environmental markers that may be used for testing platform types are detailed in `PEP 508 `_. Dependencies that aren't in PyPI -------------------------------- .. warning:: Dependency links support has been dropped by pip starting with version 19.0 (released 2019-01-22). If your project depends on packages that don't exist on PyPI, you may still be able to depend on them, as long as they are available for download as: - an egg, in the standard distutils ``sdist`` format, - a single ``.py`` file, or - a VCS repository (Subversion, Mercurial, or Git). You just need to add some URLs to the ``dependency_links`` argument to ``setup()``. The URLs must be either: 1. direct download URLs, 2. the URLs of web pages that contain direct download links, or 3. the repository's URL In general, it's better to link to web pages, because it is usually less complex to update a web page than to release a new version of your project. You can also use a SourceForge ``showfiles.php`` link in the case where a package you depend on is distributed via SourceForge. If you depend on a package that's distributed as a single ``.py`` file, you must include an ``"#egg=project-version"`` suffix to the URL, to give a project name and version number. (Be sure to escape any dashes in the name or version by replacing them with underscores.) EasyInstall will recognize this suffix and automatically create a trivial ``setup.py`` to wrap the single ``.py`` file as an egg. In the case of a VCS checkout, you should also append ``#egg=project-version`` in order to identify for what package that checkout should be used. You can append ``@REV`` to the URL's path (before the fragment) to specify a revision. Additionally, you can also force the VCS being used by prepending the URL with a certain prefix. Currently available are: - ``svn+URL`` for Subversion, - ``git+URL`` for Git, and - ``hg+URL`` for Mercurial A more complete example would be: ``vcs+proto://host/path@revision#egg=project-version`` Be careful with the version. It should match the one inside the project files. If you want to disregard the version, you have to omit it both in the ``requires`` and in the URL's fragment. This will do a checkout (or a clone, in Git and Mercurial parlance) to a temporary folder and run ``setup.py bdist_egg``. The ``dependency_links`` option takes the form of a list of URL strings. For example, this will cause a search of the specified page for eggs or source distributions, if the package's dependencies aren't already installed: .. tab:: setup.cfg .. code-block:: ini [options] #... dependency_links = http://peak.telecommunity.com/snapshots/ .. tab:: setup.py .. code-block:: python setup( ..., dependency_links=[ "http://peak.telecommunity.com/snapshots/", ], ) Optional dependencies ===================== Setuptools allows you to declare dependencies that only get installed under specific circumstances. These dependencies are specified with ``extras_require`` keyword and are only installed if another package depends on it (either directly or indirectly) This makes it convenient to declare dependencies for ancillary functions such as "tests" and "docs". .. note:: ``tests_require`` is now deprecated For example, Package-A offers optional PDF support and requires two other dependencies for it to work: .. tab:: setup.cfg .. code-block:: ini [metadata] name = Package-A [options.extras_require] PDF = ReportLab>=1.2; RXP .. tab:: setup.py .. code-block:: python setup( name="Project-A", ..., extras_require={ "PDF": ["ReportLab>=1.2", "RXP"], }, ) The name ``PDF`` is an arbitrary identifier of such a list of dependencies, to which other components can refer and have them installed. There are two common use cases. First is the console_scripts entry point: .. tab:: setup.cfg .. code-block:: ini [metadata] name = Project A #... [options] #... entry_points= [console_scripts] rst2pdf = project_a.tools.pdfgen [PDF] rst2html = project_a.tools.htmlgen .. tab:: setup.py .. code-block:: python setup( name="Project-A", ..., entry_points={ "console_scripts": [ "rst2pdf = project_a.tools.pdfgen [PDF]", "rst2html = project_a.tools.htmlgen", ], }, ) This syntax indicates that the entry point (in this case a console script) is only valid when the PDF extra is installed. It is up to the installer to determine how to handle the situation where PDF was not indicated (e.g. omit the console script, provide a warning when attempting to load the entry point, assume the extras are present and let the implementation fail later). The second use case is that other package can use this "extra" for their own dependencies. For example, if "Project-B" needs "project A" with PDF support installed, it might declare the dependency like this: .. tab:: setup.cfg .. code-block:: ini [metadata] name = Project-B #... [options] #... install_requires = Project-A[PDF] .. tab:: setup.py .. code-block:: python setup( name="Project-B", install_requires=["Project-A[PDF]"], ..., ) This will cause ReportLab to be installed along with project A, if project B is installed -- even if project A was already installed. In this way, a project can encapsulate groups of optional "downstream dependencies" under a feature name, so that packages that depend on it don't have to know what the downstream dependencies are. If a later version of Project A builds in PDF support and no longer needs ReportLab, or if it ends up needing other dependencies besides ReportLab in order to provide PDF support, Project B's setup information does not need to change, but the right packages will still be installed if needed. .. note:: Best practice: if a project ends up not needing any other packages to support a feature, it should keep an empty requirements list for that feature in its ``extras_require`` argument, so that packages depending on that feature don't break (due to an invalid feature name). Python requirement ================== In some cases, you might need to specify the minimum required python version. This is handled with the ``python_requires`` keyword supplied to ``setup.cfg`` or ``setup.py``. .. tab:: setup.cfg .. code-block:: ini [metadata] name = Project-B #... [options] #... python_requires = >=3.6 .. tab:: setup.py .. code-block:: python setup( name="Project-B", python_requires=">=3.6", ..., ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/development_mode.rst0000644000175100001710000000536400000000000022410 0ustar00runnerdocker"Development Mode" ================== Under normal circumstances, the ``distutils`` assume that you are going to build a distribution of your project, not use it in its "raw" or "unbuilt" form. However, if you were to use the ``distutils`` to build a distribution, you would have to rebuild and reinstall your project every time you made a change to it during development. Another problem that sometimes comes up with the ``distutils`` is that you may need to do development on two related projects at the same time. You may need to put both projects' packages in the same directory to run them, but need to keep them separate for revision control purposes. How can you do this? Setuptools allows you to deploy your projects for use in a common directory or staging area, but without copying any files. Thus, you can edit each project's code in its checkout directory, and only need to run build commands when you change a project's C extensions or similarly compiled files. You can even deploy a project into another project's checkout directory, if that's your preferred way of working (as opposed to using a common independent staging area or the site-packages directory). To do this, use the ``setup.py develop`` command. It works very similarly to ``setup.py install``, except that it doesn't actually install anything. Instead, it creates a special ``.egg-link`` file in the deployment directory, that links to your project's source code. And, if your deployment directory is Python's ``site-packages`` directory, it will also update the ``easy-install.pth`` file to include your project's source code, thereby making it available on ``sys.path`` for all programs using that Python installation. In addition, the ``develop`` command creates wrapper scripts in the target script directory that will run your in-development scripts after ensuring that all your ``install_requires`` packages are available on ``sys.path``. You can deploy the same project to multiple staging areas, e.g. if you have multiple projects on the same machine that are sharing the same project you're doing development work. When you're done with a given development task, you can remove the project source from a staging area using ``setup.py develop --uninstall``, specifying the desired staging area if it's not the default. There are several options to control the precise behavior of the ``develop`` command; see the section on the :ref:`develop ` command below for more details. Note that you can also apply setuptools commands to non-setuptools projects, using commands like this:: python -c "import setuptools; with open('setup.py') as f: exec(compile(f.read(), 'setup.py', 'exec'))" develop That is, you can simply list the normal setup commands and options following the quoted part. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/distribution.rst0000644000175100001710000003071400000000000021576 0ustar00runnerdockerTagging and "Daily Build" or "Snapshot" Releases ------------------------------------------------ When a set of related projects are under development, it may be important to track finer-grained version increments than you would normally use for e.g. "stable" releases. While stable releases might be measured in dotted numbers with alpha/beta/etc. status codes, development versions of a project often need to be tracked by revision or build number or even build date. This is especially true when projects in development need to refer to one another, and therefore may literally need an up-to-the-minute version of something! To support these scenarios, ``setuptools`` allows you to "tag" your source and egg distributions by adding one or more of the following to the project's "official" version identifier: * A manually-specified pre-release tag, such as "build" or "dev", or a manually-specified post-release tag, such as a build or revision number (``--tag-build=STRING, -bSTRING``) * An 8-character representation of the build date (``--tag-date, -d``), as a postrelease tag You can add these tags by adding ``egg_info`` and the desired options to the command line ahead of the ``sdist`` or ``bdist`` commands that you want to generate a daily build or snapshot for. See the section below on the :ref:`egg_info ` command for more details. (Also, before you release your project, be sure to see the section on :ref:`Specifying Your Project's Version` for more information about how pre- and post-release tags affect how version numbers are interpreted. This is important in order to make sure that dependency processing tools will know which versions of your project are newer than others.) Finally, if you are creating builds frequently, and either building them in a downloadable location or are copying them to a distribution server, you should probably also check out the :ref:`rotate ` command, which lets you automatically delete all but the N most-recently-modified distributions matching a glob pattern. So, you can use a command line like:: setup.py egg_info -rbDEV bdist_egg rotate -m.egg -k3 to build an egg whose version info includes "DEV-rNNNN" (where NNNN is the most recent Subversion revision that affected the source tree), and then delete any egg files from the distribution directory except for the three that were built most recently. If you have to manage automated builds for multiple packages, each with different tagging and rotation policies, you may also want to check out the :ref:`alias ` command, which would let each package define an alias like ``daily`` that would perform the necessary tag, build, and rotate commands. Then, a simpler script or cron job could just run ``setup.py daily`` in each project directory. (And, you could also define sitewide or per-user default versions of the ``daily`` alias, so that projects that didn't define their own would use the appropriate defaults.) Generating Source Distributions ------------------------------- ``setuptools`` enhances the distutils' default algorithm for source file selection with pluggable endpoints for looking up files to include. If you are using a revision control system, and your source distributions only need to include files that you're tracking in revision control, use a corresponding plugin instead of writing a ``MANIFEST.in`` file. See the section below on :ref:`Adding Support for Revision Control Systems` for information on plugins. If you need to include automatically generated files, or files that are kept in an unsupported revision control system, you'll need to create a ``MANIFEST.in`` file to specify any files that the default file location algorithm doesn't catch. See the distutils documentation for more information on the format of the ``MANIFEST.in`` file. But, be sure to ignore any part of the distutils documentation that deals with ``MANIFEST`` or how it's generated from ``MANIFEST.in``; setuptools shields you from these issues and doesn't work the same way in any case. Unlike the distutils, setuptools regenerates the source distribution manifest file every time you build a source distribution, and it builds it inside the project's ``.egg-info`` directory, out of the way of your main project directory. You therefore need not worry about whether it is up-to-date or not. Indeed, because setuptools' approach to determining the contents of a source distribution is so much simpler, its ``sdist`` command omits nearly all of the options that the distutils' more complex ``sdist`` process requires. For all practical purposes, you'll probably use only the ``--formats`` option, if you use any option at all. Making "Official" (Non-Snapshot) Releases ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ When you make an official release, creating source or binary distributions, you will need to override the tag settings from ``setup.cfg``, so that you don't end up registering versions like ``foobar-0.7a1.dev-r34832``. This is easy to do if you are developing on the trunk and using tags or branches for your releases - just make the change to ``setup.cfg`` after branching or tagging the release, so the trunk will still produce development snapshots. Alternately, if you are not branching for releases, you can override the default version options on the command line, using something like:: setup.py egg_info -Db "" sdist bdist_egg The first part of this command (``egg_info -Db ""``) will override the configured tag information, before creating source and binary eggs. Thus, these commands will use the plain version from your ``setup.py``, without adding the build designation string. Of course, if you will be doing this a lot, you may wish to create a personal alias for this operation, e.g.:: setup.py alias -u release egg_info -Db "" You can then use it like this:: setup.py release sdist bdist_egg Or of course you can create more elaborate aliases that do all of the above. See the sections below on the :ref:`egg_info ` and :ref:`alias ` commands for more ideas. Distributing Extensions compiled with Cython -------------------------------------------- ``setuptools`` will detect at build time whether Cython is installed or not. If Cython is not found ``setuptools`` will ignore pyx files. To ensure Cython is available, include Cython in the build-requires section of your pyproject.toml:: [build-system] requires=[..., "cython"] Built with pip 10 or later, that declaration is sufficient to include Cython in the build. For broader compatibility, declare the dependency in your setup-requires of setup.cfg:: [options] setup_requires = ... cython As long as Cython is present in the build environment, ``setuptools`` includes transparent support for building Cython extensions, as long as extensions are defined using ``setuptools.Extension``. If you follow these rules, you can safely list ``.pyx`` files as the source of your ``Extension`` objects in the setup script. If it is, then ``setuptools`` will use it. Of course, for this to work, your source distributions must include the C code generated by Cython, as well as your original ``.pyx`` files. This means that you will probably want to include current ``.c`` files in your revision control system, rebuilding them whenever you check changes in for the ``.pyx`` source files. This will ensure that people tracking your project in a revision control system will be able to build it even if they don't have Cython installed, and that your source releases will be similarly usable with or without Cython. .. _Specifying Your Project's Version: Specifying Your Project's Version --------------------------------- Setuptools can work well with most versioning schemes. Over the years, setuptools has tried to closely follow the `PEP 440 `_ scheme, but it also supports legacy versions. There are, however, a few special things to watch out for, in order to ensure that setuptools and other tools can always tell what version of your package is newer than another version. Knowing these things will also help you correctly specify what versions of other projects your project depends on. A version consists of an alternating series of release numbers and pre-release or post-release tags. A release number is a series of digits punctuated by dots, such as ``2.4`` or ``0.5``. Each series of digits is treated numerically, so releases ``2.1`` and ``2.1.0`` are different ways to spell the same release number, denoting the first subrelease of release 2. But ``2.10`` is the *tenth* subrelease of release 2, and so is a different and newer release from ``2.1`` or ``2.1.0``. Leading zeros within a series of digits are also ignored, so ``2.01`` is the same as ``2.1``, and different from ``2.0.1``. Following a release number, you can have either a pre-release or post-release tag. Pre-release tags make a version be considered *older* than the version they are appended to. So, revision ``2.4`` is *newer* than revision ``2.4c1``, which in turn is newer than ``2.4b1`` or ``2.4a1``. Postrelease tags make a version be considered *newer* than the version they are appended to. So, revisions like ``2.4-1`` are newer than ``2.4``, but *older* than ``2.4.1`` (which has a higher release number). In the case of legacy versions (for example, ``2.4pl1``), they are considered older than non-legacy versions. Taking that in count, a revision ``2.4pl1`` is *older* than ``2.4`` A pre-release tag is a series of letters that are alphabetically before "final". Some examples of prerelease tags would include ``alpha``, ``beta``, ``a``, ``c``, ``dev``, and so on. You do not have to place a dot or dash before the prerelease tag if it's immediately after a number, but it's okay to do so if you prefer. Thus, ``2.4c1`` and ``2.4.c1`` and ``2.4-c1`` all represent release candidate 1 of version ``2.4``, and are treated as identical by setuptools. In addition, there are three special prerelease tags that are treated as if they were the letter ``c``: ``pre``, ``preview``, and ``rc``. So, version ``2.4rc1``, ``2.4pre1`` and ``2.4preview1`` are all the exact same version as ``2.4c1``, and are treated as identical by setuptools. A post-release tag is either a series of letters that are alphabetically greater than or equal to "final", or a dash (``-``). Post-release tags are generally used to separate patch numbers, port numbers, build numbers, revision numbers, or date stamps from the release number. For example, the version ``2.4-r1263`` might denote Subversion revision 1263 of a post-release patch of version ``2.4``. Or you might use ``2.4-20051127`` to denote a date-stamped post-release. Notice that after each pre or post-release tag, you are free to place another release number, followed again by more pre- or post-release tags. For example, ``0.6a9.dev-r41475`` could denote Subversion revision 41475 of the in- development version of the ninth alpha of release 0.6. Notice that ``dev`` is a pre-release tag, so this version is a *lower* version number than ``0.6a9``, which would be the actual ninth alpha of release 0.6. But the ``-r41475`` is a post-release tag, so this version is *newer* than ``0.6a9.dev``. For the most part, setuptools' interpretation of version numbers is intuitive, but here are a few tips that will keep you out of trouble in the corner cases: * Don't stick adjoining pre-release tags together without a dot or number between them. Version ``1.9adev`` is the ``adev`` prerelease of ``1.9``, *not* a development pre-release of ``1.9a``. Use ``.dev`` instead, as in ``1.9a.dev``, or separate the prerelease tags with a number, as in ``1.9a0dev``. ``1.9a.dev``, ``1.9a0dev``, and even ``1.9.a.dev`` are identical versions from setuptools' point of view, so you can use whatever scheme you prefer. * If you want to be certain that your chosen numbering scheme works the way you think it will, you can use the ``pkg_resources.parse_version()`` function to compare different version numbers:: >>> from pkg_resources import parse_version >>> parse_version("1.9.a.dev") == parse_version("1.9a0dev") True >>> parse_version("2.1-rc2") < parse_version("2.1") True >>> parse_version("0.6a9dev-r41475") < parse_version("0.6a9") True Once you've decided on a version numbering scheme for your project, you can have setuptools automatically tag your in-development releases with various pre- or post-release tags. See the following sections for more details: * `Tagging and "Daily Build" or "Snapshot" Releases`_ * The :ref:`egg_info ` command ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/entry_point.rst0000644000175100001710000001221100000000000021421 0ustar00runnerdocker.. _`entry_points`: ============ Entry Points ============ Packages may provide commands to be run at the console (console scripts), such as the ``pip`` command. These commands are defined for a package as a specific kind of entry point in the ``setup.cfg`` or ``setup.py``. Console Scripts =============== First consider an example without entry points. Imagine a package defined thus: .. code-block:: bash timmins/ timmins/__init__.py timmins/__main__.py setup.cfg # or setup.py #other necessary files with ``__init__.py`` as: .. code-block:: python def hello_world(): print("Hello world") and ``__main__.py`` providing a hook: .. code-block:: python from . import hello_world if __name__ == '__main__': hello_world() After installing the package, the function may be invoked through the `runpy `_ module: .. code-block:: bash python -m timmins Adding a console script entry point allows the package to define a user-friendly name for installers of the package to execute. Installers like pip will create wrapper scripts to execute a function. In the above example, to create a command ``hello-world`` that invokes ``timmins.hello_world``, add a console script entry point to ``setup.cfg``: .. code-block:: ini [options.entry_points] console_scripts = hello-world = timmins:hello_world After installing the package, a user may invoke that function by simply calling ``hello-world`` on the command line. The syntax for entry points is specified as follows: .. code-block:: ini = [.[.]][:.] where ``name`` is the name for the script you want to create, the left hand side of ``:`` is the module that contains your function and the right hand side is the object you want to invoke (e.g. a function). In addition to ``console_scripts``, Setuptools supports ``gui_scripts``, which will launch a GUI application without running in a terminal window. .. _dynamic discovery of services and plugins: Advertising Behavior ==================== Console scripts are one use of the more general concept of entry points. Entry points more generally allow a packager to advertise behavior for discovery by other libraries and applications. This feature enables "plug-in"-like functionality, where one library solicits entry points and any number of other libraries provide those entry points. A good example of this plug-in behavior can be seen in `pytest plugins `_, where pytest is a test framework that allows other libraries to extend or modify its functionality through the ``pytest11`` entry point. The console scripts work similarly, where libraries advertise their commands and tools like ``pip`` create wrapper scripts that invoke those commands. For a project wishing to solicit entry points, Setuptools recommends the `importlib.metadata `_ module (part of stdlib since Python 3.8) or its backport, `importlib_metadata `_. For example, to find the console script entry points from the example above: .. code-block:: pycon >>> from importlib import metadata >>> eps = metadata.entry_points()['console_scripts'] ``eps`` is now a list of ``EntryPoint`` objects, one of which corresponds to the ``hello-world = timmins:hello_world`` defined above. Each ``EntryPoint`` contains the ``name``, ``group``, and ``value``. It also supplies a ``.load()`` method to import and load that entry point (module or object). .. code-block:: ini [options.entry_points] my.plugins = hello-world = timmins:hello_world Then, a different project wishing to load 'my.plugins' plugins could run the following routine to load (and invoke) such plugins: .. code-block:: pycon >>> from importlib import metadata >>> eps = metadata.entry_points()['my.plugins'] >>> for ep in eps: ... plugin = ep.load() ... plugin() ... The project soliciting the entry points needs not to have any dependency or prior knowledge about the libraries implementing the entry points, and downstream users are able to compose functionality by pulling together libraries implementing the entry points. Dependency Management ===================== Some entry points may require additional dependencies to properly function. For such an entry point, declare in square brackets any number of dependency ``extras`` following the entry point definition. Such entry points will only be viable if their extras were declared and installed. See the :doc:`guide on dependencies management ` for more information on defining extra requirements. Consider from the above example: .. code-block:: ini [options.entry_points] console_scripts = hello-world = timmins:hello_world [pretty-printer] In this case, the ``hello-world`` script is only viable if the ``pretty-printer`` extra is indicated, and so a plugin host might exclude that entry point (i.e. not install a console script) if the relevant extra dependencies are not installed. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/extension.rst0000644000175100001710000002554000000000000021074 0ustar00runnerdocker.. _Creating ``distutils`` Extensions: Creating ``distutils`` Extensions ================================= It can be hard to add new commands or setup arguments to the distutils. But the ``setuptools`` package makes it a bit easier, by allowing you to distribute a distutils extension as a separate project, and then have projects that need the extension just refer to it in their ``setup_requires`` argument. With ``setuptools``, your distutils extension projects can hook in new commands and ``setup()`` arguments just by defining "entry points". These are mappings from command or argument names to a specification of where to import a handler from. (See the section on :ref:`Dynamic Discovery of Services and Plugins` above for some more background on entry points.) Adding Commands --------------- You can add new ``setup`` commands by defining entry points in the ``distutils.commands`` group. For example, if you wanted to add a ``foo`` command, you might add something like this to your distutils extension project's setup script:: setup( # ... entry_points={ "distutils.commands": [ "foo = mypackage.some_module:foo", ], }, ) (Assuming, of course, that the ``foo`` class in ``mypackage.some_module`` is a ``setuptools.Command`` subclass.) Once a project containing such entry points has been activated on ``sys.path``, (e.g. by running "install" or "develop" with a site-packages installation directory) the command(s) will be available to any ``setuptools``-based setup scripts. It is not necessary to use the ``--command-packages`` option or to monkeypatch the ``distutils.command`` package to install your commands; ``setuptools`` automatically adds a wrapper to the distutils to search for entry points in the active distributions on ``sys.path``. In fact, this is how setuptools' own commands are installed: the setuptools project's setup script defines entry points for them! .. note:: When creating commands, and specially when defining custom ways of building compiled extensions (for example via ``build_ext``), consider handling exceptions such as ``CompileError``, ``LinkError``, ``LibError``, among others. These exceptions are available in the ``setuptools.errors`` module. Adding ``setup()`` Arguments ---------------------------- .. warning:: Adding arguments to setup is discouraged as such arguments are only supported through imperative execution and not supported through declarative config. Sometimes, your commands may need additional arguments to the ``setup()`` call. You can enable this by defining entry points in the ``distutils.setup_keywords`` group. For example, if you wanted a ``setup()`` argument called ``bar_baz``, you might add something like this to your distutils extension project's setup script:: setup( # ... entry_points={ "distutils.commands": [ "foo = mypackage.some_module:foo", ], "distutils.setup_keywords": [ "bar_baz = mypackage.some_module:validate_bar_baz", ], }, ) The idea here is that the entry point defines a function that will be called to validate the ``setup()`` argument, if it's supplied. The ``Distribution`` object will have the initial value of the attribute set to ``None``, and the validation function will only be called if the ``setup()`` call sets it to a non-None value. Here's an example validation function:: def assert_bool(dist, attr, value): """Verify that value is True, False, 0, or 1""" if bool(value) != value: raise DistutilsSetupError( "%r must be a boolean value (got %r)" % (attr,value) ) Your function should accept three arguments: the ``Distribution`` object, the attribute name, and the attribute value. It should raise a ``DistutilsSetupError`` (from the ``distutils.errors`` module) if the argument is invalid. Remember, your function will only be called with non-None values, and the default value of arguments defined this way is always None. So, your commands should always be prepared for the possibility that the attribute will be ``None`` when they access it later. If more than one active distribution defines an entry point for the same ``setup()`` argument, *all* of them will be called. This allows multiple distutils extensions to define a common argument, as long as they agree on what values of that argument are valid. Also note that as with commands, it is not necessary to subclass or monkeypatch the distutils ``Distribution`` class in order to add your arguments; it is sufficient to define the entry points in your extension, as long as any setup script using your extension lists your project in its ``setup_requires`` argument. Customizing Distribution Options -------------------------------- Plugins may wish to extend or alter the options on a Distribution object to suit the purposes of that project. For example, a tool that infers the ``Distribution.version`` from SCM-metadata may need to hook into the option finalization. To enable this feature, Setuptools offers an entry point "setuptools.finalize_distribution_options". That entry point must be a callable taking one argument (the Distribution instance). If the callable has an ``.order`` property, that value will be used to determine the order in which the hook is called. Lower numbers are called first and the default is zero (0). Plugins may read, alter, and set properties on the distribution, but each plugin is encouraged to load the configuration/settings for their behavior independently. .. _Adding new EGG-INFO Files: Adding new EGG-INFO Files ------------------------- Some extensible applications or frameworks may want to allow third parties to develop plugins with application or framework-specific metadata included in the plugins' EGG-INFO directory, for easy access via the ``pkg_resources`` metadata API. The easiest way to allow this is to create a distutils extension to be used from the plugin projects' setup scripts (via ``setup_requires``) that defines a new setup keyword, and then uses that data to write an EGG-INFO file when the ``egg_info`` command is run. The ``egg_info`` command looks for extension points in an ``egg_info.writers`` group, and calls them to write the files. Here's a simple example of a distutils extension defining a setup argument ``foo_bar``, which is a list of lines that will be written to ``foo_bar.txt`` in the EGG-INFO directory of any project that uses the argument:: setup( # ... entry_points={ "distutils.setup_keywords": [ "foo_bar = setuptools.dist:assert_string_list", ], "egg_info.writers": [ "foo_bar.txt = setuptools.command.egg_info:write_arg", ], }, ) This simple example makes use of two utility functions defined by setuptools for its own use: a routine to validate that a setup keyword is a sequence of strings, and another one that looks up a setup argument and writes it to a file. Here's what the writer utility looks like:: def write_arg(cmd, basename, filename): argname = os.path.splitext(basename)[0] value = getattr(cmd.distribution, argname, None) if value is not None: value = "\n".join(value) + "\n" cmd.write_or_delete_file(argname, filename, value) As you can see, ``egg_info.writers`` entry points must be a function taking three arguments: a ``egg_info`` command instance, the basename of the file to write (e.g. ``foo_bar.txt``), and the actual full filename that should be written to. In general, writer functions should honor the command object's ``dry_run`` setting when writing files, and use the ``distutils.log`` object to do any console output. The easiest way to conform to this requirement is to use the ``cmd`` object's ``write_file()``, ``delete_file()``, and ``write_or_delete_file()`` methods exclusively for your file operations. See those methods' docstrings for more details. .. _Adding Support for Revision Control Systems: Adding Support for Revision Control Systems ------------------------------------------------- If the files you want to include in the source distribution are tracked using Git, Mercurial or SVN, you can use the following packages to achieve that: - Git and Mercurial: `setuptools_scm `_ - SVN: `setuptools_svn `_ If you would like to create a plugin for ``setuptools`` to find files tracked by another revision control system, you can do so by adding an entry point to the ``setuptools.file_finders`` group. The entry point should be a function accepting a single directory name, and should yield all the filenames within that directory (and any subdirectories thereof) that are under revision control. For example, if you were going to create a plugin for a revision control system called "foobar", you would write a function something like this: .. code-block:: python def find_files_for_foobar(dirname): ... # loop to yield paths that start with `dirname` And you would register it in a setup script using something like this:: entry_points={ "setuptools.file_finders": [ "foobar = my_foobar_module:find_files_for_foobar", ] } Then, anyone who wants to use your plugin can simply install it, and their local setuptools installation will be able to find the necessary files. It is not necessary to distribute source control plugins with projects that simply use the other source control system, or to specify the plugins in ``setup_requires``. When you create a source distribution with the ``sdist`` command, setuptools automatically records what files were found in the ``SOURCES.txt`` file. That way, recipients of source distributions don't need to have revision control at all. However, if someone is working on a package by checking out with that system, they will need the same plugin(s) that the original author is using. A few important points for writing revision control file finders: * Your finder function MUST return relative paths, created by appending to the passed-in directory name. Absolute paths are NOT allowed, nor are relative paths that reference a parent directory of the passed-in directory. * Your finder function MUST accept an empty string as the directory name, meaning the current directory. You MUST NOT convert this to a dot; just yield relative paths. So, yielding a subdirectory named ``some/dir`` under the current directory should NOT be rendered as ``./some/dir`` or ``/somewhere/some/dir``, but *always* as simply ``some/dir`` * Your finder function SHOULD NOT raise any errors, and SHOULD deal gracefully with the absence of needed programs (i.e., ones belonging to the revision control system itself. It *may*, however, use ``distutils.log.warn()`` to inform the user of the missing program(s). ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/functionalities_rewrite.rst0000644000175100001710000000052600000000000024016 0ustar00runnerdocker======================================================== Using setuptools to package and distribute your project ======================================================== ``setuptools`` offers a variety of functionalities that make it easy to build and distribute your python package. Here we provide an overview on the commonly used ones. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/index.rst0000644000175100001710000000217300000000000020164 0ustar00runnerdocker================================================== Building and Distributing Packages with Setuptools ================================================== ``Setuptools`` is a collection of enhancements to the Python ``distutils`` that allow developers to more easily build and distribute Python packages, especially ones that have dependencies on other packages. Packages built and distributed using ``setuptools`` look to the user like ordinary Python packages based on the ``distutils``. Transition to PEP517 ==================== Since setuptools no longer serves as the default build tool, one must explicitly opt in (by providing a :file:`pyproject.toml` file) to use this library. The user facing part is provided by tools such as pip and backend interface is described :doc:`in this document <../build_meta>`. The quickstart provides an overview of the new workflow. .. toctree:: :maxdepth: 1 quickstart package_discovery entry_point dependency_management datafiles development_mode distribution extension declarative_config keywords commands functionalities_rewrite miscellaneous ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/keywords.rst0000644000175100001710000002133200000000000020722 0ustar00runnerdockerNew and Changed ``setup()`` Keywords ==================================== The following keyword arguments to ``setup()`` are added or changed by ``setuptools``. All of them are optional; you do not have to supply them unless you need the associated ``setuptools`` feature. ``include_package_data`` If set to ``True``, this tells ``setuptools`` to automatically include any data files it finds inside your package directories that are specified by your ``MANIFEST.in`` file. For more information, see the section on :ref:`Including Data Files`. ``exclude_package_data`` A dictionary mapping package names to lists of glob patterns that should be *excluded* from your package directories. You can use this to trim back any excess files included by ``include_package_data``. For a complete description and examples, see the section on :ref:`Including Data Files`. ``package_data`` A dictionary mapping package names to lists of glob patterns. For a complete description and examples, see the section on :ref:`Including Data Files`. You do not need to use this option if you are using ``include_package_data``, unless you need to add e.g. files that are generated by your setup script and build process. (And are therefore not in source control or are files that you don't want to include in your source distribution.) ``zip_safe`` A boolean (True or False) flag specifying whether the project can be safely installed and run from a zip file. If this argument is not supplied, the ``bdist_egg`` command will have to analyze all of your project's contents for possible problems each time it builds an egg. ``install_requires`` A string or list of strings specifying what other distributions need to be installed when this one is. See the section on :ref:`Declaring Dependencies` for details and examples of the format of this argument. ``entry_points`` A dictionary mapping entry point group names to strings or lists of strings defining the entry points. Entry points are used to support dynamic discovery of services or plugins provided by a project. See :ref:`Dynamic Discovery of Services and Plugins` for details and examples of the format of this argument. In addition, this keyword is used to support :ref:`Automatic Script Creation `. ``extras_require`` A dictionary mapping names of "extras" (optional features of your project) to strings or lists of strings specifying what other distributions must be installed to support those features. See the section on :ref:`Declaring Dependencies` for details and examples of the format of this argument. ``python_requires`` A string corresponding to a version specifier (as defined in PEP 440) for the Python version, used to specify the Requires-Python defined in PEP 345. ``setup_requires`` A string or list of strings specifying what other distributions need to be present in order for the *setup script* to run. ``setuptools`` will attempt to obtain these (using pip if available) before processing the rest of the setup script or commands. This argument is needed if you are using distutils extensions as part of your build process; for example, extensions that process setup() arguments and turn them into EGG-INFO metadata files. (Note: projects listed in ``setup_requires`` will NOT be automatically installed on the system where the setup script is being run. They are simply downloaded to the ./.eggs directory if they're not locally available already. If you want them to be installed, as well as being available when the setup script is run, you should add them to ``install_requires`` **and** ``setup_requires``.) ``dependency_links`` A list of strings naming URLs to be searched when satisfying dependencies. These links will be used if needed to install packages specified by ``setup_requires`` or ``tests_require``. They will also be written into the egg's metadata for use during install by tools that support them. ``namespace_packages`` A list of strings naming the project's "namespace packages". A namespace package is a package that may be split across multiple project distributions. For example, Zope 3's ``zope`` package is a namespace package, because subpackages like ``zope.interface`` and ``zope.publisher`` may be distributed separately. The egg runtime system can automatically merge such subpackages into a single parent package at runtime, as long as you declare them in each project that contains any subpackages of the namespace package, and as long as the namespace package's ``__init__.py`` does not contain any code other than a namespace declaration. See the section below on :ref:`Namespace Packages` for more information. ``test_suite`` A string naming a ``unittest.TestCase`` subclass (or a package or module containing one or more of them, or a method of such a subclass), or naming a function that can be called with no arguments and returns a ``unittest.TestSuite``. If the named suite is a module, and the module has an ``additional_tests()`` function, it is called and the results are added to the tests to be run. If the named suite is a package, any submodules and subpackages are recursively added to the overall test suite. Specifying this argument enables use of the :ref:`test ` command to run the specified test suite, e.g. via ``setup.py test``. See the section on the :ref:`test ` command below for more details. New in 41.5.0: Deprecated the test command. ``tests_require`` If your project's tests need one or more additional packages besides those needed to install it, you can use this option to specify them. It should be a string or list of strings specifying what other distributions need to be present for the package's tests to run. When you run the ``test`` command, ``setuptools`` will attempt to obtain these (using pip if available). Note that these required projects will *not* be installed on the system where the tests are run, but only downloaded to the project's setup directory if they're not already installed locally. New in 41.5.0: Deprecated the test command. .. _test_loader: ``test_loader`` If you would like to use a different way of finding tests to run than what setuptools normally uses, you can specify a module name and class name in this argument. The named class must be instantiable with no arguments, and its instances must support the ``loadTestsFromNames()`` method as defined in the Python ``unittest`` module's ``TestLoader`` class. Setuptools will pass only one test "name" in the ``names`` argument: the value supplied for the ``test_suite`` argument. The loader you specify may interpret this string in any way it likes, as there are no restrictions on what may be contained in a ``test_suite`` string. The module name and class name must be separated by a ``:``. The default value of this argument is ``"setuptools.command.test:ScanningLoader"``. If you want to use the default ``unittest`` behavior, you can specify ``"unittest:TestLoader"`` as your ``test_loader`` argument instead. This will prevent automatic scanning of submodules and subpackages. The module and class you specify here may be contained in another package, as long as you use the ``tests_require`` option to ensure that the package containing the loader class is available when the ``test`` command is run. New in 41.5.0: Deprecated the test command. ``eager_resources`` A list of strings naming resources that should be extracted together, if any of them is needed, or if any C extensions included in the project are imported. This argument is only useful if the project will be installed as a zipfile, and there is a need to have all of the listed resources be extracted to the filesystem *as a unit*. Resources listed here should be "/"-separated paths, relative to the source root, so to list a resource ``foo.png`` in package ``bar.baz``, you would include the string ``bar/baz/foo.png`` in this argument. If you only need to obtain resources one at a time, or you don't have any C extensions that access other files in the project (such as data files or shared libraries), you probably do NOT need this argument and shouldn't mess with it. For more details on how this argument works, see the section below on :ref:`Automatic Resource Extraction`. ``project_urls`` An arbitrary map of URL names to hyperlinks, allowing more extensible documentation of where various resources can be found than the simple ``url`` and ``download_url`` options provide. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/miscellaneous.rst0000644000175100001710000001304700000000000021722 0ustar00runnerdocker.. _Automatic Resource Extraction: Automatic Resource Extraction ----------------------------- If you are using tools that expect your resources to be "real" files, or your project includes non-extension native libraries or other files that your C extensions expect to be able to access, you may need to list those files in the ``eager_resources`` argument to ``setup()``, so that the files will be extracted together, whenever a C extension in the project is imported. This is especially important if your project includes shared libraries *other* than distutils-built C extensions, and those shared libraries use file extensions other than ``.dll``, ``.so``, or ``.dylib``, which are the extensions that setuptools 0.6a8 and higher automatically detects as shared libraries and adds to the ``native_libs.txt`` file for you. Any shared libraries whose names do not end with one of those extensions should be listed as ``eager_resources``, because they need to be present in the filesystem when he C extensions that link to them are used. The ``pkg_resources`` runtime for compressed packages will automatically extract *all* C extensions and ``eager_resources`` at the same time, whenever *any* C extension or eager resource is requested via the ``resource_filename()`` API. (C extensions are imported using ``resource_filename()`` internally.) This ensures that C extensions will see all of the "real" files that they expect to see. Note also that you can list directory resource names in ``eager_resources`` as well, in which case the directory's contents (including subdirectories) will be extracted whenever any C extension or eager resource is requested. Please note that if you're not sure whether you need to use this argument, you don't! It's really intended to support projects with lots of non-Python dependencies and as a last resort for crufty projects that can't otherwise handle being compressed. If your package is pure Python, Python plus data files, or Python plus C, you really don't need this. You've got to be using either C or an external program that needs "real" files in your project before there's any possibility of ``eager_resources`` being relevant to your project. Defining Additional Metadata ---------------------------- Some extensible applications and frameworks may need to define their own kinds of metadata to include in eggs, which they can then access using the ``pkg_resources`` metadata APIs. Ordinarily, this is done by having plugin developers include additional files in their ``ProjectName.egg-info`` directory. However, since it can be tedious to create such files by hand, you may want to create a distutils extension that will create the necessary files from arguments to ``setup()``, in much the same way that ``setuptools`` does for many of the ``setup()`` arguments it adds. See the section below on :ref:`Creating ``distutils\`\` Extensions` for more details, especially the subsection on :ref:`Adding new EGG-INFO Files`. Setting the ``zip_safe`` flag ----------------------------- For some use cases (such as bundling as part of a larger application), Python packages may be run directly from a zip file. Not all packages, however, are capable of running in compressed form, because they may expect to be able to access either source code or data files as normal operating system files. So, ``setuptools`` can install your project as a zipfile or a directory, and its default choice is determined by the project's ``zip_safe`` flag. You can pass a True or False value for the ``zip_safe`` argument to the ``setup()`` function, or you can omit it. If you omit it, the ``bdist_egg`` command will analyze your project's contents to see if it can detect any conditions that would prevent it from working in a zipfile. It will output notices to the console about any such conditions that it finds. Currently, this analysis is extremely conservative: it will consider the project unsafe if it contains any C extensions or datafiles whatsoever. This does *not* mean that the project can't or won't work as a zipfile! It just means that the ``bdist_egg`` authors aren't yet comfortable asserting that the project *will* work. If the project contains no C or data files, and does no ``__file__`` or ``__path__`` introspection or source code manipulation, then there is an extremely solid chance the project will work when installed as a zipfile. (And if the project uses ``pkg_resources`` for all its data file access, then C extensions and other data files shouldn't be a problem at all. See the :ref:`Accessing Data Files at Runtime` section above for more information.) However, if ``bdist_egg`` can't be *sure* that your package will work, but you've checked over all the warnings it issued, and you are either satisfied it *will* work (or if you want to try it for yourself), then you should set ``zip_safe`` to ``True`` in your ``setup()`` call. If it turns out that it doesn't work, you can always change it to ``False``, which will force ``setuptools`` to install your project as a directory rather than as a zipfile. In the future, as we gain more experience with different packages and become more satisfied with the robustness of the ``pkg_resources`` runtime, the "zip safety" analysis may become less conservative. However, we strongly recommend that you determine for yourself whether your project functions correctly when installed as a zipfile, correct any problems if you can, and then make an explicit declaration of ``True`` or ``False`` for the ``zip_safe`` flag, so that it will not be necessary for ``bdist_egg`` to try to guess whether your project can work as a zipfile. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/package_discovery.rst0000644000175100001710000001562100000000000022541 0ustar00runnerdocker.. _`package_discovery`: ======================================== Package Discovery and Namespace Package ======================================== .. note:: a full specification for the keyword supplied to ``setup.cfg`` or ``setup.py`` can be found at :doc:`keywords reference ` .. note:: the examples provided here are only to demonstrate the functionality introduced. More metadata and options arguments need to be supplied if you want to replicate them on your system. If you are completely new to setuptools, the :doc:`quickstart section ` is a good place to start. ``Setuptools`` provide powerful tools to handle package discovery, including support for namespace package. Normally, you would specify the package to be included manually in the following manner: .. tab:: setup.cfg .. code-block:: ini [options] #... packages = mypkg1 mypkg2 .. tab:: setup.py .. code-block:: python setup( # ... packages=['mypkg1', 'mypkg2'] ) This can get tiresome really quickly. To speed things up, we introduce two functions provided by setuptools: .. tab:: setup.cfg .. code-block:: ini [options] packages = find: #or packages = find_namespace: .. tab:: setup.py .. code-block:: python from setuptools import find_packages # or from setuptools import find_namespace_packages Using ``find:`` or ``find_packages`` ==================================== Let's start with the first tool. ``find:`` (``find_packages``) takes a source directory and two lists of package name patterns to exclude and include, and then return a list of ``str`` representing the packages it could find. To use it, consider the following directory .. code-block:: bash mypkg/ src/ pkg1/__init__.py pkg2/__init__.py additional/__init__.py setup.cfg #or setup.py To have your setup.cfg or setup.py to automatically include packages found in ``src`` that starts with the name ``pkg`` and not ``additional``: .. tab:: setup.cfg .. code-block:: ini [options] packages = find: package_dir = =src [options.packages.find] where = src include = pkg* exclude = additional .. tab:: setup.py .. code-block:: python setup( # ... packages=find_packages( where='src', include=['pkg*'], exclude=['additional'], ), package_dir={"": "src"} # ... ) .. _Namespace Packages: Using ``find_namespace:`` or ``find_namespace_packages`` ======================================================== ``setuptools`` provides the ``find_namespace:`` (``find_namespace_packages``) which behaves similarly to ``find:`` but works with namespace package. Before diving in, it is important to have a good understanding of what namespace packages are. Here is a quick recap: Suppose you have two packages named as follows: .. code-block:: bash /Users/Desktop/timmins/foo/__init__.py /Library/timmins/bar/__init__.py If both ``Desktop`` and ``Library`` are on your ``PYTHONPATH``, then a namespace package called ``timmins`` will be created automatically for you when you invoke the import mechanism, allowing you to accomplish the following .. code-block:: pycon >>> import timmins.foo >>> import timmins.bar as if there is only one ``timmins`` on your system. The two packages can then be distributed separately and installed individually without affecting the other one. Suppose you are packaging the ``foo`` part: .. code-block:: bash foo/ src/ timmins/foo/__init__.py setup.cfg # or setup.py and you want the ``foo`` to be automatically included, ``find:`` won't work because timmins doesn't contain ``__init__.py`` directly, instead, you have to use ``find_namespace:``: .. code-block:: ini [options] package_dir = =src packages = find_namespace: [options.packages.find] where = src When you install the zipped distribution, ``timmins.foo`` would become available to your interpreter. You can think of ``find_namespace:`` as identical to ``find:`` except it would count a directory as a package even if it doesn't contain ``__init__.py`` file directly. As a result, this creates an interesting side effect. If you organize your package like this: .. code-block:: bash foo/ timmins/ foo/__init__.py setup.cfg # or setup.py tests/ test_foo/__init__.py a naive ``find_namespace:`` would include tests as part of your package to be installed. A simple way to fix it is to adopt the aforementioned ``src`` layout. Legacy Namespace Packages ========================= The fact you can create namespace package so effortlessly above is credited to `PEP 420 `_. It use to be more cumbersome to accomplish the same result. Historically, there were two methods to create namespace packages. One is the ``pkg_resources`` style supported by ``setuptools`` and the other one being ``pkgutils`` style offered by ``pkgutils`` module in Python. Both are now considered deprecated despite the fact they still linger in many existing packages. These two differ in many subtle yet significant aspects and you can find out more on `Python packaging user guide `_ ``pkg_resource`` style namespace package ---------------------------------------- This is the method ``setuptools`` directly supports. Starting with the same layout, there are two pieces you need to add to it. First, an ``__init__.py`` file directly under your namespace package directory that contains the following: .. code-block:: python __import__("pkg_resources").declare_namespace(__name__) And the ``namespace_packages`` keyword in your ``setup.cfg`` or ``setup.py``: .. tab:: setup.cfg .. code-block:: ini [options] namespace_packages = timmins .. tab:: setup.py .. code-block:: python setup( # ... namespace_packages=['timmins'] ) And your directory should look like this .. code-block:: bash /foo/ src/ timmins/ __init__.py foo/__init__.py setup.cfg #or setup.py Repeat the same for other packages and you can achieve the same result as the previous section. ``pkgutil`` style namespace package ----------------------------------- This method is almost identical to the ``pkg_resource`` except that the ``namespace_packages`` declaration is omitted and the ``__init__.py`` file contains the following: .. code-block:: python __path__ = __import__('pkgutil').extend_path(__path__, __name__) The project layout remains the same and ``setup.cfg`` remains the same. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/docs/userguide/quickstart.rst0000644000175100001710000002002600000000000021244 0ustar00runnerdocker========================== ``setuptools`` Quickstart ========================== Installation ============ To install the latest version of setuptools, use:: pip install --upgrade setuptools Python packaging at a glance ============================ The landscape of Python packaging is shifting and ``Setuptools`` has evolved to only provide backend support, no longer being the de-facto packaging tool in the market. All python package must provide a ``pyproject.toml`` and specify the backend (build system) it wants to use. The distribution can then be generated with whatever tools that provides a ``build sdist``-alike functionality. While this may appear cumbersome, given the added pieces, it in fact tremendously enhances the portability of your package. The change is driven under :pep:`PEP 517 <517#build-requirements>`. To learn more about Python packaging in general, navigate to the :ref:`bottom ` of this page. Basic Use ========= For basic use of setuptools, you will need a ``pyproject.toml`` with the exact following info, which declares you want to use ``setuptools`` to package your project: .. code-block:: toml [build-system] requires = ["setuptools", "wheel"] build-backend = "setuptools.build_meta" Then, you will need a ``setup.cfg`` or ``setup.py`` to specify your package information, such as metadata, contents, dependencies, etc. Here we demonstrate the minimum .. tab:: setup.cfg .. code-block:: ini [metadata] name = mypackage version = 0.0.1 [options] packages = mypackage install_requires = requests importlib; python_version == "2.6" .. tab:: setup.py .. code-block:: python from setuptools import setup setup( name='mypackage', version='0.0.1', packages=['mypackage'], install_requires=[ 'requests', 'importlib; python_version == "2.6"', ], ) This is what your project would look like:: ~/mypackage/ pyproject.toml setup.cfg # or setup.py mypackage/__init__.py Then, you need an builder, such as :std:doc:`PyPA build ` which you can obtain via ``pip install build``. After downloading it, invoke the builder:: python -m build You now have your distribution ready (e.g. a ``tar.gz`` file and a ``.whl`` file in the ``dist`` directory), which you can upload to PyPI! Of course, before you release your project to PyPI, you'll want to add a bit more information to your setup script to help people find or learn about your project. And maybe your project will have grown by then to include a few dependencies, and perhaps some data files and scripts. In the next few sections, we will walk through those additional but essential information you need to specify to properly package your project. Automatic package discovery =========================== For simple projects, it's usually easy enough to manually add packages to the ``packages`` keyword in ``setup.cfg``. However, for very large projects , it can be a big burden to keep the package list updated. ``setuptools`` therefore provides two convenient tools to ease the burden: :literal:`find:\ ` and :literal:`find_namespace:\ `. To use it in your project: .. code-block:: ini [options] packages = find: [options.packages.find] #optional include=pkg1, pkg2 exclude=pk3, pk4 When you pass the above information, alongside other necessary ones, ``setuptools`` walks through the directory specified in ``where`` (omitted here as the package reside in current directory) and filters the packages it can find following the ``include`` (default to none), then remove those that match the ``exclude`` and return a list of Python packages. Note that each entry in the ``[options.packages.find]`` is optional. The above setup also allows you to adopt a ``src/`` layout. For more details and advanced use, go to :ref:`package_discovery` Entry points and automatic script creation =========================================== Setuptools support automatic creation of scripts upon installation, that runs code within your package if you specify them with the ``entry_points`` keyword. This is what allows you to run commands like ``pip install`` instead of having to type ``python -m pip install``. To accomplish this, add the entry_points keyword in your ``setup.cfg``: .. code-block:: ini [options.entry_points] console_scripts = main = mypkg:some_func When this project is installed, a ``main`` script will be installed and will invoke the ``some_func`` in the ``__init__.py`` file when called by the user. For detailed usage, including managing the additional or optional dependencies, go to :doc:`entry_point`. Dependency management ===================== ``setuptools`` supports automatically installing dependencies when a package is installed. The simplest way to include requirement specifiers is to use the ``install_requires`` argument to ``setup.cfg``. It takes a string or list of strings containing requirement specifiers (A version specifier is one of the operators <, >, <=, >=, == or !=, followed by a version identifier): .. code-block:: ini [options] install_requires = docutils >= 0.3 requests <= 0.4 When your project is installed, all of the dependencies not already installed will be located (via PyPI), downloaded, built (if necessary), and installed. This, of course, is a simplified scenarios. ``setuptools`` also provide additional keywords such as ``setup_requires`` that allows you to install dependencies before running the script, and ``extras_require`` that take care of those needed by automatically generated scripts. It also provides mechanisms to handle dependencies that are not in PyPI. For more advanced use, see :doc:`dependency_management` .. _Including Data Files: Including Data Files ==================== The distutils have traditionally allowed installation of "data files", which are placed in a platform-specific location. Setuptools offers three ways to specify data files to be included in your packages. For the simplest use, you can simply use the ``include_package_data`` keyword: .. code-block:: ini [options] include_package_data = True This tells setuptools to install any data files it finds in your packages. The data files must be specified via the distutils' ``MANIFEST.in`` file. For more details, see :doc:`datafiles` Development mode ================ .. tip:: Prior to :ref:`pip v21.1 `, a ``setup.py`` script was required to be compatible with development mode. With late versions of pip, any project may be installed in this mode. ``setuptools`` allows you to install a package without copying any files to your interpreter directory (e.g. the ``site-packages`` directory). This allows you to modify your source code and have the changes take effect without you having to rebuild and reinstall. Here's how to do it:: pip install --editable . This creates a link file in your interpreter site package directory which associate with your source code. For more information, see :doc:`development_mode`. Uploading your package to PyPI ============================== After generating the distribution files, next step would be to upload your distribution so others can use it. This functionality is provided by `twine `_ and we will only demonstrate the basic use here. Transitioning from ``setup.py`` to ``setup.cfg`` ================================================ To avoid executing arbitrary scripts and boilerplate code, we are transitioning into a full-fledged ``setup.cfg`` to declare your package information instead of running ``setup()``. This inevitably brings challenges due to a different syntax. Here we provide a quick guide to understanding how ``setup.cfg`` is parsed by ``setuptool`` to ease the pain of transition. .. _packaging-resources: Resources on Python packaging ============================= Packaging in Python is hard. Here we provide a list of links for those that want to learn more. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/launcher.c0000644000175100001710000002414200000000000015344 0ustar00runnerdocker/* Setuptools Script Launcher for Windows This is a stub executable for Windows that functions somewhat like Effbot's "exemaker", in that it runs a script with the same name but a .py extension, using information from a #! line. It differs in that it spawns the actual Python executable, rather than attempting to hook into the Python DLL. This means that the script will run with sys.executable set to the Python executable, where exemaker ends up with sys.executable pointing to itself. (Which means it won't work if you try to run another Python process using sys.executable.) To build/rebuild with mingw32, do this in the setuptools project directory: gcc -DGUI=0 -mno-cygwin -O -s -o setuptools/cli.exe launcher.c gcc -DGUI=1 -mwindows -mno-cygwin -O -s -o setuptools/gui.exe launcher.c To build for Windows RT, install both Visual Studio Express for Windows 8 and for Windows Desktop (both freeware), create "win32" application using "Windows Desktop" version, create new "ARM" target via "Configuration Manager" menu and modify ".vcxproj" file by adding "true" tag as child of "PropertyGroup" tags that has "Debug|ARM" and "Release|ARM" properties. It links to msvcrt.dll, but this shouldn't be a problem since it doesn't actually run Python in the same process. Note that using 'exec' instead of 'spawn' doesn't work, because on Windows this leads to the Python executable running in the *background*, attached to the same console window, meaning you get a command prompt back *before* Python even finishes starting. So, we have to use spawnv() and wait for Python to exit before continuing. :( */ #include #include #include #include #include #include #include int child_pid=0; int fail(char *format, char *data) { /* Print error message to stderr and return 2 */ fprintf(stderr, format, data); return 2; } char *quoted(char *data) { int i, ln = strlen(data), nb; /* We allocate twice as much space as needed to deal with worse-case of having to escape everything. */ char *result = calloc(ln*2+3, sizeof(char)); char *presult = result; *presult++ = '"'; for (nb=0, i=0; i < ln; i++) { if (data[i] == '\\') nb += 1; else if (data[i] == '"') { for (; nb > 0; nb--) *presult++ = '\\'; *presult++ = '\\'; } else nb = 0; *presult++ = data[i]; } for (; nb > 0; nb--) /* Deal w trailing slashes */ *presult++ = '\\'; *presult++ = '"'; *presult++ = 0; return result; } char *loadable_exe(char *exename) { /* HINSTANCE hPython; DLL handle for python executable */ char *result; /* hPython = LoadLibraryEx(exename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); if (!hPython) return NULL; */ /* Return the absolute filename for spawnv */ result = calloc(MAX_PATH, sizeof(char)); strncpy(result, exename, MAX_PATH); /*if (result) GetModuleFileNameA(hPython, result, MAX_PATH); FreeLibrary(hPython); */ return result; } char *find_exe(char *exename, char *script) { char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT]; char path[_MAX_PATH], c, *result; /* convert slashes to backslashes for uniform search below */ result = exename; while (c = *result++) if (c=='/') result[-1] = '\\'; _splitpath(exename, drive, dir, fname, ext); if (drive[0] || dir[0]=='\\') { return loadable_exe(exename); /* absolute path, use directly */ } /* Use the script's parent directory, which should be the Python home (This should only be used for bdist_wininst-installed scripts, because easy_install-ed scripts use the absolute path to python[w].exe */ _splitpath(script, drive, dir, fname, ext); result = dir + strlen(dir) -1; if (*result == '\\') result--; while (*result != '\\' && result>=dir) *result-- = 0; _makepath(path, drive, dir, exename, NULL); return loadable_exe(path); } char **parse_argv(char *cmdline, int *argc) { /* Parse a command line in-place using MS C rules */ char **result = calloc(strlen(cmdline), sizeof(char *)); char *output = cmdline; char c; int nb = 0; int iq = 0; *argc = 0; result[0] = output; while (isspace(*cmdline)) cmdline++; /* skip leading spaces */ do { c = *cmdline++; if (!c || (isspace(c) && !iq)) { while (nb) {*output++ = '\\'; nb--; } *output++ = 0; result[++*argc] = output; if (!c) return result; while (isspace(*cmdline)) cmdline++; /* skip leading spaces */ if (!*cmdline) return result; /* avoid empty arg if trailing ws */ continue; } if (c == '\\') ++nb; /* count \'s */ else { if (c == '"') { if (!(nb & 1)) { iq = !iq; c = 0; } /* skip " unless odd # of \ */ nb = nb >> 1; /* cut \'s in half */ } while (nb) {*output++ = '\\'; nb--; } if (c) *output++ = c; } } while (1); } void pass_control_to_child(DWORD control_type) { /* * distribute-issue207 * passes the control event to child process (Python) */ if (!child_pid) { return; } GenerateConsoleCtrlEvent(child_pid,0); } BOOL control_handler(DWORD control_type) { /* * distribute-issue207 * control event handler callback function */ switch (control_type) { case CTRL_C_EVENT: pass_control_to_child(0); break; } return TRUE; } int create_and_wait_for_subprocess(char* command) { /* * distribute-issue207 * launches child process (Python) */ DWORD return_value = 0; LPSTR commandline = command; STARTUPINFOA s_info; PROCESS_INFORMATION p_info; ZeroMemory(&p_info, sizeof(p_info)); ZeroMemory(&s_info, sizeof(s_info)); s_info.cb = sizeof(STARTUPINFO); // set-up control handler callback funciotn SetConsoleCtrlHandler((PHANDLER_ROUTINE) control_handler, TRUE); if (!CreateProcessA(NULL, commandline, NULL, NULL, TRUE, 0, NULL, NULL, &s_info, &p_info)) { fprintf(stderr, "failed to create process.\n"); return 0; } child_pid = p_info.dwProcessId; // wait for Python to exit WaitForSingleObject(p_info.hProcess, INFINITE); if (!GetExitCodeProcess(p_info.hProcess, &return_value)) { fprintf(stderr, "failed to get exit code from process.\n"); return 0; } return return_value; } char* join_executable_and_args(char *executable, char **args, int argc) { /* * distribute-issue207 * CreateProcess needs a long string of the executable and command-line arguments, * so we need to convert it from the args that was built */ int len,counter; char* cmdline; len=strlen(executable)+2; for (counter=1; counterscript && *end != '.') *end-- = '\0'; *end-- = '\0'; strcat(script, (GUI ? "-script.pyw" : "-script.py")); /* figure out the target python executable */ scriptf = open(script, O_RDONLY); if (scriptf == -1) { return fail("Cannot open %s\n", script); } end = python + read(scriptf, python, sizeof(python)); close(scriptf); ptr = python-1; while(++ptr < end && *ptr && *ptr!='\n' && *ptr!='\r') {;} *ptr-- = '\0'; if (strncmp(python, "#!", 2)) { /* default to python.exe if no #! header */ strcpy(python, "#!python.exe"); } parsedargs = parse_argv(python+2, &parsedargc); /* Using spawnv() can fail strangely if you e.g. find the Cygwin Python, so we'll make sure Windows can find and load it */ ptr = find_exe(parsedargs[0], script); if (!ptr) { return fail("Cannot find Python executable %s\n", parsedargs[0]); } /* printf("Python executable: %s\n", ptr); */ /* Argument array needs to be parsedargc + argc, plus 1 for null sentinel */ newargs = (char **)calloc(parsedargc + argc + 1, sizeof(char *)); newargsp = newargs; *newargsp++ = quoted(ptr); for (i = 1; i= "10.3" or \ dversion == 8 and macosversion >= "10.4": return True # egg isn't macOS or legacy darwin return False # are they the same major version and machine type? if provMac.group(1) != reqMac.group(1) or \ provMac.group(3) != reqMac.group(3): return False # is the required OS major update >= the provided one? if int(provMac.group(2)) > int(reqMac.group(2)): return False return True # XXX Linux and other platforms' special cases should go here return False def run_script(dist_spec, script_name): """Locate distribution `dist_spec` and run its `script_name` script""" ns = sys._getframe(1).f_globals name = ns['__name__'] ns.clear() ns['__name__'] = name require(dist_spec)[0].run_script(script_name, ns) # backward compatibility run_main = run_script def get_distribution(dist): """Return a current distribution object for a Requirement or string""" if isinstance(dist, str): dist = Requirement.parse(dist) if isinstance(dist, Requirement): dist = get_provider(dist) if not isinstance(dist, Distribution): raise TypeError("Expected string, Requirement, or Distribution", dist) return dist def load_entry_point(dist, group, name): """Return `name` entry point of `group` for `dist` or raise ImportError""" return get_distribution(dist).load_entry_point(group, name) def get_entry_map(dist, group=None): """Return the entry point map for `group`, or the full entry map""" return get_distribution(dist).get_entry_map(group) def get_entry_info(dist, group, name): """Return the EntryPoint object for `group`+`name`, or ``None``""" return get_distribution(dist).get_entry_info(group, name) class IMetadataProvider: def has_metadata(name): """Does the package's distribution contain the named metadata?""" def get_metadata(name): """The named metadata resource as a string""" def get_metadata_lines(name): """Yield named metadata resource as list of non-blank non-comment lines Leading and trailing whitespace is stripped from each line, and lines with ``#`` as the first non-blank character are omitted.""" def metadata_isdir(name): """Is the named metadata a directory? (like ``os.path.isdir()``)""" def metadata_listdir(name): """List of metadata names in the directory (like ``os.listdir()``)""" def run_script(script_name, namespace): """Execute the named script in the supplied namespace dictionary""" class IResourceProvider(IMetadataProvider): """An object that provides access to package resources""" def get_resource_filename(manager, resource_name): """Return a true filesystem path for `resource_name` `manager` must be an ``IResourceManager``""" def get_resource_stream(manager, resource_name): """Return a readable file-like object for `resource_name` `manager` must be an ``IResourceManager``""" def get_resource_string(manager, resource_name): """Return a string containing the contents of `resource_name` `manager` must be an ``IResourceManager``""" def has_resource(resource_name): """Does the package contain the named resource?""" def resource_isdir(resource_name): """Is the named resource a directory? (like ``os.path.isdir()``)""" def resource_listdir(resource_name): """List of resource names in the directory (like ``os.listdir()``)""" class WorkingSet: """A collection of active distributions on sys.path (or a similar list)""" def __init__(self, entries=None): """Create working set from list of path entries (default=sys.path)""" self.entries = [] self.entry_keys = {} self.by_key = {} self.callbacks = [] if entries is None: entries = sys.path for entry in entries: self.add_entry(entry) @classmethod def _build_master(cls): """ Prepare the master working set. """ ws = cls() try: from __main__ import __requires__ except ImportError: # The main program does not list any requirements return ws # ensure the requirements are met try: ws.require(__requires__) except VersionConflict: return cls._build_from_requirements(__requires__) return ws @classmethod def _build_from_requirements(cls, req_spec): """ Build a working set from a requirement spec. Rewrites sys.path. """ # try it without defaults already on sys.path # by starting with an empty path ws = cls([]) reqs = parse_requirements(req_spec) dists = ws.resolve(reqs, Environment()) for dist in dists: ws.add(dist) # add any missing entries from sys.path for entry in sys.path: if entry not in ws.entries: ws.add_entry(entry) # then copy back to sys.path sys.path[:] = ws.entries return ws def add_entry(self, entry): """Add a path item to ``.entries``, finding any distributions on it ``find_distributions(entry, True)`` is used to find distributions corresponding to the path entry, and they are added. `entry` is always appended to ``.entries``, even if it is already present. (This is because ``sys.path`` can contain the same value more than once, and the ``.entries`` of the ``sys.path`` WorkingSet should always equal ``sys.path``.) """ self.entry_keys.setdefault(entry, []) self.entries.append(entry) for dist in find_distributions(entry, True): self.add(dist, entry, False) def __contains__(self, dist): """True if `dist` is the active distribution for its project""" return self.by_key.get(dist.key) == dist def find(self, req): """Find a distribution matching requirement `req` If there is an active distribution for the requested project, this returns it as long as it meets the version requirement specified by `req`. But, if there is an active distribution for the project and it does *not* meet the `req` requirement, ``VersionConflict`` is raised. If there is no active distribution for the requested project, ``None`` is returned. """ dist = self.by_key.get(req.key) if dist is not None and dist not in req: # XXX add more info raise VersionConflict(dist, req) return dist def iter_entry_points(self, group, name=None): """Yield entry point objects from `group` matching `name` If `name` is None, yields all entry points in `group` from all distributions in the working set, otherwise only ones matching both `group` and `name` are yielded (in distribution order). """ return ( entry for dist in self for entry in dist.get_entry_map(group).values() if name is None or name == entry.name ) def run_script(self, requires, script_name): """Locate distribution for `requires` and run `script_name` script""" ns = sys._getframe(1).f_globals name = ns['__name__'] ns.clear() ns['__name__'] = name self.require(requires)[0].run_script(script_name, ns) def __iter__(self): """Yield distributions for non-duplicate projects in the working set The yield order is the order in which the items' path entries were added to the working set. """ seen = {} for item in self.entries: if item not in self.entry_keys: # workaround a cache issue continue for key in self.entry_keys[item]: if key not in seen: seen[key] = 1 yield self.by_key[key] def add(self, dist, entry=None, insert=True, replace=False): """Add `dist` to working set, associated with `entry` If `entry` is unspecified, it defaults to the ``.location`` of `dist`. On exit from this routine, `entry` is added to the end of the working set's ``.entries`` (if it wasn't already present). `dist` is only added to the working set if it's for a project that doesn't already have a distribution in the set, unless `replace=True`. If it's added, any callbacks registered with the ``subscribe()`` method will be called. """ if insert: dist.insert_on(self.entries, entry, replace=replace) if entry is None: entry = dist.location keys = self.entry_keys.setdefault(entry, []) keys2 = self.entry_keys.setdefault(dist.location, []) if not replace and dist.key in self.by_key: # ignore hidden distros return self.by_key[dist.key] = dist if dist.key not in keys: keys.append(dist.key) if dist.key not in keys2: keys2.append(dist.key) self._added_new(dist) # FIXME: 'WorkingSet.resolve' is too complex (11) def resolve(self, requirements, env=None, installer=None, # noqa: C901 replace_conflicting=False, extras=None): """List all distributions needed to (recursively) meet `requirements` `requirements` must be a sequence of ``Requirement`` objects. `env`, if supplied, should be an ``Environment`` instance. If not supplied, it defaults to all distributions available within any entry or distribution in the working set. `installer`, if supplied, will be invoked with each requirement that cannot be met by an already-installed distribution; it should return a ``Distribution`` or ``None``. Unless `replace_conflicting=True`, raises a VersionConflict exception if any requirements are found on the path that have the correct name but the wrong version. Otherwise, if an `installer` is supplied it will be invoked to obtain the correct version of the requirement and activate it. `extras` is a list of the extras to be used with these requirements. This is important because extra requirements may look like `my_req; extra = "my_extra"`, which would otherwise be interpreted as a purely optional requirement. Instead, we want to be able to assert that these requirements are truly required. """ # set up the stack requirements = list(requirements)[::-1] # set of processed requirements processed = {} # key -> dist best = {} to_activate = [] req_extras = _ReqExtras() # Mapping of requirement to set of distributions that required it; # useful for reporting info about conflicts. required_by = collections.defaultdict(set) while requirements: # process dependencies breadth-first req = requirements.pop(0) if req in processed: # Ignore cyclic or redundant dependencies continue if not req_extras.markers_pass(req, extras): continue dist = best.get(req.key) if dist is None: # Find the best distribution and add it to the map dist = self.by_key.get(req.key) if dist is None or (dist not in req and replace_conflicting): ws = self if env is None: if dist is None: env = Environment(self.entries) else: # Use an empty environment and workingset to avoid # any further conflicts with the conflicting # distribution env = Environment([]) ws = WorkingSet([]) dist = best[req.key] = env.best_match( req, ws, installer, replace_conflicting=replace_conflicting ) if dist is None: requirers = required_by.get(req, None) raise DistributionNotFound(req, requirers) to_activate.append(dist) if dist not in req: # Oops, the "best" so far conflicts with a dependency dependent_req = required_by[req] raise VersionConflict(dist, req).with_context(dependent_req) # push the new requirements onto the stack new_requirements = dist.requires(req.extras)[::-1] requirements.extend(new_requirements) # Register the new requirements needed by req for new_requirement in new_requirements: required_by[new_requirement].add(req.project_name) req_extras[new_requirement] = req.extras processed[req] = True # return list of distros to activate return to_activate def find_plugins( self, plugin_env, full_env=None, installer=None, fallback=True): """Find all activatable distributions in `plugin_env` Example usage:: distributions, errors = working_set.find_plugins( Environment(plugin_dirlist) ) # add plugins+libs to sys.path map(working_set.add, distributions) # display errors print('Could not load', errors) The `plugin_env` should be an ``Environment`` instance that contains only distributions that are in the project's "plugin directory" or directories. The `full_env`, if supplied, should be an ``Environment`` contains all currently-available distributions. If `full_env` is not supplied, one is created automatically from the ``WorkingSet`` this method is called on, which will typically mean that every directory on ``sys.path`` will be scanned for distributions. `installer` is a standard installer callback as used by the ``resolve()`` method. The `fallback` flag indicates whether we should attempt to resolve older versions of a plugin if the newest version cannot be resolved. This method returns a 2-tuple: (`distributions`, `error_info`), where `distributions` is a list of the distributions found in `plugin_env` that were loadable, along with any other distributions that are needed to resolve their dependencies. `error_info` is a dictionary mapping unloadable plugin distributions to an exception instance describing the error that occurred. Usually this will be a ``DistributionNotFound`` or ``VersionConflict`` instance. """ plugin_projects = list(plugin_env) # scan project names in alphabetic order plugin_projects.sort() error_info = {} distributions = {} if full_env is None: env = Environment(self.entries) env += plugin_env else: env = full_env + plugin_env shadow_set = self.__class__([]) # put all our entries in shadow_set list(map(shadow_set.add, self)) for project_name in plugin_projects: for dist in plugin_env[project_name]: req = [dist.as_requirement()] try: resolvees = shadow_set.resolve(req, env, installer) except ResolutionError as v: # save error info error_info[dist] = v if fallback: # try the next older version of project continue else: # give up on this project, keep going break else: list(map(shadow_set.add, resolvees)) distributions.update(dict.fromkeys(resolvees)) # success, no need to try any more versions of this project break distributions = list(distributions) distributions.sort() return distributions, error_info def require(self, *requirements): """Ensure that distributions matching `requirements` are activated `requirements` must be a string or a (possibly-nested) sequence thereof, specifying the distributions and versions required. The return value is a sequence of the distributions that needed to be activated to fulfill the requirements; all relevant distributions are included, even if they were already activated in this working set. """ needed = self.resolve(parse_requirements(requirements)) for dist in needed: self.add(dist) return needed def subscribe(self, callback, existing=True): """Invoke `callback` for all distributions If `existing=True` (default), call on all existing ones, as well. """ if callback in self.callbacks: return self.callbacks.append(callback) if not existing: return for dist in self: callback(dist) def _added_new(self, dist): for callback in self.callbacks: callback(dist) def __getstate__(self): return ( self.entries[:], self.entry_keys.copy(), self.by_key.copy(), self.callbacks[:] ) def __setstate__(self, e_k_b_c): entries, keys, by_key, callbacks = e_k_b_c self.entries = entries[:] self.entry_keys = keys.copy() self.by_key = by_key.copy() self.callbacks = callbacks[:] class _ReqExtras(dict): """ Map each requirement to the extras that demanded it. """ def markers_pass(self, req, extras=None): """ Evaluate markers for req against each extra that demanded it. Return False if the req has a marker and fails evaluation. Otherwise, return True. """ extra_evals = ( req.marker.evaluate({'extra': extra}) for extra in self.get(req, ()) + (extras or (None,)) ) return not req.marker or any(extra_evals) class Environment: """Searchable snapshot of distributions on a search path""" def __init__( self, search_path=None, platform=get_supported_platform(), python=PY_MAJOR): """Snapshot distributions available on a search path Any distributions found on `search_path` are added to the environment. `search_path` should be a sequence of ``sys.path`` items. If not supplied, ``sys.path`` is used. `platform` is an optional string specifying the name of the platform that platform-specific distributions must be compatible with. If unspecified, it defaults to the current platform. `python` is an optional string naming the desired version of Python (e.g. ``'3.6'``); it defaults to the current version. You may explicitly set `platform` (and/or `python`) to ``None`` if you wish to map *all* distributions, not just those compatible with the running platform or Python version. """ self._distmap = {} self.platform = platform self.python = python self.scan(search_path) def can_add(self, dist): """Is distribution `dist` acceptable for this environment? The distribution must match the platform and python version requirements specified when this environment was created, or False is returned. """ py_compat = ( self.python is None or dist.py_version is None or dist.py_version == self.python ) return py_compat and compatible_platforms(dist.platform, self.platform) def remove(self, dist): """Remove `dist` from the environment""" self._distmap[dist.key].remove(dist) def scan(self, search_path=None): """Scan `search_path` for distributions usable in this environment Any distributions found are added to the environment. `search_path` should be a sequence of ``sys.path`` items. If not supplied, ``sys.path`` is used. Only distributions conforming to the platform/python version defined at initialization are added. """ if search_path is None: search_path = sys.path for item in search_path: for dist in find_distributions(item): self.add(dist) def __getitem__(self, project_name): """Return a newest-to-oldest list of distributions for `project_name` Uses case-insensitive `project_name` comparison, assuming all the project's distributions use their project's name converted to all lowercase as their key. """ distribution_key = project_name.lower() return self._distmap.get(distribution_key, []) def add(self, dist): """Add `dist` if we ``can_add()`` it and it has not already been added """ if self.can_add(dist) and dist.has_version(): dists = self._distmap.setdefault(dist.key, []) if dist not in dists: dists.append(dist) dists.sort(key=operator.attrgetter('hashcmp'), reverse=True) def best_match( self, req, working_set, installer=None, replace_conflicting=False): """Find distribution best matching `req` and usable on `working_set` This calls the ``find(req)`` method of the `working_set` to see if a suitable distribution is already active. (This may raise ``VersionConflict`` if an unsuitable version of the project is already active in the specified `working_set`.) If a suitable distribution isn't active, this method returns the newest distribution in the environment that meets the ``Requirement`` in `req`. If no suitable distribution is found, and `installer` is supplied, then the result of calling the environment's ``obtain(req, installer)`` method will be returned. """ try: dist = working_set.find(req) except VersionConflict: if not replace_conflicting: raise dist = None if dist is not None: return dist for dist in self[req.key]: if dist in req: return dist # try to download/install return self.obtain(req, installer) def obtain(self, requirement, installer=None): """Obtain a distribution matching `requirement` (e.g. via download) Obtain a distro that matches requirement (e.g. via download). In the base ``Environment`` class, this routine just returns ``installer(requirement)``, unless `installer` is None, in which case None is returned instead. This method is a hook that allows subclasses to attempt other ways of obtaining a distribution before falling back to the `installer` argument.""" if installer is not None: return installer(requirement) def __iter__(self): """Yield the unique project names of the available distributions""" for key in self._distmap.keys(): if self[key]: yield key def __iadd__(self, other): """In-place addition of a distribution or environment""" if isinstance(other, Distribution): self.add(other) elif isinstance(other, Environment): for project in other: for dist in other[project]: self.add(dist) else: raise TypeError("Can't add %r to environment" % (other,)) return self def __add__(self, other): """Add an environment or distribution to an environment""" new = self.__class__([], platform=None, python=None) for env in self, other: new += env return new # XXX backward compatibility AvailableDistributions = Environment class ExtractionError(RuntimeError): """An error occurred extracting a resource The following attributes are available from instances of this exception: manager The resource manager that raised this exception cache_path The base directory for resource extraction original_error The exception instance that caused extraction to fail """ class ResourceManager: """Manage resource extraction and packages""" extraction_path = None def __init__(self): self.cached_files = {} def resource_exists(self, package_or_requirement, resource_name): """Does the named resource exist?""" return get_provider(package_or_requirement).has_resource(resource_name) def resource_isdir(self, package_or_requirement, resource_name): """Is the named resource an existing directory?""" return get_provider(package_or_requirement).resource_isdir( resource_name ) def resource_filename(self, package_or_requirement, resource_name): """Return a true filesystem path for specified resource""" return get_provider(package_or_requirement).get_resource_filename( self, resource_name ) def resource_stream(self, package_or_requirement, resource_name): """Return a readable file-like object for specified resource""" return get_provider(package_or_requirement).get_resource_stream( self, resource_name ) def resource_string(self, package_or_requirement, resource_name): """Return specified resource as a string""" return get_provider(package_or_requirement).get_resource_string( self, resource_name ) def resource_listdir(self, package_or_requirement, resource_name): """List the contents of the named resource directory""" return get_provider(package_or_requirement).resource_listdir( resource_name ) def extraction_error(self): """Give an error message for problems extracting file(s)""" old_exc = sys.exc_info()[1] cache_path = self.extraction_path or get_default_cache() tmpl = textwrap.dedent(""" Can't extract file(s) to egg cache The following error occurred while trying to extract file(s) to the Python egg cache: {old_exc} The Python egg cache directory is currently set to: {cache_path} Perhaps your account does not have write access to this directory? You can change the cache directory by setting the PYTHON_EGG_CACHE environment variable to point to an accessible directory. """).lstrip() err = ExtractionError(tmpl.format(**locals())) err.manager = self err.cache_path = cache_path err.original_error = old_exc raise err def get_cache_path(self, archive_name, names=()): """Return absolute location in cache for `archive_name` and `names` The parent directory of the resulting path will be created if it does not already exist. `archive_name` should be the base filename of the enclosing egg (which may not be the name of the enclosing zipfile!), including its ".egg" extension. `names`, if provided, should be a sequence of path name parts "under" the egg's extraction location. This method should only be called by resource providers that need to obtain an extraction location, and only for names they intend to extract, as it tracks the generated names for possible cleanup later. """ extract_path = self.extraction_path or get_default_cache() target_path = os.path.join(extract_path, archive_name + '-tmp', *names) try: _bypass_ensure_directory(target_path) except Exception: self.extraction_error() self._warn_unsafe_extraction_path(extract_path) self.cached_files[target_path] = 1 return target_path @staticmethod def _warn_unsafe_extraction_path(path): """ If the default extraction path is overridden and set to an insecure location, such as /tmp, it opens up an opportunity for an attacker to replace an extracted file with an unauthorized payload. Warn the user if a known insecure location is used. See Distribute #375 for more details. """ if os.name == 'nt' and not path.startswith(os.environ['windir']): # On Windows, permissions are generally restrictive by default # and temp directories are not writable by other users, so # bypass the warning. return mode = os.stat(path).st_mode if mode & stat.S_IWOTH or mode & stat.S_IWGRP: msg = ( "Extraction path is writable by group/others " "and vulnerable to attack when " "used with get_resource_filename ({path}). " "Consider a more secure " "location (set with .set_extraction_path or the " "PYTHON_EGG_CACHE environment variable)." ).format(**locals()) warnings.warn(msg, UserWarning) def postprocess(self, tempname, filename): """Perform any platform-specific postprocessing of `tempname` This is where Mac header rewrites should be done; other platforms don't have anything special they should do. Resource providers should call this method ONLY after successfully extracting a compressed resource. They must NOT call it on resources that are already in the filesystem. `tempname` is the current (temporary) name of the file, and `filename` is the name it will be renamed to by the caller after this routine returns. """ if os.name == 'posix': # Make the resource executable mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777 os.chmod(tempname, mode) def set_extraction_path(self, path): """Set the base path where resources will be extracted to, if needed. If you do not call this routine before any extractions take place, the path defaults to the return value of ``get_default_cache()``. (Which is based on the ``PYTHON_EGG_CACHE`` environment variable, with various platform-specific fallbacks. See that routine's documentation for more details.) Resources are extracted to subdirectories of this path based upon information given by the ``IResourceProvider``. You may set this to a temporary directory, but then you must call ``cleanup_resources()`` to delete the extracted files when done. There is no guarantee that ``cleanup_resources()`` will be able to remove all extracted files. (Note: you may not change the extraction path for a given resource manager once resources have been extracted, unless you first call ``cleanup_resources()``.) """ if self.cached_files: raise ValueError( "Can't change extraction path, files already extracted" ) self.extraction_path = path def cleanup_resources(self, force=False): """ Delete all extracted resource files and directories, returning a list of the file and directory names that could not be successfully removed. This function does not have any concurrency protection, so it should generally only be called when the extraction path is a temporary directory exclusive to a single process. This method is not automatically called; you must call it explicitly or register it as an ``atexit`` function if you wish to ensure cleanup of a temporary directory used for extractions. """ # XXX def get_default_cache(): """ Return the ``PYTHON_EGG_CACHE`` environment variable or a platform-relevant user cache dir for an app named "Python-Eggs". """ return ( os.environ.get('PYTHON_EGG_CACHE') or appdirs.user_cache_dir(appname='Python-Eggs') ) def safe_name(name): """Convert an arbitrary string to a standard distribution name Any runs of non-alphanumeric/. characters are replaced with a single '-'. """ return re.sub('[^A-Za-z0-9.]+', '-', name) def safe_version(version): """ Convert an arbitrary string to a standard version string """ try: # normalize the version return str(packaging.version.Version(version)) except packaging.version.InvalidVersion: version = version.replace(' ', '.') return re.sub('[^A-Za-z0-9.]+', '-', version) def safe_extra(extra): """Convert an arbitrary string to a standard 'extra' name Any runs of non-alphanumeric characters are replaced with a single '_', and the result is always lowercased. """ return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower() def to_filename(name): """Convert a project or version name to its filename-escaped form Any '-' characters are currently replaced with '_'. """ return name.replace('-', '_') def invalid_marker(text): """ Validate text as a PEP 508 environment marker; return an exception if invalid or False otherwise. """ try: evaluate_marker(text) except SyntaxError as e: e.filename = None e.lineno = None return e return False def evaluate_marker(text, extra=None): """ Evaluate a PEP 508 environment marker. Return a boolean indicating the marker result in this environment. Raise SyntaxError if marker is invalid. This implementation uses the 'pyparsing' module. """ try: marker = packaging.markers.Marker(text) return marker.evaluate() except packaging.markers.InvalidMarker as e: raise SyntaxError(e) from e class NullProvider: """Try to implement resources and metadata for arbitrary PEP 302 loaders""" egg_name = None egg_info = None loader = None def __init__(self, module): self.loader = getattr(module, '__loader__', None) self.module_path = os.path.dirname(getattr(module, '__file__', '')) def get_resource_filename(self, manager, resource_name): return self._fn(self.module_path, resource_name) def get_resource_stream(self, manager, resource_name): return io.BytesIO(self.get_resource_string(manager, resource_name)) def get_resource_string(self, manager, resource_name): return self._get(self._fn(self.module_path, resource_name)) def has_resource(self, resource_name): return self._has(self._fn(self.module_path, resource_name)) def _get_metadata_path(self, name): return self._fn(self.egg_info, name) def has_metadata(self, name): if not self.egg_info: return self.egg_info path = self._get_metadata_path(name) return self._has(path) def get_metadata(self, name): if not self.egg_info: return "" path = self._get_metadata_path(name) value = self._get(path) try: return value.decode('utf-8') except UnicodeDecodeError as exc: # Include the path in the error message to simplify # troubleshooting, and without changing the exception type. exc.reason += ' in {} file at path: {}'.format(name, path) raise def get_metadata_lines(self, name): return yield_lines(self.get_metadata(name)) def resource_isdir(self, resource_name): return self._isdir(self._fn(self.module_path, resource_name)) def metadata_isdir(self, name): return self.egg_info and self._isdir(self._fn(self.egg_info, name)) def resource_listdir(self, resource_name): return self._listdir(self._fn(self.module_path, resource_name)) def metadata_listdir(self, name): if self.egg_info: return self._listdir(self._fn(self.egg_info, name)) return [] def run_script(self, script_name, namespace): script = 'scripts/' + script_name if not self.has_metadata(script): raise ResolutionError( "Script {script!r} not found in metadata at {self.egg_info!r}" .format(**locals()), ) script_text = self.get_metadata(script).replace('\r\n', '\n') script_text = script_text.replace('\r', '\n') script_filename = self._fn(self.egg_info, script) namespace['__file__'] = script_filename if os.path.exists(script_filename): with open(script_filename) as fid: source = fid.read() code = compile(source, script_filename, 'exec') exec(code, namespace, namespace) else: from linecache import cache cache[script_filename] = ( len(script_text), 0, script_text.split('\n'), script_filename ) script_code = compile(script_text, script_filename, 'exec') exec(script_code, namespace, namespace) def _has(self, path): raise NotImplementedError( "Can't perform this operation for unregistered loader type" ) def _isdir(self, path): raise NotImplementedError( "Can't perform this operation for unregistered loader type" ) def _listdir(self, path): raise NotImplementedError( "Can't perform this operation for unregistered loader type" ) def _fn(self, base, resource_name): self._validate_resource_path(resource_name) if resource_name: return os.path.join(base, *resource_name.split('/')) return base @staticmethod def _validate_resource_path(path): """ Validate the resource paths according to the docs. https://setuptools.pypa.io/en/latest/pkg_resources.html#basic-resource-access >>> warned = getfixture('recwarn') >>> warnings.simplefilter('always') >>> vrp = NullProvider._validate_resource_path >>> vrp('foo/bar.txt') >>> bool(warned) False >>> vrp('../foo/bar.txt') >>> bool(warned) True >>> warned.clear() >>> vrp('/foo/bar.txt') >>> bool(warned) True >>> vrp('foo/../../bar.txt') >>> bool(warned) True >>> warned.clear() >>> vrp('foo/f../bar.txt') >>> bool(warned) False Windows path separators are straight-up disallowed. >>> vrp(r'\\foo/bar.txt') Traceback (most recent call last): ... ValueError: Use of .. or absolute path in a resource path \ is not allowed. >>> vrp(r'C:\\foo/bar.txt') Traceback (most recent call last): ... ValueError: Use of .. or absolute path in a resource path \ is not allowed. Blank values are allowed >>> vrp('') >>> bool(warned) False Non-string values are not. >>> vrp(None) Traceback (most recent call last): ... AttributeError: ... """ invalid = ( os.path.pardir in path.split(posixpath.sep) or posixpath.isabs(path) or ntpath.isabs(path) ) if not invalid: return msg = "Use of .. or absolute path in a resource path is not allowed." # Aggressively disallow Windows absolute paths if ntpath.isabs(path) and not posixpath.isabs(path): raise ValueError(msg) # for compatibility, warn; in future # raise ValueError(msg) warnings.warn( msg[:-1] + " and will raise exceptions in a future release.", DeprecationWarning, stacklevel=4, ) def _get(self, path): if hasattr(self.loader, 'get_data'): return self.loader.get_data(path) raise NotImplementedError( "Can't perform this operation for loaders without 'get_data()'" ) register_loader_type(object, NullProvider) def _parents(path): """ yield all parents of path including path """ last = None while path != last: yield path last = path path, _ = os.path.split(path) class EggProvider(NullProvider): """Provider based on a virtual filesystem""" def __init__(self, module): NullProvider.__init__(self, module) self._setup_prefix() def _setup_prefix(self): # Assume that metadata may be nested inside a "basket" # of multiple eggs and use module_path instead of .archive. eggs = filter(_is_egg_path, _parents(self.module_path)) egg = next(eggs, None) egg and self._set_egg(egg) def _set_egg(self, path): self.egg_name = os.path.basename(path) self.egg_info = os.path.join(path, 'EGG-INFO') self.egg_root = path class DefaultProvider(EggProvider): """Provides access to package resources in the filesystem""" def _has(self, path): return os.path.exists(path) def _isdir(self, path): return os.path.isdir(path) def _listdir(self, path): return os.listdir(path) def get_resource_stream(self, manager, resource_name): return open(self._fn(self.module_path, resource_name), 'rb') def _get(self, path): with open(path, 'rb') as stream: return stream.read() @classmethod def _register(cls): loader_names = 'SourceFileLoader', 'SourcelessFileLoader', for name in loader_names: loader_cls = getattr(importlib_machinery, name, type(None)) register_loader_type(loader_cls, cls) DefaultProvider._register() class EmptyProvider(NullProvider): """Provider that returns nothing for all requests""" module_path = None _isdir = _has = lambda self, path: False def _get(self, path): return '' def _listdir(self, path): return [] def __init__(self): pass empty_provider = EmptyProvider() class ZipManifests(dict): """ zip manifest builder """ @classmethod def build(cls, path): """ Build a dictionary similar to the zipimport directory caches, except instead of tuples, store ZipInfo objects. Use a platform-specific path separator (os.sep) for the path keys for compatibility with pypy on Windows. """ with zipfile.ZipFile(path) as zfile: items = ( ( name.replace('/', os.sep), zfile.getinfo(name), ) for name in zfile.namelist() ) return dict(items) load = build class MemoizedZipManifests(ZipManifests): """ Memoized zipfile manifests. """ manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime') def load(self, path): """ Load a manifest at path or return a suitable manifest already loaded. """ path = os.path.normpath(path) mtime = os.stat(path).st_mtime if path not in self or self[path].mtime != mtime: manifest = self.build(path) self[path] = self.manifest_mod(manifest, mtime) return self[path].manifest class ZipProvider(EggProvider): """Resource support for zips and eggs""" eagers = None _zip_manifests = MemoizedZipManifests() def __init__(self, module): EggProvider.__init__(self, module) self.zip_pre = self.loader.archive + os.sep def _zipinfo_name(self, fspath): # Convert a virtual filename (full path to file) into a zipfile subpath # usable with the zipimport directory cache for our target archive fspath = fspath.rstrip(os.sep) if fspath == self.loader.archive: return '' if fspath.startswith(self.zip_pre): return fspath[len(self.zip_pre):] raise AssertionError( "%s is not a subpath of %s" % (fspath, self.zip_pre) ) def _parts(self, zip_path): # Convert a zipfile subpath into an egg-relative path part list. # pseudo-fs path fspath = self.zip_pre + zip_path if fspath.startswith(self.egg_root + os.sep): return fspath[len(self.egg_root) + 1:].split(os.sep) raise AssertionError( "%s is not a subpath of %s" % (fspath, self.egg_root) ) @property def zipinfo(self): return self._zip_manifests.load(self.loader.archive) def get_resource_filename(self, manager, resource_name): if not self.egg_name: raise NotImplementedError( "resource_filename() only supported for .egg, not .zip" ) # no need to lock for extraction, since we use temp names zip_path = self._resource_to_zip(resource_name) eagers = self._get_eager_resources() if '/'.join(self._parts(zip_path)) in eagers: for name in eagers: self._extract_resource(manager, self._eager_to_zip(name)) return self._extract_resource(manager, zip_path) @staticmethod def _get_date_and_size(zip_stat): size = zip_stat.file_size # ymdhms+wday, yday, dst date_time = zip_stat.date_time + (0, 0, -1) # 1980 offset already done timestamp = time.mktime(date_time) return timestamp, size # FIXME: 'ZipProvider._extract_resource' is too complex (12) def _extract_resource(self, manager, zip_path): # noqa: C901 if zip_path in self._index(): for name in self._index()[zip_path]: last = self._extract_resource( manager, os.path.join(zip_path, name) ) # return the extracted directory name return os.path.dirname(last) timestamp, size = self._get_date_and_size(self.zipinfo[zip_path]) if not WRITE_SUPPORT: raise IOError('"os.rename" and "os.unlink" are not supported ' 'on this platform') try: real_path = manager.get_cache_path( self.egg_name, self._parts(zip_path) ) if self._is_current(real_path, zip_path): return real_path outf, tmpnam = _mkstemp( ".$extract", dir=os.path.dirname(real_path), ) os.write(outf, self.loader.get_data(zip_path)) os.close(outf) utime(tmpnam, (timestamp, timestamp)) manager.postprocess(tmpnam, real_path) try: rename(tmpnam, real_path) except os.error: if os.path.isfile(real_path): if self._is_current(real_path, zip_path): # the file became current since it was checked above, # so proceed. return real_path # Windows, del old file and retry elif os.name == 'nt': unlink(real_path) rename(tmpnam, real_path) return real_path raise except os.error: # report a user-friendly error manager.extraction_error() return real_path def _is_current(self, file_path, zip_path): """ Return True if the file_path is current for this zip_path """ timestamp, size = self._get_date_and_size(self.zipinfo[zip_path]) if not os.path.isfile(file_path): return False stat = os.stat(file_path) if stat.st_size != size or stat.st_mtime != timestamp: return False # check that the contents match zip_contents = self.loader.get_data(zip_path) with open(file_path, 'rb') as f: file_contents = f.read() return zip_contents == file_contents def _get_eager_resources(self): if self.eagers is None: eagers = [] for name in ('native_libs.txt', 'eager_resources.txt'): if self.has_metadata(name): eagers.extend(self.get_metadata_lines(name)) self.eagers = eagers return self.eagers def _index(self): try: return self._dirindex except AttributeError: ind = {} for path in self.zipinfo: parts = path.split(os.sep) while parts: parent = os.sep.join(parts[:-1]) if parent in ind: ind[parent].append(parts[-1]) break else: ind[parent] = [parts.pop()] self._dirindex = ind return ind def _has(self, fspath): zip_path = self._zipinfo_name(fspath) return zip_path in self.zipinfo or zip_path in self._index() def _isdir(self, fspath): return self._zipinfo_name(fspath) in self._index() def _listdir(self, fspath): return list(self._index().get(self._zipinfo_name(fspath), ())) def _eager_to_zip(self, resource_name): return self._zipinfo_name(self._fn(self.egg_root, resource_name)) def _resource_to_zip(self, resource_name): return self._zipinfo_name(self._fn(self.module_path, resource_name)) register_loader_type(zipimport.zipimporter, ZipProvider) class FileMetadata(EmptyProvider): """Metadata handler for standalone PKG-INFO files Usage:: metadata = FileMetadata("/path/to/PKG-INFO") This provider rejects all data and metadata requests except for PKG-INFO, which is treated as existing, and will be the contents of the file at the provided location. """ def __init__(self, path): self.path = path def _get_metadata_path(self, name): return self.path def has_metadata(self, name): return name == 'PKG-INFO' and os.path.isfile(self.path) def get_metadata(self, name): if name != 'PKG-INFO': raise KeyError("No metadata except PKG-INFO is available") with io.open(self.path, encoding='utf-8', errors="replace") as f: metadata = f.read() self._warn_on_replacement(metadata) return metadata def _warn_on_replacement(self, metadata): replacement_char = '�' if replacement_char in metadata: tmpl = "{self.path} could not be properly decoded in UTF-8" msg = tmpl.format(**locals()) warnings.warn(msg) def get_metadata_lines(self, name): return yield_lines(self.get_metadata(name)) class PathMetadata(DefaultProvider): """Metadata provider for egg directories Usage:: # Development eggs: egg_info = "/path/to/PackageName.egg-info" base_dir = os.path.dirname(egg_info) metadata = PathMetadata(base_dir, egg_info) dist_name = os.path.splitext(os.path.basename(egg_info))[0] dist = Distribution(basedir, project_name=dist_name, metadata=metadata) # Unpacked egg directories: egg_path = "/path/to/PackageName-ver-pyver-etc.egg" metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO')) dist = Distribution.from_filename(egg_path, metadata=metadata) """ def __init__(self, path, egg_info): self.module_path = path self.egg_info = egg_info class EggMetadata(ZipProvider): """Metadata provider for .egg files""" def __init__(self, importer): """Create a metadata provider from a zipimporter""" self.zip_pre = importer.archive + os.sep self.loader = importer if importer.prefix: self.module_path = os.path.join(importer.archive, importer.prefix) else: self.module_path = importer.archive self._setup_prefix() _declare_state('dict', _distribution_finders={}) def register_finder(importer_type, distribution_finder): """Register `distribution_finder` to find distributions in sys.path items `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item handler), and `distribution_finder` is a callable that, passed a path item and the importer instance, yields ``Distribution`` instances found on that path item. See ``pkg_resources.find_on_path`` for an example.""" _distribution_finders[importer_type] = distribution_finder def find_distributions(path_item, only=False): """Yield distributions accessible via `path_item`""" importer = get_importer(path_item) finder = _find_adapter(_distribution_finders, importer) return finder(importer, path_item, only) def find_eggs_in_zip(importer, path_item, only=False): """ Find eggs in zip files; possibly multiple nested eggs. """ if importer.archive.endswith('.whl'): # wheels are not supported with this finder # they don't have PKG-INFO metadata, and won't ever contain eggs return metadata = EggMetadata(importer) if metadata.has_metadata('PKG-INFO'): yield Distribution.from_filename(path_item, metadata=metadata) if only: # don't yield nested distros return for subitem in metadata.resource_listdir(''): if _is_egg_path(subitem): subpath = os.path.join(path_item, subitem) dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath) for dist in dists: yield dist elif subitem.lower().endswith(('.dist-info', '.egg-info')): subpath = os.path.join(path_item, subitem) submeta = EggMetadata(zipimport.zipimporter(subpath)) submeta.egg_info = subpath yield Distribution.from_location(path_item, subitem, submeta) register_finder(zipimport.zipimporter, find_eggs_in_zip) def find_nothing(importer, path_item, only=False): return () register_finder(object, find_nothing) def _by_version_descending(names): """ Given a list of filenames, return them in descending order by version number. >>> names = 'bar', 'foo', 'Python-2.7.10.egg', 'Python-2.7.2.egg' >>> _by_version_descending(names) ['Python-2.7.10.egg', 'Python-2.7.2.egg', 'bar', 'foo'] >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.egg' >>> _by_version_descending(names) ['Setuptools-1.2.3.egg', 'Setuptools-1.2.3b1.egg'] >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.post1.egg' >>> _by_version_descending(names) ['Setuptools-1.2.3.post1.egg', 'Setuptools-1.2.3b1.egg'] """ def try_parse(name): """ Attempt to parse as a version or return a null version. """ try: return packaging.version.Version(name) except Exception: return packaging.version.Version('0') def _by_version(name): """ Parse each component of the filename """ name, ext = os.path.splitext(name) parts = itertools.chain(name.split('-'), [ext]) return [try_parse(part) for part in parts] return sorted(names, key=_by_version, reverse=True) def find_on_path(importer, path_item, only=False): """Yield distributions accessible on a sys.path directory""" path_item = _normalize_cached(path_item) if _is_unpacked_egg(path_item): yield Distribution.from_filename( path_item, metadata=PathMetadata( path_item, os.path.join(path_item, 'EGG-INFO') ) ) return entries = ( os.path.join(path_item, child) for child in safe_listdir(path_item) ) # for performance, before sorting by version, # screen entries for only those that will yield # distributions filtered = ( entry for entry in entries if dist_factory(path_item, entry, only) ) # scan for .egg and .egg-info in directory path_item_entries = _by_version_descending(filtered) for entry in path_item_entries: fullpath = os.path.join(path_item, entry) factory = dist_factory(path_item, entry, only) for dist in factory(fullpath): yield dist def dist_factory(path_item, entry, only): """Return a dist_factory for the given entry.""" lower = entry.lower() is_egg_info = lower.endswith('.egg-info') is_dist_info = ( lower.endswith('.dist-info') and os.path.isdir(os.path.join(path_item, entry)) ) is_meta = is_egg_info or is_dist_info return ( distributions_from_metadata if is_meta else find_distributions if not only and _is_egg_path(entry) else resolve_egg_link if not only and lower.endswith('.egg-link') else NoDists() ) class NoDists: """ >>> bool(NoDists()) False >>> list(NoDists()('anything')) [] """ def __bool__(self): return False def __call__(self, fullpath): return iter(()) def safe_listdir(path): """ Attempt to list contents of path, but suppress some exceptions. """ try: return os.listdir(path) except (PermissionError, NotADirectoryError): pass except OSError as e: # Ignore the directory if does not exist, not a directory or # permission denied if e.errno not in (errno.ENOTDIR, errno.EACCES, errno.ENOENT): raise return () def distributions_from_metadata(path): root = os.path.dirname(path) if os.path.isdir(path): if len(os.listdir(path)) == 0: # empty metadata dir; skip return metadata = PathMetadata(root, path) else: metadata = FileMetadata(path) entry = os.path.basename(path) yield Distribution.from_location( root, entry, metadata, precedence=DEVELOP_DIST, ) def non_empty_lines(path): """ Yield non-empty lines from file at path """ with open(path) as f: for line in f: line = line.strip() if line: yield line def resolve_egg_link(path): """ Given a path to an .egg-link, resolve distributions present in the referenced path. """ referenced_paths = non_empty_lines(path) resolved_paths = ( os.path.join(os.path.dirname(path), ref) for ref in referenced_paths ) dist_groups = map(find_distributions, resolved_paths) return next(dist_groups, ()) register_finder(pkgutil.ImpImporter, find_on_path) if hasattr(importlib_machinery, 'FileFinder'): register_finder(importlib_machinery.FileFinder, find_on_path) _declare_state('dict', _namespace_handlers={}) _declare_state('dict', _namespace_packages={}) def register_namespace_handler(importer_type, namespace_handler): """Register `namespace_handler` to declare namespace packages `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item handler), and `namespace_handler` is a callable like this:: def namespace_handler(importer, path_entry, moduleName, module): # return a path_entry to use for child packages Namespace handlers are only called if the importer object has already agreed that it can handle the relevant path item, and they should only return a subpath if the module __path__ does not already contain an equivalent subpath. For an example namespace handler, see ``pkg_resources.file_ns_handler``. """ _namespace_handlers[importer_type] = namespace_handler def _handle_ns(packageName, path_item): """Ensure that named package includes a subpath of path_item (if needed)""" importer = get_importer(path_item) if importer is None: return None # use find_spec (PEP 451) and fall-back to find_module (PEP 302) try: loader = importer.find_spec(packageName).loader except AttributeError: # capture warnings due to #1111 with warnings.catch_warnings(): warnings.simplefilter("ignore") loader = importer.find_module(packageName) if loader is None: return None module = sys.modules.get(packageName) if module is None: module = sys.modules[packageName] = types.ModuleType(packageName) module.__path__ = [] _set_parent_ns(packageName) elif not hasattr(module, '__path__'): raise TypeError("Not a package:", packageName) handler = _find_adapter(_namespace_handlers, importer) subpath = handler(importer, path_item, packageName, module) if subpath is not None: path = module.__path__ path.append(subpath) importlib.import_module(packageName) _rebuild_mod_path(path, packageName, module) return subpath def _rebuild_mod_path(orig_path, package_name, module): """ Rebuild module.__path__ ensuring that all entries are ordered corresponding to their sys.path order """ sys_path = [_normalize_cached(p) for p in sys.path] def safe_sys_path_index(entry): """ Workaround for #520 and #513. """ try: return sys_path.index(entry) except ValueError: return float('inf') def position_in_sys_path(path): """ Return the ordinal of the path based on its position in sys.path """ path_parts = path.split(os.sep) module_parts = package_name.count('.') + 1 parts = path_parts[:-module_parts] return safe_sys_path_index(_normalize_cached(os.sep.join(parts))) new_path = sorted(orig_path, key=position_in_sys_path) new_path = [_normalize_cached(p) for p in new_path] if isinstance(module.__path__, list): module.__path__[:] = new_path else: module.__path__ = new_path def declare_namespace(packageName): """Declare that package 'packageName' is a namespace package""" _imp.acquire_lock() try: if packageName in _namespace_packages: return path = sys.path parent, _, _ = packageName.rpartition('.') if parent: declare_namespace(parent) if parent not in _namespace_packages: __import__(parent) try: path = sys.modules[parent].__path__ except AttributeError as e: raise TypeError("Not a package:", parent) from e # Track what packages are namespaces, so when new path items are added, # they can be updated _namespace_packages.setdefault(parent or None, []).append(packageName) _namespace_packages.setdefault(packageName, []) for path_item in path: # Ensure all the parent's path items are reflected in the child, # if they apply _handle_ns(packageName, path_item) finally: _imp.release_lock() def fixup_namespace_packages(path_item, parent=None): """Ensure that previously-declared namespace packages include path_item""" _imp.acquire_lock() try: for package in _namespace_packages.get(parent, ()): subpath = _handle_ns(package, path_item) if subpath: fixup_namespace_packages(subpath, package) finally: _imp.release_lock() def file_ns_handler(importer, path_item, packageName, module): """Compute an ns-package subpath for a filesystem or zipfile importer""" subpath = os.path.join(path_item, packageName.split('.')[-1]) normalized = _normalize_cached(subpath) for item in module.__path__: if _normalize_cached(item) == normalized: break else: # Only return the path if it's not already there return subpath register_namespace_handler(pkgutil.ImpImporter, file_ns_handler) register_namespace_handler(zipimport.zipimporter, file_ns_handler) if hasattr(importlib_machinery, 'FileFinder'): register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler) def null_ns_handler(importer, path_item, packageName, module): return None register_namespace_handler(object, null_ns_handler) def normalize_path(filename): """Normalize a file/dir name for comparison purposes""" return os.path.normcase(os.path.realpath(os.path.normpath( _cygwin_patch(filename)))) def _cygwin_patch(filename): # pragma: nocover """ Contrary to POSIX 2008, on Cygwin, getcwd (3) contains symlink components. Using os.path.abspath() works around this limitation. A fix in os.getcwd() would probably better, in Cygwin even more so, except that this seems to be by design... """ return os.path.abspath(filename) if sys.platform == 'cygwin' else filename def _normalize_cached(filename, _cache={}): try: return _cache[filename] except KeyError: _cache[filename] = result = normalize_path(filename) return result def _is_egg_path(path): """ Determine if given path appears to be an egg. """ return _is_zip_egg(path) or _is_unpacked_egg(path) def _is_zip_egg(path): return ( path.lower().endswith('.egg') and os.path.isfile(path) and zipfile.is_zipfile(path) ) def _is_unpacked_egg(path): """ Determine if given path appears to be an unpacked egg. """ return ( path.lower().endswith('.egg') and os.path.isfile(os.path.join(path, 'EGG-INFO', 'PKG-INFO')) ) def _set_parent_ns(packageName): parts = packageName.split('.') name = parts.pop() if parts: parent = '.'.join(parts) setattr(sys.modules[parent], name, sys.modules[packageName]) def _nonblank(str): return str and not str.startswith('#') @functools.singledispatch def yield_lines(iterable): """Yield valid lines of a string or iterable""" return itertools.chain.from_iterable(map(yield_lines, iterable)) @yield_lines.register(str) def _(text): return filter(_nonblank, map(str.strip, text.splitlines())) MODULE = re.compile(r"\w+(\.\w+)*$").match EGG_NAME = re.compile( r""" (?P[^-]+) ( -(?P[^-]+) ( -py(?P[^-]+) ( -(?P.+) )? )? )? """, re.VERBOSE | re.IGNORECASE, ).match class EntryPoint: """Object representing an advertised importable object""" def __init__(self, name, module_name, attrs=(), extras=(), dist=None): if not MODULE(module_name): raise ValueError("Invalid module name", module_name) self.name = name self.module_name = module_name self.attrs = tuple(attrs) self.extras = tuple(extras) self.dist = dist def __str__(self): s = "%s = %s" % (self.name, self.module_name) if self.attrs: s += ':' + '.'.join(self.attrs) if self.extras: s += ' [%s]' % ','.join(self.extras) return s def __repr__(self): return "EntryPoint.parse(%r)" % str(self) def load(self, require=True, *args, **kwargs): """ Require packages for this EntryPoint, then resolve it. """ if not require or args or kwargs: warnings.warn( "Parameters to load are deprecated. Call .resolve and " ".require separately.", PkgResourcesDeprecationWarning, stacklevel=2, ) if require: self.require(*args, **kwargs) return self.resolve() def resolve(self): """ Resolve the entry point from its module and attrs. """ module = __import__(self.module_name, fromlist=['__name__'], level=0) try: return functools.reduce(getattr, self.attrs, module) except AttributeError as exc: raise ImportError(str(exc)) from exc def require(self, env=None, installer=None): if self.extras and not self.dist: raise UnknownExtra("Can't require() without a distribution", self) # Get the requirements for this entry point with all its extras and # then resolve them. We have to pass `extras` along when resolving so # that the working set knows what extras we want. Otherwise, for # dist-info distributions, the working set will assume that the # requirements for that extra are purely optional and skip over them. reqs = self.dist.requires(self.extras) items = working_set.resolve(reqs, env, installer, extras=self.extras) list(map(working_set.add, items)) pattern = re.compile( r'\s*' r'(?P.+?)\s*' r'=\s*' r'(?P[\w.]+)\s*' r'(:\s*(?P[\w.]+))?\s*' r'(?P\[.*\])?\s*$' ) @classmethod def parse(cls, src, dist=None): """Parse a single entry point from string `src` Entry point syntax follows the form:: name = some.module:some.attr [extra1, extra2] The entry name and module name are required, but the ``:attrs`` and ``[extras]`` parts are optional """ m = cls.pattern.match(src) if not m: msg = "EntryPoint must be in 'name=module:attrs [extras]' format" raise ValueError(msg, src) res = m.groupdict() extras = cls._parse_extras(res['extras']) attrs = res['attr'].split('.') if res['attr'] else () return cls(res['name'], res['module'], attrs, extras, dist) @classmethod def _parse_extras(cls, extras_spec): if not extras_spec: return () req = Requirement.parse('x' + extras_spec) if req.specs: raise ValueError() return req.extras @classmethod def parse_group(cls, group, lines, dist=None): """Parse an entry point group""" if not MODULE(group): raise ValueError("Invalid group name", group) this = {} for line in yield_lines(lines): ep = cls.parse(line, dist) if ep.name in this: raise ValueError("Duplicate entry point", group, ep.name) this[ep.name] = ep return this @classmethod def parse_map(cls, data, dist=None): """Parse a map of entry point groups""" if isinstance(data, dict): data = data.items() else: data = split_sections(data) maps = {} for group, lines in data: if group is None: if not lines: continue raise ValueError("Entry points must be listed in groups") group = group.strip() if group in maps: raise ValueError("Duplicate group name", group) maps[group] = cls.parse_group(group, lines, dist) return maps def _version_from_file(lines): """ Given an iterable of lines from a Metadata file, return the value of the Version field, if present, or None otherwise. """ def is_version_line(line): return line.lower().startswith('version:') version_lines = filter(is_version_line, lines) line = next(iter(version_lines), '') _, _, value = line.partition(':') return safe_version(value.strip()) or None class Distribution: """Wrap an actual or potential sys.path entry w/metadata""" PKG_INFO = 'PKG-INFO' def __init__( self, location=None, metadata=None, project_name=None, version=None, py_version=PY_MAJOR, platform=None, precedence=EGG_DIST): self.project_name = safe_name(project_name or 'Unknown') if version is not None: self._version = safe_version(version) self.py_version = py_version self.platform = platform self.location = location self.precedence = precedence self._provider = metadata or empty_provider @classmethod def from_location(cls, location, basename, metadata=None, **kw): project_name, version, py_version, platform = [None] * 4 basename, ext = os.path.splitext(basename) if ext.lower() in _distributionImpl: cls = _distributionImpl[ext.lower()] match = EGG_NAME(basename) if match: project_name, version, py_version, platform = match.group( 'name', 'ver', 'pyver', 'plat' ) return cls( location, metadata, project_name=project_name, version=version, py_version=py_version, platform=platform, **kw )._reload_version() def _reload_version(self): return self @property def hashcmp(self): return ( self.parsed_version, self.precedence, self.key, self.location, self.py_version or '', self.platform or '', ) def __hash__(self): return hash(self.hashcmp) def __lt__(self, other): return self.hashcmp < other.hashcmp def __le__(self, other): return self.hashcmp <= other.hashcmp def __gt__(self, other): return self.hashcmp > other.hashcmp def __ge__(self, other): return self.hashcmp >= other.hashcmp def __eq__(self, other): if not isinstance(other, self.__class__): # It's not a Distribution, so they are not equal return False return self.hashcmp == other.hashcmp def __ne__(self, other): return not self == other # These properties have to be lazy so that we don't have to load any # metadata until/unless it's actually needed. (i.e., some distributions # may not know their name or version without loading PKG-INFO) @property def key(self): try: return self._key except AttributeError: self._key = key = self.project_name.lower() return key @property def parsed_version(self): if not hasattr(self, "_parsed_version"): self._parsed_version = parse_version(self.version) return self._parsed_version def _warn_legacy_version(self): LV = packaging.version.LegacyVersion is_legacy = isinstance(self._parsed_version, LV) if not is_legacy: return # While an empty version is technically a legacy version and # is not a valid PEP 440 version, it's also unlikely to # actually come from someone and instead it is more likely that # it comes from setuptools attempting to parse a filename and # including it in the list. So for that we'll gate this warning # on if the version is anything at all or not. if not self.version: return tmpl = textwrap.dedent(""" '{project_name} ({version})' is being parsed as a legacy, non PEP 440, version. You may find odd behavior and sort order. In particular it will be sorted as less than 0.0. It is recommended to migrate to PEP 440 compatible versions. """).strip().replace('\n', ' ') warnings.warn(tmpl.format(**vars(self)), PEP440Warning) @property def version(self): try: return self._version except AttributeError as e: version = self._get_version() if version is None: path = self._get_metadata_path_for_display(self.PKG_INFO) msg = ( "Missing 'Version:' header and/or {} file at path: {}" ).format(self.PKG_INFO, path) raise ValueError(msg, self) from e return version @property def _dep_map(self): """ A map of extra to its list of (direct) requirements for this distribution, including the null extra. """ try: return self.__dep_map except AttributeError: self.__dep_map = self._filter_extras(self._build_dep_map()) return self.__dep_map @staticmethod def _filter_extras(dm): """ Given a mapping of extras to dependencies, strip off environment markers and filter out any dependencies not matching the markers. """ for extra in list(filter(None, dm)): new_extra = extra reqs = dm.pop(extra) new_extra, _, marker = extra.partition(':') fails_marker = marker and ( invalid_marker(marker) or not evaluate_marker(marker) ) if fails_marker: reqs = [] new_extra = safe_extra(new_extra) or None dm.setdefault(new_extra, []).extend(reqs) return dm def _build_dep_map(self): dm = {} for name in 'requires.txt', 'depends.txt': for extra, reqs in split_sections(self._get_metadata(name)): dm.setdefault(extra, []).extend(parse_requirements(reqs)) return dm def requires(self, extras=()): """List of Requirements needed for this distro if `extras` are used""" dm = self._dep_map deps = [] deps.extend(dm.get(None, ())) for ext in extras: try: deps.extend(dm[safe_extra(ext)]) except KeyError as e: raise UnknownExtra( "%s has no such extra feature %r" % (self, ext) ) from e return deps def _get_metadata_path_for_display(self, name): """ Return the path to the given metadata file, if available. """ try: # We need to access _get_metadata_path() on the provider object # directly rather than through this class's __getattr__() # since _get_metadata_path() is marked private. path = self._provider._get_metadata_path(name) # Handle exceptions e.g. in case the distribution's metadata # provider doesn't support _get_metadata_path(). except Exception: return '[could not detect]' return path def _get_metadata(self, name): if self.has_metadata(name): for line in self.get_metadata_lines(name): yield line def _get_version(self): lines = self._get_metadata(self.PKG_INFO) version = _version_from_file(lines) return version def activate(self, path=None, replace=False): """Ensure distribution is importable on `path` (default=sys.path)""" if path is None: path = sys.path self.insert_on(path, replace=replace) if path is sys.path: fixup_namespace_packages(self.location) for pkg in self._get_metadata('namespace_packages.txt'): if pkg in sys.modules: declare_namespace(pkg) def egg_name(self): """Return what this distribution's standard .egg filename should be""" filename = "%s-%s-py%s" % ( to_filename(self.project_name), to_filename(self.version), self.py_version or PY_MAJOR ) if self.platform: filename += '-' + self.platform return filename def __repr__(self): if self.location: return "%s (%s)" % (self, self.location) else: return str(self) def __str__(self): try: version = getattr(self, 'version', None) except ValueError: version = None version = version or "[unknown version]" return "%s %s" % (self.project_name, version) def __getattr__(self, attr): """Delegate all unrecognized public attributes to .metadata provider""" if attr.startswith('_'): raise AttributeError(attr) return getattr(self._provider, attr) def __dir__(self): return list( set(super(Distribution, self).__dir__()) | set( attr for attr in self._provider.__dir__() if not attr.startswith('_') ) ) @classmethod def from_filename(cls, filename, metadata=None, **kw): return cls.from_location( _normalize_cached(filename), os.path.basename(filename), metadata, **kw ) def as_requirement(self): """Return a ``Requirement`` that matches this distribution exactly""" if isinstance(self.parsed_version, packaging.version.Version): spec = "%s==%s" % (self.project_name, self.parsed_version) else: spec = "%s===%s" % (self.project_name, self.parsed_version) return Requirement.parse(spec) def load_entry_point(self, group, name): """Return the `name` entry point of `group` or raise ImportError""" ep = self.get_entry_info(group, name) if ep is None: raise ImportError("Entry point %r not found" % ((group, name),)) return ep.load() def get_entry_map(self, group=None): """Return the entry point map for `group`, or the full entry map""" try: ep_map = self._ep_map except AttributeError: ep_map = self._ep_map = EntryPoint.parse_map( self._get_metadata('entry_points.txt'), self ) if group is not None: return ep_map.get(group, {}) return ep_map def get_entry_info(self, group, name): """Return the EntryPoint object for `group`+`name`, or ``None``""" return self.get_entry_map(group).get(name) # FIXME: 'Distribution.insert_on' is too complex (13) def insert_on(self, path, loc=None, replace=False): # noqa: C901 """Ensure self.location is on path If replace=False (default): - If location is already in path anywhere, do nothing. - Else: - If it's an egg and its parent directory is on path, insert just ahead of the parent. - Else: add to the end of path. If replace=True: - If location is already on path anywhere (not eggs) or higher priority than its parent (eggs) do nothing. - Else: - If it's an egg and its parent directory is on path, insert just ahead of the parent, removing any lower-priority entries. - Else: add it to the front of path. """ loc = loc or self.location if not loc: return nloc = _normalize_cached(loc) bdir = os.path.dirname(nloc) npath = [(p and _normalize_cached(p) or p) for p in path] for p, item in enumerate(npath): if item == nloc: if replace: break else: # don't modify path (even removing duplicates) if # found and not replace return elif item == bdir and self.precedence == EGG_DIST: # if it's an .egg, give it precedence over its directory # UNLESS it's already been added to sys.path and replace=False if (not replace) and nloc in npath[p:]: return if path is sys.path: self.check_version_conflict() path.insert(p, loc) npath.insert(p, nloc) break else: if path is sys.path: self.check_version_conflict() if replace: path.insert(0, loc) else: path.append(loc) return # p is the spot where we found or inserted loc; now remove duplicates while True: try: np = npath.index(nloc, p + 1) except ValueError: break else: del npath[np], path[np] # ha! p = np return def check_version_conflict(self): if self.key == 'setuptools': # ignore the inevitable setuptools self-conflicts :( return nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt')) loc = normalize_path(self.location) for modname in self._get_metadata('top_level.txt'): if (modname not in sys.modules or modname in nsp or modname in _namespace_packages): continue if modname in ('pkg_resources', 'setuptools', 'site'): continue fn = getattr(sys.modules[modname], '__file__', None) if fn and (normalize_path(fn).startswith(loc) or fn.startswith(self.location)): continue issue_warning( "Module %s was already imported from %s, but %s is being added" " to sys.path" % (modname, fn, self.location), ) def has_version(self): try: self.version except ValueError: issue_warning("Unbuilt egg for " + repr(self)) return False return True def clone(self, **kw): """Copy this distribution, substituting in any changed keyword args""" names = 'project_name version py_version platform location precedence' for attr in names.split(): kw.setdefault(attr, getattr(self, attr, None)) kw.setdefault('metadata', self._provider) return self.__class__(**kw) @property def extras(self): return [dep for dep in self._dep_map if dep] class EggInfoDistribution(Distribution): def _reload_version(self): """ Packages installed by distutils (e.g. numpy or scipy), which uses an old safe_version, and so their version numbers can get mangled when converted to filenames (e.g., 1.11.0.dev0+2329eae to 1.11.0.dev0_2329eae). These distributions will not be parsed properly downstream by Distribution and safe_version, so take an extra step and try to get the version number from the metadata file itself instead of the filename. """ md_version = self._get_version() if md_version: self._version = md_version return self class DistInfoDistribution(Distribution): """ Wrap an actual or potential sys.path entry w/metadata, .dist-info style. """ PKG_INFO = 'METADATA' EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])") @property def _parsed_pkg_info(self): """Parse and cache metadata""" try: return self._pkg_info except AttributeError: metadata = self.get_metadata(self.PKG_INFO) self._pkg_info = email.parser.Parser().parsestr(metadata) return self._pkg_info @property def _dep_map(self): try: return self.__dep_map except AttributeError: self.__dep_map = self._compute_dependencies() return self.__dep_map def _compute_dependencies(self): """Recompute this distribution's dependencies.""" dm = self.__dep_map = {None: []} reqs = [] # Including any condition expressions for req in self._parsed_pkg_info.get_all('Requires-Dist') or []: reqs.extend(parse_requirements(req)) def reqs_for_extra(extra): for req in reqs: if not req.marker or req.marker.evaluate({'extra': extra}): yield req common = frozenset(reqs_for_extra(None)) dm[None].extend(common) for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []: s_extra = safe_extra(extra.strip()) dm[s_extra] = list(frozenset(reqs_for_extra(extra)) - common) return dm _distributionImpl = { '.egg': Distribution, '.egg-info': EggInfoDistribution, '.dist-info': DistInfoDistribution, } def issue_warning(*args, **kw): level = 1 g = globals() try: # find the first stack frame that is *not* code in # the pkg_resources module, to use for the warning while sys._getframe(level).f_globals is g: level += 1 except ValueError: pass warnings.warn(stacklevel=level + 1, *args, **kw) def parse_requirements(strs): """Yield ``Requirement`` objects for each specification in `strs` `strs` must be a string, or a (possibly-nested) iterable thereof. """ # create a steppable iterator, so we can handle \-continuations lines = iter(yield_lines(strs)) for line in lines: # Drop comments -- a hash without a space may be in a URL. if ' #' in line: line = line[:line.find(' #')] # If there is a line continuation, drop it, and append the next line. if line.endswith('\\'): line = line[:-2].strip() try: line += next(lines) except StopIteration: return yield Requirement(line) class RequirementParseError(packaging.requirements.InvalidRequirement): "Compatibility wrapper for InvalidRequirement" class Requirement(packaging.requirements.Requirement): def __init__(self, requirement_string): """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!""" super(Requirement, self).__init__(requirement_string) self.unsafe_name = self.name project_name = safe_name(self.name) self.project_name, self.key = project_name, project_name.lower() self.specs = [ (spec.operator, spec.version) for spec in self.specifier] self.extras = tuple(map(safe_extra, self.extras)) self.hashCmp = ( self.key, self.url, self.specifier, frozenset(self.extras), str(self.marker) if self.marker else None, ) self.__hash = hash(self.hashCmp) def __eq__(self, other): return ( isinstance(other, Requirement) and self.hashCmp == other.hashCmp ) def __ne__(self, other): return not self == other def __contains__(self, item): if isinstance(item, Distribution): if item.key != self.key: return False item = item.version # Allow prereleases always in order to match the previous behavior of # this method. In the future this should be smarter and follow PEP 440 # more accurately. return self.specifier.contains(item, prereleases=True) def __hash__(self): return self.__hash def __repr__(self): return "Requirement.parse(%r)" % str(self) @staticmethod def parse(s): req, = parse_requirements(s) return req def _always_object(classes): """ Ensure object appears in the mro even for old-style classes. """ if object not in classes: return classes + (object,) return classes def _find_adapter(registry, ob): """Return an adapter factory for `ob` from `registry`""" types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob)))) for t in types: if t in registry: return registry[t] def ensure_directory(path): """Ensure that the parent directory of `path` exists""" dirname = os.path.dirname(path) os.makedirs(dirname, exist_ok=True) def _bypass_ensure_directory(path): """Sandbox-bypassing version of ensure_directory()""" if not WRITE_SUPPORT: raise IOError('"os.mkdir" not supported on this platform.') dirname, filename = split(path) if dirname and filename and not isdir(dirname): _bypass_ensure_directory(dirname) try: mkdir(dirname, 0o755) except FileExistsError: pass def split_sections(s): """Split a string or iterable thereof into (section, content) pairs Each ``section`` is a stripped version of the section header ("[section]") and each ``content`` is a list of stripped lines excluding blank lines and comment-only lines. If there are any such lines before the first section header, they're returned in a first ``section`` of ``None``. """ section = None content = [] for line in yield_lines(s): if line.startswith("["): if line.endswith("]"): if section or content: yield section, content section = line[1:-1].strip() content = [] else: raise ValueError("Invalid section heading", line) else: content.append(line) # wrap up last segment yield section, content def _mkstemp(*args, **kw): old_open = os.open try: # temporarily bypass sandboxing os.open = os_open return tempfile.mkstemp(*args, **kw) finally: # and then put it back os.open = old_open # Silence the PEP440Warning by default, so that end users don't get hit by it # randomly just because they use pkg_resources. We want to append the rule # because we want earlier uses of filterwarnings to take precedence over this # one. warnings.filterwarnings("ignore", category=PEP440Warning, append=True) # from jaraco.functools 1.3 def _call_aside(f, *args, **kwargs): f(*args, **kwargs) return f @_call_aside def _initialize(g=globals()): "Set up global resource manager (deliberately not state-saved)" manager = ResourceManager() g['_manager'] = manager g.update( (name, getattr(manager, name)) for name in dir(manager) if not name.startswith('_') ) class PkgResourcesDeprecationWarning(Warning): """ Base class for warning about deprecations in ``pkg_resources`` This class is not derived from ``DeprecationWarning``, and as such is visible by default. """ @_call_aside def _initialize_master_working_set(): """ Prepare the master working set and make the ``require()`` API available. This function has explicit effects on the global state of pkg_resources. It is intended to be invoked once at the initialization of this module. Invocation by other packages is unsupported and done at their own risk. """ working_set = WorkingSet._build_master() _declare_state('object', working_set=working_set) require = working_set.require iter_entry_points = working_set.iter_entry_points add_activation_listener = working_set.subscribe run_script = working_set.run_script # backward compatibility run_main = run_script # Activate all distributions already on sys.path with replace=False and # ensure that all distributions added to the working set in the future # (e.g. by calling ``require()``) will get activated as well, # with higher priority (replace=True). tuple( dist.activate(replace=False) for dist in working_set ) add_activation_listener( lambda dist: dist.activate(replace=True), existing=False, ) working_set.entries = [] # match order list(map(working_set.add_entry, sys.path)) globals().update(locals()) ././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1639341979.89867 setuptools-59.6.0/pkg_resources/_vendor/0000755000175100001710000000000000000000000017703 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/__init__.py0000644000175100001710000000000000000000000022002 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/appdirs.py0000644000175100001710000006017500000000000021730 0ustar00runnerdocker#!/usr/bin/env python # -*- coding: utf-8 -*- # Copyright (c) 2005-2010 ActiveState Software Inc. # Copyright (c) 2013 Eddy Petrișor """Utilities for determining application-specific dirs. See for details and usage. """ # Dev Notes: # - MSDN on where to store app data files: # http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120 # - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html # - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html __version_info__ = (1, 4, 3) __version__ = '.'.join(map(str, __version_info__)) import sys import os PY3 = sys.version_info[0] == 3 if PY3: unicode = str if sys.platform.startswith('java'): import platform os_name = platform.java_ver()[3][0] if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc. system = 'win32' elif os_name.startswith('Mac'): # "Mac OS X", etc. system = 'darwin' else: # "Linux", "SunOS", "FreeBSD", etc. # Setting this to "linux2" is not ideal, but only Windows or Mac # are actually checked for and the rest of the module expects # *sys.platform* style strings. system = 'linux2' else: system = sys.platform def user_data_dir(appname=None, appauthor=None, version=None, roaming=False): r"""Return full path to the user-specific data dir for this application. "appname" is the name of application. If None, just the system directory is returned. "appauthor" (only used on Windows) is the name of the appauthor or distributing body for this application. Typically it is the owning company name. This falls back to appname. You may pass False to disable it. "version" is an optional version path element to append to the path. You might want to use this if you want multiple versions of your app to be able to run independently. If used, this would typically be ".". Only applied when appname is present. "roaming" (boolean, default False) can be set True to use the Windows roaming appdata directory. That means that for users on a Windows network setup for roaming profiles, this user data will be sync'd on login. See for a discussion of issues. Typical user data directories are: Mac OS X: ~/Library/Application Support/ Unix: ~/.local/share/ # or in $XDG_DATA_HOME, if defined Win XP (not roaming): C:\Documents and Settings\\Application Data\\ Win XP (roaming): C:\Documents and Settings\\Local Settings\Application Data\\ Win 7 (not roaming): C:\Users\\AppData\Local\\ Win 7 (roaming): C:\Users\\AppData\Roaming\\ For Unix, we follow the XDG spec and support $XDG_DATA_HOME. That means, by default "~/.local/share/". """ if system == "win32": if appauthor is None: appauthor = appname const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA" path = os.path.normpath(_get_win_folder(const)) if appname: if appauthor is not False: path = os.path.join(path, appauthor, appname) else: path = os.path.join(path, appname) elif system == 'darwin': path = os.path.expanduser('~/Library/Application Support/') if appname: path = os.path.join(path, appname) else: path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share")) if appname: path = os.path.join(path, appname) if appname and version: path = os.path.join(path, version) return path def site_data_dir(appname=None, appauthor=None, version=None, multipath=False): r"""Return full path to the user-shared data dir for this application. "appname" is the name of application. If None, just the system directory is returned. "appauthor" (only used on Windows) is the name of the appauthor or distributing body for this application. Typically it is the owning company name. This falls back to appname. You may pass False to disable it. "version" is an optional version path element to append to the path. You might want to use this if you want multiple versions of your app to be able to run independently. If used, this would typically be ".". Only applied when appname is present. "multipath" is an optional parameter only applicable to *nix which indicates that the entire list of data dirs should be returned. By default, the first item from XDG_DATA_DIRS is returned, or '/usr/local/share/', if XDG_DATA_DIRS is not set Typical site data directories are: Mac OS X: /Library/Application Support/ Unix: /usr/local/share/ or /usr/share/ Win XP: C:\Documents and Settings\All Users\Application Data\\ Vista: (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.) Win 7: C:\ProgramData\\ # Hidden, but writeable on Win 7. For Unix, this is using the $XDG_DATA_DIRS[0] default. WARNING: Do not use this on Windows. See the Vista-Fail note above for why. """ if system == "win32": if appauthor is None: appauthor = appname path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA")) if appname: if appauthor is not False: path = os.path.join(path, appauthor, appname) else: path = os.path.join(path, appname) elif system == 'darwin': path = os.path.expanduser('/Library/Application Support') if appname: path = os.path.join(path, appname) else: # XDG default for $XDG_DATA_DIRS # only first, if multipath is False path = os.getenv('XDG_DATA_DIRS', os.pathsep.join(['/usr/local/share', '/usr/share'])) pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)] if appname: if version: appname = os.path.join(appname, version) pathlist = [os.sep.join([x, appname]) for x in pathlist] if multipath: path = os.pathsep.join(pathlist) else: path = pathlist[0] return path if appname and version: path = os.path.join(path, version) return path def user_config_dir(appname=None, appauthor=None, version=None, roaming=False): r"""Return full path to the user-specific config dir for this application. "appname" is the name of application. If None, just the system directory is returned. "appauthor" (only used on Windows) is the name of the appauthor or distributing body for this application. Typically it is the owning company name. This falls back to appname. You may pass False to disable it. "version" is an optional version path element to append to the path. You might want to use this if you want multiple versions of your app to be able to run independently. If used, this would typically be ".". Only applied when appname is present. "roaming" (boolean, default False) can be set True to use the Windows roaming appdata directory. That means that for users on a Windows network setup for roaming profiles, this user data will be sync'd on login. See for a discussion of issues. Typical user config directories are: Mac OS X: same as user_data_dir Unix: ~/.config/ # or in $XDG_CONFIG_HOME, if defined Win *: same as user_data_dir For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME. That means, by default "~/.config/". """ if system in ["win32", "darwin"]: path = user_data_dir(appname, appauthor, None, roaming) else: path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config")) if appname: path = os.path.join(path, appname) if appname and version: path = os.path.join(path, version) return path def site_config_dir(appname=None, appauthor=None, version=None, multipath=False): r"""Return full path to the user-shared data dir for this application. "appname" is the name of application. If None, just the system directory is returned. "appauthor" (only used on Windows) is the name of the appauthor or distributing body for this application. Typically it is the owning company name. This falls back to appname. You may pass False to disable it. "version" is an optional version path element to append to the path. You might want to use this if you want multiple versions of your app to be able to run independently. If used, this would typically be ".". Only applied when appname is present. "multipath" is an optional parameter only applicable to *nix which indicates that the entire list of config dirs should be returned. By default, the first item from XDG_CONFIG_DIRS is returned, or '/etc/xdg/', if XDG_CONFIG_DIRS is not set Typical site config directories are: Mac OS X: same as site_data_dir Unix: /etc/xdg/ or $XDG_CONFIG_DIRS[i]/ for each value in $XDG_CONFIG_DIRS Win *: same as site_data_dir Vista: (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.) For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False WARNING: Do not use this on Windows. See the Vista-Fail note above for why. """ if system in ["win32", "darwin"]: path = site_data_dir(appname, appauthor) if appname and version: path = os.path.join(path, version) else: # XDG default for $XDG_CONFIG_DIRS # only first, if multipath is False path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg') pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)] if appname: if version: appname = os.path.join(appname, version) pathlist = [os.sep.join([x, appname]) for x in pathlist] if multipath: path = os.pathsep.join(pathlist) else: path = pathlist[0] return path def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True): r"""Return full path to the user-specific cache dir for this application. "appname" is the name of application. If None, just the system directory is returned. "appauthor" (only used on Windows) is the name of the appauthor or distributing body for this application. Typically it is the owning company name. This falls back to appname. You may pass False to disable it. "version" is an optional version path element to append to the path. You might want to use this if you want multiple versions of your app to be able to run independently. If used, this would typically be ".". Only applied when appname is present. "opinion" (boolean) can be False to disable the appending of "Cache" to the base app data dir for Windows. See discussion below. Typical user cache directories are: Mac OS X: ~/Library/Caches/ Unix: ~/.cache/ (XDG default) Win XP: C:\Documents and Settings\\Local Settings\Application Data\\\Cache Vista: C:\Users\\AppData\Local\\\Cache On Windows the only suggestion in the MSDN docs is that local settings go in the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming app data dir (the default returned by `user_data_dir` above). Apps typically put cache data somewhere *under* the given dir here. Some examples: ...\Mozilla\Firefox\Profiles\\Cache ...\Acme\SuperApp\Cache\1.0 OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value. This can be disabled with the `opinion=False` option. """ if system == "win32": if appauthor is None: appauthor = appname path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA")) if appname: if appauthor is not False: path = os.path.join(path, appauthor, appname) else: path = os.path.join(path, appname) if opinion: path = os.path.join(path, "Cache") elif system == 'darwin': path = os.path.expanduser('~/Library/Caches') if appname: path = os.path.join(path, appname) else: path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache')) if appname: path = os.path.join(path, appname) if appname and version: path = os.path.join(path, version) return path def user_state_dir(appname=None, appauthor=None, version=None, roaming=False): r"""Return full path to the user-specific state dir for this application. "appname" is the name of application. If None, just the system directory is returned. "appauthor" (only used on Windows) is the name of the appauthor or distributing body for this application. Typically it is the owning company name. This falls back to appname. You may pass False to disable it. "version" is an optional version path element to append to the path. You might want to use this if you want multiple versions of your app to be able to run independently. If used, this would typically be ".". Only applied when appname is present. "roaming" (boolean, default False) can be set True to use the Windows roaming appdata directory. That means that for users on a Windows network setup for roaming profiles, this user data will be sync'd on login. See for a discussion of issues. Typical user state directories are: Mac OS X: same as user_data_dir Unix: ~/.local/state/ # or in $XDG_STATE_HOME, if defined Win *: same as user_data_dir For Unix, we follow this Debian proposal to extend the XDG spec and support $XDG_STATE_HOME. That means, by default "~/.local/state/". """ if system in ["win32", "darwin"]: path = user_data_dir(appname, appauthor, None, roaming) else: path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state")) if appname: path = os.path.join(path, appname) if appname and version: path = os.path.join(path, version) return path def user_log_dir(appname=None, appauthor=None, version=None, opinion=True): r"""Return full path to the user-specific log dir for this application. "appname" is the name of application. If None, just the system directory is returned. "appauthor" (only used on Windows) is the name of the appauthor or distributing body for this application. Typically it is the owning company name. This falls back to appname. You may pass False to disable it. "version" is an optional version path element to append to the path. You might want to use this if you want multiple versions of your app to be able to run independently. If used, this would typically be ".". Only applied when appname is present. "opinion" (boolean) can be False to disable the appending of "Logs" to the base app data dir for Windows, and "log" to the base cache dir for Unix. See discussion below. Typical user log directories are: Mac OS X: ~/Library/Logs/ Unix: ~/.cache//log # or under $XDG_CACHE_HOME if defined Win XP: C:\Documents and Settings\\Local Settings\Application Data\\\Logs Vista: C:\Users\\AppData\Local\\\Logs On Windows the only suggestion in the MSDN docs is that local settings go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in examples of what some windows apps use for a logs dir.) OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA` value for Windows and appends "log" to the user cache dir for Unix. This can be disabled with the `opinion=False` option. """ if system == "darwin": path = os.path.join( os.path.expanduser('~/Library/Logs'), appname) elif system == "win32": path = user_data_dir(appname, appauthor, version) version = False if opinion: path = os.path.join(path, "Logs") else: path = user_cache_dir(appname, appauthor, version) version = False if opinion: path = os.path.join(path, "log") if appname and version: path = os.path.join(path, version) return path class AppDirs(object): """Convenience wrapper for getting application dirs.""" def __init__(self, appname=None, appauthor=None, version=None, roaming=False, multipath=False): self.appname = appname self.appauthor = appauthor self.version = version self.roaming = roaming self.multipath = multipath @property def user_data_dir(self): return user_data_dir(self.appname, self.appauthor, version=self.version, roaming=self.roaming) @property def site_data_dir(self): return site_data_dir(self.appname, self.appauthor, version=self.version, multipath=self.multipath) @property def user_config_dir(self): return user_config_dir(self.appname, self.appauthor, version=self.version, roaming=self.roaming) @property def site_config_dir(self): return site_config_dir(self.appname, self.appauthor, version=self.version, multipath=self.multipath) @property def user_cache_dir(self): return user_cache_dir(self.appname, self.appauthor, version=self.version) @property def user_state_dir(self): return user_state_dir(self.appname, self.appauthor, version=self.version) @property def user_log_dir(self): return user_log_dir(self.appname, self.appauthor, version=self.version) #---- internal support stuff def _get_win_folder_from_registry(csidl_name): """This is a fallback technique at best. I'm not sure if using the registry for this guarantees us the correct answer for all CSIDL_* names. """ if PY3: import winreg as _winreg else: import _winreg shell_folder_name = { "CSIDL_APPDATA": "AppData", "CSIDL_COMMON_APPDATA": "Common AppData", "CSIDL_LOCAL_APPDATA": "Local AppData", }[csidl_name] key = _winreg.OpenKey( _winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" ) dir, type = _winreg.QueryValueEx(key, shell_folder_name) return dir def _get_win_folder_with_pywin32(csidl_name): from win32com.shell import shellcon, shell dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0) # Try to make this a unicode path because SHGetFolderPath does # not return unicode strings when there is unicode data in the # path. try: dir = unicode(dir) # Downgrade to short path name if have highbit chars. See # . has_high_char = False for c in dir: if ord(c) > 255: has_high_char = True break if has_high_char: try: import win32api dir = win32api.GetShortPathName(dir) except ImportError: pass except UnicodeError: pass return dir def _get_win_folder_with_ctypes(csidl_name): import ctypes csidl_const = { "CSIDL_APPDATA": 26, "CSIDL_COMMON_APPDATA": 35, "CSIDL_LOCAL_APPDATA": 28, }[csidl_name] buf = ctypes.create_unicode_buffer(1024) ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf) # Downgrade to short path name if have highbit chars. See # . has_high_char = False for c in buf: if ord(c) > 255: has_high_char = True break if has_high_char: buf2 = ctypes.create_unicode_buffer(1024) if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024): buf = buf2 return buf.value def _get_win_folder_with_jna(csidl_name): import array from com.sun import jna from com.sun.jna.platform import win32 buf_size = win32.WinDef.MAX_PATH * 2 buf = array.zeros('c', buf_size) shell = win32.Shell32.INSTANCE shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf) dir = jna.Native.toString(buf.tostring()).rstrip("\0") # Downgrade to short path name if have highbit chars. See # . has_high_char = False for c in dir: if ord(c) > 255: has_high_char = True break if has_high_char: buf = array.zeros('c', buf_size) kernel = win32.Kernel32.INSTANCE if kernel.GetShortPathName(dir, buf, buf_size): dir = jna.Native.toString(buf.tostring()).rstrip("\0") return dir if system == "win32": try: import win32com.shell _get_win_folder = _get_win_folder_with_pywin32 except ImportError: try: from ctypes import windll _get_win_folder = _get_win_folder_with_ctypes except ImportError: try: import com.sun.jna _get_win_folder = _get_win_folder_with_jna except ImportError: _get_win_folder = _get_win_folder_from_registry #---- self test code if __name__ == "__main__": appname = "MyApp" appauthor = "MyCompany" props = ("user_data_dir", "user_config_dir", "user_cache_dir", "user_state_dir", "user_log_dir", "site_data_dir", "site_config_dir") print("-- app dirs %s --" % __version__) print("-- app dirs (with optional 'version')") dirs = AppDirs(appname, appauthor, version="1.0") for prop in props: print("%s: %s" % (prop, getattr(dirs, prop))) print("\n-- app dirs (without optional 'version')") dirs = AppDirs(appname, appauthor) for prop in props: print("%s: %s" % (prop, getattr(dirs, prop))) print("\n-- app dirs (without optional 'appauthor')") dirs = AppDirs(appname) for prop in props: print("%s: %s" % (prop, getattr(dirs, prop))) print("\n-- app dirs (with disabled 'appauthor')") dirs = AppDirs(appname, appauthor=False) for prop in props: print("%s: %s" % (prop, getattr(dirs, prop))) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9066699 setuptools-59.6.0/pkg_resources/_vendor/packaging/0000755000175100001710000000000000000000000021627 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/__about__.py0000644000175100001710000000122500000000000024107 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. __all__ = [ "__title__", "__summary__", "__uri__", "__version__", "__author__", "__email__", "__license__", "__copyright__", ] __title__ = "packaging" __summary__ = "Core utilities for Python packages" __uri__ = "https://github.com/pypa/packaging" __version__ = "21.2" __author__ = "Donald Stufft and individual contributors" __email__ = "donald@stufft.io" __license__ = "BSD-2-Clause or Apache-2.0" __copyright__ = "2014-2019 %s" % __author__ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/__init__.py0000644000175100001710000000076100000000000023744 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from .__about__ import ( __author__, __copyright__, __email__, __license__, __summary__, __title__, __uri__, __version__, ) __all__ = [ "__title__", "__summary__", "__uri__", "__version__", "__author__", "__email__", "__license__", "__copyright__", ] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/_manylinux.py0000644000175100001710000002634000000000000024371 0ustar00runnerdockerimport collections import functools import os import re import struct import sys import warnings from typing import IO, Dict, Iterator, NamedTuple, Optional, Tuple # Python does not provide platform information at sufficient granularity to # identify the architecture of the running executable in some cases, so we # determine it dynamically by reading the information from the running # process. This only applies on Linux, which uses the ELF format. class _ELFFileHeader: # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header class _InvalidELFFileHeader(ValueError): """ An invalid ELF file header was found. """ ELF_MAGIC_NUMBER = 0x7F454C46 ELFCLASS32 = 1 ELFCLASS64 = 2 ELFDATA2LSB = 1 ELFDATA2MSB = 2 EM_386 = 3 EM_S390 = 22 EM_ARM = 40 EM_X86_64 = 62 EF_ARM_ABIMASK = 0xFF000000 EF_ARM_ABI_VER5 = 0x05000000 EF_ARM_ABI_FLOAT_HARD = 0x00000400 def __init__(self, file: IO[bytes]) -> None: def unpack(fmt: str) -> int: try: data = file.read(struct.calcsize(fmt)) result: Tuple[int, ...] = struct.unpack(fmt, data) except struct.error: raise _ELFFileHeader._InvalidELFFileHeader() return result[0] self.e_ident_magic = unpack(">I") if self.e_ident_magic != self.ELF_MAGIC_NUMBER: raise _ELFFileHeader._InvalidELFFileHeader() self.e_ident_class = unpack("B") if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}: raise _ELFFileHeader._InvalidELFFileHeader() self.e_ident_data = unpack("B") if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}: raise _ELFFileHeader._InvalidELFFileHeader() self.e_ident_version = unpack("B") self.e_ident_osabi = unpack("B") self.e_ident_abiversion = unpack("B") self.e_ident_pad = file.read(7) format_h = "H" format_i = "I" format_q = "Q" format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q self.e_type = unpack(format_h) self.e_machine = unpack(format_h) self.e_version = unpack(format_i) self.e_entry = unpack(format_p) self.e_phoff = unpack(format_p) self.e_shoff = unpack(format_p) self.e_flags = unpack(format_i) self.e_ehsize = unpack(format_h) self.e_phentsize = unpack(format_h) self.e_phnum = unpack(format_h) self.e_shentsize = unpack(format_h) self.e_shnum = unpack(format_h) self.e_shstrndx = unpack(format_h) def _get_elf_header() -> Optional[_ELFFileHeader]: try: with open(sys.executable, "rb") as f: elf_header = _ELFFileHeader(f) except (OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader): return None return elf_header def _is_linux_armhf() -> bool: # hard-float ABI can be detected from the ELF header of the running # process # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf elf_header = _get_elf_header() if elf_header is None: return False result = elf_header.e_ident_class == elf_header.ELFCLASS32 result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB result &= elf_header.e_machine == elf_header.EM_ARM result &= ( elf_header.e_flags & elf_header.EF_ARM_ABIMASK ) == elf_header.EF_ARM_ABI_VER5 result &= ( elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD ) == elf_header.EF_ARM_ABI_FLOAT_HARD return result def _is_linux_i686() -> bool: elf_header = _get_elf_header() if elf_header is None: return False result = elf_header.e_ident_class == elf_header.ELFCLASS32 result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB result &= elf_header.e_machine == elf_header.EM_386 return result def _have_compatible_abi(arch: str) -> bool: if arch == "armv7l": return _is_linux_armhf() if arch == "i686": return _is_linux_i686() return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"} # If glibc ever changes its major version, we need to know what the last # minor version was, so we can build the complete list of all versions. # For now, guess what the highest minor version might be, assume it will # be 50 for testing. Once this actually happens, update the dictionary # with the actual value. _LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50) class _GLibCVersion(NamedTuple): major: int minor: int def _glibc_version_string_confstr() -> Optional[str]: """ Primary implementation of glibc_version_string using os.confstr. """ # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely # to be broken or missing. This strategy is used in the standard library # platform module. # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183 try: # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17". version_string = os.confstr("CS_GNU_LIBC_VERSION") assert version_string is not None _, version = version_string.split() except (AssertionError, AttributeError, OSError, ValueError): # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... return None return version def _glibc_version_string_ctypes() -> Optional[str]: """ Fallback implementation of glibc_version_string using ctypes. """ try: import ctypes except ImportError: return None # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen # manpage says, "If filename is NULL, then the returned handle is for the # main program". This way we can let the linker do the work to figure out # which libc our process is actually using. # # We must also handle the special case where the executable is not a # dynamically linked executable. This can occur when using musl libc, # for example. In this situation, dlopen() will error, leading to an # OSError. Interestingly, at least in the case of musl, there is no # errno set on the OSError. The single string argument used to construct # OSError comes from libc itself and is therefore not portable to # hard code here. In any case, failure to call dlopen() means we # can proceed, so we bail on our attempt. try: process_namespace = ctypes.CDLL(None) except OSError: return None try: gnu_get_libc_version = process_namespace.gnu_get_libc_version except AttributeError: # Symbol doesn't exist -> therefore, we are not linked to # glibc. return None # Call gnu_get_libc_version, which returns a string like "2.5" gnu_get_libc_version.restype = ctypes.c_char_p version_str: str = gnu_get_libc_version() # py2 / py3 compatibility: if not isinstance(version_str, str): version_str = version_str.decode("ascii") return version_str def _glibc_version_string() -> Optional[str]: """Returns glibc version string, or None if not using glibc.""" return _glibc_version_string_confstr() or _glibc_version_string_ctypes() def _parse_glibc_version(version_str: str) -> Tuple[int, int]: """Parse glibc version. We use a regexp instead of str.split because we want to discard any random junk that might come after the minor version -- this might happen in patched/forked versions of glibc (e.g. Linaro's version of glibc uses version strings like "2.20-2014.11"). See gh-3588. """ m = re.match(r"(?P[0-9]+)\.(?P[0-9]+)", version_str) if not m: warnings.warn( "Expected glibc version with 2 components major.minor," " got: %s" % version_str, RuntimeWarning, ) return -1, -1 return int(m.group("major")), int(m.group("minor")) @functools.lru_cache() def _get_glibc_version() -> Tuple[int, int]: version_str = _glibc_version_string() if version_str is None: return (-1, -1) return _parse_glibc_version(version_str) # From PEP 513, PEP 600 def _is_compatible(name: str, arch: str, version: _GLibCVersion) -> bool: sys_glibc = _get_glibc_version() if sys_glibc < version: return False # Check for presence of _manylinux module. try: import _manylinux # noqa except ImportError: return True if hasattr(_manylinux, "manylinux_compatible"): result = _manylinux.manylinux_compatible(version[0], version[1], arch) if result is not None: return bool(result) return True if version == _GLibCVersion(2, 5): if hasattr(_manylinux, "manylinux1_compatible"): return bool(_manylinux.manylinux1_compatible) if version == _GLibCVersion(2, 12): if hasattr(_manylinux, "manylinux2010_compatible"): return bool(_manylinux.manylinux2010_compatible) if version == _GLibCVersion(2, 17): if hasattr(_manylinux, "manylinux2014_compatible"): return bool(_manylinux.manylinux2014_compatible) return True _LEGACY_MANYLINUX_MAP = { # CentOS 7 w/ glibc 2.17 (PEP 599) (2, 17): "manylinux2014", # CentOS 6 w/ glibc 2.12 (PEP 571) (2, 12): "manylinux2010", # CentOS 5 w/ glibc 2.5 (PEP 513) (2, 5): "manylinux1", } def platform_tags(linux: str, arch: str) -> Iterator[str]: if not _have_compatible_abi(arch): return # Oldest glibc to be supported regardless of architecture is (2, 17). too_old_glibc2 = _GLibCVersion(2, 16) if arch in {"x86_64", "i686"}: # On x86/i686 also oldest glibc to be supported is (2, 5). too_old_glibc2 = _GLibCVersion(2, 4) current_glibc = _GLibCVersion(*_get_glibc_version()) glibc_max_list = [current_glibc] # We can assume compatibility across glibc major versions. # https://sourceware.org/bugzilla/show_bug.cgi?id=24636 # # Build a list of maximum glibc versions so that we can # output the canonical list of all glibc from current_glibc # down to too_old_glibc2, including all intermediary versions. for glibc_major in range(current_glibc.major - 1, 1, -1): glibc_minor = _LAST_GLIBC_MINOR[glibc_major] glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor)) for glibc_max in glibc_max_list: if glibc_max.major == too_old_glibc2.major: min_minor = too_old_glibc2.minor else: # For other glibc major versions oldest supported is (x, 0). min_minor = -1 for glibc_minor in range(glibc_max.minor, min_minor, -1): glibc_version = _GLibCVersion(glibc_max.major, glibc_minor) tag = "manylinux_{}_{}".format(*glibc_version) if _is_compatible(tag, arch, glibc_version): yield linux.replace("linux", tag) # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags. if glibc_version in _LEGACY_MANYLINUX_MAP: legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version] if _is_compatible(legacy_tag, arch, glibc_version): yield linux.replace("linux", legacy_tag) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/_musllinux.py0000644000175100001710000001043200000000000024400 0ustar00runnerdocker"""PEP 656 support. This module implements logic to detect if the currently running Python is linked against musl, and what musl version is used. """ import contextlib import functools import operator import os import re import struct import subprocess import sys from typing import IO, Iterator, NamedTuple, Optional, Tuple def _read_unpacked(f: IO[bytes], fmt: str) -> Tuple[int, ...]: return struct.unpack(fmt, f.read(struct.calcsize(fmt))) def _parse_ld_musl_from_elf(f: IO[bytes]) -> Optional[str]: """Detect musl libc location by parsing the Python executable. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html """ f.seek(0) try: ident = _read_unpacked(f, "16B") except struct.error: return None if ident[:4] != tuple(b"\x7fELF"): # Invalid magic, not ELF. return None f.seek(struct.calcsize("HHI"), 1) # Skip file type, machine, and version. try: # e_fmt: Format for program header. # p_fmt: Format for section header. # p_idx: Indexes to find p_type, p_offset, and p_filesz. e_fmt, p_fmt, p_idx = { 1: ("IIIIHHH", "IIIIIIII", (0, 1, 4)), # 32-bit. 2: ("QQQIHHH", "IIQQQQQQ", (0, 2, 5)), # 64-bit. }[ident[4]] except KeyError: return None else: p_get = operator.itemgetter(*p_idx) # Find the interpreter section and return its content. try: _, e_phoff, _, _, _, e_phentsize, e_phnum = _read_unpacked(f, e_fmt) except struct.error: return None for i in range(e_phnum + 1): f.seek(e_phoff + e_phentsize * i) try: p_type, p_offset, p_filesz = p_get(_read_unpacked(f, p_fmt)) except struct.error: return None if p_type != 3: # Not PT_INTERP. continue f.seek(p_offset) interpreter = os.fsdecode(f.read(p_filesz)).strip("\0") if "musl" not in interpreter: return None return interpreter return None class _MuslVersion(NamedTuple): major: int minor: int def _parse_musl_version(output: str) -> Optional[_MuslVersion]: lines = [n for n in (n.strip() for n in output.splitlines()) if n] if len(lines) < 2 or lines[0][:4] != "musl": return None m = re.match(r"Version (\d+)\.(\d+)", lines[1]) if not m: return None return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2))) @functools.lru_cache() def _get_musl_version(executable: str) -> Optional[_MuslVersion]: """Detect currently-running musl runtime version. This is done by checking the specified executable's dynamic linking information, and invoking the loader to parse its output for a version string. If the loader is musl, the output would be something like:: musl libc (x86_64) Version 1.2.2 Dynamic Program Loader """ with contextlib.ExitStack() as stack: try: f = stack.enter_context(open(executable, "rb")) except IOError: return None ld = _parse_ld_musl_from_elf(f) if not ld: return None proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True) return _parse_musl_version(proc.stderr) def platform_tags(arch: str) -> Iterator[str]: """Generate musllinux tags compatible to the current platform. :param arch: Should be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be musllinux-compatible. :returns: An iterator of compatible musllinux tags. """ sys_musl = _get_musl_version(sys.executable) if sys_musl is None: # Python not dynamically linked against musl. return for minor in range(sys_musl.minor, -1, -1): yield f"musllinux_{sys_musl.major}_{minor}_{arch}" if __name__ == "__main__": # pragma: no cover import sysconfig plat = sysconfig.get_platform() assert plat.startswith("linux-"), "not linux" print("plat:", plat) print("musl:", _get_musl_version(sys.executable)) print("tags:", end=" ") for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])): print(t, end="\n ") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/_structures.py0000644000175100001710000000313500000000000024565 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. class InfinityType: def __repr__(self) -> str: return "Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return False def __le__(self, other: object) -> bool: return False def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __ne__(self, other: object) -> bool: return not isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return True def __ge__(self, other: object) -> bool: return True def __neg__(self: object) -> "NegativeInfinityType": return NegativeInfinity Infinity = InfinityType() class NegativeInfinityType: def __repr__(self) -> str: return "-Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return True def __le__(self, other: object) -> bool: return True def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __ne__(self, other: object) -> bool: return not isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return False def __ge__(self, other: object) -> bool: return False def __neg__(self: object) -> InfinityType: return Infinity NegativeInfinity = NegativeInfinityType() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/markers.py0000644000175100001710000002046000000000000023647 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import operator import os import platform import sys from typing import Any, Callable, Dict, List, Optional, Tuple, Union from pkg_resources.extern.pyparsing import ( # noqa: N817 Forward, Group, Literal as L, ParseException, ParseResults, QuotedString, ZeroOrMore, stringEnd, stringStart, ) from .specifiers import InvalidSpecifier, Specifier __all__ = [ "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName", "Marker", "default_environment", ] Operator = Callable[[str, str], bool] class InvalidMarker(ValueError): """ An invalid marker was found, users should refer to PEP 508. """ class UndefinedComparison(ValueError): """ An invalid operation was attempted on a value that doesn't support it. """ class UndefinedEnvironmentName(ValueError): """ A name was attempted to be used that does not exist inside of the environment. """ class Node: def __init__(self, value: Any) -> None: self.value = value def __str__(self) -> str: return str(self.value) def __repr__(self) -> str: return f"<{self.__class__.__name__}('{self}')>" def serialize(self) -> str: raise NotImplementedError class Variable(Node): def serialize(self) -> str: return str(self) class Value(Node): def serialize(self) -> str: return f'"{self}"' class Op(Node): def serialize(self) -> str: return str(self) VARIABLE = ( L("implementation_version") | L("platform_python_implementation") | L("implementation_name") | L("python_full_version") | L("platform_release") | L("platform_version") | L("platform_machine") | L("platform_system") | L("python_version") | L("sys_platform") | L("os_name") | L("os.name") # PEP-345 | L("sys.platform") # PEP-345 | L("platform.version") # PEP-345 | L("platform.machine") # PEP-345 | L("platform.python_implementation") # PEP-345 | L("python_implementation") # undocumented setuptools legacy | L("extra") # PEP-508 ) ALIASES = { "os.name": "os_name", "sys.platform": "sys_platform", "platform.version": "platform_version", "platform.machine": "platform_machine", "platform.python_implementation": "platform_python_implementation", "python_implementation": "platform_python_implementation", } VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0]))) VERSION_CMP = ( L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<") ) MARKER_OP = VERSION_CMP | L("not in") | L("in") MARKER_OP.setParseAction(lambda s, l, t: Op(t[0])) MARKER_VALUE = QuotedString("'") | QuotedString('"') MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0])) BOOLOP = L("and") | L("or") MARKER_VAR = VARIABLE | MARKER_VALUE MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR) MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0])) LPAREN = L("(").suppress() RPAREN = L(")").suppress() MARKER_EXPR = Forward() MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN) MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR) MARKER = stringStart + MARKER_EXPR + stringEnd def _coerce_parse_result(results: Union[ParseResults, List[Any]]) -> List[Any]: if isinstance(results, ParseResults): return [_coerce_parse_result(i) for i in results] else: return results def _format_marker( marker: Union[List[str], Tuple[Node, ...], str], first: Optional[bool] = True ) -> str: assert isinstance(marker, (list, tuple, str)) # Sometimes we have a structure like [[...]] which is a single item list # where the single item is itself it's own list. In that case we want skip # the rest of this function so that we don't get extraneous () on the # outside. if ( isinstance(marker, list) and len(marker) == 1 and isinstance(marker[0], (list, tuple)) ): return _format_marker(marker[0]) if isinstance(marker, list): inner = (_format_marker(m, first=False) for m in marker) if first: return " ".join(inner) else: return "(" + " ".join(inner) + ")" elif isinstance(marker, tuple): return " ".join([m.serialize() for m in marker]) else: return marker _operators: Dict[str, Operator] = { "in": lambda lhs, rhs: lhs in rhs, "not in": lambda lhs, rhs: lhs not in rhs, "<": operator.lt, "<=": operator.le, "==": operator.eq, "!=": operator.ne, ">=": operator.ge, ">": operator.gt, } def _eval_op(lhs: str, op: Op, rhs: str) -> bool: try: spec = Specifier("".join([op.serialize(), rhs])) except InvalidSpecifier: pass else: return spec.contains(lhs) oper: Optional[Operator] = _operators.get(op.serialize()) if oper is None: raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") return oper(lhs, rhs) class Undefined: pass _undefined = Undefined() def _get_env(environment: Dict[str, str], name: str) -> str: value: Union[str, Undefined] = environment.get(name, _undefined) if isinstance(value, Undefined): raise UndefinedEnvironmentName( f"{name!r} does not exist in evaluation environment." ) return value def _evaluate_markers(markers: List[Any], environment: Dict[str, str]) -> bool: groups: List[List[bool]] = [[]] for marker in markers: assert isinstance(marker, (list, tuple, str)) if isinstance(marker, list): groups[-1].append(_evaluate_markers(marker, environment)) elif isinstance(marker, tuple): lhs, op, rhs = marker if isinstance(lhs, Variable): lhs_value = _get_env(environment, lhs.value) rhs_value = rhs.value else: lhs_value = lhs.value rhs_value = _get_env(environment, rhs.value) groups[-1].append(_eval_op(lhs_value, op, rhs_value)) else: assert marker in ["and", "or"] if marker == "or": groups.append([]) return any(all(item) for item in groups) def format_full_version(info: "sys._version_info") -> str: version = "{0.major}.{0.minor}.{0.micro}".format(info) kind = info.releaselevel if kind != "final": version += kind[0] + str(info.serial) return version def default_environment() -> Dict[str, str]: iver = format_full_version(sys.implementation.version) implementation_name = sys.implementation.name return { "implementation_name": implementation_name, "implementation_version": iver, "os_name": os.name, "platform_machine": platform.machine(), "platform_release": platform.release(), "platform_system": platform.system(), "platform_version": platform.version(), "python_full_version": platform.python_version(), "platform_python_implementation": platform.python_implementation(), "python_version": ".".join(platform.python_version_tuple()[:2]), "sys_platform": sys.platform, } class Marker: def __init__(self, marker: str) -> None: try: self._markers = _coerce_parse_result(MARKER.parseString(marker)) except ParseException as e: raise InvalidMarker( f"Invalid marker: {marker!r}, parse error at " f"{marker[e.loc : e.loc + 8]!r}" ) def __str__(self) -> str: return _format_marker(self._markers) def __repr__(self) -> str: return f"" def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool: """Evaluate a marker. Return the boolean from evaluating the given marker against the environment. environment is an optional argument to override all or part of the determined environment. The environment is determined from the current Python process. """ current_environment = default_environment() if environment is not None: current_environment.update(environment) return _evaluate_markers(self._markers, current_environment) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/requirements.py0000644000175100001710000001114200000000000024723 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import re import string import urllib.parse from typing import List, Optional as TOptional, Set from pkg_resources.extern.pyparsing import ( # noqa Combine, Literal as L, Optional, ParseException, Regex, Word, ZeroOrMore, originalTextFor, stringEnd, stringStart, ) from .markers import MARKER_EXPR, Marker from .specifiers import LegacySpecifier, Specifier, SpecifierSet class InvalidRequirement(ValueError): """ An invalid requirement was found, users should refer to PEP 508. """ ALPHANUM = Word(string.ascii_letters + string.digits) LBRACKET = L("[").suppress() RBRACKET = L("]").suppress() LPAREN = L("(").suppress() RPAREN = L(")").suppress() COMMA = L(",").suppress() SEMICOLON = L(";").suppress() AT = L("@").suppress() PUNCTUATION = Word("-_.") IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM) IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END)) NAME = IDENTIFIER("name") EXTRA = IDENTIFIER URI = Regex(r"[^ ]+")("url") URL = AT + URI EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA) EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras") VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE) VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE) VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY VERSION_MANY = Combine( VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False )("_raw_spec") _VERSION_SPEC = Optional((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY) _VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "") VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier") VERSION_SPEC.setParseAction(lambda s, l, t: t[1]) MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker") MARKER_EXPR.setParseAction( lambda s, l, t: Marker(s[t._original_start : t._original_end]) ) MARKER_SEPARATOR = SEMICOLON MARKER = MARKER_SEPARATOR + MARKER_EXPR VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER) URL_AND_MARKER = URL + Optional(MARKER) NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER) REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd # pkg_resources.extern.pyparsing isn't thread safe during initialization, so we do it eagerly, see # issue #104 REQUIREMENT.parseString("x[]") class Requirement: """Parse a requirement. Parse a given requirement string into its parts, such as name, specifier, URL, and extras. Raises InvalidRequirement on a badly-formed requirement string. """ # TODO: Can we test whether something is contained within a requirement? # If so how do we do that? Do we need to test against the _name_ of # the thing as well as the version? What about the markers? # TODO: Can we normalize the name and extra name? def __init__(self, requirement_string: str) -> None: try: req = REQUIREMENT.parseString(requirement_string) except ParseException as e: raise InvalidRequirement( f'Parse error at "{ requirement_string[e.loc : e.loc + 8]!r}": {e.msg}' ) self.name: str = req.name if req.url: parsed_url = urllib.parse.urlparse(req.url) if parsed_url.scheme == "file": if urllib.parse.urlunparse(parsed_url) != req.url: raise InvalidRequirement("Invalid URL given") elif not (parsed_url.scheme and parsed_url.netloc) or ( not parsed_url.scheme and not parsed_url.netloc ): raise InvalidRequirement(f"Invalid URL: {req.url}") self.url: TOptional[str] = req.url else: self.url = None self.extras: Set[str] = set(req.extras.asList() if req.extras else []) self.specifier: SpecifierSet = SpecifierSet(req.specifier) self.marker: TOptional[Marker] = req.marker if req.marker else None def __str__(self) -> str: parts: List[str] = [self.name] if self.extras: formatted_extras = ",".join(sorted(self.extras)) parts.append(f"[{formatted_extras}]") if self.specifier: parts.append(str(self.specifier)) if self.url: parts.append(f"@ {self.url}") if self.marker: parts.append(" ") if self.marker: parts.append(f"; {self.marker}") return "".join(parts) def __repr__(self) -> str: return f"" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/specifiers.py0000644000175100001710000007436400000000000024353 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc import functools import itertools import re import warnings from typing import ( Callable, Dict, Iterable, Iterator, List, Optional, Pattern, Set, Tuple, TypeVar, Union, ) from .utils import canonicalize_version from .version import LegacyVersion, Version, parse ParsedVersion = Union[Version, LegacyVersion] UnparsedVersion = Union[Version, LegacyVersion, str] VersionTypeVar = TypeVar("VersionTypeVar", bound=UnparsedVersion) CallableOperator = Callable[[ParsedVersion, str], bool] class InvalidSpecifier(ValueError): """ An invalid specifier was found, users should refer to PEP 440. """ class BaseSpecifier(metaclass=abc.ABCMeta): @abc.abstractmethod def __str__(self) -> str: """ Returns the str representation of this Specifier like object. This should be representative of the Specifier itself. """ @abc.abstractmethod def __hash__(self) -> int: """ Returns a hash value for this Specifier like object. """ @abc.abstractmethod def __eq__(self, other: object) -> bool: """ Returns a boolean representing whether or not the two Specifier like objects are equal. """ @abc.abstractmethod def __ne__(self, other: object) -> bool: """ Returns a boolean representing whether or not the two Specifier like objects are not equal. """ @abc.abstractproperty def prereleases(self) -> Optional[bool]: """ Returns whether or not pre-releases as a whole are allowed by this specifier. """ @prereleases.setter def prereleases(self, value: bool) -> None: """ Sets whether or not pre-releases as a whole are allowed by this specifier. """ @abc.abstractmethod def contains(self, item: str, prereleases: Optional[bool] = None) -> bool: """ Determines if the given item is contained within this specifier. """ @abc.abstractmethod def filter( self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None ) -> Iterable[VersionTypeVar]: """ Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. """ class _IndividualSpecifier(BaseSpecifier): _operators: Dict[str, str] = {} _regex: Pattern[str] def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None: match = self._regex.search(spec) if not match: raise InvalidSpecifier(f"Invalid specifier: '{spec}'") self._spec: Tuple[str, str] = ( match.group("operator").strip(), match.group("version").strip(), ) # Store whether or not this Specifier should accept prereleases self._prereleases = prereleases def __repr__(self) -> str: pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return "<{}({!r}{})>".format(self.__class__.__name__, str(self), pre) def __str__(self) -> str: return "{}{}".format(*self._spec) @property def _canonical_spec(self) -> Tuple[str, str]: return self._spec[0], canonicalize_version(self._spec[1]) def __hash__(self) -> int: return hash(self._canonical_spec) def __eq__(self, other: object) -> bool: if isinstance(other, str): try: other = self.__class__(str(other)) except InvalidSpecifier: return NotImplemented elif not isinstance(other, self.__class__): return NotImplemented return self._canonical_spec == other._canonical_spec def __ne__(self, other: object) -> bool: if isinstance(other, str): try: other = self.__class__(str(other)) except InvalidSpecifier: return NotImplemented elif not isinstance(other, self.__class__): return NotImplemented return self._spec != other._spec def _get_operator(self, op: str) -> CallableOperator: operator_callable: CallableOperator = getattr( self, f"_compare_{self._operators[op]}" ) return operator_callable def _coerce_version(self, version: UnparsedVersion) -> ParsedVersion: if not isinstance(version, (LegacyVersion, Version)): version = parse(version) return version @property def operator(self) -> str: return self._spec[0] @property def version(self) -> str: return self._spec[1] @property def prereleases(self) -> Optional[bool]: return self._prereleases @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value def __contains__(self, item: str) -> bool: return self.contains(item) def contains( self, item: UnparsedVersion, prereleases: Optional[bool] = None ) -> bool: # Determine if prereleases are to be allowed or not. if prereleases is None: prereleases = self.prereleases # Normalize item to a Version or LegacyVersion, this allows us to have # a shortcut for ``"2.0" in Specifier(">=2") normalized_item = self._coerce_version(item) # Determine if we should be supporting prereleases in this specifier # or not, if we do not support prereleases than we can short circuit # logic if this version is a prereleases. if normalized_item.is_prerelease and not prereleases: return False # Actually do the comparison to determine if this item is contained # within this Specifier or not. operator_callable: CallableOperator = self._get_operator(self.operator) return operator_callable(normalized_item, self.version) def filter( self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None ) -> Iterable[VersionTypeVar]: yielded = False found_prereleases = [] kw = {"prereleases": prereleases if prereleases is not None else True} # Attempt to iterate over all the values in the iterable and if any of # them match, yield them. for version in iterable: parsed_version = self._coerce_version(version) if self.contains(parsed_version, **kw): # If our version is a prerelease, and we were not set to allow # prereleases, then we'll store it for later in case nothing # else matches this specifier. if parsed_version.is_prerelease and not ( prereleases or self.prereleases ): found_prereleases.append(version) # Either this is not a prerelease, or we should have been # accepting prereleases from the beginning. else: yielded = True yield version # Now that we've iterated over everything, determine if we've yielded # any values, and if we have not and we have any prereleases stored up # then we will go ahead and yield the prereleases. if not yielded and found_prereleases: for version in found_prereleases: yield version class LegacySpecifier(_IndividualSpecifier): _regex_str = r""" (?P(==|!=|<=|>=|<|>)) \s* (?P [^,;\s)]* # Since this is a "legacy" specifier, and the version # string can be just about anything, we match everything # except for whitespace, a semi-colon for marker support, # a closing paren since versions can be enclosed in # them, and a comma since it's a version separator. ) """ _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE) _operators = { "==": "equal", "!=": "not_equal", "<=": "less_than_equal", ">=": "greater_than_equal", "<": "less_than", ">": "greater_than", } def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None: super().__init__(spec, prereleases) warnings.warn( "Creating a LegacyVersion has been deprecated and will be " "removed in the next major release", DeprecationWarning, ) def _coerce_version(self, version: UnparsedVersion) -> LegacyVersion: if not isinstance(version, LegacyVersion): version = LegacyVersion(str(version)) return version def _compare_equal(self, prospective: LegacyVersion, spec: str) -> bool: return prospective == self._coerce_version(spec) def _compare_not_equal(self, prospective: LegacyVersion, spec: str) -> bool: return prospective != self._coerce_version(spec) def _compare_less_than_equal(self, prospective: LegacyVersion, spec: str) -> bool: return prospective <= self._coerce_version(spec) def _compare_greater_than_equal( self, prospective: LegacyVersion, spec: str ) -> bool: return prospective >= self._coerce_version(spec) def _compare_less_than(self, prospective: LegacyVersion, spec: str) -> bool: return prospective < self._coerce_version(spec) def _compare_greater_than(self, prospective: LegacyVersion, spec: str) -> bool: return prospective > self._coerce_version(spec) def _require_version_compare( fn: Callable[["Specifier", ParsedVersion, str], bool] ) -> Callable[["Specifier", ParsedVersion, str], bool]: @functools.wraps(fn) def wrapped(self: "Specifier", prospective: ParsedVersion, spec: str) -> bool: if not isinstance(prospective, Version): return False return fn(self, prospective, spec) return wrapped class Specifier(_IndividualSpecifier): _regex_str = r""" (?P(~=|==|!=|<=|>=|<|>|===)) (?P (?: # The identity operators allow for an escape hatch that will # do an exact string match of the version you wish to install. # This will not be parsed by PEP 440 and we cannot determine # any semantic meaning from it. This operator is discouraged # but included entirely as an escape hatch. (?<====) # Only match for the identity operator \s* [^\s]* # We just match everything, except for whitespace # since we are only testing for strict identity. ) | (?: # The (non)equality operators allow for wild card and local # versions to be specified so we have to define these two # operators separately to enable that. (?<===|!=) # Only match for equals and not equals \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? # You cannot use a wild card and a dev or local version # together so group them with a | and make them optional. (?: (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local | \.\* # Wild card syntax of .* )? ) | (?: # The compatible operator requires at least two digits in the # release segment. (?<=~=) # Only match for the compatible operator \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) (?: # pre release [-_\.]? (a|b|c|rc|alpha|beta|pre|preview) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) | (?: # All other operators only allow a sub set of what the # (non)equality operators do. Specifically they do not allow # local versions to be specified nor do they allow the prefix # matching wild cards. (?=": "greater_than_equal", "<": "less_than", ">": "greater_than", "===": "arbitrary", } @_require_version_compare def _compare_compatible(self, prospective: ParsedVersion, spec: str) -> bool: # Compatible releases have an equivalent combination of >= and ==. That # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to # implement this in terms of the other specifiers instead of # implementing it ourselves. The only thing we need to do is construct # the other specifiers. # We want everything but the last item in the version, but we want to # ignore suffix segments. prefix = ".".join( list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1] ) # Add the prefix notation to the end of our string prefix += ".*" return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( prospective, prefix ) @_require_version_compare def _compare_equal(self, prospective: ParsedVersion, spec: str) -> bool: # We need special logic to handle prefix matching if spec.endswith(".*"): # In the case of prefix matching we want to ignore local segment. prospective = Version(prospective.public) # Split the spec out by dots, and pretend that there is an implicit # dot in between a release segment and a pre-release segment. split_spec = _version_split(spec[:-2]) # Remove the trailing .* # Split the prospective version out by dots, and pretend that there # is an implicit dot in between a release segment and a pre-release # segment. split_prospective = _version_split(str(prospective)) # Shorten the prospective version to be the same length as the spec # so that we can determine if the specifier is a prefix of the # prospective version or not. shortened_prospective = split_prospective[: len(split_spec)] # Pad out our two sides with zeros so that they both equal the same # length. padded_spec, padded_prospective = _pad_version( split_spec, shortened_prospective ) return padded_prospective == padded_spec else: # Convert our spec string into a Version spec_version = Version(spec) # If the specifier does not have a local segment, then we want to # act as if the prospective version also does not have a local # segment. if not spec_version.local: prospective = Version(prospective.public) return prospective == spec_version @_require_version_compare def _compare_not_equal(self, prospective: ParsedVersion, spec: str) -> bool: return not self._compare_equal(prospective, spec) @_require_version_compare def _compare_less_than_equal(self, prospective: ParsedVersion, spec: str) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) <= Version(spec) @_require_version_compare def _compare_greater_than_equal( self, prospective: ParsedVersion, spec: str ) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) >= Version(spec) @_require_version_compare def _compare_less_than(self, prospective: ParsedVersion, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is less than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective < spec: return False # This special case is here so that, unless the specifier itself # includes is a pre-release version, that we do not accept pre-release # versions for the version mentioned in the specifier (e.g. <3.1 should # not match 3.1.dev0, but should match 3.0.dev0). if not spec.is_prerelease and prospective.is_prerelease: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # less than the spec version *and* it's not a pre-release of the same # version in the spec. return True @_require_version_compare def _compare_greater_than(self, prospective: ParsedVersion, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is greater than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective > spec: return False # This special case is here so that, unless the specifier itself # includes is a post-release version, that we do not accept # post-release versions for the version mentioned in the specifier # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). if not spec.is_postrelease and prospective.is_postrelease: if Version(prospective.base_version) == Version(spec.base_version): return False # Ensure that we do not allow a local version of the version mentioned # in the specifier, which is technically greater than, to match. if prospective.local is not None: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # greater than the spec version *and* it's not a pre-release of the # same version in the spec. return True def _compare_arbitrary(self, prospective: Version, spec: str) -> bool: return str(prospective).lower() == str(spec).lower() @property def prereleases(self) -> bool: # If there is an explicit prereleases set for this, then we'll just # blindly use that. if self._prereleases is not None: return self._prereleases # Look at all of our specifiers and determine if they are inclusive # operators, and if they are if they are including an explicit # prerelease. operator, version = self._spec if operator in ["==", ">=", "<=", "~=", "==="]: # The == specifier can include a trailing .*, if it does we # want to remove before parsing. if operator == "==" and version.endswith(".*"): version = version[:-2] # Parse the version, and if it is a pre-release than this # specifier allows pre-releases. if parse(version).is_prerelease: return True return False @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value _prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") def _version_split(version: str) -> List[str]: result: List[str] = [] for item in version.split("."): match = _prefix_regex.search(item) if match: result.extend(match.groups()) else: result.append(item) return result def _is_not_suffix(segment: str) -> bool: return not any( segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post") ) def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]: left_split, right_split = [], [] # Get the release segment of our versions left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) # Get the rest of our versions left_split.append(left[len(left_split[0]) :]) right_split.append(right[len(right_split[0]) :]) # Insert our padding left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split))) class SpecifierSet(BaseSpecifier): def __init__( self, specifiers: str = "", prereleases: Optional[bool] = None ) -> None: # Split on , to break each individual specifier into it's own item, and # strip each item to remove leading/trailing whitespace. split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] # Parsed each individual specifier, attempting first to make it a # Specifier and falling back to a LegacySpecifier. parsed: Set[_IndividualSpecifier] = set() for specifier in split_specifiers: try: parsed.add(Specifier(specifier)) except InvalidSpecifier: parsed.add(LegacySpecifier(specifier)) # Turn our parsed specifiers into a frozen set and save them for later. self._specs = frozenset(parsed) # Store our prereleases value so we can use it later to determine if # we accept prereleases or not. self._prereleases = prereleases def __repr__(self) -> str: pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return "".format(str(self), pre) def __str__(self) -> str: return ",".join(sorted(str(s) for s in self._specs)) def __hash__(self) -> int: return hash(self._specs) def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet": if isinstance(other, str): other = SpecifierSet(other) elif not isinstance(other, SpecifierSet): return NotImplemented specifier = SpecifierSet() specifier._specs = frozenset(self._specs | other._specs) if self._prereleases is None and other._prereleases is not None: specifier._prereleases = other._prereleases elif self._prereleases is not None and other._prereleases is None: specifier._prereleases = self._prereleases elif self._prereleases == other._prereleases: specifier._prereleases = self._prereleases else: raise ValueError( "Cannot combine SpecifierSets with True and False prerelease " "overrides." ) return specifier def __eq__(self, other: object) -> bool: if isinstance(other, (str, _IndividualSpecifier)): other = SpecifierSet(str(other)) elif not isinstance(other, SpecifierSet): return NotImplemented return self._specs == other._specs def __ne__(self, other: object) -> bool: if isinstance(other, (str, _IndividualSpecifier)): other = SpecifierSet(str(other)) elif not isinstance(other, SpecifierSet): return NotImplemented return self._specs != other._specs def __len__(self) -> int: return len(self._specs) def __iter__(self) -> Iterator[_IndividualSpecifier]: return iter(self._specs) @property def prereleases(self) -> Optional[bool]: # If we have been given an explicit prerelease modifier, then we'll # pass that through here. if self._prereleases is not None: return self._prereleases # If we don't have any specifiers, and we don't have a forced value, # then we'll just return None since we don't know if this should have # pre-releases or not. if not self._specs: return None # Otherwise we'll see if any of the given specifiers accept # prereleases, if any of them do we'll return True, otherwise False. return any(s.prereleases for s in self._specs) @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value def __contains__(self, item: UnparsedVersion) -> bool: return self.contains(item) def contains( self, item: UnparsedVersion, prereleases: Optional[bool] = None ) -> bool: # Ensure that our item is a Version or LegacyVersion instance. if not isinstance(item, (LegacyVersion, Version)): item = parse(item) # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # We can determine if we're going to allow pre-releases by looking to # see if any of the underlying items supports them. If none of them do # and this item is a pre-release then we do not allow it and we can # short circuit that here. # Note: This means that 1.0.dev1 would not be contained in something # like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 if not prereleases and item.is_prerelease: return False # We simply dispatch to the underlying specs here to make sure that the # given version is contained within all of them. # Note: This use of all() here means that an empty set of specifiers # will always return True, this is an explicit design decision. return all(s.contains(item, prereleases=prereleases) for s in self._specs) def filter( self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None ) -> Iterable[VersionTypeVar]: # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # If we have any specifiers, then we want to wrap our iterable in the # filter method for each one, this will act as a logical AND amongst # each specifier. if self._specs: for spec in self._specs: iterable = spec.filter(iterable, prereleases=bool(prereleases)) return iterable # If we do not have any specifiers, then we need to have a rough filter # which will filter out any pre-releases, unless there are no final # releases, and which will filter out LegacyVersion in general. else: filtered: List[VersionTypeVar] = [] found_prereleases: List[VersionTypeVar] = [] item: UnparsedVersion parsed_version: Union[Version, LegacyVersion] for item in iterable: # Ensure that we some kind of Version class for this item. if not isinstance(item, (LegacyVersion, Version)): parsed_version = parse(item) else: parsed_version = item # Filter out any item which is parsed as a LegacyVersion if isinstance(parsed_version, LegacyVersion): continue # Store any item which is a pre-release for later unless we've # already found a final version or we are accepting prereleases if parsed_version.is_prerelease and not prereleases: if not filtered: found_prereleases.append(item) else: filtered.append(item) # If we've found no items except for pre-releases, then we'll go # ahead and use the pre-releases if not filtered and found_prereleases and prereleases is None: return found_prereleases return filtered ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/tags.py0000644000175100001710000003653600000000000023154 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import logging import platform import sys import sysconfig from importlib.machinery import EXTENSION_SUFFIXES from typing import ( Dict, FrozenSet, Iterable, Iterator, List, Optional, Sequence, Tuple, Union, cast, ) from . import _manylinux, _musllinux logger = logging.getLogger(__name__) PythonVersion = Sequence[int] MacVersion = Tuple[int, int] INTERPRETER_SHORT_NAMES: Dict[str, str] = { "python": "py", # Generic. "cpython": "cp", "pypy": "pp", "ironpython": "ip", "jython": "jy", } _32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32 class Tag: """ A representation of the tag triple for a wheel. Instances are considered immutable and thus are hashable. Equality checking is also supported. """ __slots__ = ["_interpreter", "_abi", "_platform", "_hash"] def __init__(self, interpreter: str, abi: str, platform: str) -> None: self._interpreter = interpreter.lower() self._abi = abi.lower() self._platform = platform.lower() # The __hash__ of every single element in a Set[Tag] will be evaluated each time # that a set calls its `.disjoint()` method, which may be called hundreds of # times when scanning a page of links for packages with tags matching that # Set[Tag]. Pre-computing the value here produces significant speedups for # downstream consumers. self._hash = hash((self._interpreter, self._abi, self._platform)) @property def interpreter(self) -> str: return self._interpreter @property def abi(self) -> str: return self._abi @property def platform(self) -> str: return self._platform def __eq__(self, other: object) -> bool: if not isinstance(other, Tag): return NotImplemented return ( (self._hash == other._hash) # Short-circuit ASAP for perf reasons. and (self._platform == other._platform) and (self._abi == other._abi) and (self._interpreter == other._interpreter) ) def __hash__(self) -> int: return self._hash def __str__(self) -> str: return f"{self._interpreter}-{self._abi}-{self._platform}" def __repr__(self) -> str: return "<{self} @ {self_id}>".format(self=self, self_id=id(self)) def parse_tag(tag: str) -> FrozenSet[Tag]: """ Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. Returning a set is required due to the possibility that the tag is a compressed tag set. """ tags = set() interpreters, abis, platforms = tag.split("-") for interpreter in interpreters.split("."): for abi in abis.split("."): for platform_ in platforms.split("."): tags.add(Tag(interpreter, abi, platform_)) return frozenset(tags) def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]: value = sysconfig.get_config_var(name) if value is None and warn: logger.debug( "Config variable '%s' is unset, Python ABI tag may be incorrect", name ) return value def _normalize_string(string: str) -> str: return string.replace(".", "_").replace("-", "_") def _abi3_applies(python_version: PythonVersion) -> bool: """ Determine if the Python version supports abi3. PEP 384 was first implemented in Python 3.2. """ return len(python_version) > 1 and tuple(python_version) >= (3, 2) def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]: py_version = tuple(py_version) # To allow for version comparison. abis = [] version = _version_nodot(py_version[:2]) debug = pymalloc = ucs4 = "" with_debug = _get_config_var("Py_DEBUG", warn) has_refcount = hasattr(sys, "gettotalrefcount") # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled # extension modules is the best option. # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 has_ext = "_d.pyd" in EXTENSION_SUFFIXES if with_debug or (with_debug is None and (has_refcount or has_ext)): debug = "d" if py_version < (3, 8): with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) if with_pymalloc or with_pymalloc is None: pymalloc = "m" if py_version < (3, 3): unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) if unicode_size == 4 or ( unicode_size is None and sys.maxunicode == 0x10FFFF ): ucs4 = "u" elif debug: # Debug builds can also load "normal" extension modules. # We can also assume no UCS-4 or pymalloc requirement. abis.append(f"cp{version}") abis.insert( 0, "cp{version}{debug}{pymalloc}{ucs4}".format( version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4 ), ) return abis def cpython_tags( python_version: Optional[PythonVersion] = None, abis: Optional[Iterable[str]] = None, platforms: Optional[Iterable[str]] = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a CPython interpreter. The tags consist of: - cp-- - cp-abi3- - cp-none- - cp-abi3- # Older Python versions down to 3.2. If python_version only specifies a major version then user-provided ABIs and the 'none' ABItag will be used. If 'abi3' or 'none' are specified in 'abis' then they will be yielded at their normal position and not at the beginning. """ if not python_version: python_version = sys.version_info[:2] interpreter = "cp{}".format(_version_nodot(python_version[:2])) if abis is None: if len(python_version) > 1: abis = _cpython_abis(python_version, warn) else: abis = [] abis = list(abis) # 'abi3' and 'none' are explicitly handled later. for explicit_abi in ("abi3", "none"): try: abis.remove(explicit_abi) except ValueError: pass platforms = list(platforms or platform_tags()) for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) if _abi3_applies(python_version): yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) if _abi3_applies(python_version): for minor_version in range(python_version[1] - 1, 1, -1): for platform_ in platforms: interpreter = "cp{version}".format( version=_version_nodot((python_version[0], minor_version)) ) yield Tag(interpreter, "abi3", platform_) def _generic_abi() -> Iterator[str]: abi = sysconfig.get_config_var("SOABI") if abi: yield _normalize_string(abi) def generic_tags( interpreter: Optional[str] = None, abis: Optional[Iterable[str]] = None, platforms: Optional[Iterable[str]] = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a generic interpreter. The tags consist of: - -- The "none" ABI will be added if it was not explicitly provided. """ if not interpreter: interp_name = interpreter_name() interp_version = interpreter_version(warn=warn) interpreter = "".join([interp_name, interp_version]) if abis is None: abis = _generic_abi() platforms = list(platforms or platform_tags()) abis = list(abis) if "none" not in abis: abis.append("none") for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: """ Yields Python versions in descending order. After the latest version, the major-only version will be yielded, and then all previous versions of that major version. """ if len(py_version) > 1: yield "py{version}".format(version=_version_nodot(py_version[:2])) yield "py{major}".format(major=py_version[0]) if len(py_version) > 1: for minor in range(py_version[1] - 1, -1, -1): yield "py{version}".format(version=_version_nodot((py_version[0], minor))) def compatible_tags( python_version: Optional[PythonVersion] = None, interpreter: Optional[str] = None, platforms: Optional[Iterable[str]] = None, ) -> Iterator[Tag]: """ Yields the sequence of tags that are compatible with a specific version of Python. The tags consist of: - py*-none- - -none-any # ... if `interpreter` is provided. - py*-none-any """ if not python_version: python_version = sys.version_info[:2] platforms = list(platforms or platform_tags()) for version in _py_interpreter_range(python_version): for platform_ in platforms: yield Tag(version, "none", platform_) if interpreter: yield Tag(interpreter, "none", "any") for version in _py_interpreter_range(python_version): yield Tag(version, "none", "any") def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: if not is_32bit: return arch if arch.startswith("ppc"): return "ppc" return "i386" def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]: formats = [cpu_arch] if cpu_arch == "x86_64": if version < (10, 4): return [] formats.extend(["intel", "fat64", "fat32"]) elif cpu_arch == "i386": if version < (10, 4): return [] formats.extend(["intel", "fat32", "fat"]) elif cpu_arch == "ppc64": # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? if version > (10, 5) or version < (10, 4): return [] formats.append("fat64") elif cpu_arch == "ppc": if version > (10, 6): return [] formats.extend(["fat32", "fat"]) if cpu_arch in {"arm64", "x86_64"}: formats.append("universal2") if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: formats.append("universal") return formats def mac_platforms( version: Optional[MacVersion] = None, arch: Optional[str] = None ) -> Iterator[str]: """ Yields the platform tags for a macOS system. The `version` parameter is a two-item tuple specifying the macOS version to generate platform tags for. The `arch` parameter is the CPU architecture to generate platform tags for. Both parameters default to the appropriate value for the current system. """ version_str, _, cpu_arch = platform.mac_ver() if version is None: version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2]))) else: version = version if arch is None: arch = _mac_arch(cpu_arch) else: arch = arch if (10, 0) <= version and version < (11, 0): # Prior to Mac OS 11, each yearly release of Mac OS bumped the # "minor" version number. The major version was always 10. for minor_version in range(version[1], -1, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=10, minor=minor_version, binary_format=binary_format ) if version >= (11, 0): # Starting with Mac OS 11, each yearly release bumps the major version # number. The minor versions are now the midyear updates. for major_version in range(version[0], 10, -1): compat_version = major_version, 0 binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=major_version, minor=0, binary_format=binary_format ) if version >= (11, 0): # Mac OS 11 on x86_64 is compatible with binaries from previous releases. # Arm64 support was introduced in 11.0, so no Arm binaries from previous # releases exist. # # However, the "universal2" binary format can have a # macOS version earlier than 11.0 when the x86_64 part of the binary supports # that version of macOS. if arch == "x86_64": for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) else: for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_format = "universal2" yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: linux = _normalize_string(sysconfig.get_platform()) if is_32bit: if linux == "linux_x86_64": linux = "linux_i686" elif linux == "linux_aarch64": linux = "linux_armv7l" _, arch = linux.split("_", 1) yield from _manylinux.platform_tags(linux, arch) yield from _musllinux.platform_tags(arch) yield linux def _generic_platforms() -> Iterator[str]: yield _normalize_string(sysconfig.get_platform()) def platform_tags() -> Iterator[str]: """ Provides the platform tags for this installation. """ if platform.system() == "Darwin": return mac_platforms() elif platform.system() == "Linux": return _linux_platforms() else: return _generic_platforms() def interpreter_name() -> str: """ Returns the name of the running interpreter. """ name = sys.implementation.name return INTERPRETER_SHORT_NAMES.get(name) or name def interpreter_version(*, warn: bool = False) -> str: """ Returns the version of the running interpreter. """ version = _get_config_var("py_version_nodot", warn=warn) if version: version = str(version) else: version = _version_nodot(sys.version_info[:2]) return version def _version_nodot(version: PythonVersion) -> str: return "".join(map(str, version)) def sys_tags(*, warn: bool = False) -> Iterator[Tag]: """ Returns the sequence of tag triples for the running interpreter. The order of the sequence corresponds to priority order for the interpreter, from most to least important. """ interp_name = interpreter_name() if interp_name == "cp": yield from cpython_tags(warn=warn) else: yield from generic_tags() yield from compatible_tags() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/utils.py0000644000175100001710000001015000000000000023336 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import re from typing import FrozenSet, NewType, Tuple, Union, cast from .tags import Tag, parse_tag from .version import InvalidVersion, Version BuildTag = Union[Tuple[()], Tuple[int, str]] NormalizedName = NewType("NormalizedName", str) class InvalidWheelFilename(ValueError): """ An invalid wheel filename was found, users should refer to PEP 427. """ class InvalidSdistFilename(ValueError): """ An invalid sdist filename was found, users should refer to the packaging user guide. """ _canonicalize_regex = re.compile(r"[-_.]+") # PEP 427: The build number must start with a digit. _build_tag_regex = re.compile(r"(\d+)(.*)") def canonicalize_name(name: str) -> NormalizedName: # This is taken from PEP 503. value = _canonicalize_regex.sub("-", name).lower() return cast(NormalizedName, value) def canonicalize_version(version: Union[Version, str]) -> str: """ This is very similar to Version.__str__, but has one subtle difference with the way it handles the release segment. """ if isinstance(version, str): try: parsed = Version(version) except InvalidVersion: # Legacy versions cannot be normalized return version else: parsed = version parts = [] # Epoch if parsed.epoch != 0: parts.append(f"{parsed.epoch}!") # Release segment # NB: This strips trailing '.0's to normalize parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in parsed.release))) # Pre-release if parsed.pre is not None: parts.append("".join(str(x) for x in parsed.pre)) # Post-release if parsed.post is not None: parts.append(f".post{parsed.post}") # Development release if parsed.dev is not None: parts.append(f".dev{parsed.dev}") # Local version segment if parsed.local is not None: parts.append(f"+{parsed.local}") return "".join(parts) def parse_wheel_filename( filename: str, ) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]: if not filename.endswith(".whl"): raise InvalidWheelFilename( f"Invalid wheel filename (extension must be '.whl'): {filename}" ) filename = filename[:-4] dashes = filename.count("-") if dashes not in (4, 5): raise InvalidWheelFilename( f"Invalid wheel filename (wrong number of parts): {filename}" ) parts = filename.split("-", dashes - 2) name_part = parts[0] # See PEP 427 for the rules on escaping the project name if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: raise InvalidWheelFilename(f"Invalid project name: {filename}") name = canonicalize_name(name_part) version = Version(parts[1]) if dashes == 5: build_part = parts[2] build_match = _build_tag_regex.match(build_part) if build_match is None: raise InvalidWheelFilename( f"Invalid build number: {build_part} in '{filename}'" ) build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2))) else: build = () tags = parse_tag(parts[-1]) return (name, version, build, tags) def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]: if filename.endswith(".tar.gz"): file_stem = filename[: -len(".tar.gz")] elif filename.endswith(".zip"): file_stem = filename[: -len(".zip")] else: raise InvalidSdistFilename( f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" f" {filename}" ) # We are requiring a PEP 440 version, which cannot contain dashes, # so we split on the last dash. name_part, sep, version_part = file_stem.rpartition("-") if not sep: raise InvalidSdistFilename(f"Invalid sdist filename: {filename}") name = canonicalize_name(name_part) version = Version(version_part) return (name, version) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0 setuptools-59.6.0/pkg_resources/_vendor/packaging/version.py0000644000175100001710000003451100000000000023672 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import collections import itertools import re import warnings from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType __all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"] InfiniteTypes = Union[InfinityType, NegativeInfinityType] PrePostDevType = Union[InfiniteTypes, Tuple[str, int]] SubLocalType = Union[InfiniteTypes, int, str] LocalType = Union[ NegativeInfinityType, Tuple[ Union[ SubLocalType, Tuple[SubLocalType, str], Tuple[NegativeInfinityType, SubLocalType], ], ..., ], ] CmpKey = Tuple[ int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType ] LegacyCmpKey = Tuple[int, Tuple[str, ...]] VersionComparisonMethod = Callable[ [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool ] _Version = collections.namedtuple( "_Version", ["epoch", "release", "dev", "pre", "post", "local"] ) def parse(version: str) -> Union["LegacyVersion", "Version"]: """ Parse the given version string and return either a :class:`Version` object or a :class:`LegacyVersion` object depending on if the given version is a valid PEP 440 version or a legacy version. """ try: return Version(version) except InvalidVersion: return LegacyVersion(version) class InvalidVersion(ValueError): """ An invalid version was found, users should refer to PEP 440. """ class _BaseVersion: _key: Union[CmpKey, LegacyCmpKey] def __hash__(self) -> int: return hash(self._key) # Please keep the duplicated `isinstance` check # in the six comparisons hereunder # unless you find a way to avoid adding overhead function calls. def __lt__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key < other._key def __le__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key <= other._key def __eq__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key == other._key def __ge__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key >= other._key def __gt__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key > other._key def __ne__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key != other._key class LegacyVersion(_BaseVersion): def __init__(self, version: str) -> None: self._version = str(version) self._key = _legacy_cmpkey(self._version) warnings.warn( "Creating a LegacyVersion has been deprecated and will be " "removed in the next major release", DeprecationWarning, ) def __str__(self) -> str: return self._version def __repr__(self) -> str: return f"" @property def public(self) -> str: return self._version @property def base_version(self) -> str: return self._version @property def epoch(self) -> int: return -1 @property def release(self) -> None: return None @property def pre(self) -> None: return None @property def post(self) -> None: return None @property def dev(self) -> None: return None @property def local(self) -> None: return None @property def is_prerelease(self) -> bool: return False @property def is_postrelease(self) -> bool: return False @property def is_devrelease(self) -> bool: return False _legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE) _legacy_version_replacement_map = { "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@", } def _parse_version_parts(s: str) -> Iterator[str]: for part in _legacy_version_component_re.split(s): part = _legacy_version_replacement_map.get(part, part) if not part or part == ".": continue if part[:1] in "0123456789": # pad for numeric comparison yield part.zfill(8) else: yield "*" + part # ensure that alpha/beta/candidate are before final yield "*final" def _legacy_cmpkey(version: str) -> LegacyCmpKey: # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch # greater than or equal to 0. This will effectively put the LegacyVersion, # which uses the defacto standard originally implemented by setuptools, # as before all PEP 440 versions. epoch = -1 # This scheme is taken from pkg_resources.parse_version setuptools prior to # it's adoption of the packaging library. parts: List[str] = [] for part in _parse_version_parts(version.lower()): if part.startswith("*"): # remove "-" before a prerelease tag if part < "*final": while parts and parts[-1] == "*final-": parts.pop() # remove trailing zeros from each series of numeric parts while parts and parts[-1] == "00000000": parts.pop() parts.append(part) return epoch, tuple(parts) # Deliberately not anchored to the start and end of the string, to make it # easier for 3rd party code to reuse VERSION_PATTERN = r""" v? (?: (?:(?P[0-9]+)!)? # epoch (?P[0-9]+(?:\.[0-9]+)*) # release segment (?P
                                          # pre-release
            [-_\.]?
            (?P(a|b|c|rc|alpha|beta|pre|preview))
            [-_\.]?
            (?P[0-9]+)?
        )?
        (?P                                         # post release
            (?:-(?P[0-9]+))
            |
            (?:
                [-_\.]?
                (?Ppost|rev|r)
                [-_\.]?
                (?P[0-9]+)?
            )
        )?
        (?P                                          # dev release
            [-_\.]?
            (?Pdev)
            [-_\.]?
            (?P[0-9]+)?
        )?
    )
    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
"""


class Version(_BaseVersion):

    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)

    def __init__(self, version: str) -> None:

        # Validate the version and parse it into pieces
        match = self._regex.search(version)
        if not match:
            raise InvalidVersion(f"Invalid version: '{version}'")

        # Store the parsed out pieces of the version
        self._version = _Version(
            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
            release=tuple(int(i) for i in match.group("release").split(".")),
            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
            post=_parse_letter_version(
                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
            ),
            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
            local=_parse_local_version(match.group("local")),
        )

        # Generate a key which will be used for sorting
        self._key = _cmpkey(
            self._version.epoch,
            self._version.release,
            self._version.pre,
            self._version.post,
            self._version.dev,
            self._version.local,
        )

    def __repr__(self) -> str:
        return f""

    def __str__(self) -> str:
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        # Pre-release
        if self.pre is not None:
            parts.append("".join(str(x) for x in self.pre))

        # Post-release
        if self.post is not None:
            parts.append(f".post{self.post}")

        # Development release
        if self.dev is not None:
            parts.append(f".dev{self.dev}")

        # Local version segment
        if self.local is not None:
            parts.append(f"+{self.local}")

        return "".join(parts)

    @property
    def epoch(self) -> int:
        _epoch: int = self._version.epoch
        return _epoch

    @property
    def release(self) -> Tuple[int, ...]:
        _release: Tuple[int, ...] = self._version.release
        return _release

    @property
    def pre(self) -> Optional[Tuple[str, int]]:
        _pre: Optional[Tuple[str, int]] = self._version.pre
        return _pre

    @property
    def post(self) -> Optional[int]:
        return self._version.post[1] if self._version.post else None

    @property
    def dev(self) -> Optional[int]:
        return self._version.dev[1] if self._version.dev else None

    @property
    def local(self) -> Optional[str]:
        if self._version.local:
            return ".".join(str(x) for x in self._version.local)
        else:
            return None

    @property
    def public(self) -> str:
        return str(self).split("+", 1)[0]

    @property
    def base_version(self) -> str:
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        return "".join(parts)

    @property
    def is_prerelease(self) -> bool:
        return self.dev is not None or self.pre is not None

    @property
    def is_postrelease(self) -> bool:
        return self.post is not None

    @property
    def is_devrelease(self) -> bool:
        return self.dev is not None

    @property
    def major(self) -> int:
        return self.release[0] if len(self.release) >= 1 else 0

    @property
    def minor(self) -> int:
        return self.release[1] if len(self.release) >= 2 else 0

    @property
    def micro(self) -> int:
        return self.release[2] if len(self.release) >= 3 else 0


def _parse_letter_version(
    letter: str, number: Union[str, bytes, SupportsInt]
) -> Optional[Tuple[str, int]]:

    if letter:
        # We consider there to be an implicit 0 in a pre-release if there is
        # not a numeral associated with it.
        if number is None:
            number = 0

        # We normalize any letters to their lower case form
        letter = letter.lower()

        # We consider some words to be alternate spellings of other words and
        # in those cases we want to normalize the spellings to our preferred
        # spelling.
        if letter == "alpha":
            letter = "a"
        elif letter == "beta":
            letter = "b"
        elif letter in ["c", "pre", "preview"]:
            letter = "rc"
        elif letter in ["rev", "r"]:
            letter = "post"

        return letter, int(number)
    if not letter and number:
        # We assume if we are given a number, but we are not given a letter
        # then this is using the implicit post release syntax (e.g. 1.0-1)
        letter = "post"

        return letter, int(number)

    return None


_local_version_separators = re.compile(r"[\._-]")


def _parse_local_version(local: str) -> Optional[LocalType]:
    """
    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
    """
    if local is not None:
        return tuple(
            part.lower() if not part.isdigit() else int(part)
            for part in _local_version_separators.split(local)
        )
    return None


def _cmpkey(
    epoch: int,
    release: Tuple[int, ...],
    pre: Optional[Tuple[str, int]],
    post: Optional[Tuple[str, int]],
    dev: Optional[Tuple[str, int]],
    local: Optional[Tuple[SubLocalType]],
) -> CmpKey:

    # When we compare a release version, we want to compare it with all of the
    # trailing zeros removed. So we'll use a reverse the list, drop all the now
    # leading zeros until we come to something non zero, then take the rest
    # re-reverse it back into the correct order and make it a tuple and use
    # that for our sorting key.
    _release = tuple(
        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
    )

    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
    # We'll do this by abusing the pre segment, but we _only_ want to do this
    # if there is not a pre or a post segment. If we have one of those then
    # the normal sorting rules will handle this case correctly.
    if pre is None and post is None and dev is not None:
        _pre: PrePostDevType = NegativeInfinity
    # Versions without a pre-release (except as noted above) should sort after
    # those with one.
    elif pre is None:
        _pre = Infinity
    else:
        _pre = pre

    # Versions without a post segment should sort before those with one.
    if post is None:
        _post: PrePostDevType = NegativeInfinity

    else:
        _post = post

    # Versions without a development segment should sort after those with one.
    if dev is None:
        _dev: PrePostDevType = Infinity

    else:
        _dev = dev

    if local is None:
        # Versions without a local segment should sort before those with one.
        _local: LocalType = NegativeInfinity
    else:
        # Versions with a local segment need that segment parsed to implement
        # the sorting rules in PEP440.
        # - Alpha numeric segments sort before numeric segments
        # - Alpha numeric segments sort lexicographically
        # - Numeric segments sort numerically
        # - Shorter versions sort before longer versions when the prefixes
        #   match exactly
        _local = tuple(
            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
        )

    return epoch, _release, _pre, _post, _dev, _local
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/_vendor/pyparsing.py0000644000175100001710000070516700000000000022311 0ustar00runnerdocker# module pyparsing.py
#
# Copyright (c) 2003-2018  Paul T. McGuire
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#

__doc__ = \
"""
pyparsing module - Classes and methods to define and execute parsing grammars
=============================================================================

The pyparsing module is an alternative approach to creating and executing simple grammars,
vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
provides a library of classes that you use to construct the grammar directly in Python.

Here is a program to parse "Hello, World!" (or any greeting of the form 
C{", !"}), built up using L{Word}, L{Literal}, and L{And} elements 
(L{'+'} operator gives L{And} expressions, strings are auto-converted to
L{Literal} expressions)::

    from pyparsing import Word, alphas

    # define grammar of a greeting
    greet = Word(alphas) + "," + Word(alphas) + "!"

    hello = "Hello, World!"
    print (hello, "->", greet.parseString(hello))

The program outputs the following::

    Hello, World! -> ['Hello', ',', 'World', '!']

The Python representation of the grammar is quite readable, owing to the self-explanatory
class names, and the use of '+', '|' and '^' operators.

The L{ParseResults} object returned from L{ParserElement.parseString} can be accessed as a nested list, a dictionary, or an
object with named attributes.

The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
 - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
 - quoted strings
 - embedded comments


Getting Started -
-----------------
Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing
classes inherit from. Use the docstrings for examples of how to:
 - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes
 - construct character word-group expressions using the L{Word} class
 - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
 - use L{'+'}, L{'|'}, L{'^'}, and L{'&'} operators to combine simple expressions into more complex ones
 - associate names with your parsed results using L{ParserElement.setResultsName}
 - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
 - find more useful common expressions in the L{pyparsing_common} namespace class
"""

__version__ = "2.2.1"
__versionTime__ = "18 Sep 2018 00:49 UTC"
__author__ = "Paul McGuire "

import string
from weakref import ref as wkref
import copy
import sys
import warnings
import re
import sre_constants
import collections
import pprint
import traceback
import types
from datetime import datetime

try:
    from _thread import RLock
except ImportError:
    from threading import RLock

try:
    # Python 3
    from collections.abc import Iterable
    from collections.abc import MutableMapping
except ImportError:
    # Python 2.7
    from collections import Iterable
    from collections import MutableMapping

try:
    from collections import OrderedDict as _OrderedDict
except ImportError:
    try:
        from ordereddict import OrderedDict as _OrderedDict
    except ImportError:
        _OrderedDict = None

#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )

__all__ = [
'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 
'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',
'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 
'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',
'CloseMatch', 'tokenMap', 'pyparsing_common',
]

system_version = tuple(sys.version_info)[:3]
PY_3 = system_version[0] == 3
if PY_3:
    _MAX_INT = sys.maxsize
    basestring = str
    unichr = chr
    _ustr = str

    # build list of single arg builtins, that can be used as parse actions
    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]

else:
    _MAX_INT = sys.maxint
    range = xrange

    def _ustr(obj):
        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
           then < returns the unicode object | encodes it with the default encoding | ... >.
        """
        if isinstance(obj,unicode):
            return obj

        try:
            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
            # it won't break any existing code.
            return str(obj)

        except UnicodeEncodeError:
            # Else encode it
            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')
            xmlcharref = Regex(r'&#\d+;')
            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])
            return xmlcharref.transformString(ret)

    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions
    singleArgBuiltins = []
    import __builtin__
    for fname in "sum len sorted reversed list tuple set any all min max".split():
        try:
            singleArgBuiltins.append(getattr(__builtin__,fname))
        except AttributeError:
            continue
            
_generatorType = type((y for y in range(1)))
 
def _xml_escape(data):
    """Escape &, <, >, ", ', etc. in a string of data."""

    # ampersand must be replaced first
    from_symbols = '&><"\''
    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())
    for from_,to_ in zip(from_symbols, to_symbols):
        data = data.replace(from_, to_)
    return data

class _Constants(object):
    pass

alphas     = string.ascii_uppercase + string.ascii_lowercase
nums       = "0123456789"
hexnums    = nums + "ABCDEFabcdef"
alphanums  = alphas + nums
_bslash    = chr(92)
printables = "".join(c for c in string.printable if c not in string.whitespace)

class ParseBaseException(Exception):
    """base exception class for all parsing runtime exceptions"""
    # Performance tuning: we construct a *lot* of these, so keep this
    # constructor as small and fast as possible
    def __init__( self, pstr, loc=0, msg=None, elem=None ):
        self.loc = loc
        if msg is None:
            self.msg = pstr
            self.pstr = ""
        else:
            self.msg = msg
            self.pstr = pstr
        self.parserElement = elem
        self.args = (pstr, loc, msg)

    @classmethod
    def _from_exception(cls, pe):
        """
        internal factory method to simplify creating one type of ParseException 
        from another - avoids having __init__ signature conflicts among subclasses
        """
        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)

    def __getattr__( self, aname ):
        """supported attributes by name are:
            - lineno - returns the line number of the exception text
            - col - returns the column number of the exception text
            - line - returns the line containing the exception text
        """
        if( aname == "lineno" ):
            return lineno( self.loc, self.pstr )
        elif( aname in ("col", "column") ):
            return col( self.loc, self.pstr )
        elif( aname == "line" ):
            return line( self.loc, self.pstr )
        else:
            raise AttributeError(aname)

    def __str__( self ):
        return "%s (at char %d), (line:%d, col:%d)" % \
                ( self.msg, self.loc, self.lineno, self.column )
    def __repr__( self ):
        return _ustr(self)
    def markInputline( self, markerString = ">!<" ):
        """Extracts the exception line from the input string, and marks
           the location of the exception with a special symbol.
        """
        line_str = self.line
        line_column = self.column - 1
        if markerString:
            line_str = "".join((line_str[:line_column],
                                markerString, line_str[line_column:]))
        return line_str.strip()
    def __dir__(self):
        return "lineno col line".split() + dir(type(self))

class ParseException(ParseBaseException):
    """
    Exception thrown when parse expressions don't match class;
    supported attributes by name are:
     - lineno - returns the line number of the exception text
     - col - returns the column number of the exception text
     - line - returns the line containing the exception text
        
    Example::
        try:
            Word(nums).setName("integer").parseString("ABC")
        except ParseException as pe:
            print(pe)
            print("column: {}".format(pe.col))
            
    prints::
       Expected integer (at char 0), (line:1, col:1)
        column: 1
    """
    pass

class ParseFatalException(ParseBaseException):
    """user-throwable exception thrown when inconsistent parse content
       is found; stops all parsing immediately"""
    pass

class ParseSyntaxException(ParseFatalException):
    """just like L{ParseFatalException}, but thrown internally when an
       L{ErrorStop} ('-' operator) indicates that parsing is to stop 
       immediately because an unbacktrackable syntax error has been found"""
    pass

#~ class ReparseException(ParseBaseException):
    #~ """Experimental class - parse actions can raise this exception to cause
       #~ pyparsing to reparse the input string:
        #~ - with a modified input string, and/or
        #~ - with a modified start location
       #~ Set the values of the ReparseException in the constructor, and raise the
       #~ exception in a parse action to cause pyparsing to use the new string/location.
       #~ Setting the values as None causes no change to be made.
       #~ """
    #~ def __init_( self, newstring, restartLoc ):
        #~ self.newParseText = newstring
        #~ self.reparseLoc = restartLoc

class RecursiveGrammarException(Exception):
    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""
    def __init__( self, parseElementList ):
        self.parseElementTrace = parseElementList

    def __str__( self ):
        return "RecursiveGrammarException: %s" % self.parseElementTrace

class _ParseResultsWithOffset(object):
    def __init__(self,p1,p2):
        self.tup = (p1,p2)
    def __getitem__(self,i):
        return self.tup[i]
    def __repr__(self):
        return repr(self.tup[0])
    def setOffset(self,i):
        self.tup = (self.tup[0],i)

class ParseResults(object):
    """
    Structured parse results, to provide multiple means of access to the parsed data:
       - as a list (C{len(results)})
       - by list index (C{results[0], results[1]}, etc.)
       - by attribute (C{results.} - see L{ParserElement.setResultsName})

    Example::
        integer = Word(nums)
        date_str = (integer.setResultsName("year") + '/' 
                        + integer.setResultsName("month") + '/' 
                        + integer.setResultsName("day"))
        # equivalent form:
        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

        # parseString returns a ParseResults object
        result = date_str.parseString("1999/12/31")

        def test(s, fn=repr):
            print("%s -> %s" % (s, fn(eval(s))))
        test("list(result)")
        test("result[0]")
        test("result['month']")
        test("result.day")
        test("'month' in result")
        test("'minutes' in result")
        test("result.dump()", str)
    prints::
        list(result) -> ['1999', '/', '12', '/', '31']
        result[0] -> '1999'
        result['month'] -> '12'
        result.day -> '31'
        'month' in result -> True
        'minutes' in result -> False
        result.dump() -> ['1999', '/', '12', '/', '31']
        - day: 31
        - month: 12
        - year: 1999
    """
    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):
        if isinstance(toklist, cls):
            return toklist
        retobj = object.__new__(cls)
        retobj.__doinit = True
        return retobj

    # Performance tuning: we construct a *lot* of these, so keep this
    # constructor as small and fast as possible
    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):
        if self.__doinit:
            self.__doinit = False
            self.__name = None
            self.__parent = None
            self.__accumNames = {}
            self.__asList = asList
            self.__modal = modal
            if toklist is None:
                toklist = []
            if isinstance(toklist, list):
                self.__toklist = toklist[:]
            elif isinstance(toklist, _generatorType):
                self.__toklist = list(toklist)
            else:
                self.__toklist = [toklist]
            self.__tokdict = dict()

        if name is not None and name:
            if not modal:
                self.__accumNames[name] = 0
            if isinstance(name,int):
                name = _ustr(name) # will always return a str, but use _ustr for consistency
            self.__name = name
            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):
                if isinstance(toklist,basestring):
                    toklist = [ toklist ]
                if asList:
                    if isinstance(toklist,ParseResults):
                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)
                    else:
                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
                    self[name].__name = name
                else:
                    try:
                        self[name] = toklist[0]
                    except (KeyError,TypeError,IndexError):
                        self[name] = toklist

    def __getitem__( self, i ):
        if isinstance( i, (int,slice) ):
            return self.__toklist[i]
        else:
            if i not in self.__accumNames:
                return self.__tokdict[i][-1][0]
            else:
                return ParseResults([ v[0] for v in self.__tokdict[i] ])

    def __setitem__( self, k, v, isinstance=isinstance ):
        if isinstance(v,_ParseResultsWithOffset):
            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
            sub = v[0]
        elif isinstance(k,(int,slice)):
            self.__toklist[k] = v
            sub = v
        else:
            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
            sub = v
        if isinstance(sub,ParseResults):
            sub.__parent = wkref(self)

    def __delitem__( self, i ):
        if isinstance(i,(int,slice)):
            mylen = len( self.__toklist )
            del self.__toklist[i]

            # convert int to slice
            if isinstance(i, int):
                if i < 0:
                    i += mylen
                i = slice(i, i+1)
            # get removed indices
            removed = list(range(*i.indices(mylen)))
            removed.reverse()
            # fixup indices in token dictionary
            for name,occurrences in self.__tokdict.items():
                for j in removed:
                    for k, (value, position) in enumerate(occurrences):
                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
        else:
            del self.__tokdict[i]

    def __contains__( self, k ):
        return k in self.__tokdict

    def __len__( self ): return len( self.__toklist )
    def __bool__(self): return ( not not self.__toklist )
    __nonzero__ = __bool__
    def __iter__( self ): return iter( self.__toklist )
    def __reversed__( self ): return iter( self.__toklist[::-1] )
    def _iterkeys( self ):
        if hasattr(self.__tokdict, "iterkeys"):
            return self.__tokdict.iterkeys()
        else:
            return iter(self.__tokdict)

    def _itervalues( self ):
        return (self[k] for k in self._iterkeys())
            
    def _iteritems( self ):
        return ((k, self[k]) for k in self._iterkeys())

    if PY_3:
        keys = _iterkeys       
        """Returns an iterator of all named result keys (Python 3.x only)."""

        values = _itervalues
        """Returns an iterator of all named result values (Python 3.x only)."""

        items = _iteritems
        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""

    else:
        iterkeys = _iterkeys
        """Returns an iterator of all named result keys (Python 2.x only)."""

        itervalues = _itervalues
        """Returns an iterator of all named result values (Python 2.x only)."""

        iteritems = _iteritems
        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""

        def keys( self ):
            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""
            return list(self.iterkeys())

        def values( self ):
            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""
            return list(self.itervalues())
                
        def items( self ):
            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""
            return list(self.iteritems())

    def haskeys( self ):
        """Since keys() returns an iterator, this method is helpful in bypassing
           code that looks for the existence of any defined results names."""
        return bool(self.__tokdict)
        
    def pop( self, *args, **kwargs):
        """
        Removes and returns item at specified index (default=C{last}).
        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no
        argument or an integer argument, it will use C{list} semantics
        and pop tokens from the list of parsed tokens. If passed a 
        non-integer argument (most likely a string), it will use C{dict}
        semantics and pop the corresponding value from any defined 
        results names. A second default return value argument is 
        supported, just as in C{dict.pop()}.

        Example::
            def remove_first(tokens):
                tokens.pop(0)
            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']

            label = Word(alphas)
            patt = label("LABEL") + OneOrMore(Word(nums))
            print(patt.parseString("AAB 123 321").dump())

            # Use pop() in a parse action to remove named result (note that corresponding value is not
            # removed from list form of results)
            def remove_LABEL(tokens):
                tokens.pop("LABEL")
                return tokens
            patt.addParseAction(remove_LABEL)
            print(patt.parseString("AAB 123 321").dump())
        prints::
            ['AAB', '123', '321']
            - LABEL: AAB

            ['AAB', '123', '321']
        """
        if not args:
            args = [-1]
        for k,v in kwargs.items():
            if k == 'default':
                args = (args[0], v)
            else:
                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
        if (isinstance(args[0], int) or 
                        len(args) == 1 or 
                        args[0] in self):
            index = args[0]
            ret = self[index]
            del self[index]
            return ret
        else:
            defaultvalue = args[1]
            return defaultvalue

    def get(self, key, defaultValue=None):
        """
        Returns named result matching the given key, or if there is no
        such name, then returns the given C{defaultValue} or C{None} if no
        C{defaultValue} is specified.

        Similar to C{dict.get()}.
        
        Example::
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

            result = date_str.parseString("1999/12/31")
            print(result.get("year")) # -> '1999'
            print(result.get("hour", "not specified")) # -> 'not specified'
            print(result.get("hour")) # -> None
        """
        if key in self:
            return self[key]
        else:
            return defaultValue

    def insert( self, index, insStr ):
        """
        Inserts new element at location index in the list of parsed tokens.
        
        Similar to C{list.insert()}.

        Example::
            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

            # use a parse action to insert the parse location in the front of the parsed results
            def insert_locn(locn, tokens):
                tokens.insert(0, locn)
            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
        """
        self.__toklist.insert(index, insStr)
        # fixup indices in token dictionary
        for name,occurrences in self.__tokdict.items():
            for k, (value, position) in enumerate(occurrences):
                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))

    def append( self, item ):
        """
        Add single element to end of ParseResults list of elements.

        Example::
            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
            
            # use a parse action to compute the sum of the parsed integers, and add it to the end
            def append_sum(tokens):
                tokens.append(sum(map(int, tokens)))
            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
        """
        self.__toklist.append(item)

    def extend( self, itemseq ):
        """
        Add sequence of elements to end of ParseResults list of elements.

        Example::
            patt = OneOrMore(Word(alphas))
            
            # use a parse action to append the reverse of the matched strings, to make a palindrome
            def make_palindrome(tokens):
                tokens.extend(reversed([t[::-1] for t in tokens]))
                return ''.join(tokens)
            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
        """
        if isinstance(itemseq, ParseResults):
            self += itemseq
        else:
            self.__toklist.extend(itemseq)

    def clear( self ):
        """
        Clear all elements and results names.
        """
        del self.__toklist[:]
        self.__tokdict.clear()

    def __getattr__( self, name ):
        try:
            return self[name]
        except KeyError:
            return ""
            
        if name in self.__tokdict:
            if name not in self.__accumNames:
                return self.__tokdict[name][-1][0]
            else:
                return ParseResults([ v[0] for v in self.__tokdict[name] ])
        else:
            return ""

    def __add__( self, other ):
        ret = self.copy()
        ret += other
        return ret

    def __iadd__( self, other ):
        if other.__tokdict:
            offset = len(self.__toklist)
            addoffset = lambda a: offset if a<0 else a+offset
            otheritems = other.__tokdict.items()
            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
                                for (k,vlist) in otheritems for v in vlist]
            for k,v in otherdictitems:
                self[k] = v
                if isinstance(v[0],ParseResults):
                    v[0].__parent = wkref(self)
            
        self.__toklist += other.__toklist
        self.__accumNames.update( other.__accumNames )
        return self

    def __radd__(self, other):
        if isinstance(other,int) and other == 0:
            # useful for merging many ParseResults using sum() builtin
            return self.copy()
        else:
            # this may raise a TypeError - so be it
            return other + self
        
    def __repr__( self ):
        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )

    def __str__( self ):
        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'

    def _asStringList( self, sep='' ):
        out = []
        for item in self.__toklist:
            if out and sep:
                out.append(sep)
            if isinstance( item, ParseResults ):
                out += item._asStringList()
            else:
                out.append( _ustr(item) )
        return out

    def asList( self ):
        """
        Returns the parse results as a nested list of matching tokens, all converted to strings.

        Example::
            patt = OneOrMore(Word(alphas))
            result = patt.parseString("sldkj lsdkj sldkj")
            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
            print(type(result), result) # ->  ['sldkj', 'lsdkj', 'sldkj']
            
            # Use asList() to create an actual list
            result_list = result.asList()
            print(type(result_list), result_list) # ->  ['sldkj', 'lsdkj', 'sldkj']
        """
        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]

    def asDict( self ):
        """
        Returns the named parse results as a nested dictionary.

        Example::
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
            
            result = date_str.parseString('12/31/1999')
            print(type(result), repr(result)) # ->  (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
            
            result_dict = result.asDict()
            print(type(result_dict), repr(result_dict)) # ->  {'day': '1999', 'year': '12', 'month': '31'}

            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
            import json
            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
        """
        if PY_3:
            item_fn = self.items
        else:
            item_fn = self.iteritems
            
        def toItem(obj):
            if isinstance(obj, ParseResults):
                if obj.haskeys():
                    return obj.asDict()
                else:
                    return [toItem(v) for v in obj]
            else:
                return obj
                
        return dict((k,toItem(v)) for k,v in item_fn())

    def copy( self ):
        """
        Returns a new copy of a C{ParseResults} object.
        """
        ret = ParseResults( self.__toklist )
        ret.__tokdict = self.__tokdict.copy()
        ret.__parent = self.__parent
        ret.__accumNames.update( self.__accumNames )
        ret.__name = self.__name
        return ret

    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
        """
        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
        """
        nl = "\n"
        out = []
        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
                                                            for v in vlist)
        nextLevelIndent = indent + "  "

        # collapse out indents if formatting is not desired
        if not formatted:
            indent = ""
            nextLevelIndent = ""
            nl = ""

        selfTag = None
        if doctag is not None:
            selfTag = doctag
        else:
            if self.__name:
                selfTag = self.__name

        if not selfTag:
            if namedItemsOnly:
                return ""
            else:
                selfTag = "ITEM"

        out += [ nl, indent, "<", selfTag, ">" ]

        for i,res in enumerate(self.__toklist):
            if isinstance(res,ParseResults):
                if i in namedItems:
                    out += [ res.asXML(namedItems[i],
                                        namedItemsOnly and doctag is None,
                                        nextLevelIndent,
                                        formatted)]
                else:
                    out += [ res.asXML(None,
                                        namedItemsOnly and doctag is None,
                                        nextLevelIndent,
                                        formatted)]
            else:
                # individual token, see if there is a name for it
                resTag = None
                if i in namedItems:
                    resTag = namedItems[i]
                if not resTag:
                    if namedItemsOnly:
                        continue
                    else:
                        resTag = "ITEM"
                xmlBodyText = _xml_escape(_ustr(res))
                out += [ nl, nextLevelIndent, "<", resTag, ">",
                                                xmlBodyText,
                                                "" ]

        out += [ nl, indent, "" ]
        return "".join(out)

    def __lookup(self,sub):
        for k,vlist in self.__tokdict.items():
            for v,loc in vlist:
                if sub is v:
                    return k
        return None

    def getName(self):
        r"""
        Returns the results name for this token expression. Useful when several 
        different expressions might match at a particular location.

        Example::
            integer = Word(nums)
            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
            house_number_expr = Suppress('#') + Word(nums, alphanums)
            user_data = (Group(house_number_expr)("house_number") 
                        | Group(ssn_expr)("ssn")
                        | Group(integer)("age"))
            user_info = OneOrMore(user_data)
            
            result = user_info.parseString("22 111-22-3333 #221B")
            for item in result:
                print(item.getName(), ':', item[0])
        prints::
            age : 22
            ssn : 111-22-3333
            house_number : 221B
        """
        if self.__name:
            return self.__name
        elif self.__parent:
            par = self.__parent()
            if par:
                return par.__lookup(self)
            else:
                return None
        elif (len(self) == 1 and
               len(self.__tokdict) == 1 and
               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):
            return next(iter(self.__tokdict.keys()))
        else:
            return None

    def dump(self, indent='', depth=0, full=True):
        """
        Diagnostic method for listing out the contents of a C{ParseResults}.
        Accepts an optional C{indent} argument so that this string can be embedded
        in a nested display of other data.

        Example::
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
            
            result = date_str.parseString('12/31/1999')
            print(result.dump())
        prints::
            ['12', '/', '31', '/', '1999']
            - day: 1999
            - month: 31
            - year: 12
        """
        out = []
        NL = '\n'
        out.append( indent+_ustr(self.asList()) )
        if full:
            if self.haskeys():
                items = sorted((str(k), v) for k,v in self.items())
                for k,v in items:
                    if out:
                        out.append(NL)
                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
                    if isinstance(v,ParseResults):
                        if v:
                            out.append( v.dump(indent,depth+1) )
                        else:
                            out.append(_ustr(v))
                    else:
                        out.append(repr(v))
            elif any(isinstance(vv,ParseResults) for vv in self):
                v = self
                for i,vv in enumerate(v):
                    if isinstance(vv,ParseResults):
                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))
                    else:
                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))
            
        return "".join(out)

    def pprint(self, *args, **kwargs):
        """
        Pretty-printer for parsed results as a list, using the C{pprint} module.
        Accepts additional positional or keyword args as defined for the 
        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})

        Example::
            ident = Word(alphas, alphanums)
            num = Word(nums)
            func = Forward()
            term = ident | num | Group('(' + func + ')')
            func <<= ident + Group(Optional(delimitedList(term)))
            result = func.parseString("fna a,b,(fnb c,d,200),100")
            result.pprint(width=40)
        prints::
            ['fna',
             ['a',
              'b',
              ['(', 'fnb', ['c', 'd', '200'], ')'],
              '100']]
        """
        pprint.pprint(self.asList(), *args, **kwargs)

    # add support for pickle protocol
    def __getstate__(self):
        return ( self.__toklist,
                 ( self.__tokdict.copy(),
                   self.__parent is not None and self.__parent() or None,
                   self.__accumNames,
                   self.__name ) )

    def __setstate__(self,state):
        self.__toklist = state[0]
        (self.__tokdict,
         par,
         inAccumNames,
         self.__name) = state[1]
        self.__accumNames = {}
        self.__accumNames.update(inAccumNames)
        if par is not None:
            self.__parent = wkref(par)
        else:
            self.__parent = None

    def __getnewargs__(self):
        return self.__toklist, self.__name, self.__asList, self.__modal

    def __dir__(self):
        return (dir(type(self)) + list(self.keys()))

MutableMapping.register(ParseResults)

def col (loc,strg):
    """Returns current column within a string, counting newlines as line separators.
   The first column is number 1.

   Note: the default parsing behavior is to expand tabs in the input string
   before starting the parsing process.  See L{I{ParserElement.parseString}} for more information
   on parsing strings containing C{}s, and suggested methods to maintain a
   consistent view of the parsed string, the parse location, and line and column
   positions within the parsed string.
   """
    s = strg
    return 1 if 0} for more information
   on parsing strings containing C{}s, and suggested methods to maintain a
   consistent view of the parsed string, the parse location, and line and column
   positions within the parsed string.
   """
    return strg.count("\n",0,loc) + 1

def line( loc, strg ):
    """Returns the line of text containing loc within a string, counting newlines as line separators.
       """
    lastCR = strg.rfind("\n", 0, loc)
    nextCR = strg.find("\n", loc)
    if nextCR >= 0:
        return strg[lastCR+1:nextCR]
    else:
        return strg[lastCR+1:]

def _defaultStartDebugAction( instring, loc, expr ):
    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))

def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))

def _defaultExceptionDebugAction( instring, loc, expr, exc ):
    print ("Exception raised:" + _ustr(exc))

def nullDebugAction(*args):
    """'Do-nothing' debug action, to suppress debugging output during parsing."""
    pass

# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
#~ 'decorator to trim function calls to match the arity of the target'
#~ def _trim_arity(func, maxargs=3):
    #~ if func in singleArgBuiltins:
        #~ return lambda s,l,t: func(t)
    #~ limit = 0
    #~ foundArity = False
    #~ def wrapper(*args):
        #~ nonlocal limit,foundArity
        #~ while 1:
            #~ try:
                #~ ret = func(*args[limit:])
                #~ foundArity = True
                #~ return ret
            #~ except TypeError:
                #~ if limit == maxargs or foundArity:
                    #~ raise
                #~ limit += 1
                #~ continue
    #~ return wrapper

# this version is Python 2.x-3.x cross-compatible
'decorator to trim function calls to match the arity of the target'
def _trim_arity(func, maxargs=2):
    if func in singleArgBuiltins:
        return lambda s,l,t: func(t)
    limit = [0]
    foundArity = [False]
    
    # traceback return data structure changed in Py3.5 - normalize back to plain tuples
    if system_version[:2] >= (3,5):
        def extract_stack(limit=0):
            # special handling for Python 3.5.0 - extra deep call stack by 1
            offset = -3 if system_version == (3,5,0) else -2
            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
            return [frame_summary[:2]]
        def extract_tb(tb, limit=0):
            frames = traceback.extract_tb(tb, limit=limit)
            frame_summary = frames[-1]
            return [frame_summary[:2]]
    else:
        extract_stack = traceback.extract_stack
        extract_tb = traceback.extract_tb
    
    # synthesize what would be returned by traceback.extract_stack at the call to 
    # user's parse action 'func', so that we don't incur call penalty at parse time
    
    LINE_DIFF = 6
    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 
    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
    this_line = extract_stack(limit=2)[-1]
    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)

    def wrapper(*args):
        while 1:
            try:
                ret = func(*args[limit[0]:])
                foundArity[0] = True
                return ret
            except TypeError:
                # re-raise TypeErrors if they did not come from our arity testing
                if foundArity[0]:
                    raise
                else:
                    try:
                        tb = sys.exc_info()[-1]
                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:
                            raise
                    finally:
                        del tb

                if limit[0] <= maxargs:
                    limit[0] += 1
                    continue
                raise

    # copy func name to wrapper for sensible debug output
    func_name = ""
    try:
        func_name = getattr(func, '__name__', 
                            getattr(func, '__class__').__name__)
    except Exception:
        func_name = str(func)
    wrapper.__name__ = func_name

    return wrapper

class ParserElement(object):
    """Abstract base level parser element class."""
    DEFAULT_WHITE_CHARS = " \n\t\r"
    verbose_stacktrace = False

    @staticmethod
    def setDefaultWhitespaceChars( chars ):
        r"""
        Overrides the default whitespace chars

        Example::
            # default whitespace chars are space,  and newline
            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
            
            # change to just treat newline as significant
            ParserElement.setDefaultWhitespaceChars(" \t")
            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']
        """
        ParserElement.DEFAULT_WHITE_CHARS = chars

    @staticmethod
    def inlineLiteralsUsing(cls):
        """
        Set class to be used for inclusion of string literals into a parser.
        
        Example::
            # default literal class used is Literal
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']


            # change to Suppress
            ParserElement.inlineLiteralsUsing(Suppress)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']
        """
        ParserElement._literalStringClass = cls

    def __init__( self, savelist=False ):
        self.parseAction = list()
        self.failAction = None
        #~ self.name = ""  # don't define self.name, let subclasses try/except upcall
        self.strRepr = None
        self.resultsName = None
        self.saveAsList = savelist
        self.skipWhitespace = True
        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
        self.copyDefaultWhiteChars = True
        self.mayReturnEmpty = False # used when checking for left-recursion
        self.keepTabs = False
        self.ignoreExprs = list()
        self.debug = False
        self.streamlined = False
        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
        self.errmsg = ""
        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
        self.debugActions = ( None, None, None ) #custom debug actions
        self.re = None
        self.callPreparse = True # used to avoid redundant calls to preParse
        self.callDuringTry = False

    def copy( self ):
        """
        Make a copy of this C{ParserElement}.  Useful for defining different parse actions
        for the same parsing pattern, using copies of the original parse element.
        
        Example::
            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
            
            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
        prints::
            [5120, 100, 655360, 268435456]
        Equivalent form of C{expr.copy()} is just C{expr()}::
            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
        """
        cpy = copy.copy( self )
        cpy.parseAction = self.parseAction[:]
        cpy.ignoreExprs = self.ignoreExprs[:]
        if self.copyDefaultWhiteChars:
            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
        return cpy

    def setName( self, name ):
        """
        Define name for this expression, makes debugging and exception messages clearer.
        
        Example::
            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
        """
        self.name = name
        self.errmsg = "Expected " + self.name
        if hasattr(self,"exception"):
            self.exception.msg = self.errmsg
        return self

    def setResultsName( self, name, listAllMatches=False ):
        """
        Define name for referencing matching tokens as a nested attribute
        of the returned parse results.
        NOTE: this returns a *copy* of the original C{ParserElement} object;
        this is so that the client can define a basic element, such as an
        integer, and reference it in multiple places with different names.

        You can also set results names using the abbreviated syntax,
        C{expr("name")} in place of C{expr.setResultsName("name")} - 
        see L{I{__call__}<__call__>}.

        Example::
            date_str = (integer.setResultsName("year") + '/' 
                        + integer.setResultsName("month") + '/' 
                        + integer.setResultsName("day"))

            # equivalent form:
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
        """
        newself = self.copy()
        if name.endswith("*"):
            name = name[:-1]
            listAllMatches=True
        newself.resultsName = name
        newself.modalResults = not listAllMatches
        return newself

    def setBreak(self,breakFlag = True):
        """Method to invoke the Python pdb debugger when this element is
           about to be parsed. Set C{breakFlag} to True to enable, False to
           disable.
        """
        if breakFlag:
            _parseMethod = self._parse
            def breaker(instring, loc, doActions=True, callPreParse=True):
                import pdb
                pdb.set_trace()
                return _parseMethod( instring, loc, doActions, callPreParse )
            breaker._originalParseMethod = _parseMethod
            self._parse = breaker
        else:
            if hasattr(self._parse,"_originalParseMethod"):
                self._parse = self._parse._originalParseMethod
        return self

    def setParseAction( self, *fns, **kwargs ):
        """
        Define one or more actions to perform when successfully matching parse element definition.
        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:
         - s   = the original string being parsed (see note below)
         - loc = the location of the matching substring
         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object
        If the functions in fns modify the tokens, they can return them as the return
        value from fn, and the modified list of tokens will replace the original.
        Otherwise, fn does not need to return any value.

        Optional keyword arguments:
         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing

        Note: the default parsing behavior is to expand tabs in the input string
        before starting the parsing process.  See L{I{parseString}} for more information
        on parsing strings containing C{}s, and suggested methods to maintain a
        consistent view of the parsed string, the parse location, and line and column
        positions within the parsed string.
        
        Example::
            integer = Word(nums)
            date_str = integer + '/' + integer + '/' + integer

            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']

            # use parse action to convert to ints at parse time
            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
            date_str = integer + '/' + integer + '/' + integer

            # note that integer fields are now ints, not strings
            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]
        """
        self.parseAction = list(map(_trim_arity, list(fns)))
        self.callDuringTry = kwargs.get("callDuringTry", False)
        return self

    def addParseAction( self, *fns, **kwargs ):
        """
        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}}.
        
        See examples in L{I{copy}}.
        """
        self.parseAction += list(map(_trim_arity, list(fns)))
        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
        return self

    def addCondition(self, *fns, **kwargs):
        """Add a boolean predicate function to expression's list of parse actions. See 
        L{I{setParseAction}} for function call signatures. Unlike C{setParseAction}, 
        functions passed to C{addCondition} need to return boolean success/fail of the condition.

        Optional keyword arguments:
         - message = define a custom message to be used in the raised exception
         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
         
        Example::
            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
            year_int = integer.copy()
            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
            date_str = year_int + '/' + integer + '/' + integer

            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
        """
        msg = kwargs.get("message", "failed user-defined condition")
        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException
        for fn in fns:
            def pa(s,l,t):
                if not bool(_trim_arity(fn)(s,l,t)):
                    raise exc_type(s,l,msg)
            self.parseAction.append(pa)
        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
        return self

    def setFailAction( self, fn ):
        """Define action to perform if parsing fails at this expression.
           Fail acton fn is a callable function that takes the arguments
           C{fn(s,loc,expr,err)} where:
            - s = string being parsed
            - loc = location where expression match was attempted and failed
            - expr = the parse expression that failed
            - err = the exception thrown
           The function returns no value.  It may throw C{L{ParseFatalException}}
           if it is desired to stop parsing immediately."""
        self.failAction = fn
        return self

    def _skipIgnorables( self, instring, loc ):
        exprsFound = True
        while exprsFound:
            exprsFound = False
            for e in self.ignoreExprs:
                try:
                    while 1:
                        loc,dummy = e._parse( instring, loc )
                        exprsFound = True
                except ParseException:
                    pass
        return loc

    def preParse( self, instring, loc ):
        if self.ignoreExprs:
            loc = self._skipIgnorables( instring, loc )

        if self.skipWhitespace:
            wt = self.whiteChars
            instrlen = len(instring)
            while loc < instrlen and instring[loc] in wt:
                loc += 1

        return loc

    def parseImpl( self, instring, loc, doActions=True ):
        return loc, []

    def postParse( self, instring, loc, tokenlist ):
        return tokenlist

    #~ @profile
    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
        debugging = ( self.debug ) #and doActions )

        if debugging or self.failAction:
            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
            if (self.debugActions[0] ):
                self.debugActions[0]( instring, loc, self )
            if callPreParse and self.callPreparse:
                preloc = self.preParse( instring, loc )
            else:
                preloc = loc
            tokensStart = preloc
            try:
                try:
                    loc,tokens = self.parseImpl( instring, preloc, doActions )
                except IndexError:
                    raise ParseException( instring, len(instring), self.errmsg, self )
            except ParseBaseException as err:
                #~ print ("Exception raised:", err)
                if self.debugActions[2]:
                    self.debugActions[2]( instring, tokensStart, self, err )
                if self.failAction:
                    self.failAction( instring, tokensStart, self, err )
                raise
        else:
            if callPreParse and self.callPreparse:
                preloc = self.preParse( instring, loc )
            else:
                preloc = loc
            tokensStart = preloc
            if self.mayIndexError or preloc >= len(instring):
                try:
                    loc,tokens = self.parseImpl( instring, preloc, doActions )
                except IndexError:
                    raise ParseException( instring, len(instring), self.errmsg, self )
            else:
                loc,tokens = self.parseImpl( instring, preloc, doActions )

        tokens = self.postParse( instring, loc, tokens )

        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
        if self.parseAction and (doActions or self.callDuringTry):
            if debugging:
                try:
                    for fn in self.parseAction:
                        tokens = fn( instring, tokensStart, retTokens )
                        if tokens is not None:
                            retTokens = ParseResults( tokens,
                                                      self.resultsName,
                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
                                                      modal=self.modalResults )
                except ParseBaseException as err:
                    #~ print "Exception raised in user parse action:", err
                    if (self.debugActions[2] ):
                        self.debugActions[2]( instring, tokensStart, self, err )
                    raise
            else:
                for fn in self.parseAction:
                    tokens = fn( instring, tokensStart, retTokens )
                    if tokens is not None:
                        retTokens = ParseResults( tokens,
                                                  self.resultsName,
                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
                                                  modal=self.modalResults )
        if debugging:
            #~ print ("Matched",self,"->",retTokens.asList())
            if (self.debugActions[1] ):
                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )

        return loc, retTokens

    def tryParse( self, instring, loc ):
        try:
            return self._parse( instring, loc, doActions=False )[0]
        except ParseFatalException:
            raise ParseException( instring, loc, self.errmsg, self)
    
    def canParseNext(self, instring, loc):
        try:
            self.tryParse(instring, loc)
        except (ParseException, IndexError):
            return False
        else:
            return True

    class _UnboundedCache(object):
        def __init__(self):
            cache = {}
            self.not_in_cache = not_in_cache = object()

            def get(self, key):
                return cache.get(key, not_in_cache)

            def set(self, key, value):
                cache[key] = value

            def clear(self):
                cache.clear()
                
            def cache_len(self):
                return len(cache)

            self.get = types.MethodType(get, self)
            self.set = types.MethodType(set, self)
            self.clear = types.MethodType(clear, self)
            self.__len__ = types.MethodType(cache_len, self)

    if _OrderedDict is not None:
        class _FifoCache(object):
            def __init__(self, size):
                self.not_in_cache = not_in_cache = object()

                cache = _OrderedDict()

                def get(self, key):
                    return cache.get(key, not_in_cache)

                def set(self, key, value):
                    cache[key] = value
                    while len(cache) > size:
                        try:
                            cache.popitem(False)
                        except KeyError:
                            pass

                def clear(self):
                    cache.clear()

                def cache_len(self):
                    return len(cache)

                self.get = types.MethodType(get, self)
                self.set = types.MethodType(set, self)
                self.clear = types.MethodType(clear, self)
                self.__len__ = types.MethodType(cache_len, self)

    else:
        class _FifoCache(object):
            def __init__(self, size):
                self.not_in_cache = not_in_cache = object()

                cache = {}
                key_fifo = collections.deque([], size)

                def get(self, key):
                    return cache.get(key, not_in_cache)

                def set(self, key, value):
                    cache[key] = value
                    while len(key_fifo) > size:
                        cache.pop(key_fifo.popleft(), None)
                    key_fifo.append(key)

                def clear(self):
                    cache.clear()
                    key_fifo.clear()

                def cache_len(self):
                    return len(cache)

                self.get = types.MethodType(get, self)
                self.set = types.MethodType(set, self)
                self.clear = types.MethodType(clear, self)
                self.__len__ = types.MethodType(cache_len, self)

    # argument cache for optimizing repeated calls when backtracking through recursive expressions
    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail
    packrat_cache_lock = RLock()
    packrat_cache_stats = [0, 0]

    # this method gets repeatedly called during backtracking with the same arguments -
    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
        HIT, MISS = 0, 1
        lookup = (self, instring, loc, callPreParse, doActions)
        with ParserElement.packrat_cache_lock:
            cache = ParserElement.packrat_cache
            value = cache.get(lookup)
            if value is cache.not_in_cache:
                ParserElement.packrat_cache_stats[MISS] += 1
                try:
                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
                except ParseBaseException as pe:
                    # cache a copy of the exception, without the traceback
                    cache.set(lookup, pe.__class__(*pe.args))
                    raise
                else:
                    cache.set(lookup, (value[0], value[1].copy()))
                    return value
            else:
                ParserElement.packrat_cache_stats[HIT] += 1
                if isinstance(value, Exception):
                    raise value
                return (value[0], value[1].copy())

    _parse = _parseNoCache

    @staticmethod
    def resetCache():
        ParserElement.packrat_cache.clear()
        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)

    _packratEnabled = False
    @staticmethod
    def enablePackrat(cache_size_limit=128):
        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
           Repeated parse attempts at the same string location (which happens
           often in many complex grammars) can immediately return a cached value,
           instead of re-executing parsing/validating code.  Memoizing is done of
           both valid results and parsing exceptions.
           
           Parameters:
            - cache_size_limit - (default=C{128}) - if an integer value is provided
              will limit the size of the packrat cache; if None is passed, then
              the cache size will be unbounded; if 0 is passed, the cache will
              be effectively disabled.
            
           This speedup may break existing programs that use parse actions that
           have side-effects.  For this reason, packrat parsing is disabled when
           you first import pyparsing.  To activate the packrat feature, your
           program must call the class method C{ParserElement.enablePackrat()}.  If
           your program uses C{psyco} to "compile as you go", you must call
           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,
           Python will crash.  For best results, call C{enablePackrat()} immediately
           after importing pyparsing.
           
           Example::
               import pyparsing
               pyparsing.ParserElement.enablePackrat()
        """
        if not ParserElement._packratEnabled:
            ParserElement._packratEnabled = True
            if cache_size_limit is None:
                ParserElement.packrat_cache = ParserElement._UnboundedCache()
            else:
                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)
            ParserElement._parse = ParserElement._parseCache

    def parseString( self, instring, parseAll=False ):
        """
        Execute the parse expression with the given string.
        This is the main interface to the client code, once the complete
        expression has been built.

        If you want the grammar to require that the entire input string be
        successfully parsed, then set C{parseAll} to True (equivalent to ending
        the grammar with C{L{StringEnd()}}).

        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
        in order to report proper column numbers in parse actions.
        If the input string contains tabs and
        the grammar uses parse actions that use the C{loc} argument to index into the
        string being parsed, you can ensure you have a consistent view of the input
        string by:
         - calling C{parseWithTabs} on your grammar before calling C{parseString}
           (see L{I{parseWithTabs}})
         - define your parse action using the full C{(s,loc,toks)} signature, and
           reference the input string using the parse action's C{s} argument
         - explictly expand the tabs in your input string before calling
           C{parseString}
        
        Example::
            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']
            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text
        """
        ParserElement.resetCache()
        if not self.streamlined:
            self.streamline()
            #~ self.saveAsList = True
        for e in self.ignoreExprs:
            e.streamline()
        if not self.keepTabs:
            instring = instring.expandtabs()
        try:
            loc, tokens = self._parse( instring, 0 )
            if parseAll:
                loc = self.preParse( instring, loc )
                se = Empty() + StringEnd()
                se._parse( instring, loc )
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc
        else:
            return tokens

    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
        """
        Scan the input string for expression matches.  Each match will return the
        matching tokens, start location, and end location.  May be called with optional
        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If
        C{overlap} is specified, then overlapping matches will be reported.

        Note that the start and end locations are reported relative to the string
        being parsed.  See L{I{parseString}} for more information on parsing
        strings with embedded tabs.

        Example::
            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
            print(source)
            for tokens,start,end in Word(alphas).scanString(source):
                print(' '*start + '^'*(end-start))
                print(' '*start + tokens[0])
        
        prints::
        
            sldjf123lsdjjkf345sldkjf879lkjsfd987
            ^^^^^
            sldjf
                    ^^^^^^^
                    lsdjjkf
                              ^^^^^^
                              sldkjf
                                       ^^^^^^
                                       lkjsfd
        """
        if not self.streamlined:
            self.streamline()
        for e in self.ignoreExprs:
            e.streamline()

        if not self.keepTabs:
            instring = _ustr(instring).expandtabs()
        instrlen = len(instring)
        loc = 0
        preparseFn = self.preParse
        parseFn = self._parse
        ParserElement.resetCache()
        matches = 0
        try:
            while loc <= instrlen and matches < maxMatches:
                try:
                    preloc = preparseFn( instring, loc )
                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
                except ParseException:
                    loc = preloc+1
                else:
                    if nextLoc > loc:
                        matches += 1
                        yield tokens, preloc, nextLoc
                        if overlap:
                            nextloc = preparseFn( instring, loc )
                            if nextloc > loc:
                                loc = nextLoc
                            else:
                                loc += 1
                        else:
                            loc = nextLoc
                    else:
                        loc = preloc+1
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def transformString( self, instring ):
        """
        Extension to C{L{scanString}}, to modify matching text with modified tokens that may
        be returned from a parse action.  To use C{transformString}, define a grammar and
        attach a parse action to it that modifies the returned token list.
        Invoking C{transformString()} on a target string will then scan for matches,
        and replace the matched text patterns according to the logic in the parse
        action.  C{transformString()} returns the resulting transformed string.
        
        Example::
            wd = Word(alphas)
            wd.setParseAction(lambda toks: toks[0].title())
            
            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
        Prints::
            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
        """
        out = []
        lastE = 0
        # force preservation of s, to minimize unwanted transformation of string, and to
        # keep string locs straight between transformString and scanString
        self.keepTabs = True
        try:
            for t,s,e in self.scanString( instring ):
                out.append( instring[lastE:s] )
                if t:
                    if isinstance(t,ParseResults):
                        out += t.asList()
                    elif isinstance(t,list):
                        out += t
                    else:
                        out.append(t)
                lastE = e
            out.append(instring[lastE:])
            out = [o for o in out if o]
            return "".join(map(_ustr,_flatten(out)))
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def searchString( self, instring, maxMatches=_MAX_INT ):
        """
        Another extension to C{L{scanString}}, simplifying the access to the tokens found
        to match the given parse expression.  May be called with optional
        C{maxMatches} argument, to clip searching after 'n' matches are found.
        
        Example::
            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
            cap_word = Word(alphas.upper(), alphas.lower())
            
            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))

            # the sum() builtin can be used to merge results into a single ParseResults object
            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))
        prints::
            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
        """
        try:
            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
        """
        Generator method to split a string using the given expression as a separator.
        May be called with optional C{maxsplit} argument, to limit the number of splits;
        and the optional C{includeSeparators} argument (default=C{False}), if the separating
        matching text should be included in the split results.
        
        Example::        
            punc = oneOf(list(".,;:/-!?"))
            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
        prints::
            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
        """
        splits = 0
        last = 0
        for t,s,e in self.scanString(instring, maxMatches=maxsplit):
            yield instring[last:s]
            if includeSeparators:
                yield t[0]
            last = e
        yield instring[last:]

    def __add__(self, other ):
        """
        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement
        converts them to L{Literal}s by default.
        
        Example::
            greet = Word(alphas) + "," + Word(alphas) + "!"
            hello = "Hello, World!"
            print (hello, "->", greet.parseString(hello))
        Prints::
            Hello, World! -> ['Hello', ',', 'World', '!']
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return And( [ self, other ] )

    def __radd__(self, other ):
        """
        Implementation of + operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other + self

    def __sub__(self, other):
        """
        Implementation of - operator, returns C{L{And}} with error stop
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return self + And._ErrorStop() + other

    def __rsub__(self, other ):
        """
        Implementation of - operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other - self

    def __mul__(self,other):
        """
        Implementation of * operator, allows use of C{expr * 3} in place of
        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer
        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples
        may also include C{None} as in:
         - C{expr*(n,None)} or C{expr*(n,)} is equivalent
              to C{expr*n + L{ZeroOrMore}(expr)}
              (read as "at least n instances of C{expr}")
         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}
              (read as "0 to n instances of C{expr}")
         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}

        Note that C{expr*(None,n)} does not raise an exception if
        more than n exprs exist in the input stream; that is,
        C{expr*(None,n)} does not enforce a maximum number of expr
        occurrences.  If this behavior is desired, then write
        C{expr*(None,n) + ~expr}
        """
        if isinstance(other,int):
            minElements, optElements = other,0
        elif isinstance(other,tuple):
            other = (other + (None, None))[:2]
            if other[0] is None:
                other = (0, other[1])
            if isinstance(other[0],int) and other[1] is None:
                if other[0] == 0:
                    return ZeroOrMore(self)
                if other[0] == 1:
                    return OneOrMore(self)
                else:
                    return self*other[0] + ZeroOrMore(self)
            elif isinstance(other[0],int) and isinstance(other[1],int):
                minElements, optElements = other
                optElements -= minElements
            else:
                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
        else:
            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))

        if minElements < 0:
            raise ValueError("cannot multiply ParserElement by negative value")
        if optElements < 0:
            raise ValueError("second tuple value must be greater or equal to first tuple value")
        if minElements == optElements == 0:
            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")

        if (optElements):
            def makeOptionalList(n):
                if n>1:
                    return Optional(self + makeOptionalList(n-1))
                else:
                    return Optional(self)
            if minElements:
                if minElements == 1:
                    ret = self + makeOptionalList(optElements)
                else:
                    ret = And([self]*minElements) + makeOptionalList(optElements)
            else:
                ret = makeOptionalList(optElements)
        else:
            if minElements == 1:
                ret = self
            else:
                ret = And([self]*minElements)
        return ret

    def __rmul__(self, other):
        return self.__mul__(other)

    def __or__(self, other ):
        """
        Implementation of | operator - returns C{L{MatchFirst}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return MatchFirst( [ self, other ] )

    def __ror__(self, other ):
        """
        Implementation of | operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other | self

    def __xor__(self, other ):
        """
        Implementation of ^ operator - returns C{L{Or}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return Or( [ self, other ] )

    def __rxor__(self, other ):
        """
        Implementation of ^ operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other ^ self

    def __and__(self, other ):
        """
        Implementation of & operator - returns C{L{Each}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return Each( [ self, other ] )

    def __rand__(self, other ):
        """
        Implementation of & operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other & self

    def __invert__( self ):
        """
        Implementation of ~ operator - returns C{L{NotAny}}
        """
        return NotAny( self )

    def __call__(self, name=None):
        """
        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.
        
        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
        passed as C{True}.
           
        If C{name} is omitted, same as calling C{L{copy}}.

        Example::
            # these are equivalent
            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             
        """
        if name is not None:
            return self.setResultsName(name)
        else:
            return self.copy()

    def suppress( self ):
        """
        Suppresses the output of this C{ParserElement}; useful to keep punctuation from
        cluttering up returned output.
        """
        return Suppress( self )

    def leaveWhitespace( self ):
        """
        Disables the skipping of whitespace before matching the characters in the
        C{ParserElement}'s defined pattern.  This is normally only used internally by
        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
        """
        self.skipWhitespace = False
        return self

    def setWhitespaceChars( self, chars ):
        """
        Overrides the default whitespace chars
        """
        self.skipWhitespace = True
        self.whiteChars = chars
        self.copyDefaultWhiteChars = False
        return self

    def parseWithTabs( self ):
        """
        Overrides default behavior to expand C{}s to spaces before parsing the input string.
        Must be called before C{parseString} when the input grammar contains elements that
        match C{} characters.
        """
        self.keepTabs = True
        return self

    def ignore( self, other ):
        """
        Define expression to be ignored (e.g., comments) while doing pattern
        matching; may be called repeatedly, to define multiple comment or other
        ignorable patterns.
        
        Example::
            patt = OneOrMore(Word(alphas))
            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
            
            patt.ignore(cStyleComment)
            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
        """
        if isinstance(other, basestring):
            other = Suppress(other)

        if isinstance( other, Suppress ):
            if other not in self.ignoreExprs:
                self.ignoreExprs.append(other)
        else:
            self.ignoreExprs.append( Suppress( other.copy() ) )
        return self

    def setDebugActions( self, startAction, successAction, exceptionAction ):
        """
        Enable display of debugging messages while doing pattern matching.
        """
        self.debugActions = (startAction or _defaultStartDebugAction,
                             successAction or _defaultSuccessDebugAction,
                             exceptionAction or _defaultExceptionDebugAction)
        self.debug = True
        return self

    def setDebug( self, flag=True ):
        """
        Enable display of debugging messages while doing pattern matching.
        Set C{flag} to True to enable, False to disable.

        Example::
            wd = Word(alphas).setName("alphaword")
            integer = Word(nums).setName("numword")
            term = wd | integer
            
            # turn on debugging for wd
            wd.setDebug()

            OneOrMore(term).parseString("abc 123 xyz 890")
        
        prints::
            Match alphaword at loc 0(1,1)
            Matched alphaword -> ['abc']
            Match alphaword at loc 3(1,4)
            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
            Match alphaword at loc 7(1,8)
            Matched alphaword -> ['xyz']
            Match alphaword at loc 11(1,12)
            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
            Match alphaword at loc 15(1,16)
            Exception raised:Expected alphaword (at char 15), (line:1, col:16)

        The output shown is that produced by the default debug actions - custom debug actions can be
        specified using L{setDebugActions}. Prior to attempting
        to match the C{wd} expression, the debugging message C{"Match  at loc (,)"}
        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}
        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,
        which makes debugging and exception messages easier to understand - for instance, the default
        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.
        """
        if flag:
            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
        else:
            self.debug = False
        return self

    def __str__( self ):
        return self.name

    def __repr__( self ):
        return _ustr(self)

    def streamline( self ):
        self.streamlined = True
        self.strRepr = None
        return self

    def checkRecursion( self, parseElementList ):
        pass

    def validate( self, validateTrace=[] ):
        """
        Check defined expressions for valid structure, check for infinite recursive definitions.
        """
        self.checkRecursion( [] )

    def parseFile( self, file_or_filename, parseAll=False ):
        """
        Execute the parse expression on the given file or filename.
        If a filename is specified (instead of a file object),
        the entire file is opened, read, and closed before parsing.
        """
        try:
            file_contents = file_or_filename.read()
        except AttributeError:
            with open(file_or_filename, "r") as f:
                file_contents = f.read()
        try:
            return self.parseString(file_contents, parseAll)
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def __eq__(self,other):
        if isinstance(other, ParserElement):
            return self is other or vars(self) == vars(other)
        elif isinstance(other, basestring):
            return self.matches(other)
        else:
            return super(ParserElement,self)==other

    def __ne__(self,other):
        return not (self == other)

    def __hash__(self):
        return hash(id(self))

    def __req__(self,other):
        return self == other

    def __rne__(self,other):
        return not (self == other)

    def matches(self, testString, parseAll=True):
        """
        Method for quick testing of a parser against a test string. Good for simple 
        inline microtests of sub expressions while building up larger parser.
           
        Parameters:
         - testString - to test against this expression for a match
         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
            
        Example::
            expr = Word(nums)
            assert expr.matches("100")
        """
        try:
            self.parseString(_ustr(testString), parseAll=parseAll)
            return True
        except ParseBaseException:
            return False
                
    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):
        """
        Execute the parse expression on a series of test strings, showing each
        test, the parsed results or where the parse failed. Quick and easy way to
        run a parse expression against a list of sample strings.
           
        Parameters:
         - tests - a list of separate test strings, or a multiline string of test strings
         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           
         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 
              string; pass None to disable comment filtering
         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;
              if False, only dump nested list
         - printResults - (default=C{True}) prints test output to stdout
         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing

        Returns: a (success, results) tuple, where success indicates that all tests succeeded
        (or failed if C{failureTests} is True), and the results contain a list of lines of each 
        test's output
        
        Example::
            number_expr = pyparsing_common.number.copy()

            result = number_expr.runTests('''
                # unsigned integer
                100
                # negative integer
                -100
                # float with scientific notation
                6.02e23
                # integer with scientific notation
                1e-12
                ''')
            print("Success" if result[0] else "Failed!")

            result = number_expr.runTests('''
                # stray character
                100Z
                # missing leading digit before '.'
                -.100
                # too many '.'
                3.14.159
                ''', failureTests=True)
            print("Success" if result[0] else "Failed!")
        prints::
            # unsigned integer
            100
            [100]

            # negative integer
            -100
            [-100]

            # float with scientific notation
            6.02e23
            [6.02e+23]

            # integer with scientific notation
            1e-12
            [1e-12]

            Success
            
            # stray character
            100Z
               ^
            FAIL: Expected end of text (at char 3), (line:1, col:4)

            # missing leading digit before '.'
            -.100
            ^
            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)

            # too many '.'
            3.14.159
                ^
            FAIL: Expected end of text (at char 4), (line:1, col:5)

            Success

        Each test string must be on a single line. If you want to test a string that spans multiple
        lines, create a test like this::

            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")
        
        (Note that this is a raw string literal, you must include the leading 'r'.)
        """
        if isinstance(tests, basestring):
            tests = list(map(str.strip, tests.rstrip().splitlines()))
        if isinstance(comment, basestring):
            comment = Literal(comment)
        allResults = []
        comments = []
        success = True
        for t in tests:
            if comment is not None and comment.matches(t, False) or comments and not t:
                comments.append(t)
                continue
            if not t:
                continue
            out = ['\n'.join(comments), t]
            comments = []
            try:
                t = t.replace(r'\n','\n')
                result = self.parseString(t, parseAll=parseAll)
                out.append(result.dump(full=fullDump))
                success = success and not failureTests
            except ParseBaseException as pe:
                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
                if '\n' in t:
                    out.append(line(pe.loc, t))
                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)
                else:
                    out.append(' '*pe.loc + '^' + fatal)
                out.append("FAIL: " + str(pe))
                success = success and failureTests
                result = pe
            except Exception as exc:
                out.append("FAIL-EXCEPTION: " + str(exc))
                success = success and failureTests
                result = exc

            if printResults:
                if fullDump:
                    out.append('')
                print('\n'.join(out))

            allResults.append((t, result))
        
        return success, allResults

        
class Token(ParserElement):
    """
    Abstract C{ParserElement} subclass, for defining atomic matching patterns.
    """
    def __init__( self ):
        super(Token,self).__init__( savelist=False )


class Empty(Token):
    """
    An empty token, will always match.
    """
    def __init__( self ):
        super(Empty,self).__init__()
        self.name = "Empty"
        self.mayReturnEmpty = True
        self.mayIndexError = False


class NoMatch(Token):
    """
    A token that will never match.
    """
    def __init__( self ):
        super(NoMatch,self).__init__()
        self.name = "NoMatch"
        self.mayReturnEmpty = True
        self.mayIndexError = False
        self.errmsg = "Unmatchable token"

    def parseImpl( self, instring, loc, doActions=True ):
        raise ParseException(instring, loc, self.errmsg, self)


class Literal(Token):
    """
    Token to exactly match a specified string.
    
    Example::
        Literal('blah').parseString('blah')  # -> ['blah']
        Literal('blah').parseString('blahfooblah')  # -> ['blah']
        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"
    
    For case-insensitive matching, use L{CaselessLiteral}.
    
    For keyword matching (force word break before and after the matched string),
    use L{Keyword} or L{CaselessKeyword}.
    """
    def __init__( self, matchString ):
        super(Literal,self).__init__()
        self.match = matchString
        self.matchLen = len(matchString)
        try:
            self.firstMatchChar = matchString[0]
        except IndexError:
            warnings.warn("null string passed to Literal; use Empty() instead",
                            SyntaxWarning, stacklevel=2)
            self.__class__ = Empty
        self.name = '"%s"' % _ustr(self.match)
        self.errmsg = "Expected " + self.name
        self.mayReturnEmpty = False
        self.mayIndexError = False

    # Performance tuning: this routine gets called a *lot*
    # if this is a single character match string  and the first character matches,
    # short-circuit as quickly as possible, and avoid calling startswith
    #~ @profile
    def parseImpl( self, instring, loc, doActions=True ):
        if (instring[loc] == self.firstMatchChar and
            (self.matchLen==1 or instring.startswith(self.match,loc)) ):
            return loc+self.matchLen, self.match
        raise ParseException(instring, loc, self.errmsg, self)
_L = Literal
ParserElement._literalStringClass = Literal

class Keyword(Token):
    """
    Token to exactly match a specified string as a keyword, that is, it must be
    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:
     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.
     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
    Accepts two optional constructor arguments in addition to the keyword string:
     - C{identChars} is a string of characters that would be valid identifier characters,
          defaulting to all alphanumerics + "_" and "$"
     - C{caseless} allows case-insensitive matching, default is C{False}.
       
    Example::
        Keyword("start").parseString("start")  # -> ['start']
        Keyword("start").parseString("starting")  # -> Exception

    For case-insensitive matching, use L{CaselessKeyword}.
    """
    DEFAULT_KEYWORD_CHARS = alphanums+"_$"

    def __init__( self, matchString, identChars=None, caseless=False ):
        super(Keyword,self).__init__()
        if identChars is None:
            identChars = Keyword.DEFAULT_KEYWORD_CHARS
        self.match = matchString
        self.matchLen = len(matchString)
        try:
            self.firstMatchChar = matchString[0]
        except IndexError:
            warnings.warn("null string passed to Keyword; use Empty() instead",
                            SyntaxWarning, stacklevel=2)
        self.name = '"%s"' % self.match
        self.errmsg = "Expected " + self.name
        self.mayReturnEmpty = False
        self.mayIndexError = False
        self.caseless = caseless
        if caseless:
            self.caselessmatch = matchString.upper()
            identChars = identChars.upper()
        self.identChars = set(identChars)

    def parseImpl( self, instring, loc, doActions=True ):
        if self.caseless:
            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):
                return loc+self.matchLen, self.match
        else:
            if (instring[loc] == self.firstMatchChar and
                (self.matchLen==1 or instring.startswith(self.match,loc)) and
                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
                (loc == 0 or instring[loc-1] not in self.identChars) ):
                return loc+self.matchLen, self.match
        raise ParseException(instring, loc, self.errmsg, self)

    def copy(self):
        c = super(Keyword,self).copy()
        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
        return c

    @staticmethod
    def setDefaultKeywordChars( chars ):
        """Overrides the default Keyword chars
        """
        Keyword.DEFAULT_KEYWORD_CHARS = chars

class CaselessLiteral(Literal):
    """
    Token to match a specified string, ignoring case of letters.
    Note: the matched results will always be in the case of the given
    match string, NOT the case of the input text.

    Example::
        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
        
    (Contrast with example for L{CaselessKeyword}.)
    """
    def __init__( self, matchString ):
        super(CaselessLiteral,self).__init__( matchString.upper() )
        # Preserve the defining literal.
        self.returnString = matchString
        self.name = "'%s'" % self.returnString
        self.errmsg = "Expected " + self.name

    def parseImpl( self, instring, loc, doActions=True ):
        if instring[ loc:loc+self.matchLen ].upper() == self.match:
            return loc+self.matchLen, self.returnString
        raise ParseException(instring, loc, self.errmsg, self)

class CaselessKeyword(Keyword):
    """
    Caseless version of L{Keyword}.

    Example::
        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
        
    (Contrast with example for L{CaselessLiteral}.)
    """
    def __init__( self, matchString, identChars=None ):
        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )

    def parseImpl( self, instring, loc, doActions=True ):
        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
            return loc+self.matchLen, self.match
        raise ParseException(instring, loc, self.errmsg, self)

class CloseMatch(Token):
    """
    A variation on L{Literal} which matches "close" matches, that is, 
    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:
     - C{match_string} - string to be matched
     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match
    
    The results from a successful parse will contain the matched text from the input string and the following named results:
     - C{mismatches} - a list of the positions within the match_string where mismatches were found
     - C{original} - the original match_string used to compare against the input string
    
    If C{mismatches} is an empty list, then the match was an exact match.
    
    Example::
        patt = CloseMatch("ATCATCGAATGGA")
        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)

        # exact match
        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})

        # close match allowing up to 2 mismatches
        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
    """
    def __init__(self, match_string, maxMismatches=1):
        super(CloseMatch,self).__init__()
        self.name = match_string
        self.match_string = match_string
        self.maxMismatches = maxMismatches
        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)
        self.mayIndexError = False
        self.mayReturnEmpty = False

    def parseImpl( self, instring, loc, doActions=True ):
        start = loc
        instrlen = len(instring)
        maxloc = start + len(self.match_string)

        if maxloc <= instrlen:
            match_string = self.match_string
            match_stringloc = 0
            mismatches = []
            maxMismatches = self.maxMismatches

            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):
                src,mat = s_m
                if src != mat:
                    mismatches.append(match_stringloc)
                    if len(mismatches) > maxMismatches:
                        break
            else:
                loc = match_stringloc + 1
                results = ParseResults([instring[start:loc]])
                results['original'] = self.match_string
                results['mismatches'] = mismatches
                return loc, results

        raise ParseException(instring, loc, self.errmsg, self)


class Word(Token):
    """
    Token for matching words composed of allowed character sets.
    Defined with string containing all allowed initial characters,
    an optional string containing allowed body characters (if omitted,
    defaults to the initial character set), and an optional minimum,
    maximum, and/or exact length.  The default value for C{min} is 1 (a
    minimum value < 1 is not valid); the default values for C{max} and C{exact}
    are 0, meaning no maximum or exact length restriction. An optional
    C{excludeChars} parameter can list characters that might be found in 
    the input C{bodyChars} string; useful to define a word of all printables
    except for one or two characters, for instance.
    
    L{srange} is useful for defining custom character set strings for defining 
    C{Word} expressions, using range notation from regular expression character sets.
    
    A common mistake is to use C{Word} to match a specific literal string, as in 
    C{Word("Address")}. Remember that C{Word} uses the string argument to define
    I{sets} of matchable characters. This expression would match "Add", "AAA",
    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.
    To match an exact literal string, use L{Literal} or L{Keyword}.

    pyparsing includes helper strings for building Words:
     - L{alphas}
     - L{nums}
     - L{alphanums}
     - L{hexnums}
     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)
     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)
     - L{printables} (any non-whitespace character)

    Example::
        # a word composed of digits
        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
        
        # a word with a leading capital, and zero or more lowercase
        capital_word = Word(alphas.upper(), alphas.lower())

        # hostnames are alphanumeric, with leading alpha, and '-'
        hostname = Word(alphas, alphanums+'-')
        
        # roman numeral (not a strict parser, accepts invalid mix of characters)
        roman = Word("IVXLCDM")
        
        # any string of non-whitespace characters, except for ','
        csv_value = Word(printables, excludeChars=",")
    """
    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
        super(Word,self).__init__()
        if excludeChars:
            initChars = ''.join(c for c in initChars if c not in excludeChars)
            if bodyChars:
                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
        self.initCharsOrig = initChars
        self.initChars = set(initChars)
        if bodyChars :
            self.bodyCharsOrig = bodyChars
            self.bodyChars = set(bodyChars)
        else:
            self.bodyCharsOrig = initChars
            self.bodyChars = set(initChars)

        self.maxSpecified = max > 0

        if min < 1:
            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")

        self.minLen = min

        if max > 0:
            self.maxLen = max
        else:
            self.maxLen = _MAX_INT

        if exact > 0:
            self.maxLen = exact
            self.minLen = exact

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayIndexError = False
        self.asKeyword = asKeyword

        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
            if self.bodyCharsOrig == self.initCharsOrig:
                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
            elif len(self.initCharsOrig) == 1:
                self.reString = "%s[%s]*" % \
                                      (re.escape(self.initCharsOrig),
                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
            else:
                self.reString = "[%s][%s]*" % \
                                      (_escapeRegexRangeChars(self.initCharsOrig),
                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
            if self.asKeyword:
                self.reString = r"\b"+self.reString+r"\b"
            try:
                self.re = re.compile( self.reString )
            except Exception:
                self.re = None

    def parseImpl( self, instring, loc, doActions=True ):
        if self.re:
            result = self.re.match(instring,loc)
            if not result:
                raise ParseException(instring, loc, self.errmsg, self)

            loc = result.end()
            return loc, result.group()

        if not(instring[ loc ] in self.initChars):
            raise ParseException(instring, loc, self.errmsg, self)

        start = loc
        loc += 1
        instrlen = len(instring)
        bodychars = self.bodyChars
        maxloc = start + self.maxLen
        maxloc = min( maxloc, instrlen )
        while loc < maxloc and instring[loc] in bodychars:
            loc += 1

        throwException = False
        if loc - start < self.minLen:
            throwException = True
        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
            throwException = True
        if self.asKeyword:
            if (start>0 and instring[start-1] in bodychars) or (loc4:
                    return s[:4]+"..."
                else:
                    return s

            if ( self.initCharsOrig != self.bodyCharsOrig ):
                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
            else:
                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)

        return self.strRepr


class Regex(Token):
    r"""
    Token for matching strings that match a given regular expression.
    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
    If the given regex contains named groups (defined using C{(?P...)}), these will be preserved as 
    named parse results.

    Example::
        realnum = Regex(r"[+-]?\d+\.\d*")
        date = Regex(r'(?P\d{4})-(?P\d\d?)-(?P\d\d?)')
        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
    """
    compiledREtype = type(re.compile("[A-Z]"))
    def __init__( self, pattern, flags=0):
        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
        super(Regex,self).__init__()

        if isinstance(pattern, basestring):
            if not pattern:
                warnings.warn("null string passed to Regex; use Empty() instead",
                        SyntaxWarning, stacklevel=2)

            self.pattern = pattern
            self.flags = flags

            try:
                self.re = re.compile(self.pattern, self.flags)
                self.reString = self.pattern
            except sre_constants.error:
                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
                    SyntaxWarning, stacklevel=2)
                raise

        elif isinstance(pattern, Regex.compiledREtype):
            self.re = pattern
            self.pattern = \
            self.reString = str(pattern)
            self.flags = flags
            
        else:
            raise ValueError("Regex may only be constructed with a string or a compiled RE object")

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayIndexError = False
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        result = self.re.match(instring,loc)
        if not result:
            raise ParseException(instring, loc, self.errmsg, self)

        loc = result.end()
        d = result.groupdict()
        ret = ParseResults(result.group())
        if d:
            for k in d:
                ret[k] = d[k]
        return loc,ret

    def __str__( self ):
        try:
            return super(Regex,self).__str__()
        except Exception:
            pass

        if self.strRepr is None:
            self.strRepr = "Re:(%s)" % repr(self.pattern)

        return self.strRepr


class QuotedString(Token):
    r"""
    Token for matching strings that are delimited by quoting characters.
    
    Defined with the following parameters:
        - quoteChar - string of one or more characters defining the quote delimiting string
        - escChar - character to escape quotes, typically backslash (default=C{None})
        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})
        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})

    Example::
        qs = QuotedString('"')
        print(qs.searchString('lsjdf "This is the quote" sldjf'))
        complex_qs = QuotedString('{{', endQuoteChar='}}')
        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
        sql_qs = QuotedString('"', escQuote='""')
        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
    prints::
        [['This is the quote']]
        [['This is the "quote"']]
        [['This is the quote with "embedded" quotes']]
    """
    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
        super(QuotedString,self).__init__()

        # remove white space from quote chars - wont work anyway
        quoteChar = quoteChar.strip()
        if not quoteChar:
            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
            raise SyntaxError()

        if endQuoteChar is None:
            endQuoteChar = quoteChar
        else:
            endQuoteChar = endQuoteChar.strip()
            if not endQuoteChar:
                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
                raise SyntaxError()

        self.quoteChar = quoteChar
        self.quoteCharLen = len(quoteChar)
        self.firstQuoteChar = quoteChar[0]
        self.endQuoteChar = endQuoteChar
        self.endQuoteCharLen = len(endQuoteChar)
        self.escChar = escChar
        self.escQuote = escQuote
        self.unquoteResults = unquoteResults
        self.convertWhitespaceEscapes = convertWhitespaceEscapes

        if multiline:
            self.flags = re.MULTILINE | re.DOTALL
            self.pattern = r'%s(?:[^%s%s]' % \
                ( re.escape(self.quoteChar),
                  _escapeRegexRangeChars(self.endQuoteChar[0]),
                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
        else:
            self.flags = 0
            self.pattern = r'%s(?:[^%s\n\r%s]' % \
                ( re.escape(self.quoteChar),
                  _escapeRegexRangeChars(self.endQuoteChar[0]),
                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
        if len(self.endQuoteChar) > 1:
            self.pattern += (
                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'
                )
        if escQuote:
            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
        if escChar:
            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))

        try:
            self.re = re.compile(self.pattern, self.flags)
            self.reString = self.pattern
        except sre_constants.error:
            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
                SyntaxWarning, stacklevel=2)
            raise

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayIndexError = False
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
        if not result:
            raise ParseException(instring, loc, self.errmsg, self)

        loc = result.end()
        ret = result.group()

        if self.unquoteResults:

            # strip off quotes
            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]

            if isinstance(ret,basestring):
                # replace escaped whitespace
                if '\\' in ret and self.convertWhitespaceEscapes:
                    ws_map = {
                        r'\t' : '\t',
                        r'\n' : '\n',
                        r'\f' : '\f',
                        r'\r' : '\r',
                    }
                    for wslit,wschar in ws_map.items():
                        ret = ret.replace(wslit, wschar)

                # replace escaped characters
                if self.escChar:
                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)

                # replace escaped quotes
                if self.escQuote:
                    ret = ret.replace(self.escQuote, self.endQuoteChar)

        return loc, ret

    def __str__( self ):
        try:
            return super(QuotedString,self).__str__()
        except Exception:
            pass

        if self.strRepr is None:
            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)

        return self.strRepr


class CharsNotIn(Token):
    """
    Token for matching words composed of characters I{not} in a given set (will
    include whitespace in matched characters if not listed in the provided exclusion set - see example).
    Defined with string containing all disallowed characters, and an optional
    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a
    minimum value < 1 is not valid); the default values for C{max} and C{exact}
    are 0, meaning no maximum or exact length restriction.

    Example::
        # define a comma-separated-value as anything that is not a ','
        csv_value = CharsNotIn(',')
        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
    prints::
        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
    """
    def __init__( self, notChars, min=1, max=0, exact=0 ):
        super(CharsNotIn,self).__init__()
        self.skipWhitespace = False
        self.notChars = notChars

        if min < 1:
            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")

        self.minLen = min

        if max > 0:
            self.maxLen = max
        else:
            self.maxLen = _MAX_INT

        if exact > 0:
            self.maxLen = exact
            self.minLen = exact

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayReturnEmpty = ( self.minLen == 0 )
        self.mayIndexError = False

    def parseImpl( self, instring, loc, doActions=True ):
        if instring[loc] in self.notChars:
            raise ParseException(instring, loc, self.errmsg, self)

        start = loc
        loc += 1
        notchars = self.notChars
        maxlen = min( start+self.maxLen, len(instring) )
        while loc < maxlen and \
              (instring[loc] not in notchars):
            loc += 1

        if loc - start < self.minLen:
            raise ParseException(instring, loc, self.errmsg, self)

        return loc, instring[start:loc]

    def __str__( self ):
        try:
            return super(CharsNotIn, self).__str__()
        except Exception:
            pass

        if self.strRepr is None:
            if len(self.notChars) > 4:
                self.strRepr = "!W:(%s...)" % self.notChars[:4]
            else:
                self.strRepr = "!W:(%s)" % self.notChars

        return self.strRepr

class White(Token):
    """
    Special matching class for matching whitespace.  Normally, whitespace is ignored
    by pyparsing grammars.  This class is included when some whitespace structures
    are significant.  Define with a string containing the whitespace characters to be
    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,
    as defined for the C{L{Word}} class.
    """
    whiteStrs = {
        " " : "",
        "\t": "",
        "\n": "",
        "\r": "",
        "\f": "",
        }
    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
        super(White,self).__init__()
        self.matchWhite = ws
        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
        #~ self.leaveWhitespace()
        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
        self.mayReturnEmpty = True
        self.errmsg = "Expected " + self.name

        self.minLen = min

        if max > 0:
            self.maxLen = max
        else:
            self.maxLen = _MAX_INT

        if exact > 0:
            self.maxLen = exact
            self.minLen = exact

    def parseImpl( self, instring, loc, doActions=True ):
        if not(instring[ loc ] in self.matchWhite):
            raise ParseException(instring, loc, self.errmsg, self)
        start = loc
        loc += 1
        maxloc = start + self.maxLen
        maxloc = min( maxloc, len(instring) )
        while loc < maxloc and instring[loc] in self.matchWhite:
            loc += 1

        if loc - start < self.minLen:
            raise ParseException(instring, loc, self.errmsg, self)

        return loc, instring[start:loc]


class _PositionToken(Token):
    def __init__( self ):
        super(_PositionToken,self).__init__()
        self.name=self.__class__.__name__
        self.mayReturnEmpty = True
        self.mayIndexError = False

class GoToColumn(_PositionToken):
    """
    Token to advance to a specific column of input text; useful for tabular report scraping.
    """
    def __init__( self, colno ):
        super(GoToColumn,self).__init__()
        self.col = colno

    def preParse( self, instring, loc ):
        if col(loc,instring) != self.col:
            instrlen = len(instring)
            if self.ignoreExprs:
                loc = self._skipIgnorables( instring, loc )
            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
                loc += 1
        return loc

    def parseImpl( self, instring, loc, doActions=True ):
        thiscol = col( loc, instring )
        if thiscol > self.col:
            raise ParseException( instring, loc, "Text not in expected column", self )
        newloc = loc + self.col - thiscol
        ret = instring[ loc: newloc ]
        return newloc, ret


class LineStart(_PositionToken):
    """
    Matches if current position is at the beginning of a line within the parse string
    
    Example::
    
        test = '''\
        AAA this line
        AAA and this line
          AAA but not this one
        B AAA and definitely not this one
        '''

        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
            print(t)
    
    Prints::
        ['AAA', ' this line']
        ['AAA', ' and this line']    

    """
    def __init__( self ):
        super(LineStart,self).__init__()
        self.errmsg = "Expected start of line"

    def parseImpl( self, instring, loc, doActions=True ):
        if col(loc, instring) == 1:
            return loc, []
        raise ParseException(instring, loc, self.errmsg, self)

class LineEnd(_PositionToken):
    """
    Matches if current position is at the end of a line within the parse string
    """
    def __init__( self ):
        super(LineEnd,self).__init__()
        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
        self.errmsg = "Expected end of line"

    def parseImpl( self, instring, loc, doActions=True ):
        if loc len(instring):
            return loc, []
        else:
            raise ParseException(instring, loc, self.errmsg, self)

class WordStart(_PositionToken):
    """
    Matches if the current position is at the beginning of a Word, and
    is not preceded by any character in a given set of C{wordChars}
    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
    the string being parsed, or at the beginning of a line.
    """
    def __init__(self, wordChars = printables):
        super(WordStart,self).__init__()
        self.wordChars = set(wordChars)
        self.errmsg = "Not at the start of a word"

    def parseImpl(self, instring, loc, doActions=True ):
        if loc != 0:
            if (instring[loc-1] in self.wordChars or
                instring[loc] not in self.wordChars):
                raise ParseException(instring, loc, self.errmsg, self)
        return loc, []

class WordEnd(_PositionToken):
    """
    Matches if the current position is at the end of a Word, and
    is not followed by any character in a given set of C{wordChars}
    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
    the string being parsed, or at the end of a line.
    """
    def __init__(self, wordChars = printables):
        super(WordEnd,self).__init__()
        self.wordChars = set(wordChars)
        self.skipWhitespace = False
        self.errmsg = "Not at the end of a word"

    def parseImpl(self, instring, loc, doActions=True ):
        instrlen = len(instring)
        if instrlen>0 and loc maxExcLoc:
                    maxException = err
                    maxExcLoc = err.loc
            except IndexError:
                if len(instring) > maxExcLoc:
                    maxException = ParseException(instring,len(instring),e.errmsg,self)
                    maxExcLoc = len(instring)
            else:
                # save match among all matches, to retry longest to shortest
                matches.append((loc2, e))

        if matches:
            matches.sort(key=lambda x: -x[0])
            for _,e in matches:
                try:
                    return e._parse( instring, loc, doActions )
                except ParseException as err:
                    err.__traceback__ = None
                    if err.loc > maxExcLoc:
                        maxException = err
                        maxExcLoc = err.loc

        if maxException is not None:
            maxException.msg = self.errmsg
            raise maxException
        else:
            raise ParseException(instring, loc, "no defined alternatives to match", self)


    def __ixor__(self, other ):
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        return self.append( other ) #Or( [ self, other ] )

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"

        return self.strRepr

    def checkRecursion( self, parseElementList ):
        subRecCheckList = parseElementList[:] + [ self ]
        for e in self.exprs:
            e.checkRecursion( subRecCheckList )


class MatchFirst(ParseExpression):
    """
    Requires that at least one C{ParseExpression} is found.
    If two expressions match, the first one listed is the one that will match.
    May be constructed using the C{'|'} operator.

    Example::
        # construct MatchFirst using '|' operator
        
        # watch the order of expressions to match
        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]

        # put more selective expression first
        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
    """
    def __init__( self, exprs, savelist = False ):
        super(MatchFirst,self).__init__(exprs, savelist)
        if self.exprs:
            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
        else:
            self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        maxExcLoc = -1
        maxException = None
        for e in self.exprs:
            try:
                ret = e._parse( instring, loc, doActions )
                return ret
            except ParseException as err:
                if err.loc > maxExcLoc:
                    maxException = err
                    maxExcLoc = err.loc
            except IndexError:
                if len(instring) > maxExcLoc:
                    maxException = ParseException(instring,len(instring),e.errmsg,self)
                    maxExcLoc = len(instring)

        # only got here if no expression matched, raise exception for match that made it the furthest
        else:
            if maxException is not None:
                maxException.msg = self.errmsg
                raise maxException
            else:
                raise ParseException(instring, loc, "no defined alternatives to match", self)

    def __ior__(self, other ):
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        return self.append( other ) #MatchFirst( [ self, other ] )

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"

        return self.strRepr

    def checkRecursion( self, parseElementList ):
        subRecCheckList = parseElementList[:] + [ self ]
        for e in self.exprs:
            e.checkRecursion( subRecCheckList )


class Each(ParseExpression):
    """
    Requires all given C{ParseExpression}s to be found, but in any order.
    Expressions may be separated by whitespace.
    May be constructed using the C{'&'} operator.

    Example::
        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
        integer = Word(nums)
        shape_attr = "shape:" + shape_type("shape")
        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
        color_attr = "color:" + color("color")
        size_attr = "size:" + integer("size")

        # use Each (using operator '&') to accept attributes in any order 
        # (shape and posn are required, color and size are optional)
        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)

        shape_spec.runTests('''
            shape: SQUARE color: BLACK posn: 100, 120
            shape: CIRCLE size: 50 color: BLUE posn: 50,80
            color:GREEN size:20 shape:TRIANGLE posn:20,40
            '''
            )
    prints::
        shape: SQUARE color: BLACK posn: 100, 120
        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
        - color: BLACK
        - posn: ['100', ',', '120']
          - x: 100
          - y: 120
        - shape: SQUARE


        shape: CIRCLE size: 50 color: BLUE posn: 50,80
        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
        - color: BLUE
        - posn: ['50', ',', '80']
          - x: 50
          - y: 80
        - shape: CIRCLE
        - size: 50


        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
        - color: GREEN
        - posn: ['20', ',', '40']
          - x: 20
          - y: 40
        - shape: TRIANGLE
        - size: 20
    """
    def __init__( self, exprs, savelist = True ):
        super(Each,self).__init__(exprs, savelist)
        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
        self.skipWhitespace = True
        self.initExprGroups = True

    def parseImpl( self, instring, loc, doActions=True ):
        if self.initExprGroups:
            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))
            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]
            self.optionals = opt1 + opt2
            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
            self.required += self.multirequired
            self.initExprGroups = False
        tmpLoc = loc
        tmpReqd = self.required[:]
        tmpOpt  = self.optionals[:]
        matchOrder = []

        keepMatching = True
        while keepMatching:
            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
            failed = []
            for e in tmpExprs:
                try:
                    tmpLoc = e.tryParse( instring, tmpLoc )
                except ParseException:
                    failed.append(e)
                else:
                    matchOrder.append(self.opt1map.get(id(e),e))
                    if e in tmpReqd:
                        tmpReqd.remove(e)
                    elif e in tmpOpt:
                        tmpOpt.remove(e)
            if len(failed) == len(tmpExprs):
                keepMatching = False

        if tmpReqd:
            missing = ", ".join(_ustr(e) for e in tmpReqd)
            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )

        # add any unmatched Optionals, in case they have default values defined
        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]

        resultlist = []
        for e in matchOrder:
            loc,results = e._parse(instring,loc,doActions)
            resultlist.append(results)

        finalResults = sum(resultlist, ParseResults([]))
        return loc, finalResults

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"

        return self.strRepr

    def checkRecursion( self, parseElementList ):
        subRecCheckList = parseElementList[:] + [ self ]
        for e in self.exprs:
            e.checkRecursion( subRecCheckList )


class ParseElementEnhance(ParserElement):
    """
    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.
    """
    def __init__( self, expr, savelist=False ):
        super(ParseElementEnhance,self).__init__(savelist)
        if isinstance( expr, basestring ):
            if issubclass(ParserElement._literalStringClass, Token):
                expr = ParserElement._literalStringClass(expr)
            else:
                expr = ParserElement._literalStringClass(Literal(expr))
        self.expr = expr
        self.strRepr = None
        if expr is not None:
            self.mayIndexError = expr.mayIndexError
            self.mayReturnEmpty = expr.mayReturnEmpty
            self.setWhitespaceChars( expr.whiteChars )
            self.skipWhitespace = expr.skipWhitespace
            self.saveAsList = expr.saveAsList
            self.callPreparse = expr.callPreparse
            self.ignoreExprs.extend(expr.ignoreExprs)

    def parseImpl( self, instring, loc, doActions=True ):
        if self.expr is not None:
            return self.expr._parse( instring, loc, doActions, callPreParse=False )
        else:
            raise ParseException("",loc,self.errmsg,self)

    def leaveWhitespace( self ):
        self.skipWhitespace = False
        self.expr = self.expr.copy()
        if self.expr is not None:
            self.expr.leaveWhitespace()
        return self

    def ignore( self, other ):
        if isinstance( other, Suppress ):
            if other not in self.ignoreExprs:
                super( ParseElementEnhance, self).ignore( other )
                if self.expr is not None:
                    self.expr.ignore( self.ignoreExprs[-1] )
        else:
            super( ParseElementEnhance, self).ignore( other )
            if self.expr is not None:
                self.expr.ignore( self.ignoreExprs[-1] )
        return self

    def streamline( self ):
        super(ParseElementEnhance,self).streamline()
        if self.expr is not None:
            self.expr.streamline()
        return self

    def checkRecursion( self, parseElementList ):
        if self in parseElementList:
            raise RecursiveGrammarException( parseElementList+[self] )
        subRecCheckList = parseElementList[:] + [ self ]
        if self.expr is not None:
            self.expr.checkRecursion( subRecCheckList )

    def validate( self, validateTrace=[] ):
        tmp = validateTrace[:]+[self]
        if self.expr is not None:
            self.expr.validate(tmp)
        self.checkRecursion( [] )

    def __str__( self ):
        try:
            return super(ParseElementEnhance,self).__str__()
        except Exception:
            pass

        if self.strRepr is None and self.expr is not None:
            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
        return self.strRepr


class FollowedBy(ParseElementEnhance):
    """
    Lookahead matching of the given parse expression.  C{FollowedBy}
    does I{not} advance the parsing position within the input string, it only
    verifies that the specified parse expression matches at the current
    position.  C{FollowedBy} always returns a null token list.

    Example::
        # use FollowedBy to match a label only if it is followed by a ':'
        data_word = Word(alphas)
        label = data_word + FollowedBy(':')
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        
        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
    prints::
        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
    """
    def __init__( self, expr ):
        super(FollowedBy,self).__init__(expr)
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        self.expr.tryParse( instring, loc )
        return loc, []


class NotAny(ParseElementEnhance):
    """
    Lookahead to disallow matching with the given parse expression.  C{NotAny}
    does I{not} advance the parsing position within the input string, it only
    verifies that the specified parse expression does I{not} match at the current
    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}
    always returns a null token list.  May be constructed using the '~' operator.

    Example::
        
    """
    def __init__( self, expr ):
        super(NotAny,self).__init__(expr)
        #~ self.leaveWhitespace()
        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
        self.mayReturnEmpty = True
        self.errmsg = "Found unwanted token, "+_ustr(self.expr)

    def parseImpl( self, instring, loc, doActions=True ):
        if self.expr.canParseNext(instring, loc):
            raise ParseException(instring, loc, self.errmsg, self)
        return loc, []

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "~{" + _ustr(self.expr) + "}"

        return self.strRepr

class _MultipleMatch(ParseElementEnhance):
    def __init__( self, expr, stopOn=None):
        super(_MultipleMatch, self).__init__(expr)
        self.saveAsList = True
        ender = stopOn
        if isinstance(ender, basestring):
            ender = ParserElement._literalStringClass(ender)
        self.not_ender = ~ender if ender is not None else None

    def parseImpl( self, instring, loc, doActions=True ):
        self_expr_parse = self.expr._parse
        self_skip_ignorables = self._skipIgnorables
        check_ender = self.not_ender is not None
        if check_ender:
            try_not_ender = self.not_ender.tryParse
        
        # must be at least one (but first see if we are the stopOn sentinel;
        # if so, fail)
        if check_ender:
            try_not_ender(instring, loc)
        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )
        try:
            hasIgnoreExprs = (not not self.ignoreExprs)
            while 1:
                if check_ender:
                    try_not_ender(instring, loc)
                if hasIgnoreExprs:
                    preloc = self_skip_ignorables( instring, loc )
                else:
                    preloc = loc
                loc, tmptokens = self_expr_parse( instring, preloc, doActions )
                if tmptokens or tmptokens.haskeys():
                    tokens += tmptokens
        except (ParseException,IndexError):
            pass

        return loc, tokens
        
class OneOrMore(_MultipleMatch):
    """
    Repetition of one or more of the given expression.
    
    Parameters:
     - expr - expression that must match one or more times
     - stopOn - (default=C{None}) - expression for a terminating sentinel
          (only required if the sentinel would ordinarily match the repetition 
          expression)          

    Example::
        data_word = Word(alphas)
        label = data_word + FollowedBy(':')
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

        text = "shape: SQUARE posn: upper left color: BLACK"
        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]

        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
        
        # could also be written as
        (attr_expr * (1,)).parseString(text).pprint()
    """

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + _ustr(self.expr) + "}..."

        return self.strRepr

class ZeroOrMore(_MultipleMatch):
    """
    Optional repetition of zero or more of the given expression.
    
    Parameters:
     - expr - expression that must match zero or more times
     - stopOn - (default=C{None}) - expression for a terminating sentinel
          (only required if the sentinel would ordinarily match the repetition 
          expression)          

    Example: similar to L{OneOrMore}
    """
    def __init__( self, expr, stopOn=None):
        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)
        self.mayReturnEmpty = True
        
    def parseImpl( self, instring, loc, doActions=True ):
        try:
            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)
        except (ParseException,IndexError):
            return loc, []

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "[" + _ustr(self.expr) + "]..."

        return self.strRepr

class _NullToken(object):
    def __bool__(self):
        return False
    __nonzero__ = __bool__
    def __str__(self):
        return ""

_optionalNotMatched = _NullToken()
class Optional(ParseElementEnhance):
    """
    Optional matching of the given expression.

    Parameters:
     - expr - expression that must match zero or more times
     - default (optional) - value to be returned if the optional expression is not found.

    Example::
        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
        zip.runTests('''
            # traditional ZIP code
            12345
            
            # ZIP+4 form
            12101-0001
            
            # invalid ZIP
            98765-
            ''')
    prints::
        # traditional ZIP code
        12345
        ['12345']

        # ZIP+4 form
        12101-0001
        ['12101-0001']

        # invalid ZIP
        98765-
             ^
        FAIL: Expected end of text (at char 5), (line:1, col:6)
    """
    def __init__( self, expr, default=_optionalNotMatched ):
        super(Optional,self).__init__( expr, savelist=False )
        self.saveAsList = self.expr.saveAsList
        self.defaultValue = default
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        try:
            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
        except (ParseException,IndexError):
            if self.defaultValue is not _optionalNotMatched:
                if self.expr.resultsName:
                    tokens = ParseResults([ self.defaultValue ])
                    tokens[self.expr.resultsName] = self.defaultValue
                else:
                    tokens = [ self.defaultValue ]
            else:
                tokens = []
        return loc, tokens

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "[" + _ustr(self.expr) + "]"

        return self.strRepr

class SkipTo(ParseElementEnhance):
    """
    Token for skipping over all undefined text until the matched expression is found.

    Parameters:
     - expr - target expression marking the end of the data to be skipped
     - include - (default=C{False}) if True, the target expression is also parsed 
          (the skipped text and target expression are returned as a 2-element list).
     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 
          comments) that might contain false matches to the target expression
     - failOn - (default=C{None}) define expressions that are not allowed to be 
          included in the skipped test; if found before the target expression is found, 
          the SkipTo is not a match

    Example::
        report = '''
            Outstanding Issues Report - 1 Jan 2000

               # | Severity | Description                               |  Days Open
            -----+----------+-------------------------------------------+-----------
             101 | Critical | Intermittent system crash                 |          6
              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
              79 | Minor    | System slow when running too many reports |         47
            '''
        integer = Word(nums)
        SEP = Suppress('|')
        # use SkipTo to simply match everything up until the next SEP
        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
        # - parse action will call token.strip() for each matched token, i.e., the description body
        string_data = SkipTo(SEP, ignore=quotedString)
        string_data.setParseAction(tokenMap(str.strip))
        ticket_expr = (integer("issue_num") + SEP 
                      + string_data("sev") + SEP 
                      + string_data("desc") + SEP 
                      + integer("days_open"))
        
        for tkt in ticket_expr.searchString(report):
            print tkt.dump()
    prints::
        ['101', 'Critical', 'Intermittent system crash', '6']
        - days_open: 6
        - desc: Intermittent system crash
        - issue_num: 101
        - sev: Critical
        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
        - days_open: 14
        - desc: Spelling error on Login ('log|n')
        - issue_num: 94
        - sev: Cosmetic
        ['79', 'Minor', 'System slow when running too many reports', '47']
        - days_open: 47
        - desc: System slow when running too many reports
        - issue_num: 79
        - sev: Minor
    """
    def __init__( self, other, include=False, ignore=None, failOn=None ):
        super( SkipTo, self ).__init__( other )
        self.ignoreExpr = ignore
        self.mayReturnEmpty = True
        self.mayIndexError = False
        self.includeMatch = include
        self.asList = False
        if isinstance(failOn, basestring):
            self.failOn = ParserElement._literalStringClass(failOn)
        else:
            self.failOn = failOn
        self.errmsg = "No match found for "+_ustr(self.expr)

    def parseImpl( self, instring, loc, doActions=True ):
        startloc = loc
        instrlen = len(instring)
        expr = self.expr
        expr_parse = self.expr._parse
        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None
        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
        
        tmploc = loc
        while tmploc <= instrlen:
            if self_failOn_canParseNext is not None:
                # break if failOn expression matches
                if self_failOn_canParseNext(instring, tmploc):
                    break
                    
            if self_ignoreExpr_tryParse is not None:
                # advance past ignore expressions
                while 1:
                    try:
                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
                    except ParseBaseException:
                        break
            
            try:
                expr_parse(instring, tmploc, doActions=False, callPreParse=False)
            except (ParseException, IndexError):
                # no match, advance loc in string
                tmploc += 1
            else:
                # matched skipto expr, done
                break

        else:
            # ran off the end of the input string without matching skipto expr, fail
            raise ParseException(instring, loc, self.errmsg, self)

        # build up return values
        loc = tmploc
        skiptext = instring[startloc:loc]
        skipresult = ParseResults(skiptext)
        
        if self.includeMatch:
            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)
            skipresult += mat

        return loc, skipresult

class Forward(ParseElementEnhance):
    """
    Forward declaration of an expression to be defined later -
    used for recursive grammars, such as algebraic infix notation.
    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.

    Note: take care when assigning to C{Forward} not to overlook precedence of operators.
    Specifically, '|' has a lower precedence than '<<', so that::
        fwdExpr << a | b | c
    will actually be evaluated as::
        (fwdExpr << a) | b | c
    thereby leaving b and c out as parseable alternatives.  It is recommended that you
    explicitly group the values inserted into the C{Forward}::
        fwdExpr << (a | b | c)
    Converting to use the '<<=' operator instead will avoid this problem.

    See L{ParseResults.pprint} for an example of a recursive parser created using
    C{Forward}.
    """
    def __init__( self, other=None ):
        super(Forward,self).__init__( other, savelist=False )

    def __lshift__( self, other ):
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass(other)
        self.expr = other
        self.strRepr = None
        self.mayIndexError = self.expr.mayIndexError
        self.mayReturnEmpty = self.expr.mayReturnEmpty
        self.setWhitespaceChars( self.expr.whiteChars )
        self.skipWhitespace = self.expr.skipWhitespace
        self.saveAsList = self.expr.saveAsList
        self.ignoreExprs.extend(self.expr.ignoreExprs)
        return self
        
    def __ilshift__(self, other):
        return self << other
    
    def leaveWhitespace( self ):
        self.skipWhitespace = False
        return self

    def streamline( self ):
        if not self.streamlined:
            self.streamlined = True
            if self.expr is not None:
                self.expr.streamline()
        return self

    def validate( self, validateTrace=[] ):
        if self not in validateTrace:
            tmp = validateTrace[:]+[self]
            if self.expr is not None:
                self.expr.validate(tmp)
        self.checkRecursion([])

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name
        return self.__class__.__name__ + ": ..."

        # stubbed out for now - creates awful memory and perf issues
        self._revertClass = self.__class__
        self.__class__ = _ForwardNoRecurse
        try:
            if self.expr is not None:
                retString = _ustr(self.expr)
            else:
                retString = "None"
        finally:
            self.__class__ = self._revertClass
        return self.__class__.__name__ + ": " + retString

    def copy(self):
        if self.expr is not None:
            return super(Forward,self).copy()
        else:
            ret = Forward()
            ret <<= self
            return ret

class _ForwardNoRecurse(Forward):
    def __str__( self ):
        return "..."

class TokenConverter(ParseElementEnhance):
    """
    Abstract subclass of C{ParseExpression}, for converting parsed results.
    """
    def __init__( self, expr, savelist=False ):
        super(TokenConverter,self).__init__( expr )#, savelist )
        self.saveAsList = False

class Combine(TokenConverter):
    """
    Converter to concatenate all matching tokens to a single string.
    By default, the matching patterns must also be contiguous in the input string;
    this can be disabled by specifying C{'adjacent=False'} in the constructor.

    Example::
        real = Word(nums) + '.' + Word(nums)
        print(real.parseString('3.1416')) # -> ['3', '.', '1416']
        # will also erroneously match the following
        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']

        real = Combine(Word(nums) + '.' + Word(nums))
        print(real.parseString('3.1416')) # -> ['3.1416']
        # no match when there are internal spaces
        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
    """
    def __init__( self, expr, joinString="", adjacent=True ):
        super(Combine,self).__init__( expr )
        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
        if adjacent:
            self.leaveWhitespace()
        self.adjacent = adjacent
        self.skipWhitespace = True
        self.joinString = joinString
        self.callPreparse = True

    def ignore( self, other ):
        if self.adjacent:
            ParserElement.ignore(self, other)
        else:
            super( Combine, self).ignore( other )
        return self

    def postParse( self, instring, loc, tokenlist ):
        retToks = tokenlist.copy()
        del retToks[:]
        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)

        if self.resultsName and retToks.haskeys():
            return [ retToks ]
        else:
            return retToks

class Group(TokenConverter):
    """
    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.

    Example::
        ident = Word(alphas)
        num = Word(nums)
        term = ident | num
        func = ident + Optional(delimitedList(term))
        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']

        func = ident + Group(Optional(delimitedList(term)))
        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]
    """
    def __init__( self, expr ):
        super(Group,self).__init__( expr )
        self.saveAsList = True

    def postParse( self, instring, loc, tokenlist ):
        return [ tokenlist ]

class Dict(TokenConverter):
    """
    Converter to return a repetitive expression as a list, but also as a dictionary.
    Each element can also be referenced using the first token in the expression as its key.
    Useful for tabular report scraping when the first column can be used as a item key.

    Example::
        data_word = Word(alphas)
        label = data_word + FollowedBy(':')
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        
        # print attributes as plain groups
        print(OneOrMore(attr_expr).parseString(text).dump())
        
        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
        print(result.dump())
        
        # access named fields as dict entries, or output as dict
        print(result['shape'])        
        print(result.asDict())
    prints::
        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']

        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
        - color: light blue
        - posn: upper left
        - shape: SQUARE
        - texture: burlap
        SQUARE
        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
    See more examples at L{ParseResults} of accessing fields by results name.
    """
    def __init__( self, expr ):
        super(Dict,self).__init__( expr )
        self.saveAsList = True

    def postParse( self, instring, loc, tokenlist ):
        for i,tok in enumerate(tokenlist):
            if len(tok) == 0:
                continue
            ikey = tok[0]
            if isinstance(ikey,int):
                ikey = _ustr(tok[0]).strip()
            if len(tok)==1:
                tokenlist[ikey] = _ParseResultsWithOffset("",i)
            elif len(tok)==2 and not isinstance(tok[1],ParseResults):
                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
            else:
                dictvalue = tok.copy() #ParseResults(i)
                del dictvalue[0]
                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):
                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
                else:
                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)

        if self.resultsName:
            return [ tokenlist ]
        else:
            return tokenlist


class Suppress(TokenConverter):
    """
    Converter for ignoring the results of a parsed expression.

    Example::
        source = "a, b, c,d"
        wd = Word(alphas)
        wd_list1 = wd + ZeroOrMore(',' + wd)
        print(wd_list1.parseString(source))

        # often, delimiters that are useful during parsing are just in the
        # way afterward - use Suppress to keep them out of the parsed output
        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
        print(wd_list2.parseString(source))
    prints::
        ['a', ',', 'b', ',', 'c', ',', 'd']
        ['a', 'b', 'c', 'd']
    (See also L{delimitedList}.)
    """
    def postParse( self, instring, loc, tokenlist ):
        return []

    def suppress( self ):
        return self


class OnlyOnce(object):
    """
    Wrapper for parse actions, to ensure they are only called once.
    """
    def __init__(self, methodCall):
        self.callable = _trim_arity(methodCall)
        self.called = False
    def __call__(self,s,l,t):
        if not self.called:
            results = self.callable(s,l,t)
            self.called = True
            return results
        raise ParseException(s,l,"")
    def reset(self):
        self.called = False

def traceParseAction(f):
    """
    Decorator for debugging parse actions. 
    
    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}
    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.

    Example::
        wd = Word(alphas)

        @traceParseAction
        def remove_duplicate_chars(tokens):
            return ''.join(sorted(set(''.join(tokens))))

        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
    prints::
        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
        <3:
            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )
        try:
            ret = f(*paArgs)
        except Exception as exc:
            sys.stderr.write( "< ['aa', 'bb', 'cc']
        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
    """
    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
    if combine:
        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)
    else:
        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)

def countedArray( expr, intExpr=None ):
    """
    Helper to define a counted list of expressions.
    This helper defines a pattern of the form::
        integer expr expr expr...
    where the leading integer tells how many expr expressions follow.
    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.
    
    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.

    Example::
        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']

        # in this parser, the leading integer value is given in binary,
        # '10' indicating that 2 values are in the array
        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']
    """
    arrayExpr = Forward()
    def countFieldParseAction(s,l,t):
        n = t[0]
        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))
        return []
    if intExpr is None:
        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))
    else:
        intExpr = intExpr.copy()
    intExpr.setName("arrayLen")
    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)
    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')

def _flatten(L):
    ret = []
    for i in L:
        if isinstance(i,list):
            ret.extend(_flatten(i))
        else:
            ret.append(i)
    return ret

def matchPreviousLiteral(expr):
    """
    Helper to define an expression that is indirectly defined from
    the tokens matched in a previous expression, that is, it looks
    for a 'repeat' of a previous expression.  For example::
        first = Word(nums)
        second = matchPreviousLiteral(first)
        matchExpr = first + ":" + second
    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a
    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.
    If this is not desired, use C{matchPreviousExpr}.
    Do I{not} use with packrat parsing enabled.
    """
    rep = Forward()
    def copyTokenToRepeater(s,l,t):
        if t:
            if len(t) == 1:
                rep << t[0]
            else:
                # flatten t tokens
                tflat = _flatten(t.asList())
                rep << And(Literal(tt) for tt in tflat)
        else:
            rep << Empty()
    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
    rep.setName('(prev) ' + _ustr(expr))
    return rep

def matchPreviousExpr(expr):
    """
    Helper to define an expression that is indirectly defined from
    the tokens matched in a previous expression, that is, it looks
    for a 'repeat' of a previous expression.  For example::
        first = Word(nums)
        second = matchPreviousExpr(first)
        matchExpr = first + ":" + second
    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by
    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};
    the expressions are evaluated first, and then compared, so
    C{"1"} is compared with C{"10"}.
    Do I{not} use with packrat parsing enabled.
    """
    rep = Forward()
    e2 = expr.copy()
    rep <<= e2
    def copyTokenToRepeater(s,l,t):
        matchTokens = _flatten(t.asList())
        def mustMatchTheseTokens(s,l,t):
            theseTokens = _flatten(t.asList())
            if  theseTokens != matchTokens:
                raise ParseException("",0,"")
        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )
    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
    rep.setName('(prev) ' + _ustr(expr))
    return rep

def _escapeRegexRangeChars(s):
    #~  escape these chars: ^-]
    for c in r"\^-]":
        s = s.replace(c,_bslash+c)
    s = s.replace("\n",r"\n")
    s = s.replace("\t",r"\t")
    return _ustr(s)

def oneOf( strs, caseless=False, useRegex=True ):
    """
    Helper to quickly define a set of alternative Literals, and makes sure to do
    longest-first testing when there is a conflict, regardless of the input order,
    but returns a C{L{MatchFirst}} for best performance.

    Parameters:
     - strs - a string of space-delimited literals, or a collection of string literals
     - caseless - (default=C{False}) - treat all literals as caseless
     - useRegex - (default=C{True}) - as an optimization, will generate a Regex
          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or
          if creating a C{Regex} raises an exception)

    Example::
        comp_oper = oneOf("< = > <= >= !=")
        var = Word(alphas)
        number = Word(nums)
        term = var | number
        comparison_expr = term + comp_oper + term
        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))
    prints::
        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
    """
    if caseless:
        isequal = ( lambda a,b: a.upper() == b.upper() )
        masks = ( lambda a,b: b.upper().startswith(a.upper()) )
        parseElementClass = CaselessLiteral
    else:
        isequal = ( lambda a,b: a == b )
        masks = ( lambda a,b: b.startswith(a) )
        parseElementClass = Literal

    symbols = []
    if isinstance(strs,basestring):
        symbols = strs.split()
    elif isinstance(strs, Iterable):
        symbols = list(strs)
    else:
        warnings.warn("Invalid argument to oneOf, expected string or iterable",
                SyntaxWarning, stacklevel=2)
    if not symbols:
        return NoMatch()

    i = 0
    while i < len(symbols)-1:
        cur = symbols[i]
        for j,other in enumerate(symbols[i+1:]):
            if ( isequal(other, cur) ):
                del symbols[i+j+1]
                break
            elif ( masks(cur, other) ):
                del symbols[i+j+1]
                symbols.insert(i,other)
                cur = other
                break
        else:
            i += 1

    if not caseless and useRegex:
        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
        try:
            if len(symbols)==len("".join(symbols)):
                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))
            else:
                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))
        except Exception:
            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
                    SyntaxWarning, stacklevel=2)


    # last resort, just use MatchFirst
    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))

def dictOf( key, value ):
    """
    Helper to easily and clearly define a dictionary by specifying the respective patterns
    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
    in the proper order.  The key pattern can include delimiting markers or punctuation,
    as long as they are suppressed, thereby leaving the significant key text.  The value
    pattern can include named results, so that the C{Dict} results can include named token
    fields.

    Example::
        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        print(OneOrMore(attr_expr).parseString(text).dump())
        
        attr_label = label
        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)

        # similar to Dict, but simpler call format
        result = dictOf(attr_label, attr_value).parseString(text)
        print(result.dump())
        print(result['shape'])
        print(result.shape)  # object attribute access works too
        print(result.asDict())
    prints::
        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
        - color: light blue
        - posn: upper left
        - shape: SQUARE
        - texture: burlap
        SQUARE
        SQUARE
        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
    """
    return Dict( ZeroOrMore( Group ( key + value ) ) )

def originalTextFor(expr, asString=True):
    """
    Helper to return the original, untokenized text for a given expression.  Useful to
    restore the parsed fields of an HTML start tag into the raw tag text itself, or to
    revert separate tokens with intervening whitespace back to the original matching
    input text. By default, returns astring containing the original parsed text.  
       
    If the optional C{asString} argument is passed as C{False}, then the return value is a 
    C{L{ParseResults}} containing any results names that were originally matched, and a 
    single token containing the original matched text from the input string.  So if 
    the expression passed to C{L{originalTextFor}} contains expressions with defined
    results names, you must set C{asString} to C{False} if you want to preserve those
    results name values.

    Example::
        src = "this is test  bold text  normal text "
        for tag in ("b","i"):
            opener,closer = makeHTMLTags(tag)
            patt = originalTextFor(opener + SkipTo(closer) + closer)
            print(patt.searchString(src)[0])
    prints::
        [' bold text ']
        ['text']
    """
    locMarker = Empty().setParseAction(lambda s,loc,t: loc)
    endlocMarker = locMarker.copy()
    endlocMarker.callPreparse = False
    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
    if asString:
        extractText = lambda s,l,t: s[t._original_start:t._original_end]
    else:
        def extractText(s,l,t):
            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
    matchExpr.setParseAction(extractText)
    matchExpr.ignoreExprs = expr.ignoreExprs
    return matchExpr

def ungroup(expr): 
    """
    Helper to undo pyparsing's default grouping of And expressions, even
    if all but one are non-empty.
    """
    return TokenConverter(expr).setParseAction(lambda t:t[0])

def locatedExpr(expr):
    """
    Helper to decorate a returned token with its starting and ending locations in the input string.
    This helper adds the following results names:
     - locn_start = location where matched expression begins
     - locn_end = location where matched expression ends
     - value = the actual parsed results

    Be careful if the input text contains C{} characters, you may want to call
    C{L{ParserElement.parseWithTabs}}

    Example::
        wd = Word(alphas)
        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
            print(match)
    prints::
        [[0, 'ljsdf', 5]]
        [[8, 'lksdjjf', 15]]
        [[18, 'lkkjj', 23]]
    """
    locator = Empty().setParseAction(lambda s,l,t: l)
    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))


# convenience constants for positional expressions
empty       = Empty().setName("empty")
lineStart   = LineStart().setName("lineStart")
lineEnd     = LineEnd().setName("lineEnd")
stringStart = StringStart().setName("stringStart")
stringEnd   = StringEnd().setName("stringEnd")

_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
_charRange = Group(_singleChar + Suppress("-") + _singleChar)
_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"

def srange(s):
    r"""
    Helper to easily define string ranges for use in Word construction.  Borrows
    syntax from regexp '[]' string range definitions::
        srange("[0-9]")   -> "0123456789"
        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
    The input string must be enclosed in []'s, and the returned string is the expanded
    character set joined into a single string.
    The values enclosed in the []'s may be:
     - a single character
     - an escaped character with a leading backslash (such as C{\-} or C{\]})
     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 
         (C{\0x##} is also supported for backwards compatibility) 
     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)
     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)
     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)
    """
    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))
    try:
        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
    except Exception:
        return ""

def matchOnlyAtCol(n):
    """
    Helper method for defining parse actions that require matching at a specific
    column in the input text.
    """
    def verifyCol(strg,locn,toks):
        if col(locn,strg) != n:
            raise ParseException(strg,locn,"matched token not at column %d" % n)
    return verifyCol

def replaceWith(replStr):
    """
    Helper method for common parse actions that simply return a literal value.  Especially
    useful when used with C{L{transformString}()}.

    Example::
        num = Word(nums).setParseAction(lambda toks: int(toks[0]))
        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
        term = na | num
        
        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
    """
    return lambda s,l,t: [replStr]

def removeQuotes(s,l,t):
    """
    Helper parse action for removing quotation marks from parsed quoted strings.

    Example::
        # by default, quotation marks are included in parsed results
        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]

        # use removeQuotes to strip quotation marks from parsed results
        quotedString.setParseAction(removeQuotes)
        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
    """
    return t[0][1:-1]

def tokenMap(func, *args):
    """
    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 
    args are passed, they are forwarded to the given function as additional arguments after
    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the
    parsed data to an integer using base 16.

    Example (compare the last to example in L{ParserElement.transformString}::
        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
        hex_ints.runTests('''
            00 11 22 aa FF 0a 0d 1a
            ''')
        
        upperword = Word(alphas).setParseAction(tokenMap(str.upper))
        OneOrMore(upperword).runTests('''
            my kingdom for a horse
            ''')

        wd = Word(alphas).setParseAction(tokenMap(str.title))
        OneOrMore(wd).setParseAction(' '.join).runTests('''
            now is the winter of our discontent made glorious summer by this sun of york
            ''')
    prints::
        00 11 22 aa FF 0a 0d 1a
        [0, 17, 34, 170, 255, 10, 13, 26]

        my kingdom for a horse
        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']

        now is the winter of our discontent made glorious summer by this sun of york
        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
    """
    def pa(s,l,t):
        return [func(tokn, *args) for tokn in t]

    try:
        func_name = getattr(func, '__name__', 
                            getattr(func, '__class__').__name__)
    except Exception:
        func_name = str(func)
    pa.__name__ = func_name

    return pa

upcaseTokens = tokenMap(lambda t: _ustr(t).upper())
"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""

downcaseTokens = tokenMap(lambda t: _ustr(t).lower())
"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""
    
def _makeTags(tagStr, xml):
    """Internal helper to construct opening and closing tag expressions, given a tag name"""
    if isinstance(tagStr,basestring):
        resname = tagStr
        tagStr = Keyword(tagStr, caseless=not xml)
    else:
        resname = tagStr.name

    tagAttrName = Word(alphas,alphanums+"_-:")
    if (xml):
        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
        openTag = Suppress("<") + tagStr("tag") + \
                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
    else:
        printablesLessRAbrack = "".join(c for c in printables if c not in ">")
        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
        openTag = Suppress("<") + tagStr("tag") + \
                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
                Optional( Suppress("=") + tagAttrValue ) ))) + \
                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
    closeTag = Combine(_L("")

    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)
    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("" % resname)
    openTag.tag = resname
    closeTag.tag = resname
    return openTag, closeTag

def makeHTMLTags(tagStr):
    """
    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches
    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.

    Example::
        text = 'More info at the pyparsing wiki page'
        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple
        a,a_end = makeHTMLTags("A")
        link_expr = a + SkipTo(a_end)("link_text") + a_end
        
        for link in link_expr.searchString(text):
            # attributes in the  tag (like "href" shown here) are also accessible as named results
            print(link.link_text, '->', link.href)
    prints::
        pyparsing -> http://pyparsing.wikispaces.com
    """
    return _makeTags( tagStr, False )

def makeXMLTags(tagStr):
    """
    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches
    tags only in the given upper/lower case.

    Example: similar to L{makeHTMLTags}
    """
    return _makeTags( tagStr, True )

def withAttribute(*args,**attrDict):
    """
    Helper to create a validating parse action to be used with start tags created
    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
    with a required attribute value, to avoid false matches on common tags such as
    C{} or C{
}.

    Call C{withAttribute} with a series of attribute names and values. Specify the list
    of filter attributes names and values as:
     - keyword arguments, as in C{(align="right")}, or
     - as an explicit dict with C{**} operator, when an attribute name is also a Python
          reserved word, as in C{**{"class":"Customer", "align":"right"}}
     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
    For attribute names with a namespace prefix, you must use the second form.  Attribute
    names are matched insensitive to upper/lower case.
       
    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.

    To verify that the attribute exists, but without specifying a value, pass
    C{withAttribute.ANY_VALUE} as the value.

    Example::
        html = '''
            

            Some text
            
1 4 0 1 0

            
1,3 2,3 1,1

            
this has no type

            

                
        '''
        div,div_end = makeHTMLTags("div")

        # only match div tag having a type attribute with value "grid"
        div_grid = div().setParseAction(withAttribute(type="grid"))
        grid_expr = div_grid + SkipTo(div | div_end)("body")
        for grid_header in grid_expr.searchString(html):
            print(grid_header.body)
        
        # construct a match with any div tag having a type attribute, regardless of the value
        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
        div_expr = div_any_type + SkipTo(div | div_end)("body")
        for div_header in div_expr.searchString(html):
            print(div_header.body)
    prints::
        1 4 0 1 0

        1 4 0 1 0
        1,3 2,3 1,1
    """
    if args:
        attrs = args[:]
    else:
        attrs = attrDict.items()
    attrs = [(k,v) for k,v in attrs]
    def pa(s,l,tokens):
        for attrName,attrValue in attrs:
            if attrName not in tokens:
                raise ParseException(s,l,"no matching attribute " + attrName)
            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
                                            (attrName, tokens[attrName], attrValue))
    return pa
withAttribute.ANY_VALUE = object()

def withClass(classname, namespace=''):
    """
    Simplified version of C{L{withAttribute}} when matching on a div class - made
    difficult because C{class} is a reserved word in Python.

    Example::
        html = '''
            

            Some text
            
1 4 0 1 0

            
1,3 2,3 1,1

            
this <div> has no class

            

                
        '''
        div,div_end = makeHTMLTags("div")
        div_grid = div().setParseAction(withClass("grid"))
        
        grid_expr = div_grid + SkipTo(div | div_end)("body")
        for grid_header in grid_expr.searchString(html):
            print(grid_header.body)
        
        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
        div_expr = div_any_type + SkipTo(div | div_end)("body")
        for div_header in div_expr.searchString(html):
            print(div_header.body)
    prints::
        1 4 0 1 0

        1 4 0 1 0
        1,3 2,3 1,1
    """
    classattr = "%s:class" % namespace if namespace else "class"
    return withAttribute(**{classattr : classname})        

opAssoc = _Constants()
opAssoc.LEFT = object()
opAssoc.RIGHT = object()

def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
    """
    Helper method for constructing grammars of expressions made up of
    operators working in a precedence hierarchy.  Operators may be unary or
    binary, left- or right-associative.  Parse actions can also be attached
    to operator expressions. The generated parser will also recognize the use 
    of parentheses to override operator precedences (see example below).
    
    Note: if you define a deep operator list, you may see performance issues
    when using infixNotation. See L{ParserElement.enablePackrat} for a
    mechanism to potentially improve your parser performance.

    Parameters:
     - baseExpr - expression representing the most basic element for the nested
     - opList - list of tuples, one for each operator precedence level in the
      expression grammar; each tuple is of the form
      (opExpr, numTerms, rightLeftAssoc, parseAction), where:
       - opExpr is the pyparsing expression for the operator;
          may also be a string, which will be converted to a Literal;
          if numTerms is 3, opExpr is a tuple of two expressions, for the
          two operators separating the 3 terms
       - numTerms is the number of terms for this operator (must
          be 1, 2, or 3)
       - rightLeftAssoc is the indicator whether the operator is
          right or left associative, using the pyparsing-defined
          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
       - parseAction is the parse action to be associated with
          expressions matching this operator expression (the
          parse action tuple member may be omitted); if the parse action
          is passed a tuple or list of functions, this is equivalent to
          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})
     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})
     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})

    Example::
        # simple example of four-function arithmetic with ints and variable names
        integer = pyparsing_common.signed_integer
        varname = pyparsing_common.identifier 
        
        arith_expr = infixNotation(integer | varname,
            [
            ('-', 1, opAssoc.RIGHT),
            (oneOf('* /'), 2, opAssoc.LEFT),
            (oneOf('+ -'), 2, opAssoc.LEFT),
            ])
        
        arith_expr.runTests('''
            5+3*6
            (5+3)*6
            -2--11
            ''', fullDump=False)
    prints::
        5+3*6
        [[5, '+', [3, '*', 6]]]

        (5+3)*6
        [[[5, '+', 3], '*', 6]]

        -2--11
        [[['-', 2], '-', ['-', 11]]]
    """
    ret = Forward()
    lastExpr = baseExpr | ( lpar + ret + rpar )
    for i,operDef in enumerate(opList):
        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
        if arity == 3:
            if opExpr is None or len(opExpr) != 2:
                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
            opExpr1, opExpr2 = opExpr
        thisExpr = Forward().setName(termName)
        if rightLeftAssoc == opAssoc.LEFT:
            if arity == 1:
                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
            elif arity == 2:
                if opExpr is not None:
                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
                else:
                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
            elif arity == 3:
                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
            else:
                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
        elif rightLeftAssoc == opAssoc.RIGHT:
            if arity == 1:
                # try to avoid LR with this extra test
                if not isinstance(opExpr, Optional):
                    opExpr = Optional(opExpr)
                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
            elif arity == 2:
                if opExpr is not None:
                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
                else:
                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
            elif arity == 3:
                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
            else:
                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
        else:
            raise ValueError("operator must indicate right or left associativity")
        if pa:
            if isinstance(pa, (tuple, list)):
                matchExpr.setParseAction(*pa)
            else:
                matchExpr.setParseAction(pa)
        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )
        lastExpr = thisExpr
    ret <<= lastExpr
    return ret

operatorPrecedence = infixNotation
"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""

dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")
sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")
quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|
                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")
unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")

def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
    """
    Helper method for defining nested lists enclosed in opening and closing
    delimiters ("(" and ")" are the default).

    Parameters:
     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression
     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression
     - content - expression for items within the nested lists (default=C{None})
     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})

    If an expression is not provided for the content argument, the nested
    expression will capture all whitespace-delimited content between delimiters
    as a list of separate values.

    Use the C{ignoreExpr} argument to define expressions that may contain
    opening or closing characters that should not be treated as opening
    or closing characters for nesting, such as quotedString or a comment
    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
    The default is L{quotedString}, but if no expressions are to be ignored,
    then pass C{None} for this argument.

    Example::
        data_type = oneOf("void int short long char float double")
        decl_data_type = Combine(data_type + Optional(Word('*')))
        ident = Word(alphas+'_', alphanums+'_')
        number = pyparsing_common.number
        arg = Group(decl_data_type + ident)
        LPAR,RPAR = map(Suppress, "()")

        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))

        c_function = (decl_data_type("type") 
                      + ident("name")
                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 
                      + code_body("body"))
        c_function.ignore(cStyleComment)
        
        source_code = '''
            int is_odd(int x) { 
                return (x%2); 
            }
                
            int dec_to_hex(char hchar) { 
                if (hchar >= '0' && hchar <= '9') { 
                    return (ord(hchar)-ord('0')); 
                } else { 
                    return (10+ord(hchar)-ord('A'));
                } 
            }
        '''
        for func in c_function.searchString(source_code):
            print("%(name)s (%(type)s) args: %(args)s" % func)

    prints::
        is_odd (int) args: [['int', 'x']]
        dec_to_hex (int) args: [['char', 'hchar']]
    """
    if opener == closer:
        raise ValueError("opening and closing strings cannot be the same")
    if content is None:
        if isinstance(opener,basestring) and isinstance(closer,basestring):
            if len(opener) == 1 and len(closer)==1:
                if ignoreExpr is not None:
                    content = (Combine(OneOrMore(~ignoreExpr +
                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
                                ).setParseAction(lambda t:t[0].strip()))
                else:
                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
                                ).setParseAction(lambda t:t[0].strip()))
            else:
                if ignoreExpr is not None:
                    content = (Combine(OneOrMore(~ignoreExpr + 
                                    ~Literal(opener) + ~Literal(closer) +
                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
                                ).setParseAction(lambda t:t[0].strip()))
                else:
                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
                                ).setParseAction(lambda t:t[0].strip()))
        else:
            raise ValueError("opening and closing arguments must be strings if no content expression is given")
    ret = Forward()
    if ignoreExpr is not None:
        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
    else:
        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )
    ret.setName('nested %s%s expression' % (opener,closer))
    return ret

def indentedBlock(blockStatementExpr, indentStack, indent=True):
    """
    Helper method for defining space-delimited indentation blocks, such as
    those used to define block statements in Python source code.

    Parameters:
     - blockStatementExpr - expression defining syntax of statement that
            is repeated within the indented block
     - indentStack - list created by caller to manage indentation stack
            (multiple statementWithIndentedBlock expressions within a single grammar
            should share a common indentStack)
     - indent - boolean indicating whether block must be indented beyond the
            the current level; set to False for block of left-most statements
            (default=C{True})

    A valid block must contain at least one C{blockStatement}.

    Example::
        data = '''
        def A(z):
          A1
          B = 100
          G = A2
          A2
          A3
        B
        def BB(a,b,c):
          BB1
          def BBA():
            bba1
            bba2
            bba3
        C
        D
        def spam(x,y):
             def eggs(z):
                 pass
        '''


        indentStack = [1]
        stmt = Forward()

        identifier = Word(alphas, alphanums)
        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")
        func_body = indentedBlock(stmt, indentStack)
        funcDef = Group( funcDecl + func_body )

        rvalue = Forward()
        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
        rvalue << (funcCall | identifier | Word(nums))
        assignment = Group(identifier + "=" + rvalue)
        stmt << ( funcDef | assignment | identifier )

        module_body = OneOrMore(stmt)

        parseTree = module_body.parseString(data)
        parseTree.pprint()
    prints::
        [['def',
          'A',
          ['(', 'z', ')'],
          ':',
          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
         'B',
         ['def',
          'BB',
          ['(', 'a', 'b', 'c', ')'],
          ':',
          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
         'C',
         'D',
         ['def',
          'spam',
          ['(', 'x', 'y', ')'],
          ':',
          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 
    """
    def checkPeerIndent(s,l,t):
        if l >= len(s): return
        curCol = col(l,s)
        if curCol != indentStack[-1]:
            if curCol > indentStack[-1]:
                raise ParseFatalException(s,l,"illegal nesting")
            raise ParseException(s,l,"not a peer entry")

    def checkSubIndent(s,l,t):
        curCol = col(l,s)
        if curCol > indentStack[-1]:
            indentStack.append( curCol )
        else:
            raise ParseException(s,l,"not a subentry")

    def checkUnindent(s,l,t):
        if l >= len(s): return
        curCol = col(l,s)
        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
            raise ParseException(s,l,"not an unindent")
        indentStack.pop()

    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')
    PEER   = Empty().setParseAction(checkPeerIndent).setName('')
    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')
    if indent:
        smExpr = Group( Optional(NL) +
            #~ FollowedBy(blockStatementExpr) +
            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
    else:
        smExpr = Group( Optional(NL) +
            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
    blockStatementExpr.ignore(_bslash + LineEnd())
    return smExpr.setName('indented block')

alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")

anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))
_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))
commonHTMLEntity = Regex('&(?P' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")
def replaceHTMLEntity(t):
    """Helper parser action to replace common HTML entities with their special characters"""
    return _htmlEntityMap.get(t.entity)

# it's easy to get these comment structures wrong - they're very common, so may as well make them available
cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")
"Comment of the form C{/* ... */}"

htmlComment = Regex(r"").setName("HTML comment")
"Comment of the form C{}"

restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")
dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")
"Comment of the form C{// ... (to end of line)}"

cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")
"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"

javaStyleComment = cppStyleComment
"Same as C{L{cppStyleComment}}"

pythonStyleComment = Regex(r"#.*").setName("Python style comment")
"Comment of the form C{# ... (to end of line)}"

_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +
                                  Optional( Word(" \t") +
                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")
"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.
   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""

# some other useful expressions - using lower-case class name since we are really using this as a namespace
class pyparsing_common:
    """
    Here are some common low-level expressions that may be useful in jump-starting parser development:
     - numeric forms (L{integers}, L{reals}, L{scientific notation})
     - common L{programming identifiers}
     - network addresses (L{MAC}, L{IPv4}, L{IPv6})
     - ISO8601 L{dates} and L{datetime}
     - L{UUID}
     - L{comma-separated list}
    Parse actions:
     - C{L{convertToInteger}}
     - C{L{convertToFloat}}
     - C{L{convertToDate}}
     - C{L{convertToDatetime}}
     - C{L{stripHTMLTags}}
     - C{L{upcaseTokens}}
     - C{L{downcaseTokens}}

    Example::
        pyparsing_common.number.runTests('''
            # any int or real number, returned as the appropriate type
            100
            -100
            +100
            3.14159
            6.02e23
            1e-12
            ''')

        pyparsing_common.fnumber.runTests('''
            # any int or real number, returned as float
            100
            -100
            +100
            3.14159
            6.02e23
            1e-12
            ''')

        pyparsing_common.hex_integer.runTests('''
            # hex numbers
            100
            FF
            ''')

        pyparsing_common.fraction.runTests('''
            # fractions
            1/2
            -3/4
            ''')

        pyparsing_common.mixed_integer.runTests('''
            # mixed fractions
            1
            1/2
            -3/4
            1-3/4
            ''')

        import uuid
        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
        pyparsing_common.uuid.runTests('''
            # uuid
            12345678-1234-5678-1234-567812345678
            ''')
    prints::
        # any int or real number, returned as the appropriate type
        100
        [100]

        -100
        [-100]

        +100
        [100]

        3.14159
        [3.14159]

        6.02e23
        [6.02e+23]

        1e-12
        [1e-12]

        # any int or real number, returned as float
        100
        [100.0]

        -100
        [-100.0]

        +100
        [100.0]

        3.14159
        [3.14159]

        6.02e23
        [6.02e+23]

        1e-12
        [1e-12]

        # hex numbers
        100
        [256]

        FF
        [255]

        # fractions
        1/2
        [0.5]

        -3/4
        [-0.75]

        # mixed fractions
        1
        [1]

        1/2
        [0.5]

        -3/4
        [-0.75]

        1-3/4
        [1.75]

        # uuid
        12345678-1234-5678-1234-567812345678
        [UUID('12345678-1234-5678-1234-567812345678')]
    """

    convertToInteger = tokenMap(int)
    """
    Parse action for converting parsed integers to Python int
    """

    convertToFloat = tokenMap(float)
    """
    Parse action for converting parsed numbers to Python float
    """

    integer = Word(nums).setName("integer").setParseAction(convertToInteger)
    """expression that parses an unsigned integer, returns an int"""

    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))
    """expression that parses a hexadecimal integer, returns an int"""

    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)
    """expression that parses an integer with optional leading sign, returns an int"""

    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")
    """fractional expression of an integer divided by an integer, returns a float"""
    fraction.addParseAction(lambda t: t[0]/t[-1])

    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")
    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
    mixed_integer.addParseAction(sum)

    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)
    """expression that parses a floating point number and returns a float"""

    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)
    """expression that parses a floating point number with optional scientific notation and returns a float"""

    # streamlining this expression makes the docs nicer-looking
    number = (sci_real | real | signed_integer).streamline()
    """any numeric expression, returns the corresponding Python type"""

    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)
    """any int or real number, returned as float"""
    
    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")
    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
    
    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")
    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"

    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")
    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")
    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")
    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)
    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")
    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")
    "IPv6 address (long, short, or mixed form)"
    
    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")
    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"

    @staticmethod
    def convertToDate(fmt="%Y-%m-%d"):
        """
        Helper to create a parse action for converting parsed date string to Python datetime.date

        Params -
         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})

        Example::
            date_expr = pyparsing_common.iso8601_date.copy()
            date_expr.setParseAction(pyparsing_common.convertToDate())
            print(date_expr.parseString("1999-12-31"))
        prints::
            [datetime.date(1999, 12, 31)]
        """
        def cvt_fn(s,l,t):
            try:
                return datetime.strptime(t[0], fmt).date()
            except ValueError as ve:
                raise ParseException(s, l, str(ve))
        return cvt_fn

    @staticmethod
    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
        """
        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime

        Params -
         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})

        Example::
            dt_expr = pyparsing_common.iso8601_datetime.copy()
            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
        prints::
            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
        """
        def cvt_fn(s,l,t):
            try:
                return datetime.strptime(t[0], fmt)
            except ValueError as ve:
                raise ParseException(s, l, str(ve))
        return cvt_fn

    iso8601_date = Regex(r'(?P\d{4})(?:-(?P\d\d)(?:-(?P\d\d))?)?').setName("ISO8601 date")
    "ISO8601 date (C{yyyy-mm-dd})"

    iso8601_datetime = Regex(r'(?P\d{4})-(?P\d\d)-(?P\d\d)[T ](?P\d\d):(?P\d\d)(:(?P\d\d(\.\d*)?)?)?(?PZ|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")
    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"

    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")
    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"

    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()
    @staticmethod
    def stripHTMLTags(s, l, tokens):
        """
        Parse action to remove HTML tags from web page HTML source

        Example::
            # strip HTML links from normal text 
            text = 'More info at the pyparsing wiki page'
            td,td_end = makeHTMLTags("TD")
            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
            
            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'
        """
        return pyparsing_common._html_stripper.transformString(tokens[0])

    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 
                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")
    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")
    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""

    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))
    """Parse action to convert tokens to upper case."""

    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))
    """Parse action to convert tokens to lower case."""


if __name__ == "__main__":

    selectToken    = CaselessLiteral("select")
    fromToken      = CaselessLiteral("from")

    ident          = Word(alphas, alphanums + "_$")

    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
    columnNameList = Group(delimitedList(columnName)).setName("columns")
    columnSpec     = ('*' | columnNameList)

    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
    tableNameList  = Group(delimitedList(tableName)).setName("tables")
    
    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")

    # demo runTests method, including embedded comments in test string
    simpleSQL.runTests("""
        # '*' as column list and dotted table name
        select * from SYS.XYZZY

        # caseless match on "SELECT", and casts back to "select"
        SELECT * from XYZZY, ABC

        # list of column names, and mixed case SELECT keyword
        Select AA,BB,CC from Sys.dual

        # multiple tables
        Select A, B, C from Sys.dual, Table2

        # invalid SELECT keyword - should fail
        Xelect A, B, C from Sys.dual

        # incomplete command - should fail
        Select

        # invalid column name - should fail
        Select ^^^ frox Sys.dual

        """)

    pyparsing_common.number.runTests("""
        100
        -100
        +100
        3.14159
        6.02e23
        1e-12
        """)

    # any int or real number, returned as float
    pyparsing_common.fnumber.runTests("""
        100
        -100
        +100
        3.14159
        6.02e23
        1e-12
        """)

    pyparsing_common.hex_integer.runTests("""
        100
        FF
        """)

    import uuid
    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
    pyparsing_common.uuid.runTests("""
        12345678-1234-5678-1234-567812345678
        """)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/_vendor/vendored.txt0000644000175100001710000000006000000000000022246 0ustar00runnerdockerpackaging==21.2
pyparsing==2.2.1
appdirs==1.4.3
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/api_tests.txt0000644000175100001710000002767700000000000021026 0ustar00runnerdockerPluggable Distributions of Python Software
==========================================

Distributions
-------------

A "Distribution" is a collection of files that represent a "Release" of a
"Project" as of a particular point in time, denoted by a
"Version"::

    >>> import sys, pkg_resources
    >>> from pkg_resources import Distribution
    >>> Distribution(project_name="Foo", version="1.2")
    Foo 1.2

Distributions have a location, which can be a filename, URL, or really anything
else you care to use::

    >>> dist = Distribution(
    ...     location="http://example.com/something",
    ...     project_name="Bar", version="0.9"
    ... )

    >>> dist
    Bar 0.9 (http://example.com/something)


Distributions have various introspectable attributes::

    >>> dist.location
    'http://example.com/something'

    >>> dist.project_name
    'Bar'

    >>> dist.version
    '0.9'

    >>> dist.py_version == '{}.{}'.format(*sys.version_info)
    True

    >>> print(dist.platform)
    None

Including various computed attributes::

    >>> from pkg_resources import parse_version
    >>> dist.parsed_version == parse_version(dist.version)
    True

    >>> dist.key    # case-insensitive form of the project name
    'bar'

Distributions are compared (and hashed) by version first::

    >>> Distribution(version='1.0') == Distribution(version='1.0')
    True
    >>> Distribution(version='1.0') == Distribution(version='1.1')
    False
    >>> Distribution(version='1.0') <  Distribution(version='1.1')
    True

but also by project name (case-insensitive), platform, Python version,
location, etc.::

    >>> Distribution(project_name="Foo",version="1.0") == \
    ... Distribution(project_name="Foo",version="1.0")
    True

    >>> Distribution(project_name="Foo",version="1.0") == \
    ... Distribution(project_name="foo",version="1.0")
    True

    >>> Distribution(project_name="Foo",version="1.0") == \
    ... Distribution(project_name="Foo",version="1.1")
    False

    >>> Distribution(project_name="Foo",py_version="2.3",version="1.0") == \
    ... Distribution(project_name="Foo",py_version="2.4",version="1.0")
    False

    >>> Distribution(location="spam",version="1.0") == \
    ... Distribution(location="spam",version="1.0")
    True

    >>> Distribution(location="spam",version="1.0") == \
    ... Distribution(location="baz",version="1.0")
    False



Hash and compare distribution by prio/plat

Get version from metadata
provider capabilities
egg_name()
as_requirement()
from_location, from_filename (w/path normalization)

Releases may have zero or more "Requirements", which indicate
what releases of another project the release requires in order to
function.  A Requirement names the other project, expresses some criteria
as to what releases of that project are acceptable, and lists any "Extras"
that the requiring release may need from that project.  (An Extra is an
optional feature of a Release, that can only be used if its additional
Requirements are satisfied.)



The Working Set
---------------

A collection of active distributions is called a Working Set.  Note that a
Working Set can contain any importable distribution, not just pluggable ones.
For example, the Python standard library is an importable distribution that
will usually be part of the Working Set, even though it is not pluggable.
Similarly, when you are doing development work on a project, the files you are
editing are also a Distribution.  (And, with a little attention to the
directory names used,  and including some additional metadata, such a
"development distribution" can be made pluggable as well.)

    >>> from pkg_resources import WorkingSet

A working set's entries are the sys.path entries that correspond to the active
distributions.  By default, the working set's entries are the items on
``sys.path``::

    >>> ws = WorkingSet()
    >>> ws.entries == sys.path
    True

But you can also create an empty working set explicitly, and add distributions
to it::

    >>> ws = WorkingSet([])
    >>> ws.add(dist)
    >>> ws.entries
    ['http://example.com/something']
    >>> dist in ws
    True
    >>> Distribution('foo',version="") in ws
    False

And you can iterate over its distributions::

    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

Adding the same distribution more than once is a no-op::

    >>> ws.add(dist)
    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

For that matter, adding multiple distributions for the same project also does
nothing, because a working set can only hold one active distribution per
project -- the first one added to it::

    >>> ws.add(
    ...     Distribution(
    ...         'http://example.com/something', project_name="Bar",
    ...         version="7.2"
    ...     )
    ... )
    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

You can append a path entry to a working set using ``add_entry()``::

    >>> ws.entries
    ['http://example.com/something']
    >>> ws.add_entry(pkg_resources.__file__)
    >>> ws.entries
    ['http://example.com/something', '...pkg_resources...']

Multiple additions result in multiple entries, even if the entry is already in
the working set (because ``sys.path`` can contain the same entry more than
once)::

    >>> ws.add_entry(pkg_resources.__file__)
    >>> ws.entries
    ['...example.com...', '...pkg_resources...', '...pkg_resources...']

And you can specify the path entry a distribution was found under, using the
optional second parameter to ``add()``::

    >>> ws = WorkingSet([])
    >>> ws.add(dist,"foo")
    >>> ws.entries
    ['foo']

But even if a distribution is found under multiple path entries, it still only
shows up once when iterating the working set:

    >>> ws.add_entry(ws.entries[0])
    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

You can ask a WorkingSet to ``find()`` a distribution matching a requirement::

    >>> from pkg_resources import Requirement
    >>> print(ws.find(Requirement.parse("Foo==1.0")))   # no match, return None
    None

    >>> ws.find(Requirement.parse("Bar==0.9"))  # match, return distribution
    Bar 0.9 (http://example.com/something)

Note that asking for a conflicting version of a distribution already in a
working set triggers a ``pkg_resources.VersionConflict`` error:

    >>> try:
    ...     ws.find(Requirement.parse("Bar==1.0"))
    ... except pkg_resources.VersionConflict as exc:
    ...     print(str(exc))
    ... else:
    ...     raise AssertionError("VersionConflict was not raised")
    (Bar 0.9 (http://example.com/something), Requirement.parse('Bar==1.0'))

You can subscribe a callback function to receive notifications whenever a new
distribution is added to a working set.  The callback is immediately invoked
once for each existing distribution in the working set, and then is called
again for new distributions added thereafter::

    >>> def added(dist): print("Added %s" % dist)
    >>> ws.subscribe(added)
    Added Bar 0.9
    >>> foo12 = Distribution(project_name="Foo", version="1.2", location="f12")
    >>> ws.add(foo12)
    Added Foo 1.2

Note, however, that only the first distribution added for a given project name
will trigger a callback, even during the initial ``subscribe()`` callback::

    >>> foo14 = Distribution(project_name="Foo", version="1.4", location="f14")
    >>> ws.add(foo14)   # no callback, because Foo 1.2 is already active

    >>> ws = WorkingSet([])
    >>> ws.add(foo12)
    >>> ws.add(foo14)
    >>> ws.subscribe(added)
    Added Foo 1.2

And adding a callback more than once has no effect, either::

    >>> ws.subscribe(added)     # no callbacks

    # and no double-callbacks on subsequent additions, either
    >>> just_a_test = Distribution(project_name="JustATest", version="0.99")
    >>> ws.add(just_a_test)
    Added JustATest 0.99


Finding Plugins
---------------

``WorkingSet`` objects can be used to figure out what plugins in an
``Environment`` can be loaded without any resolution errors::

    >>> from pkg_resources import Environment

    >>> plugins = Environment([])   # normally, a list of plugin directories
    >>> plugins.add(foo12)
    >>> plugins.add(foo14)
    >>> plugins.add(just_a_test)

In the simplest case, we just get the newest version of each distribution in
the plugin environment::

    >>> ws = WorkingSet([])
    >>> ws.find_plugins(plugins)
    ([JustATest 0.99, Foo 1.4 (f14)], {})

But if there's a problem with a version conflict or missing requirements, the
method falls back to older versions, and the error info dict will contain an
exception instance for each unloadable plugin::

    >>> ws.add(foo12)   # this will conflict with Foo 1.4
    >>> ws.find_plugins(plugins)
    ([JustATest 0.99, Foo 1.2 (f12)], {Foo 1.4 (f14): VersionConflict(...)})

But if you disallow fallbacks, the failed plugin will be skipped instead of
trying older versions::

    >>> ws.find_plugins(plugins, fallback=False)
    ([JustATest 0.99], {Foo 1.4 (f14): VersionConflict(...)})



Platform Compatibility Rules
----------------------------

On the Mac, there are potential compatibility issues for modules compiled
on newer versions of macOS than what the user is running. Additionally,
macOS will soon have two platforms to contend with: Intel and PowerPC.

Basic equality works as on other platforms::

    >>> from pkg_resources import compatible_platforms as cp
    >>> reqd = 'macosx-10.4-ppc'
    >>> cp(reqd, reqd)
    True
    >>> cp("win32", reqd)
    False

Distributions made on other machine types are not compatible::

    >>> cp("macosx-10.4-i386", reqd)
    False

Distributions made on earlier versions of the OS are compatible, as
long as they are from the same top-level version. The patchlevel version
number does not matter::

    >>> cp("macosx-10.4-ppc", reqd)
    True
    >>> cp("macosx-10.3-ppc", reqd)
    True
    >>> cp("macosx-10.5-ppc", reqd)
    False
    >>> cp("macosx-9.5-ppc", reqd)
    False

Backwards compatibility for packages made via earlier versions of
setuptools is provided as well::

    >>> cp("darwin-8.2.0-Power_Macintosh", reqd)
    True
    >>> cp("darwin-7.2.0-Power_Macintosh", reqd)
    True
    >>> cp("darwin-8.2.0-Power_Macintosh", "macosx-10.3-ppc")
    False


Environment Markers
-------------------

    >>> from pkg_resources import invalid_marker as im, evaluate_marker as em
    >>> import os

    >>> print(im("sys_platform"))
    Invalid marker: 'sys_platform', parse error at ''

    >>> print(im("sys_platform=="))
    Invalid marker: 'sys_platform==', parse error at ''

    >>> print(im("sys_platform=='win32'"))
    False

    >>> print(im("sys=='x'"))
    Invalid marker: "sys=='x'", parse error at "sys=='x'"

    >>> print(im("(extra)"))
    Invalid marker: '(extra)', parse error at ')'

    >>> print(im("(extra"))
    Invalid marker: '(extra', parse error at ''

    >>> print(im("os.open('foo')=='y'"))
    Invalid marker: "os.open('foo')=='y'", parse error at 'os.open('

    >>> print(im("'x'=='y' and os.open('foo')=='y'"))   # no short-circuit!
    Invalid marker: "'x'=='y' and os.open('foo')=='y'", parse error at 'and os.o'

    >>> print(im("'x'=='x' or os.open('foo')=='y'"))   # no short-circuit!
    Invalid marker: "'x'=='x' or os.open('foo')=='y'", parse error at 'or os.op'

    >>> print(im("'x' < 'y' < 'z'"))
    Invalid marker: "'x' < 'y' < 'z'", parse error at "< 'z'"

    >>> print(im("r'x'=='x'"))
    Invalid marker: "r'x'=='x'", parse error at "r'x'=='x"

    >>> print(im("'''x'''=='x'"))
    Invalid marker: "'''x'''=='x'", parse error at "'x'''=='"

    >>> print(im('"""x"""=="x"'))
    Invalid marker: '"""x"""=="x"', parse error at '"x"""=="'

    >>> print(im(r"x\n=='x'"))
    Invalid marker: "x\\n=='x'", parse error at "x\\n=='x'"

    >>> print(im("os.open=='y'"))
    Invalid marker: "os.open=='y'", parse error at 'os.open='

    >>> em("sys_platform=='win32'") == (sys.platform=='win32')
    True

    >>> em("python_version >= '2.7'")
    True

    >>> em("python_version > '2.6'")
    True

    >>> im("implementation_name=='cpython'")
    False

    >>> im("platform_python_implementation=='CPython'")
    False

    >>> im("implementation_version=='3.5.1'")
    False
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9066699
setuptools-59.6.0/pkg_resources/extern/0000755000175100001710000000000000000000000017554 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/extern/__init__.py0000644000175100001710000000447200000000000021674 0ustar00runnerdockerimport importlib.util
import sys


class VendorImporter:
    """
    A PEP 302 meta path importer for finding optionally-vendored
    or otherwise naturally-installed packages from root_name.
    """

    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
        self.root_name = root_name
        self.vendored_names = set(vendored_names)
        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')

    @property
    def search_path(self):
        """
        Search first the vendor package then as a natural package.
        """
        yield self.vendor_pkg + '.'
        yield ''

    def _module_matches_namespace(self, fullname):
        """Figure out if the target module is vendored."""
        root, base, target = fullname.partition(self.root_name + '.')
        return not root and any(map(target.startswith, self.vendored_names))

    def load_module(self, fullname):
        """
        Iterate over the search path to locate and load fullname.
        """
        root, base, target = fullname.partition(self.root_name + '.')
        for prefix in self.search_path:
            try:
                extant = prefix + target
                __import__(extant)
                mod = sys.modules[extant]
                sys.modules[fullname] = mod
                return mod
            except ImportError:
                pass
        else:
            raise ImportError(
                "The '{target}' package is required; "
                "normally this is bundled with this package so if you get "
                "this warning, consult the packager of your "
                "distribution.".format(**locals())
            )

    def create_module(self, spec):
        return self.load_module(spec.name)

    def exec_module(self, module):
        pass

    def find_spec(self, fullname, path=None, target=None):
        """Return a module spec for vendored names."""
        return (
            importlib.util.spec_from_loader(fullname, self)
            if self._module_matches_namespace(fullname) else None
        )

    def install(self):
        """
        Install this importer into sys.meta_path if not already present.
        """
        if self not in sys.meta_path:
            sys.meta_path.append(self)


names = 'packaging', 'pyparsing', 'appdirs'
VendorImporter(__name__, names).install()
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9066699
setuptools-59.6.0/pkg_resources/tests/0000755000175100001710000000000000000000000017411 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/__init__.py0000644000175100001710000000000000000000000021510 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8866699
setuptools-59.6.0/pkg_resources/tests/data/0000755000175100001710000000000000000000000020322 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9066699
setuptools-59.6.0/pkg_resources/tests/data/my-test-package-source/0000755000175100001710000000000000000000000024613 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package-source/setup.cfg0000644000175100001710000000000000000000000026422 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package-source/setup.py0000644000175100001710000000015000000000000026321 0ustar00runnerdockerimport setuptools
setuptools.setup(
    name="my-test-package",
    version="1.0",
    zip_safe=True,
)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9066699
setuptools-59.6.0/pkg_resources/tests/data/my-test-package-zip/0000755000175100001710000000000000000000000024115 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package-zip/my-test-package.zip0000644000175100001710000000342100000000000027634 0ustar00runnerdockerPK
ºJŽQmy_test_package.egg-info/UT	/Ÿ×_/Ÿ×_uxééPK
µJŽQ“×2&my_test_package.egg-info/top_level.txtUT	&Ÿ×_&Ÿ×_uxéé
PK
µJŽQ“×2-my_test_package.egg-info/dependency_links.txtUT	&Ÿ×_&Ÿ×_uxéé
PK
µJŽQ“×2!my_test_package.egg-info/zip-safeUT	&Ÿ×_&Ÿ×_uxéé
PKµJŽQ‰&{ùfÐ$my_test_package.egg-info/SOURCES.txtUT	&Ÿ×_&Ÿ×_uxéé}ÊA
ƒ0нwIzˆbE
*×!ÄŸLãÀŒ¥ñô‚{ݽÅcÈFÚùPñ)*Õ·‹!ë ‚ŠÙ¯áݨ¶{õ×cì§Ï³µüå:Í äÙ“b^ø~ËJ&á‡tßöHŠ­ÇPKµJŽQ^Æx»!my_test_package.egg-info/PKG-INFOUT	&Ÿ×_&Ÿ×_uxééóM-ILI,IÔ
K-*ÎÌϳR0Ô3àòKÌMµRÈ­Ô-I-.Ñ-HLÎNLOåBQ\š››XTi¥êçíçîÇå‘Ÿ›
TšžŠr,-ÉÈ/Bçë¦æ&fæ D}2“SóŠ‘´¹¤'e”€í‚	ä$–¤åå"DPK
ðFŽQ	setup.cfgUT	™×_&Ÿ×_uxééPKðFŽQËÕ",Thsetup.pyUT	™×_w×_uxééËÌ-È/*Q(N-)-(ÉÏÏ)æB0õÀL
. ÈKÌMµUÊ­Ô-I-.Ñ-HLÎNLOUÒË•¥gæçÙ*ê@…ª2â‹ÓRmCŠJSu¸4¹PK
ºJŽQýAmy_test_package.egg-info/UT/Ÿ×_uxééPK
µJŽQ“×2&´Smy_test_package.egg-info/top_level.txtUT&Ÿ×_uxééPK
µJŽQ“×2-´´my_test_package.egg-info/dependency_links.txtUT&Ÿ×_uxééPK
µJŽQ“×2!´my_test_package.egg-info/zip-safeUT&Ÿ×_uxééPKµJŽQ‰&{ùfÐ$´xmy_test_package.egg-info/SOURCES.txtUT&Ÿ×_uxééPKµJŽQ^Æx»!´<my_test_package.egg-info/PKG-INFOUT&Ÿ×_uxééPK
ðFŽQ	´setup.cfgUT™×_uxééPKðFŽQËÕ",Th´Rsetup.pyUT™×_uxééPKè././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8866699
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/0000755000175100001710000000000000000000000025727 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00112 path=setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/
28 mtime=1639341979.8866699
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000755000175100001710000000000000000000000032553 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000022500000000000010214 xustar00121 path=setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/
28 mtime=1639341979.9066699
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000755000175100001710000000000000000000000032553 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000022700000000000010216 xustar00129 path=setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO
22 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001710000000027300000000000032557 0ustar00runnerdockerMetadata-Version: 1.0
Name: my-test-package
Version: 1.0
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
././@PaxHeader0000000000000000000000000000023200000000000010212 xustar00132 path=setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt
22 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001710000000032000000000000032550 0ustar00runnerdockersetup.cfg
setup.py
my_test_package.egg-info/PKG-INFO
my_test_package.egg-info/SOURCES.txt
my_test_package.egg-info/dependency_links.txt
my_test_package.egg-info/top_level.txt
my_test_package.egg-info/zip-safe././@PaxHeader0000000000000000000000000000024300000000000010214 xustar00141 path=setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt
22 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001710000000000100000000000032544 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000023400000000000010214 xustar00134 path=setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt
22 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001710000000000100000000000032544 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000022700000000000010216 xustar00129 path=setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe
22 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001710000000000100000000000032544 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9066699
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_zipped-egg/0000755000175100001710000000000000000000000025430 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg0000644000175100001710000000151300000000000032425 0ustar00runnerdockerPK‘+O^Æx»EGG-INFO/PKG-INFOóM-ILI,IÔ
K-*ÎÌϳR0Ô3àòKÌMµRÈ­Ô-I-.Ñ-HLÎNLOåBQ\š››XTi¥êçíçîÇå‘Ÿ›
TšžŠr,-ÉÈ/Bçë¦æ&fæ D}2“SóŠ‘´¹¤'e”€í‚	ä$–¤åå"DPK‘+O‰&{ùfÐEGG-INFO/SOURCES.txt}ÊA
ƒ0нwIzˆbE
*×!ÄŸLãÀŒ¥ñô‚{ݽÅcÈFÚùPñ)*Õ·‹!ë ‚ŠÙ¯áݨ¶{õ×cì§Ï³µüå:Í äÙ“b^ø~ËJ&á‡tßöHŠ­ÇPK‘+O“×2EGG-INFO/dependency_links.txtãPK‘+O“×2EGG-INFO/top_level.txtãPK‘+O“×2EGG-INFO/zip-safeãPK‘+O^Æx»€EGG-INFO/PKG-INFOPK‘+O‰&{ùfЀ§EGG-INFO/SOURCES.txtPK‘+O“×2€?EGG-INFO/dependency_links.txtPK‘+O“×2€}EGG-INFO/top_level.txtPK‘+O“×2€´EGG-INFO/zip-safePKOæ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/test_find_distributions.py0000644000175100001710000000330000000000000024720 0ustar00runnerdockerimport py
import pytest
import pkg_resources


TESTS_DATA_DIR = py.path.local(__file__).dirpath('data')


class TestFindDistributions:

    @pytest.fixture
    def target_dir(self, tmpdir):
        target_dir = tmpdir.mkdir('target')
        # place a .egg named directory in the target that is not an egg:
        target_dir.mkdir('not.an.egg')
        return target_dir

    def test_non_egg_dir_named_egg(self, target_dir):
        dists = pkg_resources.find_distributions(str(target_dir))
        assert not list(dists)

    def test_standalone_egg_directory(self, target_dir):
        (TESTS_DATA_DIR / 'my-test-package_unpacked-egg').copy(target_dir)
        dists = pkg_resources.find_distributions(str(target_dir))
        assert [dist.project_name for dist in dists] == ['my-test-package']
        dists = pkg_resources.find_distributions(str(target_dir), only=True)
        assert not list(dists)

    def test_zipped_egg(self, target_dir):
        (TESTS_DATA_DIR / 'my-test-package_zipped-egg').copy(target_dir)
        dists = pkg_resources.find_distributions(str(target_dir))
        assert [dist.project_name for dist in dists] == ['my-test-package']
        dists = pkg_resources.find_distributions(str(target_dir), only=True)
        assert not list(dists)

    def test_zipped_sdist_one_level_removed(self, target_dir):
        (TESTS_DATA_DIR / 'my-test-package-zip').copy(target_dir)
        dists = pkg_resources.find_distributions(
            str(target_dir / "my-test-package.zip"))
        assert [dist.project_name for dist in dists] == ['my-test-package']
        dists = pkg_resources.find_distributions(
            str(target_dir / "my-test-package.zip"), only=True)
        assert not list(dists)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/test_markers.py0000644000175100001710000000034300000000000022466 0ustar00runnerdockerimport mock

from pkg_resources import evaluate_marker


@mock.patch('platform.python_version', return_value='2.7.10')
def test_ordering(python_version_mock):
    assert evaluate_marker("python_full_version > '2.7.3'") is True
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/test_pkg_resources.py0000644000175100001710000003337500000000000023710 0ustar00runnerdockerimport sys
import tempfile
import os
import zipfile
import datetime
import time
import subprocess
import stat
import distutils.dist
import distutils.command.install_egg_info

try:
    from unittest import mock
except ImportError:
    import mock

from pkg_resources import (
    DistInfoDistribution, Distribution, EggInfoDistribution,
)

import pytest

import pkg_resources


def timestamp(dt):
    """
    Return a timestamp for a local, naive datetime instance.
    """
    try:
        return dt.timestamp()
    except AttributeError:
        # Python 3.2 and earlier
        return time.mktime(dt.timetuple())


class EggRemover(str):
    def __call__(self):
        if self in sys.path:
            sys.path.remove(self)
        if os.path.exists(self):
            os.remove(self)


class TestZipProvider:
    finalizers = []

    ref_time = datetime.datetime(2013, 5, 12, 13, 25, 0)
    "A reference time for a file modification"

    @classmethod
    def setup_class(cls):
        "create a zip egg and add it to sys.path"
        egg = tempfile.NamedTemporaryFile(suffix='.egg', delete=False)
        zip_egg = zipfile.ZipFile(egg, 'w')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'mod.py'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'x = 3\n')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'data.dat'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'hello, world!')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'subdir/mod2.py'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'x = 6\n')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'subdir/data2.dat'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'goodbye, world!')
        zip_egg.close()
        egg.close()

        sys.path.append(egg.name)
        subdir = os.path.join(egg.name, 'subdir')
        sys.path.append(subdir)
        cls.finalizers.append(EggRemover(subdir))
        cls.finalizers.append(EggRemover(egg.name))

    @classmethod
    def teardown_class(cls):
        for finalizer in cls.finalizers:
            finalizer()

    def test_resource_listdir(self):
        import mod
        zp = pkg_resources.ZipProvider(mod)

        expected_root = ['data.dat', 'mod.py', 'subdir']
        assert sorted(zp.resource_listdir('')) == expected_root

        expected_subdir = ['data2.dat', 'mod2.py']
        assert sorted(zp.resource_listdir('subdir')) == expected_subdir
        assert sorted(zp.resource_listdir('subdir/')) == expected_subdir

        assert zp.resource_listdir('nonexistent') == []
        assert zp.resource_listdir('nonexistent/') == []

        import mod2
        zp2 = pkg_resources.ZipProvider(mod2)

        assert sorted(zp2.resource_listdir('')) == expected_subdir

        assert zp2.resource_listdir('subdir') == []
        assert zp2.resource_listdir('subdir/') == []

    def test_resource_filename_rewrites_on_change(self):
        """
        If a previous call to get_resource_filename has saved the file, but
        the file has been subsequently mutated with different file of the
        same size and modification time, it should not be overwritten on a
        subsequent call to get_resource_filename.
        """
        import mod
        manager = pkg_resources.ResourceManager()
        zp = pkg_resources.ZipProvider(mod)
        filename = zp.get_resource_filename(manager, 'data.dat')
        actual = datetime.datetime.fromtimestamp(os.stat(filename).st_mtime)
        assert actual == self.ref_time
        f = open(filename, 'w')
        f.write('hello, world?')
        f.close()
        ts = timestamp(self.ref_time)
        os.utime(filename, (ts, ts))
        filename = zp.get_resource_filename(manager, 'data.dat')
        with open(filename) as f:
            assert f.read() == 'hello, world!'
        manager.cleanup_resources()


class TestResourceManager:
    def test_get_cache_path(self):
        mgr = pkg_resources.ResourceManager()
        path = mgr.get_cache_path('foo')
        type_ = str(type(path))
        message = "Unexpected type from get_cache_path: " + type_
        assert isinstance(path, str), message

    def test_get_cache_path_race(self, tmpdir):
        # Patch to os.path.isdir to create a race condition
        def patched_isdir(dirname, unpatched_isdir=pkg_resources.isdir):
            patched_isdir.dirnames.append(dirname)

            was_dir = unpatched_isdir(dirname)
            if not was_dir:
                os.makedirs(dirname)
            return was_dir

        patched_isdir.dirnames = []

        # Get a cache path with a "race condition"
        mgr = pkg_resources.ResourceManager()
        mgr.set_extraction_path(str(tmpdir))

        archive_name = os.sep.join(('foo', 'bar', 'baz'))
        with mock.patch.object(pkg_resources, 'isdir', new=patched_isdir):
            mgr.get_cache_path(archive_name)

        # Because this test relies on the implementation details of this
        # function, these assertions are a sentinel to ensure that the
        # test suite will not fail silently if the implementation changes.
        called_dirnames = patched_isdir.dirnames
        assert len(called_dirnames) == 2
        assert called_dirnames[0].split(os.sep)[-2:] == ['foo', 'bar']
        assert called_dirnames[1].split(os.sep)[-1:] == ['foo']

    """
    Tests to ensure that pkg_resources runs independently from setuptools.
    """

    def test_setuptools_not_imported(self):
        """
        In a separate Python environment, import pkg_resources and assert
        that action doesn't cause setuptools to be imported.
        """
        lines = (
            'import pkg_resources',
            'import sys',
            (
                'assert "setuptools" not in sys.modules, '
                '"setuptools was imported"'
            ),
        )
        cmd = [sys.executable, '-c', '; '.join(lines)]
        subprocess.check_call(cmd)


def make_test_distribution(metadata_path, metadata):
    """
    Make a test Distribution object, and return it.

    :param metadata_path: the path to the metadata file that should be
        created. This should be inside a distribution directory that should
        also be created. For example, an argument value might end with
        ".dist-info/METADATA".
    :param metadata: the desired contents of the metadata file, as bytes.
    """
    dist_dir = os.path.dirname(metadata_path)
    os.mkdir(dist_dir)
    with open(metadata_path, 'wb') as f:
        f.write(metadata)
    dists = list(pkg_resources.distributions_from_metadata(dist_dir))
    dist, = dists

    return dist


def test_get_metadata__bad_utf8(tmpdir):
    """
    Test a metadata file with bytes that can't be decoded as utf-8.
    """
    filename = 'METADATA'
    # Convert the tmpdir LocalPath object to a string before joining.
    metadata_path = os.path.join(str(tmpdir), 'foo.dist-info', filename)
    # Encode a non-ascii string with the wrong encoding (not utf-8).
    metadata = 'née'.encode('iso-8859-1')
    dist = make_test_distribution(metadata_path, metadata=metadata)

    with pytest.raises(UnicodeDecodeError) as excinfo:
        dist.get_metadata(filename)

    exc = excinfo.value
    actual = str(exc)
    expected = (
        # The error message starts with "'utf-8' codec ..." However, the
        # spelling of "utf-8" can vary (e.g. "utf8") so we don't include it
        "codec can't decode byte 0xe9 in position 1: "
        'invalid continuation byte in METADATA file at path: '
    )
    assert expected in actual, 'actual: {}'.format(actual)
    assert actual.endswith(metadata_path), 'actual: {}'.format(actual)


def make_distribution_no_version(tmpdir, basename):
    """
    Create a distribution directory with no file containing the version.
    """
    dist_dir = tmpdir / basename
    dist_dir.ensure_dir()
    # Make the directory non-empty so distributions_from_metadata()
    # will detect it and yield it.
    dist_dir.join('temp.txt').ensure()

    if sys.version_info < (3, 6):
        dist_dir = str(dist_dir)

    dists = list(pkg_resources.distributions_from_metadata(dist_dir))
    assert len(dists) == 1
    dist, = dists

    return dist, dist_dir


@pytest.mark.parametrize(
    'suffix, expected_filename, expected_dist_type',
    [
        ('egg-info', 'PKG-INFO', EggInfoDistribution),
        ('dist-info', 'METADATA', DistInfoDistribution),
    ],
)
def test_distribution_version_missing(
        tmpdir, suffix, expected_filename, expected_dist_type):
    """
    Test Distribution.version when the "Version" header is missing.
    """
    basename = 'foo.{}'.format(suffix)
    dist, dist_dir = make_distribution_no_version(tmpdir, basename)

    expected_text = (
        "Missing 'Version:' header and/or {} file at path: "
    ).format(expected_filename)
    metadata_path = os.path.join(dist_dir, expected_filename)

    # Now check the exception raised when the "version" attribute is accessed.
    with pytest.raises(ValueError) as excinfo:
        dist.version

    err = str(excinfo.value)
    # Include a string expression after the assert so the full strings
    # will be visible for inspection on failure.
    assert expected_text in err, str((expected_text, err))

    # Also check the args passed to the ValueError.
    msg, dist = excinfo.value.args
    assert expected_text in msg
    # Check that the message portion contains the path.
    assert metadata_path in msg, str((metadata_path, msg))
    assert type(dist) == expected_dist_type


def test_distribution_version_missing_undetected_path():
    """
    Test Distribution.version when the "Version" header is missing and
    the path can't be detected.
    """
    # Create a Distribution object with no metadata argument, which results
    # in an empty metadata provider.
    dist = Distribution('/foo')
    with pytest.raises(ValueError) as excinfo:
        dist.version

    msg, dist = excinfo.value.args
    expected = (
        "Missing 'Version:' header and/or PKG-INFO file at path: "
        '[could not detect]'
    )
    assert msg == expected


@pytest.mark.parametrize('only', [False, True])
def test_dist_info_is_not_dir(tmp_path, only):
    """Test path containing a file with dist-info extension."""
    dist_info = tmp_path / 'foobar.dist-info'
    dist_info.touch()
    assert not pkg_resources.dist_factory(str(tmp_path), str(dist_info), only)


class TestDeepVersionLookupDistutils:
    @pytest.fixture
    def env(self, tmpdir):
        """
        Create a package environment, similar to a virtualenv,
        in which packages are installed.
        """

        class Environment(str):
            pass

        env = Environment(tmpdir)
        tmpdir.chmod(stat.S_IRWXU)
        subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
        env.paths = dict(
            (dirname, str(tmpdir / dirname))
            for dirname in subs
        )
        list(map(os.mkdir, env.paths.values()))
        return env

    def create_foo_pkg(self, env, version):
        """
        Create a foo package installed (distutils-style) to env.paths['lib']
        as version.
        """
        ld = "This package has unicode metadata! â„"
        attrs = dict(name='foo', version=version, long_description=ld)
        dist = distutils.dist.Distribution(attrs)
        iei_cmd = distutils.command.install_egg_info.install_egg_info(dist)
        iei_cmd.initialize_options()
        iei_cmd.install_dir = env.paths['lib']
        iei_cmd.finalize_options()
        iei_cmd.run()

    def test_version_resolved_from_egg_info(self, env):
        version = '1.11.0.dev0+2329eae'
        self.create_foo_pkg(env, version)

        # this requirement parsing will raise a VersionConflict unless the
        # .egg-info file is parsed (see #419 on BitBucket)
        req = pkg_resources.Requirement.parse('foo>=1.9')
        dist = pkg_resources.WorkingSet([env.paths['lib']]).find(req)
        assert dist.version == version

    @pytest.mark.parametrize(
        'unnormalized, normalized',
        [
            ('foo', 'foo'),
            ('foo/', 'foo'),
            ('foo/bar', 'foo/bar'),
            ('foo/bar/', 'foo/bar'),
        ],
    )
    def test_normalize_path_trailing_sep(self, unnormalized, normalized):
        """Ensure the trailing slash is cleaned for path comparison.

        See pypa/setuptools#1519.
        """
        result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
        result_from_normalized = pkg_resources.normalize_path(normalized)
        assert result_from_unnormalized == result_from_normalized

    @pytest.mark.skipif(
        os.path.normcase('A') != os.path.normcase('a'),
        reason='Testing case-insensitive filesystems.',
    )
    @pytest.mark.parametrize(
        'unnormalized, normalized',
        [
            ('MiXeD/CasE', 'mixed/case'),
        ],
    )
    def test_normalize_path_normcase(self, unnormalized, normalized):
        """Ensure mixed case is normalized on case-insensitive filesystems.
        """
        result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
        result_from_normalized = pkg_resources.normalize_path(normalized)
        assert result_from_unnormalized == result_from_normalized

    @pytest.mark.skipif(
        os.path.sep != '\\',
        reason='Testing systems using backslashes as path separators.',
    )
    @pytest.mark.parametrize(
        'unnormalized, expected',
        [
            ('forward/slash', 'forward\\slash'),
            ('forward/slash/', 'forward\\slash'),
            ('backward\\slash\\', 'backward\\slash'),
        ],
    )
    def test_normalize_path_backslash_sep(self, unnormalized, expected):
        """Ensure path seps are cleaned on backslash path sep systems.
        """
        result = pkg_resources.normalize_path(unnormalized)
        assert result.endswith(expected)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/test_resources.py0000644000175100001710000007440000000000000023041 0ustar00runnerdockerimport os
import sys
import string
import platform
import itertools

import pytest
from pkg_resources.extern import packaging

import pkg_resources
from pkg_resources import (
    parse_requirements, VersionConflict, parse_version,
    Distribution, EntryPoint, Requirement, safe_version, safe_name,
    WorkingSet)


# from Python 3.6 docs.
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return zip(a, b)


class Metadata(pkg_resources.EmptyProvider):
    """Mock object to return metadata as if from an on-disk distribution"""

    def __init__(self, *pairs):
        self.metadata = dict(pairs)

    def has_metadata(self, name):
        return name in self.metadata

    def get_metadata(self, name):
        return self.metadata[name]

    def get_metadata_lines(self, name):
        return pkg_resources.yield_lines(self.get_metadata(name))


dist_from_fn = pkg_resources.Distribution.from_filename


class TestDistro:
    def testCollection(self):
        # empty path should produce no distributions
        ad = pkg_resources.Environment([], platform=None, python=None)
        assert list(ad) == []
        assert ad['FooPkg'] == []
        ad.add(dist_from_fn("FooPkg-1.3_1.egg"))
        ad.add(dist_from_fn("FooPkg-1.4-py2.4-win32.egg"))
        ad.add(dist_from_fn("FooPkg-1.2-py2.4.egg"))

        # Name is in there now
        assert ad['FooPkg']
        # But only 1 package
        assert list(ad) == ['foopkg']

        # Distributions sort by version
        expected = ['1.4', '1.3-1', '1.2']
        assert [dist.version for dist in ad['FooPkg']] == expected

        # Removing a distribution leaves sequence alone
        ad.remove(ad['FooPkg'][1])
        assert [dist.version for dist in ad['FooPkg']] == ['1.4', '1.2']

        # And inserting adds them in order
        ad.add(dist_from_fn("FooPkg-1.9.egg"))
        assert [dist.version for dist in ad['FooPkg']] == ['1.9', '1.4', '1.2']

        ws = WorkingSet([])
        foo12 = dist_from_fn("FooPkg-1.2-py2.4.egg")
        foo14 = dist_from_fn("FooPkg-1.4-py2.4-win32.egg")
        req, = parse_requirements("FooPkg>=1.3")

        # Nominal case: no distros on path, should yield all applicable
        assert ad.best_match(req, ws).version == '1.9'
        # If a matching distro is already installed, should return only that
        ws.add(foo14)
        assert ad.best_match(req, ws).version == '1.4'

        # If the first matching distro is unsuitable, it's a version conflict
        ws = WorkingSet([])
        ws.add(foo12)
        ws.add(foo14)
        with pytest.raises(VersionConflict):
            ad.best_match(req, ws)

        # If more than one match on the path, the first one takes precedence
        ws = WorkingSet([])
        ws.add(foo14)
        ws.add(foo12)
        ws.add(foo14)
        assert ad.best_match(req, ws).version == '1.4'

    def checkFooPkg(self, d):
        assert d.project_name == "FooPkg"
        assert d.key == "foopkg"
        assert d.version == "1.3.post1"
        assert d.py_version == "2.4"
        assert d.platform == "win32"
        assert d.parsed_version == parse_version("1.3-1")

    def testDistroBasics(self):
        d = Distribution(
            "/some/path",
            project_name="FooPkg",
            version="1.3-1",
            py_version="2.4",
            platform="win32",
        )
        self.checkFooPkg(d)

        d = Distribution("/some/path")
        assert d.py_version == '{}.{}'.format(*sys.version_info)
        assert d.platform is None

    def testDistroParse(self):
        d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg")
        self.checkFooPkg(d)
        d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg-info")
        self.checkFooPkg(d)

    def testDistroMetadata(self):
        d = Distribution(
            "/some/path", project_name="FooPkg",
            py_version="2.4", platform="win32",
            metadata=Metadata(
                ('PKG-INFO', "Metadata-Version: 1.0\nVersion: 1.3-1\n")
            ),
        )
        self.checkFooPkg(d)

    def distRequires(self, txt):
        return Distribution("/foo", metadata=Metadata(('depends.txt', txt)))

    def checkRequires(self, dist, txt, extras=()):
        assert list(dist.requires(extras)) == list(parse_requirements(txt))

    def testDistroDependsSimple(self):
        for v in "Twisted>=1.5", "Twisted>=1.5\nZConfig>=2.0":
            self.checkRequires(self.distRequires(v), v)

    needs_object_dir = pytest.mark.skipif(
        not hasattr(object, '__dir__'),
        reason='object.__dir__ necessary for self.__dir__ implementation',
    )

    def test_distribution_dir(self):
        d = pkg_resources.Distribution()
        dir(d)

    @needs_object_dir
    def test_distribution_dir_includes_provider_dir(self):
        d = pkg_resources.Distribution()
        before = d.__dir__()
        assert 'test_attr' not in before
        d._provider.test_attr = None
        after = d.__dir__()
        assert len(after) == len(before) + 1
        assert 'test_attr' in after

    @needs_object_dir
    def test_distribution_dir_ignores_provider_dir_leading_underscore(self):
        d = pkg_resources.Distribution()
        before = d.__dir__()
        assert '_test_attr' not in before
        d._provider._test_attr = None
        after = d.__dir__()
        assert len(after) == len(before)
        assert '_test_attr' not in after

    def testResolve(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        # Resolving no requirements -> nothing to install
        assert list(ws.resolve([], ad)) == []
        # Request something not in the collection -> DistributionNotFound
        with pytest.raises(pkg_resources.DistributionNotFound):
            ws.resolve(parse_requirements("Foo"), ad)

        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.egg",
            metadata=Metadata(('depends.txt', "[bar]\nBaz>=2.0"))
        )
        ad.add(Foo)
        ad.add(Distribution.from_filename("Foo-0.9.egg"))

        # Request thing(s) that are available -> list to activate
        for i in range(3):
            targets = list(ws.resolve(parse_requirements("Foo"), ad))
            assert targets == [Foo]
            list(map(ws.add, targets))
        with pytest.raises(VersionConflict):
            ws.resolve(parse_requirements("Foo==0.9"), ad)
        ws = WorkingSet([])  # reset

        # Request an extra that causes an unresolved dependency for "Baz"
        with pytest.raises(pkg_resources.DistributionNotFound):
            ws.resolve(parse_requirements("Foo[bar]"), ad)
        Baz = Distribution.from_filename(
            "/foo_dir/Baz-2.1.egg", metadata=Metadata(('depends.txt', "Foo"))
        )
        ad.add(Baz)

        # Activation list now includes resolved dependency
        assert (
            list(ws.resolve(parse_requirements("Foo[bar]"), ad))
            == [Foo, Baz]
        )
        # Requests for conflicting versions produce VersionConflict
        with pytest.raises(VersionConflict) as vc:
            ws.resolve(parse_requirements("Foo==1.2\nFoo!=1.2"), ad)

        msg = 'Foo 0.9 is installed but Foo==1.2 is required'
        assert vc.value.report() == msg

    def test_environment_marker_evaluation_negative(self):
        """Environment markers are evaluated at resolution time."""
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        res = ws.resolve(parse_requirements("Foo;python_version<'2'"), ad)
        assert list(res) == []

    def test_environment_marker_evaluation_positive(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename("/foo_dir/Foo-1.2.dist-info")
        ad.add(Foo)
        res = ws.resolve(parse_requirements("Foo;python_version>='2'"), ad)
        assert list(res) == [Foo]

    def test_environment_marker_evaluation_called(self):
        """
        If one package foo requires bar without any extras,
        markers should pass for bar without extras.
        """
        parent_req, = parse_requirements("foo")
        req, = parse_requirements("bar;python_version>='2'")
        req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
        assert req_extras.markers_pass(req)

        parent_req, = parse_requirements("foo[]")
        req, = parse_requirements("bar;python_version>='2'")
        req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
        assert req_extras.markers_pass(req)

    def test_marker_evaluation_with_extras(self):
        """Extras are also evaluated as markers at resolution time."""
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.dist-info",
            metadata=Metadata(("METADATA", "Provides-Extra: baz\n"
                               "Requires-Dist: quux; extra=='baz'"))
        )
        ad.add(Foo)
        assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
        ad.add(quux)
        res = list(ws.resolve(parse_requirements("Foo[baz]"), ad))
        assert res == [Foo, quux]

    def test_marker_evaluation_with_extras_normlized(self):
        """Extras are also evaluated as markers at resolution time."""
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.dist-info",
            metadata=Metadata(("METADATA", "Provides-Extra: baz-lightyear\n"
                               "Requires-Dist: quux; extra=='baz-lightyear'"))
        )
        ad.add(Foo)
        assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
        ad.add(quux)
        res = list(ws.resolve(parse_requirements("Foo[baz-lightyear]"), ad))
        assert res == [Foo, quux]

    def test_marker_evaluation_with_multiple_extras(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.dist-info",
            metadata=Metadata(("METADATA", "Provides-Extra: baz\n"
                               "Requires-Dist: quux; extra=='baz'\n"
                               "Provides-Extra: bar\n"
                               "Requires-Dist: fred; extra=='bar'\n"))
        )
        ad.add(Foo)
        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
        ad.add(quux)
        fred = Distribution.from_filename("/foo_dir/fred-0.1.dist-info")
        ad.add(fred)
        res = list(ws.resolve(parse_requirements("Foo[baz,bar]"), ad))
        assert sorted(res) == [fred, quux, Foo]

    def test_marker_evaluation_with_extras_loop(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        a = Distribution.from_filename(
            "/foo_dir/a-0.2.dist-info",
            metadata=Metadata(("METADATA", "Requires-Dist: c[a]"))
        )
        b = Distribution.from_filename(
            "/foo_dir/b-0.3.dist-info",
            metadata=Metadata(("METADATA", "Requires-Dist: c[b]"))
        )
        c = Distribution.from_filename(
            "/foo_dir/c-1.0.dist-info",
            metadata=Metadata(("METADATA", "Provides-Extra: a\n"
                               "Requires-Dist: b;extra=='a'\n"
                               "Provides-Extra: b\n"
                               "Requires-Dist: foo;extra=='b'"))
        )
        foo = Distribution.from_filename("/foo_dir/foo-0.1.dist-info")
        for dist in (a, b, c, foo):
            ad.add(dist)
        res = list(ws.resolve(parse_requirements("a"), ad))
        assert res == [a, c, b, foo]

    def testDistroDependsOptions(self):
        d = self.distRequires("""
            Twisted>=1.5
            [docgen]
            ZConfig>=2.0
            docutils>=0.3
            [fastcgi]
            fcgiapp>=0.1""")
        self.checkRequires(d, "Twisted>=1.5")
        self.checkRequires(
            d, "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3".split(), ["docgen"]
        )
        self.checkRequires(
            d, "Twisted>=1.5 fcgiapp>=0.1".split(), ["fastcgi"]
        )
        self.checkRequires(
            d, "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3 fcgiapp>=0.1".split(),
            ["docgen", "fastcgi"]
        )
        self.checkRequires(
            d, "Twisted>=1.5 fcgiapp>=0.1 ZConfig>=2.0 docutils>=0.3".split(),
            ["fastcgi", "docgen"]
        )
        with pytest.raises(pkg_resources.UnknownExtra):
            d.requires(["foo"])


class TestWorkingSet:
    def test_find_conflicting(self):
        ws = WorkingSet([])
        Foo = Distribution.from_filename("/foo_dir/Foo-1.2.egg")
        ws.add(Foo)

        # create a requirement that conflicts with Foo 1.2
        req = next(parse_requirements("Foo<1.2"))

        with pytest.raises(VersionConflict) as vc:
            ws.find(req)

        msg = 'Foo 1.2 is installed but Foo<1.2 is required'
        assert vc.value.report() == msg

    def test_resolve_conflicts_with_prior(self):
        """
        A ContextualVersionConflict should be raised when a requirement
        conflicts with a prior requirement for a different package.
        """
        # Create installation where Foo depends on Baz 1.0 and Bar depends on
        # Baz 2.0.
        ws = WorkingSet([])
        md = Metadata(('depends.txt', "Baz==1.0"))
        Foo = Distribution.from_filename("/foo_dir/Foo-1.0.egg", metadata=md)
        ws.add(Foo)
        md = Metadata(('depends.txt', "Baz==2.0"))
        Bar = Distribution.from_filename("/foo_dir/Bar-1.0.egg", metadata=md)
        ws.add(Bar)
        Baz = Distribution.from_filename("/foo_dir/Baz-1.0.egg")
        ws.add(Baz)
        Baz = Distribution.from_filename("/foo_dir/Baz-2.0.egg")
        ws.add(Baz)

        with pytest.raises(VersionConflict) as vc:
            ws.resolve(parse_requirements("Foo\nBar\n"))

        msg = "Baz 1.0 is installed but Baz==2.0 is required by "
        msg += repr(set(['Bar']))
        assert vc.value.report() == msg


class TestEntryPoints:
    def assertfields(self, ep):
        assert ep.name == "foo"
        assert ep.module_name == "pkg_resources.tests.test_resources"
        assert ep.attrs == ("TestEntryPoints",)
        assert ep.extras == ("x",)
        assert ep.load() is TestEntryPoints
        expect = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
        assert str(ep) == expect

    def setup_method(self, method):
        self.dist = Distribution.from_filename(
            "FooPkg-1.2-py2.4.egg", metadata=Metadata(('requires.txt', '[x]')))

    def testBasics(self):
        ep = EntryPoint(
            "foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"],
            ["x"], self.dist
        )
        self.assertfields(ep)

    def testParse(self):
        s = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
        ep = EntryPoint.parse(s, self.dist)
        self.assertfields(ep)

        ep = EntryPoint.parse("bar baz=  spammity[PING]")
        assert ep.name == "bar baz"
        assert ep.module_name == "spammity"
        assert ep.attrs == ()
        assert ep.extras == ("ping",)

        ep = EntryPoint.parse(" fizzly =  wocka:foo")
        assert ep.name == "fizzly"
        assert ep.module_name == "wocka"
        assert ep.attrs == ("foo",)
        assert ep.extras == ()

        # plus in the name
        spec = "html+mako = mako.ext.pygmentplugin:MakoHtmlLexer"
        ep = EntryPoint.parse(spec)
        assert ep.name == 'html+mako'

    reject_specs = "foo", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2"

    @pytest.mark.parametrize("reject_spec", reject_specs)
    def test_reject_spec(self, reject_spec):
        with pytest.raises(ValueError):
            EntryPoint.parse(reject_spec)

    def test_printable_name(self):
        """
        Allow any printable character in the name.
        """
        # Create a name with all printable characters; strip the whitespace.
        name = string.printable.strip()
        spec = "{name} = module:attr".format(**locals())
        ep = EntryPoint.parse(spec)
        assert ep.name == name

    def checkSubMap(self, m):
        assert len(m) == len(self.submap_expect)
        for key, ep in self.submap_expect.items():
            assert m.get(key).name == ep.name
            assert m.get(key).module_name == ep.module_name
            assert sorted(m.get(key).attrs) == sorted(ep.attrs)
            assert sorted(m.get(key).extras) == sorted(ep.extras)

    submap_expect = dict(
        feature1=EntryPoint('feature1', 'somemodule', ['somefunction']),
        feature2=EntryPoint(
            'feature2', 'another.module', ['SomeClass'], ['extra1', 'extra2']),
        feature3=EntryPoint('feature3', 'this.module', extras=['something'])
    )
    submap_str = """
            # define features for blah blah
            feature1 = somemodule:somefunction
            feature2 = another.module:SomeClass [extra1,extra2]
            feature3 = this.module [something]
    """

    def testParseList(self):
        self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str))
        with pytest.raises(ValueError):
            EntryPoint.parse_group("x a", "foo=bar")
        with pytest.raises(ValueError):
            EntryPoint.parse_group("x", ["foo=baz", "foo=bar"])

    def testParseMap(self):
        m = EntryPoint.parse_map({'xyz': self.submap_str})
        self.checkSubMap(m['xyz'])
        assert list(m.keys()) == ['xyz']
        m = EntryPoint.parse_map("[xyz]\n" + self.submap_str)
        self.checkSubMap(m['xyz'])
        assert list(m.keys()) == ['xyz']
        with pytest.raises(ValueError):
            EntryPoint.parse_map(["[xyz]", "[xyz]"])
        with pytest.raises(ValueError):
            EntryPoint.parse_map(self.submap_str)

    def testDeprecationWarnings(self):
        ep = EntryPoint(
            "foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"],
            ["x"]
        )
        with pytest.warns(pkg_resources.PkgResourcesDeprecationWarning):
            ep.load(require=False)


class TestRequirements:
    def testBasics(self):
        r = Requirement.parse("Twisted>=1.2")
        assert str(r) == "Twisted>=1.2"
        assert repr(r) == "Requirement.parse('Twisted>=1.2')"
        assert r == Requirement("Twisted>=1.2")
        assert r == Requirement("twisTed>=1.2")
        assert r != Requirement("Twisted>=2.0")
        assert r != Requirement("Zope>=1.2")
        assert r != Requirement("Zope>=3.0")
        assert r != Requirement("Twisted[extras]>=1.2")

    def testOrdering(self):
        r1 = Requirement("Twisted==1.2c1,>=1.2")
        r2 = Requirement("Twisted>=1.2,==1.2c1")
        assert r1 == r2
        assert str(r1) == str(r2)
        assert str(r2) == "Twisted==1.2c1,>=1.2"
        assert (
            Requirement("Twisted")
            !=
            Requirement("Twisted @ https://localhost/twisted.zip")
        )

    def testBasicContains(self):
        r = Requirement("Twisted>=1.2")
        foo_dist = Distribution.from_filename("FooPkg-1.3_1.egg")
        twist11 = Distribution.from_filename("Twisted-1.1.egg")
        twist12 = Distribution.from_filename("Twisted-1.2.egg")
        assert parse_version('1.2') in r
        assert parse_version('1.1') not in r
        assert '1.2' in r
        assert '1.1' not in r
        assert foo_dist not in r
        assert twist11 not in r
        assert twist12 in r

    def testOptionsAndHashing(self):
        r1 = Requirement.parse("Twisted[foo,bar]>=1.2")
        r2 = Requirement.parse("Twisted[bar,FOO]>=1.2")
        assert r1 == r2
        assert set(r1.extras) == set(("foo", "bar"))
        assert set(r2.extras) == set(("foo", "bar"))
        assert hash(r1) == hash(r2)
        assert (
            hash(r1)
            ==
            hash((
                "twisted",
                None,
                packaging.specifiers.SpecifierSet(">=1.2"),
                frozenset(["foo", "bar"]),
                None
            ))
        )
        assert (
            hash(Requirement.parse("Twisted @ https://localhost/twisted.zip"))
            ==
            hash((
                "twisted",
                "https://localhost/twisted.zip",
                packaging.specifiers.SpecifierSet(),
                frozenset(),
                None
            ))
        )

    def testVersionEquality(self):
        r1 = Requirement.parse("foo==0.3a2")
        r2 = Requirement.parse("foo!=0.3a4")
        d = Distribution.from_filename

        assert d("foo-0.3a4.egg") not in r1
        assert d("foo-0.3a1.egg") not in r1
        assert d("foo-0.3a4.egg") not in r2

        assert d("foo-0.3a2.egg") in r1
        assert d("foo-0.3a2.egg") in r2
        assert d("foo-0.3a3.egg") in r2
        assert d("foo-0.3a5.egg") in r2

    def testSetuptoolsProjectName(self):
        """
        The setuptools project should implement the setuptools package.
        """

        assert (
            Requirement.parse('setuptools').project_name == 'setuptools')
        # setuptools 0.7 and higher means setuptools.
        assert (
            Requirement.parse('setuptools == 0.7').project_name
            == 'setuptools'
        )
        assert (
            Requirement.parse('setuptools == 0.7a1').project_name
            == 'setuptools'
        )
        assert (
            Requirement.parse('setuptools >= 0.7').project_name
            == 'setuptools'
        )


class TestParsing:
    def testEmptyParse(self):
        assert list(parse_requirements('')) == []

    def testYielding(self):
        for inp, out in [
            ([], []), ('x', ['x']), ([[]], []), (' x\n y', ['x', 'y']),
            (['x\n\n', 'y'], ['x', 'y']),
        ]:
            assert list(pkg_resources.yield_lines(inp)) == out

    def testSplitting(self):
        sample = """
                    x
                    [Y]
                    z

                    a
                    [b ]
                    # foo
                    c
                    [ d]
                    [q]
                    v
                    """
        assert (
            list(pkg_resources.split_sections(sample))
            ==
            [
                (None, ["x"]),
                ("Y", ["z", "a"]),
                ("b", ["c"]),
                ("d", []),
                ("q", ["v"]),
            ]
        )
        with pytest.raises(ValueError):
            list(pkg_resources.split_sections("[foo"))

    def testSafeName(self):
        assert safe_name("adns-python") == "adns-python"
        assert safe_name("WSGI Utils") == "WSGI-Utils"
        assert safe_name("WSGI  Utils") == "WSGI-Utils"
        assert safe_name("Money$$$Maker") == "Money-Maker"
        assert safe_name("peak.web") != "peak-web"

    def testSafeVersion(self):
        assert safe_version("1.2-1") == "1.2.post1"
        assert safe_version("1.2 alpha") == "1.2.alpha"
        assert safe_version("2.3.4 20050521") == "2.3.4.20050521"
        assert safe_version("Money$$$Maker") == "Money-Maker"
        assert safe_version("peak.web") == "peak.web"

    def testSimpleRequirements(self):
        assert (
            list(parse_requirements('Twis-Ted>=1.2-1'))
            ==
            [Requirement('Twis-Ted>=1.2-1')]
        )
        assert (
            list(parse_requirements('Twisted >=1.2, \\ # more\n<2.0'))
            ==
            [Requirement('Twisted>=1.2,<2.0')]
        )
        assert (
            Requirement.parse("FooBar==1.99a3")
            ==
            Requirement("FooBar==1.99a3")
        )
        with pytest.raises(ValueError):
            Requirement.parse(">=2.3")
        with pytest.raises(ValueError):
            Requirement.parse("x\\")
        with pytest.raises(ValueError):
            Requirement.parse("x==2 q")
        with pytest.raises(ValueError):
            Requirement.parse("X==1\nY==2")
        with pytest.raises(ValueError):
            Requirement.parse("#")

    def test_requirements_with_markers(self):
        assert (
            Requirement.parse("foobar;os_name=='a'")
            ==
            Requirement.parse("foobar;os_name=='a'")
        )
        assert (
            Requirement.parse("name==1.1;python_version=='2.7'")
            !=
            Requirement.parse("name==1.1;python_version=='3.6'")
        )
        assert (
            Requirement.parse("name==1.0;python_version=='2.7'")
            !=
            Requirement.parse("name==1.2;python_version=='2.7'")
        )
        assert (
            Requirement.parse("name[foo]==1.0;python_version=='3.6'")
            !=
            Requirement.parse("name[foo,bar]==1.0;python_version=='3.6'")
        )

    def test_local_version(self):
        req, = parse_requirements('foo==1.0+org1')

    def test_spaces_between_multiple_versions(self):
        req, = parse_requirements('foo>=1.0, <3')
        req, = parse_requirements('foo >= 1.0, < 3')

    @pytest.mark.parametrize(
        ['lower', 'upper'],
        [
            ('1.2-rc1', '1.2rc1'),
            ('0.4', '0.4.0'),
            ('0.4.0.0', '0.4.0'),
            ('0.4.0-0', '0.4-0'),
            ('0post1', '0.0post1'),
            ('0pre1', '0.0c1'),
            ('0.0.0preview1', '0c1'),
            ('0.0c1', '0-rc1'),
            ('1.2a1', '1.2.a.1'),
            ('1.2.a', '1.2a'),
        ],
    )
    def testVersionEquality(self, lower, upper):
        assert parse_version(lower) == parse_version(upper)

    torture = """
        0.80.1-3 0.80.1-2 0.80.1-1 0.79.9999+0.80.0pre4-1
        0.79.9999+0.80.0pre2-3 0.79.9999+0.80.0pre2-2
        0.77.2-1 0.77.1-1 0.77.0-1
        """

    @pytest.mark.parametrize(
        ['lower', 'upper'],
        [
            ('2.1', '2.1.1'),
            ('2a1', '2b0'),
            ('2a1', '2.1'),
            ('2.3a1', '2.3'),
            ('2.1-1', '2.1-2'),
            ('2.1-1', '2.1.1'),
            ('2.1', '2.1post4'),
            ('2.1a0-20040501', '2.1'),
            ('1.1', '02.1'),
            ('3.2', '3.2.post0'),
            ('3.2post1', '3.2post2'),
            ('0.4', '4.0'),
            ('0.0.4', '0.4.0'),
            ('0post1', '0.4post1'),
            ('2.1.0-rc1', '2.1.0'),
            ('2.1dev', '2.1a0'),
        ] + list(pairwise(reversed(torture.split()))),
    )
    def testVersionOrdering(self, lower, upper):
        assert parse_version(lower) < parse_version(upper)

    def testVersionHashable(self):
        """
        Ensure that our versions stay hashable even though we've subclassed
        them and added some shim code to them.
        """
        assert (
            hash(parse_version("1.0"))
            ==
            hash(parse_version("1.0"))
        )


class TestNamespaces:

    ns_str = "__import__('pkg_resources').declare_namespace(__name__)\n"

    @pytest.fixture
    def symlinked_tmpdir(self, tmpdir):
        """
        Where available, return the tempdir as a symlink,
        which as revealed in #231 is more fragile than
        a natural tempdir.
        """
        if not hasattr(os, 'symlink'):
            yield str(tmpdir)
            return

        link_name = str(tmpdir) + '-linked'
        os.symlink(str(tmpdir), link_name)
        try:
            yield type(tmpdir)(link_name)
        finally:
            os.unlink(link_name)

    @pytest.fixture(autouse=True)
    def patched_path(self, tmpdir):
        """
        Patch sys.path to include the 'site-pkgs' dir. Also
        restore pkg_resources._namespace_packages to its
        former state.
        """
        saved_ns_pkgs = pkg_resources._namespace_packages.copy()
        saved_sys_path = sys.path[:]
        site_pkgs = tmpdir.mkdir('site-pkgs')
        sys.path.append(str(site_pkgs))
        try:
            yield
        finally:
            pkg_resources._namespace_packages = saved_ns_pkgs
            sys.path = saved_sys_path

    issue591 = pytest.mark.xfail(platform.system() == 'Windows', reason="#591")

    @issue591
    def test_two_levels_deep(self, symlinked_tmpdir):
        """
        Test nested namespace packages
        Create namespace packages in the following tree :
            site-packages-1/pkg1/pkg2
            site-packages-2/pkg1/pkg2
        Check both are in the _namespace_packages dict and that their __path__
        is correct
        """
        real_tmpdir = symlinked_tmpdir.realpath()
        tmpdir = symlinked_tmpdir
        sys.path.append(str(tmpdir / 'site-pkgs2'))
        site_dirs = tmpdir / 'site-pkgs', tmpdir / 'site-pkgs2'
        for site in site_dirs:
            pkg1 = site / 'pkg1'
            pkg2 = pkg1 / 'pkg2'
            pkg2.ensure_dir()
            (pkg1 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
            (pkg2 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
        import pkg1
        assert "pkg1" in pkg_resources._namespace_packages
        # attempt to import pkg2 from site-pkgs2
        import pkg1.pkg2
        # check the _namespace_packages dict
        assert "pkg1.pkg2" in pkg_resources._namespace_packages
        assert pkg_resources._namespace_packages["pkg1"] == ["pkg1.pkg2"]
        # check the __path__ attribute contains both paths
        expected = [
            str(real_tmpdir / "site-pkgs" / "pkg1" / "pkg2"),
            str(real_tmpdir / "site-pkgs2" / "pkg1" / "pkg2"),
        ]
        assert pkg1.pkg2.__path__ == expected

    @issue591
    def test_path_order(self, symlinked_tmpdir):
        """
        Test that if multiple versions of the same namespace package subpackage
        are on different sys.path entries, that only the one earliest on
        sys.path is imported, and that the namespace package's __path__ is in
        the correct order.

        Regression test for https://github.com/pypa/setuptools/issues/207
        """

        tmpdir = symlinked_tmpdir
        site_dirs = (
            tmpdir / "site-pkgs",
            tmpdir / "site-pkgs2",
            tmpdir / "site-pkgs3",
        )

        vers_str = "__version__ = %r"

        for number, site in enumerate(site_dirs, 1):
            if number > 1:
                sys.path.append(str(site))
            nspkg = site / 'nspkg'
            subpkg = nspkg / 'subpkg'
            subpkg.ensure_dir()
            (nspkg / '__init__.py').write_text(self.ns_str, encoding='utf-8')
            (subpkg / '__init__.py').write_text(
                vers_str % number, encoding='utf-8')

        import nspkg.subpkg
        import nspkg
        expected = [
            str(site.realpath() / 'nspkg')
            for site in site_dirs
        ]
        assert nspkg.__path__ == expected
        assert nspkg.subpkg.__version__ == 1
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pkg_resources/tests/test_working_set.py0000644000175100001710000002023000000000000023352 0ustar00runnerdockerimport inspect
import re
import textwrap
import functools

import pytest

import pkg_resources

from .test_resources import Metadata


def strip_comments(s):
    return '\n'.join(
        line for line in s.split('\n')
        if line.strip() and not line.strip().startswith('#')
    )


def parse_distributions(s):
    '''
    Parse a series of distribution specs of the form:
    {project_name}-{version}
       [optional, indented requirements specification]

    Example:

        foo-0.2
        bar-1.0
          foo>=3.0
          [feature]
          baz

    yield 2 distributions:
        - project_name=foo, version=0.2
        - project_name=bar, version=1.0,
          requires=['foo>=3.0', 'baz; extra=="feature"']
    '''
    s = s.strip()
    for spec in re.split(r'\n(?=[^\s])', s):
        if not spec:
            continue
        fields = spec.split('\n', 1)
        assert 1 <= len(fields) <= 2
        name, version = fields.pop(0).split('-')
        if fields:
            requires = textwrap.dedent(fields.pop(0))
            metadata = Metadata(('requires.txt', requires))
        else:
            metadata = None
        dist = pkg_resources.Distribution(project_name=name,
                                          version=version,
                                          metadata=metadata)
        yield dist


class FakeInstaller:

    def __init__(self, installable_dists):
        self._installable_dists = installable_dists

    def __call__(self, req):
        return next(iter(filter(lambda dist: dist in req,
                                self._installable_dists)), None)


def parametrize_test_working_set_resolve(*test_list):
    idlist = []
    argvalues = []
    for test in test_list:
        (
            name,
            installed_dists,
            installable_dists,
            requirements,
            expected1, expected2
        ) = [
            strip_comments(s.lstrip()) for s in
            textwrap.dedent(test).lstrip().split('\n\n', 5)
        ]
        installed_dists = list(parse_distributions(installed_dists))
        installable_dists = list(parse_distributions(installable_dists))
        requirements = list(pkg_resources.parse_requirements(requirements))
        for id_, replace_conflicting, expected in (
            (name, False, expected1),
            (name + '_replace_conflicting', True, expected2),
        ):
            idlist.append(id_)
            expected = strip_comments(expected.strip())
            if re.match(r'\w+$', expected):
                expected = getattr(pkg_resources, expected)
                assert issubclass(expected, Exception)
            else:
                expected = list(parse_distributions(expected))
            argvalues.append(pytest.param(installed_dists, installable_dists,
                                          requirements, replace_conflicting,
                                          expected))
    return pytest.mark.parametrize('installed_dists,installable_dists,'
                                   'requirements,replace_conflicting,'
                                   'resolved_dists_or_exception',
                                   argvalues, ids=idlist)


@parametrize_test_working_set_resolve(
    '''
    # id
    noop

    # installed

    # installable

    # wanted

    # resolved

    # resolved [replace conflicting]
    ''',

    '''
    # id
    already_installed

    # installed
    foo-3.0

    # installable

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    foo-3.0

    # resolved [replace conflicting]
    foo-3.0
    ''',

    '''
    # id
    installable_not_installed

    # installed

    # installable
    foo-3.0
    foo-4.0

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    foo-3.0

    # resolved [replace conflicting]
    foo-3.0
    ''',

    '''
    # id
    not_installable

    # installed

    # installable

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    DistributionNotFound

    # resolved [replace conflicting]
    DistributionNotFound
    ''',

    '''
    # id
    no_matching_version

    # installed

    # installable
    foo-3.1

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    DistributionNotFound

    # resolved [replace conflicting]
    DistributionNotFound
    ''',

    '''
    # id
    installable_with_installed_conflict

    # installed
    foo-3.1

    # installable
    foo-3.5

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    foo-3.5
    ''',

    '''
    # id
    not_installable_with_installed_conflict

    # installed
    foo-3.1

    # installable

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    DistributionNotFound
    ''',

    '''
    # id
    installed_with_installed_require

    # installed
    foo-3.9
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',

    '''
    # id
    installed_with_conflicting_installed_require

    # installed
    foo-5
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable

    # wanted
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    DistributionNotFound
    ''',

    '''
    # id
    installed_with_installable_conflicting_require

    # installed
    foo-5
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable
    foo-2.9

    # wanted
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    baz-0.1
    foo-2.9
    ''',

    '''
    # id
    installed_with_installable_require

    # installed
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable
    foo-3.9

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',

    '''
    # id
    installable_with_installed_require

    # installed
    foo-3.9

    # installable
    baz-0.1
        foo>=2.1,!=3.1,<4

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',

    '''
    # id
    installable_with_installable_require

    # installed

    # installable
    foo-3.9
    baz-0.1
        foo>=2.1,!=3.1,<4

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',

    '''
    # id
    installable_with_conflicting_installable_require

    # installed
    foo-5

    # installable
    foo-2.9
    baz-0.1
        foo>=2.1,!=3.1,<4

    # wanted
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    baz-0.1
    foo-2.9
    ''',

    '''
    # id
    conflicting_installables

    # installed

    # installable
    foo-2.9
    foo-5.0

    # wanted
    foo>=2.1,!=3.1,<4
    foo>=4

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    VersionConflict
    ''',

    '''
    # id
    installables_with_conflicting_requires

    # installed

    # installable
    foo-2.9
        dep==1.0
    baz-5.0
        dep==2.0
    dep-1.0
    dep-2.0

    # wanted
    foo
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    VersionConflict
    ''',

    '''
    # id
    installables_with_conflicting_nested_requires

    # installed

    # installable
    foo-2.9
        dep1
    dep1-1.0
        subdep<1.0
    baz-5.0
        dep2
    dep2-1.0
        subdep>1.0
    subdep-0.9
    subdep-1.1

    # wanted
    foo
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    VersionConflict
    ''',
)
def test_working_set_resolve(installed_dists, installable_dists, requirements,
                             replace_conflicting, resolved_dists_or_exception):
    ws = pkg_resources.WorkingSet([])
    list(map(ws.add, installed_dists))
    resolve_call = functools.partial(
        ws.resolve,
        requirements, installer=FakeInstaller(installable_dists),
        replace_conflicting=replace_conflicting,
    )
    if inspect.isclass(resolved_dists_or_exception):
        with pytest.raises(resolved_dists_or_exception):
            resolve_call()
    else:
        assert sorted(resolve_call()) == sorted(resolved_dists_or_exception)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pyproject.toml0000644000175100001710000000230400000000000016307 0ustar00runnerdocker[build-system]
requires = []
build-backend = "setuptools.build_meta"
backend-path = ["."]

[tool.black]
skip-string-normalization = true

[tool.setuptools_scm]

[pytest.enabler.black]
#addopts = "--black"

[pytest.enabler.mypy]
#addopts = "--mypy"

[pytest.enabler.flake8]
addopts = "--flake8"

[pytest.enabler.cov]
addopts = "--cov"

[pytest.enabler.xdist]
addopts = "-n auto"

[tool.towncrier]
    package = "setuptools"
    package_dir = "setuptools"
    filename = "CHANGES.rst"
    directory = "changelog.d"
    title_format = "v{version}"
    issue_format = "#{issue}"
    template = "towncrier_template.rst"
    underlines = ["-", "^"]

    [[tool.towncrier.type]]
        directory = "deprecation"
        name = "Deprecations"
        showcontent = true

    [[tool.towncrier.type]]
        directory = "breaking"
        name = "Breaking Changes"
        showcontent = true

    [[tool.towncrier.type]]
        directory = "change"
        name = "Changes"
        showcontent = true

    [[tool.towncrier.type]]
        directory = "doc"
        name = "Documentation changes"
        showcontent = true

    [[tool.towncrier.type]]
        directory = "misc"
        name = "Misc"
        showcontent = true
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/pytest.ini0000644000175100001710000000342000000000000015424 0ustar00runnerdocker[pytest]
norecursedirs=dist build .tox .eggs
addopts=
	--doctest-modules
	--doctest-glob=pkg_resources/api_tests.txt
	-r sxX
doctest_optionflags=ALLOW_UNICODE ELLIPSIS
filterwarnings=
	# Fail on warnings
	error

	## upstream
	# Suppress deprecation warning in flake8
	ignore:SelectableGroups dict interface is deprecated::flake8
	# Suppress deprecation warning in pypa/packaging#433
	ignore:The distutils package is deprecated::packaging.tags
	## end upstream

	# https://github.com/pypa/setuptools/issues/1823
	ignore:bdist_wininst command is deprecated
	# Suppress this error; unimportant for CI tests
	ignore:Extraction path is writable by group/others:UserWarning
	# Suppress weird RuntimeWarning.
	ignore:Parent module 'setuptools' not found while handling absolute import:RuntimeWarning
	# Suppress use of bytes for filenames on Windows until fixed #2016
	ignore:The Windows bytes API has been deprecated:DeprecationWarning

	# https://github.com/pypa/setuptools/issues/2823
	ignore:setuptools.installer is deprecated.

	# https://github.com/pypa/setuptools/issues/917
	ignore:setup.py install is deprecated.
	ignore:easy_install command is deprecated.

	# https://github.com/pypa/setuptools/issues/2497
	ignore:.* is an invalid version and will not be supported::pkg_resources

	# https://github.com/pypa/setuptools/pull/2865#issuecomment-965700112
	# ideally would apply to Python 3.10+ when
	# SETUPTOOLS_USE_DISTUTILS=stdlib but for
	# https://github.com/pytest-dev/pytest/discussions/9296
	ignore:The distutils.sysconfig module is deprecated, use sysconfig instead

	# Workaround for pypa/setuptools#2868
	# ideally would apply to PyPy only but for
	# https://github.com/pytest-dev/pytest/discussions/9296
	ignore:Distutils was imported before setuptools
	ignore:Setuptools is replacing distutils
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9586704
setuptools-59.6.0/setup.cfg0000644000175100001710000001044000000000000015214 0ustar00runnerdocker[metadata]
name = setuptools
version = 59.6.0
author = Python Packaging Authority
author_email = distutils-sig@python.org
description = Easily download, build, install, upgrade, and uninstall Python packages
long_description = file:README.rst
url = https://github.com/pypa/setuptools
classifiers = 
	Development Status :: 5 - Production/Stable
	Intended Audience :: Developers
	License :: OSI Approved :: MIT License
	Programming Language :: Python :: 3
	Programming Language :: Python :: 3 :: Only
	Topic :: Software Development :: Libraries :: Python Modules
	Topic :: System :: Archiving :: Packaging
	Topic :: System :: Systems Administration
	Topic :: Utilities
keywords = CPAN PyPI distutils eggs package management
project_urls = 
	Documentation = https://setuptools.pypa.io/

[options]
packages = find_namespace:
python_requires = >=3.6
install_requires = 

[options.packages.find]
exclude = 
	build*
	dist*
	docs*
	tests*
	*.tests
	tools*

[options.extras_require]
testing = 
	pytest >= 6
	pytest-checkdocs >= 2.4
	pytest-flake8
	pytest-black >= 0.3.7; \
	python_implementation != "PyPy"
	pytest-cov
	pytest-mypy; \
	python_implementation != "PyPy"
	pytest-enabler >= 1.0.1
	
	mock
	flake8-2020
	virtualenv>=13.0.0
	pytest-virtualenv>=1.2.7  # TODO: Update once man-group/pytest-plugins#188 is solved
	wheel
	paver
	pip>=19.1 # For proper file:// URLs support.
	jaraco.envs>=2.2
	pytest-xdist
	sphinx
	jaraco.path>=3.2.0
docs = 
	sphinx
	jaraco.packaging >= 8.2
	rst.linker >= 1.9
	jaraco.tidelift >= 1.4
	
	pygments-github-lexers==0.0.5
	sphinx-inline-tabs
	sphinxcontrib-towncrier
	furo
ssl = 
certs = 

[options.entry_points]
distutils.commands = 
	alias = setuptools.command.alias:alias
	bdist_egg = setuptools.command.bdist_egg:bdist_egg
	bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
	build_clib = setuptools.command.build_clib:build_clib
	build_ext = setuptools.command.build_ext:build_ext
	build_py = setuptools.command.build_py:build_py
	develop = setuptools.command.develop:develop
	dist_info = setuptools.command.dist_info:dist_info
	easy_install = setuptools.command.easy_install:easy_install
	egg_info = setuptools.command.egg_info:egg_info
	install = setuptools.command.install:install
	install_egg_info = setuptools.command.install_egg_info:install_egg_info
	install_lib = setuptools.command.install_lib:install_lib
	install_scripts = setuptools.command.install_scripts:install_scripts
	rotate = setuptools.command.rotate:rotate
	saveopts = setuptools.command.saveopts:saveopts
	sdist = setuptools.command.sdist:sdist
	setopt = setuptools.command.setopt:setopt
	test = setuptools.command.test:test
	upload_docs = setuptools.command.upload_docs:upload_docs
setuptools.finalize_distribution_options = 
	parent_finalize = setuptools.dist:_Distribution.finalize_options
	keywords = setuptools.dist:Distribution._finalize_setup_keywords
distutils.setup_keywords = 
	eager_resources = setuptools.dist:assert_string_list
	namespace_packages = setuptools.dist:check_nsp
	extras_require = setuptools.dist:check_extras
	install_requires = setuptools.dist:check_requirements
	tests_require = setuptools.dist:check_requirements
	setup_requires = setuptools.dist:check_requirements
	python_requires = setuptools.dist:check_specifier
	entry_points = setuptools.dist:check_entry_points
	test_suite = setuptools.dist:check_test_suite
	zip_safe = setuptools.dist:assert_bool
	package_data = setuptools.dist:check_package_data
	exclude_package_data = setuptools.dist:check_package_data
	include_package_data = setuptools.dist:assert_bool
	packages = setuptools.dist:check_packages
	dependency_links = setuptools.dist:assert_string_list
	test_loader = setuptools.dist:check_importable
	test_runner = setuptools.dist:check_importable
	use_2to3 = setuptools.dist:invalid_unless_false
egg_info.writers = 
	PKG-INFO = setuptools.command.egg_info:write_pkg_info
	requires.txt = setuptools.command.egg_info:write_requirements
	entry_points.txt = setuptools.command.egg_info:write_entries
	eager_resources.txt = setuptools.command.egg_info:overwrite_arg
	namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
	top_level.txt = setuptools.command.egg_info:write_toplevel_names
	depends.txt = setuptools.command.egg_info:warn_depends_obsolete
	dependency_links.txt = setuptools.command.egg_info:overwrite_arg

[egg_info]
tag_build = 
tag_date = 0

[sdist]
formats = zip

././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setup.py0000755000175100001710000000510200000000000015107 0ustar00runnerdocker#!/usr/bin/env python

import os
import sys
import textwrap

import setuptools
from setuptools.command.install import install

here = os.path.dirname(__file__)


package_data = dict(
    setuptools=['script (dev).tmpl', 'script.tmpl', 'site-patch.py'],
)

force_windows_specific_files = (
    os.environ.get("SETUPTOOLS_INSTALL_WINDOWS_SPECIFIC_FILES", "1").lower()
    not in ("", "0", "false", "no")
)

include_windows_files = sys.platform == 'win32' or force_windows_specific_files

if include_windows_files:
    package_data.setdefault('setuptools', []).extend(['*.exe'])
    package_data.setdefault('setuptools.command', []).extend(['*.xml'])


def pypi_link(pkg_filename):
    """
    Given the filename, including md5 fragment, construct the
    dependency link for PyPI.
    """
    root = 'https://files.pythonhosted.org/packages/source'
    name, sep, rest = pkg_filename.partition('-')
    parts = root, name[0], name, pkg_filename
    return '/'.join(parts)


class install_with_pth(install):
    """
    Custom install command to install a .pth file for distutils patching.

    This hack is necessary because there's no standard way to install behavior
    on startup (and it's debatable if there should be one). This hack (ab)uses
    the `extra_path` behavior in Setuptools to install a `.pth` file with
    implicit behavior on startup to give higher precedence to the local version
    of `distutils` over the version from the standard library.

    Please do not replicate this behavior.
    """

    _pth_name = 'distutils-precedence'
    _pth_contents = textwrap.dedent("""
        import os
        var = 'SETUPTOOLS_USE_DISTUTILS'
        enabled = os.environ.get(var, 'stdlib') == 'local'
        enabled and __import__('_distutils_hack').add_shim()
        """).lstrip().replace('\n', '; ')

    def initialize_options(self):
        install.initialize_options(self)
        self.extra_path = self._pth_name, self._pth_contents

    def finalize_options(self):
        install.finalize_options(self)
        self._restore_install_lib()

    def _restore_install_lib(self):
        """
        Undo secondary effect of `extra_path` adding to `install_lib`
        """
        suffix = os.path.relpath(self.install_lib, self.install_libbase)

        if suffix.strip() == self._pth_contents.strip():
            self.install_lib = self.install_libbase


setup_params = dict(
    cmdclass={'install': install_with_pth},
    package_data=package_data,
)

if __name__ == '__main__':
    # allow setup.py to run from another directory
    here and os.chdir(here)
    dist = setuptools.setup(**setup_params)
././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1639341979.91467
setuptools-59.6.0/setuptools/0000755000175100001710000000000000000000000015615 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/__init__.py0000644000175100001710000001643000000000000017732 0ustar00runnerdocker"""Extensions to the 'distutils' for large or complex distributions"""

from fnmatch import fnmatchcase
import functools
import os
import re

import _distutils_hack.override  # noqa: F401

import distutils.core
from distutils.errors import DistutilsOptionError
from distutils.util import convert_path

from ._deprecation_warning import SetuptoolsDeprecationWarning

import setuptools.version
from setuptools.extension import Extension
from setuptools.dist import Distribution
from setuptools.depends import Require
from . import monkey


__all__ = [
    'setup',
    'Distribution',
    'Command',
    'Extension',
    'Require',
    'SetuptoolsDeprecationWarning',
    'find_packages',
    'find_namespace_packages',
]

__version__ = setuptools.version.__version__

bootstrap_install_from = None


class PackageFinder:
    """
    Generate a list of all Python packages found within a directory
    """

    @classmethod
    def find(cls, where='.', exclude=(), include=('*',)):
        """Return a list all Python packages found within directory 'where'

        'where' is the root directory which will be searched for packages.  It
        should be supplied as a "cross-platform" (i.e. URL-style) path; it will
        be converted to the appropriate local path syntax.

        'exclude' is a sequence of package names to exclude; '*' can be used
        as a wildcard in the names, such that 'foo.*' will exclude all
        subpackages of 'foo' (but not 'foo' itself).

        'include' is a sequence of package names to include.  If it's
        specified, only the named packages will be included.  If it's not
        specified, all found packages will be included.  'include' can contain
        shell style wildcard patterns just like 'exclude'.
        """

        return list(
            cls._find_packages_iter(
                convert_path(where),
                cls._build_filter('ez_setup', '*__pycache__', *exclude),
                cls._build_filter(*include),
            )
        )

    @classmethod
    def _find_packages_iter(cls, where, exclude, include):
        """
        All the packages found in 'where' that pass the 'include' filter, but
        not the 'exclude' filter.
        """
        for root, dirs, files in os.walk(where, followlinks=True):
            # Copy dirs to iterate over it, then empty dirs.
            all_dirs = dirs[:]
            dirs[:] = []

            for dir in all_dirs:
                full_path = os.path.join(root, dir)
                rel_path = os.path.relpath(full_path, where)
                package = rel_path.replace(os.path.sep, '.')

                # Skip directory trees that are not valid packages
                if '.' in dir or not cls._looks_like_package(full_path):
                    continue

                # Should this package be included?
                if include(package) and not exclude(package):
                    yield package

                # Keep searching subdirectories, as there may be more packages
                # down there, even if the parent was excluded.
                dirs.append(dir)

    @staticmethod
    def _looks_like_package(path):
        """Does a directory look like a package?"""
        return os.path.isfile(os.path.join(path, '__init__.py'))

    @staticmethod
    def _build_filter(*patterns):
        """
        Given a list of patterns, return a callable that will be true only if
        the input matches at least one of the patterns.
        """
        return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns)


class PEP420PackageFinder(PackageFinder):
    @staticmethod
    def _looks_like_package(path):
        return True


find_packages = PackageFinder.find
find_namespace_packages = PEP420PackageFinder.find


def _install_setup_requires(attrs):
    # Note: do not use `setuptools.Distribution` directly, as
    # our PEP 517 backend patch `distutils.core.Distribution`.
    class MinimalDistribution(distutils.core.Distribution):
        """
        A minimal version of a distribution for supporting the
        fetch_build_eggs interface.
        """

        def __init__(self, attrs):
            _incl = 'dependency_links', 'setup_requires'
            filtered = {k: attrs[k] for k in set(_incl) & set(attrs)}
            distutils.core.Distribution.__init__(self, filtered)

        def finalize_options(self):
            """
            Disable finalize_options to avoid building the working set.
            Ref #2158.
            """

    dist = MinimalDistribution(attrs)

    # Honor setup.cfg's options.
    dist.parse_config_files(ignore_option_errors=True)
    if dist.setup_requires:
        dist.fetch_build_eggs(dist.setup_requires)


def setup(**attrs):
    # Make sure we have any requirements needed to interpret 'attrs'.
    _install_setup_requires(attrs)
    return distutils.core.setup(**attrs)


setup.__doc__ = distutils.core.setup.__doc__


_Command = monkey.get_unpatched(distutils.core.Command)


class Command(_Command):
    __doc__ = _Command.__doc__

    command_consumes_arguments = False

    def __init__(self, dist, **kw):
        """
        Construct the command for dist, updating
        vars(self) with any keyword parameters.
        """
        _Command.__init__(self, dist)
        vars(self).update(kw)

    def _ensure_stringlike(self, option, what, default=None):
        val = getattr(self, option)
        if val is None:
            setattr(self, option, default)
            return default
        elif not isinstance(val, str):
            raise DistutilsOptionError(
                "'%s' must be a %s (got `%s`)" % (option, what, val)
            )
        return val

    def ensure_string_list(self, option):
        r"""Ensure that 'option' is a list of strings.  If 'option' is
        currently a string, we split it either on /,\s*/ or /\s+/, so
        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
        ["foo", "bar", "baz"].
        """
        val = getattr(self, option)
        if val is None:
            return
        elif isinstance(val, str):
            setattr(self, option, re.split(r',\s*|\s+', val))
        else:
            if isinstance(val, list):
                ok = all(isinstance(v, str) for v in val)
            else:
                ok = False
            if not ok:
                raise DistutilsOptionError(
                    "'%s' must be a list of strings (got %r)" % (option, val)
                )

    def reinitialize_command(self, command, reinit_subcommands=0, **kw):
        cmd = _Command.reinitialize_command(self, command, reinit_subcommands)
        vars(cmd).update(kw)
        return cmd


def _find_all_simple(path):
    """
    Find all files under 'path'
    """
    results = (
        os.path.join(base, file)
        for base, dirs, files in os.walk(path, followlinks=True)
        for file in files
    )
    return filter(os.path.isfile, results)


def findall(dir=os.curdir):
    """
    Find all files under 'dir' and return the list of full filenames.
    Unless dir is '.', return full filenames with dir prepended.
    """
    files = _find_all_simple(dir)
    if dir == os.curdir:
        make_rel = functools.partial(os.path.relpath, start=dir)
        files = map(make_rel, files)
    return list(files)


class sic(str):
    """Treat this string as-is (https://en.wikipedia.org/wiki/Sic)"""


# Apply monkey patches
monkey.patch_all()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_deprecation_warning.py0000644000175100001710000000033200000000000022346 0ustar00runnerdockerclass SetuptoolsDeprecationWarning(Warning):
    """
    Base class for warning deprecations in ``setuptools``

    This class is not derived from ``DeprecationWarning``, and as such is
    visible by default.
    """
././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1639341979.91867
setuptools-59.6.0/setuptools/_distutils/0000755000175100001710000000000000000000000020000 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/__init__.py0000644000175100001710000000103000000000000022103 0ustar00runnerdocker"""distutils

The main package for the Python Module Distribution Utilities.  Normally
used from a setup script as

   from distutils.core import setup

   setup (...)
"""

import sys
import importlib

__version__ = sys.version[:sys.version.index(' ')]


try:
    # Allow Debian and pkgsrc (only) to customize system
    # behavior. Ref pypa/distutils#2 and pypa/distutils#16.
    # This hook is deprecated and no other environments
    # should use it.
    importlib.import_module('_distutils_system_mod')
except ImportError:
    pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/_msvccompiler.py0000644000175100001710000005051500000000000023222 0ustar00runnerdocker"""distutils._msvccompiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for Microsoft Visual Studio 2015.

The module is compatible with VS 2015 and later. You can find legacy support
for older versions in distutils.msvc9compiler and distutils.msvccompiler.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)
# ported to VS 2005 and VS 2008 by Christian Heimes
# ported to VS 2015 by Steve Dower

import os
import subprocess
import contextlib
import warnings
import unittest.mock
with contextlib.suppress(ImportError):
    import winreg

from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
                             CompileError, LibError, LinkError
from distutils.ccompiler import CCompiler, gen_lib_options
from distutils import log
from distutils.util import get_platform

from itertools import count

def _find_vc2015():
    try:
        key = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE,
            r"Software\Microsoft\VisualStudio\SxS\VC7",
            access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY
        )
    except OSError:
        log.debug("Visual C++ is not registered")
        return None, None

    best_version = 0
    best_dir = None
    with key:
        for i in count():
            try:
                v, vc_dir, vt = winreg.EnumValue(key, i)
            except OSError:
                break
            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
                try:
                    version = int(float(v))
                except (ValueError, TypeError):
                    continue
                if version >= 14 and version > best_version:
                    best_version, best_dir = version, vc_dir
    return best_version, best_dir

def _find_vc2017():
    """Returns "15, path" based on the result of invoking vswhere.exe
    If no install is found, returns "None, None"

    The version is returned to avoid unnecessarily changing the function
    result. It may be ignored when the path is not None.

    If vswhere.exe is not available, by definition, VS 2017 is not
    installed.
    """
    root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
    if not root:
        return None, None

    try:
        path = subprocess.check_output([
            os.path.join(root, "Microsoft Visual Studio", "Installer", "vswhere.exe"),
            "-latest",
            "-prerelease",
            "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
            "-property", "installationPath",
            "-products", "*",
        ], encoding="mbcs", errors="strict").strip()
    except (subprocess.CalledProcessError, OSError, UnicodeDecodeError):
        return None, None

    path = os.path.join(path, "VC", "Auxiliary", "Build")
    if os.path.isdir(path):
        return 15, path

    return None, None

PLAT_SPEC_TO_RUNTIME = {
    'x86' : 'x86',
    'x86_amd64' : 'x64',
    'x86_arm' : 'arm',
    'x86_arm64' : 'arm64'
}

def _find_vcvarsall(plat_spec):
    # bpo-38597: Removed vcruntime return value
    _, best_dir = _find_vc2017()

    if not best_dir:
        best_version, best_dir = _find_vc2015()

    if not best_dir:
        log.debug("No suitable Visual C++ version found")
        return None, None

    vcvarsall = os.path.join(best_dir, "vcvarsall.bat")
    if not os.path.isfile(vcvarsall):
        log.debug("%s cannot be found", vcvarsall)
        return None, None

    return vcvarsall, None

def _get_vc_env(plat_spec):
    if os.getenv("DISTUTILS_USE_SDK"):
        return {
            key.lower(): value
            for key, value in os.environ.items()
        }

    vcvarsall, _ = _find_vcvarsall(plat_spec)
    if not vcvarsall:
        raise DistutilsPlatformError("Unable to find vcvarsall.bat")

    try:
        out = subprocess.check_output(
            'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
            stderr=subprocess.STDOUT,
        ).decode('utf-16le', errors='replace')
    except subprocess.CalledProcessError as exc:
        log.error(exc.output)
        raise DistutilsPlatformError("Error executing {}"
                .format(exc.cmd))

    env = {
        key.lower(): value
        for key, _, value in
        (line.partition('=') for line in out.splitlines())
        if key and value
    }

    return env

def _find_exe(exe, paths=None):
    """Return path to an MSVC executable program.

    Tries to find the program in several places: first, one of the
    MSVC program search paths from the registry; next, the directories
    in the PATH environment variable.  If any of those work, return an
    absolute path that is known to exist.  If none of them work, just
    return the original program name, 'exe'.
    """
    if not paths:
        paths = os.getenv('path').split(os.pathsep)
    for p in paths:
        fn = os.path.join(os.path.abspath(p), exe)
        if os.path.isfile(fn):
            return fn
    return exe

# A map keyed by get_platform() return values to values accepted by
# 'vcvarsall.bat'. Always cross-compile from x86 to work with the
# lighter-weight MSVC installs that do not include native 64-bit tools.
PLAT_TO_VCVARS = {
    'win32' : 'x86',
    'win-amd64' : 'x86_amd64',
    'win-arm32' : 'x86_arm',
    'win-arm64' : 'x86_arm64'
}

class MSVCCompiler(CCompiler) :
    """Concrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class."""

    compiler_type = 'msvc'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']
    _rc_extensions = ['.rc']
    _mc_extensions = ['.mc']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = (_c_extensions + _cpp_extensions +
                      _rc_extensions + _mc_extensions)
    res_extension = '.res'
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'


    def __init__(self, verbose=0, dry_run=0, force=0):
        CCompiler.__init__ (self, verbose, dry_run, force)
        # target platform (.plat_name is consistent with 'bdist')
        self.plat_name = None
        self.initialized = False

    def initialize(self, plat_name=None):
        # multi-init means we would need to check platform same each time...
        assert not self.initialized, "don't init multiple times"
        if plat_name is None:
            plat_name = get_platform()
        # sanity check for platforms to prevent obscure errors later.
        if plat_name not in PLAT_TO_VCVARS:
            raise DistutilsPlatformError("--plat-name must be one of {}"
                                         .format(tuple(PLAT_TO_VCVARS)))

        # Get the vcvarsall.bat spec for the requested platform.
        plat_spec = PLAT_TO_VCVARS[plat_name]

        vc_env = _get_vc_env(plat_spec)
        if not vc_env:
            raise DistutilsPlatformError("Unable to find a compatible "
                "Visual Studio installation.")

        self._paths = vc_env.get('path', '')
        paths = self._paths.split(os.pathsep)
        self.cc = _find_exe("cl.exe", paths)
        self.linker = _find_exe("link.exe", paths)
        self.lib = _find_exe("lib.exe", paths)
        self.rc = _find_exe("rc.exe", paths)   # resource compiler
        self.mc = _find_exe("mc.exe", paths)   # message compiler
        self.mt = _find_exe("mt.exe", paths)   # message compiler

        for dir in vc_env.get('include', '').split(os.pathsep):
            if dir:
                self.add_include_dir(dir.rstrip(os.sep))

        for dir in vc_env.get('lib', '').split(os.pathsep):
            if dir:
                self.add_library_dir(dir.rstrip(os.sep))

        self.preprocess_options = None
        # bpo-38597: Always compile with dynamic linking
        # Future releases of Python 3.x will include all past
        # versions of vcruntime*.dll for compatibility.
        self.compile_options = [
            '/nologo', '/O2', '/W3', '/GL', '/DNDEBUG', '/MD'
        ]

        self.compile_options_debug = [
            '/nologo', '/Od', '/MDd', '/Zi', '/W3', '/D_DEBUG'
        ]

        ldflags = [
            '/nologo', '/INCREMENTAL:NO', '/LTCG'
        ]

        ldflags_debug = [
            '/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL'
        ]

        self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
        self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
        self.ldflags_shared = [*ldflags, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
        self.ldflags_shared_debug = [*ldflags_debug, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
        self.ldflags_static = [*ldflags]
        self.ldflags_static_debug = [*ldflags_debug]

        self._ldflags = {
            (CCompiler.EXECUTABLE, None): self.ldflags_exe,
            (CCompiler.EXECUTABLE, False): self.ldflags_exe,
            (CCompiler.EXECUTABLE, True): self.ldflags_exe_debug,
            (CCompiler.SHARED_OBJECT, None): self.ldflags_shared,
            (CCompiler.SHARED_OBJECT, False): self.ldflags_shared,
            (CCompiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
            (CCompiler.SHARED_LIBRARY, None): self.ldflags_static,
            (CCompiler.SHARED_LIBRARY, False): self.ldflags_static,
            (CCompiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
        }

        self.initialized = True

    # -- Worker methods ------------------------------------------------

    def object_filenames(self,
                         source_filenames,
                         strip_dir=0,
                         output_dir=''):
        ext_map = {
            **{ext: self.obj_extension for ext in self.src_extensions},
            **{ext: self.res_extension for ext in self._rc_extensions + self._mc_extensions},
        }

        output_dir = output_dir or ''

        def make_out_path(p):
            base, ext = os.path.splitext(p)
            if strip_dir:
                base = os.path.basename(base)
            else:
                _, base = os.path.splitdrive(base)
                if base.startswith((os.path.sep, os.path.altsep)):
                    base = base[1:]
            try:
                # XXX: This may produce absurdly long paths. We should check
                # the length of the result and trim base until we fit within
                # 260 characters.
                return os.path.join(output_dir, base + ext_map[ext])
            except LookupError:
                # Better to raise an exception instead of silently continuing
                # and later complain about sources and targets having
                # different lengths
                raise CompileError("Don't know how to compile {}".format(p))

        return list(map(make_out_path, source_filenames))


    def compile(self, sources,
                output_dir=None, macros=None, include_dirs=None, debug=0,
                extra_preargs=None, extra_postargs=None, depends=None):

        if not self.initialized:
            self.initialize()
        compile_info = self._setup_compile(output_dir, macros, include_dirs,
                                           sources, depends, extra_postargs)
        macros, objects, extra_postargs, pp_opts, build = compile_info

        compile_opts = extra_preargs or []
        compile_opts.append('/c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)


        add_cpp_opts = False

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            if debug:
                # pass the full pathname to MSVC in debug mode,
                # this allows the debugger to find the source file
                # without asking the user to browse for it
                src = os.path.abspath(src)

            if ext in self._c_extensions:
                input_opt = "/Tc" + src
            elif ext in self._cpp_extensions:
                input_opt = "/Tp" + src
                add_cpp_opts = True
            elif ext in self._rc_extensions:
                # compile .RC to .RES file
                input_opt = src
                output_opt = "/fo" + obj
                try:
                    self.spawn([self.rc] + pp_opts + [output_opt, input_opt])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            elif ext in self._mc_extensions:
                # Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.
                h_dir = os.path.dirname(src)
                rc_dir = os.path.dirname(obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn([self.mc, '-h', h_dir, '-r', rc_dir, src])
                    base, _ = os.path.splitext(os.path.basename (src))
                    rc_file = os.path.join(rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn([self.rc, "/fo" + obj, rc_file])

                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            else:
                # how to handle this file?
                raise CompileError("Don't know how to compile {} to {}"
                                   .format(src, obj))

            args = [self.cc] + compile_opts + pp_opts
            if add_cpp_opts:
                args.append('/EHsc')
            args.append(input_opt)
            args.append("/Fo" + obj)
            args.extend(extra_postargs)

            try:
                self.spawn(args)
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects


    def create_static_lib(self,
                          objects,
                          output_libname,
                          output_dir=None,
                          debug=0,
                          target_lang=None):

        if not self.initialized:
            self.initialize()
        objects, output_dir = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname,
                                                output_dir=output_dir)

        if self._need_link(objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass # XXX what goes here?
            try:
                log.debug('Executing "%s" %s', self.lib, ' '.join(lib_args))
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)


    def link(self,
             target_desc,
             objects,
             output_filename,
             output_dir=None,
             libraries=None,
             library_dirs=None,
             runtime_library_dirs=None,
             export_symbols=None,
             debug=0,
             extra_preargs=None,
             extra_postargs=None,
             build_temp=None,
             target_lang=None):

        if not self.initialized:
            self.initialize()
        objects, output_dir = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs,
                                        runtime_library_dirs)
        libraries, library_dirs, runtime_library_dirs = fixed_args

        if runtime_library_dirs:
            self.warn("I don't know what to do with 'runtime_library_dirs': "
                       + str(runtime_library_dirs))

        lib_opts = gen_lib_options(self,
                                   library_dirs, runtime_library_dirs,
                                   libraries)
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            ldflags = self._ldflags[target_desc, debug]

            export_opts = ["/EXPORT:" + sym for sym in (export_symbols or [])]

            ld_args = (ldflags + lib_opts + export_opts +
                       objects + ['/OUT:' + output_filename])

            # The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            build_temp = os.path.dirname(objects[0])
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename))
                implib_file = os.path.join(
                    build_temp,
                    self.library_filename(dll_name))
                ld_args.append ('/IMPLIB:' + implib_file)

            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            output_dir = os.path.dirname(os.path.abspath(output_filename))
            self.mkpath(output_dir)
            try:
                log.debug('Executing "%s" %s', self.linker, ' '.join(ld_args))
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def spawn(self, cmd):
        env = dict(os.environ, PATH=self._paths)
        with self._fallback_spawn(cmd, env) as fallback:
            return super().spawn(cmd, env=env)
        return fallback.value

    @contextlib.contextmanager
    def _fallback_spawn(self, cmd, env):
        """
        Discovered in pypa/distutils#15, some tools monkeypatch the compiler,
        so the 'env' kwarg causes a TypeError. Detect this condition and
        restore the legacy, unsafe behavior.
        """
        bag = type('Bag', (), {})()
        try:
            yield bag
        except TypeError as exc:
            if "unexpected keyword argument 'env'" not in str(exc):
                raise
        else:
            return
        warnings.warn(
            "Fallback spawn triggered. Please update distutils monkeypatch.")
        with unittest.mock.patch('os.environ', env):
            bag.value = super().spawn(cmd)

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "/LIBPATH:" + dir

    def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(
              "don't know how to set runtime library search path for MSVC")

    def library_option(self, lib):
        return self.library_filename(lib)

    def find_library_file(self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename(name))
                if os.path.isfile(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/archive_util.py0000644000175100001710000002057400000000000023040 0ustar00runnerdocker"""distutils.archive_util

Utility functions for creating archive files (tarballs, zip files,
that sort of thing)."""

import os
from warnings import warn
import sys

try:
    import zipfile
except ImportError:
    zipfile = None


from distutils.errors import DistutilsExecError
from distutils.spawn import spawn
from distutils.dir_util import mkpath
from distutils import log

try:
    from pwd import getpwnam
except ImportError:
    getpwnam = None

try:
    from grp import getgrnam
except ImportError:
    getgrnam = None

def _get_gid(name):
    """Returns a gid, given a group name."""
    if getgrnam is None or name is None:
        return None
    try:
        result = getgrnam(name)
    except KeyError:
        result = None
    if result is not None:
        return result[2]
    return None

def _get_uid(name):
    """Returns an uid, given a user name."""
    if getpwnam is None or name is None:
        return None
    try:
        result = getpwnam(name)
    except KeyError:
        result = None
    if result is not None:
        return result[2]
    return None

def make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
                 owner=None, group=None):
    """Create a (possibly compressed) tar file from all the files under
    'base_dir'.

    'compress' must be "gzip" (the default), "bzip2", "xz", "compress", or
    None.  ("compress" will be deprecated in Python 3.2)

    'owner' and 'group' can be used to define an owner and a group for the
    archive that is being built. If not provided, the current owner and group
    will be used.

    The output tar file will be named 'base_dir' +  ".tar", possibly plus
    the appropriate compression extension (".gz", ".bz2", ".xz" or ".Z").

    Returns the output filename.
    """
    tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', 'xz': 'xz', None: '',
                       'compress': ''}
    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz',
                    'compress': '.Z'}

    # flags for compression program, each element of list will be an argument
    if compress is not None and compress not in compress_ext.keys():
        raise ValueError(
              "bad value for 'compress': must be None, 'gzip', 'bzip2', "
              "'xz' or 'compress'")

    archive_name = base_name + '.tar'
    if compress != 'compress':
        archive_name += compress_ext.get(compress, '')

    mkpath(os.path.dirname(archive_name), dry_run=dry_run)

    # creating the tarball
    import tarfile  # late import so Python build itself doesn't break

    log.info('Creating tar archive')

    uid = _get_uid(owner)
    gid = _get_gid(group)

    def _set_uid_gid(tarinfo):
        if gid is not None:
            tarinfo.gid = gid
            tarinfo.gname = group
        if uid is not None:
            tarinfo.uid = uid
            tarinfo.uname = owner
        return tarinfo

    if not dry_run:
        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
        try:
            tar.add(base_dir, filter=_set_uid_gid)
        finally:
            tar.close()

    # compression using `compress`
    if compress == 'compress':
        warn("'compress' will be deprecated.", PendingDeprecationWarning)
        # the option varies depending on the platform
        compressed_name = archive_name + compress_ext[compress]
        if sys.platform == 'win32':
            cmd = [compress, archive_name, compressed_name]
        else:
            cmd = [compress, '-f', archive_name]
        spawn(cmd, dry_run=dry_run)
        return compressed_name

    return archive_name

def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
    """Create a zip file from all the files under 'base_dir'.

    The output zip file will be named 'base_name' + ".zip".  Uses either the
    "zipfile" Python module (if available) or the InfoZIP "zip" utility
    (if installed and found on the default search path).  If neither tool is
    available, raises DistutilsExecError.  Returns the name of the output zip
    file.
    """
    zip_filename = base_name + ".zip"
    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)

    # If zipfile module is not available, try spawning an external
    # 'zip' command.
    if zipfile is None:
        if verbose:
            zipoptions = "-r"
        else:
            zipoptions = "-rq"

        try:
            spawn(["zip", zipoptions, zip_filename, base_dir],
                  dry_run=dry_run)
        except DistutilsExecError:
            # XXX really should distinguish between "couldn't find
            # external 'zip' command" and "zip failed".
            raise DistutilsExecError(("unable to create zip file '%s': "
                   "could neither import the 'zipfile' module nor "
                   "find a standalone zip utility") % zip_filename)

    else:
        log.info("creating '%s' and adding '%s' to it",
                 zip_filename, base_dir)

        if not dry_run:
            try:
                zip = zipfile.ZipFile(zip_filename, "w",
                                      compression=zipfile.ZIP_DEFLATED)
            except RuntimeError:
                zip = zipfile.ZipFile(zip_filename, "w",
                                      compression=zipfile.ZIP_STORED)

            with zip:
                if base_dir != os.curdir:
                    path = os.path.normpath(os.path.join(base_dir, ''))
                    zip.write(path, path)
                    log.info("adding '%s'", path)
                for dirpath, dirnames, filenames in os.walk(base_dir):
                    for name in dirnames:
                        path = os.path.normpath(os.path.join(dirpath, name, ''))
                        zip.write(path, path)
                        log.info("adding '%s'", path)
                    for name in filenames:
                        path = os.path.normpath(os.path.join(dirpath, name))
                        if os.path.isfile(path):
                            zip.write(path, path)
                            log.info("adding '%s'", path)

    return zip_filename

ARCHIVE_FORMATS = {
    'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
    'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
    'xztar': (make_tarball, [('compress', 'xz')], "xz'ed tar-file"),
    'ztar':  (make_tarball, [('compress', 'compress')], "compressed tar file"),
    'tar':   (make_tarball, [('compress', None)], "uncompressed tar file"),
    'zip':   (make_zipfile, [],"ZIP file")
    }

def check_archive_formats(formats):
    """Returns the first format from the 'format' list that is unknown.

    If all formats are known, returns None
    """
    for format in formats:
        if format not in ARCHIVE_FORMATS:
            return format
    return None

def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
                 dry_run=0, owner=None, group=None):
    """Create an archive file (eg. zip or tar).

    'base_name' is the name of the file to create, minus any format-specific
    extension; 'format' is the archive format: one of "zip", "tar", "gztar",
    "bztar", "xztar", or "ztar".

    'root_dir' is a directory that will be the root directory of the
    archive; ie. we typically chdir into 'root_dir' before creating the
    archive.  'base_dir' is the directory where we start archiving from;
    ie. 'base_dir' will be the common prefix of all files and
    directories in the archive.  'root_dir' and 'base_dir' both default
    to the current directory.  Returns the name of the archive file.

    'owner' and 'group' are used when creating a tar archive. By default,
    uses the current owner and group.
    """
    save_cwd = os.getcwd()
    if root_dir is not None:
        log.debug("changing into '%s'", root_dir)
        base_name = os.path.abspath(base_name)
        if not dry_run:
            os.chdir(root_dir)

    if base_dir is None:
        base_dir = os.curdir

    kwargs = {'dry_run': dry_run}

    try:
        format_info = ARCHIVE_FORMATS[format]
    except KeyError:
        raise ValueError("unknown archive format '%s'" % format)

    func = format_info[0]
    for arg, val in format_info[1]:
        kwargs[arg] = val

    if format != 'zip':
        kwargs['owner'] = owner
        kwargs['group'] = group

    try:
        filename = func(base_name, base_dir, **kwargs)
    finally:
        if root_dir is not None:
            log.debug("changing back to '%s'", save_cwd)
            os.chdir(save_cwd)

    return filename
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/bcppcompiler.py0000644000175100001710000003505600000000000023042 0ustar00runnerdocker"""distutils.bcppcompiler

Contains BorlandCCompiler, an implementation of the abstract CCompiler class
for the Borland C++ compiler.
"""

# This implementation by Lyle Johnson, based on the original msvccompiler.py
# module and using the directions originally published by Gordon Williams.

# XXX looks like there's a LOT of overlap between these two classes:
# someone should sit down and factor out the common code as
# WindowsCCompiler!  --GPW


import os
from distutils.errors import \
     DistutilsExecError, \
     CompileError, LibError, LinkError, UnknownFileError
from distutils.ccompiler import \
     CCompiler, gen_preprocess_options
from distutils.file_util import write_file
from distutils.dep_util import newer
from distutils import log

class BCPPCompiler(CCompiler) :
    """Concrete class that implements an interface to the Borland C/C++
    compiler, as defined by the CCompiler abstract class.
    """

    compiler_type = 'bcpp'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = _c_extensions + _cpp_extensions
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'


    def __init__ (self,
                  verbose=0,
                  dry_run=0,
                  force=0):

        CCompiler.__init__ (self, verbose, dry_run, force)

        # These executables are assumed to all be in the path.
        # Borland doesn't seem to use any special registry settings to
        # indicate their installation locations.

        self.cc = "bcc32.exe"
        self.linker = "ilink32.exe"
        self.lib = "tlib.exe"

        self.preprocess_options = None
        self.compile_options = ['/tWM', '/O2', '/q', '/g0']
        self.compile_options_debug = ['/tWM', '/Od', '/q', '/g0']

        self.ldflags_shared = ['/Tpd', '/Gn', '/q', '/x']
        self.ldflags_shared_debug = ['/Tpd', '/Gn', '/q', '/x']
        self.ldflags_static = []
        self.ldflags_exe = ['/Gn', '/q', '/x']
        self.ldflags_exe_debug = ['/Gn', '/q', '/x','/r']


    # -- Worker methods ------------------------------------------------

    def compile(self, sources,
                output_dir=None, macros=None, include_dirs=None, debug=0,
                extra_preargs=None, extra_postargs=None, depends=None):

        macros, objects, extra_postargs, pp_opts, build = \
                self._setup_compile(output_dir, macros, include_dirs, sources,
                                    depends, extra_postargs)
        compile_opts = extra_preargs or []
        compile_opts.append ('-c')
        if debug:
            compile_opts.extend (self.compile_options_debug)
        else:
            compile_opts.extend (self.compile_options)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            # XXX why do the normpath here?
            src = os.path.normpath(src)
            obj = os.path.normpath(obj)
            # XXX _setup_compile() did a mkpath() too but before the normpath.
            # Is it possible to skip the normpath?
            self.mkpath(os.path.dirname(obj))

            if ext == '.res':
                # This is already a binary file -- skip it.
                continue # the 'for' loop
            if ext == '.rc':
                # This needs to be compiled to a .res file -- do it now.
                try:
                    self.spawn (["brcc32", "-fo", obj, src])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue # the 'for' loop

            # The next two are both for the real compiler.
            if ext in self._c_extensions:
                input_opt = ""
            elif ext in self._cpp_extensions:
                input_opt = "-P"
            else:
                # Unknown file type -- no extra options.  The compiler
                # will probably fail, but let it just in case this is a
                # file the compiler recognizes even if we don't.
                input_opt = ""

            output_opt = "-o" + obj

            # Compiler command line syntax is: "bcc32 [options] file(s)".
            # Note that the source file names must appear at the end of
            # the command line.
            try:
                self.spawn ([self.cc] + compile_opts + pp_opts +
                            [input_opt, output_opt] +
                            extra_postargs + [src])
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects

    # compile ()


    def create_static_lib (self,
                           objects,
                           output_libname,
                           output_dir=None,
                           debug=0,
                           target_lang=None):

        (objects, output_dir) = self._fix_object_args (objects, output_dir)
        output_filename = \
            self.library_filename (output_libname, output_dir=output_dir)

        if self._need_link (objects, output_filename):
            lib_args = [output_filename, '/u'] + objects
            if debug:
                pass                    # XXX what goes here?
            try:
                self.spawn ([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    # create_static_lib ()


    def link (self,
              target_desc,
              objects,
              output_filename,
              output_dir=None,
              libraries=None,
              library_dirs=None,
              runtime_library_dirs=None,
              export_symbols=None,
              debug=0,
              extra_preargs=None,
              extra_postargs=None,
              build_temp=None,
              target_lang=None):

        # XXX this ignores 'build_temp'!  should follow the lead of
        # msvccompiler.py

        (objects, output_dir) = self._fix_object_args (objects, output_dir)
        (libraries, library_dirs, runtime_library_dirs) = \
            self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)

        if runtime_library_dirs:
            log.warn("I don't know what to do with 'runtime_library_dirs': %s",
                     str(runtime_library_dirs))

        if output_dir is not None:
            output_filename = os.path.join (output_dir, output_filename)

        if self._need_link (objects, output_filename):

            # Figure out linker args based on type of target.
            if target_desc == CCompiler.EXECUTABLE:
                startup_obj = 'c0w32'
                if debug:
                    ld_args = self.ldflags_exe_debug[:]
                else:
                    ld_args = self.ldflags_exe[:]
            else:
                startup_obj = 'c0d32'
                if debug:
                    ld_args = self.ldflags_shared_debug[:]
                else:
                    ld_args = self.ldflags_shared[:]


            # Create a temporary exports file for use by the linker
            if export_symbols is None:
                def_file = ''
            else:
                head, tail = os.path.split (output_filename)
                modname, ext = os.path.splitext (tail)
                temp_dir = os.path.dirname(objects[0]) # preserve tree structure
                def_file = os.path.join (temp_dir, '%s.def' % modname)
                contents = ['EXPORTS']
                for sym in (export_symbols or []):
                    contents.append('  %s=_%s' % (sym, sym))
                self.execute(write_file, (def_file, contents),
                             "writing %s" % def_file)

            # Borland C++ has problems with '/' in paths
            objects2 = map(os.path.normpath, objects)
            # split objects in .obj and .res files
            # Borland C++ needs them at different positions in the command line
            objects = [startup_obj]
            resources = []
            for file in objects2:
                (base, ext) = os.path.splitext(os.path.normcase(file))
                if ext == '.res':
                    resources.append(file)
                else:
                    objects.append(file)


            for l in library_dirs:
                ld_args.append("/L%s" % os.path.normpath(l))
            ld_args.append("/L.") # we sometimes use relative paths

            # list of object files
            ld_args.extend(objects)

            # XXX the command-line syntax for Borland C++ is a bit wonky;
            # certain filenames are jammed together in one big string, but
            # comma-delimited.  This doesn't mesh too well with the
            # Unix-centric attitude (with a DOS/Windows quoting hack) of
            # 'spawn()', so constructing the argument list is a bit
            # awkward.  Note that doing the obvious thing and jamming all
            # the filenames and commas into one argument would be wrong,
            # because 'spawn()' would quote any filenames with spaces in
            # them.  Arghghh!.  Apparently it works fine as coded...

            # name of dll/exe file
            ld_args.extend([',',output_filename])
            # no map file and start libraries
            ld_args.append(',,')

            for lib in libraries:
                # see if we find it and if there is a bcpp specific lib
                # (xxx_bcpp.lib)
                libfile = self.find_library_file(library_dirs, lib, debug)
                if libfile is None:
                    ld_args.append(lib)
                    # probably a BCPP internal library -- don't warn
                else:
                    # full name which prefers bcpp_xxx.lib over xxx.lib
                    ld_args.append(libfile)

            # some default libraries
            ld_args.append ('import32')
            ld_args.append ('cw32mt')

            # def file for export symbols
            ld_args.extend([',',def_file])
            # add resource files
            ld_args.append(',')
            ld_args.extend(resources)


            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            self.mkpath (os.path.dirname (output_filename))
            try:
                self.spawn ([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)

        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    # link ()

    # -- Miscellaneous methods -----------------------------------------


    def find_library_file (self, dirs, lib, debug=0):
        # List of effective library names to try, in order of preference:
        # xxx_bcpp.lib is better than xxx.lib
        # and xxx_d.lib is better than xxx.lib if debug is set
        #
        # The "_bcpp" suffix is to handle a Python installation for people
        # with multiple compilers (primarily Distutils hackers, I suspect
        # ;-).  The idea is they'd have one static library for each
        # compiler they care about, since (almost?) every Windows compiler
        # seems to have a different format for static libraries.
        if debug:
            dlib = (lib + "_d")
            try_names = (dlib + "_bcpp", lib + "_bcpp", dlib, lib)
        else:
            try_names = (lib + "_bcpp", lib)

        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename(name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

    # overwrite the one from CCompiler to support rc and res-files
    def object_filenames (self,
                          source_filenames,
                          strip_dir=0,
                          output_dir=''):
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
            (base, ext) = os.path.splitext (os.path.normcase(src_name))
            if ext not in (self.src_extensions + ['.rc','.res']):
                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
                      (ext, src_name))
            if strip_dir:
                base = os.path.basename (base)
            if ext == '.res':
                # these can go unchanged
                obj_names.append (os.path.join (output_dir, base + ext))
            elif ext == '.rc':
                # these need to be compiled to .res-files
                obj_names.append (os.path.join (output_dir, base + '.res'))
            else:
                obj_names.append (os.path.join (output_dir,
                                            base + self.obj_extension))
        return obj_names

    # object_filenames ()

    def preprocess (self,
                    source,
                    output_file=None,
                    macros=None,
                    include_dirs=None,
                    extra_preargs=None,
                    extra_postargs=None):

        (_, macros, include_dirs) = \
            self._fix_compile_args(None, macros, include_dirs)
        pp_opts = gen_preprocess_options(macros, include_dirs)
        pp_args = ['cpp32.exe'] + pp_opts
        if output_file is not None:
            pp_args.append('-o' + output_file)
        if extra_preargs:
            pp_args[:0] = extra_preargs
        if extra_postargs:
            pp_args.extend(extra_postargs)
        pp_args.append(source)

        # We need to preprocess: either we're being forced to, or the
        # source file is newer than the target (or the target doesn't
        # exist).
        if self.force or output_file is None or newer(source, output_file):
            if output_file:
                self.mkpath(os.path.dirname(output_file))
            try:
                self.spawn(pp_args)
            except DistutilsExecError as msg:
                print(msg)
                raise CompileError(msg)

    # preprocess()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/ccompiler.py0000644000175100001710000013503400000000000022335 0ustar00runnerdocker"""distutils.ccompiler

Contains CCompiler, an abstract base class that defines the interface
for the Distutils compiler abstraction model."""

import sys, os, re
from distutils.errors import *
from distutils.spawn import spawn
from distutils.file_util import move_file
from distutils.dir_util import mkpath
from distutils.dep_util import newer_group
from distutils.util import split_quoted, execute
from distutils import log

class CCompiler:
    """Abstract base class to define the interface that must be implemented
    by real compiler classes.  Also has some utility methods used by
    several compiler classes.

    The basic idea behind a compiler abstraction class is that each
    instance can be used for all the compile/link steps in building a
    single project.  Thus, attributes common to all of those compile and
    link steps -- include directories, macros to define, libraries to link
    against, etc. -- are attributes of the compiler instance.  To allow for
    variability in how individual files are treated, most of those
    attributes may be varied on a per-compilation or per-link basis.
    """

    # 'compiler_type' is a class attribute that identifies this class.  It
    # keeps code that wants to know what kind of compiler it's dealing with
    # from having to import all possible compiler classes just to do an
    # 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'
    # should really, really be one of the keys of the 'compiler_class'
    # dictionary (see below -- used by the 'new_compiler()' factory
    # function) -- authors of new compiler interface classes are
    # responsible for updating 'compiler_class'!
    compiler_type = None

    # XXX things not handled by this compiler abstraction model:
    #   * client can't provide additional options for a compiler,
    #     e.g. warning, optimization, debugging flags.  Perhaps this
    #     should be the domain of concrete compiler abstraction classes
    #     (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base
    #     class should have methods for the common ones.
    #   * can't completely override the include or library searchg
    #     path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".
    #     I'm not sure how widely supported this is even by Unix
    #     compilers, much less on other platforms.  And I'm even less
    #     sure how useful it is; maybe for cross-compiling, but
    #     support for that is a ways off.  (And anyways, cross
    #     compilers probably have a dedicated binary with the
    #     right paths compiled in.  I hope.)
    #   * can't do really freaky things with the library list/library
    #     dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against
    #     different versions of libfoo.a in different locations.  I
    #     think this is useless without the ability to null out the
    #     library search path anyways.


    # Subclasses that rely on the standard filename generation methods
    # implemented below should override these; see the comment near
    # those methods ('object_filenames()' et. al.) for details:
    src_extensions = None               # list of strings
    obj_extension = None                # string
    static_lib_extension = None
    shared_lib_extension = None         # string
    static_lib_format = None            # format string
    shared_lib_format = None            # prob. same as static_lib_format
    exe_extension = None                # string

    # Default language settings. language_map is used to detect a source
    # file or Extension target language, checking source filenames.
    # language_order is used to detect the language precedence, when deciding
    # what language to use when mixing source types. For example, if some
    # extension has two files with ".c" extension, and one with ".cpp", it
    # is still linked as c++.
    language_map = {".c"   : "c",
                    ".cc"  : "c++",
                    ".cpp" : "c++",
                    ".cxx" : "c++",
                    ".m"   : "objc",
                   }
    language_order = ["c++", "objc", "c"]

    def __init__(self, verbose=0, dry_run=0, force=0):
        self.dry_run = dry_run
        self.force = force
        self.verbose = verbose

        # 'output_dir': a common output directory for object, library,
        # shared object, and shared library files
        self.output_dir = None

        # 'macros': a list of macro definitions (or undefinitions).  A
        # macro definition is a 2-tuple (name, value), where the value is
        # either a string or None (no explicit value).  A macro
        # undefinition is a 1-tuple (name,).
        self.macros = []

        # 'include_dirs': a list of directories to search for include files
        self.include_dirs = []

        # 'libraries': a list of libraries to include in any link
        # (library names, not filenames: eg. "foo" not "libfoo.a")
        self.libraries = []

        # 'library_dirs': a list of directories to search for libraries
        self.library_dirs = []

        # 'runtime_library_dirs': a list of directories to search for
        # shared libraries/objects at runtime
        self.runtime_library_dirs = []

        # 'objects': a list of object files (or similar, such as explicitly
        # named library files) to include on any link
        self.objects = []

        for key in self.executables.keys():
            self.set_executable(key, self.executables[key])

    def set_executables(self, **kwargs):
        """Define the executables (and options for them) that will be run
        to perform the various stages of compilation.  The exact set of
        executables that may be specified here depends on the compiler
        class (via the 'executables' class attribute), but most will have:
          compiler      the C/C++ compiler
          linker_so     linker used to create shared objects and libraries
          linker_exe    linker used to create binary executables
          archiver      static library creator

        On platforms with a command-line (Unix, DOS/Windows), each of these
        is a string that will be split into executable name and (optional)
        list of arguments.  (Splitting the string is done similarly to how
        Unix shells operate: words are delimited by spaces, but quotes and
        backslashes can override this.  See
        'distutils.util.split_quoted()'.)
        """

        # Note that some CCompiler implementation classes will define class
        # attributes 'cpp', 'cc', etc. with hard-coded executable names;
        # this is appropriate when a compiler class is for exactly one
        # compiler/OS combination (eg. MSVCCompiler).  Other compiler
        # classes (UnixCCompiler, in particular) are driven by information
        # discovered at run-time, since there are many different ways to do
        # basically the same things with Unix C compilers.

        for key in kwargs:
            if key not in self.executables:
                raise ValueError("unknown executable '%s' for class %s" %
                      (key, self.__class__.__name__))
            self.set_executable(key, kwargs[key])

    def set_executable(self, key, value):
        if isinstance(value, str):
            setattr(self, key, split_quoted(value))
        else:
            setattr(self, key, value)

    def _find_macro(self, name):
        i = 0
        for defn in self.macros:
            if defn[0] == name:
                return i
            i += 1
        return None

    def _check_macro_definitions(self, definitions):
        """Ensures that every element of 'definitions' is a valid macro
        definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do
        nothing if all definitions are OK, raise TypeError otherwise.
        """
        for defn in definitions:
            if not (isinstance(defn, tuple) and
                    (len(defn) in (1, 2) and
                      (isinstance (defn[1], str) or defn[1] is None)) and
                    isinstance (defn[0], str)):
                raise TypeError(("invalid macro definition '%s': " % defn) + \
                      "must be tuple (string,), (string, string), or " + \
                      "(string, None)")


    # -- Bookkeeping methods -------------------------------------------

    def define_macro(self, name, value=None):
        """Define a preprocessor macro for all compilations driven by this
        compiler object.  The optional parameter 'value' should be a
        string; if it is not supplied, then the macro will be defined
        without an explicit value and the exact outcome depends on the
        compiler used (XXX true? does ANSI say anything about this?)
        """
        # Delete from the list of macro definitions/undefinitions if
        # already there (so that this one will take precedence).
        i = self._find_macro (name)
        if i is not None:
            del self.macros[i]

        self.macros.append((name, value))

    def undefine_macro(self, name):
        """Undefine a preprocessor macro for all compilations driven by
        this compiler object.  If the same macro is defined by
        'define_macro()' and undefined by 'undefine_macro()' the last call
        takes precedence (including multiple redefinitions or
        undefinitions).  If the macro is redefined/undefined on a
        per-compilation basis (ie. in the call to 'compile()'), then that
        takes precedence.
        """
        # Delete from the list of macro definitions/undefinitions if
        # already there (so that this one will take precedence).
        i = self._find_macro (name)
        if i is not None:
            del self.macros[i]

        undefn = (name,)
        self.macros.append(undefn)

    def add_include_dir(self, dir):
        """Add 'dir' to the list of directories that will be searched for
        header files.  The compiler is instructed to search directories in
        the order in which they are supplied by successive calls to
        'add_include_dir()'.
        """
        self.include_dirs.append(dir)

    def set_include_dirs(self, dirs):
        """Set the list of directories that will be searched to 'dirs' (a
        list of strings).  Overrides any preceding calls to
        'add_include_dir()'; subsequence calls to 'add_include_dir()' add
        to the list passed to 'set_include_dirs()'.  This does not affect
        any list of standard include directories that the compiler may
        search by default.
        """
        self.include_dirs = dirs[:]

    def add_library(self, libname):
        """Add 'libname' to the list of libraries that will be included in
        all links driven by this compiler object.  Note that 'libname'
        should *not* be the name of a file containing a library, but the
        name of the library itself: the actual filename will be inferred by
        the linker, the compiler, or the compiler class (depending on the
        platform).

        The linker will be instructed to link against libraries in the
        order they were supplied to 'add_library()' and/or
        'set_libraries()'.  It is perfectly valid to duplicate library
        names; the linker will be instructed to link against libraries as
        many times as they are mentioned.
        """
        self.libraries.append(libname)

    def set_libraries(self, libnames):
        """Set the list of libraries to be included in all links driven by
        this compiler object to 'libnames' (a list of strings).  This does
        not affect any standard system libraries that the linker may
        include by default.
        """
        self.libraries = libnames[:]

    def add_library_dir(self, dir):
        """Add 'dir' to the list of directories that will be searched for
        libraries specified to 'add_library()' and 'set_libraries()'.  The
        linker will be instructed to search for libraries in the order they
        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
        """
        self.library_dirs.append(dir)

    def set_library_dirs(self, dirs):
        """Set the list of library search directories to 'dirs' (a list of
        strings).  This does not affect any standard library search path
        that the linker may search by default.
        """
        self.library_dirs = dirs[:]

    def add_runtime_library_dir(self, dir):
        """Add 'dir' to the list of directories that will be searched for
        shared libraries at runtime.
        """
        self.runtime_library_dirs.append(dir)

    def set_runtime_library_dirs(self, dirs):
        """Set the list of directories to search for shared libraries at
        runtime to 'dirs' (a list of strings).  This does not affect any
        standard search path that the runtime linker may search by
        default.
        """
        self.runtime_library_dirs = dirs[:]

    def add_link_object(self, object):
        """Add 'object' to the list of object files (or analogues, such as
        explicitly named library files or the output of "resource
        compilers") to be included in every link driven by this compiler
        object.
        """
        self.objects.append(object)

    def set_link_objects(self, objects):
        """Set the list of object files (or analogues) to be included in
        every link to 'objects'.  This does not affect any standard object
        files that the linker may include by default (such as system
        libraries).
        """
        self.objects = objects[:]


    # -- Private utility methods --------------------------------------
    # (here for the convenience of subclasses)

    # Helper method to prep compiler in subclass compile() methods

    def _setup_compile(self, outdir, macros, incdirs, sources, depends,
                       extra):
        """Process arguments and decide which source files to compile."""
        if outdir is None:
            outdir = self.output_dir
        elif not isinstance(outdir, str):
            raise TypeError("'output_dir' must be a string or None")

        if macros is None:
            macros = self.macros
        elif isinstance(macros, list):
            macros = macros + (self.macros or [])
        else:
            raise TypeError("'macros' (if supplied) must be a list of tuples")

        if incdirs is None:
            incdirs = self.include_dirs
        elif isinstance(incdirs, (list, tuple)):
            incdirs = list(incdirs) + (self.include_dirs or [])
        else:
            raise TypeError(
                  "'include_dirs' (if supplied) must be a list of strings")

        if extra is None:
            extra = []

        # Get the list of expected output (object) files
        objects = self.object_filenames(sources, strip_dir=0,
                                        output_dir=outdir)
        assert len(objects) == len(sources)

        pp_opts = gen_preprocess_options(macros, incdirs)

        build = {}
        for i in range(len(sources)):
            src = sources[i]
            obj = objects[i]
            ext = os.path.splitext(src)[1]
            self.mkpath(os.path.dirname(obj))
            build[obj] = (src, ext)

        return macros, objects, extra, pp_opts, build

    def _get_cc_args(self, pp_opts, debug, before):
        # works for unixccompiler, cygwinccompiler
        cc_args = pp_opts + ['-c']
        if debug:
            cc_args[:0] = ['-g']
        if before:
            cc_args[:0] = before
        return cc_args

    def _fix_compile_args(self, output_dir, macros, include_dirs):
        """Typecheck and fix-up some of the arguments to the 'compile()'
        method, and return fixed-up values.  Specifically: if 'output_dir'
        is None, replaces it with 'self.output_dir'; ensures that 'macros'
        is a list, and augments it with 'self.macros'; ensures that
        'include_dirs' is a list, and augments it with 'self.include_dirs'.
        Guarantees that the returned values are of the correct type,
        i.e. for 'output_dir' either string or None, and for 'macros' and
        'include_dirs' either list or None.
        """
        if output_dir is None:
            output_dir = self.output_dir
        elif not isinstance(output_dir, str):
            raise TypeError("'output_dir' must be a string or None")

        if macros is None:
            macros = self.macros
        elif isinstance(macros, list):
            macros = macros + (self.macros or [])
        else:
            raise TypeError("'macros' (if supplied) must be a list of tuples")

        if include_dirs is None:
            include_dirs = self.include_dirs
        elif isinstance(include_dirs, (list, tuple)):
            include_dirs = list(include_dirs) + (self.include_dirs or [])
        else:
            raise TypeError(
                  "'include_dirs' (if supplied) must be a list of strings")

        return output_dir, macros, include_dirs

    def _prep_compile(self, sources, output_dir, depends=None):
        """Decide which source files must be recompiled.

        Determine the list of object files corresponding to 'sources',
        and figure out which ones really need to be recompiled.
        Return a list of all object files and a dictionary telling
        which source files can be skipped.
        """
        # Get the list of expected output (object) files
        objects = self.object_filenames(sources, output_dir=output_dir)
        assert len(objects) == len(sources)

        # Return an empty dict for the "which source files can be skipped"
        # return value to preserve API compatibility.
        return objects, {}

    def _fix_object_args(self, objects, output_dir):
        """Typecheck and fix up some arguments supplied to various methods.
        Specifically: ensure that 'objects' is a list; if output_dir is
        None, replace with self.output_dir.  Return fixed versions of
        'objects' and 'output_dir'.
        """
        if not isinstance(objects, (list, tuple)):
            raise TypeError("'objects' must be a list or tuple of strings")
        objects = list(objects)

        if output_dir is None:
            output_dir = self.output_dir
        elif not isinstance(output_dir, str):
            raise TypeError("'output_dir' must be a string or None")

        return (objects, output_dir)

    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
        """Typecheck and fix up some of the arguments supplied to the
        'link_*' methods.  Specifically: ensure that all arguments are
        lists, and augment them with their permanent versions
        (eg. 'self.libraries' augments 'libraries').  Return a tuple with
        fixed versions of all arguments.
        """
        if libraries is None:
            libraries = self.libraries
        elif isinstance(libraries, (list, tuple)):
            libraries = list (libraries) + (self.libraries or [])
        else:
            raise TypeError(
                  "'libraries' (if supplied) must be a list of strings")

        if library_dirs is None:
            library_dirs = self.library_dirs
        elif isinstance(library_dirs, (list, tuple)):
            library_dirs = list (library_dirs) + (self.library_dirs or [])
        else:
            raise TypeError(
                  "'library_dirs' (if supplied) must be a list of strings")

        if runtime_library_dirs is None:
            runtime_library_dirs = self.runtime_library_dirs
        elif isinstance(runtime_library_dirs, (list, tuple)):
            runtime_library_dirs = (list(runtime_library_dirs) +
                                    (self.runtime_library_dirs or []))
        else:
            raise TypeError("'runtime_library_dirs' (if supplied) "
                            "must be a list of strings")

        return (libraries, library_dirs, runtime_library_dirs)

    def _need_link(self, objects, output_file):
        """Return true if we need to relink the files listed in 'objects'
        to recreate 'output_file'.
        """
        if self.force:
            return True
        else:
            if self.dry_run:
                newer = newer_group (objects, output_file, missing='newer')
            else:
                newer = newer_group (objects, output_file)
            return newer

    def detect_language(self, sources):
        """Detect the language of a given file, or list of files. Uses
        language_map, and language_order to do the job.
        """
        if not isinstance(sources, list):
            sources = [sources]
        lang = None
        index = len(self.language_order)
        for source in sources:
            base, ext = os.path.splitext(source)
            extlang = self.language_map.get(ext)
            try:
                extindex = self.language_order.index(extlang)
                if extindex < index:
                    lang = extlang
                    index = extindex
            except ValueError:
                pass
        return lang


    # -- Worker methods ------------------------------------------------
    # (must be implemented by subclasses)

    def preprocess(self, source, output_file=None, macros=None,
                   include_dirs=None, extra_preargs=None, extra_postargs=None):
        """Preprocess a single C/C++ source file, named in 'source'.
        Output will be written to file named 'output_file', or stdout if
        'output_file' not supplied.  'macros' is a list of macro
        definitions as for 'compile()', which will augment the macros set
        with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
        list of directory names that will be added to the default list.

        Raises PreprocessError on failure.
        """
        pass

    def compile(self, sources, output_dir=None, macros=None,
                include_dirs=None, debug=0, extra_preargs=None,
                extra_postargs=None, depends=None):
        """Compile one or more source files.

        'sources' must be a list of filenames, most likely C/C++
        files, but in reality anything that can be handled by a
        particular compiler and compiler class (eg. MSVCCompiler can
        handle resource files in 'sources').  Return a list of object
        filenames, one per source filename in 'sources'.  Depending on
        the implementation, not all source files will necessarily be
        compiled, but all corresponding object filenames will be
        returned.

        If 'output_dir' is given, object files will be put under it, while
        retaining their original path component.  That is, "foo/bar.c"
        normally compiles to "foo/bar.o" (for a Unix implementation); if
        'output_dir' is "build", then it would compile to
        "build/foo/bar.o".

        'macros', if given, must be a list of macro definitions.  A macro
        definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
        The former defines a macro; if the value is None, the macro is
        defined without an explicit value.  The 1-tuple case undefines a
        macro.  Later definitions/redefinitions/ undefinitions take
        precedence.

        'include_dirs', if given, must be a list of strings, the
        directories to add to the default include file search path for this
        compilation only.

        'debug' is a boolean; if true, the compiler will be instructed to
        output debug symbols in (or alongside) the object file(s).

        'extra_preargs' and 'extra_postargs' are implementation- dependent.
        On platforms that have the notion of a command-line (e.g. Unix,
        DOS/Windows), they are most likely lists of strings: extra
        command-line arguments to prepend/append to the compiler command
        line.  On other platforms, consult the implementation class
        documentation.  In any event, they are intended as an escape hatch
        for those occasions when the abstract compiler framework doesn't
        cut the mustard.

        'depends', if given, is a list of filenames that all targets
        depend on.  If a source file is older than any file in
        depends, then the source file will be recompiled.  This
        supports dependency tracking, but only at a coarse
        granularity.

        Raises CompileError on failure.
        """
        # A concrete compiler class can either override this method
        # entirely or implement _compile().
        macros, objects, extra_postargs, pp_opts, build = \
                self._setup_compile(output_dir, macros, include_dirs, sources,
                                    depends, extra_postargs)
        cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)

        # Return *all* object filenames, not just the ones we just built.
        return objects

    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        """Compile 'src' to product 'obj'."""
        # A concrete compiler class that does not override compile()
        # should implement _compile().
        pass

    def create_static_lib(self, objects, output_libname, output_dir=None,
                          debug=0, target_lang=None):
        """Link a bunch of stuff together to create a static library file.
        The "bunch of stuff" consists of the list of object files supplied
        as 'objects', the extra object files supplied to
        'add_link_object()' and/or 'set_link_objects()', the libraries
        supplied to 'add_library()' and/or 'set_libraries()', and the
        libraries supplied as 'libraries' (if any).

        'output_libname' should be a library name, not a filename; the
        filename will be inferred from the library name.  'output_dir' is
        the directory where the library file will be put.

        'debug' is a boolean; if true, debugging information will be
        included in the library (note that on most platforms, it is the
        compile step where this matters: the 'debug' flag is included here
        just for consistency).

        'target_lang' is the target language for which the given objects
        are being compiled. This allows specific linkage time treatment of
        certain languages.

        Raises LibError on failure.
        """
        pass


    # values for target_desc parameter in link()
    SHARED_OBJECT = "shared_object"
    SHARED_LIBRARY = "shared_library"
    EXECUTABLE = "executable"

    def link(self,
             target_desc,
             objects,
             output_filename,
             output_dir=None,
             libraries=None,
             library_dirs=None,
             runtime_library_dirs=None,
             export_symbols=None,
             debug=0,
             extra_preargs=None,
             extra_postargs=None,
             build_temp=None,
             target_lang=None):
        """Link a bunch of stuff together to create an executable or
        shared library file.

        The "bunch of stuff" consists of the list of object files supplied
        as 'objects'.  'output_filename' should be a filename.  If
        'output_dir' is supplied, 'output_filename' is relative to it
        (i.e. 'output_filename' can provide directory components if
        needed).

        'libraries' is a list of libraries to link against.  These are
        library names, not filenames, since they're translated into
        filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
        on Unix and "foo.lib" on DOS/Windows).  However, they can include a
        directory component, which means the linker will look in that
        specific directory rather than searching all the normal locations.

        'library_dirs', if supplied, should be a list of directories to
        search for libraries that were specified as bare library names
        (ie. no directory component).  These are on top of the system
        default and those supplied to 'add_library_dir()' and/or
        'set_library_dirs()'.  'runtime_library_dirs' is a list of
        directories that will be embedded into the shared library and used
        to search for other shared libraries that *it* depends on at
        run-time.  (This may only be relevant on Unix.)

        'export_symbols' is a list of symbols that the shared library will
        export.  (This appears to be relevant only on Windows.)

        'debug' is as for 'compile()' and 'create_static_lib()', with the
        slight distinction that it actually matters on most platforms (as
        opposed to 'create_static_lib()', which includes a 'debug' flag
        mostly for form's sake).

        'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
        of course that they supply command-line arguments for the
        particular linker being used).

        'target_lang' is the target language for which the given objects
        are being compiled. This allows specific linkage time treatment of
        certain languages.

        Raises LinkError on failure.
        """
        raise NotImplementedError


    # Old 'link_*()' methods, rewritten to use the new 'link()' method.

    def link_shared_lib(self,
                        objects,
                        output_libname,
                        output_dir=None,
                        libraries=None,
                        library_dirs=None,
                        runtime_library_dirs=None,
                        export_symbols=None,
                        debug=0,
                        extra_preargs=None,
                        extra_postargs=None,
                        build_temp=None,
                        target_lang=None):
        self.link(CCompiler.SHARED_LIBRARY, objects,
                  self.library_filename(output_libname, lib_type='shared'),
                  output_dir,
                  libraries, library_dirs, runtime_library_dirs,
                  export_symbols, debug,
                  extra_preargs, extra_postargs, build_temp, target_lang)


    def link_shared_object(self,
                           objects,
                           output_filename,
                           output_dir=None,
                           libraries=None,
                           library_dirs=None,
                           runtime_library_dirs=None,
                           export_symbols=None,
                           debug=0,
                           extra_preargs=None,
                           extra_postargs=None,
                           build_temp=None,
                           target_lang=None):
        self.link(CCompiler.SHARED_OBJECT, objects,
                  output_filename, output_dir,
                  libraries, library_dirs, runtime_library_dirs,
                  export_symbols, debug,
                  extra_preargs, extra_postargs, build_temp, target_lang)


    def link_executable(self,
                        objects,
                        output_progname,
                        output_dir=None,
                        libraries=None,
                        library_dirs=None,
                        runtime_library_dirs=None,
                        debug=0,
                        extra_preargs=None,
                        extra_postargs=None,
                        target_lang=None):
        self.link(CCompiler.EXECUTABLE, objects,
                  self.executable_filename(output_progname), output_dir,
                  libraries, library_dirs, runtime_library_dirs, None,
                  debug, extra_preargs, extra_postargs, None, target_lang)


    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function; there is
    # no appropriate default implementation so subclasses should
    # implement all of these.

    def library_dir_option(self, dir):
        """Return the compiler option to add 'dir' to the list of
        directories searched for libraries.
        """
        raise NotImplementedError

    def runtime_library_dir_option(self, dir):
        """Return the compiler option to add 'dir' to the list of
        directories searched for runtime libraries.
        """
        raise NotImplementedError

    def library_option(self, lib):
        """Return the compiler option to add 'lib' to the list of libraries
        linked into the shared library or executable.
        """
        raise NotImplementedError

    def has_function(self, funcname, includes=None, include_dirs=None,
                     libraries=None, library_dirs=None):
        """Return a boolean indicating whether funcname is supported on
        the current platform.  The optional arguments can be used to
        augment the compilation environment.
        """
        # this can't be included at module scope because it tries to
        # import math which might not be available at that point - maybe
        # the necessary logic should just be inlined?
        import tempfile
        if includes is None:
            includes = []
        if include_dirs is None:
            include_dirs = []
        if libraries is None:
            libraries = []
        if library_dirs is None:
            library_dirs = []
        fd, fname = tempfile.mkstemp(".c", funcname, text=True)
        f = os.fdopen(fd, "w")
        try:
            for incl in includes:
                f.write("""#include "%s"\n""" % incl)
            f.write("""\
int main (int argc, char **argv) {
    %s();
    return 0;
}
""" % funcname)
        finally:
            f.close()
        try:
            objects = self.compile([fname], include_dirs=include_dirs)
        except CompileError:
            return False
        finally:
            os.remove(fname)

        try:
            self.link_executable(objects, "a.out",
                                 libraries=libraries,
                                 library_dirs=library_dirs)
        except (LinkError, TypeError):
            return False
        else:
            os.remove(os.path.join(self.output_dir or '', "a.out"))
        finally:
            for fn in objects:
                os.remove(fn)
        return True

    def find_library_file (self, dirs, lib, debug=0):
        """Search the specified list of directories for a static or shared
        library file 'lib' and return the full path to that file.  If
        'debug' true, look for a debugging version (if that makes sense on
        the current platform).  Return None if 'lib' wasn't found in any of
        the specified directories.
        """
        raise NotImplementedError

    # -- Filename generation methods -----------------------------------

    # The default implementation of the filename generating methods are
    # prejudiced towards the Unix/DOS/Windows view of the world:
    #   * object files are named by replacing the source file extension
    #     (eg. .c/.cpp -> .o/.obj)
    #   * library files (shared or static) are named by plugging the
    #     library name and extension into a format string, eg.
    #     "lib%s.%s" % (lib_name, ".a") for Unix static libraries
    #   * executables are named by appending an extension (possibly
    #     empty) to the program name: eg. progname + ".exe" for
    #     Windows
    #
    # To reduce redundant code, these methods expect to find
    # several attributes in the current object (presumably defined
    # as class attributes):
    #   * src_extensions -
    #     list of C/C++ source file extensions, eg. ['.c', '.cpp']
    #   * obj_extension -
    #     object file extension, eg. '.o' or '.obj'
    #   * static_lib_extension -
    #     extension for static library files, eg. '.a' or '.lib'
    #   * shared_lib_extension -
    #     extension for shared library/object files, eg. '.so', '.dll'
    #   * static_lib_format -
    #     format string for generating static library filenames,
    #     eg. 'lib%s.%s' or '%s.%s'
    #   * shared_lib_format
    #     format string for generating shared library filenames
    #     (probably same as static_lib_format, since the extension
    #     is one of the intended parameters to the format string)
    #   * exe_extension -
    #     extension for executable files, eg. '' or '.exe'

    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
        if output_dir is None:
            output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            base, ext = os.path.splitext(src_name)
            base = os.path.splitdrive(base)[1] # Chop off the drive
            base = base[os.path.isabs(base):]  # If abs, chop off leading /
            if ext not in self.src_extensions:
                raise UnknownFileError(
                      "unknown file type '%s' (from '%s')" % (ext, src_name))
            if strip_dir:
                base = os.path.basename(base)
            obj_names.append(os.path.join(output_dir,
                                          base + self.obj_extension))
        return obj_names

    def shared_object_filename(self, basename, strip_dir=0, output_dir=''):
        assert output_dir is not None
        if strip_dir:
            basename = os.path.basename(basename)
        return os.path.join(output_dir, basename + self.shared_lib_extension)

    def executable_filename(self, basename, strip_dir=0, output_dir=''):
        assert output_dir is not None
        if strip_dir:
            basename = os.path.basename(basename)
        return os.path.join(output_dir, basename + (self.exe_extension or ''))

    def library_filename(self, libname, lib_type='static',     # or 'shared'
                         strip_dir=0, output_dir=''):
        assert output_dir is not None
        if lib_type not in ("static", "shared", "dylib", "xcode_stub"):
            raise ValueError(
                  "'lib_type' must be \"static\", \"shared\", \"dylib\", or \"xcode_stub\"")
        fmt = getattr(self, lib_type + "_lib_format")
        ext = getattr(self, lib_type + "_lib_extension")

        dir, base = os.path.split(libname)
        filename = fmt % (base, ext)
        if strip_dir:
            dir = ''

        return os.path.join(output_dir, dir, filename)


    # -- Utility methods -----------------------------------------------

    def announce(self, msg, level=1):
        log.debug(msg)

    def debug_print(self, msg):
        from distutils.debug import DEBUG
        if DEBUG:
            print(msg)

    def warn(self, msg):
        sys.stderr.write("warning: %s\n" % msg)

    def execute(self, func, args, msg=None, level=1):
        execute(func, args, msg, self.dry_run)

    def spawn(self, cmd, **kwargs):
        spawn(cmd, dry_run=self.dry_run, **kwargs)

    def move_file(self, src, dst):
        return move_file(src, dst, dry_run=self.dry_run)

    def mkpath (self, name, mode=0o777):
        mkpath(name, mode, dry_run=self.dry_run)


# Map a sys.platform/os.name ('posix', 'nt') to the default compiler
# type for that platform. Keys are interpreted as re match
# patterns. Order is important; platform mappings are preferred over
# OS names.
_default_compilers = (

    # Platform string mappings

    # on a cygwin built python we can use gcc like an ordinary UNIXish
    # compiler
    ('cygwin.*', 'unix'),

    # OS name mappings
    ('posix', 'unix'),
    ('nt', 'msvc'),

    )

def get_default_compiler(osname=None, platform=None):
    """Determine the default compiler to use for the given platform.

       osname should be one of the standard Python OS names (i.e. the
       ones returned by os.name) and platform the common value
       returned by sys.platform for the platform in question.

       The default values are os.name and sys.platform in case the
       parameters are not given.
    """
    if osname is None:
        osname = os.name
    if platform is None:
        platform = sys.platform
    for pattern, compiler in _default_compilers:
        if re.match(pattern, platform) is not None or \
           re.match(pattern, osname) is not None:
            return compiler
    # Default to Unix compiler
    return 'unix'

# Map compiler types to (module_name, class_name) pairs -- ie. where to
# find the code that implements an interface to this compiler.  (The module
# is assumed to be in the 'distutils' package.)
compiler_class = { 'unix':    ('unixccompiler', 'UnixCCompiler',
                               "standard UNIX-style compiler"),
                   'msvc':    ('_msvccompiler', 'MSVCCompiler',
                               "Microsoft Visual C++"),
                   'cygwin':  ('cygwinccompiler', 'CygwinCCompiler',
                               "Cygwin port of GNU C Compiler for Win32"),
                   'mingw32': ('cygwinccompiler', 'Mingw32CCompiler',
                               "Mingw32 port of GNU C Compiler for Win32"),
                   'bcpp':    ('bcppcompiler', 'BCPPCompiler',
                               "Borland C++ Compiler"),
                 }

def show_compilers():
    """Print list of available compilers (used by the "--help-compiler"
    options to "build", "build_ext", "build_clib").
    """
    # XXX this "knows" that the compiler option it's describing is
    # "--compiler", which just happens to be the case for the three
    # commands that use it.
    from distutils.fancy_getopt import FancyGetopt
    compilers = []
    for compiler in compiler_class.keys():
        compilers.append(("compiler="+compiler, None,
                          compiler_class[compiler][2]))
    compilers.sort()
    pretty_printer = FancyGetopt(compilers)
    pretty_printer.print_help("List of available compilers:")


def new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0):
    """Generate an instance of some CCompiler subclass for the supplied
    platform/compiler combination.  'plat' defaults to 'os.name'
    (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
    for that platform.  Currently only 'posix' and 'nt' are supported, and
    the default compilers are "traditional Unix interface" (UnixCCompiler
    class) and Visual C++ (MSVCCompiler class).  Note that it's perfectly
    possible to ask for a Unix compiler object under Windows, and a
    Microsoft compiler object under Unix -- if you supply a value for
    'compiler', 'plat' is ignored.
    """
    if plat is None:
        plat = os.name

    try:
        if compiler is None:
            compiler = get_default_compiler(plat)

        (module_name, class_name, long_description) = compiler_class[compiler]
    except KeyError:
        msg = "don't know how to compile C/C++ code on platform '%s'" % plat
        if compiler is not None:
            msg = msg + " with '%s' compiler" % compiler
        raise DistutilsPlatformError(msg)

    try:
        module_name = "distutils." + module_name
        __import__ (module_name)
        module = sys.modules[module_name]
        klass = vars(module)[class_name]
    except ImportError:
        raise DistutilsModuleError(
              "can't compile C/C++ code: unable to load module '%s'" % \
              module_name)
    except KeyError:
        raise DistutilsModuleError(
               "can't compile C/C++ code: unable to find class '%s' "
               "in module '%s'" % (class_name, module_name))

    # XXX The None is necessary to preserve backwards compatibility
    # with classes that expect verbose to be the first positional
    # argument.
    return klass(None, dry_run, force)


def gen_preprocess_options(macros, include_dirs):
    """Generate C pre-processor options (-D, -U, -I) as used by at least
    two types of compilers: the typical Unix compiler and Visual C++.
    'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
    means undefine (-U) macro 'name', and (name,value) means define (-D)
    macro 'name' to 'value'.  'include_dirs' is just a list of directory
    names to be added to the header file search path (-I).  Returns a list
    of command-line options suitable for either Unix compilers or Visual
    C++.
    """
    # XXX it would be nice (mainly aesthetic, and so we don't generate
    # stupid-looking command lines) to go over 'macros' and eliminate
    # redundant definitions/undefinitions (ie. ensure that only the
    # latest mention of a particular macro winds up on the command
    # line).  I don't think it's essential, though, since most (all?)
    # Unix C compilers only pay attention to the latest -D or -U
    # mention of a macro on their command line.  Similar situation for
    # 'include_dirs'.  I'm punting on both for now.  Anyways, weeding out
    # redundancies like this should probably be the province of
    # CCompiler, since the data structures used are inherited from it
    # and therefore common to all CCompiler classes.
    pp_opts = []
    for macro in macros:
        if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2):
            raise TypeError(
                  "bad macro definition '%s': "
                  "each element of 'macros' list must be a 1- or 2-tuple"
                  % macro)

        if len(macro) == 1:        # undefine this macro
            pp_opts.append("-U%s" % macro[0])
        elif len(macro) == 2:
            if macro[1] is None:    # define with no explicit value
                pp_opts.append("-D%s" % macro[0])
            else:
                # XXX *don't* need to be clever about quoting the
                # macro value here, because we're going to avoid the
                # shell at all costs when we spawn the command!
                pp_opts.append("-D%s=%s" % macro)

    for dir in include_dirs:
        pp_opts.append("-I%s" % dir)
    return pp_opts


def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
    """Generate linker options for searching library directories and
    linking with specific libraries.  'libraries' and 'library_dirs' are,
    respectively, lists of library names (not filenames!) and search
    directories.  Returns a list of command-line options suitable for use
    with some compiler (depending on the two format strings passed in).
    """
    lib_opts = []

    for dir in library_dirs:
        lib_opts.append(compiler.library_dir_option(dir))

    for dir in runtime_library_dirs:
        opt = compiler.runtime_library_dir_option(dir)
        if isinstance(opt, list):
            lib_opts = lib_opts + opt
        else:
            lib_opts.append(opt)

    # XXX it's important that we *not* remove redundant library mentions!
    # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
    # resolve all symbols.  I just hope we never have to say "-lfoo obj.o
    # -lbar" to get things to work -- that's certainly a possibility, but a
    # pretty nasty way to arrange your C code.

    for lib in libraries:
        (lib_dir, lib_name) = os.path.split(lib)
        if lib_dir:
            lib_file = compiler.find_library_file([lib_dir], lib_name)
            if lib_file:
                lib_opts.append(lib_file)
            else:
                compiler.warn("no library file corresponding to "
                              "'%s' found (skipping)" % lib)
        else:
            lib_opts.append(compiler.library_option (lib))
    return lib_opts
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/cmd.py0000644000175100001710000004323700000000000021126 0ustar00runnerdocker"""distutils.cmd

Provides the Command class, the base class for the command classes
in the distutils.command package.
"""

import sys, os, re
from distutils.errors import DistutilsOptionError
from distutils import util, dir_util, file_util, archive_util, dep_util
from distutils import log

class Command:
    """Abstract base class for defining command classes, the "worker bees"
    of the Distutils.  A useful analogy for command classes is to think of
    them as subroutines with local variables called "options".  The options
    are "declared" in 'initialize_options()' and "defined" (given their
    final values, aka "finalized") in 'finalize_options()', both of which
    must be defined by every command class.  The distinction between the
    two is necessary because option values might come from the outside
    world (command line, config file, ...), and any options dependent on
    other options must be computed *after* these outside influences have
    been processed -- hence 'finalize_options()'.  The "body" of the
    subroutine, where it does all its work based on the values of its
    options, is the 'run()' method, which must also be implemented by every
    command class.
    """

    # 'sub_commands' formalizes the notion of a "family" of commands,
    # eg. "install" as the parent with sub-commands "install_lib",
    # "install_headers", etc.  The parent of a family of commands
    # defines 'sub_commands' as a class attribute; it's a list of
    #    (command_name : string, predicate : unbound_method | string | None)
    # tuples, where 'predicate' is a method of the parent command that
    # determines whether the corresponding command is applicable in the
    # current situation.  (Eg. we "install_headers" is only applicable if
    # we have any C header files to install.)  If 'predicate' is None,
    # that command is always applicable.
    #
    # 'sub_commands' is usually defined at the *end* of a class, because
    # predicates can be unbound methods, so they must already have been
    # defined.  The canonical example is the "install" command.
    sub_commands = []


    # -- Creation/initialization methods -------------------------------

    def __init__(self, dist):
        """Create and initialize a new Command object.  Most importantly,
        invokes the 'initialize_options()' method, which is the real
        initializer and depends on the actual command being
        instantiated.
        """
        # late import because of mutual dependence between these classes
        from distutils.dist import Distribution

        if not isinstance(dist, Distribution):
            raise TypeError("dist must be a Distribution instance")
        if self.__class__ is Command:
            raise RuntimeError("Command is an abstract class")

        self.distribution = dist
        self.initialize_options()

        # Per-command versions of the global flags, so that the user can
        # customize Distutils' behaviour command-by-command and let some
        # commands fall back on the Distribution's behaviour.  None means
        # "not defined, check self.distribution's copy", while 0 or 1 mean
        # false and true (duh).  Note that this means figuring out the real
        # value of each flag is a touch complicated -- hence "self._dry_run"
        # will be handled by __getattr__, below.
        # XXX This needs to be fixed.
        self._dry_run = None

        # verbose is largely ignored, but needs to be set for
        # backwards compatibility (I think)?
        self.verbose = dist.verbose

        # Some commands define a 'self.force' option to ignore file
        # timestamps, but methods defined *here* assume that
        # 'self.force' exists for all commands.  So define it here
        # just to be safe.
        self.force = None

        # The 'help' flag is just used for command-line parsing, so
        # none of that complicated bureaucracy is needed.
        self.help = 0

        # 'finalized' records whether or not 'finalize_options()' has been
        # called.  'finalize_options()' itself should not pay attention to
        # this flag: it is the business of 'ensure_finalized()', which
        # always calls 'finalize_options()', to respect/update it.
        self.finalized = 0

    # XXX A more explicit way to customize dry_run would be better.
    def __getattr__(self, attr):
        if attr == 'dry_run':
            myval = getattr(self, "_" + attr)
            if myval is None:
                return getattr(self.distribution, attr)
            else:
                return myval
        else:
            raise AttributeError(attr)

    def ensure_finalized(self):
        if not self.finalized:
            self.finalize_options()
        self.finalized = 1

    # Subclasses must define:
    #   initialize_options()
    #     provide default values for all options; may be customized by
    #     setup script, by options from config file(s), or by command-line
    #     options
    #   finalize_options()
    #     decide on the final values for all options; this is called
    #     after all possible intervention from the outside world
    #     (command-line, option file, etc.) has been processed
    #   run()
    #     run the command: do whatever it is we're here to do,
    #     controlled by the command's various option values

    def initialize_options(self):
        """Set default values for all the options that this command
        supports.  Note that these defaults may be overridden by other
        commands, by the setup script, by config files, or by the
        command-line.  Thus, this is not the place to code dependencies
        between options; generally, 'initialize_options()' implementations
        are just a bunch of "self.foo = None" assignments.

        This method must be implemented by all command classes.
        """
        raise RuntimeError("abstract method -- subclass %s must override"
                           % self.__class__)

    def finalize_options(self):
        """Set final values for all the options that this command supports.
        This is always called as late as possible, ie.  after any option
        assignments from the command-line or from other commands have been
        done.  Thus, this is the place to code option dependencies: if
        'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
        long as 'foo' still has the same value it was assigned in
        'initialize_options()'.

        This method must be implemented by all command classes.
        """
        raise RuntimeError("abstract method -- subclass %s must override"
                           % self.__class__)


    def dump_options(self, header=None, indent=""):
        from distutils.fancy_getopt import longopt_xlate
        if header is None:
            header = "command options for '%s':" % self.get_command_name()
        self.announce(indent + header, level=log.INFO)
        indent = indent + "  "
        for (option, _, _) in self.user_options:
            option = option.translate(longopt_xlate)
            if option[-1] == "=":
                option = option[:-1]
            value = getattr(self, option)
            self.announce(indent + "%s = %s" % (option, value),
                          level=log.INFO)

    def run(self):
        """A command's raison d'etre: carry out the action it exists to
        perform, controlled by the options initialized in
        'initialize_options()', customized by other commands, the setup
        script, the command-line, and config files, and finalized in
        'finalize_options()'.  All terminal output and filesystem
        interaction should be done by 'run()'.

        This method must be implemented by all command classes.
        """
        raise RuntimeError("abstract method -- subclass %s must override"
                           % self.__class__)

    def announce(self, msg, level=1):
        """If the current verbosity level is of greater than or equal to
        'level' print 'msg' to stdout.
        """
        log.log(level, msg)

    def debug_print(self, msg):
        """Print 'msg' to stdout if the global DEBUG (taken from the
        DISTUTILS_DEBUG environment variable) flag is true.
        """
        from distutils.debug import DEBUG
        if DEBUG:
            print(msg)
            sys.stdout.flush()


    # -- Option validation methods -------------------------------------
    # (these are very handy in writing the 'finalize_options()' method)
    #
    # NB. the general philosophy here is to ensure that a particular option
    # value meets certain type and value constraints.  If not, we try to
    # force it into conformance (eg. if we expect a list but have a string,
    # split the string on comma and/or whitespace).  If we can't force the
    # option into conformance, raise DistutilsOptionError.  Thus, command
    # classes need do nothing more than (eg.)
    #   self.ensure_string_list('foo')
    # and they can be guaranteed that thereafter, self.foo will be
    # a list of strings.

    def _ensure_stringlike(self, option, what, default=None):
        val = getattr(self, option)
        if val is None:
            setattr(self, option, default)
            return default
        elif not isinstance(val, str):
            raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
                                       % (option, what, val))
        return val

    def ensure_string(self, option, default=None):
        """Ensure that 'option' is a string; if not defined, set it to
        'default'.
        """
        self._ensure_stringlike(option, "string", default)

    def ensure_string_list(self, option):
        r"""Ensure that 'option' is a list of strings.  If 'option' is
        currently a string, we split it either on /,\s*/ or /\s+/, so
        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
        ["foo", "bar", "baz"].
        """
        val = getattr(self, option)
        if val is None:
            return
        elif isinstance(val, str):
            setattr(self, option, re.split(r',\s*|\s+', val))
        else:
            if isinstance(val, list):
                ok = all(isinstance(v, str) for v in val)
            else:
                ok = False
            if not ok:
                raise DistutilsOptionError(
                      "'%s' must be a list of strings (got %r)"
                      % (option, val))

    def _ensure_tested_string(self, option, tester, what, error_fmt,
                              default=None):
        val = self._ensure_stringlike(option, what, default)
        if val is not None and not tester(val):
            raise DistutilsOptionError(("error in '%s' option: " + error_fmt)
                                       % (option, val))

    def ensure_filename(self, option):
        """Ensure that 'option' is the name of an existing file."""
        self._ensure_tested_string(option, os.path.isfile,
                                   "filename",
                                   "'%s' does not exist or is not a file")

    def ensure_dirname(self, option):
        self._ensure_tested_string(option, os.path.isdir,
                                   "directory name",
                                   "'%s' does not exist or is not a directory")


    # -- Convenience methods for commands ------------------------------

    def get_command_name(self):
        if hasattr(self, 'command_name'):
            return self.command_name
        else:
            return self.__class__.__name__

    def set_undefined_options(self, src_cmd, *option_pairs):
        """Set the values of any "undefined" options from corresponding
        option values in some other command object.  "Undefined" here means
        "is None", which is the convention used to indicate that an option
        has not been changed between 'initialize_options()' and
        'finalize_options()'.  Usually called from 'finalize_options()' for
        options that depend on some other command rather than another
        option of the same command.  'src_cmd' is the other command from
        which option values will be taken (a command object will be created
        for it if necessary); the remaining arguments are
        '(src_option,dst_option)' tuples which mean "take the value of
        'src_option' in the 'src_cmd' command object, and copy it to
        'dst_option' in the current command object".
        """
        # Option_pairs: list of (src_option, dst_option) tuples
        src_cmd_obj = self.distribution.get_command_obj(src_cmd)
        src_cmd_obj.ensure_finalized()
        for (src_option, dst_option) in option_pairs:
            if getattr(self, dst_option) is None:
                setattr(self, dst_option, getattr(src_cmd_obj, src_option))

    def get_finalized_command(self, command, create=1):
        """Wrapper around Distribution's 'get_command_obj()' method: find
        (create if necessary and 'create' is true) the command object for
        'command', call its 'ensure_finalized()' method, and return the
        finalized command object.
        """
        cmd_obj = self.distribution.get_command_obj(command, create)
        cmd_obj.ensure_finalized()
        return cmd_obj

    # XXX rename to 'get_reinitialized_command()'? (should do the
    # same in dist.py, if so)
    def reinitialize_command(self, command, reinit_subcommands=0):
        return self.distribution.reinitialize_command(command,
                                                      reinit_subcommands)

    def run_command(self, command):
        """Run some other command: uses the 'run_command()' method of
        Distribution, which creates and finalizes the command object if
        necessary and then invokes its 'run()' method.
        """
        self.distribution.run_command(command)

    def get_sub_commands(self):
        """Determine the sub-commands that are relevant in the current
        distribution (ie., that need to be run).  This is based on the
        'sub_commands' class attribute: each tuple in that list may include
        a method that we call to determine if the subcommand needs to be
        run for the current distribution.  Return a list of command names.
        """
        commands = []
        for (cmd_name, method) in self.sub_commands:
            if method is None or method(self):
                commands.append(cmd_name)
        return commands


    # -- External world manipulation -----------------------------------

    def warn(self, msg):
        log.warn("warning: %s: %s\n", self.get_command_name(), msg)

    def execute(self, func, args, msg=None, level=1):
        util.execute(func, args, msg, dry_run=self.dry_run)

    def mkpath(self, name, mode=0o777):
        dir_util.mkpath(name, mode, dry_run=self.dry_run)

    def copy_file(self, infile, outfile, preserve_mode=1, preserve_times=1,
                  link=None, level=1):
        """Copy a file respecting verbose, dry-run and force flags.  (The
        former two default to whatever is in the Distribution object, and
        the latter defaults to false for commands that don't define it.)"""
        return file_util.copy_file(infile, outfile, preserve_mode,
                                   preserve_times, not self.force, link,
                                   dry_run=self.dry_run)

    def copy_tree(self, infile, outfile, preserve_mode=1, preserve_times=1,
                   preserve_symlinks=0, level=1):
        """Copy an entire directory tree respecting verbose, dry-run,
        and force flags.
        """
        return dir_util.copy_tree(infile, outfile, preserve_mode,
                                  preserve_times, preserve_symlinks,
                                  not self.force, dry_run=self.dry_run)

    def move_file (self, src, dst, level=1):
        """Move a file respecting dry-run flag."""
        return file_util.move_file(src, dst, dry_run=self.dry_run)

    def spawn(self, cmd, search_path=1, level=1):
        """Spawn an external command respecting dry-run flag."""
        from distutils.spawn import spawn
        spawn(cmd, search_path, dry_run=self.dry_run)

    def make_archive(self, base_name, format, root_dir=None, base_dir=None,
                     owner=None, group=None):
        return archive_util.make_archive(base_name, format, root_dir, base_dir,
                                         dry_run=self.dry_run,
                                         owner=owner, group=group)

    def make_file(self, infiles, outfile, func, args,
                  exec_msg=None, skip_msg=None, level=1):
        """Special case of 'execute()' for operations that process one or
        more input files and generate one output file.  Works just like
        'execute()', except the operation is skipped and a different
        message printed if 'outfile' already exists and is newer than all
        files listed in 'infiles'.  If the command defined 'self.force',
        and it is true, then the command is unconditionally run -- does no
        timestamp checks.
        """
        if skip_msg is None:
            skip_msg = "skipping %s (inputs unchanged)" % outfile

        # Allow 'infiles' to be a single string
        if isinstance(infiles, str):
            infiles = (infiles,)
        elif not isinstance(infiles, (list, tuple)):
            raise TypeError(
                  "'infiles' must be a string, or a list or tuple of strings")

        if exec_msg is None:
            exec_msg = "generating %s from %s" % (outfile, ', '.join(infiles))

        # If 'outfile' must be regenerated (either because it doesn't
        # exist, is out-of-date, or the 'force' flag is true) then
        # perform the action that presumably regenerates it
        if self.force or dep_util.newer_group(infiles, outfile):
            self.execute(func, args, exec_msg, level)
        # Otherwise, print the "skip" message
        else:
            log.debug(skip_msg)
././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1639341979.92667
setuptools-59.6.0/setuptools/_distutils/command/0000755000175100001710000000000000000000000021416 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/__init__.py0000644000175100001710000000143700000000000023534 0ustar00runnerdocker"""distutils.command

Package containing implementation of all the standard Distutils
commands."""

__all__ = ['build',
           'build_py',
           'build_ext',
           'build_clib',
           'build_scripts',
           'clean',
           'install',
           'install_lib',
           'install_headers',
           'install_scripts',
           'install_data',
           'sdist',
           'register',
           'bdist',
           'bdist_dumb',
           'bdist_rpm',
           'bdist_wininst',
           'check',
           'upload',
           # These two are reserved for future use:
           #'bdist_sdux',
           #'bdist_pkgtool',
           # Note:
           # bdist_packager is not included because it only provides
           # an abstract base class
          ]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/bdist.py0000644000175100001710000001267200000000000023105 0ustar00runnerdocker"""distutils.command.bdist

Implements the Distutils 'bdist' command (create a built [binary]
distribution)."""

import os
from distutils.core import Command
from distutils.errors import *
from distutils.util import get_platform


def show_formats():
    """Print list of available formats (arguments to "--format" option).
    """
    from distutils.fancy_getopt import FancyGetopt
    formats = []
    for format in bdist.format_commands:
        formats.append(("formats=" + format, None,
                        bdist.format_command[format][1]))
    pretty_printer = FancyGetopt(formats)
    pretty_printer.print_help("List of available distribution formats:")


class bdist(Command):

    description = "create a built (binary) distribution"

    user_options = [('bdist-base=', 'b',
                     "temporary directory for creating built distributions"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('formats=', None,
                     "formats for distribution (comma-separated list)"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in "
                     "[default: dist]"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('owner=', 'u',
                     "Owner name used when creating a tar file"
                     " [default: current user]"),
                    ('group=', 'g',
                     "Group name used when creating a tar file"
                     " [default: current group]"),
                   ]

    boolean_options = ['skip-build']

    help_options = [
        ('help-formats', None,
         "lists available distribution formats", show_formats),
        ]

    # The following commands do not take a format option from bdist
    no_format_option = ('bdist_rpm',)

    # This won't do in reality: will need to distinguish RPM-ish Linux,
    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
    default_format = {'posix': 'gztar',
                      'nt': 'zip'}

    # Establish the preferred order (for the --help-formats option).
    format_commands = ['rpm', 'gztar', 'bztar', 'xztar', 'ztar', 'tar',
                       'wininst', 'zip', 'msi']

    # And the real information.
    format_command = {'rpm':   ('bdist_rpm',  "RPM distribution"),
                      'gztar': ('bdist_dumb', "gzip'ed tar file"),
                      'bztar': ('bdist_dumb', "bzip2'ed tar file"),
                      'xztar': ('bdist_dumb', "xz'ed tar file"),
                      'ztar':  ('bdist_dumb', "compressed tar file"),
                      'tar':   ('bdist_dumb', "tar file"),
                      'wininst': ('bdist_wininst',
                                  "Windows executable installer"),
                      'zip':   ('bdist_dumb', "ZIP file"),
                      'msi':   ('bdist_msi',  "Microsoft Installer")
                      }


    def initialize_options(self):
        self.bdist_base = None
        self.plat_name = None
        self.formats = None
        self.dist_dir = None
        self.skip_build = 0
        self.group = None
        self.owner = None

    def finalize_options(self):
        # have to finalize 'plat_name' before 'bdist_base'
        if self.plat_name is None:
            if self.skip_build:
                self.plat_name = get_platform()
            else:
                self.plat_name = self.get_finalized_command('build').plat_name

        # 'bdist_base' -- parent of per-built-distribution-format
        # temporary directories (eg. we'll probably have
        # "build/bdist./dumb", "build/bdist./rpm", etc.)
        if self.bdist_base is None:
            build_base = self.get_finalized_command('build').build_base
            self.bdist_base = os.path.join(build_base,
                                           'bdist.' + self.plat_name)

        self.ensure_string_list('formats')
        if self.formats is None:
            try:
                self.formats = [self.default_format[os.name]]
            except KeyError:
                raise DistutilsPlatformError(
                      "don't know how to create built distributions "
                      "on platform %s" % os.name)

        if self.dist_dir is None:
            self.dist_dir = "dist"

    def run(self):
        # Figure out which sub-commands we need to run.
        commands = []
        for format in self.formats:
            try:
                commands.append(self.format_command[format][0])
            except KeyError:
                raise DistutilsOptionError("invalid format '%s'" % format)

        # Reinitialize and run each command.
        for i in range(len(self.formats)):
            cmd_name = commands[i]
            sub_cmd = self.reinitialize_command(cmd_name)
            if cmd_name not in self.no_format_option:
                sub_cmd.format = self.formats[i]

            # passing the owner and group names for tar archiving
            if cmd_name == 'bdist_dumb':
                sub_cmd.owner = self.owner
                sub_cmd.group = self.group

            # If we're going to need to run this command again, tell it to
            # keep its temporary files around so subsequent runs go faster.
            if cmd_name in commands[i+1:]:
                sub_cmd.keep_temp = 1
            self.run_command(cmd_name)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/bdist_dumb.py0000644000175100001710000001146100000000000024107 0ustar00runnerdocker"""distutils.command.bdist_dumb

Implements the Distutils 'bdist_dumb' command (create a "dumb" built
distribution -- i.e., just an archive to be unpacked under $prefix or
$exec_prefix)."""

import os
from distutils.core import Command
from distutils.util import get_platform
from distutils.dir_util import remove_tree, ensure_relative
from distutils.errors import *
from distutils.sysconfig import get_python_version
from distutils import log

class bdist_dumb(Command):

    description = "create a \"dumb\" built distribution"

    user_options = [('bdist-dir=', 'd',
                     "temporary directory for creating the distribution"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('format=', 'f',
                     "archive format to create (tar, gztar, bztar, xztar, "
                     "ztar, zip)"),
                    ('keep-temp', 'k',
                     "keep the pseudo-installation tree around after " +
                     "creating the distribution archive"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('relative', None,
                     "build the archive using relative paths "
                     "(default: false)"),
                    ('owner=', 'u',
                     "Owner name used when creating a tar file"
                     " [default: current user]"),
                    ('group=', 'g',
                     "Group name used when creating a tar file"
                     " [default: current group]"),
                   ]

    boolean_options = ['keep-temp', 'skip-build', 'relative']

    default_format = { 'posix': 'gztar',
                       'nt': 'zip' }

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.format = None
        self.keep_temp = 0
        self.dist_dir = None
        self.skip_build = None
        self.relative = 0
        self.owner = None
        self.group = None

    def finalize_options(self):
        if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'dumb')

        if self.format is None:
            try:
                self.format = self.default_format[os.name]
            except KeyError:
                raise DistutilsPlatformError(
                       "don't know how to create dumb built distributions "
                       "on platform %s" % os.name)

        self.set_undefined_options('bdist',
                                   ('dist_dir', 'dist_dir'),
                                   ('plat_name', 'plat_name'),
                                   ('skip_build', 'skip_build'))

    def run(self):
        if not self.skip_build:
            self.run_command('build')

        install = self.reinitialize_command('install', reinit_subcommands=1)
        install.root = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0

        log.info("installing to %s", self.bdist_dir)
        self.run_command('install')

        # And make an archive relative to the root of the
        # pseudo-installation tree.
        archive_basename = "%s.%s" % (self.distribution.get_fullname(),
                                      self.plat_name)

        pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
        if not self.relative:
            archive_root = self.bdist_dir
        else:
            if (self.distribution.has_ext_modules() and
                (install.install_base != install.install_platbase)):
                raise DistutilsPlatformError(
                       "can't make a dumb built distribution where "
                       "base and platbase are different (%s, %s)"
                       % (repr(install.install_base),
                          repr(install.install_platbase)))
            else:
                archive_root = os.path.join(self.bdist_dir,
                                   ensure_relative(install.install_base))

        # Make the archive
        filename = self.make_archive(pseudoinstall_root,
                                     self.format, root_dir=archive_root,
                                     owner=self.owner, group=self.group)
        if self.distribution.has_ext_modules():
            pyversion = get_python_version()
        else:
            pyversion = 'any'
        self.distribution.dist_files.append(('bdist_dumb', pyversion,
                                             filename))

        if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/bdist_msi.py0000644000175100001710000010537300000000000023756 0ustar00runnerdocker# Copyright (C) 2005, 2006 Martin von Löwis
# Licensed to PSF under a Contributor Agreement.
# The bdist_wininst command proper
# based on bdist_wininst
"""
Implements the bdist_msi command.
"""

import os
import sys
import warnings
from distutils.core import Command
from distutils.dir_util import remove_tree
from distutils.sysconfig import get_python_version
from distutils.version import StrictVersion
from distutils.errors import DistutilsOptionError
from distutils.util import get_platform
from distutils import log
import msilib
from msilib import schema, sequence, text
from msilib import Directory, Feature, Dialog, add_data

class PyDialog(Dialog):
    """Dialog class with a fixed layout: controls at the top, then a ruler,
    then a list of buttons: back, next, cancel. Optionally a bitmap at the
    left."""
    def __init__(self, *args, **kw):
        """Dialog(database, name, x, y, w, h, attributes, title, first,
        default, cancel, bitmap=true)"""
        Dialog.__init__(self, *args)
        ruler = self.h - 36
        bmwidth = 152*ruler/328
        #if kw.get("bitmap", True):
        #    self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")
        self.line("BottomLine", 0, ruler, self.w, 0)

    def title(self, title):
        "Set the title text of the dialog at the top."
        # name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix,
        # text, in VerdanaBold10
        self.text("Title", 15, 10, 320, 60, 0x30003,
                  r"{\VerdanaBold10}%s" % title)

    def back(self, title, next, name = "Back", active = 1):
        """Add a back button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

        Return the button, so that events can be associated"""
        if active:
            flags = 3 # Visible|Enabled
        else:
            flags = 1 # Visible
        return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next)

    def cancel(self, title, next, name = "Cancel", active = 1):
        """Add a cancel button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

        Return the button, so that events can be associated"""
        if active:
            flags = 3 # Visible|Enabled
        else:
            flags = 1 # Visible
        return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next)

    def next(self, title, next, name = "Next", active = 1):
        """Add a Next button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

        Return the button, so that events can be associated"""
        if active:
            flags = 3 # Visible|Enabled
        else:
            flags = 1 # Visible
        return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next)

    def xbutton(self, name, title, next, xpos):
        """Add a button with a given title, the tab-next button,
        its name in the Control table, giving its x position; the
        y-position is aligned with the other buttons.

        Return the button, so that events can be associated"""
        return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)

class bdist_msi(Command):

    description = "create a Microsoft Installer (.msi) binary distribution"

    user_options = [('bdist-dir=', None,
                     "temporary directory for creating the distribution"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('keep-temp', 'k',
                     "keep the pseudo-installation tree around after " +
                     "creating the distribution archive"),
                    ('target-version=', None,
                     "require a specific python version" +
                     " on the target system"),
                    ('no-target-compile', 'c',
                     "do not compile .py to .pyc on the target system"),
                    ('no-target-optimize', 'o',
                     "do not compile .py to .pyo (optimized) "
                     "on the target system"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('install-script=', None,
                     "basename of installation script to be run after "
                     "installation or before deinstallation"),
                    ('pre-install-script=', None,
                     "Fully qualified filename of a script to be run before "
                     "any files are installed.  This script need not be in the "
                     "distribution"),
                   ]

    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
                       'skip-build']

    all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4',
                    '2.5', '2.6', '2.7', '2.8', '2.9',
                    '3.0', '3.1', '3.2', '3.3', '3.4',
                    '3.5', '3.6', '3.7', '3.8', '3.9']
    other_version = 'X'

    def __init__(self, *args, **kw):
        super().__init__(*args, **kw)
        warnings.warn("bdist_msi command is deprecated since Python 3.9, "
                      "use bdist_wheel (wheel packages) instead",
                      DeprecationWarning, 2)

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.no_target_compile = 0
        self.no_target_optimize = 0
        self.target_version = None
        self.dist_dir = None
        self.skip_build = None
        self.install_script = None
        self.pre_install_script = None
        self.versions = None

    def finalize_options(self):
        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))

        if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'msi')

        short_version = get_python_version()
        if (not self.target_version) and self.distribution.has_ext_modules():
            self.target_version = short_version

        if self.target_version:
            self.versions = [self.target_version]
            if not self.skip_build and self.distribution.has_ext_modules()\
               and self.target_version != short_version:
                raise DistutilsOptionError(
                      "target version can only be %s, or the '--skip-build'"
                      " option must be specified" % (short_version,))
        else:
            self.versions = list(self.all_versions)

        self.set_undefined_options('bdist',
                                   ('dist_dir', 'dist_dir'),
                                   ('plat_name', 'plat_name'),
                                   )

        if self.pre_install_script:
            raise DistutilsOptionError(
                  "the pre-install-script feature is not yet implemented")

        if self.install_script:
            for script in self.distribution.scripts:
                if self.install_script == os.path.basename(script):
                    break
            else:
                raise DistutilsOptionError(
                      "install_script '%s' not found in scripts"
                      % self.install_script)
        self.install_script_key = None

    def run(self):
        if not self.skip_build:
            self.run_command('build')

        install = self.reinitialize_command('install', reinit_subcommands=1)
        install.prefix = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0

        install_lib = self.reinitialize_command('install_lib')
        # we do not want to include pyc or pyo files
        install_lib.compile = 0
        install_lib.optimize = 0

        if self.distribution.has_ext_modules():
            # If we are building an installer for a Python version other
            # than the one we are currently running, then we need to ensure
            # our build_lib reflects the other Python version rather than ours.
            # Note that for target_version!=sys.version, we must have skipped the
            # build step, so there is no issue with enforcing the build of this
            # version.
            target_version = self.target_version
            if not target_version:
                assert self.skip_build, "Should have already checked this"
                target_version = '%d.%d' % sys.version_info[:2]
            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
            build = self.get_finalized_command('build')
            build.build_lib = os.path.join(build.build_base,
                                           'lib' + plat_specifier)

        log.info("installing to %s", self.bdist_dir)
        install.ensure_finalized()

        # avoid warning of 'install_lib' about installing
        # into a directory not in sys.path
        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))

        install.run()

        del sys.path[0]

        self.mkpath(self.dist_dir)
        fullname = self.distribution.get_fullname()
        installer_name = self.get_installer_filename(fullname)
        installer_name = os.path.abspath(installer_name)
        if os.path.exists(installer_name): os.unlink(installer_name)

        metadata = self.distribution.metadata
        author = metadata.author
        if not author:
            author = metadata.maintainer
        if not author:
            author = "UNKNOWN"
        version = metadata.get_version()
        # ProductVersion must be strictly numeric
        # XXX need to deal with prerelease versions
        sversion = "%d.%d.%d" % StrictVersion(version).version
        # Prefix ProductName with Python x.y, so that
        # it sorts together with the other Python packages
        # in Add-Remove-Programs (APR)
        fullname = self.distribution.get_fullname()
        if self.target_version:
            product_name = "Python %s %s" % (self.target_version, fullname)
        else:
            product_name = "Python %s" % (fullname)
        self.db = msilib.init_database(installer_name, schema,
                product_name, msilib.gen_uuid(),
                sversion, author)
        msilib.add_tables(self.db, sequence)
        props = [('DistVersion', version)]
        email = metadata.author_email or metadata.maintainer_email
        if email:
            props.append(("ARPCONTACT", email))
        if metadata.url:
            props.append(("ARPURLINFOABOUT", metadata.url))
        if props:
            add_data(self.db, 'Property', props)

        self.add_find_python()
        self.add_files()
        self.add_scripts()
        self.add_ui()
        self.db.Commit()

        if hasattr(self.distribution, 'dist_files'):
            tup = 'bdist_msi', self.target_version or 'any', fullname
            self.distribution.dist_files.append(tup)

        if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)

    def add_files(self):
        db = self.db
        cab = msilib.CAB("distfiles")
        rootdir = os.path.abspath(self.bdist_dir)

        root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
        f = Feature(db, "Python", "Python", "Everything",
                    0, 1, directory="TARGETDIR")

        items = [(f, root, '')]
        for version in self.versions + [self.other_version]:
            target = "TARGETDIR" + version
            name = default = "Python" + version
            desc = "Everything"
            if version is self.other_version:
                title = "Python from another location"
                level = 2
            else:
                title = "Python %s from registry" % version
                level = 1
            f = Feature(db, name, title, desc, 1, level, directory=target)
            dir = Directory(db, cab, root, rootdir, target, default)
            items.append((f, dir, version))
        db.Commit()

        seen = {}
        for feature, dir, version in items:
            todo = [dir]
            while todo:
                dir = todo.pop()
                for file in os.listdir(dir.absolute):
                    afile = os.path.join(dir.absolute, file)
                    if os.path.isdir(afile):
                        short = "%s|%s" % (dir.make_short(file), file)
                        default = file + version
                        newdir = Directory(db, cab, dir, file, default, short)
                        todo.append(newdir)
                    else:
                        if not dir.component:
                            dir.start_component(dir.logical, feature, 0)
                        if afile not in seen:
                            key = seen[afile] = dir.add_file(file)
                            if file==self.install_script:
                                if self.install_script_key:
                                    raise DistutilsOptionError(
                                          "Multiple files with name %s" % file)
                                self.install_script_key = '[#%s]' % key
                        else:
                            key = seen[afile]
                            add_data(self.db, "DuplicateFile",
                                [(key + version, dir.component, key, None, dir.logical)])
            db.Commit()
        cab.commit(db)

    def add_find_python(self):
        """Adds code to the installer to compute the location of Python.

        Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
        registry for each version of Python.

        Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
        else from PYTHON.MACHINE.X.Y.

        Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe"""

        start = 402
        for ver in self.versions:
            install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
            machine_reg = "python.machine." + ver
            user_reg = "python.user." + ver
            machine_prop = "PYTHON.MACHINE." + ver
            user_prop = "PYTHON.USER." + ver
            machine_action = "PythonFromMachine" + ver
            user_action = "PythonFromUser" + ver
            exe_action = "PythonExe" + ver
            target_dir_prop = "TARGETDIR" + ver
            exe_prop = "PYTHON" + ver
            if msilib.Win64:
                # type: msidbLocatorTypeRawValue + msidbLocatorType64bit
                Type = 2+16
            else:
                Type = 2
            add_data(self.db, "RegLocator",
                    [(machine_reg, 2, install_path, None, Type),
                     (user_reg, 1, install_path, None, Type)])
            add_data(self.db, "AppSearch",
                    [(machine_prop, machine_reg),
                     (user_prop, user_reg)])
            add_data(self.db, "CustomAction",
                    [(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
                     (user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
                     (exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
                    ])
            add_data(self.db, "InstallExecuteSequence",
                    [(machine_action, machine_prop, start),
                     (user_action, user_prop, start + 1),
                     (exe_action, None, start + 2),
                    ])
            add_data(self.db, "InstallUISequence",
                    [(machine_action, machine_prop, start),
                     (user_action, user_prop, start + 1),
                     (exe_action, None, start + 2),
                    ])
            add_data(self.db, "Condition",
                    [("Python" + ver, 0, "NOT TARGETDIR" + ver)])
            start += 4
            assert start < 500

    def add_scripts(self):
        if self.install_script:
            start = 6800
            for ver in self.versions + [self.other_version]:
                install_action = "install_script." + ver
                exe_prop = "PYTHON" + ver
                add_data(self.db, "CustomAction",
                        [(install_action, 50, exe_prop, self.install_script_key)])
                add_data(self.db, "InstallExecuteSequence",
                        [(install_action, "&Python%s=3" % ver, start)])
                start += 1
        # XXX pre-install scripts are currently refused in finalize_options()
        #     but if this feature is completed, it will also need to add
        #     entries for each version as the above code does
        if self.pre_install_script:
            scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
            with open(scriptfn, "w") as f:
                # The batch file will be executed with [PYTHON], so that %1
                # is the path to the Python interpreter; %0 will be the path
                # of the batch file.
                # rem ="""
                # %1 %0
                # exit
                # """
                # 
                f.write('rem ="""\n%1 %0\nexit\n"""\n')
                with open(self.pre_install_script) as fin:
                    f.write(fin.read())
            add_data(self.db, "Binary",
                [("PreInstall", msilib.Binary(scriptfn))
                ])
            add_data(self.db, "CustomAction",
                [("PreInstall", 2, "PreInstall", None)
                ])
            add_data(self.db, "InstallExecuteSequence",
                    [("PreInstall", "NOT Installed", 450)])


    def add_ui(self):
        db = self.db
        x = y = 50
        w = 370
        h = 300
        title = "[ProductName] Setup"

        # see "Dialog Style Bits"
        modal = 3      # visible | modal
        modeless = 1   # visible
        track_disk_space = 32

        # UI customization properties
        add_data(db, "Property",
                 # See "DefaultUIFont Property"
                 [("DefaultUIFont", "DlgFont8"),
                  # See "ErrorDialog Style Bit"
                  ("ErrorDialog", "ErrorDlg"),
                  ("Progress1", "Install"),   # modified in maintenance type dlg
                  ("Progress2", "installs"),
                  ("MaintenanceForm_Action", "Repair"),
                  # possible values: ALL, JUSTME
                  ("WhichUsers", "ALL")
                 ])

        # Fonts, see "TextStyle Table"
        add_data(db, "TextStyle",
                 [("DlgFont8", "Tahoma", 9, None, 0),
                  ("DlgFontBold8", "Tahoma", 8, None, 1), #bold
                  ("VerdanaBold10", "Verdana", 10, None, 1),
                  ("VerdanaRed9", "Verdana", 9, 255, 0),
                 ])

        # UI Sequences, see "InstallUISequence Table", "Using a Sequence Table"
        # Numbers indicate sequence; see sequence.py for how these action integrate
        add_data(db, "InstallUISequence",
                 [("PrepareDlg", "Not Privileged or Windows9x or Installed", 140),
                  ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),
                  # In the user interface, assume all-users installation if privileged.
                  ("SelectFeaturesDlg", "Not Installed", 1230),
                  # XXX no support for resume installations yet
                  #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),
                  ("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250),
                  ("ProgressDlg", None, 1280)])

        add_data(db, 'ActionText', text.ActionText)
        add_data(db, 'UIText', text.UIText)
        #####################################################################
        # Standard dialogs: FatalError, UserExit, ExitDialog
        fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title,
                     "Finish", "Finish", "Finish")
        fatal.title("[ProductName] Installer ended prematurely")
        fatal.back("< Back", "Finish", active = 0)
        fatal.cancel("Cancel", "Back", active = 0)
        fatal.text("Description1", 15, 70, 320, 80, 0x30003,
                   "[ProductName] setup ended prematurely because of an error.  Your system has not been modified.  To install this program at a later time, please run the installation again.")
        fatal.text("Description2", 15, 155, 320, 20, 0x30003,
                   "Click the Finish button to exit the Installer.")
        c=fatal.next("Finish", "Cancel", name="Finish")
        c.event("EndDialog", "Exit")

        user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title,
                     "Finish", "Finish", "Finish")
        user_exit.title("[ProductName] Installer was interrupted")
        user_exit.back("< Back", "Finish", active = 0)
        user_exit.cancel("Cancel", "Back", active = 0)
        user_exit.text("Description1", 15, 70, 320, 80, 0x30003,
                   "[ProductName] setup was interrupted.  Your system has not been modified.  "
                   "To install this program at a later time, please run the installation again.")
        user_exit.text("Description2", 15, 155, 320, 20, 0x30003,
                   "Click the Finish button to exit the Installer.")
        c = user_exit.next("Finish", "Cancel", name="Finish")
        c.event("EndDialog", "Exit")

        exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title,
                             "Finish", "Finish", "Finish")
        exit_dialog.title("Completing the [ProductName] Installer")
        exit_dialog.back("< Back", "Finish", active = 0)
        exit_dialog.cancel("Cancel", "Back", active = 0)
        exit_dialog.text("Description", 15, 235, 320, 20, 0x30003,
                   "Click the Finish button to exit the Installer.")
        c = exit_dialog.next("Finish", "Cancel", name="Finish")
        c.event("EndDialog", "Return")

        #####################################################################
        # Required dialog: FilesInUse, ErrorDlg
        inuse = PyDialog(db, "FilesInUse",
                         x, y, w, h,
                         19,                # KeepModeless|Modal|Visible
                         title,
                         "Retry", "Retry", "Retry", bitmap=False)
        inuse.text("Title", 15, 6, 200, 15, 0x30003,
                   r"{\DlgFontBold8}Files in Use")
        inuse.text("Description", 20, 23, 280, 20, 0x30003,
               "Some files that need to be updated are currently in use.")
        inuse.text("Text", 20, 55, 330, 50, 3,
                   "The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.")
        inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess",
                      None, None, None)
        c=inuse.back("Exit", "Ignore", name="Exit")
        c.event("EndDialog", "Exit")
        c=inuse.next("Ignore", "Retry", name="Ignore")
        c.event("EndDialog", "Ignore")
        c=inuse.cancel("Retry", "Exit", name="Retry")
        c.event("EndDialog","Retry")

        # See "Error Dialog". See "ICE20" for the required names of the controls.
        error = Dialog(db, "ErrorDlg",
                       50, 10, 330, 101,
                       65543,       # Error|Minimize|Modal|Visible
                       title,
                       "ErrorText", None, None)
        error.text("ErrorText", 50,9,280,48,3, "")
        #error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None)
        error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo")
        error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes")
        error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort")
        error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel")
        error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore")
        error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk")
        error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry")

        #####################################################################
        # Global "Query Cancel" dialog
        cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title,
                        "No", "No", "No")
        cancel.text("Text", 48, 15, 194, 30, 3,
                    "Are you sure you want to cancel [ProductName] installation?")
        #cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,
        #               "py.ico", None, None)
        c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No")
        c.event("EndDialog", "Exit")

        c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes")
        c.event("EndDialog", "Return")

        #####################################################################
        # Global "Wait for costing" dialog
        costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title,
                         "Return", "Return", "Return")
        costing.text("Text", 48, 15, 194, 30, 3,
                     "Please wait while the installer finishes determining your disk space requirements.")
        c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None)
        c.event("EndDialog", "Exit")

        #####################################################################
        # Preparation dialog: no user input except cancellation
        prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title,
                        "Cancel", "Cancel", "Cancel")
        prep.text("Description", 15, 70, 320, 40, 0x30003,
                  "Please wait while the Installer prepares to guide you through the installation.")
        prep.title("Welcome to the [ProductName] Installer")
        c=prep.text("ActionText", 15, 110, 320, 20, 0x30003, "Pondering...")
        c.mapping("ActionText", "Text")
        c=prep.text("ActionData", 15, 135, 320, 30, 0x30003, None)
        c.mapping("ActionData", "Text")
        prep.back("Back", None, active=0)
        prep.next("Next", None, active=0)
        c=prep.cancel("Cancel", None)
        c.event("SpawnDialog", "CancelDlg")

        #####################################################################
        # Feature (Python directory) selection
        seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title,
                        "Next", "Next", "Cancel")
        seldlg.title("Select Python Installations")

        seldlg.text("Hint", 15, 30, 300, 20, 3,
                    "Select the Python locations where %s should be installed."
                    % self.distribution.get_fullname())

        seldlg.back("< Back", None, active=0)
        c = seldlg.next("Next >", "Cancel")
        order = 1
        c.event("[TARGETDIR]", "[SourceDir]", ordering=order)
        for version in self.versions + [self.other_version]:
            order += 1
            c.event("[TARGETDIR]", "[TARGETDIR%s]" % version,
                    "FEATURE_SELECTED AND &Python%s=3" % version,
                    ordering=order)
        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
        c.event("EndDialog", "Return", ordering=order + 2)
        c = seldlg.cancel("Cancel", "Features")
        c.event("SpawnDialog", "CancelDlg")

        c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3,
                           "FEATURE", None, "PathEdit", None)
        c.event("[FEATURE_SELECTED]", "1")
        ver = self.other_version
        install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver
        dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver

        c = seldlg.text("Other", 15, 200, 300, 15, 3,
                        "Provide an alternate Python location")
        c.condition("Enable", install_other_cond)
        c.condition("Show", install_other_cond)
        c.condition("Disable", dont_install_other_cond)
        c.condition("Hide", dont_install_other_cond)

        c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1,
                           "TARGETDIR" + ver, None, "Next", None)
        c.condition("Enable", install_other_cond)
        c.condition("Show", install_other_cond)
        c.condition("Disable", dont_install_other_cond)
        c.condition("Hide", dont_install_other_cond)

        #####################################################################
        # Disk cost
        cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title,
                        "OK", "OK", "OK", bitmap=False)
        cost.text("Title", 15, 6, 200, 15, 0x30003,
                 r"{\DlgFontBold8}Disk Space Requirements")
        cost.text("Description", 20, 20, 280, 20, 0x30003,
                  "The disk space required for the installation of the selected features.")
        cost.text("Text", 20, 53, 330, 60, 3,
                  "The highlighted volumes (if any) do not have enough disk space "
              "available for the currently selected features.  You can either "
              "remove some files from the highlighted volumes, or choose to "
              "install less features onto local drive(s), or select different "
              "destination drive(s).")
        cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223,
                     None, "{120}{70}{70}{70}{70}", None, None)
        cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return")

        #####################################################################
        # WhichUsers Dialog. Only available on NT, and for privileged users.
        # This must be run before FindRelatedProducts, because that will
        # take into account whether the previous installation was per-user
        # or per-machine. We currently don't support going back to this
        # dialog after "Next" was selected; to support this, we would need to
        # find how to reset the ALLUSERS property, and how to re-run
        # FindRelatedProducts.
        # On Windows9x, the ALLUSERS property is ignored on the command line
        # and in the Property table, but installer fails according to the documentation
        # if a dialog attempts to set ALLUSERS.
        whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title,
                            "AdminInstall", "Next", "Cancel")
        whichusers.title("Select whether to install [ProductName] for all users of this computer.")
        # A radio group with two options: allusers, justme
        g = whichusers.radiogroup("AdminInstall", 15, 60, 260, 50, 3,
                                  "WhichUsers", "", "Next")
        g.add("ALL", 0, 5, 150, 20, "Install for all users")
        g.add("JUSTME", 0, 25, 150, 20, "Install just for me")

        whichusers.back("Back", None, active=0)

        c = whichusers.next("Next >", "Cancel")
        c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1)
        c.event("EndDialog", "Return", ordering = 2)

        c = whichusers.cancel("Cancel", "AdminInstall")
        c.event("SpawnDialog", "CancelDlg")

        #####################################################################
        # Installation Progress dialog (modeless)
        progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title,
                            "Cancel", "Cancel", "Cancel", bitmap=False)
        progress.text("Title", 20, 15, 200, 15, 0x30003,
                     r"{\DlgFontBold8}[Progress1] [ProductName]")
        progress.text("Text", 35, 65, 300, 30, 3,
                      "Please wait while the Installer [Progress2] [ProductName]. "
                      "This may take several minutes.")
        progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:")

        c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...")
        c.mapping("ActionText", "Text")

        #c=progress.text("ActionData", 35, 140, 300, 20, 3, None)
        #c.mapping("ActionData", "Text")

        c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537,
                           None, "Progress done", None, None)
        c.mapping("SetProgress", "Progress")

        progress.back("< Back", "Next", active=False)
        progress.next("Next >", "Cancel", active=False)
        progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg")

        ###################################################################
        # Maintenance type: repair/uninstall
        maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title,
                         "Next", "Next", "Cancel")
        maint.title("Welcome to the [ProductName] Setup Wizard")
        maint.text("BodyText", 15, 63, 330, 42, 3,
                   "Select whether you want to repair or remove [ProductName].")
        g=maint.radiogroup("RepairRadioGroup", 15, 108, 330, 60, 3,
                            "MaintenanceForm_Action", "", "Next")
        #g.add("Change", 0, 0, 200, 17, "&Change [ProductName]")
        g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]")
        g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]")

        maint.back("< Back", None, active=False)
        c=maint.next("Finish", "Cancel")
        # Change installation: Change progress dialog to "Change", then ask
        # for feature selection
        #c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1)
        #c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2)

        # Reinstall: Change progress dialog to "Repair", then invoke reinstall
        # Also set list of reinstalled features to "ALL"
        c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5)
        c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6)
        c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7)
        c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8)

        # Uninstall: Change progress to "Remove", then invoke uninstall
        # Also set list of removed features to "ALL"
        c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11)
        c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12)
        c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13)
        c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14)

        # Close dialog when maintenance action scheduled
        c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20)
        #c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21)

        maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg")

    def get_installer_filename(self, fullname):
        # Factored out to allow overriding in subclasses
        if self.target_version:
            base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
                                            self.target_version)
        else:
            base_name = "%s.%s.msi" % (fullname, self.plat_name)
        installer_name = os.path.join(self.dist_dir, base_name)
        return installer_name
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/bdist_rpm.py0000644000175100001710000005204100000000000023755 0ustar00runnerdocker"""distutils.command.bdist_rpm

Implements the Distutils 'bdist_rpm' command (create RPM source and binary
distributions)."""

import subprocess, sys, os
from distutils.core import Command
from distutils.debug import DEBUG
from distutils.file_util import write_file
from distutils.errors import *
from distutils.sysconfig import get_python_version
from distutils import log

class bdist_rpm(Command):

    description = "create an RPM distribution"

    user_options = [
        ('bdist-base=', None,
         "base directory for creating built distributions"),
        ('rpm-base=', None,
         "base directory for creating RPMs (defaults to \"rpm\" under "
         "--bdist-base; must be specified for RPM 2)"),
        ('dist-dir=', 'd',
         "directory to put final RPM files in "
         "(and .spec files if --spec-only)"),
        ('python=', None,
         "path to Python interpreter to hard-code in the .spec file "
         "(default: \"python\")"),
        ('fix-python', None,
         "hard-code the exact path to the current Python interpreter in "
         "the .spec file"),
        ('spec-only', None,
         "only regenerate spec file"),
        ('source-only', None,
         "only generate source RPM"),
        ('binary-only', None,
         "only generate binary RPM"),
        ('use-bzip2', None,
         "use bzip2 instead of gzip to create source distribution"),

        # More meta-data: too RPM-specific to put in the setup script,
        # but needs to go in the .spec file -- so we make these options
        # to "bdist_rpm".  The idea is that packagers would put this
        # info in setup.cfg, although they are of course free to
        # supply it on the command line.
        ('distribution-name=', None,
         "name of the (Linux) distribution to which this "
         "RPM applies (*not* the name of the module distribution!)"),
        ('group=', None,
         "package classification [default: \"Development/Libraries\"]"),
        ('release=', None,
         "RPM release number"),
        ('serial=', None,
         "RPM serial number"),
        ('vendor=', None,
         "RPM \"vendor\" (eg. \"Joe Blow \") "
         "[default: maintainer or author from setup script]"),
        ('packager=', None,
         "RPM packager (eg. \"Jane Doe \") "
         "[default: vendor]"),
        ('doc-files=', None,
         "list of documentation files (space or comma-separated)"),
        ('changelog=', None,
         "RPM changelog"),
        ('icon=', None,
         "name of icon file"),
        ('provides=', None,
         "capabilities provided by this package"),
        ('requires=', None,
         "capabilities required by this package"),
        ('conflicts=', None,
         "capabilities which conflict with this package"),
        ('build-requires=', None,
         "capabilities required to build this package"),
        ('obsoletes=', None,
         "capabilities made obsolete by this package"),
        ('no-autoreq', None,
         "do not automatically calculate dependencies"),

        # Actions to take when building RPM
        ('keep-temp', 'k',
         "don't clean up RPM build directory"),
        ('no-keep-temp', None,
         "clean up RPM build directory [default]"),
        ('use-rpm-opt-flags', None,
         "compile with RPM_OPT_FLAGS when building from source RPM"),
        ('no-rpm-opt-flags', None,
         "do not pass any RPM CFLAGS to compiler"),
        ('rpm3-mode', None,
         "RPM 3 compatibility mode (default)"),
        ('rpm2-mode', None,
         "RPM 2 compatibility mode"),

        # Add the hooks necessary for specifying custom scripts
        ('prep-script=', None,
         "Specify a script for the PREP phase of RPM building"),
        ('build-script=', None,
         "Specify a script for the BUILD phase of RPM building"),

        ('pre-install=', None,
         "Specify a script for the pre-INSTALL phase of RPM building"),
        ('install-script=', None,
         "Specify a script for the INSTALL phase of RPM building"),
        ('post-install=', None,
         "Specify a script for the post-INSTALL phase of RPM building"),

        ('pre-uninstall=', None,
         "Specify a script for the pre-UNINSTALL phase of RPM building"),
        ('post-uninstall=', None,
         "Specify a script for the post-UNINSTALL phase of RPM building"),

        ('clean-script=', None,
         "Specify a script for the CLEAN phase of RPM building"),

        ('verify-script=', None,
         "Specify a script for the VERIFY phase of the RPM build"),

        # Allow a packager to explicitly force an architecture
        ('force-arch=', None,
         "Force an architecture onto the RPM build process"),

        ('quiet', 'q',
         "Run the INSTALL phase of RPM building in quiet mode"),
        ]

    boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode',
                       'no-autoreq', 'quiet']

    negative_opt = {'no-keep-temp': 'keep-temp',
                    'no-rpm-opt-flags': 'use-rpm-opt-flags',
                    'rpm2-mode': 'rpm3-mode'}


    def initialize_options(self):
        self.bdist_base = None
        self.rpm_base = None
        self.dist_dir = None
        self.python = None
        self.fix_python = None
        self.spec_only = None
        self.binary_only = None
        self.source_only = None
        self.use_bzip2 = None

        self.distribution_name = None
        self.group = None
        self.release = None
        self.serial = None
        self.vendor = None
        self.packager = None
        self.doc_files = None
        self.changelog = None
        self.icon = None

        self.prep_script = None
        self.build_script = None
        self.install_script = None
        self.clean_script = None
        self.verify_script = None
        self.pre_install = None
        self.post_install = None
        self.pre_uninstall = None
        self.post_uninstall = None
        self.prep = None
        self.provides = None
        self.requires = None
        self.conflicts = None
        self.build_requires = None
        self.obsoletes = None

        self.keep_temp = 0
        self.use_rpm_opt_flags = 1
        self.rpm3_mode = 1
        self.no_autoreq = 0

        self.force_arch = None
        self.quiet = 0

    def finalize_options(self):
        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
        if self.rpm_base is None:
            if not self.rpm3_mode:
                raise DistutilsOptionError(
                      "you must specify --rpm-base in RPM 2 mode")
            self.rpm_base = os.path.join(self.bdist_base, "rpm")

        if self.python is None:
            if self.fix_python:
                self.python = sys.executable
            else:
                self.python = "python3"
        elif self.fix_python:
            raise DistutilsOptionError(
                  "--python and --fix-python are mutually exclusive options")

        if os.name != 'posix':
            raise DistutilsPlatformError("don't know how to create RPM "
                   "distributions on platform %s" % os.name)
        if self.binary_only and self.source_only:
            raise DistutilsOptionError(
                  "cannot supply both '--source-only' and '--binary-only'")

        # don't pass CFLAGS to pure python distributions
        if not self.distribution.has_ext_modules():
            self.use_rpm_opt_flags = 0

        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
        self.finalize_package_data()

    def finalize_package_data(self):
        self.ensure_string('group', "Development/Libraries")
        self.ensure_string('vendor',
                           "%s <%s>" % (self.distribution.get_contact(),
                                        self.distribution.get_contact_email()))
        self.ensure_string('packager')
        self.ensure_string_list('doc_files')
        if isinstance(self.doc_files, list):
            for readme in ('README', 'README.txt'):
                if os.path.exists(readme) and readme not in self.doc_files:
                    self.doc_files.append(readme)

        self.ensure_string('release', "1")
        self.ensure_string('serial')   # should it be an int?

        self.ensure_string('distribution_name')

        self.ensure_string('changelog')
          # Format changelog correctly
        self.changelog = self._format_changelog(self.changelog)

        self.ensure_filename('icon')

        self.ensure_filename('prep_script')
        self.ensure_filename('build_script')
        self.ensure_filename('install_script')
        self.ensure_filename('clean_script')
        self.ensure_filename('verify_script')
        self.ensure_filename('pre_install')
        self.ensure_filename('post_install')
        self.ensure_filename('pre_uninstall')
        self.ensure_filename('post_uninstall')

        # XXX don't forget we punted on summaries and descriptions -- they
        # should be handled here eventually!

        # Now *this* is some meta-data that belongs in the setup script...
        self.ensure_string_list('provides')
        self.ensure_string_list('requires')
        self.ensure_string_list('conflicts')
        self.ensure_string_list('build_requires')
        self.ensure_string_list('obsoletes')

        self.ensure_string('force_arch')

    def run(self):
        if DEBUG:
            print("before _get_package_data():")
            print("vendor =", self.vendor)
            print("packager =", self.packager)
            print("doc_files =", self.doc_files)
            print("changelog =", self.changelog)

        # make directories
        if self.spec_only:
            spec_dir = self.dist_dir
            self.mkpath(spec_dir)
        else:
            rpm_dir = {}
            for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
                rpm_dir[d] = os.path.join(self.rpm_base, d)
                self.mkpath(rpm_dir[d])
            spec_dir = rpm_dir['SPECS']

        # Spec file goes into 'dist_dir' if '--spec-only specified',
        # build/rpm. otherwise.
        spec_path = os.path.join(spec_dir,
                                 "%s.spec" % self.distribution.get_name())
        self.execute(write_file,
                     (spec_path,
                      self._make_spec_file()),
                     "writing '%s'" % spec_path)

        if self.spec_only: # stop if requested
            return

        # Make a source distribution and copy to SOURCES directory with
        # optional icon.
        saved_dist_files = self.distribution.dist_files[:]
        sdist = self.reinitialize_command('sdist')
        if self.use_bzip2:
            sdist.formats = ['bztar']
        else:
            sdist.formats = ['gztar']
        self.run_command('sdist')
        self.distribution.dist_files = saved_dist_files

        source = sdist.get_archive_files()[0]
        source_dir = rpm_dir['SOURCES']
        self.copy_file(source, source_dir)

        if self.icon:
            if os.path.exists(self.icon):
                self.copy_file(self.icon, source_dir)
            else:
                raise DistutilsFileError(
                      "icon file '%s' does not exist" % self.icon)

        # build package
        log.info("building RPMs")
        rpm_cmd = ['rpmbuild']

        if self.source_only: # what kind of RPMs?
            rpm_cmd.append('-bs')
        elif self.binary_only:
            rpm_cmd.append('-bb')
        else:
            rpm_cmd.append('-ba')
        rpm_cmd.extend(['--define', '__python %s' % self.python])
        if self.rpm3_mode:
            rpm_cmd.extend(['--define',
                             '_topdir %s' % os.path.abspath(self.rpm_base)])
        if not self.keep_temp:
            rpm_cmd.append('--clean')

        if self.quiet:
            rpm_cmd.append('--quiet')

        rpm_cmd.append(spec_path)
        # Determine the binary rpm names that should be built out of this spec
        # file
        # Note that some of these may not be really built (if the file
        # list is empty)
        nvr_string = "%{name}-%{version}-%{release}"
        src_rpm = nvr_string + ".src.rpm"
        non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
        q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
            src_rpm, non_src_rpm, spec_path)

        out = os.popen(q_cmd)
        try:
            binary_rpms = []
            source_rpm = None
            while True:
                line = out.readline()
                if not line:
                    break
                l = line.strip().split()
                assert(len(l) == 2)
                binary_rpms.append(l[1])
                # The source rpm is named after the first entry in the spec file
                if source_rpm is None:
                    source_rpm = l[0]

            status = out.close()
            if status:
                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))

        finally:
            out.close()

        self.spawn(rpm_cmd)

        if not self.dry_run:
            if self.distribution.has_ext_modules():
                pyversion = get_python_version()
            else:
                pyversion = 'any'

            if not self.binary_only:
                srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
                assert(os.path.exists(srpm))
                self.move_file(srpm, self.dist_dir)
                filename = os.path.join(self.dist_dir, source_rpm)
                self.distribution.dist_files.append(
                    ('bdist_rpm', pyversion, filename))

            if not self.source_only:
                for rpm in binary_rpms:
                    rpm = os.path.join(rpm_dir['RPMS'], rpm)
                    if os.path.exists(rpm):
                        self.move_file(rpm, self.dist_dir)
                        filename = os.path.join(self.dist_dir,
                                                os.path.basename(rpm))
                        self.distribution.dist_files.append(
                            ('bdist_rpm', pyversion, filename))

    def _dist_path(self, path):
        return os.path.join(self.dist_dir, os.path.basename(path))

    def _make_spec_file(self):
        """Generate the text of an RPM spec file and return it as a
        list of strings (one per line).
        """
        # definitions and headers
        spec_file = [
            '%define name ' + self.distribution.get_name(),
            '%define version ' + self.distribution.get_version().replace('-','_'),
            '%define unmangled_version ' + self.distribution.get_version(),
            '%define release ' + self.release.replace('-','_'),
            '',
            'Summary: ' + self.distribution.get_description(),
            ]

        # Workaround for #14443 which affects some RPM based systems such as
        # RHEL6 (and probably derivatives)
        vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
        # Generate a potential replacement value for __os_install_post (whilst
        # normalizing the whitespace to simplify the test for whether the
        # invocation of brp-python-bytecompile passes in __python):
        vendor_hook = '\n'.join(['  %s \\' % line.strip()
                                 for line in vendor_hook.splitlines()])
        problem = "brp-python-bytecompile \\\n"
        fixed = "brp-python-bytecompile %{__python} \\\n"
        fixed_hook = vendor_hook.replace(problem, fixed)
        if fixed_hook != vendor_hook:
            spec_file.append('# Workaround for http://bugs.python.org/issue14443')
            spec_file.append('%define __os_install_post ' + fixed_hook + '\n')

        # put locale summaries into spec file
        # XXX not supported for now (hard to put a dictionary
        # in a config file -- arg!)
        #for locale in self.summaries.keys():
        #    spec_file.append('Summary(%s): %s' % (locale,
        #                                          self.summaries[locale]))

        spec_file.extend([
            'Name: %{name}',
            'Version: %{version}',
            'Release: %{release}',])

        # XXX yuck! this filename is available from the "sdist" command,
        # but only after it has run: and we create the spec file before
        # running "sdist", in case of --spec-only.
        if self.use_bzip2:
            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
        else:
            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')

        spec_file.extend([
            'License: ' + self.distribution.get_license(),
            'Group: ' + self.group,
            'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
            'Prefix: %{_prefix}', ])

        if not self.force_arch:
            # noarch if no extension modules
            if not self.distribution.has_ext_modules():
                spec_file.append('BuildArch: noarch')
        else:
            spec_file.append( 'BuildArch: %s' % self.force_arch )

        for field in ('Vendor',
                      'Packager',
                      'Provides',
                      'Requires',
                      'Conflicts',
                      'Obsoletes',
                      ):
            val = getattr(self, field.lower())
            if isinstance(val, list):
                spec_file.append('%s: %s' % (field, ' '.join(val)))
            elif val is not None:
                spec_file.append('%s: %s' % (field, val))


        if self.distribution.get_url() != 'UNKNOWN':
            spec_file.append('Url: ' + self.distribution.get_url())

        if self.distribution_name:
            spec_file.append('Distribution: ' + self.distribution_name)

        if self.build_requires:
            spec_file.append('BuildRequires: ' +
                             ' '.join(self.build_requires))

        if self.icon:
            spec_file.append('Icon: ' + os.path.basename(self.icon))

        if self.no_autoreq:
            spec_file.append('AutoReq: 0')

        spec_file.extend([
            '',
            '%description',
            self.distribution.get_long_description()
            ])

        # put locale descriptions into spec file
        # XXX again, suppressed because config file syntax doesn't
        # easily support this ;-(
        #for locale in self.descriptions.keys():
        #    spec_file.extend([
        #        '',
        #        '%description -l ' + locale,
        #        self.descriptions[locale],
        #        ])

        # rpm scripts
        # figure out default build script
        def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0]))
        def_build = "%s build" % def_setup_call
        if self.use_rpm_opt_flags:
            def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build

        # insert contents of files

        # XXX this is kind of misleading: user-supplied options are files
        # that we open and interpolate into the spec file, but the defaults
        # are just text that we drop in as-is.  Hmmm.

        install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT '
                       '--record=INSTALLED_FILES') % def_setup_call

        script_options = [
            ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
            ('build', 'build_script', def_build),
            ('install', 'install_script', install_cmd),
            ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
            ('verifyscript', 'verify_script', None),
            ('pre', 'pre_install', None),
            ('post', 'post_install', None),
            ('preun', 'pre_uninstall', None),
            ('postun', 'post_uninstall', None),
        ]

        for (rpm_opt, attr, default) in script_options:
            # Insert contents of file referred to, if no file is referred to
            # use 'default' as contents of script
            val = getattr(self, attr)
            if val or default:
                spec_file.extend([
                    '',
                    '%' + rpm_opt,])
                if val:
                    with open(val) as f:
                        spec_file.extend(f.read().split('\n'))
                else:
                    spec_file.append(default)


        # files section
        spec_file.extend([
            '',
            '%files -f INSTALLED_FILES',
            '%defattr(-,root,root)',
            ])

        if self.doc_files:
            spec_file.append('%doc ' + ' '.join(self.doc_files))

        if self.changelog:
            spec_file.extend([
                '',
                '%changelog',])
            spec_file.extend(self.changelog)

        return spec_file

    def _format_changelog(self, changelog):
        """Format the changelog correctly and convert it to a list of strings
        """
        if not changelog:
            return changelog
        new_changelog = []
        for line in changelog.strip().split('\n'):
            line = line.strip()
            if line[0] == '*':
                new_changelog.extend(['', line])
            elif line[0] == '-':
                new_changelog.append(line)
            else:
                new_changelog.append('  ' + line)

        # strip trailing newline inserted by first changelog entry
        if not new_changelog[0]:
            del new_changelog[0]

        return new_changelog
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/bdist_wininst.py0000644000175100001710000003723600000000000024663 0ustar00runnerdocker"""distutils.command.bdist_wininst

Implements the Distutils 'bdist_wininst' command: create a windows installer
exe-program."""

import os
import sys
import warnings
from distutils.core import Command
from distutils.util import get_platform
from distutils.dir_util import remove_tree
from distutils.errors import *
from distutils.sysconfig import get_python_version
from distutils import log

class bdist_wininst(Command):

    description = "create an executable installer for MS Windows"

    user_options = [('bdist-dir=', None,
                     "temporary directory for creating the distribution"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('keep-temp', 'k',
                     "keep the pseudo-installation tree around after " +
                     "creating the distribution archive"),
                    ('target-version=', None,
                     "require a specific python version" +
                     " on the target system"),
                    ('no-target-compile', 'c',
                     "do not compile .py to .pyc on the target system"),
                    ('no-target-optimize', 'o',
                     "do not compile .py to .pyo (optimized) "
                     "on the target system"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in"),
                    ('bitmap=', 'b',
                     "bitmap to use for the installer instead of python-powered logo"),
                    ('title=', 't',
                     "title to display on the installer background instead of default"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('install-script=', None,
                     "basename of installation script to be run after "
                     "installation or before deinstallation"),
                    ('pre-install-script=', None,
                     "Fully qualified filename of a script to be run before "
                     "any files are installed.  This script need not be in the "
                     "distribution"),
                    ('user-access-control=', None,
                     "specify Vista's UAC handling - 'none'/default=no "
                     "handling, 'auto'=use UAC if target Python installed for "
                     "all users, 'force'=always use UAC"),
                   ]

    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
                       'skip-build']

    # bpo-10945: bdist_wininst requires mbcs encoding only available on Windows
    _unsupported = (sys.platform != "win32")

    def __init__(self, *args, **kw):
        super().__init__(*args, **kw)
        warnings.warn("bdist_wininst command is deprecated since Python 3.8, "
                      "use bdist_wheel (wheel packages) instead",
                      DeprecationWarning, 2)

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.no_target_compile = 0
        self.no_target_optimize = 0
        self.target_version = None
        self.dist_dir = None
        self.bitmap = None
        self.title = None
        self.skip_build = None
        self.install_script = None
        self.pre_install_script = None
        self.user_access_control = None


    def finalize_options(self):
        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))

        if self.bdist_dir is None:
            if self.skip_build and self.plat_name:
                # If build is skipped and plat_name is overridden, bdist will
                # not see the correct 'plat_name' - so set that up manually.
                bdist = self.distribution.get_command_obj('bdist')
                bdist.plat_name = self.plat_name
                # next the command will be initialized using that name
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'wininst')

        if not self.target_version:
            self.target_version = ""

        if not self.skip_build and self.distribution.has_ext_modules():
            short_version = get_python_version()
            if self.target_version and self.target_version != short_version:
                raise DistutilsOptionError(
                      "target version can only be %s, or the '--skip-build'" \
                      " option must be specified" % (short_version,))
            self.target_version = short_version

        self.set_undefined_options('bdist',
                                   ('dist_dir', 'dist_dir'),
                                   ('plat_name', 'plat_name'),
                                  )

        if self.install_script:
            for script in self.distribution.scripts:
                if self.install_script == os.path.basename(script):
                    break
            else:
                raise DistutilsOptionError(
                      "install_script '%s' not found in scripts"
                      % self.install_script)

    def run(self):
        if (sys.platform != "win32" and
            (self.distribution.has_ext_modules() or
             self.distribution.has_c_libraries())):
            raise DistutilsPlatformError \
                  ("distribution contains extensions and/or C libraries; "
                   "must be compiled on a Windows 32 platform")

        if not self.skip_build:
            self.run_command('build')

        install = self.reinitialize_command('install', reinit_subcommands=1)
        install.root = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0
        install.plat_name = self.plat_name

        install_lib = self.reinitialize_command('install_lib')
        # we do not want to include pyc or pyo files
        install_lib.compile = 0
        install_lib.optimize = 0

        if self.distribution.has_ext_modules():
            # If we are building an installer for a Python version other
            # than the one we are currently running, then we need to ensure
            # our build_lib reflects the other Python version rather than ours.
            # Note that for target_version!=sys.version, we must have skipped the
            # build step, so there is no issue with enforcing the build of this
            # version.
            target_version = self.target_version
            if not target_version:
                assert self.skip_build, "Should have already checked this"
                target_version = '%d.%d' % sys.version_info[:2]
            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
            build = self.get_finalized_command('build')
            build.build_lib = os.path.join(build.build_base,
                                           'lib' + plat_specifier)

        # Use a custom scheme for the zip-file, because we have to decide
        # at installation time which scheme to use.
        for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
            value = key.upper()
            if key == 'headers':
                value = value + '/Include/$dist_name'
            setattr(install,
                    'install_' + key,
                    value)

        log.info("installing to %s", self.bdist_dir)
        install.ensure_finalized()

        # avoid warning of 'install_lib' about installing
        # into a directory not in sys.path
        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))

        install.run()

        del sys.path[0]

        # And make an archive relative to the root of the
        # pseudo-installation tree.
        from tempfile import mktemp
        archive_basename = mktemp()
        fullname = self.distribution.get_fullname()
        arcname = self.make_archive(archive_basename, "zip",
                                    root_dir=self.bdist_dir)
        # create an exe containing the zip-file
        self.create_exe(arcname, fullname, self.bitmap)
        if self.distribution.has_ext_modules():
            pyversion = get_python_version()
        else:
            pyversion = 'any'
        self.distribution.dist_files.append(('bdist_wininst', pyversion,
                                             self.get_installer_filename(fullname)))
        # remove the zip-file again
        log.debug("removing temporary file '%s'", arcname)
        os.remove(arcname)

        if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)

    def get_inidata(self):
        # Return data describing the installation.
        lines = []
        metadata = self.distribution.metadata

        # Write the [metadata] section.
        lines.append("[metadata]")

        # 'info' will be displayed in the installer's dialog box,
        # describing the items to be installed.
        info = (metadata.long_description or '') + '\n'

        # Escape newline characters
        def escape(s):
            return s.replace("\n", "\\n")

        for name in ["author", "author_email", "description", "maintainer",
                     "maintainer_email", "name", "url", "version"]:
            data = getattr(metadata, name, "")
            if data:
                info = info + ("\n    %s: %s" % \
                               (name.capitalize(), escape(data)))
                lines.append("%s=%s" % (name, escape(data)))

        # The [setup] section contains entries controlling
        # the installer runtime.
        lines.append("\n[Setup]")
        if self.install_script:
            lines.append("install_script=%s" % self.install_script)
        lines.append("info=%s" % escape(info))
        lines.append("target_compile=%d" % (not self.no_target_compile))
        lines.append("target_optimize=%d" % (not self.no_target_optimize))
        if self.target_version:
            lines.append("target_version=%s" % self.target_version)
        if self.user_access_control:
            lines.append("user_access_control=%s" % self.user_access_control)

        title = self.title or self.distribution.get_fullname()
        lines.append("title=%s" % escape(title))
        import time
        import distutils
        build_info = "Built %s with distutils-%s" % \
                     (time.ctime(time.time()), distutils.__version__)
        lines.append("build_info=%s" % build_info)
        return "\n".join(lines)

    def create_exe(self, arcname, fullname, bitmap=None):
        import struct

        self.mkpath(self.dist_dir)

        cfgdata = self.get_inidata()

        installer_name = self.get_installer_filename(fullname)
        self.announce("creating %s" % installer_name)

        if bitmap:
            with open(bitmap, "rb") as f:
                bitmapdata = f.read()
            bitmaplen = len(bitmapdata)
        else:
            bitmaplen = 0

        with open(installer_name, "wb") as file:
            file.write(self.get_exe_bytes())
            if bitmap:
                file.write(bitmapdata)

            # Convert cfgdata from unicode to ascii, mbcs encoded
            if isinstance(cfgdata, str):
                cfgdata = cfgdata.encode("mbcs")

            # Append the pre-install script
            cfgdata = cfgdata + b"\0"
            if self.pre_install_script:
                # We need to normalize newlines, so we open in text mode and
                # convert back to bytes. "latin-1" simply avoids any possible
                # failures.
                with open(self.pre_install_script, "r",
                          encoding="latin-1") as script:
                    script_data = script.read().encode("latin-1")
                cfgdata = cfgdata + script_data + b"\n\0"
            else:
                # empty pre-install script
                cfgdata = cfgdata + b"\0"
            file.write(cfgdata)

            # The 'magic number' 0x1234567B is used to make sure that the
            # binary layout of 'cfgdata' is what the wininst.exe binary
            # expects.  If the layout changes, increment that number, make
            # the corresponding changes to the wininst.exe sources, and
            # recompile them.
            header = struct.pack("' under the base build directory.  We only use one of
        # them for a given distribution, though --
        if self.build_purelib is None:
            self.build_purelib = os.path.join(self.build_base, 'lib')
        if self.build_platlib is None:
            self.build_platlib = os.path.join(self.build_base,
                                              'lib' + plat_specifier)

        # 'build_lib' is the actual directory that we will use for this
        # particular module distribution -- if user didn't supply it, pick
        # one of 'build_purelib' or 'build_platlib'.
        if self.build_lib is None:
            if self.distribution.has_ext_modules():
                self.build_lib = self.build_platlib
            else:
                self.build_lib = self.build_purelib

        # 'build_temp' -- temporary directory for compiler turds,
        # "build/temp."
        if self.build_temp is None:
            self.build_temp = os.path.join(self.build_base,
                                           'temp' + plat_specifier)
        if self.build_scripts is None:
            self.build_scripts = os.path.join(self.build_base,
                                              'scripts-%d.%d' % sys.version_info[:2])

        if self.executable is None and sys.executable:
            self.executable = os.path.normpath(sys.executable)

        if isinstance(self.parallel, str):
            try:
                self.parallel = int(self.parallel)
            except ValueError:
                raise DistutilsOptionError("parallel should be an integer")

    def run(self):
        # Run all relevant sub-commands.  This will be some subset of:
        #  - build_py      - pure Python modules
        #  - build_clib    - standalone C libraries
        #  - build_ext     - Python extensions
        #  - build_scripts - (Python) scripts
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)


    # -- Predicates for the sub-command list ---------------------------

    def has_pure_modules(self):
        return self.distribution.has_pure_modules()

    def has_c_libraries(self):
        return self.distribution.has_c_libraries()

    def has_ext_modules(self):
        return self.distribution.has_ext_modules()

    def has_scripts(self):
        return self.distribution.has_scripts()


    sub_commands = [('build_py',      has_pure_modules),
                    ('build_clib',    has_c_libraries),
                    ('build_ext',     has_ext_modules),
                    ('build_scripts', has_scripts),
                   ]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/build_clib.py0000644000175100001710000001752600000000000024073 0ustar00runnerdocker"""distutils.command.build_clib

Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module."""


# XXX this module has *lots* of code ripped-off quite transparently from
# build_ext.py -- not surprisingly really, as the work required to build
# a static library from a collection of C source files is not really all
# that different from what's required to build a shared object file from
# a collection of C source files.  Nevertheless, I haven't done the
# necessary refactoring to account for the overlap in code between the
# two modules, mainly because a number of subtle details changed in the
# cut 'n paste.  Sigh.

import os
from distutils.core import Command
from distutils.errors import *
from distutils.sysconfig import customize_compiler
from distutils import log

def show_compilers():
    from distutils.ccompiler import show_compilers
    show_compilers()


class build_clib(Command):

    description = "build C/C++ libraries used by Python extensions"

    user_options = [
        ('build-clib=', 'b',
         "directory to build C/C++ libraries to"),
        ('build-temp=', 't',
         "directory to put temporary build by-products"),
        ('debug', 'g',
         "compile with debugging information"),
        ('force', 'f',
         "forcibly build everything (ignore file timestamps)"),
        ('compiler=', 'c',
         "specify the compiler type"),
        ]

    boolean_options = ['debug', 'force']

    help_options = [
        ('help-compiler', None,
         "list available compilers", show_compilers),
        ]

    def initialize_options(self):
        self.build_clib = None
        self.build_temp = None

        # List of libraries to build
        self.libraries = None

        # Compilation options for all libraries
        self.include_dirs = None
        self.define = None
        self.undef = None
        self.debug = None
        self.force = 0
        self.compiler = None


    def finalize_options(self):
        # This might be confusing: both build-clib and build-temp default
        # to build-temp as defined by the "build" command.  This is because
        # I think that C libraries are really just temporary build
        # by-products, at least from the point of view of building Python
        # extensions -- but I want to keep my options open.
        self.set_undefined_options('build',
                                   ('build_temp', 'build_clib'),
                                   ('build_temp', 'build_temp'),
                                   ('compiler', 'compiler'),
                                   ('debug', 'debug'),
                                   ('force', 'force'))

        self.libraries = self.distribution.libraries
        if self.libraries:
            self.check_library_list(self.libraries)

        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        if isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

        # XXX same as for build_ext -- what about 'self.define' and
        # 'self.undef' ?


    def run(self):
        if not self.libraries:
            return

        # Yech -- this is cut 'n pasted from build_ext.py!
        from distutils.ccompiler import new_compiler
        self.compiler = new_compiler(compiler=self.compiler,
                                     dry_run=self.dry_run,
                                     force=self.force)
        customize_compiler(self.compiler)

        if self.include_dirs is not None:
            self.compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for (name,value) in self.define:
                self.compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                self.compiler.undefine_macro(macro)

        self.build_libraries(self.libraries)


    def check_library_list(self, libraries):
        """Ensure that the list of libraries is valid.

        `library` is presumably provided as a command option 'libraries'.
        This method checks that it is a list of 2-tuples, where the tuples
        are (library_name, build_info_dict).

        Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        """
        if not isinstance(libraries, list):
            raise DistutilsSetupError(
                  "'libraries' option must be a list of tuples")

        for lib in libraries:
            if not isinstance(lib, tuple) and len(lib) != 2:
                raise DistutilsSetupError(
                      "each element of 'libraries' must a 2-tuple")

            name, build_info = lib

            if not isinstance(name, str):
                raise DistutilsSetupError(
                      "first element of each tuple in 'libraries' "
                      "must be a string (the library name)")

            if '/' in name or (os.sep != '/' and os.sep in name):
                raise DistutilsSetupError("bad library name '%s': "
                       "may not contain directory separators" % lib[0])

            if not isinstance(build_info, dict):
                raise DistutilsSetupError(
                      "second element of each tuple in 'libraries' "
                      "must be a dictionary (build info)")


    def get_library_names(self):
        # Assume the library list is valid -- 'check_library_list()' is
        # called from 'finalize_options()', so it should be!
        if not self.libraries:
            return None

        lib_names = []
        for (lib_name, build_info) in self.libraries:
            lib_names.append(lib_name)
        return lib_names


    def get_source_files(self):
        self.check_library_list(self.libraries)
        filenames = []
        for (lib_name, build_info) in self.libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError(
                       "in 'libraries' option (library '%s'), "
                       "'sources' must be present and must be "
                       "a list of source filenames" % lib_name)

            filenames.extend(sources)
        return filenames


    def build_libraries(self, libraries):
        for (lib_name, build_info) in libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError(
                       "in 'libraries' option (library '%s'), "
                       "'sources' must be present and must be "
                       "a list of source filenames" % lib_name)
            sources = list(sources)

            log.info("building '%s' library", lib_name)

            # First, compile the source code to object files in the library
            # directory.  (This should probably change to putting object
            # files in a temporary build directory.)
            macros = build_info.get('macros')
            include_dirs = build_info.get('include_dirs')
            objects = self.compiler.compile(sources,
                                            output_dir=self.build_temp,
                                            macros=macros,
                                            include_dirs=include_dirs,
                                            debug=self.debug)

            # Now "link" the object files together into a static library.
            # (On Unix at least, this isn't really linking -- it just
            # builds an archive.  Whatever.)
            self.compiler.create_static_lib(objects, lib_name,
                                            output_dir=self.build_clib,
                                            debug=self.debug)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/build_ext.py0000644000175100001710000007557400000000000023771 0ustar00runnerdocker"""distutils.command.build_ext

Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP)."""

import contextlib
import os
import re
import sys
from distutils.core import Command
from distutils.errors import *
from distutils.sysconfig import customize_compiler, get_python_version
from distutils.sysconfig import get_config_h_filename
from distutils.dep_util import newer_group
from distutils.extension import Extension
from distutils.util import get_platform
from distutils import log
from . import py37compat

from site import USER_BASE

# An extension name is just a dot-separated list of Python NAMEs (ie.
# the same as a fully-qualified module name).
extension_name_re = re.compile \
    (r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')


def show_compilers ():
    from distutils.ccompiler import show_compilers
    show_compilers()


class build_ext(Command):

    description = "build C/C++ extensions (compile/link to build directory)"

    # XXX thoughts on how to deal with complex command-line options like
    # these, i.e. how to make it so fancy_getopt can suck them off the
    # command line and make it look like setup.py defined the appropriate
    # lists of tuples of what-have-you.
    #   - each command needs a callback to process its command-line options
    #   - Command.__init__() needs access to its share of the whole
    #     command line (must ultimately come from
    #     Distribution.parse_command_line())
    #   - it then calls the current command class' option-parsing
    #     callback to deal with weird options like -D, which have to
    #     parse the option text and churn out some custom data
    #     structure
    #   - that data structure (in this case, a list of 2-tuples)
    #     will then be present in the command object by the time
    #     we get to finalize_options() (i.e. the constructor
    #     takes care of both command-line and client options
    #     in between initialize_options() and finalize_options())

    sep_by = " (separated by '%s')" % os.pathsep
    user_options = [
        ('build-lib=', 'b',
         "directory for compiled extension modules"),
        ('build-temp=', 't',
         "directory for temporary files (build by-products)"),
        ('plat-name=', 'p',
         "platform name to cross-compile for, if supported "
         "(default: %s)" % get_platform()),
        ('inplace', 'i',
         "ignore build-lib and put compiled extensions into the source " +
         "directory alongside your pure Python modules"),
        ('include-dirs=', 'I',
         "list of directories to search for header files" + sep_by),
        ('define=', 'D',
         "C preprocessor macros to define"),
        ('undef=', 'U',
         "C preprocessor macros to undefine"),
        ('libraries=', 'l',
         "external C libraries to link with"),
        ('library-dirs=', 'L',
         "directories to search for external C libraries" + sep_by),
        ('rpath=', 'R',
         "directories to search for shared C libraries at runtime"),
        ('link-objects=', 'O',
         "extra explicit link objects to include in the link"),
        ('debug', 'g',
         "compile/link with debugging information"),
        ('force', 'f',
         "forcibly build everything (ignore file timestamps)"),
        ('compiler=', 'c',
         "specify the compiler type"),
        ('parallel=', 'j',
         "number of parallel build jobs"),
        ('swig-cpp', None,
         "make SWIG create C++ files (default is C)"),
        ('swig-opts=', None,
         "list of SWIG command line options"),
        ('swig=', None,
         "path to the SWIG executable"),
        ('user', None,
         "add user include, library and rpath")
        ]

    boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']

    help_options = [
        ('help-compiler', None,
         "list available compilers", show_compilers),
        ]

    def initialize_options(self):
        self.extensions = None
        self.build_lib = None
        self.plat_name = None
        self.build_temp = None
        self.inplace = 0
        self.package = None

        self.include_dirs = None
        self.define = None
        self.undef = None
        self.libraries = None
        self.library_dirs = None
        self.rpath = None
        self.link_objects = None
        self.debug = None
        self.force = None
        self.compiler = None
        self.swig = None
        self.swig_cpp = None
        self.swig_opts = None
        self.user = None
        self.parallel = None

    def finalize_options(self):
        from distutils import sysconfig

        self.set_undefined_options('build',
                                   ('build_lib', 'build_lib'),
                                   ('build_temp', 'build_temp'),
                                   ('compiler', 'compiler'),
                                   ('debug', 'debug'),
                                   ('force', 'force'),
                                   ('parallel', 'parallel'),
                                   ('plat_name', 'plat_name'),
                                   )

        if self.package is None:
            self.package = self.distribution.ext_package

        self.extensions = self.distribution.ext_modules

        # Make sure Python's include directories (for Python.h, pyconfig.h,
        # etc.) are in the include search path.
        py_include = sysconfig.get_python_inc()
        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        if isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

        # If in a virtualenv, add its include directory
        # Issue 16116
        if sys.exec_prefix != sys.base_exec_prefix:
            self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))

        # Put the Python "system" include dir at the end, so that
        # any local include dirs take precedence.
        self.include_dirs.extend(py_include.split(os.path.pathsep))
        if plat_py_include != py_include:
            self.include_dirs.extend(
                plat_py_include.split(os.path.pathsep))

        self.ensure_string_list('libraries')
        self.ensure_string_list('link_objects')

        # Life is easier if we're not forever checking for None, so
        # simplify these options to empty lists if unset
        if self.libraries is None:
            self.libraries = []
        if self.library_dirs is None:
            self.library_dirs = []
        elif isinstance(self.library_dirs, str):
            self.library_dirs = self.library_dirs.split(os.pathsep)

        if self.rpath is None:
            self.rpath = []
        elif isinstance(self.rpath, str):
            self.rpath = self.rpath.split(os.pathsep)

        # for extensions under windows use different directories
        # for Release and Debug builds.
        # also Python's library directory must be appended to library_dirs
        if os.name == 'nt':
            # the 'libs' directory is for binary installs - we assume that
            # must be the *native* platform.  But we don't really support
            # cross-compiling via a binary install anyway, so we let it go.
            self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
            if sys.base_exec_prefix != sys.prefix:  # Issue 16116
                self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs'))
            if self.debug:
                self.build_temp = os.path.join(self.build_temp, "Debug")
            else:
                self.build_temp = os.path.join(self.build_temp, "Release")

            # Append the source distribution include and library directories,
            # this allows distutils on windows to work in the source tree
            self.include_dirs.append(os.path.dirname(get_config_h_filename()))
            self.library_dirs.append(sys.base_exec_prefix)

            # Use the .lib files for the correct architecture
            if self.plat_name == 'win32':
                suffix = 'win32'
            else:
                # win-amd64
                suffix = self.plat_name[4:]
            new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
            if suffix:
                new_lib = os.path.join(new_lib, suffix)
            self.library_dirs.append(new_lib)

        # For extensions under Cygwin, Python's library directory must be
        # appended to library_dirs
        if sys.platform[:6] == 'cygwin':
            if not sysconfig.python_build:
                # building third party extensions
                self.library_dirs.append(os.path.join(sys.prefix, "lib",
                                                      "python" + get_python_version(),
                                                      "config"))
            else:
                # building python standard extensions
                self.library_dirs.append('.')

        # For building extensions with a shared Python library,
        # Python's library directory must be appended to library_dirs
        # See Issues: #1600860, #4366
        if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
            if not sysconfig.python_build:
                # building third party extensions
                self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
            else:
                # building python standard extensions
                self.library_dirs.append('.')

        # The argument parsing will result in self.define being a string, but
        # it has to be a list of 2-tuples.  All the preprocessor symbols
        # specified by the 'define' option will be set to '1'.  Multiple
        # symbols can be separated with commas.

        if self.define:
            defines = self.define.split(',')
            self.define = [(symbol, '1') for symbol in defines]

        # The option for macros to undefine is also a string from the
        # option parsing, but has to be a list.  Multiple symbols can also
        # be separated with commas here.
        if self.undef:
            self.undef = self.undef.split(',')

        if self.swig_opts is None:
            self.swig_opts = []
        else:
            self.swig_opts = self.swig_opts.split(' ')

        # Finally add the user include and library directories if requested
        if self.user:
            user_include = os.path.join(USER_BASE, "include")
            user_lib = os.path.join(USER_BASE, "lib")
            if os.path.isdir(user_include):
                self.include_dirs.append(user_include)
            if os.path.isdir(user_lib):
                self.library_dirs.append(user_lib)
                self.rpath.append(user_lib)

        if isinstance(self.parallel, str):
            try:
                self.parallel = int(self.parallel)
            except ValueError:
                raise DistutilsOptionError("parallel should be an integer")

    def run(self):
        from distutils.ccompiler import new_compiler

        # 'self.extensions', as supplied by setup.py, is a list of
        # Extension instances.  See the documentation for Extension (in
        # distutils.extension) for details.
        #
        # For backwards compatibility with Distutils 0.8.2 and earlier, we
        # also allow the 'extensions' list to be a list of tuples:
        #    (ext_name, build_info)
        # where build_info is a dictionary containing everything that
        # Extension instances do except the name, with a few things being
        # differently named.  We convert these 2-tuples to Extension
        # instances as needed.

        if not self.extensions:
            return

        # If we were asked to build any C/C++ libraries, make sure that the
        # directory where we put them is in the library search path for
        # linking extensions.
        if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command('build_clib')
            self.libraries.extend(build_clib.get_library_names() or [])
            self.library_dirs.append(build_clib.build_clib)

        # Setup the CCompiler object that we'll use to do all the
        # compiling and linking
        self.compiler = new_compiler(compiler=self.compiler,
                                     verbose=self.verbose,
                                     dry_run=self.dry_run,
                                     force=self.force)
        customize_compiler(self.compiler)
        # If we are cross-compiling, init the compiler now (if we are not
        # cross-compiling, init would not hurt, but people may rely on
        # late initialization of compiler even if they shouldn't...)
        if os.name == 'nt' and self.plat_name != get_platform():
            self.compiler.initialize(self.plat_name)

        # And make sure that any compile/link-related options (which might
        # come from the command-line or from the setup script) are set in
        # that CCompiler object -- that way, they automatically apply to
        # all compiling and linking done here.
        if self.include_dirs is not None:
            self.compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for (name, value) in self.define:
                self.compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                self.compiler.undefine_macro(macro)
        if self.libraries is not None:
            self.compiler.set_libraries(self.libraries)
        if self.library_dirs is not None:
            self.compiler.set_library_dirs(self.library_dirs)
        if self.rpath is not None:
            self.compiler.set_runtime_library_dirs(self.rpath)
        if self.link_objects is not None:
            self.compiler.set_link_objects(self.link_objects)

        # Now actually compile and link everything.
        self.build_extensions()

    def check_extensions_list(self, extensions):
        """Ensure that the list of extensions (presumably provided as a
        command option 'extensions') is valid, i.e. it is a list of
        Extension objects.  We also support the old-style list of 2-tuples,
        where the tuples are (ext_name, build_info), which are converted to
        Extension instances here.

        Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        """
        if not isinstance(extensions, list):
            raise DistutilsSetupError(
                  "'ext_modules' option must be a list of Extension instances")

        for i, ext in enumerate(extensions):
            if isinstance(ext, Extension):
                continue                # OK! (assume type-checking done
                                        # by Extension constructor)

            if not isinstance(ext, tuple) or len(ext) != 2:
                raise DistutilsSetupError(
                       "each element of 'ext_modules' option must be an "
                       "Extension instance or 2-tuple")

            ext_name, build_info = ext

            log.warn("old-style (ext_name, build_info) tuple found in "
                     "ext_modules for extension '%s' "
                     "-- please convert to Extension instance", ext_name)

            if not (isinstance(ext_name, str) and
                    extension_name_re.match(ext_name)):
                raise DistutilsSetupError(
                       "first element of each tuple in 'ext_modules' "
                       "must be the extension name (a string)")

            if not isinstance(build_info, dict):
                raise DistutilsSetupError(
                       "second element of each tuple in 'ext_modules' "
                       "must be a dictionary (build info)")

            # OK, the (ext_name, build_info) dict is type-safe: convert it
            # to an Extension instance.
            ext = Extension(ext_name, build_info['sources'])

            # Easy stuff: one-to-one mapping from dict elements to
            # instance attributes.
            for key in ('include_dirs', 'library_dirs', 'libraries',
                        'extra_objects', 'extra_compile_args',
                        'extra_link_args'):
                val = build_info.get(key)
                if val is not None:
                    setattr(ext, key, val)

            # Medium-easy stuff: same syntax/semantics, different names.
            ext.runtime_library_dirs = build_info.get('rpath')
            if 'def_file' in build_info:
                log.warn("'def_file' element of build info dict "
                         "no longer supported")

            # Non-trivial stuff: 'macros' split into 'define_macros'
            # and 'undef_macros'.
            macros = build_info.get('macros')
            if macros:
                ext.define_macros = []
                ext.undef_macros = []
                for macro in macros:
                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
                        raise DistutilsSetupError(
                              "'macros' element of build info dict "
                              "must be 1- or 2-tuple")
                    if len(macro) == 1:
                        ext.undef_macros.append(macro[0])
                    elif len(macro) == 2:
                        ext.define_macros.append(macro)

            extensions[i] = ext

    def get_source_files(self):
        self.check_extensions_list(self.extensions)
        filenames = []

        # Wouldn't it be neat if we knew the names of header files too...
        for ext in self.extensions:
            filenames.extend(ext.sources)
        return filenames

    def get_outputs(self):
        # Sanity check the 'extensions' list -- can't assume this is being
        # done in the same run as a 'build_extensions()' call (in fact, we
        # can probably assume that it *isn't*!).
        self.check_extensions_list(self.extensions)

        # And build the list of output (built) filenames.  Note that this
        # ignores the 'inplace' flag, and assumes everything goes in the
        # "build" tree.
        outputs = []
        for ext in self.extensions:
            outputs.append(self.get_ext_fullpath(ext.name))
        return outputs

    def build_extensions(self):
        # First, sanity-check the 'extensions' list
        self.check_extensions_list(self.extensions)
        if self.parallel:
            self._build_extensions_parallel()
        else:
            self._build_extensions_serial()

    def _build_extensions_parallel(self):
        workers = self.parallel
        if self.parallel is True:
            workers = os.cpu_count()  # may return None
        try:
            from concurrent.futures import ThreadPoolExecutor
        except ImportError:
            workers = None

        if workers is None:
            self._build_extensions_serial()
            return

        with ThreadPoolExecutor(max_workers=workers) as executor:
            futures = [executor.submit(self.build_extension, ext)
                       for ext in self.extensions]
            for ext, fut in zip(self.extensions, futures):
                with self._filter_build_errors(ext):
                    fut.result()

    def _build_extensions_serial(self):
        for ext in self.extensions:
            with self._filter_build_errors(ext):
                self.build_extension(ext)

    @contextlib.contextmanager
    def _filter_build_errors(self, ext):
        try:
            yield
        except (CCompilerError, DistutilsError, CompileError) as e:
            if not ext.optional:
                raise
            self.warn('building extension "%s" failed: %s' %
                      (ext.name, e))

    def build_extension(self, ext):
        sources = ext.sources
        if sources is None or not isinstance(sources, (list, tuple)):
            raise DistutilsSetupError(
                  "in 'ext_modules' option (extension '%s'), "
                  "'sources' must be present and must be "
                  "a list of source filenames" % ext.name)
        # sort to make the resulting .so file build reproducible
        sources = sorted(sources)

        ext_path = self.get_ext_fullpath(ext.name)
        depends = sources + ext.depends
        if not (self.force or newer_group(depends, ext_path, 'newer')):
            log.debug("skipping '%s' extension (up-to-date)", ext.name)
            return
        else:
            log.info("building '%s' extension", ext.name)

        # First, scan the sources for SWIG definition files (.i), run
        # SWIG on 'em to create .c files, and modify the sources list
        # accordingly.
        sources = self.swig_sources(sources, ext)

        # Next, compile the source code to object files.

        # XXX not honouring 'define_macros' or 'undef_macros' -- the
        # CCompiler API needs to change to accommodate this, and I
        # want to do one thing at a time!

        # Two possible sources for extra compiler arguments:
        #   - 'extra_compile_args' in Extension object
        #   - CFLAGS environment variable (not particularly
        #     elegant, but people seem to expect it and I
        #     guess it's useful)
        # The environment variable should take precedence, and
        # any sensible compiler will give precedence to later
        # command line args.  Hence we combine them in order:
        extra_args = ext.extra_compile_args or []

        macros = ext.define_macros[:]
        for undef in ext.undef_macros:
            macros.append((undef,))

        objects = self.compiler.compile(sources,
                                         output_dir=self.build_temp,
                                         macros=macros,
                                         include_dirs=ext.include_dirs,
                                         debug=self.debug,
                                         extra_postargs=extra_args,
                                         depends=ext.depends)

        # XXX outdated variable, kept here in case third-part code
        # needs it.
        self._built_objects = objects[:]

        # Now link the object files together into a "shared object" --
        # of course, first we have to figure out all the other things
        # that go into the mix.
        if ext.extra_objects:
            objects.extend(ext.extra_objects)
        extra_args = ext.extra_link_args or []

        # Detect target language, if not provided
        language = ext.language or self.compiler.detect_language(sources)

        self.compiler.link_shared_object(
            objects, ext_path,
            libraries=self.get_libraries(ext),
            library_dirs=ext.library_dirs,
            runtime_library_dirs=ext.runtime_library_dirs,
            extra_postargs=extra_args,
            export_symbols=self.get_export_symbols(ext),
            debug=self.debug,
            build_temp=self.build_temp,
            target_lang=language)

    def swig_sources(self, sources, extension):
        """Walk the list of source files in 'sources', looking for SWIG
        interface (.i) files.  Run SWIG on all that are found, and
        return a modified 'sources' list with SWIG source files replaced
        by the generated C (or C++) files.
        """
        new_sources = []
        swig_sources = []
        swig_targets = {}

        # XXX this drops generated C/C++ files into the source tree, which
        # is fine for developers who want to distribute the generated
        # source -- but there should be an option to put SWIG output in
        # the temp dir.

        if self.swig_cpp:
            log.warn("--swig-cpp is deprecated - use --swig-opts=-c++")

        if self.swig_cpp or ('-c++' in self.swig_opts) or \
           ('-c++' in extension.swig_opts):
            target_ext = '.cpp'
        else:
            target_ext = '.c'

        for source in sources:
            (base, ext) = os.path.splitext(source)
            if ext == ".i":             # SWIG interface file
                new_sources.append(base + '_wrap' + target_ext)
                swig_sources.append(source)
                swig_targets[source] = new_sources[-1]
            else:
                new_sources.append(source)

        if not swig_sources:
            return new_sources

        swig = self.swig or self.find_swig()
        swig_cmd = [swig, "-python"]
        swig_cmd.extend(self.swig_opts)
        if self.swig_cpp:
            swig_cmd.append("-c++")

        # Do not override commandline arguments
        if not self.swig_opts:
            for o in extension.swig_opts:
                swig_cmd.append(o)

        for source in swig_sources:
            target = swig_targets[source]
            log.info("swigging %s to %s", source, target)
            self.spawn(swig_cmd + ["-o", target, source])

        return new_sources

    def find_swig(self):
        """Return the name of the SWIG executable.  On Unix, this is
        just "swig" -- it should be in the PATH.  Tries a bit harder on
        Windows.
        """
        if os.name == "posix":
            return "swig"
        elif os.name == "nt":
            # Look for SWIG in its standard installation directory on
            # Windows (or so I presume!).  If we find it there, great;
            # if not, act like Unix and assume it's in the PATH.
            for vers in ("1.3", "1.2", "1.1"):
                fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
                if os.path.isfile(fn):
                    return fn
            else:
                return "swig.exe"
        else:
            raise DistutilsPlatformError(
                  "I don't know how to find (much less run) SWIG "
                  "on platform '%s'" % os.name)

    # -- Name generators -----------------------------------------------
    # (extension names, filenames, whatever)
    def get_ext_fullpath(self, ext_name):
        """Returns the path of the filename for a given extension.

        The file is located in `build_lib` or directly in the package
        (inplace option).
        """
        fullname = self.get_ext_fullname(ext_name)
        modpath = fullname.split('.')
        filename = self.get_ext_filename(modpath[-1])

        if not self.inplace:
            # no further work needed
            # returning :
            #   build_dir/package/path/filename
            filename = os.path.join(*modpath[:-1]+[filename])
            return os.path.join(self.build_lib, filename)

        # the inplace option requires to find the package directory
        # using the build_py command for that
        package = '.'.join(modpath[0:-1])
        build_py = self.get_finalized_command('build_py')
        package_dir = os.path.abspath(build_py.get_package_dir(package))

        # returning
        #   package_dir/filename
        return os.path.join(package_dir, filename)

    def get_ext_fullname(self, ext_name):
        """Returns the fullname of a given extension name.

        Adds the `package.` prefix"""
        if self.package is None:
            return ext_name
        else:
            return self.package + '.' + ext_name

    def get_ext_filename(self, ext_name):
        r"""Convert the name of an extension (eg. "foo.bar") into the name
        of the file from which it will be loaded (eg. "foo/bar.so", or
        "foo\bar.pyd").
        """
        from distutils.sysconfig import get_config_var
        ext_path = ext_name.split('.')
        ext_suffix = get_config_var('EXT_SUFFIX')
        return os.path.join(*ext_path) + ext_suffix

    def get_export_symbols(self, ext):
        """Return the list of symbols that a shared extension has to
        export.  This either uses 'ext.export_symbols' or, if it's not
        provided, "PyInit_" + module_name.  Only relevant on Windows, where
        the .pyd file (DLL) must export the module "PyInit_" function.
        """
        name = ext.name.split('.')[-1]
        try:
            # Unicode module name support as defined in PEP-489
            # https://www.python.org/dev/peps/pep-0489/#export-hook-name
            name.encode('ascii')
        except UnicodeEncodeError:
            suffix = 'U_' + name.encode('punycode').replace(b'-', b'_').decode('ascii')
        else:
            suffix = "_" + name

        initfunc_name = "PyInit" + suffix
        if initfunc_name not in ext.export_symbols:
            ext.export_symbols.append(initfunc_name)
        return ext.export_symbols

    def get_libraries(self, ext):
        """Return the list of libraries to link against when building a
        shared extension.  On most platforms, this is just 'ext.libraries';
        on Windows, we add the Python library (eg. python20.dll).
        """
        # The python library is always needed on Windows.  For MSVC, this
        # is redundant, since the library is mentioned in a pragma in
        # pyconfig.h that MSVC groks.  The other Windows compilers all seem
        # to need it mentioned explicitly, though, so that's what we do.
        # Append '_d' to the python import library on debug builds.
        if sys.platform == "win32":
            from distutils._msvccompiler import MSVCCompiler
            if not isinstance(self.compiler, MSVCCompiler):
                template = "python%d%d"
                if self.debug:
                    template = template + '_d'
                pythonlib = (template %
                       (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
                # don't extend ext.libraries, it may be shared with other
                # extensions, it is a reference to the original list
                return ext.libraries + [pythonlib]
        else:
            # On Android only the main executable and LD_PRELOADs are considered
            # to be RTLD_GLOBAL, all the dependencies of the main executable
            # remain RTLD_LOCAL and so the shared libraries must be linked with
            # libpython when python is built with a shared python library (issue
            # bpo-21536).
            # On Cygwin (and if required, other POSIX-like platforms based on
            # Windows like MinGW) it is simply necessary that all symbols in
            # shared libraries are resolved at link time.
            from distutils.sysconfig import get_config_var
            link_libpython = False
            if get_config_var('Py_ENABLE_SHARED'):
                # A native build on an Android device or on Cygwin
                if hasattr(sys, 'getandroidapilevel'):
                    link_libpython = True
                elif sys.platform == 'cygwin':
                    link_libpython = True
                elif '_PYTHON_HOST_PLATFORM' in os.environ:
                    # We are cross-compiling for one of the relevant platforms
                    if get_config_var('ANDROID_API_LEVEL') != 0:
                        link_libpython = True
                    elif get_config_var('MACHDEP') == 'cygwin':
                        link_libpython = True

            if link_libpython:
                ldversion = get_config_var('LDVERSION')
                return ext.libraries + ['python' + ldversion]

        return ext.libraries + py37compat.pythonlib()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/build_py.py0000644000175100001710000004015700000000000023606 0ustar00runnerdocker"""distutils.command.build_py

Implements the Distutils 'build_py' command."""

import os
import importlib.util
import sys
import glob

from distutils.core import Command
from distutils.errors import *
from distutils.util import convert_path
from distutils import log

class build_py (Command):

    description = "\"build\" pure Python modules (copy to build directory)"

    user_options = [
        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
        ('compile', 'c', "compile .py to .pyc"),
        ('no-compile', None, "don't compile .py files [default]"),
        ('optimize=', 'O',
         "also compile with optimization: -O1 for \"python -O\", "
         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
        ]

    boolean_options = ['compile', 'force']
    negative_opt = {'no-compile' : 'compile'}

    def initialize_options(self):
        self.build_lib = None
        self.py_modules = None
        self.package = None
        self.package_data = None
        self.package_dir = None
        self.compile = 0
        self.optimize = 0
        self.force = None

    def finalize_options(self):
        self.set_undefined_options('build',
                                   ('build_lib', 'build_lib'),
                                   ('force', 'force'))

        # Get the distribution options that are aliases for build_py
        # options -- list of packages and list of modules.
        self.packages = self.distribution.packages
        self.py_modules = self.distribution.py_modules
        self.package_data = self.distribution.package_data
        self.package_dir = {}
        if self.distribution.package_dir:
            for name, path in self.distribution.package_dir.items():
                self.package_dir[name] = convert_path(path)
        self.data_files = self.get_data_files()

        # Ick, copied straight from install_lib.py (fancy_getopt needs a
        # type system!  Hell, *everything* needs a type system!!!)
        if not isinstance(self.optimize, int):
            try:
                self.optimize = int(self.optimize)
                assert 0 <= self.optimize <= 2
            except (ValueError, AssertionError):
                raise DistutilsOptionError("optimize must be 0, 1, or 2")

    def run(self):
        # XXX copy_file by default preserves atime and mtime.  IMHO this is
        # the right thing to do, but perhaps it should be an option -- in
        # particular, a site administrator might want installed files to
        # reflect the time of installation rather than the last
        # modification time before the installed release.

        # XXX copy_file by default preserves mode, which appears to be the
        # wrong thing to do: if a file is read-only in the working
        # directory, we want it to be installed read/write so that the next
        # installation of the same module distribution can overwrite it
        # without problems.  (This might be a Unix-specific issue.)  Thus
        # we turn off 'preserve_mode' when copying to the build directory,
        # since the build directory is supposed to be exactly what the
        # installation will look like (ie. we preserve mode when
        # installing).

        # Two options control which modules will be installed: 'packages'
        # and 'py_modules'.  The former lets us work with whole packages, not
        # specifying individual modules at all; the latter is for
        # specifying modules one-at-a-time.

        if self.py_modules:
            self.build_modules()
        if self.packages:
            self.build_packages()
            self.build_package_data()

        self.byte_compile(self.get_outputs(include_bytecode=0))

    def get_data_files(self):
        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
        data = []
        if not self.packages:
            return data
        for package in self.packages:
            # Locate package source directory
            src_dir = self.get_package_dir(package)

            # Compute package build directory
            build_dir = os.path.join(*([self.build_lib] + package.split('.')))

            # Length of path to strip from found files
            plen = 0
            if src_dir:
                plen = len(src_dir)+1

            # Strip directory from globbed filenames
            filenames = [
                file[plen:] for file in self.find_data_files(package, src_dir)
                ]
            data.append((package, src_dir, build_dir, filenames))
        return data

    def find_data_files(self, package, src_dir):
        """Return filenames for package's data files in 'src_dir'"""
        globs = (self.package_data.get('', [])
                 + self.package_data.get(package, []))
        files = []
        for pattern in globs:
            # Each pattern has to be converted to a platform-specific path
            filelist = glob.glob(os.path.join(glob.escape(src_dir), convert_path(pattern)))
            # Files that match more than one pattern are only added once
            files.extend([fn for fn in filelist if fn not in files
                and os.path.isfile(fn)])
        return files

    def build_package_data(self):
        """Copy data files into build directory"""
        lastdir = None
        for package, src_dir, build_dir, filenames in self.data_files:
            for filename in filenames:
                target = os.path.join(build_dir, filename)
                self.mkpath(os.path.dirname(target))
                self.copy_file(os.path.join(src_dir, filename), target,
                               preserve_mode=False)

    def get_package_dir(self, package):
        """Return the directory, relative to the top of the source
           distribution, where package 'package' should be found
           (at least according to the 'package_dir' option, if any)."""
        path = package.split('.')

        if not self.package_dir:
            if path:
                return os.path.join(*path)
            else:
                return ''
        else:
            tail = []
            while path:
                try:
                    pdir = self.package_dir['.'.join(path)]
                except KeyError:
                    tail.insert(0, path[-1])
                    del path[-1]
                else:
                    tail.insert(0, pdir)
                    return os.path.join(*tail)
            else:
                # Oops, got all the way through 'path' without finding a
                # match in package_dir.  If package_dir defines a directory
                # for the root (nameless) package, then fallback on it;
                # otherwise, we might as well have not consulted
                # package_dir at all, as we just use the directory implied
                # by 'tail' (which should be the same as the original value
                # of 'path' at this point).
                pdir = self.package_dir.get('')
                if pdir is not None:
                    tail.insert(0, pdir)

                if tail:
                    return os.path.join(*tail)
                else:
                    return ''

    def check_package(self, package, package_dir):
        # Empty dir name means current directory, which we can probably
        # assume exists.  Also, os.path.exists and isdir don't know about
        # my "empty string means current dir" convention, so we have to
        # circumvent them.
        if package_dir != "":
            if not os.path.exists(package_dir):
                raise DistutilsFileError(
                      "package directory '%s' does not exist" % package_dir)
            if not os.path.isdir(package_dir):
                raise DistutilsFileError(
                       "supposed package directory '%s' exists, "
                       "but is not a directory" % package_dir)

        # Require __init__.py for all but the "root package"
        if package:
            init_py = os.path.join(package_dir, "__init__.py")
            if os.path.isfile(init_py):
                return init_py
            else:
                log.warn(("package init file '%s' not found " +
                          "(or not a regular file)"), init_py)

        # Either not in a package at all (__init__.py not expected), or
        # __init__.py doesn't exist -- so don't return the filename.
        return None

    def check_module(self, module, module_file):
        if not os.path.isfile(module_file):
            log.warn("file %s (for module %s) not found", module_file, module)
            return False
        else:
            return True

    def find_package_modules(self, package, package_dir):
        self.check_package(package, package_dir)
        module_files = glob.glob(os.path.join(glob.escape(package_dir), "*.py"))
        modules = []
        setup_script = os.path.abspath(self.distribution.script_name)

        for f in module_files:
            abs_f = os.path.abspath(f)
            if abs_f != setup_script:
                module = os.path.splitext(os.path.basename(f))[0]
                modules.append((package, module, f))
            else:
                self.debug_print("excluding %s" % setup_script)
        return modules

    def find_modules(self):
        """Finds individually-specified Python modules, ie. those listed by
        module name in 'self.py_modules'.  Returns a list of tuples (package,
        module_base, filename): 'package' is a tuple of the path through
        package-space to the module; 'module_base' is the bare (no
        packages, no dots) module name, and 'filename' is the path to the
        ".py" file (relative to the distribution root) that implements the
        module.
        """
        # Map package names to tuples of useful info about the package:
        #    (package_dir, checked)
        # package_dir - the directory where we'll find source files for
        #   this package
        # checked - true if we have checked that the package directory
        #   is valid (exists, contains __init__.py, ... ?)
        packages = {}

        # List of (package, module, filename) tuples to return
        modules = []

        # We treat modules-in-packages almost the same as toplevel modules,
        # just the "package" for a toplevel is empty (either an empty
        # string or empty list, depending on context).  Differences:
        #   - don't check for __init__.py in directory for empty package
        for module in self.py_modules:
            path = module.split('.')
            package = '.'.join(path[0:-1])
            module_base = path[-1]

            try:
                (package_dir, checked) = packages[package]
            except KeyError:
                package_dir = self.get_package_dir(package)
                checked = 0

            if not checked:
                init_py = self.check_package(package, package_dir)
                packages[package] = (package_dir, 1)
                if init_py:
                    modules.append((package, "__init__", init_py))

            # XXX perhaps we should also check for just .pyc files
            # (so greedy closed-source bastards can distribute Python
            # modules too)
            module_file = os.path.join(package_dir, module_base + ".py")
            if not self.check_module(module, module_file):
                continue

            modules.append((package, module_base, module_file))

        return modules

    def find_all_modules(self):
        """Compute the list of all modules that will be built, whether
        they are specified one-module-at-a-time ('self.py_modules') or
        by whole packages ('self.packages').  Return a list of tuples
        (package, module, module_file), just like 'find_modules()' and
        'find_package_modules()' do."""
        modules = []
        if self.py_modules:
            modules.extend(self.find_modules())
        if self.packages:
            for package in self.packages:
                package_dir = self.get_package_dir(package)
                m = self.find_package_modules(package, package_dir)
                modules.extend(m)
        return modules

    def get_source_files(self):
        return [module[-1] for module in self.find_all_modules()]

    def get_module_outfile(self, build_dir, package, module):
        outfile_path = [build_dir] + list(package) + [module + ".py"]
        return os.path.join(*outfile_path)

    def get_outputs(self, include_bytecode=1):
        modules = self.find_all_modules()
        outputs = []
        for (package, module, module_file) in modules:
            package = package.split('.')
            filename = self.get_module_outfile(self.build_lib, package, module)
            outputs.append(filename)
            if include_bytecode:
                if self.compile:
                    outputs.append(importlib.util.cache_from_source(
                        filename, optimization=''))
                if self.optimize > 0:
                    outputs.append(importlib.util.cache_from_source(
                        filename, optimization=self.optimize))

        outputs += [
            os.path.join(build_dir, filename)
            for package, src_dir, build_dir, filenames in self.data_files
            for filename in filenames
            ]

        return outputs

    def build_module(self, module, module_file, package):
        if isinstance(package, str):
            package = package.split('.')
        elif not isinstance(package, (list, tuple)):
            raise TypeError(
                  "'package' must be a string (dot-separated), list, or tuple")

        # Now put the module source file into the "build" area -- this is
        # easy, we just copy it somewhere under self.build_lib (the build
        # directory for Python source).
        outfile = self.get_module_outfile(self.build_lib, package, module)
        dir = os.path.dirname(outfile)
        self.mkpath(dir)
        return self.copy_file(module_file, outfile, preserve_mode=0)

    def build_modules(self):
        modules = self.find_modules()
        for (package, module, module_file) in modules:
            # Now "build" the module -- ie. copy the source file to
            # self.build_lib (the build directory for Python source).
            # (Actually, it gets copied to the directory for this package
            # under self.build_lib.)
            self.build_module(module, module_file, package)

    def build_packages(self):
        for package in self.packages:
            # Get list of (package, module, module_file) tuples based on
            # scanning the package directory.  'package' is only included
            # in the tuple so that 'find_modules()' and
            # 'find_package_tuples()' have a consistent interface; it's
            # ignored here (apart from a sanity check).  Also, 'module' is
            # the *unqualified* module name (ie. no dots, no package -- we
            # already know its package!), and 'module_file' is the path to
            # the .py file, relative to the current directory
            # (ie. including 'package_dir').
            package_dir = self.get_package_dir(package)
            modules = self.find_package_modules(package, package_dir)

            # Now loop over the modules we found, "building" each one (just
            # copy it to self.build_lib).
            for (package_, module, module_file) in modules:
                assert package == package_
                self.build_module(module, module_file, package)

    def byte_compile(self, files):
        if sys.dont_write_bytecode:
            self.warn('byte-compiling is disabled, skipping.')
            return

        from distutils.util import byte_compile
        prefix = self.build_lib
        if prefix[-1] != os.sep:
            prefix = prefix + os.sep

        # XXX this code is essentially the same as the 'byte_compile()
        # method of the "install_lib" command, except for the determination
        # of the 'prefix' string.  Hmmm.
        if self.compile:
            byte_compile(files, optimize=0,
                         force=self.force, prefix=prefix, dry_run=self.dry_run)
        if self.optimize > 0:
            byte_compile(files, optimize=self.optimize,
                         force=self.force, prefix=prefix, dry_run=self.dry_run)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/build_scripts.py0000644000175100001710000001351300000000000024641 0ustar00runnerdocker"""distutils.command.build_scripts

Implements the Distutils 'build_scripts' command."""

import os, re
from stat import ST_MODE
from distutils import sysconfig
from distutils.core import Command
from distutils.dep_util import newer
from distutils.util import convert_path
from distutils import log
import tokenize

# check if Python is called on the first line with this expression
first_line_re = re.compile(b'^#!.*python[0-9.]*([ \t].*)?$')

class build_scripts(Command):

    description = "\"build\" scripts (copy and fixup #! line)"

    user_options = [
        ('build-dir=', 'd', "directory to \"build\" (copy) to"),
        ('force', 'f', "forcibly build everything (ignore file timestamps"),
        ('executable=', 'e', "specify final destination interpreter path"),
        ]

    boolean_options = ['force']


    def initialize_options(self):
        self.build_dir = None
        self.scripts = None
        self.force = None
        self.executable = None
        self.outfiles = None

    def finalize_options(self):
        self.set_undefined_options('build',
                                   ('build_scripts', 'build_dir'),
                                   ('force', 'force'),
                                   ('executable', 'executable'))
        self.scripts = self.distribution.scripts

    def get_source_files(self):
        return self.scripts

    def run(self):
        if not self.scripts:
            return
        self.copy_scripts()


    def copy_scripts(self):
        r"""Copy each script listed in 'self.scripts'; if it's marked as a
        Python script in the Unix way (first line matches 'first_line_re',
        ie. starts with "\#!" and contains "python"), then adjust the first
        line to refer to the current Python interpreter as we copy.
        """
        self.mkpath(self.build_dir)
        outfiles = []
        updated_files = []
        for script in self.scripts:
            adjust = False
            script = convert_path(script)
            outfile = os.path.join(self.build_dir, os.path.basename(script))
            outfiles.append(outfile)

            if not self.force and not newer(script, outfile):
                log.debug("not copying %s (up-to-date)", script)
                continue

            # Always open the file, but ignore failures in dry-run mode --
            # that way, we'll get accurate feedback if we can read the
            # script.
            try:
                f = open(script, "rb")
            except OSError:
                if not self.dry_run:
                    raise
                f = None
            else:
                encoding, lines = tokenize.detect_encoding(f.readline)
                f.seek(0)
                first_line = f.readline()
                if not first_line:
                    self.warn("%s is an empty file (skipping)" % script)
                    continue

                match = first_line_re.match(first_line)
                if match:
                    adjust = True
                    post_interp = match.group(1) or b''

            if adjust:
                log.info("copying and adjusting %s -> %s", script,
                         self.build_dir)
                updated_files.append(outfile)
                if not self.dry_run:
                    if not sysconfig.python_build:
                        executable = self.executable
                    else:
                        executable = os.path.join(
                            sysconfig.get_config_var("BINDIR"),
                           "python%s%s" % (sysconfig.get_config_var("VERSION"),
                                           sysconfig.get_config_var("EXE")))
                    executable = os.fsencode(executable)
                    shebang = b"#!" + executable + post_interp + b"\n"
                    # Python parser starts to read a script using UTF-8 until
                    # it gets a #coding:xxx cookie. The shebang has to be the
                    # first line of a file, the #coding:xxx cookie cannot be
                    # written before. So the shebang has to be decodable from
                    # UTF-8.
                    try:
                        shebang.decode('utf-8')
                    except UnicodeDecodeError:
                        raise ValueError(
                            "The shebang ({!r}) is not decodable "
                            "from utf-8".format(shebang))
                    # If the script is encoded to a custom encoding (use a
                    # #coding:xxx cookie), the shebang has to be decodable from
                    # the script encoding too.
                    try:
                        shebang.decode(encoding)
                    except UnicodeDecodeError:
                        raise ValueError(
                            "The shebang ({!r}) is not decodable "
                            "from the script encoding ({})"
                            .format(shebang, encoding))
                    with open(outfile, "wb") as outf:
                        outf.write(shebang)
                        outf.writelines(f.readlines())
                if f:
                    f.close()
            else:
                if f:
                    f.close()
                updated_files.append(outfile)
                self.copy_file(script, outfile)

        if os.name == 'posix':
            for file in outfiles:
                if self.dry_run:
                    log.info("changing mode of %s", file)
                else:
                    oldmode = os.stat(file)[ST_MODE] & 0o7777
                    newmode = (oldmode | 0o555) & 0o7777
                    if newmode != oldmode:
                        log.info("changing mode of %s from %o to %o",
                                 file, oldmode, newmode)
                        os.chmod(file, newmode)
        # XXX should we modify self.outfiles?
        return outfiles, updated_files
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/check.py0000644000175100001710000001300500000000000023044 0ustar00runnerdocker"""distutils.command.check

Implements the Distutils 'check' command.
"""
from distutils.core import Command
from distutils.errors import DistutilsSetupError

try:
    # docutils is installed
    from docutils.utils import Reporter
    from docutils.parsers.rst import Parser
    from docutils import frontend
    from docutils import nodes

    class SilentReporter(Reporter):

        def __init__(self, source, report_level, halt_level, stream=None,
                     debug=0, encoding='ascii', error_handler='replace'):
            self.messages = []
            Reporter.__init__(self, source, report_level, halt_level, stream,
                              debug, encoding, error_handler)

        def system_message(self, level, message, *children, **kwargs):
            self.messages.append((level, message, children, kwargs))
            return nodes.system_message(message, level=level,
                                        type=self.levels[level],
                                        *children, **kwargs)

    HAS_DOCUTILS = True
except Exception:
    # Catch all exceptions because exceptions besides ImportError probably
    # indicate that docutils is not ported to Py3k.
    HAS_DOCUTILS = False

class check(Command):
    """This command checks the meta-data of the package.
    """
    description = ("perform some checks on the package")
    user_options = [('metadata', 'm', 'Verify meta-data'),
                    ('restructuredtext', 'r',
                     ('Checks if long string meta-data syntax '
                      'are reStructuredText-compliant')),
                    ('strict', 's',
                     'Will exit with an error if a check fails')]

    boolean_options = ['metadata', 'restructuredtext', 'strict']

    def initialize_options(self):
        """Sets default values for options."""
        self.restructuredtext = 0
        self.metadata = 1
        self.strict = 0
        self._warnings = 0

    def finalize_options(self):
        pass

    def warn(self, msg):
        """Counts the number of warnings that occurs."""
        self._warnings += 1
        return Command.warn(self, msg)

    def run(self):
        """Runs the command."""
        # perform the various tests
        if self.metadata:
            self.check_metadata()
        if self.restructuredtext:
            if HAS_DOCUTILS:
                self.check_restructuredtext()
            elif self.strict:
                raise DistutilsSetupError('The docutils package is needed.')

        # let's raise an error in strict mode, if we have at least
        # one warning
        if self.strict and self._warnings > 0:
            raise DistutilsSetupError('Please correct your package.')

    def check_metadata(self):
        """Ensures that all required elements of meta-data are supplied.

        Required fields:
            name, version, URL

        Recommended fields:
            (author and author_email) or (maintainer and maintainer_email))

        Warns if any are missing.
        """
        metadata = self.distribution.metadata

        missing = []
        for attr in ('name', 'version', 'url'):
            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
                missing.append(attr)

        if missing:
            self.warn("missing required meta-data: %s"  % ', '.join(missing))
        if metadata.author:
            if not metadata.author_email:
                self.warn("missing meta-data: if 'author' supplied, " +
                          "'author_email' should be supplied too")
        elif metadata.maintainer:
            if not metadata.maintainer_email:
                self.warn("missing meta-data: if 'maintainer' supplied, " +
                          "'maintainer_email' should be supplied too")
        else:
            self.warn("missing meta-data: either (author and author_email) " +
                      "or (maintainer and maintainer_email) " +
                      "should be supplied")

    def check_restructuredtext(self):
        """Checks if the long string fields are reST-compliant."""
        data = self.distribution.get_long_description()
        for warning in self._check_rst_data(data):
            line = warning[-1].get('line')
            if line is None:
                warning = warning[1]
            else:
                warning = '%s (line %s)' % (warning[1], line)
            self.warn(warning)

    def _check_rst_data(self, data):
        """Returns warnings when the provided data doesn't compile."""
        # the include and csv_table directives need this to be a path
        source_path = self.distribution.script_name or 'setup.py'
        parser = Parser()
        settings = frontend.OptionParser(components=(Parser,)).get_default_values()
        settings.tab_width = 4
        settings.pep_references = None
        settings.rfc_references = None
        reporter = SilentReporter(source_path,
                          settings.report_level,
                          settings.halt_level,
                          stream=settings.warning_stream,
                          debug=settings.debug,
                          encoding=settings.error_encoding,
                          error_handler=settings.error_encoding_error_handler)

        document = nodes.document(settings, reporter, source=source_path)
        document.note_source(source_path, -1)
        try:
            parser.parse(data, document)
        except AttributeError as e:
            reporter.messages.append(
                (-1, 'Could not finish the parsing: %s.' % e, '', {}))

        return reporter.messages
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/clean.py0000644000175100001710000000533000000000000023053 0ustar00runnerdocker"""distutils.command.clean

Implements the Distutils 'clean' command."""

# contributed by Bastian Kleineidam , added 2000-03-18

import os
from distutils.core import Command
from distutils.dir_util import remove_tree
from distutils import log

class clean(Command):

    description = "clean up temporary files from 'build' command"
    user_options = [
        ('build-base=', 'b',
         "base build directory (default: 'build.build-base')"),
        ('build-lib=', None,
         "build directory for all modules (default: 'build.build-lib')"),
        ('build-temp=', 't',
         "temporary build directory (default: 'build.build-temp')"),
        ('build-scripts=', None,
         "build directory for scripts (default: 'build.build-scripts')"),
        ('bdist-base=', None,
         "temporary directory for built distributions"),
        ('all', 'a',
         "remove all build output, not just temporary by-products")
    ]

    boolean_options = ['all']

    def initialize_options(self):
        self.build_base = None
        self.build_lib = None
        self.build_temp = None
        self.build_scripts = None
        self.bdist_base = None
        self.all = None

    def finalize_options(self):
        self.set_undefined_options('build',
                                   ('build_base', 'build_base'),
                                   ('build_lib', 'build_lib'),
                                   ('build_scripts', 'build_scripts'),
                                   ('build_temp', 'build_temp'))
        self.set_undefined_options('bdist',
                                   ('bdist_base', 'bdist_base'))

    def run(self):
        # remove the build/temp. directory (unless it's already
        # gone)
        if os.path.exists(self.build_temp):
            remove_tree(self.build_temp, dry_run=self.dry_run)
        else:
            log.debug("'%s' does not exist -- can't clean it",
                      self.build_temp)

        if self.all:
            # remove build directories
            for directory in (self.build_lib,
                              self.bdist_base,
                              self.build_scripts):
                if os.path.exists(directory):
                    remove_tree(directory, dry_run=self.dry_run)
                else:
                    log.warn("'%s' does not exist -- can't clean it",
                             directory)

        # just for the heck of it, try to remove the base build directory:
        # we might have emptied it right now, but if not we don't care
        if not self.dry_run:
            try:
                os.rmdir(self.build_base)
                log.info("removing '%s'", self.build_base)
            except OSError:
                pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/config.py0000644000175100001710000003147500000000000023247 0ustar00runnerdocker"""distutils.command.config

Implements the Distutils 'config' command, a (mostly) empty command class
that exists mainly to be sub-classed by specific module distributions and
applications.  The idea is that while every "config" command is different,
at least they're all named the same, and users always see "config" in the
list of standard commands.  Also, this is a good place to put common
configure-like tasks: "try to compile this C code", or "figure out where
this header file lives".
"""

import os, re

from distutils.core import Command
from distutils.errors import DistutilsExecError
from distutils.sysconfig import customize_compiler
from distutils import log

LANG_EXT = {"c": ".c", "c++": ".cxx"}

class config(Command):

    description = "prepare to build"

    user_options = [
        ('compiler=', None,
         "specify the compiler type"),
        ('cc=', None,
         "specify the compiler executable"),
        ('include-dirs=', 'I',
         "list of directories to search for header files"),
        ('define=', 'D',
         "C preprocessor macros to define"),
        ('undef=', 'U',
         "C preprocessor macros to undefine"),
        ('libraries=', 'l',
         "external C libraries to link with"),
        ('library-dirs=', 'L',
         "directories to search for external C libraries"),

        ('noisy', None,
         "show every action (compile, link, run, ...) taken"),
        ('dump-source', None,
         "dump generated source files before attempting to compile them"),
        ]


    # The three standard command methods: since the "config" command
    # does nothing by default, these are empty.

    def initialize_options(self):
        self.compiler = None
        self.cc = None
        self.include_dirs = None
        self.libraries = None
        self.library_dirs = None

        # maximal output for now
        self.noisy = 1
        self.dump_source = 1

        # list of temporary files generated along-the-way that we have
        # to clean at some point
        self.temp_files = []

    def finalize_options(self):
        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        elif isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

        if self.libraries is None:
            self.libraries = []
        elif isinstance(self.libraries, str):
            self.libraries = [self.libraries]

        if self.library_dirs is None:
            self.library_dirs = []
        elif isinstance(self.library_dirs, str):
            self.library_dirs = self.library_dirs.split(os.pathsep)

    def run(self):
        pass

    # Utility methods for actual "config" commands.  The interfaces are
    # loosely based on Autoconf macros of similar names.  Sub-classes
    # may use these freely.

    def _check_compiler(self):
        """Check that 'self.compiler' really is a CCompiler object;
        if not, make it one.
        """
        # We do this late, and only on-demand, because this is an expensive
        # import.
        from distutils.ccompiler import CCompiler, new_compiler
        if not isinstance(self.compiler, CCompiler):
            self.compiler = new_compiler(compiler=self.compiler,
                                         dry_run=self.dry_run, force=1)
            customize_compiler(self.compiler)
            if self.include_dirs:
                self.compiler.set_include_dirs(self.include_dirs)
            if self.libraries:
                self.compiler.set_libraries(self.libraries)
            if self.library_dirs:
                self.compiler.set_library_dirs(self.library_dirs)

    def _gen_temp_sourcefile(self, body, headers, lang):
        filename = "_configtest" + LANG_EXT[lang]
        with open(filename, "w") as file:
            if headers:
                for header in headers:
                    file.write("#include <%s>\n" % header)
                file.write("\n")
            file.write(body)
            if body[-1] != "\n":
                file.write("\n")
        return filename

    def _preprocess(self, body, headers, include_dirs, lang):
        src = self._gen_temp_sourcefile(body, headers, lang)
        out = "_configtest.i"
        self.temp_files.extend([src, out])
        self.compiler.preprocess(src, out, include_dirs=include_dirs)
        return (src, out)

    def _compile(self, body, headers, include_dirs, lang):
        src = self._gen_temp_sourcefile(body, headers, lang)
        if self.dump_source:
            dump_file(src, "compiling '%s':" % src)
        (obj,) = self.compiler.object_filenames([src])
        self.temp_files.extend([src, obj])
        self.compiler.compile([src], include_dirs=include_dirs)
        return (src, obj)

    def _link(self, body, headers, include_dirs, libraries, library_dirs,
              lang):
        (src, obj) = self._compile(body, headers, include_dirs, lang)
        prog = os.path.splitext(os.path.basename(src))[0]
        self.compiler.link_executable([obj], prog,
                                      libraries=libraries,
                                      library_dirs=library_dirs,
                                      target_lang=lang)

        if self.compiler.exe_extension is not None:
            prog = prog + self.compiler.exe_extension
        self.temp_files.append(prog)

        return (src, obj, prog)

    def _clean(self, *filenames):
        if not filenames:
            filenames = self.temp_files
            self.temp_files = []
        log.info("removing: %s", ' '.join(filenames))
        for filename in filenames:
            try:
                os.remove(filename)
            except OSError:
                pass


    # XXX these ignore the dry-run flag: what to do, what to do? even if
    # you want a dry-run build, you still need some sort of configuration
    # info.  My inclination is to make it up to the real config command to
    # consult 'dry_run', and assume a default (minimal) configuration if
    # true.  The problem with trying to do it here is that you'd have to
    # return either true or false from all the 'try' methods, neither of
    # which is correct.

    # XXX need access to the header search path and maybe default macros.

    def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
        """Construct a source file from 'body' (a string containing lines
        of C/C++ code) and 'headers' (a list of header files to include)
        and run it through the preprocessor.  Return true if the
        preprocessor succeeded, false if there were any errors.
        ('body' probably isn't of much use, but what the heck.)
        """
        from distutils.ccompiler import CompileError
        self._check_compiler()
        ok = True
        try:
            self._preprocess(body, headers, include_dirs, lang)
        except CompileError:
            ok = False

        self._clean()
        return ok

    def search_cpp(self, pattern, body=None, headers=None, include_dirs=None,
                   lang="c"):
        """Construct a source file (just like 'try_cpp()'), run it through
        the preprocessor, and return true if any line of the output matches
        'pattern'.  'pattern' should either be a compiled regex object or a
        string containing a regex.  If both 'body' and 'headers' are None,
        preprocesses an empty file -- which can be useful to determine the
        symbols the preprocessor and compiler set by default.
        """
        self._check_compiler()
        src, out = self._preprocess(body, headers, include_dirs, lang)

        if isinstance(pattern, str):
            pattern = re.compile(pattern)

        with open(out) as file:
            match = False
            while True:
                line = file.readline()
                if line == '':
                    break
                if pattern.search(line):
                    match = True
                    break

        self._clean()
        return match

    def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
        """Try to compile a source file built from 'body' and 'headers'.
        Return true on success, false otherwise.
        """
        from distutils.ccompiler import CompileError
        self._check_compiler()
        try:
            self._compile(body, headers, include_dirs, lang)
            ok = True
        except CompileError:
            ok = False

        log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

    def try_link(self, body, headers=None, include_dirs=None, libraries=None,
                 library_dirs=None, lang="c"):
        """Try to compile and link a source file, built from 'body' and
        'headers', to executable form.  Return true on success, false
        otherwise.
        """
        from distutils.ccompiler import CompileError, LinkError
        self._check_compiler()
        try:
            self._link(body, headers, include_dirs,
                       libraries, library_dirs, lang)
            ok = True
        except (CompileError, LinkError):
            ok = False

        log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

    def try_run(self, body, headers=None, include_dirs=None, libraries=None,
                library_dirs=None, lang="c"):
        """Try to compile, link to an executable, and run a program
        built from 'body' and 'headers'.  Return true on success, false
        otherwise.
        """
        from distutils.ccompiler import CompileError, LinkError
        self._check_compiler()
        try:
            src, obj, exe = self._link(body, headers, include_dirs,
                                       libraries, library_dirs, lang)
            self.spawn([exe])
            ok = True
        except (CompileError, LinkError, DistutilsExecError):
            ok = False

        log.info(ok and "success!" or "failure.")
        self._clean()
        return ok


    # -- High-level methods --------------------------------------------
    # (these are the ones that are actually likely to be useful
    # when implementing a real-world config command!)

    def check_func(self, func, headers=None, include_dirs=None,
                   libraries=None, library_dirs=None, decl=0, call=0):
        """Determine if function 'func' is available by constructing a
        source file that refers to 'func', and compiles and links it.
        If everything succeeds, returns true; otherwise returns false.

        The constructed source file starts out by including the header
        files listed in 'headers'.  If 'decl' is true, it then declares
        'func' (as "int func()"); you probably shouldn't supply 'headers'
        and set 'decl' true in the same call, or you might get errors about
        a conflicting declarations for 'func'.  Finally, the constructed
        'main()' function either references 'func' or (if 'call' is true)
        calls it.  'libraries' and 'library_dirs' are used when
        linking.
        """
        self._check_compiler()
        body = []
        if decl:
            body.append("int %s ();" % func)
        body.append("int main () {")
        if call:
            body.append("  %s();" % func)
        else:
            body.append("  %s;" % func)
        body.append("}")
        body = "\n".join(body) + "\n"

        return self.try_link(body, headers, include_dirs,
                             libraries, library_dirs)

    def check_lib(self, library, library_dirs=None, headers=None,
                  include_dirs=None, other_libraries=[]):
        """Determine if 'library' is available to be linked against,
        without actually checking that any particular symbols are provided
        by it.  'headers' will be used in constructing the source file to
        be compiled, but the only effect of this is to check if all the
        header files listed are available.  Any libraries listed in
        'other_libraries' will be included in the link, in case 'library'
        has symbols that depend on other libraries.
        """
        self._check_compiler()
        return self.try_link("int main (void) { }", headers, include_dirs,
                             [library] + other_libraries, library_dirs)

    def check_header(self, header, include_dirs=None, library_dirs=None,
                     lang="c"):
        """Determine if the system header file named by 'header_file'
        exists and can be found by the preprocessor; return true if so,
        false otherwise.
        """
        return self.try_cpp(body="/* No body */", headers=[header],
                            include_dirs=include_dirs)

def dump_file(filename, head=None):
    """Dumps a file content into log.info.

    If head is not None, will be dumped before the file content.
    """
    if head is None:
        log.info('%s', filename)
    else:
        log.info(head)
    file = open(filename)
    try:
        log.info(file.read())
    finally:
        file.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/install.py0000644000175100001710000007045200000000000023446 0ustar00runnerdocker"""distutils.command.install

Implements the Distutils 'install' command."""

import sys
import os
import contextlib
import sysconfig
import itertools

from distutils import log
from distutils.core import Command
from distutils.debug import DEBUG
from distutils.sysconfig import get_config_vars
from distutils.errors import DistutilsPlatformError
from distutils.file_util import write_file
from distutils.util import convert_path, subst_vars, change_root
from distutils.util import get_platform
from distutils.errors import DistutilsOptionError

from site import USER_BASE
from site import USER_SITE
HAS_USER_SITE = True

WINDOWS_SCHEME = {
    'purelib': '{base}/Lib/site-packages',
    'platlib': '{base}/Lib/site-packages',
    'headers': '{base}/Include/{dist_name}',
    'scripts': '{base}/Scripts',
    'data'   : '{base}',
}

INSTALL_SCHEMES = {
    'posix_prefix': {
        'purelib': '{base}/lib/{implementation_lower}{py_version_short}/site-packages',
        'platlib': '{platbase}/{platlibdir}/{implementation_lower}{py_version_short}/site-packages',
        'headers': '{base}/include/{implementation_lower}{py_version_short}{abiflags}/{dist_name}',
        'scripts': '{base}/bin',
        'data'   : '{base}',
        },
    'posix_home': {
        'purelib': '{base}/lib/{implementation_lower}',
        'platlib': '{base}/{platlibdir}/{implementation_lower}',
        'headers': '{base}/include/{implementation_lower}/{dist_name}',
        'scripts': '{base}/bin',
        'data'   : '{base}',
        },
    'nt': WINDOWS_SCHEME,
    'pypy': {
        'purelib': '{base}/site-packages',
        'platlib': '{base}/site-packages',
        'headers': '{base}/include/{dist_name}',
        'scripts': '{base}/bin',
        'data'   : '{base}',
        },
    'pypy_nt': {
        'purelib': '{base}/site-packages',
        'platlib': '{base}/site-packages',
        'headers': '{base}/include/{dist_name}',
        'scripts': '{base}/Scripts',
        'data'   : '{base}',
        },
    }

# user site schemes
if HAS_USER_SITE:
    INSTALL_SCHEMES['nt_user'] = {
        'purelib': '{usersite}',
        'platlib': '{usersite}',
        'headers': '{userbase}/{implementation}{py_version_nodot}/Include/{dist_name}',
        'scripts': '{userbase}/{implementation}{py_version_nodot}/Scripts',
        'data'   : '{userbase}',
        }

    INSTALL_SCHEMES['posix_user'] = {
        'purelib': '{usersite}',
        'platlib': '{usersite}',
        'headers':
            '{userbase}/include/{implementation_lower}{py_version_short}{abiflags}/{dist_name}',
        'scripts': '{userbase}/bin',
        'data'   : '{userbase}',
        }

# The keys to an installation scheme; if any new types of files are to be
# installed, be sure to add an entry to every installation scheme above,
# and to SCHEME_KEYS here.
SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')


def _load_sysconfig_schemes():
    with contextlib.suppress(AttributeError):
        return {
            scheme: sysconfig.get_paths(scheme, expand=False)
            for scheme in sysconfig.get_scheme_names()
        }


def _load_schemes():
    """
    Extend default schemes with schemes from sysconfig.
    """

    sysconfig_schemes = _load_sysconfig_schemes() or {}

    return {
        scheme: {
            **INSTALL_SCHEMES.get(scheme, {}),
            **sysconfig_schemes.get(scheme, {}),
        }
        for scheme in set(itertools.chain(INSTALL_SCHEMES, sysconfig_schemes))
    }


def _get_implementation():
    if hasattr(sys, 'pypy_version_info'):
        return 'PyPy'
    else:
        return 'Python'


class install(Command):

    description = "install everything from build directory"

    user_options = [
        # Select installation scheme and set base director(y|ies)
        ('prefix=', None,
         "installation prefix"),
        ('exec-prefix=', None,
         "(Unix only) prefix for platform-specific files"),
        ('home=', None,
         "(Unix only) home directory to install under"),

        # Or, just set the base director(y|ies)
        ('install-base=', None,
         "base installation directory (instead of --prefix or --home)"),
        ('install-platbase=', None,
         "base installation directory for platform-specific files " +
         "(instead of --exec-prefix or --home)"),
        ('root=', None,
         "install everything relative to this alternate root directory"),

        # Or, explicitly set the installation scheme
        ('install-purelib=', None,
         "installation directory for pure Python module distributions"),
        ('install-platlib=', None,
         "installation directory for non-pure module distributions"),
        ('install-lib=', None,
         "installation directory for all module distributions " +
         "(overrides --install-purelib and --install-platlib)"),

        ('install-headers=', None,
         "installation directory for C/C++ headers"),
        ('install-scripts=', None,
         "installation directory for Python scripts"),
        ('install-data=', None,
         "installation directory for data files"),

        # Byte-compilation options -- see install_lib.py for details, as
        # these are duplicated from there (but only install_lib does
        # anything with them).
        ('compile', 'c', "compile .py to .pyc [default]"),
        ('no-compile', None, "don't compile .py files"),
        ('optimize=', 'O',
         "also compile with optimization: -O1 for \"python -O\", "
         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),

        # Miscellaneous control options
        ('force', 'f',
         "force installation (overwrite any existing files)"),
        ('skip-build', None,
         "skip rebuilding everything (for testing/debugging)"),

        # Where to install documentation (eventually!)
        #('doc-format=', None, "format of documentation to generate"),
        #('install-man=', None, "directory for Unix man pages"),
        #('install-html=', None, "directory for HTML documentation"),
        #('install-info=', None, "directory for GNU info files"),

        ('record=', None,
         "filename in which to record list of installed files"),
        ]

    boolean_options = ['compile', 'force', 'skip-build']

    if HAS_USER_SITE:
        user_options.append(('user', None,
                             "install in user site-package '%s'" % USER_SITE))
        boolean_options.append('user')

    negative_opt = {'no-compile' : 'compile'}


    def initialize_options(self):
        """Initializes options."""
        # High-level options: these select both an installation base
        # and scheme.
        self.prefix = None
        self.exec_prefix = None
        self.home = None
        self.user = 0

        # These select only the installation base; it's up to the user to
        # specify the installation scheme (currently, that means supplying
        # the --install-{platlib,purelib,scripts,data} options).
        self.install_base = None
        self.install_platbase = None
        self.root = None

        # These options are the actual installation directories; if not
        # supplied by the user, they are filled in using the installation
        # scheme implied by prefix/exec-prefix/home and the contents of
        # that installation scheme.
        self.install_purelib = None     # for pure module distributions
        self.install_platlib = None     # non-pure (dists w/ extensions)
        self.install_headers = None     # for C/C++ headers
        self.install_lib = None         # set to either purelib or platlib
        self.install_scripts = None
        self.install_data = None
        self.install_userbase = USER_BASE
        self.install_usersite = USER_SITE

        self.compile = None
        self.optimize = None

        # Deprecated
        # These two are for putting non-packagized distributions into their
        # own directory and creating a .pth file if it makes sense.
        # 'extra_path' comes from the setup file; 'install_path_file' can
        # be turned off if it makes no sense to install a .pth file.  (But
        # better to install it uselessly than to guess wrong and not
        # install it when it's necessary and would be used!)  Currently,
        # 'install_path_file' is always true unless some outsider meddles
        # with it.
        self.extra_path = None
        self.install_path_file = 1

        # 'force' forces installation, even if target files are not
        # out-of-date.  'skip_build' skips running the "build" command,
        # handy if you know it's not necessary.  'warn_dir' (which is *not*
        # a user option, it's just there so the bdist_* commands can turn
        # it off) determines whether we warn about installing to a
        # directory not in sys.path.
        self.force = 0
        self.skip_build = 0
        self.warn_dir = 1

        # These are only here as a conduit from the 'build' command to the
        # 'install_*' commands that do the real work.  ('build_base' isn't
        # actually used anywhere, but it might be useful in future.)  They
        # are not user options, because if the user told the install
        # command where the build directory is, that wouldn't affect the
        # build command.
        self.build_base = None
        self.build_lib = None

        # Not defined yet because we don't know anything about
        # documentation yet.
        #self.install_man = None
        #self.install_html = None
        #self.install_info = None

        self.record = None


    # -- Option finalizing methods -------------------------------------
    # (This is rather more involved than for most commands,
    # because this is where the policy for installing third-
    # party Python modules on various platforms given a wide
    # array of user input is decided.  Yes, it's quite complex!)

    def finalize_options(self):
        """Finalizes options."""
        # This method (and its helpers, like 'finalize_unix()',
        # 'finalize_other()', and 'select_scheme()') is where the default
        # installation directories for modules, extension modules, and
        # anything else we care to install from a Python module
        # distribution.  Thus, this code makes a pretty important policy
        # statement about how third-party stuff is added to a Python
        # installation!  Note that the actual work of installation is done
        # by the relatively simple 'install_*' commands; they just take
        # their orders from the installation directory options determined
        # here.

        # Check for errors/inconsistencies in the options; first, stuff
        # that's wrong on any platform.

        if ((self.prefix or self.exec_prefix or self.home) and
            (self.install_base or self.install_platbase)):
            raise DistutilsOptionError(
                   "must supply either prefix/exec-prefix/home or " +
                   "install-base/install-platbase -- not both")

        if self.home and (self.prefix or self.exec_prefix):
            raise DistutilsOptionError(
                  "must supply either home or prefix/exec-prefix -- not both")

        if self.user and (self.prefix or self.exec_prefix or self.home or
                self.install_base or self.install_platbase):
            raise DistutilsOptionError("can't combine user with prefix, "
                                       "exec_prefix/home, or install_(plat)base")

        # Next, stuff that's wrong (or dubious) only on certain platforms.
        if os.name != "posix":
            if self.exec_prefix:
                self.warn("exec-prefix option ignored on this platform")
                self.exec_prefix = None

        # Now the interesting logic -- so interesting that we farm it out
        # to other methods.  The goal of these methods is to set the final
        # values for the install_{lib,scripts,data,...}  options, using as
        # input a heady brew of prefix, exec_prefix, home, install_base,
        # install_platbase, user-supplied versions of
        # install_{purelib,platlib,lib,scripts,data,...}, and the
        # install schemes.  Phew!

        self.dump_dirs("pre-finalize_{unix,other}")

        if os.name == 'posix':
            self.finalize_unix()
        else:
            self.finalize_other()

        self.dump_dirs("post-finalize_{unix,other}()")

        # Expand configuration variables, tilde, etc. in self.install_base
        # and self.install_platbase -- that way, we can use $base or
        # $platbase in the other installation directories and not worry
        # about needing recursive variable expansion (shudder).

        py_version = sys.version.split()[0]
        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
        try:
            abiflags = sys.abiflags
        except AttributeError:
            # sys.abiflags may not be defined on all platforms.
            abiflags = ''
        self.config_vars = {'dist_name': self.distribution.get_name(),
                            'dist_version': self.distribution.get_version(),
                            'dist_fullname': self.distribution.get_fullname(),
                            'py_version': py_version,
                            'py_version_short': '%d.%d' % sys.version_info[:2],
                            'py_version_nodot': '%d%d' % sys.version_info[:2],
                            'sys_prefix': prefix,
                            'prefix': prefix,
                            'sys_exec_prefix': exec_prefix,
                            'exec_prefix': exec_prefix,
                            'abiflags': abiflags,
                            'platlibdir': getattr(sys, 'platlibdir', 'lib'),
                            'implementation_lower': _get_implementation().lower(),
                            'implementation': _get_implementation(),
                           }

        if HAS_USER_SITE:
            self.config_vars['userbase'] = self.install_userbase
            self.config_vars['usersite'] = self.install_usersite

        self.expand_basedirs()

        self.dump_dirs("post-expand_basedirs()")

        # Now define config vars for the base directories so we can expand
        # everything else.
        self.config_vars['base'] = self.install_base
        self.config_vars['platbase'] = self.install_platbase
        self.config_vars['installed_base'] = (
            sysconfig.get_config_vars()['installed_base'])

        if DEBUG:
            from pprint import pprint
            print("config vars:")
            pprint(self.config_vars)

        # Expand "~" and configuration variables in the installation
        # directories.
        self.expand_dirs()

        self.dump_dirs("post-expand_dirs()")

        # Create directories in the home dir:
        if self.user:
            self.create_home_path()

        # Pick the actual directory to install all modules to: either
        # install_purelib or install_platlib, depending on whether this
        # module distribution is pure or not.  Of course, if the user
        # already specified install_lib, use their selection.
        if self.install_lib is None:
            if self.distribution.has_ext_modules(): # has extensions: non-pure
                self.install_lib = self.install_platlib
            else:
                self.install_lib = self.install_purelib


        # Convert directories from Unix /-separated syntax to the local
        # convention.
        self.convert_paths('lib', 'purelib', 'platlib',
                           'scripts', 'data', 'headers',
                           'userbase', 'usersite')

        # Deprecated
        # Well, we're not actually fully completely finalized yet: we still
        # have to deal with 'extra_path', which is the hack for allowing
        # non-packagized module distributions (hello, Numerical Python!) to
        # get their own directories.
        self.handle_extra_path()
        self.install_libbase = self.install_lib # needed for .pth file
        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)

        # If a new root directory was supplied, make all the installation
        # dirs relative to it.
        if self.root is not None:
            self.change_roots('libbase', 'lib', 'purelib', 'platlib',
                              'scripts', 'data', 'headers')

        self.dump_dirs("after prepending root")

        # Find out the build directories, ie. where to install from.
        self.set_undefined_options('build',
                                   ('build_base', 'build_base'),
                                   ('build_lib', 'build_lib'))

        # Punt on doc directories for now -- after all, we're punting on
        # documentation completely!

    def dump_dirs(self, msg):
        """Dumps the list of user options."""
        if not DEBUG:
            return
        from distutils.fancy_getopt import longopt_xlate
        log.debug(msg + ":")
        for opt in self.user_options:
            opt_name = opt[0]
            if opt_name[-1] == "=":
                opt_name = opt_name[0:-1]
            if opt_name in self.negative_opt:
                opt_name = self.negative_opt[opt_name]
                opt_name = opt_name.translate(longopt_xlate)
                val = not getattr(self, opt_name)
            else:
                opt_name = opt_name.translate(longopt_xlate)
                val = getattr(self, opt_name)
            log.debug("  %s: %s", opt_name, val)

    def finalize_unix(self):
        """Finalizes options for posix platforms."""
        if self.install_base is not None or self.install_platbase is not None:
            if ((self.install_lib is None and
                 self.install_purelib is None and
                 self.install_platlib is None) or
                self.install_headers is None or
                self.install_scripts is None or
                self.install_data is None):
                raise DistutilsOptionError(
                      "install-base or install-platbase supplied, but "
                      "installation scheme is incomplete")
            return

        if self.user:
            if self.install_userbase is None:
                raise DistutilsPlatformError(
                    "User base directory is not specified")
            self.install_base = self.install_platbase = self.install_userbase
            self.select_scheme("posix_user")
        elif self.home is not None:
            self.install_base = self.install_platbase = self.home
            self.select_scheme("posix_home")
        else:
            if self.prefix is None:
                if self.exec_prefix is not None:
                    raise DistutilsOptionError(
                          "must not supply exec-prefix without prefix")

                # Allow Fedora to add components to the prefix
                _prefix_addition = getattr(sysconfig, '_prefix_addition', "")

                self.prefix = (
                    os.path.normpath(sys.prefix) + _prefix_addition)
                self.exec_prefix = (
                    os.path.normpath(sys.exec_prefix) + _prefix_addition)

            else:
                if self.exec_prefix is None:
                    self.exec_prefix = self.prefix

            self.install_base = self.prefix
            self.install_platbase = self.exec_prefix
            self.select_scheme("posix_prefix")

    def finalize_other(self):
        """Finalizes options for non-posix platforms"""
        if self.user:
            if self.install_userbase is None:
                raise DistutilsPlatformError(
                    "User base directory is not specified")
            self.install_base = self.install_platbase = self.install_userbase
            self.select_scheme(os.name + "_user")
        elif self.home is not None:
            self.install_base = self.install_platbase = self.home
            self.select_scheme("posix_home")
        else:
            if self.prefix is None:
                self.prefix = os.path.normpath(sys.prefix)

            self.install_base = self.install_platbase = self.prefix
            try:
                self.select_scheme(os.name)
            except KeyError:
                raise DistutilsPlatformError(
                      "I don't know how to install stuff on '%s'" % os.name)

    def select_scheme(self, name):
        """Sets the install directories by applying the install schemes."""
        # it's the caller's problem if they supply a bad name!
        if (hasattr(sys, 'pypy_version_info') and
                sys.version_info < (3, 8) and
                not name.endswith(('_user', '_home'))):
            if os.name == 'nt':
                name = 'pypy_nt'
            else:
                name = 'pypy'
        scheme = _load_schemes()[name]
        for key in SCHEME_KEYS:
            attrname = 'install_' + key
            if getattr(self, attrname) is None:
                setattr(self, attrname, scheme[key])

    def _expand_attrs(self, attrs):
        for attr in attrs:
            val = getattr(self, attr)
            if val is not None:
                if os.name == 'posix' or os.name == 'nt':
                    val = os.path.expanduser(val)
                val = subst_vars(val, self.config_vars)
                setattr(self, attr, val)

    def expand_basedirs(self):
        """Calls `os.path.expanduser` on install_base, install_platbase and
        root."""
        self._expand_attrs(['install_base', 'install_platbase', 'root'])

    def expand_dirs(self):
        """Calls `os.path.expanduser` on install dirs."""
        self._expand_attrs(['install_purelib', 'install_platlib',
                            'install_lib', 'install_headers',
                            'install_scripts', 'install_data',])

    def convert_paths(self, *names):
        """Call `convert_path` over `names`."""
        for name in names:
            attr = "install_" + name
            setattr(self, attr, convert_path(getattr(self, attr)))

    def handle_extra_path(self):
        """Set `path_file` and `extra_dirs` using `extra_path`."""
        if self.extra_path is None:
            self.extra_path = self.distribution.extra_path

        if self.extra_path is not None:
            log.warn(
                "Distribution option extra_path is deprecated. "
                "See issue27919 for details."
            )
            if isinstance(self.extra_path, str):
                self.extra_path = self.extra_path.split(',')

            if len(self.extra_path) == 1:
                path_file = extra_dirs = self.extra_path[0]
            elif len(self.extra_path) == 2:
                path_file, extra_dirs = self.extra_path
            else:
                raise DistutilsOptionError(
                      "'extra_path' option must be a list, tuple, or "
                      "comma-separated string with 1 or 2 elements")

            # convert to local form in case Unix notation used (as it
            # should be in setup scripts)
            extra_dirs = convert_path(extra_dirs)
        else:
            path_file = None
            extra_dirs = ''

        # XXX should we warn if path_file and not extra_dirs? (in which
        # case the path file would be harmless but pointless)
        self.path_file = path_file
        self.extra_dirs = extra_dirs

    def change_roots(self, *names):
        """Change the install directories pointed by name using root."""
        for name in names:
            attr = "install_" + name
            setattr(self, attr, change_root(self.root, getattr(self, attr)))

    def create_home_path(self):
        """Create directories under ~."""
        if not self.user:
            return
        home = convert_path(os.path.expanduser("~"))
        for name, path in self.config_vars.items():
            if path.startswith(home) and not os.path.isdir(path):
                self.debug_print("os.makedirs('%s', 0o700)" % path)
                os.makedirs(path, 0o700)

    # -- Command execution methods -------------------------------------

    def run(self):
        """Runs the command."""
        # Obviously have to build before we can install
        if not self.skip_build:
            self.run_command('build')
            # If we built for any other platform, we can't install.
            build_plat = self.distribution.get_command_obj('build').plat_name
            # check warn_dir - it is a clue that the 'install' is happening
            # internally, and not to sys.path, so we don't check the platform
            # matches what we are running.
            if self.warn_dir and build_plat != get_platform():
                raise DistutilsPlatformError("Can't install when "
                                             "cross-compiling")

        # Run all sub-commands (at least those that need to be run)
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        if self.path_file:
            self.create_path_file()

        # write list of installed files, if requested.
        if self.record:
            outputs = self.get_outputs()
            if self.root:               # strip any package prefix
                root_len = len(self.root)
                for counter in range(len(outputs)):
                    outputs[counter] = outputs[counter][root_len:]
            self.execute(write_file,
                         (self.record, outputs),
                         "writing list of installed files to '%s'" %
                         self.record)

        sys_path = map(os.path.normpath, sys.path)
        sys_path = map(os.path.normcase, sys_path)
        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
        if (self.warn_dir and
            not (self.path_file and self.install_path_file) and
            install_lib not in sys_path):
            log.debug(("modules installed to '%s', which is not in "
                       "Python's module search path (sys.path) -- "
                       "you'll have to change the search path yourself"),
                       self.install_lib)

    def create_path_file(self):
        """Creates the .pth file"""
        filename = os.path.join(self.install_libbase,
                                self.path_file + ".pth")
        if self.install_path_file:
            self.execute(write_file,
                         (filename, [self.extra_dirs]),
                         "creating %s" % filename)
        else:
            self.warn("path file '%s' not created" % filename)


    # -- Reporting methods ---------------------------------------------

    def get_outputs(self):
        """Assembles the outputs of all the sub-commands."""
        outputs = []
        for cmd_name in self.get_sub_commands():
            cmd = self.get_finalized_command(cmd_name)
            # Add the contents of cmd.get_outputs(), ensuring
            # that outputs doesn't contain duplicate entries
            for filename in cmd.get_outputs():
                if filename not in outputs:
                    outputs.append(filename)

        if self.path_file and self.install_path_file:
            outputs.append(os.path.join(self.install_libbase,
                                        self.path_file + ".pth"))

        return outputs

    def get_inputs(self):
        """Returns the inputs of all the sub-commands"""
        # XXX gee, this looks familiar ;-(
        inputs = []
        for cmd_name in self.get_sub_commands():
            cmd = self.get_finalized_command(cmd_name)
            inputs.extend(cmd.get_inputs())

        return inputs

    # -- Predicates for sub-command list -------------------------------

    def has_lib(self):
        """Returns true if the current distribution has any Python
        modules to install."""
        return (self.distribution.has_pure_modules() or
                self.distribution.has_ext_modules())

    def has_headers(self):
        """Returns true if the current distribution has any headers to
        install."""
        return self.distribution.has_headers()

    def has_scripts(self):
        """Returns true if the current distribution has any scripts to.
        install."""
        return self.distribution.has_scripts()

    def has_data(self):
        """Returns true if the current distribution has any data to.
        install."""
        return self.distribution.has_data_files()

    # 'sub_commands': a list of commands this command might have to run to
    # get its work done.  See cmd.py for more info.
    sub_commands = [('install_lib',     has_lib),
                    ('install_headers', has_headers),
                    ('install_scripts', has_scripts),
                    ('install_data',    has_data),
                    ('install_egg_info', lambda self:True),
                   ]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/install_data.py0000644000175100001710000000540600000000000024434 0ustar00runnerdocker"""distutils.command.install_data

Implements the Distutils 'install_data' command, for installing
platform-independent data files."""

# contributed by Bastian Kleineidam

import os
from distutils.core import Command
from distutils.util import change_root, convert_path

class install_data(Command):

    description = "install data files"

    user_options = [
        ('install-dir=', 'd',
         "base directory for installing data files "
         "(default: installation base dir)"),
        ('root=', None,
         "install everything relative to this alternate root directory"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ]

    boolean_options = ['force']

    def initialize_options(self):
        self.install_dir = None
        self.outfiles = []
        self.root = None
        self.force = 0
        self.data_files = self.distribution.data_files
        self.warn_dir = 1

    def finalize_options(self):
        self.set_undefined_options('install',
                                   ('install_data', 'install_dir'),
                                   ('root', 'root'),
                                   ('force', 'force'),
                                  )

    def run(self):
        self.mkpath(self.install_dir)
        for f in self.data_files:
            if isinstance(f, str):
                # it's a simple file, so copy it
                f = convert_path(f)
                if self.warn_dir:
                    self.warn("setup script did not provide a directory for "
                              "'%s' -- installing right in '%s'" %
                              (f, self.install_dir))
                (out, _) = self.copy_file(f, self.install_dir)
                self.outfiles.append(out)
            else:
                # it's a tuple with path to install to and a list of files
                dir = convert_path(f[0])
                if not os.path.isabs(dir):
                    dir = os.path.join(self.install_dir, dir)
                elif self.root:
                    dir = change_root(self.root, dir)
                self.mkpath(dir)

                if f[1] == []:
                    # If there are no files listed, the user must be
                    # trying to create an empty directory, so add the
                    # directory to the list of output files.
                    self.outfiles.append(dir)
                else:
                    # Copy files, adding them to the list of output files.
                    for data in f[1]:
                        data = convert_path(data)
                        (out, _) = self.copy_file(data, dir)
                        self.outfiles.append(out)

    def get_inputs(self):
        return self.data_files or []

    def get_outputs(self):
        return self.outfiles
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/install_egg_info.py0000644000175100001710000000530100000000000025272 0ustar00runnerdocker"""distutils.command.install_egg_info

Implements the Distutils 'install_egg_info' command, for installing
a package's PKG-INFO metadata."""


from distutils.cmd import Command
from distutils import log, dir_util
import os, sys, re

class install_egg_info(Command):
    """Install an .egg-info file for the package"""

    description = "Install package's PKG-INFO metadata as an .egg-info file"
    user_options = [
        ('install-dir=', 'd', "directory to install to"),
    ]

    def initialize_options(self):
        self.install_dir = None

    @property
    def basename(self):
        """
        Allow basename to be overridden by child class.
        Ref pypa/distutils#2.
        """
        return "%s-%s-py%d.%d.egg-info" % (
            to_filename(safe_name(self.distribution.get_name())),
            to_filename(safe_version(self.distribution.get_version())),
            *sys.version_info[:2]
        )

    def finalize_options(self):
        self.set_undefined_options('install_lib',('install_dir','install_dir'))
        self.target = os.path.join(self.install_dir, self.basename)
        self.outputs = [self.target]

    def run(self):
        target = self.target
        if os.path.isdir(target) and not os.path.islink(target):
            dir_util.remove_tree(target, dry_run=self.dry_run)
        elif os.path.exists(target):
            self.execute(os.unlink,(self.target,),"Removing "+target)
        elif not os.path.isdir(self.install_dir):
            self.execute(os.makedirs, (self.install_dir,),
                         "Creating "+self.install_dir)
        log.info("Writing %s", target)
        if not self.dry_run:
            with open(target, 'w', encoding='UTF-8') as f:
                self.distribution.metadata.write_pkg_file(f)

    def get_outputs(self):
        return self.outputs


# The following routines are taken from setuptools' pkg_resources module and
# can be replaced by importing them from pkg_resources once it is included
# in the stdlib.

def safe_name(name):
    """Convert an arbitrary string to a standard distribution name

    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
    """
    return re.sub('[^A-Za-z0-9.]+', '-', name)


def safe_version(version):
    """Convert an arbitrary string to a standard version string

    Spaces become dots, and all other non-alphanumeric characters become
    dashes, with runs of multiple dashes condensed to a single dash.
    """
    version = version.replace(' ','.')
    return re.sub('[^A-Za-z0-9.]+', '-', version)


def to_filename(name):
    """Convert a project or version name to its filename-escaped form

    Any '-' characters are currently replaced with '_'.
    """
    return name.replace('-','_')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/install_headers.py0000644000175100001710000000242200000000000025131 0ustar00runnerdocker"""distutils.command.install_headers

Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory."""

from distutils.core import Command


# XXX force is never used
class install_headers(Command):

    description = "install C/C++ header files"

    user_options = [('install-dir=', 'd',
                     "directory to install header files to"),
                    ('force', 'f',
                     "force installation (overwrite existing files)"),
                   ]

    boolean_options = ['force']

    def initialize_options(self):
        self.install_dir = None
        self.force = 0
        self.outfiles = []

    def finalize_options(self):
        self.set_undefined_options('install',
                                   ('install_headers', 'install_dir'),
                                   ('force', 'force'))


    def run(self):
        headers = self.distribution.headers
        if not headers:
            return

        self.mkpath(self.install_dir)
        for header in headers:
            (out, _) = self.copy_file(header, self.install_dir)
            self.outfiles.append(out)

    def get_inputs(self):
        return self.distribution.headers or []

    def get_outputs(self):
        return self.outfiles
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/install_lib.py0000644000175100001710000002031500000000000024265 0ustar00runnerdocker"""distutils.command.install_lib

Implements the Distutils 'install_lib' command
(install all Python modules)."""

import os
import importlib.util
import sys

from distutils.core import Command
from distutils.errors import DistutilsOptionError


# Extension for Python source files.
PYTHON_SOURCE_EXTENSION = ".py"

class install_lib(Command):

    description = "install all Python modules (extensions and pure Python)"

    # The byte-compilation options are a tad confusing.  Here are the
    # possible scenarios:
    #   1) no compilation at all (--no-compile --no-optimize)
    #   2) compile .pyc only (--compile --no-optimize; default)
    #   3) compile .pyc and "opt-1" .pyc (--compile --optimize)
    #   4) compile "opt-1" .pyc only (--no-compile --optimize)
    #   5) compile .pyc and "opt-2" .pyc (--compile --optimize-more)
    #   6) compile "opt-2" .pyc only (--no-compile --optimize-more)
    #
    # The UI for this is two options, 'compile' and 'optimize'.
    # 'compile' is strictly boolean, and only decides whether to
    # generate .pyc files.  'optimize' is three-way (0, 1, or 2), and
    # decides both whether to generate .pyc files and what level of
    # optimization to use.

    user_options = [
        ('install-dir=', 'd', "directory to install to"),
        ('build-dir=','b', "build directory (where to install from)"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ('compile', 'c', "compile .py to .pyc [default]"),
        ('no-compile', None, "don't compile .py files"),
        ('optimize=', 'O',
         "also compile with optimization: -O1 for \"python -O\", "
         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
        ('skip-build', None, "skip the build steps"),
        ]

    boolean_options = ['force', 'compile', 'skip-build']
    negative_opt = {'no-compile' : 'compile'}

    def initialize_options(self):
        # let the 'install' command dictate our installation directory
        self.install_dir = None
        self.build_dir = None
        self.force = 0
        self.compile = None
        self.optimize = None
        self.skip_build = None

    def finalize_options(self):
        # Get all the information we need to install pure Python modules
        # from the umbrella 'install' command -- build (source) directory,
        # install (target) directory, and whether to compile .py files.
        self.set_undefined_options('install',
                                   ('build_lib', 'build_dir'),
                                   ('install_lib', 'install_dir'),
                                   ('force', 'force'),
                                   ('compile', 'compile'),
                                   ('optimize', 'optimize'),
                                   ('skip_build', 'skip_build'),
                                  )

        if self.compile is None:
            self.compile = True
        if self.optimize is None:
            self.optimize = False

        if not isinstance(self.optimize, int):
            try:
                self.optimize = int(self.optimize)
                if self.optimize not in (0, 1, 2):
                    raise AssertionError
            except (ValueError, AssertionError):
                raise DistutilsOptionError("optimize must be 0, 1, or 2")

    def run(self):
        # Make sure we have built everything we need first
        self.build()

        # Install everything: simply dump the entire contents of the build
        # directory to the installation directory (that's the beauty of
        # having a build directory!)
        outfiles = self.install()

        # (Optionally) compile .py to .pyc
        if outfiles is not None and self.distribution.has_pure_modules():
            self.byte_compile(outfiles)

    # -- Top-level worker functions ------------------------------------
    # (called from 'run()')

    def build(self):
        if not self.skip_build:
            if self.distribution.has_pure_modules():
                self.run_command('build_py')
            if self.distribution.has_ext_modules():
                self.run_command('build_ext')

    def install(self):
        if os.path.isdir(self.build_dir):
            outfiles = self.copy_tree(self.build_dir, self.install_dir)
        else:
            self.warn("'%s' does not exist -- no Python modules to install" %
                      self.build_dir)
            return
        return outfiles

    def byte_compile(self, files):
        if sys.dont_write_bytecode:
            self.warn('byte-compiling is disabled, skipping.')
            return

        from distutils.util import byte_compile

        # Get the "--root" directory supplied to the "install" command,
        # and use it as a prefix to strip off the purported filename
        # encoded in bytecode files.  This is far from complete, but it
        # should at least generate usable bytecode in RPM distributions.
        install_root = self.get_finalized_command('install').root

        if self.compile:
            byte_compile(files, optimize=0,
                         force=self.force, prefix=install_root,
                         dry_run=self.dry_run)
        if self.optimize > 0:
            byte_compile(files, optimize=self.optimize,
                         force=self.force, prefix=install_root,
                         verbose=self.verbose, dry_run=self.dry_run)


    # -- Utility methods -----------------------------------------------

    def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
        if not has_any:
            return []

        build_cmd = self.get_finalized_command(build_cmd)
        build_files = build_cmd.get_outputs()
        build_dir = getattr(build_cmd, cmd_option)

        prefix_len = len(build_dir) + len(os.sep)
        outputs = []
        for file in build_files:
            outputs.append(os.path.join(output_dir, file[prefix_len:]))

        return outputs

    def _bytecode_filenames(self, py_filenames):
        bytecode_files = []
        for py_file in py_filenames:
            # Since build_py handles package data installation, the
            # list of outputs can contain more than just .py files.
            # Make sure we only report bytecode for the .py files.
            ext = os.path.splitext(os.path.normcase(py_file))[1]
            if ext != PYTHON_SOURCE_EXTENSION:
                continue
            if self.compile:
                bytecode_files.append(importlib.util.cache_from_source(
                    py_file, optimization=''))
            if self.optimize > 0:
                bytecode_files.append(importlib.util.cache_from_source(
                    py_file, optimization=self.optimize))

        return bytecode_files


    # -- External interface --------------------------------------------
    # (called by outsiders)

    def get_outputs(self):
        """Return the list of files that would be installed if this command
        were actually run.  Not affected by the "dry-run" flag or whether
        modules have actually been built yet.
        """
        pure_outputs = \
            self._mutate_outputs(self.distribution.has_pure_modules(),
                                 'build_py', 'build_lib',
                                 self.install_dir)
        if self.compile:
            bytecode_outputs = self._bytecode_filenames(pure_outputs)
        else:
            bytecode_outputs = []

        ext_outputs = \
            self._mutate_outputs(self.distribution.has_ext_modules(),
                                 'build_ext', 'build_lib',
                                 self.install_dir)

        return pure_outputs + bytecode_outputs + ext_outputs

    def get_inputs(self):
        """Get the list of files that are input to this command, ie. the
        files that get installed as they are named in the build tree.
        The files in this list correspond one-to-one to the output
        filenames returned by 'get_outputs()'.
        """
        inputs = []

        if self.distribution.has_pure_modules():
            build_py = self.get_finalized_command('build_py')
            inputs.extend(build_py.get_outputs())

        if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command('build_ext')
            inputs.extend(build_ext.get_outputs())

        return inputs
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/install_scripts.py0000644000175100001710000000374100000000000025212 0ustar00runnerdocker"""distutils.command.install_scripts

Implements the Distutils 'install_scripts' command, for installing
Python scripts."""

# contributed by Bastian Kleineidam

import os
from distutils.core import Command
from distutils import log
from stat import ST_MODE


class install_scripts(Command):

    description = "install scripts (Python or otherwise)"

    user_options = [
        ('install-dir=', 'd', "directory to install scripts to"),
        ('build-dir=','b', "build directory (where to install from)"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ('skip-build', None, "skip the build steps"),
    ]

    boolean_options = ['force', 'skip-build']

    def initialize_options(self):
        self.install_dir = None
        self.force = 0
        self.build_dir = None
        self.skip_build = None

    def finalize_options(self):
        self.set_undefined_options('build', ('build_scripts', 'build_dir'))
        self.set_undefined_options('install',
                                   ('install_scripts', 'install_dir'),
                                   ('force', 'force'),
                                   ('skip_build', 'skip_build'),
                                  )

    def run(self):
        if not self.skip_build:
            self.run_command('build_scripts')
        self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
        if os.name == 'posix':
            # Set the executable bits (owner, group, and world) on
            # all the scripts we just installed.
            for file in self.get_outputs():
                if self.dry_run:
                    log.info("changing mode of %s", file)
                else:
                    mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
                    log.info("changing mode of %s to %o", file, mode)
                    os.chmod(file, mode)

    def get_inputs(self):
        return self.distribution.scripts or []

    def get_outputs(self):
        return self.outfiles or []
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/py37compat.py0000644000175100001710000000123700000000000024001 0ustar00runnerdockerimport sys


def _pythonlib_compat():
    """
    On Python 3.7 and earlier, distutils would include the Python
    library. See pypa/distutils#9.
    """
    from distutils import sysconfig
    if not sysconfig.get_config_var('Py_ENABLED_SHARED'):
        return

    yield 'python{}.{}{}'.format(
        sys.hexversion >> 24,
        (sys.hexversion >> 16) & 0xff,
        sysconfig.get_config_var('ABIFLAGS'),
    )


def compose(f1, f2):
    return lambda *args, **kwargs: f1(f2(*args, **kwargs))


pythonlib = (
    compose(list, _pythonlib_compat)
    if sys.version_info < (3, 8)
    and sys.platform != 'darwin'
    and sys.platform[:3] != 'aix'
    else list
)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/register.py0000644000175100001710000002670000000000000023621 0ustar00runnerdocker"""distutils.command.register

Implements the Distutils 'register' command (register with the repository).
"""

# created 2002/10/21, Richard Jones

import getpass
import io
import urllib.parse, urllib.request
from warnings import warn

from distutils.core import PyPIRCCommand
from distutils.errors import *
from distutils import log

class register(PyPIRCCommand):

    description = ("register the distribution with the Python package index")
    user_options = PyPIRCCommand.user_options + [
        ('list-classifiers', None,
         'list the valid Trove classifiers'),
        ('strict', None ,
         'Will stop the registering if the meta-data are not fully compliant')
        ]
    boolean_options = PyPIRCCommand.boolean_options + [
        'verify', 'list-classifiers', 'strict']

    sub_commands = [('check', lambda self: True)]

    def initialize_options(self):
        PyPIRCCommand.initialize_options(self)
        self.list_classifiers = 0
        self.strict = 0

    def finalize_options(self):
        PyPIRCCommand.finalize_options(self)
        # setting options for the `check` subcommand
        check_options = {'strict': ('register', self.strict),
                         'restructuredtext': ('register', 1)}
        self.distribution.command_options['check'] = check_options

    def run(self):
        self.finalize_options()
        self._set_config()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        if self.dry_run:
            self.verify_metadata()
        elif self.list_classifiers:
            self.classifiers()
        else:
            self.send_metadata()

    def check_metadata(self):
        """Deprecated API."""
        warn("distutils.command.register.check_metadata is deprecated, \
              use the check command instead", PendingDeprecationWarning)
        check = self.distribution.get_command_obj('check')
        check.ensure_finalized()
        check.strict = self.strict
        check.restructuredtext = 1
        check.run()

    def _set_config(self):
        ''' Reads the configuration file and set attributes.
        '''
        config = self._read_pypirc()
        if config != {}:
            self.username = config['username']
            self.password = config['password']
            self.repository = config['repository']
            self.realm = config['realm']
            self.has_config = True
        else:
            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
                raise ValueError('%s not found in .pypirc' % self.repository)
            if self.repository == 'pypi':
                self.repository = self.DEFAULT_REPOSITORY
            self.has_config = False

    def classifiers(self):
        ''' Fetch the list of classifiers from the server.
        '''
        url = self.repository+'?:action=list_classifiers'
        response = urllib.request.urlopen(url)
        log.info(self._read_pypi_response(response))

    def verify_metadata(self):
        ''' Send the metadata to the package index server to be checked.
        '''
        # send the info to the server and report the result
        (code, result) = self.post_to_server(self.build_post_data('verify'))
        log.info('Server response (%s): %s', code, result)

    def send_metadata(self):
        ''' Send the metadata to the package index server.

            Well, do the following:
            1. figure who the user is, and then
            2. send the data as a Basic auth'ed POST.

            First we try to read the username/password from $HOME/.pypirc,
            which is a ConfigParser-formatted file with a section
            [distutils] containing username and password entries (both
            in clear text). Eg:

                [distutils]
                index-servers =
                    pypi

                [pypi]
                username: fred
                password: sekrit

            Otherwise, to figure who the user is, we offer the user three
            choices:

             1. use existing login,
             2. register as a new user, or
             3. set the password to a random string and email the user.

        '''
        # see if we can short-cut and get the username/password from the
        # config
        if self.has_config:
            choice = '1'
            username = self.username
            password = self.password
        else:
            choice = 'x'
            username = password = ''

        # get the user's login info
        choices = '1 2 3 4'.split()
        while choice not in choices:
            self.announce('''\
We need to know who you are, so please choose either:
 1. use your existing login,
 2. register as a new user,
 3. have the server generate a new password for you (and email it to you), or
 4. quit
Your selection [default 1]: ''', log.INFO)
            choice = input()
            if not choice:
                choice = '1'
            elif choice not in choices:
                print('Please choose one of the four options!')

        if choice == '1':
            # get the username and password
            while not username:
                username = input('Username: ')
            while not password:
                password = getpass.getpass('Password: ')

            # set up the authentication
            auth = urllib.request.HTTPPasswordMgr()
            host = urllib.parse.urlparse(self.repository)[1]
            auth.add_password(self.realm, host, username, password)
            # send the info to the server and report the result
            code, result = self.post_to_server(self.build_post_data('submit'),
                auth)
            self.announce('Server response (%s): %s' % (code, result),
                          log.INFO)

            # possibly save the login
            if code == 200:
                if self.has_config:
                    # sharing the password in the distribution instance
                    # so the upload command can reuse it
                    self.distribution.password = password
                else:
                    self.announce(('I can store your PyPI login so future '
                                   'submissions will be faster.'), log.INFO)
                    self.announce('(the login will be stored in %s)' % \
                                  self._get_rc_file(), log.INFO)
                    choice = 'X'
                    while choice.lower() not in 'yn':
                        choice = input('Save your login (y/N)?')
                        if not choice:
                            choice = 'n'
                    if choice.lower() == 'y':
                        self._store_pypirc(username, password)

        elif choice == '2':
            data = {':action': 'user'}
            data['name'] = data['password'] = data['email'] = ''
            data['confirm'] = None
            while not data['name']:
                data['name'] = input('Username: ')
            while data['password'] != data['confirm']:
                while not data['password']:
                    data['password'] = getpass.getpass('Password: ')
                while not data['confirm']:
                    data['confirm'] = getpass.getpass(' Confirm: ')
                if data['password'] != data['confirm']:
                    data['password'] = ''
                    data['confirm'] = None
                    print("Password and confirm don't match!")
            while not data['email']:
                data['email'] = input('   EMail: ')
            code, result = self.post_to_server(data)
            if code != 200:
                log.info('Server response (%s): %s', code, result)
            else:
                log.info('You will receive an email shortly.')
                log.info(('Follow the instructions in it to '
                          'complete registration.'))
        elif choice == '3':
            data = {':action': 'password_reset'}
            data['email'] = ''
            while not data['email']:
                data['email'] = input('Your email address: ')
            code, result = self.post_to_server(data)
            log.info('Server response (%s): %s', code, result)

    def build_post_data(self, action):
        # figure the data to send - the metadata plus some additional
        # information used by the package server
        meta = self.distribution.metadata
        data = {
            ':action': action,
            'metadata_version' : '1.0',
            'name': meta.get_name(),
            'version': meta.get_version(),
            'summary': meta.get_description(),
            'home_page': meta.get_url(),
            'author': meta.get_contact(),
            'author_email': meta.get_contact_email(),
            'license': meta.get_licence(),
            'description': meta.get_long_description(),
            'keywords': meta.get_keywords(),
            'platform': meta.get_platforms(),
            'classifiers': meta.get_classifiers(),
            'download_url': meta.get_download_url(),
            # PEP 314
            'provides': meta.get_provides(),
            'requires': meta.get_requires(),
            'obsoletes': meta.get_obsoletes(),
        }
        if data['provides'] or data['requires'] or data['obsoletes']:
            data['metadata_version'] = '1.1'
        return data

    def post_to_server(self, data, auth=None):
        ''' Post a query to the server, and return a string response.
        '''
        if 'name' in data:
            self.announce('Registering %s to %s' % (data['name'],
                                                    self.repository),
                                                    log.INFO)
        # Build up the MIME payload for the urllib2 POST data
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = '\n--' + boundary
        end_boundary = sep_boundary + '--'
        body = io.StringIO()
        for key, value in data.items():
            # handle multiple entries for the same name
            if type(value) not in (type([]), type( () )):
                value = [value]
            for value in value:
                value = str(value)
                body.write(sep_boundary)
                body.write('\nContent-Disposition: form-data; name="%s"'%key)
                body.write("\n\n")
                body.write(value)
                if value and value[-1] == '\r':
                    body.write('\n')  # write an extra newline (lurve Macs)
        body.write(end_boundary)
        body.write("\n")
        body = body.getvalue().encode("utf-8")

        # build the Request
        headers = {
            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'%boundary,
            'Content-length': str(len(body))
        }
        req = urllib.request.Request(self.repository, body, headers)

        # handle HTTP and include the Basic Auth handler
        opener = urllib.request.build_opener(
            urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
        )
        data = ''
        try:
            result = opener.open(req)
        except urllib.error.HTTPError as e:
            if self.show_response:
                data = e.fp.read()
            result = e.code, e.msg
        except urllib.error.URLError as e:
            result = 500, str(e)
        else:
            if self.show_response:
                data = self._read_pypi_response(result)
            result = 200, 'OK'
        if self.show_response:
            msg = '\n'.join(('-' * 75, data, '-' * 75))
            self.announce(msg, log.INFO)
        return result
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/sdist.py0000644000175100001710000004507500000000000023131 0ustar00runnerdocker"""distutils.command.sdist

Implements the Distutils 'sdist' command (create a source distribution)."""

import os
import sys
from glob import glob
from warnings import warn

from distutils.core import Command
from distutils import dir_util
from distutils import file_util
from distutils import archive_util
from distutils.text_file import TextFile
from distutils.filelist import FileList
from distutils import log
from distutils.util import convert_path
from distutils.errors import DistutilsTemplateError, DistutilsOptionError


def show_formats():
    """Print all possible values for the 'formats' option (used by
    the "--help-formats" command-line option).
    """
    from distutils.fancy_getopt import FancyGetopt
    from distutils.archive_util import ARCHIVE_FORMATS
    formats = []
    for format in ARCHIVE_FORMATS.keys():
        formats.append(("formats=" + format, None,
                        ARCHIVE_FORMATS[format][2]))
    formats.sort()
    FancyGetopt(formats).print_help(
        "List of available source distribution formats:")


class sdist(Command):

    description = "create a source distribution (tarball, zip file, etc.)"

    def checking_metadata(self):
        """Callable used for the check sub-command.

        Placed here so user_options can view it"""
        return self.metadata_check

    user_options = [
        ('template=', 't',
         "name of manifest template file [default: MANIFEST.in]"),
        ('manifest=', 'm',
         "name of manifest file [default: MANIFEST]"),
        ('use-defaults', None,
         "include the default file set in the manifest "
         "[default; disable with --no-defaults]"),
        ('no-defaults', None,
         "don't include the default file set"),
        ('prune', None,
         "specifically exclude files/directories that should not be "
         "distributed (build tree, RCS/CVS dirs, etc.) "
         "[default; disable with --no-prune]"),
        ('no-prune', None,
         "don't automatically exclude anything"),
        ('manifest-only', 'o',
         "just regenerate the manifest and then stop "
         "(implies --force-manifest)"),
        ('force-manifest', 'f',
         "forcibly regenerate the manifest and carry on as usual. "
         "Deprecated: now the manifest is always regenerated."),
        ('formats=', None,
         "formats for source distribution (comma-separated list)"),
        ('keep-temp', 'k',
         "keep the distribution tree around after creating " +
         "archive file(s)"),
        ('dist-dir=', 'd',
         "directory to put the source distribution archive(s) in "
         "[default: dist]"),
        ('metadata-check', None,
         "Ensure that all required elements of meta-data "
         "are supplied. Warn if any missing. [default]"),
        ('owner=', 'u',
         "Owner name used when creating a tar file [default: current user]"),
        ('group=', 'g',
         "Group name used when creating a tar file [default: current group]"),
        ]

    boolean_options = ['use-defaults', 'prune',
                       'manifest-only', 'force-manifest',
                       'keep-temp', 'metadata-check']

    help_options = [
        ('help-formats', None,
         "list available distribution formats", show_formats),
        ]

    negative_opt = {'no-defaults': 'use-defaults',
                    'no-prune': 'prune' }

    sub_commands = [('check', checking_metadata)]

    READMES = ('README', 'README.txt', 'README.rst')

    def initialize_options(self):
        # 'template' and 'manifest' are, respectively, the names of
        # the manifest template and manifest file.
        self.template = None
        self.manifest = None

        # 'use_defaults': if true, we will include the default file set
        # in the manifest
        self.use_defaults = 1
        self.prune = 1

        self.manifest_only = 0
        self.force_manifest = 0

        self.formats = ['gztar']
        self.keep_temp = 0
        self.dist_dir = None

        self.archive_files = None
        self.metadata_check = 1
        self.owner = None
        self.group = None

    def finalize_options(self):
        if self.manifest is None:
            self.manifest = "MANIFEST"
        if self.template is None:
            self.template = "MANIFEST.in"

        self.ensure_string_list('formats')

        bad_format = archive_util.check_archive_formats(self.formats)
        if bad_format:
            raise DistutilsOptionError(
                  "unknown archive format '%s'" % bad_format)

        if self.dist_dir is None:
            self.dist_dir = "dist"

    def run(self):
        # 'filelist' contains the list of files that will make up the
        # manifest
        self.filelist = FileList()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        # Do whatever it takes to get the list of files to process
        # (process the manifest template, read an existing manifest,
        # whatever).  File list is accumulated in 'self.filelist'.
        self.get_file_list()

        # If user just wanted us to regenerate the manifest, stop now.
        if self.manifest_only:
            return

        # Otherwise, go ahead and create the source distribution tarball,
        # or zipfile, or whatever.
        self.make_distribution()

    def check_metadata(self):
        """Deprecated API."""
        warn("distutils.command.sdist.check_metadata is deprecated, \
              use the check command instead", PendingDeprecationWarning)
        check = self.distribution.get_command_obj('check')
        check.ensure_finalized()
        check.run()

    def get_file_list(self):
        """Figure out the list of files to include in the source
        distribution, and put it in 'self.filelist'.  This might involve
        reading the manifest template (and writing the manifest), or just
        reading the manifest, or just using the default file set -- it all
        depends on the user's options.
        """
        # new behavior when using a template:
        # the file list is recalculated every time because
        # even if MANIFEST.in or setup.py are not changed
        # the user might have added some files in the tree that
        # need to be included.
        #
        #  This makes --force the default and only behavior with templates.
        template_exists = os.path.isfile(self.template)
        if not template_exists and self._manifest_is_not_generated():
            self.read_manifest()
            self.filelist.sort()
            self.filelist.remove_duplicates()
            return

        if not template_exists:
            self.warn(("manifest template '%s' does not exist " +
                        "(using default file list)") %
                        self.template)
        self.filelist.findall()

        if self.use_defaults:
            self.add_defaults()

        if template_exists:
            self.read_template()

        if self.prune:
            self.prune_file_list()

        self.filelist.sort()
        self.filelist.remove_duplicates()
        self.write_manifest()

    def add_defaults(self):
        """Add all the default files to self.filelist:
          - README or README.txt
          - setup.py
          - test/test*.py
          - all pure Python modules mentioned in setup script
          - all files pointed by package_data (build_py)
          - all files defined in data_files.
          - all files defined as scripts.
          - all C sources listed as part of extensions or C libraries
            in the setup script (doesn't catch C headers!)
        Warns if (README or README.txt) or setup.py are missing; everything
        else is optional.
        """
        self._add_defaults_standards()
        self._add_defaults_optional()
        self._add_defaults_python()
        self._add_defaults_data_files()
        self._add_defaults_ext()
        self._add_defaults_c_libs()
        self._add_defaults_scripts()

    @staticmethod
    def _cs_path_exists(fspath):
        """
        Case-sensitive path existence check

        >>> sdist._cs_path_exists(__file__)
        True
        >>> sdist._cs_path_exists(__file__.upper())
        False
        """
        if not os.path.exists(fspath):
            return False
        # make absolute so we always have a directory
        abspath = os.path.abspath(fspath)
        directory, filename = os.path.split(abspath)
        return filename in os.listdir(directory)

    def _add_defaults_standards(self):
        standards = [self.READMES, self.distribution.script_name]
        for fn in standards:
            if isinstance(fn, tuple):
                alts = fn
                got_it = False
                for fn in alts:
                    if self._cs_path_exists(fn):
                        got_it = True
                        self.filelist.append(fn)
                        break

                if not got_it:
                    self.warn("standard file not found: should have one of " +
                              ', '.join(alts))
            else:
                if self._cs_path_exists(fn):
                    self.filelist.append(fn)
                else:
                    self.warn("standard file '%s' not found" % fn)

    def _add_defaults_optional(self):
        optional = ['test/test*.py', 'setup.cfg']
        for pattern in optional:
            files = filter(os.path.isfile, glob(pattern))
            self.filelist.extend(files)

    def _add_defaults_python(self):
        # build_py is used to get:
        #  - python modules
        #  - files defined in package_data
        build_py = self.get_finalized_command('build_py')

        # getting python files
        if self.distribution.has_pure_modules():
            self.filelist.extend(build_py.get_source_files())

        # getting package_data files
        # (computed in build_py.data_files by build_py.finalize_options)
        for pkg, src_dir, build_dir, filenames in build_py.data_files:
            for filename in filenames:
                self.filelist.append(os.path.join(src_dir, filename))

    def _add_defaults_data_files(self):
        # getting distribution.data_files
        if self.distribution.has_data_files():
            for item in self.distribution.data_files:
                if isinstance(item, str):
                    # plain file
                    item = convert_path(item)
                    if os.path.isfile(item):
                        self.filelist.append(item)
                else:
                    # a (dirname, filenames) tuple
                    dirname, filenames = item
                    for f in filenames:
                        f = convert_path(f)
                        if os.path.isfile(f):
                            self.filelist.append(f)

    def _add_defaults_ext(self):
        if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command('build_ext')
            self.filelist.extend(build_ext.get_source_files())

    def _add_defaults_c_libs(self):
        if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command('build_clib')
            self.filelist.extend(build_clib.get_source_files())

    def _add_defaults_scripts(self):
        if self.distribution.has_scripts():
            build_scripts = self.get_finalized_command('build_scripts')
            self.filelist.extend(build_scripts.get_source_files())

    def read_template(self):
        """Read and parse manifest template file named by self.template.

        (usually "MANIFEST.in") The parsing and processing is done by
        'self.filelist', which updates itself accordingly.
        """
        log.info("reading manifest template '%s'", self.template)
        template = TextFile(self.template, strip_comments=1, skip_blanks=1,
                            join_lines=1, lstrip_ws=1, rstrip_ws=1,
                            collapse_join=1)

        try:
            while True:
                line = template.readline()
                if line is None:            # end of file
                    break

                try:
                    self.filelist.process_template_line(line)
                # the call above can raise a DistutilsTemplateError for
                # malformed lines, or a ValueError from the lower-level
                # convert_path function
                except (DistutilsTemplateError, ValueError) as msg:
                    self.warn("%s, line %d: %s" % (template.filename,
                                                   template.current_line,
                                                   msg))
        finally:
            template.close()

    def prune_file_list(self):
        """Prune off branches that might slip into the file list as created
        by 'read_template()', but really don't belong there:
          * the build tree (typically "build")
          * the release tree itself (only an issue if we ran "sdist"
            previously with --keep-temp, or it aborted)
          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
        """
        build = self.get_finalized_command('build')
        base_dir = self.distribution.get_fullname()

        self.filelist.exclude_pattern(None, prefix=build.build_base)
        self.filelist.exclude_pattern(None, prefix=base_dir)

        if sys.platform == 'win32':
            seps = r'/|\\'
        else:
            seps = '/'

        vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr',
                    '_darcs']
        vcs_ptrn = r'(^|%s)(%s)(%s).*' % (seps, '|'.join(vcs_dirs), seps)
        self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)

    def write_manifest(self):
        """Write the file list in 'self.filelist' (presumably as filled in
        by 'add_defaults()' and 'read_template()') to the manifest file
        named by 'self.manifest'.
        """
        if self._manifest_is_not_generated():
            log.info("not writing to manually maintained "
                     "manifest file '%s'" % self.manifest)
            return

        content = self.filelist.files[:]
        content.insert(0, '# file GENERATED by distutils, do NOT edit')
        self.execute(file_util.write_file, (self.manifest, content),
                     "writing manifest file '%s'" % self.manifest)

    def _manifest_is_not_generated(self):
        # check for special comment used in 3.1.3 and higher
        if not os.path.isfile(self.manifest):
            return False

        fp = open(self.manifest)
        try:
            first_line = fp.readline()
        finally:
            fp.close()
        return first_line != '# file GENERATED by distutils, do NOT edit\n'

    def read_manifest(self):
        """Read the manifest file (named by 'self.manifest') and use it to
        fill in 'self.filelist', the list of files to include in the source
        distribution.
        """
        log.info("reading manifest file '%s'", self.manifest)
        with open(self.manifest) as manifest:
            for line in manifest:
                # ignore comments and blank lines
                line = line.strip()
                if line.startswith('#') or not line:
                    continue
                self.filelist.append(line)

    def make_release_tree(self, base_dir, files):
        """Create the directory tree that will become the source
        distribution archive.  All directories implied by the filenames in
        'files' are created under 'base_dir', and then we hard link or copy
        (if hard linking is unavailable) those files into place.
        Essentially, this duplicates the developer's source tree, but in a
        directory named after the distribution, containing only the files
        to be distributed.
        """
        # Create all the directories under 'base_dir' necessary to
        # put 'files' there; the 'mkpath()' is just so we don't die
        # if the manifest happens to be empty.
        self.mkpath(base_dir)
        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)

        # And walk over the list of files, either making a hard link (if
        # os.link exists) to each one that doesn't already exist in its
        # corresponding location under 'base_dir', or copying each file
        # that's out-of-date in 'base_dir'.  (Usually, all files will be
        # out-of-date, because by default we blow away 'base_dir' when
        # we're done making the distribution archives.)

        if hasattr(os, 'link'):        # can make hard links on this system
            link = 'hard'
            msg = "making hard links in %s..." % base_dir
        else:                           # nope, have to copy
            link = None
            msg = "copying files to %s..." % base_dir

        if not files:
            log.warn("no files to distribute -- empty manifest?")
        else:
            log.info(msg)
        for file in files:
            if not os.path.isfile(file):
                log.warn("'%s' not a regular file -- skipping", file)
            else:
                dest = os.path.join(base_dir, file)
                self.copy_file(file, dest, link=link)

        self.distribution.metadata.write_pkg_info(base_dir)

    def make_distribution(self):
        """Create the source distribution(s).  First, we create the release
        tree with 'make_release_tree()'; then, we create all required
        archive files (according to 'self.formats') from the release tree.
        Finally, we clean up by blowing away the release tree (unless
        'self.keep_temp' is true).  The list of archive files created is
        stored so it can be retrieved later by 'get_archive_files()'.
        """
        # Don't warn about missing meta-data here -- should be (and is!)
        # done elsewhere.
        base_dir = self.distribution.get_fullname()
        base_name = os.path.join(self.dist_dir, base_dir)

        self.make_release_tree(base_dir, self.filelist.files)
        archive_files = []              # remember names of files we create
        # tar archive must be created last to avoid overwrite and remove
        if 'tar' in self.formats:
            self.formats.append(self.formats.pop(self.formats.index('tar')))

        for fmt in self.formats:
            file = self.make_archive(base_name, fmt, base_dir=base_dir,
                                     owner=self.owner, group=self.group)
            archive_files.append(file)
            self.distribution.dist_files.append(('sdist', '', file))

        self.archive_files = archive_files

        if not self.keep_temp:
            dir_util.remove_tree(base_dir, dry_run=self.dry_run)

    def get_archive_files(self):
        """Return the list of archive files created when the command
        was run, or None if the command hasn't run yet.
        """
        return self.archive_files
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/upload.py0000644000175100001710000001665500000000000023271 0ustar00runnerdocker"""
distutils.command.upload

Implements the Distutils 'upload' subcommand (upload package to a package
index).
"""

import os
import io
import hashlib
from base64 import standard_b64encode
from urllib.request import urlopen, Request, HTTPError
from urllib.parse import urlparse
from distutils.errors import DistutilsError, DistutilsOptionError
from distutils.core import PyPIRCCommand
from distutils.spawn import spawn
from distutils import log


# PyPI Warehouse supports MD5, SHA256, and Blake2 (blake2-256)
# https://bugs.python.org/issue40698
_FILE_CONTENT_DIGESTS = {
    "md5_digest": getattr(hashlib, "md5", None),
    "sha256_digest": getattr(hashlib, "sha256", None),
    "blake2_256_digest": getattr(hashlib, "blake2b", None),
}


class upload(PyPIRCCommand):

    description = "upload binary package to PyPI"

    user_options = PyPIRCCommand.user_options + [
        ('sign', 's',
         'sign files to upload using gpg'),
        ('identity=', 'i', 'GPG identity used to sign files'),
        ]

    boolean_options = PyPIRCCommand.boolean_options + ['sign']

    def initialize_options(self):
        PyPIRCCommand.initialize_options(self)
        self.username = ''
        self.password = ''
        self.show_response = 0
        self.sign = False
        self.identity = None

    def finalize_options(self):
        PyPIRCCommand.finalize_options(self)
        if self.identity and not self.sign:
            raise DistutilsOptionError(
                "Must use --sign for --identity to have meaning"
            )
        config = self._read_pypirc()
        if config != {}:
            self.username = config['username']
            self.password = config['password']
            self.repository = config['repository']
            self.realm = config['realm']

        # getting the password from the distribution
        # if previously set by the register command
        if not self.password and self.distribution.password:
            self.password = self.distribution.password

    def run(self):
        if not self.distribution.dist_files:
            msg = ("Must create and upload files in one command "
                   "(e.g. setup.py sdist upload)")
            raise DistutilsOptionError(msg)
        for command, pyversion, filename in self.distribution.dist_files:
            self.upload_file(command, pyversion, filename)

    def upload_file(self, command, pyversion, filename):
        # Makes sure the repository URL is compliant
        schema, netloc, url, params, query, fragments = \
            urlparse(self.repository)
        if params or query or fragments:
            raise AssertionError("Incompatible url %s" % self.repository)

        if schema not in ('http', 'https'):
            raise AssertionError("unsupported schema " + schema)

        # Sign if requested
        if self.sign:
            gpg_args = ["gpg", "--detach-sign", "-a", filename]
            if self.identity:
                gpg_args[2:2] = ["--local-user", self.identity]
            spawn(gpg_args,
                  dry_run=self.dry_run)

        # Fill in the data - send all the meta-data in case we need to
        # register a new release
        f = open(filename,'rb')
        try:
            content = f.read()
        finally:
            f.close()

        meta = self.distribution.metadata
        data = {
            # action
            ':action': 'file_upload',
            'protocol_version': '1',

            # identify release
            'name': meta.get_name(),
            'version': meta.get_version(),

            # file content
            'content': (os.path.basename(filename),content),
            'filetype': command,
            'pyversion': pyversion,

            # additional meta-data
            'metadata_version': '1.0',
            'summary': meta.get_description(),
            'home_page': meta.get_url(),
            'author': meta.get_contact(),
            'author_email': meta.get_contact_email(),
            'license': meta.get_licence(),
            'description': meta.get_long_description(),
            'keywords': meta.get_keywords(),
            'platform': meta.get_platforms(),
            'classifiers': meta.get_classifiers(),
            'download_url': meta.get_download_url(),
            # PEP 314
            'provides': meta.get_provides(),
            'requires': meta.get_requires(),
            'obsoletes': meta.get_obsoletes(),
            }

        data['comment'] = ''

        # file content digests
        for digest_name, digest_cons in _FILE_CONTENT_DIGESTS.items():
            if digest_cons is None:
                continue
            try:
                data[digest_name] = digest_cons(content).hexdigest()
            except ValueError:
                # hash digest not available or blocked by security policy
                pass

        if self.sign:
            with open(filename + ".asc", "rb") as f:
                data['gpg_signature'] = (os.path.basename(filename) + ".asc",
                                         f.read())

        # set up the authentication
        user_pass = (self.username + ":" + self.password).encode('ascii')
        # The exact encoding of the authentication string is debated.
        # Anyway PyPI only accepts ascii for both username or password.
        auth = "Basic " + standard_b64encode(user_pass).decode('ascii')

        # Build up the MIME payload for the POST data
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = b'\r\n--' + boundary.encode('ascii')
        end_boundary = sep_boundary + b'--\r\n'
        body = io.BytesIO()
        for key, value in data.items():
            title = '\r\nContent-Disposition: form-data; name="%s"' % key
            # handle multiple entries for the same name
            if not isinstance(value, list):
                value = [value]
            for value in value:
                if type(value) is tuple:
                    title += '; filename="%s"' % value[0]
                    value = value[1]
                else:
                    value = str(value).encode('utf-8')
                body.write(sep_boundary)
                body.write(title.encode('utf-8'))
                body.write(b"\r\n\r\n")
                body.write(value)
        body.write(end_boundary)
        body = body.getvalue()

        msg = "Submitting %s to %s" % (filename, self.repository)
        self.announce(msg, log.INFO)

        # build the Request
        headers = {
            'Content-type': 'multipart/form-data; boundary=%s' % boundary,
            'Content-length': str(len(body)),
            'Authorization': auth,
        }

        request = Request(self.repository, data=body,
                          headers=headers)
        # send the data
        try:
            result = urlopen(request)
            status = result.getcode()
            reason = result.msg
        except HTTPError as e:
            status = e.code
            reason = e.msg
        except OSError as e:
            self.announce(str(e), log.ERROR)
            raise

        if status == 200:
            self.announce('Server response (%s): %s' % (status, reason),
                          log.INFO)
            if self.show_response:
                text = self._read_pypi_response(result)
                msg = '\n'.join(('-' * 75, text, '-' * 75))
                self.announce(msg, log.INFO)
        else:
            msg = 'Upload failed (%s): %s' % (status, reason)
            self.announce(msg, log.ERROR)
            raise DistutilsError(msg)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-10.0-amd64.exe0000644000175100001710000066200000000000000025105 0ustar00runnerdockerMZÿÿ¸@º´	Í!¸LÍ!This program cannot be run in DOS mode.

$¡,°åfBãåfBãåfBãv(ÚãâfBãŠéãÁfBãŠÜãîfBãìÁãçfBãìÅãäfBãìÑãêfBãåfCãDfBãŠèãhfBãŠØãäfBãŠßãäfBãRichåfBãPEd†ܯOð#
FÌá@àòÜ Àð Àe`@.textÌDF `.rdataLÑ`ÒJ@@.data„\@@À.pdata 4@@.rsrcðÀP@@H…Ét€9t¶€9/º\DˆHÿÁuæóÃÌÌÌH‰\$H‰l$H‰t$WHƒì I‹øH‹ÚH‹ñH…Ò„“€;„Šº\H‹Ëè˜|H‹ØH…ÀtuH‹ÎÆÿ4R‹èƒøÿu/3ÒH‹Îÿ*R…ÀuH…ÿtHJUHL‹Æÿ×ë
H‹Ö¹ÿ×@öÅu!¹·ÿýQH…ÿtHUL‹Æ¹ÿ×Æ\HÿÃ…mÿÿÿH‹\$0H‹l$8H‹t$@¸HƒÄ _ÃÌH‰\$H‰l$H‰t$WATAUHƒìPH‹œ$ E‹éM‹àH‹ú‹é¸…íºÀDèHƒd$0E3ÉE3ÀH‹ÏÇD$(€‰l$ ÿQH‹ðHƒøÿ…ÿQƒøuL‹ÃI‹ÔH‹Ïè«þÿÿ…Àu¦ëwƒøPt
‹Èÿ,QëFH…ÛtcH‹×¹ÿÓ…ÀtKHƒd$0E3ÉE3ÀºÀH‹ÏÇD$(€ÇD$ ÿ¥PH‹ðHƒøÿu)H…ÛtHHTL‹Ç¹ÿÓë
H‹×¹ÿÓ3ÀéÕH…Ût
H‹×¹ÿÓ·”$˜·Œ$LD$@ÿYPLL$@LD$@HT$@H‹ÎÿIPH‹ÎE…íuÿCPë§Hƒd$(E3É3ÒEAD‰l$ ÿ/PH‹ÎH‹èÿPHƒýÿuH…Û„rÿÿÿH…SéPÿÿÿHƒd$ E3ÉE3ÀAQH‹Íÿ÷OH‹ÍH‹ðÿÛOH…öuH…Û„3ÿÿÿH.SéÿÿÿH‹ÆL\$PI‹[ I‹k(I‹s0I‹ãA]A\_ÃH‰\$H‰l$WHì€A‹ùH‹ÚH‹éAƒø…Ô3ÒHL$ DBXèzGH‰\$ »‰D$(‹„$°L@SHL$ DKWSð‰D$8H‰l$0è2UH‹¼$¸…ÀtH…ÿt2HöRëHL$ ºèiW;ÃtH…ÿtH½RD‹À¹ÿ×3ÛHL$ è‹m…ÀtH…ÿtHRD‹À¹ÿ×3ÛH‹ÍÿšNLœ$€‹ÃI‹[I‹kI‹ã_ÃE…ÀuÙLc„$°è9z»ëÇÌÌH‰\$UVWATAUAVAWH¬$`ÿÿÿHì H‹z.H3ÄH‰…L‹­I‹ØE‹áA‹DúE+döE‹ùD+àL‹ÂH‰T$xAƒìA|êPKH‰L$HB L‰l$`t3Àé¶E3íD‰l$@fE;lôHcòHóHc~*B'LcðLó>PKuÉA>PKuÀ¿N ƒÂ.HcÂHÃH‰D$P¿FÈ¿FÐI¿FÑH;‰T$DI¿VHÐIcÄHÊHU€HDI‹ÈI+ÐH‰D$pŠˆ
HÿÁ„ÀuôHƒÉÿ3ÀH}€ò®HU€HÿÊH÷Ñ€|ÿ\H‰T$XtH}€HƒÉÿò®·HQf‰GÿHM€ÿ
MHcÈHD
€H‰D$hH‹D$HHƒ8t?L‹ÈI‹9H‹T$PHƒÉÿ3Àò®H÷ÑLAÿI‹	踅À„öIÿÅM‹ÍIÁáLL$HIƒ9uÄM¿FH‹T$PHM€èH|L‹l$XHM€è:úÿÿHƒÉÿ3ÀH}€ò®H‹|$hH÷ÑB€|)ÿ\L‹l$`tX·FD‹NL‰l$0f‰D$(·FHU€L‹Ç3Éf‰D$ èèúÿÿH…Àt*‹NE¿FD‹NH‹T$pL‰l$(‰L$ H‹Èèµüÿÿ…À„3þÿÿM…ítD‹L$@E¿DôH‹×AÿÁ¹AÿÕ‹L$@A¿DôÿÁ‰L$@;ȵ‹T$DL‹D$xE3íéþÿÿH‹T$HMíIƒÊÿJ‹<êN‹Dê3ÀI‹Êò®H}€H÷ÑLIÿI‹Êò®3ÒAŠHÿˆDþ„ÀuñL‹l$XE¿F3ÀH}€I‹ÊIcÑHT$Pò®E+ÁH÷ÑBŠD)ÿ<\t\éÅHÒNH‹Èÿ¡HH‰ú>LD$ H²NH‹Ëÿ\…À„‘Hƒ=Õ>t©3ÛH=*'H‹T$ H‹èMi…ÀtÿÃHƒÇƒû
räH‹
/lHPNëGHï&HcÃE3ÉHÀ3ÉD‹ÂHT$0ÿ}>…ÀtHT$0H
1NÿonëH‹
žoHïML‹D$ ÿt[3ÀH‹Œ$@H3ÌèByH‹œ$`HÄP_ÃÌH‰\$UH¬$@þÿÿHìÀH‹(H3ÄH‰…°Hƒe€Hƒd$hƒd$XHƒd$xHƒd$PHƒd$`3ÉH‹ÚÿUJ…ÀyHOH‹
oD‹ÀÿâZé¿HD$XLMLEˆH‰D$@HD$hHÏNH‰D$8HD$xH‹ËH‰D$0HE€H‰D$(HD$pH‰D$ ÿŒZ…Àu3Àé¿HD$P»L
ȌH
¡²3ÒD‹ÃH‰D$ ÿ±I…ÀyH>Né_ÿÿÿH‹L$PLD$`H0¡H‹ÿ…ÀyHðMé9ÿÿÿH‹L$PH‹UˆH‹ÿ …ÀyH®MéÿÿÿH‹L$PH‹UH‹ÿP8…ÀyHgMéøþÿÿH‹U€H…ÒtH‹L$PH‹ÿPX…ÀyH#MéÔþÿÿH‹T$hH…Òt#H‹L$PD‹D$XH‹ÿˆ…ÀyHÖLé§þÿÿH‹T$xH…ÒtH‹L$PH‹ÿPH…ÀyH‰Lé‚þÿÿL‹D$pHE AƒÉÿ3Ò3ÉÇD$(H‰D$ ÿÐEH‹L$`H‹HU D‹ÃÿP0…ÀyGL‹D$pH‹
FmHLD‹ÈÿYH‹L$`H…ÉtH‹ÿPH‹L$PH…ÉtH‹ÿPÿXHécþÿÿH‹L$`H‹ÿPH‹L$PH‹ÿPÿ7HH
KÿªkH‹°H3Ìè›vH‹œ$ÐHÄÀ]ÃÌÌL‹ÜHƒìHIKH‹ÂMK I‰KØMCèHËLH‹ÈÿvX…Àu3Àë-ÿðFD‹L$`L‹D$hH‹T$0H‹ÈÿàFH
‘L‹Ðÿ)kHƒÄHÃH‹
m"Hÿ%vhÌÌH‰\$H‰|$UH¬$PþÿÿHì°H‹ã$H3ÄH‰… H‹ÙLkHpLHÇD$ ÿ[FHèoH‹Ëÿ>DH…À…¡D‹
6jD‹ógHøKHL$0ÿFLL$ LE€HT$0HÇÁ€ÿúA…Àt#LL$ LE€HT$0HÇÁ€ÿÛA…Àt3Àë?3ÀHƒÊÿH}€H‹Êò®·HH‹Êf‰Gÿ3ÀH}€ò®3ÉŠHÿÁˆDþ„ÀuòHM€ÿ”CH‹ H3ÌèõtLœ$°I‹[I‹{ I‹ã]ÃH‰\$UVWATAUAVAWHƒì H%LH‹ÙÿTCHýKH‹ËH‹øÿACHÒKH‹ËL‹ðÿ.CH¯KH‹ËH‹ðÿCHŒKH‹ËL‹øÿCHaKH‹ËH‹èH‰D$hÿðBH9KH‹ËL‹àÿÝBHKH‹ËL‹èÿÊB3ÛH‰D$pH…ÿ„ÇH…ö„¾M…ö„µM…ÿ„¬H…í„£M…ä„šM…í„‘H
¥Jÿ×H‹øH…Àt[H„JH‹ÈÿÖHpJH‹ÏH‰>fÿÖH-¥!H‹õH‰ãiHcË3ÒHÁáHÍAÿ×H‹H‹ÏL‹ÀAÿÖÿÃHƒÆ ƒûrÚH‹l$hH‹D$pH‰-thL‰%…UH‰Æe3ÀL‰-}Uë¸H‹\$`HƒÄ A_A^A]A\_^]ÃÌ@USVWATAUAVAWHì˜Hl$ H‹"H3ÅH‰E`H‹ÚHÿJM‹áMcøH‹ñH‰Mÿ”AHÕJH‹ÎH‰Eÿ€AH©JH‹ÎL‹èÿmAH†JH‹ÎH‹øH‰E ÿVAHÇIH‹ÎL‹ðH‰Eÿ?AH‹MH¼IH‹ðÿ+AH‹MH€IH‰EÿAH‹MH[IH‰E(ÿA3ÉH9M„–M…í„H…ÿ„„M…ö„{H…ö„rH9M(„hH…À„_H9M„UH…Û„E8„=3ÒH‹Ëèõû‹ðƒøÿu èåƒH~IL‹ÃHH`èúFéH‹
ãfLDIºìÿ!CÿUH‹MèÕüÿÿH
®63ÒA¸è!k3ÛE…ÿ~0L5“6M+æIÜJ‹0H…Étèröÿÿë3ÀI‰ÞHÿÃI;ß|ÞL‹uL%c6A‹ÏI‹ÔAÿÕ3ÛE…ÿ~I‹ÜH…Étè5yHÿÃI;ß|êHU0‹Î»è‘}…ÀuMD‹EDA@HcÈHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðè"…H+à‹ÎH|$ H‹×è„…À~H˜H‹ÏfÇ8
ÿU ‹ØAÿÖ‹Îè²S‹Ãë¸ë¸H‹M`H3Íè¶pHexA_A^A]A\_^[]ÃÌH‰\$H‰l$H‰t$WATAUAVAWHƒìPIƒ!D‹òL‹ù3Ò3ÉI‹ñM‹è½èî$Hƒd$0E3ÉD‹ÅH‹ÈºÀÇD$(€€L‹àÇD$ ÿý>¿õÿÿÿH‹Ø‹Ïÿ==¹ôÿÿÿH‰„$˜ÿ*=H‹Ó‹ÏH‰D$@ÿ=H‹Ó¹ôÿÿÿÿ=H
QèÜùÿÿH‹øH…ÀtM‹ÍE‹ÆI‹×H‹Èè—üÿÿH‹Ï‹èÿÌ<ëèµH¾GHH`èÍH‹”$˜¹õÿÿÿÿª<H‹T$@¹ôÿÿÿÿš<3ÒH‹Ëÿ7=¿;Çs
3ÒH‹Ëÿ#=‹øGHcÈèæwE3íH‰H…ÀtDE3ÉE3À3ÒH‹ËD‰¬$˜ÿº=H‹LŒ$˜D‹ÇH‹ËL‰l$ ÿ¦=D‹œ$˜H‹Eˆ,H‹Ëÿî=I‹Ìÿ=L\$P‹ÅI‹[0I‹k8I‹s@I‹ãA_A^A]A\_ÃÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì L‹òH­FL‹áÿL=HÝFI‹ÌL‹èÿ9=HRFI‹ÌH‹Øÿ&=HOFI‹ÌH‹øÿ=H”FI‹ÌH‹èÿ=H‹ðM…ít;H…Ût6H…ÿt1H…ít,H…Àt'H
Õ`ÿÓAÿÕI‹ÌèXùÿÿI‹ÎÿÕ‹Ø…ÀtÿÖÿ׋ÃëƒÈÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A^A]A\ÃÌÌÌH‰\$H‰l$VWATAUAVHìàH‹ÐH3ÄH‰„$ÐH‹ù3Ò3ÉèM"Hƒd$0E3ÉEAºÀH‹ÈÇD$(€€L‹àÇD$ ÿ[<»õÿÿÿ‹ËH‹ðÿ›:½ôÿÿÿ‹ÍL‹èÿ‹:H‹Ö‹ËL‹ðÿu:H‹Ö‹Íÿj:H
kNèB÷ÿÿH‹ØH…Àu-ÿ<HÉEHL$PD‹ÀÿË=HL$PèñÿÿƒÈÿéìH‹×H‹Èè2þÿÿH‹Ë‹èÿ:I‹Õ¹õÿÿÿÿ:I‹Ö¹ôÿÿÿÿ÷9…í„ž3ÒH‹ÎÿŒ:‹ø¸ƒÿÿDøG-HcÈèDuH‹ØH…Àtgƒd$@HEH+Š
ˆHÿ„ÉuôE3ÉE3À3ÒH‹Îÿ;Hƒd$ HS,LL$@D‹ÇH‹Îÿõ:D‹\$@H‹ËAƒÃ,AÆèÃðÿÿH‹ËèGtëH
–Dè­ðÿÿH‹Îÿ ;I‹Ìÿ¿:‹ÅH‹Œ$ÐH3Ìè%lLœ$àI‹[8I‹k@I‹ãA^A]A\_^ÃÌH‰\$WHì`H‹äH3ÄH‰„$P3ÀH‹ú»…ÉtEH‰D$0‰D$(HD$@D‹ÁD‹Ë3Ò¹H‰D$ ÿÕ8H‹T$@HL$PD‹ÃèH‹L$@ÿ°8ëˆD$PHL$Pÿ/:L‹ÇHcÈH+ÙHLPH‹ÓèáH‹
º]LDHT$PA¹ÿú;3ÀH‹Œ$PH3Ìè@kH‹œ$€HÄ`_ÃÌÌÌL‹ÜI‰SM‰CM‰K VWHì8H‹ýH3ÄH‰„$ Is‹ùL‹ÂHL$ ºL‹Î蟂ÿÏ„ƒï„³ÿÏ„ˆÿÏtmÿÏt$ÿÏ…H‹
÷`H…É„«H§Cé’‹H‹
©_Hc~D·ÈE3ÀºAÁáÿ×;L‹Œ$XH‹
€_L‹Çºÿº;é³ÿ9HT$ ‹ÈèCþÿÿéœÿà:L-CHT$ H‹ÈA¹0ÿÍ:ëyH‹
\`H…ÉtHðBL‹„$XèzH‹Œ$Xº.èµ€H…ÀtBH=ÁBH‹ð¹ó¦u/H‹Œ$Xè|îÿÿë H‹
`H…ÉtL‹„$XHwBèÂy¸H‹Œ$ H3Ìè•iHÄ8_^ÃÌÌÌH‹ÄH‰XH‰hH‰p WHƒì@Hƒ`èE3ÉH‹òÇ@à€EAº€Ç@Øÿ8H‹ØHƒøÿu3ÀëiHT$`H‹Èÿá6Hƒd$(ƒd$ E3É3ÒH‹ËEA‹èÿú7H‹ËH‹øÿæ7Hƒÿÿt½Hƒd$ E3ÉE3ÀAQH‹Ïÿ×7H‹ÏH‹Øÿ»7‰.H‹ÃH‹\$PH‹l$XH‹t$hHƒÄ@_ÃÌH‰\$WHƒì0Hƒ=öJH‹ùtQHƒ=ñ^uGÿá9L‹ÚJƒd$(E‹H
IPH‹ÈMÈA¸H‹ØH‰T$ ÿS5H‹ÓH‹ÏH‰®^ÿ¨9H‹\$@HƒÄ0_ÃÌ@SUVWATAUAVHì`H‹#H3ÄH‰„$PL‹¬$À‹ÂE3ö+TúM‹á+TöM‰uM‰1ƒê"HcÚHÙ|êPK…;{V4tH#A3ÉèÔûÿÿéþ…ÒˆôD9stHcCH‹ËH+ÈHcCH+ÈH‰
ùI+SH{½+‹ÍA‰HcH+ØèpH‹ðH…À„¬HT$@‹Íÿª4…À„ƒH£@HL$@L‹ÎE3Àÿ‚4…ÀtgD‹E3ÀL‰t$0AHH‹ÖfD‰t$(fD‰t$ è{äÿÿH‹èH…ÀtPLcH‹ÓH‹Èè}|HƒÉÿ3ÀH‹ýò®H÷ÑHË觺H‹ÍI‰EI‰4$ÿ®5¸ëÿ±5Hú?‹ÈèÓúÿÿ3ÀH‹Œ$PH3ÌèÉfHÄ`A^A]A\_^][ÃÌÌÌHƒìhëHL$0ÿÓ7HL$0ÿÐ7HL$0E3ÉE3À3ÒÇD$ ÿ½7…ÀuËHƒÄhÃ@SUVWHìØH‹QH3ÄH‰„$ÀH‹éƒútÿX7é&HT$pÿP7¹H‹ðÿJ7E3ɋиgfffE3À÷ê‹Â3ÒÁø‹ÈÁéÁH
~?H‰L$h3ɉL$`‰L$X‰L$P‰L$H‰L$@‰L$8‰L$0‹ÈÇD$(ÇD$ ¼ÿƒ2H‹ÎH‹Ðÿ2ºH‹ÎH‹Øÿv2HƒÉÿ3ÀH=±CL
ªCò®PH÷ÑD‹ÂHÿɉL$ H‹ÎÿO2ºÿÿÿH‹ÎÿI2HƒÉÿ3ÀP
H=qCL
jCò®D‹ÂH÷ÑHÿɉL$ H‹Îÿ2H‹ÓH‹Îÿö1H‹Èÿ
2HT$pH‹ÍÿG63ÀH‹Œ$ÀH3Ìè
eHÄØ_^][ÃÌH‰\$H‰t$UWAUH¬$@ðÿÿ¸ÀèyH+àH‹ÆH3ÄH‰…°HQþÿÿH‹Ù3ö3ÉÇD$`H‰D$hH‰t$pÿÞ1º3ÉH‰u€H‰D$xÿx5¹€H‰Eˆÿq1L-B>HL$`L‰m H‰u˜H‰EÿS5f…ÀuH‹
§VL>Há=E3Éÿè4HÁ=HM°L‹ÃÿÄ43Éÿ\1¹H‹Øÿ65¹‹øÿ)5H‰t$XH‰\$PH‰t$HH‰t$@‰|$8‰D$0LE°E3ÉI‹Õ3ɉt$(‰t$ ÿË4H‹ÈºH‹ØÿÂ4H‹ËÿÁ4H‹ÃH‹°H3Ìè§cLœ$ÀI‹[(I‹s0I‹ãA]_]ÃÌÌÌH‰\$WHƒìPH‹kH3ÄH‰D$@HT$0H‹ùÿ=43Éÿ}4¹‹Øÿp4D‹T$0‹L$"‹Èéž‹­H
ÚL
Û2H‰L$ LïH‹Èè3Ôÿÿ…Àt	HƒÄ8éfüÿÿHƒ=²2u‹
†	ƒù~H‹~	HƒÄ8éðÿÿH
6º\èSH…Àt%HÿÀt H¯!A¸H‹Èè=ƒHn!…ÀtH;!3ÉèüÏÿÿ¸HƒÄ8ÃÌÌH‰|$D‹ÉL‹ÚD·ÑAÁéAƒøu,¶¹ñÿDиÿÿD;ÑrDÐEÊD;É‚…DÈé}H…ÒuBézAƒøsFE…ÀtA¶IÿÃDÐEÊAÿÈuî¹ñÿD;Ñr¸ÿÿDиq€€A÷áÁêkÒAÁàAÂé.¹q€€Aø°‚ÿ¸¯©n^A÷àÁê‹úAÀPêÿÿº[A¶IƒÃDÐA¶CñEÊDÐA¶CòEÊDÐA¶CóEÊDÐA¶CôEÊDÐA¶CõEÊDÐA¶CöEÊDÐA¶C÷EÊDÐA¶CøEÊDÐA¶CùEÊDÐA¶CúEÊDÐA¶CûEÊDÐA¶CüEÊDÐA¶CýEÊDÐA¶CþEÊDÐA¶CÿEÊDÐEÊÿÊ…Eÿÿÿ‹ÁA÷â‹ÁÁêiÒÿÿDÒA÷áÁêiÒÿÿDÊHÿÏ…ÿÿÿE…À„
Aƒø‚ÇA‹ÐHÁêA¶AƒÀðIƒÃDÐA¶CñEÊDÐA¶CòEÊDÐA¶CóEÊDÐA¶CôEÊDÐA¶CõEÊDÐA¶CöEÊDÐA¶C÷EÊDÐA¶CøEÊDÐA¶CùEÊDÐA¶CúEÊDÐA¶CûEÊDÐA¶CüEÊDÐA¶CýEÊDÐA¶CþEÊDÐA¶CÿEÊDÐEÊHÿÊ…@ÿÿÿE…ÀtA¶IÿÃDÐEÊAÿÈuî‹ÁA÷â‹ÁÁêiÒÿÿDÒA÷áÁêiÒÿÿDÊAÁáEÊA‹ÁH‹|$ÃÌÌH‰\$D‹ÒA‹ØD‹ÙAÁë¸q€€A÷àD·ÁA·ÊÁêE‹ÈAÁêE„ðÿ¸q€€¹ÿÿiÒñÿ+ÚD¯ËA÷áÁêiÒñÿD+ÚºñÿEÚD+ÛC„ñÿD;ÂrDÁD;ÂrDÁ=âÿrþÿ;ÂrÁH‹\$ÁàAÀÃÌÌé_ÿÿÿÌÌÌéWÿÿÿÌÌÌH!ÃH‰\$H‰t$H‰|$D‹ÑE‹ØH‹ÚH5A÷ÒE…Àt#öÃt¶A‹ÂHÿÃH3ÈÁè¶ÑD‹–D3ÐAÿËuÝAƒû ‚!A‹ûHÁïD3A‹ÂHÁè¶ÐA‹ÂD‹„–HÁè¶ÈA‹ÂD3„ŽHÁèD3†A¶ÂD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CA‹ÀE‹ÈHÁè¶ÐA‹ÀHÁèD‹„–¶ÈA‹ÁD3„ŽHÁèHƒÃ D3†A¶ÁAƒÃàD3„†D3CøE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CüA‹ÀHÁè¶ÐA‹ÀD‹”–HÁè¶ÈA‹ÀD3”ŽHÁèD3†A¶ÀD3”†HÿÏ…æýÿÿAƒûrUE‹ËIÁéD3AƒÃüHƒÃE‹ÂA‹ÂHÁè¶ÐA‹ÂD‹”–HÁè¶ÈA‹ÀD3”ŽHÁèD3†A¶ÀD3”†IÿÉu²E…Ût¶A‹ÂHÿÃH3ÈÁè¶ÑD‹–D3ÐAÿËuâH‹\$H‹t$H‹|$A÷ÒA‹ÂÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x D‹Ñ½ÿ‹ÁD#ÕÁàE‹ØDЋÁÁéAÁâÁèH5Ø#ÅDÐDÑA÷ÒE…Àt+öÂt&¶A‹ÊHÿÂHÁéH3ÈA‹ÂD‹”ŽÁàD3ÐAÿËuÕHZüAƒû ‚AA‹ûHÁïD3SA‹ÂHÁè¶ÐA‹ÂD‹„–HÁè¶ÈA‹ÂD3„ŽHÁèD3„†A¶ÂD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CA‹ÀE‹ÈHÁè¶ÐA‹ÀHÁèD‹„–¶ÈA‹ÁD3„ŽHÁèHƒÃ D3„†A¶ÁAƒÃàD3„†D3CüE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈA‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3A‹ÀHÁè¶ÐA‹ÀD‹”–HÁè¶ÈA‹ÀD3”ŽHÁèD3”†A¶ÀD3”†HÿÏ…ÆýÿÿAƒûrYE‹ËIÁéHƒÃAƒÃüD3E‹ÂA‹ÂHÁè¶ÐA‹ÂD‹”–HÁè¶ÈA‹ÀD3”ŽHÁèD3”†A¶ÀD3”†IÿÉu®HƒÃE…Ût&¶A‹ÊHÿÃHÁéH3ÈA‹ÂD‹”ŽÁàD3ÐAÿËuÚH‹\$H‹t$H‹|$ A÷ÒA‹ÂA‹Ê#ÅÁáÁA‹ÊAÁêÁàÁé#ÍH‹l$ÁAÂÃÌÌÌ3À…ÒtöÂt3HƒÁÑêuñóÃÌHƒì(L‹ÊL‹ÒL‹ÁL+ÉA» C‹I‹ÊèÆÿÿÿA‰IƒÀIÿËuèHƒÄ(ÃÌH‹ÄH‰XH‰pH‰xUHhÈHì0H‹VàH3ÄH‰E A‹ø‹ò‹ÙE…ÀŽ‡¹ÇD$  ƒ¸í‹Á‰L„ HÿÀÉHƒø |ñHT$ HM ègÿÿÿHU HL$ èYÿÿÿHT$ HM èKÿÿÿ@öÇt
HM ‹Óè"ÿÿÿ‹ØÑÿt&HU HL$ è&ÿÿÿ@öÇtHL$ ‹Óèüþÿÿ‹ØÑÿuµ3Þ‹ÃH‹M H3Ìèº0Lœ$0I‹[I‹sI‹{ I‹ã]ÃÌéÿÿÿÌÌÌéÿÿÿÌÌÌH…Òu3ÀÃéøÿÿÌÌÌ@SUVWATAUAVAWHƒì8H‹i(D‹qH‹9L‹AL‹MXH‹u`D‹m4‹]@D‹UDL‹á‹IIÿÈ+ÑD¹ÿþÿÿ‹Mh‹ÂI‹ÐHÿÏH+ЋE,AƒÆû‰„$€‹E0H‰T$‰„$˜H‹E8ºH‰D$¸L÷Óà‹MlMøÓâÿÈL‰L$ÿÊH‰4$‰”$‹ÐH‰T$ Aƒús¶GA‹ÊHƒÇÓàAJضÓàØAƒÂ‹ÃH#Âë"öÂuGöÂ@…ڋʸAÁëÓàÿÈ#ÃAÃE‹A‹ÃA¶ÓÁè¶ÈÓëD+ÑE„ÛuÃIÿÀAÁëEˆéˆAÁëƒât+D;ÒsHÿÇA‹Ê¶ÓàØAƒÂ‹Ê¸ÓàÿÈ#ÃÓëDØD+ÒAƒús¶GA‹ÊHƒÇÓàAJضÓàØAƒÂ‹Œ$‹ÃH#È‹4Žë'öÂ@…A·„$Š‹ÊºÓâH‹$ÿÊ#ÓЋ4‘‹Æ@¶Ö‰´$ˆÁè¶ÈÓëD+ÑöÂt¼ƒâÁîD;Òs'HÿÇA‹ÊAƒÂ¶ÓàØD;ÒsHÿÇA‹Ê¶ÓàØAƒÂ‹Ê¸D+ÒÓàÿÈ#ÃÓëðA‹À+D$;ð†-‹Î+È;Œ$˜v
ƒ½Ø… H‹T$LJÿE…íu*‹„$€+ÁLÈA;˃‰D+ÙIÿÁIÿÀÿÉAŠAˆuðëlA‹Å+ÁD;ésG„$€A+ÍLÈA;ËsXD+ÙM+ÈIÿÀÿÉCŠAˆuòLJÿE;ës;A‹ÍE+ÝIÿÁIÿÀÿÉAŠAˆuðëLÈA;ËsD+ÙIÿÁIÿÀÿÉAŠAˆuð‹ÆM‹ÈL+ÈAƒûv7AKý¸«ªªª÷áÑêJAŠAIƒÁIƒÀAˆ@þAŠAÿAƒÃýHÿÉAˆ@ÿAŠAˆuÙE…ÛtuAŠAH‹4$IÿÀAˆAƒûv
AŠAIÿÀAˆL‹L$ëY‹ÆI‹ÈH+ÈŠAHƒÁIƒÀAˆ@þŠAÿAƒÃýAˆ@ÿŠAˆAƒûwÛE…Ût#ŠAH‹4$IÿÀAˆAƒûvŠAIÿÀAˆë	L‹L$H‹4$I;þsBM;Çs=H‹T$ éíüÿÿö t	ÇEë%H•2ëHt2ëHK2I‰D$ ÇEA‹ÊE+øÁéAÇ‹ÁE‰|$H+ø‹ÁÁàD+÷D+ÐHGAƒÆI‰$I@E‰t$I‰D$¸A‹ÊÓàD‰UDÿÈ#ÉE@HƒÄ8A_A^A]A\_^][ÃÌÌ3ÀH…ÉtaH‹Q(H…ÒtX‰B‰A‰AH‰A D@D‰ALƒŠÜÿH‰‰BH‰B H‰B,‰B4H‰B@H‚HH‰‚€H‰B`H‰BX3ÀÇB€D‰‚ØøþÿÿÿÃÌÌH‰\$H‰l$H‰t$WHƒì ‹ÚH‹ñH…ÉtZH‹y(H…ÿtQ…Òy3í÷Ûë‹êÁýÿŃú0}ƒã…Ût
ƒû|/ƒû*H‹W8H…Òt9_(tH‹I@ÿV8Hƒg8H‹Î‰o‰_(èÿÿÿë¸þÿÿÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$H‰t$WHƒì ‹úH‹ÙM…À„ŸA€81…•AƒùX…‹H…ÉuAþéƒHƒa Hƒy0uHƒa@Hò!H‰A0H‹A8H
ï!ºHƒøA¸èHDÁH‹K@H‰C8ÿS0H‹ðH…ÀuFüë1H‰C(Hƒ`8‹×H‹ËèÉþÿÿ‹ø…ÀtH‹K@H‹ÖÿS8Hƒc(‹Çë¸úÿÿÿH‹\$0H‹t$8HƒÄ _ÃÌÌÌE‹ÈL‹ÂºéÿÿÿE‹ØH…ÉtJL‹I(M…ÉtA…Òy
Aƒa@AƒaD3ÀÃú+E‹ADEAƒú w‹Ê¸E‰QDÓàA‹ÈÿÈA#ÃÓàAA@ë͸þÿÿÿÃHñ/ÇAh	ÇAlH‰AXHØ7H‰A`ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì H‹Y(E3ä‹êH‹ñ¿L9c8u!‹K(‹×D‹ÇÓâH‹N@ÿV0H‰C8H…Àu‹ÇéD9c,u‹K(L‰c0Óç‰{,+n‹{,H‹V;ïrH‹K8D‹ÇH+×èÀ#D‰c4‹C,ëS+{4‹K4‹Å;ýGýHK8H+ÐD‹Çè›#+ïtH‹VH‹K8D‹ÅI+Ðè„#‰k4ëÃ{4‹C4‹K,;ÁADĉC4‹C0;ÁsljC03ÀH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A\ÉT$USVWATAUAVAWH‹ìHƒìXE3Û‹ÚL‹ñH…É„ÃH‹y(H…ÿ„¶L9Y„¬L9u
D9Y…‹D‹g@‹wDƒø¹D‰]HDÁ‰E‹NM‹VM‹.E‹~L‰UðD‰MXL‰mèD‰}àE‹ÁD‰M`º¸‹ƒùC	„å;È8„·…É„ŠÿÉt`ÿÉ„øÿÉ„vÿÉ„ÌÿÉ„äÿÉ„ê¸þÿÿÿHƒÄXA_A^A]A\_^[]ÃE…ÿ„àA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆ;òrÚD‰gA€ütHÜ7é`A÷ÄàtH§7éKH‹O H…ÉtA‹ÄÁèƒà‰÷Gt$DˆeØAÁìHUØDˆeÙ‹OA¸è§öÿÿE3Û‰GE‹ãA‹óÇë"E…ÿ„@A¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆƒþ rÙH‹G H…ÀtD‰`÷Gt6A‹ÄDˆeØHUØÁèA¸ˆEÙA‹ÄAÁìÁèDˆeÛˆEÚ‹Oè&öÿÿE3Û‰GE‹ãA‹óǺë"E…ÿ„ºA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆ;òrÚH‹O H…ÉtA¶Ä‰AH‹G A‹ÌÁé‰H÷Gt(DˆeØAÁìHUØDˆeÙ‹OA¸è£õÿÿE3Û‰GASE‹ãA‹óÇ÷G…‚H‹G H…ÀtL‰XÇ÷G„÷‹_HA;ßAGß…Û„ÛH‹G H…À„¢L‹HM…É„•‹P‹H+WH;Ávs+ÊëqE…ÿ„ÍA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆ;òrÚH‹G D‰gHH…ÀtD‰`÷Gt$DˆeØAÁìHUØDˆeÙ‹OA¸èÂôÿÿE3Û‰GE‹ãA‹óé>ÿÿÿ‹ËD‹Á‹ÊI‹ÕIÉè¯÷Gt‹OD‹ÃI‹Õèˆôÿÿ‰G)_H‹ÃD+ûLèE3ÛL‰mèD9_H…D‰_HÇ÷GtyE…ÿ„A‹ÛM‹ÅH‹G E¶(ÿÃIÿÀH…ÀtH‹P H…Òt‹OH;H(sDˆ,ÿGHE…ítA;ßrÌ÷GtH‹Uè‹OD‹ÃèûóÿÿE3Û‰G‹ÃD+ûHEèE…í…™L‹mèë
H‹G H…ÀtL‰X D‰_HÇ÷G„1E…ÿtjA‹ÛM‹ÅH‹G E¶(ÿÃIÿÀH…ÀtH‹P0H…Òt‹OH;H8sDˆ,ÿGHE…ítA;ßrÌ÷GtH‹Uè‹OD‹ÃèbóÿÿE3Û‰G‹ÃD+ûHEèE…í„ÏD‹mHH‹Eð‹]`E‰~I‰F‹EXA‰FH‹EèI‰‰wD3öD‰g@9w,uƒ?|A;^„r‹ÓI‹ÎèÎùÿÿ…À„`ÇéSD9_u)Çé9ûÿÿE…ÿt‹A¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆ;òrÞöGtRAü‹uIE3À3Ò3ÉèòÿÿHUØA¸‰GfD‰eØ‹OèƒòÿÿljGE3ÛA‹óE‹ãD‹E`D‹MXL‹UðéºúÿÿH‹G D‰_H…ÀtƒH@ÿöG„§A¶ÌA‹ÄÁèÁáȸ…B÷á‹Á+ÂÑèÂÁèkÀ;ÈuzA‹Ä$<tHí2I‰F ÇéXúÿÿAÁìƒÆüA‹ÌƒáƒÁD9_(u7‰O(¸E3À3ÒÓà3ɉGègæÿÿAÁìA÷Ô‰GA‰FLAƒäAƒÌ	D‰'é7ÿÿÿ;O(vÇHM2ë–ºH'2I‰F ÇéçùÿÿH‹G H…ÀtL‰X0L‹mèD‹E`D‹MXL‹Uð‹]PǺ÷G„¦é‚ƒétéÿÉ„ÿÉ„SÿÉ„ÿÉ„‹ÿÉt
ÿÉ…Ñùÿÿëg‹ÎƒáAÓì+ñë"E…ÿ„¹ýÿÿA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆƒþ rÙA‹ÄA·Ì÷ÐÁè;ÈtH>1é2ÿÿÿ‰OHE‹ãA‹óǃû„gýÿÿǸD‹oHE…í„<E;ïEGïE;éEGéE…í„8ýÿÿH‹UèE‹ÅI‹ÊA‹Ýè€H]èD‹MXL‹UðE+ýE+ÍLÓD)oHL‹mè‹]PD‰MXL‰UðéÚE…ÿ„ðüÿÿA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆƒþ rÙA‹ÌA‹ÄºÿÁà#ÊA‹óÈA‹ÄAÁìÁèÁá#ÂÁAÄE‹ã‰GA‰FLÇ
D9_„
E3À3Ò3ÉèeäÿÿD‹E`D‹MXL‹UðE3Û‰GA‰FLÇASƒû„Züÿÿƒû„QüÿÿD9_t;‹Î¸Ç#ÈAÓì+ñéà÷ÿÿE…ÿ„)üÿÿA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆƒþrÙA‹ÄAÑìÿ΃à‰GA‹ÄƒàtBÿÈtÿÈtÿÈuóÿÿHF$é¼òÿÿƒét±ÿÉ„MÿÉt*ÿÉ„îÿÉ„ÿÉ„èÿÉ…Oíÿÿ¸üÿÿÿéJíÿÿD9_„¼ë"E…ÿ„/ñÿÿA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆƒþ rÙE+ÁEFDGE…Àt4‹OA‹ÀI‹ÒH+ÐD9_tè4äÿÿëèÅØÿÿD‹MXL‹UðE3Û‰GASA‰FLA‹ÌA‹ÄE‹ÁÁàáÿD‰M`ÈA‹ÄÁèÁá%ÿÈA‹ÄÁèÈD9_AEÌ;OtH3#é7òÿÿE‹ãA‹óÇD9_„D9_„ë"E…ÿ„YðÿÿA¶E‹ÎIÿÅÓàAÿÏL‰mèDàƒÆƒþ rÙD;g„ÎH¼"éØñÿÿE…É„ðÿÿŠGHAˆIÿÂAÿÉD‰MXL‰UðÇé¦ëÿÿ‹G4;Èv	‹W,+È+Ñë+Á‹Ð‹GHHW8;Èv
ë	‹GHI‹ÒH+Ñ‹ÈA;ÉAGÉD+É+ÁI+ÒD‰MX‰GHBŠAˆIÿÂÿÉuòL‰UðQAD9_H…GëÿÿÇé<ëÿÿM‰VE‰NM‰.E‰~¸D‰g@‰wDétëÿÿA½ýÿÿÿégïÿÿE‹ãA‹óÇA½éPïÿÿA+^D‹MàE+NA^EN_D‰Mà9wt/…Ût+I‹V‹O‹ÃH+ÐD‹Ã9wtèYâÿÿëèêÖÿÿD‹Mà‰GA‰FLƒ?tƒ?D‹ÆuA¸‹G‹Ö÷ظ€Ƀá@ƒ?DÐAÐWDA‰VHE…Éu…Ûtƒ}Pu¸ûÿÿÿE…íDDèA‹Åé©êÿÿÌ@SHƒì H‹ÙH…Ét6H‹A(H…Àt-L‹A8M…Àt$H‹P8H…ÒtH‹I@AÿÐH‹S(H‹K@ÿS8Hƒc(3Àë¸þÿÿÿHƒÄ [ÃÌH‰\$H‰l$H‰t$WHƒì A‹ðH‹êH‹ùH…ÉtH‹Y(H…Ûtƒ{tƒ;
t¸þÿÿÿH‹\$0H‹l$8H‹t$@HƒÄ _Ã;
u%E3À3Ò3ÉèÓÕÿÿD‹ÆH‹Õ‹ÈèÆÕÿÿ;Ct¸ýÿÿÿëÁ‹WH‹Ïèççÿÿ…Àt
Ǹüÿÿÿë¥H‹K8;s,vD‹C,H‹ÖI+ÐHÕèûD‹[,D‰[0ë‹C,H+ÎL‹ÆHÈH‹Õè݉s0ÇC3Àé[ÿÿÿH…ÉtH‹A(H…Àtö@tH‰P ƒb@3ÀøþÿÿÿÃÌÌÌD‹	E3ÒL‹ÙE…ÀttT‹VDE3ÀNjʃáÓf@+щVDƒúr%‹N@LL$0ŠF@ƒÂøÁéAˆIÿÁAÿÀ‰N@‰VDƒúsãHN|HT$0ƒ!èÿÿÿD‹GH‹HN|èÿÿÿG)GD‹W‹ÈHƒ~|t¸ýÿÿÿë#D‹OH‹ÏèÙãÿÿD‰WD‰OÇ3Àë¸þÿÿÿH‹\$8H‹t$@HƒÄ _ÃÌÌ3ÀH…ÉtH‹I(H…Étƒ9
u9ADu¸øþÿÿÿÃÌÌH‰\$H‰l$H‰t$WATAUHƒì H‹ÚL‹áH…É„=H…Ò„4H‹z(H…ÿ„'H‹B0H…À„Hƒz8„H‹K@A½A¸èA‹ÕÿÐH‹ðH…Àu
¸üÿÿÿéí3íH9o8t&‹O(A‹ÕE‹ÅÓâH‹K@ÿS0H‹èH…ÀuH‹K@H‹ÖÿS8ëÈI‹ÌH‹ÓA¸Xèu	A¸èH‹×H‹Îèd	L‹_XH‡H¹HL;ØrM…ÿuèÂ\Çè¯L€}øéäE…ítAƒý|ÜAƒý$ÖEŠ'L‹Eà3ÿI_Aƒ¸~LEàA¶ÌºèpL‹EàëI‹€@A¶Ì·Hƒà…ÀtDŠ#HÿÃëÀ‹uPA€ü-uƒÎëA€ü+uDŠ#HÿÃE…íˆWAƒý„MAƒý$CE…íu(A€ü0tA½
ë8€;xt
€;XtA½ë&A½ëAƒýuA€ü0u€;xt€;XuDŠcHƒÃM‹@3ÒƒÈÿA÷õD‹ÈA¶ÌE·JA‹Èƒát	A¾Ìƒé0ëAàt.AD$ŸA¾Ì<wƒé ƒÁÉA;ÍsƒÎA;ùr"u;ÊvƒÎM…öuHÿË@öÆuM…öIEß3ÿë\A¯ýùDŠ#HÿÃëA¼ÿÿÿ@öÆu@öÆu<‹Æƒàtÿ€w	…Àu)A;üv$è[Ç"@öÆtƒÏÿë@ŠÆ$öØÿ÷ßAüM…ötI‰@öÆt÷߀}øtH‹Mðƒ¡Èý‹ÇëM…ötM‰>@8}øtH‹Eðƒ Èý3ÀL\$@I‹[0I‹s@I‹{HI‹ãA_A^A]A\]ÃÌHƒì83ÀE‹ÈL‹Â9žÌ‰D$ H‹Ñu	H
·ë3ÉèiýÿÿHƒÄ8ÃHƒì8ƒd$ I‹ÁE‹ÈL‹ÂH‹ÑH‹ÈèGýÿÿHƒÄ8ÃÌÌHƒì8ƒ=QÌE‹ÈL‹ÂH‹ÑÇD$ u	H
¯¶ë3ÉèýÿÿHƒÄ8ÃÌHƒì8I‹ÁE‹ÈL‹ÂH‹ÑH‹ÈÇD$ èìüÿÿHƒÄ8ÃÌÌÌH…Ét7SHƒì L‹ÁH‹
ôË3Òÿ<Ç…ÀuèÇYH‹ØÿªÆ‹ÈèoY‰HƒÄ [ÃÌÌÌ@SHƒì H‹ÙH‹
¸ËH…Éu è‚‚¹è€¹ÿè¶?H‹
“ËH…ÛA¸LEÃ3ÒHƒÄ [Hÿ%ÐÆH‰\$H‰t$WHƒì H‹ÙHƒùàw|¿H…ÉHEùH‹
MËH…Éu 肹譹ÿèK?H‹
(ËL‹Ç3ÒÿuÆH‹ðH…Àu,9GÑtH‹Ëè‚…Àt
ë«èÞXÇèÓXÇH‹Æëèg‚è¾XÇ3ÀH‹\$0H‹t$8HƒÄ _ÃÌÌH‰\$UVWATAVH‹ìHƒì0HƒeHƒ=1ïH‹òH‹ùuƒÈÿé@H…ÉuèkXÇèXHëáH…Òu_Dr=A‹Öè1H…Àt H‹È»ÿH+ÏH;Ë}ÈHH‹Óè	H;Ãs¸H‹ÏèTŽºHHH‹Ø蛌H‰EHH…Àt‰L‹ÇHSH‹Èëz»ÿ‹ÓèÊŽ‹ÓH‹ÎL‹à轎L;ãƒhÿÿÿH;Ã_ÿÿÿJ\ ºH‹ËèIŒH‰EHH…À„3ÿÿÿL‹ÇH‹ÓH‹Èè‹H‹EHA¾=Eˆ4H‹EHIÿÄI+ÜL‹ÆIH‹ÓèëŠHMHºèA‡…ÀtH‹MHH…É„ßþÿÿèkýÿÿéÕþÿÿHƒ=¶Â„
ƒd$(Hƒe@Hƒd$ ƒËÿL‹Ç3ÒD‹Ë3ÉÿåÃD‹à…ÀuèWÇ*‹ÃéÓH…öt$ƒd$(Hƒd$ D‹ËL‹Æ3Ò3Éÿ¬Ã…ÀtÊEdIc̺è^‹H‰E@H…ÀtºD‹ËL‹Ç3Ò3ÉD‰d$(H‰D$ ÿsÃ…ÀuH‹M@è¶üÿÿë†H…öt>H‹M@è>…H‹M@D‹ËfD‰4AH‹M@HÿÀD+àHAL‹Æ3Ò3ÉD‰d$(H‰D$ ÿ%Ã…Àt²HM@3ÒèB…ÀtH‹M@H…É„2ÿÿÿèPüÿÿé(ÿÿÿ3ÀH‹\$`HƒÄ0A^A\_^]Ã@SHƒì H‹Ù¹è)’3ÒH‹Ëèbýÿÿ‹Ø¹èò‹ÃHƒÄ [ÃÌÌH‰\$H‰t$WHƒì H‹úH‹ñ3Û‹ÃH…Ò•À…ÀuèÈU»‰è´E‹Ãë-¹èÆ‘H‹×H‹Îèþüÿÿ…Àtè™U‹¹è…ëÏH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰t$ WATAUAVAWHì H‹k¢H3ÄH‰„$˜H‹úHcñ‰t$L3Û‹ÃH…Ò•À…ÀuèOU‰è(UÇé"3ÒDB0H‹Ïè³ìÿÿƒþþuè%U‰èþTÇ	éý…öˆÞ;5eéƒÒL‹æL‹îIÁýL=béAƒäMkäXK‹ïB¾L A¾A#΄ ‹Îèf“K‹ïF„t!uè•TÇ	éoJ‹!ÿºðA;Æ„”ƒøt ƒøt…ÀtËÿKÁ‹Èè˜Té8ƒøu¹ ë¹f‰O‰7‰wfD‰wf‰_‰_
H‰_(H‰_ H‰_ƒøu‰_éüK‹ïH‰\$(HD$HH‰D$ E3ÉE3À3ÒJ‹!ÿƒÁ÷ØÉ#L$H‰Oélj_
‰_fD‰wK‹ïHT$`J‹!ÿMÁ…À„Tÿÿÿ·GD„t$`t
$ë
¶f‰G9\$tu9\$xuH‰_ ëhHT$@HL$tÿÁ…À„YHT$PHL$@ÿàÀ…À„A·D$\D·T$ZD·L$XD·D$V·T$R·L$PƒL$0ÿ‰D$(D‰T$ 輕H‰G 9\$lu9\$puH‹G ëdHT$@HL$lÿ†À…À„ßHT$PHL$@ÿfÀ…À„Ç·D$\D·T$ZD·L$XD·D$V·T$R·L$PƒL$0ÿ‰D$(D‰T$ èB•H‰G9\$du9\$huH‹G ë\HT$@HL$dÿÀ…ÀtiHT$PHL$@ÿð¿…ÀtU·D$\D·T$ZD·L$XD·D$V·T$R·L$PƒL$0ÿ‰D$(D‰T$ èДH‰G(‹„$„‰G·Gºèf‰G‰‰_ëƒËÿ‹Îèy‘‹Ãëè(R‰èRÇ	èîAƒÈÿH‹Œ$˜H3ÌèðÿÿLœ$ I‹[@I‹sHI‹ãA_A^A]A\_ÃÌÌH‹ÄH‰PH‰HL‰@L‰H SVWATHƒì(H‹ù3ö3ÀH…É•À…Àuè’QÇèAƒÈÿéß3ÀH…Ò•À…ÀtÜLd$`èöG@…†H‹Ï讦ƒøÿt*ƒøþt%HcÐH‹ÊHÁùLÏåƒâHkÒXIÈH
°ëH
°H‹ÑLªåöB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€tèæPÇèÓ@ƒÎÿ…öu*H‹Ïèt™‹ØM‹ÌE3ÀH‹T$XH‹Ïè«›‹ðH‹×‹Ëè'šH‹Ïè^‹ÆHƒÄ(A\_^[ÃÌÌL‰D$L‰L$ Hƒì(LL$Hè@§HƒÄ(ÃÌÌÌL‰D$L‰L$ Hƒì(LL$HèD§HƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(LHE3Àè§HƒÄ(ÃL‰D$L‰L$ Hƒì(LL$Hè$§HƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(LHE3Àèý¦HƒÄ(ÃH	Ã@SHƒì ‹Ìö»…Àu¸ë;ÃLÃHcȺ‰©öè<„H‰…æH…Àu$PH‹Ë‰Œöè„H‰hæH…Àu¸ëv3ÉH›œH‰HƒÂ0HƒÁHÿËt	H‹;æëæE3ÀH“œEHI‹ÈLÙãI‹ÀHÁøƒáI‹ÂHkÉXL‹IƒúÿtIƒúþtM…ÒuÇþÿÿÿIÿÀHƒÂ0IÿÉu½3ÀHƒÄ [ÃHƒì(è;©€=€ºt艦H‹
ÂåHƒÄ(éñôÿÿÌ@SHƒì H‹ÙH
ð›H;Ùr>HtŸH;Øw2H‹ÓH¸«ªªªªªª*H+ÑH÷êHÁúH‹ÊHÁé?L謊ºkHƒÄ [ÃHK0HƒÄ [Hÿ%¼Ì@SHƒì H‹Úƒù}ƒÁèzŠºkHƒÄ [ÃHJ0HƒÄ [Hÿ%ë»ÌÌÌHa›H;Êr5HåžH;Èw)ºqH+ÊH¸«ªªªªªª*H÷éHÁúH‹ÊHÁé?LéûˆHƒÁ0Hÿ%¤»ƒù}
ºrƒÁéÞˆHJ0Hÿ%‡»ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„HƒìL‰$L‰\$M3ÛLT$L+ÐMBÓeL‹%M;ÓsfAâðM›ðÿÿAÆM;ÓuðL‹$L‹\$HƒÄÃÌÌL‰D$L‰L$ USVWH‹ìHƒìXHƒeÈH‹Ú3ÒI‹ðH‹ùDB(HMÐèÞäÿÿH…öuè0MÇè=ƒÈÿë\H…ÛtH…ÿtá¸ÿÿÿLM@HMÈH;ØH‹ÖÇEàBGØE3ÀH‰}؉]ÐH‰}ÈèÚ—‹ØH…ÿtÿMÐx	H‹EÈÆëHUÈ3É觋ÃHƒÄX_^[]ÃÌÌÌL‰L$ Hƒì8HD$`H‰D$ è°HƒÄ8ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„L‹ÙMÀt$H+ÊöÂt(Š„Àˆ„ãHÿÂIÿÈtöÂuæëI‹ÃÃH‰HƒÂH‹Iƒèv&I¹ÿþþþþþþ~LÈL‹ÐIƒòÿM3ÑI¹M…ÑtÉIƒÀ„‹„Àˆ„„HÿÂIÿÈtx„äˆ$tuHÿÂIÿÈtiHÁè„ÀˆtbHÿÂIÿÈtV„äˆ$tSHÿÂIÿÈtGHÁè„Àˆt@HÿÂIÿÈt4„äˆ$t1HÿÂIÿÈt%Áè„ÀˆtHÿÂIÿÈt„äˆ$tHÿÂIÿÈ…<ÿÿÿI‹ÃÃHÊH3ÒIƒørEöÁt
HÿÁˆIÿÈëñIƒè rH‰H‰QH‰QH‰QHƒÁ Iƒè sçIƒÀ Iƒèr	H‰HƒÁëñIƒÀIƒèrˆHÿÁëóI‹ÃÃÌÌL‹ÉE3ÀŠHÿÁ„Àu÷HÿÉI;Ét8uô8LDÁI‹ÀÃÌÌÌH‹ÄH‰XH‰hH‰pWHƒìPHƒ`ÈH‹Ú3ÒI‹ðH‹ùDB(HHÐI‹éè`âÿÿH…öuè²JÇèŸ:ƒÈÿëhH…ÛtH…ÿtáL‹Œ$€¸ÿÿÿHL$ H;ØL‹ÅH‹ÖGØÇD$8BH‰|$0‰\$(H‰|$ èS•‹ØH…ÿtÿL$(x
H‹D$ ÆëHT$ 3É舤‹ÃH‹\$`H‹l$hH‹t$pHƒÄP_ÃÌHƒì8L‰L$ E3Éè#ÿÿÿHƒÄ8ÃÌÌH‹ÄH‰XH‰hH‰pWHƒìPHƒ`ÈH‹ú3ÒI‹ØH‹éDB(HHÐI‹ñè|áÿÿH…ÿuèÎIÇè»9ƒÈÿëCH…ÛtæH‹ÏèåL‹Œ$€¹ÿÿÿH;ÁL‹ÆH‹ÓGÁHL$ ÇD$8IH‰|$0H‰|$ ‰D$(ÿÕH‹\$`H‹l$hH‹t$pHƒÄP_ÃÌÌL‹ÜI‰SM‰CM‰K Hƒì8L‹ÂICH‹ÑH
h¦E3ÉI‰Cèè(ÿÿÿHƒÄ8ÃÌÌÌL‹ÜM‰CM‰K Hƒì8M‹ÈL‹ÂIC H‹ÑH
1¦I‰CèèôþÿÿHƒÄ8ÃÌÌÌL‹ÜI‰SM‰CM‰K Hƒì8L‹ÂICH‹ÑH
°·E3ÉI‰Cèè¼þÿÿHƒÄ8ÃÌÌÌL‹ÜM‰CM‰K Hƒì8M‹ÈL‹ÂIC H‹ÑH
y·I‰CèèˆþÿÿHƒÄ8ÃÌÌÌH‰\$WHƒì ƒÏÿH‹ÙH…ÉuèrHÇè_8ÇëFöAƒt:è  H‹Ë‹øèÊH‹Ëèž‹ÈèCÉ…ÀyƒÏÿëH‹K(H…Ét
è<îÿÿHƒc(ƒc‹ÇH‹\$0HƒÄ _ÃÌÌH‰\$H‰L$WHƒì H‹ÙƒÏÿ3ÀH…É•À…ÀuèêGÇè×7‹Çë&öA@tƒaëðèîøÿÿH‹Ëè5ÿÿÿ‹øH‹ËèsùÿÿëÖH‹\$8HƒÄ _ÃÌÌH‰\$H‰l$H‰t$ WATAUAVAWHƒì I‹ñM‹øL‹âL‹ñH…ÒtM…ÀtM…Éu/èlGÇèY73ÀH‹\$PH‹l$`H‹t$hHƒÄ A_A^A]A\_ÃH…ÉtÌ3ÒHƒÈÿI÷ôL;Àw¾I‹üI¯ÿA÷AH‹ïtE‹i$ëA½H…ÿ„à‹F%t<‹N…Ét5ˆ‡H;éI‹ÖB͉L$X‹ÙD‹ÁH‹èyßÿÿ‹D$XH)FH+ëLóé’A‹ÝH;ërd…ÀtH‹Îèôž…ÀuDE…ít3ÒH‹ÅH÷ó‹Ý+Úë‹ÝH‹Îèã›D‹ÃI‹Ö‹ÈèÞσøÿt‹È;ÃGËH+éLñ;Ãs:ƒN H+ý3ÒH‹ÇI÷ôéõþÿÿA¾H‹Öè” ƒøÿtßIÿÆHÿ̓~$A½DOn$H…íéÿÿÿI‹Çé¿þÿÿÌÌH‹ÄH‰XH‰pH‰xL‰H ATHƒì I‹ÙI‹øH‹òL‹áH…ÒtMM…ÀtH3ÀH…Û•À…ÀuèÜEÇèÉ5ë*H‹ËèëöÿÿL‹ËL‹ÇH‹ÖI‹Ìè
þÿÿH‹øH‹Ëèf÷ÿÿH‹Çë3ÀH‹\$0H‹t$8H‹|$@HƒÄ A\ÃÌH…Ét‰HƒÁH‹ÁÃÌHƒì(H…ÉtHƒé9ÝÝuèvëÿÿHƒÄ(ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒìPH‹ÑHHØ3íèqçÿÿL‹\$03ÿM‹£XI‹Lü8èQ{I‹üH‹ØèE{HÿÇHÅHlHƒÿrÙHMèyH‹øH…ÀtnH‹Ø3öÆ:M‹ôHÿÃH‹ÏH+ËHT)H‹Ëè=x…À…‹H‹ËèñzHØH‹ÇÆ:M‹Dô8HÿÃH+ÃH‹ËHT(èx…ÀuHH‹ËèÄzHÿÆHØHƒþršÆ€|$HtH‹D$@ƒ ÈýH‹\$`H‹l$hH‹t$pH‹ÇH‹|$xHƒÄPA\ÃHƒd$ E3ÉE3À3Ò3Éè{3ÌHƒd$ E3ÉE3À3Ò3Éèe3Ì3ÉéÁþÿÿÌH‹ÄH‰XH‰hH‰pH‰x ATHƒìPH‹ÑHHØ3íè1æÿÿL‹\$0DeI‹³XH~pH‹O`èzH‹H‹ØèzHƒÇHÅIÿÌHluÛHMè¿wH‹øH…ÀtuH‹ØHÆÐÆ:L‹F HÿÃH‹ÏH+ËHT)H‹Ëèôv…À…H‹Ëè¨yHØH‹ÇÆ:L‹HÿÃH+ÃH‹ËHT(èÅv…ÀuLH‹Ëè}yIÿÄHƒÆHØIƒür˜Æ€|$HtH‹D$@ƒ ÈýH‹\$`H‹l$hH‹t$pH‹ÇH‹|$xHƒÄPA\ÃHƒd$ E3ÉE3À3Ò3Éè02ÌHƒd$ E3ÉE3À3Ò3Éè2ÌÌ3ÉéµþÿÿÌH‹ÄH‰XH‰hH‰pWATAUAVAWHƒìPH‹ÑE3ÿHH¸A‹ïèÞäÿÿL‹\$0I‹³XA‹ÿH‹Lþ8è½xH‹þH‹Øè±xHÿÇHÅHlHƒÿrÙLfpA½I‹üH‹O`èŠxH‹H‹ØèxHƒÇHÅIÿÍHluÛH‹Ž8èbxH‹Ž0H‹ØèSxH‹Ž@HÅH\è?xH‹ŽHH\è.xH‹ŽPH\èxH¬ÁH‹ÍèåuH‹ØH…À„¬A¸ÀH‹ÖH‹ÈH¸ÀèYÚÿÿL‹óL+öLn8K‰|.ÈM‹EÈH‹ÓH+×H‹ÏHÕèu…À…RH‹ÏèµwH‹ÓH|K‰<.M‹EH+×HÕH‹ÏèÓt…À…H‹Ïè‡wIÿÇIƒÅH|Iƒÿr–E3ÿE‹ïK‰<4M‹$H‹ÓH+×H‹ÏHÕè’t…À…¸H‹ÏèFwH‹ÓH|K‰|&`M‹D$`H+×HÕH‹Ïèbt…À…sH‹ÏèwIÿÅIƒÄH|Iƒýr•H‰»0L‹†0H‹ÓH+×H‹ÏHÕè!t…À…H‹ÏèÕvH‹ÓH|H‰»8L‹†8H+×HÕH‹Ïèís…À…ÔH‹Ïè¡vH‹ÓH|H‰»@L‹†@H+×HÕH‹Ïè¹s…À…‹H‹ÏèmvH‹ÓH|H‰»HL‹†HH+×HÕH‹Ïè…s…ÀuFH‹Ïè=vH‹ÓHLH‰‹PL‹†PH+ÑHÕèXs…À„¿E3ÉE3À3Ò3ÉL‰|$ è/ÌE3ÉE3À3Ò3ÉL‰|$ è÷.ÌE3ÉE3À3Ò3ÉL‰|$ èâ.ÌE3ÉE3À3Ò3ÉL‰|$ èÍ.ÌE3ÉE3À3Ò3ÉL‰|$ è¸.ÌE3ÉE3À3Ò3ÉL‰|$ è£.ÌE3ÉE3À3Ò3ÉL‰|$ èŽ.ÌHƒd$ E3ÉE3À3Ò3Éèx.ÌHƒd$ E3ÉE3À3Ò3Éèb.ÌD8|$HtH‹D$@ƒ ÈýL\$PH‹ÃI‹[0I‹k8I‹s@I‹ãA_A^A]A\_ÃÌ3ÉéüÿÿÌëDŠ	E„ÉtH‹HÿÁDˆHÿIÿIƒ8uãóÃÌÌÌL‹
L‹ÒD‹Ùë3¸gfffA÷ëÁú‹ÂÁèЊÂÀàÉD*ÙA€Ã0EˆIÿIÿÁD‹Ú…Ò~Iƒ8wÇI‹M‰
IÿÉŠAŠ	Aˆˆ
HÿÂIÿÉI;ÑrëóÃH‰\$H‰|$E3ÒD‹ÙD9T$(t^M‹ë3¸gfffA÷ëÁú‹ÂÁèЊÂÀàÉD*ÙA€Ã0EˆIÿ	IÿÂD‹Ú…Ò~Iƒ9wÇI‹M‰IÿÊŠAŠ
Aˆˆ
HÿÂIÿÊI;ÒrëëYHcÂI;sNÿÊHcúZ…Ût7¸gfffAÿÂA÷ëÁú‹ÂÁèЊÂÀàI‹ÉD*ÙA€Ã0DˆHÿÏÿËD‹ÚuÉIcÂII)ëM!H‹\$H‹|$ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì0D¾ÒI‹ùI‹ðH‹éA¾AƒúY¸„eAƒúIG„Aƒê„©Aƒê	„ŸAƒê„ÓAƒêtzAÿÊt!AND;Ñ…’A‹H…ɈvƒùéÎ3ÛA9XŒbAƒxWIcHH‹D$xH‹”ÈÐH‹L$pëDŠE„À„.I‹IÖDˆM1Hÿ	H9uàé3ÛA9XŒKA9HIcHH‹D$xH‹TÈ8H‹L$pëDŠE„À„ÛI‹IÖDˆM1Hÿ	H9uàéÂI‹Æ%H‹D$pM1Hÿé¬A‹H…Ɉ¥ƒùœ¸«ªª*÷éÑú‹ÂÁèÐRÁà+ȸDÈéÝAƒêM„ö¹D+Ñ„ÌAƒêt\Aƒêt7AÿÊ…ZH‹D$xH‰D$(H‹D$pH‰D$ ºH‹Íè]…À…é,A‹@3Û…Àˆ;Á…ÀtHÿë3ÛA9XŒñA9HçA‹HA9XŒÙAxmËA9H|+E‹@¸“$I’A÷èAÐÁú‹ÂÁèЋ‹ÚkÀD+ÀD;Á|AÞ‹Ëéù3ÛA9ŒˆAƒ8;~‹éÝA‹H…Ɉkƒù;éÃAx”øÿÿŒUAx£GE‹@¸…ëQA÷èÁú‹ÂÁèЋÂJºkÀdD+ÀkÉdAÈéAƒúm²„AƒêZ„ÉAƒê„*AÿÊ„ÐAÿÊtlAÿÊt/¹D;Ñ…áA‹H…ɈÅùm¹ÿÁºëA‹HA;ÎŒ£ƒùšº‹„$€L‹L$pL‹Ç‰D$ è™ûÿÿésL‹l$xL‹d$p3ÛL‰l$(L‰d$ 9œ$€tu"è-/ÇHH‹L$ è*Á3ÀëL‹ÈE‹ÄH‹×H‹Îèó¼H‹øH‹Ëè°àÿÿH‹ÇH‹\$HH‹t$PH‹|$XHƒÄ0A\ÃÌÌÌA¸@éÿÿÿÌ@SHƒì I‹ÀL‹ÊH‹ÙH…Éuè³.»‰èŸ‹Ãë$A¸€H‹ÐI‹ÉèâþÿÿH‰H…Àt3Àëè.‹HƒÄ [ÃÌH‰T$L‰D$L‰L$ USWH‹ìHƒìPHƒeÐH‹ú3ÒH‹ÙHMØDB(èéÅÿÿH…ÿuè;.Çè(ƒÈÿëKH…ÛtæLM0HMÐE3ÀH‹×ÇEØÿÿÿÇEèBH‰]àH‰]ÐèñxÿMØ‹Øx	H‹MÐÆëHUÐ3Éè.ˆ‹ÃHƒÄP_[]ÃL‰D$L‰L$ Hƒì(LL$Hè8ÀHƒÄ(ÃÌÌÌL‹ÜM‰CM‰K Hƒì8IC E3ÉI‰CèèÃHƒÄ8ÃL‰L$ Hƒì8HD$`H‰D$ èüÂHƒÄ8ÃÌÌÌL‹ÜM‰K Hƒì8IC(I‰CðIƒcèè_ÃHƒÄ8ÃÌÌL‹ÜHƒì8IC0I‰CðI‹C(I‰Cèè<ÃHƒÄ8ÃÌÌÌL‹ÜM‰CM‰K Hƒì8IC E3ÉI‰Cèè±ÄHƒÄ8ÃL‰L$ Hƒì8HD$`H‰D$ è”ÄHƒÄ8ÃÌÌÌH‹ÄH‰HH‰PL‰@L‰H Hƒì(HPè”ÀHƒÄ(ÃÌÌÌH‹ÄH‰HH‰PL‰@L‰H Hƒì(HPèœÀHƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(L@è`ÀHƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(L@èlÀHƒÄ(ÃÌÌÌ@SHƒì@HcÙHL$ èyÎÿÿH‹D$ ƒ¸~LD$ º‹ËèÆ?D‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=ïHcÙuH‹3ˆ·X%ëYHL$ 3ÒèôÍÿÿH‹D$ ƒ¸~LD$ º‹ËèA?D‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ èÍÿÿH‹D$ ƒ¸~LD$ º‹ËèÚ>D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=HcÙuH‹K‡·XƒàëVHL$ 3ÒèÍÿÿH‹D$ ƒ¸~LD$ º‹Ëè[>D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ è©ÌÿÿH‹D$ ƒ¸~LD$ º‹Ëèö=D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=#œHcÙuH‹g†·XƒàëVHL$ 3Òè*ÌÿÿH‹D$ ƒ¸~LD$ º‹Ëèw=D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ èÅËÿÿH‹D$ ƒ¸~LD$ º‹Ëè=D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=?›HcÙuH‹ƒ…·XƒàëVHL$ 3ÒèFËÿÿH‹D$ ƒ¸~LD$ º‹Ëè“<D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ èáÊÿÿH‹D$ ƒ¸~LD$ º€‹Ëè.<D‹ØëH‹€@D·XA　|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=WšHcÙuH‹›„·X%€ëYHL$ 3Òè\ÊÿÿH‹D$ ƒ¸~LD$ º€‹Ëè©;D‹ØëH‹€@D·XA　|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ èõÉÿÿH‹D$ ƒ¸~LD$ º‹ËèB;D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=o™HcÙuH‹³ƒ·XƒàëVHL$ 3ÒèvÉÿÿH‹D$ ƒ¸~LD$ º‹ËèÃ:D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ èÉÿÿH‹D$ ƒ¸~LD$ º‹Ëè^:D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=‹˜HcÙuH‹Ï‚·XƒàëVHL$ 3Òè’ÈÿÿH‹D$ ƒ¸~LD$ º‹Ëèß9D‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ è-ÈÿÿH‹D$ ƒ¸~LD$ º‹Ëèz9D‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=£—HcÙuH‹ç·X%ëYHL$ 3Òè¨ÇÿÿH‹D$ ƒ¸~LD$ º‹Ëèõ8D‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ èAÇÿÿH‹D$ ƒ¸~LD$ ºW‹ËèŽ8D‹ØëH‹€@D·XAãW€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=·–HcÙuH‹û€·X%WëYHL$ 3Òè¼ÆÿÿH‹D$ ƒ¸~LD$ ºW‹Ëè	8D‹ØëH‹€@D·XAãW€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ èUÆÿÿH‹D$ ƒ¸~LD$ º‹Ëè¢7D‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=Ë•HcÙuH‹€·X%ëYHL$ 3ÒèÐÅÿÿH‹D$ ƒ¸~LD$ º‹Ëè7D‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ èiÅÿÿH‹D$ ƒ¸~LD$ º ‹Ëè¶6D‹ØëH‹€@D·XAƒã €|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=ã”HcÙuH‹'·Xƒà ëVHL$ 3ÒèêÄÿÿH‹D$ ƒ¸~LD$ º ‹Ëè76D‹ØëH‹€@D·XAƒã €|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ3Àù€’ÀÃá‹ÁÃÌÌ@SHƒì@HcÙHL$ èqÄÿÿH‹D$ ƒ¸~LD$ º‹Ëè¾5D‹ØëH‹€@D·XAã3É8L$8tH‹D$0ƒ ÈýE…Ûuƒû_u¹‹ÁHƒÄ@[ÃÌÌÌ@SHƒì ‹ÙèÛõÿÿ3Ò…Àuƒû_uº‹ÂHƒÄ [ÃÌÌÌ@SHƒì@HcÙHL$ èÑÃÿÿH‹D$ ƒ¸~LD$ º‹Ëè5D‹ØëH‹€@D·XAã3É8L$8tH‹D$0ƒ ÈýE…Ûuƒû_u¹‹ÁHƒÄ@[ÃÌÌÌ@SHƒì ‹Ù¶Éè„ûÿÿ3Ò…Àu€û_uº‹ÂHƒÄ [ÃÌÌÌÌÌÌÌÌÌÌÌÌL‹ÉH;Êt M…ÀtL+ʶA¶HÿÂIÿÈAˆDÿˆJÿuèóÃÌÌÌÌÌÌH;ц²H‰l$ WATAUHƒì H‰\$@H‰t$HL‰t$PN4M‹éI‹èH‹úL‹áff„I‹ÜI‹öL;÷wDH‹ÓH‹ÎAÿÕ…ÀHOÞHõH;÷véL‹ÅH‹×H;ßt$H…ítH+ßfD¶¶HÿÂIÿȈDÿˆJÿuêH+ýI;üw¢L‹t$PH‹t$HH‹\$@H‹l$XHƒÄ A]A\_óÃÌÌÌ@UATAVHìM‹áI‹èL‹ñH…Éu!H…ÒtèçÇHÄA^A\]éÈM…ÀtßM…ÉtÚHƒú‚šH‰œ$0H‰´$8H‰¼$@L‰¬$LjÿL‰¼$L¯íLéE3ÿff„3ÒI‹ÅI‹ÎI+ÆH÷õHpHƒþw&M‹ÌL‹ÅI‹ÕèŠþÿÿIÿψN‹tü N‹¬üëÂHÑîH¯õIöH‹ÖAÿÔ…À~6L‹ÅH‹ÖL;öt+M‹ÎL+Îfffff„¶A¶HÿÂIÿÈAˆDÿˆJÿuèI‹ÕI‹ÎAÿÔ…À~3L‹ÅI‹ÕM;õt(M‹ÎM+Íff„¶A¶HÿÂIÿÈAˆDÿˆJÿuèI‹ÕH‹ÎAÿÔ…À~3L‹ÅI‹ÕI;õt(L‹ÎM+Íff„¶A¶HÿÂIÿÈAˆDÿˆJÿuèI‹ÞI‹ýfH;óvHÝH;ÞsH‹ÖH‹ËAÿÔ…À~ëH;ówHÝI;Ýw
H‹ÖH‹ËAÿÔ…À~ëH+ýH;þv
H‹ÖH‹ÏAÿÔ…ÀëH;ßw6L‹ÍH‹×t!L‹ÃL+ǶA¶HÿÂIÿÉAˆDÿˆJÿuèH;÷uƒH‹óé{ÿÿÿHýH;÷s#H+ýH;þvH‹ÖH‹ÏAÿÔ…ÀtëH;÷rfDH+ýI;þv
H‹ÖH‹ÏAÿÔ…ÀtëI‹ÍH‹ÇH+ËI+ÆH;Á|&L;÷sN‰tü J‰¼üIÿÇI;݃"þÿÿL‹óéôýÿÿI;ÝsJ‰\ü N‰¬üIÿÇL;÷ƒüýÿÿL‹ïéÎýÿÿL‹¬$H‹¼$@H‹´$8H‹œ$0L‹¼$HÄA^A\]ÃÌH‰\$H‰t$WHƒì H‹ÚH‹ùH…Éu
H‹Êè–ÃÿÿëjH…ÒuèúÂÿÿë\HƒúàwCH‹
óŽ¸H…ÛHDØL‹Ç3ÒL‹ËÿŠH‹ðH…Àuo9•tPH‹ËèIF…Àt+Hƒûàv½H‹Ëè7FèŽÇ3ÀH‹\$0H‹t$8HƒÄ _ÃèqH‹ØÿT‰‹Èè‰ëÕèXH‹Øÿ;‰‹Èè‰H‹Æë»Ì@SVWATAUHƒì0I‹Ø‹òL‹éL‹áH‹ùH…Éu…ÒtèÇè3Àé!3À…Ò™À…ÀtÞ3ÀH…Û•À…ÀtÒ…ÒtÞH‰\$xH‹ËèÍÿÿöC@…ŠH‹Ëè#qƒøÿt*ƒøþt%HcÐH‹ÊHÁùLD°ƒâHkÒXIÈH
’zëH
‰zH‹ÑL°öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€tè[ÇèH3ÿH‰|$ H…ÿtTÿΉt$htGÿKxH‹¶HÿÀH‰ë
H‹Ëèý²‹È‰L$`ƒùÿuM;åu3ÿH‰|$ ëAˆ$IÿÄL‰d$(€ù
të±AÆ$H‹Ëè¤ÌÿÿH‹ÇHƒÄ0A]A\_^[ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„M…ÀtuH+ÑL‹ÊI»öÁtŠBŠ	HÿÁ:ÂuWIÿÈtN„ÀtJH÷ÁuáJ	fâÿfúøwÑH‹J‹	H;ÂuÅHƒÁIƒèIºÿþþþþþþ~vHƒðÿLÒI3ÂI…ÃtÁëH3ÀÃHÀHƒØÿÄÒt'„öt#HÁê„Òt„ötHÁê„Òt„ötÁê„Òt„öuˆH3ÀÃÌÌÌ@SHƒì ‹ÙH
öÿ»‡H…ÀtH÷õH‹Èÿ–†H…Àt‹ËÿÐHƒÄ [ÃÌÌÌ@SHƒì ‹Ùè·ÿÿÿ‹Ëÿ‡‡ÌÌ̹é¾UÌ̹é’TÌÌ@SHƒì è})H‹ÈH‹Øè¶BH‹ËèH‹Ëè2¼H‹ËèB¹H‹Ëè³H‹ËHƒÄ [éñ²ÌH;Ês-H‰\$WHƒì H‹úH‹ÙH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃÌH‰\$WHƒì 3ÀH‹úH‹ÙH;Ês…ÀuH‹H…ÉtÿÑHƒÃH;ßréH‹\$0HƒÄ _ÃÌÌÌHƒì(H…ÉuèÖÇèøëH‹A„H…ÀtÝH‰3ÀHƒÄ(ÃÌÌHƒì(H…ÉuèžÇ苸ëH‹„H…ÀtÝH‰3ÀHƒÄ(ÃÌÌH‰\$WHƒì Hƒ=.¯‹ÙtH
#¯覾…Àt‹Ëÿ¯èÕ½H&ˆH
÷‡èÿÿÿ…ÀuZH
½è*½HˇH=̇ëH‹H…ÀtÿÐHƒÃH;ßríHƒ=Ç®tH
¾®è9¾…ÀtE3À3ÉAPÿ¦®3ÀH‹\$0HƒÄ _ÃÌH‰\$H‰t$D‰D$WATAUAVAWHƒì@E‹à‹ÚD‹ù¹è®Sƒ="ƒ„ǃDˆ%ƒ…Û…ÔH‹
$®ÿ>…H‹ðH‰D$0H…À„£H‹
þ­ÿ …H‹øH‰D$ L‹öH‰t$(L‹èH‰D$8HƒïH‰|$ H;þrpè	'H9uëæH;þr_H‹ÿà„H‹Øèì&H‰ÿÓH‹
¬­ÿÆ„H‹ØH‹
”­ÿ¶„L;óuL;èt¼L‹óH‰\$(H‹óH‰\$0L‹èH‰D$8H‹øH‰D$ ëšH»†H
”†èGýÿÿH¸†H
©†è4ýÿÿE…ät¹èpQE…äu&Çý¹èWQA‹ÏèSüÿÿA‹Ïÿ"„ÌH‹\$pH‹t$xHƒÄ@A_A^A]A\_ÃÌE3À3ÒéfþÿÿÌÌE3ÀAPéXþÿÿ3Ò3ÉDBéKþÿÿÌÌ̺3ÉD‹Âé9þÿÿÌ@SHƒì ‹Ùèß>‹Ëèx<E3À¹ÿAPèþÿÿÌÌÌ@SHƒì ƒ=s‹Ùuè®>‹ËèG<¹ÿHƒÄ [éàûÿÿ¸MZf9 ÿÿt3ÀÃHc
@ ÿÿHýÿÿHÈ9PEuä¸f9AuÙ3Àƒ¹„v	9ø•ÀÃÌÌH‰\$WHì HL$0ÿ0ƒA»MZH=«ÿÿfD9£ÿÿt3Ûë1HcÒÿÿHÇ8PEuê¹f9Huß3Ûƒ¸„v	9˜ø•Ã‰œ$°èÐ:…Àu"ƒ=€uèÊ=¹è`;¹ÿèþúÿÿèå'…Àu"ƒ=b€uèŸ=¹è5;¹ÿèÓúÿÿ躹èðY…Ày
¹è†þÿÿÿ`‚H‰«èôÁH‰€èðÀ…Ày
¹èZþÿÿèÕ½…Ày
¹	èGþÿÿ¹èÅûÿÿ…Àt‹Èè2þÿÿè1½öD$l·T$pA¹
DEÊL‹À3ÒH‹Ïè$uÿÿ‹ø‰D$ …Ûu‹ÈèÃýÿÿèÖýÿÿë‹øƒ¼$°u‹ÈèµýÿÿÌèËýÿÿ‹ÇH‹œ$¸HÄ _ÃÌÌÌHƒì(è/ÂHƒÄ(éRþÿÿÌÌH‰L$HìˆH
íÿ·H‹Ø€H‰D$XE3ÀHT$`H‹L$XèCdH‰D$PHƒ|$PtAHÇD$8HD$HH‰D$0HD$@H‰D$(H˜H‰D$ L‹L$PL‹D$XH‹T$`3Éèñcë"H‹„$ˆH‰d€H„$ˆHƒÀH‰ñH‹J€H‰»~H‹„$H‰¼Ç’~	ÀÇŒ~H‹á_H‰D$hH‹Ý_H‰D$pÿ€‰ü~¹èÒÁ3Éÿ¢€H
Óîÿ€ƒ=Ö~u
¹èªÁÿô}º	ÀH‹Èÿ^€HĈÃÌÌH‰
}ƒÃH‰\$H‰t$UWATH¬$ûÿÿHìðH‹H_H3ÄH‰…àA‹ø‹ò‹ÙƒùÿtèEÁƒd$pHL$t3ÒA¸”覩ÿÿL\$pHEHML‰\$HH‰D$Pÿ	€L‹¥HT$@I‹ÌE3ÀèœbH…Àt7Hƒd$8H‹T$@HL$`H‰L$0HL$XL‹ÈH‰L$(HMM‹ÄH‰L$ 3Éè\bëH‹…H‰…H…H‰…¨H‹…‰t$p‰|$tH‰E€ÿi3É‹øÿWHL$HÿD…Àu…ÿuƒûÿt‹Ëè`ÀH‹àH3ÌèI¯ÿÿLœ$ðI‹[(I‹s0I‹ãA\_]ÃÌH‰\$WHƒì H‹ùH‹
‚ÿÎ~H‹ÏH‹ØÿH‰‚H‹ÃH‹\$0HƒÄ _ÃÌH‹
íHÿ%ž~ÌÌHƒì(A¸ºÀAHèPþÿÿÿ|ºÀH‹ÈHƒÄ(Hÿ%ƒ~ÌÌÌHƒì8H‹D$`H‰D$ è¹ÿÿÿÌH‰\$H‰l$H‰t$WHƒì0H‹éH‹
~A‹ÙI‹øH‹òÿ'~D‹ËL‹ÇH‹ÖH‹ÍH…Àt!L‹T$`L‰T$ ÿÐH‹\$@H‹l$HH‹t$PHƒÄ0_ÃH‹D$`H‰D$ èJÿÿÿÌÌHƒì8Hƒd$ E3ÉE3À3Ò3ÉèwÿÿÿHƒÄ8ÃÌÌHƒì8Hƒd$ E3ÉE3À3Ò3ÉèWÿÿÿHƒd$ E3ÉE3À3Ò3ÉèúþÿÿÌÌHƒì8H‹D$`H‰D$ è-ÿÿÿHƒÄ8Ã@SHƒì ‹Ùè+‰HƒÄ [ÃÌÌÌ@SHƒì ‹Ùè‰HƒÄ [ÃÌÌÌ@SHƒì ‹Ùè‰HƒÄ [ÃÌÌÌH‹ÄSVWATAUAVAWHƒìPE3öE‹îA‹öD‰pD‰pD‰pANè@KèÒL‹àHŒ$èÂ
…À…HŒ$˜èM
…À…âHŒ$ èh
…À…¹èÉ‹ØD‰5²€AƒÏÿD‰=Ã_D‰=¬_H
ëèÈ¿H‹øH‰D$@H…À„‘D80„ˆH‹
w€H…Ét$H‹ÑH‹Èèç¾…À„¸H‹
X€H…Étè~´ÿÿH‹Ïè–DHHèeBH‰6€H…À„†H‹ÏèuDL‹ÇHPH‹
€èžA…À„hL‰t$ E3ÉE3À3Ò3ÉèRýÿÿH‹
ïH…Étè´ÿÿL‰5ÞH
'ÿ)|ƒøÿ„!Ǻ‹
kÉ<‰Œ$‹LfD956t‹ÂkÀ<ȉŒ$fD95rt#‹x…ÀtÇ„$˜+ÂkÀ<‰„$ ëD‰´$˜D‰´$ H„$¨H‰D$8L‰t$0¾?‰t$(I‹$H‰D$ E‹ÏLy~3Ò‹Ëÿk{…ÀtD9´$¨u
I‹$Dˆp?ëI‹$Dˆ0H„$¨H‰D$8L‰t$0‰t$(I‹D$H‰D$ E‹ÏLz~3Ò‹Ëÿ{…ÀtD9´$¨uI‹D$Dˆp?ëI‹D$Dˆ0¾‹œ$èZ‰‹œ$˜è<‰‹œ$ è6‰¹è‚G…ö…˜D~E‹ÏL‹ÇV@I‹$èô»…À…(Iÿ€?-uDnHÿÇH‹Ïè»D‹ØEiÛD‰œ$³0@¶9Š<+„è:Ã|	@:ÆŽÛ€?:udHÿÇH‹ÏèC»kÀR‰3ÀHƒÄ(ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì I‹ØH‹úH‹ñH…Òt?H…Ût?H…ÒtÆH…Ét2E…ÉtAƒùu'IcéL%vRI‹ìèý6HÿÀH‰H…ÿu3Àë5H…ÛtÁè°»‰èœðÿÿ‹ÃëH;Ãv¸"ëM‹ìH‹ÓH‹Ïèõ3H‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A\ÃÌÌHyQÃHuQÃHeQÃHíQÃL
õQ3ÀI‹ÑD@;
t+ÿÀIЃø-ròAíƒøw¸
ÃÁDÿÿÿ¸ƒùAFÀÃH˜A‹DÁÃÌHƒì(èïH…Àu	HSëHƒÀHƒÄ(ÃHƒì(èÏH…Àu	HëRëHƒÀHƒÄ(Ã@SHƒì ‹Ùè«H…Àu	HÇRëHƒÀ‰è’L¯RH…ÀtLP‹Ëè;ÿÿÿA‰HƒÄ [ÃÌÌ@SHƒì ‹ÙècH…Àu¸ëèRH…Àu	HjRëHƒÀ‰3ÀHƒÄ [ÃÌÌ@SHƒì H‹ÙH…Éu
è!ïÿÿCëèH…Àu	H/RëHƒÀ‹‰3ÀHƒÄ [ÃÌ@SHƒì ‹ÙèëH…Àu¸ëèÚH…Àu	HöQëHƒÀ‰3ÀHƒÄ [ÃÌÌ@SHƒì H‹ÙH…Éu
è©îÿÿCëèŸH…Àu	H»QëHƒÀ‹‰3ÀHƒÄ [ÃÌH‰\$H‰t$WHƒì 3öH‹úH‹ÙH…Éuègþÿÿ»‰èSîÿÿ‹Ãé\ºÿA¸$èè•ÿÿH…ÿtÓD‹Aø@Wÿÿ}è.þÿÿ»‰ëʸy-A÷èÁú‹ÂÁèЋÂ•FiÀ€àyøDÀ¸€3áD;À|%D+ÀÿÂD;À|D+À¸…âÿÂD;À|ÿÂD+À뾉S¸E.ÂL
w]A÷èAÐÁú‹ÂÁèÐH˜]‰SD‹[iÒ€®þÿDÂ…öLDȺIIëÿÂHƒÁD9|õÿʸE.ÂHcʉSE+‰D‰[÷/ƒc Áú‹ÂÁèL¸“$I’÷éÑÁú‹ÂÁèиų¢‘kÒ+ÊA÷è‰KAÐÁú‹ÂÁèи‰ˆˆˆ‰SiÒðñÿÿDÂA÷èAÐÁú‹ÂÁèЉSkÒè…ÿÿHƒd;PAÇEL‰l;Xé¿ýÿÿHƒd$ E3ÉE3À3Ò3Éè€ÎÿÿÌÌÌÌ@SUVWATAUAVHìÐH‹7,H3ÄH‰„$ÀI‹ØH‹ù…Òt H…Ût
è¸üÿÿé3HcÂHÁàH‹DHé"3öDfH…Û„A€8L…AA€xC…6A€x_…+HtÀH‹ËèÜÅH‹èH…À„„L‹èL+ë„x€8;„oA¾L%.¿I‹$M‹ÅH‹Óè·Ãÿÿ…ÀuI‹$èšL;ètHf¿IƒÄAÿÆL;à~ÌHÿÅHô¿H‹Íèx¸H‹ØH…Àu
€};…
Aƒþ4HL$0L‹ÈL‹Åºƒè—…ÀuaLD$0A‹ÖH‹ÏˆD0è«ûÿÿH…ÀtÿÆHÝ€;tHÿÀ;…ÿÿÿ…ö„´H‹Ïèh÷ÿÿH‹Œ$ÀH3Ìèà{ÿÿHÄÐA^A]A\_^][ÃHƒd$ E3ÉE3À3Ò3ÉèÕÌÿÿÌ!t$(H!t$ HT$0E3ÉA¸ƒH‹ËèíøÿÿH…Àt¤3ÛHoH…Ût-H‹UHL$0è¼…ÀtLD$0‹ÓH‹ÏèùúÿÿH…ÀuE3äëÿÆÿÃHƒÅ ƒû~ÄE…ä…QÿÿÿéDÿÿÿ3ÀéMÿÿÿÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì H‹ò‹éƒùw+H…Òt&A¼A‹ÔAL$èiH‹ØH…Àu(èÐÜÿÿÇ3ÀH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A\ÃI‹Ô¹`è,H‰H…Àu
H‹Ë褂ÿÿë¹I‹Ô¹ è
H‰CH…Àu
H‹è„‚ÿÿëÖH‹;H…ÿt%Hƒ7H;útH‹ÏA¸`èðtÿÿƒ'H‹ÏèµèÿÿH‹L‹Æ‹ÕèøüÿÿH…ÀtH‹H‹S‹HèÄãÿÿ…Àt%H‹Kè'‚ÿÿH‹èéÿÿH‹è§éÿÿH‹Ëè‚ÿÿ3ÛëH‹CD‰ H‹CD‰ H‹ÃéÿÿÿÌéÃþÿÿÌÌÌH‰\$H‰t$H‰|$ ATAUAVHƒì0L‹êD‹á3öƒùvè­ÛÿÿÇèšËÿÿ3ÀéeèíÿÿH‹ØH‰D$`èëÿÿƒ‹Èº¹`èÿH‹øH…À„'¹èuH‹“ÀH…ÒtH;útH‹ÏA¸`èásÿÿƒ'H‹Ïè¦çÿÿ¹èM‹ÅA‹ÔH‹ÏèÝûÿÿH‹ðH‰D$ H…À„·M…ít)HT3I‹ÍèX‹‹
M…ÀA¼AẺ
ðLëA¼¹èâH‹×H‹ÀèÚéÿÿH‹Ïè²çÿÿöƒÈuLD„%ö2uCH‹“ÀH
7è­éÿÿL‹
7I‹ƒ(H‰¤:I‹ƒ@H‰6;A‹ƒ‰9;¹èKëH‹ÏèIçÿÿH‹Ïèåçÿÿƒ£ÈïH‹ÆH‹\$PH‹t$XH‹|$hHƒÄ0A^A]A\ÃHƒì(E3Àº3ÉÇD$0ÿœHH‰LH…Àt)ÿ‚H<sH‹
ÿKLD$0A¹3Òÿ\H¸HƒÄ(ÃÌÌHƒì(H‹
ÕKÿGHƒ%ÇKHƒÄ(ÃÌÌH‹¹KÃL)Ä3ÀI‹Ð;
tÿÀHƒÂƒørñ3ÀÃH˜HÀI‹DÀÃÌÌÌH‰\$H‰l$H‰t$ WATAUHìPH‹b&H3ÄH‰„$@‹ùè ÿÿÿ3öH‹ØH…À„îNèºÄƒø„uNè©Ä…Àu
ƒ=î)„\ÿü„¸H-KA¼LhÅH‹ÍA‹ÔèÄ3É…À…L-KA¸f‰5MI‹ÕÿnDA|$ç…Àu*LöÄ‹×I‹ÍèÀÃ…ÀtE3ÉE3À3Ò3ÉH‰t$ èÀÇÿÿÌI‹Íè#HÿÀHƒøH…ÀtÃH‰(H‹5?H…öu ¹è‘H‰ê>H…ÀtžH‰(H‹5Û>H‹îH…ötŒH‹M+ìH‹þIÑýL‰l$pMcíH…ÀtE¾=M‹ÅH‹ÐI‹Ìè?À3É…ÀuH‹fB94h„¡fB9h„–HƒÇH‹H…ÀuÇH‹5u>H+þHÁÿ÷ßE3í…ÿˆŒL9m„‚Hc÷H‹LõèòxÿÿE…ÿtfL9lõtHLõH‹ÿÇHƒÁH‰DõHÿÆL9lõuèHc×H¸ÿÿÿÿÿÿÿH;Ѓ’H‹
>A¸è%H…Àt{ërH‹5ë=H+þHÁÿésÿÿÿL‰dõM‰.ë\E…ÿ…û…ÿy÷ßG;ÇŒtþÿÿLcÀH¸ÿÿÿÿÿÿÿL;Àƒ^þÿÿºH‹ÎèÄH…À„HþÿÿHcÏL‰$ÈL‰lÈM‰.H‰y=D9l$xtuI‹Ì誾H‹ÖèzH‹øH…ÀtUI‹ÌèŠM‹ÄH‹ÏHè÷¼…ÀuQH‹D$pH‹ÏHGfD‰*HÖE…ÿIEÕÿ÷>…ÀuƒËÿèŸÑÿÿÇ*H‹Ïè¥wÿÿE…ÿtI‹Ìè˜wÿÿM‰.‹Ãé¢ýÿÿE3ÉE3À3Ò3ÉL‰l$ è¦ÀÿÿÌI‹ÌèqwÿÿM‰.éšýÿÿÌH‹Á·HƒÀf…ÒuôH+ÁHÑøHÿÈÃÌÌÌH‰\$H‰t$WHƒì H‹~<LcÂH‹ñH‹H‹ØH…Òt4I‹øL‹ÇH‹Îè¿Â…ÀuH‹€<=t4€<t.HƒÃH‹H…ÒuÖH‹9<H+ØHÁû÷ÛH‹t$8‹ÃH‹\$0HƒÄ _ÃH+<HÁûëáÌH‰\$H‰t$WHƒì H‹Ù3ÉH‹ÃH…Ût[H9tHƒÀÿÁHƒ8uôAºHcÈèH‹øH‹ðH…ÀuH	èhºÿÿH‹H…ÉtH+ßèÂH‰HƒÇH‹;H…ÉuëHƒ'H‹ÆH‹\$0H‹t$8HƒÄ _ÃÌH‰\$‰T$UVWATAUAVAWHƒì0E3í‹êL‹ñA‹ÝH…ÉuèÿÏÿÿÇèì¿ÿÿéìL‹!M…ä„Õº=I‹ÌèºH‹øH‰D$pH…À„·L;à„®D8hH‹5
;E‹ýA”ÇH;5;utH‹îA‹ÅH…öuI‹õëYHƒÆÿÀL9.uõÿÀºHcÈèH‹øH‹ðH…ÀuH	èh¹ÿÿH‹EH…ÀtH+ïH‹ÈèÁH‰HƒÇH‹/H…ÀuèL‰/H‹|$p‹l$xH‰5‰:H…ö…‡…ít8L9-…:t/èFÁ…Àtjè	ÏÿÿǃÈÿH‹œ$€HƒÄ0A_A^A]A\_^]ÃE…ÿt3Àëß¹èáH‰*:H…ÀtÆL‰(L9-+:u¹è¿H‰:H…Àt¤L‰(H‹5ù9H‹îH…öt’H‹‹ÇH‹þA+ÄLcèH…Ét?H‹ÑM‹ÅI‹Ìè0À…ÀuH‹A€|=„¡A8\„–HƒÇH‹H…ÉuÈH‹5Ÿ9H+þHÁÿ÷ßE3í…ÿˆŒL9m„‚Hc÷H‹Lõè,tÿÿE…ÿtfL9lõtHLõH‹ÿÇHƒÁH‰DõHÿÆL9lõuèHc×H¸ÿÿÿÿÿÿÿH;Ѓ’H‹
.9A¸è_H…Àt{ërH‹59H+þHÁÿésÿÿÿL‰dõM‰.ë\E…ÿ…ú…ÿy÷ßG;ÇŒ†þÿÿLcÀH¸ÿÿÿÿÿÿÿL;ÀƒpþÿÿºH‹ÎèþH…À„ZþÿÿHcÏL‰$ÈL‰lÈM‰.H‰£8D9l$xttI‹ÌèlºHHè¶H‹øH…ÀtVI‹ÌèNM‹ÄH‹ÏHPè{…ÀuRH‹×H‹ÏI+ÔHT$pDˆ*HÿÂE…ÿIEÕÿ*:…ÀuƒËÿèÚÌÿÿÇ*H‹ÏèàrÿÿE…ÿtI‹ÌèÓrÿÿM‰.‹ÃéµýÿÿE3ÉE3À3Ò3ÉL‰l$ èá»ÿÿÌI‹Ìè¬rÿÿM‰.é­ýÿÿ@SHƒì H…Ét
H…ÒtM…ÀuDˆèsÌÿÿ»‰è_¼ÿÿ‹ÃHƒÄ [ÃL‹ÉM+ÈAŠCˆIÿÀ„ÀtHÿÊuíH…Òuˆè:Ìÿÿ»"ëÅ3ÀëÊÌÌÌ@SHƒì ‹ÙÿR9ƒÈÿÃè;gDGØ‹ÃHƒÄ [ËVD‰
PDÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì ‹=-D3íH‹ñAƒÌÿH‹ÎèhrÿÿH‹ØH…Àu(…ÿt$‹Íÿä8‹=DDèD;ßA‹ëAGìA;ìuÈH‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3ÿH‹òH‹éAƒÌÿE3ÀH‹ÖH‹Íèi¾H‹ØH…Àu*9‹Cv"‹Ïÿ]8DŸèD;sCA‹ûAGüA;üuÀH‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3öH‹úH‹éAƒÌÿH‹×H‹Í謭ÿÿH‹ØH…Àu/H…ÿt*9Cv"‹Îÿ×7DžèD;íBA‹óAGôA;ôu¾H‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌÌÌH‰\$H‰l$H‰t$WATAUHƒì 3öI‹øH‹êAƒÍÿL‹áL‹ÇH‹ÕI‹Ìè÷½H‹ØH…Àu/H…ÿt*9xBv"‹ÎÿJ7DžèD;`BA‹óAGõA;õu»H‹l$HH‹t$PH‹ÃH‹\$@HƒÄ A]A\_ÃÌÌÌÌÌÌÌÌÌÌff„H‹ÁH÷ÙH©tfŠHÿÀ„Òt_¨uóI¸ÿþþþþþþ~I»H‹M‹ÈHƒÀLÊH÷ÒI3ÑI#ÓtèH‹Pø„ÒtQ„ötGHÁê„Òt9„öt/HÁê„Òt!„ötÁê„Òt
„öu¹HDÿÃHDþÃHDýÃHDüÃHDûÃHDúÃHDùÃHDøÃ3ÀH…Òt€9tHÿÀHÿÁH;ÂrðóÃÌÌÌH‰\$H‰t$H‰|$UH‹ìHƒì@H‹Ù‹úHMàI‹Ðèkÿÿ3öH…Ûu8èÔÈÿÿÇèÁ¸ÿÿ@8uøtH‹Eðƒ Èý3ÀH‹\$PH‹t$XH‹|$`HƒÄ@]ÃH‹Uè9ru‹×H‹Ëèú_ÿÿ@8uøtÒH‹Mðƒ¡ÈýëŶf…Ét3¶ÁöDtHÿÃ@83t˜¶·ÉÁáÈ;ùu
HCÿë¾·Á;øtHÿÃëÅ·Á;ø…lÿÿÿ@8uøtH‹Eðƒ ÈýH‹ÃéfÿÿÿE3ÀéÿÿÿL‹ÜI‰[I‰kI‰s I‰SWATAUAVAWHƒì@M‹yM‹1‹AI‹y8M+÷M‹áL‹êH‹é¨f…íIcqHI‰KÈM‰CÐH‹Æ;7ƒHÀH\Ç‹CøL;ð‚¨‹CüL;ðƒœƒ{„’ƒ;t‹HL$0I‹ÕIÇÿÐ…Àˆ‰~t}csmàu(Hƒ=ö]tH
í]è¨m…ÀtºH‹ÍÿÖ]‹KA¸I‹ÕIÏèrYI‹D$@‹SLcMH‰D$(I‹D$(I×L‹ÅI‹ÍH‰D$ ÿ˜3èsYÿÆHƒÃ;7ƒ·é9ÿÿÿ3Àé°M‹A 3íE3íM+Ǩ t;3Ò9v5HO‹AüL;Àr‹L;ÀvÿÂHƒÁ;sëå‹ÂHÀ‹LÇ…Éu‹lÇëD‹éIcqHH‹Þ;7sUHÿÃHÁãHß‹CôL;ðr9‹CøL;ðs1E…ítD;+t1…ít;küt(ƒ;uH‹T$xF±A‰D$HD‹CüMÇAÿÐÿÆHƒÃ;7rµ¸L\$@I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰t$H‰|$ATHƒì L%¬"3ö3ÛI‹üƒu&Hcƺ ÿÆH€H:>HÈH‰ÿU2…Àt&ÿÃHƒÇƒû$|ɸH‹\$0H‹t$8H‹|$@HƒÄ A\ÃHcÃHÀIƒ$Ä3ÀëÛH‰\$H‰l$H‰t$WHƒì ¿$H$"‹÷H‹+H…ítƒ{tH‹ÍÿÛ1H‹ÍèckÿÿHƒ#HƒÃHÿÎuÔH÷!H‹KøH…Étƒ;uÿ«1HƒÃHÿÏuãH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌHcÉH²!HÉH‹ÈHÿ%œ2Hƒì(H‹Ñ3Éÿ]1¹ÿHƒÄ(é«ÿÿÌÌÌH‰\$H‰t$H‰|$AUHƒì HcÙ¾Hƒ=Ç6uè”íÿÿNè,ëÿÿ¹ÿèʪÿÿH‹ûHÿL-9!Iƒ|ýt‹Æëy¹(è{øÿÿH‹ØH…ÀuèbÄÿÿÇ3ÀëX¹
èfH‹ËIƒ|ýu-º ÿÃ0…ÀuH‹Ëè?jÿÿè&ÄÿÿÇ3öë
I‰\ýëè$jÿÿH‹
\!ÿ®1ëƒH‹\$0H‹t$8H‹|$@HƒÄ A]ÃÌÌH‰\$WHƒì HcÙH=ˆ HÛHƒ<ßuèõþÿÿ…ÀuHè½­ÿÿH‹ßH‹\$0HƒÄ _Hÿ%H1H‹ÄH‰XH‰hH‰pH‰x ATHƒì M‹Q8H‹òM‹àA‹H‹éI‹ÑHÀH‹ÎI‹ùI\ÂL‹Ãè:_ÿÿD‹D‹UA‹ÃAƒãº#ÂA€âfDDØE…ÛtL‹ÏM‹ÄH‹ÖH‹Íèûÿÿ‹ÐH‹\$0H‹l$8H‹t$@H‹|$H‹ÂHƒÄ A\ÃH‰\$H‰l$H‰t$WHƒì H‹Ú…Éxg;
oWs_HcùH-wWH‹÷ƒçHÁþHkÿXH‹DõHƒ<ÿu;ƒ=¦u%…ÉtÿÉtÿÉu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿÿÇ-H‹DõH‰3Àëè‰ÂÿÿÇ	èžÂÿÿƒ ƒÈÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$WHƒì …Éxq;
ÇVsiHcÙH-ÏVH‹ûƒãHÁÿHkÛXH‹DýöDtEHƒ<ÿt>ƒ=÷u'…ÉtÿÉtÿÉu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿ3Òÿ-H‹DýHƒÿ3Àëè×ÁÿÿÇ	èìÁÿÿƒ ƒÈÿH‹\$0H‹l$8HƒÄ _ÃÌÌHƒì(ƒùþuèÆÁÿÿƒ èžÁÿÿÇ	ëM…Éx1;
Vs)HcÑH
VH‹ÂƒâHÁøHkÒXH‹ÁöDtH‹ëè|Áÿÿƒ èTÁÿÿÇ	èA±ÿÿHƒÈÿHƒÄ(ÃH‹ÄH‰XH‰pH‰xL‰` AVHƒì HcÙL‹ãIÁüL5ªUƒãHkÛXK‹4濃|3u4O	èýÿÿƒ|3uHL3º ÿk-÷ØÒ#úÿD3¹
èÃûÿÿ…ÿtK‹æHLÿ\.‹ÇH‹\$0H‹t$8H‹|$@L‹d$HHƒÄ A^ÃÌÌÌHcÑH
"UH‹ÂƒâHÁøHkÒXH‹ÁHLHÿ%.H‰\$H‰t$H‰|$ATAUAVHƒì@HƒÎÿD‹æE3í^‹Ëèsûÿÿ…Àu‹Æ鶋ËèIüÿÿ3ÿH»T‰|$$ƒÿ@‹Lc÷J‹ðH…Û„ñH‰\$0J‹ðHH;؃ÉöC…«ƒ{u<¹
èðûÿÿƒ{u!HKº ÿN,…ÀuDhD‰l$(ëÿC¹
èžúÿÿE…íudHKÿ;-öCtHKÿ3-ëHHƒÎÿE…íu?ÆCH‰3LTK+ðH¸£‹.ºè¢‹.H÷ëL‹âIÁüI‹ÄHÁè?Là‹ÇÁàDàD‰d$ ëHƒÃXHƒÎÿHÂSéÿÿÿD;æ…‘ÿÇéëþÿÿºXJÈè˜óÿÿH‰D$0H…ÀtsHc×LŒSI‰ЃmS I‹ÐHÁH;ÁsÆ@H‰0Æ@	
ƒ`HƒÀXH‰D$0ëÖÁç‰|$ HcÏH‹ÁHÁøƒáHkÉXI‹ÀÆD‹Ïè[ýÿÿ…ÀDþD‹ç‰|$ ¹è}ùÿÿA‹ÄH‹\$`H‹t$hH‹|$pHƒÄ@A^A]A\ÃH‹ÄH‰XH‰pH‰x ATHƒì0H‹ñE3äD‰`èöÂA¶ÜAD$ Eغâs€Ë€„Òy€ËÿÀ+…Àuÿ+‹ÈèS¾ÿÿƒÈÿ鈃øu€Ë@ëƒøu€Ëè„ýÿÿHcø‰|$Hƒÿÿuèã½ÿÿÇèø½ÿÿD‰ ëÀH‹Ö‹Ïè¹úÿÿ€ËH‹×H‹ÏHÁùLIRƒâHkÒXI‹Ȉ\I‹È€d8€I‹È€d8ÇD$ ‹Ïèíüÿÿ‹ÇH‹\$@H‹t$PH‹|$XHƒÄ0A\ÃÌ@USVWATAUAVAWH‹ìHƒìxH‹e
H3ÄH‰Eð3ÿ™”øÿÿMcùHcò‰}¸‰}¼‰}ÀƒûFŒ\ûLPFÿƒø‡DAƒÿ‡:LcmhAƒý;‡,LcupAƒþ;‡DWE;ÂŒH
ÄA»…ëQD‹L±ü‹±A+ÉA;È}b‹Ã%€}	A+ƒÈüAÂ…ÀuA‹Ã÷ëÁú‹ÂÁèÐkÒd;Úu#‹lA‹Ã÷éÁú‹ÂÁèÐiÒ;Ê…¥ƒþ…œAƒø’‹ÃG$%€}	A+ƒÈüAÂ…ÀuA‹Ã÷ëÁú‹ÂÁèÐkÒd;Úu‹lA‹Ã÷éÁú‹ÂÁèÐiÒ;Êuƒþ~Eâ謶ÿÿHM¸èKºÿÿ…À…HM¼èjºÿÿ…À…êHMÀ艺ÿÿ…À…Ä‹+Aº…ëQDCÿA‹ÂD‰eä‰]ÜD‰}ÐD‰mÌD‰uÈ÷éD‹ÊA‹ÂAÁùA‹ÉÁéDÉA÷èÁúA‹À‹ÊÁéÑD+Ê™ƒâÂÁøALïHcÃHƒèFHcÑHiÀmHÐIcÄHÐHcEÀHRI<ÏHkÿIƒÆèê¦E3Ò…À„ß‹D$@AöÅ tf‰ë‰ÇD$\éYAƒÍ@A¹
‹T$H¸€D…èt	M‹IƒÆë:AºårðIƒÆAöÅ tL‰t$pAöÅ@tM¿FøëE·FøëAöÅ@tMcFøëE‹FøL‰t$pAöÅ@t
M…ÀyI÷ØAºíD…èu
AºårE‹ÀE…ÿyA¿ëAƒå÷E;ûEOûD‹t$`I‹ÀH¿H÷ØÉ#ʉL$HA‹ÏAÿÏ…ÉM…Àt 3ÒI‹ÀIcÉH÷ñL‹ÀB0ƒø9~AƈHÿËëÑL‹t$pH…¿+ÃHÿÉD$DE…ë„…Àt	€;0„úHÿËÿD$DÆ0éëuA€ügu=A¿ë5E;ûEOûAÿ£~%A¿]HcÏèEãÿÿH‰E H…ÀtH‹Ø‹÷ëA¿£I‹H‹
­IƒÆA¾üHcöH‰E¸ÿàHM€D‹ÏH‰L$0‹L$xL‹Æ‰L$(HM¸H‹ÓD‰|$ ÿÐA‹ýç€tE…ÿuH‹
tÿžHU€H‹ËÿÐA€ügu…ÿuH‹
Lÿ~HU€H‹ËÿЀ;-uAºíHÿÃH‹Ëè¸äÿÿE3Ò‰D$DD9T$\…FAöÅ@t1AºåsÆD$L-ëAöÅtÆD$L+¿‰|$HëAöÅtÆD$L ëè‹|$HD‹d$TH‹t$hD+d$DD+çAöÅuLL$@L‹ÆA‹Ô± è	øÿÿLL$@HL$LL‹Æ‹×èIøÿÿAöÅtAöÅuLL$@L‹ÆA‹Ô±0è×÷ÿÿ‹|$D3À9D$Pti…ÿ~eH‹óD·H•ÀHM¨A¸ÿÏHƒÆèÀ¥E3Ò…Àu+‹U¨…Òt$L‹D$hLL$@HÀèÔ÷ÿÿE3Ò…ÿuµH‹t$hë%H‹t$hAƒÈÿD‰D$@ëLL$@L‹Æ‹×H‹Ëè¤÷ÿÿE3ÒD‹D$@E…Àx AöÅtLL$@L‹ÆA‹Ô± è+÷ÿÿE3ÒD‹D$@H‹E H…ÀtH‹Èè*SÿÿD‹D$@E3ÒL‰U H‹}°ƒÎÿ‹T$XA»L
f·þÿDŠ'E„ä…YùÿÿD8U˜tH‹Mƒ¡ÈýA‹ÀH‹ÈH3ÌèçJÿÿH‹œ$ HÄÐA_A^A]A\_^]ÃA€üIt7A€üht(A€ült
A€üwužAºíë—€?lu
HÿÇAºíëˆAƒÍë‚AƒÍ éyÿÿÿŠAºí<6u€4uHƒÇAºíéZÿÿÿ<3u€2uHƒÇAºõéBÿÿÿIƒÆE…ÿ‰¡þÿÿD‹þé™þÿÿC¿A¾ÄD|HÐé‡þÿÿE‹úéþÿÿA€ü*uA‹IƒÆ‰D$T…À‰fþÿÿAƒÍ÷Øë‹D$T€A¾ÄDHЉD$TéFþÿÿA€ü tAA€ü#t1A€ü+t"A€ü-tA€ü0…$þÿÿAƒÍéþÿÿAƒÍéþÿÿAƒÍé	þÿÿAºíéÿýÿÿAƒÍéöýÿÿD‰T$xD‰T$\D‰T$TD‰T$HE‹êD‹þD‰T$PéÒýÿÿ迪ÿÿÇ謚ÿÿ3À8E˜é×öÿÿÌÌHƒì(H…Éu蚪ÿÿÇ臚ÿÿƒÈÿë‹AHƒÄ(ÃÌÌH‹ÄH‰XH‰pH‰x H‰PATAUAVHƒì M‹éM‹àH‹úL‹ñ3ö3ÀH…Ò•À…ÀuèDªÿÿÇè1šÿÿƒÈÿéÛ3ÀM…À•À…ÀtÜH‹ÊèA[ÿÿöG@…†H‹Ïèbÿÿÿƒøÿt*ƒøþt%HcÐH‹ÊHÁùLƒ>ƒâHkÒXIÈH
ÑëH
ÈH‹ÑL^>öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€tèš©ÿÿÇ臙ÿÿƒÎÿ…öu(H‹Ïè(òÿÿ‹ØL‹L$`M‹ÅI‹ÔH‹ÏAÿÖ‹ðH‹×‹ËèÝòÿÿH‹Ïè[ÿÿ‹ÆH‹\$@H‹t$PH‹|$XHƒÄ A^A]A\ÃHƒì8L‰L$ M‹ÈL‹ÂH‹ÑH
ôÿÿèžþÿÿHƒÄ8ÃÌHƒì8L‰L$ M‹ÈL‹ÂH‹ÑH
£èzþÿÿHƒÄ8ÃÌHƒì8L‰L$ M‹ÈL‹ÂH‹ÑH
#°èVþÿÿHƒÄ8ÃÌHƒì8L‰D$ L‹ÂH‹ÑH
®óÿÿE3Éè2þÿÿHƒÄ8ÃÌHƒì8L‰D$ L‹ÂH‹ÑH
®¢E3ÉèþÿÿHƒÄ8ÃÌHƒì8L‰D$ L‹ÂH‹ÑH
º¯E3ÉèêýÿÿHƒÄ8ÃÌH‰\$H‰t$WHƒì03ÿOècäÿÿ_‰\$ ;1O}eHcóH‹
?Hƒ<ðtPH‹ðöAƒtè`ÿÿƒøÿtÿlj|$$ƒû|1H‹à>H‹ðHƒÁ0ÿzH‹
Ë>H‹ñèúMÿÿL‹»>Iƒ$óÿÃë¹èÄâÿÿ‹ÇH‹\$@H‹t$HHƒÄ0_ÃÌÌH‰\$H‰t$WHƒì ‹A3öH‹Ù$<u?÷At6‹9+y…ÿ~-èÜüÿÿH‹SD‹Ç‹ÈèÖ0;Çu‹C„Àyƒàý‰CëƒK ƒÎÿH‹Kƒc‹ÆH‹t$8H‰H‹\$0HƒÄ _ÃÌÌÌ@SHƒì H‹ÙH…Éu
HƒÄ [é4ègÿÿÿ…ÀtƒÈÿë ÷C@tH‹Ëè]üÿÿ‹Èè^¿÷ØÀë3ÀHƒÄ [ÃH‰\$H‰t$H‰|$ATAUAWHƒì0D‹é3ö3ÿNèàâÿÿ3ÛAƒÏÿ‰\$ ;«M€LcãH‹ƒ=Jƒ<àthJ‹àöBƒt^‹ËèXÿÿH‹c=J‹àöAƒt3Aƒýuè6ÿÿÿA;Çt#ÿƉt$$ëE…íuöAtèÿÿÿA;ÇADÿ‰|$(H‹=J‹â‹Ëè@XÿÿÿÃépÿÿÿ¹èáÿÿAƒýDþ‹ÇH‹\$PH‹t$XH‹|$`HƒÄ0A_A]A\ÃH‰\$H‰L$WHƒì H‹ÙH…ÉuèøþÿÿëèWÿÿH‹Ëèœþÿÿ‹øH‹ËèŠWÿÿ‹ÇH‹\$8HƒÄ _Ã̹éÆþÿÿÌÌH‹ÄH‰XH‰hH‰p ‰HWHƒì H‹ÊH‹Úèêúÿÿ‹KHcðöÁ‚uè‚¥ÿÿÇ	ƒK ƒÈÿé4öÁ@t
èf¥ÿÿÇ"ëâ3ÿöÁt‰{öÁ„‰H‹CƒáþH‰‰K‹C‰{ƒàïƒÈ‰C©u/è7UÿÿHƒÀ0H;Øtè)UÿÿHƒÀ`H;Øu‹ÎèQ™…ÀuH‹Ëè­¿÷C„‹+H‹S+kHBH‰‹C$ÿȉC…í~D‹Å‹Îè&.‹øëWƒÉ ‰Ké?ÿÿÿƒþÿt#ƒþþtH‹ÎH‹ÆH49ƒáHÁøHkÉXHÂëH
|öA t3Ò‹ÎDBèE¾Hƒøÿ„ïþÿÿH‹KŠD$0ˆë½HT$0‹ÎD‹Åè«-‹ø;ý…Åþÿÿ¶D$0H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì I‹ñI‹øH‹ÚH;
udM9u=H‹ºèØÿÿH‰H…Àu3ÀëKH‹D$PH‹ÖÇL‹H‹èt<ÿÿL‹MÛL‰ë"H‹H‹A¸èLÙÿÿH…ÀtÂH‰H‹HÉH‰¸H‹\$0H‹t$8HƒÄ _ÃÌÌH‹H‹€(ÃÌ@SHƒì ¾Ù¶Éè7zÿÿ‹Ëƒá߃é…ÀEË‹ÁHƒÄ [ÃÌÌHƒì(ÿIxH‹¶HÿÀH‰ëè;‹Ð‹ÂHƒÄ(ÃÌÌÌHƒì(ƒùÿtè*¾HƒÄ(ÃÌH‰\$H‰t$WHƒì H‹òH‹ùÿH‹Îè¥ÿÿÿ‹Øƒøÿt¶Èè†{ÿÿ…ÀuãH‹t$8‹ÃH‹\$0HƒÄ _ÃH‰\$UVWATAUAVAWH¬$€þÿÿHì€H‹ÆïH3ÄH‰…p3ÀLmL‰M¸I‹ØL‹âH‰T$PL‰l$xH‹ñH‰L$hHÇE°^‰E„f‰Eˆ‹ø‰D$mÿÿE3À…ÀtfHÁe‹Î@¾ßè?lÿÿH‹u‹ûƒçßE3Àƒï…ÀEû‰|$kÿÿ‹t$\‹ûE3Àƒç߃ï…ÀEû‰|$<¸t>ÐD$L‰t$\D9D$`tD+èt6H‹\$hD$4H‹ËèØðÿÿ‹ø‰D$<éKÿÿÿÿL$4A;ÿt
H‹Ó‹Ïè¯E3À‹t$\D8D$@t÷Þ‰t$\‹D$LAƒþFADÀ…À„¨÷ÿÿD8D$0uÿD$p‹D$\ëD‹d$HH‹M E…ätH‹EH‰L‹d$PD‹t$4ëL‹d$PD‹t$4D8D$8t‰ëf‰H‹t$hA½Dl$9MåL‰d$PëbA8$uID$8LDàEõH‹ÎD‰t$4è
ðÿÿ‹ø‰D$	Aƒýc„Aƒýd„*	ŽRAƒýg~vAƒýitXAƒýn…<D‹t$4A‹Æ„ÉuD‹t$LH‹M˜E…ö„H‹EH‰D‹t$4H‹t$pL‹d$`A½Dl$9Iõ3ÛH‰t$péRA½dƒÿ-…$ˆT$@é I‹Ùƒÿ-u
H‹D$xH‹Ú@ˆ8ëƒÿ+u(L‹l$`D‹d$HD‹t$4I‹ÍD+âDòèQúÿÿE3É‹ø‰D$<ëD‹d$HL‹l$`D‹t$4D9L$P@¶ÏEDçè‘bÿÿ3öë^A‹Ä¹D+á…ÀtSH‹D$xL$XLM@ˆ<HÙHEˆLD$xHU¨H‹ËH‰D$ è$ùÿÿ…À„‘I‹ÍAÿÆèÑùÿÿ¶È‹ø‰D$<è/bÿÿ…ÀužH‹EÐH‹ˆ(H‹¹@Š0@:÷…¹A‹ÄD+á…À„«DñI‹Íè‡ùÿÿLMLD$x‹ø‰D$ÐD$X‰t$\D9L$PtD+àt6H‹\$`D$4H‹Ëè&ðÿÿ‹ø‰D$<éKÿÿÿÿL$4A;ÿt
H‹Ó‹Ïè´œE3É‹t$\D8L$@t÷Þ‰t$\‹D$XAƒýFADÁ…À„•÷ÿÿD8L$0…õÿÿÿD$h‹D$\éëôÿÿD‹t$4D8L$8t‰éñôÿÿf‰ééôÿÿ8u
HF8HDðEõI‹ÌD‰t$4èïÿÿ‹ø‰D$<¶IõH‰t$p;Ç…Ù@¶Ïè™…ÀtI‹Ìèaïÿÿ¶IõH‰t$p;È…¢A;ÿu€>%…õöÿÿ€~n…ëöÿÿŠ„À„áöÿÿéìðÿÿA;ÿ„ÓöÿÿH‹T$`‹Ïè¾›éÂöÿÿE„ä~fD‰	ëDˆ	螀ÿÿÇé¤öÿÿA;ÿtH‹T$`‹Ï芛A½éöÿÿèr€ÿÿE3äÇE‹ì@„öt	fD‰#éqöÿÿDˆ#éiöÿÿA;Çt
I‹Ô‹ÈèI›A;ÿ„IöÿÿI‹ÔésÿÿÿE‹éé>öÿÿAƒýu'è€ÿÿÇè
pÿÿD8eètH‹Màƒ¡Èý‹D$hë‹\$h3É8MètH‹Eàƒ Èý‹ÃH‹pH3ÌèøÿÿH‹œ$ÐHÄ€A_A^A]A\_^]ÃÌH‰\$WHƒì Hcù‹Ïèð½ÿÿHƒøÿtYH‹+¹ƒÿu	@„¸¸u
;ùuö@`tèÁ½ÿÿ¹H‹Øè´½ÿÿH;Ãt‹Ï訽ÿÿH‹ÈÿWì…Àu
ÿ5ì‹Øë3Û‹ÏèܼÿÿL‹ßH‹ÏHÁùAƒãH»H‹ÊMkÛXBÆD…Ût‹ËèNÿÿƒÈÿë3ÀH‹\$0HƒÄ _ÃH‰\$‰L$VWATHƒì HcÙƒûþuèþ~ÿÿƒ èÖ~ÿÿÇ	é…Éxe;As]H‹ûH‹óHÁþL%BƒçHkÿXI‹ô¾L8ƒát7‹ËèR½ÿÿI‹ôöD8t‹ËèÇþÿÿ‹øëèv~ÿÿÇ	ƒÏÿ‹Ëèνÿÿ‹Çëè}~ÿÿƒ èU~ÿÿÇ	èBnÿÿƒÈÿH‹\$PHƒÄ A\_^ÃÌ@SHƒì öAƒH‹Ùt"öAtH‹Iè.$ÿÿc÷ûÿÿ3ÀH‰H‰C‰CHƒÄ [ÃÌH‰\$ UVWATAUAVAWH¬$Ðåÿÿ¸0è"0ÿÿH+àH‹èÊH3ÄH‰… 3ÿE‹ðL‹ê!|$DHcÙE…Àu3ÀéåH…ÒuèÅ}ÿÿ!8èž}ÿÿÇè‹mÿÿƒÈÿéÁL‹ûL‹ãHIÁüAƒçJ‹àL‰d$PMkÿXAŠt8L‰|$`@ö@Ðþ@€þt@€þu	A‹Æ÷ШtšAöD t
3Ò‹ËDBèg–‹Ëètq…À„ÊH­J‹àAöD€„³耎ÿÿ3ÛHT$\H‹ˆÀHƒ9YJ‹àI‹”Ãÿ?é…À„}…Ût	@„ö„pÿ,é!|$XI‹Ý‰D$\E…ö„M@„ö…„Š3À€ù
”À‰D$LH"J‹àAƒ|Pt AŠDLˆL$aA¸ˆD$`AƒdPHT$`ëI¾Éèâ…Àt4I‹ÆH+ÃIÅHƒøŽ­HL$@A¸H‹Ó蚃øÿ„²HÿÃëA¸H‹ÓHL$@èû™ƒøÿ„‘Hƒd$8Hƒd$0‹L$\HD$`LD$@A¹3ÒÇD$(HÿÃH‰D$ ÿêD‹à…À„NH‹L$PHƒd$ HEH‹ÈLL$XHT$`I‹E‹Äÿêè…À„"‹ûA+ý|$DD9d$XŒƒ|$LL‹d$P„ÅHƒd$ HñÆD$`
J‹àLL$XHT$`I‹A¸ÿŽè…À„ƃ|$XŒ²ÿD$DÿÇëz@€þt@€þu·E3äfƒø
f‰D$@A”ÄHƒÃD‰d$LëD‹d$L@€þt@€þu:·L$@èΘf;D$@ugƒÇE…ät!A¼
A‹ÌfD‰d$@諘f;D$@uDÿÇÿD$DL‹d$P‹ÃA+ÅA;Æs&éêýÿÿŠH!ÿÇJ‹âAˆDLJ‹âAÇDP‹\$LéùÿRç‹Øéì‹\$LéëHãJ‹àAöD€„þ3ÛM‹å@„ö…ËE…ö„S
D‹|$DHµ 3ÉA‹ÄA+ÅA;Æs'AŠ$IÿÄ<
uˆAÿÇHÿÆHÿÁHÿÁˆHÿÆHùÿrÎH!\$ H… D‹ÆD+ÀH‹D$PH
[H‹ÁD‰|$DL‹|$`I‹LL$HH• ÿ÷æ…À„/ÿÿÿ|$HH… H+ðHcD$HH;ÆŒA‹Äº
A+ÅA;Æ‚Fÿÿÿéó@€þ…ØE…ö„Hº
D‹|$DHµ 3ÉA‹ÄA+ÅA;Æs2A·$IƒÄfƒø
uf‰AƒÇHƒÆHƒÁHƒÁf‰HƒÆHùþrÃH!\$ H… D‹ÆD+ÀH‹D$PH
y
H‹ÁD‰|$DL‹|$`I‹LL$HH• ÿæ…À„Mþÿÿ|$HH… H+ðHcD$HH;ÆŒ*A‹Äº
A+ÅA;Æ‚;ÿÿÿéE…ö„pA¸
HL$p3ÒA‹ÄA+ÅA;Æs/A·$IƒÄfƒø
ufD‰HƒÁHƒÂHƒÂf‰HƒÁHú¨rÆHƒd$8Hƒd$0HD$p+ÈLD$pÇD$(U
‹Á¹éý™+Â3ÒÑøD‹ÈH… H‰D$ ÿ%æD‹ø…À„›3öH‹D$PHƒd$ HcÎH”
 E‹ÇH
XH‹ÁH‹D$`LL$HH‹D+Æÿýä…Àtt$HD;þ¸ëÿ€ä‹ØD;þA‹üA¸
A+ýA;þ‚ÿÿÿL‹|$`…ÿ…›…Ût\ƒûuKè]wÿÿÇ	èrwÿÿ‰é¸ùÿÿÿ1ä‹ØëÉI‹H!|$ LL$HE‹ÆI‹Õÿ{ä…À„³üÿÿ‹|$H3Û뤋ËèPwÿÿéxùÿÿH‹D$PH
“H‹ÁAöD@tA€}„2ùÿÿèãvÿÿÇèøvÿÿƒ é=ùÿÿ+|$D‹ÇH‹ H3ÌèßÿÿH‹œ$ˆHÄ0A_A^A]A\_^]ÃH‰\$‰L$VWATAUAVHƒì A‹ðL‹âHcùƒÿþuè˜vÿÿƒ èpvÿÿÇ	é…Éxs;=Û
skH‹ßL‹ïIÁýL5Ü
ƒãHkÛXK‹î¾LƒátE‹Ïèì´ÿÿK‹îöDtD‹ÆI‹Ô‹Ïèøÿÿ‹Øëè
vÿÿÇ	èvÿÿƒ ƒËÿ‹ÏèZµÿÿ‹Ãëè	vÿÿƒ èáuÿÿÇ	èÎeÿÿƒÈÿH‹\$XHƒÄ A^A]A\_^ÃÌ@SHƒì@‹ÙHL$ èêÿÿH‹D$ D¶ÛH‹ˆ@B·Y%€€|$8tH‹L$0ƒ¡ÈýHƒÄ@[ÃÌÌÌ@SHƒì@‹ÙHL$ 3Òè ÿÿH‹D$ D¶ÛH‹ˆ@B·Y%€€|$8tH‹L$0ƒ¡ÈýHƒÄ@[Ã̺骓Ì̺éž“Ì̺é’“Ì̺醓Ì̺éz“Ì̺én“Ì̺éb“Ì̺éV“Ì̺€éJ“Ì̺€é>“Ì̺é2“Ì̺é&“Ì̺é“Ì̺é“Ì̺é“Ì̺éö’Ì̺Wéê’Ì̺WéÞ’Ì̺éÒ’Ì̺éÆ’Ì̺ 麒Ì̺ é®’ÌÌ3Àº€f;Ê’ÀÃÌÌ@SHƒì º·Ù艒3Ò…Àufƒû_uº‹ÂHƒÄ [Ã@SHƒì º·Ùè]’3Ò…Àufƒû_uº‹ÂHƒÄ [Ã@SHƒì º·Ùè1’3Ò…Àufƒû_uº‹ÂHƒÄ [Ã@SHƒì º·Ùè’3Ò…Àufƒû_uº‹ÂHƒÄ [ÃL‹ÉE¶IÿÁA@¿ƒøwAƒÀ ¶
HÿÂA¿ƒøwƒÁ E…ÀtD;ÁtÑD+ÁA‹ÀÃÌÌÌH‰\$H‰t$H‰|$UH‹ìHƒì@H‹ñH‹úHMàI‹Ðè?ÿÿH…öu(èùrÿÿÇèæbÿÿ€}øtH‹Eðƒ Èý¸ÿÿÿëkH…ÿtÓH‹EàƒxuH‹×H‹ÎèTÿÿÿ€}øtKH‹Mðƒ¡Èýë>H+÷¶>HUà虑¶HUà‹Øè‹‘HÿÇ…Ût;ØtÚ+Ø€}øtH‹Mðƒ¡Èý‹ÃH‹\$PH‹t$XH‹|$`HƒÄ@]ÃÌÌHƒì(ƒ=]äu-H…Éuè=rÿÿÇè*bÿÿ¸ÿÿÿHƒÄ(ÃH…ÒtáHƒÄ(é²þÿÿE3ÀHƒÄ(éâþÿÿÌÌH‰\$H‰l$VWATAUAWHƒì0‹-îI‹ñE3ÉE3ÒE3Û€: EyE‹àH‹ÚL‹éuI߀; tø€;at/€;rt#€;wtè¶qÿÿÇè£aÿÿ3Àé7¿ë3ÿAïë¿	ƒÍIßA‹×Š„À„»A¸@…Ò„î¾ÈƒùSytjƒé „΃étGÿÉt>ƒét'ƒé
tƒùuŠE…Ò…¥E‹×ƒÏ颺ïé™@öÇ@…‡ƒÏ@é‡E‹ßëz@öÇutƒçþƒåüƒÏºíëmE…Òu`E‹×ƒÏ ë`ƒéTtMƒét:ÿÉt)ƒétƒù…ÿÿÿ÷ÇÀu4Aøë7E…Éu*E‹Ïºõë)E…ÉuE‹ÏAèë÷ÇÀuºïëºçs3ÒëºïIߊ„À…
ÿÿÿE…Û„¶ëI߀; tøH
œ]A¸H‹Óèæ…À…—þÿÿHƒÃëI߀; tø€;=…€þÿÿI߀; tøHd]A¸H‹ËèBœ…Àu
HƒÃºïëMHM]A¸H‹Ë蜅Àu
HƒÃºïë*H:]A¸H‹Ëèü›…À…þÿÿHƒÃºïëI߀; tø€;…úýÿÿHL$hE‹ÌD‹ÇI‹ÕÇD$ €袙…À…çýÿÿD=ÇÚ!F‹D$hHƒ&HƒfHƒf(‰F‰nH‹ÆH‹\$`H‹l$pHƒÄ0A_A]A\_^ÃÌÌH‰\$H‰t$WHƒì03ÛKèS«ÿÿ3ÿ‰|$ ;="ìHc÷H‹úHƒ<ðtfH‹ðö@ƒuU÷@€uLGýƒøwOè$ªÿÿ…À„°H‹ÁH‹ò‹Ïèb ÿÿL‹¯I‹óö@ƒtH‹Ð‹ÏèÇ ÿÿëH‹Øë|ÿÇéyÿÿÿ¹Xè³¢ÿÿH‹ÈHcÿH‹vH‰øH…ÉtUHƒÁ0º ÿÛ…ÀuH‹
SH‹ùè‚ÿÿL‹CIƒ$ûë$H‹5H‹øHƒÁ0ÿïÛL‹ I‹ûƒcH…Ûtc€ƒcHƒcHƒ#Hƒc(ƒKÿ¹è©ÿÿH‹ÃH‹\$@H‹t$HHƒÄ0_ÃÌÌÌÌÌÌÌff„HìØM3ÀM3ÉH‰d$ L‰D$(è"¿HÄØÃÌÌÌÌÌÌfDH‰L$H‰T$D‰D$IÇÁ “ëÌÌÌÌÌÌfÃÌÌÌÌÌÌf„ÃÌÌÌH‹ÄH‰XH‰hH‰pWHƒìPHƒ`ÈH‹ú3ÒI‹èH‹ÙDB(HHÐI‹ñèøÿÿH…ÿuèJmÿÿÇè7]ÿÿƒÈÿëRH…ÛtæHL$ L‹ÎL‹ÅH‹×ÇD$(ÿÿÿÇD$8BH‰\$0H‰\$ èü·ÿÿÿL$(‹Øx
H‹L$ ÆëHT$ 3Éè6Çÿÿ‹ÃH‹\$`H‹l$hH‹t$pHƒÄP_ÃÌÌÌM‹ÈE3Àé=ÿÿÿÌH‹ÄH‰XH‰hH‰pWHƒìPHƒ`ÈH‹Ú3ÒI‹ðH‹éDB(HHÐI‹ùè4ÿÿH…Ûuè†lÿÿÇès\ÿÿƒÈÿë,Hƒd$0Hƒd$ HL$ L‹ÏL‹ÆH‹ÓÇD$(ÿÿÿÇD$8BÿÕH‹\$`H‹l$hH‹t$pHƒÄP_ÃÌL‹ÊH‹ÑH
·ÿÿE3Àé[ÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
·ÿÿéCÿÿÿÌÌÌL‹ÊH‹ÑH
?sE3Àé+ÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
$séÿÿÿÌÌÌH‰\$H‰t$H‰|$UATAUH‹ìHƒìP3ÛM‹àL‹éH‹òHMØDC(3ÒI‹ùH‰]Ðè<ÿÿH…ÿuèŽkÿÿÇè{[ÿÿƒÈÿëvM…ätH…ötáL‹MHL‹E@¹ÿÿÿL;áA‹ÄH‹×GÁHMÐÇEèBH‰uàH‰uЉEØAÿÕ‹øH…öt3…Àx!ÿMØxH‹EЈëHUÐ3ÉèkÅÿÿƒøÿt‹Çë9]ØBˆ\&ÿÃCþL\$PI‹[ I‹s(I‹{0I‹ãA]A\]ÃÌÌHƒì8L‰L$(Hƒd$ M‹ÈL‹ÂH‹ÑH
ÁµÿÿèôþÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂH‹ÑH
‰µÿÿè¼þÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌ@SHƒì0H‹ÙM…ÀtGH…ÉtBH…Òt=H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂH‹ÑH
adèpþÿÿ…Àyƃøþu è3jÿÿÇ"ëè&jÿÿÇèZÿÿƒÈÿHƒÄ0[ÃÌÌHƒì8L‰L$ E3ÉèÿÿÿHƒÄ8ÃÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì0I‹éI‹ðH‹ÚH‹ùM…É„ìM…ÀuH…ÉuH…Ò…Ù3ÀéåH…É„ÉH…Ò„ÀI;ÐvMè”iÿÿLFH
¡c‹H‹D$hL‹ÍH‰D$(H‹D$`H‹×H‰D$ è”ýÿÿƒøþulè^iÿÿƒ8"…‡èPiÿÿ‰ë~èGiÿÿH
XcL‹ÍD‹ H‹D$hL‹ÃH‰D$(H‹D$`H‹×H‰D$ èGýÿÿÆDÿƒøþuHƒþÿuèiÿÿƒ8"u3èühÿÿD‰ ë)…Ày(ƃøþuèæhÿÿÇ"ëèÙhÿÿÇèÆXÿÿƒÈÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A\ÃHƒì8H‹D$`H‰D$(Hƒd$ èŸþÿÿHƒÄ8ÃÌÌHƒì8L‰L$(Hƒd$ M‹ÈL‹ÂH‹ÑH
¹oè˜üÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂH‹ÑH
oè`üÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌH‰\$H‰t$WHƒì H‹ùH…ÉuèhÿÿÇèõWÿÿé‹A¨ƒ„¨@…¨tƒÈ ‰AéñƒÈ‰A©uèx‚ëH‹AH‰H‹Ïè½ÿÿD‹G$H‹W‹Èè\œ‰G…À„£ƒøÿ„šöG‚u_H‹ÏèÚ¼ÿÿƒøÿtƒ=€Þu5ºH
‚ýÿÿÿüσøu‰aÞëè®cÿÿH‹ØÿqЉA¼‹Ïƒé„™ƒétlƒé	t?ƒétÿÉt^H‹\$ é¢H‹
Þÿ$ÑH‹ØHƒþ„ˆH‹Îÿ^ÑH‰ßÝëvH‹
æÝÿøÐH‹ØHƒþt`H‹Îÿ6ÑH‰ÇÝëNH‹
¶ÝÿÐÐH‹ØHƒþt8H‹ÎÿÑH‰—Ýë&H‹
~Ýÿ¨ÐH‹ØHƒþtH‹ÎÿæÐH‰_Ý3Éè¤ÿÿE…äuH‹Ãë-ƒÿt$ƒÿtƒÿ
tƒÿ~ƒÿ~è„bÿÿÇèqRÿÿHƒÈÿH‹\$@H‹t$HH‹|$PHƒÄ0A\ÃÌÌÌH‰\$H‰t$WATAUAVAWHƒì0‹Ù3ÿ‰|$`3ö‹Ñƒê„ŃêtbƒêtMƒêtXƒêtSƒêt.ƒêtÿÊt5è	bÿÿÇèöQÿÿë@L%©ÜH‹
¢ÜéŒL%¦ÜH‹
ŸÜë|L%ŽÜH‹
‡Üëlè¼rÿÿH‹ðH…ÀuƒÈÿérH‹ H‹ÊLcP9YtHƒÁI‹ÀHÁàHÂH;ÈrèI‹ÀHÁàHÂH;Ès9Yt3ÉLaM‹,$ë L%ÜH‹
	Ü¿‰|$`ÿ*ÏL‹èIƒýu3ÀéüM…íu
AMèKÿÿÌ…ÿt3Éè<ÿÿƒûtƒûtƒûtL‹|$(ë,L‹¾¨L‰|$(Hƒ¦¨ƒûuD‹¶°Ç†°ŒëD‹t$`ƒûu9‹
%O‹Ñ‰L$ ‹OÈ;Ñ}*HcÊHÉH‹† HƒdÈÿ‰T$ ‹
ôNëÓè‰pÿÿI‰$…ÿt3Éè‚›ÿÿ¿;ßu
‹–°‹ÏAÿÕë‹ËAÿÕ;ßtƒût	ƒû…ÿÿÿL‰¾¨;ß…	ÿÿÿD‰¶°éýþÿÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌH‰
õÚÃH‰\$H‰l$H‰t$WHƒì H‹éH‹
ÖÚÿØÍH‹øH…íuèï_ÿÿ»‰èÛOÿÿ‹Ã髃eH…Àu~H
@MÿÌH‹ðH…ÀtÊHMH‹ÈÿjÌH‹øH…Àu+è¡_ÿÿH‹Øÿ„Ì‹ÈèI_ÿÿ‰è‚OÿÿÿpÌ‹Èè5_ÿÿëJH‹ÈÿžÍH‹ØèZoÿÿH‡7ÚH;Øt	H‹ÎÿyʺH‹Íÿ×…ÀuèB_ÿÿÇè7_ÿÿ‹ë3ÀH‹\$0H‹l$8H‹t$@HƒÄ _Ã@SUVWATAUAVHìÐH‹¬H3ÄH‰„$ÀH‹œ$0A‹ñE‹àL‹ñƒú…
LL$@D‹ÆA‹ÔH|$@3íÇD$ €èG–D‹è…Àu\ÿžËƒøzux!l$ E3ÉD‹ÆA‹ÔI‹Îè –Lcè…Àt\UI‹Íè“ÿÿH‹øH…ÀtIL‹ÈD‹ÆA‹ÔI‹Î½D‰l$ èë•D‹è…ÀtIcõºH‹ÎèØ’ÿÿH‹ÈH‰H…Àu1…ítH‹ÏèIÿÿƒÈÿH‹Œ$ÀH3ÌèFüþÿHÄÐA^A]A\_^][ÃAEÿL‹ÇH‹ÖLcÈè†
…Àu…ítH‹Ïèÿÿ3Àë¸Hƒd$ E3ÉE3À3Ò3ÉèMÿÿ̽;ÕuTHƒ#E3ÉE3À‹ÖA‹ÌÿÊHcø…Àt'H‹Ï‹Õè1’ÿÿH‰H…ÀtD‹ÏL‹À‹ÖA‹ÌÿØÉ…ÀušH‹è”ÿÿHƒ#éBÿÿÿ…Ò…:ÿÿÿ!T$0ºîLD$0‹ÖD‹ÍA‹Ìÿ É…À„ÿÿÿŠD$0ˆéSÿÿÿÌH‰
ØÃH‰\$H‰l$H‰t$WATAUHƒì L‹éH‹
ÒóÿìÊH‹
½óH‹èÿÜÊH‹øH;Å‚•H‹ØH+ÝLcIƒü‚H‹ÍèÈ”H‹ðI;ÄsOºH;ÂHBÐHÐH;Ðr
H‹ÍèÄ‘ÿÿH…ÀuHV H;ÖrGH‹Í讑ÿÿH…Àt:HÁûH‹ÈH<Øÿ´ÊH‰=óI‹Íÿ¤ÊHOH‰ÿ—ÊH‰óI‹Åë3ÀH‹\$@H‹l$HH‹t$PHƒÄ A]A\_Ã@SHƒì ºJè½ÿÿH‹ÈH‹ØÿQÊH‰ÚòH‰ËòH…ÛuCëHƒ#3ÀHƒÄ [ÃÌH‰\$H‰t$H‰|$ATAUAVHƒì L‹ñè/BÿÿH‹
“òÿ­ÉL‹àH‹
{òÿÉH‹ØI;Ä‚›H‹øI+üLoIƒý‚‡I‹Ì艓H‹ðI;ÅsUºH;ÂHBÐHÐH;ÐrI‹Ìè…ÿÿ3ÛH…Àuë3ÛHV H;ÖrII‹ÌèiÿÿH…Àt9’Àuǃ°Šë*9µÀuǃ°ë9´À‹ÇºŽD‰ƒ°‹“°¹AÿЉ»°ë
L‰I‹IAÿÐH‰«¨éÔþÿÿ3ÀH‹\$0H‹l$8H‹t$@HƒÄ _øcsmà;Èu‹Èé þÿÿ3ÀÃÌH‰\$WHƒì 3ÿ9=ªíuè+cÿÿH‹|íH]ÉH…ÛHDØ€; w	€;t3…ÿt)€;"u	3À…ÿ”À‹ø¶èò…ÀtHÿÃHÿÃëÐ< w	HÿÊ„ÀuóH‹ÃH‹\$0HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0ƒ=%íuè¦bÿÿH‹ïÁ3ÿH…ÛuƒÈÿé´<=tÿÇH‹ËèjŒÿÿH\Š„ÀuçGºHcÈ觊ÿÿH‹øH‰mÁH…ÀtÀH‹¡Á€;tPH‹Ëè,Œÿÿ€;=pt.HcîºH‹ÍèlŠÿÿH‰H…ÀtsL‹ÃH‹ÕH‹Èè:‰ÿÿ…ÀuKHƒÇHcÆHØ€;u·H‹LÁH‹Ëè¼ûþÿHƒ%<ÁHƒ'Ç>ì3ÀH‹\$@H‹l$HH‹t$PHƒÄ0_ÃHƒd$ E3ÉE3À3Ò3Éè¦DÿÿÌH‹
ºÀèmûþÿHƒ%­ÀéÿÿÿH‰
ÁÀÃH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì L‹l$`M‹ñI‹øAƒeL‹âH‹ÙAÇH…ÒtL‰IƒÄ3í€;"u3À…í@¶"”ÀHÿËèë9AÿEH…ÿtŠˆHÿǶ3HÿËÎè…ÀtAÿEH…ÿtŠˆHÿÇHÿÃ@„öt…íu­@€þ t@€þ	u¡H…ÿt	ÆGÿëHÿË3ö€;„ã€; t€;	uHÿÃëñ€;„ËM…ätI‰<$IƒÄAÿº3ÉëHÿÃÿÁ€;\tö€;"u6„Êu…ötHC€8"uH‹Øë3À3Ò…ö”À‹ðÑéëÿÉH…ÿtÆ\HÿÇAÿE…Éu늄ÀtO…öu< tG<	tC…Òt7¾Èè8ŽH…ÿt…ÀtŠHÿÈHÿÇAÿEŠˆHÿÇë…ÀtHÿÃAÿEAÿEHÿÃéYÿÿÿH…ÿtÆHÿÇAÿEéÿÿÿM…ätIƒ$$AÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A^A]A\ÃÌH‰\$H‰t$ WHƒì0ƒ="êuè£_ÿÿH=4ÎA¸3ÉH‹×Æ&ÏÿÔ¾H‹ÕéH‰=¦¾H…Ût€;uH‹ßHD$HLL$@E3À3ÒH‹ËH‰D$ è½ýÿÿHct$@H¹ÿÿÿÿÿÿÿH;ñs\HcL$HHƒùÿsQHñH;ÑrHH‹Êè݆ÿÿH‹øH…Àt8LðHD$HLL$@H‹×H‹ËH‰D$ ègýÿÿD‹\$@H‰=ë½AÿË3ÀD‰Û½ëƒÈÿH‹\$PH‹t$XHƒÄ0_ÃÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì@ÿ™¾E3äH‹øH…À„©H‹ØfD9 tHƒÃfD9#uöHƒÃfD9#uìL‰d$8H+ØL‰d$0HÑûL‹À3ÒDK3ÉD‰d$(L‰d$ ÿ:ÀHcè…ÀtQH‹Íè†ÿÿH‹ðH…ÀtAL‰d$8L‰d$0DKL‹Ç3Ò3ɉl$(H‰D$ ÿÿ¿…ÀuH‹ÎèÓ÷þÿI‹ôH‹Ïÿ÷½H‹ÆëH‹Ïÿé½3ÀH‹\$PH‹l$XH‹t$`H‹|$hHƒÄ@A\ÃH‰\$WHƒì H‹‹žHƒd$0H¿2¢ß-™+H;ÇtH÷ÐH‰tžëvHL$0ÿ¯¾H‹\$0ÿd½D‹ØI3Ûÿ°¿D‹ØI3ÛÿT½HL$8D‹ØI3ÛÿK½L‹\$8L3ÛH¸ÿÿÿÿÿÿL#ØH¸3¢ß-™+L;ßLDØL‰þI÷ÓL‰üH‹\$@HƒÄ _Ã̃%IåÃ3ÒDB
é%öþÿÌL‹Ê3ÒDB
éFöþÿÌÌ3ÒDB
é	öþÿÌL‹Ê3ÒDB
é*öþÿÌÌ3ÒDB
éýÌL‹Ê3ÒDB
éŽÌÌ@SHƒì 3ÛM‹ÐM…ÉuH…ÉuH…Òu3Àë-H…ÉtH…ÒtM…ÉuˆëéM…Àuˆè;Pÿÿ»‰è'@ÿÿ‹ÃHƒÄ [ÃL‹ÙL‹ÂIƒùÿuM+ÚAŠCˆIÿ„Àt*IÿÈuíë#L+ÑCŠAˆIÿÄÀt
IÿÈtIÿÉuèM…ÉuAˆM…À…yÿÿÿIƒùÿu
ˆ\ÿA@P뚈èÀOÿÿ»"ëƒÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„H+ÑL‹ÊöÁtŠBŠ	:ÂuVHÿÁ„ÀtWH÷ÁuæI»J	fâÿfúøwËH‹J‹	H;Âu¿Iºÿþþþþþþ~LÒHƒðÿHƒÁI3ÂI…ÃtÇëHÀHƒØÿÃ3ÀÃfff„Òt'„öt#HÁê„Òt„ötHÁê„Òt„ötÁê„Òt„öu‹3ÀÃHÀHƒØÿÃH‰\$H‰t$WHƒì ƒ=‚åH‹+ºH‹ñtmH…ÛuH9*ºt_èë@…ÀuVH‹ºH…ÛtJH…ötEH‹Îè΄ÿÿH‹øH‹H…Ét2辄ÿÿH;ÇvH‹€<9=uL‹ÇH‹Öè-@…ÀtHƒÃëÐH‹HD8ë3ÀH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0I‹ØH‹úH‹éH…Éu(è!Nÿÿ»‰è
>ÿÿ‹ÃH‹\$@H‹l$HH‹t$PHƒÄ0_ÃHƒ!H…ÒtH…ÛuëÈH…ÛuÃH…ÒtÆI‹ÉèíþÿÿH‹ðH…Àu3ÀëºH‹ÈèùƒÿÿHÿÀH‰EH…ÛtèH;Ãv¸"ëšL‹ÆH‹ÓH‹Ïèÿÿ…ÀtÊHƒd$ E3ÉE3À3Ò3ÉèÆ<ÿÿÌÌH‰\$H‰l$H‰t$WHƒì0H‹ÚH‹ùH…Éu(è`Mÿÿ»‰èL=ÿÿ‹ÃH‹\$@H‹l$HH‹t$PHƒÄ0_ÃHƒ!H…ÒtHƒ"M…ÀtÆI‹Èè7þÿÿH‹èH…Àu3ÀëÅH‹ÈèCƒÿÿºH4H‹Îè"‹H‰H…ÀuèñLÿÿÇèæLÿÿ‹ëL‹ÅH‹ÖH‹ÈèD€ÿÿ…Àu
H…Ût°H‰3ë«Hƒd$ E3ÉE3À3Ò3Éèñ;ÿÿÌ@SHƒì H‹Ù3ÀH…É•À…Àuè–LÿÿÇèƒ<ÿÿ3Àë<ºÿèYƒÿÿ3ÉH=ÿ’Á…ÉtÓ¹è|ˆÿÿH‹ËèoýÿÿH‹Ø¹èF‡ÿÿH‹ÃHƒÄ [ÃÌH‹ÄH‰XH‰pH‰xL‰` AUHƒì0M‹áI‹ðH‹úL‹é¹è-ˆÿÿ3Û‹ÃM…í•À…ÀuèLÿÿ»‰èí;ÿÿënI‰]H…ÿt
H…öu
H…ÿuH…öu¸ë‹Ã…ÀtÈH…ÿtˆI‹ÌèÓüÿÿL‹àH…Àt2H‹ÈèãÿÿHÿÀI‰EH…ötH;Æv»"ëM‹ÄH‹ÖH‹Ïèù~ÿÿ…Àu¹ès†ÿÿ‹ÃëH‰\$ E3ÉE3À3Ò3Éè£:ÿÿH‹\$@H‹t$HH‹|$PL‹d$XHƒÄ0A]ÃÌÌÌH‹ÄH‰XH‰pH‰xL‰` AUHƒì0M‹àH‹úH‹ñ¹è0‡ÿÿ3Û‹ÃH…ö•À…ÀuèKÿÿ»‰èð:ÿÿëvH‰H…ÿtH‰‹ÃM…ä•À…ÀtÖI‹ÌèëûÿÿL‹àH…ÀtOH‹Èèû€ÿÿºL,I‹ÍèÚˆH‰H…Àuè©JÿÿÇèžJÿÿ‹ëM‹ÄI‹ÕH‹Èèü}ÿÿ…ÀuH…ÿtL‰/¹èn…ÿÿ‹ÃëH‰\$ E3ÉE3À3Ò3Éèž9ÿÿH‹\$@H‹t$HH‹|$PL‹d$XHƒÄ0A]ÃÌÌL‹ÜI‰[I‰kI‰s WATAUAVAWHìH‹.—H3ÄH‰„$ˆ3ÛH‹ùI‰K¨H‰\$XD‹ëD‹ûD‹óD‹ãI‰[°9Y„CHis9]u#D·A0IK¨3ÒA¹H‰l$ è¥êÿÿ…À…ä¹è»}ÿÿA¼€ºA‹ÌH‰D$Xè#~ÿÿH‹ÖA‹ÌL‹èè~ÿÿH‹ÖA‹ÌL‹øè~ÿÿAL$H‹ÖL‹ðè÷}ÿÿL‹àH‹D$XH…À„…M…í„|M…ä„sM…ÿ„jM…ö„a‰I‹Ì‹ÃˆÆHÎ=|ò‹MHT$pÿW·…À„6ƒ|$p‡+·D$p‰D$P;Æ~/8\$vt)HL$w8t ¶Qÿë
HcÂÖBÆ  ¶;Ð~ïHƒÁ8YÿuÜ‹E‰\$8I‰\$0‰D$(H‰L$ 3ÉA¹M‹Ä‹ÖèO…À„º‹E‹W‰\$@‰D$8¸ÿI‰D$0H‰L$(D@ML$3ɉD$ è…À„{‹E‹W‰\$@‰D$8¸ÿIŽ‰D$0H‰L$(ML$3ÉA¸‰D$ è×…À„:I­þf‰]Aˆ_Aˆ^AˆŸ€Aˆž€9t$P~98\$vt3HL$w8t*¶QÿëHcÂA¸€ÖfE‰„E¶;Ð~åHƒÁ8YÿuÒI•A¸þI‹Íè>àþÿI—A¸I‹Ïè)àþÿI–A¸I‹ÎèàþÿH‹0H…ÉtDðÿ	u?H‹8Héþè`íþÿH‹HHƒÁ€èPíþÿH‹PHƒÁ€è@íþÿH‹0è4íþÿH‹D$X‰0H‰‡0I…H‰‡@I‡€H‰¯8H‰‡HI†€H‰‡P‹D$P‰‡ë$H‹L$XèßìþÿI‹Íè×ìþÿI‹ÏèÏìþÿI‹ÎèÇìþÿ‹ÞI‹Ìè½ìþÿ‹ÃëTH‹0H…ÀtðÿHó5¾H‰™0H‰@Hi:H‰™8H‰HHÔ;‰±H‰P3ÀH‹Œ$ˆH3ÌèeäþÿLœ$I‹[8I‹k@I‹sHI‹ãA_A^A]A\_ÃHƒì(è“WÿÿH‹ˆÀH;
¢t‹€È…OžuèlUÿÿH‹È‹HƒÄ(ÃÌÌH…ÉuéºÿÿÿH‹‹€ÃHƒì(èCWÿÿH‹ˆÀH;
=¢t‹€È…ÿuèUÿÿH‹È‹AHƒÄ(ÃÌHƒì(èWÿÿH‹ˆÀH;
¢t‹€È…ÇuèäTÿÿH‹È‹AHƒÄ(ÃÌHƒì(èÓVÿÿH‹ˆÀH;
Í¡t‹€È…uè¬TÿÿH‹ÈHAHƒÄ(˅ÒtÿÈ€9t	HÿÁ…ÀuòÿÈ+ÐBÿÃ@UATAUAVAWHƒìPHl$@H‰]@H‰uHH‰}PH‹ú‘H3ÅH‰E‹]`3ÿM‹ñE‹ø‰U…Û~*D‹ÓI‹ÁAÿÊ@88tHÿÀE…ÒuðAƒÊÿ‹ÃA+ÂÿÈ;ÃX|‹ØD‹ex‹÷E…äuH‹D‹`÷€D‹ËM‹ÆÒA‹Ì‰|$(ƒâH‰|$ ÿÂÿ0±Lcè…Àu3ÀéöI¸ðÿÿÿÿÿÿ…À~^3ÒHBàI÷õHƒørOKL-Hùw*HAH;ÁwI‹ÀHƒàðèböþÿH+àH|$@H…ÿt¬ÇÌÌëè¨êþÿH‹øH…Àt
ÇÝÝHƒÇH…ÿtˆD‹ËM‹ÆºA‹ÌD‰l$(H‰|$ ÿ“°…À„LD‹u!t$(H!t$ A‹ÎE‹ÍL‹ÇA‹×ÿįHcð…À„"A¸E…øt7‹Mp…É„;ñH‹Eh‰L$(E‹ÍL‹ÇA‹×A‹ÎH‰D$ ÿ|¯éà…À~g3ÒHBàH÷öHƒørXHL6I;Èw5HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèfõþÿH+àH\$@H…Û„–ÇÌÌëè¨éþÿH‹ØH…ÀtÇÝÝHƒÃë3ÛH…ÛtnE‹ÍL‹ÇA‹×A‹Î‰t$(H‰\$ ÿê®3É…Àt<‹Ep3ÒH‰L$8D‹ÎL‹ÃH‰L$0…Àu‰L$(H‰L$ ë
‰D$(H‹EhH‰D$ A‹Ìÿ°‹ðHKð9ÝÝuèèþÿHOð9ÝÝuè~èþÿ‹ÆH‹MH3Íè€àþÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃÌÌH‰\$H‰t$WHƒìp‹òH‹ÑHL$PI‹ÙA‹øèXäþÿ‹„$¸D‹œ$ÀHL$PD‰\$@‰D$8‹„$°‰D$0H‹„$¨L‹ËH‰D$(‹„$ D‹Ç‹Ö‰D$ èÃüÿÿ€|$htH‹L$`ƒ¡ÈýL\$pI‹[I‹sI‹ã_ÃÌÌ@UATAUAVAWHƒì@Hl$0H‰]@H‰uHH‰}PH‹–ŽH3ÅH‰E‹uh3ÿE‹éM‹ðD‹ú…öuH‹‹p÷]p‹Î‰|$(ÒH‰|$ ƒâÿÂÿ®Lcà…Àu3ÀéÊ~gH¸ðÿÿÿÿÿÿL;àwXKL$Hùw1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèCóþÿH+àH\$0H…Ût±ÇÌÌëè‰çþÿH‹ØH…ÀtÇÝÝHƒÃëH‹ßH…ÛtˆM‹Ä3ÒH‹ËMÀè]ØþÿE‹ÍM‹Æº‹ÎD‰d$(H‰\$ ÿ`­…ÀtL‹M`D‹ÀH‹ÓA‹Ïÿ™¬‹øHKð9ÝÝuè†æþÿ‹ÇH‹MH3ÍèˆÞþÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@A‹ÙI‹øè`âþÿD‹œ$¨‹„$˜HL$@D‰\$0‰D$(H‹„$D‹ËL‹Ç‹ÖH‰D$ èEþÿÿ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌH‰\$H‰t$H‰|$UATAUH‹ìHƒì@·rBD·bDH‹ùH…ÉuƒÈÿé"HƒeøHAA¹1EiÐH‰UðHMðD‹ÆA‹ÕH‰D$ èMàÿÿHOEM1H‰L$ HMðD‹ÆA‹Õ‹Øè/àÿÿHOEM2H‰L$ HMðD‹ÆA‹ÕØèàÿÿEM3HMðØHG D‹ÆA‹ÕH‰D$ èóßÿÿEM4HMðØHG(D‹ÆA‹ÕH‰D$ èÕßÿÿEM5HMðØHG0D‹ÆA‹ÕH‰D$ è·ßÿÿEM6HMðD‹ÆA‹ÕH‰|$ ØèßÿÿEM)ØHG@HMðD‹ÆA‹ÕH‰D$ èßÿÿEM*HMðØHGHD‹ÆA‹ÕH‰D$ èaßÿÿEM+HMðØHGPD‹ÆA‹ÕH‰D$ èCßÿÿØHGXEM,HMðD‹ÆA‹ÕH‰D$ è%ßÿÿEM-ØHG`HMðD‹ÆA‹ÕH‰D$ èßÿÿEM.HMðØHGhD‹ÆA‹ÕH‰D$ èéÞÿÿEM/HMðØHG8D‹ÆA‹ÕH‰D$ èËÞÿÿEMCHMðØHGpD‹ÆA‹ÕH‰D$ è­ÞÿÿEMDHMðØHGxD‹ÆA‹ÕH‰D$ èÞÿÿEMEHMðØH‡€D‹ÆA‹ÕH‰D$ ènÞÿÿEMFHMðØH‡ˆD‹ÆA‹ÕH‰D$ èMÞÿÿEMGHMðØH‡D‹ÆA‹ÕH‰D$ è,ÞÿÿEMHHMðØH‡˜D‹ÆA‹ÕH‰D$ èÞÿÿØH‡ EMIHMðD‹ÆA‹ÕH‰D$ èêÝÿÿEMJHMðØH‡¨D‹ÆA‹ÕH‰D$ èÉÝÿÿEMKHMðØH‡°D‹ÆA‹ÕH‰D$ è¨ÝÿÿEMLHMðØH‡¸D‹ÆA‹ÕH‰D$ è‡ÝÿÿEMMHMðØH‡ÀD‹ÆA‹ÕH‰D$ èfÝÿÿEMNHMðØH‡ÈD‹ÆA‹ÕH‰D$ èEÝÿÿEM7HMðØH‡ÐD‹ÆA‹ÕH‰D$ è$ÝÿÿEM8HMðØH‡ØD‹ÆA‹ÕH‰D$ èÝÿÿEM9HMðØH‡àD‹ÆA‹ÕH‰D$ èâÜÿÿEM:HMðØH‡èD‹ÆA‹ÕH‰D$ èÁÜÿÿØH‡ðEM;HMðD‹ÆA‹ÕH‰D$ è ÜÿÿEMHMðØH‡D‹ÆA‹ÕH‰D$ è=ÜÿÿEM?HMðØH‡D‹ÆA‹ÕH‰D$ èÜÿÿEM@HMðØH‡D‹ÆA‹ÕH‰D$ èûÛÿÿEMAHMðØH‡ D‹ÆA‹ÕH‰D$ èÚÛÿÿEMBHMðØH‡(D‹ÆA‹ÕH‰D$ è¹ÛÿÿEM'HMðØH‡0D‹ÆA‹ÕH‰D$ è˜ÛÿÿEM(HMðØH‡8D‹ÆA‹ÕH‰D$ èwÛÿÿØH‡@H‰D$ EMHMðE‹ÄA‹ÕèVÛÿÿEMHMðØH‡HE‹ÄA‹ÕH‰D$ è5ÛÿÿHMðA¹ØH‡PE‹ÄA‹ÕH‰D$ èÛÿÿHMðA¹	ØH‡\E‹Ä3ÒH‰D$ èðÚÿÿEM0HMðEiÑØH‡pD‹ÆA‹ÕD‰§XH‰D$ èÄÚÿÿEM0ØH‡xHMðD‹ÆA‹ÕH‰D$ è£ÚÿÿEM1HMðØH‡€D‹ÆA‹ÕH‰D$ è‚ÚÿÿEM2HMðØH‡ˆD‹ÆA‹ÕH‰D$ èaÚÿÿEM3HMðØH‡D‹ÆA‹ÕH‰D$ è@ÚÿÿEM4HMðØH‡˜D‹ÆA‹ÕH‰D$ èÚÿÿØH‡hEM5HMðD‹ÆA‹ÕH‰D$ èþÙÿÿEM(HMðØH‡¨D‹ÆA‹ÕH‰D$ èÝÙÿÿEM)HMðØH‡°D‹ÆA‹ÕH‰D$ è¼ÙÿÿEM*HMðØH‡¸D‹ÆA‹ÕH‰D$ è›ÙÿÿEM+HMðØH‡ÀD‹ÆA‹ÕH‰D$ èzÙÿÿEM,HMðØH‡ÈD‹ÆA‹ÕH‰D$ èYÙÿÿEM-HMðØH‡ÐD‹ÆA‹ÕH‰D$ è8ÙÿÿEM.HMðØH‡ D‹ÆA‹ÕH‰D$ èÙÿÿEMBHMðØH‡ØD‹ÆA‹ÕH‰D$ èöØÿÿEMCHMðØH‡àD‹ÆA‹ÕH‰D$ èÕØÿÿØH‡èH‰D$ EMDHMðD‹ÆA‹Õè´ØÿÿEMEHMðØH‡ðD‹ÆA‹ÕH‰D$ è“ØÿÿEMFHMðØH‡øD‹ÆA‹ÕH‰D$ èrØÿÿEMGHMðØH‡D‹ÆA‹ÕH‰D$ èQØÿÿEMHHMðØH‡D‹ÆA‹ÕH‰D$ è0ØÿÿEMIHMðØH‡D‹ÆA‹ÕH‰D$ èØÿÿEMJHMðØH‡D‹ÆA‹ÕH‰D$ èî×ÿÿEMKHMðØH‡ D‹ÆA‹ÕH‰D$ èÍ×ÿÿEMLHMðØH‡(D‹ÆA‹ÕH‰D$ è¬×ÿÿEMMHMðØH‡0D‹ÆA‹ÕH‰D$ è‹×ÿÿEM6ØH‡8H‰D$ HMðD‹ÆA‹Õèj×ÿÿEM7HMðØH‡@D‹ÆA‹ÕH‰D$ èI×ÿÿEM8HMðØH‡HD‹ÆA‹ÕH‰D$ è(×ÿÿEM9HMðØH‡PD‹ÆA‹ÕH‰D$ è×ÿÿEM:HMðØH‡XD‹ÆA‹ÕH‰D$ èæÖÿÿEM;HMðØH‡`D‹ÆA‹ÕH‰D$ èÅÖÿÿEMHMðØH‡xD‹ÆA‹ÕH‰D$ èbÖÿÿEM?HMðØH‡€D‹ÆA‹ÕH‰D$ èAÖÿÿEM@D‹ÆØH‡ˆH‰D$ HMðA‹Õè ÖÿÿEMAHMðØH‡D‹ÆA‹ÕH‰D$ èÿÕÿÿEM&HMðØH‡˜D‹ÆA‹ÕH‰D$ èÞÕÿÿEM'HMðØH‡ D‹ÆA‹ÕH‰D$ è½ÕÿÿEMHMðØH‡¨E‹ÄA‹ÕH‰D$ èœÕÿÿEMHMðØH‡°E‹ÄA‹ÕH‰D$ è{ÕÿÿHMðA¹ØH‡¸E‹ÄA‹ÕH‰D$ èXÕÿÿÃH‹\$`H‹t$hH‹|$pHƒÄ@A]A\]ÃÌH…É„äSHƒì H‹ÙH‹IèRÚþÿH‹KèIÚþÿH‹Kè@ÚþÿH‹K è7ÚþÿH‹K(è.ÚþÿH‹K0è%ÚþÿH‹èÚþÿH‹K@èÚþÿH‹KHèÚþÿH‹KPèÚþÿH‹KXèùÙþÿH‹K`èðÙþÿH‹KhèçÙþÿH‹K8èÞÙþÿH‹KpèÕÙþÿH‹KxèÌÙþÿH‹‹€èÀÙþÿH‹‹ˆè´ÙþÿH‹‹è¨ÙþÿH‹‹˜èœÙþÿH‹‹ èÙþÿH‹‹¨è„ÙþÿH‹‹°èxÙþÿH‹‹¸èlÙþÿH‹‹Àè`ÙþÿH‹‹ÈèTÙþÿH‹‹ÐèHÙþÿH‹‹Øè<ÙþÿH‹‹àè0ÙþÿH‹‹èè$ÙþÿH‹‹ðèÙþÿH‹‹øèÙþÿH‹‹èÙþÿH‹‹èôØþÿH‹‹èèØþÿH‹‹èÜØþÿH‹‹ èÐØþÿH‹‹(èÄØþÿH‹‹0è¸ØþÿH‹‹8è¬ØþÿH‹‹@è ØþÿH‹‹Hè”ØþÿH‹‹PèˆØþÿH‹‹pè|ØþÿH‹‹xèpØþÿH‹‹€èdØþÿH‹‹ˆèXØþÿH‹‹èLØþÿH‹‹˜è@ØþÿH‹‹hè4ØþÿH‹‹¨è(ØþÿH‹‹°èØþÿH‹‹¸èØþÿH‹‹ÀèØþÿH‹‹Èèø×þÿH‹‹Ðèì×þÿH‹‹ èà×þÿH‹‹ØèÔ×þÿH‹‹àèÈ×þÿH‹‹èè¼×þÿH‹‹ðè°×þÿH‹‹øè¤×þÿH‹‹è˜×þÿH‹‹èŒ×þÿH‹‹è€×þÿH‹‹èt×þÿH‹‹ èh×þÿH‹‹(è\×þÿH‹‹0èP×þÿH‹‹8èD×þÿH‹‹@è8×þÿH‹‹Hè,×þÿH‹‹Pè ×þÿH‹‹Xè×þÿH‹‹`è×þÿH‹‹hèüÖþÿH‹‹pèðÖþÿH‹‹xèäÖþÿH‹‹€èØÖþÿH‹‹ˆèÌÖþÿH‹‹èÀÖþÿH‹‹˜è´ÖþÿH‹‹ è¨ÖþÿH‹‹¨èœÖþÿH‹‹°èÖþÿH‹‹¸è„ÖþÿHƒÄ [ÃÌÌH‰\$H‰l$WHƒì ƒy H‹ùH-¯ˆtKºÀ¹èÆdÿÿH‹ØH…Àu¸ëLH‹×H‹ÈèXðÿÿ…ÀtH‹Ëè¼ûÿÿH‹Ëè ÖþÿëØǃ`ëH‹ÝH‹‡XH;Åtðÿˆ`H‰ŸX3ÀH‹\$0H‹l$8HƒÄ _ÃÌÌÌE3ÉH‹ÑD8	tŠ<0|<9,0ˆHÿÂD8
uêóÃ<;uòL‹ÂAŠ@AˆIÿÀ„ÀuòëâÌÌH…ÉtfSHƒì H‹ÙH‹	H;
­tè†ÕþÿH‹KH;
£tètÕþÿH‹KH;
™tèbÕþÿH‹KXH;
ÏtèPÕþÿH‹K`H;
Åtè>ÕþÿHƒÄ [ÃH‹ÄH‰XH‰hH‰pWATAUAVAWHƒì@3ÛH‹ñH‰HÈH‰XÐ9Yu9YuD‹ëD‹óH-鶿˜A¼‹×A‹ÌèVcÿÿH‹èH…ÀuA‹ÄéàH‹–(H‹ÈL‹ÇèLÇþÿ¿‹Ïè¨bÿÿL‹ðH…Àu
H‹Íè Ôþÿëȉ9^„H‹ÏèƒbÿÿL‹èH…À„·‰·~>HL$0A¹A‹ÔD‹ÇH‰l$ è.ÏÿÿHMH‰L$ HL$0A¹D‹ÇA‹Ô‹Øè
ÏÿÿL}HL$0A¹D‹ÇA‹ÔØL‰|$ èìÎÿÿA¹ØHEXHL$0AQôD‹ÇH‰D$ èÊÎÿÿA¹ØHE`HL$0AQóD‹ÇH‰D$ è¨ÎÿÿÃtH‹Íè(þÿÿAƒÌÿH‹ÍèÀÓþÿI‹ÎéÿÿÿI‹3ÛëŠ<0|<9
,0ˆIÔ8uëëQ<;uóL‹ÂAŠ@AˆIÿÀ„ÀuòëãH‹œL‹ëH‰EH‹–H‰EH‹“H‰EH‹ÐH‰EXH‹ÍH‰E`E‰&M…ítE‰eH‹†H…ÀtðÿH‹ŽH…Étðÿ	uH‹ŽèÓþÿH‹Ž(èÓþÿL‰®L‰¶H‰®(3ÀL\$@I‹[0I‹k8I‹s@I‹ãA_A^A]A\_ÃE3ÉH‹ÑD8	tŠ<0|<9,0ˆHÿÂD8
uêóÃ<;uòL‹ÂAŠ@AˆIÿÀ„ÀuòëâÌÌH…É„SHƒì H‹ÙH‹IH;
°ŒtèqÒþÿH‹K H;
¦Œtè_ÒþÿH‹K(H;
œŒtèMÒþÿH‹K0H;
’Œtè;ÒþÿH‹K8H;
ˆŒtè)ÒþÿH‹K@H;
~ŒtèÒþÿH‹KHH;
tŒtèÒþÿH‹KhH;
‚ŒtèóÑþÿH‹KpH;
xŒtèáÑþÿH‹KxH;
nŒtèÏÑþÿH‹‹€H;
aŒtèºÑþÿH‹‹ˆH;
TŒtè¥ÑþÿH‹‹H;
GŒtèÑþÿHƒÄ [ÃÌÌH‰\$H‰t$H‰|$UATAUAVAWH‹ìHƒì@3ÛH‹ñH‰MðD‹ëH‰]ø9Yu9YuD‹óL%e‹éÿA¿˜¹A‹×è¥_ÿÿL‹àH…Àu
¸é)¿‹Ïè_ÿÿL‹ðH…Àu
I‹ÌèÿÐþÿë؉9^„=H‹Ïèâ^ÿÿL‹èH…Àu
I‹ÌèÚÐþÿI‹Îëщ·~8A¹ID$HMðAQìD‹ÇH‰D$ èËÿÿIL$ A¹H‰L$ AQíHMðD‹Ç‹Øè]ËÿÿIL$(A¹H‰L$ AQëHMðD‹ÇØè;ËÿÿA¹HMðØID$0AQêD‹ÇH‰D$ èËÿÿA¹M|$8HMðAQéD‹ÇØL‰|$ è÷ÊÿÿA¹PØID$@HMðAQ±D‹ÇH‰D$ èÕÊÿÿA¹QØID$HHMðAQ°D‹ÇH‰D$ è³ÊÿÿHMðA¹ØID$PD‹Ç3ÒH‰D$ è“ÊÿÿHMðA¹ØID$QD‹Ç3ÒH‰D$ èsÊÿÿHMðA¹TØID$RD‹Ç3ÒH‰D$ èSÊÿÿØID$SHMðA¹UD‹Ç3ÒH‰D$ è3ÊÿÿHMðØID$TA¹VD‹Ç3ÒH‰D$ èÊÿÿHMðA¹WØID$UD‹Ç3ÒH‰D$ èóÉÿÿHMðA¹RØID$VD‹Ç3ÒH‰D$ èÓÉÿÿHMðA¹SØID$WD‹Ç3ÒH‰D$ è³ÉÿÿA¹HMðØID$hAQíD‹ÇH‰D$ è‘ÉÿÿA¹HMðØID$pAQîD‹ÇH‰D$ èoÉÿÿA¹HMðØID$xAQìD‹ÇH‰D$ èMÉÿÿA¹HMðØI„$€AQëD‹ÇH‰D$ è(ÉÿÿA¹PHMðØI„$ˆAQ²D‹ÇH‰D$ èÉÿÿØA¹QI„$HMðAQ±D‹ÇH‰D$ èÞÈÿÿÃt I‹ÌènûÿÿI‹ÌèúÍþÿI‹ÎèòÍþÿI‹ÍéæüÿÿI‹3ÛëŠ<0|<9
,0ˆHÿÂ8uëë)<;uóL‹ÂAŠ@AˆIÿÀ„ÀuòëãH·I‹ÌM‹Çè3ÀþÿH‹†(H‹I‰$H‹†(H‹HI‰L$H‹†(H‹HI‰L$H‹†(H‹HXI‰L$XH‹†(H‹H`I‰L$`AÇM…ítAÇEH‹† H…ÀtðÿH‹ŽH…Étðÿ	uH‹Ž(èÍþÿH‹Žè	ÍþÿL‰® L‰¶L‰¦(3ÀL\$@I‹[0I‹s8I‹{@I‹ãA_A^A]A\]ÃHƒì(è38ÿÿH‹
4ƒH9ˆÀt‹€È…ï~uè6ÿÿH‹¹†HƒÄ(ÃH‹U‡ÃHƒì(èó7ÿÿH‹ˆÀH;
í‚t‹€È…¯~uèÌ5ÿÿH‹ÈH‹@HƒÄ(ÃÌ3ÀÃÌ@SHƒì E3ÒL‹ÉH…Ét
H…ÒtM…ÀuDˆè&ÿÿ»‰è	ÿÿ‹ÃHƒÄ [ÃD8tHÿÁHÿÊuóH…ÒuEˆëÐI+ÈAŠBˆIÿÀ„ÀtHÿÊuíH…ÒuEˆèÏ%ÿÿ»"ë°3ÀëµHƒì8H‹ÍrH3ÄH‰D$ ŠE3ÉL‹ÚL‰$L‰L$L‰L$L‰L$L‹ÑëD¶À¶ÀƒàIÁèŠÈÒâBIÿÃAŠº„ÀuÛ$ëAÿÁºIÿÂE¶A‹ÈIÁèƒáÓâB„tßIcÁH‹L$ H3ÌèZÃþÿHƒÄ8ÃÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì 3ÛM‹è‹úL‹ñ¸‹ó…Òx?…Àt=I‹M>™+ÂÑøHcèL‹åMäK‹æ舲ÿÿ…ÀuKLæI‰Më
y}ÿëu;÷~Á…ÀH‹l$HH‹t$PH‹|$X”ËÃH‹\$@HƒÄ A^A]A\ÃÌ@SHƒì IH‹ÙÿŽ‰C$‰C HƒÄ [ÃÌÌH‰\$WHƒì H‹úH‹ÙH…ÉtS€9tNH&è²Ôÿÿ…Àt>H&H‹ËèŸÔÿÿ…Àu!‹O$DHLD$0º ÿl…Àt-‹D$0ë9H‹ËèBÓÿÿë/‹O$LD$0A¹º ÿ?…Àu3Àë‹D$0…Àuÿ)’H‹\$8HƒÄ _ÃÌÌE3ÀHz%A@f;
tDÀHƒÂAƒø
rîóÃ3ÀÃÌÌÌŠL‹ÁE3Éë'BŸIÿÀ<w€ÂÙë
B¿<w€Âù¾ÊAŠEÉFLÉЄÒuÕA‹ÁÃÌÌÌ3ÒŠHÿÁ‰÷Ct÷CtöCuƒcHƒÄ [ÃH‹3ÒŠHÿÀ€ùA|€ùZ~€éa€ùw­ÿÂëå@SHƒì H‹ÙH‹	è#Sÿÿ3ÒHƒø”‰S…Òt*º‰SH
ÈýÿÿºÿÁˆöCuƒcHƒÄ [ÃH‹3ÒŠHÿÀ€ùA|€ùZ~€éa€ùw¿ÿÂëåÌH‰\$H‰l$VWATHƒì0M‹àH‹êH‹ñèð-ÿÿH˜@H…öuKéãHF@H‰3H‰CH…Àt€8tLCH
€ºè÷ÿÿH‹ƒcH…Àti€8tdH‹CH…Àt€8t
H‹ËèsþÿÿëH‹Ëèÿÿÿƒ{…”H
$L‹Ãº@è³öÿÿ…ÀtrH‹CH…Àt€8t
H‹Ëè1þÿÿëZH‹Ëè¿þÿÿëPH‹KH…Ét4€9t/èÞQÿÿ3ɺHƒø”Á‰KH
Bøÿÿÿˆ‡öCuƒcëÇCÿ‡‰C ‰C$ƒ{„—H†€H÷ÞHÿH#øtZ€?tUHH‹Ïè¡Ëÿÿ…ÀtBHúH‹ÏèŽËÿÿ…Àu%‹K$DHLD$Pº ÿ[‡…À„;‹|$Pë;H‹Ïè-Êÿÿë/‹K$LD$PA¹º ÿ*‡…À„
‹|$P…ÿuÿ‰‹ø…ÿ„òÿèý„æÿéý„Ú·Ïÿùˆ…À„É‹K ºÿ{†…À„³H…ít·C f‰E·C$f‰}f‰EM…ä„Š¸f9Eu.Lº@I‹Ìè®Mÿÿ…Àt1Hƒd$ E3ÉE3À3Ò3Éèe	ÿÿÌ‹K A¹@M‹Äºÿ†…Àt=‹K$MD$@ºA¹@ÿô……Àt A¹
I”$€‹ÏEAèËZ¸ë3ÀH‹\$XH‹l$`HƒÄ0A\_^ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„H+ÑIƒør"öÁtfŠ:
u,HÿÁIÿÈöÁuîM‹ÈIÁéuM…ÀtŠ:
uHÿÁIÿÈuñH3ÀÃÀƒØÿÃIÁét7H‹H;
u[H‹AH;D
uLH‹AH;D
u=H‹AH;D
u.HƒÁ IÿÉuÍIƒàM‹ÈIÁét›H‹H;
uHƒÁIÿÉuîIƒàëƒHƒÁHƒÁHƒÁH‹HÈHÉH;ÁÀƒØÿÃÌHƒì8H‹ÝeH3ÄH‰D$ ŠE3ÛL‹ÒL‰$L‰\$L‰\$L‰\$L‹Éë!D¶À¶ÀºƒàIÁèŠÈÒâBIÿÂAŠ„ÀuÛëA¶ÈA¶ÀºƒáHÁèÓâ„uIÿÁEŠE„ÀuÚ3ÀH‹L$ H3Ìèi¶þÿHƒÄ8ÃI‹ÁëéÌÌÌ@SUVWATAUAVHƒìPH‹6eH3ÄH‰D$HA‹èL‹òL‹éèü'ÿÿ3ÛH9÷“H‹ø…ÕH
OÿA„H‹ðH…À„“H&H‹Èÿ„H…À„zH‹Èÿë…HôH‹ÎH‰¢“ÿd„H‹ÈÿË…H¼H‹ÎH‰Š“ÿD„H‹Èÿ«…H|H‹ÎH‰r“ÿ$„H‹Èÿ‹…L‹ØH‰i“H…Àt"H5H‹ÎÿüƒH‹Èÿc…H‰<“ëH‹3“ëH‹*“L‹+“H;ÇtbL;ßt]H‹Èÿà„H‹
“H‹ðÿЄL‹àH…ötëþÿ@8u˜é–öÿÿÌH‰\$H‰|$DŠYA‹Ù‹úL‹ÉA€ûp„"A€øp„E3ÒºA€ûst	A‹ÊA€ûSu‹ÊA€øst	A‹ÂA€øSu‹Â…É…À…À…×±iA€ûdtfD:Ùt;A€ûot5A€ûut/A€ûxt)A€ûXt#A€ødtD:ÁtA€øotA€øutA€øxtA€øXukA€ûdt D:ÙtA€ûotA€ûutA€ûxt	A‹ÂA€ûXu‹ÂA€ødt D:ÁtA€øotA€øutA€øxt	A€øXtA‹Ò;Ât3ÀëMA‹I‹Á3úàrî3ËöÁ uçA99ë,;Èu¸A‹ÊA…A•Á…ØA‹Â•À;ÈtA‹Ò‹Âë
E3ÒE:ØA”ÂA‹ÂH‹\$H‹|$ÃÌÌ@SHƒì öB@I‹ØtHƒzuAÿë%ÿJx
H‹ˆHÿ¶Áë¾Éè÷Sÿÿƒøÿu	ëÿHƒÄ [ÃÌÌ…Ò~LH‰\$H‰l$H‰t$WHƒì I‹ùI‹ð‹Ú@ŠéL‹ÇH‹Ö@ŠÍÿËè…ÿÿÿƒ?ÿt…ÛçH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì Aö@@I‹ùI‹ð‹ÚH‹étIƒxuAë7…Ò~3ŠML‹ÇH‹ÖÿËèÿÿÿHÿŃ?ÿuèñøþÿƒ8*uL‹ÇH‹Ö±?èÿþÿÿ…ÛÍH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌHƒH‹H‹@øÃH‰\$UVWATAUAVAWH¬$ ôÿÿHì`H‹¦EH3ÄH‰…X3ÿH‹ÙH‰MÀL‹âH‰UèHL$`I‹ÐM‹ñ‰}°D‹ï‰|$P‰|$D‰}è“šþÿAƒÏÿA‹÷H‰}¨H…Ûu+èBøþÿÇè/èþÿ@8|$xtH‹L$pƒ¡ÈýA‹ÇéOöC@…¢H‹ËèbMÿÿH÷VA;Çt(ƒøþt#LcÀL
cþÿI‹ÈAƒàHÁùMkÀXM„É Šë
L‹ÂL
@þÿAö@8u)A;ÇtƒøþtHcÐH‹ÂƒâHÁøHkÒXI”Á ŠöB8€t,è—÷þÿÇè„çþÿ@8|$x„]ÿÿÿH‹D$pƒ ÈýéLÿÿÿM…ätÏH‹]è‹ÇD‹ß‰D$L‰}¸Aƒûu…ö„mƒÎÿ‰|$TM‹ÌEŠ$$McË×H‰}ØE‹×D‰|$@‰}€‰|$HD‰}ȉu L‰E˜E„ä„ÔA»MËL‰Mˆ…Àˆ[AD$à…öu
A·IƒÆë%Aƒÿc‡"IcÇH@M…À„	H‹„Íø·ˆEðD‰\$TE3äH]ðéíýÿÿD‰é‰þÿÿD‰]ÌA€Ä AƒÍ@A;ó…M…À…vAƒÿc‡Ã
IcÇH@H„ÍðD9…-ÇDˆ¤ÍD‰¬Íéë	ƒøeŒ~ýÿÿƒøg~Ÿƒøi„‰ƒøn„ƒøo„ƒøp„»ƒøs„lþÿÿƒøu„`ƒøx…:ýÿÿ¸'é©Aƒÿc‡/
IcÇH@M…ÀuH„ÍðD9„ªýÿÿéÀýÿÿH‹œÍøH‹A÷Åt0H…ÛD‰]HD]QH‹Ãë
A+ÓfD9tHƒÀ…ÒuïH+ÃHÑøé¸ýÿÿH…ÛHD)QH‹ÃëA+ÓD8tIÃ…Òuñ+Ãé’ýÿÿ¿Aºí‰|$H¸‰E°A¹E„퉘AQòQÆD$X0‰T$PˆD$Yé„A¹E„íyu¸Dèëk…öu	I‹>IƒÆë%Aƒÿc‡:	IcÇH@M…À„ÿÿÿH‹„ÍøH‹8èuçÿÿE3ä…À„àüÿÿ‹D$LAöÅ tf‰ë‰¸‰D$DéîûÿÿAƒÍ@A¹
‹T$PAºåsH…öuM‹IƒÆéAƒÿc‡ÁIcÇH@M…ÀueH„ÍðD9uÇé;üÿÿºéKüÿÿAºåsL…öt±Aƒÿc‡~IcÇH@M…Àu"H„ÍðD9uÇéøûÿÿºéüÿÿH‹„ÍøL‹éAöÅ „ŒAöÅ@tQ…öu
M¿IƒÆéáAƒÿc‡IcÇH@M…ÀuH„ÍðD9„ýÿÿA‹Óé¨ûÿÿH‹„ÍøL¿é¡…öu
E·IƒÆéAƒÿc‡ÄIcÇH@M…Àt¯H‹„ÍøD·ëlAöÅ@t4…öu	McIƒÆëYAƒÿc‡IcÇH@M…À„tÿÿÿH‹„ÍøLcë2…öu	E‹IƒÆë%Aƒÿc‡YIcÇH@M…À„@ÿÿÿH‹„ÍøD‹AöÅ@t
M…ÀyI÷ØAºíAºår
AºårE‹À¾…ÿyA‹ûë	Aƒå÷;þOþD‹}°I‹ÀHïH÷ØÉ#ʉL$P‹ÏA+û…ÉM…Àt 3ÒI‹ÀIcÉH÷ñL‹ÀB0ƒø9~ALjI+ÛëÒD‹}ÈH…ï‰|$H+ÃIÛ‰D$TD…î„’ùÿÿ…Àt	€;0„…ùÿÿI+ÛD\$TÆ0éuùÿÿE‹ÍEŠÄºH‹ÈèNóÿÿE3ä…À„1úÿÿL‹E˜é®¸H]ð‹ð…ÿy
ÇD$HëIu
A€üguAD‰\$Hë:;øOø‰|$Hÿ£~)Ç]HcÏè;"ÿÿE3ÒH‰EØH…ÀtH‹Ø‹÷ëÇD$H£D9U u
I‹IƒÆH‰Eàë Aƒÿc‡ØIcÇH@H‹„ÍøH‹H‰MàH‹
nMA¾üHcöÿ©[HL$`D‹ÏH‰L$0‹MÌL‹Æ‰L$(‹L$HH‹Ó‰L$ HMàÿÐA‹ýç€tƒ|$HuH‹
8Mÿb[HT$`H‹ËÿÐA€ügu E3ä…ÿuH‹
Mÿ>[HT$`H‹ËÿÐëE3ä€;-uAºíHÿÃH‹Ëèr#ÿÿ‰D$TéøÿÿAöÅtÆD$X+¿‰|$PëAöÅtÆD$X ëè‹|$PD‹e€H‹uÀD+d$TD+çAöÅuLL$LL‹ÆA‹Ô± èNóÿÿLL$LHL$XL‹Æ‹×èŽóÿÿAöÅtAöÅuLL$LL‹ÆA‹Ô±0èóÿÿ‹|$T3À9Et^…ÿ~ZH‹óD·H•PHMÐA¸ÿÏHƒÆèšäÿÿ…Àu&‹UÐ…ÒtL‹EÀLL$LHPèóÿÿ…ÿu¼H‹uÀëH‹uÀƒÈÿ‰D$LëLL$LL‹Æ‹×H‹Ëèõòÿÿ‹D$L…ÀxAöÅtLL$LL‹ÆA‹Ô± èòÿÿE3äH‹MØH…Ét	è’þÿL‰eØ‹|$Hé|ýÿÿA€üItJA€üht;A€ültA€üw…AºíéA€9lD‹T$@u
MËAºíéþAƒÍéõAƒÍ éçAŠ¹€Dé<6uA€y4uIƒÁDééÅ<3uA€y2uIƒÁAºõé¬IƒÆëDHU¨A¸
I‹Éè€þÿH‹M¨L‹E˜LIA»A+ÃL‰MˆM…À„°H˜H@H‹„Íø‹8D‹T$@‰|$H…ÿ‰ƒÏÿ‰|$HéD‰Æ„Í*D‰¬Íéö¿A¾Ä|HЉ|$HéÝA‹úD‰T$HéÐA€ü*…Ê…öuA‹IƒÆéœHU¨A¸
I‹ÉèÌþÿH‹M¨L‹E˜LIA»A+ÃL‰MˆM…Àu\…Àˆ#€9$…AƒÿdD‹T$@A;ÂDOÐH˜E3äH@D‰T$@H„ÍðD9 „7ÿÿÿE‹ÍA°*A‹ÓH‹Èè·îÿÿégûÿÿH˜H@H‹„Íø‹D‹T$@‰M€…ɉAƒÍ÷Ù‰M€é‹E€€A¾ÄLHЉM€éæA€ü tEA€ü#t5A€ü+t'A€ü-tD‹T$@A€ü0…ÄAƒÍé»AƒÍé­Eëé¥Aºíé›AƒÍé’ƒÏÿD‰UÌD‰T$DD‰U€D‰T$PE‹ê‰|$HD‰UëpM…ÀuA;ótfM;Ãuƒþÿt\HT$`A¶ÌD‰UèNsÿÿ…Àt(H‹UÀLD$LAŠÌèïÿÿH‹EˆDŠ HÿÀH‰EˆE„ä„ÃH‹UÀLD$LAŠÌèñîÿÿéMúÿÿ‹|$HL‹MˆD‹T$@EŠ!‹u ‹D$L‹U´E„ä…–ñÿÿA»3ÿ…Òt	ƒú…A;óD‹]¸uNE…ÛuIL‹ÇMcÊE…Òx>H•ø‹JøÿÉtÿÉtÿÉtÿÉt
ÿÉt	ÿÉtƒùu]L‰2IÿÀIƒÆHƒÂM;Á~Íë3ÿ‹D$LAÿÃD‰]¸Aƒû}LL‹eèAƒÏÿéÄðÿÿèèþÿÇèØþÿ€|$xtH‹D$pƒ ÈýƒÈÿë*èòçþÿÇèß×þÿ@8|$xëÖ@8|$xtH‹L$pƒ¡ÈýH‹XH3Ìèâ…þÿH‹œ$°HÄ`A_A^A]A\_^]ÃÌÌÌH‰\$‰L$VWATHƒì Hcùƒÿþuè‚çþÿÇ	é…Ɉ…;=é{s}H‹ßH‹÷HÁþL%ê{ƒãHkÛXI‹ô¾LƒátW‹Ïèú%ÿÿI‹ôöDt+‹Ïès%ÿÿH‹Èÿ
S…Àu
ÿT‹Øë3Û…Ûtè%çþÿ‰èþæþÿÇ	ƒËÿ‹ÏèV&ÿÿ‹ÃëèåæþÿÇ	èÒÖþÿƒÈÿH‹\$PHƒÄ A\_^ÃÌH‰\$WHƒì HcÙA‹øH‰T$8‹Ëèø$ÿÿHƒøÿuè¡æþÿÇ	HƒÈÿëW‹T$8LD$é¸ýÿÿÇEÌA½‹IcÄE‹ÅHTÌE+Äèœbÿÿƒøÿ„ýÿÿDàE;ìÚëD‹}ÄA¸HcDŠeXH‹ÁƒáA€äHÁøHkÉXI‹Æ€d8€Dd8HcH‹ÂƒâHÁøHkÒXI‹Æ‹Æ€d8ÁèÀàD8@8}Ôu @öÆtHcH‹ÁƒáHÁøHkÉXI‹Æ€L ¹ÀA‹Ç#Á;Á…•A„ð„ŒH‹Màÿ‹E‹EÐD‹EÈH‹MPH‰|$0‰D$(Aº÷LMèÇD$ A‹×ÿ=EHƒøÿu5ÿ9E‹Èè†ØþÿLcI‹ÃAƒãHÁøMkÛXI‹ÆB€dþ‹èÃÿÿésûÿÿHcH‹ÊƒâHÁùHkÒXI‹ÎH‰
‹Çé.ùÿÿE3ÉE3À3Ò3ÉH‰|$ è*ÇþÿÌÌH‹Ä‰PL‰@L‰H SWHƒìHƒHØÿƒ`ÜE3ÀH…ÉA•ÀE…Àuè¸×þÿÇè¥ÇþÿƒÈÿé‹HD$pHƒÀD‹@øD‰D$(ÇD$ @D‹ÊL‹ÁHT$0HL$4èæ÷ÿÿ‹ø‰D$8ƒ|$4t9…Àt(Hc\$0H‹ËH‹ÃHÁøHãkƒáHkÉXH‹€dþë‹\$0‹Ëèšÿÿë‹\$0…ÿtè#×þÿ‰8éoÿÿÿ‹ÃHƒÄH_[ÃÌÌÌH‰\$WHƒì@ƒd$03ÀH‹|$pH…ÿ•À…ÀuèëÖþÿ»‰è×Æþÿ‹Ãéƒÿ3ÀH…É•À…ÀtÙƒ|$xtA÷Áþÿÿ¸”À…Àt¿D‰L$(D‰D$ D‹ÊL‹ÁH‹×HL$0è÷ÿÿ‹Ø‰D$4ƒ|$0t,…Àt!HcH‹ÁHÁøHkƒáHkÉXH‹€dþ‹èÁÿÿ…Û„rÿÿÿƒÿéjÿÿÿH‹\$PHƒÄ@_ÃÌÌL‹ÜE‰CM‰K SHƒì@ƒd$(MKèIC M‰KØD‹ƒËÿ‰\$0èüþÿÿ‹L$0…ÀEË‹ÁHƒÄ@[ÃÌÌÌHƒì8A‹ÁD‹L$`E‹ÐL‹ÚÇD$(H‰L$ D‹ÀA‹ÒI‹Ëè»þÿÿHƒÄ8ÃÌÌH‹ÄH‰XH‰pH‰xL‰` UH‹ìHƒì@H‹ùH‹òHMàI‹ÑI‹ØèÐwþÿE3äH…ÛuD8eøtH‹Eðƒ Èý3Àé|H‹MèD9auL‹ÃH‹ÖH‹ÏèéNH…ÿu+èMÕþÿÇè:ÅþÿD8eøtH‹Eðƒ Èý¸ÿÿÿé/H…ötÐA±¶HÿËHÿÇD„L
tWH…Ûu¶A·ÔD„L…lÿÿÿéÇD8'uA‹ÔëC¶fÁâHÿÇfÐf;Qrf;QwfQë$f;Qrf;QwfQë·ÂöDt¶”D¶HÿÆA‹ÀE„LtPH…ÛuA‹Äë_HÿËD8&uA·ÄëQ¶fAÁàHÿÆfDÀA·ÀfD;Arf;AwfAë+f;Ar%f;AwfAëA·ÀöDt
¶„ëA·Àf;Âuf…Ò„’þÿÿH…Û…öþÿÿé„þÿÿÀƒàÿÈD8eøtH‹Mðƒ¡ÈýH‹\$PH‹t$XH‹|$`L‹d$hHƒÄ@]ÃÌÌE3ÉéþÿÿH‹ÄH‰XH‰pH‰xL‰` UH‹ìHƒì@E3äI‹ØH‹òH‹ùM…Àu3ÀéHMàI‹ÑèÑuþÿL‹]èE9cuL‹ÃH‹ÖH‹ÏèÁ¸þÿéÙH…ÿu+ènÓþÿÇè[ÃþÿD8eøtH‹Eðƒ Èý¸ÿÿÿéºH…ötÐA°¶HÿËHÿÇF„Dt/H…Ûu¶A‹ÌF„Du^·ÐëJD8'uA·Ìë
¶fÁáfÈHÿǶHÿÆF„Dt%H…ÛuA‹ÔëHÿËD8&uA·Ôë
¶fÁâfÐHÿÆf;Ñu$f…ÉtH…Ûu€D8eø„ÿÿÿH‹Eðƒ ÈýéþþÿÿÀƒàÿÈD8eøtH‹Mðƒ¡ÈýH‹\$PH‹t$XH‹|$`L‹d$hHƒÄ@]ÃE3Éé˜þÿÿH‰T$‰L$USVWATAUAVAWH‹ìHƒìXHcÁA‹ØÇEàþÿÿÿ‰]äƒøþuèVÒþÿ3ÿ‰8è-ÒþÿÇ	éÅ3ÿ…Ɉ¤;’fƒ˜H‹ðL‹øL
sÜýÿIÁÿƒæK‹Œù ŠHköXŠD1¨„lûÿÿÿvèóÑþÿ‰8èÌÑþÿÇé_D‹ç…Û„>¨…6H…ÒtÑDŠl18A¸EíAÐýA¾ÍDˆm`ÿÉtÿÉu‹Ã÷Шt¨ƒãþL‹òë`‹Ã÷Шt˜ÑëA;ØABØ‹ËèlÿÿL‹ðH…ÀuèSÑþÿÇèhÑþÿÇéà‹MH3ÒDBègêÿÿL
œÛýÿL‹ØK‹„ù ŠL‰\0@K‹„ù ŠI‹ÖA¸
öD0H„›ŠL0	A:È„Ž…Û„†AˆK‹„ù ŠAƒÊÿAÚIVE`÷DˆD0	E„ítbK‹„ù ŠŠL09A:ÈtQ…ÛtMˆ
K‹„ù ŠAÚHÿÂE`øDˆD09A€ýu.K‹„ù ŠŠL0:A:Èt…Ûtˆ
K‹„ù ŠHÿÂE`ùAÚDˆD0:K‹Œù ŠLMÜD‹ÃH‹1H‰|$ ÿç<…À„ˆHcUÜ…Òˆ|‹ÃH;ЇqL‘ÚýÿDâK‹„ø ŠöD0€„5A€ý„Œ…Òt
A€>
u€L0ë€d0ûIcÄI‹ÞM‹îIÆH‰EèL;ðƒA¼
AŠE<„êA:Ät
ˆHÿÃIÿÅéÌH‹EèHÿÈL;èsIE€8
uIƒÅë~L‹èé£K‹Œø ŠLMÜHUXH‹1A¸IÿÅH‰|$ ÿ<…Àu
ÿA<…Àuf9}ÜtaL¹ÙýÿK‹„ø ŠöD0Ht€}X
tDˆ#K‹Œø ŠŠEXˆD1	ë;I;Þu€}X
uÆ
ë+‹MHA¸HƒÊÿè2èÿÿ€}X
LcÙýÿtëLXÙýÿDˆ#HÿÃL;mè‚ÿÿÿëK‹„ø ŠöD0@u€L0ë	AŠEˆHÿÃD‹ãE+æ€}`…ÑE…ä„ÈHÿËö€uHÿÃ鱺ëƒúI;ÞrHÿËÿ¶B8¼€Vtä¶B¾„€V…ÀuèRÎþÿÇ*ƒËÿéuÿÀ;ÂuHcÂHØë]K‹„ø ŠöD0Ht;HÿÈL0	ƒú|ŠK‹Œø ŠHÿÈD19ƒúuŠK‹Œø ŠHÿÈD1:HcÂH+Øë‹MH÷ÚA¸HcÒèçÿÿ‹EäL‹mPA+ÞÑèD‹ËM‹Æ‰D$(3Ò¹éýL‰l$ ÿu:D‹à…Àuÿ:‹ÈèÝÍþÿƒËÿéÊ;Ë]àHý×ýÿJ‹„ø Š@•ÇEä‰|0H馅Һ
t
fA9u€L0ë€d0ûIcÄI‹ÞM‹îIÆH‰E`L;ðƒeA¼
A·Efƒø„.fA;Ätf‰HƒÃIƒÅéH‹E`HƒÀþL;èsIEf9u	IƒÅé­L‹èéÝK‹Œø ŠLMÜHUØH‹1A¸IƒÅH‰|$ ÿf9…Àuÿ¤9…À…–9}Ü„L×ýÿK‹„ø ŠöD0Ht;º
f9UØt@fD‰#ŠEØK‹Œø ŠˆD1	ŠEÙK‹Œø ŠˆD19K‹„ø ŠˆT0:ëLI;Þuº
f9UØuf‰ë7‹MHHÇÂþÿÿÿDBèfåÿÿº
L–Öýÿf9UØtëº
L‚ÖýÿfD‰#HƒÃL;m`‚Åþÿÿë"K‹„ø ŠöD0@u€L0ëA·Ef‰HƒÃD‹ãE+æ‹]àL‹mPM;õtI‹ÎèÒqþÿƒûþADÜ‹ÃëYÿ™8ƒøuè£ËþÿÇ	è¸ËþÿÇéAýÿÿƒømu‹ß뵋Èè½Ëþÿé,ýÿÿ3ÀëèËþÿ‰8èhËþÿÇ	èU»þÿƒÈÿHƒÄXA_A^A]A\_^[]ÃÌH‰\$H‰t$‰L$WATAUAVAWHƒì A‹ðL‹êHcùƒÿþuè:Ëþÿ3Û‰èËþÿÇ	é¾3ۅɈ;=v_ƒ‘L‹çL‹÷IÁþL=s_AƒäMkäXK‹÷B¾L ƒáti‹ÃAøÿÿÿ–À…ÀuèÓÊþÿ‰è¬ÊþÿÇëW‹Ïè]	ÿÿK‹÷BöD tD‹ÆI‹Õ‹Ïèøÿÿ‹ØëèzÊþÿÇ	èÊþÿ‰ƒËÿ‹ÏèË	ÿÿ‹ÃëèzÊþÿ‰èSÊþÿÇ	è@ºþÿƒÈÿH‹\$XH‹t$`HƒÄ A_A^A]A\_ÃÌHƒì(èÏdÿÿH…Àt
¹è¸gÿÿö,tA¸º@AH蟷þÿ¹èųþÿÌ‹Ú+D‹Â#ÊA÷ÐD#ÀDÁD‰Å+Ã@UATAUAVAWHƒìPHl$@H‰]@H‰uHH‰}PH‹¾H3ÅH‰EH‹E‹èD‹òD‹`M‹ùE3ÀE3ÉA‹ÕA‹Î3ÿÿË5Hcð…Àu3ÀéÓ~g3ÒHBàH÷öHƒørXHL6Hùw1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèz{þÿH+àH\$@H…Ût±ÇÌÌëèÀoþÿH‹ØH…ÀtÇÝÝHƒÃëH‹ßH…ÛtˆD‹ÎL‹ÃA‹ÕA‹Îÿ:5…Àt9‹E`AƒÉÿ3ÒH‰|$8L‹ÃA‹ÌH‰|$0…Àu‰|$(H‰|$ ë	‰D$(L‰|$ ÿç6‹øHKð9ÝÝuè´nþÿ‹ÇH‹MH3Íè¶fþÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃH‰\$H‰t$WHƒìP‹òH‹ÑHL$0I‹ÙA‹øèjþÿD‹œ$€HL$0L‹ËD‹Ç‹ÖD‰\$ èeþÿÿ€|$HtH‹L$@ƒ¡ÈýH‹\$`H‹t$hHƒÄP_ÃÌÌHƒì(H…ÉuèÈþÿÇèï·þÿHƒÈÿHƒÄ(ÃL‹ÁH‹
:3ÒHƒÄ(Hÿ%³3ÌÌ̹éαþÿÌÌH‰\$H‰t$WHƒì@‹ÚH‹ÑHL$ A‹ùA‹ðèàiþÿH‹D$(D¶ÛA„|u…ötH‹D$ H‹ˆ@B·Y#Æë3À…Àt¸€|$8tH‹L$0ƒ¡ÈýH‹\$PH‹t$XHƒÄ@_ÃÌH‹Â‹ÑA¹H‹ÈE3ÀénÿÿÿÌÌ‹ÑA¹E3À3ÉéZÿÿÿÌÌH‹Â‹ÑA¹H‹ÈE3ÀéBÿÿÿÌÌ‹ÑA¹E3À3Éé.ÿÿÿÌÌH‹Â‹ÑA¹H‹ÈE3ÀéÿÿÿÌÌ‹ÑA¹E3À3ÉéÿÿÿÌÌH‹Â‹ÑA¹H‹ÈA¸éçþÿÿÌÌÌ‹ÑA¹A¸3ÉéÏþÿÿÌÌÌH‹Â‹ÑA¹H‹ÈA¸é³þÿÿÌÌÌ‹ÑA¹A¸3Éé›þÿÿÌÌÌH‹Â‹ÑA¹H‹ÈA¸éþÿÿÌÌÌ‹ÑA¹A¸3ÉégþÿÿÌÌÌH‹Â‹ÑA¹H‹ÈA¸WéKþÿÿÌÌÌ‹ÑA¹A¸W3Éé3þÿÿÌÌÌH‹ÂA¹‹ÑEAH‹ÈéþÿÿÌA¹‹Ñ3ÉEAéþÿÿÌH‹Â‹ÑA¹H‹ÈE3ÀéîýÿÿÌÌ‹ÑA¹E3À3ÉéÚýÿÿÌÌH‹Â‹ÑA¹H‹ÈE3ÀéÂýÿÿÌÌ‹ÑA¹E3À3Éé®ýÿÿÌÌH‰\$WHƒì@‹ùHL$ H‹Úè—gþÿL‹\$(M…Ût2A{¤u(A¹E3À‹×H‹Ëèlýÿÿ€|$8t#H‹L$0ƒ¡Èýë€|$8tH‹D$0ƒ Èý3ÀH‹\$PHƒÄ@_ÃÌÌÌ3ÒéÿÿÿÌH‹ÄH‰XH‰hH‰p WATAUAVAWHƒì@L‹êH‹ÑHH¸E‹áM‹ðèÿfþÿM…ötM‰.M…íu*è±ÄþÿÇèž´þÿ€|$8tH‹D$0ƒ Èý3ÀéßE…ätAƒü|ËAƒü$ÅAŠuL‹D$ 3ÿI]Aƒ¸~LD$ @¶Îºè÷×þÿL‹D$ ëI‹€@@¶Î·Hƒà…Àt@Š3HÿÃ뾋¬$@€þ-uƒÍë@€þ+u@Š3HÿÃE…äu&@€þ0tA¼
ë6€;xt
€;XtA¼ë$A¼Aƒüu@€þ0u€;xt€;Xu@ŠsHƒÃM‹¸@McÜ3ÒHƒÈÿI÷óL‹ÒL‹È@¶ÎE·OA‹Èƒát	@¾Öƒê0ëAàt/FŸ@¾Ö<wƒê ƒÂÉA;ÔsƒÍI;ùr%u‹ÂI;ÂvƒÍM…öu HÿË@öÅuM…öIEÝ3ÿëpI‹ËH¯Ï‹úHù@Š3HÿÃë†H¾ÿÿÿÿÿÿÿ@öÅu%@öÅuF‹ÅƒàtH¹€H;ùw	…Àu,H;þv'èöÂþÿÇ"@öÅtHƒÏÿë@ŠÅ$öØHÿH÷ßHþM…ötI‰@öÅtH÷߀|$8tH‹L$0ƒ¡ÈýH‹ÇL\$@I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌHƒì83ÀE‹ÈL‹Â9Ž4‰D$ H‹Ñu	H
öë3ÉèmýÿÿHƒÄ8ÃHƒì8ƒd$ I‹ÁE‹ÈL‹ÂH‹ÑH‹ÈèKýÿÿHƒÄ8ÃÌÌHƒì8ƒ=A4E‹ÈL‹ÂH‹ÑÇD$ u	H
Ÿë3ÉèýÿÿHƒÄ8ÃÌHƒì8I‹ÁE‹ÈL‹ÂH‹ÑH‹ÈÇD$ èðüÿÿHƒÄ8ÃÌÌÌ@SHƒì ƒd$@LD$@èï´ÿÿH‹ØH…Àu9D$@tè´ÁþÿH…ÀtèªÁþÿ‹L$@‰H‹ÃHƒÄ [ÃÌÌÌL‹ÑM…Àt;E¶
IÿÂAA¿ƒøwAƒÁ ¶
HÿÂA¿ƒøwƒÁ IÿÈt
E…ÉtD;ÉtÌD+ÉA‹ÁÃ3ÀÃÌÌH‹ÄH‰XH‰pH‰xL‰` UH‹ìHƒì@M‹àH‹òH‹ùM…À„ºHMàI‹ÑèScþÿH…ÿu+è
ÁþÿÇèú°þÿ€}øtH‹Eðƒ Èý¸ÿÿÿé€H…ötÐIüÿÿÿwÇH‹Eàƒxu!M‹ÄH‹ÖH‹Ïè)ÿÿÿ€}øtTH‹Mðƒ¡ÈýëGH+þ¶7HUàèžßÿÿ¶HUà‹ØèßÿÿHÿÆIÿÌt…Ût;ØtÕ+Ø€}øtH‹Mðƒ¡Èý‹Ãë3ÀH‹\$PH‹t$XH‹|$`L‹d$hHƒÄ@]ÃÌHƒì(ƒ=U2u6H…Éuè5ÀþÿÇè"°þÿ¸ÿÿÿHƒÄ(ÃH…ÒtáIøÿÿÿwØHƒÄ(éqþÿÿE3ÉHƒÄ(é­þÿÿÌH‰\$H‰t$WHƒì A‹ñM‹ØL‹Ò‹ùH…ÒuèØ¿þÿ»‰èįþÿ‹ÃéªM…ÀtãÆ‹T$P‹Â÷ØHÉH÷ÙHÿÁL;Áw袿þÿ»"ëÈAAþ»";Ãw±3ÉM‹Â…Òt
AÆ-MBKß÷ßM‹È3Ò‹Ç÷ö‹øƒú	v€ÂWë€Â0AˆHÿÁIÿÀ…ÀtI;ËrÙI;ËrAÆè@¿þÿéhÿÿÿAÆIÿÈAŠAŠAˆAˆ	IÿÁIÿÈM;Èré3ÀH‹\$0H‹t$8HƒÄ _ÃÌÌÌHƒì8Aƒù
u…Éy
ÇD$ ëƒd$ èêþÿÿHƒÄ8ÃÌHƒì83ÀAƒù
u…ÉyAA÷‰D$ èÇþÿÿHƒÄ8ÃÌÌHƒì8ƒd$ è²þÿÿHƒÄ8ÃÌH‰\$H‰t$WHƒì A‹ñM‹ØL‹ÒH‹ùH…Òu胾þÿ»‰èo®þÿ‹Ãé®M…ÀtãÆ‹T$P‹Â÷ØHÉH÷ÙHÿÁL;ÁwèM¾þÿ»"ëÈFþ»";Ãw²3ÉM‹Â…ÒtAÆ-MBKßH÷ßM‹È3ÒH‹ÇH÷öH‹øƒú	v€ÂWë€Â0AˆHÿÁIÿÀH…ÀtI;ËrÕI;ËrAÆèç½þÿédÿÿÿAÆIÿÈAŠAŠAˆAˆ	IÿÁIÿÈM;Èré3ÀH‹\$0H‹t$8HƒÄ _ÃÌÌHƒì83ÀAƒù
u	H…ÉyAA÷‰D$ èêþÿÿHƒÄ8ÃÌHƒì8ƒd$ èÖþÿÿHƒÄ8ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì0IcÙI‹ð‹êD‹áE…É~H‹ÓI‹Èèh
H‹ØHcD$hH‹|$`…À~H‹ÐH‹ÏèL
…Ût …Àt‰D$(D‹ËL‹Æ‹ÕA‹ÌH‰|$ ÿÚ)ë+ظHþHÁ¹…ÛDÁH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A\ÃÌÌ‹Â…ÒtÿÈ€9t	HÿÁ…ÀuòÿÈ+ÐBÿÃ@USVWATAUAVAWHƒìhHl$0H‹«	H3ÅH‰E(‹½ L‹¥¨3ÛD‰EM‹é‰UL‹ÁL‰eA¿…ÿ~C‹×I‹ÁA+׃Éÿ8t	IÇ…Òuï‹Ñ‹Á+Âø‹µ°…ö~)‹ÆI‹ÔA+Ç8t	I×…Àuò‹Á+ÈñëƒÉÿ;ù}Ô3Àéˆ;ñ|õD‹µ¸E…öuI‹D‹p…ÿt…ö…™;þu
¸éWA;÷~A‹ÇéJA;ÿ~
¸é;HUA‹Îÿÿ)…Àt›…ÿ~)ƒ}rÛ8]HEtÒ8XtÍAŠM:r:Hv¤HƒÀ8ëä…ö~-ƒ}r¡8]HEt˜8Xt“AŠ$:r	:H†sÿÿÿHƒÀ8ëàD‹ÏM‹Åº	A‹Î‰\$(H‰\$ ÿ(Lcø…À„ÿÿÿI¸ðÿÿÿÿÿÿ~f3ÒHBàI÷÷HƒørWKL?Hùw0HAH;ÁwI‹ÀHƒàðè7mþÿH+àLd$0M…ä„ÆþÿÿAÇ$ÌÌëèwaþÿL‹àH…ÀtÇÝÝIƒÄëL‹ãM…ä„—þÿÿD‹ÏM‹ÅºA‹ÎD‰|$(L‰d$ ÿY'…À„ìL‹ED‹Îº	A‹Î‰\$(H‰\$ ÿ3'Lcè…À„Ã~g3ÒHBàI÷õHƒørXKL-Hùw1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèmlþÿH+àH|$0H…ÿt{ÇÌÌëè³`þÿH‹øH…ÀtÇÝÝHƒÇëH‹ûH…ÿtRL‹ED‹ÎºA‹ÎD‰l$(H‰|$ ÿ˜&…Àt‹U‹ME‹ÏM‹ÄD‰l$(H‰|$ ÿˆ&‹ØHOð9ÝÝuèµ_þÿIL$ð9ÝÝuè£_þÿ‹ÃH‹M(H3Íè¥WþÿHe8A_A^A]A\_^[]ÃH‰\$H‰t$WHƒì`‹òH‹ÑHL$@I‹ÙA‹øèˆ[þÿD‹œ$¨‹„$ HL$@D‰\$8‰D$0H‹„$˜H‰D$(‹„$L‹ËD‹Ç‹Ö‰D$ èVüÿÿ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$H‰t$H‰|$UH‹ìHƒì`H‹ñH‹úHMàI‹ÑI‹ØèôZþÿH…Ûu8]øtH‹Eðƒ Èý3Àé¥H…öu(è’¸þÿÇè¨þÿ€}øtH‹Eðƒ Èý¸ÿÿÿëxH…ÿtÓHûÿÿÿwÊH‹Eà‹P…ÒuLMàL‹ÃH‹×H‹Îèôöÿÿë:‹@HMàL‹Î‰D$8‰\$0A¸H‰|$(‰\$ è¬þÿÿ…Àu
è¸þÿÇ넃Àþ€}øtH‹Mðƒ¡ÈýL\$`I‹[I‹sI‹{ I‹ã]Ã̃=í)ué†÷ÿÿE3ÉéæþÿÿÌÌH‰\$H‰t$H‰|$ ATAUAVHƒì M‹áM‹èH‹òL‹ñè²gþÿHx0H‰|$H3ÀH…ö•À…Àuè„·þÿÇèq§þÿƒÈÿë9H‹ÏèhþÿH‹Ïèÿÿ‹ØM‹ÌM‹ÅH‹ÖH‹ÏAÿÖ‹ðH‹×‹ËèÂÿÿH‹Ïèùhþÿ‹ÆH‹\$@H‹t$PH‹|$XHƒÄ A^A]A\ÃÌM‹ÈL‹ÂH‹ÑH
ÿÿéCÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
±ÿÿé+ÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
(¾ÿÿéÿÿÿÌÌÌL‹ÊH‹ÑH
¿ÿÿE3ÀéûþÿÿÌÌÌL‹ÊH‹ÑH
Ë°ÿÿE3ÀéãþÿÿÌÌÌL‹ÊH‹ÑH
ã½ÿÿE3ÀéËþÿÿÌÌÌHƒìHHƒd$0ƒd$(A¸H
H¹E3ɺ@D‰D$ ÿ-"H‰VHƒÄHÃÌHƒì(H‹
EHƒùÿtHƒùþtÿ;#HƒÄ(ÃÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAWHƒì H‹ê3ÿ3ÒDG‹ñè9ÏÿÿL‹èHƒøÿtPDG3Ò‹Îè#ÏÿÿHƒøÿt=H‹ÝH+ØH…ÛŽÁÿ#A¿WH‹ÈE‹Çÿ/#H‹èH…Àu1讵þÿÇ裵þÿ‹H‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A]A\ú€‹Îè^D‹àD‹ÃI;ßH‹ÕEMÇ‹Îè_7ÿÿƒøÿtH˜H+ØH…Û~ëÛèiµþÿƒ8uè?µþÿÇ
HƒÏÿA‹Ô‹Îèÿa"L‹ÅH‹È3Òÿƒ"ëUy]E3ÀH‹Õ‹Îè>ÎÿÿHƒøÿ„Tÿÿÿ‹ÎèAóþÿH‹Èÿ° ÷ØHÿH÷ßHÿÏHƒÿÿu%èÖ´þÿÇ
èë´þÿH‹Øÿ®!‰Hƒÿÿ„ÿÿÿE3ÀI‹Õ‹ÎèáÍÿÿHƒøÿ„÷þÿÿ3Àé÷þÿÿH‰\$H‰t$ ‰L$WATAUHƒì H‹ÚHcùƒÿþuè‘´þÿƒ G驅Ɉ†;=ØHs~H‹÷L‹çIÁüL-ÙHƒæHköXK‹Då¾L0ƒátW3ÀH…Ò™À…Àuè>´þÿƒ è´þÿ»ëI‹ÏèÈòþÿK‹DåöD0tH‹Ó‹ÏèÁýÿÿ‹Øëèè³þÿ»	‰‹ÏèBóþÿëèó³þÿƒ è˳þÿ»	‰è·£þÿ‹ÃH‹\$HH‹t$XHƒÄ A]A\_ÃÌHƒì(HcÒèÿÿÿ÷ØÀHƒÄ(ÃÌÌÌH‰\$H‰t$WHƒì HcÙA‹ø‹ò‹Ëè¾ñþÿHƒøÿuèg³þÿÇ	ƒÈÿëRD‹ÏE3À‹ÖH‹Èÿç‹øƒøÿuÿ* ë3À…Àt	‹Èèo³þÿëÌH‹ËH‹ÃH´GHÁøƒáH‹ÂHkÉX€dý‹ÇH‹\$0H‹t$8HƒÄ _ÃÌÌH‰\$‰L$VWATAUAVHƒì A‹ðD‹âHcùƒÿþuèð²þÿƒ èȲþÿÇ	é…Éxs;=3GskH‹ßL‹ïIÁýL54GƒãHkÛXK‹î¾LƒátE‹ÏèDñþÿK‹îöDtD‹ÆA‹Ô‹ÏèÛþÿÿ‹Øëèb²þÿÇ	èw²þÿƒ ƒËÿ‹Ïè²ñþÿ‹Ãëèa²þÿƒ è9²þÿÇ	è&¢þÿƒÈÿH‹\$XHƒÄ A^A]A\_^ÃÌH‰\$LcÁHFM‹ÈAƒàIÁùMkÀXJ‹ËBŠD8F¶\ÀAã€D¾ÐAÑúú@tXú€tHút(út úuHB€L€J‹ËB€d8B€L8ë0B€L€J‹ËB€d8‚B€L8ëB€dëB€L€J‹ËB€d8€E…Ûu¸€ëA÷ÚÀ%À@H‹\$ÃÌÌHƒì(ù@t'ù€tùtè'±þÿÇè¡þÿ¸ë‡
7-3ÀHƒÄ(ÃHƒì(H…Éuèú°þÿÇèç þÿ¸ë
‹
-‰3ÀHƒÄ(ÃÌH‰\$H‰t$ ‰L$WATAUHƒì ‹ÚHcùú@t0ú€t(út útútè°þÿÇ銃ÿþu
èz°þÿÇ	ë}…Éxi;=èDsaH‹÷L‹çIÁüL-éDƒæHköXK‹Då¾Lƒát:‹ÏèøîþÿK‹DåöDt
‹Ó‹Ïè
þÿÿ‹Øëè°þÿÇ	ƒËÿ‹Ïèqïþÿ‹Ãëè°þÿÇ	èíŸþÿƒÈÿH‹\$PH‹t$XHƒÄ A]A\_ÃÌÌE3ÀA‹ÀH…ÒtfD9tHÿÀHƒÁH;ÂrîóÃÌÿ%ÿ%ÿ%ÿ% ÿ%"ÿ%$ÿ%&ÿ%(ÿ%*ÿ%,ÿ%.ÿ%0ÿ%2ÿ%4ÿ%6ÿ%8ÿ%:ÿ%<ÿ%>ÿ%@ÿ%Bÿ%Dÿ%Fÿ%Hÿ%Jÿ%Lÿ%Nÿ%Pÿ%Rÿ%Tÿ%Vÿ%Xÿ%Zÿ%\ÿ%^ÿ%`ÿ%bÿ%dÿ%fÿ%hÿ%"ÿ%ÿ%ÿ%øÿ%âÿ%<ÿ%.ÿ% ÿ%ÿ%ÿ%öÿ%èÿ%Úÿ%Ìÿ%¾ÿ%°ÿ%¢ÿ%”ÿ%†ÿ%xÿ%jÿ%\ÿ%Nÿ%@ÿ%2ÿ%$ÿ%ÿ%ÿ%úÿ%ìÿ%Þÿ%Ðÿ%BÌÌHƒì8M‹Ñ…Ét+;ÊtA;Èu"H‹D$xD‹L$pL‹D$hH‹T$`I‹ÊH‰D$ èþÿÌ‹ÁHƒÄ8ÃÌÌÌH‰\$WHƒì H‹Ù3ÿèäãþÿHHWè0âþÿL‹ØH…Àt4H‹ÈŠ„Àt&<"uHÿÃÿÇë	AˆIÿÃHÿÊ„Àuæ…ÿtAˆH‹Áëè|Sþÿ3ÀH‹\$0HƒÄ _ÃÌÌÌH‹ÄH‰XH‰pH‰x ATAUAVHƒì0H‹òH‹ÙE3öL!pANèYèþÿ…Àu3Àé€Lû¯3ÒHL$`èÇaÿÿ…ÀtƒøuL!t$ E3ÉE3À3Ò3Éè.œþÿÌ…ÀuH‹L$`H…Ét3ÒèÜ…ÀuH‹\$`ë5H…Ût3ÒH‹ËèÂ…Àt"3ÒH
­è°H¡H
FŽ…ÀHEÙH…ötH‹Îè¿âþÿL‹ðH‹Ëè´âþÿBL0D‹éºè’êÿÿH‹øH…À„°ÆL‹ÃA‹ÕH‹Èè†ÿÿ…À…H‹ËèuâþÿLdÿº\A8$u9H‹Ëè%L;àt_LA‹ÕH‹ÏèÒ…ÿÿ…ÀtIHƒd$ E3ÉE3À3Ò3Éè9›þÿÌA€<$/t,LæI‹ÕH‹Ï蟅ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éè›þÿÌH…öt(L‹ÆI‹ÕH‹Ïèr…ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèÙšþÿÌH‹ÏèÄáþÿL$¹èšçþÿ‹5ƒ
D95 '¸Bð‰5n
D‰5‹'èZ«þÿ‹‹
Z
ÿÁ‰
R
‹Á+Æ=ÿÿÿvè:«þÿ‰H‹ÏèDQþÿ3ÿëBM‹ÅM+ÄLÇA¹
I‹ÔèYìÿÿ…Àu3è«þÿƒ 3ÒH‹Ïè…Àt£èöªþÿƒ8
t™èìªþÿ‰¹èØåþÿë,Hƒd$ E3ÉE3À3Ò3Éè	šþÿHƒd$ E3ÉE3À3Ò3Éèó™þÿÌH‹L$`è¼Pþÿ3ÉèµPþÿH‹ÇH‹\$PH‹t$XH‹|$hHƒÄ0A^A]A\ÃH‰\$H‰t$WHƒì03ÿOèƒæþÿ3Û‰\$ ;RQ}\HcóH‹.AHƒ<ðtGH‹ðöBƒt=‹ËèÂ[þÿH‹AH‹òöAƒtHƒy(tèaþÿÿlj|$$H‹ë@H‹ò‹Ëè\þÿÿÃ똹èîäþÿ‹ÇH‹\$@H‹t$HHƒÄ0_ÃH‰\$H‰t$WHƒì@H‹Ù‹òHL$ I‹Ð3ÿèýKþÿH…Ûu'è·©þÿÇ褙þÿ@8|$8tH‹D$0ƒ Èý3Àë~L‹D$(A9xu‹ÖH‹Ëèh^þÿ@8|$8tbH‹L$0ƒ¡ÈýëT¶‹ÑBöDt%HÿÊ„ÉtÁâ¶ÁÐ;òuH{ÿëH…ÿuH‹ûë;ñHDûHÿÄÉuÁ8L$8tH‹L$0ƒ¡ÈýH‹ÇH‹\$PH‹t$XHƒÄ@_ÃÌÌÌE3Àéÿÿÿ@SHƒì ‹ÚH…Éuè
©þÿƒ èâ¨þÿ»‰èΘþÿ‹ÃëP÷ÂùÿÿÿuÛÿàƒøÿuÿ¥‹Èèò¨þÿè­¨þÿ‹ë'¨u!¨töÃtè·¨þÿÇ茨þÿÇ
ëÒ3ÀHƒÄ [ÃHƒì(èwÿÿÿ÷ØÀHƒÄ(ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌ@UHƒì H‹ê¹èAãþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹è&ãþÿHƒÄ ]ÃÌ@UHƒì@H‹ê‹MLè}çþÿHƒÄ@]ÃÌ@UHƒì H‹êH‹MPè·YþÿHƒÄ ]ÃÌ@UHƒì H‹êH‹M0èYþÿHƒÄ ]ÃÌ@UHƒì H‹êH‹MHèƒYþÿHƒÄ ]ÃÌ@UHƒì H‹êH‹M@èiYþÿHƒÄ ]ÃÌ@UHƒì H‹êH‹MxèOYþÿHƒÄ ]ÃÌ@UHƒì H‹êƒ½€t¹ègâþÿHƒÄ ]ÃÌ@UHƒì H‹êH‹H‹Ñ‹èuNÿÿHƒÄ ]ÃÌ@UHƒì@H‹ê¹è.âþÿHƒÄ@]ÃÌ@UHƒì H‹ê¹èâþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹èøáþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹èÝáþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹
èÂáþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹
è§áþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹èŒáþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹
èqáþÿHƒÄ ]ÃÌÌÌÌÌÌ@UHƒì H‹ê¹èQáþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹
è6áþÿHƒÄ ]ÃÌÌÌÌÌÌ@UHƒì H‹ê¹èáþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹
èûàþÿHƒÄ ]ÃÌÌÌÌÌÌ@UHƒì H‹ê¹èÛàþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹èÀàþÿHƒÄ ]ÃÌÌÌÌÌÌ@UHƒì H‹ê¹
è àþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹è…àþÿHƒÄ ]ÃÌÌÌÌÌÌ@UHƒì H‹ê¹èeàþÿHƒÄ ]ÃÌÌÌÌÌÌ@UHƒì H‹êH‹E`ƒ ÈïHƒÄ ]ÃÌ@UHƒì H‹êH‹
‰ÿÛHƒÄ ]ÃÌ@UHƒì H‹ê¹
èàþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹
èñßþÿHƒÄ ]ÃÌÌÌÌÌÌ@UHƒì H‹ê¹èÑßþÿHƒÄ ]ÃÌ@UHƒì H‹êƒ} u'HcUHH‹ÊH‹ÂHÁøLA9ƒáHkÉXI‹À€dþë‹UH‹ÊèùãþÿHƒÄ ]ÃÌ@UHƒì H‹êH‹MHè3VþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹èTßþÿHƒÄ ]ÃÌ@UHƒì H‹êHcM H‹ÁH‹;H‹Êè'L'\'l'x'Š'ž'®'Â'Ò'â'ö'
((2(D(Z(n(†(¢(*110'þ0î0Ú0Ê0´0¢0Œ0z0j0T0D0*00ö/ä/Ô/¼/ª/š/ˆ/x/`/8/*/'''ô&â&Ì&À&
1®& &&x&j&\&F&6& &&ü%"/:1/î.â.Ô.ê+,,,4,N,l,|,Š,¢,º,Ì,Þ,ì,---0-B-V-r--¤-¸-Ò-æ-ö-.&.2.<.H.Z.h.v.€.–.¢.¸.Æ.Ž+à(Ô(Æ(H*:*$***ø)ê)Ü)Ê)¸)ª)š)ˆ)z)f)Z)F)2)")))þ(ì(¼+Ð+ª+¨¥@Ø@H™@hœ@8?@K@ˆ¦@ܯObtøtâCreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.5\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\Please wait while running postinstall script...-installIsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptnamemetadatatarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”Þñinvalid distance too far backinvalid distance codeinvalid literal/length code`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

incorrect length checkincorrect data checktoo many length or distance symbolsinvalid distances setinvalid literal/lengths setinvalid code -- missing end-of-blockinvalid bit length repeatinvalid code lengths setheader crc mismatchinvalid block typeinvalid stored block lengthsincorrect header checkinvalid window sizeunknown header flags setunknown compression method inflate 1.2.5 Copyright 1995-2010 Mark Adler 	

#+3;CScsƒ£ÃãIÃ	
!1AaÁ 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionaryÐ¥@À¥@h@°¥@ ¥@¥@x¥@h¥@P¥@h@€fàFðKуî É
ÈI*TÀðKуî É
ÈIÀT§TðKуî É
ÈIàOÐ ê:i¢Ø+00€S‡ Bi¢ê+00@ð_dPŸª/•N  ì!ê:i¢Ý+00€¢'"ê:i¢Þ+00º
E%­Ð˜¨6ÀF‘ÀF’ÀF“ÀF”ÀF ÀF¡ÀFÐÀFÑÀFÒÀFÓÀFáÀFâÀFãÀFäÀFåÀFæÀFèÀFéÀFêÀFëÀFìÀFîÀFïÀFðÀFñÀFòÀFóÀFôÀFõÀFöÀF÷ÀFøÀFùÀFúÀFûÀFüÀFþÀFÀF¡΋!	±ÿÝÌH€žãˆx5Ï®i+.b ö`¬ÙЙËÀOÖD—¢Vö	¯AHˆ÷Ì
F¤Mä^2mãF†¼T
íÐàðd_˜ÔN¾"ÚòµÅáÑÎú
(èÑ‘‡µ2ñéW]Â/4*&{ÐŒ© É-¿èzeÒG'{ÐŒ© É-¿èpŠh}ÆЙ›ÀOÖUáBl‰ÅЙšÀOÖUá•3”(Ò9ÀOŽë> ãG ©òήe+.bµchÈЙœÀOÖUá4^ñ;ݧBª}/NÅK°›f’£NrŸ@¶"ö=½Å3ŒÈH$¹Ñ˜ÕÀO¶‡Ú àü¼ìРÉ'€þmyÏ•4À[®ðJ1ÒйB Éá&®M[¸Ð˜ÀOÙrÈèGÂй: Éá ·qíEÐ’J ¯Ç¬MàÐWs5Ï®i+.bÀs5Ï®i+.bà¥s5Ï®i+.bw~s5Ï®i+.bå%ñeá{HºÒqÈC,ã4ÄÂ0‰L˜]©÷0°©²ë‹ÐRзôÀO×ì$¦ïŽéÑ[D”·tûÎ.¡+à*U6ÌF¶:(Yˆ;Êaª-kQG´œû˜^ø)˜|ÞÃI)ÓЫsÀOÃ>€±â+ØdWЩnÀO×¢@;òûðㄈª>Vø€;òûðㄈª>Vø 
»ÊWÚÏ™t ¯×—b@J7<äºÏ¿}ªiFϦЙËÀOÖD—a'»wjÐ¥5ÀO×Ðb°0¡wý”Ð¥DÀO×Ðb AG†QÒ»¶`—{FL!m•‘v’Ñ’`—ß[Ôc'»wjÐ¥5ÀO×Ðbd'»wjÐ¥5ÀO×Ðbñ6À†¡Ð‚Jª[CƒA¦VgqÞЃª[Cƒe'»wjÐ¥5ÀO×Ðb“Û5iè!ÌL¾¹ŸãÇz)zR88øÓüѦ¹`—ß[Ô|¼ë^1Ò¶/`—ß[Ô@¾–L\‘ϙӪJè7@å‘°ãƒÏ§ ¯×—b‡uïИˆ`—Þ¬ùëô@јˆ`—Þ¬ùà.PR€ìЉ«ÀO—-âT'²tEјˆ`—Þ¬ùA`ÂtÑpÑ·Z Édþ¥lÄ?<Ò¾æøÊWý4p ªlTI¬?—¢rùŠPèBÒ¾, É¨=¡Oñ${уøaÏP‡¦“•Ñ”o0pû,•Ñ”o€iyŜѨ?ÀOÉa¸4‚¢Ò†ÅÀOŽê™Øµä,¢Ò†ÅÀOŽê™ ÇÌÏ‚¢Ñ‚`“‚RéWp½Ñ‰ÀOÂÈ6Œöò“Ó£ÀOy«Ñ¦jc(=•ÒµÖÀOÙÐ0ñ%·ïG¥ñ`Œžë¬¡¸51M–Ùl¿Ég™‹Í~6Á›J”N½fsÌöv]=›»D¶®%ÚOcŠg3K›ÿ@Ò¢~ÀOÃq!‹2)wüK•L+2V°4K›ÿ@Ò¢~ÀOÃq€T'ò‚÷‘B½”ñ6“Q:ì.7£VœÎÒŸ`—Ɔö䬮®‰E¹·»†z¾âí5K›ÿ@Ò¢~ÀOÃqiI~©+.Í©áp¶Ñ¡ÎÀO×]_e¸ÿ¹ÎO¸œšk§mçŠ'WFAÒƒšÀOÙлóP0µ˜Ï»‚ª½Î³óP0µ˜Ï»‚ª½Î´óP0µ˜Ï»‚ª½Îá‹MÒ…]`“gµáI6FÓ—÷ÀOEг]“šˆ—K¹$ßÉáåè¢ñþ^5N“›$×÷̈&HÇS™«3M¬¤1õ7ˆ£iÙÿçЩ; É'$â9YõÓŽ:ÀOh7Õ%â9YõÓŽ:ÀOh7Õ&â9YõÓŽ:ÀOh7Õ'â9YõÓŽ:ÀOh7Õ«³ë|šI¤’ÊÄ˃(â9YõÓŽ:ÀOh7Õã¤!FÖðsGŠœFç{H@¡FãÕS÷2I´Et€$˜¤á„#œC¤È«‘Rõ†
e.{ ŽJO°že—¯Ç/°ö”P($IªZÑ^„†€9Ÿ½À¸$í\EƒæÕ9OèÄ奄ñ‚`O’„O·\;éx‡Ð8WõFž¿ºTpjØ÷œ«¸ìÂzO‘1Iæ(
@ü­úw·iKªw^ðæèàÖ‡Åω© ÉA)!¿\_ÑЃª[Cƒ°â+ØdWЩnÀO×¢€ÿ4DLïήe+.bÀSmbŒÑ²Í`—ߌ Àœí¹Ñ˜#ÀOÙrìŽ'Œ«>ÑŒ°ÀOÙÐë¯çÑ.jÐŒxÀOÙ´ôº^QmÒƒ­ÀOÙÐd¦Ñ4 É'äô>áòÒИÀOÙr3ó€ß·Ò£;`—ß[Ôè»ÚM•ÓO°ôµ¹KúLb`w¤±GŠŽ:J˜'iÏ>ŒV–MYFDAtâÖ;&åO‘ÁF°¤íÔÛ}êÄîÒ¨\I®;¿% ›S|ƒÀ
ø»*E…
yÐŽf|§txŸMNI–{@°Ò>KëJ§‚´®\F Зî4mc-Nüv­ÖE¦c7½V…ø‹fCNÁ²I—Étw„ׄ·8A!Ó±J»©'ËÀÅ8šEûþK}4@¥¾¬°Vq’Cšš(D¾W@¤Xzv×çùF@S·Ë>L¾NdÍL·Ö¬+Ùo—.ÑEˆÿ°Ñ†¸ÞÝ·Œ"ý®ãJ†Ló‘
¸þ:Ì¿´,ÛLB°)隇ÆA» }¹jô—Lº^6CTw]§+.ÃD¦¢«¦JQÃS[bH«ÁNº¡ïAFüÀP®ÒëŠC†UŠ	.4˜zlƒ‰À'K@-ÜýtКÓý#¯F­´l…HiÇa÷w­hŠM‡½0·Yú3ÝS¿«Åá!A‰†boÂÉs½t’ÑÏÃA³^±?U§Xôè“2¦NfÛH yßuž	÷5ꥂÍÙÅG–)á]/qNnNÔ9þjòI†=¯Êæÿ¸W¤.ÖIª|çK‹ã°g
4ªÄòcH¯ïø~òæº%‚]«bÁýÃM©Ý
I]—ç7B¹¬WGC‘Q°Œl2Ñ÷¯$HíäܨEâüye64Û…¶>ùeöL :ãïerŸ=…'³ñºoÏOU{Žp‘¤¡ ¥€öO½sCůè$5¾3QBº…`ÊíÏ]v+éÀqAŽ¦¸Oö;ŠÜÙ„·.C§Z0§YcwNÁç]N·D.±®Q˜·°1RÖñ²WH¤Î¨çÆê}'ô‹óCòB“gÞ(ü#…l^"`Gšþê3¶qs0â3NvFƒZ˜9\;ûï@Z|û üK‡JÀòà¹úŽ$M—ÞÆÙ>M¿‘ôEQ ¹w“€mðjKD‰W£w? §Õec
åE‡ö
¥kjO}¶c^¿ÁNI²œe·2ÓÒíñ÷mŸ¢Gª®)ÓÆðfâ®×\"gJ¸]lœáV`ËW0½¼\Ê"F´-¼VÛ
åpñNr-¤ïOŸ&¶„oºO}N8Ðú—GË¢)³’µqÕØKmÓH¾—B" C›˜µ™[E„«|täÝüKpÈžô&A©Ãµ*ôè†ûë¶i‡µ†G´ï½Ã2®®øÚHÏæNO¸iØNã„«•9žœO¸'H²Klqto%µ¼öyîL·%Ü4äýF˜x€WOŒbD»cq#€±	µ(O\iø„NŽ`ñ¹|\ÇÞ1‹¥I“¸káLúICš«N_3haO‰1ÏF—I&×I}!<O™ªýÂÉGFVXi³aé;B¶‡8n¿Ø29ÌÝÖ”hJuA£t½XJQxd©_w~8Æ¢WU¦]ƒOˆ	ÂÉŠ¦ú36ÐË(AŸ#)Vãåàç)–¯€ÿF€#Ϋœ>ãî%'˜GožG´G+ú}.а‰¶Óv»L‡÷X]àp`OÞúK¤”‹ ²#ó”7EµªC£)Ãt0Å*ƾ{,DÈ
J‘úÎöõœý¡àÙÖ‡Í+DW^
ëOor9tÖÙRNƒNgɆó‚>!€ý¼OLˆ»'`g©+$Ì%|šQO€àz)(þ¾Bã¢_@^A¦îÊÖ% xSDŠMƒt	ÖN†nòØ8Ã…¼m]rL§wìx,¹4ïK†§u@ºˆ+‰©ô׉#äG©``¼Âí“„µËW´é®G¡ Äß35ÞâãóÆíA„	A­ól ·ÞG؂تçíI†·æá÷Íþ‚Âï à`F“têˆQ<ü€ð÷Ëë[áM¼ƒEÄ€öªd_»ðµNŽM&uf4L—3l÷³¯×E¥ŸZIéC~Á½"ñ‚@Œ0(9ŸA8L"k1Ë÷%¸BŠ	T
#¤=ØE\¿«Ì\·G»N‡Ë‡»ÑbÒãR
FœHòsÔp£ÚS ’i)!@¿'QLü.JiÀFÏÀFÀFÀFÀFÀF ÀF ÀF!ÀFÀFÀFÀF&ÀFÀFÀF	ÀFÀFÀkŸò!PΪi)?ÀF0:s*έåªDw=ÀF
ÀFÀFÀF
ÀF
ÀFÀFÀFÀFÀFPÀF%ÀFQÀFÀFÀFÀF`kõÕ;Yµi+-¿zÐ1OYб” É
È¿¶Ÿ¥4<Ñœ™ÀO¹˜ªV±%п
ª¸ßÒ… XÈ$5I´‚?Ø#3:O4jõÕ;Yµi+-¿züjõÕ;Yµi+-¿zÐiõÕ;Yµi+-¿z ÄvÏšñ ¯nrô=ÀF>ÀF@ÀFDÀF[ÀFðÊ™^Aψªµiõ XשFÏ•üªh
´Mm8gÏ–ªh
´zÔó0GdÑŽ<ÀO¹8m®ö¼xˆÑƒéÀOÂÆÔ4ÈyˆÑƒéÀOÂÆÔ"ÀFFÀF’Mm8gÏ–ªh
´0ÀF1ÀF2ÀF3ÀF%ÀF)ÀF*ÀF0:s*έåªDw=IÀFè¹ë–yÒ‡.øY+ÀF&ÀFEÀFGÀFHÀFÊ:/Û†/ÑŽÀO¹˜šË:/Û†/ÑŽÀO¹˜šÌ:/Û†/ÑŽÀO¹˜šÍ:/Û†/ÑŽÀO¹˜šÎ:/Û†/ÑŽÀO¹˜šÏ:/Û†/ÑŽÀO¹˜šÇ–v\цø°WÞy”(ÌÒ ÷€_…±ÁÀFÀÀFÆÀFÕÀFÔÀFÎÀFU
8r+£C…+nó4é4ÀFâRX0eѶ£øu{ùÚ®šP9VѶ¡øu{ùðþ½ÏÏ£0ªÁne0ÕE
KvСʪÁne
y˜´âа±ÀOØܦÏ«|õxÒ–ÀO£†À¨´jÒ­IÀO£†ÐàQžnÒ–ÀO£†0îüŒ½9иѠ$«-»¸1.¦Ð¦Å É¯EÀ^¼ƒ*oСĪÁneÀÞP«oСĪÁne |Œ~|Б?ªÁne?Ç¦üàЗP É¯E^æ#ŠÂ1Љ $«-»á?îƒÙWй2 $«-»â?îƒÙWй2 $«-»pðwµâ~Б?ªÁneg­‡Ð‘@ªÁneñ˳ÁjˆÐ‘@ªÁneò˳ÁjˆÐ‘@ªÁneã?îƒÙWй2 $«-»~{ŒS^ÒЗB É¯Eyð¾|„ªKD¼phäƒê¼KΔӳѹ´ÀOØÕ°ž™rÀIúÑ ¯ÀO£†°…‘’ËÅC€©’'zO{Tx…hиÀO×ìà{ËlhиÀO×ìÎ6²Ç€îИ_`“‚ðÙÃ\Ñ•¾`——êOßOðÎrþÒ‡¥ÀOh7Ïü¬y½)ÓŽ
ÀOh7ÕBÐTyI¼²6¾Eº&jnLF°BìÀ}æsíïg'èD´“xó˜+h\ÒtÉ<³6M­>Ù?i]?ˆú9ì¯øÅA„!8¾ÒFs°%çÍÉÌE‘~2]rú´Î?àöjdÖôN–&÷àí6u^g¤óO!˜BŽ°>9ù}˜Œ®—‡ÓN¾r*GÝ“°¥ùkF³ðNª]Í·gh±hÏ“ægÙA‡c™*î^Z¡%­È”2îAeqKÐW»'ìØ;?B@±
JÏÙ$ÔSõQ¦À‹´Òµí`—Ɔö†(ÂœŽÜÒ±ÐÀOŽë>’ƒÛñ1sÐŒ™ É-¿èªO(hHjÐŒxÀOÙ´…ÀiQÍD”¯(ߥlù+ ‹rˆ÷Î’­ª§LÐm‚CçîB¼U¡âaÃ{þÓ°Ÿ~Ÿ‘C«.›`1“y‹Á¼º/D€ÄŠYÃF;šæa¥¸´A‘¥dƼÊ403bpcã(J¥g
·€æ×ØДէ{E³´Î]º¬ˆ°­é½ÆEŽ)П“SáãØ-<¨©M£0G$4[¡¾“Vÿà,HMµÅ@}͹2Ý­H¥<$A«ãµ§%1²efþÊà¹I¡x+\´’¥ÚýhŠÜ LŒëAfCµ¦%§ñ°”¼D–áB–£Râm§>¶…oE¡œHžú…‹?¾syûYz(©…¸yòé
…K¬Ýìù@‰Aº—º“X‡G§áA'qQU”‚AÿJ€ú
sêÌY!ëW«O«Zåú{ê*lñ×ðg²(M‹â2¥Ä(¼ÿ ‚TfC¾'>çŽÂ|a.» 	ÑšÀOÂÖÁî±;•´“ј£ÀO¶‡Ú.K[ãÚÁKŸ8¼õÔ…¶¤³…¶H™Ù]êÒ‡26 Ù-&{ÐŒ© É-¿èráë:Љ³ É
¬ü%äwùËCºj»W'tVaämÑyî«!@‘i²aÖWBóýVmýЕŠ`—É •I-`:±›B¦n5äOC‘ûê(ž†K鞟Š^ﯘÇ=ÄÑ•êK0»™â˜:ÚšÑL¥%2J³·4{î[ãkY¦s=ÐåBM¯ÀQ!ºB\[–ˆ/B{N€sASÃÖ¦.À̆I›#t9JD¨f?kјÀH¢"ûÞtâûÅ»˜‘ªìÌ-G¾í¤ös?z¥ZÕA°žže¬!`[ǽ6îæN¾XXâ$µ¶ÓßÁéK…ö¦iiôöÅ‘£•Ôž(L„«žqžm®å–ájKÆHªˆ(.~,-Y@ƒo‚3\.Q¸ŸÉåëC£pðg{‡L¿°õµŒK”Ižs<_«z”\
L´ÖK÷ƒoÉø(t¦ã;sM³|¥@¿ø•)Ù^ÏvJ¿YêÓž¢¹~+IÇzŽÃŠC‡ÛhsxDÿp§ØÎWJ?,C“P0òDƒ÷OôAÑoËZ\ÊÜq"ütD·Åk¬â×¾®‡TLžrTŒöIkE
àaÿ`N’Ne7¶Ý6ò‹Œì_I˜”‘Õ|k’H¢rYøˆšM>sáë:Љ³ É
¬ë¯çÑ.jÐŒxÀOÙ´ðË¡d:aD‘X7iii9PÛ5—}+E‰ut¨X(ÓT6QøB~ÛœC…ñä]_È#ͼ„Þ_ÛL®¤¯d¸=x«ˆr|Õ­ÔhG¾–•2Ù`Òýæ?uIœŒ¦Ÿ£p4Bf6×—K›ƒt„©Ð3ÇOtaµ…‘G©°'"v0›
SNæwL£¬1Ð"(i¡v”ù¬@È	Yè‡G€ºØ­+ÐÀO×ÐbÈCß¾Ó‹4`—ß[Ô„L¼Òr?RJ¦{Ëó˜,»AÛs…EŽO¨ŒW¡£L›Ñ‹"ÀOÙÐ7vî8áуyÀOÙÐà½äühK€KŽœt&1Zsˆ~¯§:6›B¨ã÷}Ft¤ˆrØ⋪†GM·v2̤pŠDÍ´†œfD’.b[‡®€Gåvt­ãH¦•;© ¯ñ
zæ<§±ŠñDCÒü¿kÐÊ?}ùÖHƒ2”lwâG”Zrµ\Úí£˜GŠÛÅçÚ™±—YýÆkŸˆH‡”èŒÞ?FA&O©•AŸŸ;±,àÉUi™6
ÈI‹Jì²"ûx‡Š§9Jª³£›œ4§Ùܰܵ;E¾–fDþ×°¼ÒÀqmrÌE¦À.1ÁÛ!Yu´Y&¸î·H³xHÏ£‚'¶éGˆVÁBeUNOØ®Ç|)¼I‰EÁ@É0l…yדس„Dƒg,Ý ÎÖeÆùòÂL¿3ƒ"×5/QÞóqíCA„wéSk‚5X§;-î3ÕB»{_41Ølxƒpé³æòO…h6þǾƱ•ˆ´L¥b
VBPƒo¯zÈþù5zD­· #D‘@Fègmœ[¸Mœ¼Ýá/BTñ|\¹ŽÔ?@«™ÖÇz„¬ìpà¼ÀD—°FÇÉ[žÜ0é	49Zуú É
ÈI}ÑÞA³ÖaB™}ˆÆKXÐ䌠%ú«Dµ|DZÃ#à¹`ËÚ½Wv®G„EÒ>Ï‚®ÏZ…#ê@–Òk{Xö8ø&ˆ¨o‡IªÞêï¿èQ–d5ÀCþÕv†Sdn0@Dš×ÐHˆæ¤&’'›û®ûÒÖñŒEŒ4V˜w¢Ò˜n¨B*O—øŠôà&Ù-bØÑÞfôM¿lV!™jñ’
ö
hÖF³XÖapÝäf_Ï:ÛqúJð?Äýò¥¸¿Þ2cµ‡pFÀ^W´¤ž5}3Æ” H¼çjœiÔÖŸOY<0Ÿ¡G—šÉè==
–Û6e–ÑF›§ÓpžìùíûèqîüF¿ŒwH¨¡®Ò¶‰e_žK·à#ÍÙq}ŒÄkdÁ˜ò‘O¢ë-ÑpÙÑ;z©5³O¤gôŒ¬5âе.áÃ}øD¶Ýw³Mmä3sîðüæ›GŸ%¨`Â4£Žún¦.8E’4ï0…±é§PïpÑ·Z ÉdþÀF K6ó¹eΩºªJè7`, ê:i¢×+00ÀFh3©ÝM¸nÚãMÜ™ŠS{5”)ÊxKƒ®èþt	OÏó¨°3C«KˆsË­¤‹“w`µ¬$ÇD‚âƒ&ªl·´;ýÝ0M£HŸµÖ¿þR¸×UÑöòBªu‡(¡²ÒdÆT&©àaërr†C‘uòäÆ‹.|uUÐ:WˆPH’w¸[ÛŽ	œZÜŠèÞM¥¡`ø* ®÷óâ´À!ºsGº3^ÉFë‹0ÇðMßãJ‘Sªk‚éyZ
8—Ñy
ÈM 3íˆ,/¡KáqóI\ŒœMš;T¦‚Q'°ˆCH¿ïâÈCªåÁh4-§6¶C¬$Óð/Ù`zÌL’be…L†WÑw’R"¶«Œ!’ªì5C3€Ò4Âî¬a@ðY?J©TwZ¥Àƒ®8—™•ˆKžMn錕RÚa/pam/pmCorExitProcessmscoree.dll@a@àa@TZSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunLC_TIMELC_NUMERICLC_MONETARYLC_CTYPELC_COLLATELC_ALLÖ@t@Ö@äM@HÏ@øÕ@äM@L«@èÕ@äM@Ê@ØÕ@äM@hÆ@ÐÕ@äM@$Å@	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;runtime error 

TLOSS error

SING error

DOMAIN error

R6033

- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.

R6032

- not enough space for locale information

R6031

- Attempt to initialize the CRT more than once.
This indicates a bug in your application.

R6030

- CRT not initialized

R6028

- unable to initialize heap

R6027

- not enough space for lowio initialization

R6026

- not enough space for stdio initialization

R6025

- pure virtual function call

R6024

- not enough space for _onexit/atexit table

R6019

- unable to open console device

R6018

- unexpected heap error

R6017

- unexpected multithread lock error

R6016

- not enough space for thread data

R6010

- abort() has been called

R6009

- not enough space for environment

R6008

- not enough space for arguments

R6002

- floating point support not loaded

Àß@`ß@	ß@
°Þ@PÞ@ðÝ@ Ý@@Ý@ÐÜ@€Ü@Ü@ Û@PÛ@Û@@Ú@ ÐÙ@!à×@x¸×@y˜×@zx×@üp×@ÿP×@Microsoft Visual C++ Runtime Library

...<program name unknown>Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODESystemFunction036ADVAPI32.DLLÀÀ–ÀÀŽÀÀÀ‘À’À“À´ÀµÀ	À         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿunited-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamerican¨ñ@ENUñ@ENUxñ@ENUhñ@ENA`ñ@NLBPñ@ENCLñ@ZHHHñ@ZHI@ñ@CHS(ñ@ZHHñ@CHSøð@ZHIàð@CHTÐð@NLB¸ð@ENU¨ð@ENA˜ð@ENLˆð@ENCpð@ENB`ð@ENIPð@ENJ@ð@ENZ(ð@ENSð@ENTøï@ENGèï@ENUØï@ENUÈï@FRB¸ï@FRC ï@FRLï@FRS€ï@DEAhï@DECPï@DEL@ï@DES0ï@ENI ï@ITSï@NORøî@NORàî@NONÈî@PTB°î@ESS î@ESBî@ESLxî@ESO`î@ESC@î@ESD0î@ESFî@ESEî@ESGèí@ESHØí@ESMÈí@ESN°í@ESI í@ESAˆí@ESZxí@ESR`í@ESUPí@ESY8í@ESV(í@SVFí@DESí@ENGí@ENUí@ENUí@USAí@GBRøì@CHNðì@CZEèì@GBRØì@GBRÐì@NLDÀì@HKG°ì@NZL¬ì@NZL ì@CHNì@CHN€ì@PRIxì@SVKhì@ZAFXì@KORHì@ZAF8ì@KOR ì@TTOí@GBRì@GBRì@USAí@USA6-OCPACPNorwegian-NynorskGetProcessWindowStationGetUserObjectInformationWGetLastActivePopupGetActiveWindowMessageBoxWUSER32.DLL€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwppCONOUT$TMPRSDS¤‘# ,H¨0FŸH©C:\python-dev\porting\cpython\lib\distutils\command\wininst-9.0-amd64.pdbdT42p
dT4’ÐÀpT4òp04=4ðàÐ
Àp`PÈ‘T42p20

4
2pd
T	4Rp
4,
*pÈ‘@&4ZXPÈ‘°‚+tZ4YVPÈ‘ 
42ðàÐ
Àp`P'%#
ðà	ÐÀp`0PÈ‘€dT4’ðàÐÀptd
T	42àÐÀ+T$4#àÐÀp`È‘Ð
4
ŒpÈ‘P*‡p`È‘ d
T4
rp

4
Rp$	,à	ÐÀp`P0È‘PÂp`P0È‘À4	#d#4#ÐpPÈ‘°
4

’pÈ‘@!0È‘0&	44,Ð
Àp`PÈ‘P

4	
Rp204"t1"d0"4/"*àÐÀÈ‘@3"tY"dX"4W"RðÐPÈ‘€+È‘@)	t3d241.PÈ‘`BÈ‘È‘ÀÈ‘°&4dbPÈ‘dT
4RpdT
4Rp2020d4
rp=
,t,d,4,ðàÐÀPÈ‘P'	T9482Àp`È‘€td
T	42àÐÀBB&Àp`P0È‘04$"P/	dT4
pȑ0bt4t
d4tdT4B)	t*d)4(&PÈ‘ 	b
ðà	ÐÀp`P0dT42pd42p
t	dT42À	¢ðàÐ
Àp`0P20dT42pd42p
d
T	42ÐÀp*4ðàÐ
Àp`PÈ‘ 20B		R0rp0Pd42p2020td4rðàÐÀPbbbb

2020d42p4Rà
Àp`P2P20x-|ŸˆŸ0M2Pd42px-ߟõŸKMrP,d4ðàÐ
Àpè1ç t£fMš2PBÀp`0x-$¤â¤MBBBBB20B2020¢p
`0P		bdT
4’pbdT
4’pbbbb

4
2p2P42px-íͭ™Md
T4
2ðàÐÀp2Ptd42Àx-Ưگ³MB
tdT
4’À
tdT
4’ÀdT4’ðàÐÀp

t4t
dT4
RàÐÀ'E4CÒð
àÐÀp`PÈ‘h##t#d#4#ÒðàÐÀPbbb2Ptd
4	RÀx-UÆwÆÍM|ÆÆÍM20’p0PBb		bbbb		bBBBBr0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r020r020!ÀÔ×Ôì!ä

d	4ÀÔ×ÔìT2ÐÀp!€ÕÐÕ0!,
,ô€ Ôtˆd‡4†€ÕÐÕ0

‚àÀPd42p2PRÐÀp`0x-¯ÙœÚçM20202042p

4
2pBB

4
2p2P
d4rðàÐÀpx-÷ÝßN20202P	

4
px-÷àœá%NœáB.	dÄ4þÀpPÈ‘à

4
2pBbd
T	4Rpbbb202020rP’ðà
ÐÀp`0x-eæøèCNeê¢êCNT4RÀp`
dT4²ÐÀp2PBx-Lð`ð^N2PBx-ð…ðyN2P20x-¨ð²ð”NdT42pd42pBBB
t	dT42ÀBB2020202020d42p20d42pdT42p/	tµd´4³°PÈ‘p2P

4
2px-"üyü¯Nr04rÐ
Àp`PÈ‘8‚2P
Ät
d	4RÐx-Ø„ÊNBd42p202P20x-CYåNB2P2P

4
2px-&0OEl O

4
2p202P2P42px-Ìù;OB[O2020d²	ÀpP

20202P2P2
0x-<`vO{¢–O2P2P

4
2px-09±OPWÑObp`P0
td
T	4RÀd	4RpdT
4RðàÐÀp&

ðà	ÐÀp`P0È‘à04MBðàÐ
Àp`PÈ‘$	à	ÐÀp`P0È‘À
t	dT42À2P2P2P
t
d4
RàÐÀx-0[ìOÃ/P
L,PBB-dQTP4OJÐÀpÈ‘@B

4
2p20dT42pd42p
4RðàÐÀp`
Pd42pd42p
4RðàÐÀp`
P2020
t	dT42À
t	dT42À
t	dT42À
d
T	42ÐÀptd4
rP  d T 4 rðàÐÀptd42ÀdT42pB2Ptd42Ðx-?1}1GP

4
2p
t	dT42ÀdT42pT42pB2P
Ä	td42àx-–4·4eP2P2P
td
4ràÐÀx-µ5Ü5€P\5ý6 P2Ptd
4RÀx-¹78»P"	â
ðà	ÐÀp`0PÈ‘htT4àÐÀd42pt42À		2020dT42pdT42p04dZðàÐ
Àp`PÈ‘ÈB2P
td
42àÐÀx-pK,LQbbbbbb2Pd	4Rpx-BM¶MQd42p202P2P
td4
RðÐÀx-þNBO8QÅN[OhQ2P42px-¬O¶OƒQd	T42pd42p20BBd42p04ZPðàÐ
Àp`PÈ‘pd42p20BBd42p04ZPðàÐ
Àp`PÈ‘p

4
2p2P4
2
Àp
`x-ûvwQ206%4q%fðàÐ
Àp`PÈ‘ 2P42àÐ
Àp
`x-aҦQr0r020202020td4
rPB
T4RðÐÀp`2Pd	4Rpx-R†r‡ÏQ›dT
4’pdT
4’p
td4’ÐÀPbbR0b
td
T	4RÀbbbd42p	Bx-ÑŽÕŽÕŽB	Bx-B2Pd42px-ÍêQBB2Pt
d	4RÀx-Ç‘Ù’R2P
d4
RðàÐ
Àpx-i”÷”RdT42p$	à	ÐÀp`P0È‘À
d
T	42ÐÀp202P
t
d	42àÐÀx-®™tš8RB

4
2p

4
2p

4
2p2P	Bx-盜PRœBBdT42p

4
2pd
T	4Rptd
T	42àÐÀd4
Rp
t
dT4
rÀ

4
2p20d42pd
T	4Rpd
T	4Rp2P20x-)©4©rRRP
Ät
d	4RÐx-x©ªRª*ªRRP
Ät
d	4RÐx-uª«¨R«/«¨R1
dT4ðàÐÀpÈ‘ˆBBBB-
Etd4C’
ðàÐÀPÈ‘Hd4Òp-
5td43r
ðàÐÀPÈ‘0d4²p
td
4rÐÀP2
0T42p

20dT4rðàÐÀp2
0td4rðàÐÀPBB20bÈ‘ td
T	42àÐÀ20

4
2p$d4pÈ‘ d	T42p$T4pÈ‘°
4
pÈ‘°202020T4RÀp`bÈ‘ ’à	ÐÀp`P0È‘H202020BdT
4’pBd	4RpT
4	Rp
td
T	4RÀdT42p
Ätd4²Pd	4RpT4rp

4
2pd42pB2PBp0x-‹êÇêÃRBBBBB4²p
`Pbd
4’pd	4Rp20dT42pdT42p04dZðàÐ
Àp`PÈ‘È

t420dT42pdT42p04–ŒðàÐ
Àp`PÈ‘X2P4
2
Àp
`x-S—êR

4
2p2P42àÐ
Àp
`x-ÑS20

4
2p2P42px-ÞêS
Ätd
4’P		b2P20x-ðû6S

20ÄtÒP$
$4$òðàÐÀp`PRP‚p0x-ôQSRP

4

rpx-ÝŸSr0b
Ä
td4
rP
Ä
td4
rP	¢ðàÐÀ
p`0
P2P
d42ðàÐÀpx-ð*"+èSB-
Etd4C’
ðàÐÀPÈ‘@d
4’pBd4
rp

4

rpdT4rðàÐÀpbbbb20
Ä
td4
rPBd42pbbbd42pbb
td
T	4RÀ$
53Â
ðà	ÐÀp`0PÈ‘Xd4²ptd4²P2P
td
42àÐÀx-!>G>T‚Btd
T	42ðÐÀ2Pd4	2ÐÀpx-…A«ATBd42p2P42àÐ
Àp
`x-	C;C4T4BB2Pd4
2ÐÀpx-UE|EMTb

4
2pRP
t
d4
RàÐÀx-J¢JfT®JÄJfT2P2Pd	4Rpx-SK}KT"KŒK±Td4
rp20BÐ î%P`0!¸(°`È$T*Hdè Ü*h`€ €+`¸$ž+8d %à+ e:+ø*+n+^+L++*+æ*Ò%À%º*ª*ž*’*‚*r*`*È*>'L'\'l'x'Š'ž'®'Â'Ò'â'ö'
((2(D(Z(n(†(¢(*110'þ0î0Ú0Ê0´0¢0Œ0z0j0T0D0*00ö/ä/Ô/¼/ª/š/ˆ/x/`/8/*/'''ô&â&Ì&À&
1®& &&x&j&\&F&6& &&ü%"/:1/î.â.Ô.ê+,,,4,N,l,|,Š,¢,º,Ì,Þ,ì,---0-B-V-r--¤-¸-Ò-æ-ö-.&.2.<.H.Z.h.v.€.–.¢.¸.Æ.Ž+à(Ô(Æ(H*:*$***ø)ê)Ü)Ê)¸)ª)š)ˆ)z)f)Z)F)2)")))þ(ì(¼+Ð+ª+…PropertySheetACreatePropertySheetPageACOMCTL32.dll€SetLastError|CreateDirectoryAìGetFileAttributesAYMapViewOfFile‰CreateFileMappingARCloseHandlexSetFileTimeèDosDateTimeToFileTimeGetLastErrorˆCreateFileAåUnmapViewOfFile`lstrlenAiMultiByteToWideCharLGetProcAddress>LoadLibraryAÔDeleteFileAÃReadFiletSetFilePointer÷GetFileSizehFreeLibrary”SetStdHandlekGetStdHandleJLocalFreecFormatMessageA‰GetTempFileNameA‹GetTempPathAGetModuleHandleA«GetVersionExAResumeThreadŠSetPriorityClassÆGetCurrentProcessÊGetCurrentThread¦SetThreadPriority¤CreateProcessAGetModuleFileNameARemoveDirectoryABGetPrivateProfileIntAHGetPrivateProfileStringAGetModuleFileNameWKERNEL32.dllMessageBoxA.GetFocus:wsprintfA•SetDlgItemTextA{SendMessageAiReleaseDC#GetDC6PeekMessageA®DispatchMessageATranslateMessageÜEndPaint€GetSystemMetricsBeginPaint›DefWindowProcAUpdateWindowçShowWindowmCreateWindowExAORegisterClassAìLoadCursorAMoveWindow GetWindowRect9PostMessageAfGetParentvSendDlgItemMessageA)GetDlgItemŽSetCursorUSER32.dll6CreateDIBitmapæDeleteObject¦SetTextColor¸TextOutASetBkModewSelectObject<CreateFontATCreateSolidBrushGDI32.dlllRegQueryValueANRegEnumKeyExA0RegCloseKeymRegQueryValueExA`RegOpenKeyExA}RegSetValueExA8RegCreateKeyExA=RegDeleteKeyAGRegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dllpCoUninitializeCoCreateInstanceBCoInitializeole32.dll€GetSystemTimeAsFileTime×HeapFreeÓHeapAlloc+FileTimeToSystemTime*FileTimeToLocalFileTimeóGetFileInformationByHandlePeekNamedPipeúGetFileTypeòEnterCriticalSection;LeaveCriticalSectionÍGetDateFormatAœGetTimeFormatAÚHeapReAllocGetModuleHandleWExitProcessËDecodePointerŒGetCommandLineAjGetStartupInfoWÎTerminateProcessâUnhandledExceptionFilter³SetUnhandledExceptionFilterIsDebuggerPresent&RtlVirtualUnwindRtlLookupFunctionEntryRtlCaptureContextîEncodePointer WideCharToMultiByteŸGetTimeZoneInformationxGetCPInfonGetACP>GetOEMCPIsValidCodePageZFlsGetValue[FlsSetValueYFlsFreeËGetCurrentThreadIdXFlsAllocÛHeapSetInformationªGetVersionÕHeapCreateÖHeapDestroy4WriteFileeSetEnvironmentVariableWdSetEnvironmentVariableAÀSleep%RtlUnwindExëInitializeCriticalSectionAndSpinCountÒDeleteCriticalSection&FatalAppExitA|SetHandleCount GetConsoleCP²GetConsoleMode;SetConsoleCtrlHandlerALoadLibraryWGetLocaleInfoWgFreeEnvironmentStringsWáGetEnvironmentStringsW©QueryPerformanceCounteršGetTickCountÇGetCurrentProcessId/LCMapStringWpGetStringTypeW£GetUserDefaultLCID
GetLocaleInfoAEnumSystemLocalesAIsValidLocale]FlushFileBuffers3WriteConsoleWÜHeapSizedCompareStringWCreateFileWaSetEndOfFileQGetProcessHeapÿÿÿÿÿÿÿÿSoftware\Microsoft\Windows\CurrentVersion\Uninstall h@h@h@h@h@h@h@ðg@äg@h@ h@Ðg@h@Ðg@h@h@h@ðg@äg@h@¸g@¨g@˜g@xg@`g@Hg@8g@ g@g@g@ðf@€@Øf@@@Èf@Œ@¸f@4N@ f@xN@f@(@Software\Microsoft\Windows\CurrentVersion\Uninstall2¢ß-™+Í] ÒfÔÿÿ€Œ@€Œ@ÿÿÿÿÿÿÿÿ€pðñÿÿPSTPDT°F@ðF@
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ°H@¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þþÿÿÿCÈÕ@ÄÕ@ÀÕ@¼Õ@¸Õ@´Õ@°Õ@¨Õ@ Õ@˜Õ@ˆÕ@xÕ@lÕ@`Õ@\Õ@XÕ@TÕ@PÕ@LÕ@HÕ@DÕ@@Õ@<Õ@8Õ@4Õ@0Õ@(Õ@Õ@Õ@Õ@LÕ@üÔ@ôÔ@ìÔ@àÔ@ØÔ@ÈÔ@¸Ô@°Ô@¬Ô@ Ô@ˆÔ@xÔ@	pÔ@hÔ@`Ô@XÔ@PÔ@HÔ@@Ô@0Ô@ Ô@Ô@øÓ@àÓ@ÐÓ@¸Ó@°Ó@¨Ó@ Ó@˜Ó@Ó@ˆÓ@€Ó@xÓ@pÓ@hÓ@`Ó@XÓ@HÓ@0Ó@ Ó@Ó@Ó@Ó@ðÒ@àÒ@ÈÒ@¸Ò@ Ò@ˆÒ@|Ò@tÒ@`Ò@8Ò@ Ò@äM@äM@äM@äM@äM@ÀU@ðä@€é@ë@ðM@°P@°P@°H@ÿÿÿÿôæ@ÿÿÿÿÿÿÿÿ€
Xâ@Hâ@¸-@¸-@¸-@¸-@¸-@¸-@¸-@¸-@¸-@¸-@ÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Ml..ÀU@°U@xq@xq@xq@xq@xq@xq@xq@xq@xq@´U@|q@|q@|q@|q@|q@|q@|q@ðä@òæ@.þÿÿÿÿÿÿÿ$÷øøøìùìþ$ùY4ùlXùJhù`¢pù¤=|ù@ù€&¨ù(ŒÀùœÐÈùÐo äùp #üù#Ë$ úÌ$­%<ú°%§'Xú¨'(|ú„(%*”ú(*ï*¨úð*c+¼úd+ù,Èúü,<-èú<-¯.ðú°.!0û$0Ã0(ûÄ0Õ1<ûØ1Ë3PûÌ3"4pû$4Ž4|û´4"9„û$9G=¨ûH=Ò=ÌûÔ=2@Üû4@t@üût@AüAeAühAøA$üB´C4ü´CÁDLüÄDÕE`üØEFtüFPF|üPFbG„üdGÎK”üÐK-M¼ü0M4NÜü4NvNøüxNºNý¼N-Rý0R¤S$ý¤S¥V4ý¨V¶WTý¸WŠZ\ýŒZ&[dý@[I^lýL^Ùa|ýôa'bý(bc˜ý0c†g¸ýøgŠhÐýŒh]iäýðiìjôýìj3þ4ƒ$þ„d‚,þà‚Öƒ@þ„‚…Pþä…«Šhþ0Žþ0Žd‘˜þd‘Ç‘œþȑ呤þ’•“°þ°“Ï“¸þГ”¼þ”—Äþ —e—Ðþh—Å—àþÈ—i˜èþ„˜ïšðþðš ›ÿ ›B›ÿD›w›ÿx››$ÿ ›Ý›,ÿà›0œ4ÿ0œæœ<ÿèœhŸLÿhŸšŸhÿœŸ ÿ Æ£ÀÿÈ£ö¤ø¤¥(¥5¥08¥\¥8\¥y¥@|¥ ¥H¨¥ˆ¦Pˆ¦¯¦X°¦§`§E§hЧ¨p ¨Ñ¨xÔ¨ñ¨ˆ©rªœªg«”h«~«¨€«&¬°(¬]¬Ä`¬‘¬Ì”¬É¬Ô̬ý¬Ü­z­ä|­â­øä­n¯p¯ÿ¯@°/°l0°h±tp±³²Œ¼²Ÿ¶¤0·	¸À¸E¾ÌH¾°Ãè°Ã€Å€ÅžÅ( ÅºÅ0¼ÅÚÅ8ÜűÆHÀÆÇ„Ç´ÇŒ´ÇÑǘÔÇøÇ øÇȨÈ:È°<È]ȸ`È„ÈÀ„È¡ÈȤÈÉÈÐÌÈñÈØôÈÉàÉ9Éè<É¢Éð¤É'Êø(Ê‹ÊŒÊ
ËËoËpËîËðËSÌ TÌÒÌ(ÔÌ:Í0<Í¿Í8ÀÍ#Î@$΢ÎH¤ÎÏPφÏXˆÏîÏ`ðÏsÐhtÐÚÐpÜÐ_Ñx`ÑÆÑ€ÈÑKÒˆLÒ¯Ò°Ò.Ó˜DÓ¹Ó ¼ÓáÓ¨äÓYÔ°\Ô„Ô¸ÀÔ×Ôì×Ô{ÕÐ{Õ}ÕÀ€ÕÐÕ0ÐÕjØjØwØüxØKÙ@LÙ³ÚXÐÚ…Û€ˆÛÁÛ„ÄÛÚÛŒôÛ7Ü”8ÜkÜœlܥܨ¨ÜÞÜ´àÜݼÝÇÝÄÈÝWßØ߶߸ßäß0àÉá ÌáÞáHàá*ãP4ãäX€ä»äxÌäýä„ååŒåƒå”„å¢å¨¤åÓå°Ôåìå¸ìåæÀææÈæ1æÐ4æ²êà´êˆíˆí1ð04ðoðPpð”ðx”ðÄð Äð”óÀ”óÙóÔÜóôäô;ôì<ôkôôlô"õüŒõ¬õ¬õÌõÌõö$öNö,Pö‹ö4ŒöÆö<Èö÷D÷¤øL¤øêø\ìø1ùdhùôùtôùäûˆäûžü° ü0ýÔ0ý¥ÿܨÿøÿøøÿÖØ80©@¬Py`¤É€Ì˜„Ì,Ø,_ð`ž$	°1	,	4	
4	P
ƒ
D	„
í
L	 Æd	Ðl¤	xÝØ	àè	&
(
@,
@ML
Psp
t«
´pÀ
pÆÈæy |¿DÈL0cXdô`ô{ t| 7$„T$×$œØ$_%¬`%ü(¼ü(])Ô`)ˆ)ܘ)*ä*›*üœ*!+$+¬+,À+h,H„,p-Lx-u/`x/ü/|ü/ƒ0œ0¹0¤¼0¢1´¤1è1àè1|2ì|2)3
,3Ö3
Ø3L4(
L4ñ48
5$7x
$78À
 8ê:ì
ì:¾=À=3>(4>?8???H@?†?Pˆ?Ù?XÜ?Z@l€@âJ€äJ
K¤KPL´PLsLätL—Lì˜L»Lô¼LßLüàLMM'M(MÒMÔMMNDPNœNTœNˆOlˆOËO´ØOeQØhQþQìR2Rü4RYR\RoRpR´R´R(c$(c¾cHÀcæcXèc
d`d#dh$dhdphdÓu€Ôuv¤vSw¸Tw‹wàŒwì~èì~ËÌ€@€[€Ht P ÌXÌø`ø$‚h`‚6ƒp8ƒ~ƒ„€ƒ6†Œ8†‡¬ ‡ćØЇè‡àð‡ñ‡äˆˆèˆ¹ˆìȈW‰¸‰žŠ ŠÑŠ,ÔŠ	‹4‹z‹<|‹’‹D”‹ÜŒLÜŒúŒdüŒ-l0ethºŽ|¼ŽߎŒàŽýŽ¬%´(EÔhüäH\\pp-“$0“b•Xl•p–ˆp–K˜œT˜H™¼H™‹™ÔŒ™–šä˜š¯š°šèšèš ›( ›V›4à›!œH$œeœhhœ€œp°œ€žx”ž
ŸŒŸ@ ˜H ¢¬¢£È£¤Ø¤·¤ð¥Ó¥ü𥠦 ¦A§D§¨¨ܨ0ܨG©LH©EªtHªJ«¼L«l¯ül¯¦¯$¼¯ó¯,ô¯+°4,°d°<€°J³DL³â³lä³Bµ|Dµµ¤ĵ3Á´4Á"ÅÌ$ŽÅÔüÅhÆähÆÐÈìÉÊÊÌÎÌÎÏ,ÏGÏ4LÏÈÏ<ÈÏ[ÐD\ÐóÐTôÐÑpѺÑx<Ò!Ó„$Ó´Ó ´ÓÖ´„Ö²×д×ô×èô׌ØðŒØ÷ØøøØÕÛð۷ܸÜQÝTÝ\ß,\ßáßHäß³àP´àáX á`á`háâhâ$ã|$ã™ã„œãaä”dä™å¤œå!æ¼DæFçÐPçÀçèÀç²èø´èNéPéÖéØé7ê$8êãê4äêëXë)ë`,ëSëhTëuëpxëŸëxàë¤í€¤í¸í¸í3î˜4îˆî¨ˆîÎî¸Ðî!ïÀ$ï¢ïÔ¤ïOúèPúªû¬ûòûôûEü HüÆü4Ôüé
Hì
ÃtÄYœ\?°@“Ü”Ÿä ÿøu€Ù4ÜDvdŒÚlü£|¤yœ|NÈP‘ì”ÆôÈ®!ü¸!# #C*,D*_+L`+ +|¼+-„-z-¬|-µ-¼Ä-?.Ä00Ô˜0ý2à303ü03R3T3‡3ˆ3­3°3ñ3<4?5$@55<56D„6«6T¬6Î6\Ð6ã6dä6Ú7lÜ7ÿ7|88„8º8ŒØ8<¤<¥<Ĩ<«=ÔÄ=k>ðü>7? 8?Z?(\?ô@0ô@ãATäAùA€üA’Bˆ”BsC tCBDÌDD„DÔ„D³DÜ´D®EìˆGÅGÈG1H 4HK4K¨K„¨K…L¼LMÌM"MÔ0MKM`ÿKMfMˆÿfMM¸ÿM™Møÿ™M³Mð³MÍM8ÍMçM@çMNPN%NÐ%NCNCN^NØ^NyNHyN”Np”N¯N˜¯NÊN¨ÊNåNåNOXOO O;Oˆ;OVOè[OvOàvO‘O\	–O±OT	±OÌOœ	ÑOìO”	ìOP¸
P'P°
,PGP¨
GPeP¬eP€P0
€P›Pp
 P»Ph
»PQ¸
QQ¬Q8Q8Q`QdhQƒQ\ƒQQ¬Q¶Q°¶QÏQÏQêQ¤êQRÜRRR8RP8RNRÜPRrR@rRRDR¨Rl¨RÃR´ÃRêR,êRSlSS¨S6Sð6SQS<QSŸS”ŸSèSÀèSTDTTèT4TL4TMT˜MTfTäfTT,T©T|±TÌTt(€@€p€nˆ€k €l¸€mЀn耀	(	8	H	X	hxÁ
ä€Ë ä Íä$ÏZä€Ñä”ÒZä(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnPAÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-10.0.exe0000644000175100001710000056500000000000000024176 0ustar00runnerdockerMZÿÿ¸@øº´	Í!¸LÍ!This program cannot be run in DOS mode.

$[§ÜìÉìÉìÉŒ¢QìÉqb;ìÉqW	ìÉ”JìÉ”ZìÉìȾìÉqc‘ìÉqSìÉqTìÉRichìÉPELç®{Oà
Ì5º0@Pg™àÆ 0ðà2¨¾@0 .text¿ `.rdata¼¥0¦@@.data$MàÄ@À.rsrcð0Ö@@…ÀtŠ„Ét€ù/uÆ\@uïÃU‹ìV‹u…ö„€S‹]W¿ü2B€>toj\Vèôg‹ðYY…öt_SÆÿT1B‰Eƒøÿu&jSÿX1B…Àu9EtSWjÿUƒÄëSjÿUYYöEuh·ÿ\1Bƒ}t
SWjÿUƒÄÆ\FuŒ_[3À@^]ÃU‹ìƒìSVW‹=81B3ö»À9uuÇEVh€ÿuVVSÿuÿ׉Eüƒøÿ…‡ÿ<1Bƒøuÿu ÿuÿuèÿÿÿƒÄ…Àu·éûƒøPt	Pÿ\1Bë/9u „äÿujÿU YY…Àt.Vh€jVVSÿuÿ׉Eüƒøÿu%9u „µÿuh@3Bé ÿujÿU YYé™9u t
ÿujÿU YYEôPÿuÿuÿ@1B‹}üEôPPPWÿD1B9uu	WÿH1Bë\VÿuVjVWÿL1BW‹=H1B‹Øÿ׃ûÿu9u t8ÿuh(3Bë&VVVjSÿP1BS‰Eÿ׋E;Æu9u tÿuh3BjÿU ƒÄ3À_^[ÉÃU‹ìƒì8ƒ}S‹]VW…•j8EÈjPè,j‹E‰EÈ‹E@‰EÌ‹Ej8h”3B‰EØEÈjñ3öP‰]ÔFèÝF‹}ƒÄ…Àt…ÿt*Ph|3BëEÈjPè©HYY;Æt…ÿt
Phh3Bjÿ׃Ä3öEÈPè7[Y…Àt,…ÿt
PhP3Bjÿ׃Ä3öë3ö9uuÿuÿuSè!fƒÄFSÿ41B_‹Æ^[ÉÃU‹ìì@¡€áB3ʼnEü‹E‹M‰…èþÿÿ‹EW‹}‰ôþÿÿL8ê+A‹Q+ƒè‰…ÈþÿÿÂ9PK‰½Øþÿÿ‰Ôþÿÿt3À냥ðþÿÿ3ÒSVf;Q
|3À@^[‹Mü3Í_è¸jÉË…Äþÿÿ‹s*÷µÈþÿÿ;PK‰µäþÿÿ…Ï>PK…ÿSƒÀ.‰àþÿÿ¿K Ê¿SпFC*Ñ¿NÈ‹…ÈþÿÿÏD‹M‰…Àþÿÿ…øþÿÿ‰•Äþÿÿ+ÁŠˆA„Òuö…øþÿÿPŠ@„Éuù+ÂøþÿÿI€<\‰Ìþÿÿt"½øþÿÿOŠGG„Àuø¾œ3Bf¥‹µäþÿÿ‹½Øþÿÿ…øþÿÿPÿ,1Bƒ¥ìþÿÿ„øþÿÿ‰…Ðþÿÿ‹…èþÿÿëG‹‹ÁP‰•ÜþÿÿŠ@„Òuù+…ÜþÿÿPÿµàþÿÿQè¥þƒÄ…À‹…èþÿÿ„ûÿ…ìþÿÿ‹ìþÿÿȃ8u´¿FPÿµàþÿÿ…øþÿÿPè$hƒÄ…øþÿÿè6ûÿÿ…øþÿÿPŠ@„Éuù‹Ìþÿÿ+€<\tVÿµôþÿÿ·CP·CPÿs…øþÿÿÿµÐþÿÿPjèœûÿÿƒÄ…Àt(ÿµôþÿÿ¿NÿsÿsQÿµÀþÿÿPèÞüÿÿƒÄ…À„ƒ½ôþÿÿt$‹…ðþÿÿ@P‹…Ôþÿÿ¿@
PÿµÐþÿÿjÿ•ôþÿÿƒÄ‹…Ôþÿÿ¿@
ÿ…ðþÿÿ9…ðþÿÿŒØýÿÿéÁýÿÿ‹ìþÿÿ4È‹xŠ@„Éuù‹N+Ç‹ñŠA„Òuù+νøþÿÿ‹ÑOŠOG„Éuø‹ÊÁéó¥‹Êƒáó¤‹àþÿÿȉÜþÿÿ‹äþÿÿ¿I+È…øþÿÿpŠ@„Òuù‹•Ìþÿÿ+ÆŠ<\t‹ðj¿@9BY3Àó¦tÀƒØÿ…Àu%ÿuè%òÿÿYë¡ÈC…Àtÿuh,9BPè—fƒÄ‹Mü3À_3Í@^èðXÉÃU‹ìQQVW3öVh€jVjh€ÿuÿ81B‹øƒÿÿu3ÀëNSEøPWÿ°0BVVVjVW‹ØÿL1BW‹=H1B‰Eüÿ׃}üÿu3ÀëVVVjÿuüÿP1Bÿuü‹ðÿ׋E‰‹Æ[_^ÉÃU‹ìƒ=Ct@ƒ=ÐCu7Vÿuÿ|2B‹ð¡C‹P
jHQÐRjQVÿL0BVÿu£ÐCÿ€2B^]ÃU‹ìì¡€áB3ʼnEü‹E‰ôþÿÿLê+AV+AW‹}ƒè"43Ò‰‰9PK‰½ìþÿÿ…>{V4tR¿œ9BèáüÿÿYé;ÂŒø‹N;Êt
‹Ö+V+щC+F‹ôþÿÿ+F‹þ‰+~hèƒ^Y‰…ðþÿÿ…À„¸…øþÿÿPhÿp0B…À„Œÿµðþÿÿ…øþÿÿjh˜9BPÿl0B…Àtn3ÀPPPÿvPÿµðþÿÿjè¿éÿÿƒÄ‰…ôþÿÿ…Àt]ÿvWPèýh‹…ôþÿÿƒÄpŠ@„Éuù+ÆD8PèfŸY‹ìþÿÿÿµôþÿÿ‰‹…ðþÿÿ‰ÿ41B3À@ëÿ<1BP¿x9BèÜûÿÿY3À‹Mü_3Í^è±VÉÃU‹ìƒìV‹5p2BW3ÿëEäPÿt2BEäPÿx2BjWWWEäPÿÖ…ÀuÝ_^ÉÃU‹ìƒìP¡€áB3ʼnEüƒ}‹E‰E°tÿuÿuÿuPÿ`2BéÆSVWM¼QPÿd2Bj‰E¸ÿh2Bj
Y™÷ùhÐ9B3ÛSSSSSSSjh¼SSSPÿ40BPÿu¸ÿ80Bjÿu¸‰E´ÿ<0B¾àC‹ÆxŠ@:Ëuù+Ç‹=@0BPVjjÿu¸ÿ×hÿÿÿÿu¸ÿD0B‹ÆHŠ@:Óuù+ÁPVj
j
ÿu¸ÿ×ÿu´ÿu¸ÿ80BPÿH0BE¼Pÿu°ÿl2B_^3À[‹Mü3ÍèuUÉÂU‹ì¸0èi¡€áB3ʼnEü‹ESVW‹=t0B3öV‰…øïÿÿÇ…ÐïÿÿÇ…ÔïÿÿŸ'@‰µÜïÿÿ‰µØïÿÿÿ×hV‰…àïÿÿ‰µäïÿÿÿL2Bh€‰…èïÿÿÿP0B‰…ìïÿÿ…Ðïÿÿ»:BP‰µðïÿÿ‰ôïÿÿÿP2Bf…ÀuVh:Bhè9Bÿ5 Cÿ,2Bÿµøïÿÿ…üïÿÿhÜ9BPÿ$2BƒÄVVÿ׋=h2BPVVjÿ×Pjÿ×PVVV…üïÿÿPSVÿT2B‹ðjVÿX2BVÿ\2B‹Mü_‹Æ^3Í[èUTÉÃU‹ìƒì¡€áB3ʼnEüSVEìPWÿD2B‹5h2BjÿÖj‹ØÿÖ‹Uø‹È‹Eð+Ð+EøjR‹Uô+UìÁR™+ÂÑøP‹Eì+EôÙ+ÂÑøPWÿH2B‹Mü^3Í[èæSÉÃU‹ì¸èòg¡€áB3ʼnEüƒ}NS‹]„Ž}…¤Sè=ûÿÿ¡ÐCY…ÀtPjhrhSÿ82BVWSÿ<2B‹øè+ÿÿÿh`C…üïÿÿh(:BPÿ$2B‹5ˆ2BƒÄ…üïÿÿPhèSÿÖh ChýSÿÖh`ChSÿÖ_^ë#‹Ex8ÿÿÿujjhpSÿ<2BPÿ@2B‹Mü3Í3À[èSÉÂU‹ìì¡€áB3ʼnEü‹ESÿÿÿQh3ÛS‰…üþÿÿ‹Ehè:BP‰…ôþÿÿ‰ÿÿÿÿ0B…Àt3Àé~SSSS…ÿÿÿPE¬PSÿµÿÿÿÇ…ÿÿÿPÿ0B…À…AVW‹=„2B‹uÿ…ÿÿÿÇ…ÿÿÿP;ót48t0E¬Š:u:ËtŠN:HuƒÆƒÀ:Ëuä3ÀëÀƒØÿ;Ã…Ë5$2BE¬P…\ÿÿÿhÀ:BPÿÖE¬P…ÿÿÿh”:BPÿփąøþÿÿPhS…ÿÿÿPÿµôþÿÿÿ0B…ÀurhèÌX‹ðYÇ…ðþÿÿ;ótK…ðþÿÿPVSSSÿµøþÿÿÿ0B…Àu0…\ÿÿÿPSh€ÿµüþÿÿÿ׋ôþÿÿVPhšÿµüþÿÿ‰Žÿ×ÿµøþÿÿÿ0BSSSS…ÿÿÿPE¬Pÿµÿÿÿÿµÿÿÿÿ0B…À„Éþÿÿ_^ÿµÿÿÿÿ0B3À@‹Mü3Í[è"QÉÃU‹ìQVEüPjjhdàBh€ÿ0B‹ð…öu	ÿuüÿ0B3À…ö”À^ÉÃU‹ì¡àBV¾€;Æt?=€uè¬ÿÿÿ…Àu/‰5àBë'jh,;Bh;Bÿuÿ,2Bè†ÿÿÿ÷ØÀ÷ØÆ£àB^]ÃU‹ìƒ}~¸4àB]Ãuƒ}¸4àB}¸àB]ÃU‹ì¸è€d¡€áB3ʼnEü‹EƒèNS‹]VW‰ôîÿÿ„Z-‹=82Bt)H…†‹E¾þ‹Îf;Á…sÁèH„éd¡ÐC…ÀtPjhrhSÿ×»0CSh€¾þVÿµôîÿÿÿ42BPèÔüÿÿƒÄSh€Vÿµôîÿÿÿ42BPè¸üÿÿƒÄjjh‹Vÿµôîÿÿÿ׉…ðîÿÿ…ÀtƒøÿtjHPh†Vÿµôîÿÿÿ×€=0Ct.S…øîÿÿhè;BPÿ$2BƒÄ…øîÿÿPhèÿµôîÿÿÿˆ2Bƒ½ðîÿÿu@€=0CtS…øîÿÿh ;BPÿ$2BƒÄ…øîÿÿë¸l;Bjh\;BPÿµôîÿÿÿ,2B‹<2BjjhpÿµôîÿÿÿÓPÿ@2BjjhˆVÿµôîÿÿÿ׉…ðîÿÿƒøÿuSjjhpÿµôîÿÿÿÓPÿ@2B‹=ˆ2B¾5BVhïÿµôîÿÿÿ×Vhðÿµôîÿÿÿ× 5B¢ÀC¢àCéÈjjhpÿµôîÿÿÿÓPÿ@2Bjÿµðîÿÿh™Vÿµôîÿÿÿ׋ˆ‰
àB¹ÀC‹Ñ+Њˆ@„ÛuöQhïÿµôîÿÿÿˆ2BjÿµðîÿÿhŠVÿµôîÿÿÿ×@PèòT‹ØY…ÛtZSÿµðîÿÿh‰Vÿµôîÿÿÿ×hHCh(ChD;BSèxbƒÄƒøuÿ5HCÿ5(Ch4;BhàCÿ$2BƒÄSèTYë
 5B¢àCÿ5HCÿ5(CèãüÿÿƒÄ3ÉŠ‘ÀCˆ”
øþÿÿA„ÒuîøþÿÿqŠA„Òuù+΀¼
÷þÿÿ\t½øþÿÿOŠOG„Éuø¾œ3Bf¥‹@‹ÐŠ@„Éuù½øþÿÿ+ÂOŠOG„Éuø‹ÈÁé‹òó¥‹È…øþÿÿPhðÿµôîÿÿƒáó¤ÿˆ2Bë@‹Ex8ÿÿÿu43öVVhˆhþSÿ82BƒøÿujëjVhpSÿ<2BPÿ@2B‹Mü_^3Í3À[èšLÉÂU‹ìì(¡€áB3ʼnEü‹E‰…ìýÿÿ¡àBÇ…ðýÿÿø=B=€t
Ç…ðýÿÿä=BSVW‹=0B3ÛSäýÿÿQSjSSS¾HáBVPÿ×;Ãt5ƒøujShˆ=Bÿ(2BPÿ,2B3ÀéÚSht=BVÿ(2BPÿ,2B¾`CVÿµìýÿÿ…ôþÿÿh`=BPèÍt…ôþÿÿh\=BPè^t£ÈC…ØýÿÿPèŸN…ØýÿÿPèlN…ØýÿÿPè`NPh,=B…ôþÿÿhPè#s…ôþÿÿPÿ5ÈCèYhÀCh =Bÿ5ÈCèÿXƒÄHÿµðýÿÿh=Bÿ5ÈCèæXÿ5HC…ôýÿÿÿ5(CVh=BPètƒÄ …àýÿÿP…èýÿÿPShSSS…ôýÿÿPÿµäýÿÿÿ×…ÀtShèB…ôþÿÿhPènp…ôþÿÿPÿ5ÈCè_V¡ÈCƒÄ$…ÀtPèc^Y‹Mü3Íè­HÉÃU‹ìì ¡€áB3ʼnEüƒ}NV‹uW‰µðþÿÿ„Í}„u}…Öƒ=$C„¡€=@C„”ƒ¥èþÿÿS‹ˆ2Bhð>BhèVÇ…äþÿÿä>BÿÓ3ÀŠˆÀCˆŒøþÿÿ@„Éuî½øþÿÿOŠGG„Àuø¾Ø>B¥¥¸@Cf¥‹ÐŠ@„Éuù½øþÿÿ+ÂOŠOG„Éuø‹ÈÁé‹òó¥‹È¡ÈCƒáó¤…ÀtøþÿÿQhàChÀ>BPèDUƒÄhjÿL2B‹502BPÿÖ‰…ìþÿÿ…øþÿÿ‰…àþÿÿ…àþÿÿP…øþÿÿjP½ôþÿÿèéÿÿƒÄ…ÀtPh>Bè‚VƒÀ@PèãTƒÄƒ½ôþÿÿtÿµôþÿÿhìÿµðþÿÿÿÓh@>BhèÿµðþÿÿÿÓÿµôþÿÿè–MYÿµìþÿÿÿÖèÚýÿÿ[ëF¡ÐC3ÿ;ÇtPWhrhVÿ82B9=$CuèÐßÿÿPhìVÿˆ2BWWhVÿ@2B3À@ë%‹Ex8ÿÿÿujjhpVÿ<2BPÿ@2B3À‹Mü_3Í^è…FÉÂh”5Bÿ 1B…Àu3ÀÃh ?BPÿ$1B£öB…ÀtèÿàU‹ìƒìX¡€áB3ʼnEü€=0Cu3ÀëAh0CE¬h”:BPÿ$2BƒÄE¨PhjE¬Ph€ÿ0B…ÀuÇÿu¨ÿ0B3À@‹Mü3ÍèðEÉÃU‹ì옡€áB3ʼnEü…hÿÿÿPÇ…hÿÿÿ”ÿx0B…Àt3À@ƒ½lÿÿÿwu9…pÿÿÿs3À‹Mü3ÍèžEÉÃU‹ìì„¡€áB3ʼnEüjjh5BhÀCht?Bjÿ2Bƒø ,P…|ÿÿÿh8?BPÿ$2BƒÄjh0?B…|ÿÿÿPjÿ,2B‹Mü3Íè3EÉÃU‹ì‹E‹‹E‹Š:u„ÒtŠP:QuƒÀƒÁ„Òuä3À]ÃÀƒØÿ]ÃU‹ìì`¡€áB3ʼnEüSVWh…øþÿÿP3ÿWÿ”0B…øþÿÿP…ôýÿÿh´?BPè¥m…ôýÿÿh°?BPè6m‹Øh¤?BSè1R…øþÿÿP¾˜?BVSèR…øþÿÿPh|?BSèR…ôýÿÿPVSèþQƒÄ@SèZjD^V… ýÿÿWPèšBƒÄ3Àf‰…Ðýÿÿ…äýÿÿP… ýÿÿPhœ3BWVWWW…ôýÿÿPW‰µ ýÿÿÇ…Ìýÿÿÿ0B…ÀtO‹5Œ0BjñÿµèýÿÿÿÖjÿˆ0BPÿÖh€ÿ„0BPÿ€0Bÿµäýÿÿ‹5H1BÿÖÿµèýÿÿÿ|0BÿµèýÿÿÿÖ‹Mü_^3Í[è­CÉÃU‹ìQQSWÿuèŒj[P‰Eøè¬=‹ø3ÛƒÄ;û„˜VGj]Wè“=‹ðYY;ó„ˆFj
Vè|=YY;ÃtˆEüPhSWÿ5àBÿ0B…ÀtSht=Bÿuÿ(2BPÿ,2Bë2Vÿuüÿ0B;ÃtƒøtSh¼?Bÿuÿ(2BPÿ,2Bÿuüÿ0BÿuøèpIY^_[ÉÃU‹ìQQSWÿuèJ‹j[P‰Eøèç<‹ø3ÛƒÄ;û„˜VGj]WèÎ<‹ðYY;ó„ˆFj=Vè·<YY;ÃtpˆEüPhSWÿ5àBÿ0B…ÀtSht=Bÿuÿ(2BPÿ,2Bë2Vÿuüÿ0B;ÃtƒøtShÔ?Bÿuÿ(2BPÿ,2Bÿuüÿ0Bÿuøè«HY^_[ÉÃU‹ìVj:ÿuè.<‹ðYY…ötF¾PèoY…ÀuñVÿ1B^]ÃU‹ìVj:ÿuèÿ;‹ðYY…ötF¾PèPoY…ÀuñVÿ˜0B^]ÃU‹ìƒìj[ÿuèÎ;YY…ÀuÉÃV@j]Pè¼;‹ðYY…ö„²SÆF»€ñB‹Î‹ÃŠ:u„ÒtŠP:QuƒÀƒÁ„Òuä3ÀëÀƒØÿ…ÀtwƒeøƒeüWEðPjV}üÇEô,@B‰uðèîâÿÿƒÄ…Àth@BèVPƒÀ@Pè·NYY‹}ü…ÿt€?tjhì?BWÿ(2BPÿ,2BWè}GY‹Ó‹Æ+Ö_Šˆ@„Éuö3À@[^ÉÃU‹ì¸(èîT¡€áB3ʼnEü‹E3Ƀ}Sj
‰…Øïÿÿ‰ìïÿÿ‰ôïÿÿ‰àïÿÿ‰øïÿÿ[tQQhHBBQÿ,2B3À@é1V‹pWj¿DBBY3Òó¦t3ÀPPh0BBé)h,BBÿpèåh3öYY‰…ðïÿÿ;Æu
VVhBBVéj(è3GY‰…äïÿÿ;ÆuVéhÿµðïÿÿ…üïÿÿhPèñtƒÄ…À„¢½üïÿÿ…üïÿÿPŠ@„Éuù+‹ðëN¾D7ÿPèYmY…Àuï…üïÿÿPÆ„5üïÿÿè5ˆ‹•ìïÿÿÿ…ìïÿÿY‹äïÿÿ‰‘9ìïÿÿ|ƒÃ
‹ÃÁàPQèËsYY‰…äïÿÿ…À„Æÿµðïÿÿ…üïÿÿhPèQtƒÄ…À…fÿÿÿ3öÿµðïÿÿèUÇ$ä8@jÿµìïÿÿÿµäïÿÿèçpƒÄj$hBBhÀABVÿ,2Bƒø…ÄÇàB€Ç…Üïÿÿ5B‰µðïÿÿ9µìïÿÿŽj[‹…äïÿÿ‹ðïÿÿ‹4ˆ‹…Üïÿÿ‹ÎŠ:u*„ÒtŠP:QuÃË„Òuæ3Àëj¿¬ABèÏãÿÿYéVÀƒØÿ…À„–…üïÿÿP…èïÿÿPhœABV‰µÜïÿÿè5SƒÄ;ÃuMj¿ä=BµüïÿÿY3Àó¦uÇàB€éMè2íÿÿ…À…@jPh@ABÿ(2BPÿ,2B3À@éÖ…üïÿÿP…èïÿÿPh,ABVèÈRƒÄ;ÃuVèüÿÿY…À„‰ÿ…àïÿÿéé…üïÿÿP…èïÿÿPhABVèŽRƒÄ;ÃuVè¬ûÿÿY…ÀtSÿ…ôïÿÿé³…üïÿÿP…èïÿÿPhABVèXRƒÄ;ÃtÊ…üïÿÿP…èïÿÿPhì@BVè8RƒÄ;ÃuVèÌùÿÿëjÿ<1B;Ãtaƒøt\ÿ…øïÿÿëT…üïÿÿP…èïÿÿPhØ@BVèùQƒÄ;ÃuVèRúÿÿë+…üïÿÿP…èïÿÿPhÄ@BVèÑQƒÄ;ÃuÿµÜïÿÿèHûÿÿYÿ…ðïÿÿ‹…ìïÿÿ9…ðïÿÿŒþýÿÿ‹µØïÿÿÿvÿ1B…Àtÿ…ôïÿÿëÿ…øïÿÿÿ<1B‹~PèÞáÿÿYƒ½øïÿÿ…üïÿÿt#ÿµøïÿÿÿµàïÿÿÿµôïÿÿhp@BPÿ$2BƒÄëÿµàïÿÿÿµôïÿÿhH@BPÿ$2BƒÄj@h4@B…üïÿÿPjÿ,2Bè\÷ÿÿ3À_^‹Mü3Í[èJ<ÉÃU‹ììX¡€áB3ʼnEü‹ESV3ö‰…¬þÿÿ¡ŒöBW‰µ´þÿÿ3Éë‹@A;Æuø‹=82B·ÁÁàPVh»ëSÿ5¸Cÿ×VVhSÿ5¸Cÿ׉µ°þÿÿ‹5ŒöB…ö„¦‹E÷ØÀƒàƒÀc‰…¨þÿÿÿ6ÿ…°þÿÿ…¸þÿÿhhBBPÿ$2B…¸þÿÿPÿ•¬þÿÿƒÄ…Àtÿ…´þÿÿÿµ¨þÿÿ…¸þÿÿÿ6h`BBPÿ$2B…¸þÿÿPjè%áÿÿƒÄjÿµ°þÿÿhSÿ5¸Cÿ×ÿ6hìÿ5¸Cÿˆ2B‹v…ö…mÿÿÿ‹Mü‹…´þÿÿ_^3Í[è;ÉÃU‹ìƒìSV‹5$1Bh\8BWÿÖh˜8BW‹ØÿÖh,8BW‰EüÿÖh88BW‰EôÿÖh¨BBW‰EøÿÖh˜BBW‰EðÿÖ3ö95ŒöBu3ÀëJ;ÞtC9uüt>9uôt99uøt49uðt/;Æt+3É9uh@C•Á‰ÿUüÿÓÿuÿuøè3þÿÿƒÄ‹ðÿUô‹ÆëƒÈÿ^[ÉÃU‹ìQEüPh`5BÿuÿäCƒÄ…ÀuÉÃÿuüjèàÿÿh5Bÿ°CƒÄÉÃU‹ìQEüPh`5BÿuÿäCƒÄ…ÀuÉÃÿuüjèÏßÿÿh5Bÿ°CƒÄÉÃU‹ì¸èN¡€áB3ʼnEü‹EƒèNV‹uW‹}‰½øïÿÿ„¸-ÂtS-ñt+H…¨PÿuhhëWÿ82BVhìWÿˆ2BëVjhhëWÿ82BèÄâÿÿ3À@ée¡ÐC…ÀtPjhrhWÿ82Bh`C…üïÿÿhpCBPÿ$2B‹5ˆ2BƒÄ…üïÿÿPhèWÿÖh\CBhìWÿÖé‹vþ1ÿÿÿt(þ8ÿÿÿ…îjjhpWÿ<2BPÿ@2BéÒ‹5<2BS3ÛSShpW‰=¸CÇ$CÿÖPÿ@2BSShkWÿÖPÿ„2B»ÀC‹ÃpŠ@„Éuù+Æ€¸¿C\t{ÿŠGG„Àuø¾œ3Bf¥‹½øïÿÿ‹ÃPŠ@„Éuù+ÂWˆˆ¿CègçÿÿSèµëÿÿYY…À„8ÿ5HCÿ5(Cèšçÿÿ‹5ˆ2B‹ø¡üCƒÄ»è…Àt€8th‹ÂÁè3ÇÁâ3…HUBFÿMuæ÷Ò‹Â#Á‹òÁæÆ‹òÁî#ñÁà_ÆÁê^Â[ÉÃ3À…ÉtöÁt3ƒÂÑéuòÃU‹ìSVW‹}‹ðj +þ[‹7‹UèÐÿÿÿ‰ƒÆKuí_^[]ÃU‹ìì¡€áB3ʼnEüƒ}V‹ñ‹Æé¤3É3ÀAÇ…|ÿÿÿ ƒ¸í@‰Œ…|ÿÿÿÉ@ƒø |ñ…|ÿÿÿP…üþÿÿè„ÿÿÿ…üþÿÿP…|ÿÿÿèrÿÿÿYY…|ÿÿÿP…üþÿÿè^ÿÿÿöEYt‹Î•üþÿÿè5ÿÿÿ‹ðÑ}t-…üþÿÿP…|ÿÿÿè1ÿÿÿöEYt‹Î•|ÿÿÿèÿÿÿ‹ðÑ}u¦‹Æ3E‹Mü3Í^èÿ)ÉÃU‹ìÿu‹MÿuèÿÿÿYY]ÃU‹ìÿu‹MÿuèÿÿÿYY]ÃU‹ì‹U…Òu3À]Ãÿu‹Eè}ùÿÿY]ÃU‹ìƒì@‹E‹H‹PS‹KLû‰MÔ‹Ê+MV‹pW‹xOωMÄŒ:ÿþÿÿ‰MЋN(‰MÜ‹N,‰MÀ‹N0‰Mè‹N4‰MØ‹N8‰Mü‹N<‰M‹NL3Ò‰Mä‹NPB‰Mà‹NTÓâ‹NXJ‰UÌ3ÒBÓâJ‰UÈ‹Mƒùs¶SƒEÓâ‹MUüƒÃ¶ÓâUüƒE‹MÌ#Mü‹Uä‹Š‰Mð‹UðÁé¶ÉÓmü)M‰Mø¶Ê‰Mø„ÒtG‹MøöÁuJöÁ@…¬3ÒBÓâ‹MðÁéJ#UüÑ‹Mä‹‘‰Mð‹UðÁé¶ÉÓmü)M‰Mø¶Ê‰Mø…Éu¹GÁêˆéIÁêƒá‰Uô‰Møt*‹M;Møs
C¶ÓâUüƒE‹Mø3ÒBÓâJ#UüÓmüUô)M‹Mƒùs¶SƒEÓâ‹MUüƒÃ¶ÓâUüƒE‹MÈ#Mü‹Uà‹ŠëöÁ@…ì3ÒBÓâ·MòJ#UüÑ‹Mà‹‘‰Mð‹UðÁé¶ÉÓmü)M‰Mø¶ÊöÁtŃáÁê‰Uì‰Mø9Ms+‹MƒEC¶Óâ‹MøUü9Ms‹MC¶Óâ‹MøUüƒE3ÒBÓâ‹Mø)MJ#UüÓmüUì‹Uì‹Ï+MÄ;ц+щUø;UÀv
ƒ¾À…9‹MØI‰Mð‹Mè…Éu'‹MÜ+ÊMð‹Mø;Môƒ)Mô‹MðAŠGÿMøˆuõëS;ÊsY+ÊMÜMð‹Mø+Mè;Môsf‹Uð)Mô+׉Uðë‹UðGIŠ:ˆuô‹MØI‰Mð‹Mè;Môs>)Mô‰Mø‹MðAŠGÿMøˆuõ‹Ï+Mì‰Mðë#+ÊMð‹Mø;Môs)Mô‹MðAŠGÿMøˆuõëÖ‹Mð‹UôƒúvTBýj3ÒY÷ñ‹Mð@ŠQƒmôˆWŠQƒÁˆWŠƒÇHˆuã‹Eë$‹Ï+ÊŠQƒmôˆWŠQƒÁˆWŠƒÇƒ}ôˆwàƒ}ôtŠQGƒ}ôˆvŠIGˆ;]Ôs7;}Ђýÿÿë,Ç@|eBëÇ@deBëöÁ tÇë
Ç@HeBÇ‹MÁé+ÙÁá)M3ÉA‹Ñ‹MÓâK‰O‰H‹MÔ+˃Á‰H‹MÐJ‰U‹Uü#U+ÏÁ‰H‹E_‰V8‰F<^[ÉÃU‹ì‹M3Ò;Êt\‹A;ÂtUV3ö‰P‰Q‰Q‰QF‰q0ƒˆÄÿˆ0‰°À‰‰P‰PÇ@€‰P ‰P(‰P,‰P0‰P8‰P<‰Hl‰HP‰HL3À^]ÃjþX]ÃU‹ìS‹]VW…Ût`‹s…ötY‹}…ÿyƒe÷ßë‹ÇÁø@‰Eƒÿ0}ƒç…ÿt
ƒÿ|0ƒÿ+‹F4…Àt9~$t
Pÿs(ÿS$ƒf4YY‹ES‰F‰~$è)ÿÿÿYëjþX_^[]ÃU‹ì‹ES3ÛVW;Ãtw€81urƒ}8ul‹u;óujþëc‰^9^ u
ÇF âu@‰^(9^$uÇF$õu@hÌjÿv(ÿV ‹øƒÄ;ûujüë+ÿu‰~V‰_4èÿÿÿYY‰E;ÃtWÿv(ÿV$YY‰^‹EëjúX_^[]ÃU‹ìÿuÿujÿuè_ÿÿÿƒÄ]ÃU‹ì‹EV…ÀtC‹@…Àt<‹M…Éyƒ`8ƒ`<3Àë,ƒù$‹P<4
ƒþ wW3ÿGÓç‹Ê‰puÇ‹H‹8‹^8‰Mì‹H‹@‰}ü‹~<‰Mð‰Eø‰EÔ‰Mä‰UÜé{ÿ$…]m@‹F…Àu*Çébƒ}ø„¦‹Mü¶ÿMø‹ÏÓâÚÿEüƒÇƒÿrܨt:û‹u23ÿWWWèYøÿÿ‰FjEèPf‰]èÿvèDøÿÿƒÄ‰F3ÛÇé‹F ƒf…ÀtƒH0ÿöF„Œ¶ÃÁà‹ËÁéÁj3ÒY÷ñ…Òut‹Ã$<t‹EÇ@ÀoB鲋F$Áë‹ËƒáƒïƒÁ…Àu5‰N$3À3ÿ@ÓàWWW‰Fè¡îÿÿ‹MÁë÷ÓƒãƒË	‰F‰A0ƒÄ‰3Ûén;ÈvÊ‹EÇ@¬oBéU‹EÇ@”oBéFƒ}ø„‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿr܉^€û…Uÿÿÿ÷Ãàt‹EÇ@xoBéÿ‹F …Àt
‹ËÁéƒá‰÷Ftˆ]èjEèÁëPˆ]éÿvè÷ÿÿƒÄ‰F3Û3ÿÇëƒ}ø„‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿ rÜ‹F …Àt‰X÷Ft-‹ÃÁèˆEé‹ÃÁèˆEêˆ]èjEèÁëPˆ]ëÿvè•öÿÿƒÄ‰F3Û3ÿÇëƒ}ø„–‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿrÜ‹F …Àt‹Ëáÿ‰H‹N ‹ÃÁè‰A÷Ftˆ]èjEèÁëPˆ]éÿvè"öÿÿƒÄ‰F3Û3ÿÇ÷F……‹F …Àtƒ`Ç÷F„ð‹V@‹Eø‰Uô;Ðv‰Eôƒ}ô„Ì‹N …É„˜‹A‰EØ…À„Š‹A‹I+‹UôÐ;Ñvd+Èëcƒ}ø„²
‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿrÜ‹F ‰^@…Àt‰X÷Ftˆ]èjEèÁëPˆ]éÿvèNõÿÿƒÄ‰F3Û3ÿéEÿÿÿ‹MôQ‹MØÿuüÈQèÛƒÄ÷FtÿuôÿuüÿvèõÿÿƒÄ‰F‹Eô)EøEü)F@ƒ~@…
ƒf@Ç÷Ft{ƒ}ø„÷3É‹Eü¶A‰Mô‹N ‰Eà…Ét‹Q‰UØ…Òt‹V@;Q s	‹M؈ÿF@…Àt‹Mô;MørÄ÷Ftÿuôÿuüÿvè…ôÿÿ‰F‹EàƒÄ‹Mô)MøMü…À…ˆë‹F …Àtƒ`ƒf@Ç÷Ft{ƒ}ø„^3É‹Eü¶A‰Mô‹N ‰Eà…Ét‹Q$‰UØ…Òt‹V@;Q(s	‹M؈ÿF@…Àt‹Mô;MørÄ÷Ftÿuôÿuüÿvèìóÿÿ‰F‹EàƒÄ‹Mô)MøMü…À…ïë‹F …Àtƒ`$Ç÷FtAëƒ}ø„Ç‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿrÜ·F;Øt‹EÇ@doBéB3Û3ÿ‹F …Àt‹V3ÉAÁú	#щP,‹F ‰H03ÀPPPèPóÿÿ‹M‰FƒÄ‰A0é`ƒ}ø„R‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿ rÜ‹Ë‹Ó¸ÿ#ÈÁâÊ‹ÓÁêÁá#ÂÁ‹MÁëÉF‰A03Û3ÿÇ
ë‹Mƒ~„º
3ÀPPPè°éÿÿ‹M‰F‰A0ƒÄǃ}„Ï
ƒ}„Å
ƒ~t3‹ÏƒáÓë+ùÇé]
ƒ}ø„¡
‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿr܋Ãà‰FÑë‹ÃƒàƒètAHt HtHu>‹EÇ@PoBÇë,Çë$‹Æè øÿÿƒ}ÇuÁëƒïé2
Ç
ÁëƒïéÓ	‹ÏƒáÓë+ùëƒ}ø„
‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿ rÜ‹Ë‹Ã÷Ñ%ÿÿÁé;Át‹EÇ@0oBé}	3Û3ÿƒ}‰F@Ç„º	Ç‹F@‰Eô…À„ª‹Eø9Eôv‰Eô‹Eð9Eôv‰Eôƒ}ô„†	ÿuôÿuüÿuìè	‹Eô)EøEü)EðEìƒÄ)F@é	ƒ}ø„T	‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿr܋Ãà‰F`Áë‹Ãƒà@Áë‰Fd‹ÃƒàƒÀÁëƒï~`‰F\wƒ~dwƒfhÇëQ‹EÇ@oBéƒ}ø„Ù‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿrÜ‹Nh·M nB‹Ãƒàf‰DNpÿFhÁëƒï‹Fh;F\rÕë‹Fh·E nB3Éf‰LFpÿFhƒ~hrå†0Nl‰‰FL–ðRFTPQÇjFpPjè«
ƒÄ‰EÜ…Àt‹EÇ@ðnBéâƒfhÇéƒ}ø„‹Eü¶ÿMø‹ÏÓàØÿEüƒÇ‹NT3À@Óà‹NLH#Ë‹ÈÁé¶É‰Eà;ÏwÁ‹ÈÁéfƒùsK‹ÈÁé¶Éë"ƒ}ø„É‹Mü¶ÿMø‹ÏÓâ¶ÌÚÿEüƒÇ;ùrڶ̋FhÓë+ùf‹Mâf‰LFpÿFhéfƒ}âuW¶Äëƒ}ø„|‹Mü¶ÿMø‹ÏÓâÚÿEüƒÇH;ùrÚ‹È+ø‹FhÓë…À„Ö·DFn‰Eà‹ÃƒàƒÀÁëƒïé…fƒ}â¶ÔuZëƒ}ø„‹Eü¶ÿMø‹ÏÓàØÿEüƒÇB;ørÚ‹ÊÓëjý‹ÃƒàƒÀÁëë7ƒ}ø„å‹Eü¶ÿMø‹ÏÓàØÿEüƒÇB;ørÚ‹ÊÓëjù‹ÃƒàƒÀÁëƒeàY+Êù‹Vd‹NhV`È;Êw6…Àt‹Nhf‹Uàf‰TNpÿFhHuî‹FdF`9Fh‚sþÿÿë‹EÇ@ÔnBé‹EÇ@ÔnBǃ>„fƒ¾pu‹EÇ@¬nBéä†0Nl‰‰FL–ðRFTPQÿv`Ç	FpPjèfƒÄ‰EÜ…Àt‹EÇ@nBéNl‹‰FP–ðRFXPQÿvdÇ‹F`DFpPjè!ƒÄ‰EÜ…Àt‹EÇ@xnBéXƒ}Ç„œÇƒ}øri}ðr`‹E‹Mìÿuä‰H‹Mð‰H‹Mü‰‹Mø‰HP‰^8‰~<è]íÿÿƒ>‹E‹^8‹~}'‹Eä‹M;At‹Eä‹}è³íÿÿ…Àt
Çjüémÿÿÿ‹}‹EÔ+G‹]ä+_G_^ƒ~‰EÔt,…Ût(‹GS+Ã~PÿvtèWçÿÿëè2Þÿÿ‰F‰G0‹EÔƒÄ‹ƒùu	ÇE€ëƒeƒùt	ƒùt3É빋V÷ÚÒƒâ@ÑUV<‰W,…Àu…Ûtƒ}u
ƒ}ÜuÇEÜûÿÿÿ‹EÜéÂþÿÿ[@ä\@n]@Þ]@0^@N^@U_@î_@ƒ`@"a@]a@†a@ša@>b@¥b@«b@ c@¾c@Õe@Ãf@Éf@h@åh@	j@Uj@òj@k@Îk@Ol@Xl@ªl@U‹ìV‹u…öt0‹F…Àt)‹N$…Ét"‹@4…ÀtPÿv(ÿÑYYÿvÿv(ÿV$ƒfYY3ÀëjþX^]ÃU‹ìSVW‹}3À;øt‹w;ðt
‹]9Ft
ƒ>
t
jþX_^[]Ã>
uPPPèÒÜÿÿÿuSPèÈÜÿÿƒÄ;Ftjýë׋Gèãëÿÿ…Àt
ÇjüëÁ‹F(‹};øv+ØPßSÿv4èZ
‹F(‰F,ë‹N4W+ÏÈSQèC
‰~,ƒÄÇF3Àë‚U‹ì‹E…Àt‹@…Àtö@t‹M‰H ƒa03À]ÃjþX]ÃU‹ì‹3À9Ev?SWƒùs6‹UŠƒùÿçÿÿÿ¶ÚÇÿ;ßuAë„Òt3ÉëjZ+Ñ‹Ê@;ErÅ_[‰]ÃU‹ìS‹]3ÒVW;Ú„®‹{;ú„£9Su
ƒ<sjûé“jX9tG‰‹G<‹ÈƒáÓg8+Á‰G<ƒør‹O8‹ðŠG8ƒîˆDÁéB‰O8‰w<ƒþsçREwhƒ&Pè5ÿÿÿYYÿswhÿ3è&ÿÿÿ)CCƒ>‹CYY‰Etjýë‹sSèvèÿÿ‹E‰C‰sYÇ3ÀëjþX_^[]ÃU‹ì‹E…Àt‹@…Àtƒ8
uƒx<u3À@]Ã3À]ÃjþX]ÃU‹ìQQSVW3ÿ9}„‹u;÷„‹^;ß„ù‹F ;Ç„î9~$„åhÌjÿv(ÿЃÄ‰Eü;Çujüéʉ}ø9{4t(‹K$3À@ÓàjPÿv(ÿV ƒÄ‰Eø;Çu
ÿuüÿv(ÿV$YYëÉ‹}jYhÌó¥‹uüSVè%‹CL“0ƒÄ¹0;Âr/“¼;Âw%+Ã+ÁÁø„†0‰FL‹CP+Ã+ÁÁø„†0‰FP‹Cl‹}ø+Ã+ÁÁø„†0‰Fl…ÿt‹K$3À@ÓàPÿs4Wè´ƒÄ‹E‰~4‰p3ÀëjþX_^[ÉÃU‹ì‹E…Àt‹@…ÀtÇ€ÀjýëjþX]ÃU‹ì‹E…Àt2‹@…Àt+‹ƒùu‹H@ëƒùu‹ˆÈ+H@ë3É‹€ÄÁàÁ]øÿÿ]ÃU‹ì쌡€áB3ʼnEü‹E‹U‰E€‹ES‰E´3ÀV‹u·ØW‹ÃÁãjÃY}Üó«3ɉ•tÿÿÿ9Mv‹E€·HDEÜfÿA;Mrì‹j[3ÿ‰E¨‰]”Gfƒ|]ÜuK‰]”;ßsð;Ãv‰]¨…Ûu‹ÇE¸@‹E¸‰ƒ‹‰ƒ‰:éS‹Ç‰E¬;ßvfƒ|EÜu@‰E¬;Ãrð9E¨s‰E¨‹×‹Ï·DMÜÒ+Ј…Aƒùvë…Ò~
ƒ}tu;ßuq3Àjf‰E¾Yf‹D
¼fD
܃Áf‰D
¼ƒùré‹}´3Ò9Uv(‹E€Pfƒ8t··LM¼f‰O·LM¼fÿB;UrØ‹MƒétAItƒMÿÇEˆpBÇE„ÐpBë7ƒÈÿ锹ºpB+щUˆºPpB+щU„ÇEë
‰}„‰}ˆÇE‹M¨‹E¬ƒMŒÿ‹>3ÒBÓâ3Ûƒ}‰]œJÿ‰…|ÿÿÿ‰]°‰U˜‰U¤‰xÿÿÿuúTsƒ}uúPr3À@é‹M´‰M ŠÈ*M°ˆM¹‹M ·‹Ê;M}
ÆE¸f‰Uºë&~‹M ·	‹U„ÉŠˆU¸‹Uˆf‹ëÆE¸`3Éf‰Mº3Ò‹È+M°BÓâ‹M˜‰M´‰M¬‹M°Óë]´Ÿ)U´‹ÚÁã+˃}´‹]¸‰uë3ÒHÿBÓâ‹MœëÑê…Ñuú…Òt	Zÿ#ÙÚë3ÛƒE ¹ÿÿfLE܉]œu;E”„ß‹E ·‹M€·A‰…|ÿÿÿ‹U¨;†,ÿÿÿ‹xÿÿÿ#ˉM´;MŒ„ÿÿÿƒ}°u‰U°‹M¬<‹È‹E°3Ò+ÈBÁÓâ;E”s)‰E¬DEÜë‹E˜·+Ó…Ò~ƒÀAÿE¬‰E˜‹E¬Ò;E”rà3À@‹ÐÓâU¤‰U˜9Eu
}¤Tƒ»ƒ}u
}¤Pƒ¨‹E´‹‹]œˆ‚‹ŠU¨ˆT‹‹×+ÑÁú‰EŒf‰T‹…|ÿÿÿékþÿÿŠÈ*M°ÆE¸@ˆM¹3Éf‰MºëKƒ}°t‹xÿÿÿ#Ë;MŒt‹E¨ƒe°‹>ˆE¹‹M°‹ÓÓê‹M¸‰—3ÒHÿBÓâëÑê…Óuú…Òt	Jÿ#ÙÚë3Û…Ûu±‹E¤‹M¨Áà‹…tÿÿÿ‰3À‹Mü_^3Í[èSÉø”3BÃjUXÃU‹ì‹EÁ๘qB+È‹]ÃU‹ì‹E¯EPè Y]ÃU‹ìÿuè™Y]ÃÌÿ%,0Bÿ%(0Bÿ%\1Bÿ%X1Bÿ%T1Bÿ%P1Bÿ%L1Bÿ%H1Bÿ%D1Bÿ%@1Bÿ%<1Bÿ%81Bÿ%41Bÿ%,1Bÿ%(1Bÿ%$1Bÿ% 1Bÿ%1Bÿ%1Bÿ%1Bÿ%°0Bÿ%X0Bÿ%\0Bÿ%`0Bÿ%d0Bÿ%h0Bÿ%l0Bÿ%p0Bÿ%t0Bÿ%x0Bÿ%|0Bÿ%€0Bÿ%„0Bÿ%ˆ0Bÿ%Œ0Bÿ%0Bÿ%”0Bÿ%˜0Bÿ%œ0Bÿ% 0Bÿ%¤0Bÿ%,2Bÿ%(2Bÿ%$2Bÿ%ˆ2Bÿ%„2Bÿ%€2Bÿ%|2Bÿ%x2Bÿ%t2Bÿ%p2Bÿ%l2Bÿ%h2Bÿ%d2Bÿ%`2Bÿ%\2Bÿ%X2Bÿ%T2Bÿ%P2Bÿ%L2Bÿ%H2Bÿ%D2Bÿ%@2Bÿ%<2Bÿ%82Bÿ%42Bÿ%02Bÿ%L0Bÿ%H0Bÿ%D0Bÿ%@0Bÿ%<0Bÿ%80Bÿ%40Bÿ%P0Bÿ% 0Bÿ%0Bÿ%0Bÿ%0Bÿ%0Bÿ%0Bÿ%0Bÿ%0Bÿ%0Bÿ%2Bÿ%˜2Bÿ%2Bÿ%”2BÌÌÌÌÌÌÌÌÌÌÌÌBÿ[ä$d$3ÀŠD$S‹ØÁà‹T$÷ÂtŠ
ƒÂ:ËtÏ„ÉtQ÷ÂuëØW‹ÃÁãVØ‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂáu%tÓ%uæ€uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[ÃÌÌU‹ìWV‹u‹M‹}‹Á‹ÑÆ;þv;ø‚ ù€rƒ=ìCtWVƒçƒæ;þ^_uéA÷ÇuÁéƒâƒùr)ó¥ÿ$•`z@‹ÇºƒérƒàÈÿ$…ty@ÿ$pz@ÿ$ôy@„y@°y@Ôy@#ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•`z@I#ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•`z@#ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•`z@IWz@Dz@W‹ùƒúr1÷Ùƒát+шƒÇƒéuö‹ÈÁàÁ‹ÈÁàÁ‹ÊƒâÁétó«…Òt
ˆƒÇƒêuö‹D$_ËD$ÃÌÌÌÌÌÌ‹L$W…É„·‹|$V÷ÇStŠƒÇ„Àt9÷Çuÿþþ~Ѓðÿ3ƒÇ©tè‹Gü„Àt!„ät©ÿt©ÿuσïë
ƒïëƒïëƒï‹t$÷Æu	‹ÙÁéu\ë"ŠƒÆ„Òt=ˆƒÇƒét)÷Æuå‹ÙÁéu8‹ËƒátŠƒÆˆƒÇ„Òtƒéuíˆ[^‹D$_È‹D$[^_ɃǃétȺÿþþ~‹Ѓðÿ3‹ƒÆ©tÜ„Òt΄öt*÷Âÿt÷Âÿuĉ‹D$[^_Ãf‰3Ò‹D$ˆW[^_Ãf‰‹D$[^_Ã;
€áBuóÃéè=‹ÿU‹ìƒ}tÿuÿuÿuÿuÿuè;@]ËÿU‹ìƒìV‹uW3ÿ‰}ø‰}ô‰}ü;÷uè|Lj^‰0èz@‹ÆëTSj$hÿVèÞýÿÿ‹]ƒÄ;ßuèQLj^‰0èO@ë(‹C‹;Ç|;Ïrƒø|ùÿo@“vè"Lj^‰0‹Æ[_^ÉÃèvGEøPè•JY…À…ßEôPè°JY…À…ÍEüPèËJY…À…»‹K‹;…É|jÿ€ôv`‹Eü™+øEìPÊV‰}ì‰MðèÝGYY…Àu9Eø„;Vè‡GY…À„,‹Eô™)EìEìPUðVè«GYY…À…YÿÿÿÇF éSVèŽGYY…À…<ÿÿÿ9Eøt,Vè8GY…Àt!‹EüEôÇF ™‹È‹‰U™‹ø‹Ú+ù]ë‹™‹ø‹Eü‹Ú™+øÚjj‹Yƒøÿtƒøþt‹ÐÁú‹ÈƒáÁá•àCë¹àîBöA$u)ƒøÿtƒøþt‹ÈÁùƒàÁààCë¸àîBö@$€tè‚>Çè2ƒMäÿ9]äu#Wèý|‹ðEPSÿuWè²~‰EäWVè}ƒÄÇEüþÿÿÿè	‹EäèªpÃÿuèÖYËÿU‹ìEPÿuÿuÿu訋ƒÄ]ËÿU‹ìEPÿuÿuÿu謋ƒÄ]ËÿU‹ìEPjÿuÿuè‘‹ƒÄ]ËÿU‹ìEPÿuÿuÿuè•‹ƒÄ]ËÿU‹ìEPjÿuÿuèz‹ƒÄ]øˆáBá -CVj^…Àu¸ë;Æ}‹Æ£ -CjPèpkYY£C…ÀujV‰5 -CèWkYY£C…ÀujX^Ã3Ò¹ˆáBë¡C‰ƒÁ ƒÂùäB|êjþ^3Ò¹˜áBW‹ÂÁø‹…àC‹úƒçÁ狃øÿt;Æt…Àu‰1ƒÁ BùøáB|Î_3À^Ã诀=ÀöBtè(‹ÿ5Cè„öÿÿYËÿU‹ìV‹u¸ˆáB;ðr"þèãBw‹Î+ÈÁùƒÁQènN€Yë
ƒÆ Vÿ˜1B^]ËÿU‹ì‹Eƒø}ƒÀPècn‹EH€Y]ËEƒÀ Pÿ˜1B]ËÿU‹ì‹E¹ˆáB;Ár=èãBw`ÿÿÿ+ÁÁøƒÀPè)mY]ÃÀ Pÿœ1B]ËÿU‹ì‹M‹Eƒù}`ÿÿÿƒÁQèúlY]ÃÀ Pÿœ1B]ÃÌÌÌÌÌÌÌÌÌÌÌQL$+ȃáÁÉÁYéQL$+ȃáÁÉÁYé‹ÿU‹ìƒì SW3Ûj3ÀY}ä‰]àó«9]uè“;Çè/ƒÈÿëu‹MV‹u;Ët;óuèo;Çèl/ƒÈÿëP¸ÿÿÿ‰Eä;Èw‰MäEPSÿuEàPÇEìB‰uè‰uàèŒ{ƒÄ‹ø;ótÿMäx‹EàˆëEàPSèå‹YY‹Ç^_[ÉËÿU‹ìEPÿuÿuÿuÿuèkƒÄ]ÃÌÌÌÌÌÌÌÌÌ‹L$W…É„’VS‹Ù‹t$÷Æ‹|$uÁé……ë'ŠƒÆˆƒÇƒét+„Àt/÷Æuå‹ÙÁéuaƒãtŠƒÆˆƒÇ„Àt7ƒëuí‹D$[^_Ã÷ÇtˆƒÇƒé„˜÷Çuê‹ÙÁéutˆƒÇƒëuö[^‹D$_ɃǃétŸºÿþþ~‹Ѓðÿ3‹ƒÆ©tÜ„Òt,„öt÷Âÿt÷Âÿuĉëâÿÿ‰ëâÿ‰ë3Ò‰ƒÇ3Àƒét3À‰ƒÇƒéuöƒã…wÿÿÿ‹D$[^_ÃÌÌÌÌÌÌÌÌÌÌÌÌU‹ìW‹}3ÀƒÉÿò®ƒÁ÷ÙƒïŠEýò®ƒÇ8t3Àë‹Çü_ÉËÿU‹ìƒì ƒeàWj3ÀY}äó«9Euèd9Çèa-ƒÈÿëx‹MV‹u…Ét…öuè@9Çè=-ƒÈÿëS¸ÿÿÿ‰Eä;Èw‰MäÿuEàÿuÇEìBÿu‰uèP‰uàè\yƒÄ‹ø…ötÿMäx‹EàÆë
EàPj賉YY‹Ç^_ÉËÿU‹ìÿujÿuÿuÿuè<ÿÿÿƒÄ]ÃÌÌÌÌÌÌÌÌÌÌQL$+ÈÀ÷Ð#È‹Ä%ðÿÿ;Èr
‹ÁY”‹‰$Ã-…ëé‹ÿU‹ìƒì ƒeàWjY3À}äó«_…öuèf8Çèc,ƒÈÿÉÃ9EtæVè9gY¹ÿÿÿÇEìI‰uè‰uà‰Mä;Áw‰EäÿuEàÿuÿuPÿUƒÄÉËÿU‹ìV‹uEPjÿuhôAèvÿÿÿƒÄ^]ËÿU‹ìV‹uEPÿuÿuhôAèSÿÿÿƒÄ^]ËÿU‹ìV‹uEPjÿuhÂ.Aè1ÿÿÿƒÄ^]ËÿU‹ìV‹uEPÿuÿuhÂ.AèÿÿÿƒÄ^]ËÿU‹ìV‹uWƒÏÿ…öuèy7Çèv+ÇëDöFƒt8VèJ†V‹øè¹­V貃Pè鬃Ä…ÀyƒÏÿë‹F…ÀtPèèðÿÿƒfYƒf‹Ç_^]Ãjhð¿BèDiƒMäÿ3À‹u…ö•À…Àuèÿ6Çèü*ƒÈÿë
öF@t
ƒf‹EäèPiÃVèúÿÿYƒeüVè<ÿÿÿY‰EäÇEüþÿÿÿèëÔ‹uVèXúÿÿYËÿU‹ìƒìSVW‹}…ÿtƒ}t‹u…öuèŠ6Çè‡*3À_^[ÉËM…ÉtâƒÈÿ3Ò÷÷9EwÖ¯}÷F‰Mü‰}ô‹ßt‹F‰EøëÇEø…ÿ„¿‹Nát/‹F…Àt(ˆ¯‹û;Ør‹øWÿuüÿ6èäÿÿ)~>ƒÄ+ß}üëO;]ørO…ÉtVèÜ„Y…Àu}ƒ}ø‹ût	3Ò‹Ã÷uø+úWÿuüVè2‚YPèZ³ƒÄƒøÿta‹Ï;Çw‹ÈMü+Ù;ÇrP‹}ôë)‹Eü¾VPèp†YYƒøÿt)ÿEü‹FK‰Eø…ÀÇEø…Û…Aÿÿÿ‹EéõþÿÿƒN ‹Ç+Ã3Ò÷uéãþÿÿƒN ‹EôëëjhÀBèyg3ö9ut!9ut3À9u•À;Æuè.5Çè+)3ÀègÃÿuèHøÿÿY‰uüÿuÿuÿuÿuèPþÿÿƒÄ‰EäÇEüþÿÿÿè‹EäëÆÿuè‡øÿÿYËÿU‹ì‹E…Àt‹M‰ƒÀ]ËÿU‹ì‹E…Àtƒè8ÝÝuPèaîÿÿY]ËÿU‹ìƒìSVWÿuMè3Ûèòêÿÿ‹E苸ԉ]ü‹uüÿt·èecÿ4·‰EøèZcÃÿEüƒ}üYY‹Mø\rÕCPèb‹ðY‰uø…ötdƒeü‹EüÆ:ÿ4‡‹EøF+ÆDPVèCaƒÄ…ÀuTVècð‹EüÆ:ÿt‡‹EøF+ÆDPVèaƒÄ…Àu*VèÞbðÿEüƒ}üYr£Æ€}ô_^[t‹Eðƒ`pý‹EøÉÃ3ÀPPPPPè\'ÌjèÿÿÿYËÿU‹ìƒìSVWÿuMä3Ûèêÿÿ‹E䋸Ôw8‰uøÇEüÿv0ènbÿ6‰Eôèdb‹uøYY‹MôÃÆÿMü\‰uøuÕCPè
a‹ðY‰uø…ötbƒeüƒÇh‹EøÆ:ÿwÐF+ÆDPVèH`ƒÄ…ÀuRVè
bð‹EøÆ:ÿ7F+ÆDPVè#`ƒÄ…Àu-VèèaðÿEüƒÇƒ}üYr¨Æ€}ð_^[t‹Eìƒ`pý‹EøÉÃ3ÀPPPPPèc&Ìjè	ÿÿÿYËÿU‹ìƒì$SVWÿuMÜ3ÿèéÿÿ‹EÜ‹°Ô‰}ü‹]üÿtžè{aÿ4ž‰EìèpaÇÿEüƒ}üYY‹Mì|rÕF8‰EðÇEì‹]ðÿs0èDaÿ3‰Eôè:aƒEðYY‹MôÇÿMì|u×ÿ¶œèaÿ¶˜‹Øèaÿ¶ Ç|èý`ÿ¶¤|èî`ÿ¶¨|èß`„eP‰Eøè—_‹ØƒÄ…Û„íhdVS»dèÐßÿÿƒeüF‰]ðƒÄ)uð‰Eô‹Eü‰<ƒ‹Eôÿpä‹Ã+ÇEøPWè±^ƒÄ…ÀuTWèv`‹Mð|‹Eô‰<ÿ0‹Ã+ÇEøPWè‡^ƒÄ…Àu*WèL`ÿEüƒEôƒ}üY|rƒeüCh‰EìF8‰Eôë3ÀPPPPPèÊ$‹Eô‹Mð‰<ÿ0‹Ã+ÇEøPWè1^ƒÄ…ÀuÔWèö_|‹Eì‰8‹Eôÿp0‹Ã+ÇEøPWè^ƒÄ…ÀuªWèÌ_ÿEüƒEôƒEìƒ}üY|rš‹Ã+ÇEø‰»˜ÿ¶˜PWèÊ]ƒÄ…À…iÿÿÿWè‹_|‹Ã+ÇEø‰»œÿ¶œPWè›]ƒÄ…À…:ÿÿÿWè\_|‹Ã+ÇEø‰» ÿ¶ PWèl]ƒÄ…À…ÿÿÿWè-_|‹Ã+ÇEø‰»¤ÿ¶¤PWè=]ƒÄ…À…ÜþÿÿWèþ^D‹Ë+ÈMø‰ƒ¨ÿ¶¨QPè]ƒÄ…À…­þÿÿ€}èt‹Eäƒ`pý_^‹Ã[ÉÃjèýÿÿYÃ8V‹òtWŠ„Òt‹9ˆÿFÿƒ8uì_^Ã>‹Svj
™[÷û€Â0ˆAÿ‹…À~ƒúw狉IŠŠˆIˆ@;Árò[ËÿU‹ìQSV‹ò3Ò‰Uü9Ut5ƒ9‹7vj
™[÷û€Â0ˆFÿ	‹…À~ƒúw狉7NŠŠˆNˆ@;Æròë.;1s(NV…Òtj
™[÷û‹€Â0ÿEüˆNƒþÿué‹Eü)ë‰^[ÉËÿU‹ìQS¾ÀV‹uW‹Ù‹úƒøY±„{ƒøIÀ„ƒè„vƒè	„mƒètjƒètEHt"ƒè…t‹F…ÀˆYƒøPéÊ‹v…öˆ@ƒþ7‹U‹T²hé‹v…öˆ ƒþ‹U‹T²éõ‹Æ%ÿÿéð‹v…öˆòƒþé‹Æ™jY÷ù‹Â…ÀuQX‹ËéQƒèM„–jY+ÁtwHHt,HHtH…Ãéi‹F…Àˆ£;Á›…ÀtHÿë‹F…Àˆ‡;Á‹È‹F…Àˆr=mg;Á}3Àë†j™^÷þ;ÑŒxÿÿÿ@érÿÿÿ‹…ÀˆAƒø;8éZÿÿÿ‹F…Àˆ(ƒø;éÊþÿÿ‹F=”øÿÿŒ=£™jdY÷ùÿu‹ËjƒÀkÀdÂëtƒøm„ƒèZ„%ƒè„ÃH„¤HtUHt*ƒè…É‹v…öˆ®þm¢ÿuFjë‹vƒþŒŒƒþƒ‹ÆÿujZè>ýÿÿYécƒ}ÿuSWVt#u@FPÿuôEàÿuMüPŠUèÜöÿÿƒÄ…ÀtBF9]üw9]üv‹Eˆ+}ü‹Ç8]ìtT‹MèƒapýëK‰Mø‹Eðˆ9]øu 9]üwè”%Ç"ë9]üvßÇEøëÖèy%Çèv8]ìt‹Eèƒ`pý3À^_[ÉËÿU‹ìÿujÿuÿuÿuÿuèYþÿÿƒÄ]ËÿU‹ìjjÿuÿuÿuÿuè:þÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuÿuèþÿÿƒÄ]Ãjh0ÀBèW3Û‰]ä3À‹};û•À;ÃuèØ$ÇèÕ3Àëy3À‹u;ó•À;ÃtÞ3À8•À;ÃtÓèž©‰E;Ãu
èŸ$Çëʉ]ü8u è‹$ÇjþEðPh€áB裪ƒÄë£PÿuVWèÁ¦ƒÄ‰EäÇEüþÿÿÿè	‹Eäè¾VÃÿuèêçÿÿYËÿU‹ìj@ÿuÿuè2ÿÿÿƒÄ]ËÿU‹ìV‹u…öuè$j^‰0è‹Æë$h€ÿuÿuèýþÿÿƒÄ‰…Àt3Àëèç#‹^]ËÿU‹ìƒì SW3Ûj3ÀY}ä‰]àó«9]uè¿#Ç較ÈÿëM‹E;ÃtäV‰Eè‰EàEPSÿuEàPÇEäÿÿÿÇEìBèÜcƒÄÿMä‹ðx‹EàˆëEàPSè9tYY‹Æ^_[ÉËÿU‹ìEPÿuÿuÿuèǪƒÄ]ËÿU‹ìEPjÿuÿuÿuè2­ƒÄ]ËÿU‹ìEPÿuÿuÿuÿuè­ƒÄ]ËÿU‹ìEPjÿuÿuÿuÿu膭ƒÄ]ËÿU‹ìEPÿuÿuÿuÿuÿuèd­ƒÄ]ËÿU‹ìEPjÿuÿuÿuè{®ƒÄ]ËÿU‹ìEPÿuÿuÿuÿuè\®ƒÄ]ËÿU‹ìEPÿuèîªYY]ËÿU‹ìEPÿuè«YY]ËÿU‹ìEPÿuÿuèݪƒÄ]ËÿU‹ìEPÿuÿuèýªƒÄ]ËÿU‹ìƒìÿuMðèyØÿÿ‹Eðƒ¸¬~EðPhÿuèÅ5ƒÄ닀ȋM·H%€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·A%]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðèó×ÿÿ‹Eðƒ¸¬~EðPjÿuèB5ƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèt×ÿÿ‹Eðƒ¸¬~EðPjÿuèÃ4ƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèõÖÿÿ‹Eðƒ¸¬~EðPjÿuèD4ƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèvÖÿÿ‹Eðƒ¸¬~EðPh€ÿuèÂ3ƒÄ닀ȋM·H%€€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·A%€]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðèðÕÿÿ‹Eðƒ¸¬~EðPjÿuè?3ƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèqÕÿÿ‹Eðƒ¸¬~EðPjÿuèÀ2ƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèòÔÿÿ‹Eðƒ¸¬~EðPhÿuè>2ƒÄ닀ȋM·H%€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·A%]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðèlÔÿÿ‹Eðƒ¸¬~EðPhWÿuè¸1ƒÄ닀ȋM·H%W€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·A%W]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðèæÓÿÿ‹Eðƒ¸¬~EðPhÿuè21ƒÄ닀ȋM·H%€}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·A%]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðè`Óÿÿ‹Eðƒ¸¬~EðPj ÿuè¯0ƒÄ닀ȋM·Hƒà €}üt‹MøƒapýÉËÿU‹ìƒ=äúBu‹E‹
˜íB·Aƒà ]Ãjÿuè…ÿÿÿYY]ËÿU‹ì}€À÷Ø]ËÿU‹ì‹Eƒà]ËÿU‹ìÿuÿuè9úÿÿYY…Àuƒ}_t]Ã3À@]ËÿU‹ìÿuèoúÿÿY…Àuƒ}_t]Ã3À@]ËÿU‹ìÿuÿuè~ýÿÿYY…Àuƒ}_t]Ã3À@]ËÿU‹ì¶EPè²ýÿÿY…Àu€}_t]Ã3À@]ÃÌÌÌÌÌÌÌÌÌÌ‹ÿV‹ò;Èt…öt+ÈSŠŠˆˆ@Nuò[^ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìQ‹UW‹ø;úvl‹M
S‰EüVëI‹uü‹Ú;÷w"¤$SVÿUƒÄ…À~‹Þu;÷vë‹M‹U‹ñ‹Ç;ßt!…Ét‹Ë+ÏëIŠŠˆˆ@Nuò‹M‹U+ù;úw¦^[_‹å]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ììV‹uW‹}…ÿu…ötèÇèÿ_^‹å]ÃS‹]…Ûtƒ}uèÞÇèÛ[_^‹å]ÃþrôN¯ó÷ÇEô‰}ü‰uø‹ÿ‹Æ+Ç3Ò÷ó@ƒøw‹EPSW‹ÆèåþÿÿƒÄéÎÑè¯ØßSWÿUƒÄ…À~,‹U‹Ã;ût#‹Ï+ËJ‰Uð¶ˆU¶ˆ¶Uˆ‹Uð@…ÒuáVWÿUƒÄ…À~,‹M‹Æ;þt#+þ¤$¶ˆU¶ˆ¶Uˆ@Iué‹}üVSÿUƒÄ…À~*‹M‹Æ;Þt!‹û+þ¶ˆU¶ˆ¶Uˆ@Iué‹}üI;ßv};ûsSWÿUƒÄ…À~í;ßwëI};}øwSWÿUƒÄ…À~ì+u;óvSVÿUƒÄ…Àí;þw2‹U‹Æt#‹Ï+ÎJ‰Uð¶ˆU¶ˆ¶Uˆ‹Uð@…Òuá;Þu‡‹ßëƒu;Þs+u;óvSVÿUƒÄ…Àtí;ÞrëI+u‹Eü;ðvSVÿUƒÄ…Àtê‹Eü‹Uø‹Ê‹Þ+Ï+Ø;Ù|+;Æs‹Mô‰„xÿÿÿ‰´ÿÿÿA‰Mô;ús9‹uø‹]‰}üé=þÿÿ;ús‹Mô‰¼xÿÿÿ‰”ÿÿÿA‰Mô;Æs‹}ü‹]‰uøéþÿÿ‹]‹EôH‰Eôˆáýÿÿ‹”…xÿÿÿ‹„…ÿÿÿ‰Uü‰Eø‹ð‹úéåýÿÿ‹ÿU‹ìƒ}uÿuè´ÒÿÿY]ÃV‹u…öu
ÿuè(ÒÿÿY3ÀëMWë0…öuFVÿujÿ5èúBÿ¨1B‹ø…ÿu^9Ct@Vèî>Y…ÀtƒþàvËVèÞ>Yè(Ç3À_^]Ãè‹ðÿ<1BPèÇY‰ëâèÿ‹ðÿ<1BPè¯Y‰‹ÇëÊjhPÀBèJ‹]‹û‰]ä3É;Ùu9MtèÆÇèÃ3Àéñ3À9MÀ;ÁtÝ3À‹u;ñ•À;ÁtÏ9MtÚ‰uVèÁÚÿÿYƒeüöF@uoVèÝcYƒøÿtƒøþt‹ÐÁú‹ÈƒáÁá•àCë¹àîBöA$u)ƒøÿtƒøþt‹ÈÁùƒàÁààCë¸àîBö@$€tè!Çèƒeäƒ}ät:ÿMt2ÿNx
‹¶A‰ëVèî¢Y‰Eàƒøÿu
;ûuƒeäë
ˆG‰}Ü<
uÉÆÇEüþÿÿÿè‹Eäè1IËuVè\ÚÿÿYËÿU‹ìQƒeüS‹]…Ûu3ÀéšVƒûrusü…ötn‹M‹EŠƒÀƒÁ„ÒtR:QüuMŠPý„Òt<:Qýu7ŠPþ„Òt&:Qþu!ŠPÿ„Òt:QÿuƒEü9uürÂë.¶@ÿ¶IÿëF¶@þ¶Iþë<¶@ý¶Iýë2¶@ü¶Iüë(‹M‹E‹uüë
Š„Òt:u
@FA;órï3À^[Éö¶	+Áëò‹ÿU‹ìh8Bÿ¬1B…Àth(BPÿ$1B…ÀtÿuÿÐ]ËÿU‹ìÿuèÈÿÿÿYÿuÿ°1BÌjè—GYÃjèFYËÿVè6$‹ðVèá;Vè·VèÒªVè!¨Vè(£V裃Ä^ËÿU‹ìV‹ðë‹…ÀtÿЃÆ;urð^]ËÿU‹ìV‹u3Àë…Àu‹…ÉtÿуÆ;urì^]ËÿU‹ì‹M…ÉuèÇè	jX]á¼öB…Àtâ‰3À]ËÿU‹ì‹M…ÉuèèÇèåjX]á¸öB…Àtâ‰3À]ËÿU‹ìƒ=CthCèO¬Y…Àt
ÿuÿCY胫hÀ2Bh¨2BèAÿÿÿYY…ÀuTVWh¢aAèÿª¸ 2B¾¤2BY‹ø;Æs‹…ÀtÿЃÇ;þrñƒ=C_^thCèå«Y…ÀtjjjÿC3À]Ãj hpÀBèTFjèFYƒeü3À@9ÈöB„Ø£ÄöBŠE¢ÀöBƒ}… ÿ5C‹5´1Bÿ֋؉]Ð…Ûthÿ5üCÿÖ‹ø‰}Ô‰]܉}؃ï‰}Ô;ûrKè\"9tí;ûr>ÿ7ÿÖ‹ØèI"‰ÿÓÿ5CÿÖ‹Øÿ5üCÿÖ9]Üu9EØt‰]܉]ЉEØ‹ø‰}Ô‹]Ðë«ÇEäÄ2B}äÔ2Bs‹Eä‹…ÀtÿЃEäëæÇEàØ2B}àÜ2Bs‹Eà‹…ÀtÿЃEàëæÇEüþÿÿÿè ƒ}u)ÇÈöBjèDYÿuè@ýÿÿƒ}tjèøCYÃèfEËÿU‹ìjjÿuè¯þÿÿƒÄ]ËÿU‹ìjjÿuè™þÿÿƒÄ]Ãjjjè‰þÿÿƒÄÃjjjèzþÿÿƒÄËÿU‹ìè¹8ÿuè7Yhÿè¯ÿÿÿÌ‹ÿU‹ìƒ=ÔöBuè’8ÿuèÛ6hÿèžüÿÿYY]øMZf9@t3Àá<@¸@PEuì¹f9ˆ@uÞƒ¸t@vÕ3É9ˆè@•Á‹ÁÃjXhÀBè-uÇEÈFVè,¨YiÀ‰EäŠ<+t<0|<9Fëï3Û‹uÄjèð9YÀ>:u8FVè÷§YkÀ<Eäë<9FŠ<0}õ€>:uFVèקYEäë<9FŠ<0}õ9]Èt÷]侉EÜ;ÃtjVj@ÿw訃ąÀt
éþÿÿ‹Gˆ‹uäè-‰0‹uÜè‰0èÝ:ËÿU‹ìƒìƒeüƒ}SVW‹}‹ð‹Ç…û%€yHƒÈü@‰Eôu‹Çjd™[÷û…Òu‡l™»÷û…Òt
‹ÆÁà‹°ïBë‹ÆÁà‹°\ïB‰E‡+™_ÿ¿÷ÿjd_Fj‰Eø‹Ã™÷ÿ‹Uø‹}[+ЉUøGÿ™ƒâÂÁøÆEø‹×iÒm„%œÿÿ™÷û‹EkÀ+ÂE;Utùëðƒ}…€ƒ}ôu‹Çjd™[÷û…Òu‡l™»÷û…Òt‹E‹€”ïBë	‹E‹€`ïB;ð~Dƒîë?%€yHƒÈü@u‹Çjd™[÷û…Òu‡l™»÷û…Òt	‹4µïBë‹4µ\ïBukÉ<M kÉ<M$iÉèM(ƒ}u‰5äB‰
äB‰=äB_^[ÉÃEüP‰5$äB‰
(äBè‚Y…ÀuD‹EüiÀè(äBy(äB\&ÿ
$äBë¸\&9(äB|)(äBÿ$äB‰= äBë3ÀPPPPPèúÿÿÌ‹ÿU‹ìƒìVEü3öP‰uüèèY…À…¬9uü„X‹WS3ÛC;äBu; äB„95¬úB„¸·¦úB·
 úBP·¤úBP·¢úBPf95˜úBu·œúBVP·žúBPRSë·žúBPVVRV·šúBSècýÿÿ·RúB·
LúBƒÄ$P·PúBP·NúBPf95DúBu·HúBVP·JúBPÿwSë·JúBPVVÿwV·FúBVèýÿÿƒÄ$ëTjXjYÇEô‰]øƒúk}jX‹ËÇEô
ÇEøVVVVVQRSSjYèÈüÿÿ‹EôVVVVVÿuøÿwSVjYè°üÿÿƒÄH‹
äB¡$äB‹W;È};Ñ|";Ð;Ñ~;Ð}‹Ã[^ÉÃ;Ð|ö;Ñò;Ð~;Ñ}3Àëè‹GkÀ<GkÀ<iÀè;Ñu
3É;äBÁë3É;(äBœÁ‹Áë´VVVVVè8øÿÿÌjhÐÀBè½63ö95´úBu*jèm6Y‰uü95´úBuèñøÿÿÿ´úBÇEüþÿÿÿèèÉ6ÃjèL5YÃjhðÀBèn6jè(6Yƒeüè³øÿÿÇEüþÿÿÿèè‘6Ãjè5YÃjhÁBè66jèð5Yƒeü‹}è‚ýÿÿ‰EäÇEüþÿÿÿè	‹EäèP6ÃjèÓ4YËÿU‹ìƒìƒeüV‹u…öuèºj^‰0è¸÷ÿÿ‹Æéj$hÿVèµÿÿ‹EƒÄ…ÀtÓ‹‹@‰Mð‰Eôƒøÿ|ù@Wÿÿsèsj^‰0뼃ø|
íùÏ&A“wåSWjh€3áPQè+HF+™»÷ûyÿjd‰}ø‰M‹Ø‹Ç™_÷ÿjÿh“þÿÿ+Ø‹Eø™ƒâÂÁøDøAº‹Ú™RPèþ«+ÇÓj»€QSRPèë«‹}ðøUôƒ}ôM|…ÿsG‹EøÇ€3áƒUô‹ÈဉEyIƒÉüAu
jd™Y÷ù…Òu‹El™¹÷ù…ÒuAûƒUôë2‹E‹Èá€yIƒÉüAu
jd™Y÷ù…Òu‹El™¹÷ù…ÒuÇEü‹EjSÿuô‰FWè%jÿ‰F™h€®þÿRPè3«øUôƒ}üº`ïBuº”ïB‹F3ÉA9B}
‹ØA9Š|ú»€QI‰N+Šj‰F‹ESÿpÿ0èÌjƒÀY™÷ù3ÛShÿuôW‰Vè¯jÿ‰F™hðñÿÿRP轪SøUôj<ÿuôW茉FkÀ<+ø‰>_‰^ 3À[^ÉËÿU‹ìVè‹ð…ötÿuVè­ýÿÿ÷ØÀY÷ÐY#Æ^]ËÿU‹ì‹E…ÀuèbÇè_õÿÿjX]Ë
4äB‰3À]ËÿU‹ì‹E…Àuè5Çè2õÿÿjX]Ë
8äB‰3À]ËÿU‹ì‹E…ÀuèÇèõÿÿjX]Ë
0äB‰3À]ËÿU‹ìS‹]V…Ût4ƒ}v4…ÛtÆW‹}…ÿt‹E…Àt1ƒøt,è¸j^‰0è¶ôÿÿ‹ÆëKƒ}tÌèŸj^‰0èôÿÿ‹Æë34…ÀäBÿ6èq/@Y‰…Ûu3Àë;Evj"Xëÿ6ÿuSè~-ƒÄ_^[]ø4äBø8äBø0äBøÀäBËÿU‹ì‹E3É;ÍÈäBtAƒù-rñHíƒùwj
X]ËÍÌäB]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãè…Àu¸0æBÃÀÃèý…Àu¸4æBÃÀËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ËÿU‹ìèÂ…ÀujX]ÃèŸÿÿÿ‹M‰3À]ËÿU‹ìV‹u…öu
èŒóÿÿjXëèzÿÿÿ‹‰3À^]ËÿU‹ìè|…ÀujX]Ãèlÿÿÿ‹M‰3À]ËÿU‹ìV‹u…öu
èFóÿÿjXëèGÿÿÿ‹‰3À^]ÃÌÌÌÌÌÌÌÌÌWVS3ÿ‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$Àu‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ÓëA‹Ø‹L$‹T$‹D$ÑëÑÙÑêÑØÛuô÷ñ‹ð÷d$‹È‹D$÷æÑr;T$wr;D$vN3Ò‹ÆOu÷Ú÷؃Ú[^_ÂÌÌÌÌÌÌSW3ÿ‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$‹D$À}‹T$÷Ø÷ڃ؉D$‰T$Àu‹L$‹D$3Ò÷ñ‹D$÷ñ‹Â3ÒOyNëS‹Ø‹L$‹T$‹D$ÑëÑÙÑêÑØÛuô÷ñ‹È÷d$‘÷d$Ñr;T$wr;D$v+D$T$+D$T$Oy÷Ú÷؃Ú_[‹ÿU‹ìQƒeüV‹u…öuè©ýÿÿj^‰0è§ñÿÿ‹ÆéSj$hÿVè¯ÿÿ‹]ƒÄ…Ûuè{ýÿÿj^‰0èyñÿÿë‹ù@Wÿÿ}è`ýÿÿj^‰0‹ÆéЋÁ™W¿€†÷ÿ‹ÐiÒ€àyøÊ…F¸€3á;È|+ÈB;È|+ȸ…âB;È|B+ÈëÇEü‹Á‰V™¿€Q÷ÿ¿`ïB‰FiÀ€®þÿȃ}üu¿”ïB‹F3ÒB9G}‹ØB9—|ú‹]J‰V+—¿€Q‰F‹™÷ÿj_j<ƒf ƒÀ™÷ÿ‹Á¿‰V™÷ÿ_‰FiÀðñÿÿÈ‹Á™÷ÿ_‰FkÀ<+ȉ3À[^ÉËÿVè‹ð…öuèmüÿÿÇ3À^Ã~Duj$è*Y‰FD…ÀtÜ‹FD^ËÿU‹ìVè¾ÿÿÿ‹ð…ötÿuVèoþÿÿ÷ØÀY÷ÐY#Æ^]ÃSV‹D$Àu‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ÓëA‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$vN3Ò‹Æ^[Â-¤t"ƒètƒè
tHt3ÀøøøøËÿVW‹ðh3ÿFWPèò¬ÿÿ3À·È‹Á‰~‰~‰~ÁáÁ~«««¹@æBƒÄF+οŠˆ@Ou÷†¾Šˆ@Nu÷_^ËÿU‹ìì¡€áB3ʼnEüSW…èúÿÿPÿvÿä1B¿…À„ü3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt0ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj Rè/¬ÿÿƒÄŠCƒÃ„ÀuÖjÿv…üúÿÿÿvPW…üþÿÿPjjèè¦3ÛSÿv…üýÿÿWPW…üþÿÿPWÿvS蛥ƒÄDSÿv…üüÿÿWPW…üþÿÿPhÿvSèv¥ƒÄ$3À·ŒEüúÿÿöÁt€LŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒëˆœ@;Çr¿ëR†Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ÐZ ƒûw
€LQ ë
ƒúw€L QàˆëÆA;ÏrÆ‹Mü_3Í[è̬ÿÿÉÃjh0ÁBè¹+è
‹ø¡`ëB…Gptƒlt‹wh…öuj è¾æÿÿY‹ÆèÑ+Ãj
èE+Yƒeü‹wh‰uä;5hêBt6…ötVÿì1B…Àuþ@æBtVèݲÿÿY¡hêB‰Gh‹5hêB‰uäVÿè1BÇEüþÿÿÿè뎋uäj
èó)YËÿU‹ìƒìS3ÛSMðèB¯ÿÿ‰¸úBƒþþuǸúBÿô1B8]ütE‹Møƒapýë<ƒþýuǸúBÿð1BëÛƒþüu‹Eð‹@ǸúBëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€áB3ʼnEüS‹]V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãèºüÿÿ3À顉uä3À9¸pêB„‘ÿEäƒÀ0=ðrçÿèý„tÿéý„h·ÇPÿø1B…À„VEèPWÿä1B…À„7hCVPèR©ÿÿ3ÒBƒÄ‰{‰s9Uè†ü€}î„ÓuɄƶFÿ¶Éé©hCVPè©ÿÿ‹MäƒÄkÉ0‰uà±€êB‰uäë+ŠF„Àt)¶>¶Àë‹EàŠ€lêBD;¶FG;øvê‹}ƒÆ€>uЋuäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇCèiûÿÿj‰CC‰têBZf‹1f‰0ƒÁƒÀJuñ‹óè×ûÿÿé´þÿÿ€L@;ÁvöƒÆ€~ÿ…0ÿÿÿC¹þ€@Iuù‹Cèûÿÿ‰C‰Së‰s3À·È‹ÁÁáÁ{«««ë§95¸úB…TþÿÿƒÈÿ‹Mü_^3Í[èéÿÿÉËÿU‹ìƒìjMðè߬ÿÿ‹Eôƒxt€}ü‹@t‹MøƒapýÉÀ}üt‹Eøƒ`pý3ÀÉÃjhPÁBèr(ƒMàÿèÉ‹ø‰}Üèšüÿÿ‹_h‹uè3ýÿÿ‰E;C„Wh èÆ#Y‹Ø…Û„F¹ˆ‹wh‹ûó¥ƒ#SÿuèvýÿÿYY‰Eà…À…ü‹uÜÿvhÿì1B…Àu‹Fh=@æBtPèw¯ÿÿY‰^hS‹=è1Bÿ×öFp…êö`ëB…Ýj
è„'Yƒeü‹C£ÈúB‹C£ÌúB‹C£ÐúB3À‰Eäƒø}f‹LCf‰E¼úB@ëè3À‰Eä=}
ŠLˆˆ`èB@ëé3À‰Eä=}ŠŒˆˆhéB@ëæÿ5hêBÿì1B…Àu¡hêB=@æBtPè¾®ÿÿY‰hêBSÿ×ÇEüþÿÿÿèë0j
èæ%YÃë%ƒøÿu û@æBtS舮ÿÿYèËôÿÿÇëƒeà‹Eàè*'Ã=CujýèVþÿÿYÇC3ÀËÿU‹ìSV‹5è1BW‹}WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{ødëBt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒSV‹5ì1BWÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{ødëBt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ^[‹Ç_]ËÿU‹ìSV‹u‹†¼3ÛW;Ãto=ØïBth‹†°;Ãt^9uZ‹†¸;Ãt9uPèç¬ÿÿÿ¶¼èu®YY‹†´;Ãt9uPèƬÿÿÿ¶¼èË«YYÿ¶°è®¬ÿÿÿ¶¼è£¬ÿÿYY‹†À;ÃtD9u@‹†Ä-þP肬ÿÿ‹†Ì¿€+ÇPèo¬ÿÿ‹†Ð+ÇPèa¬ÿÿÿ¶ÀèV¬ÿÿƒÄ‹†Ô=hëBt9˜´uPè$§ÿ¶Ôè-¬ÿÿYY~PÇEødëBt‹;Ãt9uPè¬ÿÿY9_üt‹G;Ãt9uPèñ«ÿÿYƒÇÿMuÇVèâ«ÿÿY_^[]ËÿU‹ìW‹}…ÿt;‹E…Àt4V‹0;÷t(W‰8èjýÿÿY…ötVèîýÿÿƒ>YuþÐìBtVèsþÿÿY‹Ç^ë3À_]ÃjhpÁBèú#èU‹ð¡`ëB…Fpt"ƒ~ltè>‹pl…öuj èúÞÿÿY‹Æè
$Ãjè#Yƒeüÿ5¨íBƒÆlVèYÿÿÿYY‰EäÇEüþÿÿÿèë¾jèb"Y‹uäÃjÿØ1BÃÿü1B‹ÿU‹ìÿuÿ5¸íBÿ2BÿÐ]¡´íBËÿVÿ5¸íBÿ2B‹ð…öuÿ5ØúBÿ´1B‹ðVÿ5¸íBÿ2B‹Æ^ËÿU‹ìÿuÿuÿ5ÜúBÿ´1BÿÐ]¡´íBƒøÿtPÿ5àúBÿ´1BÿЃ
´íBÿ¡¸íBƒøÿtPÿ2Bƒ
¸íBÿéF!jhÁBèÁ"hì Bÿ¬1B‹uÇF\­Bƒf3ÿG‰~‰~pƆÈCƆKCÇFh@æBj
èD"Yƒeüÿvhÿè1BÇEüþÿÿÿè>jè#"Y‰}ü‹E‰Fl…Àu¡¨íB‰Flÿvlè~ûÿÿYÇEüþÿÿÿèèw"Ã3ÿG‹uj
èô YÃjèë YËÿVWÿ<1Bÿ5´íB‹øè§þÿÿÿЋð…öuNhj軋ðYY…öt:Vÿ5´íBÿ5ÜúBÿ´1BÿÐ…ÀtjVèøþÿÿYYÿ2BƒNÿ‰ë	Vè8©ÿÿY3öWÿ\1B_‹Æ^ËÿVèÿÿÿ‹ð…öujèµÜÿÿY‹Æ^Ãjh¸ÁBèz!‹u…ö„ø‹F$…ÀtPèë¨ÿÿY‹F,…ÀtPèݨÿÿY‹F4…ÀtPèϨÿÿY‹F<…ÀtPèÁ¨ÿÿY‹F@…ÀtP賨ÿÿY‹FD…ÀtP襨ÿÿY‹FH…ÀtPè—¨ÿÿY‹F\=­BtP膨ÿÿYj
è¶ Yƒeü‹~h…ÿtWÿì1B…Àuÿ@æBtWèY¨ÿÿYÇEüþÿÿÿèWjè} YÇEü‹~l…ÿt#WèpúÿÿY;=¨íBtÿÐìBtƒ?uWèíúÿÿYÇEüþÿÿÿèVè¨ÿÿYè· Â‹uj
è5YËujè)YËÿU‹ìƒ=´íBÿtKƒ}u'Vÿ5¸íB‹52BÿÖ…Àtÿ5´íBÿ5¸íBÿÖÿЉE^jÿ5´íBÿ5ÜúBÿ´1BÿÐÿuèxþÿÿ¡¸íBƒøÿt	jPÿ2B]Ãÿ%2Bÿ%ˆ0B‹ÿWhì Bÿ¬1B‹ø…ÿu	èºüÿÿ3À_ÃV‹5$1Bh(¡BWÿÖh¡BW£ÔúBÿÖh¡BW£ØúBÿÖh¡BW£ÜúBÿÖƒ=ÔúB‹52B£àúBtƒ=ØúBt
ƒ=ÜúBt…Àu$¡2B£ØúB¡2BÇÔúBŒÙ@‰5ÜúB£àúBÿü1B£¸íBƒøÿ„Áÿ5ØúBPÿÖ…À„°èG×ÿÿÿ5ÔúB‹5Ø1BÿÖÿ5ØúB£ÔúBÿÖÿ5ÜúB£ØúBÿÖÿ5àúB£ÜúBÿÖ£àúBè…Àtc‹=´1BhŠÛ@ÿ5ÔúBÿ×ÿУ´íBƒøÿtDhjèq‹ðYY…öt0Vÿ5´íBÿ5ÜúBÿ×ÿÐ…ÀtjVè²ûÿÿYYÿ2BƒNÿ‰3À@ëè]ûÿÿ3À^_ËÿU‹ìƒìSÿuMè胢ÿÿ‹]C=w‹E苀ȷXëu‰]Á}EèP‹E%ÿPèkYY…ÀtŠEjˆEøˆ]ùÆEúYë
3Ɉ]øÆEùA‹EèjÿpÿpEüPQEøPEèjPè˜ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E€}ôt‹Mðƒapý[ÉËÿU‹ìƒ=äúBu‹E‹
˜íB·A#E]ÃjÿuÿuèÿÿÿƒÄ]áäCøèCËÿV‹ñ…öt…Àt;ÆtWj6Y‹øó¥ƒ Pè„öÿÿY_^ËÿU‹ìVè›ûÿÿ‹HpjZöÁ”Âr‹Uƒúÿt0…Òt3ƒútƒútèãêÿÿÇèàÞÿÿƒÈÿëƒáýëƒÉ‰Hpëƒ
`ëBÿ‹Æ^]á¨íB‹ˆ¼‰
(ðB‹ˆÈ‰
,ðB‹€¬£4ðBÃjhàÁB賋u…ö„j
èbYƒeü‹F…ÀtPÿì1B…Àu‹F=@æBtPè¤ÿÿYÇEüþÿÿÿè[ƒ>tCuS€~uMhT¢BÿuÿµdÿÿÿèXƒÄ…Àu'…ÿtf‰f‰Gf‰G‹…`ÿÿÿ…Àtƒ ‹…dÿÿÿéC3ÀPPPPPèžØÿÿVè꿃Y‰…Pÿÿÿ;Çs,Vÿµhÿÿÿè…YY…À„£VÿµXÿÿÿè…YY…À„ƒ¥Lÿÿÿ…lÿÿÿVPèàûÿÿYY…À…Õ…lÿÿÿPSPè%«ƒÄ…À„¼·C‹Tÿÿÿ‰…lÿÿÿPWÿµhÿÿÿè½üÿÿƒÄ€>t
‹…Pÿÿÿ;Çr‹…Lÿÿÿ¾5B@PVWÿµXÿÿÿèŃƒÄ…À…%ÿÿÿ3ö9µ\ÿÿÿtjSÿµ\ÿÿÿè)’ÿÿƒÄ9µ`ÿÿÿtjÿµTÿÿÿÿµ`ÿÿÿè’ÿÿƒÄÿµhÿÿÿÿuÿµdÿÿÿèƒÄ…Àu‹…hÿÿÿëVVVVVéÆþÿÿ3À‹Mü_^3Í[èñ–ÿÿÉËÿU‹ììÈ¡€áB3ʼnEü‹ES‹ÙW‰pþÿÿ‰…hþÿÿèôÿÿ‹øS…\þÿÿP…PþÿÿPhƒ…xÿÿÿPÿµhþÿÿèŠýÿÿƒÄ…Àu3À‹Mü_3Í[è…–ÿÿÉÃÁãÞÿsH…xÿÿÿPèzƒYY…Àu‹CHëÓ…xÿÿÿPèƒÀP‰…tþÿÿèÌYY‰…lþÿÿ…Àtª‹CH‹pþÿÿ‰…hþÿÿDŽ‰…Xþÿÿ‹‰…HþÿÿAkÀÆjP‰…dþÿÿ…8þÿÿPèÚÿÿ‹FxÿÿÿQ‹tþÿÿ‰…Lþÿÿ‹…lþÿÿƒÁüƒÀQP迃ąÀ…	‹…lþÿÿ‹XþÿÿƒÀ‰CH·…Pþÿÿ‰j…PþÿÿPÿµdþÿÿèwÿÿƒÄƒ½pþÿÿ…‹…\þÿÿƒ¥tþÿÿ‰F‹‡ô‹ð‰…dþÿÿ‡Ð‹V;t6‹ÿ…tþÿÿ‰‹dþÿÿ‰•@þÿÿ‹P‰H‹@þÿÿƒÀƒ½tþÿÿ‰•dþÿÿ|Åë-‹…tþÿÿ…Àt#„ÇЋ‰—ЋP‰—Ô‰‹dþÿÿ‰Hƒ½tþÿÿurjÿv…xþÿÿÿvPjhÀ¡BjjèŽƒÄ …Àt<3À¹ÿf!ŒExþÿÿ@ƒøríhþÿ5¼íB…xþÿÿP迃Ä÷ØÀ@‰‡Ô냧ԋF‰‡Ð‹‡Ô‰†¨ƒ½pþÿÿu	‹…\þÿÿ‰F‹…pþÿÿkÀVÿ€¡BY…Àt1‹…hþÿÿÿµlþÿÿ‰CH輚ÿÿ‹…HþÿÿY‹Xþÿÿ‰‹…Lþÿÿ‰Féˆýÿÿ½hþÿÿdëBt.‹½pþÿÿƒÇÿÿ4þÿì1B…Àuÿ4þèsšÿÿÿsTèkšÿÿƒcLYY‹pþÿÿ‹…lþÿÿƒÁÉljÎéYýÿÿ3ÀPPPPPèÔÿÿÌ‹ÿU‹ì옡€áB3ʼnEü‹ESV3Û‹òW‰µhÿÿÿ;Ët;ÃtPè“üÿÿYéÔÉ‹DÎHéÉÇ…pÿÿÿ‰tÿÿÿ;Ĭ€8L…0€xC…&€x_…‹øhX¢BWèúÒ‹ØYY…Û„ÿ+lj…pÿÿÿ„ñ€;;„èÇ…lÿÿÿ¾„¡Bë‹…pÿÿÿPWÿ6èÉÿÿƒÄ…Àuÿ6è™Y9…pÿÿÿtÿ…lÿÿÿƒÆþ´¡B~ÉChL¢BSè ‹ø3öYY;þu	€;;…ƒ½lÿÿÿDWS…xÿÿÿhƒPèÝ~ƒÄ…ÀuT‹lÿÿÿ‹µhÿÿÿˆ„=xÿÿÿ…xÿÿÿPètûÿÿY…Àtÿ…tÿÿÿû€?t
G€?…
ÿÿÿ3À9…tÿÿÿ„‘‹µhÿÿÿéVVVVVèÒÿÿ3ÀëxSSShƒxÿÿÿQPèûøÿÿƒÄ;Ãt\~H…Ût5ÿ7…xÿÿÿPèú~YY…Àt…xÿÿÿP‹ËèìúÿÿY…Àu!…pÿÿÿëÿ…tÿÿÿCƒÇƒû~¾3À9…pÿÿÿu9…tÿÿÿtè3÷ÿÿ‹Mü_^3Í[蛑ÿÿÉËÿU‹ìƒ}VWw$ƒ}t3ÿGWjèC‹ðYY…öuè;ÞÿÿÇ3À_^]ÃWhØèYY‰…Àu	VèÍ—ÿÿYëÓWh èYY‰F…Àuÿ6诗ÿÿVè©—ÿÿYëÙ‹¹ÐìBè¥òÿÿÿu‹M‹èTýÿÿY…Àuÿ6èÁéÿÿÿ6èSêÿÿVèt—ÿÿƒÄë2ÿv‹ÿpè4åÿÿYY…Àt#ÿvèT—ÿÿÿ6èéÿÿÿ6èêÿÿVè@—ÿÿƒÄ3öë
‹F‰8‹F‰8‹Æé>ÿÿÿ‹ÿU‹ì]éÿÿÿjh0ÂB舃eàƒ}vèKÝÿÿÇèHÑÿÿ3Àé9èÂíÿÿ‹ð‰uäèRëÿÿƒNpƒeü3ÿGWhØèYY‹Ø‰]Ü…Û„öjèíY‰}ü‹Nl‹Ãè²ñÿÿƒeüè³ÿu‹M‹ÓèXüÿÿY‰Eà…À„±ƒ}thdëBÿuèù|YY…Àt‰=äúBjè—YÇEü~lSWèqêÿÿSè‡èÿÿƒÄöFpu?ö`ëBu6ÿ7h¨íBèMêÿÿYY¡¨íB‹ˆ¼‰
(ðB‹ˆÈ‰
,ðB‹€¬£4ðBƒeüèë.‹]Ü‹uä3ÿGjè+
YËuäjè
YÃëSèèÿÿSè¡èÿÿYYÇEüþÿÿÿè‹EàènËuäƒfpïÃjhjÿ2B3É…À•Á£èúB‹ÁÃÿ5èúBÿ2Bƒ%èúBáèúBËÿU‹ì3À‹M;ÅàªBt
@ƒørî3À]ËÅäªB]ËÿU‹ììü¡€áB3ʼnEüSV‹uWVè¹ÿÿÿ‹ø3ÛY‰½þÿÿ;û„ljè¨ÑYƒø„jè—ÑY…Àu
ƒ=äB„îþü„6h¬Bh¿ðúBWèуÄ…À…¸h¾"ûBVSf£*ýBÿ¤0B»û…Àuhì«BSVèÉЃÄ…Àt3ÀPPPPPèfÎÿÿVèÑ@YƒøÿÿÿƒÄ]ËÿVW3ö¿(Cƒ<õÄíBuõÀíB‰8h ÿ0ƒÇÿ`1B…ÀtFƒþ$|Ó3À@_^Ã$õÀíB3Àëñ‹ÿS‹1BV¾ÀíBW‹>…ÿtƒ~t
WÿÓWèëˆÿÿƒ&YƒÆþàîB|ܾÀíB_‹…Àt	ƒ~uPÿÓƒÆþàîB|æ^[ËÿU‹ì‹Eÿ4ÅÀíBÿœ1B]Ãÿt$jÿ1Bhÿè¹ÿÿYÃjhhÂBèõ3ÿG‰}ä3Û9èúBuèÍôÿÿjèóÿÿhÿèÚ¸ÿÿYY‹u4õÀíB9t‹Çëmjè<üÿÿY‹ø;ûuèzÎÿÿÇ3ÀëPj
èXY‰]ü9u+h Wÿ`1B…ÀuWèˆÿÿYèEÎÿÿÇ‰]äë‰>ëWèç‡ÿÿYÇEüþÿÿÿè	‹EäèŽÃj
èÿÿÿYËÿU‹ì‹EV4ÅÀíBƒ>uPè#ÿÿÿY…ÀujèB»ÿÿYÿ6ÿ˜1B^]ÃÌÌÌÌÌÌÌÌÌÌÌÌh ý@dÿ5‹D$‰l$l$+àSVW¡€áB1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌ‹ƒøþt
‹OÎ30è‘€ÿÿ‹O‹GÎ30é€ÿÿÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹]V‹s35€áBW‹ÆEÿÇEô{ƒøþt
‹NÏ38è<€ÿÿ‹N‹FÏ38è,€ÿÿ‹Eö@f…‹MUè‰Sü‹[‰Eè‰Mìƒûþt_I[‹L†D†‰Eð‹‰Eø…Ét‹×èÔSÆEÿ…Àx@G‹Eø‹Øƒøþu΀}ÿt$‹ƒøþt
‹NÏ38è¹ÿÿ‹N‹VÏ3:è©ÿÿ‹Eô_^[‹å]ÃÇEôëÉ‹M9csmàu)ƒ=àCt hàCèãcƒÄ…Àt‹UjRÿàCƒÄ‹M‹UètS‹E9Xth€áBW‹Ó‹ÈèvS‹E‹Mø‰H‹ƒøþt
‹NÏ38è#ÿÿ‹N‹VÏ3:èÿÿ‹Eð‹H‹×è
Sºþÿÿÿ9S„Oÿÿÿh€áBW‹Ëè!Séÿÿÿ‹ÿU‹ì‹EVW…ÀxY;ØCsQ‹ÈÁù‹ðƒæ<àC‹Áæƒ<ÿu5ƒ=äBS‹]uƒètHtHuSjôëSjõëSjöÿ\0B‹‰3À[ëèGËÿÿÇ	èOËÿÿƒ ƒÈÿ_^]ËÿU‹ì‹MS3ÛVW;Ë|[;
ØCsS‹ÁÁø‹ñƒæ<…àC‹ÁæöD0t6ƒ<0ÿt0ƒ=äBu+ËtItIuSjôëSjõëSjöÿ\0B‹ƒÿ3ÀëèÁÊÿÿÇ	èÉÊÿÿ‰ƒÈÿ_^[]ËÿU‹ì‹Eƒøþuè­Êÿÿƒ è’ÊÿÿÇ	ƒÈÿ]Ã…Àx;ØCrè‰Êÿÿƒ ènÊÿÿÇ	èk¾ÿÿëÕ‹ÈÁù‹àCƒàÁàöDtÍ‹]ÃjhˆÂBèeüÿÿ‹}‹ÇÁø‹÷ƒæÁæ4…àCÇEä3Û9^u5j
èúûÿÿY‰]ü9^uh FPÿ`1B…Àu‰]äÿFÇEüþÿÿÿè09]ät‹ÇÁøƒçÁç‹…àCD8Pÿ˜1B‹Eäè&üÿÿÃ3Û‹}j
è¤úÿÿYËÿU‹ì‹E‹ÈƒàÁù‹àCÁàDPÿœ1B]Ãjh¨ÂBèŸûÿÿƒMäÿ3ÿ‰}ÜjèŽúÿÿY…ÀuƒÈÿéajè<ûÿÿY‰}ü‰}؃ÿ@;‹4½àC…ö„¹‰uà‹½àC;ðƒ–öFu[ƒ~u8j
èóúÿÿY3ÛC‰]üƒ~uh FPÿ`1B…Àu‰]ÜëÿFƒeüè(ƒ}Üu^Sÿ˜1BöFtSÿœ1BƒÆ@냋}Ø‹uàj
è¢ùÿÿYÃ}ÜuæÆFƒÿ+4½àCÁþ‹ÇÁàð‰uäƒ}äÿuyGé,ÿÿÿj@j ègöÿÿYY‰Eà…Àta½àC‰ƒØC ‹Â;ÂsÆ@ƒÿÆ@
ƒ`ƒÀ@‰EàëÝÁç‰}ä‹ÇÁø‹ÏƒáÁá‹…àCÆDWèÈýÿÿY…ÀuƒMäÿÇEüþÿÿÿè	‹EäèaúÿÿÃjèäøÿÿYÃjhÐÂBèúÿÿ3ÿ‰}ä2ÛöEt€Ã ÷E@t€Ë€öE€t€Ëÿuÿ”1B;Çuÿ<1BPèÀÇÿÿYƒÈÿèúÿÿÃøu€Ë@ëƒøu€Ëèüýÿÿ‹ð‰uƒþÿuèjÇÿÿÇèrÇÿÿ‰8ë‰}üÿuVèœûÿÿYY€Ë‹ÆÁø…àC‹ÆƒàÁà‹ˆ\‹T$€"€‹	D$€ ÇEäÇEüþÿÿÿè9}ä„iÿÿÿ‹Æéeÿÿÿ‹u3ÿ9}äu‹ÆÁø‹ÎƒáÁá‹…àCD€ þVè,ýÿÿYËÿU‹ìƒì@¡€áB3ʼnEüS‹]V‹u3ÀÆ”øÿÿW‰]ȉẺEĉEÀƒþFŒþLCÿƒø‡øƒ}‡îƒ};‡äƒ};‡Úƒ}ŒÐ”ïB‹Hü‹+Á¿;E}E‹Æ%€yHƒÈü@u‹Æjd™[÷û…Òu†l™‹ß÷û…Ò…‰‹]ȃû…}ƒ}sM‹Æ%€‰MÔyHƒÈü@u‹Æjd™Y÷ù…Òu†l™‹Ï÷ù…Òuƒû~ÿEÔè ÁÿÿEÌPè?ÄÿÿY…À…EÄPèZÄÿÿY…À…EÀPèuÄÿÿY…À…ó†+™÷ÿjd[jhm‹øFÿ™÷û+øFÿ™ƒâÂÁøD؉UЋƙƒèFƒÚRPè@nØ‹EЉEЋEԙ؋EÐÂ3ÿWjPSèn‹È‹E‹Ú™WÈj<ÚSQè	n‹È‹E‹Ú™WÈj<ÚSQèóm‹M‹ø‹EÀ‹Ú™øÚ‹Á™ø‹EÔ‰Eô‹EÈÚ‰uìHƒ} ‰Eè‹E‰Eà‹E‰E܉MØtƒ} ÿuƒ}ÌtEØPè‘ÀÿÿY…Àt‹EÄ™øÚ‹Ç‹Óë3ÀPPPPPè"¸ÿÿèÄÿÿǃÈÿЋMü_^3Í[èœwÿÿÉËÿU‹ìƒìLVE´PÿÀ1Bj@j ^VèDòÿÿYY3É;ÁuƒÈÿé£àC‰5ØC;Âs6ƒÀƒHûÿfÇ@ÿ
‰HfÇ@
Æ@!
‰H3ˆH/‹5àCƒÀ@PûÆ;ÖrÍSWf9Mæ„‹Eè;Á„‹ƒÀ‰Eüþ‰Eø;Þ|‹Þ9ØC}k¿äCj@j è¤ñÿÿYY…ÀtQƒØC ˆ‰;Ás1ƒÀƒHûÿƒ`€`€ƒ`3fÇ@ÿ
fÇ@ 

Æ@/‹ƒÀ@ÎPû;ÑrÒƒÇ9ØC|¢ë‹ØC3ÿ…Û~r‹Eø‹ƒøÿt\ƒøþtW‹MüŠ	öÁtMöÁuPÿ”1B…Àt=‹÷ƒæ‹ÇÁøÁæ4…àC‹Eø‹‰‹EüŠˆFh FPÿ`1B…À„¼ÿFƒEøGÿEü;û|Ž3Û‹óÁæ5àC‹ƒøÿtƒøþt€N€ëqÆF…ÛujöXë
Cÿ÷ØÀƒÀõPÿ`0B‹øƒÿÿtB…ÿt>Wÿ”1B…Àt3%ÿ‰>ƒøu€N@ë	ƒøu€Nh FPÿ`1B…Àt,ÿFë
€N@ÇþÿÿÿCƒûŒhÿÿÿÿ5ØCÿ1B3À_[^ÉÃÈÿëö‹ÿVW¿àC‹…Àt6ˆ;Ás!pƒ~ütVÿ1B‹ƒÆ@Nô;Èrâÿ7è˜{ÿÿƒ'YƒÇÿàC|¹_^ÃÌÌÌÌÌÌÌÌÌÌÌÌÌh ý@dÿ5‹D$‰l$l$+àSVW¡€áB1Eü3ʼnEäP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mä3Íè£tÿÿéÞóÿÿ‹ÿU‹ìV‹uVè¾
PèÕ¾YY…Àt|詃ÿÿƒÀ ;ðu3Àë虃ÿÿƒÀ@;ðu`3À@ÿ”öB÷FuNSW<…xCƒ?»u Sè¿îÿÿY‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N3À_@[ë3À^]ËÿU‹ìƒ}t'V‹u÷FtVèfÿîÿÿƒfƒ&ƒfY^]ÃöA@tƒyt$ÿIx‹ˆÿ¶Àë¾ÀQPèGYYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìQöC@V‹ð‹‰Eüt
ƒ{u‹Eë>ƒ'ƒ}~0‹EŠÿM‹ËènÿÿÿÿEƒ>ÿuƒ?*u‹Ë°?èXÿÿÿƒ}Õƒ?u‹Eü‰^ÉËÿU‹ì‹Eƒ‹‹@ü]ËÿU‹ì‹Eƒ‹‹Aø‹Qü]ËÿU‹ì‹Eƒ‹f‹@ü]ËÿU‹ì쀡€áB3ʼnEüS‹]V‹u3ÀW‹}ÿu¤ýÿÿ‰µÐýÿÿ‰½äýÿÿ‰…´ýÿÿ‰…ðýÿÿ‰…Èýÿÿ‰…èýÿÿ‰…Ìýÿÿ‰…¼ýÿÿ‰…Äýÿÿè¢uÿÿè:¿ÿÿ‰…”ýÿÿ…öu+è+¿ÿÿÇè(³ÿÿ€½°ýÿÿt
‹…¬ýÿÿƒ`pýƒÈÿé7öF@u^Vè[YºàîBƒøÿtƒøþt‹Èƒá‹ðÁþÁáµàCë‹ÊöA$u›ƒøÿtƒøþt‹ÈƒàÁùÁààCë‹Âö@$€…qÿÿÿ3É;Ù„gÿÿÿŠ‰Üýÿÿ‰Øýÿÿ‰¸ýÿÿˆ•ïýÿÿ„Ò„Ž
C3ö‰Àýÿÿ9µÜýÿÿŒy
Bà‹½äýÿÿƒðýÿÿ@Ç…Øýÿÿ
‹ðýÿÿ÷Á€„à‹‹WƒÇé‹½äýÿÿƒðýÿÿ@ôýÿÿ¸‰àýÿÿ‰… ýÿÿ9µèýÿÿ}Ç…èýÿÿëju€úgucÇ…èýÿÿëW9…èýÿÿ~‰…èýÿÿ½èýÿÿ£~=‹µèýÿÿÆ]VèoæÿÿŠ•ïýÿÿY‰…¸ýÿÿ…Àt‰…àýÿÿ‰µ ýÿÿ‹Øë
Ç…èýÿÿ£‹‹5´1BƒÇ‰…€ýÿÿ‹Gü‰…„ýÿÿ…¤ýÿÿPÿµˆýÿÿ¾Âÿµèýÿÿ‰½äýÿÿPÿµ ýÿÿ…€ýÿÿSPÿ5HïBÿÖÿЋ½ðýÿÿƒÄç€tƒ½èýÿÿu…¤ýÿÿPSÿ5TïBÿÖÿÐYY€½ïýÿÿgu…ÿu…¤ýÿÿPSÿ5PïBÿÖÿÐYY€;-uðýÿÿC‰àýÿÿSéÁýÿÿÇ…èýÿÿ‰´ýÿÿë*ƒès„nüÿÿHH„Xþÿÿƒè…»‹½äýÿÿÇ…´ýÿÿ'ö…ðýÿÿ€Ç…Øýÿÿ„2þÿÿŠ…´ýÿÿQÆ…Ôýÿÿ0ˆ…ÕýÿÿÇ…Ìýÿÿéþÿÿ÷Á…þÿÿƒÇöÁ t‰½äýÿÿöÁ@t¿Güë·Gü™ë‹GüöÁ@t™ë3Ò‰½äýÿÿöÁ@t…Ò|…Às÷ØÖ÷Úðýÿÿ÷…ðýÿÿ‹ú‹Øu3ÿ9µèýÿÿ}Ç…èýÿÿ냥ðýÿÿ÷¸9…èýÿÿ~‰…èýÿÿ‹ÃÇu!µÌýÿÿuó‹…èýÿÿÿèýÿÿ…À‹ÃÇt-‹…Øýÿÿ™RPWS踷ƒÁ0‰ ýÿÿ‹Ø‹úƒù9~´ýÿÿˆNë½Eó+ÆF÷…ðýÿÿ‰…Øýÿÿ‰µàýÿÿtb…Àt‹Î€90tWÿàýÿÿ‹àýÿÿÆ0@ë?If90tƒÀ…Éuó+…àýÿÿÑøë(…ÿu¡ ïB‰…àýÿÿ‹…àýÿÿëI€8t@…Éuõ+…àýÿÿ‰…Øýÿÿƒ½¼ýÿÿ…¸‹ðýÿÿöÁ@t5÷Át	Æ…Ôýÿÿ-ëöÁt	Æ…Ôýÿÿ+ëöÁtÆ…Ôýÿÿ Ç…Ìýÿÿ‹…Èýÿÿ+…Øýÿÿ+…Ìýÿÿ‰… ýÿÿöÁu%‹øë‹ÐýÿÿµÜýÿÿ° OèÐôÿÿƒ½Üýÿÿÿt…ÿßÿµÌýÿÿ‹½”ýÿÿ‹Ðýÿÿ…ÔýÿÿP…Üýÿÿèøôÿÿö…ðýÿÿYYt.ö…ðýÿÿu%‹½ ýÿÿëµÜýÿÿ‹Ë°0Oèsôÿÿƒ½Üýÿÿÿt…ÿヽÄýÿÿ‹…Øýÿÿtu…À~q‹µàýÿÿ‰…˜ýÿÿ·ÿ˜ýÿÿPjEôP…ýÿÿPƒÆèOµƒÄ…Àu69…ýÿÿt.ÿµýÿÿ‹½”ýÿÿ‹ÐýÿÿEôP…ÜýÿÿèQôÿÿƒ½˜ýÿÿYYu¦ë#ƒÜýÿÿÿ닽”ýÿÿPÿµàýÿÿ…Üýÿÿè#ôÿÿYYƒ½Üýÿÿ|2ö…ðýÿÿt)‹½ ýÿÿë‹ÐýÿÿµÜýÿÿ° Oèšóÿÿƒ½Üýÿÿÿt…ÿ߃½¸ýÿÿtÿµ¸ýÿÿèËmÿÿƒ¥¸ýÿÿY‹ÀýÿÿŠˆ…ïýÿÿ„Àt‹Œýÿÿ‹½äýÿÿŠÐérõÿÿ€½°ýÿÿt
‹…¬ýÿÿƒ`pý‹…Üýÿÿ‹Mü_^3Í[èôfÿÿÉþA½AíAK
A—
A¢
Aè
AA‹ÿU‹ì‹E…Àuè³ÿÿÇ芧ÿÿƒÈÿ]Ë@]ÃjhðÂBèšåÿÿ3ö‰uä3À‹};þ•À;ÆuèT³ÿÿÇèQ§ÿÿƒÈÿéÄ3À9u•À;Æt܉}WèavÿÿY‰uüöG@uoWè~ÿÿÿYƒøÿtƒøþt‹ÐÁú‹ÈƒáÁá•àCë¹àîBöA$u)ƒøÿtƒøþt‹ÈÁùƒàÁààCë¸àîBö@$€tè²ÿÿÇ迦ÿÿƒMäÿ9uäu"Wè=ñÿÿ‹ðÿuÿuÿuWÿU‰EäWVèÀñÿÿƒÄÇEüþÿÿÿè	‹EäèëäÿÿÃÿuèvÿÿYËÿU‹ìÿuÿuÿuÿuh<AèÚþÿÿƒÄ]ËÿU‹ìÿuÿuÿuÿuh`ÍAèºþÿÿƒÄ]ËÿU‹ìÿuÿuÿuÿuhÛAèšþÿÿƒÄ]ËÿU‹ìÿujÿuÿuh<Aè{þÿÿƒÄ]ËÿU‹ìÿujÿuÿuh`ÍAè\þÿÿƒÄ]ËÿU‹ìÿujÿuÿuhÛAè=þÿÿƒÄ]ÃjhÃBèÒãÿÿ3Û‰]äjè‡ãÿÿY‰]üj_‰}à;= -C}T‹÷¡C9°tE‹°ö@ƒtPèIzÿÿYƒøÿtÿEäƒÿ|(¡C‹°ƒÀ Pÿ1B¡Cÿ4°èõjÿÿY¡C‰°Gë¡ÇEüþÿÿÿè	‹Eäè‘ãÿÿÃjèâÿÿYËÿU‹ìSV‹u‹F‹È€á3Û€ùu@©t9‹FW‹>+ø…ÿ~,WPVèBýÿÿYPèj.ƒÄ;Çu‹F„Àyƒàý‰FëƒN ƒËÿ_‹Fƒf‰^‹Ã[]ËÿU‹ìV‹u…öu	Vè5Yë/Vè|ÿÿÿY…ÀtƒÈÿë÷F@tVèÙüÿÿPèBÔY÷ØYÀë3À^]Ãjh0ÃBè†âÿÿ3ÿ‰}ä‰}Üjè8âÿÿY‰}ü3ö‰uà;5 -Cƒ¡C°98t^‹ö@ƒtVPVèsÿÿYY3ÒB‰Uü¡C‹°‹HöÁƒt/9UuPèJÿÿÿYƒøÿtÿEäë9}uöÁtPè/ÿÿÿYƒøÿu	E܉}üèFë„3ÿ‹uà¡Cÿ4°Vè˜sÿÿYYÃÇEüþÿÿÿèƒ}‹Eät‹EÜèâÿÿÃjèŠàÿÿYÃjhXÃBè¬áÿÿ3ö9uu	Vè
ÿÿÿYë'ÿuè›rÿÿY‰uüÿuè®þÿÿY‰EäÇEüþÿÿÿè	‹EäèµáÿÿÃÿuèárÿÿYÃjèÌþÿÿYËÿU‹ìQV‹uVè€ûÿÿ‰E‹FY¨‚uè¯ÿÿÇ	ƒN ƒÈÿé/¨@t
èó®ÿÿÇ"ëãS3Û¨t‰^¨„‡‹Nƒàþ‰‰F‹FƒàïƒÈ‰F‰^‰]ü©u,èqÿÿƒÀ ;ðtèqÿÿƒÀ@;ðu
ÿuè¬Y…ÀuVè£ÔY÷FW„€‹F‹>H‰‹N+øI‰N;û~WPÿuèë+ƒÄ‰EüëMƒÈ ‰FƒÈÿëy‹Mƒùÿtƒùþt‹Áƒà‹ÑÁúÁà•àCë¸àîBö@ tjSSQè>Ó#ƒÄƒøÿt%‹FŠMˆë3ÿGWEPÿuè|+ƒÄ‰Eü9}üt	ƒN ƒÈÿë‹E%ÿ_[^ÉËÿU‹ì‹9EuF‹jP;Mu+èªÛÿÿYY‰…Àu3À]ËEÇÿ6ÿuÿ7èœ[ÿÿƒÄëQèÜÿÿƒÄ…ÀtÕ‰Ñ&3À@]ËÿU‹ì‹E‹‹€¼]ËÿU‹ì¶EPèþŒÿÿ…À¾EYuƒà߃è]ÃÿJx	‹
¶A‰
ÃRè)9YËÿU‹ìƒ}ÿt]é|Ó]ËÿU‹ìS‹UÿèÇÿÿÿ‹Øƒûÿt¶ÃPè©ÿÿY…Àuá‹Ã[]ËÿU‹ìì¡€áB3ʼnEü‹M‹EV‹uW3ÿ‰þÿÿ|þÿÿ‰…\þÿÿ‰PþÿÿÇ…$þÿÿ^‰½0þÿÿ‰½þÿÿ‰½lþÿÿ;÷uè¬ÿÿÇ茠ÿÿƒÈÿé„;Çtäö@@SurPèÍøÿÿYºàîBƒøÿtƒøþt‹Èƒá‹ØÁûÁáàCë‹ÊöA$u&ƒøÿtƒøþt‹ÈƒàÁùÁààCë‹Âö@$€tè¬ÿÿÇè ÿÿƒÈÿéÿuþÿÿèTbÿÿŠÆ…[þÿÿ‰½tþÿÿ‰½4þÿÿ„À„‹þ¶ÀPèzŒÿÿY…Àt?ÿµ\þÿÿÿtþÿÿµtþÿÿè•þÿÿYƒøÿtÿµ\þÿÿPèýÑYYG¶Pè@ŒÿÿY…Àuñéë
Š<%…k
8G„X
3À‰…þÿÿˆ…/þÿÿ‰…Tþÿÿ‰…Hþÿÿ‰…dþÿÿˆ…Xþÿÿˆ…Yþÿÿˆ…cþÿÿˆ…sþÿÿˆ…Zþÿÿˆ…kþÿÿÆ…{þÿÿ‰…(þÿÿ3öG¶¶ÃP辊ÿÿY…Àt‹…dþÿÿÿ…HþÿÿkÀ
DЉ…dþÿÿéŃûNƒ„¶ƒû*tpƒûF„¨ƒûItƒûLutþ…{þÿÿé“ŠO€ù6uG€84uÿ…(þÿÿ‹ø‰µ8þÿÿ‰µ<þÿÿëm€ù3uG€82u‹øë\€ùdtW€ùitR€ùotM€ùxtH€ùXuëAþ…cþÿÿë9ƒûht(ƒûlt
ƒûwtþ…sþÿÿë"G€8lt—þ…{þÿÿþ…kþÿÿëþ{þÿÿþkþÿÿ€½sþÿÿ„þþÿÿ€½cþÿÿ‰½Dþÿÿu‹…þÿÿ‹0‰…þÿÿƒÀ‰…þÿÿë3ö€½kþÿÿ‰µ@þÿÿÆ…sþÿÿuŠ]u²]FÆEç 鞊•/þÿÿé“F<-uq„ÒtmŠ€ù]tfF:Ñsˆ{þÿÿ눕{þÿÿŠÑ:•{þÿÿs,Š…{þÿÿ*¶ú¶Ð‹Ïƒá‹Ç³ÒãÁèDÜGJuè‹Lþÿÿ¶{þÿÿ‹Áƒá²ÒâÁèDÜ2Òë¶ÈŠÐ‹Áƒá³ÒãÁèDÜ‹LþÿÿŠ<]…cÿÿÿ„À„‰µDþÿÿ‹µ@þÿÿébýÿÿƒû+u.ÿdþÿÿu
…Ét	Æ…sþÿÿë‹•\þÿÿÿ…tþÿÿèøôÿÿ‹Ø‰lþÿÿƒû0…Š‹•\þÿÿÿ…tþÿÿèÖôÿÿ‹Ø‰lþÿÿ€ûxt_€ûXtZƒ½LþÿÿxÇ…Tþÿÿt&ƒ½Hþÿÿtÿdþÿÿuþ…sþÿÿÇ…Lþÿÿoé.ÿtþÿÿƒûÿtÿµ\þÿÿSèÈYYj0[é‹•\þÿÿÿ…tþÿÿèYôÿÿƒ½Hþÿÿ‹Ø‰lþÿÿtƒ­dþÿÿƒ½dþÿÿ}þ…sþÿÿÇ…LþÿÿxéƈF‰µ@þÿÿéxüÿÿGérüÿÿÿtþÿÿƒøÿtÿµ\þÿÿPè›ÇYY;þ„Õ€½cþÿÿ…óÿ…4þÿÿƒûc„䀽Zþÿÿt‹@þÿÿ3Àf‰éË‹…@þÿÿÆé½Æ…{þÿÿ‹lþÿÿƒû-u	Æ…Yþÿÿëƒû+u.ÿdþÿÿu
…Ét	Æ…sþÿÿë‹•\þÿÿÿ…tþÿÿèeóÿÿ‹Ø‰lþÿÿƒ½(þÿÿ„<€½sþÿÿ…øƒ½Lþÿÿxt]ƒ½LþÿÿptT¶ÃPè€ÿÿY…À„»ƒ½Lþÿÿouƒû8©‹µ8þÿÿ‹½<þÿÿ¤÷ÁæëKjj
ÿµ<þÿÿÿµ8þÿÿè"I‹ð‹úë0¶ÃPèE€ÿÿY…Àtk‹µ8þÿÿ‹½<þÿÿ¤÷SÁæè–òÿÿ‹ØY‰lþÿÿÿ…TþÿÿCЙðúƒ½Hþÿÿ‰µ8þÿÿ‰½<þÿÿtÿdþÿÿt7‹•\þÿÿÿ…tþÿÿèqòÿÿ‹Ø‰lþÿÿé!ÿÿÿÿtþÿÿƒûÿtÿµ\þÿÿSèðÅYY€½Yþÿÿ‹½þÿÿ„ì‹…8þÿÿ‹<þÿÿ÷؃Ñ÷Ù‰…8þÿÿ‰<þÿÿéÈ€½sþÿÿ‹½þÿÿ…ªƒ½Lþÿÿxt/ƒ½Lþÿÿpt&¶ÃPèÓ~ÿÿY…Àtqƒ½Lþÿÿou
ƒû8}cÁçë%kÿ
ë ¶ÃPè1ÿÿY…ÀtKSÁçè’ñÿÿ‹ØY‰lþÿÿÿ…Tþÿÿƒ½Hþÿÿ|Ðtÿdþÿÿt7‹•\þÿÿÿ…tþÿÿè}ñÿÿ‹Ø‰lþÿÿéoÿÿÿÿtþÿÿƒûÿtÿµ\þÿÿSèüÄYY€½Yþÿÿt÷߃½LþÿÿFuƒ¥Tþÿÿƒ½Tþÿÿ„€½cþÿÿu8ÿ…4þÿÿ‹µ@þÿÿƒ½(þÿÿt‹…8þÿÿ‰‹…<þÿÿ‰F뀽{þÿÿt‰>ëf‰>‹½Dþÿÿþ…[þÿÿG‰½Dþÿÿëd<%u8GuG‹•\þÿÿÿ…tþÿÿè¾ðÿÿ‹Ø¶G‰lþÿÿ‰½Dþÿÿ;Ãuw¶ÃPè½Y…Àt%‹•\þÿÿÿ…tþÿÿè‰ðÿÿ¶G‰½Dþÿÿ;Èu7ÿtþÿÿƒ½lþÿÿÿu€?%uN‹…Dþÿÿ€xnuB‹øŠ„À…¾ñÿÿë4ƒ½lþÿÿÿëƒøÿtÿµ\þÿÿPèÖÃYYƒûÿtÿµ\þÿÿÿµlþÿÿè¾ÃYYƒ½0þÿÿuÿµPþÿÿèýVÿÿYƒ½lþÿÿÿu*‹…4þÿÿ…Àu8…[þÿÿuƒÈÿ€½þÿÿt%‹þÿÿƒapý뀽þÿÿt
‹…þÿÿƒ`pý‹…4þÿÿ[‹Mü_3Í^èPÿÿÉËÿU‹ì‹9EuF‹jP;Mu+èÊÊÿÿYY‰…Àu3À]ËEÇÿ6ÿuÿ7è¼JÿÿƒÄëQè8ËÿÿƒÄ…ÀtÕ‰Ñ&3À@]ËÿU‹ì¶EPè0|ÿÿ…À¾EYuƒà߃è]ÃÿJx	‹
¶A‰
ÃRè[(YËÿU‹ìƒ}ÿt]é®Â]ËÿU‹ìS‹UÿèÇÿÿÿ‹Øƒûÿt¶ÃPèÛ|ÿÿY…Àuá‹Ã[]ËÿU‹ìì¡€áB3ʼnEü‹M‹EV‹uW3ÿ‰þÿÿ|þÿÿ‰…`þÿÿ‰µPþÿÿ‰XþÿÿÇ…(þÿÿ^‰½0þÿÿ‰½þÿÿ‰½lþÿÿ‰½þÿÿ;÷uèµ›ÿÿÇè²ÿÿƒÈÿé—;Çtäö@@SurPèóçÿÿYºàîBƒøÿtƒøþt‹Èƒá‹ØÁûÁáàCë‹ÊöA$u&ƒøÿtƒøþt‹ÈƒàÁùÁààCë‹Âö@$€tè8›ÿÿÇè5ÿÿƒÈÿéÿuüýÿÿèzQÿÿŠÆ…^þÿÿ‰½tþÿÿ‰½8þÿÿ„À„Õ¶ÀPè¢{ÿÿY…ÀtKÿµ`þÿÿÿtþÿÿµtþÿÿè‹þÿÿYƒøÿtÿµ`þÿÿPè%ÁYY‹µPþÿÿF¶Pèb{ÿÿY…Àuñ‰µPþÿÿép‹µPþÿÿŠ<%…Ú
8F„Ç
3ÿ‰½<þÿÿÆ…/þÿÿ‰½Tþÿÿ‰½@þÿÿ‰½dþÿÿ‰½4þÿÿÆ…]þÿÿÆ…\þÿÿÆ…jþÿÿÆ…sþÿÿÆ…_þÿÿÆ…kþÿÿÆ…{þÿÿ‰½$þÿÿF¶¶ÃPèÉyÿÿY…Àt‹…dþÿÿÿ…@þÿÿkÀ
DЉ…dþÿÿéŃûNƒ„¶ƒû*tpƒûF„¨ƒûItƒûLutþ…{þÿÿé“ŠN€ù6uF€84uÿ…$þÿÿ‹ð‰½Hþÿÿ‰½Lþÿÿëm€ù3uF€82u‹ðë\€ùdtW€ùitR€ùotM€ùxtH€ùXuëAþ…jþÿÿë9ƒûht(ƒûlt
ƒûwtþ…sþÿÿë"F€8lt—þ…{þÿÿþ…kþÿÿëþ{þÿÿþkþÿÿ€½sþÿÿ„þþÿÿ€½jþÿÿ‰µPþÿÿu‹…þÿÿ‹‰…þÿÿƒÀ‰…þÿÿë3Û€½kþÿÿ‰DþÿÿÆ…sþÿÿuŠƒÏ ‰½þÿÿƒÿntPƒÿctƒÿ{tÿµ`þÿÿµtþÿÿèZüÿÿYë‹•`þÿÿÿ…tþÿÿèüÿÿ‰…lþÿÿƒøÿ„û‹Dþÿÿ‹µPþÿÿ‹½þÿÿ‹@þÿÿ…Ét
ƒ½dþÿÿ„6€½jþÿÿuAƒÿct
ƒÿstƒÿ{u2‹…þÿÿ‹ƒÀ‰…þÿÿƒÀ‰…þÿÿ‹@ü‰Dþÿÿ‰…4þÿÿƒø‚õƒÿo—„Uƒÿc„ƒÿd„CŽ£ƒÿg~Dƒÿit!ƒÿn…€½jþÿÿ‹…tþÿÿ„¿
éæ
jd_‹lþÿÿƒû-…“Æ…\þÿÿéŒ3Ûƒ½lþÿÿ-u‹…XþÿÿÆ-Cë	ƒ½lþÿÿ+uÿdþÿÿ‹•`þÿÿÿ…tþÿÿèôúÿÿ‰…lþÿÿƒ½@þÿÿuƒdþÿÿÿ¶…lþÿÿëk‹…dþÿÿÿdþÿÿ…ÀtfŠ…lþÿÿ‹Xþÿÿÿ…Tþÿÿˆ…0þÿÿP…|þÿÿPCS½Xþÿÿµ(þÿÿèúÿÿƒÄ…À„q‹•`þÿÿÿ…tþÿÿèsúÿÿ‰…lþÿÿ¶ÀPèƒvÿÿY…ÀuŠ‹…üýÿÿ‹€¼‹Šˆ…]þÿÿ:…lþÿÿ…å‹…dþÿÿÿdþÿÿ…À„Ñ‹•`þÿÿÿ…tþÿÿèúÿÿ‹Xþÿÿ‰…lþÿÿŠ…]þÿÿˆ…0þÿÿP…|þÿÿPCS½Xþÿÿµ(þÿÿèkùÿÿƒÄ…À„Ä
¶…lþÿÿëk‹…dþÿÿÿdþÿÿ…Àtf‹…XþÿÿŠlþÿÿÿ…Tþÿÿˆ…0þÿÿP…|þÿÿPCS½Xþÿÿµ(þÿÿèùÿÿƒÄ…À„j
‹•`þÿÿÿ…tþÿÿèlùÿÿ‰…lþÿÿ¶ÀPè|uÿÿY…ÀuŠƒ½Tþÿÿ„_ƒ½lþÿÿet
ƒ½lþÿÿE…I‹…dþÿÿÿdþÿÿ…À„5‹…XþÿÿÆe…0þÿÿP…|þÿÿPCS½Xþÿÿµ(þÿÿèøÿÿƒÄ…À„Ø	‹•`þÿÿÿ…tþÿÿèÚøÿÿ‰…lþÿÿƒø-u,‹…XþÿÿÆ-…0þÿÿP…|þÿÿPCSè9øÿÿƒÄ…À„’	ë	ƒ½lþÿÿ+u/‹…dþÿÿÿdþÿÿ…Àu!…dþÿÿë‹•`þÿÿÿ…tþÿÿèqøÿÿ‰…lþÿÿ¶…lþÿÿëk‹…dþÿÿÿdþÿÿ…Àtf‹…XþÿÿŠlþÿÿÿ…Tþÿÿˆ…0þÿÿP…|þÿÿPCS½Xþÿÿµ(þÿÿè¥÷ÿÿƒÄ…À„þ‹•`þÿÿÿ…tþÿÿèøÿÿ‰…lþÿÿ¶ÀPètÿÿY…ÀuŠÿtþÿÿƒ½lþÿÿÿtÿµ`þÿÿÿµlþÿÿ衺YYƒ½Tþÿÿ„ª€½jþÿÿ…M‹…Xþÿÿÿ…8þÿÿüýÿÿQPÿµDþÿÿƾ…{þÿÿHPÿ5LïBÿ´1BÿЃÄé…Éuÿ…dþÿÿÇ…@þÿÿ€½kþÿÿ~Æ…_þÿÿÿtþÿÿƒ½lþÿÿÿ‹ótÿµ`þÿÿÿµlþÿÿèºYYƒÿctÿ4þÿÿƒ½@þÿÿt‹…dþÿÿÿdþÿÿ…À„v‹•`þÿÿÿ…tþÿÿèòöÿÿ‰…lþÿÿƒøÿ„=ƒÿctLƒÿsuƒø	|	ƒø
Ž%ƒø u4ƒÿ{…¾½]þÿÿ3ҋȃáBÓâ‹ÈÁù¾L
Ü3Ï…Ñ„ò‹½þÿÿ€½jþÿÿ…Ùƒ½4þÿÿ„€½_þÿÿ„±ˆ… þÿÿ¶ÀPè¬Y…Àt‹•`þÿÿÿ…tþÿÿèFöÿÿˆ…!þÿÿ…üýÿÿP‹…üýÿÿÇ…þÿÿ?ÿ°¬… þÿÿP…þÿÿPè1ºf‹…þÿÿƒÄf‰ƒÃéD‹Çƒèp„²ƒè„ˆþÿÿHH„¨ƒè„úÿÿƒèt3¶;…lþÿÿ…<þ^þÿÿ€½jþÿÿ…L‹…þÿÿ‰…þÿÿé;€½kþÿÿ~Æ…_þÿÿF€>^uFÆ…]þÿÿÿj EÜjPèdCÿÿƒÄ€>]u²]FÆEç é’Š•/þÿÿé‡F<-uk„ÒtgŠ€ù]t`F:Ñsˆ{þÿÿ눕{þÿÿŠÑ:•{þÿÿs&Š…{þÿÿ*¶ú¶Ð‹Ïƒá‹Ç³ÒãÁèDÜGJuè¶{þÿÿ‹Áƒá²ÒâÁèDÜ2Òë¶ÈŠÐ‹Áƒá³ÁèÒãDÜŠ<]…oÿÿÿ„À„¨‹Dþÿÿ‹½þÿÿ‰µPþÿÿéUýÿÿƒû+u.ÿdþÿÿu
…Ét	Æ…sþÿÿë‹•`þÿÿÿ…tþÿÿèyôÿÿ‹Ø‰lþÿÿƒû0…x‹•`þÿÿÿ…tþÿÿèWôÿÿ‹Ø‰lþÿÿ€ûxtP€ûXtKÇ…Tþÿÿƒÿxtƒ½@þÿÿtÿdþÿÿuþ…sþÿÿjoë[ÿtþÿÿƒûÿtÿµ`þÿÿSèÙ¶YYj0[é‹•`þÿÿÿ…tþÿÿèéóÿÿƒ½@þÿÿ‹Ø‰lþÿÿtƒ­dþÿÿƒ½dþÿÿ}þ…sþÿÿjx_éʈC‰Dþÿÿé†üÿÿFé†üÿÿÿtþÿÿƒøÿtÿµ`þÿÿPèd¶YY;ó„r€½jþÿÿ…ÿ…8þÿÿƒ½þÿÿc„€½_þÿÿt‹Dþÿÿ3Àf‰éé‹…DþÿÿÆéÛÆ…{þÿÿ‹lþÿÿƒû-u	Æ…\þÿÿëƒû+u.ÿdþÿÿu
…Ét	Æ…sþÿÿë‹•`þÿÿÿ…tþÿÿèøòÿÿ‹Ø‰lþÿÿƒ½$þÿÿ„F€½sþÿÿ…ƒÿxtiƒÿptd¶ÃPèânÿÿY…À„Óƒÿou*ƒû8Å‹…Hþÿÿ‹Lþÿÿ¤ÁÁà‰…Hþÿÿ‰Lþÿÿë_jj
ÿµLþÿÿÿµHþÿÿèç7‰…Hþÿÿ‰•Lþÿÿë<¶ÃPèoÿÿY…Àts‹…Hþÿÿ‹Lþÿÿ¤ÁÁàS‰…Hþÿÿ‰Lþÿÿèòÿÿ‹ØY‰lþÿÿÿ…TþÿÿCЙ…Hþÿÿ•Lþÿÿƒ½@þÿÿtÿdþÿÿt7‹•`þÿÿÿ…tþÿÿèôñÿÿ‹Ø‰lþÿÿéÿÿÿÿtþÿÿƒûÿtÿµ`þÿÿS襴YY€½\þÿÿ„þ‹…Hþÿÿ‹Lþÿÿ÷؃Ñ÷Ù‰…Hþÿÿ‰LþÿÿéÚ€½sþÿÿ…¾ƒÿxt7ƒÿpt2¶ÃPèœmÿÿY…À„‰ƒÿouƒû8}‹…<þÿÿÁàë5‹…<þÿÿkÀ
ë*¶ÃPèîmÿÿY…Àt[Á¥<þÿÿSèñÿÿ‹Ø‹…<þÿÿY‰lþÿÿÿ…Tþÿÿƒ½@þÿÿDЉ…<þÿÿtÿdþÿÿt7‹•`þÿÿÿ…tþÿÿèøðÿÿ‹Ø‰lþÿÿé[ÿÿÿÿtþÿÿƒûÿtÿµ`þÿÿS詳YY€½\þÿÿt÷<þÿÿƒÿFuƒ¥Tþÿÿƒ½Tþÿÿ„—€½jþÿÿu>ÿ…8þÿÿ‹Dþÿÿ‹…<þÿÿƒ½$þÿÿt‹…Hþÿÿ‰‹…Lþÿÿ‰C뀽{þÿÿt‰ëf‰‹µPþÿÿþ…^þÿÿF‰µPþÿÿël<%u8FuF‹•`þÿÿÿ…tþÿÿè3ðÿÿ‹Ø¶F‰lþÿÿ‰µPþÿÿ;Ã…î¶ÃPè`Y…Àt)‹•`þÿÿÿ…tþÿÿèúïÿÿ¶F‰µPþÿÿ;È…ªÿtþÿÿƒ½lþÿÿÿu€>%…½‹…Pþÿÿ€xn…­‹ðŠ„À…-ñÿÿ霃½lþÿÿÿë~€½kþÿÿ~3Àf‰ëÆèŒÿÿÇësƒ½lþÿÿÿtÿµ`þÿÿÿµlþÿÿèA²YYÇ…þÿÿëKèÌ‹ÿÿ€½_þÿÿÇt3Àf‰ë0Æë+ƒøÿtÿµ`þÿÿPè²YYƒûÿtÿµ`þÿÿÿµlþÿÿèê±YYƒ½0þÿÿuÿµXþÿÿè)EÿÿYƒ½lþÿÿÿu*‹…8þÿÿ…Àu8…^þÿÿuƒÈÿ€½þÿÿt>‹þÿÿƒapýë2ƒ½þÿÿuè0‹ÿÿÇè-ÿÿ€½þÿÿt
‹…þÿÿƒ`pý‹…8þÿÿ[‹Mü_3Í^è2>ÿÿÉËÿU‹ìV‹uWVèAÀÿÿYƒøÿtP¡àCƒþu	ö€„uƒþuö@DtjèÀÿÿj‹øè
ÀÿÿYY;ÇtVèÀÿÿYPÿH1B…Àu
ÿ<1B‹øë3ÿVè]¿ÿÿ‹ÆÁø‹…àCƒæÁæYÆD0…ÿtWè“ŠÿÿYƒÈÿë3À_^]ÃjhxÃB胼ÿÿ‹]ƒûþuè[Šÿÿƒ è@ŠÿÿÇ	ƒÈÿé„…Ûx;ØCrè4Šÿÿƒ èŠÿÿÇ	è~ÿÿëÒ‹ÃÁø<…àC‹óƒæÁ拾D0ƒàtÆS裿ÿÿYƒeü‹öD0tSèÕþÿÿY‰EäëèljÿÿÇ	ƒMäÿÇEüþÿÿÿè‹Eäè¼ÿÿË]Sèû¿ÿÿYËÿU‹ìV‹u‹F¨ƒt¨tÿvè8Cÿÿf÷ûÿÿ3ÀY‰‰F‰F^]ËÿU‹ì¸äè«Pÿÿ¡€áB3ʼnEü‹EV‹uW3ÿ‰…4åÿÿ‰½8åÿÿ‰½0åÿÿ9}u3Àé®;Çuè5‰ÿÿ‰8è‰ÿÿÇè}ÿÿƒÈÿé‹‹ÆÁø‹þS…àC‹ƒçÁçŠL8$ÉÐù‰$åÿÿˆ?åÿÿ€ùt€ùu'‹M÷ÑöÁuè׈ÿÿƒ 輈ÿÿÇè¹|ÿÿéöD8 tjjjVèC­ƒÄVè†Y…À„™‹öD€„Œè™ÿÿ‹@l3É9H… åÿÿ”ÁP‹ÿ4‹ñÿ1B3É;Á„`;ñt8?åÿÿ„Pÿ1B‹4åÿÿ‰… åÿÿ3À‰…,åÿÿ9E†#‰…@åÿÿŠ…?åÿÿ„À…gŠ‹µ$åÿÿ3À€ù
”À‰…åÿÿ‹ǃx8tŠP4ˆUôˆMõƒ`8jEôPëK¾ÁPè¤Y…Àt:‹4åÿÿ+ËM3À@;Ȇ¥j…DåÿÿSPèa°ƒÄƒøÿ„’Cÿ…@åÿÿëjS…DåÿÿPè=°ƒÄƒøÿ„n3ÀPPjMôQjDåÿÿQPÿµ åÿÿCÿ…@åÿÿÿÜ1B‹ð…ö„=j…,åÿÿPVEôP‹…$åÿÿ‹ÿ4ÿt1B…À„
‹…@åÿÿ‹0åÿÿÁ‰…8åÿÿ9µ,åÿÿŒöƒ½åÿÿ„Íj…,åÿÿPjEôP‹…$åÿÿ‹ÆEô
ÿ4ÿt1B…À„±ƒ½,åÿÿŒ°ÿ…0åÿÿÿ…8åÿÿéƒ<t<u!·33Ƀþ
”ÁƒÃƒ…@åÿÿ‰µDåÿÿ‰åÿÿ<t<uRÿµDåÿÿè@¯Yf;…Dåÿÿ…Iƒ…8åÿÿƒ½åÿÿt)j
XP‰…Dåÿÿè¯Yf;…Dåÿÿ…ÿ…8åÿÿÿ…0åÿÿ‹E9…@åÿÿ‚ùýÿÿé‹Šÿ…8åÿÿˆT4‹‰D8éï3É‹öD8€„¡€½?åÿÿ‰Dåÿÿ…¨‹4åÿÿ9M†ý‹Ë3ö+4åÿÿ…Håÿÿ;Ms&ŠCA‰ åÿÿ€ú
uÿ…0åÿÿÆ
@Fˆ@FþÿrÕ‹ð…Håÿÿ+ðj…(åÿÿPV…HåÿÿP‹…$åÿÿ‹ÿ4ÿt1B…À„C‹…(åÿÿ…8åÿÿ;ÆŒ;‹Ã+…4åÿÿ;E‚lÿÿÿé%€½?åÿÿ…Í‹4åÿÿ9M†Hƒ¥@åÿÿ‹Ë+4åÿÿj…Håÿÿ^;MsC·ÞΉ åÿÿƒú
uµ0åÿÿj
[f‰‹ åÿÿƵ@åÿÿµ@åÿÿf‰ƽ@åÿÿþr¸‹ð…Håÿÿ+ðj…(åÿÿPV…HåÿÿP‹…$åÿÿ‹ÿ4ÿt1B…À„i‹…(åÿÿ…8åÿÿ;ÆŒa‹Ã+…4åÿÿ;E‚GÿÿÿéK‹…4åÿÿ‰…,åÿÿ9M†u‹,åÿÿƒ¥@åÿÿ+4åÿÿj…Hùÿÿ^;Ms;‹•,åÿÿ·µ,åÿÿ΃ú
uj
[f‰Æµ@åÿÿµ@åÿÿf‰ƽ@åÿÿ¨rÀ3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéýÿÜ1B‹Ø;Þ„—j…(åÿÿP‹Ã+ÆP„5ðëÿÿP‹…$åÿÿ‹ÿ4ÿt1B…Àtµ(åÿÿ;ÞËëÿ<1B‰…Dåÿÿ;Þ\‹…,åÿÿ+…4åÿÿ‰…8åÿÿ;E‚ÿÿÿë?Q(åÿÿQÿuÿµ4åÿÿÿ48ÿt1B…Àt‹…(åÿÿƒ¥Dåÿÿ‰…8åÿÿëÿ<1B‰…Dåÿÿƒ½8åÿÿulƒ½Dåÿÿt-j^9µDåÿÿuèÝ‚ÿÿÇ	èå‚ÿÿ‰0ë?ÿµDåÿÿèé‚ÿÿYë1‹…$åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$è‚ÿÿÇ襂ÿÿƒ ƒÈÿë‹…8åÿÿ+…0åÿÿ[‹Mü_3Í^è¤5ÿÿÉÃjh˜ÃBè‘´ÿÿ‹]ƒûþuèi‚ÿÿƒ èN‚ÿÿÇ	ƒÈÿé”…Ûx;ØCrèB‚ÿÿƒ è'‚ÿÿÇ	è$vÿÿëÒ‹ÃÁø<…àC‹óƒæÁ拾D0ƒàtÆSè±·ÿÿYƒeü‹öD0tÿuÿuSènøÿÿƒÄ‰EäëèÍÿÿÇ	èÕÿÿƒ ƒMäÿÇEüþÿÿÿè‹Eäè´ÿÿË]Sèù·ÿÿYËÿU‹ì‹UV‹uW¶H¿FƒùwƒÀ ¶
y¿BƒÿwƒÁ …Àt;ÁtÚ_+Á^]ËÿU‹ìƒìSÿuMðè±7ÿÿ‹]…Ûu#èBÿÿÇè?uÿÿ8]üt‹Eøƒ`pý¸ÿÿÿëV‹u…öu$èÿÿÇèuÿÿ€}üt‹Eøƒ`pý¸ÿÿÿëR‹EðƒxuVSèMÿÿÿYYë1+ÞW¶3MðQPèFª‹ø¶MðQPè7ªƒÄF…ÿt;øt×+ø‹Ç_€}üt‹Møƒapý^[ÉËÿU‹ì3À9äúBu'9Eu艀ÿÿÇè†tÿÿ¸ÿÿÿ]Ã9Etä]éÑþÿÿPÿuÿuèþþÿÿƒÄ]ËÿU‹ìƒìÿuMðè«6ÿÿ¶E‹Mð‹‰È·A%€€}üt‹MøƒapýÉËÿU‹ìjÿuè¹ÿÿÿYY]ËÿU‹ìhÿu貪YY]ËÿU‹ìhÿu蜪YY]ËÿU‹ìjÿu艪YY]ËÿU‹ìjÿuèvªYY]ËÿU‹ìjÿuècªYY]ËÿU‹ìjÿuèPªYY]ËÿU‹ìjÿuè=ªYY]ËÿU‹ìjÿuè*ªYY]ËÿU‹ìh€ÿuèªYY]ËÿU‹ìh€ÿuèþ©YY]ËÿU‹ìjÿuèë©YY]ËÿU‹ìjÿuèØ©YY]ËÿU‹ìjÿuèÅ©YY]ËÿU‹ìjÿu販YY]ËÿU‹ìhÿu蜩YY]ËÿU‹ìhÿu膩YY]ËÿU‹ìhWÿuèp©YY]ËÿU‹ìhWÿuèZ©YY]ËÿU‹ìhÿuèD©YY]ËÿU‹ìhÿuè.©YY]ËÿU‹ìj ÿuè©YY]ËÿU‹ìj ÿuè©YY]ËÿU‹ì¸€f9EÀ÷Ø]ËÿU‹ìhÿuèÞ¨YY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìhÿu踨YY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìhÿuè’¨YY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìhÿuèl¨YY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìƒì¡ÈCS3ÛV‹u‰Eü‰]ô‰]ø‰]ðëF€> túŠ tújVhĬBèu³ƒÄ…Àu~ƒÆëF€> tú€>=unF€> tújhȬBVè屃Ä…ÀuƒÆËë?jhЬBVèƱƒÄ…ÀuƒÆËë jhܬBV觱ƒÄ…ÀuƒÆËëF€> tú€>tèa{ÿÿÇè^oÿÿëh€ÿuESÿuPè?¯ƒÄ…Àt3Àë"ÿ”öB‹E‹Mü‰H3ɉH‰‰H‰H‹M‰H_^[ÉÃjh¸ÃBè/­ÿÿ3Û3ÿ‰}äjèâ¬ÿÿY‰]ü3ö‰uà;5 -CÊ¡C°9t[‹‹@¨ƒuH©€uAFýƒøwFPèÞ«ÿÿY…À„”¡Cÿ4°Vè>ÿÿYY¡C‹°ö@ƒtPVèg>ÿÿYYFë‘‹ø‰}äëcj8è&¨ÿÿY‹
C‰±;ÃtNh ¡C‹°ƒÀ Pÿ`1B…À¡Cuÿ4°èñ3ÿÿY¡C‰°ë‹°ƒÀ Pÿ˜1B¡C‹<°‰}ä‰_;ûtg€‰_‰_‰‰_ƒOÿÇEüþÿÿÿè‹ÇèZ¬ÿÿË}äjèÚªÿÿYÃÌÌÌÌÌÌÌÌSVW‹T$‹D$‹L$URPQQh QAdÿ5¡€áB3ĉD$d‰%‹D$0‹X‹L$,3‹pƒþþt;‹T$4ƒúþt;òv.4v\³‹‰Hƒ{uÌh‹Cè"²¹‹Cè4²ë°dƒÄ_^[ËL$÷A¸t3‹D$‹H3ÈèU,ÿÿU‹hÿpÿpÿpè>ÿÿÿƒÄ]‹D$‹T$‰¸ÃU‹L$‹)ÿqÿqÿq(èÿÿÿƒÄ]ÂUVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè±3À3Û3É3Ò3ÿÿæU‹ìSVWjRhFRAQèÑ_^[]ÃU‹l$RQÿt$èµþÿÿƒÄ]‹ÿU‹ìƒì ƒeàWjY3À}äó«_9Euè^xÿÿÇè[lÿÿƒÈÿÉËE…ÀtäVÿu‰Eèÿu‰EàÿuEàPÇEäÿÿÿÇEìBèz¸ÿÿƒÄÿMä‹ðx‹EàÆë
EàPjèÕÈÿÿYY‹Æ^ÉËÿU‹ìÿujÿuÿuègÿÿÿƒÄ]ËÿU‹ìƒì Wj3ÒY3À}ä‰Uàó«_9Uuè¿wÿÿÇè¼kÿÿƒÈÿÉÃÿuEàÿuÇEäÿÿÿÿuÇEìBP‰Uè‰UàÿUƒÄÉËÿU‹ìÿujÿuh<AèÿÿÿƒÄ]ËÿU‹ìÿuÿuÿuh<AèpÿÿÿƒÄ]ËÿU‹ìÿujÿuhÛAèTÿÿÿƒÄ]ËÿU‹ìÿuÿuÿuhÛAè7ÿÿÿƒÄ]ËÿU‹ìƒì SW3Ûj3ÀY}ä‰]àó«9]uèñvÿÿÇèîjÿÿƒÈÿé‹}V‹u;ût;óuèÊvÿÿÇèÇjÿÿƒÈÿëk¸ÿÿÿ‰Eä;øw‰}äÿuEàÿuÇEìBÿu‰uèP‰uàÿUƒÄ‰E;ót5;Ã|"ÿMäx‹EàˆëEàPSè<ÇÿÿYYƒøÿt‹Eë3À9]äˆ\>ÿÀƒè^_[ÉËÿU‹ìÿujÿuÿuÿuh<AèÿÿÿƒÄ…ÀyƒÈÿ]ËÿU‹ìÿuÿuÿuÿuÿuh<AèïþÿÿƒÄ…ÀyƒÈÿ]ËÿU‹ìƒ}uèçuÿÿÇèäiÿÿƒÈÿ]ÃV‹u…ötƒ}w
èÄuÿÿÇë1ÿuÿuÿuÿuVh`ÍAè‘þÿÿƒÄ…Àyƃøþuè‘uÿÿÇ"èŽiÿÿƒÈÿ^]ËÿU‹ìÿujÿuÿuÿuèqÿÿÿƒÄ]ËÿU‹ìƒ}uèSuÿÿÇèPiÿÿƒÈÿ]ÃS‹]V‹uW…Ûu…öu9uu3À骅öt‹}…ÿuèuÿÿÇé‡èuÿÿÿuÿuÿu;ûv*‹8CSVh`ÍAèÖýÿÿƒÄƒøþuGèÝtÿÿƒ8"uYèÓtÿÿ‰8ëP‹WVh`ÍAè­ýÿÿƒÄÆD>ÿƒøþuƒ}ÿuè©tÿÿƒ8"u%èŸtÿÿ‰ë…ÀyƃøþuèŠtÿÿÇ"è‡hÿÿƒÈÿ_^[]ËÿU‹ìÿujÿuÿuÿuÿuèùþÿÿƒÄ]ËÿU‹ìÿujÿuÿuÿuhÛAè&ýÿÿƒÄ…ÀyƒÈÿ]ËÿU‹ìÿuÿuÿuÿuÿuhÛAèüüÿÿƒÄ…ÀyƒÈÿ]ËÿU‹ìV‹u…öuèòsÿÿÇèïgÿÿéú‹F¨ƒ„ï¨@…ç¨tƒÈ ‰Fé؃ȉF©u	VèÆ™Yë‹F‰ÿvÿvVèû¿ÿÿYPè.²ƒÄ‰F…À„‹ƒøÿ„‚öF‚uQVèÑ¿ÿÿYƒøÿt0VèÅ¿ÿÿYƒøþt$WV踿ÿÿÁøV<…àC訿ÿÿƒàYÁàY_ë¸àîBŠ@$‚<‚uN ~u‹F¨t©uÇF‹ÿN¶A‰ë÷ØÀƒàƒÀ	FƒfƒÈÿ^]ÃjhØÃBè¥ÿÿè_ƒÿÿ‹@x…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿèA²è¥ÿÿÃè2ƒÿÿ‹@|…ÀtÿÐé´ÿÿÿjhøÃB踤ÿÿÿ5€Cÿ´1B…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿè}ÿÿÿÌhXAÿØ1B£€CËÿU‹ì‹E£„C£ˆC£ŒC£C]ÃjhÄBèQ¤ÿÿ3ÿWè
¤ÿÿY‰}ü9}u¾„Cÿ5„Cÿ´1B‰EäÇEà뾈Cÿ5ˆCÿ´1B‰EäÇEà;Çtƒøtèm€ÿÿ‰ÇEüþÿÿÿè9}äu3Àë3ÿWè«¢ÿÿYÃ}ätÿuàÿUäY3À@è	¤ÿÿ‹ÿU‹ì‹E‹
´­BV9Pt‹ñköuƒÀ;ÆrìkÉM^;Ás9Pt3À]Ãÿ5ŒCÿ´1BÃèØÿÿƒÀdÃèÏÿÿƒÀ`Ãjh8ÄBè_£ÿÿƒeà‹u‹]ƒþ„ïƒþ„æj_;ß„ǃû„¾ƒû„µƒû„¬ƒû„£ƒûtƒût	ƒû…¤èã€ÿÿ‹ð…ö„•¿­B9~\u'ÿ5°­BèežÿÿY‰F\…À„tÿ5°­BWPè¤ÿÿƒÄÿv\‹ÓèöþÿÿY…À„Q‹H‰Mä‹Mƒù„.ƒÀë‰HƒÀ‹´­BkÒV\xü;úƒ9tßéjè+¢ÿÿYƒeü;ßtƒûu>ƒ=”Cu5jh³XAÿø0B3ÉA;Áu‰
”Cëèpÿÿ‹ðÿ<1B‰ÇEà‹u‹Ã+Çtyƒètƒè	tNƒèt(H…‚ÿ5ŒCÿ´1B‰Eä;÷toVÿØ1B£ŒCëaÿ5ˆCÿ´1B‰Eä;÷tNVÿØ1B£ˆCë@ÿ5Cÿ´1B‰Eä;÷t-VÿØ1B£Cëÿ5„Cÿ´1B‰Eä;÷tVÿØ1B£„CÇEüþÿÿÿèƒ}àu‹Eäë8‹]jè/ ÿÿYÃût$ƒûtƒû
tƒû~ƒû~èoÿÿÇècÿÿƒÈÿèq¡ÿÿÃj hXÄBè¡ÿÿ3ÿ‰}ä‰}Ø‹]ƒûKt‹ÃjY+Át"+Át+ÁtY+ÁuCèÚ~ÿÿ‹ø‰}Ø…ÿuƒÈÿéT¾„C¡„CëUÿw\‹ÓèýÿÿYp‹ëQ‹Ãƒèt2ƒèt!Htè‚nÿÿÇèbÿÿë¹¾ŒC¡ŒC뾈C¡ˆCë
¾C¡CÇEäPÿ´1B‰Eà3Àƒ}à„Ö9EàujèN[ÿÿ9EätPè ÿÿY3À‰Eüƒût
ƒûtƒûu‹O`‰MÔ‰G`ƒûu>‹Od‰MÐÇGdŒƒûu,‹
¨­B‰MÜ‹
¬­B
¨­B9MÜ}‹MÜkÉ‹W\‰DÿEÜëÝèZ|ÿÿ‰ÇEüþÿÿÿèƒûuÿwdSÿUàYë‹]‹}؃}ätj臞ÿÿYÃSÿUàYƒût
ƒûtƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèΟÿÿËÿU‹ì‹E£˜C]ËÿU‹ìQVÿ5˜Cÿ´1B‹ð‹E…Àuè*mÿÿj^‰0è(aÿÿ‹Æ黃 W…ö…hø¬Bÿð0B‰Eü…Àuèölÿÿj^‰0èô`ÿÿ‹Æé†hä¬BPÿ$1B‹ð…öu(èÎlÿÿ‹5<1B‹øÿÖPè|lÿÿY‰è¾`ÿÿÿÖPèllÿÿYëLSVÿØ1B‹øè={ÿÿWh˜C‹Øÿô0B;Ã[t	ÿuüÿX0BjÿuÿÖ…ÀuèplÿÿÇèelÿÿ‹ë3À_^ÉËÿU‹ìì¡€áB3ʼnEüƒ}‹ESVW‹}‰…xÿÿÿ…tÿÿÿh€|ÿÿÿ‹ËQÿuÿuPè̬‹ðƒÄ…öubÿ<1BƒøzuxVVÿuÿuÿµxÿÿÿ襬ƒÄ‰…pÿÿÿ…ÀtXFVPèË™ÿÿ‹ØYY…ÛtHÿµpÿÿÿ‰µtÿÿÿSÿuÿuÿµxÿÿÿèj¬‹ðƒÄ…ötjVè”™ÿÿ‰3ÿYY;Çu!9½tÿÿÿtSè8%ÿÿYƒÈÿ‹Mü_^3Í[è£ÿÿÉÃNÿQSVPèé
ƒÄ…Àu9½tÿÿÿtSè%ÿÿY3ÀëËWWWWWèÚ^ÿÿƒ}uH‹5ì0B3ÀPPÿu‰ÿuÿÖ‹Ø…ÛtjSè™ÿÿYY‰…ÀtSPÿuÿuÿÖ…Àu´ÿ7è°$ÿÿƒ'Yépÿÿÿƒ}…fÿÿÿƒ¥xÿÿÿj…xÿÿÿP‹E
 Pÿuÿì0B…À„<ÿÿÿŠ…xÿÿÿˆécÿÿÿ‹ÿU‹ì‹E£œC]ËÿU‹ìQSV‹5´1BWÿ5CÿÖÿ5üC‹Ø‰]üÿÖ‹ð;ó‚‹þ+ûGƒøruSèZ«‹ØGY;ØsH¸;Øs‹ÃÃ;ÃrPÿuü胘ÿÿYY…ÀuC;Ãr>Pÿuüèm˜ÿÿYY…Àt/ÁÿP4¸ÿØ1B£Cÿu‹=Ø1Bÿ׉ƒÆVÿ×£üC‹Eë3À_^[ÉËÿVjj èÙ—ÿÿYY‹ðVÿØ1B£C£üC…öujX^Ã&3À^ÃjhxÄBèÛ›ÿÿèùSÿÿƒeüÿuèüþÿÿY‰EäÇEüþÿÿÿè	‹Eäè÷›ÿÿÃèØSÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸`¿B¾`¿BW‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸h¿B¾h¿BW‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿÿ·0ïBÿØ1B‰‡0ïBƒÇƒÿ(ræ_^ÃÌÌÌÌÌ‹ÿU‹ì‹M¸MZf9t3À]ËA<Á8PEuï3Ò¹f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öt‹}‹H;ùr	‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh˜ÄBh ý@d¡PƒìSVW¡€áB1Eø3ÅPEðd£‰eèÇEüh@è*ÿÿÿƒÄ…ÀtT‹E-@Ph@èPÿÿÿƒÄ…Àt:‹@$Áè÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹3Ò9À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]ËÿU‹ì‹E‹8csmàu*ƒxu$‹@= “t=!“t="“t=@™uèˆôÿÿ3À]Âh=Àu	ÇFd†ë.=’Àu	ÇFdŠë=µÀu	ÇFdë=´ÀuÇFdŽÿvdjÿÒY‰~dëƒ`QÿÒY‰^`[ƒÈÿ_^]ËÿU‹ì¸csmà9Eu
ÿuPèžþÿÿYY]Ã3À]ËÿVW3ÿ9=Cuèýpÿÿ‹5ðC…öu¾5BŠ< w„Àt.…ÿt$<"u	3É…ÿ”Á‹ù¶ÀPè¨Y…ÀtFFëÓ< wFŠ„Àuõ_‹Æ^Ã=Cuè£pÿÿV‹5ÌöBW3ÿ…öuƒÈÿé‘<=tGVè&”ÿÿYtŠ„ÀuêjGWè“ÿÿ‹øYY‰=¨öB…ÿtË‹5ÌöBSë3Vèõ“ÿÿ€>=YXt"jSèñ’ÿÿYY‰…Àt?VSPè’ÿÿƒÄ…ÀuGƒÇó€>uÈÿ5ÌöBèÿÿƒ%ÌöBƒ'ÇøC3ÀY[_^Ãÿ5¨öBè[ÿÿƒ%¨öBƒÈÿëä3ÀPPPPPè(XÿÿÌ‹ÿU‹ì‹E£¸öB]ËÿU‹ìQ‹MS3ÀV‰‹ò‹UÇ9Et	‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰UŠ¶ÃPFèd§Y…Àtÿƒ}t
‹MŠÿEˆF‹U‹M„Ût2ƒ}üu©€û t€û	uŸ…ÒtÆBÿƒeü€>„éŠ< t<	uFëóNëã€>„Ѓ}t	‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁuƒ}ütF€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰UŠ„ÀtUƒ}üu< tK<	tG…Ût=¾ÀP…Òt#è¦Y…Àt
Š‹MÿEˆFÿ‹MŠÿEˆë
è\¦Y…ÀtFÿÿ‹UFéVÿÿÿ…ÒtÆB‰Uÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒìS3ÛVW9Cuènÿÿh¾ CVSˆ¤Cÿ”0B¡ðC‰5¸öB;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ=ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6Pèÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄH£œöB‰5 öB3ÀëƒÈÿ_^[ÉËÿU‹ìƒìSVÿä0B‹Ø3ö;Þu3Àëwf93tƒÀf90uøƒÀf90uðW‹=Ü1BVVV+ÃVÑø@PSVV‰Eôÿ׉Eø;Æt8Pè†ÿÿY‰Eü;Æt*VVÿuøPÿuôSVVÿ×…ÀuÿuüèeÿÿY‰uüSÿè0B‹Eüë	Sÿè0B3À_^[ÉËÿU‹ìƒì¡€áBƒeøƒeüSW¿Næ@»»ÿÿ;Çt
…Ãt	÷У„áBëeVEøPÿx1B‹uü3uøÿØ0B3ðÿ2B3ðÿÜ0B3ðEðPÿà0B‹Eô3Eð3ð;÷u¾Oæ@»ë…óu‹Æ
GÁàð‰5€áB÷Ö‰5„áB^_[ÉÃ%ÔCËÿU‹ìj
jÿuèÿÿƒÄ]ËÿU‹ìÿuj
jÿuèÿÿƒÄ]ËÿU‹ì]éÆÿÿÿ‹ÿU‹ì]éÑÿÿÿ‹ÿU‹ìj
jÿuè'§ƒÄ]ËÿU‹ìÿuj
jÿuè9§ƒÄ]ËÿU‹ì‹ES3ÛVW9]u;Ãu9]u3À_^[]Ã;Ãt‹};ûwèG`ÿÿj^‰0èETÿÿ‹ÆëÝ9]uˆëÒ‹U;ÓuˆëÙƒ}ÿ‹Èu‹ð+òŠ
ˆB:Ët"Ouóë‹ò+ðŠˆA:ÓtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹MjPˆ\ÿXéxÿÿÿˆèÍ_ÿÿj"Y‰‹ñë‚ÌÌ‹T$‹L$÷Âu<‹:u.
Àt&:au%
ätÁè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ÂtŠƒÂ:uçƒÁ
ÀtÜ÷Ât¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁ눋ÿU‹ìƒ=øCV‹5¨öBu3ÀëcW…öu95°öBtSè[…ÀuJ‹5¨öB…öt@ƒ}t:ÿuèáÿÿY‹øë'PèÖÿÿY;Çv‹€<8=uWÿuPè]ZƒÄ…ÀtƒÆ‹…ÀuÓ3À_^]ËD8ëô‹ÿU‹ìSV‹ð3Û;óuèŸ^ÿÿj^‰0èRÿÿ‹ÆëC‹E‰;Ãt9]wëÝ9]uØ;ÃtˆWÿuè3ÿÿÿ‹øY;ût/WèNÿÿ@Y‰9]t ;Evj"X_^[]ÃWÿuÿuèZ‹ÿÿƒÄ…Àu3ÀëäSSSSSèÅQÿÿÌ‹ÿU‹ìVW‹ø3ö;þuè^ÿÿj^‰0èRÿÿ‹ÆëO‹E‰7;Æt‰09utÝSÿuè³þÿÿ‹ØY;ÞtKSèÎŒÿÿpjVèö¤‰3ÿƒÄ;ÇuèÅ]ÿÿÇèº]ÿÿ‹[_^]ÃSVPèÇŠÿÿƒÄ…Àu
‹E;Çt‰03ÀëßWWWWWè)QÿÿÌjh¸ÄBè®ÿÿ3À9E•À…Àuèo]ÿÿÇèlQÿÿ3Àë?¾ÿVÿuèËŒÿÿYY;ÆÀ÷ØtÔjè0ÿÿYƒeüÿuèúýÿÿY‰EäÇEüþÿÿÿè	‹EäèÿÿÃjèŽÿÿYÃjhØÄBè4ÿÿjèîŽÿÿY3Û‰]ü3À‹};û•À;Ãuèæ\ÿÿj^‰0èäPÿÿ‰uäëj‰‹M;Ët	9]w	;Ëu
9]u3À@ë3À;ÃtÊ;ËtˆÿuèmýÿÿY‹ð;ót0V舋ÿÿY@‰9]t!;Ev	ÇEä"ëVÿuÿu蓉ÿÿƒÄ;Ãu‰]äÇEüþÿÿÿè‹EäèÌŽÿÿÃSSSSSèêOÿÿjèEÿÿYÃjhøÄBègŽÿÿjè!ŽÿÿY3ö‰uü3À‹};þ•À;Æuè\ÿÿj^‰0èPÿÿ‰uäët‰7‹E;Æt‰03À9u•À;ÆtÕÿuè±üÿÿY‹Ø;ÞtÕSèÌŠÿÿpjVèô¢ƒÄ‰3ÿ;ÇuèÃ[ÿÿÇè¸[ÿÿ‹‰EäëSVPèňÿÿƒÄ;Çu!‹E;Çt‰0‰}äÇEüþÿÿÿè‹EäèõÿÿÃWWWWWèOÿÿjènŒÿÿYËÿU‹ìƒìL¡€áB3ʼnEüS3ÛV‹uW‰]Ô‰]ä‰]à‰]؉]܉u´‰]¸9^„F9u P·F0hPE´SPè¿îÿÿƒÄ…À…Êj辈ÿÿj¿€W‰EÔèóˆÿÿjW‰EäèèˆÿÿjW‰Eàè݈ÿÿjh‰EØèΈÿÿƒÄ$‰EÜ9]Ô„9]ä„v;Än9]à„e9]Ø„\‹EÔ‰3À‹M܈@=|òEèPÿvÿä1B…À„2ƒ}è‡(·Eè‰EЃø~.8]ît)EïŠ:Ët ¶xÿ¶Éë‹MÜÆ ¶G;ù~ñƒÀ8XÿuÚ‹EäSSÿvPhÿu܉EÀjSèvƒÄ …À„‹Mà‹EÜSÿv¿ÿWÁQW@PhÿvSèƒÄ$…À„‹EØSÿvWP‹EÜW@PhÿvSèéƒÄ$…À„b‹Eä‹}àˆþ3Òƒ}Ðf‰‹U؉MÄ€ˆ_ˆZˆ‰M¼Š€‰MȈ~U8]îtPMï‰MäŠ:ÓtD¶Iÿ¶Ò‰Mà;Ê(ŒHë‹MÌÿE຀f‰ƒÁ‰MÌ‹Mä¶	9Mà~á‹MäƒÁ‰Mä8Yÿu¶hþˆQPèÿÿj‡PWèÿÿ‹EØjˆQPèôÿÿ‹†ÀƒÄ$;ÃtKPÿì1B…Àu@‹†Ä-þPètÿÿ‹†Ì¿€+ÇPèaÿÿ‹†Ð+ÇPèSÿÿÿ¶ÀèHÿÿƒÄ‹EÔlj†À‹EÀ‰†È‹Eĉ†Ä‹E¼‰†Ì‹Eȉ†Ð‹EЉ†¬ÿuÜèÿÿY‹ÃëoÿuÔèôÿÿÿuäèìÿÿÿuàèäÿÿÿuØèÜÿÿ3ÛƒÄCëË‹†À;ÃtPÿì1B‰žÀ‰žÄdžȸ®BdžÌ@³BdžÐÀ´Bdž¬3À‹Mü_^3Í[èü
ÿÿÉÃèPhÿÿ‹È‹Al;¨íBt‹`ëB…QpuèÍeÿÿ‹€¬Ã‹ÿU‹ì‹E…Àu]éÅÿÿÿ‹‹€¬]Ãèhÿÿ‹È‹Al;¨íBt‹`ëB…Qpuèˆeÿÿ‹@Ãèågÿÿ‹È‹Al;¨íBt‹`ëB…Qpuèbeÿÿ‹@Ãè¿gÿÿ‹È‹Al;¨íBt‹`ëB…QpuèSEôjPè,äÿÿø†„Pj?SEôjPèäÿÿø†ˆPj@SEôjPèþãÿÿø†ŒPjASEôjPèçãÿÿƒÄPø†PjBSEôjPèÍãÿÿø†”PjCSEôjPè¶ãÿÿø†˜Pj(SEôjPèŸãÿÿø†œPj)SEôjPèˆãÿÿƒÄPø† PjÿuüEôjPèlãÿÿø†¤Pj ÿuüEôjPèSãÿÿø†¨PhÿuüEôjPè7ãÿÿø†°Ph	ÿuüEôjPèãÿÿø‹EüƒÄP‰†¬†¼Pj1SEôjPèøâÿÿø†ÀPj2SEôjPèáâÿÿø†ÄPj3SEôjPèÊâÿÿø†ÈPj4SEôjPè³âÿÿƒÄPø†ÌPj5SEôjPè™âÿÿø†ÐPj6SEôjPè‚âÿÿø†¸Pj7SEôjPèkâÿÿø†ØPj*SEôjPèTâÿÿƒÄPø†ÜPj+SEôjPè:âÿÿø†àPj,SEôjPè#âÿÿø†äPj-SEôjPèâÿÿø†èPj.SEôjPèõáÿÿƒÄPø†ìPj/SEôjPèÛáÿÿø†ÔPj0SEôjPèÄáÿÿø†ðPjDSEôjPè­áÿÿø†ôPjESEôjPè–áÿÿƒÄPø†øPjFSEôjPè|áÿÿø†üPjGSEôjPèeáÿÿø†PjHSEôjPèNáÿÿø†PjISEôjPè7áÿÿƒÄPø†PjJSEôjPèáÿÿø†PjKSEôjPèáÿÿø†PjLSEôjPèïàÿÿø†PjMSEôjPèØàÿÿƒÄPø†PjNSEôjPè¾àÿÿø†PjOSjEôPè§àÿÿø† Pj8SEôjPèàÿÿø†$Pj9SEôjPèyàÿÿƒÄPø†(Pj:SEôjPè_àÿÿø†,Pj;SEôjPèHàÿÿø†0PjSEôjPèàÿÿø†<Pj?SEôjPèéßÿÿø†@Pj@SEôjPèÒßÿÿø†DPjASEôjPè»ßÿÿƒÄPø†HPjBSEôjPè¡ßÿÿø†LPjCSEôjPèŠßÿÿø†PPj(SEôjPèsßÿÿø†TPj)Sj[EôSPèZßÿÿƒÄPø†XPjÿuüEôSPè?ßÿÿø†\Pj ÿuüEôSPè'ßÿÿÆ`VhÿuüøEôSPèßÿÿƒÄ<Ç_^[ÉËÿU‹ìV‹u…ö„cÿvèûÿÿÿvèóÿÿÿvèëÿÿÿvèãÿÿÿvèÛÿÿÿvèÓÿÿÿ6èÌÿÿÿv èÄÿÿÿv$è¼ÿÿÿv(è´ÿÿÿv,è¬ÿÿÿv0è¤ÿÿÿv4èœÿÿÿvè”ÿÿÿv8èŒÿÿÿv<è„ÿÿƒÄ@ÿv@èyÿÿÿvDèqÿÿÿvHèiÿÿÿvLèaÿÿÿvPèYÿÿÿvTèQÿÿÿvXèIÿÿÿv\èAÿÿÿv`è9ÿÿÿvdè1ÿÿÿvhè)ÿÿÿvlè!ÿÿÿvpèÿÿÿvtèÿÿÿvxè	ÿÿÿv|èÿÿƒÄ@ÿ¶€èóÿÿÿ¶„èèÿÿÿ¶ˆèÝÿÿÿ¶ŒèÒÿÿÿ¶èÇÿÿÿ¶”è¼ÿÿÿ¶˜è±ÿÿÿ¶œè¦ÿÿÿ¶ è›ÿÿÿ¶¤èÿÿÿ¶¨è…ÿÿÿ¶¼èzÿÿÿ¶Àèoÿÿÿ¶Äèdÿÿÿ¶ÈèYÿÿÿ¶ÌèNÿÿƒÄ@ÿ¶Ðè@ÿÿÿ¶¸è5ÿÿÿ¶Øè*ÿÿÿ¶Üèÿÿÿ¶àèÿÿÿ¶äè	ÿÿÿ¶èèþÿÿÿ¶ìèóÿÿÿ¶Ôèèÿÿÿ¶ðèÝÿÿÿ¶ôèÒÿÿÿ¶øèÇÿÿÿ¶üè¼ÿÿÿ¶è±ÿÿÿ¶è¦ÿÿÿ¶è›ÿÿƒÄ@ÿ¶èÿÿÿ¶è‚ÿÿÿ¶èwÿÿÿ¶èlÿÿÿ¶èaÿÿÿ¶ èVÿÿÿ¶$èKÿÿÿ¶(è@ÿÿÿ¶,è5ÿÿÿ¶0è*ÿÿÿ¶4èÿÿÿ¶8èÿÿÿ¶<è	ÿÿÿ¶@èþÿÿÿ¶Dèóÿÿÿ¶HèèÿÿƒÄ@ÿ¶LèÚÿÿÿ¶PèÏÿÿÿ¶TèÄÿÿÿ¶Xè¹ÿÿÿ¶\è®ÿÿÿ¶`è£ÿÿƒÄ^]ËÿU‹ìSV‹uƒ~ W»hëBtBhdjè¿uÿÿ‹øYY…ÿu3À@ëI‹Æ‹ÏèRôÿÿ…ÀtWèGüÿÿWèUÿÿYYëÞLJ´ë‹û‹†Ô;Ãt´Pÿì1B‰¾Ô3À_^[]Ã2Ò8tSVŠ<0|<9,0ˆA8uí^[Ã<;uô‹ÁŠXˆ@8uöëç‹ÿU‹ìV‹u…ötY‹;ØïBtPèÓÿÿY‹F;ÜïBtPèÁÿÿY‹F;àïBtPè¯ÿÿY‹F0;ðBtPèÿÿY‹v4;5ðBtVè‹ÿÿY^]ËÿU‹ìƒìSV‹uW3ÿ‰uð‰}ô9~u9~u‰}ü‰}ø»ØïBéejPjè’tÿÿ‹ØYY;ßu3À@颋¶¼jY‹ûjó¥è)tÿÿ3ÿY‰Eø;Çu	SèÿÿYëÑ‹u‰89~„ÙjètÿÿY‰Eü;Çu3öFSèñÿþÿÿuøèéÿþÿYY‹ÆéD‰8·v>SjVEðjPè¹Ùÿÿ‹øCPjVEðjPè¥ÙÿÿøCPjVEðjPè‘ÙÿÿøC0PjVEðjPè}ÙÿÿƒÄPøC4PjVEðjPèfÙÿÿƒÄÇtSè{þÿÿYƒÎÿékÿÿÿ‹C늀ù0|€ù9
€é0ˆ@€8uéë>€ù;uó‹ðŠNˆF€>uõëå¡ØïB‰¡ÜïB‰C¡àïB‰C¡ðB‰C0¡ðB‰}ü‰C4‹Mø‹u3À@‰‹Mü…Ét‰‹†´‹=ì1B…ÀtPÿ׋†°…ÀtPÿ×…Àuÿ¶°èÃþþÿÿ¶¼è¸þþÿYY‹Eü‰†´‹Eø‰†°‰ž¼3À_^[ÉÃ2Ò8tSVŠ<0|<9,0ˆA8uí^[Ã<;uô‹ÁŠXˆ@8uöëç‹ÿU‹ìV‹u…ö„ê‹F;äïBtPèEþþÿY‹F;èïBtPè3þþÿY‹F;ìïBtPè!þþÿY‹F;ðïBtPèþþÿY‹F;ôïBtPèýýþÿY‹F ;øïBtPèëýþÿY‹F$;üïBtPèÙýþÿY‹F8;ðBtPèÇýþÿY‹F<;ðBtPèµýþÿY‹F@;ðBtPè£ýþÿY‹FD;ðBtPè‘ýþÿY‹FH; ðBtPèýþÿY‹vL;5$ðBtVèmýþÿY^]ËÿU‹ìƒìSV‹uW3ÿ‰}ü‰uð‰}ô9~u9~u‰}ü‰}ø»ØïBéÐjPjèqqÿÿ‹ØYY;ßu3À@éjèqÿÿY‰Eø;Çu	SèýþÿYëà‰89~„4jèòpÿÿY‰Eü;ÇuSèåüþÿÿuøèÝüþÿYëÒ‰8·v8CPjVEðjPè°Öÿÿ‹øCPjVEðjPèœÖÿÿøCPjVEðjPèˆÖÿÿøCPjVEðjPètÖÿÿƒÄPøCPjVEðjPè]ÖÿÿøC PjPVEðjPèIÖÿÿøC$PjQVEðjPè5ÖÿÿøC(PjVEðjPè!ÖÿÿƒÄPøC)PjVjEðPè
ÖÿÿøC*PjTVEðjPèöÕÿÿøC+PjUVEðjPèâÕÿÿøC,PjVVEðjPèÎÕÿÿƒÄPøC-PjWVEðjPè·ÕÿÿøC.PjRVEðjPè£ÕÿÿøC/PjSVEðjPèÕÿÿøC8PjVEðjPè{ÕÿÿƒÄPøCuõëåjY¾ØïB‹ûó¥‹E‹ˆ¼‹	‰‹ˆ¼‹I‹u‰K‹ˆ¼‹I‰K‹ˆ¼‹I0‰K0‹€¼‹@4‹Mø‰C43À@3ÿ‰9}üt‹Mü‰‹†¸;ÇtPÿì1B‹†°;Çt#Pÿì1B…Àuÿ¶¼è5úþÿÿ¶°è*úþÿYY‹Eü‰†¸‹Eø‰†°‰ž¼3À_^[ÉÃèÛPÿÿ‹Hl;
¨íBt‹
`ëB…HpuèZNÿÿ¡(ðBá0ðBÃè¯Pÿÿ‹È‹Al;¨íBt‹`ëB…Qpuè,Nÿÿ‹€ÈÃ3ÀËÿU‹ì‹MVW…Ét‹}…ÿuèà?ÿÿj^‰0èÞ3ÿÿ‹ÆëA‹U…ÒuÆëá‹ñ€>tFOu÷…ÿtì+òŠˆB„ÀtOuó…ÿuÆèœ?ÿÿj"Y‰‹ñë¸3À_^]ÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹uƒÉÿIƒÁŠ
Àt	ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ì3ÀS3Û@9]|FVW…Àt>‹EÙ+‹ð‹EÑþ<ðÿ7‹Eÿ0èf¾ÿÿYY…Àu
‹MƒÇ‰9ëyN‰uë^;]~¾_^3É…À”Á[‹Á]ÃNÿÌ0B‰F‰FËÿU‹ìQ…ötP€>tKh ½BVèêÞÿÿYY…Àt:hœ½BVèÙÞÿÿYY…ÀujEüPh ÿwÿì0B…Àt)‹EüÉÃVè…ÝÿÿY‰EüëïjEüPh ÿwÿì0B…Àu3ÀÉÃ}üuÍÿð1BÉËÿU‹ì3Àf‹Mf;ˆˆ½Bt
ƒÀƒørë3À@]Ã3À]ËÿV3öë AŸB<w€ÁÙë
A¿<w€Áù¾ÁötðЊ
„ÉuÚ‹Æ^Ã3ÀŠ
B€ùA|€ùZ~€éa€ùw@ëèËÿU‹ìƒì|¡€áB3ʼnEüVW‹}èCNÿÿ‹×‹ðèÿÿÿ‹øjxE„P‹†°÷ØÀ%ðÿÿPWÿÈ0B…Àu	!†¤@ëAE„Pÿ¶ èʼÿÿYY…ÀuWèÿÿÿY…ÀtƒŽ¤‰¾¸‰¾´‹†¤Áè÷Ѓà‹Mü_3Í^èaðþÿÉ‹ÿU‹ìQV‹ðjEüP‹Æ%ÿh 
Pÿì0B…Àu3Àë);uüt!ƒ}t‹E‹0W‹Öè÷þÿÿV‹øèÉkÿÿY;ø_tÖ3À@^ÉËÿU‹ìƒì|¡€áB3ʼnEüSVW‹}è@Mÿÿ‹×°œèˆþÿÿ‹È0B‹øjxE„P‹F÷ØÀ%ðÿÿPWÿÓ…Àuƒf3À@écE„PÿvèÄ»ÿÿYY…À…‘jxE„P‹F÷ØÀ%ðÿÿPWÿÓ…Àt¿E„Pÿ6è»ÿÿYY…ÀuN‰~ëRöFuO‹F…Àt,PE„Pÿ6èJ„ƒÄ…Àuÿ6ƒN‰~èàjÿÿY;Fu!‰~ë‹VöÂuWè—ýÿÿY…Àt	ƒÊ‰V‰~‹N¸#È;È„ŸjxE„P‹F÷ØÀ%ðÿÿPWÿÓ…À„ÿÿÿE„Pÿ6èéºÿÿY3ÛY…Àu0N‹F9^t

‰FëH9^t<ÿ6èLjÿÿY;Fu/Vjë9^u49^t/E„Pÿ6蜺ÿÿYY…ÀuVS‹ÇèþÿÿYY…ÀtN9^u‰~‹FÁè÷Ѓà‹Mü_^3Í[è5îþÿÉ‹ÿU‹ìƒì|¡€áB3ʼnEüVW‹}èpKÿÿ‹×°œè¸üÿÿ‹øjxE„P‹F÷ØÀ%ðÿÿPWÿÈ0B…Àu!F@ë\E„Pÿ6èý¹ÿÿYY…Àu
9Fu1Vjëƒ~u0ƒ~t*E„Pÿ6èÖ¹ÿÿYY…ÀuVP‹Çè?ýÿÿYY…Àt
ƒN‰~‰~‹FÁè÷Ѓà‹Mü_3Í^èuíþÿÉÂÿvè$iÿÿƒè÷ØYÀj@hA‰FÿÄ0BöFuƒfÃÿ6èùhÿÿÿvƒè÷ØÀ@‰Fèæhÿÿƒè÷ØÀƒf@ƒ~YY‰FtjXë‹èéûÿÿjhŽA‰FÿÄ0B‹F©t©t¨uƒfÃÿ6è’hÿÿƒè÷ØÀ@Y‰FtjXë‹èžûÿÿjhäA‰FÿÄ0BöFuƒfËÿU‹ìSVWèðIÿÿ¸œ‹E…ÀuOéɃÀ@_‰t€8tSjhмBèïùÿÿƒÄ‹ƒg…Àt[€8tV‹…Àt€8t	‹÷èõþÿÿë‹÷èSÿÿÿƒ…„Wj@hȺBè«ùÿÿƒÄ…Àtf‹…Ût€;t	‹÷è¼þÿÿëR‹÷èÿÿÿëI‹…Ût0€;t+Sè gÿÿƒè÷ØYÀj@hA‰GÿÄ0BöGuƒgëÇGÿÌ0B‰G‰Gƒ„ë‹u‹Æƒè€÷Þö#ðè—ùÿÿ‹ð‰u…ö„Ëþèý„¿þéý„³·ÆPÿø1B…À„¡jÿwÿÀ0B…À„Ž‹E…Àtf‹Of‰f‹Of‰Hf‰p‹]…Ûth‹5È0B¹f9u h¤½Bj@SèñdÿÿƒÄ…Àt3ÀPPPPPè^+ÿÿj@ShÿwÿÖ…Àt,j@C@PhÿwÿÖ…Àtj
jƒë€SÿuèÝ€ƒÄ3À@ë3À_^[]Ã…Àt3É…ÀŸÁD	ÿö¶	+Át3É…ÀŸÁD	ÿÃf‹f;t1¶¶À+Ât3Ò…ÀŸÂDÿ…Àu¶F¶I+Át3É…ÀŸÁD	ÿÃ3ÀË;tg¶¶À+Ât3Ò…ÀŸÂDÿ…ÀuP¶F¶Q+Ât3Ò…ÀŸÂDÿ…Àu5¶F¶Q+Ât3Ò…ÀŸÂDÿ…Àu¶F¶I+Át3É…ÀŸÁD	ÿÃ3ÀËÿVW‹øéN‹;tv¶ð¶+ðt3À…öŸÀDÿ…À…ô¶q¶B+ðt3À…öŸÀDÿ…À…Õ¶q¶B+ðt3À…öŸÀDÿ…À…¶¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…‘‹A;Btw¶ð¶B+ðt3À…öŸÀDÿ…À…k¶q¶B+ðt3À…öŸÀDÿ…À…L¶q¶B+ðt3À…öŸÀDÿ…À…-¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…‹A;Btw¶ð¶B+ðt3À…öŸÀDÿ…À…â¶q	¶B	+ðt3À…öŸÀDÿ…À…öq
¶B
+ðt3À…öŸÀDÿ…À…¤¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…‹A;Btw¶ð¶B+ðt3À…öŸÀDÿ…À…Y¶q
¶B
+ðt3À…öŸÀDÿ…À…:¶q¶B+ðt3À…öŸÀDÿ…À…¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…ö‹A;Btw¶ð¶B+ðt3À…öŸÀDÿ…À…жq¶B+ðt3À…öŸÀDÿ…À…±¶q¶B+ðt3À…öŸÀDÿ…À…’¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…m‹A;Btw¶ð¶B+ðt3À…öŸÀDÿ…À…G¶q¶B+ðt3À…öŸÀDÿ…À…(¶q¶B+ðt3À…öŸÀDÿ…À…	¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…ä‹A;Btw¶ð¶B+ðt3À…öŸÀDÿ…À…¾¶q¶B+ðt3À…öŸÀDÿ…À…Ÿ¶q¶B+ðt3À…öŸÀDÿ…À…€¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…[‹A;Btw¶ð¶B+ðt3À…öŸÀDÿ…À…5¶q¶B+ðt3À…öŸÀDÿ…À…¶q¶B+ðt3À…öŸÀDÿ…À…÷¶q¶B+ðt3À…öŸÀtÿ‹Æë3À…À…ÒƒÁ ƒÂ ƒï ƒÿ ƒ©ûÿÿÏ׃ÿ‡±ÿ$½þ§A‹Aä;Bätx¶Bä¶qä+ðt3À…öŸÀDÿ…À……¶qå¶Bå+ðt3À…öŸÀDÿ…À…f¶qæ¶Bæ+ðt3À…öŸÀDÿ…À…G¶qç¶Bç+ðt3À…öŸÀtÿ‹Æë3À…À…"‹Aè;Bètw¶ð¶Bè+ðt3À…öŸÀDÿ…À…ü¶qé¶Bé+ðt3À…öŸÀDÿ…À…ݶqê¶Bê+ðt3À…öŸÀDÿ…À…¾¶që¶Bë+ðt3À…öŸÀtÿ‹Æë3À…À…™‹Aì;Bìtw¶ð¶Bì+ðt3À…öŸÀDÿ…À…s¶qí¶Bí+ðt3À…öŸÀDÿ…À…T¶qî¶Bî+ðt3À…öŸÀDÿ…À…5¶qï¶Bï+ðt3À…öŸÀtÿ‹Æë3À…À…‹Að;Bðtw¶ð¶Bð+ðt3À…öŸÀDÿ…À…ê¶qñ¶Bñ+ðt3À…öŸÀDÿ…À…˶qò¶Bò+ðt3À…öŸÀDÿ…À…¬¶qó¶Bó+ðt3À…öŸÀtÿ‹Æë3À…À…‡‹Aô;Bôtw¶ð¶Bô+ðt3À…öŸÀDÿ…À…a¶qõ¶Bõ+ðt3À…öŸÀDÿ…À…B¶qö¶Bö+ðt3À…öŸÀDÿ…À…#¶q÷¶B÷+ðt3À…öŸÀtÿ‹Æë3À…À…þ‹Aø;Bøtw¶ð¶Bø+ðt3À…öŸÀDÿ…À…ضqù¶Bù+ðt3À…öŸÀDÿ…À…¹¶qú¶Bú+ðt3À…öŸÀDÿ…À…š¶qû¶Bû+ðt3À…öŸÀtÿ‹Æë3À…Àuy‹Aü;Büti¶ð¶Bü+ðt3À…öŸÀDÿ…ÀuW¶qý¶Bý+ðt3À…öŸÀDÿ…Àu<¶qþ¶Bþ+ðt3À…öŸÀDÿ…Àu!¶Aÿ¶Jÿ+Át3É…ÀŸÁD	ÿë3À…Àu3À_^ËAã;Bãtk¶ð¶Bã+ðt3À…öŸÀDÿ…ÀuÛ¶qä¶Bä+ðt3À…öŸÀDÿ…ÀuÀ¶qå¶Bå+ðt3À…öŸÀDÿ…Àu¥¶qæ¶Bæ+ðt3À…öŸÀtÿ‹Æë3À…Àu„‹Aç;Bçtx¶Bç¶qç+ðt3À…öŸÀDÿ…À…]ÿÿÿ¶qè¶Bè+ðt3À…öŸÀDÿ…À…>ÿÿÿ¶qé¶Bé+ðt3À…öŸÀDÿ…À…ÿÿÿ¶qê¶Bê+ðt3À…öŸÀtÿ‹Æë3À…À…úþÿÿ‹Aë;Bëtw¶ð¶Bë+ðt3À…öŸÀDÿ…À…Ôþÿÿ¶qì¶Bì+ðt3À…öŸÀDÿ…À…µþÿÿ¶qí¶Bí+ðt3À…öŸÀDÿ…À…–þÿÿ¶qî¶Bî+ðt3À…öŸÀtÿ‹Æë3À…À…qþÿÿ‹Aï;Bïtw¶ð¶Bï+ðt3À…öŸÀDÿ…À…Kþÿÿ¶qð¶Bð+ðt3À…öŸÀDÿ…À…,þÿÿ¶qñ¶Bñ+ðt3À…öŸÀDÿ…À…
þÿÿ¶qò¶Bò+ðt3À…öŸÀtÿ‹Æë3À…À…èýÿÿ‹Aó;Bótw¶ð¶Bó+ðt3À…öŸÀDÿ…À…Âýÿÿ¶qô¶Bô+ðt3À…öŸÀDÿ…À…£ýÿÿ¶qõ¶Bõ+ðt3À…öŸÀDÿ…À…„ýÿÿ¶qö¶Bö+ðt3À…öŸÀtÿ‹Æë3À…À…_ýÿÿ‹A÷;B÷tw¶ð¶B÷+ðt3À…öŸÀDÿ…À…9ýÿÿ¶qø¶Bø+ðt3À…öŸÀDÿ…À…ýÿÿ¶qù¶Bù+ðt3À…öŸÀDÿ…À…ûüÿÿ¶qú¶Bú+ðt3À…öŸÀtÿ‹Æë3À…À…Öüÿÿ‹Aû;Bûtw¶ð¶Bû+ðt3À…öŸÀDÿ…À…°üÿÿ¶qü¶Bü+ðt3À…öŸÀDÿ…À…‘üÿÿ¶qý¶Bý+ðt3À…öŸÀDÿ…À…rüÿÿ¶qþ¶Bþ+ðt3À…öŸÀtÿ‹Æë3À…À…Müÿÿ¶Aÿ¶Jÿ+Á„=üÿÿ3É…ÀŸÁD	ÿé-üÿÿ‹Aâ;Bâtw¶ð¶Bâ+ðt3À…öŸÀDÿ…À…üÿÿ¶qã¶Bã+ðt3À…öŸÀDÿ…À…èûÿÿ¶qä¶Bä+ðt3À…öŸÀDÿ…À…Éûÿÿ¶qå¶Bå+ðt3À…öŸÀtÿ‹Æë3À…À…¤ûÿÿ‹Aæ;Bætx¶Bæ¶qæ+ðt3À…öŸÀDÿ…À…}ûÿÿ¶qç¶Bç+ðt3À…öŸÀDÿ…À…^ûÿÿ¶qè¶Bè+ðt3À…öŸÀDÿ…À…?ûÿÿ¶qé¶Bé+ðt3À…öŸÀtÿ‹Æë3À…À…ûÿÿ‹Aê;Bêtw¶ð¶Bê+ðt3À…öŸÀDÿ…À…ôúÿÿ¶që¶Bë+ðt3À…öŸÀDÿ…À…Õúÿÿ¶qì¶Bì+ðt3À…öŸÀDÿ…À…¶úÿÿ¶qí¶Bí+ðt3À…öŸÀtÿ‹Æë3À…À…‘úÿÿ‹Aî;Bîtw¶ð¶Bî+ðt3À…öŸÀDÿ…À…kúÿÿ¶qï¶Bï+ðt3À…öŸÀDÿ…À…Lúÿÿ¶qð¶Bð+ðt3À…öŸÀDÿ…À…-úÿÿ¶qñ¶Bñ+ðt3À…öŸÀtÿ‹Æë3À…À…úÿÿ‹Aò;Bòtw¶ð¶Bò+ðt3À…öŸÀDÿ…À…âùÿÿ¶qó¶Bó+ðt3À…öŸÀDÿ…À…Ãùÿÿ¶qô¶Bô+ðt3À…öŸÀDÿ…À…¤ùÿÿ¶qõ¶Bõ+ðt3À…öŸÀtÿ‹Æë3À…À…ùÿÿ‹Aö;Bötw¶ð¶Bö+ðt3À…öŸÀDÿ…À…Yùÿÿ¶q÷¶B÷+ðt3À…öŸÀDÿ…À…:ùÿÿ¶qø¶Bø+ðt3À…öŸÀDÿ…À…ùÿÿ¶qù¶Bù+ðt3À…öŸÀtÿ‹Æë3À…À…öøÿÿ‹Aú;Bútw¶ð¶Bú+ðt3À…öŸÀDÿ…À…Ðøÿÿ¶qû¶Bû+ðt3À…öŸÀDÿ…À…±øÿÿ¶qü¶Bü+ðt3À…öŸÀDÿ…À…’øÿÿ¶qý¶Bý+ðt3À…öŸÀtÿ‹Æë3À…À…møÿÿf‹Aþf;Bþ„]øÿÿéß‹Aá;Bátx¶Bá¶qá+ðt3À…öŸÀDÿ…À…3øÿÿ¶qâ¶Bâ+ðt3À…öŸÀDÿ…À…øÿÿ¶qã¶Bã+ðt3À…öŸÀDÿ…À…õ÷ÿÿ¶qä¶Bä+ðt3À…öŸÀtÿ‹Æë3À…À…Ð÷ÿÿ‹Aå;Båtw¶ð¶Bå+ðt3À…öŸÀDÿ…À…ª÷ÿÿ¶qæ¶Bæ+ðt3À…öŸÀDÿ…À…‹÷ÿÿ¶qç¶Bç+ðt3À…öŸÀDÿ…À…l÷ÿÿ¶qè¶Bè+ðt3À…öŸÀtÿ‹Æë3À…À…G÷ÿÿ‹Aé;Bétw¶ð¶Bé+ðt3À…öŸÀDÿ…À…!÷ÿÿ¶qê¶Bê+ðt3À…öŸÀDÿ…À…÷ÿÿ¶që¶Bë+ðt3À…öŸÀDÿ…À…ãöÿÿ¶qì¶Bì+ðt3À…öŸÀtÿ‹Æë3À…À…¾öÿÿ‹Aí;Bítw¶ð¶Bí+ðt3À…öŸÀDÿ…À…˜öÿÿ¶qî¶Bî+ðt3À…öŸÀDÿ…À…yöÿÿ¶qï¶Bï+ðt3À…öŸÀDÿ…À…Zöÿÿ¶qð¶Bð+ðt3À…öŸÀtÿ‹Æë3À…À…5öÿÿ‹Añ;Bñtw¶ð¶Bñ+ðt3À…öŸÀDÿ…À…öÿÿ¶qò¶Bò+ðt3À…öŸÀDÿ…À…ðõÿÿ¶qó¶Bó+ðt3À…öŸÀDÿ…À…Ñõÿÿ¶qô¶Bô+ðt3À…öŸÀtÿ‹Æë3À…À…¬õÿÿ‹Aõ;Bõtw¶ð¶Bõ+ðt3À…öŸÀDÿ…À…†õÿÿ¶qö¶Bö+ðt3À…öŸÀDÿ…À…gõÿÿ¶q÷¶B÷+ðt3À…öŸÀDÿ…À…Hõÿÿ¶qø¶Bø+ðt3À…öŸÀtÿ‹Æë3À…À…#õÿÿ‹Aù;Bùtw¶ð¶Bù+ðt3À…öŸÀDÿ…À…ýôÿÿ¶qú¶Bú+ðt3À…öŸÀDÿ…À…Þôÿÿ¶qû¶Bû+ðt3À…öŸÀDÿ…À…¿ôÿÿ¶qü¶Bü+ðt3À…öŸÀtÿ‹Æë3À…À…šôÿÿ¶qý¶Bý+ðt3À…öŸÀDÿ…À…{ôÿÿ¶qþ¶Bþ+ð„øÿÿ3À…öŸÀDÿéøÿÿVœA Aë£A¾§Aß›A‚ŸAb£A5§AZ›AùžAÙ¢A¬¦AÑšApžAP¢A#¦AHšAçAÇ¡Aš¥A¿™A^A>¡A¥A6™AÔœA´ Aˆ¤A¬˜A[œA+ Aþ£A‹ÿU‹ìVW‹}‹Çƒè„·H„ŸH„lH„!H„™‹M‹ESj Zé2‹0;1tt¶0¶+ót3Û…öŸÃtÿ…ö…+¶p¶Y+ót3Û…öŸÃtÿ…ö…¶p¶Y+ót3Û…öŸÃtÿ…ö…í¶p¶Y+ót3Û…öŸÃtÿë3ö…ö…Ê‹p;qtv¶p¶Y+ót3Û…öŸÃtÿ…ö…£¶p¶Y+ót3Û…öŸÃtÿ…ö…„¶p¶Y+ót3Û…öŸÃtÿ…ö…e¶p¶Y+ót3Û…öŸÃtÿë3ö…ö…B‹p;qtv¶p¶Y+ót3Û…öŸÃtÿ…ö…¶p	¶Y	+ót3Û…öŸÃtÿ…ö…ü¶p
¶Y
+ót3Û…öŸÃtÿ…ö…ݶp¶Y+ót3Û…öŸÃtÿë3ö…ö…º‹p;qtv¶p¶Y+ót3Û…öŸÃtÿ…ö…“¶p
¶Y
+ót3Û…öŸÃtÿ…ö…t¶p¶Y+ót3Û…öŸÃtÿ…ö…U¶p¶Y+ót3Û…öŸÃtÿë3ö…ö…2‹p;qtv¶Y¶p+ót3Û…öŸÃtÿ…ö…¶p¶Y+ót3Û…öŸÃtÿ…ö…ì¶p¶Y+ót3Û…öŸÃtÿ…ö…Ͷp¶Y+ót3Û…öŸÃtÿë3ö…ö…ª‹p;qtv¶p¶Y+ót3Û…öŸÃtÿ…ö…ƒ¶p¶Y+ót3Û…öŸÃtÿ…ö…d¶p¶Y+ót3Û…öŸÃtÿ…ö…E¶p¶Y+ót3Û…öŸÃtÿë3ö…ö…"‹p;qtv¶p¶Y+ót3Û…öŸÃtÿ…ö…û¶p¶Y+ót3Û…öŸÃtÿ…ö…ܶp¶Y+ót3Û…öŸÃtÿ…ö…½¶p¶Y+ót3Û…öŸÃtÿë3ö…ö…š‹p;qtj¶p¶Y+ót3Û…öŸÃtÿ…öuw¶p¶Y+ót3Û…öŸÃtÿ…öu\¶p¶Y+ót3Û…öŸÃtÿ…öuA¶p¶Y+ót3Û…öŸÃtÿë3ö…öu"ÂÊ+ú;úƒÆûÿÿÇσÿ‡¤ÿ$½R½A‹Æ阋Pä;Qäti¶ò¶Qä+òt3Ò…öŸÂtÿ…öu׶på¶Qå+òt3Ò…öŸÂtÿ…öu¼¶pæ¶Qæ+òt3Ò…öŸÂtÿ…öu¡¶pç¶Qç+òt3Ò…öŸÂtÿë3ö…öu‚‹Pè;Qètu¶ò¶Qè+òt3Ò…öŸÂtÿ…ö…\ÿÿÿ¶pé¶Qé+òt3Ò…öŸÂtÿ…ö…=ÿÿÿ¶pê¶Qê+òt3Ò…öŸÂtÿ…ö…ÿÿÿ¶pë¶Që+òt3Ò…öŸÂtÿë3ö…ö…ûþÿÿ‹Pì;Qìtu¶ò¶Qì+òt3Ò…öŸÂtÿ…ö…Õþÿÿ¶pí¶Qí+òt3Ò…öŸÂtÿ…ö…¶þÿÿ¶pî¶Qî+òt3Ò…öŸÂtÿ…ö…—þÿÿ¶pï¶Qï+òt3Ò…öŸÂtÿë3ö…ö…tþÿÿ‹Pð;Qðtu¶ò¶Qð+òt3Ò…öŸÂtÿ…ö…Nþÿÿ¶pñ¶Qñ+òt3Ò…öŸÂtÿ…ö…/þÿÿ¶pò¶Qò+òt3Ò…öŸÂtÿ…ö…þÿÿ¶pó¶Qó+òt3Ò…öŸÂtÿë3ö…ö…íýÿÿ‹Pô;Qôtv¶Qô¶pô+òt3Ò…öŸÂtÿ…ö…Æýÿÿ¶põ¶Qõ+òt3Ò…öŸÂtÿ…ö…§ýÿÿ¶pö¶Qö+òt3Ò…öŸÂtÿ…ö…ˆýÿÿ¶p÷¶Q÷+òt3Ò…öŸÂtÿë3ö…ö…eýÿÿ‹Pø;Qøtu¶ò¶Qø+òt3Ò…öŸÂtÿ…ö…?ýÿÿ¶pù¶Qù+òt3Ò…öŸÂtÿ…ö… ýÿÿ¶pú¶Qú+òt3Ò…öŸÂtÿ…ö…ýÿÿ¶pû¶Qû+òt3Ò…öŸÂtÿë3ö…ö…Þüÿÿ‹Pü;Qütm¶ò¶Qü+òt3Ò…öŸÂTÿ…Òu6¶pý¶Qý+òt3Ò…öŸÂTÿ…Òu¶pþ¶Qþ+òt3Ò…öŸÂTÿ…Òt‹Âë¶@ÿ¶Iÿ+Át3É…ÀŸÁD	ÿë3À…Àu3À[é›‹Pã;Qãtu¶ò¶Qã+òt3Ò…öŸÂtÿ…ö…5üÿÿ¶pä¶Qä+òt3Ò…öŸÂtÿ…ö…üÿÿ¶på¶Qå+òt3Ò…öŸÂtÿ…ö…÷ûÿÿ¶pæ¶Qæ+òt3Ò…öŸÂtÿë3ö…ö…Ôûÿÿ‹Pç;Qçtu¶ò¶Qç+òt3Ò…öŸÂtÿ…ö…®ûÿÿ¶pè¶Qè+òt3Ò…öŸÂtÿ…ö…ûÿÿ¶pé¶Qé+òt3Ò…öŸÂtÿ…ö…pûÿÿ¶pê¶Qê+òt3Ò…öŸÂtÿë3ö…ö…Mûÿÿ‹Pë;Qëtu¶ò¶Që+òt3Ò…öŸÂtÿ…ö…'ûÿÿ¶pì¶Qì+òt3Ò…öŸÂtÿ…ö…ûÿÿ¶pí¶Qí+òt3Ò…öŸÂtÿ…ö…éúÿÿ¶pî¶Qî+òt3Ò…öŸÂtÿë3ö…ö…Æúÿÿ‹Pï;Qïtu¶ò¶Qï+òt3Ò…öŸÂtÿ…ö… úÿÿ¶pð¶Qð+òt3Ò…öŸÂtÿ…ö…úÿÿ¶pñ¶Qñ+òt3Ò…öŸÂtÿ…ö…búÿÿ¶pò¶Qò+òt3Ò…öŸÂtÿë3ö…ö…?úÿÿ‹Pó;Qótu¶ò¶Qó+òt3Ò…öŸÂtÿ…ö…úÿÿ¶pô¶Qô+òt3Ò…öŸÂtÿ…ö…úùÿÿ¶põ¶Qõ+òt3Ò…öŸÂtÿ…ö…Ûùÿÿ¶pö¶Qö+òt3Ò…öŸÂtÿë3ö…ö…¸ùÿÿ‹P÷;Q÷tv¶Q÷¶p÷+òt3Ò…öŸÂtÿ…ö…‘ùÿÿ¶pø¶Qø+òt3Ò…öŸÂtÿ…ö…rùÿÿ¶pù¶Qù+òt3Ò…öŸÂtÿ…ö…Sùÿÿ¶pú¶Qú+òt3Ò…öŸÂtÿë3ö…ö…0ùÿÿ‹Pû;Qûtu¶ò¶Qû+òt3Ò…öŸÂtÿ…ö…
ùÿÿ¶pü¶Qü+òt3Ò…öŸÂtÿ…ö…ëøÿÿ¶pý¶Qý+òt3Ò…öŸÂtÿ…ö…Ìøÿÿ¶pþ¶Qþ+òt3Ò…öŸÂtÿë3ö…ö…©øÿÿ¶Iÿ¶@ÿ+Á„8üÿÿ3É…ÀŸÁD	ÿé(üÿÿ‹Pâ;Qâtu¶ò¶Qâ+òt3Ò…öŸÂtÿ…ö…cøÿÿ¶pã¶Qã+òt3Ò…öŸÂtÿ…ö…Døÿÿ¶pä¶Qä+òt3Ò…öŸÂtÿ…ö…%øÿÿ¶på¶Qå+òt3Ò…öŸÂtÿë3ö…ö…øÿÿ‹Pæ;Qætu¶ò¶Qæ+òt3Ò…öŸÂtÿ…ö…Ü÷ÿÿ¶pç¶Qç+òt3Ò…öŸÂtÿ…ö…½÷ÿÿ¶pè¶Qè+òt3Ò…öŸÂtÿ…ö…ž÷ÿÿ¶pé¶Qé+òt3Ò…öŸÂtÿë3ö…ö…{÷ÿÿ‹Pê;Qêtu¶ò¶Qê+òt3Ò…öŸÂtÿ…ö…U÷ÿÿ¶pë¶Që+òt3Ò…öŸÂtÿ…ö…6÷ÿÿ¶pì¶Qì+òt3Ò…öŸÂtÿ…ö…÷ÿÿ¶pí¶Qí+òt3Ò…öŸÂtÿë3ö…ö…ôöÿÿ‹Pî;Qîtu¶ò¶Qî+òt3Ò…öŸÂtÿ…ö…Îöÿÿ¶pï¶Qï+òt3Ò…öŸÂtÿ…ö…¯öÿÿ¶pð¶Qð+òt3Ò…öŸÂtÿ…ö…öÿÿ¶pñ¶Qñ+òt3Ò…öŸÂtÿë3ö…ö…möÿÿ‹Pò;Qòtu¶ò¶Qò+òt3Ò…öŸÂtÿ…ö…Göÿÿ¶pó¶Qó+òt3Ò…öŸÂtÿ…ö…(öÿÿ¶pô¶Qô+òt3Ò…öŸÂtÿ…ö…	öÿÿ¶põ¶Qõ+òt3Ò…öŸÂtÿë3ö…ö…æõÿÿ‹Pö;Qötv¶Qö¶pö+òt3Ò…öŸÂtÿ…ö…¿õÿÿ¶Q÷¶p÷+òt3Ò…öŸÂtÿ…ö… õÿÿ¶Qø¶pø+òt3Ò…öŸÂtÿ…ö…õÿÿ¶Qù¶pù+òt3Ò…öŸÂtÿë3ö…ö…^õÿÿ‹Pú;Qútu¶ò¶Qú+òt3Ò…öŸÂtÿ…ö…8õÿÿ¶pû¶Qû+òt3Ò…öŸÂtÿ…ö…õÿÿ¶pü¶Qü+òt3Ò…öŸÂtÿ…ö…úôÿÿ¶pý¶Qý+òt3Ò…öŸÂtÿë3ö…ö…×ôÿÿf‹Pþf;Qþ„føÿÿ¶Qþ¶pþ+ò„üÿÿ3Ò…öŸÂTÿ…Ò…Ûéøûÿÿ‹Pá;Qátv¶Qá¶pá+òt3Ò…öŸÂtÿ…ö…zôÿÿ¶pâ¶Qâ+òt3Ò…öŸÂtÿ…ö…[ôÿÿ¶pã¶Qã+òt3Ò…öŸÂtÿ…ö…<ôÿÿ¶pä¶Qä+òt3Ò…öŸÂtÿë3ö…ö…ôÿÿ‹På;Qåtu¶ò¶Qå+òt3Ò…öŸÂtÿ…ö…óóÿÿ¶pæ¶Qæ+òt3Ò…öŸÂtÿ…ö…Ôóÿÿ¶pç¶Qç+òt3Ò…öŸÂtÿ…ö…µóÿÿ¶pè¶Qè+òt3Ò…öŸÂtÿë3ö…ö…’óÿÿ‹Pé;Qétu¶ò¶Qé+òt3Ò…öŸÂtÿ…ö…lóÿÿ¶pê¶Qê+òt3Ò…öŸÂtÿ…ö…Móÿÿ¶pë¶Që+òt3Ò…öŸÂtÿ…ö….óÿÿ¶pì¶Qì+òt3Ò…öŸÂtÿë3ö…ö…óÿÿ‹Pí;Qítu¶ò¶Qí+òt3Ò…öŸÂtÿ…ö…åòÿÿ¶pî¶Qî+òt3Ò…öŸÂtÿ…ö…Æòÿÿ¶pï¶Qï+òt3Ò…öŸÂtÿ…ö…§òÿÿ¶pð¶Qð+òt3Ò…öŸÂtÿë3ö…ö…„òÿÿ‹Pñ;Qñtv¶Qñ¶pñ+òt3Ò…öŸÂtÿ…ö…]òÿÿ¶pò¶Qò+òt3Ò…öŸÂtÿ…ö…>òÿÿ¶pó¶Qó+òt3Ò…öŸÂtÿ…ö…òÿÿ¶pô¶Qô+òt3Ò…öŸÂtÿë3ö…ö…üñÿÿ‹Põ;Qõtu¶ò¶Qõ+òt3Ò…öŸÂtÿ…ö…Öñÿÿ¶pö¶Qö+òt3Ò…öŸÂtÿ…ö…·ñÿÿ¶p÷¶Q÷+òt3Ò…öŸÂtÿ…ö…˜ñÿÿ¶pø¶Qø+òt3Ò…öŸÂtÿë3ö…ö…uñÿÿ‹Pù;Qùtu¶ò¶Qù+òt3Ò…öŸÂtÿ…ö…Oñÿÿ¶pú¶Qú+òt3Ò…öŸÂtÿ…ö…0ñÿÿ¶pû¶Qû+òt3Ò…öŸÂtÿ…ö…ñÿÿ¶pü¶Qü+òt3Ò…öŸÂtÿë3ö…ö…îðÿÿ¶pý¶Qý+ò„üÿÿ3Ò…öŸÂTÿ…Ò„üÿÿ‹Âécôÿÿ‹M‹u¶¶+Ât3Ò…ÀŸÂDÿ…À…á¶A¶V+Ât3Ò…ÀŸÂDÿ…À…¶A¶V+Ât3Ò…ÀŸÂDÿ…À…£¶A¶N+Á„“3É…ÀŸÁD	ÿ郋M‹u¶¶+Ât3Ò…ÀŸÂDÿ…Àud¶A¶V+Ât3Ò…ÀŸÂDÿ…ÀuI¶A¶N뤋M‹u¶¶+Ât3Ò…ÀŸÂDÿ…Àu ¶A¶Néxÿÿÿ‹E‹M¶¶	égÿÿÿ3À_^]Ëÿ©°Ac´A5¸A¼A.°AܳA®·A—»A§¯AT³A&·A»A¯AͲAŸ¶AˆºA˜®AF²A¶AºA®A¿±A‘µAz¹AŠ­A8±A
µAó¸A­A±°Aƒ´Ak¸AÌÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹u‹ÿŠ
ÀtƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìƒì$¡€áB3ʼnEü‹ES‰Eà‹EVW‰Eäè=ÿÿƒeìƒ=°C‰Eèu}h¾Bÿð0B‹Ø…Û„‹=$1Bh¾BSÿ×…À„ú‹5Ø1BPÿÖh¾BS£°Cÿ×PÿÖhì½BS£´Cÿ×PÿÖhнBS£¸Cÿ×PÿÖ£ÀC…Àth¸½BSÿ×PÿÖ£¼C¡¼C‹Mè‹5´1B;ÁtG9
ÀCt?PÿÖÿ5ÀC‹øÿÖ‹Ø…ÿt,…Ût(ÿ×…ÀtMÜQjMðQjPÿÓ…ÀtöEøu	M ë3¡´C;Eèt)PÿÖ…Àt"ÿЉEì…Àt¡¸C;EètPÿÖ…ÀtÿuìÿЉEìÿ5°CÿÖ…ÀtÿuÿuäÿuàÿuìÿÐë3À‹Mü_^3Í[苾þÿÉËÿU‹ìV‹uW…öt‹}…ÿuè<ÿÿj^‰0è:ÿþÿ‹Æ_^]ËM…Éu3Àf‰ëÝ‹Öfƒ:tƒÂOuô…ÿtç+Ñ·f‰
ƒÁf…ÀtOuî3À…ÿuÂf‰èê
ÿÿj"Y‰‹ñ몋ÿU‹ì‹US‹]VW…Ûu…Òu9Uu3À_^[]Ã…Òt‹}…ÿuè¯
ÿÿj^‰0è­þþÿ‹ÆëÝ…Ûu3Àf‰ëЋM…Éu3Àf‰ëԋƒûÿu‹ò+ñ·f‰ƒÁf…Àt'Ouîë"‹ñ+ò·f‰ƒÀf…ÉtOtKuë…Ûu3Éf‰…ÿ…yÿÿÿ3Àƒûÿu‹MjPf‰DJþXédÿÿÿf‰è 
ÿÿj"Y‰‹ñéjÿÿÿ‹ÿU‹ìV‹uW…öt‹}…ÿuèú	ÿÿj^‰0èøýþÿ‹Æ_^]ËE…Àuf‰ëß‹Ö+зf‰ƒÀf…ÉtOuî3À…ÿuÔf‰èº	ÿÿj"Y‰‹ñ뼋ÿU‹ì‹M…Éxƒù~ƒùu¡ÔöB]áÔöB‰
ÔöB]Ãè‚	ÿÿÇèýþÿƒÈÿ]ËÿU‹ì‹E£äB]ËÿU‹ìƒìS‹]…Ûu3Àéƒ}uèA	ÿÿÇè>ýþÿ¸ÿÿÿéæV‹u…öuè	ÿÿÇèýþÿ¸ÿÿÿéÃW¿ÿÿÿ;ßvèûÿÿÇèøüþÿéÿuMðèC¿þÿ‹Eð‹@…ÀuJ‹U+Ö·2ƒøAr
ƒøZwƒÀ ·Èë‹È·ƒøArƒøZwƒÀ ·ÀƒÆKt
f…Étf;ÈtŷзÁ+Âë7SVSÿuhPèvSƒÄ…Àuèoÿÿ€}üÇt‹Eøƒ`pý‹ÇëƒÀþ€}üt‹Møƒapý_^[ÉËÿU‹ìƒ=äúBV…‘ƒ}uè%ÿÿÇè"üþÿ¸ÿÿÿé„‹M…Étß¾ÿÿÿ9uvèúÿÿÇè÷ûþÿ‹Æë_‹u+ñ·ƒøAr
ƒøZwƒÀ ·Ðë‹Ð·ƒøArƒøZwƒÀ ·ÀƒÁÿMt
f…Òtf;Ðt÷ȷÂ+Áëjÿuÿuÿuè,þÿÿƒÄ^]ËÿU‹ìS3Û9]u3ÀëAVWÿuè{1ÿÿpjVè„N‹øƒÄ;ûtÿuVWè<ýÿÿƒÄ…Àu‹ÇëSSSSSè×úþÿ3À_^[]ËÿU‹ìQQSV‹5¨öB3Û‰]ü‹W;ÃtP‹=(1BSSjÿPSSÿ׉Eø;ÃtAjPèö4ÿÿYY‰Eü;Ãt0ÿuøPjÿÿ6SSÿ×…Àt*EüSPèe.ÿÿYY…ÀxƒÆ‹;Ãu¶3À_^[ÉÃÈÿëö9]ütöÿuüègÀþÿYëë‹ÿV‹5ÐöBW3ÿ…öuƒÈÿéfƒø=tGVè•0ÿÿYtF·f…ÀuæSjGWèl4ÿÿ‹ØYY‰°öB…ÛuƒÈÿëe‹5ÐöBë5Vè]0ÿÿfƒ>=Yxt"jWè94ÿÿYY‰…ÀtAVWPèüÿÿƒÄ…ÀuIƒÃ4~fƒ>uÅÿ5ÐöBèÇ¿þÿƒ%ÐöBƒ#ÇøC3ÀY[_^Ãÿ5°öBè¡¿þÿƒ%°öBƒÈÿëä3ÀPPPPPènùþÿÌ‹ÿVÿä0B‹ð3É;ñu3À^Ãf9tƒÀf9uøƒÀf9uðS+ÆXWSèP3ÿÿ‹øY…ÿu
Vÿè0B‹Ç_[^ÃSVW茳þÿƒÄëæ‹ÿU‹ì‹Ef‹Uëf;ÊtƒÀ·f…Éuðf9t3À]ËÿU‹ìƒìSÿuMðè¡»þÿ‹M3Û;Ëu8]üt‹Eøƒ`pý3Àé«9]u&èÿÿÇèùþÿ8]üt‹Eøƒ`pý¸ÿÿÿé€9]tÕV¾ÿÿÿ;ÎvèãÿÿÇèàøþÿë?‹Eô9XuÿuQÿuÿuèëRƒÄë6ÿpQÿuQÿuhÿpEðPèˆRƒÄ ;Ãu8]üt‹Eøƒ`pý‹ÆëƒÀþ8]üt‹Møƒapý^[ÉËÿU‹ìjÿuÿuÿuè
ÿÿÿƒÄ]ËÿU‹ìS3Û9]u3Àë>VWÿuè-3ÿÿpVèf¾þÿ‹øYY;ûtÿuVWè@1ÿÿƒÄ…Àu‹ÇëSSSSSè«÷þÿ3À_^[]ËÿU‹ìQQSV3öW‹=°öB‰uü‹;Æte‹Ü1BVVVVjÿPVVÿÓ‰Eø;ÆtTjPèÈ1ÿÿYY‰Eü;ÆtCVVÿuøPjÿÿ7VVÿÓ…Àt6EüVPè‚.ÿÿYY…Ày9uütÿuüèL½þÿY‰uüƒÇ‹;Æu¡3À_^[ÉÃÈÿëöÿuüè+½þÿYëð‹ÿU‹ì‹M…Étjà3ÒX÷ñ;EsèTÿÿÇ3À]ïMV‹ñ…öuF3ÀƒþàwVjÿ5èúBÿ€1B…Àu2ƒ=CtVèÅ)ÿÿY…ÀuÒ‹E…ÀtÇ3Àë
‹M…ÉtÇ^]ËÿU‹ì‹MS3Û;Ëvjà3ÒX÷ñ;EsèÏÿÿÇ3ÀëA¯MVW‹ñ9]tÿuèªCY‹ØVÿuè
êþÿ‹øYY…ÿt;Þs+óVjßSè	´þÿƒÄ‹Ç_^[]ËÿU‹ì‹EƒøþuèoÿÿÇ	3À]Ã…Àx;ØCrèTÿÿÇ	èQöþÿëދȃàÁù‹àCÁà¾Dƒà@]ÃjhÅBèM4ÿÿ3À3ö9u•À;ÆuèÿÿÇè	öþÿƒÈÿë_èUÄþÿj [ÃPjè`ÅþÿYY‰uüè>ÄþÿÃPèm@ÿÿY‹øEPVÿuè&ÄþÿÃPèBÿÿ‰EäèÄþÿÃPWèà@ÿÿƒÄÇEüþÿÿÿè	‹Eäè4ÿÿÃèðÃþÿƒÀ PjèkÅþÿYYËÿU‹ìEPÿuÿuè4QƒÄ]ËÿU‹ìEPÿuÿuè8QƒÄ]ËÿU‹ìEPjÿuè QƒÄ]ËÿU‹ìEPÿuÿuè$QƒÄ]ËÿU‹ìEPjÿuèQƒÄ]ËÿU‹ì‹
€áB‹UƒÉ3À9
ÄC”À÷ÚÒ#щÄC]á€áBƒÈ3É9ÄC”Á‹ÁËÿU‹ìƒìSV‹u3ÛW‹};óu;ûv
‹E;Ãt‰3Àë{‹E;ÃtƒÿÿÿÿÿvèŠÿÿj^‰0èˆôþÿ‹ÆëVÿuMðèÔ¶þÿ‹Eð9X…f‹E¹ÿf;Áv6;ót;ûvWSVèűþÿƒÄè?ÿÿÇ*è4ÿÿ‹8]üt‹Møƒapý_^[ÉÃ;ót&;ûw èÿÿj"^‰0èôþÿ8]üt…‹Eøƒ`pýéyÿÿÿˆ‹E;ÃtÇ8]ü„<ÿÿÿ‹Eøƒ`pýé0ÿÿÿMQSWVjMQS‰]ÿpÿÜ1B;Ãt9]…jÿÿÿ‹M;Ët½‰ë¹ÿ<1Bƒøz…Pÿÿÿ;ó„sÿÿÿ;û†kÿÿÿWSVèú°þÿƒÄé[ÿÿÿ‹ÿU‹ìjÿuÿuÿuÿuè“þÿÿƒÄ]ËÿU‹ìƒìÿuƒMüÿMì裵þÿEìPÿu‹Eìÿ°¬EüÿuPè[þÿÿƒÄ…Àu‹EüëƒÈÿ€}øt‹MôƒapýÉËÿU‹ìQƒMüÿjÿuè+§ÿÿPÿuEüPèþÿÿƒÄ…Àu‹EüÉÃÈÿÉÃÌÌV‹D$Àu(‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$v	N+D$T$3Û+D$T$÷Ú÷؃ڋʋӋًȋÆ^ÂöA@tƒyt$ÿIx‹ˆÿ¶Àë¾ÀQPèéNÿÿYYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìQöC@V‹ð‹‰Eüt
ƒ{u‹Eë>ƒ'ƒ}~0‹EŠÿM‹ËènÿÿÿÿEƒ>ÿuƒ?*u‹Ë°?èXÿÿÿƒ}Õƒ?u‹Eü‰^ÉËÿU‹ì쀡€áB3ʼnEüS‹]V‹u3ÀW‹}ÿu¬ýÿÿ‰µÐýÿÿ‰½äýÿÿ‰…¨ýÿÿ‰…ðýÿÿ‰…Èýÿÿ‰…èýÿÿ‰…Ìýÿÿ‰…¤ýÿÿ‰…Äýÿÿè~³þÿèýþÿ‰…œýÿÿ…öu+èýþÿÇèñþÿ€½¸ýÿÿt
‹…´ýÿÿƒ`pýƒÈÿéaöF@u^Vè7IÿÿYºàîBƒøÿtƒøþt‹Èƒá‹ðÁþÁáµàCë‹ÊöA$u›ƒøÿtƒøþt‹ÈƒàÁùÁààCë‹Âö@$€…qÿÿÿ3ö;Þ„gÿÿÿŠ‰µÜýÿÿ‰µØýÿÿ‰µ¼ýÿÿ‰µ ýÿÿˆ•ïýÿÿ„Ò„²
C‰Àýÿÿ9µÜýÿÿŒ‰
Bà‹½äýÿÿƒðýÿÿ@Ç…Øýÿÿ
‹ðýÿÿ÷Á€„Ýþ‹Gø‹Wüé	‹½äýÿÿƒðýÿÿ@ƒ½èýÿÿôýÿÿ¸‰àýÿÿ‰…˜ýÿÿ}Ç…èýÿÿëju€úgucÇ…èýÿÿëW9…èýÿÿ~‰…èýÿÿ½èýÿÿ£~=‹µèýÿÿÆ]Vè2$ÿÿŠ•ïýÿÿY‰… ýÿÿ…Àt‰…àýÿÿ‰µ˜ýÿÿ‹Øë
Ç…èýÿÿ£‹‹5´1BƒÇ‰…€ýÿÿ‹Gü‰…„ýÿÿ…¬ýÿÿPÿµŒýÿÿ¾Âÿµèýÿÿ‰½äýÿÿPÿµ˜ýÿÿ…€ýÿÿSPÿ5HïBÿÖÿЋ½ðýÿÿƒÄç€tƒ½èýÿÿu…¬ýÿÿPSÿ5TïBÿÖÿÐYY€½ïýÿÿgu…ÿu…¬ýÿÿPSÿ5PïBÿÖÿÐYY€;-uðýÿÿC‰àýÿÿSéÄýÿÿ‰µèýÿÿ‰¨ýÿÿë*ƒès„tüÿÿHH„[þÿÿƒè…¾‹½äýÿÿÇ…¨ýÿÿ'ö…ðýÿÿ€Ç…Øýÿÿ„5þÿÿŠ…¨ýÿÿQÆ…Ôýÿÿ0ˆ…ÕýÿÿÇ…Ìýÿÿéþÿÿ÷Á…þÿÿƒÇöÁ t‰½äýÿÿöÁ@t¿Güë·Gü™ë‹GüöÁ@t™ë3Ò‰½äýÿÿöÁ@t…Ò|…Às÷؃Ò÷Úðýÿÿ÷…ðýÿÿ‹ú‹Øu3ÿƒ½èýÿÿ}Ç…èýÿÿ냥ðýÿÿ÷¸9…èýÿÿ~‰…èýÿÿ‹ÃÇu!…Ìýÿÿuó‹…èýÿÿÿèýÿÿ…À‹ÃÇt-‹…Øýÿÿ™RPWSè}õÿÿƒÁ0‰˜ýÿÿ‹Ø‹úƒù9~¨ýÿÿˆNë½Eó+ÆF÷…ðýÿÿ‰…Øýÿÿ‰µàýÿÿtc…Àt‹Î€90tXÿàýÿÿ‹àýÿÿÆ0@ë@Ifƒ8tƒÀ…Éuò+…àýÿÿÑøë(…ÿu¡ ïB‰…àýÿÿ‹…àýÿÿëI€8t@…Éuõ+…àýÿÿ‰…Øýÿÿƒ½¤ýÿÿ…¸‹ðýÿÿöÁ@t5÷Át	Æ…Ôýÿÿ-ëöÁt	Æ…Ôýÿÿ+ëöÁtÆ…Ôýÿÿ Ç…Ìýÿÿ‹…Èýÿÿ+…Øýÿÿ+…Ìýÿÿ‰…˜ýÿÿöÁu%‹øë‹ÐýÿÿµÜýÿÿ° Oèòôÿÿƒ½Üýÿÿÿt…ÿßÿµÌýÿÿ‹½œýÿÿ‹Ðýÿÿ…ÔýÿÿP…Üýÿÿèõÿÿö…ðýÿÿYYt.ö…ðýÿÿu%‹½˜ýÿÿëµÜýÿÿ‹Ë°0Oè•ôÿÿƒ½Üýÿÿÿt…ÿヽÄýÿÿ‹…Øýÿÿtu…À~q‹µàýÿÿ‰…ýÿÿ·ÿýÿÿPjEôP…ˆýÿÿPƒÆèóÿÿƒÄ…Àu69…ˆýÿÿt.ÿµˆýÿÿ‹½œýÿÿ‹ÐýÿÿEôP…Üýÿÿèsôÿÿƒ½ýÿÿYYu¦ë#ƒÜýÿÿÿ닽œýÿÿPÿµàýÿÿ…ÜýÿÿèEôÿÿYYƒ½Üýÿÿ|2ö…ðýÿÿt)‹½˜ýÿÿë‹ÐýÿÿµÜýÿÿ° Oè¼óÿÿƒ½Üýÿÿÿt…ÿ߃½ ýÿÿtÿµ ýÿÿè«þÿƒ¥ ýÿÿY‹ÀýÿÿŠˆ…ïýÿÿ„Àt‹½äýÿÿ3öŠÐédõÿÿƒ½¼ýÿÿt
ƒ½¼ýÿÿ…ôÿÿ€½¸ýÿÿt
‹…´ýÿÿƒ`pý‹…Üýÿÿ‹Mü_^3Í[覤þÿÉÃIüÐAùÎA+ÏA‡ÏAÓÏAßÏA%ÐAWÑA‹ÿU‹ìSŠ]V‹uŠFÿtƒ}ç^]ËÿU‹ìQöC@V‹ð‹‰Eüt
ƒ{u‹Eë>ƒ'ƒ}~0‹EŠÿM‹ËènÿÿÿÿEƒ>ÿuƒ?*u‹Ë°?èXÿÿÿƒ}Õƒ?u‹Eü‰^ÉËÿU‹ì‹Eƒ‹‹Aø‹Qü]ËÿU‹ììØ¡€áB3ʼnEü‹ES‹]V‹uWÿu3ÿ„÷ÿÿ‰µd÷ÿÿ‰…¬÷ÿÿ‰½H÷ÿÿ‰½°÷ÿÿ‰½`÷ÿÿ‰½L÷ÿÿ‰½X÷ÿÿè[¥þÿƒ ÷ÿÿÿ‰½h÷ÿÿèæîþÿ‰…D÷ÿÿ;÷u+è×îþÿÇèÔâþÿ€½÷ÿÿt
‹…Œ÷ÿÿƒ`pýƒÈÿéRöF@u^Vè;ÿÿYºàîBƒøÿtƒøþt‹Èƒá‹ðÁþÁáµàCë‹ÊöA$u›ƒøÿtƒøþt‹ÈƒàÁùÁààCë‹Âö@$€…qÿÿÿ;ß„iÿÿÿ‰½€÷ÿÿ‰(÷ÿÿ‰½œ÷ÿÿƒ½œ÷ÿÿu9½ ÷ÿÿ„¦3ÿ‹…(÷ÿÿƒl÷ÿÿÿƒ”÷ÿÿÿƒ ÷ÿÿÿ‰½x÷ÿÿŠ‰½T÷ÿÿ‰½P÷ÿÿ‰½p÷ÿÿ‰½¨÷ÿÿˆ¤÷ÿÿ„Û„E‹ø늤÷ÿÿGƒ½€÷ÿÿ‰½|÷ÿÿŒ°Càƒ¨÷ÿÿÿ‰•8÷ÿÿ‰•L÷ÿÿ‰•p÷ÿÿ‰•`÷ÿÿ‰•°÷ÿÿ‰•X÷ÿÿé¾Ãƒè tIƒèt5ƒèt%HHtƒè…÷ÿÿéヰ÷ÿÿé×	µ°÷ÿÿéÌ°÷ÿÿ€é½ƒ°÷ÿÿé±€û*…Á9• ÷ÿÿuƒ…¬÷ÿÿ‹…¬÷ÿÿ‹@üé„j
…h÷ÿÿPW轤þÿ‹h÷ÿÿƒÄHƒ½œ÷ÿÿQ‰•|÷ÿÿuL…Àˆ—üÿÿ€9$…Žüÿÿƒ½”÷ÿÿdüÿÿ;…l÷ÿÿ~‰…l÷ÿÿÀŒÅ´ùÿÿƒ9„Úÿµ°÷ÿÿj*Vé3À‹„Ÿùÿÿ‹3Ò‰…p÷ÿÿ;Âù
ƒ°÷ÿÿ÷p÷ÿÿéç
‹…p÷ÿÿkÀ
¾ËDЉ…p÷ÿÿéÌ
‰•¨÷ÿÿéÁ
€û*…Œ9• ÷ÿÿuƒ…¬÷ÿÿ‹…¬÷ÿÿ‹@üëWWÿ6èI"ƒÄëšÇEäj[‹Ã+ÇPD=äPÿ6è\LÿÿƒÄƒøÿ„ˆýÿÿø;ß݃Ëÿ‹‹ÈÁù‹àCƒàÁàD$Š2Mþ€á0‹‹ÈÁù‹àCƒàÁàD$‹MŠÁéÀá€â
Ê€}ýˆu!öEt‹‹ÈƒàÁù‹àCÁàD€ ‹Mô¸À#È;Èu~öEtxÿuàÿH1BjÿuðEÐjPÿuì‹Eô%ÿÿÿPÿuÿ81B;Ãu4ÿ<1BPèÎþÿ‹‹ÈƒàÁù‹àCÁàD€ þÿ6è¢ÿÿYé¢ûÿÿ‹6‹ÎÁù‹àCƒæÁ手EøéVúÿÿSSSSSèAÁþÿÌjh¸ÅBèÆÿþÿƒMäÿ3ÿ‰}à3À9}•À;Çuè~ÍþÿÇè{ÁþÿƒÈÿër‰}üÿuj@ÿuÿuEàPEäè|øÿÿƒÄ‰EÜÇEüþÿÿÿè‹uÜ;÷t<è6Íþÿ‰0ë¿3ÿ9}àt+9}Üt‹EäÁø‹MäƒáÁá‹…àCD€ þÿuäè]ÿÿYËEäèjÿþÿÃjhØÅBèÿþÿ3ÿ‰}ä3À‹u;÷•À;ÇuèÒÌþÿj^‰0èÐÀþÿ‹ÆëYƒÿ3À9}•À;ÇtÞ9}t‹E%þÿÿ÷ØÀ@tʉ}üÿuÿuÿuÿuEäP‹Æè¯÷ÿÿƒÄ‰EàÇEüþÿÿÿè‹Eà;ÇtƒÿèÙþþÿÃ3ÿ‹u9}ät(9}àt‹‹ÈÁùƒàÁà‹àCD€ þÿ6èÿÿYËÿU‹ìQƒMüÿjEüPÿuÿuÿuÿuèÿÿÿƒÄ…ÀtƒÈÿÉËEüÉËÿU‹ìjÿuÿuÿuÿuÿuèïþÿÿƒÄ]ËÿU‹ìƒìSÿuMèè/‚þÿ3Û9]u8]ôt‹Eðƒ`pý3Àé¿‹Eì9Xu&ÿuÿuÿuè߃Ä8]ô„‹Mðƒapýé‘9]u&èzËþÿÇèw¿þÿ8]ôt‹Eðƒ`pý¸ÿÿÿéfW‹};ûu&èLËþÿÇèI¿þÿ8]ôt‹Eðƒ`pý¸ÿÿÿé7V‹M¶	ÿMÿE¶ÑöD‰Møte9]u¶öD‰]ø…øf‹óéÖ‹UŠ:Óu‰]øëTÁá¶ÒfÊÿE·Éf‹ñ‰Møf;prf;pwfpë1f;pr+f;pw%fpë·UøöAt	¶‰ë‹Ê‰Møf‹uø¶¶ÑGöD‰MütG9]u‰]üëXŠÿM:ÓtòÁá¶ÒfÊ·ÉG‰Müf;Hrf;HwfHë1f;Hr+f;Hw%fHë·UüöAt	¶‰ë‹Ê‰Müf‹Müf;Îu!f;ót	9]…Ùþÿÿ8]ôt‹Eðƒ`pý3À^_[ÉÃÀƒàH8]ôtð‹Mðƒapýëç‹ÿU‹ìjÿuÿuÿuèçýÿÿƒÄ]ËÿU‹ìƒìƒ}u3ÀÉÃWÿuMðè€þÿ‹}ôƒu'ÿuÿuÿuèÛ²þÿƒÄ€}ü„—‹Møƒapýé‹S‹]…Ûu#ègÉþÿÇèd½þÿ8]üt‹Eøƒ`pý¸ÿÿÿë_V‹u…öu$è<ÉþÿÇè9½þÿ€}üt‹Eøƒ`pý¸ÿÿÿë2¶ÿM¶ÁCöD8t=ƒ}u ¶3ÉöD8tY€}üt‹Eøƒ`pý3À^[_ÉÊ„Àu3Éë
Áá¶ÀfÈ·ÉC¶¶ÐFöD:t ƒ}u3ÀëŠÿM„ÒtóÁà¶Òf·ÀFf;Áuf…Étƒ}…pÿÿÿë‘ÀƒàH€}üt”‹Møƒapýë‹‹ÿU‹ìjÿuÿuÿuèŸþÿÿƒÄ]ÃÌÌÌÌÌÌÌÌÌÌU‹ìSVWUjjh¨Bÿuè¦ ]_^[‹å]ËL$÷A¸t2‹D$‹Hü3ÈèE{þÿU‹h‹P(R‹P$RèƒÄ]‹D$‹T$‰¸ÃSVW‹D$UPjþh°Bdÿ5¡€áB3ÄPD$d£‹D$(‹X‹pƒþÿt:ƒ|$,ÿt;t$,v-4v‹³‰L$‰Hƒ|³uh‹D³èI‹D³è_ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y°Bu‹Q‹R9Qu¸ÃSQ»@ðBëSQ»@ðB‹L$‰K‰C‰kUQPXY]Y[ÂÿÐËÿU‹ìƒì‹UV‹ujþX‰Eì‰Uä;ðuè
Çþÿƒ èòÆþÿÇ	ƒÈÿé}S3Û;ó|;5ØCrèãÆþÿ‰èÉÆþÿÇ	èƺþÿƒÈÿéN‹ÆÁøWƒæ<…àC‹ÁæŠL0öÁuè¦Æþÿ‰èŒÆþÿÇ	ëhúÿÿÿwN‰]ô;Ó„öÁ…ý9]t5ŠD0$ÀÐøˆEþ¾ÀHjYtHu‹Â÷Шtƒâþ‰U‹]‰]ðëz‹Â÷Шuè<Æþÿ‰è"ÆþÿÇèºþÿë6‹ÂÑè‰M;Ár‰Eÿuèµóþÿ‹ØY‰]ð…ÛuèðÅþÿÇèøÅþÿǃÈÿénjjjÿuèsêÿÿ‹‰D(ƒÄ‰T,‹ÎöAH‹ÃtzŠI€ù
trƒ}tlÿM€}þˆ‹CÇEôÆD
tP‹ŠL%€ù
tEƒ}t?ˆ‹@ÿM€}þÇEôÆD%
u%‹ŠL&€ù
tƒ}tˆ‹@ÿMÇEôÆD&
jMèQÿuP‹ÿ4ÿ1B…À„x‹Mè…Ɉm;M‡d‹MôDö€„ä€}þ„…Ét
€;
u€ë€ û‹]ð‹EôÉ]‰Eô;؃ыMŠ<„¯<
tˆCA‰Mé‘‹EôH;ÈsA€8
uƒÁ‰MÆ
ëu‰EëmÿEjEèPjEÿP‹ÿ4ÿ1B…Àu
ÿ<1B…ÀuEƒ}èt?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ðu€}ÿ
t jjÿjÿÿuèËèÿÿƒÄ€}ÿ
tÆ
C‹Eô9E‚Fÿÿÿë‹Dö@u€ëŠˆC‹Ã+Eð€}þ‰Eô…Ð…À„ÈKŠ„ÉxCé†3À@¶Éëƒø;]ðrK¶@€¹PðBt芶ʾ‰PðB…Éu
è•ÃþÿÇ*ëzA;ÈuØë@‹öD1Ht%CˆT1ƒø|	Š‹ˆT%Cƒøu	Š‹ˆT&C+Øë÷Ø™jRPÿuèñçÿÿƒÄ‹Eä+]ðÑèPÿuSÿuðjhéýÿ(1B‰Eô…Àu4ÿ<1BPè:ÃþÿYƒMìÿ‹Eð;EtPè¸|þÿY‹Eìƒøþ…‹‹Eô郋Eô‹3É;ÕÁÀ‰Eô‰L0ëÆ…Étfƒ;
u€ë€ û‹]ð‹EôÉ]‰Eô;؃‹E·ƒù„Ùƒù
tf‰ƒÃƒÀ‰E鵋MôƒÁþ;ÁsHfƒ9
u
ƒÀ‰Ej
鎉M鄃EjEèPjEøP‹ÿ4ÿ1B…Àu
ÿ<1B…Àu[ƒ}ètU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ðufƒ}ø
t…jjÿjþÿuèæÿÿƒÄfƒ}ø
t	j
Xf‰ƒÃ‹Eô9E‚ÿÿÿë‹tö@u€ë	f‹f‰ƒÃ+]ð‰]ôé’þÿÿÿ<1Bj^;ÆuèÁþÿÇ	è—Áþÿ‰0éjþÿÿƒøm…Zþÿÿƒeìé\þÿÿ3À_[^ÉÃjhøÅBè†óþÿ‹]ƒûþuè^Áþÿƒ èCÁþÿÇ	ƒÈÿ鶅Ûx;ØCrè7Áþÿƒ èÁþÿÇ	èµþÿëÒ‹ÃÁø<…àC‹óƒæÁ拾D0ƒàtƸÿÿÿ;EÀ@uèðÀþÿƒ èÕÀþÿÇë·Sè„öþÿYƒeü‹öD0tÿuÿuSè’ùÿÿƒÄ‰Eäëè ÀþÿÇ	è¨Àþÿƒ ƒMäÿÇEüþÿÿÿè‹EäèíòþÿË]SèÌöþÿYÃè
Oÿÿ…ÀtjèaQÿÿYöPñBtjh@jè…²þÿƒÄjè`­þÿÌ‹ÿU‹ì‹M¡PñB‹U#U÷Ñ#Èʉ
PñB]ËÿU‹ìƒì¡€áB3ʼnEü‹E‹‹@SVW‹=ì0B3öVVÿu‰Eøÿuÿ׋ȉMô;Îu3Àé†~Ejà3ÒX÷ñƒør9D	=wè؃þÿ‹Ü;ÞtÕÇÌ̃ÃëPèÓyþÿY;Æt	ÇÝ݃À‹Øë3Û;Þt¬ÿuôSÿuÿuÿ×…Àt VV9uuVVëÿuÿujÿSVÿuøÿÜ1B‹ðS莊þÿY‹Æeè_^[‹Mü3ÍèurþÿÉËÿU‹ìƒìÿuMðèuþÿÿuEðÿuÿuÿuPèþþÿÿƒÄ€}üt‹MøƒapýÉËÿU‹ìƒ}uèö¾þÿÇèó²þÿƒÈÿ]Ãÿujÿ5èúBÿ´0B]Ãjè$¬þÿYËÿU‹ìƒìÿuMðèuþÿ¶E‹MôŠU„Tuƒ}t‹Mð‹‰È·A#Eë3À…Àt3À@€}üt‹MøƒapýÉËÿU‹ìjjÿuÿuè™ÿÿÿƒÄ]ËÿU‹ìjjÿujèÿÿÿƒÄ]ËÿU‹ìjjÿuÿuèhÿÿÿƒÄ]ËÿU‹ìjjÿujèPÿÿÿƒÄ]ËÿU‹ìjjÿuÿuè7ÿÿÿƒÄ]ËÿU‹ìjjÿujèÿÿÿƒÄ]ËÿU‹ìjhÿuÿuèÿÿÿƒÄ]ËÿU‹ìjhÿujèèþÿÿƒÄ]ËÿU‹ìjhÿuÿuèÌþÿÿƒÄ]ËÿU‹ìjhÿujè±þÿÿƒÄ]ËÿU‹ìjhÿuÿuè•þÿÿƒÄ]ËÿU‹ìjhÿujèzþÿÿƒÄ]ËÿU‹ìjhWÿuÿuè^þÿÿƒÄ]ËÿU‹ìjhWÿujèCþÿÿƒÄ]ËÿU‹ìjjÿuÿuè*þÿÿƒÄ]ËÿU‹ìjjÿujèþÿÿƒÄ]ËÿU‹ìjjÿuÿuèùýÿÿƒÄ]ËÿU‹ìjjÿujèáýÿÿƒÄ]ËÿU‹ìjjÿuÿuèÈýÿÿƒÄ]ËÿU‹ìjjÿujè°ýÿÿƒÄ]ËÿU‹ìƒìÿuMðèÅrþÿ‹Eô…Àt*x¤u!jjÿuÿuèyýÿÿƒÄ€}üt‹MøƒapýÉÀ}üt‹Eøƒ`pý3ÀÉËÿU‹ìjÿuèœÿÿÿYY]ËÿU‹ìƒì9uðr9wƒ}ìÿv1èÙ¹þÿöEÇ"t
ƒMìÿƒMðÿëöEt	ƒeì‰]ðëƒMìÿ‰uð‹E_^…Àt‹Mø‰öEt‹Eì‹Mð÷؃Ñ÷Ù‰Eì‰Mð€}Ðt‹Ẽ`pý‹Eì‹Uð[ÉËÿU‹ì3ÀPÿuÿuÿu9äúBuh¬íBëPè=ýÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuè ýÿÿƒÄ]ËÿU‹ìƒ=äúBjÿuÿuÿuuh¬íBëjèôüÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuè×üÿÿƒÄ]ËÿU‹ìQƒeüVEüPÿuÿuèTµÿÿ‹ðƒÄ…öu9Eüt貸þÿ…Àt
詸þÿ‹Mü‰‹Æ^ÉËÿU‹ìƒìƒ}SVW„ÆÿuMðèânþÿ‹]…Ûu'ès¸þÿÇèp¬þÿ€}üt‹Eøƒ`pý¸ÿÿÿé‹u…ötÒ¿ÿÿÿ9}v!è;¸þÿÇè8¬þÿ€}üt‹Eøƒ`pý‹Çë]‹EðƒxuÿuVSèʃÄ€}ütA‹Møƒapýë8+Þ¶3MðQPè]áÿÿ‹ø¶MðQPèNáÿÿƒÄFÿMt…ÿt;øtÒ+ø‹Çë»3À_^[ÉËÿU‹ì3À9äúBu09Eu褷þÿÇè¡«þÿ¸ÿÿÿ]Ã9Etä}ÿÿÿwÛ]é<PÿuÿuÿuèÐþÿÿƒÄ]ËÿU‹ìSV‹ñ3Û;óuèV·þÿj^‰0èT«þÿ‹ÆéW9]wè:·þÿj^‰0è8«þÿ‹Æëu3É9]ˆ•ÁA9Mw	è·þÿj"ëÛ‹MƒÁþƒù"wÉ‹Î9]t3ÛCÆ-N÷Ø‹ù3Ò÷uƒú	v€ÂWë€Â0ˆAC…Àt;]rá;]rÆë¯ÆIŠŠˆIˆG;ùrò3À_^[]Â‹ÿU‹ìƒ}
‹Eu
…Àyjj
ëjÿuÿu‹Mèÿÿÿ]ËÿU‹ì3Àƒ}
u9E}@‹MPÿu‹Eÿuè÷þÿÿ]ËÿU‹ì‹M‹EjÿuÿuèÝþÿÿ]ËÿU‹ìƒì3ÉV;ùuè1¶þÿj^‰0è/ªþÿ‹ÆéÂ9Mvå3À9Mˆ•À@9Ew	è¶þÿj"ëÓ‹EƒÀþƒø"wÁ‹ES‹]‰Mü‹÷9Mt÷ÛÁÆ-wÇEü÷؉u‰MÿuÿuPSèî¶ÿÿ‰]ø‹Ø‹Âƒù	v€ÁWë€Á0ˆ‹MüFA‰Mü…Àu…Ût;MrÈ‹Mü[;MrÆ脵þÿj"Y‰‹ñéLÿÿÿÆN‹EŠŠˆNˆ@‰E;Ærì3À^É‹ÿU‹ì3Àƒ}
u9E
|9Es3À@W‹}Pÿuÿuÿuÿuèâþÿÿ_]ËÿU‹ìW‹}jÿuÿuÿuÿuèÃþÿÿ_]ËÿU‹ìV‹u…ö~
VÿuèYY‹ð‹E…À~PÿuèúYY…öt…ÀtPÿuVÿuÿuÿuÿ01Bë‹Î+ÈujXë3À…É™ÀD^]ËÿU‹ì‹MëI€8t@…ÉuõI‹E+ÁH]ËÿU‹ìƒì,¡€áB3ʼnEü‹ESVW‹}‹Ù‰E܉Uà…ÿ~?‹ÏI€8t@…ÉuõƒÉÿƒÈÿ+Áø‰}‹u…ö~*‹Î‹ÂI€8t@…ÉuõƒÉÿƒÈÿ+Áð‰uëƒÿÿ}Ö3Àéêƒþÿ|ôƒe؃}u‹‹@‰E…ÿt…ö…œ;þujXé»3ÛC;ó~‹Ãé­;û~jëäEèPÿuÿä1B…Àt£…ÿ~-ƒ}èrá€}îEîtØŠP„ÒtÑ‹MÜŠ	:r:ÊvªƒÀ€8uä뺅ö~4ƒ}èr¥€}îEîtœŠP„Òt•‹MàŠ	:r:ʆuÿÿÿƒÀ€8uàéwÿÿÿ‹5(1BjjWÿuÜj	ÿuÿ֋؉]Ô…Û„ÿÿÿ¿~@jà3ÒX÷óƒør4D;Çwè/wþÿ‹Ä…ÀtÇÌÌëPè-mþÿY…Àt	ÇÝ݃À‰Eäëƒeäƒ}ä„ÃþÿÿSÿuäÿuÿuÜjÿuÿÖ…À„jjÿuÿuàj	ÿuÿÖ‹Ø…Ûtx~?jà3ÒX÷óƒør3D;Çwè¯vþÿ‹Ä…ÀtÇÌÌëPè­lþÿY…Àt	ÇÝ݃À‹øë3ÿ…ÿt1SWÿuÿuàjÿuÿÖ…ÀtSWÿuÔÿuäÿuÿuÿ01B‰EØWèn}þÿYÿuäèe}þÿ‹EØYeÈ_^[‹Mü3ÍèKeþÿÉËÿU‹ìƒìÿuMðèfhþÿÿu$‹Uÿu MðÿuÿuÿuÿuèbýÿÿƒÄ€}üt‹MøƒapýÉËÿU‹ìƒìSÿuMðè#hþÿ‹U3Û;Óu8]üt‹Eøƒ`pý3Àé·9]u&èš±þÿÇè—¥þÿ8]üt‹Eøƒ`pý¸ÿÿÿéŒ9]tÕV¾ÿÿÿ;Övèe±þÿÇèb¥þÿëK‹Eð‹H;ËuEðPRÿuÿuèŸøÿÿƒÄë?ÿpEðRÿuRÿuhQPè	ÿÿÿƒÄ ;Ãuè±þÿÇ8]üt‹Eøƒ`pý‹ÆëƒÀþ8]üt‹Møƒapý^[ÉËÿU‹ìƒ=äúBu]éùÿÿjÿuÿuÿuèòþÿÿƒÄ]ÃjhÆBèãâþÿèsþÿp ‰uä3À9E•À…Àuè™°þÿÇè–¤þÿƒÈÿëÓJÐdÐpÐ|ДЮÐÌÐÜÐêÐÑÑ,Ñ>ÑLÑ`ÑnÑ~ÑѦѸÑÔÑèÑÒ"Ò6ÒFÒ\ÒvÒ‚ÒšÒ²Ò¼ÒÈÒÚÒæÒôÒÓÓ"Ó0ÓîÏ@Í4Í&ͨΚ΄ÎxÎhÎXÎJÎ<Î*ÎÎ
ÎúÍèÍÚÍÆͺ͖ͪ͂ÍzÍnÍ^ÍLÍÐ0Ð
ÐF@B»@,Ö@ø`A~cApB¾&B÷@ç®{O]ð¾ð¬CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.5\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removed%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Root Key: %sOut of memoryAre you sure you want to remove
this package from your computer?Please confirmcould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”Þñinvalid literal/length codeinvalid distance codeinvalid distance too far back`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

incorrect length checkincorrect data checkinvalid distances setinvalid literal/lengths setinvalid code -- missing end-of-blockinvalid bit length repeatinvalid code lengths settoo many length or distance symbolsinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method inflate 1.2.5 Copyright 1995-2010 Mark Adler 	

#+3;CScsƒ£ÃãIÃ	
!1AaÁ 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionary€qBtqB5BhqBXqBLqB8qB(qBqB5B€fàFðKуî É
ÈI*TÀðKуî É
ÈIÀT§TðKуî É
ÈIàOÐ ê:i¢Ø+00€S‡ Bi¢ê+00@ð_dPŸª/•N  ì!ê:i¢Ý+00€¢'"ê:i¢Þ+00º
E%­Ð˜¨6ÀF‘ÀF’ÀF“ÀF”ÀF ÀF¡ÀFÐÀFÑÀFÒÀFÓÀFáÀFâÀFãÀFäÀFåÀFæÀFèÀFéÀFêÀFëÀFìÀFîÀFïÀFðÀFñÀFòÀFóÀFôÀFõÀFöÀF÷ÀFøÀFùÀFúÀFûÀFüÀFþÀFÀF¡΋!	±ÿÝÌH€žãˆx5Ï®i+.b ö`¬ÙЙËÀOÖD—¢Vö	¯AHˆ÷Ì
F¤Mä^2mãF†¼T
íÐàðd_˜ÔN¾"ÚòµÅáÑÎú
(èÑ‘‡µ2ñéW]Â/4*&{ÐŒ© É-¿èzeÒG'{ÐŒ© É-¿èpŠh}ÆЙ›ÀOÖUáBl‰ÅЙšÀOÖUá•3”(Ò9ÀOŽë> ãG ©òήe+.bµchÈЙœÀOÖUá4^ñ;ݧBª}/NÅK°›f’£NrŸ@¶"ö=½Å3ŒÈH$¹Ñ˜ÕÀO¶‡Ú àü¼ìРÉ'€þmyÏ•4À[®ðJ1ÒйB Éá&®M[¸Ð˜ÀOÙrÈèGÂй: Éá ·qíEÐ’J ¯Ç¬MàÐWs5Ï®i+.bÀs5Ï®i+.bà¥s5Ï®i+.bw~s5Ï®i+.bå%ñeá{HºÒqÈC,ã4ÄÂ0‰L˜]©÷0°©²ë‹ÐRзôÀO×ì$¦ïŽéÑ[D”·tûÎ.¡+à*U6ÌF¶:(Yˆ;Êaª-kQG´œû˜^ø)˜|ÞÃI)ÓЫsÀOÃ>€±â+ØdWЩnÀO×¢@;òûðㄈª>Vø€;òûðㄈª>Vø 
»ÊWÚÏ™t ¯×—b@J7<äºÏ¿}ªiFϦЙËÀOÖD—a'»wjÐ¥5ÀO×Ðb°0¡wý”Ð¥DÀO×Ðb AG†QÒ»¶`—{FL!m•‘v’Ñ’`—ß[Ôc'»wjÐ¥5ÀO×Ðbd'»wjÐ¥5ÀO×Ðbñ6À†¡Ð‚Jª[CƒA¦VgqÞЃª[Cƒe'»wjÐ¥5ÀO×Ðb“Û5iè!ÌL¾¹ŸãÇz)zR88øÓüѦ¹`—ß[Ô|¼ë^1Ò¶/`—ß[Ô@¾–L\‘ϙӪJè7@å‘°ãƒÏ§ ¯×—b‡uïИˆ`—Þ¬ùëô@јˆ`—Þ¬ùà.PR€ìЉ«ÀO—-âT'²tEјˆ`—Þ¬ùA`ÂtÑpÑ·Z Édþ¥lÄ?<Ò¾æøÊWý4p ªlTI¬?—¢rùŠPèBÒ¾, É¨=¡Oñ${уøaÏP‡¦“•Ñ”o0pû,•Ñ”o€iyŜѨ?ÀOÉa¸4‚¢Ò†ÅÀOŽê™Øµä,¢Ò†ÅÀOŽê™ ÇÌÏ‚¢Ñ‚`“‚RéWp½Ñ‰ÀOÂÈ6Œöò“Ó£ÀOy«Ñ¦jc(=•ÒµÖÀOÙÐ0ñ%·ïG¥ñ`Œžë¬¡¸51M–Ùl¿Ég™‹Í~6Á›J”N½fsÌöv]=›»D¶®%ÚOcŠg3K›ÿ@Ò¢~ÀOÃq!‹2)wüK•L+2V°4K›ÿ@Ò¢~ÀOÃq€T'ò‚÷‘B½”ñ6“Q:ì.7£VœÎÒŸ`—Ɔö䬮®‰E¹·»†z¾âí5K›ÿ@Ò¢~ÀOÃqiI~©+.Í©áp¶Ñ¡ÎÀO×]_e¸ÿ¹ÎO¸œšk§mçŠ'WFAÒƒšÀOÙлóP0µ˜Ï»‚ª½Î³óP0µ˜Ï»‚ª½Î´óP0µ˜Ï»‚ª½Îá‹MÒ…]`“gµáI6FÓ—÷ÀOEг]“šˆ—K¹$ßÉáåè¢ñþ^5N“›$×÷̈&HÇS™«3M¬¤1õ7ˆ£iÙÿçЩ; É'$â9YõÓŽ:ÀOh7Õ%â9YõÓŽ:ÀOh7Õ&â9YõÓŽ:ÀOh7Õ'â9YõÓŽ:ÀOh7Õ«³ë|šI¤’ÊÄ˃(â9YõÓŽ:ÀOh7Õã¤!FÖðsGŠœFç{H@¡FãÕS÷2I´Et€$˜¤á„#œC¤È«‘Rõ†
e.{ ŽJO°že—¯Ç/°ö”P($IªZÑ^„†€9Ÿ½À¸$í\EƒæÕ9OèÄ奄ñ‚`O’„O·\;éx‡Ð8WõFž¿ºTpjØ÷œ«¸ìÂzO‘1Iæ(
@ü­úw·iKªw^ðæèàÖ‡Åω© ÉA)!¿\_ÑЃª[Cƒ°â+ØdWЩnÀO×¢€ÿ4DLïήe+.bÀSmbŒÑ²Í`—ߌ Àœí¹Ñ˜#ÀOÙrìŽ'Œ«>ÑŒ°ÀOÙÐë¯çÑ.jÐŒxÀOÙ´ôº^QmÒƒ­ÀOÙÐd¦Ñ4 É'äô>áòÒИÀOÙr3ó€ß·Ò£;`—ß[Ôè»ÚM•ÓO°ôµ¹KúLb`w¤±GŠŽ:J˜'iÏ>ŒV–MYFDAtâÖ;&åO‘ÁF°¤íÔÛ}êÄîÒ¨\I®;¿% ›S|ƒÀ
ø»*E…
yÐŽf|§txŸMNI–{@°Ò>KëJ§‚´®\F Зî4mc-Nüv­ÖE¦c7½V…ø‹fCNÁ²I—Étw„ׄ·8A!Ó±J»©'ËÀÅ8šEûþK}4@¥¾¬°Vq’Cšš(D¾W@¤Xzv×çùF@S·Ë>L¾NdÍL·Ö¬+Ùo—.ÑEˆÿ°Ñ†¸ÞÝ·Œ"ý®ãJ†Ló‘
¸þ:Ì¿´,ÛLB°)隇ÆA» }¹jô—Lº^6CTw]§+.ÃD¦¢«¦JQÃS[bH«ÁNº¡ïAFüÀP®ÒëŠC†UŠ	.4˜zlƒ‰À'K@-ÜýtКÓý#¯F­´l…HiÇa÷w­hŠM‡½0·Yú3ÝS¿«Åá!A‰†boÂÉs½t’ÑÏÃA³^±?U§Xôè“2¦NfÛH yßuž	÷5ꥂÍÙÅG–)á]/qNnNÔ9þjòI†=¯Êæÿ¸W¤.ÖIª|çK‹ã°g
4ªÄòcH¯ïø~òæº%‚]«bÁýÃM©Ý
I]—ç7B¹¬WGC‘Q°Œl2Ñ÷¯$HíäܨEâüye64Û…¶>ùeöL :ãïerŸ=…'³ñºoÏOU{Žp‘¤¡ ¥€öO½sCůè$5¾3QBº…`ÊíÏ]v+éÀqAŽ¦¸Oö;ŠÜÙ„·.C§Z0§YcwNÁç]N·D.±®Q˜·°1RÖñ²WH¤Î¨çÆê}'ô‹óCòB“gÞ(ü#…l^"`Gšþê3¶qs0â3NvFƒZ˜9\;ûï@Z|û üK‡JÀòà¹úŽ$M—ÞÆÙ>M¿‘ôEQ ¹w“€mðjKD‰W£w? §Õec
åE‡ö
¥kjO}¶c^¿ÁNI²œe·2ÓÒíñ÷mŸ¢Gª®)ÓÆðfâ®×\"gJ¸]lœáV`ËW0½¼\Ê"F´-¼VÛ
åpñNr-¤ïOŸ&¶„oºO}N8Ðú—GË¢)³’µqÕØKmÓH¾—B" C›˜µ™[E„«|täÝüKpÈžô&A©Ãµ*ôè†ûë¶i‡µ†G´ï½Ã2®®øÚHÏæNO¸iØNã„«•9žœO¸'H²Klqto%µ¼öyîL·%Ü4äýF˜x€WOŒbD»cq#€±	µ(O\iø„NŽ`ñ¹|\ÇÞ1‹¥I“¸káLúICš«N_3haO‰1ÏF—I&×I}!<O™ªýÂÉGFVXi³aé;B¶‡8n¿Ø29ÌÝÖ”hJuA£t½XJQxd©_w~8Æ¢WU¦]ƒOˆ	ÂÉŠ¦ú36ÐË(AŸ#)Vãåàç)–¯€ÿF€#Ϋœ>ãî%'˜GožG´G+ú}.а‰¶Óv»L‡÷X]àp`OÞúK¤”‹ ²#ó”7EµªC£)Ãt0Å*ƾ{,DÈ
J‘úÎöõœý¡àÙÖ‡Í+DW^
ëOor9tÖÙRNƒNgɆó‚>!€ý¼OLˆ»'`g©+$Ì%|šQO€àz)(þ¾Bã¢_@^A¦îÊÖ% xSDŠMƒt	ÖN†nòØ8Ã…¼m]rL§wìx,¹4ïK†§u@ºˆ+‰©ô׉#äG©``¼Âí“„µËW´é®G¡ Äß35ÞâãóÆíA„	A­ól ·ÞG؂تçíI†·æá÷Íþ‚Âï à`F“têˆQ<ü€ð÷Ëë[áM¼ƒEÄ€öªd_»ðµNŽM&uf4L—3l÷³¯×E¥ŸZIéC~Á½"ñ‚@Œ0(9ŸA8L"k1Ë÷%¸BŠ	T
#¤=ØE\¿«Ì\·G»N‡Ë‡»ÑbÒãR
FœHòsÔp£ÚS ’i)!@¿'QLü.JiÀFÏÀFÀFÀFÀFÀF ÀF ÀF!ÀFÀFÀFÀF&ÀFÀFÀF	ÀFÀFÀkŸò!PΪi)?ÀF0:s*έåªDw=ÀF
ÀFÀFÀF
ÀF
ÀFÀFÀFÀFÀFPÀF%ÀFQÀFÀFÀFÀF`kõÕ;Yµi+-¿zÐ1OYб” É
È¿¶Ÿ¥4<Ñœ™ÀO¹˜ªV±%п
ª¸ßÒ… XÈ$5I´‚?Ø#3:O4jõÕ;Yµi+-¿züjõÕ;Yµi+-¿zÐiõÕ;Yµi+-¿z ÄvÏšñ ¯nrô=ÀF>ÀF@ÀFDÀF[ÀFðÊ™^Aψªµiõ XשFÏ•üªh
´Mm8gÏ–ªh
´zÔó0GdÑŽ<ÀO¹8m®ö¼xˆÑƒéÀOÂÆÔ4ÈyˆÑƒéÀOÂÆÔ"ÀFFÀF’Mm8gÏ–ªh
´0ÀF1ÀF2ÀF3ÀF%ÀF)ÀF*ÀF0:s*έåªDw=IÀFè¹ë–yÒ‡.øY+ÀF&ÀFEÀFGÀFHÀFÊ:/Û†/ÑŽÀO¹˜šË:/Û†/ÑŽÀO¹˜šÌ:/Û†/ÑŽÀO¹˜šÍ:/Û†/ÑŽÀO¹˜šÎ:/Û†/ÑŽÀO¹˜šÏ:/Û†/ÑŽÀO¹˜šÇ–v\цø°WÞy”(ÌÒ ÷€_…±ÁÀFÀÀFÆÀFÕÀFÔÀFÎÀFU
8r+£C…+nó4é4ÀFâRX0eѶ£øu{ùÚ®šP9VѶ¡øu{ùðþ½ÏÏ£0ªÁne0ÕE
KvСʪÁne
y˜´âа±ÀOØܦÏ«|õxÒ–ÀO£†À¨´jÒ­IÀO£†ÐàQžnÒ–ÀO£†0îüŒ½9иѠ$«-»¸1.¦Ð¦Å É¯EÀ^¼ƒ*oСĪÁneÀÞP«oСĪÁne |Œ~|Б?ªÁne?Ç¦üàЗP É¯E^æ#ŠÂ1Љ $«-»á?îƒÙWй2 $«-»â?îƒÙWй2 $«-»pðwµâ~Б?ªÁneg­‡Ð‘@ªÁneñ˳ÁjˆÐ‘@ªÁneò˳ÁjˆÐ‘@ªÁneã?îƒÙWй2 $«-»~{ŒS^ÒЗB É¯Eyð¾|„ªKD¼phäƒê¼KΔӳѹ´ÀOØÕ°ž™rÀIúÑ ¯ÀO£†°…‘’ËÅC€©’'zO{Tx…hиÀO×ìà{ËlhиÀO×ìÎ6²Ç€îИ_`“‚ðÙÃ\Ñ•¾`——êOßOðÎrþÒ‡¥ÀOh7Ïü¬y½)ÓŽ
ÀOh7ÕBÐTyI¼²6¾Eº&jnLF°BìÀ}æsíïg'èD´“xó˜+h\ÒtÉ<³6M­>Ù?i]?ˆú9ì¯øÅA„!8¾ÒFs°%çÍÉÌE‘~2]rú´Î?àöjdÖôN–&÷àí6u^g¤óO!˜BŽ°>9ù}˜Œ®—‡ÓN¾r*GÝ“°¥ùkF³ðNª]Í·gh±hÏ“ægÙA‡c™*î^Z¡%­È”2îAeqKÐW»'ìØ;?B@±
JÏÙ$ÔSõQ¦À‹´Òµí`—Ɔö†(ÂœŽÜÒ±ÐÀOŽë>’ƒÛñ1sÐŒ™ É-¿èªO(hHjÐŒxÀOÙ´…ÀiQÍD”¯(ߥlù+ ‹rˆ÷Î’­ª§LÐm‚CçîB¼U¡âaÃ{þÓ°Ÿ~Ÿ‘C«.›`1“y‹Á¼º/D€ÄŠYÃF;šæa¥¸´A‘¥dƼÊ403bpcã(J¥g
·€æ×ØДէ{E³´Î]º¬ˆ°­é½ÆEŽ)П“SáãØ-<¨©M£0G$4[¡¾“Vÿà,HMµÅ@}͹2Ý­H¥<$A«ãµ§%1²efþÊà¹I¡x+\´’¥ÚýhŠÜ LŒëAfCµ¦%§ñ°”¼D–áB–£Râm§>¶…oE¡œHžú…‹?¾syûYz(©…¸yòé
…K¬Ýìù@‰Aº—º“X‡G§áA'qQU”‚AÿJ€ú
sêÌY!ëW«O«Zåú{ê*lñ×ðg²(M‹â2¥Ä(¼ÿ ‚TfC¾'>çŽÂ|a.» 	ÑšÀOÂÖÁî±;•´“ј£ÀO¶‡Ú.K[ãÚÁKŸ8¼õÔ…¶¤³…¶H™Ù]êÒ‡26 Ù-&{ÐŒ© É-¿èráë:Љ³ É
¬ü%äwùËCºj»W'tVaämÑyî«!@‘i²aÖWBóýVmýЕŠ`—É •I-`:±›B¦n5äOC‘ûê(ž†K鞟Š^ﯘÇ=ÄÑ•êK0»™â˜:ÚšÑL¥%2J³·4{î[ãkY¦s=ÐåBM¯ÀQ!ºB\[–ˆ/B{N€sASÃÖ¦.À̆I›#t9JD¨f?kјÀH¢"ûÞtâûÅ»˜‘ªìÌ-G¾í¤ös?z¥ZÕA°žže¬!`[ǽ6îæN¾XXâ$µ¶ÓßÁéK…ö¦iiôöÅ‘£•Ôž(L„«žqžm®å–ájKÆHªˆ(.~,-Y@ƒo‚3\.Q¸ŸÉåëC£pðg{‡L¿°õµŒK”Ižs<_«z”\
L´ÖK÷ƒoÉø(t¦ã;sM³|¥@¿ø•)Ù^ÏvJ¿YêÓž¢¹~+IÇzŽÃŠC‡ÛhsxDÿp§ØÎWJ?,C“P0òDƒ÷OôAÑoËZ\ÊÜq"ütD·Åk¬â×¾®‡TLžrTŒöIkE
àaÿ`N’Ne7¶Ý6ò‹Œì_I˜”‘Õ|k’H¢rYøˆšM>sáë:Љ³ É
¬ë¯çÑ.jÐŒxÀOÙ´ðË¡d:aD‘X7iii9PÛ5—}+E‰ut¨X(ÓT6QøB~ÛœC…ñä]_È#ͼ„Þ_ÛL®¤¯d¸=x«ˆr|Õ­ÔhG¾–•2Ù`Òýæ?uIœŒ¦Ÿ£p4Bf6×—K›ƒt„©Ð3ÇOtaµ…‘G©°'"v0›
SNæwL£¬1Ð"(i¡v”ù¬@È	Yè‡G€ºØ­+ÐÀO×ÐbÈCß¾Ó‹4`—ß[Ô„L¼Òr?RJ¦{Ëó˜,»AÛs…EŽO¨ŒW¡£L›Ñ‹"ÀOÙÐ7vî8áуyÀOÙÐà½äühK€KŽœt&1Zsˆ~¯§:6›B¨ã÷}Ft¤ˆrØ⋪†GM·v2̤pŠDÍ´†œfD’.b[‡®€Gåvt­ãH¦•;© ¯ñ
zæ<§±ŠñDCÒü¿kÐÊ?}ùÖHƒ2”lwâG”Zrµ\Úí£˜GŠÛÅçÚ™±—YýÆkŸˆH‡”èŒÞ?FA&O©•AŸŸ;±,àÉUi™6
ÈI‹Jì²"ûx‡Š§9Jª³£›œ4§Ùܰܵ;E¾–fDþ×°¼ÒÀqmrÌE¦À.1ÁÛ!Yu´Y&¸î·H³xHÏ£‚'¶éGˆVÁBeUNOØ®Ç|)¼I‰EÁ@É0l…yדس„Dƒg,Ý ÎÖeÆùòÂL¿3ƒ"×5/QÞóqíCA„wéSk‚5X§;-î3ÕB»{_41Ølxƒpé³æòO…h6þǾƱ•ˆ´L¥b
VBPƒo¯zÈþù5zD­· #D‘@Fègmœ[¸Mœ¼Ýá/BTñ|\¹ŽÔ?@«™ÖÇz„¬ìpà¼ÀD—°FÇÉ[žÜ0é	49Zуú É
ÈI}ÑÞA³ÖaB™}ˆÆKXÐ䌠%ú«Dµ|DZÃ#à¹`ËÚ½Wv®G„EÒ>Ï‚®ÏZ…#ê@–Òk{Xö8ø&ˆ¨o‡IªÞêï¿èQ–d5ÀCþÕv†Sdn0@Dš×ÐHˆæ¤&’'›û®ûÒÖñŒEŒ4V˜w¢Ò˜n¨B*O—øŠôà&Ù-bØÑÞfôM¿lV!™jñ’
ö
hÖF³XÖapÝäf_Ï:ÛqúJð?Äýò¥¸¿Þ2cµ‡pFÀ^W´¤ž5}3Æ” H¼çjœiÔÖŸOY<0Ÿ¡G—šÉè==
–Û6e–ÑF›§ÓpžìùíûèqîüF¿ŒwH¨¡®Ò¶‰e_žK·à#ÍÙq}ŒÄkdÁ˜ò‘O¢ë-ÑpÙÑ;z©5³O¤gôŒ¬5âе.áÃ}øD¶Ýw³Mmä3sîðüæ›GŸ%¨`Â4£Žún¦.8E’4ï0…±é§PïpÑ·Z ÉdþÀF K6ó¹eΩºªJè7`, ê:i¢×+00ÀFh3©ÝM¸nÚãMÜ™ŠS{5”)ÊxKƒ®èþt	OÏó¨°3C«KˆsË­¤‹“w`µ¬$ÇD‚âƒ&ªl·´;ýÝ0M£HŸµÖ¿þR¸×UÑöòBªu‡(¡²ÒdÆT&©àaërr†C‘uòäÆ‹.|uUÐ:WˆPH’w¸[ÛŽ	œZÜŠèÞM¥¡`ø* ®÷óâ´À!ºsGº3^ÉFë‹0ÇðMßãJ‘Sªk‚éyZ
8—Ñy
ÈM 3íˆ,/¡KáqóI\ŒœMš;T¦‚Q'°ˆCH¿ïâÈCªåÁh4-§6¶C¬$Óð/Ù`zÌL’be…L†WÑw’R"¶«Œ!’ªì5C3€Ò4Âî¬a@ðY?J©TwZ¥Àƒ®8—™•ˆKžMn錕RÚa/pam/pmCorExitProcessmscoree.dllØöB0÷BTZSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunKERNEL32.DLLFlsFreeFlsSetValueFlsGetValueFlsAllocLC_TIMELC_NUMERICLC_MONETARYLC_CTYPELC_COLLATELC_ALLl¡BÒá@`¡BdëBåŠAT¡BdëBtoAH¡BdëB0‡A<¡BdëB„A4¡BdëBü‚A	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;runtime error 

TLOSS error

SING error

DOMAIN error

R6033

- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.

R6032

- not enough space for locale information

R6031

- Attempt to initialize the CRT more than once.
This indicates a bug in your application.

R6030

- CRT not initialized

R6028

- unable to initialize heap

R6027

- not enough space for lowio initialization

R6026

- not enough space for stdio initialization

R6025

- pure virtual function call

R6024

- not enough space for _onexit/atexit table

R6019

- unable to open console device

R6018

- unexpected heap error

R6017

- unexpected multithread lock error

R6016

- not enough space for thread data

R6010

- abort() has been called

R6009

- not enough space for environment

R6008

- not enough space for arguments

R6002

- floating point support not loaded

€ªB(ªB	ЩB
ˆ©B0©BШBˆ¨B0¨BÀ§Bp§B§B¦B@¦B¦B8¥B ФB!à¢Bx¼¢By ¢Bz„¢Bü|¢Bÿ\¢BMicrosoft Visual C++ Runtime Library

...<program name unknown>Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODESystemFunction036ADVAPI32.DLLÀÀ–ÀÀŽÀÀÀ‘À’À“À´ÀµÀ	         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿunited-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamerican¼ºBENU¨ºBENU”ºBENUˆºBENA€ºBNLBtºBENCpºBZHHlºBZHIdºBCHSPºBZHH<ºBCHS(ºBZHIºBCHTºBNLBð¹BENUä¹BENAÔ¹BENLȹBENC´¹BENB¨¹BENI˜¹BENJŒ¹BENZt¹BENSX¹BENTL¹BENG@¹BENU4¹BENU$¹BFRB¹BFRC¹BFRLð¸BFRSà¸BDEA̸BDEC¸¸BDEL¨¸BDES˜¸BENIˆ¸BITS|¸BNORh¸BNORT¸BNON<¸BPTB(¸BESS¸BESB¸BESLô·BESOà·BESCÄ·BESD´·BESF ·BESEŒ·BESGx·BESHh·BESMX·BESND·BESI4·BESA ·BESZ·BESRü¶BESUì¶BESYضBESVȶBSVFÀ¶BDES¼¶BENG¸¶BENU´¶BENU¬¶BUSA¤¶BGBRœ¶BCHN”¶BCZEŒ¶BGBR|¶BGBRt¶BNLDh¶BHKG\¶BNZLX¶BNZLL¶BCHN@¶BCHN4¶BPRI,¶BSVK¶BZAF¶BKOR¶BZAFôµBKORàµBTTO¼¶BGBRеBGBRÀµBUSA¸¶BUSA6-OCPACPNorwegian-NynorskGetProcessWindowStationGetUserObjectInformationWGetLastActivePopupGetActiveWindowMessageBoxWUSER32.DLL€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwppCONOUT$TMPH€áBP¿BRSDSé_­M<ë!N–ÊŠ½·¹ED:\python-dev\porting\cpython\lib\distutils\command\wininst-10.0.pdb ý Q°þÿÿÿÔÿÿÿþÿÿÿ߇@þÿÿÿÔÿÿÿþÿÿÿOˆ@äÿÿÿxÿÿÿþÿÿÿ ‹@þÿÿÿÔÿÿÿþÿÿÿ¬Œ@þÿÿÿÔÿÿÿþÿÿÿ)”@þÿÿÿÔÿÿÿþÿÿÿû•@þÿÿÿÔÿÿÿþÿÿÿ˜¦@þÿÿÿÌÿÿÿþÿÿÿ%´@þÿÿÿÀÿÿÿþÿÿÿÛ·@þÿÿÿˆÿÿÿþÿÿÿ÷¹@º@þÿÿÿ´ÿÿÿþÿÿÿäÁ@þÿÿÿØÿÿÿþÿÿÿÆ@þÿÿÿØÿÿÿþÿÿÿÅÆ@þÿÿÿÔÿÿÿþÿÿÿÇ@þÿÿÿÔÿÿÿþÿÿÿãÑ@þÿÿÿÌÿÿÿþÿÿÿóÕ@þÿÿÿÔÿÿÿþÿÿÿwÙ@þÿÿÿØÿÿÿþÿÿÿßÚ@þÿÿÿîÚ@þÿÿÿØÿÿÿþÿÿÿ¡Ü@þÿÿÿ­Ü@þÿÿÿØÿÿÿþÿÿÿûà@þÿÿÿá@þÿÿÿÔÿÿÿþÿÿÿµá@þÿÿÿÁá@þÿÿÿÌÿÿÿþÿÿÿèî@¥î@·î@þÿÿÿÔÿÿÿþÿÿÿÈü@þÿÿÿÔÿÿÿþÿÿÿ0AþÿÿÿÈÿÿÿþÿÿÿõA1AþÿÿÿÔÿÿÿþÿÿÿçAþÿÿÿÔÿÿÿþÿÿÿkAþÿÿÿÐÿÿÿþÿÿÿÅAþÿÿÿÌÿÿÿþÿÿÿOAAþÿÿÿÔÿÿÿþÿÿÿ¡AþÿÿÿÐÿÿÿþÿÿÿ:AAþÿÿÿÐÿÿÿþÿÿÿÓJÐdÐpÐ|ДЮÐÌÐÜÐêÐÑÑ,Ñ>ÑLÑ`ÑnÑ~ÑѦѸÑÔÑèÑÒ"Ò6ÒFÒ\ÒvÒ‚ÒšÒ²Ò¼ÒÈÒÚÒæÒôÒÓÓ"Ó0ÓîÏ@Í4Í&ͨΚ΄ÎxÎhÎXÎJÎ<Î*ÎÎ
ÎúÍèÍÚÍÆͺ͖ͪ͂ÍzÍnÍ^ÍLÍÐ0Ð
ЄPropertySheetACreatePropertySheetPageACOMCTL32.dllsSetLastError|CreateDirectoryAåGetFileAttributesAWMapViewOfFile‰CreateFileMappingARCloseHandlejSetFileTimeäDosDateTimeToFileTimeGetLastErrorˆCreateFileAÖUnmapViewOfFileMlstrlenAgMultiByteToWideCharEGetProcAddress<LoadLibraryAÓDeleteFileAÀReadFilefSetFilePointerðGetFileSizebFreeLibrary‡SetStdHandledGetStdHandleHLocalFree]FormatMessageA‚GetTempFileNameA„GetTempPathAGetModuleHandleA£GetVersionExAResumeThread}SetPriorityClassÀGetCurrentProcessÄGetCurrentThread™SetThreadPriority¤CreateProcessAGetModuleFileNameARemoveDirectoryA;GetPrivateProfileIntAAGetPrivateProfileStringAGetModuleFileNameWKERNEL32.dllMessageBoxA,GetFocus2wsprintfASetDlgItemTextAwSendMessageAeReleaseDC!GetDC®DispatchMessageAüTranslateMessage2PeekMessageAÜEndPaint~GetSystemMetricsBeginPaint›DefWindowProcAUpdateWindowßShowWindowmCreateWindowExAKRegisterClassAèLoadCursorAMoveWindowœGetWindowRect5PostMessageAdGetParentrSendDlgItemMessageA'GetDlgItemˆSetCursorUSER32.dll6CreateDIBitmapæDeleteObject¦SetTextColor¸TextOutASetBkModewSelectObject<CreateFontATCreateSolidBrushGDI32.dlllRegQueryValueA0RegCloseKeymRegQueryValueExANRegEnumKeyExA`RegOpenKeyExA}RegSetValueExA8RegCreateKeyExA=RegDeleteKeyAGRegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dlllCoUninitializeCoCreateInstance>CoInitializeole32.dllyGetSystemTimeAsFileTimeÏHeapFreeËHeapAlloc%FileTimeToSystemTime$FileTimeToLocalFileTimeìGetFileInformationByHandlePeekNamedPipeóGetFileTypeîEnterCriticalSection9LeaveCriticalSection•GetTimeFormatAÆGetDateFormatAÒHeapReAllocGetModuleHandleWExitProcessÊDecodePointer†GetCommandLineAÓHeapSetInformationcGetStartupInfoWIsProcessorFeaturePresentÀTerminateProcessÓUnhandledExceptionFilter¥SetUnhandledExceptionFilterIsDebuggerPresentêEncodePointerWideCharToMultiByte˜GetTimeZoneInformationrGetCPInfoïInterlockedIncrementëInterlockedDecrementhGetACP7GetOEMCP
IsValidCodePageÅTlsAllocÇTlsGetValueÈTlsSetValueÆTlsFreeÅGetCurrentThreadIdÍHeapCreateÎHeapDestroy%WriteFileWSetEnvironmentVariableWVSetEnvironmentVariableA²SleepãInitializeCriticalSectionAndSpinCountÑDeleteCriticalSection FatalAppExitAoSetHandleCountšGetConsoleCP¬GetConsoleModeRtlUnwind-SetConsoleCtrlHandlerìInterlockedExchange?LoadLibraryWGetLocaleInfoWaFreeEnvironmentStringsWÚGetEnvironmentStringsW§QueryPerformanceCounter“GetTickCountÁGetCurrentProcessId-LCMapStringWiGetStringTypeW›GetUserDefaultLCIDGetLocaleInfoA
EnumSystemLocalesAIsValidLocaleWFlushFileBuffers$WriteConsoleWÔHeapSizedCompareStringWCreateFileWSSetEndOfFileJGetProcessHeapÿÿÿÿ5B5B5B5B5B5Bü4Bð4Bè4B5B5BÔ4B5BÔ4B5B5Bü4Bð4Bè4B5BSoftware\Microsoft\Windows\CurrentVersion\Uninstall¼4B¬4Bœ4B|4Bd4BL4B<4B$4B4B4Bø3BÎ@à3B®@Ð3B@À3B­C@¬3BæC@ 3BA@Software\Microsoft\Windows\CurrentVersion\UninstallNæ@»±¿D C Cÿÿÿÿÿÿÿÿ€pðñÿÿPSTPDT@äB€äB
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@æB¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þþÿÿÿCè Bä Bà BÜ BØ BÔ BРBÈ BÀ B¸ B¬ B  B˜ BŒ Bˆ B„ B€ B| Bx Bt Bp Bl Bh Bd B` B\ BT BH B@ B8 Bx B0 B( B  B B B BôŸBðŸBìŸBàŸBÌŸBÀŸB	¸ŸB°ŸB¨ŸB ŸB˜ŸBŸBˆŸBxŸBhŸBXŸBDŸB0ŸB ŸBŸBŸBüžBôžBìžBäžBÜžBÔžBÌžBÄžB¼žB´žB¬žBœžBˆžB|žBpžBäžBdžBXžBHžB4žB$žBžBüBôBìBØB°BœBdëBdëBdëBdëBdëBØïB¸®B@³BÀ´BhëBÐìBÐìB@æBÿÿÿÿÿÿÿÿ¼°Bÿÿÿÿ€
`¬BP¬BBBBBBBBBBBÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Ml..ÐïB¨C¨C¨C¨C¨C¨C¨C¨C¨CÔïB¬C¬C¬C¬C¬C¬C¬CØïB¸®Bº°B. “þÿÿÿ(€@€p€nˆ€k €l¸€mЀn耀	(	8	H	X	hx1
ä€; ä =ä$?Zä€Aä”BZä(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnPAÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-14.0-amd64.exe0000644000175100001710000217400000000000000025111 0ustar00runnerdockerMZÿÿ¸@ º´	Í!¸LÍ!This program cannot be run in DOS mode.

$Œ–%¾È÷KíÈ÷KíÈ÷Kí|kºíÀ÷Kí|k¸í`÷Kí|k¹íÆ÷KíVWŒíÏ÷Kíó©HìÏ÷Kíó©NìÔ÷Kíó©OìÛ÷Kí…íÊ÷Kí›íÉ÷Kí€íÇ÷KíÈ÷Jíf÷Kí_©CìÀ÷KíZ©´íÉ÷Kí_©IìÉ÷KíRichÈ÷KíPEd† *PXð"ÀpÈ—@p	`d @	XдZ`	l°ëTì”Ш.text ¿À `.rdata*§Ð¨Ä@@.data¨K€l@À.pdata´ZÐ\|@@.gfidst0	Ø@@.rsrcX@	Ú@@.relocl`	
î@BH…ÉtŠ„Àt
ú+|>ö+øƒïB|.êPK8t3ÀéÌ3Û‰\$@fB;\.ôµLcòLöMcF*A8LcàLæA>PKuÊA<$PKuÀA¿FƒÂ.A¿N ÈLcúA¿FLþÐI¿D$ÑHcÏHƒÁ‰T$DI¿T$HÎIÐHÊHÁH‹ËH‰D$`H	¤ŠˆDpHÿÁ„ÀuëHL$pHÿÉHT$pH‰L$PHƒÈÿHÿÀ8uø€<\tHL$pHÿÉHÿÁ8uù·–f‰HL$pÿs½HcÈHD$pHÁH‰D$XE3ÒH‹D$Hë2H‹IƒÈÿIÿÀF8u÷I‹×èU†E3Ò…À„ýHÿÃH‹ÃHÁàHD$HL9uÉM¿D$HL$pI‹×è¿H‹\$PHD$p€8t€8/uÆ\HƒÀuíHL$pHƒÈÿHÿÀ€<u÷€<\H‹\$Xt_E‹NHvH‰D$0HT$pA·FL‹Ãf‰D$(3ÉA·Ff‰D$ èòúÿÿH…Àt'A‹NE¿D$E‹NH‹T$`‰L$ H‹ÈèÂüÿÿ…À„þÿÿD‹|$@H‹ÓF¿D.ôAÿÇE‹ÏD‰|$@¹èÿB¿D.ôD;ø¹‹T$D3ÛéùýÿÿH‹T$HHÛIƒËÿM‹ËH‹ÚIÿÁF8u÷HL$pHÿÉHÿÁD8uøL‹DÚ3ÒAŠˆHÿ„ÀuòE¿D$HL$pIcÑI‹ÃI×E+ÁHÿÀD8u÷H‹\$P€<\t €</tHL$pHÿÉHÿÁD8uø·°”f‰€:\t€:/uHÿÂAÿÈMcÀHL$pè@éþÿÿ¸H‹€H3ÌèzLœ$I‹[8I‹s@I‹{HI‹ãA_A^A]A\]ÃÌÌHE´ÃHE´ÃH‰\$H‰t$WHƒì0I‹ÙH‹úH‹ñèÓÿÿÿE3ÉH‰\$ L‹ÇH‹ÖH‹èÅžH‹\$@H‹t$HHƒÄ0_ÃÌH‹ÄH‰PL‰@L‰H SVWHƒì0H‹úHpH‹Ùè‡ÿÿÿE3ÉH‰t$ L‹ÇH‹ÓH‹èyžHƒÄ0_^[ÃÌH‰\$H‰t$WHƒì0I‹ØH‹úH‹ñèKÿÿÿL‹ËL‹ÇH‹ÖH‹H‹D$`HƒÉH‰D$(Hƒd$ è>¤H‹\$@ƒÉÿH‹t$H…ÀHÁHƒÄ0_ÃÌÌH‰\$H‰l$H‰t$WHƒì0I‹ÙI‹øH‹òH‹éèçþÿÿH‰\$(L‹ÏHƒd$ L‹ÆH‹ÕH‹HƒÉèߣH‹\$@ƒÉÿH‹l$H…ÀH‹t$PHÁHƒÄ0_ÃÌÌH‰\$H‰t$WHƒì0I‹ÙH‹úH‹ñè‹þÿÿH‰\$(L‹ÏHƒd$ HƒËÿL‹ÃH‹ÖH‹HƒÉè£H‹t$H…ÀHÃH‹\$@HƒÄ0_ÃÌÌH‹ÄH‰PL‰@L‰H SVWHƒì0H‹ÚHpH‹ùè+þÿÿL‹ËH‰t$(Hƒd$ HƒËÿL‹ÃH‹×H‹HƒÉ装ÀHÃHƒÄ0_^[ÃÌÌL‰D$L‰L$ SUVWHƒì8I‹ðHl$xH‹ÚH‹ùèÓýÿÿH‰l$(L‹ÎHƒd$ L‹ÃH‹×H‹HƒÉèË¢ƒÉÿ…ÀHÁHƒÄ8_^][ÃÌÌH‰\$H‰t$WHƒì0I‹ÙH‹úH‹ñè‹ýÿÿH‰\$(L‹ÏHƒd$ IƒÈÿH‹ÖH‹èºH‹\$@H‹t$HHƒÄ0_ÃÌÌH‹ÄH‰PL‰@L‰H SVWHƒì0H‹ÚHpH‹ùè7ýÿÿH‰t$(L‹ËHƒd$ IƒÈÿH‹×H‹èfHƒÄ0_^[ÃÌÌé/çÌÌÌé·ßÌÌÌH‰\$H‰l$WHƒì A‹øH‹ÂH‹ÙH…ÒtwƒÍÿŠ„ÉtnƒÿviHÿÀ€ù\uU€80|W€83~#€8nt
€8ruHHÿÀÆ
ë;fÇ
HÿÀHƒÃƒÇþë/A¸HT$0H‹ÈèQÛ<
uÆ
HÿÃýˆH‹D$0ëˆHÿÃýH…ÀuŒH‹l$@ÆH‹\$8HƒÄ _ÃÌ@SHƒì H‹ÙH‹
H…Étè²æH‹Ëè6£ƒ%£H‰ìŽHƒÄ [ÃÌÌH‹ÝŽH…ÀuH±ÃH‰\$WHƒì H‹Ù¹èY9H‹ËH‹øèê¢H‹
¯ŽH‹\$0H‰OH‰H‰=œŽHƒÄ _ÃÌÌH‰\$H‰l$ VWAVHìH‹XdH3ÄH‰„$€H‹fŽ3ÿE3À‹ÚL‹ñëH‹@AÿÀH…ÀuôH‹
—ŸºëA·ÀE3ÉHÁàH‰D$ DBÿH¹H‹
qŸºëH!|$ E3ÉDBÿ*¹H‹5Ž3íH…ö„•÷ÛÛƒãL‹H×HL$0ÿÅÿº¸HL$0AÿÖ…ÀtÿÇL‹DKcHÞHL$0ÿ“¸HT$0¹èÐH‹
ힺëHƒd$ LcÍDBÿ¥¸L‹ºìH‹
Æžÿ˜¸H‹vH…ö…rÿÿÿ‹ÇH‹Œ$€H3ÌèqtLœ$I‹[0I‹k8I‹ãA^_^ÃÌH‰\$H‰l$H‰t$WHƒì0H‹ñHƒËÿHÿÀ<u÷ƒd$(DKHƒd$ L‹Æ3Ò3Éÿ¨³‹ÈHÉ‹èè„7H‹øH…Àu3Àë+‰l$(DKL‹ÆH‰|$ 3Ò3Éÿv³…Àu
H‹ÏèbäëÔH‹ÇH‹\$@H‹l$HH‹t$PHƒÄ0_ÃH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒì D‹úH‹ÙHžŽÿP³H¡ŽH‹ËH‹øÿ=³H¦ŽH‹ËH‹ðÿ*³H£ŽH‹ËH‹èÿ³H¨ŽH‹ËL‹ðÿ³H¥ŽH‹ËL‹àÿñ²3ÉH9
Œu3ÀëGH…ÿt?H…öt:H…ít5M…öt0M…ät+H…Àt&E…ÿ•Á‰H
U—ÿÖÿ×A‹×I‹Îè2ýÿÿ‹ØÿÕ‹ÃëƒÈÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A^A\ÃHƒì(H‹ÊLD$@HíŽÿ㬅Àu3ÀëH‹T$@¹è˜H
çŒÿšHƒÄ(ÃÌÌHƒì(H‹ÊLD$@H©ŽÿŸ¬…Àu3ÀëH‹T$@¹èTH
£ŒÿÓ™HƒÄ(ÃÌÌH‰\$WHìPH‹à`H3ÄH‰„$@Hƒ=õŠH‹ÚuBH
IŽÿ£±H…ÀuH‹
_˜H@ŽÿJ˜éÅHFŽH‹Èÿ±H‰®ŠLD$ H‹ËHûÿñ«…À„‘Hƒ=‰Št©3ÛH=ÎkH‹T$ H‹è¡Œ…ÀtÿÃHƒÇƒû
räH‹
›”HŽëGH“kHcÃHÀE3É3ÉD‹ÂHT$0ÿ1Š…ÀtHT$0H
}ÿ˘ëH‹
š—H«L‹D$ ÿ€—3ÀH‹Œ$@H3ÌèqH‹œ$`HÄP_ÃÌH‰\$UH¬$@þÿÿHìÀH‹˜_H3ÄH‰…°Hƒd$h3ÉHƒd$pH‹Úƒd$XHƒd$xHƒd$PHƒd$`ÿø´…ÀyHMH‹
þ–D‹Àÿí–é¾HD$XH‹ËH‰D$@LMHD$pH‰D$8LEˆHD$xH‰D$0H(HD$hH‰D$(HE€H‰D$ ÿwª…Àu3Àé¾HD$P»D‹ÃH‰D$ L
Â3ÒH
šßÿT´…ÀyHáŒé_ÿÿÿH‹L$PLD$`HCÐH‹ÿ…ÀyHãŒé9ÿÿÿH‹L$PH‹UˆH‹ÿ …ÀyHéŒéÿÿÿH‹L$PH‹UH‹ÿP8…ÀyHêŒéøþÿÿH‹T$hH…ÒtH‹L$PH‹ÿPX…ÀyHíŒéÓþÿÿH‹T$pH…Òt#H‹L$PD‹D$XH‹ÿˆ…ÀyHàŒé¦þÿÿH‹T$xH…ÒtH‹L$PH‹ÿPH…ÀyHÛŒéþÿÿL‹E€HE ÇD$(AƒÉÿ3ÒH‰D$ 3Éÿƒ®H‹L$`HU D‹ÃH‹ÿP0…ÀyFL‹E€HºŒH‹
;•D‹Èÿ*•H‹L$`H…ÉtH‹ÿPH‹L$PH…ÉtH‹ÿPÿä²édþÿÿH‹L$`H‹ÿPH‹L$PH‹ÿPÿòH
Öˆÿ–H‹°H3Ìè_nH‹œ$ÐHÄÀ]ÃÌÌL‹ÜHƒìHIKH‹ÂI‰KØMK H‹ÈMCèH<Œÿb¨…Àu3Àë-ÿ¬±D‹L$`H‹ÈL‹D$hH‹T$0ÿ̱‹ÐH
Œÿ…•HƒÄHÃH‹
éhHÿ%*•ÌÌH‰\$UH¬$@þÿÿHìÀH‹|\H3ÄH‰…°LK•ÇD$0H,ŒH ÿO±H èßHœH‹Ëÿ­H…À…µD‹
ÔH¾‡D‹Í“Hî‹HL$@H‰D$ ÿþ°LL$0HÇÁ€LEHT$@ÿ¬…Àt#LL$0HÇÁ€LEHT$@ÿô«…Àt3ÀëGHMHÿÉHÿÁ€9uø·F‡f‰HMHÿÉHÿÁ€9uø3ÒŠˆHÿ„Àuó3ÒHMDBÿ­H‹°H3Ìè¦lH‹œ$ÐHÄÀ]ÃÌH‰\$UVWATAUAVAWHƒì HI‹H‹Ùÿ0¬HQ‹H‹ËH‹øÿ¬HV‹H‹ËL‹àÿ
¬H[‹H‹ËH‹ðÿ÷«HX‹H‹ËL‹èÿä«HU‹H‹ËH‹èH‰D$hÿÌ«HU‹H‹ËL‹ðÿ¹«HR‹H‹ËL‹øÿ¦«3ÛH‰D$pH…ÿ„ÇH…ö„¾M…䄵M…턬H…í„£M…ö„šM…ÿ„‘H
‹ÿ×H‹øH…Àt[H‹H‹ÈÿÖH‹H‰ŽH‹ÏÿÖH-¹fH‰Ò‘H‹õHcË3ÒHÁáHÍAÿÕH‹L‹ÀH‹ÏAÿÔÿÃHv ƒûrÚH‹l$hH‹D$pH‰x’3ÀH‰-·’L‰5X¥L‰=y‘ë¸H‹\$`HƒÄ A_A^A]A\_^]ÃÌ@UVWATAUAVAWHƒìpHl$ H‰ H‹‘YH3ÅH‰EHH‹ÚM‹ñHÅ…H‹ùÿtªHMŠH‹ÏH‰Eÿ`ªHÙ…H‹ÏL‹øÿMªH¶…H‹ÏL‹èÿ:ªH›‰H‹ÏL‹àÿ'ªHx‰H‹ÏH‹ðÿªH…‰H‹ÏH‰EÿªH‰‰H‹ÏH‰Eÿì©3ÉH9M„›M…ÿ„’M…턉M…ä„€H…ö„wH9M„mH…À„dH9M„ZH…Û„J8„Bº€H‹Ëè
‘‹ðƒøÿu"HèJH‹ÈHX‰L‹ÃèðÿÿFéH‹
Á“Lb‰ºìÿ‡­ÿUH‹ÏèàüÿÿHmƒ3ÒH‹ËA¸èýL+óH‹ûI‹>H…Étèñôÿÿë3ÀH‰HƒÇHGƒH;ø|ÛH‹Ó¹Aÿ×H0ƒH‹H…Étè›ÙHƒHƒÃH;Ø|ãHU‹Î»è÷)…ÀuUD‹E,A@HcÈHAH;Áw
H¸ðÿÿÿÿÿÿHƒàð蘔H+à‹ÎH|$ H‹×èž…À~HcÐH‹ÏÿÀÆ:
HcÐÆ:AÿÕ‹ØAÿÔ‹Îè줋Ãë¸ë¸H‹MHH3ÍèthH‹ HePA_A^A]A\_^]ÃÌH‰\$‰T$UVWATAUAVAWHƒì@Iƒ!L‹á3É3ÒI‹ñM‹ø½èÍ‚Hƒd$0E3ÉÇD$(€€D‹ÅºÀÇD$ H‹ÈL‹ðÿ<©¿õÿÿÿH‹Ø‹Ïÿܨ¹ôÿÿÿL‹èÿΨH‹Ó‹ÏH‰„$˜ÿƒ§H‹Ó¹ôÿÿÿÿu§èàùÿÿH‹øH…ÀtM‹ÏI‹ÔH‹Èè®üÿÿH‹Ï‹èÿw§ë¹è#
H‹ÈHq‡èÜíÿÿI‹Õ¹õÿÿÿÿ&§H‹”$˜¹ôÿÿÿÿ§3ÒH‹Ëÿ §¿;Çs
3ÒH‹Ëÿ§‹øGHcÈè§*E3ÿH‰H…ÀtCE3ÉD‰¼$ˆE3À3ÒH‹Ëÿƒ¦H‹LŒ$ˆD‹ÇL‰|$ H‹Ëÿÿ§‹Œ$ˆH‹Dˆ<H‹Ëÿ¨I‹Îÿ¦H‹œ$€‹ÅHƒÄ@A_A^A]A\_^]ÃÌH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒì L‹âL‹ñH’ÿD¦H•I‹ÎL‹øÿ1¦HšI‹ÎH‹Øÿ¦H—I‹ÎH‹øÿ¦HT†I‹ÎH‹èÿø¥H‹ðM…ÿt;H…Ût6H…ÿt1H…ít,H…Àt'H
uŠÿÓAÿ×I‹ÎètùÿÿI‹ÌÿÕ‹Ø…ÀtÿÖÿ׋ÃëƒÈÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A^A\ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAVAWHìàH‹iTH3ÄH‰„$ÐH‹=ÿŒ3Ò3Éè2€Hƒd$0E3ÉÇD$(€€ºÀH‹ÈÇD$ L‹ðEAÿ ¦»õÿÿÿH‹ð‹Ëÿ@¦½ôÿÿÿL‹ø‹Íÿ0¦H‹Ö‹ËL‹àÿê¤H‹Ö‹ÍÿߤèJ÷ÿÿH‹ØH…Àu-ÿd¦D‹ÀH*…HL$Pÿ¿¨HL$Pè±îÿÿƒÈÿééH‹×H‹Ëè.þÿÿH‹Ë‹èÿ·¤I‹×¹õÿÿÿÿ¤I‹Ô¹ôÿÿÿÿs¤…í„›3ÒH‹Îÿx¤‹ø¸ƒÿÿDøG-HcÈè(H‹ØH…Àtdƒd$@HÌ„H+Š
ˆHÿ„ÉuôE3ÉE3À3ÒH‹ÎÿÔ£Hƒd$ HS,LL$@D‹ÇH‹ÎÿQ¥‹D$@H‹ËƒÀ,ÆèêíÿÿH‹Ëè®ÔëH
„èÔíÿÿH‹ÎÿG¥I‹Îÿ¶£‹ÅH‹Œ$ÐH3ÌèôcLœ$àI‹[ I‹k(I‹s0I‹{8I‹ãA_A^A\ÃÌÌH‰\$WHì`H‹|RH3ÄH‰„$P3ÀH‹ú»…ÉtEH‰D$0D‹Á‰D$(D‹ËHD$@3Ò¹H‰D$ ÿm£H‹T$@HL$PD‹Ã蛜H‹L$@ÿ(£ëˆD$PHL$Pÿ¯¤HcÈL‹ÇH+ÙHD$PH‹ÓHÈèJëÿÿH‹
¿ŠL¸ƒA¹HT$Pÿç¦3ÀH‹Œ$PH3ÌècH‹œ$xHÄ`_ÃL‹ÜI‰SM‰CM‰K SVWHì@H‹”QH3ÄH‰„$0H‹ÚIs‹ùèÇèÿÿH‰t$(HT$0Hƒd$ L‹ËA¸H‹HƒÉ躃ƒï„‹ƒïtoƒït%ƒÿ…H‹
á‰H…É„«H!ƒé’‹E3ÀH‹
pŒºHc^D·ÈIÁáÿ9¦L‹Œ$hL‹ÃH‹
GŒºÿ¦é³ÿQ£‹ÈHT$0è%þÿÿéœÿ‚¥A¹0LÉ‚H‹ÈHT$0ÿŸ¥ëyH‹
F‰H…ÉtHr‚L‹„$hè
èÿÿH‹Œ$hº.è—sH…ÀtBHw‚H‹ÈèG”…Àu/H‹Œ$hè~ëÿÿë H‹
íˆH…ÉtL‹„$hHùè´çÿÿ¸H‹Œ$0H3Ìè?aHÄ@_^[ÃH‹ÄH‰XH‰pH‰PWHƒì@Hƒ`èH
Ô‰E3ÉÇ@à€º€Ç@ØEAÿ4¢H‹ØHƒøÿu3ÀëlHT$XH‹Ëÿ© Hƒd$(E3Ƀd$ 3ÒH‹Ë‹ðEAÿê¡H‹ËH‹øÿæ¡H…ÿt¾Hƒd$ E3ÉE3ÀH‹ÏAQÿ¨¡H‹ÏH‹Øÿ¼¡H‹Ã‰5ˆH‹\$PH‹t$`HƒÄ@_ÃÌÌÌH‰\$WHƒì0Hƒ=¦šH‹ùtQHƒ=¡‡uGÿé£L‹ŠšH‹Èƒd$(H‹ØE‹H
IPMÈH‰T$ A¸ÿCŸH‹ÓH‹ÏH‰^‡ÿp£H‹\$@HƒÄ0_ÃÌH‹ÄH‰XH‰hH‰pH‰x AVHì`H‹‘NH3ÄH‰„$PH‹
·†3í‹C‡‹Â+T
ú+Töƒê"H‰-‡HcÚHÙH‰-Þ™|êPK…!;{V4tHq€3Éè¢ûÿÿé…ÒˆþLcCE…ÀtHcCH‹ËH+ÈI+ÈH‰
˜™Ls¿A+‹ÏA+ЉuƒIcH+Øèž"H‹ðH…À„³HT$@‹Ïÿ¥ž…À„ŠL‹ÎH'€E3ÀHL$@ÿåž…ÀtnE‹E3ÀH‰l$0H‹Öf‰l$(f‰l$ AHèxÞÿÿH‹øH…ÀtYMcH‹ÓH‹Èèâ—HƒÈÿHÿÀ@8,u÷HKHÈè­‹H‹ÏH‰÷…H‰5ИÿÚŸ¸ëÿÅŸ‹ÈHœè—úÿÿ3ÀH‹Œ$PH3ÌèU^Lœ$`I‹[I‹kI‹s I‹{(I‹ãA^ÃÌÌÌHƒìhëHL$0ÿ¢HL$0ÿ ¡E3ÉÇD$ E3ÀHL$03Òÿ%¢…ÀuËHƒÄhÃ@SUVWAVHìÐH‹ŸLH3ÄH‰„$ÀH‹ñƒútÿ®¡éHT$pÿ.¡»H‹ø‹Ëÿ^¡E3ÉE3À‹È¸gfff÷éHà~H‰D$hD‹Òƒd$`3Òƒd$Xƒd$Pƒd$Hƒd$@ƒd$8ƒd$0AÁúA‹Ê‰\$(ÁéAÊÇD$ ¼ÿ¤œH‹ÐH‹Ïÿ`œ‹ÓH‹ÏH‹èÿrœHƒËÿL5¿ƒH‹ËHÿÁA€<uöº‰L$ D‹ÂM‹ÎH‹Ïÿ:œºÿÿÿH‹Ïÿ$œHÿÃA€<uöº
‰\$ D‹ÂM‹ÎH‹Ïÿ
œH‹ÕH‹Ïÿæ›H‹ÈÿœHT$pH‹Îÿ' 3ÀH‹Œ$ÀH3Ìè•\HÄÐA^_^][ÃÌÌÌH‹ÄH‰XH‰pH‰xL‰x UH¨8ðÿÿ¸Àè/ˆH+àH‹KH3ÄH‰…°HPþÿÿÇD$`3öH‰D$h3ÉH‰t$pÿ°›ºH‰u€3ÉH‰D$xÿ²Ÿ¹€H‰Eˆÿ[›L=\}H‰u˜HL$`H‰EL‰} ÿÅŸf…ÀuH‹
iƒLJ}E3ÉHP}ÿ’ŸL[‚H\}HM°ÿjŸ3Éÿ*›¹H‹ØÿLŸ¹‹øÿ?ŸH‰t$XLE°H‰\$PE3ÉH‰t$HI‹×H‰t$@3ɉ|$8‰D$0‰t$(‰t$ ÿAŸH‹ÈºH‹ØÿŸH‹ËÿoŸH‹ÃH‹°H3Ìè%[Lœ$ÀI‹[I‹sI‹{ M‹{(I‹ã]ÃH‰\$WHƒìPH‹·IH3ÄH‰D$@HT$0H‹ùÿqž3Éÿ‘ž¹‹Øÿ„žD‹T$0‹È‹D$4D‹\$œLD$`HêzHM°ÿ(œHD$PA¹E3ÀH‰D$ HU°H‹Îÿ—…Àu{¹è²ÇD$DH‹ØH…ÀtVH‹L$PHD$DH‰D$(E3ÉE3ÀH‰\$ 3Òÿè–…Àu0LME3Àº€I‹Îÿÿ›L‹ËH‰³LcÀºšI‹Îÿä›H‹L$Pÿ™–Hƒd$8‹×Hƒd$0Hƒd$(Hƒd$ H‹L$HLL$@LD$`ÿš–…À„¿þÿÿH‹L$HÿW–¸H‹MPH3ÌèvWLœ$`I‹[0I‹s8I‹ãA^_]ÃÌÌH‰\$WHƒì0HD$@A¹E3ÀH‰D$ HHRHÇÁ€ÿó•3Û‹ø…ÀuH‹L$@ÿè•…ÿ”ËÃH‹\$HHƒÄ0_ÃÌÌ@SHƒì H‹ÿQHÇÀH;ÃtKH=€uè‚ÿÿÿ…Àu:H‰ÛQë1A¹LlyHmyÿ‡šèVÿÿÿ÷ØHÉH÷ÙHËH‰
¨QHƒÄ [ÃÌÌ‹
}ƒø~HVPÃuƒ=Ü}HEP}H|RÃÌÌÌH‰l$H‰|$L‰d$ AUAVAW¸Pè‚H+àH‹ÿDH3ÄH‰„$@H‹ùƒêN„ŸêÂt+ƒú…ç½þfD;Å…ØIÁèfD;„3éÅH‹F}H…ÀtE3ÉH‰D$ ºA¸rÿЙ½þH‹Ï‹Õÿà™H‹ÈHÇ€è]üÿÿ‹ÕH‹ÏÿÆ™H‹ÈHÇ€èCüÿÿHƒd$ E3ÉA¸‹‹ÕH‹Ïÿ}™L‹ðHƒùvHƒd$ HÿLcÉA¸†H‹Ï‹ÕÿU™Š¿|„Àt8L´|HxHŒ$@ÿï˜L„$@ºèH‹Ïÿ!™Šƒ|E…öuG„Àt&Ls|H,xHŒ$@ÿ®˜H”$@ëHUxA¹LxxH‹Ïÿ—˜H‹Ïÿî˜A¿E3ÀH‹ÈE‹ÏºpÿT˜Hƒd$ E3ÉA¸ˆ‹ÕH‹ÏÿŠ˜IƒÎÿH‹ÏL‹àA;Æu\ÿ¥˜EOþE3ÀH‹Èºpÿ˜L»nºïH‹ÏÿS˜L¦nºðH‹Ïÿ>˜Š’nˆÊ{ˆDvéïÿI˜M‹ÏE3ÀH‹Èºpÿµ—Hƒd$ A¸™Mcä‹ÕM‹ÌH‹Ïÿè—L-{I‹ÕH+ÐH‹ˆH‰
ÕNŠˆHÿÀ„ÉuôM‹ÅºïH‹Ïÿ¸—Hƒd$ M‹ÌA¸Š‹ÕH‹Ïÿ–—ÿÀHcÈèL‹øH…ÀtgM‹ÌH‰D$ A¸‰‹ÕH‹Ïÿk—L
ÄzI‹ÏLÒyHwèÜÿÿƒøu"D‹
¢zHwD‹¬yH
Muÿç–I‹Ïè§ÃëŠymˆ1uètüÿÿL‹À3ÒBŠ*ˆL0Hÿ„ÉuñHD$0IÿÆB€<0uöHD$0A€|ÿ\tHL$0HÿÉHÿÁ€9uø·%mf‰HL$0HÿÉHÿÁ€9uøM‹@3ÒAŠˆHÿ„ÀuòLD$0ºðH‹Ïÿ“–ëYAy8ÿÿÿuOHƒd$ E3ɺþA¸ˆÿe–IƒÎÿH‹ÏA;Æuÿƒ–ENëÿw–A¹E3ÀºpH‹Èÿà•3ÀH‹Œ$@H3ÌèRLœ$PI‹k(I‹{0M‹c8I‹ãA_A^A]ÃH‹ÄH‰XH‰xL‰`L‰h UAVAWH¨XúÿÿHìH‹“@H3ÄH‰…€H‹
ÊLH›uHù€H¥uL=vLHDØI‹×Hƒd$@HD$`H‰D$8E3ÉHƒd$0E3ÀÇD$(ƒd$ ÿX…ÀtEƒøu$ÿù”HjuE3ÀH‹ÈEHÿ•3Àé€ÿÕ”E3ÉL£uH‹ÈI‹×ÿ÷”L% xL-¹xM‹ÌM‹ÅH”uHL$pè¾ØÿÿH—uHL$pè©ñH‰jxH…Àu9èà’‹èèL‹ÈLD$pHjuH€èzØÿÿÿP”H•€éRÿÿÿHL$Xèj¹HL$XèÐÀHL$XèÆÀL‹ÈLluºHL$pè
H‹
îwHT$pèÄÖÿÿH‹
ÝwLyHguèªÖÿÿH‹
ÃwHduL‹Ãè”Öÿÿ‹ŽwHguD‹
˜vH€M‹Ä‰D$ èÉ×ÿÿH‹L$`HD$PH‰D$@H•€HD$hE3ÉH‰D$8E3ÀHƒd$0ÇD$(ƒd$ ÿ¶Ž…Àt ÿ\“E3ÉL
uH‹ÈH•€ÿz“H‹L$`ÿoŽA¾D9t$PuH‹
wL€M‹ÇHâtèÕÕÿÿD‹
ÎvHvD‹ØuHÙtHL$pH‰D$ è×ÿÿHƒÏÿHL$pH‹ÇHÿÀ€<u÷H‹L$hH¹tAÆE‹Î‰D$(E3ÀHD$pH‹ÓH‰D$ ÿŽ…Àtÿ—’E3ÉL•tH‹ÈHT$pÿ·’H‹
`vHD$pH‰D$(L€M‹ÇH‰\$ HxtèÕÿÿM‹ÌH‰tM‹ÅHL$pè`ÖÿÿH…tHL$pèKïHcÐrL‹ÈH‹
zuM‹ÆH‹Øè;H‹Ëè‹òM‹ÌL‰d$(M‹ÅL‰l$ HHtHL$pè
ÖÿÿHD$pHÿÇ€<8u÷H‹L$hHD$pAþHLt‰|$(H‹ÓE‹ÎH‰D$ E3Àÿ…Àtÿ¢‘E3ÉL sH‹ÈHT$pÿ‘HL$pM‹ÇH‰L$(L€H‹
WuHˆsH‰\$ è&ÔÿÿA‹ÆH‹€H3Ìè´MLœ$I‹[ I‹{(M‹c0M‹k8I‹ãA_A^]ÃÌÌÌHìXH‹B<H3ÄH‰„$@HL$ è5¶HL$ 蛽HL$ 葽L‹ÈLsºHL$0èØH‹
¹tHT$0èÓÿÿH‹
¨tH…Étè:ñH‹Œ$@H3ÌèMHÄXÃÌÌ@UVW¸@èÆxH+àH‹¬;H3ÄH‰„$0I‹ñH‹ùƒêN„ëêÂtxêñt4ƒú…ëHƒd$ ºëM‹ÈDBÿ¡L‹ÆºìH‹Ïÿ˜ëºëH‰t$ E3ÉDBÿwè>îÿÿ¸H‹Œ$0H3Ìè]LHÄ@_^]ÃH‹£sH…ÀtE3ÉH‰D$ ºA¸rÿ-L&sHrHL$0ÿÔLD$0ºèH‹Ïÿ	LúrºìH‹ÏÿôéAy1ÿÿÿt0Ay8ÿÿÿ…ÿùA¹E3ÀH‹ÈºpÿbéßH‰=ÖuÇ$sÿÆE3ÉE3ÀH‹Èºpÿ2H‹Ïÿ©E3ÉE3ÀH‹ÈºkÿuHƒÊÿLúrH‹ÂHÿÀA€<uöB€|ÿ\tIHÿHÿÁ€9uø·’ef‰HÿÂA€<uöHÿÊHúƒNH‹ÏBÆèôÿÿèùÿÿ…À„-è^ôÿÿH‹
WrH‹è¾èH…Ét€9tLîq‹ÖH‹ÏÿÓŽèöäÿÿƒ=Gr„ëLêq‹ÖH‹Ïÿ¯ŽH‹Íè?Íÿÿ…ÀuH
äqèKÔÿÿƒ=r„´ƒ=kqtKLêq‹ÖH‹ÏÿoŽH‹
tLñqºìÿVŽèqÜÿÿH‹èH…Àt3ÒH‹ÈèwÖÿÿH‹ÍÿŠƒ=¯qtWƒ=fntNLÅq‹ÖH‹ÏÿŽH‹
3tL”qºìÿùèÜÿÿH‹øH…ÀtºH‹ÈèÖÿÿH‹Ïÿ®‰3ÀéZýÿÿèîJÌÌH‹ÄH‰pL‰pL‰x UHhˆHìpH‹^8H3ÄH‰E`H‹ñƒúN„íú„uú…üƒ=ôp„Á€=Ÿl„´Hƒd$HHqL%qH‰D$@ºèÿ=3ÉHÌpŠˆDPHÿÁ„ÀuëHL$PHÿÉHÿÁ€9uøòq·qòf‰AHL$PHÿÉHÿÁ€9uøL l3ÒAŠˆHÿ„ÀuòH‹
IpH…ÉtLL$PLØjHÑpèÏÿÿº3Éÿ?ŒH‹Èÿ®ŒL‹øLL$0HD$PLD$8H‰D$8HL$PèàÿÿD‹ð…Àt¹èüêH‹ÈH’pE‹Æè²ÎÿÿL‹t$0M…ötM‹ÆºìH‹Îÿ?ŒL pºèH‹Îÿ*ŒI‹Î袸I‹Ïÿ)Œè|úÿÿëeH‹[oH…ÀtE3ÉH‰D$ ºA¸rÿ勃=fou#H‹­`L†bH…ÀºìH‹ÎLEÀÿÁ‹E3ÉE3ÀºH‹ÎÿU‹¸ë)Ay8ÿÿÿuÿ¾‹A¹E3ÀH‹Èºpÿ'‹3ÀH‹M`H3ÌèiGLœ$pI‹sM‹s M‹{(I‹ã]ÃH‰\$UHl$àHì H‹÷5H3ÄH‰EH‹¹nHL$$3ÒDBdè¹_HƒeðHM3À3ÒH‰EøH‰EH‰ED@`è—_3ÉÇD$ hÇD$$ÿg†Hƒd$PHL$ H‰D$(H`ìÿÿH‰D$HHÇD$0kÿÄ…HL$ ÇD$$H‰EðH4ðÿÿH‰D$HHÇD$0lÿ˜…HL$ ÇD$$H‰EøHlùÿÿH‰D$HHÇD$0mÿl…HL$ ÇD$$H‰EH„üÿÿH‰D$HHÇD$0nÿ@…3ÉÇE`H‰Eÿ¥…HƒeØHMHƒeèƒeÀH‰E HEðH‰EÈH‰]˜ÇE” ÇE¸ÿÿ„H‹MH3ÌèÛEH‹œ$0HÄ ]ÃÌÌHƒì(H
bÿ_…H…Àu3ÀHƒÄ(ÃHdnH‹Èÿ[…H‰d^H…ÀtÝHƒÄ(HÿàHì¨H‹:4H3ÄH‰„$€=Ølu3ÀëRLËlHÌgHL$@ÿ	‰HD$0A¹E3ÀH‰D$ HT$@HÇÁ€ÿ샅ÀuºH‹L$0ÿ僸H‹Œ$H3ÌèEHĨÃHìÈH‹ª3H3ÄH‰„$°ÇD$(L
2_Hƒd$ LƒmHŒm3Éÿˆƒø /D‹ÀH}mHL$0ÿZˆA¹L¡mHT$03ÉÿPˆH‹Œ$°H3ÌèpDHÄÈÃH‰\$H‰l$AV¸@è"pH+àH‹3H3ÄH‰„$0H‹~~L5‘^H‰D$(H-7m»LL$0M‹Æ‰\$ H‹ÍH$mÿ
„A¸PHT$0H
jèÿÌÿÿH‹,~LL$0H‰D$(H÷lM‹Æ‰\$ H‹Íÿ˃D‹ÃHT$0H
ômèÃÌÿÿH‹ð}L
mH‰D$(HÅlM‹ÆÇD$ PH‹Íÿ‰ƒL‹
Â}H³lA¸H‹ÍÿdƒL‹
¥}H¦lA¸‰:jH‹ÍÿAƒ‰ƒgH¤jH‹u}M‹ÆH‰D$(H~lL‹ËÇD$ 
H‹ÍÿƒH‹K}L
üiH‰D$(H`lM‹ÆÇD$ PH
Vlÿà‚H‹}L
fH‰D$(HFlM‹ÆÇD$ H‹Íÿ²‚H‹ë|L
iH‰D$(H(lM‹ÆÇD$ 
H‹Íÿ„‚HÿËHÿÀ;uøŠÍ\HlH
Ýhˆèu…Àuè…üÿÿ…ÀuuèLýÿÿé­HìkH
±hèìt…Àuè[üÿÿ…ÀuKè’üÿÿ…ÀtBëË€=ht7HÀkH
}hè¸t…Àt ÿ†…E3ÉL¨kH‹ÈHªkÿ¤…èKåÿÿH‰XièsúÿÿH‹
´hÿƒH‹
÷{H…ÉtÿTH‹
õhH…Étÿâ€3ÀH‹Œ$0H3Ìè€ALœ$@I‹[I‹kI‹ãA^ÃÌÌH‹H‹H+Њ:u
HÿÀ„Éuò3ÀÃÀƒÈÃH‰\$UH¬$ðýÿÿHìH‹ì/H3ÄH‰…A¸HUà3Éÿ‚LEàHõjHðèµÈÿÿHêjHðèžáHßjH‹ÈH‹Øè4ÇÿÿLEàH‹ËHÖjè!ÇÿÿLEàH‹ËHÓjèÇÿÿL…ðH‹ËH­jèøÆÿÿH‹Ëè¬ä»hHL$pD‹Ã3ÒèYHD$P‰\$pH‰D$HH•ð3ÛÇE¬HD$pf‰]°H‰D$@E3ÉH¦ZE3ÀH‰D$83ÉH‰\$0ÇD$(D‰\$ ÿ
€…ÀtUH‹L$XSñÿƒÿ­H‹ÈSÿqÿó€H‹Èº€ÿí€H‹L$PÿH‹L$XÿWH‹L$XÿH‹H3Ìè½?H‹œ$ HÄ]ÃH‰\$H‰l$H‰t$ WHƒì0H‹ñè¤lº[H‹ÈH‹èèðPH‹øH…À„¾º]HHèÖPH‹ØH…À„¤º
ÆHHè¹PH…ÀtÆH‹
B:HD$HA¹H‰D$ E3ÀHWÿå}…Àtÿ«‚E3ÉLycH‹ÈH‹ÖÿÍ‚ë=H‹L$HHSÿÄ}©ýÿÿÿtÿw‚E3ÉLiH‹ÈH‹Öÿ™‚H‹L$HÿŽ}H‹Íè>¯H‹\$@H‹l$PH‹t$XHƒÄ0_ÃÌH‰\$H‰l$H‰t$ WHƒì0H‹ñè˜kº[H‹ÈH‹èèäOH‹øH…À„º]HHèÊOH‹ØH…À„¨º=ÆHHè­OH…À„ŽH‹
59HWÆA¹HD$HE3ÀH‰D$ ÿÕ|…Àtÿ›E3ÉLibH‹ÈH‹Öÿ½ë=H‹L$HHSÿœ|©ýÿÿÿtÿgE3ÉLhH‹ÈH‹Öÿ‰H‹L$Hÿ~|H‹Íè.®H‹\$@H‹l$PH‹t$XHƒÄ0_ÃÌ@SHƒì º:èðNH‹ØH…ÀuHƒÄ [ÃHÿþè×·…ÀuñH‹ËHƒÄ [Hÿ%}@SHƒì º:è´NH‹ØH…ÀuHƒÄ [ÃHÿþ蛷…ÀuñH‹ËHƒÄ [Hÿ%ð|H‰\$H‰t$WHƒìPH‹Â+H3ÄH‰D$@º[è`NH…Àu3ÀéÜHHº]èFNH‹ØH…ÀtãHÿÃÆH5±UH‹ÓH+ÖH‹Æ¶D¶A+ÈuHÿÀE…Àuë…É„ŽHƒd$8HþfHƒd$ LL$ LD$(H‰D$0H‹ËH‰\$(èÔÿÿ…Àt¹èöÞH‹ÈHÌfè¯ÂÿÿH‹|$ H…ÿt!€?tÿÒE3ÉLØfH‹ÈH‹×ÿôH‹Ï褬H+óŠˆHÿÄÉuô¸H‹L$@H3Ìèû;H‹\$hH‹t$pHƒÄP_ÃÌÌÌH‹ÄH‰XH‰pH‰x UATAUAVAWH¨xðÿÿ¸`ègH+àH‹u*H3ÄH‰…PE3öH‰T$@3öD‰t$0!t$43ÿL‹ÂEn
ƒùtHCféîH‹JŠ:Jf…ÕŠA:‹”$ˆé÷üÿÿö t	AÇë$H´~ëH“~ëHj~I‰G AÇA‹ÊE+èÁéAÅ‹ÁH+øE‰o‹ÁD+çÁàAƒÄD+ÐE‰gHGE‰VDI‰A‹ÊI@I‰G¸ÓàÿÈ#ÃA‰F@HƒÄ(A_A^A]A\_^][ÃÌE3ÀH…ÉtfH‹Q(H…Òt]D‰BD‰AD‰AL‰A ‹B…Àtƒà‰ALƒŠÜÿH‚HH‰‚€H‰B`H‰BX3ÀL‰D‰BÇB€L‰B L‰B@Ç‚ØøþÿÿÿÃ3ÒH…ÉtH‹A(H…ÀtH‰P,‰P4épÿÿÿ¸þÿÿÿÃÌÌH‰\$H‰l$H‰t$WHƒì ‹ÚH‹éH…ÉtXH‹y(H…ÿtO…Òy3ö÷Ûë‹óÁþÿƃû0}ƒã…ÛtCøƒøw*H‹W8H…Òt9_(tH‹I@ÿU8Hƒg8H‹Í‰w‰_(èhÿÿÿë¸þÿÿÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃH‰\$H‰t$WHƒì ‹òH‹ÙM…À„—A€81…AƒùX…ƒH…ÉuAþë~Hƒa Hƒy0uHƒa@Hy"H‰A0Hƒy8uHs"H‰A8H‹I@ºA¸èÿS0H‹øH…ÀuGüë1H‰{(‹ÖHƒ`8H‹ËèÕþÿÿ‹ð…ÀtH‹K@H‹×ÿS8Hƒc(‹Æë¸úÿÿÿH‹\$0H‹t$8HƒÄ _ÃÌÌÌE‹ÈL‹Âºé$ÿÿÿE‹ØH…ÉtJL‹I(M…ÉtA…Òy
Aƒa@AƒaD3ÀÃú+E‹ADEAƒú w‹ÊE‰QD¸ÓàA‹ÈÿÈA#ÃÓàAA@ë͸þÿÿÿÃHiqÇAh	H‰AXHWyH‰A`ÇAlÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì H‹Y(E3öA‹èH‹òH‹Á¿L9s8u!‹K(‹×ÓâD‹ÇH‹H@ÿP0H‰C8H…Àu‹Çé‹D9s,u‹K(Óç‰{,L‰s0‹{,;ïrH‹K8H+÷H‹ÖD‹ÇèPD‰s4‹C,ëR+{4H‹Ö‹K4;ýGýHK8D‹ÇH+ÕèâO+ïtH‹K8D‹ÅI+ðH‹ÖèÌO‰k4ëÃ{4‹C4;C,ADƉC4‹C0;C,sljC03ÀH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃÌ@USVWATAUAVAWH‹ìHƒìXH‹y(3ÒL‹áH…ÿ„¹H9Q„¯H9u	9Q…¡ƒ?uÇD‹QE‹ÂL‹YL‹	D‹iD‹w@‹wDL‰]èL‰MàD‰UHD‰mÜD‰UP‰UØH_lLh¸‹ƒù	„Ð;È-„ñ…É„TƒétCƒé„ƒé„\ƒé„Ùƒé„ùƒù„¸þÿÿÿHƒÄXA_A^A]A\_^[]ø;ðs&E…í„A¶‹ÎÓàIÿÁDðL‰MàAÿ̓ƃþrÚD‰wA€þtH·yéA÷ÆàtHÚyéH‹O H…ÉtA‹ÆÁèƒà‰÷Gt'‹OHUXDˆuXA¸AÁîDˆuYèžîÿÿL‹Mà3Ò‰GD‹òÇ‹òë!E…í„xA¶‹ÎÓàIÿÁDðL‰MàAÿ̓ƃþ rÚH‹G H…ÀtD‰p÷Gt5‹OHUXA‹ÆDˆuXÁèA¸ˆEYA‹ÆÁèAÁîˆEZDˆu[èîÿÿ‰G3ÒL‹MàD‹ò‹òÇ»ë!E…í„ñA¶‹ÎÓàIÿÁDðL‰MàAÿ̓Æ;órÛH‹O H…ÉtA¶Æ‰AA‹ÎH‹G Áé‰H÷Gt#‹OHUXDˆuXA¸AÁîDˆuYè˜íÿÿ‰G3ÒL‹MàD‹ò‹òÇë»÷G……H‹G H…ÀtH‰PL‹MàÇ÷G„‹_HA;ÝAGÝ…Û„ðH‹G H…À„§L‹HM…É„š‹P+WH‹H;Ávp+ÊënE…í„üA¶‹ÎÓàIÿÁDðL‰MàAÿ̓Æ;órÛH‹G D‰wHH…ÀtD‰p÷Gt#‹OHUXDˆuXA¸AÁîDˆuYè¯ìÿÿ‰G3ÒD‹ò‹òé=ÿÿÿ‹ËL‹}àD‹Á‹ÊI‹×IÉèîK3ÒëL‹}à÷GtM…ÿu‹Âë‹OD‹ÃI‹×èbìÿÿ3Ò‰GL‹MàD+ë‹ÃLÈ)_HL‰Mà9WH…:‰WHÇ÷G„ƒE…í„‹Ú‹ÃÿÃF¶<H‹G H…ÀtH‹P H…Òt‹OH;H(sDˆ<ÿGH3ÒE…ÿtA;ÝrÊ÷Gt M…Éu‹Âë‹OD‹ÃI‹ÑèÊëÿÿL‹Mà3Ò‰G‹ÃD+ëLÈL‰MàE…ÿtM‹ùéÁH‹G H…ÀtH‰P ‰WHÇ÷G„ðE…í„u‹Ú‹ÃÿÃF¶<H‹G H…ÀtH‹P0H…Òt‹OH;H8sDˆ<ÿGH3ÒE…ÿtA;ÝrÊ÷G„‹M…É…k‹Âéx9Wu,ÇépûÿÿE…í„A¶‹ÎÓàIÿÁDðL‰MàAÿ̓Ƹ;ðrÖöGtEAþ‹u<‰WD@òHUXfD‰uX3ÉèÇêÿÿ3Ò‰GD‹òÇ‹òL‹MàD‹EPD‹UHL‹]èéûúÿÿH‹G ‰WH…ÀtƒH@ÿöG„®A¶ÎA‹ÆÁèÁáȸ…B÷á‹Á+ÂÑèÂÁèkÀ;È…€A‹Æ$<tHuI‰D$ Ç3Òé“úÿÿAÁîƒÆüA‹Î3ÒƒáƒÁ9W(u9‰O(AÁî¸A÷ÖÓàAƒæ‰GAƒÎ	ÇGAÇD$L‹òD‰7D‹òéCúÿÿ;O(vÅHÂtë	3ÒHtI‰D$ Çéúÿÿ‹OD‹ÃI‹ÑèµéÿÿL‹Mà3Ò‰G‹ÃD+ëLÈL‰MàE…ÿ…çýÿÿë
H‹G H…ÀtH‰P0D‹EPLhD‹UHH_lL‹]èÇ÷G„“ékƒétéƒé„ƒé„Qƒé„gƒé„^ƒétƒù…Üùÿÿë\‹ÎƒáAÓî+ñë!E…í„A¶‹ÎÓàIÿÁDðL‰MàAÿ̓ƃþ rÚA‹ÆA·Î÷ÐÁè;ÈtH&téÿÿÿ‰OHD‹ò‹òÇÇD‹HE…ÿ„E;ýEGýE;úEGúE…ÿ„–
E‹ÇI‹ÑI‹ËA‹ßèðGL‹MàE+ïD‹UHLËL‹]èE+×D‹EPLÛD)HH_lLhL‰MàD‰UHL‰]èéþÿÿE…í„C
A¶‹ÎÓàIÿÁDðL‰MàAÿ̓ƃþ rÚA‹Î¾ÿ#ÎA‹ÆÁàÈA‹ÆÁè#ÆÁáAÁîÁAÆ‹ò‰GD‹òA‰D$LÇ
9W„¹ÇGAÇD$LÇ9Wt:‹ÎǸ#ÈAÓî+ñéøÿÿE…턧A¶‹ÎÓàIÿÁDðL‰MàAÿ̓ƃþrÚA‹Æÿ΃àAÑî‰GA‹ÆƒàtWƒèt'ƒètƒøuNH™rI‰D$ Çë:¸‰ë1HlgAÇ	H‰GXHZoH‰G`ÇÇëÇ
AÁîƒÆþék÷ÿÿE…í„A¶‹ÎÓàIÿÁDðL‰MàAÿ̓Ƹ;ðrÖ·GD;ðtHôqéýÿÿD‹ò‹òH‹O H…Ét‹GÁø	ƒà‰AnL‹MàD‹EPD‹UHL‹]èI‰D$ ÇésòÿÿH‹HOlD‹GxL‹ËH‰G`‹GtHƒÀDÇL‰|$(H‰L$ ¹HGè‡
3Ò‰EØ…Àt	H÷më—L‹MàLhD‹EPH_lD‹UHL‹]èÇÇAƒýruAúrlM‰\$A‹ÐE‰T$I‹ÌM‰$E‰l$D‰w@‰wDè‘éÿÿƒ?ºM‹\$M‹$E‹T$E‹l$BD‹w@‹wDD‹EPL‰]èD‰UHL‰Mà…¤ñÿÿƒÜÿé˜ñÿÿA‹¸L‹_XÓà‰—ÜHÿA‹ÆH#ÈA‹‹ë;E…í„A¶‹ÎÓàIÿÁA‹Dð¸L‰MàÓàAÿ̓ÆHÿA‹ÆH#ÈH‹GX‹ˆ‹ÈÁé¶É;Îw¹„À„̨ð…ÄD‹Ð¶ÈAÁêA¹E¶Â‹ÐAȉE`AÓáA‹ÈAÿÉÁèE#ÎAÓéDÈC‹‹‹ÈÁéD¶ÁA¶ÊDÁD;ÆviL‹}àE…í„€A¶‹ÎD¶MaA¸ÓàIÿÇDð¶Ê·EbAÉAÓàAÿÍAÿÈL‰}àE#ÆA‹ÉAÓèƒÆDÀH‹GXB‹€‹ÈÁéD¶ÁEÁD;ÆwŸLh¶MaAÓî+ñ3҉܋ÈÁé¶ÉÜ+ñAÓî‹ÈÁé‰OH„ÀuÇéõÿÿ¨ tƒÜÿÇéõÿÿ¨@tH=jé²úÿÿL‹Mà¶ÈƒáljOP‹WP…ÒtCë!E…í„šA¶‹ÎÓàIÿÁDðL‰MàAÿ̓Æ;òrۋʸÓà+òÿÈA#ÆAÓîGH—Ü‹GH3Ò‰‡àÇ‹¸L‹_`ÓàHÿA‹ÆH#ÈA‹‹ë:E…í„A¶‹ÎÓàIÿÁ‹Dð¸L‰MàÓàAÿ̓ÆHÿA‹ÆH#ÈH‹G`‹ˆ‹ÈÁé¶É;Îwº¨ð…¾D‹Ð¶ÈAÁêA¹E¶Â‹ÐAȉE`AÓáA‹ÈAÿÉÁèE#ÎAÓéDÈC‹‹‹ÈÁéD¶ÁA¶ÊDÁD;ÆveL‹}àE…í„”A¶‹ÎD¶MaA¸ÓàIÿÇDð¶Ê·EbAÉAÓàAÿÍAÿÈL‰}àE#ÆA‹ÉAÓèƒÆDÀH‹G`B‹€‹ÈÁéD¶ÁEÁD;ÆwŸ¶MaAÓî+ñÜL‹MàLhD‹EP‹ÈD‹UHL‹]èÁé¶ÉÜ+ñAÓî¨@tHXhé“óÿÿ‹ÈÇÁé‰OL¶Èƒá‰OP‹WP…ÒtOë-H$iégóÿÿE…턽A¶‹ÎÓàIÿÁDðL‰MàAÿ̓Æ;òrۋʸÓà+òÿÈA#ÆAÓîGL—ÜÇ3ÒE…Ò„Z‹OLA‹ÀA+Â;ȆÑ+È;O0†¥9—Ø„™H†géZóÿÿƒét¾ƒé„Wƒét.ƒé„ùƒé„ƒé„ñƒù…­íÿÿ¸üÿÿÿé¨íÿÿ9W„Åë!E…í„ÑA¶‹ÎÓàIÿÁDðL‰MàAÿ̓ƃþ rÚE+ÂED$DGE…Àt?9WI‹ÓA‹ÀtH+Ðu‹Âë#‹OèŽÜÿÿë‹OH+Ðè­ØÿÿL‹]è3ÒD‹UHL‹Mà‰GA‰D$LA‹ÎD‰UPáÿA‹ÆÁàE‹ÂÈA‹ÆÁè%ÿÁáÈA‹ÆÁèÈ9WAEÎ;OtH\héPòÿÿD‹ò‹òÇ9W„9W„
ë!E…í„ôA¶‹ÎÓàIÿÁDðL‰MàAÿ̓ƃþ rÚD;w„ÓHhéõñÿÿE…Ò„¸ŠGHAˆIÿÃAÿÊL‰]èD‰UHÇéùëÿÿ‹G4;Èv	‹W,+È+Ñë+Á‹ÐHW8‹GH;Èv
ë	‹GHI‹ÓH+Ñ‹ÈA;ÊAGÊD+Ñ+ÁD‰UHI+Ó‰GHBŠAˆIÿÃÁÿuñ3ÒL‰]èA9WH…›ëÿÿÇéëÿÿM‰\$¸E‰T$M‰$E‰l$D‰w@‰wDéÊëÿÿÇEØýÿÿÿL‹}àëD‹ò‹òÇÇEØëæL‹}à3ÒH‹Eè‹]PI‰D$‹EHA‰D$M‰<$E‰l$D‰w@‰wD9W,uA;\$t+ƒ?&I‹T$D‹ÃE+D$I‹Ìèyéÿÿ3Ò…ÀtÇé–ýÿÿA+\$A\$‹EÜA+D$AD$_9Wt>…Ût:9WI‹T$‹ÃtH+Ðu‹Âë‹OD‹ÃèIÚÿÿë‹OH+ÐD‹ÃèeÖÿÿ3Ò‰GA‰D$Lƒ?tƒ?D‹ÂuA¸‹G÷ظ€Ƀá@ƒ?DЋEØAÈѹûÿÿÿWD…ÀA‰T$HDÁé¤êÿÿ@SHƒì H‹A(H‹ÙH…Àt-L‹A8M…Àt$H‹P8H…ÒtH‹I@AÿÐH‹S(H‹K@ÿS8Hƒc(3Àë¸þÿÿÿHƒÄ [ÃÌÌH‰\$H‰t$WHƒì I‹øH‹òH…ÉtMH‹Y(H…ÛtD‹C0…Àt/H…Òt*‹S4H‹Î+ÂHS8D‹Àè½8D‹C4‹K0H‹S8I+ÈHÎè§8H…ÿt‹C0‰3Àë¸þÿÿÿH‹\$0H‹t$8HƒÄ _ÃH‰\$H‰l$H‰t$WHƒì A‹ðH‹êH‹ùH…ÉtH‹Y(H…Ûtƒ{tƒ;
t¸þÿÿÿH‹\$0H‹l$8H‹t$@HƒÄ _Ã;
uD‹Æ¹èêÔÿÿ;Ct¸ýÿÿÿëÍH.D‹ÆH‹Ïèçÿÿ…Àt
Ǹüÿÿÿë­ÇC3Àë¢ÌÌÌH…ÉtH‹A(H…Àtö@tH‰P ƒb@3ÀøþÿÿÿÃÌÌÌD‹	E3ÒL‹ÙE…ÀttQ‹VDE3À‹ÊǃáÓf@+щVDƒúr"D‹N@ŠF@ƒÂøAÁéBˆD0AÿÀD‰N@ƒúså‰VDHN|ƒ!HT$0èÿÿÿH‹HN|D‹GèÿÿÿG)GD‹W‹ÈHƒ~|t¸ýÿÿÿë#D‹OH‹ÏèäÿÿD‰W3ÀD‰OÇë¸þÿÿÿH‹\$8H‹t$@HƒÄ _ÃÌ3ÀH…ÉtH‹I(H…Étƒ9
u9ADu¸øþÿÿÿÃÌÌH‰\$H‰l$H‰t$WAVAWHƒì H‹ÚH‹éH…É„áH…Ò„ØH‹z(H…ÿ„ËH‹B0H…À„¾Hƒz8„³H‹K@A¿A‹×A¸èÿÐH‹ðH…Àu
¸üÿÿÿé‘E3öL9w8t&‹O(A‹×ÓâE‹ÇH‹K@ÿS0L‹ðH…ÀuH‹K@H‹ÖÿS8ëǺ7H‹ÎH‹ÇEKDBIMC E K0M0C@E@òKPòMPHI@ A H0I0@@A@HPIP@`A`IÈHpIÀIðI+×u·ºHHI@ A H0I0@@A@HPIPH‹@`H‰A`H‡HH‹OXH;ÈrAH‡ÔH;Èw5H+ÏH+ÊHÁùHRH†H‰FXH‹G`H+ÇH+ÂHÁøHRH†H‰F`H‹‡€H+ÇH+ÂHÁøHRH†H‰†€M…öt‹O(H‹W8AÓçI‹ÎE‹ÇèT4L‰v83ÀH‰u(ë¸þÿÿÿH‹\$@H‹l$HH‹t$PHƒÄ A_A^_ÃÌÌH…ÉtH‹A(H…ÀtǀظýÿÿÿøþÿÿÿÃ3ÒH…Ét-H‹A(H…Àt$ƒ8u‹PHëƒ8u	‹à+PH‹€ÜÁàÂøÿÿÃÌÌH‰\$UVWATAUAVAWHl$éHìÀH‹…õH3ÄH‰EL‹}H‹òH‰U¿M‹é3ÒE‹ØL‹Ew‹ÙL‰M·D‹Ò‰M‡DbL‰EÇL‰}¯A‹ÂHÀHƒø ƒEÔf‰TÏAƒúvâA¾E…ÛtH‹ÎI‹Ó·IÎfDdEÏI+ÔuïA‹8ƒÉÿ‰M‹A¹A‹Áf9TEÏuDÉE;ÌsîA;ùAGùE…ÉuHÇD$ @‹D$ I‹M‰IƒEM+ôuðE‰ 3ÀH‹MH3ÌèõH‹œ$HÄÀA_A^A]A\_^]ÃE‹ÄE;ÌvHEÑf9uEÄIÆE;ÁrðA;øA‹ÔE‹ÔABøA‹ÂÒ·LEÏ+ш0EÔAƒúvåE3Ò…Ò~…Û„E;Ì…fD‰UñI‹Êº·D
ÑfD
ñf‰D
óIÎI+Ôué3ÀE…Ût+H‹Öf9t··LEïfE‰O·fDdEï3ÀEÔIÖE;ÓrØE3Û…ÛtBA;ÜtH5e[AƒÊÿH‰u—H\ë5¸HÈ[H+ÐH5~[H+ðAºH‰u—ëI‹÷L‰}—I‹×AºI‹EA‹ÛD‰\$$E‹ãD‰\$(‹ÏA»H‰EŸAÓã‹M‡E‹ûH‰UD‰]ƒACÿ‰E§ƒùu	AûTwA;ÎuAûPv
¸épþÿÿ‹ËëD‹d$(AŠÀA*ĈD$!‹ÁH‹M¯·AA;Ê}
3Àf‰L$"ˆD$ ë~
ŠNˆD$ ·JëÆD$ `3Àf‰D$"‹D$ A‹ÈL‹mŸA+̾D‰]«Óæ‹ÓA‹ÌÓêAÓ+ÖA‰D•D+ÞuôL‹m·AHÿASÓâëÑê…ÓuúE3Û…Òt	Bÿ#ØÚëA‹Û‹L$$ºÿÿÿÁA‹À‰L$$fTEÏu E;Á„‹ÁH‹M¯·AH‹E¿D·H‹L$$D‹]ƒH‹UH‹u—D;džÿÿÿD‹e§D#ãD;e‹„ÿÿÿD‹\$(A‹ðH‹MŸE…Û‹E«ºDDßA+óD‰\$(DÞHH‰MŸ‹ÎÓâE;ÙsB·L]Ï+Ñ…Ò~ÿÆAÿÃÒE;ÙrèL‹m·‹E‡‹ÎA»AÓãEûD‰]ƒƒøu
AÿT‡{þÿÿA;Æu
AÿP‡iþÿÿI‹EH‹UD‰e‹Bˆ4 I‹EH‹u—Bˆ| I‹MH‹EŸH+ÁHÁøfB‰D¡‹L$$é<þÿÿ…Ût H‹UŸE*Ä‹ËÆD$ @DˆD$!fD‰\$"‹D$ ‰ŠA‹ÇHÁàIEH‹Elj8élüÿÿƒÈÿéfüÿÿèŽÌÌHeøeÃÌ̸+ÁH
ÂYH˜H‹ÁÃÌÌÌA¯Ð‹Êé¥ÅÌH‹Êé¬rÿ%6Aÿ%(Aÿ%‚Cÿ%tCÿ%fCÿ%XCÿ%JCÿ%ÿ%†Cÿ%xDÿ%bDÿ%dDÌÌÌÌÌÌÌÌÌÌff„H;
¹îòuHÁÁf÷ÁÿÿòuòÃHÁÉé7ÌÌÌ@SHƒì H‹Ù3Éÿ›AH‹ËÿŠAÿ´@H‹Èº	ÀHƒÄ [Hÿ%€AH‰L$Hƒì8¹èÙ'…Àt¹Í)H
ƒýèÚH‹D$8H‰jþHD$8HƒÀH‰úýH‹SþH‰ÄüH‹D$@H‰ÈýÇžü	ÀǘüÇ¢ü¸HkÀH
šüHǸHkÀH‹
ÂíH‰L ¸HkÀH‹
µíH‰L H
tèÿÿÿHƒÄ8ÃÌÌÌHƒì(¹èHƒÄ(Ã̉L$Hƒì(¹èò&…Àt‹D$0‹ÈÍ)H
›üè‚H‹D$(H‰‚ýHD$(HƒÀH‰ýH‹kýH‰ÜûÇÂû	ÀǼûÇÆû¸HkÀH
¾û‹T$0H‰H
_sèNþÿÿHƒÄ(ÃÌL‰D$‰T$‰L$Hƒì8¹èM&…Àt‹D$@‹ÈÍ)H
öûèÝH‹D$8H‰ÝüHD$8HƒÀH‰müH‹ÆüH‰7ûÇû	ÀÇûƒ|$HvHƒ|$PuÇD$Hƒ|$Hv
‹D$HÿȉD$H‹D$HÿÀ‰÷ú¸HkÀH
ïú‹T$@H‰ÇD$ ë
‹D$ ÿÀ‰D$ ‹D$H9D$ s"‹D$ ‹L$ ÿÁ‹ÉH¶úL‹D$PI‹ÀH‰ÊëÊH
Prè?ýÿÿHƒÄ8ÃÌÌH‰\$ WHƒì@H‹Ùÿ±>H‹»øHT$PH‹ÏE3Àÿ¡>H…Àt2Hƒd$8HL$XH‹T$PL‹ÈH‰L$0L‹ÇHL$`H‰L$(3ÉH‰\$ ÿr>H‹\$hHƒÄ@_ÃÌÌÌ@SVWHƒì@H‹ÙÿC>H‹³ø3ÿE3ÀHT$`H‹Îÿ1>H…Àt9Hƒd$8HL$hH‹T$`L‹ÈH‰L$0L‹ÆHL$pH‰L$(3ÉH‰\$ ÿ>ÿǃÿ|±HƒÄ@_^[ÃÌÌÌ@SHƒì ¹èÄèS‹Èèœßè³üH‹Øè;¹‰è„ÀtlèÆ
H
èJè
‹ÈèæÌ…ÀuVèèX…ÀtH
éè„Äèèèñ‹Èèêêè„ÀtèDØèÇ	3ÀHƒÄ [ùè1̹è&ÌÌHƒì(èÛ3ÀHƒÄ(ÃHƒì(èç	è–‹ÈHƒÄ(éÃûÌÌÌHƒì(è»HƒÄ(éÌÌH‰\$WHƒì0¹èø„Àu¹èÂÌ@2ÿ@ˆ|$ èlŠØ‹
Ìýƒùu
¹è…ÉuJǯýH ?H
a?è¸Ù…Àt
¸ÿéëH??H
(?èÙÇqýë@·@ˆ|$ ŠËèè#H‹ØHƒ8t"H‹Èèj„ÀtH‹H‹Ëè×	E3ÀAP3ÉÿÓèûH‹ØHƒ8tH‹Èè:„ÀtH‹è6Ýè1·Øèå×L‹ÀD‹Ë3ÒH
âhÿÿèÙÂÿÿ‹ØèN„Àu‹ËèGÝ@„ÿuèÕÜ3ұ訋Ãë!‹Øè%„Àu‹ËèÆÜÌ€|$ uè™Ü‹ÃH‹\$@HƒÄ0_ÃHƒì(èë‹ÈHƒÄ(éÀʸÃÌÌéSÖÌÌÌ@SHƒì è‘·ØèE×L‹ÀH
GhÿÿD‹Ë3ÒHƒÄ [é4ÂÿÿHƒì(èëHƒÄ(é2þÿÿÌÌH‹èH‹Ñ‹ÈH3ƒá?HÓÈÃÌÌL‹èH‹ÁA‹Ð¹@ƒâ?+ÊHÓÈI3ÀÃÌÌH‹Á‹ÊHÓÈÃÌÌÌLcAO¹L*OèùøÿÿH‹ðH…ÀtH‹ÈèÑçÿÿH‹Ó‹ÏÿÖëH‹Ó‹ÏÿÁH‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰l$H‰t$WHƒì A‹èL
òN‹ÚLáNH‹ùHßN¹è‰øÿÿH‹ðH…ÀtH‹ÈèaçÿÿD‹Å‹ÓH‹ÏÿÖë‹ÓH‹Ïÿ6H‹\$0H‹l$8H‹t$@HƒÄ _ÃÌH‹ÆE3À‹Â¹@ƒà?E‹È+ÈHÈÛIÓÉH
ÜL3ÊH;ÈHÉH÷уá	IÿÀL‰H@L;ÁuñÃÌÌÌ„Éu9SHƒì HlÛH‹H…ÉtHƒùÿtÿ8Hƒ#HƒÃHiÛH;ØuØHƒÄ [ÃÌÌH‹õŹ@‹Âƒà?+È3ÀHÓÈH3ÂÃL‹ÙÅH‹ÁA‹Ð¹@ƒâ?+ÊHÓÈI3ÀÃÌÌH‹¹Å¹@‹Âƒà?+È3ÀHÓÈH3ÂH‰FÛÃÌÂÌHƒ!H‹ÁÃH‰\$H‰t$WHƒì Hƒ!H‹úÆAAŠðaÿÿÿH‹ÙH‹H…Ò„–€:„‡E3ÀL‹AŠ	@:ÎtAAÜ<;wIºò?åÿÿI£ÂrAŸ<v€Á€€ù~v÷úÚt5IAAÿÀH‰€8u´H‹ËèmH‹Š„ÉtHÿÀH‰@:Ît&Hƒ#ÆCëÆCë€{uÆCë
ÆAëÆAH‹t$8H‹ÃH‹\$0HƒÄ _ÃH‹ÁóÃ̈T$SHƒì Hƒ!H‹ÙÆAaÿÿÿ„ÒtA¸HT$8èåH‹ÃHƒÄ [ÃH‰\$H‰t$WHƒì 3öH‹úH‹ÙH…ÒtHE3ÀVH
;Úè@H…ÀtH
’ZH‰ŠO€é€ùHFþH‰xëH‹ÆH‰H÷ØÀöÐ$ˆCë@ˆqH‰1cÿÿÿH‹ÃH‹\$0H‹t$8HƒÄ _ÃÌÌÌ@SHƒì H‹Ù3ɈKcÿÿÿH‰H…Òt!H‹ÂD‹Á8
tHÿÀAÿÀ8uöE…ÀtH‹ËèH‹ÃHƒÄ [ÃÌH‰\$WHƒì aÿÿÿBþ3ÿH‹ÙD‹ÂOH‰;;ÁDGÇDˆC;Ñuè÷kH‰H…ÀuÆCH‹ÃH‹\$0HƒÄ _ÃÌHƒ!H‹ÁÆAaÿÿÿÃÌ@SHƒì@H‹+ÃH3ÄH‰D$8E3ÛLL$5DˆYL‹ÂaÿÿÿH‹ÙL‰EŠÓDˆ\$5H…ÒyA²I÷ØIÿÉH¸ÍÌÌÌÌÌÌÌI÷àHÁêŠÂÀàÉD*ÁA€À0EˆL‹ÂH…ÒuÐE„ÒtIÿÉAÆ-LD$5I‹ÑE+ÁH‹ËèH‹ÃH‹L$8H3ÌèÕÓÿÿHƒÄ@[ÃÌÌÌ@SHƒì@H‹ÂH3ÄH‰D$8E3ÒLL$4DˆQL‹ÂaÿÿÿH‹ÙL‰DˆT$4IÿÉH¸ÍÌÌÌÌÌÌÌI÷àHÁêŠÂÀàÉD*ÁA€À0EˆL‹ÂH…ÒuÐLD$4I‹ÑE+ÁH‹ËèƒH‹ÃH‹L$8H3ÌèCÓÿÿHƒÄ@[ÃÌHõWH‰H‹ÁÃÌÌHeX‰QH‰3ÀƒúD@ADÀ‰AH‹ÁÃÌÌ̃	ÿH‹ÁÃÌAƒÊÿHAXD‰D‰L‰{×L‰l×E3ÀH…ÒtD‰
u×H‰f×ëL‰]×D‰^×H‰/׋D$0‰Q×H‹D$(H‰Q×H‹ÁH‰
×Dˆ8×ÃÌÌÌHeWˆQH‰H‹ÁÃÌÌÌE3ÀHŽWH‰H…Òt	ŠB,<vL‹ÂL‰AH‹ÁÃÌ̃IÿH¥WH‰H‹ÁH‰QL‰AÃÌÌH‰\$H‰t$WHƒì A‹øHWH‰H‹òH‹ÙE…ÀtEH…Òt@Hc×H
¶ÖE3ÀèŠ<H‰CH‹È‰{H…Àt…ÿt$H+ð‹×ŠˆHÿÁHƒêuòëƒcë	HƒaƒaH‹t$8H‹ÃH‹\$0HƒÄ _ÃH‹ÑH
ZÖé1<ÌH‹ÁóÃ̈T$SHƒì Hƒ!H‹ÙÆAaÿÿÿ„ÒtA¸HT$8è‘H‹ÃHƒÄ [ÃH‰\$H‰t$WHƒì 3öH‹ú@ˆqH‹ÙaÿÿÿH‰1H…ÒtEE3ÀVH
ÙÕè°;H…ÀtH
0VH‰ŠO€é€ùHFþH‰xëH‹ÆH‰H…Àu
ÆCëÆAH‹t$8H‹ÃH‹\$0HƒÄ _ÃÌÌ@SHƒì H‹ÙH‹Â3ÉD‹ÁˆKcÿÿÿH‰8
t
HÿÀAÿÀ8uöH‹ËèÌH‹ÃHƒÄ [ÃÌÌÌ@SHƒì aÿÿÿH‹ÙˆQ¹;Ñuè¿gH‰H…Àu
ÆCëHƒ#H‹ÃHƒÄ [Ã@SHƒì H‹ÚAƒø	w"ƒ9ÿtD;IcÀH‹LÁóëºëºH‹Ëè:ûÿÿH‹ÃHƒÄ [ÃÌH‰\$H‰|$UH‹ìHƒì`‹Mȸÿÿ!EØ#ÈH‹vÔ¿HƒeÀHƒeЉMÈH…À„Í€8?…ŠP€ú@u>Hƒ:ÔHMàèá)HPH‹ØHMðèrúÿÿH‹ÓHMÀóEÀèî(MÀëU€ú$uV3ÒHMðè°YfoÁfsØf~ÀˆEÈ<t…=óÓuSH‹ÎÓ€8tGH‹ÊÓH‰»ÓHMðèb))MÀë'€ú?uéH‹¥Ó€x@uÜáÿÿƒÉHƒeÀ‰MÈ(MÀ€}Èu3Àé߀}Èt…=…ÓuH‹`Ó€8ufMÐëH‹UÓHMÐèìýÿÿH‹MÓH…ÀuOH‹}ÐH…ÿtH‹H‹H‹ËèÞÿÿH‹ÏÿÓH‹EÓÿÀHcøH‹ËHƒÇ‰ÓHƒçøèÞÝÿÿH‹ÏÿÓH‰þÒH…ÀtSD‹úÒHMÐH‹ÐèºNH‹ßÒH‹ÈŠ„Òt%A° HÿÀA:ÐuDˆëHÿÀD8tø눊HÿÁ„ÒuÞŠˆH‹¦ÒH‹\$pH‹|$xHƒÄ`]ÃÌÌH‰\$WHƒì0H‹ùI‹ØHL$ èþ÷ÿÿH‹ÓH‹Ïóè<H‹\$@H‹ÇHƒÄ0_ÃÌÌH‰\$WHƒì0H‹ùI‹ØHL$ è‚øÿÿH‹ÓH‹ÏóèH‹\$@H‹ÇHƒÄ0_ÃÌÌH‰\$WHƒì0H‹ùI‹ØHL$ èŽøÿÿH‹ÓH‹ÏóèÄH‹\$@H‹ÇHƒÄ0_ÃÌÌ@SHƒì H‹ÚH‹ËóI‹Ðè™H‹ÃHƒÄ [Ã@SHƒì H‹ÚH‹ËóAŠÐèµH‹ÃHƒÄ [Ã@SHƒì H‹ÚH‹ËóI‹ÐèH‹ÃHƒÄ [Ã@SHƒì H‹ÚH‹ËóI‹Ðè‰H‹ÃHƒÄ [Ã@SHƒì H‹ÚH‹ËóA‹ÐèñH‹ÃHƒÄ [Ã@SHƒì €yH‹Ù(Hƒ:u¾RèÊëHƒ9u	óëH‹èõH‹ÃHƒÄ [ÃH‰\$WHƒì A¸@ŠúH‹ÙD8AZ„ÒtVHƒ9uHƒ!ˆT$0HT$0ÆAaÿÿÿèAë1E3ÀH
½ÐAPè6H…ÀtH
ÐP@ˆxH‰H‹ÐH‹ËèvH‹ÃH‹\$8HƒÄ _ÃH‰\$H‰t$WHƒì €yH‹úH‹Ùg3öH…Òt`H91uèLúÿÿëTŠB<v
¾ÐèçëCE3ÀH
?ÐAPè6H…ÀtH
’PH‰ŠO€é€ùHFþH‰xëH‹ÆH‹ÐH‹ËèæH‹t$8H‹ÃH‹\$0HƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì €yH‹òH‹ù\3ÛH…ÒtU8tQH9uè8úÿÿëEE3ÀH
´ÏAPè‡5H…Àt"H‹ÎD‹Ã8t
HÿÁAÿÀ8uöH‹ÖH‹Èè›øÿÿH‹ØH‹ÓH‹ÏèYH‹\$0H‹ÇH‹t$8HƒÄ _ÃÌÌ@SHƒì €yH‹Ù+Hƒ9t Bþƒøv…Òt‹ÊèÔaH‹ÐH‹ËèëèâùÿÿH‹ÃHƒÄ [ÃÌH‰\$WHƒì ƒ9	H‹úH‹Ùt;Hƒ:t5E3ÀH
ûÎAPèÎ4H‹ÈH…Àt	óë3ÉH…Ét
ÿHcH‰LÃH‹ÃH‹\$0HƒÄ _ÃÌÌ€yt
ŠB<~ˆAH‹ÁÃ3ÀH‰H‰A H‰AH‰AL‰AÃÌÌH‰\$WHƒì HƒyH‹ùt4H‹AH‰Aë%H‹GH‹_H‹H‰OH‹ËèÙÿÿH‹OÿÓH‹GH‰GH…ÀuÖH‹\$0HƒÄ _ÃÌ‹&Î÷ШHcÁH
d@H‹ÁuHƒÀÃÌH‰\$WHƒì H‹úH‹ÙH…Òt?E3ÀH
ÎAP èÔ3H…ÀtH‹H
‘NƒHÿH‰H‰PH‰xH‰H…Àu
ÆCëÆAH‹\$0HƒÄ _ÃÌH‹ÄH‰XUVWATAUAVAWHh¡Hìð‹\$HL‹êHƒd$@ãÿÿ)p¸H‹ñ‰\$H)x¨èìUIƒ}‹øtA÷Et	ÇEëƒeÿÿÿuºH‹Îè¯óÿÿéó
ÿþÿu&ºHL$0è“óÿÿI‹ÕH‹ÎóèÉûÿÿéÅ
ÿýÿuAEóé¯
D‹÷A怄QE3ÿD‹ÇAàA¼AøD‰EoºA”Ç%`‰EwA‹ÇA”Ä÷ØÉáôÿÿÊ#ωM·t‹Ç%;„ù…Ét.‹×âú„á3ÉA‹Æú”Á÷ØÀ…Á…ǺçsZ‹
@ÌÁé
7ÌÑé÷ÑöÁHL$0„µè0² HM§H‹ØèŠñÿÿH‹ÓHM‡óE‡èÆúÿÿ(E‡fD$@‹\$HD‹Eo‹E·3É…À„»Aø…®3ÒHL$0èÎ#AE²{HM‡óE‡è¹úÿÿ(E‡HT$0HM‡fE‡èbúÿÿHU‡HL$@èTúÿÿH‹iËHM×€8tW€8At:ºëPè{€|$H„pÿÿÿ€xD‹EoŽfÿÿÿ¶@ãÿÿÿ؉\$HéQÿÿÿHÿÀH3KH‰Ëè_ñÿÿë
ºè›ñÿÿ»…ËuH²,HL$0èzðÿÿHU×HM‡óE‡èµùÿÿ(E‡HªGHM‡fE‡èøúÿÿHU‡HL$@èŽùÿÿH‹GHL$@èÙúÿÿHL$0èÛ‹
¥Ê‹ÁÑè÷Ш„‹ÁÁè÷Ш„ò…Ë…ê² HM§èíïÿÿHT$0HM‡óE‡è'ùÿÿ(E‡HM‡² fE‡èSùÿÿ(E‡HT$@HM‡fE‡èüøÿÿ(u‡‹]oD‹mwéID‹eϺÿÿ!UÿD#â!Uß!Uï!U¯H‰M÷H‰M×H‰MçH‰M§H‰MÇD‰eÏ…À„„E…ÿte‹Ç%=u.²HL$0èÕ!(D$0HL$0²fE÷è¿!(D$0fE×ëE…ÿt$‹Ç%=u²HL$0è”!(D$0fEç²HL$0è~!(|$03ɺÿÿë(}§E…ÿ„•‹Ç%=„ƒ‹CÉLM§!U¯LóÞƒà`ÇD$ <`t'!UÏHL$0Hƒe§HUÇHƒeÇè;(D$0fEÇë9!UHU‡H‰M§H‰M‡HL$0è€}Ït€|$8~¶D$8AäÿÿÿDàD‰eÏ‹
ÀÈ‹ÁÑè÷Шt8Áé÷ÑöÁt.HM‡èÓHT$@HL$0óD$0èS÷ÿÿ(D$0fD$@ë'HL$0褀|$Ht€x~¶@ãÿÿÿ؉\$HIƒ}tQHƒ|$@t>÷>Èu2² HM‡è©íÿÿI‹ÕHL$0óD$0èãöÿÿHT$0HL$@èÔöÿÿëAEóD$@eÿÿE3íL!m‡D9mt_3ÒHM§è”<H©DH‹ØHM—èîÿÿH‹ÓHL$0óD$0èöÿÿHT$0HL$@èpöÿÿ÷žÇt
(D$@é£úÿÿ(u‡ë>E3ÀH
–ÇAPèi-L‹èH…ÀtHƒ Æ@`ÿÿÿëE3íI‹ÕHM—è<0ƒ}·„+E…ÿ„ë‹Ç%=u{HúCHM—èUíÿÿHU÷HL$0óD$0èÎõÿÿ(D$0HL$0²,fD$0è÷õÿÿ(D$0HU×HL$0fD$0èžõÿÿ(D$0HL$0²,fD$0èÇõÿÿ(D$0fD$0ë,E…ÿt]‹Ç%=uOH|CHM—èÇìÿÿóD$0HUçHL$0è@õÿÿ(D$0HL$0²,fD$0èiõÿÿHT$0HL$@èõÿÿëH=CHL$@ècöÿÿHCf|$0HL$0èLöÿÿHT$0HL$@èáôÿÿHM—èè	²(HM‡H‹ØèzëÿÿH‹ÓHL$0óD$0è´ôÿÿ(D$0HL$0²)fD$0èÝôÿÿHT$0HL$@èŽôÿÿE3ÿ}oA”ÇE3äD9ewA”ÄE…öA‹ÄAEÇ…Àt!E…ÿt‹Ç%=tHUÇHL$@èFôÿÿ‹xÅHM—Áè÷Шtèî8H‹ÐHL$@è!ôÿÿë&èÚ8€|$Ht€x~‹L$H¶@áÿÿÿȉL$H‹+ÅHM—Áè÷ШtèÝLH‹ÐHL$@èÔóÿÿë&èÉL€|$Ht€x~‹L$H¶@áÿÿÿȉL$HHM—è?€|$Ht€x~‹L$H¶@áÿÿÿȉL$H‹´ÄÁè÷ШtM…ít(D$@óAEéfúÿÿ(t$@‹]oD‹mwé¯I‹ÕHL$@è@óÿÿA»|E…ö…Ž‹ÇA#Ã=huHT$@H‹ÎèüPéE…öuk‹ÇA#Ã=ptÝ=`uX3ÒHM‡è0(D$@HL$0²{fD$0èóÿÿ(D$0HU‡HL$0fD$0èÀòÿÿ(D$0H¸@H‹Îóèôÿÿ餋Ç%üA;ÃuU(D$@HËCH‹ÎóèÛóÿÿHM—è–8H‹ÐH‹Îèkòÿÿ²}H‹Îè¡òÿÿH‹vÀ8@…RHÿÀH‰cÃéCE3ÒA¹‹ßD‹ïãûA”ÂAå`A”ÁE…öA‹ÁAEÂ÷ØEÀAàôÿÿAÀD#Çt%3É‹Ç%A‹Ö=”Á÷ÚÀ…Át	H@ëgE…Àt%3É‹Ç%A‹Ö=”Á÷ÚÀ…Át	H@ë=E…öEEÊA÷ÙÀ%ôÿÿ…Çt/3É‹Ç%A‹Ö=”Á÷ÚÀ…ÁtH@HL$@è½òÿÿëE…öu‹ÇA#Ã=x„æúÿÿE3ÿûA”ÇE3äE…íA”ÄE…öA‹ÄAEÇ÷ØÀ%ôÿÿ…Çtc3É‹×âA‹Æú”Á÷ØÀ…Áu3ÉA‹Æú”Á÷ØÀ…Át/Hä>HM—èCèÿÿHT$@HL$0óD$0è»ðÿÿ(t$0ëHT$@HM—èj 0)t$@E…öA‹ÄAEÇ…À„ÁÁè	÷Ш„E…öA‹ÄA¸AEÇ…ÀtV3É‹ÇA#À=¸”ÁE…öEÁ…Àt8H?HM—è§çÿÿHT$@HL$0óD$0èðÿÿ(t$0A¸)t$@E…öt‹ÇA#À=tZE…öA‹ÔAE׋Â÷ØÉáôÿÿÁ…Ïtl…Òt‹ÇA#À=t*E…öA‹ÌAEÏ…ÉtN‹ÇA#À=t…Ét>‹ÇA#À=u2Hq>HM—èçÿÿHT$@HL$0óD$0è|ïÿÿ(t$0)t$@‹¤ÀÁè÷Ш„ÂE…öA‹Ä²ÀAEÇ…Àt!3É‹Ç"Â<@A‹Ç”ÁE…öEÁ…Àt	H>ëfE…öA‹ÄAEÇ…Àt)3É‹Ç"Â<€”Á3Àû”ÀE…öEÁ…Àt	Hí=ë/E…öEEçE…ätN@„ú¹”Á3À…Û”ÀE…öEÁ…Àt2HÌ=HM—è/æÿÿHT$@HL$0óD$0è§îÿÿ(t$0)t$@3Éû”Á3ÀE…í”ÀE…öEÁ¹÷ØÀ%ôÿÿÁ…Çt:…
¢¿u2Hu=HM—èÈåÿÿHT$@HL$0óD$0è@îÿÿ(t$0)t$@ºçs-HM=HM—èåÿÿHT$@HL$0óD$0èîÿÿ(t$0ó6Lœ$ðH‹ÆI‹[@A(sðA({àI‹ãA_A^A]A\_^]ÃÌÌÌ‹¿Áè÷ЃàÃÌ‹ö¾Áè÷ЃàÃÌ‹æ¾Áè÷ЃàÃÌ‹Ö¾Áè÷ЃàÃÌ‹ƾÁè÷ЃàÃÌ‹¶¾Áè÷ЃàÃÌ‹¦¾Ñè÷ЃàÃÌÌ‹–¾Áè	÷ЃàÃÌ‹†¾%Ëz¾%ÃH‰\$H‰t$WHƒì Hƒ9A‹øH‹òH‹ÙtaÿÿÿHƒ!ÆAëjH…öta…ÿt]E3ÀH
F¾ƒÿtAPè$H…Àt0D‹ÇH‹ÖH‹Èè9çÿÿë"ºèõ#H…ÀtŠH3>H‰ˆHë3ÀH‰H…Àu
ÆCëÆAH‹\$0H‹t$8HƒÄ _ÃÌÌÌ‹½Áè÷ЃàÃÌ‹²½Áè÷ЃàÃÌ‹
¢½3Àƒá`€ù`•ÀÃÌÌ‹Ž½Áè÷ЃàÃÌ‹~½% Ër½÷ЃàÃH‰\$H‰t$WHƒìPHƒ!H‹ÙÆA¾aÿÿÿ€y…ÿH‹½€8@„ï€8Z„æ…öt3öë²,H‹ËèìÿÿH‹î¼€8„·D¾Aƒè0Aƒø	w(H‹
¸¼HT$@HÿÀH‰Á¼èàçÿÿH‹ÐH‹Ëè•ëÿÿënHƒd$ HT$ d$(ÿÿHL$0H‹øè_+H‹ˆ¼H+ÇHƒø~H‹
`¼ƒ9	t
HT$0èyíÿÿHT$0H‹Ëè@ëÿÿH‹U¼H;ÇucÿÿÿHƒ#ÆCH‹:¼€{„ÿÿÿë
ºH‹ËèíìÿÿH‹t$hH‹ÃH‹\$`HƒÄP_ÃÌÌ@SHƒì0H‹ÿ»H‹Ù€8X„€8Z„ŽHL$ èþÿÿ€|$(ufH‹Ò»€8tZ€8@t`€8ZtºH‹ËèRâÿÿé–(D$ H=:HÿÀfD$ H‰•»HL$ ‹¦»Áè÷ШH:HEÐè³ëÿÿ(D$ óëMHÿÀH‰^»ëéHÿÀHÒ9H‰K»‹a»Áè÷ШH«7HEÐëHÿÀH7H‰ »èoáÿÿH‹ÃHƒÄ0[ÃÌÌH‰\$H‰t$H‰|$UAVAWH‹ìHƒìpH‹îºE3ÿH‹òL‹ñD88„eèŸ!…À‹øAHÿ…ÿu<²[HMÐèTàÿÿWHMÀóEÀèxëÿÿ(EÀHM°²]fE°è¼éÿÿHU°é•e¸ÿÿ÷FL‰}°ttHÜ0HM°è«êÿÿëb‹ÇÿÏ…Àt`H‹ZºD88tT3ÒHMàèn²[HMðH‹ØèÐßÿÿH‹ÓHMÐóEÐèéÿÿ(EÐHMв]fEÐè8éÿÿHUÐHM°èëèÿÿ€}¸~˜L9>te÷Ft
óEÐë<²(HMðèrßÿÿH‹ÖHMÐóEÐè®èÿÿ(EÐHMв)fEÐèÚèÿÿ(EÐfEÐHU°HMÐè„èÿÿ(EÐfE°HU°HMÀèZ(ºmÈEÀóAé…HMðL9:t?²(èûÞÿÿH‹ÖHMÐóEÐè7èÿÿ(EÐH`9HMÐfEÐèzéÿÿ(EÐfEÐë²[è¼ÞÿÿóEкHMÐèÞéÿÿ(EÐHMÀ²]fEÀè"èÿÿHUÀI‹ÎèÞL\$pI‹ÆI‹[ I‹s(I‹{0I‹ãA_A^]ÃÌ@SHƒì@‹ä¸H‹ÙH‹&+÷ШuHƒÂHL$ èþÞÿÿH‹
£¸€9tU¾HÿÁH‰
‘¸ƒø0t0ƒø2tƒø5uHPÍH‹ËèßÿÿëUHL$0è2H‹ÐHL$ èBçÿÿë"H­4HL$ è‹èÿÿëºHL$ èéÿÿHG6HL$ èièÿÿD$ óH‹ÃHƒÄ@[ÃÌÌÌH‰\$UVWH‹ìHƒìPH‹ùH‹òH‹
ø·ŠˆE8„À„éHƒeÐHÿÁeØÿÿƒËÿ¶ÀH‰
Ï·ÆE0ƒøNwe„¯ƒøC‚mƒøEvHƒøGv:ƒøIv,ƒøKvƒøM…PHk6HMÐè2âÿÿéHN6ëéHA6ëàH06ë×H6ë΃øO„7†ƒøS†øƒøX„ãƒø_…í¶HÿÁH‰
*·‹ÃƒûN‡ÐƒøN„»ƒøGwyƒøFsk…ÀtJƒø$t!ƒÀ¼ƒø‡þHà5HMÐèáÿÿéíHMðèÅþÿÿH*6H‹ØHMàèÝÿÿH‹ÓéÍHÿɺH‰
¯¶HMÐèŽáÿÿé¬H’5먃øH‚–ƒøIv#ƒøKvƒøM‡ƒH…5ëƒHt5éwÿÿÿH`5ékÿÿÿH<5é_ÿÿÿƒøO„‰ƒøRtxƒøStgƒøUtVƒøWtEƒÀ¨ƒøw1HÿÉH‰
 ¶HMðèfH~À)EÐH…À…
óéHR5éýþÿÿH65éñþÿÿH5éåþÿÿHþ4éÙþÿÿHâ4éÍþÿÿ»þÿÿÿHƒeÐeØÿÿóEàƒûþ…9»L
iË	]èLEàHUÐHMðèÓ'…]øuH×+HMðè¦åÿÿEðé[ÿÿÿH®1é¾ýÿÿ‹ØƒãëIHÿÉH‰
@µHMðè7fH~À)EÐH…Àu.éÿÿÿHJ3HMÐè¹ßÿÿHê3HMÐèAåÿÿƒûÿ…@ÿÿÿŠ]0ŠM8€ùCt"A»¨ùt€ù_uD€ëE€ûw<öÃu7H3ëH,4HMàèÛÿÿHUÐHMðóEðèŠãÿÿ(EðfEÐHƒ>t,² HMàè ÚÿÿH‹ÖHMðóEðè\ãÿÿHUðHMÐèOãÿÿ(EÐé`þÿÿHƒ>uAöÃt'HÀ3HMÐèïÞÿÿöÃt'H³3HMÐèräÿÿëöÃtHt2HMÐèÃÞÿÿL
”*H‹ÏLEàHUÐè\&ë ºHMðèÚÿÿH‹ÖH‹ÏóèÆâÿÿH‹ÇH‹\$pHƒÄP_^]ÃÌÌ@SHƒì 3ÒH‹ÙèäH‹ÃHƒÄ [ÃÌÌÌH‰\$WHƒì0H‹£³H‹ù€8„ʾºHÿÀƒëAH‰‚³ƒû‡±HL$ èÚÿÿ‹
…³‹ÁÑè÷Ш„ƒƒãþtbƒûtTƒûtFƒût8ƒût*ƒûtƒûtƒûu[H‹Ä%ë=H‹Ë%ë4H‹º%ë+H‹¡%ë"H‹ˆ%ëH‹‡%ëH‹n%ëH‹]%÷ÑöÁuHƒÂHL$ è€ÝÿÿD$ óë
ºè_ÙÿÿH‹ÇH‹\$@HƒÄ0_ÃÌH‹ÄH‰XH‰pH‰x L‰@UATAUAVAWHh©Hì3ö)pÈ)x¸L‹òH‹y²ºÿÿ!U÷M‹ùH‹ÙH‰uï@ˆu¿@80„€8$D‹eu,E‹ÌLE¿HUoHMßè¡H9ußt
Eßóé}ºÿÿH‹²L‹îH‰uÏH‰uß@ˆuÀ¾¸‹ù@ˆuÁD@+A:ÈAMÀ!Uç+ø!U×(}Ï‹²‹Çƒè„+ƒè„§ƒè„Œƒètuƒø…²‹ÂÑè÷Ш„G÷ÒH9ußtGH‹=T$öÂuHƒÇ(EßHMß² fEßè£àÿÿ(EßHMßH‹×fEßèªáÿÿ(EßfEßéìöÂH‹
$éÎE…ä„ÆEÁé×E…ä„ïÆEÀéÅ‹ÂÑè÷Ш„·÷ÒM…ítCH‹=Í#öÂuHƒÇ² f}ÏHMÏèàÿÿ(EÏHMÏH‹×fEÏèáÿÿ(}Ï)}ÏL‹mÏëaöÂH‹‡#uHƒÂHMÏè`ÛÿÿL‹mÏ(}Ïë>·Å°ÂÑè÷Шt9÷ÒH9ußtH‹=>#éíþÿÿöÂH‹/#uHƒÂHMßèÛÿÿ‹†°A¸AH‹]°HÿÀH‰S°€8$u*E‹ÌLE¿HUoHMÿèžH9uÿ…Ù‹F°A¸AH‹°¹D8¾8AMÈ+ùé#þÿÿH‹°@80tHÿô¯ƒÿ‡¨H‹uoHMÏH‹Öè/Öÿÿ(EïHUÏHMïfEïè©ÞÿÿHƒ}ß(uï)uÏt.² fuïHMïèÊÞÿÿ(EïHUßHMïfEïètÞÿÿ(uï)uÏM…ít.² f}ïHMïè—Þÿÿ(EïHUÏHMïfEïèAÞÿÿ(uï)uÏE3í@öÇ„þE…ät
ºH‹Ëé„D8.tnH+HMÿèuÕÿÿHUÏHMïóEïèðÝÿÿH‹¯HMÿ(EïfEÏD8(tèò#ë
ºè~ÕÿÿHUÏHMïóEïè±Ýÿÿ(uï)uÏëFH‹¼®D8(t[HMÿè²#foÆfsØf~ÁˆM×€ùt€x~‹M׶@áÿÿÿȉM×(uÏH‹v®Š„ÉtHÿÀH‰f®€ù@téÿÿÿºHMÏèßÿÿ(uÏ‹`®Ñè÷Ш‹Çt8ƒà<ucE…ä…çþÿÿHMÿèMõÿÿHUÏHMïóEïèðÜÿÿ(uï)uÏë2ƒà<u+HMÿèõÿÿ€}×t€x~‹M׶@áÿÿÿȉM×(uÏ@öÇt-H›-HMÿèÔÿÿHUÏHMïóEïè‰Üÿÿ(uï)uÏ@öÇt-Ht-HMÿèÛÓÿÿHUÏHMïóEïèVÜÿÿ(uï)uÏD8mÀtHI-fuïHMïèÝÿÿ(uï)uÏD8mÁtH*-fuïHMïèlÝÿÿ(EïfEÏ¿E…ä…§M9.tqA…~uFM9/tA² HMÿèŽÒÿÿI‹×HMïóEïèÊÛÿÿ(EïHMï² fEïèöÛÿÿ(EïI‹ÖfEïë@A÷FtAóEÏëA² HMÿè8ÒÿÿI‹ÖëM9/t,² HMÿè#ÒÿÿI‹×óEïHMïè_ÛÿÿHUïHMÏèRÛÿÿ	}×D8m¿tºm×
(EÏé$úÿÿEÿéúÿÿ9u…ŽI96tn¿A…~uPI91tKºHMïè¾ÒÿÿI‹×HMÿóEÿèòÚÿÿ(EÿHMÿ² fEÿèÛÿÿ(EÿI‹ÖH‹ËóèËÚÿÿë8ºHMÿèsÒÿÿëÜI91tºHMÿè[ÒÿÿI‹×ëĺèIÒÿÿ(|$pLœ$I‹s8H‹ÃI‹[0I‹{HA(sðI‹ãA_A^A]A\]ÃÌÌÌL‹ÜSHƒìPH‹ÙMKØ3ÉL>Á¸ÿÿI‰KØ!D$8ISèI‰Kè!D$H‰L$ H‹Ëè‹øÿÿH‹ÃHƒÄP[ÃÌÌH‰\$UH‹ìHƒì`H‹ÙHMÐèçÐÿÿH‹«3É8„‰€8?tI€8XtHUÐH‹ËèÄéHÿÀH‰åªH9MÐuH0'H‹Ëè$ÑÿÿënH)HMàèÑÿÿëIeèÿÿLMàHÿÀH‰Mà‰L$ LyÀHMðH‰”ªHUÐè×÷ÿÿóEÐëºHMðèÑÿÿHUÐH‹ËóèDÙÿÿH‹ÃH‹\$pHƒÄ`]ÃÌÌH‰\$H‰t$ UH‹ìHƒìP‹TªH‹Ùºà
s*ºð
HMà3Ò‰;ªèæþÿÿº-.ª
EàóéH‹þ©²?Š:Ê…ëHÿÀH‰è©8uOHÿÀ8u#HMàè„ÿÿÿH‹Í©ë
HÿÀH‰Á©€8uñ먀8$HMÐu	²èf/ë!E3ÀH‰ž©3ÒèÓëE3ÀHMвè8Hƒ}ЋuØtºæ	s	ÇE ëƒe ‹ÎÁéƒá€}؉M~	(EÐéBÿÿÿH‹I©ö¿„ HMàè;Hƒ}à„‰€=E©tE(EÐHUàHMÐfEÐÆ+©èê×ÿÿH‹ÿ¨(EÐfEЀ8@tKHMàèìóEàë	(EàfEàH²$HMàèÙÿÿ(EàHUÐHMàfEàè“×ÿÿ(EàfEЋuØ‹M‹U …ÒtHƒ}Ðtºî	‰uØA¸€…ÉtAð‰uØHƒ}Єÿÿÿ¹…ñ…
ÿÿÿH‹\¨€8t€8@tºëRHÿD¨…
Z¨t'…Òu#A…ðuHƒeàHUàeèÿÿHMðèŽÚÿÿé¼þÿÿHUÐH‹Ëè}Úÿÿ뺄ÉuºH‹ËèÎÿÿH‹t$xH‹ÃH‹\$`HƒÄP]ÃÌÌH‰\$H‰t$H‰|$UH‹ìHƒì`L‹¾§3öDŠÊH‹ùA€8QDVuMÂH5Ú#L‰›§AŠ„ÉuA‹ÒH‹Ïè%ÎÿÿéëAÐ<	w*M¾Áƒè/L‰m§HcÐH…öt	HMÐé…HMðé®3ÒA³@ë+„Ét´A¿<wL¾ÁHÁâƒèAHcÈHÊMÂH‹ÑL‰$§AŠA:ËuÐAŠMÂL‰§A:ÃuE„Ét%H…ötHMðè÷Íÿÿë#ºéZÿÿÿHMÐèâÍÿÿë@H…öt2HMðè~ÎÿÿH‹ÖHMàH‹ØèÍÿÿH‹ÓHMÀóEÀè“ÕÿÿHEÀë	HMÐèLÎÿÿóL\$`H‹ÇI‹[I‹sI‹{ I‹ã]Ã@SHƒì H‹ÙH‹
p¦€9_u5€y_u/HƒÁH‰
Z¦¾HÿÁƒèAH‰
J¦ƒøvºH‹ËèÔÌÿÿëHƒ#ÆCcÿÿÿH‹ÃHƒÄ [ÃÌÌ@SHƒì ²H‹Ùè0þÿÿH‹ÃHƒÄ [ÃÌÌÌH‰\$H‰t$H‰|$UH‹ìHƒìP‹ÿ¥H‹ùD‹ÀAÁèA÷ÐAƒàt
ºàr¾ë3öH‹º¥HƒeÐeØÿÿ¾
HÿÂH‰¡¥…É„ɃéTt{ƒétmƒét_ƒétƒétƒùurH4%ë`H%ëWHMÐA‹ðèÙH&%H‹ØHMðèžËÿÿH‹ÓHMàóEàèÔÿÿ(EàfEÐë"HÌ$ëH»$ëHª$HMÐè±ÏÿÿHƒeàeèÿÿ…öt	(EÐfEàHMÐè—HUÐHMàè¾Óÿÿ(EàóëHÿÊH‹ÏH‰äHE$èËÿÿH‹\$`H‹ÇH‹|$pH‹t$hHƒÄP]ÃÌÌÌ@SHƒì H‹Ùè>H‹ÃHƒÄ [ÃÌH‰\$UH‹ìHƒìPH‹p¤H‹ÙHƒeÐeØÿÿ€8„¢Š<0Œ‘<1~-<3~ <4t5<5t,6<w{Ha"ëHP"ëH?"ëH."HMÐèµÎÿÿH‹¤¾Hÿü£ƒÀÏ©ùÿÿÿu+H#"HMðè6ÊÿÿHUÐHMàóEàè±Òÿÿ(Eàë(EÐóëºëºèHÊÿÿH‹ÃH‹\$`HƒÄP]ÃÌÌH‰\$H‰t$L‰t$UH‹ìHƒìPD‹UèH‹ÙH‹
w£I‹ðHƒeàAâÿÿA¾D‰UèIÎE‹ÙH‰
Q£D¾	E‹ÁAƒèA„€E+Æ„7E;Æ„"€9„ŠA„À„E…ÛtºH‹Ëè¤Éÿÿé“AÁáHƒÁ¾ðÆÐüÿÿH‰
ë¢AñA;övKHƒeàHUÐAâÿÿÿÆEÐ,AâÿÿÿHMàE‹ÆD‰Uèè`äÿÿ‹ÖHMðèYÊÿÿ(EàHMàH‹ÐfEàè|Ñÿÿ(EàHMà²>fEàè¨ÑÿÿH‹}¢(EàfEà€8$uIÆH‰e¢ë ²^fEàHMàèwÑÿÿ(EàH‹H¢fEà€8tIÆH‰4¢ëA‹ÖHMàèòÒÿÿºmè(Eàóé¤A‹ÖéüþÿÿH¥H‰ë7E…Û…âþÿÿHƒeàHUÐAâÿÿÿDˆ6AâÿÿÿÆEÐ>E‹ÆD‰UèHMàèqãÿÿL5¡ëAE…Ûu2H‹€8&uHLH‰H‹
¢¡H‹€8*uHSH‰H‹
‰¡IÎH‰
¡Hƒ#ÆCcÿÿÿH‹t$hH‹ÃH‹\$`L‹t$pHƒÄP]ÃH‰\$H‰t$H‰|$UH‹ìHƒì`E3ÀH‹òH‹ùH
a¡APè4H‹ØH…ÀtHƒ Æ@`ÿÿÿë3ÛH‹ÓH‹ÏèÎõÿÿHƒeÐLMÐHƒeàLǶƒd$ HUà¸ÿÿHMð!EØ!Eèèîÿÿ(EðHMಠfEàèàÏÿÿ(EàHMàH‹ÖfEàè‹Ïÿÿ(EàL\$`I‹sH‹ÇI‹{ óI‹[I‹ã]ÃÌÌH‹ÄH‰XH‰pH‰xUATAUAVAWHh¡HìH‹ù3ÛH‹
U L‹â8u#SHMèÞÆÿÿI‹ÔH‹ÏóèÏÿÿé¡Š,6<v€9_t
ºé‚D¾1¾HÎAƒî6ƒÊÿH‰
úŸAƒþ)u(8t D¾1HÎAƒî=H‰
ÞŸAFüƒøvD‹òë‹ÖëAƒþDGòD;òt¡D‹}ïºÿÿA$D#úH‰]çE‹îD‰}ïóE×Aƒå„$€9@„±HhHMèÏÅÿÿHU×HMóEèJÎÿÿH‹_ŸHM(EfE×8tAèM² HM÷H‹ØèÏÄÿÿH‹ÓHMóEèÎÿÿ(EHU×HMfEèõÍÿÿ3Ûë‹Öè¢ÅÿÿHU×HMóEèÕÍÿÿ(EºÿÿH‹
ážfE×ë
HÎH‰
ОŠ„À„<@… þÿÿ‹ÔžL‹´!UÿH΃à`H‰
¡žH‰]÷HM‰t$ <`„ˆ!UïLMçHU÷H‰]çèÅëÿÿ(EfEçAöÆ„Û‹|žÑè÷Ð@„Æ„¡HMèvåÿÿ² HM÷H‹ØèÐÃÿÿH‹ÓHMóEèÍÿÿ(EHU×HMfEèöÌÿÿ(E3ÛfE×ëz!ULM÷HUH‰]è=ëÿÿ€}ï„wÿÿÿ@8uŽmÿÿÿ¶EAçÿÿÿDøD‰}ïéVÿÿÿ‹ÖHMèWÄÿÿHU×ésýÿÿHMèÕäÿÿ€}ßt@8p~‹M߶@áÿÿÿȉMß‹¡Ñè÷Ð@„Æt)HMè¿éÿÿHU×HMóEèBÌÿÿ(EfE×ë'HMè–éÿÿ€}ßt@8p~‹M߶@áÿÿÿȉMßI9$t=²(HMè¯ÂÿÿHU×HMóEèêËÿÿ(EHM²)fEèÌÿÿ(EfE×E3ÀH
APèâL‹ðH…ÀtˆX`ÿÿÿH‰ëL‹óI‹ÖHM'è€HMè›àÿÿ²(HM÷H‹Øè-ÂÿÿH‹ÓHMóEèiËÿÿ(EHM²)fEè•ËÿÿHUHM×èHËÿÿ‹
zœ‹Áƒà`<`tE…ítHUçHM×è'Ëÿÿ‹
YœÁé÷Ñ@„ÎHMtèÎH‹ÐHM×èËÿÿë#軀}ßt@8p~‹M߶@áÿÿÿȉMß‹œHMÁè÷Ð@„ÆtèÀ#H‹ÐHM×è¸Êÿÿë#è­#€}ßt@8p~‹M߶@áÿÿÿȉMßM…öt(E×óAM'óë
ºH‹Ïè&ÂÿÿLœ$H‹ÇI‹[0I‹s8I‹{@I‹ãA_A^A]A\]ÃÌÌ@SHƒì 3ÒH‹ÙèxóÿÿH‹ÃHƒÄ [ÃÌÌÌH‰\$WHƒì H‹9H…ÿu2ÀëH‹H‹XH‹Ëè¦ÿÿH‹ÏÿÓH‹\$0HƒÄ _ÃÌÌ̃y•ÀþÈ$ ÊAÃH‰\$WHƒì H‹Q3ÀH…ÒtH‹:H…ÿtH‹H‹XH‹Ë踥ÿÿH‹ÏÿÓH‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì H‹yH‹ñH‹H‹XH‹Ë胥ÿÿH‹ÏÿÓ„ÀuH‹~H‹H‹XH‹Ëèg¥ÿÿH‹ÏÿÓH‹\$0H‹t$8HƒÄ _ÃÌÌ‹Q3À…Òt
BÿHcÐH‹AŠÃÌH‰\$WHƒìPH‹ù3ÒHL$0è_òÿÿ²`HL$@H‹ØèÀ¿ÿÿH‹ÓHL$ óD$ èúÈÿÿD$ ²'H‹Ïóè'ÉÿÿH‹\$`H‹ÇHƒÄP_ÃÌH‰\$H‰t$WHƒì HzH‹ÙHƒçøE…ÀtH‹H‹Ë认ÿÿH‹ÏÿÓëzH…ÿ¸HDøH‹A H;ÇsR¾H;þv3ÀëWºH
Ä™A¸è•ÿÿÿH…ÀtHƒ H…Àt×H‹KH…ÉtH‰ëH‰CH+÷H‰CH‰s ëH+ÇH‰A H‹C HƒÀHCH‹\$0H‹t$8HƒÄ _ÃÌH‹
1™Š„Òu3ÀÃBÐ<	w¾Âƒè/HÿÁH‰
™ÃE3ÀA±@ë%„ÒtÙB¿<w4AÁàAƒÀ¿¾ÂDÀHÿÁH‰
嘊A:ÑuÖŠHÿÁH‰
Ò˜A:ÁuA‹ÀÃÈÿÃÌH‹ÄH‰XH‰pH‰x L‰@UH‹ìHƒì`H‹¢˜H‹ùHƒeÀ¹ÿÿ!MÈ3öHƒeоHÿÃ!MØH‰{˜ƒøA΄¼…À„§ƒø/ŽÞƒø1~dƒø9оCÿƒè2HcÐHtÿÿHMÀH‹”Ó èÓÂÿÿHƒ}À„BH‰HMðèd¾ÿÿHUÀHMàóEàèßÆÿÿ(Eàé!MØH‰uЄÒ„›HMðè²u² HMÐè£Æÿÿ²>HMÐè˜ÆÿÿH‹E H…ÀtÆH‹a—€;uEÐë|H‹uÐHÿÃH‰H—E3ÀHMð3ÒèÒ%H‰0—fH~À)EÀH‰EÀH…Àt.€{ÿ1u(²~HMð衼ÿÿHUÀHMàóEàèÜÅÿÿ(Eà)EÀH…ötHUÐHMÀèÂÅÿÿ(EÀóL\$`H‹ÇI‹[I‹sI‹{(I‹ã]ÃHÿ˺H‰®–H‹ÏèB½ÿÿë΃øB„掃øZŽÜƒø_…¾p¢HÞH‰s–ƒùOƒùD”ƒù9Œt^…ÉtIƒù/ŽÌƒù6~/ƒù8¾¾CÿƒèHcÐHbÿÿH‹ÏH‹”Ó èn¼ÿÿé?ÿÿÿ¾CÿƒèéÃýÿÿH+ÞH‰ÿ•‹ÖéJÿÿÿ¾CÿHMЃèHÿÿHcÐH‹”Ó è*¼ÿÿºmØépþÿÿƒù?t0ƒù@~EƒùBŽìƒùCu7D‹ÆHòHMÐ詺mØé;þÿÿ¾HÞH‰Š•…À„yÿÿÿƒø0t
ºéÅþÿÿE3ÀH뽃ùTGƒùSˆƒéP„Þ+΄ýÿÿ;ÎuþCÿHMÀƒèHfÿþÿHcÐH‹”Ó èÆ¿ÿÿH‹•Š„Éu(EÀ‹ÖH‹ÏóèËÅÿÿé$þÿÿ¾ÁƒÀЈqÿÿÿƒøƒhÿÿÿHcÐHMÐH‹”Ó(èy¿ÿÿH‹
Ê”¾HÎH‰
½”ƒø0„ƒø1t0ƒÀ΃øw(EÀHUÐH‹ÏóèwÃÿÿé¸ýÿÿH+ÎH‰
„”é€þÿÿ(EÀHUÐHMÀfEÀèMÃÿÿHMðè(²,HMàóEàèqÃÿÿHUàHMÀè$ÃÿÿHMðèÿ²,HMàóEàèHÃÿÿHUàHMÀèûÂÿÿHMðèÖ²,HMàóEàèÃÿÿHUàHMÀèÒÂÿÿ3ÒHMðèìÿÿ²)HMàóEàèôÂÿÿHUàHMÀè§Âÿÿ(EÀ²'H‹ÏóèÕÂÿÿéÖüÿÿ3ÒHMðèmèÿÿ(EðHMಠfEàè±Âÿÿ(EàHUÀHMàfEàè[Âÿÿ(EàéËþÿÿ¾CÿHMÀƒèH”ýþÿHcÐH‹”Ó èô½ÿÿE3ÀHMð3ÒèzúÿÿfH~ÀEÐH…À„‚þÿÿ÷EØ„uþÿÿéšýÿÿƒùVŽMƒùWŽˆýÿÿƒùYŽ/ƒù_…výÿÿ¾HÞH‰æ’ƒøAŒ`ýÿÿƒøDŽûƒøF~uƒøJŽíƒøK…@ýÿÿ¾CÿHMàƒÀHãüþÿHcÐH‹”Ó èï¸ÿÿë€ù@t'HÆŠÑHMàH‰„’è£ÁÿÿH‹x’Š„ÉuÙ€ù@u
HÆH‰c’Eàé€ûÿÿ¾CÿHMЃÀH€üþÿHcÐH‹”Ó 茸ÿÿH‹1’HMð€8?u)èÓçÿÿH‹ÐHMÐèûÀÿÿH‹’€8@uHÆH‰’ëèòH‹ÐHMÐèÒÀÿÿHHMÐèÂÿÿé}úÿÿ¾CÿƒÀé™ûÿÿ¾Cÿƒèéûÿÿ¾Cÿƒèéoùÿÿ¾¾CÿHMÀƒè9HÖûþÿHcÐH‹”Ó è6¼ÿÿ…ö„[ùÿÿHƒ}À„úÿÿºmÈ	é“úÿÿÌ@SHƒì L
ãH‹Ùè³H‹ÃHƒÄ [ÃÌÌ@SHƒì L
§H‹Ùè“H‹ÃHƒÄ [ÃÌÌH‰\$H‰|$UH‹ìHƒìPL‹‘H‹úHƒeàºÿÿ!UèH‹ÙA¾…É„òƒé$tƒét=ƒùtH‹×H‹ËèÊØÿÿéóH"HMàèq»ÿÿHƒ?t² HMàèÜ¿ÿÿL‹±L
>IÿÀHUàL‰™H‹ËEðLEðfsØf~Àºè‰EøèÑéŽAŠ@<$t„À„^H‹Ëºèó¶ÿÿélIƒÀL‰GA¾…É„5ƒéA„ƒé„ïƒé„°ƒé„›ƒétnƒétZƒétƒùH‹ËuŸIÿÀL‰öè¡	éIÿÀL‰âHƒ?tH5HMðè ¶ÿÿéÏH0H‹Ëè¶ÿÿéÍIÿÀL‰©é@ÿÿÿHí
HMàè<ºÿÿHƒ?t² HMà觾ÿÿL‹|L
=éÆþÿÿ!UèLMàHƒeàHMðƒd$ IÿÀL‰QH‹×L!¥èŽÜÿÿH‹ÐéTþÿÿIÿÀH‹×L‰-H‹ËA¸èOë7IÿÀH‹×H‹ËL‰
è„îÿÿë ºHMð蔵ÿÿH‹×H‹ËóèʽÿÿH‹|$hH‹ÃH‹\$`HƒÄP]ÃÌÌÌH‰\$H‰|$UH‹ìHƒìPH‹·ŽH‹úH‹Ù€8„ËE…ÀtW€8Xu6HÿÀH‰”ŽHƒ:uHß
èÖ´ÿÿéÀHºHMàèÁ´ÿÿ陀8_u€x_u€xZuHƒÀH‰LŽ€8YuHÿÀH‰=Žè(ÓÿÿëyHMÐèÖÿÿ÷G@t+HHMðèh´ÿÿHUÐHMàóEàèã¼ÿÿ(Eàë÷G t	Hñ
ëÊ(EÐóë ºHMðèk´ÿÿH‹×H‹Ëó衼ÿÿH‹|$hH‹ÃH‹\$`HƒÄP]ÃÌÌH‰\$H‰t$H‰|$UAVAWH‹ìHƒì@H‹†H‹ñ3ÛM‹ùI‹øL‹òŠ„É„‡AÊ<v6€ù_t1L‹Ê‰\$ H‹×HMðM‹Çè˜ÚÿÿA€?*HUðH‹Î”ÃD‹ÃèfþÿÿéžI‹×HMðèy³ÿÿI9tH9t	÷GuI‹ÖHMðèê»ÿÿH9tH‹×HMðèÙ»ÿÿHUðH‹ÎèeìÿÿëTºHMðèu³ÿÿI‹×HMðè
½ÿÿI9tI‹ÖHMðè »ÿÿH9tI9t² HMðèË»ÿÿH‹×HMðè»ÿÿEðóH‹\$`H‹ÆH‹t$hH‹|$pHƒÄ@A_A^]ÃÌÌÌ@SHƒì H‹Ùè¾þÿÿH‹ÃHƒÄ [ÃÌL‹ÜI‰[I‰sWHƒì0H‹EŒH‹Ù€8_…äHÿÀH‰/Œ¾0HÿÀƒîAH‰Œƒþ‡žIƒcè‹'Œd$(ÿÿÑè÷Ш„—HÜIKèè'¼ÿÿ‹ý‹H‹¢þ÷ШuHƒÂHL$ è¼ÿÿ…ötV‹þ÷×ÿÇ#þ‹Çƒètƒøu3H[
ëHN
HL$ èÔ»ÿÿ÷×#÷t"H?
HL$ è½»ÿÿë¹H‹Ëºè
²ÿÿë&²)HL$ 脺ÿÿD$ óëHƒ!ÆAaÿÿÿH‹t$HH‹ÃH‹\$@HƒÄ0_ÃÌÌÌ@SHƒì H‹#‹H‹Ù€8@uHÿÀH‰‹èØ°ÿÿëèÑßÿÿH‹ÃHƒÄ [ÃH‹ÄH‰XH‰pH‰xL‰p UHhÈHì0E3öH‹ùDˆqAŠö‹A%ÿÿÿL‰1‰A„À…ÍH‹³Šö¿„½D85Êt
D85»Š„!L97taHlHM€èÓ°ÿÿH‹×HL$ óD$ èM¹ÿÿD$ ó@„öt-²[HMèä¯ÿÿH‹×HL$ óD$ è¹ÿÿD$ AŠöóH‹'Š€8?…úHÿÀH‰Š¾ƒé$„׃é„sƒé„Ôƒé„aƒé„sƒùtl3ÒHM èøáÿÿ²`HM°H‹ØèZ¯ÿÿH‹ÐHL$@èA¯ÿÿH‹ÓHL$@è¸ÿÿ(D$@²'fD$ HL$ 蹸ÿÿ(D$ HL$ H‹×fD$ èa¸ÿÿ(D$ éyd$8ÿÿHÿd‰L‰t$0E3ÀHL$P²èèD8t$XuJ(D$PL9t$0t6HfD$ HL$ èf¹ÿÿ(D$ HT$0HL$ fD$ èð·ÿÿ(D$ fD$0ë‹D$8%ÿÿL‰t$0ƒÈ‰D$8D8t$8u_H‹܈€8@…tÿÿÿ²[HMÀè\®ÿÿHT$0HL$ óD$ è”·ÿÿ(D$ HL$ ²]fD$ è½·ÿÿ(D$ óHÿ‰ˆéŽgÿÿÿÆGL‰7é{HÿjˆHMÐE3À²èô²]HL$ óD$ èk·ÿÿ(D$ HL$ H‹×fD$ è·ÿÿ(D$ @¶é(H‹ˆHH€9_uO€x?uIH‰
ˆE3ÀHMà3Òè3ïÿÿH‹×HL$ óD$ èŶÿÿD$ óH‹ч€8@…Òé3ÿÿÿHMðèjÝÿÿ²`HMH‹Øè@­ÿÿH‹ÓHL$ óD$ èz¶ÿÿ(D$ éåýÿÿA°@H‚‡HL$`è ¬ÿÿH‰HMè¼­ÿÿH‹×HL$ óD$ è6¶ÿÿD$ óH‹
2‡ƒ9	tGHT$`èC¸ÿÿë;Hÿ
*‡HM ëHL$pE3À²è­H‹×HL$ óD$ èãµÿÿD$ óD8wé-üÿÿH‹æ†D80t€8@tigÿÿÿÆGL‰7ëYºL97u
H‹Ï袱ÿÿëEHL$pèJ­ÿÿH‹HL$@óD$@èÔ¶ÿÿ(D$@HL$@H‹×fD$@è`µÿÿ(D$@óLœ$0H‹ÇI‹[I‹sI‹{ M‹s(I‹ã]ÃÌÌÌH‰\$UH‹ìHƒì@Hƒ!H‹ÙÆAE3Àaÿÿÿ²HMàè»ó€{H‹†uO€8tJ€8@tJHMðèûÿÿHÙHMàóEàè$¶ÿÿ(EàHMàH‹ÓfEàè³´ÿÿ(EàóH‹À…€8@uHÿÀH‰±…ëi€8tcÿÿÿHƒ#ÆCëSHƒ;ºu
H‹Ëèn°ÿÿë>HMðè¬ÿÿHXHMàóEà裵ÿÿ(EàHMàH‹ÓfEàè2´ÿÿ(EàóH‹ÃH‹\$PHƒÄ@]ÃH‰\$WHƒì@H‹ùH‹
$…Š„ÀuºH‹Ïè­«ÿÿëE3Òu² HL$ è¨ÿÿ²>HL$ èø§ÿÿE„ÿtH‹Èx€8t
HÆH‰¹xD$ H‹…ØH‰žxL‰%‡xL‰-ˆxóë
ºè$ŸÿÿH‹ÇH‹œ$ÀHÄ€A_A^A]A\_^]ÃÌÌL‹ÜSHƒìPIƒcØMKØIƒcèL%Ž¸ÿÿÇD$ !D$8ISè!D$HH‹ÙèvÅÿÿH‹ÃHƒÄP[ÃÌH‰\$H‰|$UH‹ìHƒìPH‹xH‹ù€8tW€8Zu HƒeÐHÿÀeØÿÿEÐH‰àwóëjHMàèÅ»ÿÿHröH‹ØHMðèžÿÿH‹ÓHMÐóEÐ莦ÿÿë&HIöHMðèìÿÿºHMÐóEÐèN¨ÿÿEв)H‹Ïó蔦ÿÿH‹\$`H‹ÇH‹|$hHƒÄP]ÃÌHƒì(L‹QwA¹@A»3ÒA€8_u
MÃA‹ÑL‰0wAŠ,A<†¤A€8$…ÍMÃE2ÒL‰wA¾ƒùBñ„à…É„˃ù$… I@€8PLDÀMÃL‰ÓvE8t|AŠ,F¨ýt&A€8Jt/A€8KŽ|A€8M~A€8O~A€8Q…fMÃL‰•véKÿÿÿMÃL‰†vAŠ,0<	w!A¾ƒè/H˜LÀL‰jvè	ÿÿÿºèé]ºÿÿé÷¸þÿéIƒù/Žƒù5~gƒùA…øÊé˺þÿM+Ãé¾Ê˜é³ƒéC„¤A+Ë„“A+Ë„‚ƒé
…±MÃEŠÓL‰ÝuAŠAÐ<wRE¾ʈAƒé0AöÚA‹ÁÉáÁʋѺê
A"ÃDÑAƒátAƒùtAƒùt6éSºêë+ƒÊ@ë&öÙºÿÿÀÂérÊ’ëÊ‘ëÊ|MÃL‰QuéKAŠAÐ<‡—MþÉL‰1uƒé0t{A+ËtlA+Ët`A+ËtSA+ËtDA+Ët4A+Ët$A+ËtA;Ë…ÇÊxéôÊpééÊhéÞÊ`éÓº éÉAÑéÁ3Ò麺é°º馀ù9uMúýÿL‰“téöÙºþÿÀ÷ØÐë~E¾ºêAƒéAMËÊL‰gtºê
A‹ÁA"ÃDÑAƒù}S‹ÂºÐA‹Áƒàtƒøtƒøt¸ÿÿë3ºêëƒÊ@Aƒát"AƒùtAƒùtAƒùuغê
ë
ºêëºê	‹ÂHƒÄ(ÃÌÌ@SHƒì H‹ësH‹Ù€8t$€8AtºëHÿÀHéóH‰Æsèšÿÿë
ºèQšÿÿH‹ÃHƒÄ [Ã@SHƒì H‹ÙèfH‹ÃHƒÄ [ÃÌ@SHƒì0H¨óH‹Ùó踣ÿÿHL$ èrèÿÿH‹ÐH‹ËèG¢ÿÿ²}H‹Ëè}¢ÿÿH‹Rs€8@u
HÿÀH‰CsH‹ÃHƒÄ0[ÃÌÌH‰\$H‰|$UH‹ìHƒì`H‹ùó€y”H‹s€8„THƒeÐLMÐHƒeàLLjƒd$ HUà¸ÿÿHMð!EØ!EèèÀÿÿ(EðHMಠfEàèà¡ÿÿ(EàHMàH‹×fEàè‹¡ÿÿ(Eàó€H‹Žr€8@„ËH¢òH‹Ï趢ÿÿH‹or€¦ö¿txHMðè[çÿÿ²`HMÐH‹ØèÝ—ÿÿH‹ÓHMàóEàè¡ÿÿ(EàHMà²'fEàèE¡ÿÿHUàH‹Ïèù ÿÿH‹r€8@u
HÿÀH‰ÿq€:€8@t…Hòéjÿÿÿ€#€8u
ºH‹Ï蜢ÿÿ²}H‹Ïèê ÿÿH‹¿q€8@uÿë‘ÌÌÌH‰\$H‰t$ UWATAVAWH¬$ðûÿÿHìH‹H)H3ÄH‰…E3äI‹ÙI‹øH‹òL‹ùM…Éuèe|Ç肃Èÿé
M…ÀtH…ÒtÞH‹•`HL$Xèéÿÿ3ÒHL$0DB èÇRÿÿM‹÷H‰t$0H‰|$8L‰d$@Aƒæu
Dˆd$HH…öuÆD$HHD$0L‹ËH‰D$PHT$PH‹…hHM€H‰D$(M‹ÇHD$`H‰D$ èHTHM€è3‹HcØH…ötKAöÇt"H…ÿu…À…H‹D$@H;Çu)…Ûx*H;ßv%ë{M…ötqH…ÿt…ÀyfD‰&ëH‹D$@H;ÇtqfD‰$FH‹àè wL‰¥àD8d$ptH‹L$Xƒ¡¨ý‹ÃH‹H3Ìè99ÿÿLœ$I‹[0I‹sHI‹ãA_A^A\_]ÃH…ÿuƒËÿë£H‹D$@H;Çu”»þÿÿÿfD‰d~þëŒH‰\$UVWAVAWH¬$€òÿÿHì€H‹š'H3ÄH‰…p
I‹ÙI‹øH‹òL‹ùM…ÉuèºzÇès€ƒÈÿé
M…ÀtH…ÒtÞH‹•Ð
HL$Xèpçÿÿ3ÒHL$0DB èQÿÿHƒd$@M‹÷H‰t$0H‰|$8Aƒæu
Dˆt$HH…öuÆD$HHD$0L‹ËH‰D$PHT$PH‹…Ø
HM€H‰D$(M‹ÇHD$`H‰D$ èèOHM€èC}HcØH…ötIAöÇt"H…ÿu…À…ŠH‹D$@H;Çu(…Ûx(H;ßv#ëuM…ötkH…ÿt…ÀyÆëH‹D$@H;ÇtlÆH‹àèöuHƒ¥à€|$ptH‹L$Xƒ¡¨ý‹ÃH‹p
H3ÌèŽ7ÿÿH‹œ$°HÄ€A_A^_^]ÃH…ÿuƒËÿë§H‹D$@H;Çu™»þÿÿÿÆD>ÿë‘ÌÌÌH‰\$H‰t$ UWATAVAWH¬$€òÿÿHì€H‹ì%H3ÄH‰…p
E3äI‹ÙI‹øH‹òL‹ùM…Éuè	yÇèÂ~ƒÈÿé
M…ÀtH…ÒtÞH‹•Ð
HL$Xè¿åÿÿ3ÒHL$0DB èkOÿÿM‹÷H‰t$0H‰|$8L‰d$@Aƒæu
Dˆd$HH…öuÆD$HHD$0L‹ËH‰D$PHT$PH‹…Ø
HM€H‰D$(M‹ÇHD$`H‰D$ èlQHM€è_ŠHcØH…ötKAöÇt"H…ÿu…À…H‹D$@H;Çu)…Ûx*H;ßv%ë{M…ötqH…ÿt…ÀyfD‰&ëH‹D$@H;ÇtqfD‰$FH‹àèDtL‰¥àD8d$ptH‹L$Xƒ¡¨ý‹ÃH‹p
H3ÌèÝ5ÿÿLœ$€I‹[0I‹sHI‹ãA_A^A\_]ÃH…ÿuƒËÿë£H‹D$@H;Çu”»þÿÿÿfD‰d~þëŒH‰\$UVWAVAWH¬$ðûÿÿHìH‹>$H3ÄH‰…I‹ÙI‹øH‹òL‹ùM…Éuè^wÇè}ƒÈÿé
M…ÀtH…ÒtÞH‹•`HL$Xèäÿÿ3ÒHL$0DB èÀMÿÿHƒd$@M‹÷H‰t$0H‰|$8Aƒæu
Dˆt$HH…öuÆD$HHD$0L‹ËH‰D$PHT$PH‹…hHM€H‰D$(M‹ÇHD$`H‰D$ è(MHM€èw|HcØH…ötIAöÇt"H…ÿu…À…ŠH‹D$@H;Çu(…Ûx(H;ßv#ëuM…ötkH…ÿt…ÀyÆëH‹D$@H;ÇtlÆH‹àèšrHƒ¥à€|$ptH‹L$Xƒ¡¨ý‹ÃH‹H3Ìè24ÿÿH‹œ$@HÄA_A^_^]ÃH…ÿuƒËÿë§H‹D$@H;Çu™»þÿÿÿÆD>ÿë‘ÌÌÌH‰\$H‰t$ UWATAVAWH¬$ðûÿÿHìH‹"H3ÄH‰…E3äI‹ÙI‹øH‹òL‹ùM…Éuè­uÇèf{ƒÈÿé
M…ÀtH…ÒtÞH‹•`HL$Xècâÿÿ3ÒHL$0DB èLÿÿM‹÷H‰t$0H‰|$8L‰d$@Aƒæu
Dˆd$HH…öuÆD$HHD$0L‹ËH‰D$PHT$PH‹…hHM€H‰D$(M‹ÇHD$`H‰D$ è¬NHM€è·‰HcØH…ötKAöÇt"H…ÿu…À…H‹D$@H;Çu)…Ûx*H;ßv%ë{M…ötqH…ÿt…ÀyfD‰&ëH‹D$@H;ÇtqfD‰$FH‹àèèpL‰¥àD8d$ptH‹L$Xƒ¡¨ý‹ÃH‹H3Ìè2ÿÿLœ$I‹[0I‹sHI‹ãA_A^A\_]ÃH…ÿuƒËÿë£H‹D$@H;Çu”»þÿÿÿfD‰d~þëŒ@SHƒì0H‹ÚM…ÉttëÖH@I‹„ʶH‰
°HƒÄ0[ÃÌÌ@SHƒì0ƒ¹|L‹ÑuHƒA H‹I D¶AøL‰é’Hcì
ƒøcvè#nÇèÜs2Àëtƒ¹xuWD‹A„ÀuæèxPÇè1VëÖH@I‹„ÊHƒÀò@ø°òHƒÄ0[ÃÌÌ@SHƒì0ƒ¹|L‹ÑuHƒA H‹I òAøé—Hcì
ƒøcvèPÇèËU2Àë}ƒ¹xuYD‹AcÌÌE‹H‹H‹	éNdÌÌE‹H‹H‹	écÌÌE‹H‹H‹	é.dÌÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXL‹ÑH‹ˆA‹ØH…ÉD‹ÚHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀE…Ût6ÿÈ3ÒA‰B8A‹Ã÷ó€Â0D‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë½E+BHIÿBHH‹\$E‰BPÃÌH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃH‰\$HAXA‹ØL‹ÑL‹ÚH‹ˆH…ÉHDÈHƒ¸u¸ë
H‹€HÑèLAÿLÀM‰BHA‹B8…ÀM…Ût7ÿÈ3ÒA‰B8I‹ÃH÷ó€Â0L‹Ø€ú9~AŠÁöØÉ€áà€Áa€é:ÑI‹BHˆIÿJHë¼E+BHIÿBHH‹\$E‰BPÃE…À~~H‹ÄH‰XH‰hH‰pH‰x AVHƒì I‹ÙA‹èDŠòH‹ñ3ÿH‹‹HÁéöÁt
H‹HƒxtH‹A¾ÎèLǃøÿtÿ‹ƒøÿtÿÇ;ý}ëƃÿH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃE…ÀŽ„H‹ÄH‰XH‰hH‰pH‰x AVHƒì I‹ÙD¾òA‹èH‹ñ3ÿH‹‹HÁéöÁt
H‹HƒxtH‹A·Îè£Ä¹ÿÿf;Átÿ‹ƒøÿtÿÇ;ý}ëÁƒÿH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃÌÌH‰\$E3ÛH‹ÙE…À~EL‹I‹BI9BuA€ztAÿëAƒ	ÿëAÿH‹Hÿ@H‹H‹ˆH‹HÿAƒ9ÿtAÿÃE;Ø|»H‹\$ÃÌE…À~hH‰\$H‰|$@ŠúH‹ÙE3ÛL‹I‹BI9BuA€ztAÿë$Aƒ	ÿëAÿH‹@¾×Hÿ@H‹H‹f‰H‹HƒAƒ9ÿtAÿÃE;Ø|µH‹\$H‹|$ÃÌÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‹H‰H‹ÁÃÌÌH‹H‰H‹ÁÃÌÌH‹H‰H‹ÁÃÌÌH‹H‰H‹ÁÃÌÌH‹H‰H‹ÁÃÌÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‹H‰H‹ÁÃÌÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‹H‰H‹ÁÃÌÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‹H‰H‹ÁÃÌÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‹H‰H‹ÁÃÌÌH‹H‰H‹ÁÃÌÌH‹H‰H‹ÁÃÌÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‹H‰H‹ÁÃÌÌ3ÀH‰H‰AH‰AH‰AH‰A H‰A(H‰A0‰A8f‰A@‰APˆATH‰XH‰`H‹ÁÃ3ÀH‰H‰AH‰AH‰AH‰A H‰A(H‰A0‰A8ˆA@f‰AB‰APˆATH‰XH‰`H‹ÁÃÌ3ÀH‰H‰AH‰AH‰A H‰AH‰A(H‰A0‰A8f‰A@‰APˆATH‰XH‰`H‹H‰hH‹D$(H‰AH‹D$0H‰A H‹ÁL‰L‰IÃÌ3ÀH‰H‰AH‰AH‰A H‰AH‰A(H‰A0‰A8f‰A@‰APˆATH‰XH‰`H‹H‰hH‹D$(H‰AH‹D$0H‰A H‹ÁL‰L‰IÃÌ3ÀH‰H‰AH‰AH‰A H‰AH‰A(H‰A0‰A8ˆA@f‰AB‰APˆATH‰XH‰`H‹H‰hH‹D$(H‰AH‹D$0H‰A H‹ÁL‰L‰IÃÌÌ3ÀH‰H‰AH‰AH‰A H‰AH‰A(H‰A0‰A8ˆA@f‰AB‰APˆATH‰XH‰`H‹H‰hH‹D$(H‰AH‹D$0H‰A H‹ÁL‰L‰IÃÌÌ@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8f‰K@‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pèÙ+H‰CH‹ÃHƒÄ [Ã@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8f‰K@‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C ƒÈÿ‰ƒè
‰ƒì
L‰L‰K‰‹pH‰‹xL‰‹€è@+H‰CH‹ÃHƒÄ [ÃÌÌÌ@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8f‰K@‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pèÁ*H‰CH‹ÃHƒÄ [Ã@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8f‰K@‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pèE*H‰CH‹ÃHƒÄ [Ã@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8f‰K@‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C ƒÈÿ‰ƒè
‰ƒì
L‰L‰K‰‹pH‰‹xL‰‹€è¬)H‰CH‹ÃHƒÄ [ÃÌÌÌ@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8f‰K@‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pè-)H‰CH‹ÃHƒÄ [Ã@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8ˆK@f‰KB‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pè®(H‰CH‹ÃHƒÄ [ÃÌ@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8ˆK@f‰KB‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C ƒÈÿ‰ƒè
‰ƒì
L‰L‰K‰‹pH‰‹xL‰‹€è(H‰CH‹ÃHƒÄ [Ã@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8ˆK@f‰KB‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pè’'H‰CH‹ÃHƒÄ [ÃÌ@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8ˆK@f‰KB‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pè'H‰CH‹ÃHƒÄ [ÃÌ@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8ˆK@f‰KB‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C ƒÈÿ‰ƒè
‰ƒì
L‰L‰K‰‹pH‰‹xL‰‹€èu&H‰CH‹ÃHƒÄ [Ã@SHƒì H‹Ù3ÉH‰H‰KH‰KH‰K H‰KH‰K(H‰K0‰K8ˆK@f‰KB‰KPˆKTH‰‹XH‰‹`H‹H‰ƒhH‹D$PH‰CH‹D$XH‰C L‰L‰K‰‹pèö%H‰CH‹ÃHƒÄ [ÃÌH‰H‹ÁÃÌH‰H‹ÁÃÌH‰H‹ÁÃÌH‰H‹ÁÃÌ@SHƒì H‹ÙH‰H‹Ê轈CH‹ÃHƒÄ [ÃH‰‹‰AH‹Áƒ"ÃÌHƒ¡H‹ÁHƒ¡Ã@SHƒì H‹ÙH‹‰`è«!Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è‡!Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èc!Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è?!Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è!Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è÷ Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èÓ Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è¯ Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è‹ Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èg Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èC Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èûHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è×Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è³Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èkHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èGHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è#Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èÿHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èÛHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è·Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è“Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èoHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èKHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è'Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`èßHƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è»Hƒ£`HƒÄ [ÃÌ@SHƒì H‹ÙH‹‰`è—Hƒ£`HƒÄ [ÃÌH‹ŠIéí¹ÌH‹ƒ:u	‹A…Àt‰ÃÌÌ@SHƒì H‹ÙH‹‰èSHƒ£HƒÄ [ÃÌH‰\$WHƒì H‹ùH‹ÚH‹	è,Hƒ'H‹H‰H‹ÇHƒ#H‹\$0HƒÄ _ÃH‰\$H‰t$WHìðH‹{ÍH3ÄH‰„$àH‹H‹ÙH‹8H‹Ïè{¸H‹SHL$8@ŠðH‹èoÿÿH‹HD$@H‹K L‹KL‹HT$0H‹	M‹	L‰D$0L‹CH‰L$(HL$`H‰D$ M‹èõÿÿHL$`èKH‹Œ$À‹ØèpHƒ¤$À€|$PtH‹L$8ƒ¡¨ýH‹×@ŠÎ蹸‹ÃH‹Œ$àH3ÌèûÝþÿLœ$ðI‹[I‹s I‹ã_ÃÌÌH‹	é8ÿÿH‹	é$ÿÿH‹	éÿÿH‹	é ÿÿH‹	éÿÿH‰\$H‰t$WHì`H‹cÌH3ÄH‰„$PH‹H‹ÙH‹8H‹Ïèc·H‹SHL$8@ŠðH‹èWŒÿÿH‹HD$@H‹K L‹KL‹HT$0H‹	M‹	L‰D$0L‹CH‰L$(HL$`H‰D$ M‹èióÿÿHL$`è“H‹Œ$À‹ØèXHƒ¤$À€|$PtH‹L$8ƒ¡¨ýH‹×@ŠÎè¡·‹ÃH‹Œ$PH3ÌèãÜþÿLœ$`I‹[I‹s I‹ã_ÃÌÌH‹	é €ÿÿH‰\$H‰t$WHì`H‹kËH3ÄH‰„$PH‹H‹ÙH‹8H‹Ïèk¶H‹SHL$8@ŠðH‹è_‹ÿÿH‹HD$@H‹K L‹KL‹HT$0H‹	M‹	L‰D$0L‹CH‰L$(HL$`H‰D$ M‹èõÿÿHL$`èw(H‹Œ$À‹Øè`Hƒ¤$À€|$PtH‹L$8ƒ¡¨ýH‹×@ŠÎ詶‹ÃH‹Œ$PH3ÌèëÛþÿLœ$`I‹[I‹s I‹ã_ÃÌÌH‹	éÿÿH‰\$H‰t$WHìðH‹sÊH3ÄH‰„$àH‹H‹ÙH‹8H‹ÏèsµH‹SHL$8@ŠðH‹ègŠÿÿH‹HD$@H‹K L‹KL‹HT$0H‹	M‹	L‰D$0L‹CH‰L$(HL$`H‰D$ M‹èýðÿÿHL$`èƒH‹Œ$À‹ØèhHƒ¤$À€|$PtH‹L$8ƒ¡¨ýH‹×@ŠÎè±µ‹ÃH‹Œ$àH3ÌèóÚþÿLœ$ðI‹[I‹s I‹ã_ÃÌÌH‹	é$~ÿÿH‰\$H‰t$WHìðH‹{ÉH3ÄH‰„$àH‹H‹ÙH‹8H‹Ïè{´H‹SHL$8@ŠðH‹èo‰ÿÿH‹HD$@H‹K L‹KL‹HT$0H‹	M‹	L‰D$0L‹CH‰L$(HL$`H‰D$ M‹è-óÿÿHL$`è$H‹Œ$À‹ØèpHƒ¤$À€|$PtH‹L$8ƒ¡¨ýH‹×@ŠÎè¹´‹ÃH‹Œ$àH3ÌèûÙþÿLœ$ðI‹[I‹s I‹ã_ÃÌÌH‹	é,}ÿÿH‹	é0}ÿÿH‹	é(}ÿÿH‰\$H‰t$WHìðH‹sÈH3ÄH‰„$àH‹H‹ÙH‹8H‹Ïès³H‹SHL$8@ŠðH‹ègˆÿÿH‹HD$@H‹K L‹KL‹HT$0H‹	M‹	L‰D$0L‹CH‰L$(HL$`H‰D$ M‹èAóÿÿHL$`è3(H‹Œ$À‹ØèhHƒ¤$À€|$PtH‹L$8ƒ¡¨ýH‹×@ŠÎè±³‹ÃH‹Œ$àH3ÌèóØþÿLœ$ðI‹[I‹s I‹ã_ÃÌÌH‹	é0|ÿÿöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌöÚÀƒààƒÀ'ÁÃÌÌÌÿxH‹Á‹‰xƒùu2ÀÃùu	ƒ¸|tïƒÉÿ3Ò‰ˆè
‰ˆì
H‹ˆ€H‰H‰|H‰P4°ÃÌÌÿxH‹Á‹‰xƒùu2ÀÃùu	ƒ¸|tïƒÉÿ3Ò‰ˆè
‰ˆì
H‹ˆ€H‰H‰|H‰P4°ÃÌÌÿxH‹Á‹‰xƒùu2ÀÃùu	ƒ¸|tïƒÉÿ3Ò‰ˆè
‰ˆì
H‹ˆ€H‰H‰|H‰P4°ÃÌÌÿxH‹Á‹‰xƒùu2ÀÃùu	ƒ¸|tïƒÉÿ3Ò‰ˆè
‰ˆì
H‹ˆ€H‰H‰|H‰P4°ÃÌÌÿpƒ¹p•ÀÃÌÌÌÿpƒ¹p•ÀÃÌÌÌÿpƒ¹p•ÀÃÌÌÌÿpƒ¹p•ÀÃÌÌÌH‹H‹øH‹DŠëA:Àt	HÿÁŠ„ÀuòŠHÿÁ„Àt2ë	,E¨ßt	HÿÁŠ„ÀuñH‹ÑHÿÉ€90tøD8uHÿÉŠHÿÁHÿˆ„ÀuòÃBàL
þ[[uE…ötD‰6H‹\$H@ŠÅH‹l$PHƒÄ A^_^ÃÌH‹ÄH‰XH‰hVWAVHƒì H‹qH‹ù½H‹ÚHPD‹6ƒ&DE	H‹IHƒ`H+Íèã-‰H‹Gƒ8"tH‹D$@H;GrH‰Gë@2íƒ>uE…ötD‰6H‹\$H@ŠÅH‹l$PHƒÄ A^_^ÃÌH‹ÄH‰XH‰hVWAVHƒì H‹qH‹ù½H‹ÚHPD‹6ƒ&DE	H‹IHƒ`H+Íè_-‰H‹Gƒ8"tH‹D$@H;GrH‰Gë@2íƒ>uE…ötD‰6H‹\$H@ŠÅH‹l$PHƒÄ A^_^ÃÌH‹ÄH‰XH‰hVWAVHƒì H‹qH‹ù½H‹ÚHPD‹6ƒ&DE	H‹IHƒ`H+ÍèÛ,‰H‹Gƒ8"tH‹D$@H;GrH‰Gë@2íƒ>uE…ötD‰6H‹\$H@ŠÅH‹l$PHƒÄ A^_^ÃÌH‹ÄH‰XH‰hVWAVHƒì H‹qH‹ù½H‹ÚHPD‹6ƒ&DE	H‹IHƒ`H+ÍèW,‰H‹Gƒ8"tH‹D$@H;GrH‰Gë@2íƒ>uE…ötD‰6H‹\$H@ŠÅH‹l$PHƒÄ A^_^ÃÌH‹ÄH‰XH‰hVWAVHƒì H‹qH‹ù½H‹ÚHPD‹6ƒ&DE	H‹IHƒ`H+ÍèÓ+‰H‹Gƒ8"tH‹D$@H;GrH‰Gë@2íƒ>uE…ötD‰6H‹\$H@ŠÅH‹l$PHƒÄ A^_^ÃÌH‹ÄH‰XH‰hH‰p WHƒì H‹qH‹ùH‹ÚA¸
HP‹.ƒ&H‹IHƒ`Hƒéèq,‰H‹Gƒ8"tH‹D$0H;GrH‰G°ë2Àƒ>u…ít‰.H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌH‹ÄH‰XH‰hH‰p WHƒì H‹qH‹ùH‹ÚA¸
HP‹.ƒ&H‹IHƒ`Hƒéèñ+‰H‹Gƒ8"tH‹D$0H;GrH‰G°ë2Àƒ>u…ít‰.H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌH‹ÄH‰XH‰hH‰p WHƒì H‹qH‹ùH‹ÚA¸
HP‹.ƒ&H‹IHƒ`Hƒéèq+‰H‹Gƒ8"tH‹D$0H;GrH‰G°ë2Àƒ>u…ít‰.H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌH‹ÄH‰XH‰hH‰p WHƒì H‹qH‹ùH‹ÚA¸
HP‹.ƒ&H‹IHƒ`Hƒéèñ*‰H‹Gƒ8"tH‹D$0H;GrH‰G°ë2Àƒ>u…ít‰.H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌH‹ÄH‰XH‰hH‰p WHƒì H‹qH‹ùH‹ÚA¸
HP‹.ƒ&H‹IHƒ`Hƒéèq*‰H‹Gƒ8"tH‹D$0H;GrH‰G°ë2Àƒ>u…ít‰.H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌH‹ÄH‰XH‰hH‰p WHƒì H‹qH‹ùH‹ÚA¸
HP‹.ƒ&H‹IHƒ`Hƒéèñ)‰H‹Gƒ8"tH‹D$0H;GrH‰G°ë2Àƒ>u…ít‰.H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌH‰\$H‰l$WHƒì H‹ÙH‹‰hH…Éuè•ÇèNë	èGØ„ÀuƒÈÿéºHƒ{tÖÿƒpƒ»p„ƒÏÿH-3IƒcPƒc,éRHÿCƒ{(ŒYŠCA‹S,, ëD‰.é—€{A*H‹ËtI‹Öë¶èõ¿„À„²ƒ»xu	ƒ»|ujA‹…Ày	ƒK0÷ØA‰°ëRŠCA< t(<#t<+t<-t
<0u?ƒK0ë9ƒK0ë3ƒK0ë-ƒK0 ë'ƒK0ë!A‰.@ˆk@‰k0‰>‰k<@ˆkTëH‹ËèÕ„Àt6H‹CŠˆKA„É…hþÿÿHÿCH‹Ëè0Ï„Àtéïýÿÿè&Çèß‹Çë‹C(H‹\$@H‹l$HH‹t$PHƒÄ A_A^_ÃÌÌÌH‰\$H‰l$WHƒì H‹ÙH‹‰hH…ÉuèÕÇèŽë	è‡Ó„ÀuƒÈÿéªHƒ{tÖÿƒpƒ»p„ƒÏÿH-DƒcPƒc,éNHÿCƒ{(ŒUŠCA‹S,, ƒK0ë8ƒK0ë2ƒK0ë,ƒK0 ë&ƒK0ë H‰s0@ˆs@‰{8‰s<@ˆsTëH‹ËèÁ„Àt[H‹CŠˆKA„É…¤þÿÿHÿC9s,tƒ{,u+ÿƒpƒ»p…wþÿÿ‹C(H‹\$0H‹l$8H‹t$@HƒÄ _ÃèåüÇèž‹Çë×ÌÌH‰\$H‰l$H‰t$WAVAWHƒì 3íH‹ÙH9©huè©üÇèbƒÈÿé8H9itâƒÏÿL=f@ÿƒx‹ƒxƒø„ƒøu
ƒ»|„þH‹ƒ€Ls4Hs8‰«|‰»è
‰»ì
A‰.‰.H‰C‰kP‰k,ŠˆCA„À„˜HÿC9k(ŒŠCA‹S,, ëD‰.é—€{A*H‹ËtI‹Öë¶èSº„À„²ƒ»xu	ƒ»|ujA‹…Ày	ƒK0÷ØA‰°ëRŠCA< t(<#t<+t<-t
<0u?ƒK0ë9ƒK0ë3ƒK0ë-ƒK0 ë'ƒK0ë!A‰.@ˆk@‰k0‰>‰k<@ˆkTëH‹Ë蛄Àt6H‹CŠˆKA„É…hþÿÿHÿCH‹ËèÉ„ÀtéïýÿÿèpúÇè)‹Çë‹C(H‹\$@H‹l$HH‹t$PHƒÄ A_A^_ÃÌH‰\$H‰l$WHƒì Hƒ¹hH‹Ùuè#úÇèÜÿƒÈÿéªHƒytáÿpƒ¹p„ƒÏÿH-l=ƒcPƒc,éNHÿCƒ{(ŒUŠCA‹S,, ëE‰.éžfƒ{B*H‹ËtI‹Öëµè<´„À„¼ƒ»xu	ƒ»|upA‹…Ày	ƒK0÷ØA‰°ëX·CBA;Ät,ƒø#t!ƒø+tƒø-tƒø0u?ƒK0ë9ƒK0ë3ƒK0ë-D	c0ë'ƒK0ë!A‰.@ˆk@‰k0‰>‰k<@ˆkTëH‹ËèÒ„Àt:H‹C·f‰KBf…É…XþÿÿHƒCH‹Ëè]„ÀtéÛýÿÿè;óÇèôø‹Çë‹C(H‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A^A]A\ÃÌÌH‹ÄH‰XH‰pH‰xL‰p AWHƒì 3öH‹ÙH9±huèÜòÇè•øƒÈÿéH9qtâÿpƒ¹p„ëƒÏÿL=&6Dw!‰sP‰s,é¦HƒC9s(Œ±·CB‹S,fA+ÆfƒøZw·CBB¶L8àƒáë‹ÎÊB¶8Áè‰C,ƒø„©…À„ƒè„êƒè„¢ƒètkƒèt^ƒèt(ƒètƒø…‚H‹Ëè¡FéH‹ËèH+é
fƒ{B*tHS8H‹Ëè4êÿÿéòHƒC H‹C ‹Hø…ÉHωK8é׉s8éÕfƒ{B*tHS4ëÅHƒC H‹C ‹Hø‰K4…ɉ«ƒK0÷Ù‰K4é·CBA;Æt0ƒø#t%ƒø+tƒø-tƒø0…‚ƒK0ë|ƒK0ëvƒK0ëpD	s0ëjƒK0ëdH‰s0@ˆs@‰{8‰s<@ˆsTëPD·CBÆCTH‹ƒh‹HÁéöÁt
H‹ƒhH9ptH‹“hA·Èèñ„¹ÿÿf;Áu‰{(ëÿC(°„ÀtZH‹C·f‰KBf…É…FþÿÿHƒCÿƒpƒ»p…#þÿÿ‹C(H‹\$0H‹t$8H‹|$@L‹t$HHƒÄ A_Ãè¢ðÇè[ö‹ÇëÑÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì 3öH‹ÙH9±huèdðÇèöƒÈÿéH9qtâÿpƒ¹p„üƒÏÿL54o!‰sP‰s,é­HƒC9s(Œ¸·CB‹S,f+ÅfƒøZw·CBB¶L0àƒáë‹ÎÊÈB¶1Áé‰K,ƒù„º…É„ƒé„ëƒé„¢ƒétkƒét^ƒét(ƒétƒù…“H‹ËèõFéH‹Ëèt*éfƒ{B*tHS8H‹Ëè<èÿÿéøHƒC H‹C ‹Hø…ÉHωK8é݉s8éÛfƒ{B*tHS4ëÅHƒC H‹C ‹Hø‰K4…ɉ±ƒK0÷Ù‰K4飷CB;Åt2ƒø#t(ƒø+tƒø-tƒø0…‰ƒK0逃K0ëzƒK0ët	k0ëoƒK0ëiH‰s0@ˆs@‰{8‰s<@ˆsTëU·SBÆCTH‹‹hH‹AH9Au@8qtÿC(ë+‰{(ë&ÿC(H‹ƒhHÿ@H‹ƒhH‹f‰H‹ƒhHƒ°„ÀteH‹C·f‰KBf…É…?þÿÿHƒC9s,tƒ{,u1ÿƒpƒ»p…þÿÿ‹C(H‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃèîÇèÒó‹ÇëÑÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì 3íH‹ÙH9©huèØíÇè‘óƒÈÿéPH9itâƒÏÿL-•1Dg!ÿƒx‹ƒxƒø„$ƒøu
ƒ»|„H‹ƒ€Ls4Hs8‰«|‰»è
‰»ì
A‰.‰.H‰C‰kP‰k,·f‰CBf…À„¨HƒC9k(ŒŸ·CB‹S,fA+ÄfƒøZw·CBB¶L(àƒáë‹ÍÊÈB¶)Áé‰K,H‹Ëè.¹„À„~‹C,ƒø„b…À„$ƒè„ƒè„ƒèt{ƒètoƒèt(ƒètƒø…;H‹Ëè×FéðH‹Ëè.)éãfƒ{B*H‹Ët
H‹ÖèÓåÿÿéÌ色„À„ýƒ»xu
ƒ»|…­9.}I‰>ëE‰.éžfƒ{B*H‹ËtI‹Öëµè ­„À„¼ƒ»xu	ƒ»|upA‹…Ày	ƒK0÷ØA‰°ëX·CBA;Ät,ƒø#t!ƒø+tƒø-tƒø0u?ƒK0ë9ƒK0ë3ƒK0ë-D	c0ë'ƒK0ë!A‰.@ˆk@‰k0‰>‰k<@ˆkTëH‹ËèJ„Àt:H‹C·f‰KBf…É…XþÿÿHƒCH‹Ëè5»„ÀtéÛýÿÿè‡ëÇè@ñ‹Çë‹C(H‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A^A]A\ÃÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì 3öH‹ÙH9±huè(ëÇèáðƒÈÿéH9qtâÿpƒ¹p„ïƒÏÿL5r.o!‰sP‰s,é«HƒC9s(Œ¶·CB‹S,f+ÅfƒøZw·CBB¶L0àƒáë‹ÎÊB¶0Áè‰C,ƒø„¯…À„ƒè„ëƒè„¢ƒètkƒèt^ƒèt(ƒètƒø…ˆH‹ËègGéH‹Ëè‚(éfƒ{B*tHS8H‹ËèäÿÿéøHƒC H‹C ‹Hø…ÉHωK8é݉s8éÛfƒ{B*tHS4ëÅHƒC H‹C ‹Hø‰K4…ɉ±ƒK0÷Ù‰K4飷CB;Åt2ƒø#t(ƒø+tƒø-tƒø0…‰ƒK0逃K0ëzƒK0ët	k0ëoƒK0ëiH‰s0@ˆs@‰{8‰s<@ˆsTëU·SBÆCTH‹‹hH‹AH9Au@8qtÿC(ë+‰{(ë&ÿC(H‹ƒhHÿ@H‹ƒhH‹f‰H‹ƒhHƒ°„ÀtZH‹C·f‰KBf…É…AþÿÿHƒCÿƒpƒ»p…þÿÿ‹C(H‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃèêèÇè£î‹ÇëÑÌÌÌ	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0Ã	Q0ø9xu
9|t3Àø9xu
9|t3Àø9xu
9|t3Àø9xu
9|t3ÀðÃÌ°ÃÌ°ÃÌ°ÃÌ‹‘xƒúuƒ¹|u°Ãúu	ƒ¹|tï2ÀË‘xƒúuƒ¹|u°Ãúu	ƒ¹|tï2ÀË‘xƒúuƒ¹|u°Ãúu	ƒ¹|tï2ÀË‘xƒúuƒ¹|u°Ãúu	ƒ¹|tï2ÀÃ2ÀÃÌ2ÀÃÌ2ÀÃÌ2ÀÃ̃¹|u
¸9xt3ÀÃÌÌ̃¹|u
¸9xt3ÀÃÌÌ̃¹|u
¸9xt3ÀÃÌÌ̃¹|u
¸9xt3ÀÃÌÌÌ2ÀÃÌ2ÀÃÌ2ÀÃÌ2ÀÃ̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°Ã̃a8°ÃÌŠAA< t(<#t<+t<-t
<0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°ÃÌÌŠAA< t(<#t<+t<-t
<0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°ÃÌÌŠAA< t(<#t<+t<-t
<0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°ÃÌÌŠAA< t(<#t<+t<-t
<0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°ÃÌÌŠAA< t(<#t<+t<-t
<0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°ÃÌÌŠAA< t(<#t<+t<-t
<0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°ÃÌÌ·ABƒø t,ƒø#t!ƒø+tƒø-tƒø0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°Ã·ABƒø t,ƒø#t!ƒø+tƒø-tƒø0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°Ã·ABƒø t,ƒø#t!ƒø+tƒø-tƒø0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°Ã·ABƒø t,ƒø#t!ƒø+tƒø-tƒø0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°Ã·ABƒø t,ƒø#t!ƒø+tƒø-tƒø0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°Ã·ABƒø t,ƒø#t!ƒø+tƒø-tƒø0uƒI0ëƒI0ëƒI0ë
ƒI0 ëƒI0°Ã@SHƒì 3ÒH‹Ùèp	„ÀtCH‹ƒhŠSA‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hè²yƒøÿu	C(ëÿC(°ëè”ãÇèMé2ÀHƒÄ [ÃÌ@SHƒì H‹Ù‹‰xƒùu	ƒ»|tƒùu
ƒ»|u°ëa3ÒH‹Ëèk	„ÀtAH‹ƒhŠSA‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hèyƒøÿu	C(ë²ÿC(ë­èýâÇè¶è2ÀHƒÄ [ÃÌÌ@SHƒì 3ÒH‹Ùè	„ÀtCH‹ƒhŠSA‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hèªxƒøÿu	C(ëÿC(°ëèŒâÇèEè2ÀHƒÄ [ÃÌ@SHƒì 3ÒH‹Ùè´	„ÀtHH‹‹hDŠCAH‹AH9Au€ytÿC(ë$ƒK(ÿëÿC(HÿAH‹‹hH‹DˆH‹‹hHÿ°ëèâÇèÐç2ÀHƒÄ [Ã@SHƒì H‹Ù‹‰xƒùu	ƒ»|tƒùu
ƒ»|u°ëd3ÒH‹Ëè¯	„ÀtDH‹‹hŠSAH‹AH9Au€ytÿC(ëσK(ÿëÉÿC(HÿAH‹ƒhH‹ˆH‹ƒhHÿëªè~áÇè7ç2ÀHƒÄ [ÃÌÌÌ@SHƒì 3ÒH‹ÙèÔ	„ÀtHH‹‹hDŠCAH‹AH9Au€ytÿC(ë$ƒK(ÿëÿC(HÿAH‹‹hH‹DˆH‹‹hHÿ°ëèáÇèÀæ2ÀHƒÄ [Ã@SHƒì ÆATH‹Ù·IBH‹ƒh‹PÁêöÂtH‹ƒhHƒxtH‹“hèŸt¹ÿÿf;ÁuƒK(ÿëÿC(°HƒÄ [Ã@SHƒì H‹Ù‹‰xƒùu	ƒ»|tZƒùu	ƒ»|tLD·CBÆCTH‹ƒh‹HÁéöÁtH‹ƒhHƒxt H‹“hA·Èè t¹ÿÿf;ÁuƒK(ÿëÿC(°HƒÄ [ÃÌ@SHƒì ÆATH‹Ù·IBH‹ƒh‹PÁêöÂtH‹ƒhHƒxtH‹“hèÇs¹ÿÿf;ÁuƒK(ÿëÿC(°HƒÄ [ÃD·IBL‹ÁÆATH‹‰hH‹AH9Au€ytAÿ@(ë(AƒH(ÿë!Aÿ@(HÿAI‹ˆhH‹fD‰
I‹ˆhHƒ°ÃH‹Ñ‹‰xƒùu	ƒº|tYƒùu	ƒº|tKD·BBÆBTH‹ŠhH‹AH9Au€ytÿB(ë&ƒJ(ÿë ÿB(HÿAH‹‚hH‹fD‰H‹‚hHƒ°ÃÌD·IBL‹ÁÆATH‹‰hH‹AH9Au€ytAÿ@(ë(AƒH(ÿë!Aÿ@(HÿAI‹ˆhH‹fD‰
I‹ˆhHƒ°Ã@SHƒì 3ÒH‹Ùè(„ÀtAH‹ƒhŠSA‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hèjtƒøÿu	C(ëÿC(°HƒÄ [ÃÌ@SHƒì 3ÒH‹Ùè`„ÀtAH‹ƒhŠSA‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hètƒøÿu	C(ëÿC(°HƒÄ [ÃÌ@SHƒì 3ÒH‹Ù蘄ÀtAH‹ƒhŠSA‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hè²sƒøÿu	C(ëÿC(°HƒÄ [ÃÌ@SHƒì 3ÒH‹ÙèЄÀtFH‹‹hDŠCAH‹AH9Au€ytÿC(ë$ƒK(ÿëÿC(HÿAH‹‹hH‹DˆH‹‹hHÿ°HƒÄ [Ã@SHƒì 3ÒH‹Ùè„ÀtFH‹‹hDŠCAH‹AH9Au€ytÿC(ë$ƒK(ÿëÿC(HÿAH‹‹hH‹DˆH‹‹hHÿ°HƒÄ [Ã@SHƒì 3ÒH‹Ùè@„ÀtFH‹‹hDŠCAH‹AH9Au€ytÿC(ë$ƒK(ÿëÿC(HÿAH‹‹hH‹DˆH‹‹hHÿ°HƒÄ [Ã@SHƒì ÆATH‹Ù·IBH‹ƒh‹PÁêöÂtH‹ƒhHƒxtH‹“hèp¹ÿÿf;ÁuƒK(ÿëÿC(°HƒÄ [Ã@SHƒì ÆATH‹Ù·IBH‹ƒh‹PÁêöÂtH‹ƒhHƒxtH‹“hèÇo¹ÿÿf;ÁuƒK(ÿëÿC(°HƒÄ [Ã@SHƒì ÆATH‹Ù·IBH‹ƒh‹PÁêöÂtH‹ƒhHƒxtH‹“hèoo¹ÿÿf;ÁuƒK(ÿëÿC(°HƒÄ [ÃD·IBL‹ÁÆATH‹‰hH‹AH9Au€ytAÿ@(ë(AƒH(ÿë!Aÿ@(HÿAI‹ˆhH‹fD‰
I‹ˆhHƒ°ÃD·IBL‹ÁÆATH‹‰hH‹AH9Au€ytAÿ@(ë(AƒH(ÿë!Aÿ@(HÿAI‹ˆhH‹fD‰
I‹ˆhHƒ°ÃD·IBL‹ÁÆATH‹‰hH‹AH9Au€ytAÿ@(ë(AƒH(ÿë!Aÿ@(HÿAI‹ˆhH‹fD‰
I‹ˆhHƒ°Ã@SHƒì H‹AH‹Ù¶QAÆAT¹€H‹H‹f…PtdH‹ƒh‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hè#pƒøÿu	C(ëÿC(H‹CŠHÿÀˆKAH‰C„ÉuèõÙÇè®ß2Àë°HƒÄ [ÃÌÌ@SHƒì H‹AH‹Ù¶QAÆAT¹€H‹H‹f…PtdH‹ƒh‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hèoƒøÿu	C(ëÿC(H‹CŠHÿÀˆKAH‰C„ÉuèaÙÇèß2Àë°HƒÄ [ÃÌÌ@SHƒì H‹AH‹Ù¶QAÆAT¹€H‹H‹f…PtdH‹ƒh‹HÁéöÁtH‹ƒhHƒxt¾ÊH‹“hèûnƒøÿu	C(ëÿC(H‹CŠHÿÀˆKAH‰C„ÉuèÍØÇè†Þ2Àë°HƒÄ [ÃÌÌHƒì(H‹AH‹ÑD¶AAÆAT¹€H‹H‹fB…@thH‹ŠhH‹AH9Au€ytÿB(ë$ƒJ(ÿëÿB(HÿAH‹‚hH‹DˆH‹‚hHÿH‹BŠHÿÀˆJAH‰B„Éuè5ØÇèîÝ2Àë°HƒÄ(ÃÌÌÌHƒì(H‹AH‹ÑD¶AAÆAT¹€H‹H‹fB…@thH‹ŠhH‹AH9Au€ytÿB(ë$ƒJ(ÿëÿB(HÿAH‹‚hH‹DˆH‹‚hHÿH‹BŠHÿÀˆJAH‰B„Éuè×ÇèVÝ2Àë°HƒÄ(ÃÌÌÌHƒì(H‹AH‹ÑD¶AAÆAT¹€H‹H‹fB…@thH‹ŠhH‹AH9Au€ytÿB(ë$ƒJ(ÿëÿB(HÿAH‹‚hH‹DˆH‹‚hHÿH‹BŠHÿÀˆJAH‰B„Éuè×Çè¾Ü2Àë°HƒÄ(ÃÌÌÌÆAT°ÃÌÆAT°ÃÌÆAT°ÃÌÆAT°ÃÌÆAT°ÃÌÆAT°Ã̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌ̃I8ÿ3ÀH‰A0ˆA@‰A<ˆAT°ÃÌÌ€yA*L‹Át	HQ8éºÉÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌÌ@SHƒì €yA*H‹ÙtHQ8HƒÄ [éÊÿÿ蘄Àtƒ»xu	ƒ»|u
ƒ{8}ƒK8ÿ°HƒÄ [ÃÌÌ€yA*L‹Át	HQ8éFÊÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌÌ€yA*L‹Át	HQ8éšÊÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌÌ@SHƒì €yA*H‹ÙtHQ8HƒÄ [éãÊÿÿèz˜„Àtƒ»xu	ƒ»|u
ƒ{8}ƒK8ÿ°HƒÄ [ÃÌÌ€yA*L‹Át	HQ8é&ËÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌÌfƒyB*L‹Át	HQ8éyËÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌ@SHƒì fƒyB*H‹ÙtHQ8HƒÄ [é¾ËÿÿèᘄÀtƒ»xu	ƒ»|u
ƒ{8}ƒK8ÿ°HƒÄ [ÃÌfƒyB*L‹Át	HQ8éýËÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌfƒyB*L‹Át	HQ8éMÌÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌ@SHƒì fƒyB*H‹ÙtHQ8HƒÄ [é’ÌÿÿèM™„Àtƒ»xu	ƒ»|u
ƒ{8}ƒK8ÿ°HƒÄ [ÃÌfƒyB*L‹Át	HQ8éÑÌÿÿHƒA H‹A ‹HøƒÈÿ…ÉHÈ°A‰H8ÃÌÌHƒì(ŠAA†ÿÿH‹CHk(L³hH‰D$ L‹ÍHT$PI‹ÎD‹Ç蘋K0‹ÁÁèA„ÇtÁéA„ÏuL‹ÍD‹Æ²0I‹Îèò…ÿÿ3ÒH‹Ëèȃ}|‹C0ÁèA„ÇtL‹ÍD‹Æ² I‹ÎèÇ…ÿÿAŠÇH‹\$XH‹l$`H‹t$hHƒÄ0A_A^_ÃÌÌÌH‰\$H‰l$H‰t$ WAVAWHƒì0¾AAH‹ÙA¿ƒød]„ȃøA„ÒƒøCt3ƒøDŽÍƒøGŽ»ƒøSt_ƒøXtoƒøZtƒøa„£ƒøc…£3Òè¼>é“èê鉃øg~ƒøitgƒønt[ƒøot8ƒøptƒøstƒøutRƒøxueP˜ëMèjëUÇA8ÇA<EŠÇºë1‹I0‹ÁÁèA„Çtºé‰K0ºH‹ËëèŠ]ëƒI0º
E3Àè³KëèX(„Àu2Àé[ƒ»|u
D9»x„B€{@…8‹S03Àf‰D$P3ÿˆD$R‹ÂÁèA„Çt.‹ÂÁèA„ÇtÆD$P-ëA„×tÆD$P+ë‹ÂÑèA„ÇtÆD$P I‹ÿŠKAA¨¨ßu‹ÂÁèA„ÇtEŠÇëE2ÀA¿¨ß”ÀE„Àu„Àt*ÆDxÿÿH‹CHk(L³hH‰D$ L‹ÍHT$0I‹ÎD‹Ç蛉‹K0‹ÁÁèA„ÇtÁéA„ÏuL‹ÍD‹ÆAŠÔI‹Îèñwÿÿ3ÒH‹Ëè·„ƒ}|‹C0ÁèA„ÇtL‹ÍD‹ÆAŠÕI‹ÎèÅwÿÿAŠÇH‹L$8H3ÌèÅfþÿL\$@I‹[8I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰l$H‰t$ WATAUAVAWHƒì@H‹AUH3ÄH‰D$8·AB¾XH‹ÙnéD~©ƒød[„Æ;Å„уøCt2ƒøDŽÌƒøGŽºƒøSt^;ÆtoƒøZtƒøa„£ƒøc…£3Òèé4é“è鉃øg~ƒøitgƒønt[ƒøot8ƒøptƒøstƒøutRƒøxueP˜ëMè$`ëUÇA8ÇA<EŠÇºë1‹I0‹ÁÁèA„Çtºé‰K0ºH‹Ëëè‹TëƒI0º
E3ÀèGëè&„Àu2Àél€{@…_‹S03À‰D$03ÿf‰D$4‹ÂÁèDo A„Çt2‹ÂÁèA„Çt
G-f‰D$0ëA„×t¸+ëí‹ÂÑèA„Çt	fD‰l$0I‹ÿ·KBA¹ßÿ·Áf+ÆfA…Áu‹ÂÁèA„ÇtEŠÇëE2À·ÁA¼0f+ÅfA…Á”ÀE„Àu„Àt/fD‰d|0Iÿf;Ît	f;Ít2ÀëAŠÇöØÀ$àa¾Àf‰D|0Iÿ‹s4+sP+÷öÂuLK(D‹ÆH‹hAŠÕè^vÿÿH‹CHk(L³hH‰D$ L‹ÍHT$0I‹ÎD‹Çè—ˆ‹K0‹ÁÁèA„ÇtÁéA„ÏuL‹ÍD‹ÆAŠÔI‹Îèvÿÿ3ÒH‹Ëèׂƒ}|‹C0ÁèA„ÇtL‹ÍD‹ÆAŠÕI‹ÎèåuÿÿAŠÇH‹L$8H3ÌèùcþÿL\$@I‹[8I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰l$H‰t$ WATAUAVAWHƒì@H‹uRH3ÄH‰D$8·AB¾XH‹ÙnéD~©ƒød[„Æ;Å„уøCt2ƒøDŽÌƒøGŽºƒøSt^;ÆtoƒøZtƒøa„£ƒøc…£3ÒèÅ2é“è¿鉃øg~ƒøitgƒønt[ƒøot8ƒøptƒøstƒøutRƒøxueP˜ëMè ^ëUÇA8ÇA<EŠÇºë1‹I0‹ÁÁèA„Çtºé‰K0ºH‹Ëëè›RëƒI0º
E3ÀèÔEëè•%„Àu2À邃»|u
D9»x„i€{@…_‹S03À‰D$03ÿf‰D$4‹ÂÁèDo A„Çt2‹ÂÁèA„Çt
G-f‰D$0ëA„×t¸+ëí‹ÂÑèA„Çt	fD‰l$0I‹ÿ·KBA¹ßÿ·Áf+ÆfA…Áu‹ÂÁèA„ÇtEŠÇëE2À·ÁA¼0f+ÅfA…Á”ÀE„Àu„Àt/fD‰d|0Iÿf;Ît	f;Ít2ÀëAŠÇöØÀ$àa¾Àf‰D|0Iÿ‹s4+sP+÷öÂuLK(D‹ÆH‹hAŠÕè|sÿÿH‹CHk(L³hH‰D$ L‹ÍHT$0I‹ÎD‹Çèµ…‹K0‹ÁÁèA„ÇtÁéA„ÏuL‹ÍD‹ÆAŠÔI‹Îè/sÿÿ3ÒH‹Ëè倃}|‹C0ÁèA„ÇtL‹ÍD‹ÆAŠÕI‹ÎèsÿÿAŠÇH‹L$8H3ÌèaþÿL\$@I‹[8I‹k@I‹sHI‹ãA_A^A]A\_ÃÌH‰\$H‰l$H‰t$ WATAUAVAWHƒì@H‹•OH3ÄH‰D$8·AB¾XH‹ÙnéD~©ƒød[„Æ;Å„уøCt2ƒøDŽÌƒøGŽºƒøSt^;ÆtoƒøZtƒøa„£ƒøc…£3Òè±0é“è鉃øg~ƒøitgƒønt[ƒøot8ƒøptƒøstƒøutRƒøxueP˜ëMè \ëUÇA8ÇA<EŠÇºë1‹I0‹ÁÁèA„Çtºé‰K0ºH‹Ëëè¿PëƒI0º
E3ÀèøDëè%%„Àu2Àél€{@…_‹S03À‰D$03ÿf‰D$4‹ÂÁèDo A„Çt2‹ÂÁèA„Çt
G-f‰D$0ëA„×t¸+ëí‹ÂÑèA„Çt	fD‰l$0I‹ÿ·KBA¹ßÿ·Áf+ÆfA…Áu‹ÂÁèA„ÇtEŠÇëE2À·ÁA¼0f+ÅfA…Á”ÀE„Àu„Àt/fD‰d|0Iÿf;Ît	f;Ít2ÀëAŠÇöØÀ$àa¾Àf‰D|0Iÿ‹s4+sP+÷öÂuLK(D‹ÆH‹hAŠÕè²pÿÿH‹CHk(L³hH‰D$ L‹ÍHT$0I‹ÎD‹Çèë‚‹K0‹ÁÁèA„ÇtÁéA„ÏuL‹ÍD‹ÆAŠÔI‹Îèepÿÿ3ÒH‹Ëèƒ}|‹C0ÁèA„ÇtL‹ÍD‹ÆAŠÕI‹Îè9pÿÿAŠÇH‹L$8H3ÌèM^þÿL\$@I‹[8I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌ€yA*t	HQ4éM”ÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°ÃÌÌ@SHƒì €yA*H‹ÙtHQ4HƒÄ [é“”ÿÿèú]„Àt$ƒ»xu	ƒ»|u‹C4…Ày	ƒK0÷؉C4°HƒÄ [ÀyA*t	HQ4éÕ”ÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°ÃÌÌ€yA*t	HQ4é)•ÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°ÃÌÌ@SHƒì €yA*H‹ÙtHQ4HƒÄ [éo•ÿÿè^^„Àt$ƒ»xu	ƒ»|u‹C4…Ày	ƒK0÷؉C4°HƒÄ [ÀyA*t	HQ4鱕ÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°ÃÌÌfƒyB*t	HQ4é–ÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°ÃÌ@SHƒì fƒyB*H‹ÙtHQ4HƒÄ [éF–ÿÿèÁ^„Àt$ƒ»xu	ƒ»|u‹C4…Ày	ƒK0÷؉C4°HƒÄ [ÃÌÌÌfƒyB*t	HQ4逖ÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°ÃÌfƒyB*t	HQ4éЖÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°ÃÌ@SHƒì fƒyB*H‹ÙtHQ4HƒÄ [é—ÿÿè%_„Àt$ƒ»xu	ƒ»|u‹C4…Ày	ƒK0÷؉C4°HƒÄ [ÃÌÌÌfƒyB*t	HQ4éL—ÿÿHƒA H‹A ‹Pø‰Q4…Òy	ƒI0÷Ú‰Q4°Ã̸	ÃÌ̸	ÃÌ̸	ÃÌ̸	ÃÌ̸ÃÌ̸ÃÌ̸ÃÌ̸ÃÌÌHýàÃHõàÃHíàÃHåàÃH}àÃHuàÃHmàÃHeàÃù2t…Étƒét!ƒétƒétƒùu)¸øøøÃétãƒétÞƒétÙëÍ3ÀÃÌA°ºé;,ÌÌÌA°ºéË-ÌÌÌA°ºé¿/ÌÌÌA°ºéO1ÌÌÌA°ºéß2ÌÌÌA°ºéÓ4ÌÌÌA°ºéc6ÌÌÌA°ºéó7ÌÌÌA°ºéç9ÌÌÌA°ºéw;ÌÌÌA°ºé=ÌÌÌA°ºéû>ÌÌÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt3H‹wH…öt*D‹A<ŠQAH‹	èüXÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
¶ßÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃÌH‹ÄH‰XH‰pWHƒì Hƒ`HPH‹ÙèBÿÿ„Àtgƒ»xu	ƒ»|uSH‹|$8H…ÿt3H‹wH…öt*D‹C<ŠSAH‹è_Xÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëHßÇCPH‰CHÆCT°H‹\$0H‹t$@HƒÄ _ÃH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt3H‹wH…öt*D‹A<ŠQAH‹	èàWÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
šÞÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt3H‹wH…öt*D‹A<ŠQAH‹	è`Wÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
ÞÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃÌH‹ÄH‰XH‰pWHƒì Hƒ`HPH‹ÙèwAÿÿ„Àtgƒ»xu	ƒ»|uSH‹|$8H…ÿt3H‹wH…öt*D‹C<ŠSAH‹èÃVÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH}ÝÇCPH‰CHÆCT°H‹\$0H‹t$@HƒÄ _ÃH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt3H‹wH…öt*D‹A<ŠQAH‹	èDVÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
þÜÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt4H‹wH…öt+D‹A<·QBH‹	èóUÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
}ÜÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃH‹ÄH‰XH‰pWHƒì Hƒ`HPH‹ÙèÛ@ÿÿ„Àthƒ»xu	ƒ»|uTH‹|$8H…ÿt4H‹wH…öt+D‹C<·SBH‹èVUÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëHàÛÇCPH‰CHÆCT°H‹\$0H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt4H‹wH…öt+D‹A<·QBH‹	èÓTÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
]ÛÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt4H‹wH…öt+D‹A<·QBH‹	èSTÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
ÝÚÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃH‹ÄH‰XH‰pWHƒì Hƒ`HPH‹Ùè;@ÿÿ„Àthƒ»xu	ƒ»|uTH‹|$8H…ÿt4H‹wH…öt+D‹C<·SBH‹è¶Sÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH@ÚÇCPH‰CHÆCT°H‹\$0H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A H‹xøH…ÿt4H‹wH…öt+D‹A<·QBH‹	è3Sÿÿ„ÀH‰sH·tÑè‰CPÆCTë‰CPëH
½ÙÇCPH‰KHÆCTH‹\$0°H‹t$8HƒÄ _ÃH‰\$WHƒìPƒI0H‹Ù‹A8…ÀyŠAA,A$ßöØÀƒàùƒÀ
‰A8ëuŠAA,G¨ßuÇA8‹A8HyX]H‹ÏHcÐèÕ!ÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KAHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹Êèš%‹C0Áè¨tƒ{8u
H‹SH‹KHè~ÿÿŠCA,G¨ßum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£ÁsÆCAsHƒÉÿHÿÁ€<
u÷‰KP°H‹\$hHƒÄP_ÃÌÌH‰\$H‰t$WHƒìPƒI0H‹Ùèec„Àu2À郻xu
ƒ»|…û‹C8…ÀyŠCA,A$ßöØÀƒàùƒÀ
‰C8ëuŠCA,G¨ßuÇC8‹C8H{X]H‹ÏHcÐèŽÿÿ¾„Àu Hƒ¿u‹Æë
H‹‡HÑè£þÿÿ‰C8H‹‡HT$`H…ÀH‹ËHDÇH‰CH3ÀH‰D$`è›@ÿÿ„À„FÿÿÿHƒ¿uL‹Æë
L‹‡IÑèH‹H…Éu	Lë
L‹IÑéLÉHƒùt
H‹·HÑîH‹CH‹ÑH‰D$@H…ÉH‹¾KAHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰D$ L‹ÆèT#‹C0Áè¨tƒ{8u
H‹SH‹KHè×{ÿÿŠCA,G¨ßum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹KHŠ,I<%wHº!!H£ÂsÆCAsHƒÈÿHÿÀ€<u÷‰CP°H‹\$hH‹t$pHƒÄP_ÃÌÌÌH‰\$WHƒìPƒI0H‹Ù‹A8…ÀyŠAA,A$ßöØÀƒàùƒÀ
‰A8ëuŠAA,G¨ßuÇA8‹A8HyX]H‹ÏHcÐèmÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KAHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹Êè2!‹C0Áè¨tƒ{8u
H‹SH‹KHèµyÿÿŠCA,G¨ßum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£ÁsÆCAsHƒÉÿHÿÁ€<
u÷‰KP°H‹\$hHƒÄP_ÃÌÌH‰\$WHƒìPƒI0H‹Ù‹A8…ÀyŠAA,A$ßöØÀƒàùƒÀ
‰A8ëuŠAA,G¨ßuÇA8‹A8HyX]H‹ÏHcÐèQÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KAHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹Êè‹C0Áè¨tƒ{8u
H‹SH‹KHè™wÿÿŠCA,G¨ßum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£ÁsÆCAsHƒÉÿHÿÁ€<
u÷‰KP°H‹\$hHƒÄP_ÃÌÌH‰\$H‰t$WHƒìPƒI0H‹Ùè}]„Àu2À郻xu
ƒ»|…û‹C8…ÀyŠCA,A$ßöØÀƒàùƒÀ
‰C8ëuŠCA,G¨ßuÇC8‹C8H{X]H‹ÏHcÐè
ÿÿ¾„Àu Hƒ¿u‹Æë
H‹‡HÑè£þÿÿ‰C8H‹‡HT$`H…ÀH‹ËHDÇH‰CH3ÀH‰D$`èß:ÿÿ„À„FÿÿÿHƒ¿uL‹Æë
L‹‡IÑèH‹H…Éu	Lë
L‹IÑéLÉHƒùt
H‹·HÑîH‹CH‹ÑH‰D$@H…ÉH‹¾KAHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰D$ L‹ÆèЋC0Áè¨tƒ{8u
H‹SH‹KHèSuÿÿŠCA,G¨ßum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹KHŠ,I<%wHº!!H£ÂsÆCAsHƒÈÿHÿÀ€<u÷‰CP°H‹\$hH‹t$pHƒÄP_ÃÌÌÌH‰\$WHƒìPƒI0H‹Ù‹A8…ÀyŠAA,A$ßöØÀƒàùƒÀ
‰A8ëuŠAA,G¨ßuÇA8‹A8HyX]H‹ÏHcÐèéÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KAHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹Ê讋C0Áè¨tƒ{8u
H‹SH‹KHè1sÿÿŠCA,G¨ßum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£ÁsÆCAsHƒÉÿHÿÁ€<
u÷‰KP°H‹\$hHƒÄP_ÃÌÌH‰\$H‰|$AVHƒìPƒI0H‹Ù‹A8A¾ßÿ…Ày·ABfƒèAfA#Æf÷ØÀƒàùƒÀ
‰A8ëu·ABfƒèGfA…ÆuÇA8‹A8HyX]H‹ÏHcÐè¶ÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KBHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹Êè{‹C0Áè¨tƒ{8u
H‹SH‹KHèþpÿÿ·CBfƒèGfA…Æum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£Ás	¸sf‰CBHƒÉÿHÿÁ€<
u÷H‹|$p°‰KPH‹\$hHƒÄPA^ÃÌÌÌH‰\$H‰t$H‰|$ AWHƒìPƒI0H‹ÙègW„Àu2Àé.ƒ»xu
ƒ»|…‹C8A¿ßÿ…Ày·CBfƒèAfA#Çf÷ØÀƒàùƒÀ
‰C8ëu·CBfƒèGfA…ÇuÇC8‹C8H{X]H‹ÏHcÐèGÿÿ¾„Àu Hƒ¿u‹Æë
H‹‡HÑè£þÿÿ‰C8H‹‡HT$`H…ÀH‹ËHDÇH‰CH3ÀH‰D$`èä4ÿÿ„À„5ÿÿÿHƒ¿uL‹Æë
L‹‡IÑèH‹H…Éu	Lë
L‹IÑéLÉHƒùt
H‹·HÑîH‹CH‹ÑH‰D$@H…ÉH‹¾KBHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰D$ L‹Æè
‹C0Áè¨tƒ{8u
H‹SH‹KHènÿÿ·CBfƒèGfA…Çum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹KHŠ,I<%wHº!!H£Âs	¸sf‰CBHƒÈÿHÿÀ€<u÷‰CP°H‹\$hH‹t$pH‹|$xHƒÄPA_ÃH‰\$H‰|$AVHƒìPƒI0H‹Ù‹A8A¾ßÿ…Ày·ABfƒèAfA#Æf÷ØÀƒàùƒÀ
‰A8ëu·ABfƒèGfA…ÆuÇA8‹A8HyX]H‹ÏHcÐèÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KBHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹ÊèÇ‹C0Áè¨tƒ{8u
H‹SH‹KHèJlÿÿ·CBfƒèGfA…Æum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£Ás	¸sf‰CBHƒÉÿHÿÁ€<
u÷H‹|$p°‰KPH‹\$hHƒÄPA^ÃÌÌÌH‰\$H‰|$AVHƒìPƒI0H‹Ù‹A8A¾ßÿ…Ày·ABfƒèAfA#Æf÷ØÀƒàùƒÀ
‰A8ëu·ABfƒèGfA…ÆuÇA8‹A8HyX]H‹ÏHcÐè¾
ÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KBHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹Ê胋C0Áè¨tƒ{8u
H‹SH‹KHèjÿÿ·CBfƒèGfA…Æum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£Ás	¸sf‰CBHƒÉÿHÿÁ€<
u÷H‹|$p°‰KPH‹\$hHƒÄPA^ÃÌÌÌH‰\$H‰t$H‰|$ AWHƒìPƒI0H‹ÙèQ„Àu2Àé.ƒ»xu
ƒ»|…‹C8A¿ßÿ…Ày·CBfƒèAfA#Çf÷ØÀƒàùƒÀ
‰C8ëu·CBfƒèGfA…ÇuÇC8‹C8H{X]H‹ÏHcÐèOÿÿ¾„Àu Hƒ¿u‹Æë
H‹‡HÑè£þÿÿ‰C8H‹‡HT$`H…ÀH‹ËHDÇH‰CH3ÀH‰D$`è´.ÿÿ„À„5ÿÿÿHƒ¿uL‹Æë
L‹‡IÑèH‹H…Éu	Lë
L‹IÑéLÉHƒùt
H‹·HÑîH‹CH‹ÑH‰D$@H…ÉH‹¾KBHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰D$ L‹Æè‹C0Áè¨tƒ{8u
H‹SH‹KHè˜gÿÿ·CBfƒèGfA…Çum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹KHŠ,I<%wHº!!H£Âs	¸sf‰CBHƒÈÿHÿÀ€<u÷‰CP°H‹\$hH‹t$pH‹|$xHƒÄPA_ÃH‰\$H‰|$AVHƒìPƒI0H‹Ù‹A8A¾ßÿ…Ày·ABfƒèAfA#Æf÷ØÀƒàùƒÀ
‰A8ëu·ABfƒèGfA…ÆuÇA8‹A8HyX]H‹ÏHcÐè
	ÿÿA¸„Àu!Hƒ¿uA‹Àë
H‹‡HÑè£þÿÿ‰C8H‹‡H…ÀHDÇH‰CH3ÀHƒC Hƒ¿H‰D$`H‹C ò@øòD$`uM‹Èë
L‹IÑéH‹H…Éu	L—ë
L‹—IÑêLÑHƒùt
L‹‡IÑèH‹CH‹ÑH‰D$@H…ÉH‹¾KBHD×H‰D$8‹C8‰D$0‰L$(HL$`L‰L$ M‹ÊèÏ‹C0Áè¨tƒ{8u
H‹SH‹KHèReÿÿ·CBfƒèGfA…Æum‹C0Áè¨ucH‹CH‹SHH‹H‹øH‹DŠëA:Àt	HÿŠ„ÀuòŠHÿ„Àt2ë	,E¨ßt	HÿŠ„ÀuñH‹ÊHÿÊ€:0tøD8uHÿÊŠHÿÂHÿÁˆ„ÀuòH‹CH€8-uƒK0@HÿÀH‰CHH‹SHŠ,I<%wH¹!!H£Ás	¸sf‰CBHƒÉÿHÿÁ€<
u÷H‹|$p°‰KPH‹\$hHƒÄPA^ÃÌÌÌ3ÒéYÌ3ÒéÌ3ÒéõÌ3Òé¡Ì3ÒéMÌ3Òé=Ì3ÒééÌ3Òé‰Ì3ÒéMÌ3ÒéíÌ3ÒéÌ3ÒéQÌH‰\$WHƒì D‹A…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$WHƒì 3ÛHT$8H‰\$8H‹ùèÿÿ„Àu2ÀéЃ¿xu
ƒ¿|…¸è¬ñ…ÀuèZÇèÐ_ëÈ‹O<ºƒù/t<…Étƒétƒétƒétƒùu)ë"H‹Úë"»ë»ëƒét
ƒétƒéuÒ»Hƒët9Hƒët%HƒëtH;Úu‡H‹D$8HcO(H‰ë$H‹D$8‹O(‰ëH‹D$8·O(f‰ë
H‹D$8ŠO(ˆÆG@°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì »H‹ùHY H‹A H‹pøèÄð…Àuè/YÇèè^2À鈋O<ºƒù,t>…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì »H‹ùHY H‹A H‹pøèèï…ÀuèSXÇè^2À鈋O<ºƒù,t>…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$WHƒì 3ÛHT$8H‰\$8H‹ùèÿÿ„Àu2ÀéЃ¿xu
ƒ¿|…¸èðî…Àuè[WÇè]ëÈ‹O<ºƒù/t<…Étƒétƒétƒétƒùu)ë"H‹Úë"»ë»ëƒét
ƒétƒéuÒ»Hƒët9Hƒët%HƒëtH;Úu‡H‹D$8HcO(H‰ë$H‹D$8‹O(‰ëH‹D$8·O(f‰ë
H‹D$8ŠO(ˆÆG@°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì »H‹ùHY H‹A H‹pøèî…ÀuèsVÇè,\2À鈋O<ºƒù,t>…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì »H‹ùHY H‹A H‹pøè,í…Àuè—UÇèP[2À鈋O<ºƒù,t>…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$WHƒì 3ÛHT$8H‰\$8H‹ùèÿÿ„Àu2ÀéЃ¿xu
ƒ¿|…¸è4ì…ÀuèŸTÇèXZëÈ‹O<ºƒù/t<…Étƒétƒétƒétƒùu)ë"H‹Úë"»ë»ëƒét
ƒétƒéuÒ»Hƒët9Hƒët%HƒëtH;Úu‡H‹D$8HcO(H‰ë$H‹D$8‹O(‰ëH‹D$8·O(f‰ë
H‹D$8ŠO(ˆÆG@°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì »H‹ùHY H‹A H‹pøèLë…Àuè·SÇèpY2À鈋O<ºƒù,t>…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì »H‹ùHY H‹A H‹pøèpê…ÀuèÛRÇè”X2À鈋O<ºƒù,t>…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$WHƒì 3ÛHT$8H‰\$8H‹ùè&ÿþÿ„Àu2ÀéЃ¿xu
ƒ¿|…¸èxé…ÀuèãQÇèœWëÈ‹O<ºƒù/t<…Étƒétƒétƒétƒùu)ë"H‹Úë"»ë»ëƒét
ƒétƒéuÒ»Hƒët9Hƒët%HƒëtH;Úu‡H‹D$8HcO(H‰ë$H‹D$8‹O(‰ëH‹D$8·O(f‰ë
H‹D$8ŠO(ˆÆG@°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì »H‹ùHY H‹A H‹pøèè…ÀuèûPÇè´V2À鈋O<ºƒù,t>…Ét7ƒétƒétƒét(ƒùt&3Ûë"»ë»ëƒétƒét
ƒétëÓH‹ÚHƒët*HƒëtHƒëtH;Úu…HcG(H‰ë‹G(‰ë·G(f‰ëŠO(ˆÆG@°H‹\$0H‹t$8HƒÄ _ÃÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPéáßÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPéaáÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPéEãÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPéÅäÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPéEæÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPé)èÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPé©éÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPé)ëÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPé
íÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPéîÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPé
ðÿÿÌ‹Q0‹ÂÁè¨tºê‰Q0E3ÀAPéññÿÿ̺ÇA<A°‰Q8éiÞÿÿ̺ÇA<A°‰Q8éñßÿÿ̺ÇA<A°‰Q8éÝáÿÿ̺ÇA<A°‰Q8éeãÿÿ̺ÇA<A°‰Q8éíäÿÿ̺ÇA<A°‰Q8éÙæÿÿ̺ÇA<A°‰Q8éaèÿÿ̺ÇA<A°‰Q8éééÿÿ̺ÇA<A°‰Q8éÕëÿÿ̺ÇA<A°‰Q8é]íÿÿ̺ÇA<A°‰Q8éåîÿÿ̺ÇA<A°‰Q8éÑðÿÿÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹q8ƒþÿD‹A<ŠQAH‹xø¸ÿÿÿH‰yHDðH‹	èÐ
ÿÿHcÖ„ÀtH…ÿÆCTH
£‘HEÏH‰KHèö‰ëH…ÿH
~‘HEÏH‰KHèˆH‹t$8‰CP°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì HyHH‹ÙH‹×èjðþÿ„Àttƒ»xu	ƒ»|u`‹s8¸ÿÿÿD‹C<ƒþÿŠSAH‹Dðè/
ÿÿ„Àt!Hƒ?u
H‘H‰H‹HcÖÆCTèT‰ëHƒ?u
HÙH‰H‹HcÖèÛ‡‰CP°H‹\$0H‹t$8HƒÄ _ÃÌÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹q8ƒþÿD‹A<ŠQAH‹xø¸ÿÿÿH‰yHDðH‹	è˜	ÿÿHcÖ„ÀtH…ÿÆCTH
kHEÏH‰KH辈ëH…ÿH
FHEÏH‰KHèI‡H‹t$8‰CP°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹q8ƒþÿD‹A<ŠQAH‹xø¸ÿÿÿH‰yHDðH‹	è	ÿÿHcÖ„ÀtH…ÿÆCTH
ÛHEÏH‰KHè.ˆëH…ÿH
¶HEÏH‰KH蹆H‹t$8‰CP°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì HyHH‹ÙH‹×èfïþÿ„Àttƒ»xu	ƒ»|u`‹s8¸ÿÿÿD‹C<ƒþÿŠSAH‹Dðègÿÿ„Àt!Hƒ?u
H>H‰H‹HcÖÆCT茇ëHƒ?u
HH‰H‹HcÖ膉CP°H‹\$0H‹t$8HƒÄ _ÃÌÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹q8ƒþÿD‹A<ŠQAH‹xø¸ÿÿÿH‰yHDðH‹	èÐÿÿHcÖ„ÀtH…ÿÆCTH
£ŽHEÏH‰KHèö†ëH…ÿH
~ŽHEÏH‰KHè…H‹t$8‰CP°H‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹y8ƒÿÿD‹A<·QBH‹pø¸ÿÿÿH‰qHDøH‹	èoÿÿ„Àt#H…öHc×H
ŽÆCTHEÎH‰KHèe†‰CPëLH…öuHèH‰CHL‹CHE3É…ÿ~-A€8t'H‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁD;Ï|ÓD‰KPH‹\$0°H‹t$8HƒÄ _ÃÌÌH‰\$H‰t$WHƒì HyHH‹ÙH‹×è*îþÿ„À„©ƒ»xu
ƒ»|…‘‹s8¸ÿÿÿD‹C<ƒþÿ·SBH‹DðèŽÿÿ„Àt$Hƒ?u
H5H‰H‹HcÖÆCT胅‰CPëKHƒ?u
HH‰L‹E3É…ö~-A€8t'H‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁD;Î|ÓD‰KP°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹y8ƒÿÿD‹A<·QBH‹pø¸ÿÿÿH‰qHDøH‹	èÇÿÿ„Àt#H…öHc×H
nŒÆCTHEÎH‰KH轄‰CPëLH…öuH@ŒH‰CHL‹CHE3É…ÿ~-A€8t'H‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁD;Ï|ÓD‰KPH‹\$0°H‹t$8HƒÄ _ÃÌÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹y8ƒÿÿD‹A<·QBH‹pø¸ÿÿÿH‰qHDøH‹	èÿÿÿ„Àt#H…öHc×H
¦‹ÆCTHEÎH‰KHèõƒ‰CPëLH…öuHx‹H‰CHL‹CHE3É…ÿ~-A€8t'H‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁD;Ï|ÓD‰KPH‹\$0°H‹t$8HƒÄ _ÃÌÌH‰\$H‰t$WHƒì HyHH‹ÙH‹×è~ìþÿ„À„©ƒ»xu
ƒ»|…‘‹s8¸ÿÿÿD‹C<ƒþÿ·SBH‹Dðèÿÿ„Àt$Hƒ?u
HÅŠH‰H‹HcÖÆCT胉CPëKHƒ?u
H•ŠH‰L‹E3É…ö~-A€8t'H‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁD;Î|ÓD‰KP°H‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì HƒA H‹ÙH‹A ‹y8ƒÿÿD‹A<·QBH‹pø¸ÿÿÿH‰qHDøH‹	èWÿÿ„Àt#H…öHc×H
þ‰ÆCTHEÎH‰KHèM‚‰CPëLH…öuHЉH‰CHL‹CHE3É…ÿ~-A€8t'H‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁD;Ï|ÓD‰KPH‹\$0°H‹t$8HƒÄ _ÃÌÌH‹IHHcÒ退H‹IHHcÒét€H‹IHHcÒéh€H‹IHHcÒé\€H‹IHHcÒéP€H‹IHHcÒéD€L‹AHE3ÉD‹ÒL‹Ù…Ò~-A€8t'I‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁE;Ê|ÓA‹ÁÃÌÌL‹AHE3ÉD‹ÒL‹Ù…Ò~-A€8t'I‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁE;Ê|ÓA‹ÁÃÌÌL‹AHE3ÉD‹ÒL‹Ù…Ò~-A€8t'I‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁE;Ê|ÓA‹ÁÃÌÌL‹AHE3ÉD‹ÒL‹Ù…Ò~-A€8t'I‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁE;Ê|ÓA‹ÁÃÌÌL‹AHE3ÉD‹ÒL‹Ù…Ò~-A€8t'I‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁE;Ê|ÓA‹ÁÃÌÌL‹AHE3ÉD‹ÒL‹Ù…Ò~-A€8t'I‹CA¶H‹H‹¹€f…PtIÿÀIÿÀAÿÁE;Ê|ÓA‹ÁÃÌÌE3ÀAP
éÓÿÿE3ÀAP
é˜ÔÿÿE3ÀAP
éÖÿÿE3ÀAP
é$ØÿÿE3ÀAP
é¸ÙÿÿE3ÀAP
é°ÛÿÿE3ÀAP
éDÝÿÿE3ÀAP
éØÞÿÿE3ÀAP
éÐàÿÿE3ÀAP
édâÿÿE3ÀAP
éøãÿÿE3ÀAP
éðåÿÿE3ÀAPétÒÿÿE3ÀAPéÔÿÿE3ÀAPéÖÿÿE3ÀAPé”×ÿÿE3ÀAPé(ÙÿÿE3ÀAPé ÛÿÿE3ÀAPé´ÜÿÿE3ÀAPéHÞÿÿE3ÀAPé@àÿÿE3ÀAPéÔáÿÿE3ÀAPéhãÿÿE3ÀAPé`åÿÿ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌ÷Ò!Q0ÃÌÌH‰\$WHƒì0ƒ¹|H‹ÙuHƒA H‹Q D‹BøD‰A4éÚH‹IHT$@3ÿH‰|$@DG
èsdƒ»xPÿH‹D$@HHH‰K……Òxx€8$usƒúd}n‹ƒè
;ÐD‹CÇèDëÒèÒ>Çè‹D2ÀëHcÂH@H‹„Ë‹‰K4°H‹\$HHƒÄ0_ÃÌÌH‰\$WHƒì0ƒ¹|H‹ÙuHƒA H‹Q D‹BøD‰A4éÝH‹IHT$@3ÿH‰|$@DG
èSbƒ»xPÿH‹D$@HHH‰K…“…Òx{fƒ8$uuƒúd}p‹ƒè
;ÐD‹CëÒè9ÇèË>2ÀëHcÂH@H‹„Ë‹‰K8°H‹\$HHƒÄ0_ÃÌÌHƒA H‹A ‹Pø°‰Q8ÃÌÌHƒA H‹A ‹Pø°‰Q8ÃÌÌHƒA H‹A ‹Pø°‰Q8ÃÌÌHƒA H‹A ‹Pø°‰Q8ÃÌÌHƒì(H‹	H…Éuè8Çè8>2ÀHƒÄ(ÃHƒÄ(é(Hƒì(Hƒ9uèU8Çè>2Àë°HƒÄ(ÃÌÌÌHƒì(Hƒ9uè-8Çèæ=2Àë°HƒÄ(ÃÌÌÌHƒì(Hƒ9uè8Çè¾=2Àë°HƒÄ(ÃÌÌÌHƒì8ƒ:‹D$`uD‰DˆJ‰B°HƒÄ8ÉD$ è¥#ÿÿ„Àuìè¼7Çèu=2ÀëÚÌHƒì8ƒ:‹D$`uD‰DˆJ‰B°HƒÄ8ÉD$ èU%ÿÿ„Àuìè|7Çè5=2ÀëÚÌHƒì8ƒ:‹D$`uD‰fD‰J‰B°HƒÄ8ÉD$ è'ÿÿ„Àuìè;7Çèô<2ÀëÚHƒì8ƒ:‹D$`uD‰fD‰J‰B°HƒÄ8ÉD$ èÌ(ÿÿ„Àuìèû6Çè´<2ÀëÚ@SHƒì ƒy,H‹Ù…ÕH‹IŠ<%„ǃ»|u]Hƒd$0,0<	wGA¸
HT$0è~Y…À~3H‹D$0€8$u)ƒ»xuH‹ˆ3ÒA¸`	è
þÿǃ|ë
ǃ|ƒ»|uXH‹KHT$8Hƒd$8A¸
èYƒ»xH‹T$8Hÿ‰‹ì
HBH‰Cu…Éx#€:$uƒùd}‹ƒè
;ÈOÁ‰ƒè
°HƒÄ [Ãè÷5Çè°;2Àëæ@SHƒì ƒy,H‹Ù…ÕH‹IŠ<%„ǃ»|u]Hƒd$0,0<	wGA¸
HT$0èzX…À~3H‹D$0€8$u)ƒ»xuH‹ˆ3ÒA¸`	èþÿǃ|ë
ǃ|ƒ»|uXH‹KHT$8Hƒd$8A¸
èXƒ»xH‹T$8Hÿ‰‹ì
HBH‰Cu…Éx#€:$uƒùd}‹ƒè
;ÈOÁ‰ƒè
°HƒÄ [Ãèó4Çè¬:2Àëæ@SHƒì ƒy,H‹Ù…ÞH‹I·fƒø%„̓»|ubHƒd$0fƒè0fƒø	wHA¸
HT$0èX…À~4H‹D$0fƒ8$u)ƒ»xuH‹ˆ3ÒA¸`	èþÿǃ|ë
ǃ|ƒ»|uYH‹KHT$8Hƒd$8A¸
è*Xƒ»xH‹T$8Hÿ‰‹ì
HBH‰Cu …Éx$fƒ:$uƒùd}‹ƒè
;ÈOÁ‰ƒè
°HƒÄ [Ãèæ3ÇèŸ92ÀëæÌÌÌ@SHƒì ƒy,H‹Ù…ÞH‹I·fƒø%„̓»|ubHƒd$0fƒè0fƒø	wHA¸
HT$0èW…À~4H‹D$0fƒ8$u)ƒ»xuH‹ˆ3ÒA¸`	èû	þÿǃ|ë
ǃ|ƒ»|uYH‹KHT$8Hƒd$8A¸
èWƒ»xH‹T$8Hÿ‰‹ì
HBH‰Cu …Éx$fƒ:$uƒùd}‹ƒè
;ÈOÁ‰ƒè
°HƒÄ [ÃèÖ2Çè82ÀëæÌÌÌ°ÃÌ°ÃÌ°ÃÌ°ÃÌHƒì(ƒy,tƒy,tèŸ2ÇèX82Àë°HƒÄ(ÃÌHƒì(ƒy,tƒy,tès2Çè,82Àë°HƒÄ(ÃÌHƒì(ƒy,tƒy,tèG2Çè82Àë°HƒÄ(ÃÌHƒì(ƒy,tƒy,tè2ÇèÔ72Àë°HƒÄ(ÃÌHƒì(ƒy,H‹Ñtƒy,tèì1Çè¥72Àë]ƒ¹|uRƒ¹xuIHcè
LˆLHJNHNÉM;Át*A‹H‹B I‰@ƒétƒét
ƒétƒùuœHƒB IƒÀëÑ°HƒÄ(ÃÌÌÌHƒì(ƒy,H‹Ñtƒy,tè`1Çè72Àë]ƒ¹|uRƒ¹xuIHcè
LˆLHJNHNÉM;Át*A‹H‹B I‰@ƒétƒét
ƒétƒùuœHƒB IƒÀëÑ°HƒÄ(ÃÌÌÌHƒì(ƒy,H‹Ñtƒy,tèÔ0Çè62Àë]ƒ¹|uRƒ¹xuIHcè
LˆLHJNHNÉM;Át*A‹H‹B I‰@ƒétƒét
ƒétƒùuœHƒB IƒÀëÑ°HƒÄ(ÃÌÌÌHƒì(ƒy,H‹Ñtƒy,tèH0Çè62Àë]ƒ¹|uRƒ¹xuIHcè
LˆLHJNHNÉM;Át*A‹H‹B I‰@ƒétƒét
ƒétƒùuœHƒB IƒÀëÑ°HƒÄ(ÃÌÌÌ°ÃÌ°ÃÌ°ÃÌ°ÃÌ@SHƒì0ƒ¹|…€ƒ¹xuwHcì
ƒøcvè—/ÇèP52ÀëYD‹A/Çè÷4ëÖ°HƒÄ0[ÃÌ@SHƒì0ƒ¹|…€ƒ¹xuwHcì
ƒøcvèû.Çè´42ÀëYD‹A°H‹L$@H3Ìè³æýÿH‹\$hH‹t$pHƒÄP_ÃÌÌÌH‰\$H‰t$WHƒìPH‹JÕH3ÄH‰D$@€yTH‹Ùtn‹AP…À~gH‹qH3ÿ…Àt~D·HT$4ƒd$0HL$0A¸Hvè~®…Àu1D‹D$0E…Àt'H‹CLK(H‹hH‰D$ HT$4èš	ÿÇ;{Pu«ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ èj	°H‹L$@H3ÌèÛåýÿH‹\$hH‹t$pHƒÄP_ÃÌÌÌH‰\$H‰t$WHƒìPH‹rÔH3ÄH‰D$@€yTH‹Ùtn‹AP…À~gH‹qH3ÿ…Àt~D·HT$4ƒd$0HL$0A¸Hv覭…Àu1D‹D$0E…Àt'H‹CLK(H‹hH‰D$ HT$4èÂÿÇ;{Pu«ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ è’°H‹L$@H3ÌèåýÿH‹\$hH‹t$pHƒÄP_ÃÌÌÌH‰\$H‰t$WHƒìPH‹šÓH3ÄH‰D$@€yTH‹Ùtn‹AP…À~gH‹qH3ÿ…Àt~D·HT$4ƒd$0HL$0A¸Hvèά…Àu1D‹D$0E…Àt'H‹CLK(H‹hH‰D$ HT$4èêÿÇ;{Pu«ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ 躰H‹L$@H3Ìè+äýÿH‹\$hH‹t$pHƒÄP_ÃÌÌÌH‰\$H‰l$VWAVHƒì0E3öH‹ÙD8qT…”‹AP…ÀŽ‰H‹qHA‹þL‹KHL$PfD‰t$PH‹ÖI‹Lc@èf¨Hcè…À~WH‹ƒhD·D$P‹HÁéöÁt
H‹ƒhL9pt H‹“hA·Èèr¹¹ÿÿf;ÁuƒK(ÿëÿC(HõÿÇH‹Å;{Pu†ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ èµH‹\$X°H‹l$`HƒÄ0A^_^ÃH‰\$H‰l$VWAVHƒì0E3öH‹ÙD8qT…”‹AP…ÀŽ‰H‹qHA‹þL‹KHL$PfD‰t$PH‹ÖI‹Lc@èz§Hcè…À~WH‹ƒhD·D$P‹HÁéöÁt
H‹ƒhL9pt H‹“hA·È膸¹ÿÿf;ÁuƒK(ÿëÿC(HõÿÇH‹Å;{Pu†ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ èÉH‹\$X°H‹l$`HƒÄ0A^_^ÃH‰\$H‰l$VWAVHƒì0E3öH‹ÙD8qT…”‹AP…ÀŽ‰H‹qHA‹þL‹KHL$PfD‰t$PH‹ÖI‹Lc@莦Hcè…À~WH‹ƒhD·D$P‹HÁéöÁt
H‹ƒhL9pt H‹“hA·Èèš·¹ÿÿf;ÁuƒK(ÿëÿC(HõÿÇH‹Å;{Pu†ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ èÝH‹\$X°H‹l$`HƒÄ0A^_^ÃH‰\$H‰l$H‰t$ WHƒì03íH‹Ù@8iT…’‹AP…ÀŽ‡H‹qH‹ýL‹KHL$@f‰l$@H‹ÖI‹Lc@裥HcÐ…À~WH‹‹hD·D$@H‹AH9Au@8itÿC(ë&ƒK(ÿë ÿC(HÿAH‹ƒhH‹fD‰H‹ƒhHƒHòÿÇH‹Â;{Pu‡ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ èºH‹\$H°H‹l$PH‹t$XHƒÄ0_ÃÌÌÌH‰\$H‰l$H‰t$ WHƒì03íH‹Ù@8iT…’‹AP…ÀŽ‡H‹qH‹ýL‹KHL$@f‰l$@H‹ÖI‹Lc@賤HcÐ…À~WH‹‹hD·D$@H‹AH9Au@8itÿC(ë&ƒK(ÿë ÿC(HÿAH‹ƒhH‹fD‰H‹ƒhHƒHòÿÇH‹Â;{Pu‡ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ èÊH‹\$H°H‹l$PH‹t$XHƒÄ0_ÃÌÌÌH‰\$H‰l$H‰t$ WHƒì03íH‹Ù@8iT…’‹AP…ÀŽ‡H‹qH‹ýL‹KHL$@f‰l$@H‹ÖI‹Lc@èãHcÐ…À~WH‹‹hD·D$@H‹AH9Au@8itÿC(ë&ƒK(ÿë ÿC(HÿAH‹ƒhH‹fD‰H‹ƒhHƒHòÿÇH‹Â;{Pu‡ë'ƒK(ÿë!H‹CLI(D‹CPHÁhH‹SHH‰D$ èÚH‹\$H°H‹l$PH‹t$XHƒÄ0_ÃÌÌÌH‰\$H‰l$H‰t$WAVAWHƒì H‹I‹ÙL‹òH‹ñD‹PAÁêAöÂtH‹HƒxuEé˜H‹|$`IcèHêD‹?ƒ'H;ÕtuH‹AŠ‹HÁéöÁt
H‹Hƒxt¾ÊH‹è¶ƒøÿu	ë	ÿ‹ƒøÿu5ƒ?*u8H‹‹HÁéöÁt
H‹HƒxtH‹¹?èеƒøÿu	ëÿIÿÆL;õu‹ƒ?uE…ÿtD‰?H‹\$@H‹l$HH‹t$PHƒÄ A_A^_ÃÌÌÌH‰\$H‰l$H‰t$ WAVAWHƒì H‹I‹ÙL‹òH‹ñD‹PAÁêAöÂtH‹HƒxuEé¬H‹|$`IcÀ‹/ƒ'Lƒ&H‹	H‹AH9Au€ytA)ëMAƒ	ÿëGH+AL‹õH‹	H;ÅLBðK6L‹Ãè9I‹$HI‹$LpI‹$€xt/ë
L;õtƒÿëD7ƒ>uE…ÿtD‰>H‹\$PH‹l$XH‹t$`HƒÄ A_A^A]A\_ÃÌH‹D¶ÁH‹B·A%€ÃÌÌÌ@UH‹ìHƒì`H‹E0H‰EÀL‰ML‰E(H‰UH‰M H…ÒuèÁÇèz"ƒÈÿëJM…ÀtæHEH‰UÈH‰EØLMÈHEH‰UÐH‰EàLEØHE H‰EèHUÐHE(H‰EðHM0HEÀH‰EøèÓ–þÿHƒÄ`]ÃÌ@UH‹ìHƒì`H‹E0H‰EÀL‰ML‰E(H‰UH‰M H…Òuè5Çèî!ƒÈÿëJM…ÀtæHEH‰UÈH‰EØLMÈHEH‰UÐH‰EàLEØHE H‰EèHUÐHE(H‰EðHM0HEÀH‰EøèG•þÿHƒÄ`]ÃÌ@UH‹ìHƒì`H‹E0H‰EÀL‰ML‰E(H‰UH‰M H…Òuè©Çèb!ƒÈÿëJM…ÀtæHEH‰UÈH‰EØLMÈHEH‰UÐH‰EàLEØHE H‰EèHUÐHE(H‰EðHM0HEÀH‰Eøè;•þÿHƒÄ`]ÃÌ@UH‹ìHƒì`H‹E0H‰EÀL‰ML‰E(H‰UH‰M H…ÒuèÇèÖ ƒÈÿëJM…ÀtæHEH‰UÈH‰EØLMÈHEH‰UÐH‰EàLEØHE H‰EèHUÐHE(H‰EðHM0HEÀH‰Eøèï”þÿHƒÄ`]ÃÌ@UH‹ìHƒì`H‹E0H‰EÀL‰ML‰E(H‰UH‰M H…Òuè‘ÇèJ ƒÈÿëJM…ÀtæHEH‰UÈH‰EØLMÈHEH‰UÐH‰EàLEØHE H‰EèHUÐHE(H‰EðHM0HEÀH‰Eøèã”þÿHƒÄ`]ÃÌ@UH‹ìHƒì`H‹E0H‰EÀL‰ML‰E(H‰UH‰M H…ÒuèÇ较ÈÿëJM…ÀtæHEH‰UÈH‰EØLMÈHEH‰UÐH‰EàLEØHE H‰EèHUÐHE(H‰EðHM0HEÀH‰EøèW“þÿHƒÄ`]ÃÌH‰\$H‰l$H‰t$WATAWHƒì0Hƒ|$pI‹éI‹ðH‹úL‹á„ýM…ÉuH…ÒuM…À…ê3Ûé÷H…Ò„ÚM…À„ÑHƒËÿM;ÁvQè:L‹L$pLEH‹×I‹Ì‹0H‹„$€H‰D$(H‹D$xH‰D$ 赚þÿƒøþuoèƒ8"…“èõ‰0é‡èéL‹L$pL‹ÆH‹×I‹ÌD‹8H‹„$€H‰D$(H‹D$xH‰D$ èdšþÿÆD7ÿƒøþuH;ëu訃8"u@èžD‰8ë6…Àyƃøþu*èˆÇ"èAë‹ØëèrÇè+HƒËÿH‹l$X‹ÃH‹\$PH‹t$`HƒÄ0A_A\_ÃH‹ÄH‰XH‰hH‰pH‰x ATAUAWHƒì0E3íI‹éI‹ðH‹úL‹áL9l$p„M…ÉuH…ÒuM…À…íA‹ÝéùH…Ò„ÜM…À„ÓHƒËÿM;ÁvQèÖL‹L$pLEH‹×I‹Ì‹0H‹„$€H‰D$(H‹D$xH‰D$ èùšþÿƒøþup蟃8"…•è‘‰0é‰è…L‹L$pL‹ÆH‹×I‹ÌD‹8H‹„$€H‰D$(H‹D$xH‰D$ 訚þÿfD‰lwþƒøþuH;ëuèCƒ8"uAè9D‰8ë7…ÀyfD‰/ƒøþu*è"Ç"èÛë‹ØëèÇèÅHƒËÿH‹l$X‹ÃH‹\$PH‹t$`H‹|$hHƒÄ0A_A]A\ÃH‰\$H‰t$ UWATAVAWH¬$ðûÿÿHìH‹tÃH3ÄH‰…E3äI‹ÙI‹øH‹òL‹ùM…Éuè‘ÇèJƒËÿé¨M…ÀtH…ÒtÞH‹•`HL$0èGƒþÿ3ÒHL$PDB èóìýÿM‹÷H‰t$PH‰|$XL‰d$`Aƒæu
Dˆd$hH…öuÆD$hHD$PL‹ËH‰D$pHT$pH‹…hHM€H‰D$(M‹ÇHD$8H‰D$ è\ìþÿHM€è«ÿÿHcØH…öu/H‹àèL‰¥àD8d$H„óH‹D$0ƒ ¨ýéâAöÇtMH…ÿu3…Àt/H‹àèÙL‰¥àD8d$H„ÿÿÿH‹D$0ƒ ¨ýéôþÿÿH‹D$`H;Çup…ÛxpH;ßvkë¼M…ötH…ÿt_…ÀyDˆ&ëVH‹D$`H;ÇuHDˆd7ÿëEH…ÿt“H‹D$`H;Çu2H‹àDˆd7ÿè]L‰¥àD8d$HtH‹D$0ƒ ¨ý»þÿÿÿë*Dˆ$0H‹àè,L‰¥àD8d$HtH‹L$0ƒ¡¨ý‹ÃH‹H3ÌèÅÒýÿLœ$I‹[0I‹sHI‹ãA_A^A\_]ÃÌH‰\$H‰t$ UWATAVAWH¬$€òÿÿHì€H‹@ÁH3ÄH‰…p
E3äI‹ÙI‹øH‹òL‹ùM…Éuè]ÇèƒËÿé¨M…ÀtH…ÒtÞH‹•Ð
HL$0èþÿ3ÒHL$PDB è¿êýÿM‹÷H‰t$PH‰|$XL‰d$`Aƒæu
Dˆd$hH…öuÆD$hHD$PL‹ËH‰D$pHT$pH‹…Ø
HM€H‰D$(M‹ÇHD$8H‰D$ èŒéþÿHM€èçÿÿHcØH…öu/H‹àèãL‰¥àD8d$H„óH‹D$0ƒ ¨ýéâAöÇtMH…ÿu3…Àt/H‹àè¥L‰¥àD8d$H„ÿÿÿH‹D$0ƒ ¨ýéôþÿÿH‹D$`H;Çup…ÛxpH;ßvkë¼M…ötH…ÿt_…ÀyDˆ&ëVH‹D$`H;ÇuHDˆd7ÿëEH…ÿt“H‹D$`H;Çu2H‹àDˆd7ÿè)L‰¥àD8d$HtH‹D$0ƒ ¨ý»þÿÿÿë*Dˆ$0H‹àèøL‰¥àD8d$HtH‹L$0ƒ¡¨ý‹ÃH‹p
H3Ìè‘ÐýÿLœ$€I‹[0I‹sHI‹ãA_A^A\_]ÃÌ@SHƒì0H‹ÚM…ÉtH‹ŠHHH‰B¨¨ßtGE…ÿEDùHÿÉH‰„Òt8tèîüÿÿÇè§A¹3ÒA‹ÄA÷÷D‹ÀOЀù	w!@¾ÏƒÁÐë;@Š9¸E…ÿDDøHAH‰ëÌGŸ<w	@¾ÏƒÁ©ëG¿<w	@¾ÏƒÁÉëA‹ÌA;Ìt-A;Ïs(EñA;ðru;ÊvAƒÎëA¯÷ñH‹@Š8HÿÀH‰ë‚HÿH‹@„ÿt@88tè?üÿÿÇèøAöÆu€}øL‰+„ûýÿÿH‹Eàƒ ¨ýéëýÿÿ‹ÖA‹Îèýÿÿ„ÀtjèþûÿÿÇ"AöÆuA‹ôë\AöÆt'€}øtH‹Eàƒ ¨ýH‹KH…ÉtH‹H‰¸€ëQ€}øtH‹Eàƒ ¨ýH‹KH…ÉtH‹H‰¸ÿÿÿë*AöÆt÷Þ€}øtH‹Màƒ¡¨ýH‹CH…ÀtH‹H‰‹ÆL\$@I‹[0I‹s@I‹{HI‹ãA_A^A]A\]ÃÌH‰\$H‰l$H‰t$ WATAUAVAWHƒìPE3íAŠñE‹øH‹úL9*u&èûÿÿÇè×H‹OH…ÉtH‹H‰3ÀécE…Àt	A@þƒø"wÌH‹ÑHL$(èÆgþÿL‹'E‹õL‰d$ ½A·$ID$ë
H‹·HƒÀ‹ÕH‰·Ëèó¨…Àuå@„öA‹í@•Åfƒû-uƒÍëfƒû+u
H‹·HƒÀH‰¾æ	Ç„$ˆjAƒÉÿ¹`Aº0A»ÿºð¸f
DF€A÷Çïÿÿÿ…fA;Ú‚Êfƒû:s·ÃA+Âé´fA;Ûƒ•f;Ù‚¦f;œ$ˆs
·Ã+Áéf;Ú‚‰¹úf;Ùs
·Ã+ÂépfA;Ø‚k¹p	f;Ùs·ÃA+ÀéQf;Þ‚M¹ð	f;Ùs
·Ã+Æé4f;Ø‚0¸p
f;Øs
·Ã-f
é¹æ
f;Ù‚A
f;Ø‚cÿÿÿHvf;Ù‚óA
f;Ø‚Kÿÿÿ¹ff;Ù‚ÙA
f;Ø‚1ÿÿÿHvf;Ù‚ÁA
f;Ø‚ÿÿÿHvf;Ù‚©A
f;Ø‚ÿÿÿ¹Pf;Ù‚A
f;Ø‚çþÿÿHvf;Ùr{A
f;Ø‚ÓþÿÿHFf;ÙrgA
f;Ø‚¿þÿÿ¹@f;ÙrQA
f;Ø‚©þÿÿ¹àf;Ùr;A
f;Ø‚“þÿÿH&f;Ùr'A
f;Øsé~þÿÿ¸ÿf;Øs·ÃA+ÃëƒÈÿƒøÿu)C¿fƒøvCŸfƒøvA‹ÁëCŸfƒø·Ãwƒè ƒÀɾ…ÀtE…ÿuyD~ësH‹A¸ßÿ·HHH‰B¨fA…Àt:E…ÿDDþHƒÁþH‰f…ÒtDf9t?èù÷ÿÿÇè²ýAƒÉÿAº0A»ÿë·¸E…ÿDDøHAH‰ë¾3ÒA‹ÁA÷÷A½`A¼ðD‹ÀfA;Ú‚®fƒû:s·ËA+Êé˜fA;ÛƒyfA;Ý‚‰¸jf;Øs·ËA+ÍéofA;Ü‚j¸úf;Øs·ËA+ÌéP¸f	f;Ø‚GH
f;Ùs
·Ë+Èé0¸æ	f;Ø‚'H
f;ÙràAvf;Ø‚H
f;ÙrÌAvf;Ø‚ÿH
f;Ùr¸Avf;Ø‚ëH
f;Ùr¤¸ff;Ø‚ÕH
f;ÙrŽAvf;Ø‚ÁH
f;Ù‚vÿÿÿAvf;Ø‚©H
f;Ù‚^ÿÿÿ¸Pf;Ø‚H
f;Ù‚DÿÿÿAvf;Ør{H
f;Ù‚0ÿÿÿAFf;ØrgH
f;Ù‚ÿÿÿ¸@f;ØrQH
f;Ù‚ÿÿÿ¸àf;Ør;H
f;Ù‚ðþÿÿA&f;Ør'H
f;ÙséÛþÿÿ¸ÿf;Øs·ËA+ËëƒÉÿƒùÿu)C¿fƒøvCŸfƒøvA‹ÉëCŸ·Ëfƒøwƒé ƒÁÉA;Ét0A;Ïs+îE;ðru;ÊvƒÍëE¯÷DñH‹·HƒÀH‰éêýÿÿHƒþE3íH‹L‹d$ f…Ûtf9tètõÿÿÇè-û@„îuL‰'D8l$@„CúÿÿH‹D$(ƒ ¨ýé2úÿÿA‹Ö‹ÍèKöÿÿ„Àtoè2õÿÿÇ"@öÅuAƒÎÿëa@öÅt)D8l$@tH‹D$(ƒ ¨ýH‹OH…ÉtH‹H‰¸€ëWD8l$@tH‹D$(ƒ ¨ýH‹OH…ÉtH‹H‰¸ÿÿÿë.@öÅtA÷ÞD8l$@tH‹L$(ƒ¡¨ýH‹WH…ÒtH‹H‰
A‹ÆL\$PI‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃH‰\$H‰t$H‰|$ UATAUAVAWH‹ìHƒì@Hƒ:EŠáE‹øH‹Úu&èIôÿÿÇèúH‹KH…ÉtH‹H‰3ÀéÁE…Àt	A@þƒø"wÌH‹ÑHMàèò`þÿL‹+E3öH‹UèL‰m8AŠ}IEEnH‰ƒz@¶Ç~LEèA‹Õ‹Èè±¢H‹Uèë
H‹ÈH‹·HA#Å…ÀtH‹@Š8HÿÀëÃ3öE„ä@•Æ@€ÿ-uƒÎë@€ÿ+uH‹@Š8HÿÀH‰L‹m8A÷Çïÿÿÿ…€GÐ<	w	@¾ÇƒÀÐë#GŸ<w	@¾ÇƒÀ©ëG¿<w	@¾ÇƒÀÉëƒÈÿA»…ÀtE…ÿuDE{ë>H‹ŠHHH‰B¨¨ßtOE…ÿEDûHÿÉH‰„Òt8tèóÿÿÇèÄøA»IƒÌÿMc×I‹Ä3ÒI÷òL‹ÈOЀù	w"D¾ÇAƒÀÐë>@Š9¸E…ÿDDøHAH‰ëÄGŸ<w
D¾ÇAƒÀ©ëG¿<w
D¾ÇAƒÀÉëAƒÈÿAƒøÿt:E;Çs5AóM;ñruA‹ÀH;ÂvƒÎë
I‹ÊI¯ÎE‹ðLñH‹@Š8HÿÀH‰épÿÿÿL#H‹@„ÿt@88tèCòÿÿÇèü÷@öÆu€}øL‰+„çýÿÿH‹Eàƒ ¨ýé×ýÿÿI‹Ö‹ÎèGóÿÿ„ÀttèòÿÿÇ"@öÆuM‹ôëg@öÆt,€}øtH‹Eàƒ ¨ýH‹KH…ÉtH‹H‰H¸€ëX€}øtH‹Eàƒ ¨ýH‹KH…ÉtH‹H‰H¸ÿÿÿÿÿÿÿë,@öÆtI÷Þ€}øtH‹Màƒ¡¨ýH‹CH…ÀtH‹H‰I‹ÆL\$@I‹[0I‹s@I‹{HI‹ãA_A^A]A\]ÃÌH‰\$H‰l$H‰t$ WATAUAVAWHì E3íAŠñE‹øH‹úL9*u&èñÿÿÇèÌöH‹OH…ÉtH‹H‰3ÀéAE…Àt	A@þƒø"wÌH‹ÑHL$xè»]þÿL‹'M‹õL‰¤$˜½A·$ID$ë
H‹·HƒÀ‹ÕH‰·Ëèåž…Àuå@„öA‹í@•Åfƒû-uƒÍëfƒû+u
H‹·HƒÀH‰ÇD$tj¾f
Ç„$Øð
¹0ÇD$Pfº`ÇD$(pA»ÿÇD$hfDV€ÇD$0p¸æ
ÇD$XæA¸ðÇD$8ðA¹f	ÇD$pf
ÇD$@p
ÇD$`PÇD$HZÇD$lÐÇD$ ÚÇD$$ ÇD$,*ÇD$4@ÇD$ÿÿÿ‹D$lf;Ørvf;\$ ‚*ÿÿÿ‹D$$f;Ørbf;\$,‚ÿÿÿ‹D$4f;ØrNf;\$<‚ÿÿÿ‹D$Df;Ør:f;\$L‚îþÿÿ‹D$Tf;Ør&f;\$\séÙþÿÿf;\$ds	D·ÃE+ÃëAƒÈÿAƒøÿu-C¿fƒøvCŸfƒøvAƒÈÿëCŸD·ÃfƒøwAƒè AƒÀÉAƒøÿt?E;Çs:îM;ñruA‹ÀH;ÂvƒÍëI‹ÊI¯ÎE‹ðLñ¹0H‹·HƒÀH‰é±ýÿÿHƒþE3íH‹L‹¤$˜f…Ûtf9tè¡êÿÿÇèZð@„îu"L‰'D8¬$„xùÿÿH‹D$xƒ ¨ýégùÿÿI‹Ö‹Íè¡ëÿÿ„Àtè\êÿÿÇ"@öÅuIƒÎÿëq@öÅt1D8¬$tH‹D$xƒ ¨ýH‹OH…ÉtH‹H‰H¸€ëbD8¬$tH‹D$xƒ ¨ýH‹OH…ÉtH‹H‰H¸ÿÿÿÿÿÿÿë1@öÅtI÷ÞD8¬$tH‹L$xƒ¡¨ýH‹WH…ÒtH‹H‰
I‹ÆLœ$ I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èäêÿÿH‹ÐA±D‹ÃH‹ÏèûêÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è¼êÿÿH‹ÐA±D‹ÃH‹ÏèÓíÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èlêÿÿH‹ÐE3ÉD‹ÃH‹ÏèƒêÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èDêÿÿH‹ÐE3ÉD‹ÃH‹Ïè[íÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èôéÿÿH‹ÐA±D‹ÃH‹ÏèóóÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èÌéÿÿH‹ÐA±D‹ÃH‹ÏèëöÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è|éÿÿH‹ÐE3ÉD‹ÃH‹Ïè{óÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èTéÿÿH‹ÐE3ÉD‹ÃH‹ÏèsöÿÿH‹\$@HƒÄ0_ÃH‰L‰AM…ÀtI‰H‹ÁÃÌH‰L‰AM…ÀtI‰H‹ÁÃÌH‹QH…ÒtH‹H‰ÃH‹QH…ÒtH‹H‰ÃH‹ŠHÿÂH‰ÃH‹·HƒÂH‰ÃÌÌH‰\$WHƒì ¶ùH…Òt&H‹ƒx~L‹Â‹Ïºèú•ëH‹HcÏ·Hë	è•·xƒàH‹\$0…À•ÀHƒÄ _ÃHƒì(ºè.•…À•ÀHƒÄ(øÿÿÿÃÌÌH¸ÿÿÿÿÿÿÿÃ̸€ÃÌÌH¸€ÃÌAÐ<	w¾Áƒè0ÃAŸ<w¾ÁƒèWÃA¿<w¾Áƒè7ÃÈÿÃÌ̺0f;Ê‚Ÿfƒù:s
·Á+Â銺ÿf;ʃkº`f;Ê‚sB
f;ÈrÒºðf;Ê‚]B
f;Èr¼ºf	f;Ê‚GB
f;Èr¦Pvf;Ê‚3B
f;Èr’Pvf;Ê‚B
f;È‚zÿÿÿPvf;Ê‚B
f;È‚bÿÿÿPvf;Ê‚ïB
f;È‚Jÿÿÿºff;Ê‚ÕB
f;È‚0ÿÿÿPvf;Ê‚½B
f;È‚ÿÿÿPvf;Ê‚¥B
f;È‚ÿÿÿºPf;Ê‚‹B
f;È‚æþÿÿPvf;ÊrwB
f;È‚ÒþÿÿPFf;ÊrcB
f;È‚¾þÿÿº@f;ÊrMB
f;È‚¨þÿÿºàf;Êr7B
f;È‚’þÿÿP&f;Êr#B
f;Èsé}þÿÿ¸ÿf;È‚oþÿÿƒÈÿƒøÿu(A¿fƒøv
AŸfƒøvƒÈÿÃAŸfƒø·Áwƒè ƒÀÉÃÌÌH‰°ÃÌÌH‰°ÃÌÌH‹ÃH‹ÃHƒì(Hÿ	H‹„Òt8tèäÿÿÇè:êHƒÄ(ÃÌHƒì(HƒþH‹f…Òtf9tèVäÿÿÇèêHƒÄ(ÃÌÌHƒì(Hƒ9uè5äÿÿÇèîé2Àë°HƒÄ(ÃÌÌÌHƒì(Hƒ9uè
äÿÿÇèÆé2Àë°HƒÄ(ÃÌÌ̺0f;Ê‚ƒfƒù:s·Á+Âúÿf;ʃ[º`f;Ê‚[B
f;ÈrÖºðf;Ê‚EB
f;ÈrÀºf	f;Ê‚/B
f;ÈrªPvf;Ê‚B
f;Èr–Pvf;Ê‚B
f;Èr‚Pvf;Ê‚óB
f;È‚jÿÿÿPvf;Ê‚ÛB
f;È‚Rÿÿÿºff;Ê‚ÁB
f;È‚8ÿÿÿPvf;Ê‚©B
f;È‚ ÿÿÿPvf;Ê‚‘B
f;È‚ÿÿÿºPf;Êr{B
f;È‚òþÿÿPvf;ÊrgB
f;È‚ÞþÿÿPFf;ÊrSB
f;È‚Êþÿÿº@f;Êr=B
f;È‚´þÿÿºàf;Êr'B
f;È‚žþÿÿP&f;ÊrB
ë¸ÿf;È‚ƒþÿÿƒÈÿÃÌÌÌH‹ÃH‰\$WHƒì Hcù‹ÚM…ÀtI‹H‹·y#Âëè5·x#ÃH‹\$0HƒÄ _ÃH‰\$WHƒì Hcù‹ÚM…ÀtI‹ƒx~	‹ÏèÔëH‹·x#Âëèî·x#ÃH‹\$0HƒÄ _ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ è3ãÿÿH‹ÐA±D‹Ã3Éè3íÿÿHƒÄ0[ÃÌH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èüâÿÿH‹ÐA±D‹ÃH‹ÏèûìÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èÀâÿÿH‹ÐA±D‹ÃH‹Ïè¿ìÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è„âÿÿH‹ÐA±D‹ÃH‹Ïè›âÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èHâÿÿH‹ÐA±D‹ÃH‹ÏèGìÿÿH‹\$@HƒÄ0_Ã@SHƒì0A‹ØL‹ÂH‹ÑHL$ èâÿÿH‹ÐE3ÉD‹Ã3ÉèìÿÿHƒÄ0[ÃÌH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èÜáÿÿH‹ÐE3ÉD‹ÃH‹ÏèÛëÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è áÿÿH‹ÐE3ÉD‹ÃH‹Ïè·áÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èdáÿÿH‹ÐE3ÉD‹ÃH‹ÏècëÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è(áÿÿH‹ÐE3ÉD‹ÃH‹Ïè'ëÿÿH‹\$@HƒÄ0_Ã@SHƒì0A‹ØL‹ÂH‹ÑHL$ èáÿÿH‹ÐA±D‹Ã3Éè'îÿÿHƒÄ0[ÃÌH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èÐàÿÿH‹ÐA±D‹ÃH‹ÏèïíÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è”àÿÿH‹ÐA±D‹ÃH‹Ïè³íÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èXàÿÿH‹ÐA±D‹ÃH‹ÏèoãÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èàÿÿH‹ÐA±D‹ÃH‹Ïè;íÿÿH‹\$@HƒÄ0_Ã@SHƒì0A‹ØL‹ÂH‹ÑHL$ èçßÿÿH‹ÐE3ÉD‹Ã3ÉèíÿÿHƒÄ0[ÃÌH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è°ßÿÿH‹ÐE3ÉD‹ÃH‹ÏèÏìÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ ètßÿÿH‹ÐE3ÉD‹ÃH‹Ïè‹âÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ è8ßÿÿH‹ÐE3ÉD‹ÃH‹ÏèWìÿÿH‹\$@HƒÄ0_ÃH‰\$WHƒì0A‹ØI‹ùL‹ÂH‹ÑHL$ èüÞÿÿH‹ÐE3ÉD‹ÃH‹ÏèìÿÿH‹\$@HƒÄ0_Ã@SHƒì0A‹ØL‹ÂH‹ÑHL$ è³ÞÿÿH‹ÐA±D‹Ã3Éè³èÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èƒÞÿÿH‹ÐA±D‹Ã3Éè›ÞÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èSÞÿÿH‹ÐA±D‹Ã3ÉèSèÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ è#ÞÿÿH‹ÐE3ÉD‹Ã3Éè;ÞÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èóÝÿÿH‹ÐE3ÉD‹Ã3ÉèóçÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èÃÝÿÿH‹ÐE3ÉD‹Ã3ÉèÃçÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ è§ÝÿÿH‹ÐA±D‹Ã3ÉèÇêÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èwÝÿÿH‹ÐA±D‹Ã3ÉèàÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èGÝÿÿH‹ÐA±D‹Ã3ÉègêÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èÝÿÿH‹ÐE3ÉD‹Ã3Éè/àÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ èçÜÿÿH‹ÐE3ÉD‹Ã3ÉèêÿÿHƒÄ0[ÃÌ@SHƒì0A‹ØL‹ÂH‹ÑHL$ è·ÜÿÿH‹ÐE3ÉD‹Ã3Éè×éÿÿHƒÄ0[ÃÌ@SHƒì 3ÀH‹ÙHL$0H‰D$0Pè_‹T$0ƒÉÿƒøEÑH…Ût‰‹ÂHƒÄ [ÃÌÌÌ@SHƒì03ÀH‹ÙHL$ H‰D$ Pè³H‹T$ HƒÉÿƒøHEÑH…ÛtH‰H‹ÂHƒÄ0[ÃÌÌ@SHƒì H‹ÙH…Éuè‰ÚÿÿÇèBà3Àëfƒúu÷3ÀHL$0H‰D$0è0ýL‹D$0H¹€Á*!NbþLÁH¸½BzåÕ”¿ÖI÷èIÐHÁúH‹ÂHÁè?HÐHúÒÿ­iÊ€–˜¸‰D+ÁAkÈd‰KHƒÄ [ÃÌÌ@SHƒì H‹ÙH…ÉuèùÙÿÿÇè²ß3Àëmƒúu÷3ÀHL$0H‰D$0è üL‹D$0H¹€Á*!NbþLÁH¸½BzåÕ”¿ÖI÷èIÐHÁúH‹ÂHÁè?HÐH¸ÿo@“H;ЧiÊ€–˜¸H‰D+ÁAkÈd‰KHƒÄ [ÃÌÌÌ@SHƒì 3ÀH‹ÙHL$0H‰D$0Pè»þÿÿ‹T$0ƒÉÿƒøEÑH…Ût‰‹ÂHƒÄ [ÃÌÌÌ@SHƒì03ÀH‹ÙHL$ H‰D$ PèÿÿÿH‹T$ HƒÉÿƒøHEÑH…ÛtH‰H‹ÂHƒÄ0[ÃÌÌéWþÿÿÌÌÌéßþÿÿÌÌÌH‰\$H‰t$WHƒì H‹ùèU3öH‹ØH…ÀtH‹×H‹Èèd…ÀHEÞH‹ÃH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì H‹ùè
3öH‹ØH…ÀtH‹×H‹Èèø…ÀHEÞH‹ÃH‹\$0H‹t$8HƒÄ _ÃÌÌÌ@USWH‹ìHƒì@H‹úH‹ÙH…Éuè=Øÿÿ»‰èõÝ‹ÃHƒÄ@_[]úÿA¸$è·®ýÿH…ÿtЃ?}èØÿÿ»‰ëÎ?Òÿêèn›ƒe8HM8ƒeðƒe0è}ˆ…À…AHMð蜈…À…HM0軈…À…ó‹üÿ=}é÷wY+M0HU ‰M H‹Ë誅À…[ÿÿÿ9E8„mH‹Ëè1›…À„]‹EðHU )E H‹Ëèw…À…(ÿÿÿÇC é7H‹×H‹ËèX…À…	ÿÿÿ‹;9E8tH‹Ëèáš…Àt‹MðM0+ùÇC ë+}0A¸‰ˆˆˆ‹ÏA‹À÷ï×Áú‹ÂÁèÐkÂ<+ȉyA<ƒï<‰A‹À÷ïDAÁùA‹ÁÁèDÈA‹ÀDKA÷éAÑÁú‹ÂÁèÐkʘ…À„…HcE8HUðH)EðH‹ËèÒŒ…À…ÿÿÿÇC é]H‹×H‹Ë賌…À…ðþÿÿHc;9E0tH‹Ëèë—…Àt‹E E8H˜ÇC ëHcE H+øI¸‰ˆˆˆˆˆˆˆI‹À‹ÏH÷ïH×HÁúH‹ÂHÁè?HÐkÂ<+ȉy	AA´HÿCH‹CH9{tH;CwH‹3H‹èUSƒøÿtHÿFŠÐˆEP<0uëÍ@Š×ˆUP‹ÏŠE`L‹}ØöØEöAƒæAƒÆ	BÐ<	w¾Âƒè0ë!BŸ<w¾ÂƒèWëB¿<w¾Âƒè7ëƒÈÿA;ÆwKA´M;ïtAˆEIÿÅHÿCÿÁH‹C‰MÈH9{tH;CwH‹3H‹è½R‹MȃøÿtHÿFë@ŠÇŠÐˆEPë€L‹}HI‹H‹ˆøH‹:…ûHÿCH‹CH9{tH;CwH‹3H‹èmRƒøÿtHÿFë@ŠÇH‹MXŠÐHƒÁˆEPL;éuC<0u?A´HÿCÿMÈH‹CH9{tH;CwH‹3H‹è$RƒøÿtHÿFŠÐˆEP<0uëÊ@Š×ˆUPBÐ<	w¾Âƒè0ë!BŸ<w¾ÂƒèWëB¿<w¾Âƒè7ëƒÈÿA;ÆwDA´L;mØtAˆEIÿÅHÿCH‹CH9{tH;CwH‹3H‹è¦QƒøÿtHÿFë@ŠÇŠÐˆEPë‡E„äu!HMàèׄ„À„ýûÿÿö]`ÀƒàûƒÀé`HÿKH‹CH9{tH;CwB<v¾ÊH‹ƒùÿtHÿJH‹è=}H‹CH‰EÐHÿÀH‰CH9{tH;CwH‹3H‹èQ‹ÈƒøÿtHÿFë@ŠÏˆMP@ŠÇ€ùEt€ùPt
€ùet
€ùpuŠE`ë@8}`”ÀD‹÷„À„ðHÿCH‹CH9{tH;CwH‹3H‹è³PƒøÿtHÿFë@ŠÇ<-ˆEPŠÈA”Ä,+¨ýu2HÿCH‹CH9{tH;CwH‹3H‹èuPƒøÿtHÿFë@ŠÇŠÈˆEPDŠÿ€ù0uk„À„rùÿÿHÿCH‹CH9{tH;CwH‹H‹BH;Bt¾HÿÀH‰Bƒùÿu@ŠÏˆMHHÿKH‹CH9{tH;CwþÁ€ùvH‹H‹AH;tHÿÈH‰AL;ÞtfICÿ@88uL‹ØH;ÆuïL;ÞtPE;Ö~¸	ëmº°ëÿÿD;Ò}¸ë\AŠÇöØɃáÿÁA¯ÌDÑE;ÖÐD;Ò|ÜD+ÞE‰UE„ÿE‰]@•Ç‹Çë)¸ë"L‹EXHMHH‹Óè$ëL‹EXHMHH‹ÓèÞH‹œ$€HƒÄ@A_A^A]A\_^]ÃÌÌL‰D$H‰L$USVWATAUAVAWH‹ìHƒìhL‹
3ÿM‹èH‹ÚM…ÉtH9zu謘ÿÿÇèež¸é›H‹BA¼ÿÿH‰EÈHÿÀH‰BH9ztH;Bv·ÏëI‹AI;At·HƒÀI‰AfA;Ìu‹ÏHE¼H‰UØH‰EàA¿HEÈf‰M¼A‹×H‰EèèrFEwùëELsH‹CH9{tH;Cv·Ïë H‹H‹BH;Bt·HƒÀH‰BfA;Ìu‹ÏA‹×f‰M¼è'F…Àu··U¼Mfƒú-A¸ýÿ”ÀAˆBÕfA…Àu=LsH‹CH9{t
H;Cv‹×ë!H‹H‹AH;At·HƒÀH‰AfA;Ôu·×f‰U¼B·AºßÿfA…„_B²fA…„@¹0@ˆ}PDŠÿf;Ñ…ÙL‹KIAH‰CH9{tH;Cv·ÏéƒL‹I‹@I;@tn·HƒÀI‰@fA;ÌtYA¨fA…ÂuJLsEŠþH‹CDˆuPH9{tH;Cv·×ë H‹H‹AH;At·HƒÀH‰AfA;Ôu‹×f‰U¼L‰MÈëH·U¼ë·U¼‹ÏA¸ýÿHÿKH‹CH9{tH;Cw"fA+ÎfA;ÈwH‹H‹AH;tHƒÀþH‰A·U¼MeA¸0L‰eЋωMÀM‹ôDŠÏfA;ÐucA@ÑAºÿÿDŠÈHCH‹CH9{tH;Cw9H‹H‹AH;At,D·HƒÀH‰AfE;Ât¸0A·Ðf‰U¼fD;Àu¸ë³·×f‰U¼‹ÏAŠÇÇE`jöØA¸¾ÿA¿`EÒA½ÿÿAƒâAƒÂ	E`/¸ðfA;Ô‚\fƒú:s·ÂA+ÄéFf;Öƒ)fA;ׂ8f;U`s·ÂA+Çé"f;Ђ¸úf;Ðs
·Â-ðé¸f	f;Ђù¸p	f;Ðs
·Â-f	éݸæ	f;ЂԸð	f;Ðs
·Â-æ	鸸f
f;Ђ¯¸p
f;Ðs
·Â-f
铸æ
f;ЂŠ¸ð
f;Ðs
·Â-æ
én¸ff;Ђe¸pf;Ðs
·Â-féI¸ff;Ђ@¸pf;Ðs
·Â-fé$¸æf;Ђ¸ðf;Ðs
·Â-æéÿ¸f
f;Ђö¸p
f;Ðs
·Â-f
éÚ¸Pf;ЂѸZf;Ðs
·Â-P鵸Ðf;Ђ¬¸Úf;Ðs
·Â-Ðé¸ f;Ђ‡¸*f;Ðs
·Â- ën¸@f;Ðri¸Jf;Ðs
·Â-@ëP¸àf;ÐrK¸êf;Ðs
·Â-àë2¸f;Ðr-¸f;Ðs#·Â-ë¸ÿf;Ðs·Â+ÆëƒÈÿƒøÿu)B¿fƒøvBŸfƒøvƒÈÿëBŸfƒø·Âwƒè ƒÀÉA;ÂwYEŠÈM;ótAˆMðLCAÈH‹C‰MÀH9{tH;Cv·×ë#H‹H‹AH;At·HƒÀH‰AfA;Õu‹×‹MÀf‰U¼éýÿÿH‹uHL‹mXDŠ}PL‰uÐH‹MeH‹ˆøH‹¾·Â;Á…LCH‹CH9{tH;Cv·Ïë$H‹H‹BH;Bt·HƒÀH‰B¸ÿÿf;Èu‹Ïf‰M¼·Ñ¸0M;ôunf;Èui‹uÀEŠÈLCA+ðH‹C‰uÀH9{tH;Cw=H‹H‹AH;At0D·HƒÀH‰A¸ÿÿfD;Àt¸0A·Ðf‰U¼fD;ÀuD@Ñ멷׸0f‰U¼¾`A¼A½ÿÿA¿ÿf;Ђ¥fƒú:s·Âƒè0éfA;׃pf;Ö‚¸jf;Ðs
·Â+Æéh¹ðf;Ñ‚_A
f;Ðs
·Â+ÁéH¹f	f;Ñ‚?A
f;ÐràHvf;Ñ‚+A
f;ÐrÌHvf;Ñ‚A
f;Ðr¸Hvf;Ñ‚A
f;Ðr¤Hvf;Ñ‚ïA
f;Ðr¹ff;Ñ‚ÙA
f;ЂvÿÿÿHvf;Ñ‚ÁA
f;Ђ^ÿÿÿHvf;Ñ‚©A
f;ЂFÿÿÿ¹Pf;Ñ‚A
f;Ђ,ÿÿÿHvf;Ñr{A
f;ЂÿÿÿHFf;ÑrgA
f;Ђÿÿÿ¹@f;ÑrQA
f;Ђîþÿÿ¹àf;Ñr;A
f;ЂØþÿÿH&f;Ñr'A
f;ÐséÃþÿÿ¸ÿf;Ðs·ÂA+ÇëƒÈÿƒøÿu)B¿fƒøvBŸfƒøvƒÈÿëBŸfƒø·Âwƒè ƒÀÉA;ÂwUEŠÌM;ótAˆMôLcH‹CH9{tH;Cv·×ë H‹H‹AH;At·HƒÀH‰AfA;Õu‹×f‰U¼¸0éÏýÿÿL‹mXDŠ}PL‰uÐMe‹uÀE„Éu!HMØèÆc„À„ÍöÿÿAößÀƒàûƒÀébHÿKH‹CH9{tH;Cw*A¸¸ýÿfA+Ðf;ÐwH‹H‹AH;tHƒÀþH‰AëA¸H‹CH‰EÈHÿÀH‰CH9{tH;Cv·Ïë$H‹H‹BH;Bt·HƒÀH‰B¸ÿÿf;Èu‹Ï·Á@Š×f‰M¼ƒøEtƒøPt
ƒøet
ƒøpuAŠ×ëE„ÿ”‰}ÄD‹×A»P„Ò„ÍLCH‹CH9{tH;Cv·×ë$H‹H‹AH;At·HƒÀH‰A¸ÿÿf;Ðu‹×fƒú-f‰U¼·Ê¸ýÿA”Áfƒê+DˆM¸f…ÐuALCH‹CH9{tH;Cv·Ïë$H‹H‹BH;Bt·HƒÀH‰B¸ÿÿf;Èu‹Ïf‰M¼¸0@ˆ}`f;Èue¸ˆE`HCH‹CH9{tH;Cw:H‹H‹AH;At-·HƒÀH‰A¸ÿÿf;Ðt¸0f‰U¼·Êf;Ðu¸ë²·Ïf‰M¼¸0f;È‚Ÿfƒù:s
·Ñ+Ð銸ÿf;ȃk¸`f;È‚sP
f;ÊrÒ¸ðf;È‚]P
f;Êr¼¸f	f;È‚GP
f;Êr¦Bvf;È‚3P
f;Êr’Bvf;È‚P
f;Ê‚zÿÿÿBvf;È‚P
f;Ê‚bÿÿÿBvf;È‚ïP
f;Ê‚Jÿÿÿ¸ff;È‚ÕP
f;Ê‚0ÿÿÿBvf;È‚½P
f;Ê‚ÿÿÿBvf;È‚¥P
f;Ê‚ÿÿÿ¸Pf;È‚‹P
f;Ê‚æþÿÿBvf;ÈrwP
f;Ê‚ÒþÿÿBFf;ÈrcP
f;Ê‚¾þÿÿ¸@f;ÈrMP
f;Ê‚¨þÿÿ¸àf;Èr7P
f;Ê‚’þÿÿB&f;Èr#P
f;Êsé}þÿÿºÿf;Ê‚oþÿÿƒÊÿƒúÿu)A¿fƒøvAŸfƒøvƒÊÿëAŸ·Ñfƒøwƒê ƒÂɃú
sdC’ÆE`DBD‰UÄE;ÓEHÿCH‹CH9{t
H;C‡ñýÿÿH‹H‹BH;Bt·HƒÀH‰B¸ÿÿf;È…Îýÿÿ‹ÏéÇýÿÿAºQD‰Uĺ0¾ðA»ÿÿA½ÿA¼`A¿f	A¹æ	A¸f
Aºæ
A¾ff;Ê‚@fƒù:s
·Á+Âé+fA;̓fA;Ì‚¸jf;Ès·ÁA+Äéf;΂þ¸úf;Ès
·Á+ÆéåfA;Ï‚à¸p	f;Ès·ÁA+ÇéÆfA;É‚Á¸ð	f;Ès·ÁA+Áé§fA;È‚¢¸p
f;Ès·ÁA+ÀéˆfA;Ê‚ƒ¸ð
f;Ès·ÁA+ÂéifA;΂d¸pf;Ès·ÁA+ÆéJ¸ff;È‚A¸pf;Ès
·Á-fé%¸æf;È‚¸ðf;Ès
·Á-æé¸f
f;È‚÷¸p
f;Ès
·Á-f
éÛ¸Pf;È‚Ò¸Zf;Ès
·Á-P鶸Ðf;È‚­¸Úf;Ès
·Á-Ð鑸 f;È‚ˆ¸*f;Ès
·Á- ëo¸@f;Èrj¸Jf;Ès
·Á-@ëQ¸àf;ÈrL¸êf;Ès
·Á-àë3¸f;Èr.¸f;Ès$·Á-ë¸ÿf;Ès·ÁA+ÅëƒÈÿƒøÿu)A¿fƒøvAŸfƒøvƒÈÿëAŸfƒø·Áwƒè ƒÀɃø
sGHÿCH‹CH9{tH;Cv·Ïë%H‹H‹BH;Bt·HƒÀH‰BfA;Ëu‹Ïº0f‰M¼éBýÿÿL‹mXA»PDŠM¸D‹UÄDŠE`L‹uÐMeDŠ}P‹uÀE„ÉtA÷ÚE„ÀuZHMØèm\„À„tïÿÿA¸LCH‹CH9{tH;Cv·Ïë$H‹H‹BH;Bt·HƒÀH‰B¸ÿÿf;Èu‹Ïf‰M¼ëA¸HÿKH‹CH9{tH;Cw"fA+ȸýÿf;ÈwH‹H‹AH;tHƒÀþH‰AM;ôtfIFÿ@88uL‹ðI;ÄuïM;ôtPE;Ó~¸	ëmº°ëÿÿD;Ò}¸ë\AŠÇöØɃáAȯÎDÑE;ÓÐD;Ò|ÜE+ôE‰UE„ÿE‰u@•Ç‹Çë)¸ë"L‹EÈHM¼H‹ÓèFëL‹EÈHM¼H‹Óè˜HƒÄhA_A^A]A\_^[]ÃÌÌÌL‹ÜI‰[I‰sM‰CWATAVHƒì@ICI‰SÈI‰CØL%}³üÿH‹ÚI‰KÐL‹ñ3ÿAŠB:„'È$tB:„'Ì$…¡HÿCHƒ{H‹CtH;CwH‹3H‹èö!‹ÈƒøÿtHÿFë2ÉHÿÇAˆHƒÿuªHÿKHƒ{H‹CtH;CwA<vH‹¾ÉƒùÿtHÿJH‹è¬MH‹CH‰D$pHÿÀHƒ{H‰CtH;Cw*H‹;H‹è€!ƒøÿtHÿGëHL$ è»Y¸é•2ÀAˆ3ÿAŠB:„'Ð$tB:„'Ø$…‡HÿCHƒ{H‹CtH;CwH‹3H‹è!‹ÈƒøÿtHÿFë2ÉHÿÇAˆHƒÿuªHÿKHƒ{H‹CtH;CwA<vH‹¾ÉƒùÿtHÿJH‹èÕL¸H‹\$`H‹t$hHƒÄ@A^A\_ÃHL$ èþXöØÀƒàüƒÀëÖÌÌL‹ÜM‰CSHƒì@ICI‰SØI‰CèHÁ±üÿI‰KàL‹ÑE3ÛE‹ÃAŠA:„$%tA:„(%…AHÿBH‹BL9ZtH;BwL‹
I‹AI;At¾HÿÀI‰AƒùÿuAŠËIÿÀAˆ
Iƒøu¦HÿJH‹BL9ZtH;BwþÁ€ùvH‹
H‹AH;tHÿÈH‰AH‹BH‰D$`HÿÀH‰BL9ZtH;BwL‹I‹@I;@t¾HÿÀI‰@ƒùÿuAŠËAˆ
M‹ÃAŠA:„,%tA:„4%…‰HÿBH‹BL9ZtH;BwL‹
I‹AI;At¾HÿÀI‰AƒùÿuAŠËIÿÀAˆ
Iƒøu¦HÿJH‹BL9ZtH;BwþÁ€ùvL‹I‹HI;tHÿÉI‰H¸HƒÄ@[ÃHL$ èJX¸ëéHL$ è9XöØÀƒàüƒÀëÓÌL‹ÜI‰[I‰kI‰s M‰CWATAUAVAWHƒì@3íI‰S¸ICI‰KÀH‹ÚI‰CÈL‹ñL%ñ¯üÿD}‹ýA·fB;„'è$tfB;„'ð$…¡L{H‹CH9ktH;Cv·Íë H‹3H‹è‰·È¸ÿÿf;ÈtL~ë‹ÍHƒÇfA‰Hƒÿu›HÿKA½ýÿH‹CH9ktH;Cw·ÁfA+ÇfA;ÅwH‹HÿJH‹èhHH‹CH‰„$€HÿÀH‰CH9ktH;Cv·Åë1HL$ è&S¸é¾H‹;H‹èí¹ÿÿf;ÁtLë‹ÅfA‰H‹ýA·fB;„'ø$tfB;„'%…šL{H‹CH9ktH;Cv·Íë H‹3H‹è’·È¸ÿÿf;ÈtL~ë‹ÍHƒÇfA‰Hƒÿ
u›HÿKH‹CH9ktH;Cw·ÁfA+ÇfA;ÅwH‹HÿJH‹èwG¸L\$@I‹[0I‹k8I‹sHI‹ãA_A^A]A\_ÃHL$ è6RöØÀƒàüƒÀëÌÌÌL‹ÜI‰[I‰kI‰s M‰CWHƒì@ICI‰SØI‰CèH=ù­üÿI‰KàL‹ÑE3Û½ÿÿE‹ÃA[A·fA;„8D%tfA;„8L%…ŸHZH‹BL9ZtH;BvA·Ëë L‹
I‹AI;At·HƒÀI‰Af;ÍuA‹ËIƒÀfA‰
IƒøušHÿJ¾ýÿH‹BL9ZtH;Bwf+Ëf;ÎwH‹
H‹AH;tHƒÀþH‰AH‹BH‰D$`HÿÀH‰BL9Zt H;BvA·Ëë4HL$ èxU¸éÂL‹I‹@I;@t·HƒÀI‰@f;ÍuA‹ËfA‰
M‹ÃA·fA;„8X%tfA;„8h%…’HZH‹BL9ZtH;BvA·Ëë L‹
I‹AI;At·HƒÀI‰Af;ÍuA‹ËIƒÀfA‰
Iƒø
ušHÿJH‹BL9ZtH;Bwf+Ëf;ÎwH‹
H‹AH;tHƒÀþH‰A¸H‹\$PH‹l$XH‹t$hHƒÄ@_ÃHL$ èTöØÀƒàüƒÀëÕÌL‹ÜI‰[I‰sM‰CWAUAVHƒì@ICI‰SÈI‰CØL-ù«üÿH‹ÚI‰KÐH‹ù3öŠB:„.à$tB:„.ä$… HÿCHƒ{H‹CtH;CwL‹3I‹ès‹ÈƒøÿtIÿFë2ÉHÿƈHƒþu¬HÿKHƒ{H‹CtH;CwA<vH‹¾ÉƒùÿtHÿJH‹è*FH‹CH‰D$pHÿÀHƒ{H‰CtH;Cw*H‹3H‹èþƒøÿtHÿFëHL$ èñS¸é\2Àˆ<(tHL$ èÕSöØÀƒàýƒÀé;HÿCHƒ{H‹CtH;CwH‹3H‹èžƒøÿtHÿFë2ÀH‹ÓˆH‹Ïè<„Àt?ŠHÿKHƒ{H‹CtH;CwA<vH‹¾ÉƒùÿtHÿJH‹èOE¸é¾H‹ÓH‹Ï趄Àt<ŠHÿKHƒ{H‹CtH;CwA<vH‹¾ÉƒùÿtHÿJH‹èE¸ësA¶)D87tf€?tX¾AЃø	vAŸƒøvA¿ƒøv	ƒù_…îþÿÿHÿCHƒ{H‹CtH;CwH‹3H‹è¥ƒøÿtHÿFë2ÀˆA:Æu£D87…±þÿÿ¸H‹\$`H‹t$hHƒÄ@A^A]_ÃÌÌÌL‹ÜI‰[M‰CWHƒì@ICI‰SØH‹ÚI‰CèH‹ùI‰Kà3ÒL
}©üÿŠB:„
<%tB:„
@%…ÈHÿCHƒ{H‹CtH;CwL‹I‹@I;@t¾HÿÀI‰@ƒùÿu2ÉHÿˆHƒúu¨HÿKHƒ{H‹CtH;CwþÁ€ùvH‹H‹AH;tHÿÈH‰AH‹CH‰D$`HÿÀHƒ{H‰CtH;CwH‹H‹BH;Bt¾HÿÀH‰Bƒùÿu2Ɉ€ù(t-HL$ èŠMöØÀƒàýƒÀéQHL$ èqM¸é=HÿCHƒ{H‹CtH;CwH‹H‹BH;Bt¾HÿÀH‰Bƒùÿu2ɈH‹ÓH‹ÏèS	„Àt:ŠHÿKHƒ{H‹KtH;KwþÀ<vH‹H‹AH;tHÿÈH‰A¸é¿H‹ÓH‹ÏèÒ„Àt7ŠHÿKHƒ{H‹KtH;KwþÀ<vH‹H‹AH;tHÿÈH‰A¸ëyA°)D8tl€?t^¾AЃø	vAŸƒøvA¿ƒøv	ƒù_…ÞþÿÿHÿCHƒ{H‹CtH;CwH‹H‹BH;Bt¾HÿÀH‰Bƒùÿu2ɈA:ÈuD8…›þÿÿ¸H‹\$PHƒÄ@_ÃÌÌÌL‹ÜI‰[I‰kI‰s M‰CWATAUAVAWHƒì@3íI‰S¸ICI‰KÀH‹ÚI‰CÈH‹ùL%ý¦üÿD}‹õA½ÿÿ·fB;„&%tfB;„&%…œL{H‹CH9ktH;Cv·ÍëL‹3I‹è·ÈfA;ÅtM~ë‹ÍHƒÆf‰Hƒþu¡HÿKA¾ýÿH‹CH9ktH;Cw·ÁfA+ÇfA;ÆwH‹HÿJH‹èt?H‹CH‰„$€HÿÀH‰CH9ktH;Cv·Åë-HL$ èFL¸é~H‹3H‹èùfA;ÅtL~ë‹Åf‰fƒø(tHL$ èLöØÀƒàýƒÀéCL{H‹CH9ktH;Cv·ÅëH‹3H‹è¥fA;ÅtL~ë‹ÅH‹Óf‰H‹Ïè-„Àt=·HÿKH‹CH9ktH;Cw·ÁfA+ÇfA;ÆwH‹HÿJH‹èŠ>¸éÂH‹ÓH‹Ïè©„Àt:·HÿKH‹CH9ktH;Cw·ÑfA+×fA;ÖwH‹HÿJH‹è>>¸ëyfƒ?)tnf9/t_·AЃø	vAŸƒøvA¿ƒøv	ƒù_…îþÿÿL{H‹CH9ktH;Cv·ÅëH‹3H‹è¬fA;ÅtL~ë‹Åf‰fƒø)uœfƒ?)…©þÿÿ¸L\$@I‹[0I‹k8I‹sHI‹ãA_A^A]A\_ÃL‹ÜI‰[I‰kI‰s M‰CWAVAWHƒì@3öI‰SÈICI‰KÐH‹ÚI‰CØH‹ùL
M¤üÿDv‹ÖA¿ÿÿ·fB;„
t%tfB;„
|%…LsH‹CH9stH;Cv·Îë L‹I‹@I;@t·HƒÀI‰@fA;Ïu‹ÎHƒÂf‰HƒúuHÿK½ýÿH‹CH9stH;CwfA+Îf;ÍwH‹H‹AH;tHƒÀþH‰AH‹CH‰D$pHÿÀH‰CH9stH;Cv·Îë4HL$ èJ¸é˜H‹H‹BH;Bt·HƒÀH‰BfA;Ïu‹Îf‰fƒù(tHL$ èÔIöØÀƒàýƒÀéVLsH‹CH9stH;Cv·Îë H‹H‹BH;Bt·HƒÀH‰BfA;Ïu‹Îf‰H‹ÓH‹Ïè„Àt>·HÿKH‹KH9stH;KwfA+Æf;ÅwH‹H‹AH;tHƒÀþH‰A¸éÍH‹ÓH‹Ïè„Àt>·HÿKH‹CH9stH;CwfA+Îf;ÍwH‹H‹JH;
tHƒÁþH‰J¸é€fƒ?)tuf97tf·AЃø	vAŸƒøvA¿ƒøv	ƒù_…âþÿÿLsH‹CH9stH;Cv·Îë H‹H‹BH;Bt·HƒÀH‰BfA;Ïu‹Îf‰fƒù)u•fƒ?)…–þÿÿ¸H‹\$`H‹l$hH‹t$xHƒÄ@A_A^_ÃÌÌH‰\$H‰l$H‰t$WAVAWHƒì 3ÛH-Ÿ¡üÿ‹ûH‹òL‹ùAŠ:„/”%t	:„/˜%u:HÿFH‹FH9^tH;FwL‹6I‹è#ƒøÿtIÿFëŠÃHÿÇAˆHƒÿu³³H‹l$HŠÃH‹\$@H‹t$PHƒÄ A_A^_ÃÌH‰\$E3ÀH¡üÿE‹ÈL‹ÙAŠA:„à%t
A:„ä%uBHÿBH‹BL9BtH;BwL‹I‹BI;Bt¾HÿÀI‰BƒùÿuAŠÈIÿÁAˆIƒùuªA°H‹\$AŠÀÃÌH‰\$H‰l$H‰t$WAVAWHƒì 3ÛH-“ üÿ‹ûH‹òL‹ùA·f;„/À%t
f;„/È%uFHÿFH‹FH9^tH;Fv·ÃëL‹6I‹è/¹ÿÿf;ÁtIÿFë‹ÃHƒÇfA‰Hƒÿu¤³H‹l$HŠÃH‹\$@H‹t$PHƒÄ A_A^_ÃÌÌH‰\$E3ÀH üÿE‹ÈL‹ÙA·fA;„&tfA;„&uPHÿBH‹BL9BtH;BvA·Èë%L‹I‹BI;Bt·HƒÀI‰B¸ÿÿf;ÈuA‹ÈIƒÁfA‰Iƒùu™A°H‹\$AŠÀÃH‰\$H‰l$H‰t$WAVAWHƒì 3ÛH-gŸüÿ‹ûH‹òL‹ùAŠ:„/„%t	:„/Œ%u:HÿFH‹FH9^tH;FwL‹6I‹èë
ƒøÿtIÿFëŠÃHÿÇAˆHƒÿu³³H‹l$HŠÃH‹\$@H‹t$PHƒÄ A_A^_ÃÌH‰\$E3ÀHåžüÿE‹ÈL‹ÙAŠA:„Ð%t
A:„Ø%uBHÿBH‹BL9BtH;BwL‹I‹BI;Bt¾HÿÀI‰BƒùÿuAŠÈIÿÁAˆIƒùuªA°H‹\$AŠÀÃÌH‰\$H‰l$H‰t$WAVAWHƒì 3ÛH-[žüÿ‹ûH‹òL‹ùA·f;„/ %t
f;„/°%uFHÿFH‹FH9^tH;Fv·ÃëL‹6I‹è÷¹ÿÿf;ÁtIÿFë‹ÃHƒÇfA‰Hƒÿ
u¤³H‹l$HŠÃH‹\$@H‹t$PHƒÄ A_A^_ÃÌÌH‰\$E3ÀHÉüÿE‹ÈL‹ÙA·fA;„è%tfA;„ø%uPHÿBH‹BL9BtH;BvA·Èë%L‹I‹BI;Bt·HƒÀI‰B¸ÿÿf;ÈuA‹ÈIƒÁfA‰Iƒù
u™A°H‹\$AŠÀÃHƒì8L‹Êƒù¦„‹3À…ÉtmƒétMƒét:ƒét"ƒù…Î8‚•ÀÁà
ÿÿÿA‰éÃ8‚•ÀÁà
€ëå8‚•ÀÁàë×HT$ L‰D$ I‹ÉˆD$(è|té‰HT$ L‰D$ I‹ÉˆD$(èVëq3À8‚•ÀÁà
€ëƒétNƒét=ƒét ƒùu83À8‚•ÀÁà
€A‰Aë-3À8‚•ÀÁàA‰¸ë3ÀA‰¸ë	AÇÀÿ3ÀHƒÄ8ÃÌHƒì8L‹Êƒù¤„3À…ÉtqƒétPƒét9ƒét(ƒù…ØH¹ÿÿÿÿÿÿÿ8‚•ÀHÁà?HÁéÊH¹ðëß8‚•ÀHÁà?é¬HT$ L‰D$ I‹ÉÆD$(è`sé•HT$ L‰D$ I‹ÉÆD$(è€Uë|3ÀH¹ð늃étZƒétIƒét+ƒùuD3ÀH¹ð8‚•ÀHÁà?HÁI‰¸ë43À8‚•ÀHÁà?I‰¸ë3ÀI‰¸ëH¸øÿI‰3ÀHƒÄ8ÃÌH‰\$H‰t$H‰|$ UATAUAVAWH‹ìHƒìPE3äEŠùE‹èH‹ÚL9"tL9bu)ènÿÿÇèÎsH‹CH…Àt	L9cuDˆ 3Àé E…Àt	A@þƒø"wÉH‹ÑHMØè»ÚýÿH‹CH‰EÐHÿÀH‰CL9ctH;CwH‹3H‹è1	‹øƒøÿtHÿFëAŠüA¾H‹Eà@¶Ïƒx~LEàA‹ÖèYëH‹EàH‹ÑH‹·QA#Æ…Àt2HÿCH‹CL9ctH;CvAŠüë¶H‹;H‹èƃøÿtëHÿG@ŠøëE„ÿA‹ô@•Æ@€ÿ-uƒÎë@€ÿ+u0HÿCH‹CL9ctH;CwH‹;H‹è~ƒøÿt	HÿG@ŠøëAŠüM‹ôA÷Åïÿÿÿ…GÐ<	w	@¾ÇƒÀÐë#GŸ<w	@¾ÇƒÀ©ëG¿<w	@¾ÇƒÀÉëƒÈÿ…ÀtA¹E…í…ÌEiéÃHÿCH‹CL9ctH;CwgL‹;I‹èï‹ÐƒøÿtUIÿGH¨öÁßuLE…í¸DDèHÿCH‹CL9ctH;CvAŠüëfH‹;H‹è¬A¹ƒøÿt	HÿG@ŠøëMAŠüëHAŠÔE…íA¹EDéHÿKH‹CL9ctH;Cw$B<v¾ÊH‹ƒùÿtHÿJH‹èU3A¹Mcå3ÒHƒÈÿI÷ôH‰U8L‹øOЀù	w
D¾ÇAƒÀÐë&GŸ<w
D¾ÇAƒÀ©ëG¿<w
D¾ÇAƒÀÉëAƒÈÿAƒøÿtqE;ÅslAñM;÷ruA‹ÀH;ÂvƒÎë
I‹ÌI¯ÎE‹ðLñHÿCHƒ{H‹CtH;Cv@2ÿé|ÿÿÿH‹;H‹è©ƒøÿtHÿG@ŠøH‹U8A¹éVÿÿÿ@2ÿëìIƒÌÿE3ÿLcH‹CL9{tH;CwG<vH‹@¾ÏA;ÌtLbH‹èS2@öÆuAH‹EÐH;CtH‹CDˆ8D8}ðtH‹E؃ ¨ýH‹CH…À„¢üÿÿL9{…˜üÿÿDˆ8éüÿÿI‹Ö‹Îèºkÿÿ„ÀtzèujÿÿÇ"@öÆuM‹ôëm@öÆt/D8}ðtH‹E؃ ¨ýH‹CH…Àt	L9{uDˆ8H¸€ë^D8}ðtH‹E؃ ¨ýH‹CH…Àt	L9{uDˆ8H¸ÿÿÿÿÿÿÿë/@öÆtI÷ÞD8}ðtH‹M؃¡¨ýH‹KH…Ét	L9{uDˆ9I‹ÆL\$PI‹[0I‹s@I‹{HI‹ãA_A^A]A\]ÃÌÌÌH‰\$H‰l$H‰t$ WATAUAVAWHì°E3öAŠéE‹èH‹úL92tL9ru)èuiÿÿÇè.oH‹GH…Àt	L9wuDˆ03ÀéøE…Àt	A@þƒø"wÉH‹ÑHŒ$€èÖýÿH‹GM‹æH‰„$ ¾HÿÀA¿ÿÿH‰GL9wtH;GwYH‹7H‹è›·ØfA;Çt
¸HF‹ðëf;\$X‚Âþÿÿ‹D$`f;Ør*f;\$hs#é­þÿÿf;\$ps
D·ÃAèÿëAƒÈÿAƒøÿu-C¿fƒøvCŸfƒøvAƒÈÿëCŸD·ÃfƒøwAƒè AƒÀÉAƒøÿt~E;ÇsyêM;ñruA‹ÀI;ÃvƒÍë
I‹ÊI¯ÎE‹ðLñHwH‹GL9gtH;GvA·Üë*H‹H‹AH;Atí·HƒÀH‰A¸ÿÿf;Ðt·ÚºA¸ÿé©ýÿÿºë¾HÿOH‹GL‹¬$€L9gtH;Gw!f+Þ¸ýÿf;ØwH‹H‹AH;tHƒÀþH‰A@„êu/L;otH‹GDˆ D8¤$ „øÿÿH‹„$ˆƒ ¨ýéï÷ÿÿI‹Ö‹ÍèTÿÿ„À„Šè6SÿÿÇ"@„îuIƒÎÿë}@öÅt7D8¤$ tH‹„$ˆƒ ¨ýH‹GH…Àt	L9guDˆ H¸€ënD8¤$ tH‹„$ˆƒ ¨ýH‹GH…Àt	L9guDˆ H¸ÿÿÿÿÿÿÿë7@öÅtI÷ÞD8¤$ tH‹Œ$ˆƒ¡¨ýH‹OH…Ét	L9guDˆ!I‹ÆLœ$°I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒì M‹ùM‹àH‹ÚH‹éM…ÀtVH‹|$`H+êL‹òI÷ÞAŠ:+t:u]HÿGHƒH‹GtH;GwH‹7H‹èpíƒøÿtHÿFë2ÀHÿÃAˆII;Äu¸°H‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A^A\Ã2ÀëÝÌÌÌH‰\$H‰|$M‹ÙI‹øL‹ÑM…Àt]L‹L$(L+ÒH‹ÚH÷ÛAŠA:t:uOIÿAIƒyI‹AtI;AwM‹I‹@I;@t¾HÿÀI‰@ƒùÿu2ÉHÿÂAˆHH;Çu±°H‹\$H‹|$Ã2ÀëñÌÌH‰\$H‰l$H‰t$WATAUAVAWHƒì E3íM‹ùM‹àH‹ÚH‹éA‹õM…Àt_H‹|$pH+êA·f;+tf;ugHÿGH‹GL9otH;GvA·ÅëL‹7I‹èUë¹ÿÿf;ÁtIÿFëA‹ÅHÿÆfA‰HƒÃI;ôu©°H‹\$PH‹l$XH‹t$`HƒÄ A_A^A]A\_Ã2ÀëßÌÌÌH‰\$H‰t$H‰|$3öI‹ÙI‹øL‹ÙD‹ÖM…ÀtcL‹L$(L+Ú·fA;tf;u^IÿAI‹AI9qtI;Av·Îë$M‹I‹@I;@t·HƒÀI‰@¸ÿÿf;Èu‹ÎIÿÂf‰HƒÂL;×u¥°H‹\$H‹t$H‹|$Ã2ÀëìÌH‹ÄH‰XWHƒì@L‹A8HQH‹ÙLHWÀHHØ3ÿó@@ˆxèšÿÿH‹KpLD$XH‹Ðè	ÿÿ@8|$PtHƒøtC@8{2t°ë;HƒCxH‹CxH‹HøH…Éuè`OÿÿÇèUëHÿƒ€@·‹D$X‰@ŠÇë2ÀH‹\$`HƒÄ@_ÃÌH‹ÄH‰XWHƒì@L‹A@HQH‹ÙLHWÀHHØ3ÿó@@ˆxè:ÿÿH‹KxLD$XH‹Ðè	’ÿÿ@8|$PtNƒøtI@8{:t°ëAHƒƒ€H‹ƒ€H‹HøH…ÉuèºNÿÿÇèsTëHÿƒˆ@·‹D$X‰@ŠÇë2ÀH‹\$`HƒÄ@_ÃÌÌÌH‹ÄH‰XWHƒì@L‹A8HQH‹ÙLHWÀHHØ3ÿó@@ˆxèrŽÿÿH‹KXLD$XH‹Ðèÿÿ@8|$PtEƒøt@@8{4t°ë8HƒC`H‹C`H‹HøH…ÉuèNÿÿÇèÑSë
HÿCh@·‹D$X‰@ŠÇë2ÀH‹\$`HƒÄ@_ÃH‹ÄH‰XWHƒì@L‹A@HQH‹ÙLHWÀHHØ3ÿó@@ˆxèŽÿÿH‹K`LD$XH‹Ðè’ÿÿ@8|$PtEƒøt@@8{H‹¬$˜H‹„$€IÿÇéWÿÿÿHƒÿÿ„ÿÿÿéýþÿÿfE;õtHÿKA·ÎH‹Sè†H‹„$€M…ÿ„•þÿÿE…äuL;øt	ö„‚þÿÿ€{4uE…ätH‹D$0ÆHÿCh°H‹œ$ˆHƒÄ@A_A^A]A\_^]ÃÌH‰\$UVWATAUAVAWHƒì03öD‹âH‹Ù@8qÌÌHƒì(HƒAxH‹AxL‹@øM…Àuè9ÿÿÇèV?2ÀëHÿ€°‹
A‰HƒÄ(ÃÌÌÌHƒì(Hƒ€H‹€L‹@øM…ÀuèW9ÿÿÇè?2ÀëHÿˆ°‹
A‰HƒÄ(ÃÌHƒì(HƒA`H‹A`L‹@øM…Àuè9ÿÿÇèÒ>2ÀëHÿAh°‹
A‰HƒÄ(ÃÌÌHƒì(HƒAhH‹AhL‹@øM…ÀuèÝ8ÿÿÇè–>2ÀëHÿAp°‹
A‰HƒÄ(ÃÌÌHƒì(HƒAxH‹AxL‹@øM…Àuè¡8ÿÿÇèZ>2ÀëHÿ€°H‹
I‰HƒÄ(ÃÌÌHƒì(Hƒ€H‹€L‹@øM…Àuè[8ÿÿÇè>2ÀëHÿˆ°H‹
I‰HƒÄ(ÃHƒì(HƒA`H‹A`L‹@øM…Àuè8ÿÿÇèÖ=2ÀëHÿAh°H‹
I‰HƒÄ(ÃÌHƒì(HƒAhH‹AhL‹@øM…Àuèá7ÿÿÇèš=2ÀëHÿAp°H‹
I‰HƒÄ(ÃÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁL‰AL‰IÃÌH‹H‰H‹ÁÃÌÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁL‰AL‰IÃÌH‹D$(H‰AH‹D$0H‰A H‹ÁH‰L‰AL‰IÃÌÌÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁL‰AL‰IÃÌH‹H‰H‹ÁÃÌÌH‹H‰H‹ÁÃÌÌH‰H‹ÁL‰AL‰IÃÌH‹H‰H‹ÁÃÌÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁL‰AL‰IÃÌH‰H‹ÁÃÌ@SHƒì ƒaH‹ÙH‰3ÒL‰AHƒÁ4DB èýýÿƒcH‹ÃHƒc ƒc(ƒc0fÇCÆCÆC,HƒÄ [ÃÌ3ÀH‰H‰AL‰AH‰A8‰AˆAH‰A ‰A(ˆA,‰A0H‹ÁÃHƒaH‰L‰AL‰IM…ÉtAÆH‹ÁÃÌÌÌHƒaH‰L‰AL‰IM…ÉtAÆH‹ÁÃÌÌÌHƒaH‰L‰AL‰IM…ÉtAÆH‹ÁÃÌÌÌHƒaH‰L‰AL‰IM…ÉtAÆH‹ÁÃÌÌÌ@SHƒì L‰H‹Ù3ÒóAƒa(L‰ADB L‰I HƒÁLèýýÿƒc,Hƒc8ƒc@ƒcHH‹D$PfÇC0ÆC2ÆCDHƒ£€Hƒ£ˆH‰CpH‹D$XH‰CxH‹ÃHƒÄ [ÃÌÌÌ@SHƒì L‰H‹ÙAòJ3ÒòIƒa0L‰A L‰I(DB HƒÁTèxýÿƒc4Hƒc@ƒcHƒcPH‹D$PfÇC8ÆC:ÆCLHƒ£ˆHƒ£H‰CxH‹D$XH‰ƒ€H‹ÃHƒÄ [ÃÌÌÌH‹D$(L‰3ÒóAL‰AL‰I H‰Q(H‰QP‰Q0ˆQ4H‰Q8‰Q@ˆQD‰QHH‰AXH‹D$0H‰A`H‹ÁH‰QhH‰QpÃÌÌH‹D$(L‰AòJ3ÒòIL‰A L‰I(H‰Q0H‰QX‰Q8ˆQss
A‹E‰D†AÿëA‰6E…ÿtED‹ÆA96t"A‹ÐAÿÀA‹ÇA‹L–HÈL‹ùA‰L–IÁï E;uÞE…ÿtAƒ>ss
A‹E‰|†AÿëA‰6D‹þD‹îA¶C¿AÿÅIÿÁDssA‹E‰D†Aÿé`A‰6@ŠÆéWAƒ>‡«L‹ÆI^‹;A‰63öIÁàM…ÀtGH…Ûu
è†'ÿÿÇë0¸ÌH‹ËL;ÀwH•èEëL‹À3ÒèùýüÿèT'ÿÿÇ"è
-…ÿ„ÿÿÿƒÿ„ÜE‹E…Ò„ÐD‹ÆD‹ÎL‹ßA‹ÑAÿÁA‹À‹“I¯ËHÈL‹Á‰“IÁè E;ÊuÞé!ÿÿÿA;6I~E‹H•’ÀH„ÀDEÆHD×AE6HEÏ3ÀH‰T$0E3ÒH‰L$8D‰D$ ‰D$@E…À„üF‹$’E…äuD;Ð…ÙF!d”DAB‰D$@éÇ3ÛE‹Ê…ö„«E‹ÚA÷ÛAƒùstVD;ÈuA‹ÁAKƒd„DCȉL$@H‹D$8CE‹ÁAÿÁ‹ˆB‹D„DI¯ÔHЋÃHÐCH‹ÚB‰T„DHÁë ;Æ‹D$@u¤…Ût@Aƒùs„CD;ÈuA‹Áƒd„DAA‰D$@A‹ÉAÿÁ‹Ã‹TŒDHЉTŒD‹D$@HÁê ‹Ú…ÒuÀD‹D$ Aƒùs„þH‹T$0AÿÂE;Ð…	ÿÿÿD‹d$$D‹À3öIÁàA‰M…ÀtEH…ÿu
è—%ÿÿÇë.¸ÌH‹ÏL;ÀwHT$DèXëL‹À3Òèüüÿèg%ÿÿÇ"è +°„À„D+d$,HRüÿD‰d$$…ƒüÿÿ‹D$(€ÀD+ètkAEÿ‹„‚¸"…ÀtYƒøtWE‹E…ÒtOD‹ÆD‹ÎD‹ØA‹ÑAÿÁA‹ÀA‹L–I¯ËHÈL‹ÁA‰L–IÁè E;ÊuÚE…ÀtAƒ>ssA‹E‰D†Aÿë3öA‰6A‰6E…ÿtED‹ÆA96t"A‹ÈAÿÀA‹×A‹DŽHÐA‰TŽHÁê D‹úE;uÞE…ÿtAƒ>ss
A‹E‰|†AÿëA‰6H‹àH3ÌèiâüÿLœ$ðI‹[0I‹s8I‹{HI‹ãA_A^A]A\]ÃÌÌÌÌÌÌÌÌHìøD‹ÊL‹Á…ÒtHE3ÛE‹ÓD9t(@A‹ÂAÿÂA‹T€I€A‹ÁHÐL‹Ê‰QIÁé E;uÜE…ÉtA‹ƒøssE‰L€Aÿ°HÄøÃE‰IHLD$$D‰\$ E3ɺÌèÏs2ÀHÄøÃÌÌÌÌÌ‹‹ÒHÂA‹ÐH‰HÁè ÃÌÌÌÌÌÌÌÌÌÌÌÌA‹ÀD‹ÒL¯Ð‹LÐA‹ÁLÐL‰T$‹D$D‰ÃÌÌH‰\$H‰t$WHƒì 3öH‹Ù9qt2Àé H‹A‰qf‰q@ˆqH‰q ‰q(@ˆq,‰q0@80u
¿‰yëͶèˆ[ÿÿ…Àt3H‹CÇC¶èq[ÿÿ¿ëH{H‹K¶	èZ[ÿÿ…Àuìé2H‹K²%8…¶HA8„ªÇC¿H‰C€8*uHÿÀ@ˆ{H‰CH‹ËèX„À„DÿÿÿH‹Ëèo[H‹KŠI‹„Òt@„íH¹ð•ÃHÁã?HÙH‰ë@„í•ÃÁãË€‰¸éÌŠÂI¼€ÿÿÿöØÉá€üÿÿƒÁ‚;ñDA0A‹ðEMÿ÷ÞDÈD‰L$ A‹ÉE…ɉ÷Ù‰L$$ƒù@ƒç‹ÁA¿H£ÇA‹ÇÿÉ’D$pHÓàH…Ç•ÁˆŒ$E„ÒtHÿÈDŠãH…ÇtEŠç„ÉuE„ät[è-ç…Àt%=tD‹L$ D‹\$x=u:@ŠÅë7@„í”Àë8œ$tE„äu8\$ptAŠÇD‹L$ D‹\$xëD‹L$ D‹\$xŠÃ‹L$$HÓï¶ÀHøt9AŠVI¼€ÿÿÿŠÂöØHÉI#ÌHÁÿÿH;ù†9A‹óA+ñA+õA+÷é(I‹A8^t@„í•ÃHÁã?H‰ë@„í•ÃÁ㉸égE…í‰êA÷ÝAƒý@rH‹ûé˜A‹ÅAMÿH£ÇA¿A‹Ç’„$HÓàH…Ç•ÁˆL$xE„ÒtHÿÈDŠãH…ÇtEŠç„ÉuE„ät9èüå…Àt=t=u"DŠýë @„íA”Çë8\$xtE„äu8œ$uDŠûA‹ÍA¶ÇHÓïI¼€ÿÿÿHøAŠVŠÂöØH¸ÿÿÿHÉH#ÈHÁÿÿÿH;ùv%HÑïŠÂÿÆöØÉဃÁ;ñ~
éjýÿÿ~A‹ÍHÓçŠÂöØHÉI#ÌHÁÿÿH#ù„ÒI‹t0Žÿ@¶ÅáÿHÁàHÈH¸ÿÿÿÿÿÿH#øHÁá4HÏH‰
ëN@¶ÅÁáçÿÿá€ÁàÈω
3ÀH‹œ$€HƒÄ0A_A^A]A\_^]ÃÌH‰\$H‰l$H‰t$WATAUAVAWHƒì0H‹´$€D‹ÚA¼EŠñAŠèL‹ÑŠFöØA\$?ÒƒâƒÂA+ÔD;Ûw2ƒ9vD‹AëE3ÀD9!v‹Aë3ÀE„ö‹ÈA‹ÀA”ÁHÁá HÈéÜE‹ËAÁëE{ÿECþAƒáuFB‹|¹A‹ØB‹LÁãHÁç ÚHùE„öA”ÁE3ÛE…ÀtCƒ|š”ÀEÜD"ÈE;Øuì‹ÓH‹ÏéG‹|ºA‹üG‹l‚A+ÙA‹ÉÓçA+üE‹àAÁäKàIÓçEáDâ‹ÇC‹Tš‹ËH#ÐHÓâA‹ÉLú‹×÷ÒI#ÕHÓêLúE„öu
D…ïuA±ëE2ÉE3ÛE…ÀtCƒ|š”ÀAÿÃD"ÈE;ØuìA‹ÔI‹ÏDŠÅH‰´$€H‹\$`H‹l$hH‹t$pHƒÄ0A_A^A]A\_éÂúÿÿÌÌH‹E3ÀD8Bt„ÉA•ÀIÁà?L‰Ã„ÉA•ÀAÁàD‰ÃÌÌÌÌÌÌÌÌL‹Á‹	…Éu3ÀÃÿÉ3ÒE½LˆtAQÁá
ÃÌÌÌÌÌÌÌÌÌÌÌÌ̽ÁÇD$tÿÀÃ3ÀÃÌÌÌÌÌÌÌÌÌÌÌÌ̸ÿÿÿÿH;ÈvHÁé 3À½ÑtBƒÀ Ã3À½ÑtBÃÌH‹AÃÌÌÌH‹AÃÌÌÌH‹AH+ÃH‹AH+HÑøÃÌH‰\$UVWATAUAVAWH¬$õÿÿHìpH‹îÅH3ÄH‰…`
D‹LÚEüÿŠBöØH‰L$XH‰T$pH‹Ñ‹IÀƒàE3öƒÀD‰µPE…Ò‰D$T‹ÁLJEHÖA^&D;ÑE‹þE‹æE‹îABÂD+ÐLÈHBD‰T$PHÁL‰L$x‹ÈH‰D$hA+ÉLR‰L$0M;Ñ„:Aƒý	…òE…ÿtzE‹ÆE‹ÎA‹ÑAÿÁ‹„•THiÈÊš;A‹ÀHÈL‹Á‰Œ•TIÁè E;ÏuÓL‹L$xE…Àt6ƒ½Pss!‹…PD‰„…TD‹½PAÿÇD‰½PëE‹þD‰µPëD‹½PE…äthE‹ÆE…ÿt-A‹ÐAÿÀA‹Ä‹Œ•THÈL‹á‰Œ•TD‹½PIÁì E;ÇuÓE…ät.AƒÿssA‹ÇD‰¤…TD‹½PAÿÇD‰½Pë
E‹þD‰µPE‹æE‹îA¶C¤AÿÅIÿÂD$HM;Ñ…éþÿÿE…털ÍÌÌÌA÷å‹ÂÁè‰D$8‹È‰D$@…À„×;Ë‹ÁGÃ3Ò‰D$<ÿÈ‹øA¶Œƒ""A¶´ƒ#"‹ÙHÁãL‹ÃHĉ…Àè¼íüÿH
ÕCüÿHÁæ·„¹ "H‘HÄL‹ÆHËH‚èÌ‹½Àƒÿ‡¦‹…Ä…ÀuE‹þD‰µPéƒø„E…ÿ„E‹ÆE‹ÎL‹ÐA‹ÑAÿÁA‹À‹Œ•TI¯ÊHÈL‹Á‰Œ•TIÁè E;ÏuÖE…À„Àƒ½Pss$‹…PD‰„…TD‹½PAÿÇD‰½PéšE‹þD‰µPAŠÆéŠAƒÿ‡­‹TL‹ÇIÁàD‹ÿ‰½PM…Àt@¸ÌHTL;ÀwH•ÄèÕëL‹À3Òè‰ìüÿèäÿÿÇ"èD‹½P…Û„÷þÿÿƒû„E…ÿ„	E‹ÆE‹ÎL‹ÓA‹ÑAÿÁA‹À‹Œ•TI¯ÊHÈL‹Á‰Œ•TIÁè E;ÏuÖéÿÿÿA;ÿD‰µðH•TE‹Ö’ÀL…Ä„ÀHÄHDÊH•TIDÐH‰L$`E‹ÇH‰T$HDEÇAEÿD‰D$DE‹þE…À„"A‹Â‹4…öu!E;×…EzD‰´…ôD‰½ðéëA‹ÞE‹Ê…ÿ„ÉE‹ÚA÷ÛAƒùstfE;ÏuA‹ÁAJD‰´…ôCȉðCE‹Á‹‚AÿÁ‹ÃH¯ÖHÐB‹„…ôHÐCH‹ÚB‰”…ôD‹½ðHÁë ;ÇtH‹T$Hë”…ÛtNAƒùs„E;ÏuA‹ÁD‰´…ôAA‰…ðA‹ÉAÿÁ‹Ó‹„ôHЉ”ôD‹½ðHÁê ‹Ú…Òu²D‹D$DAƒùs„°H‹L$`H‹T$HAÿÂE;Ð…ÞþÿÿE‹ÇIÁàD‰½PM…Àt@¸ÌHTL;ÀwH•ôè²þëL‹À3ÒèfêüÿèÁÿÿÇ"èzD‹½P°„ÀtA‹L$@L^@üÿ+L$<‰L$@t
»&é-üÿÿ‹D$8€ÀD+è„AEÿA‹„ƒ¸"…ÀuE‹þD‰µPësƒøtnE…ÿtiE‹ÆE‹ÎL‹ÐA‹ÑAÿÁA‹À‹Œ•TI¯ÊHÈL‹Á‰Œ•TIÁè E;ÏuÖE…Àt*ƒ½Pss©‹…PD‰„…TD‹½PAÿÇD‰½PëD‹½PE…ätvE‹ÆE…ÿt-A‹ÈAÿÀA‹Ä‹”THЉ”TD‹½PHÁê D‹âE;ÇuÓE…ätüÿD;ãE‹ìDGë3ÒD‰l$8AEÿA¶Œƒ""A¶´ƒ#"‹Ù‹øHÁãL‹ÃHĉ…Àè‡èüÿH
 >üÿHÁæ·„¹ "H‘HÄL‹ÆHËH‚è—ü‹½Àƒÿ‡®‹…Ä…ÀuE‹þD‰µPéƒø„E…ÿ„E‹ÆE‹ÎL‹ÐA‹ÑAÿÁA‹À‹Œ•TI¯ÊHÈL‹Á‰Œ•TIÁè E;ÏuÖE…Àt?ƒ½Pss$‹…PD‰„…TD‹½PAÿÇD‰½Pé E‹þD‰µPAŠÆéD‹½Pé‚Aƒÿ‡­‹TL‹ÇIÁàD‹ÿ‰½PM…Àt@¸ÌHTL;ÀwH•Äè˜ûëL‹À3ÒèLçüÿè§ÿÿÇ"è`D‹½P…Û„ïþÿÿƒû„E…ÿ„E‹ÆE‹ÎL‹ÓA‹ÑAÿÁA‹À‹Œ•TI¯ÊHÈL‹Á‰Œ•TIÁè E;ÏuÖéùþÿÿA;ÿD‰µðHTE‹ç’ÀL­Ä„ÀH•TE‹ÖLDéDEçAEÿHÄHDÑE‹þH‰T$HE…ä„A‹ÂA‹t……öu!E;×…ûEzD‰´…ôD‰½ðéãA‹ÞE‹Ê…ÿ„ÆE‹ÚA÷ÛAƒùsthE;ÏuA‹ÁAKD‰´…ôCȉðCE‹Á‹‚AÿÁH¯Ö‹È‹ÃHÐB‹„…ôHÐCH‹ÚB‰”…ôD‹½ðHÁë ;ÇtH‹T$Hë’…ÛtNAƒùs„…E;ÏuA‹ÁD‰´…ôAA‰…ðA‹ÉAÿÁ‹Ó‹„ôHЉ”ôD‹½ðHÁê ‹Ú…Òu²Aƒùs„7H‹T$HAÿÂE;Ô…äþÿÿE‹ÇIÁàD‰½PM…Àt@¸ÌHTL;ÀwH•ôè…ùëL‹À3Òè9åüÿè”ÿÿÇ"èMD‹½PD‹d$DD‹l$8°„À„¿E+å»&D‰d$D…&üÿÿ‹D$<‹L$P€À+È„òÿÉHý:üÿ‹„ˆ¸"…ÀuE‹þD‰µPéÔƒø„ÆE…ÿ„ÂE‹ÆE‹ÎL‹ÐA‹ÑAÿÁA‹À‹Œ•TI¯ÊHÈL‹Á‰Œ•TIÁè E;ÏuÖE…Àt~ƒ½Pss!‹…PD‰„…TD‹½PAÿÇD‰½Pë[H‹D$pL‹D$XD8pH‹AŠˆt„ÉH¹ðA•ÆIÁæ?LñL‰0ë„ÉA•ÆAÁæA΀D‰0¸éŸD‹½PE…ÿuA‹ÎëAOÿD‰t$H½„TtÿÀëA‹ÆÁáÈD‹L$0‰L$D;L$Tƒ1E…É„+H‹\$xE‹îH‹|$hE‹æD‰µ E‹ÆH;ß„Aƒø	…4E…í„’E‹ÆE‹ÎA‹ÑAÿÁ‹„•$HiÈÊš;A‹ÀHÈL‹Á‰Œ•$IÁè E;ÍuÓE…ÀtSƒ½ ss!‹… D‰„…$D‹­ AÿÅD‰­ ë0E3ÉD‰µL…”D‰µ ºÌH$è^\D‹­ E…ä„ŠA‹ÖE…ít)‹ÊÿÂE‹ä‹„$LàD‰¤$D‹­ IÁì A;Õu×E…ätTAƒýssA‹ÅD‰¤…$D‹­ AÿÅD‰­ ë0E3ÉD‰µL…”D‰µ ºÌH$èË[D‹­ E‹æE‹Æ¶C¤AÿÀHÿÃD$HH;ß…¨þÿÿD‰D$RD‹¥ð°„À„«‹L$P+L$H‰L$P…÷ûÿÿ‹D$8D‹L$0€ÀD+Èt@AIÿH­.üÿ‹„ˆ¸"…ÀuuE3ÉD‰u€LE„D‰µðºÌHôèÏQD‹¥ðE…í…"A‹Öé9D‰u€LE„¿ÌE3ÉD‰µðH‹×Hôè‘QD‹¥ðAŠÆéMÿÿÿH‹×ëxƒøt°E…ät«E‹ÆE‹ÎL‹ÐA‹ÑAÿÁA‹À‹Œ•ôI¯ÊHÈL‹Á‰Œ•ôIÁè E;ÌuÖE…À„hÿÿÿƒ½ðss$‹…ðD‰„…ôD‹¥ðAÿÄD‰¥ðéBÿÿÿºÌE3ÉD‰u€LE„D‰µðHôèçPH‹D$pL‹D$XH‹ÈAŠ˜D8ptè¤àÿÿ„ÛA•ÆIÁæ?L‰0ëèÌàÿÿ„ÛA•ÆAÁæD‰0¸éÑAUÿD‰t$H½„•$tÿÀëA‹ÆÁâÐE…äuA‹Îë AL$ÿD‰t$H½„ôtÿÀëA‹ÆÁáÈ‹Á»r+ÂA¹ÿÿÿÿ;ÑÿDS®#ø‰|$0†…‹÷D‰t$H‹\$0H‹t$8•ÀHƒÄ _ÃÌÌÌ3ÀH9•ÀÃÌÌÌ‹AËAËA0E3À…Àxƒø~{APƒø~%ƒøt;Âtiƒø	t3ÀËA(…ÀtQƒøtQ;ÂIEÐëI‹I(ƒù-t?…Ét6ƒétƒétƒét'ƒùt'I‹Ðë"ºëºëƒétƒét
ƒéë׺H‹ÂÊA,öØHÀH÷ØHÿÀÃÌÌÌ‹A0E3À…Àxƒø~{APƒø~%ƒøt;Âtiƒø	t3ÀËA(…ÀtQƒøtQ;ÂIEÐëI‹I(ƒù-t?…Ét6ƒétƒétƒét'ƒùt'I‹Ðë"ºëºëƒétƒét
ƒéë׺H‹ÂÊA,öØHÀH÷ØHÿÀÃÌÌÌŠA÷AÃÌÌÌŠAÃ3À‰QHÁê …Ò‰Q•ÀÿÀ‰H‹ÁÃÌÌÌŠAöØÀƒàƒÀÃÌÌŠAöØÀ%€ƒÀÊAöØÀ%€üÿÿƒÀ‚ËA0ËA0ÃÌÌÌÌÌÌÌÌÌÌÌÌ@SVWHì H‹>œH3ÄH‰„$ðH‹ñ‹
ƒù‡¸‹B…Àu(E3ÒHNE3ÉD‰T$ LD$$D‰ºÌèM?°éðƒøtôD‹E…ÛtìE3ÒH^E‹ÂE‹ÊH‹øf„A‹ÁAÿÁ‹ƒHƒA‹ÀH¯×HÐL‹Â‰IÁè E;ËuÛE…Àt©‹ƒøssD‰D†°ÿé‹E3ÉD‰T$ LD$$D‰ºÌH‹ËèÄ>2ÀégL‰´$D‹6Aƒþ‡Ë‹~H^‰LBD‹
H‹ËIÁáºÌè‡>…ÿu'E3ÒLD$$E3ÉD‰T$ ºÌD‰H‹Ëèc>°éþƒÿtôD‹E…ÛtìE3ÒE‹ÂE‹ÊfDA‹ÁAÿÁ‹ƒHƒA‹ÀH¯×HÐL‹Â‰IÁè E;ËuÛE…Àt³‹ƒøssD‰D†°ÿé£E3ÉD‰T$ LD$$D‰ºÌH‹Ëèä=2ÀéA;ÎL‰¤$L‰¬$’ÀL‰¼$„ÀHFtLjL‹øD‹áë
E‹æLzD‹ñL‹èE3ÒH‰¬$PA‹ÊA‹Ú‰L$ E…ä„ä‹ÃA‹l……íu;Ù…ÆKD‰T„$‰L$ éµE‹Ú‹ÃE…ö„¢‹û÷߃østQ;Áu‹ÈSD‰TŒ$щT$ ‹ÈLL$$M‰ÿÀE‹A‹ËL¯ÅLÁA‹	LÁM‹ØE‰IÁë A;΋L$ uªE…ÛtCƒøs„«;Áu‹ÈD‰TŒ$H‰L$ ‹ÈHT$$HŠE‹Ã‹
ÿÀLÁD‰‹L$ IÁè E‹ØE…Àu½ƒøstlÿÃA;Ü…ÿÿÿD‹ÉLD$$‰ºÌIÁáHNè€<°H‹¬$PL‹¬$L‹¤$L‹¼$L‹´$H‹Œ$ðH3Ìè6ªüÿHÄ _^[ÃD‰2Àë¶ÌÌÌÌHìøL‹Á…Òu+E3ÒLD$$D‰E3ÉHƒÁD‰T$ ºÌè<°HÄøÃútñH‰œ$‹…Ûu°H‹œ$HÄøÃH‰´$E3ÒH‰¼$ðE‹ÊHy‹òE‹ÚA‹ÃAÿˇH‡A‹ÁH¯ÖHÐL‹Ê‰IÁé D;ÛuÛH‹´$E…ÉtA‹ƒøss"E‰L€Aÿ°H‹¼$ðH‹œ$HÄøÃE‰E3ÉLD$$D‰T$ ºÌH‹Ïè7;2ÀëÇÌÌÌ‹ÂH¯ÁÃÌÌÌÌÌÌÌÌÌH‰\$UVWATAUAVAWH¬$ýÿÿHìðH‹ª—H3ÄH‰…à¸ÍÌÌ̉T$(D‹ÂL%üÿ÷âE3ÉL‹ñ‹ÂÁè‰D$,D‹ø‰D$ …À„F¸&„Aƒÿ&E‹ïDGè3ÒD‰l$$AEÿH<… "B¶L'B¶t'HL‹ÃHL$D‰D$@èúÀüÿB·'HL$DHÁæHËL‹ÆH…IÔèÕ‹L$@ƒù‡ ‹D$D…Àu
3öA‰6釃ø„~E‹E…Ò„r3öM^D‹ÆD‹ÎH‹ØA‹ÁAÿÁA‹ƒIƒA‹ÀH¯ÓHÐL‹Â‰IÁè E;ÊuÚE…À„1A‹ƒøss
E‰D†AÿéE3ɉt$@LD$DA‰6ºÌI‹Ëè 92ÀéûA‹6ƒþ‡A‹~I^L‹ÁA‰IÁàM…ÀtGH…Ûu
è\éþÿÇë0H‹ËIøÌwHT$DèÔë3ÒA¸ÌèÏ¿üÿè*éþÿÇ"èãî…ÿu#3öLD$DE3ɉt$@ºÌA‰6H‹Ëè
9éhƒÿ„_E‹E…Ò„S3öL‹ßD‹ÆD‹Î„A‹ÁAÿÁ‹ƒHƒA‹ÀI¯ÓHÐL‹Â‰IÁè E;ÊuÛE…À„A‹ƒøss
E‰D†AÿéýE3ɉt$@LD$DA‰6ºÌH‹Ëè82ÀéÜ;ÎMn’À„Àt
HT$DM‹ýD‹áë
D‹æL|$D‹ñI‹ÕE3ÉH‰T$0A‹ÉA‹Ù‰E…ä„fD‹Ã‹<‚…ÿu;Ù…óKD‰Œ…‰éÝE‹Ñ‹Ã…ö„ÆD‹ÛA÷ÛfDƒøst_;Áu‹ÈSD‰ŒAщ•‹ÈLM‰AÿÀE‹A‹	L¯ÇLÁA‹ÊLÁAE‰M‹ÐIÁê E3É;΋uœE…ÒtQ€ƒøst{;Áu‹ÈD‰ŒH‰‹ÈH•D‹ŠHŠA‹ÊÿÀLÁD‰‹IÁè E‹ÐE…Àu¶ƒøst1H‹T$0ÿÃA;Ü…ñþÿÿD‹ÁIÁàA‰M…ÀtaM…íu%èøæþÿÇëJD‹|$ L%¤üÿD‹l$$2ÀE‰ëMI‹ÍIøÌwH•è Ñë3ÒA¸ÌèQ½üÿè¬æþÿÇ"èeìD‹|$ L%UüÿD‹l$$°E3É„À„€E+ý¸&D‰|$ …Ðûÿÿ‹D$,D‹D$(€ÀD+Àt.A@ÿA‹„„¸"…ÀulD‰L$@INE‰LD$DE3ɺÌè?6°H‹àH3Ìè¤üÿH‹œ$@HÄðA_A^A]A\_^]ÃD‰L$@INE‰LD$DE3ɺÌèõ52Àë´ƒøt­E‹E…Òt¥M^E‹ÁH‹Øff„C‹‹K‹A‹ÀAÿÁH¯ÓHÐL‹Â‰IÁè E;ÊuÝE…À„eÿÿÿA‹ƒøss
E‰D†AÿéPÿÿÿ3öLD$DE3ɉt$@ºÌA‰6I‹Ëèq52Àé-ÿÿÿÌÌÌÌÌÌÌÌÌÌH‰\$3ÀD‹ÒH‹ÙD‹È…Òt/E‹Øf„E‹ÁAÿÁ‹ÈB‹ƒI¯ÓHÑH‹ÂB‰ƒHÁè E;ÊuÝH‹\$ÃÌÌÌŠAH¹ÿÿÿöØHÀH#ÁHÿÿÿÃH‰\$H‰t$WHƒì H‹ÙH‹IH…ÉuèÈäþÿÇèêë	èz·þÿ„Àu	HƒÈÿéHƒ{ uèäþÿHƒÏÿÇëjH‹Ë蹄Àt
HKèÁÿÿ„ÀuçHƒ»ˆ‹³€u,H‹KèßHƒÏÿ;ÇtHÿCë‹÷;ÇtH{‹ÈH‹SèÀ«öt‹[(…Ûtè+äþÿ‹þ‰èæé‹Çë‹ÆH‹\$0H‹t$8HƒÄ _ÃH‰\$H‰t$WHƒì H‹AH‹ÙH…ÀtH;AvèæãþÿÇèŸéƒÈÿé¥Hƒy(uèÇãþÿƒÏÿÇé€HƒÁ ëH‹Ëè„Àt
HK è2Àÿÿ„ÀuçHƒ»‹³ˆuŸÿÿë
E3À3ÒH‹Ë蟗ÿÿ@Šø@ŠÇ醺
ëwƒêtmƒêtaƒêt+ƒút2Àëg3ÿ@8ySüÿH‹œ$¸HÄ€A_A^_^]ÃÌÌÌH‰\$UVWAVAWH‹ìHì€H‹ÇAH3ÄH‰EøH‹ùI‹ÙI‹ÈM‹ð‹òÿœ•‹ÈA¿ºñA;Ï…ùfD‰{H…ÿt"ƒe°HU°H‹Ïè±
„À„î‹E°ÿȉC‰¾(HMÐD‹Æ3Òè8küÿD‹ÎLEÐ3ÒI‹Îè/¶…À„¼‹MðH‹×è0H‹Mà3Òf‰Cèý‰C$ƒøÿ„’H‹MØ‹Ðèæ‰C ƒøÿt‹S$H‹MÐèÒ‰C(ƒøÿtk3ÀDNðLE¸H‰E¸A‹×H‰EÀI‹ÎH‰EÈè¹µ…ÀtJHƒc}Äÿÿÿ~
èú“þÿÇ„ë+HcUÄ‹MÀHÁâ HÑH‰SëwAþA;Çv"…ÉuèÍ“þÿÇ	2Àë_ÿ
“‹ÈèF“þÿëíƒùfD‰{¸‰sº ‰3fDÂf‰Ct,Hƒd$(HE°E3ÉH‰D$ E3À3ÒI‹Îÿ+”…ÀtHcE°H‰CAŠÇH‹MøH3ÌèXQüÿH‹œ$¸HÄ€A_A^_^]ÃÌH‰\$UVWAVAWH‹ìHì€H‹ã?H3ÄH‰EøH‹ùI‹ÙI‹ÈM‹ð‹òÿ¸“‹ÈA¿ºñA;Ï…fD‰{H…ÿt"ƒe°HU°H‹ÏèÍ„À„ú‹E°ÿȉC‰¾(HMÐD‹Æ3ÒèTiüÿD‹ÎLEÐ3ÒI‹ÎèK´…À„È‹MðH‹×èL
H‹Mà3Òf‰CèÑH‰C(Hƒøÿ„œH‹MØH‹Ðè·H‰C Hƒøÿ„‚H‹S(H‹MÐèœH‰C0Hƒøÿtk3ÀDNðLE¸H‰E¸A‹×H‰EÀI‹ÎH‰EÈèɳ…ÀtJHƒc}Äÿÿÿ~
è
’þÿÇ„ë+HcUÄ‹MÀHÁâ HÑH‰SëwAþA;Çv"…ÉuèÝ‘þÿÇ	2Àë_ÿ‘‹ÈèV‘þÿëíƒùfD‰{¸‰sº ‰3fDÂf‰Ct,Hƒd$(HE°E3ÉH‰D$ E3À3ÒI‹Îÿ;’…ÀtHcE°H‰CAŠÇH‹MøH3ÌèhOüÿH‹œ$¸HÄ€A_A^_^]ÃÌH‰\$UVWAVAWH‹ìHì€H‹ó=H3ÄH‰EøH‹ùI‹ÙI‹ÈM‹ð‹òÿÈ‘‹ÈA¿ºñA;Ï…ýfD‰{H…ÿt"ƒe°HU°H‹ÏèÝ	„À„ò‹E°ÿȉC‰¾(HMÐD‹Æ3ÒèdgüÿD‹ÎLEÐ3ÒI‹Îè[²…À„À‹MðH‹×è\H‹Mà3Òf‰CèáH‰C Hƒøÿ„”H‹MØH‹ÐèÇH‰CHƒøÿt~H‹S H‹MÐè°H‰C(Hƒøÿtg3ÀDNðLE¸H‰E¸A‹×H‰EÀI‹ÎH‰EÈèݱ…ÀtFƒcƒ}ÄuH‹MÀùÿÿÿw‰Ké‚èþÿÇ„ëAþA;Çv"…ÉuèõþÿÇ	2Àë]ÿ5‹ÈènþÿëíƒùfD‰{¸‰sº ‰3fDÂf‰Ct*Hƒd$(HE°E3ÉH‰D$ E3À3ÒI‹ÎÿS…Àt‹E°‰CAŠÇH‹MøH3Ìè‚MüÿH‹œ$¸HÄ€A_A^_^]ÃÌÌÌ@UH‹ìHƒìpH‹<H3ÄH‰EøH‰MÐ…ÉuHÁé …Éu‹ÂëxHUèHMÐÿ÷…ÀtVLEØ3ÉHUèÿÛ…ÀtBD·UäD·]âƒL$0ÿD·MàD·EÞ·UÚ·MØD‰T$(D‰\$ ètƒøÿuèÝŽþÿÇ„ë
ÿŽ‹ÈèXŽþÿƒÈÿH‹MøH3Ìè¹LüÿHƒÄp]ÃÌÌÌ@UH‹ìHƒìpH‹`;H3ÄH‰EøH‰MÐ…Éu
HÁé …ÉuH‹ÂëzHUèHMÐÿ>…ÀtWLEØ3ÉHUèÿ"…ÀtCD·UäD·]âƒL$0ÿD·MàD·EÞ·UÚ·MØD‰T$(D‰\$ èfsHƒøÿuè#ŽþÿÇ„ë
ÿe‹ÈèžþÿHƒÈÿH‹MøH3ÌèþKüÿHƒÄp]Ã@SHƒì@H‹D$xE·	E···H‹D$p·	D·H‹„$€D‹D‰”$€‰\$xD‰\$pHƒÄ@[éÝrÌ@SHƒì@H‹D$xE·	E···H‹D$p·	D·H‹„$€D‹D‰”$€‰\$xD‰\$pHƒÄ@[é™rÌH‹D$8E‹	E‹‹D‹H‹D$0‹	D‰T$8D‹H‹D$(D‰T$0D‹D‰T$(éZrÌÌH‹D$8E‹	E‹‹D‹H‹D$0‹	D‰T$8D‹H‹D$(D‰T$0D‹D‰T$(é*rÌÌ‹‰H‹ÁÃH‰H‹ÁL‰AÃÌH‰H‹ÁL‰AÃÌ‹‰H‹ÁÃH‰H‹ÁL‰AÃÌ‹‰H‹ÁˉH‹ÁˉH‹ÁˉH‹ÁˉH‹ÁˉH‹ÁÃH‰H‹ÁL‰AÃÌH‰H‹ÁÃÌH‰H‹ÁÃÌ@SHƒì Hƒ9ÿH‹Ùt
H‹	ÿ‹HƒÿHƒÄ [ÃÌÌ@SHƒì H‹ÙH‹	èúþÿHƒ#HƒÄ [ÃÌHƒ9ÿ•ÀË	éégÌ@SHƒìPH‹H‹ÙH

[HcL‹ÂH‹ÂHÁøAƒà?IÁàH‹ÁBöD8uèç‹þÿÇ	ƒÈÿëJL‹KN‹D(3ÉM‹	èÅôÿÿ„Àu13ÒHL$ DB$èUbüÿH‹CD$ L$0H‹‹D$@I‰A ë³3ÀHƒÄP[Ã@SHƒì`H‹H‹ÙH
yZHcL‹ÂH‹ÂHÁøAƒà?IÁàH‹ÁBöD8uèS‹þÿÇ	ƒÈÿëWL‹KN‹D(3ÉM‹	èõ÷ÿÿ„Àu>3ÒHL$ DB8èÁaüÿH‹CD$ L$0H‹D$@IòL$PA òI0ë¦3ÀHƒÄ`[ÃÌÌÌ‹	égÌ@SHƒìPH‹H‹ÙH
ÍYHcL‹ÂH‹ÂHÁøAƒà?IÁàH‹ÁBöD8u觊þÿÇ	ƒÈÿëLL‹KN‹D(3ÉM‹	èeõÿÿ„Àu33ÒHL$ DB0èaüÿH‹CD$ L$0H‹D$@IA ë±3ÀHƒÄP[ÃÌÌ‹	é	fÌ‹	éåfÌ‹	éÝfÌ‹	éñeÌ‹	éÍfÌ‹	éáeÌ@SHƒìPH‹H‹ÙH
YHcL‹ÂH‹ÂHÁøAƒà?IÁàH‹ÁBöD8uè߉þÿÇ	ƒÈÿëLL‹KN‹D(3ÉM‹	èqøÿÿ„Àu33ÒHL$ DB0èM`üÿH‹CD$ L$0H‹D$@IA ë±3ÀHƒÄP[ÃÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì M‹ñI‹ØH‹êH‹ùèV‰þÿ‹0èO‰þÿL‹ÃH‹ÕH‹Ïƒ èf^H‹ØH…Àtè1‰þÿ‰0H‹Ãë%è%‰þÿƒ8"t3Àëè‰þÿE3ÀH‹Õ3ɉ0è0^I‰H‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃÌÌ@SHƒì Hƒ9ÿH‹Ùt
H‹	ÿˆHƒÿHƒÄ [ÃÌÌHƒì(ÿò‡…À•ÀHƒÄ(ÃHƒì(ƒ"ƒyu‹=ÿÿÿw‰°ë
èˆþÿÇ„2ÀHƒÄ(ÃÌÌHƒì(Hƒ"H‹Áyÿÿÿ~ègˆþÿÇ„2ÀëHcI‹HÁá HÈ°H‰
HƒÄ(ÃÌÌH‰\$H‰t$WHƒì L‹Â3ö¶ÑA±‹ÂÁèA„ÁuSM…ÀtGA·A¿fƒøv
fƒéafƒùwfAƒx:tDŠÎE„ÉI@I‹ÈHEÈf91tfƒ9\tfƒ9/uf9qt»€ë»@@fÁ⸀f÷Òf#иfÐfÚM…Àteº.I‹Èè´vH‹øH…ÀtPH-ÛH‹ÈèÉ]…Àt9H*ÛH‹Ïè¶]…Àt&H'ÛH‹Ïè£]…ÀtH$ÛH‹Ïè]…ÀufƒË@H‹t$8·ÃfÁèfƒà8fØ·ÃfÁèfƒàfÃH‹\$0HƒÄ _ÃH‹ÃH‹ÁÃH‹ÁÃ@SHƒì H‹Ú3Ò‰·fƒèAfƒøv
·fƒèafƒøw:fƒy:u,f9Qu¹è^†þÿ2Àë!·fƒèAfƒø·wƒÀ ƒÀ ‰è™U‰°HƒÄ [ÃÌÌÌHƒÈÿÃÌÌÌ@SHƒì H…Éu2Àë`º.è—uH‹ØH…ÀtêHÚH‹Èè¬\…Àt9H
ÚH‹Ëè™\…Àt&H
ÚH‹Ëè†\…ÀtHÚH‹Ëès\…Àuž°HƒÄ [ÃÌÌÌE3ÀH‹ÑH…ÉtH·	A¿fƒøv
fƒéafƒùw	fƒz:°tAŠÀ„ÀHJHEÑfD9u°Ãfƒ:\tfƒ:/ufD9Btê2ÀÃÌÌHƒÈÿ3ÒHÿÀf9Au÷Hƒø‚†fA¹\fA¸/fD9	tfD9upfD9ItfD9AubfD9At[fD9ItTHA·f…ÉtHfA;ÉtfA;ÈtHƒÀëæf9t1HƒÀf9t(·f…ÉtfA;ÉtfA;ÈtHƒÀëæf9tf9Pu°Ã2ÀÃÌÌfƒù\t	fƒù/t3ÀøÃÌÌÌH‰\$H‰l$VWAVHì@H‹°1H3ÄH‰„$0H¾ØH‹ñèâZE3öH…À„ŸI‹Þè„þÿ‹(軄þÿA¸HL$ H‹ÖD‰0èÍYH‹øH…Àt	蘄þÿ‰(ë$è„þÿƒ8"uQè…„þÿE3ÀH‹Ö3ɉ(èžYH‹ØH‹øH…ÿt2HƒÈÿHÿÀfD94GuöHƒøtH‹Ïè‡þÿÿ„ÀtH‹Îÿê„¿;ÇwAŠþH‹Ë趲þÿ@ŠÇH‹Œ$0H3ÌèBüÿLœ$@I‹[(I‹k0I‹ãA^_^ÃÌÌÌHƒ9ÿ•ÀÃ@SHƒì H‹ÙH‹	èo²þÿHƒ#HƒÄ [ÃÌ@USH‹ìHƒìhH‰U¸H‹Ú‰M H…Òu螃þÿ!è·ƒþÿÇé±3ÒHMÐDB$è=ZüÿEЋEðMàK‰C HcU ƒúþuèZƒþÿƒ èrƒþÿÇ	ët…ÒxX;`V}PH‹ÊLTRƒá?H‹ÂHÁøHÁáI‹ÀöD8t-HE ‰U(H‰EÀLM(HE¸‰U0LEÀH‰EÈHU0HMèèÛÿÿëèé‚þÿƒ èƒþÿÇ	躈ƒÈÿHƒÄh[]Ã@USH‹ìHƒìxH‰U¨H‹Ú‰M H…Òu讂þÿ!èÇ‚þÿÇé³3ÒHMÀDB0èMYüÿEÀMÐEàKC HcU ƒúþuèh‚þÿƒ 耂þÿÇ	ët…ÒxX;nU}PH‹ÊLbQƒá?H‹ÂHÁøHÁáI‹ÀöD8t-HE ‰U(H‰E°LM(HE¨‰U0LE°H‰E¸HU0HMèªØÿÿëè÷þÿƒ è‚þÿÇ	èȇƒÈÿHƒÄx[]ÃÌÌ@USH‹ìHƒìxH‰U¨H‹Ú‰M H…Òuèºþÿ!èÓþÿÇé½3ÒHMÀDB8èYXüÿEÀMÐEàKòMðC òK0HcU ƒúþuèjþÿƒ è‚þÿÇ	ët…ÒxX;pT}PH‹ÊLdPƒá?H‹ÂHÁøHÁáI‹ÀöD8t-HE ‰U(H‰E°LM(HE¨‰U0LE°H‰E¸HU0HMè,Ùÿÿëèù€þÿƒ èþÿÇ	èʆƒÈÿHƒÄx[]Ã@USH‹ìHƒìxH‰U¨H‹Ú‰M H…Òuè¾€þÿ!è×€þÿÇé³3ÒHMÀDB0è]WüÿEÀMÐEàKC HcU ƒúþuèx€þÿƒ è€þÿÇ	ët…ÒxX;~S}PH‹ÊLrOƒá?H‹ÂHÁøHÁáI‹ÀöD8t-HE ‰U(H‰E°LM(HE¨‰U0LE°H‰E¸HU0HMèz×ÿÿëè€þÿƒ è€þÿÇ	èØ…ƒÈÿHƒÄx[]ÃÌÌ@SHƒì H‹ÚH…Éu	èaÞÿÿ‹Øë7Hƒd$0HT$0èWH‹L$0…Àu
è|ƒËÿëH‹Óè2ÞÿÿH‹L$0‹Øèö{‹ÃHƒÄ [ÃÌÌ@SHƒì H‹ÚH…Éu	è
àÿÿ‹Øë7Hƒd$0HT$0èEWH‹L$0…Àu
è·{ƒËÿëH‹ÓèÞßÿÿH‹L$0‹Øèž{‹ÃHƒÄ [ÃÌÌ@SHƒì H‹ÚH…Éu	èÁáÿÿ‹Øë7Hƒd$0HT$0èíVH‹L$0…Àu
è_{ƒËÿëH‹Óè’áÿÿH‹L$0‹ØèF{‹ÃHƒÄ [ÃÌÌ@SHƒì H‹ÚH…Éu	è‘ãÿÿ‹Øë7Hƒd$0HT$0è•VH‹L$0…Àu
è{ƒËÿëH‹ÓèbãÿÿH‹L$0‹Øèîz‹ÃHƒÄ [ÃÌÌéÝÿÿÌÌÌéßÿÿÌÌÌéáÿÿÌÌÌé/ãÿÿÌÌÌéÿzÌÌÌH‚Àë9
tHƒÂH;Ðuó3ÀÃH‹ÂÃÌÌ̸csmà;Èt3ÀËÈéÌH‰\$H‰l$H‰t$WHƒì H‹ò‹ùèŽÑE3ÀH‹ØH…Àu3ÀéHH‹H‹ÁH‘ÀH;Êt
98tHƒÀH;ÂuóI‹ÀH…ÀtÒH‹xH…ÿtÉHƒÿuL‰@GüéHƒÿ„ùH‹kH‰s‹pƒþ…ÐHƒÁ0H‘ëL‰AHƒÁH;Êuó8À‹s„ˆ8ŽÀtw8Àtf8ÀtU8‘ÀtD8’Àt38“Àt"8´Àt8µÀuOÇCëFÇCŽë=ÇC…ë4ÇCŠë+ÇC„ë"ÇCëÇC†ëÇCƒëÇC‚H‹Ïÿc‹S¹ÿ׉sëH‹ÏL‰@ÿG‹Îÿ×H‰kƒÈÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌ2ÀÃÌHƒì(¹èêaƒøu°ë…Àu	ƒ=@tï2ÀHƒÄ(ÃÌ@SHìPH‹<)H3ÄH‰„$@H‹Ù¹ôÿÿÿÿS{L‹ÐHPÿHƒúýwYLL$@E3ÀHT$@ŠH„$4ˆ
HÿÂH;Ðt·HƒÃf…ÀuàA+ÑDˆ„$3D‰D$0LL$0L‰D$ I‹ÊDBÿHT$@ÿÍ|H‹Œ$@H3Ìèí9üÿHÄP[ÃH‰\$H‰l$H‰t$WAVAWHƒì0H‹Ù¹èÿ`ƒø„3ö…Àu
ƒ=?„òA¿H-?A‹×L\ÐH‹ÍèT¯3É…À…>L5%?f‰5&AI‹ÖA¸ÿ}yAç…ÀuLVЋ×I‹Î诅À…¬HƒÉÿHÿÁfA94NuöHAHƒø€ÌÌ‹’=Ã̉
Š=ÃÌH‹Ñ&H‹Ñ‹ÈH3ƒá?HÓÈÃÌÌL‹¹&H‹ÁA‹Ð¹@ƒâ?+ÊHÓÈI3ÀÃÌÌE3ÀHAL‹ÈL+ÉIƒÁIÁéH;ÈMGÈM…ÉtIÿÀH‰HIM;ÁuñÃÌÌÌH‹ÁÃH‹a&‹ÊH3@Cƒá?HÓÊH…Ò•ÀÃÌÌÌH‰
)CÃH‰\$WHƒì H‹/&H‹ù‹ËH3Cƒá?HÓËH…Ûu3ÀëH‹Ëÿ³{H‹ÏÿÓH‹\$0HƒÄ _ÃÌÌÌL‹ñ%L‹ÉA‹Ð¹@ƒâ?+ÊIÓÉM3ÈL‰
¼BÃÌÌÌH‹ÊéDuH‹ÊéuH‹óHEHH‰}@LM@H‰D$ E3ÀH‰}H3ÒH‹ÎèbL‹}@A¸H‹UHI‹ÏèH‹ØH…ÀuèKxþÿ{‰8ë:NøH‹ÓHEHH‹ÎLM@H‰D$ èAƒþu‹E@ÿȉS;H‹ÃH‰M;H‹ß‹÷ëVHU8H‰}8H‹ËèRt‹ð…ÀtH‹M8ë1H‹U8H‹ÏH‹ÂH9:tH@HÿÁH98uô‰
;‹÷H‹ÏH‰ý:H‰M8èðsH‰}8H‹Ëèäs‹ÆH‹\$`HƒÄ0A_A^_^]ÃÌH‰\$UVWAVAWH‹ìHƒì0AÿD‹ñƒøvèqwþÿ»‰è)}‹ÃéHBA¸H‹Ó3ÉÿfuH‹5—:3ÿH‰ž:H…ötf9>uH‹óHEHH‰}@LM@H‰D$ E3ÀH‰}H3ÒH‹Îè·L‹}@A¸H‹UHI‹Ïè™H‹ØH…Àuèävþÿ{‰8ë:NøH‹ÓHEHH‹ÎLM@H‰D$ èqAƒþu‹E@ÿȉì9H‹ÃH‰î9H‹ß‹÷ëVHU8H‰}8H‹Ëèór‹ð…ÀtH‹M8ë1H‹U8H‹ÏH‹ÂH9:tH@HÿÁH98uô‰
ž9‹÷H‹ÏH‰ž9H‰M8è‰rH‰}8H‹Ëè}r‹ÆH‹\$`HƒÄ0A_A^_^]ÃÌÌE‹H‹	Hÿ%'uÌÌÌE‹H‹	Hÿ%/tÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒì L‹|$`M‹áI‹øL‹òH‹ÙIƒ'IÇH…ÒtL‰IƒÆ@2í€;"u@„í@¶"@”ÅHÿÃë7IÿH…ÿtŠˆHÿǾ3HÿËÎè8€…ÀtIÿH…ÿtŠˆHÿÇHÿÃ@„öt@„íu°@€þ t@€þ	u¤H…ÿt	ÆGÿëHÿË@2ö€;„Ò€; t€;	uHÿÃëñ€;„ºM…ötI‰>IƒÆIÿ$º3ÀëHÿÃÿÀ€;\tö€;"u1„Âu@„öt€{"uHÿÃë	3Ò@„ö@”ÆÑèëÿÈH…ÿtÆ\HÿÇIÿ…Àu슄ÀtD@„öu< t;<	t7…Òt+H…ÿtˆHÿǾèT…ÀtIÿHÿÃH…ÿtŠˆHÿÇIÿHÿÃéiÿÿÿH…ÿtÆHÿÇIÿé%ÿÿÿM…ötIƒ&Iÿ$H‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A^A\ÃH‹ÄH‰XH‰pH‰xL‰` AWL‹T$03öI‹ÙI‰2IÇH…ÒtL‰HƒÂDŠÎA¼"fD9!uE„ÉA·ÄA”ÁHƒÁëIÿM…Àt·fA‰IƒÀ·HƒÁf…ÀtE„ÉuÅfƒø tfƒø	u¹M…ÀtfA‰pþëHƒé@ŠþA¿\f91„Ífƒ9 tfƒ9	uHƒÁëîf91„²H…ÒtL‰HƒÂHÿA»‹ÆëHƒÁÿÀfD99tôfD9!u7A„Ãu@„ÿt
fD9auHƒÁë
@„ÿD‹Þ@”ÇÑèëÿÈM…ÀtfE‰8IƒÀIÿ…Àuê·f…Àt/@„ÿufƒø t$fƒø	tE…ÛtM…ÀtfA‰IƒÀIÿHƒÁérÿÿÿM…ÀtfA‰0IƒÀIÿé*ÿÿÿH…ÒtH‰2HÿH‹\$H‹t$H‹|$ L‹d$(A_ÃÌÌH‹H‰6ÃÌH‹H‰
6ÃÌH‰H‹ÁÃÌH‰H‹ÁÃÌH‰H‹ÁÃÌH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	è«nHƒ#HƒÄ [ÃÌ@SHƒì H‹ÙH‹	ènHƒ#HƒÄ [ÃÌH‹	3ÀH‹H9t
HRHÿÀHƒ:uóÃÌH‹	3ÀH‹H9t
HRHÿÀHƒ:uóÃÌH‹Hƒ!ÃH‹Hƒ!ÃH‹Hƒ!ÃéçuÌÌÌÂÌéCnÌÌÌéCnÌÌÌH‹ÃH‹ÃH‹ÁÃH‹ÁÃH5ÃH5ÃH‹5ÃH‹5Ã@SHƒì H‹ÙH‹	è×mHƒ#HƒÄ [ÃÌ@SHƒì H‹ÙH‹	è»mHƒ#HƒÄ [ÃÌHƒì(¾Éè|…À•ÀHƒÄ(ÃÌÌ2ÀÃÌ@SHƒì H¸ÿÿÿÿÿÿÿL‹ÊL‹ÑH;Èr3ÀëuH‹óHEHH‰}@LM@H‰D$ E3ÀH‰}H3ÒH‹ÎèXúÿÿL‹}@A¸H‹UHI‹ÏèöþÿÿH‹ØH…ÀuèApþÿ{‰83ÉéŸNøH‹ÓHEHH‹ÎLM@H‰D$ è
úÿÿAƒþu‹E@ÿÈH‰G3‰=3ëÃHU8H‰}8H‹ËèKl‹ð…ÀtH‹M8èlH‹ËH‰}8èl‹þë?H‹U8H‹ÏH‹ÂH9:tH@HÿÁH98uô‰
ë23ÉH‰}8H‰â2èÙkH‹ËH‰}8èÍk‹ÇH‹\$`HƒÄ0A_A^_^]ÃÌÌH‰\$UVWAVAWH‹ìHƒì0AÿD‹ñƒøvèYoþÿ¿‰8èué*H:A¸H‹Ó3ÉÿPmH‹523ÿH‰ˆ2H…ötf9>uH‹óHEHH‰}@LM@H‰D$ E3ÀH‰}H3ÒH‹Îè¡úÿÿL‹}@A¸H‹UHI‹ÏèƒýÿÿH‹ØH…ÀuèÎnþÿ{‰83ÉéŸNøH‹ÓHEHH‹ÎLM@H‰D$ èVúÿÿAƒþu‹E@ÿÈH‰Ü1‰Ê1ëÃHU8H‰}8H‹Ëèàj‹ð…ÀtH‹M8è©jH‹ËH‰}8èj‹þë?H‹U8H‹ÏH‹ÂH9:tH@HÿÁH98uô‰
x13ÉH‰}8H‰w1èfjH‹ËH‰}8èZj‹ÇH‹\$`HƒÄ0A_A^_^]ÃÌÌÌH‰
a1ÃH‰
a1ÃHƒì(H‹Õ:H…Àuè3H‰Ä:HƒÄ(ÃÌÌÌHƒì(H‹©:H…ÀuèWH‰˜:HƒÄ(ÃÌÌÌ@SHƒì H‹s:3ÛH…Àu+H9m:u3Àëèj…Àuóè%H‹
J:…ÀHEËH‹ÁHƒÄ [ÃÌÌÌ@SHƒì H‹3:3ÛH…Àu+H9:u3Àë莅Àuóè±H‹
:…ÀHEËH‹ÁHƒÄ [ÃÌÌÌH‰\$WHƒì 3ÿH9=Ý9t3ÀëHèöpèyH‹ØH…ÀuƒÏÿë'H‹ÈèôH…ÀuƒÏÿëH‰¿9H‰ 93ÉèiH‹Ëèýh‹ÇH‹\$0HƒÄ _ÃH‰\$WHƒì 3ÿH9=y9t3ÀëCèžyH‹ØH…ÀuƒÏÿë'H‹Èè‰H…ÀuƒÏÿëH‰P9H‰A93ÉèžhH‹Ëè–h‹ÇH‹\$0HƒÄ _ÃÌ3Àë€ú=tHÿÀHƒÊÿHÿ€<u÷HÿÁHÊŠ„ÒußÃÌÌE3ÀA‹Àëfƒú=tHÿÀHƒÊÿHÿÂfD9QuöHQHƒÁ·f…ÒuÙÃH‰\$H‰l$H‰t$WAVAWHƒì03öL‹ñ‹Öë<=tHÿÂHƒÈÿHÿÀ@84u÷HÿÁHÈŠ„ÀuàHJºè¹iH‹ØH…ÀtlL‹øA86taHƒÍÿHÿÅA84.u÷HÿÅA€>=t5ºH‹Íè†iH‹øH…Àt%M‹ÆH‹ÕH‹Èèœh3É…ÀuHI‰?IƒÇè†gLõë«H‹ËèI3ÉèrgëH‹ó3ÉèfgH‹\$PH‹ÆH‹t$`H‹l$XHƒÄ0A_A^_ÃE3ÉH‰t$ E3À3ÒèqÌÌÌÌH‰\$H‰l$H‰t$WAVAWHƒì03öL‹ñ‹Öëfƒø=tHÿÂHƒÈÿHÿÀf94Au÷HAHƒÁ·f…ÀuÚHJºè·hH‹ØH…ÀtpL‹øfA96tdHƒÍÿHÿÅfA94nuöHÿÅfAƒ>=t5ºH‹ÍèhH‹øH…Àt&M‹ÆH‹ÕH‹Èè'ž3É…ÀuII‰?IƒÇèfM4në§H‹Ëè‡3ÉèlfëH‹ó3Éè`fH‹\$PH‹ÆH‹t$`H‹l$XHƒÄ0A_A^_ÃE3ÉH‰t$ E3À3Òè
pÌÌH…Ét;H‰\$WHƒì H‹H‹ÙH‹ùëH‹ÈèfHH‹H…ÀuìH‹ËèúeH‹\$0HƒÄ _ÃÌÌÌH…Ét;H‰\$WHƒì H‹H‹ÙH‹ùëH‹ÈèÊeHH‹H…ÀuìH‹Ëè¶eH‹\$0HƒÄ _ÃÌÌÌékuÌÌÌégvÌÌÌH‰\$H‰l$VHƒì@H‹56H…ö…‹ƒÈÿéHƒd$8AƒÉÿHƒd$03Òƒd$(3ÉL‹Hƒd$ ÿ•iHcè…ÀtɺH‹Íè
gH‹ØH…Àt[Hƒd$8AƒÉÿHƒd$03ÒL‹3ɉl$(H‰D$ ÿSi…Àt13ÒH‹Ëè
²3ÉèòdHƒÆHƒ>…sÿÿÿ3ÀH‹\$PH‹l$XHƒÄ@^ÃH‹ËèÊdéLÿÿÿÌH‰\$H‰l$VHƒì0H‹5B5H…öupƒÈÿësƒd$(AƒÉÿL‹3ÒHƒd$ 3ÉÿÜeHcè…ÀtغH‹ÍèLfH‹ØH…ÀtKL‹AƒÉÿ‰l$(3Ò3ÉH‰D$ ÿ¦e…Àt-3ÒH‹Ëè`±3Éè=dHƒÆHƒ>u3ÀH‹\$@H‹l$HHƒÄ0^ÃH‹ËèdékÿÿÿM‹H‹H‹	é
eÌÌM‹H‹H‹	銛ÌÌH‹HƒÈÿHÿÀ€<u÷ÃÌÌÌH‹HƒÈÿHÿÀfƒ…íu.Hƒø@ƒ¢fƒÿ.„˜L‹ÈU@L‹ÃH‹Îè;…Àte鯃ýu*Hƒø@ssfƒÿ_tmHŽ€L‹ÈL‹ÃU?èë:…Àt6镃ýuJHƒøsDf…ÿtfƒÿ,u9HŽL‹ÈL‹Ãºèµ:…Àuyfƒÿ,„ÿÿÿf…ÿ„úþÿÿI^ÿÅé0ÿÿÿƒÈÿH‹\$PH‹l$XH‹t$`HƒÄ0A_A^_ÃE3ÉL‰|$ E3À3Ò3ÉèYÌE3ÉL‰|$ E3À3Ò3ÉèþXÌE3ÉL‰|$ E3À3Ò3ÉèéXÌE3ÉL‰|$ E3À3Ò3ÉèÔXÌÌÌÌ@SHƒì ‹Ùè{¥D‹€¨A‹Ð€âöÚɃûÿt6…Ût9ƒût ƒûtè†RþÿÇè?XƒÈÿëAƒàýëAƒÈD‰€¨ëƒ
ô	ÿAHƒÄ [ÃÌÌÌHƒì(H…Ò„¬H…É„£H;Ê„š¸L‹ÁDH~AJAHB A@ J0AH0B@A@@JPAHPB`A@`MÁJpIÑAHðHƒèu®AJAHB A@ J0AH0B@A@@H‹BPI‰@PƒaèkyHƒÄ(ÃÌÌ@SHìPH‹@þH3ÄH‰„$@‹Ùƒùw:H…Òt5HD$0ÇD$(ƒL‹ÂH‰D$ 3ÒAƒÉÿ3ÉÿÖN…ÀtHT$0‹Ëèzë3ÀH‹Œ$@H3Ìè"üÿHÄP[ÃÌ@USVWATAUAVAWH¬$¸þÿÿHìHH‹µýH3ÄH‰…0L‹µ¸3öH‰T$HI‹ØH‰\$XM‹áL‹úH‹ùH…Éu%3ÀH‹0H3Ìè¶üÿHÄHA_A^A]A\_^[]Ãèi£H‹•°A¹U‰t$0Hˆ¸H‰L$8L¨ÂHˆ¼HðH‰L$@L‹ÀI‹ÌH‰D$Pè»7…À…fƒ?Cu0f9wu*Lì§H‹ÓI‹Ïè„…À…PM…ötA‰6I‹ÇéTÿÿÿHƒËÿH‹óE3ÉHÿÆfD9wuöHþƒsLL‹ÇI‹ÅM+Å·B·+ÊuHƒÀ…Òuì…É„¢H‹D$@L‹ÇL+À·B·+ÊuHƒÀ…Òuì…É„{èKz3ÉH‹×D‹ù„ÀHL$`A”Çèûÿÿ…Àu}E…ÿLD$`L‹|$8HL$`I‹×tè'ëè`„…Àt[LD$`ºƒI‹Íè>úÿÿE3ÿM…ä„ÛH…€HÿÃfD9;…£AƒüJL‹ÈHL$0M‹Æºƒè¥-…À…#HH=ƒ
LD$0fD‰l0A‹ÔH‹ÏèH…ÀtÿÆI^fD9+tHƒÃfD9+…öþÿÿ…ö„ÈH‹ÏètüÿÿH‹Œ$ðH3ÌèÔüÿH‹œ$XHÄA_A^A]A\_^]Ã3ÀëÑL‰l$(LŒ$@A¸ƒHÇD$ UHT$0H‹ËètôÿÿH…Àt£A‹ÝLw(…Ût@I‹HD$0H+зD·A+Èu	HƒÀE…Àuê…ÉtLD$0‹ÓH‹ÏèHH…ÀuA‹íëÿÆÿÃIƒÆ ƒû~±…í…=ÿÿÿé0ÿÿÿI‹Åé8ÿÿÿèCüÿÌE3ÉL‰l$ E3À3Ò3ÉèKÌÌH‰\$ UVWATAUAVAWH¬$ÐýÿÿHì0H‹šñH3ÄH‰… I‹ØLcâH‹ù莗LpA¸ƒHT$`H‹ËL¸ÈHD$@H‰D$(HÇD$ UèvóÿÿE3ÒH…Àu,3ÀH‹ H3ÌèuüÿH‹œ$ˆHÄ0A_A^A]A\_^]ÃI‹ôHL$`HÁæH‹D>(L‹ÈL+É·F·	A+Ðu	HƒÁE…Àuê…Òt¥HD$`HƒËÿHÿÃfD9XuöH]è…@L‹èH…À„wÿÿÿH‹L>(LD$`H‰L$HHSJ‹Œç(H‰L$P‹O‰L$DHHèw3Û…À…ìfƒ|$`CIEH‰D>(uf9\$bu
J‰œç(ëHpè¥íÿÿJ‰„ç(Aƒü…Ñ‹D$@D‹Ã‰GH‹ÓI‹O A‹×9GtI‹×AÿÀI‰×HÿÂH‹ÈHƒú|àëE…ÀtIcÐI‹×I‰I‰×Aƒøu|‹GEHzÇD$0LAš‰D$(AQ‚HEp3ÉH‰D$ è)i…Àt@‹ÓHMp¸ÿÿÂf!HIHcÂHƒøréH‹ùðHMpA¸þè²2‹Ë…À”ÁA‰OëA‰_‹GA‰A‹G‰GëAƒüu	‹D$@‰Gë
Aƒüu‹D$@‰GKdH«˜H‹ÃH‹ËÿæDH‹ÏÿÓ3Û…Àt8H‹D$HH‰D>(J‹Œç(è˜>H‹D$PI‹ÍJ‰„ç(èƒ>‹D$D‰GéµýÿÿH
óH9L$Ht?H‹D>8ƒÉÿðÁƒùu.H‹L>8èN>H‹L>0èD>J‹Œç(è7>H‰\>(J‰œç(AÇEH‹D>(L‰l>8éSýÿÿE3ÉH‰\$ E3À3Ò3Éè×GÌÌÌH‹ÙH‹ˆøH‰
3ùH‹H‰
‘ò‹H‰
„òÃÌÌÌH‹ÁËšÃÌHƒì(ƒùvèzAþÿÇè3GƒÈÿë‡
t‹ÁHƒÄ(ÃÌHiÃH‹
î¹@‹Âƒà?+È3ÀHÓÈH3ÂÃH‹Êél=H‰\$L‰L$ WHƒì I‹ÙI‹ø‹
èôH‹Ïè׋ø‹è6€‹ÇH‹\$0HƒÄ _ÃÌH‰\$H‰t$L‰L$ WATAUAVAWHƒì@I‹ùM‹ø‹
è«I‹H‹H…Òu	HƒËÿé@H‹5oíD‹ÆAƒà?H‹þH3:A‹ÈHÓÏH‰|$0H‹ÞH3ZHÓËH‰\$ HGÿHƒøý‡úL‹çH‰|$(L‹óH‰\$8A½@A‹ÍA+È3ÀHÓÈH3ÆHƒëH‰\$ H;ßrH9uëëH;ßsJHƒËÿH;ûtH‹Ïèg<H‹5äì‹Æƒà?D+èA‹Í3ÒHÓÊH3ÖI‹H‹H‰I‹H‹H‰QI‹H‹H‰Qër‹Îƒá?H33HÓÎH‰H‹ÎÿCBÿÖI‹H‹H‹5ŒìD‹ÆAƒà?L‹ÎL3
A‹ÈIÓÉH‹BH3ÆHÓÈM;ÌuI;Æt M‹áL‰L$(I‹ùL‰L$0L‹ðH‰D$8H‹ØH‰D$ éÿÿÿH‹¼$ˆ3Û‹è£~‹ÃH‹\$pH‹t$xHƒÄ@A_A^A]A\_ÃÌH‹ÄHƒì(‰HLH‰H L‹ÂHP HHè?þÿÿHƒÄ(ÃÌÌH‹ÄHƒì(‰HLH‰H L‹ÂHP HHèÛýÿÿHƒÄ(ÃÌÌL‹½ëH‹ÁA‹Ð¹@ƒâ?+ÊHÓÈI3ÀÃÌÌH‰H‹ÁÃÌ‹‰H‹ÁÃH‰H‹ÁL‰AÃÌ‹‰H‹ÁˉH‹ÁˉH‹ÁÃH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	èÓ:Hƒ#HƒÄ [ÃÌH‰\$H‰l$H‰t$WATAUAVAWHƒì H‹3íL‹ñH‹8H…ÿuƒÈÿéýH‹7L‹ëH‹I3ðI3øE‹ÈAƒá?A‹ÉHÓÎHÓÏHFÿHƒøý‡ÉL‹îL‹çA¿@A‹ÏH‹ÕA+ÉHÓÊI3ÐHƒïH;þraH9tòH‹A‹ÉI3ØH‰HÓËH‹ËÿM@ÿÓL‹œêI‹E‹ÈAƒá?A‹ÉH‹L‹H‹BM3ÐI3ÀIÓÊHÓÈM;ÕuI;Ät•M‹êI‹òL‹àH‹øë‡HƒþÿtH‹ÎèÏ9L‹LêA‹Àƒà?D+øI‹AŠÏHÓÍI3èH‹H‰)I‹H‹H‰iI‹H‹H‰i3ÀH‹\$PH‹l$XH‹t$`HƒÄ A_A^A]A\_ÃÌÌ‹	éi|ÌH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒì H‹3öL‹ùH‹H…ÛuƒÈÿé†L‹¸éA¼@H‹+A‹ÈL‹Kƒá?H‹[I3èM3ÈHÓÍI3ØIÓÉHÓËL;Ë…ÇH+ݸHÁûH;ØH‹ûHGøAD$àHûHDøH;ûrED$ÈH‹×H‹Íè3ÉL‹ðèÁ8M…öu(H{A¸H‹×H‹Íèã~3ÉL‹ðè8M…ö„QÿÿÿL‹éMÞA‹ÀIþƒà?A‹Ì+ÈH‹ÖHÓÊH‹ÃI+ÁI3ÐHƒÀI‹îHÁèI‹ÉL;ËHGÆH…ÀtHÿÆH‰HIH;ðuñL‹¿èA‹ÀA‹Ìƒà?+ÈI‹GH‹A‹ÄHÓÊI3ÐMAI‰H‹–è‹Êƒá?+ÁŠÈI‹HÓÍH3êH‹H‰)A‹ÌH‹tè‹Âƒà?+ÈI‹IÓÈL3ÂH‹L‰BH‹Vè‹Âƒà?D+àI‹AŠÌHÓËH3ÚH‹3ÀH‰YH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A^A\ÃÌÌ‹	é…zÌ‹	é)zÌ‹	é!zÌH‹Hƒ!Ã@SHƒì H‹ÙH‹	èc7Hƒ#HƒÄ [ÃÌH‹ÑH
BéÌH‹ÑH
é}ÌL‹ÜI‰KHƒì8ICI‰CèMK¸MCèIS ‰D$PIK‰D$XèÓùÿÿHƒÄ8ÃÌÌE3ÉL‹ÁH…ÉuƒÈÿÃH‹AH9u$H‹aç¹@‹Âƒà?+ÈIÓÉL3ÊM‰M‰HM‰H3ÀÃÌH‰T$H‰L$UH‹ìHƒì@HEH‰EèLM(HEH‰EðLEè¸HUàHM ‰E(‰EàèùÿÿHƒÄ@]ÃH±éH‰J°ÃÌÌÌHƒì(H
1èTÿÿÿH
=èHÿÿÿ°HƒÄ(ÃÌ°ÃÌ°ÃÌHƒì(èÔÿÿ°HƒÄ(ðÃÌ°ÃÌ@SHƒì H‹“æ¹@‹Â3Ûƒà?+ÈHÓËH3ÚH‹Ëè—>H‹Ëè“~H‹ËèûH‹ËèÀÿÿH‹ËèSÚÿÿ°HƒÄ [ÃÌÌÌ3Éé
üÿÌ@SHƒì H‹
OíƒÈÿðÁƒøuH‹
<íH
ëH;Ëtè5H‰$íH‹
uè|5H‹
q3ÛH‰`èg5H‹
düH‰UèT5H‹
YüH‰JüèA5°H‰DüHƒÄ [ÃÌÌ°ÃÌE3ÀHAL‹ÈL+ÉIƒÁIÁéH;ÈMGÈM…ÉtIÿÀH‰HIM;ÁuñÃÌÌÌHu‘H
~éù{ÌHƒì(èÿ‹H…À•ÀHƒÄ(ÃHƒì(è‹°HƒÄ(ÃH=‘H
FéU|ÌHƒì(裌°HƒÄ(ÃHƒyH6HEAÃÌÌHƒì(è‹H
ø5HƒxHEHH‹ÁHƒÄ(ÃÌÌ@SHƒì H‹ÙèæŠH‹ÐHÌ5HƒzHEBH‰ZHƒÄ [Ã@SHƒì 轊H‹XH…Ût
H‹ËÿG:ÿÓëè’5ÌL‹ÑM…ÀtHT$(èv¶¶HT$(‹Øèg¶HÿÇHƒít…Ût;ØtÒ+Ø€|$8tH‹D$ ƒ ¨ý‹Ãë3ÀH‹\$PH‹l$XH‹t$`HƒÄ@_ÃÌÌH‹ÊéàdþÿH‹ÄH‰XH‰PUVWATAUAVAWHƒì0L‹âLH‹ÙE3í3ÒL‰hHHè'”Eu…Àtƒø„=A‹õëwH‹t$pH…ötm3ÒH‹Îè)–…Àu3ÉH‹þè#2éÚŠI‹ÕI‹ÍL‹Æ„Àt6<"uIÖMÆIÎAŠ„ÀuìH…ÒtH+ÊI‹ÖIÎèÀ3H‹øH…Àu*3ÉèÙ1I‹ýH‹ÏèÎ1H…Ût^3ÒH‹Ëè·•…ÀuPH‹ûëgH‹ÈH‹ÆD8.tŠ€ú"tˆIÎIÆD8(uìDˆ)3Éè13ÒH‹Ïè{•…Àu©3Éèx1H‹Îèp1H‹÷ë'H=ð3ÒH‹ÏèR•…ÀtH=ßH‹ÎèG1I‹õHƒÍÿM…ätL‹ýIÿÇG8,éÍŠ3Ò3ÉL‹Ã„Àt8<"uHÿÂIÿÀHÿÁAŠ„ÀuìH…ÒtH+ʺHÿÁè$,H‹ðH…Àu)3Éè=*3öH‹Îè3*H…ítS3ÒH‹Í莅ÀuEI‰.ëd€;tŠ€ù"tˆHÿÀHÿÇ€?uì3ÉÆèø)3ÒH‹Îèæ…Àu¯3ÉI‰6èà)H‹þë&H=`†3ÒH‹ÏèÂ…ÀuI‰>ë
HJ†I‰3ÿH‹Ëè­)H‹\$PH‹ÇH‹l$XHƒÄ0A^_^ÃHƒd$ E3ÉE3À3Ò3ÉèZ3ÌÌH‹ÄH‰XH‰hH‰p WAVAWHƒì0L‹òL†H‹éE3ÿ3ÒL‰xHHè5‹…Àtƒø„/A‹ßëH‹\$`H‹ûH…Ûtr3ÒH‹ËèXŒ…ÀuI‹ßI‰>éà·I‹×I‹ÏL‹Ãf…Àt=fƒø"uHÿÂIƒÀHÿÁA·f…ÀuçH…ÒtH+ʺHÿÁèª*H‹ðH…Àu*3ÉèÃ(I‹÷H‹Îè¸(H…ít[3ÒH‹Íèá‹…ÀuMI‰.ëlfD9;t·fƒù"tf‰HƒÀHƒÇfD9?uæ3ÉfD‰8èu(3ÒH‹Î裋…Àu§3ÉI‰6è](H‹þë'H=å„3ÒH‹Ïè‹…ÀuI‰>ë
HÏ„I‰I‹ÿH‹Ëè)(H‹\$PH‹ÇH‹l$XH‹t$hHƒÄ0A_A^_ÃE3ÉL‰|$ E3À3Ò3ÉèÑ1ÌHƒì8Hƒd$@Lƒ„3ÒHL$@觉…Àt	ƒøt3ÀëH‹D$@HƒÄ8ÃHƒd$ E3ÉE3À3Ò3Éè‡1ÌÌÌHƒì8Hƒd$@L?„3ÒHL$@è{‰…Àt	ƒøt3ÀëH‹D$@HƒÄ8ÃHƒd$ E3ÉE3À3Ò3Éè;1ÌÌÌH‰\$WHƒì H‹ù3Û‹Ó‹ËL‹ÇŠ„ÀtW<"uHÿÂIÿÀHÿÁAŠ„ÀuìH…Òt>H+ʺHÿÁèó(H…ÀtH‹È늀ú"tˆHÿÁHÿÇ8uíˆH‹Ø3Éèò&H‹Ãë3ÀH‹\$0HƒÄ _ÃH‰\$WHƒì H‹ù3Û‹Ó‹ËL‹Ç·f…Àtcfƒø"uHÿÂIƒÀHÿÁA·f…ÀuçH…ÒtEH+ʺHÿÁèl(H…Àt$H‹Èë·fƒú"tf‰HƒÁHƒÇf9uçf‰H‹Ø3Éèd&H‹Ãë3ÀH‹\$0HƒÄ _ÃÌÌ‹éAŠÌ‹éy‰Ì‹H‹	é.ŠÌÌ‹H‹	éb‰ÌÌ‹H‹	éŠÌÌ‹H‹	éJ‰ÌÌ‹M‹H‹	鯈ÌÌÌ‹H‹	颈ÌÌ‹M‹H‹	铈ÌÌÌ‹M‹H‹	é£ÌÌÌ‹H‹	é–ÌÌ‹M‹H‹	é‡ÌÌÌH‹HƒÈÿHÿÀ€<u÷ÃÌÌÌH‹HƒÈÿHÿÀfƒHT$(èò¥¶HT$(‹Øèã¥HÿÇ…Ût;ØtØ+Ø€|$8tH‹L$ ƒ¡¨ýH‹t$X‹ÃH‹\$PHƒÄ@_ÃÌÂÌ@SHƒìP3ÀH…É•À…ÀuèÑ%þÿÇèŠ+ƒÈÿ釃L$`ÿƒd$xƒd$@ƒd$0D‰D$(ÇD$ @D‹ÊL‹ÁHT$`HL$xèD‹Ø‰D$@ƒ|$xt0…Àt#HcL$`H‹ÁHÁøHdôƒá?HÁáH‹€d8þ‹L$`è÷…ÛtèB%þÿ‰éuÿÿÿ‹D$`HƒÄP[ÃÌ@SHƒìP3ÀH…É•À…Àuè%þÿÇèÒ*ƒÈÿ釃L$`ÿƒd$xƒd$@ƒd$0D‰D$(ÇD$ @D‹ÊL‹ÁHT$`HL$xèÀ‹Ø‰D$@ƒ|$xt0…Àt#HcL$`H‹ÁHÁøH¬óƒá?HÁáH‹€d8þ‹L$`è?…ÛtèŠ$þÿ‰éuÿÿÿ‹D$`HƒÄP[ÃÌH‰\$WHƒìPE‹ÐL‹Á3ÀH‹œ$€H…Û•À…ÀuèO$þÿ»‰è*‹Ãé—ƒÿ3ÀH…É•À…ÀtÙ‹Œ$ˆ…ÉtA÷Áþÿÿ¸”À…Àt»ƒd$@ƒd$D‰L$0D‰L$(D‰T$ D‹ÊH‹ÓHL$@è£	‹ø‰D$Dƒ|$@t,…Àt!HcH‹ÁHÁøHÅòƒá?HÁáH‹€d8þ‹èZ…ÿtƒÿ‹ÇH‹\$`HƒÄP_ÃÌÌH‰\$WHƒìPE‹ÐL‹Á3ÀH‹œ$€H…Û•À…Àuèo#þÿ»‰è')‹Ãé—ƒÿ3ÀH…É•À…ÀtÙ‹Œ$ˆ…ÉtA÷Áþÿÿ¸”À…Àt»ƒd$@ƒd$D‰L$0D‰L$(D‰T$ D‹ÊH‹ÓHL$@è÷	‹ø‰D$Dƒ|$@t,…Àt!HcH‹ÁHÁøHåñƒá?HÁáH‹€d8þ‹èzÿ…ÿtƒÿ‹ÇH‹\$`HƒÄP_ÃÌÌH‹D$8E‹	M‹H‹D‹H‹D$0H‹	D‰T$8D‹H‹D$(D‰T$0D‹D‰T$(é<H‹D$8E‹	M‹H‹D‹H‹D$0H‹	D‰T$8D‹H‹D$(D‰T$0D‹D‰T$(é8	H‹D$8E‹	M‹H‹D‹H‹D$0H‹	D‰T$8D‹H‹D$(D‰T$0D‹D‰T$(éÌH‹D$8E‹	M‹H‹D‹H‹D$0H‹	D‰T$8D‹H‹D$(D‰T$0D‹D‰T$(éÈL‹ÜI‰[I‰kI‰s WAVAWHƒì0Lcñ3ÛM‹ÖAˆAƒâ?H
ªðI‹ÆIÁâHÁøI‹ñA‹øH‹êH‹ÁBöD8€„A¿@E…Çu"IK‰\$PèÆÂÿÿ…À…‹D$PA#Çu?ºï‹ÏA#ÏA¿ù@t>ÿÿºÿ¿ÿÿ…Âtþÿ…Ât üÿ…ÂuÆëøëÁ¹‹Ç#Á;ÁuDˆ>ëˆ÷Ç„„öE@…z‹EºÀ#‹ˋû=@t=€t3;Â…V‹E…À„KA;Çvƒøv\ƒø…8¿…É„ÎA¸‰\$PHT$PA‹Îèò…À~ƒÿDûƒøÿtEA;ÇtWƒø…‡|$PuDÆéˆE‹Ç3ÒA‹Î誉H…ÀtzE3À3ÒA‹Î蘉Hƒøÿuè1 þÿ‹é¶‹MÁéévÿÿÿ·D$P=þÿu
è þÿÇëÐ=ÿþuE3ÀI‹×A‹ÎèM‰HƒøÿtµDˆ>ëE3À3ÒA‹Îè5‰Hƒøÿt…ÿtY¾‹û‰\$PƒétƒùuÇD$PÿþA‹ÿëÇD$P¿…ÿ~(D‹ÇHcÃHT$PD+ÃHÐA‹ÎèaÃøÿ„FÿÿÿØ;ûØ3ÀH‹\$XH‹l$`H‹t$hHƒÄ0A_A^_ÃE3ÉH‰\$ E3À3Ò3Éè[%ÌÌÌHƒìHA‹@M‹ÐA@L‹ÊHƒd$0‰D$(A‹@E‹@A‹R‰D$ ÿ²HƒÄHÃÌHƒì(‹ÑD‹ÁƒâtHƒêt!ƒútèïþÿÇè¨$ƒÈÿë.¸Àë'÷Á•ÁAöÀ•À"ÈöÙÀ%€@븀HƒÄ(ÃHƒì(¸#ÈteùtVùtGùt8ùtEùt!ùt';ÈtèfþÿÇè$ƒÈÿë!¸ë¸ë¸ë¸ë¸HƒÄ(ÃH‰\$H‰l$VWAVHƒì0H‹ÙÆ‹ÊE‹ñA‹è‹ú¾ÿÿÿÿƒátFƒét ƒùtèõþÿÇè®#‹Æë-¸Àë&÷•Áö•À"ÈöÙÀ%€@븀‰C¹‹Ç#Át^=tP=tB=t4=tB=t=t&;ÁtèxþÿÇè1#‹Æë!¸ë¸ë¸ë¸ë¸‰CƒítJƒít>ƒít2ƒít&ƒí@tè'þÿÇèà"ë&3ö{€@”Æë¾ë¾ë	¾ë3öƒc@µ€‰sÇC€@„ýt€¾€…þu÷Ç@uHL$Xè¾ÿÿ…Àu9t$Xt@+¹…ùt‹8ó÷ÐA#Æ@„ÅuÇC@öÇ@tºkºkƒKºçs	Kºç
sºk@öÇ tºkë@öÇtºkH‹l$`H‹ÃH‹\$PHƒÄ0A^_^ÃHƒd$ E3ÉE3À3Ò3Éè<"ÌÌÌÌHƒì(ƒétKƒét?ƒét3ƒét'ƒù@tèþÿÇè»!ƒÈÿë$3Àú€”Àë¸ë¸ë	¸ë3ÀHƒÄ(ÃÌHƒì8ºás2ÀHƒÄ8Ã÷Á@t°ëïHL$@èù¼ÿÿ…Àu
|$@€•ÀëÔHƒd$ E3ÉE3À3Ò3Éè!ÌÌÌH‰\$H‰t$WHƒì HcÙH
_êH‹ÓH‹ÃHÁøƒâ?HÁâH‹ÁŠL8öÁHux„ÉytA¸HƒÊÿ‹Ë舄H‹øHƒøÿuèþþÿ8ƒtMèþÿ‹ëF3öHT$0‹Ëf‰t$0DFè^…Àufƒ|$0uH‹×‹Ëè~ƒøÿtÅE3À3Ò‹Ëè+„Hƒøÿt³3ÀH‹\$8H‹t$@HƒÄ _ÃÌÌÌH‹Ä‰PL‰@L‰H Hƒì(H@D‹è®ôÿÿHƒÄ(ÃÌL‹ÜE‰CM‰K SHƒì@ƒd$(MKèIC M‰KØD‹ƒËÿ‰\$0èèõÿÿ‹L$0…ÀEË‹ÁHƒÄ@[ÃÌÌÌéÏõÿÿÌÌÌH‹ÄH‰XH‰hH‰pWHƒìPHƒ`èH‹òH‹éHPèI‹ÈA‹ùèÒñ…ÀuƒÈÿëC‹„$D‹ÏH‹\$@H‹Ö‰D$0L‹Ã‹„$ˆH‹Í‰D$(‹„$€‰D$ èÆH‹Ë‹øè‹ÇH‹\$`H‹l$hH‹t$pHƒÄP_ÃÌHƒì8A‹ÁÇD$(D‹L$`E‹ÐL‹ÚH‰L$ D‹ÀA‹ÒI‹ËèõÿÿHƒÄ8ÃÌÌH‹Ä‰PL‰@L‰H Hƒì(H@D‹è2ôÿÿHƒÄ(ÃÌL‹ÜE‰CM‰K SHƒì@ƒd$(MKèIC M‰KØD‹ƒËÿ‰\$0è”õÿÿ‹L$0…ÀEË‹ÁHƒÄ@[ÃÌÌÌé{õÿÿÌÌÌH‹ÄH‰XH‰xL‰@UATAUAVAWHh¹HìÀE‹áM‹ðD‹MwH‹úD‹EoH‹ÙA‹ÔHMÿèúÿÿÈfsÙfI~ÏIÁï L‰}ïE§ò@òEÏòE·Aƒÿÿuèwþÿƒ ƒÿèŒþÿ‹éGèPõ‰ƒøÿuèTþÿƒ ƒÿèiþÿÇëÐHƒd$0LM׋M¯A‹ÄH‹U§E‹ÇHƒeßÇH‹]·ÁèHÁë ÷Ð]·ƒà‰\$(‰L$ I‹ÎHÁê ÇE׉EçH‰]Çÿ©D‹u«¹ÀH‰E¿L‹èHƒøÿ…‚A‹Æ#Á;ÁuFAöÄt@Hƒd$0LM׋M¯AºöD‰u«E‹ÇH‹U§‰\$(‰L$ H‹M_HÁê ÿMH‰E¿L‹èHƒøÿu3HcL=–æH‹Áƒá?HÁøHÁáI‹Ç€d8þÿÉ‹ÈèþÿéÜþÿÿI‹Íÿ…ÀuQÿª‹È‹ØèáþÿHcL=GæH‹Êƒâ?HÁùHÁâI‹Ï€d8þI‹Íÿ_…Û…ŽþÿÿèþÿÇ
é~þÿÿŠ]§ƒøu€Ë@ëƒøu€Ë‹I‹ÕèÜòHcL=æåH‹Á€ËHÁøƒá?HÁáˆ]§I‹Lj\8HcH‹Áƒá?HÁøHÁáI‹ÇÆD9AöÄt‹è+ûÿÿD‹è…Àu3L‹m¿E§LMŸ‹òMÏHUÿE‹Ä)EÿÆEŸòMè˜ôÿÿ…ÀtD‹è‹èbA‹ÅéHcŠEŸH‹Êƒâ?HÁùHÁâI‹ψD9HcH‹Âƒâ?HÁøHÁâI‹ÇA‹ÄÁè$€d=þD=öÃHu AöÄtHcH‹Áƒá?HÁøHÁáI‹Ç€L8 ¹ÀA‹Æ#Á;Á…¡AöÄ„—I‹ÍÿH‹MÇLM×Hƒd$0AºöD‹Eï‰L$(‹M¯‰L$ H‹M_D‰u«H‹U§HÁê ÿ6H‹ÐHƒøÿu3ÿ׋ÈèþÿHcH‹Áƒá?HÁáHÁøI‹Ç€d8þ‹è_óéÉüÿÿHcH‹Áƒá?HÁøHÁáI‹ÇH‰T(3ÀLœ$ÀI‹[0I‹{8I‹ãA_A^A]A\]ÃÌHƒì8A‹ÁÇD$(D‹L$`E‹ÐL‹ÚH‰L$ D‹ÀA‹ÒI‹Ëè[ñÿÿHƒÄ8ÃÌÌH‰\$H‰t$WHƒì0H‹ùH…Éu3ÀH‹\$@H‹t$HHƒÄ0_ÃHƒËÿHÿÀ<u÷HKè%–ÿÿH‹ðH…ÀtÐL‹ÇHSH‹ÈèÖ…ÀuH‹ÆëºHƒd$ E3ÉE3À3Ò3ÉèŒÌÌÌÌH‰\$ UVWATAUAVAWHƒì0LcéL‹òI‹ýHPãƒç?M‹ýIÁÿHÁçJ‹úH‹L8(H‰Œ$€M…Àt
A€>
u€L88ë€d88ûO$I‹öI‹ÞM;ôƒInŠ<„ã<
tˆHÿÃHÿÆHÿÅéÄI;ìs€}
uHƒÆÆ
HƒÅHÿÃé¦Æ
ëÏHƒd$ LL$xA¸HT$pHÿÆHÿÅÿ°…Àtfƒ|$xt_HŽâJ‹úöD88HtŠL$p€ù
uˆëMÆ
J‹úˆL8:ë@€|$p
u
I;ÞuÆ
ë,A¸HƒÊÿA‹Íè¢|€|$p
H:âtëH/âÆ
HÿÃH‹Œ$€I;ô‚ÿÿÿëJ‹úŠD98¨@uˆD98늈HÿÃI+Þ‹ÃH‹œ$ˆHƒÄ0A_A^A]A\_^]ÃÌÌ@SUVWATAUAVAWHƒì8LcéLÁáI‹ýM‹ýIÁÿƒç?HÁçL‹òA¹
K‹úH‹L8(H‰Œ$˜M…Àt
fD9
u€L88ë€d88ûN$BH‹òH‹ÚI;Ôƒ¢Hjº
·fƒø„nf;Âtf‰HƒÃHƒÆHƒÅéšI;ìsfD9MuHƒÆfD‰HƒÅHƒÃë|f‰ëÌHƒd$ LŒ$A¸H”$€HƒÆHƒÅÿ…À„䃼$„ÖLÓàA¹
K‹úöD88Hte·„$€fA;ÁufD‰º
H‹Œ$˜I;ô‚7ÿÿÿé˹
f‰„$ˆf‰3ÒK‹úŠ„ˆHψD:HÿÂHƒú|åK‹úDˆL8<ë­fD9Œ$€uI;Þu
fD‰HƒÃë“HÇÂþÿÿÿA‹ÍDBèŒzA¹
L#àfD9Œ$€„dÿÿÿAQf‰HƒÃéYÿÿÿº
Løßf‰HƒÃDJýé=ÿÿÿK‹úŠD98¨@uˆD98ë
·f‰HƒÃI+ÞHÑûHHƒÄ8A_A^A]A\_^][ÃÌÌÌLcÁH
¢ßI‹ÀAƒà?HÁøIÁàH‹ÁBˆT:ÃÌLcÁL~ßM‹Èf‰T$IÁù3ÒAƒà?IÁàK‹ÊŠDIȈD:HÿÂHƒú|èK‹ÊBÆD<
ÃÌL‰L$ ‰L$SUVWATAUAVAWHƒì8I‹éLá<ûÿLcÉL‹òI‹ùM‹ùIÁÿƒç?HÁçK‹„ú@¢L‹l8(M…Àt€:
u€L88ë€d88ûN$H‹òH‹ÚI;Ôƒ5HjŠ<„ø<
tˆHÿÃHÿÆHÿÅéÙI;ìs€}
uHƒÆHƒÅÆ
é»Æ
ëÒHƒd$ LŒ$A¸H”$ˆI‹ÍHÿÆHÿÅÿw…Àt}ƒ¼$tsL<ûÿK‹„ú@¢öD88Ht!ŠŒ$ˆ€ù
uˆëZÆ
K‹„ú@¢ˆL8:ëI€¼$ˆ
u	I;Þ„pÿÿÿ‹Œ$€A¸HƒÊÿèUx€¼$ˆ
Lª;ûÿtëLŸ;ûÿÆ
HÿÃI;ô‚ÿÿÿëK‹Œú@¢ŠD98¨@uˆD98늈HÿÃD‹Œ$€H‹¬$˜A+Þu3Àé;K‹Œú@¢€|99u‹Ãé%HcÃI^ÿHØö€uHÿÃ骺ëƒúwI;ÞrHÿËÿ¶B€¼`tãD¶C¾„`…Àuè,þÿÇ*ƒÈÿéÆÿÀ;Âu‹ÂHØëUöD98Ht;HÿÃDˆD9:ƒúrŠHÿÃK‹Œú@¢ˆD9;ƒúuŠHÿÃK‹Œú@¢ˆD9<‹ÂH+Øë÷ÚA¸HcÒA‹Éèw‹„$ A+Þ‰D$(D‹ËM‹ÆH‰l$ 3Ò¹éýÿ&‹Ð…ÀuÿÚ‹Èè
þÿéXÿÿÿH
7:ûÿJ‹Œù@¢€d9=ý;ÕÀ$ÀD9=‹ÂHÀHƒÄ8A_A^A]A\_^][ÃÌÌÌH‰\$NBLcÙL‹ÊL‹ÂH‹ÂI;ÒskHƒÂ»
A·fƒùt7fƒù
uI;Òsf9uIƒÀf‰HƒÂHƒÀëf‰IƒÀHƒÀHƒÂM;ÂrÁë!I‹ÓLÖÛƒâ?I‹ËHÁùHÁâI‹È€L8H‹\$I+ÁHÑøHÀÃH‰\$‰L$VATAUAVAWHƒì E‹øL‹êHcñƒþþuègþÿƒ èþÿÇ	éŅɈ¥;5f߃™L‹öL‹æIÁüHOÛAƒæ?IÁæJ‹àB¶L08ƒátq3ÀAøÿÿÿ–À…Àuèþÿƒ èþÿÇë_‹ÎèÔçƒËÿHÛJ‹àBöD08uèñþÿÇ	èÆþÿƒ ëE‹ÇI‹Õ‹Îè<‹Ø‹Îèwè‹Ãëè¢þÿƒ èºþÿÇ	èsƒÈÿH‹\$XHƒÄ A_A^A]A\^ÃÌH‰\$H‰T$UVWATAUAVAWHƒì`LcéL‹ÊE‹àAƒýþuèKþÿ3ö‰0èbþÿÇ	é	3ö…ɈèD;-FÞƒÛI‹íDFƒå?L‰D$HI‹ÕHÁåHÁúLÚH‰T$@I‹ÓD„D(8„¦AüÿÿÿvèÝ
þÿ‰0èö
þÿÇé˜E…ä„yöD(8…nM…ÉtÐH‹L((H‹ÞD¾T(9¿H‰L$8A‹ÊDˆ”$ A+ÈtA+Èu
A‹Ä÷ÐA„ÀtE‹ôM‹ùé A‹Ä÷ÐA„Àuèa
þÿ‰0èz
þÿÇè3é†E‹ôAÑîD;÷DB÷A‹ÎèÑ3ÉH‹Øè‡3Éè€L‹ûH…Ûuè7
þÿÇè
þÿÇé=3ÒA‹ÍDBèosH‹T$@LÙDŠ”$ A¸I‹ÓH‰D)0I‹Ó‹þL‰|$PA¹
öD(8Ht}ŠL(:A:ÉttE…ötoAˆAÿÎI‹ÓMøA‹øDˆL(:E„ÒtUI‹ÓŠL(;A:ÉtHE…ötCAˆAyøI‹ÓMøAÿÎDˆL(;E:Ðu(I‹ÓŠL(è9þÿÇ	ƒÈÿHƒÄ(ÃÌÌÌ‹	ééáÌH‰\$WHƒì ‹ùèËäHƒøÿu3ÀëUH‹þÔ¹ƒÿu	@„¸¸u
;ùuö@xtè˜ä¹H‹Øè‹äH;ÃtÁ‹ÏèäH‹Èÿò…Àu­ÿH‹\$0HƒÄ _Ã̉L$Hƒì8Hcуúþuèoþÿƒ è‡þÿÇ	ët…ÉxX;uØsPH‹ÊLiÔƒá?H‹ÂHÁøHÁáI‹ÀöD8t-HD$@‰T$P‰T$XLL$PHT$XH‰D$ LD$ HL$Hèõýÿÿëèþþÿƒ èþÿÇ	èÏ
ƒÈÿHƒÄ8ÃÌÌÌH‰\$WHƒì Hcù‹Ïè¨ãHƒøÿu3ÛëWH‹ÛÓ¹ƒÿu	@„¸¸u
;ùuö@xtèuã¹H‹ØèhãH;ÃtÁ‹Ïè\ãH‹ÈÿÏ…Àu­ÿÝ‹Ø‹Ïè„âH‹×LzÓƒâ?H‹ÏHÁùHÁâI‹ÈÆD8…Ût‹ËèèþÿƒÈÿë3ÀH‹\$0HƒÄ _ÃÌÌH‡H‹ÂÃÌH‹ÃH‹‰ÚÃH‰\$WHƒì H‹?³HƒøuJH
ú\ÿ,3ÛH…ÀuH‡³3Àë+ºVH‹Èÿ¬H‹øH…ÀtßH‹ÈÿCÿ×H‹ÈH‡
ï²H‹\$0HƒÄ _ÃH…Ét7SHƒì L‹Á3ÒH‹
Úÿ¨…ÀuèŸþÿH‹Øÿæ‹Èè×þÿ‰HƒÄ [ÃÌÌÌ@SHƒì H‹ÙHƒùàwE„Àu0ºwë
E„Àu$ºoA°AŠÐë$‹©Àuºè닺às@ŠÖëºè‰²„ÒH‹Æ•ÀHC„Ò…ÒþÿÿE„ÒtHƒÃf9+t÷E„Òuf93…¿ÆGéÆA¸H¼KH‹Ë舅À…™HƒÃëHƒÃf9+t÷fƒ;=…€HƒÃf9+t÷A¸H…KH‹Ëè}\…Àu
HƒÃ
º/ëJA¸HrKH‹ËèZ\…Àu
HƒÃº/ë'A¸H_KH‹Ëè7\…ÀuHƒÃº/ëHƒÃf9+t÷é8ÿÿÿèîñýÿÇè§÷ÿÿH‹\$@H‹ÇH‹l$HH‹t$PHƒÄ0_ÃÌÌÌH‰\$H‰|$L‰L$ UH‹ìHƒì`H‹ùA‹ØHMèèzúÿÿò‹@òE؉Eà„Àu3Àë`D‹EØHMÐD‹ËÇD$ €H‹×è¼×ÿÿ…ÀuÝÿž´H‹M(‹EÜð	AH‹E(ƒ`H‹E(Hƒ`(H‹E(Hƒ`H‹E(Hƒ ‹EÐH‹M(‰AH‹E(H‹\$pH‹|$xHƒÄ`]ÃÌÌÌH‰\$H‰|$L‰L$ UH‹ìHƒì`H‹ùA‹ØHMèèfüÿÿò‹@òE؉Eà„Àu3Àë`D‹EØHMÐD‹ËÇD$ €H‹×è Ûÿÿ…ÀuÝÿî³H‹M(‹EÜð	AH‹E(ƒ`H‹E(Hƒ`(H‹E(Hƒ`H‹E(Hƒ ‹EÐH‹M(‰AH‹E(H‹\$pH‹|$xHƒÄ`]ÃÌÌÌM‹H‹	é­ëýÿÌM‹H‹	éEÌM‹H‹	鹸ÿÿÌM‹H‹	é­¸ÿÿÌM‹H‹	顸ÿÿÌM‹H‹	éIZÌM‹H‹	é=ZÌM‹H‹	é1ZÌH‹D$(E‹	E‹H‹D‹H‹	D‰T$(é6ÖÿÿÌÌH‹D$(E‹	E‹H‹D‹H‹	D‰T$(éªÚÿÿÌÌ‹¨@t2ÀÃÈ@‰°ÃÌÌ̺)°ÃÌ€:t2ÀÃÆ°ƒ	ÃÌÌÌ€:t2ÀÃÆ°ƒ	 ÃÌÌÌ‹º…Ât2ÀÉ°ÃÌÌÌ‹©Àt2Àú艰ÃÌÌÌ€:t2ÀÃÆ°ºiÃÌ€:t2ÀÃÆ°ºqÃÌ€:L‹Át2ÀÃÆ‹¨uôƒàþƒÈ‰°‹IƒáüƒÉA‰HË©Àt2Àú艰ÃÌÌÌH‹ÄH‰XH‰hH‰p WHƒìPH‹éI‹ùHHèA‹ðèš÷ÿÿ3Ûò‹@òD$0‰D$8:ÃtGD‹D$0HL$pD‹ÎÇD$ €H‹ÕèÚÔÿÿ…Àu&ÿ¼±‹D$4ð	G‹D$p‰_H‰_(H‰_H‰H‹ß‰GH‹l$hH‹ÃH‹\$`H‹t$xHƒÄP_ÃH‹ÄH‰XH‰hH‰p WHƒìPH‹éI‹ùHHèA‹ðèšùÿÿ3Ûò‹@òD$0‰D$8:ÃtGD‹D$0HL$pD‹ÎÇD$ €H‹ÕèÒØÿÿ…Àu&ÿ ±‹D$4ð	G‹D$p‰_H‰_(H‰_H‰H‹ß‰GH‹l$hH‹ÃH‹\$`H‹t$xHƒÄP_ÃH‰\$WHƒì H‹_šH‹ù‹ËH3ƒ¼ƒá?HÓËH‹ËÿìïE3À3ÒH‹ÏH‹ÃH‹\$0HƒÄ _HÿàH‹%š¹@‹Âƒà?+È3ÀHÓÈH3ÂÃH‰\$H‰t$L‰L$ WHƒì I‹ùI‹Ø‹
è,H‹L‹H‹á™‹Âƒà?»@‹Ë+ÈIÓÈL3ÂL‰ö»SÁH
Lÿÿÿÿ>î‹ðL‹­™A‹Ðƒâ?+Ú‹Ë3ÒHÓÊI3ÐH‰Ä»‹è,‹ÆH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‹ÄHƒì(‰HLH‰H L‹ÂHP HHèGÿÿÿHƒÄ(ÃÌÌH‹I™H‹Ñ‹ÈH3ƒá?HÓÈÃÌÌL‹1™H‹ÁA‹Ð¹@ƒâ?+ÊHÓÈI3ÀÃÌÌ‹‰H‹ÁÃH‰H‹ÁÃÌ‹‰H‹ÁÃH‰þÿÿË	é+Ì@SHƒì L‹ã˜H‹ÑA‹À»@ƒà?‹Ë+ÈH‹H‹HÓÊH
QþÿÿI3ÐH‰çºSÁÿ6íL‹§˜A‹Ðƒâ?+Ú3ÒŠËHÓÊI3ÐH‰¾ºHƒÄ [Ë	éõ*Ì@SHƒì L‹s˜L‹ÉA‹Ð»@ƒâ?‹Ë+ÊIÓÉH
çýÿÿM3ÈSÁL‰
zºÿÌìL‹=˜A‹Ðƒâ?+Ú3ÒŠËHÓÊI3ÐH‰TºHƒÄ [ÃÌÌHƒÈÿÃÌÌÌL
áI3ÉLÔIHÕIéÄL
áI¹LÍIHÎIé¥ÌL
ÙI¹LÅIHÆIé…ÌL
ÙI¹LÅIHVéeÌL
ÁI¹L­IHNéEÌL
©I¹L•IH>é%ÌL
‘I¹L}IH6éÌL
yI¹LeIHfIéåÌL
qI¹L]IH^IéÅÌL
qI¹	L]IH^Ié¥ÌL
iI¹
LUIHVIé…ÌL
qI¹L]IH^IéeÌL
yI¹LeIHfIéEÌL
yI¹
LeIHfIé%ÌL
qI¹L]IH^IéÌL
mI¹L]IH^IéåÌL
yI¹LeIHfIéÅÌL
qI¹L]IH^Ié¥ÌL
yI¹LeIHfIé…ÌL
I¹LmIHnIéeÌL
I¹LmIHŽéEÌL
iI¹LUIHVIé%ÌL
I¹LmIHnIéÌL
II¹L5IH6IéåÌL
aI¹LMIHNIéÅÌL
aI¹LMIHNIé¥ÌL
aI¹LMIHNIé…ÌL
YI¹LEIHFIéeÌL
II¹L9IH6IéEÌL
=I¹L-IH.Ié%ÌL
9I¹L%IH&IéÌL
9I¹L%IH&IéåÌH‰\$H‰l$H‰t$WAVAWHƒì H‹êH‹ùH;Ê„L=êûÿ‹7I‹œ÷ H…ÛtHƒûÿttëmM‹´÷ ,3ÒI‹ÎA¸ÿzçH‹ØH…Àu ÿ<æƒøWuE3À3ÒI‹ÎÿYçH‹Øë3ÛH…ÛuHƒÈÿI‡„÷ ëH‹ÃI‡„÷ H…Àt	H‹Ëÿ†äH…Ûu(HƒÇH;ý…jÿÿÿ3ÀH‹\$@H‹l$HH‹t$PHƒÄ A_A^_ÃH‹ÃëâH‰\$H‰l$H‰t$WATAUAVAWHƒì D‹ñL=ûÿM‹áI‹èL‹êK‹Œ÷0¡L‹ö’HƒÏÿA‹ÂI‹ÒH3уà?ŠÈHÓÊH;ׄ%H…ÒtH‹ÂéM;Á„£‹uI‹œ÷ H…ÛtH;ßtzësM‹¼÷ ,3ÒI‹ÏA¸ÿRæH‹ØH…Àu ÿåƒøWuE3À3ÒI‹Ïÿ1æH‹Øë3ÛL=cûÿH…Ûu
H‹ÇI‡„÷ ëH‹ÃI‡„÷ H…Àt	H‹ËÿXãH…ÛuUHƒÅI;ì…dÿÿÿL‹’3ÛH…ÛtJI‹ÕH‹ËÿãH…Àt2L‹’º@A‹Èƒá?+ÑŠÊH‹ÐHÓÊI3ÐK‡”÷0¡ë-L‹בë¸L‹ΑA‹Â¹@ƒà?+ÈHÓÏI3úK‡¼÷0¡3ÀH‹\$PH‹l$XH‹t$`HƒÄ A_A^A]A\_ÃH‹ÄH‰XH‰hH‰pH‰x AVHƒì ‹ùL5rûÿI‹„þ 3íH…Àt
HƒÉÿH;ÁHDÅësI‹´þ ,3ÒH‹ÎA¸ÿýäH‹ØH…Àu!ÿ¿ãƒøWuE3À3ÒH‹ÎÿÜäH‹ØëH‹ÝH…ÛuHƒÉÿI‡Œþ 3ÀëH‹ÃI‡„þ H…Àt	H‹ËÿâH‹ÃH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒì I‹èH‹úL‹ùI;ЄL%’ûÿ‹7I‹œô H…ÛtHƒûÿttëmM‹´ô ,3ÒI‹ÎA¸ÿ"äH‹ØH…Àu ÿäâƒøWuE3À3ÒI‹ÎÿäH‹Øë3ÛH…ÛuHƒÈÿI‡„ô ëH‹ÃI‡„ô H…Àt	H‹Ëÿ.áH…ÛuHƒÇH;ý…jÿÿÿ3ÛH…Ûu3ÀëI‹×H‹ËÿåàH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A^A\ÃÌÌ@SHƒì 3ÒA¸H‹ÙÿmãH…Àu!ÿ2âƒøWuE3À3ÒH‹ËHƒÄ [Hÿ%Iã3ÀHƒÄ [ÃÌ@SHƒì L
GA3ÉL:AH;Aè*üÿÿH‹ØH…ÀtH‹ÈÿõäH‹ÃHƒÄ [Hÿà¸HƒÄ [ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒìPA‹ùI‹ð‹êL
ü@L‹ñLê@Hë@¹è½ûÿÿH‹ØH…ÀtWH‹ÈÿˆäH‹Œ$ D‹ÏH‹„$€L‹ÆH‰L$@‹ÕH‹Œ$˜H‰L$8H‹Œ$H‰L$0‹Œ$ˆ‰L$(I‹ÎH‰D$ ÿÓë23ÒI‹Îèà‹ÈD‹Ï‹„$ˆL‹Æ‰D$(‹ÕH‹„$€H‰D$ ÿÀâH‹\$`H‹l$hH‹t$pH‹|$xHƒÄPA^ÃÌH‹ÄH‰XH‰hH‰p H‰HWHƒì@I‹ùI‹ð‹êL
%@L@¹H@èÑúÿÿH‹ØH…ÀtH‹ÈÿœãH‹L$PL‹ÏL‹Æ‹ÕÿÓë0HD$PH‰D$0LL$$¸LD$0HT$(‰D$$HL$ ‰D$(è£óÿÿH‹\$XH‹l$`H‹t$hHƒÄ@_ÃÌÌH‰\$WHƒì H‹ùL
°?¹Lœ?H-è<úÿÿH‹ØH…ÀtH‹ÈÿãH‹ÏÿÓëÿòàH‹\$0HƒÄ _ÃÌÌÌH‰\$WHƒì ‹ÙL
a?¹LM?HîèåùÿÿH‹øH…ÀtH‹Èÿ°â‹Ëÿ×ë‹Ëÿ²àH‹\$0HƒÄ _ÃÌÌÌH‰\$WHƒì ‹ÙL
?¹Lý>H¦èùÿÿH‹øH…ÀtH‹ÈÿXâ‹Ëÿ×ë‹ËÿJàH‹\$0HƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì H‹ÚL
»>‹ùHj¹Lž>è-ùÿÿH‹ðH…ÀtH‹ÈÿøáH‹Ó‹ÏÿÖëH‹Ó‹ÏÿìßH‹\$0H‹t$8HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x AVHƒì@I‹ùI‹ð‹êL
„>L‹ñLr>Hs>¹	èµøÿÿH‹ØH…Àt7H‹Èÿ€áH‹Œ$€L‹ÏH‰L$0L‹Æ‹L$x‹Õ‰L$(H‹L$pH‰L$ I‹ÎÿÓë,3ÒI‹Îèø‹ÈL‹Ï‹D$xL‹Æ‰D$(‹ÕH‹D$pH‰D$ ÿÎßH‹\$PH‹l$XH‹t$`H‹|$hHƒÄ@A^ÃÌÌÌ@SHƒì L
ë=¹
L×=HØ=èøÿÿH‹ØH…ÀtH‹ÈÿÒàH‹ÃHƒÄ [HÿàèÜÿÿÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì A‹ùI‹ð‹êL
°=L‹ñLž=HŸ=¹è¡÷ÿÿH‹ØH…ÀtH‹ÈÿlàD‹ÏL‹Æ‹ÕI‹ÎÿÓë
¹xÿZÝ3ÀH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì A‹ùI‹ð‹êL
l=L‹ñLZ=H[=¹
è÷ÿÿH‹ØH…ÀtH‹ÈÿàßD‹ÏL‹Æ‹ÕI‹ÎÿÓë3ÒI‹Îèw‹ÈD‹ÏL‹Æ‹ÕÿÞH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃH‰\$WHƒì H‹ÙL
=¹L=H
=è”öÿÿH‹øH…ÀtH‹Èÿ_ßH‹Ëÿ×ë	H‹ËÿçÜH‹\$0HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x AVHƒì0I‹ùI‹ð‹êL
Ü<L‹ñLÊ<HË<¹è%öÿÿH‹ØH…Àt*H‹ÈÿðÞ‹L$hL‹Ï‰L$(L‹ÆH‹L$`‹ÕH‰L$ I‹ÎÿÓë,3ÒI‹Îèu‹ÈL‹Ï‹D$hL‹Æ‰D$(‹ÕH‹D$`H‰D$ ÿSÝH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A^ÃH‰\$H‰t$WHƒì ‹úL
H<H‹ñH><¹L*<èyõÿÿH‹ØH…ÀtH‹ÈÿDÞ‹×H‹ÎÿÓëÿ
ÝE3ÉD‹Ç‹ÈH‹ÖèYH‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì H‹úL
#<H‹ñH<¹L<èõÿÿH‹ØH…Àt$H‹ÈÿÏÝH‹×H‹ÎH‹ÃH‹\$0H‹t$8HƒÄ _HÿàèÙÿÿÌÌÌH‰\$H‰l$H‰t$WHƒì A‹èL
Ö;‹ÚLÅ;H‹ùHã¹è•ôÿÿH‹ðH…ÀtH‹Èÿ`ÝD‹Å‹ÓH‹ÏÿÖë‹ÓH‹Ïÿ9ÛH‹\$0H‹l$8H‹t$@HƒÄ _ÃH‰\$WHƒì H‹ùL
p;¹L\;H];è,ôÿÿH‹ØH…ÀtH‹Èÿ÷ÜH‹ÏÿÓë3ÒH‹Ï薋Ⱥÿ©ÛH‹\$0HƒÄ _ÃÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì E‹ñA‹ØH‹úL
+;‹ñL;H;¹è­óÿÿH‹èH…ÀtH‹ÈÿxÜE‹ÎD‹ÃH‹×‹ÎÿÕë
D‹ÃH‹×‹Îè4GH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃÌH‹ÄH‰XH‰hH‰pH‰x AVHƒìPA‹ùI‹ð‹êL
ˆ:L‹ñLv:Hw:¹è!óÿÿH‹ØH…ÀtWH‹ÈÿìÛH‹Œ$ D‹ÏH‹„$€L‹ÆH‰L$@‹ÕH‹Œ$˜H‰L$8H‹Œ$H‰L$0‹Œ$ˆ‰L$(I‹ÎH‰D$ ÿÓë23ÒI‹ÎèD‹ÈD‹Ï‹„$ˆL‹Æ‰D$(‹ÕH‹„$€H‰D$ ÿ,ÚH‹\$`H‹l$hH‹t$pH‹|$xHƒÄPA^ÃÌH‰\$H‰t$WHƒì ‹òL
à9H‹ÙHÖ9¹LÂ9èAòÿÿH‹øH…ÀtH‹ÈÿÛ‹ÖH‹Ëÿ×ëH‹Ëè·FH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì I‹øL
’9‹òL9H‹éH9¹èÑñÿÿH‹ØH…Àt+H‹ÈÿœÚL‹Ç‹ÖH‹ÍH‹ÃH‹\$0H‹l$8H‹t$@HƒÄ _HÿàèÉÕÿÿÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì A‹ùI‹ðH‹êL
39L‹ñL!9H"9¹èTñÿÿH‹ØH…Àt5H‹ÈÿÚD‹ÏL‹ÆH‹ÕI‹ÎH‹ÃH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^HÿàèBÕÿÿÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì A‹ùI‹ðH‹êL
Ã8L‹ñL±8H²8¹èÌðÿÿH‹ØH…Àt5H‹Èÿ—ÙD‹ÏL‹ÆH‹ÕI‹ÎH‹ÃH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^HÿàèºÔÿÿÌÌH‰\$WHƒì ‹ùL
a8¹LQ8HN8è]ðÿÿH‹ØH…Àt
H‹Èÿ(Ù‹ÏÿÓH‹\$0HƒÄ _ÃÌ@SHƒì L
/8¹L8H 8èðÿÿH‹ØH…ÀtH‹ÈÿâØÿÓHƒÄ [ÃÌÌH‰\$H‰t$WHƒì ‹úL
 8H‹ñH8¹L8èÉïÿÿH‹ØH…Àt#H‹Èÿ”Ø‹×H‹ÎH‹ÃH‹\$0H‹t$8HƒÄ _HÿàèÉÓÿÿÌH‰\$WHƒì H‹ùL
 7¹LŒ7H7èlïÿÿH‹ØH…ÀtH‹Èÿ7ØH‹ÏÿÓH‹\$0HƒÄ _ÃÌÌÌ@SHƒì L
ÿ6¹Lë6Hì6è#ïÿÿ3ÛH…Àt'L
ñ6Lâ6Hã6KèÿîÿÿH…Àt»ŠÃHƒÄ [ÃÌHƒì(L
4¹Lñ3Hò3èÉîÿÿH…À•ÀHƒÄ(ÃÌÌHƒì(L
U6¹LA6HB6è™îÿÿH…À•ÀHƒÄ(ÃÌÌH‰\$WHƒì L
÷3¹Lã3Hä3ècîÿÿH‹ØH…Àu3ÀëMH‹Èÿ*×ÿÓH‹ØH…ÀtéL
Y4¹LE4HF4è%îÿÿH‹øH…ÀuH‹ÃëH‹ÈÿëÖH‹Ëÿ×H‹\$0HƒÄ _ÃÌÌÌH‰|$H‹$H=M¢‹Â¹@ƒà?+È3ÀHÓȹ H3ÂóH«H‹|$°ÃÌH‰\$WHƒìPH‹ç€H3ÄH‰D$@L
ø3¹Lä3Hå3èŒíÿÿH‹ØH…Àu°ëvL
U4¹LA4HB4èaíÿÿH‹øH…ÀtÕH‹Ëÿ,ÖÿÓH‹ØH…Àu2Àë83ÀH‹ÏH‰D$0‰D$8ÿ
ÖHƒd$ LD$0A¹H‹ËAQõÿ×…ÀtÊŠD$8$H‹L$@H3Ìèq‘ûÿH‹\$`HƒÄP_ÃÌÌH‰\$WHƒì ‹L¢3Û…Àtƒø”Àë\L
_2¹LK2HL2è³ìÿÿH‹øH…Àt(H‹È‰\$0ÿzÕ3ÒHL$0ÿ׃øzu
H‡°‡
ñ¡ë
¸‡ä¡2ÀH‹\$8HƒÄ _ÃÌÌÌ@SHƒì „Éu/H H‹H…ÉtHƒùÿtÿ—ÐHƒ#HƒÃH˜ H;ØuØ°HƒÄ [ÃÌÌÌH‰\$WHƒì0ƒd$ ¹è_»‰\$$;—•tnHcûH‹“•H‹øH…ÀuëU‹HÁé
öÁtH‹
v•H‹ùèY4üÿƒøÿtÿD$ H‹]•H‹øHƒÁ0ÿoÒH‹
H•H‹ùèKÎÿÿH‹8•Hƒ$øÿÃ놹è)‹D$ H‹\$@HƒÄ0_ÃÌÌH‰L$H‹AH‰H‹D$ƒ`ÃÌÌH‹‹H#Ê;Ê”ÀÃÌÌL‹D‹ÊA÷ÑA
HA‹@‹ÈA#ÉðA±Huó…•ÀÃÌÌÌH‰\$H‰t$WHƒì H‹Ù‹A$<uJ‹A¨ÀtC‹9+yƒaH‹qH‰1…ÿ~/è•‹ÈD‹ÇH‹Öè(u;øt
ðƒKƒÈÿë‹CÁè¨tðƒcý3ÀH‹\$0H‹t$8HƒÄ _ÃÌ@SHƒì H‹ÙH…Éu
HƒÄ [é@èkÿÿÿ…ÀtƒÈÿë‹CÁè¨tH‹Ëè ‹Èè}@…ÀuÞ3ÀHƒÄ [Ã̹éÌÌH‹ÄH‰XH‰pWAVAWHƒì@‹ñƒ`̃`ȹè|H‹=Ä“Hcµ“L4ÇAƒÏÿH‰|$(I;þtqH‹H‰\$hH‰\$0H…ÛuëWH‹Ëè¯1üÿ‹CÁè
¨t<ƒþuH‹Ëè+ÿÿÿA;Çt*ÿD$$ë$…öu ‹CÑè¨tH‹Ëèÿÿÿ‹T$ A;ÇAD׉T$ H‹Ëèl1üÿHƒÇë…¹è4‹D$ ƒþDD$$H‹\$`H‹t$pHƒÄ@A_A^_ÃH‰\$H‰L$WHƒì H‹ÙH…Éuèÿÿÿëè
1üÿH‹Ëè˜þÿÿ‹øH‹Ëè1üÿ‹ÇH‹\$8HƒÄ _ÃÌH‹‹@ÁèƒàÃÌÌÌ@SHƒì H‹Ù‹AÁè
¨t'‹AÁè¨tH‹Iè¢Ëÿÿðc¿þÿÿ3ÀH‰CH‰‰CHƒÄ [Ã…Étƒét¸ôÿÿÿøõÿÿÿøöÿÿÿÃÌH‹ÄH‰XH‰hH‰pH‰x AVHìHHˆÿ"ÏE3öfD9t$b„˜H‹D$hH…À„ŠHcHp¿ HÞ98L8‹Ïèâ©;=Ì¡O=Å¡…ÿt^A‹îHƒ;ÿtEHƒ;þt?öt:öu
H‹ÿOÏ…Àt(H‹ÍH‘ƒá?H‹ÅHÁøHÁáHÂH‹H‰A(ŠˆA8HÿÅHÿÆHƒÃHƒïu¥Lœ$I‹[I‹kI‹s I‹{(I‹ãA^ÃÌH‰\$H‰t$H‰|$AVHƒì 3ÿE3öHcßH
 H‹Ãƒã?HÁøHÁãHÁH‹C(HƒÀHƒøv	€K8€é‰ÆC8‹Ï…ÿtƒét
ƒù¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿÿ¼ÌH‹ðHHHƒùvH‹ÈÿfÎë3À…Àt¶ÈH‰s(ƒùu€K8@ë.ƒùu)€K8ë#€K8@HÇC(þÿÿÿH‹®H…ÀtI‹Ç@þÿÿÿÿÇIƒÆƒÿ…5ÿÿÿH‹\$0H‹t$8H‹|$@HƒÄ A^ÃÌ@SHƒì ¹è3Û3Éè?¨…ÀuèöýÿÿèÝþÿÿ³¹èIŠÃHƒÄ [ÃÌH‰\$WHƒì 3ÛH=ù›H‹;H…Ét
諧Hƒ$;HƒÃHûrÙ°H‹\$0HƒÄ _ÃH‹‹@ÃÌHƒì(H…Éuè¶ÌýÿÇèoÒÿÿƒÈÿë‹AHƒÄ(ÃÌÌ@SHƒì E3ÒH…ÉtH…Òt	M…ÀufD‰è{Ìýÿ»‰è3Òÿÿ‹ÃHƒÄ [ÃL‹ÉL+ÁC·fA‰MIf…ÀtHƒêuèH…ÒufD‰è;Ìýÿ»"ë¾3ÀëÃ@SHƒì 3ÛH…Ét
H…ÒtM…Àuf‰èÌýÿ»‰èÉÑÿÿ‹ÃHƒÄ [ÃL‹ÉL+ÁC·fA‰MIf…ÀtHƒêuèH…ÒuÕf‰èÒËýÿ»"ë¿ÌÌÌ@UHƒì Hl$ Hƒåà‹‹xL‹ÉƒøŒ‹L‹Á¸ AƒàI+ÀI÷ØMÒL#ÐI;ÒLBÒI
ë€9tHÿÁH;ÈuóI+ÉI;ÊuIL‹ÂIÉM+ÂI‹ÀƒàL+ÀLÁÅìWÒëÅít	Åý×Á…Àu	HƒÁ I;ÈuëIë€9tHÿÁH;ÈuóI+ÉÅøwH‹Á鮃øŒŠƒá¸H+ÁH÷ÙI‹ÉMÒL#ÐI;ÒLBÒK
L;Èt
€9tHÿÁH;ÈuóI+ÉI;Êu³L‹ÂIÉM+ÂWÉI‹ÀƒàL+ÀLÁëfoftÁf×À…Àu	HƒÁI;ÈuçIë€9tHÿÁH;ÈuóI+ÉéeÿÿÿHÊI‹ÁL;Ét
€8tHÿÀH;ÁuóI+ÁHƒÄ ]Ã@UHƒì Hl$ Hƒåà‹+wL‹ÒL‹ÁƒøŒÍöÁt)HQH‹ÑH;ÈtE3ÉfD9
t	HƒÂH;ÐuñH+ÑHÑú闃ḠH+ÁH÷ÙMÛL#ØIÑëI;ÓLBÚE3ÉI‹ÐKXL;ÀtfD9
t	HƒÂH;ÐuñI+ÐHÑúI;ÓuPI‹ÊIPI+ËH‹ÁƒàH+ÈÅìWÒLJëÅíu
Åý×Á…Àu	HƒÂ I;ÓuëKPë
fD9
t	HƒÂH;ÐuñI+ÐHÑúÅøwH‹ÂéúƒøŒÍöÁt+HQH‹ÑH;È„8ÿÿÿE3ÉfD9
„+ÿÿÿHƒÂH;Ðuíéÿÿÿƒá¸H+ÁH÷ÙMÛL#ØIÑëI;ÓLBÚE3ÉI‹ÐKXL;ÀtfD9
t	HƒÂH;ÐuñI+ÐHÑúI;Ó…tÿÿÿI‹ÊIPI+ËWÉH‹ÁƒàH+ÈLJëfofuÁf×À…Àu	HƒÂI;ÓuçKPë
fD9
t	HƒÂH;ÐuñI+ÐéƒþÿÿHQI‹ÀL;ÁtE3ÉfD9t	HƒÀH;ÁuñI+ÀHÑøHƒÄ ]ÃÌÌÌLH‹ÁI;Èt
€8tHÿÀI;ÀuóH+ÁÃÌÌÌLQH‹ÁI;Ètfƒ8t	HƒÀI;ÀuñH+ÁHÑøÃÌÌ@UHƒì Hl$ HƒåàL‹ÁL‹ÉAƒà¸ I+ÀL‹ÚI÷ØMÒL#ÐI‹ÁI;ÒLBÒIÊL;Ét
€8tHÿÀH;ÁuóI+ÁI;ÂuJI+ÒJH‹ÂƒàH+ÐHÑÅôWÉëÅõtÅý×À…Àu	HƒÁ H;ÊuëKë€9tHÿÁH;ÈuóI+ÉÅøwH‹ÁHƒÄ ]Ã@UHƒì Hl$ HƒåàL‹ÒL‹ÁöÁt)HQI‹ÀL;ÁtE3ÉfD9t	HƒÀH;ÁuñI+ÀHÑø隃ḠH+ÁH÷ÙMÛL#ØI‹ÀIÑëI;ÓLBÚE3ÉKXL;ÁtfD9t	HƒÀH;ÁuñI+ÀHÑøI;ÃuSI@I‹ÊI+ËH‹ÁƒàH+ÈÅôWÉLJëÅõuÅý×À…Àu	HƒÂ I;ÓuëKPë
fD9
t	HƒÂH;ÐuñI+ÐHÑúÅøwH‹ÂHƒÄ ]ÃÌL‹ÁL‹ÉAƒà¸I+ÀL‹ÚI÷ØMÒL#ÐI‹ÁI;ÒLBÒIÊL;Ét
€8tHÿÀH;ÁuóI+ÁI;ÂuJI+ÒJH‹ÂWɃàH+ÐHÑëfoÁftf×À…Àu	HƒÁH;ÊuçKë€9tHÿÁH;ÈuóI+ÉH‹ÁÃL‹ÒL‹ÁöÁt%HQI‹ÀL;ÁtE3ÉfD9t	HƒÀH;ÁuñI+ÀHÑøÃá¸H+ÁH÷ÙMÛL#ØI‹ÀIÑëI;ÓLBÚE3ÉKXL;ÁtfD9t	HƒÀH;ÁuñI+ÀHÑøI;ÃuSI@I‹ÊI+ËWÉH‹ÁƒàH+ÈLJëfoÁfuf×À…Àu	HƒÂI;ÓuçKPë
fD9
t	HƒÂH;ÐuñI+ÐHÑúH‹ÂÃÌÅøwÃÂÌ@UHƒì Hl$ HƒåàÅþoÅýtHƒÄ ]ÃÌÌÌ@UHƒì Hl$ HƒåàÅþoÅýuHƒÄ ]ÃÌÌÌfoftÃÌÌÌfofuÃÌÌÌÅþoÅý×ÀÃÌÌÌfof×ÀÃÌÌÌ@UHƒì Hl$ HƒåàÅüWÀHƒÄ ]ÃÌÌÌWÀÃ@UHƒì Hl$ Hƒåà‹wqL‹ÉƒøŒŒL‹Á¸ AƒàI+ÀI÷ØMÒL#ÐI;ÒLBÒI
ë€9tHÿÁH;ÈuóI+ÉI;Ê…ñL‹ÂIÉM+ÂI‹ÀƒàL+ÀLÁÅìWÒëÅít	Åý×Á…Àu	HƒÁ I;ÈuëIë€9tHÿÁH;ÈuóI+ÉÅøw飃øŒ„ƒá¸H+ÁH÷ÙI‹ÉMÒL#ÐI;ÒLBÒK
L;Èt
€9tHÿÁH;ÈuóI+ÉI;Êu^L‹ÂIÉM+ÂWÉI‹ÀƒàL+ÀLÁëfoÁftf×À…Àu	HƒÁI;ÈuçIë€9tHÿÁH;ÈuóëHë€9tHÿÁH;ÈuóI+ÉH‹ÁHƒÄ ]ÃÌÌÌ@UHƒì Hl$ Hƒåà‹pL‹ÒL‹ÁƒøŒÐöÁt+HQH‹ÑH;È„¨E3ÉfD9
„›HƒÂH;Ðuíéƒá¸ H+ÁH÷ÙMÛL#ØIÑëI;ÓLBÚE3ÉI‹ÐKXL;ÀtfD9
t	HƒÂH;ÐuñI+ÐHÑúI;Ó…HI‹ÊIPI+ËH‹ÁƒàH+ÈÅìWÒLJëÅíu
Åý×Á…Àu	HƒÂ I;ÓuëKPë
fD9
t	HƒÂH;ÐuñI+ÐHÑúÅøwéóƒøŒÆöÁt+HQH‹ÑH;È„ÏE3ÉfD9
„ÂHƒÂH;Ðuíé´ƒá¸H+ÁH÷ÙMÛL#ØIÑëI;ÓLBÚE3ÉI‹ÐKXL;ÀtfD9
t	HƒÂH;ÐuñI+ÐHÑúI;ÓusI‹ÊIPI+ËWÉH‹ÁƒàH+ÈLJëfoÁfuf×À…Àu	HƒÂI;ÓuçKPë
fD9
t	HƒÂH;ÐuñI+Ðë!HQH‹ÑH;ÈtE3ÉfD9
t	HƒÂH;ÐuñH+ÑHÑúH‹ÂHƒÄ ]Ã@SHƒì 3ÛHi”E3ÀH›Hʺ èæÿÿ…ÀtÿR–ÿÃû
rÓ°ë	3Éè$2ÀHƒÄ [ÃHcÁH€H"”HÈHÿ%GÁÌÌÌ@SHƒì ‹–ëHÿ“ÿËH›HÈÿ/Áÿ
ñ•…Ûuß°HƒÄ [ÃÌHcÁH€HΓHÈHÿ%ûÀÌÌÌH
Y”Hÿ%âÀÌÌH
I”Hÿ%ÚÀÌÌH‰\$‰T$UVWATAUAVAWHƒì03ö‹ÚL‹ùH…ÉuègÀýÿÇHƒÈÿ锺=H‹ùè»ûÿL‹èH…Àt^I;ÇtY@8pL‹5@”ÅL;5@ˆl$puI‹ÎèiL‹ðH‰ߌA¼M…ö…¿…ÛtPH95ÍŒtGèúYÿÿH…À…˜èà¿ýÿHƒÎÿÇ‹î‹õ‹î‹õH‹Ïè¼ÿÿ‹ÆH‹œ$€HƒÄ0A_A^A]A\_^]Ã@„íuѺI‹Ì讽ÿÿ3ÉH‰aŒèÈ»ÿÿL‹5UŒM…öuHƒÍÿë¦H95KŒu+ºI‹Ìèx½ÿÿ3ÉH‰3Œè’»ÿÿH95'ŒtÍL‹5ŒM…ötÁM‹åI‹ÞM+çI96t4H‹M‹ÄI‹Ïè!1…ÀuH‹A€<=tA84t	HƒÃH93ëÓI+ÞHÁûë
I+ÞHÁûH÷ÛH…ÛxWI96tRI‹Þè»ÿÿ@„íuM‰<Þé•I‹DÞI‰ÞHÿÃI94ÞuîA¸H‹ÓI‹Îè)3ÉH‹ØèãºÿÿH…ÛtfH‰k‹ë]@„í…¾þÿÿH÷ÛHSH;Ós	HƒÍÿé«þÿÿH¸ÿÿÿÿÿÿÿH;ÐsèA¸I‹ÎèÖ3ÉL‹ðèºÿÿM…ötËM‰<ÞI‰tÞL‰5‹H‹þ9t$x„dþÿÿHƒÍÿL‹õIÿÆC847u÷ºINè(¼ÿÿH‹ØH…ÀtGM‹ÇIVH‹Èè=»ÿÿ…ÀuAH‹ÃIUI+ÇH‹ËHÐ@8t$p@ˆrÿHEÖÿ&¿…Àu
èͽýÿ‹õÇ*H‹Ëèù¹ÿÿéêýÿÿE3ÉH‰t$ E3À3Ò3Éè¸ÃÿÿÌÌÌÌH‰\$H‰l$H‰t$WATAUAVAWHƒì03ö‹êL‹ùH…Éuès½ýÿÇHƒÈÿ鑺=H‹ù苧L‹àH…Àt[I;ÇtVf9pL‹5ŠA”ÅL;5ŠuI‹ÎèfL‹ðH‰ø‰»M…ö…ÁH‹Û‰…ítQH…ÀtLèWÿÿH…À…—èï¼ýÿHƒÎÿÇ‹î‹õ‹î‹õH‹Ïè¹ÿÿ‹ÆH‹\$`H‹l$hH‹t$pHƒÄ0A_A^A]A\_ÃE„íuÌH…Àu4PH‹Ë赺ÿÿ3ÉH‰h‰èϸÿÿH95\‰uHƒÍÿë¡L‹5U‰M…öu'ºH‹Ëèºÿÿ3ÉH‰:‰虸ÿÿL‹5.‰M…ötÇM+çI‹ÞIÑüI96t:H‹M‹ÄI‹Ïèi,…ÀuH‹¹=fB9`tfB94`t	HƒÃH93ëÍI+ÞHÁûë
I+ÞHÁûH÷ÛH…ÛxWI96tRI‹Þè(¸ÿÿE„íuM‰<Þé•I‹DÞI‰ÞHÿÃI94ÞuîA¸H‹ÓI‹Îè3þ3ÉH‹Øèí·ÿÿH…ÛtfH‰}ˆë]E„í…¹þÿÿH÷ÛHSH;Ós	HƒÍÿé¦þÿÿH¸ÿÿÿÿÿÿÿH;ÐsèA¸I‹Îèàý3ÉL‹ðèš·ÿÿM…ötËM‰<ÞI‰tÞL‰5!ˆH‹þ…í„aþÿÿHƒÍÿL‹õIÿÆfC94wuöºLòI‹Îè1¹ÿÿH‹ØH…Àt@M‹ÇI‹ÖH‹Èè×îÿÿ…Àu;IT$E„íHSH‹Ëf‰rþHEÖÿŽº…Àu
èݺýÿ‹õÇ*H‹Ëè	·ÿÿéëýÿÿE3ÉH‰t$ E3À3Ò3ÉèÈÀÿÿÌÌÌÌH‰\$H‰t$H‰|$AVHƒì0H‹ùH…Éu3ÀéŽ3ÉH‹ÇH9t
HÿÁH@Hƒ8uóHÿÁºè|¸ÿÿH‹ØH…ÀtxHƒ?tRL‹ðL+÷H‹HƒÎÿHÿÆ€<0u÷ºHNèJ¸ÿÿ3ÉI‰>èg¶ÿÿI‹>H…ÉtVL‹HVèV·ÿÿ…Àu0HƒÇHƒ?u´3Éè=¶ÿÿH‹ÃH‹\$@H‹t$HH‹|$PHƒÄ0A^Ã蟷ÿÿÌHƒd$ E3ÉE3À3Ò3Éèá¿ÿÿÌ胷ÿÿÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì03íH‹ùH…Éu3ÀéŒH‹ÍH‹ÇH9/tHÿÁH@H9(uôHÿÁº芷ÿÿH‹ØH…Àt{H9/tQL‹ðL+÷H‹HƒÎÿHÿÆf9,pu÷ºHNèY·ÿÿ3ÉI‰>èvµÿÿI‹>H…ÉtYL‹HVèõìÿÿ…Àu4HƒÇH9/uµ3ÉèMµÿÿH‹ÃH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A^Ã誶ÿÿÌE3ÉH‰l$ E3À3Ò3Éèí¾ÿÿÌè¶ÿÿÌÌÌH‰\$H‰l$H‰t$WHƒì H‹=……H‹òH‹éH‹ßHƒ?t4H‹L‹ÆH‹Íè”*…ÀuH‹€<=t€<t
HƒÃHƒ;ëÓH+ßHÁûë
H+ßHÁûH÷ÛH‹l$8H‹ÃH‹\$0H‹t$@HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x AVHƒì H‹=…E3öH‹òH‹éH‹ßL97t5H‹L‹ÆH‹ÍèE(…ÀuH‹fƒH;ÐHÉH#ÈHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðè_H+àH\$@H…Û„»ÇÌÌëH;ÐHÉH#Èèä‘ÿÿE3ÀH‹ØH…ÀtÇÝÝHƒÃëI‹ØH…Û„‚I‹¸3ÒL‹ÏE„öt‰t$(LEH‰\$ èF¸ÿÿëL‰D$0LE‰t$(H‰\$ èµÿÿ‹ÐL‹ÃÿÊE3ÉëM9vA·IƒÀI‹$f‰Iƒ$IÿÿÊ…ÒÞHKð9ÝÝuè‘ÿÿ°éL‹uAºL‹]D·fE…É„ä¸dM9„ÖAŠØA‹ÈH‹÷HƒÆAÊMÂfD9tðA·Ñ;Ðh„+A»'A;Ó„±AC;ÐtEC!A;ÐtdAC&;Ðt%AC:;Ð…HöH‹Ïèoj…ÀuXHw
ëiƒét%ƒét#ƒétƒù…àAAéù¸béïAŠÚ¸méâƒét
ƒùté²AŠÚA·ÀéÇH¸õH‹Ïèj…ÀuHw¸p馋Á%€}	A+ƒÈþAÂ…ÀuFJ-”Â3ÀH×…ÛŸÀ…ÀtIƒÈÿIÿÀB€<uöHcÈIÿÀHÊè5_ƒ>-H‹×uÆ-HW…Û~ŠBˆHÿÂH‹D$8H‹ˆøH‹Šˆ
3ÉL
Ý8Œ$”ÁHÚHÙH+ûH‹ËHƒýÿH/HDÕè7qÿÿ…À…¤HKE„ÿtÆEH‹F€80tWD‹FAƒèyA÷ØÆC-Aƒød|¸…ëQA÷èÁú‹ÂÁèÐSkÂœDÀAƒø
|¸gfffA÷èÁú‹ÂÁèÐSkÂöDÀDCƒ¼$€u€90uHQA¸èE^€|$HtH‹D$0ƒ ¨ý3Àé…þÿÿHƒd$ E3ÉE3À3Ò3ÉèJyÿÿÌÌL‹ÜI‰[I‰sWHƒì@‹t$x3ÀH‹	I‹øI‰CèMCèI‰CðH‹ÚH‹D$p‹ÖI‰CØè!D‹D$4LL$03ÉH‹×ƒ|$0-”ÁDÆH+ÑHƒÿÿHD×HËè\ì…ÀtÆë%H‹„$€LL$0H‰D$(D‹ÆH‹×ÆD$ H‹ËèH‹\$PH‹t$XHƒÄ@_ÃÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì@H‹T$xH‹ÙHHØM‹ñA‹øè@ßûÿA‹NÿÉ€|$pt;Ïu3ÀHcÉAƒ>-”ÀHÃfÇ0Aƒ>-uÆ-HÿÃHƒÎÿAƒ~$L‹ÆIÿÀB€<uöIÿÀHKH‹Óèã\Æ0HÿÃëIcFHØ…ÿ~|HkL‹ÆIÿÀB€<uöIÿÀH‹ÓH‹Íè±\H‹D$(H‹ˆøH‹ŠˆA‹N…ÉyB€|$pu‹Á÷Ø;Ç}‹ù÷ß…ÿtHÿÆ€<.u÷HcÏLFHÍH‹Õèd\LcǺ0H‹ÍèHûÿ€|$8tH‹D$ ƒ ¨ýH‹\$P3ÀH‹l$XH‹t$`H‹|$hHƒÄ@A^ÃL‹ÜI‰[I‰kI‰sAVHƒìPH‹	3ÀI‰CèI‹èI‰CðMCèH‹„$€H‹ò‹”$ˆI‰CÈè(þD‹t$DLL$@D‹„$ˆ3Ƀ|$@-H‹Õ”ÁAÿÎH+ÑHƒýÿH1HDÕH‹ËèWê…ÀtÆ阋D$DÿÈD;ðœÁƒøü|E;„$ˆ}<„ÉtŠHÿÄÀu÷ˆCþH‹„$ LL$@D‹„$ˆH‹ÕH‰D$(H‹ÎÆD$ èÛýÿÿëBH‹„$ H‹ÕDŠŒ$H‹ÎD‹„$ˆH‰D$8HD$@ÆD$0H‰D$(‹„$˜‰D$ èûÿÿH‹\$`H‹l$hH‹t$pHƒÄPA^ÃÌ@UHl$±HìÀH‹·H3ÄH‰E?M‹Ñ¶ÂHƒÀM‹ÈL;ÐsAƸH‹M?H3ÌèÉ-ûÿHÄÀ]ÄÒtIÿÁAÆ-IÿÊAÆö]HHØLEØH‰UßH.ØH‰UçH‰E¿H‰EÇHØH‰EÏH‰E×H ØH‰EÿH%ØH‰EH*ØH‰EH/ØH‰E/H‰UH‰U'QÿÉL‰EïHÁâ÷уáL‰E÷‹ÁHÂL‰EL‰E7L‹DÅ¿HƒÈÿHÿÀA€<uöL;ЗÀE3À„ÀA”ÀDÁI‹ÉLÂI‹ÒN‹DÅ¿è(lÿÿ…À„ÿÿÿHƒd$ E3ÉE3À3Ò3ÉèßtÿÿÌÌÌHƒì(I‹ÀE…ÉtIƒÈÿIÿÀB€<uöIcÉIÿÀHÈH‹Ðè}YHƒÄ(Ãé>ûÿÌÌÌH‰\$H‰l$H‰t$WATAUAVAWHƒì`M‹éI‹èH‹òL‹ùH…Òuè^nýÿ»‰ètÿÿ‹ÃéÞM…ÀtãM…ÉtÞL‹¤$°M…ätÑ‹œ$¸ƒûAt
C»ƒøvE2öëA¶H‹¼$È@öÇu*èQôÿÿ…Àt!I‹L‹ÍHÁê?L‹Æ€âDˆt$ ‹ÈèÙýÿÿésHÁïƒçƒÏƒëA„)ƒë„çƒëtXƒëtƒë„
ƒë„˃ût€áûˆL2=A¸HUàˆEàDˆmáëEè4¶º€f…Ht)I;üƒïA¸HMÀH‹×èïåÿÿƒøÿ„ôHÿÇëA¸H‹×HMÀèÏåÿÿƒøÿ„ÔHƒd$8HEèHƒd$0LEÀ‹MÌA¹ÇD$(3ÒH‰D$ HÿÇÿ1bD‹ð…À„”H‹MÐLMÈHƒd$ HUèD‹ÀÿSb3Ò…Àtk‹K+MØωKD9uÈrbA€ý
u4H‹MÐB
H‰T$ DBHUÄf‰EÄLMÈÿb3Ò…Àt,ƒ}Èr.ÿCÿCI;üé¶þÿÿŠK‹þˆD1>K‹þ€L0=ÿCëÿ\`‰H‹ÃH‹MðH3ÌèûûÿH‹œ$ÀHÄ€A_A^A]A\_^]ÃH‹ÄH‰XH‰hH‰pH‰x AVHƒì 3ÀA‹èHêH‰‰AH‹úH‹ÙH;ÕsEDp
·7·ÎèÃf;Æu)ƒCfƒþ
uA‹Îè¬fA;ÆuÿCÿCHƒÇH;ýs
ëÇÿ»_‰H‹l$8H‹ÃH‹\$0H‹t$@H‹|$HHƒÄ A^ÃÌÌÌH‰\$H‰t$WHƒì HcÙ‹Ëè÷É…Àu2ÀëZH‹ûH5/HÁÿƒã?HÁãH‹þöD8€tÜèβÿÿH‹ˆHƒ¹8uH‹þ€|9t»H‹þHT$8H‹L(ÿÂ`…À•ÀH‹\$0H‹t$@HƒÄ _ÃÌH‰\$H‰l$VWAV¸PètIH+àH‹ZH3ÄH‰„$@H‹ÙLcÒI‹ÂA‹éHÁøH
x.Aƒâ?Ièƒ#I‹ðƒcH‹ÁƒcIÁâN‹t(L;ÅsoH|$@H;õs$ŠHÿÆ<
u	ÿCÆ
HÿLjHÿÇH„$?H;ør×Hƒd$ HD$@+øLL$0D‹ÇHT$@I‹ÎÿÐ_…Àt‹D$0C;ÇrH;õr›ëÿ4^‰H‹ÃH‹Œ$@H3ÌèÏûÿLœ$PI‹[ I‹k0I‹ãA^_^ÃÌÌÌH‰\$H‰l$VWAV¸PèlHH+àH‹RH3ÄH‰„$@H‹ùLcÒI‹ÂA‹éHÁøH
p-Aƒâ?Ièƒ'I‹ðƒgH‹ÁƒgIÁâN‹t(L;Ń‚H\$@H;õs1·HƒÆfƒø
uƒG¹
f‰HƒÃf‰HƒÃH„$>H;ØrÊHƒd$ HD$@H+ØLL$0HÑûHT$@ÛI‹ÎD‹Ãÿ±^…Àt‹D$0G;ÃrH;õrˆëÿ]‰H‹ÇH‹Œ$@H3Ìè°ûÿLœ$PI‹[ I‹k0I‹ãA^_^ÃH‰\$H‰l$VWATAVAW¸pèLGH+àH‹2
H3ÄH‰„$`LcÒH‹ÙI‹ÂE‹ñHÁøH
P,Aƒâ?MðIÁâM‹øI‹øH‹ÁN‹d(3Àƒ#H‰CM;ƃÏHD$PI;þs-·HƒÇfƒù
uº
f‰HƒÀf‰HƒÀHŒ$øH;ÁrÎHƒd$8HL$PHƒd$0LD$PH+ÁÇD$(U
HŒ$HÑøH‰L$ D‹È¹éý3Òÿ4]‹è…ÀtI3ö…Àt3Hƒd$ H”$‹ÎLL$@D‹ÅHÑI‹ÌD+ÆÿI]…Àtt$@;õrÍ‹ÇA+ljCI;þé3ÿÿÿÿ§[‰H‹ÃH‹Œ$`H3ÌèBûÿLœ$pI‹[0I‹k@I‹ãA_A^A\_^ÃÌÌH‰\$H‰t$‰L$WATAUAVAWHƒì E‹øL‹âHcÙƒûþuèÖ[ýÿƒ èî[ýÿÇ	é…Éxt;Ù.slH‹óL‹óIÁþL-Æ*ƒæ?HÁæK‹Dõ¶L08ƒátE‹Ëèq7ƒÏÿK‹DõöD08uè•[ýÿÇ	èj[ýÿƒ ëE‹ÇI‹Ô‹Ëè@‹ø‹Ëè8‹ÇëèF[ýÿƒ è^[ýÿÇ	èaÿÿƒÈÿH‹\$XH‹t$`HƒÄ A_A^A]A\_ÃH‰\$ UVWATAUAVAWH‹ìHƒì`3ÿE‹øLcáH‹òE…Àu3Àé›H…ÒuèàZýÿ‰8èùZýÿÇè²`ÿÿƒÈÿéwM‹ôHÜ)Aƒæ?M‹ìIÁýIÁæL‰mðJ‹èBŠ\19Cÿ<w	A‹Ç÷Шt«BöD18 t3ÒA‹ÌDBèöÃA‹ÌH‰}àèVÄ…À„H)J‹èBöD08€„êè6­ÿÿH‹ˆH9¹8uHS)J‹èB8|09„¿H=)J‹èHUøJ‹L1(ÿ[…À„„Ût{þË€û‡+!}ÐN$>3ÛL‹þ‰]ÔI;ôƒ	E·/A·ÍèfA;Åu3ƒÃ‰]ÔfAƒý
uA½
A‹ÍèñÿfA;ÅuÿÉ]ÔÿÇIƒÇM;üsëºÿÿX‰EÐL‹mðé±E‹ÏHMÐL‹ÆA‹Ôè©öÿÿò‹xé˜H~(J‹èBöD18€tM¾Ë„Ût2ƒétƒùuyE‹ÏHMÐL‹ÆA‹Ôè›úÿÿë¼E‹ÏHMÐL‹ÆA‹Ôè£ûÿÿë¨E‹ÏHMÐL‹ÆA‹Ôèkùÿÿë”J‹L1(LMÔ!}Ð3ÀH!D$ E‹ÇH‹ÖH‰EÔÿÒY…Àu	ÿHX‰EЋ}ØòEÐòEàH‹EàHÁè …Àuh‹Eà…Àt-ƒøuèËXýÿÇ	è XýÿÇéÇýÿÿ‹Màè=XýÿéºýÿÿH¡'J‹èBöD08@t	€>„{ýÿÿè‡XýÿÇè\Xýÿƒ é†ýÿÿ‹Eä+ÇH‹œ$¸HƒÄ`A_A^A]A\_^]ÃÌÌÌH‹ÄH‰XH‰pH‰x H‰PUH‹ìHƒì ‹ùH‹Êèk‹ÿÿH‹U‹ðD‹BAöÀuèXýÿÇ	H‹EðƒHƒÈÿéÒH‹E‹HÁéA¸A„Èt
èéWýÿÇ"ëÍH‹E‹HA„Èt+H‹Eƒ`H‹E‹HH‹EÁéA„ÈtªH‹HH‰H‹Eðƒ`þH‹EðƒHH‹Eðƒ`÷H‹Eƒ`H‹E‹P÷ÂÀu8H‹]A‹Èè
¸ûÿH;ØtH‹]¹èú·ûÿH;Øu‹ÎèÁ…Àu	H‹MèÉýH‹U@ŠÏè]„À„!ÿÿÿ@¶ÇH‹\$0H‹t$@H‹|$HHƒÄ ]ÃH‹ÄH‰XH‰pH‰x H‰PUH‹ìHƒì ‹ùH‹Êè3ŠÿÿH‹U‹ðD‹BAöÀuèâVýÿÇ	H‹EðƒH¸ÿÿéÑH‹E‹HÁéA¸A„Èt
è¯VýÿÇ"ëËH‹E‹HA„Èt+H‹Eƒ`H‹E‹HH‹EÁéA„Èt¨H‹HH‰H‹Eðƒ`þH‹EðƒHH‹Eðƒ`÷H‹Eƒ`H‹E‹P÷ÂÀu8H‹]A‹ÈèÓ¶ûÿH;ØtH‹]¹èÀ¶ûÿH;Øu‹Îèä¿…Àu	H‹MèüH‹U·Ïè'„À„ÿÿÿ·ÇH‹\$0H‹t$@H‹|$HHƒÄ ]ÃÌÌÌH‹ÄH‰XH‰p H‰PˆHWHƒì H‹ÊèýˆÿÿH‹L$8LcÈ‹QöÂÀ„¨H‹L$83Û‹óH‹A‹9HÿÀ+yH‰H‹D$8‹H ÿɉH…ÿ~)H‹T$8D‹ÇA‹ÉH‹RèLùÿÿ‹ðH‹D$8;÷H‹HŠD$0ˆëlAAƒøvI‹ÉHH$ƒá?I‹ÁHÁøHÁáHÂëH
]öA8 t¹3ÒA‹ÉDBèm¾Hƒøÿu¥H‹L$8ðƒI°ëA¸HT$0A‹ÉèÎøÿÿƒø”ÀH‹\$@H‹t$HHƒÄ _ÃH‹ÄH‰XH‰p H‰Pf‰HWHƒì H‹Êèø‡ÿÿH‹L$8LcÈ‹QöÂÀ„¬H‹L$83Û‹óH‹A‹9HƒÀ+yH‰H‹D$8‹H ƒé‰H…ÿ~+H‹T$8D‹ÇA‹ÉH‹RèEøÿÿ‹ðH‹D$8;÷H‹H·D$0f‰ëlAAƒøvI‹ÉH?#ƒá?I‹ÁHÁøHÁáHÂëH
TöA8 t·3ÒA‹ÉDBèd½Hƒøÿu£H‹L$8ðƒI°ëA¸HT$0A‹ÉèÅ÷ÿÿƒø”ÀH‹\$@H‹t$HHƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì ‹ùH‹ÚH‹Êèð†ÿÿD‹C‹ðAöÀuè£SýÿÇ	ðƒKƒÈÿ阋CÁè¹„Át
è|SýÿÇ"ë׋C„Átƒc‹CÁè„ÁtÂH‹CH‰ðƒcþðƒKðƒc÷ƒc‹C©Àu,èγûÿH;Øt¹迳ûÿH;Øu‹Îèã¼…ÀuH‹ËèùH‹Ó@ŠÏè$ýÿÿ„À„_ÿÿÿ@¶ÇH‹\$0H‹t$8HƒÄ _ÃH‰\$H‰t$WHƒì ‹ùH‹ÚH‹Êè†ÿÿD‹C‹ðAöÀuè»RýÿÇ	ðƒK¸ÿÿé—‹CÁè¹„Át
è’RýÿÇ"ëÕ‹C„Átƒc‹CÁè„ÁtÀH‹CH‰ðƒcþðƒKðƒc÷ƒc‹C©Àu,èä²ûÿH;Øt¹èÕ²ûÿH;Øu‹Îèù»…ÀuH‹Ëè¥øH‹Ó·Ïè>ýÿÿ„À„]ÿÿÿ·ÇH‹\$0H‹t$8HƒÄ _ÃÌÌÌHƒì(迤ÿÿHT$0H‹ˆH‰L$0H‹ÈèJ¦ÿÿH‹D$0H‹HƒÄ(ÃÌH‹½ÃéÌÌÌH‰\$WHƒì ¸ÿÿ·Úf;Èu3ÀëJ¸f;ÈsH‹ˆ·É·Hë+3ÿf‰L$@LL$0f‰|$0HT$@OD‹ÁÿõP…Àt¼·D$0·Ë#ÁH‹\$8HƒÄ _ËR…ÀuH‹»HcÉ·H#ÂÃE3ÀéÌH‰t$H‰|$L‰t$ UH‹ìHì€H‹ÇýH3ÄH‰EðD‹òHcùI‹ÐHMÈèÒ½ûÿG=wH‹EÐH‹·yé‚‹÷HUÐÁþ@¶Îè.ĺ…Àt@ˆuÀDJ@ˆ}ÁÆEÂë@ˆ}ÀD‹ÊÆEÁ3À‰T$0‰EèLEÀf‰EìH‹EЋHHEè‰L$(HMÐH‰D$ èŽv…Àu8EàtH‹Eȃ ¨ý3Àë·EèA#Æ€}àtH‹Mȃ¡¨ýH‹MðH3Ìè2ûÿLœ$€I‹sI‹{ M‹s(I‹ã]ÃÌH‹ÁÃE3ÀHAL‹ÈL+ÉIƒÁIÁéH;ÈMGÈM…ÉtIÿÀ‰HIM;ÁuòÃE3ÀHAL‹ÈL+ÉIƒÁIÁéH;ÈMGÈM…ÉtIÿÀ‰HIM;ÁuòÃH‹ÁÃH)Çß$€pH‰è$3ÀÇÐ$ÇÊ$ðñÿÿÃÌH½$ÃH¹$ÃH©$ÃH‹±$ÃHƒì(H…ÉuèROýÿÇèUÿÿ¸ë
‹~$‰3ÀHƒÄ(ÃÌHƒì(H…Éuè"OýÿÇèÛTÿÿ¸ë
‹R$‰3ÀHƒÄ(ÃÌHƒì(H…ÉuèòNýÿÇè«Tÿÿ¸ë
‹$‰3ÀHƒÄ(ÃÌHƒì(M‹ØL‹ÒH…ÒtFM…ÀtFH…ÒtÆH…Ét9Aƒùw3H‹ò#IcÑL‹ÐHƒÈÿHÿÀA€<uöHÿÀH‰M…Òu&3ÀHƒÄ(ÃM…ÀtºèqNýÿÇè*Tÿÿ¸HƒÄ(ÃI;Ãv
¸"HƒÄ(ÃL‹–#I‹ÊM‹ÐI‹ÓHƒÄ(ésKÿÿÌÌÌH‹ÊédJÿÿDAÿAº…ëQÁ+A‹Â÷éA‹ÂD‹ÊA÷èAÁùA‹ÀÁúA‹ÉÁéDÉ‹ÊÁéÑD+Ê™ƒâÂÁøƒÀïAÁÃÌH‰\$H‰t$WHƒì H‹ùèI3öH‹ØH…ÀtH‹×H‹Èèd…ÀHEÞH‹ÃH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì H‹ùè3öH‹ØH…ÀtH‹×H‹ÈèÄ…ÀHEÞH‹ÃH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$WHƒì H‹úH‹ÙH…Éuè2Mýÿ»‰èêRÿÿ‹ÃénºÿA¸$è¯#ûÿH…ÿtÓLcAø@Wÿÿ}èùLýÿ»‰ëÊH¹Ï&A“L;Áã¸y-2ÉA÷èA»Áú‹ÂÁèÐi€àyø•FDÀ¸€3áD;À|&AÓD+ÀD;À|D+ÀAÓ¸…âD;À|AÓD+ÀëAŠË‰SL¸E.ÂE‹ËA÷èAÐÁú‹ÂÁèÐi€®þÿ‰SDÀH"„ÉLEÐIJëEËHI9|õE+˸E.ÂD‰KIcÉA+Š‰S÷/¸“$I’ƒc Áú‹ÊƒÂÁéÊ÷éÑÁú‹ÂÁèÐkÂ+ȸų¢‘A÷è‰KAÐÁú‹ÂÁèÐiÂðñÿÿ‰SDÀ¸‰ˆˆˆA÷èAÐÁú‹ÂÁèÐkÂ<‰SD+ÀD‰3ÀH‹\$0HƒÄ _ÃÌÌH‰\$WHƒì H‹úH‹ÙH…ÉuèŠKýÿ»‰èBQÿÿ‹Ãé[ºÿA¸$è"ûÿH…ÿtÓH‹H‰D$@H=@Wÿÿ}èMKýÿ»‰ëÆH¹Ï&A“H;ÁãHT$0ÆD$0HL$@èL‹D$@L­‰CI»W)QΠÈEI‹ÃA¹I÷èHÁú
H‹ÂHÁè?HÐHcÂHiÈ€®þÿH­‰SLÁ€|$0LEÐIJëAÿÁHI9|õAÿÉI‹ÃIcÉD‰KA+Š‰SH÷/ƒc H‹ÊHÁù
H‹ÁHÁè?Hȸ“$I’ƒÁ÷éÑÁú‹ÂÁèÐkÂ+ÈH¸|ójâYÑHI÷è‰KHÁú
H‹ÂHÁè?HÐHcÂHiÈðñÿÿ‰SH¸‰ˆˆˆˆˆˆˆLÁI÷èIÐHÁúH‹ÂHÁè?HÐkÂ<‰SD+ÀD‰3ÀH‹\$8HƒÄ _ÃÌH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	è3FÿÿHƒ#HƒÄ [ÃÌD‹L‹Ê¸y-Aº€3áA÷èÁú‹ÂÁèÐi€†•FD+ÀD‰E;Â|/A€€Ìþÿ‰A;Â|€Ìþÿ‰=…â|ÿÂ{þ‰ëAÆ‹ÂÃH‰\$H‰t$WHƒì H‹ùH‹òAº…ëQH¸¹pËõH1ˆH÷)H‹ÚHHÁûH‹ÃHÁè?HØA‹ÂƒÃF‹+÷éA‹ÂDKÿD‹ÂA÷éAÁøÁúA‹È‹ÂÁéÁèDÁÐA‹ÁD+™ƒâÁùCºƒÁïAÈHcÑHcÈHiÁ“þÿÿH+ÂHiÀ€QHyH€3áA‹ÉA‹Ùè§ÿÿ„ÀtH€Që‹Ëè“ÿÿ„ÀtÆH‹t$8‹ÃH‹\$0HƒÄ _ÃÌÌH‹Hƒ!Ã@SHƒì H‹ÙH‹	èÃDÿÿHƒ#HƒÄ [ÃÌ@SHƒì èÑ›ÿÿH‹ØH…Àt%H‹@hH…Àu)H$èÔDÿÿ3ÉH‰Chè‰DÿÿH‹ChH…Àu
è?HýÿÇ3ÀHƒÄ [ÃÌH‰\$H‰t$WHƒì H‹ñèÿÿÿ3ÛH‹øH…ÀtH‹ÖH‹Èè¸úÿÿ…ÀHEûH‹ßH‹t$8H‹ÃH‹\$0HƒÄ _Ãé—úÿÿÌÌÌH‰\$H‰t$WHƒì H‹ñèMÿÿÿ3ÛH‹øH…ÀtH‹ÖH‹Èèüÿÿ…ÀHEûH‹ßH‹t$8H‹ÃH‹\$0HƒÄ _ÃéïûÿÿÌÌÌH‹ÄH‰XH‰hH‰p WATAUAVAWHƒì`H‹ñ3ÿHH‰xèøÿÿ…À…Ò9¼$˜u 3ÀL\$`I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ËnA¿;-³øu;-»ø„9=o„uf9=
ud·

D‹Å··þD·ðD·ä·ßD·
Ó‰D$P‰L$H3ɉT$@A‹×D‰T$8‰|$0D‰\$(‰\$ èuéƒD·5ª‹ÍD·=žD·%”D·-Š·}èF›ÿÿH
'súÿ„ÀtHcË”ë‹”™ÔŒ·W‰-Ñ÷‰Ï÷AkÅÿÿH‹ØH…Àt$L‹D$8L
)³H‹ÐHL$@è4 …ÀuH‹û3Ûë3ÿH‹Ëèû=ÿÿH‹ÇH‹\$0HƒÄ _ÃÌH‰\$UVWAUAVH‹ìHƒì0H‹Ùè-òÿÿE3öHM8D‰u8H‹ðD‰u@è~òÿÿ…À…ÿHM@è
òÿÿ…À…ÙH‹
¶H…Ét&L‹ÁH‹ÃL+öF¶A+ÑuHÿÀE…Éuë…Ò„Wèj=ÿÿHƒÏÿH‹ÏHÿÁD84u÷HÿÁè’=ÿÿ3ÉH‰eèD=ÿÿH‹
YH…É„HÿÇD84;u÷HWL‹Ãè#>ÿÿ…À…:H‹DhE‹ÍP@L‹ÃA‹ýè/…À…D83t	HÿÃHƒïuò€;-@”Ç@„ÿtHÿÃH‹ËèâBÿÿiЉU8Š<+t,0<	wHÿÃëï€;:uLHÿÃH‹Ëè¸Bÿÿ‹U8kÈ<щU8ë<9	HÿÊ<0}ó€;:u"HÿÃH‹ËèŽBÿÿ‹U8ЉU8ë<9	HÿÊ<0}ó@„ÿt÷Ú‰U8D83A‹Æ•À‰E@…ÀtH‹NM‹ÍL‹Ãº@èi
…Àt	ë,H‹FDˆ0‹]8èxðÿÿ‰‹]@è^ðÿÿ‰H‹\$`HƒÄ0A^A]_^]ÃE3ÉL‰t$ E3À3Ò3ÉèËEÿÿÌE3ÉL‰t$ E3À3Ò3Éè¶EÿÿÌE3ÉL‰t$ E3À3Ò3Éè¡EÿÿÌE3ÉL‰t$ E3À3Ò3ÉèŒEÿÿÌE3ÉL‰t$ E3À3Ò3ÉèwEÿÿÌÌÌ@USVWH‹ìHƒìHèçïÿÿ3öHM(‰u(H‹Ø‰u0‰u8è8ðÿÿ…À…HM0èÇïÿÿ…À…iHM8èæïÿÿ…À…CH‹
_è>;ÿÿH
kH‰5Lÿn>ƒøÿ„ók
N…Àt9u@u	H‹@ˆp?ëH‹@ˆ0HE@AƒÉÿH‰D$8LôH‹C3ÒH‰t$0‹ÏÇD$(?H‰D$ ÿ”>…Àt9u@u
H‹C@ˆp?ëH‹C@ˆ0‹](èzîÿÿ‰‹]0è`îÿÿ‰‹]8è^îÿÿ‰HƒÄH_^[]ÃE3ÉH‰t$ E3À3Ò3ÉèËCÿÿÌE3ÉH‰t$ E3À3Ò3Éè¶CÿÿÌE3ÉH‰t$ E3À3Ò3Éè¡CÿÿÌH‰\$H‰t$WHì@H‹3êH3ÄH‰„$0ƒÈÿL
¦®3ö‰öîA¸‰5ªHT$0‰ÏîHL$ è•›…ÀuH|$0ëNƒø"tH‹þëDH‹L$ è’9ÿÿH‹øH…Àu	3ÉèC9ÿÿëàL‹D$ L
A®H‹ÐHL$(èL›…ÀtH‹Ïë×3Éè9ÿÿHD$0H‹ßH;øHDÞH…ÿt@87t
H‹ÏèûÿÿëèTýÿÿH‹Ëèè8ÿÿH‹Œ$0H3ÌèœúúÿLœ$@I‹[I‹sI‹ã_ÃÌÌÌHƒì(‹–…Àu)HèN{ÿÿ‹ƒ…ÀuèÒþÿÿðÿs¹è{ÿÿHƒÄ(Ã@SHƒì H‹Ù¹è{ÿÿH‹Ëèœôÿÿ‹Ø¹èT{ÿÿ‹ÃHƒÄ [ÃHƒì(¹èêzÿÿèxþÿÿ¹è-{ÿÿHƒÄ(ÃH‰T$L‹BIƒÀL9sƒzt¸ÿÿÃHcB HƒørðL‰H‹T$‹BHƒþÁè¨H‹tf9tHƒÀH‰ëÉf‰H‹D$ƒ@H‹D$ðƒ`÷H‹D$ðƒH·ÁÃÌH‰\$H‰t$ H‰T$UWAVH‹ìHƒì@H‹èH3ÄH‰Eø·ñf‰MèH‹Êè…nÿÿƒøÿt=H‹M(èwnÿÿƒøþt/H‹](H‹ËèfnÿÿHcøL5 
H‹ËHÁÿèPnÿÿƒà?HÁàIþëH0êŠ@93Û3ɉ]àˆ]ð‰Mñ„Àu)D·ÎDCHUðHMàèÁÿÿ…Àt
¸ÿÿé‚D‹EàëŠEéA¸ˆEñD‰Eà@ˆuðH‹E(IcÐL‹HLÊL9s9XuÄD;@ ¾L‰H‹E(D‹EàAHÿHcÑ…ÉxHÿH‹ŠDðHƒêˆH‹E(yêD‹EàD@H‹E(ðƒ`÷H‹E(ðƒH·EèH‹MøH3Ìè;øúÿH‹\$pH‹t$xHƒÄ@A^_]ÃH‹ÄH‰XH‰hH‰pH‰x AVHƒì ¾ÿÿH‹ú·éf;΄ù‹B‹R‹O¨uÁêö„àÑéöÁ…ÕHƒuH‹ÏèHà‹GÁè¨u_H‹Ïèòlÿÿƒøÿt8H‹Ïèålÿÿƒøþt+H‹ÏèØlÿÿHcØL5’H‹ÏHÁûèÂlÿÿƒà?HÁàIÞëH¢èö@8€t
H‹×·Íèáýÿÿë`H‹GHHH9sƒuJHcG Hƒør@H‰‹GÁè¨H‹tHƒèH‰f9(tHƒÀH‰ëHƒèH‰f‰(ƒGðƒg÷ðƒO·õ·ÆH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃH‰\$H‰T$WHƒì H‹Ú·ù3ÀH…Ò•À…Àuè¾8ýÿÇèw>ÿÿ¸ÿÿë"H‹Êèô™ûÿH‹Ó·Ïèpþÿÿ·øH‹Ëèé™ûÿ·ÇH‹\$0HƒÄ _ÃÌÌÌH‰\$WHƒì ‹BH‹Ú‹ùÁè¨u}H‹Êè—kÿÿLcÈHçLJAIƒùvM‹ÁI‹ÉAƒà?HÁùIÁàMÊëL‹ÂA€x9u$AAƒøvI‹ÑI‹Áƒâ?HÁøHÁâIÂöB=tèö7ýÿÇè¯=ÿÿƒÈÿëlƒÿÿtö‹C‹K¨uƒá€ùuäHƒ{uH‹Ëè@ÞH‹H;Cuƒ{tÆHÿÀH‰‹CHÿÁè¨H‹t
@88tHÿÀH‰ë£@ˆ8ÿCðƒc÷ðƒK@¶ÇH‹\$0HƒÄ _ÃÌÌÌH‰\$H‰T$WHƒì H‹Ú‹ù3ÀH…Ò•À…ÀuèG7ýÿÇè=ÿÿƒÈÿëH‹Êè˜ûÿH‹Ó‹Ïè¨þÿÿ‹øH‹Ëèv˜ûÿ‹ÇH‹\$0HƒÄ _ÃÌHƒì(è#Þ¹#Át$=t=t+Á÷ØÀë¸ë¸ë¸HƒÄ(ÃHƒì(èãÝ%HƒÄ(ÃÌH¨ÃHñ¬ÃH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒìPE3äI‹èL‹òH‹ùA‹ÜH…ÉtM…Àu3Àé€fD‰!H…Òuè]6ýÿÇè<ÿÿHƒÈÿé^I‹ÑHL$0è £ûÿH‹D$8H…ÿ„ßL9 8u,H…í„B¶3f‰F8$3„	HÿÃHƒÇH;Ýrâéø‹HHƒËÿ‰l$(D‹ËM‹ÆH‰|$ S
ÿj3HcÈ…À…Êÿ5ƒøzu_D‹ýI‹ö…ít)AÿÏD8&t!¶HT$8è©…ÀtHÿÆD8&t4HÿÆE…ÿëÕH‹D$8A+ö‰l$(D‹ÎM‹ÆH‰|$ º‹Hÿü2HcÈ…Àuè`5ýÿÇ*fD‰'ëSH‹ÙëNHƒËÿL9 8uHÿÃE8$u÷ë6‹HD‹ËD‰d$(M‹Æº	L‰d$ ÿ©2HcÈ…Àu
è
5ýÿÇ*ëHYÿD8d$HtH‹L$0ƒ¡¨ýH‹ÃL\$PI‹[ I‹k(I‹s0I‹{8I‹ãA_A^A\ÃéþÿÿÌÌÌH‰\$H‰t$H‰|$ATAVAWHƒì@E3äM‹ùI‹ðH‹úL‹ñA‹ÜH…ÒuM…Àt!ëM…Àuèƒ4ýÿ»‰è;:ÿÿéÂfD‰"H…ÉtL‰!H‹”$ˆHL$ è8¡ûÿL‹„$€L;ÆLGÆIøÿÿÿvè74ýÿ»ëNLL$(I‹×H‹ÏèxýÿÿHƒøÿuH…ÿtfD‰'è4ýÿ‹ëEHÿÀH…ÿt5H;Æv*Hƒ¼$€ÿtfD‰'èç3ýÿ»"‰èŸ9ÿÿëH‹Æ»PfD‰dGþM…ötI‰D8d$8tH‹L$ ƒ¡¨ýH‹t$h‹ÃH‹\$`H‹|$pHƒÄ@A_A^A\Ëš…Àu	L
[äëE3ÉéÑüÿÿÌHƒì8H‹D$`Hƒd$(H‰D$ è›þÿÿHƒÄ8ÃÌÌ@SHƒì L‹ÒM…ÉuH…ÉuH…Òu 3Àë/H…ÉtH…ÒtM…ÉuDˆ	ëèM…ÀuDˆè3ýÿ»‰èÓ8ÿÿ‹ÃHƒÄ [ÃL+ÁH‹ÑM‹ÚI‹ÙIƒùÿuAŠˆHÿ„Àt(Iƒëuíë AŠˆHÿ„ÀtIƒëtHƒëuçH…ÛuˆM…Û…wÿÿÿIƒùÿuFˆ\ÿACPë™Æèž2ýÿ»"ëÌÌÌH‰\$WHƒì E3ÒL‹ÚM…Éu,H…Éu,H…Òtèp2ýÿ»‰è(8ÿÿD‹ÓA‹ÂH‹\$0HƒÄ _ÃH…ÉtÙH…ÒtÔM…ÉuDˆëÞM…ÀuDˆëÀL+ÁH‹ÑI‹ÛI‹ùIƒùÿuAŠˆHÿ„Àt)Hƒëuíë!AŠˆHÿ„ÀtHƒëtHƒïuçH…ÿuDˆH…Ûu‡IƒùÿuFˆTÿDSPésÿÿÿDˆèÌ1ýÿ»"éWÿÿÿÌÌfƒ9tfƒy:u·fƒèafƒø·wƒè ƒÀÀÃ3ÀÃÌ@SHƒì0H‹KÞH3ÄH‰D$(Aÿƒøv èV1ýÿÇèk1ýÿÇ
è$7ÿÿƒÈÿë1fƒÁ@ÇD$":f‰L$ HL$ ÿ0…Àuÿ…0‹Èè¾0ýÿëÌ3ÀH‹L$(H3ÌèïúÿHƒÄ0[ÃÌÌÌH‰\$H‰t$WHì@H‹»ÝH3ÄH‰„$03ÿHL$"3Òf‰|$ A¸èwûÿHT$ ¹ÿŸ/=w&·L$ f…Étyfƒ|$":uqAŸfƒø·Áwƒè xÀë]pº‹ÎèŸ.ÿÿH‹ØH…ÀtH‹Ð‹ÎÿP/…Àu
èo0ýÿÇë"f9;tfƒ{:u·fƒèafƒø·wƒè xÀH‹Ëèy,ÿÿ‹ÇH‹Œ$0H3Ìè+îúÿLœ$@I‹[I‹sI‹ã_ÃÌÌH‰\$H‰l$H‰t$WHƒì 3ÿI‹ØH‹òH…Ò„•@8:„ŒH…Ét
èàéE3ÉE3À3ÒH‹ÎÿŽ.…Àuÿ/‹ÈèE/ýÿëT‹èºH;ÝHGëH‹ÍèÁ|H‹ØH…Àuè/ýÿ3ÉÇè^ýÿë"D‹ÅH‹ÖH‹ÈèwH…ÀuH‹Ëëá3Éèê]ýÿH‹ûH‹Çë¸ÿÿÿH;ØBËÐèpÜH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì 3ÿI‹ØH‹òH…Ò„•f9:„ŒH…Ét
èxéE3ÉE3À3ÒH‹Îÿ²-…Àuÿ(.‹Èèa.ýÿëT‹èºH;ÝHGëH‹ÍèÝ{H‹ØH…Àuè¬.ýÿ3ÉÇè']ýÿë"D‹ÅH‹ÖH‹ÈèH…ÀuH‹Ëëá3Éè]ýÿH‹ûH‹Çë¸ÿÿÿH;ØBËÐèÔÛH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì H‹ÚE3É3ÒE3ÀH‹éÿì,3ÿ…Àuÿh-‹Èè¡-ýÿ3ÀëR‹ðºH;ÞHGóH‹Îè{H‹ØH…Àu
èê-ýÿÇëD‹ÆH‹ÕH‹ÈèØH…Àt	H‹ËH‹ßH‹ùH‹ËèF\ýÿH‹ÇH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$H‰l$H‰t$WHƒì H‹ÚE3É3ÒE3ÀH‹éÿL,3ÿ…ÀuÿÀ,‹Èèù,ýÿ3ÀëR‹ðºH;ÞHGóH‹ÎèszH‹ØH…Àu
èB-ýÿÇëD‹ÆH‹ÕH‹Èè¬H…Àt	H‹ËH‹ßH‹ùH‹Ëèž[ýÿH‹ÇH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$WHƒì I‹ØH‹ÂH‹ùM…Àuèß,ýÿÇè˜2ÿÿ3ÀëE¹ÿÿÿÿH;Ùv
èÁ,ýÿÇ"ëåE3ÉL‹Ç‹ÓH‹Èÿp+‹ÈH;ËsÛ…Àuÿç+‹Èè ,ýÿëºH‹ÇH‹\$0HƒÄ _ÃH‰\$WHƒì I‹ØH‹ÂH‹ùM…Àuèc,ýÿÇè2ÿÿ3ÀëE¹ÿÿÿÿH;Ùv
èE,ýÿÇ"ëåE3ÉL‹Ç‹ÓH‹Èÿü*‹ÈH;ËsÛ…Àuÿk+‹Èè¤+ýÿëºH‹ÇH‹\$0HƒÄ _ËH‹	é"ÙÌÌ‹H‹	é^ÙÌÌA‹ÀL‹ÒL‹Á‹ÐI‹ÊE3ÉHÿ%œ*A‹ÀL‹ÒL‹Á‹ÐI‹ÊE3ÉHÿ%Œ*H‰\$H‰l$H‰t$WHƒì 3ÿI‹ØH‹òH…Ò„’@8:„‰H…Ét
èˆþÿÿéŒE3ÉE3À3ÒH‹Îÿ6*…Àuÿ´*‹Èèí*ýÿëk‹èºH;ÝHGëH‹ÍèixH‹ØH…Àuè8+ýÿ3ÉÇè³Yýÿë9D‹ÅH‹ÖH‹ÈèþÿÿH…ÀuH‹Ëëá3Éè’YýÿH‹ûë¸ÿÿÿH;ØBËÐèØH‹øH‹\$0H‹ÇH‹l$8H‹t$@HƒÄ _ÃH‰\$H‰l$H‰t$WHƒì 3ÿI‹ØH‹òH…Ò„’f9:„‰H…Ét
è þÿÿéŒE3ÉE3À3ÒH‹ÎÿZ)…ÀuÿÐ)‹Èè	*ýÿëk‹èºH;ÝHGëH‹Íè…wH‹ØH…ÀuèT*ýÿ3ÉÇèÏXýÿë9D‹ÅH‹ÖH‹Èè·ýÿÿH…ÀuH‹Ëëá3Éè®XýÿH‹ûë¸ÿÿÿH;ØBËÐè×H‹øH‹\$0H‹ÇH‹l$8H‹t$@HƒÄ _ÃL‹ÂE3ÉfD9	t(I‹ÀfE9tA·f;tHƒÀ·f…ÒuïHƒÁëÖH‹ÁÃ3ÀÃÌHƒì(‹¾öL‹ÊL‹ÑE3À…ÀueH…Éuè›)ýÿÇèT/ÿÿ¸ÿÿÿHƒÄ(ÃH…ÒtáL+ÒC·
B¿fƒøwfƒÂ A·	A¿fƒøwfƒÁ IƒÁf…Òtf;ÑtÏ·É·Â+ÁHƒÄ(ÃHƒÄ(éÌÌÌH‹ÄH‰XH‰hH‰pWHƒì@H‹úH‹ñI‹ÐHHØèò•ûÿ3íH…ötH…ÿuèý(ýÿÇè¶.ÿÿ¸ÿÿÿë|H‹D$(H9¨8u4H+÷·>C¿fƒøwfƒÃ ·A¿fƒøwfƒÁ HƒÇf…Ût9f;ÙtÑë2·HT$(èTÖ·HT$(·ØHvè@ÖH·Èf…Ûtf;ØtηɷÃ+Á@8l$8tH‹L$ ƒ¡¨ýH‹\$PH‹l$XH‹t$`HƒÄ@_ÃÌÌÌH‰\$H‰l$H‰t$WAVAWHƒì03ÿH‹òH‹éH…Éuè(ýÿÇèÓ-ÿÿ3Àé¡H…Òtäè>Eÿÿ…À‰|$(D‹ÿH‰>A”ÇH‰|$ A‹ÏAƒÉÿL‹Å3Òÿg%Lcð…Àuÿ'‹ÈèS'ýÿë²I‹ÎHÉè2$ÿÿH‹ØH…Àt=D‰t$(AƒÉÿL‹ÅH‰D$ 3ÒA‹Ïÿ"%…ÀuÿØ&‹Èè'ýÿëH‹ÃH‹ßH‰¿H‹Ëè¥#ÿÿ‹ÇH‹\$PH‹l$XH‹t$`HƒÄ0A_A^_ÃÌÌH‰\$H‰l$H‰t$WAVAWHƒì@3ÿH‹òH‹éH…Éuè"'ýÿÇèÛ,ÿÿ3Àé²H…ÒtäèFDÿÿH‰|$8…ÀD‹ÿH‰|$0A”lj|$(A‹ÏH‰>AƒÉÿH‰|$ L‹Å3Òÿ]'Lcð…Àuÿ&‹ÈèQ&ýÿë¨I‹Îè3#ÿÿH‹ØH…ÀtGH‰|$8AƒÉÿH‰|$0L‹ÅD‰t$(3ÒA‹ÏH‰D$ ÿ'…ÀuÿÏ%‹Èè&ýÿëH‹ÃH‹ßH‰¿H‹Ëèœ"ÿÿ‹ÇH‹\$`H‹l$hH‹t$pHƒÄ@A_A^_ÃÌH‹Êéx"ÿÿH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	è_"ÿÿHƒ#HƒÄ [ÃÌ3ÀH9•ÀÃÌÌÌH‹Hƒ!ÃH‹Ã3ÀH9•ÀÃÌÌÌ@SHƒì H‹ÙH‹	è"ÿÿHƒ#HƒÄ [ÃÌH‰\$H‰l$H‰t$WHƒì º@‹ÊèÌ#ÿÿ3öH‹ØH…ÀtLH¨H;Åt=Hx0HOÐE3Àº èIJÿÿHƒOøÿH‰7ÇG

ÆG
€g
ø@ˆwH@HGÐH;ÅuÇH‹ó3Éè—!ÿÿH‹\$0H‹ÆH‹t$@H‹l$8HƒÄ _ÃÌÌÌH…ÉtJH‰\$H‰t$WHƒì H±H‹ÙH‹ùH;ÎtH‹Ïÿa%HƒÇ@H;þuîH‹ËèLcewAƒü;‡0tºü‹Ëèqÿÿ„Àtƒÿ~ÿÆè!àÿÿ3ÿHM¯‰}¯‰}·‰}³è1Íÿÿ…À…RHM·èPÍÿÿ…À…,HM³èoÍÿÿ…À…Hc}·‹+Aº…ëQDCÿA‹Â÷éA‹ÂD‹ÊA÷èAÁùA‹ÀÁúA‹ÉÁéDÉ‹ÊÁéÑD+Ê™ƒâHcÃÁùHƒÀºƒÁïAÉHcÑHiÈmHcÆHÑHÐHcE³HRHÍIÍHkÑÿÿH‹\$`H‹l$hH‹t$pH‹|$xHƒÄPA^ÃÌH‹ÄH‰XH‰hH‰pH‰x AVHƒìPA‹ðL‹òH‹ÙèCÿÿ@Šèÿ|3ÿ…ÀtH…Ût	H‹Ëÿ@„ít
¸é­èˆ@ÿÿ„ÀuÿJ÷ØÀ÷؃Àé@„ítdH‰|$(LL$0L6‰|$ 3ÒL‰t$03ÉH‰\$8‰t$@‰|$DÿžH‹ØHƒøÿtE3ÀƒÊÿH‹ÈÿŽ…Àu‹|$DHƒûÿt	H‹Ëÿÿ‹Çë'è†Aÿÿ„Àuºî3Éëè­@ÿÿH‹ÈD‹ÎM‹ÆH‹Óè>ÿÿH‹\$`H‹l$hH‹t$pH‹|$xHƒÄPA^ÃÌE‹	M‹H‹H‹	éc=ÿÿÌÌÌE‹	M‹H‹H‹	é×=ÿÿÌÌÌE‹	M‹H‹H‹	é;=ÿÿÌÌÌE‹	M‹H‹H‹	é¯=ÿÿÌÌÌE‹	M‹H‹H‹	é=ÿÿÌÌÌE‹	M‹H‹H‹	é‡=ÿÿÌÌÌ@SHƒì D‹IH‹ÙL‹H‹Q3Éèá<ÿÿ‰C3ÀHƒÄ [ÃÌÌ@SHƒì D‹IH‹ÙL‹H‹Q3ÉèA=ÿÿ‰C3ÀHƒÄ [ÃÌÌH‹	Hÿ%nÌÌH‹	Hÿ%ZÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒìPA‹ðL‹òH‹ÙèAÿÿ@Šèÿ€3ÿ…ÀtH…Ût	H‹Ëÿ@„ít
¿é©èŒ>ÿÿ„ÀuÿN÷Øÿ÷߃ÇéŒ@„ít^H‰|$(LL$0Lÿÿÿ‰|$ 3ÒL‰t$03ÉH‰\$8‰t$@‰|$Dÿ¢H‹ØHƒøÿtME3ÀƒÊÿH‹Èÿ’H‹Ë…Àtÿ
ë/‹|$Dëòè?ÿÿ„Àuºî3Éëè·>ÿÿH‹ÈD‹ÎM‹ÆH‹Óèš;ÿÿ‹øH‹\$`‹ÇH‹|$xH‹l$hH‹t$pHƒÄPA^ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒìPA‹ðL‹òH‹Ùèù?ÿÿ@Šèÿd3ÿ…ÀtH…Ût	H‹Ëÿø@„ít
¿é©èp=ÿÿ„Àuÿ2÷Øÿ÷߃ÇéŒ@„ít^H‰|$(LL$0Lþÿÿ‰|$ 3ÒL‰t$03ÉH‰\$8‰t$@‰|$Dÿ†H‹ØHƒøÿtME3ÀƒÊÿH‹ÈÿvH‹Ë…Àtÿñë/‹|$Dëòèt>ÿÿ„Àuºî3Éëè›=ÿÿH‹ÈD‹ÎM‹ÆH‹Óè;ÿÿ‹øH‹\$`‹ÇH‹|$xH‹l$hH‹t$pHƒÄPA^ÃÌÌÌH;ÊsƒÈÿÃ3ÀH;Ê—ÀÃÌÌH;ÊsƒÈÿÃ3ÀH;Ê—ÀÃÌÌH‰\$H‰T$UVWATAUAVAWH‹ìHƒì`3ÿH‹ÙH…Òuèýÿ_‰èÏÿÿ‹Ãé WÀH‰:H99óEàH‰}ðtWH‹HUPfÇEP*?@ˆ}Rè^ÀH‹H…ÀuLMàE3À3ÒèÀëLEàH‹ÐèÖD‹ð…Àu	HƒÃH9;ë´L‹eèH‹uàéùH‹uàL‹ÏL‹eèH‹ÖI‹ÄH‰}PH+ÆL‹ÇL‹øIÁÿIÿÇHHHÁéI;ôHGÏIƒÎÿH…Ét%L‹I‹ÆHÿÀA8<u÷IÿÁHƒÂLÈIÿÀL;ÁußL‰MPA¸I‹ÑI‹ÏèΟþÿH‹ØH…ÀtwJøL‹þH‰UØH‹ÂH‰UXI;ôtVH‹ËH+ÎH‰MÐM‹M‹îIÿÅC8<(u÷H+ÐIÿÅHUPM‹ÍH‹ÈèEÞÿÿ…À……H‹EXH‹MÐH‹UØJ‰9IÅIƒÇH‰EXM;üu´H‹EHD‹÷H‰3ÉèÜÿÿI‹ÜL‹þH+ÞHƒÃHÁëI;ôHGßH…ÛtI‹è·ÿÿHÿÇMH;ûuìH‹Îè£ÿÿA‹ÆH‹œ$ HƒÄ`A_A^A]A\_^]ÃE3ÉH‰|$ E3À3Ò3ÉèLÿÿÌÌÌÌH‰\$UVWATAUAVAWH‹ìHì€H‹Ó¼H3ÄH‰Eð3ÿH‰UØH‹ÙH…Òuèùýÿ_‰è³ÿÿ‹Ãé§WÀH‰:H99óE¸H‰}ÈtXH‹HUèÇEè*?f‰}ìèÉåÿÿH‹H…ÀuLM¸E3À3Òè³ëLE¸H‹ÐèeD‹ð…Àu	HƒÃH9;ë³L‹eÀH‹u¸éÿH‹u¸L‹ÏL‹eÀH‹ÖI‹ÄH‰}èH+ÆL‹ÇL‹øIÁÿIÿÇHHHÁéI;ôHGÏIƒÎÿH…Ét&L‹I‹ÆHÿÀfA9éÿÿÿL‹Òƒù	uA7ÃA¹‹ÑI‹ÊEA>éäþÿÿ‹ÑA¹3ÉA¸éÏþÿÿÌÌÌH‹ÂA¹‹ÑA¸H‹Èé³þÿÿÌÌÌ‹ÑA¹3ÉE3ÀéžþÿÿÌÌH‹ÂA¹‹ÑE3ÀH‹Èé†þÿÿÌÌ3ÒéÌH‰\$WHƒì@‹ùH‹ÚHL$ èçbûÿH‹D$0H…Àt x¤uA¹E3À‹×H‹Ëè=þÿÿ‹Èë3É€|$8tH‹D$ ƒ ¨ý‹ÁH‹\$PHƒÄ@_ÃÌÌÌ‹ÑA¹3ÉE3ÀéþÿÿÌÌH‹ÂA¹‹ÑE3ÀH‹ÈéêýÿÿÌÌ‹ÑA¹3ÉE3ÀéÖýÿÿÌÌH‹ÂA¹‹ÑE3ÀH‹Èé¾ýÿÿÌÌ‹ÑA¹3ÉE3ÀéªýÿÿÌÌH‹ÂA¹‹ÑE3ÀH‹Èé’ýÿÿÌÌ‹ÑA¹3ÉA¸Wé{ýÿÿÌÌÌH‹ÂA¹‹ÑA¸WH‹Èé_ýÿÿÌÌÌA¹‹Ñ3ÉEAéIýÿÿÌH‹ÂA¹‹ÑH‹ÈEAé1ýÿÿÌ‹ÑA¹3ÉE3ÀéýÿÿÌÌH‹ÂA¹‹ÑE3ÀH‹ÈéýÿÿÌÌH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	H…Ét
ÿÝòHƒ#HƒÄ [ÃÌÌÌ3ÀH9•ÀÃÌÌÌ@SHƒì H‹ÙH‹	H…Ét
ÿ­òHƒ#HƒÄ [ÃÌÌÌHƒì(ÿ–ò°HƒÄ(ÃÌÌÌ3ÒëHƒÈÿHÿÀf9Au÷HAHƒÁf9uæHAÃÌH‹Ã3ÀÃÌ3ÀH9•ÀÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì@ÿ=òE3öH‹ØH…À„¦H‹ðfD90tHƒÈÿHÿÀfD94FuöH4FHƒÆfD96uäL‰t$8H+óL‰t$0HƒÆHÑþL‹ÃD‹ÎD‰t$(3ÒL‰t$ 3ÉÿôHcè…ÀtLH‹ÍèèïþÿH‹øH…Àt/L‰t$8D‹ÎL‰t$0L‹Ã‰l$(3Ò3ÉH‰D$ ÿÉó…ÀtH‹÷I‹þëI‹öH‹ÏèfïþÿëI‹öH…Ût	H‹ËÿoñH‹\$PH‹ÆH‹t$`H‹l$XH‹|$hHƒÄ@A^ÃÌH‰\$H‰l$H‰t$WHƒì ÿ>ñ3öH‹ØH…Àt[ëHƒÉÿHÿÁf94Hu÷HHHƒÀf90uæH+ÃHƒÀHÑøH,H‹ÍèïþÿH‹øH…ÀtL‹ÅH‹ÓH‹ÈèlÝH‹÷3Éè¾îþÿH‹ËÿÑðH‹\$0H‹ÆH‹t$@H‹l$8HƒÄ _ÃÌH¥ÈÃH‹ÊéŒîþÿH‹Êé„îþÿH‰H‹ÁÃÌH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	ècîþÿHƒ#HƒÄ [ÃÌ@SHƒì H‹ÙH‹	èGîþÿHƒ#HƒÄ [ÃÌH‹Hƒ!ÃH‹Hƒ!Ã@SHƒì H‹ÙH‹	èîþÿHƒ#HƒÄ [ÃÌ@SHƒì H‹ÙH‹	èÿíþÿHƒ#HƒÄ [ÃÌHƒì(è{DÿÿHT$0H‹ˆH‰L$0H‹ÈèFÿÿH‹D$0‹@HƒÄ(ÃÌHƒì(èKDÿÿHT$0H‹ˆH‰L$0H‹ÈèÖEÿÿH‹D$0‹@HƒÄ(ÃÌHƒì(èDÿÿHT$0H‹ˆH‰L$0H‹Èè¦EÿÿH‹D$0H(HƒÄ(ÃÌÌHƒì(èçCÿÿHT$0H‹ˆH‰L$0H‹ÈèrEÿÿH‹D$0‹@HƒÄ(ÃÌH…É„ÇÿÿÿH‹‹@ÃL‹ÜI‰[I‰kI‰s WATAUAVAWHì H‹~H3ÄH‰„$˜L‹83ÛI‰K¨H‹ùI‰[°D‹ûD‹ó‹ëD‹ëM…À„ýLaH‰\$XsA9$u3ÒL‰d$ A¹IK¨èß¡…À…ºH‹Îèbîþÿ3ÉH‰D$Xè~ìþÿ½€º‹ÍèEîþÿ3ÉL‹øècìþÿH‹Ö‹Íè1îþÿ3ÉL‹ðèOìþÿH‹Ö‹Íèîþÿ3ÉH‹èè;ìþÿH‹Ö¹èîþÿ3ÉL‹èè$ìþÿH9\$X„M…ÿ„M…í„
M…ö„H…í„ûI‹Í‹ÃˆHÎÆ=|òA‹$H”$€ÿüí…À„΃¼$€‡À·„$€IŽH‹—8MM‰\$@‰D$PA‹$‰D$8¸ÿ‰D$0H‰L$(3ɉD$ D@è/h…À„qA‹$HH‹—8MM‰\$@A¸‰D$8¸ÿ‰D$0H‰L$(3ɉD$ èêg…À„,9t$P~58œ$†t,HŒ$‡8t ¶Qÿë
HcÂÖBÆ( ¶;Ð~ïHƒÁ8YÿuÜA‹$I‰\$0A¹‰D$(M‹ÅH‰L$`‹ÖH‰L$ 3Éè …À„ºD‹d$PI‡þf‰Aˆ^ˆ]Aˆž€ˆ€H‰D$hD;æ~?8œ$†t6HŒ$‡8t*¶QÿëHcÂA¸€ÖfE‰„G¶;Ð~åHƒÁ8YÿuÒI¸€IAAOA I0AG AO0A@IPAG@AOPA`AG`LøApHÈAGð	H‹ApAAI AGA0AO I@AG0APAO@I`AGPAO`I‰Gp‹AxA‰Gx·A|fA‰G|A‹†xA†AŽAA† ANAŽ0AF A†@AN0AŽPAF@A†`ANPòAŽpAF`òANpA‰FxA·†|fA‰F|AŠ†~AˆF~…‹…xE… M0E …@M0PE@…`MPòpE`òMp‰Ex·…|f‰E|Š…~ˆE~H‹H…ÉtNƒÈÿðÁ;ÆuCH‹HéþènèþÿH‹A¿€I+ÏèYèþÿH‹I+ÏèJèþÿH‹è>èþÿH‹D$X‰0H‰‡H‹D$`H‰H‹D$hH‰‡I†€H‰‡H…€H‰‡D‰gë$H‹L$XèðçþÿI‹ÏèèçþÿI‹ÎèàçþÿH‹ÍèØçþÿ‹ÞI‹ÍèÎçþÿ‹ÃëMH‹H…ÀtðÿHxUH‰™H‰¾HâWH‰™H‰HMYH‰3À‰qH‹Œ$˜H3Ìè1©úÿLœ$ I‹[8I‹k@I‹sHI‹ãA_A^A]A\_ÃH‹ÊéDçþÿH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	è+çþÿHƒ#HƒÄ [ÃÌH‹Hƒ!Ã@SHƒì H‹ÙH‹	èçþÿHƒ#HƒÄ [ÃÌH…É„SHƒì H‹ÙH‹IH;
¬¡tèÙæþÿH‹K H;
¢¡tèÇæþÿH‹K(H;
˜¡tèµæþÿH‹K0H;
Ž¡tè£æþÿH‹K8H;
„¡tè‘æþÿH‹K@H;
z¡tèæþÿH‹KHH;
p¡tèmæþÿH‹KhH;
~¡tè[æþÿH‹KpH;
t¡tèIæþÿH‹KxH;
j¡tè7æþÿH‹‹€H;
]¡tè"æþÿH‹‹ˆH;
P¡tè
æþÿH‹‹H;
C¡tèøåþÿHƒÄ [ÃÌÌH‰\$H‰t$H‰|$UATAUAVAWH‹ìHƒì@3ÛH‰MðH‹ñD‹ûH‰]øH9™@uH9™HuD‹ãL5Y étA½º˜A‹Íèeçþÿ3ÉL‹ðèƒåþÿM…öuA‹Åé ¿I‹Í‹×è?çþÿ3ÉL‹àè]åþÿM…äu
I‹ÎèPåþÿëÐH9ž@„RH‹×I‹Íèçþÿ3ÉL‹øè,åþÿM…ÿu
I‹ÎèåþÿI‹ÌëÅH‹¾@IFL‹ÇH‰D$ A¹HMðA‹Õè5šIN A¹H‰L$ L‹ÇHMðA‹Õ‹ØèšIN(A¹H‰L$ L‹ÇHMðA‹ÕØèõ™ØHMðIF0A¹L‹ÇH‰D$ A‹ÕèÕ™A¹Mn8L‹ÇL‰l$ HMðØAQéè´™A¹PHMðØL‹ÇIF@H‰D$ AQ±è“™A¹QHMðØL‹ÇIFHH‰D$ AQ°èr™ØHMðIFPA¹L‹ÇH‰D$ 3ÒèS™ØHMðIFQA¹L‹ÇH‰D$ 3Òè4™ØHMðIFRA¹TL‹ÇH‰D$ 3Òè™ØIFSA¹UL‹ÇH‰D$ 3ÒHMðèö˜ØHMðIFTA¹VL‹ÇH‰D$ 3ÒèטØHMðIFUA¹WL‹ÇH‰D$ 3Ò踘ØHMðIFVA¹RL‹ÇH‰D$ 3Ò虘ØHMðIFWA¹SL‹ÇH‰D$ 3Òèz˜A¹HMðØL‹ÇIFhH‰D$ AQíèY˜A¹HMðØL‹ÇIFpH‰D$ AQîè8˜A¹HMðØL‹ÇIFxH‰D$ AQìè˜A¹HMðØL‹ÇI†€H‰D$ AQëèó—A¹PHMðØL‹ÇI†ˆH‰D$ AQ²èÏ—ØI†A¹QH‰D$ L‹ÇHMðAQ±è«—Ãt*I‹ÎècûÿÿI‹ÎèWâþÿI‹ÌèOâþÿI‹ÏèGâþÿ¸égI‹U3Û8„¨Š
AÐ<	w€é0ˆ
A½IÕ8uå鎀ù;uéL‹ÂIHŠAˆL‹Á„ÀuðA½ë×Hœœº€AHAN@ AF H0AN0@@AF@HPANP@`AF`@pADðAH‹DI‰DëA½H‹†øH‹I‰H‹†øH‹HI‰NH‹†øH‹HI‰NH‹†øH‹HXI‰NXH‹†øH‹H`I‰N`E‰,$M…ÿtE‰/H‹†ðH…ÀtðÿH‹ŽàH…Ét$ƒÈÿðÁƒøuH‹ŽøèùàþÿH‹ŽàèíàþÿL‰¾ð3ÀL‰¦àL‰¶øL\$@I‹[0I‹s8I‹{@I‹ãA_A^A]A\]ÃE3ÉH‹ÑD8	tŠ
AÐ<	w€é0ˆ
HÿÂD8
uêÀù;uòL‹ÂIHŠAˆL‹Á„ÀuðëàH…ÉtfSHƒì H‹ÙH‹	H;
›tè^àþÿH‹KH;
›tèLàþÿH‹KH;
›tè:àþÿH‹KXH;
;›tè(àþÿH‹K`H;
1›tèàþÿHƒÄ [ÃH‹ÄH‰XH‰hH‰pWATAUAVAWHƒì@3ÛH‰HÈH‹ñH‰XÐH9™HuH9™@uD‹ûL5šD‹ã齺˜‹ÍèŠáþÿL‹ðH…Àu‹ÅéSH‹†øº€z„‹ÏAHAN@ AF H0AN0@@AF@HPANP@`AF`@pADðAH‹DI‰Dèsßþÿ3ÉL‹àè)ßþÿM…äu
I‹ÎèßþÿémÿÿÿA‰$H9žH„H‹Ïè>ßþÿ3ÉL‹øèôÞþÿM…ÿ„·A‰HL$0H‹¾HA¹L‹ÇL‰t$ ‹Õè”INA¹H‰L$ L‹ÇHL$0‹Õ‹Øèç“MnA¹L‹ÇL‰l$ ‹ÕHL$0ØèÇ“A¹HL$0ØL‹ÇIFXH‰D$ AQô襓A¹HL$0ØL‹ÇIF`H‰D$ AQó胓ÃtI‹Îè»ýÿÿƒÍÿI‹Îè,ÞþÿI‹ÌéÿÿÿI‹U3ÛëŠ
AÐ<	w€é0ˆ
HÕ8uëëS€ù;uòL‹ÂIHŠAˆL‹Á„ÀuðëàH‹˜˜L‹ûI‰H‹“˜I‰FH‹˜I‰FH‹͘I‰FXH‹ʘI‰F`A‰,$M…ÿtA‰/H‹†èH…ÀtðÿH‹ŽàH…Ét$ƒÈÿðÁƒøuH‹ŽàèsÝþÿH‹ŽøègÝþÿL‰¾è3ÀL‰¦àL‰¶øL\$@I‹[0I‹k8I‹s@I‹ãA_A^A]A\_ÃÌÌE3ÉH‹ÑD8	tŠ
AÐ<	w€é0ˆ
HÿÂD8
uêÀù;uòL‹ÂIHŠAˆL‹Á„ÀuðëàH‹ÊéìÜþÿºévÌ̺éjÌ̺é^Ì̺éRÌ̺éFÌ̺é:ÌÌH‰H‹ÁÃÌ@SHƒì H‹ÙH‹	è‹ÜþÿHƒ#HƒÄ [ÃÌ3ÀH9•ÀÃÌÌÌH‹Hƒ!ÃH‰\$H‰t$WHƒì 3ÿHÑH‹ðH‹ÙH+ñHƒÆHÁîH;ÈHG÷H…ötH‹è2ÜþÿHÿÇH[H;þuìH‹\$0H‹t$8HƒÄ _ÃÌÌH‹ÃH‰\$WHƒì Hƒ¹PH‹ùu	HÖAë;ºÀ¹è¹ÝþÿH‹ØH…ÀtH‹×H‹Èè6„Àu H‹Ëèž3ÿH‹Ëè¸ÛþÿH‹ÇH‹\$0HƒÄ _Ãǃ\H‹û3ÛëÙÌH‰\$H‰t$H‰|$ UATAUAVAWH‹ìHƒì@L‹²PL‹ùE3äH‰UðI‹ÎL‰eøè0‰þÿI‰‡¸El$1A‹ôHÇE0AMи%I’$÷á‹ÁE‹Í+ÂM‹ÆÑèºÁèkÀ+È‹ùIÏHMðH‰D$ èKðEMùIG8M‹ÆHøºHMðH‰D$ è'ðHMðI‡`E‹ÍHøM‹ÆºH‰D$ èðEMùI‡˜M‹ÆHøºHMðH‰D$ èÚðAÿÅHƒm0…EÿÿÿA½8I¿ÐEeÔHG M‹ÆEMH‰D$ ºHMðè›E‹ÍH‰|$ M‹ÆHMðºðè€ðEMH‡»M‹ÆH‰D$ ‹ÓHMðè[ðHMðH‡`E‹ÍM‹ÆH‰D$ ‹Óè<ðHƒÇAÿÅIƒì…pÿÿÿI‡0M‹Æ{&H‰D$ D‹ÏSÿHMðèð_I‡8D‹ËEl$H‰D$ M‹ÆHMðA‹ÕèàŽD‹ÏHMðð{ÙI‡‹×M‹ÆH‰D$ 辎ðHMðI‡˜D‹ËM‹ÆH‰D$ ‹×蟎ðDcöI‡@E‹ÌM‹ÆH‰D$ A‹ÕHMðè{Žð{÷I‡HD‹ÏM‹ÆH‰D$ A‹ÕHMðèXŽðHMðI‡P»D‹ËH‰D$ M‹ÆA‹Õè3ŽðDKI‡XM‹Æ3ÒH‰D$ HMðèŽE‹ÌHMððEeI‡ A‹ÔM‹ÆH‰D$ èïðI‡¨D‹ÏH‰D$ M‹ÆHMðA‹ÔèÏI°D‹ËH‰L$ M‹ÆHMðA‹Ôðè¯L\$@ÆI‹[8I‹s@”ÀI‹{HI‹ãA_A^A]A\]Ã3ÀH9•ÀÃÌÌÌ@SHƒì H‹ÙH‹	è/ØþÿHƒ#HƒÄ [ÃÌH…É„þH‰\$H‰l$VHƒì ½H‹Ù‹Õè‘ûÿÿHK8‹Õè†ûÿÿu‹ÖHKpèxûÿÿH‹Ð‹ÖèjûÿÿH‹0Uûè[ûÿÿH‹‹@è»×þÿH‹‹Hè¯×þÿH‹‹Pè£×þÿH‹`‹Õè)ûÿÿH‹˜‹ÕèûÿÿH‹Ð‹Öè
ûÿÿH‹0‹ÖèÿúÿÿH‹UûèðúÿÿH‹‹ èP×þÿH‹‹¨èD×þÿH‹‹°è8×þÿH‹‹¸è,×þÿH‹\$0H‹l$8HƒÄ ^ÃH‰\$WHƒì Hƒ¹PH‹ùu	Hâ<ëRºÀ¹èÅØþÿH‹ØH…Àu3ÉëH‹×H‹Èè>ûÿÿ„ÀuH‹Ëè¦þÿÿH‹ËèÂÖþÿ¸ë&3Éǃ\èªÖþÿH‹ èš3ÀH‰Ÿ H‹\$0HƒÄ _ÃÌÌE3ÒL‹ÊfD9H‹Át)M‹ÁfE9tA·f9tIƒÀA·f…ÒuîHƒÀfD9ëÕH+ÁHÑøÃÌM…Àu3À÷f…Àtf;uHƒÁHƒÂIƒèuå··
+ÁÃ@UATAUAVAWHƒì`Hl$0H‰]`H‰uhH‰}pH‹z†H3ÅH‰E D‹êE‹ùH‹ÑM‹àHMè‚Fûÿ‹µˆ…öuH‹E‹p÷E‹ÏM‹Ä‹ÎÒƒd$(Hƒd$ ƒâÿÂÿ÷ÖLcð…Àu3ÿéñI‹þHÿHOH;ùHÀH…ÁtuHOH;ùHÀH#ÁH=HGw:H;øHÉH#ÈHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèÖÂH+àH\$0H…ÛtyÇÌÌëH;øHÉH#Èè_ÕþÿH‹ØH…ÀtÇÝÝHƒÃë3ÛH…ÛtHL‹Ç3ÒH‹Ëè[¯úÿE‹ÏD‰t$(M‹ÄH‰\$ º‹Îÿ.Ö…ÀtL‹€D‹ÀH‹ÓA‹ÍÿØ‹øë3ÿH…ÛtHKð9ÝÝuè¤Ôþÿ€}tH‹Eƒ ¨ý‹ÇH‹M H3ÍèI–úÿH‹]`H‹uhH‹}pHe0A_A^A]A\]ÃÌÌÌðÿAH‹àH…ÀtðÿH‹ðH…ÀtðÿH‹èH…ÀtðÿH‹H…ÀtðÿHA8A¸HÈH9PðtH‹H…ÒtðÿHƒxètH‹PøH…ÒtðÿHƒÀ IƒèuËH‹‰ éyÌH‰\$H‰l$H‰t$WHƒì H‹øH‹ÙH…ÀtyH
fŽH;ÁtmH‹ƒàH…Àtaƒ8u\H‹‹ðH…Étƒ9uè†ÓþÿH‹‹øè~ìÿÿH‹‹èH…Étƒ9uèdÓþÿH‹‹øèÜòÿÿH‹‹àèLÓþÿH‹‹øè@ÓþÿH‹ƒH…ÀtGƒ8uBH‹‹HéþèÓþÿH‹‹¿€H+ÏèÓþÿH‹‹H+ÏèùÒþÿH‹‹èíÒþÿH‹‹ è¥H³(½H{8Hv‡H9GðtH‹H…Étƒ9u
è²ÒþÿH‹èªÒþÿHƒètH‹OøH…Ét
ƒ9uèÒþÿHƒÆHƒÇ Hƒíu±H‹ËH‹\$0H‹l$8H‹t$@HƒÄ _éfÒþÿÌÌH…ÉtH<8H;Èt¸ðÁ\ÿÀøÿÿÿÃÌH…Ét0SHƒì H8H‹ÙH;Èt‹\…Àu
èðùÿÿH‹ËèÒþÿHƒÄ [ÃÌÌH…ÉtHÜ7H;ÈtƒÈÿðÁ\ÿÈøÿÿÿÃÌÌÌHƒì(H…É„–AƒÉÿðDIH‹àH…ÀtðDH‹ðH…ÀtðDH‹èH…ÀtðDH‹H…ÀtðDHA8A¸H!†H9PðtH‹H…ÒtðD
Hƒxèt
H‹PøH…ÒtðD
HƒÀ IƒèuÉH‹‰ è5ÿÿÿHƒÄ(ÃH‰\$WHƒì èµ'ÿÿH‹ø‹
xŒ…ˆ¨tH‹˜H…Ûu6¹è¢ÿÿHH‹Ó©è&H‹Ø¹èÕÿÿH…ÛuèSÒþÿÌH‹ÃH‹\$0HƒÄ _ÃH‰\$WHƒì H‹úH…ÒtIH…ÉtDH‹H;ÚuH‹Âë9H‰H‹Êè-üÿÿH…Ût"H‹Ëè¬þÿÿƒ{uH¿ƒH;ØtH‹Ëè’üÿÿH‹Çë3ÀH‹\$0HƒÄ _ÃH‰\$WHìðH‹Ì€H3ÄH‰„$àIH‹ÙHL$0ºUèÈ÷þÿƒø~2IƒÉÿHD$03ÿIÿÁfB9ÔþÿÌÌH‰\$H‰t$WHì0H‹ÏzH3ÄH‰„$ H‹ùèÈ ÿÿA¹xLD$0H˜˜‹K÷ÙH‹ÏÒâðÿÿÂèðþÿ3ö…Àu‰sFëIH‹HT$0èø£ÿÿ…Àu-IƒÉÿIÿÁfB94OuöIÿÁH‹XL‹ÇºUèï´ÿÿ…Àu4ƒK‹CÁè÷ЃàH‹Œ$ H3Ìèh‹úÿLœ$0I‹[I‹s I‹ã_ÃE3ÉH‰t$ E3À3Ò3ÉèSÓþÿÌÌÌH‰\$H‰t$WHƒì 3öH‹úH‹ÙH…ÉtVf91tQHlSèS€…ÀtAHdSH‹Ëè@€…Àu$HXº DNLD$0èïþÿ…Àt0‹D$0ë™+ÂÑøHcèL‹õIÁæK‹&蘡ÿÿ…Àu
IL$IÎI‰ë
y}ÿëu;÷~¿…ÀH‹l$H”ÃH‹t$P‹ÃH‹\$@H‹|$XHƒÄ A_A^A\ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAVAWHƒì0I‹èH‹òL‹ñè­ÿÿE3äH˜˜I†€D‰cL»XL‰3H{fE‰'H‰fD9 tL‹ÇAT$H
rEèõþÿÿH‹H‹ËfD9 tMH‹fD9 tè÷ÿÿëèÔ÷ÿÿD9cuAL‹ÃH
Aº@èºþÿÿ…ÀtH‹H‹ËfD9 tèÕöÿÿëèž÷ÿÿëèöÿÿD9c„IŽH‹Óèêüÿÿ‹Ø…À„÷ˆÿÿƒù†è·Èÿ|È…À„×H…öt‰H…í„ÀHµ IƒÉÿfD‰&IÿÁfG9$OuöIÿÁM‹ÇºUH‹Îè$±ÿÿ…À…´DH@L‹ÅºH‹ÎèØëþÿ…Àt{H½€A¹@L‹ÇºH‹Îè·ëþÿ…ÀtZº_H‹Ï観H…ÀuP.H‹Ïè–³H…ÀtA¹@L‹ÇH‹ÎAQÇè|ëþÿ…ÀtA¹
H•‹ËEAèø¸ë3ÀH‹\$PH‹l$XH‹t$`H‹|$hHƒÄ0A_A^A\ÃE3ÉL‰d$ E3À3Ò3ÉèÏþÿÌÌÌÌH‰\$H‰l$H‰t$ WHì H‹ŽuH3ÄH‰„$H‹Ùè‡ÿÿH‹èèÿÿH‹ËH‹¸ èø‹´LD$ ÷ÙA¹x‹È‹ðÒâðÿÿÂÿ©É3Û…Àu‰CëCH‹ HT$ 蟞ÿÿ…Àu$H
¸Nf;1tÿÃHƒÁHcÃHƒø
r색w‰w‹Áè÷ЃàH‹Œ$H3Ìè†úÿLœ$ I‹[I‹k I‹s(I‹ã_ÃH‰\$WHƒì H‹ÙèºÿÿHƒÊÿL‹À3ÿH‹€ HÿÂf9H„HH‹Ëè`u…Àu!‹ODNLD$0º ÿ1Ã…Àt-‹D$0ë9H‹ËèOÃþÿë/‹OLD$0A¹º ÿÃ…Àu3Àë‹D$0…Àuÿ¦ÂH‹\$8H‹t$@HƒÄ _ÃÌÌE3ÉL
HAAfA;tDÈIƒÀIcÑHƒú
rêÃ3ÀÃH‰\$H‰t$WHƒì ‹ò‹Ùè8ÿÿ‹ËLD$0áÿA¹ºé
º H‹øÿwÂE3Ò…Àu3ÀëS;\$0tH…ötDL‹˜E‹ÂA·IIB¿fƒøv
fƒêafƒúw·AÿÀHƒÁëáHƒÈÿHÿÀfE9AuöD;Àt®¸H‹\$8H‹t$@HƒÄ _ÃÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì 3öM‹ð‹ÚH‹é…Òx0I‹™+ÂÑøHcøH‹×HÒH‹TÕè×–ÿÿ…Àt+y_ÿëw;ó~Ð2ÀH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A^ÃH‹ÇHÁàHƒÀHÅI‰°ëÐÌÌÌ@USVWATAVAWH‹ìHƒì@H‹ólH3ÄH‰EðI‹øL‹úL‹ñèêÿÿH‹ð3ÀH‰Eà‰EèèÙÿÿHMàE3äHž H‰ˆ I†€L‰¶˜H‰H…ÀtfD9 t‹<H
Ÿ:ÿÊL‹ÃèíþÿÿD‰eàH‹†˜H…ÀtyfD9 tsH‹H…ÀtfD9 tHMàèøÿÿë	HMàèáøÿÿD9eà…½‹=:L†˜ÿÊH
6èþÿÿ„À„H‹H…ÀtfD9 tHMàèÍ÷ÿÿëwHMàè’øÿÿëlH‹H…ÀtQfD9 tKèõÿÿH‹ÐHƒÉÿH‹€ HÿÁfD9$HuöHƒùA‹ÄH
öÿÿ”À‰‚´ºÿ7ÀöEàuD‰eàëÇEàÿÀ‰Eè‰EäD9eà„êI†I÷ÞHUàHÉH#ÈèQüÿÿ‹Ø…À„Ljÿÿƒù†¸·Èÿ½…À„§‹Mäºÿ­¿…À„‘M…ÿtA‰‹MäH–ðE3ÉAqUD‹ÆèèãþÿH…ÿtd‹MäH— E3ÉD‹ÆèÎãþÿ‹Mä¾@D‹ÎL‹ÇºÿI¿…Àt9‹MèL‡€D‹Îºÿ-¿…ÀtH—‹ËDNÊDFÐ诸ë3ÀH‹MðH3ÌèÎ{úÿHƒÄ@A_A^A\_^[]ÃÌÌÌHƒì(èÿÿHT$0H‹ˆH‰L$0H‹Èè
ÿÿH‹D$0H‹€øHƒÄ(ÃÌéÌÌÌH‰\$H‰l$H‰t$WHƒì I‹èH‹ÚH‹ñH…Òt3ÒHBàH÷óI;ÀsèK½üÿÇ3ÀëAH…Ét
èïpH‹øë3ÿH¯ÝH‹ÎH‹ÓèÿÿH‹ðH…ÀtH;ûsH+ßH8L‹Ã3Ò裓úÿH‹ÆH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‹9“ÃHƒì(ÿ&»H…ÀH‰$“•ÀHƒÄ(ÃHƒ%“°ÃÌH‹	“ÃH‰\$H‰l$H‰t$WHƒì H‹òH‹ùH;Êu°ë\H‹ÙH‹+H…ítH‹Íÿá¾ÿÕ„Àt	HƒÃH;ÞuàH;ÞtÔH;ßt-HƒÃøHƒ{øtH‹3H…öt
H‹Îÿ¬¾3ÉÿÖHƒëHCH;Çu×2ÀH‹\$0H‹l$8H‹t$@HƒÄ _ÃH‰\$H‰t$WHƒì H‹ñH;Êt&HZøH‹;H…ÿt
H‹ÏÿX¾3Éÿ×HƒëHCH;ÆuÞH‹\$0°H‹t$8HƒÄ _ÃÌH‹…h¹@‹Âƒà?+È3ÀHÓÈH3ÂÃH‹ihH‹Ñ‹ÈH3ƒá?HÓÈÃÌÌL‹QhH‹ÁA‹Ð¹@ƒâ?+ÊHÓÈI3ÀÃÌÌH‹1h¹@‹Âƒà?+È3ÀHÓÈH3ÂH‹ÈéµÌE3ÀHAL‹ÈL+ÉIƒÁIÁéH;ÈMGÈM…ÉtIÿÀH‰HIM;ÁuñÃÌÌÌH‹ÁÃH‰
u‘ÃH‰\$WHƒì H‹ùè.H‹ØH…ÀtH‹ÈÿY½H‹ÏÿÓ…Àt¸ë3ÀH‹\$0HƒÄ _Ã@SHƒì 3Éè§ùþÿH‹g‹Ëƒá?H3‘HÓË3ÉèÝùþÿH‹ÃHƒÄ [ÃH‰\$WHƒì H‹ù3ÉèlùþÿH‹Dg‹Âƒà?H‹ÚH3Õ‹ÈHÓ˹@+ÈHÓÏH3úH‰=¼3Éè‰ùþÿH‹ÃH‹\$0HƒÄ _ÃÌÌÌH‹ýf¹@‹Âƒà?+È3ÀHÓÈH3ÂÃH‰\$L‰L$ WHƒì I‹ù‹
èïøþÿH‹Çf‹Ëƒá?H3{HÓË‹è%ùþÿH‹ÃH‹\$0HƒÄ _ÃÌÌÌH‹ÄHƒì(‰HLH‰H L‹ÂHP HHè—ÿÿÿHƒÄ(ÃÌÌH‹qfH‹Ñ‹ÈH3ƒá?HÓÈÃÌÌL‹YfH‹ÁA‹Ð¹@ƒâ?+ÊHÓÈI3ÀÃÌÌ‹‰H‹ÁˉH‹ÁË	éIøþÿÌ‹	é•øþÿÌH‹f‹ÈH3Ѓá?HÓÈÃÌH‰\$WHƒì ‹Ù¹èøþÿH‹êe‹Âƒà?‹È…ÛH‹ÚuL…H3~¿ëLxH3q¿HÓËHƒûr¹@+È3ÀHÓÈH3ÂI‰¹èøþÿH…Ûu3ÀëHƒût
H‹Ëÿ»‹ÏÿÓ¸H‹\$0HƒÄ _ÃÌÌ̃ét/ƒétƒé	tƒétƒùt3ÀÃHýŽÃHíŽÃHõŽÃHÕŽÃE3ÀHAL‹ÈL+ÉIƒÁIÁéH;ÈMGÈM…ÉtIÿÀH‰HIM;ÁuñÃÌÌÌH‹ÙHÁàHÂë	9JtHƒÂH;Ðuò3ÀÃH‹ÂÃÌÌÌHƒì(ƒùw
¸
 £Èrèð·üÿÇHƒÈÿHƒÄ(ÃÌH‹ÁÃL‹ÜHƒì(¸MKMC‰D$8IS‰D$@IKè‹ýÿÿHƒÄ(ÃÌÌH‰
ŽH‰
ŽH‰
ŽH‰
ŽÃÌÌÌHƒì(èO
ÿÿHƒÀHƒÄ(ÃÌÌHƒì(è;
ÿÿHƒÀHƒÄ(ÃÌÌH‹ÄSVWATAUAWHƒìH‹ùE3íD!h@¶@ˆ´$€ƒù„Žƒùt"ƒù„€ƒùtƒùtƒùtqAëƒøviëDèk
ÿÿL‹èH…ÀuƒÈÿé"H‹H‹¡HÁâHÑë	9ytHƒÁH;Êuò3É3ÀH…É•À…ÀuèǶüÿÇ耼þÿë·HY@2ö@ˆ´$€ë?ƒét3ƒétƒé	t ƒétƒùt3Ûë"HëHôŒëHûŒëHÚŒHƒ¤$˜@„öt¹è2õþÿ@„ötH‹c‹Êƒá?H3HÓÊL‹úëL‹;Iƒÿ”Àˆ„$ˆ„À…¿M…ÿu@„öt	AOè=õþÿ¹èãVþÿA¼	ƒÿw@A£üs:I‹EH‰„$˜H‰D$0IƒeƒÿuVèšÿÿ‹@‰„$‰D$ è‡ÿÿÇ@Œƒÿu2H‹h
HÁàIEH‹
a
HÁáHÈH‰D$(H;Át1Hƒ`HƒÀëëH‹6b‹Âƒà?¹@+È3ÀHÓÈH3ÂH‰ëA¼	@„öt
¹è|ôþÿ€¼$ˆt3ÀëaƒÿuèüÿÿH‹ØI‹ÏH‹‹·ÿÒ‹S‹ÏAÿ×ëI‹ÏH‹u·ÿЋÏAÿ׃ÿwÃA£üs½H‹„$˜I‰Eƒÿu¬è±ÿÿ‹Œ$‰Hë›HƒÄHA_A]A\_^[ÃÌÌÌH‰\$H‰|$L‰t$AWHƒì0L‹ò‹ùHBýHƒø†ƒù‡Ì¸D€`£Èƒ¾2ÛE3ÿAOè[óþÿƒÿtƒÿu:€=ÑŠu1ºH
ûÿÿÿ²…Àt	ƲŠëè#´üÿH‹ØÿŠ³‰³‹ÏèûÿÿH…Àt3L‹ã`A‹Ðƒâ?M‹øL38‹ÊIÓÏL‰|$ Iƒþt¹@+ÊIÓÎM3ðL‰0¹è!óþÿ„Ûtƒÿ‡Ü¸
 £øéÍI‹ÇéÖƒù‡¯¸	£Èƒ¡èÿÿH‹ØH…Àt¾L=L98u&H‹
Lè°þÿH‰H…ÀtžL‹8I‹×H‹ÈèUžH‹H‹ÁL‹MÀJÁH;Êt9xtHƒÀH;Âuò3ÀH…À„ZÿÿÿHPL‹IƒþtNÁI;Át9züuL‰2HƒÂHJøI;ÉuëI‹Âëƒùw
¸
 £Èrèÿ²üÿÇHƒÈÿH‹\$@H‹|$HL‹t$PHƒÄ0A_ÃÌÌÌéë°þÿÌÌÌ@SHƒì ‹ÁI‹Ø3ÉL‹ÚL‹Ò8L$PtÆ-LR¹÷ØM‹Â3ÒA÷ñƒú	v€ÂWë€Â0AˆHÿÁIÿÂ…ÀtH;ËrÜH;ËrAÆèx²üÿ»"‰è0¸þÿ‹Ãë AÆIÿÊAŠAŠ
AˆIÿÊAˆIÿÀM;Âré3ÀHƒÄ [ÃÌÌH‰\$WHƒì 3ÿ‹ÁI‹ØL‹ÚL‹Ò‹Ï@8|$PtO-÷Øf‰
LROM‹Â3ÒA÷ñƒú	vfƒÂWëfƒÂ0fA‰HÿÁIƒÂ…ÀtH;ËrØH;ËrfA‰;èرüÿ»"‰è·þÿ‹Ãë'fA‰:IƒêA·A·
fA‰IƒêfA‰IƒÀM;Ârã3ÀH‹\$0HƒÄ _ÃÌÌ@SHƒì H‹ÁI‹Ø3ÉL‹ÚL‹Ò8L$PtÆ-LR¹H÷ØM‹ÂE‹É3ÒI÷ñƒú	v€ÂWë€Â0AˆHÿÁIÿÂH…ÀtH;ËrÛH;ËrAÆè2±üÿ»"‰èê¶þÿ‹Ãë AÆIÿÊAŠAŠ
AˆIÿÊAˆIÿÀM;Âré3ÀHƒÄ [ÃH‰\$WHƒì 3ÿH‹ÁI‹ØL‹ÚL‹Ò‹Ï@8|$PtO-H÷Øf‰
LROM‹ÂE‹É3ÒI÷ñƒú	vfƒÂWëfƒÂ0fA‰HÿÁIƒÂH…ÀtH;Ër×H;ËrfA‰;莰üÿ»"‰èF¶þÿ‹Ãë'fA‰:IƒêA·A·
fA‰IƒêfA‰IƒÀM;Ârã3ÀH‹\$0HƒÄ _Ã@SHƒì0E‹ÑD‹ÙH…Òuè6°üÿ»‰èîµþÿ‹ÃHƒÄ0[ÃM…ÀtâDŠL$`AŠÁÆöØHÉH÷ÙHÿÁL;Áwèý¯üÿ»"ëÅABþ»";Ãw®DˆL$`A‹ËE‹ÊHƒÄ0[éýÿÿ@SHƒì03ÀE‹ÑD‹ÙH…Òu輯üÿ»‰ètµþÿ‹ÃHƒÄ0[ÃM…ÀtâDŠL$`f‰AŠÁöØHÉH÷ÙHÿÁL;Áw胯üÿ»"ëÅABþ»";Ãw®DˆL$`A‹ËE‹ÊHƒÄ0[éýÿÿÌÌ@SHƒì0E‹ÑL‹ÙH…ÒuèB¯üÿ»‰èú´þÿ‹ÃHƒÄ0[ÃM…ÀtâDŠL$`AŠÁÆöØHÉH÷ÙHÿÁL;Áwè	¯üÿ»"ëÅABþ»";Ãw®DˆL$`I‹ËE‹ÊHƒÄ0[éLýÿÿ@SHƒì03ÀE‹ÑL‹ÙH…ÒuèÈ®üÿ»‰耴þÿ‹ÃHƒÄ0[ÃM…ÀtâDŠL$`f‰AŠÁöØHÉH÷ÙHÿÁL;Áwè®üÿ»"ëÅABþ»";Ãw®DˆL$`I‹ËE‹ÊHƒÄ0[éjýÿÿÌÌ@SHƒì03ÀH‹ÚAƒø
uH…Éy°E‹ÈˆD$ IƒÈÿè¨üÿÿH‹ÃHƒÄ0[ÃÌÌÌHƒì83ÀAƒù
uH…Éy°ˆD$ è¼þÿÿHƒÄ8ÃÌÌÌ@SHƒì03ÀH‹ÚAƒø
uH…Éy°E‹ÈˆD$ IƒÈÿèèüÿÿH‹ÃHƒÄ0[ÃÌÌÌHƒì83ÀAƒù
uH…Éy°ˆD$ èÜþÿÿHƒÄ8ÃÌÌÌ@SHƒì03ÀH‹ÚAƒø
u…Éy°E‹ÈˆD$ IƒÈÿè¹úÿÿH‹ÃHƒÄ0[ÃHƒì83ÀAƒù
u…Éy°ˆD$ èýÿÿHƒÄ8Ã@SHƒì03ÀH‹ÚAƒø
u…Éy°E‹ÈˆD$ IƒÈÿèýúÿÿH‹ÃHƒÄ0[ÃHƒì83ÀAƒù
u…Éy°ˆD$ èEýÿÿHƒÄ8Ã@SHƒì03ÀH‹ÚAƒø
u…Éy°E‹ÈˆD$ IƒÈÿèúÿÿH‹ÃHƒÄ0[ÃHƒì83ÀAƒù
u…Éy°ˆD$ è}üÿÿHƒÄ8Ã@SHƒì03ÀH‹ÚAƒø
u…Éy°E‹ÈˆD$ IƒÈÿè]úÿÿH‹ÃHƒÄ0[ÃHƒì83ÀAƒù
u…Éy°ˆD$ è¥üÿÿHƒÄ8Ã@SHƒì0E‹ÈÆD$ IƒÈÿH‹ÚèÆúÿÿH‹ÃHƒÄ0[ÃÌHƒì8ÆD$ èêüÿÿHƒÄ8ÃÌ@SHƒì0E‹ÈÆD$ IƒÈÿH‹Úè&ûÿÿH‹ÃHƒÄ0[ÃÌHƒì8ÆD$ è*ýÿÿHƒÄ8ÃÌ@SHƒì0E‹ÈÆD$ IƒÈÿH‹ÚèùÿÿH‹ÃHƒÄ0[ÃÌHƒì8ÆD$ è†ûÿÿHƒÄ8ÃÌ@SHƒì0E‹ÈÆD$ IƒÈÿH‹ÚèrùÿÿH‹ÃHƒÄ0[ÃÌHƒì8ÆD$ èÆûÿÿHƒÄ8ÃÌH‹ÄH‰XH‰pH‰xL‰p AWHƒì0I‹øH‹òL‹ù¹èHêþÿ3Û‹ÃM…ÿ•À…ÀuèT«üÿ»‰è±þÿëuI‰H…ötH‰‹ÃH…ÿ•À…ÀtÖH‹Ïè+L‹ðH…ÀtNHƒÏÿHÿÇ88uøºHúH‹Ïè'øÿÿI‰H…Àuèöªüÿ¹‰‹ÙëM‹ÆH‹×H‹Èè¨þÿ…ÀuH…ötH‰>¹èûéþÿ‹ÃëH‰\$ E3ÉE3À3Ò3ÉèðþÿH‹\$@H‹t$HH‹|$PL‹t$XHƒÄ0A_ÃÌÌÌH‹ÄH‰XH‰pH‰xL‰p AWHƒì0I‹øH‹òL‹ù¹èDéþÿ3Û‹ÃM…ÿ•À…ÀuèPªüÿ»‰è°þÿëvI‰H…ötH‰‹ÃH…ÿ•À…ÀtÖH‹Ïè¯L‹ðH…ÀtOHƒÏÿHÿÇf9xu÷HÿǺH‹Ïè"÷ÿÿI‰H…Àuèñ©üÿ¹‰‹ÙëM‹ÆH‹×H‹Èè¨Ýþÿ…ÀuH…ötH‰>¹èöèþÿ‹ÃëH‰\$ E3ÉE3À3Ò3É辯þÿH‹\$@H‹t$HH‹|$PL‹t$XHƒÄ0A_ÃÌÌH‰\$H‰t$H‰|$AVHƒì0H‹úL‹ñH…Éu)èg©üÿ»‰è¯þÿ‹ÃH‹\$@H‹t$HH‹|$PHƒÄ0A^ÃHƒ!H…ÒtHƒ"M…ÀtÅI‹Èè-H‹ðH…Àu3ÀëÄHƒËÿHÿÀ<u÷ºHÚH‹Ëè$öÿÿI‰H…Àuèó¨üÿ¹‰‹ÁëL‹ÆH‹ÓH‹Èè¦þÿ…Àu
H…ÿt°H‰ë«Hƒd$ E3ÉE3À3Ò3ÉèË®þÿÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì03íH‹úL‹ñH…Éu.艨üÿ»‰èA®þÿ‹ÃH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A^ÃH‰)H…ÒtH‰*M…ÀtÂI‹ÈèÔH‹ðH…Àu3ÀëÁHƒËÿHÿÃf9,Xu÷HÿúH‹ËèCõÿÿI‰H…Àuè¨üÿ¹‰‹ÁëŒL‹ÆH‹ÓH‹ÈèÉÛþÿ…Àu
H…ÿt°H‰ë«E3ÉH‰l$ E3À3Ò3Éèë­þÿÌÌÌ@SHƒì H‹Ù3ÀH…É•À…Àu躧üÿÇès­þÿ3Àë<ºÿèíâþÿ3ÉH=ÿ’Á…ÉtÓ¹èhæþÿH‹ËèƒH‹Ø¹è¦æþÿH‹ÃHƒÄ [ÃÌ@SHƒì H‹Ù3ÀH…É•À…ÀuèN§üÿÇè­þÿ3Àë<ºÿèÝãþÿ3ÉH=ÿ’Á…ÉtÓ¹èüåþÿH‹ËèŸH‹Ø¹è:æþÿH‹ÃHƒÄ [ÃÌH‰\$H‰t$WHƒì H‹ñèñ@þÿH‹ØH…ÀtWH…ötRHƒÏÿHÿÇ€<>u÷Hƒ8t?H‹HƒÈÿHÿÀ€<u÷H;Çv€<9=uL‹ÇH‹Öè›…Àt
HƒÃHƒ;ëÊH‹HÿÀHÇë3ÀH‹\$0H‹t$8HƒÄ _ÃH‰\$H‰l$H‰t$WHƒì H‹ñèl@þÿ3íH‹ØH…ÀtXH…ötSHƒÏÿHÿÇf9,~u÷H9(tAH‹HƒÈÿHÿÀf9,Au÷H;ÇvfƒþÿH‹ËèF˜þÿE3ÀI‹Ö‹ÎèYHƒøÿ„Pÿÿÿ3ÀH‹\$@H‹l$HH‹t$PHƒÄ A_A^_Ãè³›üÿƒ8uèÉ›üÿÇ
è¾›üÿH‹Ë‹8èð—þÿ‹Çë¿y¤E3ÀH‹Ó‹ÎèýHƒøÿ„ôþÿÿ‹ÎèLzÿÿH‹Èÿ¿™…À…uÿÿÿèz›üÿÇ
èO›üÿH‹Øÿ¶š‰é¼þÿÿÌÌÌH‰T$‰L$USH‹ìHƒìHLcÁAƒøþuè›üÿƒ ¸	é“…ÉxtD;$nskI‹ÈL
jƒá?I‹ÀHÁøHÁáI‹ÁöD8tHH…ÒyèÕšüÿƒ èíšüÿ»ëAHED‰E0H‰EàLM0HE D‰EØLEàH‰EèHUØHM(è©üÿÿëè’šüÿƒ 誚üÿ»	‰èb þÿ‹ÃHƒÄH[]ÃÌH‰\$H‰t$‰L$WATAUAVAWHƒì E‹øD‹âHcÙƒûþuèFšüÿƒ è^šüÿÇ	é…Éxt;ImslH‹óL‹óIÁþL-6iƒæ?HÁæK‹Dõ¶L08ƒátE‹ËèáuÿÿƒÏÿK‹DõöD08uèšüÿÇ	èÚ™üÿƒ ëE‹ÇA‹Ô‹Ëè0‹ø‹Ëè‹vÿÿ‹Çë趙üÿƒ èΙüÿÇ	臟þÿƒÈÿH‹\$XH‹t$`HƒÄ A_A^A]A\_ÃH‰\$H‰t$‰L$WATAUAVAWHƒì E‹øL‹âHcÙƒûþuèZ™üÿƒ èr™üÿÇ	é“…Éxw;]lsoH‹óL‹óIÁþL-Jhƒæ?HÁæK‹Dõ¶L08ƒátH‹ËèõtÿÿHƒÏÿK‹DõöD08uè™üÿÇ	èí˜üÿƒ ëE‹ÇI‹Ô‹Ëè¿H‹ø‹ËèuÿÿH‹Çëèǘüÿƒ èߘüÿÇ	蘞þÿHƒÈÿH‹\$XH‹t$`HƒÄ A_A^A]A\_ÃH‰\$H‰t$WHƒì HcÙA‹ø‹Ë‹òèVwÿÿHƒøÿuè˜üÿÇ	ƒÈÿë7D‹Ç‹ÖH‹Èè׋ЃøÿtçH‹ËLfgƒá?H‹ÃHÁøHÁáI‹À€d8ý‹ÂH‹\$0H‹t$8HƒÄ _ÃÌH‰\$H‰t$WHƒì HcÙA‹ø‹ËH‹òèÙvÿÿHƒøÿuè˜üÿÇ	HƒÈÿëSD‹ÏLD$HH‹ÖH‹Èÿ"–…Àuÿ8—‹Èèq—üÿëÓH‹D$HHƒøÿtÈH‹ÓLÊfƒâ?H‹ËHÁùHÁâI‹È€d8ýH‹\$0H‹t$8HƒÄ _ÃÌÌÌL‹ÜI‰[I‰sWHƒì0ƒd$X3ÀA‹øHcò‰D$\MCèI‹S H‹ÙDHÿš•…Àuÿ°–‹Èèé–üÿƒÈÿëSƒd$XLD$X3ÀH‹ÖD‹Ï‰D$\H‹Ëÿe•…ÀtËH|$Xÿÿÿ~!H‹T$ E3ÉE3ÀH‹ËÿB•è
—üÿÇ묋D$XH‹\$@H‹t$HHƒÄ0_ÃÌHƒì(E‹ÈLD$Hÿ•…Àuÿ$–‹Èè]–üÿHƒÈÿëH‹D$HHƒÄ(ÃÌé#üÿÿÌÌÌé÷ýÿÿÌÌÌéÿüÿÿÌÌÌécþÿÿÌÌÌHƒì(ƒd$0HT$0á€è‹D$0HƒÄ(ÃÌÌHƒì(H…Òuèj–üÿÇè#œþÿ¸ë‹æl‰÷ÁþÿÿuÙ‰
Öl3ÀHƒÄ(ÃÌÌÌHƒì(ƒùþu
è*–üÿÇ	ëB…Éx.;
is&HcÉHeH‹Áƒá?HÁøHÁáH‹Â¶D8ƒà@ëèë•üÿÇ	褛þÿ3ÀHƒÄ(ÃÌHƒì(‹ÚbM‹ØL‹ÑE3É…ÀuyM…ÀtlH…Éu貕üÿÇèk›þÿ¸ÿÿÿHƒÄ(ÃH…ÒtáL+ÒA·A¿fƒøwfƒÁ D·A@¿fƒøwfAƒÀ HƒÂIƒëtf…ÉtfA;ÈtÆA·ÀD·ÉD+ÈA‹ÁHƒÄ(ÃHƒÄ(éÌÌÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì@E3öI‹èH‹úH‹ñA‹ÆM…À„ÌH…Éuè•üÿÇ躚þÿ¸ÿÿÿé­H…ÒtáI‹ÑHL$ è¾ûÿH‹D$(L9°8u:H+÷·>C¿fƒøwfƒÃ ·A¿fƒøwfƒÁ HƒÇHƒítDf…Ût?f;ÙtËë8·HT$(è=B·HT$(·Øè-BHv·ÈHHƒít
f…Ûtf;ØtÈ·É·Ã+ÁD8t$8tH‹L$ ƒ¡¨ýH‹\$PH‹l$XH‹t$`H‹|$hHƒÄ@A^ÃD‹ÑE3ÀA¹ãCA‹Ê™L‰+ÂÑøHcÐHÁâB+t…ÉyDHÿëD@E;Á~̓ÈÿÃÌH‹ÄH‰XH‰hH‰pH‰x AV3íL5¢4D‹ÕH‹ñA»ãCH‹þ™»U+ÂÑøLcÀI‹ÈHÁáN‹1I+ùB·J¿fƒùwfƒÂ A·	A¿fƒøwfƒÁ IƒÁHƒët
f…Òtf;ÑtÉ·Á·Ê+Èt…ÉyEXÿëEPE;Ó~ŠƒÈÿëI‹ÀHÀA‹DÆH‹\$H‹l$H‹t$ H‹|$(A^ÃÌE3ÉL‹ÒL‹ÙM…ÀtDL+ÚC·A¿fƒøwfƒÁ A·B¿fƒøwfƒÂ IƒÂIƒèt
f…Étf;ÊtÉ·ÂD·ÉD+ÈA‹ÁÃÌÌH‰\$H‰l$H‰t$WHƒì0IcØD‹ÁH‹ò÷Áÿóÿÿuùu
H…Òu…Û…Ûy3ÀëyE3ÉH-øAºãC
™+ÂA‹ÐÑøHcÈHÁá+)t…ÒyDPÿëDHE;Ê~ÕƒÈÿ…ÀxºH˜ºUHÀH‹lÅH‹ÍèÑÎþÿH‹ø…Û~;Ã}˜H‹ÓL‹ÅH‹ÎèàÅþÿ…ÀuGH‹\$@H‹l$HH‹t$PHƒÄ0_ÃHƒd$ E3ÉE3À3Ò3Éèó—þÿÌÌÌHƒì(H…Ét"èîýÿÿ…ÀxH˜H=äsHÀH
6‹Áë3ÀHƒÄ(ÃÌÌH‰\$L‰L$ WHƒì I‹ùI‹Ø‹
èTmÿÿH‹HcH‹ÑH‹ÁHÁøLt`ƒâ?HÁâI‹ÀöD8t$èpÿÿH‹Èÿ|3Û…Àuè)‘üÿH‹Øÿ‰è9‘üÿÇ	ƒËÿ‹èÕmÿÿ‹ÃH‹\$0HƒÄ _ÃH‹ÄHƒì(‰HLH‰H L‹ÂHP HHèSÿÿÿHƒÄ(ÃÌÌ‹‰H‹ÁÃH‰H‹ÁÃÌ‹‰H‹ÁË	émÿÿÌ@SHƒì H‹LÄ_HcH‹ÑH‹ÁHÁøƒâ?HÁâI‹ÀöD8t&è\oÿÿH‹Èÿ¿Ž…Àt3ÀëèjüÿH‹ØÿщèzüÿÇ	ƒÈÿHƒÄ [ÃÌÌÌ‹	é)lÿÿ̉L$Hƒì8Hcуúþu
èKüÿÇ	ël…ÉxX;9csPH‹ÊL-_ƒá?H‹ÂHÁøHÁáI‹ÀöD8t-HD$@‰T$P‰T$XLL$PHT$XH‰D$ LD$ HL$HèAþÿÿëèâüÿÇ	蛕þÿƒÈÿHƒÄ8ÃÌÌÌHƒì(‹Î\L‹ÒL‹ÙE3É…ÀutH…Éuè«üÿÇèd•þÿ¸ÿÿÿHƒÄ(ÃH…ÒtáIøÿÿÿwØL+ÚC·B¿fƒøwfƒÂ A·
A¿fƒøwfƒÁ IƒÂIƒèt
f…Òtf;ÑtÉ·É·Â+ÁHƒÄ(ÃHƒÄ(éH‹ÄH‰XH‰hH‰pH‰x AVHƒìP3íI‹ðH‹úL‹ñM…Àu3ÀéæH…ÉuèþŽüÿÇè·”þÿ¸ÿÿÿéÇH…Òtá»ÿÿÿL;ÃvèÕŽüÿÇ莔þÿé¡I‹ÑHL$0èœûúÿH‹D$8H‹ˆ0H…ÉuCL+÷A·>A¿fƒøwfƒÁ ·B¿fƒøwfƒÂ HƒÇHƒît
f…Étf;Êtʷ·Ù+Øë-‰t$(D‹ÎM‹ÆH‰|$ ºè³N…Àu
èBŽüÿÇëXþ@8l$HtH‹D$0ƒ ¨ý‹ÃH‹\$`H‹l$hH‹t$pH‹|$xHƒÄPA^ÃÌÌÌ‹
[…À„jVþÿE3ÉéÌÌH‹ÄH‰XH‰hH‰pWHƒì`H‹òH‹éI‹ÑHHØI‹øè§úúÿH…ÿu3Ûé H…ítH…öuè¨üÿÇèa“þÿ»ÿÿÿë»ÿÿÿH;ûvè‡üÿÇè@“þÿëcH‹D$HH‹0H…ÒuLL$HL‹ÇH‹ÖH‹ÍèVþÿ‹Øë;‹@HL$H‰D$8L‹Í‰|$0A¸H‰t$(‰|$ èçQ…Àu
è"üÿÇëXþ€|$XtH‹D$@ƒ ¨ýL\$`‹ÃI‹[I‹kI‹s I‹ã_Ã@SHƒì º·Ùè;ÿÿ3Ò…Àufƒû_uº‹ÂHƒÄ [Ã@SHƒì º·Ùèñ:ÿÿ3Ò…Àufƒû_uº‹ÂHƒÄ [Ã@SHƒì@‹ÙHL$ èfùúÿH‹D$(¶ÓH‹·Q%€€|$8tH‹L$ ƒ¡¨ýHƒÄ@[Ã̺éŽ:ÿÿÌ̺é‚:ÿÿÌÌfƒù	u¸@ú@éj:ÿÿÌ̺ é^:ÿÿÌÌ@SHƒì º·ÙèI:ÿÿ3Ò…Àufƒû_uº‹ÂHƒÄ [Ã@SHƒì º·Ùè:ÿÿ3Ò…Àufƒû_uº‹ÂHƒÄ [úéú9ÿÿÌ̺éî9ÿÿÌ̺éâ9ÿÿÌ̺WéÖ9ÿÿÌ̺éÊ9ÿÿÌ̺é¾9ÿÿÌ̺é²9ÿÿÌ̺€é¦9ÿÿÌÌ@SHƒì@‹Ù3ÒHL$ è0øúÿH‹D$(¶ÓH‹·Q%€€|$8tH‹L$ ƒ¡¨ýHƒÄ@[ÃÌÌ̺éV9ÿÿÌ̺éJ9ÿÿÌÌ3Àº€f;Ê’ÀÃÌÌfƒù	u¸@ú@é"9ÿÿÌ̺ é9ÿÿÌ̺é
9ÿÿÌ̺éþ8ÿÿÌ̺éò8ÿÿÌ̺Wéæ8ÿÿÌ̺éÚ8ÿÿÌ̺éÎ8ÿÿÌ̺éÂ8ÿÿÌ̺€é¶8ÿÿÌÌ3ÀH9•ÀÃÌÌÌ@UATAUAVAWHƒì`Hl$PH‰]@H‰uHH‰}PH‹þ6H3ÅH‰EHc]`M‹ùH‰UE‹èH‹ù…Û~H‹ÓI‹Éè_O;ÃX|‹ØD‹uxE…öuH‹D‹p÷€D‹ËM‹ÇA‹ÎÒƒd$(Hƒd$ ƒâÿÂÿg‡Lcà…À„{I‹ÔI¸ðÿÿÿÿÿÿHÒHJH;ÑHÀH…ÁtrHJH;ÑHÀH#ÁH=HBw7H;ÐHÉH#ÈHAH;ÁwI‹ÀHƒàðèFsH+àHt$PH…ö„úÇÌÌëH;ÐHÉH#ÈèË…þÿH‹ðH…ÀtÇÝÝHƒÆë3öH…ö„ÅD‰d$(D‹ËM‹ÇH‰t$ ºA‹Îÿ¢†…À„ŸHƒd$@E‹ÌHƒd$8L‹ÆHƒd$0A‹ÕL‹}ƒd$(I‹ÏHƒd$ è¯þÿHcø…À„bA¸E…ètR‹Ep…À„N;øDHƒd$@E‹ÌHƒd$8L‹ÆHƒd$0A‹Õ‰D$(I‹ÏH‹EhH‰D$ 觮þÿ‹ø…À…éH‹×HÒHJH;ÑHÀH…ÁtvHJH;ÑHÀH#ÁI;ÀHBw>H;ÐHÉH#ÈHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèðqH+àH\$PH…Û„¤ÇÌÌëH;ÐHÉH#Èèu„þÿH‹ØH…ÀtÇÝÝHƒÃë3ÛH…ÛtsHƒd$@E‹ÌHƒd$8L‹ÆHƒd$0A‹Õ‰|$(I‹ÏH‰\$ èÚ­þÿ…Àt2Hƒd$83ÒH!T$0D‹Ï‹EpL‹ÃA‹Î…Àuf!T$(H!T$ ÿ
ˆ‹ø…Àu`HKð9ÝÝu觃þÿ3ÿH…ötHNð9ÝÝuèƒþÿ‹ÇH‹MH3ÍèEEúÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÉD$(H‹EhH‰D$ ë”HKð9ÝÝu§èGƒþÿë ÌH‰\$H‰t$WHƒìpH‹òI‹ÙH‹ÑA‹øHL$PèÇóúÿ‹„$ÀHL$X‰D$@L‹Ë‹„$¸D‹Ç‰D$8H‹Ö‹„$°‰D$0H‹„$¨H‰D$(‹„$ ‰D$ è3üÿÿ€|$htH‹L$Pƒ¡¨ýL\$pI‹[I‹sI‹ã_ÃÌÌ@SHƒì 3ÛH…Éuè^†üÿ»‰èŒþÿ‹Ãé”H…ÒtãE…Àˆ‹ÃAOÀÿÀH˜H;Ðwè-†üÿ»"ëÍM…Ét¾I‹QHAÆ0ëDŠE„ÒtHÿÂëA²0DˆHÿÀAÿÈE…Àâˆx€:5|ëÆ0HÿÈ€89tõþ€91uAÿAëIƒÈÿIÿÀB8\uöIÿÀHQè™p3ÀHƒÄ [ÃÌ@USVWATAUAVAWH¬$HùÿÿHì¸H‹M2H3ÄH‰… H‹… A¾H‰D$XL‰D$P‰T$8òD$HH‹T$HL‹ÂL‰L$@IÁè4A¹ÿM…Á”ÁŠÁöØH¸HÿH÷×H#øH¸ÿÿÿÿÿÿH#ÐHúöÙÀE#Á÷ØAÆA˜ÌûÿÿØèäKèKò,ȉ|$dEVr€ƒàþ÷ØEäHÁï D#á‰|$h‹ÇD‰d$ ÷ØÒ÷ÚAÖ‰T$`…Ûˆ“3ÀÇ…‰…p‰µ;Ö…UE3ÀB‹D„dB9„……?EÆD;Æuåƒd$(D[E‹ËA¸ AƒãAÁéA‹ðI‹ÞA+ó‹ÎHÓãA+Þ½ÇD‹ãA÷ÔtÿÀë3ÀD+ÀAAE;ØA—ÇA;ÂA—ÀA;Âu
E„ÿtAŠÎë2ÉAƒÍÿE„À…‘„É…‰A¾rA;ÆDBðE;õtWE‹ÆE+ÁC<A;ùrHD;ÂsF‹T„dëE3ÒA@ÿ;Âs‹T„dë3ÒA#Ô‹ÎÓêEÅD#ÓA‹ËAÓâAÒC‰T¼dA;Åt‹T$`ë¯3ÉE…ÉtƒdŒdÿÁA;ÉuôE„ÿAFDEðëE3öÇ…4ƒ¥A¿D‹d$ D‰½0D‰½D‰t$`éhƒd$(D[E‹ËBÿAƒãAÁéA¸ I‹ÞE‹øE+ûA‹ÏHÓãA+ދȽD„dD‹ëA÷ÕtÿÀë3ÀD+ÀB
E;ØA—ÄA;ÂA—ÀA;Âu
E„ätAŠÎë2ÉAƒÊÿE„À…–„É…ŽA¾rA;ÆDBðE;òt\E‹ÆE+ÁC<A;ùrMD;ÂsF‹T„dëE3ÒA@ÿ;Âs‹T„dë3ÒA#ÕD#ÓA‹ÏÓêA‹ËAÓâAÒAƒÊÿE‰T¼dCA;Ât‹T$`ëª3ÉE…ÉtƒdŒdÿÁA;ÉuôE„äAFDEðëE3ö‰µ4é»þÿÿûüÿÿ„03ÀÇ…‰…p‰µ;Ö…
E3ÀB‹D„dB9„……÷EÆD;Æuåƒd$(½ÇtÿÀë3ÀA¸ ‹ÎD+ÀD;ÆA’ÁAƒÍÿ;Ês	‹ÁD‹D„dëE3ÀAÿ;Âs‹T„dë3ÒA‹ÀÁêÁà3ЋÁA͉T„dA;Ít‹T$`ëÂAöÙHEö3ÒA÷ÞDö+ó‹þD‰t$`Áï‹ßHÁãL‹ÃèëWúÿƒæD@ŠÎ¸Óà‰„E‹ÇIÁàD‰½D‰½0M…À„7»ÌH4L;ÇH•èÔké
ƒd$(Bÿ‹È½D„dtÿÀë3ÀA¸ D+ÀE;ÆA’ÁA;Ò—ÁA;Òu
E„ÉtAŠÆë2ÀAƒÍÿ„Éub„Àu^A¾rA;ÖDBòE;õt?A‹Î;Ês	‹ÁD‹D„dëE3ÀAÿ;Âs‹T„dë3ÒÁêC3ЋÁA͉T„dA;Ít‹T$`ëÄE„ÉAFDEðëE3ö¿D‰t$`+ûH‹÷3ÒÁî‹ÞHÁãL‹Ãè¼VúÿƒçD~@ŠÏ¸Óà‰„éÌþÿÿL‹Ã3Òè•VúÿèðüÿÇ"è©…þÿD‹½0¸ÍÌÌÌE…䈨A÷ä‹ÂH„¬ùÿÁè‰D$4D‹à‰D$$…À„ϸ&E‹ìD;àDGèD‰l$0AEÿ¶Œ‚""¶´‚#"‹Ù‹ø3ÒHÁãL‹ÃH‰…èVúÿH
¬ùÿHÁæ·„¹ "H‘HL‹ÆHËH‚èjD‹Aƒû‡¢‹……ÀuE3ÿD‰½0éƒø„ÿE…ÿ„öE3ÀL‹ÐE3ÉB‹Œ4A‹ÀI¯ÊHÈL‹ÁB‰Œ4IÁè AÿÁE;Ïu×E…Àt4ƒ½0ss‹…0D‰„…4D‹½0AÿÇëˆE3ÿD‰½02ÀéD‹½0éAƒÿ‡­‹4M‹ÃIÁàE‹ûD‰0M…Àt@¸ÌH4L;ÀwH•èiëL‹À3ÒèÒTúÿè-~üÿÇ"èæƒþÿD‹½0…Û„úþÿÿƒû„E…ÿ„ÿE3ÀL‹ÓE3ÉB‹Œ4A‹ÀI¯ÊHÈL‹ÁB‰Œ4IÁè AÿÁE;Ïu×éÿÿÿE;ßH4E‹çL­’ÀH•4„ÀLDéEEãEEßHHDÑE3ÿE3ÒH‰T$(D‰½ÐE…ä„C‹t•A‹Â…öu!E;×…øB!´•ÔEzD‰½Ðéà3ÛE‹ÊE…Û„ÃA‹ú÷ßAƒùstfE;ÏuA‹ÁOƒ¤…ÔCȉÐA9E‹Á‹‚AÿÁ‹ÃH¯ÖHÐB‹„…ÔHÐA9H‹ÚB‰”…ÔD‹½ÐHÁë A;ÃtH‹T$(ë”…ÛtNAƒùs„lE;ÏuA‹Áƒ¤…ÔAA‰…ÐA‹ÉAÿÁ‹Ó‹„ÔHЉ”ÔD‹½ÐHÁê ‹Ú…Òu²Aƒùs„H‹T$(AÿÂE;Ô…çþÿÿE‹ÇIÁàD‰½0M…Àt@¸ÌH4L;ÀwH•ÔègëL‹À3ÒèÃRúÿè|üÿÇ"è×þÿD‹½0D‹d$$D‹l$0°„À„¦E+åH®¨ùÿD‰d$$…5üÿÿ‹D$4‹|$ €À‹Ï+È„Aÿ‹„‚¸"…Àt{ƒø„E…ÿ„ÿE3ÀD‹ÐE3ÉB‹Œ4A‹ÀI¯ÊHÈL‹ÁB‰Œ4IÁè AÿÁE;Ïu×E…ÀtAƒ½0ss)‹…0D‰„…4D‹½0AÿÇëE3ÿD‰½0é’E3ÿD‰½0é‡D‹½0é{A‹Ì÷Ù÷á‰L$0‹ÂHÔ§ùÿÁè‰D$(D‹à‰D$$…À„¦¸&E‹ìD;àDGèD‰l$4AEÿ¶Œ‚""¶´‚#"‹Ù‹ø3ÒHÁãL‹ÃH‰…èTQúÿH
m§ùÿHÁæ·„¹ "H‘HL‹ÆHËH‚èdeD‹Aƒû‡‹……Àu
E3öD‰t$`é݃ø„ÔE…ö„ËE3ÀL‹ÐE3ÉB‹LŒdA‹ÀI¯ÊHÈL‹ÁB‰LŒdIÁè AÿÁE;ÎuÝE…Àt)ƒ|$`ss‹D$`D‰D„dD‹t$`AÿÆë™E3öD‰t$`2ÀésD‹t$`égAƒþ‡Ÿ‹\$dM‹ÃIÁàE‹óD‰\$`M…Àt<¸ÌHL$dL;ÀwH•è‰dëL‹À3Òè=Púÿè˜yüÿÇ"èQþÿD‹t$`…Û„ÿÿÿƒû„øE…ö„ïE3ÀL‹ÓE3ÉB‹LŒdA‹ÀI¯ÊHÈL‹ÁB‰LŒdIÁè AÿÁE;ÎuÝéÿÿÿE;ÞHL$dE‹æL­’ÀHT$d„ÀLDéEEãEEÞHHDÑE3öE3ÒH‰T$HD‰µÐE…ä„C‹t•A‹Â…öu!E;Ö…øB!´•ÔErD‰µÐéà3ÛE‹ÊE…Û„ÃA‹ú÷ßAƒùstfE;ÎuA‹ÁOƒ¤…ÔCȉÐA9E‹Á‹‚AÿÁ‹ÃH¯ÖHÐB‹„…ÔHÐA9H‹ÚB‰”…ÔD‹µÐHÁë A;ÃtH‹T$Hë”…ÛtNAƒùs„ZE;ÎuA‹Áƒ¤…ÔAA‰…ÐA‹ÉAÿÁ‹Ó‹„ÔHЉ”ÔD‹µÐHÁê ‹Ú…Òu²Aƒùs„H‹T$HAÿÂE;Ô…çþÿÿE‹ÆIÁàD‰t$`M…Àt<¸ÌHL$dL;ÀwH•ÔèŠbëL‹À3Òè>Núÿè™wüÿÇ"èR}þÿD‹t$`D‹d$$D‹l$4°„À„šE+åH+¤ùÿD‰d$$…büÿÿ‹L$0‹D$(€À+È„šAÿ‹„‚¸"…Àtbƒø„ƒE…öt~E3ÀD‹ÐE3ÉB‹LŒdA‹ÀI¯ÊHÈL‹ÁB‰LŒdIÁè AÿÁE;ÎuÝE…ÀtHƒ|$`s‹|$ s.‹D$`D‰D„dD‹t$`AÿÆD‰t$`ë.H‹t$@ƒd$`H‹Þ‹|$ éŒH‹t$@ƒd$`H‹Þë}D‹t$`‹|$ H‹t$@H‹ÞE…ötgE3ÀE3ÉB‹DŒdH€A‹ÀLHF‰DŒdAÿÁIÁè E;ÎußE…Àt;ƒ|$`ss‹D$`D‰D„dÿD$`ë%ƒ¥L…ƒd$`HL$dE3ɺÌèÍH•0HL$`èÈ{ýÿƒø
…ŽÿÇÆ1H^E…ÿ„ŒE3ÀE3ÉB‹„4H€A‹ÀLHF‰„4AÿÁIÁè E;ÏuÙE…ÀtZƒ½0ss‹…0D‰„…4ÿ…0ë;ƒ¥L…ƒ¥0H4E3ɺÌè'ë…ÀuÿÏë0H^ˆH‹D$P‹L$8‰8…ÿx
ùÿÿÿwÏH‹D$XHÿÈ‹ùH;ÇHBøHþH;ß„îA¾	ƒÎÿD‹T$`E…Ò„×E3ÀE3ÉB‹DŒdHiÈÊš;A‹ÀHÈL‹ÁB‰LŒdIÁè AÿÁE;ÊuÚE…Àt;ƒ|$`ss‹D$`D‰D„dÿD$`ë%ƒ¥L…ƒd$`HL$dE3ɺÌè\H•0HL$`èWzýÿD‹×L‹ÀD+ÓA¹¸ÍÌÌÌA÷àÁêŠÊÀáÀD*ÀAH0D‹ÂE;ÑrA‹ÁˆDÎD;ÎuÎH‹ÇH+ÃI;ÆIOÆHØH;ß…ÿÿÿÆH‹ H3ÌèK2úÿHĸA_A^A]A\_^[]ÃÌÌÌ@SHƒì H‹Ùè†9‹ƒà<uÆCëH‹ËèÛ9ÆCH‹ÃHƒÄ [ÃÌÌHƒì(€ytèq9HƒÄ(ÃÌÌÌÌÌÌÌÌÌÌÌÌD‹L‹ÊL‹ÑD;t2ÀÃ3ÀE…Àt#„H…B‹L
B9LuÚÿÀA;Àuå°ÃÌÌD‹E3ÛL‹ÊL‹ÑD;t2À„À”ÀÃA‹ÃE…Àt‹ÈHB‹LB9L
uÚÿÀA;Àuã°„À”ÀÃÌÌÌÌÌÌÌÌÌÌ3À9”ÀÃÌÌÌÌÌÌÌÌH‰\$H‰t$H‰|$AVHƒì ‹ò‹úL‹ñÁîHƒÁ3ÒHµL‹Ãè«Iúÿƒç¸@¶ÏH‹|$@ÓàB‰D3FH‹\$0H‹t$8A‰I‹ÆHƒÄ A^ÃÌ@USVWATAUAVAWH¬$(ùÿÿHìØH‹uH3ÄH‰…ÀH‰L$8M‹ñHL$`L‰L$PM‹øL‰D$p‹òèê7‹D$`E3íƒà<uDˆl$hëHL$`è78ÆD$hH‹\$8H¹€H‹ÃM‰wH#Á¿ H÷ØI¼ÿÿÿÿÿÿH¸ðɃá
ÏA‰H…Øu,I…Üu'H‹•@Lƒ+I‹ÎE‰oèCoþÿ…À„ñé HL$8è8øþÿ…ÀtAÇGƒè„¯ƒè„‡ƒè„_ƒø„7H¸ÿÿÿÿÿÿÿA¹ÿH#ØÿÆH‰\$8òD$8òD$XH‹T$XL‹Â‰t$LIÁè4M…Á”ÁŠÁöØH¸MöI#ÔI÷ÖL#ðLòöÙÀE#Á÷ØÿÀA˜ÌûÿÿØè*8èa7ò,ÈD‰u„Aº€ƒàþ÷ØEäIÁî D#áD‰uˆA‹ÆD‰d$0÷ØÒ÷ÚAÒ‰U€…Ûˆ©3ÀÇ…(‰…$p‰µ ;Ö…aE‹ÅA‹È‹D„9„$…JEÂD;ÆuäD[D‰l$8E‹Ë‹÷AƒãAÁéA+óI‹Ú‹ÎHÓãA+ÚA½ÆD‹ãA÷ÔtÿÀëA‹Å+øAAD;ßA—ǃøsA—ÀƒøsuAŠÊE„ÿuAŠÍAƒÍÿE„À…¡„É…™A¾rA;ÆDBðE;õt\E‹ÆE+ÁC<A;ùrGD;ÂsF‹T…„ëE3ÒA@ÿ;Âs‹T…„ë3ÒA#Ô‹ÎÓêEÅD#ÓA‹ËAÓâAÒC‰T½„A;Åt‹U€ë°AºE3íA‹ÍE…Ét‹ÁAÊD‰l…„A;ÉuñE„ÿAFDEðD‰u€ë
E3íE‹õD‰m€Ç…TD‹d$0A¿D‰½PD‰½ D‰­(étƒd$8D[E‹ËBÿAƒãAÁéD‹ÿI‹ÚE+ûA‹ÏHÓãA+ڋȽD…„D‹ëA÷ÕtÿÀë3À+øB
D;ßA—ăøsA—Àƒøsu
E„ätAŠÊë2ÉAƒÊÿE„À… „É…˜A¾rA;ÆDBðE;òt\E‹ÆE+ÁC<A;ùrMD;ÂsF‹T…„ëE3ÒA@ÿ;Âs‹T…„ë3ÒD#ÓA‹ËAÓâA#ÕA‹ÏÓêDÒD‰T½„AƒÊÿEÂCA;Ât‹U€ëªE3íA‹ÍE…Ét‹ÁÿÁD‰l…„A;ÉuòE„äAFDEðD‰u€ë
E3íE‹õD‰m€‰µTé¶þÿÿûüÿÿ„,3ÀÇ…(‰…$p‰µ ;Ö…	E‹ÅA‹È‹D„9„$…òEÂD;ÆuäA½ÆD‰l$8tÿÀëA‹Å+ø‹Î;þA’ÁAƒÍÿ;Ês	‹ÁD‹D…„ëE3ÀAÿ;Âs‹T…„ë3ÒA‹ÀÁêÁà3ЋÁA͉T…„A;Ít‹U€ëÃAöÙH$Eö3ÒA÷ÞDö+ó‹þD‰u€Áï‹ßHÁãL‹Ãè DúÿƒæD@ŠÎE‹Ç¸IÁàÓà‰„$E3íD‰½PD‰½ M…À„=»ÌHTL;ÇH•$èXéBÿD‰l$8‹È½D…„tÿÀëA‹Å+øA;úA’Áƒús—ÁƒúsuAŠÂE„ÉuAŠÅAƒÍÿ„Éuh„ÀudA¾rA;ÖDBòE;õt>A‹Î;Ês	‹ÁD‹D…„ëE3ÀAÿ;Âs‹T…„ë3ÒÁêC3ЋÁA͉T…„A;Ít‹U€ëÅE3íAFE„ÉDEðD‰u€ë
E3íE‹õD‰m€A‹úH$+û3Ò‹÷Áî‹ÞHÁãL‹ÃèïBúÿƒçD~@ŠÏE‹Ç¸Óà‰„$IÁàéÍþÿÿL‹Ã3ÒèÁBúÿèlüÿÇ"èÕqþÿD‹½P¸ÍÌÌÌE…䈾A÷ä‹ÂH°˜ùÿÁè‰D$HD‹à‰D$@…À„Ó¸&E‹ìD;àDGèD‰l$DAEÿ¶Œ‚""¶´‚#"‹Ù‹ø3ÒHÁãL‹ÃH$‰… è0BúÿH
I˜ùÿHÁæ·„¹ "H‘H$L‹ÆHËH‚è@VD‹ Aƒû‡¢‹…$…ÀuE3ÿD‰½Pé	ƒø„E…ÿ„÷E3ÀL‹ÐE3ÉB‹ŒTA‹ÀI¯ÊHÈL‹ÁB‰ŒTIÁè AÿÁE;Ïu×E…Àt4ƒ½Pss‹…PD‰„…TD‹½PAÿÇëˆE3ÿD‰½P2ÀéŽD‹½Pé€Aƒÿ‡­‹TM‹ÃIÁàE‹ûD‰PM…Àt@¸ÌHTL;ÀwH•$èJUëL‹À3Òèþ@úÿèYjüÿÇ"èpþÿD‹½P…Û„úþÿÿƒû„	E…ÿ„E3ÀL‹ÓE3ÉB‹ŒTA‹ÀI¯ÊHÈL‹ÁB‰ŒTIÁè AÿÁE;Ïu×éÿÿÿE;ßHTE‹çL­$’ÀH•T„ÀLDéEEãEEßH$HDÑE3ÿE3ÒH‰T$8D‰½ðE…ä„C‹t•A‹Â…öu!E;×…ùB!´•ôEzD‰½ðéá3ÛE‹ÊE…Û„ÄA‹ú÷ßAƒùstgE;ÏuA‹ÁAJƒ¤…ôBȉðBE‹Á‹‚AÿÁ‹ÃH¯ÖHÐB‹„…ôHÐBH‹ÚB‰”…ôD‹½ðHÁë A;ÃtH‹T$8ë“…ÛtNAƒùs„~E;ÏuA‹Áƒ¤…ôAA‰…ðA‹ÉAÿÁ‹Ó‹„ôHЉ”ôD‹½ðHÁê ‹Ú…Òu²Aƒùs„0H‹T$8AÿÂE;Ô…æþÿÿE‹ÇIÁàD‰½PM…Àt@¸ÌHTL;ÀwH•ôè:SëL‹À3Òèî>úÿèIhüÿÇ"ènþÿD‹½PD‹d$@D‹l$D°„À„¸E+åHÙ”ùÿD‰d$@…4üÿÿ‹D$HE3í‹|$0€À‹Ï+È„Aÿ‹„‚¸"…À„‰ƒø„E…ÿ„ûE‹ÅE‹ÍD‹ÐA‹ÑAÿÁA‹À‹Œ•TI¯ÊHÈL‹Á‰Œ•TIÁè E;ÏuÖE…ÀtNƒ½Pss6‹…PD‰„…TD‹½PAÿÇD‰½Pé–E3íE‹ýD‰­Pé€E‹ýD‰­PéuD‹½PéiA‹Ì÷Ù÷á‰L$D‹ÂHê“ùÿÁè‰D$8D‹à‰D$@…À„—¸&E‹ìD;àDGèD‰l$HAEÿ¶Œ‚""¶´‚#"‹Ù‹ø3ÒHÁãL‹ÃH$‰… èj=úÿH
ƒ“ùÿHÁæ·„¹ "H‘H$L‹ÆHËH‚èzQ‹½ ƒÿ‡‡‹…$…ÀuE3öD‰u€é΃ø„ÅE…ö„¼E3ÀL‹ÐE3ÉB‹L„A‹ÀI¯ÊHÈL‹ÁB‰L„IÁè AÿÁE;ÎuÝE…Àt%ƒ}€ss‹E€D‰D…„D‹u€AÿÆëE3öD‰u€2ÀéhD‹u€é]Aƒþ‡š‹]„L‹ÇIÁàD‹÷‰}€M…Àt:¸ÌHM„L;ÀwH•$è«PëL‹À3Òè_<úÿèºeüÿÇ"èskþÿD‹u€…Û„"ÿÿÿƒû„óE…ö„êE3ÀL‹ÓE3ÉB‹L„A‹ÀI¯ÊHÈL‹ÁB‰L„IÁè AÿÁE;ÎuÝé)ÿÿÿA;þHM„E‹æL­$’ÀHU„„ÀLDéDEçAEþH$HDÑE3öE3ÒH‰T$XD‰µðE…ä„C‹t•A‹Â…öu!E;Ö…øB!´•ôErD‰µðéà3ÛE‹Ê…ÿ„ÄE‹ÚA÷ÛAƒùstfE;ÎuA‹ÁAIƒ¤…ôCȉðCE‹Á‹‚AÿÁH¯ÖB‹„…ôHЋÃHÐCH‹ÚB‰”…ôD‹µðHÁë ;ÇtH‹T$Xë”…ÛtNAƒùs„WE;ÎuA‹Áƒ¤…ôAA‰…ðA‹ÉAÿÁ‹Ã‹”ôHЉ”ôD‹µðHÁê ‹Ú…Òu²Aƒùs„	H‹T$XAÿÂE;Ô…çþÿÿE‹ÆIÁàD‰u€M…Àt:¸ÌHM„L;ÀwH•ôè±NëL‹À3Òèe:úÿèÀcüÿÇ"èyiþÿD‹u€D‹d$@D‹l$H°„À„šE+åHSùÿD‰d$@…tüÿÿ‹L$DE3í‹D$8€À+È„—Aÿ‹„‚¸"…Àtbƒø„€E…öt{E‹ÅE‹ÍD‹ÐA‹ÑAÿÁA‹À‹L•„I¯ÊHÈL‹Á‰L•„IÁè E;ÎuÜE…ÀtEƒ}€s‹|$0s-‹E€D‰D…„D‹u€AÿÆD‰u€ë.E3íH‹t$P‹|$0H‹ÞD‰m€é‡H‹t$PH‹ÞD‰m€ëyD‹u€‹|$0H‹t$PH‹ÞE…ötdE‹ÅE‹ÍA‹ÑAÿÁ‹D•„H€A‹ÀLHD‰D•„IÁè E;ÎuÝE…Àt6ƒ}€ss
‹E€D‰D…„ÿE€ë#E3ÉD‰­ L…$D‰m€ºÌHM„èøH•PHM€èôgýÿƒø
…ÿÇÆ1H^E…ÿ„ŽE‹ÅE‹ÍA‹ÑAÿÁ‹„•TH€A‹ÀLHD‰„•TIÁè E;Ïu×E…ÀtZƒ½Pss‹…PD‰„…Tÿ…Pë;E3ÉD‰­ L…$D‰­PºÌHTèQë…ÀuÿÏë0H^ˆH‹D$p‹L$L‰x…ÿx
ùÿÿÿwÏH‹…@HÿÈ‹ùH;ÇHBøHþH;ß„èA¾	ƒÎÿD‹U€E…Ò„ÒE‹ÅE‹ÍA‹ÑAÿÁ‹D•„HiÈÊš;A‹ÀHÈL‹Á‰L•„IÁè E;ÊuÙE…Àt6ƒ}€ss
‹E€D‰D…„ÿE€ë#E3ÉD‰­ L…$D‰m€ºÌHM„èˆH•PHM€è„fýÿD‹×L‹ÀD+ÓA¹¸ÍÌÌÌA÷àÁêŠÊÀáÀD*ÀAH0D‹ÂE;ÑrA‹ÁˆDÎD;ÎuÎH‹ÇH+ÃI;ÆIOÆHØH;ß…!ÿÿÿDˆ+ë{H‹•@LI‹Îè¯]þÿ…Àtaé¥H‹•@LàI‹Îè]þÿ…ÀtBé›H‹•@L¹I‹Îèq]þÿ…Àt#é‘H‹•@L’I‹ÎèR]þÿ…À…ˆD8l$ht
HL$`èy%H‹ÀH3ÌèêúÿHÄØA_A^A]A\_^[]ÃE3ÉL‰l$ E3À3Ò3ÉèÖeþÿÌE3ÉL‰l$ E3À3Ò3ÉèÁeþÿÌE3ÉL‰l$ E3À3Ò3Éè¬eþÿÌE3ÉL‰l$ E3À3Ò3Éè—eþÿÌE3ÉL‰l$ E3À3Ò3Éè‚eþÿÌÌH‰\$H‰t$WHƒì I‹ÙI‹ðH‹úM…Éu3ÀëVH…ÉuèA_üÿ»‰èùdþÿ‹ÃëH‹ÖHL$@èVé‡E3ÉHL$@E3À3ÒÿfV‹ð…ÀuÿâV‹ÈèWüÿë\;èºGõ‹Î蜤ÿÿH‹ØH…ÀuèKWüÿÇè`Wüÿ3ÉÇèÛ…üÿë$D‹ÆHL$@H‹ÐèáH…ÀuH‹Ëëß3É踅üÿH‹ûH‹ÇH‹\$0H‹l$8H‹t$HHƒÄ _ÃÌH‰\$ UVWHƒì0H‹ÁH3ÄH‰D$(3ÿA‹èH‹ò‹ÙE…ÀyèåVüÿÇèž\þÿ3Àéø…Ét!èr…Àuè¡VüÿÇè¶VüÿÇ
ëÏè•%ÿÿ‹Ø…ÛtfƒÃ@ÇD$":.f‰\$ f‰|$&ëÇD$ .H…öt…í~D‹Åf‰>H‹ÖHL$ èsé‡E3ÉHL$ E3À3ÒÿU‹ð…Àuÿ“U‹ÈèÌUüÿë\;èºGõ‹ÎèM£ÿÿH‹ØH…ÀuèüUüÿÇèVüÿ3ÉÇ茄üÿë$D‹ÆHL$ H‹ÐèþH…ÀuH‹Ëëß3Éèi„üÿH‹ûH‹ÇH‹L$(H3ÌèÎúÿH‹\$hHƒÄ0_^]ÃÌH‰\$H‰l$H‰t$WHƒì ‹ÚE3É3ÒE3ÀH‹éÿaT3ÿ‹ð…ÀuÿÛT‹ÈèUüÿ3ÀëX;غGó‹Îè“¢ÿÿH‹ØH…ÀuèBUüÿÇèWUüÿÇëD‹ÆH‹ÐH‹ÍèáH…Àt	H‹ËH‹ßH‹ùH‹Ë賃üÿH‹ÇH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì ‹ÚE3É3ÒE3ÀH‹éÿ¹S3ÿ‹ð…Àuÿ+T‹ÈèdTüÿ3ÀëX;غGó‹Îèã¡ÿÿH‹ØH…Àuè’TüÿÇè§TüÿÇëD‹ÆH‹ÐH‹ÍèH…Àt	H‹ËH‹ßH‹ùH‹ËèƒüÿH‹ÇH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$WHƒì A‹øH‹ÚE…ÀuèFTüÿÇèÿYþÿ3Àë5L‹ÂE3É‹×ÿñR;Çr
è TüÿÇ"ëÝ…Àuÿ^S‹Èè—SüÿëÊH‹ÃH‹\$0HƒÄ _ÃÌÌÌH‰\$WHƒì A‹øH‹ÚE…ÀuèÚSüÿÇè“Yþÿ3Àë5L‹ÂE3É‹×ÿR;Çr
è´SüÿÇ"ëÝ…ÀuÿòR‹Èè+SüÿëÊH‹ÃH‹\$0HƒÄ _ÃÌÌÌA‹ÀL‹ÒL‹Á‹ÐI‹ÊE3ÉHÿ%8RA‹ÀL‹ÒL‹Á‹ÐI‹ÊE3ÉHÿ%(R@SHƒì0H‹H3ÄH‰D$(ƒùvèSüÿÇè.SüÿÇ
èçXþÿ3Àë43Û…ÉuCë)fƒÁ@ÇD$":\f‰L$ HL$ f‰\$&ÿ›Sƒø“ËÃH‹L$(H3ÌèÞúÿHƒÄ0[ÃHƒì8ƒd$(D‹ÂHƒd$ H‹Ñ3ÉA¹è^úÿÿHƒÄ8ÃÌHƒì8ƒd$(A¹Hƒd$ è>úÿÿHƒÄ8ÃÌHƒì8ƒd$(D‹ÂHƒd$ H‹Ñ3ÉA¹èZûÿÿHƒÄ8ÃÌHƒì8ƒd$(A¹Hƒd$ è:ûÿÿHƒÄ8ÃÌf‰L$UH‹ìHƒìP¸ÿÿf;È„£HMàè¿úÿH‹EèL‹8M…Òu·UB¿fƒøwifƒÂ ëc·Mºf;Ês)ºè-ÿÿ…Àu·UëAH‹Eè·UH‹ˆ¶ë,A¹HE D‰L$(LEI‹ÊH‰D$ è
$·U…Àt·U €}øtH‹Màƒ¡¨ý·ÂHƒÄP]Ã3Òé5ÿÿÿÌHƒìXH‹1þH3ÄH‰D$@3ÀL‹ÊHƒø L‹ÁswÆD HÿÀHƒø |ðŠë¶ÐHÁê¶Àƒà¶L «ÁIÿÁˆL AŠ„ÀuÝëA¶ÁºA¶ÉƒáHÁèÓâ„T uIÿÀEŠE„ÉuÙ3ÀH‹L$@H3ÌèîúÿHƒÄXÃI‹ÀëéèúÿÌÌÌE3ÀéH‰\$WHƒì@H‹ÚH‹ùH…ÉuèºPüÿÇèsVþÿ3ÀëbH…ÒtçH;ÊsòI‹ÐHL$ èx½úÿH‹L$0ƒyuHÿËë%HSÿHÿÊH;úw
¶öDuîH‹ËH+ʃáH+ÙHÿË€|$8tH‹L$ ƒ¡¨ýH‹ÃH‹\$PHƒÄ@_ÃÌÌHƒì(è'Tÿÿ3É„À”Á‹ÁHƒÄ(ÃÌ@UAVAWHƒìpHl$@H‰]PH‰uXH‰}`L‰ehH‹¾üH3ÅH‰E L‹òM‹ùH‹ÑA‹ðHMèƼúÿH‹EE3ÉE3À‹ÖI‹ÎD‹`èþqþÿHcø…Àu3ÿéüH‹×HÒHJH;ÑHÀH…ÁtyHJH;ÑHÀH#ÁH=HBw>H;ÐHÉH#ÈHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðè99H+àH\$@H…Û„€ÇÌÌëH;ÐHÉH#Èè¾KþÿH‹ØH…ÀtÇÝÝHƒÃë3ÛH…ÛtOD‹ÏL‹Ã‹ÖI‹ÎèKqþÿ…Àt;D‹EpA‹ÌA‹À÷ØHÒHƒd$8Hƒd$0I#×D‰D$(AƒÉÿH‰T$ L‹Ã3ÒÿdO‹øë3ÿH…ÛtHKð9ÝÝuèüJþÿ€}tH‹Eƒ ¨ý‹ÇH‹M H3Íè¡úÿH‹]PH‹uXH‹}`L‹ehHe0A_A^]ÃÌÌÌ@SUVWATAVAWHìÐH‹+ûH3ÄH‰„$ÀH‹´$03ÿA‹éM‹ðL‹áH‰>ƒú…ÚLL$@ÇD$ €D‹ÅI‹ÖèþÿÿHcØ…ÀtCWH‹Ëè+Lþÿ3ÉH‰èIJþÿH9>„H‹CÿLcÈLD$@H‹ÓèZÿÿ…À…3Àéìÿ)Mƒøz…ÚE3ɉ|$ D‹ÅI‹ÖI‹Ìè—ýÿÿLcø…À„ºI‹Ïºè·KþÿH‹ØH…Àt%L‹ÈD‰|$ D‹ÅI‹ÖI‹Ìèaýÿÿ…ÀtH‹ÃH‹ßH‰ëƒÏÿH‹Ëè§Iþÿ‹Çët»;Óu;E3ÉE3À‹ÕI‹Îè‚oþÿLcø…ÀtQI‹Ï‹ÓèQKþÿH‹ØH…Àt¿E‹ÏL‹À‹ÕI‹ÎèYoþÿëž…Òu)ºí‰|$0‹ÕLD$0D‹ËI‹Îè9oþÿ…ÀtŠD$0ˆéÿÿÿƒÈÿH‹Œ$ÀH3Ìèã
úÿHÄÐA_A^A\_^][ÃE3ÉH‰|$ E3À3Ò3ÉèÑRþÿÌD·
3ÀD·E+ÁuH+ÊfE…ÉtHƒÂD·
D·E+ÁtèE…ÀyƒÈÿßÀÃÌHƒì(H…ÉuèvLüÿÇè/RþÿHƒÈÿHƒÄ(ÃL‹Á3ÒH‹
®"HƒÄ(Hÿ%ÃKÌÌÌHƒì(H…Éuè:LüÿÇèóQþÿHƒÈÿHƒÄ(ÃL‹Á3ÒH‹
r"HƒÄ(Hÿ%‡KÌÌÌH‹ÄH‰XH‰pH‰xL‰p AWHƒì M‹ñA‹øH‹òH‹Ù¹轊þÿè×KüÿD‹8D‹ÇH‹ÖH‹Ëè‹ð3ÿ…ÀtI‰è¶Küÿ‰0ë!H…ÛuèŸþÿH…ÀtHxHH‹I‰è”KüÿD‰8¹車þÿ‹ÆH‹\$0H‹t$8H‹|$@L‹t$HHƒÄ A_ÃÌÌH‹ÄH‰XH‰pH‰xL‰p AWHƒì M‹ñA‹øH‹òH‹Ù¹èŠþÿè3KüÿD‹8D‹ÇH‹ÖH‹Ë誋ð3ÿ…ÀtI‰èKüÿ‰0ë!H…ÛuèdžþÿH…ÀtHxPH‹I‰èðJüÿD‰8¹èŠþÿ‹ÆH‹\$0H‹t$8H‹|$@L‹t$HHƒÄ A_ÃÌÌH‹ÄH‰XH‰hH‰pH‰x AWHƒì0H‹ñA‹øA‹ÈH‹êèêH‹ØH…À„É€8A¿u	‹ÏèTëH‹Èë
¸é«H‹ËI‹×èX„Àtç3ÒH‹Ë膪ÿÿ…ÀtãH…öt;…ÿt!HƒÈÿHÿÀ€<u÷H;ÅrH…ítƸ"ëdL‹ÃH‹ÕH‹ÎèVGþÿ…Àum3ÀëNèiþÿH…Àt?HxHH…ÿt6H‹H…ÉuQI‹ÏèüGþÿ3ÉH‰èFþÿH‹H…ÉtL‹ÃI‹×èGþÿ…Àtµë6¸H‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A_ÃHƒd$ E3ÉE3À3Ò3Éè¤OþÿÌHƒd$ E3ÉE3À3Ò3ÉèŽOþÿÌÌH‰\$H‰l$H‰t$WATAUAVAWHƒì0IcèL% E3öH‹úH‹ñA¿A½M94ìuA‹×A‹Íè@Gþÿ3ÉI‰ìè]EþÿI‹ìH…Û„¿fD93u‹Íè£ëA‹Çé­I‹ÕH‹Ë膄Àté3ÒH‹ËèX¨ÿÿ…ÀtãH…öt=…ít#HƒÈÿHÿÀfD94CuöH;ÇrH…ÿtfD‰6¸"ëdL‹ÃH‹×H‹Îèv|þÿ…Àuo3ÀëNèù›þÿH…Àt?HxPH…ÿt6H‹H…ÉuI‹×I‹ÍèŒFþÿ3ÉH‰èªDþÿH‹H…ÉtL‹ÃI‹Õè+|þÿ…Àtµë7¸H‹\$`H‹l$hH‹t$pHƒÄ0A_A^A]A\_ÃE3ÉL‰t$ E3À3Ò3Éè3NþÿÌE3ÉL‰t$ E3À3Ò3ÉèNþÿÌÌH‰\$H‰t$WHƒì0H‹úH‹Ùº.èåúÿH‹ÈH…Àuè Mþÿ2ÀH‹\$@H‹t$HHƒÄ0_ÃH;ÃräH+ÃH;øvÜ3ÒHqH‹ÎDB$èküÿHƒÀtÉH+ÞA¹$H‹ÖH‹ÈLè=›ÿÿ…Àu°ë«Hƒd$ E3ÉE3À3Ò3Éè„MþÿÌÌÌÌH‰\$H‰t$WHƒì0H‹úH‹Ùº.èe6L‹ÀH…ÀuèMþÿ2ÀH‹\$@H‹t$HHƒÄ0_ÃH;ÃräH+ÃHÑøH;øvÙIp3ÒH‹ÎDB$è”küÿHƒÀtÆL‹ÆA¹$L+ÃH‹ÖIÑøH‹ÈI+øL‹ÇèΚÿÿ…Àu°ë Hƒd$ E3ÉE3À3Ò3ÉèÝLþÿÌH‹‹	é¦ÌÌH‹‹	Hÿ%ÀDH‰\$WHƒì HcÙH=4Hƒ<ßuº¹èšDþÿ3ÉH‰ßè·BþÿH‹ßH‹\$0HƒÄ _ÃH‰\$WHƒì HcÙH=Hƒ<ßuº¹èVDþÿ3ÉH‰ßèsBþÿH‹ßH‹\$0HƒÄ _ÃH‰\$H‰t$WHƒì0‹ùèbÿÿÿH‹ðH…Àt~H‹Ð¹èåHÿùíwc‹ØHÞ…ÿtƒït
ƒÿuÆuëÆtëÆsHÿÃH+óÿ¶E‹ÈA¹$L†H‹Óè_™ÿÿ…Àu1HƒÉÿHÿÁ€<u÷fÇ.0°ÆDëÆ2ÀH‹\$@H‹t$HHƒÄ0_ÃHƒd$ E3ÉE3À3Ò3ÉèyKþÿÌH‹ÄH‰XH‰hH‰pH‰x AVHƒì0HcùHñE3ö½L94ûuAV‹ÍèL;ÀHÉH#ÈHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèý%H+àH\$PH…Û„…ÇÌÌëL;ÀHÉH#Èè‚8þÿH‹ØH…ÀtÇÝÝHƒÃë3ÛH…ÛtTD‰|$(D‹ÎM‹ÅH‰\$ ºA‹Îÿ]9…Àt2Hƒd$@E‹ÌHƒd$8L‹ÇHƒd$0‹UH‹MD‰|$(H‰\$ è'Yþÿ‹ðë3öH…ÛtHKð9ÝÝu	è»7þÿë3öH…ÿtHOð9ÝÝuè¡7þÿ‹ÆH‹M(H3ÍèWùùÿHe8A_A^A]A\_^[]ÃÌÌH‰\$H‰t$WHƒì`H‹òI‹ÙH‹ÑA‹øHL$@è¨úÿ‹„$¨HL$H‰D$8L‹Ë‹„$ D‹Ç‰D$0H‹ÖH‹„$˜H‰D$(‹„$‰D$ èüÿÿ€|$XtH‹L$@ƒ¡¨ýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌ3À8tH;Ât	HÿÀ€<uòÃÌÌÌ@SHƒì H‹Ùè²áÿÿ‰èÃáÿÿ‰C3ÀHƒÄ [Ã@SHƒì ƒd$0H‹Ù‹	ƒd$4è²áÿÿ‹Kè¶áÿÿHL$0è´ÿÿÿ‹D$09u
‹D$49Cu3Àë¸HƒÄ [Ã@SHƒì ƒd$8H‹Ùƒd$<HL$8èwÿÿÿ…Àt¸ë"H‹D$8HL$8ƒL$8H‰èuÿÿÿ…ÀuÞè¸3ÀHƒÄ [ÃE3ÀòD$H‹T$H¹ÿÿÿÿÿÿÿH‹ÂH#ÁH¹@CH;ÐA•ÀH;ÁrH¹ðH;Áv~H‹Êé©H¹ð?H;Ás+H…ÀtbM…ÀtH¸€H‰D$òD$ëFòióëH= t&H=@tH;Áu0H‹Eƒë'H‹Eƒ þH‹EƒëH‹Eƒ ýH‹EƒëH‹Eƒ üH‹EæÿÁæ þÿH‹E	0H‹EH‹u8ƒH ƒ}@t3H‹Eºáÿÿÿ!P H‹E0‹H‹E‰HH‹EƒH`H‹E!P`H‹E‹‰HPëHH‹MA¸ãÿÿÿ‹A A#ÀƒÈ‰A H‹E0H‹H‹EH‰HH‹EƒH`H‹U‹B`A#ÀƒÈ‰B`H‹EH‹H‰PPèæ3ÒLM‹ÏDBÿ”H‹MöAtHº3öAtHº3	öAtHº3
öAtHº3öAtHº3‹ƒàt0ƒètƒètƒøu(H`ëHº3
Hº+ëHº3Hº+
ëH#ÿŸÿÿƒ}@t‹AP‰ëH‹APH‰H‹\$8H‹t$@H‹|$HHƒÄ ]ÃÌÌHƒìHH‹D$xÇD$0H‰D$(H‹D$pH‰D$ èÓüÿÿHƒÄHÃÌÌHƒì(ƒùtAþƒøwè&üÿÇ"ëèüÿÇ!HƒÄ(ÃÌÌò\$ òT$SHƒìPL
Äò‹ÙI‹ÁE3À9tAÿÀH
~ôHƒÀH;Á|é3ÀëIcÀHÀI‹DÁH‹Œ$ˆºÀÿH‰D$(H…Àt\‹D$p‰D$0‹D$t‰D$4‹D$x‰D$8‹D$|‰D$<‹„$€‰D$@‹„$„‰D$D‰\$ èXHL$ èæ£ýÿ…Àu‹ËèÿÿÿòD$@ëè6‹Ëèÿÿÿò„$€HƒÄP[Ã@SHƒì è=ïÿÿ‹Øƒã?èMïÿÿ‹ÃHƒÄ [ÃÌÌÌH‰\$H‰t$ WHƒì H‹ÚH‹ùèïÿÿ‹ð‰D$8‹Ë÷ÑÉ€ÿÿ#È#ûωL$0€=Ôt%öÁ@t èñîÿÿëƈԋL$0ƒá¿èÜîÿÿ‹t$8ëƒá¿èÎîÿÿ‹ÆH‹\$@H‹t$HHƒÄ _Ã@SHƒì H‹Ùèžîÿÿƒã?ËÈHƒÄ [éîÿÿÌHƒì(èƒîÿÿƒà?HƒÄ(ÃÌÌÌòD$¸ÿH‹L$HÁé0fÁéf#ÈòD$ H‹D$ fÊòD$º€HÁè0f#ÂfÁáfÈf‰L$òD$ÃÌÌ(ÈòD$WÀL‹Òf.Èz	u3ÉéH‹D$¹ðL‹ÀIÁè0fD…Á…­‹T$HÁè ©ÿÿu…Ò„–E3ɹüÿÿf/ÁA—ÁAöÀu$‹D$À‰D$…ÒyƒÈ‰D$ÒÿÉöD$tä‰T$·D$ºïÿf#Âf‰D$E…Ét
º€fÂf‰D$òD$ºï¿òD$H‹D$HÁè0f#ÂòD$ºà?fÂf‰D$òD$ëJºï¿òL$¹ÿòL$H‹D$HÁè0f#ºà?fÂf‰D$·D$òD$fÁèf#Á¿ÈéþA‰
ùÿòD$H‹D$HÁè0fÁèf#Á¹þf+Á˜ÃÌÌÌòD$¹€H‹D$HÁè0òD$f#ÁfÁâfÂf‰D$òD$ÃòD$¹€H‹D$HÁè0f#ÁòD$¹þfÑfÁâfÂf‰D$òD$ÃòD$H‹D$H‹ÈHÁé ùðu
…Àu¸Ãùðÿu
…Àu¸ÃA¸øH‹ÐHÁê0fA#ÐfA;Ðu¸ÃA¸ðfA;Ðu÷Áÿÿu…Àt¸Ã3ÀÃÿ%Šÿ%Œÿ%Žÿ%ÿ%’ÿ%”ÿ%–ÿ%˜ÿ%šÿ%œÿ%žÿ% ÿ%¢ÿ%¤ÿ%¦ÿ%¨ÿ%ªÿ%¬ÿ%®ÿ%°ÿ%²ÿ%´ÿ%¶ÿ%¸ÿ%ºÿ%¼ÿ%¾ÿ%Àÿ%Âÿ%Äÿ%Æÿ%Èÿ%Êÿ%Ìÿ%Îÿ%Ðÿ%Òÿ%Ôÿ%Öÿ%Øÿ%Úÿ%Üÿ%Þÿ%àÿ%âÿ%äÿ%æÿ%èÿ%êÿ%ìÿ%îÿ%ðÿ%òÿ%Dÿ%6ÿ%(ÿ%ÿ%ÿ%^ÿ%Pÿ%Bÿ%4ÿ%&ÿ%ÿ%
ÿ%üÿ%îÿ%àÿ%Òÿ%Äÿ%¶ÿ%¨ÿ%šÿ%Œÿ%~ÿ%pÿ%bÿ%Tÿ%Fÿ%8ÿ%*ÿ%ÿ%ÿ%`ÿ%òÿ%dÌÌÌÌÌÌÌÌÌÌÌÌLcAFþÿÌ@UHƒì H‹ê€} u"HcMHH‹ÁHÁøHèÕƒá?HÁáH‹€d8þ‹MHè|ãþÿHƒÄ ]ÃÌ@UHƒì H‹êH‹EH‹HƒÄ ]éãEþÿÌ@UHƒì H‹ê¹HƒÄ ]éÊEþÿÌ@UHƒì H‹ê¹HƒÄ ]é±EþÿÌ@UHƒì H‹ê3ÉHƒÄ ]é›EþÿÌ@UHƒì H‹ê3ÉHƒÄ ]é…EþÿÌ@UHƒì H‹êH‹EH‹HƒÄ ]ékEþÿÌ@UHƒì H‹ê¹HƒÄ ]éREþÿÌ@UHƒì H‹ê€½€t¹è5EþÿHƒÄ ]ÃÌ@UHƒì H‹ê¹HƒÄ ]éEþÿÌ@UHƒì0H‹ê¹HƒÄ0]éüDþÿÌ@UHƒì0H‹ê¹HƒÄ0]éãDþÿÌ@UHƒì H‹ê¹HƒÄ ]éÊDþÿÌ@UHƒì H‹ê¹HƒÄ ]é±DþÿÌ@UHƒì0H‹ê¹HƒÄ0]é˜DþÿÌ@UHƒì0H‹ê¹HƒÄ0]éDþÿÌ@UHƒì H‹êH‹M@è”fúÿHƒÄ ]ÃÌ@UHƒì H‹ê¹HƒÄ ]éLDþÿÌ@UHƒì H‹êH‹EH‹HƒÄ ]éªáþÿÌ@UHƒì H‹ê‹MPHƒÄ ]é“áþÿÌ@UHƒì H‹ê‹MPHƒÄ ]é|áþÿÌ@UHƒì H‹êH‹EH‹HƒÄ ]ébáþÿÌ@UHƒì H‹êH‹EH‹HƒÄ ]éÐCþÿÌ@UHƒì H‹ê¹HƒÄ ]é·CþÿÌ@UHƒì H‹ê¹HƒÄ ]éžCþÿÌ@UHƒì H‹ê¹HƒÄ ]é…CþÿÌ@UHƒì0H‹êH‹M0ƒyÿu	èˆþÿH‹M0è‹eúÿHƒÄ0]ÃÌ@UHƒì H‹êH‹8Àt8Àt3Àë¸HƒÄ ]ÃÌ@UHƒì H‹êH‹8Àt8Àt3Àë¸HƒÄ ]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ@UHƒì H‹êH‹3É8À”Á‹ÁHƒÄ ]Ã̘oªoppðoÞoÌoºoˆorj`j`oNo>o2o&ooopoîkll$l8lNl^lrl‚ll l²l¾lÌlàlîlmm&m>mw0kØkØvÄv´vœv„vrvXv>v2v&vvvôuàuÌuÀu°u˜u‚uluXuDu,uuÆk¶k¢kŽkxklk\kìvDkkkþjèjØjÆjºj¬jœjüvútwètØtÊt°tŒp pºpÎpêpqq8qRqhq~q˜q®qÂqÔqèqöqr*rBrZrrršr¦r´rÂrÌrÞrôrss&s6sDsTsvsŽsšs¨s¾sÈsÚsêsöstt&t8tHtZtjt€t–t0p‚mtmhmânÒnÆn¸n°n nŒn€nrndnVnDn2n nnömämÔmÈmºmªmžmŽm\pnpLpˆ¢@€Ä@Ü•@•@Ì•@¸2@ƒ@ƒ@€ª@à}@ˆ4@ @ì3@°â+ØdWЩnÀO×¢ãóÆíA„	A­ól ·ÞGRéWp½Ñ‰ÀOÂÈ6a'»wjÐ¥5ÀO×Ðb÷ÀFÃ…¼m]rL§wìx,a®OØM‡G€¶	 Ä·]v+éÀqAŽ¦¸Oöáp¶Ñ¡ÎÀO×]àÙÖ‡Í+DW^
ëOor;Éoñ®wþL½§¨fð÷Ëë[áM¼ƒEÄ€ö¢vßß*ÈcMjVD¬Es…Á½"ñ‚@Œ0(9ŸA8LÑ7ʸ!A¦9mG-—*+$Ì%|šQO€àz)(þ¾B“ÀFé¥ä\ëäG¸ŸˆaUûÀF䬮®‰E¹·»†z¾âíø‹fCNÁ²I—Étw„ׄ·txŸMNI–{@°Ò>K]T£ÿÞKF«èaÈd“›ÐâºÁß4C¾Ýz¢"zŒöò“Ó£ÀOy«Ñ|ÞÃI)ÓЫsÀOÃ>€©BÖq±òÍB­’ë“ÇÌ
ó”7EµªC£)Ãt0Å*¤Mä^2mãF†¼T
íÐà» }¹jô—Lº^6CT¶v]=›»D¶®%ÚOcŠg´óP0µ˜Ï»‚ª½Î¢Vö	¯AHˆ÷Ì
FüÀFPèBÒ¾, É¨=¡¯$HíäܨEâüye64Bl‰ÅЙšÀOÖUá¢WU¦]ƒOˆ	ÂÉŠ¦úäÀF€iyŜѨ?ÀOÉa3K›ÿ@Ò¢~ÀOÃq†½K
àMš;Ùr–G¸E\¿«Ì\·G»N‡Ë‡»Ñb¢Ûo-ôXC§˜·MtY&Åh~vËIsB‡Â óUá[ñ6À†¡Ð‚Jª[CƒÃS[bH«ÁNº¡ïAFü·Œ"ý®ãJ†Ló‘
¸þÈèGÂй: Éáý7³Õ5F¦ÔÚ3ý+zÓÀFOñ${уøaϽt’ÑÏÃA³^±?U§Xô&×I}!<O™ªýÂÉGFV;&åO‘ÁF°¤íÔÛ}êö”P($IªZÑ^„†€9&®M[¸Ð˜ÀOÙr„µËW´é®G¡ Äß35Þâw~s5Ï®i+.b£iÙÿçЩ; É'~Í.g¯™C‡\„[bGžEòÃÖ€ÜE¿ïvŸ+ç0P‡¦“•Ñ”oÚS ’i)!@¿'QLü.Ji¬frßt’gHU;ÖaÞ‡-+Ùo—.ÑEˆÿ°Ñ†¸ÞÝf¹@"µÑ³´ªnýçàOÐ ê:i¢Ø+00à.PR€ìЉ«ÀO—-è“2¦NfÛH yßuž	÷âM7?eE‘d9Ä’^F{ëÜw†àª@=T¨Rø%«•9žœO¸'H²Klqt}±
{Òœ“J—3F̉.|-Ã÷!ªî›C»Q7¹oÖ©C€þmyÏ•4À[®_e¸ÿ¹ÎO¸œšk§mçá‹MÒ…]`“g”­ž…….­H§	iËV¦ÍõÀFÅëO…#òA¢Ž,\‘ûVàô׉#äG©``¼Â퓺
E%­Ð˜¨6QM\–v‹WN€·VM.¤µ^ÒãR
FœHòsÔp£ôº^QmÒƒ­ÀOÙÐpñNr-¤ïOŸ&¶„oºO²ë‹ÐRзôÀO×ìå%ñeá{HºÒqÈC,㟽À¸$í\EƒæÕ9OèÄt¤<&KA¸ÎÊ>=Øaª-kQG´œû˜^ø)˜,ÅÊ=µÜN’×k.ŠÁ”4qÙaÞ¼^O£©l‚‰^\`«Uå;MŸ¥þ™üìW¤.ÖIª|çK‹ã°g+à*U6ÌF¶:(Yˆ;ÊëJ§‚´®\F Зî4mcÂ/4*&{ÐŒ© É-¿èëô@јˆ`—Þ¬ù)–¯€ÿF€#Ϋœ>ã/’ICVôJ§ëNztµáI6FÓ—÷ÀOEг@ü­úw·iKªw^ðæèÄîÒ¨\I®;¿% ›S¦jc(=•ÒµÖÀOÙÐìŽ'Œ«>ÑŒ°ÀOÙСÀFÎVþeþ\ÄK­Šzãþ~|Tn9{ÅžC¾
$‚ë®&;ŠÜÙ„·.C§Z0§YctXT9bq^F·ƒ*¡‡Oï  ì!ê:i¢Ý+00iI~©+.Í©ã¢_@^A¦îÊÖ% xS†ûë¶iM¿‘ôEQ ¹3ó€ß·Ò£;`—ß[Ô}N8Ðú—GË¢)³’µw]§+.ÃD¦¢«¦JQ•3”(Ò9ÀOŽë>Ü¥>‡µ†G´ï½Ã2®®A`ÂtÑpÑ·Z Édþf½aÝèpÝH–UeÅáªÂÑ–[/tÿÚA¯Øx¥ó®¢Cšš(D¾W@¤Xzv×çùiÏ>ŒV–MYFDAtâÖKpÈžô&A©Ãµ*ôè.7£VœÎÒŸ`—Ɔö€¢'"ê:i¢Þ+00hXtÙ_ÊvJ‘Íõ¡)û°v؂تçíI†·æá÷Íþ'â9YõÓŽ:ÀOh7Õ
e.{ ŽJO°že—¯Ç/°±â+ØdWЩnÀO×¢ÀF]“šˆ—K¹$ßÉáåèúLb`w¤±GŠŽ:J˜'àÐWs5Ï®i+.b!¿\_ÑЃª[CƒP2nD\H±Cæ*v
Ÿåô‹óCòB“gÞ(ü#€ÿ4DLïήe+.b1ÑŠÛ*–B¨÷äp2Ér%â9YõÓŽ:ÀOh7Õ¡΋!	±ÿÝÌH¥lÄ?<Ò¾æøÊWäô>áòÒИÀOÙr AG†QÒ»¶`—{FL‚>!€ý¼OLˆ»'`g©$žØ$/4EÞjfqû¸þðJ1ÒйB Éá*)l6³Ù¿M»pæ.Ãл¿àÕ¹¿©ÆL@²²®m¶¯Ih.6]§üP·O¬,¨¾ª1D“l¯‚ñ4LŒá~É‹@J7<äºÏ¿}ªiFîÀs5Ï®i+.bÞ1‹¥I“¸káLúIC™Î£'õ+I‹~vú˜ÖäpŠh}ÆЙ›ÀOÖUáEûþK}4@¥¾¬°Vq’zeÒG'{ÐŒ© É-¿èîÀFý4p ªlTI¬?—¢rùŠïÀFÌÝÖ”hJuA£t½XJQx€;òûðㄈª>Vøf’£NrŸ@¶"ö=½Å3uwƒ-ÍöNF§EH/дt“óÀF5K›ÿ@Ò¢~ÀOÃqáÀF9tÖÙRNƒNgɆóš«N_3haO‰1ÏF—I¡FãÕS÷2I´Et€$˜¶c^¿ÁNI²œe·2ÓÒè$5¾3QBº…`ÊíÏó¿k(ÔºC°y·&|=H‘ÀF5ꥂÍÙÅG–)á]/qNnw“€mðjKD‰W£w? ”šjY>Ñ4 É'èrìã`F¿$<;{dˆÐÀF³óP0µ˜Ï»‚ª½ÎöÀF:Ì¿´,ÛLB°)隇ÆA˜x€WOŒbD»cq#€±	Û…¶>ùeöL :ãïerŸ=íñ÷mŸ¢Gª®)ÓÆðf«Rž
øßI¬¸C0õhxU*TÀðKуî É
ÈI€žãˆx5Ï®i+.b¢ñþ^5N“›$×÷̈Ñc<‰ÈEM¾";çãeа‰¶Óv»L‡÷X]àp0â3NvFƒZ˜9\;û¡¸51M–Ùl¿Ég™DŠMƒt	ÖN†nòØ8ëÀF…l^"`Gšþê3¶qs§Õec
åE‡ö
¥kjO}‹Í~6Á›J”N½fsÌÃOÞ¼eO'Oƒ§ü¤ß}Ý‹Ûé´º49LµÌ¡½,AFº+¥áé_C³Ù(Ú¦HÀöR88øÓüѦ¹`—ß[Ô4ÄÂ0‰L˜]©÷0°©³iÊî0ÁI¬ák^Ãr¯µ
Ÿ\ž•Ð£¤ É&6ÇÁ’ÞƒiO£»†æ1 J#
«!jÈþO£h
énG.± Œ´UVL¸¨Mä²™Ó¾rÒb
Å°K£‚i}Ír›€ Àœí¹Ñ˜#ÀOÙrøÀF°0¡wý”Ð¥DÀO×ÐbÀFQšœ>ªÔpH´|t$´‘ñÌøÚHÏæNO¸iØNã„ÏÒi3ü·Ošë°ðü´<œ«¸ìÂzO‘1Iæ(
W0½¼\Ê"F´-¼VÛ
åàÖ‡Åω© ÉA)ùÀF 
»ÊWÚÏ™t ¯×—bï@Z|û üK‡JÀòà¹úŽA¦VgqÞЃª[Cƒ@¾–L\‘ϙӪJè7ë¯çÑ.jÐŒxÀOÙ´`OÞúK¤”‹ ²#@;òûðㄈª>VøêÀFhÆP²}õáN¦<)çѪôÀF	ÙÄ$aàO™B‚d-©@Äy#uL„KdæúøqkÀP®ÒëŠC†UŠ	.4˜z‚]«bÁýÃM©Ý
I]—úÀF£¶t›ý
Ožx_xòçrd©_w~L¾NdÍL·Ö¬ìÀF¹4ïK†§u@ºˆ+‰©ÐšÓý#¯F­´l…HiÇ"k1Ë÷%¸BŠ	T
#¤8ƪd_»ðµNŽM&uf4Lc'»wjÐ¥5ÀO×Ðbx‡Ð8WõFž¿ºTpjØ÷ç7B¹¬WGC‘Q°Œl2Ñ÷ÀFiÈìÛÁÀM…^eöÅQ¯I”+ê”ÌéàIÀÿîdÊ[ÀFÏÀFÀFÀFÀF ÀF ÀF!ÀFÀFÀF0:s*έåªDw=ÀF`kõÕ;Yµi+-¿zÐ1OYб” É
È¿¶Ÿ¥4<Ñœ™ÀO¹˜ªV±%п
ª¸ßÒ… XÈ$5I´‚?Ø#3:O4jõÕ;Yµi+-¿züjõÕ;Yµi+-¿zÐiõÕ;Yµi+-¿z ÄvÏšñ ¯nrô=ÀF>ÀFDÀF[ÀF"ÀFFÀF0ÀF1ÀF2ÀF3ÀF%ÀF)ÀF*ÀF0:s*έåªDw=IÀFè¹ë–yÒ‡.øY+ÀFGÀFHÀFÊ:/Û†/ÑŽÀO¹˜šË:/Û†/ÑŽÀO¹˜šÌ:/Û†/ÑŽÀO¹˜šÍ:/Û†/ÑŽÀO¹˜šÎ:/Û†/ÑŽÀO¹˜šÏ:/Û†/ÑŽÀO¹˜šÁÀFÀÀFÆÀFÎÀFU
8r+£C…+nó4é@ÀFæõòØacHŸ&8šFvïÞCj?À¤e˜˜~à¸Ò¦òÀFÀFÀF&ÀFÀFÀF	ÀFÀFÀkŸò!PΪi)?
ÀFÀFÀF
ÀF
ÀFÀFÀFÀFÀFPÀF%ÀFQÀFÀFÀFÀF@ÀFðÊ™^Aψªµiõ XשFÏ•üªh
´Mm8gÏ–ªh
´zÔó0GdÑŽ<ÀO¹8m®ö¼xˆÑƒéÀOÂÆÔ4ÈyˆÑƒéÀOÂÆÔ’Mm8gÏ–ªh
´&ÀFEÀFÇ–v\цø°WÞy”(ÌÒ ÷€_…±ÕÀFÔÀF4ÀF	Zð¢¢'µB¼¬>ô›Ã¢RX0eѶ£øu{ùÚ®šP9VѶ¡øu{ùðþ½ÏÏ£0ªÁne0ÕE
KvСʪÁne
y˜´âа±ÀOØܦÏ«|õxÒ–ÀO£†À¨´jÒ­IÀO£†ÐàQžnÒ–ÀO£†0îüŒ½9иѠ$«-»¸1.¦Ð¦Å É¯EÀ^¼ƒ*oСĪÁneÀÞP«oСĪÁne |Œ~|Б?ªÁne?Ç¦üàЗP É¯E^æ#ŠÂ1Љ $«-»á?îƒÙWй2 $«-»â?îƒÙWй2 $«-»pðwµâ~Б?ªÁneg­‡Ð‘@ªÁneñ˳ÁjˆÐ‘@ªÁneò˳ÁjˆÐ‘@ªÁneã?îƒÙWй2 $«-»~{ŒS^ÒЗB É¯Eyð¾|„ªKD¼phäƒê¼KΔӳѹ´ÀOØÕ°ž™rÀIúÑ ¯ÀO£†°…‘’ËÅC€©’'zO{Tx…hиÀO×ìà{ËlhиÀO×ìÎ6²Ç€îИ_`“‚ðÙÃ\Ñ•¾`——êOßOðÎrþÒ‡¥ÀOh7Ïü¬y½)ÓŽ
ÀOh7ÕBÐTyI¼²6¾Eº¬Z{Ù’ÇÙ?i]?ˆú9ì¯øÅA„!8¾ÒFs°%çÍÉÌE‘~2]rú´Î?àöjdÖôN–&÷àí6u^g¤óO!˜BŽ°>9ù}˜Œ®—‡ÓN¾r*GÝ“°¥ùkF³ðNª]Í·gh±hÏ“ægÙA‡c™*î^Z¡%­È”2îAeqKÐW»'ìØ;?B@±
JÏÙ$ÔSõQ¦À‹´Òµí`—Ɔö†(ÂœŽÜÒ±ÐÀOŽë>’ƒÛñ1sÐŒ™ É-¿èªO(hHjÐŒxÀOÙ´…ÀiQÍD”¯(ߥlù+ ‹rˆ÷Î’­ª§LÐm‚CçîB¼U¡âaÃ{þÓ°Ÿ~Ÿ‘C«.›`1“y‹Á¼º/D€ÄŠYÃF;šæa¥¸´A‘¥dƼÊ403bpcã(J¥g
·€æ×ØДէ{E³´Î]º¬ˆ°­é½ÆEŽ)П“SáãØ-<¨©M£0G$4[¡¾“Vÿà,HMµÅ@}͹2Ý­H¥<$A«ãµ§%1²efþÊà¹I¡x+\´’¥ÚýhŠÜ LŒëAfCµ¦%§ñ°”¼D–áB–£Râm§>¶…oE¡œHžú…‹?¾syûYz(©…¸yòé
…K¬Ýìù@‰Aº—º“X‡G§áA'qQU”‚AÿJ€ú
sêÌY!ëW«O«Zåú{ê*lñ×ðg²(M‹â2¥Ä(¼ÿ ‚TfC¾'>çŽÂ|a.» 	ÑšÀOÂÖÁî±;•´“ј£ÀO¶‡Ú.K[ãÚÁKŸ8¼õÔ…¶¤³…¶H™Ù]êÒ‡26 Ù-&{ÐŒ© É-¿èráë:Љ³ É
¬ü%äwùËCºj»W'tVaämÑyî«!@‘i²aÖWBóýVmýЕŠ`—É •I-`:±›B¦n5äOC‘ûê(ž†K鞟Š^ﯘÇ=ÄÑ•êK0»™â˜:ÚšÑL¥%2J³·4{î[ãkY¦s=ÐåBM¯ÀQ!ºB\[–ˆ/B{N€sASÃÖ¦.À̆I›#t9JD¨f?kјÀH¢"ûÞtâûÅ»˜‘ªìÌ-G¾í¤ös?z¥ZÕA°žže¬!`[ǽ6îæN¾XXâ$µ¶ÓßÁéK…ö¦iiôöÅ‘£•Ôž(L„«žqžm®å–ájKÆHªˆ(.~,-Y@ƒo‚3\.Q¸ŸÉåëC£pðg{‡L¿°õµŒK”Ižs<_«z”\
L´ÖK÷ƒoÉø(t¦ã;sM³|¥@¿ø•)Ù^ÏvJ¿YêÓž¢¹~+IÇzŽÃŠC‡ÛhsxDÿp§ØÎWJ?,C“P0òDƒ÷OôAÑoËZ\ÊÜq"ütD·Åk¬â×¾®‡TLžrTŒöIkE
àaÿ`N’Ne7¶Ý6ò‹Œì_I˜”‘Õ|k’H¢rYøˆšM>sáë:Љ³ É
¬ë¯çÑ.jÐŒxÀOÙ´ðË¡d:aD‘X7iii9PÛ5—}+E‰ut¨X(ÓT6QøB~ÛœC…ñä]_È#ͼ„Þ_ÛL®¤¯d¸=x«ˆr|Õ­ÔhG¾–•2Ù`Òýæ?uIœŒ¦Ÿ£p4Bf6×—K›ƒt„©Ð3ÇOtaµ…‘G©°'"v0›
SNæwL£¬1Ð"(i¡v”ù¬@È	Yè‡G€ºØ­+ÐÀO×ÐbÈCß¾Ó‹4`—ß[Ô„L¼Òr?RJ¦{Ëó˜,»AÛs…EŽO¨ŒW¡£L›Ñ‹"ÀOÙÐ7vî8áуyÀOÙÐà½äühK€KŽœt&1Zsˆ~¯§:6›B¨ã÷}Ft¤ˆrØ⋪†GM·v2̤pŠDÍ´†œfD’.b[‡®€Gåvt­ãH¦•;© ¯ñ
zæ<§±ŠñDCÒü¿kÐÊ?}ùÖHƒ2”lwâG”Zrµ\Úí£˜GŠÛÅçÚ™±—YýÆkŸˆH‡”èŒÞ?FA&O©•AŸŸ;±,àÉUi™6
ÈI‹Jì²"ûx‡Š§9Jª³£›œ4§Ùܰܵ;E¾–fDþ×°¼ÒÀqmrÌE¦À.1ÁÛ!Yu´Y&¸î·H³xHÏ£‚'¶éGˆVÁBeUNOØ®Ç|)¼I‰EÁ@É0l…yדس„Dƒg,Ý ÎÖeÆùòÂL¿3ƒ"×5/QÞóqíCA„wéSk‚5X§;-î3ÕB»{_41Ølxƒpé³æòO…h6þǾƱ•ˆ´L¥b
VBPƒo¯zÈþù5zD­· #D‘@Fègmœ[¸Mœ¼Ýá/BTñ|\¹ŽÔ?@«™ÖÇz„¬ìpà¼ÀD—°FÇÉ[žÜ0é	49Zуú É
ÈI}ÑÞA³ÖaB™}ˆÆKXÐ䌠%ú«Dµ|DZÃ#à¹`ËÚ½Wv®G„EÒ>Ï‚®ÏZ…#ê@–Òk{Xö8ø&ˆ¨o‡IªÞêï¿èQ–d5ÀCþÕv†Sdn0@Dš×ÐHˆæ¤&’'›û®ûÒÖñŒEŒ4V˜w¢Ò˜n¨B*O—øŠôà&Ù-bØÑÞfôM¿lV!™jñ’
ö
hÖF³XÖapÝäf_Ï:ÛqúJð?Äýò¥¸¿Þ2cµ‡pFÀ^W´¤ž5}3Æ” H¼çjœiÔÖŸOY<0Ÿ¡G—šÉè==
–Û6e–ÑF›§ÓpžìùíûèqîüF¿ŒwH¨¡®Ò¶‰e_žK·à#ÍÙq}ŒÄkdÁ˜ò‘O¢ë-Ñp©V+¹U‹Nš‰™»¶ù;ÙÑ;z©5³O¤gôŒ¬5âе.áÃ}øD¶Ýw³Mmä3sîðüæ›GŸ%¨`Â4£Žún¦.8E’4ï0…yªvüøF£'6÷Ñ]‘A”.—VGºìÞ‰J=±é§PïpÑ·Z Édþ1ÏÂFÁO¹ÐŠœÄ½ÀF K6ó¹eΩºªJè7`, ê:i¢×+00ÀFh3©ÝM¸nÚãMÜ™ŠS{5”)ÊxKƒ®èþt	OÏó¨°3C«KˆsË­¤‹“w`µ¬$ÇD‚âƒ&ªl·´;ýÝ0M£HŸµÖ¿þR¸×UÑöòBªu‡(¡²ÒdÆT&©àaërr†C‘uòäÆ‹.|uUÐ:WˆPH’w¸[ÛŽ	œZÜŠèÞM¥¡`ø* ®÷óâ´À!ºsGº3^ÉFë‹0ÇðMßãJ‘Sªk‚éyZ
8—Ñy
ÈM 3íˆ,/¡KáqóI\ŒœMš;T¦‚Q'°ˆCH¿ïâÈCªåÁh4-§6¶C¬$Óð/Ù`zÌL’be…L†WÑw’R"¶FÎ)´ J ŠÓëȬ¤£
ÕºFÅD‚-Ê€’Áür¾‚3Æ3yÐHšÈ…ûF¾/ÝÙã_~_˜I‘ùîùý§ÓN¨ÎÙK‘
âRù—¯Â(”Nä¼½‡I ™@ÜÒUçoÁ®±ƒ#RH°éÆkMÅ?'kýaI•¢Ãµé×õ}ºE¨êFŠ·Vêx”<µoŠ•²Ü¯Oªý°T­;|´Û%¥@ž€¥F À«Œ!’ªì5C3€Ò4Âî¬a@ðY?J©TwZ¥Àƒ®8—™•ˆKžMn錕RÚÖö%=*KÜC¼ÞEgèÈ{Sl"vžM§`3Û)’/‹#RWð$ZI‚ñ/Õ“g–ý3w’¥åBµ”$„hŨ"ÜIˆßΕL™Ý?vk΄e‚}ÂI‰ÉƼºŒ8-êF"êÊDD£Ämè'äCb*±Ø*+CŒÏ,R¯Í[09|ò)€ÑJ”ã=ºAxÁB:¸RC%jAÙÀÞyiȳ©²„áðOŸ^ø‚Ð7q³¢2hK_L¸rzÑçšî=*ãÖF…¼Å—Û5WáIZgnM¥åI´Ê/~¼o&
IíF©k"tÛ% ÷ªå¸0H‡ Ng4ËÕóÆf/÷`Cµ£” U7%¬‘‘˜ÿ(ðL•„àÐx¼#–½Ôh>5qM€Ÿ¶Ùó?¡ïw™€ø;E9á¢ÒeZ‡J	5±‹7B–ÆÄî½°x§Ëê™sà¶C¨–U¯äŠ3 Ž@@@ @¸@ø@8@advapi32api-ms-win-core-fibers-l1-1-1api-ms-win-core-synch-l1-2-0kernel32EventRegisterEventSetInformationEventUnregisterEventWriteTransferFlsAllocFlsFreeFlsGetValueFlsSetValueInitializeCriticalSectionExP@`@h@x@ˆ@˜@¨@¸@Ä@Ð@Ø@è@ø@¢«@@@@@ @$@(@,@0@8@D@H@L@P@T@X@\@`@d@h@l@p@t@x@|@€@„@ˆ@Œ@@”@˜@œ@ @¤@¨@¬@°@´@¸@¼@À@Ð@à@è@ø@
@ 
@8
@X
@x
@˜
@¸
@Ø
@@ @H@h@@°@À@Ä@Ð@à@@@ @0@P@p@˜@À@è@@8@`@ˆ@¸@è@@¢«@@0@P@h@ˆ@__based(__cdecl__pascal__stdcall__thiscall__fastcall__vectorcall__clrcall__eabi__ptr64__restrict__unalignedrestrict( new delete=>><<!==!=[]operator->*++---+&->*/%<<=>>=,()~^|&&||*=+=-=/=%=>>=<<=&=|=^=`vftable'`vbtable'`vcall'`typeof'`local static guard'`string'`vbase destructor'`vector deleting destructor'`default constructor closure'`scalar deleting destructor'`vector constructor iterator'`vector destructor iterator'`vector vbase constructor iterator'`virtual displacement map'`eh vector constructor iterator'`eh vector destructor iterator'`eh vector vbase constructor iterator'`copy constructor closure'`udt returning'`EH`RTTI`local vftable'`local vftable constructor closure' new[] delete[]`omni callsig'`placement delete closure'`placement delete[] closure'`managed vector constructor iterator'`managed vector destructor iterator'`eh vector copy constructor iterator'`eh vector vbase copy constructor iterator'`dynamic initializer for '`dynamic atexit destructor for '`vector copy constructor iterator'`vector vbase copy constructor iterator'`managed vector copy constructor iterator'`local static thread guard'operator ""  Type Descriptor' Base Class Descriptor at ( Base Class Array' Class Hierarchy Descriptor' Complete Object Locator'CV: ::template-parameter-generic-type-`'`anonymous namespace'''`non-type-template-parametervoid`template-parameter...NULL%d`template-type-parameter-`generic-class-parameter-`generic-method-parameter-}' }' `vtordispex{`vtordisp{`adjustor{`local static destructor helper'`template static data member constructor helper'`template static data member destructor helper'static virtual private: protected: public: [thunk]:extern "C" ) char short int long unsigned void volatilestd::nullptr_t std::nullptr_t,..., throw(cpuamp, charshortintlongfloatdoublebool__int8__int16__int32__int64__int128char16_tchar32_twchar_t__w64 UNKNOWNsigned const volatile`unknown ecsu'union struct class coclass cointerface enum volatile const & && cli::array<cli::pin_ptr<)[{flat}{for s ¨ì@À,@À,@À,@ í@Ü'@Äú@ @ í@Œ(@\û@˜@ î@ä'@Èú@´@ î@Ø'@¸ú@\@ ï@ (@û@@ ?? EEE50P( 8PX700WP  `h````xpxxxx€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxwpwpp(null)(null)
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×äTc-^Çk@êítFÐœ,Ÿaõ¹«¿¤\Ãñ)cdµý4ÄÒ‡f’ù;lDÙe”,Bb×E"š&'OŸ@•Á‰V$§úÅgmÈsÜm­ërÁÎd'¢cʤï%{ÑÍpïßk>ê_änþÃÍj¼f29.EZ%øÒqVJÂÃÚ.¨C²ª|!Ž@ΊóÎÄ„'ë|Ô%­I@ÝÚTŸÌ¿aYÜ««\ÇDõg¼ÑR¯·û)`”*!Š»¤Ž¯V©ŸG6²K]à_Ü€
ªþð@ÙŽ¨Ð€k#cd8L2–ÇWƒÕBJäa"©Ù=<½róå‘tYÀ
¦ìlÙ*Óæ…[aOni*{âP+4Ý/î'Pc™qɦéJŽ(.onIn@2&@­PrùÕÑ”)»Í[f–.;¢Û}úe¬SÞw›¢ °Sù¿Æ«%”KMã-ÃûôÐ"RP(·óòWBÜ}]9Ö™Yø8’Ö³†¹w¥zaþ·jaägÃV ”:‹6	›ip½¾ev ëÄ&›ègn	+ò2qQH¾Î¢åER»x”÷ÀtŒ]ð°uÆÛ©¹ÙâßreLK(wàöm‘CQÏÉ•'U«âÖ'樜¦±=@JÐìôðˆ#Åm
Xo¿CÃ]-øHîY ú(ðôÍ?¥. qÖ¼‡Di}nùVyu¤á²¹º èÈÏçUÀúá²Dï°~ $s%rÑù¸ä®@b;zO]¤Î3AâOmm!ò3VåVÁ%—×ë(„ë–Ów;I®-G 8­–ÑÎúŠÛÍÞN†ÀhU¡]i²‰<$qE}A'JnW®b쪉"ïÝû¢¶äïáò½f3€ˆ´7>,¸¿‘Þ¬dôÔNjÿ5jVg¹Û@Ê;*xh›2kÙůõ¼id&äô_€û¯ÑUí¨ J›øW—«
þ®{¦,Ji•¿)ÄǪÒÕØvÇ6ÑUÚ“Çš¨ËK%vð
	ˆ¨÷t:üHå­ŽcYçË—èi×&>rä´†ª["93œuzK‘éG-wùnšç@Äø’ð_òlÃ%B‹ùÉ‘s¯|ÿ…-C°iu+-,„W¦ïÐ@zÇåb¸èjˆØå˜ÍÈÅU‰U¶YÐÔ¾ûX1‚¸EL9ÉM¬ÅâÀLy¡€É;Ñ-±éø"m^š‰8{ØyÎrvÆxŸ¹åyN”ä¡éÔ\lo}ä›çÙ;ù¡obwQ4‹ÆèY+ÞXÞ<ÏXÿF"|W¨Yuç&Sgwc·æë_
ýãi9è35 ¨‡¹1öC!ÛCZØ–õ«¢?hdþ}¾/ÉK°íõáÚN¡sÛ	äœîOg
Ÿ©Öµµö–8s‘ÂIëÌ—+_•?8ö³‘ 7xÑßBÑÁÞ">W߯Š_åõw‹Êç£[R/=OçB
ÝôR	E]áB´®.4³£o£Í?nz(´÷wÁKÐÈÒgàø¨®g;É­³VÈl•ÁH[=Š¾Jô6ÙRMèÛqÅ!ù	EJjت×|Lᜥ›uˆ<ä@’Ôñ¾rdÁ6‡û«x)¯Qü9—ë%0+L¡;<þ(ºüˆwXCž¸¤ä=sÂòF|˜bt!Û®¶£.²Pª«9êB4–—©ßßþÓóÒ€y 7›œPñ­ÜÇ,­=87MÆsÐgmꨛQøòÄ¢áR :#שs…DºÙχp›:ÜRèR²åNû/¦M¾á׫
OíbŒ{ì¹Î!@fÔƒ¡æuãÌò)/„äwdûõÓq=v é/}fLô3.ñ¸óŽ
i”Ls¨&`@<
ˆqÌ!-¥7ïÉÚŠ´1»BALùÖl‹È¸â|í—RÄaÃbªØÚ‡Þê3¸ah𔽚ÌjÕÁ-è6zÆž)ô
?IóϦ¥w£#¾¤‚[¢Ì/r5D¾¸¨N2LÉ­3ž¼ºþ¬v2!L.2Í>´‘þp6Ù\»…—BýÌFøÝ8æÒ‡iÑþñµ>®«¹Ãoî¾@ªÂ@Ùwø,=×áq˜/çÕ	cQrݨ¯FZ*ÖÎÜ*þÝFÎ$'­Ò#·»Ä+Ì·Êë±GÜK	ÊÜÅŽQæ1€VÃŽ¨X/4B‹å¿þüÿycgý6ÕfvPá¹ba°g
ÒÀáÐ;sÛ?.Ÿ£â²aâÜc*¼&”›Õpa–%ã¹u!,`j¸¢;Ò‰s}ñ`ß×ÊÆ+ßi7‡¸$í“fënIoÛ“u‚t^6šnÅ1·6ÅB(ÈŽy®$ÞdAÁšˆÕ™,CÙ瀢.=ök=yI‚C©çyJæý"špÖàïÏÊפ½ldã³ÜN¥n¨¡žEtÈTŽüWÆtÌÔøBncÙWÌ[µ5éþlaQÄÛº•µNñ¡PçùÜqc+Ÿ/Þ"‰½^Î̯…p?Óm-è}o”i^á,ŽdH9¡•à4X<´”öH'½W&|.Ú‹u €;¶Û-HÏm~ä$™P	
%-5	>
H
R]iu
‚Ÿ®¾Ïàò-C	Y	p	ˆ
 
¹
Ó
î	%
dè' †@B€–˜áõÊš;minkernel\crts\ucrt\inc\corecrt_internal_strtox.h__crt_strtox::floating_point_value::as_double_is_double__crt_strtox::floating_point_value::as_float!_is_doubleINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanSNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)Visual C++ CRT: Not enough memory to complete call to strerror.Visual C++ CRT: Not enough memory to complete call to strerror..exe.cmd.bat.com./\?*ÀÀ–ÀÀŽÀÀÀ‘À’À“À´ÀµÀÀ	Runtime Error!

Program: <program name unknown>...

Microsoft Visual C++ Runtime Libraryð(@\)@\/ )@/mscoree.dllCorExitProcessà)@àv@ð)@(„@àv@*@(„@\â@ *@(„@Œé@8*@(„@lï@P*@(„@`ø@LC_ALLLC_COLLATELC_CTYPELC_MONETARYLC_NUMERICLC_TIME	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=;;=C_.,_.™@`™@Ðþ@d@X™@\™@Ø@<@`@|@´™@@'@|'@ø@4@ÔË@üË@4×@Lš@¼™@D™@H™@™@@™@\\\.\.TMPTMPmsvcrt.dllccsUTF-8UTF-16LEUNICODEccsUTF-8UTF-16LEUNICODE@-@-@¸@Ð-@.@`.@À.@/@ø@P/@/@Ð/@0@`0@À0@ 1@p1@ @8@À1@api-ms-win-appmodel-runtime-l1-1-1api-ms-win-core-datetime-l1-1-1api-ms-win-core-file-l2-1-1api-ms-win-core-localization-l1-2-1api-ms-win-core-localization-obsolete-l1-2-0api-ms-win-core-processthreads-l1-1-2api-ms-win-core-string-l1-1-0api-ms-win-core-sysinfo-l1-2-1api-ms-win-core-winrt-l1-1-0api-ms-win-core-xstate-l2-1-0api-ms-win-rtcore-ntuser-window-l1-1-0api-ms-win-security-systemfunctions-l1-1-0ext-ms-win-kernel32-package-current-l1-1-0ext-ms-win-ntuser-dialogbox-l1-1-0ext-ms-win-ntuser-windowstation-l1-1-0user32AreFileApisANSICompareStringExEnumSystemLocalesExGetActiveWindowGetCurrentPackageIdGetDateFormatExGetEnabledXStateFeaturesGetFileInformationByHandleExGetLastActivePopupGetLocaleInfoExGetProcessWindowStation	GetSystemTimePreciseAsFileTimeGetTimeFormatExGetUserDefaultLocaleNameGetUserObjectInformationWGetXStateFeaturesMaskIsValidLocaleNameLCMapStringExLCIDToLocaleNameLocaleNameToLCIDLocateXStateFeatureMessageBoxAMessageBoxW
RoInitialize
RoUninitializeSetThreadStackGuarantee
SystemFunction036am/pma/p -
:	+% 8@$8@(8@,8@08@48@88@<8@D8@P8@X8@h8@t8@€8@Œ8@8@”8@˜8@œ8@ 8@¤8@¨8@¬8@°8@´8@¸8@À8@È8@Ô8@Ü8@œ8@ä8@ì8@ô8@9@9@9@(9@49@89@@9@P9@h9@x9@€9@ˆ9@9@˜9@ 9@¨9@°9@À9@Ð9@à9@ø9@:@ :@8:@@:@H:@P:@X:@`:@h:@p:@x:@€:@ˆ:@:@˜:@¨:@À:@Ð:@X:@à:@ð:@;@;@(;@8;@P;@d;@l;@x;@;@¸;@Ð;@SunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssSunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssen-USINFinfNANnanNAN(SNAN)nan(snan)NAN(IND)nan(ind)e+000         (((((                  H„„„„„„„„„„‚‚‚‚‚‚ €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ         (((((                  H„„„„„„„„„„‚‚‚‚‚‚      (                          0SunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecTZðE@F@F@8F@HF@hF@€F@ F@¸F@ÐF@èF@G@(G@@G@XG@hG@xG@ˆG@˜G@¨G@¸G@ÈG@ØG@ðG@H@(H@hG@PH@`H@xH@ˆH@ H@°H@ÀH@ÐH@hG@èH@hG@I@ I@8I@XI@pI@hG@No errorOperation not permittedNo such file or directoryNo such processInterrupted function callInput/output errorNo such device or addressArg list too longExec format errorBad file descriptorNo child processesResource temporarily unavailableNot enough spacePermission deniedBad addressUnknown errorResource deviceFile existsImproper linkNo such deviceNot a directoryIs a directoryInvalid argumentToo many open files in systemToo many open filesInappropriate I/O control operationFile too largeNo space left on deviceInvalid seekRead-only file systemToo many linksBroken pipeDomain errorResult too largeResource deadlock avoidedFilename too longNo locks availableFunction not implementedDirectory not emptyIllegal byte sequence+°I@ÀI@ÐI@àI@ja-JPzh-CNko-KRzh-TWˆO@ENU O@ENUÈO@ENUðO@ENAP@NLBP@ENC0P@ZHH8P@ZHI@P@CHSPP@ZHHxP@CHS P@ZHIÈP@CHTðP@NLBQ@ENU8Q@ENAPQ@ENLpQ@ENCˆQ@ENB°Q@ENIÈQ@ENJèQ@ENZR@ENS0R@ENThR@ENG€R@ENU˜R@ENU°R@FRBÐR@FRCðR@FRLS@FRS8S@DEAXS@DEC€S@DEL¨S@DESÈS@ENIèS@ITST@NOR T@NORHT@NONpT@PTB T@ESSÈT@ESBèT@ESLU@ESO0U@ESCXU@ESDU@ESF°U@ESEØU@ESGV@ESH(V@ESMHV@ESNhV@ESIV@ESA°V@ESZØV@ESRøV@ESU W@ESY@W@ESVhW@SVFˆW@DES”W@ENGœW@ENU¨W@ENUA°W@USAÀW@GBRÐW@CHNàW@CZEðW@GBRX@GBR X@NLD0X@HKGHX@NZL`X@NZLhX@CHN€X@CHN˜X@PRI°X@SVKÀX@ZAFàX@KORøX@ZAFY@KOR0Y@TTO”W@GBRXY@GBRxY@USAœW@USAamericanamerican englishamerican-englishaustralianbelgiancanadianchhchichinesechinese-hongkongchinese-simplifiedchinese-singaporechinese-traditionaldutch-belgianenglish-americanenglish-ausenglish-belizeenglish-canenglish-caribbeanenglish-ireenglish-jamaicaenglish-nzenglish-south africaenglish-trinidad y tobagoenglish-ukenglish-usenglish-usafrench-belgianfrench-canadianfrench-luxembourgfrench-swissgerman-austriangerman-lichtensteingerman-luxembourggerman-swissirish-englishitalian-swissnorwegiannorwegian-bokmalnorwegian-nynorskportuguese-brazilianspanish-argentinaspanish-boliviaspanish-chilespanish-colombiaspanish-costa ricaspanish-dominican republicspanish-ecuadorspanish-el salvadorspanish-guatemalaspanish-hondurasspanish-mexicanspanish-modernspanish-nicaraguaspanish-panamaspanish-paraguayspanish-peruspanish-puerto ricospanish-uruguayspanish-venezuelaswedish-finlandswissukususaamericabritainchinaczechenglandgreat britainhollandhong-kongnew-zealandnzpr chinapr-chinapuerto-ricoslovaksouth africasouth koreasouth-africasouth-koreatrinidad & tobagounited-kingdomunited-statesACPOCP6-h@h@h@h@(h@0h@8h@@h@	Hh@
Ph@Xh@`h@
hh@ph@xh@€h@ˆh@h@˜h@ h@¨h@°h@¸h@Àh@Èh@Ðh@Øh@àh@èh@ðh@ øh@!i@"”W@#i@$i@%i@& i@'(i@)0i@*8i@+@i@,Hi@-Pi@/Xi@6`i@7hi@8pi@9xi@>€i@?ˆi@@i@A˜i@C i@D¨i@F°i@G¸i@IÀi@JÈi@KÐi@NØi@Oài@Pèi@Vði@Wøi@Zj@ej@j@j@(j@8j@àI@Hj@Xj@hj@xj@	Ð;@ˆj@˜j@
¨j@¸j@Èj@Øj@°I@ÐI@èj@øj@k@k@(k@8k@Hk@Xk@hk@xk@ˆk@˜k@ ¨k@!¸k@"Èk@#Øk@$èk@%øk@&l@'l@)(l@*8l@+Hl@,Xl@-pl@/€l@2l@4 l@5°l@6Àl@7Ðl@8àl@9ðl@:m@;m@> m@?0m@@@m@APm@C`m@Dxm@Eˆm@F˜m@G¨m@I¸m@JÈm@KØm@Lèm@Nøm@On@Pn@R(n@V8n@WHn@ZXn@ehn@kxn@lˆn@˜n@¨n@ÀI@¸n@	Èn@
Øn@èn@øn@o@o@(o@8o@Po@,`o@;xo@>ˆo@C˜o@k°o@Ào@Ðo@ào@	ðo@
p@p@ p@;8p@kHp@Xp@hp@xp@	ˆp@
˜p@¨p@¸p@;Èp@Øp@èp@øp@	q@
q@(q@8q@;Pq@`q@	pq@
€q@q@ q@;¸q@Èq@	Øq@
èq@øq@;r@  r@	 0r@
 @r@; Pr@$`r@	$pr@
$€r@;$r@( r@	(°r@
(Àr@,Ðr@	,àr@
,ðr@0s@	0s@
0 s@40s@	4@s@
4Ps@8`s@
8ps@<€s@
<s@@ s@
@°s@
DÀs@
HÐs@
Làs@
Pðs@|t@|t@arbgcazh-CHScsdadeelenesfifrhehuisitjakonlnoplptroruhrsksqsvthtruridbesletlvltfavihyazeumkafkafohimskkkyswuzttpagutateknmrsamnglkoksyrdivar-SAbg-BGca-EScs-CZda-DKde-DEel-GRfi-FIfr-FRhe-ILhu-HUis-ISit-ITnl-NLnb-NOpl-PLpt-BRro-ROru-RUhr-HRsk-SKsq-ALsv-SEth-THtr-TRur-PKid-IDuk-UAbe-BYsl-SIet-EElv-LVlt-LTfa-IRvi-VNhy-AMaz-AZ-Latneu-ESmk-MKtn-ZAxh-ZAzu-ZAaf-ZAka-GEfo-FOhi-INmt-MTse-NOms-MYkk-KZky-KGsw-KEuz-UZ-Latntt-RUbn-INpa-INgu-INta-INte-INkn-INml-INmr-INsa-INmn-MNcy-GBgl-ESkok-INsyr-SYdiv-MVquz-BOns-ZAmi-NZar-IQde-CHen-GBes-MXfr-BEit-CHnl-BEnn-NOpt-PTsr-SP-Latnsv-FIaz-AZ-Cyrlse-SEms-BNuz-UZ-Cyrlquz-ECar-EGzh-HKde-ATen-AUes-ESfr-CAsr-SP-Cyrlse-FIquz-PEar-LYzh-SGde-LUen-CAes-GTfr-CHhr-BAsmj-NOar-DZzh-MOde-LIen-NZes-CRfr-LUbs-BA-Latnsmj-SEar-MAen-IEes-PAfr-MCsr-BA-Latnsma-NOar-TNen-ZAes-DOsr-BA-Cyrlsma-SEar-OMen-JMes-VEsms-FIar-YEen-CBes-COsmn-FIar-SYen-BZes-PEar-JOen-TTes-ARar-LBen-ZWes-ECar-KWen-PHes-CLar-AEes-UYar-BHes-PYar-QAes-BOes-SVes-HNes-NIes-PRzh-CHTsrj@B`i@,`‚@qh@p‚@Ø€‚@Ú‚@± ‚@ °‚@À‚@ÏЂ@Õà‚@Òð‚@©ƒ@¹ƒ@Ä ƒ@Ü0ƒ@C@ƒ@ÌPƒ@¿`ƒ@ÈHi@)pƒ@›ˆƒ@ki@! ƒ@ch@°ƒ@DÀƒ@}Ѓ@·h@èƒ@E(h@øƒ@G„@‡0h@„@H8h@(„@¢8„@‘H„@IX„@³h„@«j@Ax„@‹@h@ˆ„@JHh@˜„@£¨„@͸„@¬È„@ÉØ„@’è„@ºø„@Å…@´…@Ö(…@Ð8…@KH…@ÀX…@ÓPh@	h…@Ñx…@݈…@ט…@ʨ…@µ¸…@ÁÈ…@ÔØ…@¤è…@­ø…@߆@“†@à(†@»8†@ÎH†@áX†@Ûh†@Þx†@Ùˆ†@Æi@#˜†@ePi@*¨†@l0i@&¸†@hXh@
Ȇ@Lpi@.؆@s`h@è†@”ø†@¥‡@®‡@M(‡@¶8‡@¼ði@>H‡@ˆ¸i@7X‡@hh@h‡@Nxi@/x‡@tÈh@ˆ‡@¯˜‡@Zph@
¨‡@O@i@(¸‡@ji@ȇ@axh@؇@P€h@è‡@•ø‡@Qˆh@ˆ@Rhi@-ˆ@rˆi@1(ˆ@xÐi@:8ˆ@‚h@øi@?Hˆ@‰Xˆ@Si@2hˆ@y(i@%xˆ@g i@$ˆˆ@f˜ˆ@ŽXi@+¨ˆ@m¸ˆ@ƒèi@=Ȉ@†Øi@;؈@„€i@0èˆ@øˆ@w‰@u‰@U˜h@(‰@–8‰@TH‰@— h@X‰@°i@6h‰@~¨h@x‰@V°h@ˆ‰@W˜‰@˜¨‰@Œ¸‰@ŸÈ‰@¨¸h@؉@XÀh@è‰@Yài@<ø‰@…Š@§Š@v(Š@œÐh@8Š@[i@"HŠ@dXŠ@¾hŠ@ÃxŠ@°ˆŠ@¸˜Š@˨Š@ÇØh@¸Š@\t@ãÈŠ@ÂàŠ@½øŠ@¦‹@™àh@(‹@š8‹@]˜i@3H‹@zj@@X‹@ŠÀi@8h‹@€Èi@9x‹@èh@ˆ‹@^˜‹@nðh@¨‹@_¨i@5¸‹@|”W@ È‹@bøh@Ø‹@` i@4è‹@žŒ@{8i@'Œ@i(Œ@o8Œ@HŒ@âXŒ@hŒ@¡xŒ@²ˆŒ@ª˜Œ@F¨Œ@paf-zaar-aear-bhar-dzar-egar-iqar-joar-kwar-lbar-lyar-maar-omar-qaar-saar-syar-tnar-yeaz-az-cyrlaz-az-latnbe-bybg-bgbn-inbs-ba-latnca-escs-czcy-gbda-dkde-atde-chde-dede-lide-ludiv-mvel-gren-auen-bzen-caen-cben-gben-ieen-jmen-nzen-phen-tten-usen-zaen-zwes-ares-boes-cles-coes-cres-does-eces-eses-gtes-hnes-mxes-nies-paes-pees-pres-pyes-sves-uyes-veet-eeeu-esfa-irfi-fifo-fofr-befr-cafr-chfr-frfr-lufr-mcgl-esgu-inhe-ilhi-inhr-bahr-hrhu-huhy-amid-idis-isit-chit-itja-jpka-gekk-kzkn-inkok-inko-krky-kglt-ltlv-lvmi-nzmk-mkml-inmn-mnmr-inms-bnms-mymt-mtnb-nonl-benl-nlnn-nons-zapa-inpl-plpt-brpt-ptquz-boquz-ecquz-pero-roru-rusa-inse-fise-nose-sesk-sksl-sisma-nosma-sesmj-nosmj-sesmn-fisms-fisq-alsr-ba-cyrlsr-ba-latnsr-sp-cyrlsr-sp-latnsv-fisv-sesw-kesyr-syta-inte-inth-thtn-zatr-trtt-ruuk-uaur-pkuz-uz-cyrluz-uz-latnvi-vnxh-zazh-chszh-chtzh-cnzh-hkzh-mozh-sgzh-twzu-za01#INF1#QNAN1#SNAN1#INDÿÿÿÿ:Yw–´Óò/Mlÿÿÿÿ;Zx—µÔó0Nmð?ðÿðøÿÿÿÿÿÿÿÿðå&{ËÛ?xËÛ?5•q(7©¨>PDÓ?%>bÞ?ï>@ð?à?`?à?UUUUUUÕ?Ð?š™™™™™É?UUUUUUÅ?øÀý°?î?ñ?ÿÿÿÿÿÿÿæTUUUUµ?Ôƺ™™™‰?ŸQñ#Ib?ðÿ]È4€´? ë´?0wGµ?`!£µ?@€þµ?@”Y¶?ð]´¶?°Ý·?i·?`÷?0¦¸?v¸?0ϸ?@æ'¹?m€¹? ®Ø¹?Щ0º? _ˆº?pÐߺ?°ü6»?Ðä»?0‰ä»?@ê:¼?p‘¼?äæ¼? }<½?€Õ‘½?ìæ½? Á;¾?°V¾? «ä¾?ÀÀ8¿?€–Œ¿?0-à¿? ÂÀ?pOCÀ?`½lÀ?€–À?=¿À?OèÀ?ðBÁ? :Á?€ÐbÁ?j‹Á?ç³Á?0FÜÁ?ˆÂ?à¬,Â?дTÂ?ðŸ|Â?€n¤Â?° ÌÂ?¶óÂ?P0Ã? ŽBÃ? ÐiÃ?€öÃ?`¸Ã?àðÞÃ?0ÅÄ?p~,Ä?ÐSÄ?p yÄ?p	 Ä?XÆÄ?0ŒìÄ?@¦Å?0¦8Å?PŒ^Å?X„Å?@ªÅ?p¤ÏÅ?@$õÅ?ЊÆ?PØ?Æ?ÐeÆ?€(ŠÆ?€+¯Æ?àÔÆ?ÐçøÆ?p¡Ç?àBBÇ?@ÌfÇ? =‹Ç?0—¯Ç?ÙÓÇ?PøÇ? È?@È?ÀõcÈ?à‡È?y«È?0ÏÈ?  òÈ?pÉ?°m9É?€²\É?áÉ?Pù¢É?pûÅÉ?°çèÉ?ð½Ê?€~.Ê?`)QÊ? ¾sÊ?p>–Ê?ð¨¸Ê? þÚÊ?0>ýÊ?0iË?@AË?p€cË?ðl…Ë?°D§Ë?ðÉË?À¶êË?0QÌ?P×-Ì?PIOÌ?@§pÌ?0ñ‘Ì?@'³Ì?€IÔÌ?XõÌ?SÍ?`:7Í?`XÍ?ÏxÍ?p|™Í? ºÍ?ÐÚÍ?ðûÍ?0sÎ? Á;Î?Pý[Î?`&|Î?à<œÎ?à@¼Î?€2ÜÎ?ÐüÎ?àÞÏ?Й;Ï? B[Ï?€ÙzÏ?p^šÏ?ѹÏ?ð2ÙÏ? ‚øÏ?PàÐ? vÐ?0+Ð?‰:Ð?@JÐ?àxYÐ?ðãhÐ?pFxÐ?€ ‡Ð?ò–Ð?0;¦Ð?ð{µÐ?P´ÄÐ?`äÓÐ?0ãÐ?À+òÐ?CÑ?@RÑ?@YÑ?0X.Ñ?O=Ñ?Ð=LÑ? $[Ñ?pjÑ?PÚxÑ?@©‡Ñ?`p–Ñ? /¥Ñ?ç³Ñ?À–ÂÑ?°>ÑÑ?ðÞßÑ?pwîÑ?`ýÑ? ‘Ò?PÒ?p(Ò?7Ò?0kEÒ?ÐÎSÒ?+bÒ?ÐpÒ?@Í~Ò?`Ò? R›Ò? ‰©Ò?๷Ò?àâÅÒ?°ÔÒ?PâÒ?À2ðÒ? ?þÒ?pDÓ?°BÓ?à9(Ó?*6Ó?PDÓ? ²"¼
²=Ô
.3i±=WÒ~è
•Î=imb;DóÓ=W>6¥êZô=¿á­y+¦>ÄÓîÀ—>IÔ­wJ­=07ð?v>ÃöG×bá=¼MÌ>¿åöQàóê=ëóz	>ÇÀp‰£À=QÇW.>nÍî[>¯µp)†ß=m£6³¹W>OêJÈK>­¼¡žÚC>*ê÷´§f>ïü÷8à²ö=ˆðpÆTéó=³Ê:		r>§]'çp>ç¹qwžß>`
§¿'>¼MÌ>[^jö7>Kb|ñj>:b€Î²>	>Þ”éÑ0>1 k>Aòºœ‡>+¼¦^ÿ=lgÆÍ=¶)>,«Ä¼,+>DeÝ}Ðù=ž7W`@>`z”‹Ñ>~©|'e­>©_ŸÅMˆ>‚Ð`Ä>ø1<.	/>:á+ãÅ>šOsý§»&>ƒ„àµôý=•MÇ›/#>yHèsù=nXƼÌ>˜JRùé!>¸11Y@/>58d%‹Ï>€í‹¨_>äÙ)ùMJ$>”"Ø ˜>	ã“H*>þe¦«VM>cQ6!>6'Yþxø=ÊÈ%ˆR>jtm}S•à=`
§¿'><“E쨰>©ÛõøZ>ÕU&úâ>¿ä®¿ìY
>£?hÚ/‹>77:ýݸ$>®a~‚>ŸéI{Œ,>Y—ðê)>6{1n¦ª>Ur	Vr.>T¬zü3&>R¢aÏ+f)>0'ÄÈC>6ËZ»d >¤'„4
>ÖyµUŽ>š^œ!-é=jý
æc?>cQÙ›.>5b#)>^x8ˆo2>¯¦«Lj[;>vŽÜj"ð=í:1×J<>s|èd>fŠñì3>fvwõž’=>¸ ð;H9>&XªîÝ;>º7YÝÄ9>ÇÊëàéó>¬
'‚SÎ5>º¹*StO9>T†ˆ•'4>ðKãZ>‚Ð`Ä'>øŒí´%%> Òò΋Ñ.>Tu
.(!>ʧY3óp
>%@¨~+>‰!Ãn03>Pu‹øÇ?>d׌5°>>t”…"Èv:>ã†ÞRÆ=>¯X†à̤/>ž
ÀÒ¢„;>Ñ[Âò°¥ >™ö["`Ö=>7ð›…±>á˵#ˆ>>ö–ó6>š¢\‡.>¥¹9Ir•,>âX>z•8>4Ÿê&ñ/>	VŽYõS9>HÄVøoÁ6>ôaò"Ë$>¢S=Õ á5>Vò‰aR:>œÔÿüV8>Ú×(‚.0>àßD”Ðñ=¦Yêc%>×2x.&>ÏøÙ>í=…ÍK~Je#>!­€Ix[>dn±Ô-/!>õ9Ù­Ä7>ü€qb„(>aIáÇbQê=cQ61>ˆv¡+M<7>=éà¥è*>¯!ðÆ°*>f[Ýt‹0>”T»ìo ->ÌOr‹´ð=)âaƒ?>¯¼Ä—ø=ª·Ël(>>“
"Ic(>\,¢Áÿ=F	çET5>…mø0æ;>9lÙðß™%>°±…Ì6>ȨmG4>Óžˆ?7>‡*y
W3>öa®yÑ;>âöÃV£>ûœbp(=>?gÒ€8º:>¦})Ë36,>êï™8„!>æ ÉÌ;>PÓ½D8>áj`&‘+>ß+¶&ßz*>Én‚ÈOv>ðhå=O>ã•yuÊ`÷=GQ€Ó~fü=oßjö37>kƒ>ó·/>dºnˆ9>Œ¯ÐhSû=q)iŒ5>ûm"e”þ=—?~X3>Ÿç6>T¬zü36>J`„¦?>!T”ä¿4<>0Að±8>cÖ„BC?>6t9^	c:>Þ¹V†B4>¦Ù²’Ê6>“*:‚8'>0’ˆ<>þRmÜ=1>é"‰Õî3>PÝk„’Y)>‹'._MÛ
>Ä5*ñ¥ñ=4<,ˆðBF>^Gö§›î*>ä`JƒK&>.yCâB
)>O 'L>[ÏÖ.xJ>HfÚy\PD>!ÍMêÔ©L>¼Õ|b=})>ª¼ù\± >ÝvÏc [1>H'ªóæƒ)>”éÿôdL?>Zè|º¾F>¸¦Nýiœ;>«¤_ƒ¥j+>ÑíyÃÌC>àO@ÄLÀ)>ØuzKs@>àÄD>”HÎÂeÅ@>Í5ÙAÇ3>N;kU’¤r=CÜA	ú >ôÙã	p.>EŠ‹öK>V©úßRî>>½eä	kE>fvwõž’M>`â7†¢nH>ð¢ñ¯eF>tìH¯ý/>ÇѤ†¾L>ev¨þ[°%>J
ÂÎA>Ÿ›@
_ÍA>pP&ÈV6E>`"(5Ø~7>Ò¹@0¼$>òïy{ïŽ@>éWÜ9oÇM>Wô§“L>¦¥ÎÖƒJ>ºWÅ
pÖ0>
½èlÉD>#ã“,=>B‚_!Ç">}tÚM>š'>+§AiŸøü=1ñ§I!>Ûu|K­N>
çcþ0iN>/îÙ¾áA>’ñ‚+h->|¤Ûˆñ:>örÁ-4ù@>%>bÞ?ï>@ àààÿ?ðüÀÿ?úª¡ÿ? øøÿ?µÛ ¬cÿ?qBJžeDÿ?µ
#Dö%ÿ?|ðÁÿ?ŽEøÇéþ?Àì³Ìþ?ëºz€®þ?g·ð«1‘þ?äP—¥tþ?tåÉ:Wþ?sÜy‘:þ?þ?ààþ?Š†øãÖåý?Ê ÜÊý?Û¹v`®ý?Š#ò’ý?4,¸T¶wý?²ru€¬\ý?ÔAÔAý?[ü£,'ý?tÀnµý?Æ¿D\nòü?›‰VØü?çË–m¾ü?‘á^³¤ü?BŠûZ&‹ü?ÇqÇqü?†I
Ñ”Xü?ðøÃ?ü? .9µ&ü?àÀü?‹†îƒõû?÷”‰+Ýû?{>ˆeýÄû?кÁù¬û?#ÿ+•û?‹3Ú=l}û?î¾ãâeû?Oè´Nû?ÎØJH7û?Ù€l@6 û?¤"Ù1K	û?(¯¡¼†òú?^”èÛú?pÅpÅú?ýë‡/¯ú?¾cj`ï˜ú?Yá0Qæ‚ú?mЦmú?JŠhAWú?¤A¤Aú? Ň*,ú?KzùÓú?  ú?Ù3•Žìù?-hkŸ×ù?¡äNÑÂù?ÚUê$®ù?š™™™™™ù?ÿÀŽ
/…ù?r¸øäpù?®wã»\ù?àéÖü°Hù?æ,›Æ4ù?)âÐIû ù?ÕO
ù?úœÁùø??7ñzRæø?Ó0Óø?:ÿb€Î¿ø?ªók¹¬ø?œ‰öÀ™ø?J°«ðå†ø?¹’À¼'tø?†a†aø?xÂOø?ݾ²z—<ø? ¤‚J*ø?ø?`€ø?@ýô÷?OZQ%â÷?ô}A_Ð÷?|.’³¾÷?Ãìà"­÷?‹9¶kª›÷?ȤxLŠ÷?
Æšy÷?±©4äÜg÷?muÂÊV÷?F]tÑE÷?þAÅð4÷?¼ÞF($÷?	|œmx÷?p\à÷?`ò`òö?Ç7Ck÷áö?aÈ&¦Ñö?lÁlÁö?=£
I±ö?rSÑ<¡ö?ÀЈ:G‘ö?hhö?g6Ÿqö?ù"Qjìaö?£J;…ORö?d!YÈBö?ÞÀŠ¸V3ö?@bwú#ö?”®1h³ö?X`ö?ü-)4döõ?çи[çõ?¥âìÃgØõ?W“+ˆÉõ?‘úGƼºõ?ÀZk¬õ?ªÌ#ñaõ?íX0ÒŽõ?`XV€õ?:kP<íqõ?âR|º—cõ?UUUUUUõ?þ‚»æ%Gõ?ëôH	9õ?K¨Vÿ*õ?øâêõ?ÅÄá"õ?PPõ?›LÝbóô?9/§àåô?L,ܾCØô?n¯%‡¸Êô?á¦Ý>½ô?[¿R Ö¯ô?Jv­¢ô?gвã9•ô?€H"ˆô?{®Gázô?f`Y4Îmô?šÏõÇË`ô?ÊvÇâÙSô?ûÙbeøFô?Mî«0':ô?‡Õ%f-ô?QY^&µ ô?ô?feÑ‚ô?û°?ûó?¯¥Bîó?©ä¼,âó?Æuª‘ÙÕó?ç«{¤•Éó?U)#Ù`½ó?;±;±ó?"Èz8$¥ó?c,™ó?ŽfÓ"ó?88ó?îEÉÑ[uó?HÞóió?ø*Ÿ_Î]ó?Áx+ûRó?Fà¬yFó?²¼W[ä:ó?újí\/ó?¿+Jã#ó?¶ëéXwó?Ñ0
ó?`Ä*Èó?h/¡½„öò?KÑþ¡Nëò?—€KÀ%àò? P-
Õò? ,MûÉò?7ZŽù¾ò?@+­´ò?Áó’©ò?žä)Ažò?¥¸[r“ò?°ˆ°ˆò?MΡ8ú}ò?5'¸Psò?'Ö|³hò?ñ’€p"^ò?²w‘~Sò?’$I’$Iò?[`—·>ò?ß¼šxV4ò?* "*ò?xû!·ò?æUH€yò?ÙÀgGò?  ò?pÁ}÷ñ?L¸<ôìñ?t¸?;ïâñ?½J.gõØñ?¢­Ïñ?Yàü"Åñ?)íF@J»ñ?ãºòg|±ñ?–{a¹§ñ?žàžñ?œ¢Œ€S”ñ?Û+ƒ°Šñ?ñ?„ÖŠwñ?ysB‰nñ?2üPdñ?
'u_[ñ?ÉÕý£¹Qñ?;Í
_Hñ?$G4?ñ?È5È5ñ?¬À퉋,ñ?30]çX#ñ?&H§0ñ?ñ?€¾ûñ?ðþðþð?¢%³úíõð?œækõìð?`‚Uäð?–F¨ Ûð?:ž5VDÒð?;Ú¼OqÉð?qA‹†§Àð?È%ìæ·ð?µì.r/¯ð?§h
¦ð?`ƒ¯¦Ûð?T	9?•ð?âeu³«Œð?„B!„ð?âê¸)Ÿ{ð?Æ÷G
&sð?ûyœµjð?ü©ñÒMbð?†ur îYð?4×÷—Qð?ÅdÌIIð?AAð?üG‚·Æ8ð?^µ‘0ð?é)wüd(ð?@ ð?7zQ6$ð?ð?€ð?ð?logflog10floglog10à©@ä©@¨@¨@è©@ð©@!ø©@ª@
ª@ª@ª@ ª@(ª@,ª@ 0ª@4ª@<ª@Dª@Lª@Tª@\ª@dª@lª@tª@"|ª@#€ª@$„ª@%ˆª@&ª@exppowsinhcoshtanhasinacosatanatan2sqrtsincostanceilfloorfabsmodfldexp_cabs_hypotfmodfrexp_y0_y1_yn_logb_nextafter€€ðøÿÿÿÿÿÿÿï@ȼ@CreateDirectory (%s)CreateFile (%s)CreateFileMapping (%s)MapViewOfFile (%s)1.2.8inflateInit2 returns %dinflate returns %dinflateEnd returns %d\PURELIBPLATLIBHEADERSSCRIPTSScripts\DATALib\site-packages\Installation failed.import py_compile; py_compile.compile (r'%s')%s%cPy_InitializePy_SetProgramNamePy_FinalizePyRun_SimpleStringPySys_GetObjectPy_OptimizeFlagCSIDL_COMMON_STARTMENUCSIDL_STARTMENUCSIDL_APPDATACSIDL_COMMON_DESKTOPDIRECTORYCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_STARTUPCSIDL_STARTUPCSIDL_COMMON_PROGRAMSCSIDL_PROGRAMSCSIDL_FONTSsshell32.dllfunction not availableSHGetSpecialFolderPathAno such folder (%s)unknown CSIDL (%s)CoInitialize failed, error 0x%xsss|sssiCoCreateInstance failed, error 0x%xQueryInterface(IPersistFile) error 0x%xSetPath() failed, error 0x%xSetDescription() failed, error 0x%xSetArguments() error 0x%xSetIconLocation() error 0x%xSetWorkingDirectory() error 0x%xFailed to create shortcut '%s' - error 0x%xssiicreate_shortcutget_special_folder_pathget_root_hkeyfile_createddirectory_createdmessage_boxPYTHONHOME=%sSOFTWARE\Python\PythonCore\%d.%d%s\InstallPathPyImport_ImportModulePyObject_SetAttrStringPyObject_GetAttrStringPyCFunction_NewPy_BuildValuePyArg_ParseTuplePyErr_FormatPyLong_FromVoidPtrbuiltinsValueErrorOSErrorPySys_SetArgvCould not open postinstall-script %s
Running Script...*** Could not load Python ***PyErr_PrintCan't load Python for pre-install script (%d)Running the pre-installation script failed
Out of memory!Runtime Error100 Made Dir: %s
200 File Copy: %s
200 File Overwrite: %s
.pyErrorInvalid cfgdata magic number (see bdist_wininst.py)~duCould not create temporary fileTimes RomanSetupWindowClassSetup.exeCould not register window classSetup %sThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCorePython Version %s (found in registry)Software\Python\PythonCore\%s\InstallPathStrangeDon't know Python's installation typePython %s is required for this package. Select installation to use:Python version %s required, which was not found in the registry.No Python installation found in the registry.Cannot installPython Version %d.%dpython%d%d.dllHKEY_LOCAL_MACHINEHKEY_CURRENT_USERYou do not seem to have sufficient access rights
on this machine to install this softwareCould not open key%s\%s-wininst.logaCan't create "%s" (%s).

Try to execute the installer as administrator.*** Installation started %Y/%m/%d %H:%M ***
Source: %s
999 Root Key: %s
%s-py%d.%dCould not create key020 Reg DB Key: [%s]%s
Python %d.%d %sDisplayNameCould not set key value040 Reg DB Value: [%s\%s]%s=%s
%s\Remove%s.exewb"%s\Remove%s.exe" -u "%s\%s-wininst.log"UninstallString*** Installation finished %Y/%m/%d %H:%M ***
Click Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Ready to installRunning pre-installation scriptInstalling files...Failed to unzip installation filesCompiling files to .pyc...Loading python...Compiling files to .pyo...-installPlease wait while running postinstall script...\Scripts\300 Run Script: [%s]%s
*** run_installscript: internal error 0x%X ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.IsUserAnAdminrunasFailed to start elevated process (ShellExecute returned %d)Setuptitleinfobuild_infotarget_compiletarget_optimizetarget_versionnamemetadatainstall_scriptuser_access_controlforceautononeoopsBad user_access_control value%s.batw:Repeat
del "%s"
if exist "%s" goto Repeat
Could not delete keyCould not delete value-remove*** Could not run installation script ***uninstall-scriptWrong number of args-u2. arg is not -urcould not open logfileOut of memoryPlease confirmAre you sure you want to remove
this package from your computer?%d Root Key: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Made Dir: %s%d File Copy: %s%d File Overwrite: %s%d Reg DB Key: %s%d Reg DB Value: %s%d Run Script: %s%d files and %d directories removed
%d files or directories could not be removed%d files and %d directories removedUninstall Finished!Could not open archiveRemoveThis program is normally started by windowsSetup program invalid or damaged¢«@–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”Þñ`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

@@HN	

#+3;CScsģ̋	
!1AaÁ 0@` inflate 1.2.8 Copyright 1995-2013 Mark Adler  ë@0ë@¢«@@ë@Pë@`ë@pë@ˆë@˜ë@¢«@invalid distance too far backinvalid distance codeinvalid literal/length codeincorrect header checkunknown compression methodinvalid window sizeunknown header flags setheader crc mismatchinvalid block typeinvalid stored block lengthstoo many length or distance symbolsinvalid code lengths setinvalid bit length repeatinvalid code -- missing end-of-blockinvalid literal/lengths setinvalid distances setincorrect data checkincorrect length checkneed dictionarystream endfile errorstream errordata errorinsufficient memorybuffer errorincompatible version *PXZðä *PXpðpä *PX
ô„ð„䔀@¨Õ@°Õ@°Ðì¨ìèìøì°ÿÿÿÿ@ÐìÐHí í`íxíøìÐÿÿÿÿ@HíðÈí íàíøíøìðÿÿÿÿ@ÈíŽHî î`îxîøìŽÿÿÿÿ@Hî8ŽÈî îàîøîøì8Žÿÿÿÿ@Èî`ŽHï ï`ïxïøì`Žÿÿÿÿ@HÈï ïàïðÿÿÿÿ@ÈïRSDSßm©>0JH¸•¼È§°´™E:\CPython\cpython35\lib\distutils\command\wininst-14.0-amd64.pdbððçGCTLp´.text$mnpÄ .text$mn$00Ä.text$xШ.idata$5¨Õ.00cfg¸Õ.CRT$XCAÀÕ.CRT$XCAAÈÕ.CRT$XCZÐÕ.CRT$XIAØÕ.CRT$XIAAàÕ.CRT$XIACèÕ .CRT$XICÖ.CRT$XIZÖ.CRT$XPAÖ.CRT$XPX0Ö.CRT$XPXA8Ö.CRT$XPZ@Ö.CRT$XTAHÖ.CRT$XTZPÖX.rdata¨ìl.rdata$rðd.rdata$zzzdbgxó.rtc$IAA€ó.rtc$IZZˆó.rtc$TAAó.rtc$TZZ˜ó|p.xdatadŒ.idata$2 d.idata$3¸d¨.idata$4`jÊ.idata$6€°
.data°ð.data$r Ž=.bssдZ.pdata0	ô.gfids$xô0	€.gfids$y@	0.rsrc$010A	(.rsrc$02dT42p
dT4’ðàpd4òp7
&t;&d:&49&2ðàÐÀP@¼€d	4RpRp`0d	4Rpd
T	4Rpd	4RpRp`0bp
`P0d	4RpRp`0T42p20

4
2p'	T9482àp`@¼€d
T	4Rptd
T	42ðàÀBB
4,
*p@¼@&4ZXP@¼°‚&4ZXP@¼°
42ðàÐ
Àp`P*%4#Òð
àÐÀp`P@¼h
4rðàÐÀp`
Ptd
T	42ðàÀ2
 t# d" T! 4  ðàÀ@¼Ð
4
Œp@¼P+ˆp`0@¼0d4
rp

4
Rp.t1d0T/4.,à@¼P àp`P0@¼À9(ô(t(d(4(P@¼°
4

’p@¼@!0@¼0(	d342,àpP@¼P

4	
Rp204"Ä1"t0"T/"*ðàÐ@¼@7
&ÔÙ&ÄØ&t×&4Ö&ÒðàP@¼€+@¼@#p`P@¼0)	ô3ä2d1.P@¼` 4&$P@¼B@¼@¼°+T4
à@¼0&4dbP@¼dT
4RpdT
4Rp2020d4
’p@¼@=
,t,d,4,ðàÐÀP@¼PR0t4t
d4t
d4)	t*d)4(&P@¼ 	B
ðà	ÐÀp`P0dT42pd42p
t	dT42à	¢
ðà	ÐÀp`0P20d42pdT42pd42p
d
T	42ðàp*4 ðàÐ
Àp`P@¼¸BbB		b

4

rprp`020B2020BB	

4
Rp|¤7–L—ÄL—2PBBB20	"|¤7›Â›®Ä›PB202020

4

rPdT42pBBBBBB

4	
2PBB4º¸PBd42pd42pt42P""dT4rðàÐÀpBBBBB20dT4rðàÐÀp20202020›BBBd42p20B20B20202020
t	dT42à
t	dT42à

4
2p
td
T	4Rà

4
2p

4
2p

4
2pd42pdT42p		2020
t	dT42àtd
T	42ðàÀdT4
2ðàÐÀpdT4
2ðàÐÀp	t d4à|¤ô)Ž*ÆÄRP	t d4à|¤ì*Œ+ÜÄRPd
T	4Rpbp
`P0d42p

4
2p		2020d42p

4
2pd42pr0@¼8r0@¼8

4
2p

4
2ptd42àdT42p2020202020

4
2pd42pd42p202020		20d42p20

4
Rp

4
Rp

4
Rp

4
2pd42p

4
2p20d4’P20-td4ðàP@¼€td4²Pä+t*d)4(&P

4

rP

4

rptd4²P480ðàÐ
Àp`P1
#t!#d #4#ðàÐÀP@¼°-t#d"4!ðàP@¼Ð??x
4h4&ðàÐÀ
p	`PBr020

4
’P

4
Rp20

4
²Pt
4’P11x-h't'd'4'ðàÐÀPäd
4’P’04’p`Ptd
4’P
td
4rðàPt
4’P
td4ÒðàP#
#t#d#4#ðàÐÀPR0d
4’pt
4’Pd	4Rp20

4
’p’0’0202020td4²P202020t4²P20R020r0t4²Pd42p

4
2p

4
2pdT42pdT42pd42p
t	dT42à20

4
2p

4
2pd
4	Rp|¤010òÄ2P20td
4	Rà|¤ù01Å2P20B
t	dT42à20202042p|¤¦5°5HÅ2P

4
2p2020b‚b‚

4
2p|¤ë5ø5`Å2P

4
2p|¤+686yÅ2Pd42pd42ptd
T	42ðàÀ
td
T	4Ràtd
T	42ðàÀ2020
t
dT4
rà

4
Rp4
rp

R0

4
2pbbb
dT4’àÀp
dT4’àÀpdT4²ðàÐÀp		²P		²P		²P2!d«!4¨!¢ðàÀpP@¼

4
Rpt
dT4
RðÐÀ2!dÙ!4Ö!ÐðàÀpP@¼p		²P		²P		²P2!d«!4¨!¢ðàÀpP@¼R0
dT4
RðÀp2!dÙ!4Ö!ÐðàÀpP@¼p20B

4
2p20

4
2p²P²P²P²P²P²P,	4¨¢ð
àp`P@¼2!d«!4¨!¢ðàÀpP@¼R0

4
Rp
ät
d	4Rð
td4
RðàÀ,	4ÖÐð
àp`P@¼p2!dÙ!4Ö!ÐðàÀpP@¼pB20
d
T	42ðàp20202020T42p202020T
4	2à
p`B
d
T4Rðàp

4
2pd42pd42p

4

’p20d42pd4
’p@¼@20$d¢4¡žp@¼àBB20
dT
4	2ðàp20202020
ä	td42ð2020d	T42pB+dT4rðàÐÀp@¼8d42pd42pd42pt4
’à20d42pT4Ràp`20$d¢4¡žp@¼àBB2020T42p202020T
4	2à
p`B
d
T4Rðàp

4
2pd42pd42p

4

’p20d42pd4
’p@¼@20$d¢4¡žp@¼àBB2020
ä	td42ð2020d	T42pB+dT4rðàÐÀp@¼8d42pd42pd42pt4
’à20d42pT4Ràp`20$d¢4¡žp@¼àBB

4	
Rp

4	
RpR020d42àb2020
d
T	42ðàp202020T
4	2à
p`2020B
d
T4Rðàpd42pd42pd42pd4
’p
dT
4	2àÀp

4
2pd4
’p@¼@20$dÐ4ÏÌp@¼PBB

4	
Rp

4	
RpR020d42àb2020td
T	42àÐÀ2020d	T42p2020B+dT4rðàÐÀp@¼8d42pd42pd42ptd4
’ð
dT
4	2àÀp

4
2pT4Ràp`20$dÐ4ÏÌp@¼PBBtd
T	42ðàÀ202020T42p2020BT
4	2à
p`B
d
T4Rðàp

4
2pd42pd42p

4

’p20d42pd4
’p@¼@20BdT4
2ðàÐÀp202020
t	dT42àd	T42pB+dT4rðàÐÀp@¼8d42pd42pd42pt4
’à20d42pdT
4	Rp20,	4¨¢ð
àp`P@¼2!d«!4¨!¢ðàÀpP@¼B20B

4	
Rp

4	
RpR020d42àb2020
d
T	42ðàp2020BT
4	2à
p`2020B
d
T4Rðàpd42pd42pd42pd4
’p
dT
4	2àÀp

4
2pd4
’p@¼@20B20B

4	
Rp

4	
RpR020d42àb2020td
T	42àÐÀd	T42p2020B+dT4rðàÐÀp@¼8d42pd42pd42ptd4
’ð
dT
4	2àÀp

4
2pdT
4	Rp204444444444
t	dT42à"
"t	"d"T"4"2à4t
4dT42pR0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R044444444R0R0R0R0R0R0R0R0R0R044R0R0R0R0R0R0R0R0R0444444R0R0R0R0R0R0R0R0R0R044R0R0R0R0R0R0R0R0R04442p|¤ÊMÔMþÅ2P42p|¤ŠM”MãÅ2P42p|¤JMTMÈÅ2P42p|¤
MM­Å2P42p|¤ÊLÔL’Å2P42p|¤
NNÆ2P20dT42p2020BT
4	2à
p`B
d
T4Rðàp

4
2pd42pd42p

4

’p20d42pd4
’p@¼@2020
t	dT42àd	T42pB+dT4rðàÐÀp@¼8d42pd42pd42pt4
’à20d42pdT
4	Rp20444444
ˆàÀP@¼!(
(ôƒ Ô„t…d†4‡ Ç{Çä! Ç{ÇäT2ðàp!Ä

d	4 Æ7Æ0! Æ7Æ0BBBd
4Rðàp|¤ÍaÍ4Æ2Pd
4Rðàp|¤èÍ8ÎNÆ2P²PdT4
2ðàÐÀpd42pB42p|¤.Ï9ÏhÆ2PB2020B2020

4
2pR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
Rp

4
2p

4
2p

4
2pBR0

4
RpR0

4
RpR0

4
RpR0

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
RpBBtd4rðàÐÀPtd4rðàÐÀPBBdT4’ðàÐÀp
dT4ðàÐÀp20R0202020R0d42pd42prp0Prp0Pd42pd42pr0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r02020r0r0d42pb		²Pt"d!4 ðàP		²P-t(d'4&"ðàP@¼2020	TG>ðà
ÐÀ`!tFàsà !4DsŒø !sŒø !àsà ?4?!4@ ç^çP!!t>dA4@ ç^çP!!t>4@ ç^çP!!t>4@ ç^çP!Dp`0@¼ð!äA°ã“ä¸!!GGTJô@ÔBÄC“ävåÐ!!“ävåÐ!!°ã“ä¸!!
ô@äAÔBÄCTJ°ã“ä¸!04ˆ~ðàÐ
Àp`P@¼àYYôCQäDIÄFATG64HIp`!ÔEàØIÚl"!àØIÚl"bb
t	dT42àtd
T	42ðàÀ
4RðàÐÀp`
PdT
4RðàÐÀp@
/t‡/d…/4„/~!ðàÐÀP@¼à04xnðàÐ
Àp`P@¼`

4
Rp20

4
2p20

4
2p2020²P²P-t(d'4&"ðàP@¼t"d!4 ðàPB20B20d42p

4
2p2020

4
2p

4
2pd42pd42pd
T4rp

4
2p

4
2p20Bd42p2020d42pB20)	t"d!4 P@¼àBB20Bd42p

4
2p2020

4
2pd42pd	4RpBd
T4rp

4
2p

4
2pB

4
2p

4
2pd
T42ðàÐÀpd42pd42p
t	dT42à

4
2pd42p202020t4PBB20d42p

4
2p20

4
2p

4
2pd42pd42pd
T4rp

4
2p

4
2pB

4
2p

4
2p20

4
2pd42pd	4RpBd
T4rp

4
2p

4
2p20dT42p

4
2pdT42pd42pdT4
2ðàÐÀp
4RðàÐ
Àp`PB20Btd4’ðàÐÀP4rp4rp
4rðàÐ
Àp`P
4
2ðàÐ
Àp`PB

4
2pB
dT4ðàÐÀp4rp4rp
t	dT42à
T4
RðàÀp`Btd4rðàÐÀP4rp4rp
4RðàÐ
Àp`Pd
T42ðàÐÀpB
dT4ðàÐÀp4rp4rp42p|¤z
„
žÆ2P42p|¤:
D
Į2P
4m
hp@¼0B
4m
hp@¼0B
4m
hp@¼0B
4m
hp@¼0B
4m
hp@¼0B
4m
hp@¼0B
4m
hp@¼0B
4m
hp@¼0B	¢ðàÐÀp
`0Pbb	ÂðàÐÀp
`0P
4rðàÐ
Àp`P	ÂðàÐÀp
`0P

4
2pd
4ràÀpd
4ràÐpbbbb

4
2p  d T 4 rðàÐÀp  d T 4 rðàÐÀpr04
rpd
T4
rp
dT
4rðàp

4
2ptd
T	42ðàÀ

4
2p
d
T	42ðàp
d
T	42ðàp

4
2pdT4
2ðàÐÀp

4
2p
d
T	42ðàp
d
T	42ðàp

t444t
d444

4
Rpd
T	4Rpd
T	4Rp

4
Rp20b

4
Rp

4
Rpd
T	4Rpd
T	4RpB

Â0P

â0P

â0P

â0P20202020BB
t	dT42à20d42p20'	TN4MHàp`@¼0202020
d4ÒðàÀpP20
d4ÒðàÀpP20
d4òðàÀpP20
d4ÒðàÀpPÂ0
Pâ0
Pâ0
Pâ0
P2020$4òð
àp`P@¼xT4
rp$4òð
àp`P@¼xT4
rp$4òð
àp`P@¼xT4
rp$4òð
àp`P@¼xT4
rp’0B’0B²0B’0B	ÒP@¼h	ÒP@¼hd
4’p|¤:,½,
Ç2Pd
4’p|¤î)s*¹Æ2Pd4²p|¤n+þ+íÆ2Pd
4’p|¤®*3+ÓÆ2Pr0r0dT42p
dT4
RðàpB	J0@¼@

4
2p4Rð
àp`P4Rð
àp`P20B4Rð
àp`P4Rð
àp`Ptd
T	42ðàÀ2020	Ätd4ð2020BBB

4
2p

4
2pBd42pBd42p42p42p2020BB
dT4
Rðàp
dT4
RðàpT4
r`T	4R`

4
2pB

4
2p
t	dT42àd42pBBB

4
2p2020B20
ä	td42ð|¤Ûq9r$Çxr¿q~r?Ç2P2P42ðà
Àp
`|¤ªuÎuXÇ2PBBä
t4d	4Rp20Rp0P	*0@¼@2
0|¤@†k†÷dž†®†È2P2P²
Ptd
T	42ðàÀ-
I
ðà	ÐÀp`0P@¼0bp`P0d
T	4Rp
dT4
Rðàp04qfðàÐ
Àp`P@¼ dT
4RðàÐÀp)4K@ðàÐ
Àp`P@¼ðB2p|¤~~ÞÇ2P202020202020BB

4
’p20B42p|¤ÅxÔxÄÇ2P42p|¤w+woÇ2P

20|¤MwVw‰Ç2P42p|¤‰w”xªÇ2PBrPb2020td
T	42ðàÀBdT4
2ðàÐÀpB42p|¤-’7’)È2P
d4rðàÐÀp|¤v’Ê“CÈ2PBBBBB2020	20|¤X›e›e›20BBdT4
rpbb

4
2p
4RðàÐÀp
`PdT4
RðàÐÀpT4
Rà
p`20202020Ä
td4
RðàÐ|¤Тm£`ÈRP
d
T4
Rðàp2020Ä
td4
RðàÐ|¤Ì£i¤yÈRPb

4
2pb

4
2pBd4
rpbbdT
4’p##t#4#ðàÐÀPB’0|¤‘­¾­’ÈrPB’0|¤I®v®ÙÈrP

4
’p|¤;¯_¯ ÉrP

4
’p|¤°?°sÉrP‚BBBbT4
Ràp`d42p
d
T4Rðàpr0r0d	4Rp42ðàÐÀ
`|¤7ÇnÇÆÉ2P
4²ðàÐÀ
p`P4	bðàÐÀ
p`P
0
4RðàÐ
Àp`P	b
ðà	ÐÀp`P0b

4
2p

4
2pBB42p|¤-ÌmÌÝÉ2P

20

4
2p202020B20bR0bR0bR0bR0bbbbR0R0R0R0

4
Rp

4
Rp

4
Rp

4
RpbbB20B.	dÄ4þàpP@¼à

4

rp
td
T	4Rà20|¤LÚzÚ÷É2PdT42p2020dT
4’pdT
4’pt4²Pt4²P

4
Rpd
T	4Rp

4
2p

4
2p

4
2pd42pt2020
tdT
4’àd
T4rp
t
dT4
rà20
t	dT42à
t	dT42à

4
2p
td
T	4Ràd42pd42pdT42p

4
2p
tdT
4’à
t	dT42àd42pdT42p
t	dT42à
t	dT42à

4
2p20d42p

4
2p20BB

4
2p
4
’p@¼@

4
2p20
t	dT42à
d
T	42ðàptd
T	42ðàÀdT4
2ðàÐÀp20

4
2p20Bd42p|¤ælæÊ2P

4
Rp|¤ÂA*Ê2P42p|¤„ŽvÊ2P20d42pd4rðàp|¤â(CÊ¥6]Ê2P2P2020|¤
!ŽÊ2P

4
2ptdT4àtd42àB20202P2P2P2P2P2P2P2P2P2020
4RðàÐÀp`
PdT
4RðàÐÀpt
d	4RàdT42p
td
T	4Rà
t	dT42à

4
2pBB

4
2pd42p2020

20

4
2prPBB		’P

RPBBB		rP

4
2p2020d42p42p|¤ñÛÊ2P42p|¤©¿ÁÊ2P42p|¤Iy§Ê2P42p|¤1?õÊ2P2020Bbbtd4ÒðàÐÀPdT4’ðàÐÀpdT4’ðàÐÀpdT4’ðàÐÀptdT4d42pd42p204’
p`P'E4CÒð
àÐÀp`P@¼`BbBBBd4ÒPd4ÒP

4
2p

4
2pdÒ	àpPdÒ	àpP
tdT
4’à

4
Rp

4
’pbd4²pdT4²ðàÐÀpBP@¼°
tdT
4’ðdT
4’ptdT4ÒðàÀ
t
dT4
ràd4
rpdT
4’à42p|¤iiË2P20!T4
ràp`@¼0		B4Rp|¤âij'Ë…j¦j'Ë2P20

4
2p		2042p|¤#n.nAË2PBB2ðp`P04
Rp|¤	o¦oYˬo¶oYË2PBBB
d42ðàÐÀp|¤šwÊwsË2P
4²ðàÐ
Àp`Pd42p(
4òðàÐ
Àp`P@¼p
t	dT42à-	T4ŽŠàp`@¼@-	T4ŽŠàp`@¼@1T–4”ŽðàÀp`@¼`

4
Rpd42pd42pt	d42Pt	d42Pd	42pd	42pB

4
2p(ätdòP@¼pBBBBd42pd42p20d42p

4
2p

4
2p2020d42pd42pB|¤7—=—¼Ë2P20|¤——£Ë2PB|¤Ó–é–ŠË2P202020

4
2p‚p`0P4Rà
Ðp`P$d+4*(p@¼0dT
4	RpdT4²ðàÐÀp42p|¤š«šÕË2P
t	dT42à(d4ràpP@¼842p|¤œœíË2P

4
2pBBb
td
4rðàÀtdT4’ðàÀ

4
2p20R0@¼($dK4JHp@¼0dT42pdT42pdT42pdT42p

4
2pdT42p

4
2pdT42pBdT4
rp
dT4
Rðàp
dT
4rðàpBtd
4Rà|¤
³Q³7Ì2P
td4
RðàÀ|¤7°±Ì2Ptd42à
t	dT42àdT42pd42pt
d	4Rð|¤˜®å®Ì2P2020

4
2p"	â
ðà	ÐÀp`0P@¼h'

ðà	ÐÀp`0P@¼pB2020

4
2p

4
2p
tdT
4’à
tdT
4’à
tdT
4’à
tdT
4’à2020B
4²ðàÐÀ
p`P(
4òðàÐ
Àp`P@¼pd42p

4
2pdT42pt
dT4
RðàÀ%	490ð
àp`P@¼pd42p

4
2pdT42pdT
4RðàÐÀp%	4[Rð
àp`P@¼€2020d42p

4
2p|¤š×ø×’Ì2PB‚%
T4rðàÀp`@¼8r0dT42p+tô4óðP@¼p4rp`Pd42pB42p|¤ÉÏÒÏxÌ2P

4

rpd4
rp
t
dT4
ràdT42pB2020B1
dT4ðàÐÀp@¼˜BBB20202020td4rðàÐÀP2
02020dT4rðàÐÀp

20

4
2pT42`td4rðàÐÀP

4
2p2020d42p-
5td43²
ðàÐÀP@¼PBdT42p

20

4
2p|¤þ•þ«Ì2P

4
2pt
dT4
RðàÀtd
T	42ðàÀ

4
2p'	T4Ðp`@¼°

4
2p$d*4)&p@¼ 
4!
p@¼àd42p
4
rp@¼8

4
2p rð	àÀp`0P@¼0
t	dT42à

4
2p(	d*4)$ð
àp@¼

4
2p$d(4'$p@¼

4
2p)	d)T(4'$p@¼20d42pd42pBdT42pBdT42pd42p

4
2p20|¤zÄÌ2P

4
2p|¤µäÚÌ2PBBBä
t	4Rð|¤ÆIGÍ2P‚ð
ÐÀp`0|¤ïé#Í2PB

4
2p|¤g
Í2PB42p|¤2HðÌ2PbR0bR0bR0bR0bR0bR0bR0bR0bR0bR0R020R020R0

4
2pR0

4
2pbb20|¤¹+Ä+’Í2P20|¤%,0,«Í2P
ät
d	4Rð|¤”-#.ÄÍ1.F.ÄÍRP
ät
d	4Rð|¤”.%/ÝÍ3/H/ÝÍRP
ät
d	4Rð|¤Ù'o(`Í}(’(`ÍRP
ät
d	4Rð|¤Ý(t)yÍ‚)—)yÍRPd42pdT42pd	4Rpd
T	4Rpt
d	4Rà
td
T	4Rà2020B’0@¼HB20d4
rp

4	
Rp|¤ì4	5öͶ45Î2P2PBB‚0
P
d
T	42ðàpBB42p|¤M5’5)Î2Pd	4RpB
d42ðàÐÀp|¤*9Z9CÎ2P
d42ðàÐÀp|¤:H:ZÎ2Pd42pd42pBBBB
t
dT4
ràBd
T	4Rp	tdT4àb20B42p|¤µABqÎ2PB
tdT
4’àdT4²p20202020r0r0d4Òp-
Utd4S²
ðàÐÀP@¼X20d42p-
û
ðà	ÐÀp`0P@¼Àtd42à20B-
÷
ðà	ÐÀp`0P@¼ t	d42P
td
4	2ðàPb		bB42p|¤©x·x‹Î2P2020BBbbbbR0@¼(d	T42p4
Rp`P@¼(

4
2pdT42p

4
2pdT42p

’P¢@¼@

4

rpB$	ð	àÀp`P0@¼À-
EÄtd4C
ÒðàP@¼`BBBBBBBd42pBBd
4rð
àp|¤îÇ‘ðÎRP

4
2pd	4Rpd	4Rp

4
2p|¤CZ×Î2P
ä	td42ð|¤d‡¯‡¥Î2P
ä	td42ð|¤ˆSˆ¾Î2P
td
T	4RðdT
4RðàÐÀp

4
2p
td
T	4Ràd	4Rp
tdT
4’àd4²p'US
ðà	ÐÀp`0P@¼x202020

h¢‚B20B	
td
4	2ðàÀ|¤V¤_¤Ï_¤2PdT
4’p
4P
Lp@¼P’0d42p&	h	àp`0P@¼Ð&	h	àp`0P@¼Ð0hâbbhÂbb'	h
4!
p	`P@¼À+x
h4#
p	`P@¼ÀBh4RðàÐ
Àp`P‚‚’
0t	d42P20	d	42p|¤j¶q¶EÏq¶2PB20	

4
2p|¤Í»¼€Ï¼2P0B20"eŽjPÐheZm°Ðhiön°Ô e~ohиd"pÐXi@p Ô@j‚pˆÕ˜oªoppðoÞoÌoºoˆorj`j`oNo>o2o&ooopoîkll$l8lNl^lrl‚ll l²l¾lÌlàlîlmm&m>mw0kØkØvÄv´vœv„vrvXv>v2v&vvvôuàuÌuÀu°u˜u‚uluXuDu,uuÆk¶k¢kŽkxklk\kìvDkkkþjèjØjÆjºj¬jœjüvútwètØtÊt°tŒp pºpÎpêpqq8qRqhq~q˜q®qÂqÔqèqöqr*rBrZrrršr¦r´rÂrÌrÞrôrss&s6sDsTsvsŽsšs¨s¾sÈsÚsêsöstt&t8tHtZtjt€t–t0p‚mtmhmânÒnÆn¸n°n nŒn€nrndnVnDn2n nnömämÔmÈmºmªmžmŽm\pnpLp…PropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrorSetFileTimelstrlenA•UnmapViewOfFileVGetLastError7GetFileAttributesAºCreateFileACloseHandle»CreateFileMappingA­CreateDirectoryADosDateTimeToFileTimeÃMapViewOfFileTReadFilehGetModuleFileNameA#SetPriorityClassGetCurrentProcessÇGetStdHandle©LoadLibraryExAiGetModuleFileNameWCSetThreadPrioritySetFilePointer¬ResumeThreadjGetModuleHandleAÔMultiByteToWideCharéGetTempPathAGetCurrentThread¨LoadLibraryADeleteFileA0SetStdHandle¤GetProcAddressµLocalFreeBGetFileSize–RemoveDirectoryA¤FreeLibrary×CreateProcessAŸFormatMessageAçGetTempFileNameAšGetPrivateProfileIntA GetPrivateProfileStringAKERNEL32.dlléEndPaintBeginPaint©ReleaseDC_UpdateWindow|GetParentoPeekMessageA>GetDlgItemÏSetCursor»SendMessageA×SetDlgItemTextA¶SendDlgItemMessageAGTranslateMessagepCreateWindowExA DefWindowProcA‹RegisterClassAWMoveWindowJMessageBoxA(ShowWindow‚wsprintfA¬GetSystemMetricssPostMessageA6GetDC"LoadCursorADGetFocusÏGetWindowRect´DispatchMessageAUSER32.dllVCreateSolidBrushDeleteObjectÝSetBkModeTextOutASetTextColor7CreateDIBitmapÕSelectObject=CreateFontAGDI32.dllrRegEnumKeyExAkRegDeleteValueA„RegOpenKeyExA¡RegSetValueExARegQueryValueA\RegCreateKeyExA‘RegQueryValueExAaRegDeleteKeyATRegCloseKeyADVAPI32.dll3ShellExecuteASHELL32.dllSCoInitializeƒCoUninitializeCoCreateInstanceole32.dll®RtlCaptureContextµRtlLookupFunctionEntry¼RtlVirtualUnwind’UnhandledExceptionFilterRSetUnhandledExceptionFilterpTerminateProcesspIsProcessorFeaturePresent0QueryPerformanceCounterGetCurrentProcessIdGetCurrentThreadIdÝGetSystemTimeAsFileTimeTInitializeSListHeadjIsDebuggerPresentÅGetStartupInfoWmGetModuleHandleW»RtlUnwindExZInterlockedPushEntrySListXInterlockedFlushSList)EnterCriticalSection¥LeaveCriticalSectionDeleteCriticalSectionQInitializeCriticalSectionAndSpinCount‚TlsAlloc„TlsGetValue…TlsSetValueƒTlsFreeªLoadLibraryExWÝWideCharToMultiByteÎGetCommandLineAÏGetCommandLineWÂCreateFileW&GetDriveTypeWEGetFileTypePeekNamedPipemSystemTimeToTzSpecificLocalTimecFileTimeToSystemTimeñWriteFileWExitProcesslGetModuleHandleExWªGetACPôGetConsoleModeRReadConsoleW<HeapFree8HeapAllocGetDateFormatWþGetTimeFormatW“CompareStringW™LCMapStringWZGetLocaleInfoWwIsValidLocaleGetUserDefaultLCIDLEnumSystemLocalesWüSetEnvironmentVariableAýSetEnvironmentVariableW?HeapReAllocâGetConsoleCPÌGetStringTypeWGetTimeZoneInformationòSetCurrentDirectoryW	GetCurrentDirectoryWPGetFullPathNameWMGetFullPathNameAüOutputDebugStringAýOutputDebugStringW¼WaitForSingleObjectExçCreateThreadnFindClosesFindFirstFileExAtFindFirstFileExWƒFindNextFileA…FindNextFileWuIsValidCodePageGetOEMCP¹GetCPInfo.GetEnvironmentStringsW£FreeEnvironmentStringsW©GetProcessHeapÒSetConsoleCtrlHandler9GetFileAttributesExWùSetEndOfFileSetFilePointerEx˜FlushFileBuffersðWriteConsoleWAHeapSizeêGetTempPathWDRaiseException2¢ß-™+Í] ÒfÔÿÿÿÿÿÿ/ ÿÿÿÿ   DB@ÿÿÿÿÿÿÿÿ€


ÿÿÿÿ@=@(„@(„@(„@(„@(„@0Š@À?@@A@`5@À‚@ð„@C@=@BB@PSTPDT@„@€„@ÿÿÿÿÿÿÿÿ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZð„@¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZЊ@©@©@©@©@©@©@©@©@©@ÔŠ@”©@”©@”©@”©@”©@”©@”©@0Š@..þÿÿÿþÿÿÿÿÿÿÿu˜¨«@à«@°«@à«@¸«@¢«@À«@È«@Ô«@¢«@¸¬@Ь@à¬@ð¬@­@(­@@­@P­@h­@x­@Software\Microsoft\Windows\CurrentVersion\UninstallÿÿÿÿÿÿÿÿSoftware\Microsoft\Windows\CurrentVersion\Uninstall`¯@L @p¯@@ˆ¯@X#@˜¯@„@¨¯@È@À¯@ô"@¨«@¢«@°«@¢«@¸«@¢«@À«@È«@Ô«@¢«@ðª@.?AVDNameNode@@ðª@.?AVcharNode@@ðª@.?AVpcharNode@@ðª@.?AVpDNameNode@@ðª@.?AVDNameStatusNode@@ðª@.?AVpairNode@@ðª@.?AVtype_info@@ð˜óðã¬óäÝÄóàJÔó\Ÿüó ãôä>ô@¢(ô¤ú<ôüRLôTªXô¬öhôøBxôTû„ôü2”ôHŠœôŒç¨ôè€Èô€„Üô„ÆøôÈ
õK õL ò" õô"X#8õh#«$@õ¬$K&XõL&ã(põä(‹*”õŒ*m+¬õp+n-Èõp-L.ðõL.0ö0Õ0 öØ0K10öL1	3<ö3L3`öL3¹4hö¼486„ö86Ø6¨öØ6é7¼öì7â9Ðöä9::ðö<:¦:üöØ:@?÷@?­C(÷°C:DP÷{>€ˆ>­>˜°>ß> à>?¨?3?°x?“?ˆ¤?Ü?ä?@ˆ$@´@ÈØ@1Bì^p,@^Ó^Ô,Ô^K_d-L_î_8-ð_x`„-x`a¼,aƒa\-„a&b -(b°b|-°bÇcX+Ècïd`+ðdiP(isÐ(s™w@)œw瀰)耑”,”‚P-‚Ñ‚ø,Ô‚oƒl-pƒ„l(„µ„\)¸„T…ð(T…ð…Ð)ð…‘†x(”†;‡h)<‡Ú‡ü(܇zˆÜ)|ˆ,Š(,Šô‹)ô‹ç„(èÈt)È°‘ (°‘°“ )°“v•œ(x•7—Œ)˜—˜À'˜a˜Ô'd˜ñ˜à'ô˜M™ô'ˆ™Å™X*È™šØ*šFš˜*Hš‚š+„ššx*Äš›ø*›C›¸*D››8+Àœ¸$´-ž $0žµž &`Ÿ}Ÿ%ˆŸ¥Ÿ€#ðŸ Ð D _ ”#` } l&Рí t&ð 
¡¸'¡+¡d&,¡G¡°#H¡|¡œ#€¡¯¡Ø ¢‹¢°+Œ¢£,£¤%¤}¤ì,@¥¦|&¦‘¦-§‡§ˆ,Ȩ?©°,@©ø®(#¯‹¯@!Ô¯¤±È$¤±,³Ü%,³e³°"h³¡³¸"೓·ô"”·¹#ì¹®×P#°×_Øt#xؽ؈#àØIÚl"IÚ|ÝŒ"|ݮݠ"ÌÝÞ@(ÞQÞ¼(ÈÞèÞ$èÞ
ß8%|ß÷ßT&°àýà %áMá„' áñá&°ã“ä¸!“ävåÐ!våòæä!òæúæ"úæç"çç$" ç^çP!^ç~çX!~çÒçl!Òçüçˆ!üçè !0èæíH"ðí9îH!Xî4ï($4ï"ð¨&$ðûðH%üðáñ8'Lòió`$lóôØ&ô­õt%°õåöX'èöL÷ $L÷º÷'¼÷&ø¼%(øø ' øDùŒ$Dùòù'ôùžú¨% úUûŒ'Xû¡ûL$àû"ül%düÙüT$ÜügýÌ&pýþ8$þÈþ¸&ÈþqÿX%tÿ)D',«l$¬5ä&8½€%ÀPd'PD$„¿Ä&À÷d%ø:P'<W¨#Xqø$tËH&ŒVØ" 	Ç	à$È	è%˜óØ$Xëè$ìÉô%$š &àsà sŒø Œî!î$ !$]0!À"dõ0&`žH( ãÈ(Lj$l‘@%ÔúÀ$ü"Ô%$P8(P|´(|¨8)¨Ô¨)Ô$%0%(V˜&X†0'°E|$`üô&ü¦%Änt'Œ
¬$$'È%‡¬'ˆ ¤  Ÿ €   ç!¬ è!
#ˆ #M#x P#×#h Ø#|$Ü-|$:%è-<%ã%ô-ä%&.¤&¼&Ô-Ü&	'Ì-'Ê'Œ-Ì'{(˜-|( )À- )Ë)¬-Ì)Œ*ì0Œ*L+L1L+,1,Ö,¼0à,-d0-.-„00-V-t0X-~-”0€-q.l/t.g/x/h/e0„/h0[1/\1«1ì.¬1`3ô.`3¯3/°3k5/l5»5,/¼5”74/”7ã7L/ä7¢9T/¤9H:È/H:ì:ô/ì:“; 0”;;<L0<<>¬/>ÿ?Ø/@ïA0ðAÕC00ØCDœ0DHE¬0HE“E|1”EßE„1ÐFòFœ/ôFGÜ. G´G\0´GUH|0`HöHl0(I¾IŒ0ÀIVJ„.XJzJ¤/|JJ.J¾Jt.ÀJúJ|.üJ(L¤.4LL´.¨LMœ.4N=O¼.HOcOä.dOTP$.TPFQ0.HQDRH.DR6S<.8SŽST.SæS\.èS>Tl.@T–Td.ôTVŒ1ˆV³V¸1´V\WÀ1\WY 1ÀYZÔ1@Z«[2¬[],24]ð^@2ð^†`l2À`Û`\2Ü`÷`„2”a¯ad2°aËaŒ2Ìaâa2èaIb2LbÂcà1Äc5eô1Heie3lee$3eÕe3Øef3 fŒf¬2Œfóf¸2LgEh,3HhKiD3Liiô2iÑi3äi·j\3¸jhkl3°kõkÌ2øk=lä2@lZlÄ2\lvlÜ2\m”m¤2¤mÅm”2Èmémœ2ümln3Ønînˆ3ôndo|3´o*pœ3,pxp´3Üpýpè3q-qð30qDqÌ3Dq°r4°rùr4s\sÔ3\s„sø3„sðsÜ38t|tÄ3˜tÇt”4ÈtuŒ4uþuX4vßvœ4üv=wÀ6@wiwì6lw¦x7¨xæx”6èxyh6y6yŒ68y^yp6$z?zH6@z[z86\zwzX6¬z:{x6<{Y|„6ø|}P6}/}@60}K}`6P}Ò}¬4à}'~6(~Ê~x5Ì~€Œ5„€í€¼4ð€®6°'‚Ð4(‚$†H5$†Ɔä4Ȇƒ‡Ä4„‡̈,5̈1‰h54‰Љ$5Љµ‹È5¸‹?Žä5@Ž~‘¤5¸‘ã‘@7’K’°7L’ë“Ü7ì“”¨7”:”„7˜”³”X7´”–Œ7–æ—h7˜#˜`7D˜~˜P7À˜™H7™?™,8H™X™48`™±™<8¼™JšD8˜š¬š8¬š¼š$8Кàš8ôš›t8›D›l8D›k›L8´›œ|8œÞœ„8èœß´8ÄŸ™¢Ì8œ¢˜£9˜£”¤€9”¤û¥è8ü¥„§X9„§Χ¼9Ч¨Ð9¨œ¨Ä9œ¨*©Ø9dªªü8€ª›ªp9œª·ª9Ъ«¨8«««9¬«Ç«x9È«ã«9ä«þ« 8¬¬˜8X¬Ÿ¬ä9 ¬S­ì9X­®D:®Ç®t:È®¦¯œ:¨¯†°È:h±ú³@;ü³3´ô:4´”´ü:”´µ;µ·;·w·;x·Æ·;È·‰¸0;Œ¸¯¸<:°¸ñ¸X;ü¸‹¹:Œ¹¾¹:À¹ã¹l:ä¹%º`;0º¾ : ¾R¾ü9T¾ɾh;̾bÀä;dÀ‘Âü;üÂùÅÌ;üÅÆÄ;ƧÇx;¨Ç
̬;ÌÌD<„̪Ì<<ÌÌÍ4< Í›Í(<œÍ=Î<@ÎúÎ<Ï|Ïx<|ϹÏp<¼ÏЄ<Ð~Д<€ÐßÐŒ<üÐQÑœ<TÑÉѤ<ôÑ0Ò,=0ÒlÒD=lÒ¨Ò8=¨ÒäÒP=äÒÓ=ÓCÓ$=DÓwÓ=xÓ«Ó=¬ÓßÓ=àÓ
Ô¬<Ô6ÔÜ<8ÔkÔä<lÔŸÔ´< ÔÊÔ¼<ÌÔÿÔÄ<Õ*ÕÌ<,Õ_ÕÔ<`ÕŠÕì<ŒÕ¶Õô<¸ÕâÕü<Ö‰Ö¤=ÄÖØ„=@ØZØ|=\ØÙ°=Ù"Ù\=$ÙSÙd=TÙšÙl=ÐÙõÙt=Ú3Ú>4ÚÚÈ=èÚÒÛð=ÜÛ÷Û>ܳÞ\>´Þuáh>xá%â<>(âÕâL>Xäôä>ôäå(>åÔåAðå…æ4Aˆæ®æ,Açxç$A€çâçAèëÌìÀ@Ììlîô@lî8ï¨@8ï:ðØ@<ðð @€ðÉðÀ>Ìð»ñÈ>¼ñbòà>dò¹ò|>¼òóˆ>óió”>lóÔó >Ôóôô> ôçô?èôsõ?tõö,?ödöD?dö ÷P? ÷“÷h?”÷ú÷x?ü÷tøˆ?tøÚøœ?ÜøgùÀ?hùWú¨?Xú½úØ?Àú4ûè?4û»ûü?¼ûCü@Düü,@üÎü8@Ðü4ý@@4ýýP@„ýßý\@àýþd@þ>þl@@þÍþt@Ðþÿ°>ÿÚÿ€@Üÿa”@d¥¸>¨ZdA¬#ÄA$o¼A|`ÔA`£A´ô Bû\Bü÷xBø3(B4tPB|¢ŒB¤œBu”BxØÌBØÉ
ÔB´ÜB´—äBü
¬B9´Bl…¤BŒåÄBèؼBØ ìB<sôB°üB Cz0C|nXCpðDCð~pC "ˆC,‹°DŒÑ„DÔXDQÜDTzD|¢ôC¤ÊDÌòìC`zÈC|—8DÀøDd )!äC,!ù!üC" "ÐC "#D#
$$D$‹$,DŒ$!%HD0%K%@DL%³%ØCÈ%	&ÀC& &¤C &?'°C@'y'”C|'ž'œC°'á'Eä'(E„(¦(Fä(H)ÄEH):*´E<*_*ÔE¤*C:ÜEH:˜; EH<¯AìEÐApCLEpCEhEEgM„EhM†MFˆM,O0E,OKOELOjO(ElO†O EˆO¸O F¸OõP€FøP5RpF8R…RXFˆRÕRdFSBT8FHT†UHFˆU³U0F´UßU(FàU(WF0W¢W´F¤W(YÈF(YuY¨FxYŒYÀFZ]]$\>?,\`?'@`\€@bAL\dA–AD\˜A$B\$BJBˆ\lBÕB€\àBqCx\tCD¼\D9EÄ\TETFÜ\TF€Fø\€F¬Fð\¬FëF](GTG]TG€G]àG!H]ÜH7L0]8LÎL ]ÐLMX]M	_´]_>_¤]@_T_¬]`g`]h`Ósp]Ôs[t`]\tvÔ]væwè]ŒxÌx^Ìxòx^(ycy^dy½y^Ày!zD^`zwzT^xz‰z\^˜zèzL^èz+|”^,|}¨^€}-~Ì^0~Ý~ì^à~IÀ^Lµà^èh€„^h€€t^€¯€|^°€×€d^Ø€÷€l^ø€¼_Äb‚_l‚ƒ_ƒƒ$_ƒ¹„L_¼„„†,_¼†õ†|_ø†1‡t_4‡Ö‡X`؇zˆ`|ˆljÈ`ȉ7‹à`8‹Ñ‹`Ô‹xŒ aŒÔŒ`ÔŒü`Ü`ÜõŽaq,`t÷‘Ì_’/’¼_0’G’Ä_X’¸’¬_¸’Þ’Œ_à’“„_“;“œ_H“n“¤_p“¥“”_¨“e”0ah”ú—Xaü—…˜Ha ˜À˜|aÀ˜™„a™\™Œa šËŸ˜aÌŸ ¤a ( ¬a¡^¡´a(¢\¢¼a¤¢:¥ÄaP¥`¥b ¥'¦b(¦ϦbЦ5§4b8§ñ§ttj\Vèzx‹ðYY…ötdWÆÿD±E‰Eüƒøÿu*jWÿ¬°E…Àu…ÛtWhHZFjÿÓƒÄëWjÿÓYY‹Eü¨uh·ÿX±E…Ût
WhHZFjÿÓƒÄÆ\ƒÆu‡[3À_@^‹å]ÃU‹ìƒìSV‹u‹ÁW‹ú‰Eø…Àu@‰Eøjh€PjjhÀWÿ@±E‹Øƒûÿ…‚ÿH±Eƒøu‹U‹ÏVèÿÿÿ…À‹EøYu·éôƒøPt	PÿX±Eë2…ö„ÞWjÿÖYY…Àt23ÀPh€jPPhÀWÿ@±E‹Øƒûÿu…ö„¬Wh`ZFéšWjÿÖYYé•…ötWjÿÖYYEðPÿuÿuÿ4±EEðPPPSÿT±Eƒ}u	Sÿ<±Eë^3ÀPÿuPjPSÿ8±ES‰Eøÿ<±E‹]ø…Ûu…öt8WhpZFë)3ÀPPPjSÿ,±ES‰Eøÿ<±E‹Eø…Àu…öt
WhˆZFjÿÖƒÄ3À_^[‹å]ÃU‹ìƒì8ƒ}VW‹ò‹ù…j8EÈjPèc}‹EMÈj8@‰uÈhœZF‰EÌ3ö‹EFjñZ‰}Ô‰EØèhGƒÄ…ÀtPh¤ZFëMÈè,I;ÆtPh¼ZFjè!ƒÄ3öMÈèò\…ÀtPhÐZFjèƒÄ3öWÿL±E_‹Æ^‹å]Ã}uéÿuVWè\3öƒÄFëÙU‹ìƒäøìD¡ÀF3ĉ„$@S‹ÔéFVW‹=TéF‰L$‰|$$OêˉL$<+Y‹A+؃ëÃ9PKt3À鎃d$,3Òf;Q
z4‹V*úû‰t$4>PK‰|$uÎ?PKuÆ¿N ƒÀ.‰D$‹D$$D$‰D$ ¿FÈ¿FD$Á¿O‰D$¿GÂÈCL$$Á3ɉD$8ŠàéFˆD@A„ÀuñL$@QŠA„Àuù+ÊD$@H‰D$(€<\t|$@OŠGG„Àuøf¡èZFf‰D$@PÿP±E|$@Ç3ÿ‰D$0‹D$98t9‹‹ÊA‰D$ŠA„Àuù+L$Qÿt$$RèOwƒÄ…À„΋D$Gøƒ8uÇ‹|$¿GPÿt$$D$HPègæƒÄL$@è«ûÿÿL$@QŠA„Àuù‹D$(+Ê€<\tJ·FT$@hž&@P·F3ÉPÿvÿt$@èüÿÿƒÄ…Àt"‹T$8Qÿv¿OÿvQ‹Èè\ýÿÿƒÄ…À„]þÿÿ‹|$,‹t$‹}ô…ÿt7‹uð…öt0ƒ}ìt*…Ét&3À9EühÀæF•À‰ÿÒYÿÓ‹Uü‹ÎèÌýÿÿ‹ðÿ׋ÆëƒÈÿ_^[‹å]ÃU‹ìQEüPh¼\Fÿuÿ€üFƒÄ…Àtÿuüjè†høZFÿÜéFƒÄ‹å]ÃU‹ìQEüPh¼\Fÿuÿ€üFƒÄ…ÀtÿuüjèMhøZFÿÜéFƒÄ‹å]ÃU‹ìì¡ÀF3ʼnEüƒ=LßFV‹uu:hÀ\Fÿt°E…ÀuhÌ\Fÿ5ÌèFÿÈèFYY3ÀéÍhä\FPÿ€°E£LßFW…ôþÿÿ¿¼\FPWVÿ€üFƒÄ…À„™ƒ=LßFuhÌ\Fÿ5ÌèFÿÈèFYYë{3öÿµôþÿÿÿ4õ´ÉFèd|YY…ÀtFƒþ
râÿµôþÿÿh]Fÿ5„åFë?jÿ4õ°ÉF…øþÿÿPjÿLßF…Àt…øþÿÿPWÿÜéFYYëÿµôþÿÿhü\Fÿ5ÌèFÿÈèFƒÄ3À_‹Mü3Í^è.^‹å]ÃU‹ìì0¡ÀF3ʼnEüV‹uW3ÿW‰½èýÿÿ‰½äýÿÿ‰½Üýÿÿ‰½àýÿÿ‰½ðýÿÿ‰½ìýÿÿÿȲE…ÀyPh$]Fÿ5ÌèFÿÈèFƒÄé­…ÜýÿÿP…äýÿÿP…àýÿÿP…èýÿÿP…ØýÿÿP…ÐýÿÿP…ÔýÿÿPhD]FVÿ€üFƒÄ$…Àu3Àé·…ðýÿÿPhÀEjWh ÝEÿIJE…ÀyPhP]Féxÿÿÿ‹…ðýÿÿ•ìýÿÿRhpÎEP‹ÿ…ÀyPht]FéRÿÿÿ‹…ðýÿÿÿµÔýÿÿP‹ÿQP…ÀyPhœ]Fé1ÿÿÿ‹…ðýÿÿÿµÐýÿÿP‹ÿQ…ÀyPh¼]Féÿÿÿ9½èýÿÿt!‹…ðýÿÿÿµèýÿÿP‹ÿQ,…ÀyPhà]Féçþÿÿ9½äýÿÿt'‹…ðýÿÿÿµÜýÿÿÿµäýÿÿ‹PÿQD…ÀyPhü]Fé¸þÿÿ9½àýÿÿt!‹…ðýÿÿÿµàýÿÿP‹ÿQ$…ÀyPh^Féþÿÿh…ôýÿÿPjÿÿµØýÿÿWWÿh°E‹…ìýÿÿ•ôýÿÿjRP‹ÿQ…ÀyFPÿµØýÿÿh@^Fÿ5ÌèFÿÈèFƒÄ‹ìýÿÿ…Ét‹QÿP‹ðýÿÿ…Ét‹QÿPÿÀ²Eélþÿÿ‹…ìýÿÿP‹ÿQ‹…ðýÿÿP‹ÿQÿÀ²EhøZFÿÜéFY‹Mü_3Í^è¹[‹å]ÃU‹ìƒìEüPEøPEôPhl^Fÿuÿ€üFƒÄ…Àt$ÿuüÿuøÿuôÿh²EPÿ„²EPhp^FÿÜéFYY‹å]Ãÿ54ÊFÿ°éFYÃU‹ììl¡ÀF3ʼnEüSV‹5|²E…˜ýÿÿhàéFhÜ^FPÇ…”ýÿÿÿÖ…˜ýÿÿPèüëƒÄ»€äFSÿt°E…À…¶hìZFÿ5¸éFE¬ÿ5ÐèFhì^FPÿÖ‹5°E…”ýÿÿƒÄP…¨þÿÿPE¬Ph€ÿÖ…Àt!…”ýÿÿP…¨þÿÿPE¬Ph€ÿÖ…Àt3ÀëSW½¨þÿÿOŠGG„Àuøf¡èZF‹óf‰ŠC„Àuù½¨þÿÿ+ÞOŠGG„Àuø‹Ë…¨þÿÿÁéó¥j‹Ëƒájó¤Pÿ±E_‹Mü^3Í[è;Z‹å]ÃU‹ìƒìSV‹5€°EW‹ùh_FWÿÖh4_FW‰EèÿÖhL_FW‰EøÿÖhd_FW‹ØÿÖht_FW‰EüÿÖh„_FW‰EôÿÖh˜_FW‰EðÿÖh¨_FW‰EìÿÖ‰Eä‹Eè…À„…Û„•ƒ}ø„‹ƒ}ü„ƒ}ôt{ƒ}ðtuƒ}ìtoh¼_FÿЋøY…ÿt=hÈ_FWÿÓhÔ_FW£„åFÿӃģÌèF¾pÊFj[jVÿUüPÿ6WÿUøƒÄƒÆƒëuè‹Eô£ÜéF‹Eð£€üF‹Eì£ÈèF‹E䣰éF3Àë3À@_^[‹å]ÃU‹ìƒìX¡ÀF3ʼnEü‹ESV‹5€°E‹ÙWhŒ[FS‹ú‰]¨‰EÀÿÖhÜ_FS‰EÄÿÖh¼[FS‰EÈÿÖh°[FS‰E¼ÿÖht_FS‰E¸ÿÖhd_FS‰E´ÿÖh„_FS‰E¬ÿÖh˜_FS‰E°ÿÖ‹uÄ…ö„iƒ}È„_ƒ}¼„Uƒ}¸„Kƒ}´„Aƒ}°„7…À„/ƒ}¬„%…ÿ„€?„
h€Wè©€‹ØYYƒûÿuWhì_Fjè·ÞYPèRôÿÿƒÄjXéäh`Fhìÿ5pìFÿ ²EÿÖ‹M¨è¸ýÿÿhj¾`àFVè»m‹}ÀƒÄ‹Æ+ljEÀjZ‰UÄ‹…Étèåöÿÿ‹UÄ‹È‹EÀë3ɉ8ƒÇƒê‰UÄuÛVjÿUÈYYƒ>tÿ6èr6YƒÆþhàF|èEÌÇEÈPSè-YY…Àu*‹uàFè‘J‹üVWSèÓ‰ƒÄ…À~WfÇ8
ÿU¼Y‰EÈÿU¸Sè‹EÈYë
jéÿÿÿ3À@eœ_^[‹Mü3ÍèW‹å]ÃU‹ìƒìS‹]3ÀVW3ö‰MøPF‰P‰uüèGtYYjh€€jjVhÀP‰Eìÿ@±E‹5±E‹øjõÿÖjô‰EôÿÖ‹5|°EWjõ‰EðÿÖWjôÿÖèWûÿÿ‰E…Àtÿu‹UøQ‹Èè}ýÿÿYYÿu‰Eüÿ°Eëh(`FjèÝYPè¯òÿÿYYÿuôjõÿÖÿuðjôÿÖjWÿˆ°E¾;ÆsjWÿˆ°E‹ðFPè‰-‰Y…Àt(3ÀPPPW‰Eÿ\°EjEPVÿ3Wÿ(±E‹‹EÆWÿ<±Eÿuìÿx°E‹Eü_^[‹å]ÃU‹ìƒìSV‹5€°EW‹ù‰UìhŒ[FWÿÖhœ[FW‰EüÿÖh°[FW‰EôÿÖh¼[FW‰EøÿÖhH`FW‰EðÿÖƒ}ü‹Øt?‹Eô…Àt8ƒ}øt2‹uð…öt+…Ût'hÀæFÿÐÿUü‹ÏèHûÿÿÿuìÿÖ‹ðYY…ötÿÓÿUø‹ÆëƒÈÿ_^[‹å]ÃU‹ì씡ÀF3ʼnEü¡¼éFSVW3Û‰…tÿÿÿSSè…rYYSh€€jSjhÀP‰…lÿÿÿÿ@±E‹5±E‹ØjõÿÖjô‰…xÿÿÿÿÖ‹5|°ESjõ‰…pÿÿÿÿÖSjôÿÖèùÿÿ‹ø…ÿu/ÿH±EP…|ÿÿÿhT`FPÿ|²EƒÄ|ÿÿÿèQòÿÿƒÈÿéÙ‹•tÿÿÿ‹Ïè«þÿÿW‰…tÿÿÿÿ°EÿµxÿÿÿjõÿÖÿµpÿÿÿjôÿÖƒ½tÿÿÿ„…jSÿˆ°E‹øƒÿÿu¿G-PèŸ+‹ðY…ötVƒ¥xÿÿÿ¹`F‹Ö+ÑŠˆ
A„Àuö3ÀPPPSÿ\°Ej…xÿÿÿPWF,PSÿ(±E‹…xÿÿÿ‹ÎÆD0,èœñÿÿVèÞ2Yë
¹À`Fè‰ñÿÿSÿ<±Eÿµlÿÿÿÿx°E‹…tÿÿÿ‹Mü_^3Í[èÊS‹å]ÃU‹ìì¡ÀF3ʼnEüV¾W‹ú…Ét=3Ò…øûÿÿRRPVQRhÿ˜°EVÿµøûÿÿ…üûÿÿPèHƒÄÿµøûÿÿÿ„°EëÆ…üûÿÿ…üûÿÿPÿP±E+ðüûÿÿWÁVPèðÿÿƒÄ…üûÿÿjhÐ`FPÿ5ØéFÿ„²E‹Mü3À_3Í^èS‹å]ÃU‹ìì¡ÀF3ʼnEüVEºPQÿuüûÿÿè7ïÿÿ‹EƒÄƒè„òHƒè„œƒètzƒèt]ƒèt ƒè…ê¡ÌéF…À„‘ÿuhaFë~·E‹5¤²EW‹}ÁàPjhÿ5pìFÿÖÿuWhÿ5pìFÿÖ_é›ÿH±E•üûÿÿ‹Èèþÿÿéƒj0h$aF…üûÿÿPÿh²EPÿ„²Eëf¡ÌéF…Àtÿuhô`FPèTîÿÿƒÄj.ÿuè=b‹ÐYY…Òt:¾ aF3ɶ
:u*Aƒùuñ‹Mè¹ïÿÿë¡ÌéF…Àtÿuhà`FPèîÿÿƒÄ‹Mü3À3Í@^è¿Q‹å]ÃU‹ìQQSV3ÛSh€jSjh€hëFÿ@±E‹ðƒþÿu3ÀëIWEøPVÿˆ°ESSSjSV‰Eüÿ8±E‹<±E‹øVÿÓ3À…ÿtPPPjWÿ,±EW‹ðÿÓ‹Eü£ÔéF‹Æ_^[‹å]Ã=ˆüFS‹Ùt?ƒ=´éFu6VWSÿp²E‹ˆüF‹øj‹J
rVÊQjVWÿ8°EWS£´éFÿT²E_^[ÃU‹ìì¡ÀF3ʼnEü‹ÔéF¡TéFV+Qú+Qöƒ%¼éFƒê"ƒ%„üFyêPK4t3Àéÿ>{V4tº,aF3ÉèÊüÿÿéæ…ÒxÜ‹N…Ét‹Æ+F+Á£ˆüFSW~++щ½ôþÿÿ‰¤æF+7hè›'‹ØY…Û„Ÿ…øþÿÿPhÿl°E…ÀtwSjh`aF…øþÿÿPÿœ°E…Àt^3À‹ÓPPPÿ7PjYèçÿÿ‹øƒÄ…ÿtU‹…ôþÿÿÿ0VWè½ÿ‹ÏƒÄQŠA„Àuù+ÊFÁPè¯|YW£¼éF‰„üFÿL±E3À@ëÿH±EºdaF‹Èèãûÿÿ3À_[‹Mü3Í^èšO‹å]ÃU‹ìƒìW3ÿëEäPÿ˜²EEäPÿ`²EjWWWEäPÿ°²E…ÀuÙ_‹å]ÃU‹ìƒìL¡ÀF3ʼnEüƒ}SV‹uWtÿuÿuÿuVÿ²Eé¸E¸PVÿX²Ej‹øÿx²Ej
Y™÷ùh„aF3ÉQQQQQQQjh¼QQQPÿP°EPWÿ4°EjW‰E´ÿD°E»éF‹ËQŠA„Àuù+ÊQS‹@°EjjWÿÓhÿÿÿWÿ<°E¹éFQŠA„Àuù+ÊQhéFj
j
WÿÓÿu´Wÿ4°EPÿH°EE¸PVÿ\²E3À‹Mü_^3Í[èiN‹å]ÂU‹ì¸0è´A¡ÀF3ʼnEüV‹5d°EW3ÿÇ…ÐïÿÿWÇ…ÔïÿÿS*@‰½Üïÿÿ‰½ØïÿÿÿÖhW‰…àïÿÿ‰½äïÿÿÿl²Eh€‰…èïÿÿÿL°E‰…ìïÿÿ…ÐïÿÿP‰½ðïÿÿÇ…ôïÿÿaFÿŒ²Ef…ÀuWh¤aFh°aFÿ5ØéFÿ„²EhéF…øïÿÿhÐaFPÿ|²EƒÄWWÿÖ‹5x²EPWWjÿÖPjÿÖPWWW…øïÿÿPhaFWÿ”²E‹ðjVÿ€²EVÿ¸²E‹Mü‹Æ_3Í^èPM‹å]ÃU‹ìƒì¡ÀF3ʼnEüSVWEì‹ÙPSÿd²E‹5x²EjÿÖj‹øÿÖ‹Mø‹Ð‹Eð+È+Eø‹uìÂjQ‹Mô™+Î+uô+ÂÑøQP7™+ÂÑøPSÿˆ²E‹Mü_^3Í[èÛL‹å]ÃU‹ì¸è(@¡ÀF3ʼnEüƒ}NW‹}„Œ}…¢‹Ïèaûÿÿ¡´éF…ÀtPjhrhWÿœ²EVWÿ´²E‹Èè&ÿÿÿh`éF…üïÿÿhàaFPÿ|²E‹5 ²E…üïÿÿƒÄPhèWÿÖh€ìFhýWÿÖh ìFhWÿÖ^ë#‹Ex8ÿÿÿujjhpWÿ´²EPÿt²E‹Mü3À3Í_èöK‹å]ÂU‹ìì¡ÀF3ʼnEüSVW…ÿÿÿ‰ÿÿÿPh3ÿ‹òWhLbFV‰µøþÿÿ‹ßÿ°E…Àt3ÀéyWWWW…ÿÿÿÇ…ÿÿÿPPE¬PWÿµÿÿÿÿ °E‹=°Eé5CÇ…ÿÿÿP€=ÀéFt5M¬¸ÀéFŠ:u„ÒtŠP:QuƒÀƒÁ„Òuä3ÀëÀƒÈ…À…ÎE¬P…ÿÿÿhhbFPÿ|²EE¬P…\ÿÿÿhbFPÿ|²EƒÄ…üþÿÿPhj…\ÿÿÿPVÿ°E…Àuhè"‹ðÇ…ôþÿÿY…ötV…ôþÿÿPV3ÀPPPÿµüþÿÿÿ°E…Àu9…ÿÿÿPjh€ÿµÿÿÿÿ¤²E‹øþÿÿVPhšÿµÿÿÿ‰Žÿ¤²Eÿµüþÿÿÿ׋µøþÿÿ3ÀPPPP…ÿÿÿPE¬PSÿµÿÿÿÿ °E…À„Ãþÿÿÿµÿÿÿÿ×3À@‹Mü_^3Í[èJ‹å]ÃU‹ìQVEüPjjh8ÊFh€ÿ°E‹ð…öu	ÿuüÿ°E3À…ö^”À‹å]ÃÌ¡4ÊFV¾€;Æt==€uè¬ÿÿÿ…Àu-‰54ÊF^Ãjh¼bFhÄbFQÿ„²Eèˆÿÿÿ÷ØÀ÷ØÆ£4ÊF^ÃU‹ìQ¡ÐèFƒø~¸€ÉFëuƒ=¸éF¸€ÉF}¸ÐÊF‹å]ÃU‹ì¸è¶<¡ÀF3ʼnEü‹ES‹]VWƒèN„!j_-Ât+ƒè…N‹E¾þf;Æ…=Áèƒè„é,¡´éF…ÀtPWhrhSÿœ²E‹5¬²EQhþSÿÖº€‹ÈèàüÿÿhþSÿÖº€‹ÈèÌüÿÿYWWh‹¾þVSÿœ²E‰…ôîÿÿ…ÀtƒøÿtWHÿQh†VSÿœ²E ÀéF„Àt2hÀéF…øîÿÿhðbFPÿ|²EƒÄ…øîÿÿPhèSÿ ²E ÀéFƒ½ôîÿÿu:„Àt"hÀéF…øîÿÿh8cFPÿ|²EƒÄ…øîÿÿë¸|cFjh¬cFPSÿ„²EjWhpSÿ´²EPÿt²EWWhˆVSÿœ²E‰…ôîÿÿƒøÿuGjWhpSÿ´²EPÿt²E‹5 ²E¿øZFWhïSÿÖWhðSÿÖ øZF¢àéF¢€äFé¶jWhpSÿ´²EPÿt²EWÿµôîÿÿh™VSÿœ²E‹Ð‹Š‰
4ÊF¹àéF+ÊŠˆB„ÀuöhàéFhïSÿ ²EWÿµôîÿÿhŠVSÿœ²E@Pèd‰…ðîÿÿY…Àt_Pÿµôîÿÿh‰VSÿœ²E‹µðîÿÿh¸éFhÐèFh¼cFVèÜãÿÿƒÄƒøuÿ5¸éFÿ5ÐèFhÔcFh€äFÿ|²EƒÄVè–%Yë
 øZF¢€äFèýÿÿ‹ðŠàéFˆŒ=øþÿÿG„ÉuîøþÿÿQŠA„Àuù+Ê€¼
÷þÿÿ\t½øþÿÿOŠGG„Àuøf¡èZFf‰‹V‹òŠB„Àuù½øþÿÿ+ÖOŠGG„Àuø‹Ê…øþÿÿÁéó¥P‹Êƒáhðó¤Sÿ ²Eë@‹Ex8ÿÿÿu43ÿWWhˆhþSÿœ²EƒøÿujëjWhpSÿ´²EPÿt²E‹Mü3À_^3Í[èÌE‹å]ÂU‹ìì ¡ÀF3ʼnEü¡4ÊFSV¾äcFW=€t¾øcF3ÒðùÿÿRQRjRRRhÊFPÿ°E‹=„²E‹h²E…Àt+ƒøujjhdFÿÓPÿ×3Àé	jhldFhÊFÿÓPÿ×h`éFhàéF…ôþÿÿh€dFPèÌáÿÿ…ôþÿÿh”dFPè(ʃÄ£ÌéF…Àu=èšüÿ0èÝüP…ôþÿÿP…ôùÿÿh˜dFPèŠáÿÿƒÄ…ôùÿÿjjPÿÓPÿ×ésÿÿÿ…àùÿÿPèq…àùÿÿPèe#…àùÿÿPèY#PhàdF…ôþÿÿhPèÚ…ôþÿÿPÿ5ÌéFè¹àÿÿhëFheFÿ5ÌéFè¤àÿÿVheFÿ5ÌéFè“àÿÿÿ5¸éF…ôýÿÿÿ5ÐèFh`éFh0eFPèÝàÿÿƒÄP…èùÿÿ3öP…ìùÿÿPVhVVV…ôýÿÿPÿµðùÿÿÿ°E…ÀtVhB‹å]ÃU‹ìì¡ÀF3ʼnEü…ìþÿÿPèÊ…ìþÿÿPè¾ …ìþÿÿPè² PhfF…ôþÿÿhPèè×…ôþÿÿPÿ5ÌéFèÞÿÿ¡ÌéFƒÄ$…ÀtPèÔÉY‹Mü3Íè½A‹å]ÃU‹ì¸è
5¡ÀF3ʼnEü‹ES‹]V‹uWƒèN„È-Âtc-ñt-ƒè…‚PÿuhhëSÿœ²EVhìSÿ ²EëVjhhëSÿœ²Eè£ñÿÿ3À@‹Mü_^3Í[è)A‹å]¡´éF…ÀtPjhrhSÿœ²Eh`éF…øïÿÿh@fFPÿ|²E‹5 ²E…øïÿÿƒÄPhèSÿÖhàfFhìSÿÖéÑ~1ÿÿÿt)~8ÿÿÿ…»jjhpSÿ´²EPÿt²E韋5´²EjjhpS‰pìFÇÐéFÿÖPÿt²EjjhkSÿÖPÿ¤²E¹àéF‹ÑrŠB„Àuù+Ö€ºßéF\tyÿŠGG„Àuøf¡èZFf‰QŠA„Àuù+ÊIùƒ!ˆàéF‹Ëè öÿÿè6úÿÿ…À„è\öÿÿ‹
¼éF‹ø‹5 ²E…Ét€9thôfFhèSÿÖègêÿÿƒ=ÐéF„ÅhgFhèSÿÖƒì‹Ïè·ØÿÿƒÄ…Àu
¹(gFè*Ýÿÿƒ=ÐéF„ƒ=PéFt:hLgFhèSÿÖhhgFhìÿ5pìFÿÖèÿãÿÿ‹ø…ÿt3Ò‹ÏèÓÞÿÿWÿ°Eƒ=ÐéFtDƒ=¨æFt;h|gFhèSÿÖhhgFhìÿ5pìFÿÖè³ãÿÿ‹ð…öt3Ò‹ÎBè†ÞÿÿVÿ°E3Àé·ýÿÿè@ÌU‹ìì¡ÀF3ʼnEüƒ}NS‹]V„»}„c}…ă=ÐéF„€= åF„‚ƒ¥ôþÿÿh¤gFhèSÇ…ðþÿÿ˜gFÿ ²E3ÉŠàéFˆ„
øþÿÿA„ÀuîW½øþÿÿOŠGG„Àuø¾ÔgFº åF¥¥f¥‹òŠB„Àuù½øþÿÿ+ÖOŠGG„Àuø¡ÌéF‹ÊÁéó¥‹Êƒáó¤…ÀtøþÿÿQh€äFhàgFPè-ÚÿÿƒÄhjÿl²E‹=¨²EPÿ׉…äþÿÿøþÿÿ…øþÿÿ‰…ìþÿÿ…èþÿÿP…ìþÿÿPèšæÿÿYY…ÀtPhøgFjè4ÄYPèÏÙÿÿƒÄ‹µèþÿÿ…öt
VhìSÿ ²Eh(hFhèSÿ ²EVèGYÿµäþÿÿÿ×èûÿÿ_ëF¡´éF3ö…ÀtPVhrhSÿœ²E95ÐéFuèëÚÿÿPhìSÿ ²EVVhSÿt²E3À@ë%‹Ex8ÿÿÿujjhpSÿ´²EPÿt²E3À‹Mü^3Í[èÙ<‹å]ÂU‹ìì„¡ÀF3ʼnEüS‹ØéFE¸VWj43öVPè‡R3À‰uì}ðƒÄ«j4«V«E€PèmR‹=d°EƒÄÇE´8ÇE¸Vÿ׉E¼E´‰uЋ5(°EPÇEÌÛ,@ÇEÀkÿÖ‰EìE´PÇE¸ÇEÀlÇEÌM0@ÿÖ‰EðE´PÇE¸ÇEÀmÇEÌù7@ÿÖ‰EôE´PÇE¸ÇEÀnÇEÌË:@ÿÖ3ö‰EøVÇE€4ÿ׉EŒEì‰E E€P‰]ˆÇE„ ‰u¨‰u°‰uœÇE˜ÿ,°E‹Mü_^3Í[è²;‹å]ÃhÀ\Fÿt°E…Àu3ÀÃhxhFPÿ€°E£@ßF…ÀtèÿàU‹ìƒìX¡ÀF3ʼnEü€=ÀéFu3ÀëAhÀéFE¬hbFPÿ|²EƒÄE¨PhjE¬Ph€ÿ°E…ÀuÇÿu¨ÿ°E3À@‹Mü3Íè;‹å]ÃU‹ìì„¡ÀF3ʼnEüjjhøZFhëFhˆhFjÿL²Eƒø ,P…|ÿÿÿhhFPÿ|²EƒÄ…|ÿÿÿjhÌhFPjÿ„²E‹Mü3Íè°:‹å]ÃÌÌÌU‹ìƒäø¸è÷-¡ÀF3ĉ„$SVWÿ5„üF‹=¤°ED$¾»ÌhFVPhøZFhÔhFSÿ×jPT$¹éFèp×ÿÿYÿ5„üFD$VPhøZFhÜhFSÿ×VT$¹€ìFèG×ÿÿYÿ5„üFjPh ìFhøZFhähFSÿ×ÿ5„üF‹5 °EjhðhFSÿÖÿ5„üF£PéFjhiFSÿÖÿ5„üF¾ÀéF£¨æFj
VhøZFhiFSÿ×ÿ5„üFjPh`éFhøZFh iFh(iFÿ×ÿ5„üFhh åFhøZFh4iFSÿ×ÿ5„üF¸àèFj
PhøZFhDiFSÿ×NŠFF„Àuø¡ìZF‹þ¾XiF3ɺàèF‰¶
:uAƒùuñèŠýÿÿ…Àunèþÿÿ韾`iF3ɶ
:uAƒùuñèaýÿÿ…ÀuEèýÿÿ…Àt<ëÌ€=àèFt1¾hiF3ɶ
:uAƒùuñëjhpiFhxiFÿh²EPÿ„²Eè^êÿÿ£ØéFèäûÿÿÿ5TéFÿL±E¡„üF…ÀtPÿx°E¡´éF…ÀtPÿH°E‹Œ$3À_^[3Ìèx8‹å]ÃU‹ì‹E‹‹E‹Š:u„ÒtŠP:QuƒÀƒÁ„Òuä3À]ÃÀƒÈ]ÃU‹ìì`¡ÀF3ʼnEüSVWh…øþÿÿ3ÛPSÿ$±E…øþÿÿP…ôýÿÿh˜iFPè¡Ôÿÿ…ôýÿÿh iFPèý¼‹ðh¤iFVèÔÿÿ…øþÿÿ¿°iFPWVèÔÿÿ…øþÿÿPh¼iFVèòÓÿÿ…ôýÿÿPWVèäÓÿÿƒÄ@V诿jD^V… ýÿÿSPèpMƒÄ‰µ ýÿÿ3ÀÇ…Ìýÿÿf‰…Ðýÿÿ…äýÿÿP… ýÿÿPhèZFSVSSS…ôýÿÿPSÿ”°E…ÀtO‹5X°EjñÿµèýÿÿÿÖjÿp°EPÿÖh€ÿ±EPÿ ±Eÿµäýÿÿ‹5<±EÿÖÿµèýÿÿÿ`°EÿµèýÿÿÿÖ‹Mü_^3Í[èð6‹å]ÃU‹ìQQS‹ÙWSè¹cj[P‰EøèÐE‹øƒÄ…ÿ„™VGj]Wè¹E‹ðYY…ö„‚ÆFj
Vè¡EYY…ÀtÆEüPhjWÿ54ÊFÿ°E…ÀtjhldFSÿh²EPÿ„²Eë1Vÿuüÿ°E…ÀtƒøtjhØiFSÿh²EPÿ„²Eÿuüÿ°EÿuøèY^_[‹å]ÃU‹ìQQS‹ÙWSèóbj[P‰Eøè
E‹øƒÄ…ÿ„™VGj]WèóD‹ðYY…ö„‚ÆFj=VèÛDYY…ÀtpÆEüPhjWÿ54ÊFÿ°E…ÀtjhldFSÿh²EPÿ„²Eë1Vÿuüÿ°E…ÀtƒøtjhðiFSÿh²EPÿ„²Eÿuüÿ°EÿuøèIY^_[‹å]ÃVj:QèUD‹ðYY…öu^ÃF¾PèFY…ÀuñVÿx°E^ÃVj:Qè*D‹ðYY…öu^ÃF¾PèY…ÀuñVÿŒ°E^ÃU‹ìƒì¡ÀF3ʼnEüj[QèðCYY…À„ÄV@j]PèÜC‹ðYY…ö„­SÆ»PßFF‹Ã‹ÎŠ:u„ÒtŠP:QuƒÀƒÁ„Òuä3ÀëÀƒÈ…ÀtrƒeøEìƒeì‹ÎPEðÇEôjFP‰uðècÝÿÿYY…ÀthjFjèþºYPè™ÐÿÿYYW‹}ì…ÿt€?tjhA@jÿµìïÿÿVè­Þ‹=„²EƒÄj$h¬jFhÀjFjÿ׃øt3Àé»3ÉÇ4ÊF€¾øZF‰ðïÿÿ9ìïÿÿŽ÷‹…èïÿÿ‹ˆ‹ÆŠ:u„ÒtŠP:QuƒÀƒÁ„Òuä3ÀëÀƒÈ…À„¦‹…èïÿÿ‹µðïÿÿ‹4°…üïÿÿP…øïÿÿPhkFVèÑÎÿÿƒÄƒøuT•üïÿÿ3ɶ
ºøcF:
•üïÿÿuAƒùuæÇ4ÊF€éEèçÿÿ…À…8jPhkFÿh²EPÿ×éÙ…üïÿÿP…øïÿÿPhtkFVè\ÎÿÿƒÄƒøu‹Îèüÿÿ…À„ÿ…äïÿÿéç…üïÿÿP…øïÿÿPh„kFVè!ÎÿÿƒÄƒøu‹Îè¸ûÿÿ…ÀtVÿ…ôïÿÿé°…üïÿÿP…øïÿÿPh˜kFVèêÍÿÿƒÄƒøtÉ…üïÿÿP…øïÿÿPh°kFVèÉÍÿÿƒÄƒøu‹ÎèÔùÿÿëeÿH±EƒøtZƒøtUCëR…üïÿÿP…øïÿÿPhÄkFVèŒÍÿÿƒÄƒøu	‹Îè]úÿÿë(…üïÿÿP…øïÿÿPhØkFVèbÍÿÿƒÄƒøu‹ÎèOûÿÿ‹ðïÿÿA‰ðïÿÿ;ìïÿÿŒ	þÿÿ‹µàïÿÿÿvÿx°E…Àt	‹…ôïÿÿ@ëCÿH±E‹V‹ÈèMÜÿÿ‹…ôïÿÿ…ÛtSÿµäïÿÿP…üïÿÿhðkFPÿ|²EƒÄëÿµäïÿÿP…üïÿÿhDlFPÿ|²EƒÄj@hhlF…üïÿÿPjÿ×èw÷ÿÿéQýÿÿ3ÀPPhljFPÿ„²E3À@‹Mü_^3Í[è’/‹å]Ãè½0ÌSVW¾¿ëFVW3ÛSÿ$±EVhÀæFSÿ°°Eè£Ýÿÿ£TéF…ÀuÿH±Eº|lF‹Èè}Ûÿÿ3À@éƒìèCÞÿÿƒÄ…Àtè~ôÿÿëz3öF9„üFu5è#à90~,è à‹8èàƒ8tSShPjFSÿ„²EëC‹ÏèÓúÿÿ‹ðë8j\Wè?YY…ÀtƒÀtjh”lFPè#âƒÄºœlF…ÀtºÈlF3ÉèçÚÿÿ‹Æ_^[ÂU‹ìQQS‹]3ÀVW‹ù‰Uü@Áï·ñ;Øu!¶ð¸ñÿ;ðr+ðþ;ø‚ö+øéï…Ò„îƒûs.…Ût
¶ðBþƒëuó¹ñÿ;ñr+ñ3Ò‹Ç÷ñÁâÖ‹Â黸°¹ñÿ;Ø‚Ó‹Ã3Ò¹°÷ñ‰Eø‹Uü¸°+؉]»[¶
¶Bñþ¶Jð¶Bþð¶Bþð¶Bþð¶Bþð¶Bþð¶Bþð¶Bþð¶B	þð¶B
þð¶Bþð¶Bþð¶B
þð¶BþƒÂðþñþƒë…uÿÿÿ‰Uü‹Æ3Ò‹]¹ñÿ÷ñ‹Ç‹ò3Ò÷ñƒmø‹ú…>ÿÿÿ‹Uü…Û„ǃû‚‹ÃÁè‰E‹È¶ƒëð¶Bþð¶Bþð¶Bþð¶Bþð¶Bþð¶Bþð¶Bþð¶Bþð¶B	þð¶B
þð¶Bþð¶Bþð¶B
þð¶Bþð¶BþƒÂðþƒé…rÿÿÿ¹ñÿ…Ût
¶ðBþƒëuó3Ò‹Æ÷ñ‹Ç‹ò3Ò÷ñ‹úÁçþ‹Ç_^[‹å]ÃU‹ìQS3À‹ÚW‹ù9E|9EsƒÈÿëjVP¸ñÿPÿu‰Eüÿuè‹ð·Ï‹ÁÁï¯Æ3Ò÷uü·ÃðÿÁëÈÂñÿ;+ƺñÿ;Êr+Ê;Êr+ʾâÿ;Ær+Æ^;Âr+ÂÁàÁ_[‹å]ÃU‹ì‹EV‹ò™RP‹Öè`ÿÿÿYY^]ÃU‹ìÿuÿuèMÿÿÿYY]ø mFÃU‹ì…Òu3À]Ã]éÌÌÌU‹ìQSV‹u‹Ù÷Ó…ötöÂt¶3ÃÁë¶À3… mFBƒîuãWƒþ ‚Ü‹ÆÁè‰Eü3ƒÂ‹Ã‰UÁè¶È‹ÃÁè¶À‹}‹ qF3… uF‹ÃÁè3… mF¶Ã3… yF3‹ÂÁè¶È‹ÂÁè¶À‹ qF3… uF‹ÂÁè3… mF¶Â3… yF3_‹ÃÁè¶È‹ÃÁè¶À‹ qF3… uF‹ÃÁè3… mF¶Ã3… yF3W‹ÂÁè¶È‹ÂÁè¶À‹ qF3… uF‹ÂÁè3… mF¶Â3… yF3_‹ÃÁè¶È‹ÃÁè¶À‹ qF3… uF‹ÃÁè3… mF¶Ã3… yF3W‹ÂÁè¶È‹ÂÁè¶À‹ qF3… uFƒî ‹ÂÁè3… mF¶Â3… yF3_‹ÃÁè¶È‹ÃÁè¶À‹ qF3… uF‹ÃÁè3… mF¶Ã3… yF3WƒÇ‹Â‰}Áè¶È‹ÂÁè¶À‹ qF3… uF‹ÂÁè3… mF¶Â‹×3… yFƒmü…,þÿÿƒþrH‹þÁï3ƒî‹ÃƒÂÁè¶È‹ÃÁè¶À‹ qF3… uF‹ÃÁè3… mF¶Ã3… yF‹Ùƒïu½_…öt¶3ÃÁë¶À3… mFBƒîuè÷Ó^‹Ã[‹å]ÃU‹ìSV¾ÿ‹Ù#Þ‹ÁÁàØ‹ÁÁãÁè#ÆÁé‹uØÙ÷ÓW…ötöÂt¶‹ËÁé3ÈÁã3 }FBƒîuázüƒþ ‚Ï‹ÆÁè‰E3_‹ÃÁè¶È‹ÃÁè¶À‹ …F3… F‹ÃÁè3… ‰F¶Ã3… }F3W‹ÂÁè¶È‹ÂÁè¶À‹ …F3… F‹ÂÁè3… ‰F¶Â3… }F3_‹ÃÁè¶È‹ÃÁè¶À‹ …F3… F‹ÃÁè3… ‰F¶Ã3… }F3W‹ÂÁè¶È‹ÂÁè¶À‹ …F3… F‹ÂÁè3… ‰F¶Â3… }F3_‹ÃÁè¶È‹ÃÁè¶À‹ …F3… F‹ÃÁè3… ‰F¶Ã3… }F3W‹ÂÁè¶È‹ÂÁè¶À‹ …F3… F‹ÂÁè3… ‰Fƒî ¶Â3… }F3_ƒÇ ‹ÃÁè¶È‹ÃÁè¶À‹ …F3… F‹ÃÁè3… ‰F¶Ã3… }F3‹ÂÁè¶È‹ÂÁè¶À‹ …F3… F‹ÂÁè3… ‰F¶Â3… }Fƒm…9þÿÿƒþrH‹ÖÁêƒÇƒî3‹ÃÁè¶È‹ÃÁè¶À‹ …F3… F‹ÃÁè3… ‰F¶Ã3… }F‹Ùƒêu½ƒÇ…öt¶‹ËÁé3ÈÁã3 }FGƒîuæ÷Óºÿ‹Ã‹ËÁá#ÂÁ‹ËÁéÁà#Ê_ÁëÁ^Ã[]Ã3À…ÒtöÂt3ƒÁÑêuòÃU‹ìQSVW‹ÚÇEü ‹ñ‹û+þ‹7‹ËèËÿÿÿƒmü‰vuë_^[‹å]ÃU‹ìì¡ÀF3ʼnEüS‹]VW‹}‹ñ‰•øþÿÿ…ÿŒ»…Û„³3ÉÇ…|ÿÿÿ ƒ¸í3ÀA@‰Œ…|ÿÿÿÉ@ƒø |ñ•|ÿÿÿüþÿÿèhÿÿÿ•üþÿÿ|ÿÿÿèWÿÿÿ•|ÿÿÿüþÿÿèFÿÿÿ‹ÃƒàƒÈt‹Öüþÿÿèÿÿÿ‹ð¬ûÑÿ‹ÃÇt6•üþÿÿ|ÿÿÿèÿÿÿ‹ÃƒàƒÈt‹Ö|ÿÿÿèäþÿÿ‹ð¬ûÑÿ‹ÃÇu”3µøþÿÿ‹Mü‹Æ_^3Í[è%‹å]ÃU‹ì‹EV‹ò™RP‹ÖèñþÿÿYY^]ÃU‹ìÿuÿuèÞþÿÿYY]ÃU‹ìƒìHS‹ÙVW‰]ð‹K‹;‹CO‹sƒÀûlj}ô‰EÈN‹C‹Øÿþÿÿ+Ú‹Q8ƉEÄÞ‹A(‰EЋA,‰E¼‹A0‰Eà‹A4‰EÌ‹AL‰EÜ‹AP‰EØ3À@‰]À‹Y<‹IT‰EèÓeè‹MðÿMè‰Eä‰Uü‹A‹HX‹EäÓàH‰Eäƒûs ¶G‹ËÓàƒÇЉ}ôK¶ÓàЃÃ‰Uü‹Eè#ÂëöÁu<öÁ@…ž3ÀÁê@ÓàH#Eü‹MÜ‹‹ÂÁè¶ÈÓmü+ٶʄÒuÊFÁêˆéÁêƒá‰Uì‰MÔt+;ÙsG‹Ë‰}ô¶ÓàEüƒÃ‹MÔ3À@ÓàH#EüÓmüЉUì+Ùƒûs&¶G‹ËÓàƒÇEüK‰}ô¶Óà‹MüȃÉMüë‹Mü‹Eä#Á‹MØ‹‰Eøë(öÁ@…‹}Ø3À@Óà‹MøH#EüÁéÁ‹‡‹Á‹}ô‰MøÁè¶ÈÓmü+Ù‹Eø¶ÈöÁtƒáÁè‰Eø‰MÔ;Ùs,G‹ËƒÃ‰}ô¶ÓàEü‹MÔ;ÙsG‹Ë‰}ô¶ÓàEüƒÃ‹MÔ3À+Ù@‰]¸ÓàH#EüÓmü‹ÎEø+MÀ‹Eø‰MÔ;Á†‹È+MÔ;M¼v‹}ð‹G‹}ôƒ¸À…^‹}Ì‹EàO…Àu‹EÐ+Áø;Êsr+щUìGFŠˆƒéuõë[;Ás?+Á+MàEÐø;ÊsN+Ñ+þ‰UìFŠ7ˆƒéuõ‹}Ì‹EàO;Âs1+ЋȉUìGFŠˆƒéuõë+Áø;Ês+щUìGFŠˆƒéuõ‹þ+}øƒúv6Bý3ÒjY÷ñ‹Uì@‰EÔ‹ØŠOˆNŠGƒÇˆFƒÆjŠˆX+Ѓëuà‹]¸…ÒtŠGFˆƒúvŠGFˆ‹}ô;}ȃŠ;uă‹Uüéfýÿÿ‹Îj+È_ŠAIˆF+׊AÿˆFƒÆŠˆƒúwã‹}ô…Òt»ŠAFˆƒúv°ŠAFˆë¨öÁ ‹Mð‹AtÇë(ÇA0—Fë‹Mð‹AÇA—Fë
‹MðÇAø–FÇ‹Uð‹ÃÁè+øÁà+Ø3À@‹ËÓà‹MüH#ÈG‰F‰B‹EÈ+Ç‹ú‹UăÀ+Ö‰G‚‰G‹G_^‰X<‰H8[‹å]Ã…Ét_‹Q…ÒtXV3ö‰r‰q‰q‰q‹B…Àtƒà‰A0ƒŠÄÿ‚0‰2‰r‰r‰r ‰r8‰r<‰Bl‰BP‰BL3ÀÇB€Ç‚À^ÃjþXÃ…Ét‹A…Àt3Ò‰P(‰P,‰P0é~ÿÿÿjþXÃU‹ìQSV‹Ù‹òW…Ût^‹{…ÿtW…öyƒeü÷Þë‹ÆÁø@‰Eüƒþ0}ƒæ…öt
ƒþ|1ƒþ,ƒ4t9w$tÿw4ÿs(ÿS$ƒg4YY‹Eü‹Ë‰G‰w$èvÿÿÿëjþX_^[‹å]ÃU‹ì‹ES‹ÚV‹ñW…Àtt€81uoƒ}8ui…öujþëc3À‰F9F u
ÇF w@‰F(9F$uÇF$”w@hÌjÿv(ÿV ‹øƒÄ…ÿujüë)‰~‹Óƒg4‹Îèÿÿÿ‹Ø…Ût
Wÿv(ÿV$ƒfYY‹ÃëjúX_^[]ÃU‹ìÿuRjZèdÿÿÿYY]ÃU‹ìSVW…Ét>‹q…öt7…Òyƒf8ƒf<3Àë*ƒú"‹~<ƒû w3À‰^<@‹ÊÓà‹ÏH#EÓàF8ëÕjþX_^[]ÃÇAL FÇAT	ÇAP •FÇAXÃU‹ìQ‹Â‹ÑSVW‹r3ÿ3Û‰EüG9^4u#‹N$‹ÇWÓàPÿr(ÿR ƒÄ‰F4…Àu‹Ç錋Eü9^(u‹N$Óç‰~(‰^0‰^,‹~(‹];ßrW+ÇPÿv4èƒÄƒf0‹F(ëO+~0;ûv‹û+ÃWP‹F4F0PèjƒÄ+ßt‹EüS+ÃPÿv4èTƒÄ‰^0ëÄ~0‹N(9N0uƒf0‹F,;ÁsljF,3À_^[‹å]ÃU‹ìƒì
tjþX_^[‹å]Ã>
u3ÉSAè¹ÚÿÿY;Ftjýëà‹EüS‹Ïè^êÿÿY…Àt
ÇjüëÃÇF3Àë¹…Ét‹A…Àtö@t
‰P ƒb03ÀÃjþXÃU‹ìQQSV‹ÙW3ÿ‰]ø‹39}v=‹Úƒþs3Šƒþ¶ÂÉáÿÿÿÁÿ;ÁuFë„Òt3öëjX+Æ‹ðG;}rÈ‹]ø‹Ç‰3_^[‹å]ÃU‹ìQSVW‹ù…ÿ„­‹_…Û„¢ƒu
ƒ{<sjûé‘jX9tE‹S<3ö‹Ê‰ƒáÓc8+щS<ƒúr‹K8ŠC8ƒêˆD5üFÁé‰K8ƒúsê‰StVèƒY„ÀtWjW‹6‹Îè&ÿÖèÙ‹ð9>tVè^Y„Àtÿ6èéêYèÜ·ÀPèNæPWh@è”Ëÿÿ‹ðèö„ÀuVèõê„Ûuè‰êWjè¼YYÇEüþÿÿÿ‹Æë=‹Mì‹‹‰EàQPèsÒYYËeè貄Àuÿuàè[ê€}çuè2êÇEüþÿÿÿ‹EàèÏÃè¯PèŸÝYÃjXÃéêäè:·ÀPè¬åPjh@èñÊÿÿÃèÞé\þÿÿU‹ì¡ÀF‹È3EƒáÓÈ]ÃU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]ÃU‹ì‹E‹MÓÈ]ÃU‹ì‹EV‹H<È·AQзAkð(ò;Öt‹M;Jr
‹BB;ÈrƒÂ(;Öuê3À^]ËÂëùU‹ì‹E…Àu2À]ùMZf9uò‹H<È9PEuå¸f9A”À]Ãd¡Ã者Àu2ÀÃd¡V¾àÎF‹Pë;Ðt3À‹Êð±…Àuð2À^ð^ÃèK…Àtè¨ëèrPèbÜY…Àt2ÀÃè«ã°ÃjèÏ„ÀY•ÀÃè|„Àu2ÀÃèÐ	„Àuèrëí°ÃèÈ	èc°ÃU‹ìèã…Àuƒ}uÿu‹MPÿuèÇÿUÿuÿuè`ÐYY]Ãè³…ÀthäÎFè®YÃèwè…À„JèÃjè}	Yé'U‹ìƒ}uÆüÎFèÙ评Àu2À]Ãè	„Àu
jèÖYëé°]ÃU‹ìƒìV‹u…ötƒþu|è7…Àt*…öu&häÎFèKY…Àt2ÀëWhðÎFè8÷ØYÀþÀëD¡ÀFuôWƒà¿äÎFj Y+ȃÈÿÓÈ3ÀF‰Eô‰Eø‰Eü¥¥¥¿ðÎF‰Eô‰Eøuô‰Eü°¥¥¥_^‹å]ÃjèvÌjh ŸFè·ƒeü¸MZf9@u]¡<@¸@PEuL¹f9ˆ@u>‹E¹@+ÁPQègýÿÿYY…Àt'ƒx$|!ÇEüþÿÿÿ°ë‹Eì‹3É8À”Á‹ÁËeèÇEüþÿÿÿ2Àè€ÃU‹ìè&…Àt€}u	3À¹àÎF‡]ÃU‹ì€=üÎFt€}uÿuèÔÿuèo
YY°]ÃU‹ì¡ÀF‹È3äÎFƒáÿuÓȃøÿuèºëhäÎFèY÷ØYÀ÷Ð#E]ÃU‹ì¡ÀF‹È3ðÎFƒáÓȃøÿu]ékÿuhðÎFèäYY]ÃU‹ìÿuè‰ÿÿÿ÷ØYÀ÷ØH]ÃU‹ìƒìƒeôƒeø¡ÀFVW¿Næ@»¾ÿÿ;Çt
…Æt	÷УÀFëfEôPÿ”±E‹Eø3Eô‰Eüÿ±E1EüÿŒ±E1EüEìPÿˆ±E‹MðEü3Mì3Mü3È;Ïu¹Oæ@»ë…Îu‹Á
GÁàȉ
ÀF÷щ
ÀF_^‹å]Ã3ÀÃ3À@Ã3Àø@Ã3ÀÃ3ÀÃhÏFÿ˜±EÃhÏFè–
YðÃhhj苃Ä…ÀuÃjè8ÌÃÃ讑ÿÿ‹Hƒ‰H覑ÿÿ‹Hƒ‰HÃ3À9ÀF”ÀøhäFødäFÃU‹ìì$SVjè\á…Àt‹MÍ)3ö…ÜüÿÿhÌVP‰5ÏFèƒÄ‰…Œýÿÿ‰ˆýÿÿ‰•„ýÿÿ‰€ýÿÿ‰µ|ýÿÿ‰½xýÿÿfŒ•¤ýÿÿfŒ˜ýÿÿfŒtýÿÿfŒ…pýÿÿfŒ¥lýÿÿfŒ­hýÿÿœ…œýÿÿ‹E‰…”ýÿÿE‰… ýÿÿÇ…Üüÿÿ‹@üjP‰…ýÿÿE¨VPè
‹EƒÄÇE¨@ÇE¬‰E´ÿœ±EVXÿ÷ÛE¨‰Eø…ÜüÿÿÛ‰EüþÃÿ|±EEøPÿx±E…Àu
¶Ã÷ØÀ!ÏF^[‹å]ÃU‹ìƒìDjDE¼jPè 
ƒÄE¼Pÿ ±EöEèt·Eìëj
X‹å]Ã3ÀÃjÿ¤±E‹È…Éu2ÀøMZf9uó‹A<Á8PEuæ¹f9HuÛƒxtvÕƒ¸è•ÀÃhã…@ÿ|±EÃU‹ì‹E‹8csmàu%ƒxu‹@= “t=!“t="“t
=@™t3À]Âè
̃%ÏFÃSV¾tŸF»tŸF;ósW‹>…ÿt	‹Ïè8ÿ׃Æ;órê_^[ÃSV¾|ŸF»|ŸF;ósW‹>…ÿt	‹Ïè
ÿ׃Æ;órê_^[Ãÿ%вEÌÌÌÌÌÌÌÌh`‹@dÿ5‹D$‰l$l$+àSVW¡ÀF1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£òËMðd‰
Y__^[‹å]QòÃU‹ìƒ%ÏFƒì(S3ÛC	ÀFj
è§Þ…À„mƒeð3Àƒ
ÀF3ÉVW‰ÏF}ØS¢‹ó[‰‰w‰O‰W‹EØ‹Mä‰EøñineI‹Eà5ntelÈ‹EÜj5GenuÈXjYS¢‹ó[‰‰w‰O‰WuC‹EØ%ð?ÿ=Àt#=`t=pt=Pt=`t=pu‹= ÏFƒÏ‰= ÏFë‹= ÏFƒ}ø‹Eä‰Eè‹Eà‰Eü‰Eì|2jX3ÉS¢‹ó[]؉‰s‰K‰S‹EÜ©‰Eð‹Eüt	ƒÏ‰= ÏF_^©tmƒ
ÀFÇÏF©tU©tN3ÉЉEô‰Uø‹Eô‹Møƒà3Ƀøu3…Éu/¡ÀFƒÈÇÏFöEð £ÀFtƒÈ ÇÏF£ÀF3À[‹å]Ã3À9`äF•ÀÃË
вE3Àù‘ˆ@•ÀÃÌÌÌÌÌÌÌÌÌÌÌ̃=ÏFr_¶D$‹ÐÁàÐfnÚòpÛÛ‹T$¹ƒÈÿ#ÊÓà+Ñóo
fïÒftÑftËfëÑf×Ê#ÈuƒÈÿƒÂëܼÁÂf~Ú3É:EÁÃ3ÀŠD$S‹ØÁà‹T$÷ÂtŠ
ƒÂ:ËtY„ÉtQ÷ÂuëØW‹ÃÁãVØ‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂáu!%tÓ%uæ€uÄ^_[3ÀÃBÿ[ËBü:Ãt6„Àtê:ãt'„ätâÁè:Ãt„Àt×:ãt„ätÏë‘^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[ÃÌÌÌÌÌU‹ìWƒ=ÏF‚ý‹}ww¶U‹ÂÁâÐfnÚòpÛÛ¹#σÈÿÓà+ù3ÒóofïÒftÑftËf×Ê#Èuf×É#ȽÁÇ…ÉEЃÈÿƒÇëÐSf×Ù#ØÑá3À+Á#ÈI#Ë[½ÁÇ…ÉDÂ_ÉöU…Òt93À÷Çt¶;ÊDÇ…Ét G÷ÇuëfnƒÇf:cGð@LðBÁuí_Éøðÿÿÿ#ÇfïÀft¹#ϺÿÿÿÿÓâf×ø#úufïÀft@ƒÀf×ø…ÿtì¼×Â뽋}3ÀƒÉÿò®ƒÁ÷ÙƒïŠEýò®ƒÇ8t3Àë‹Çü_ÉÃÌÌÌÌÌÌÌÌÌU‹ìV‹uW‹}‹ƒøþt
‹NÏ38èsîÿÿ‹F‹NÏ38_^]é`îÿÿÌÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìƒìSV‹uWÆEÿÇEô‹^F3ÀFPS‰Eì‰]øèÿÿÿ‹}W赋EƒÄö@f…º‰EäEä‰}è‹~‰Füƒÿþ„ÉGG‹Lƒƒ‹‰Eð…ÉteV豈Mÿ…Àxf~U‹E8csmàu7ƒ=läFt.hläFèèۃąÀt‹5läF‹ÎjÿuèaúÿÿÿÖ‹uƒÄ‹E‹Ð‹Îèé9~tlëXŠMÿ‹ûƒûþt‹]øésÿÿÿ‹]øÇEôë$„Ét,‹]øëƒ~þt!hÀFFºþÿÿÿP‹Îè¹ÿuìSè™þÿÿƒÄ‹Eô_^[‹å]ÃhÀFF‹×P‹Î葉^^Sÿuøèkþÿÿ‹MðƒÄ‹Ó‹Iè@Ìèèj
èB„Àu2ÀÃèè„Àuè~ëí°ÃèC…À•ÀÃjèòY°ÃU‹ì€}uèéèPjèU
Y°]ÃèÓ°ÃÃéù&U‹ì]é*'U‹ìÿuèå&Y]ÂU‹ìÿuèÕ&Y]ÂU‹ì‹U‹M‹Eð±]ÃU‹ì‹U‹M‹Eð±]ÃU‹ì‹M3Ò3Àð±]ÃU‹ì‹E‰‹Á]ÂU‹ì‹E‰‹Á]ÂV‹ñÿ6èv&ƒ&Y^ÃV‹ñÿ6èf&ƒ&Y^ø-@ø2@Ã9•ÀÃ9•ÀÃU‹ìÿuè;&Y]ÂU‹ìÿuèe&Y]‹ƒ!ËËÃ9•ÀÃ9•ÀÃV‹ñÿ6è&ƒ&Y^ÃV‹ñÿ6èò%ƒ&Y^ÃU‹ì‹E‹M;Áu3À]ÃÁƒÀŠ:u„ÒtìŠP:QuƒÀƒÁ„ÒuäëØÀƒÈ]ÃU‹ìÿuÿ¬±E…ÀtV‹0Pè—%‹ÆY…öuñ^]ÃU‹ì‹EºÅHë¶À3ÂiГAŠ„Àuî‹Â]ÃU‹ìƒì3É3ÀS‹]ð±…À…¬Vh(h-@h2@PK‰EüQPè]h‹ðƒÄ…ötz‹ÎQŠA„Àuù+Êt€|ÿ u
ÆDÿƒéuïA‰EøƒÀWPè/%‹øY…ÿt7ƒ'GVÿuø‰}ôP‰Eüèº%‹MüƒÄ3Àð±…Àuÿuô3ÿÿuÿ¨±E‹EüW‰Eüè®$Y_Vè¦$‹EüY^[‹å]ÃÌ‹L$¶D$‹×‹|$…É„<iÀƒù Žßù€Œ‹º% ÏFs	óª‹D$‹úú%ÀFƒ²fnÀfpÀσǃçð+Ïù€~L¤$¤$ffGfG fG0fG@fGPfG`fGp¿€é€÷ÁÿÿÿuÅëº%ÀFs>fnÀfpÀƒù róóGƒÇ ƒé ƒù sì÷Átb|9àóóG‹D$‹úÃ÷ÁtˆGƒé÷Áuò÷Át‰ƒÇƒé÷Áøÿÿÿt ¤$›‰‰GƒÇƒé÷Áøÿÿÿuí‹D$‹úÃÌÌÌÌÌÌSVW‹T$‹D$‹L$URPQQh€‘@dÿ5¡ÀF3ĉD$d‰%‹D$0‹X‹L$,3‹pƒþþt;‹T$4ƒúþt;òv.4v\³‹‰Hƒ{uÌh‹Cè‚h¹‹Cè”hë°dƒÄ_^[ËL$÷A¸t3‹D$‹H3ÈèèÿÿU‹hÿpÿpÿpè>ÿÿÿƒÄ]‹D$‹T$‰¸ÃUÿt$èƒÄ‹L$‹)ÿqÿqÿq(è	ÿÿÿƒÄ]ÂUVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹ÁjèÓg3À3Û3É3Ò3ÿÿæU‹ìSVWjRh2’@QèÀÓ_^[]ÃU‹l$RQÿt$è©þÿÿƒÄ]ÂÃÃU‹ìÿuèÐ!Y]ÂU‹ì‹E‰‹Á]ÂV‹ñÿH±E‰‹Æ^ÃV‹ñÿ6è¤!ƒ&Y^Ãÿ1ÿX±EÃ9•À˃!ËÃ9•ÀÃV‹ñÿ6èt!ƒ&Y^ÃU‹ìÿuÿ5 ÀFèé…ÀYY•À]ÃU‹ì‹E…Àt=$ÏFtPè=!Y]ÂU‹ì¡ ÀFƒøÿt'V‹u…öuPèo‹ð¡ ÀFYjPè™YYVè±ÿÿÿ^]Ãè	…À„R"Ã= ÀFÿu3ÀÃSWÿH±Eÿ5 ÀF‹øè%‹ØYƒûÿt…ÛuYjÿÿ5 ÀFèFYY…Àu3ÛëBVj(jèF"‹ðYY…ötVÿ5 ÀFèYY…Àu3ÛSÿ5 ÀFè
YYë‹Þ3öVèp Y^WÿX±E_‹Ã[Ãh×’@è6£ ÀFYƒøÿu2ÀÃh$ÏFPèËYY…Àuèëå°á ÀFƒøÿtPè7ƒ
 ÀFÿY°ÃVW¿LÏF3öjh WèǃÄ…ÀtÿdÏFƒÆƒÇƒþrÛ°ëè2À_^ÃU‹ìkELÏFPÿ´±E]ÃV‹5dÏF…öt kÆW¸4ÏFWÿ¼±Eÿ
dÏFƒïƒîuë_°^ÃU‹ìkELÏFPÿ¸±E]áÀFƒàj Y+È3ÀÓÈ3ÀFÃU‹ì¡ÀF‹È3EƒáÓÈ]ÃU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]ÃU‹ì‹U‹M‹Eð±]ÃU‹ì‹U‹M‹Eð±]ÃU‹ì‹E‹M‡]ÃU‹ì‹E‹M‡]ÃU‹ì‹E‹M‡]ÃU‹ì‹M3Ò3Àð±]ÃU‹ì‹M3Ò3Àð±]ÃU‹ìQŠEÿ‹å]ÃÈÿÃhüãEhøãEhüãEjèöƒÄÃhäEhäEhäEjè܃ÄÃh(äEh$äEh(äEjèƒÄÃh<äEh8äEh<äEj訃ÄÃhXäEhPäEhXäEj莃ÄÃhläEhdäEhläEjètƒÄÃh|äEhtäEh|äEjèZƒÄÃhäEhˆäEhäEjè@ƒÄÃh¤äEhœäEh¤äEjè&ƒÄÃU‹ìV‹uëÿ6è²Y…Àu
ƒÆ;uuì3À^]ÃU‹ì‹E3ÉSVW…xÏF3Àð±‹ÀFƒÏÿ‹Ê‹òƒá3ðÓÎ;÷ti…öt‹Æëc‹u;utÿ6èYY…Àu/ƒÆ;uuì‹ÀF3À…Àt)ÿuPÿ€°E‹ð…ötVèçýÿÿY‡빋ÀFëÙ‹ÀF‹Âj ƒàY+ÈÓÏ3ú‡;3À_^[]ÃU‹ìS‹]3ÉW3Àtƒ>ÿtÿ6ÿ°Eƒ&ƒÆþxÏFuà^]áÀFƒàj Y+È3ÀÓÈ3ÀFÃU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]áÀFƒàj Y+È3ÀÓÈ3ÀF£œÏFÃÃ!‹ÁÃU‹ìSV‹ñW‹}ƒ&ÆFfÿÿÿ‹…É„‰€9t~3Ò‹Š:EtK<_t<<$t8<t0<-t,úÿÿ‹Èè‹E‹å]ÃU‹ì‹V‹uÿu‰‹I‰N‹Îè‹Æ^]ÂU‹ì‹V‹uÿu‰‹I‰N‹Îè°‹Æ^]ÂU‹ì‹V‹uÿu‰‹I‰N‹ÎèÞ‹Æ^]ÂU‹ì‹V‹uÿu‰‹I‰N‹Îè!‹Æ^]ÂU‹ì‹V‹uÿu‰‹I‰N‹Îè`‹Æ^]ÂU‹ìV‹ñ€~0‹Mƒ9u¾A‹ÎPè9ëƒ>u‹‰‹A‰Fë	ÿ1‹Îè6‹Æ^]ÂU‹ìV‹ñ€~=S‹]„Ût4ƒ>uSè÷ûÿÿë'jj¹ÈÏFè$.…ÀtÇ ðEˆXë3ÀP‹Îèç[‹Æ^]ÂU‹ìV‹ñ€~RW‹}…ÿtIS3Û9uWèÑûÿÿë9ŠG„Àt<t¾ÀPèë#Sj¹ÈÏFè½-…Àt
W‹Èè©úÿÿ‹ØS‹Îèƒ[_‹Æ^]ÂU‹ìS‹Ù€{NW‹}…ÿtE€?t@V3ö93uWè°ûÿÿë0Vj¹ÈÏFèi-…Àt€?tF€<>uùVW‹Èèúÿÿ‹ðV‹Ëè"^_‹Ã[]ÂU‹ìV‹ñ€~-ƒ>‹Etƒøtƒøt…ÀtPè¬QYP‹ÎèèëPènûÿÿ‹Æ^]ÂU‹ìV‹ñƒ>	t8W‹}ƒ?t.jj¹ÈÏFèÛ,‹Ð…Òt‹‰
‹O‰Jë3Ò…Òtÿ‹‰T†_‹Æ^]ÂU‹ì€yt
‹EŠ@<~ˆA‹Á]ÂU‹ì‹E‰‹E‰A3À‰A‰A‰A]ÂW‹ùƒt.‹G‰G…Àt$V‹G‹w‹Îÿw‹‰GèBáÿÿÿÖ‹G‰GY…ÀuÞ^_ÃU‹ì¡¼ÏF÷Ш‹E‹…ÀäEuƒÀ]ÃU‹ìVW‹}‹ñ…ÿt.jj¹ÈÏFè,…Àt‹ƒHÿÇ`ðE‰H‰xë3À‰…ÀuÆF_^]ÂU‹ìƒì`eÔÿÿ3ÀSW‰Eü‰EÐèØG‹}‹Ø3À3É@9t÷G‰Eìu‰Mìûÿÿu‹Mjèƒöÿÿ‹Eé£ûþÿuWPÿuèüÿÿƒÄëáûýÿu‹E‹‰‹O‰HérV‹ó怉uØ„–‹Ã3Ò%=‰Eà‹Ã”‰Uø…Òt%ë%…Àt‹Ã%=„W‹Ã…Òt%ë%…Àt‹Ã%=„/=„$÷Ã@t^‹
¼ÏFÁé
¼ÏFÑé÷ÑöÁt.E¸PèYPE°Pj MÀèÚôÿÿ‹ÈèVûÿÿ‹E°‰EЋE´‰EÔëE°PèìYPMÐèÂýÿÿ‹Uø3ɋþ…Òt%ë#Æ…À„}à…QE°PèYYE°‹ÏPE¸Pj{EÀPèûÿÿ‹ÈèßúÿÿPMÐè€ûÿÿE°PèSIY…5¼ÏFu>E°PE¸Pj,MÀè/ôÿÿ‹Èè«úÿÿ‹E¸M°‰E°‹E¼híE‰E´è4üÿÿE°PMÐè0ûÿÿhíEMÐèüÿÿE°Pè¹Y‹
¼ÏF‹ÁÁèÁÑè÷Ш„Ö…Î…ÎE°PE¸Pj MÀè¹óÿÿ‹Èè5úÿÿ‹E¸M°‰E°‹E¼j ‰E´èûÿÿ‹E°M¸‰E¸‹E´‰E¼EÐPè±úÿÿ‹M¸‹}¼éú¸ÿÿ‰M¸!E´‹u´!E¼#ð!EÌ!EċÉuྉM°‰MȉMä‰MÀ…Òt%ë#Æ…À„—…Òtw‹Ã%=u>EÜjPè‹E܉E¸‹Eà‰E¼EÜjPè‹E܉E°‹Eà‰E´EÜjPèïƒÄë…Òt'‹Ã%=uEÜjPèÍYY‹E܉EÈ‹Eà‰EÌEÜjPè´‹EÜ‹UøY‰Eä‹EàY‰Eà…Òt@‹Ã%=t2¡¼ÏFƒà`<`EðPtèŒCY‹‹@‰MÀ‰EÄëèyCYPMÀèjûÿÿ‹
¼ÏF‹ÁÑè÷Шt0Áé÷ÑöÁt&EÐPEðPE¨PèûY‹Èèªøÿÿ‹‹@‰MЉEÔëE¨PèÝYPMÐèûÿÿ3É9t>9MÐt.…5¼ÏFu&WEðPj M¨èåñÿÿ‹ÈèaøÿÿEðPMÐèÿøÿÿ3É닉EЋG‰EÔ‹}¬çÿÿ‰Môƒ}ìQtNE¨Pè¼3YYPEèPhíEM èòÿÿ‹ÈèøÿÿEèPMÐè­øÿÿ…5¼ÏF…P3ö‹Mø‹Ã…ÉtI%ëGj¹ÈÏFè'‹È‰Mô…Ét3ÀˆAaÿÿÿ‰ë3ö‹Î‰uôQE PèA3YY‹0‹x‰uüë®%…À„…É„Ú‹Ã%=uzE¸PEèPh íEM èañÿÿ‹Èèd÷ÿÿ‹EèM¸‰E¸‹Eìj,‰E¼è;øÿÿ‹E¸Mè‰Eè‹E¼‰EìE°Pèà÷ÿÿ‹EèM°‰E°‹Eìj,‰E´è
øÿÿ‹E°M¸‰E¸‹E´‰E¼EÈPè²÷ÿÿë.…ÉtN‹Ã%=u@EÈPE¸Ph0íEM èÕðÿÿ‹ÈèØöÿÿ‹E¸M°‰E°‹E¼j,‰E´è¯÷ÿÿE°PMÐè`÷ÿÿë
h<íEMÐèIøÿÿ‹EäM°‰E°‹EàhíE‰E´è0øÿÿE°PMÐè,÷ÿÿE PèD	YPE¸Pj(M¨èæïÿÿ‹Èèböÿÿ‹E¸M°‰E°‹E¼j)‰E´è9÷ÿÿE°PMÐèêöÿÿ‹Eø…Àt‹Ã%=tEÀPMÐèÉöÿÿ¡¼ÏFÁè÷ШE Ptè¨0YPMÐè¨öÿÿëè—0YPMÐèzøÿÿ¡¼ÏFÁè÷ШE Ptè¢@YPMÐèvöÿÿëè‘@YPMÐèHøÿÿE PèkYPMÐè5øÿÿ¡¼ÏFÁè÷Шt‹Mô…Ét‹EЉ‹EÔ‰A‰uÐé„‹EЋ}Ô‰EüéyWMÐèöÿÿ¹|…öu}‹Ã#Á=ht…öun‹Ã#Á=puEÐPÿuèfDël=`uN3öEÀVP觋EÐYY‰E°M°‹EÔj{‰E´èúõÿÿ‹E°M¸‰E¸‹E´‰E¼EÀPèŸõÿÿhíEÿuM¸èKõÿÿë‹Ã%ü;ÁuEÐPÿuè¢CYY‹Eé‹Ã¿…öt	#Ç-ë%`÷غÀ@…À‹Ãt%ë#Â…Àt"‹Ã‹Î%+Â÷ØÀ@÷ÙÉ…Èt
hHíEéš‹Ã…öt	#Ç-ë%`÷ØÀ@…À‹Ãt%ë#Â…Àt"‹Ã‹Î%-÷ØÀ@÷ÙÉ…ÈthlíEëL‹Ã…öt	#Ç-ë%`÷ØÀ@…À‹Ãt%ë#Â…Àt7‹Ã‹Î%-÷ØÀ@÷ÙÉ…Èth íEMÐèjõÿÿ…öt0‹Ã#Ç-ë,…öuñ‹Ã%|=xuß‹E‹MЉ‹MÔ‰Héë‹Ã%`÷ØÀ@…À‹Ãt%ë%…Àt\‹Ó3Àâ‹Îú”À÷ÙÉ…Èu3À‹Îú”À÷ÙÉ…Èt*EÐPE°PhíEM è!íÿÿ‹Èè$óÿÿ‹E°‹}´‰Eü‰EÐëEÐPE PèôYY‹‹x‰MЉMü‰}Ô‹uØ‹Ã…öt%-ë%`÷ØÀ@…À„Ž¡¼ÏFÁè	÷Ш„b‹Ã…öt%-ë%`÷ØÀ@…ÀtI…öt‹Ã%-÷ØÀ@ë3À@…Àt+EÐPE°PhÐíEM ècìÿÿ‹Èèfòÿÿ‹E°‹}´‰Eü‰EЉ}Ô‹Ã…öt"%=„¸‹Ã¹#Áº+Âë%`¹º÷ØÀ@…À‹Ãt%ë%…À„£‹Ã…öt#Á+Âë%`÷ØÀ@…Àt‹Ã%=tP‹Ã…öt#Á+Âë%`÷ØÀ@…Àt‹Ã%=t(‹Ã…öt#Á+Âë%`÷ØÀ@…Àt9‹Ã%=u+EÐPE°PhØíEM èjëÿÿ‹Èèmñÿÿ‹E°‹}´‰Eü‰EЉ}Ô¡¼ÏFÁè÷Ш„‹Ãº…öt	#Â-ë%`÷ØÀ@…Àt3…öt
‹Ã3É$À<@”Áë‹Ë#Êé÷ÙÉA…ÉtEÐPE°PhäíEëN‹Ã…öt	#Â-ë%`÷ØÀ@…ÀtN…öt
‹Ã3É$À<€”Áë‹Ë#Êé÷ÙÉA…Ét*EÐPE°PhðíEM è—êÿÿ‹Èèšðÿÿ‹M°‹}´‰MЉ}ÔëK‹Ã…öt	#Â-ë%`÷ØÀ@…Àt+…ötjöÃÀX”Àë	‹Ã#Â÷ØÀ@…ÀtEÐPE°PhüíE뛋Mü‹Ã…öt%-ë%`÷ØÀ@…À‹Ãt%ë%…Àt4÷¼ÏFu(EÐPE°PhîEM èäéÿÿ‹Èèçïÿÿ‹M°‹}´‰MЉ}Ô÷Ãt"EÐPE°PhîEM è´éÿÿ‹Èè·ïÿÿ‹M°‹}´‹E‰‰x^_[‹å]á¼ÏFÁè÷Ѓàá¼ÏFÁè÷Ѓàá¼ÏFÁè÷Ѓàá¼ÏFÁè÷Ѓàá¼ÏFÁè÷Ѓàá¼ÏFÁè÷Ѓàá¼ÏFÑè÷Ѓàá¼ÏFÁè	÷Ѓàá¼ÏF%á¼ÏF%ÃU‹ìV‹ñW3ÿ9>tfÿÿÿÆF‰>ëhS‹]…Ût[9}tV‹E+ÇtI¹ÈÏFWƒètjè…Àt
ÿu‹ÈSèKëÿÿ‹ø‰>…ÿëjèý…Àt
ŠÇ ðEˆHë‹Ç‰…Àu
ÆFëÆF[_^]¡¼ÏFÁè÷Ѓàá¼ÏFÁè÷ЃàË
¼ÏF3Àƒá`€ù`•Àá¼ÏFÁè÷Ѓàá¼ÏF% á¼ÏF÷ЃàÃU‹ìƒìSV‹u3ÛCƒ&ÆFfÿÿÿ€~…Þ¡¬ÏFWŠ€ù@„Ì€ùZ„Ã…Ût3Ûëj,‹ÎèÝîÿÿ¡¬ÏFŠ„É„š¾Éƒé0ƒù	w @£¬ÏFEèQ‹
 ÏFPèŸëÿÿP‹Îèbîÿÿë^ƒeø‹øeüÿÿEøPEðPè.$¡¬ÏF+ÇYYƒø~‹
 ÏFƒ9	t	EðPè½ïÿÿEð‹ÎPèîÿÿ¡¬ÏF;Çufÿÿÿƒ&ÆF¡¬ÏF€~„4ÿÿÿë	j‹ÎèAïÿÿ_‹Æ^[‹å]ÃU‹ì¡¬ÏFƒì¾ƒéX„¯Iƒé„„EøPèÊþÿÿ‹UüY„Òuf¡¬ÏFŠ„Ét[€ù@tP€ùZt‹Mjèçÿÿéƒ@£¬ÏF¡¼ÏFÁè÷Ш¸îEu¸˜îEPEðPMøèíÿÿ‹U‹‰
‹H‹Â‰JëJ@£¬ÏF‹E‹Mø‰‰Pë7@£¬ÏF¡¼ÏFÁè÷Ш¸°ìEu¸„îEPë@£¬ÏFh”ìE‹MèRæÿÿ‹E‹å]ÃU‹ì¡¬ÏFƒì0€8V„Nè	‹ð…öy3ö…öuEàj]PEèMðé ‹Eüƒeø%ÿÿW‹}‰Eü÷GthçEMøè—íÿÿ‹Eü<\‹ÆN…ÀtU¡¬ÏF€8tKEØjPèTYYPEðPj[MÐè>åÿÿ‹Èèºëÿÿ‹EðMè‰Eè‹Eôj]‰Eìè‘ìÿÿEèPMøèBìÿÿ€}ü~¤ƒ?tr÷GtEø‹ÏPEÐPèuëÿÿ‹‰Mø‹@ëMWEèPj(MÐèÙäÿÿ‹ÈèUëÿÿ‹EèMð‰Eð‹Eìj)‰Eôè,ìÿÿ‹EðMè‰Eè‹Eô‰EìEøPèÑëÿÿ‹Eè‰Eø‹Eì‰EüEøPEàPè !‹E‹UäYY‹Màʉ‰P_éš‹Eƒ8t`PEàPj(MÐèXäÿÿ‹ÈèÔêÿÿ‹EàMè‰Eè‹EähôïE‰Eìè]ìÿÿ‹EèMð‰Eð‹Eìj‰Eôè¨ìÿÿ‹EðMø‰Eø‹Eôj]‰Eüè|ëÿÿEøë$EÐj]PEØMàjPj[èñãÿÿ‹Èèõêÿÿ‹ÈèˆêÿÿPÿu裋EYY^‹å]ÃU‹ìƒìjèEíÿÿYPMøè2äÿÿ‹
¬ÏFŠ„ÀtM¾ÀA‰
¬ÏFƒè0t/Hƒètƒèu=‹Mjè<äÿÿ‹EëIEðPè)YPMøèžêÿÿëh”ìEMøè‡ëÿÿë
jMøèÜëÿÿh îEMøènëÿÿ‹E‹Mø‰‹Mü‰H‹å]ÃU‹ì‹
¬ÏFƒìŠSVW„À„–ƒeô¿ÿÿ!}øAjN¶ðƒËÿZ‰
¬ÏFÆEÿ;òwN„VF½ƒø
‡¶€{¼@ÿ$…c¼@h¸îEMôèÈæÿÿé@hÀîEëìhÈîEëåhÌîEëÞhÔîEë׃þO„ø†ÍƒþS†½ƒþX„ªƒþ_…²ŠA¶Ã‰
¬ÏF;‡¦„™ƒøGwkƒøFs_…ÀtEƒø$tƒÀ¼ƒø‡ÓhìîEMôè7æÿÿé²ÿuEäPèôþÿÿPhDïEÿuèXèÿÿƒÄéI‰
¬ÏFMôjè1æÿÿézhôîEë´ƒøHr}ƒøIvƒøKvƒøMwnhïEë™hïEë’hüîEë‹häîE넃øOtƒøRtpƒøStaƒøUtRƒøWtCƒÀ¨ƒøw1EäIP‰
¬ÏFèBY‹‹P‰Mô‰Uø…É…þ‹E‰‰PéhLïEé(ÿÿÿh<ïEéÿÿÿh0ïEéÿÿÿh$ïEé
ÿÿÿhïEéÿÿÿjþ[‹Mƒeô!}ø‹‰Eä‹A‰Eèƒûþ…D¾ƉEèEähøZFPEôPEìPè!‹UðƒÄ…ÖuhçEMìèéÿÿ‹Uð‹Mìé^ÿÿÿh”ìEéþÿÿ‹Þƒãë?EäIP‰
¬ÏFèk
Y‹‹P‰Mô‰Uø…Éu(é(ÿÿÿh<îEMôè™äÿÿhÜîEMôè¶èÿÿƒûÿ…GÿÿÿŠ]ÿƒîCt?jY+ñt)+ñt%+ñt!+ñtƒîuO¶ÃƒèEt+Át+Át+Át+Áu7EôPEäPhDîEë
EôPEäPhTïEMìè¥àÿÿ‹Èè¨æÿÿ‹Eä‰Eô‹Eè‰Eø‹Eƒ8t"PEäPj Mìèàÿÿ‹Èè~æÿÿEäPMôèçÿÿ‹E‹Mô‰‹Mø‰Hëjƒ9u8öÃt!h\ïEMôèÃãÿÿöÃt!hdïEMôèÛçÿÿëöÃt
hXîEMôèãÿÿh çEEäPEôPÿu蘃ÄëÿujÿuèÚåÿÿƒÄ‹E_^[‹å]ÃIô¸@¹@
¹@¹@¹@þº@U‹ìjÿuè@
‹EYY]ÃU‹ìQQ¡¬ÏFŠ„É„š¾ÉƒéA@£¬ÏFjƒù‡…‹Eüƒeø%ÿÿZ‰Eü¡¼ÏFÑè÷ШtTƒáþƒùw&t ƒét+Êt+Êt+Êu9jë&jë"Rëjëjëƒét+Êt+Êujëjëjè"èÿÿYPMøè‘âÿÿ‹E‹Mø‰‹Mü‰Hë
j‹Mè/ßÿÿ‹E‹å]ÃU‹ìƒìT‹EÈ%ÿÿÆEÿ‰Eø¡¬ÏFSVWŠ„À„t‹u<$u,VEÿPEPEÌPèú‹M̃Ä…Ét‹E‰‹MЉH顬ÏF3ÉŠÿÿÿjMìè:ãÿÿ‹Uð¡¼ÏFÑè÷Ш‹Ãt5ƒà<uK…ö…ÿÿÿEìPE¬PE´Pè²öÿÿY‹Èèýàÿÿ‹‹P‰Mì‰Uðëƒà<uE¬PèöÿÿYPMìècãÿÿ‹UðöÃt(EìPEÌPh¼ïEM¬è¯Úÿÿ‹Èè²àÿÿ‹EÌ‹UЉEì‰UðöÃt(EìPEÌPhÈïEM¬è‚Úÿÿ‹Èè…àÿÿ‹EÌ‹UЉEì‰UðŠEþ„Àt"‹EìMÔhÐïE‰EÔ‰UØèþáÿÿ‹EÔ‹U؉Eì‰UðŠEý„Àt"‹EìMÔhÔïE‰EÔ‰UØèÕáÿÿ‹EÔ‹U؉Eì‰Uð¿…ö…’‹u3É9t]…~uB‹E9t;PEÔPj M¬èsÙÿÿ‹Èèïßÿÿ‹EÔM̉EÌ‹EØj ‰EÐèÆàÿÿVE´PMÌèÌßÿÿë6÷Ft
‹‹V‰Eìë/Vë‹E9t%PEÄPj M¬èÙÿÿ‹Èè—ßÿÿEÄPMìè5àÿÿ‹Uð×€}ÿtÊ ‹E‹M쉉P鎋E‰‹MÈé·úÿÿƒ}un‹uƒ>t[÷FuB‹Eƒ8t:PEÄPjM¬è_Ùÿÿ‹Èè(ßÿÿ‹EÄM̉EÌ‹EÈj ‰EÐèÿßÿÿVÿuMÌèßÿÿë%VjÿuèÕÞÿÿƒÄë‹Eƒ8tPëæj‹MèÙÿÿ‹E_^[‹å]ÃU‹ìƒì3ɸÿÿ!Eü!EôEøQPhøZFEð‰MøPÿu‰Mðè®ùÿÿ‹EƒÄ‹å]ÃU‹ìƒìMøÿuè4Øÿÿ¡¬ÏFŠ„É„“€ù?tI€ùXtEøPÿuèøYYéŽ@ƒ}ø£¬ÏFu‹Mh”ìEè<ØÿÿësEøPÿuMðhPîEè&ØÿÿëVƒeð@eôÿÿ£¬ÏFEðjPhøZFEøPEèPè
ùÿÿ‹‰Mø‹@‰EüEøPÿu考ÄëEøPÿuMèjèØÿÿ‹ÈèÑÝÿÿ‹E‹å]ÃU‹ì¡¼ÏFƒì$SV¾ W…Æt0%ÿßÿÿ£¼ÏFEÜjPèÿÿÿ	5¼ÏFYY‹E‹M܉‹Mà‰Héþ¡¬ÏFŠ€ù?…Ý@£¬ÏF8u#8HuEÜPè‘ÿÿÿ¡¬ÏFYë@£¬ÏF€8uõë°EôPèI ‹uô3À‹]ø@Y…öt
÷Ãt‰Eüëƒeü‹ûÁï#ø€û~
‹E‰0‰X逡¬ÏFŠ„À„Ò<@„ÊEÜP見EÜY…À„µ€=ÀÏFtrEÜÆÀÏFPMì‰uì‰]ðèaÝÿÿ¡¬ÏF‹uì‹]ð‰uô€8@‰]øt}EÜPèYÇ$(ìE‹‹@‰MìMì‰Eðè Þÿÿ‹EìMä‰Eä‹Eð‰EèEôPèÝÿÿ‹uä‹]èë4‰EäMä‹Eàh(ìE‰EèèêÝÿÿ‹EäMì‰Eì‹Eè‰EðEôPèÚÜÿÿ‹uì‹]ð‰]ø‰uô‹Mü…Ét
…öt	ˉ]øº€…ÿtÚ‰]ø…ö„èþÿÿ¿…ß…Ûþÿÿ¡¬ÏFŠ„Àt<@tjëJÿ¬ÏF…=¼ÏFt&…Éu"…Úu!MÜEÜeàÿÿPEäPèßÿÿYYé”þÿÿEôPÿuèüÞÿÿYYë„Éu´j‹Mè¸Õÿÿ‹E_^[‹å]ÃU‹ì‹
¬ÏFƒìV3ö€9QW‹þuA¿tìE‰
¬ÏFŠ„Àu‹Mjè{Õÿÿ‹Eéö<0|L<9H¾Àƒè/A™‰
¬ÏFRP…ÿtMøè8ÖÿÿPEðWPèÌÚÿÿƒÄëMèè Öÿÿ‹Ð‹E‹
‰‹J‰Hé¦S‹Þë)„ÀtEÙÿÿ‹Eð‰Eø‹Eô‰EüëhïEëhˆïEëh€ïEMøèÖÿÿƒeð!]ô…öt‹Eø‰Eð‹Eü‰EôEøPè”YEøPMðè’Ùÿÿ‹E‹Mð‰‹Mô‰HëI‰
¬ÏF‹MhqïEèºÒÿÿ‹E^[‹å]ÃU‹ìÿuèO‹EY]ÃU‹ìƒì¡¬ÏFƒeøeüÿÿŠ„À„™¾ÀƒÀЃø‡†ÿ$…sÊ@h$îEëh,îEëh4îEëh<îEMøèÊÕÿÿ¡¬ÏF¾ÿ¬ÏFƒè1tHƒètHƒètHƒèu(EøPEðPhDîEMèèÒÿÿ‹ÈèØÿÿ‹Eð‰Eø‹Eô‰Eü‹E‹Mø‰‹Mü‰Hëjëj‹MèÒÿÿ‹E‹å]ËÿÝÉ@ÝÉ@äÉ@äÉ@ÿÉ@ëÉ@òÉ@òÉ@U‹ìƒì‹¬ÏFSV‹uü3Ûæÿÿ‰]øB‰uü‰¬ÏFWŠ
¾ù‹ÇƒèA„'ƒè„òƒè„Þ„É„ÒŠB„À„Ç9]…ÒOЃÂÁáƒÁоøù‰¬ÏFƒÿv&j,Møè6ÔÿÿSWMðèBÒÿÿPEèPMøè×ÿÿ‹‹pj>Mð‰]ð‰uôèô×ÿÿ¡¬ÏF‹Uð‹Mô‰Uø€8$‰Müu@£¬ÏFë!‰MôMðj^‰UðèÆ×ÿÿ‹Uð‹Mô¡¬ÏF‰Uø‰Mü€8t@£¬ÏFëjMøè´Øÿÿ‹Mü‹Uø‹EÉ@‰‰Hëjë‹EÇ@çEë$9]tj‹Mè­Ðÿÿ‹Eë\‹EMøj>ÆèkÓÿÿÿ¬ÏFë59]u)‹M‹€8&uÇ@çE‹¬ÏF‹€8*uÇ`çE‹¬ÏFB‰¬ÏF‹EˆX`ÿÿÿ‰_^[‹å]ÃU‹ìƒì¹ÈÏFVjjè@‹ð…ötƒ&ÆFfÿÿÿë3öVÿuèC÷ÿÿEðPè÷ÿÿ‹EðMøƒÄ‰Eø‹Eô‰Eüj èªÖÿÿÿuEèPMøè®Õÿÿ‹‰‹H‹E‰N^‹å]ÃU‹ì‹
¬ÏFƒì8Š„ÀuÿujÿuèYÕÿÿƒÄ‹EéÛ<6|<9~<_t‹MjèŒÏÿÿëàS¾Øƒë6A‰
¬ÏFƒû)u/Š„Àt¾Øƒë=A‰
¬ÏFƒû| ƒûëÿujÿuèùÔÿÿƒÄë…Ûxƒû~ƒËÿƒûÿu‹Mjè-Ïÿÿ‹Eé]ƒeðeôÿÿV‹uW‹û‹‰Eø‹F‰Eüƒç„ì€9@„¢EøPEèPh(ìEMàè§Îÿÿ‹ÈèªÔÿÿ‹Eè‰Eø‹Eì‰Eü¡¬ÏF€8tCEÐPèLYPEàPj MÈèøÍÿÿ‹ÈètÔÿÿ‹EàMè‰Eè‹Eä‰EìEøPèÕÿÿ‹Eè‰Eø‹Eìë"EøPEàPjMÈèoÎÿÿ‹Èè8Ôÿÿ‹Eà‰Eø‹Eä‹
¬ÏF‰EüëA‰
¬ÏFŠ„À„¤<@…•¡¼ÏFAƒà`‰
¬ÏF<`EÈPtmèY‹‹@‰Mð‰EôöÄ—¡¼ÏFÑè÷ШEÈPtwèqéÿÿYPEàPj MÐè1Íÿÿ‹Èè­Óÿÿ‹EàMè‰Eè‹Eä‰EìEøPè?Ôÿÿ‹Eè‰Eø‹Eì‰EüëDèYPMðèÖÿÿë“jéÊEøPÿuMÈjèŽÍÿÿ‹ÈèWÓÿÿéµèúèÿÿYPMøèÐÕÿÿ¡¼ÏFÑè÷Шt&EøPEÈPEÐPèníÿÿY‹ÈèÓÿÿ‹‹@‰Mø‰EüëEÈPèPíÿÿYPMøèŠÕÿÿ3Û9t;EøPEàPj(MÈèbÌÿÿ‹ÈèÞÒÿÿ‹EàMè‰Eè‹Eäj)‰EìèµÓÿÿ‹Eè‰Eø‹Eì‰EüSj¹ÈÏFèï‹ð…ötˆ^fÿÿÿ‰ë‹óEØVPè!EÈPèQåÿÿƒÄMÐPEàPj(èñËÿÿ‹ÈèmÒÿÿ‹EàMè‰Eè‹Eäj)‰EìèDÓÿÿEèPMøèõÒÿÿ‹
¼ÏF‹Áƒà`<`t…ÿtEðPMøèÖÒÿÿ‹
¼ÏFÁéEÈ÷ÑPöÁtè³YPMøè³Òÿÿëè¢YPMøè…Ôÿÿ¡¼ÏFÁè÷ШEÈPtè­YPMøèÒÿÿëèœYPMøèSÔÿÿ…öt‹Eø‰‹Eü‰F‹E‹M؉‹M܉Hë
j‹MèÍËÿÿ‹E_^[‹å]ÃU‹ìjÿuèöÿÿ‹EYY]ÃW‹9…ÿu2À_ËV‹p‹Î蘵ÿÿ‹ÏÿÖ^_Ãy•ÀþÈ$ ÊAËI…É…Æÿÿÿ2ÀÃS‹ÙVW‹{‹‹p‹Îè_µÿÿ‹ÏÿÖ„Àu‹{‹‹p‹ÎèHµÿÿ‹ÏÿÖ_^[ËQ…Òt‹AŠDÿÃ2ÀÃU‹ìƒìEðjPènõÿÿYYPEøPj`MèèXÊÿÿ‹ÈèÔÐÿÿj'ÿuMøèéÐÿÿ‹E‹å]ÃU‹ìV‹uƒÆƒæøƒ}W‹ùtV‹7‹ÎèÑ´ÿÿÿÖYëc…öuj^‹GS;ÆsE»;ów8jh¹ÈÏFè²ÿÿÿ…Àtƒ ë3À…Àt‹O…Ét‰ë‰G+Þ‰G‰_ë	3Àë+ƉG‹GƒÀG[_^]‹
¬ÏFŠ„Àu3ÀÃ<0|<9¾Àƒè/A‰
¬ÏFÃ3Òë „Àtßu
j Mðè¿Ïÿÿj>MðèµÏÿÿ‹E…ÀtÆ‹5¬ÏF8u‹E‹Mð‰‹Môéyÿÿÿ‹]ðF‰5¬ÏFWEØWPè ƒÄ‹‹P‰Mø‰Uü‰5¬ÏF…Ét+€~ÿ1u%EøPEàPj~MØèÜÇÿÿ‹ÈèXÎÿÿ‹Mà‹Uä‰Mø‰Uü…ÛtEðPMøèæÎÿÿ‹Uü‹Mø‹E‰‰PéÿÿÿN‰5¬ÏFj‹MèHÈÿÿ‹EéèþÿÿƒøB„)ŽÓƒøZŽƒø_…Á¾F‰5¬ÏFƒøOÕƒøDÕƒø9ft@…ÀtŸƒø/Ž‘ƒø6~ƒø8ƒ¾Fÿÿ4…ÀäE‹Mè”Çÿÿ넾Fÿÿ4…ÀäEé þÿÿ¾FÿMàÿ4…ÀäEèoÇÿÿ‹UäÊ€‹Màé2ÿÿÿƒø?t9ƒø@Ž,ƒøBŽSƒøC…jhÜçEEàPèj‹UäƒÄÊ뺾F‰5¬ÏF…À„ïþÿÿƒø0…áWhXìEëƃøTëƒøS÷ƒèP„‡ƒè„ýÿÿƒè…¬¾FÿMøÿ4…¤äEè?Êÿÿ¡¬ÏFŠ„ÀujÿuMøè7Íÿÿé’þÿÿ¾Àƒè0ˆpƒøƒgÿ4…<æEMðèþÉÿÿ‹
¬ÏF¾A‰
¬ÏFƒø0„Ƀø1tƒÀ΃ø†5I‰
¬ÏFé.þÿÿ‹EøMè‰Eè‹Eü‰EìEðPèâÌÿÿj,EØPEàPèÃY‹ÈèCÌÿÿPMèèÂÌÿÿj,EØPEàPè£Y‹Èè#ÌÿÿPMèè¢Ìÿÿj,EØPEàPèƒY‹ÈèÌÿÿPMèè‚Ìÿÿj)EØPEàWPèJðÿÿYY‹ÈèáËÿÿPMèè`Ìÿÿj'ÿuMèèËËÿÿéŒýÿÿEØWPèþìÿÿ‹EØYY‰EèMè‹EÜj ‰EìèoÌÿÿ‹EèMà‰Eà‹Eì‰EäEøPèÌÿÿMàëA¾FÿMøÿ4…¤äEèÊÈÿÿWEØWPèvûÿÿƒÄ‹‹@‰Mð‰Eô…Ét©tjéýÿÿMøEðPÿuèËÿÿéûüÿÿƒøVŽƒøW~׃øYŽþƒø_uɾF‰5¬ÏFƒøA|ºƒøDŽÑƒøF~^ƒøJŽÃƒøKuž¾FÿMàÿ4…åEè¯Äÿÿë<@t A‰
¬ÏFMàPèËÿÿ‹
¬ÏFŠ„Àuà<@uA‰
¬ÏF‹E‹Mà‰‹MäéQûÿÿ¾FÿMèÿ4…åEè_Äÿÿ¡¬ÏF€8?EØPu!èŒìÿÿYPMèèöÊÿÿ¡¬ÏF€8@u@£¬ÏFëèA
YPMèèÕÊÿÿhpìEMèèÀËÿÿ‹E‹M艋Mìéãúÿÿ¾Fÿÿ4…åEéXüÿÿ¾Fÿÿ4…¤äEéHüÿÿ¾Fÿÿ4…¤äEérúÿÿ3ÿG¾FÿMøÿ4…äEè@Çÿÿ…ÿ„\úÿÿƒ}ø„€úÿÿMüétúÿÿU‹ìh çEÿuÿuÿuè‹EƒÄ]ÃU‹ìhøZFÿuÿuÿuèþ‹EƒÄ]ÃU‹ìƒì‹
¬ÏFºÿÿ!UüVW¾3ÿ‰}ø+Ç„µƒè$tr‹uƒèt6ƒètVÿuèsßÿÿYYé£hXîEMøè‘Æÿÿ9>t
j MøèøÉÿÿ‹
¬ÏFh4çE‹A‰Eð‹F
‰
¬ÏF‰EôEðPEøPÿuèaƒÄéNŠA<$t„À„/‹MjèèÂÿÿé0‹uƒÁ‰
¬ÏF¾ƒøQ}„ü+ÇtmƒèAtSƒèt7ƒèuÄ!UüEøWPhøZFEð‰}øAVP‰
¬ÏFèmãÿÿPÿuè¢ÞÿÿƒÄéÑjVÿuA‰
¬ÏFèÈé·VÿuA‰
¬ÏFè‘òÿÿéûþÿÿVé’ƒèRt_ƒètNƒètƒè…HÿÿÿÿuA‰
¬ÏFèšéÊþÿÿ‹ÆA‰
¬ÏF98tPhdîEÿuè“ÇÿÿëS‹MhtîEèÂÁÿÿëGA‰
¬ÏFéüþÿÿhXîEMøè)Åÿÿ9>t
j MøèÈÿÿ‹
¬ÏFhhçEé“þÿÿÿujÿuèbÇÿÿƒÄ‹E_^‹å]ÃU‹ì¡¬ÏFƒìŠ„É„Öƒ}tP€ùXu3@£¬ÏF‹Eƒ8u‹Mh”ìEè5Áÿÿé»PhPîEÿuèäÆÿÿ饀ù_u8Hu€xZuƒÀ£¬ÏF€8Yuÿu@ÿu£¬ÏFè¤ÚÿÿYYëvV‹uEøVPè-Ýÿÿ÷F@YYt$EøPEðPhØïEMèè½Àÿÿ‹ÈèÀÆÿÿ‹Mð‹Uôë÷F tEøPEðPhäïEëÑ‹Uü‹Mø‹E^‰‰Pëÿujÿuè^ÆÿÿƒÄ‹E‹å]ÃU‹ìQQ¡¬ÏFVWŠ„À„‹<6|<9~<_uPÿuMøèAÀÿÿ‹E3ö‹}90t97t	÷Gu	PMøèÓÆÿÿ97t	WMøèÆÆÿÿEøPÿuètðÿÿYY‹Eé„‹uEøjÿuVÿuPèùàÿÿ3À€>*”ÀPEøPÿuèbþÿÿƒÄ ëÉjMøèý¿ÿÿÿuMøèdÇÿÿ‹}3ö97t	WMøèZÆÿÿS‹]93t97t
j Møè‡ÆÿÿSMøè;Æÿÿ‹E‹Mø[‰‹Mü‰H_^‹å]ÃU‹ìÿuÿuÿuÿuèðþÿÿ‹EƒÄ]ÃU‹ìQQ¡¬ÏFVWŠ„É„Å€ù_…¼@£¬ÏF¾8ƒïA@£¬ÏFƒÿw|¡¼ÏF3Ò‹MüÑèáÿÿ÷ЉUø‰Mü¨t}híEMøè¡Æÿÿjè÷ÇÿÿYPMøèÆÿÿ…ÿtK‹÷÷ÖF#÷‹Æƒètƒèu)h°îEëh¬îEMøèeÆÿÿ÷Ö#þth´îEMøèRÆÿÿëÄ‹MjèÔ¾ÿÿ‹Eë+j)Møè‚Åÿÿ‹Mü‹Uø‹E‰‰Hë‹Eƒ Æ@`ÿÿÿ_^‹å]ÃU‹ì¡¬ÏFÿu€8@u‹M@£¬ÏFèù½ÿÿë
ÿuèªåÿÿYY‹E]ÃU‹ììôSV‹uWÆEÿƒ&ÆF‹F%ÿÿÿ‰F„À…I‹]ø¡¬ÏFŠ„À„7<@„/€=ÀÏFt
€=ÁÏF„xƒ>tUVEÄPh(ìE|ÿÿÿè¾½ÿÿ‹ÈèÁÃÿÿ€}ÿ‹Eĉ‹EȉFt(VE¼Pj[tÿÿÿè½ÿÿ‹Èè—Ãÿÿ‹E¼‰‹EÀ‰FÆEÿ¡¬ÏF€8?…@£¬ÏF¾ƒè$„Zƒè„ƒè„YHƒè„òƒè„ƒètV…lÿÿÿP…dÿÿÿPè-òÿÿYé>3ÿãÿÿÿ¬ÏF‰}ô‰]øjEÔjP蔋M؃Ä„ÉuA…ÿt6‹EÔ‰MðMìh(ìE‰EìèÄÿÿ‹EìMä‰Eä‹Eð‰EèEôPèqÃÿÿ‹}ä‹]èë‹}Ô‹ÙëãÿÿƒË3ÿ‰]ø‰}ô„ÛuR¡¬ÏF€8@u‰EôPE´Pj[\ÿÿÿè¼ÿÿ‹Èè}Âÿÿ‹E´M܉EÜ‹E¸j]‰EàèTÃÿÿ‹E܉‹Eà‰Fÿ¬ÏFé~fÿÿÿƒ&ÆFékÿ¬ÏF…TÿÿÿVPj]…LÿÿÿPj…DÿÿÿjP訃Ä‹Èè/Âÿÿ‹ÈèÂÿÿÆEÿ顬ÏFH€9_uM€x?uGV…<ÿÿÿ‰
¬ÏFPj…4ÿÿÿjPèûñÿÿƒÄ‹ÈèÂÁÿÿ‹È‹‰‹A‰F¡¬ÏF€8@…ÕéGÿÿÿ…,ÿÿÿPèÍãÿÿYPE¬Pj`$ÿÿÿè»ÿÿ‹Èè}Áÿÿ‹E¬M̉EÌ‹E°j'‰EÐèTÂÿÿV…ÿÿÿPMÌëvj@h¬ÏFMœèù¹ÿÿVE¤PhXìEÿÿÿè,»ÿÿ‹Èè/Áÿÿ‹E¤‰‹E¨‰F‹
¤ÏFƒ9	tFEœPèSÃÿÿë;ÿ
¬ÏF…ÿÿÿVPE”ëEŒVPE„jjPèzƒÄ‹ÈèßÀÿÿ‹È‹‰‹A‰F€~„ºüÿÿ¡¬ÏFŠ„Àt<@tPfÿÿÿƒ&ÆFë@ƒ>uj‹ÎèF¾ÿÿë0VE„Ph(ìEEŒPjM”貺ÿÿ‹ÈèáÀÿÿ‹ÈètÀÿÿ‹‰‹@‰F_‹Æ^[‹å]ÃU‹ìƒìSV‹u3ÛW¿ÿþÿÿSˆ^‹F#lj%ÿÿÿ‰FEøjPèÁ‹ÈƒÄ‹‰‹A„À‰F¡¬ÏFuBŠ„Ét<€ù@t>VEøPh(ìEEðPEèPè·ûÿÿY‹ÈèTÀÿÿ‹Èèç¿ÿÿ‹È‹‰‹A‰F¡¬ÏFŠ€ù@u@£¬ÏFëX„Ét‹F#lj%ÿÿÿ‰FÆFë?9uj‹ÎèK½ÿÿë0VEèPh(ìEEðPjMøè·¹ÿÿ‹Èèæ¿ÿÿ‹Èèy¿ÿÿ‹‰‹H‰N_‹Æ^[‹å]ÃU‹ìQQ¡¬ÏFŠ„Éu‹Mjè|¹ÿÿë0j€ù?u@£¬ÏFEøPè¶ãÿÿPj-ÿuè½¾ÿÿƒÄë
ÿuèžãÿÿYY‹E‹å]ÃU‹ìÿuè3àÿÿ‹EY]ÃU‹ìW‹9…ÿu‹Eë‹Vÿu‹p‹Îÿuè£ÿÿ‹ÏÿÖ^_]ÂU‹ìS‹ÙV‹uWƒ;t6…öuèV¹ÈÏFxWèîíÿÿ‹ð…ötë‹}Gÿ‹ËÆPVè“ÿÿÿÆë…ötÆ_‹Æ^[]ÂU‹ìƒyujhlðEÿuÿuè:ƒÄë‹E]ÂU‹ì‹E;EsŠIˆ@]ÂU‹ì‹I…Ét]é2ÿÿÿ‹E]ÂU‹ìSV‹ÙWÿu‹{ÿu‹‹p‹ÎèA¢ÿÿ‹ÏÿÖ;Es‹{ÿuP‹‹r‹Îè%¢ÿÿ‹ÏÿÖ_^[]ÂU‹ìÿqÿqÿuÿu誃Ä]ÂU‹ìƒìMøÿuè³·ÿÿ‹
¬ÏFŠA‰
¬ÏF<@unŠA‰
¬ÏF<_uaEðAjP‰
¬ÏFè
âÿÿEðjPèâÿÿ¡¬ÏFƒÄŠ„Ét,€ù@t@£¬ÏFŠ„Éuï€8t‹Mø@£¬ÏF‹E‰‹Mü‰HëH£¬ÏFjëj‹Mèb·ÿÿ‹E‹å]ÃU‹ì‹E‹U+‹M;È~‹È…ÉtSVW‹}‹ò+ú‹ÙŠ7ˆFƒëuõ_^[
]ÃU‹ì¡¬ÏF€8?u'@€8$ujÿuèYYë"jjÿu£¬ÏFèñìÿÿëjjÿuèE
ƒÄ‹E]ÃU‹ìƒì|¡ÀF3ʼnEüSW‹}·ƒ'ÆGgÿÿÿˆ=ÁÏF€…VV‹5¬ÏFŠˆ}ã„À„A<@„9ƒeä2ÿeèÿÿ2۾ȃé0ƒù	w)Q‹
¨ÏFE¤FP‰5¬ÏFè	ºÿÿ‹È‹‰Eä‹A‰Eè鶉uÌ<$u"8Fu¾Fƒè$tEƒè1t0ƒèt6ƒèt$ƒèt,Šu
j Mô賶ÿÿj>Mô詶ÿÿ€}t¡¬ÏF€8t@£¬ÏF‹Mô‹Eð£¨ÏF‹E‰=¤ÏF‰5 ÏF_‰‹Mø^‰H[ë
‹Mj襯ÿÿ‹E‹å]ÃU‹ìƒìƒeø¸ÿÿ!Eü!EôEøƒeðjPhøZFEðPÿuèFÐÿÿ‹EƒÄ‹å]ÃU‹ì¡¬ÏFƒìŠ„ÉtL€ùZu‹Mü@£¬ÏFáÿÿ‹Eƒ ‰HëVEðPèÆÇÿÿYPEøPh¤îEMèèÞ®ÿÿ‹Èèá´ÿÿj)ÿuMøë!j)ÿuEèjPh¤îEMðèµ®ÿÿ‹Èè@µÿÿ‹ÈèÓ´ÿÿ‹E‹å]ÃU‹ìQ‹¬ÏFSVWj3Û¿@^€:_‹Ëu	B‹Ï‰¬ÏFŠ¹ ë7Éhë/Épë'Éxë<9uB¹ýÿ‰¬ÏFë
3É„À•ÁÁþÿ‹Á_^[‹å]ÃIKð@Rð@Yð@]ð@ið@að@pð@xð@€ð@U‹ì¡¬ÏFŠ„Ét€ùA‹Mtjë@høïE£¬ÏFèF«ÿÿë
‹Mjèt«ÿÿ‹E]ÃU‹ìÿuÿuè]‹EYY]ÃU‹ìQQ‹MV‹uhðE‹‰‹A‹Î‰F課ÿÿEøPèÀìÿÿYP‹Îè ±ÿÿj}‹ÎèÚ±ÿÿ‹
¬ÏF€9@uA‰
¬ÏF‹Æ^‹å]ÃU‹ì‹Mƒì ‹SV‹u3ÛC‰‹AŠÈ‰F:Ë8¡¬ÏF€8„EðPèÃÑÿÿ‹EðY‰EøMø‹Eôj ‰Eüèn±ÿÿVEèPMøèt°ÿÿ‹È‹‰‹A‰F:Ã顬ÏF€8@„¯hðE‹Îèè±ÿÿ¡¬ÏF8^Š„Étj€ù@teEèPèåëÿÿYPEðPj`Màè‘©ÿÿ‹Èè
°ÿÿ‹EðMø‰Eø‹Eôj'‰Eüèä°ÿÿEø‹ÎPè–°ÿÿ¡¬ÏF€8@u@£¬ÏF8^/€8@t‘hðEé{ÿÿÿ8^€8uS‹Îè¹±ÿÿj}‹Îèš°ÿÿ¡¬ÏF€8@u,@£¬ÏFë$:Ë VEðPSMà蹩ÿÿ‹È肯ÿÿ‹Mð‰‹Mô‰N‹Æ^[‹å]ÃU‹ìƒì<¡ÀF3ʼnEüSV‹5¬ÏFW‹}Š¾Ãƒè0ƒø	w‹
¤ÏFFPW‰5¬ÏFè­ÿÿéëƒeäeèÿÿ€û?uLEÌjPèNøÿÿYY‹‹@‰Mä‹
¬ÏF‰EèŠA‰
¬ÏF<@„‡I3À‰
¬ÏF8Mä•À@P耬ÿÿéj¸,ìEjPV‰Eàè—ƒÄ…ÀuƒÆë¸@ìEj
PV‰EàèzƒÄ…À…÷ƒÆ
EÔ‰5¬ÏFPè ïÿÿ÷¼ÏF@Y„†ƒ=ÄÏFt}jEìPMÔèˆïÿÿEìPèjÅ‹5ÄÏFYP‹Îèw’ÿÿÿÖYMä…ÀtP讫ÿÿéÊhPìE蟫ÿÿEÔPEÌPÿuàMÄè
¨ÿÿ‹Èè
®ÿÿ‹EÌM܉EÜ‹EÐhTìE‰Eàè–¯ÿÿEÜëChPìEMäèZ«ÿÿEÔPEÌPÿuàMÄèŧÿÿ‹ÈèÈ­ÿÿ‹EÌMÔ‰EÔ‹EÐhTìE‰EØèQ¯ÿÿEÔPMäèM®ÿÿë:€}t€û@u‹Eȃeä%ÿÿF‰5¬ÏFëj@h¬ÏFMÄè ¦ÿÿ‹‹@‰Mä‰Eè€}t‹
¤ÏFƒ9	t	EäPè¯ÿÿ‹E䉋Eè‰G‹Mü‹Ç_^3Í[蔄ÿÿ‹å]á¼ÏF%@ËAÁèƒàËAÁèƒàÃ3À9”ÀÃ3Àƒ9	”ÀËAÁèƒàËAÁè
ƒàËAÁèƒàÃ3À9t
÷At@Ã3À9t
÷At@ËAÁèƒàÃ3À€yžÀÃW‹9…ÿu3À_ËV‹0‹ÎèÅÿÿ‹ÏÿÖ^_ËAÃ3À@ËI…É…Ïÿÿÿ3ÀÃU‹ìQ‹Á‰Eüƒx}4S‹XVW‹x‹‹0‹Îè…ÿÿ‹ÏÿÖ‹‹ø‹2‹Îètÿÿ‹ËÿÖø‹Eü‰x_^[‹@‹å]ËAÃU‹ì¡ÐF¨ua3ÉÇðÏFAÇøÏFÁ‰
ìÏF3Ò£ÐF¸PðE‰àÏF£ÜÏF‰äÏF£èÏF£ôÏF‰üÏF£ÐFÇÐF‰ÐF‹Eƒøw
kÀÜÏF]øÐF]ÃIÃI@ÃIÃI Ã9tIÃI€ÃI‹ÁþAÃU‹ì‹U…Òt‹MV‹u+ñŠˆAƒêuõ^]ÃU‹ì‹M3À8t@A€9uù]ÃU‹ì‹E…Àu]ËM‹USƒètŠ„Ût:uBAëí¶¶	+Á[]ÃjdhÀŸFè+ÿÿ‹}…ÿu3Àëk3ö‰uäVèØœÿÿY‰uü‰=ÈÏF‹E£ÌÏF‰5ØÏF‰5ÐÏF‰5ÔÏF·EPVÿuÿuÿuMŒèU¦ÿÿMŒè®¨ÿÿ‹ø‰}ä¹ÈÏFèJ­ÿÿÇEüþÿÿÿè
‹ÇèöŽÿÿÃ3ö‹}äVè«œÿÿYÃjdhàŸFè–Žÿÿ‹}…ÿu3Àëk3ö‰uäVèCœÿÿY‰uü‰=ÈÏF‹E£ÌÏF‰5ØÏF‰5ÐÏF‰5ÔÏFÿu ÿuÿuÿuÿuMŒèÀ¥ÿÿMŒè¨ÿÿ‹ø‰}ä¹ÈÏF赬ÿÿÇEüþÿÿÿè
‹ÇèaŽÿÿÃ3ö‹}äVèœÿÿYÃU‹ìÿuÿuÿuÿuÿuè&ÿÿÿpÿ0èÃ+ƒÄ…ÀyƒÈÿ]ÃU‹ìEPjÿuÿuÿuè¼ÿÿÿƒÄ]ÃÌÌÌÌU‹ìSVWUjjhèø@ÿuè
m]_^[‹å]ËL$÷A¸t2‹D$‹Hü3È袀ÿÿU‹h‹P(R‹P$RèƒÄ]‹D$‹T$‰¸ÃSVW‹D$UPjþhðø@dÿ5¡ÀF3ÄPD$d£‹D$(‹X‹pƒþÿt:ƒ|$,ÿt;t$,v-4v‹³‰L$‰Hƒ|³uh‹D³èI‹D³è_ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
yðø@u‹Q‹R9Qu¸ÃSQ»0ÀFëSQ»0ÀF‹L$‰K‰C‰kUQPXY]Y[ÂÿÐÃU‹ì¡ÀF‹È3EƒáÓÈ]ÃU‹ì‹U‹M‹Eð±]ÃU‹ì‹E‹M‡]ÃU‹ì‹M3Ò3Àð±]Ã3ɺœÏF3Àð±
‹
ÀF3ÀFƒáÓÈÃVèÛÿÿÿ‹ð…öt	‹ÎèŒÿÿÿÖè»ÌU‹ìÿuè/ ÿÿ‹Ð¸œÏFY‡¡ÀF‹Èƒá3ÂÓÈ]ÃÌÌÌÌÌÌÌ‹L$W…É„·‹|$V÷ÇStŠƒÇ„Àt9÷Çuÿþþ~Ѓðÿ3ƒÇ©tè‹Gü„Àt!„ät©ÿt©ÿuσïë
ƒïëƒïëƒï‹t$÷Æu	‹ÙÁéu\ë"ŠƒÆ„Òt=ˆƒÇƒét)÷Æuå‹ÙÁéu8‹ËƒátŠƒÆˆƒÇ„Òtƒéuíˆ[^‹D$_È‹D$[^_ɃǃétȺÿþþ~‹Ѓðÿ3‹ƒÆ©tÜ„Òt΄öt*÷Âÿt÷Âÿuĉ‹D$[^_Ãf‰3Ò‹D$ˆW[^_Ãf‰‹D$[^_ËÿU‹ìV‹u…öuèO5j^‰0èÀ‹Æë$h€ÿuÿuè^ƒÄ‰…Àu	è#5‹ë3À^]ËÿU‹ìV‹u…öuè5j^‰0èÉ¿‹Æë$h€ÿuÿuè؃Ä‰…Àu	èÜ4‹ë3À^]Ãjh FèŠÿÿ3À‹u…ö•À…Àuè´4Çèt¿3Àës3À‹}…ÿ•À…ÀtÞ3À8•À…ÀtÓ€>u
è‚4ÇëÑEäPè3ÀYƒ}äu
èe4Çë´ƒeàƒeüÿuäÿuWVè¤ÉƒÄ‹ð‰uàÇEüþÿÿÿè‹Æ轉ÿÿËuà…öu	ÿuäè>ÀYÿuäèÌYÃjh  FèP‰ÿÿ3À‹u…ö•À…Àuèó3Çè³¾3Àës3À‹}…ÿ•À…ÀtÞ3À3Ûf9•À…ÀtÐf9u
è¾3ÇëÎEäPèo¿Y9]äu
è¢3Ç벉]à‰]üÿuäÿuWVèîȃċð‰uàÇEüþÿÿÿè‹ÆèüˆÿÿËuà…öu	ÿuäè}¿YÿuäèYËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èȃÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èwȃÄ]ËÃÿ1è¹YÃ3À9•ÀËÿU‹ì]éþÿÿ‹ÿU‹ìj@ÿuÿuèÈþÿÿƒÄ]ËÿU‹ìV‹u…öuèÃ2j^‰0脽ë$h€ÿuÿuè•þÿÿƒÄ‰…Àu	è™2‹0ë3ö‹Æ^]ËÿU‹ì]éqþÿÿ‹ÿU‹ìj@ÿuÿuèžýÿÿƒÄ]ËÿU‹ìV‹u…öuèZ2j^‰0è½ë$h€ÿuÿuèkýÿÿƒÄ‰…Àu	è02‹0ë3ö‹Æ^]ËÿU‹ìÿuèý´Y]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6èÌ´ƒ&Y^Ë˃!ËÿV‹ñÿ6è±´ƒ&Y^áÐFVj^…Àu¸ë;Æ}‹Æ£ÐFjPè$¶j£ÐFèx´ƒÄƒ=ÐFu+jV‰5ÐFèþµj£ÐFèR´ƒÄƒ=ÐFuƒÈÿ^ÃW3ÿ¾@ÀFjh F PèRÓ¡ÐF‹×Áú‰4¸‹Çƒà?kÈ0‹•¨ÚF‹Dƒøÿt	ƒøþt…ÀuÇFþÿÿÿƒÆ8GþèÀFu¯_3À^ËÿU‹ìkE8@ÀF]ËÿVèÛèWÙ3ö¡ÐFÿ4è4Ü¡ÐFY‹ƒÀ Pÿ¼±EƒÆƒþuØÿ5ÐF葳ƒ%ÐFY^ËÿU‹ì‹M…Éuè‘0ÇèQ»jX]ËU…ÒtA‰‹E…Àt‰‹U…ÒtA‰3À]ËÿU‹ì‹EƒÀ Pÿ´±E]ËÿU‹ì‹EƒÀ Pÿ¸±E]ËÿU‹ì‹E‹]ËÿU‹ì‹E‹]Ë‹@Ë‹@Áè
ƒàË‹@ÁèƒàËÿU‹ìV‹u…öuèì/Ç謺ƒÈÿëQ‹FWƒÏÿÁè
¨t9Vè7ÙV‹øè"ÛVèpÝPèõ°ƒÄ…ÀyƒÏÿëƒ~t
ÿv貃fYVè°»Y‹Ç_^]Ãjh@ FèÆ„ÿÿ‹u‰uà3À…ö•À…Àuèf/Çè&ºƒÈÿë;‹FÁèV¨tèg»YëèƒeäèÞþÿÿYƒeüVè1ÿÿÿY‹ð‰uäÇEüþÿÿÿè‹Æ覄ÿÿËuäÿuàèÂþÿÿYËÿU‹ìÿuèà±Y]Âjh` Fè4„ÿÿƒeäjè_æYƒeüÿuÿuèuYY‹ð‰uäÇEüþÿÿÿè‹ÆèE„ÿÿËuäjèræYÃjh€ FèæƒÿÿƒeäjèæYƒeüÿuÿuè¨YY‹ð‰uäÇEüþÿÿÿè‹Æè÷ƒÿÿËuäjè$æYËÿU‹ìƒ=„ÙFuƒ=ˆÙFuƒÈÿ]ÃV‹u…öuè1.Çèñ¸ƒÈÿëEÿuVèZYY…Àt)jPè!îYY…Àu9ˆÙFu3öëÿuVè‡YY„ÀuíƒÎÿjèÄ°Y‹Æ^]ËÿU‹ìƒ=„ÙFuƒ=ˆÙFuƒÈÿ]ÃV‹u…öuè°-Çèp¸ƒÈÿëEÿuVèÕYY…Àt)jPè«íYY…Àu9„ÙFu3öëÿuVèËYY„ÀuíƒÎÿjèC°Y‹Æ^]ËÿU‹ìVW3ÿWWjÿÿuWWÿh°E‹ð…öuè5-Ç*3Àë9}tWWjÿÿuWWÿh°E…ÀtÙÆ_^]ËÿU‹ìVW3ÿWWWWjÿÿuWWÿرE‹ð…öuèè,Ç*3Àë9}tWWWWjÿÿuWWÿرE…Àt×Æ_^]ËÿU‹ìQQSVW‹}…ÿtz¾ÿVÿuèáVW‹Øè÷àƒÄ‰Eø;Þrè‡,ÇèG·3Àé¬;ÆsåƒÀÃjP‰Eüèæ°‹ðYY…ötwÿuÿuüVè°‹Eø@Æ=WPCÆPèÿ¯ƒÄë`‹}j=Wè’ƒÿÿYY…Àt‹È¾ÿ+Ï;Î}‰@VPènàYY;ƃwÿÿÿ‹ÏQŠA„Àuù+ÊjYSèo°‹ðYY…öu3öëWSV诃Äjè±®Y‹Æ_^[‹å]ËÿU‹ìƒìS‹]VW…Û„Š¾ÿVÿuè&á‹øVS‰}øèáƒÄ‰Eô;þrèƒ+ÇèC¶3ÀéÒ;ÆsåƒÀÇjP‰Eüè⯋ð3ÿYY…ö„–ÿuÿuüVèÙ‹Møj=XSf‰N‹Eô@PAFPècÙƒÄëz‹]j=SèÙgYY…Àt,‹È+˃áþùþÿvÿÿÿ¾ÿƒÀVPèwàYY;ƃ]ÿÿÿ‹Ë3ÿQf‹ƒÁf;Çuõ+ÊÑùjAP‰EôèF¯‹ðYY…öu‹÷ë
SÿuôVèç؃ÄW臭Y‹Æ_^[‹å]ËÿU‹ì‹Eÿ0‹Eÿ0è›êYY]ËÿU‹ì‹Eÿ0‹Eÿ0èŽêYY]ËÿU‹ìSVW3ÀPPjÿÿuPPÿh°E‹]‹øj*^…ÿuè>*3ÿ‰0ë…Ût3ÀPPjÿSPPÿh°E…ÀtÞøjW蜮‹ðYY…öt"WVjÿÿujjÿh°E‹È…Éuèó)Ç*2ÛVèʬY_^ŠÃ[]Ã…Ûtj=Z+ùNWPjÿSjjf‰Pþÿh°E…Àt‹Æ3öVPèÑé‹Ø÷ÛYÛYþÃ븋ÿU‹ìSVW3ÀPPPPjÿÿuPPÿرE‹]‹øj*^…ÿuèw)3ÿ‰0ë…Ût3ÀPPPPjÿSPPÿرE…ÀtÜøjWèÓ­‹ðYY…öt$3ÀPPWVjÿÿuPPÿرE‹È…Éuè()Ç*2ÛVèÿ«Y_^ŠÃ[]Ã…Ût3Ò1RR+ùÆ@ÿ=WPjÿSRRÿرE…ÀtËÆ3öVPèüè‹Ø÷ÛYÛYþÃ빋ÿU‹ì‹E¾P‹Eÿ0è-€ÿÿYY]ËÿU‹ì‹Ef¾·ÀP‹Eÿ0ègeYY]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èO¬ƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0è1¬ƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èˆÖƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èjÖƒÄ]ËÿU‹ì‹E‹PŠ@„Éuù+Â]ËÿU‹ì‹E‹Pf‹ƒÀf…Éuõ+ÂÑø]ËÿU‹ì‹Eÿ0‹Eÿ0è@ÜYY]ËÿU‹ì‹Eÿ0‹Eÿ0èOÝYY]ËÿU‹ì‹Eÿ0‹Eÿ0èÜYY]ËÿU‹ì‹Eÿ0‹Eÿ0èÝYY]ËÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6è\ªƒ&Y^Ã3À9•ÀËÿU‹ì3ÀPPjÿÿuPÿuÿh°E]ËÿU‹ì3ÀPPPPjÿÿuPÿuÿرE]ËÿU‹ìÿuÿujÿÿujÿuÿh°E]ËÿU‹ì3ÀPPÿuÿujÿÿuPÿuÿرE]˃!˃!ËÃ3ÀÃ3À9•ÀÃ3À9ˆÙF•ÀÃ3À9„ÙF•ÀËÿV‹ñÿ6詃&Y^ËÁËÁËÿU‹ìjÿuè§÷ÿÿYY]ËÿU‹ìƒ}uè‰&ÇèI±jX]Ãÿuÿuèx÷ÿÿYY…Àu]Ãèa&‹]ËÿU‹ìjÿuè¦÷ÿÿYY]ËÿU‹ìƒ}uè:&Çèú°jX]Ãÿuÿuèw÷ÿÿYY…Àu]Ãè&‹]ËÿU‹ì]é0æ‹ÿU‹ìW‹ù‹MÆG…Ét
‹‰G‹A롨ÙF…Àu¡øÂF‰G¡üÂF‰GëDVèéìW‰Rw‹HL‰
‹HHP‰è+îVÿ7èPċP^¨u
ƒÈ‰PÆG‹Ç_]€yt	‹ƒ PýÃAÃjèYËÿU‹ìƒìSVWÿuMèèJÿÿÿ‹Eì3Û3ö‹ˆœ‰Mü‹±zŠB„Àuù‹L±+×yŠA„Àuù+σËMüØFƒþrÐC‰]øPè ¨‹øY…ÿtq‹÷3Û‹Eü‹MøÆ:AFÿ4˜‹Ç+ÆÁPV袨ƒÄ…Àul‹ÎQŠA„Àuù‹Eü+Êñ‹MøAÆ:Fÿt˜‹Ç+ÆÁPVèo¨ƒÄ…Àu9‹ÎQŠA„Àuù+ÊñCƒûr•ˆjèg§€}ôYt
‹M胡Pý‹Ç_^[‹å]Ã3ÀPPPPPèT¯ÌjèYËÿU‹ìƒìSVWÿuMèè9þÿÿ‹Eì3Ûj_‹€œƒÀh‰Eü‹ð‹NÐQŠA„Àuù+Ê‹B‰EøŠB„Àuù+UøƒÃƒÆ
؃ïuÏCP觋øY…ÿt{ƒeø‹÷‹EüÆ:FÿpЋÇ+Æ@ÃPV莧ƒÄ…Àuw‹ÎQŠA„Àuù‹Eü+ÊñÆ:Fÿ0‹Ç+Æ@ÃPVè`§ƒÄ…ÀuI‹ÎQŠA„Àuù‹Eü+ÊñƒÀ‹MøA‰Eü‰Møƒùr‘ÆjèH¦€}ôYt
‹M胡Pý‹Ç_^[‹å]Ã3ÀPPPPPè5®Ìéf‹ÿU‹ìjÿuÿuÿuÿuÿuèƒÄ]ËÿU‹ìƒìSVÿuMèèÿüÿÿ‹Eì3Û‹H‹E‰Mü…Àt‹u…ötˆ9]t9]uèØ"Ç蘭éÈSSjÿÿuSQÿh°E‰Eø…ÀuÿH±EPèp"Yé ÀWP趥‹øY…ÿ„„ÿuøWjÿÿuSÿuüÿh°E…ÀuÿH±EPè3"ë^6Pè}¥‹ðY…ötHÿuÿuÿuWÿuV葃ĉEø…Àt+SSÿuÿujÿVSÿuüÿرE…ÀuÿH±EPèß!Yë‹]øVèî¤YWèç¤Y_€}ôt
‹M胡Pý^‹Ã[‹å]Ë
¨ÙF3À…É•ÀËÿU‹ìƒ}u]Ãÿuÿuÿuÿuÿu豬Ì‹ÿU‹ìÿujÿuÿuÿuÿuè†þÿÿƒÄ]ËÿU‹ìjjÿuÿuÿuÿuègþÿÿƒÄ]ËÿU‹ìVÿu‹ñÿuÿuÿuÿuèO‹Æ^]‹ÿU‹ìVÿu‹ñÿuÿuÿuÿuè,‹Fƒ¦Xƒ¦\ƒŽ¤
ÿƒŽ¨
ÿ‰†`‹Æ^]‹ÿU‹ì‹EV‹ñÿ0‹Eÿ0‹Eÿ0‹Eÿpÿ0ÿuè Kƒ¦P‹Æ^]‹ÿU‹ìVÿu‹ñÿuÿuÿuÿuèO‹Æ^]‹ÿU‹ìVÿu‹ñÿuÿuÿuÿuè,‹Fƒ¦Xƒ¦\ƒŽ¤
ÿƒŽ¨
ÿ‰†`‹Æ^]‹ÿU‹ì‹EV‹ñÿ0‹Eÿ0‹Eÿ0‹Eÿpÿ0ÿuèxKƒ¦P‹Æ^]‹ÿU‹ìVÿu‹ñÿuÿuÿuÿuèO‹Æ^]‹ÿU‹ìVÿu‹ñÿuÿuÿuÿuè,‹Fƒ¦Xƒ¦\ƒŽ¤
ÿƒŽ¨
ÿ‰†`‹Æ^]‹ÿU‹ì‹EV‹ñÿ0‹Eÿ0‹Eÿ0‹Eÿpÿ0ÿuèœJƒ¦P‹Æ^]‹ÿU‹ìVÿu‹ñÿuÿuÿuÿuèO‹Æ^]‹ÿU‹ìVÿu‹ñÿuÿuÿuÿuè,‹Fƒ¦Xƒ¦\ƒŽ¤
ÿƒŽ¨
ÿ‰†`‹Æ^]‹ÿU‹ì‹EV‹ñÿ0‹Eÿ0‹Eÿ0‹Eÿpÿ0ÿuètJƒ¦P‹Æ^]Âjh ¡Fè7tÿÿƒeä‹Eÿ0èƒîÿÿYƒeü‹MèƒO‹ð‰uäÇEüþÿÿÿè
‹ÆèJtÿÿÂ‹uä‹Eÿ0èbîÿÿYÃjh@¡Fèæsÿÿƒeä‹Eÿ0è2îÿÿYƒeü‹MèÑQ‹ð‰uäÇEüþÿÿÿè
‹ÆèùsÿÿÂ‹uä‹Eÿ0èîÿÿYÃjhà Fè•sÿÿƒeä‹Eÿ0èáíÿÿYƒeü‹Mè·R‹ð‰uäÇEüþÿÿÿè
‹Æè¨sÿÿÂ‹uä‹Eÿ0èÀíÿÿYÃjh¡FèDsÿÿƒeä‹Eÿ0èíÿÿYƒeü‹MèÊM‹ð‰uäÇEüþÿÿÿè
‹ÆèWsÿÿÂ‹uä‹Eÿ0èoíÿÿYÃjhÀ Fèórÿÿƒeä‹Eÿ0è?íÿÿYƒeü‹MèIO‹ð‰uäÇEüþÿÿÿè
‹ÆèsÿÿÂ‹uä‹Eÿ0èíÿÿYÃjh  Fè¢rÿÿƒeä‹Eÿ0èîìÿÿYƒeü‹MèÇO‹ð‰uäÇEüþÿÿÿè
‹ÆèµrÿÿÂ‹uä‹Eÿ0èÍìÿÿYËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèéþÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèÎýÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèêþÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèÿÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPè§ýÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèÐýÿÿ‹å]ËÿU‹ìƒìƒ}uèÇèЦƒÈÿë2ƒ}tåE‰EìE‰EðE‰EôE‰EøE‰EüEìPÿuè…ÿÿÿYY‹å]ËÿU‹ìƒìƒ}uè·Çèw¦ƒÈÿë2ƒ}tåE‰EìE‰EðE‰EôE‰EøE‰EüEìPÿuèdþÿÿYY‹å]ËÿU‹ìƒìƒ}uè^Ç覃Èÿë2ƒ}tåE‰EìE‰EðE‰EôE‰EøE‰EüEìPÿuè3þÿÿYY‹å]ËÿU‹ìƒìƒ}uèÇèÅ¥ƒÈÿë2ƒ}tåE‰EìE‰EðE‰EôE‰EøE‰EüEìPÿuèRþÿÿYY‹å]ËÿU‹ìƒìƒ}uè¬Çèl¥ƒÈÿë2ƒ}tåE‰EìE‰EðE‰EôE‰EøE‰EüEìPÿuèÑýÿÿYY‹å]ËÿU‹ìƒìƒ}uèSÇ襃Èÿë2ƒ}tåE‰EìE‰EðE‰EôE‰EøE‰EüEìPÿuèPýÿÿYY‹å]ËÿU‹ìQƒ}uèüÇ輤ƒÈÿéÜSV‹uW‹}…ÿu…öu9u…¬3À鸅ö„‹]…Û„’è°ÿu$ÿu ÿu;ßv-‹GPVÿuÿuèƒÄƒøþuM脃8"ulèz‰ëc‹SVÿu‰EüÿuècƒÄÆDÿƒøþuƒÿÿuèMƒ8"u5èC‹Mü‰ë)…Ày(ƃøþuè+Ç"ëèÇèÞ£ƒÈÿ_^[‹å]ËÿU‹ìQƒ}uèøÇ踣ƒÈÿéàSV‹uW‹}…ÿu…öu9u…°3Àé¼…ö„¡‹]…Û„–è¬ÿu$ÿu ÿu;ßv-‹GPVÿuÿuèƒÄƒøþuO考8"upèv‰ëg‹SVÿu‰EüÿuèÛ3ɃÄf‰L^þƒøþuƒÿÿuèGƒ8"u7è=‹Mü‰ë+…Ày*3Éf‰ƒøþuè#Ç"ëèÇèÖ¢ƒÈÿ_^[‹å]ËÿU‹ìì„¡ÀF3ʼnEüƒ}‹ES‹]‰… ûÿÿuèÔÇ蔢ƒÈÿé…Ût…ÀtàVWÿu|ûÿÿè¦ñÿÿ‹M½ûÿÿ3À3Ò««««‹Á‹½ ûÿÿƒà‰…Œûÿÿ‰½ûÿÿ‰”ûÿÿ‰•˜ûÿÿu
ˆ•œûÿÿ…ÿuÆ…œûÿÿÿu …ûÿÿ‰… ûÿÿ…€ûÿÿPÿu… ûÿÿÿuQP¤ûÿÿèsC¤ûÿÿèß`‹ð…ÿtK‹E3ɃàÁt…Ûu…öuo‹…˜ûÿÿ;Ãu*…öx);óv%ë[‹…ŒûÿÿÁtM…Ût…öyˆë
‹…˜ûÿÿ;ÃtMˆäûÿÿènF€½ˆûÿÿt
‹|ûÿÿƒ¡Pý_‹Æ^‹Mü3Í[è_ÿÿ‹å]Ã…ÛuƒÎÿëË…˜ûÿÿ;Ãu¶jþ^ˆLÿë°‹ÿU‹ìì„¡ÀF3ʼnEüƒ}‹ES‹]‰… ûÿÿuèXÇ衃Èÿé…Ût…ÀtàVWÿu|ûÿÿè*ðÿÿ‹M½ûÿÿ3À3Ò««««‹Á‹½ ûÿÿƒà‰…Œûÿÿ‰½ûÿÿ‰”ûÿÿ‰•˜ûÿÿu
ˆ•œûÿÿ…ÿuÆ…œûÿÿÿu …ûÿÿ‰… ûÿÿ…€ûÿÿPÿu… ûÿÿÿuQP¤ûÿÿè)C¤ûÿÿè³f‹ð…ÿtQ‹EƒàƒÈt…Ûu…öuv‹…˜ûÿÿ;Ãu.…öx0;óv,ëb‹…ŒûÿÿƒÈtS…Ût…öy3Àf‰ë‹…˜ûÿÿ;ÃtP3Éf‰GäûÿÿèìD€½ˆûÿÿt
‹|ûÿÿƒ¡Pý_‹Æ^‹Mü3Í[è]ÿÿ‹å]Ã…ÛuƒÎÿëË…˜ûÿÿ;Ãu³jþ^3Àf‰D_þë­‹ÿU‹ììð
¡ÀF3ʼnEü‹ES‹]V‹u‰…Hõÿÿ…öuèÑÇè‘ŸƒÈÿéO…Ût…ÀtàWÿuõÿÿè¤îÿÿ‹M½8õÿÿ3À3Ò««««‹Á‹½Hõÿÿƒà‰…4õÿÿ‰½8õÿÿ‰<õÿÿ‰•@õÿÿu
ˆ•Dõÿÿ…ÿuÆ…Dõÿÿ…8õÿÿ‰ õÿÿ‰…(õÿÿLõÿÿ‹E ‰…Hõÿÿ…õÿÿ‰…,õÿÿ‹E‰…$õÿÿ…HõÿÿP…,õÿÿ‰µ0õÿÿP…0õÿÿP… õÿÿP…(õÿÿPèäóÿÿèõLõÿÿ‰…XõÿÿèÅ^‹ð…ÿtK‹E3ɃàÁt…Ûu…öuo‹…@õÿÿ;Ãu*…öx);óv%ë[‹…4õÿÿÁtM…Ût…öyˆë
‹…@õÿÿ;ÃtMˆŒõÿÿè,C€½õÿÿ_t
‹õÿÿƒ¡Pý‹Æ‹Mü^3Í[èÏ[ÿÿ‹å]Ã…ÛuƒÎÿëË…@õÿÿ;Ãu¶jþ^ˆLÿë°‹ÿU‹ììð
¡ÀF3ʼnEü‹ES‹]V‹u‰…Hõÿÿ…öuèÇèÔƒÈÿéU…Ût…ÀtàWÿuõÿÿèçìÿÿ‹M½8õÿÿ3À3Ò««««‹Á‹½Hõÿÿƒà‰…4õÿÿ‰½8õÿÿ‰<õÿÿ‰•@õÿÿu
ˆ•Dõÿÿ…ÿuÆ…Dõÿÿ…8õÿÿ‰ õÿÿ‰…(õÿÿLõÿÿ‹E ‰…Hõÿÿ…õÿÿ‰…,õÿÿ‹E‰…$õÿÿ…HõÿÿP…,õÿÿ‰µ0õÿÿP…0õÿÿP… õÿÿP…(õÿÿPèÇòÿÿè8Lõÿÿ‰…Xõÿÿè`d‹ð…ÿtQ‹EƒàƒÈt…Ûu…öuv‹…@õÿÿ;Ãu.…öx0;óv,ëb‹…4õÿÿƒÈtS…Ût…öy3Àf‰ë‹…@õÿÿ;ÃtP3Éf‰GŒõÿÿèiA€½õÿÿ_t
‹õÿÿƒ¡Pý‹Æ‹Mü^3Í[èZÿÿ‹å]Ã…ÛuƒÎÿëË…@õÿÿ;Ãu³jþ^3Àf‰D_þë­‹ÿU‹ìì„¡ÀF3ʼnEüƒ}‹ES‹]‰… ûÿÿuèPÇ蜃Èÿé…Ût…ÀtàVWÿu|ûÿÿè"ëÿÿ‹M½ûÿÿ3À3Ò««««‹Á‹½ ûÿÿƒà‰…Œûÿÿ‰½ûÿÿ‰”ûÿÿ‰•˜ûÿÿu
ˆ•œûÿÿ…ÿuÆ…œûÿÿÿu …ûÿÿ‰… ûÿÿ…€ûÿÿPÿu… ûÿÿÿuQP¤ûÿÿèS=¤ûÿÿèß\‹ð…ÿtK‹E3ɃàÁt…Ûu…öuo‹…˜ûÿÿ;Ãu*…öx);óv%ë[‹…ŒûÿÿÁtM…Ût…öyˆë
‹…˜ûÿÿ;ÃtMˆäûÿÿèê?€½ˆûÿÿt
‹|ûÿÿƒ¡Pý_‹Æ^‹Mü3Í[èXÿÿ‹å]Ã…ÛuƒÎÿëË…˜ûÿÿ;Ãu¶jþ^ˆLÿë°‹ÿU‹ìì„¡ÀF3ʼnEüƒ}‹ES‹]‰… ûÿÿuèÔÇ蔚ƒÈÿé…Ût…ÀtàVWÿu|ûÿÿè¦éÿÿ‹M½ûÿÿ3À3Ò««««‹Á‹½ ûÿÿƒà‰…Œûÿÿ‰½ûÿÿ‰”ûÿÿ‰•˜ûÿÿu
ˆ•œûÿÿ…ÿuÆ…œûÿÿÿu …ûÿÿ‰… ûÿÿ…€ûÿÿPÿu… ûÿÿÿuQP¤ûÿÿè	=¤ûÿÿè¿b‹ð…ÿtQ‹EƒàƒÈt…Ûu…öuv‹…˜ûÿÿ;Ãu.…öx0;óv,ëb‹…ŒûÿÿƒÈtS…Ût…öy3Àf‰ë‹…˜ûÿÿ;ÃtP3Éf‰Gäûÿÿèh>€½ˆûÿÿt
‹|ûÿÿƒ¡Pý_‹Æ^‹Mü3Í[èWÿÿ‹å]Ã…ÛuƒÎÿëË…˜ûÿÿ;Ãu³jþ^3Àf‰D_þë­‹ÿU‹ìƒ}uèlÇè,™ƒÈÿ]ÃV‹u…öt:ƒ}v4ÿu ÿuÿuÿuVÿuÿuè5öÿÿƒÄ…Àyƃøþu è"Ç"ëèÇèÕ˜ƒÈÿ^]ËÿU‹ìƒ}uèô
Çè´˜ƒÈÿ]ÃV‹u…öt<ƒ}v6ÿu ÿuÿuÿuVÿuÿuè9÷ÿÿƒÄ…Ày3Éf‰ƒøþu è¨
Ç"ëè›
Çè[˜ƒÈÿ^]ùu¸ËÑèË…Àu‹ÁË…Àu‹ÁËÿU‹ìQƒÈÿ3ÒV‹u÷öWƒàþ‹ùƒøsè7
Ç2ÀëSS3Ûö9Ÿuþv;·w°ë1Vè%‰EüY…ÀtEüPè­<‹Eü³‰·PèÃYŠÃ[_^‹å]‹ÿU‹ìƒ¹\uƒA‹I¾Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPèÂçë Ò‹„Ñl¾ë°èdÇè$—2À]‹ÿU‹ìƒ¹\uƒA‹I¾Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPèŽçë Ò‹„Ñl¾ë°èåÇ襖2À]‹ÿU‹ìƒ¹\uƒA‹I¾Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPèZçë Ò‹„Ñl¾ë°èfÇè&–2À]‹ÿU‹ìƒ¹\uƒA‹I¾Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPè(çë Ò‹„Ñl¾ë°èç
Ç觕2À]‹ÿU‹ìƒA‹A‹M¾@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¾@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¾@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¾@ü™‰°‰Q]‹ÿU‹ìƒ¹\uƒA‹I¶Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPèJåë Ò‹„Ñl¶ë°èì	Ç謔2À]‹ÿU‹ìƒ¹\uƒA‹I¶Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPèåë Ò‹„Ñl¶ë°èm	Çè-”2À]‹ÿU‹ìƒ¹\uƒA‹I¶Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPèâäë Ò‹„Ñl¶ë°èîÇ讓2À]‹ÿU‹ìƒ¹\uƒA‹I¶Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPè°äë Ò‹„Ñl¶ë°èoÇè/“2À]‹ÿU‹ìƒA‹A‹M¶@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¶@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¶@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¶@ü™‰°‰Q]‹ÿU‹ìƒ¹\uƒA‹I¿Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPèÒâë Ò‹„Ñl¿ë°ètÇè4’2À]‹ÿU‹ìƒ¹\uƒA‹I¿Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPèžâë Ò‹„Ñl¿ë°èõÇ赑2À]‹ÿU‹ìƒ¹\uƒA‹I¿Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPèjâë Ò‹„Ñl¿ë°èvÇè6‘2À]‹ÿU‹ìƒ¹\uƒA‹I¿Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPè8âë Ò‹„Ñl¿ë°è÷Çè·2À]‹ÿU‹ìƒA‹A‹M¿@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¿@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¿@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M¿@ü™‰°‰Q]‹ÿU‹ìƒ¹\uƒA‹IŠQü‹Mˆ°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPè_àë$Ò‹„ÑlŠ‹EˆëµèýÇè½2À]‹ÿU‹ìƒ¹\uƒA‹IŠQü‹Mˆ°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPè,àë$Ò‹„ÑlŠ‹EˆëµèÇè?2À]‹ÿU‹ìƒA‹AŠHü‹Eˆ°]‹ÿU‹ìƒA‹AŠHü‹Eˆ°]‹ÿU‹ìƒ¹\uƒA‹I·Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPè*ßë Ò‹„Ñl·ë°èÌÇ茎2À]‹ÿU‹ìƒ¹\uƒA‹I·Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,¶A1PÁâdjÂPèöÞë Ò‹„Ñl·ë°èMÇè
Ž2À]‹ÿU‹ìƒ¹\uƒA‹I·Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPèÂÞë Ò‹„Ñl·ë°èÎÇèŽ2À]‹ÿU‹ìƒ¹\uƒA‹I·Aü‹M™‰°‰QëU‹‘¨
…Òx9ƒúd}4ƒ¹Xuÿq,·A2PÁâdjÂPèÞë Ò‹„Ñl·ë°èOÇè2À]‹ÿU‹ìƒA‹A‹M·@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M·@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M·@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M·@ü™‰°‰Q]‹ÿU‹ìƒ¹\uƒA‹A‹@ü‹M™‰°‰QëT‹‘¨
…Òx8ƒúd}3ƒ¹Xuÿq,¶A1PÁâdjÂPè³ÜëÒ‹„Ñl‹ë±èVÇèŒ2À]‹ÿU‹ìƒ¹\uƒA‹A‹@ü‹M™‰°‰QëT‹‘¨
…Òx8ƒúd}3ƒ¹Xuÿq,¶A1PÁâdjÂPèÜëÒ‹„Ñl‹ë±èÙÇ虋2À]‹ÿU‹ìƒ¹\uƒA‹A‹@ü‹M™‰°‰QëT‹‘¨
…Òx8ƒúd}3ƒ¹Xuÿq,·A2PÁâdjÂPèOÜëÒ‹„Ñl‹ë±è\Çè‹2À]‹ÿU‹ìƒ¹\uƒA‹A‹@ü‹M™‰°‰QëT‹‘¨
…Òx8ƒúd}3ƒ¹Xuÿq,·A2PÁâdjÂPèÜëÒ‹„Ñl‹ë±èßÿÇ蟊2À]‹ÿU‹ìƒA‹A‹M‹@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M‹@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M‹@ü™‰°‰Q]‹ÿU‹ìƒA‹A‹M‹@ü™‰°‰Q]‹ÿU‹ìƒ¹\uƒA‹I‹U‹Iüƒb‰
°ë]‹‘¨
…ÒxAƒúd}<ƒ¹Xuÿq,¶A1PÁâdjÂPèGÚë(Ò‹„Ñl‹M‹ƒa‰ë±èáþÇ衉2À]‹ÿU‹ìƒ¹\uƒA‹I‹U‹Iüƒb‰
°ë]‹‘¨
…ÒxAƒúd}<ƒ¹Xuÿq,¶A1PÁâdjÂPèÚë(Ò‹„Ñl‹M‹ƒa‰ë±è[þÇè‰2À]‹ÿU‹ìƒ¹\uƒA‹I‹U‹Iüƒb‰
°ë]‹‘¨
…ÒxAƒúd}<ƒ¹Xuÿq,·A2PÁâdjÂPèÑÙë(Ò‹„Ñl‹M‹ƒa‰ë±èÕýÇ蕈2À]‹ÿU‹ìƒ¹\uƒA‹I‹U‹Iüƒb‰
°ë]‹‘¨
…ÒxAƒúd}<ƒ¹Xuÿq,·A2PÁâdjÂPè˜Ùë(Ò‹„Ñl‹M‹ƒa‰ë±èOýÇèˆ2À]‹ÿU‹ìƒA‹A‹M‹@üƒa‰°]‹ÿU‹ìƒA‹A‹M‹@üƒa‰°]‹ÿU‹ìƒA‹A‹M‹@üƒa‰°]‹ÿU‹ìƒA‹A‹M‹@üƒa‰°]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPè»×ë$Ò‹„Ñl‹‹E‰ëµèYüÇè‡2À]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPèˆ×ë$Ò‹„Ñl‹‹E‰ëµèÛûÇ蛆2À]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,·A2PÁâdjÂPèU×ë$Ò‹„Ñl‹‹E‰ëµè]ûÇè†2À]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,·A2PÁâdjÂPè$×ë$Ò‹„Ñl‹‹E‰ëµèßúÇ蟅2À]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPèAÕë$Ò‹„Ñl‹‹E‰ëµèßùÇ蟄2À]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPèÀÔë$Ò‹„Ñl‹‹E‰ëµèùÇèÓƒ2À]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,·A2PÁâdjÂPè?Ôë$Ò‹„Ñl‹‹E‰ëµèGøÇèƒ2À]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,·A2PÁâdjÂPèÀÓë$Ò‹„Ñl‹‹E‰ëµè{÷Çè;‚2À]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPè+Òë$Ò‹„Ñl‹‹E‰ëµèÉöÇè‰2À]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,¶A1PÁâdjÂPèøÑë$Ò‹„Ñl‹‹E‰ëµèKöÇè2À]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,·A2PÁâdjÂPèÅÑë$Ò‹„Ñl‹‹E‰ëµèÍõÇè€2À]‹ÿU‹ìƒ¹\uƒA‹I‹Qü‹M‰°ëY‹‘¨
…Òx=ƒúd}8ƒ¹Xuÿq,·A2PÁâdjÂPè”Ñë$Ò‹„Ñl‹‹E‰ëµèOõÇè€2À]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒA‹A‹Hü‹E‰°]‹ÿU‹ìƒ¹\uƒA°‹IV‹qü‹Qø‹M‰q‰^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,¶A1PÁâdjÂPèÃÏë,Ò‹„Ñl‹‹P‹E‰‰P°ëèYôÇè2À]‹ÿU‹ìƒ¹\uƒA°‹IV‹qü‹Qø‹M‰q‰^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,¶A1PÁâdjÂPè€Ïë,Ò‹„Ñl‹‹P‹E‰‰P°ëèËóÇè‹~2À]‹ÿU‹ìƒ¹\uƒA°‹IV‹qü‹Qø‹M‰q‰^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,·A2PÁâdjÂPè=Ïë,Ò‹„Ñl‹‹P‹E‰‰P°ëè=óÇèý}2À]‹ÿU‹ìƒ¹\uƒA°‹IV‹qü‹Qø‹M‰q‰^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,·A2PÁâdjÂPèüÎë,Ò‹„Ñl‹‹P‹E‰‰P°ëè¯òÇèo}2À]‹ÿU‹ìƒA‹A‹Hø‹Pü‹E‰‰P°]‹ÿU‹ìƒA‹A‹Hø‹Pü‹E‰‰P°]‹ÿU‹ìƒA‹A‹Hø‹Pü‹E‰‰P°]‹ÿU‹ìƒA‹A‹Hø‹Pü‹E‰‰P°]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,¶A1PÁâdjÂPèÍë,Ò‹”Ñl‹M‹‰‹B‰A°ëè¡ñÇèa|2À]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,¶A1PÁâdjÂPèÈÌë,Ò‹”Ñl‹M‹‰‹B‰A°ëèñÇèÓ{2À]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,·A2PÁâdjÂPè…Ìë,Ò‹”Ñl‹M‹‰‹B‰A°ëè…ðÇèE{2À]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,·A2PÁâdjÂPèDÌë,Ò‹”Ñl‹M‹‰‹B‰A°ëè÷ïÇè·z2À]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,¶A1PÁâdjÂPèSÊë,Ò‹”Ñl‹M‹‰‹B‰A°ëèéîÇè©y2À]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,¶A1PÁâdjÂPèÊë,Ò‹”Ñl‹M‹‰‹B‰A°ëè[îÇèy2À]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,·A2PÁâdjÂPèÍÉë,Ò‹”Ñl‹M‹‰‹B‰A°ëèÍíÇèx2À]‹ÿU‹ìƒ¹\uƒA°‹UV‹q‹Nø‰
‹Nü‰J^ëa‹‘¨
…ÒxEƒúd}@ƒ¹Xuÿq,·A2PÁâdjÂPèŒÉë,Ò‹”Ñl‹M‹‰‹B‰A°ëè?íÇèÿw2À]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒA‹Q‹M‹Bø‰‹Bü‰A°]‹ÿU‹ìƒ¹\uƒA‹If‹Qü‹Mf‰°ë[‹‘¨
…Òx?ƒúd}:ƒ¹Xuÿq,¶A1PÁâdjÂPè¡Çë&Ò‹„Ñlf‹‹Ef‰ë³è=ìÇèýv2À]‹ÿU‹ìƒ¹\uƒA‹If‹Qü‹Mf‰°ë[‹‘¨
…Òx?ƒúd}:ƒ¹Xuÿq,¶A1PÁâdjÂPèjÇë&Ò‹„Ñlf‹‹Ef‰ë³è»ëÇè{v2À]‹ÿU‹ìƒ¹\uƒA‹If‹Qü‹Mf‰°ë[‹‘¨
…Òx?ƒúd}:ƒ¹Xuÿq,·A2PÁâdjÂPè3Çë&Ò‹„Ñlf‹‹Ef‰ë³è9ëÇèùu2À]‹ÿU‹ìƒ¹\uƒA‹If‹Qü‹Mf‰°ë[‹‘¨
…Òx?ƒúd}:ƒ¹Xuÿq,·A2PÁâdjÂPèþÆë&Ò‹„Ñlf‹‹Ef‰ë³è·êÇèwu2À]‹ÿU‹ìƒA‹Af‹Hü‹Ef‰°]‹ÿU‹ìƒA‹Af‹Hü‹Ef‰°]‹ÿU‹ìƒA‹Af‹Hü‹Ef‰°]‹ÿU‹ìƒA‹Af‹Hü‹Ef‰°]ÂjXÃjXÃjXÃjXÃjXÃjXÃjXÃjXÃjXÃjXÃjXÃjXËÿU‹ìŠEÉYY‹Mü‹Æ_3Í^è)ÿÿ‹å]Ãÿ1èVœÿÿYËÿU‹ììä
¡ÀF3ʼnEüV‹ñW‹‹8WèIȈ… õÿÿ‹FY$õÿÿÿ0ès¦ÿÿ‹‹N‹‰…Hõÿÿ‹F‹‰…Dõÿÿ…(õÿÿ‰…@õÿÿ‹F‹‰…<õÿÿ‹‰…4õÿÿ‹ALõÿÿ‰…8õÿÿ…DõÿÿP…@õÿÿP…<õÿÿP…4õÿÿP…HõÿÿPèR«ÿÿèÌLõÿÿ‰…Xõÿÿè{Œõÿÿ‹ðè‰ûÿÿ€½0õÿÿt
‹$õÿÿƒ¡PýWÿµ õÿÿè4ÈYY‹Mü‹Æ_3Í^èÿÿ‹å]Ãÿ1è`›ÿÿYÃÿ1èC›ÿÿYÃÿ1è:›ÿÿYÃÿ1èE›ÿÿYÃÿ1è<›ÿÿYÃÿ1è›ÿÿYËÿU‹ììx¡ÀF3ʼnEüV‹ñW‹‹8WèLj…œûÿÿ‹FYˆûÿÿÿ0è<¥ÿÿ‹¤ûÿÿ‹‰… ûÿÿ‹Fÿ0…ŒûÿÿP‹Fÿ0‹Fÿpÿ0… ûÿÿPè³öÿÿ¤ûÿÿèäûÿÿ‹ðè–úÿÿ€½”ûÿÿt
‹ˆûÿÿƒ¡PýWÿµœûÿÿèAÇYY‹Mü‹Æ_3Í^è,ÿÿ‹å]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÿU‹ì‹E3É8M”ÁƒÀÆIƒáàƒÁaÁ]ËÁÿ€X‹ˆXƒùu2ÀÃùu	ƒ¸\t¤
ÿ3Ƀˆ¨
ÿ‰ˆ\‰H$‰H(‹ˆ`‰H°ËÁÿ€X‹ˆXƒùu2ÀÃùu	ƒ¸\t¤
ÿ3Ƀˆ¨
ÿ‰ˆ\‰H$‰H(‹ˆ`‰H°ËÁÿ€X‹ˆXƒùu2ÀÃùu	ƒ¸\t¤
ÿ3Ƀˆ¨
ÿ‰ˆ\‰H$‰H(‹ˆ`‰H°ËÁÿ€X‹ˆXƒùu2ÀÃùu	ƒ¸\t¤
ÿ3Ƀˆ¨
ÿ‰ˆ\‰H$‰H(‹ˆ`‰H°ÃÿP3Àƒ¹P•ÀÃÿP3Àƒ¹P•ÀÃÿP3Àƒ¹P•ÀÃÿP3Àƒ¹P•ÀËÿU‹ì‹E‹MS‹‹€ˆ‹Šë:ÃtAŠ„ÀuõŠA„Àt(ë	8uÿu.:Ðu*ÿuSÿwÿ7èÚÿÿÿvŠØÿuøÿwÿ7èÿÙÿÿƒÄ :ÔÀë2Àë3À:ò”À_^[‹å]‹ÿU‹ìQQS‹]V‹uW‹ùŠN€ùp‰Mø”Æ€ûp”„ö…ò„Ò…ê3À€ùstˆEÿ€ùSuÆEÿ€ûstŠð€ûSu¶€ùctŠÐ€ùCu²€ûct€ûCu°€}ÿur„ö…„Òuk„À…‘QèØÿÿSˆEÿèø×ÿÿYYŠMÿ„Éu
„Àuu‹3À;Mët:Èuh3Ƀ~	”Á3Àƒ}	”À;ÈuRÿvèðSÿu‹ØèæS+Ø÷ÛYÛCYŠÃë>8uÿu.:Ðu*ÿuSÿwÿ7èãØÿÿÿvŠØÿuøÿwÿ7èÑØÿÿƒÄ :ÔÀë2Àë3À:ò”À_^[‹å]‹ÿU‹ìQQS‹]V‹uWjpX·~f;ø‰Mø”Âf;Ø”Á„Ò…å„É…ÝWè?ØÿÿSˆEýè6ØÿÿWˆEÿè¯ÖÿÿSˆEþè¦ÖÿÿŠMýƒÄ„Éut8Mÿ…¥ŠMþ„Éul„À…–Wè×ÿÿÿuŠØè×ÿÿYY„Ûu
„Àu|‹3À;Më{:Øuo3Ƀ~	”Á3Àƒ}	”À;ÈuYÿvèÔRÿu‹ØèÊR+Ø÷ÛYÛCYŠÃëE:Mÿu5ŠMþ:Èu.ÿu‹EøSÿpÿ0èØÿÿÿvŠØ‹EøWÿpÿ0èî×ÿÿƒÄ :ÔÀë2Àë3À:Ñ”À_^[‹å]‹ÿU‹ìQQS‹]V‹uWjpX·~f;ø‰Mø”Âf;Ø”Á„Ò…å„É…ÝWè8×ÿÿSˆEýè/×ÿÿWˆEÿè¨ÕÿÿSˆEþèŸÕÿÿŠMýƒÄ„Éut8Mÿ…¥ŠMþ„Éul„À…–Wè)ÖÿÿÿuŠØèÖÿÿYY„Ûu
„Àu|‹3À;Më{:Øuo3Ƀ~	”Á3Àƒ}	”À;ÈuYÿvè±Qÿu‹Øè§Q+Ø÷ÛYÛCYŠÃëE:Mÿu5ŠMþ:Èu.ÿu‹EøSÿpÿ0èÞÖÿÿÿvŠØ‹EøWÿpÿ0èËÖÿÿƒÄ :ÔÀë2Àë3À:Ñ”À_^[‹å]¸4ñEø4ñEø4ñEø4ñEø4ñEø4ñEø4ñEø4ñEø4ñEø4ñEø4ñEø4ñEËÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüHPè³Û‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüHPèWÛ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüHPèûÚ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüHPèŸÚ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüHPèCÚ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüHPèçÙ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüƒèPè‘Ú‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüƒèPè3Ú‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüƒèPèÕÙ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüƒèPèwÙ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüƒèPèÙ‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿU‹ìQSV‹ñMüWj
Q‹~‹ƒ'‹FƒeüƒèPè»Ø‹MƒÄ‰‹Fƒ8"t‹Eü;Fr‰F°ë2Àƒ?u…Ût‰_^[‹å]‹ÿV‹ñŽHè®”„ÀuƒÈÿ^ÃS3Û9^…Êè½¹Çè}DƒÈÿéȉ^8‰^é…ÿF9^ŒŒÿv¶F1‹ÎPèòÿÿ‰FƒøtºƒøwÅÿ$…gxA‹Îè~ëEƒN(ÿ‰^$ˆ^0‰^ ‰^,ˆ^<ë8‹Îè„ë'‹ÎèUIë‰^(ë!‹Îè?ë‹Îèdë‹Îè¹-„À„hÿÿÿ‹FŠˆF1„À…kÿÿÿÿF‹Îèy™„À„Fÿÿÿÿ†Pƒ¾P…;ÿÿÿ‹F[^ÃÖwAßwAôwAýwAxAxAxAxA‹ÿV‹ñŽH膓„ÀuƒÈÿ^ÃS3Û9^u虸ÇèYCƒÈÿééW‹Îè*ïÿÿ„À„ÕƒÏÿ‰^8‰^éšÿF9^Œ¡ÿv¶F1‹ÎPèñÿÿ‹Î‰Fè¼”„À„±‹Fƒø„•ƒø‡œÿ$…ÃyA‹ÎèLëD‰^$ˆ^0‰^ ‰~(‰^,ˆ^<ë4‹Îèqë'‹Îè0Hë‰^(ë‹Îèë‹Îè}ë‹Îè˜.„ÀtD‹FŠˆF1„À…VÿÿÿÿF‹Î赘„Àt&‹ÎèUîÿÿ„À….ÿÿÿ‹F_[^Ãè•·ÇèUB‹ÇëèI'yA0yADyAMyAVyA[yAdyAmyA‹ÿV‹ñŽHè*’„ÀuƒÈÿ^ÃS3Û9^…»è9·ÇèùAƒÈÿ鹉^8‰^é…ÿF9^ŒŒÿv¶F1‹ÎPèéïÿÿ‰FƒøtºƒøwÅÿ$…ßzA‹ÎèJëEƒN(ÿ‰^$ˆ^0‰^ ‰^,ˆ^<ë8‹Îèzë'‹Îè‹ÇëèIÇ|AÐ|Aä|Aí|Aö|Aû|A}A
}A‹ÿV‹ñŽHèÆŽ„ÀuƒÈÿ^ÃS3Û9^…»è™³ÇèY>ƒÈÿ鹉^8‰^é…ÿF9^ŒŒÿv¶F1‹ÎPèåìÿÿ‰FƒøtºƒøwÅÿ$…~A‹ÎèëEƒN(ÿ‰^$ˆ^0‰^ ‰^,ˆ^<ë8‹Îè‘ë'‹Îè2Dë‰^(ë!‹Îèë‹ÎèMë‹Îè–2„À„hÿÿÿ‹FŠˆF1„À…kÿÿÿÿFÿ†Pƒ¾P…Jÿÿÿ‹F[^ÃIú}A~A~A!~A*~A/~A8~AA~A‹ÿV‹ñŽHè„ÀuƒÈÿ^ÃS3Û9^…Ïè}²Çè==ƒÈÿé͉^8‰^醃F9^Œÿv·F2‹ÎPèúëÿÿ‰Fƒøt¹ƒøwÄÿ$…¯A‹Îè
ëEƒN(ÿ‰^$ˆ^0‰^ ‰^,ˆ^<ë8‹Îè±
ë'‹Îè@Cë‰^(ë!‹Îèë‹Îè™ë‹Îè¨3„À„gÿÿÿ‹F·f‰F2f…À…gÿÿÿƒF‹Îèx’„À„Aÿÿÿÿ†Pƒ¾P…6ÿÿÿ‹F[^ÃIA A5A>AGALAUA^A‹ÿV‹ñŽHè_Œ„ÀuƒÈÿ^ÃS3Û9^uèQ±Çè<ƒÈÿéîW‹Îèzèÿÿ„À„ÚƒÏÿ‰^8‰^雃F9^Œ¥ÿv·F2‹ÎPèòêÿÿ‹Î‰Fèc„À„µ‹Fƒø„™ƒø‡ ÿ$…A‹ÎèáëD‰^$ˆ^0‰^ ‰~(‰^,ˆ^<ë4‹Îè–	ë'‹ÎèBë‰^(ë‹Îèãë‹Îè½ë‹Îè­4„ÀtH‹F·f‰F2f…À…RÿÿÿƒF‹Îèh’„Àt&‹Îè çÿÿ„À…)ÿÿÿ‹F_[^ÃèH°Çè;‹Çëè‹ÿp€Ay€A€A–€AŸ€A¤€A­€A¶€A‹ÿV‹ñŽHèÿŠ„ÀuƒÈÿ^ÃS3Û9^…Àèí¯Çè­:ƒÈÿ龉^8‰^醃F9^Œÿv·F2‹ÎPèØéÿÿ‰Fƒøt¹ƒøwÄÿ$…/‚A‹ÎèÛ
ëEƒN(ÿ‰^$ˆ^0‰^ ‰^,ˆ^<ë8‹Îè›ë'‹ÎèAë‰^(ë!‹Îèæë‹Îèë‹Îèá5„À„gÿÿÿ‹F·f‰F2f…À…gÿÿÿƒFÿ†Pƒ¾P…Eÿÿÿ‹F[^Ëÿ§A°AÅAÎA×AÜAåAîA‹ÿV‹ñŽH芄ÀuƒÈÿ^ÃS3Û9^…ÏèÍ®Çè9ƒÈÿé͉^8‰^醃F9^Œÿv·F2‹ÎPèìèÿÿ‰Fƒøt¹ƒøwÄÿ$…_ƒA‹ÎèÚ	ëEƒN(ÿ‰^$ˆ^0‰^ ‰^,ˆ^<ë8‹Îè¸ë'‹Îè)@ë‰^(ë!‹Îèïë‹Îè]ë‹Îè7„À„gÿÿÿ‹F·f‰F2f…À…gÿÿÿƒF‹ÎèꎄÀ„Aÿÿÿÿ†Pƒ¾P…6ÿÿÿ‹F[^ÃIÇ‚AЂAå‚Aî‚A÷‚Aü‚AƒAƒA‹ÿV‹ñŽHè刄ÀuƒÈÿ^ÃS3Û9^uè¡­Çèa8ƒÈÿéîW‹Îèåÿÿ„À„ÚƒÏÿ‰^8‰^雃F9^Œ¥ÿv·F2‹ÎPèäçÿÿ‹Î‰F赌„À„µ‹Fƒø„™ƒø‡ ÿ$…¿„A‹Îè ëD‰^$ˆ^0‰^ ‰~(‰^,ˆ^<ë4‹Îèë'‹Îèý>ë‰^(ë‹ÎèÀë‹Îèë‹Îè#8„ÀtH‹F·f‰F2f…À…RÿÿÿƒF‹Îè8„Àt&‹Îè<äÿÿ„À…)ÿÿÿ‹F_[^Ã蘬ÇèX7‹Çëè‹ÿ „A)„A=„AF„AO„AT„A]„Af„A‹ÿV‹ñŽHè…‡„ÀuƒÈÿ^ÃS3Û9^…Àè=¬Çèý6ƒÈÿ龉^8‰^醃F9^Œÿv·F2‹ÎPèÊæÿÿ‰Fƒøt¹ƒøwÄÿ$…ß…A‹ÎèšëEƒN(ÿ‰^$ˆ^0‰^ ‰^,ˆ^<ë8‹Îè¢ë'‹Îè>ë‰^(ë!‹ÎèÃë‹ÎèÅë‹ÎèW9„À„gÿÿÿ‹F·f‰F2f…À…gÿÿÿƒFÿ†Pƒ¾P…Eÿÿÿ‹F[^ËÿW…A`…Au…A~…A‡…AŒ…A•…Až…A‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]‹ÿU‹ì‹E	A ]Â3À@9Xu
9\t3ÀÃ3À@9Xu
9\t3ÀÃ3À@9Xu
9\t3ÀÃ3À@9Xu
9\t3ÀððððË‘Xƒúuƒ¹\u°Ãúu	ƒ¹\tï2ÀË‘Xƒúuƒ¹\u°Ãúu	ƒ¹\tï2ÀË‘Xƒúuƒ¹\u°Ãúu	ƒ¹\tï2ÀË‘Xƒúuƒ¹\u°Ãúu	ƒ¹\tï2ÀÃ2ÀÃ2ÀÃ2ÀÃ2Àù\u3À@9Xt3Àù\u3À@9Xt3Àù\u3À@9Xt3Àù\u3À@9Xt3ÀÃ2ÀÃ2ÀÃ2ÀÃ2ÀÃa(°Ãa(°Ãa(°Ãa(°Ãa(°Ãa(°Ãa(°Ãa(°Ãa(°Ãa(°Ãa(°Ãa(°Ã¾A1ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã¾A1ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã¾A1ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã¾A1ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã¾A1ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã¾A1ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã·A2ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã·A2ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã·A2ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã·A2ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã·A2ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ã·A2ƒè t-ƒèt"ƒètHƒètƒèuƒI ëƒI ëƒI ë
ƒI  ëƒI °Ãè·„ÀuèÝ¥Çè02ÀðËÿV‹ñè“ûÿÿ„Àu‹Î貄Àu讥Çèn02À^ð^Ã軄Àuè¥ÇèM02ÀðÃèÆ„Àuèn¥Çè.02ÀðËÿV‹ñèLûÿÿ„Àu‹ÎèÁ„Àuè?¥Çèÿ/2À^ð^ÃèÊ„Àuè¥ÇèÞ/2ÀðÃèÕ„Àuèÿ¤Çè¿/2ÀðËÿV‹ñèûÿÿ„Àu‹ÎèÁ„ÀuèФÇè/2À^ð^Ã軄Àu诤Çèo/2ÀðÃè·„Àuè¤ÇèP/2ÀðËÿV‹ñè¾úÿÿ„Àu‹Î裄Àuèa¤Çè!/2À^ð^Ãè„Àuè@¤Çè/2ÀðËÿVj‹ñè’„Àu^ÃFP¶F1ŽHPè;‰°^ËÿVj‹ñèÉ„Àu^ÃFP¶F1ŽHP艰^ËÿVj‹ñè„Àu^ÃFP¶F1ŽHPè爰^ËÿVj‹ñè7„Àu^ÃFP¶F1ŽHPè:‰°^ËÿVj‹ñèn„Àu^ÃFP¶F1ŽHP艰^ËÿVj‹ñ襄Àu^ÃFP¶F1ŽHPè戰^ÃQÆA<R·Q2ÁHR芈°ÃQÆA<R·Q2ÁHRèoˆ°ÃQÆA<R·Q2ÁHRèTˆ°ÃQÆA<R·Q2ÁHR軈°ÃQÆA<R·Q2ÁHRè ˆ°ÃQÆA<R·Q2ÁHRè…ˆ°ËÿV‹ñW¿€‹FŠN1ÆF<¶Ñ‹‹f…ƒøTt-ƒøh…ë‹A€8hu@ÇA,‰AéÓÇA,éÇÇA,
é»ÇA,鯋QŠ<3u€z2uBÇA,
‰AéŽ<6u€z4uBÇA,‰AëuƒøTt-ƒøh…ë‹A€8hu@ÇA,‰AéÓÇA,éÇÇA,
é»ÇA,鯋QŠ<3u€z2uBÇA,
‰AéŽ<6u€z4uBÇA,‰AëuƒøTt-ƒøh…ë‹A€8hu@ÇA,‰AéÓÇA,éÇÇA,
é»ÇA,鯋QŠ<3u€z2uBÇA,
‰AéŽ<6u€z4uBÇA,‰AëuƒøTt-ƒøh…ë‹A€8hu@ÇA,‰AéÓÇA,éÇÇA,
é»ÇA,鯋QŠ<3u€z2uBÇA,
‰AéŽ<6u€z4uBÇA,‰AëuƒøTt-ƒøh…ë‹A€8hu@ÇA,‰AéÓÇA,éÇÇA,
é»ÇA,鯋QŠ<3u€z2uBÇA,
‰AéŽ<6u€z4uBÇA,‰AëuƒøTt-ƒøh…ë‹A€8hu@ÇA,‰AéÓÇA,éÇÇA,
é»ÇA,鯋QŠ<3u€z2uBÇA,
‰AéŽ<6u€z4uBÇA,‰Aëut7ƒøA„“ƒøCt>ƒøD~ƒøGŽ€ƒøSu‹ÎèoV„À…Ÿ2ÀéÍSjëWƒèZtƒètVHƒèuäQ‹Îè=5ëÒ‹Îè|ëɃøpMt?ƒøg~1ƒøitƒøntƒøou¶‹Îè‚S륋ÎèuM뜃N Qj
‹Îè=댋ÎèJ#냋ÎèËTéwÿÿÿƒès„gÿÿÿHƒètЃè…gÿÿÿQéiÿÿÿ€~0tŠÃé(‹V 3ÀWf‰Eü‹øˆEþ‹ÂÁè„Ãt'‹ÂÁè„ÃtÆEü-ë„ÓtÆEü+ë‹ÂÑè„ÃtÆEü ‹ûŠN1€ùxt€ùXu	‹ÂÁè„Ãu2Û€ùat	€ùAt2Àë°„Ûu„Àt'ÆD=ü0€ùXt	€ùAt2Àë°„À”ÀþÈ$àxˆD=ýƒÇ‹^$+^8+ßöÂuFPS†Hj PèV±ÿÿƒÄÿvFPWEüŽHPèúv‹N ~‹ÁÁè¨tÁéöÁuWS†Hj0Pè±ÿÿƒÄj‹Îè›oƒ?|‹F Áè¨tWS†Hj Pèê°ÿÿƒÄ°_^[‹å]ËÿU‹ìQSV‹ñ3ÛC3ɾF1ƒødl„“ƒøX>t7ƒøA„“ƒøCt>ƒøD~ƒøGŽ€ƒøSu‹Îè³T„À…Ÿ2ÀéØSjëWƒèZtƒètVHƒèuäQ‹Îèž3ëÒ‹Îè°ëɃøpMt?ƒøg~1ƒøitƒøntƒøou¶‹ÎèrQ륋ÎèºK뜃N Qj
‹Îè8<댋Îèu"냋Îè´Réwÿÿÿƒès„gÿÿÿHƒètЃè…gÿÿÿQéiÿÿÿ‹Îè¼Þÿÿ„ÀtŠÃé.€~0uó‹V 3ÀWf‰Eü‹øˆEþ‹ÂÁè„Ãt'‹ÂÁè„ÃtÆEü-ë„ÓtÆEü+ë‹ÂÑè„ÃtÆEü ‹ûŠN1€ùxt€ùXu	‹ÂÁè„Ãu2Û€ùat	€ùAt2Àë°„Ûu„Àt'ÆD=ü0€ùXt	€ùAt2Àë°„À”ÀþÈ$àxˆD=ýƒÇ‹^$+^8+ßöÂuFPS†Hj Pè¯ÿÿƒÄÿvFPWEüŽHPèÀt‹N ~‹ÁÁè¨tÁéöÁuWS†Hj0PèÛ®ÿÿƒÄj‹Îènƒ?|‹F Áè¨tWS†Hj Pè°®ÿÿƒÄ°_^[‹å]ËÿU‹ìQSV‹ñ3ÛC3ɾF1ƒødl„“ƒøX>t7ƒøA„“ƒøCt>ƒøD~ƒøGŽ€ƒøSu‹ÎèõR„À…Ÿ2ÀéÍSjëWƒèZtƒètVHƒèuäQ‹Îè$2ëÒ‹ÎèõëɃøpMt?ƒøg~1ƒøitƒøntƒøou¶‹ÎèWO륋ÎèJ뜃N Qj
‹Îè|;댋Îè´!냋Îè’Péwÿÿÿƒès„gÿÿÿHƒètЃè…gÿÿÿQéiÿÿÿ€~0tŠÃé(‹V 3ÀWf‰Eü‹øˆEþ‹ÂÁè„Ãt'‹ÂÁè„ÃtÆEü-ë„ÓtÆEü+ë‹ÂÑè„ÃtÆEü ‹ûŠN1€ùxt€ùXu	‹ÂÁè„Ãu2Û€ùat	€ùAt2Àë°„Ûu„Àt'ÆD=ü0€ùXt	€ùAt2Àë°„À”ÀþÈ$àxˆD=ýƒÇ‹^$+^8+ßöÂuFPS†Hj Pèí¬ÿÿƒÄÿvFPWEüŽHPè‘r‹N ~‹ÁÁè¨tÁéöÁuWS†Hj0P謬ÿÿƒÄj‹Îè€lƒ?|‹F Áè¨tWS†Hj Pè¬ÿÿƒÄ°_^[‹å]ËÿU‹ìQSV‹ñ3ÛC3ɾF1ƒødl„“ƒøX>t7ƒøA„“ƒøCt>ƒøD~ƒøGŽ€ƒøSu‹Îè9Q„À…Ÿ2ÀéÍSjëWƒèZtƒètVHƒèuäQ‹Îè…0ëÒ‹Îè)ëɃøpMt?ƒøg~1ƒøitƒøntƒøou¶‹ÎèGM륋Îè^H뜃N Qj
‹Îè—:댋Îèß ëƒ‹Îè{Néwÿÿÿƒès„gÿÿÿHƒètЃè…gÿÿÿQéiÿÿÿ€~0tŠÃé(‹V 3ÀWf‰Eü‹øˆEþ‹ÂÁè„Ãt'‹ÂÁè„ÃtÆEü-ë„ÓtÆEü+ë‹ÂÑè„ÃtÆEü ‹ûŠN1€ùxt€ùXu	‹ÂÁè„Ãu2Û€ùat	€ùAt2Àë°„Ûu„Àt'ÆD=ü0€ùXt	€ùAt2Àë°„À”ÀþÈ$àxˆD=ýƒÇ‹^$+^8+ßöÂuFPS†Hj Pè«ÿÿƒÄÿvFPWEüŽHPèyq‹N ~‹ÁÁè¨tÁéöÁuWS†Hj0PèÚªÿÿƒÄj‹Îèøjƒ?|‹F Áè¨tWS†Hj P诪ÿÿƒÄ°_^[‹å]ËÿU‹ìQSV‹ñ3ÛC3ɾF1ƒødl„“ƒøX>t7ƒøA„“ƒøCt>ƒøD~ƒøGŽ€ƒøSu‹Îè}O„À…Ÿ2ÀéØSjëWƒèZtƒètVHƒèuäQ‹Îèæ.ëÒ‹Îè]ëɃøpMt?ƒøg~1ƒøitƒøntƒøou¶‹Îè7K륋Îè£F뜃N Qj
‹Îè²9댋Îè
 냋ÎèdLéwÿÿÿƒès„gÿÿÿHƒètЃè…gÿÿÿQéiÿÿÿ‹Îè;Øÿÿ„ÀtŠÃé.€~0uó‹V 3ÀWf‰Eü‹øˆEþ‹ÂÁè„Ãt'‹ÂÁè„ÃtÆEü-ë„ÓtÆEü+ë‹ÂÑè„ÃtÆEü ‹ûŠN1€ùxt€ùXu	‹ÂÁè„Ãu2Û€ùat	€ùAt2Àë°„Ûu„Àt'ÆD=ü0€ùXt	€ùAt2Àë°„À”ÀþÈ$àxˆD=ýƒÇ‹^$+^8+ßöÂuFPS†Hj Pèá¨ÿÿƒÄÿvFPWEüŽHPè?o‹N ~‹ÁÁè¨tÁéöÁuWS†Hj0Pè ¨ÿÿƒÄj‹Îèeiƒ?|‹F Áè¨tWS†Hj Pèu¨ÿÿƒÄ°_^[‹å]ËÿU‹ìQSV‹ñ3ÛC3ɾF1ƒødl„“ƒøX>t7ƒøA„“ƒøCt>ƒøD~ƒøGŽ€ƒøSu‹Îè¿M„À…Ÿ2ÀéÍSjëWƒèZtƒètVHƒèuäQ‹Îèl-ëÒ‹Îè¢ëɃøpMt?ƒøg~1ƒøitƒøntƒøou¶‹ÎèI륋ÎèE뜃N Qj
‹Îèö8댋ÎèI냋ÎèBJéwÿÿÿƒès„gÿÿÿHƒètЃè…gÿÿÿQéiÿÿÿ€~0tŠÃé(‹V 3ÀWf‰Eü‹øˆEþ‹ÂÁè„Ãt'‹ÂÁè„ÃtÆEü-ë„ÓtÆEü+ë‹ÂÑè„ÃtÆEü ‹ûŠN1€ùxt€ùXu	‹ÂÁè„Ãu2Û€ùat	€ùAt2Àë°„Ûu„Àt'ÆD=ü0€ùXt	€ùAt2Àë°„À”ÀþÈ$àxˆD=ýƒÇ‹^$+^8+ßöÂuFPS†Hj P貦ÿÿƒÄÿvFPWEüŽHPèm‹N ~‹ÁÁè¨tÁéöÁuWS†Hj0Pèq¦ÿÿƒÄj‹ÎèÝgƒ?|‹F Áè¨tWS†Hj PèF¦ÿÿƒÄ°_^[‹å]ËÿU‹ìƒì¡ÀF3ʼnEüSV‹ñ3ÛjAZjX·F2Yƒødk„’;Á>t6;„”ƒøCt?ƒøD~ƒøGŽƒøSu‹ÎèöK„À… 2ÀéäjjëWƒèZtƒètVHƒèuãS‹Îè¿+ëÑ‹ÎèÈëȃøpMt?ƒøg~1ƒøitƒøntƒøouµ‹ÎèþF뤋Îè9C뛃N Sj
‹Îè8ë‹‹Îèfë‚‹ÎèHévÿÿÿƒès„fÿÿÿHƒètЃè…fÿÿÿSéiÿÿÿ8^0…@‹V 3ÉW‹Â‰]ôÁèAf‰]øj _„Át(‹ÂÁè„Át	j-Xf‰Eôë„Ñtj+ëñ‹ÂÑè„Átf‰}ô‹Ù·N2ƒùxtjXXf;Èu
‹ÂÁè¨t´ë2äƒùatjA_f;Ït2Àë°j0_„äu„Àt0jXXf‰|]ôf;ÈtjAXf;Èt2Àë°„À”ÀþÈ$àxf˜f‰D]öƒÃ‹~$+~8+ûöÂuFPW†Hj Pè.¤ÿÿƒÄÿvFPSEôŽHPè0j‹N ^‹ÁÁè¨tÁéöÁuSW†Hj0Pèí£ÿÿƒÄj‹Îè1fƒ;|‹F Áè¨tSW†Hj Pè£ÿÿƒÄ_°‹Mü^3Í[èLÄþÿ‹å]ËÿU‹ìƒì¡ÀF3ʼnEüSV‹ñ3ÛjAZjX·F2Yƒødk„’;Á>t6;„”ƒøCt?ƒøD~ƒøGŽƒøSu‹Îè
J„À… 2ÀéójjëWƒèZtƒètVHƒèuãS‹Îèú)ëÑ‹ÎèÎëȃøpMt?ƒøg~1ƒøitƒøntƒøouµ‹ÎèÀD뤋ÎèPA뛃N Sj
‹Îèð6ë‹‹Îè{ë‚‹ÎèØEévÿÿÿƒès„fÿÿÿHƒètЃè…fÿÿÿSéiÿÿÿ‹Îè~Ñÿÿ„À…I8^0…@‹V 3ÉW‹Â‰]ôÁèAf‰]øj _„Át(‹ÂÁè„Át	j-Xf‰Eôë„Ñtj+ëñ‹ÂÑè„Átf‰}ô‹Ù·N2ƒùxtjXXf;Èu
‹ÂÁè¨t´ë2äƒùatjA_f;Ït2Àë°j0_„äu„Àt0jXXf‰|]ôf;ÈtjAXf;Èt2Àë°„À”ÀþÈ$àxf˜f‰D]öƒÃ‹~$+~8+ûöÂuFPW†Hj Pè¡ÿÿƒÄÿvFPSEôŽHPèÄg‹N ^‹ÁÁè¨tÁéöÁuSW†Hj0Pè¡ÿÿƒÄj‹ÎèPdƒ;|‹F Áè¨tSW†Hj PèV¡ÿÿƒÄ_°‹Mü^3Í[èàÁþÿ‹å]ËÿU‹ìƒì¡ÀF3ʼnEüSV‹ñ3ÛjAZjX·F2Yƒødk„’;Á>t6;„”ƒøCt?ƒøD~ƒøGŽƒøSu‹ÎèH„À… 2ÀéäjjëWƒèZtƒètVHƒèuãS‹Îè=(ëÑ‹ÎèáëȃøpMt?ƒøg~1ƒøitƒøntƒøouµ‹ÎèsB뤋Îè}?뛃N Sj
‹Îè6ë‹‹Îè ë‚‹Îè„Cévÿÿÿƒès„fÿÿÿHƒètЃè…fÿÿÿSéiÿÿÿ8^0…@‹V 3ÉW‹Â‰]ôÁèAf‰]øj _„Át(‹ÂÁè„Át	j-Xf‰Eôë„Ñtj+ëñ‹ÂÑè„Átf‰}ô‹Ù·N2ƒùxtjXXf;Èu
‹ÂÁè¨t´ë2äƒùatjA_f;Ït2Àë°j0_„äu„Àt0jXXf‰|]ôf;ÈtjAXf;Èt2Àë°„À”ÀþÈ$àxf˜f‰D]öƒÃ‹~$+~8+ûöÂuFPW†Hj PèeŸÿÿƒÄÿvFPSEôŽHPège‹N ^‹ÁÁè¨tÁéöÁuSW†Hj0Pè$ŸÿÿƒÄj‹Îè~bƒ;|‹F Áè¨tSW†Hj PèùžÿÿƒÄ_°‹Mü^3Í[胿þÿ‹å]ËÿU‹ìƒì¡ÀF3ʼnEüSV‹ñ3ÛjAZjX·F2Yƒødk„’;Á>t6;„”ƒøCt?ƒøD~ƒøGŽƒøSu‹Îè6F„À… 2ÀéäjjëWƒèZtƒètVHƒèuãS‹Îèx&ëÑ‹Îèç
ëȃøpMt?ƒøg~1ƒøitƒøntƒøouµ‹Îè5@뤋Îè”=뛃N Sj
‹Îèï4ë‹‹Îèµë‚‹Îè?Aévÿÿÿƒès„fÿÿÿHƒètЃè…fÿÿÿSéiÿÿÿ8^0…@‹V 3ÉW‹Â‰]ôÁèAf‰]øj _„Át(‹ÂÁè„Át	j-Xf‰Eôë„Ñtj+ëñ‹ÂÑè„Átf‰}ô‹Ù·N2ƒùxtjXXf;Èu
‹ÂÁè¨t´ë2äƒùatjA_f;Ït2Àë°j0_„äu„Àt0jXXf‰|]ôf;ÈtjAXf;Èt2Àë°„À”ÀþÈ$àxf˜f‰D]öƒÃ‹~$+~8+ûöÂuFPW†Hj PèeÿÿƒÄÿvFPSEôŽHPè*d‹N ^‹ÁÁè¨tÁéöÁuSW†Hj0Pè$ÿÿƒÄj‹Îè¬`ƒ;|‹F Áè¨tSW†Hj PèùœÿÿƒÄ_°‹Mü^3Í[è&½þÿ‹å]ËÿU‹ìƒì¡ÀF3ʼnEüSV‹ñ3ÛjAZjX·F2Yƒødk„’;Á>t6;„”ƒøCt?ƒøD~ƒøGŽƒøSu‹ÎèMD„À… 2ÀéójjëWƒèZtƒètVHƒèuãS‹Îè³$ëÑ‹ÎèíëȃøpMt?ƒøg~1ƒøitƒøntƒøouµ‹Îè÷=뤋Îè«;뛃N Sj
‹ÎèÜ3ë‹‹ÎèÊë‚‹Îèú>évÿÿÿƒès„fÿÿÿHƒètЃè…fÿÿÿSéiÿÿÿ‹ÎèoÊÿÿ„À…I8^0…@‹V 3ÉW‹Â‰]ôÁèAf‰]øj _„Át(‹ÂÁè„Át	j-Xf‰Eôë„Ñtj+ëñ‹ÂÑè„Átf‰}ô‹Ù·N2ƒùxtjXXf;Èu
‹ÂÁè¨t´ë2äƒùatjA_f;Ït2Àë°j0_„äu„Àt0jXXf‰|]ôf;ÈtjAXf;Èt2Àë°„À”ÀþÈ$àxf˜f‰D]öƒÃ‹~$+~8+ûöÂuFPW†Hj PèùšÿÿƒÄÿvFPSEôŽHPè¾a‹N ^‹ÁÁè¨tÁéöÁuSW†Hj0P踚ÿÿƒÄj‹ÎèË^ƒ;|‹F Áè¨tSW†Hj PèšÿÿƒÄ_°‹Mü^3Í[躺þÿ‹å]ËÿU‹ìƒì¡ÀF3ʼnEüSV‹ñ3ÛjAZjX·F2Yƒødk„’;Á>t6;„”ƒøCt?ƒøD~ƒøGŽƒøSu‹Îè_B„À… 2ÀéäjjëWƒèZtƒètVHƒèuãS‹Îèö"ëÑ‹Îè
ëȃøpMt?ƒøg~1ƒøitƒøntƒøouµ‹Îèª;뤋ÎèØ9뛃N Sj
‹Îèî2ë‹‹Îèïë‚‹Îè¦<évÿÿÿƒès„fÿÿÿHƒètЃè…fÿÿÿSéiÿÿÿ8^0…@‹V 3ÉW‹Â‰]ôÁèAf‰]øj _„Át(‹ÂÁè„Át	j-Xf‰Eôë„Ñtj+ëñ‹ÂÑè„Átf‰}ô‹Ù·N2ƒùxtjXXf;Èu
‹ÂÁè¨t´ë2äƒùatjA_f;Ït2Àë°j0_„äu„Àt0jXXf‰|]ôf;ÈtjAXf;Èt2Àë°„À”ÀþÈ$àxf˜f‰D]öƒÃ‹~$+~8+ûöÂuFPW†Hj P蜘ÿÿƒÄÿvFPSEôŽHPèa_‹N ^‹ÁÁè¨tÁéöÁuSW†Hj0Pè[˜ÿÿƒÄj‹Îèù\ƒ;|‹F Áè¨tSW†Hj Pè0˜ÿÿƒÄ_°‹Mü^3Í[è]¸þÿ‹å]Ày1*t
A$Pè›±ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°ËÿV‹ñ€~1*tF$PèDZÿÿ^ÃèJD„Àu^ËÎèÅÿÿ„Àt‹F$…Ày	ƒN ÷؉F$°^Ày1*t
A$Pèè±ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°Ày1*t
A$Pè²ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°ËÿV‹ñ€~1*tF$PèE²ÿÿ^ÃèjD„Àu^ËÎè‡Äÿÿ„Àt‹F$…Ày	ƒN ÷؉F$°^Ày1*t
A$Pèf²ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°Ãfƒy2*t
A$Pè–²ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°ËÿV‹ñfƒ~2*tF$Pèòÿÿ^ÃèˆD„Àu^ËÎèÄÿÿ„Àt‹F$…Ày	ƒN ÷؉F$°^Ãfƒy2*t
A$Pèå²ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°Ãfƒy2*t
A$Pè³ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°ËÿV‹ñfƒ~2*tF$PèD³ÿÿ^Ãè¦D„Àu^ËÎè‚Ãÿÿ„Àt‹F$…Ày	ƒN ÷؉F$°^Ãfƒy2*t
A$Pèf³ÿÿÃA‹A‹@ü‰A$…ÀyƒI ÷Y$°Ãj	XÃj	XÃj	XÃj	XÃjXÃjXÃjXÃjXøØðEøØðEøØðEøØðEøxðEøxðEøxðEøxðEËÿU‹ì‹Eƒøwÿ$…3ÄAjX]Ã3À@]Ãjëôjëð3À]ËÿÄA ÄA%ÄAÄA)ÄA)ÄAÄAÄA-ÄAÄAÄA)ÄAjjèMÃjjè Ãjjè"ÃjjèA#Ãjjè$Ãjjèõ%Ãjjè5'Ãjjèu(Ãjjèé)Ãjjè)+Ãjjèi,ÃjjèÝ-ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,¶F1Pÿvÿ6è„ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿU‹ìQƒeüEüVP‹ñè¦qÿÿ„Àt`‹ÎèTÁÿÿ„ÀtSSW‹}ü…ÿt6‹_…Ût/ÿv,¶F1Pÿvÿ6裃ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_[°^‹å]ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,¶F1Pÿvÿ6è=ƒÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,¶F1Pÿvÿ6èÚ‚ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿU‹ìQƒeüEüVP‹ñè-qÿÿ„Àt`‹Îè%Àÿÿ„ÀtSSW‹}ü…ÿt6‹_…Ût/ÿv,¶F1Pÿvÿ6è^‚ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_[°^‹å]ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,¶F1Pÿvÿ6èøÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,·F2Pÿvÿ6èÕÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿU‹ìQƒeüEüVP‹ñè´pÿÿ„Àt`‹Îèö¾ÿÿ„ÀtSSW‹}ü…ÿt6‹_…Ût/ÿv,·F2Pÿvÿ6èYÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_[°^‹å]ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,·F2Pÿvÿ6èó€ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,·F2Pÿvÿ6è€ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿU‹ìQƒeüEüVP‹ñè;pÿÿ„Àt`‹Îèǽÿÿ„ÀtSSW‹}ü…ÿt6‹_…Ût/ÿv,·F2Pÿvÿ6è€ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_[°^‹å]ËÿSV‹ñWƒF‹F‹xü…ÿt6‹_…Ût/ÿv,·F2Pÿvÿ6è®ÿÿƒÄ‰^4„À·tÑè‰F8ÆF<ë‰F8ëÇF44ñEÇF8ÆF<_^°[ËÿU‹ìQQV‹ñWƒN ‹F(…ÀyŠF1ÿÿëè#Aÿÿ„À„{ÿÿÿ‹ÎèÛ ÿÿ„À„—‹Uü‹MøW‹~ ‹ÇÁè¨t…Ò|…És
÷ÙƒÒ÷ÚƒÏ@‰~ ƒ~(_}	ÇF(ëƒf ÷¸9F(~‰F(‹ÁÂuƒf ßÿuÿuƒûuRQ‹ÎèÉlÿÿëQ‹Îè0gÿÿ‹F Áè¨tƒ~8t‹F4€80tÿN4‹F4Æ0ÿF8°^[‹å]‹ÿU‹ìSV‹ñÿv,èuÝÿÿY‹Ø‹ËƒétxƒétVIƒét3ƒétè•JÇèUÕ2Àé‹F ƒFÁ訋F‹Hø‹PüëX‹F ƒFÁ訋Ft‹@üë?‹Hü3Òë;‹F ƒFÁ訋Ft¿@üë!·@üë‹F ƒFÁ訋Ft¾@üë¶@ü™‹ÈW‹~ ‹ÇÁè¨t…Ò|…És
÷ÙƒÒ÷ÚƒÏ@‰~ ƒ~(_}	ÇF(ëƒf ÷¸9F(~‰F(‹ÁÂuƒf ßÿuÿuƒûuRQ‹ÎèlÿÿëQ‹ÎèYfÿÿ‹F Áè¨tƒ~8t‹F4€80tÿN4‹N4Æ0ÿF8°^[]‹ÿU‹ìSV‹ñÿv,è+ÜÿÿY‹Ø‹ËƒétxƒétVIƒét3ƒétèKIÇèÔ2Àé‹F ƒFÁ訋F‹Hø‹PüëX‹F ƒFÁ訋Ft‹@üë?‹Hü3Òë;‹F ƒFÁ訋Ft¿@üë!·@üë‹F ƒFÁ訋Ft¾@üë¶@ü™‹ÈW‹~ ‹ÇÁè¨t…Ò|…És
÷ÙƒÒ÷ÚƒÏ@‰~ ƒ~(_}	ÇF(ëƒf ÷¸9F(~‰F(‹ÁÂuƒf ßÿuÿuƒûuRQ‹ÎèCkÿÿëQ‹Îè„eÿÿ‹F Áè¨tƒ~8t‹F4€80tÿN4‹N4Æ0ÿF8°^[]‹ÿU‹ìQQSV‹ñÿv,èßÚÿÿƒeø‹ØƒeüY‹Ëƒé„ƒét^Iƒét:ƒétèóGÇè³Ò2Àé&‹F ‹ÎÁè¨EøPtèÇèÉ2Àé‹F ƒFÁ訋F‹Hø‹PüëX‹F ƒFÁ訋Ft‹@üë?‹Hü3Òë;‹F ƒFÁ訋Ft¿@üë!·@üë‹F ƒFÁ訋Ft¾@üë¶@ü™‹ÈW‹~ ‹ÇÁè¨t…Ò|…És
÷ÙƒÒ÷ÚƒÏ@‰~ ƒ~(_}	ÇF(ëƒf ÷¸9F(~‰F(‹ÁÂuƒf ßÿuÿuƒûuRQ‹Îè—dÿÿëQ‹Îè@^ÿÿ‹F Áè¨tƒ~8t‹F4€80tÿN4‹N4Æ0ÿF8°^[]‹ÿV‹ñWƒF‹F‹xüè¡8…Àuè'=ÇèçÇ2ÀëDÿv,èÑÏÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËÿU‹ìQƒeüEüVP‹ñè…Eÿÿ„Àu2Àëv‹Îè’ÿÿ„Àtiè8…Àuèš<ÇèZÇëÖÿv,èFÏÿÿYƒèt4ƒèt#HƒètƒèuЋF‹Mü™‰‰Që‹Eü‹N‰ë‹Eüf‹Nf‰ë‹EüŠNˆÆF0°^‹å]ËÿV‹ñWƒF‹F‹xüè”7…Àuè<ÇèÚÆ2ÀëDÿv,èÄÎÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËÿV‹ñWƒF‹F‹xüè 7…Àuè¦;ÇèfÆ2ÀëDÿv,èPÎÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËÿU‹ìQƒeüEüVP‹ñè‚Dÿÿ„Àu2Àëv‹Îè®ÿÿ„Àtiè“6…Àuè;ÇèÙÅëÖÿv,èÅÍÿÿYƒèt4ƒèt#HƒètƒèuЋF‹Mü™‰‰Që‹Eü‹N‰ë‹Eüf‹Nf‰ë‹EüŠNˆÆF0°^‹å]ËÿV‹ñWƒF‹F‹xüè6…Àuè™:ÇèYÅ2ÀëDÿv,èCÍÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËÿV‹ñWƒF‹F‹xüèŸ5…Àuè%:ÇèåÄ2ÀëDÿv,èÏÌÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËÿU‹ìQƒeüEüVP‹ñèCÿÿ„Àu2Àëv‹ÎèCÿÿ„Àtiè5…Àuè˜9ÇèXÄëÖÿv,èDÌÿÿYƒèt4ƒèt#HƒètƒèuЋF‹Mü™‰‰Që‹Eü‹N‰ë‹Eüf‹Nf‰ë‹EüŠNˆÆF0°^‹å]ËÿV‹ñWƒF‹F‹xüè’4…Àuè9ÇèØÃ2ÀëDÿv,èÂËÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËÿV‹ñWƒF‹F‹xüè4…Àuè¤8ÇèdÃ2ÀëDÿv,èNËÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËÿU‹ìQƒeüEüVP‹ñè|Bÿÿ„Àu2Àëv‹ÎèØÿÿ„Àtiè‘3…Àuè8Çè×ÂëÖÿv,èÃÊÿÿYƒèt4ƒèt#HƒètƒèuЋF‹Mü™‰‰Që‹Eü‹N‰ë‹Eüf‹Nf‰ë‹EüŠNˆÆF0°^‹å]ËÿV‹ñWƒF‹F‹xüè3…Àuè—7ÇèWÂ2ÀëDÿv,èAÊÿÿYƒèt+ƒètHƒètƒèu΋F™‰‰Wë‹F‰ëf‹Ff‰ëŠFˆÆF0°_^ËQ ‹ÂÁè¨t	Ê€‰Q jjè–éÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèÁêÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjè ìÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèKíÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèvîÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèÕïÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèñÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjè+òÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèŠóÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèµôÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjèàõÿÿËQ ‹ÂÁè¨t	Ê€‰Q jjè?÷ÿÿÃjjÇA(ÇA,
è)èÿÿÃjjÇA(ÇA,
è[éÿÿÃjjÇA(ÇA,
èÁêÿÿÃjjÇA(ÇA,
èóëÿÿÃjjÇA(ÇA,
è%íÿÿÃjjÇA(ÇA,
è‹îÿÿÃjjÇA(ÇA,
è½ïÿÿÃjjÇA(ÇA,
èïðÿÿÃjjÇA(ÇA,
èUòÿÿÃjjÇA(ÇA,
è‡óÿÿÃjjÇA(ÇA,
è¹ôÿÿÃjjÇA(ÇA,
èöÿÿËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,¶F1Pÿvÿ6è\LÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<èãéë…ÛuÇF44ñEWÿv4è¦èYY_‰F8°^[ËÿV‹ñW~4Wèe7ÿÿ„Àtf‹Îè‰ÿÿ„ÀtYS‹^(ƒûÿu»ÿÿÿÿv,¶F1Pÿvÿ6èÞKÿÿƒÄ„Àtƒ?uÇ<ñESÿ7ÆF<èféëƒ?uÇ4ñESÿ7è*èYY‰F8[°_^ËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,¶F1Pÿvÿ6èmKÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<èôèë…ÛuÇF44ñEWÿv4è·çYY_‰F8°^[ËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,¶F1Pÿvÿ6èúJÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<èèë…ÛuÇF44ñEWÿv4èDçYY_‰F8°^[ËÿV‹ñW~4Wè6ÿÿ„Àtf‹ÎèAˆÿÿ„ÀtYS‹^(ƒûÿu»ÿÿÿÿv,¶F1Pÿvÿ6è|JÿÿƒÄ„Àtƒ?uÇ<ñESÿ7ÆF<èèëƒ?uÇ4ñESÿ7èÈæYY‰F8[°_^ËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,¶F1Pÿvÿ6èJÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<è’çë…ÛuÇF44ñEWÿv4èUæYY_‰F8°^[ËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,·F2Pÿvÿ6èØIÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<èçYYë…ÛuÇF44ñEjW‹Îèå_‰F8°^[ËÿV‹ñW~4Wèœ5ÿÿ„Àth‹Îèô†ÿÿ„Àt[S‹^(ƒûÿu»ÿÿÿÿv,·F2Pÿvÿ6èYIÿÿƒÄ„Àtƒ?uÇ<ñESÿ7ÆF<è¡æYYëƒ?uÇ4ñEjS‹Î觉F8[°_^ËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,·F2Pÿvÿ6èæHÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<è-æYYë…ÛuÇF44ñEjW‹Îès_‰F8°^[ËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,·F2Pÿvÿ6èrHÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<è¹åYYë…ÛuÇF44ñEjW‹Îè?_‰F8°^[ËÿV‹ñW~4Wè´4ÿÿ„Àth‹Î褅ÿÿ„Àt[S‹^(ƒûÿu»ÿÿÿÿv,·F2Pÿvÿ6èóGÿÿƒÄ„Àtƒ?uÇ<ñESÿ7ÆF<è;åYYëƒ?uÇ4ñEjS‹Îè‰F8[°_^ËÿSV‹ñWƒF‹F‹~(‹Xü‰^4ƒÿÿu¿ÿÿÿÿv,·F2Pÿvÿ6è€GÿÿƒÄ„Àt…ÛuÇF4<ñEWÿv4ÆF<èÇäYYë…ÛuÇF44ñEjW‹ÎèÍ_‰F8°^[ËÿU‹ìÿuÿq4ènãYY]‹ÿU‹ìÿuÿq4èXãYY]‹ÿU‹ìÿuÿq4èBãYY]‹ÿU‹ìÿuÿq4è,ãYY]‹ÿU‹ìÿuÿq4èãYY]‹ÿU‹ìÿuÿq4èãYY]‹ÿU‹ìVW‹ù3ö‹W49u~%SŠ„Àt¶È»€‹G‹‹f…HtBBF;u|Ý[_‹Æ^]‹ÿU‹ìVW‹ù3ö‹W49u~%SŠ„Àt¶È»€‹G‹‹f…HtBBF;u|Ý[_‹Æ^]‹ÿU‹ìVW‹ù3ö‹W49u~%SŠ„Àt¶È»€‹G‹‹f…HtBBF;u|Ý[_‹Æ^]‹ÿU‹ìVW‹ù3ö‹W49u~%SŠ„Àt¶È»€‹G‹‹f…HtBBF;u|Ý[_‹Æ^]‹ÿU‹ìVW‹ù3ö‹W49u~%SŠ„Àt¶È»€‹G‹‹f…HtBBF;u|Ý[_‹Æ^]‹ÿU‹ìVW‹ù3ö‹W49u~%SŠ„Àt¶È»€‹G‹‹f…HtBBF;u|Ý[_‹Æ^]Âjj
èƒßÿÿÃjj
èÃàÿÿÃjj
è7âÿÿÃjj
èwãÿÿÃjj
è·äÿÿÃjj
è+æÿÿÃjj
èkçÿÿÃjj
è«èÿÿÃjj
èêÿÿÃjj
è_ëÿÿÃjj
èŸìÿÿÃjj
èîÿÿÃjjèßÿÿÃjjèKàÿÿÃjjè¿áÿÿÃjjèÿâÿÿÃjjè?äÿÿÃjjè³åÿÿÃjjèóæÿÿÃjjè3èÿÿÃjjè§éÿÿÃjjèçêÿÿÃjjè'ìÿÿÃjjè›íÿÿËÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ì‹E÷Ð!A ]‹ÿU‹ìQV‹ñƒ¾\uƒF‹V‹Jü‰N$鋃eüEüj
Pÿvè¾HƒÄƒ¾XPÿ‹EüH‰NuS…Òx;€8$u6ƒúd}1‹†¤
;Ð~‹Âÿv,‰†¤
‹Î¶F1PÁâ†djÂPèë$èË*Ç苵2ÀëÒ‹„Öl‹‰F$°^‹å]ËÿU‹ìQV‹ñƒ¾\uƒF‹V‹Jü‰N$鋃eüEüj
PÿvèHƒÄƒ¾XPÿ‹EüH‰NuS…Òx;€8$u6ƒúd}1‹†¤
;Ð~‹Âÿv,‰†¤
‹Î¶F1PÁâ†djÂPè°ë$è*ÇèÕ´2ÀëÒ‹„Öl‹‰F$°^‹å]ËÿU‹ìQV‹ñƒ¾\uƒF‹V‹Jü‰N$錃eüEüj
PÿvèZHƒÄƒ¾XPÿ‹EüH‰NuT…ÒxƒÄ…À~4‹Eüj$Yf9u)9žXuh@†dWPèi~þÿƒÄdž\뉞\ƒ¾\uQj
Eø‰}øPÿvè>‹UøƒÄHÿB‰Ž¨
‰F9žXu#…Éx(j$Xf9u ƒùd}‹†¤
;ȋȉŽ¤
ŠÃ_^[‹å]Ãè¢Çèbª2Àëå°ðððÃytƒytèvÇè6ª2ÀðÃytƒytèTÇèª2ÀðÃytƒytè2Çèò©2ÀðÃytƒytèÇèЩ2ÀðËÿV‹ñènÿÿÿ„Àu2À^þ\uOƒ¾XuF‹†¤
–tÁàŽdÐë)‹F‰A‹ƒètƒèt
ƒètƒèuƒFëƒFƒÁ;ÊuÓ°^ÃèŒÇèL©뎋ÿV‹ñèÿÿÿ„Àu2À^þ\uOƒ¾XuF‹†¤
–tÁàŽdÐë)‹F‰A‹ƒètƒèt
ƒètƒèuƒFëƒFƒÁ;ÊuÓ°^ÃèÇę̀뎋ÿV‹ñè²þÿÿ„Àu2À^þ\uOƒ¾XuF‹†¤
–tÁàŽdÐë)‹F‰A‹ƒètƒèt
ƒètƒèuƒFëƒFƒÁ;ÊuÓ°^ÃèŒÇèL¨뎋ÿV‹ñèTþÿÿ„Àu2À^þ\uOƒ¾XuF‹†¤
–tÁàŽdÐë)‹F‰A‹ƒètƒèt
ƒètƒèuƒFëƒFƒÁ;ÊuÓ°^ÃèÇȩ̀뎰ðððù\uGƒ¹Xu>‹‘¨
…Òx!ƒúd}ÿq,¶A1PÁâdjÂPèøÿÿÃè±Çèq§2Àðù\uGƒ¹Xu>‹‘¨
…Òx!ƒúd}ÿq,¶A1PÁâdjÂPèø÷ÿÿÃè^Çè§2Àðù\uGƒ¹Xu>‹‘¨
…Òx!ƒúd}ÿq,·A2PÁâdjÂPèð÷ÿÿÃèÇè˦2Àðù\uGƒ¹Xu>‹‘¨
…Òx!ƒúd}ÿq,·A2PÁâdjÂPèê÷ÿÿÃè¸Çèx¦2ÀðððððËÿU‹ì‹MV‹AÁè¨ujQè8ɋоÂFYƒúÿtƒúþtƒà?‹ÊkÀ0Áù¨ÚFë‹Æ€x)u"ƒúÿtƒúþt‹Âƒâ?kò0Áø4…¨ÚFöF-tè-Çèí¥2Àë°^]ðø<ñEø<ñEø<ñEø<ñEø<ñEø<ñEø<ñEø<ñEø<ñEø<ñEø<ñEø<ñEËÿU‹ì‹‹@Áè¨t‹ƒxtÿ1¾EPè²YYƒøÿu‹Eƒÿë‹Eÿ]‹ÿU‹ì‹‹@Áè¨t‹ƒxtÿ1ÿuè›YY¹ÿÿf;Áu‹Eƒÿë‹Eÿ]‹ÿU‹ì‹Ñ‹
‹A;A‹Eu€ytÿëƒÿ‹Š@ëÿ‹ÿ@‹‹ŠEˆ‹ÿ°]‹ÿU‹ì‹Ñ‹
‹A;A‹Eu€ytÿëƒÿ‹Š@ëÿ‹ÿ@‹‹f‹Ef‰‹ƒ°]‹ÿU‹ìƒì¡ÀF3ʼnEüSV‹ñW€~<t]‹F8…À~V‹~43Û…Àte·ƒeðPjEôPEðPèAƒÄ…Àu&9Eðt!ÿvFPÿuðEôPŽHèÀC;^8u»ëƒNÿëÿvFPÿv8ŽHÿv4èš‹Mü°_^3Í[è•aþÿ‹å]‹ÿU‹ìƒì¡ÀF3ʼnEüSV‹ñW€~<t]‹F8…À~V‹~43Û…Àte·ƒeðPjEôPEðP蚃ąÀu&9Eðt!ÿvFPÿuðEôPŽHèC;^8u»ëƒNÿëÿvFPÿv8ŽHÿv4èó‹Mü°_^3Í[èî`þÿ‹å]‹ÿU‹ìƒì¡ÀF3ʼnEüSV‹ñW€~<t]‹F8…À~V‹~43Û…Àte·ƒeðPjEôPEðPèóƒÄ…Àu&9Eðt!ÿvFPÿuðEôPŽHèrC;^8u»ëƒNÿëÿvFPÿv8ŽHÿv4èL‹Mü°_^3Í[èG`þÿ‹å]‹ÿU‹ìƒì¡ÀF3ʼnEüSV‹ñW€~<t]‹F8…À~V‹~43Û…Àte·ƒeðPjEôPEðPèLƒÄ…Àu&9Eðt!ÿvFPÿuðEôPŽHèâC;^8u»ëƒNÿëÿvFPÿv8ŽHÿv4輋Mü°_^3Í[è _þÿ‹å]‹ÿU‹ìƒì¡ÀF3ʼnEüSV‹ñW€~<t]‹F8…À~V‹~43Û…Àte·ƒeðPjEôPEðP襃ąÀu&9Eðt!ÿvFPÿuðEôPŽHè;C;^8u»ëƒNÿëÿvFPÿv8ŽHÿv4è‹Mü°_^3Í[èù^þÿ‹å]‹ÿU‹ìƒì¡ÀF3ʼnEüSV‹ñW€~<t]‹F8…À~V‹~43Û…Àte·ƒeðPjEôPEðPèþƒÄ…Àu&9Eðt!ÿvFPÿuðEôPŽHè”C;^8u»ëƒNÿëÿvFPÿv8ŽHÿv4èn‹Mü°_^3Í[èR^þÿ‹å]‹ÿU‹ìQQSV‹ñW€~<uV‹F8…À~O‹^43ÿ…Àt^3Àf‰Eü‹FP‹ÿpEüSP觃ĉEø…À~NQÿuüŽHèøúÿÿ]øG;~8uÂëƒNÿëÿvFPÿv8ŽHÿv4èL_^°[‹å]‹ÿU‹ìQQSV‹ñW€~<uV‹F8…À~O‹^43ÿ…Àt^3Àf‰Eü‹FP‹ÿpEüSPèƒÄ‰Eø…À~NQÿuüŽHèmúÿÿ]øG;~8uÂëƒNÿëÿvFPÿv8ŽHÿv4èÁ_^°[‹å]‹ÿU‹ìQQSV‹ñW€~<uV‹F8…À~O‹^43ÿ…Àt^3Àf‰Eü‹FP‹ÿpEüSPè‘ÿƒÄ‰Eø…À~NQÿuüŽHèâùÿÿ]øG;~8uÂëƒNÿëÿvFPÿv8ŽHÿv4è6_^°[‹å]‹ÿU‹ìQQSV‹ñW€~<uV‹F8…À~O‹^43ÿ…Àt^3Àf‰Eü‹FP‹ÿpEüSPèÿƒÄ‰Eø…À~NQÿuüŽHèÙùÿÿ]øG;~8uÂëƒNÿëÿvFPÿv8ŽHÿv4èË_^°[‹å]‹ÿU‹ìQQSV‹ñW€~<uV‹F8…À~O‹^43ÿ…Àt^3Àf‰Eü‹FP‹ÿpEüSPè{þƒÄ‰Eø…À~NQÿuüŽHèNùÿÿ]øG;~8uÂëƒNÿëÿvFPÿv8ŽHÿv4è@_^°[‹å]‹ÿU‹ìQQSV‹ñW€~<uV‹F8…À~O‹^43ÿ…Àt^3Àf‰Eü‹FP‹ÿpEüSPèðýƒÄ‰Eø…À~NQÿuüŽHèÃøÿÿ]øG;~8uÂëƒNÿëÿvFPÿv8ŽHÿv4èµ_^°[‹å]‹ÿU‹ìQQS‹Ù‹‹@Áè¨t‹ƒxu
‹M‹Eë[‹EV‹uW‹}ljEü‹ƒ&‰Mø;øt2‹EP¶‹ËPè}÷ÿÿ‹Eƒ8ÿuƒ>*uPj?‹Ëèf÷ÿÿ‹EG;}üuÔ‹Møƒ>u…Ét‰_^[‹å]‹ÿU‹ìQQS‹Ù‹‹@Áè¨t‹ƒxu
‹M‹Eë^‹EV‹uW‹}‹ƒ&G‰Mø‰Eü;øt4‹EP·‹ËPè/÷ÿÿ‹Eƒ8ÿuƒ>*uPj?‹Ëè÷ÿÿ‹EƒÇ;}üuÒ‹Møƒ>u…Ét‰_^[‹å]‹ÿU‹ìQQVW‹}‹Á‰Eø‹ƒ'‹‰Mü‹p9pu€xt
‹M‹EëJ‹EƒÿëE+pS‹];ór‹óVÿuÿ0è®N‹MøƒÄ‹0‹p‹€x‹Etë;ótƒÿë0[‹Müƒ?u…Ét‰_^‹å]‹ÿU‹ìQQS‹]‹ÁW‰Eø‹ƒ#‹‰Mü‹z9zu€zt
‹M‹EëQ‹EƒÿëL+z‹E;ør‹øV4?Vÿuÿ2èN‹MøƒÄ‹0‹^x‹€x‹Et‹Më;}tƒÿë8‹Müƒ;u…Ét‰_[‹å]‹ÿU‹ì‹E¶M‹‹·H%€]ËÿU‹ìƒì,‹E‹U‹M‰Eð‹E‰Eø‹E‰Eè‹E‰Mô‰Uü‰Eì…Òuè
ÇèÊšƒÈÿë.…ÉtçEü‰EÔEø‰EØEè‰EÜEô‰EàEð‰EäEÔPRè3óþÿYY‹å]ËÿU‹ìƒì,‹E‹U‹M‰Eð‹E‰Eø‹E‰Eè‹E‰Mô‰Uü‰Eì…Òuè“ÇèSšƒÈÿë.…ÉtçEü‰EÔEø‰EØEè‰EÜEô‰EàEð‰EäEÔPRèlòþÿYY‹å]ËÿU‹ìƒì,‹E‹U‹M‰Eð‹E‰Eø‹E‰Eè‹E‰Mô‰Uü‰Eì…ÒuèÇèÜ™ƒÈÿë.…ÉtçEü‰EÔEø‰EØEè‰EÜEô‰EàEð‰EäEÔPRè•òþÿYY‹å]ËÿU‹ìƒì,‹E‹U‹M‰Eð‹E‰Eø‹E‰Eè‹E‰Mô‰Uü‰Eì…Òuè¥Çèe™ƒÈÿë.…ÉtçEü‰EÔEø‰EØEè‰EÜEô‰EàEð‰EäEÔPRè¦ñþÿYY‹å]ËÿU‹ìƒì,‹E‹U‹M‰Eð‹E‰Eø‹E‰Eè‹E‰Mô‰Uü‰Eì…Òuè.ÇèÈÿë.…ÉtçEü‰EÔEø‰EØEè‰EÜEô‰EàEð‰EäEÔPRèñþÿYY‹å]ËÿU‹ìƒì,‹E‹U‹M‰Eð‹E‰Eø‹E‰Eè‹E‰Mô‰Uü‰Eì…Òuè·
Çèw˜ƒÈÿë.…ÉtçEü‰EÔEø‰EØEè‰EÜEô‰EàEð‰EäEÔPRèhðþÿYY‹å]ËÿU‹ìÿu$ÿu ÿuÿuÿuÿuÿuÿuèFóþÿƒÄ ]ËÿU‹ìÿu$ÿu ÿuÿuÿuÿuÿuÿuè#ôþÿƒÄ ]ËÿU‹ìÿu ÿuÿuÿuÿuÿuÿuè‹ûþÿƒÄ]ËÿU‹ìÿu ÿuÿuÿuÿuÿuÿuèä÷þÿƒÄ]ËÿU‹ìÿu ÿuÿuÿuÿuÿuÿuèDþþÿƒÄ]ËÿU‹ìÿu ÿuÿuÿuÿuÿuÿuè›üþÿƒÄ]ËÿU‹ìÿu ÿuÿuÿuÿuÿuÿuè5ùþÿƒÄ]ËÿU‹ìÿu ÿuÿuÿuÿuÿuÿuèPþþÿƒÄ]ÃÃÌÌÌÌÌÌÌÌ‹ÿU‹ìQ¡ÀF3ʼnEü‹MS‹];Ùvl‹EVW‹ò‹ù;ów(ëI‹MWVÿвEÿUƒÄ…À~‹þ‹Eð;óvà‹M‹ð‹Ó;ût!…Àt+ûŠRŠLÿˆDÿˆJÿƒîuë‹E‹M+Ø;Ùwž_^‹Mü3Í[è Tþÿ‹å]ÃÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹EW‹};øt&V‹u…öt+ø›Š@ŠTÿˆLÿˆPÿƒîuë^_]ÃÌÌÌÌÌÌÌ‹ÿU‹ìì¡ÀF3ʼnEü‹M‹U‰üþÿÿV‹u‰µÿÿÿW‹}‰½ÿÿÿ…Éu$…Òt è$Çèä•_^‹Mü3ÍèySþÿ‹å]Ã…ÿtÜ…ötØÇ…øþÿÿƒú‚J¯×Sщ•ÿÿÿ‹Â3Ò+Á÷÷XƒûwVWÿµÿÿÿQè}þÿÿƒÄé·Ñë¯ßÙSQ‹Î‰ðþÿÿÿвEÿփąÀ~WSÿµüþÿÿèèþÿÿƒÄÿµÿÿÿ‹ÎÿµüþÿÿÿвEÿփąÀ~Wÿµÿÿÿÿµüþÿÿè¶þÿÿƒÄÿµÿÿÿ‹ÎSÿвEÿփąÀ~WÿµÿÿÿSèŽþÿÿƒÄ‹…ÿÿÿ‹ø‹µüþÿÿ‹•ÿÿÿ‰…ìþÿÿ;Þv7ò‰µôþÿÿ;ós%‹ÿÿÿSVÿвEÿ•ÿÿÿ‹•ÿÿÿƒÄ…À~Ó;Þw=‹…ÿÿÿ‹½ÿÿÿò;ðwSV‹ÏÿвEÿ׋•ÿÿÿƒÄ…À‹…ÿÿÿ~Û‹½ìþÿÿ‰µôþÿÿ‹µÿÿÿ뛋•ÿÿÿ+ú;ûvSW‹ÎÿвEÿփąÀá‹•ÿÿÿ‹µôþÿÿ‰½ìþÿÿ;þr^‰•èþÿÿ‰½äþÿÿ;÷t3‹Þ‹×‹µèþÿÿ+ߊRŠLÿˆDÿˆJÿƒîu답ôþÿÿ‹ðþÿÿ‹•ÿÿÿ‹…ÿÿÿ;ß…úþÿÿ‹Þ‰ðþÿÿéíþÿÿú;ßs2¤$+ú;ûv%‹ÿÿÿSWÿвEÿ•ÿÿÿ‹•ÿÿÿƒÄ…ÀtÙ;ßr/‹µÿÿÿ+ú;½üþÿÿvSW‹ÎÿвEÿÖ‹•ÿÿÿƒÄ…ÀtÝ‹µôþÿÿ‹•ÿÿÿ‹Ç‹üþÿÿ‹Ê+Î+Ã;Á|9;ßs‹…øþÿÿ‰œ…ÿÿÿ‰|…„@‰…øþÿÿ‹½ÿÿÿ;òsL‹Î‹µÿÿÿ‰üþÿÿéjýÿÿ;òs‹…øþÿÿ‰´…ÿÿÿ‰T…„@‰…øþÿÿ‹üþÿÿ‹µÿÿÿ;Ïs‹×‹½ÿÿÿé+ýÿÿ‹µÿÿÿ닽ÿÿÿ‹…øþÿÿƒè‰…øþÿÿx‹Œ…ÿÿÿ‹T…„‰üþÿÿéöüÿÿ[‹Mü_3Í^èåÿÿƒÄÿuèñÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèåÿÿƒÄÿuèÔðÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèääÿÿƒÄÿuèçÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè·äÿÿƒÄÿuèzðÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèŠäÿÿƒÄjèNðÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè^äÿÿƒÄÿuè!ðÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè1äÿÿƒÄÿuèiæÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèäÿÿƒÄÿuèÇïÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè×ãÿÿƒÄÿuèšïÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèãÿÿƒÄjèÈìÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPècãÿÿƒÄjèãÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè7ãÿÿƒÄjèpìÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèãÿÿƒÄjè7ãÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèßâÿÿƒÄjèìÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè³âÿÿƒÄjèìëÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè¢âÿÿƒÄjèfîÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèvâÿÿƒÄjè¯äÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèJâÿÿƒÄjèîÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèâÿÿƒÄjèWäÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèòáÿÿƒÄjè¶íÿÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèÆáÿÿƒÄjèŠíÿÿƒÄ‹å]ËÿU‹ìQQƒeøEøjPè^YYƒøtƒÈÿë‹Eø‹M…Ét‰‹å]ËÿU‹ìƒì3ÀW}ð«j«««EðPè YY_ƒøtƒÈÿ‹Ðë‹Uô‹Eð‹M…Ét‰‰Q‹å]ËÿU‹ìQQV‹u…öuèýßÿÿÇè½j3ÀëSƒ}uöƒeøEøƒeüSPè`€‹Mø‹Eüé€>Õjh€–˜Þ±PQèa‰]ü[…Ò|	»=Òÿw´kÉd‰3À@‰N^‹å]ËÿU‹ìQQV‹u…öuè‚ßÿÿÇèBj3ÀëWƒ}uöƒeøEøƒeüSPèå‹Mø‹Eüé€>Õjh€–˜Þ±PQèæ‰]ü[ƒú|	º=ÿo@“w³kÉd‰3À‰V@‰N^‹å]ËÿU‹ìQQƒeøEøjPèðþÿÿYYƒøtƒÈÿë‹Eø‹M…Ét‰‹å]ËÿU‹ìƒì3ÀW}ð«j«««EðPè2ÿÿÿYY_ƒøtƒÈÿ‹Ðë‹Uô‹Eð‹M…Ét‰‰Q‹å]ËÿU‹ì]é‡þÿÿ‹ÿU‹ì]é÷þÿÿ‹ÿU‹ìVè)ó‹ð…ötÿuVè4÷ØYÀ÷ÐY#Æ^]ËÿU‹ìVèó‹ð…ötÿuVè÷ØYÀ÷ÐY#Æ^]ËÿU‹ìƒìV‹u…öuè*Þÿÿj^‰0èëh‹ÆéžWj	ƒÈÿ‹þYó«‹}…ÿuèÞÿÿj^‰0èÃhëƒ?|?Òÿ~èäÝÿÿj^‰0‹Æé\Sèû3ÛEôP‰]ô‰]ð‰]øèììY…À…wEðPèíY…À…eEøPè íY…À…S‹=€ô~_=ÿÝû}X+Eø‰EüEüPVè}òYY…À…ê9]ô„ßVèÜúY…À„ЋEð)EüEüPVèKòYY…À…¸ÇF éªWVè.òYY…À…›‹>9]ôtVèúY…Àt‹EøEð+øÇF ë+}ø‹Çj<™[÷û‰…ÒyJ<+û‰‹Ç™÷û‹ø~‹Ç™÷û‰V…ÒyJ<+û‰N‹Ç™÷ûj‹ø~‹Ç™[÷û‰V…ÒyJ+û‰N‹Ç™÷û‹È…É~‹FÁj™_÷ÿN‰VN3À[_^‹å]Ãyõ‹FƒÀNÁj™_÷ÿ‹F‰V…À׃ÀÇF‰FmFÿNë¿SSSSSè,gÌ‹ÿU‹ìƒìV‹u…öuèÜÿÿj^‰0èßf‹ÆëSWj	ƒÈÿ‹þYó«‹}…ÿuèùÛÿÿj^‰0èºf‹Æë-S3Û9_|9rjX9G|?ÿo@“vèÆÛÿÿj^‰0‹Æ[_^‹å]ÃèæøEø‰]øP‰]ô‰]üèÏêY…À…äEôPèéêY…À…ÒEüPèëY…À…À‹_‹…Û|ù€ôvujX;Øn|ù{<“sd‹Eü™+ÈEìPÚ‰MìV‰]ðèvðYY…À…oÿÿÿ9Eø„*Vè£øY…À„‹Eô™)EìEìPUðVè@ðYY…À…9ÿÿÿÇF éñWVè#ðYY…À…ÿÿÿƒ}ø‹™‹ø‹ÚtVèLøY…Àt‹EüEôÇF ë‹Eü™+øjj<ÚSWèÛ‰…ÀyƒÀ<ƒÇĉƒÓÿjj‰½xÿÿÿ‰…|ÿÿÿM„…lÿÿÿ‰}€Pÿu…xÿÿÿÿuÿuPè_M„è秀½tÿÿÿ^t
‹hÿÿÿƒ¡Pý‹Mü3Í_èÆþÿ‹å]ËÿU‹ìƒì|W‹}…ÿuèAÎÿÿÇèYƒÈÿ邃}tâSV‹u3Ûƒþÿu‹÷Nf‹ƒÆf;Ãuõ+ñÑþÿuMäèú§þÿÿu w‰}ô‰EøM„Eè‰}üPÿuEôÿuÿuPèñ^M„èK¨ÿuЋðè¨PY‰]Ð8]ðt
‹M䃡Pý‹Æ^[_‹å]ËÿU‹ìQQ‹E‰EøEøPÿuÆEüètYY‹å]ËÿU‹ìQQ‹E‰EøEøPÿuÆEüèÞsYY‹å]ËÿU‹ìQQ‹E‰EøEøPÿuÆEüè~‘YY‹å]ËÿU‹ìQQ‹E‰EøEøPÿuÆEüè[‘YY‹å]ÃÃÃÃÃÃÃÃËÿU‹ì‹E¶PèqùÿÿY]ËÿU‹ì‹Ej·PèÚYY]ËÿU‹ìÿu‹MÿuÿuÿuèE\‹E]ËÿU‹ìÿu‹MÿuÿuÿuèX\‹E]ËÿU‹ìÿu‹Mÿuÿuÿuèk\‹E]ËÿU‹ìÿu‹Mÿuÿuÿuè~\‹E]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…ÀuèGÌÿÿÇèW3À@ë"ðüÿÿQMQPèŽVðüÿÿQPè.2ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèeþÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…ÀuèÌËÿÿÇèŒV3À@ë"ðüÿÿQMQPèVðüÿÿQPèÃ2ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèêþÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…ÀuèQËÿÿÇèV3À@ë"ðüÿÿQMQPèÿVðüÿÿQPè81ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèoþÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…ÀuèÖÊÿÿÇè–U3À@ë"ðüÿÿQMQPè„VðüÿÿQPèÍ1ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèôþÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…Àuè[ÊÿÿÇèU3À@ë"ðüÿÿQMQPè7VðüÿÿQPèB0ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèyþÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…ÀuèàÉÿÿÇè T3À@ë"ðüÿÿQMQPè¼VðüÿÿQPè×0ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèþþÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…ÀuèeÉÿÿÇè%T3À@ë"ðüÿÿQMQPè¨VðüÿÿQPèL/ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèƒþÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹u,…öt…ÀuèêÈÿÿÇèªS3À@ë"ðüÿÿQMQPè-VðüÿÿQPèá/ƒÄ‹U$^…Òt
‹MM uˆ
‹Mü3Íèþÿ‹å]ËÿU‹ìƒì$V‹u‹ÎWèо„ÀujXéA‹F‹Î‰Eè‹FS‰Eì艒‹]Mù‰MàMè‰u܉Mäë‹Îèn’SˆEù¶ÀjPèòáÿÿƒÄ…ÀuãŠMù‹U€ù-”Àˆ‚€ù-t€ù+u‹Îè5’ŠÈˆMù€ùI„·€ùi„®€ùN„“€ùn„Š3Ûˆ]ÿ€ù0uC‹F‹Î‹~‰Eðèò‘ˆEô
fƒún„4
3Àj0Y‰EìŠøˆ}ÿf;ÑuS‹w‹]‹Ë‹èŸ·ÀƒøxtƒøXt‹ûP‹Ïèí·f‹Uø3ÀŠøë‹ËÆEÿèsf‹Ð‰}Ü‹ûf‰UøŠ}ÿ3À‰uØ‹uä‹MŠØj0‰EàƒÁX‰Mèf;ÐuP³^‹Ïè;f‹Ðf‰Uøf;Ötí‹uäj0X3ÉÇE˜:„ÿÇ…HÿÿÿÿÇ…`ÿÿÿ`”ÁÇEÈjIÇE€ðƒáÇEÀúƒÁ	Ç…Lÿÿÿf	‰@ÿÿÿÇE¸p	Ç…xÿÿÿæ	ÇE°ð	Ç…Xÿÿÿf
ÇE¨p
Ç…pÿÿÿæ
ÇE ð
Ç…DÿÿÿfÇEÔpÇ…hÿÿÿfÇEpÇ…PÿÿÿæÇEˆðÇEÐf
ÇEÌp
ÇEÄPÇE¼ZÇE´ÐÇE¬ÚÇE¤ ÇEœ*ÇE”@ÇEŒJÇE„àÇ…|ÿÿÿêÇ…tÿÿÿÇ…lÿÿÿÇ…dÿÿÿÿÇ…\ÿÿÿAÇ…TÿÿÿZÇEôaÇEðf;Ђf;U˜s·Âƒè0éõf;•HÿÿÿƒÒf;•`ÿÿÿ‚àf;UÈs
·Â-`éÈf;U€‚Ãf;UÀs
·Â-ðé«f;•Lÿÿÿ‚£f;U¸s
·Â-f	é‹f;•xÿÿÿ‚ƒf;U°s
·Â-æ	ékf;•Xÿÿÿ‚cf;U¨s
·Â-f
éKf;•pÿÿÿ‚Cf;U s
·Â-æ
é+f;•Dÿÿÿ‚#f;UÔs
·Â-féf;•hÿÿÿ‚f;Us
·Â-féëf;•Pÿÿÿ‚ãf;Uˆs
·Â-æéËf;UЂÆf;UÌs
·Â-f
é®f;UÄ‚©f;U¼s
·Â-Pé‘f;U´‚Œf;U¬s
·Â-Ðëwf;U¤rvf;Uœs
·Â- ëaf;U”r`f;UŒs
·Â-@ëKf;U„rJf;•|ÿÿÿs
·Â-àë2f;•tÿÿÿr.f;•lÿÿÿs%·Â-ëf;•dÿÿÿs
·Â-ÿëƒÈÿƒøÿu:f9•\ÿÿÿw	f;•Tÿÿÿv
f‹Âf+Eôf;Eðwf‹Âf+Eôf;Eð·Âwƒè ƒÀÉëƒÈÿ;Áw.‹Mè³;ÎtˆA‰MèÿEà‹Ïèl‰‹@ÿÿÿf‹Ðj0f‰UøXé€ýÿÿ‹E‹‹€ˆ‹¾·Â;Á…É‹Ïè5‰‹Uèf‹È‹E‹uäƒÀj0;Ðf‰MøXu*f;Èu%‹uೋÏNè	‰f‹Èj0Xf‰Møf;Èté‹Uè‰uà‹u䋽@ÿÿÿf;È‚f;M˜s·Áƒè0éõf;HÿÿÿƒÒf;`ÿÿÿ‚àf;MÈs
·Á-`éÈf;M€‚Ãf;MÀs
·Á-ðé«f;Lÿÿÿ‚£f;M¸s
·Á-f	é‹f;xÿÿÿ‚ƒf;M°s
·Á-æ	ékf;Xÿÿÿ‚cf;M¨s
·Á-f
éKf;pÿÿÿ‚Cf;M s
·Á-æ
é+f;Dÿÿÿ‚#f;MÔs
·Á-féf;hÿÿÿ‚f;Ms
·Á-féëf;Pÿÿÿ‚ãf;Mˆs
·Á-æéËf;MЂÆf;MÌs
·Á-f
é®f;MÄ‚©f;M¼s
·Á-Pé‘f;M´‚Œf;M¬s
·Á-Ðëwf;M¤rvf;Mœs
·Á- ëaf;M”r`f;MŒs
·Á-@ëKf;M„rJf;|ÿÿÿs
·Á-àë2f;tÿÿÿr.f;lÿÿÿs%·Á-ëf;dÿÿÿs
·Á-ÿëƒÈÿƒøÿu:f9\ÿÿÿw	f;Tÿÿÿv
f‹Áf+Eôf;Eðwf‹Áf+Eôf;Eð·Áwƒè ƒÀÉëƒÈÿ;Çw&³;ÖtˆB‰Uè‹Mè…†‹Uèf‹Èj0f‰MøXéˆýÿÿ„Ûu&4ÿÿÿèšP„À„­3À„ÿ”ÀHƒàûƒÀéáÿuø‹u‹Îè¡°‹F‹Î‰EØ‹F‰EÜè)†f‰Eø3Û·ÀŠËƒøEtƒøPt
ƒøet
ƒøpuŠMÿë8]ÿ”Á¿P„É„ñ‹Îèë…f‹Èj-Xf;Èf‰Møj+Z”Çf;Êtf;Èu‹ÎèÇ…f‹Èf‰Møj03ÒXŠÚf;Èu³‹Îè«…f‹Èj0Xf‰Møf;Ètê3Òf;È‚f;M˜s·Áƒè0éõf;HÿÿÿƒÒf;`ÿÿÿ‚àf;MÈs
·Á-`éÈf;M€‚Ãf;MÀs
·Á-ðé«f;Lÿÿÿ‚£f;M¸s
·Á-f	é‹f;xÿÿÿ‚ƒf;M°s
·Á-æ	ékf;Xÿÿÿ‚cf;M¨s
·Á-f
éKf;pÿÿÿ‚Cf;M s
·Á-æ
é+f;Dÿÿÿ‚#f;MÔs
·Á-féf;hÿÿÿ‚f;Ms
·Á-féëf;Pÿÿÿ‚ãf;Mˆs
·Á-æéËf;MЂÆf;MÌs
·Á-f
é®f;MÄ‚©f;M¼s
·Á-Pé‘f;M´‚Œf;M¬s
·Á-Ðëwf;M¤rvf;Mœs
·Á- ëaf;M”r`f;MŒs
·Á-@ëKf;M„rJf;|ÿÿÿs
·Á-àë2f;tÿÿÿr.f;lÿÿÿs%·Á-ëf;dÿÿÿs
·Á-ÿëƒÈÿƒøÿu:f9\ÿÿÿw	f;Tÿÿÿv
f‹Áf+Eôf;Eðwf‹Áf+Eôf;Eð·Áwƒè ƒÀÉëƒÈÿƒø
s.kÒ
³ЉUì;׋Îè2ƒ‹Uìf‹Èj0f‰MøXé†ýÿÿÇEìQj0Zf;Ê‚Žf;M˜s
·Á+Âéy‹•Hÿÿÿf;ʃZ‹•`ÿÿÿf;Ê‚`f;MÈrÒ‹U€f;Ê‚Nf;MÀrÀ‹•Lÿÿÿf;Ê‚9f;M¸r«‹•xÿÿÿf;Ê‚$f;M°r–‹•Xÿÿÿf;Ê‚f;M¨r‹•pÿÿÿf;Ê‚úf;M ‚hÿÿÿ‹•Dÿÿÿf;Ê‚áf;MÔ‚Oÿÿÿ‹•hÿÿÿf;Ê‚Èf;M‚6ÿÿÿ‹•Pÿÿÿf;Ê‚¯f;Mˆ‚ÿÿÿ‹UÐf;Ê‚™f;MÌ‚ÿÿÿ‹UÄf;Ê‚ƒf;M¼‚ñþÿÿ‹U´f;Êrqf;M¬‚ßþÿÿ‹U¤f;Êr_f;Mœ‚Íþÿÿ‹U”f;ÊrMf;MŒ‚»þÿÿ‹U„f;Êr;f;|ÿÿÿ‚¦þÿÿ‹•tÿÿÿf;Êr#f;lÿÿÿséþÿÿf;dÿÿÿ‚€þÿÿƒÈÿƒøÿu$f9\ÿÿÿw	f;Tÿÿÿv*‹Uôf‹Áf+Âf;EðvƒÈÿƒø
s-‹ÎèOf‹Èf‰Møé*þÿÿ‹Uôf‹Áf+Âf;Eð·Áwƒè ƒÀÉë΄ÿt÷]ì„Ûu4ÿÿÿèIK„Àt`‹Îèf‰Eø‹]ìÿuø‹Îè\«‹u‹MèV;ÊtX€yÿuI;Êuõ;ÊtI;ß$¿°ëÿÿ;ß|'3À8Eÿ”ÀHƒà@¯EàØûP~j	ëjë;ß}jë3À‰+Ê8Eÿ‰N•Àë*jXë%ÿuÜEøÿuØWPèõëÿuÜEøÿuØWPè!ƒÄ^_[‹å]ËÿU‹ìƒì$V‹u‹ÎWè}¬„ÀujXéA‹F‹Î‰Eè‹FS‰Eìèf€‹]Mù‰MàMè‰u܉Mäë‹ÎèK€SˆEù¶ÀjPè]ÏÿÿƒÄ…ÀuãŠMù‹U€ù-”Àˆ‚€ù-t€ù+u‹Î耊ȈMù€ùI„·€ùi„®€ùN„“€ùn„Š3Ûˆ]ÿ€ù0uC‹F‹Î‹~‰EðèψEô
fƒún„4
3Àj0Y‰EìŠøˆ}ÿf;ÑuS‹w‹]‹Ë‹è}{·ÀƒøxtƒøXt‹ûP‹ÏèÞ¥f‹Uø3ÀŠøë‹ËÆEÿèQ{f‹Ð‰}Ü‹ûf‰UøŠ}ÿ3À‰uØ‹uä‹MŠØj0‰EàƒÁX‰Mèf;ÐuP³^‹Ïè{f‹Ðf‰Uøf;Ötí‹uäj0X3ÉÇE˜:„ÿÇ…HÿÿÿÿÇ…`ÿÿÿ`”ÁÇEÈjIÇE€ðƒáÇEÀúƒÁ	Ç…Lÿÿÿf	‰@ÿÿÿÇE¸p	Ç…xÿÿÿæ	ÇE°ð	Ç…Xÿÿÿf
ÇE¨p
Ç…pÿÿÿæ
ÇE ð
Ç…DÿÿÿfÇEÔpÇ…hÿÿÿfÇEpÇ…PÿÿÿæÇEˆðÇEÐf
ÇEÌp
ÇEÄPÇE¼ZÇE´ÐÇE¬ÚÇE¤ ÇEœ*ÇE”@ÇEŒJÇE„àÇ…|ÿÿÿêÇ…tÿÿÿÇ…lÿÿÿÇ…dÿÿÿÿÇ…\ÿÿÿAÇ…TÿÿÿZÇEôaÇEðf;Ђf;U˜s·Âƒè0éõf;•HÿÿÿƒÒf;•`ÿÿÿ‚àf;UÈs
·Â-`éÈf;U€‚Ãf;UÀs
·Â-ðé«f;•Lÿÿÿ‚£f;U¸s
·Â-f	é‹f;•xÿÿÿ‚ƒf;U°s
·Â-æ	ékf;•Xÿÿÿ‚cf;U¨s
·Â-f
éKf;•pÿÿÿ‚Cf;U s
·Â-æ
é+f;•Dÿÿÿ‚#f;UÔs
·Â-féf;•hÿÿÿ‚f;Us
·Â-féëf;•Pÿÿÿ‚ãf;Uˆs
·Â-æéËf;UЂÆf;UÌs
·Â-f
é®f;UÄ‚©f;U¼s
·Â-Pé‘f;U´‚Œf;U¬s
·Â-Ðëwf;U¤rvf;Uœs
·Â- ëaf;U”r`f;UŒs
·Â-@ëKf;U„rJf;•|ÿÿÿs
·Â-àë2f;•tÿÿÿr.f;•lÿÿÿs%·Â-ëf;•dÿÿÿs
·Â-ÿëƒÈÿƒøÿu:f9•\ÿÿÿw	f;•Tÿÿÿv
f‹Âf+Eôf;Eðwf‹Âf+Eôf;Eð·Âwƒè ƒÀÉëƒÈÿ;Áw.‹Mè³;ÎtˆA‰MèÿEà‹ÏèJw‹@ÿÿÿf‹Ðj0f‰UøXé€ýÿÿ‹E‹‹€ˆ‹¾·Â;Á…É‹Ïèw‹Uèf‹È‹E‹uäƒÀj0;Ðf‰MøXu*f;Èu%‹uೋÏNèçvf‹Èj0Xf‰Møf;Èté‹Uè‰uà‹u䋽@ÿÿÿf;È‚f;M˜s·Áƒè0éõf;HÿÿÿƒÒf;`ÿÿÿ‚àf;MÈs
·Á-`éÈf;M€‚Ãf;MÀs
·Á-ðé«f;Lÿÿÿ‚£f;M¸s
·Á-f	é‹f;xÿÿÿ‚ƒf;M°s
·Á-æ	ékf;Xÿÿÿ‚cf;M¨s
·Á-f
éKf;pÿÿÿ‚Cf;M s
·Á-æ
é+f;Dÿÿÿ‚#f;MÔs
·Á-féf;hÿÿÿ‚f;Ms
·Á-féëf;Pÿÿÿ‚ãf;Mˆs
·Á-æéËf;MЂÆf;MÌs
·Á-f
é®f;MÄ‚©f;M¼s
·Á-Pé‘f;M´‚Œf;M¬s
·Á-Ðëwf;M¤rvf;Mœs
·Á- ëaf;M”r`f;MŒs
·Á-@ëKf;M„rJf;|ÿÿÿs
·Á-àë2f;tÿÿÿr.f;lÿÿÿs%·Á-ëf;dÿÿÿs
·Á-ÿëƒÈÿƒøÿu:f9\ÿÿÿw	f;Tÿÿÿv
f‹Áf+Eôf;Eðwf‹Áf+Eôf;Eð·Áwƒè ƒÀÉëƒÈÿ;Çw&³;ÖtˆB‰Uè‹Mèct‹Uèf‹Èj0f‰MøXéˆýÿÿ„Ûu&4ÿÿÿè$?„À„­3À„ÿ”ÀHƒàûƒÀéáÿuø‹u‹Îè’ž‹F‹Î‰EØ‹F‰EÜètf‰Eø3Û·ÀŠËƒøEtƒøPt
ƒøet
ƒøpuŠMÿë8]ÿ”Á¿P„É„ñ‹ÎèÉsf‹Èj-Xf;Èf‰Møj+Z”Çf;Êtf;Èu‹Îè¥sf‹Èf‰Møj03ÒXŠÚf;Èu³‹Îè‰sf‹Èj0Xf‰Møf;Ètê3Òf;È‚f;M˜s·Áƒè0éõf;HÿÿÿƒÒf;`ÿÿÿ‚àf;MÈs
·Á-`éÈf;M€‚Ãf;MÀs
·Á-ðé«f;Lÿÿÿ‚£f;M¸s
·Á-f	é‹f;xÿÿÿ‚ƒf;M°s
·Á-æ	ékf;Xÿÿÿ‚cf;M¨s
·Á-f
éKf;pÿÿÿ‚Cf;M s
·Á-æ
é+f;Dÿÿÿ‚#f;MÔs
·Á-féf;hÿÿÿ‚f;Ms
·Á-féëf;Pÿÿÿ‚ãf;Mˆs
·Á-æéËf;MЂÆf;MÌs
·Á-f
é®f;MÄ‚©f;M¼s
·Á-Pé‘f;M´‚Œf;M¬s
·Á-Ðëwf;M¤rvf;Mœs
·Á- ëaf;M”r`f;MŒs
·Á-@ëKf;M„rJf;|ÿÿÿs
·Á-àë2f;tÿÿÿr.f;lÿÿÿs%·Á-ëf;dÿÿÿs
·Á-ÿëƒÈÿƒøÿu:f9\ÿÿÿw	f;Tÿÿÿv
f‹Áf+Eôf;Eðwf‹Áf+Eôf;Eð·Áwƒè ƒÀÉëƒÈÿƒø
s.kÒ
³ЉUì;׋Îèq‹Uìf‹Èj0f‰MøXé†ýÿÿÇEìQj0Zf;Ê‚Žf;M˜s
·Á+Âéy‹•Hÿÿÿf;ʃZ‹•`ÿÿÿf;Ê‚`f;MÈrÒ‹U€f;Ê‚Nf;MÀrÀ‹•Lÿÿÿf;Ê‚9f;M¸r«‹•xÿÿÿf;Ê‚$f;M°r–‹•Xÿÿÿf;Ê‚f;M¨r‹•pÿÿÿf;Ê‚úf;M ‚hÿÿÿ‹•Dÿÿÿf;Ê‚áf;MÔ‚Oÿÿÿ‹•hÿÿÿf;Ê‚Èf;M‚6ÿÿÿ‹•Pÿÿÿf;Ê‚¯f;Mˆ‚ÿÿÿ‹UÐf;Ê‚™f;MÌ‚ÿÿÿ‹UÄf;Ê‚ƒf;M¼‚ñþÿÿ‹U´f;Êrqf;M¬‚ßþÿÿ‹U¤f;Êr_f;Mœ‚Íþÿÿ‹U”f;ÊrMf;MŒ‚»þÿÿ‹U„f;Êr;f;|ÿÿÿ‚¦þÿÿ‹•tÿÿÿf;Êr#f;lÿÿÿséþÿÿf;dÿÿÿ‚€þÿÿƒÈÿƒøÿu$f9\ÿÿÿw	f;Tÿÿÿv*‹Uôf‹Áf+Âf;EðvƒÈÿƒø
s-‹Îè-of‹Èf‰Møé*þÿÿ‹Uôf‹Áf+Âf;Eð·Áwƒè ƒÀÉë΄ÿt÷]ì„Ûu4ÿÿÿèÓ9„Àt`‹Îèænf‰Eø‹]ìÿuø‹ÎèM™‹u‹MèV;ÊtX€yÿuI;Êuõ;ÊtI;ß$¿°ëÿÿ;ß|'3À8Eÿ”ÀHƒà@¯EàØûP~j	ëjë;ß}jë3À‰+Ê8Eÿ‰N•Àë*jXë%ÿuÜEøÿuØWPèŒëÿuÜEøÿuØWPè[ƒÄ^_[‹å]ËÿU‹ìƒìS‹]EV3ö‰EøW‹}‹Æ‰}ð‰]ô‰uüŠ:ˆXþEt:ˆ\þEug‹ÏèVmŠÈ‹Eü@ˆ‰Eüƒøu×Q‹Ïè›—‹G‹Ï‰E‹G‰Eè+mˆŠ:†`þEt:†hþEu-‹ÏèmFˆƒþußP‹Ïè]—jX_^[‹å]ÃMðè¨8jëìMðèœ83É„À”ÁëÕ‹ÿU‹ìƒìS‹]EV3ö‰EøW‹}‹Æ‰}ð‰]ô‰uüŠ:ˆ°þEt:ˆ´þEug‹ÏèmŠÈ‹Eü@ˆ‰Eüƒøu×Q‹Ïè`—‹G‹Ï‰E‹G‰EèÜlˆŠ:†¸þEt:†ÀþEu-‹ÏèÁlFˆƒþußP‹Ïè"—jX_^[‹å]ÃMðèò5jëìMðèæ53É„À”ÁëÕ‹ÿU‹ìƒìS‹]EV3ö‰EøW‹}‹Æ‰}ð‰]ô‰uü·f;ˆxþEt	f;ˆ€þEur‹Ïè
lf‹È‹EüƒÀf‰‰EüƒøuÐQ‹ÏèS–‹G‹Ï‰E‹G‰EèÛkf‰·f;†ˆþEt	f;†”þEu0‹Ïè¼kƒÆf‰ƒþ
uÙP‹Ïè–jX_^[‹å]ÃMðèT7jëìMðèH73É„À”ÁëÕ‹ÿU‹ìƒìS‹]EV3ö‰EøW‹}‹Æ‰}ð‰]ô‰uü·f;ˆÐþEt	f;ˆØþEur‹Ïè®kf‹È‹EüƒÀf‰‰EüƒøuÐQ‹Ïè
–‹G‹Ï‰E‹G‰Eèkf‰·f;†àþEt	f;†ìþEu0‹Ïè`kƒÆf‰ƒþ
uÙP‹ÏèÅ•jX_^[‹å]ÃMðè~4jëìMðèr43É„À”ÁëÕ‹ÿU‹ìƒìSV‹uEW‹}3Û‰}ô‰uø‰EüŠ:ƒpþEt:ƒtþEuJ‹Ïè;jCˆƒûußP‹Ï舔‹G‹Ï‰E‹G‰Eèjˆ<(t)Môè%4¶À÷ØÀƒàýƒÀéMôè4j逋ÏèâiWVˆèÖYY„ÀtjëWVèÑYY„Àtj¶‹Ï[R蔋ÃëH€>)t@Š„Àt1¾ÈAЃø	vAŸƒøvA¿ƒøv	ƒù_…oÿÿÿ‹Ïèziˆ<)uÉ€>)…YÿÿÿjX_^[‹å]ËÿU‹ìƒìSV‹uEW‹}3Û‰}ô‰uø‰EüŠ:ƒÈþEt:ƒÌþEuJ‹Ïè›iCˆƒûußP‹Ïèü“‹G‹Ï‰E‹G‰Eèxiˆ<(t)Môè=3¶À÷ØÀƒàýƒÀéMôè#3j逋ÏèBiWVˆèþYY„ÀtjëWVèùYY„Àtj¶‹Ï[Rè…“‹ÃëH€>)t@Š„Àt1¾ÈAЃø	vAŸƒøvA¿ƒøv	ƒù_…oÿÿÿ‹ÏèÚhˆ<)uÉ€>)…YÿÿÿjX_^[‹å]ËÿU‹ìƒìSV‹uEW‹}3Û‰}ð‰uô‰EøÇEü·f;ƒ þEt	f;ƒ¨þEuP‹ÏèFhƒÃf‰ƒûuÙP‹Ï蘒‹G‹Ï‰E‹G‰Eè hf‰fƒø(t)Mðèƒ4¶À÷ØÀƒàýƒÀéšMðèi4j銋ÏèçgWVf‰èYY„Àt	ÇEüë
WVèYY„Àt·‹ÏRè’‹EüëNj)[f9tC·f…Àt2‹ÈAЃø	vAŸƒøvA¿ƒøv	ƒù_…gÿÿÿ‹Ïèwgf‰f;ÃuÆf9…OÿÿÿjX_^[‹å]ËÿU‹ìƒìSV‹uEW‹}3Û‰}ð‰uô‰EøÇEü·f;ƒøþEt	f;ƒÿEuP‹ÏègƒÃf‰ƒûuÙP‹Ïèò‘‹G‹Ï‰E‹G‰Eèggf‰fƒø(t)MðèE1¶À÷ØÀƒàýƒÀéšMðè+1j銋Ïè.gWVf‰è)YY„Àt	ÇEüë
WVèYY„Àt·‹ÏRèu‘‹EüëNj)[f9tC·f…Àt2‹ÈAЃø	vAŸƒøvA¿ƒøv	ƒù_…gÿÿÿ‹Ïè¾ff‰f;ÃuÆf9…OÿÿÿjX_^[‹å]ËÿU‹ìSV3ÛW‹}‹óŠ:†ÿEt:†ÿEu‹MèÎeFˆƒþuÞ³_^ŠÃ[]ËÿU‹ìSV3ÛW‹}‹óŠ:†XÿEt:†\ÿEu‹MèfFˆƒþuÞ³_^ŠÃ[]ËÿU‹ìSV3ÛW‹}‹ó·f;†8ÿEt	f;†@ÿEu‹MèeƒÆf‰ƒþuس_^ŠÃ[]ËÿU‹ìSV3ÛW‹}‹ó·f;†xÿEt	f;†€ÿEu‹MèÃeƒÆf‰ƒþuس_^ŠÃ[]ËÿU‹ìSV3ÛW‹}‹óŠ:†ÿEt:†ÿEu‹MèÚdFˆƒþuÞ³_^ŠÃ[]ËÿU‹ìSV3ÛW‹}‹óŠ:†HÿEt:†PÿEu‹MèeFˆƒþuÞ³_^ŠÃ[]ËÿU‹ìSV3ÛW‹}‹ó·f;† ÿEt	f;†,ÿEu‹MèœdƒÆf‰ƒþ
uس_^ŠÃ[]ËÿU‹ìSV3ÛW‹}‹ó·f;†`ÿEt	f;†lÿEu‹MèÏdƒÆf‰ƒþ
uس_^ŠÃ[]ËÿU‹ì‹Eƒø	‡™ÿ$…D˜Bÿuÿuè ÌÿÿYY]ÃÿuÿuèWÌÿÿëï‹E3É8ˆ•ÁÁá‹E‰3À]ËE3É8ˆ•ÁÁáÉ€ëÞ‹E3É8ˆ•ÁÁáÉÿÿÿëÅ‹E3É8ˆ•ÁÁáÉ€묋EÇÀÿ릋Eƒ 3À@]ËE3Éj8ˆ•ÁÁá‹E‰X]ËE3Éj8ˆ•ÁÁáÉ€ëÝIt—Bƒ—B—Bª—B×BÜ—Bõ—B˜B˜B&˜B‹ÿU‹ì‹Eƒø	‡‘ÿ$…H™Bÿuÿuè3ËÿÿYY]ÃÿuÿuèjËÿÿëï‹Eÿu¶€PèÈÿÿYY3À]ËEÿu¶€PèÒÆÿÿëå‹Eÿu¶€PèÇÿÿëЋEÿu¶€Pè`Çÿÿë»ÿuèRÆÿÿë²ÿujè4ÈÿÿYY3À@]ËEÿu¶€PèÈÿÿYYjX]ËEÿu¶€Pè^ÆÿÿYYjëä‹ÿ„˜B“˜B ˜B¹˜BΘBã˜Bø˜B™B™B-™B‹ÿU‹ìƒì@MVW莄Àt!‹},…ÿt%ƒÿ|ƒÿ$~誗ÿÿÇèj"3À‹Ð‹ðéTSÿuMÀè…qþÿ3ÀM‰Eø‹ð‹E‰EЋE ‰EÔè’aŠØEÄPj¶ËQëMè|aŠØEÄPj¶ÃPˆ]üèû°ÿÿƒÄ…ÀuÝ8E0•À‰Eô€û-uƒÈ‰Eôë€û+u
Mè>aŠØˆ]üƒÉÿ‰Mð…ÿtƒÿu{ŠÃ,0<	w¾ÃƒÀÐë"ŠÃ,a<w¾ÃƒÀ©ëŠÃ,A<w¾ÃƒÀÉë‹Á…Àt	…ÿuAj
_ëYŠØEÄPj¶ÃPˆ]üèK¨ÿÿƒÄ…ÀuÝ8E0•À‰Eô€û-uƒÈ‰Eôë€û+u
MèYŠØˆ]üƒÉÿ‰Mð…ÿtƒÿu{ŠÃ,0<	w¾ÃƒÀÐë"ŠÃ,a<w¾ÃƒÀ©ëŠÃ,A<w¾ÃƒÀÉë‹Á…Àt	…ÿuAj
_ë‰ÁàP…`üÿÿPhÌVèacƒÄ…ÿu3ÀP‰…\üÿÿ‰…`üÿÿPhÌVéòƒÿ„ñ‹‰…Xüÿÿ…À„á3É3Û‹Ç÷$žÁ‰žƒÒC‹Ê;Xüÿÿuè‹Püÿÿ…É„·‹ƒøss	‰Lƒé7ÿÿÿ3ÀP‰…\üÿÿ‰…`üÿÿPhÌVé=;µ`üÿÿ’Á„Éus½`üÿÿ‰½0üÿÿ„Ét‹Ð‰…Xüÿÿë{ë牕Xüÿÿ„Éu‰…<üÿÿ3É3ÿ‰,þÿÿ…Ò„…0þÿÿ+ð‰µ@üÿÿ¾‹„0þÿÿ‰…,üÿÿ…Àu;ù…ä!„½0þÿÿO‰,þÿÿéÏ3À3Ò‹÷‰•Lüÿÿ‰…4üÿÿ9…<üÿÿ„œƒþst_;ñuƒ¤µ0þÿÿ@lj…,þÿÿ‹…4üÿÿ‹0üÿÿ‹÷¥,üÿÿ…LüÿÿƒÒ„µ0þÿÿ‹…4üÿÿ‹,þÿÿƒÒ@‰•LüÿÿF‰…4üÿÿ;…<üÿÿuœ…Òt4ƒþs„;ñuƒ¤µ0þÿÿF‰…,þÿÿ‹Â3Ò„µ0þÿÿ‹,þÿÿÒFëȃþs„Í‹µ@üÿÿ‹•XüÿÿG;ú…÷þÿÿ‹Á‰ÁàP…0þÿÿPhÌCPèFaƒÄ°„À„¸‹…Tüÿÿ+…Hüÿÿ‰…Tüÿÿ…ƒüÿÿ‹8üÿÿ…É„Ë4\üE…ö„‘ƒþ„«‹‰…@üÿÿ…À„›C3ɉ…8üÿÿ3ÿ‹Ø‹Æ÷$»Á‰»ƒÒG‹Ê;½@üÿÿuè‹Püÿÿ…Étj‹ƒøss@‰Lƒÿë[3ÀP‰…\úÿÿ‰…`úÿÿPhÌCPè‹`ƒÄ2Àé@ÿÿÿƒ¥\úÿÿƒ#jë3ÀP‰‰…\úÿÿ…`úÿÿPChÌPèS`ƒÄ‹•Düÿÿ…ÒtP3ÿ9;ts3ÀvÀG‹Ð;;uð…Òt3‹ƒøss‰Tƒÿë$ƒ¥\úÿÿ…`úÿÿƒ#jPChÌPèù_ƒÄ‹Mü_^3Í[èG«ýÿ‹å]ÃÌ‹ÿU‹ììÐW‹}…ÿt2‹US3Û9tVr3Àv~üÀC‹ø;uï^[…ÿt
‹ƒøss
‰|‚ÿ°_‹å]Ãj…4þÿÿÇ…0þÿÿPBÇhÌPèq_ƒÄ2À_‹å]ÃÌÌÌ‹ÿU‹ì‹U3À‹
MÀM‰
ƒÐ]ÃÌÌÌÌÌ‹ÿU‹ì‹E÷e‹MƒÒE‰ƒÒ‹Â]ÃÌ‹ÿSV‹ñ3Û9^t2Àé	‹F‰^f‰^ˆ^‰^‰^‰^ ˆ^$‰^(8u	ÇFëжPè?ŽÿÿY…Àt$ÇFëÿF‹F¶Pè"ŽÿÿY…Àuì°鮋N€9%…€A€8%txÇF‰F€8*u@ÆF‰F‹ÎèPJ„À„dÿÿÿ‹ÎèM‹Îè°O‹ÎèWG„À„GÿÿÿkN(‹F 8œàýEu’‰^f‰^ˆ^‰^‰^‰^ ˆ^$‰^(ÇFéÿÿÿÇFŠˆF3À€9%S”ÀAÁ‹Î‰FèðN^[ËÿV‹ñ3É9Nt2À^Ã3À‰N‰F‹FˆN‰N ‰N$‰N(ˆN,‰N0f9u	ÇFëÑ·jPèÅmYY…Àt&ÇFëƒF‹Fj·Pè¤mYY…Àuè錋Nj%Zf9udAf9t\‹ÎÇF‰Fè'I‹ÎèÓI„À„gÿÿÿ‹ÎèM‹Îè²N‹Îè¦G„À„JÿÿÿkN0‹F(€¼àýEu+j‹ÎèXDé+ÿÿÿÇFf‹f‰F3Àf9”À@A‰F°^Àyt‹ÃjhŸhˆüEhðüEhLýEèÈêÌ€yu‹Ãjh¥hˆüEhhýEhÄýEè£êÌ‹ÿU‹ì‹M€ytè£ÿÿÿPÿuèæÿÿYY]Ãè¶ÿÿÿ3É8M•ÁÁáÉ€‰]ËÿU‹ìƒì$SV‹u3ÛW‹};ówƒÿÿw½Ç‰]ÜtHë‹Ëë½Æ‰]ÜHu‹ËƒÁ ‹E3ÒŠ@„ÀˆEÿ”Â3ÀJƒâƒÂ+Ñ‹M+ʉUô8Eÿ‰Mø”ÀH%€ƒÀ‰Eð;È~ÿuÿuèBÿÿÿYYjXé·3À8Eÿ”ÀH%€üÿÿƒÀ‚;È5‹EðHÁ‹MðÂ÷Ù‰Eì‰Mø…À‰÷؉Eðƒø@ƒðHÿ3Ò3À@虋Mð‰EèƒÀÿ‰Eà‹ÂƒÐÿ‰Uä‰EÜ3Ò3À@èl™#ÇÆEý#ÖÂuˆ]ý‹Eè‹Mä#Ç#ÎÁ±uŠËˆMÿ8]t‹Eà‹UÜ#Ç#ÖŠÃt°ˆEþ„Éu„Àt5èh€…Àt=t=uŠ]ë8]”Ãë8]ÿt8]þu8]ýt³‹Mð‹Ç‹Ö虋ø‹ò¶Ã™ø‹ÇòÆt)‹Mè#;ò‚]w;ø†S‹]+]ì+]ôKéGÿuÿuèYYjé´þÿÿ‹Mìé…Ò‰÷Ú‰Uôƒú@r	‹û‹óéÁ3ÀJÿ@3Òèf˜‹Mô‰E܃Àÿ‰Eä‹ÂƒÐÿ‰Uà‰Eè3Ò3À@èE˜#ÇÆEÿ#ÖÂuˆ]ÿ‹EÜ‹Mà#Ç#ÎÁ±uŠËˆMý8]t‹Eä‹Uè#Ç#ÖŠÃt°ˆEþ„Éu„Àt5èA…Àt=t=uŠ]ë8]”Ãë8]ýt8]þu8]ÿt³‹Mô‹Ç‹ÖèÞ—‹ø‹ò¶Ã™øò‹Mèx5;òr@w;øv:‹M3À‹]ø¬÷ÑîC8A”ÀH%€ƒÀ;Ø~QéŠýÿÿ~‹Mô‹Ö‹Çèj—‹ò‹ø‹]ø‹Mè£!#ø#ò‹E‹È€xtèYüÿÿPVWSÿuèÅ‹ÿÿëèküÿÿPVWSÿuè‚‹ÿÿƒÄ_^[‹å]ËÿU‹ìƒì3ÒS‹]VW‹}8S”ÂJƒâƒÂƒÿ@w9‹Mƒ9v‹që3öƒ9v‹Ië3É€}S”À¶ÀPÿu3ÀÆRƒÑQPé!‹ÇÁïƒà‰Eäwþ…ÀuQ‹ÎÁáÊ‹U‹º‹}D·‰EìƒÒ€}‰Uô”ˆUð…ötƒÇƒ?”À"Ѓîuð‹EìˆUðSÿuðÿuQÿuôë—3Û‰uüÁeü‹ÈEüCUü‰]øÓeøÿMøj@Y+È‹E‰MèƒÁà‹T°‹¸‰Uì3Òè#–‹Mè‰Eô‹E‰Uð3Ò‹D¸‹}ø#Çè–Eô‹Ç‹Mä÷ÐUð3Ò#Eìè–‹MôÈ‹Eð‰Mô€}‰Eðu…}ìt2Ûˆ]ø…öt‹MƒÁƒ9I”À"؈]øƒîuí‹Mô‹EðÿuÿuøÿuÿuüPQè0ûÿÿƒÄ_^[‹å]ËÿU‹ì‹M€ytèúÿÿPÿuètŠÿÿYY]Ãè¢úÿÿ3É8M•ÁÁá‰]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìQ‹E‹…Éu3À‹å]ˈ½ÀÇEütPAÿÁà‹å]ÃAÿ3ÒÁà‹å]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìQ½EÇEüt@‹å]Ã3À‹å]ÃÌÌ‹ÿU‹ìQ‹E…Àu‹Mƒùÿw‰Eü½Át@‹å]Ã3À‹å]ýÀÇEüt@ƒÀ ‹å]Ã3À¸ ‹å]ËAËAËA+ËA+ÑøËÿU‹ìì,¡ÀF3ʼnEü‹M3ÀSVW8A‹}”À‰½°öÿÿH‰¨öÿÿƒà‹ƒÀ‰…¬öÿÿ…Ûy3Û‹G‹Ë;Ør‹ÈƒÀWÇщ…Äöÿÿ+Ù+‰ÌöÿÿƒÇ‰…àöÿÿ3À‰•Ôöÿÿ3ö‰…èöÿÿ3ɉ…,þÿÿ‰µäöÿÿ‰½Üöÿÿ;úu
‹Øék‹…èöÿÿƒù	…7…À„“‹èöÿÿ3É3ö¿Êš;‹„µ0þÿÿ÷çÁ‰„µ0þÿÿƒÒF‹Ê;óu䋽Üöÿÿ‹…,þÿÿ…ÉtLƒøss‰Œ…0þÿÿ‹…,þÿÿ@‰…,þÿÿë1ƒ¥¼øÿÿ…Àøÿÿƒ¥,þÿÿjP…0þÿÿhÌPè^U‹…,þÿÿƒÄ‹µäöÿÿ‰…èöÿÿ…ö„‚3Ò…Àt3À´•0þÿÿÀB‹ð‹…,þÿÿ‰…èöÿÿ;Ðuâ…ötZƒøss‰´…0þÿÿ‹,þÿÿC‰èöÿÿ‰,þÿÿë?ƒ¥¼øÿÿ…Àøÿÿƒ¥,þÿÿjP…0þÿÿhÌPèÐT‹,þÿÿƒÄ‰èöÿÿë‹èöÿÿ‹•Ôöÿÿ3ö3Éë‹èöÿÿ¶kö
ðAG‰µäöÿÿ‰½Üöÿÿ;ú…–þÿÿ…É„ó‹Á3Òj
Y÷ñ‰…Èöÿÿ‹Ê‰¸öÿÿ…À„ƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…ÐöÿÿÁçW1‰…¼øÿÿ…ÀøÿÿjPècµýÿ‹ÆÁàP‹…Ðöÿÿ·…ÄûE…ÀòEP…ÀøÿÿÇPèi”‹…¼øÿÿ3ÉAƒÄ;Á‡³‹µÀøÿÿ…öu3À‰…ìöÿÿ‰…,þÿÿP…ðöÿÿé;ñuŠÁéµ…Ûtõ3É3ÿ‹Æ÷¤½0þÿÿÁ‰„½0þÿÿƒÒG‹Ê;ûuä…ÉtO‹…,þÿÿƒøss‰Œ…0þÿÿ‹,þÿÿC‰,þÿÿë43Û…Àøÿÿ‰¼øÿÿSP…0þÿÿ‰,þÿÿhÌPèJSŠÃé/‹,þÿÿ°é+;Ù‡Ž‹½0þÿÿ»Ì‰…,þÿÿÁàP…ÀøÿÿP…0þÿÿSPèSƒÄ3À…ÿuP‰…¼øÿÿ‰…,þÿÿ…ÀøÿÿPSéÀ‹,þÿÿ@‰èöÿÿ;ø„È…Û„À3É3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;óuäé
ÿÿÿ;õÀøÿÿ’Á„Éu µ0þÿÿ•Àøÿÿ‰•Üöÿÿ„Ét‹Ð‰•èöÿÿë•0þÿÿëä‹Ó‰èöÿÿ„Éu‹Ø3É3ÿ‰\üÿÿ…Ò„…`üÿÿ+ð‰µ´öÿÿ¾‹„`üÿÿ‰…¤öÿÿ…Àu;ù…Ü!„½`üÿÿO‰\üÿÿéÇ3Ò3À‰•Øöÿÿ‹÷‰…¼öÿÿ…Û„˜ƒþst[;ñuƒ¤µ`üÿÿ@lj…\üÿÿ‹…¼öÿÿ‹Üöÿÿ‹÷¥¤öÿÿ…ØöÿÿƒÒ„µ`üÿÿ‹…¼öÿÿ‹\üÿÿƒÒ@‰•ØöÿÿF‰…¼öÿÿ;Ãu …Òt4ƒþs„ì;ñuƒ¤µ`üÿÿF‰…\üÿÿ‹Â3Ò„µ`üÿÿ‹\üÿÿÒFëȃþs„¸‹•èöÿÿ‹µ´öÿÿG;ú…ÿþÿÿ‹Á‰,þÿÿÁàP…`üÿÿPhÌ…0þÿÿPèQ°‹,þÿÿƒÄ‰èöÿÿ„Àt1‹…Èöÿÿ+…Ðöÿÿ‰…Èöÿÿ…‡üÿÿ‹¸öÿÿ…É„·‹<\üE…ÿuLƒ¥¼øÿÿ…Àøÿÿƒ¥,þÿÿjP…0þÿÿhÌPè¨P‹…,þÿÿƒÄ‰…èöÿÿëy3Û…ðöÿÿ‰ìöÿÿé!ýÿÿ‹…èöÿÿƒÿt[…ÀtW3É‹Ø3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;óuä‹…,þÿÿ…Étªƒøsƒpÿÿÿ‰Œ…0þÿÿ‹…,þÿÿ@‰…èöÿÿ‰…,þÿÿë‹…èöÿÿ‹•äöÿÿ…Ò„‚3É…Àt‹Â3Ò„0þÿÿ‹…,þÿÿÒ‰…èöÿÿA;Èuâ…ÒtZƒøss‰”…0þÿÿ‹,þÿÿC‰èöÿÿ‰,þÿÿë?ƒ¥¼øÿÿ…Àøÿÿƒ¥,þÿÿjP…0þÿÿhÌPèŸO‹,þÿÿƒÄ‰èöÿÿë‹èöÿÿ‹…Ìöÿÿ…À„j
3ÒY÷ñ‰…Øöÿÿ‹Ê‰¸öÿÿ…À„­ƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…¼öÿÿÁçW1‰…¼øÿÿ…ÀøÿÿjPè^°ýÿ‹ÆÁàP‹…¼öÿÿ·…ÄûE…ÀòEP…ÀøÿÿÇPèd‹…¼øÿÿ3ÉAƒÄ;Á‡”‹½Àøÿÿ…ÿuC3ÀP‰…ìöÿÿ‰…,þÿÿ…ðöÿÿPhÌ…0þÿÿPè³NƒÄ‹,þÿÿ°‰èöÿÿ‹èöÿÿéÁ;ùuŠÁëí…Ûtø3É3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;óuä駉Œ…0þÿÿ‹,þÿÿC‰,þÿÿë¦;ه׋½0þÿÿ»Ì‰…,þÿÿÁàP…ÀøÿÿP…0þÿÿSPèNƒÄ3À…ÿuP‰…¼øÿÿ‰…,þÿÿ…ÀøÿÿPSé=ÿÿÿ‹,þÿÿ@‰èöÿÿ;ø„Eÿÿÿ…Û„=ÿÿÿ3É3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;óuä…É„ÿÿÿ‹…,þÿÿƒøs‚Bÿÿÿ3Û…ÀøÿÿSP…0þÿÿ‰¼øÿÿhÌP‰,þÿÿèMŠÃƒÄ‹,þÿÿéÉþÿÿ;ÕÀøÿÿ’Á„Éu•0þÿÿ‰•äöÿÿ•0þÿÿ„Éu•Àøÿÿ‰•Èöÿÿ„Ét
‹ø‰½Üöÿÿë‹û‰Üöÿÿ„Éu‹Ø3Ò3ö‰•\üÿÿ…ÿ„‹…äöÿÿ`üÿÿ+Á‰…äöÿÿ°‹„`üÿÿ‰…Ìöÿÿ…Àu;ò…È!„µ`üÿÿV‰•\üÿÿé³3À3ÿ‰…Ðöÿÿ‹Î…Û„ƒùstS;Êuƒ¤`üÿÿ@Ɖ…\üÿÿ‹…Ðöÿÿ‹•Èöÿÿ‹‚÷¥ÌöÿÿǃÒ„`üÿÿ‹…ÐöÿÿƒÒ@A‰…Ðöÿÿ‹ú‹•\üÿÿ;Ãu¨…ÿt4ƒùs„ü;Êuƒ¤`üÿÿA‰…\üÿÿ‹Ç3ÿ„`üÿÿ‹•\üÿÿÿAëȃùs„È‹½Üöÿÿ‹…äöÿÿF;÷…
ÿÿÿ‹Â‰•,þÿÿÁàP…`üÿÿP…0þÿÿhÌPèçKƒÄ°‹,þÿÿ‰èöÿÿ„À„§‹…Øöÿÿ+…¼öÿÿ‰…Øöÿÿ…Yüÿÿ‹¸öÿÿ…ÉtE‹<\üE…ÿ…ˆ3ÀP‰…¼øÿÿ‰…,þÿÿ…ÀøÿÿP…0þÿÿhÌPèvKƒÄ‹,þÿÿ‰èöÿÿ…Û…ì3Éé3ÀP‰…ìöÿÿ‰…,þÿÿ…ðöÿÿP…0þÿÿhÌPè1KƒÄ2ÀéEÿÿÿƒ¥¼øÿÿƒ¥,þÿÿjëdƒÿt©…Ût­3É3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;óuä…É„qÿÿÿ‹…,þÿÿƒøss‰Œ…0þÿÿ‹,þÿÿC‰,þÿÿéSÿÿÿ3À‰…¼øÿÿ‰…,þÿÿP…ÀøÿÿP…0þÿÿhÌPè™J‹…°öÿÿƒÄÿµ¨öÿÿ¶€PèÅíÿÿYYjX鎋„,þÿÿƒ¥Ìöÿÿ½Àt@ë3ÀKÿÁáÈ‹…àöÿÿ‰¼öÿÿ;¬öÿÿƒ)…À„!‹½Ôöÿÿ3Û3ö‰äöÿÿ3ɉŒúÿÿ‰µÜöÿÿ;½Äöÿÿ„=ƒù	……Û„†3ɾʚ;3ÿ‹„½úÿÿ÷æÁ‰„½úÿÿƒÒG‹Ê;ûu䋵Üöÿÿ…ÉtK‹…Œúÿÿƒøss‰Œ…úÿÿ‹ŒúÿÿC‰Œúÿÿë03ÀP‰…¼øÿÿ‰…Œúÿÿ…ÀøÿÿP…úÿÿhÌPèIƒÄ‹Œúÿÿ‹½Ôöÿÿ…ötn3É…Ût‹Æ3ö„úÿÿ‹ŒúÿÿöA;Ëuè…ötLƒûss‰´úÿÿ‹ŒúÿÿC‰Œúÿÿë1ƒ¥¼øÿÿ…Àøÿÿƒ¥ŒúÿÿjP…úÿÿhÌPè	I‹ŒúÿÿƒÄ3ö3ɶkö
ðAG‰µÜöÿÿ‰½Ôöÿÿ;½Äöÿÿ…Ñþÿÿ‰äöÿÿ…É„ú‹Á3Òj
Y÷ñ‰…Èöÿÿ‹Ê‰´öÿÿ…À„mƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…ØöÿÿÁçW1‰…¼øÿÿ…ÀøÿÿjP让ýÿ‹ÆÁàP‹…Øöÿÿ·…ÄûE…ÀòEP…ÀøÿÿÇPè´ˆ‹…¼øÿÿ3ÉAƒÄ;Á‡³‹½Àøÿÿ…ÿu3À‰…ìöÿÿ‰…ŒúÿÿP…ðöÿÿé‡;ùuŠÁ韅Ûtõ3É3ö‹Ç÷¤µúÿÿÁ‰„µúÿÿƒÒF‹Ê;óuä…ÉtO‹…Œúÿÿƒøss‰Œ…úÿÿ‹ŒúÿÿC‰Œúÿÿë43Û…ÀøÿÿSP…úÿÿ‰¼øÿÿhÌP‰Œúÿÿè•GŠÃé‹Œúÿÿ°é;Ù‡Ž‹½úÿÿ»Ì‰…ŒúÿÿÁàP…ÀøÿÿP…úÿÿSPèPGƒÄ3À…ÿuP‰…¼øÿÿ‰…Œúÿÿ…ÀøÿÿPS骋Œúÿÿ@‰äöÿÿ;ø„²…Û„ª3É3ö‹Ç÷¤µúÿÿÁ‰„µúÿÿƒÒF‹Ê;óuäé
ÿÿÿ;ýÀøÿÿ’Á„Éuy½úÿÿ•Àøÿÿ‰•Äöÿÿ‰…Ôöÿÿ„Éu‰Ôöÿÿ‹Ø3Ò3ö‰•\üÿÿ9•Ôöÿÿ„…`üÿÿ+ø‰½¸öÿÿ·‹„`üÿÿ‰…Ìöÿÿ…Àu%;ò…Ð!„µ`üÿÿV‰•\üÿÿ黕úÿÿë‹3À3ÿ‰…Ðöÿÿ‹Î…Û„ƒùstS;Êuƒ¤`üÿÿ@Ɖ…\üÿÿ‹…Ðöÿÿ‹•Äöÿÿ‹‚÷¥ÌöÿÿǃÒ„`üÿÿ‹…ÐöÿÿƒÒ@A‰…Ðöÿÿ‹ú‹•\üÿÿ;Ãu¨…ÿt4ƒùs„;Êuƒ¤`üÿÿA‰…\üÿÿ‹Ç3ÿ„`üÿÿ‹•\üÿÿÿAëȃùs„ß‹½¸öÿÿF;µÔöÿÿ…ÿÿÿ‹Â‰•ŒúÿÿÁàP…`üÿÿPhÌ…úÿÿPèwE°ƒÄ‹Œúÿÿ‰äöÿÿ„À„À‹…Èöÿÿ+…Øöÿÿ‰…Èöÿÿ…™üÿÿ‹´öÿÿ…É„â‹<\üE…ÿ„ƒÿ„Ê…Û„Â3É3ö‹Ç÷¤µúÿÿÁ‰„µúÿÿƒÒF‹Ê;óuä…É„Ž‹…ŒúÿÿƒøssY‰Œ…úÿÿ‹ŒúÿÿC‰Œúÿÿës3ÀP‰…ìöÿÿ‰…Œúÿÿ…ðöÿÿP…úÿÿhÌPè¨DƒÄ2Àé,ÿÿÿƒ¥¼øÿÿƒ¥Œúÿÿjë3ÀP‰…Œúÿÿ‰…¼øÿÿ…ÀøÿÿP…úÿÿhÌPèeDƒÄ‹Œúÿÿ‰äöÿÿ‹•Üöÿÿ…Òtz3É…Ût‹Â3Ò„úÿÿ‹ŒúÿÿÒ‰äöÿÿA;Ëuâ…ÒtRƒûss‰”úÿÿ‹ŒúÿÿC‰Œúÿÿë1ƒ¥¼øÿÿ…Àøÿÿƒ¥ŒúÿÿjP…úÿÿhÌPèáC‹ŒúÿÿƒÄ‰äöÿÿ‹…àöÿÿ‹°öÿÿƒ9}+j
3Òƒ¥düÿÿ^÷ö3ÉA‰•´öÿÿ‰`üÿÿ‰àöÿÿ‰\üÿÿ‰…Èöÿÿ…À„Úƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…ÐöÿÿÁçW1‰…¼øÿÿ…ÀøÿÿjP艤ýÿ‹ÆÁàP‹…Ðöÿÿ·…ÄûE…ÀòEP…ÀøÿÿÇP胋…¼øÿÿ3ÒBƒÄ;‡¡ƒ½ÀøÿÿuC3ÀP‰…ìöÿÿ‰…\üÿÿ…ðöÿÿPhÌ…`üÿÿPèßBƒÄ‹\üÿÿ°‰àöÿÿ‹àöÿÿéï9•ÀøÿÿuŠÂëé‹àöÿÿ…Étò3ö3ÿ‹…Àøÿÿ÷¤½`üÿÿƉ„½`üÿÿƒÒG‹ò;ùuà鿉´…`üÿÿ‹\üÿÿA‰\üÿÿ똋àöÿÿ;ʇ鋵`üÿÿ¿Ì‰…\üÿÿÁàP…Àøÿÿ‰µÌöÿÿP…`üÿÿWPè1BƒÄ3À…öuP‰…¼øÿÿ‰…\üÿÿ…ÀøÿÿPWé#ÿÿÿ‹\üÿÿ@‰àöÿÿ;ð„+ÿÿÿ…É„#ÿÿÿ‹Ìöÿÿ3ö3ÿ‹Ã÷¤½`üÿÿƉ„½`üÿÿƒÒG‹ò;ùuä‹äöÿÿ…ö„áþÿÿ‹…\üÿÿƒøs‚*ÿÿÿ3ÀP‰…¼øÿÿ‰…\üÿÿ…ÀøÿÿP…`üÿÿhÌPè‡A‹\üÿÿƒÄ2Àé£þÿÿ;ÁµÀøÿÿ’„Òuyµ`üÿÿ½Àøÿÿ‰½Äöÿÿ‰…Øöÿÿ„Òu‰Øöÿÿ‹È3Ò3ÿ‰•ìöÿÿ9•Øöÿÿ„%…ðöÿÿ+ð‰µ¸öÿÿ¾‹„ðöÿÿ‰…Ìöÿÿ…Àu%;ú…î!„½ðöÿÿW‰•ìöÿÿéÙ½`üÿÿ닃¥Ôöÿÿ3À‰…Üöÿÿ‹÷…É„©ƒþst[;òuƒ¤µðöÿÿ@lj…ìöÿÿ‹…Üöÿÿ‹•Äöÿÿ‹‚÷¥Ìöÿÿ…ÔöÿÿƒÒ„µðöÿÿ‹…ÜöÿÿƒÒ@F‰•Ôöÿÿ‹•ìöÿÿ‰…Üöÿÿ;Áu ƒ½Ôöÿÿt@ƒþs„;òuƒ¤µðöÿÿF‰…ìöÿÿ‹…Ôöÿÿ3Ò„µðöÿÿÒF‰•Ôöÿÿ…Ò‹•ìöÿÿuÀƒþs„À‹µ¸öÿÿG;½Øöÿÿ…éþÿÿ‹Â‰•\üÿÿÁàP…ðöÿÿP…`üÿÿhÌPèå?ƒÄ°‹\üÿÿ‰àöÿÿ„À„¡‹…Èöÿÿ+…Ðöÿÿ‰…Èöÿÿ…,üÿÿ‹•´öÿÿ…Ò„=‹•\üE‰…Ìöÿÿ…Àu|P‰…Ôôÿÿ‰…\üÿÿ…ØôÿÿP…`üÿÿhÌPèp?ƒÄ‹\üÿÿ‰àöÿÿéù3ÀP‰…Ôôÿÿ‰…\üÿÿ…ØôÿÿP…`üÿÿhÌPè5?ƒÄ2ÀéKÿÿÿƒ¥Ôôÿÿƒ¥\üÿÿjësƒø„§…É„Ÿ3ÿ3ö÷¤µ`üÿÿlj„µ`üÿÿ‹…ÌöÿÿƒÒF‹ú;ñuà…ÿ„oÿÿÿ‹…\üÿÿƒøss‰¼…`üÿÿ‹\üÿÿA‰àöÿÿ‰\üÿÿëR3À‰…Ôôÿÿ‰…\üÿÿP…ØôÿÿP…`üÿÿhÌPèŽ>‹…°öÿÿƒÄÿµ¨öÿÿ¶€PèÎæÿÿYYjéðóÿÿ‹àöÿÿ…Ûu3öë ‹„Œúÿÿƒ¥Ìöÿÿ½Àt@ë3ÀsÿÁæð…Éu3Òë ‹„\üÿÿƒ¥Ìöÿÿ½Àt@ë3ÀQÿÁâЋÂ+Æ;òjÿö#ð‰µÔöÿÿ_†­‹…Ôöÿÿ3ÒƒàÁîj Y+ȉ…Èöÿÿ3À‰µÜöÿÿ@‰¸öÿÿè¹{‹ŒŒúÿÿH½É‰…´öÿÿ÷Љ…ÌöÿÿtAë3Éj X+Á9…Èöÿÿ‰•Ðöÿÿ—Àƒúsˆ…Ãöÿÿ—Áƒúsu„Àt°ë2À„É…ê„À…âƒúrr	jrZ‰•Ðöÿÿ‹Ê‰Øöÿÿ;ׄ‹…Üöÿÿ‹ò+ð•úÿÿ²;Èrl;ós‹ë3À‰…ÄöÿÿFÿ;Ãs‹Büë3À#…Ìöÿÿƒê‹¸öÿÿ‹Äöÿÿ#´öÿÿÓè‹ÈöÿÿÓã‹ØöÿÿÉ„úÿÿIN‰Øöÿÿ;Ït‹Œúÿÿ‹…Üöÿÿë‹•Ðöÿÿ‹µÜöÿÿ…öt3À½úÿÿ‹Îó«ƒÏÿ€½ÃöÿÿZ‹àöÿÿ‹µÔöÿÿu‹Ú‰Œúÿÿë<3ÀP‰…Ôôÿÿ‰…Œúÿÿ…ØôÿÿP…úÿÿhÌPèb<‹ŒúÿÿƒÄ‹àöÿÿ‹µÔöÿÿ‹•¬öÿÿ‹…¼öÿÿ+Љ•¬öÿÿ…Àt+‹Â;ðv!ÿµ¨öÿÿ‹…°öÿÿj¶€Pÿµ¼öÿÿé‹Ð+Ö;Ùw9r0Kÿ;Ït0‹„úÿÿ;„`üÿÿuI;Ïuë;Ït‹„úÿÿ;„`üÿÿwF‰µÔöÿÿ‹ò3ÀƒâÁîj Y+ʉ•Èöÿÿ@‰µÜöÿÿ3Ò‰¸öÿÿèy‹ŒŒúÿÿH½É‰…´öÿÿ÷Љ…ÌöÿÿtAë3Àj Y+È9Èöÿÿ‰•Ðöÿÿ—Àƒúsˆ…Ãöÿÿ—Áƒúsu„Àt°ë2À„É…ä„À…܃úrr	jrZ‰•Ðöÿÿ‹Ê‰Øöÿÿ;ׄ‹…Üöÿÿ‹ò+ð•úÿÿ²;Èrl;ós‹ë3À‰…ÄöÿÿFÿ;Ãs‹Büë3À#…Ìöÿÿƒê‹¸öÿÿ‹Äöÿÿ#´öÿÿÓè‹ÈöÿÿÓã‹ØöÿÿÉ„úÿÿIN‰Øöÿÿ;Ït‹Œúÿÿ‹…Üöÿÿë‹•Ðöÿÿ‹µÜöÿÿ…öt3À½úÿÿ‹Îó«ƒÏÿ€½ÃöÿÿtB‰…Œúÿÿë2‰•Œúÿÿë*3ÀP‰…Ôôÿÿ‰…Œúÿÿ…ØôÿÿP…úÿÿhÌPè=:ƒÄ…\üÿÿP…ŒúÿÿPèsƒ½Œúÿÿ‹ØYY‹Ê‰Äöÿÿ”‰Üöÿÿˆ•Øöÿÿ…Éu;ßw½Ãtpë3öë½Átpë3öƒÆ ‹…¬öÿÿ;ðvI+ð„Òt%3À3Ò@‹Îè°w‹ÜöÿÿÇÆ…Øöÿÿ×#Ã#ÑÂtÆ…Øöÿÿ‹Ñ‹Ã‹Îè¥w‰…Äöÿÿ‰•Üöÿÿ‹¬öÿÿ3À;…èöÿÿö@#µ0þÿÿ;…èöÿÿÒ3À#•4þÿÿƃÒèHw‹È‹…¼öÿÿÄöÿÿ•Üöÿÿ…Àtxþë+½Ôöÿÿÿµ¨öÿÿ‹…°öÿÿÿµØöÿÿ¶€PWRQè™ÜÿÿƒÄë-ÿµ¨öÿÿ…À•À¶ÀP‹…°öÿÿ¶€PQ…,þÿÿPè¶ßÿÿƒÄ‹Mü_^3Í[è6„ýÿ‹å]ËÿU‹ìQQ‹E3É‹USV3ÛW3ÿr8H‹”ÁHIƒáƒÁÁJ‰Eø‹BȉMü;ñt5‹MèI;Úw#r;øw¶‹Mü¤û™ÁçøÚƒmøF;ñuÓë‹Mü‹U°ë
„ÀtŠF„Àtñ2ÀˆEü;ñuìÿu¶‚ÿuüPÿuøSWè´ÛÿÿƒÄ_^[‹å]ÃÌÌÌÌ‹ÿU‹ì½Mt	¸+Á]ø ]ËÁËÿU‹ìQV‹ñƒ>u%jh èc¿YY‰Eü‹ÎEüPèóÍÿÿÿuü諽Y‹^‹å]Àyt	ƒÈÿºÿÿøÿÿ3ÒÃÌ‹ÿU‹ììS‹]‹…Àu3Ò[‹å]ÃW‹}‹…Éu
_3À3Ò[‹å]ÃVpÿAÿ‰uô…À…-‹O‰M؃ùu/‹sKP‰…äýÿÿ‰…èýÿÿPhÌQèF7ƒÄ‹Æ3Ò^_[‹å]Ã…öuI‹s…èýÿÿjP{Ç…äýÿÿhÌWÇè
73Ò‹Æ÷u؃Ä3É;ʉÉ^÷Ù3Ò_‰[‹å]Ã3ÿÇEøÇEü‰}ðƒþÿtD‹EôF@‰Eä4³d$jQ3ÀWPèRq‰UÀvü3Ò‰]ð‹ùЋMøƒÑ‰Uøƒmä‰Mü‹MØu΋]j…èýÿÿÇ…äýÿÿPsÇhÌVèh6‹EðƒÄ‹Uü3É;ȉ>‰C‹EøÉ÷Ù^A_‰[‹å]Ã;ÆwG‹ÖH+ЉMÈ‹Î;ò|2‹ÁF+Â4³<‡ƒÇ‹;u
Iƒïƒî;Ê}ïë‹u‹Á+‹D†;D‹sB…Òu^_3À3Ò[‹å]Ë}È‹E‹4¸‹D¸ü‰Eà½Æ‰uÌt	¹+Èë¹ ¸ ‰MÜ+Á‰EÄ…Ét)‹Eà‹MÄÓè‹MÜÓeàÓæð‰ũÿv‹u‹MÄ‹D¾øÓè	Eà3öÇE¸ƒÂÿ‰Uäˆ,K‘‰Mð:Kü‰Eø‰M´;Eôw‹Aë3Àƒ}Ü‹Q‹	‰EÐÇE؉Eü‰MìvI‹ù‹Â‹MÄ3ö‹UüÓï‹MÜès‹MÜòø‹Æ‹uì‹×Óæƒ}ø‰Eü‰uìr‹EÈEä‹MÄ‹DƒøÓèð‹Eü‰uìjÿuÌPRè‚o‰]Ø3ö‹Ø‰u؋‰]ü‰Eè‹ù‰]¼‰EÀ…Àuƒûÿv*jÿũÃÐÿPSè
pøòƒËÿ3À‰u؉]ü‰]¼‰Eè‰EÀ…öwPrƒÿÿwIPS3É‹÷Mìjÿuà‰MüèÔo;Ör)w;Eüv"‹EèƒÃÿ‰]¼ƒÐÿ}̉EèƒU؉EÀu
ƒÿÿv¿ë‹Eè‰]ü…Àu…Û„´‹MÈ3ÿ3ö…ÉtU‹E‹]ðƒÀ‰Eì‰Mô‹‰EØ‹EÀ÷eØ‹È‹E¼÷eØÑø‹‹Ïò‹þ3ö;ÁsƒÇö+Á‰ƒÃ‹EìƒÀƒmô‰EìuÀ‹]ü‹MÈ3À;ÆwGr9}Ðs@…Ét5‹u‹ù‹UðƒÆ‹Ø¤$‹
v3ÀRNüÀˉJüƒÐ‹Øƒïuâ‹]üƒÃÿƒUèÿ‹EøH‰Eô‹u¸3À‹UäËM´‹ø‹EøƒÖƒmðJ‹]ƒéH‰}¸‰Uä‰M´‰Eø…Ò‰îýÿÿë3ÿ‹UôB‹Â;sH‹ë›ÇI@;rò‰…Òt‹ƒ<‹uƒÁÿ‰uñ‹Ö‹Ç^_[‹å]ËAËAÃ3À8A”ÀH%€ƒÀËÃA‹Q‹ÂƒQV‹qÆt9qrw9Qw‹1ÿ6è¸4YƒøÿtÿF^Ã2À^ÃA‹Q‹ÂƒQV‹qÆt9qrw9Qw‹	è›·À¹ÿÿf;Áu3À^ÃA‹Q‹ÂƒQV‹qÆt9qrw9Qv2À^Ë	è}‹Èƒùÿ^”ÀþÈ"ÁÃA‹Q‹ÂƒQV‹qÆt9qrw9Qw‹	è]·À¹ÿÿf;Áu3À^ËÿV‹ñÿ6èñ3YƒøÿtÿF^ËÿV‹ñÿ6èÿ2Y·À¹ÿÿf;ÁtÿF^ËыJ;JuƒÈÿþA‰JËыJ;Ju¸ÿÿ÷ƒÁ‰JÃQ ‹ÂV3ö+Á;ÑÒ÷Ò#ÐtöAF;òuø^ËÿVèrùÿÿ3ö ‹Ê+È;ÐÒ÷Ò#Ñtö@F;òuø^ËÿU‹ì‹Uƒúÿu2Àë1‹Eƒèt'ƒètƒèuêRƒÁ<è¼'„ÀëB÷ƒøvÕƒú •Àë°]‹ÿU‹ì‹Uƒúÿu2Àë1‹Eƒèt'ƒètƒèuêRƒÁDèv'„ÀëB÷ƒøvÕƒú •Àë°]‹ÿU‹ì‹U¸ÿÿf;Ðu2Àë3‹Eƒèt)ƒètƒèuêRƒÁDè\'„Àë
B÷fƒøvÔfƒú •Àë°]‹ÿU‹ì‹U¸ÿÿf;Ðu2Àë3‹Eƒèt)ƒètƒèuêRƒÁLè'„Àë
B÷fƒøvÔfƒú •Àë°]‹ÿU‹ì‹MAЃø	w°]ÃAŸƒøvôA¿ƒøvìƒù_”À]ÊAËÿU‹ìkU3À‹M8„
àýE•À]Ã3À…É•ÀÃèÕ÷ÿÿ÷ØÀ÷ØÃ3À9•ÀËAËAËA(…Àxƒø~+ƒø~ƒøt
ƒøtƒø	t
3ÀÃÿq è’&ëÿq è«&YÃ3À8A$•À@ËA0…Àxƒø~+ƒø~ƒøt
ƒøtƒø	t
3ÀÃÿq(èQ&ëÿq(èj&YÃ3À8A,•À@ÊAÃf‹AÊAÃÌ‹ÿU‹ì‹E3Ò‹M‰H‹M…ɉH•ÂB‰]Ã3À8A”ÀHƒàƒÀÃ3À8A”ÀH%€ƒÀÃ3À8A”ÀH%€üÿÿƒÀ‚ËA(ËA0ÃÌÌÌÌ‹ÿU‹ììÀ¡ÀF3ʼnEü‹MS‹]V‹‰ þÿÿWƒú‡É‹y…ÿuW…0þÿÿ‰½,þÿÿPhÌC‰;Péƒÿ„‹…À„úS3ö‰•$þÿÿ3É‹Ø‹Ç÷$Šƃҋò‹•$þÿÿ‰ŠA;Ëuæ‹ þÿÿ…ö„˃øss‰tƒ°ÿ_^[‹Mü3Íèxyýÿ‹å]Ãj…0þÿÿÇ…,þÿÿPhÌRÇèò-ƒÄ2À_^[‹Mü3Íè>yýÿ‹å]Ë3‰µþÿÿƒþ‡è‹{s‰‹ÁàPA‰½(þÿÿPhÌVè¨-ƒÄ…ÿuW…0þÿÿ‰½,þÿÿPh̉;Véƒÿ„
‹‰…$þÿÿ…À„ú‹(þÿÿ3ÿ3É‹Ã÷$ŽljŽƒÒA‹ú;$þÿÿuè‹ þÿÿ…ÿ„Ê‹ƒøss‰|ƒ°ÿ_^[‹Mü3Íèxýÿ‹å]Ãj…0þÿÿÇ…,þÿÿPhÌVÇèù,ƒÄ2À_^[‹Mü3ÍèExýÿ‹å]Ã;Ö’À„ÀC‰…þÿÿt
‰…$þÿÿy‹Âë‹ø‰•þÿÿA‰…$þÿÿ‹Æ3Ò‰…(þÿÿ3Û‰•,þÿÿ…À„ü…0þÿÿ+ø‰½þÿÿ¤$Ÿ‹„0þÿÿ‰…þÿÿ…Àu;Ú…¾S‰„0þÿÿ‰•,þÿÿé©3ö3ÿ‹Ë9µþÿÿ„ŒƒùstJ;ÊuCÇ„0þÿÿlj…,þÿÿ‹…$þÿÿ‹¸÷¥þÿÿƃÒ„0þÿÿƒÒGA‹ò‹•,þÿÿ;½þÿÿu±…öt9ƒùs„…;ÊuAÇ„0þÿÿ‰…,þÿÿ‹Æ3ö„0þÿÿ‹•,þÿÿöA…öuǃùstP‹½þÿÿC;(þÿÿ…ÿÿÿ‹… þÿÿ‰•P…0þÿÿPhÌÿµþÿÿèv+ƒÄ_^°[‹Mü3ÍèÂvýÿ‹å]Ë… þÿÿjÇ…@üÿÿÇ…DüÿÿPhÌÿµþÿÿè1+‹MüƒÄ3Í2À_^[è}výÿ‹å]ÃÌÌÌÌÌÌÌ‹ÿU‹ììØW‹}…ÿu+‹E,þÿÿWQh̉8ƒÀP‰½(þÿÿèà*ƒÄ°_‹å]Ãÿtô‹M‹…ÀtëSQ3ÛV‰Uü3ö‹È›‹Ç÷$²ÃҋڋUü‰²F;ñué‹M…Ût
‹ƒøss‰\ÿ^[°_‹å]Ãj…,þÿÿÇ…(þÿÿPhÌRÇè\*ƒÄ2À^[_‹å]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E÷e‹È‹E÷eÑ]ÃÌÌÌÌÌÌÌÌÌ‹ÿU‹ììÈ¡ÀF3ʼnEü¸ÍÌÌÌ÷eS‹ÊÁéV‹Á‰Hüÿÿ‰…DüÿÿW‹}‰½Xüÿÿ…À„'¹&¤$ƒø&‹ØGÙ‰Püÿÿ¶ÆûE¶4ÇûE<1W‰…,þÿÿ…0þÿÿjPèÓŠýÿµP·ÄûE…ÀòEP…0þÿÿÇPèÝi‹,þÿÿƒÄƒù‡Ü‹½0þÿÿ…ÿu1‰½\üÿÿ…`üÿÿ‹½XüÿÿjPhÌGÇPè,)ƒÄéBƒÿu‹½Xüÿÿé2‹…Xüÿÿ‹…Ûu‹øé3öP3É›‹Ç‹½0þÿÿ÷$Šƃҋò‹•XüÿÿƒÂ‰ŠA;ËuÝ‹½Xüÿÿ…ö„ዃøss‰t‡ÿéÏj…0þÿÿÇ…,þÿÿPhÌRÇè(ƒÄ2À飋½Xüÿÿ‹w‰•Lüÿÿƒú‡Ï‹P…0þÿÿ‰PhÌVèK(ƒÄ…Ûu#S…0þÿÿ‰,þÿÿPhÌV‰è)(ƒÄé?ƒû„6‹‰…Tüÿÿ…À„&3ÿ3É‹Ã÷$ŽljŽƒÒA‹ú;Tüÿÿuè…ÿ„Åþÿÿ‹Xüÿÿ‹ƒøss
‰|‹ùÿéèj…0þÿÿÇ…,þÿÿP‹ùhÌVÇè¤'ƒÄ2Àéº;Ê’À„Àt‰µ@üÿÿ‹Áµ0þÿÿë…0þÿÿ‰Lüÿÿ‰…@üÿÿ‹Â3Ò‰…Tüÿÿ3Û‰•\üÿÿ…À„…`üÿÿ+ð‰µ8üÿÿIž‹„`üÿÿ‰…<üÿÿ…Àu;Ú…ËS‰„`üÿÿ‰•\üÿÿé¶3ö3ÿ‹Ë9µLüÿÿ„™ƒùstQ;ÊuCÇ„`üÿÿlj…\üÿÿ‹…@üÿÿ‹¸÷¥<üÿÿƃÒ„`üÿÿ‰„`üÿÿƒÒGA‹ò‹•\üÿÿ;½Lüÿÿuª…öt?Iƒùstr;ÊuAÇ„`üÿÿ‰…\üÿÿ‹Æ3ö„`üÿÿ‰„`üÿÿ‹•\üÿÿöA…öuăùst6‹µ8üÿÿC;Tüÿÿ…ÿÿÿ‹½Xüÿÿ‰Áâ…Òt_G…Àuè')ÿÿÇëF‹½Xüÿÿ2ÀÇë=úÌwR`üÿÿQPèsfƒÄë hÌjPè1‡ýÿƒÄèß(ÿÿÇ"蟳°„Àtn‹…Düÿÿ¹&+…Püÿÿ‰…Düÿÿ…ëûÿÿ‹Hüÿÿ‰‹MÀ+Èt,‹\üE…ÛuqS…0þÿÿ‰,þÿÿPG‰hÌPè„%ƒÄ_^°[‹Mü3ÍèÐpýÿ‹å]Ãj…0þÿÿÇ…,þÿÿPGÇhÌPèG%ƒÄ2À_^[‹Mü3Íè“pýÿ‹å]Ãût«‹‰…Hüÿÿ…ÀtŸW3ö‰•Püÿÿ3É‹ø‹Ã÷$Šƃҋò‹•Püÿÿ‰ŠA;Ïu拽Xüÿÿ…ö„hÿÿÿ‹ƒøss‰t‡°ÿ_^[‹Mü3Íè+pýÿ‹å]Ãj…0þÿÿÇ…,þÿÿPhÌRÇè¥$‹MüƒÄ3Í2À_^[èñoýÿ‹å]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìVW‹}3ö3É…ÿt&‹US‹]¤$‹Ã÷$Šƃҋò‹U‰ŠA;Ïué[_‹Æ^]Àyt	ƒÈÿºÿÿøÿÿÿ3ÒËÿV‹ñW~‹Ïèá„ÀuƒÈÿëpS^‹Ëè„ÀuƒÈÿë[‹Îè„Àt‹ËèÌÄÿÿ„Àuêƒ~l‹^huÿ7èÕ%YƒøÿtÿGëƒËÿP‹ÏèF‹ƒàƒÈt‹v…ötè¢&ÿÿ‰0èf±‹Ã[_^ËÿSV‹ñ^‹Ëè‘„ÀuƒÈÿëiW~‹Ïè…„ÀuƒÈÿëT‹Îè„Àt‹Ïè@Äÿÿ„Àuêƒ~t‹~pu‹Ëè‚ñÿÿƒøÿuøP‹Ë苃àƒÈt‹v$…ötè&ÿÿ‰0èá°‹Ç_^[ËÿSV‹ñ^‹Ëèñ„ÀuƒÈÿërW~‹Ïè„ÀuƒÈÿë]‹Îès„Àt‹ÏèÛÄÿÿ„Àuêƒ~T‹~Pu‹ËèÞðÿÿ·À¹ÿÿf;ÁuƒÏÿP‹ËèQ‹ƒàƒÈt‹v…ötè%ÿÿ‰0èS°‹Ç_^[ËÿSV‹ñ^‹Ëè „ÀuƒÈÿërW~‹Ï莄ÀuƒÈÿë]‹Îè„Àt‹ÏèMÄÿÿ„Àuêƒ~\‹~Xu‹Ëè…ðÿÿ·À¹ÿÿf;ÁuƒÏÿP‹Ë苃àƒÈt‹v$…ötè%ÿÿ‰0èů‹Ç_^[Ày&t°Ãjjÿqè®Ày.t°ËA+AjjPèÀy(t°ÃjjÿqèlÀy0t°ËA+AjÑøjPèÇËA8ƒø	wAÿ$…
CjèÃjëöjëòjjèhÃjj
ëôjjëîjëòjjëäéŒéUÿÿÿ2ÀÃÃCËCÓCÝCãCéCíCóCÏCøC‹A@ƒø	wAÿ$…t
CjèSÃjëöjëòjjèZÃjj
ëôjjëîjëòjjëäéHé÷þÿÿ2ÀÃ7
C?
CG
CQ
CW
C]
Ca
Cg
CC
Cl
C‹A@ƒø	wAÿ$…è
Cjè'ÃjëöjëòjjèLÃjj
ëôjjëîjëòjjëäééþÿÿ2Àë
C³
C»
CÅ
CË
CÑ
CÕ
CÛ
C·
Cà
C‹AHƒø	wAÿ$…\CjèûÃjëöjëòjjè>Ãjj
ëôjjëîjëòjjëäéÀé?þÿÿ2ÀÃC'C/C9C?CECICOC+CTC‹ÿV‹ñèÛNèúïÿÿƒøtƒøt2À^ËÎ^éàžÿÿ‹Î^é8ÿÿ‹ÿV‹ñèÈNèÊïÿÿƒøtƒøt2À^ËÎ^éŸÿÿ‹Î^épÿÿ‹ÿV‹ñèµNèÛïÿÿƒøtƒøt2À^ËÎ^éPŸÿÿ‹Î^é¨ÿÿ‹ÿV‹ñè¥Nè«ïÿÿƒøtƒøt2À^ËÎ^鈟ÿÿ‹Î^éàÿÿ‹ÿU‹ìQQV‹ñèÿuEÿÆEÿÿuƒì ‹ÌPÿv,Fÿv(PQèèTÿÿƒÄÿv`èï‰ÿÿƒÄ,€}ÿu2Àë€~&t°ëjRP‹Îèr^‹å]‹ÿU‹ìQQV‹ñèÍÿuEÿÆEÿÿuƒì ‹ÌPÿv4Fÿv0PQè¾TÿÿƒÄÿvhè9’ÿÿƒÄ,€}ÿu2Àë€~.t°ëjRP‹Îèƒ^‹å]‹ÿU‹ìQQV‹ñè„ÿuEÿÆEÿÿuƒì ‹ÌPÿv4Fÿv0PQè:TÿÿƒÄÿvHèÔ‹ÿÿƒÄ,€}ÿu2Àë€~(t°ëjRP‹Îè”^‹å]‹ÿU‹ìQQV‹ñè>ÿuEÿÆEÿÿuƒì ‹ÌPÿvƒúTt,ƒúh…ðP€:huƒÀÇA ‰A^ÃÇA éÊ@ÇA ‰A^Ã@ÇA ‰A^ÃpŠ€ú3u€x2uƒÀ‰AÇA 	^Àú6u€x4uƒÀÇA 
‰A^Àúdt€úit€úot€úut
€úxt€úXu\‰qëº@ÇA ‰A^Ãúlt$ƒúttƒúzu;@ÇA ‰A^Ã@ÇA ‰A^ÃP€:luƒÀÇA ‰A^ÃÇA ‰Q^ËAV·ƒújÏ„ºƒúItVƒúLtBƒúTt.jh^;Ö…ÿPf92uƒÀÇA(‰A^ÃÇA(éÙƒÀÇA(‰A^ÃÀÇA(‰A^Ãp·ƒú3ufƒx2uƒÀ‰AÇA(	^Ãú6ufƒx4uƒÀÇA(
‰A^Ãúdtƒúitƒúotƒúut
ƒúxtƒúXud‰q빃ÀÇA(‰A^Ãjl^;Öt(ƒúttƒúzu?ƒÀÇA(‰A^ÃÀÇA(‰A^ÃPf92uƒÀÇA(‰A^ÃÇA(‰Q^ËÿV‹ñèÔ¶V¹€f…Pt6‹FŠ„Éu&3ÀÇF*‰Ff‰FˆF‰F‰F‰F ˆF$‰F(2Àë	@ˆN‰F°^°‹QŠ·Pj][f;Ót2·Hþ‹Úf;Ëv‹Á‹Ë‹ØC·Á‰Eøf;Ët‹ðV‹ÏèÍFf;óuò‹uôëQ‹Ï躃F‹F‹Uðj]Yf9u”Š]ÿ‹Ffƒ8u
j‹Îèªóÿÿ2Àë„Ût‹ÏèëÚÿÿƒF°[_^‹å]ÃA,ÃA4Ë3ÉA#ÁƒÈu3ÉŠÁË3ÉA#ÁƒÈu3ÉŠÁË3ÉA#ÁƒÈu3ÉŠÁË3ÉA#ÁƒÈu3ÉŠÁËÿU‹ìV¶u‹ÖÁê¶
æ€yNƒÎøF«ðˆ
^]‹ÿU‹ìV·uèÒÓÿÿ‹ÎÁéȶæ€yNƒÎøF«ðˆ^]‹A ƒøuÆA$ƒøt
ƒøtƒøuÆA$ËA(ƒøuÆA,ƒøt
ƒøtƒøuÆA,ÃÌÌÌ‹ÿU‹ìììS‹]3ÒV‹Ã¾ Áèƒã‹Î‰Eô+ˉ]WFá‰Mäè+I‹UH‰Eè÷ЉEìÇEø‹:‹º½Át@ë3À‹Mô+ð;ޗÈ]ÿƒøs—ǃøsu„Ût³ë2Û„ÿ…˜„Û…¾r;ÆBð‰uø‹Þƒþÿt_+ñz‹Ã@<·‚‰Eð;ÙrG‹
;ñs‹ë3ÒFÿ;Ás‹Güë3À#EìK‹MäN#UèƒïÓè‹MÓâ‹Mð‹U‰ƒé‰Mð‹Môƒûÿuµ‹uø…Étz3Àó«€}ÿtF_‰2°^[‹å]Ãj…þÿÿÇ…þÿÿPBÇhÌPè1
ƒÄ2À_^[‹å]ËÿU‹ìŠEƒÄ‰F(ƒøÿtOjY3À}¼ó«jE¼P3À@Pÿu¸èÙ…Àt3FPEÄPèY
„ÀYY•Àëxƒùt'ƒùt"…ÉuèïïþÿÇ	2Àë[ÿH±EPè£ïþÿYëí3Àºƒù•ÀH#ÂÂf‰F3À@f‰F‹E‰F‰ƒùt3ÛE¸SPSSSWÿð±E…Àt
‹E¸™‰F‰V3À@‹Mü_^3Í[èé7ýÿ‹å]ËÿU‹ìƒìP¡ÀF3ʼnEü‹ESV‹uW‹}W‰E´‰}¸ÿì±E‹È3Àáÿÿÿ@;È…õf‰F3Û‹E´…Àt M°‰]°QPè
YY„À„ê‹E°H‰F‰j
Y3À}Ôj(ó«EÔPSÿu¸è²Ž…À„Ä‹E´Pÿuôèo	SSÿuèf‰Fÿuäèl‰F(ƒÄ#‰V,ƒøÿ„Rÿv(ÿuàÿuÜèI‰F ƒÄ#‰V$ƒøÿtpÿv,ÿv(ÿuØÿuÔè(‰F0ƒÄ#‰V4ƒøÿtOjY3À}¼ó«jE¼P3À@Pÿu¸èŽ…Àt3FPEÄPè„ÀYY•Àëxƒùt'ƒùt"…Éuè3îþÿÇ	2Àë[ÿH±EPèçíþÿYëí3Àºƒù•ÀH#ÂÂf‰F3À@f‰F‹E‰F‰ƒùt3ÛE¸SPSSSWÿð±E…Àt
‹E¸™‰F‰V3À@‹Mü_^3Í[è-6ýÿ‹å]ËÿU‹ìƒìP¡ÀF3ʼnEü‹ESV‹uW‹}W‰E´‰}¸ÿì±E‹È3Àáÿÿÿ@;È…õf‰F3Û‹E´…Àt M°‰]°QPèbYY„À„ê‹E°H‰F‰j
Y3À}Ôj(ó«EÔPSÿu¸èöŒ…À„Ä‹E´Pÿuôè³SSÿuèf‰Fÿuäè°‰F ƒÄ#‰V$ƒøÿ„Rÿv ÿuàÿuÜè‰FƒÄ#‰Vƒøÿtpÿv$ÿv ÿuØÿuÔèl‰F(ƒÄ#‰V,ƒøÿtOjY3À}¼ó«jE¼P3À@Pÿu¸èaŒ…Àt3FPEÄP评ÀYY•Àëtƒùt'ƒùt"…ÉuèwìþÿÇ	2ÀëWÿH±EPè+ìþÿYëí3Àºƒù•ÀH#ÂÂf‰F3À@f‰F‹E‰F‰ƒùt3ÛE¸SPSSSWÿð±E…Àt‹M¸‰N3À@‹Mü_^3Í[èu4ýÿ‹å]ËÿU‹ìƒì(¡ÀF3ʼnEüƒ}uƒ}u‹EëpEÜPEPÿø±E…ÀtNEìPEÜPjÿô±E…Àt:ƒMØÿEØPEøPEöPEôPEòPEîPEìPè݃ăøÿuèŠëþÿÇ„ë
ÿH±EPè@ëþÿYƒÈÿ‹Mü3ÍèÔ3ýÿ‹å]ËÿU‹ìƒì(¡ÀF3ʼnEüƒ}uƒ}u‹E‹UëvEÜPEPÿø±E…ÀtREìPEÜPjÿô±E…Àt>ƒMØÿEØPEøPEöPEôPEòPEîPEìPèw‹ÈƒÄ#ʃùÿuèâêþÿÇ„ë
ÿH±EPè˜êþÿYƒÈÿЋMü3Íè*3ýÿ‹å]ËÿU‹ì‹E ÿ0‹E·P‹E·P‹E·P‹E·P‹E·P‹E·PèŽ!ƒÄ]ËÿU‹ì‹E ÿ0‹E·P‹E·P‹E·P‹E·P‹E·P‹E·Pè[!ƒÄ]ËÿU‹ì‹E ÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0è!ƒÄ]ËÿU‹ì‹E ÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0è÷ ƒÄ]ËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹E‰A‹Á]‹ÿU‹ì‹E‰‹E‰A‹Á]‹ÿU‹ì‹E‰‹E‰A‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹E‰A‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñƒ>ÿtÿ6ÿ<±Eƒÿ^ËÿV‹ñÿ6èüÿÿƒ&Y^Ã3Àƒ9ÿ•ÀÃÿ1èÀYËÿU‹ìƒì0VW‹ù‹‹‹Á‹Ñƒà?Áúkð0‹•¨ÚFöD2(uègèþÿÇ	ƒÈÿë9‹Gÿ0ÿt2QjèŽúÿÿƒÄ„Àuj0EÐjPèFýÿ‹uЃÄ‹?jYó¥ëÄ3À_^‹å]ËÿU‹ìƒì0VW‹ù‹‹‹Á‹Ñƒà?Áúkð0‹•¨ÚFöD2(uèíçþÿÇ	ƒÈÿë9‹Gÿ0ÿt2Qjè¶öÿÿƒÄ„Àuj0EÐjPèFýÿ‹uЃÄ‹?jYó¥ëÄ3À_^‹å]ËÿU‹ìƒì$S‹ÙV‹‹0‹Æ‹Öƒà?ÁúkÈ0‹•¨ÚFöD
(uèsçþÿÇ	ƒÈÿë8‹Cÿ0ÿt
VjèžôÿÿƒÄ„ÀuWj	Y3À}Üó«‹{uÜj	YƒÈÿ‹?ó¥_ë3À^[‹å]Ãÿ1èJYÃÿ1èŠYÃÿ1è8YËÿU‹ìƒì8VW‹ù‹‹‹Á‹Ñƒà?Áúkð0‹•¨ÚFöD2(uèßæþÿÇ	ƒÈÿë9‹Gÿ0ÿt2QjèJ÷ÿÿƒÄ„Àuj8EÈjPèùDýÿ‹uȃÄ‹?jYó¥ëÄ3À_^‹å]Ãÿ1èµYÃÿ1èõYÃÿ1èìYÃÿ1èãYËÿU‹ìVWèeæþÿ‹8è^æþÿÿuÿuƒ ÿu脃Ä‹ðèCæþÿ…öt‰8‹Æë$ƒ8"t3Àëè+æþÿjÿuj‰8èT‹MƒÄ‰_^]ËÿV‹ñƒ>ÿtÿ6ÿ<±Eƒÿ^ËÿU‹ìÿuÿ<±E÷ØÀ÷Ø]ËÿU‹ì‹M‹Eƒ!ƒxu‹=ÿÿÿw‰°]Ãè¼åþÿÇ„2À]ËÿU‹ìV‹uW‹}ƒ&ƒf‹G=ÿÿÿ~èåþÿÇ„2Àë3É™‰ƒÐ‰F°_^]ËÿU‹ìVW¶}‹ÇÁè¨uÿuè3¾€Y„Àt¾@@ÿuÁç÷×ç€Ï÷èšY„ÀtƒÎ@‹ÆÁèƒà8ð‹ÆÁèƒà_Æ^]ËËÁËÁËÿU‹ì‹M3ÒSV‹uWjA[‰·jZ_f;Øwf;ÇvjaZf;Ðw9ƒøzw43Òfƒy:u$f9Qujè…äþÿY2Àëf;Ãrf;ÇwƒÀ ƒÀ ‰è‰°_^[]ÃÈÿËÿU‹ìƒ}u2À]ÃVj.ÿuèf'‹ðYY…ötDhXFVè7YY…Àt7hdFVè&YY…Àt&hpFVèYY…Àth|FVèYY…Àt2Àë°^]ËÿU‹ì‹M…ÉtG·jAZf;ÐwƒøZv
jaZf;Ðwƒøzw
fƒy:uƒÁ·f…Àu°]ÃPèփĄÀtfƒytè2À]ËÿU‹ì‹U‹ÊVW3ÿqf‹ƒÁf;Çuõ+ÎÑùƒù‚•·P蒃ĄÀ„·BPè}ƒÄ„Àtp·BPèlƒÄ„Àu_J·f…ÀtTPèTƒÄ„ÀuƒÁ·f…Àuèf99t7ƒÁf99t/·f…Àt#Pè'ƒÄ„ÀuƒÁ·f…Àuèf99tf9yu°ë2À_^]ËÿU‹ìfƒ}\tfƒ}/t3À]Ã3À@]ËÿU‹ìì¡ÀF3ʼnEüV‹uhˆFVèU
YY…Àu2ÀëpS…ðýÿÿ3ÛPh…ôýÿÿ‰ðýÿÿVPè+üÿÿ‹ÐƒÄ…Òt6‹ÊWyf‹ƒÁf;Ãuõ+ÏÑù_ƒùtRè¦þÿÿY„ÀtVÿè±E3ÛC;Ãw3ÛÿµðýÿÿèŸ	ÿÿYŠÃ[‹Mü3Í^è¯*ýÿ‹å]Ã3Àƒ9ÿ•ÀËÿV‹ñÿ6èw	ÿÿƒ&Y^ËÿU‹ì]éÉäÿÿ‹ÿU‹ì]é}åÿÿ‹ÿU‹ì]é:æÿÿ‹ÿU‹ì]é÷æÿÿ‹ÿU‹ìQƒ}VuÿujèýçÿÿYY‹ðë<ƒeüEüPÿuèYY…Àuÿuüè¢dYƒÎÿëÿuÿuüèÈçÿÿÿuü‹ðè‡dƒÄ‹Æ^‹å]ËÿU‹ìQƒ}VuÿujèïèÿÿYY‹ðë<ƒeüEüPÿuè²
YY…ÀuÿuüèBdYƒÎÿëÿuÿuüèºèÿÿÿuü‹ðè'dƒÄ‹Æ^‹å]ËÿU‹ìQƒ}VuÿujèëéÿÿYY‹ðë<ƒeüEüPÿuèR
YY…ÀuÿuüèâcYƒÎÿëÿuÿuüè¶éÿÿÿuü‹ðèÇcƒÄ‹Æ^‹å]ËÿU‹ìQƒ}VuÿujèçêÿÿYY‹ðë<ƒeüEüPÿuèòYY…Àuÿuüè‚cYƒÎÿëÿuÿuüè²êÿÿÿuü‹ðègcƒÄ‹Æ^‹å]ËÿU‹ì]é‰æÿÿ‹ÿU‹ì]éÐçÿÿ‹ÿU‹ì]é!éÿÿ‹ÿU‹ì]érêÿÿ‹ÿU‹ì]é`c‹ÿU‹ì‹Eˆ;Át‹U9t	ƒÀ;Áuõ3À]ËÿU‹ì¸csmà9Et3À]ÃÿuPèYY]ËÿU‹ìQQ¡ÀF3ʼnEüV莧‹ð…ö„C‹‹ÊS3ÛW‚;Ðt‹}99t	ƒÁ;Èuõ‹Ë…Ét‹y…ÿu3Àé
ƒÿu3À‰Y@éýƒÿ„ñ‹F‰Eø‹E‰Fƒy…ÄB$Plë‰XƒÀ;Âuö‹^¸‘À9wOtD9Àt39ŽÀt"9Àt9ÀuoÇFëfÇF†ë]ÇFƒëTÇF‚ëKÇF„ëB9’Àt39“Àt"9´Àt9µÀu"ÇFëÇFŽëÇF…ëÇFŠÿv‹ÏjÿвEÿ×Y‰^ëÿq‰Y‹ÏÿвEÿ׋EøY‰FƒÈÿ_[‹Mü3Í^èú&ýÿ‹å]Ã2ÀÃjè£Yƒøu°Ã…Àu	ƒ=8ÐFtð2ÀËÿU‹ììü¡ÀF3ʼnEüVjôÿ±E‹ð…ötJƒþÿtE‹UþÿÿŠˆAEü;Ètf‹ƒÂf…Àué3ÀPˆEû‰…þÿÿ…þÿÿP…þÿÿ+ÈIQPVÿü±E‹Mü3Í^èZ&ýÿ‹å]ËÿU‹ìjèYƒø„ø…Àu
ƒ=8ÐF„çSVh8Fh»@ÐFSè苃Ä3ö…À…ÉWhhrÐFVf£zÒFÿ°°E¿û…ÀuhlFWhrÐF誋ƒÄ…À…¹rÐFQf‹ƒÁf;Æuõ+ÊÑùAƒø"u
„É°"”ÁFˆMÿë5ÿ…ÿtŠˆGŠFˆEþ¾ÀPè(,Y…Àtÿ…ÿtŠˆGFŠEþ„ÀtŠMÿ„Éuµ< t<	u­…ÿtÆGÿëNÆEÿ€>„Š< t<	uFëó€>„¬‹M…Ét‰9ƒÁ‰M‹Eÿ3ÒB3ÀëF@€>\tù€>"u1¨uŠMÿ„ÉtN€9"u‹ñëŠMÿ3Ò„É”EÿÑèëH…ÿtÆ\Gÿ…ÀuñŠ„Àt;€}ÿu< t1<	t-…Òt#…ÿtˆG¾PèO+Y…ÀtFÿ…ÿtŠˆGÿFéwÿÿÿ…ÿtÆGÿé5ÿÿÿ‹M_^[…Étƒ!‹Eÿ‹å]ËÿU‹ì‹Eƒì‹M‹USV‹u3ÛW‹}‰Ç…öt‰ƒÆ‰uÇEø ÇEô	j"Xf9u
„Û”ÃÁëÿ…Òt	f‹f‰ƒÂ·ƒÁf…Àt„ÛuÐf;Eøt	f;Eôj"XuÄ…Òt3Àf‰Bþëƒé‹]3ÀˆEÿf9„Ú·f;Eøtf;EôuƒÁëì3Àf9„»…öt‰ƒÆ‰uÿ3Ûj\^ÇEð‹ÃëƒÁ@f91t÷j"^f91j\^u8¨u 8]ÿtj"^f9qj\^uƒÁë
8]ÿ‰]ð”Eÿ‹}Ñèë
H…Òtf‰2ƒÂÿ…Àuï·f…Àt*8]ÿuf;Eøtf;Eôt9]ðt…Òtf‰ƒÂÿƒÁésÿÿÿ‹u‹]…Òt3Àf‰ƒÂÿ3Àéÿÿÿ…öt‰ÿ_^[‹å]ËÿU‹ì‹E‹£0ÐF]ËÿU‹ì‹E‹£4ÐF]ËÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6è£Xƒ&Y^ËÿV‹ñÿ6è‘Xƒ&Y^Ë3Ò‹9t	IBƒ9u÷‹ÂË3Ò‹9t	IBƒ9u÷‹Â˃!˃!˃!Ãéü"ËÿU‹ì]麋ÿU‹ì]麋ËËÁËÁø ÐFø$ÐFá(ÐFá,ÐFËÿV‹ñÿ6èXƒ&Y^ËÿV‹ñÿ6èïWƒ&Y^ËÿU‹ì¾EPèT(÷ØYÀ÷Ø]Ã2ÀËÿU‹ìV‹uþÿÿÿ?r3Àë=WƒÏÿ‹M3Ò‹Ç÷u;Ès
¯MÁæ+þ;ùw3Àë1jPè+Yj‹ðè‚WƒÄ‹Æ_^]ËÿU‹ì]éëøÿÿ‹ÿU‹ì]éúÿÿ‹ÿU‹ì‹E£0ÐF]ËÿU‹ì‹E£4ÐF]áÙF…Àu
è£ÙFáŒÙF…Àu
è5£ŒÙFá„ÙF…Àu%9ˆÙFu3ÀÃèE…Àuôè—÷ØÀ÷Ð#„ÙFáˆÙF…Àu%9„ÙFu3ÀÃèo…Àuôèç÷ØÀ÷Ð#ˆÙFÃ=„ÙFt3ÀÃVWè`!èˆ(‹ð…öuƒÏÿë*VèÿY…ÀuƒÏÿëP¹„ÙF£ÙFèl3ÿjèsVYVèlVY‹Ç_^Ã=ˆÙFt3ÀÃVWè·(‹ð…öuƒÏÿë*Vè|Y…ÀuƒÏÿëP¹ˆÙF£ŒÙFèI3ÿjèVYVèVY‹Ç_^ËÿU‹ìV‹u3ÒŠ„ÀtW<=tB‹ÎyŠA„Àuù+ÏFñŠ„Àuä_‹Â^]ËÿU‹ìSV‹u3Û‹Ó·f…Àt+Wfƒø=tB‹Îyf‹ƒÁf;Ãuõ+ÏÑù4NƒÆ·f…Àu×_^‹Â[]ËÿU‹ìQQSVW‹}3Ò‹÷Šë<=tB‹ÎYŠA„Àuù+ËFñŠ„ÀuäBjPèûV‹ØYY…Ûtm‰]üëR‹ÏQŠA„Àuù+Ê€?=A‰Eøt7jPèÍV‹ðYY…öt0WÿuøVèýUƒÄ…ÀuA‹Eüj‰0ƒÀ‰EüèU‹EøYø€?u©ëSè#jèèTYY3ÛjèÝTY_^‹Ã[‹å]Ã3ÀPPPPPèÚ\Ì‹ÿU‹ìQQS‹]3À‰Eø‹ÐVW·‹óf…Àt/j=[f;ÃtB‹Îyf‹ƒÁf;Eøuô+ÏÑù4NƒÆ·f…Àu׋]BjPèV‹ø3öYY…ÿty‰}üë]‹ËQf‹ƒÁf;Æuõ+ÊÑùj=AY‰Eøf9t8jPèÕU‹ðYY…öt2SÿuøVèzƒÄ…ÀuC‹Eü‰03öƒÀV‰Eüè	T‹EøYCf93užëWèX3öVèíSYY‹þVèãSY‹Ç_^[‹å]Ã3ÀPPPPPèà[Ì‹ÿU‹ìV‹u…öt‹W‹þëPè²S‹Y…ÀuðVè¢SY_^]ËÿU‹ìV‹u…öt‹W‹þëPèƒS‹Y…ÀuðVèsSY_^]ÃéJ%éÈ%‹ÿW‹=ˆÙF…ÿuƒÈÿ_ÃSV3ÛëQSSSSjÿÿ7SSÿرE‹Ø…ÛtLjSèÎT‹ðYY…öt5jjSVjÿÿ73ÛSSÿرE…ÀtSVè9SèSƒÄƒÇ9u«3À^[_ÃVèëRYƒÈÿëð‹ÿW‹=„ÙF…ÿuƒÈÿ_ÃSV3ÛëKSSjÿÿ7SSÿh°E‹Ø…ÛtHjSèQT‹ðYY…öt1SVjÿÿ73ÛSSÿh°E…ÀtSVèËSèˆRƒÄƒÇ9u±3À^[_ÃVèrRYƒÈÿëð‹ÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0è5SƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èŒ}ƒÄ]ËÿU‹ì‹E‹PŠ@„Éuù+Â]ËÿU‹ì‹E‹Pf‹ƒÀf…Éuõ+ÂÑø]ËÿU‹ìQ¡ÀF3ʼnEüV‹ñW~ë‹MVÿвEÿUYƒÆ;÷uë‹Mü_3Í^èGýÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüV‹ñW~ë‹MVÿвEÿUYƒÆ;÷uë‹Mü_3Í^èýÿ‹å]‹ÿU‹ì‹E‹;ÙFtPè–ýÿÿY]ËÿU‹ì‹E‹;ŒÙFtPèªýÿÿY]Ã3À9•ÀÃ3À9•Àø„ÙFøˆÙFø„ÙFøˆÙFøÙFøŒÙFËÿU‹ìA‹Ð+уÂV3öÁê;ÁÀ÷Ð#Ât
‹UF‰I;ðuö^]‹ÿU‹ìA‹Ð+уÂV3öÁê;ÁÀ÷Ð#Ât
‹UF‰I;ðuö^]Â3À9•ÀÃ3À9•ÀÃéMÃévùÿÿé ùÿÿh±bC¹„ÙFè…þÿÿhÌbC¹ˆÙFè¶þÿÿÿ5ÙFè™üÿÿÿ5ŒÙFè½üÿÿYYø„ÙFøˆÙFáÙF…Àu
è ùÿÿ£ÙFáŒÙF…Àu
è;ùÿÿ£ŒÙFÃé_ùÿÿé³ùÿÿ‹ÿSVèÄ‹5(ÐF…öu¾”ÙF2ÛŠ< „Àt*„Ût <"u„۔þÀPèY Y…ÀtFFë×< FŠ„Àuõ‹Æ^[á,ÐF…Àu¸˜ÙFVj 2Ò^·f;Îw	f…Ét#„Òtƒù"u„Ò”ƒÀëàf;ÎwƒÀ·f…Éuð^Ãé/á(ÐFá,ÐFËÿU‹ì¾EPèÙ÷ØYÀ÷Ø]Ã2ÀËÿSVèþ‹5(ÐF…öu¾”ÙF2ÛŠ< „Àt*„Ût <"u„۔þÀPè“Y…ÀtFFë×< FŠ„Àuõ‹Æ^[á,ÐF…Àu¸˜ÙFVj 2Ò^·f;Îw	f…Ét#„Òtƒù"u„Ò”ƒÀëàf;ÎwƒÀ·f…Éuð^ËÿU‹ìQQ¡ÀF3ʼnEü‹ESV‹u+ƃÀW3ÿÁè9uÛ÷Ó#Øt‹‰Eø…Àt‹ÈÿвEÿUøƒÆG;ûuä‹Mü_^3Í[èéýÿ‹å]ËÿU‹ìQ¡ÀF3ʼnEüV‹uWë‹>…ÿt‹ÏÿвEÿ×…Àu
ƒÆ;uuä3À‹Mü_3Í^è¤ýÿ‹å]áÀFƒàj Y+È3ÀÓÈ3ÀFËÿU‹ì¡ÀF‹È3EƒáÓÈ]ËÿU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]ËÿU‹ìÿuÿuÿ€°E]ËÿU‹ì‹E‰‹Á]‹ÿV‹ñƒ>tÿ6ÿ°Eƒ&^ËÿU‹ì3À}csmà”À]ËÿV‹ñƒ>tÿ6ÿ°Eƒ&^ËÿU‹ìÿuÿ°E÷ØÀ÷Ø]Ãjh€¢F蛋u…öuèK„Àt	ÿuèžYjèÁYƒeü€=¤ÙF…™3À@¹œÙF‡ÇEü‹}…ÿu<‹ÀF‹Óƒâj Y+Ê3ÀÓÈ3Ë
 ÙF;Èt3Ù3ÀPPP‹ÊÓË‹ËÿвEÿÓh´ÙFë
ƒÿuhÀÙFè!Yƒeü…ÿuh³Eh³EèßýÿÿYYh³Eh³EèÎýÿÿYY…öuƤÙFÇEüþÿÿÿè'…öu,ÿuè*‹Eì‹ÿ0èÅþÿÿƒÄËeèèM#‹ujè$YÃèØËÿU‹ìèq„Àt d¡0‹@hÁè¨uÿuÿ±EPÿ€±EÿuèsYÿuÿ²EÌ‹ËÁÃ3ÀÃjÿ¤±E‹È…Éu2ÀøMZf9uó‹A<Á8PEuæ¹f9HuÛƒxtvÕƒ¸è•ÀÃèzp„ÀuÃd¡0‹@hÁèöÐ$ËÿU‹ìQQ¡ÀF3ʼnEüƒeøEøPh$Fjÿ²E…Àt#Vh<Fÿuøÿ€°E‹ð…öt
ÿu‹ÎÿвEÿÖ^ƒ}øt	ÿuøÿ°E‹Mü3Íè±ýÿ‹å]ËÿU‹ìjjÿuèÃýÿÿƒÄ]ËÿU‹ì‹E£ ÙF]Ãjjjè¤ýÿÿƒÄÃjjjè•ýÿÿƒÄËÿU‹ìjjÿuè€ýÿÿƒÄ]áœÙFËÿU‹ì¡ÀFƒàj Y+È3ÀÓÈ3ÀF9 ÙF…¡!ÿuè¬üÿÿY£ ÙF]ËÿU‹ìjjÿuè,ýÿÿƒÄ]ËÿU‹ìjjÿuèýÿÿƒÄ]ËÿU‹ì‹E‹]ËÿU‹ì‹M…ÉuèaÇþÿÇè!RjX]áìÞF‰3À]ËÿU‹ì‹E=@t#=€t=tè$ÇþÿÇèäQjX]ùìÞF‡3À]Ãjh¨¢FèGýÿ‹}ÿ@t0ÿ€t(ÿt ÿtÿtèÍÆþÿÇ鹋uƒþþuèµÆþÿÇ	馅öˆŽ;5¨ÜFƒ‚‹ÎÁù‰Mà‹Æƒà?kÐ0‰UÜ‹¨ÚF¶D(ƒàt^VèÜõYƒËÿ‰]äƒeü‹Eà‹…¨ÚF‹MÜöD(u
èHÆþÿÇ	ëWVè>YY‹Ø‰]äÇEüþÿÿÿè
‹Ãë!‹u‹]äVè=öYÃèÆþÿÇ	èÏPƒÈÿèŒýÿËÿU‹ìQ‹ESVW‹øƒà?ÁÿkÐ0‹4½¨ÚFŠD(Š\)¶ÈဉMü‹Mù@tPù€t@ùt$ùtùuB€ˆD(‹½¨ÚFÆD)ë.€ˆD(‹½¨ÚFÆD)ë$ˆD(ë€ˆD(‹½¨ÚFÆD)ƒ}üu¸€ë„Ûu¸@ë3À€û•ÀH%_^[‹å]Ã3ÀËÿU‹ìÿuèÿGY]‹ÿU‹ìÿuèíGY]‹ÿU‹ìÿuèÛGY]ÂjhP£Fè/ýÿƒeü‹Mè
ÇEüþÿÿÿèèXýÿÂ‹E‹‹ƒ PïÃjh£Fèôýÿ‹Eÿ0è |Yƒeü‹E‹‹ÿ0è
.YÇEüþÿÿÿèèýÿÂ‹Eÿ0è6|YÃjhp£Fèªýÿ‹Eÿ0èÖ{Yƒeü‹Mè	ÇEüþÿÿÿèèÈýÿÂ‹Eÿ0èó{YÃjh0£Fègýÿ‹Eÿ0è“{Yƒeü‹E‹‹‹@ðÿÇEüþÿÿÿèè€ýÿÂ‹Eÿ0è«{YËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèÿÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèlÿÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèÿÿÿ‹å]ËÿU‹ìQÿuEÿÿuMÿPè`þÿÿ‹å]ÃËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹E‰A‹E‰A‹E‰A‹E‰A‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹E‰A‹E‰A‹E‰A‹E‰A‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6è	Eƒ&Y^ËÿV‹ñÿ6è÷Dƒ&Y^ËÿV‹ñÿ6èåDƒ&Y^Ã3À9•ÀÃ3À9•ÀÃ3À9•ÀÃÿ1è£yYË‹ÿ0èN+YËÿU‹ìƒìVWh¸j‹ùè9F‹ð‹j‰0èŒDƒÄ…öt*‹‰Eì‹G‰Eð‹G‰Eô‹G‰Eø‹G‰EüEìPjèçýÿÿYY_^‹å]ÃÃÿ1èèxYÃÿ1è'yYË‹‹@ðÿÃÿ1èËxYÃÿ1èÂxYËÿV‹ñ‹F‹ÿpL‹ÿ0è-‹Fÿ0‹Fÿ0‹ÿ0èº‹NƒÄ‰…À„¯‹F‹…Àt?ºÃFWf‹83ÉAf;:uf…ÿtf‹xf;zuƒÀƒÂf…ÿuÛ3ÀëÀÁ_…Àt¸¨ÙF‡‹ÿ0‹F‹ƒÀLPèn-‹ÿ0èm,‹FƒÄ‹ö€PuOö4ÉFuFÿpLhìÝFè>-¡ìÝFYY^‹ˆˆ‰
0ÉF‹‰
ÃF‹@£<ÂFËÿ0è,‹ÿ0èC*YY^Ãÿ1èxYË‹ƒ Pï˃!˃!˃!ËËËÃ3À9•ÀÃ3À9•ÀÃ3À9•ÀËÿV‹ñÿ6èÓBƒ&Y^ËÿV‹ñÿ6èÁBƒ&Y^ËÿV‹ñÿ6è¯Bƒ&Y^ËÁËÿU‹ìƒ}u3À]ÃSjUÿuè/u‹ØYYƒûUr3Àë]WPè«B‹øY…ÿu_[]ÃCPÿuPWè‰øƒÄ…Àu‹Çëã3ÀPPPPPèTJÌ3À¹¨ÙF@‡Ãjhð¢FèŽýÿ¾@ÂF95ìÝFt*jè°vYƒeüVhìÝFèá+YY£ìÝFÇEüþÿÿÿèè˜ýÿÃjèÈvYËÿU‹ìVW‹}Wÿuÿuè$mƒÄ3ö…ÀuF‡€f90tPh´Fjÿuÿuè
ƒÄÇf97tWh¸FjÿuÿuèéƒÄ_^]ÃVVVVVè‡IÌ‹ÿU‹ìQQSVW‹}3ÛhÊSWè½ýÿ‹uƒÄ·f…Àu3Àéíj.Yf;Áu-Ff9t%jP‡jPèS÷ƒÄ…À…Èf‰‡ëĉ]üh¬FVèô%YY…À„F·‰Mø‹Müj,Z…Éuƒø@ƒj.Yf;ÙtyPVj@Wë:ƒùuƒø@shƒû_tcPVj@‡€ëƒùuRƒøsMf…Ûtf;ÚuCPVj‡Pè½öƒÄ…Àu#j,Xf;Ø„/ÿÿÿf…Û„&ÿÿÿ‹uøƒÆÿEüéWÿÿÿ3ÀPPPPPëƒÈÿ_^[‹å]ÃSSSSSèXHÌ‹ÿU‹ìVèx„‹U‹ðjX‹ŽPöÁ”À@ƒúÿt3…Òt6ƒútƒútè'½þÿÇèçGƒÈÿëƒáýëƒÉ‰ŽPëƒ
4ÉFÿ^]ËÿU‹ìV‹u…öt‹E…Àt;ÆtWj.Y‹øó¥ƒ`PèS&Y_^]ËÿU‹ìì¡ÀF3ʼnEü‹EV‹uƒþw2…Àt.hƒôþÿÿQjÿPjjÿh°E…Àt…ôþÿÿPVè¿YYë3À‹Mü3Í^èÚýÿ‹å]ËÿU‹ììô¡ÀF3ʼnEü‹ES‹]V‹u‰…þÿÿ‰þÿÿW‹}‰½$þÿÿ…öu3À‹Mü_^3Í[èýÿ‹å]Ãè<ƒjUHh‰(þÿÿHl‰ þÿÿˆr ‰,þÿÿPÿu3ɉ…þÿÿW‰þÿÿ‰þÿÿèëôƒÄ…À…ofƒ>Cu43ÿf9~u,‹µþÿÿh¨FÿuVèäiƒÄ…À…Ÿ…Ût‰;‹Æébÿÿÿ‹þ3ÒOf‹ƒÇf;Âuõ+ùÑÿÿƒsv‹…,þÿÿ‹Îf‹f;uf…Òtf‹Pf;QuƒÀƒÁf…ÒuÞ3ÀëÀƒÈ…À„Ë… þÿÿ‹Îf‹f;uf…Òtf‹Pf;QuƒÀƒÁf…ÒuÞ3ÀëÀƒÈ…À„ˆèMa3Û„À…0þÿÿVP”ÃèUüÿÿYY…À…Š…0þÿÿ…Û‹(þÿÿPSPtèm8ëè/ƒÄ…Àtj…0þÿÿPhƒÿµ,þÿÿèžûÿÿ‹$þÿÿƒÄ…Û„ÔPÿÿÿQf‹ƒÁf;…þÿÿuñ+ÊÑùAP…PÿÿÿPÿuSé”3ÀPPPPPéV‹(þÿÿVè³\…À„ýj…þÿÿPh VèGZ…Àt
‹…þÿÿ…Àuÿ²E‰…þÿÿ·À‰_SVhƒÿµ,þÿÿè	óƒÄ…Àu‘SVÿuÿµ$þÿÿèòòƒÄ…À…vÿÿÿSVjUÿµþÿÿèØòƒÄ…À…\ÿÿÿ3Ûf9t+¹ƒ;ùs"GPVQÿµ þÿÿè¬òƒÄ…ÀtSSSSS錋… þÿÿ3Éf‰‹þÿÿ…Ût
‹…(þÿÿ‹‰‹,þÿÿ‹µþÿÿSÿuVèŒgƒÄ…À…êþÿÿ‹Ãéýÿÿ‹$þÿÿ3ö‹ËQf‹ƒÁf;Æuõ+ÊÑùAPSjUÿµþÿÿè&òƒÄ…À„ÕüÿÿVVVVVëWWWWWèìCÌjhÈ¢Fè1ýÿ‹u…ö„ƒjèUpYƒeü‹N…ÉtƒÈÿðÁu~°ÆFt	ÿvè”;YÇEüþÿÿÿèRƒ>t=jèpYÇEüÿ6èP$Y‹…Àtƒxu=@ÂFtPèj"YÇEüþÿÿÿèVè?;Yèä
ýÿËujèpYËujèpYËÿU‹ìQQVèRjj‹ðè¨<‰EüYY…Àu3öëGè[$èËEü‹NL‰‹Eü‹NH‰HEü‰EøEøPjè	ôÿÿEü‰EøEøPjè ôÿÿ‹uüƒÄƒeüjè­:Y‹Æ^‹å]ËÿU‹ìQƒ}‡óƒ}„éSW3ÛjCSè<‹ø‰}üYY…ÿu艷þÿ3ÛÇé²Vh¸Sèõ;‹ðYY…öuèc·þÿ3ÛÇé„h SèÐ;‹øYY…ÿu
è>·þÿÇëXh@ÂFVè.úÿÿÿuÿuVèƒąÀt*WÿvèÀYY…Àu‹Eü‹Î‰3ö‹Ø‰‹Ï3ÿ‰H3À‰EüëVè±"V3öèÝ YY3ÛWè»9‹}üYVè±9Y^Wè©9Y_‹Ã[ë3À‹å]ËÿU‹ìS3ÛV‹ó9]~"W}ÿ7ÿuÿuègîƒÄ…ÀuF;u|ã_^[]ÃSSSSSèoAÌ‹ÿU‹ìƒì(ƒeôƒeðƒ}vè[¶þÿÇèA3ÀëRèk}‰Eøè‰"‹EøMÿƒˆPEø‰EìEð‰EØEø‰EÜEô‰EàE‰EäE‰EèEìPEØPEÿPèñÿÿ‹Eô‹å]ËÿU‹ìƒìSV3öFh¦‰uøèû8‹Ø3ÀY…Û„W{f‰‰3‹uF0ÿ0‰Eôh¤Fÿ5\FjhQWèìþÿÿ¸\FƒÄ‰Eüh FhQWè\íƒÄ…À…‹EôH‹‰Mô‹	f‹f;uf…Òtf‹Pf;QuƒÀƒÁf…ÒuÞ3ÀëÀƒÈ‹Mü÷ØÀƒÁ÷ЉMü!Eø‹Eô‰Eôÿ0h¤Fÿ1jhQWè`þÿÿ‹EüƒÄ=ŒFŒnÿÿÿƒ}øuJ‹N(ƒÏÿ…Ét‹ÇðÁu	ÿv(èË7Y‹F$…ÀtðÁ8Ou	ÿv$è´7Yƒf$Cƒf‰^(‰F _^[‹å]ÃSè•7Y‹N(ƒÏÿ…Ét‹ÇðÁu	ÿv(èz7Y‹F$…ÀtðÁ8Ou	ÿv$èc7Y3À‰F$‰F‰F(‰F ‹F@ë­3ÀPPPPPèV?Ì‹ÿU‹ììСÀF3ʼnEü‹ESV‹uW‹}‰½8þÿÿ…Àt!…ötVPW讃Ä郃ÀÀ‹Çév3ÀÇ…@þÿÿ‰…4þÿÿ‹Ø‰Dþÿÿ…ö„Mfƒ>L…afƒ~C…Vfƒ~_…Kh˜FVèQދ؉0þÿÿYY…Û„'+ÆÑø‰…@þÿÿ„j;Xf9„‹½@þÿÿ»\FÇ…<þÿÿWVÿ3衃Ä…Àu‹Qf‹ƒÁf;…4þÿÿuñ+ÊÑù;ùtÿ…<þÿÿƒÃûŒF~Ë0þÿÿƒÃh FSè	‹½8þÿÿ‹ðYY…öuj;Xf9…‹ƒ½<þÿÿ_VS…ôþÿÿhƒPèìƒÄ…À…j6=ƒW3Éf‰Œôþÿÿ…ôþÿÿPÿµ<þÿÿWèLƒÄ…À‹…Dþÿÿt@‰…Dþÿÿë‹…Dþÿÿ4s3Éf9tƒÆf9…Ãþÿÿ…Àéã3ÀééPjU…HþÿÿPhƒ…ôþÿÿPVèþõÿÿƒÄ…À„Â3ÉW ‹ñ‰•Dþÿÿ…ö„‹
…ôþÿÿf‹8f;9‹½8þÿÿu3fƒ8t'f‹Pf;Qf‰•>þÿÿ‹•DþÿÿuƒÀƒÁfƒ½>þÿÿuÅ3É‹ÁëÀƒÈ3É…Àt,…ôþÿÿPVWèn‹•DþÿÿƒÄ…ÀtC3Éë
3É‹Á‰…@þÿÿëC‹…@þÿÿFƒÂ‰•DþÿÿƒþŽ^ÿÿÿ…Àu…Ûu‹ÁëWè¦ûÿÿY‹Mü_^3Í[èúùüÿ‹å]Ãè%ûüÿ3ÀPPPPPèq<Ì‹ÿU‹ììä¡ÀF3ʼnEüS‹]V‹uW‹}‰ýÿÿèpxx‰…,ýÿÿ…@ýÿÿPjU…HýÿÿPhƒ…ôþÿÿPVèµôÿÿƒÄ…Àu3À‹Mü_^3Í[èuùüÿ‹å]ÃsÁæ…ôþÿÿ‰µ8ýÿÿ‹>‹Êf‹0ƒ¥Dýÿÿf;1‹µ8ýÿÿu5fƒ8t'f‹pf;qf‰µ>ýÿÿ‹µ8ýÿÿuƒÀƒÁfƒ½>ýÿÿu¾‹…DýÿÿëÀƒÈ…Àu‹ÂëôþÿÿQf‹ƒÁf;…Dýÿÿuñ+ÊÑùA‰…4ýÿÿEPè„3‰…(ýÿÿY…À„>ÿÿÿ‹>ƒÀ‰0ýÿÿ‹ŒŸ ‰$ýÿÿ‹O‰ ýÿÿôþÿÿQÿµ4ýÿÿ‰…<ýÿÿPèW^ƒÄ…À…Sfƒ½ôþÿÿC‹…<ýÿÿ‰>ufƒ½öþÿÿu‹Dýÿÿ‰ŒŸ ë…HýÿÿPèðÿÿY‹Dýÿÿ‰„Ÿ ƒû…‹µ,ýÿÿ‹Ñ‹…@ýÿÿ‹Î‰G‰µ<ýÿÿ‹F ‰…4ýÿÿ‹F$‰…@ýÿÿ‹G;tG‹µ<ýÿÿB‹‹4ýÿÿ‹I‰‹@ýÿÿ‰@ýÿÿ‹ÎƒÁ‰^‹ýÿÿ‹µ,ýÿÿ‰…4ýÿÿ‰<ýÿÿƒú|´ë#…Òt‹Ö‰‹DÖ‰F‹…4ýÿÿ‰Ö‹…@ýÿÿ‰DÖƒúunjÿw…ôýÿÿPjhFjÿµDýÿÿècƒÄ…À‹…Dýÿÿt9¹ÿf!ŒEôýÿÿ@ƒøríhþÿ5øÀF…ôýÿÿPèuó3ɃÄ…À”Á‰Në‰F‹G‰‹F‰Gëƒûu‹…@ýÿÿ‰Gëƒûu	‹…@ýÿÿ‰GkÃW‹°XF‹ÎÿвEÿÖY‹0ýÿÿ…Àt>‹…8ýÿÿ‰8ÿ´Ÿ è=1‹(ýÿÿ‹…$ýÿÿQ‰„Ÿ è$1‹… ýÿÿYY‰GéýÿÿùÃFtJ‹óƒÉÿö‹D÷(ðÁu9ÿt÷(èò0ÿt÷$èé0ÿ´Ÿ èÝ0‹…8ýÿÿƒÄ‹Dýÿÿ‰8‰ŒŸ ë‹…8ýÿÿ‹(ýÿÿÛÇ‹8‰Lß(é§üÿÿ‹…DýÿÿPPPPPè¥8Ì¡ìÝF‹ˆˆ‰
0ÉF‹‰
ÃF‹@£<ÂFËÁá¬ÙFËÿU‹ì‹E…Àtƒøtèk­þÿÇè+8ƒÈÿ]ù¬ÙF‡]ø°ÙFáÀFƒàj Y+È3ÀÓÈ3ÀFËÿU‹ìÿuè0Y]Âjh£Fè`ýÿƒeä‹Eÿ0èˆdYƒeü‹M裋ð‰uäÇEüþÿÿÿè
‹ÆèsýÿÂ‹uä‹Eÿ0è›dYÃjh°£Fèýÿƒeä‹Eÿ0è7dYƒeü‹Mè)‹ð‰uäÇEüþÿÿÿè
‹Æè"ýÿÂ‹uä‹Eÿ0èJdYËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPè‹ÿÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèÿÿÿ‹å]ËÿU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]ËÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹E‰A‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6èl.ƒ&Y^ËÿU‹ìƒì¡ÀF3ʼnEü‹Á‰EèS‹‹…ÛuƒÈÿéé‹ÀFVW‹;‹ò‹[ƒæ3ú‰uì‹Î3ÚÓÏÓË…ÿ„¾ƒÿÿ„µ‰}ô‰]ðj Y+Î3ÀÓÈ3ƒë;ßr`9tõ‹3‹Mì3òÓ΋ΉÿвEÿÖ‹Eè‹ÀF‹òƒæ‰uì‹‹‹‹@3ʉMø3‹ÎÓMøÓÈ‹Mø;Môuj Y;Eðt ‹Mø‰Mô‹ù‰Eð‹Ø뎃ÿÿt
Wè‹-‹ÀFY‹Â3Òƒàj Y+ÈÓÊ‹Mè3ÀF‹‹‰‹‹‰P‹‹‰P_3À^‹Mü3Í[èÑòüÿ‹å]Ãÿ1è"bYËÿU‹ìƒì‹Á‰EøV‹‹0…öuƒÈÿé¡ÀF‹ÈS‹ƒáW‹~3Ø‹v3ø3ðÓÏÓÎÓË;þ…´+ó¸Áþ;ðw‹Æ<0…ÿuj _;þrjWSèÈ)j‰EüèÆ,‹MüƒÄ…Éu(j~WSè¨)j‰Eüè¦,‹MüƒÄ…ÉuƒÈÿ鑱‹Ù‰Eü4¹¡ÀF‹}üƒàj Y+È3ÀÓÈ‹Ï3ÀF‰Eô‹Æ+ǃÀÁè;÷Ò÷Ò#ЉUüt‹Uô3À@‰I;Eüuõ‹Eø‹@ÿ0è!ýÿÿS‰è[÷üÿ‹]ø‹‹	‰GPèI÷üÿ‹V‹	‰Aè<÷üÿ‹ƒÄ‹	‰A3À_[^‹å]Ãÿ1èØ`YÃÿ1è‡`YÃÿ1è~`Y˃!ËÿV‹ñÿ6èÏ+ƒ&Y^ËÿU‹ìÿuhÀÙFètYY]ËÿU‹ìÿuh´ÙFè^YY]ËÿU‹ìQE‰EüEüPjè!üÿÿYY‹å]ËÿU‹ìV‹u…öuƒÈÿë(‹;Fu¡ÀFƒàj Y+È3ÀÓÈ3ÀF‰‰F‰F3À^]ËÿU‹ìQQE‰EøE‰EüEøPjèèûÿÿYY‹å]Ãh@ÂF¹ìÝFèñ°Ãh´ÙFèƒÿÿÿÇ$ÀÙFèwÿÿÿY°ððÃèZÚÿÿ°ððáÀFVj ƒà3öY+ÈÓÎ35ÀFVèô1VèÂ)Vèr-Vè–ËÿÿVè™ßÿÿƒÄ°^ÃjèuýÿYáÐÈFƒÉÿVðÁu¡ÐÈF¾°ÆF;Æt
Pèv*Y‰5ÐÈFÿ5ôÝFèd*ÿ5øÝF3ö‰5ôÝFèQ*ÿ5 ÐF‰5øÝFè@*ÿ5$ÐF‰5 ÐFè/*ƒÄ‰5$ÐF°^ðËÿU‹ìA‹Ð+уÂV3öÁê;ÁÀ÷Ð#Ât
‹UF‰I;ðuö^]Âh8FhÀFèv'YYÃèšn…À•ÀÃèßm°Ãh8FhÀFèÔ'YYËÿU‹ìÿuèoY°]ËÿU‹ì‹M‹Eáÿÿ÷ÿ#ÁV‹u©àüðüt$…öt
jjèé8YY‰茦þÿj^‰0èM1‹ÆëQÿu…öt	èÅ8‰ëè¼8YY3À^]ËÿU‹ì‹E‹@…Àu¸ˆµC]Ãèjm‹@…Àu¸ˆµCËÿU‹ìèSm‹Ð‹B…Àu¸ˆµC‹M‰J]ÃjhУFèGáè,m‹p…ötƒeü‹ÎÿвEÿÖë3À@ËeèÇEüþÿÿÿè *Ì‹ÿU‹ì¡¨ÙFV…ÀuG9EuèÄ¥þÿÇè„0¸ÿÿÿë>ƒ}tã¾ÿÿÿ9uvè¥þÿÇè]0‹Æë^]éA=jÿuÿuÿuèƒÄ^]ËÿU‹ìƒìƒ}„ŸSVWÿuMðèNýÿ‹}¾ÿÿÿ…ÿt‹]…Ût‹M;Îvè2¥þÿÇèò/ëN‹Eôƒ¸¨uQSWèË<ƒÄ‹ðë3+û¶MôQPè[Mô‹ð¶QPèLƒÄCƒmt…öt;ðtÑ+ð€}üt
‹Mðƒ¡Pý_‹Æ^[ë3À‹å]ËÿU‹ìÿuèúËþÿY]‹ÿU‹ìQQƒeüEüSVWPÿu躃}‹øYYt‹]KŠC„Àuù+Ùë3Û‹MüQŠA„Àuù+ÊjAÃP‰Eøèm<‹ðYY…ö„‚ÿuüÆÿuøVè†KƒÄ…À…ÿuüèùY„Àth8FÿuøVè`KƒÄ…Àu_ƒ}tÿuÿuøVèGKƒÄ…ÀuF‹ÎQŠA„Àuù+Ê‹ÆÎ+ÁEøSPQVè_ƒÄ„Àt‹Þ3öë3ÛVè	ËþÿWè›&YY_^‹Ã[‹å]Ã3ÀPPPPPè—.Ì‹ÿU‹ìƒìSVWEü3öPÿu‰uô‰uüè}‹øYY9ut‹]Kf‹ƒÃf;Æuõ+ÙÑûë‹Þ‹MüQf‹ƒÁf;Æuõ+ÊÑùjAÃP‰EøèS;‹ðYY…ö„’ÿuü3Àÿuøf‰VèïÚƒÄ…À…‘ÿuüè Y„Àth<FÿuøVèÉÚƒÄ…Àuoƒ}tÿuÿuøVè°ÚƒÄ…ÀuV‹ÎQf‹ƒÁf;Eôuô+Ê‹UøÑùSN‹Á+ÆÑø+ÐRQVèƒÄ„Àt3À‹Þ‹ðë3À‹ØVèÝÉþÿWèo%YY_^‹Ã[‹å]Ã3ÀPPPPPèk-Ìjhð£Fè°÷üÿ3Ûˆ]çjèÚYY‰]ü‹E9ßFs
Ç@ÉF£ßF‹=@ÉFè1¢þÿ‹0‹
@ÉFA‰
@ÉF‹Á+Ç=ÿÿÿwMj
ÿuÿuQèoAƒÄ…Àu.èý¡þÿ‰SÿuèšJYY…Àt½èç¡þÿƒ8
t³èÝ¡þÿ‰0³ˆ]çëSSSSSèÂ,èÅ¡þÿ‰0ÇEüþÿÿÿèŠÃè@÷üÿÊ]çjèmYYÃjh¤Fèáöüÿ3Ûˆ]çjèYY‰]ü‹E9ßFs
Ç@ÉF£ßF‹=@ÉFèb¡þÿ‹0‹
@ÉFA‰
@ÉF‹Á+Ç=ÿÿÿwMj
ÿuÿuQèÜ@ƒÄ…Àu.è.¡þÿ‰SÿuèóHYY…Àt½è¡þÿƒ8
t³è¡þÿ‰0³ˆ]çëSSSSSèó+èö þÿ‰0ÇEüþÿÿÿèŠÃèqöüÿÊ]çjèžXYËÿU‹ìQSVW3ÛEühPFSP‰]üè5GƒÄ…Àt
ƒø„š‹óëN‹uü‹þ…ötESVè;IYY…Àu	‹E‹ó‰8ëgWèÊ‹øY…ÿtSWèIYY…Àu‹ES‰8èD#Yë?Wè;#Y‹}…ÿtSWèïHYY…Àu‹E‰8ëS¿@FWèÖHY…À‹EYtçÇDF‹ûVèü"Y‹Ç_^[‹å]ÃSSSSSèû*Ì‹ÿU‹ìQSVW3ÛEühTFSP‰]üèFƒÄ…Àt
ƒø„š‹óëN‹uü‹þ…ötESVè‘GYY…Àu	‹E‹ó‰8ëgWè[‹øY…ÿtSWènGYY…Àu‹ES‰8èr"Yë?Wèi"Y‹}…ÿtSWèEGYY…Àu‹E‰8ëS¿HFWè,GY…À‹EYtçÇLF‹ûVè*"Y‹Ç_^[‹å]ÃSSSSSè)*Ì‹ÿU‹ìQV3öEühPFVP‰uüè“EƒÄ…Àt	ƒøt3Àë‹Eü^‹å]ÃVVVVVèë)Ì‹ÿU‹ìQV3öEühTFVP‰uüèsEƒÄ…Àt	ƒøt3Àë‹Eü^‹å]ÃVVVVVè­)Ì‹ÿU‹ìV‹u3É3ÀW‹þŠ„ÒtG€ú"uA@GŠ„Òuò…Ét5+Á@jPè#‹øYY…ÿt‹Ïë
Š<"tˆAF€>uñÆjèA!Y‹Çë3À_^]ËÿU‹ìQSV‹u3ÛW‹Ë‹Ã‹Ö·>f…ÿteÇEü"f;}üuAƒÂ@·:f…ÿuí…ÉtG+Á@jPè‘"‹øYY…ÿu‹ûë%‹Çf9t‹Uü·f;Êtf‰ƒÀƒÆf9uê3Éf‰Sèº Y‹Çë3À_^[‹å]ËÿU‹ì‹Eÿ0ÿuè]FYY]ËÿU‹ì‹Eÿ0ÿuèoEYY]ËÿU‹ì‹Eÿ0‹Eÿ0è/FYY]ËÿU‹ì‹Eÿ0‹Eÿ0è?EYY]ËÿU‹ì‹Eÿ0‹Eÿ0èÿEYY]ËÿU‹ì‹Eÿ0‹Eÿ0èEYY]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èqDƒÄ]ËÿU‹ì‹Eÿuÿ0‹Eÿ0èUDƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0è7DƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èžÔƒÄ]ËÿU‹ì‹Eÿuÿ0‹Eÿ0è‚ÔƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èdÔƒÄ]ËÿU‹ì‹E‹PŠ@„Éuù+Â]ËÿU‹ì‹E‹Pf‹ƒÀf…Éuõ+ÂÑø]ËÿU‹ì‹E‹PŠ@„Éuù+Â]ËÿU‹ì‹E‹Pf‹ƒÀf…Éuõ+ÂÑø]ËÿU‹ì‹Eÿuÿ0‹Eÿ0è†BƒÄ]ËÿU‹ì‹Eÿuÿ0‹Eÿ0èˆBƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0è/;ƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èH;ƒÄ]ËÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6èJƒ&Y^ËÿV‹ñÿ6è8ƒ&Y^ËÿV‹ñÿ6èŽÂþÿƒ&Y^Ã3À9•ÀÃ3À9•ÀËÿU‹ì‹U‹ÊVqŠA„Àuù+Î4;Öt"ŠFÿ<\uj\RèûCYYNÿ3Ò;È•Àë+Át5+Át,+Át$ƒè@tèT‘þÿÇèƒÈÿë3À9~”ÀëjëjXë3À@ë3Àƒf‰FÇF€„Ûy€¿€…ßu÷Ã@uEüPè‰ÉÿÿY…Àuz9}üt€€¹…Ùt¡ßF÷Ð#E„ÀxÇFöÃ@tNNƒN÷Ãt	N÷à tNöà t	NëöÃtN_‹Æ^[‹å]Ã3ÀPPPPPèhÌ‹ÿU‹ì‹EjY+ÁtB+Át9+Át0+Át(ƒè@tèJþÿÇè
ƒÈÿ]Ã3À}€”À]ÃjëjX]Ã3À@]Ã3À]ËÿU‹ìQV¾€…ut2À^‹å]Ã÷E@t°ëîEüPèzÈÿÿY…Àu9uü•ÀëØ3ÀPPPPPèËÌ‹ÿU‹ìQV‹u‹Æƒà?‹ÖÁúkÈ0‹•¨ÚFŠD(¨Ht3Àë3„ÀyøSWjjÿjÿVè!A‹ø‹Ú‹ÏƒÄ#˃ùÿuènþÿ8ƒuN3À_[^‹å]Ã3Àf‰EüEüjPVèWƒÄ…Àufƒ}üuSWVèî:ƒÄƒøÿt3ÀPPPVèÀ@#ƒÄƒøÿu²è&þÿ‹ë«‹ÿU‹ìÿuÿuÿuèöÿÿƒÄ]ËÿU‹ìQVjEüƒÎÿPÿu‰uüÿuÿuÿuèV÷ÿÿƒÄ…Àu‹uü‹Æ^‹å]ËÿU‹ì]é:÷ÿÿ‹ÿU‹ìQƒeüEüPÿuèûºYY…ÀuƒÈÿë,V‹uüWÿu ÿuÿuÿuVÿuÿuè‹V‹øèiƒÄ ‹Ç_^‹å]ËÿU‹ìjÿuÿuÿuÿuÿuèÎöÿÿƒÄ]ËÿU‹ìÿuÿuÿuèöÿÿƒÄ]ËÿU‹ìQVjEüƒÎÿPÿu‰uüÿuÿuÿuèY÷ÿÿƒÄ…Àu‹uü‹Æ^‹å]ËÿU‹ì]é=÷ÿÿ‹ÿU‹ìƒìDSVWÿuE¼ÿuÿuPèùûÿÿƒÄ}Ô‹ðjYó¥ƒÎÿ9uàuè·þÿƒ ‹E‰0è½þÿ‹é×èû½‹]‰;Æuèþÿƒ ‰3è™þÿÇëÏ‹EuÔƒeð3ÉAÇEìƒì‰‹EÁè÷Ð#ÁjY‰Eô‹üEìPÿuó¥èuúÿÿ‹øƒÄ ‰}øºÀƒÿÿuk‹MØ‹Á#Â;Âu5öEt/ƒìEìáÿÿÿuÔ‰MØjY‹üPÿuó¥è0úÿÿ‹øƒÄ ‰}øƒÿÿu+‹‹Áƒá?ÁøkÉ0‹…¨ÚF€d(þÿH±EPè«ŒþÿYéÿÿÿWÿì±E…ÀuGÿH±E‹ðV茌þÿY‹‹Áƒá?ÁøkÉ0W‹…¨ÚF€d(þÿ<±E…ö…×þÿÿ蔌þÿÇ
éÇþÿÿƒøuŠEÔ@ë
ƒøŠEÔuWÿ3ˆEÿèû»ŠUÿYY‹€Ê‹ÁˆUÿƒá?ÁøkÉ0ˆUÔ‹…¨ÚFˆT(‹‹Áƒá?ÁøkÉ0öE‹…¨ÚFÆD)tÿ3èJüÿÿ‹ðY…öu(EþÆEþPÿuuÔƒìjY‹üÿ3ó¥èÆöÿÿƒÄ$…Àt‹ðÿ3è¦
Y‹Æéÿ‹‹Èƒà?ÁùkÐ0ŠEþ‹¨ÚFˆD)‹‹ÁÁøƒá?kÑ0‹…¨ÚF‹EÁè2D-$0D-öEÿHuöEt‹‹Áƒá?ÁøkÉ0‹…¨ÚF€L( ‹uعÀ‹Æ#Á;Á……öEtÿuøÿ<±EƒìEìæÿÿÿ‰uØuÔjY‹üPÿuó¥èRøÿÿ‹ÐƒÄ ƒúÿu2ÿH±EPèéŠþÿ‹‹Áƒá?ÁøkÉ0‹…¨ÚF€d(þÿ3è[¼Yéþÿÿ‹‹ÁÁøƒá?kÉ0‹…¨ÚF‰T3À_^[‹å]ËÿU‹ìjÿuÿuÿuÿuÿuèùóÿÿƒÄ]ËÿU‹ìƒ}u3À]ËMQŠA„Àuù+ÊSWYSèCªÿÿ‹øY…ÿu_[]ÃÿuSWèAƒÄ…Àu‹Çëç3ÀPPPPPè[Ì‹ÿU‹ìƒì‹E‹Mƒà?‹USÁùVWkø0‹¨ÚF‰Mð‹L8‰Mì‹M…Ét€:
u€L8(ë€d8(û
‹Ú‰Eø‹ò;ЃôBŠ€ù„Ç€ù
t
ˆFC@é«‹Mø;Ás€8
uƒÃÆ
ƒÀFé“Æ
FC@éˆC@j‰EôEèPjEÿPÿuìÿ(±E…Àt]ƒ}ètW‹Mð‹¨ÚFöD8(HtŠUÿ€ú
uˆë>Æ
‹¨ÚFˆT8*ë.€}ÿ
u
‹U;òuÆ
Fëjjÿjÿÿuèà:ƒÄ€}ÿ
tÆ
F‹U‹Eô‹Mø;Ù‚0ÿÿÿë‹Mð‹¨ÚFŠD9(¨@uˆD9(늈F+ò_‹Æ^[‹å]ËÿU‹ìƒì‹E‹Mƒà?SV‹uWÁùkø0‰Møj
‹¨ÚF[‹T8‰Uì‹U…ötf9u€L8(ë€d8(ûr‹Ú‰Eð‹ò;ЃWB·‰Môƒù‹Mø„"j
Zf9Uô‹Ut‹MôƒÃf‰ƒÆƒÀé÷;Eðs3j
Zf9‹Uuj
YƒÃf‰ƒÀƒÆéÓj
Zf‰ƒÃƒÆƒÀ鼃ÀƒÃj‰EôEèPjEüPÿuìÿ(±E…À„Šƒ}è„€‹Møj
‹¨ÚFöD8(HXt:f‹Uüf;Ðuf‰ëgj
Xf‰‹¨ÚFj
ˆT8*‹¨ÚFˆt8+‹¨ÚFZˆT8,ë;f9Eüu‹U;òuf‰ƒÆ‹Eôë)jjÿjþÿuè*9ƒÄj
Xf9Eüt	j
Xf‰ƒÆ‹Eô‹U;]ð‚Îþÿÿë ‹¨ÚFŠD9(¨@uˆD9(ë	f‹f‰ƒÆ+òƒæþ_‹Æ^[‹å]ËÿU‹ì‹E‹Èƒà?ÁùkÐ0ŠE‹¨ÚFˆD*]ËÿU‹ì‹Ef‹MV‹ðƒà?ÁþkÐ0‹µ¨ÚFˆL*‹µ¨ÚFˆl+‹µ¨ÚF^ÆD,
]ËÿU‹ìQQSÿu‹]Sÿuèrüÿÿ‹ÈƒÄ…É„'‹E‹Uƒà?ÁúWkø0‰Uü‹•¨ÚF‰Eø€|8)u‹ÁéûVsÿñŠ„ÀxFé›3Ò¶ÀBëƒúw;órNB¶€¸ÁFt銶Á¾€ÁF…ÀuèV†þÿÇ*é†@;ÂuòëS‹EøöD8(Ht5FˆL8*ƒúr‹MüŠF‹¨ÚFˆD9+ƒúu‹Eü‹…¨ÚFŠFˆD9,+òë÷Ú‹Âj™RPÿuè}7ƒÄÿu+óÿuVSjhéýÿh°E‹Ð…ÒuÿH±EPè…þÿYƒÈÿë‹Eü;Ö‹…¨ÚF•ÀÀ2D9-$0D9-^_[‹å]ËÿU‹ì‹EVW‹}‹÷G‹Ç;ús^OS·ƒût7ƒû
u ;Êsj
_f99‹}uj
[ƒÀf‰ƒÁƒÆëf‰ƒÀƒÆƒÁ;ÂrÃë‹E‹Èƒà?ÁùkÐ0‹¨ÚF€L([+÷ƒæþ_‹Æ^]Ãjh°¤FèXÚüÿ‹uƒþþuèî„þÿƒ èù„þÿÇ	éÞ…öˆ¾;5¨ÜFƒ²‹ÞÁû‹Æƒà?kÈ0‰Mà‹¨ÚF¶D(ƒà„¸ÿÿÿ;EÀƒÀu莄þÿƒ 虄þÿÇë|Vèû³YƒÏÿ‰}äƒeü‹¨ÚF‹MàöD(uèj„þÿÇ	èL„þÿƒ ëÿuÿuVèGƒÄ‹ø‰}äÇEüþÿÿÿè
‹Çë)‹u‹}äVèQ´YÃè„þÿƒ è„þÿÇ	èÛƒÈÿè˜ÙüÿËÿU‹ìƒì(S‹]Wƒûþuè݃þÿƒ èèƒþÿÇ	é‚…Ûˆb;¨ÜFƒV‹ÃÇEìƒà?‹ûÁÿkÐ0‰}ð‹½¨ÚF‰UèŠL(ˆMÿöÁ„%‹Mùÿÿÿvèuƒþÿƒ 考þÿÇé…É„ööEÿ…ìƒ}tÐV‹tŠD)ˆEÿ‰uä3ö¾Àƒètƒèu‹Á÷Шt‹E‰Mô‰Eø霋Uì‹Á÷ЄÂuèƒþÿ!0èƒþÿÇèÒ
éÂjXÑé‰Eô;Èr‹Á‰MôPè
j‹ðèÇjèÀƒÄ‰uø…öuèÌ‚þÿÇ讂þÿÇévÿuìjjSè44‹½¨ÚFƒÄ‹}è‰D ‹Æ‰T$‹×‹Mô‹]ð3ÿ‰EÜ‹¨ÚF‰]àöD(H‹]„΋]àŠ\*ˆ]þ€û
‹]„¸…É„°Š]þ‹}ìˆ@‹]I€}ÿ‰Eø‹Eð‰Mô‹…¨ÚFÆD*
„„‹Eð‹…¨ÚFŠD+ˆEþ<
to…Étk‹EøŠ]þj_ˆ@‹]I‰Eø‹Eð‰Mô‹…¨ÚFÆD+
ŠEÿ:Eìu>‹Eð‹…¨ÚFŠD,ˆEþ<
t)…Ét%‹EøŠ]þj_ˆ@‹]I‰Eø‹Eð‰Mô‹…¨ÚFÆD,
SèŸ3Y…Àtq‹Eð‹Mè‹…¨ÚFöD(€t]EØPÿuäÿ²E…ÀtL€}ÿuJjEàP‹EôÑèPÿuøÿuäÿ²E…ÀuÿH±EPèþÿYƒÏÿVèY‹Ç^éÖ‹Eà‹MˆG„Àtƒéuñ_…Éuˆ
èA|þÿj"ëÏ3ÀëÕ‹ÿU‹ì‹UV…Òt‹M…Ét
‹u…öuÆè|þÿj^‰0è׋Æ^]ÃW‹ú+òŠ>ˆG„Àtƒéuñ_…Éuˆ
èç{þÿj"ëÏ3öëÓ‹ÿU‹ì‹U¡ÂF÷Ò‹M#Ð#MщÂF]ÃèD…ÀtjèYöÂFt!jè°…ÀtjYÍ)jh@jècƒÄjè~³ÿÿÌ‹ÿU‹ìV‹u…ötjà3ÒX÷ö;Er4¯u…öuFëèËÍÿÿ…Àt VèHýY…ÀtVjÿ5øÞFÿ²E…ÀtÙë
è){þÿÇ3À^]ËÿU‹ì‹E‹M‹U‰‰H…Ét‰]ËÿU‹ì‹E‹M‹U‰‰H…Ét‰]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPè¯ÿÿÿƒÄÿuè
|þÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèÿÿÿƒÄÿuè~þÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèUÿÿÿƒÄÿuèÀ„þÿƒÄ‹å]ËÿU‹ìQjÿuQQ‹ÄÿuÿuPèCÿÿÿƒÄÿuè9‡þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèýþÿÿƒÄjèi„þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèÓþÿÿƒÄÿuè>„þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPè¨þÿÿƒÄÿuè{þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPè}þÿÿƒÄÿuèÛzþÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèRþÿÿƒÄÿu轃þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèBþÿÿƒÄjè®|þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèþÿÿƒÄjè†þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèîýÿÿƒÄÿuèä…þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèÃýÿÿƒÄÿuè.|þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPè˜ýÿÿƒÄjè|þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPènýÿÿƒÄÿuèÙ{þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèCýÿÿƒÄjè:…þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèýÿÿƒÄÿuè…þÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèÓüÿÿƒÄjè2yþÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPè©üÿÿƒÄjèyþÿƒÄ‹å]ËÿU‹ìQjj
QQ‹ÄjÿuPèüÿÿƒÄjèëþÿƒÄ‹å]ËÿU‹ì¡ÀF‹È3EƒáÓÈ]ËÿU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]ËÿU‹ìA‹Ð+уÂV3öÁê;ÁÀ÷Ð#Ât
‹UF‰I;ðuö^]‹ÁËÿU‹ìì(¡ÀF3ʼnEüƒ}ÿWt	ÿuèÝËüÿYjP…àüÿÿjPè8ÕüÿhÌ…0ýÿÿjPè%Õüÿ…àüÿÿƒÄ‰…Øüÿÿ…0ýÿÿ‰…Üüÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹E‰…èýÿÿE‰…ôýÿÿÇ…0ýÿÿ‹@ü‰…äýÿÿ‹E‰…àüÿÿ‹E‰…äüÿÿ‹E‰…ìüÿÿÿœ±Ej‹øÿ|±E…ØüÿÿPÿx±E…Àu…ÿuƒ}ÿt	ÿuèÖÊüÿY‹Mü3Í_èX¾üÿ‹å]ËÿU‹ìÿu¹ÌÙFèþÿÿ]áÀF‹È3ÌÙFƒáÓÈÃèd=…ÀuË€\ËÿU‹ìQ¡ÀF3ʼnEüVèB=…Àt5‹°\…öt+ÿuÿuÿuÿuÿu‹ÎÿвEÿÖ‹MüƒÄ3Í^èѽüÿ‹å]Ãÿu‹5ÀF‹Îÿu35ÌÙFƒáÿuÓÎÿuÿu…öu¾è.Ì3ÀPPPPPèyÿÿÿƒÄËÿV3öVVVVVèfÿÿÿƒÄVVVVVèÌjèk©…ÀtjYÍ)Vj¾ÀVjèÅýÿÿƒÄVÿ±EPÿ€±E^ËÿU‹ìV‹5ÀFWÿu‹þ3=ÌÙFèBýÿÿYƒæ£ÌÙF‹ÎÓÏ‹Ç_^]ËÿU‹ìè¿;‹M‹Ð‹‚\‰Š\]ËÿU‹ìÿuè`÷ÿÿY]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]ƒ!‹ÁËÿV‹ñÿ6è)÷ÿÿƒ&Y^Ãjhð¤Fè|Éüÿ3ÿ‹u‰>jè¤+Y‰}üEäPèƒY‹‰…Àt‰x‰x‰8‰xƒHÿÇEüþÿÿÿè‹Æè|ÉüÿËujè©+YËÿU‹ì‹E3ɉ‹E‰H‹E‰H‹EƒHÿ‹E‰H‹E‰H‹E‰H‹EƒÀ‡]Ë3ÒƒÀ‡Ëƒ!ËÿU‹ìQS‹ÐFVW‹=ÐFƒÇƒÃýŸ‰]üëA‹7…ötS‹FÁè
¨u.VèÿBýÿYV» ‹‹ÈËð±
uö‹]üÁè
öШuVèìBýÿYƒÇ;ûu»‹Eƒ _^[‹å]ËE‰0ëòj8jè”÷ÿÿj‰èëõÿÿ‹ƒÄ…ÀtуHÿ‹jh ƒÀ Pèõ‹7¹ Fð	VèxBýÿYë²ÿ1ènBýÿYËÿV‹ñÿ6è¡õÿÿƒ&Y^ËV¾ ƒÂ‹‹ÈÎð±
uöÁè
÷Ѓà^ËÿU‹ìƒì3ÀS‹]VW}ð«uð««‹û¥¥¥¡°ÙF‹u‰CëF€> túŠ3É tú„íu€>…œÆCé£jhtFVèÌlþÿƒÄ…Àuj ƒÆXëF8tû€>=umF8tûjhxFVèúÊÿÿƒÄ…ÀuƒÆë?jh€FVèÛÊÿÿƒÄ…ÀuƒÆë jhˆFVè¼ÊÿÿƒÄ…ÀuƒÆëF€> túé[ÿÿÿèwpþÿÇè7ûÿÿ_^‹Ã[‹å]ËÿU‹ìƒì3ÀS‹]VW}ð«uðjYj ««‹û¥¥¥¡°ÙF‹u‰C_ëñf9>tù·3Òƒøat!ƒørtƒøw…ÛÇë‰ÇCë	Ç	‰KñˆUý2íˆUüˆUþ±ˆmÿ·f…À„݃øSpt\+Ç„·ƒètBƒèt4ƒèt'ƒè
tƒè…uŠmÿ„Òuƒë4€±éSè©ësµˆmÿ2ÉësEüPSè€Yë]Šmÿ„Òuè	;²ˆUþŠÊëTƒèTt@ƒèt3ƒèt"ƒètƒè…Sè}ë&EýPSèëºEýPSèìë®SèÄëSèŠUþYŠÈŠmÿ3À„É•À4F„É…ÿÿÿëŠmÿ„ítƒÆf9>tø„íu3Àf9…¦ÆCé­jhFVèñÖƒÄ…À……ƒÆëƒÆf9>tøfƒ>=urƒÆf9>tøjh˜FVèñ ƒÄ…ÀuƒÆ
ëAjh¤FVèÒ ƒÄ…ÀuƒÆë"jh´FVè³ ƒÄ…ÀuƒÆëƒÆf9>tøéOÿÿÿè3nþÿÇèóøÿÿ_^‹Ã[‹å]ËÿU‹ìƒìVWÿuEäPètûÿÿ‹ð}ðYY¥¥¥€}ø_^u3ÀëUh€ÿuEüÿuðÿuPècßÿÿƒÄ…ÀuÞ‹EÿÐFƒÀ‹Môð	‹E3ɉH‹E‰H‹E‰H‹E‰‹M‹Eü‰A‹E‹å]ËÿU‹ìƒìVWÿuEäPè!ýÿÿ‹ð}ðYY¥¥¥€}ø_^u3ÀëUh€ÿuEüÿuðÿuPèâÿÿƒÄ…ÀuÞ‹EÿÐFƒÀ‹Môð	‹E3ɉH‹E‰H‹E‰H‹E‰‹M‹Eü‰A‹E‹å]ËÿU‹ì‹Eÿ0‹Eÿuÿ0èÈhþÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿuÿ0èÕƒÄ]ËÿU‹ì‹Eÿ0‹Eÿuÿ0èéÆÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿuÿ0èÍÆÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿuÿ0è±ÆÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿuÿ0è΃Ä]ËÿU‹ì‹Eÿ0‹Eÿuÿ0貃Ä]ËÿU‹ì‹Eÿ0‹Eÿuÿ0è–ƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0è™ÝÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èáÿÿƒÄ]ËÿU‹ì‹M‹¨@t2À]ÃÈ@‰°]ËÿU‹ì‹E€°]ËÿU‹ì‹E€8t2À]ËMÆ°ƒ	]ËÿU‹ì‹E€8t2À]ËMÆ°ƒ	 ]ËÿU‹ì‹Mº‹…Ât2À]É°]ËÿU‹ì‹M‹©Àt2À]Ã
€‰°]ËÿU‹ì‹E€8t2À]ËMÆ°I]ËÿU‹ì‹E€8t2À]ËMÆ°aÿ÷ÿÿ]ËÿU‹ì‹E€8t2À]ËUÆ‹¨uð‹JƒàþƒÈƒáüƒÉ‰‰J°]ËÿU‹ì‹M‹©Àt2À]Ã
@‰°]ËÿU‹ì]ézüÿÿ‹ÿU‹ì]éôüÿÿ‹ÿU‹ìQ¡ÀF3ʼnEüV‹5ÀF‹Î35 ÚFƒájjÿuÓ΋ÎÿвEÿÖ‹Mü3Í^躲üÿ‹å]¡ÀFƒàj Y+È3ÀÓÈ3ÀFÃjh¥Fèn¿üÿƒeä‹Eÿ0è–!Yƒeü‹E‹ÿ0è—Y£ ÚFjh¸ÆCÿ8²E‹ð¡ÀFƒàj Y+È3ÀÓÈ3ÀF£ ÚF‰uäÇEüþÿÿÿè
‹ÆèN¿üÿÂ‹uä‹Mÿ1èv!YËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèXÿÿÿ‹å]ËÿU‹ì¡ÀF‹È3EƒáÓÈ]ËÿU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]ËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‹‰‹Á]¸¸ÆCÃÿ1èŽ YËÿ0è•ÿÿÿYjh¸ÆC£ ÚFÿ8²E‹ÀFƒâj Y+Ê3ÒÓÊ3ÀF‰ ÚFÃÿ1è’ YËÿU‹ìÿuèMÿÿÿYjh¸ÆC£ ÚFÿ8²E‹ÀFƒâj Y+Ê3ÒÓÊ3ÀF‰ ÚF]ÃÈÿÃhl	Fhh	Fhl	FjèNƒÄÃh„	Fh|	Fh„	Fjè4ƒÄÃhœ	Fh”	Fhœ	FjèƒÄÃh¸	Fh°	FhXäEjèƒÄÃhÀ	Fh¸	FhläEjèæƒÄÃhÈ	FhÀ	Fh|äEjè̃ÄÃhÐ	FhÈ	FhäEj貃ÄÃhØ	FhÐ	FhØ	Fj蘃ÄÃhð	Fhè	Fhð	Fjè~ƒÄÃh
Fh
Fh
Fj	èdƒÄÃh$
Fh
Fh$
Fj
èJƒÄÃhH
Fh@
FhH
Fjè0ƒÄÃhp
Fhh
Fhp
FjèƒÄÃhŒ
Fh„
FhŒ
Fj
èüƒÄÃh¤
Fhœ
Fh¤
FjèâƒÄÃhÀ
Fh¼
FhÀ
FjèȃÄÃhè
Fhà
Fhè
Fj讃ÄÃhFhø
FhFj蔃ÄÃh$FhFh$FjèzƒÄÃhHFh@FhHFjè`ƒÄÃhhFh`Fh¤äEjèFƒÄÃhpFhhFhpFjè,ƒÄÃh¤FhœFh¤FjèƒÄÃhŒFh„FhŒFjèøƒÄÃhÀFh¸FhÀFjèÞƒÄÃhÜFhÔFhÜFjèăÄÃhøFhðFhøFj誃ÄÃhFhFhFjèƒÄÃhFhFhFjèvƒÄÃh0Fh,Fh0Fjè\ƒÄÃhHFh@FhHFjèBƒÄÃhhFh`FhhFjè(ƒÄËÿU‹ìV‹uëÿ6è®Y…Àu
ƒÆ;uuì3À^]ËÿU‹ì‹ESVW… ÚF‹‹ÀFƒÏÿ‹Ê‹òƒá3ðÓÎ;÷ti…öt‹Æëc‹u;utÿ6èYY…Àu/ƒÆ;uuì‹ÀF3À…Àt)ÿuPÿ€°E‹ð…ötVè@ÈüÿY‡빋ÀFëÙ‹ÀF‹Âj ƒàY+ÈÓÏ3ú‡;3À_^[]ËÿU‹ì‹EW<…ÐÙF‹…ÉtA÷ØÀ#ÁëWS‹…ÈFVhjSÿÔ±E‹ð…öu'ÿH±EƒøWu
VVSÿÔ±E‹ðë3ö…öu	ƒÈÿ‡3Àë‹Æ‡…ÀtVÿ°E‹Æ^[_]ËÿU‹ìV‹uëÿ6èsÿÿÿY…Àu
ƒÆ;uuì3À^…Àu]ÃÿuPÿ€°E]ËÿU‹ìhjÿuÿÔ±E…ÀuÿH±EƒøWujjÿuÿÔ±E]Ã3À]ËÿU‹ìQ¡ÀF3ʼnEüVhl	Fhh	Fhl	FjèWþÿÿ‹ðƒÄ…öt‹ÎÿвEÿÖë3À@‹Mü3Í^èÀ«üÿ‹å]ËÿU‹ìQ¡ÀF3ʼnEüVèÐúÿÿ‹ð…öt'ÿu(‹Îÿu$ÿu ÿuÿuÿuÿuÿuÿuÿвEÿÖë ÿuÿuÿuÿuÿujÿuè¹Pÿ$²E‹Mü3Í^èN«üÿ‹å]Â$‹ÿU‹ìQQ¡ÀF3ʼnEüVhœ	Fh”	Fhœ	Fjè”ýÿÿ‹ðƒÄ…ötÿu‹ÎÿuÿuÿuÿвEÿÖëE‰EøEøPjèÖøÿÿYY‹Mü3Í^èáªüÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVh¸	Fh°	FhXäEjè(ýÿÿ‹ðƒÄ…ötÿu‹ÎÿвEÿÖëÿıE‹Mü3Í^苪üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhÀ	Fh¸	FhläEjèÒüÿÿƒÄ‹ðÿu…öt‹ÎÿвEÿÖëÿбE‹Mü3Í^è5ªüÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhÈ	FhÀ	Fh|äEjè|üÿÿƒÄ‹ðÿu…öt‹ÎÿвEÿÖëÿȱE‹Mü3Í^èß©üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhÐ	FhÈ	FhäEjè&üÿÿƒÄ‹ðÿuÿu…öt‹ÎÿвEÿÖëÿ̱E‹Mü3Í^膩üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVh
Fh
Fh
Fj	èÍûÿÿ‹ðƒÄ…öt!ÿu ‹ÎÿuÿuÿuÿuÿuÿuÿвEÿÖë ÿuÿuÿuÿuÿujÿuèoPÿ²E‹Mü3Í^è©üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVh$
Fh
Fh$
Fj
èKûÿÿ‹ðƒÄ…öt‹ÎÿвEÿÖ‹Mü3Í^蹨üÿ‹å]Ãè†äÿÿÌ‹ÿU‹ìQ¡ÀF3ʼnEüVhH
Fh@
FhH
Fjèüúÿÿ‹ðƒÄ…ötÿu‹ÎÿuÿuÿuÿвEÿÖë
jxÿX±E3À‹Mü3Í^èR¨üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhŒ
Fh„
FhŒ
Fj
è™úÿÿƒÄ‹ðÿuÿuÿu…ötÿu‹ÎÿвEÿÖëjÿuèSPÿ,²E‹Mü3Í^èè§üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhÀ
Fh¼
FhÀ
Fjè/úÿÿƒÄ‹ðÿu…öt‹ÎÿвEÿÖëÿ”±E‹Mü3Í^è’§üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhè
Fhà
Fhè
FjèÙùÿÿƒÄ‹ðÿuÿuÿuÿuÿu…ötÿu‹ÎÿвEÿÖëjÿuèPÿ ²E‹Mü3Í^è"§üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhFhø
FhFjèiùÿÿ‹ðƒÄ…ötÿu‹ÎÿuÿвEÿÖëjÿuÿuÿ4²EPè-‹Mü3Í^軦üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhHFh@FhHFjèùÿÿ‹ðƒÄ…öt!ÿu‹ÎÿuÿвEÿÖ‹Mü3Í^èj¦üÿ‹å]Âè5âÿÿÌ‹ÿU‹ìQ¡ÀF3ʼnEüVhhFh`Fh¤äEjè«øÿÿ‹ðƒÄ…ötÿu‹ÎÿuÿuÿвEÿÖëÿuÿuÿÀ±E‹Mü3Í^è¦üÿ‹å]Â‹ÿU‹ìQ¡ÀF3ʼnEüVhpFhhFhpFjèIøÿÿ‹ðƒÄ…ötÿu‹ÎÿвEÿÖëjjÿuè
Pÿ0²E‹Mü3Í^蟥üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVh¤FhœFh¤Fjèæ÷ÿÿ‹ðƒÄ…ötÿu‹ÎÿuÿuÿuÿвEÿÖëÿuÿuÿuèTƒÄ‹Mü3Í^è5¥üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVhŒFh„FhŒFjè|÷ÿÿ‹ðƒÄ…öt'ÿu(‹Îÿu$ÿu ÿuÿuÿuÿuÿuÿuÿвEÿÖë ÿuÿuÿuÿuÿujÿuèPÿ(²E‹Mü3Í^è­¤üÿ‹å]Â$‹ÿU‹ìQ¡ÀF3ʼnEüVhÀFh¸FhÀFjèôöÿÿ‹ðƒÄ…ötÿu‹ÎÿuÿвEÿÖë	ÿuèY‹Mü3Í^èQ¤üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVèÏõÿÿ‹ð…öt$ÿu‹ÎÿuÿuÿвEÿÖ‹Mü3Í^è¤üÿ‹å]ÂèÜßÿÿÌ‹ÿU‹ìQ¡ÀF3ʼnEüVè£õÿÿ‹ð…öt'ÿu‹ÎÿuÿuÿuÿвEÿÖ‹Mü3Í^èÈ£üÿ‹å]Âè“ßÿÿÌ‹ÿU‹ìQ¡ÀF3ʼnEüVètõÿÿ‹ð…öt'ÿu‹ÎÿuÿuÿuÿвEÿÖ‹Mü3Í^è£üÿ‹å]ÂèJßÿÿÌ‹ÿU‹ìQ¡ÀF3ʼnEüVhFhFhFjèÀõÿÿ‹ðƒÄ…ötÿu‹ÎÿвEÿÖë3À‹Mü3Í^è'£üÿ‹å]‹ÿU‹ìQ¡ÀF3ʼnEüVh0Fh,Fh0Fjènõÿÿ‹ðƒÄ…öt
‹ÎÿвEÿÖ‹Mü3Í^èÜ¢üÿ‹å]ËÿU‹ìQ¡ÀF3ʼnEüVhhFh`FhhFjè%õÿÿ‹ðƒÄ…öt!ÿu‹ÎÿuÿвEÿÖ‹Mü3Í^è¢üÿ‹å]ÂèXÞÿÿÌ‹ÿU‹ìQ¡ÀF3ʼnEüVhHFh@FhHFjèÎôÿÿ‹ðƒÄ…ötÿu‹ÎÿвEÿÖë3À‹Mü3Í^è5¢üÿ‹å]ÂèÞóÿÿ…Àt
èïóÿÿ…Àt3À@Ã3ÀÃè;ñÿÿ÷ØÀ÷ØÃèŸóÿÿ÷ØÀ÷ØËÿU‹ìQ¡ÀF3ʼnEüVhØ	FhÐ	FhØ	FjèKôÿÿ‹ðƒÄ…öt@W‹ÎÿвEÿÖ‹ø…ÿt.hp
Fhh
Fhp
Fjèôÿÿ‹ðƒÄ…öu‹ÇëW‹ÎÿвEÿÖ_‹Mü3Í^胡üÿ‹å]áÀFWj ƒà¿ ÚFY+È3ÀÓÈ3ÀFj Yó«°_ËÿU‹ìƒì¡ÀF3ʼnEüVh¤
Fhœ
Fh¤
Fjè¤óÿÿ‹ðƒÄ…öu°ëaSh$FhFh$Fjè€óÿÿ‹ØƒÄ…Ûu°ë<‹ÎÿвEÿÖ‹È…Ét#W3À}ð«jj««EðPjQ‹ËÿвEÿÓ_…Àu2ÀëŠEø$[‹Mü3Í^è· üÿ‹å]ËÿU‹ìQQ¡ÀF3ʼnEü‹
¤ÚF…Ét
3Àƒù”ÀëTVhð	Fhè	Fhð	Fjèëòÿÿ‹ðƒÄ…öt'ƒeøEøjP‹ÎÿвEÿÖƒøzu3ɺ¤ÚFA‡
°ëjX¹¤ÚF‡2À^‹Mü3Íè0 üÿ‹å]ËÿU‹ì€}u'V¾ÐÙFƒ>tƒ>ÿtÿ6ÿ°Eƒ&ƒÆþ ÚFuà^°]Ãjh0¥FèȬüÿƒeäjèóYƒeüj^‰uà;5ÐFtX¡ÐF‹°…ÀtI‹@Áè
¨t¡ÐFÿ4°èµ'ýÿYƒøÿtÿEä¡ÐF‹°ƒÀ Pÿ¼±E¡ÐFÿ4°èúÙÿÿY¡ÐFƒ$°FëÇEüþÿÿÿè	‹Eä脬üÿÃjè´YËÿU‹ì‹E‹H‰‹Eƒ`]ËÿU‹ì‹‹@#E+E÷ØÀ@]‹ÿU‹ì‹V‹uƒÂ÷Ö‹‹È#Îð±
uö#E÷Ø^À÷Ø]‹ÿU‹ì‹MVq‹$<t3ÀëK‹¨Àtö‹AW‹9+ø‰ƒa…ÿ~0WPQèYPèT\ƒÄ;øtjXð	ƒÈÿë‹Áè¨tjýXð!3À_^]ËÿU‹ìV‹u…öu	Vè=Yë.Vè~ÿÿÿY…ÀtƒÈÿë‹FÁè¨tVè«Pè
YY…Àuß3À^]ÃjèYÃjhp¥Fè«üÿƒeäƒeÜjè@
Yƒeü‹5ÐF¡ÐF†‰EÔ‹]‰uà;ðtt‹>‰}Ø…ÿtVWè5%ýÿYÇEü‹GÁè
¨t2ƒûuWèIÿÿÿYƒøÿt!ÿEäë…Ûu‹GÑè¨tWè+ÿÿÿYƒøÿu	E܃eüè‹EÔƒÆë•‹]‹uàÿuØèæ$ýÿYÃÇEüþÿÿÿèƒû‹Eät‹EÜè ªüÿË]jèÍYÃjhP¥FèAªüÿ‹u…öu	VèÿÿÿYë)ƒeäVè$ýÿYƒeüVè§þÿÿY‹ø‰}äÇEüþÿÿÿè‹ÇèIªüÿËu‹}äVèd$ýÿYË‹@ÁèƒàËÿU‹ìV‹uW~‹Áè
¨t$‹Áè¨tÿvè\×ÿÿY¸¿þÿÿð!3À‰F‰‰F_^]ËÿU‹ì‹EƒètƒètjôƒèëjõëjöX]ËÿU‹ìƒìHE¸Pÿ ±Efƒ}ê„•‹Eì…À„ŠSV‹0X3‰Eü¸ ;ð|‹ðVèЂ¡¨ÜFY;ð~‹ðW3ÿ…ötV‹Eü‹ƒùÿt@ƒùþt;ŠöÂt4öÂuQÿì±E…Àt!‹Ç‹Ïƒà?ÁùkÐ0‹Eü¨ÚF‹‰BŠˆB(‹EüGƒÀC‰Eü;þu­_^[‹å]ËÿSVW3ÿ‹Ç‹Ïƒà?Áùkð04¨ÚFƒ~ÿtƒ~þt€N(€ë{‹ÇÆF(ƒètƒètjôƒèëjõëjöXPÿ±E‹Øƒûÿt
…Ût	Sÿì±Eë3À…Àt%ÿ‰^ƒøu€N(@ë)ƒøu$€N(ë€N(@ÇFþÿÿÿ¡ÐF…Àt
‹¸Ç@þÿÿÿGƒÿ…Uÿÿÿ_^[Ãjh˜¥Fè¨üÿjè?
Y3Ûˆ]ç‰]üSèˆY…Àuèhþÿÿèÿÿÿ³ˆ]çÇEüþÿÿÿèŠÃè¨üÿÊ]çjèF
YËÿV3ö‹†¨ÚF…ÀtPè
ƒ¦¨ÚFYƒÆþrÝ°^Ë‹@ËÿU‹ì‹E…Àuè9RþÿÇèùÜÿÿƒÈÿ]Ë@]ËÿU‹ì‹UV…Òt‹M…Ét‹u…öu3Àf‰èÿQþÿj^‰0èÀÜÿÿ‹Æ^]ÃW‹ú+ò·>f‰f…Àtƒéuì3À_…ÉuÝf‰èÈQþÿj"ëÇ‹ÿU‹ì‹UV…Òt‹M…Ét‹u…öu3Àf‰èŸQþÿj^‰0è`Üÿÿ‹Æ^]ÃW‹ú+ò·>f‰f…Àtƒéuì_…Éu3Àf‰èhQþÿj"ëÇ3öëË‹ÿU‹ì¡ÏFVWƒø|z‹u‹Öƒâj X+Â÷ÚÒ#ЋE;Âs‹Ð<2‹Î;÷t
€9tA;Ïuö+Î;Êu>‹øÎ+ú‹Çƒà+øÅôWÉùëÅõtÅý×À…ÀuƒÁ ;Ïuí‹EÆë€9tA;Èuö+ÎÅøw‹Áé—ƒø|x‹u‹ÖƒâjX+Â÷ÚÒ#ЋE;Âs‹Ð<2‹Î;÷t
€9tA;Ïuö+Î;Êu¿‹øÎ+úfïɋǃà+øùë(ftÁf×À…ÀuƒÁ;Ïuê‹EÆë€9tA;Èuö+Îé|ÿÿÿ‹M‹Á‹UÑ;Êt
€8t@;Âuö+Á_^]ËÿU‹ìQ¡ÏF‹MVWƒøŒ¶öÁt#‹E‹ÑA;Èt3ÿf9:tƒÂ;Ðuô+ÑÑú釋ñƒæj X+Æ÷Þö#ð‹EÑî;Æs‹ðq3ÿ‰Uü‹Ñ;Müt
f9:tƒÂ;Uüuó+ÑÑú;ÖuHQ‹È+΋Áƒà+ÈÅôWÉJëÅõuÅý×À…ÀuƒÂ ;Ñuí‹E‹MHëf9:tƒÂ;Ñuô+ÐÑúÅøw‹Âé݃øŒ¶öÁt'‹E‹ÑA;È„Kÿÿÿ3ÿf9:„@ÿÿÿƒÂ;Ðuðé4ÿÿÿ‹ñƒæjX+Æ÷Þö#ð‹EÑî;Æs‹ðq3ÿ‰Uü‹Ñ;Müt
f9:tƒÂ;Uüuó+ÑÑú;Öu…QfïÉ‹È+΋Áƒà+ÈJë(fuÁf×À…ÀuƒÂ;Ñuê‹E‹MHëf9:tƒÂ;Ñuô+Ðé¬þÿÿ‹EA‹Á;Êt3ÿf98tƒÀ;Âuô+ÁÑø_^‹å]ËÿU‹ì‹M‹Á‹UÑ;Êt
€8t@;Âuö+Á]ËÿU‹ì‹M‹EA‹Á;Êt
fƒ8tƒÀ;Âuó+ÁÑø]ËÿU‹ìV‹u‹ÖW‹}ƒâj X+Â÷ÚÒ#Ð;ús‹×2‹Æ;ñt
€8t@;Áuö+Æ;Âu?+ú0‹Çƒà+øÅôWÉùëÅõtÅý×À…ÀuƒÁ ;Ïuí‹EÆë€9tA;Èuö+ÎÅøw‹Á_^]ËÿU‹ì‹MWöÁt#‹EA‹Á;Êt3ÿf98tƒÀ;Âuô+ÁÑøé‡V‹ñƒæj X+Æ÷Þö#ð‹EÑî;Æs‹ðq3ÿ‹Á;Êtf98tƒÀ;Âuô+ÁÑø;ÆuKA‹M+΋Áƒà+ÈÅôWÉJëÅõuÅý×À…ÀuƒÂ ;Ñuí‹E‹MHëf9:tƒÂ;Ñuô+ÐÑúÅøw‹Â^_]ËÿU‹ìV‹u‹ÖW‹}ƒâjX+Â÷ÚÒ#Ð;ús‹×2‹Æ;ñt
€8t@;Áuö+Æ;Âu?+ú0‹ÇfïɃà+øùë(Áftf×À…ÀuƒÁ;Ïuê‹EÆë€9tA;Èuö+΋Á_^]ËÿU‹ì‹MWöÁt#‹EA‹Á;Êt3ÿf98tƒÀ;Âuô+ÁÑøé‡V‹ñƒæjX+Æ÷Þö#ð‹EÑî;Æs‹ðq3ÿ‹Á;Êtf98tƒÀ;Âuô+ÁÑø;ÆuKAfïÉ‹M+΋Áƒà+ÈJë(Áfuf×À…ÀuƒÂ;Ñuê‹E‹MHëf9:tƒÂ;Ñuô+ÐÑú‹Â^_]ÃÅøwÃÃÅýtÁÃÅýuÁÃftÁÃfuÁÃÅý×ÀÃf×ÀÃÅüWÀÃfïÀËÿU‹ì¡ÏFVWƒø||‹u‹Öƒâj X+Â÷ÚÒ#ЋE;Âs‹Ð<2‹Î;÷t
€9tA;Ïuö+Î;Ê…׋øÎ+ú‹Çƒà+øÅôWÉùëÅõtÅý×À…ÀuƒÁ ;Ïuí‹EÆë€9tA;Èuö+ÎÅøw锃ø|u‹u‹ÖƒâjX+Â÷ÚÒ#ЋE;Âs‹Ð<2‹Î;÷t
€9tA;Ïuö+Î;ÊuZ‹øÎ+úfïɋǃà+øùë(ftÁf×À…ÀuƒÁ;Ïuê‹EÆë€9tA;Èuö+Îë‹U‹Ê‹EÂ;Ðt
€9tA;Èuö+Ê_‹Á^]ËÿU‹ìQ¡ÏF‹MVWƒøŒ¼öÁt'‹E‹ÑA;È„}3ÿf9:„rƒÂ;Ðuðéf‹ñƒæj X+Æ÷Þö#ð‹EÑî;Æs‹ðq3ÿ‰Uü‹Ñ;Müt
f9:tƒÂ;Uüuó+ÑÑú;Ö…'Q‹È+΋Áƒà+ÈÅôWÉJëÅõuÅý×À…ÀuƒÂ ;Ñuí‹E‹MHëf9:tƒÂ;Ñuô+ÐÑúÅøwéÚƒøŒ³öÁt'‹E‹ÑA;È„¸3ÿf9:„­ƒÂ;Ðuðé¡‹ñƒæjX+Æ÷Þö#ð‹EÑî;Æs‹ðq3ÿ‰Uü‹Ñ;Müt
f9:tƒÂ;Uüuó+ÑÑú;ÖufQfïÉ‹È+΋Áƒà+ÈJë(fuÁf×À…ÀuƒÂ;Ñuê‹E‹MHëf9:tƒÂ;Ñuô+Ðë‹E‹ÑA;Èt3ÿf9:tƒÂ;Ðuô+ÑÑú_‹Â^‹å]ËÿVW¿°ÜF3öjh Wè·êÿÿ…ÀtÿèÝFƒÆƒÇþ8rÛ°ë
jèY2À_^ËÿU‹ìkE°ÜFPÿ´±E]ËÿV‹5èÝF…öt kÆW¸˜ÜFWÿ¼±Eÿ
èÝFƒïƒîuë_°^ËÿU‹ìkE°ÜFPÿ¸±E]ÃjèšÿÿÿYÃjèÙÿÿÿYËÿU‹ìƒìS‹]…ÛuèúGþÿǃÈÿë|VWj=S‹ûèMŸüÿ‰EôYY…ÀtN;ÃtJ€x‹5„ÙF”ÀˆEÿ;5ÙFuVè!‹ðŠEÿY‰5„ÙF3Û…ö…Ž9]t/9ˆÙFt'èÝyÿÿ…Àunè‡GþÿǃËÿWè]ÊÿÿY_‹Ã^[‹å]ÄÀt3ÛëèjjèâËÿÿS£„ÙFè7Êÿÿ‹5„ÙFƒÄ…ötÄ9ˆÙFu%jjè¹ËÿÿS£ˆÙFèÊÿÿƒÄ9ˆÙFt‹5„ÙF…öt“‹Eô‹Ï+ÁPQèÞ‰EøYY…ÀxH9tDÿ4†èÖÉÿÿY‹Mø8]ÿu‹E‹û‰Žë‹DŽ‰ŽA9ŽuójQVè¥ÆS‹ðè¥ÉÿÿƒÄ‹Ç…ötXëP8]ÿ….ÿÿÿ÷؉EøH;È‚ÿÿÿùÿÿÿ?ƒÿÿÿjQVèdÆS‹ðèdÉÿÿƒÄ…ö„óþÿÿ‹Mø‹û‹E‰Ž‰\Ž‰5„ÙF9]„Øþÿÿ‹ÈQŠA„Àuù+ÊjAP‰Eøè¿Êÿÿ‹ðYY…ötGÿuÿuøVèíÉÿÿƒÄ…Àu@‹Mô‹Æ+EAȶEÿ÷ØÀ÷ЈYÿ#ÁPVÿ<²E…ÀuèôEþÿƒËÿÇ*VèÊÈÿÿYéaþÿÿSSSSSèÍÐÿÿÌ‹ÿU‹ìƒìS‹]…Ûuè¿EþÿǃÈÿë}VWj=S‹ûèj‚‰EôYY…ÀtO;ÃtK‹5ˆÙF3Ûf9X”ÁˆMÿ;5ŒÙFuVè•YŠMÿ‹ð‰5ˆÙF…ö…‡¡„ÙF9]t+…Àt'è¦wÿÿ…ÀufèKEþÿǃËÿWè!ÈÿÿY_‹Ã^[‹å]ÄÉuì…Àu)jjè¦ÉÿÿS£„ÙFèûÇÿÿƒÄ9„ÙFtÆ‹5ˆÙF…öu!jjè}ÉÿÿS£ˆÙFèÒÇÿÿƒÄ‹5ˆÙF…öt›‹Mô‹Ç+ÈÑùQP‰Môèù‰EøYY…ÀxH9tDÿ4†èÇÿÿY‹Mø8]ÿu‹E‹û‰Žë‹DŽ‰ŽA9ŽuójQVèlÄS‹ðèlÇÿÿƒÄ‹Ç…ötXëP8]ÿ…1ÿÿÿ÷؉EøH;È‚ÿÿÿùÿÿÿ?ƒÿÿÿjQVè+ÄS‹ðè+ÇÿÿƒÄ…ö„öþÿÿ‹Mø‹û‹E‰Ž‰\Ž‰5ˆÙF9]„Ûþÿÿ‹ÈQf‹ƒÁf;Ãuõ+ÊÑùjAP‰Eøè€Èÿÿ‹ðYY…ötE‹EPÿuøVè"òÿÿƒÄ…Àu=‹MôANf‰Aþ¶Eÿ÷ØÀ÷Ð#ÁPVÿ@²E…Àuè·CþÿƒËÿÇ*VèÆÿÿYé`þÿÿSSSSSèÎÿÿÌ‹ÿU‹ìQW‹}…ÿu3Àé…3É‹Ç9t	@Aƒ8u÷VAjPèêÇÿÿ‹ðYY…öteƒ?tPS‹Þ+ß‹QŠA„Àuù+ÊjAP‰Eüè¼Çÿÿj‰;èÆÿÿƒÄƒ<;t,ÿ7ÿuüÿ4;èÞÆÿÿƒÄ…ÀuƒÇ9u¶[jèæÅÿÿY‹Æ^_‹å]Ãè5Çÿÿ3ÀPPPPPèßÍÿÿÌ‹ÿU‹ìQQW‹}…ÿu3Àé‘S3ۋNjˉ]üV9t@A9uøAjPè3Çÿÿ‹ðYY…ötl9tX‹Þ+ß‹Qf‹ƒÁf;Eüuô+ÊÑùjAP‰EøèÇÿÿ‰;3ÀPèUÅÿÿƒÄƒ<;t-ÿ7ÿuøÿ4;è–ðÿÿƒÄ…ÀuƒÇ9u®3ÛSè)ÅÿÿY‹Æ^[_‹å]ÃèwÆÿÿ3ÀPPPPPè!ÍÿÿÌ‹ÿU‹ìSVW‹=„ÙF‹÷ƒ?t*‹]Sÿ6ÿuèüƒÄ…Àu
‹Š<=t„ÀtƒÆƒ>uÙ+÷Áþ÷Þ_‹Æ^[]Ã+÷Áþëò‹ÿU‹ìSVW‹=ˆÙF‹÷ƒ?t-‹]Sÿ6ÿuèÎùƒÄ…Àu‹·Xƒø=tf…ÀtƒÆƒ>uÖ+÷Áþ÷Þ_‹Æ^[]Ã+÷ÁþëòéÅsÿÿéÅsÿÿ‹ÿU‹ì‹Eÿ0‹Eÿ0ÿ<²E]ËÿU‹ì‹Eÿ0‹Eÿ0ÿ@²E]ËÿU‹ì‹E¾‹EQÿ0虘üÿYY]ËÿU‹ì‹Ef¾·È‹EQÿ0èÓ}YY]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0è»ÄÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èïÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èÄÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èÖîÿÿƒÄ]ËÿU‹ì‹E‹PŠ@„Éuù+Â]ËÿU‹ì‹E‹Pf‹ƒÀf…Éuõ+ÂÑø]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0è`úƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èEøƒÄ]ø„ÙFøˆÙFøÙFøŒÙFø„ÙFøˆÙFËÿU‹ì]é^—üÿ‹ÿU‹ì]é«|‹ÿU‹ì]éÏ÷ÿÿ‹ÿU‹ì]éÿùÿÿ‹ÿU‹ìW‹}…ÿuÿuèÝÂÿÿYë$V‹u…öu	Wè’ÂÿÿYëƒþàv%è ?þÿÇ3À^_]Ãè’ÿÿ…ÀtæVè…ÁY…ÀtÛVWjÿ5øÞFÿD²E…ÀtØëÒ‹ÿU‹ìÿuèBÂÿÿY]ÂjhØ¥Fè–”üÿ‹Eÿ0èÂöÿÿYƒeü‹M‹A‹ÿ0‹ÿ0èÃYYÇEüþÿÿÿè觔üÿÂ‹Eÿ0èÒöÿÿYÃjhø¥FèF”üÿ‹Eÿ0èröÿÿYƒeü‹E‹‹‹HH…ÉtƒÈÿðÁuù°ÆFtQè­ÁÿÿYÇEüþÿÿÿèèF”üÿÂ‹Eÿ0èqöÿÿYÃjh¦Fèå“üÿ‹Eÿ0èöÿÿYƒeüj‹E‹ÿ0èYYÇEüþÿÿÿèèû“üÿÂ‹Eÿ0è&öÿÿYÃjh¸¥Fèš“üÿ‹Eÿ0èÆõÿÿYƒeü‹E‹‹‹@HðÿÇEüþÿÿÿè賓üÿÂ‹Eÿ0èÞõÿÿYËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèèþÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèpþÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèùþÿÿ‹å]ËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèÿÿÿ‹å]ËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹E‰A‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿH±E‰‹Æ^ËÿV‹ñÿ6èV¿ÿÿƒ&Y^Ãÿ1ÿX±EÃ3À9•ÀÃÿ1èôÿÿYÃÿ1èÊóÿÿYÃÿ1èÁóÿÿYÃÿ1è¸óÿÿYË‹‹HH…ÉtƒÈÿðÁuù°ÆFtQèù¾ÿÿYÃÿ1èÓóÿÿYÃÿ1è‚óÿÿYÃÿ1èÁóÿÿYËA‹ÿ0‹ÿ0è€YYËjÿ0èrYYÃÿ1è—óÿÿYË‹‹@HðÿËÿU‹ìQQ‹E3ÉAjC‰H‹EǘF‹E‰ˆP‹EYÇ@H°ÆF‹Ef‰Hl‹Ef‰ˆr‹Eƒ LE‰EüEüPjèËýÿÿE‰EøE‰EüEøPjèdýÿÿƒÄ‹å]ËÿU‹ìhìÝFÿuèuÿÿÿYY]ËÁËÿU‹ìƒ}tÿuèÿuèú½ÿÿYY]‹ÿU‹ìQ‹E‹ù˜Ft
QèÛ½ÿÿ‹EYÿp<èϽÿÿ‹Eÿp0èĽÿÿ‹Eÿp4è¹½ÿÿ‹Eÿp8讽ÿÿ‹Eÿp(製ÿÿ‹Eÿp,蘽ÿÿ‹Eÿp@è½ÿÿ‹EÿpD肽ÿÿ‹Eÿ°`èt½ÿÿE‰EüEüPjèjüÿÿE‰EüEüPjè©üÿÿƒÄ4‹å]ÃéRÿÿÿ‹ƒ!Ëá8ÂFƒøÿt
Pè…Øÿÿ…ÀuFVWhdj軾ÿÿ‹ðYY…öt#Vÿ58ÂFèµØÿÿ…ÀthìÝFVèQþÿÿY‹þ3öYë3ÿVèè¼ÿÿY‹Ç_^ËÿSVWÿH±E‹ð3Û¡8ÂFƒøÿtPèØÿÿ‹ø…ÿuHhdjèQ¾ÿÿ‹øYY…ÿu	S裼ÿÿYë-Wÿ58ÂFèBØÿÿ…ÀuWëåhìÝFWèÛýÿÿSè|¼ÿÿƒÄ…ÿt‹ßVÿX±E_^‹Ã[Ã3À9•ÀËÿV‹ñÿ6èR¼ÿÿƒ&Y^ËÿU‹ìV‹uƒ~Lt(ÿvL襋FLY;ìÝFt=@ÂFt
ƒxuPè.£Y‹E‰FL^…ÀtP蟢Y]á8ÂFƒøÿu3ÀÃPèF×ÿÿá8ÂFƒøÿt!VPè4×ÿÿ‹ð…ötjÿ58ÂFèw×ÿÿVè®ýÿÿ^ËÿVWÿH±E‹ð¡8ÂFƒøÿtPèýÖÿÿ‹ø…ÿuIhdjè3½ÿÿ‹øYY…ÿu	Pè…»ÿÿYë8Wÿ58ÂFè$×ÿÿ…ÀuWëåhìÝFWè½üÿÿjè]»ÿÿƒÄ…ÿtVÿX±E‹Ç_^ÃVÿX±E蛼ÿÿÌ‹ÿSVWÿH±E‹ð3Û¡8ÂFƒøÿtPèvÖÿÿ‹ø…ÿuQhdj謼ÿÿ‹øYY…ÿu	SèþºÿÿYë+Wÿ58ÂFèÖÿÿ…ÀuWëåhìÝFWè6üÿÿSè׺ÿÿƒÄ…ÿu	VÿX±Eë	VÿX±E‹ß_^‹Ã[ÃhöCèZÕÿÿ£8ÂFƒøÿu2ÀÃè_ÿÿÿ…Àu	PèYëë°á8ÂFƒøÿt
Pè~Õÿÿƒ
8ÂFÿ°Ãÿ%p°Eÿ%±E‹ÿU‹ìV‹u‹;ìÝFt‹M¡4ÉF…Pu裣‰^]ËÿU‹ìV‹u‹;ÐÈFt‹M¡4ÉF…Puèㄉ^]ËÿU‹ì‹M‹Á%€yHƒÈü@uVjd‹Á^™÷þ^…Òt°]Ãl¹™÷ù÷ÚÒB]ËÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]Âÿ1èYËÿU‹ì‹Eljd™Y÷ù‹Â]ËÿU‹ì‹Eljd™Y÷ù]ËÿU‹ìV‹uWÿu‹}WVè7ƒÄ…Àu'NVèEÿÿÿ3É„À•Á+}ÁmƒÇQWVèƒÄë3À@_^]ËÿU‹ìSV‹uWjYF™÷ù‹E+ÂÁ™÷ùÿu‹Øèôþÿÿ+uY¶Èj†s‹}™+ù^÷þm‹òÆj™Y÷ùÿl|ƒútÿk|ƒút
ÿj|
ƒúuƒÈÿëƒþtƒþt‹ÃƒþuC_^[]ËÿU‹ìVÿu‹uÿuVèVÿÿÿƒÄ…ÀuFÿë‹ÆF^]ËÿU‹ì‹E+EjYÁ™÷ù‹E+ÂÁ™÷ù]ËÿU‹ìQQ‹US·ÂVWƒøZŽÆƒøn3„ƒøeŽãƒèg„‘ƒèujbZRXëÓHƒètJƒè…º‹E‹H…Ɉœƒù“€} •ÀþÈ$0f˜·ÀPÿuÿujAPèq
ƒÄé3
‹E‹H…Ɉ[ùmO€} •ÀþÈ$0f˜·ÀPÿuÿuj뺋Ex”øÿÿŒ$x£j0ÿuÿujÿpÿpÿpè¶þÿÿƒÄljd™Y÷ùRéuÿÿÿ„üƒèa„»ƒè„†ƒètDƒè…Õ‹EƒxŒ¸ƒx®€} •ÁþÉ€á0f¾É·ÉQÿuÿujÿpéÿÿÿ‹]‹M ûF…Ý„É…Õ‹}3öVS‹]WSÿujaÿuèXþÿÿƒÄ„Àuè°3þÿÇéPWShFè=
VÿuWSÿujbÿuè"þÿÿƒÄ(„ÀtÊWShFè
VÿuWSÿujeÿuèüýÿÿƒÄ(„Àt¤WShFèñ	VÿuWSÿujTÿuèÖýÿÿƒÄ(„À„zÿÿÿWShFèÇ	VÿuWSÿujYÿuè¬ýÿÿƒÄ(„À…jéKÿÿÿSÿu3À„Éÿu•ÀÿuPÿuè»	ƒÄ„À„&ÿÿÿÿuÿuhFèo	SÿuÿuÿujÿuèŒ	ƒÄ$륋E‹H…ÉxCƒù>ÿu‹Eÿuÿ´ˆìè2	ƒÄéë‹E‹H…Éxƒùÿu‹Eÿuÿ´ˆ´ëÒè`2þÿÇè ½ÿÿ2À鵋E‹Hƒù|ÞƒùÙ€} •ÀþÈ$ f˜·ÀPÿuÿujQéDýÿÿÿuÿuh˜Fé|ÿÿÿƒøwbtƒèp„HƒètZHƒètDƒèu•‹E‹H…Ɉwÿÿÿƒùnÿÿÿ…Éu	fƒúuujY€} •ÀþÈ$0f˜·ÀPÿuÿujë†ÿuÿuh Féÿÿÿ‹uÿu VþF…‹}‹]WSÿujIÿuèüÿÿƒÄ„À„³ýÿÿWShœFèÿu VWSÿujMÿuèåûÿÿƒÄ(„À„‰ýÿÿWShœFèÖÿu VWSÿujSÿuè»ûÿÿƒÄ(„À„_ýÿÿWShFè¬ÿu VWSÿujpéàýÿÿÿuÿuÿujXÿuèûÿÿƒÄéÐýÿÿ‹E‹@…Àˆjþÿÿƒøaþÿÿƒø‹E‹€Lë‹€PÿuÿuPéþÿÿƒèx„ñƒè„¦ƒè…4þÿÿè·MEü3öP‰uüèü?Y…À…þÿÿ‹E9p t Eø‰uøPè³?Y…À…ëýÿÿ‹MüMø‰Müë‹Mü‹Á™3Â+™j<^÷þ™÷þ…ɹ¤F‹ú‹ðx¹”FÿuÿuQè¸j0ÿuÿujVèŸj0ÿuÿujWèƒÄ4éQ‹E‹Hù”øÿÿŒuýÿÿù£iýÿÿ€} •ÀþÈ$0f˜·ÀPÿulÿujéNûÿÿÿu3Àÿu8E ÿu•ÀÿuPÿuèbƒÄéxüÿÿ„{ƒøM›„ƒøDC„Ѓè%„·ƒè„‚ƒètQƒè…ìüÿÿ‹E‹Hù”øÿÿŒÊüÿÿù£¾üÿÿ€} •ÀþÈ$0f˜·ÀPÿulÿu™jjdY÷ùéúÿÿ‹E‹H…Ɉ†üÿÿƒù}üÿÿÿu‹Eÿuÿ´ˆé:üÿÿ‹E‹H…ɈZüÿÿƒùQüÿÿÿu‹Eÿuÿ´ˆÐéüÿÿÿuÿuh¨Féþûÿÿÿu ‹uÿu‹}VWÿujmÿuèùÿÿƒÄ„À„¶úÿÿVW» FSèÿu ÿuVWÿujdÿuèåøÿÿƒÄ(„À„‰úÿÿVWSèÚÿu ÿuVWÿujyéûÿÿƒèF„½ƒètvƒètJƒè…³ûÿÿ‹E‹@…Àˆ•ûÿÿƒøŒûÿÿj™Y÷ù…Òu‹Ñ€} •ÀþÈ$0f˜·ÀPÿuÿujéqùÿÿ‹E‹H…ɈTûÿÿƒùKûÿÿ€} •ÀþÈ$0émûÿÿ‹Ex”øÿÿŒ+ûÿÿx£ûÿÿj0ÿuÿujÿpÿpÿpè½÷ÿÿƒÄlé‚øÿÿÿu ‹uÿu‹}VWÿujYÿuèß÷ÿÿƒÄ„À„ƒùÿÿVW»”FSèÏÿu ÿuVWÿujmÿuè²÷ÿÿƒÄ(„À„VùÿÿVWSè§ÿu ÿuVWÿujdéÙùÿÿ‹E‹H…Ɉ~úÿÿƒù;é%ÿÿÿjƒèR_;LJxúÿÿÿ$…¾Dÿu ÿuÿuÿuÿujHÿuèI÷ÿÿƒÄ„À„íøÿÿÿuÿuhœFè6ÿu ÿuÿuÿuÿujMédùÿÿ‹E‹…Ɉ
úÿÿƒù<é±þÿÿÿu ‹uÿu‹}VWÿujHÿuèèöÿÿƒÄ„À„ŒøÿÿVW»œFSèØÿu ÿuVWÿujMÿuè»öÿÿƒÄ(„À„_øÿÿVWSè°ÿu ÿuVWÿujSéâøÿÿ‹E‹H…Ɉ‡ùÿÿƒù~ùÿÿfƒúWu
…ÉujYëI‹@…Àˆcùÿÿ=mXùÿÿ3ö;Á|
™÷ÿ‹ð;Ñ|F€} •ÁþÉ€á0f¾Á·ÀPÿuÿujVé°öÿÿ€} •ÀþÈ$0f˜·ÀPÿu‹EÿujÿpÿpÿpèÐôÿÿƒÄé}öÿÿÿuÿuÿuÿujé±ûÿÿ‹E‹Hù”øÿÿŒÏøÿÿù£Ãøÿÿ€} •ÀþÈ$0f˜·ÀPÿulÿujé(öÿÿè2H3ö‰uøè:‹M3Òÿu‹}‹]9q jÿ•Â‹Pÿ7Eøÿ3PèªNƒÄ…Àt
ƒøt0ƒø"t+ƒøPu
‹À‰7ë‹Mø3À@+ÁMþÿÿÿ°_^[‹å]ÃVVVVV耵ÿÿ€DÊDßDLD»DLDíDD‹ËÿU‹ìƒìfƒ}uÿuÿuÿuè…ƒÄë|‹EV‹u;smS3ÛHW‹}H‰Mô…ÉtP‹MÀf‹u‰Eü‰Mø…Ét‹Áj
™Y÷ù‹‹MüƒÂ0f‰ë‹f‰4‹Eø™j
Y÷ùC‹È‹Eüƒè‰Møƒmô‰Eüu‹u)_[ëƒ&^‹å]ËÿU‹ìV‹uW‹}‹‹ƒøvDS‹]‹Ãj
™[÷û‹ØB0f‰ƒÁÿ…Û~ƒ>wâ‹qþ‰[ëf‹·f‰ƒîf‰
ƒÂ;Örêë	À+ȉƒ&_^]ËÿU‹ì‹Mƒ9t"‹UV‹uW·:f…ÿt‹ƒÂf‰8ƒƒ)uè_^]ËÿU‹ìƒì0¡ÀF3ʼnEü‹E‹U‰EЋES‹]‰EÜ‹E‰UÔ‰]ØV‹u‰uäWƒètƒèt‹»\ë‹»Xë‹»Tƒ»¬„éƒ}¸l”ÁfBf‰Eìf‹Bf@ˆMãf‰Eîf‹Bf‰Eòf‹Bf‰Eôf‹Bf‰Eöf‹f‰Eø3Àf‰EúEì„Ét3ÉQQWPQÿ³`èIÉÿÿë3ÉQQQWPQÿ³`è@Çÿÿ‹Ø…Û„kJ;ÑÀ…ÁtXJ;ÑÀ#ÁJ=w#;ÑÀ#Áè¸c‹ô‰uè…ö„´ÇÌ̃Æë$;ÑÀ#ÁPè«ÿÿ‹ð‰uèY…ö„ÇÝÝëÙ3ö‰uè…öt~€}ãEìtSVWP‹EØjÿ°`èžÈÿÿëjSVWP‹EØjÿ°`è’Æÿÿ‹Ð‹þJ…Ò~#‹]ä‹u܃;v‹f‹ƒÇf‰ƒÿJ…Òæ‹uèVèBY°eÄ_^[‹Mü3ÍèÍoüÿ‹å]Ãjè$‹uäYénƒ>tÕÆEä3ɉ}è‹ß·ÂƒÃAf9t÷·Â‰]è‹]؃ød/„øƒø'„šƒøAtƒøHtXƒøMt"ƒøa…âh|FWè¿QYY…ÀuSO
‰Mèëbƒét!ƒét ƒétƒé…±jBéÂjbé»ÆEäjmé°ƒét
ƒét	é‰ÆEäjHé–hˆFWè[QYY…ÀuG‰Eèjpéx‹Á%€yHƒÈþ@„hj'XƒÇf;È„Y‹f‰ƒÿ·f…ÉuÖéBƒét!ƒét ƒétƒé…ójAéjaéýÆEäjdéòƒèh„ǃ脪ƒè„ƒèt'ƒè…±IƒétIƒé…¡jYé²jyé«‹EÔƒx‹“Lë‹“Pƒùuƒ>v‹}Üf‹‹f‰ƒÿé‘·
f…É„…‹]܃>v}‹ƒÂf‰ƒÿ·
f…Éuæëfƒétƒétë&ÆEäjSë6ƒétƒétëÆEäjMë"ƒétƒét‹M܃Ç‹f‰ƒÿë%ÆEäjIXÿuäSVÿuÜÿuÔPÿuÐè…ïÿÿƒÄ„Àt‹}è·f…Ò…†ýÿÿé[ýÿÿèÉ$þÿÇ2ÀéKýÿÿ‹ÿU‹ì‹EH;ÁÀ#Á]ËÿU‹ì‹E…Àt‹M‰ƒÀ]ËÿU‹ìƒìSVW3ÛMäS‰]üèwþüÿ‹Eèj_‹€œЉEø‹ð‹VäJf‹ƒÂf;Eüuô+Ñ‹ÑúA‰Eôf‹ƒÁf;Eüuô+MôƒÃÑùƒÆ؃ïuÁ]Pè7§ÿÿ‹ø3ÀY…ÿu‹øé©j:‰Eô‹÷‹EøYf‰ƒÆÿpä‹Î‹Ã+ÏÑù+Á@PVèÒÿÿƒÄ…À…˜‹ÎQf‹ƒÁf;Eüuô+ÊÑùj:X4Nf‰ƒÆ‹Eø‹Î+ÏÑùÿ0‹Ã+Á@PVèÛÑÿÿƒÄ…ÀuY‹ÎQf‹ƒÁf;Eüuô‹Eø+ÊÑùƒÀj:‰Eø4N‹MôA‰MôƒùY‚gÿÿÿ3Àf‰Pè>¦ÿÿ€}ðYt
‹M䃡Pý‹Ç_^[‹å]Ã3ÀPPPPPè+®ÿÿÌ‹ÿU‹ìƒìSVW3ÛMäS‰]üèýüÿ‹Eèj_‹€œ‰Eø‹ð‹VÐJf‹ƒÂf;Eüuô+Ñ‹ÑúA‰Eôf‹ƒÁf;Eüuô+MôƒÃÑùƒÆ؃ïuÁ]PèÖ¥ÿÿ‹ø3ÀY…ÿu‹øé©j:‰Eô‹÷‹EøYf‰ƒÆÿpЋ΋Ã+ÏÑù+Á@PVè½ÐÿÿƒÄ…À…˜‹ÎQf‹ƒÁf;Eüuô+ÊÑùj:X4Nf‰ƒÆ‹Eø‹Î+ÏÑùÿ0‹Ã+Á@PVèzÐÿÿƒÄ…ÀuY‹ÎQf‹ƒÁf;Eüuô‹Eø+ÊÑùƒÀj:‰Eø4N‹MôA‰MôƒùY‚gÿÿÿ3Àf‰Pèݤÿÿ€}ðYt
‹M䃡Pý‹Ç_^[‹å]Ã3ÀPPPPPèʬÿÿÌ‹ÿU‹ìƒì(VW3öMØVè¹ûüÿ‹EÜ‹Ö‰uð¿d‰UøS‹ˆœ‹Æ‰Mü‰Eôƒúu+W豤ÿÿ‰EôY…À„WVPèÈüÿ‹EôƒÄ‹Mü‰}ð¿d‹Ö‰Eì)Mì‹Ù‰Uèƒ}øu%8‹Eì‰ÿ3‹Eð+ÇPQè
¥ÿÿƒÄ…À…Z‹Uè‹A‰EèŠA„Àuù+MèG‹EôùBƒÃ‰Uèƒúr±‹]ü‹Ö‰UèƒÃƒ}øu'‹Eì‹Môωÿ3‹Eð+ÇPQ认ÿÿƒÄ…À…þ‹Uè‹A‰EèŠA„Àuù+MèGùƒÃB‰Uèƒúr²‹]ü‹Ö‰UèƒÃ8ƒ}øu'‹Eì‹Môωÿ3‹Eð+ÇPQèU¤ÿÿƒÄ…À…¥‹Uè‹A‰EèŠA„Àuù+MèGùƒÃB‰Uèƒúr²‹]ü‹Ö‰UèƒÃhƒ}øu'‹Eì‹Môωÿ3‹Eð+ÇPQèü£ÿÿƒÄ…À…L‹Uè‹A‰EèŠA„Àuù+MèGùƒÃB‰Uèƒúr²‹]ü‹Ö‰Uè؃}øu'‹Eì‹Môωÿ3‹Eð+ÇPQè £ÿÿƒÄ…À…ð‹Uè‹A‰EèŠA„Àuù+MèGùƒÃB‰Uèƒúr²ƒ}ø‹]ôu)‹Eü;‰‹ ÿ° ‹Eð+ÇPQèJ£ÿÿƒÄ…À…š‹Eü‹ˆ QŠA„Àuù+ÊGùƒ}øu)‹Eü;‰‹¤ÿ°¤‹Eð+ÇPQè£ÿÿƒÄ…À…S‹Eü‹ˆ¤QŠA„Àuù+ÊGùƒ}øu)‹Eü;‰‹¨ÿ°¨‹Eð+ÇPQè¼¢ÿÿƒÄ…À…‹Eü‹ˆ¨QŠA„Àuù+Ê‹UøY‹Mô߃úu‹Eü‹€¬‰¬‰±°‹}ü‰uèÇ´ëCöÃuúƒúu(‹ÃÑèA‹Eì‰‹Eðÿ7+ÃÑèPQè¶ÌÿÿƒÄ…À…‘‹Qf‹ƒÁf;Æuõ‹Eè+Ê‹UøƒÇÑùK‹MôƒÃ@‰EèƒørŸ‹}ü‰uèÇÐëCöÃuúƒ}øu+‹Mô‹ÃÑèA‹Eì‰‹Eðÿ7+ÃÑèPQèBÌÿÿƒÄ…À…‹Qf‹ƒÁf;Æuõ‹Eè+ÊÑùƒÇKƒÃ@‰Eèƒør¡‹}ü‰uèÇìëCöÃuúƒ}øu+‹Mô‹ÃÑèA‹Eì‰‹Eðÿ7+ÃÑèPQèÔËÿÿƒÄ…À…¯‹Qf‹ƒÁf;Æuõ‹Eè+ÊÑùƒÇKƒÃ@‰Eèƒør¡‹}ü‰uèÇëCöÃuúƒ}øu+‹Mô‹ÃÑèA‹Eì‰‹Eðÿ7+ÃÑèPQèfËÿÿƒÄ…À…A‹Qf‹ƒÁf;Æuõ‹Eè+ÊÑùƒÇKƒÃ@‰Eèƒør¡‹}ü‰uèÇLëCöÃuúƒ}øu+‹Mô‹ÃÑèA‹Eì‰‹Eðÿ7+ÃÑèPQèøÊÿÿƒÄ…À…Ó‹Qf‹ƒÁf;Æuõ‹Eè+ÊÑùƒÇKƒÃ@‰Eèƒør¡ëCöÃuúƒ}ø‹}ôu/‹ÃÑèG‹Eü‰Tÿ°T‹Eð+ÃÑèPQèÊÿÿƒÄ…À…j‹Eü‹ˆTQf‹ƒÁf;Æuõ+ÊÑùKƒÃëCöÃuúƒ}øu/‹ÃÑèG‹Eü‰Xÿ°X‹Eð+ÃÑèPQè1ÊÿÿƒÄ…À…‹Eü‹ˆXQf‹ƒÁf;Æuõ+ÊÑùKƒÃëCöÃuúƒ}øu/‹ÃÑèG‹Eü‰\ÿ°\‹Eð+ÃÑèPQèÓÉÿÿƒÄ…À…®‹Eü‹ˆ\Qf‹ƒÁf;Æuõ+ÊÑùKƒÃëCöÃuúƒ}øu+‹ÃÑèG‹Eü‰`ÿ°`‹Eð+ÃÑèPQèuÉÿÿƒÄ…ÀuT‹Eü‹ˆ`Qf‹ƒÁf;Æuõ+Ê‹UøÑùB‰Uøy<{ƒú}‹Eô‹Müé]ùÿÿ‹uô€}ä[t
‹M؃¡Pý_‹Æ^‹å]ÃVVVVVèÌ¥ÿÿÌ‹ÿU‹ìjÿuÿuÿuÿuÿuèƒÄ]ËÿU‹ìƒì$W‹}…ÿuèžþÿÇè^¥ÿÿ3ÀéUƒ}tãV‹u3Àf‰…öuètþÿÇè4¥ÿÿ3Àé*ÿuMÜèTôüÿ‹U…Òu‹Eà‹œ‰U‹E‹ÏS3Û‰Mô‰Eø…À†··>‰}ð·ÿ…ÿ‹}„Š‹}ðfƒÿ%‹}t‹EðƒÆf‰‹Mô‹EøƒÁH‰Mô‰EøëX9]„ƒÆˆ]ìfƒ>#uÆEìƒÆ·ƒøEtƒøOuƒÆÿuìEøRPEôPÿu·PEàPèGäÿÿƒÄ„À‹Eøt"‹MôƒÆ‹U…À…bÿÿÿ…Àt‹]3Àf‰+]øë4…Àt±ëŠË3Òf‰„Éu…Àu
ècþÿÇ"ëèVþÿÇè¤ÿÿ€}èt
‹M܃¡Pý‹Ã[^_‹å]ËÿU‹ì‹E…Àtƒè8ÝÝuPèú›ÿÿY]ËÿU‹ìÿujÿuÿuÿuÿuèDþÿÿƒÄ]ËÿU‹ìjjÿuÿuÿuÿuè%þÿÿƒÄ]ËÿU‹ìQèìßÿÿ‹HL‰MüMüQPè7áÿÿ‹EüYYƒÀ‹å]ËÿU‹ìƒìMäSÿuè•òüÿ‹]ûsKEèPSèkYY„Àt$€}ð‹Eè‹€˜¶t
‹E䃠Pý‹Áéò€}ðt
‹M䃡Pý‹ÃéÛ3Àf‰EüˆEþ‹Eèƒx~.‹ÃMèÁø‰EôQ¶ÀPètÓYY…Àt‹EôˆEü3Àjˆ]ýˆEþYëèýþÿ3ÉÇ*3Àˆ]üAˆEýf‰EøUøˆEú‹EèjÿpjRQMüQÿuÿ°¨EèPèä׃Ä$…Àu8Eð„gÿÿÿ‹E䃠PýéXÿÿÿƒøu€}ð¶Eøt+‹M䃡Pýë¶Uø¶EùÁâЀ}ðt
‹M䃡Pý‹Â[‹å]ËÿU‹ìƒìMäSÿuèKñüÿ‹]ûsKEèPSè>YY„Àt$€}ð‹Eè‹€”¶t
‹E䃠Pý‹Áéò€}ðt
‹M䃡Pý‹ÃéÛ3Àf‰EüˆEþ‹Eèƒx~.‹ÃMèÁø‰EôQ¶ÀPè*ÒYY…Àt‹EôˆEü3Àjˆ]ýˆEþYëè³þÿ3ÉÇ*3Àˆ]üAˆEýf‰EøUøˆEú‹EèjÿpjRQMüQÿuÿ°¨EèPèšÖƒÄ$…Àu8Eð„gÿÿÿ‹E䃠PýéXÿÿÿƒøu€}ð¶Eøt+‹M䃡Pýë¶Uø¶EùÁâЀ}ðt
‹M䃡Pý‹Â[‹å]ËÿU‹ìÿujÿuè¾/þÿƒÄ÷ØÀ÷Ø]ËÿU‹ìÿujÿuè¡/þÿƒÄ÷ØÀ÷Ø]ËÿU‹ì‹E‹‹ˆ”‹E¶]ËÿU‹ì‹E‹‹ˆ˜‹E¶]ËÿU‹ì‹EƒÀ ]ËÿU‹ìÿuhÿuè(þÿÿƒÄ]ËÿU‹ì‹EƒÀà]ËÿU‹ìÿuhÿuè·üÿÿƒÄ]ËÿU‹ì¡¨ÙF…Àtjÿuè§ÿÿÿYY‹Èë‹MA¿ƒøwƒÁ ‹Á]ËÿU‹ì¡¨ÙF…ÀtjÿuèžÿÿÿYY‹Èë‹MAŸƒøwƒÁà‹Á]ËÿU‹ìƒìSV‹u…öt‹]…Ût€>u‹E…Àt3Éf‰3À^[‹å]ÃWÿuMðè¾îüÿ‹Eôƒ¸¨u‹M…Ét¶f‰3ÿGé„EôP¶PèìÏYY…Àt@‹}ôƒ~';_|%3À9E•ÀPÿuÿwVj	ÿwÿh°E‹}ô…Àu;_r.€~t(‹ë13À9E•À3ÿPÿu‹EôGWVj	ÿpÿh°E…Àuè%þÿƒÏÿÇ*€}üt
‹Mðƒ¡Pý‹Ç_é1ÿÿÿ‹ÿU‹ìjÿuÿuÿuèñþÿÿƒÄ]ËÿU‹ìƒìÿuMìèÔíüÿƒeüEðP‹EðÿuÿpEüÿuPè#ƒÄ…ÀtƒÈÿë‹Eü€}øt
‹M샡Pý‹å]ËÿU‹ìƒìS‹]W‹}…Ûu…ÿt‹E…Àtƒ 3Àëz‹E…ÀtƒÿVÿÿÿÿvèYþÿj^‰0èžÿÿëSÿuMìè?íüÿ‹Eð3ö9°¨u]f‹E¹ÿf;Áv6…Ût…ÿtWVSèaqüÿƒÄèþÿj*^‰0€}øt
‹M샡Pý‹Æ^_[‹å]Ã…Ût…ÿt_ˆ‹E…ÀtÖÇëÎMü‰uüQVWSjMQVÿpÿرE‹È…Ét9uüuŸ‹E…Àt¢‰ëžÿH±Eƒøzu‰…Ût…ÿtWVSè×püÿƒÄè…þÿj"^‰0èFÿÿélÿÿÿ‹ÿU‹ìQƒeüjÿuèiPÿuEüPè¾þÿÿƒÄ…ÀtƒÈÿë‹Eü‹å]ËÿU‹ìjÿuÿuÿuÿuè“þÿÿƒÄ]ËÿU‹ì‹E¹ÿSV3Ò‹‹p‹ÆÁè#ÁW;ÁuC;Òu?‹þ‹ÃçÿÿÇu@ë0‹Î‹Âá€Á¸t
;Úu	;øujXë#ðÖtjëójëï3À_^[]ËÿU‹ì‹E3Ò‹H‹Âá€ÁtBŠÂ]ËÿU‹ìƒì0SVW‹}3Û…ÿy‹û‹uMÐÿu(ˆèrëüÿG9Ewèhþÿj"_‰8è)œÿÿ騋U‹‹J‰Eà‹ÁÁè%ÿ=ÿuR;ÛuNSÿu$SWÿuÿuÿuVRè‹‹øƒÄ$…ÿtˆébjeVè¥iüÿYY…Àt8] ”ÁþÉ€áà€ÁpˆˆX‹ûé:ဋÃÁtÆ-F‹J3Û8] j0”ÃÇEôÿK3ÀƒãàáðƒÃ'Á‰]äXuˆF‹B‹
%ÿÿÈu!Môë
ÇEôþëÆ1F‹ÎF‰Mè…ÿuÆë‹EÔ‹€ˆ‹Šˆ‹B%ÿÿ‰Eðw	ƒ:†Åƒeü¹j0X‰Eø‰Mð…ÿ~S‹‹R#Eü#Ñ‹Møâÿÿ¿ÉèBKj0YfÁ·Àƒø9vËMð‹UˆF‹Eü¬È‰Eü‹EøÁéƒèO‰Mð‰Eøf…Ày©f…ÀxW‹‹R#Eü#Ñ‹Møâÿÿ¿ÉèêJfƒøv6j0Fÿ[Š€ùft€ùFuˆHëï‹]ä;EètŠ€ù9u€Ã:ˆë	þÁˆëþ@ÿ…ÿ~Wj0XPVèÏmüÿƒÄ÷‹Eè€8u‹ð€} ±4‹U”ÀþÈ$àpˆ‹‹RèrJ‹È3Ûáÿ+MôÛx…Ér	ÆF+ƒÆëÆF-ƒÆ÷ÙƒÓ÷Û‹þj0Xˆ…Û|?¸è;ÈrjPSQè´G0‰UäˆF;÷u…Û|ƒùdrjjdSQè’G0‰UäˆF;÷u…Û|ƒù
rjj
SQèpG0‰UäˆFj0XÈ3ÿˆÆF€}Üt
‹MЃ¡Pý‹Ç_^[‹å]ËÿU‹ìƒìEôV‹uWÿuÿu~P‹EWÿpÿ0èvãƒÉÿƒÄ9Mt‹M3Àƒ}ô-”À+È3À…öŸÀ+ÈEôPW‹}Q3Ƀ}ô-”Á3À…öŸÀÏÁPèšÎƒÄ…ÀtÆëÿu(EôjPÿu$ÿu VÿuWè	ƒÄ _^‹å]ËÿU‹ìƒìVW‹}…ÿ~‹Çë3ÀƒÀ	9EwèÙ
þÿj"^‰0蚘ÿÿ‹Æ_^‹å]ÃSÿu$Mðè¸çüÿŠU ‹]„Òt%‹M3À…ÿŸÀP3Àƒ9-”ÀÃPÿuSèŠU ƒÄ‹E‹óƒ8-uÆ-s…ÿ~ŠFˆF‹Eô‹€ˆ‹Šˆ3À„Ò”ÀÇðƒÈÿ9Et‹Ã+ÆEh¬FPVè‘ÿÿƒÄ[…ÀuvN8EtÆE‹U‹B€80t/‹Rƒêy÷ÚÆF-jd_;×|‹Â™÷ÿFj
_;×|‹Â™÷ÿFVƒ}u€90ujAPQè³€ƒÄ€}üt
‹Eðƒ Pý3Àéòþÿÿ3ÀPPPPPè«—ÿÿÌ‹ÿU‹ìƒì3ÀVWÿu}ôÿu«««Eô‹}P‹EWÿpÿ0è‹áƒÉÿƒÄ9Mt‹M3Àƒ}ô-”À+È‹uEôP‹EøÇP3Àƒ}ô-Q”ÀÆPè¼ÌƒÄ…ÀtÆëÿu EôjPWÿuVè	ƒÄ_^‹å]ËÿU‹ìƒìMðSVWÿuèæüÿ‹U‹}‹]‹JI€}t;Ïu3Àƒ:-”ÀÁfÇ0ƒ:-‹óuÆ-s‹B…ÀjVÿuSè:ƒÄÆ0Fëð…ÿ~RjVÿuSè‹EôƒÄ‹€ˆ‹ŠˆF‹E‹H…Éy)€}u‹Á÷Ø;Ç}‹ù÷ßWVÿuSèåWj0Vè´iüÿƒÄ€}ü_^[t
‹Eðƒ Pý3À‹å]ËÿU‹ìƒìSVWÿu3À}ðÿu«««Eð‹}P‹EWÿpÿ0è&à‹Eô3É‹]ƒÄƒ}ð-”ÁH‰EüƒÈÿ49Et‹E+ÁMðQWPVè]˃Ä…ÀtÆëU‹EôH9EüœÁƒøü|*;Ç}&„Ét
ŠF„ÀuùˆFþÿu(EðjPWÿuSè‰þÿÿƒÄëÿu(EðjPÿu$ÿu WÿuSè“üÿÿƒÄ _^[‹å]ËÿU‹ìƒìH¡ÀF3ʼnEü‹U‹MSŠ]¶ÃƒÀ;ÐsjÆX‹Mü3Í[è»Rüÿ‹å]ÄÛtÆ-AJƸlFÇEÜ|F‰E¼3Û8]‰EÀ¸pF‰EĕÉEÈK¸xFÇEäˆF‰EÔƒã‰E؉Eè‰Eø‹EV¾tFÇEì”FW<…üÿÿÿ‰ủuЉuà‰uðÇEô F‹t…¼F‰E¸ŠF„Àuù+u¸;òÀGÇÃÿt…¼RQèoÿÿƒÄ_^…À„Aÿÿÿ3ÀPPPPP臔ÿÿÌ‹ÿU‹ì‹U…Òt&V‹u‹ÎWyŠA„Àuù+ÏAPVPè;}ƒÄ_^]ËÿU‹ì]ééaüÿ‹ÿU‹ìQQVW‹}…ÿuè:	þÿj^‰0èû“ÿÿ‹ÆéS‹]…Ûtƒ}tƒ}wè	þÿj^‰0èÑ“ÿÿ‹Æéó‹uƒþAtƒþEtƒþFt	ÆEüƒþGuÆEü‹E$ƒàƒÈu2ÿuè¨öÿÿ‰EøY…Àt"ÿuüSWÿuèÿöÿÿY¶ÀPÿuøè%þÿÿƒÄé—‹E$ƒàƒÈtjëjXƒþa(t
ƒîAtƒîëÿu,Pÿuüÿu ÿuÿuSWÿuèËöÿÿëUƒîeÿu,t6ƒîtPÿuüÿu ÿuÿuSWÿuèòüÿÿë/ÿu ÿuÿuSWÿuèyûÿÿƒÄëPÿuüÿu ÿuÿuSWÿuèwùÿÿƒÄ$[_^‹å]ËÿU‹ì‹Eƒ@þ‹Uƒz}·ERPè¯YY]Ë
f‹Ef‰ƒ]ËÿU‹ìƒì¡ÀF3ʼnEüW‹}‹GÁè¨tWÿuè¥ÿÿÿYYéçSVWèQµÿÿ»ÂFYƒøÿt.Wè@µÿÿYƒøþt"Wè4µÿÿ‹ðWÁþè)µÿÿƒà?kÀ0YYµ¨ÚFë‹ÃŠ@)<„Œ<„„Wèý´ÿÿYƒøÿt,Wèñ´ÿÿYƒøþt Wèå´ÿÿ‹ðWÁþèÚ´ÿÿƒà?kØ0YYµ¨ÚFöC(€tFÿuEôjPEðPè»ôÿÿƒÄ…Àu&3ö9uð~¾D5ôWPèìYYƒøÿtF;uð|çf‹Eë¸ÿÿëWÿuè»þÿÿYY^[‹Mü3Í_èOüÿ‹å]ËÿU‹ìjè£ÕüÿPÿuèƒÄ]ËÿU‹ì]éµþÿÿjh8¦FèÆ[üÿ3À‹u…ö•À…ÀuèiþÿÇè)‘ÿÿ¸ÿÿë5¸ÿÿf‰EäVèìÕüÿYƒeüVÿuègþÿÿYYf‹øf‰}äÇEüþÿÿÿèf‹Çè­[üÿËuf‹}äVèÇÕüÿYËÿU‹ì]ézÿÿÿ‹ÿU‹ì]éJÿÿÿ‹ÿU‹ì‹Uƒjy
RÿuèŸYY]Ë‹Mˆÿ¶Á]ËÿU‹ìjèÄÔüÿPÿuèƒÄ]ËÿU‹ì]é²ÿÿÿjhX¦FèçZüÿ3À‹u…ö•À…ÀuèŠþÿÇèJÿÿƒÈÿ龃eäVèÕüÿYƒeü‹FÁè¨…ƒVè
³ÿÿY‹Ðƒúÿtƒúþt‹ÊÁùƒà?kÀ0¨ÚF¹ÂFë¹ÂF‹Á€x)u"ƒúÿtƒúþt‹ÂÁøƒâ?kÊ0…¨ÚFöA-t(èúþÿÇèºÿÿjþMðQhÀFè‰düÿƒÄéXÿÿÿVÿuè×þÿÿYY‹ø‰}äÇEüþÿÿÿè‹ÇèDZüÿËu‹}äVè_ÔüÿYËÿU‹ì]éñþÿÿ‹ÿU‹ì]éÁþÿÿ‹
ÀF3ÀƒÉ9
ðÝF”ÀËÿU‹ì‹ÀF3À‹MƒÊ9ðÝF”À÷ÙÉ#ʉ
ðÝF]Ë‹@Áè	ƒàËÿU‹ìV‹uVèë±ÿÿPè5¶YY…Àu2ÀéSWjèÓüÿYj[;ðu¿ôÝFëSèÓüÿY;ðui¿øÝFÿÐFN‹©ÀuR¸‚ð	‹…Àu+hèï†ÿÿj‰謆ÿÿ‹YY…ÀuN‰^‰N‰‰^ë‰F‹‰ÇFÇF°ë2À_[^]ËÿU‹ì€}t,V‹uW~‹Áè	¨tVèܬÿÿY¸ýÿÿð!3À‰F‰F‰_^]ËÿU‹ìƒìSVW‹}‹GÁè»ÂF¨uhWèé°ÿÿYƒøÿt.WèÝ°ÿÿYƒøþt"WèÑ°ÿÿ‹ðWÁþèÆ°ÿÿƒà?kÀ0YYµ¨ÚFë‹Ã€x)t&uüWèõYƒøÿ„ˈFEþ;ðuæf‹Eüéæ‹GÁè¨…·Wès°ÿÿYƒøÿt,Wèg°ÿÿYƒøþt Wè[°ÿÿ‹ðWÁþèP°ÿÿƒà?kØ0YYµ¨ÚFöC(€ty3öWFèƒYƒøÿt]ˆEôèC¶Môº€f…Ht%Wè`Yƒøÿu¾EôWPèå#Y¸ÿÿëTjˆEõ^VEôPEøPè(îÿÿƒÄƒøÿuèþÿÇ*¸ÿÿë'f‹Eøë!‹Gƒø|ƒÀþ‰G‹·ƒÁ‰ëWèïY_^[‹å]ÃjèßÐüÿPèYYËÿU‹ì]ésþÿÿjhx¦FèWüÿ3À‹u…ö•À…ÀuèªþÿÇèjŒÿÿ¸ÿÿë.3Àf‰EäVè0ÑüÿYƒeüVè+þÿÿYf‹øf‰}äÇEüþÿÿÿèf‹ÇèõVüÿËuf‹}äVèÑüÿYËÿU‹ì]éÿÿÿéaÿÿÿ‹ÿU‹ì‹U…Òuè4þÿÇèô‹ÿÿƒÈÿ]Ãjy	Rè6îY]ËŠ@‰¶Á]ÃjèÐüÿPèYYËÿU‹ì]é©ÿÿÿjh˜¦Fè,Vüÿ‹u‰uà3À…ö•À…ÀuèÌþÿÇ茋ÿÿƒÈÿ麃eäVèSÐüÿYƒeü‹FÁè¨…ƒVèL®ÿÿY‹Ðƒúÿtƒúþt‹ÊÁùƒà?kÀ0¨ÚF¹ÂFë¹ÂF‹Á€x)u"ƒúÿtƒúþt‹ÂÁøƒâ?kÊ0…¨ÚFöA-t(è<þÿÇèüŠÿÿjþMðQhÀFèË_üÿƒÄéXÿÿÿVèÎþÿÿY‹ð‰uäÇEüþÿÿÿè‹ÆèŠUüÿËuäÿuàè¦ÏüÿYËÿU‹ì]éóþÿÿéÓþÿÿ‹ÿU‹ì‹E‹Ðƒà?ÁúkÈ0V‹u‹•¨ÚF3ÒR‹LFPÿu‰ÿu‰Q‰Pÿü±E…ÀuÿH±E‰‹Æ^]ËÿU‹ìƒì8¡ÀF3ʼnEü‹E‹Èƒà?ÁùSkØ0V‹¨ÚFW‹}‰}ЉMÔ‹D‰EØ‹EljEÜÿt±E‹u‹M܉EÈ3À‰‰F‰F;ùƒ=Š/3Àf‰Eè‹EÔˆmå‹…¨ÚFŠL-öÁtŠD.€áûˆEôEôjˆmõˆL-Pë:èĶº€f…Ht$;}܃ÁjEèWPèÈêÿÿƒÄƒøÿ„ÒGëjWEèPè­êÿÿƒÄƒøÿ„·3ÉEìQQjPjEèGPQÿuÈÿرE‰EÌ…À„‘jMàQPEìPÿuØÿü±E…Àtq‹F+EÐljF‹EÌ9Eàrf€}å
u,j
Xjf‰EäEàPjEäPÿuØÿü±E…Àt8ƒ}àr:ÿFÿF;}Ü‚îþÿÿë)‹UÔŠ‹•¨ÚFˆD.‹•¨ÚF€L-ÿFëÿH±E‰‹Mü‹Æ_^3Í[èKFüÿ‹å]ËÿU‹ìQSV‹u3ÀW‹}‰‰F‰F‹EljEü;øs?·Sè×ëYf;Ãu(ƒFƒû
uj
[Sè¿ëYf;ÃuÿFÿFƒÇ;}ürËëÿH±E‰_‹Æ^[‹å]ËÿU‹ìQV‹uVèd¯Y…Àu2ÀëXW‹þƒæ?Áÿkö0‹½¨ÚFöD0(€tèZÄÿÿ‹@Lƒ¸¨u‹½¨ÚF€|0)u2ÀëEüP‹½¨ÚFÿt0ÿ²E…À•À_^‹å]ËÿU‹ì¸è³8¡ÀF3ʼnEü‹M‹ÁÁøƒá?kÉ0S‹]‹…¨ÚFV‹uW‹L‹Eƒ&Ãfƒf‰ðëÿÿ‰…øëÿÿëe½üëÿÿ;ØsŠC<
uÿFÆ
GˆEûG;ø‹…øëÿÿrÞ…üëÿÿ+ø…ôëÿÿjPW…üëÿÿPQÿü±E…Àt‹…ôëÿÿF;Çr‹…øëÿÿ‹ðëÿÿ;Ør—ëÿH±E‰‹Mü‹Æ_^3Í[è‰Düÿ‹å]ËÿU‹ì¸èÔ7¡ÀF3ʼnEü‹M‹ÁÁøƒá?kÉ0S‹]‹…¨ÚFV‹uW‹L‹EÉðëÿÿ3Ò‰…øëÿÿ‰‰V‰Vëu½üëÿÿ;Øs+·ƒÃƒø
u
ƒFj
Zf‰ƒÇf‰EúƒÇ;ø‹…øëÿÿrÑ…üëÿÿ+ø…ôëÿÿjPƒçþ…üëÿÿWPQÿü±E…Àt‹…ôëÿÿF;Çr‹…øëÿÿ‹ðëÿÿ;Ør‡ëÿH±E‰‹Mü‹Æ_^3Í[è›Cüÿ‹å]ËÿU‹ì¸èæ6¡ÀF3ʼnEü‹M‹ÁÁøƒá?kÉ0SV‹…¨ÚF3Û‹uW‹D‹M‹ù‰…ìëÿÿ‹EÁ‰‰^‰…ôëÿÿ‰^;ȃº‹µôëÿÿ…Pùÿÿ;þs!·ƒÇƒù
u	j
Zf‰ƒÀf‰ƒÀMø;ÁrÛSShU
øëÿÿQPùÿÿ+ÁÑøP‹ÁPShéýÿرE‹u‰…èëÿÿ…ÀtLjðëÿÿ+ÃQP…øëÿÿÃPÿµìëÿÿÿü±E…Àt'ðëÿÿ‹…èëÿÿ;ØrË‹Ç+E‰F;½ôëÿÿs3ÛéNÿÿÿÿH±E‰‹Mü‹Æ_^3Í[ènBüÿ‹å]Ãjh¸¦Fè¡ÞF‹4¸F‰EüŠF„Àuù+uüF‰3…Òu3Àë;ñvj"Xë¡ÞFÿ4¸QRèlsÿÿƒÄ_[^‹å]ËÿU‹ìÿuèsrÿÿY]‹ÿU‹ì‹EV¾WHÿ+™÷þjd‹ð‹Á™_÷ÿ_+ð‹Á™ƒâÂÁøƒÀïÆ^]ËÿU‹ìVèë‹ð…ötÿuVè4÷ØYÀ÷ÐY#Æ^]ËÿU‹ìVèÄ‹ð…ötÿuVè'÷ØYÀ÷ÐY#Æ^]ËÿU‹ìQQV‹u…öuèíîýÿj^‰0è®yÿÿ‹ÆéðS‹]ƒÈÿW‹þj	Yó«…ÛuèÄîýÿj^‰0è…yÿÿë'‹‰Eø=@Wÿÿ|j™Y;Ñ|=Ï&A“vè–îýÿj^‰0‹ÆéœEÿÆEÿPEøPè‹}ø‰F‹ÇYY™¹€Q÷ù‰FiÀ€®þÿø€}ÿ¸¸LFu¸„LF‹V3ÉA9P}A9ˆ|úI‰Nj+ˆ¹€Q‰V‹™÷ùYƒÀƒf ™÷ù‹Ç¹‰V™÷ùj<‰FiÀðñÿÿYø‹Ç™÷ù‰FkÀ<+ø3À‰>_[^‹å]ËÿU‹ìƒìV‹u…öuèÒíýÿj^‰0è“xÿÿ‹Æé"Wj	ƒÈÿ‹þYó«‹}…ÿuèªíýÿj^‰0èkxÿÿë3‹O‹‰Eô‰Møƒùÿ	|=@WÿÿrjZ;Ê|=Ï&A“vèpíýÿj^‰0‹ÆéÄSEÿÆEÿPEôPè=‹]ôYYj‰F¸€QPÿuøSèÃ&‰F¹€Q÷鹸LF+Ø‹Eø€}ÿ‰Eøu¹„LF‹V3À@9Q}@9|úH‰Fj+¸€QP‰Vÿwÿ7èr&jƒÀ‹}øY™÷ùj¸‰VPWSèT&¹‰F÷éj+Øj<úWSè;&ƒf ‰FkÀ<+Ø3À‰[_^‹å]ËÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6ècoÿÿƒ&Y^ËÿU‹ìVW‹}¹€†‹7‹Æ™÷ùiÈ€†…F+ñ¹€3á‹Æ‰7;Á|+€ÌþB‰;Á|€ÌþB‰=…â|
B{þ‰ë‹MÆ_‹Â^]ËÿU‹ìQS‹]¸€3áVWj‹s‹;PVWè%º€3áHFAº‰Mü÷êQ+ø‰;ò‰sèMüÿÿ¿€Q÷ïY)‹S‹K…É2|…Às,‹uüº€3ቃÑNV‰Kèz´ÿÿY„Àt";‹EƒSÆë‹uüVè^´ÿÿY„Àt‹MÆ_‹Æ^[‹å]˃!ËÿV‹ñÿ6èDnÿÿƒ&Y^ËÿVèù²ÿÿ‹ð…öt!‹F8…Àu'j$è\nÿÿj‰F8ènÿÿ‹F8YY…Àu
è%ëýÿÇ3À^ËÿU‹ìVè·ÿÿÿ‹ð…ötÿuVèüÿÿ÷ØYÀ÷ÐY#Æ^]ËÿU‹ì]éèûÿÿ‹ÿU‹ìVè…ÿÿÿ‹ð…ötÿuVèèüÿÿ÷ØYÀ÷ÐY#Æ^]ËÿU‹ì]éÐüÿÿ‹ÿU‹ìQSEü3ÛP‰]üèÐùÿÿY…À…¾9]ü„nV‹uW3ÿG‹N;
˜ÃFu;
¤ÃF„'9ÞF„Ì·¾ÞFP·¼ÞFP·ºÞFP·¸ÞFPf9°ÞFu·´ÞFSP·¶ÞFP·²ÞFPQWë·¶ÞFP·²ÞFSSPQSSèh·jÞFƒÄ,P·hÞFP·fÞFP·dÞFPf9\ÞFu·`ÞFSP·bÞFP·^ÞFPÿvWë·bÞFP·^ÞFSSPÿvSWèƒÄ,ëOjXjZ3ÛjC_ƒùk}jXj
_3ÒjB[jjjjjjRPQjjèÇ3ÀPPPjPPSWÿvjjè°ƒÄX‹œÃF‹=¨ÃF‹N;×};Ê|&;Ï";Ê~";Ï}3À@_^[‹å]Ã;Ï|ò;Êî;Ï~;Ê}3ÀëåkF<FkÀ<iðè3À;Êu;5 ÃFÀëÂ;5¬ÃFœÀë·SSSSSèÉsÿÿÌ‹ÿU‹ìèÜ÷ÿÿ‹M‰]ËÿU‹ìèÑ÷ÿÿ‹M‰]ËÿU‹ìèÆ÷ÿÿ‹M‰]ËÿU‹ìQQƒeøƒ}VW‹}uySWèY±ÿÿ‹]ÁãˆEÿY„Àt‹³´LF닳€LFWFèÔøÿÿYiÏmÆjÁ6œÿÿÁ™Y÷ù‹MkÁ+Â;UƒÀùEð€}ÿt‹ƒ¸LF닃„LF[ƒùu*;ð~&ƒîë!Wèá°ÿÿ„À‹EYt	‹4…´LFë‹4…€LFu kE$<E(kÀ<E,iÀèE0ƒ}u‰5œÃF£ ÃF‰=˜ÃF_^‹å]ã¬ÃFEøP‰5¨ÃFè÷ÿÿY…ÀuDiEøè‹
¬ÃFȉ
¬ÃFyÁ\&ÿ
¨ÃFë¸\&;È|+Èÿ¨ÃF‰
¬ÃF‰=¤ÃFëjjjjjèFrÿÿÌ‹ÿU‹ìQQW¿FEüWhÿuPè	ŽƒÄ…Àu‹Eë@ƒø"t3Àë7Vÿuüè/jÿÿ‹ðY…ötWÿuüEøVPèփąÀu‹þ3öë3ÿVèËiÿÿY‹Ç^_‹å]ËÿU‹ìƒìSVèöõÿÿƒeü‹ØƒeôEüP‰]øè>öÿÿY…À…šEôPèÔõÿÿY…À…ˆ‹ÞF‹u…Òt4‹Ê‹ÆŠ:u„ÛtŠX:YuƒÀƒÁ„Ûuä3ÀëÀƒÈ…À„D‹]øRè;iÿÿY‹ÎQŠA„Àuù+ÊAPè]iÿÿj£ÞFèiÿÿ‹ÞFYY…Ò„‹ÎWyŠA„Àuù+ÏVAPRèÏiÿÿƒÄ…À…èj_WVj@ÿ3詃ąÀ…Ï€>tFƒïuõ€>-_”ÄÛtFVèçmÿÿYiȉMüŠ<+t<0|<9Fëï€>:uBFVèÀmÿÿkÀ:uFVè›mÿÿY‹MüȉMüë<9FŠ<0}õ„Ût÷Ù‰Mü3À8•À‰Eô…À‹EøtjVj@ÿpèø
ƒÄ…Àtë ‹@Æ‹uüèIôÿÿ‰0‹uôè3ôÿÿ‰0^[‹å]Ã3ÀPPPPPèpÿÿÌ‹ÿU‹ìƒìSVè!ôÿÿ‹ð3ÛEü‰]üP‰]ø‰]ôèiôÿÿY…À…"EøPèÿóÿÿY…À…EôPèôÿÿY…À…þÿ5ÞFègÿÿ‰ÞFÇ$ÞFÿl±Eƒøÿ„³k
ÞF<‹lÞFW3ÿG‰=ÞF‰Müf9^ÞFtkÂ<ȉMüf9²ÞFt¡ÀÞF…Àt
+‰}økÀ<‰Eôë‰]ø‰]ôèq:‹øEðPSj?ÿ6jÿhÞFSWÿرE…Àt9]ðu‹ˆX?니EðPSj?ÿvjÿhpÞFSWÿرE_…Àt
9]ðu‹FˆX?ë‹Fˆ‹uüèöòÿÿ‰0‹uøèàòÿÿ‰0‹uôèÜòÿÿ‰0^[‹å]ÃSSSSSè¦nÿÿÌ‹ÿU‹ìì¡ÀF3ʼnEüƒ
¤ÃFÿ…üþÿÿƒ
˜ÃFÿSVW»F3ÿShP…øþÿÿ‰=ÞFPè<ŠƒÄ…Àu½üþÿÿëFƒø"uAÿµøþÿÿèafÿÿ‹ðY…öuWèfÿÿë&Sÿµøþÿÿ…ôþÿÿVPèú‰ƒÄ…ÀtVëÛWèôeÿÿ‹þY…üþÿÿ‹÷+ð÷Þö#÷…ÿt€?t	WèüÿÿYëèÝýÿÿVèÄeÿÿY‹Mü_^3Í[è=+üÿ‹å]Ãjh§Fè8üÿ¡ÄÞF…Àu-jè1šÿÿYƒeü¡ÄÞF…ÀuèñþÿÿðÿÄÞFÇEüþÿÿÿèè8üÿÃjèFšÿÿYÃjhø¦Fèº7üÿƒeäjèå™ÿÿYƒeüÿuè¡÷ÿÿY‹ð‰uäÇEüþÿÿÿè‹ÆèÏ7üÿËuäjèü™ÿÿYÃjhئFèp7üÿj蟙ÿÿYƒeüèhþÿÿÇEüþÿÿÿèè”7üÿÃjèÄ™ÿÿYËÿU‹ì‹M‹AƒÀ9sƒyt¸ÿÿ]Ãyró‰‹M‹Aƒþf‹UÁè¨‹tf9t
ƒÀ‰ëÏf‰‹Ej÷Yƒ@‹EƒÀð!‹M3À@ƒÁð	f‹Â]ËÿU‹ìƒì¡ÀF3ʼnEüSVÿuè$ÿÿYƒøÿt5ÿuèÿÿYƒøþt'‹uWVèÿÿ‹øVÁÿèûŽÿÿƒà?kÀ0YY½¨ÚF_ë¸ÂFŠ@)3É‹]‰MðˆMô‰Mõ„Àu#SjEôPEðPèÇÎÿÿƒÄ…Àt¸ÿÿëj‹UðëjZˆ]ôˆ}õ‰Uð‹E‹HÊ9sƒxuÖ;Pщ‹E‹Uðrÿ…öxÿ‹ŠD5ôƒîˆ‹Eyî‹UðP‹Ej÷YƒÀð!‹M3À@ƒÁð	f‹Ã‹Mü^3Í[èñ(üÿ‹å]ËÿU‹ìV¾ÿÿf9uuf‹Æé˜W‹}‹G‹W‹O¨uÁêöÂtÑéöÁtf‹ÆërƒuWè¦ÎY‹GÁè¨uPWèÜÿÿYƒøÿt.WèÐÿÿYƒøþt"WèÄÿÿ‹ðWÁþè¹ÿÿƒà?kÀ0YYµ¨ÚFë¸ÂFö@(€tWÿuèTþÿÿë	WÿuèÙýÿÿYY_^]Ãjh8§Fè5üÿ3À‹u…ö•À…Àuè®ßýÿÇènjÿÿ¸ÿÿë5¸ÿÿf‰EäVè1¯üÿYƒeüVÿuèþþÿÿYYf‹øf‰}äÇEüþÿÿÿèf‹Çèò4üÿËuf‹}äVè¯üÿYËÿU‹ìV‹uWV‹Áè¨unVèìŒÿÿ‹Ð¿ÂFYƒúÿtƒúþtƒà?‹ÊkÀ0Áù¨ÚFë‹Ç€x)u"ƒúÿtƒúþt‹Âƒâ?kú0Áø<…¨ÚFöG-tèáÞýÿÇè¡iÿÿƒÈÿëjVS‹]ƒûÿtD‹‹
¨uƒá€ùu4ƒ~u
VèÍYV‹;Fu	ƒ~t@‰‹Áèÿ¨‹t8t
@‰ƒÈÿëˆÿFj÷Xð!3À@ð	¶Ã[_^]ÃjhX§Fè¡3üÿ3À‹u…ö•À…ÀuèDÞýÿÇèiÿÿƒÈÿë-ƒMäÿVèέüÿYƒeüVÿuèÊþÿÿYY‹ø‰}äÇEüþÿÿÿè‹Çè’3üÿËu‹}äVè­­üÿYÃè/‹È…Ét%ùtùt
3Àù”ÀHÃjëjXÃ3À@ÃèòÏ%øFøðFËÿU‹ìƒìS‹]VW‹}3ö…ÿt
3À…Û„Qf‰9uuèzÝýÿÇè:hÿÿƒÈÿé1ÿuMèèY·üÿ‹Eì…ÿ„È9°¨u)…Û„ù‹M¶f‰€<„åFƒÇ;órçéØSWƒÎÿVÿuj	ÿpÿh°E…À…¹ÿH±EƒøzuZ‹E‹È‰Mü‹Ó…Ût4ŠJ‰Uø„Àt'Mì¶ÀQPè-˜YY‹Mü…ÀtA€9t&‹UøA‰Mü…ÒuÏ‹ESW+ÈQP‹Eìjÿpÿh°E…ÀuèšÜýÿÇ*3Àf‰ëE‹ðëA9°¨u‹uNŠF„Àuù+ñë(VVƒÎÿVÿuj	ÿpÿh°E…Àu
èSÜýÿÇ*ëpÿ€}ôt
‹M胡Pý‹Æ_^[‹å]ËÿU‹ì]é|þÿÿ‹ÿU‹ìƒìS‹]VW‹}3ö…ÿu…Ûtë…ÛuèþÛýÿj^‰0è¿fÿÿé¥3Àf‰‹E…Àt‰0ÿuMðèÓµüÿ‹Ã9]w‹E=ÿÿÿv	èÀÛýÿjëCMôQPÿuWèþÿÿƒÄƒøÿu…ÿt3Àf‰è˜Ûýÿ‹0ë:@…ÿt,;Ãv!ƒ}ÿt3Àf‰è{Ûýÿj"^‰0èˆG„Àt%ƒëuñëŠ>ˆG„Àt
ƒëtƒêuì…Ò‹UuÆ_…Û[u‡ƒúÿu
‹EjPÆDÿXë§ÆèJÚýÿj"ë‘‹ÿU‹ì]éDÿÿÿ‹ÿU‹ì‹M·f…Àtfƒy:uƒøarƒøzwƒè ƒÀÀ]Ã3À]ËÿU‹ìƒì¡ÀF3ʼnEü‹Eƒø|:ƒø5ƒÀ@f‰Eôj:Xf‰Eö3Àf‰EøEôPÿh±E…ÀuÿH±EPè‹ÙýÿYë3Àëè¢ÙýÿÇèªÙýÿÇ
èjdÿÿƒÈÿ‹Mü3Íèþ!üÿ‹å]ËÿU‹ìì¡ÀF3ʼnEüW3À3ÿhf‰…ðýÿÿ…òýÿÿWPè¥7üÿƒÄ…ðýÿÿPhÿ`±E=w…ðýÿÿPèøþÿÿYëBSVXjSè¨]ÿÿ‹ðYY…ötVSÿ`±E…Àu
è
ÙýÿÇë	VèÁþÿÿY‹øVèØ[ÿÿY^‹Ç[‹Mü3Í_èO!üÿ‹å]ËÿU‹ì‹E…Àt3€8t.ƒ}tÿuPÿuè~ƒÄ]ÃÿuÿuÿuÿuPè{ƒÄ]ËE¹ÿÿÿ;Ár‹ÁPÿuè¾ÐYY]ËÿU‹ì‹E…Àt4fƒ8t.ƒ}tÿuPÿu肃Ä]ÃÿuÿuÿuÿuPè–ƒÄ]ËE¹ÿÿÿ;Ár‹ÁPÿuèÐYY]ËÿU‹ìW3ÿWWWÿuÿ±E…ÀuÿH±EPèÐ×ýÿY3ÀëJS‹]V;Øw‹ØjSè	p‹ðYY…öu
èá×ýÿÇëSÿuV葃Ä…Àt‹Î‹÷‹ùVè	ÿýÿY^‹Ç[_]ËÿU‹ìW3ÿWWWÿuÿ±E…ÀuÿH±EPèZ×ýÿY3ÀëJS‹]V;Øw‹ØjSè“o‹ðYY…öu
èk×ýÿÇëSÿuVèzƒÄ…Àt‹Î‹÷‹ùVè“þýÿY^‹Ç[_]ËÿU‹ìV‹u…öuè,×ýÿÇèìaÿÿ3Àë;ƒþÿv
è×ýÿÇ"ëêjÿuVÿuÿ±E;Æsà…ÀuÿH±EPè²ÖýÿYëÄ‹E^]ËÿU‹ìV‹u…öuèÍÖýÿÇèaÿÿ3Àë;ƒþÿv
è´ÖýÿÇ"ëêjÿuVÿuÿ±E;Æsà…ÀuÿH±EPèSÖýÿYëÄ‹E^]ËÿU‹ì‹Eÿ0‹Eÿ0è¡ÎYY]ËÿU‹ì‹Eÿ0‹Eÿ0èÃÎYY]ËÿU‹ìjÿuÿuÿuÿ±E]ËÿU‹ìjÿuÿuÿuÿ±E]ËÿU‹ì‹E…Àt0€8t+ƒ}tÿuPÿuè¿þÿÿƒÄ]ÃjjjÿuPè¿ýÿÿƒÄ]ËE¹ÿÿÿ;Ár‹ÁPÿuèÎYY]ËÿU‹ì‹E…Àt/3Éf9t(9MtÿuPÿuèÆþÿÿƒÄ]ÃQQjÿuPèßýÿÿƒÄ]ËE¹ÿÿÿ;Ár‹ÁPÿuèæÍYY]ËÿU‹ì‹E3ÉSVWf9t,‹u·>‹Îf…ÿt·‹×f;ÓtƒÁ·f…ÒuðƒÀ3Éf9uÚ3À_^[]ËÿU‹ì¡¨ÙF…Àuu‹U…ÒuèÕýÿÇèÔ_ÿÿ¸ÿÿÿ]ËM…ÉtâSVWjA_jZ+Ñ[·
f;Çr
f;ÃwƒÀ ·ðë‹ð·f;Çrf;ÃwƒÀ ·ÀƒÁf…ötf;ðtÈ·È_·Æ^+Á[]ÃjÿuÿuèƒÄ]ËÿU‹ìƒìMðSVÿuè®üÿ‹]…Ût‹u…öuèqÔýÿÇè1_ÿÿºÿÿÿé‹‹EôWƒ¸¨uBjAYjZ+ÞZ·3f;Ár
f;ÂwƒÀ ·øë‹ø·f;Árf;ÂwƒÀ ·ÀƒÆf…ÿt:f;øtÈë3·MôQPè©ÌMô·ø·[QPè–̃Ä·Àvf…ÿtf;øtÍ·×·À+Ð_€}ü^[t
‹Mðƒ¡Pý‹Â‹å]ËÿU‹ìQƒ}uè¨ÓýÿÇèh^ÿÿ3Àé V‹u…öuè‰ÓýÿÇèI^ÿÿ3Àé€SWèÒoÿÿ÷ØÛ3ÿWWjÿÿuC‰>WSÿh°E‰Eü…ÀuÿH±EPèÓýÿ3ÀëGÀPèXVÿÿ‹ðY…öt0ÿuüVjÿÿuWSÿh°E…ÀuÿH±EPèÛÒýÿYë‹M‹Æ‹÷3ÿG‰VèáUÿÿ‹ÇY_[^‹å]ËÿU‹ìQƒ}uèáÒýÿÇè¡]ÿÿ3Àé‡V‹u…öuèÂÒýÿÇè‚]ÿÿ3ÀëjWèoÿÿÿu÷Øÿƒ&GWèM«üÿ‰EüYY…ÀuÿH±EPèQÒýÿ3Àë8PèœUÿÿ‹ðY…öt!ÿuüVÿuWèS«üÿƒÄ…ÀuÿH±EPè ÒýÿY3ÿVè2Uÿÿ‹ÇY_^‹å]ËM3ÿ‹Æ‹÷G‰ëã‹ÿU‹ìÿuèUÿÿY]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6èíTÿÿƒ&Y^Ã3À9•À˃!ËÃ3À9•ÀËÿV‹ñÿ6èÂTÿÿƒ&Y^ËÿU‹ìQQSWj0j@èJVÿÿ‹ø3Û‰}øYY…ÿu‹ûëH‡;øt>Vw ‹øSh FàPè£sÿÿƒNøÿ‰v0‰^ÔFàÇFØ

ÆFÜ
€fÝøˆ^Þ;ÇuÌ‹}ø^SèKTÿÿY‹Ç_[‹å]ËÿU‹ìV‹u…öt%SžW‹þ;ótWÿ¼±EƒÇ0;ûuòVèTÿÿY_[^]Ãjh¸§Fèf&üÿ} À÷Øuè
Ñýÿj	^‰0èË[ÿÿ‹Æè‰&üÿÃ3ö‰uäjèlˆÿÿY‰uü‹þ¡¨ÜF‰}à9E|94½¨ÚFu1èôþÿÿ‰½¨ÚF…Àuj^‰uäÇEüþÿÿÿè묡¨ÜFƒÀ@£¨ÜFG뻋uäjèZˆÿÿYËÿU‹ì‹E‹Èƒà?ÁùkÀ0¨ÚFPÿ´±E]ËÿU‹ìQSV‹u…öxi;5¨ÜFsa‹Æ‹Þƒà?ÁûkÈ0‹¨ÚF‰Müƒ|ÿuCWègóþÿ‹}ƒøu"ƒîtƒît
ƒîuWjôëWjõëWjöÿ|°E‹¨ÚF‹Mü‰|3À_ëèðÏýÿÇ	èÒÏýÿƒ ƒÈÿ^[‹å]ËÿU‹ì‹E‹Èƒà?ÁùkÀ0¨ÚFPÿ¸±E]Ãjh˜§Fèô$üÿjè#‡ÿÿYƒÏÿ‰}ä3Û‰]ü‰]Ôû€}M‹¨ÚF‰EØ…ÀuSè¢ýÿÿ‰¨ÚF…Àt/ƒ¨ÜF@‹ûÁçWèÌþÿÿY‹×Áú‹Çƒà?kÈ0‹•¨ÚFÆD(‰}äÇEüþÿÿÿ膋Çè¼$üÿÈ‰Mà‹ðj0X‰uÜ;ñt`öF(uVÿ´±EöF(tVÿ¸±E‹Màj0XðëÕ+uØ‹Æ™j0Y÷ùÁã4‹ÖÁú‹Îƒá?kÉ0‹•¨ÚFÆD(‹•¨ÚF‰|‹þétÿÿÿCéÿÿÿ‹}äjèn†ÿÿYËÿU‹ìSV‹uW…öxg;5¨ÜFs_‹Æ‹þƒà?ÁÿkØ0‹½¨ÚFöD(tDƒ|ÿt=è›ñþÿƒøu#3À+ðtƒît
ƒîuPjôëPjõëPjöÿ|°E‹½¨ÚFƒLÿ3Àëè)ÎýÿÇ	èÎýÿƒ ƒÈÿ_^[]ËÿU‹ì‹MƒùþuèîÍýÿƒ èùÍýÿÇ	ëC…Éx';
¨ÜFs‹Áƒá?ÁøkÉ0‹…¨ÚFöD(t‹D]Ãè®Íýÿƒ è¹ÍýÿÇ	èyXÿÿƒÈÿ]Ãjhx§Fèç"üÿ2ÛöEt€Ã ÷E@t€Ë€öE€t€Ëÿuÿì±E…ÀuÿH±EPè.ÍýÿYƒÈÿéƒøu€Ë@ëƒøu€ËèŽýÿÿ‹ð‰uàƒþÿuè5ÍýÿÇèÍýÿƒ ëÂÆEçƒeüÿuVè§üÿÿYY€Ë‹ÖÁú‹Æƒà?kÈ0‹•¨ÚFˆ\(‹•¨ÚFÆD)‹•¨ÚF€d-þ°ˆEçÇEüþÿÿÿè‹ÆèW"üÿËuàŠEç„Àu‹ÖÁú‹Æƒà?kÈ0‹•¨ÚF€d(þVèÄüÿÿYËÿU‹ìƒì<¡ÀF3ʼnEüS‹]V‹uîlWƒþFŒ+þŠ‡Cÿƒø‡ÿuCÿPV‰EÈèƒÄ„À„øƒ}‡îƒ};‡äƒ};‡Ú‹<€LF}Vèé”ÿÿY„Àtƒû~Gè3éÿÿ3ÛEÔP‰]Ô‰]Љ]ÌèÛÿÿY…À…¼EÐPè4ÛÿÿY…À…ªEÌPèNÛÿÿY…À…˜Vè0Üÿÿ‹UÇ‹]YiÎmÃëk|ÈkÁ‹MÁkÀ<ÂkÀ<EÌ؉]Ä]Ѓ} u‹ÃëEƒ} ÿ‹EȉEè‹E‰}ô‰uì‰Mà‰U܉EØuƒ}ÔtEØPèÔèÿÿY…ÀuÊ‹EÄëèAËýÿǃÈÿ‹Mü_^3Í[è—üÿ‹å]ÃSSSSSèVÿÿÌ‹ÿU‹ìƒìH¡ÀF3ʼnEüS‹]V‹uîlWƒþFŒŒ‹Æ™…Ò‡r=L‡tCÿƒø‡hÿuCÿPV‰E¸è„ƒÄ„À„Mƒ}‡Cƒ};‡9ƒ};‡/‹<€LF}Vè^“ÿÿY„Àtƒû~Gè¨çÿÿ3ÛEÌP‰]̉]ȉ]ÄèÙÿÿY…À…EÈPè©ÙÿÿY…À…EÄPèÃÙÿÿY…À…ïVè¥ÚÿÿY¹€Q÷éj<‹Ø‹Ê‹Çº€Q÷êØ‹Æʺ€3á÷êØʺ‰MÔ‹M‹Á÷ê؉]ÐUÔ‹]‹ÃZ÷êEЋEÄUÔ™EЋEUÔ™EЋEÔÂmДƒƒØ‰EÔ‹EÈ™EЉEÀUÔƒ} ‰U¼tRƒ} ÿ‹E¸‰Eè‹E‰}ô‰uì‰Mà‰]܉EØuƒ}ÌtEØPèÿæÿÿY…Àt‹EÀ‹U¼ë‹EЋUÔëèaÉýÿǃÈÿЋMü_^3Í[èµüÿ‹å]ÃSSSSSè3TÿÿÌ‹ÿU‹ìƒ}2À]ÃW‹}‹½ˆLF+½„LF9E~ÿuèå‘ÿÿY„Àtƒÿu
ƒ}°ë2À_]ËÿU‹ì]éMüÿÿ‹ÿU‹ì]éÁýÿÿ‹ÿU‹ì‹M…Éxƒù~ƒùu¡ÈÞF]áÈÞF‰
ÈÞF]Ãè®ÈýÿÇènSÿÿƒÈÿ]ËÿU‹ìV‹uW…öt‹M…Ét‹}…ÿu3Àf‰èxÈýÿj^‰0è9Sÿÿ‹Æ_^]ËÖfƒ:tƒÂƒéuò…ÉtÒ+ú·f‰Rf…Àtƒéuì3À…ÉuÌf‰è0Èýÿj"붋ÿU‹ìSVW‹}…ÿt‹M…Ét‹]…Ûu3Àf‰èÈýÿj^‰0èÆRÿÿ_‹Æ^[]Ë×3öf92tƒÂƒéuó…ÉtÐ+Ú·f‰Rf…Àtƒéuì…ÉuÊ3Àf‰è»Çýÿj"ë´‹ÿU‹ìQ‹U‹MV…Òu
…Éu
9Mu&3Àë3…Ét‹E…Àt…Òu3Àf‰ëæ‹u…öu3Àf‰èrÇýÿj^‰0è3Rÿÿ‹Æ^‹å]ÃS+ñ‹ØW‹ùƒúÿu·>f‰f…Àt,ƒëuìë%·>f‰f…Àt
ƒëtƒêuç…Ò‹Uu3Àf‰_…Û[…rÿÿÿƒúÿu‹E3ÒjPf‰TAþXë•3Àf‰èñÆýÿj"ézÿÿÿ‹ÿU‹ì]é(ÿÿÿ‹ÿU‹ìƒìSVè‰nÿÿŠØÿœ±E‹u…Àt…ötVÿ±E„ÛtjXéžèâlÿÿ„Àuÿœ±E÷ØÀ÷؃Àé„ÛtQ‹EW3ÿ‰Eð‹EWW‰EøEðPhÙlDWW‰uô‰}üÿü°E‹ðƒþÿtWjÿVÿ±E…Àu‹}üƒþÿtVÿ<±E‹Ç_ë,èFmÿÿ„Àu‹E
 PÿuVjë
è‡lÿÿÿuÿuVPèsjÿÿ^[‹å]ËÿU‹ìƒìSVè°mÿÿŠØÿœ±E‹u…Àt…ötVÿ±E„ÛtjXéžè	lÿÿ„Àuÿœ±E÷ØÀ÷؃Àé„ÛtQ‹EW3ÿ‰Eð‹EWW‰EøEðPhûlDWW‰uô‰}üÿü°E‹ðƒþÿtWjÿVÿ±E…Àu‹}üƒþÿtVÿ<±E‹Ç_ë,èmlÿÿ„Àu‹E
 PÿuVjë
è®kÿÿÿuÿuVPèãiÿÿ^[‹å]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èviÿÿ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èŸiÿÿ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0è6iÿÿ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0è_iÿÿ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èöhÿÿ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿ0èiÿÿ]ËÿU‹ìV‹uÿvÿ6ÿvjè¼hÿÿ‰F3À^]‹ÿU‹ìV‹uÿvÿ6ÿvjèãhÿÿ‰F3À^]‹ÿU‹ì‹Eÿ0ÿ±E]ËÿU‹ì‹Eÿ0ÿ±E]ËÿU‹ì]éýÿÿ‹ÿU‹ì]ééýÿÿ‹ÿU‹ì‹E;EvƒÈÿ]ÃÀ÷Ø]ËÿU‹ì‹E;EvƒÈÿ]ÃÀ÷Ø]ËÿU‹ì‹Eƒì V…ÀuèªÃýÿj^‰0èkNÿÿ‹ÆéX‹u3ÉSW‰‹ù‹Ù‰}à‰]ä‰Mè9tVEüfÇEü*?Pÿ6ˆMþèõ¼YY…ÀuEàPjjÿ6èôƒÄëMàQPÿ6èƒÄ‹ø…ÿ…ëƒÆ3É9u°‹]ä‹}àƒeø‹Ã+ljMü‹ÐƒÀÁúBÁè;߉Uôö÷Ö#ðt0‹×‹Ù‹
A‰EüŠA„Àuù+MüC‹EøÙƒÂ@‰Eø;ÆuÝ‹Uô‰]ü‹]äjÿuüRèáíþÿ‹ðƒÄ…öuƒÏÿëg‹Eô†‰Eð‹Ð‰Uô;ûtN‹Æ+ljEì‹A‰EøŠA„Àuù+MøAPÿ7‰Eø‹Eð+ÂEüPRè3èÿÿƒÄ…Àu6‹Eì‹Uô‰8ƒÇUø‰Uô;ûu¹‹E3ÿ‰0jè3EÿÿYMàè‹Ç_[^‹å]Ã3ÀPPPPPè(MÿÿÌ‹ÿU‹ìƒì0¡ÀF3ʼnEü‹E‰EÔV‹u…Àuè
Âýÿj^‰0èËLÿÿ‹Æé{3ÉSW‰‹ù‹Ù‰Mä‰}؉]܉Mà9taj*Xf‰Eôj?Xf‰Eö3Àf‰EøEôPÿ6èMìÿÿYY…ÀuEØP3ÀPPÿ6è߃ÄëMØQPÿ6èðƒÄ‹ø…ÿ…ƒÆ3É9u¥‹]Ü‹}؋ÉMì+Ç3ɋЉMðÁúƒÀBÁè;߉Uèö÷Ö#ðt8‹]ì‹×‹
A‰Eìf‹ƒÁf;Eäuô+MìC‹EðƒÂÑùÙ@‰Eð;ÆuÖ‹Uè‰]ì‹]ÜjÿuìRè-ìþÿ‹ðƒÄ…öuƒÏÿëw‹E膉EЋЉUè;ût\‹Æ+ljEô‹A‰Eðf‹ƒÁf;Eäuô+MðÑùA‹Ê+MÐPÿ7‰Eð‹EìÑù+ÁPRèÐùÿÿƒÄ…ÀuD‹Eô‹Uè‰8ƒÇ‹EðB‰Uè;ûu«‹EÔ‰03À‹øPèpCÿÿYMØèv‹Ç_[‹Mü3Í^èßüÿ‹å]Ã3ÀPPPPPè[KÿÿÌ‹ÿU‹ìQ‹MQŠA„Àuù+ʃÈÿW‹}A+ljMü;ÈvjXëYSV_ÙjSè­Dÿÿ‹ðYY…ÿtWÿuSVèÏåÿÿƒÄ…Àu5ÿuü+ß>ÿuSPè¶åÿÿƒÄ…Àu‹MVèUj‹ðèÈBÿÿY‹Æ^[_‹å]Ã3ÀPPPPPèÅJÿÿÌ‹ÿU‹ìQ‹MSW3ÛQf‹ƒÁf;Ãuõ‹}+ÊÑùƒÈÿA+ljMü;ÈvjXëWV_ÙjSèDÿÿ‹ðYY…ÿtWÿuSVèøÿÿƒÄ…Àu5ÿuü+ß~ÿuSPètøÿÿƒÄ…Àu‹MVèìj‹ðè*BÿÿY‹Æ^_[‹å]Ã3ÀPPPPPè'JÿÿÌ‹ÿU‹ììP¡ÀF3ʼnEü‹MS‹]V‹uW‰µ¸þÿÿëŠÿtÿ6ÿø°Eƒÿ^ËÿVW‹ù‹7ëÿ6è=ÿÿYƒÆ;wuðÿ7èõ<ÿÿY_^ËÿVW‹ù‹7ëÿ6èà<ÿÿYƒÆ;wuðÿ7èÐ<ÿÿY_^øWmDøomDËÿU‹ìŠEÿtÿ6ÿø°Eƒÿ^ËÿU‹ìÿuÿø°E÷ØÀ÷Ø]ËAËAËÿV‹ñW‹~9~t3Àërƒ>u+jjèW=ÿÿj‰è®;ÿÿ‹ƒÄ…ÀujXëM‰FƒÀ‰FëÌ+>ÁÿÿÿÿÿwãSj?Sÿ6èr8ƒÄ…Àuj^ë‰¸˜‰N‰F3öjèW;ÿÿY‹Æ[_^ËÿV‹ñW‹~9~t3Àërƒ>u+jjèÐ<ÿÿj‰è';ÿÿ‹ƒÄ…ÀujXëM‰FƒÀ‰FëÌ+>ÁÿÿÿÿÿwãSj?Sÿ6èë7ƒÄ…Àuj^ë‰¸˜‰N‰F3öjèÐ:ÿÿY‹Æ[_^ËÃÈÿËÿU‹ì]霱‹ÿU‹ì‹EƒÀþ]ËA+ÁøËA+ÁøËÿU‹ì]é2±‹ÿU‹ì]é*âÿÿ‹ÿU‹ì]éÓóÿÿ‹ÿU‹ì]éXõÿÿjhø§FèÅüÿ‹Eÿ0èñnÿÿYƒeü‹MèŽÇEüþÿÿÿèèãüÿÂ‹Eÿ0èoÿÿYËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPè™ÿÿÿ‹å]ËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]Âÿ1è©nÿÿYÃÿ1èXnÿÿYËÿV‹ñj‹‹‹@H‹@£ÐÞF‹‹‹@H‹@£ÔÞF‹‹‹@H‹€£ÌÞF‹‹‹@HƒÀPjhØÞFè*‹¹Q‹‹@HƒÀPQh¨ÄF苹Q‹‹@HPQh°ÅFèð¡ÐÈFƒÄ0ƒÉÿðÁu¡ÐÈF=°ÆFtPè9ÿÿY‹‹‹@H£ÐÈF‹‹‹@Hðÿ^ËÿU‹ì‹E-¤t(ƒètƒè
tƒèt3À]áF]áüF]áøF]áôF]ËÿU‹ìƒìMðjè¿üÿƒ%äÞF‹EƒøþuÇäÞFÿà°Eë,ƒøýuÇäÞFÿ²Eëƒøüu‹EôÇäÞF‹@€}üt
‹Mðƒ¡Pý‹å]ËÿU‹ìS‹]VWh3ÿsWVèüÿ‰{3À‰{ƒÄ‰»¹{«««¿°ÆF+ûŠ7ˆFƒéuõ‹ºŠ9ˆAƒêuõ_^[]ËÿU‹ìì ¡ÀF3ʼnEüSV‹u…èøÿÿWPÿvÿÜ°E3Û¿…À„ð‹Ãˆ„üþÿÿ@;ÇrôŠ…îøÿÿîøÿÿÆ…üþÿÿ ë¶Q¶Àë
;Çs
Æ„üþÿÿ @;ÂvïƒÁŠ„ÀuÝSÿv…üøÿÿPW…üþÿÿPjSèÄSÿv…üýÿÿWPW…üþÿÿPWÿ¶SèdtƒÄ@…üüÿÿSÿvWPW…üþÿÿPhÿ¶SèÿÿÿƒÄ]ËÿU‹ìƒ}	uj@X]Ãjj@ÿujèÿÿÿƒÄ]ËÿU‹ìƒ}	uj@X]Ãjj@ÿuÿuè÷þÿÿƒÄ]ËÿU‹ìjhÿujèÜþÿÿƒÄ]ËÿU‹ìjhÿuÿuèÀþÿÿƒÄ]ËÿU‹ìjjÿujè¨þÿÿƒÄ]ËÿU‹ìjjÿuÿuèþÿÿƒÄ]ËÿU‹ìjÿuèYY]ËÿU‹ìƒìÿuMðè>‡üÿ‹Eø…Àtx¤ujjÿuÿuèEþÿÿƒÄ‹Èë3É€}üt
‹Eðƒ Pý‹Á‹å]ËÿU‹ìjjÿujèþÿÿƒÄ]ËÿU‹ìjjÿuÿuèúýÿÿƒÄ]ËÿU‹ìjjÿujèâýÿÿƒÄ]ËÿU‹ìjjÿuÿuèÉýÿÿƒÄ]ËÿU‹ìjjÿujè±ýÿÿƒÄ]ËÿU‹ìjjÿuÿuè˜ýÿÿƒÄ]ËÿU‹ìjhWÿujè}ýÿÿƒÄ]ËÿU‹ìjhWÿuÿuèaýÿÿƒÄ]ËÿU‹ìjjÿujèIýÿÿƒÄ]ËÿU‹ìjjÿuÿuè0ýÿÿƒÄ]ËÿU‹ìjjÿujèýÿÿƒÄ]ËÿU‹ìjjÿuÿuèÿüÿÿƒÄ]ËÿU‹ì‹E‰‹Á]‹ÿV‹ñƒ>tÿ6ÿÔ°Eƒ&^Ã3À9•ÀËÿV‹ñƒ>tÿ6ÿÔ°Eƒ&^ËÿU‹ìÿuÿÔ°E°]ËÿU‹ì‹UW3ÿf9:t!V‹Êqf‹ƒÁf;Çuõ+ÎÑùJƒÂf9:uá^B_]ËÃ3ÀÃ3À9•ÀËÿU‹ìQSVWÿØ°E‹ð3ÿ…ötVVèžÿÿÿYWWW‹ØW+ÞÑûSVWWÿرE‰Eü…Àt4Pè.ÿÿ‹øY…ÿt3ÀPPÿuüWSVPPÿرE…Àt‹ß3ÿë3ÛWèµ-ÿÿYë‹ß…ötVÿÔ°E_^‹Ã[‹å]ËÿVWÿØ°E‹ð…öu3ÿë7SVèÿÿÿ+ÆÑøSè®-ÿÿ‹øYY…ÿtSVWèùçƒÄjèZ-ÿÿYVÿÔ°E[‹Ç_^øìÞFËÿU‹ìÿuè9-ÿÿY]‹ÿU‹ìÿuè'-ÿÿY]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6èö,ÿÿƒ&Y^ËÿV‹ñÿ6èä,ÿÿƒ&Y^˃!˃!ËÿV‹ñÿ6èÆ,ÿÿƒ&Y^ËÿV‹ñÿ6è´,ÿÿƒ&Y^ËÿU‹ìQèâpÿÿ‹HL‰MüMüQPè-rÿÿ‹EüYY‹@‹å]ËÿU‹ìQè»pÿÿ‹HL‰MüMüQPèrÿÿ‹EüYY‹@‹å]ËÿU‹ìQè”pÿÿ‹HL‰MüMüQPèßqÿÿ‹EüYY ‹å]ËÿU‹ìQèkpÿÿ‹HL‰MüMüQPè¶qÿÿ‹EüYY‹@‹å]ËÿU‹ì‹E…Àu]éÇÿÿÿ‹‹@]ËÿU‹ìƒìH¡ÀF3ʼnEüSV‹u3ÛW‰uĉ]ä‹Ž¨‰]à‰]܉]Љu¸‰]¼…É„F‰]Ø9uPhQE¸SPè2¤ƒÄ…À…»jjè+-ÿÿS‰EØè‚+ÿÿj¿€Wè-ÿÿS‰Eäèl+ÿÿjWè-ÿÿS‰Eàè[+ÿÿjWèó,ÿÿS‰EÜèJ+ÿÿjhèÞ,ÿÿ‹øS‰}Ðè3+ÿÿƒÄ<9]Ø„N9]ä„E…ÿ„=9]à„49]Ü„+‹Ãˆ8@=|õEèPÿvÿÜ°E…À„	‹Eèƒø‡ýSÿv·ÀO‰EÔºÿ‹EàRPRQhÿ¶¨SèægƒÄ$…À„ËEܹÿSÿvQPQGPhÿ¶¨Sè²gƒÄ$…À„ƒ}Ô~+8]ît&MÀt¶Qÿ¶ÀëÆ: B¶;Ð~ôƒÁ8YÿuÝ‹EäSÿvPhWjS‰EÈ藃ąÀ„5‹Uä3É‚þf‰‹Mà‰Eä‹E܈Yƒé€ƒ}ÔˆX‰MÀˆˆ€‰M̈~@8]ît;MÀt/¶qÿ¶À;ðºžð‹EüƒÀ(PjWEèjPè'žƒÄPð‹EüƒÀ)PjWEèjPè
žð‹EüƒÀ*PjTWEèjPèöð‹EüƒÀ+PjUWEèjPèßð‹EüƒÀ,PjVWEèjPèȃÄPð‹EüƒÀ-PjWWEèjPè®ð‹EüƒÀ.PjRWEèjPè—ð‹EüƒÀ/PjSWEèjPè€ð‹EüƒÀ8PjWjEèPèiƒÄPð‹EüƒÀ$ÿÿ‹EôPè5$ÿÿƒÄérýÿÿ‹Uð‹ëŠ<0|<9,0ˆB€:uìë"<;uô‹òŠFˆv€>uóëä‹}ü¾àÈFjY󥋃ˆ3É‹uüA‹}ô‹‰‹ƒˆ‹@‰F‹ƒˆ‹@‰F‹ƒˆ‹@0‰F0‹ƒˆ‹@4‰F4‹Eø‰…ÿt‰‹ƒ„…Àtðÿ‹K|…ÉtƒÈÿðÁuÿ³ˆèx#ÿÿÿs|èp#ÿÿYY‹Eø‰C|3À‰»„‰³ˆ_^[‹å]ËÿU‹ì‹U€:tVŠ<0|<9
,0ˆB€:uì^]Ã<;uó‹òŠFˆv€>uóëã‹ÿU‹ìV‹u…ötY‹;àÈFtPèü"ÿÿY‹F;äÈFtPèê"ÿÿY‹F;èÈFtPèØ"ÿÿY‹F0;ÉFtPèÆ"ÿÿY‹F4;ÉFtPè´"ÿÿY^]ËÿU‹ìƒìS‹]3ÀVW‰]è‰Eì9ƒ°u9ƒ¬u‹ø‰Eø¾àÈFéV3öFjPV‰uôè
$ÿÿ‰EüYY…Àu‹Æé~‹³ˆ‹øjYó¥jèƒ"ÿÿ‹ð3ÿW‰uøè<"ÿÿYY…öuÿuüè."ÿÿ3ÀY@éF‰>9»°„TjèJ"ÿÿ‹ðW‰uðè"ÿÿYY…ö„ÿuü‰>Eè‹»°jWjPèuš‹Mü‹ðƒÁEèQjWjPè^šð‹EüƒÀPjW‰EôEèjPèDšð‹EüƒÀ0PjWEèjPè-šƒÄPð‹EüƒÀ4PjWEèjP蚃ÄÆt%ÿuüèXþÿÿƒMôÿYÿuüèd!ÿÿ‹MøQè[!ÿÿ‹EôYYëu‹Uô‹ëŠ<0|o<9k,0ˆB€:uì‹}ð‹uü‹Mø3À@‰…ÿt‰‹ƒ€…Àtðÿ‹K|…ÉtƒÈÿðÁuÿs|è!ÿÿÿ³ˆèõ ÿÿYY‹Eø‰C|3À‰»€‰³ˆ_^[‹å]Ã<;u•‹òŠFˆv€>uóë…‹uü¡àÈF‰¡äÈF‰F¡èÈF‰F¡ÉF‰F0¡ÉF‰F4éaÿÿÿ‹ÿU‹ì‹U€:tVŠ<0|<9
,0ˆB€:uì^]Ã<;uó‹òŠFˆv€>uóëã‹ÿU‹ìÿuèM ÿÿY]‹ÿU‹ìjÿuè“YY]ËÿU‹ìjÿuè€YY]ËÿU‹ìjÿuèmYY]ËÿU‹ìjÿuèZYY]ËÿU‹ìjÿuèGYY]ËÿU‹ìjÿuè4YY]ËÿU‹ì‹E‰‹Á]‹ÿV‹ñÿ6èºÿÿƒ&Y^Ã3À9•À˃!ËÿU‹ì‹ESV‹uW3ÿ†‹È+΃ÁÁé;ÆÛ÷Ó#Ùtÿ6èxÿÿGvY;ûuð_^[]ËËÿU‹ìW‹}ƒ¿´u¸Fë5Vhdjèá ÿÿ‹ðYY…ötWVè,YY„ÀuVè·Y3ÿVèÿÿY‹Ç^_]Ãdž°‹þ3öëã‹ÿU‹ìƒì‹EƒeðSV‹°´WV‰uø‰Eìè<ÜþÿY‹M3Ûj1‰`XjZ‰Eü‰Uôë‹M‹÷j_ƒÀÐ3Ò÷÷‹ú¹PÿuüEìVjPè7—‹uüØ‹EƒÆù¸ƒÀPVÿuøEìjPè—Ø‹E¸´PÿuüEìÿuøjPè÷–Ø‹E¸‹}øÐPVWEìjPèÙ–؃ÄP‹Eü@ƒmô‰Eü…hÿÿÿ‹Ej8^ƒÀh‰uø‰EüÇEôƒÀЃÆPVWEìjPè™–ÿuüØEìÿuøWjPè…–Ø‹Eü„PVWEìjPèm–‹uøØ‹Eü´PVWEìjPèR–؃ÄP‹EüƒÀFƒmô‰Eü‰uøu‹u†˜Pj(WEìjPè"–؆œPj)WEìjPè–؆LPj(WEìjPèô•؆PPj)WEìjPèÝ•ƒÄP؆ PjWEìjPèÕ؆¤Pj WEìjP謕؆¨PhWEìjPè’•؆¬Ph	WEìjPèx•ƒÄP؆TPjWjEìPè^•؆XPj WEìjPèG•؆\PhWEìjPè-•ƒÄ<Ã÷ØÀ_^@[‹å]Ã3À9•ÀËÿV‹ñÿ6èuÿÿƒ&Y^ËÿU‹ìV‹u…ö„ÐjVè°üÿÿFjPè¥üÿÿF8jPèšüÿÿFhjPèüÿÿ†˜jPèüÿÿÿ¶ èÿÿÿ¶¤èÿÿÿ¶¨èÿÿ†´jPèRüÿÿ†ÐjPèDüÿÿƒÄD†ìjPè3üÿÿ†jPè%üÿÿ†LjPèüÿÿÿ¶Tè²ÿÿÿ¶Xè§ÿÿÿ¶\èœÿÿÿ¶`è‘ÿÿƒÄ(^]ËÿU‹ìVW‹}ƒ¿´u¾FëMhdjèÿÿ‹ðYY…öuPèWÿÿëWVèHüÿÿYY„ÀuVèÓþÿÿVè<ÿÿY3À@ë%jdž°è%ÿÿYÿ·œèÔ‰·œ3ÀY_^]ËÿU‹ìQ‹M3ÒSVW‹Áf9t0‹}·‹÷f…Ût·‰Uü‹Óf9UütƒÆ·f…Òuï3ÒƒÀf9uÖ_+Á^Ñø[‹å]ËÿU‹ì‹E…Àu]ËM‹UVƒèt·2f…öt
f;1uƒÂƒÁëæ··	+Á^]ËÿU‹ìƒì¡ÀF3ʼnEüSVWÿuMèèzqüÿ‹M…Éu‹Eì‹@‹È‰E3À3ÿ9E WWÿu•ÀÿuÅPQÿh°E‰Eø…À„™K;ÙÀ…ÁtJK;ÙÀ#ÁK=w;ÙÀ#Áè­Ò‹ô…öt`ÇÌÌë;ÙÀ#ÁPèÿÿ‹ðY…ötEÇÝ݃Æë‹÷…öt4SWVè#õûÿƒÄÿuøVÿuÿujÿuÿh°E…ÀtÿuPVÿuÿp±E‹øVèu}ÿÿY€}ôt
‹E胠Pý‹ÇeÜ_^[‹Mü3ÍèðÞûÿ‹å]ËÿU‹ì‹Eðÿ@‹H|…Étðÿ‹ˆ„…Étðÿ‹ˆ€…Étðÿ‹ˆŒ…ÉtðÿVjH(^yøÃFt	‹…Òtðÿƒyôt
‹Qü…ÒtðÿƒÁƒîuÖÿ°œèNY^]ËÿU‹ìQSV‹uW‹†ˆ…Àtl=àÈFte‹F|…Àt^ƒ8uY‹†„…Àtƒ8uPèªÿÿÿ¶ˆè’ðÿÿYY‹†€…Àtƒ8uPèˆÿÿÿ¶ˆèdõÿÿYYÿv|èsÿÿÿ¶ˆèhÿÿYY‹†Œ…ÀtEƒ8u@‹†-þPèFÿÿ‹†”¿€+ÇPè3ÿÿ‹†˜+ÇPè%ÿÿÿ¶ŒèÿÿƒÄÿ¶œè—YjXž ‰Eü~(øÃFt‹…Àtƒ8uPèâÿÿÿ3èÛÿÿYY‹Eüƒôt‹Gü…Àtƒ8uPè¾ÿÿY‹EüƒÃƒÇƒè‰Eüu°Vè¦ÿÿY_^[‹å]ËÿU‹ì‹M…ÉtùFt3À@ðÁ°@]øÿÿÿ]ËÿU‹ìV‹u…öt þFt‹†°…ÀuVèáúÿÿVèJÿÿYY^]ËÿU‹ì‹M…ÉtùFtƒÈÿðÁ°H]øÿÿÿ]ËÿU‹ì‹E…ÀtsðÿH‹H|…Étðÿ	‹ˆ„…Étðÿ	‹ˆ€…Étðÿ	‹ˆŒ…Étðÿ	VjH(^yøÃFt	‹…Òtðÿ
ƒyôt
‹Qü…Òtðÿ
ƒÁƒîuÖÿ°œèZÿÿÿY^]Ãjh¨FèôèûÿƒeäèÅZÿÿ‹ø‹
4ÉF…Pt‹wL…öuCjèKÿÿYƒeüÿ5ìÝFGLPè0YY‹ð‰uäÇEüþÿÿÿè…öuè•ÿÿ‹uäjèKÿÿYËÆèÐèûÿËÿU‹ìV‹uW…öt<‹E…Àt5‹8;þu‹Æë-V‰0è˜üÿÿY…ÿtïWèÖþÿÿƒYuâÿ@ÂFtÚWèõüÿÿYëÑ3À_^]ËÿU‹ìì°¡ÀF3ʼnEüV‹u…PÿÿÿjUPNè4ÿÿƒø~uf…ÿtf‹zf;~uƒÂƒÆf…ÿuÞ‹Ðë҃ʅÒt_¾Ð+F‹Ñf‹:f;>uf…ÿtf‹zf;~u
ƒÂƒÆf…ÿuÞëÀƒÈ…Àu"jEüP‹Eh PPè-ÿÿ…Àt+‹Eüë7Qè.ÿÿYë.jEüP‹Eh PPèæ,ÿÿ…Àu3Àë
‹Eü…Àuÿ²E_^‹å]ËÿU‹ìƒì¡ÀF3ʼnEüV‹uEèj	PjYVè§,ÿÿ…Àtj	EèVPè ôÿÿƒÄ÷ØÀ@‹Mü3Í^èÐÔûÿ‹å]ËÿU‹ìÿuè¨ÿÿÿY…Àu/9Et*‹EV‹‹ñVf‹ƒÆf…Àuõ+òQÑþè¸úÿÿY;Æ^u3À]Ã3À@]ËÿU‹ìQV‹u3ÒWB3ÿ…öxNS…ÒtH7™+‹؋EÑûkË‰Müÿ4‹Eÿ0賶ÿÿ‹ÐYY…Òu‹E‹MüƒÀÈ‹E‰ë
ysÿë{;þ~´[3À…Ò_”À^‹å]ËÿU‹ìQQSVWèÀRÿÿ‹]3ɉMøpP†P‰Nf‰~‰Eüƒ€‰‰f9tWjh°*FèIÿÿÿƒÄ3É‹Vf9tG‹f9tèäøÿÿëèwùÿÿ3ÀY9Fu2Vj@h 'FèÿÿÿƒÄ…Àt‹3ÉVf9tè²øÿÿëèEùÿÿëèøÿÿY3ÿ9~„ƒVPè_ýÿÿ‹ðYY…ö„óþèý„çþéý„Û·ÆPÿä°E…À„É‹E…Àt‰0‹}…ÿ„°‹MüŸ 3Àf‰Qf‹ƒÁf;Eøuô+ÊÑùAPÿuüjUSèÃÿÿƒÄ…À…ƒj@WhSè~*ÿÿ…Àthj@Ÿ€Sh‡ Pè`*ÿÿ…ÀtJj_SèöÆYY…Àuj.SèèÆYY…Àtj@Sj‡ Pè/*ÿÿ…Àtj
j‡PVè°'ƒÄ3À@ë3À_^[‹å]Ã3ÀPPPPPèÕÿÿÌ‹ÿU‹ììô¡ÀF3ʼnEüSV‹uWèàPÿÿ‹ØèÙPÿÿV‹¸Lè/Y‹Kd‹ð÷Ù…ÿÿÿjxÉáðÿÿPÁQVÿ,²E…Àu!@ë3…ÿÿÿPÿsTè<´ÿÿYY…ÀuVèY…Àt	ƒ‰w‰w‹Áè÷Ѓà‹Mü_^3Í[è¥Ñûÿ‹å]‹ÿU‹ìVWèKPÿÿ‹Ð3ÿ‹JTqf‹ƒÁf;Çuõ+Î3ÀÑùƒùj”Àhj§D‰Bdÿ8²E‹Eöu‰8_^]ËÿU‹ìV‹uÿ4²E‰F‰F^]ËÿU‹ìSVWèáOÿÿ‹ð3ÛjZ‹NPyf‹Êf;Ãuö+Ï3ÀÑùƒù‹NT”À‰F`yf‹Êf;Ãuö+Ï3À‹}Ñùƒù”À‰Fd‰_9^`uÿvPè—Y‹Ðjh¤©D‰V\ÿ8²E‹öÁ•Âºá	’À"кá’À„Ðu‰_^[]ËÿU‹ìSVWèFOÿÿ‹ð3ÛjZ‹NPyf‹Êf;Ãuö+Ï3ÀÑùƒù”À‰F`…ÀuÿvPè"Y‹Ðjhô«D‰V\ÿ8²E‹Eöu‰_^[]ËÿU‹ì‹M3Ò·ƒÁfƒøArfƒøZv	ƒÀŸfƒøwBëâ‹Â]ËÿU‹ììü¡ÀF3ʼnEüSV‹uWè¦Nÿÿ‹ØèŸNÿÿV‹¸LèõY‹Kd‹ð÷Ù…ÿÿÿjxÉáðÿÿPÁQVÿ,²E…Àuƒ'3À@éÔ…ÿÿÿPÿsTèü±ÿÿƒ¥ÿÿÿYY…À…­jx…ÿÿÿP‹C`÷ØÀ%ðÿÿPVÿ,²E…Àt¯…ÿÿÿPÿsP趱ÿÿYY…Àu‰wëdöubƒ{\tBÿs\…ÿÿÿPÿsPè9ƒÄ…Àu)ƒ‰w‹KPQf‹ƒÁf;…ÿÿÿuñ+ÊÑù;K\u‰wë‹öÂuVè3Y…ÀtƒÊ‰‰w‹¹#Á;Á„ì‹K`…ÿÿÿ÷ÙjxÉáðÿÿPÁQVÿ,²E…Àu‰éëþÿÿ…ÿÿÿPÿsPèï°ÿÿYY…Àuh‹9C`tʉ9Gé†9C\të‹KPA‰…ÿÿÿf‹ƒÁf;…ÿÿÿuñ+ÿÿÿÑù;K\uWjV袃Ä…ÀtN3Àë±3Àë¥3À9C`u99C\t4…ÿÿÿPÿsPèf°ÿÿYY…ÀuW3ÛSVèbƒÄ…Àt9_u‰w‹Áè÷Ѓà‹Mü_^3Í[èÄÍûÿ‹å]‹ÿU‹ììô¡ÀF3ʼnEüSV‹uWèVLÿÿ‹ØèOLÿÿV‹¸Lè¥Y‹K`‹ð÷Ù…ÿÿÿjxÉáðÿÿPÁQVÿ,²E…Àu!@ëb…ÿÿÿPÿsP貯ÿÿYY…Àu
9C`u5Wjë#ƒ{`u3ƒ{\t-…ÿÿÿPÿsP臯ÿÿYY…ÀuWPVè…ƒÄ…Àt	ƒ‰w‰w‹Áè÷Ѓà‹Mü_^3Í[èìÌûÿ‹å]‹ÿU‹ì‹UV3ö·
f…Ét9Wj_AŸRf;ÇwÁÙÿëA¿f;ÇwÁùÿ·ÉƒÁÐÁæñ·
f…ÉuÌ_‹Æ^]ËÿU‹ìQ‹MVW…É„ž3Àf9„“¾È+F‹Ñf‹:f;>uf…ÿtf‹zf;~uƒÂƒÆf…ÿuÞ‹Ðë҃ʅÒt]¾Ð+F‹Ñf‹:f;>uf…ÿtf‹zf;~u
ƒÂƒÆf…ÿuÞëÀƒÈ…Àu jEüP‹Eh ÿpÿ,²E…Àt)‹Eüë5QèÇ
ÿÿYë,jEüP‹Eh ÿpÿ,²E…Àu3Àë
‹Eü…Àuÿ²E_^‹å]ËÿU‹ì‹M3Àf;ˆØ+Ft
ƒÀƒørï3À@]Ã3À]ËÿU‹ìQVWè9Jÿÿ‹u‹øjEü‹ÎPáÿh ÉQÿ,²E…Àu3Àë0;uüt(ƒ}t"‹wPNf‹ƒÆf…ÀuõÿwP+ñÑþèòúÿÿY;ÆtÏ3À@_^‹å]ËÿU‹ìSV‹u3ÛW…öx13™+‹ø‹EÑÿkÏÿ4‹Eÿ0èV­ÿÿYY…Àtywÿë_;Þ~Ï2À_^[]ËMkÇƒÁÁ‹M‰°ëçÌ‹ÿU‹ìƒì¡ÀF3ʼnEü‹ES‹]V‹uW‰EèèRIÿÿƒÀP}ð‰Eì3À«««è?IÿÿMð3Ò‰ˆLŽ€‹Eì‰0x‰…Étf9t¡Ä+FWHPh°*Fè3ÿÿÿ‹EìƒÄ3Ò‰Uð‹…Àtnf9ti‹…Àtf9tEðPèñøÿÿë	EðPèùÿÿƒ}ðY…„¡¬*FÿuìHPh 'FèßþÿÿƒÄ„ÀtN‹3ÿ…Àtf98tEðPèªøÿÿë	EðPè:ùÿÿYë,‹…Àtf9tEðPèøÿÿYëÇEðÿ4²E‰Eø‰Eô3ÿƒ}ðu3À‹Mü_^3Í[è‘Éûÿ‹å]Ã3ÿEðP†÷Þö#ðVèàüÿÿ‹ðYY…ötÍþèýtÅþéýt½·ÆPÿä°E…Àt¯jÿuôÿ0²E…Àt ‹Eè…Àt‰0‹EìWjUPPÿuôèŠ#ÿÿ…Ût^WjUƒ Pÿuôèt#ÿÿj@Shÿuôÿ,²E…À„Tÿÿÿj@ƒ€Phÿuøÿ,²E…À„5ÿÿÿj
j‹QVèƒÄ3À@éÿÿÿ‹ÿU‹ìQèfGÿÿ‹HL‰MüMüQPè±Hÿÿ‹EüYY‹€ˆ‹å]ËÿU‹ì]é‹ÿU‹ìV‹u…ötjà3ÒX÷ö;EsèúýÿÇ3ÀëBS‹]W…ÛtSè>}Y‹øë3ÿ¯uVSèü?ÿÿ‹ØYY…Ût;þs+÷;VjPèÿÝûÿƒÄ_‹Ã[^]áøÞFÃÿаE…À£øÞF•ÀÃ%øÞF°áøÞFËÿU‹ìQ¡ÀF3ʼnEüW‹};}u°ëWV‹÷S‹…Ût‹ËÿвEÿÓ„ÀtƒÆ;uuä;uu°ë,;÷t&ƒÆüƒ~üt‹…Ût
j‹ËÿвEÿÓYƒîF;ÇuÝ2À[^‹Mü3Í_èqÇûÿ‹å]ËÿU‹ìQ¡ÀF3ʼnEüV‹u9ut#ƒÆüW‹>…ÿt
j‹ÏÿвEÿ×YƒîF;Euâ_‹Mü°3Í^è$Çûÿ‹å]áÀFƒàj Y+È3ÀÓÈ3ÀFËÿU‹ì¡ÀF‹È3EƒáÓÈ]ËÿU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]áÀFƒàj Y+È3ÀÓÈ3ÀFPèàYËÿU‹ìA‹Ð+уÂV3öÁê;ÁÀ÷Ð#Ât
‹UF‰I;ðuö^]‹ÁËÿU‹ìÿu¹üÞFèºÿÿÿ]ËÿU‹ìQ¡ÀF3ʼnEüVè.‹ð…ötÿu‹ÎÿвEÿÖY…Àt3À@ë3À‹Mü3Í^è,Æûÿ‹å]Ãjh8¨FèúÒûÿƒeäjè%5ÿÿYƒeü‹5ÀF‹Îƒá35üÞFÓΉuäÇEüþÿÿÿè‹ÆèÓûÿËuäjè45ÿÿYÃjhX¨Fè¨ÒûÿƒeäjèÓ4ÿÿYƒeü‹5ÀF‹Îƒá35üÞFÓΉuäÿuèªþÿÿY£üÞFÇEüþÿÿÿè‹Æè§ÒûÿËuäjèÔ4ÿÿYáÀFƒàj Y+È3ÀÓÈ3ÀFÃjhبFè0Òûÿƒeä‹Eÿ0èX4ÿÿYƒeü‹5ÀF‹Îƒá35ßFÓΉuäÇEüþÿÿÿè
‹Æè:ÒûÿÂ‹uä‹Mÿ1èb4ÿÿYËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPè‚ÿÿÿ‹å]ËÿU‹ì¡ÀF‹È3EƒáÓÈ]ËÿU‹ì¡ÀFƒàj Y+È‹EÓÈ3ÀF]ËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‹‰‹Á]Âÿ1è3ÿÿYáÀF‹È3ßFƒáÓÈÃÿ1è¼3ÿÿYÃjh¸¨Fè ·3ö‰uà‰uÜjèW3ÿÿY‰uü‹ÀF‹Â‹òƒà‹Èƒ}u»ßF35ßFjë
»ßF35ßFjÓΉuà_‰}Ü…ötƒþt
j Y+È3ÀÓÈ3‰ÇEüþÿÿÿè…öu3Àë#‹uà‹}Üjè*3ÿÿYÃþtW‹ÎÿвEÿÖY3À@èʶ‹ÿU‹ì‹EHƒèt-ƒètƒè	tƒètƒèt3À]øßF]øßF]øßF]øßF]ËÿU‹ìA‹Ð+уÂV3öÁê;ÁÀ÷Ð#Ât
‹UF‰I;ðuö^]‹ÿU‹ìk
(F‹EÈ;Át‹U9Pt	ƒÀ;Áuô3À]ËÿU‹ì‹Eƒøtƒøtƒø
tƒø~ƒø~èƒzýÿǃÈÿ]ËÁËÿU‹ìQEÿPjèÌýÿÿYY‹å]ËÿU‹ìÿu¹ßFèJÿÿÿÿu¹ßFè=ÿÿÿÿu¹ßFè0ÿÿÿÿu¹ßFè#ÿÿÿ]ÃèBAÿÿƒÀÃè9AÿÿƒÀÃj,h˜¨Fè?µ3Û‰]Ô!]̱ˆMã‹uj_;÷t5Fÿƒèt"Hƒèt'HƒèuLëƒþtƒþt
ƒþ~;ƒþ6VèxþÿÿƒÄëEèZAÿÿ‹Ø‰]Ô…ÛuƒÈÿé’ÿ3VèÈþÿÿYY3É…À•Á…Éuè‡yýÿÇèGÿÿëуÀ2ɈMã‰E؃eЄÉtjèà0ÿÿYŠMãƒeÜÆEâƒeü‹EØ„Ét‹ÀF‹Êƒá3ÓÊŠMã닋‰EÜ3Òƒø”‰UȈUâ„Ò…Š…Àu„ÉtjèÑ0ÿÿYjè±þÿ;÷t
ƒþtƒþu#‹C‰EЃc;÷u;è½þÿÿ‹‰EÌè³þÿÿÇŒ;÷u"k0Fk
4FȉEÄ;Át%ƒ`ƒÀëð¡ÀFƒàj Y+È3ÀÓÈ3ÀF‹M؉ÇEüþÿÿÿè1€}Èuk;÷u6è—?ÿÿÿpW‹MÜÿвEÿUÜYë+j_‹u‹]ÔŠEâ‰EÈ€}ãtjè0ÿÿYÃV‹MÜÿвEÿUÜY;÷t
ƒþtƒþu‹EЉC;÷uè;?ÿÿ‹M̉H3Àè³Ãjhx¨FèGÍûÿ‹]ƒû„‹ƒû„‚‹}ƒÿ„ºƒÿ„±ƒÿ„¨ƒÿ„Ÿƒÿ„–ƒÿtƒÿtƒÿtWé@èF?ÿÿ‹ð…ötï>˜Fu&ÿ5,Fè¤úþÿY‰…ÀtÕÿ5,Fh˜FPèç´ƒÄ‹‰EÜPWèüÿÿYY…Àt¯P‹
‰M؃ût"k5(FuÜ;Æt9züu‰ƒÂJø;Îuï‹MØ‹ÁéÅ3Ûˆ]ç‹ó‰u؉uàjèŽ.ÿÿY‰]üƒÿtƒÿu:€=ßFu1jhTµDÿÌ°E…Àt	ÆßFëèÅvýÿ‹ðÿH±E‰³ˆ]ç‹uØWè|ûÿÿƒÄ‰EØ…Àt&‹5ÀF‹Îƒá30ÓΉuà‹EƒøtPè<úÿÿY‹M؉ÇEüþÿÿÿè„Û…Óþÿÿ‹Æë‹}Š]ç‹uàjè0.ÿÿYÃÿuèµûÿÿYèèËûÿËÿU‹ì‹M3À„ÉyjXSVW¿…ÏtƒÈ÷ÁtƒÈ÷ÁtƒÈ÷ÁtƒÈ¾…Ît
‹Ñ»`#Ót!ú tú@t;Óu

ëÇëÆ_á@€^[ƒé@téÀtƒé@u
]Ã
]Ã
]ËÿU‹ì‹M3ÀöÁ?t2öÁtjXöÁtƒÈöÁtƒÈöÁtƒÈöÁ tƒÈöÁt
]ËÿU‹ìQQ®]ü‹EüƒàÀ‰Eø®Uø‹Mü3ÀöÁ?t2öÁtjXöÁtƒÈöÁtƒÈöÁtƒÈöÁ tƒÈöÁt
‹å]ËÿU‹ìƒìºS‹]VW‹}…ÿ„l›Ù}øf‹Eø3Ò¨tjZ¨tƒÊ¨tƒÊ¨tƒÊ¨ tƒÊ¨tÊ·ð‹Îát.ùt ùtùuÊëÊëÊætþuÊëʹf…ÁtÊ‹E‹Ë÷Ñ#Ã#ÊÈ;Ê„°QèÚ	Yf‰EüÙmü›Ù}üf‹Eü3ɨtjY¨tƒÉ¨tƒÉ¨tƒÉ¨ tƒÉ¨tÉ·ð‹Öât.út útúuÉëÉëÉætþuÉëɺf…Ât
É뺉‹u…ö„…ƒ=ÏFŒuã®]ð‹Mð3À„ÉyjX÷ÁtƒÈ÷ÁtƒÈ÷ÁtƒÈ…ÊtƒÈ÷Át
‹Ñ¿`#×t'ú tú@t;×u
ë
ë
j@á@€_+ÏtéÀt+Ïu
ë
ë
‹Ë#]÷Ñ#ÈË;È„µQèRP‰EôèÍpYY®]ô‹Mô3À„ÉyjX÷ÁtƒÈ÷ÁtƒÈ÷ÁtƒÈ÷ÁtƒÈ÷Át
‹Ñ»`#Ót'ú tú@t;Óu
ë
ë
á@€+ÏtéÀt+Ïu
ë
ë
‰ëƒ&_3À^@[‹å]ËÿU‹ìQQSVW‹}ç®]ø‹Mø3ö‹Æ„ÉyjX÷ÁtƒÈ÷ÁtƒÈ÷ÁtƒÈ÷ÁtƒÈ»…Ët
‹Ñâ`t(ú tú@tú`u
ë	
ëÃá@€ƒé@téÀtƒé@u
ë
ë
‹M‹×÷Ò#Ï#ÐÑ;Є®Rè»P‰Eüè6oYY®]ü‹Eü„Àyj^º…ÂtƒÎ©tƒÎ©tƒÎ©tƒÎ…Ãt΋ȿ`#Ït"ù tù@t;ÏuÎëòëó%@€ƒè@t-Àt
ƒè@uÎëÎë΋Æ_^[‹å]Ãh€è†nYËÿU‹ì‹M3ÀöÁt¸€SVW¿öÁtÇöÁt
öÁt
öÁt
¾÷ÁtÆ‹Ñ»#Ót;Öt;×t;Óu
`ë
@ë
 º_#Ê^[ùtùt;Êu
€]ÃÈ@]Ã
@€]Ãè¶m‹È3ÀöÁ?t2öÁtjXöÁtƒÈöÁtƒÈöÁtƒÈöÁ tƒÈöÁt
ËÿU‹ì‹M3ÀöÁtjXöÁtƒÈöÁtƒÈöÁtƒÈöÁ tƒÈöÁt
SV·ñ»‹ÖW¿ât%útútúu
Ãë	Çë
#ót;÷u
ë
_^[÷Át
]ËÿU‹ìf‹M3ÀöÁ?t2öÁtjXöÁtƒÈöÁtƒÈöÁtƒÈöÁ tƒÈöÁt
]ËÿU‹ìƒìÝ}üÛâƒ=ÏFŒƒf‹Eü3É‹ÑW¿¨?t)¨tjZ¨tƒÊ¨tƒÊ¨tƒÊ¨ tƒÊ¨t×®]ø‹EøƒàÀ‰Eô®Uô‹Eø¨?t)¨tjY¨tƒÉ¨tƒÉ¨tƒÉ¨ tƒÉ¨tÏÊ‹Á_ë=f‹Mü3ÀöÁ?t2öÁtjXöÁtƒÈöÁtƒÈöÁtƒÈöÁ tƒÈöÁt
‹å]ËÿU‹ìƒì›Ù}øf‹Eø3ɨtjY¨tƒÉ¨tƒÉ¨tƒÉ¨ tƒÉ¨tÉSV·ð»‹ÖW¿#Ót&útút;ÓuÉë
ÏëÉæt;÷uÉëɺf…ÂtÉ‹}‹÷‹E÷Ö#ñ#Çð;ñ„¦Vè‹Yf‰EüÙmü›Ù}üf‹Eü3ö¨tj^¨tƒÎ¨tƒÎ¨tƒÎ¨ tƒÎ¨tηЋÊ#Ët*ùtùt;ËuÎëÎëÎâtúuÎëκf…Ât΃=ÏFŒ‰ç®]ð‹Eð3É„ÀyjY©tƒÉ©tƒÉ©tƒÉ…ÂtƒÉ©tɋл`#Ót*ú tú@t;ÓuÉëÉëÉj@%@€[+Ãt-Àt+ÃuÉëÉëÉ‹Ç#}÷Ð#ÁÇ;Á„µPèûÿÿP‰Eôè™iYY®]ô‹Eô3É„ÀyjY©tƒÉ©tƒÉ©tƒÉ©tƒÉ©tɋп`#×t*ú tú@t;×uÉëÉëÉ%@€+Ãt-Àt+ÃuÉëÉëÉ‹ÁÎ3Æ©tÉ€‹Áë‹Æ_^[‹å]ËÿU‹ì‹E%ÿÿ÷ÿPÿuèèüÿÿYY]ËÿVènðÿÿ‹0Ûãè#½ûÿèúÿÿ…öt‹F÷tƒ` Ç@$ÿÿ^ËÿU‹ì‹M3ÀöÁt@öÁtƒÈöÁtƒÈöÁtƒÈöÁtƒÈ ÷ÁtƒÈV‹Ñ¾W¿#Öt#út;×t;Öu
ë
ë
‹ÑâtúuÇëÆ_^÷Át
]ËÿU‹ìQQ}	‹Mu;ƒùÿu6›Ù}üf‹Eüº=f#º=f;Âuƒ=ÏF|.®]ø‹Eø%Àþ=€tVáÿÿ÷ÿ3öQÿuVè¤ÂþÿƒÄ…Àu^‹å]ÃVVVVVèFôþÿÌ‹ÿU‹ìQQV›Ý}üf‹Uü3À‹È¾öÂ?t/öÂtjYöÂtƒÉöÂtƒÉöÂtƒÉö tƒÉöÂt΃=ÏF|?®]ø‹UøöÂ?t/öÂtjXöÂtƒÈöÂtƒÈöÂtƒÈö tƒÈöÂtÆÁë‹Á^‹å]ËÿU‹ìQ‹U…ÒtC›Ý}üf‹Mü3ÀöÁ?t2öÁtjXöÁtƒÈöÁtƒÈöÁtƒÈöÁ tƒÈöÁt
‰V‹u…ötè¤øÿÿ‰^‹å]ÃÌÌÌÌÌÌÌU‹ìWVS‹MÉtM‹u‹}·A³Z¶ IŠ&
äŠt'
Àt#ƒÆƒÇ:çr:ãwæ:Çr:ÃwÆ:àuƒéuÑ3É:àt	¹ÿÿÿÿr÷Ù‹Á[^_ÉËÿU‹ì]é_ìþÿ‹ÿU‹ì‹E3ÉS‹]V‹óW8Mt	AÆ-s÷Ø‹þ3Ò÷uƒú	v€ÂWë€Â0ˆFA…Àt;Mrá;MrÆèŒgýÿj"^‰0èMòþÿ‹ÆëÆNŠŠˆNˆG;þrò3À_^[]ËÿU‹ì‹E‹MSV3Û‹ðW8]tj-ZCf‰p÷Ù‹þ‹Á3Ò÷u‹ÈBWƒú	wB0f‰ƒÆC…Ét;]rÜ;]r‹E3Éf‰è
gýÿj"^‰0èËñþÿ‹Æë 3Àf‰ƒîf‹·f‰ƒîf‰ƒÇ;þrê3À_^[]ËÿU‹ìƒì‹M3À‹US‹]V‹ñ‰EüW8Et@Æ-÷Û‰EüqƒÒ÷Ú‹}ü‰uôjÿuRSè>ž‰]ü‹Øƒù	v€ÁWë€Á0ˆFG…Òu…Ût;}rÑ;}‹}ôr‹EÆè^fýÿj"^‰0èñþÿ‹ÆëÆNŠŠˆNˆG;þrò3À_^[‹å]ËÿU‹ìƒì‹M3À‹US‹]V‹ó‰EüW8Etj-Xf‰s3À@÷Ù‰EüƒÒ÷Ú‹}ü‰uøjÿuRQè—‰Mü‹È‹Eü‰]ôƒø	vƒÀWëƒÀ0f‰ƒÆG…Òu…Ét;}rÈ;}‹}ør‹E3Éf‰è¬eýÿj"^‰0èmðþÿ‹Æë 3Àf‰ƒîf‹·f‰ƒîf‰ƒÇ;þrê3À_^[‹å]ËÿU‹ì‹MV…Éuèeeýÿj^‰0è&ðþÿ‹Æë<‹U…Òtæ3ÀÆ8E•À@;Ðw	è;eýÿj"ëÔ‹uFþƒø"wÂÿuVRQÿuèDýÿÿƒÄ^]ËÿU‹ì‹MV…Éuèeýÿj^‰0èÇïþÿ‹Æë<‹U…Òtæ3À8Ef‰•À@;Ðw	èÜdýÿj"ëÔ‹uFþƒø"wÂÿuVRQÿuèZýÿÿƒÄ^]ËÿU‹ì‹MV…Éuè§dýÿj^‰0èhïþÿ‹Æë?‹U…Òtæ3ÀÆ8E•À@;Ðw	è}dýÿj"ëÔ‹uFþƒø"wÂÿuVRQÿuÿuè†ýÿÿƒÄ^]ËÿU‹ì‹MV…ÉuèEdýÿj^‰0èïþÿ‹Æë?‹U…Òtæ3À8Ef‰•À@;Ðw	èdýÿj"ëÔ‹uFþƒø"wÂÿuVRQÿuÿuèÆýÿÿƒÄ^]ËÿU‹ìQ3Àƒ}
u9E
|9EsÆEüëˆEüÿuüÿujÿÿuÿuÿuèåüÿÿ‹EƒÄ‹å]ËÿU‹ìQ3Àƒ}
u9E
|9EsÆEüëˆEüÿuüÿuÿuÿuÿuÿuè¿þÿÿƒÄ‹å]ËÿU‹ìQ3Àƒ}
u9E
|9EsÆEüëˆEüÿuüÿujÿÿuÿuÿuèýÿÿ‹EƒÄ‹å]ËÿU‹ìQ3Àƒ}
u9E
|9EsÆEüëˆEüÿuüÿuÿuÿuÿuÿuèþÿÿƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿujÿÿuÿuèæúÿÿ‹EƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿuÿuÿuÿuèýÿÿƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿujÿÿuÿuèïúÿÿ‹EƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿuÿuÿuÿuèýÿÿƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿujÿÿuÿuèúÿÿ‹EƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿuÿuÿuÿuè9üÿÿƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿujÿÿuÿuèúÿÿ‹EƒÄ‹å]ËÿU‹ìQƒ}
u
ƒ}ÆEü|ÆEüÿuüÿuÿuÿuÿuè,üÿÿƒÄ‹å]ËÿU‹ìjÿujÿÿuÿuÿuèLúÿÿ‹EƒÄ]ËÿU‹ìjÿuÿuÿuÿuÿuèGüÿÿƒÄ]ËÿU‹ìjÿujÿÿuÿuÿuè¬úÿÿ‹EƒÄ]ËÿU‹ìjÿuÿuÿuÿuÿuègüÿÿƒÄ]ËÿU‹ìjÿujÿÿuÿuèÈøÿÿ‹EƒÄ]ËÿU‹ìjÿuÿuÿuÿuèûÿÿƒÄ]ËÿU‹ìjÿujÿÿuÿuèùÿÿ‹EƒÄ]ËÿU‹ìjÿuÿuÿuÿuè.ûÿÿƒÄ]Ãjhx©FèµûÿƒeäjèªÿÿYƒeüÿuÿuÿuÿuÿuÿu胃Ä‹ð‰uäÇEüþÿÿÿè‹Æ胵ûÿËuäjè°ÿÿYÃjh˜©Fè$µûÿƒeäjèOÿÿYƒeüÿuÿuÿuÿuÿuÿuè̓Ä‹ð‰uäÇEüþÿÿÿè‹Æè(µûÿËuäjèUÿÿYËÿU‹ìQVW‹}…ÿuèw_ýÿj^‰0è8êþÿ‹ÆëTƒ'‹u…ötƒ&ƒ}tÚSÿuè‹ØY…ÛtO‹ËQŠA„Àuù+ÊjAP‰EüèE÷ÿÿ‰YY…Àuè_ýÿjY‰‹Á[_^‹å]Ë}üSWPèËâþÿƒÄ…Àu
…öt‰>3ÀëÝ3ÀPPPPPèßéþÿÌ‹ÿU‹ìQVW‹}…ÿuèÒ^ýÿj^‰0è“éþÿ‹Æë]‹u3À‰Eü‰…öt‰9EtØSÿuèÞ‹ØY…ÛtV‹ËQf‹ƒÁf;Eüuô+ÊÑùjAP‰Eüè—öÿÿ‰YY…Àuèo^ýÿjY‰‹Á[_^‹å]Ë}üSWPè’ÿÿƒÄ…Àu
…öt‰>3ÀëÝ3ÀPPPPPè1éþÿÌjhø¨Fèv³ûÿ3À‹u…ö•À…Àuè^ýÿÇèÙèþÿ3Àë@¿ÿWVè_ÿÿYY;ÇÀ÷ØtÖƒeäjèiÿÿYƒeüVè¦Y‹ð‰uäÇEüþÿÿÿè‹ÆèU³ûÿËuäjè‚ÿÿYÃjh©Fèö²ûÿ3À‹u…ö•À…Àuè™]ýÿÇèYèþÿ3Àë@¿ÿWVèÿÿYY;ÇÀ÷ØtÖƒeäjèéÿÿYƒeüVè–Y‹ð‰uäÇEüþÿÿÿè‹ÆèÕ²ûÿËuäjèÿÿYËÿU‹ìQVWèxþÿ‹ø…ÿtNƒ}tH‹uNŠF„Àuù+ñë2‹‹ÊA‰EüŠA„Àuù+Mü;Îv€<2=uVÿuRèƒÄ…ÀtƒÇƒ?uÉ3À_^‹å]Ë@Æëó‹ÿU‹ìQQVWèþÿ‹ø…ÿtdƒ}t^‹u3Ò‰UüNf‹ƒÆf;Âuõ+ñÑþ9t@‹‹ÊA‰Eøf‹ƒÁf;Eüuô+MøÑù;ÎvfƒyÿÿYËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPèDÿÿÿ‹å]ËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‹‰‹Á]Âÿ1è"xÿÿYËV‹0‹Æƒà?‹ÖÁúkÈ0‹•¨ÚFöD(t%VèwzÿÿYPÿ¼°E…Àt3À^ÃèbHýÿ‹ðÿH±E‰èfHýÿ^Ç	ƒÈÿÃÿ1è{xÿÿYËÿU‹ìQV‹uƒþþu
è>HýÿÇ	ëK…öx7;5¨ÜFs/‹Æ‹Öƒà?ÁúkÈ0‹•¨ÚFöD(tE‰EüEüPVèêþÿÿYYëèöGýÿÇ	è¶ÒþÿƒÈÿ^‹å]ËÿU‹ìQ¡¨ÙFVW…À…¢‹U…ÒuèÂGýÿÇè‚Òþÿ¸ÿÿÿ锋M…Étß‹}¾ÿÿÿ;þvè•GýÿÇèUÒþÿ‹ÆëmSjA[jZ^+щuüëjZ^·
f;Ãr
f;ÆwƒÀ ·ðë‹ð·f;Ãrf;EüwƒÀ ·ÀƒÁƒït
f…ötf;ðt¿·È·Æ+Á[ëjÿuÿuÿuè	ƒÄ_^‹å]ËÿU‹ìƒìS‹]…Ûu3Àéƒ}uèñFýÿÇè±Ñþÿ¸ÿÿÿéñW‹}…ÿuèÏFýÿÇèÑþÿ¸ÿÿÿéÎV¾ÿÿÿ;Þvè«FýÿÇèkÑþÿé¬ÿuMðè üÿ‹Eô‹€¤…Àu\‹E+ÇjA‰E^·8jZZf;Ær
f;ÂwƒÀ ·Èë‹È·f;Ær
f;ÂwƒÀ ·Ðë‹ÐƒÇƒët
f…Ét‹Ef;Êt¹·Â·ñ+ðë(SWSÿuhPè¿PƒÄ…Àu
è
FýÿÇëpþ€}üt
‹Mðƒ¡Pý‹Æ^_[‹å]ËÿU‹ì¡¨ÙF…Àu]éõŸþÿjÿuÿuÿuèƒÄ]ËÿU‹ìƒìMðSVWÿuè¤üÿ‹E…Àu3öé‹M…Ét‹U…Òuè†EýÿÇèFÐþÿ¾ÿÿÿëh¾ÿÿÿ;ÆvèfEýÿÇè&ÐþÿëM‹}ô‹Ÿ¤…ÛuuôVPRQèÏŸþÿƒÄ‹ðë-ÿwPRPQhEôSPèÜRƒÄ …Àu
èEýÿÇëpþ€}üt
‹Mðƒ¡Pý_‹Æ^[‹å]ËÿU‹ìhÿuèöQÿÿYY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìhÿuèÐQÿÿYY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìƒìÿuMðè‘üÿ‹Eô¶M‹·H%€€}üt
‹Mðƒ¡Pý‹å]ËÿU‹ìhÿuèqQÿÿYY]ËÿU‹ìhÿuè[QÿÿYY]ËÿU‹ìfƒ}	j@uX]Ãÿuè>QÿÿYY]ËÿU‹ìj ÿuè+QÿÿYY]ËÿU‹ìhÿuèQÿÿYY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìhÿuèïPÿÿYY…Àu	fƒ}_t]Ã3À@]ËÿU‹ìjÿuèÌPÿÿYY]ËÿU‹ìhÿuè¶PÿÿYY]ËÿU‹ìjÿuè£PÿÿYY]ËÿU‹ìhWÿuèPÿÿYY]ËÿU‹ìjÿuèzPÿÿYY]ËÿU‹ìjÿuègPÿÿYY]ËÿU‹ìjÿuèTPÿÿYY]ËÿU‹ìh€ÿuè>PÿÿYY]ËÿU‹ìjÿuèoþÿÿYY]ËÿU‹ìhÿuèPÿÿYY]ËÿU‹ìhÿuèÿOÿÿYY]ËÿU‹ì¸€f9EÀ÷Ø]ËÿU‹ìfƒ}	j@uX]ÃÿuèÎOÿÿYY]ËÿU‹ìj ÿuè»OÿÿYY]ËÿU‹ìjÿuè¨OÿÿYY]ËÿU‹ìhÿuè’OÿÿYY]ËÿU‹ìjÿuèOÿÿYY]ËÿU‹ìhWÿuèiOÿÿYY]ËÿU‹ìjÿuèVOÿÿYY]ËÿU‹ìjÿuèCOÿÿYY]ËÿU‹ìjÿuè0OÿÿYY]ËÿU‹ìh€ÿuèOÿÿYY]Ã3À9•ÀËÿU‹ìQQ¡ÀF3ʼnEüSV‹uW…ö~VÿuèÖOY;ÆYp|‹ð‹}$…ÿu‹E‹‹x‰}$3À9E(jjVÿu•ÀÅPWÿh°E‰Eø…À„J;ÑÀ…ÁtRJ;ÑÀ#ÁJ=w;ÑÀ#Áèü|‹Ü…Û„LÇÌÌë;ÑÀ#ÁPècÄþÿ‹ØY…Û„-ÇÝ݃Ãë3Û…Û„ÿuøSVÿujWÿh°E…À„ÿ‹}ø3ÀPPPPPWSÿuÿuè1äþÿ‹ð…ö„Þ÷Et8‹E …À„Ì;ðÂ3ÉQQQPÿuWSÿuÿuèõãþÿ‹ð…ö…¤é6J;ÑÀ…ÁtJJ;ÑÀ#ÁJ=w;ÑÀ#Áè|‹ü…ÿtdÇÌÌë;ÑÀ#ÁPè‚Ãþÿ‹øY…ÿtIÇÝ݃Çë3ÿ…ÿt8jjjVWÿuøSÿuÿuèqãþÿ…Àt3ÀPP9E u:PPVWPÿu$ÿرE‹ð…öu.WèÛ&ÿÿY3öSèÒ&ÿÿY‹Æeì_^[‹Mü3Íè]ˆûÿ‹å]Ãÿu ÿuëÀWè­&ÿÿYëÒ‹ÿU‹ìƒìÿuMðèÆüÿÿu(Eôÿu$ÿu ÿuÿuÿuÿuÿuPè¯ýÿÿƒÄ$€}üt
‹Mðƒ¡Pý‹å]ËÿU‹ì‹UV…Òuè?ýÿj^‰0è@Êþÿ‹Æé–ƒ}vä‹MÆ…É~‹Áë3À@9Ew	èM?ýÿj"ëÌ‹u…öt¾SZ‹ÃW‹~Æ0…É~Š„ÛtGë³0ˆ@I…ÉíZÆ…Éx€?5|
ëÆ0H€89t÷þ€:1uÿFë‹ËqŠA„Àuù+ÎAPSRè¹²ƒÄ_3À[^]ËÿU‹ììP	¡ÀF3ʼnEü‹M‹Eƒ¥”øÿÿSVW‹}‰ˆøÿÿ‹Ï‰…„øÿÿÁé‹Á%ÿƒÈu²3öë	2Ò¾3À‹]çÿÿÝEØþ3À„Ò•Àáÿ@±Ìûÿÿð‰µ´øÿÿèjMQQÝ$èpNYYè9z‰…˜øÿÿ=ÿÿÿt=€u3À‰…˜øÿÿ‰0þÿÿ3Û…ÿ‰½4þÿÿ•ÃC‰,þÿÿ…öˆƒ¥úÿÿj^Ç…”úÿÿ‰µŒúÿÿ;Þ…
3É‹„
úÿÿ;„
0þÿÿ…÷ƒÁƒùuä‹´øÿÿ3ÒƒÁ‹ÁƒáÁ艅¨øÿÿj ^‹Æ‰œøÿÿ+Á‰…¤øÿÿ3À‹¤øÿÿ@èxƒ¥”øÿÿH½Ï‰… øÿÿ÷Љ…ŒøÿÿtAë3À+ð‹…¨øÿÿ9µœøÿÿ—ÁPˆ»øÿÿƒús‰•°øÿÿ—Ńúsu„Ét±ë2É„í…ï„É…çjrY;Ñr‹Ñ‰°øÿÿ‹Ê‰¬øÿÿƒúÿ„–‹ò…0þÿÿ‹•¨øÿÿ+ò°‰…´øÿÿ;Êrm;ós‹8ë3ÿFÿ;Ãs‹…´øÿÿ‹@üë3À#…Œøÿÿ#½ øÿÿ‹¤øÿÿÓè‹œøÿÿÓ独øÿÿlj„0þÿÿI‹…´øÿÿNƒè‰¬øÿÿ‰…´øÿÿƒùÿt‹,þÿÿë‹•°øÿÿ‹…¨øÿÿ…Àt‹È½0þÿÿ3Àó«€½»øÿÿ»ÌtB‰…,þÿÿë3‰•,þÿÿë+3À»ÌP‰…Œúÿÿ‰…,þÿÿ…úÿÿP…0þÿÿSPè³$ƒÄƒ¥”úÿÿ3ÉjXA‰…úÿÿ‰Œúÿÿ‰\üÿÿP…úÿÿP…`üÿÿSPè|$ƒÄéc‹´øÿÿ3ÒA‹ÁƒáÁ艅¨øÿÿj _‹Ç‰œøÿÿ+Á‰…°øÿÿ3À‹°øÿÿ@è”v‹Œ,þÿÿHƒ¥”øÿÿ½É‰…Œøÿÿ÷Љ… øÿÿtAë3À+ø‹…¨øÿÿ9½œøÿÿ—ň­»øÿÿƒús‰•´øÿÿ—Áƒúsu„ít°ë2À„É…æ„À…ÞjrY;Ñr‹Ñ‰´øÿÿ‹Ê‰¤øÿÿƒúÿ„‡‹µ¨øÿÿ‹ú+þ•0þÿÿº;Îrg;ûs‹ë3À‰…¬øÿÿGÿ;Ãs‹Büë3À#… øÿÿƒê‹°øÿÿ‹¬øÿÿ#ŒøÿÿÓè‹œøÿÿÓ㋤øÿÿÉ„0þÿÿIO‰¤øÿÿƒùÿt‹,þÿÿë•‹•´øÿÿj^‹…¨øÿÿ…Àt‹È½0þÿÿ3Àó«€½»øÿÿ»ÌtB‰…,þÿÿë3‰•,þÿÿë+3À»ÌP‰…Œúÿÿ‰…,þÿÿ…úÿÿP…0þÿÿSPèÈ"ƒÄƒ¥”úÿÿ3À@‰µúÿÿ‰…Œúÿÿ‰…\üÿÿjéþÿÿþüÿÿ„ƒ¥úÿÿjYÇ…”úÿÿ‰Œúÿÿ;Ù…÷3Ò‹„úÿÿ;„0þÿÿ…áƒÂƒúu䃥”øÿÿ½ÇtPë3Òj X+‹ñ;Á…8þÿÿ‰…¬øÿÿ‹ø’…»øÿÿ;ós
‹‰•°øÿÿ냥°øÿÿFÿ;Ãs‹Wüë3Ò‹…°øÿÿƒïÁàÁê3Ћ…¬øÿÿN‰ƒè‰…¬øÿÿƒþÿt‹,þÿÿë­3À8…»øÿÿ•ÀÁ+´øÿÿ‹ù‰…,þÿÿÁï…úÿÿ‹÷‰ øÿÿÁæVjPèB—ûÿ‹ øÿÿ3À@ƒáÓà‰„5úÿÿGé@‹„,þÿÿƒ¥”øÿÿ½ÀtHë3Éj X+Áƒø’Àƒûsˆ…»øÿÿ—Áƒûsu„Àt°ë2À„É…›„À…“jrY;Ùs‹Ëƒùÿti½0þÿÿ‹ñ<‰½¬øÿÿ;ós
‹‰•°øÿÿ냥°øÿÿFÿ;Ãs‹Wüë3Ò‹…°øÿÿƒïÀÁê3Ћ…¬øÿÿN‰ƒè‰…¬øÿÿƒþÿt‹,þÿÿ뮋µ´øÿÿ€½»øÿÿtA‰…,þÿÿë3‰,þÿÿë+ƒ¥Œúÿÿ…úÿÿƒ¥,þÿÿjP…0þÿÿhÌPèr ƒÄ3ÿ…úÿÿG+þ‹ßÁë‹óÁæVjPèù•ûÿ3Àƒç@‹ÏÓà‰„5úÿÿC‰…Œúÿÿ»Ì‰…\üÿÿÁàP…úÿÿP…`üÿÿSPè ƒÄ‹…˜øÿÿ3Òj
Y‰Œøÿÿ…Àˆc÷ñ‰…œøÿÿ‹Ê‰”øÿÿ…À„qƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…¤øÿÿÁçW1‰…Œúÿÿ…úÿÿjPèM•ûÿ‹ÆÁàP‹…¤øÿÿ·…ÄûE…ÀòEP…úÿÿÇPèSt‹ŒúÿÿƒÄ‰´øÿÿƒùwz‹µúÿÿ…öu3À‰…¼øÿÿ‰…\üÿÿ韃þ„®ƒ½\üÿÿ„¡‹…\üÿÿ3ɉ… øÿÿ3ÿ‹Æ÷¤½`üÿÿÁ‰„½`üÿÿƒÒG‹Ê;½ øÿÿuà鬉Œ…`üÿÿÿ…\üÿÿéZƒ½\üÿÿ‡¾‹½`üÿÿ‹ÁÁàP…úÿÿ‰\üÿÿP…`üÿÿSP躃ąÿu3À‰…Œúÿÿ‰…\üÿÿP…úÿÿéõƒÿ„ýƒ½\üÿÿ„ð‹…\üÿÿ3ɉ… øÿÿ3ö‹Ç÷¤µ`üÿÿÁ‰„µ`üÿÿƒÒF‹Ê;µ øÿÿuà…É„¸‹…\üÿÿƒøs‚=ÿÿÿ3À‰…Œúÿÿ‰…\üÿÿP…úÿÿéì;\üÿÿ½úÿÿ’À„À…ƒ½`üÿÿ•úÿÿ‰•°øÿÿ„Àu‹\üÿÿ‰¬øÿÿ„Àt‹…\üÿÿ‰…´øÿÿ3Ò3ö‰•¼øÿÿ…É„…Àøÿÿ+ø‰½€øÿÿ·‹„Àøÿÿ‰… øÿÿ…Àu%;ò…Þ!„µÀøÿÿV‰•¼øÿÿéÉ•`üÿÿë3À3ÿ‹Î‰…¨øÿÿ9…´øÿÿ„”ƒùstW;Êuƒ¤Àøÿÿ@Ɖ…¼øÿÿ‹…¨øÿÿ‹•°øÿÿ‹‚÷¥ øÿÿǃÒ„Àøÿÿ‹…¨øÿÿƒÒ@A‰…¨øÿÿ‹ú‹•¼øÿÿ;…´øÿÿu¤…ÿt4ƒùs„´;Êuƒ¤ÀøÿÿA‰…¼øÿÿ‹Ç3ÿ„Àøÿÿ‹•¼øÿÿÿAëȃùs„€‹½€øÿÿ‹¬øÿÿF;ñ…ýþÿÿ‹Â‰•\üÿÿÁàP…ÀøÿÿP…`üÿÿSP薃İ„Àtl‹…œøÿÿ+…¤øÿÿ‰…œøÿÿ…•üÿÿ‹”øÿÿ…É„‹<\üE…ÿu]3À‰…°öÿÿ‰…\üÿÿPë:3À‰…°öÿÿ‰…\üÿÿP…´öÿÿP…`üÿÿSPè(ƒÄ2À냥°öÿÿƒ¥\üÿÿj…´öÿÿP…`üÿÿ顃ÿ„¢‹…\üÿÿ‰…”øÿÿ…À„Ž3É3ö‹Ç÷¤µ`üÿÿÁ‰„µ`üÿÿƒÒF‹Ê;µ”øÿÿuà…É„b‹…\üÿÿƒøsƒKÿÿÿ‰Œ…`üÿÿÿ…\üÿÿéA÷Ø÷ñ‰…œøÿÿ‹Ê‰ øÿÿ…À„Lƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…´øÿÿÁçW1‰…Œúÿÿ…úÿÿjPèèûÿ‹ÆÁàP‹…´øÿÿ·…ÄûE…ÀòEP…úÿÿÇPèîo‹ŒúÿÿƒÄ‰¨øÿÿƒù‡“‹µúÿÿ…öu3À‰…°öÿÿ‰…,þÿÿP…´öÿÿérƒþ„zƒ½,þÿÿ„m‹…,þÿÿ3ɉ…”øÿÿ3ÿ‹Æ÷¤½0þÿÿÁ‰„½0þÿÿƒÒG‹Ê;½”øÿÿuà…É„5‹…,þÿÿƒøsƒÄ‰Œ…0þÿÿÿ…,þÿÿ都,þÿÿw|‹½0þÿÿ‹ÁÁàP…úÿÿ‰,þÿÿP…0þÿÿSPè<ƒÄ…ÿ„=ÿÿÿƒÿ„у½,þÿÿ„Ä‹…,þÿÿ3ɉ…”øÿÿ3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;µ”øÿÿuàéRÿÿÿ;,þÿÿ½úÿÿ’À„À…ƒ½0þÿÿ•úÿÿ‰•°øÿÿ„Àu‹,þÿÿ‰¬øÿÿ„Àt‹…,þÿÿ‰…¨øÿÿ3Ò3ö‰•¼øÿÿ…É„…Àøÿÿ+ø‰½€øÿÿ·‹„Àøÿÿ‰…”øÿÿ…Àu%;ò…Þ!„µÀøÿÿV‰•¼øÿÿéÉ•0þÿÿë3À3ÿ‹Î‰…¤øÿÿ9…¨øÿÿ„”ƒùstW;Êuƒ¤Àøÿÿ@Ɖ…¼øÿÿ‹…¤øÿÿ‹•°øÿÿ‹‚÷¥”øÿÿǃÒ„Àøÿÿ‹…¤øÿÿƒÒ@A‰…¤øÿÿ‹ú‹•¼øÿÿ;…¨øÿÿu¤…ÿt4ƒùs„
;Êuƒ¤ÀøÿÿA‰…¼øÿÿ‹Ç3ÿ„Àøÿÿ‹•¼øÿÿÿAëȃùs„Ö‹½€øÿÿ‹¬øÿÿF;ñ…ýþÿÿ‹Â‰•,þÿÿÁàP…ÀøÿÿP…0þÿÿSPèZƒÄ°„À„Á‹…œøÿÿ+…´øÿÿ‰…œøÿÿ…ºüÿÿ‹ øÿÿ…É„Ó‹\üE‰…”øÿÿ…À„˜ƒø„µ‹,þÿÿ…É„§3ö3ÿ÷¤½0þÿÿƉ„½0þÿÿ‹…”øÿÿƒÒG‹ò;ùuà…öt‹…,þÿÿƒøssN‰´…0þÿÿÿ…,þÿÿëe3ÀP‰…°öÿÿ‰…,þÿÿ…´öÿÿP…0þÿÿSPè–ƒÄ2Àé7ÿÿÿƒ¥°öÿÿƒ¥,þÿÿjë3ÀP‰…,þÿÿ‰…°öÿÿ…´öÿÿP…0þÿÿSPèWƒÄ‹½ˆøÿÿ‹÷‹,þÿÿ‰µ´øÿÿ…Éto3ÿ3ö‹„µ0þÿÿj
Z÷âlj„µ0þÿÿƒÒF‹ú;ñuድ´øÿÿ…ÿt@‹…,þÿÿƒøss‰¼…0þÿÿÿ…,þÿÿë&3ÀP‰…°öÿÿ‰…,þÿÿ…´öÿÿP…0þÿÿSPè҃ċþ…\üÿÿP…,þÿÿPèróýÿYYj
Z;Â…‘ÿ…˜øÿÿw‹…\üÿÿÆ1‰µ´øÿÿ…À„‹3É‹ð3ÿ‹„½`üÿÿ÷âj
Á‰„½`üÿÿƒÒG‹ÊZ;þuድ´øÿÿ…Ét\‹…\üÿÿƒøss‰Œ…`üÿÿÿ…\üÿÿëB3ÀP‰…°öÿÿ‰…\üÿÿ…´öÿÿP…`üÿÿSPè!ƒÄë…Àu	‹…˜øÿÿHë0wˆ‰µ´øÿÿ‹…˜øÿÿ‹„øÿÿ‰‹M…Àx
ùÿÿÿwÈ‹EH;Ár‹Á…ˆøÿÿ‰…°øÿÿ;ð„Ó‹…,þÿÿ…À„Å3É‹ð3ÿ‹„½0þÿÿºÊš;÷âÁ‰„½0þÿÿƒÒG‹Ê;þuß‹µ´øÿÿ…Ét@‹…,þÿÿƒøss‰Œ…0þÿÿÿ…,þÿÿë&3ÀP‰…°öÿÿ‰…,þÿÿ…´öÿÿP…0þÿÿSPèIƒÄ…\üÿÿP…,þÿÿPèëñýÿYY‹°øÿÿj_+Î3Ò÷µŒøÿÿ€Â0;Ïrˆ7Oƒÿÿuèƒù	vj	Yñ‰µ´øÿÿ;µ°øÿÿ…-ÿÿÿ‹Mü_Æ3Í^[è¬tûÿ‹å]ËÿV‹ñVèN:‹ƒàY<uÆFëVèž:YÆF‹Æ^ÀytQè@:YÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹MVW‹}‹7;1t_2À^]Ã3Ò…ötA+ù‹;uèBƒÀ;Öuñ_°^]ÃÌÌÌÌÌÌÌ‹ÿU‹ì‹MVW‹}‹1;7t
2É3À„É_”À^]Ã3Ò…ötA+ùëI‹;uÜBƒÀ;Öuñ±3À„É_”À^]ÃÌÌÌÌ‹ÿU‹ì‹M3À9”À]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìQS‹]‹ÃÁèV‹uW<…‰EüWFjPèf‰ûÿƒãƒÄ‹ËºÓâ‹Æ‹Mü‰T7A_‰^[‹å]ËÿU‹ììd	¡ÀF3ʼnEüS‹]løÿÿVW‹}‰½€øÿÿ‰„øÿÿè‰þÿÿ‹u3À‹Îá€Á°-uó¾À‹Î‰áð3À‰_Á‹}u"‹Î‹ÇáÿÿÁu‹…€øÿÿh`LFƒ`éÓEPèGÿÿY…Àt
‹€øÿÿÇAƒè„ªƒè„šƒè„Šƒè„z‹Eæÿÿÿƒ¥|øÿÿ@‰}‰uÝEÝ•˜øÿÿ‹½œøÿÿ‹Ï‰…ˆøÿÿÁé‹Á%ÿƒÈu²3öë	2Ò¾3À‹˜øÿÿçÿÿØþ3À„Ò•Àáÿ@±Ìûÿÿð‰µ´øÿÿèÓ8QQÝ$èÙ9YYè¢e‰…”øÿÿ=ÿÿÿt=€u3À‰…”øÿÿ‰0þÿÿ3Û…ÿ‰½4þÿÿ•ÃC‰,þÿÿ…öˆíƒ¥úÿÿj^Ç…”úÿÿ‰µŒúÿÿ;Þ…3É‹„
úÿÿ;„
0þÿÿ…êƒÁƒùuä‹…´øÿÿ3ÒƒÀ‹ðƒàj Y+ȉ…¤øÿÿ3ÀÁî@‰µ°øÿÿ‰øÿÿèòcƒ¥œøÿÿH½Ï‰…¨øÿÿ÷Љ…ŒøÿÿtAë3Éj X+ÁV9…¤øÿÿ‰•¬øÿÿ—Àƒúsˆ…»øÿÿ—Áƒúsu„Àt°ë2À„É…ï„À…çjrY;Ñr‹Ñ‰¬øÿÿ‹Ê‰ øÿÿƒúÿ„–‹ò…0þÿÿ‹•°øÿÿ+ò°‰…´øÿÿ;Êrm;ós‹8ë3ÿFÿ;Ãs‹…´øÿÿ‹@üë3À#…Œøÿÿ#½¨øÿÿ‹øÿÿÓ苤øÿÿÓç‹ øÿÿlj„0þÿÿI‹…´øÿÿNƒè‰ øÿÿ‰…´øÿÿƒùÿt‹,þÿÿë‹•¬øÿÿ‹µ°øÿÿ…öt‹Î½0þÿÿ3Àó«€½»øÿÿ»ÌtB‰…,þÿÿë3‰•,þÿÿë+3À»ÌP‰…Œúÿÿ‰…,þÿÿ…úÿÿP…0þÿÿSPè)ƒÄƒ¥”úÿÿ3ÉjXA‰…úÿÿ‰Œúÿÿ‰\üÿÿP…úÿÿP…`üÿÿSPèòƒÄé\‹…´øÿÿ3Ò@‹øƒàj Y+ȉ…°øÿÿ3ÀÁï@‰½´øÿÿ‰øÿÿèb‹Œ,þÿÿHƒ¥œøÿÿ½É‰…¨øÿÿ÷Љ…ŒøÿÿtAë3Éj X+Á;9…°øÿÿ‰• øÿÿ—Àƒúsˆ…»øÿÿ—Áƒúsu„Àt°ë2À„É…ì„À…äjrY;Ñr‹Ñ‰ øÿÿ‹Â‰…¬øÿÿƒúÿ„“‹ò0þÿÿ‹•´øÿÿ+ò±‰¤øÿÿ;Ârg;ós‹9ë3ÿFÿ;Ãs‹Aüë3À#½¨øÿÿ#…Œøÿÿ‹°øÿÿÓç‹øÿÿÓ苤øÿÿø‹…¬øÿÿƒé‰¤øÿÿ‰¼…0þÿÿHN‰…¬øÿÿƒøÿt‹,þÿÿë•‹• øÿÿ‹½´øÿÿj^…ÿt‹Ï3À½0þÿÿó«€½»øÿÿ»ÌtB‰…,þÿÿë3‰•,þÿÿë+3À»ÌP‰…Œúÿÿ‰…,þÿÿ…úÿÿP…0þÿÿSPèEƒÄƒ¥”úÿÿ3À@‰µúÿÿ‰…Œúÿÿ‰…\üÿÿjéþÿÿþüÿÿ„ƒ¥úÿÿjYÇ…”úÿÿ‰Œúÿÿ;Ù…÷3Ò‹„úÿÿ;„0þÿÿ…áƒÂƒúu䃥œøÿÿ½ÇtPë3Òj X+‹ñ;Á…8þÿÿ‰…¬øÿÿ‹ø’…»øÿÿ;ós
‹‰•°øÿÿ냥°øÿÿFÿ;Ãs‹Wüë3Ò‹…°øÿÿƒïÁàÁê3Ћ…¬øÿÿN‰ƒè‰…¬øÿÿƒþÿt‹,þÿÿë­3À8…»øÿÿ•ÀÁ+´øÿÿ‹ù‰…,þÿÿÁï…úÿÿ‹÷‰¨øÿÿÁæVjPè¿‚ûÿ‹¨øÿÿ3À@ƒáÓà‰„5úÿÿGé@‹„,þÿÿƒ¥œøÿÿ½ÀtHë3Éj X+Áƒø’Àƒûsˆ…»øÿÿ—Áƒûsu„Àt°ë2À„É…›„À…“jrY;Ùs‹Ëƒùÿti½0þÿÿ‹ñ<‰½¬øÿÿ;ós
‹‰•°øÿÿ냥°øÿÿFÿ;Ãs‹Wüë3Ò‹…°øÿÿƒïÀÁê3Ћ…¬øÿÿN‰ƒè‰…¬øÿÿƒþÿt‹,þÿÿ뮋µ´øÿÿ€½»øÿÿtA‰…,þÿÿë3‰,þÿÿë+ƒ¥Œúÿÿ…úÿÿƒ¥,þÿÿjP…0þÿÿhÌPèïƒÄ3ÿ…úÿÿG+þ‹ßÁë‹óÁæVjPèvûÿ3Àƒç@‹ÏÓà‰„5úÿÿC‰…Œúÿÿ»Ì‰…\üÿÿÁàP…úÿÿP…`üÿÿSP葃ċ…”øÿÿ3Òj
Y‰Œøÿÿ…Àˆc÷ñ‰…øÿÿ‹Ê‰œøÿÿ…À„qƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…¤øÿÿÁçW1‰…Œúÿÿ…úÿÿjPèÊ€ûÿ‹ÆÁàP‹…¤øÿÿ·…ÄûE…ÀòEP…úÿÿÇPèÐ_‹ŒúÿÿƒÄ‰ øÿÿƒùwz‹½úÿÿ…ÿu3À‰…¼øÿÿ‰…\üÿÿ韃ÿ„®ƒ½\üÿÿ„¡‹…\üÿÿ3ɉ…¨øÿÿ3ö‹Ç÷¤µ`üÿÿÁ‰„µ`üÿÿƒÒF‹Ê;µ¨øÿÿuà鬉Œ…`üÿÿÿ…\üÿÿéZƒ½\üÿÿ‡¾‹½`üÿÿ‹ÁÁàP…úÿÿ‰\üÿÿP…`üÿÿSPè7
ƒÄ…ÿu3À‰…Œúÿÿ‰…\üÿÿP…úÿÿéõƒÿ„ýƒ½\üÿÿ„ð‹…\üÿÿ3ɉ…¨øÿÿ3ö‹Ç÷¤µ`üÿÿÁ‰„µ`üÿÿƒÒF‹Ê;µ¨øÿÿuà…É„¸‹…\üÿÿƒøs‚=ÿÿÿ3À‰…Œúÿÿ‰…\üÿÿP…úÿÿéì;\üÿÿ½úÿÿ’À„À…ƒ½`üÿÿ•úÿÿ‰•°øÿÿ„Àu‹\üÿÿ‰¬øÿÿ„Àt‹…\üÿÿ‰… øÿÿ3Ò3ö‰•¼øÿÿ…É„…Àøÿÿ+ø‰½|øÿÿ·‹„Àøÿÿ‰…¨øÿÿ…Àu%;ò…Þ!„µÀøÿÿV‰•¼øÿÿéÉ•`üÿÿë3À3ÿ‹Î‰…´øÿÿ9… øÿÿ„”ƒùstW;Êuƒ¤Àøÿÿ@Ɖ…¼øÿÿ‹…´øÿÿ‹•°øÿÿ‹‚÷¥¨øÿÿǃÒ„Àøÿÿ‹…´øÿÿƒÒ@A‰…´øÿÿ‹ú‹•¼øÿÿ;… øÿÿu¤…ÿt4ƒùs„´;Êuƒ¤ÀøÿÿA‰…¼øÿÿ‹Ç3ÿ„Àøÿÿ‹•¼øÿÿÿAëȃùs„€‹½|øÿÿ‹¬øÿÿF;ñ…ýþÿÿ‹Â‰•\üÿÿÁàP…ÀøÿÿP…`üÿÿSPèƒÄ°„Àtl‹…øÿÿ+…¤øÿÿ‰…øÿÿ…•üÿÿ‹œøÿÿ…É„‹<\üE…ÿu]3À‰…œöÿÿ‰…\üÿÿPë:3À‰…œöÿÿ‰…\üÿÿP… öÿÿP…`üÿÿSP襃Ä2À냥œöÿÿƒ¥\üÿÿj… öÿÿP…`üÿÿ顃ÿ„¢‹…\üÿÿ‰…œøÿÿ…À„Ž3ö3É‹Ç÷¤`üÿÿƉ„`üÿÿƒÒA‹ò;œøÿÿuà…ö„b‹…\üÿÿƒøsƒKÿÿÿ‰´…`üÿÿÿ…\üÿÿéA÷Ø÷ñ‰…¬øÿÿ‹Ê‰¨øÿÿ…À„Lƒø&vj&X¶…ÆûE¶4…ÇûE‹ù‰…´øÿÿÁçW1‰…Œúÿÿ…úÿÿjPèe|ûÿ‹ÆÁàP‹…´øÿÿ·…ÄûE…ÀòEP…úÿÿÇPèk[‹ŒúÿÿƒÄ‰ øÿÿƒù‡“‹½úÿÿ…ÿu3À‰…œöÿÿ‰…,þÿÿP… öÿÿérƒÿ„zƒ½,þÿÿ„m‹…,þÿÿ3ɉ…œøÿÿ3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;µœøÿÿuà…É„5‹…,þÿÿƒøsƒÄ‰Œ…0þÿÿÿ…,þÿÿ都,þÿÿw|‹½0þÿÿ‹ÁÁàP…úÿÿ‰,þÿÿP…0þÿÿSP蹃ąÿ„=ÿÿÿƒÿ„у½,þÿÿ„Ä‹…,þÿÿ3ɉ…œøÿÿ3ö‹Ç÷¤µ0þÿÿÁ‰„µ0þÿÿƒÒF‹Ê;µœøÿÿuàéRÿÿÿ;,þÿÿ½úÿÿ’À„À…ƒ½0þÿÿ•úÿÿ‰•øÿÿ„Àu‹,þÿÿ‰°øÿÿ„Àt‹…,þÿÿ‰… øÿÿ3Ò3ö‰•¼øÿÿ…É„…Àøÿÿ+ø‰½|øÿÿ·‹„Àøÿÿ‰…œøÿÿ…Àu%;ò…Þ!„µÀøÿÿV‰•¼øÿÿéÉ•0þÿÿë3À3ÿ‹Î‰…¤øÿÿ9… øÿÿ„”ƒùstW;Êuƒ¤Àøÿÿ@Ɖ…¼øÿÿ‹…¤øÿÿ‹•øÿÿ‹‚÷¥œøÿÿǃÒ„Àøÿÿ‹…¤øÿÿƒÒ@A‰…¤øÿÿ‹ú‹•¼øÿÿ;… øÿÿu¤…ÿt4ƒùs„
;Êuƒ¤ÀøÿÿA‰…¼øÿÿ‹Ç3ÿ„Àøÿÿ‹•¼øÿÿÿAëȃùs„Ö‹½|øÿÿ‹°øÿÿF;ñ…ýþÿÿ‹Â‰•,þÿÿÁàP…ÀøÿÿP…0þÿÿSPè׃İ„À„Á‹…¬øÿÿ+…´øÿÿ‰…¬øÿÿ…ºüÿÿ‹¨øÿÿ…É„Ó‹\üE‰…œøÿÿ…À„˜ƒø„µ‹,þÿÿ…É„§3ÿ3ö÷¤µ0þÿÿlj„µ0þÿÿ‹…œøÿÿƒÒF‹ú;ñuà…ÿt‹…,þÿÿƒøssN‰¼…0þÿÿÿ…,þÿÿëe3ÀP‰…œöÿÿ‰…,þÿÿ… öÿÿP…0þÿÿSPèƒÄ2Àé7ÿÿÿƒ¥œöÿÿƒ¥,þÿÿjë3ÀP‰…,þÿÿ‰…œöÿÿ… öÿÿP…0þÿÿSPèԃċ½„øÿÿ‹÷‹,þÿÿ‰µ´øÿÿ…Étw3ö3ÿ‹„½0þÿÿj
Z÷âƉ„½0þÿÿƒÒG‹ò;ùuትœøÿÿ…ö‹µ´øÿÿtB‹,þÿÿƒùss‹Â‰„0þÿÿÿ…,þÿÿë&3ÀP‰…œöÿÿ‰…,þÿÿ… öÿÿP…0þÿÿSPèGƒÄ‹þ…\üÿÿP…,þÿÿPèçÞýÿYYj
Z;Â…‘ÿ…”øÿÿw‹…\üÿÿÆ1‰µ´øÿÿ…À„‹3ÿ‹ð3É‹„`üÿÿ÷âj
lj„`üÿÿƒÒA‹úZ;Îuድ´øÿÿ…ÿt\‹…\üÿÿƒøss‰¼…`üÿÿÿ…\üÿÿëB3ÀP‰…œöÿÿ‰…\üÿÿ… öÿÿP…`üÿÿSPè–ƒÄë…Àu	‹…”øÿÿHë0wˆ‰µ´øÿÿ‹…”øÿÿ‹€øÿÿ‰A‹ˆøÿÿ…Àx
ùÿÿÿwÈ‹EH;Ár‹Á…„øÿÿ‰…ˆøÿÿ;ð„Ó‹…,þÿÿ…À„Å3ÿ‹ð3É‹„0þÿÿºÊš;÷âlj„0þÿÿƒÒA‹ú;Îuß‹µ´øÿÿ…ÿt@‹…,þÿÿƒøss‰¼…0þÿÿÿ…,þÿÿë&3ÀP‰…œöÿÿ‰…,þÿÿ… öÿÿP…0þÿÿSP躃Ä…\üÿÿP…,þÿÿPè\ÝýÿYY‹ˆøÿÿj_+Î3Ò÷µŒøÿÿ€Â0;Ïrˆ7Oƒÿÿuèƒù	vj	Yñ‰µ´øÿÿ;µˆøÿÿ…-ÿÿÿÆë*h|LFëhtLFëhlLFëhdLFÿuSè`›þÿƒÄ…Àu'€½tøÿÿ_^[t
…løÿÿPè´%Y‹Mü3ÍèÛ_ûÿ‹å]Ã3ÀPPPPPèW¢þÿÌ‹ÿU‹ìV‹u…öu3Àëm‹E…ÀuèAýÿj^‰0è¢þÿ‹ÆëSW‹}…ÿt9urVWPè˜TƒÄ3Àë6ÿujPèVuûÿƒÄ…ÿu	èýÿjë9usèòýÿj"^‰0賡þÿ‹ÆëjX_^]ËÿU‹ì‹EV…ÀuèËýÿÇè‹¡þÿƒÈÿéY‹@S3ÛÁè
C„ÄC‹E‹@Áè„Ã…2‹E‹@Ñè„ËEtjYƒÀð	éƒÀð	‹E‹@©Àu	ÿuèÌY‹E‹H‰‹uÿvÿvVèûÃþÿYPè$‘þÿ‰FƒÄ‹E‹P…Ò„¬ƒúÿ„£‹@¨u]ÿuèÈÃþÿYƒøÿt5ÿuèºÃþÿYƒøþt'‹uWVèªÃþÿ‹øVÁÿèŸÃþÿƒà?kÀ0YY½¨ÚF_ë¸ÂFŠ@($‚<‚u‹Ej YƒÀð	‹Exu$‹@Áè„Ãt‹E‹@Áè„Ãu
‹EÇ@‹EÿH‹ŠA‰¶Âë3É…Ò•ÁƒÀÍð	‹MƒaƒÈÿ[^]ËÿU‹ì‹EV…ÀuèJýÿÇè
 þÿ¸ÿÿé’‹@S3ÛÁè
C„Äz‹E‹@Áè„Ã…i‹E‹@Ñè„ËEtjYƒÀð	éLƒÀð	‹E‹@©Àu	ÿuèIY‹E9Xu‹Š9ë2Û2ÿ‹H‰‹uÿvÿvVèiÂþÿYPè’þÿ‰FƒÄ‹E‹P…Ò„Ôƒú„˃úÿ„‹@¨u]ÿuè-ÂþÿYƒøÿt5ÿuèÂþÿYƒøþt'‹uWVèÂþÿ‹øVÁÿèÂþÿƒà?kÀ0YY½¨ÚF_ë¸ÂFŠ@($‚<‚u‹Ej YƒÀð	‹Exu$‹@Áè¨t‹E‹@Áè¨u
‹EÇ@‹E‹„Ût¶fÁâ¶ÏfÑÿHÿ·Êë
·	ƒ@þƒ‹Á·Àë 3É…Ò•ÁƒÀÍð	‹Eƒ`¸ÿÿ[^]ËÿU‹ìQ‹Eƒxu
‹ÆEüŠˆEýëfÇEüf‹Eü‹å]Ã3ÀËÿU‹ì‹Eƒxtƒxÿt3À@]Ã3À]ËÿU‹ì‹E‹H…Ét3À@;Ètƒùÿu3À]ËÿU‹ì‹EÿH‹M‹ŠB‰]ËÿU‹ìf‹E‹M„Àt‹fÁè¶fÁâfÐÿI‹M·Âÿ]Ë·ƒAþ‹Mƒ]ËÿU‹ì]éúûÿÿ‹ÿU‹ì]épýÿÿjh`ªFè
hûÿ3Àf‰Eä‹Eÿ0è0ÊþÿYƒeü‹E‹·PèÇYf‹ðf‰uäÇEüþÿÿÿèf‹ÆèhûÿÂf‹uä‹Eÿ0è8ÊþÿYËÿU‹ìƒì‹EMÿ‰Eø‰EôEøPÿuEôPè~ÿÿÿ‹å]ËÿU‹ì‹E‹‰‹Á]‹ÿU‹ì‹E‰‹Á]‹ÿU‹ì‹E‹‰‹Á]Âÿ1è‹ÉþÿYË·Pè(YÃÿ1è½ÉþÿYËÿU‹ìQE‰EüEüPj	ènÿÿÿYY‹å]ËÿU‹ìQ¡`ÉFƒøþu
è#¡`ÉFƒøÿu¸ÿÿëjMüQjMQPÿ¸°E…Àtâf‹E‹å]ËÿU‹ìÿÐFSV‹u»Sè•”þÿj‰FèQ”þÿƒ~FYYtj@Yð	‰^ë¹ð	FÇF‰F‹Fƒf‰^[]ËÿU‹ì‹M3ÀöÁt2öÁt¸öÁt
öÁt
öÁt
öÁt
]ËÿU‹ì‹U3É÷€~tg„ÒyjYW¿…×tƒÉ÷ÂtƒÉ÷ÂtƒÉ÷ÂtƒÉV¾`‹Â#Æ;Æ^uÉë÷Â@tÉë
÷ tÏ_‹Á]ËÿU‹ì‹U3É÷Â=t]öÂtjYöÂtƒÉöÂtƒÉöÂtƒÉö tƒÉV¾‹Â#Æ;Æ^uÉë÷ÂtÉë÷ÂtÉ‹Á]ËÿU‹ì‹M3ÀöÁ=t2öÁt¸öÁt
öÁt
öÁt
öÁ t
]ËÿU‹ì‹M3ÀöÁ=t2öÁt¸öÁt
öÁt
öÁt
öÁ t
]ËÿU‹ì‹U3É÷Ât[öÂtAöÂtƒÉöÂtƒÉöÂtƒÉöÂtƒÉ V¾‹Â#Æ;Æ^uÉë÷ÂtÉë÷ÂtÉ‹Á]ËÿU‹ì‹U3É÷ÂtjöÂt¹€W¿öÂtÏöÂtÉöÂtÉöÂtÉV¾‹Â#Æ;Æ^uÉ`ë…×tÉ ë÷ÂtÉ@_‹Á]ËÿU‹ì‹U3ÉöÂtNV¾‹Â#Æ;ÆuA¾‹Â#Æ;ÆuƒÉ¾‹Â#Æ;ÆuƒÉ¾‹Â#Æ;Æ^uƒÉ¸#Ð;ÐuƒÉ ‹Á]ËÿU‹ì‹U3ÉöÂtNV¾‹Â#Æ;ÆuA¾‹Â#Æ;ÆuƒÉ¾‹Â#Æ;ÆuƒÉ¾‹Â#Æ;Æ^uƒÉ¸#Ð;ÐuƒÉ ‹Á]ËÿU‹ìQQ3À!Eøf‰EüÙ}üƒ=ÏF|®]ø·EüVPè)ýÿÿÿuø‹ðè¢üÿÿYÆY%^‹å]ËÿU‹ìQQ3À3Éf‰Eü‰MøÝ}üƒ=ÏF|®]ø·Uü‹ÁöÂ=t2öÂt¸öÂt
öÂt
öÂt
öÂ t
‹UøöÂ=t6öÂt¹öÂtÉöÂtÉöÂtÉö tÉÁ%‹å]ËÿU‹ìƒì SVW3ÿ‰}à‰}ä‰}è‰}ì‰}ð‰}ô‰}øÙuà»Sè2ýÿÿÿu‹ð÷Ö#uàè#ýÿÿYðY‰uàÙeàƒ=ÏF|'‰}ü®]üSètýÿÿÿu‹ð÷Ö#uüèeýÿÿYðY‰uü®Uü_^[‹å]ËÿU‹ìƒì SVW3ÿ‰}à‰}ä‰}è‰}ì‰}ð‰}ô‰}øÙuà»Sèþÿÿÿu‹ð÷Ö#uäèõýÿÿYðY‰uäÙeàƒ=ÏF|'‰}ü®]üSètýÿÿÿu‹ð÷Ö#uüèeýÿÿYðY‰uü®Uü_^[‹å]ËÿU‹ìQV‹u…öyèÊýÿÇ芖þÿ3Àé—S‹]…Ût#SèaY…ÀuèýÿÇè•ýÿÇ
ë9èú1ÿÿ‹Ø…Ût€Ã@fÇEý:.ˆ]üÆEÿëfÇEü.‹E…Àt+…öèZýÿÇè–þÿ3Àë)VPÆEüPèƒÄëÿuEüÿuÿuVPèöƒÄ[^‹å]ËÿU‹ìƒì¡ÀF3ʼnEüS‹]W‹}…ÿyèù
ýÿÇ蹕þÿ3Àé¨V‹u…öt#VèY…Àuè¼
ýÿÇèÄ
ýÿÇ
ëHè)1ÿÿ‹ð…ötF@j:f‰EôXf‰Eöj.Xf‰Eø3Àf‰Eúë
j.Xf‰Eô3Àf‰Eö…Ût-…ÿèz
ýÿÇè:•þÿ3Àë+3ÀWf‰EôSP舃ÄëÿuEôÿuÿuWP蕃Ä^‹Mü_3Í[èŸRûÿ‹å]ËÿU‹ìW3ÿWWWÿuÿ±E…ÀuÿH±EPèÕ	ýÿY3ÀëUS‹]V;Øw‹ØjSè¢ÿÿ‹ðYY…öuèÓ	ýÿÇèÛ	ýÿÇëSVÿu蜃Ä…Àt‹Î‹÷‹ùVè1ýÿY^‹Ç[_]ËÿU‹ìW3ÿWWWÿuÿ±E…ÀuÿH±EPèT	ýÿY3ÀëUS‹]V;Øw‹ØjSè¡ÿÿ‹ðYY…öuèR	ýÿÇèZ	ýÿÇëSVÿuèuƒÄ…Àt‹Î‹÷‹ùVè‚0ýÿY^‹Ç[_]ËÿU‹ìƒ}wè	ýÿÇèÝ“þÿ3À]Ãjÿuÿuÿuÿ±E;Er
èóýÿÇ"ëÙ…ÀuÿH±EPè¥ýÿYëÆ‹E]ËÿU‹ìƒ}wèÃýÿÇ胓þÿ3À]Ãjÿuÿuÿuÿ±E;Er
è™ýÿÇ"ëÙ…ÀuÿH±EPèKýÿYëÆ‹E]ËÿU‹ìjÿuÿuÿuÿ±E]ËÿU‹ìjÿuÿuÿuÿ±E]ËÿU‹ìƒì¡ÀF3ʼnEü‹EƒøvèýÿÇèýÿÇ
èß’þÿë7…Àu3À@ë0ƒÀ@j:f‰EôXf‰Eöj\Xf‰Eø3Àf‰EúEôPÿè±E…ÀtƒøuÍ3À‹Mü3Íè;Pûÿ‹å]ËÿU‹ì3ÀPPjÿuÿuPè×ûÿÿƒÄ]ËÿU‹ìjjjÿuÿuÿuè¹ûÿÿƒÄ]ËÿU‹ì3ÀPPjÿuÿuPè^üÿÿƒÄ]ËÿU‹ìjjjÿuÿuÿuè@üÿÿƒÄ]ËÿU‹ì¸ÿÿƒìf9E„®ÿuMèè2áûÿ‹Eì‹€¨…Àu!‹MA¿fƒøw
fƒÁ ·Á‰Eøf‹È·Á‰Eøëºjf9Us0ÿuèÿÿYY…Àu	f‹E·Àë‹Eì·M‹€”¶·À‰EøëMüQjMQRPè6ƒÄ…Àuf‹E·À‰Eøëf‹Eü€}ôt
‹M胡Pý‹å]ËÿU‹ìjÿuè(ÿÿÿYY]ÃÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹u‹ÿŠ
ÀtƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìjÿuÿuèƒÄ]ËÿU‹ìƒìƒ}uèýÿÇèÌþÿ3ÀëgV‹u…öuèðýÿÇè°þÿë9ur3ÀëCÿuMðèÌßûÿ‹UøƒztNÿI9Mw
¶öDuð‹Æ+Áƒà+ðN€}üt
‹Mðƒ¡Pý‹Æ^‹å]Ãè&Sÿÿ3É„À”Á‹ÁËÿU‹ìƒì¡ÀF3ʼnEüSVWÿuMèè`ßûÿ‹Eì3ÿWWÿu‹@ÿu‰Eøèk¥þÿ‹Ø…Û„“J;ÑÀ…ÁtJJ;ÑÀ#ÁJ=w;ÑÀ#Áè¯@‹ô…ötZÇÌÌë;ÑÀ#ÁPèˆþÿ‹ðY…öt?ÇÝ݃Æë‹÷…öt.SVÿuÿuèö¤þÿ…Àt‹EWWP÷ØÀ#EPjÿVWÿuøÿرE‹øVè}ëþÿY€}ôt
‹E胠Pý‹ÇeÜ_^[‹Mü3ÍèøLûÿ‹å]ËÿU‹ìì¡ÀF3ʼnEü‹E‹MS‹]V‹uW3ÿ‰pÿÿÿ‰µxÿÿÿ‰;ƒø…âh€…|ÿÿÿPÿuVQè²þÿÿƒÄ‰…tÿÿÿ…ÀtFjP襈þÿW‰èý†þÿƒÄ9;„‹tÿÿÿAÿP…|ÿÿÿPQÿ3è®)ÿÿƒÄ…À…3ÀéðÿH±Eƒøz…ÞWWÿuVÿµpÿÿÿè?þÿÿƒÄ‰…tÿÿÿ…À„¼jPè.ˆþÿ‹ðYY…öt*ÿµtÿÿÿVÿuÿµxÿÿÿÿµpÿÿÿèþÿÿƒÄ…Àt‹Æ‹÷‰ëƒÏÿVèS†þÿY‹Çëwƒøu‹E‰8èýÿ‹Mà‰ÇEüþÿÿÿè‹Ãè’UûÿË]äjè¿·þÿYÃjh«Fè3Uûÿ3ö‰uäjè]·þÿY‰uüèÔÿüÿ‹‰Eàÿuÿu‹}WèNƒÄ‹Ø‰]ä…Ût‹M‰9èªÿüÿ‰ë!…ÿuèEÇþÿ…Àtp,‹>‹E‰8èŠÿüÿ‹Mà‰ÇEüþÿÿÿè‹ÃèUûÿË]äjè/·þÿYËÿU‹ìVW‹}Wè
‹ðY…öujXéÅ€>uWègYS3Ûë&hVè©YY„ÀuêjëÔhVè”YY„Àt7SVè°§ÿÿYY…Àtâ‹U…Òt.…ÿ‹}t"‹ÎYŠA„Àuù+Ë;Ïr…ÿtˆj"ëUjëQ3ÛVWRë:èpÆþÿ…Àt?x(…ÿt8‹…Àujhè0ƒþÿS‰èˆþÿ‹ƒÄ…ÀtVhPèU‚þÿƒÄ…Àu
ëjX[_^]ÃSSSSSèk‰þÿÌ‹ÿU‹ìQVW‹}WèS‹ðY…öujXéÀS3Û‰]üf9uWèYëjé£hVè#YY„ÀtèSVèï¥ÿÿYY…Àtâ‹U…Òt4…ÿ‹}t(‹ÎYf‹ƒÁf;Eüuô+ËÑù;Ïr
…ÿt3Àf‰j"ëQ3ÛVWRë:èÅþÿ…Àt?x,…ÿt8‹…ÀujhèA‚þÿS‰虀þÿ‹ƒÄ…ÀtVhPèÛ«þÿƒÄ…ÀuëjX[_^‹å]ÃSSSSSèzˆþÿÌ‹ÿU‹ìV‹uj.Vè
VûÿYY‹È…Éu	è.ˆþÿ2Àë-;Îró+Æ9EvìSWj$3ÛySWè_ýÿƒÄƒÀ‹ÈÓÊu2À_[^]Ãj$+÷uVWRPèœÿÿƒÄ…Àu°ëàSSSSSèˆþÿÌ‹ÿU‹ìQj.ÿuèç?YY‹È…Éu	è·‡þÿ2Àë?;Mrò+EW‹}Ñø;øw	蜇þÿ2Àë#Sj$YjSèâýÿƒÄƒÀ‹È‰EüƒÒÊu2À[_‹å]ËÃ+Ej$Ñø+øWSRÿuü趛ÿÿƒÄ…Àu°ëÙ3ÀPPPPPèp‡þÿÌ‹ÿU‹ì‹Eÿ0‹Eÿ0èYY]ËÿU‹ì‹Eÿ0‹Eÿ0ÿ0±E]ËÿU‹ìV‹uƒ<µßFujh讀þÿj‰µßFèþÿƒÄ‹µßF^]ËÿU‹ìV‹uƒ<µ(ßFujhèt€þÿj‰µ(ßFèÆ~þÿƒÄ‹µ(ßF^]ËÿU‹ìSW‹}Wè|ÿÿÿ‹ØY…Ût{Shèm
YY…Àtg=îw`V4ƒïtƒït
ƒïuÆuëÆtëÆsF+ÞÃÿŒ±Ej$SV3ÛSPèNšÿÿƒÄ…Àu&‹ÎQŠA„Àuù+ÊþÀfÇ.0ˆ\^ëÆ2À_[]ÃSSSSSè*†þÿÌ‹ÿU‹ìSW‹}Wèÿÿÿ‹ØY…Û„šShÿ0±E…À„=îwzV4Cƒïtƒït	ƒïujxëjwëjvXf‰ƒÆ‹Æ¿+ÃÑø+øÿŒ±Ej$WV3ÛSPèÞ™ÿÿƒÄ…Àu:‹ÎQf‹ƒÁf;Ãuõ+ÊÑùj.NYf‰j0Yf‰H3Éf‰H°^ë3Àf‰2À_[]ÃSSSSSèd…þÿÌ‹ÿU‹ì‹Eÿ0‹Eÿ0èÿ¢ÿÿYY]ËÿU‹ì‹Eÿ0‹Eÿ0è¢ÿÿYY]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èé}þÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0è@¨þÿƒÄ]ËÿU‹ì‹E¾‹EQÿ0èƒRûÿYY]ËÿU‹ì‹Ef¾·È‹EQÿ0è¹<YY]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0èÉýÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0è³ýÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿpÿ0èO˜ÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Eÿpÿ0èk˜ÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Ejÿ0è˜ÿÿƒÄ]ËÿU‹ì‹Eÿ0‹Eÿ0‹Eÿ0‹Ejÿ0è!˜ÿÿƒÄ]ËÿU‹ì‹E‰‹E‰A‹E‰A‹Á]Â‹ÿU‹ì‹E‰‹E‰A‹E‰A‹Á]Â‹A‹Q‹	‹+ËA‹QV‹0‹+2Ñþ‹+Æ^ÃjhÀªFè×Mûÿ3À‹u…ö•À…Àuèzøüÿj^‰0è;ƒþÿ‹ÆèùMûÿÃ&ƒeäjèÚ¯þÿYƒeüÿuVè,YY‹ð‰uä…ötè<øüÿ‰0ÇEüþÿÿÿè뼋uäjèê¯þÿYÃjh ªFè^MûÿjèÅûÿÿY‹ø…ÿujXé€?ujèüÿÿY„ÀujëåhWè]úÿÿYëéEäP蔃þÿYƒ}äujëÃ3ö‰u܉uüèº÷üÿ‹è³÷üÿ‰0‰uàh€ÿuhB…WEàPèiþÿƒÄ‹ð‰u܃þuhWèþùÿÿYY„ÀuËèt÷üÿƒ8uèj÷üÿ‰ƒ}àÿt[‹uäWè¡lþÿY‰F‹Eä3Ò9Puÿuàè„xþÿYj^ë3‰P‹Eä‰P‹E䉋
°ÙFƒÉ‹EäƒÀð	‹Mä‹Eà‰A‹M‹E䉋ò‰uÜÇEüþÿÿÿè‹Æè„LûÿËuÜ‹EäƒxÿuPèƒþÿYÿuäèÆûÿYËÿU‹ì‹E…ßF]ËÿU‹ì‹E…(ßF]ÃèW¾þÿ…ÀuÃÀ(ÃèI¾þÿ…ÀuÃÀ,ËÿU‹ì]é{9ÿDÉFËÿSVWj_¾ßF‹ßÿ6èUyþÿƒ&vYƒëuí¾(ßFÿ6è=yþÿƒ&vYƒïuí_^[ËÿU‹ìQƒeüEüPjhÿuè6öÿÿ‹EüƒÄ‹å]ËÿU‹ìQƒ}uèöüÿÇèЀþÿjXëEüPjÿuÿuèúõÿÿƒÄ‹å]ËÿU‹ìQƒeüEüj@Pè:ýÿÿ‹EüYY‹å]ËÿU‹ìjÿuè"ýÿÿYY]ËÿU‹ìQƒeüEüPjhÿuèõÿÿ‹EüƒÄ‹å]ËÿU‹ìQƒ}uèõüÿÇè?€þÿjXëEüPjÿuÿuèÙôÿÿƒÄ‹å]ËÿU‹ìV‹u…ö~
VÿuèɪþÿYY‹ð‹E…À~Pÿu赪þÿYY…öt…Àt3ÉQQQPÿuVÿuÿuÿu軑þÿë+ðujXë3À…ö™ÀE^]ËÿU‹ìƒì,¡ÀF3ʼnEü‹ESV‹u‰EØ‹E‰EÔ‹E‰EÜW‹}‰}à…ö~"VWèµY‹ð‹EÜY‹] …Û~SPè YY‹Øëƒþÿ}ç3Àé2ƒûÿ|ô‹E$…Àu‹EØ‹‹@‰E$…öt…Û…;óujXéƒû~3À@éöƒþ~jëäMèQPÿÜ°E…Àt¥…ö~/jX9Eèrá€}îMîtØŠQ„ÒtÑŠ:r:Ú†´È€9uä뺅Û~5jX9Eèr¡€}îMît˜‹uÜŠQ„ÒtŽŠ:r:Ú†~È€9uäétÿÿÿ3ÿWWVÿuàj	ÿu$ÿh°E‰EØ…À„ÿÿÿJ;ÑÀ…ÁtYJ;ÑÀ#ÁJ=w ;ÑÀ#Áè/‹Ä‰Eä…À„ÇÌÌë;ÑÀ#ÁPèvþÿ‰EäY…À„ïÇÝ݃À‰Eäë‹Ç‰}ä…À„ÔÿuØPVÿuà‹u$jVÿh°E…À„¸WWSÿuÜj	Vÿh°E‰Eà…À„žJ;ÑÀ…ÁtJJ;ÑÀ#ÁJ=w;ÑÀ#Áès.‹ô…öt`ÇÌÌë;ÑÀ#ÁPèÞuþÿ‹ðY…ötEÇÝ݃Æë‹÷…öt4ÿuàVSÿuÜjÿu$ÿh°E…Àt‹]äWWWÿuàVÿuØSÿuÿuÔè'þÿ‹øë‹]äVè8ÙþÿYë‹]äSè,ÙþÿY‹ÇeÈ_^[‹Mü3Íè·:ûÿ‹å]ËÿU‹ìƒìÿuMðè1Ìûÿÿu$Eôÿu ÿuÿuÿuÿuÿuPè'ýÿÿƒÄ €}üt
‹Mðƒ¡Pý‹å]ËÿU‹ì‹M3À8t;Et@€<uô]ËÿU‹ìVèäÿÿ‹u‰èIäÿÿ‰F3À^]ËÿU‹ìQQƒeøƒeüV‹uÿ6èÏäÿÿÿvèGåÿÿEøPè¸ÿÿÿ‹ƒÄ;Eøu‹F;Eüu3Àë3À@^‹å]ËÿU‹ìQQƒeøEøƒeüPè‚ÿÿÿY…Àt3À@ë)‹M‹Uø‹Eü‰AEø‰ƒÊP‰UøèxÿÿÿY…ÀuÙ誂ÿÿ3À‹å]ÃÌÌÌÌÌÌÌ̃=täF„‚ƒì®\$‹D$%€=€uÙ<$f‹$fƒàfƒød$uUéyƒ=täFt2ƒì®\$‹D$%€=€uÙ<$f‹$fƒàfƒød$ué%ƒìÝ$èB
è
ƒÄÃT$èí	R›Ù<$tL‹D$f<$tÙ-(OF©ðt^©€uAÙìÙÉÙñƒ=4ßF…

MFºé	
©€uëÔ©ÿÿuƒ|$u%€tÅÝØÛ-àNF¸ë"èX	ë©ÿÿuŃ|$u¾ÝØÛ-ŠNF¸ƒ=4ßF… 	
MFºè™
ZÃ=täF„
ƒì®\$‹D$%€=€uÙ<$f‹$fƒàfƒød$…Ûëó~D$f(0MFf(Èf(øfsÐ4f~ÀfTPMFfúÐfÓÊ©tL=ÿ|}fóÊ=2fÖL$ÝD$Ãf.ÿ{$ºìƒì‰T$‹ÔƒÂ‰T$‰T$‰$è
ƒÄÝD$Ãó~D$fóÊf(ØfÂÁ=ÿ|%=2°fT MFòXÈfÖL$ÝD$ÃÝ`MFÃfÂ@MFfT MFfÖ\$ÝD$Ã3ÀPPjPjh@hhMFÿä±E£`ÉFá`ÉFƒøÿtƒøþtPÿ<±EËÿU‹ìV‹u…ö~Vÿuèõ£þÿY;ÆYp|‹ð3ÀPPPÿuÿuVÿuÿuÿuè…‘þÿ^]ËÿU‹ìì¡ÀF3ʼnEüV‹u…ðýÿÿWh
3ÿWPèaLûÿƒÄ…ðýÿÿPhÿ0±E…Àu3Àë&èWŠþÿWWÿu÷ØðýÿÿVjÿQÀ@WPÿرE…Àt×H‹Mü_3Í^è46ûÿ‹å]Ãj
è'"£täF3ÀËÿU‹ì‹E3Ƀ=ÏFÁ÷ØÀ#Á£täF]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìƒìƒäðÝ$ó~$èÉÃfD$ºf(èfÀfsÕ4fÅÍf(
€MFf(MFf(ðMFf(% MFf(5°MFfTÁfVÃfXàfÅÄ%ðf(  TFf(¸PFfTðf\ÆfYôf\òòXþfYÄf(àfXÆáÿƒéùý‡¾éþÊò*ñföÁá
Á¹ºƒøDÑf(
@NFf(Øf(PNFfYÈfYÛfXÊf(`NFòYÛf(-ÀMFfYõf(ªÐMFfTåfXþfXüfYÈòYØfXÊf(pNFfYÐf(÷föfY˃ìf(ÁfXÊfÀòXÁòXÆòXÇfD$ÝD$ƒÄÃfD$f(
NFòÂÈfÅÁƒøwHƒùÿt^ùþwlfD$f(
€MFf(ðMFfTÁfVÂòÂÐfŃøtÝ(NFúéëOfðMFò^Ðf
 NFºë4f
NFòYÁºÌÿÿÿéþÿÿƒÁáÿùÿs:fWÉò^ɺ	ƒìfL$‰T$‹ÔƒÂ‰T$ƒÂ‰T$‰$è4ÝD$ƒÄÃfT$fD$f~ÐfsÒ f~ÑáÿÿÁƒøt ºé릤$ëÌÌÌÆ…pÿÿÿþ
íu;ÙÉÙñë
Æ…pÿÿÿþ2íÙêÞÉè+ÙèÞÁö…aÿÿÿtÙèÞñöÂ@uÙý
ítÙàé²èFÀt2íƒøtöÕÙÉÙáë¯éµéKÝØÝØÛ-€NFÆ…pÿÿÿÃÙíÙÉÙä›Ý½`ÿÿÿ›ö…aÿÿÿAuÒÙñÃÆ…pÿÿÿÝØÛ-ŠNFÃ
ÉuSÃÙìëÙíÙÉ
Éu®ÙñÃé[èÏÝØÝØ
ÉuÙîƒøu
ítÙàÃÆ…pÿÿÿÛ-€NFƒøuí
ítéÙàëåÝØé
ÝØéµXÙä›Ý½`ÿÿÿ›ö…aÿÿÿuÝØÛ-€NF
ítÙàÃÆ…pÿÿÿé×ÝØÝØÛ-€NFÆ…pÿÿÿÃ
Éu¯ÝØÛ-€NFÃÙÀÙáÛ-žNFÞٛݽ`ÿÿÿ›ö…aÿÿÿAu•ÙÀÙüÙä›Ý½`ÿÿÿ›Š•aÿÿÿÙÉØáÙä›Ý½`ÿÿÿÙáÙðÃÙÀÙüØÙ›ßàžuÙÀÜ
²NFÙÀÙüÞÙ›ßàžt
¸øëø¸ëñVƒìt‹ôVƒìÝ$ƒìÝ$›Ývè{ƒÄÝf݃Ät^…ÀtéÐÃÌÌÌÌÌÌÌÌÌ€zuf‹\ÿÿÿ€Ï€çþ³?ëf»?f‰^ÿÿÿÙ­^ÿÿÿ»OFÙ剕lÿÿÿ›Ý½`ÿÿÿÆ…pÿÿÿ›ŠaÿÿÿÐáÐùÐÁŠÁ$×¾Àá‹Ú؃Ãÿ#€zuf‹\ÿÿÿ€Ï€çþ³?ëf»?f‰^ÿÿÿÙ­^ÿÿÿ»OFÙ剕lÿÿÿ›Ý½`ÿÿÿÆ…pÿÿÿÙÉŠaÿÿÿÙå›Ý½`ÿÿÿÙÉŠ­aÿÿÿÐåÐýÐÅŠÅ$׊àÐáÐùÐÁŠÁ$×ÐäÐä
ľÀá‹Ú؃Ãÿ#èÎÙÉÝØÃèÄëöÝØÝØÙîÃÝØÝØÙî„ítÙàÃÝØÝØÙèÃÛ½bÿÿÿÛ­bÿÿÿö…iÿÿÿ@tÆ…pÿÿÿÃÆ…pÿÿÿÜþNFÃÙÉÛ½bÿÿÿÛ­bÿÿÿö…iÿÿÿ@t	Æ…pÿÿÿëÆ…pÿÿÿÞÁÃÛ½bÿÿÿÛ­bÿÿÿö…iÿÿÿ@t ÙÉÛ½bÿÿÿÛ­bÿÿÿö…iÿÿÿ@t	Æ…pÿÿÿëÆ…pÿÿÿÞÁÃÝØÝØÛ-àNF€½pÿÿÿÆ…pÿÿÿ
ÉÃÝØÝØÛ-ôNF
ítÙà
ÉtÝOFÞÉÃ
ÉtÙàËÿU‹ì¡4ßF‹M‰
4ßF]ÃÌÌÌÌÌÌÌÙÀÙüÜáÙÉÙàÙðÙèÞÁÙýÝÙËT$âƒÊf‰T$Ùl$ét¸ÃÜ OF¸Ã‹B%ð=ðtÝËBƒì

ÿ‰D$‹B‹
¤ÈÁá‰D$‰$Û,$ƒÄ
©‹BËD$%ð=ðtËD$Ãf<$tÙ,$ZÃf‹$f=tfƒà t›ßàfƒà t¸èÙZÃÙ,$ZÃìÝ$‹D$ƒÄ%ðëƒìÝ$‹D$ƒÄ%ðt==ðt_f‹$f=t*fƒà u!›ßàfƒà t¸ƒútè{ZÃè]ZÃÙ,$ZÃÝLOFÙÉÙýÝÙÙÀÙáÜYYtèAþÿ„ÀtVèdþÿY…Àuÿ6èXY‹Mü_3Í^è×'ûÿ‹å]‹ã[ËÿU‹ìQQÝEÙüÝ]øÝEø‹å]ËÿU‹ì‹E¨ tjë¨t3À@]ètjë¨tjX]öÀƒàÀ]ËÿS‹ÜQQƒäðƒÄU‹k‰l$‹ì숡ÀF3ʼnEüV‹s CWVPÿsèƒÄ…Àu&ƒeÀþPCPCPÿsC ÿsPE€P膋s ƒÄÿsè^ÿÿÿY‹øèWþÿ„Àt)…ÿt%ÝCVƒìÝ\$ÙîÝ\$ÝCÝ$ÿsW苃Ä$ëWèQÇ$ÿÿVèFÝÿÿÝCYY‹Mü_3Í^è¿&ûÿ‹å]‹ã[ËÿS‹ÜQQƒäðƒÄU‹k‰l$‹ì숡ÀF3ʼnEüV‹s(C WVPÿsèÏÝCƒÄ…Àu4‹EÀƒàãƒÈ‰EÀC jPCPÿsC(ÿsÝ]°PE€Pè©‹s(ƒÄëÝØÿsè}þÿÿY‹øèvþÿ„Àt*…ÿt&ÝC VƒìÝ\$ÝCÝ\$ÝCÝ$ÿsW詃Ä$ëWèoÇ$ÿÿVèdÜÿÿÝC YY‹Mü_3Í^èÝ%ûÿ‹å]‹ã[ËÿU‹ì‹M3À9ÅÈXFt
@ƒø|ñ3À]ËÅÌXF]ËÿU‹ìƒìS‹]V‹óƒæöÃtöEtjè.ÜÿÿYƒæ÷é‹Ã#E¨tjèÜÿÿYƒæûéwöÄšöE„jèòÛÿÿ‹EY¹#ÁtT=t7=t;Áub‹MÙîÜßàÝÐYFöÄ{LëH‹MÙîÜßàöÄ{,ÝÐYFë2‹MÙîÜßàöÄzÝÐYFë‹MÙîÜßàöÄzÝÀYFëÝÀYFÙà݃æþéÔöÄËöE„ÁW3ÿöÃtG‹MÝÙîÚéßàöÄD‹‘ÝEüPQQÝ$èû‹EüƒÄúÿÿ‰EüÝUðÙî=Îûÿÿ}3ÿÞÉGëYÞÙ3ÒßàöÄAuB‹Eö¹üÿÿƒàƒÈf‰Eö‹Eü;Á}++È‹EðöEðt…ÿuGÑèöEô‰Eðt
€‰EðÑmôƒéuÚÝEð…ÒtÙà‹EÝë3ÿG…ÿ_tjè™ÚÿÿYƒæýöÃtöE tj èƒÚÿÿYƒæï3À…ö^”À[‹å]ËÿU‹ìÝEÜE]ËÿU‹ìjÿuÿuÿuÿuÿuÿuèƒÄ]ËÿU‹ì‹E3ÉS3ÛC‰H‹EW¿
À‰H‹E‰H‹MöÁt‹E¿À	XöÁt‹E¿“ÀƒHöÁt‹E¿‘ÀƒHöÁt‹E¿ŽÀƒHöÁt‹E¿ÀƒH‹MV‹u‹Áà÷Ð3Aƒà1A‹M‹À÷Ð3Aƒà1A‹M‹Ñè÷Ð3Aƒà1A‹M‹Áè÷Ð3Aƒà1A‹‹MÁè÷Ð3A#Ã1Aè¾Ùÿÿ‹ÐöÂt‹MƒIöÂt‹EƒHöÂt‹EƒHöÂt‹EƒHö t‹E	X‹¹#Át5=t"=t;Áu)‹Eƒë!‹M‹ƒàþƒÈ‰ë‹M‹ƒàýÃëð‹Eƒ ü‹¹#Át =t;Áu"‹Eƒ ãë‹M‹ƒàçƒÈë‹M‹ƒàëƒÈ‰‹E‹MÁá3áàÿ1‹E	X ƒ} t,‹Eƒ` á‹EÙ‹EÙX‹E	X`‹E‹]ƒ``á‹EÙÙXPë:‹M‹A ƒàãƒÈ‰A ‹EÝ‹EÝX‹E	X`‹M‹]‹A`ƒàãƒÈ‰A`‹EÝÝXPèß×ÿÿEPjjWÿd±E‹MöAtƒ&þöAtƒ&ûöAtƒ&÷öAtƒ&ïöAtƒ&ß‹ºÿóÿÿƒàƒèt5ƒèt"ƒèt
ƒèu(ë ‹%ÿûÿÿ
‰ë‹%ÿ÷ÿÿ
ëî!‹Áèƒàƒètƒèt	ƒèu!ë‹#Â
ë	‹#Â
‰ƒ} ^tÙAPÙëÝAPÝ_[]ËÿU‹ìjÿuÿuÿuÿuÿuÿuèñüÿÿƒÄ]ËÿU‹ì‹EƒøtƒÀþƒøwèØüÿÇ"]Ãèù×üÿÇ!]ËÿU‹ì‹Uƒì 3É‹Á9ÅÈXFt@ƒø|ñë‹ÅÌXF‰Mä…ÉtU‹E‰Eè‹E‰Eì‹E‰Eð‹EV‹u‰Eô‹E hÿÿÿu(‰Eø‹E$‰uà‰EüèmÖÿÿEàPèbûýÿƒÄ…ÀuVèUÿÿÿYÝEø^ëhÿÿÿu(èCÖÿÿÿuè9ÿÿÿÝE ƒÄ‹å]ËÿU‹ì·M‹EÝEüÿÿÁéáÿÁPQQÝ$èƒÄ]ËÿU‹ìÝEÙîÝáßàWöÄDz	ÝÙ3ÿé¯Vf‹u·Æ©ðu|‹M‹U÷Áÿÿu…ÒtjÞÙ¿üÿÿßàöÄAu3À@ë3ÀöEuɉM…ÒyƒÉ‰MÒOöEtèf‹u‰U¹ïÿf#ñf‰u…Àt¸€fðf‰uÝEjQQÝ$èsƒÄë#jQÝØQÝ$è`·þƒÄÁïçÿïþ^‹E‰8_]ËÿU‹ì·EÁè%ÿ-þ˜]ËÿU‹ìQQ‹M·EÝE%€ÁáÝ]øÈf‰MþÝEø‹å]ËÿU‹ìQQ‹M·EÝE%€Ý]ø‰þÁáÈf‰MþÝEø‹å]ËÿU‹ì}ð‹Eu…Àu@]Ã}ðÿu	…ÀujX]Ãf‹Mºøf#Êf;Êujëèºðf;Êu÷Eÿÿu…ÀtjëÍ3À]ËÿU‹ìQQÙî‹EÝ]ø‰Eø‹E‹È÷Ñ3È÷Ðáÿÿÿ3ȉMüÝEø‹å]ËÿU‹ìQ‹E‹È÷Ñ3È÷Ðáÿÿÿ3ȉMüÙEü‹å]ËÿU‹ìQQÙî‹EÝ]ø‰Eø‹E3E%ÿÿÿ3E‰EüÝEø‹å]ËÿU‹ìQ‹E3E%ÿÿÿ3E‰EüÙEü‹å]ËÿU‹ìºð3À‹Êf#Mf;Ê•À]ËÿU‹ìf‹Mºðf‹Áf#Âf;Âu3ÝEQQÝ$èÈþÿÿYYƒètƒètƒèt3À@]ÃjëjX]ø]÷Éá€f…Àu÷Eÿÿuƒ}t÷ÙɃá€]ÃÝEÙîÚéßàöÄDz÷ÙɃáàA@]Ã÷ÙÉáÿÿÿ]ËÿU‹ìf‹Eºøf#ÂJøf;Áu÷Eÿÿuƒ}uf;Âu3À@]Ã3À]ËÿU‹ìƒìVW¿ÿÿWh?è·ÒÿÿÝE‹ðYY·M¸ð#Èf;ÈuLQQÝ$èÙýÿÿYY…À~
ƒø~)ƒøt-ÝEÝPFVƒìØÁÝ\$Ý$j%jèkôÿÿƒÄë\WVè[ÒÿÿYYÝEëNÙîÝéßàöÄDzÝÀYFVƒìÙàÝ\$Ý$j%jëÄEüPQQÝ$è üÿÿ‹EüÝØH‰EøÛEøWVÝ]ôèÒÿÿÝEôƒÄ_^‹å]ËÿU‹ìÝEƒìÝ\$ÝEÝ$èƒÄ]ËÿU‹ìÿuÝEQQÝ$èƒÄ]ËÿU‹ìƒìVW¿ÿÿWh?è­ÑÿÿÝE‹ðYY·M¸ð#Èf;ÈuiQQÝ$èÏüÿÿYY…À~-ƒø~aƒøu#ÛEƒìÝ]ôÝEôÝ\$ÝEÝ$è÷ÿÿƒÄésÝEÝPFØÁVƒìÝ\$ÛEÝ]ôÝEôÝ\$Ý$jjé?ÙîÝéßàöÄDzÝØWVèÑÿÿÝEYYé)EüPQQÝ$èÿúÿÿ‹MƒÄ‹Uü…Éy
¸€+Á;Ð|Zë¸ÿÿÿ+Á;и
=
ª=~-úÿÿPQQÝ$èÇûÿÿƒÄVƒìÝ\$ÛEÝ]ôÝEôÝ\$éž=öÿÿ}%ÙîÞÉVƒìÝ\$ÛEÝ]ôÝEôÝ\$ÝEÝ$jjë|=üÿÿ}&PQQÝ$ègûÿÿƒÄVƒìÝ\$ÛEÝ]ôÝEôëÃPQQÝ$èFûÿÿWVÝ]ôè(ÐÿÿÝEôƒÄë:VƒìÝ\$ÝÀYFÝ$èýûÿÿÝ\$ÛEÝ]ôÝEôÝ$QQÝEÝ$jjè»òÿÿƒÄ$_^‹å]ËÿU‹ìÝEƒìÝ\$ÝEÝ$èƒÄ]ËÿU‹ìSVEWPèQYj·ð»ð_f;÷„EPèâÝEYf;Ç„ÝEÝáßàöÄD‹ô3ÉAf;ñu$f‹E¹ïÿf#ÁÇE
ÿÿÿÿKÿÝØfÁÝعÿÿëf…öuÞÙßàöÄz3À븀f‰Ef‰Mé©ØÑßàÙîöÄz	ØÑßàöÄ{ÙÊØÙßàöÄzFÞÙßàöÄzAëÝÙÝÙÝØfƒEurfƒE
ukfƒEudf‹Ef@f‰E·À%ÿÿÿ;ÃuNjèåYëDÝØÝØf‹E¹ÿÿfÁf‰Ef;Áu+f‹E
fÁf‰E
f;Áuf‹EfÁf‰Ef;ÁufMëÝØÝ]f…]_^[ujèŽYÝE]ËÿU‹ìQV‹u¸ÿ·V‹ÊÁé#ȉMüf;Èu&öÂu3Àf9Fuf9Fuf9u@éÂjXéº÷Âÿÿÿu3Àf9Fuf9Fuf9u3À阸3+Á+E·Èf‹Á‰Müf…À~áWj5_f;ø3À Ff‰ƒÈÿf‰Vë_fÁøƒá¿ø·MèYF‹½ZF·N#Ð3‰Uüf‰Nf‹ÊƒïtƒïtƒïufN3Àf‰FfN3Àf‰Ff3Àf‰3Àf…É”ÀH_^‹å]ËÿU‹ì‹MV¾ð·A‹Ð#Öf;Ö^u¨u3Àf9Auf9Auf9u@]ÃjX]éÿÿÿu3Àf9Au
f9Auf9u]Ã3Àf…Ò•Àƒè]ËÿU‹ìQV‹u¸ÿ·N‹ÑÁê#ЉUüf;ÐuöÁufƒ>u3À@é•jXé÷Áÿÿÿu
fƒ>u3Àë{¸–+Â+E·ÀWf‹ø‰Eüf…ÿ3Àë]jZf;×3Àá€f‰ƒÈÿf‰NëAƒàfÁÿ·EZF¿Ç‹…8ZF·N#Ð3‰Uüf‰N3Àf‹Êf;Ç}ff‰3Àf…É”ÀH_^‹å]ËÿU‹ì‹MV¾€·A‹Ð#Öf;Ö^u¨ufƒ9u3À@]ÃjX]éÿÿÿu
fƒ9u3À]Ã3Àf…Ò•Àƒè]ËÿU‹ìQEüjPè¢ÿuüÿuèƒÄ‹å]ËÿU‹ì]éJýÿÿ‹ÿU‹ì]éFþÿÿ‹ÿU‹ìS‹]3ÀöÃtƒË öà t3À@öÃtƒÈöÃtƒÈöÃtƒÈV‹óƒætƒÈPèK»ÿÿ	EEjPèYƒÄ…ö^t
èdÌüÿÇ!ëöÃtèRÌüÿÇ"[]ËÿU‹ìW‹}ƒçu‹E!8ëV詾ÿÿW‹ðèòºÿÿY‹M#Æ^‰3À_]ËÿU‹ìöEu3À]ÃVWè}¾ÿÿÿu‹ðèĺÿÿ‹M‹ø÷×#þ‹	#ÈùW膿ÿÿƒçWèƒÄ3É;Ç•Á_‹Á^]ËÿU‹ìQÿuƒeüEüPèkÿÿÿ‹EüYYƒà‹å]Ãÿ%x±Eÿ%|±Eÿ%€±Eÿ%„±Eÿ%ˆ±Eÿ%Œ±Eÿ%±Eÿ%”±Eÿ%˜±Eÿ%œ±Eÿ% ±Eÿ%¤±Eÿ%¨±Eÿ%¬±Eÿ%°±Eÿ%´±Eÿ%¸±Eÿ%¼±Eÿ%À±Eÿ%ıEÿ%ȱEÿ%̱Eÿ%бEÿ%Ô±Eÿ%رEÿ%ܱEÿ%à±Eÿ%ä±Eÿ%è±Eÿ%ì±Eÿ%ð±Eÿ%ô±Eÿ%ø±Eÿ%ü±Eÿ%²Eÿ%²Eÿ%²Eÿ%²Eÿ%²Eÿ%²Eÿ%²Eÿ%²Eÿ% ²Eÿ%$²Eÿ%(²Eÿ%,²Eÿ%0²Eÿ%4²Eÿ%8²Eÿ%<²Eÿ%@²Eÿ%D²Eÿ%t±Eÿ%p±Eÿ%l±Eÿ%h±Eÿ%`±Eÿ%±Eÿ%±Eÿ%±Eÿ%±Eÿ%±Eÿ%ü°Eÿ%ø°Eÿ%ô°Eÿ%ð°Eÿ%ì°Eÿ%è°Eÿ%ä°Eÿ%à°Eÿ%Ü°Eÿ%Ø°Eÿ%Ô°Eÿ%аEÿ%Ì°Eÿ%È°Eÿ%Ä°Eÿ%À°Eÿ%¼°Eÿ%¸°Eÿ%´°Eÿ%0±Eÿ%\±Eÿ%¨°Eÿ%d±EÌÌÌÌU‹ì‹E3ÒSVW‹H<È·A·YƒÀÁ…Ût‹}‹p;þr	‹HÎ;ùr
BƒÀ(;Órè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìjþh «Fh`‹@d¡PƒìSVW¡ÀF1Eø3ÅPEðd£‰eèÇEüh@è|ƒÄ…ÀtT‹E-@Ph@èRÿÿÿƒÄ…Àt:‹@$Áè÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹3É8À”Á‹ÁËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]ÃÌÌÌÌÌÌU‹ì‹E¹MZf9t3À]ËH<È3À9PEuºf9Q”À]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌV‹D$Àu(‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$v	N+D$T$3Û+D$T$÷Ú÷؃ڋʋӋًȋÆ^ÂÇDZFÃU‹ìöEV‹ñÇDZFt
jVèOYY‹Æ^]ÂÌ‹D$‹L$È‹L$u	‹D$÷áÂS÷á‹Ø‹D$÷d$Ø‹D$÷áÓ[ÂÌÌÌÌÌÌÌÌÌÌÌÌWVU3ÿ3í‹D$À}GE‹T$÷Ø÷ڃ؉D$‰T$‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$Àu(‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹Ø‹L$‹T$‹D$ÑëÑÙÑêÑØÛuô÷ñ‹ð÷d$‹È‹D$÷æÑr;T$wr;D$v	N+D$T$3Û+D$T$My÷Ú÷؃ڋʋӋًȋÆOu÷Ú÷؃Ú]^_ÂÌWVS3ÿ‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$Àu‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ÓëA‹Ø‹L$‹T$‹D$ÑëÑÙÑêÑØÛuô÷ñ‹ð÷d$‹È‹D$÷æÑr;T$wr;D$vN3Ò‹ÆOu÷Ú÷؃Ú[^_ÂÌÌÌÌÌÌSW3ÿ‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$‹D$À}‹T$÷Ø÷ڃ؉D$‰T$Àu‹L$‹D$3Ò÷ñ‹D$÷ñ‹Â3ÒOyNëS‹Ø‹L$‹T$‹D$ÑëÑÙÑêÑØÛuô÷ñ‹È÷d$‘÷d$Ñr;T$wr;D$v+D$T$+D$T$Oy÷Ú÷؃Ú_[ÂÌÌÌÌÌÌÌÌÌÌÌÌÌÌ€ù@s€ù s¥ÂÓàËÐ3À€áÓâÃ3À3ÒÃÌ€ù@s€ù s­ÐÓêËÂ3Ò€áÓèÃ3À3ÒÃÌh`‹@dÿ5‹D$‰l$l$+àSVW¡ÀF1Eü3ʼnEäP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£òËMä3ÍòèÞûÿòéüûÿÌÌÌÌÌÌQL$+ȃáÁÉÁYéQL$+ȃáÁÉÁYéÌÌÌÌQL$+ÈÀ÷Ð#È‹Ä%ðÿÿ;Èòr‹ÁY”‹‰$òÃ-…ëçÌÌ̃=ÏFt7U‹ìƒìƒäøÝ$ò,$ÉÃ=ÏFtƒìÙ<$XfƒàfƒøtÓ¤$IU‹ìƒì ƒäðÙÀÙT$ß|$ßl$‹T$‹D$…Àt<Þé…ÒyÙ$‹$ñ€ÁÿÿÿƒÐ‹T$ƒÒë,Ù$‹$ÁÿÿÿƒØ‹T$ƒÚë‹T$÷Âÿÿÿu¸Ù\$Ù\$ÉÃU‹ìÿuèY]Ãé‹êüÿS‹ÜQQƒäðƒÄU‹k‰l$‹ì‹Kƒì ƒ=ÏFf‹S|F·ÂfnÀòpÀfpЋÁ%ÿ=ðw<fïÉfuÈfuÂfëÈf×Á…Àu5jë,f;ÂtƒÁ·f…Àuð3Àf9•ÀH#Áë$·f;Âtf…ÀtjXÈ뢼À‰EüÈëÕ3Àë‹Á‹å]‹ã[ÃÌÌÌÌÌÌÌÌÌÌWV‹t$‹L$‹|$‹Á‹ÑÆ;þv;ø‚”ƒù ‚Òù€sº%ÀF‚Žéãº% ÏFs	ó¤‹D$^_ËÇ3Æ©uº%ÀF‚àº% ÏFƒ©÷Ç…÷Æ…¬ºçs
‹ƒév‰ºçsó~ƒévfÖ÷Æteºæƒ´foNôvô‹ÿfo^ƒé0foF fon0v0ƒù0foÓf:Ùffoàf:ÂfGfoÍf:ìfo 0}·vé¯foNøvøIfo^ƒé0foF fon0v0ƒù0foÓf:Ùffoàf:ÂfGfoÍf:ìfo 0}·vëVfoNüvü‹ÿfo^ƒé0foF fon0v0ƒù0foÓf:Ùffoàf:ÂfGfoÍf:ìfo 0}·vƒù|óoƒévfëèºás
‹ƒév‰ºásó~ƒévfÖ‹$qEÿà÷ÇtŠˆIƒÆƒÇ÷Çuí‹Ñƒù ‚®Áéó¥ƒâÿ$•$qEÿ$4qE4qE÷ÿÿ¶~ã¶Bã+øt3É…ÿŸÁMÿÿÿÿ…É…÷ÿÿ¶Nä¶Bä+Èt3À…ÉŸÀEÿÿÿÿë3É…É…ööÿÿ‹Få;B儶ø¶Bå+øt3É…ÿŸÁMÿÿÿÿ…É…Éöÿÿ¶~æ¶Bæ+øt3É…ÿŸÁMÿÿÿÿ…É…§öÿÿ¶~ç¶Bç+øt3É…ÿŸÁMÿÿÿÿ…É……öÿÿ¶Nè¶Bè+Èt3À…ÉŸÀEÿÿÿÿë3É…É…_öÿÿ‹Fé;B鄶ø¶Bé+øt3É…ÿŸÁMÿÿÿÿ…É…2öÿÿ¶~ê¶Bê+øt3É…ÿŸÁMÿÿÿÿ…É…öÿÿ¶~ë¶Bë+øt3É…ÿŸÁMÿÿÿÿ…É…îõÿÿ¶Nì¶Bì+Èt3À…ÉŸÀEÿÿÿÿë3É…É…Èõÿÿ‹Fí;B턶ø¶Bí+øt3É…ÿŸÁMÿÿÿÿ…É…›õÿÿ¶~î¶Bî+øt3É…ÿŸÁMÿÿÿÿ…É…yõÿÿ¶~ï¶Bï+øt3É…ÿŸÁMÿÿÿÿ…É…Wõÿÿ¶Nð¶Bð+Èt3À…ÉŸÀEÿÿÿÿë3É…É…1õÿÿ‹Fñ;Bñ„‚¶Bñ¶~ñ+øt3É…ÿŸÁMÿÿÿÿ…É…õÿÿ¶~ò¶Bò+øt3É…ÿŸÁMÿÿÿÿ…É…áôÿÿ¶~ó¶Bó+øt3É…ÿŸÁMÿÿÿÿ…É…¿ôÿÿ¶Nô¶Bô+Èt3À…ÉŸÀEÿÿÿÿë3É…É…™ôÿÿ‹Fõ;Bõ„¶ø¶Bõ+øt3É…ÿŸÁMÿÿÿÿ…É…lôÿÿ¶~ö¶Bö+øt3É…ÿŸÁMÿÿÿÿ…É…Jôÿÿ¶~÷¶B÷+øt3É…ÿŸÁMÿÿÿÿ…É…(ôÿÿ¶Nø¶Bø+Èt3À…ÉŸÀEÿÿÿÿë3É…É…ôÿÿ‹Fù;Bù„¶ø¶Bù+øt3É…ÿŸÁMÿÿÿÿ…É…Õóÿÿ¶~ú¶Bú+øt3É…ÿŸÁMÿÿÿÿ…É…³óÿÿ¶~û¶Bû+øt3É…ÿŸÁMÿÿÿÿ…É…‘óÿÿ¶Nü¶Bü+Èt3À…ÉŸÀEÿÿÿÿë3É…É…kóÿÿ¶~ý¶Bý+øt3É…ÿŸÁMÿÿÿÿ…É…Ióÿÿ¶Bþ¶~þ+ø„S÷ÿÿ3É…ÿŸÁMÿÿÿÿé8÷ÿÿ‹M¶¶1+ðt3À…öŸÀEÿÿÿÿ…À…ñ¶q¶B+ðt3À…öŸÀEÿÿÿÿ…À…϶q¶B+ðt3À…öŸÀEÿÿÿÿ…À…­¶I¶B+Èt3À…ÉŸÀEÿÿÿÿ‹Á錋U‹u¶
¶+Èt3À…ÉŸÀEÿÿÿÿ…Àuj¶J¶F+Èt3À…ÉŸÀEÿÿÿÿ…ÀuL¶J¶Fë‹U‹u¶
¶+Èt3À…ÉŸÀEÿÿÿÿ…Àu ¶J¶Fénÿÿÿ‹E¶‹E¶é]ÿÿÿ3À^[]Ëÿü~EƒE]‡E“‹Ey~E‚EƆEüŠEâ}EéE.†EeŠEJ}ERE—…E͉E³|E»€E…E6‰E|E$€Ei„EŸˆE…{EEÒƒEˆEîzEE;ƒEp‡EU‹ìQ‹M‹USVW‹}3Ûƒÿ ‚‹;„ˆ¶ð¶+ðt3À…öŸÀEÿÿÿÿ…À…<	¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…	¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…ø¶r¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…Ê‹B;A„‰¶ð¶A+ðt3À…öŸÀEÿÿÿÿ…À…¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…{¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…Y¶r¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…+‹B;A„‰¶ð¶A+ðt3À…öŸÀEÿÿÿÿ…À…þ¶r	¶A	+ðt3À…öŸÀEÿÿÿÿ…À…ܶr
¶A
+ðt3À…öŸÀEÿÿÿÿ…À…º¶r¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…Œ‹B;A„‰¶ð¶A+ðt3À…öŸÀEÿÿÿÿ…À…_¶r
¶A
+ðt3À…öŸÀEÿÿÿÿ…À…=¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…¶r¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…í‹B;A„‰¶ð¶A+ðt3À…öŸÀEÿÿÿÿ…À…À¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…ž¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…|¶r¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…N‹B;A„‰¶ð¶A+ðt3À…öŸÀEÿÿÿÿ…À…!¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…ÿ¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…ݶr¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…¯‹B;A„‰¶ð¶A+ðt3À…öŸÀEÿÿÿÿ…À…‚¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…`¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…>¶r¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…‹B;A„‰¶ð¶A+ðt3À…öŸÀEÿÿÿÿ…À…ã¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…Á¶r¶A+ðt3À…öŸÀEÿÿÿÿ…À…Ÿ¶r¶A+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…qj ^+þÖÎ;þƒúúÿÿ×σÿ‡Qÿ$½’¤E‹Bä;Aä„Š¶Aä¶rä+ðt3À…öŸÀEÿÿÿÿ…À…¶rå¶Aå+ðt3À…öŸÀEÿÿÿÿ…À…ü¶ræ¶Aæ+ðt3À…öŸÀEÿÿÿÿ…À…Ú¶rç¶Aç+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…¬‹Bè;A脉¶ð¶Aè+ðt3À…öŸÀEÿÿÿÿ…À…¶ré¶Aé+ðt3À…öŸÀEÿÿÿÿ…À…]¶rê¶Aê+ðt3À…öŸÀEÿÿÿÿ…À…;¶rë¶Aë+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…
‹Bì;A섉¶ð¶Aì+ðt3À…öŸÀEÿÿÿÿ…À…à¶rí¶Aí+ðt3À…öŸÀEÿÿÿÿ…À…¾¶rî¶Aî+ðt3À…öŸÀEÿÿÿÿ…À…œ¶rï¶Aï+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…n‹Bð;Að„‰¶ð¶Að+ðt3À…öŸÀEÿÿÿÿ…À…A¶rñ¶Añ+ðt3À…öŸÀEÿÿÿÿ…À…¶rò¶Aò+ðt3À…öŸÀEÿÿÿÿ…À…ý¶ró¶Aó+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…Ï‹Bô;Aô„‰¶ð¶Aô+ðt3À…öŸÀEÿÿÿÿ…À…¢¶rõ¶Aõ+ðt3À…öŸÀEÿÿÿÿ…À…€¶rö¶Aö+ðt3À…öŸÀEÿÿÿÿ…À…^¶r÷¶A÷+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…0‹Bø;Aø„‰¶ð¶Aø+ðt3À…öŸÀEÿÿÿÿ…À…¶rù¶Aù+ðt3À…öŸÀEÿÿÿÿ…À…á¶rú¶Aú+ðt3À…öŸÀEÿÿÿÿ…À…¿¶rû¶Aû+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…‘‹Bü;Aüt¶ð¶Aü+ðt3Û…öŸÃ]ÿÿÿÿ…Û…™¶rý¶Aý+ðt3Û…öŸÃ]ÿÿÿÿ…Û…w¶rþ¶Aþ+ðt3Û…öŸÃ]ÿÿÿÿ…Û…U¶Zÿ¶Aÿ+Øt3À…ÛŸÀEÿÿÿÿ…Û…33À_^[‹å]ËBã;Aãt}¶ð¶Aã+ðt3À…öŸÀEÿÿÿÿ…ÀuÔ¶rä¶Aä+ðt3À…öŸÀEÿÿÿÿ…Àu¶¶rå¶Aå+ðt3À…öŸÀEÿÿÿÿ…Àu˜¶ræ¶Aæ+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…jÿÿÿ‹Bç;Aç„Š¶Aç¶rç+ðt3À…öŸÀEÿÿÿÿ…À…<ÿÿÿ¶rè¶Aè+ðt3À…öŸÀEÿÿÿÿ…À…ÿÿÿ¶ré¶Aé+ðt3À…öŸÀEÿÿÿÿ…À…øþÿÿ¶rê¶Aê+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…Êþÿÿ‹Bë;A넉¶ð¶Aë+ðt3À…öŸÀEÿÿÿÿ…À…þÿÿ¶rì¶Aì+ðt3À…öŸÀEÿÿÿÿ…À…{þÿÿ¶rí¶Aí+ðt3À…öŸÀEÿÿÿÿ…À…Yþÿÿ¶rî¶Aî+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…+þÿÿ‹Bï;A¶ð¶Aï+ðt3À…öŸÀEÿÿÿÿ…À…þýÿÿ¶rð¶Að+ðt3À…öŸÀEÿÿÿÿ…À…Üýÿÿ¶rñ¶Añ+ðt3À…öŸÀEÿÿÿÿ…À…ºýÿÿ¶rò¶Aò+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…Œýÿÿ‹Bó;A󄉶ð¶Aó+ðt3À…öŸÀEÿÿÿÿ…À…_ýÿÿ¶rô¶Aô+ðt3À…öŸÀEÿÿÿÿ…À…=ýÿÿ¶rõ¶Aõ+ðt3À…öŸÀEÿÿÿÿ…À…ýÿÿ¶rö¶Aö+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…íüÿÿ‹B÷;A÷„‰¶ð¶A÷+ðt3À…öŸÀEÿÿÿÿ…À…Àüÿÿ¶rø¶Aø+ðt3À…öŸÀEÿÿÿÿ…À…žüÿÿ¶rù¶Aù+ðt3À…öŸÀEÿÿÿÿ…À…|üÿÿ¶rú¶Aú+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…Nüÿÿ‹Bû;Aûts¶ð¶Aû+ðt3Û…öŸÃ]ÿÿÿÿ…ÛuZ¶rü¶Aü+ðt3Û…öŸÃ]ÿÿÿÿ…Ûu<¶rý¶Aý+ðt3Û…öŸÃ]ÿÿÿÿ…Ûu¶Zþ¶Aþ+Øt3À…ÛŸÀEÿÿÿÿ…Ût‹ÃéÈûÿÿ¶Rÿ¶Aÿ+Ðt3À…ÒŸÀEÿÿÿÿ‹Âé§ûÿÿ‹Bâ;A℉¶ð¶Aâ+ðt3À…öŸÀEÿÿÿÿ…À…zûÿÿ¶rã¶Aã+ðt3À…öŸÀEÿÿÿÿ…À…Xûÿÿ¶rä¶Aä+ðt3À…öŸÀEÿÿÿÿ…À…6ûÿÿ¶rå¶Aå+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…ûÿÿ‹Bæ;Aæ„Š¶Aæ¶ræ+ðt3À…öŸÀEÿÿÿÿ…À…Úúÿÿ¶rç¶Aç+ðt3À…öŸÀEÿÿÿÿ…À…¸úÿÿ¶rè¶Aè+ðt3À…öŸÀEÿÿÿÿ…À…–úÿÿ¶ré¶Aé+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…húÿÿ‹Bê;Aꄉ¶ð¶Aê+ðt3À…öŸÀEÿÿÿÿ…À…;úÿÿ¶rë¶Aë+ðt3À…öŸÀEÿÿÿÿ…À…úÿÿ¶rì¶Aì+ðt3À…öŸÀEÿÿÿÿ…À…÷ùÿÿ¶rí¶Aí+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…Éùÿÿ‹Bî;A¶ð¶Aî+ðt3À…öŸÀEÿÿÿÿ…À…œùÿÿ¶rï¶Aï+ðt3À…öŸÀEÿÿÿÿ…À…zùÿÿ¶rð¶Að+ðt3À…öŸÀEÿÿÿÿ…À…Xùÿÿ¶rñ¶Añ+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…*ùÿÿ‹Bò;Aò„‰¶ð¶Aò+ðt3À…öŸÀEÿÿÿÿ…À…ýøÿÿ¶ró¶Aó+ðt3À…öŸÀEÿÿÿÿ…À…Ûøÿÿ¶rô¶Aô+ðt3À…öŸÀEÿÿÿÿ…À…¹øÿÿ¶rõ¶Aõ+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…‹øÿÿ‹Bö;Aö„‰¶ð¶Aö+ðt3À…öŸÀEÿÿÿÿ…À…^øÿÿ¶r÷¶A÷+ðt3À…öŸÀEÿÿÿÿ…À…<øÿÿ¶rø¶Aø+ðt3À…öŸÀEÿÿÿÿ…À…øÿÿ¶rù¶Aù+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…ì÷ÿÿ‹Bú;Aú„‰¶ð¶Aú+ðt3À…öŸÀEÿÿÿÿ…À…¿÷ÿÿ¶rû¶Aû+ðt3À…öŸÀEÿÿÿÿ…À…÷ÿÿ¶rü¶Aü+ðt3À…öŸÀEÿÿÿÿ…À…{÷ÿÿ¶rý¶Aý+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…M÷ÿÿf‹Bþf;Aþ„pûÿÿ¶ð¶Aþ+ðt3Û…öŸÃ]ÿÿÿÿ…Û…Oûÿÿ¶Zÿ¶Aÿ+Ø„?ûÿÿ3À…ÛŸÀEÿÿÿÿé,ûÿÿ‹Bá;Aá„Š¶Aá¶rá+ðt3À…öŸÀEÿÿÿÿ…À…Íöÿÿ¶râ¶Aâ+ðt3À…öŸÀEÿÿÿÿ…À…«öÿÿ¶rã¶Aã+ðt3À…öŸÀEÿÿÿÿ…À…‰öÿÿ¶rä¶Aä+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…[öÿÿ‹Bå;A儉¶ð¶Aå+ðt3À…öŸÀEÿÿÿÿ…À….öÿÿ¶ræ¶Aæ+ðt3À…öŸÀEÿÿÿÿ…À…öÿÿ¶rç¶Aç+ðt3À…öŸÀEÿÿÿÿ…À…êõÿÿ¶rè¶Aè+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…¼õÿÿ‹Bé;A鄉¶ð¶Aé+ðt3À…öŸÀEÿÿÿÿ…À…õÿÿ¶rê¶Aê+ðt3À…öŸÀEÿÿÿÿ…À…mõÿÿ¶rë¶Aë+ðt3À…öŸÀEÿÿÿÿ…À…Kõÿÿ¶rì¶Aì+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…õÿÿ‹Bí;A턉¶ð¶Aí+ðt3À…öŸÀEÿÿÿÿ…À…ðôÿÿ¶rî¶Aî+ðt3À…öŸÀEÿÿÿÿ…À…Îôÿÿ¶rï¶Aï+ðt3À…öŸÀEÿÿÿÿ…À…¬ôÿÿ¶rð¶Að+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…~ôÿÿ‹Bñ;Añ„‰¶ð¶Añ+ðt3À…öŸÀEÿÿÿÿ…À…Qôÿÿ¶rò¶Aò+ðt3À…öŸÀEÿÿÿÿ…À…/ôÿÿ¶ró¶Aó+ðt3À…öŸÀEÿÿÿÿ…À…
ôÿÿ¶rô¶Aô+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…ßóÿÿ‹Bõ;Aõ„‰¶ð¶Aõ+ðt3À…öŸÀEÿÿÿÿ…À…²óÿÿ¶rö¶Aö+ðt3À…öŸÀEÿÿÿÿ…À…óÿÿ¶r÷¶A÷+ðt3À…öŸÀEÿÿÿÿ…À…nóÿÿ¶rø¶Aø+ð‰uüt3À…öŸÀEÿÿÿÿë‹Eüë‹Ã…À…@óÿÿ‹Bù;Aùt¶ð¶Aù+ðt3Û…öŸÃ]ÿÿÿÿ…Û…H÷ÿÿ¶rú¶Aú+ðt3Û…öŸÃ]ÿÿÿÿ…Û…&÷ÿÿ¶rû¶Aû+ðt3Û…öŸÃ]ÿÿÿÿ…Û…÷ÿÿ¶Zü¶Aü+Øt3À…ÛŸÀEÿÿÿÿ…Û…âöÿÿ¶rý¶Aý+ðt3À…öŸÀEÿÿÿÿ…À…òÿÿ¶rþ¶Aþ+ð„·öÿÿ3À…öŸÀEÿÿÿÿ…À…iòÿÿéœöÿÿIñ–E+›E¦ŸEB¤Eb–E¥šEŸE³£EÕEšEhžE£E$•Eg™EÉEu¢E…”EȘE*EÖ¡Eæ“E)˜E‹œE7¡EG“E‰—Eë›E˜ E§’Eú–EL›EøŸEÌÌÌÌÌÌÌÌÌÌÌÌÌÌWV‹t$‹L$‹|$‹Á‹ÑÆ;þv;ø‚”ƒù ‚Òù€sº%ÀF‚Žéãº% ÏFs	ó¤‹D$^_ËÇ3Æ©uº%ÀF‚àº% ÏFƒ©÷Ç…÷Æ…¬ºçs
‹ƒév‰ºçsó~ƒévfÖ÷Æteºæƒ´foNôvô‹ÿfo^ƒé0foF fon0v0ƒù0foÓf:Ùffoàf:ÂfGfoÍf:ìfo 0}·vé¯foNøvøIfo^ƒé0foF fon0v0ƒù0foÓf:Ùffoàf:ÂfGfoÍf:ìfo 0}·vëVfoNüvü‹ÿfo^ƒé0foF fon0v0ƒù0foÓf:Ùffoàf:ÂfGfoÍf:ìfo 0}·vƒù|óoƒévfëèºás
‹ƒév‰ºásó~ƒévfÖ‹„§Eÿà÷ÇtŠˆIƒÆƒÇ÷Çuí‹Ñƒù ‚®Áéó¥ƒâÿ$•„§Eÿ$”§E”§Eœ§E¨§E¼§E‹D$^_ʈ‹D$^_ʈŠFˆG‹D$^_ÃIŠˆŠFˆGŠFˆG‹D$^_Ã41<9ƒù ‚Qº%ÀF‚”÷Çt‹×ƒâ+ÊŠFÿˆGÿNOƒêuóƒù ‚‹ÑÁéƒâƒîƒïýó¥üÿ$•0¨E@¨EH¨EX¨El¨E‹D$^_ÊFˆG‹D$^_ÃIŠFˆGŠFˆG‹D$^_ÊFˆGŠFˆGŠFˆG‹D$^_Ã÷ÇtINOŠˆ÷Çuñù€rhî€ï€óoóoNóoV óo^0óof@óonPóov`óo~póóOóW ó_0óg@óoPów`ópé€÷Á€ÿÿÿuƒù r#ƒî ƒï óoóoNóóOƒé ÷ÁàÿÿÿuÝ÷Áüÿÿÿtƒïƒî‹‰ƒé÷Áüÿÿÿuë…ÉtƒïƒîŠˆƒéuñ‹D$^_ÃëÌÌ̋ƃà…À…ã‹ÑƒáÁêtf¤$‹ÿfofoNfoV fo^0ffOfW f_0fof@fonPfov`fo~pfg@foPfw`fp¶€¿€Ju£…Ét_‹ÑÁê…Òt!›óoóoNóóOv  Juåƒát0‹ÁÁét‹‰ƒÇƒÆƒéuñ‹ÈƒátŠˆFGIu÷¤$I‹D$^_ä$‹ÿº+Ð+ÊQ‹Â‹Èƒát	ŠˆFGIu÷Áèt
‹‰vHuóYééþÿÿä³ö³`´P´<´*´´´Ô³¾®¬®¬³š³Š³~³r³b³N³¼³:°N°`°p°„°š°ª°¾°ΰÜ°ì°þ°
±±,±:±L±^±r±Š±0»|¯$°»ôºàº̺¼º¤ºŒºzº`ºFº:º.ºººü¹è¹Ô¹ȹ¸¹ ¹Š¹t¹`¹L¹°°î¯Ú¯į¸¯¨¯»¯f¯X¯J¯4¯$¯¯¯ø®è® »4¹@»¹¹ð¸à¸Ø´ô´µ&µBµ\µrµˆµ¢µ¸µ̵Þµòµ¶&¶2¶J¶b¶z¶¢¶®¶¼¶ʶÔ¶æ¶ü¶· ·.·>·L·\·~·–·¢·°·Æ·зâ·ò·þ·
¸¸.¸@¸P¸b¸r¸ˆ¸ž¸¸¸Ò¸|´αÀ±´±.³³³³ü²ì²ز̲¾²°²¢²²~²l²X²B²0² ²²²ö±ê±Ú±¨´º´˜´‘ˆ@„}@Ø|@|}@€ÿ@%@D´+E‚CEöqCðÚD¬BEXA°â+ØdWЩnÀO×¢ãóÆíA„	A­ól ·ÞGRéWp½Ñ‰ÀOÂÈ6a'»wjÐ¥5ÀO×Ðb÷ÀFÃ…¼m]rL§wìx,a®OØM‡G€¶	 Ä·]v+éÀqAŽ¦¸Oöáp¶Ñ¡ÎÀO×]àÙÖ‡Í+DW^
ëOor;Éoñ®wþL½§¨fð÷Ëë[áM¼ƒEÄ€ö¢vßß*ÈcMjVD¬Es…Á½"ñ‚@Œ0(9ŸA8LÑ7ʸ!A¦9mG-—*+$Ì%|šQO€àz)(þ¾B“ÀFé¥ä\ëäG¸ŸˆaUûÀF䬮®‰E¹·»†z¾âíø‹fCNÁ²I—Étw„ׄ·txŸMNI–{@°Ò>K]T£ÿÞKF«èaÈd“›ÐâºÁß4C¾Ýz¢"zŒöò“Ó£ÀOy«Ñ|ÞÃI)ÓЫsÀOÃ>€©BÖq±òÍB­’ë“ÇÌ
ó”7EµªC£)Ãt0Å*¤Mä^2mãF†¼T
íÐà» }¹jô—Lº^6CT¶v]=›»D¶®%ÚOcŠg´óP0µ˜Ï»‚ª½Î¢Vö	¯AHˆ÷Ì
FüÀFPèBÒ¾, É¨=¡¯$HíäܨEâüye64Bl‰ÅЙšÀOÖUá¢WU¦]ƒOˆ	ÂÉŠ¦úäÀF€iyŜѨ?ÀOÉa3K›ÿ@Ò¢~ÀOÃq†½K
àMš;Ùr–G¸E\¿«Ì\·G»N‡Ë‡»Ñb¢Ûo-ôXC§˜·MtY&Åh~vËIsB‡Â óUá[ñ6À†¡Ð‚Jª[CƒÃS[bH«ÁNº¡ïAFü·Œ"ý®ãJ†Ló‘
¸þÈèGÂй: Éáý7³Õ5F¦ÔÚ3ý+zÓÀFOñ${уøaϽt’ÑÏÃA³^±?U§Xô&×I}!<O™ªýÂÉGFV;&åO‘ÁF°¤íÔÛ}êö”P($IªZÑ^„†€9&®M[¸Ð˜ÀOÙr„µËW´é®G¡ Äß35Þâw~s5Ï®i+.b£iÙÿçЩ; É'~Í.g¯™C‡\„[bGžEòÃÖ€ÜE¿ïvŸ+ç0P‡¦“•Ñ”oÚS ’i)!@¿'QLü.Ji¬frßt’gHU;ÖaÞ‡-+Ùo—.ÑEˆÿ°Ñ†¸ÞÝf¹@"µÑ³´ªnýçàOÐ ê:i¢Ø+00à.PR€ìЉ«ÀO—-è“2¦NfÛH yßuž	÷âM7?eE‘d9Ä’^F{ëÜw†àª@=T¨Rø%«•9žœO¸'H²Klqt}±
{Òœ“J—3F̉.|-Ã÷!ªî›C»Q7¹oÖ©C€þmyÏ•4À[®_e¸ÿ¹ÎO¸œšk§mçá‹MÒ…]`“g”­ž…….­H§	iËV¦ÍõÀFÅëO…#òA¢Ž,\‘ûVàô׉#äG©``¼Â퓺
E%­Ð˜¨6QM\–v‹WN€·VM.¤µ^ÒãR
FœHòsÔp£ôº^QmÒƒ­ÀOÙÐpñNr-¤ïOŸ&¶„oºO²ë‹ÐRзôÀO×ìå%ñeá{HºÒqÈC,㟽À¸$í\EƒæÕ9OèÄt¤<&KA¸ÎÊ>=Øaª-kQG´œû˜^ø)˜,ÅÊ=µÜN’×k.ŠÁ”4qÙaÞ¼^O£©l‚‰^\`«Uå;MŸ¥þ™üìW¤.ÖIª|çK‹ã°g+à*U6ÌF¶:(Yˆ;ÊëJ§‚´®\F Зî4mcÂ/4*&{ÐŒ© É-¿èëô@јˆ`—Þ¬ù)–¯€ÿF€#Ϋœ>ã/’ICVôJ§ëNztµáI6FÓ—÷ÀOEг@ü­úw·iKªw^ðæèÄîÒ¨\I®;¿% ›S¦jc(=•ÒµÖÀOÙÐìŽ'Œ«>ÑŒ°ÀOÙСÀFÎVþeþ\ÄK­Šzãþ~|Tn9{ÅžC¾
$‚ë®&;ŠÜÙ„·.C§Z0§YctXT9bq^F·ƒ*¡‡Oï  ì!ê:i¢Ý+00iI~©+.Í©ã¢_@^A¦îÊÖ% xS†ûë¶iM¿‘ôEQ ¹3ó€ß·Ò£;`—ß[Ô}N8Ðú—GË¢)³’µw]§+.ÃD¦¢«¦JQ•3”(Ò9ÀOŽë>Ü¥>‡µ†G´ï½Ã2®®A`ÂtÑpÑ·Z Édþf½aÝèpÝH–UeÅáªÂÑ–[/tÿÚA¯Øx¥ó®¢Cšš(D¾W@¤Xzv×çùiÏ>ŒV–MYFDAtâÖKpÈžô&A©Ãµ*ôè.7£VœÎÒŸ`—Ɔö€¢'"ê:i¢Þ+00hXtÙ_ÊvJ‘Íõ¡)û°v؂تçíI†·æá÷Íþ'â9YõÓŽ:ÀOh7Õ
e.{ ŽJO°že—¯Ç/°±â+ØdWЩnÀO×¢ÀF]“šˆ—K¹$ßÉáåèúLb`w¤±GŠŽ:J˜'àÐWs5Ï®i+.b!¿\_ÑЃª[CƒP2nD\H±Cæ*v
Ÿåô‹óCòB“gÞ(ü#€ÿ4DLïήe+.b1ÑŠÛ*–B¨÷äp2Ér%â9YõÓŽ:ÀOh7Õ¡΋!	±ÿÝÌH¥lÄ?<Ò¾æøÊWäô>áòÒИÀOÙr AG†QÒ»¶`—{FL‚>!€ý¼OLˆ»'`g©$žØ$/4EÞjfqû¸þðJ1ÒйB Éá*)l6³Ù¿M»pæ.Ãл¿àÕ¹¿©ÆL@²²®m¶¯Ih.6]§üP·O¬,¨¾ª1D“l¯‚ñ4LŒá~É‹@J7<äºÏ¿}ªiFîÀs5Ï®i+.bÞ1‹¥I“¸káLúIC™Î£'õ+I‹~vú˜ÖäpŠh}ÆЙ›ÀOÖUáEûþK}4@¥¾¬°Vq’zeÒG'{ÐŒ© É-¿èîÀFý4p ªlTI¬?—¢rùŠïÀFÌÝÖ”hJuA£t½XJQx€;òûðㄈª>Vøf’£NrŸ@¶"ö=½Å3uwƒ-ÍöNF§EH/дt“óÀF5K›ÿ@Ò¢~ÀOÃqáÀF9tÖÙRNƒNgɆóš«N_3haO‰1ÏF—I¡FãÕS÷2I´Et€$˜¶c^¿ÁNI²œe·2ÓÒè$5¾3QBº…`ÊíÏó¿k(ÔºC°y·&|=H‘ÀF5ꥂÍÙÅG–)á]/qNnw“€mðjKD‰W£w? ”šjY>Ñ4 É'èrìã`F¿$<;{dˆÐÀF³óP0µ˜Ï»‚ª½ÎöÀF:Ì¿´,ÛLB°)隇ÆA˜x€WOŒbD»cq#€±	Û…¶>ùeöL :ãïerŸ=íñ÷mŸ¢Gª®)ÓÆðf«Rž
øßI¬¸C0õhxU*TÀðKуî É
ÈI€žãˆx5Ï®i+.b¢ñþ^5N“›$×÷̈Ñc<‰ÈEM¾";çãeа‰¶Óv»L‡÷X]àp0â3NvFƒZ˜9\;û¡¸51M–Ùl¿Ég™DŠMƒt	ÖN†nòØ8ëÀF…l^"`Gšþê3¶qs§Õec
åE‡ö
¥kjO}‹Í~6Á›J”N½fsÌÃOÞ¼eO'Oƒ§ü¤ß}Ý‹Ûé´º49LµÌ¡½,AFº+¥áé_C³Ù(Ú¦HÀöR88øÓüѦ¹`—ß[Ô4ÄÂ0‰L˜]©÷0°©³iÊî0ÁI¬ák^Ãr¯µ
Ÿ\ž•Ð£¤ É&6ÇÁ’ÞƒiO£»†æ1 J#
«!jÈþO£h
énG.± Œ´UVL¸¨Mä²™Ó¾rÒb
Å°K£‚i}Ír›€ Àœí¹Ñ˜#ÀOÙrøÀF°0¡wý”Ð¥DÀO×ÐbÀFQšœ>ªÔpH´|t$´‘ñÌøÚHÏæNO¸iØNã„ÏÒi3ü·Ošë°ðü´<œ«¸ìÂzO‘1Iæ(
W0½¼\Ê"F´-¼VÛ
åàÖ‡Åω© ÉA)ùÀF 
»ÊWÚÏ™t ¯×—bï@Z|û üK‡JÀòà¹úŽA¦VgqÞЃª[Cƒ@¾–L\‘ϙӪJè7ë¯çÑ.jÐŒxÀOÙ´`OÞúK¤”‹ ²#@;òûðㄈª>VøêÀFhÆP²}õáN¦<)çѪôÀF	ÙÄ$aàO™B‚d-©@Äy#uL„KdæúøqkÀP®ÒëŠC†UŠ	.4˜z‚]«bÁýÃM©Ý
I]—úÀF£¶t›ý
Ožx_xòçrd©_w~L¾NdÍL·Ö¬ìÀF¹4ïK†§u@ºˆ+‰©ÐšÓý#¯F­´l…HiÇ"k1Ë÷%¸BŠ	T
#¤8ƪd_»ðµNŽM&uf4Lc'»wjÐ¥5ÀO×Ðbx‡Ð8WõFž¿ºTpjØ÷ç7B¹¬WGC‘Q°Œl2Ñ÷ÀFiÈìÛÁÀM…^eöÅQ¯I”+ê”ÌéàIÀÿîdÊ[ÀFÏÀFÀFÀFÀF ÀF ÀF!ÀFÀFÀF0:s*έåªDw=ÀF`kõÕ;Yµi+-¿zÐ1OYб” É
È¿¶Ÿ¥4<Ñœ™ÀO¹˜ªV±%п
ª¸ßÒ… XÈ$5I´‚?Ø#3:O4jõÕ;Yµi+-¿züjõÕ;Yµi+-¿zÐiõÕ;Yµi+-¿z ÄvÏšñ ¯nrô=ÀF>ÀFDÀF[ÀF"ÀFFÀF0ÀF1ÀF2ÀF3ÀF%ÀF)ÀF*ÀF0:s*έåªDw=IÀFè¹ë–yÒ‡.øY+ÀFGÀFHÀFÊ:/Û†/ÑŽÀO¹˜šË:/Û†/ÑŽÀO¹˜šÌ:/Û†/ÑŽÀO¹˜šÍ:/Û†/ÑŽÀO¹˜šÎ:/Û†/ÑŽÀO¹˜šÏ:/Û†/ÑŽÀO¹˜šÁÀFÀÀFÆÀFÎÀFU
8r+£C…+nó4é@ÀFæõòØacHŸ&8šFvïÞCj?À¤e˜˜~à¸Ò¦òÀFÀFÀF&ÀFÀFÀF	ÀFÀFÀkŸò!PΪi)?
ÀFÀFÀF
ÀF
ÀFÀFÀFÀFÀFPÀF%ÀFQÀFÀFÀFÀF@ÀFðÊ™^Aψªµiõ XשFÏ•üªh
´Mm8gÏ–ªh
´zÔó0GdÑŽ<ÀO¹8m®ö¼xˆÑƒéÀOÂÆÔ4ÈyˆÑƒéÀOÂÆÔ’Mm8gÏ–ªh
´&ÀFEÀFÇ–v\цø°WÞy”(ÌÒ ÷€_…±ÕÀFÔÀF4ÀF	Zð¢¢'µB¼¬>ô›Ã¢RX0eѶ£øu{ùÚ®šP9VѶ¡øu{ùðþ½ÏÏ£0ªÁne0ÕE
KvСʪÁne
y˜´âа±ÀOØܦÏ«|õxÒ–ÀO£†À¨´jÒ­IÀO£†ÐàQžnÒ–ÀO£†0îüŒ½9иѠ$«-»¸1.¦Ð¦Å É¯EÀ^¼ƒ*oСĪÁneÀÞP«oСĪÁne |Œ~|Б?ªÁne?Ç¦üàЗP É¯E^æ#ŠÂ1Љ $«-»á?îƒÙWй2 $«-»â?îƒÙWй2 $«-»pðwµâ~Б?ªÁneg­‡Ð‘@ªÁneñ˳ÁjˆÐ‘@ªÁneò˳ÁjˆÐ‘@ªÁneã?îƒÙWй2 $«-»~{ŒS^ÒЗB É¯Eyð¾|„ªKD¼phäƒê¼KΔӳѹ´ÀOØÕ°ž™rÀIúÑ ¯ÀO£†°…‘’ËÅC€©’'zO{Tx…hиÀO×ìà{ËlhиÀO×ìÎ6²Ç€îИ_`“‚ðÙÃ\Ñ•¾`——êOßOðÎrþÒ‡¥ÀOh7Ïü¬y½)ÓŽ
ÀOh7ÕBÐTyI¼²6¾Eº¬Z{Ù’ÇÙ?i]?ˆú9ì¯øÅA„!8¾ÒFs°%çÍÉÌE‘~2]rú´Î?àöjdÖôN–&÷àí6u^g¤óO!˜BŽ°>9ù}˜Œ®—‡ÓN¾r*GÝ“°¥ùkF³ðNª]Í·gh±hÏ“ægÙA‡c™*î^Z¡%­È”2îAeqKÐW»'ìØ;?B@±
JÏÙ$ÔSõQ¦À‹´Òµí`—Ɔö†(ÂœŽÜÒ±ÐÀOŽë>’ƒÛñ1sÐŒ™ É-¿èªO(hHjÐŒxÀOÙ´…ÀiQÍD”¯(ߥlù+ ‹rˆ÷Î’­ª§LÐm‚CçîB¼U¡âaÃ{þÓ°Ÿ~Ÿ‘C«.›`1“y‹Á¼º/D€ÄŠYÃF;šæa¥¸´A‘¥dƼÊ403bpcã(J¥g
·€æ×ØДէ{E³´Î]º¬ˆ°­é½ÆEŽ)П“SáãØ-<¨©M£0G$4[¡¾“Vÿà,HMµÅ@}͹2Ý­H¥<$A«ãµ§%1²efþÊà¹I¡x+\´’¥ÚýhŠÜ LŒëAfCµ¦%§ñ°”¼D–áB–£Râm§>¶…oE¡œHžú…‹?¾syûYz(©…¸yòé
…K¬Ýìù@‰Aº—º“X‡G§áA'qQU”‚AÿJ€ú
sêÌY!ëW«O«Zåú{ê*lñ×ðg²(M‹â2¥Ä(¼ÿ ‚TfC¾'>çŽÂ|a.» 	ÑšÀOÂÖÁî±;•´“ј£ÀO¶‡Ú.K[ãÚÁKŸ8¼õÔ…¶¤³…¶H™Ù]êÒ‡26 Ù-&{ÐŒ© É-¿èráë:Љ³ É
¬ü%äwùËCºj»W'tVaämÑyî«!@‘i²aÖWBóýVmýЕŠ`—É •I-`:±›B¦n5äOC‘ûê(ž†K鞟Š^ﯘÇ=ÄÑ•êK0»™â˜:ÚšÑL¥%2J³·4{î[ãkY¦s=ÐåBM¯ÀQ!ºB\[–ˆ/B{N€sASÃÖ¦.À̆I›#t9JD¨f?kјÀH¢"ûÞtâûÅ»˜‘ªìÌ-G¾í¤ös?z¥ZÕA°žže¬!`[ǽ6îæN¾XXâ$µ¶ÓßÁéK…ö¦iiôöÅ‘£•Ôž(L„«žqžm®å–ájKÆHªˆ(.~,-Y@ƒo‚3\.Q¸ŸÉåëC£pðg{‡L¿°õµŒK”Ižs<_«z”\
L´ÖK÷ƒoÉø(t¦ã;sM³|¥@¿ø•)Ù^ÏvJ¿YêÓž¢¹~+IÇzŽÃŠC‡ÛhsxDÿp§ØÎWJ?,C“P0òDƒ÷OôAÑoËZ\ÊÜq"ütD·Åk¬â×¾®‡TLžrTŒöIkE
àaÿ`N’Ne7¶Ý6ò‹Œì_I˜”‘Õ|k’H¢rYøˆšM>sáë:Љ³ É
¬ë¯çÑ.jÐŒxÀOÙ´ðË¡d:aD‘X7iii9PÛ5—}+E‰ut¨X(ÓT6QøB~ÛœC…ñä]_È#ͼ„Þ_ÛL®¤¯d¸=x«ˆr|Õ­ÔhG¾–•2Ù`Òýæ?uIœŒ¦Ÿ£p4Bf6×—K›ƒt„©Ð3ÇOtaµ…‘G©°'"v0›
SNæwL£¬1Ð"(i¡v”ù¬@È	Yè‡G€ºØ­+ÐÀO×ÐbÈCß¾Ó‹4`—ß[Ô„L¼Òr?RJ¦{Ëó˜,»AÛs…EŽO¨ŒW¡£L›Ñ‹"ÀOÙÐ7vî8áуyÀOÙÐà½äühK€KŽœt&1Zsˆ~¯§:6›B¨ã÷}Ft¤ˆrØ⋪†GM·v2̤pŠDÍ´†œfD’.b[‡®€Gåvt­ãH¦•;© ¯ñ
zæ<§±ŠñDCÒü¿kÐÊ?}ùÖHƒ2”lwâG”Zrµ\Úí£˜GŠÛÅçÚ™±—YýÆkŸˆH‡”èŒÞ?FA&O©•AŸŸ;±,àÉUi™6
ÈI‹Jì²"ûx‡Š§9Jª³£›œ4§Ùܰܵ;E¾–fDþ×°¼ÒÀqmrÌE¦À.1ÁÛ!Yu´Y&¸î·H³xHÏ£‚'¶éGˆVÁBeUNOØ®Ç|)¼I‰EÁ@É0l…yדس„Dƒg,Ý ÎÖeÆùòÂL¿3ƒ"×5/QÞóqíCA„wéSk‚5X§;-î3ÕB»{_41Ølxƒpé³æòO…h6þǾƱ•ˆ´L¥b
VBPƒo¯zÈþù5zD­· #D‘@Fègmœ[¸Mœ¼Ýá/BTñ|\¹ŽÔ?@«™ÖÇz„¬ìpà¼ÀD—°FÇÉ[žÜ0é	49Zуú É
ÈI}ÑÞA³ÖaB™}ˆÆKXÐ䌠%ú«Dµ|DZÃ#à¹`ËÚ½Wv®G„EÒ>Ï‚®ÏZ…#ê@–Òk{Xö8ø&ˆ¨o‡IªÞêï¿èQ–d5ÀCþÕv†Sdn0@Dš×ÐHˆæ¤&’'›û®ûÒÖñŒEŒ4V˜w¢Ò˜n¨B*O—øŠôà&Ù-bØÑÞfôM¿lV!™jñ’
ö
hÖF³XÖapÝäf_Ï:ÛqúJð?Äýò¥¸¿Þ2cµ‡pFÀ^W´¤ž5}3Æ” H¼çjœiÔÖŸOY<0Ÿ¡G—šÉè==
–Û6e–ÑF›§ÓpžìùíûèqîüF¿ŒwH¨¡®Ò¶‰e_žK·à#ÍÙq}ŒÄkdÁ˜ò‘O¢ë-Ñp©V+¹U‹Nš‰™»¶ù;ÙÑ;z©5³O¤gôŒ¬5âе.áÃ}øD¶Ýw³Mmä3sîðüæ›GŸ%¨`Â4£Žún¦.8E’4ï0…yªvüøF£'6÷Ñ]‘A”.—VGºìÞ‰J=±é§PïpÑ·Z Édþ1ÏÂFÁO¹ÐŠœÄ½ÀF K6ó¹eΩºªJè7`, ê:i¢×+00ÀFh3©ÝM¸nÚãMÜ™ŠS{5”)ÊxKƒ®èþt	OÏó¨°3C«KˆsË­¤‹“w`µ¬$ÇD‚âƒ&ªl·´;ýÝ0M£HŸµÖ¿þR¸×UÑöòBªu‡(¡²ÒdÆT&©àaërr†C‘uòäÆ‹.|uUÐ:WˆPH’w¸[ÛŽ	œZÜŠèÞM¥¡`ø* ®÷óâ´À!ºsGº3^ÉFë‹0ÇðMßãJ‘Sªk‚éyZ
8—Ñy
ÈM 3íˆ,/¡KáqóI\ŒœMš;T¦‚Q'°ˆCH¿ïâÈCªåÁh4-§6¶C¬$Óð/Ù`zÌL’be…L†WÑw’R"¶FÎ)´ J ŠÓëȬ¤£
ÕºFÅD‚-Ê€’Áür¾‚3Æ3yÐHšÈ…ûF¾/ÝÙã_~_˜I‘ùîùý§ÓN¨ÎÙK‘
âRù—¯Â(”Nä¼½‡I ™@ÜÒUçoÁ®±ƒ#RH°éÆkMÅ?'kýaI•¢Ãµé×õ}ºE¨êFŠ·Vêx”<µoŠ•²Ü¯Oªý°T­;|´Û%¥@ž€¥F À«Œ!’ªì5C3€Ò4Âî¬a@ðY?J©TwZ¥Àƒ®8—™•ˆKžMn錕RÚÖö%=*KÜC¼ÞEgèÈ{Sl"vžM§`3Û)’/‹#RWð$ZI‚ñ/Õ“g–ý3w’¥åBµ”$„hŨ"ÜIˆßΕL™Ý?vk΄e‚}ÂI‰ÉƼºŒ8-êF"êÊDD£Ämè'äCb*±Ø*+CŒÏ,R¯Í[09|ò)€ÑJ”ã=ºAxÁB:¸RC%jAÙÀÞyiȳ©²„áðOŸ^ø‚Ð7q³¢2hK_L¸rzÑçšî=*ãÖF…¼Å—Û5WáIZgnM¥åI´Ê/~¼o&
IíF©k"tÛ% ÷ªå¸0H‡ Ng4ËÕóÆf/÷`Cµ£” U7%¬‘‘˜ÿ(ðL•„àÐx¼#–½Ôh>5qM€Ÿ¶Ùó?¡ïw™€ø;E9á¢ÒeZ‡J	5±‹7B–ÆÄî½°x§Ëê™sà¶C¨–U¯äŠ3ÀËFÌFXãElãE¨ãEäãEadvapi32api-ms-win-core-fibers-l1-1-1api-ms-win-core-synch-l1-2-0kernel32EventRegisterEventSetInformationEventUnregisterEventWriteTransferFlsAllocFlsFreeFlsGetValueFlsSetValueInitializeCriticalSectionExPæE\æEdæEpæE|æEˆæE”æE¤æE°æE¸æEÀæEÌæEØæEøZFäæEìæEôæEøæEüæEçEçEçEçEçEçE çE$çE(çE,çE0çE4çE8çE<çE@çEDçEHçELçEPçETçEXçE\çE`çEdçEhçElçEpçEtçExçE|çE€çE„çEˆçEŒçEçE”çE˜çE¤çE°çE¸çEÄçEÜçEèçEüçEèE<èE\èE|èEœèEÀèEÜèEéE éEHéEdéEtéExéE€éEéE´éE¼éEÈéEØéEôéEêE<êEdêEŒêE¸êEÔêEøêEëEHëEtëEëEøZF ëE´ëEÐëEäëEìE__based(__cdecl__pascal__stdcall__thiscall__fastcall__vectorcall__clrcall__eabi__ptr64__restrict__unalignedrestrict( new delete=>><<!==!=[]operator->*++---+&->*/%<<=>>=,()~^|&&||*=+=-=/=%=>>=<<=&=|=^=`vftable'`vbtable'`vcall'`typeof'`local static guard'`string'`vbase destructor'`vector deleting destructor'`default constructor closure'`scalar deleting destructor'`vector constructor iterator'`vector destructor iterator'`vector vbase constructor iterator'`virtual displacement map'`eh vector constructor iterator'`eh vector destructor iterator'`eh vector vbase constructor iterator'`copy constructor closure'`udt returning'`EH`RTTI`local vftable'`local vftable constructor closure' new[] delete[]`omni callsig'`placement delete closure'`placement delete[] closure'`managed vector constructor iterator'`managed vector destructor iterator'`eh vector copy constructor iterator'`eh vector vbase copy constructor iterator'`dynamic initializer for '`dynamic atexit destructor for '`vector copy constructor iterator'`vector vbase copy constructor iterator'`managed vector copy constructor iterator'`local static thread guard'operator ""  Type Descriptor' Base Class Descriptor at ( Base Class Array' Class Hierarchy Descriptor' Complete Object Locator'CV: ::template-parameter-generic-type-`'`anonymous namespace'''`non-type-template-parametervoid`template-parameter...NULL%d`template-type-parameter-`generic-class-parameter-`generic-method-parameter-}' }' `vtordispex{`vtordisp{`adjustor{`local static destructor helper'`template static data member constructor helper'`template static data member destructor helper'static virtual private: protected: public: [thunk]:extern "C" ) char short int long unsigned void volatilestd::nullptr_t std::nullptr_t,..., throw(cpuamp, charshortintlongfloatdoublebool__int8__int16__int32__int64__int128char16_tchar32_twchar_t__w64 UNKNOWNsigned const volatile`unknown ecsu'union struct class coclass cointerface enum volatile const & && cli::array<cli::pin_ptr<)[{flat}{for s šFiú@iú@iú@\šFÈõ@ýÐ@øã@¨šF$ö@BÑ@hä@ôšFÌõ@Ñ@
ä@@›FÄõ@ñÐ@Ñã@Œ›FÚõ@Ñ@$ä@ ?? EEE50P( 8PX700WP  `h````xpxxxx€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxwpwpp(null)(null)
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×äTc-^Çk@êítFÐœ,Ÿaõ¹«¿¤\Ãñ)cdµý4ÄÒ‡f’ù;lDÙe”,Bb×E"š&'OŸ@•Á‰V$§úÅgmÈsÜm­ërÁÎd'¢cʤï%{ÑÍpïßk>ê_änþÃÍj¼f29.EZ%øÒqVJÂÃÚ.¨C²ª|!Ž@ΊóÎÄ„'ë|Ô%­I@ÝÚTŸÌ¿aYÜ««\ÇDõg¼ÑR¯·û)`”*!Š»¤Ž¯V©ŸG6²K]à_Ü€
ªþð@ÙŽ¨Ð€k#cd8L2–ÇWƒÕBJäa"©Ù=<½róå‘tYÀ
¦ìlÙ*Óæ…[aOni*{âP+4Ý/î'Pc™qɦéJŽ(.onIn@2&@­PrùÕÑ”)»Í[f–.;¢Û}úe¬SÞw›¢ °Sù¿Æ«%”KMã-ÃûôÐ"RP(·óòWBÜ}]9Ö™Yø8’Ö³†¹w¥zaþ·jaägÃV ”:‹6	›ip½¾ev ëÄ&›ègn	+ò2qQH¾Î¢åER»x”÷ÀtŒ]ð°uÆÛ©¹ÙâßreLK(wàöm‘CQÏÉ•'U«âÖ'樜¦±=@JÐìôðˆ#Åm
Xo¿CÃ]-øHîY ú(ðôÍ?¥. qÖ¼‡Di}nùVyu¤á²¹º èÈÏçUÀúá²Dï°~ $s%rÑù¸ä®@b;zO]¤Î3AâOmm!ò3VåVÁ%—×ë(„ë–Ów;I®-G 8­–ÑÎúŠÛÍÞN†ÀhU¡]i²‰<$qE}A'JnW®b쪉"ïÝû¢¶äïáò½f3€ˆ´7>,¸¿‘Þ¬dôÔNjÿ5jVg¹Û@Ê;*xh›2kÙůõ¼id&äô_€û¯ÑUí¨ J›øW—«
þ®{¦,Ji•¿)ÄǪÒÕØvÇ6ÑUÚ“Çš¨ËK%vð
	ˆ¨÷t:üHå­ŽcYçË—èi×&>rä´†ª["93œuzK‘éG-wùnšç@Äø’ð_òlÃ%B‹ùÉ‘s¯|ÿ…-C°iu+-,„W¦ïÐ@zÇåb¸èjˆØå˜ÍÈÅU‰U¶YÐÔ¾ûX1‚¸EL9ÉM¬ÅâÀLy¡€É;Ñ-±éø"m^š‰8{ØyÎrvÆxŸ¹åyN”ä¡éÔ\lo}ä›çÙ;ù¡obwQ4‹ÆèY+ÞXÞ<ÏXÿF"|W¨Yuç&Sgwc·æë_
ýãi9è35 ¨‡¹1öC!ÛCZØ–õ«¢?hdþ}¾/ÉK°íõáÚN¡sÛ	äœîOg
Ÿ©Öµµö–8s‘ÂIëÌ—+_•?8ö³‘ 7xÑßBÑÁÞ">W߯Š_åõw‹Êç£[R/=OçB
ÝôR	E]áB´®.4³£o£Í?nz(´÷wÁKÐÈÒgàø¨®g;É­³VÈl•ÁH[=Š¾Jô6ÙRMèÛqÅ!ù	EJjت×|Lᜥ›uˆ<ä@’Ôñ¾rdÁ6‡û«x)¯Qü9—ë%0+L¡;<þ(ºüˆwXCž¸¤ä=sÂòF|˜bt!Û®¶£.²Pª«9êB4–—©ßßþÓóÒ€y 7›œPñ­ÜÇ,­=87MÆsÐgmꨛQøòÄ¢áR :#שs…DºÙχp›:ÜRèR²åNû/¦M¾á׫
OíbŒ{ì¹Î!@fÔƒ¡æuãÌò)/„äwdûõÓq=v é/}fLô3.ñ¸óŽ
i”Ls¨&`@<
ˆqÌ!-¥7ïÉÚŠ´1»BALùÖl‹È¸â|í—RÄaÃbªØÚ‡Þê3¸ah𔽚ÌjÕÁ-è6zÆž)ô
?IóϦ¥w£#¾¤‚[¢Ì/r5D¾¸¨N2LÉ­3ž¼ºþ¬v2!L.2Í>´‘þp6Ù\»…—BýÌFøÝ8æÒ‡iÑþñµ>®«¹Ãoî¾@ªÂ@Ùwø,=×áq˜/çÕ	cQrݨ¯FZ*ÖÎÜ*þÝFÎ$'­Ò#·»Ä+Ì·Êë±GÜK	ÊÜÅŽQæ1€VÃŽ¨X/4B‹å¿þüÿycgý6ÕfvPá¹ba°g
ÒÀáÐ;sÛ?.Ÿ£â²aâÜc*¼&”›Õpa–%ã¹u!,`j¸¢;Ò‰s}ñ`ß×ÊÆ+ßi7‡¸$í“fënIoÛ“u‚t^6šnÅ1·6ÅB(ÈŽy®$ÞdAÁšˆÕ™,CÙ瀢.=ök=yI‚C©çyJæý"špÖàïÏÊפ½ldã³ÜN¥n¨¡žEtÈTŽüWÆtÌÔøBncÙWÌ[µ5éþlaQÄÛº•µNñ¡PçùÜqc+Ÿ/Þ"‰½^Î̯…p?Óm-è}o”i^á,ŽdH9¡•à4X<´”öH'½W&|.Ú‹u €;¶Û-HÏm~ä$™P	
%-5	>
H
R]iu
‚Ÿ®¾Ïàò-C	Y	p	ˆ
 
¹
Ó
î	%
dè' †@B€–˜áõÊš;minkernel\crts\ucrt\inc\corecrt_internal_strtox.h__crt_strtox::floating_point_value::as_double_is_double__crt_strtox::floating_point_value::as_float!_is_doubleINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanSNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)Visual C++ CRT: Not enough memory to complete call to strerror.Visual C++ CRT: Not enough memory to complete call to strerror..exe.cmd.bat.com./\?*ÀÀ–ÀÀŽÀÀÀ‘À’À“À´ÀµÀ	Runtime Error!

Program: <program name unknown>...

Microsoft Visual C++ Runtime LibraryF\F\/ F/mscoree.dllCorExitProcess˜FlC¨FÃFlCÀFÃF4ˆDÔFÃFDìFÃF{‘DFÃF ˜DLC_ALLLC_COLLATELC_CTYPELC_MONETARYLC_NUMERICLC_TIME	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=;;=C_.,_.‰CL‰C3ØC†ÙCF‰CI‰C…èCÝèC¡±D²±D‰‰CsùCŸùCtÞCÊÞC¤*B½*Bß~D	ŠC’‰C;‰C>‰C‰C8‰C\\\.\.TMPTMPmsvcrt.dllccsUTF-8UTF-16LEUNICODEccsUTF-8UTF-16LEUNICODEF`FlãE FØF F€FÌF¨ãEFHF„FÀFFhFÀF	FXãEäãEX	Fapi-ms-win-appmodel-runtime-l1-1-1api-ms-win-core-datetime-l1-1-1api-ms-win-core-file-l2-1-1api-ms-win-core-localization-l1-2-1api-ms-win-core-localization-obsolete-l1-2-0api-ms-win-core-processthreads-l1-1-2api-ms-win-core-string-l1-1-0api-ms-win-core-sysinfo-l1-2-1api-ms-win-core-winrt-l1-1-0api-ms-win-core-xstate-l2-1-0api-ms-win-rtcore-ntuser-window-l1-1-0api-ms-win-security-systemfunctions-l1-1-0ext-ms-win-kernel32-package-current-l1-1-0ext-ms-win-ntuser-dialogbox-l1-1-0ext-ms-win-ntuser-windowstation-l1-1-0user32AreFileApisANSICompareStringExEnumSystemLocalesExGetActiveWindowGetCurrentPackageIdGetDateFormatExGetEnabledXStateFeaturesGetFileInformationByHandleExGetLastActivePopupGetLocaleInfoExGetProcessWindowStation	GetSystemTimePreciseAsFileTimeGetTimeFormatExGetUserDefaultLocaleNameGetUserObjectInformationWGetXStateFeaturesMaskIsValidLocaleNameLCMapStringExLCIDToLocaleNameLocaleNameToLCIDLocateXStateFeatureMessageBoxAMessageBoxW
RoInitialize
RoUninitializeSetThreadStackGuarantee
SystemFunction036am/pma/p -
:	+%SunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssSunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssen-US¬F°F´F¸F¼FÀFÄFÈFÐFØFàFìFøF
F
F
F
F
F
F 
F$
F(
F,
F0
F4
F8
F<
FD
FP
FX
F
F`
Fh
Fp
Fx
F„
FŒ
F˜
F¤
F¨
F¬
F¸
FÌ
FØ
Fà
Fè
Fð
Fø
FFFF F0F@FTFhFxFŒF”FœF¤F¬F´F¼FÄFÌFÔFÜFäFìFüFFF¬F(F4F@FPFdFtFˆFœF¤F¬FÀFèFüFINFinfNANnanNAN(SNAN)nan(snan)NAN(IND)nan(ind)e+000         (((((                  H„„„„„„„„„„‚‚‚‚‚‚      (                          0         (((((                  H„„„„„„„„„„‚‚‚‚‚‚ €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecTZ¸FÄFÜFøFF$F8FTFhF|FF¤FÈFÜFðFüFFF(F8FHFXFhF|FœF°FüFÔFäFüFF$F4F@FPFüFdFüF€F”F¨FÄFØFüFNo errorOperation not permittedNo such file or directoryNo such processInterrupted function callInput/output errorNo such device or addressArg list too longExec format errorBad file descriptorNo child processesResource temporarily unavailableNot enough spacePermission deniedBad addressUnknown errorResource deviceFile existsImproper linkNo such deviceNot a directoryIs a directoryInvalid argumentToo many open files in systemToo many open filesInappropriate I/O control operationFile too largeNo space left on deviceInvalid seekRead-only file systemToo many linksBroken pipeDomain errorResult too largeResource deadlock avoidedFilename too longNo locks availableFunction not implementedDirectory not emptyIllegal byte sequence+FFF(Fja-JPzh-CNko-KRzh-TWamericanamerican englishamerican-englishaustralianbelgiancanadianchhchichinesechinese-hongkongchinese-simplifiedchinese-singaporechinese-traditionaldutch-belgianenglish-americanenglish-ausenglish-belizeenglish-canenglish-caribbeanenglish-ireenglish-jamaicaenglish-nzenglish-south africaenglish-trinidad y tobagoenglish-ukenglish-usenglish-usafrench-belgianfrench-canadianfrench-luxembourgfrench-swissgerman-austriangerman-lichtensteingerman-luxembourggerman-swissirish-englishitalian-swissnorwegiannorwegian-bokmalnorwegian-nynorskportuguese-brazilianspanish-argentinaspanish-boliviaspanish-chilespanish-colombiaspanish-costa ricaspanish-dominican republicspanish-ecuadorspanish-el salvadorspanish-guatemalaspanish-hondurasspanish-mexicanspanish-modernspanish-nicaraguaspanish-panamaspanish-paraguayspanish-peruspanish-puerto ricospanish-uruguayspanish-venezuelaswedish-finlandswissukususaamericabritainchinaczechenglandgreat britainhollandhong-kongnew-zealandnzpr chinapr-chinapuerto-ricoslovaksouth africasouth koreasouth-africasouth-koreatrinidad & tobagounited-kingdomunited-states4FENUHFENUlFENUFENA¨FNLB¸FENCÌFZHHÔFZHIÜFCHSìFZHHFCHS8FZHI\FCHT„FNLB FENUÄFENAÜFENLüFENC FENB8 FENIP FENJp FENZˆ FENS´ FENTè FENG!FENU!FENU0!FFRBP!FFRCp!FFRL”!FFRS°!FDEAÐ!FDECø!FDEL"FDES8"FENIT"FITSp"FNOR„"FNOR¨"FNONÌ"FPTBø"FESS#FESB<#FESLX#FESO|#FESC¤#FESDÜ#FESFü#FESE$$FESGH$FESHl$FESMŒ$FESN¬$FESIÐ$FESAð$FESZ%FESR0%FESUX%FESYx%FESVœ%FSVF¼%FDESÈ%FENGÐ%FENUØ%FENUAà%FUSAð%FGBR&FCHN&FCZE&FGBR(&FGBRD&FNLDT&FHKGh&FNZL€&FNZLˆ&FCHNœ&FCHN°&FPRIÈ&FSVKØ&FZAFô&FKOR'FZAF('FKOR@'FTTOÈ%FGBRd'FGBR„'FUSAÐ%FUSAACPOCP6-3F3F 3F(3F83F@3FH3FP3F	X3F
`3Fh3Fp3F
x3F€3Fˆ3F3F˜3F 3F¨3F°3F¸3FÀ3FÈ3FÐ3FØ3Fà3Fè3Fð3Fø3F4F 4F!4F"È%F#4F$ 4F%(4F&04F'84F)@4F*H4F+P4F,X4F-`4F/h4F6p4F7x4F8€4F9ˆ4F>4F?˜4F@ 4FA¨4FC°4FD¸4FFÀ4FGÈ4FIÐ4FJØ4FKà4FNè4FOð4FPø4FV5FW5FZ5Fe5F 5F$5F05F<5F(FH5FT5F`5Fl5F	üFx5F„5F
5Fœ5F¨5F´5FFFÀ5FÌ5FØ5Fä5Fð5Fü5F6F6F 6F,6F86FD6F P6F!\6F"h6F#t6F$€6F%Œ6F&˜6F'¤6F)°6F*¼6F+È6F,Ô6F-ì6F/ø6F27F47F57F6(7F747F8@7F9L7F:X7F;d7F>p7F?|7F@ˆ7FA”7FC 7FD¸7FEÄ7FFÐ7FGÜ7FIè7FJô7FK8FL8FN8FO$8FP08FR<8FVH8FWT8FZd8Fet8Fk„8Fl”8F 8F¬8FF¸8F	Ä8F
Ð8FÜ8Fè8Fô8F9F9F9F09F,<9F;T9F>`9FCl9Fk„9F”9F 9F¬9F	¸9F
Ä9FÐ9FÜ9F;ô9Fk:F:F:F(:F	4:F
@:FL:FX:F;d:Ft:F€:FŒ:F	˜:F
¤:F°:F¼:F;Ô:Fä:F	ð:F
ü:F;F;F;,;F<;F	H;F
T;F`;F;x;F ˆ;F	 ”;F
  ;F; ¬;F$¼;F	$È;F
$Ô;F;$à;F(ð;F	(ü;F
(ôGFˆÈ4F7HFx3FHFNˆ4F/HFtØ3F$HF¯0HFZ€3F
@ÿÿÿÿÿÿï˜À˜@ðððÿà €€€ÿÀÀÿ€ÊòIqÊòIñ`B¢
`B¢YóøÂn¥YóøÂn¥loglog10exppowasinacossqrtð??ä
¨|?÷Q-8>=Þ¶W‹?0ûþ	k8=€–Þ®p”?á‘xü9=>Ž.Úš?pnžÑ5=ÀY÷Ø­ ?¡	Q*=cÆ÷ú£??õñb6=ÀïY§?ÛTÏ?½=Ç>ª?†ÓÐÈWÒ!=@Ã-32­?DÙøÛz= Öp(°?vP¯(‹ó=`ñ윱?ÔUS?à>=Àeý³?•gŒ€â7=`Å€'“´?ó¥bͬÄ/=€é^s¶?Ÿ}¡#ÏÃ= Jwk·?zn è=ÀäNÖ¸?‚LNÌå9=@$"´3º?5Wg4pñ6=€§T¶•»?ÇNv$^)=àé&ê¼?ËË.‚)Ñë< lÁ´B¾?éMóå%=`j±¿?§w·¢¥Ž*= <Å›mÀ?Eúáî2=Þ¬>
Á?®ðƒËEŠ=Ðt?¸Á?Ôÿ“ñ=ÐOþQÂ?Àw(@	¬þ<àô0÷Â?Ac
Çõ0=Pyp”Ã?dry?é= ´St)Ä?4K¼Å	Î>=Àþú$ÊÄ?QhæBC .=0	ubÅ?-ª³ìß0=öòÅ?a>-ï?=¢Æ?Й–ü,”í<(lX Ç?ÍT@b¨ ==Pÿ•´Ç?Å3‘h,%= Îf¢?È?Ÿ#‡†ÁÆ =ðVÌÈ?ß Ï¡´ã6=ÐçïßYÉ?åàÿz $=ÀÒGéÉ? $òl35=@‹¤nÊ?[+¹¬ë3=ðRÅ·Ë?sªdLiô==pù|æˆË?r x"#ÿ2=@.ºãÌ?|½UÍË2=lÔ‘Ì?r¬æ”F¶=aûÍ?–®‘Û4=ý«YŸÍ?sl×¼#{ =`~R=Î?ä“.òi1= Ü,šÎ?‡ñõë =”vXÏ?êë¯=pÛ€™Ï?h–ò÷}s"=Ð	E[
Ð?%S#[k=èû7€HÐ?ƹ¹“j=¨!V1‡Ð?®ó¿}Úa2=¸jqÆÐ?2Á0Jé5=¨ÒÍÙÿÐ?€ñö5=x¾/@Ñ?‹º"B <1=i—zÑ?™\-!yò!=X¬0zµÑ?~„ÿb>Ï==¸:ÛðÑ?ß#.X'=HBO&Ò?ù¤(~=x¦bbÒ?.°=ØCÀq˜Ò?y7ž¬i9+=€vÁÕÒ?¿¾Þê:=0»§³Ó?2ض™’8=xŸPDÓ?X³1ï=ÀÛ?ÀÛ?QÛ?QÛ?ðèÚ?ðèÚ?à€Ú?à€Ú?ÀÚ?ÀÚ? ¾Ù? ¾Ù?€]Ù?€]Ù?PÙ?PÙ? ©Ø? ©Ø?àUØ?àUØ?(ÿ×?(ÿ×?`¯×?`¯×?˜_×?˜_×?Ð×?Ð×?€ÃÖ?€ÃÖ?¨zÖ?¨zÖ?Ð1Ö?Ð1Ö?pìÕ?pìÕ?§Õ?§Õ?(eÕ?(eÕ?@#Õ?@#Õ?ÐäÔ?ÐäÔ?`¦Ô?`¦Ô?hkÔ?hkÔ?ø,Ô?ø,Ô?xõÓ?xõÓ?€ºÓ?€ºÓ?ƒÓ?ƒÓ?øNÓ?øNÓ?xÓ?xÓ?pãÒ?pãÒ?à²Ò?à²Ò?Ø~Ò?Ø~Ò?HNÒ?HNÒ?¸Ò?¸Ò? ðÑ? ðÑ?ˆÃÑ?ˆÃÑ?p–Ñ?p–Ñ?XiÑ?XiÑ?¸?Ñ?¸?Ñ? Ñ? Ñ?éÐ?éÐ?ØÂÐ?ØÂÐ?8™Ð?8™Ð?sÐ?sÐ?pIÐ?pIÐ?À&Ð?À&Ð?˜Ð?˜Ð?à´Ï?à´Ï?€oÏ?€oÏ? *Ï? *Ï?ÀäÎ?ÀäÎ?`ŸÎ?`ŸÎ?ZÎ?ZÎ?Î?Î?0ÖÍ?0ÖÍ?À—Í?À—Í?PYÍ?PYÍ?àÍ?àÍ?`ãÌ?`ãÌ?ð¤Ì?ð¤Ì?pmÌ?pmÌ?/Ì?/Ì?€÷Ë?€÷Ë?ÀË?ÀË?à?tanhatanatan2sincostanceilfloorfabsmodfldexp_cabs_hypotfmodfrexp_y0_y1_yn_logb_nextafterÜOFàOFÐOFÔOF°YF¸YF!8XFäOF
ìOF@XFHXFôOFPXFTXF XXF\XFdXFlXFtXF|XF„XFŒXF”XFœXF"¤XF#¨XF$¬XF%°XF&¸XFsinhcoshðøÿÿÿÿÿÿÿï€?ÿÿÿÿÿÿÿ?ÿ?ÿÿÿÿÿÿÿ?ÿØ›FŒiECreateDirectory (%s)CreateFile (%s)CreateFileMapping (%s)MapViewOfFile (%s)1.2.8inflateInit2 returns %dinflate returns %dinflateEnd returns %d\-32PURELIBPLATLIBHEADERSSCRIPTSScripts\DATALib\site-packages\Installation failed.import py_compile; py_compile.compile (r'%s')%s%cPy_InitializePy_SetProgramNamePy_FinalizePyRun_SimpleStringPySys_GetObjectPy_OptimizeFlagCSIDL_COMMON_STARTMENUCSIDL_STARTMENUCSIDL_APPDATACSIDL_COMMON_DESKTOPDIRECTORYCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_STARTUPCSIDL_STARTUPCSIDL_COMMON_PROGRAMSCSIDL_PROGRAMSCSIDL_FONTSsshell32.dllfunction not availableSHGetSpecialFolderPathAno such folder (%s)unknown CSIDL (%s)CoInitialize failed, error 0x%xsss|sssiCoCreateInstance failed, error 0x%xQueryInterface(IPersistFile) error 0x%xSetPath() failed, error 0x%xSetDescription() failed, error 0x%xSetArguments() error 0x%xSetIconLocation() error 0x%xSetWorkingDirectory() error 0x%xFailed to create shortcut '%s' - error 0x%xssiicreate_shortcutget_special_folder_pathget_root_hkeyfile_createddirectory_createdmessage_boxPYTHONHOME=%sSOFTWARE\Python\PythonCore\%d.%d%s\InstallPathPyImport_ImportModulePyObject_SetAttrStringPyObject_GetAttrStringPyCFunction_NewPy_BuildValuePyArg_ParseTuplePyErr_FormatPyLong_FromVoidPtrbuiltinsValueErrorOSErrorPySys_SetArgvCould not open postinstall-script %s
Running Script...*** Could not load Python ***PyErr_PrintCan't load Python for pre-install script (%d)Running the pre-installation script failed
Out of memory!Runtime Error100 Made Dir: %s
200 File Copy: %s
200 File Overwrite: %s
.pyErrorInvalid cfgdata magic number (see bdist_wininst.py)~duCould not create temporary fileTimes RomanSetupWindowClassSetup.exeCould not register window classSetup %sThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCorePython Version %s (found in registry)Software\Python\PythonCore\%s\InstallPathStrangeDon't know Python's installation typePython %s is required for this package. Select installation to use:Python version %s required, which was not found in the registry.No Python installation found in the registry.Cannot installPython Version %d.%dpython%d%d.dllHKEY_LOCAL_MACHINEHKEY_CURRENT_USERYou do not seem to have sufficient access rights
on this machine to install this softwareCould not open key%s\%s-wininst.logaCan't create "%s" (%s).

Try to execute the installer as administrator.*** Installation started %Y/%m/%d %H:%M ***
Source: %s
999 Root Key: %s
%s-py%d.%dCould not create key020 Reg DB Key: [%s]%s
Python %d.%d %sDisplayNameCould not set key value040 Reg DB Value: [%s\%s]%s=%s
%s\Remove%s.exewb"%s\Remove%s.exe" -u "%s\%s-wininst.log"UninstallString*** Installation finished %Y/%m/%d %H:%M ***
Click Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Ready to installRunning pre-installation scriptInstalling files...Failed to unzip installation filesCompiling files to .pyc...Loading python...Compiling files to .pyo...-installPlease wait while running postinstall script...\Scripts\300 Run Script: [%s]%s
*** run_installscript: internal error 0x%X ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.IsUserAnAdminrunasFailed to start elevated process (ShellExecute returned %d)Setuptitleinfobuild_infotarget_compiletarget_optimizetarget_versionnamemetadatainstall_scriptuser_access_controlforceautononeoopsBad user_access_control value%s.batw:Repeat
del "%s"
if exist "%s" goto Repeat
Could not delete keyCould not delete value-remove*** Could not run installation script ***uninstall-scriptWrong number of args-u2. arg is not -urcould not open logfileOut of memoryPlease confirmAre you sure you want to remove
this package from your computer?%d Root Key: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Made Dir: %s%d File Copy: %s%d File Overwrite: %s%d Reg DB Key: %s%d Reg DB Value: %s%d Run Script: %s%d files and %d directories removed
%d files or directories could not be removed%d files and %d directories removedUninstall Finished!Could not open archiveRemoveThis program is normally started by windowsSetup program invalid or damagedìZFà˜Fð˜FøZFü˜F™F™F$™F8™FH™FøZF–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”Þñ`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

@@HN	

#+3;CScsģ̋	
!1AaÁ 0@` inflate 1.2.8 Copyright 1995-2013 Mark Adler invalid distance too far backinvalid distance codeinvalid literal/length codeincorrect header checkunknown compression methodinvalid window sizeunknown header flags setheader crc mismatchinvalid block typeinvalid stored block lengthstoo many length or distance symbolsinvalid code lengths setinvalid bit length repeatinvalid code -- missing end-of-blockinvalid literal/lengths setinvalid distances setincorrect data checkincorrect length checkneed dictionarystream endfile errorstream errordata errorinsufficient memorybuffer errorincompatible version*PXT,œ,Œ*PX€œ€Œ*PX
Ü”œ”Œ\ÀF œFвEËF(šF8šF@šFËFÿÿÿÿ@(šFËFpšF€šFŒšF@šFËFÿÿÿÿ@pšF0ËF¼šFÌšFØšF@šF0ËFÿÿÿÿ@¼šFHËF›F›F$›F@šFHËFÿÿÿÿ@›FdËFT›Fd›Fp›F@šFdËFÿÿÿÿ@T›F„ËF ›F°›F¼›F@šF„ËFÿÿÿÿ@ ›FœËFì›Fü›FœFœËFÿÿÿÿ@ì›F`‹€‘ðøRSDS•¢7û¡Hš~¶„H·,šE:\CPython\cpython35\lib\distutils\command\wininst-14.0.pdbûûòGCTL”š.text$mn°Ð.idata$5в.00cfgÔ².CRT$XCAز.CRT$XCAAܲ.CRT$XCZà².CRT$XIAä².CRT$XIAAè².CRT$XIACì².CRT$XICü².CRT$XIZ³.CRT$XPA³.CRT$XPX³.CRT$XPXA³.CRT$XPZ³.CRT$XTA³.CRT$XTZ ³ôæ.rdataš.rdata$r œ.rdata$sxdata,œD.rdata$zzzdbgpŸ.rtc$IAAtŸ.rtc$IZZxŸ.rtc$TAA|Ÿ.rtc$TZZ€Ÿ¼.xdata$x<«Œ.idata$2È«.idata$3Ü«Ð.idata$4¬®¦.idata$6À.dataËÀ.data$rÀËà0.bssô.gfids$xô€.gfids$y0.rsrc$010(.rsrc$02þÿÿÿÌÿÿÿþÿÿÿÅ~@Ù~@þÿÿÿØÿÿÿþÿÿÿ2‚@E‚@þÿÿÿ|ÿÿÿþÿÿÿá÷@þÿÿÿ|ÿÿÿþÿÿÿvø@þÿÿÿÐÿÿÿþÿÿÿý@þÿÿÿÐÿÿÿþÿÿÿÛý@þÿÿÿÐÿÿÿþÿÿÿ1AþÿÿÿÔÿÿÿþÿÿÿ’AþÿÿÿÔÿÿÿþÿÿÿàAþÿÿÿÔÿÿÿþÿÿÿ$AþÿÿÿÔÿÿÿþÿÿÿÓAþÿÿÿÔÿÿÿþÿÿÿ1AþÿÿÿÔÿÿÿþÿÿÿ‚AþÿÿÿÔÿÿÿþÿÿÿAþÿÿÿÔÿÿÿþÿÿÿàAþÿÿÿÈÿÿÿþÿÿÿ,BþÿÿÿÈÿÿÿþÿÿÿÈ,BþÿÿÿÔÿÿÿþÿÿÿÊ-BþÿÿÿÔÿÿÿþÿÿÿ’^BþÿÿÿÔÿÿÿþÿÿÿã^BþÿÿÿÔÿÿÿþÿÿÿB2CþÿÿÿÔÿÿÿþÿÿÿä2CþÿÿÿÔÿÿÿþÿÿÿ“2CþÿÿÿÔÿÿÿþÿÿÿ53CäÿÿÿÔÿÿÿþÿÿÿàgCÈgCØgCþÿÿÿÈÿÿÿþÿÿÿ$kCþÿÿÿØÿÿÿþÿÿÿóxCþÿÿÿÿxCþÿÿÿØÿÿÿþÿÿÿ?rCþÿÿÿØÿÿÿþÿÿÿÎlCþÿÿÿØÿÿÿþÿÿÿYmCþÿÿÿØÿÿÿþÿÿÿlCþÿÿÿØÿÿÿþÿÿÿmCþÿÿÿÔÿÿÿþÿÿÿf„CþÿÿÿÔÿÿÿþÿÿÿ·„CäÿÿÿÔÿÿÿþÿÿÿU‹CY‹CþÿÿÿÔÿÿÿþÿÿÿ—CþÿÿÿÔÿÿÿþÿÿÿfCþÿÿÿÌÿÿÿþÿÿÿ̘CþÿÿÿÌÿÿÿþÿÿÿ|™CþÿÿÿÐÿÿÿþÿÿÿPšCþÿÿÿÐÿÿÿþÿÿÿ›CþÿÿÿÌÿÿÿþÿÿÿ­CþÿÿÿÔÿÿÿþÿÿÿg±CþÿÿÿÔÿÿÿþÿÿÿ[½CþÿÿÿÔÿÿÿþÿÿÿ‹ÇCþÿÿÿÐÿÿÿþÿÿÿSÚCþÿÿÿÔÿÿÿþÿÿÿŽÜCþÿÿÿÄÿÿÿþÿÿÿ7ÜC
ÜCþÿÿÿÔÿÿÿþÿÿÿ¾ÞCþÿÿÿØÿÿÿþÿÿÿ&óCþÿÿÿØÿÿÿþÿÿÿ2òCþÿÿÿØÿÿÿþÿÿÿ“òCþÿÿÿØÿÿÿþÿÿÿÞòCþÿÿÿÔÿÿÿþÿÿÿ*+DþÿÿÿÔÿÿÿþÿÿÿ“,DþÿÿÿÔÿÿÿþÿÿÿâ/DþÿÿÿÐÿÿÿþÿÿÿM1DþÿÿÿÌÿÿÿþÿÿÿ8DþÿÿÿØÿÿÿþÿÿÿCODþÿÿÿÔÿÿÿþÿÿÿODþÿÿÿØÿÿÿþÿÿÿÁNDþÿÿÿÔÿÿÿþÿÿÿåQDþÿÿÿÔÿÿÿþÿÿÿESDþÿÿÿÐÿÿÿþÿÿÿ€dDþÿÿÿÄÿÿÿþÿÿÿ–bDþÿÿÿÌÿÿÿþÿÿÿª`DþÿÿÿÔÿÿÿþÿÿÿ‹DþÿÿÿØÿÿÿþÿÿÿöyDþÿÿÿÔÿÿÿþÿÿÿóDþÿÿÿÔÿÿÿþÿÿÿгDþÿÿÿÔÿÿÿþÿÿÿ0´DþÿÿÿÈÿÿÿþÿÿÿκDäÿÿÿ´ÿÿÿþÿÿÿæ¸DäÿÿÿÌÿÿÿþÿÿÿ×µDþÿÿÿÔÿÿÿþÿÿÿŸ´DþÿÿÿÐÿÿÿþÿÿÿ‚ÓDþÿÿÿÐÿÿÿþÿÿÿÔDþÿÿÿÔÿÿÿþÿÿÿQÕDþÿÿÿÔÿÿÿþÿÿÿ¦ÕDþÿÿÿÔÿÿÿþÿÿÿTÑDþÿÿÿÔÿÿÿþÿÿÿ¯ÑDþÿÿÿÌÿÿÿþÿÿÿˆÛDfÛDþÿÿÿÔÿÿÿþÿÿÿ
ÜDþÿÿÿÌÿÿÿþÿÿÿÔßDþÿÿÿÄÿÿÿþÿÿÿÒàDþÿÿÿÔÿÿÿþÿÿÿ"èDþÿÿÿÔÿÿÿþÿÿÿÈEþÿÿÿØÿÿÿþÿÿÿž/Eº/EþÿÿÿÌÿÿÿþÿÿÿS:EþÿÿÿÔÿÿÿþÿÿÿ9EþÿÿÿÐÿÿÿþÿÿÿE1EþÿÿÿÐÿÿÿþÿÿÿÕ1EþÿÿÿØÿÿÿþÿÿÿyhEŒhE¬Ú®(°4¬¦±X°0®B³T²¬ʳ4°Ü«n´°(®Œ´L²œ®δÀ²ä³ö³`´P´<´*´´´Ô³¾®¬®¬³š³Š³~³r³b³N³¼³:°N°`°p°„°š°ª°¾°ΰÜ°ì°þ°
±±,±:±L±^±r±Š±0»|¯$°»ôºàº̺¼º¤ºŒºzº`ºFº:º.ºººü¹è¹Ô¹ȹ¸¹ ¹Š¹t¹`¹L¹°°î¯Ú¯į¸¯¨¯»¯f¯X¯J¯4¯$¯¯¯ø®è® »4¹@»¹¹ð¸à¸Ø´ô´µ&µBµ\µrµˆµ¢µ¸µ̵Þµòµ¶&¶2¶J¶b¶z¶¢¶®¶¼¶ʶÔ¶æ¶ü¶· ·.·>·L·\·~·–·¢·°·Æ·зâ·ò·þ·
¸¸.¸@¸P¸b¸r¸ˆ¸ž¸¸¸Ò¸|´αÀ±´±.³³³³ü²ì²ز̲¾²°²¢²²~²l²X²B²0² ²²²ö±ê±Ú±¨´º´˜´„PropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrorSetFileTime
lstrlenA…UnmapViewOfFilePGetLastError0GetFileAttributesAºCreateFileACloseHandle»CreateFileMappingA­CreateDirectoryADosDateTimeToFileTimeÀMapViewOfFilePReadFilebGetModuleFileNameASetPriorityClass	GetCurrentProcessÀGetStdHandle¦LoadLibraryExAcGetModuleFileNameW5SetThreadPriorityüSetFilePointer¨ResumeThreaddGetModuleHandleAÑMultiByteToWideCharâGetTempPathA
GetCurrentThread¥LoadLibraryADeleteFileA"SetStdHandleGetProcAddress²LocalFree;GetFileSize’RemoveDirectoryAžFreeLibrary×CreateProcessA™FormatMessageAàGetTempFileNameA“GetPrivateProfileIntA™GetPrivateProfileStringAKERNEL32.dlléEndPaintBeginPaint¥ReleaseDCWUpdateWindowzGetParentkPeekMessageA<GetDlgItemÉSetCursor·SendMessageAÑSetDlgItemTextA²SendDlgItemMessageA?TranslateMessagepCreateWindowExA DefWindowProcA‡RegisterClassASMoveWindowFMessageBoxA ShowWindowzwsprintfAªGetSystemMetricsoPostMessageA4GetDCLoadCursorABGetFocusËGetWindowRect´DispatchMessageAUSER32.dllVCreateSolidBrushDeleteObjectÝSetBkModeTextOutASetTextColor7CreateDIBitmapÕSelectObject=CreateFontAGDI32.dllrRegEnumKeyExAkRegDeleteValueA„RegOpenKeyExA¡RegSetValueExARegQueryValueA\RegCreateKeyExA‘RegQueryValueExAaRegDeleteKeyATRegCloseKeyADVAPI32.dll3ShellExecuteASHELL32.dllOCoInitializeCoUninitializeCoCreateInstanceole32.dll‚UnhandledExceptionFilterCSetUnhandledExceptionFilteraTerminateProcessmIsProcessorFeaturePresent-QueryPerformanceCounter
GetCurrentProcessIdGetCurrentThreadIdÖGetSystemTimeAsFileTimeKInitializeSListHeadgIsDebuggerPresent¾GetStartupInfoWgGetModuleHandleWWInterlockedPushEntrySListTInterlockedFlushSList­RtlUnwind%EnterCriticalSection¢LeaveCriticalSectionDeleteCriticalSectionHInitializeCriticalSectionAndSpinCountsTlsAllocuTlsGetValuevTlsSetValuetTlsFree§LoadLibraryExWÍWideCharToMultiByteÈGetCommandLineAÉGetCommandLineWÂCreateFileWGetDriveTypeW>GetFileTypePeekNamedPipe^SystemTimeToTzSpecificLocalTime]FileTimeToSystemTimeáWriteFileQExitProcessfGetModuleHandleExW¤GetACPîGetConsoleModeNReadConsoleW3HeapFree/HeapAllocGetDateFormatW÷GetTimeFormatW“CompareStringW–LCMapStringWTGetLocaleInfoWtIsValidLocaleüGetUserDefaultLCIDGEnumSystemLocalesWíSetEnvironmentVariableAîSetEnvironmentVariableW6HeapReAllocÜGetConsoleCPÅGetStringTypeWùGetTimeZoneInformationãSetCurrentDirectoryWGetCurrentDirectoryWIGetFullPathNameWFGetFullPathNameAùOutputDebugStringAúOutputDebugStringW¬WaitForSingleObjectExèCreateThreadhFindClosemFindFirstFileExAnFindFirstFileExW}FindNextFileAFindNextFileWrIsValidCodePage†GetOEMCP³GetCPInfo'GetEnvironmentStringsWFreeEnvironmentStringsW¢GetProcessHeapÃSetConsoleCtrlHandler2GetFileAttributesExWêSetEndOfFileýSetFilePointerEx’FlushFileBuffersàWriteConsoleW8HeapSizeãGetTempPathW!EncodePointerþDecodePointer@RaiseException±¿DNæ@»ÿÿÿÿÿÿÿÿ “   ¼Fÿÿÿÿ€


ÿÿÿÿÀFÃFÃFÃFÃFÃFàÈF@FÀFF@ÂF°ÆFCÀFºFPSTPDTÃFPÃFÿÿÿÿÿÿÿÿ¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ°ÆF..ÔÈFðÞFðÞFðÞFðÞFðÞFðÞFðÞFðÞFðÞFØÈFôÞFôÞFôÞFôÞFôÞFôÞFôÞFàÈFþÿÿÿþÿÿÿu˜ðZF([FüZF([F[FøZF[F[F [FøZFð[F\F\F(\FH\F`\Fx\Fˆ\F \F°\FSoftware\Microsoft\Windows\CurrentVersion\UninstallÿÿÿÿSoftware\Microsoft\Windows\CurrentVersion\Uninstallt^Fˆ@„^Fc@œ^FL@¬^Fñ@¼^F*@Ð^Fý@ðZFøZFüZFøZF[FøZF[F[F [FøZFDZF.?AVDNameNode@@DZF.?AVcharNode@@DZF.?AVpcharNode@@DZF.?AVpDNameNode@@DZF.?AVDNameStatusNode@@DZF.?AVpairNode@@DZF.?AVtype_info@@Ìb±b ˜{‘4ˆll8‰‰>‰;‰’‰	Šß~½*¤*ÊÞtÞŸùsù‰‰²±¡±Ýè…èI‰F‰†Ù3ØL‰‰ˆµˆµˆµ€ÿX¸Æ¸Æ¸Æ¸ÆöÙlûlWmomWmomöq	 ó¢¤©ô«j§Tµ%@´+ðÚ&U¬B‚C

Er4

„‡„‡YÓÓÓhgflkjponutsyxw €8€nh€k€€l˜€m°€nÈ€àð 0
8 ØàZ@!(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ@D0U0c0…00Û0ì01B1W1ƒ111°1º1Ë1Û1å1ö1:2^2r22£2Ô2ä2ì2˜3Ó3á3x4|5Á5Ç5L7f7m7t7}7™7¤7µ7¿7Þ7÷7
88=8D8g8n8—88ª8°8ü8#9G9R9Z9d9o9z9…9‘9Ç9ú9:::3:<:R:X:m:x:„:Š:“:™:Ÿ:­:´:¹:Å:Î:ß:ç:í:ó:;";(;3;B;T;c;i;o;’;É;Ó;Ù;ß;<$<>>/>6><>B>N>T>d>q>|>>¢>©>¶>¼>Å>Ê>Ó>*?f?…??•? ?«?µ?À?Ë?Ö? €0+03090C0H0k0s0{0ƒ0œ0¬0´0Ä0Ï0Ú0å0ð0û01†1¤1¯1µ1Ë1'2Ô2Ú2í2"3)3P3b3ƒ3“3£3¬3Ä3Ï3×3â3í3ø3#4]4g4˜4ž4´4Õ4á4è45B5j5„5™5¹5Å5Ñ5ö5!6C6Y6{6‚6ˆ6¨6ü677-7>7L7e7r7y7€7Œ7¬7Ì7Ø788.8>8D8[8h8w8ƒ88•8­8´8º8Ì8×8Ü8ì8ö89:9O9x9„9‘9â9è9î9ù9þ9-:7:F:Z:{:‹:•: :º:Â:Î:Ó:é:ü:;;$;+;6;];i;;§;¸;Õ;Û;æ;ë;ñ;÷;ü;<<<7<>6>L>W>“>š>©>°>Ï>?%?D?p?¦?±?À?Ò?ò?û?0ø000$0.080>0E0[0¬0Ã0É01(1-161A1H1^1c1u1€1‡1—1ž1¦1µ1¼1Ë1å1ì1ò1÷1222,232G2U2Z2k2w2‹2±2¼2Á2Æ2Ú2à2å2ê2ð2333P3‘3´3Ì3Ó3ö3444)40464<4N4a4f4p4u4€4‘4Ÿ4Â4
5(52575=5H5N5Y5e5j5o5¤5®5Æ5Û5à5æ5ó5ù56
686D6N6f6r6w6}6‡6Œ6—6¨6¹6¿6Ò6×6æ67"7-7M7R7X7‚7±7Ï7Ù78M8Z8p88¨8­8¸8¿8Å8Ü899!91979D9W9\9p9„9¦9Å9Í9Û9î9ú9:#:0:8:E:P:m:s:|:„:‘:œ:º:Õ:	;;);9;?;G;h;m;;®;³;É;Ï;	<1<6>>>#>4>?>K>S>Z>w>„>£>±>¶>»>Ã>Ô>Û>ë>ô>?,?2?@?G?L?Z?f?q?v?ƒ??–?›? ?©?¯?¶?¿?Ä?Ë?Ô?Ù?Þ?æ?ë?ô?û?@000
000!0&0/040<0A0R0Y0`0‰0´0¼0Ö0Û0á0è0ò0ý01111#1|1™1«1¼1É1Ú1î1K2^2h2z2ˆ22›2©2&3,373>3E3Q3a3h3o3x3ì3ò3ý3444'4.454>4w4¢4¯4å4+5?5c5j5q5ª5Ù56676!757?7D7\7e7Ñ7ð78%8+8F88¸8Ù8ö89@9}9‘9¸9¿9Ö9Ý9ç9::3:>:D:K:U:_:d:’:µ:¼:ã:ñ:ú:>=>w>~>Š>”>­>´>À>Ê>ä>ë>÷>??"?.?8?R?Y?e?o?‰??Ÿ?©?Ã?Ê?Ö?à?P„0000R0Y0e0o00æ01!1-171Q1X1d1n1ˆ11›1¥1¿1Æ1Ò1Ü1ö1ý1	22-242@2M2j2q2}2‡2 2§2³2½2ð2÷23
3/3²3I8X8d8î9ý9°:¾:<á>>>0?H?\?o?€¸0×01W1j1}1‰1™1ª1Ð1å1ì1ò122l2y2 2¨2Á2Û2ã2û2,3G3S3b3k3x3§3¯3Ð3Ö3Ü3.474=4n4585B5S5y5—5Ø5Þ5&6/646Z6_6„6‘6®6ð6þ67$7¬7µ7½7888P8Y8f8q8z8‰8”8œ8²8æ9;÷;ÿ;å>ê>m?Å?Ø?4P011(2s2‘2Å2â2÷2393G3M3h33¤3À3Ê3Ô3â3ý34464[4b4k4y4€4†4Ÿ4¦4­4¿4È4Ü4ï4p5u5z5Š55”5¤5©5®5¾5Ã5È5Ø5Ý5â5ò5÷5ü5666&6+606@6E6J6‰6•6Ñ6á6ø67*7F7U7a7o7‘7È7Ý7ç7ù78
88H8M8R8‹88•8Å8Ê8Ï8999?9H9M9R9v9‚9‡9Œ9°9¼9Á9Æ9í9ù9þ9:3:;:@:P:Z::‘::§:¹:Â:Õ:Ü:î:ó:h;<Ü$>0>6>>>E>N>W>\>d>j>>‘>È>Ý>ð>0?ž? t€0¥0º0ñ0ø011+1G1N1a1n1€1†1›1¦1´1Ü1d3s3Ë34­4T5b5€5•5Å6Î6‡7³7Ì7ä7C9v9Ô9/:P:o:Ú:f;ž;·;3}>?€?Ø?°èÑ0ô0T1¤12D2W2‡2°2¾2Ì2Ú2è2ö2333*3e3œ3¿3Í3Ü3í3û3474b4}4‡4¶4Å4ã4ú4 5O5t5y5…5Œ5°5Ã5È5Ô5Û5ä5é56P6k6Š78'8`8y8œ8È8é8ð8õ89999T9†9¥9¼9Ð9ë9ò9ù9:.:Y:c:m:w::¹:Ö:î:;$;1;‡;–;ú;< <-u>Ô>Ú>1?7?a?†?‘?ÀÌf0†0Ö0ö011Œ1¹1æ12•3Ç3ø34404;4‹4¤4µ4Ï4à4÷45M5z5†5›5¼5ý5e6y66Ø6ì6ò6 7†7•78-8:8}8Ÿ8µ8á8è89"9)909|9„9®9Ù9Þ9å9ì9ó9:	:-:s:w:{::ƒ:‡:‹::›:µ:;K;b;;;¿;ë;<<<<"0>G>Q>x>?™?ÐÄ0'0Z0Ö1!2?2b2q2Š2¨2á2ü2•3³3Ò3+4h4§4¼4Ï45-5D55‹5¿5Í5×5ø5ö6`77¡7°7Á7ß7é788'8J8Z8j8€8«8É8ë8,9H9M9a9¦9Ô9ã9::M:`:j:|:Š:”:°:µ:Û:ù:	;;>;O;~;«;ß;÷<==(=F={=‚=•=ç=ø=C>[>d>z>Ê>Ù>7?f?¯?÷?àÈ0U0p0œ0ú01/1E1‰1½132J2w2„2¸2ñ23–3Ý3–4Ÿ4¬4½4Ò4æ4ú4
5a5†5¬5Ì5Ý566k6p6ˆ6ž6µ6×6ä67'7G7g7‡7Ç7×7ë78!8:8S8]8t8T9Y9y9—9¿:Î:ý:=;T;u;‡;‘;°;Ï;Ø;â;è;ó;ù;<@<œ<§<²<»<Á<=!=8=]=†=­=Ê=ê=>Y>q>ù>??ðÔ070G0”0³0·0»0¿0Ã0Ç0Ë0Ï0Ó0Û0ó0ø041f1r1£1ò122f2q2€2¥2°2é2ö2
33K3W3h33ž3Á3Í3Þ3þ3!4Q4c4–4Ê4Ó4ò4#5,686C6O6V6[6a6f6l6q6v6|66‡6‘6¡6¨6\77‰77•7›7Ä7ñ788$8*808Y8Ü8A9M9Å9ß9è9:M:Y:_:’:š:v<7=?›?ª?¸?Ä?Ð?Þ?î?h00=0R0h0u0ƒ0‘0œ0ø01Á1S2¡2ó2ü2D3t3}3Å34+4O4z4ó67D7„7º7æ78N8ñ9
:*:J:n:z:a;j;r;‰>–>É>Ó>?'?`? P2¡2ò2C3”3å3Q9Í:R<>Õ? Q1`D=12
3Ü3¢4Ù5Ú9ï9:$:D:V:v:‹:«:À:à:ò:;);K;`;‚;”;¶;Ë;í;<$<6<p ¼2Â2È2Î2Ô2Ú2à2æ2ì2ò2ø2þ2Ò7g8k8o8s8w8{88ƒ8#9Ã9Ç9Ë9Ï9Ó9×9Û9ß9V:ß:ã:ç:ë:ï:ó:÷:û:r;<<<<<<<#<Ã>‡>‹>>“>—>›>?¯?³?·?»?¿?Ã?Ç?Ë?€dl011111#1'1+1£1/23272;2?2C2G2K2Ã2_3c3g3k3o3s3w3{34¿4Ã4Ç4Ë4Ï4Ó4×4Û4S5ß5ã5ç5ë5ï5ó5÷5û5°3s5ß7<:™<?ÀLØ3Þ3ä3ê3ð3ö3ü3443474;4?4C4G4K4O4S4W4[4_4)5¥56n6ê6P7³7/8•8ø8t9Ú9ð$Ú<ôV>º>Ó>+?E?ž?º?0800¬01 1ƒ1ž1ö124Ç5ä5
61676=6C6I6O6U6[6a6g6m6s6…7,8Ó8z9!:È: @575ì5ž6Ë6ø6J7}7Â7`8‘8¦:«:±:¶:Á:Ç:Í:Ó:Ù:ß:å:;=;O;<‹=0Ú0
1=1P1P@¡8<.>/>S>¤>`=2â4]5Ø5S6Î6I7Ä7?8€ >>F>N>Á>É>??„??Ò?Û?lS0\0¡0ª01#1-252H3Q3t4}4‡55Á5É5ý56=6F6{6ƒ6µ6½6ñ6ú617:7p7D8H8L8P8T8X8\8`8d8h8€8H9L9P9T9X9\9`9d9h9l9À¢7Y8Â9Ê9::D=Ð,01c1h1m1ˆ11’1É7þ9:=:D:|=??B?I?à «2³5»5ò5ù59Ø:à:;;±>ðc>Œ?l<4’4š4É4Ð4ª8¿<======== =$=3=t=x=|=€=„=ˆ=Œ==”=˜=§=è=ì=ð=ô=ø=ü=>>>>>\>`>d>h>l>p>t>x>|>€> (€5œ5 5¤5¨5¬5°5´5¸5¼5À5Ä5ç>?c?”?0DÖ0Ü02T2¥2ö2\4r4!575é5ÿ5±6Ç6È78R8"9[9®9~:·:
;Ú;´>Å?@P	040R0c1§1Ö1ô13c3’3°3Û45J5n5‚5Æ5ë56&6n6‚8Ï8I9Ã9W:C;V;×<è<ù<
=f>t>Ü>P Q1…2›2Õ2ë2ù2I3x3†33®3µ3»3É3Ï3ä3444*4Y4|4Š4–4¬4¿4ú455-595A5Y5~5à5ê5ð5ö5a6j6£6®6ÿ6	777€7‰7Â7Í7ÿ78%;6;<
<<<Ñ<à<ç<õ<û<	===8=>=H=g=n=¡=¦=Ç=õ=ú=`ÌÌ0ë01K1h1Ž182P2x22½2Ø2ø2þ23
333ž3£3­3²3½3È3Õ3Û3á3ï3õ344&4f4o4²4¸4ã4ì4,555y5­5Ô5î56%606F6Y6l66º6Í6Ü67717G7^7e7q7„7‰7•7š7«788.8@8£8µ8½8Ç8Ð8á8ó8$9_9j9|9‚9–9ö93:@:¦:Æ:ë:e;±;Å;á;X<“<Ý< =pXI00µ0À0Ê0Ù0á0é0î1ù12	22)2t2•2!3A4„4²4è4‘5/7V8‰8Í8:Œ;’;¤;¯;<6<õÚ?€ 52m2À2È23›3§3¯3·3À3ì3õ3û3
4'4x45/5Î5ï5H6S6¢6º6
7£7º7k88Å8×8
999+9M9`9“9¢9§9¸9¾9É9Ñ9Ü9â9í9ó9:>:C:c:h:õ:;!;0;M;o;(=D>×>õ>ý>??? ?¦?Ä?Ì?Õ?Û?è?ï?001#1S1à1õ1#2a2y7Y8ê8	9š9¹9p:…:<;7<‚> €b0Ž1P4[4n4x4–4¡4ü45{5“5Ã5ë5676]67•7©7Æ78`89;9^9k9v9Ð9:9:D:O:•:Ô:ã:!;4;j;v;Ž;Ä>?)?X?o?ž?»?Ï?ñ?û?°|90U00÷0*1ð192x2ƒ2±2Ç2!3^3h3ƒ3²3¾3È3Ò3Ø3á3ô3ÿ3
44=4C4U4“4™4p5‚5›566À9Ö9é9/:;';4;g;s;{;;Í;ê;õ;dÀ€:0e0„0£01t2§2Æ2å2v3û3¿6Ë6Ó6ç6ÿ677C7J7P7W7i7n7È7Þ7ñ7,8G8L8R8X8j8p88”8š8 8²8¸8Ã8È8Í8Ý8â8ç8÷8ü89999+90959E9J9O9_9d9i9y9~9ƒ9“9˜99­9²9·9Ç9Ì9Ñ9á9æ9ë9û9:::::/:4:9:I:N:S:c:h:m:}:‚:‡:—:œ:¡:±:¶:»:Ë:Ð:Õ:å:ê:ï:ÿ:;	;;;#;3;8;=;M;R;W;g;l;q;;†;‹;›; ;¥;µ;º;¿;Ï;Ô;Ù;é;î;ó;4<<U>r>}>‚>‡>«>Þ>é>î>ó>??4???D?I?d?n?Š?•?š?Ÿ?º?Ä?à?ë?ð?õ?ÐD0090D0I0N0{0Ÿ0»0Æ0Ë0Ð0è0
1111C1O1m1x1}1‚1¦1»1×1â1ç1ì122-282=2B2l222¨2­2²2Ð2â2333373[3f3k3p3‘3¡3½3È3Í3Ò3í34 4+40454Y4Š4•4š4Ÿ4Ò4ö455"5'5E5n55´5Ù5ý5"6F6Q6V6[6v6˜6£6¨6­6Å6á6ì6ñ6ö6787C7H7M7h7»7Æ7Ë7Ð7é7ö7û78848?8L8b8m8r8w8‘8–8›8·8Û899&9+909R9`9o9“9¥9±9¿9à9ç9ý9: :%:3:n;;’;F<=O==š=Õ=>>T>w>Ñ>á>ì?àX1­5Õ6Š8£8Ð8×8â8ð8÷8ý899v9‚9–9«9ë9ö9::":*:ã:E;­;¿;Ó;à;'<5<=r>.?¢?´?á?40501"1¬2Þ24|4«45¾6Â6Æ6Ê6Î6Ò6Ö6Ú6$8O:³:î;<Þ<=„> > Lþ3É6777.757M7T7r7|9¬9Þ9-:Á: ;
<<<=<^<¹<Ä<Ó<á<ð<6=H=N=>A>·>€?0|[0Ë0Ð0×0û01„1£1­1Á1Ý1ü1,2¸2×2373B3R3É34454?4^4|4ë45=5[5Ù56+6G6Ð6þ6/7K7~7›7½7<8˜889§9±9ÿ9ã<ê<µ=¼=B>‚>¤>À>Ì>ô>@À+070F0Q0U0]0c0i0o0–0Â0î0g1“1ï2ö24-4Ã6Ë6×6ä6ì6ô6ü67
777*727D7O7W7_7g7p7y777—7þ78W8b8Ö8Þ89%9I9R9w9|9‚99—9®9¶9Ä9×9Ý9ã9:«:;;’<<¤<ª<¹<À<Ê<Ô<å<ì<="=G=O=¥=°=½=Æ=Û=|>†>›>«>Í>?Å?PX00N1U1|1202V2æ2“3™364D4Ÿ4æ466A7q7{7Ä7ü7/8,969¢9¬9F:T:¥:³:; ;<ê=÷=!>+>µ>æ>`ˆ0!0a0p0~0›0£0Ì0Ó0ê01:1A1ƒ1Š1“1½1Ð1Ú1û192F2u22³2É233[3o3 3Î3Ø3G4R4^4š4´4)536´6"8)8€8‡88z:Œ:§:Ó:á:ò:;S;e;€;¬;º;Ë;Þ;)=;= ?p|$2É2ð2[3‚3¨3n4•4585w5¢5¹5Ð57`7f7-8@8Â9‚:‘:£:µ:Ñ:ï:ù:
;;$;W;^;e;l;†;•;Ÿ;¬;¶;Æ;°>Ñ>Ö>á>õ>??G?\?j?s? ?¦?€T070m0€01F1m1¸15¬5¿56:6`6‚6•6Õ6à6=8=9¢;¬;¶;4c>J?»? P0ÿ2Ó3	4‘4¤4Ú566v7À7C8L8o8ç8ð8\9e9°9ú9K:;R>û>P?X?¢?¬?°¨0[0j0²0Ñ0œ1£1ª1´1½1É1í1!2L2n2“2¥2°2Æ2Ù2à2ò2;3M3i33¨3³3ß3ú344=4O4W4u4€4Ü4ò4595A5W5u5‰55˜5ž5ð5)60676>6|6ñ6þ67787ÿ7|8…88¯8Ü8
9@9°9¸9Ê9Ï9ý9H:R:X:b:r:’:Ì=ÀË2ÿ4µ7H8Ð81c13‘35`59{9…9ý:;$;”;Ç;‘
l> >¶>?N?k??àT090Y0ƒ0Q1š1¤1Î1õ1ÿ1$2J2z2„223C3l3€3©3v5Ä5C67+77œ7Ï7ä7õ7«8À8Õ89,9j9f;U?©?ð /0)1}2::S:Z:„=y>>¸>¿>Ä1X6Ä6—>Ÿ>Ö>Ý>02ü23;3B3G6‹9’9™9 9h;p;==}>w?†?¥?¼? L“3Ø3´44536'717¨7²7E8a8Ÿ8»8ß8÷89^9Ì;‹<Ê>Ê>Ð>Ø>þ>:?Y?r?}??¿?0D0f0x0Š0Ä0T1ø4
5"515D5\5k5Ì586~6°8)9:{:Œ:»:É:ã:`<=ˆ=>2>®>@Ì"0b0Í0ç0ô0$1H1S1`1r1º1Ó1W2l2u2~2œ2¢2§2­2¾2
3@3i3Š33¬3ù34	44474?4¡4­4Á4Í4Ù4ù4@5j5r55Ÿ5«5º5¾6ï617h7…7™7¤7ñ7y8à8•9	:&:6:J:S:›:œ;¬;½;Å;Õ;æ;L0>h>t>y>>Þ>{?Ü?P070¥0Ä0õ0J23é3ü3Œ4§4½4Ó4Û4A8g9x9§=á=Ô>`à0r2y2À3Ê3 5¦5¬5²5¸5¾5Ä5Ê5Ð5Ö5Ü5â5è5î5ô5ú5666666$6*60666<6B6H6N6T6Z6`6f6l6r6x6~6„6Š66–6œ6¢6¨6®6´6º6À6Æ6Ì6Ò6Ø6Þ6ä6ê6ð6ö6ü677777 7&7,72787>7D7J7P7V7\7b7h7n7t7z7€7†7Œ7’7˜7ö7û7
8+8?8E8‡9˜9<žô>?%?3?p(á011$1(1,101†1Ë1Ð1Ô1Ø1Ü1<4ê:€Hò<ö<ú<þ<==
======"=&=*=.=2=6=:=>=B=F=J=N=R=V=Z=^=b=f=j=n=£2 l’4–4š4ž4¢4¦4ª4®4²4¶4º4¾4Â4Æ4Ê4Î4Ò4Ö4Ú4Þ4â4æ4ê4î4ò4ö4ú4þ455
55T5g5…5“5A7x77„7ˆ7Œ77æ7+8084888<8° Ð2Ø2ä2è2ì2ð2ô2ø23333àÜ@3D3H3L3P3T3À4Ä4È4Ì4Ð4Ô4Ø4Ü4à4ä4è4ì4ð4ô4ø4ü455555555 5$5(5,5054585<5@5D5H5L5P5T5X5\5`5d5h5l5p5t5x5|5€5„5ˆ5Œ55”5˜5œ5 5¤5¨5¬5°5´5¸5¼5À5Ä5È5Ì5Ð5Ô5Ø5Ü5à5ä5è5ì5ð5ô5ø5ü566666666 6$6(6,6064686<6@6D6H6L6ð800000 0$0(0,0004080<0@0D0H0L0P0T0X0\0`0d0h0ˆ222P2X2\2`2d2h2l2p2t2x2|2€2„2ˆ2Œ22”2À3È3Ð3Ô3Ø3Ü3à3ä3è3ì3ô3ø3ü3444444$4(4,40444È4Ì4Ð4Ô4Ø4Ü4à4ä4è4ì4ð4ô4ø4ü4555555000000 0$0(0,0004080<0@0D0H0L0P0T0X0\0`0d0h0l0p0t0x0|0€0„0ˆ0Œ00”0˜0œ0 0¤0¨0¬0°0¼0À0Ä0È0Ì0Ð0Ô0Ø0Ü0à0ä0è0ì0ð0ô0ø0ü011111111 1$1(1,1014181<1@1D1H1L1P1T1X1\1`1d1h1:::::: :$:(:,:0:4:8:<:@:D:H:L:P:T:X:\:`:d:h:l:p:t:x:|:€:„:ˆ:Œ::”:˜:œ: :¤:¨:¬:°:´:ô=ø=ü=> ¼ 7¬7¸7Ä7Ð7Ü7è7ô7888$808<8H8T8`8l8x8„88œ8¨8´8À8Ì8Ø8ä8ð8ü899 9,989D9P9\9h9t9€9Œ9˜9¤9°9¼9È9Ô9à9ì9ø9:::(:4:@:L:X:d:p:|:ˆ:”: :°:¼:È:Ô:à:ì:ø:;;;(;4;@;L;X;d;p;|;ˆ;”; ;¬;¸;ô;ü;<<<<$<,<4<<>>>$>,>4><>D>L>T>\>d>l>t>|>„>Œ>”>œ>¤>¬>´>¼>Ä>Ì>Ô>Ü>ä>ì>ô>ü>????$?,?4?>>> >(>0>8>@>H>P>X>`>h>p>x>€>ˆ>>˜> >¨>°>¸>À>È>Ð>Ø>à>è>ð>ø>???? ?(?0?8?@?H?P?X?`?h?p?x?€?ˆ??˜? ?¨?°?¸?À?È?Ð?Ø?à?è?ð?ø?@0000 0(00080@0H0P0X0`0h0p0x0€0ˆ00˜0 0¨0°0¸0À0È0Ð0Ø0à0è0ð0ø01111 1(10181@1H1P1X1`1h1p1x1€1ˆ11˜1 1¨1°1¸1À1È1Ð1Ø1à1è1ð1ø12222 2(20282@2H2P2X2`2h2p2x2€2ˆ22˜2 2¨2°2¸2À2È2Ð2Ø2à2è2ð2ø23333 3(30383@3H3P3X3`3h3p3x3€3ˆ33˜3 3¨3°3¸3À3È3Ð3Ø3à3è3ð3ø34444 4(4Ê>Î>Ò>Ö>PHÌ8Ô8Ü8ä8ì8ô8ü89999$9,949<9D9L9T9\9d9l9t9|9„9Œ9”9œ9¤9¬9@:D:` ð<ô<ø<ü<=======xô9ø9: :$:4:8:@:X:h:l:|:€:„:Œ:¤:´:¸:È:Ì:Ð:Ø:ð:;;;;;$;<;L;P;`;d;h;p;ˆ;˜;œ;¬;°;´;¼;Ô;ä;è;ø;ü;<<”?˜?´?¸?Ø?ø? Ì080X0x0˜0¸0Ø0ø0181X1x1˜1¸1Ø1ø1282X2x2˜2 2¤2À2à2ì23(3H3h3ˆ3¨3È3ä3è34(4H4h4ˆ4¨4È4è45(5H5h5ˆ5”5°5Ð5ð5606P6p66°6Ð6ð6707P7p77°7Ð7ð7808P8p88°8Ð8ð8909P9p99°9Ð9Ü9ø9:8:X:x:”:˜:¸:Ø:ø:;4;8;À´ø0@2p2€22 2°2È2Ô2Ø2Ü2ø2ü2333”3Ð8à8ä8è8ì8ð8ô8ø8ü8999999 9$9(9,909€9„9ˆ9Œ99”9˜9œ9 9¤9´9¼9Ä9Ì9Ô9Ü9ä9ì9ô9ü9p:t:€:„::”: :¤:°:´:À:Ä:Ð:Ô:Ø:Ü:à:ä:è:ì:ð:ô:;;0;H;d;„;œ;././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-6.0.exe0000644000175100001710000017000000000000000024113 0ustar00runnerdockerMZÿÿ¸@º´	Í!¸LÍ!This program cannot be run in DOS mode.

$ÂAÅ£/\Å£/\Å£/\¾¿#\£/\ª¼%\Σ/\F¿!\Ç£/\ª¼+\Ç£/\Å£/\£/\Å£.\W£/\§¼<\È£/\À¯p\ã/\K´p\Ä£/\ó…%\Ä£/\¥)\Ä£/\RichÅ£/\PELÙ@Hà`ßlp@ŒŸ´àXph.textp^` `.rdataJ;p@p@@.data`*° °@À.rsrcXà Ð@@V‹t$…ö„ƒU‹l$W‹|$S€>tpj\Vÿ\q@‹ð…öYYt_WÆÿ¬p@‹Øƒûÿu'jWÿ¼p@…Àu…ítWhhr@jÿÕƒÄëWjÿÕYYöÃuh·ÿ´p@…ít
Whhr@jÿÕƒÄÆ\Fu‹[_]3À@^ÃU‹ìƒìSVW‹=Èp@3ö»À9uuÇEVh€ÿuVVSÿuÿ׃øÿ‰Eü…‡ÿÌp@ƒøuÿu ÿuÿuèÿÿÿƒÄ…Àu·éûƒøPt	Pÿ´p@ë/9u „äÿujÿU …ÀYYt.Vh€jVVSÿuÿ׃øÿ‰Eüu%9u „µÿuh¬r@é ÿujÿU YYé™9u t
ÿujÿU YYEôPÿuÿuÿÐp@‹}üEôPPPWÿÔp@9uu	WÿØp@ë\VÿuVjVWÿÜp@W‹=Øp@‹Øÿ׃ûÿu9u t8ÿuh”r@ë&VVVjSÿ¸p@S‰Eÿ׋E;Æu9u tÿuh€r@jÿU ƒÄ3À_^[ÉÃU‹ìƒì8ƒ}S‹]VW…•j8EÈjPèpZ‹E‰EÈ‹E@‰EÌ‹Ej8hs@‰EØEÈjñ3öP‰]ÔFè÷2‹}ƒÄ…Àt…ÿt*Phèr@ëEÈjPèÆ4;ÆYYt…ÿt
PhÔr@jÿ׃Ä3öEÈPèÔJ…ÀYt,…ÿt
Ph¼r@jÿ׃Ä3öë3ö9uuÿuÿuSèÏYƒÄFSÿÄp@_‹Æ^[ÉÃU‹ìì(‹ES‹]Lê+A‹Q+ƒè9PKW‹ø‰Mä‰}ì:t3Àëƒeüfƒy
V3À@^_[ÉËEà‹}ì4‹N*ùû>PK…E?PK…9¿VƒÀ.ÿu‰Mð¿N Ê¿VпGF*Ñ¿OÈMì‰UàD‰EÜ…ØþÿÿPèY…ØþÿÿH‰Eø…ØþÿÿPèY‹MøƒÄ€<\t…Øþÿÿhs@PèßXYY…ØþÿÿPÿÀp@ƒe„Øþÿÿ‰Eè‹Eƒ8t;‰Eô‹Eôÿ0è³XPÿuð‹Eôÿ0ÿPq@ƒÄ…À‹E„ÚÿE‹Mȃ8‰EôuÈ¿GPÿuð…ØþÿÿPÿhq@ƒÄ…ØþÿÿŠ„Ét€ù/uÆ\@uï…ØþÿÿPèJXY‹Mø€<\tNÿu3Àf‹FP3Àf‹FPÿv…ØþÿÿÿuèPjèüÿÿƒÄ…Àt"ÿu¿OÿvÿvQÿuÜPè^ýÿÿƒÄ…À„σ}t‹Eü@P‹Eä¿@
PÿuèjÿUƒÄ‹Eä¿@
ÿEü9EüŒ=þÿÿé0þÿÿ‹MÈÿ3è¯Wÿs‰E…ØþÿÿPè—W‹E¿_‹MðÈ+Ø…ØþÿÿP‰Mè€W‹MøƒÄ€<\t)…ØþÿÿPèhWY‹Mø€</t…Øþÿÿhs@PèGWYY‹EŠ€ù\t€ù/u@KSP…ØþÿÿPÿhq@‹]é³þÿÿ3Àé“ýÿÿU‹ìEPh³@ÿuÿÙ@ƒÄ…Àu]ÃÿujèmhDÄ@ÿÙ@ƒÄ]ÃU‹ìEPh³@ÿuÿÙ@ƒÄ…Àu]Ãÿujè5hDÄ@ÿÙ@ƒÄ]ÃU‹ììƒ=4Ä@VWu hh³@ÿ¤p@…Àt3hP³@Pÿ¨p@£4Ä@EüPh³@ÿuÿÙ@ƒÄ…ÀtYƒ=4Ä@uh8³@ÿ5,Ú@ÿ×@YYë;3ÿ¾|°@ÿuüÿ6ÿh\·@WUÿÖhH·@hìÿ5Ù@ÿÖSèR…ÀY‰D$tjPèYYÿt$ÿ`p@ƒ=4Ú@tBƒ=˜Ø@t9h,·@WUÿÖhH·@hìÿ5Ù@ÿÖSè‹ðY…ötjVèAYYVÿ`p@3À_^][Ä¡8Ä@…ÀtPÿ”q@Yÿt$ÿ@q@ƒ%4Ú@Y£8Ä@ÃU‹ìƒìSV‹5¨p@W‹}hظ@WÿÖhĸ@W‹ØÿÖh¸¸@W‰EÿÖh¤¸@W‰EøÿÖh”¸@W‰EüÿÖh„¸@W‰EôÿÖ3ö95<Ä@u3ÀëJ;ÞtC9ut>9uøt99uüt49uôt/;Æt+3É9uh`Ä@•Á‰ÿUÿÓÿuÿuüèƒÄ‹ðÿUø‹ÆëƒÈÿ_^[ÉÃìP¡<Ä@SUV3öW‰t$3É;Æt‹@Aëö·ÁÁà‹=$r@PV»ëhSÿ5Ù@ÿ×V½VUSÿ5Ù@ÿ׉t$‹5<Ä@…ö„‘‹„$h÷ØÀƒàƒÀc‰D$ÿ6ÿD$D$ hð¸@Pÿ,r@D$(Pÿ”$tƒÄ…ÀtÿD$ÿt$D$ ÿ6hè¸@Pÿ,r@D$,Pjè¦ñÿÿƒÄjÿt$USÿ5Ù@ÿ×ÿ6hìÿ5Ù@ÿ0r@‹v…öu„‹D$_^][ÄPÃU‹ììhV‹5,r@Wh Ù@…˜ýÿÿhP¹@PÇEüÿÖ…˜ýÿÿPÿœq@‹=¤p@ƒÄÿuÿ×…À…„ÿ5Ø@E¬ÿ5$Ú@h ¹@PÿÖƒÄEü‹5p@P…¨þÿÿPE¬Ph€ÿÖ…ÀtEüP…¨þÿÿPE¬Ph€ÿÖ…Àt3Àë,…¨þÿÿhȵ@Pè4Dÿu…¨þÿÿPè%DƒÄ…¨þÿÿPÿ×_^ÉÃU‹ììŒSV3ÛWSSÿDq@‹
Àq@‹5¼q@ƒÁ@¿Ô¹@QWP‰EüÿÖ¡Àq@ƒÀ PWÿuüÿÖh ×@èßþÿÿ‹ðƒÄ$;óu0ÿÌp@P…tÿÿÿh¤¹@Pÿ,r@…tÿÿÿPèÖüÿÿƒÄƒÈÿéÿuVèþY‰EôYVÿ`p@¡Àq@‹=¸q@ƒÀ@PÿסÀq@‹5´q@ƒÀ@PÿÖ¡Àq@ƒÀ PÿסÀq@ƒÀ PÿÖƒÄ9]ô„œht¹@è4CÇ$p¹@ÿuü‹øÿ°q@jS‹¬q@P‰EÿÓÿuÿ¨q@jjÿu‰EøÿÓ‹EøD8Pÿˆq@‹ØƒÄ(…Ût:ht¹@SèâBÿu;ÿuøjPÿ¤q@ÿuÀ$8ÿÖSèíûÿÿSÿ”q@ƒÄ$ëh`¹@è×ûÿÿYÿuüÿ q@‹EôY_^[ÉÃU‹ìQQSV‹5¨p@W‹}hظ@WÿÖhĸ@W‹ØÿÖh¸¸@W‰EÿÖh¤¸@W‰EøÿÖhع@W‰EüÿÖ‹ð3À;Øt;9Et69Eøt19Eüt,;ðt(h`Ä@ÿUÿÓWè ÿuÿUü‹øƒÄ…ÿtÿÖÿUø‹ÇëƒÈÿ_^[ÉÃU‹ìƒìSV‹5¨p@W‹}hŒº@WÿÖhtº@W‹ØÿÖh\º@W‰EøÿÖhLº@W‰EÿÖh<º@W‰EüÿÖh(º@W‰EôÿÖhº@W‰EðÿÖhº@W‰EìÿÖ3ö‰Eè;Þ„›9u„’9uø„‰9uü„€9uôt{9uðtv9uìtqhø¹@ÿÓ‹øY;þt?hì¹@WÿUhä¹@W£”Ø@ÿUƒÄ£,Ú@¾È°@jVÿUüPÿ6WÿUøƒÆƒÄþ(±@rå‹Eô£Ù@‹Eð£Ù@‹Eì£×@‹Eè£PÚ@3ÀëjX_^[ÉÃU‹ìƒìV‹5r@W3ÿjWWEäWPÿÖ…ÀtEäPÿr@EäPÿr@jWWEäWPëÛ_^ÉÃU‹ìì¡°@ÇEül¼@=€tÇEüX¼@VW3ÿMôWQWjWW¾\±@WVPÿp@;Çt5ƒøujWhü»@ÿLr@PÿPr@3ÀéŸWhè»@VÿLr@PÿPr@¾@Ø@‹=Ôq@SVÿu…äþÿÿhÔ»@Pÿ×…äþÿÿhÔ¹@Pÿ°q@£$Ø@EðPÿÐq@‹Ìq@EðPÿÓEðPÿÓPh¤»@…äþÿÿhPÿÈq@‹€q@…äþÿÿPÿ5$Ø@ÿÓh`Ä@h˜»@ÿ5$Ø@ÿÓƒÄHÿuüh„»@ÿ5$Ø@ÿÓÿ5Ø@…äýÿÿÿ5$Ú@Vhx»@Pÿ×ƒÄ EìPEøP3ÀPhPPP…äýÿÿPÿuôÿp@…Àtj…äýÿÿh`»@PÿLr@PÿPr@ÿuôÿp@ƒ}ìu…äýÿÿPh\±@hH»@ÿ5$Ø@ÿÓƒÄh€Å@…äþÿÿÿ5Ø@ÿ5$Ú@h8»@Pÿ×…äþÿÿPèØ>ƒÄ@P…äþÿÿPjjh,»@ÿuøÿp@…Àtj…äþÿÿh»@PÿLr@PÿPr@…äþÿÿP…äýÿÿh,»@Ph\±@hôº@ÿ5$Ø@ÿÓV…äþÿÿÿuhäº@Pÿ×…äþÿÿhàº@Pÿ°q@Pjÿ5üØ@‰Eüÿ5dÅ@ÿÄq@ƒÄ@ÿuüÿ´q@V…äþÿÿÿuVÿuh´º@Pÿ×…äþÿÿPè>ƒÄ @¾¤º@P…äþÿÿPjjVÿuøÿp@…Àtj…äþÿÿh»@PÿLr@PÿPr@…äþÿÿP…äýÿÿVPh\±@hôº@ÿ5$Ø@ÿÓƒÄjX[_^ÉÃU‹ì¸è«=ƒ}NV„©}„K}…´W3ÿ9=4Ú@„)¾àÅ@‹Æ…À„€=àÅ@„
S‹0r@hp½@hèÿu‰}ðÇEôd½@‰}øÿÓ…ìþÿÿh Ù@Pè=…ìþÿÿhX½@Pèú<…ìþÿÿVPèí<¡$Ø@ƒÄ;ÇtìþÿÿQh ×@h@½@Pÿ€q@ƒÄWWÿDq@‹
Àq@‹5¼q@ƒÁ@¿Ô¹@QWP‰EÿփąÀuPPh0½@ÿLr@PÿPr@¡Àq@ƒÀ PWÿuÿÖƒÄ…ÀuPPh ½@ÿLr@PÿPr@hjÿüq@Pÿr@‰Eü…ìþÿÿh ×@‰EðèH÷ÿÿ‹ðY…öt{V4thàÂ@Rè‚ÖÿÿYYéÚ;ŒЋN;Êt
‹Ö+V+щ0Ú@+F‹M‹þh+F‰+~ÿˆq@‹ØY…Û„–…üþÿÿPhÿ p@…ÀtmSj…üþÿÿhÜÂ@Pÿœp@…ÀtT3ÀPPPÿvPSjèÌÿÿƒÄ‰E…ÀtLÿvWPÿq@ÿuè(|Wÿ@q@‹MƒÄÿu‰‹E‰ÿÄp@jXëh¼Â@ÿÌp@Pè¥ÕÿÿYY3À_^[ÉÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$3É;ÑtM‹B;ÁtF‰H‰J‰J‰JÇB0‰‰H‰H‰H ‰H(‰H,‰H0‰H8‰H<ˆ0Ç@€‰Hl‰HP‰HL3ÀøþÿÿÿÃÌÌÌ‹D$W3ÿ;Ç„±€81…¨ƒ|$8…V‹t$;÷„ˆ9~ ‰~u
ÇF °]@‰~(9~$uÇF$Ð]@‹F(h0%jPÿV ƒÄ;Çu^¸üÿÿÿ_ËL$;ωF}‰x÷Ùë‹ÑÁúBƒù0‰P}ƒáƒù|ƒùV‰H$‰x4èüþÿÿƒÄ^_ÃP‹F(PÿV$ƒÄ‰~^¸þÿÿÿ_øúÿÿÿ_ÃÌÌÌÌÌÌÌÌÌSU‹l$‹]VW‹ð‹C43ÿ;Çu(‹K$¸Óà‹M(jPQÿU ƒÄ;ljC4u
_^]¸[Ã9{(u‹K$ºÓâ‰{0‰{,‰S(‹}‹K(+÷‹Æ;Ár*‹u‹{4+ñ‹ÁÁéó¥‹Èƒáó¤‹K(_^]ÇC0‰K,3À[Ã+K0;ȉL$v‹È‰L$‹S0‹{4‹uú‹ÑÁé+ðó¥‹Êƒáó¤‹L$+Át(‹u‹{4‹È‹Ñ+ðÁéó¥‹Êƒáó¤_‰C0‹C(^‰C,]3À[Ë{0‹C(ù‹×;Љ{0uÇC0‹S,;ÐsщS,_^]3À[ÃÌÌÌÌÌÌÌÌÌÌÌ‹D$ƒì8…ÀS„‡‹X…Û„|‹H…É„qƒ8u‹H…É…aƒ;uÇ‹H‹PU‹k3íUUUèR$‰CjD$4ÆD$4ÆD$5‹‹KPQè5$‰CƒÄ‰l$Ç‹Åéü‹C …ÀÇCtÇ@0ÿÿÿÿöC„¬‹L$‹Á%ÿÁàÁéÁ3Ò¹÷ñ…Ò…ˆ‹L$‹Ñ€â€út‹D$LÇ@\}@‹Áé“‹C$Áé‰L$ƒáƒÁƒí;Èv‹L$L‹D$ÇAH}@éh3íºÓâUUU‰SèL‹T$‹L$XÁê÷ÒƒâƒÄ‰C‰A0ƒÊ	‰‰l$‹Åé1‹D$LÇ@0}@‹D$éƒýs'…ÿ„n¶‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ<‰Ct‹L$LÇA\}@éÔöÄàt‹T$LÇB}@é¿‹K …ÉtÁèƒà‰‹CöÄt%‹D$ˆD$$ÁèˆD$%‹KjD$(PQè±"ƒÄ‰C3À3íÇëƒý s…ÿ„ζ‹ÍÓâOƒÅÂFƒý ‰D$rá‹K …Ét‰A‹CöÄt7‹D$ˆD$$‹È‹ÐÁèÁéˆD$'ÁêjD$(ˆL$)ˆT$*‹KPQè8"ƒÄ‰C3À3íÇëƒýs(…ÿ„T¶‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ‹K …Ét‹Ðâÿ‰Q‹K Áè‰A‹CöÄt%‹D$ˆD$$ÁèjT$(ˆD$)‹CRPè·!ƒÄ‰C3À‰D$3íÇ‹KöÅtvƒýs-›…ÿ„Ķ‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ‹K …ɉC@t‰A‹CöÄt%‹D$ˆD$$ÁèˆD$%‹KjD$(PQè5!ƒÄ‰C3À‰D$3íë‹K …ÉtÇAÇ‹KöÅ„¬‹K@;ωL$v‹Ï‰L$…É„ˆ‹S …ÒtH‹R…Ò‰T$8t=‹S ‹z‹s@‹R+þ49;òv+׋ʋT$8‹t$ú‹ÑÁéó¥‹Êƒáó¤‹L$‹|$‹t$‹SöÆt‹D$‹KPVQè† ‹L$(‰C‹D$ƒÄ‹S@+ùñ+щ|$‰t$‰S@‹K@…É…•ÇC@Ç‹KöÅ„ …ÿ„t3É›¶1A‰L$‹K …ɉT$,t-‹Q…Ò‰T$8t"‹S@;Q s‹L$8‹|$‰D$8ŠD$,ˆÿC@‹D$8‹L$,…Ét‹L$;Ïr¯‹KöÅt‹T$‹CRVPèȉC‹D$ƒÄ‹L$+ùñ‹L$,…ɉ|$‰t$…Þë‹K …ÉtÇAÇC@Ç‹KöÅ„š…ÿ„­3ɶ1A‰L$‹K …ɉT$,t-‹Q$…Ò‰T$8t"‹S@;Q(s‹L$8‹|$‰D$8ŠD$,ˆÿC@‹D$8‹L$,…Ét‹L$;Ïr¯‹KöÅt‹T$‹CRVPè‰C‹D$ƒÄ‹L$+ùñ‹L$,…ɉ|$‰t$…ë‹K …ÉtÇA$Ç‹KöÅtOƒýs'…ÿ„ò
¶‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ‹Káÿÿ;Át‹T$LÇB}@éR
3í‰l$‹C …Àt‹KÁù	ƒá‰H,‹S ÇB0jjjèL‹L$X‰C‰A0‹D$ƒÄÇé
ƒý s'…ÿ„_
¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rÙ‹È‹ÐáÿÁâÊ3ÒŠt$ÁáÁèÊÁ‹L$L‰C‰A03À‰D$3íÇ
‹K…É„¸jjj臋T$X‰C‰B0‹D$ƒÄǃ|$P„Ñ‹K…Ét‹ÍƒáÓè+éljD$éTƒýs$…ÿ„¤¶‹ÍÓâOƒÅ‰|$ÂFƒý‰t$r݋ȃáÑè‰K‹ÈƒáMƒùwsÿ$H]@ÁèÇ
‰D$ƒíéúÁèÇCLs@ÇCT	ÇCP{@ÇCXljD$ƒíéÉÁèljD$ƒíé´‹T$LÇBì|@ÇÁè‰D$ƒí锋̓áÓè+éƒý ‰D$s+d$…ÿ„Ô¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rًЋÈ÷ÒáÿÿÁê;Êt‹L$LÇAÌ|@é.3À‰K@‰D$3íÇ‹K@…ɉL$„¢;Ïv‹Ï‰L$‹T$ ;Êv‹Ê‰L$…É„R‹t$‹|$(‹ÑÁéó¥‹Ê‹T$ƒáó¤‹L$‹t$‹|$ +ñ‰t$‹t$(щT$‹S@+ùñ+щ|$ ‹|$‰t$(‹t$‰S@é
ƒýs#…ÿ„î
¶‹ÍÓâOƒÅ‰|$ÂFƒý‰t$r݋ȃáÁÁè‹Ð‰K`Áè‹ÈƒáƒÁƒâ‰K\‹K`BÁèƒíù‰Sd‰D$‡ý‹Êƒù‡òÇChÇ‹Kh;K\s[›ƒýs#…ÿ„_
¶‹ÍÓâOƒÅ‰|$ÂFƒý‰t$rÝ‹Sh·U{@3ÉŠÈÁèƒí‰D$ƒáf‰LSp‹KhA‰Kh;K\r«‹Kh¸;Ès*3Éë¤$d$‹Sh·U{@f‰LSp‹ShB;ЉShråƒ0Kl‰‰CL“ðRCTPQÇjCpPjèXƒÄ‰D$4…À‹D$t ‹L$LÇA°|@é1	‹T$LÇBŒ|@é!	ÇChÇ‹K`‹SdÑ9Shƒ‹KTºÓâ‹KLJ#Ћ‘¶Õ;Õ‰L$@v<…ÿ„A	¶‹ÍÓâ‹KTOƒÅºÓâ‹KLF‰|$J#Ћ‘¶Õ;Õ‰t$‰L$@wÄ‹T$@ÁêfƒúsR¶Í;é‰L$s&…ÿ„í¶‹ÍÓâ‹L$OƒÅÂF;é‰|$‰t$rÚf‹T$BÓè+é‹Khf‰TKp‹KhA‰D$‰KhéHuh¶ÍQ;ê‰L$s+‹ÿ…ÿ„”¶‹ÍÓâ‹L$OƒÅÂFQ;ê‰|$‰t$r×Óè+é‹Kh…ɉD$„b·LKn‰L$,‹ÈƒáƒÁÁèƒíé§fƒú¶Õ‰T$uJJ;és-d$…ÿ„$¶‹ÍÓâOƒÅ‰|$‹T$FJ;é‰t$r׋ÊÓè¿ýÿÿÿ‹ÈƒáƒÁÁèëDJ;és)…ÿ„Þ¶‹ÍÓâOƒÅ‰|$‹T$FJ;é‰t$r׋ÊÓè¿ùÿÿÿ‹ÈƒáƒÁÁè+úÇD$,ï‹{d‹Sh{`Ñ;׉D$‡˜…Ét‹T$,‹ÿ‹{hf‰T{p‹{hGI‰{huî‹|$‹S`‹KdÊ9Kh‚îýÿÿƒ;„îƒ0Kl‰‰CL“ðR‹S`CTPQÇ	RCpPjèÁ
ƒÄ…À‰D$4t8‹L$L‹D$ÇAp|@éš‹T$LÇBT|@銋L$L‹|$ÇAT|@év‹SlKl‰SP“ðRCXPQ‹K`Ç‹CdPTKpRjèP
ƒÄ…À‰D$4t‹D$LÇ@<|@‹D$é)‹D$ǃÿrg|$ r]‹D$L‹T$ ‹L$(‰P‹T$0‰H‹L$R‰0‰xP‰K8‰k<è|‹D$T‹H‹P‹0‹x‹C8‹k<ƒÄ‰L$(‰T$ ‰t$‰|$‰D$鹋KTºÓâ‹KLJ#Ћ‘¶Î;͉T$@v<…ÿ„ñ¶‹ÍÓâ‹KTOƒÅºÓâ‹KLF‰|$J#Ћ‘¶Î;͉t$‰T$@wÄ„Ò„¹öÂð…°¶Î‰L$3ɊʉT$,L$ºÓâ‹L$J#ÐÓê‹L$@ÁéÑ‹KL‹‘‹L$,Áé‰T$@¶É¶ÖÑ;Õ‰L$v[I…ÿ„T¶‹ÍÓâ3ÉŠL$,O‹T$FƒÅ‰|$ʺÓâ‹L$‰t$J#ÐÓê·L$.Ñ‹KL‹‘¶Õ‰L$@‹L$Ñ;Õw¨‹T$@Óè+é¶ÎÓè¶Î+é‹L$@Áé„Ò‰D$‰K@uÇéwö tÇégöÂ@t‹T$LÇB |@éLƒâ‰SHÇ‹KH…ÉtE;és%…ÿ„‘¶‹ÍÓâ‹KHOƒÅÂF;é‰|$‰t$rÛ‹KHºÓâ‹K@J#ÐʉK@‹KHÓè+éÇ‹KXºÓâ‹KPJ#Ћ‘¶Î;͉T$@v<…ÿ„,¶‹ÍÓâ‹KXOƒÅºÓâ‹KPF‰|$J#Ћ‘¶Î;͉t$‰T$@wÄöÂð…³¶Î‰L$3ɊʉT$,L$ºÓâ‹L$J#ÐÓê‹L$@ÁéÑ‹KP‹‘‹L$,Áé‰T$@¶É¶ÖÑ;Õ‰L$v^›…ÿ„”¶‹ÍÓâ3ÉŠL$,O‹T$FƒÅ‰|$ʺÓâ‹L$‰t$J#ÐÓê·L$.Ñ‹KP‹‘¶Õ‰L$@‹L$Ñ;Õw¨‹T$@Óè+é¶ÎÓè¶Î+éöÂ@‰D$t‹L$LÇA|@鵋L$@Áéƒâ‰KD‰SHÇ‹KH…ÉtI;és%…ÿ„ð¶‹ÍÓâ‹KHOƒÅÂF;é‰|$‰t$rÛ‹KHºÓâ‹KDJ#ÐʉKD‹KHÓè+é‰D$‹T$ ‹K,+ÊL$09KDv‹T$LÇBè{@é-Ç‹L$ …É„‹T$0+Ñ‹KD;Êv<+Ê‹S0;ʉL$v+Ê‹S4S(‰L$+Ñë‹S4+ÑS0‹L$‰T$,‹S@;ʉT$8v‹Êë‹T$(+Ñ‹K@‰T$,‰L$8‰L$‹T$ ;Êv‹Ê‰L$+щT$ ‹T$8+щS@뛋L$,Š‹L$(ˆ‹T$,A‰L$(‹L$BI‰T$,‰L$uÛ‹K@…É…nÇéc…Ò„¹‹L$(ŠS@ˆA‰L$(ÿL$ Çé>‹K…É„Õƒý s'…ÿ„„¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rÙ‹L$0+L$ ‹T$LJ‹SхɉL$0‰St8‹C‹S‹L$(…À‹D$0Pt+ÈQRèîë	+ÈQRè³‹L$X‰C‰A0‹D$ƒÄ‹K‹T$ …ɉT$0‹Èu'áÿ‹ÐÁâÊ3ÒŠt$Áá‰L$8Ê‹ÐÁêʉL$8;Kt
‹L$LÇAÐ{@ë`3À‰D$3íÇ‹K…É„“‹K…É„ˆƒý s'…ÿ„“¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rÙ;CtS‹L$LÇA¸{@Ç‹ƒù†dìÿÿ_^]¸þÿÿÿ[ƒÄ8ËL$L‹T$(‰Q‹T$ ‰y_‰1‰Q^‰k<‰C8]¸[ƒÄ8Ã3À3íÇÇD$4ëÇD$4ýÿÿÿ‹L$L‹T$(‰Q‹T$ ‰Q‰1‰y‰C8‹C(…À‰k¨@…3¹‰L$@‹È‹D$@Óà‹L$ÁéH#ÇÁ‹L$$‹¶Ì‰D$¶ÀÓï+Ù¨t‹L$Áéƒà;؉L$s(¶jB‹ËÓåƒÃ‰T$ý;Øs¶jB‹ËÓå‰T$ýƒÃ¹‹é‹ÈÓå+ØM#ï‹Í‹l$é‹ÈÓï‹L$D‹Æ+Á;è‰l$†+è;l$H‡n‹L$,‹D$I…Àu*‹D$(+ÅÈ‹D$T;胑+ʼnD$Td$ŠAAFMˆuöës;ÅsS+ÅD$(È+l$‹D$T;èsc+ʼnD$T›ŠAAFMˆuö‹L$,‹D$‹l$TI;Ås<+è‰l$T‰D$@‹èŠAAFMˆuöë+ÅÈ‹D$T;ès+ʼnD$TŠAAFMˆuö‹D$‹Î+È‹D$Tƒøv7Pý¸«ªªª÷â‹êÑíEŠAAFˆŠQAFˆ‹T$TŠAAFƒêMˆ‰T$TuÝ‹T$‹D$T…Àt^ŠAAFˆƒ|$TvPŠIFˆëH‹Æ+Ť$ŠH@FˆŠH@FˆŠH@Fˆ‹L$Tƒéƒù‰L$TwÛ…ÉtŠH@Fˆƒ|$TvŠ@Fˆ‹l$;T$0sQ;t$4‚ÁüÿÿëE‹L$P‹D$ÇAè{@Ç‹èë,‹L$PÇA|@ë¨ t	ÇEë‹D$PÇ@ |@ÇE‹ÃÁèÅ+Ð+ً˸Óà‹L$PH#øB‰F‰A‹D$0+ƒÀ‰A‹D$4+ƉA‰}8_^‰]<][ƒÄ<ÃÌÌÌÌ̃ì|‹”$ˆ3À…Ò‰D$<‰D$@‰D$D‰D$H‰D$LS‰D$TU‹¬$Œ‰D$\V‰D$dv›·LEfÿDLHLLH@;Ârí‹´$œ‹»‰D$‰\$¤$fƒ|\HuKƒûsò;É\$v‰\$…Ûu9‹„$˜‹f‰\$ÆD$@ÆD$
‹L$‰
‹ƒÂ‰‰
ƒÇ^]3À[ƒÄ|þd$fƒ|tHu:fƒ|tJu"fƒ|tLufƒ|tNufƒ|tPuƒÆƒþvÐëFë
ƒÆëƒÆëƒÆ9t$s‰t$º‹Â·LDHÒ+Ñx&@ƒøvï…ÒW‹¼$~…ÿtƒût_^]ƒÈÿ[ƒÄ|Ã^]ƒÈÿ[ƒÄ|ÃfÇD$n¸›f‹TlfTLf‹LNfÊf‰Tnf‰LpƒÀƒørÜ‹œ$˜3À…Ûv0fƒ|Et#·TE·LTl‹”$¤f‰J·TEfÿDTlTTl@;ÃrЋǃèºÿÿÿÿt;HtÇD$4Ð~@ÇD$0@‰T$,ë9¸P~@-‰D$4¸~@-ÇD$,ë‹„$¤‰D$4ÇD$,‰D$0‹„$œ‹‰L$ ‹L$¸Óà‰T$83í3ÛƒÿPÿ‰t$‰D$<‰D$(‰T$@u=°ƒk‹„$¤‰D$$IŠL$‹t$$f‹‹T$,*ˈL$·È;Ê}ÆD$f‰D$ë-~·‹T$0ÑàŠ‹T$4f‹ˆL$f‰D$ëÆD$`fÇD$‹L$‹D$<+˺Óâ‹Ë‹ýÓï‹L$ ‰D$D4•ø¹‹|$+Â+Î…À‰9uö‹T$Jÿ¸Óà…ÅtÑè…Åuú…ÀtHÿ#ÍÈ‹éë3í‹t$$ƒÆfÿLTLfƒ|TL‰t$$u;T$„à‹Œ$”‹Ö··A‰T$;T$†	ÿÿÿ‹t$@‹D$8#õ;ð‰t$H„óþÿÿ…Ûu‹\$‹D$ ‹L$D‹|$ˆ‹L$+ˉT$ ¸Óà;×s tTL·>+Ç…À~‹|$ABƒÆÑà;×rè‹t$H‹T$(¸ÓàЉD$<ƒ¼$‰T$(u
‹Â=°ƒÕ‹Ö‹´$œ‹ˆ‹ŠD$ˆD‘‹‹L$ +ÈÁù‰T$8f‰LéGþÿÿ‹¼$œŠÂ*Ã…íÆD$@ˆD$fÇD$t]‹t$ d$…Ût ‹L$@‹D$8#Í;Èt‹D$‹73Û‰D$ˆD$‹Ð‹Ë‹ÅÓè‹L$‰†Jÿ¸Óà…ÅtÑè…Åuú…ÀtHÿ#ÍÈ‹éu«‹T$(‹•‹T$ȉ‹Œ$ _^]‰3À[ƒÄ|Ã_^]¸[ƒÄ|ÃÌÌÌÌÌÌ‹L$S‹\$W‹ùÁïáÿÿƒûu1‹D$¶Êùñÿréñÿùÿñÿrïñÿ‹ÇÁà_Á[ÃV‹t$…öu	^_¸[Ãûs3…Ût¶ÈFùKuõùñÿréñÿ‹Ç3Ò¾ñÿ÷ö^_[‹ÂÁàÁÃû°‚ʸ¯©n^÷ãU‹êÁí‹ÿë°¸[ëI¶Ê¶VùʶVùʶVùʶVùʶVùʶVùʶVùʶVùʶV	ùʶV
ùʶVùʶVùʶV
ùʶVùʶVùÊùƒÆH…wÿÿÿ‹Á3Ò¹ñÿ÷ñ‹Ç¿ñÿ‹Ê3Ò÷÷M‹ú…Fÿÿÿ]…Û„Ãû‚‘‹ÃÁè¶Ê¶VùʶVùʶVùʶVùʶVùʶVùʶVùʶVùʶV	ùʶV
ùʶVùʶVùʶV
ùʶVùʶVùʃëùƒÆH…tÿÿÿ…Ût¶ÈFùKuõ‹Á3Ò¹ñÿ÷ñ‹Ç¾ñÿ‹Ê3Ò÷ö‹ú‹Ç^Áà_Á[ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌQSV‹ò…ö÷Ðt&ëIöÁt3ÒŠ3Ðâÿ‹•P@Áè3ÃANu߃þ UW‚‹þÁï3‹ÐÁê¶Ü‹,P‡@¶Ò‹•Pƒ@3Ջ؉D$Áë‹,P@‹Y3Õ%ÿ3…P‹@3Ó‹ÂÁè¶Þ‹,P‡@ƒÁ¶À‹…Pƒ@3Å‹Ú‰T$Áë‹,P@‹Y3Åâÿ3•P‹@3ÃÁ‹ÐÁê¶Ü‹,P‡@¶Ò‹•Pƒ@3Ջ؉D$Áë‹,P@‹Y3Õ%ÿ3…P‹@3ÓƒÁ‹ÂÁè¶Þ‹,P‡@¶À‹…Pƒ@‹Ú3ʼnT$Áë‹,P@‹Yâÿ3Å‹,•P‹@ƒÁ3Å3ËЃÁÁê¶Ò‹•Pƒ@‰D$¶Ü3P‡@‹ØÁë‹,P@‹3Õ%ÿ3…P‹@3Ó‹ÂÁè¶Þ‹,P‡@¶À‹…Pƒ@3Å‹ÚÁë‹,P@‹Y3ʼnT$âÿ3•P‹@3ÃÁ‹Ð¶Ü‹,P‡@Áê¶Ò‹•Pƒ@‹Ø3Õ‰D$Áë‹,P@‹Y%ÿ3Õ‹,…P‹@ƒÁ3Õ3Ó‹ÂÁè¶Þ‹,P‡@¶À‹…Pƒ@‹Ú3ÅÁë‹,P@‰T$âÿ‹•P‹@3ŃÁ3Ãî O…êýÿÿƒþrH‹ÖÁê3¶Ü‹,P‡@‰D$¶|$‹<½Pƒ@‹Ø3ýÁë‹,P@%ÿ3ý3<…P‹@ƒÁƒîJ‹Çu½…ö_]t"›3ÒŠ3Ðâÿ‹•P@Áè3ÃANuä^÷Ð[YÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹L$…Éu3ÀËT$‹D$éýÿÿÿ%`q@ÿ%dq@ÿ%lq@ÿ%pq@ÿ%tq@ÿ%xq@ÌÌÌÌQ=L$ré-…=sì+È‹Ä…‹á‹‹@PÃU‹ìjÿh€Ÿ@h`n@d¡Pd‰%ƒìhSVW‰eè3Û‰]üjÿ,q@Yƒ
TÚ@ÿƒ
XÚ@ÿÿ(q@‹
TÄ@‰ÿ$q@‹
PÄ@‰¡ q@‹£\Ú@è9 Ã@uh\n@ÿq@Yèãh°@h°@èΡLÄ@‰E”E”Pÿ5HÄ@EœPEPE Pÿq@h°@h°@蛃Ä$¡èp@‹0‰uŒ€>"u:F‰uŒŠ:Ãt<"uò€>"uF‰uŒŠ:Ãt< vò‰]ÐE¤Pÿ°p@öEÐt·EÔë€> vØF‰uŒëõj
XPVSSÿdp@PèAÔÿÿ‰E˜Pÿìp@‹Eì‹‹	‰MˆPQèYYËeèÿuˆÿôp@Ìÿ%ðp@ÿ%q@hhè
YYÃ3ÀÃÃÿ%0q@ÿ%8q@ÌÌÌ̺§B¨2¨ ¨¨ü§ì§Ø§È§è¢ú¢l§T§Š§œ§D§|§`§4§,¤8¤J¤X¤l¤|¤Š¤¢¤¾¤Î¤â¤ö¤¤¥0¥F¥Z¥h¥|¥¤ô£H£ðª$£^£4£è£Ö£È£¸£ £’£„£n£
¥TªLª>ª6ªªªªü©ò©ê©Ú©^ªnªzªŽªžª®ª¼ªÎªB«âª««$«0«:««Î©Ä©~¨ˆ¨’¨œ¨¦¨°¨º¨Ä¨Î¨Ø¨â¨ð¨ú¨©©©"©,©6©>©F©N©V©`©j©t©|©†©’©ž©¦©°©º©b¨§§ö¦æ¦Ø¦Ì¦¼¦¨¦”¦†¦v¦h¦`¦T¦>¦2¦&¦¦¦ò¥ä¥Ð¥Ä¥´¥¨¥š¥Î¢º¢¨¢CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

incorrect length checkincorrect data checkinvalid distance too far backinvalid distance codeinvalid literal/length codeinvalid distances setinvalid bit length repeatinvalid literal/lengths settoo many length or distance symbolsinvalid code lengths setinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method~@~@~@ø}@è}@Ü}@È}@¸}@ }@~@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionary inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScsƒ£ÃãÉÄ	
!1AaÁ 0@`@@–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”ÞñÀFîÀFÀFÿÿÿÿn@1n@˜¢Þ¢Xrh £(p˜ Œ¥Xp,¢(§ìqt °§4p@ T¨p$¢r¨äq(¡*ªèpº§B¨2¨ ¨¨ü§ì§Ø§È§è¢ú¢l§T§Š§œ§D§|§`§4§,¤8¤J¤X¤l¤|¤Š¤¢¤¾¤Î¤â¤ö¤¤¥0¥F¥Z¥h¥|¥¤ô£H£ðª$£^£4£è£Ö£È£¸£ £’£„£n£
¥TªLª>ª6ªªªªü©ò©ê©Ú©^ªnªzªŽªžª®ª¼ªÎªB«âª««$«0«:««Î©Ä©~¨ˆ¨’¨œ¨¦¨°¨º¨Ä¨Î¨Ø¨â¨ð¨ú¨©©©"©,©6©>©F©N©V©`©j©t©|©†©’©ž©¦©°©º©b¨§§ö¦æ¦Ø¦Ì¦¼¦¨¦”¦†¦v¦h¦`¦T¦>¦2¦&¦¦¦ò¥ä¥Ð¥Ä¥´¥¨¥š¥Î¢º¢¨¢SCoUninitialize
CoCreateInstance-CoInitializeole32.dllIPropertySheetACreatePropertySheetPageACOMCTL32.dllqSetLastError-CreateDirectoryA
GetFileAttributesAÖMapViewOfFile5CreateFileMappingACloseHandlelSetFileTime_DosDateTimeToFileTimeGetLastError4CreateFileA°UnmapViewOfFilelstrlenA>GetProcAddressÂLoadLibraryAäMultiByteToWideCharÌLocalFree¯FormatMessageA´FreeLibrary&GetModuleHandleAuGetVersionExAWDeleteFileA4GetPrivateProfileIntA:GetPrivateProfileStringA,ResumeThreadwSetPriorityClass÷GetCurrentProcessùGetCurrentThread‡SetThreadPriorityDCreateProcessA$GetModuleFileNameA'RemoveDirectoryAGetFileSizecGetTempFileNameAeGetTempPathAKERNEL32.dll¾MessageBoxAGetFocusSendMessageA»EndPaintFGetSystemMetricsBeginPaint„DefWindowProcAÞPostMessageA,SetDlgItemTextA¬wsprintfA5GetParentSendDlgItemMessageAReleaseDCýGetDCÉMoveWindow\GetWindowRectGetDlgItem•DispatchMessageA‚TranslateMessageÜPeekMessageA&SetCursoršLoadCursorA‘UpdateWindowjShowWindowYCreateWindowExAòRegisterClassAUSER32.dllSDeleteObjectóSetTextColorTextOutAÎSetBkModeÇSelectObject6CreateFontA0CreateDIBitmapMCreateSolidBrushGDI32.dll[RegCloseKeyrRegOpenKeyExA{RegQueryValueExAgRegEnumKeyExAzRegQueryValueA†RegSetValueExA_RegCreateKeyExAbRegDeleteKeyAdRegDeleteValueAADVAPI32.dllrShellExecuteASHELL32.dll·strchr—memcpy™memset¿strncat¶strcat¾strlenºstrcpy¸strcmpÃstrrchrXfprintfá_vsnprintf‘malloc®_snprintfÁstrncpy^freeµsscanf”_putenv¨remove]freaddftellbfseekWfopenLfcloseOfflush_freopen_iobffwrite½strftimelocaltimeÐtime²sprintfî_fstatÈstrtolŽ_pctype_isctypea__mb_cur_max¤qsort§reallocRfgetsÀstrncmpc__p___argvb__p___argcMSVCRT.dllÓ_exitH_XcptFilterIexit_acmdlnX__getmainargs_inittermƒ__setusermatherr_adjust_fdivj__p__commodeo__p__fmode__set_app_typeÊ_except_handler3·_controlfpPGetStartupInfoAÅ_strnicmp½_strcmpi¿_strdupÑ_tempnam³_close˜_read‡_openÿÿÿÿ³@DÄ@ü²@DÄ@ô²@DÄ@ì²@à²@ز@DÄ@³@IJ@ü²@IJ@ô²@DÄ@ì²@à²@ز@DÄ@¬²@œ²@Œ²@l²@T²@<²@,²@²@²@ø±@è±@Ý@б@î@À±@@°±@~@œ±@¶@±@·@Software\Microsoft\Windows\CurrentVersion\UninstallSoftware\Microsoft\Windows\CurrentVersion\Uninstallmessage_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBsno such folder (%s)unknown CSIDL (%s)function not availableSHGetSpecialFolderPathAshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissi100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Runtime ErrorTimes RomanThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Don't know Python's installation typeStrange\python%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Py_OptimizeFlagPySys_GetObjectPyRun_SimpleStringPy_FinalizePy_SetProgramNamePy_Initialize%s%cimport py_compile; py_compile.compile (r'%s')SOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOut of memory!rbRunning the pre-installation script failed
Can't load Python for pre-install script (%d)aPyErr_PrintOSErrorValueError__builtin__PyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleUninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINEPostinstall script finished.
Click the Finish button to exit the Setup wizard.*** Could not load Python ****** run_installscript: internal error 0x%X ***
freopen stdoutfreopen stderr300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...Installation failed.Running Script...Could not open postinstall-script %s
PySys_SetArgv*** Installation finished %Y/%m/%d %H:%M ***
IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasBad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup %sCould not register window classSetup.exeSetupWindowClassif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of argsSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archiveCould not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py) €8€nh€k€€l˜€m°€nÈ€à	ð			 0á
8ë ØìàîZ@ñ(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-7.1.exe0000644000175100001710000020000000000000000024107 0ustar00runnerdockerMZÿÿ¸@(º´	Í!¸LÍ!This program cannot be run in DOS mode.

$¿IoAÞ'tpj\Vÿd@‹ð…öYYt_WÆÿ˜€@‹Øƒûÿu'jWÿ”€@…Àu…ítWh€‚@jÿÕƒÄëWjÿÕYYöÃuh·ÿ¼€@…ít
Wh€‚@jÿÕƒÄÆ\Fu‹[_]3À@^ÃU‹ìƒìSVW‹=¸€@3ö»À9uuÇEVh€ÿuVVSÿuÿ׃øÿ‰Eü…‡ÿ´€@ƒøuÿu ÿuÿuèÿÿÿƒÄ…Àu·éûƒøPt	Pÿ¼€@ë/9u „äÿujÿU …ÀYYt.Vh€jVVSÿuÿ׃øÿ‰Eüu%9u „µÿuhÄ‚@é ÿujÿU YYé™9u t
ÿujÿU YYEôPÿuÿuÿ°€@‹}üEôPPPWÿ¨€@9uu	Wÿ¤€@ë\VÿuVjVWÿ €@W‹=¤€@‹Øÿ׃ûÿu9u t8ÿuh¬‚@ë&VVVjSÿœ€@S‰Eÿ׋E;Æu9u tÿuh˜‚@jÿU ƒÄ3À_^[ÉÃU‹ìƒì8ƒ}S‹]VW…•j8EÈjPèpZ‹E‰EÈ‹E@‰EÌ‹Ej8hƒ@‰EØEÈjñ3öP‰]ÔFè÷2‹}ƒÄ…Àt…ÿt*Phƒ@ëEÈjPèÆ4;ÆYYt…ÿt
Phì‚@jÿ׃Ä3öEÈPèÔJ…ÀYt,…ÿt
PhÔ‚@jÿ׃Ä3öë3ö9uuÿuÿuSèÏYƒÄFSÿà€@_‹Æ^[ÉÃU‹ìì(‹ES‹]Lê+A‹Q+ƒè9PKW‹ø‰Mä‰}ì:t3Àëƒeüfƒy
V3À@^_[ÉËEà‹}ì4‹N*ùû>PK…E?PK…9¿VƒÀ.ÿu‰Mð¿N Ê¿VпGF*Ñ¿OÈMì‰UàD‰EÜ…ØþÿÿPèY…ØþÿÿH‰Eø…ØþÿÿPèY‹MøƒÄ€<\t…Øþÿÿh ƒ@PèßXYY…ØþÿÿPÿØ€@ƒe„Øþÿÿ‰Eè‹Eƒ8t;‰Eô‹Eôÿ0è³XPÿuð‹Eôÿ0ÿ4@ƒÄ…À‹E„ÚÿE‹Mȃ8‰EôuÈ¿GPÿuð…ØþÿÿPÿp@ƒÄ…ØþÿÿŠ„Ét€ù/uÆ\@uï…ØþÿÿPèJXY‹Mø€<\tNÿu3Àf‹FP3Àf‹FPÿv…ØþÿÿÿuèPjèüÿÿƒÄ…Àt"ÿu¿OÿvÿvQÿuÜPè^ýÿÿƒÄ…À„σ}t‹Eü@P‹Eä¿@
PÿuèjÿUƒÄ‹Eä¿@
ÿEü9EüŒ=þÿÿé0þÿÿ‹MÈÿ3è¯Wÿs‰E…ØþÿÿPè—W‹E¿_‹MðÈ+Ø…ØþÿÿP‰Mè€W‹MøƒÄ€<\t)…ØþÿÿPèhWY‹Mø€</t…Øþÿÿh ƒ@PèGWYY‹EŠ€ù\t€ù/u@KSP…ØþÿÿPÿp@‹]é³þÿÿ3Àé“ýÿÿU‹ìEPhÃ@ÿuÿ,é@ƒÄ…Àu]ÃÿujèmhTÔ@ÿ(é@ƒÄ]ÃU‹ìEPhÃ@ÿuÿ,é@ƒÄ…Àu]Ãÿujè5hTÔ@ÿ(é@ƒÄ]ÃU‹ììƒ=DÔ@VWu hhÃ@ÿЀ@…Àt3hPÃ@PÿÔ€@£DÔ@EüPhÃ@ÿuÿ,é@ƒÄ…ÀtYƒ=DÔ@uh8Ã@ÿ5Lê@ÿ$ç@YYë;3ÿ¾|À@ÿuüÿ6ÿ8@Y…ÀYt)ƒÆGþÌÀ@rãÿuüh$Ã@ÿ5´è@ÿ$ç@ƒÄ3À_^ÉËýxÀ@jP…øþÿÿPjÿDÔ@…Àt…øþÿÿPhÃ@ÿ(é@YYëÉÿuühÃ@ÿ5Lê@ë®U‹ìì,V3öV‰uì‰uð‰uä‰uô‰uü‰uøÿp‚@;Æ}PhœÄ@éEäPEðPEôPEìPEèPEÜPEàPhÄ@ÿuÿ,é@ƒÄ$…À„FEüPhh¯@jVhx¯@ÿt‚@;Æ}PhlÄ@騋EüUøRhˆ¯@‹Pÿ;Æ}PhDÄ@鈋Eüÿuà‹PÿQP;Æ}Ph$Ä@ëp‹EüÿuÜ‹PÿQ;Æ}PhÄ@ëX9uìt‹Eüÿuì‹PÿQ,;Æ}PhäÃ@ë;9uðtÿuä‹Eüÿuð‹PÿQD;Æ}PhÄÃ@ë9uôt'‹Eüÿuô‹PÿQ$;Æ}Ph Ã@ÿ5Lê@ÿ$ç@ƒÄëG…ÔýÿÿhPjÿÿuèVVÿÌ€@‹Eø•ÔýÿÿjR‹PÿQ;Æ}h\Ç@WUÿÖhHÇ@hìÿ50é@ÿÖSèR…ÀY‰D$tjPèYYÿt$ÿÀ€@ƒ=Tê@tBƒ=¸è@t9h,Ç@WUÿÖhHÇ@hìÿ50é@ÿÖSè‹ðY…ötjVèAYYVÿÀ€@3À_^][Ä¡HÔ@…ÀtPÿœ@Yÿt$ÿ<@ƒ%Tê@Y£HÔ@ÃU‹ìƒìSV‹5Ô€@W‹}hØÈ@WÿÖhÄÈ@W‹ØÿÖh¸È@W‰EÿÖh¤È@W‰EøÿÖh”È@W‰EüÿÖh„È@W‰EôÿÖ3ö95LÔ@u3ÀëJ;ÞtC9ut>9uøt99uüt49uôt/;Æt+3É9uh€Ô@•Á‰ÿUÿÓÿuÿuüèƒÄ‹ðÿUø‹ÆëƒÈÿ_^[ÉÃìP¡LÔ@SUV3öW‰t$3É;Æt‹@Aëö·ÁÁà‹=H‚@PV»ëhSÿ50é@ÿ×V½VUSÿ50é@ÿ׉t$‹5LÔ@…ö„‘‹„$h÷ØÀƒàƒÀc‰D$ÿ6ÿD$D$ hðÈ@PÿP‚@D$(Pÿ”$tƒÄ…ÀtÿD$ÿt$D$ ÿ6hèÈ@PÿP‚@D$,Pjè¦ñÿÿƒÄjÿt$USÿ50é@ÿ×ÿ6hìÿ50é@ÿT‚@‹v…öu„‹D$_^][ÄPÃU‹ììhV‹5P‚@Wh@é@…˜ýÿÿhPÉ@PÇEüÿÖ…˜ýÿÿPÿ¤@‹=Ѐ@ƒÄÿuÿ×…À…„ÿ5°è@E¬ÿ5Dê@h É@PÿÖƒÄEü‹5€@P…¨þÿÿPE¬Ph€ÿÖ…ÀtEüP…¨þÿÿPE¬Ph€ÿÖ…Àt3Àë,…¨þÿÿhÈÅ@Pè4Dÿu…¨þÿÿPè%DƒÄ…¨þÿÿPÿ×_^ÉÃU‹ììŒSV3ÛWSSÿ@@‹
È@‹5Ä@ƒÁ@¿ÔÉ@QWP‰EüÿÖ¡È@ƒÀ PWÿuüÿÖh@ç@èßþÿÿ‹ðƒÄ$;óu0ÿ´€@P…tÿÿÿh¤É@PÿP‚@…tÿÿÿPèÖüÿÿƒÄƒÈÿéÿuVèþY‰EôYVÿÀ€@¡È@‹=À@ƒÀ@PÿסÈ@‹5¼@ƒÀ@PÿÖ¡È@ƒÀ PÿסÈ@ƒÀ PÿÖƒÄ9]ô„œhtÉ@è4CÇ$pÉ@ÿuü‹øÿ¸@jS‹´@P‰EÿÓÿuÿ°@jjÿu‰EøÿÓ‹EøD8Pÿ@‹ØƒÄ(…Ût:htÉ@SèâBÿu;ÿuøjPÿ¬@ÿuÀ$8ÿÖSèíûÿÿSÿœ@ƒÄ$ëh`É@è×ûÿÿYÿuüÿ¨@‹EôY_^[ÉÃU‹ìQQSV‹5Ô€@W‹}hØÈ@WÿÖhÄÈ@W‹ØÿÖh¸È@W‰EÿÖh¤È@W‰EøÿÖhØÉ@W‰EüÿÖ‹ð3À;Øt;9Et69Eøt19Eüt,;ðt(h€Ô@ÿUÿÓWè ÿuÿUü‹øƒÄ…ÿtÿÖÿUø‹ÇëƒÈÿ_^[ÉÃU‹ìƒìSV‹5Ô€@W‹}hŒÊ@WÿÖhtÊ@W‹ØÿÖh\Ê@W‰EøÿÖhLÊ@W‰EÿÖh<Ê@W‰EüÿÖh(Ê@W‰EôÿÖhÊ@W‰EðÿÖhÊ@W‰EìÿÖ3ö‰Eè;Þ„›9u„’9uø„‰9uü„€9uôt{9uðtv9uìtqhøÉ@ÿÓ‹øY;þt?hìÉ@WÿUhäÉ@W£´è@ÿUƒÄ£Lê@¾ÈÀ@jVÿUüPÿ6WÿUøƒÆƒÄþ(Á@rå‹Eô£(é@‹Eð£,é@‹Eì£$ç@‹Eè£pê@3ÀëjX_^[ÉÃU‹ìƒìV‹5(‚@W3ÿjWWEäWPÿÖ…ÀtEäPÿ,‚@EäPÿ0‚@jWWEäWPëÛ_^ÉÃU‹ìì¡À@ÇEülÌ@=€tÇEüXÌ@VW3ÿMôWQWjWW¾\Á@WVPÿ€@;Çt5ƒøujWhüË@ÿ‚@Pÿ8‚@3ÀéŸWhèË@Vÿ‚@Pÿ8‚@¾`è@‹=Ü@SVÿu…äþÿÿhÔË@Pÿ×…äþÿÿhÔÉ@Pÿ¸@£Dè@EðPÿØ@‹Ô@EðPÿÓEðPÿÓPh¤Ë@…äþÿÿhPÿÐ@‹ˆ@…äþÿÿPÿ5Dè@ÿÓh€Ô@h˜Ë@ÿ5Dè@ÿÓƒÄHÿuüh„Ë@ÿ5Dè@ÿÓÿ5°è@…äýÿÿÿ5Dê@VhxË@Pÿ×ƒÄ EìPEøP3ÀPhPPP…äýÿÿPÿuôÿ€@…Àtj…äýÿÿh`Ë@Pÿ‚@Pÿ8‚@ÿuôÿ€@ƒ}ìu…äýÿÿPh\Á@hHË@ÿ5Dè@ÿÓƒÄh Õ@…äþÿÿÿ5°è@ÿ5Dê@h8Ë@Pÿ×…äþÿÿPèØ>ƒÄ@P…äþÿÿPjjh,Ë@ÿuøÿ€@…Àtj…äþÿÿhË@Pÿ‚@Pÿ8‚@…äþÿÿP…äýÿÿh,Ë@Ph\Á@hôÊ@ÿ5Dè@ÿÓV…äþÿÿÿuhäÊ@Pÿ×…äþÿÿhàÊ@Pÿ¸@Pjÿ5é@‰Eüÿ5„Õ@ÿÌ@ƒÄ@ÿuüÿ¼@V…äþÿÿÿuVÿuh´Ê@Pÿ×…äþÿÿPè>ƒÄ @¾¤Ê@P…äþÿÿPjjVÿuøÿ€@…Àtj…äþÿÿhË@Pÿ‚@Pÿ8‚@…äþÿÿP…äýÿÿVPh\Á@hôÊ@ÿ5Dè@ÿÓƒÄjX[_^ÉÃU‹ì¸è«=ƒ}NV„©}„K}…´W3ÿ9=Tê@„)¾Ö@‹Æ…À„€=Ö@„
S‹T‚@hpÍ@hèÿu‰}ðÇEôdÍ@‰}øÿÓ…ìþÿÿh@é@Pè=…ìþÿÿhXÍ@Pèú<…ìþÿÿVPèí<¡Dè@ƒÄ;ÇtìþÿÿQh@ç@h@Í@Pÿˆ@ƒÄWWÿ@@‹
È@‹5Ä@ƒÁ@¿ÔÉ@QWP‰EÿփąÀuPPh0Í@ÿ‚@Pÿ8‚@¡È@ƒÀ PWÿuÿÖƒÄ…ÀuPPh Í@ÿ‚@Pÿ8‚@hjÿ ‚@Pÿ$‚@‰Eü…ìþÿÿh@ç@‰EðèH÷ÿÿ‹ðY…öt{V4thàÒ@Rè‚ÖÿÿYYéÚ;ŒЋN;Êt
‹Ö+V+щPê@+F‹M‹þh+F‰+~ÿ@‹ØY…Û„–…üþÿÿPhÿ€@…ÀtmSj…üþÿÿhÜÒ@PÿÜ€@…ÀtT3ÀPPPÿvPSjèÌÿÿƒÄ‰E…ÀtLÿvWPÿ˜@ÿuè(|Wÿ<@‹MƒÄÿu‰‹E‰ÿà€@jXëh¼Ò@ÿ´€@Pè¥ÕÿÿYY3À_^[ÉÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$3É;ÑtM‹B;ÁtF‰H‰J‰J‰JÇB0‰‰H‰H‰H ‰H(‰H,‰H0‰H8‰H<ˆ0Ç@€‰Hl‰HP‰HL3ÀøþÿÿÿÃÌÌÌ‹D$W3ÿ;Ç„±€81…¨ƒ|$8…V‹t$;÷„ˆ9~ ‰~u
ÇF °]@‰~(9~$uÇF$Ð]@‹F(h0%jPÿV ƒÄ;Çu^¸üÿÿÿ_ËL$;ωF}‰x÷Ùë‹ÑÁúBƒù0‰P}ƒáƒù|ƒùV‰H$‰x4èüþÿÿƒÄ^_ÃP‹F(PÿV$ƒÄ‰~^¸þÿÿÿ_øúÿÿÿ_ÃÌÌÌÌÌÌÌÌÌSU‹l$‹]VW‹ð‹C43ÿ;Çu(‹K$¸Óà‹M(jPQÿU ƒÄ;ljC4u
_^]¸[Ã9{(u‹K$ºÓâ‰{0‰{,‰S(‹}‹K(+÷‹Æ;Ár*‹u‹{4+ñ‹ÁÁéó¥‹Èƒáó¤‹K(_^]ÇC0‰K,3À[Ã+K0;ȉL$v‹È‰L$‹S0‹{4‹uú‹ÑÁé+ðó¥‹Êƒáó¤‹L$+Át(‹u‹{4‹È‹Ñ+ðÁéó¥‹Êƒáó¤_‰C0‹C(^‰C,]3À[Ë{0‹C(ù‹×;Љ{0uÇC0‹S,;ÐsщS,_^]3À[ÃÌÌÌÌÌÌÌÌÌÌÌ‹D$ƒì8…ÀS„‡‹X…Û„|‹H…É„qƒ8u‹H…É…aƒ;uÇ‹H‹PU‹k3íUUUèR$‰CjD$4ÆD$4ÆD$5‹‹KPQè5$‰CƒÄ‰l$Ç‹Åéü‹C …ÀÇCtÇ@0ÿÿÿÿöC„¬‹L$‹Á%ÿÁàÁéÁ3Ò¹÷ñ…Ò…ˆ‹L$‹Ñ€â€út‹D$LÇ@t@‹Áé“‹C$Áé‰L$ƒáƒÁƒí;Èv‹L$L‹D$ÇA`@éh3íºÓâUUU‰SèL‹T$‹L$XÁê÷ÒƒâƒÄ‰C‰A0ƒÊ	‰‰l$‹Åé1‹D$LÇ@H@‹D$éƒýs'…ÿ„n¶‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ<‰Ct‹L$LÇAt@éÔöÄàt‹T$LÇB,@é¿‹K …ÉtÁèƒà‰‹CöÄt%‹D$ˆD$$ÁèˆD$%‹KjD$(PQè±"ƒÄ‰C3À3íÇëƒý s…ÿ„ζ‹ÍÓâOƒÅÂFƒý ‰D$rá‹K …Ét‰A‹CöÄt7‹D$ˆD$$‹È‹ÐÁèÁéˆD$'ÁêjD$(ˆL$)ˆT$*‹KPQè8"ƒÄ‰C3À3íÇëƒýs(…ÿ„T¶‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ‹K …Ét‹Ðâÿ‰Q‹K Áè‰A‹CöÄt%‹D$ˆD$$ÁèjT$(ˆD$)‹CRPè·!ƒÄ‰C3À‰D$3íÇ‹KöÅtvƒýs-›…ÿ„Ķ‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ‹K …ɉC@t‰A‹CöÄt%‹D$ˆD$$ÁèˆD$%‹KjD$(PQè5!ƒÄ‰C3À‰D$3íë‹K …ÉtÇAÇ‹KöÅ„¬‹K@;ωL$v‹Ï‰L$…É„ˆ‹S …ÒtH‹R…Ò‰T$8t=‹S ‹z‹s@‹R+þ49;òv+׋ʋT$8‹t$ú‹ÑÁéó¥‹Êƒáó¤‹L$‹|$‹t$‹SöÆt‹D$‹KPVQè† ‹L$(‰C‹D$ƒÄ‹S@+ùñ+щ|$‰t$‰S@‹K@…É…•ÇC@Ç‹KöÅ„ …ÿ„t3É›¶1A‰L$‹K …ɉT$,t-‹Q…Ò‰T$8t"‹S@;Q s‹L$8‹|$‰D$8ŠD$,ˆÿC@‹D$8‹L$,…Ét‹L$;Ïr¯‹KöÅt‹T$‹CRVPèȉC‹D$ƒÄ‹L$+ùñ‹L$,…ɉ|$‰t$…Þë‹K …ÉtÇAÇC@Ç‹KöÅ„š…ÿ„­3ɶ1A‰L$‹K …ɉT$,t-‹Q$…Ò‰T$8t"‹S@;Q(s‹L$8‹|$‰D$8ŠD$,ˆÿC@‹D$8‹L$,…Ét‹L$;Ïr¯‹KöÅt‹T$‹CRVPè‰C‹D$ƒÄ‹L$+ùñ‹L$,…ɉ|$‰t$…ë‹K …ÉtÇA$Ç‹KöÅtOƒýs'…ÿ„ò
¶‹ÍÓâOƒÅ‰|$ÂFƒý‰D$‰t$rÙ‹Káÿÿ;Át‹T$LÇB@éR
3í‰l$‹C …Àt‹KÁù	ƒá‰H,‹S ÇB0jjjèL‹L$X‰C‰A0‹D$ƒÄÇé
ƒý s'…ÿ„_
¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rÙ‹È‹ÐáÿÁâÊ3ÒŠt$ÁáÁèÊÁ‹L$L‰C‰A03À‰D$3íÇ
‹K…É„¸jjj臋T$X‰C‰B0‹D$ƒÄǃ|$P„Ñ‹K…Ét‹ÍƒáÓè+éljD$éTƒýs$…ÿ„¤¶‹ÍÓâOƒÅ‰|$ÂFƒý‰t$r݋ȃáÑè‰K‹ÈƒáMƒùwsÿ$H]@ÁèÇ
‰D$ƒíéúÁèÇCL(ƒ@ÇCT	ÇCP(‹@ÇCXljD$ƒíéÉÁèljD$ƒíé´‹T$LÇB@ÇÁè‰D$ƒí锋̓áÓè+éƒý ‰D$s+d$…ÿ„Ô¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rًЋÈ÷ÒáÿÿÁê;Êt‹L$LÇAäŒ@é.3À‰K@‰D$3íÇ‹K@…ɉL$„¢;Ïv‹Ï‰L$‹T$ ;Êv‹Ê‰L$…É„R‹t$‹|$(‹ÑÁéó¥‹Ê‹T$ƒáó¤‹L$‹t$‹|$ +ñ‰t$‹t$(щT$‹S@+ùñ+щ|$ ‹|$‰t$(‹t$‰S@é
ƒýs#…ÿ„î
¶‹ÍÓâOƒÅ‰|$ÂFƒý‰t$r݋ȃáÁÁè‹Ð‰K`Áè‹ÈƒáƒÁƒâ‰K\‹K`BÁèƒíù‰Sd‰D$‡ý‹Êƒù‡òÇChÇ‹Kh;K\s[›ƒýs#…ÿ„_
¶‹ÍÓâOƒÅ‰|$ÂFƒý‰t$rÝ‹Sh·U¨‹@3ÉŠÈÁèƒí‰D$ƒáf‰LSp‹KhA‰Kh;K\r«‹Kh¸;Ès*3Éë¤$d$‹Sh·U¨‹@f‰LSp‹ShB;ЉShråƒ0Kl‰‰CL“ðRCTPQÇjCpPjèXƒÄ‰D$4…À‹D$t ‹L$LÇAÈŒ@é1	‹T$LÇB¤Œ@é!	ÇChÇ‹K`‹SdÑ9Shƒ‹KTºÓâ‹KLJ#Ћ‘¶Õ;Õ‰L$@v<…ÿ„A	¶‹ÍÓâ‹KTOƒÅºÓâ‹KLF‰|$J#Ћ‘¶Õ;Õ‰t$‰L$@wÄ‹T$@ÁêfƒúsR¶Í;é‰L$s&…ÿ„í¶‹ÍÓâ‹L$OƒÅÂF;é‰|$‰t$rÚf‹T$BÓè+é‹Khf‰TKp‹KhA‰D$‰KhéHuh¶ÍQ;ê‰L$s+‹ÿ…ÿ„”¶‹ÍÓâ‹L$OƒÅÂFQ;ê‰|$‰t$r×Óè+é‹Kh…ɉD$„b·LKn‰L$,‹ÈƒáƒÁÁèƒíé§fƒú¶Õ‰T$uJJ;és-d$…ÿ„$¶‹ÍÓâOƒÅ‰|$‹T$FJ;é‰t$r׋ÊÓè¿ýÿÿÿ‹ÈƒáƒÁÁèëDJ;és)…ÿ„Þ¶‹ÍÓâOƒÅ‰|$‹T$FJ;é‰t$r׋ÊÓè¿ùÿÿÿ‹ÈƒáƒÁÁè+úÇD$,ï‹{d‹Sh{`Ñ;׉D$‡˜…Ét‹T$,‹ÿ‹{hf‰T{p‹{hGI‰{huî‹|$‹S`‹KdÊ9Kh‚îýÿÿƒ;„îƒ0Kl‰‰CL“ðR‹S`CTPQÇ	RCpPjèÁ
ƒÄ…À‰D$4t8‹L$L‹D$ÇAˆŒ@éš‹T$LÇBlŒ@銋L$L‹|$ÇAlŒ@év‹SlKl‰SP“ðRCXPQ‹K`Ç‹CdPTKpRjèP
ƒÄ…À‰D$4t‹D$LÇ@TŒ@‹D$é)‹D$ǃÿrg|$ r]‹D$L‹T$ ‹L$(‰P‹T$0‰H‹L$R‰0‰xP‰K8‰k<è|‹D$T‹H‹P‹0‹x‹C8‹k<ƒÄ‰L$(‰T$ ‰t$‰|$‰D$鹋KTºÓâ‹KLJ#Ћ‘¶Î;͉T$@v<…ÿ„ñ¶‹ÍÓâ‹KTOƒÅºÓâ‹KLF‰|$J#Ћ‘¶Î;͉t$‰T$@wÄ„Ò„¹öÂð…°¶Î‰L$3ɊʉT$,L$ºÓâ‹L$J#ÐÓê‹L$@ÁéÑ‹KL‹‘‹L$,Áé‰T$@¶É¶ÖÑ;Õ‰L$v[I…ÿ„T¶‹ÍÓâ3ÉŠL$,O‹T$FƒÅ‰|$ʺÓâ‹L$‰t$J#ÐÓê·L$.Ñ‹KL‹‘¶Õ‰L$@‹L$Ñ;Õw¨‹T$@Óè+é¶ÎÓè¶Î+é‹L$@Áé„Ò‰D$‰K@uÇéwö tÇégöÂ@t‹T$LÇB8Œ@éLƒâ‰SHÇ‹KH…ÉtE;és%…ÿ„‘¶‹ÍÓâ‹KHOƒÅÂF;é‰|$‰t$rÛ‹KHºÓâ‹K@J#ÐʉK@‹KHÓè+éÇ‹KXºÓâ‹KPJ#Ћ‘¶Î;͉T$@v<…ÿ„,¶‹ÍÓâ‹KXOƒÅºÓâ‹KPF‰|$J#Ћ‘¶Î;͉t$‰T$@wÄöÂð…³¶Î‰L$3ɊʉT$,L$ºÓâ‹L$J#ÐÓê‹L$@ÁéÑ‹KP‹‘‹L$,Áé‰T$@¶É¶ÖÑ;Õ‰L$v^›…ÿ„”¶‹ÍÓâ3ÉŠL$,O‹T$FƒÅ‰|$ʺÓâ‹L$‰t$J#ÐÓê·L$.Ñ‹KP‹‘¶Õ‰L$@‹L$Ñ;Õw¨‹T$@Óè+é¶ÎÓè¶Î+éöÂ@‰D$t‹L$LÇA Œ@鵋L$@Áéƒâ‰KD‰SHÇ‹KH…ÉtI;és%…ÿ„ð¶‹ÍÓâ‹KHOƒÅÂF;é‰|$‰t$rÛ‹KHºÓâ‹KDJ#ÐʉKD‹KHÓè+é‰D$‹T$ ‹K,+ÊL$09KDv‹T$LÇBŒ@é-Ç‹L$ …É„‹T$0+Ñ‹KD;Êv<+Ê‹S0;ʉL$v+Ê‹S4S(‰L$+Ñë‹S4+ÑS0‹L$‰T$,‹S@;ʉT$8v‹Êë‹T$(+Ñ‹K@‰T$,‰L$8‰L$‹T$ ;Êv‹Ê‰L$+щT$ ‹T$8+щS@뛋L$,Š‹L$(ˆ‹T$,A‰L$(‹L$BI‰T$,‰L$uÛ‹K@…É…nÇéc…Ò„¹‹L$(ŠS@ˆA‰L$(ÿL$ Çé>‹K…É„Õƒý s'…ÿ„„¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rÙ‹L$0+L$ ‹T$LJ‹SхɉL$0‰St8‹C‹S‹L$(…À‹D$0Pt+ÈQRèîë	+ÈQRè³‹L$X‰C‰A0‹D$ƒÄ‹K‹T$ …ɉT$0‹Èu'áÿ‹ÐÁâÊ3ÒŠt$Áá‰L$8Ê‹ÐÁêʉL$8;Kt
‹L$LÇAè‹@ë`3À‰D$3íÇ‹K…É„“‹K…É„ˆƒý s'…ÿ„“¶‹ÍÓâOƒÅ‰|$ÂFƒý ‰D$‰t$rÙ;CtS‹L$LÇAЋ@Ç‹ƒù†dìÿÿ_^]¸þÿÿÿ[ƒÄ8ËL$L‹T$(‰Q‹T$ ‰y_‰1‰Q^‰k<‰C8]¸[ƒÄ8Ã3À3íÇÇD$4ëÇD$4ýÿÿÿ‹L$L‹T$(‰Q‹T$ ‰Q‰1‰y‰C8‹C(…À‰k¨@…3¹‰L$@‹È‹D$@Óà‹L$ÁéH#ÇÁ‹L$$‹¶Ì‰D$¶ÀÓï+Ù¨t‹L$Áéƒà;؉L$s(¶jB‹ËÓåƒÃ‰T$ý;Øs¶jB‹ËÓå‰T$ýƒÃ¹‹é‹ÈÓå+ØM#ï‹Í‹l$é‹ÈÓï‹L$D‹Æ+Á;è‰l$†+è;l$H‡n‹L$,‹D$I…Àu*‹D$(+ÅÈ‹D$T;胑+ʼnD$Td$ŠAAFMˆuöës;ÅsS+ÅD$(È+l$‹D$T;èsc+ʼnD$T›ŠAAFMˆuö‹L$,‹D$‹l$TI;Ås<+è‰l$T‰D$@‹èŠAAFMˆuöë+ÅÈ‹D$T;ès+ʼnD$TŠAAFMˆuö‹D$‹Î+È‹D$Tƒøv7Pý¸«ªªª÷â‹êÑíEŠAAFˆŠQAFˆ‹T$TŠAAFƒêMˆ‰T$TuÝ‹T$‹D$T…Àt^ŠAAFˆƒ|$TvPŠIFˆëH‹Æ+Ť$ŠH@FˆŠH@FˆŠH@Fˆ‹L$Tƒéƒù‰L$TwÛ…ÉtŠH@Fˆƒ|$TvŠ@Fˆ‹l$;T$0sQ;t$4‚ÁüÿÿëE‹L$P‹D$ÇAŒ@Ç‹èë,‹L$PÇA Œ@ë¨ t	ÇEë‹D$PÇ@8Œ@ÇE‹ÃÁèÅ+Ð+ً˸Óà‹L$PH#øB‰F‰A‹D$0+ƒÀ‰A‹D$4+ƉA‰}8_^‰]<][ƒÄ<ÃÌÌÌÌ̃ì|‹”$ˆ3À…Ò‰D$<‰D$@‰D$D‰D$H‰D$LS‰D$TU‹¬$Œ‰D$\V‰D$dv›·LEfÿDLHLLH@;Ârí‹´$œ‹»‰D$‰\$¤$fƒ|\HuKƒûsò;É\$v‰\$…Ûu9‹„$˜‹f‰\$ÆD$@ÆD$
‹L$‰
‹ƒÂ‰‰
ƒÇ^]3À[ƒÄ|þd$fƒ|tHu:fƒ|tJu"fƒ|tLufƒ|tNufƒ|tPuƒÆƒþvÐëFë
ƒÆëƒÆëƒÆ9t$s‰t$º‹Â·LDHÒ+Ñx&@ƒøvï…ÒW‹¼$~…ÿtƒût_^]ƒÈÿ[ƒÄ|Ã^]ƒÈÿ[ƒÄ|ÃfÇD$n¸›f‹TlfTLf‹LNfÊf‰Tnf‰LpƒÀƒørÜ‹œ$˜3À…Ûv0fƒ|Et#·TE·LTl‹”$¤f‰J·TEfÿDTlTTl@;ÃrЋǃèºÿÿÿÿt;HtÇD$4èŽ@ÇD$0(@‰T$,ë9¸hŽ@-‰D$4¸¨Ž@-ÇD$,ë‹„$¤‰D$4ÇD$,‰D$0‹„$œ‹‰L$ ‹L$¸Óà‰T$83í3ÛƒÿPÿ‰t$‰D$<‰D$(‰T$@u=°ƒk‹„$¤‰D$$IŠL$‹t$$f‹‹T$,*ˈL$·È;Ê}ÆD$f‰D$ë-~·‹T$0ÑàŠ‹T$4f‹ˆL$f‰D$ëÆD$`fÇD$‹L$‹D$<+˺Óâ‹Ë‹ýÓï‹L$ ‰D$D4•ø¹‹|$+Â+Î…À‰9uö‹T$Jÿ¸Óà…ÅtÑè…Åuú…ÀtHÿ#ÍÈ‹éë3í‹t$$ƒÆfÿLTLfƒ|TL‰t$$u;T$„à‹Œ$”‹Ö··A‰T$;T$†	ÿÿÿ‹t$@‹D$8#õ;ð‰t$H„óþÿÿ…Ûu‹\$‹D$ ‹L$D‹|$ˆ‹L$+ˉT$ ¸Óà;×s tTL·>+Ç…À~‹|$ABƒÆÑà;×rè‹t$H‹T$(¸ÓàЉD$<ƒ¼$‰T$(u
‹Â=°ƒÕ‹Ö‹´$œ‹ˆ‹ŠD$ˆD‘‹‹L$ +ÈÁù‰T$8f‰LéGþÿÿ‹¼$œŠÂ*Ã…íÆD$@ˆD$fÇD$t]‹t$ d$…Ût ‹L$@‹D$8#Í;Èt‹D$‹73Û‰D$ˆD$‹Ð‹Ë‹ÅÓè‹L$‰†Jÿ¸Óà…ÅtÑè…Åuú…ÀtHÿ#ÍÈ‹éu«‹T$(‹•‹T$ȉ‹Œ$ _^]‰3À[ƒÄ|Ã_^]¸[ƒÄ|ÃÌÌÌÌÌÌ‹L$S‹\$W‹ùÁïáÿÿƒûu1‹D$¶Êùñÿréñÿùÿñÿrïñÿ‹ÇÁà_Á[ÃV‹t$…öu	^_¸[Ãûs3…Ût¶ÈFùKuõùñÿréñÿ‹Ç3Ò¾ñÿ÷ö^_[‹ÂÁàÁÃû°‚ʸ¯©n^÷ãU‹êÁí‹ÿë°¸[ëI¶Ê¶VùʶVùʶVùʶVùʶVùʶVùʶVùʶVùʶV	ùʶV
ùʶVùʶVùʶV
ùʶVùʶVùÊùƒÆH…wÿÿÿ‹Á3Ò¹ñÿ÷ñ‹Ç¿ñÿ‹Ê3Ò÷÷M‹ú…Fÿÿÿ]…Û„Ãû‚‘‹ÃÁè¶Ê¶VùʶVùʶVùʶVùʶVùʶVùʶVùʶVùʶV	ùʶV
ùʶVùʶVùʶV
ùʶVùʶVùʃëùƒÆH…tÿÿÿ…Ût¶ÈFùKuõ‹Á3Ò¹ñÿ÷ñ‹Ç¾ñÿ‹Ê3Ò÷ö‹ú‹Ç^Áà_Á[ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌQSV‹ò…ö÷Ðt&ëIöÁt3ÒŠ3Ðâÿ‹•h@Áè3ÃANu߃þ UW‚‹þÁï3‹ÐÁê¶Ü‹,h—@¶Ò‹•h“@3Ջ؉D$Áë‹,h@‹Y3Õ%ÿ3…h›@3Ó‹ÂÁè¶Þ‹,h—@ƒÁ¶À‹…h“@3Å‹Ú‰T$Áë‹,h@‹Y3Åâÿ3•h›@3ÃÁ‹ÐÁê¶Ü‹,h—@¶Ò‹•h“@3Ջ؉D$Áë‹,h@‹Y3Õ%ÿ3…h›@3ÓƒÁ‹ÂÁè¶Þ‹,h—@¶À‹…h“@‹Ú3ʼnT$Áë‹,h@‹Yâÿ3Å‹,•h›@ƒÁ3Å3ËЃÁÁê¶Ò‹•h“@‰D$¶Ü3h—@‹ØÁë‹,h@‹3Õ%ÿ3…h›@3Ó‹ÂÁè¶Þ‹,h—@¶À‹…h“@3Å‹ÚÁë‹,h@‹Y3ʼnT$âÿ3•h›@3ÃÁ‹Ð¶Ü‹,h—@Áê¶Ò‹•h“@‹Ø3Õ‰D$Áë‹,h@‹Y%ÿ3Õ‹,…h›@ƒÁ3Õ3Ó‹ÂÁè¶Þ‹,h—@¶À‹…h“@‹Ú3ÅÁë‹,h@‰T$âÿ‹•h›@3ŃÁ3Ãî O…êýÿÿƒþrH‹ÖÁê3¶Ü‹,h—@‰D$¶|$‹<½h“@‹Ø3ýÁë‹,h@%ÿ3ý3<…h›@ƒÁƒîJ‹Çu½…ö_]t"›3ÒŠ3Ðâÿ‹•h@Áè3ÃANuä^÷Ð[YÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹L$…Éu3ÀËT$‹D$éýÿÿÿ%h@ÿ%l@ÿ%t@ÿ%x@ÿ%|@ÿ%€@ÌÌÌÌ=s÷ØăÀ…”‹PÃQL$é-…=sì+È‹Ä…‹á‹‹@PÃjth˜¯@èÛ3Û‰]àS‹=Œ€@ÿ×f8MZu‹H<È9PEu·A=t=t‰]äë'ƒ¹„vò3À9™øëƒytvâ3À9™è•À‰Eä‰]üjÿ @Yƒ
xê@ÿƒ
|ê@ÿÿ@‹
dÔ@‰ÿ@‹
`Ô@‰¡@‹£tê@èè+9 Ó@uhÐo@ÿ@YèhÀ@hÀ@èëhto@èG¡\Ô@‰EØEØPÿ5XÔ@EÐPEÌPEÈPÿ@ƒÄ ‰EÄ;Ã}jèæYhÀ@hÀ@èœYY¡è€@‹0‰uÜŠ< w]:Ãt9]àuTŠ:Ãt
< wF‰uÜëð‰]¨…|ÿÿÿPÿ¬€@öE¨t·E¬ëj
XPVSSÿ×PèâÓÿÿ‹ð‰uÀ9]äuVÿì€@ÿð€@ëU<"u3É9]à”Á‰Mà¶ÀPÿô€@Y…ÀtF‰uÜFérÿÿÿ‹Eì‹‹	‰MÔPQè(YYËeè‹uÔƒ}äuVÿü€@ÿ@ƒMüÿ‹Æè$Ãÿ%ø€@ÿ%@ƒ=|ê@ÿuÿ%,@hxê@h|ê@ÿt$èƒÄÃÿt$èÑÿÿÿ÷ØÀ÷ØYHÃjh¨¯@è˜ÇEäȯ@}äȯ@s"ƒeü‹Eä‹…ÀtÿÐë3À@ËeèƒMüÿƒEäëÕèœÃjh¸¯@èTÇEäЯ@}äЯ@s"ƒeü‹Eä‹…ÀtÿÐë3À@ËeèƒMüÿƒEäëÕèXÃÿ%@hhè_YYÃ3ÀÃÌh p@d¡P‹D$‰l$l$+àSVW‹Eø‰eèP‹EüÇEüÿÿÿÿ‰EøEðd£Ã‹Mðd‰
Y_^[ÉQÃÿ%$@ÿ%(@ÿ%0@@¸è·ø·b¸R¸Ú·.¸¸¸³³T·t·€·Œ·œ·ª·¼·d·Œ´œ´ª´Â´Þ´î´µµ*µ>µPµfµzµx´œµT³h³~³Ž³¤³²³˜»À³Ø³è³D³j´X´L´6´&´´´ˆµö³ÖºÎºÄº¶º¨º º–ºàºîºþº
»».»>»L»^»r»€»Š»ª»¶»Â»Ì»Ø»â»|ºnºê»dº\ºRºÞ¸è¸ò¸ü¸¹¹¹$¹.¹8¹B¹P¹Z¹f¹p¹x¹‚¹Œ¹–¹ž¹¦¹®¹¶¹À¹Ê¹Ô¹Ü¹æ¹ò¹þ¹ººº$º.º:ºJº‚¸ÔµÈµ–¶6·$···ø¶ì¶Ü¶È¶´¶¦¶ºµˆ¶€¶t¶^¶R¶F¶4¶$¶¶¶ðµäµÄ¸°¸ž¸CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

incorrect length checkincorrect data checkinvalid distance too far backinvalid distance codeinvalid literal/length codeinvalid distances setinvalid bit length repeatinvalid literal/lengths settoo many length or distance symbolsinvalid code lengths setinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method(Ž@Ž@Ž@Ž@Ž@ô@à@Ð@¸@Ž@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionary inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScsƒ£ÃãÉÄ	
!1AaÁ 0@`@@–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”ÞñîÀFÀFÀFÿÿÿÿ³n@Çn@ÿÿÿÿ]o@ao@ÿÿÿÿ¡o@¥o@°°6³(€à°¬µX€Œ²H·‚¼°Ð·4€ˆ°t¸€„²’¸üø²Ô¸p‚p±Šºè€@¸è·ø·b¸R¸Ú·.¸¸¸³³T·t·€·Œ·œ·ª·¼·d·Œ´œ´ª´Â´Þ´î´µµ*µ>µPµfµzµx´œµT³h³~³Ž³¤³²³˜»À³Ø³è³D³j´X´L´6´&´´´ˆµö³ÖºÎºÄº¶º¨º º–ºàºîºþº
»».»>»L»^»r»€»Š»ª»¶»Â»Ì»Ø»â»|ºnºê»dº\ºRºÞ¸è¸ò¸ü¸¹¹¹$¹.¹8¹B¹P¹Z¹f¹p¹x¹‚¹Œ¹–¹ž¹¦¹®¹¶¹À¹Ê¹Ô¹Ü¹æ¹ò¹þ¹ººº$º.º:ºJº‚¸ÔµÈµ–¶6·$···ø¶ì¶Ü¶È¶´¶¦¶ºµˆ¶€¶t¶^¶R¶F¶4¶$¶¶¶ðµäµÄ¸°¸ž¸dPropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrorECreateDirectoryAVGetFileAttributesA^MapViewOfFileNCreateFileMappingA.CloseHandleSetFileTimeˆDosDateTimeToFileTimeiGetLastErrorMCreateFileAcUnmapViewOfFile¼lstrlenA˜GetProcAddressHLoadLibraryAkMultiByteToWideCharRLocalFreeêFormatMessageAïFreeLibrarywGetModuleHandleAßGetVersionExA|DeleteFileAŽGetPrivateProfileIntA”GetPrivateProfileStringAÅResumeThread$SetPriorityClass:GetCurrentProcess=GetCurrentThread6SetThreadPriority`CreateProcessAuGetModuleFileNameA¸RemoveDirectoryA[GetFileSizeÉGetTempFileNameAËGetTempPathAKERNEL32.dllÞMessageBoxAGetFocus;SendMessageAÈEndPaint]GetSystemMetrics
BeginPaintŽDefWindowProcAPostMessageASSetDlgItemTextAÖwsprintfAEGetParent6SendDlgItemMessageA*ReleaseDCGetDCëMoveWindowtGetWindowRectGetDlgItem¡DispatchMessageAªTranslateMessageÿPeekMessageAMSetCursor¹LoadCursorA»UpdateWindow’ShowWindow`CreateWindowExARegisterClassAUSER32.dllDeleteObject<SetTextColorNTextOutASetBkModeSelectObject9CreateFontA3CreateDIBitmapPCreateSolidBrushGDI32.dllÉRegCloseKeyâRegOpenKeyExAìRegQueryValueExAÖRegEnumKeyExAëRegQueryValueAùRegSetValueExAÍRegCreateKeyExAÐRegDeleteKeyAÒRegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dllhCoUninitializeCoCreateInstance:CoInitializeole32.dllstrchråmemcpyçmemset
strncatstrcatstrlenstrcpystrcmpstrrchr¦fprintf%_vsnprintfßmallocè_snprintfstrncpy¬freesscanfÇ_putenvöremove«fread²ftell°fseek¥fopenšfclosefflush­freopenC_iob´fwritestrftimeÛlocaltimetimesprintf_fstatstrtolÁ_pctypeE_isctypey__mb_cur_maxòqsortõrealloc fgetsstrncmp{__p___argvz__p___argcMSVCR71.dllÊ_c_exitú_exitK_XcptFilterM_ismbbleadÍ_cexit—exit­_acmdlnÂ_amsg_exitn__getmainargs?_inittermŸ__setusermatherr»_adjust_fdiv‚__p__commode‡__p__fmodeœ__set_app_typeñ_except_handler3k__dllonexit¸_onexitÛ_controlfp¯GetStartupInfoA_strnicmpú_strcmpiü_strdup_tempnam×_closeÌ_read¹_openÿÿÿÿÃ@TÔ@üÂ@TÔ@ôÂ@TÔ@ìÂ@àÂ@ØÂ@TÔ@Ã@ÄÂ@üÂ@ÄÂ@ôÂ@TÔ@ìÂ@àÂ@ØÂ@TÔ@¬Â@œÂ@ŒÂ@lÂ@TÂ@<Â@,Â@Â@Â@øÁ@èÁ@Ý@ÐÁ@î@ÀÁ@@°Á@~@œÁ@¶@Á@·@Software\Microsoft\Windows\CurrentVersion\UninstallSoftware\Microsoft\Windows\CurrentVersion\Uninstallmessage_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBsno such folder (%s)unknown CSIDL (%s)function not availableSHGetSpecialFolderPathAshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissi100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Runtime ErrorTimes RomanThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Don't know Python's installation typeStrange\python%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Py_OptimizeFlagPySys_GetObjectPyRun_SimpleStringPy_FinalizePy_SetProgramNamePy_Initialize%s%cimport py_compile; py_compile.compile (r'%s')SOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOut of memory!rbRunning the pre-installation script failed
Can't load Python for pre-install script (%d)aPyErr_PrintOSErrorValueError__builtin__PyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleUninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINEPostinstall script finished.
Click the Finish button to exit the Setup wizard.*** Could not load Python ****** run_installscript: internal error 0x%X ***
freopen stdoutfreopen stderr300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...Installation failed.Running Script...Could not open postinstall-script %s
PySys_SetArgv*** Installation finished %Y/%m/%d %H:%M ***
IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasBad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup %sCould not register window classSetup.exeSetupWindowClassif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of argsSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archiveCould not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py) €8€nh€k€€l˜€m°€nÈ€à	ð			 0ñ
8û ØüàþZ@(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-8.0.exe0000644000175100001710000017000000000000000024115 0ustar00runnerdockerMZÿÿ¸@ðº´	Í!¸LÍ!This program cannot be run in DOS mode.

$œˆ<·ØéRäØéRäØéRäO-,äßéRäÿ/)äÚéRäÿ/<äÙéRäÿ//äÛéRäæ
äÚéRäæäÕéRäØéSäéRäÿ/?äÄéRäÿ/.äÙéRäÿ/*äÙéRäRichØéRäPELKÐ#Eà`€7ip@pœ± àèа@p¸.text¢]` `.rdata,OpPp@@.dataÀÀ@À.rsrcèà Ð@@…ÀtŠ„Ét€ù/uÆ\@uïÃV‹t$…ö„ƒU‹l$W‹|$S€>tpj\VÿXq@‹ð…öYYt_WÆÿ˜p@‹Øƒûÿu'jWÿ”p@…Àu…ítWhÐr@jÿÕƒÄëWjÿÕYYöÃuh·ÿp@…ít
WhÐr@jÿÕƒÄÆ\Fu‹[_]3À@^ÃU‹ìƒìSVW‹= p@3ö»À9uuÇEVh€ÿuVVSÿuÿ׃øÿ‰Eü…‡ÿèp@ƒøuÿu ÿuÿuèÿÿÿƒÄ…Àu·éûƒøPt	Pÿp@ë/9u „äÿujÿU …ÀYYt.Vh€jVVSÿuÿ׃øÿ‰Eüu%9u „µÿuhs@é ÿujÿU YYé™9u t
ÿujÿU YYEôPÿuÿuÿäp@‹}üEôPPPWÿàp@9uu	WÿÜp@ë\VÿuVjVWÿ¤p@W‹=Üp@‹Øÿ׃ûÿu9u t8ÿuhür@ë&VVVjSÿq@S‰Eÿ׋E;Æu9u tÿuhèr@jÿU ƒÄ3À_^[ÉÃU‹ìƒì8ƒ}S‹]VW…•j8EÈjPèdS‹E‰EÈ‹E@‰EÌ‹Ej8hhs@‰EØEÈjñ3öP‰]ÔFèŒ2‹}ƒÄ…Àt…ÿt*PhPs@ëEÈjPè4;ÆYYt…ÿt
PhPK…?PK…ü¿VƒÀ.ÿuŒ‰M´¿N Ê¿VпGF*Ñ¿OÈ‹E˜ËD‰EˆE¸P‰U€èÏQE¸H‰E E¸Pè¹Q‹M ƒÄ€<\tE¸hps@Pè™QYYE¸Pÿq@ƒe¤D¸‰E”‹Eœƒ8t;‰E°‹E°ÿ0èsQPÿu´‹E°ÿ0ÿ4q@ƒÄ…À‹Eœ„¾ÿE¤‹M¤ȃ8‰E°uÈ¿GPÿu´E¸Pÿdq@ƒÄE¸è„ûÿÿE¸PèQY‹M €<\tGÿu¨·FP·FPÿvE¸ÿu”PjèþûÿÿƒÄ…Àt"ÿu¨¿OÿvÿvQÿuˆPèFýÿÿƒÄ…À„¾ƒ}¨t‹E¬@P‹E¿@
Pÿu”jÿU¨ƒÄ‹E¿@
ÿE¬9E¬ŒkþÿÿéKþÿÿ‹M¤Èÿ3è‹Pÿs‰E°E¸PèvP¿_‹E°‹M´È+ØE¸P‰M´èbP‹M ƒÄ€<\t#E¸PèMPY‹M €</tE¸hps@Pè/PYY‹M´Š<\tjPÿœq@ÆSÆ8ÿÕVèóöÿÿVÿ€q@ƒÄ$ëhPx@èÝöÿÿYÿt$ÿ˜q@‹D$Y_^][ƒÄÃU‹ìì¡|Á@3ʼnEü3À9EV¾t>PPøûÿÿQVÿuPhÿìp@Vÿµøûÿÿ…üûÿÿPÿ¼q@ƒÄÿµøûÿÿÿðp@눅üûÿÿ…üûÿÿPÿq@+ðW„üûÿÿVPÿ¸q@ƒÄjhÄx@…üûÿÿPÿ5@Ú@ÿ{V4tR¿Dy@èÝüÿÿYéØ;Œ΋N;Êt
‹Ö+V+щ0Ê@+F‹Mˆ+F‹þ‰+~hÿ„q@…ÀY‰E„„“EŒPhÿ\p@…Àtnÿu„EŒjh@y@PÿXp@…ÀtV3ÀPPPÿvPÿu„jè³íÿÿƒÄ…À‰EˆtKÿvWPÿ¼q@ÿuˆèB|WÿHq@‹M€ƒÄÿuˆ‰‹E„‰ÿq@3À@ëÿèp@P¿ y@èüÿÿY3À‹_3Í^èRBÅ”ÉÃU‹ìƒìV‹5ˆr@W3ÿëEäPÿŒr@EäPÿr@jWWWEäPÿÖ…ÀuÝ_^ÉÃU‹ìƒìP¡|Á@3ʼnEüƒ}‹E‰E°tÿuÿuÿuPÿxr@é²SVWM¼QPÿ|r@‹Øj‰]¸ÿ€r@j
Y™÷ùhxy@3ÉQQQQQQQjh¼QQQPÿHp@‹=Dp@PSÿ×jS‰E´ÿ4p@¾ Æ@VèsAYPVjjS‹Pp@ÿÓhÿÿÿÿu¸ÿ8p@VèOAYPVj
j
ÿu¸ÿÓÿu´ÿu¸ÿ×PÿÉÂUl$ì¡|Á@3ʼnEl‹ExSVW‹=p@‹ñxÿÿÿQh3ÛS‰…hÿÿÿ‹E|hz@P‰…dÿÿÿ‰µ\ÿÿÿ‰tÿÿÿÿ×…Àt3Àé\SSSS…pÿÿÿPEPSÿµxÿÿÿÇ…pÿÿÿPÿp@…À…답\ÿÿÿÿ…tÿÿÿ;óÇ…pÿÿÿPt8tEPVèZ>…ÀYY…‹5Dr@EPEÌhhz@PÿÖEP…|ÿÿÿhhØ~@hèW‰u€ÇE„Ì~@‰uˆÿ r@…˜hàÚ@Pè£4…˜hÀ~@Pè†4…˜h€Æ@Pèu4¡èÛ@ƒÄ;Æt˜Qh É@h¨~@Pÿq@ƒÄSVVÿ4r@‹5”q@‰E”ÿÖ‹=´q@ƒÀ@P»Àx@Sÿu”ÿ׃Ä…ÀuPPh˜~@ÿ@r@PÿÿE”é‡E¤PEœPh`€@WÿÖƒÄ;ÃtÖE¤PEœPhL€@WÿÖƒÄ;ÃuWègùÿÿëPÿèp@;ÃtGƒøtBÿE ë=E¤PEœPh8€@WÿÖƒÄ;ÃuWèúùÿÿëE¤PEœPh$€@WÿÖƒÄ;ÃuWè	ûÿÿYÿE˜‹E˜;EŒ”þÿÿ‹u„3Ûÿvÿ€p@…ÀtÿE”ëÿE ÿèp@‹~Pè}ãÿÿY9] E¤tÿu ÿuˆÿu”hÐ@PÿDr@ƒÄëÿuˆÿu”h¨@PÿDr@ƒÄj@h”@E¤PSÿ9uôt99uøt49uðt/;Æt+3É9uhÈ@•Á‰ÿUüÿÓÿuÿuøèJþÿÿƒÄ‹ðÿUô‹ÆëƒÈÿ^[ÉÃU‹ìQEüPh4u@ÿuÿ$Ê@ƒÄ…ÀuÉÃÿuüjèÑáÿÿhèt@ÿÐÚ@ƒÄÉÃU‹ìQEüPh4u@ÿuÿ$Ê@ƒÄ…ÀuÉÃÿuüjè˜áÿÿhèt@ÿÐÚ@ƒÄÉøè'¡|Á@3ĉ„$‹„$ƒèNU‹¬$V‹´$„¹-ÂtX-ñt0H…~jÿ´$hhëUÿPr@VhìUÿ r@ëVjhhëUÿPr@èbäÿÿ3À@é6¡ðÛ@…ÀtPjhrhUÿPr@h Ç@D$hЂ@PÿDr@‹5 r@ƒÄD$PhèUÿÖh¼‚@hìUÿÖéÚ‹vþ1ÿÿÿt(þ8ÿÿÿ…ÃjjhpUÿTr@PÿXr@駋5Tr@W3ÿWWhpU‰-ØÚ@ÇDÚ@ÿÖPÿXr@WWhkUÿÖPÿœr@¿àÚ@‹÷WNèÂ%€<0\Yt
hps@Wèª%YYWè¨%UÆ0èØèÿÿYY‹Ïè³ìÿÿ…À„(Sÿ5`Ú@ÿ5HÚ@èéÿÿ‹5 r@‹Ø¡,Ê@ƒÄ…Àt€8thœ‚@hèUÿÖÿ5,Ê@è•ÝÿÿYƒ=DÚ@„Öhˆ‚@hèUÿÖhý@ÿ5Æ@ÿ5ÔÚ@WSèTÒÿÿƒÄ…Àuhd‚@èuÕÿÿYƒ=DÚ@„’ƒ=tÆ@» É@t9hH‚@hèUÿÖh4‚@hìÿ5ØÚ@ÿÖè+Ùÿÿ‹ø…ÿtjèpüÿÿYWÿôp@ƒ=DÚ@tBƒ=pÆ@t9h‚@hèUÿÖh4‚@hìÿ5ØÚ@ÿÖèàØÿÿ‹ø…ÿtjè%üÿÿYWÿôp@[_3À‹Œ$^]3Ìè^$ÄÂU‹ìƒìtSVWj,3ÛEÄSPè&$3À‰]ð}ô«j0«^V«ESP‰]Œè
$ƒÄ¿S‰uÀ‰}Äÿ`p@‹5(p@‰EÈEÀP‰]ÜÇEØô%@ÇEÌkÿÖ‰EðEÀP‰}ÄÇEÌlÇEØP)@ÿÖ‰EôEÀP‰}ÄÇEÌmÇEØu>@ÿÖ‰EøEÀP‰}ÄÇEÌnÇEØf0@ÿÖS‰EüÇEŒ4ÿ`p@‰E˜‹E‰E”Eð‰E¬EŒPÇE ‰]´‰]¼‰]¨ÇE¤ÿ,p@_^[ÉøèŸ#¡|Á@3ĉ„$SUVWÿ5ìÛ@‹=Œp@½UD$P»èt@Shàƒ@¾Øƒ@Vÿ×jPYD$º Æ@èíÒÿÿÿ5ìÛ@D$UPShЃ@Vÿ׋ÍD$º@Ê@èÈÒÿÿÿ5ìÛ@jPh€Ú@Shă@Vÿ×ÿ5ìÛ@‹-ˆp@jh´ƒ@VÿÕÿ5ìÛ@£tÆ@jh¤ƒ@VÿÕÿ5ìÛ@£pÆ@j
hPÚ@Sh”ƒ@Vÿ×ÿ5ìÛ@jPh Ç@ShŒƒ@h€ƒ@ÿ×ÿ5ìÛ@hh€Æ@Shpƒ@Vÿ×h Æ@è$áÿÿP£@Ú@èäýÿÿYYÿ5ÔÚ@ÿq@¡ìÛ@…À_^][tPÿ€p@¡ðÛ@…ÀtPÿuÇ‹B‹J‹^8ƒeÜ‹~<‰E䋉Eü‹B‰Eø‰EÔ‹ƒø‰Mì‰]ð‰MàvjþX_^[ÉËUÿ$…ŽX@‹F…Àu-Çé:ƒ}ø„~‹Mü¶ÿMø‹ÏÓâÚÿEü‰]ðƒÇƒÿrÙ¨tAû‹u93ÿWWWè‰FjEèPÆEèÆEé‹ÿvèƒÄ3Û‰F‰]ðÇé΋F ƒf…ÀtƒH0ÿöF„‰¶ÃÁà‹ËÁéÁj3ÒY÷ñ…Òuq‹Ã$<t‹EÇ@¤Ž@é€Áë‹ËƒáƒÁƒï;N$‰]ðv‹EÇ@Ž@é[3À3ÿ@ÓàWWW‰Fè‹MÁë÷ÓƒãƒË	‰F‰A0ƒÄ‰3Û‰]ðé,‹EÇ@xŽ@éƒÿs*ƒ}ø„\‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ‰]ðrÙ‹U€û‰^tÇB¤Ž@éÔf÷ÃàtÇB\Ž@éÁ‹F …Àt
‹ËÁéƒá‰f÷Ft ˆ]èjEèÁëPˆ]éÿv賋UƒÄ‰F3Û3ÿǃÿ s'ƒ}ø„ËEü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ rÜ‹U‹F …Àt‰Xf÷Ft0‹ÃÁèˆEé‹ÃÁèˆEêˆ]èjEèÁëPˆ]ëÿvè;‹UƒÄ‰F3Û3ÿǃÿs'ƒ}ø„K‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹F …Àt‹Ëáÿ‰H‹N ‹ÃÁè‰Af÷Ft ˆ]èjEèÁëPˆ]éÿvèÀ‹UƒÄ‰F3Û‰]ð3ÿÇf÷Ftjƒÿs'ƒ}ø„Å
‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹F …À‰^@t‰Xf÷Ft ˆ]èjEèÁëPˆ]éÿvèJ‹UƒÄ‰F3Û‰]ð3ÿë‹F …Àtƒ`Çf÷F„†‹V@‹Eø;ЉUôv‰Eôƒ}ôtc‹N …Ét4‹A…À‰EØt*‹A‹I+‹UôÐ;Ñv+Èë‹MôQ‹MØÿuüÈQèèƒÄf÷Ftÿuôÿuüÿvè´ƒÄ‰F‹Eô)EøEü)F@ƒ~@…Ê‹Uƒf@Çf÷Ft}ƒ}ø„«3É‹Eü¶A‰Mô‹N …ɉEØt‹Q…Ò‰UÐt‹V@;Q s	‹MЈÿF@…Àt‹Mô;MørÄf÷Ftÿuôÿuüÿvè%‰F‹E؃Ä‹Mô)MøMü…À…=‹Uë‹F …Àtƒ`ƒf@Çf÷Ft}ƒ}ø„3É‹Eü¶A‰Mô‹N …ɉEØt‹Q$…Ò‰UÐt‹V@;Q(s	‹MЈÿF@…Àt‹Mô;MørÄf÷Ftÿuôÿuüÿv苉F‹E؃Ä‹Mô)MøMü…À…£‹Uë‹F …Àtƒ`$Çf÷FtJƒÿs*ƒ}ø„v‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ‰]ðrÙ‹U·F;ØtÇBHŽ@éî
3Û‰]ð3ÿ‹F …Àt‹V3ÉAÁú	#щP,‹F ‰H03ÀPPPèä‹M‰FƒÄ‰A0éƒÿ s*ƒ}ø„ö
‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ ‰]ðrÙ‹U‹Ã%ÿ‹ËÁáÁ3ÉŠmòÁàÁëÁÉF‰B03Û3ÿÇ
ƒ~„a
3ÀPPPèù‹M‰F‰A0ƒÄǃ}„y
‹Uƒ~t‹ÏƒáÓë+ùlj]ðé
ƒÿs'ƒ}ø„J
‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹ÃƒàÑë‰F‹ÃƒàOƒèt/HtHtHu,ÇB4Ž@ÇëÇë‹Æèí÷ÿÿÇëÇ
ÁëO‰]ðOéˆ	‹ÏƒáÓë+ùƒÿ ‰]ðs*ƒ}ø„»	‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ ‰]ðrÙ‹U‹Ë‹Ã÷Ñ%ÿÿÁé;ÁtÇBŽ@é)	3Û‰F@‰]ð3ÿÇ‹F@…À‰Eô„l‹Eø9Eôv‰Eô‹Eì9Eôv‰Eôƒ}ô„?	ÿuôÿuüÿuäè‹Eô)EøEü)EìEäƒÄ)F@éɃÿs'ƒ}ø„	‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹Ãƒà‰F`Áë‹Ãƒà@Áë‰Fd‹ÃƒàƒÀÁëƒï~`‰F\‰]ðwƒ~dwƒfhÇëRÇBð@é@ƒ}ø„Š‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿrÜ‹Nh·MØŒ@¶ÃƒàÁëf‰DNpÿFh‰]ðƒï‹Fh;F\rÑë‹Fh·EØŒ@fƒdFpÿFhƒ~hræ†0Nl‰‰FL–ðRFTPQÇjFpPjèŽ
ƒÄ…À‰EÜt‹EÇ@Ô@éƒfhÇéƒ}ø„Ë‹Eü¶ÿMø‹ÏÓàØÿEüƒÇ‹NT3À@Óà‹NLH#Ë‹ÈÁé¶É;ωEØwÁ‹ÈÁéfƒùsN‹ÈÁé¶Éë"ƒ}ø„w‹Mü¶ÿMø‹ÏÓâ¶ÌÚÿEüƒÇ;ùrڶ̋FhÓë+ùf‹MÚf‰LFpÿFh‰]ðékfƒ}ÚuY¶Äëƒ}ø„'‹Mü¶ÿMø‹ÏÓâÚÿEüƒÇH;ùrÚ‹ÈÓë+ø‹Fh…À‰]ð„6·DFn‰E؋ÃàƒÀÁëOOé…fƒ}Ú¶ÔuZëƒ}ø„Ç‹Eü¶ÿMø‹ÏÓàØÿEüƒÇB;ørÚ‹ÊÓëjý‹ÃƒàƒÀÁëë7ƒ}ø„Ž‹Eü¶ÿMø‹ÏÓàØÿEüƒÇB;ørÚ‹ÊÓëjù‹ÃƒàƒÀÁëƒeØY+Êù‹Nd‹VhN`Ð;щ]ðvp‹EÇ@¸@ǃ>„߆0Nl‰‰FL–ðRFTPQÿv`Ç	FpPjèƒÄ…À‰EÜtC‹EÇ@œ@é’‹Nhf‹UØHf‰TNpÿFh…Àuì‹FdF`9Fh‚
þÿÿë‹‹EÇ@¸@é^Nl‹‰FP–ðRFXPQÿvdÇ‹F`DFpPjèƒÄ…À‰EÜt‹EÇ@„@éǃ}ør\}ìrS‹E‹Mäÿuà‰H‹Mì‰H‹Mü‰‹Mø‰HP‰^8‰~<èä‹E‹^8‹~}'‹Eà‹M;At‹Eà‹}èØíÿÿ…Àt
Çjüéïÿÿ‹}‹EÔ+G‹]à+_G_^ƒ~‰EÔt,…Ût(‹GS+Ã~PÿvtèB
ëèщF‰G0‹EÔƒÄƒ>u¹€ë3É‹V÷ÚÒƒâ@ÑV<…À‰W,u…Ûtƒ}u
ƒ}ÜuÇEÜûÿÿÿ‹EÜéuîÿÿIG@>H@×H@OI@ÍI@PJ@ìJ@†K@L@¤L@M@&M@3M@ÓM@)Mô‰Mø‹MðAŠGÿMøˆuõ‹Ï+Mì‰Mðë#+ÊMð‹Mø;Môs)Mô‹MðAŠGÿMøˆuõëÖ‹Mð‹UôƒúvLBýj3ÒY÷ñ‹Mð@ƒmôAŠGˆAŠGAˆŠGHˆuç‹Eë ‹Ï+ʃmôAŠGˆAŠGAˆŠGƒ}ôˆwäƒ}ôtAŠGƒ}ôˆvŠIGˆ;]Ôs7;}Ђ#ýÿÿë,Ç@0@ëÇ@P@ëöÁ tÇë
Ç@h@Ç‹MÁé+ÙÁá)M3ÉA‹Ñ‹MÓâJ‹Ê‹Uü#ÑK‰O‰H‹MÔ+˃Á‰H‹MÐ+ÏÁ‰H‹E_‰V8‰F<^[ÉÃUl$ ìŒ¡|Á@3ʼnE\‹E|‹UxS‹]lV‹utWj‰E3ÀY}<ó«3ÿ3É9}p‰]Ô‰UØv·KDE‰U3ÒBÓâ3Ûƒ}h‰]üJÿ‰Eà‰Uø‰U‰MÜuú°r3À@éý‹M‰MŠÈ*MˆM‹M··Ê;Mð}
ÆEf‰Uë)~‹M·	‹UèÉŠˆU‹Uäf‹f‰Më	fƒeÆE`3Ò‹È+MBÓâ‹Mø‰M‰M‹MÓë]Ÿ)U‹ÚÁã+˃}‹]‰uë3ÒHÿBÓâ‹MüëÑê…Ñuú…Òt	Zÿ#ÙÚë3ÛƒELEˆE‹M‹ÓÓê‹M‰—3ÒHÿBÓâëÑê…Óuú…ÒtJÿ#ËÊ‹Ùë3Û…Ûu²‹E‹MÁà‹E؉3À‹M\_^3Í[訃Å`ÉÃU‹ìS‹]V‹uW3À‹þ@Áïæÿÿ;Øu$‹E¶ð¸ñÿ;ðr+ðþ;ø‚Ù+øéÒ‹M…Ʉ΃û‚û°‚ȋû°3Ò÷ó‹]‰Eë°¸[¶ò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Q	þò¶Q
þò¶Qþò¶Qþò¶Q
þò¶Qþò¶QþòþƒÁH…wÿÿÿ‹Æ3Ò¾ñÿ÷ö‹Ç¿ñÿ‹ò3Ò÷÷ÿM‹ú…Iÿÿÿ…Û„âƒû‚¾‹ÃÁè¶ò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Qþò¶Q	þò¶Q
þò¶Qþò¶Qþò¶Q
þò¶Qþò¶QþòƒëþƒÁH…tÿÿÿë+¶KðAþ…Ûuó¹ñÿ;ñr+ñ‹Ç3Ò÷ñ‹Âë&¶KðAþ…Ûuó‹Æ¹ñÿ3Ò‹ñ÷ö‹Ç‹ò3Ò÷ñ‹ú‹ÇÁàÆ_^[]ÃU‹ìQƒ}SVW÷йÿtöÂt¶3Ø#ÙÁè3˜@BÿMuäƒ} j‹ò_‚ž‹UÁê‰Uü3÷‹ÐÁê¶Ü#Ñ‹•˜”@3˜˜@‹Ø#ÁÁë3˜@3…˜œ@3÷‹ÂÁè#Á‹…˜”@¶Þ3˜˜@‹Ú#ÑÁë3˜@3•˜œ@3÷‹ÐÁê¶Ü#Ñ‹•˜”@3˜˜@‹Ø#ÁÁë3˜@3…˜œ@3÷‹ÂÁè#Á‹…˜”@¶Þ3˜˜@‹Ú#ÑÁë3˜@3•˜œ@3÷‹ÐÁê¶Ü#Ñ‹•˜”@3˜˜@‹Ø#ÁÁë3˜@3…˜œ@3÷‹ÂÁè#Á‹…˜”@¶Þ3˜˜@‹ÚÁë3˜@#Ñ3•˜œ@3÷‹ÐÁê¶Ü#Ñ‹•˜”@3˜˜@‹Ø#Áƒm Áë3˜@3…˜œ@3÷‹ÂÁè#Á‹…˜”@¶Þ3˜˜@‹ÚÁë3˜@#Ñ3•˜œ@ÿMü…kþÿÿ9}rD‹UÁê‰Uü3)}‹ÐÁê#Ñ‹•˜”@¶Ü3˜˜@‹ØÁë3˜@#Á3…˜œ@÷ÿMü‹ÂuŃ}t¶3Ð#ÑÁè3•˜@FÿMué_^÷Ð[ÉËT$…Òu3ÀÃÿt$‹D$èžýÿÿYÃÌÿ%\q@ÿ%`q@ÿ%hq@ÿ%lq@ÿ%pq@;
|Á@uóÃé‚ÌQL$+ȃáÁÉÁYé*QL$+ȃáÁÉÁYéÿ%Àq@ÌÌÌÌÌÌÌÌÌÌÌÌÌÌQL$+ÈÀ÷Ð#È‹Ä%ðÿÿ;Èr
‹ÁY”‹‰$Ã-…ëéh!k@趡øÅ@Ç$ÄÂ@ÿ5ôÅ@£ÄÂ@h´Â@h¸Â@h°Â@ÿüq@ƒÄ…À£ÀÂ@}jèÒYÃjXh8±@èº3Û‰]ä‰]üE˜PÿÌp@ÇEüþÿÿÿÇEüd¡‹p¿üÛ@jVWÿÐp@…Àt;Æu3öF‹ÞëhèÿÔp@ëÚ3öF¡øÛ@;Æu
jè]Yë/¡øÛ@…Àu ‰5øÛ@hÌr@hÄr@è*YY…Àté.‰5ÌÂ@¡øÛ@;ÆuhÀr@h¸r@èûYYÇøÛ@…ÛuSWÿØp@ƒ=Ü@thÜ@èdY…ÀtjjjÿÜ@¡r@‹0‰uàŠ< wL„Àtƒ}äuBŠ„Àt
< wF‰uàëðöEÄt·EÈëj
XPVjh@è
Üÿÿ£ÈÂ@ƒ=¼Â@u[Pÿr@<"u3É9Mä”Á‰Mä¶ÀPÿr@Y…ÀtF‰uàF놋Eì‹‹	‰MÜPQèEYYËeè‹EÜ£ÈÂ@ƒ=¼Â@uPÿr@ƒ=ÌÂ@uÿr@ÇEüþÿÿÿ¡ÈÂ@ë3À@ËeèÇEüþÿÿÿ¸ÿè-Ãf=@MZt3ÀëQ¡<@¸@PEuë·ˆ@ùtùuÔƒ¸„@vË3É9ˆø@냸t@v¸3É9ˆè@•Á‹Áj£¼Â@ÿPq@jÿÿTq@YY£Ü@£Ü@ÿ0r@‹
Æ@‰ÿ,r@‹
üÅ@‰¡(r@‹£ôÛ@èúèÙƒ=œÁ@uhál@ÿ$r@Yè–ƒ=˜Á@ÿu	jÿÿ r@Y3ÀÃè¨é5ýÿÿU‹ìì(£ØÃ@‰
ÔÃ@‰ÐÃ@‰ÌÃ@‰5ÈÃ@‰=ÄÃ@fŒðÃ@fŒ
äÃ@fŒÀÃ@fŒ¼Ã@fŒ%¸Ã@fŒ-´Ã@œèÃ@‹E£ÜÃ@‹E£àÃ@E£ìÃ@‹…àüÿÿÇ(Ã@¡àÃ@£ÜÂ@ÇÐÂ@	ÀÇÔÂ@¡|Á@‰…Øüÿÿ¡€Á@‰…Üüÿÿÿ¼p@£ Ã@jèlYjÿÀp@hÈ°@ÿÄp@ƒ= Ã@ujèHYh	Àÿlp@PÿÈp@ÉÃÌÿ%øq@jh`±@èäÿ5Ü@‹5$q@ÿÖY‰Eäƒøÿuÿuÿ q@YëajèYƒeüÿ5Ü@ÿÖ‰Eäÿ5Ü@ÿÖ‰EàEàPEäPÿuè׉EÜÿuä‹5Tq@ÿÖ£Ü@ÿuàÿփģÜ@ÇEüþÿÿÿè	‹EÜè Ãjè•YÃÿt$èXÿÿÿ÷ØÀ÷ØYHÃVW¸(±@¿(±@;Ç‹ðs‹…ÀtÿЃÆ;÷rñ_^ÃVW¸0±@¿0±@;Ç‹ðs‹…ÀtÿЃÆ;÷rñ_^ÃÌÿ%r@ÌÌÌÌ‹L$f9MZt3ÀËA<Á8PEuð3Éfx”Á‹ÁÃÌÌÌÌÌÌÌ‹D$‹H<È·ASV·q3Ò…öWDv‹|$‹H;ùr	‹XÙ;ûrƒÂƒÀ(;Öræ3À_^[Ãjh€±@ènƒeüº@RèsÿÿÿY…Àt=‹E+ÂPRè’ÿÿÿYY…Àt+‹@$Áè÷ЃàÇEüþÿÿÿë ‹Eì‹‹3É=À”Á‹ÁËeèÇEüþÿÿÿ3ÀèTÃÿ%r@ÿ%r@ÌÌh•l@dÿ5‹D$‰l$l$+àSVW¡|Á@1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mðd‰
Y__^[‹å]QÃÿt$ÿt$ÿt$ÿt$h°e@h|Á@è܃ÄÃVhh3öVèуÄ…Àt
VVVVV躃Ä^Ã3ÀÃU‹ìƒì¡|Á@ƒeøƒeüSW¿Næ@»;Ç»ÿÿt
…Ãt	÷У€Á@ë`VEøPÿ¨p@‹uü3uøÿ¬p@3ðÿ°p@3ðÿ´p@3ðEðPÿ¸p@‹Eô3Eð3ð;÷u¾Oæ@»ë…óu‹ÆÁàð‰5|Á@÷Ö‰5€Á@^_[ÉÃÿ%Lq@ÿ%q@ÿ%q@ÿ%q@ÿ%(q@ÿ%,q@ÿ%0q@ȹֹ>º.ºº
ºú¹ê¹¶¹µô´n¹R¹B¹0¹z¹Š¹˜¹b¹r¶†¶–¶ª¶º¶Î¶â¶ö¶
··2·@·T·l·0µ@µTµd¶ÔµzµÊ¾´¾ž¾Ž¾t¾`¾B¾&¾¾¾â½Ú½Ä½µžµ¬µÄµR¶F¶8¶"¶¶¶ôµjµâµL½V½d½l½v½ˆ½¢½´½ä¾ú¾¿¿¿ð¾6½$½½žº¨º²º¼ºÆºÐºÚºäºôºþº»»»$»2»<»J»T»\»d»l»t»~»ˆ»’»ž»¨»²»¼»Ê»Ô»Þ»ê»ô»þ»¼¼¼"¼,¼B¼P¼`¼j¼r¼€¼Ž¼–¼ ¼¬¼º¼Ð¼ä¼ô¼½ ¿–·¤·°·¹
¹ô¸è¸Ø¸È¸º¸¬¸š¸ˆ¸z¸j¸X¸J¸6¸*¸¸¸ò·ê·Þ·Î·¼·pº„º^º+f@Uh@CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissilSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueError__builtin__PyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_InitializePyErr_PrintPy_SetProgramNameOut of memory!rbRunning the pre-installation script failed
Can't load Python for pre-install scriptaRuntime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** Could not load Python ****** run_installscript: internal error 0x%X ***
freopen stdoutfreopen stderr300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...if exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removed%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.install_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfoSetuptitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

incorrect length checkincorrect data checkinvalid distance too far backinvalid distance codeinvalid literal/length codeinvalid distances setinvalid literal/lengths setinvalid bit length repeatinvalid code lengths settoo many length or distance symbolsinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression methodincompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionary0@$@èt@@@üŽ@èŽ@ØŽ@ÀŽ@èt@ inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScsƒ£ÃãÉÄ	
!1AaÁ 0@`@@–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”ÞñîÀFÀFÀFÐÂ@(Ã@H|Á@ ±@•lþÿÿÿˆÿÿÿþÿÿÿº.ºº
ºú¹ê¹¶¹µô´n¹R¹B¹0¹z¹Š¹˜¹b¹r¶†¶–¶ª¶º¶Î¶â¶ö¶
··2·@·T·l·0µ@µTµd¶ÔµzµÊ¾´¾ž¾Ž¾t¾`¾B¾&¾¾¾â½Ú½Ä½µžµ¬µÄµR¶F¶8¶"¶¶¶ôµjµâµL½V½d½l½v½ˆ½¢½´½ä¾ú¾¿¿¿ð¾6½$½½žº¨º²º¼ºÆºÐºÚºäºôºþº»»»$»2»<»J»T»\»d»l»t»~»ˆ»’»ž»¨»²»¼»Ê»Ô»Þ»ê»ô»þ»¼¼¼"¼,¼B¼P¼`¼j¼r¼€¼Ž¼–¼ ¼¬¼º¼Ð¼ä¼ô¼½ ¿–·¤·°·¹
¹ô¸è¸Ø¸È¸º¸¬¸š¸ˆ¸z¸j¸X¸J¸6¸*¸¸¸ò·ê·Þ·Î·¼·pº„º^ºdPropertySheetACreatePropertySheetPageACOMCTL32.dll(SetLastErrorKCreateDirectoryA^GetFileAttributesAhMapViewOfFileTCreateFileMappingA4CloseHandleSetFileTimeDosDateTimeToFileTimeqGetLastErrorSCreateFileAqUnmapViewOfFileÌlstrlenA GetProcAddressRLoadLibraryAuMultiByteToWideCharøFreeLibrary\LocalFreeóFormatMessageAcGetFileSizeÓGetTempFileNameAÕGetTempPathAGetModuleHandleAÒResumeThread1SetPriorityClassBGetCurrentProcessEGetCurrentThreadDSetThreadPriorityfCreateProcessA}GetModuleFileNameAƒDeleteFileAÄRemoveDirectoryA–GetPrivateProfileIntAœGetPrivateProfileStringAKERNEL32.dllßMessageBoxAGetFocus×wsprintfASSetDlgItemTextA;SendMessageA*ReleaseDCGetDC¡DispatchMessageAªTranslateMessagePeekMessageAÈEndPaint]GetSystemMetrics
BeginPaintŽDefWindowProcA¼UpdateWindow’ShowWindow`CreateWindowExARegisterClassAºLoadCursorAìMoveWindowtGetWindowRectPostMessageAEGetParent6SendDlgItemMessageAGetDlgItemMSetCursorUSER32.dll3CreateDIBitmapDeleteObject<SetTextColorNTextOutASetBkModeSelectObject9CreateFontAPCreateSolidBrushGDI32.dllöRegQueryValueAËRegCloseKey÷RegQueryValueExAÞRegEnumKeyExAìRegOpenKeyExARegSetValueExAÑRegCreateKeyExAÔRegDeleteKeyAØRegDeleteValueAADVAPI32.dlliCoUninitializeCoCreateInstance;CoInitializeole32.dllWstrchr/memcpy3memsetastrncatUstrcat`strlenZstrcpyz_localtime64Ñ_time64nstrtolífree$malloc6_putenv³_fstat64i32æfprintf¢__iob_funcDremoveìfreadõftellófseekäfopenÙfcloseÜfflushîfreopenq_snprintfdstrncpyXstrcmphstrrchr_vsnprintfSsscanføfwrite_strftimeOsprintf
isspace>qsortCreallocßfgetscstrncmp‹__argvŠ__argcMSVCR80.dll_amsg_exit __getmainargs/_cexit_exitg_XcptFilter+_ismbbleadÖexit_acmdln
_initterm_initterm_e?_configthreadlocaleé__setusermatherr_adjust_fdivÌ__p__commodeÐ__p__fmodem_encode_pointeræ__set_app_typeN_crt_debugger_hookí_unlock—__dllonexit|_lock"_onexitc_decode_pointerv_except_handler4_common_invoke_watsonB_controlfp_s)InterlockedExchangeVSleep&InterlockedCompareExchange·GetStartupInfoA^TerminateProcessnUnhandledExceptionFilterJSetUnhandledExceptionFilter9IsDebuggerPresent£QueryPerformanceCounterßGetTickCountFGetCurrentThreadIdCGetCurrentProcessIdÊGetSystemTimeAsFileTime¬_strnicmpž_strdup¢_stricmp<_close=_read#_openÏ_tempnamÿÿÿÿìt@èt@àt@èt@Øt@èt@Ðt@Ät@¼t@èt@ìt@¨t@àt@¨t@Øt@èt@Ðt@Ät@¼t@èt@Software\Microsoft\Windows\CurrentVersion\Uninstallt@€t@pt@Pt@8t@ t@t@øs@ès@Üs@Ìs@—@´s@t@¤s@õ@”s@>@€s@<>@ts@¦@Software\Microsoft\Windows\CurrentVersion\UninstallNæ@»±¿Dÿÿÿÿÿÿÿÿþÿÿÿ(€@€p€nˆ€k €l¸€mЀn耀	(	8	H	X	hxá
ä€ë ä íä$ïZä€ñä”òRä(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnPAÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ
  
    
      
    
  
PAPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGX././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-9.0-amd64.exe0000644000175100001710000066600000000000000025041 0ustar00runnerdockerMZÿÿ¸@ðº´	Í!¸LÍ!This program cannot be run in DOS mode.

$‚ÒÇÆo¼”Æo¼”Æo¼”{ *”Áo¼”Ø=8”ào¼”Ø=)”Ío¼”á©Ñ”Äo¼”á©<”Ço¼”á©Ç”Éo¼”Æo½”`o¼”Ø=?”Lo¼”Ø=(”Ço¼”Ø=-”Ço¼”RichÆo¼”PEd†
©Ið#	Zã@à±Å€¼# Àð ´àuph.textXZ `.rdataÀÅpÆ^@@.dataäY@$@À.pdata´ <@@.rsrcðÀX@@H…ÉtŠ„Àt
PKuÌA}PKu¿N ƒÂ.HcÂHÃH‰D$P¿FÈ¿FÐI¿EÑH;‰T$HI¿UHÐHcÅHÊH”$€HDI‹ÈI+ÐH‰D$pŠˆ
HÿÁA:ÄuóHƒÉÿ3ÀH¼$€ò®H”$€HÿÊH÷Ñ€|ÿ\H‰T$`tH¼$€HƒÉÿò®·laf‰GÿHŒ$€ÿ
]HcÈH„€H‰D$hH‹D$@Hƒ8tBL‹ÈI‹9H‹T$PHƒÉÿ3Àò®H÷ÑLAÿI‹	è1-…À„ÿH‹L$@IÿÄM‹ÌIÁáLÉIƒ9uÁM¿EH‹T$PHŒ$€è.zL‹d$`HŒ$€è,úÿÿHƒÉÿ3ÀH¼$€ò®H‹|$hH÷ÑB€|!ÿ\L‹d$Xt\·FD‹NL‰d$0f‰D$(·FH”$€L‹Ç3Éf‰D$ èÊúÿÿH…Àt*‹NE¿ED‹NH‹T$pL‰d$(‰L$ H‹Èè—üÿÿ…À„
þÿÿM…ätE¿DôEOH‹×¹AÿÔA¿DôAÿÇD;øÅ‹T$HL‹D$xE3äéæýÿÿH‹T$@MäIƒÊÿJ‹<âN‹Dâ3ÀI‹Êò®H¼$€H÷ÑLIÿI‹Êò®3ÒAŠHÿˆDþ„ÀuñL‹d$`E¿E3ÀH¼$€I‹ÊIcÑHT$Pò®E+ÁH÷ÑBŠD!ÿ<\tLD$ H²^H‹ËÿEY…À„‘Hƒ=Õ>t©3ÛH=
'H‹T$ H‹èIp…ÀtÿÃHƒÇƒû
räH‹
oiHP^ëGHÏ&HcÃE3ÉHÀ3ÉD‹ÂHT$0ÿ}>…ÀtHT$0H
1^ÿ¯këH‹
ÞlHï]L‹D$ ÿ´X3ÀH‹Œ$@H3ÌèwH‹œ$`HÄP_ÃÌ@SHìÀH‹ð'H3ÄH‰„$°Hƒ¤$€Hƒd$hƒd$XHƒd$xHƒd$PHƒd$`3ÉH‹ÚÿlZ…ÀyH_H‹
JlD‹Àÿ)XéßHD$XLŒ$L„$ˆH‰D$@HD$hHÎ^H‰D$8HD$xH‹ËH‰D$0H„$€H‰D$(HD$pH‰D$ ÿÇW…Àu3ÀéÓHD$P»L
ӜH
Œ¾3ÒD‹ÃH‰D$ ÿ´Y…ÀyH9^éSÿÿÿH‹L$PLD$`Hû®H‹ÿ…ÀyHë]é-ÿÿÿH‹L$PH‹”$ˆH‹ÿ …ÀyH¥]éÿÿÿH‹L$PH‹”$H‹ÿP8…ÀyHZ]éäþÿÿH‹”$€H…ÒtH‹L$PH‹ÿPX…ÀyH]é¼þÿÿH‹T$hH…Òt#H‹L$PD‹D$XH‹ÿˆ…ÀyHÅ\éþÿÿH‹T$xH…ÒtH‹L$PH‹ÿPH…ÀyHx\éjþÿÿL‹D$pH„$ AƒÉÿ3Ò3ÉÇD$(H‰D$ ÿ›UH‹L$`H‹H”$ D‹ÃÿP0…ÀyGL‹D$pH‹
mjHî[D‹ÈÿEVH‹L$`H…ÉtH‹ÿPH‹L$PH…ÉtH‹ÿPÿ?XéOþÿÿH‹L$`H‹ÿPH‹L$PH‹ÿPÿXH
ÿZÿÑhH‹Œ$°H3ÌèQtHÄÀ[ÃL‹ÜHƒìHIKH‹ÂMK I‰KØMCèH»\H‹Èÿ¦U…Àu3Àë-ÿèVD‹L$`L‹D$hH‹T$0H‹Èÿ0WH
\‹ÐÿYhHƒÄHÃH‹
="Hÿ%¦eÌÌH‰\$WHì°H‹À$H3ÄH‰„$ H‹ÙLKhHl\HŒ$ÇD$ ÿ^VHŒ$è™H‹ËÿTH…À…µD‹
pgD‹-eHò[HL$0ÿVLL$ L„$€HT$0HÇÁ€ÿÐQ…Àt'LL$ L„$€HT$0HÇÁ€ÿ­Q…Àt3ÀëK3ÀHƒÊÿH¼$€H‹Êò®·óWH‹Êf‰Gÿ3ÀH¼$€ò®3ÉŠHÿÁˆDþ„ÀuòHŒ$€ÿZSH‹Œ$ H3ÌèªrH‹œ$ÈHÄ°_ÃÌH‰\$UVWATAUAVAWHƒì H
\H‹ÙÿSHå[H‹ËH‹øÿ	SHº[H‹ËL‹ðÿöRH—[H‹ËH‹ðÿãRHt[H‹ËL‹øÿÐRHI[H‹ËH‹èH‰D$hÿ¸RH![H‹ËL‹àÿ¥RHöZH‹ËL‹èÿ’R3ÛH‰D$pH;û„ÇH;ó„¾L;ó„µL;û„¬H;ë„£L;ã„šL;ë„‘H
Zÿ×H‹øH;Ãt[HlZH‹ÈÿÖHXZH‹ÏH‰fcÿÖH-m!H‹õH‰gHcË3ÒHÁáHÍAÿ×H‹H‹ÏL‹ÀAÿÖÿÃHƒÆ ƒûrÚH‹l$hH‹D$pH‰-œeL‰%­RH‰îb3ÀL‰-¥Rë¸H‹\$`HƒÄ A_A^A]A\_^]ÃÌ@UATAUAVAWHì€Hl$ H‰H‰µ˜H‰½ H‹Æ!H3ÅH‰EXH‹úHÕZI‹ÙMcàL‹éH‰MÿJQH«ZI‹ÍH‰Eÿ6QHZI‹ÍL‹ðÿ#QH\ZI‹ÍH‰EÿQH YI‹ÍL‹øÿüPHYI‹ÍH‹ðÿéPHbYI‹ÍH‰E ÿÕPH‹MH:YL‹èÿÁP3ÉH9M„™L;ñ„H9M„†L;ù„}H;ñ„tL;é„kH;Á„bH9M „XH;ù„H8„@3ÒH‹Ïè‹ðƒøÿu èÕ‚H^YL‹ÇHH`袀FéH‹
dL$Yºìÿ	SÿUH‹MèÍüÿÿL-Ž63ÒI‹ÍA¸èÎhI‹üE…ä~2M‹åL‹ïL+ãH‹H…ÉtèTöÿÿë3ÀI‰HƒÃIƒíuáD‹çL-D6I‹ÕA‹ÌAÿÖ3ÛH…ÿ~I‹LÝH…Étè!wHÿÃH;ß|éHU(‹Î»è­{…ÀuPD‹Eþÿÿéœÿ“JLØRHT$ H‹ÈA¹0ÿØJëyH‹
G]H…ÉtH›RL‹„$XèŽxH‹Œ$Xº.èH…ÀtBH=lRH‹ð¹ó¦u/H‹Œ$Xè'îÿÿë H‹
î\H…ÉtL‹„$XH"Rè5x¸H‹Œ$ H3ÌègHÄ8_^ÃÌÌH‹ÄH‰XH‰hH‰p WHƒì@Hƒ`èE3ÉH‹òÇ@à€EAº€Ç@Øÿ˜GH‹ØHƒøÿu3ÀëiHT$`H‹ÈÿmFHƒd$(ƒd$ E3É3ÒH‹ËEA‹èÿ†GH‹ËH‹øÿrGHƒÿÿt½Hƒd$ E3ÉE3ÀAQH‹ÏÿcGH‹ÏH‹ØÿGG‰.H‹ÃH‹\$PH‹l$XH‹t$hHƒÄ@_ÃÌH‰\$WHƒì0Hƒ=âGH‹ùtQHƒ=Ý[uGÿ•IL‹ÆGƒd$(E‹H
IPH‹ÈMÈA¸H‹ØH‰T$ ÿßDH‹ÓH‹ÏH‰š[ÿ\IH‹\$@HƒÄ0_ÃÌ@SUVWATAUAVHì`H‹¯H3ÄH‰„$PL‹¬$À‹ÂE3ö+TúM‹á+TöM‰uM‰1ƒê"HcÚHÙ|êPK…;{V4tHÏP3ÉèÐûÿÿéA;ÖŒ÷D9stHcCH‹ËH+ÈHcCH+ÈH‰
äF+SH{½+H‹ÍA‰HcH+ØèÉmH‹ðI;Æ„®HT$@‹Íÿ4DA;Æ„„HLPHL$@L‹ÎE3ÀÿDA;ÆtgD‹E3ÀL‰t$0AHH‹ÖfD‰t$(fD‰t$ èûãÿÿH‹èI;ÆtPLcH‹ÓH‹ÈèÕzHƒÉÿ3ÀH‹ýò®H÷ÑHËèc¼H‹ÍI‰EI‰4$ÿ6E¸ëÿ9EH¢O‹ÈèËúÿÿ3ÀH‹Œ$PH3ÌèAdHÄ`A^A]A\_^][ÃÌÌÌHƒìhëHL$0ÿƒGHL$0ÿ€GHL$0E3ÉE3À3ÒÇD$ ÿmG…ÀuËHƒÄhÃ@SUVWHìØH‹ÙH3ÄH‰„$ÀH‹éƒútÿGé&HT$pÿG¹H‹ðÿúFE3ɋиgfffE3À÷ê‹Â3ÒÁø‹ÈÁéÁH
&OH‰L$h3ɉL$`‰L$X‰L$P‰L$H‰L$@‰L$8‰L$0‹ÈÇD$(ÇD$ ¼ÿBH‹ÎH‹ÐÿBºH‹ÎH‹ØÿþAHƒÉÿ3ÀH=™@L
’@ò®PH÷ÑD‹ÂHÿɉL$ H‹Îÿ×AºÿÿÿH‹ÎÿÑAHƒÉÿ3ÀP
H=Y@L
R@ò®D‹ÂH÷ÑHÿɉL$ H‹ÎÿšAH‹ÓH‹Îÿ~AH‹Èÿ•AHT$pH‹Íÿ÷E3ÀH‹Œ$ÀH3Ìè…bHÄØ_^][ÃÌH‰\$H‰t$H‰|$ AT¸Àèí0H+àH‹SH3ÄH‰„$°HUþÿÿH‹Ù3ö3ÉÇD$`H‰D$h‰t$t‰t$pÿgAº3ÉH‰´$€H‰D$xÿ%E¹€H‰„$ˆÿò@L%ãMHL$`L‰¤$ H‰´$˜H‰„$ÿðDf;ÆuH‹
|SLMHvME3ÉÿÝDHVMHŒ$°L‹Ãÿ]D3ÉÿÍ@¹H‹ØÿÏD¹‹øÿÂDH‰t$XH‰\$PH‰t$HH‰t$@‰|$8‰D$0L„$°E3ÉI‹Ô3ɉt$(‰t$ ÿ`DH‹ÈºH‹ØÿÿCH‹ËÿVDH‹ÃH‹Œ$°H3ÌèaLœ$ÀI‹[I‹s I‹{(I‹ãA\ÃÌH‰\$WHƒì@HT$0H‹ùÿàC3Éÿ D¹‹ØÿD‹L$0D‹T$HïKHL$0ÿ¤BLD$0ºèH‹ËÿYCLzAºýH‹ËÿDCLÅSºH‹Ëÿ/Cë'Ay8ÿÿÿuÿ…BA¹E3ÀH‹ÈºpÿvB3ÀH‹Œ$0H3Ìè\_HÄ@[ÃÌÌÌH‰\$H‰l$ VWATHì`H‹4H3ÄH‰„$PH‹êHD$HI‹øL‹áHìKA¹E3ÀH‹ÍH‰D$ 3öÿ“=…Àt3ÀéH!t$8H!t$0H!t$(H!t$ ÇD$@P3Òé1ÿÆÇD$@PH…ÿt-€?t(HT$`H‹ÇH+׶D¶A+ÈuHÿÀE…Àuë…É…ÛLD$`H5KHŒ$ÿGALD$`HëJHŒ$°ÿ-AL\$PH”$°A¹E3ÀH‹ÍL‰\$ ÿÑ<…Àu¹èçfÇD$DH‹ØH…ÀtZH‹L$PHD$DE3ÉH‰D$(E3À3ÒH‰\$ ÿy<…Àu4LŒ$E3Àº€I‹ÌÿlAL‹ËºšI‹ÌLcÀH‰«ÿQAH‹L$Pÿ&<Hƒd$8Hƒd$0Hƒd$(Hƒd$ ‹ÖH‹L$HLL$@LD$`ÿï;…À„²þÿÿH‹L$Hÿä;¸H‹Œ$PH3Ìè_]Lœ$`I‹[0I‹k8I‹ãA\_^ÃÌÌÌH‰\$WHƒì0HD$@H–A¹E3ÀHÇÁ€H‰D$ ÿ«;3Û‹ø;ÃuH‹L$@ÿp;;û”ËÃH‹\$HHƒÄ0_ÃÌÌ@SHƒì H‹?HÇÀH;ÃtKH=€uè‚ÿÿÿ…Àu:H‰ë1LÒIH£IA¹ÿ×?èVÿÿÿ÷ØHÉH÷ÙHËH‰
è
HƒÄ [ÃÌ̃ù~HtÃuƒúHg}Hþ
ÃÌH‰l$H‰t$H‰|$ AUAVAW¸PèÍ*H+àH‹3
H3ÄH‰„$@ƒêNH‹ñ„ª3ÿêÂt+ƒú…í½þfD;Å…ÞIÁèfD;„9éËH‹ QH;ÇtE3ɺA¸rH‰D$ ÿº>½þH‹Î‹Õÿ¢>L5‹MHÇ€H‹ÈM‹ÆèIüÿÿ‹ÕH‹Îÿ~>M‹ÆHÇ€H‹Èè,üÿÿE3ÉA¸‹‹ÕH‹ÎH‰|$ ÿ[>L‹è;Çt!ƒøÿtHÿA¸†‹ÕLcÉH‹ÎH‰|$ ÿ3>ŠM@:Çt4H	IHŒ$@M‹Æÿè=L„$@ºèH‹Îÿš>ŠÜLD;ïuD@:Çt"H{HHŒ$@M‹Æÿª=H”$@ëH)HLHA¹H‹Îÿë=H‹Îÿª=A½E3ÀH‹ÈM‹Íºpÿ˜=E3ÉA¸ˆ‹ÕH‹ÎH‰|$ ÿo=H‹ÎL‹ðƒøÿu\ÿf=EMþE3ÀH‹ÈºpÿY=Lâ@ºïH‹ÎÿÔ=LÍ@ºðH‹Îÿ¿=Š¹@ˆ»Nˆ•:éôÿ
=M‹ÍE3ÀH‹Èºpÿþ<McöA¸™‹ÕH‹ÎM‹ÎH‰|$ ÿÒ<L=sNH‹ˆI‹×H‰
"H+ЊˆHÿÀ@:ÏuóM‹ÇºïH‹Îÿ9=M‹ÎA¸Š‹ÕH‹ÎH‰|$ ÿ€<ÿÀHcÈè:bL‹èH;ÇtgM‹ÎA¸‰‹ÕH‹ÎH‰D$ ÿU<L
^MLKH€FI‹Íè|rƒøu"D‹
E3ÉH‹ÈH‹Öÿ«/H‹L$HÿØ*H‹ÍèŒTH‹\$@H‹l$PH‹t$XHƒÄ0_ÃÌÌÌH‰\$H‰l$H‰t$ WHƒì0H‹ñ褺[H‹ÈH‹èèlEH‹øH…À„ÄHHº]èREH‹ØH…À„ªHHº=Æè5EH…À„ÆH‹
2úHD$HHWA¹E3ÀH‰D$ ÿM*…Àtÿƒ.L,;E3ÉH‹ÈH‹ÖÿÍ.ë?H‹L$HHSÿü)…Àt!ƒøtÿM.Lv=E3ÉH‹ÈH‹Öÿ—.H‹L$HÿÄ)H‹ÍèxSH‹\$@H‹l$PH‹t$XHƒÄ0_ÃÌÌÌ@SHƒì º:ètDH‹ØH…ÀtHÿþ臅ÀuñH‹Ëÿœ+HƒÄ [ÃÌÌ@SHƒì º:èE3ÉE3À3Éÿ€,¸é¶H‹rH=ß=¹ó¦t	H»=ëËH‹HH¦=è~H‹ðH…Àu	Hz=몹Pè²QH‹øH‰D$8H…ÀuHJ=3ÉèSßÿÿéNHL$PL‹ÆºèlH…À„¦HƒÉÿ3ÀH|$Pò®H÷ÑHÿÉHcùH‹Ù¾LIƒÆE;ý|$AƒÅ
H‹ÏIcÕHÁâèH‹øH‰D$8H…À„JÿÿÿHL$PL‹ÆºèÉH…À…]ÿÿÿD‹õH‹Îè­bMcÿL
ãøÿÿI‹×A¸H‹Ïè‹LC<Hô;A¹$3Éÿ+ƒø…CE3íHÇö€HP.M…ÿŽŽJ‹<ïH‹ÃH+û¶¶8+ÊuHÿÀ…ÒuîH‹|$8…É„YJ‹ïLL$PLD$0Hi;H‹Ëè¥`ƒøu7Ht$PH=X7Hó¦u
HǦõ€ë
èûéÿÿ…À„.H‹|$8éLL$PLD$0H;H‹ËèP`H‹Ëƒøuèüÿÿ…ÀtzAÿÆéÎLL$PLD$0Hº:è!`H‹Ëƒøuè¤ûÿÿ…ÀtKAÿÄéŸLL$PLD$0Hs:èò_H‹ËƒøtÑLL$PLD$0H=:èÔ_H‹Ëƒøuè3ùÿÿë\ÿ['ƒøtQƒøtLÿÅëHLL$PLD$0Hì9è›_H‹Ëƒøuè
úÿÿë#LL$PLD$0H¯9èv_ƒøuH‹ËèiûÿÿIÿÅM;ïŒrþÿÿH‹|$@H‹Oÿª&…Àt#AÿÄë1ÿÛ(A¹E3ÀH‹ÈH9éüÿÿÿÅÿ»&H‹W‹ÈèPÜÿÿE‹ÎE‹ÄHL$P…ítHr8‰l$ ÿˆ(ë
H78ÿy(L8HT$PA¹@3ÉÿÇ(èŠöÿÿ3ÀH‹Œ$PH3ÌèxELœ$`I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰l$ VWATHìH‹8öH3ÄH‰„$€H‹^3ÿ‹ÚE3ÀL‹áëH‹@AÿÀH…ÀuôH‹
‡9A·ÀºëÁàDBE3ÉH‰D$ ÿá'H‹
b9H!|$ ºëE3ÉDBÿÃ'H‹-ü3öH…턘÷ÛÛƒãL‹EHw9HL$0ÿÆÿj'HL$0AÿÔ…ÀtÿÇL‹EDKcHE9HL$0ÿB'HT$0¹è·ÛÿÿH‹
Ü8Hƒd$ ºëLcÎDBÿ<'L‹EH‹
¹8ºìÿÆ'H‹mH…í…oÿÿÿ‹ÇH‹Œ$€H3ÌèDLœ$I‹[0I‹k8I‹ãA\_^ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì D‹êHí-H‹Ùÿl$H.H‹ËH‹øÿY$H’-H‹ËH‹ðÿF$H-H‹ËH‹èÿ3$H”8H‹ËL‹àÿ $Hq8H‹ËL‹ðÿ
$3ÉH9
”u3ÀëGH;ùt?H;ñt:H;ét5L;át0L;ñt+H;Át&D;é•Á‰H
)5ÿÖÿ×A‹ÕI‹ÌèÆýÿÿ‹ØÿÕ‹ÃëƒÈÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A^A]A\ÃHƒì(H‹ÊLD$@HÉ)ÿ_$…Àu3ÀëH‹T$@¹èÚÿÿH
Q)ÿ#7HƒÄ(ÃÌÌHƒì(H‹ÊLD$@H…)ÿ$…Àu3ÀëH‹T$@¹èÐÙÿÿH

)ÿß6HƒÄ(ÃÌÌ@SUVWAT¸@èçH+àH‹MóH3ÄH‰„$0ƒêNI‹ñH‹Ù„ØêÂtcêñt5ƒú…ºëM‹È3ÿDBH‰|$ ÿù$L‹ÆºìH‹Ëÿˆ%ëºëL‰L$ E3ÉDBÿÏ$è¦Ýÿÿ¸é¶H‹73ÿH;ÇtE3ɺA¸rH‰D$ ÿ™$Lš Hƒ7HL$0ÿX$LD$0ºèH‹Ëÿ
%LF7ºìH‹Ëÿø$éGAy1ÿÿÿt0Ay8ÿÿÿ…/ÿ=$A¹E3ÀH‹Èºpÿ.$é
H‰
š5ÇØ2ÿ
$E3ÉE3ÀºpH‹Èÿþ#H‹Ëÿí#E3ÉE3ÀH‹Èºkÿi$L%r5HƒÊÿ3ÀH‹ÊI‹üò®H÷ÑB€|!þ\tI‹üH‹Êò®·²%f‰Gÿ3ÀH‹ÊI‹üò®3ÿH÷ÑBˆ|!þH‹ËèžãÿÿI‹Ìè–èÿÿ;Ç„f‹|4‹
:2èéãÿÿH‹
"¾èH‹èH;Ït#@89tL6‹ÖH‹ËÿÖ#H‹
ç!è–Ôÿÿ9=ô1„L¿5‹ÖH‹Ëÿ¬#D‹
yL‹~4LS×ÿÿI‹ÔH‹ÍL‰\$ èGÂÿÿ;ÇuH
\5èsÆÿÿ9=¡1„¿9=¡tRL5‹ÖH‹ËÿQ#H‹
24Lë4ºìÿ8#H
 èÀËÿÿH‹èH;Çt3ÒH‹ÈèŽûÿÿH‹Íÿ‰9=;1t]9=;tUL‚4‹ÖH‹Ëÿï"H‹
Ð3L‰4ºìÿÖ"H
·è^ËÿÿH‹ØH;ÇtºH‹Èè)ûÿÿH‹Ëÿ$3ÀH‹Œ$0H3Ìè?HÄ@A\_^][Ã@SHì3ÒH‹ÙHL$DDBdèX8Hƒd$ 3À!„$°D@\HŒ$´3ÒH‰D$(H‰D$0H‰D$8è'83ÉÇD$@hÇD$Dÿ×Hƒd$pH‰D$HHÞÿÿHL$@H‰D$hHÇD$PkÿHL$@ÇD$DH‰D$ HïáÿÿHÇD$PlH‰D$hÿçHL$@H‰D$(H¾ûÿÿÇD$DH‰D$hHÇD$PmÿºH‰D$0HºêÿÿHL$@ÇD$DHÇD$PnH‰D$hÿ3ÉÇ„$°`H‰D$8ÿ
Hƒ¤$øHƒ¤$ƒ¤$àH‰„$ÀHD$ HŒ$°H‰œ$¸Ç„$´ Ç„$ØH‰„$èÿ"HÄ[ÃÌH‰\$H‰l$H‰t$W¸@èÖH+àH‹<îH3ÄH‰„$0H‹â2H-»#Ht.H‰D$(LL$0H_4¿L‹ÅH‹Ë‰|$ ÿ–¾PHT$0H
eD‹ÆèÅÂÿÿH‹Ž2LL$0H‰T$(H4L‹ÅH‹Ë‰|$ ÿUHT$0H
iD‹Çè‰ÂÿÿH‹R2L
³0H‰T$(HÇ3L‹ÅH‹Ë‰t$ ÿL‹
(2~±H–3D‹ÇH‹ËÿòL‹
2Hl3D‹ÇH‹Ë‰ÿÒ~ºL
.‰úH‹Û1H,3H‰D$(L‹ÅH‹Ë‰|$ ÿ§H‹¸1H‰T$(L
ôH
í2HÞ2L‹Å‰t$ ÿyH‹Š1L
«H‰T$(H§2L‹ÅH‹ËÇD$ ÿKH‹\1L
=H‰T$(L‹ÅH‹Ë‰|$ HW2ÿ!H5H=;2¹ó¦u èMëÿÿ…À„ˆèpêÿÿ…ÀuèŸëÿÿéÁ¸H5ÞH=÷1H‹Èó¦uèëÿÿ…ÀtRè:êÿÿ…ÀuIèqêÿÿ…Àt@ë¿€=¬t5H5£H=´1H‹Èó¦t ÿÇL˜1Hq1H‹ÈE3Éÿ
H
NèQØÿÿH‹ÈH‰,èÆûÿÿH‹
+/ÿuH‹
^0H…Étÿ3H‹
T0H…Étÿy3ÀH‹Œ$0H3Ìèw:Lœ$@I‹[I‹kI‹s I‹ã_ÃÌÌHƒì8H±A¸3ÉÿËH<,A¸3ÉÿÖH“H
€èÓÿÿH‰Œ.H…ÀuÿáHÂ1‹È雋aH
žL
Ÿ/H‰L$ L³H‹ÈèÔÿÿ…ÀtèjüÿÿërHƒ=x/u‹
	ƒù~H‹	è÷ïÿÿëOH
þº\è8QH…Àt&HƒÀt H61A¸H‹ÈèƒHõ0…ÀtHÂ03ÉèÓÏÿÿ¸HƒÄ8ÃÌH‰|$D‹ÉL‹ÚD·ÑAÁéAƒøu,¶¹ñÿDиÿÿD;ÑrDÐEÊD;É‚ŠDÈé‚H…ÒuBéAƒøsGE…ÀtA¶IÿÃDÐEÊAƒÀÿuí¹ñÿD;Ñr¸ÿÿDиq€€A÷áÁêkÒAÁàAÂé2¹q€€Aø°‚¸¯©n^A÷àÁê‹úAÀPêÿÿº[A¶IƒÃDÐA¶CñEÊDÐA¶CòEÊDÐA¶CóEÊDÐA¶CôEÊDÐA¶CõEÊDÐA¶CöEÊDÐA¶C÷EÊDÐA¶CøEÊDÐA¶CùEÊDÐA¶CúEÊDÐA¶CûEÊDÐA¶CüEÊDÐA¶CýEÊDÐA¶CþEÊDÐA¶CÿEÊDÐEʃÂÿ…Dÿÿÿ‹ÁA÷â‹ÁÁêiÒÿÿDÒA÷áÁêiÒÿÿDÊHƒï…ÿÿÿE…À„Aƒø‚ÈA‹ÐHÁêA¶AƒÀðIƒÃDÐA¶CñEÊDÐA¶CòEÊDÐA¶CóEÊDÐA¶CôEÊDÐA¶CõEÊDÐA¶CöEÊDÐA¶C÷EÊDÐA¶CøEÊDÐA¶CùEÊDÐA¶CúEÊDÐA¶CûEÊDÐA¶CüEÊDÐA¶CýEÊDÐA¶CþEÊDÐA¶CÿEÊDÐEÊHƒê…?ÿÿÿE…ÀtA¶IÿÃDÐEÊAƒÀÿuí‹ÁA÷â‹ÁÁêiÒÿÿDÒA÷áÁêiÒÿÿDÊAÁáEÊA‹ÁH‹|$ÃÌH‰\$D‹ÒA‹ØD‹ÙAÁë¸q€€A÷àD·ÁA·ÊÁêE‹ÈAÁêE„ðÿ¸q€€¹ÿÿiÒñÿ+ÚD¯ËA÷áÁêiÒñÿD+ÚºñÿEÚD+ÛC„ñÿD;ÂvDÁD;ÂvDÁ=âÿvþÿ;ÂvÁH‹\$ÁàAÀÃÌÌHµ-ÃH‰\$H‰t$H‰|$D‹ÑE‹ØH‹ÚH5•-A÷ÒE…Àt$öÃt¶A‹ÂHÿÃH3ÈÁè¶ÑD‹–D3ÐAƒÃÿuÜAƒû ‚"A‹ûHÁïD3A‹ÂHÁè¶ÐA‹ÂD‹„–HÁè¶ÈA‹ÂD3„ŽHÁèD3†A¶ÂD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CA‹ÀE‹ÈHÁè¶ÐA‹ÀHÁèD‹„–¶ÈI‹ÁD3„ŽHÁèHƒÃ D3†A¶ÁAƒÃàD3„†D3CøE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3†A¶ÁD3„†D3CüA‹ÀHÁè¶ÐA‹ÀD‹”–HÁè¶ÈA‹ÀD3”ŽHÁèD3†A¶ÀD3”†Hƒï…åýÿÿAƒûrVE‹ËIÁéD3AƒÃüHƒÃE‹ÂA‹ÂHÁè¶ÐA‹ÂD‹”–HÁè¶ÈI‹ÀD3”ŽHÁèD3†A¶ÀD3”†Iƒéu±E…Ût¶A‹ÂHÿÃH3ÈÁè¶ÑD‹–D3ÐAƒÃÿuáH‹\$H‹t$H‹|$A÷ÒA‹ÂÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x D‹Ñ½ÿ‹ÁD#ÕÁàE‹ØDЋÁÁéAÁâÁèH5h*#ÅDÐDÑA÷ÒE…Àt,öÂt'¶A‹ÊHÿÂHÁéH3ÈA‹ÂD‹”ŽÁàD3ÐAƒÃÿuÔHZüAƒû ‚BA‹ûHÁïD3SA‹ÂHÁè¶ÐA‹ÂD‹„–HÁè¶ÈA‹ÂD3„ŽHÁèD3„†A¶ÂD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3CA‹ÀE‹ÈHÁè¶ÐA‹ÀHÁèD‹„–¶ÈI‹ÁD3„ŽHÁèHƒÃ D3„†A¶ÁAƒÃàD3„†D3CüE‹ÈA‹ÀHÁè¶ÐA‹ÀD‹„–HÁè¶ÈI‹ÁD3„ŽHÁèD3„†A¶ÁD3„†D3A‹ÀHÁè¶ÐA‹ÀD‹”–HÁè¶ÈA‹ÀD3”ŽHÁèD3”†A¶ÀD3”†Hƒï…ÅýÿÿAƒûrZE‹ËIÁéHƒÃAƒÃüD3E‹ÂA‹ÂHÁè¶ÐA‹ÂD‹”–HÁè¶ÈI‹ÀD3”ŽHÁèD3”†A¶ÀD3”†Iƒéu­HƒÃE…Ût'¶A‹ÊHÿÃHÁéH3ÈA‹ÂD‹”ŽÁàD3ÐAƒÃÿuÙH‹\$H‹t$H‹|$ A÷ÒA‹ÂA‹Ê#ÅÁáÁA‹ÊAÁêÁàÁé#ÍH‹l$ÁAÂÃÌÌÌ3À…ÒtöÂt3HƒÁÑêuñóÃÌHƒì(L‹ÊL‹ÒL‹ÁL+ÉA» C‹I‹ÊèÆÿÿÿA‰IƒÀIƒëuçHƒÄ(ÃH‰\$H‰t$WHì A‹ø‹ò‹ÙE…À„œ¹ÇD$  ƒ¸íH‹Á‰L„ HÿÀÉHƒø |ñHT$ HŒ$ èyÿÿÿH”$ HL$ ègÿÿÿHT$ HŒ$ èUÿÿÿ@öÇtHŒ$ ‹Óè(ÿÿÿ‹ØÑÿt*H”$ HL$ è(ÿÿÿ@öÇtHL$ ‹Óèþþÿÿ‹ØÑÿu©3ÞLœ$ ‹ÃI‹[I‹sI‹ã_ÃÌÌÌHƒì(H…Òu3Àëè&øÿÿHƒÄ(ÃÌ@SUVWATAUAVAWHƒì8L‹a(D‹qH‹9L‹AM‹L$XI‹t$`E‹l$4A‹\$@E‹T$DH‹é‹IIÿÈ+ÑD¹ÿþÿÿA‹L$h‹ÂI‹ÐHÿÏH+ÐA‹D$,AƒÆû‰„$€A‹D$0H‰T$‰„$˜I‹D$8ºH‰D$¸L÷ÓàA‹L$lMøÓâÿÈL‰L$ÿÊH‰4$‰”$‹ÐH‰T$ Aƒús¶GA‹ÊHƒÇÓàAJضÓàØAƒÂ‹ÃH#Âë"öÂuGöÂ@…ՋʸAÁëÓàÿÈ#ÃAÃE‹A‹ÃA¶ÓÁè¶ÈÓëD+ÑE„ÛuÃIÿÀAÁëEˆéƒAÁëƒât+D;ÒsHÿÇA‹Ê¶ÓàØAƒÂ‹Ê¸ÓàÿÈ#ÃÓëDØD+ÒAƒús¶GA‹ÊHƒÇÓàAJضÓàØAƒÂ‹Œ$‹ÃH#È‹4Žë'öÂ@…=·„$Š‹ÊºÓâH‹$ÿÊ#ÓЋ4‘‹Æ@¶Ö‰´$ˆÁè¶ÈÓëD+ÑöÂt¼ƒâÁîD;Òs'HÿÇA‹ÊAƒÂ¶ÓàØD;ÒsHÿÇA‹Ê¶ÓàØAƒÂ‹Ê¸D+ÒÓàÿÈ#ÃÓëðA‹À+D$;ð†(‹Î+È;Œ$˜‡¥H‹T$LJÿE…íu+‹„$€+ÁLÈA;˃ŒD+ÙIÿÁIÿÀƒÁÿAŠAˆuïënA‹Å+ÁD;ésH„$€A+ÍLÈA;ËsZD+ÙIÿÁIÿÀƒÁÿAŠAˆuïLJÿE;ës=A‹ÍE+ÝIÿÁIÿÀƒÁÿAŠAˆuïëLÈA;ËsD+ÙIÿÁIÿÀƒÁÿAŠAˆuï‹ÆM‹ÈL+ÈAƒûv8AKý¸«ªªª÷áÑêJAŠAIƒÁIƒÀAˆ@þAŠAÿAƒÃýHƒéAˆ@ÿAŠAˆuØE…ÛtuAŠAH‹4$IÿÀAˆAƒûv
AŠAIÿÀAˆL‹L$ëY‹ÆI‹ÈH+ÈŠAHƒÁIƒÀAˆ@þŠAÿAƒÃýAˆ@ÿŠAˆAƒûwÛE…Ût#ŠAH‹4$IÿÀAˆAƒûvŠAIÿÀAˆë	L‹L$H‹4$I;þsCM;Çs>H‹T$ éòüÿÿö t
AÇ$ë%H.BëH
BëHäAH‰E AÇ$A‹ÊE+øÁéAÇ‹ÁD‰}H+ø‹ÁÁàD+÷D+ÐHGAƒÆH‰EI@D‰uH‰E¸A‹ÊÓàE‰T$DÿÈ#ÃA‰D$@HƒÄ8A_A^A]A\_^][ÃÌÌÌ3ÀH;ÈtXH‹Q(H;ÐtO‰B‰A‰AH‰A ÇAL‰‰B‰BH‰B ‰B,‰B0‰B4‰B@‰BDH‚HH‰‚€H‰B`H‰BX3ÀÇB€Ã¸þÿÿÿÃÌÌÌE‹ØH…Ét:L‹I(M…Ét1ƒú,E‹ADEAƒú w‹Ê¸E‰QDÓàA‹ÈÿÈA#ÃÓàAA@3ÀøþÿÿÿÃH‰\$WHƒì ‹úH‹ÙM…À„½A€81…³AƒùX…©H…Éu
¸þÿÿÿéŸHƒa Hƒy0uHƒa@H¹H‰A0Hƒy8uH³H‰A8H‹I@ºA¸H%ÿS0H‹ÐH…ÀuBüëRH‰C(…ÿyƒ`÷ßë‹ÇÁøÿÀƒÿ0‰B}ƒçGøƒøwHƒb8H‹Ë‰z(èŽþÿÿëH‹K@ÿS8Hƒc(é\ÿÿÿ¸úÿÿÿH‹\$0HƒÄ _ÃÌÌÌE‹ÈL‹ÂºéÿÿÿH!@ÇAh	ÇAlH‰AXHHH‰A`ÃÌÌÌH‰\$H‰l$H‰t$WHƒì H‹Y(‹êH‹ñHƒ{8¿u!‹K(‹×D‹ÇÓâH‹N@ÿV0H‰C8H…Àu‹Ç鑃{,u‹K(ƒc4Óçƒc0‰{,+n‹{,H‹V;ïrH‹K8L‹ÇH+×èÃ!ƒc4‹C,ëP+{4‹K4‹Å;ýGýHK8H+ÐD‹Çèž!+ïtH‹VH‹K8D‹ÅI+Ðè‡!‰k4ëËK,{49K4uƒc4‹C0;ÁsljC03ÀH‹\$0H‹l$8H‹t$@HƒÄ _ÉT$SUVWATAUAVAWHƒìXE3ä‹ÚL‹éI;Ì„ÐH‹y(I;ü„ÃL9a„¹L9!u
D9a…ªƒ?uÇD‹ID‹qL‹QL‹9D‰t$8E‹ÁD‰Œ$¸D‰¤$ ‹wD‹o@D‰Œ$°L‰T$@A»º‹ƒù†„G;ʹ„‹A;Ì„ƒét_ƒé„ëƒé„_ƒé„³ƒé„ăù„º¸þÿÿÿHƒÄXA_A^A]A\_^][ÃE;ô„ûA¶‹ÎAÿÎÓàIÿÇèƒÆA;ór߉o@€ýtHìGéÕ÷ÅàtH¸GéÁH‹O I;Ìt
‹ÅÁèƒà‰ºg	s#@ˆl$0ÁíHT$0@ˆl$1‹OA¸è5÷ÿÿ‰GA‹ìA‹ôÇëE;ô„fA¶‹ÎAÿÎÓàIÿÇèƒÆƒþ rßH‹G I;Ät‰hºg	s5‹Å@ˆl$0HT$0ÁèA¸ˆD$1‹ÅÁíÁè@ˆl$3ˆD$2‹Oè¾öÿÿ‰GA‹ìA‹ôÇA»ëE;ô„éA¶‹ÎAÿÎÓàIÿÇèƒÆA;órßH‹O I;Ìt@¶Å‰AH‹G ‹ÍÁé‰Hºg	s)@ˆl$0ÁíHT$0@ˆl$1‹OA¸èCöÿÿA»‰GA‹ìA‹ôǺg
r{H‹G I;ÄtL‰`Ǻg
ƒå‹_HA;ÞAGÞA;Ü„ÈH‹G I;Ä„˜L‹HM;Ì„‹‹P‹H+WH;Ávi+ÊëgE;ô„
A¶‹ÎAÿÎÓàIÿÇèƒÆA;órßH‹G ‰oHI;Ät‰hºg	s#@ˆl$0ÁíHT$0@ˆl$1‹OA¸èqõÿÿ‰GA‹ìA‹ôéIÿÿÿ‹ËD‹Á‹ÊI‹×IÉèݺg	s‹OD‹ÃI‹×è<õÿÿ‰G‹ÃD+óLø)_HD9gH…oD‰gHǺºgs|E;ô„PA‹ÜM‹ÇE3ÉH‹G E¶ ÿÃIÿÀI;ÁtH‹P I;Ñt‹OH;H(sDˆ$ÿGHE;átA;Þr̺g	s‹OD‹ÃI‹×è³ôÿÿE3ɉG‹ÃD+óLøE;á…çE3äAT$ë
H‹G I;ÄtL‰` D‰gH‰ºgƒÕE;ô„¶A‹ÜM‹ÇE3ÉH‹G E¶ ÿÃIÿÀI;ÁtH‹P0I;Ñt‹OH;H8sDˆ$ÿGHE;átA;Þr̺g	s‹OD‹ÃI‹×èôÿÿE3ɉG‹ÃD+óLøE;á…ME3äéhD9gu'ÇéÀûÿÿE;ô„+A¶‹ÎAÿÎÓàIÿÇèƒÆA;órßöGt]ý‹uUE3À3Ò3Éè®óÿÿHT$0A¸‰GÆD$0ÆD$1‹‹OèŽóÿÿljGA‹ôA‹ìD‹„$¸D‹Œ$°L‹T$@é1ûÿÿH‹G D‰gI;ÄtƒH@ÿöG„•@¶Í‹ÅÁèÁáȸ…B÷á‹Á+ÂÑèÂÁèkÀ;Èui‹Å$<tHxCI‰E Çé×úÿÿÁíƒÆü‹ÍƒáƒÁ;O(v	HCëÕ¸E3À3ÒÓà3ɉGèçÿÿÁí÷Õ‰GA‰ELƒåƒÍ	‰/é5ÿÿÿºHÂBI‰E ÇévúÿÿH‹G I;ÄtL‰`0D‹„$¸D‹Œ$°L‹T$@‹œ$¨ºÇDZ	ºg	ƒxéTƒétëƒé„ƒé„<ƒé„tƒé„tƒù…Vúÿÿ‹Î#ÊÓí+ñëE;ô„]
A¶‹ÎAÿÎÓàIÿÇèƒÆƒþ rß‹Å·Í÷ÐÁè;ÈtHÙAé2ÿÿÿ‰OHA‹ìA‹ôÇD‹gH3ÉD;á„E;æEGæE;áEGáD;á„öE‹ÄI‹×I‹ÊA‹Üè&D‹Œ$°L‹T$@E+ÌE+ôLÓLûD)gHD‰Œ$°L‰T$@D‹„$¸‹œ$¨E3äé%ùÿÿE;ô„›A¶‹ÎAÿÎÓàIÿÇèƒÆƒþ rߋ͋źÿÁà#ÊA‹ôÈ‹ÅÁíÁèÁá#ÂÁÅA‹ì‰GA‰ELÇ
D9g„	E3À3Ò3ÉèªåÿÿD‹„$¸D‹Œ$°L‹T$@º‰GA‰ELÇDZ	ƒû„D9gt/‹ÎÇ#ÊÓí+ñéxøÿÿE;ô„ãA¶‹ÎAÿÎÓàIÿÇèƒÆƒþrß‹ÅÑíÿ΃à‰G‹ÅƒàA;Ät:ƒèt%ƒètƒøu1H0@I‰E ÇëÇëH‹Ïè\öÿÿÇëÇ
ÁíƒÆþéö÷ÿÿE;ô„aA¶‹ÎAÿÎÓàIÿÇèƒÆA;órß·G;ètH³?é<ýÿÿA‹ìA‹ôH‹O I;Ìt‹GÁø	ƒà‰A3ɉ„$ ;ÁtxD‹Œ$°L‹T$@H;I‰E Çé"úÿÿ‹G|ÿÊfD‰ŒGˆÿG|A;Ôuê‹GxGt9G|ƒDÿÿÿºé ýÿÿD‹„$¸D‹Œ$°HÐ:I‰E ÇéóÿÿH‹‡€D‹GxHOlH‰G`‹GtÇL‰d$(H‰L$ L€H”Gˆ¹èzD‹„$¸D‹Œ$°L‹T$@‹œ$¨E3䉄$ A;ÄtH:I‰E Çé‰òÿÿÇAƒþrGAùr>M‰UE‰MM‰}E‰uA‹ÐI‹Í‰o@‰wDèŸêÿÿM‹UE‹MM‹}E‹uD‹„$¸é#òÿÿ‹OhL‹_XA¹A‹ÁÓàA+Á‹È‹ÅH#ÈA‹‹ë5E;ô„ŠA¶‹ÎAÿÎÓà‹OhMùèA‹ÁƒÆÓàA+Á‹È‹ÅH#ÈH‹GX‹ˆ‹ÈÁé¶É;Îw¿A:Ä„±¨ð…©D‹Ð¶È‹ÐAÁê‰D$4ÁèE¶ÂAÈAÓáA‹ÈAÿÉD#ÍAÓéDÈC‹‹‹ÈÁéD¶ÁA¶ÊDÁëYE;ô„öA¶D¶L$5‹ÎÓàA¸¶ÊAÉè·D$6AÓàA‹ÉAÿÎAÿÈIÿǃÆD#ÅAÓèDÀH‹GXB‹€‹ÈÁéD¶ÁEÁD;Æw¢¶L$5Óí+ñ‹ÈÁé¶ÉÓí+ñ‹ÈÁé‰OHA:ÄuÇéªõÿÿ¨ …pùÿÿ¨@tH:/é÷úÿÿ¶Èǃá‰OP‹WPA;Ôt9;òs!E;ô„8A¶‹ÎƒÆÓàAÿÎIÿÇè;wPrߋʸÓàÿÈ#ÅÓíGH+òÇ‹OlL‹_`A¹A‹ÁÓàA+Á‹È‹ÅH#ÈA‹‹ë5E;ô„ÛA¶‹ÎAÿÎÓà‹OlMùèA‹ÁƒÆÓàA+Á‹È‹ÅH#ÈH‹G`‹ˆ‹ÈÁé¶É;Îw¿¨ð…©D‹Ð¶È‹ÐAÁê‰D$4ÁèE¶ÂAÈAÓáA‹ÈAÿÉD#ÍAÓéDÈC‹‹‹ÈÁéD¶ÁA¶ÊDÁëYE;ô„PA¶D¶L$5‹ÎÓàA¸¶ÊAÉè·D$6AÓàA‹ÉAÿÎAÿÈIÿǃÆD#ÅAÓèDÀH‹G`B‹€‹ÈÁéD¶ÁEÁD;Æw¢¶L$5Óí+ñ‹ÈÁé¶ÉÓí+ñ¨@tHœ-éqùÿÿD‹„$¸D‹Œ$°L‹T$@‹ÈÇA»Áé‰OL¶Èƒá‰OP‹WPA;Ôt9;òs!E;ô„A¶‹ÎƒÆÓàAÿÎIÿÇè;wPrߋʸÓàÿÈ#ÅÓíGL+ò‹G0A+ÁAÀ9GLvHï,éêóÿÿÇE;Ì„:‹OLA‹ÀA+Á;Èv/+È‹G4;Èv‹W,+È+ÑëHí5é°óÿÿ+Á‹Ð‹GHHW8;Èv
ë	‹GHI‹ÒH+Ñ‹ÈA;ÉAGÉD+É+Á‰GHD‰Œ$°ŠHÿÂAˆIÿƒÁÿuðL‰T$@QD9gH…Fîÿÿénƒé„Gƒét.ƒé„ñƒé„ƒé„pƒù…iîÿÿ¸üÿÿÿédîÿÿD9g„¼ëE;ô„dA¶‹ÎAÿÎÓàIÿÇèƒÆƒþ rßE+ÁEEDGE;Ät;‹OA‹ÀI‹ÒH+ÐD9gtèÚåÿÿëèÚÿÿD‹Œ$°L‹T$@º‰GDZ	A‰EL‹Í‹ÅE‹ÁÁàáÿD‰Œ$¸È‹ÅÁèÁá%ÿÈ‹ÅÁèÈD9gEÍ;OtH4éÀòÿÿA‹ìA‹ôÇD9g„•D9g„‹ëE;ô„ŽA¶‹ÎAÿÎÓàIÿÇèƒÆƒþ rß;ot]H4élòÿÿE;Ìt`ŠGHAˆIÿÂAÿÉD‰Œ$°L‰T$@ÇéÈìÿÿM‰UE‰MM‰}E‰u¸‰o@‰wDéíÿÿA¼ýÿÿÿëA‹ìA‹ôÇA¼ëD‹¤$ H‹D$@‹œ$¸M‰}I‰E‹„$°E‰uA‰E‰o@3í‰wD9o,uƒ?}A;]t‹ÓI‹Íè´êÿÿ;ÅtÇé!þÿÿA+]‹t$8A+uA]Au_9ot+;Ýt'I‹U‹O‹ÃH+ÐD‹Ã9otè äÿÿëèÕØÿÿ‰GA‰EL‹Gº€÷Ø‹ÅɃá@ƒ?DÂÈODA‰MH;õu;Ýt
ƒ¼$¨u¸ûÿÿÿD;åDDàA‹Äéìÿÿ@SHƒì H‹ÙH…Ét6H‹A(H…Àt-L‹A8M…Àt$H‹P8H…ÒtH‹I@AÿÐH‹S(H‹K@ÿS8Hƒc(3Àë¸þÿÿÿHƒÄ [ÃÌH‰\$H‰l$H‰t$WHƒì A‹ðH‹êH‹ùH…ÉtH‹Y(H…Ûtƒ{tƒ;
t¸þÿÿÿH‹\$0H‹l$8H‹t$@HƒÄ _Ã;
u%E3À3Ò3Éè××ÿÿD‹ÆH‹Õ‹ÈèÊ×ÿÿ;Ct¸ýÿÿÿëÁ‹WH‹ÏèCéÿÿ…Àt
Ǹüÿÿÿë¥H‹K8;s,vD‹C,H‹ÖI+ÐHÕèWD‹[,D‰[0ë‹C,H+ÎL‹ÆHÈH‹Õè9‰s0ÇC3Àé[ÿÿÿH…ÉtH‹A(H…Àtö@tH‰P ƒb@3ÀøþÿÿÿÃÌÌÌD‹	E3ÒL‹ÙE…ÀttM‹FDE3ÀNjȃáÓf@+Á‰FDƒørHL$0ŠF@ƒFDøÁn@ˆAÿÀHÿÁƒ~DsçHN|HT$0ƒ!èÿÿÿD‹GH‹HN|èÿÿÿG)GD‹O‹ÈHƒ~|t¸ýÿÿÿë#D‹GH‹ÏèÔåÿÿD‰OD‰GÇ3Àë¸þÿÿÿH‹\$8H‹t$@HƒÄ _ÃÌ3ÀH;ÈtH‹I(H;Ètƒ9
u9ADu¸øþÿÿÿÃÌÌH‰\$H‰l$H‰t$WATAUHƒì H‹ÚL‹áH…É„=H…Ò„4H‹z(H…ÿ„'H‹B0H…À„Hƒz8„H‹K@A½A¸H%A‹ÕÿÐH‹ðH…Àu
¸üÿÿÿéí3íH9o8t&‹O(A‹ÕE‹ÅÓâH‹K@ÿS0H‹èH…ÀuH‹K@H‹ÖÿS8ëÈI‹ÌH‹ÓA¸XèÙA¸H%H‹×H‹ÎèÈL‹_XH‡H¹HL;Ørýÿÿ‹Ø¹èÆ•‹ÃHƒÄ [ÃÌÌH‰\$H‰t$WHƒì0H‹úH‹ñ3Û‹ÃH;Ó•À;Ãu"è€X{‰8H‰\$ E3ÉE3À3Ò3ÉèËG‹Çë-¹è–H‹×H‹ÎèÍüÿÿ;ÃtèDX‹¹èL•‹ÃH‹\$@H‹t$HHƒÄ0_ÃÌ̉L$SVWATAUAVAWHìH‹úHcñ3Û‹ÃH;Ó•À;Ãu.èX‰èîWÇH‰\$ E3ÉE3À3Ò3Éè8GƒÈÿéÒ3ÒDB0H‹ÏèJìÿÿƒþþuèÔW‰è­WÇ	ƒÈÿé¥;óŒt;5ièƒhL‹æL‹îIÁýL=fèAƒäMkäXK‹ïB¾L A¾A#Îu.èxW‰èQWÇ	H‰\$ E3ÉE3À3Ò3Éè›FƒÈÿé5‹Î耗K‹ïF„t!uèWÇ	ƒËÿéÛJ‹!ÿ“ÓºðA;Æ„¹ƒøt1ƒøt,;ÃuèßVÇ	ƒËÿé£ÿ¯Ò‹ÈèWƒËÿ鎃øu¹ f‰Oë	¹f‰O‰7‰wfD‰wf‰_f‰_f‰_
H‰_(H‰_ H‰_ƒøu‰_éFK‹ïH‰\$(H„$ØH‰D$ E3ÉE3À3ÒJ‹!ÿØÒ÷ØÉ#Œ$؉Oéf‰_f‰_f‰_
f‰_fD‰wK‹ïHT$PJ‹!ÿ•Ò;ÃuÿëÑ‹Èè@VƒËÿéÊD„t$Pt·G
$f‰Gë
·G
¶f‰G9\$du9\$huH‰_ ënH”$àHL$dÿ,Ò;ÄwHT$@HŒ$àÿ	Ò;Ä\·D$LD·T$JD·L$HD·D$F·T$B·L$@ƒL$0ÿ‰D$(D‰T$ è•™H‰G 9\$\u9\$`u
H‹G H‰GënH”$àHL$\ÿ¨Ñ;ÄîHT$@HŒ$àÿ…Ñ;ÄӷD$LD·T$JD·L$HD·D$F·T$B·L$@ƒL$0ÿ‰D$(D‰T$ è™H‰G9\$Tu9\$Xu
H‹G H‰G(ëfH”$àHL$Tÿ$Ñ;ÃtiHT$@HŒ$àÿÑ;ÃtR·D$LD·T$JD·L$HD·D$F·T$B·L$@ƒL$0ÿ‰D$(D‰T$ 蕘H‰G(‹D$t‰G·Gºèf‰G‰‰_ë
ƒËÿëƒËÿëƒËÿ‹Îè'•‹Ãë)è>T‰èTÇ	H‰\$ E3ÉE3À3Ò3ÉèaCƒÈÿHÄA_A^A]A\_^[ÃÌÌÌH‹ÄH‰PH‰HL‰@L‰H SVWATHƒì8H‹ù3Û‹ó‹ÃH;Ë•À;Ãu'è°SÇH‰\$ E3ÉE3À3Ò3ÉèúBƒÈÿé‹ÃH;Ó•À;Ãu'è}SÇH‰\$ E3ÉE3À3Ò3ÉèÇBƒÈÿéâLd$pè¡öG@…•H‹Ïèƪƒøÿt*ƒøþt%HcÐH‹ÊHÁùLäƒâHkÒXIÈH
=±ëH
4±H‹ÑLêãöB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€t"èÎRÇH‰\$ E3ÉE3À3Ò3ÉèBƒÎÿ;óu*H‹Ïèùœ‹ØM‹ÌE3ÀH‹T$hH‹Ïè0Ÿ‹ðH‹×‹Ëè¬H‹Ïè[‹ÆHƒÄ8A\_^[ÃÌÌÌL‰D$L‰L$ Hƒì(LL$Hè «HƒÄ(ÃÌÌÌL‰D$L‰L$ Hƒì(LL$H褫HƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(LHE3Àè}«HƒÄ(ÃL‰D$L‰L$ Hƒì(LL$Hè„«HƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(LHE3Àè]«HƒÄ(ÃHÙÃ@SHƒì ‹üô»…Àu¸ë;ÃLÃHcȺ‰Ùô耈H‰µäH…Àu$PH‹Ë‰¼ôècˆH‰˜äH…Àu¸ëx3ÉHkH‰HƒÂ0HƒÁHƒët	H‹jäëåE3ÀHbEHI‹ÈLâI‹ÀHÁøƒáI‹ÂHkÉXL‹IƒúÿtIƒúþtM…ÒuÇþÿÿÿIÿÀHƒÂ0Iƒéu¼3ÀHƒÄ [ÃÌÌHƒì(蟭€=l»tèåªH‹
îãHƒÄ(ééóÿÿÌ@SHƒì H‹ÙH
¼œH;Ùr:H@ H;Øw.H‹ÓH¸«ªªªªªª*H+ÑH÷êHÁúH‹ÊHÁé?L蜎ºkë
HK0ÿóÌHƒÄ [ÃÌ@SHƒì ƒùH‹Ú}ƒÁènŽºkë
HJ0ÿÅÌHƒÄ [ÃÌÌÌHƒì(H1œH;Êr7HµŸH;Èw+ºqH+ÊH¸«ªªªªªª*H÷éHÁúH‹ÊHÁé?LèïŒë
HƒÁ0ÿsÌHƒÄ(ÃÌÌHƒì(ƒù}ºrƒÁèÆŒë
HJ0ÿJÌHƒÄ(ÃÌÌÌÌÌÌÌÌÌÌÌÌÌL‰D$L‰L$ SWHƒìhI‹ÀH‹ùM…Àu%ètOHƒd$ E3ÉE3À3Ò3ÉÇè½>ƒÈÿëiH…ÒtH…ÉtѹÿÿÿLŒ$˜ÇD$HBH;ÑH‰|$@H‰|$0GÑHL$0E3À‰T$8H‹Ðè±›‹ØH…ÿtƒl$8x
H‹D$0ÆëHT$03ÉèÉ«‹ÃHƒÄh_[ÃL‰L$ Hƒì8HD$`H‰D$ è¤HƒÄ8ÃÌÌÌÌÌÌÌÌÌff„L‹ÙMÀt$H+ÊöÂt(Š„Àˆ„ãHÿÂIÿÈtöÂuæëI‹ÃÃH‰HƒÂH‹Iƒèr&I¹ÿþþþþþþ~LÈL‹ÐIƒòÿM3ÑI¹M…ÑtÉIƒÀ„‹„Àˆ„„HÿÂIÿÈtx„äˆ$tuHÿÂIÿÈtiHÁè„ÀˆtbHÿÂIÿÈtV„äˆ$tSHÿÂIÿÈtGHÁè„Àˆt@HÿÂIÿÈt4„äˆ$t1HÿÂIÿÈt%Áè„ÀˆtHÿÂIÿÈt„äˆ$tHÿÂIÿÈ…<ÿÿÿI‹ÃÃHÊH3ÒIƒørEöÁt
HÿÁˆIÿÈëñIƒè rH‰H‰QH‰QH‰QHƒÁ Iƒè sçIƒÀ Iƒèr	H‰HƒÁëñIƒÀIƒèrˆHÿÁëóI‹ÃÃÌÌL‹ÉE3ÀŠHÿÁA:ÀuöHÿÉI;Ét8uô8LDÁI‹ÀÃÌÌH‰\$WHƒì`M‹ÑI‹ÀH‹ùM…Àu%èMHƒd$ E3ÉE3À3Ò3ÉÇèT<ƒÈÿëiH…ÒtH…ÉtÑL‹Œ$¹ÿÿÿM‹ÂH;ÑÇD$HBH‰|$@GÑHL$0H‰|$0‰T$8H‹ÐèH™‹ØH…ÿtƒl$8x
H‹D$0ÆëHT$03Éè`©‹ÃH‹\$pHƒÄ`_ÃÌÌÌHƒì8L‰L$ E3Éè;ÿÿÿHƒÄ8ÃÌÌH‰\$H‰l$H‰t$WHƒì`H‹éH‹ÊI‹ñI‹ØH‹úèЄH…ÿu%è*LHƒd$ E3ÉE3À3Ò3ÉÇès;ƒÈÿë;H…ÛtÖL‹Œ$¹ÿÿÿL‹ÆH;ÁH‹ÓÇD$HIGÁHL$0H‰|$@H‰|$0‰D$8ÿÕL\$`I‹[I‹kI‹s I‹ã_ÃÌL‹ÜI‰SM‰CM‰K Hƒì8L‹ÂICH‹ÑH
L«E3ÉI‰Cèè,ÿÿÿHƒÄ8ÃÌÌÌL‹ÜM‰CM‰K Hƒì8M‹ÈL‹ÂIC H‹ÑH
«I‰CèèøþÿÿHƒÄ8ÃÌÌÌL‹ÜI‰SM‰CM‰K Hƒì8L‹ÂICH‹ÑH
 ½E3ÉI‰CèèÀþÿÿHƒÄ8ÃÌÌÌL‹ÜM‰CM‰K Hƒì8M‹ÈL‹ÂIC H‹ÑH
i½I‰CèèŒþÿÿHƒÄ8ÃÌÌÌH‰\$WHƒì0ƒÏÿH‹ÙH…Éu#èÆJH!\$ E3ÉE3À3Ò3ÉÇè:ÇëFöAƒt:èq¥H‹Ë‹øèÛÑH‹Ë袋Èè´Ð…ÀyƒÏÿëH‹K(H…Ét
è¥íÿÿHƒc(ƒc‹ÇH‹\$@HƒÄ0_ÃÌÌÌH‰\$H‰L$WHƒì0H‹ÙƒÏÿ3ÀH…É•À…Àu$è.JÇHƒd$ E3ÉE3À3Ò3Éèw9‹Çë&öA@tƒaëèNùÿÿH‹Ëèÿÿÿ‹øH‹ËèËùÿÿ‹ÇH‹\$HHƒÄ0_ÃÌÌH‰\$H‰l$H‰t$ WATAUAVAWHƒì0I‹ñM‹øL‹âL‹ñH…Òt*M…Àt%M…Éu?è IHƒd$ E3ÉE3À3Ò3ÉÇèé83ÀH‹\$`H‹l$pH‹t$xHƒÄ0A_A^A]A\_ÃH…Ét¼3ÒHƒÈÿI÷ôL;Àw®I‹üI¯ÿA÷AH‹ïtE‹i$ëA½H…ÿ„à‹F%t<‹N…Ét5ˆ‡H;éI‹ÖB͉L$h‹ÙD‹ÁH‹è…Þÿÿ‹D$hH)FH+ëLóé’A‹ÝH;ërd…ÀtH‹Î褣…ÀuDE…ít3ÒH‹ÅH÷ó‹Ý+Úë‹ÝH‹Îè7 D‹ÃI‹Ö‹Èè‚׃øÿt‹È;ÃGËH+éLñ;Ãs:ƒN H+ý3ÒH‹ÇI÷ôéõþÿÿA¾H‹ÖèH¥ƒøÿtßIÿÆHÿ̓~$A½DOn$H…íéÿÿÿI‹Çé¿þÿÿÌÌH‹ÄH‰XH‰pH‰xL‰H ATHƒì0I‹ÙI‹øH‹òL‹áH…Òt_M…ÀtZ3ÀH…Û•À…Àu$èHÇHƒd$ E3ÉE3À3Ò3ÉèI73Àë,H‹Ëè)÷ÿÿL‹ËL‹ÇH‹ÖI‹ÌèëýÿÿH‹øH‹Ëèœ÷ÿÿH‹Çë3ÀH‹\$@H‹t$HH‹|$PHƒÄ0A\ÃÌÌÌH…Ét‰HƒÁH‹ÁÃÌHƒì(H…ÉtHƒé9ÝÝuèªêÿÿHƒÄ(ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒìPH‹ÑHHØ3íè…æÿÿL‹\$03ÿM‹£XI‹Lü8èÉI‹üH‹Øè½HÿÇHÅHlHƒÿrÙHMè“}H‹øH…À„˜H‹Ø3öÆ:M‹ôHÿÃH‹ÏH+ËHT)H‹Ëè¹|…ÀtHƒd$ E3ÉE3À3Ò3Éèœ4H‹ËèTHØH‹ÇÆ:M‹Dô8HÿÃH+ÃH‹ËHT(èw|…ÀtHƒd$ E3ÉE3À3Ò3ÉèZ4H‹ËèHÿÆHØHƒþ‚pÿÿÿÆ€|$HtH‹D$@ƒ ÈýH‹\$`H‹l$hH‹t$pH‹ÇH‹|$xHƒÄPA\ÃÌÌ3Éé½þÿÿÌH‹ÄH‰XH‰hH‰pWATAUHƒìPH‹ÑHHÈ3íèBåÿÿL‹\$0DmI‹³XM‹åH~pH‹O`è~~H‹H‹Øès~HƒÇHÅIƒìHluÚHMèH|H‹øH…À„œH‹ØHÆÐÆ:L‹F HÿÃH‹ÏH+ËHT)H‹Ëèi{…ÀtHƒd$ E3ÉE3À3Ò3ÉèL3H‹Ëè~HØH‹ÇÆ:L‹HÿÃH+ÃH‹ËHT(è){…ÀtHƒd$ E3ÉE3À3Ò3Éè3H‹ËèÄ}HƒÆHØIƒí…qÿÿÿDˆ+€|$HtH‹D$@ƒ ÈýL\$PH‹ÇI‹[ I‹k(I‹s0I‹ãA]A\_Ã3ÉéµþÿÿÌH‰\$UVWATAUAVAWHƒìPH‹ÑE3öHL$0I‹îèõãÿÿL‹\$0I‹³XI‹þH‰´$¨H‹Lþ8è0}H‹þH‹Øè$}HÿÇHÅHlHƒÿrÙA¿LfpI‹üL‰¼$ M‹ïH‹O`èò|H‹H‹Øèç|HƒÇHÅIƒíHluÚH‹Ž8èÉ|H‹Ž0H‹Øèº|H‹Ž@HÅH\è¦|H‹ŽHH\è•|H‹ŽPH\è„|H¬iH‹ÍèdzH‹ØI;Æ„¸A¸hH‹ÖH‹ÈH¸hè@ÙÿÿH‹ÃH+ÆLn8H‰„$˜L‹øJ‰<óM‹EÈH‹ÓH+×H‹ÏHÕèfy…ÀtHƒd$ E3ÉE3À3Ò3ÉèI1H‹Ïè|H‹ÓH|K‰Aƒê„øAƒê	„îAƒê„
Aƒê„­E+Öt\AND;Ñu2A‹H3Û;Ë|	ƒùŽ
èÚ>E3ÉE3À3Ò3ÉH‰\$ Çè$.3ÀH‹\$PH‹l$XH‹t$`H‹|$hHƒÄ0A^A]A\Ã3ÛA9X|¸Aƒx±IcHH‹D$xH‹”ÈÐH‹L$pëDŠD:ÄFI‹IÖDˆM1Hÿ	H9uàé-3ÛA9XŒhÿÿÿKA9H[ÿÿÿIcHH‹D$xH‹TÈ8H‹L$pëDŠD:ÄóI‹IÖDˆM1Hÿ	H9uàéÚI‹Æ%H‹D$pM1HÿéÄA‹H3Û;ËŒýþÿÿƒùôþÿÿ¸«ªª*÷éÑú‹ÂÁèÐRÁà+ÈCDÈéÛAƒêM„ö¹D+Ñ„ÌAƒêt\Aƒêt7E;Ö…ÃþÿÿH‹D$xQüH‹ÍH‰D$(H‹D$pH‰D$ èH3Û;Ã…4é•þÿÿA‹@3Û;ÃŒhþÿÿ;Á`þÿÿ;ÃtHÿë3ÛA9XŒKþÿÿA9HAþÿÿA‹HA9XŒ3þÿÿAxm%þÿÿA9H|+E‹@¸“$I’A÷èAÐÁú‹ÂÁèЋ‹ÚkÀD+ÀD;Á|AÞ‹Ëé÷3ÛA9ŒâýÿÿAƒ8;Øýÿÿ‹éÛA‹H3Û;ËŒÃýÿÿƒù;éµýÿÿAx”øÿÿ|;Ax£1E‹@¸…ëQA÷èÁú‹ÂÁèЋÂJºkÀdD+ÀkÉdAÈé…èP<3ÛéoýÿÿAƒúm¹„•AƒêZ„ÐAƒê„/E+Ö„ÕE+ÖtdE+Öt/¹D;Ñ…DýÿÿA‹H3Û;ËŒýÿÿùmýÿÿÿÁSëA‹HA;Î|…ƒù€º‹„$€L‹L$pL‹Ç‰D$ èdûÿÿéL‹l$xL‹d$p3ÛL‰l$(L‰d$ 9œ$€tIA‹Öèp;ÄÄüÿÿI9$„ºüÿÿH‹L‰l$(L‹ÏÆ L7Iÿ$L‰d$ L‹ÆºH‹Íè4ééýÿÿ3Òë¶3ÛA9XŒ\üÿÿAƒxQüÿÿIcHH‹D$xH‹TÈpH‹L$pëDŠD:ÄéI‹IÖDˆM1Hÿ	H9uàéÐ3ÛA9XŒüÿÿKA9HþûÿÿIcHH‹D$xH‹ÈH‹L$pëDŠD:Ä—I‹IÖDˆM1Hÿ	H9uàé~A‹H3Û;ËŒ·ûÿÿƒù®ûÿÿÿÁé±þÿÿAƒêp„ÝAƒê„¯E+Öt|E+ÖtNE;Ö…ŸûÿÿèÂ4è:3Û9^ H‹Ë•ÁH‹ÈH‹L$pëDŠD:Ä
H‹IÖDˆL7Hÿ	H9uàéôA‹H3Û;ËŒ-ûÿÿ¸…ëQ÷éÁú‹ÂÁèÐkÒd+ÊéþÿÿH‹D$x3ÛH‰D$(H‹D$pH‰D$ 9œ$€tA‹Öéuþÿÿ3Òénþÿÿ3ÛA9XŒØúÿÿKA9HËúÿÿ‹NA‹ÖéÏýÿÿ3ÛA9XŒ´úÿÿAƒx©úÿÿAƒxH‹D$x,H‹0H‹L$pëDŠD:Ãt@I‹IÖDˆM1Hÿ	H9uäë*L‹€8H‹T$pëEŠD:ËtH‹MÆDˆ	L7Hÿ
H9uäA‹Æé`úÿÿÌÌ@UATAUAVAWHƒìpHl$@H‰]`H‰uhH‰}pH‹…H3ÅH‰E L‹½ˆM‹ñL‰EM‹ÈE3ÀL‹éH‰MA»A;ÐtA;Ót	I‹¿PëI‹¿HëI‹¿@E9Ÿ\„aA·AL‹-FµƒúLE-3µ¹lD‰D$(fÁA‹XfD‰Ef‰EA·AL‰D$ fAÃLE3Òf‰E
A·Af‰EA·Af‰EA·Af‰EA·L‹Ïf‰EAÿÕE3ÀD‹àA;À„σÀ=:H˜HHH;Èw
H¹ðÿÿÿÿÿÿHƒáðH‹Áè‹¡H+áH\$@I;Ø„“ÇÌÌëHcÈè–ÛÿÿE3ÀH‹ØI;Àt
ÇÝÝHƒÃI;ØtiA‹XLEL‹Ï3ÒD‰d$(H‹óH‰\$ AÿÕDXÿE…Û~%H‹•€Hƒ:vŠI‹AÿˈIÿHÿ
HÿÆE…ÛâHKð9ÝÝuèÚÿÿ¸éŒL‹ML‹mA»ŠA:À„pH‹µ€L9„`A‹ØA‹ÈI‹ÐL‹çMãAËIÓA8$tñD¾ÀAƒødg„1Aƒø'„œAƒøAtAƒøHtYAƒøMt#Aƒøa…‚H²H‹Ïè^É…ÀuOLgë`A+Ët!A+ËtA+ËtA;Ë…Q²B铲béŒA‹Û²mé‚A+Ët
A;Ëté*A‹Û²HéiHLH‹ÏèüÈ…ÀuLg²péKA„ËtxHúE3ÀŠA:À„uL9„X<'tR¾ÈI‹Õè3ÆE3ÀEXA;ÀtL9vD8G„>ŠI‹HÿLjMHÿŠI‹IûˆMHÿŠA:Àu¦éIûéúHcÁHøE3ÀéìA+Ët!A+ËtA+ËtA;Ë…_²A顲aéšA‹Û²déA‹Ðƒêh„1ƒê„ƒê„ùA+Ót%ƒê…ƒùtƒù…
²YéO²yéHAƒy	I‹Ÿ0ëI‹Ÿ8E3ÀA;Ë… L9†—¾I‹Õè'ÅE3ÀEXA;ÀtL9vD8C„2ŠI‹HÿÈMHÿI‹ŠˆMHÿéýL9†ô¾ÈI‹ÕèÖÄE3ÀEXA;ÀtL9vD8C„áŠI‹HÿÈMHÿŠI‹IÛˆMHÿŠA:Àuªé¢A+ËtA;Ëtë$A‹Û²SëfA+ËtA;ËtëA‹Û²MëSA+ËtIA;ËtGI‹ÕA‹ÈèTÄE3ÀEXA;ÀtL9vD8GtcŠI‹HÿLjMHÿŠI‹IûˆMHÿë1A‹Û²IL‹E‰\$0M‹ÎI‹ÍL‰|$(H‰t$ èmôÿÿE3ÀA;ÀtEXI‹üŠA:Àt
L‹Mé›üÿÿ3ÀëA‹ÃH‹M H3Íè¿ÎÿÿH‹]`H‹uhH‹}pHe0A_A^A]A\]ÃÌH‹ÄH‰XH‰hH‰HVWATAUAVHƒìpH‹úH‹”$ÈL‹áHH°E3öM‹éI‹ØA‹öèšÒÿÿL‹œ$ M;Þ„sI;þ„jEˆ3I;Þ„^H‹¬$ÀI;îuH‹D$HH‹¨XH‹ÇI;þH‰D$@†êŠA:΄ü€ù%tsHT$H¾ÉèÃA;Æt;Hƒ|$@v3D8s„±ŠH‹„$ HÿÈH‹Œ$ HÿÁHÿL$@H‰Œ$ ëH‹Œ$ ŠHÿÈH‹D$@Hÿ„$ HÿÈH‰D$@ëSM;HÿÃA‹Æ€;#u¸HÿʉD$0HD$@LŒ$ HL$HM‹ÅH‰l$(H‰D$ èÉòÿÿA;ÆtH‹D$@HÿÃI;ÆéÿÿÿL9t$@v¾Eˆ4$A;öuAL9t$@w:è2Ç"ëLI;ÆvÞH‹Œ$ Dˆ1H+|$@D8t$`tH‹L$Xƒ¡ÈýH‹Çë4èÑ1E3ÉE3À3Ò3ÉL‰t$ Çè!D8t$`tH‹D$Xƒ Èý3ÀL\$pI‹[8I‹k@I‹ãA^A]A\_^ÃÌHƒì8H‹D$`H‰D$(Hƒd$ è×ýÿÿHƒÄ8ÃÌÌHƒì8Hƒd$(Hƒd$ è»ýÿÿHƒÄ8ÃÌÌHƒì8H‹D$`Hƒd$(H‰D$ è›ýÿÿHƒÄ8ÃÌÌH‰\$H‰t$H‰|$ ATHƒì@H‰d$0E‹àH‹úH‹ñ3ÀH…É•À…Àu'èø0ÇHƒd$ E3ÉE3À3Ò3ÉèA 3ÀéÉ3ÀH…Ò•À…Àu'èÅ0ÇHƒd$ E3ÉE3À3Ò3Éè 3Àé–3À8•À…Àu$è“0ÇHƒd$ E3ÉE3À3Ò3ÉèÜ3ÀëgèKÇH‹ØH‰D$PH…Àuè]0Ç3ÀëF€>u"èI0ÇHH‹L$0èŽÈ3ÀëL‹ÈE‹ÄH‹×H‹Îè/ÄH‹øH‹ËèðßÿÿH‹ÇH‹\$XH‹t$`H‹|$hHƒÄ@A\ÃÌÌÌA¸@é½þÿÿÌ@SHƒì0I‹ÀL‹ÊH‹ÙH…Éu%èÏ/Hƒd$ »E3ÉE3À3Ò3ɉè‹Ãë$A¸€H‹ÐI‹ÉèrþÿÿH‰H…Àt3Àëè/‹HƒÄ0[ÃÌH‰T$L‰D$L‰L$ SHƒì`H…Òu%èf/Hƒd$ E3ÉE3À3Ò3ÉÇ诃ÈÿëUH…ÉtÖH‰L$@H‰L$0LŒ$€HL$0E3ÀÇD$8ÿÿÿÇD$HBè²{ƒl$8‹Øx
H‹L$0ÆëHT$03ÉèÏ‹‹ÃHƒÄ`[ÃÌÌÌL‰D$L‰L$ Hƒì(LL$HèÇHƒÄ(ÃÌÌÌL‹ÜM‰CM‰K Hƒì8IC E3ÉI‰Cèè	ÊHƒÄ8ÃL‰L$ Hƒì8HD$`H‰D$ èìÉHƒÄ8ÃÌÌÌL‹ÜM‰K Hƒì8IC(I‰CðIƒcèè_ÊHƒÄ8ÃÌÌL‹ÜHƒì8IC0I‰CðI‹C(I‰Cèè<ÊHƒÄ8ÃÌÌÌL‹ÜM‰CM‰K Hƒì8IC E3ÉI‰CèèÅËHƒÄ8ÃL‰L$ Hƒì8HD$`H‰D$ è¨ËHƒÄ8ÃÌÌÌH‹ÄH‰HH‰PL‰@L‰H Hƒì(HPè€ÇHƒÄ(ÃÌÌÌH‹ÄH‰HH‰PL‰@L‰H Hƒì(HPèˆÇHƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(L@èLÇHƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(L@èXÇHƒÄ(ÃÌÌÌ@SHƒì@HcÙHL$ èÌÿÿH‹D$ ƒ¸~LD$ º‹ËèÎRD‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=žHcÙuH‹û†·X%ëYHL$ 3ÒèÌÿÿH‹D$ ƒ¸~LD$ º‹ËèIRD‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ è¡ËÿÿH‹D$ ƒ¸~LD$ º‹ËèâQD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=/HcÙuH‹†·XƒàëVHL$ 3Òè"ËÿÿH‹D$ ƒ¸~LD$ º‹ËècQD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ è½ÊÿÿH‹D$ ƒ¸~LD$ º‹ËèþPD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=KœHcÙuH‹/…·XƒàëVHL$ 3Òè>ÊÿÿH‹D$ ƒ¸~LD$ º‹ËèPD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ èÙÉÿÿH‹D$ ƒ¸~LD$ º‹ËèPD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=g›HcÙuH‹K„·XƒàëVHL$ 3ÒèZÉÿÿH‹D$ ƒ¸~LD$ º‹Ëè›OD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ èõÈÿÿH‹D$ ƒ¸~LD$ º€‹Ëè6OD‹ØëH‹€@D·XA　|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=šHcÙuH‹cƒ·X%€ëYHL$ 3ÒèpÈÿÿH‹D$ ƒ¸~LD$ º€‹Ëè±ND‹ØëH‹€@D·XA　|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ è	ÈÿÿH‹D$ ƒ¸~LD$ º‹ËèJND‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=—™HcÙuH‹{‚·XƒàëVHL$ 3ÒèŠÇÿÿH‹D$ ƒ¸~LD$ º‹ËèËMD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ è%ÇÿÿH‹D$ ƒ¸~LD$ º‹ËèfMD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=³˜HcÙuH‹—·XƒàëVHL$ 3Òè¦ÆÿÿH‹D$ ƒ¸~LD$ º‹ËèçLD‹ØëH‹€@D·XAƒã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@HcÙHL$ èAÆÿÿH‹D$ ƒ¸~LD$ º‹Ëè‚LD‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=Ë—HcÙuH‹¯€·X%ëYHL$ 3Òè¼ÅÿÿH‹D$ ƒ¸~LD$ º‹ËèýKD‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ èUÅÿÿH‹D$ ƒ¸~LD$ ºW‹Ëè–KD‹ØëH‹€@D·XAãW€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=ß–HcÙuH‹Ã·X%WëYHL$ 3ÒèÐÄÿÿH‹D$ ƒ¸~LD$ ºW‹ËèKD‹ØëH‹€@D·XAãW€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ èiÄÿÿH‹D$ ƒ¸~LD$ º‹ËèªJD‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ@SHƒì@ƒ=ó•HcÙuH‹×~·X%ëYHL$ 3ÒèäÃÿÿH‹D$ ƒ¸~LD$ º‹Ëè%JD‹ØëH‹€@D·XAã€|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@HcÙHL$ è}ÃÿÿH‹D$ ƒ¸~LD$ º ‹Ëè¾ID‹ØëH‹€@D·XAƒã €|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌ@SHƒì@ƒ=•HcÙuH‹ï}·Xƒà ëVHL$ 3ÒèþÂÿÿH‹D$ ƒ¸~LD$ º ‹Ëè?ID‹ØëH‹€@D·XAƒã €|$8tH‹D$0ƒ ÈýA‹ÃHƒÄ@[ÃÌÌ3Àù€’ÀÃá‹ÁÃÌÌ@SHƒì@HcÙHL$ è…ÂÿÿH‹D$ ƒ¸~LD$ º‹ËèÆHD‹ØëH‹€@D·XAã3É8L$8tH‹D$0ƒ ÈýD;Ùuƒû_u¹‹ÁHƒÄ@[ÃÌÌÌ@SHƒì ‹ÙèÛõÿÿ3Ò;Âuƒû_uº‹ÂHƒÄ [ÃÌÌÌ@SHƒì@HcÙHL$ èåÁÿÿH‹D$ ƒ¸~LD$ º‹Ëè&HD‹ØëH‹€@D·XAã3É8L$8tH‹D$0ƒ ÈýD;Ùuƒû_u¹‹ÁHƒÄ@[ÃÌÌÌ@SHƒì ‹Ù¶Éè„ûÿÿ3Ò;Âu€û_uº‹ÂHƒÄ [ÃÌÌÌÌH;Êt$M…ÀtfD¶D¶	HÿˆDˆJÿHÿÁIƒèuçóÃÌÌÌÌÌH;ц³H‰l$ WATAUHƒì H‰\$@H‰t$HL‰t$PN4M‹éI‹èH‹úL‹áff„I‹ÜI‹öL;÷wDH‹ÓH‹ÎAÿÕ…ÀHOÞHõH;÷véL‹ÅH‹×H;ßt%H…ít H+ßfD¶¶HÿÂIƒèˆDÿˆJÿuéH+ýI;üw¡L‹t$PH‹t$HH‹\$@H‹l$XHƒÄ A]A\_óÃÌÌ@UATAVAWHìM‹áI‹èL‹ñH…Éu6H…Òt1èý E3ÿE3ÉE3À3Ò3ÉÇL‰|$ èDHÄA_A^A\]ÃM…ÀtÊM…ÉtÅHƒú‚‹H‰œ$@H‰´$HH‰¼$PL‰¬$LjÿL¯íLéE3ÿfff„3ÒI‹ÅI+ÆH÷õHpHƒþw*M‹ÌL‹ÅI‹ÕI‹ÎèzþÿÿIƒïˆN‹tü0N‹¬ü ëÁHÑîI‹ÎH¯õIöH‹ÖAÿÔ…À~3L‹ÅH‹ÖL;öt(M‹ÎL+Îf„¶A¶HÿÂIƒèAˆDÿˆJÿuçI‹ÕI‹ÎAÿÔ…À~3L‹ÅI‹ÕM;õt(M‹ÎM+Íf„¶A¶HÿÂIƒèAˆDÿˆJÿuçI‹ÕH‹ÎAÿÔ…À~3L‹ÅI‹ÕI;õt(L‹ÎM+Íf„¶A¶HÿÂIƒèAˆDÿˆJÿuçI‹ÞI‹ýH;óvHÝH;ÞsH‹ÖH‹ËAÿÔ…À~ëH;ówHÝI;Ýw
H‹ÖH‹ËAÿÔ…À~ëH+ýH;þv
H‹ÖH‹ÏAÿÔ…ÀëH;ûr7L‹ÍH‹×H;ßtL‹ÃL+ǶA¶HÿÂIƒéAˆDÿˆJÿuçH;÷u‚H‹óézÿÿÿHýH;÷s"fH+ýH;þvH‹ÖH‹ÏAÿÔ…ÀtëH;÷rfDH+ýI;þv
H‹ÖH‹ÏAÿÔ…ÀtëI‹ÍH‹ÇH+ËI+ÆH;Á|&L;÷sN‰tü0J‰¼ü IÿÇI;݃"þÿÿL‹óéôýÿÿI;ÝsJ‰\ü0N‰¬ü IÿÇL;÷ƒüýÿÿL‹ïéÎýÿÿH‹¼$PH‹´$HH‹œ$@L‹¬$HÄA_A^A\]ÃÌÌÌH‰\$H‰t$WHƒì H‹ÚH‹ùH…Éu
H‹ÊèÆÁÿÿëjH…Òuè*Áÿÿë\HƒúàwCH‹
7¸H…ÛHDØL‹Ç3ÒL‹Ëÿ…šH‹ðH…Àuo97’tPH‹ËèH…Àt+Hƒûàv½H‹ËèïGèšÇ3ÀH‹\$0H‹t$8HƒÄ _Ãè}H‹ØÿX™‹Èè%‰ëÕèdH‹Øÿ?™‹Èè‰H‹Æë»Ì@SVWATAUHƒì@I‹Ø‹úL‹éL‹áH‹ñH…Éu*…Òt&è$ÇH!t$ E3ÉE3À3Ò3Éèn3Àé‹3À…Ò™À…Àu'èóÇHƒd$ E3ÉE3À3Ò3Éè<3ÀéY3ÀH…Û•À…Àu'èÀÇHƒd$ E3ÉE3À3Ò3Éè	3Àé&…Òu3ÀéH‰œ$ˆH‹ËèÓËÿÿöC@…šH‹Ëèøsƒøÿt*ƒøþt%HcÐH‹ÊHÁùLA­ƒâHkÒXIÈH
ozëH
fzH‹ÑL­öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€t'èÇHƒd$ E3ÉE3À3Ò3ÉèI3öH‰t$0H…ötVƒï‰|$xtHƒCÿxH‹¶HÿÀH‰ë
H‹Ë蔹‹È‰L$pƒùÿuM;åu3öH‰t$0ëAˆ$IÿÄL‰d$8€ù
të¯AÆ$H‹Ëè[ËÿÿH‹ÆHƒÄ@A]A\_^[ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„M…ÀtuH+ÑL‹ÊI»öÁtŠBŠ	HÿÁ:ÂuWIÿÈtN„ÀtJH÷ÁuáJ	fâÿfúøwÑH‹J‹	H;ÂuÅHƒÁIƒèIºÿþþþþþþ~vHƒðÿLÒI3ÂI…ÃtÁëH3ÀÃHÀHƒØÿÄÒt'„öt#HÁê„Òt„ötHÁê„Òt„ötÁê„Òt„öuˆH3ÀÃÌÌÌH‰\$WHƒì H‹ù»è‹ËÿN—H‹Ïÿ=—Ãèû`êwH…ÀtÜH‹\$0HƒÄ _ÃÌÌÌ@SHƒì ‹ÙèëC‹ËèAH‹
‰kè<¹ÿHƒÄ [HÿàÌÌÌ@SHƒì ‹ÙH
ÿ×–H…ÀtHûH‹Èÿ²•H…Àt‹ËÿÐHƒÄ [ÃÌÌÌ@SHƒì ‹Ùè·ÿÿÿ‹Ëÿ«–ÌÌ̹éþWÌ̹éÒVÌÌH;Ês-H‰\$WHƒì H‹úH‹ÙH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃÌH‰\$WHƒì 3ÀH‹úH‹ÙH;Ês…ÀuH‹H…ÉtÿÑHƒÃH;ßréH‹\$0HƒÄ _ÃÌÌÌHƒì8H…Éu'è>Hƒd$ E3ÉE3À3Ò3ÉÇ臸ëH‹±ƒH…ÀtÍH‰3ÀHƒÄ8ÃÌÌHƒì8H…Éu'èöHƒd$ E3ÉE3À3Ò3ÉÇè?¸ëH‹aƒH…ÀtÍH‰3ÀHƒÄ8ÃÌÌH‰\$WHƒì Hƒ=Ϋ‹ÙtH
ëèV»…Àt‹Ëÿ²«è…ºHŽ—H
_—èîþÿÿ…ÀuZH
/ºèÚ¹H3—H=4—ëH‹H…ÀtÿÐHƒÃH;ßríHƒ=g«tH
^«è麅ÀtE3À3ÉAPÿF«3ÀH‹\$0HƒÄ _ÃÌH‰\$H‰t$D‰D$WATAUAVAWHƒì@E‹à‹ÚD‹ù¹èVƒ=‚‚„üÇn‚Dˆ%c‚…Û…ÏH‹
Īè9H‹ðH‰D$0H…À„ŸH‹
Ÿªèr9H‹øH‰D$ L‹öH‰t$(L‹èH‰D$8HƒïH‰|$ H;þrè;9H9uëæH;þr\H‹è39H‹Øè9H‰ÿÓH‹
Oªè9H‹ØH‹
8ªè9L;óuL;èt L‹óH‰\$(H‹óH‰\$0L‹èH‰D$8H‹øH‰D$ ë…H(–H
–è,ýÿÿH%–H
–èýÿÿE…ät
¹èÙSE…äu&ÇbAL$èÀSA‹Ïè|üÿÿA‹Ïÿo“ÌH‹\$pH‹t$xHƒÄ@A_A^A]A\_ÃÌÌE3À3ÒéjþÿÿÌÌE3ÀAPé\þÿÿ3Ò3ÉDBéOþÿÿÌÌ̺3ÉD‹Âé=þÿÿÌ@SHƒì è8H‹ÈH‹Øè@H‹ËèBÅH‹ËèöH‹Ëè*ÅH‹Ëè.ÂH‹Ëè¾»H‹Ë膹H‹Ëèb¹H
ÿÿÿè¾7H‰3gHƒÄ [ÃÌ@SHƒì ƒ=—€‹Ùuèj?‹Ëè=¹ÿHƒÄ [éÈûÿÿ¸MZf9ÿÿu9Hc
GÿÿHÿÿHÈ9PEu ¸f9Au3Àƒ¹„v9ø•ÀÃ3ÀÃÌÌH‰\$H‰t$WHì HL$0ÿ/’¸MZf9ªÿÿubHcÝÿÿH5šÿÿHÆ8PEt3Û‰œ$°ëN¹f9Ht3Û‰œ$°ë8ƒ¸„w3Û‰œ$°ë$3Û9˜ø•Ã‰œ$°ë3Û‰œ$°H56ÿÿ¿‹Ïè–;…Àu!9=xuèM>¹èï;¹ÿè­úÿÿè°9…Àu!9=Nuè#>¹èÅ;¹ÿèƒúÿÿèöµè\[…Ày
¹èþùÿÿÿ,‘H‰E§ètÈH‰ñ~èpÇ…Ày
¹èÒùÿÿèUÄ…Ày
¹	è¿ùÿÿ‹ÏèTûÿÿ…Àt‹Èè­ùÿÿè´Ã@„|$l·T$pA¹
DEÊL‹À3ÒH‹Îètÿÿ‹ø‰D$ …Ûu‹ÈèNýÿÿèaýÿÿë‹øƒ¼$°u‹Èè@ýÿÿÌèVýÿÿ‹Çë¸ÿLœ$ I‹[I‹s I‹ã_ÃÌÌÌHƒì(ègÉHƒÄ(éþÿÿÌÌH‰L$HìˆH
Ñ~ÿ{L‹¼L‰\$XE3ÀHT$`H‹L$XèµuH‰D$PHƒ|$PtAHÇD$8HD$HH‰D$0HD$@H‰D$(H|~H‰D$ L‹L$PL‹D$XH‹T$`3Éècuë"H‹„$ˆH‰HH„$ˆHƒÀH‰Õ~H‹.H‰Ÿ}H‹„$H‰ ~Çv}	ÀÇp}H‹¥^H‰D$hH‹¡^H‰D$pÿ†‰à}¹è
É3ÉÿfH
úÿQƒ=º}u
¹èâÈÿ¸Œº	ÀH‹Èÿ"HĈÃÌÌH‰
a‚Ã@SHìàƒd$pHL$t3ÒA¸”è¦ÿÿL\$pH„$HŒ$L‰\$HH‰D$PÿûŽH‹œ$HT$@H‹ËE3Àè;tH…Àt;Hƒd$8H‹T$@HL$`H‰L$0HL$XL‹ÈH‰L$(HŒ$L‹ÃH‰L$ 3Éè÷së H‹„$èH‰„$H„$èH‰„$¨H‹„$èÇD$pÀÇD$tH‰„$€ÿEŽ3É‹Øÿ3ŽHL$Hÿ Ž…Àu…ÛuHè´ÇÿŠ‹ºÀH‹ÈÿôHÄà[ÃÌÌÌH‰\$WHƒì H‹ùH‹
$èÇ2H‹ÏH‹Øè¨2H‰
H‹ÃH‹\$0HƒÄ _ÃÌÌÌH‹
õ€é˜2Hƒì8H‹D$`H‰D$ è}þÿÿHƒÄ8ÃH‰\$H‰l$H‰t$WHƒì0H‹éH‹
º€A‹ÙI‹øH‹òèT2H…ÀtL‹T$`D‹ËL‹ÇH‹ÖH‹ÍL‰T$ ÿÐë%¹èßÆL‹\$`D‹ËL‹ÇH‹ÖH‹ÍL‰\$ èþÿÿH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌÌHƒì8Hƒd$ E3ÉE3À3Ò3Éè_ÿÿÿHƒÄ8ÃÌÌHƒì8H‹D$`H‰D$ èEÿÿÿHƒÄ8Ã@SHƒì ‹Ùèg‰HƒÄ [ÃÌÌÌ@SHƒì ‹ÙèW‰HƒÄ [ÃÌÌÌ@SHƒì ‹ÙèG‰HƒÄ [ÃÌÌÌH‹ÄSVWATAUAVAWHƒìPE3öE‹îA‹öD‰pD‰pD‰pANè˜MèL‹àHŒ$èÞ
A;ÆtL‰t$ E3ÉE3À3Ò3ÉèýÿÿHŒ$˜è8
A;ÆtL‰t$ E3ÉE3À3Ò3ÉèëüÿÿHŒ$ èR
A;ÆtL‰t$ E3ÉE3À3Ò3ÉèÅüÿÿèTÑ‹ØD‰5ÓAƒÏÿD‰=<`D‰=%`H
îöèIÇH‹øH‰D$@I;Æ„£D80„šH‹
˜I;Ît H‹ÑH‹ÈèhÆA;Æu	AwéÔH‹
sI;Ît襱ÿÿH‹ÏèGHHèèDH‰QI;Æu
¾éœH‹ÏèÚFL‹ÇHPH‹
,èDA;Æ„xL‰t$ E3ÉE3À3Ò3Éèêûÿÿé_H‹
þ~I;Îtè0±ÿÿL‰5í~H
6~ÿ‹ƒøÿ„,ÇÉ~‹
~kÉ<‰Œ$fD95K~t‹Q~‹ÂkÀ<ȉŒ$ë‹;~fD95y~t$‹~A;ÆtÇ„$˜+ÂkÀ<‰„$ ëD‰´$˜D‰´$ H„$¨H‰D$8L‰t$0¾?‰t$(I‹$H‰D$ E‹ÏL}3Ò‹ËÿIŠA;ÆtD9´$¨u
I‹$Dˆp?ëI‹$Dˆ0H„$¨H‰D$8L‰t$0‰t$(I‹D$H‰D$ E‹ÏL}3Ò‹Ëÿõ‰A;ÆtD9´$¨uI‹D$Dˆp?ëI‹D$Dˆ0¾‹œ$èF‰‹œ$˜è(‰‹œ$ è"‰¹èŠIA;ö…gA¿M‹ÏL‹ÇAW=I‹$èHÃA;ÆtL‰t$ E3ÉE3À3Ò3ÉèúÿÿIÿ€?-u	A½HÿÇH‹ÏèÂÂD‹ØEiÛD‰œ$³0@¶9Š<+„ó:Ã|	@:ÆŽæ€?:ulHÿÇH‹Ïè„ÂkÀÿÿÿƒÈÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A\ÃÌÌÌH‰\$H‰t$WHƒì0I‹ØH‹úH‹ñè?!…ÀtHƒd$ E3ÉE3À3Ò3Éè"ÙÿÿHC@€8tL
ÕA¸H‹×H‹ÎH‰D$ èØýÿÿHƒ€€8tL
íÔA¸H‹×H‹ÎH‰D$ è¯ýÿÿH‹\$@H‹t$HHƒÄ0_ÃÌÌÌH‰\$UVWATAUAVAWHƒì0H‹ÙA¼¹UA‹üèF!H‹ðH‰„$€3ÀH;ð„‘HnLkhED$ˆED‰&I‹EL‹
jÓH‰D$(HfÔºQH‹ÍH‰D$ è ýÿÿM‹üL£ˆL5;Ó3öL6ÔºQH‹Íè¥Æ;ÆtE3ÉE3À3Ò3ÉH‰t$ èØÿÿI‹$I‹Mèø¡ºQA¸;ÆH‹ÍEþIÿÇIƒÆM‹I‹ÇIƒÄ HÁàLlHI‹EH‰D$(HËÓH‰D$ èüÿÿLÓM;óŒpÿÿÿH‹´$€E3íA;ýuHH‹KXƒÏÿI;Ít‹ÇðÁÇu	H‹KXèÎŒÿÿH‹S`I;Õt‹ÏðÁ
Ïu	H‹K`貌ÿÿH‰sXH‰kHH‹ÅëRH‹ÎèŒÿÿH‹KXƒÏÿI;Ít‹ÇðÁÇu	H‹KXè~ŒÿÿH‹S`I;Õt‹ÏðÁ
Ïu	H‹K`èbŒÿÿH‹ƒˆL‰kXL‰kHL‰kPL‰k`H‹\$pHƒÄ0A_A^A]A\_^]ÃÌÌ@SUVWATAUAVAWHìøH‹í4H3ÄH‰„$àH‹´$`I‹ùM‹øH‹êH‹Ùè-HˆpL°hE3äH‰L$@HˆtL‰t$0L¨÷H‰L$8I;Ü„¤I;ì„›M;ü„’€;CuTD8cuNLRÒI‹×H‹Íè7A;ÄtE3ÉE3À3Ò3ÉL‰d$ èÖÿÿI;ütfD‰'fD‰gfD‰gI;ôtD‰&H‹Åé;H‹Ëè¯ L‹àH=ƒs(H‹ÓI‹ÍèÙŸ…À„¹H‹L$8H‹ÓèÄŸ…À„¤HL$PH‹ÓE3öèìúÿÿ…À…æH‹T$0LD$PHL$Pè¼Í…À„ÊH‹D$0H‹L$@LD$P·@ºƒ‰I‹ÍèüÿÿD83tIüƒsM‹ôëHiH‹L$8MNL‹ÃºƒèNž…ÀtHƒd$ E3ÉE3À3Ò3ÉèÕÿÿL‹t$0H…ÿtA¸I‹ÖH‹Ïè²|ÿÿH…ötH‹T$@A¸H‹Îèš|ÿÿM‹ÅI‹×H‹Íèà…ÀtHƒd$ E3ÉE3À3Ò3ÉèÃÔÿÿI‹Åë3ÀH‹Œ$àH3ÌèÜÿÿHÄøA_A^A]A\_^][ÃH‰\$ UVWATAUAVAWHìH‹ª2H3ÄH‰„$I‹ØLcúH‹ùèõ	LL$HHT$pH‹ðHD$@A¸ƒH‹ËD‰|$(H‰D$ è_ýÿÿH…Àu3ÀéoI‹ßHL$pHÁãH‹T;Hèž…À„LHL$pèÃH‹èHHè§L‹àH…Àt½H‹D;HMoHL$hH‰D$XB‹¯A¸‰D$PKDHGH‹ÐH‰D$`èh{ÿÿ‹GHULD$pIL$‰D$D袅ÀtHƒd$ E3ÉE3À3Ò3Éè…ÓÿÿH‹L$`ID$HT$HH‰D;H·D$HA¸B‰¯è
{ÿÿAƒÿ…‹D$@E3À3Ò‰GH‹Žœ‹„Ö|9Gt!H‹„Ö|H‰ŒÖ|HÿÂAÿÀHƒúH‹È|ÕëE…ÀtIcÐH‹„Ö|H‰†|H‰ŒÖ|Aƒø…’‹GAhzÇD$8‰D$0‹GLMΉD$(H„$U‚D‹Í3ÉH‰D$ èK°…ÀtCH„$¹ÿf!HƒÀHƒíuîH‹j=HŒ$A¸þè'Í3É…À”Á‰Ž€ëƒ¦€‹G‰†|‹†€‰‡Aƒÿu‹D$@‰GKH4ÍH‹ÏÿÂ…ÀH‹D$Xt"I‹ÌH‰D;Hèt‡ÿÿD‹\$P‹D$DF‰¯‰GéÑýÿÿH
ì<H;Át)H‹T;XðƒÿuH‹L;Xè>‡ÿÿIÁåI‹L=è0‡ÿÿHƒd;PAÇ$L‰d;XH‹D;HH‹Œ$H3ÌèÜ~ÿÿH‹œ$hHÄA_A^A]A\_^]ÃÌ@SUVWATAUAVHìÐH‹§/H3ÄH‰„$ÀI‹ØH‹ù…Òt H…Ût
èÀüÿÿéIHcÂHÁàH‹DHé83öDfH…Û„$A€8L…AA€xC…6A€x_…+H$ÍH‹Ëè|ÌH‹èH…À„„L‹èL+ë„x€8;„oA¾L%ÞËI‹$M‹ÅH‹Óè—Çÿÿ…ÀuI‹$èzL;ètHÌIƒÄAÿÆL;à~ÌHÿÅH¤ÌH‹Í褿H‹ØH…Àu
€};…
AƒþJHL$0L‹ÈL‹Åºƒè{™…ÀtHƒd$ E3ÉE3À3Ò3ÉèJÐÿÿLD$0A‹ÖH‹ÏÆD0èûÿÿH…ÀtÿÆHÝ€;tHÿÀ;…ÿÿÿ…ö„žH‹ÏèJ÷ÿÿH‹Œ$ÀH3Ìè*}ÿÿHÄÐA^A]A\_^][Ã!t$(H!t$ HT$0E3ÉA¸ƒH‹ËèñøÿÿH…Àtº3ÛHoH…Ût-H‹UHL$0謙…ÀtLD$0‹ÓH‹ÏèûÿÿH…ÀuE3äëÿÆÿÃHƒÅ ƒû~ÄE…ä…gÿÿÿéZÿÿÿ3ÀécÿÿÿÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì H‹ò‹éƒùw+H…Òt&A¼I‹ÔAL$èMH‹ØH…Àu(èHáÿÿÇ3ÀH‹\$0H‹l$8H‹t$@H‹|$HHƒÄ A\ÃI‹Ô¹`èH‰H…Àu
H‹Ëè@„ÿÿë¹I‹Ô¹ èñH‰CH…Àu
H‹è „ÿÿëÖH‹;H…ÿt%H³9H;útH‹ÏA¸`èPvÿÿƒ'H‹ÏèùîÿÿH‹L‹Æ‹ÕèøüÿÿH…ÀtH‹H‹S‹Hèdèÿÿ…Àt%H‹KèÃÿÿH‹è[ïÿÿH‹è?íÿÿH‹Ë諃ÿÿ3ÛëH‹CD‰ H‹CD‰ H‹ÃéÿÿÿÌéÃþÿÿÌÌÌH‰t$H‰|$L‰d$ AUAVAWHƒì@L‹êD‹ñE3äƒùv&è$àÿÿÇL!d$ E3ÉE3À3Ò3ÉènÏÿÿ3Àé¶ènH‹ðH‰D$pèýïÿÿƒŽÈº¹`èÓH‹øH…À„x¹èùH‹–ÀH…ÒtH;útH‹ÏA¸`è1uÿÿƒ'H‹ÏèÚíÿÿ¹è£M‹ÅA‹ÖH‹ÏèÍûÿÿL‹àH‰D$0H…À„M…ít)H08I‹Íè8—‹
‚P…ÀA½AE͉
pPëA½¹èfH‹×HŽÀèÖîÿÿH‹Ïèòíÿÿö†È…œD„-Ê7…H‹–ÀH
.9è¡îÿÿH‹"9HƒÂA¸H
	Pè\tÿÿL‹9A‹C‰PA‹C‰PA‹ƒ‰ì8I‹ƒXH‰Þ/I‹ƒ(H‰p>I‹ƒ@H‰ê=A‹ƒ‰]>¹è{ëH‹Ïè5íÿÿèëÿÿƒ¦ÈïI‹ÄH‹t$`H‹|$hL‹d$xHƒÄ@A_A^A]ÃÌÌÌHÿ%}[Ì3ÉHÿ%s[ÌÌÌHÿ%q[ÌHÿ%q[ÌHÿ%q[Ì‹Z8ÃÌ3ÀÃÌHÿ%e[ÌHƒì(‹
B8ƒùÿt
ÿW[ƒ
08ÿHƒÄ(é[ÌÌÌH‰\$WHƒì H‹úH‹ÙHMÎH‰ ÇAÇÈÆtCÆ÷CH1H‰¸¹
è§H‹ƒ¸ðƒ¹
èq¹è‡H‰»ÀH…ÿuH‹{7H‰ƒÀH‹‹Àèlëÿÿ¹è5H‹\$0HƒÄ _ÃÌÌH‰\$WHƒì ÿèX‹
Z7‹øÿbZH‹ØH…ÀuHHºÈèÙH‹ØH…Àt3‹
/7H‹Ðÿ>ZH‹Ë…Àt3Òèôþÿÿÿ:ZHƒKÿ‰ëèàÿÿ3Û‹ÏÿÂXH‹ÃH‹\$0HƒÄ _Ã@SHƒì èqÿÿÿH‹ØH…ÀuHèÂÿÿH‹ÃHƒÄ [ÃH…É„+H‰\$WHƒì H‹ÙH‹I8H…Étè€ÿÿH‹KHH…ÉtèrÿÿH‹KXH…ÉtèdÿÿH‹KhH…ÉtèVÿÿH‹KpH…ÉtèHÿÿH‹KxH…Étè:ÿÿH‹‹€H…Étè)ÿÿH‹‹ HÌH;Ètèÿÿ¹
èH‹‹¸H‰L$0H…ÉtðƒÿuHA‹Ì”Á‰Œ$H;=Y>utH‹÷A‹ÄI;üuI‹üë]HƒÇÿÀL9'uõÿÀºHcÈè™
H‹ØH‹øI;Äu¹	è4¹ÿÿëH‹Èè¶ÁH‰HƒÃHƒÆH‹I;Äuå‹Œ$L‰#‹œ$ˆH‰=Û=I;ü…ªH‹»=A;ÜtKI;ÄtFèdÄH‰í=è ÃA;Ä}|èNÂA;ÄtrèÓÿÿǃÈÿH‹œ$˜HƒÄ@A_A^A]A\_^]ÃA;Ìt3ÀëßI;Äu%¹èk	H‰L=I;ÄtÁL‰ H‹=M=I;üu ¹èF	H‰7=I;ÄtœL‰ H‹=(=H‹÷I;ütŠH‹M+÷3ÉIÑþH‹ßMcæH;ÁtCy=M‹ÄH‹ÐI‹ÏèÀ3É;ÁuH‹fB9<`„ªfB9`„ŸHƒÃH‹H;ÁuÇH‹=Ç<H+ßHÁû÷Û;ÙŒCH9„:HcûH‹þèUuÿÿD‹¤$3ÉD;átjH9þtHLþ3ÒH‹ÿÃHƒÁH‰þHÿÇH9þuêHcÓH¸ÿÿÿÿÿÿÿH;Ðs=H‹
V<A¸èË	3ÿH;Çt&H‰=<ëH‹=4<H+ßHÁûéjÿÿÿL‰<þI‰M3ÿ9¼$ˆ„mI‹Ïè•»HH‹ÓèlH‹ðH;Ç„HI‹ÏèpM‹ÇH‹ÎHèù¿3É;ÁtE3ÉE3À3ÒH‰L$ è¿ÿÿ3ÉJGØ‹ÃHƒÄ [Ëþ=‰
ø=ÃÌÌÌH‰\$H‰l$H‰t$WHƒì 3ÿH‹ñƒÍÿH‹ÎèmÿÿH‹ØH…Àu(9Â=v ‹ÏÿFDŸèD;ª=A‹ûGý;ýuÈH‹l$8H‹t$@H‹ÃH‹\$0HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3ÿH‹òH‹éAƒÌÿE3ÀH‹ÖH‹Íè)½H‹ØH…Àu*9G=v"‹Ïÿ‰EDŸèD;/=A‹ûAGüA;üuÀH‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3öH‹úH‹éAƒÌÿH‹×H‹Íè4ªÿÿH‹ØH…Àu/H…ÿt*9Á<v"‹ÎÿEDžèD;©<A‹óAGôA;ôu¾H‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌÌÌH‰\$H‰l$H‰t$WATAUHƒì 3öI‹øH‹êAƒÍÿL‹áL‹ÇH‹ÕI‹Ìè˼H‹ØH…Àu/H…ÿt*94<v"‹ÎÿvDDžèD;<A‹óAGõA;õu»H‹l$HH‹t$PH‹ÃH‹\$@HƒÄ A]A\_ÃÌÌÌÌÌÌff„H‹ÁH÷ÙH©tfŠHÿÀ„Òt_¨uóI¸ÿþþþþþþ~I»H‹M‹ÈHƒÀLÊH÷ÒI3ÑI#ÓtèH‹Pø„ÒtQ„ötGHÁê„Òt9„öt/HÁê„Òt!„ötÁê„Òt
„öu¹HDÿÃHDþÃHDýÃHDüÃHDûÃHDúÃHDùÃHDøÃ3ÀH…Òt€9tHÿÀHÿÁH;ÂrðóÃÌÌÌH‰\$H‰t$WHƒìPH‹Ù‹úHL$0I‹Ðè¿eÿÿ3öH;ÞuDèsÆÿÿE3ÉE3À3Ò3ÉH‰t$ Çè½µÿÿ@8t$HtH‹D$@ƒ Èý3ÀH‹\$`H‹t$hHƒÄP_ÃH‹T$89ru‹×H‹Ëè|Zÿÿ@8t$HtÕH‹L$@ƒ¡ÈýëǶf;Ît3¶ÁöDtHÿÃ@83t˜¶·ÉÁáÈ;ùu
HCÿë¼·Á;øtHÿÃëÅ·Á;ø…lÿÿÿ@8t$HtH‹D$@ƒ ÈýH‹ÃéfÿÿÿÌÌE3ÀéÿÿÿH‹ÄH‰XH‰hH‰p H‰PWATAUAVAWHƒì@M‹yM‹!I‹q8M+çöAfM‹ñH‹êL‹é…Ü3ÿH‰HÈL‰@Ð9>†+H^‹CøL;à‚§‹CüL;àƒ›ƒ{„‘ƒ;t‹HL$0H‹ÕIÇÿÐ…Àˆ„~sA}csmàu(Hƒ=ãWtH
ÚWè¥g…ÀtºI‹ÍÿÃW‹KA¸H‹ÕIÏèO]I‹F@‹SMcMH‰D$(I‹F(I×M‹ÅH‹ÍH‰D$ ÿï@èR]ÿÇHƒÃ;>sjé>ÿÿÿ3ÀëfI‹y 3íI+ÿ9.vTH^‹KôL;ár>‹CøL;às6H;ùrH;øsAöE u/ƒ;t	‹H;øt#ëH‹T$xIDZI‰D‹CüMÇAÿÐÿÅHƒÃ;.r°¸L\$@I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰t$H‰|$ATHƒì L%Ì3ö3ÿI‹Üƒ{u%Hcƺ ÿÆH€HJ8HÈH‰èÒr…Àt-HÓ!HƒÃÿÇH;Ø|øH‹\$0H‹t$8H‹|$@HƒÄ A\ÃHcÇHÀIƒ$Ä3ÀëÛÌÌH‰\$H‰l$H‰t$WHƒì HAH-z!H‹ûH‹7H…ötƒtH‹Îÿx?H‹ÎèdfÿÿHƒ'HƒÇH;ý|ÔH‹H…Étƒ{uÿO?HƒÃH;Ý|ãH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌHcÉHÎHÉH‹ÈHÿ%x?Hƒì(H‹Ñ3Éÿ?¹ÿHƒÄ(é˨ÿÿÌÌÌH‰\$H‰t$H‰|$AUHƒì HcÙ¾Hƒ=ã3uè(ìÿÿNèÌéÿÿ¹ÿ芨ÿÿH‹ûHÿL-UIƒ|ýt‹Æë{¹(èßøÿÿH‹ØH…ÀuèFÂÿÿÇ3ÀëZ¹
èfIƒ|ýu/º H‹Ëè‹ÆH‹\$0H‹t$8H‹|$@HƒÄ A]ÃH‰\$WHƒì HcÙH=¤HÛHƒ<ßuèõþÿÿ…ÀuHèE§ÿÿH‹ßH‹\$0HƒÄ _Hÿ%$>H‰\$H‰l$H‰t$WHƒì H‹Ú…Éxi;
?RsaHcùH-GRH‹÷ƒçHÁþHkÿXH‹DõHƒ<ÿu=ƒ=Žu'…Étƒétƒùu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿÿ5;H‹DõH‰3ÀëèÿÀÿÿÇ	èÁÿÿƒ ƒÈÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌH‰\$H‰l$WHƒì …Éxs;
—QskHcÙH-ŸQH‹ûƒãHÁÿHkÛXH‹DýöDtGHƒ<ÿt@ƒ=ßu)…Étƒétƒùu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿ3Òÿ„:H‹DýHƒÿ3ÀëèMÀÿÿÇ	èbÀÿÿƒ ƒÈÿH‹\$0H‹l$8HƒÄ _ÃHƒì8ƒùþuè>Àÿÿƒ èÀÿÿÇ	ë]…Éx1;
ÜPs)HcÑH
äPH‹ÂƒâHÁøHkÒXH‹ÁöDtH‹ë,èô¿ÿÿƒ èÌ¿ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ	è¯ÿÿHƒÈÿHƒÄ8ÃH‹ÄH‰XH‰pH‰xL‰` AUHƒì HcÙL‹ãIÁüL-jPƒãHkÛXK‹t心|3u3O	è’ýÿÿƒ|3uHL3º ègn÷ØÒ#úÿD3¹
èGüÿÿ…ÿtK‹LåHLÿ»;‹ÇH‹\$0H‹t$8H‹|$@L‹d$HHƒÄ A]ÃÌÌHcÑH
âOH‹ÂƒâHÁøHkÒXH‹ÁHLHÿ%|;H‰\$H‰|$L‰d$AUAVAWHƒì@IƒÌÿE‹ìE3öAL$è÷ûÿÿ…ÀuA‹ÄéɹèÉüÿÿ3ÿ‰|$$HsOƒÿ@›LcÿJ‹øH…Û„H‰\$0J‹øHH;؃ÍöC…ªƒ{u;¹
èpüÿÿƒ{u HKº èGm…ÀuDpD‰t$(ëÿC¹
èûÿÿE…öu HKÿ˜:öCtHKÿ:ëHIƒÌÿE…öu?ÆCL‰#L¿NK+øH¸£‹.ºè¢‹.H÷ëL‹êIÁýI‹ÅHÁè?Lè‹ÇÁàDèD‰l$ ëHƒÃXH‰\$0IƒÌÿHzNé ÿÿÿE;ì…ÿlj|$$H_NéçþÿÿºXJÈèYôÿÿH‰D$0H…ÀttHc×L9NI‰ЃN I‹ÐHÁH;ÁsÆ@L‰ Æ@	
ƒ`HƒÀXH‰D$0ëÖÁç‰|$ HcÏH‹ÁHÁøƒáHkÉXI‹ÀÆD‹ÏèHýÿÿ…ÀADüD‹ï‰|$ ¹èíùÿÿA‹ÅH‹\$`H‹|$hL‹d$pHƒÄ@A_A^A]ÃH‹ÄH‰XH‰pH‰x ATHƒì0L‹á3ÿ‰xèöÂ@¶ßG Eغâs€Ë€„Òy€Ëÿ9;ÇuÿV8‹È諼ÿÿƒÈÿ鉃øu€Ë@ëƒøu€ËètýÿÿHcð‰t$Hƒþÿuè;¼ÿÿÇèP¼ÿÿ‰8ÆëPI‹Ô‹Îè˜úÿÿ€ËH‹ÖH‹ÎHÁùLøLƒâHkÒXI‹Ȉ\I‹È€d8€I‹È€d8ÇD$ ‹ÎèÜüÿÿ‹ÆH‹\$@H‹t$PH‹|$XHƒÄ0A\ÃH‹ÄH‰XH‰hVWATAUAVHƒì`ƒ`¨ƒ`¬ƒ`™”øÿÿMcñHcòƒûFŒZûLNFÿƒø‡BAƒþ‡8Lc¤$°Aƒü;‡&Lc¬$¸Aƒý;‡AƒøŒ
H
iAº…ëQD‹L±ü‹±A+ÉA;È}[‹Ã™ƒâƒà;ÂuA‹Â÷ëÁú‹ÂÁèÐkÒd;Úu#‹lA‹Â÷éÁú‹ÂÁèÐiÒ;Ê…¥ƒþ…œAƒø’‹ÃC,™ƒâƒà;ÂuA‹Â÷ëÁú‹ÂÁèÐkÒd;Úu‹lA‹Â÷éÁú‹ÂÁèÐiÒ;Êuƒþ~ÿÅ‹+A‹ÂDCÿ÷éD‹ÊA‹ÂAÁùA‹ÉÁéDÉA÷èÁúA‹À‹ÊÁéÑD+Ê™ƒâÂÁøALïHcÃHƒèFHcÑHiÀmHÐHcÅHÐHRI<ÎHkÿÿtkHƒ>þteAöEt^AöEuH‹ÿô3A;ÇtILcçI‹ÄHÁøAƒäMkäXM$ÆH‹I‰$AŠEAˆD$IL$º èFfA;ÇtAÿD$ëƒÈÿéÕÿÇIÿÅHƒÆ;û|‚E‹çI‹ÿH‹ßHkÛXHÝGHƒ;ÿtHƒ;þt€K€ëÆCAD$ÿ÷ØɃÁõ¸öÿÿÿE;çDÈÿê0H‹ðHƒøÿtJI;ÇtEH‹Èÿ;3A;Çt7H‰3¶Àƒøu€K@ë	ƒøu€KHKº èšeA;ÇtÿCëƒÈÿë.€K@HÇþÿÿÿAÿÄHÿÇHƒÿŒQÿÿÿ‹
"Gÿx23ÀëƒÈÿLœ$I‹[ I‹s(I‹{0M‹c8I‹ãA_A^A]ÃÌÌÌH‰\$WHƒì HóFH‹;H…ÿt7H‡ëƒt
HOÿ*2H‹HƒÇXHH;ørÞH‹èYÿÿHƒ#H­HHƒÃH;Ø|±H‹\$0HƒÄ _ÃÌH‰\$H‰|$ATHƒì H‹Ùè
‹Èè-«…À„—è¼cÿÿHƒÀ0H;Øu3ÀëèªcÿÿHƒÀ`H;Øuw¸ÿ®÷CucL%,HcøIƒ<üu+¹èÂëÿÿI‰üH…ÀuHC H‰CH‰¸‰C$‰CëI‹üÇC$ÇCH‰KH‰K¸ë3ÀH‹\$0H‹|$8HƒÄ A\ÃÌÌÌ…Ét0SHƒì ºbH‹ÚsH‹Êè‘cÿîÿÿƒc$Hƒ#HƒcHƒÄ [ÃÌÌÌ@SHƒì öB@I‹ØtHƒzuAÿë&ƒBÿx
H‹ˆHÿ¶Áë¾ÉèFƒøÿu	ëÿHƒÄ [ÃÌ…Ò~LH‰\$H‰l$H‰t$WHƒì I‹ùI‹ð‹Ú@ŠéL‹ÇH‹Ö@ŠÍÿËè…ÿÿÿƒ?ÿt…ÛçH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì Aö@@I‹ùI‹ð‹ÚH‹étIƒxuAë7…Ò~3ŠML‹ÇH‹ÖÿËèÿÿÿHÿŃ?ÿuè±³ÿÿƒ8*uL‹ÇH‹Ö±?èÿþÿÿ…ÛÍH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌHƒH‹‹@øÃÌHƒH‹H‹@øÃHƒH‹f‹@øÃH‰\$UVWATAUAVAWHìÐH‹NÿH3ÄH‰„$È3ÀH‹ÙH‰L$hH‹úHL$xI‹ÐM‹é‰D$`D‹à‰D$TD‹ð‰D$H‰D$X‰D$Pè@RÿÿE3ÒI;ÚuAèó²ÿÿ3ÛE3ÉE3À3Ò3ÉÇH‰\$ è;¢ÿÿ8œ$tH‹„$ˆƒ ÈýƒÈÿéýAƒÏÿöC@L
¼þÿ…ºH‹Ëè"
H¿A;Çt(ƒøþt#LcÀL
ë»þÿI‹ÈAƒàHÁùMkÀXM„É€‡ë
L‹ÂL
È»þÿAö@8u)A;ÇtƒøþtHcÐH‹ÂƒâHÁøHkÒXI”Á€‡öB8€tAè'²ÿÿ3ÛE3ÉE3À3Ò3ÉÇH‰\$ èo¡ÿÿ8œ$tH‹„$ˆƒ ÈýA‹Çé1E3ÒI;út·@Š/A‹òD‰T$@D‰T$DA‹ÒL‰”$˜A:ê„êH‹œ$¨A»HÿÇA;òH‰¼$°ŒÈEà8öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€t"è"§ÿÿÇH‰\$ E3ÉE3À3Ò3Éèl–ÿÿƒÎÿ;óu(H‹ÏèMñÿÿ‹ØL‹L$pM‹ÅI‹ÔH‹ÏAÿÖ‹ðH‹×‹ËèòÿÿH‹Ïè±Vÿÿ‹ÆH‹\$PH‹t$`H‹|$hHƒÄ0A^A]A\ÃÌHƒì8L‰L$ M‹ÈL‹ÂH‹ÑH
;óÿÿèVþÿÿHƒÄ8ÃÌHƒì8L‰L$ M‹ÈL‹ÂH‹ÑH
O¢è2þÿÿHƒÄ8ÃÌHƒì8L‰L$ M‹ÈL‹ÂH‹ÑH
³¯èþÿÿHƒÄ8ÃÌHƒì8L‰D$ L‹ÂH‹ÑH
ÒòÿÿE3ÉèêýÿÿHƒÄ8ÃÌHƒì8L‰D$ L‹ÂH‹ÑH
æ¡E3ÉèÆýÿÿHƒÄ8ÃÌHƒì8L‰D$ L‹ÂH‹ÑH
J¯E3Éè¢ýÿÿHƒÄ8ÃÌH‰\$H‰t$ATHƒì03öNèöãÿÿ^‰\$ ;I}iLcãH‹Ü8Jƒ<àtPJ‹àöAƒtè>[ÿÿƒøÿtÿƉt$$ƒû|1H‹¯8J‹àHƒÁ0ÿ±!H‹
š8J‹áè•HÿÿL‹Š8Kƒ$ãÿÉ\$ ë¹èSâÿÿ‹ÆH‹\$@H‹t$HHƒÄ0A\ÃH‰\$H‰t$WHƒì ‹A3öH‹Ù$<u?÷At6‹9+y…ÿ~-è€üÿÿH‹SD‹Ç‹ÈèÊ3;Çu‹C„Àyƒàý‰CëƒK ƒÎÿH‹Kƒc‹ÆH‹t$8H‰H‹\$0HƒÄ _ÃÌÌÌ@SHƒì H‹ÙH…Éuè5ë,èjÿÿÿ…ÀtƒÈÿëºcsH‹Ëèüÿÿ‹Èè/À÷ØÀë3ÀHƒÄ [ÃÌH‰t$H‰|$L‰d$AUAVAWHƒì0D‹ñE3ä3öNèsâÿÿ3ÿ‰|$ AƒÏÿ;=zG†LcïH‹R7Jƒ<ètjJ‹èöBƒt`‹Ïè¶SÿÿH‹27J‹èöAƒt5Aƒþuè9ÿÿÿA;Çt%AÿÄD‰d$$ëE…öuöAtèÿÿÿA;ÇAD÷‰t$(H‹ì6J‹ê‹ÏèåSÿÿÿlj|$ énÿÿÿ¹è¬àÿÿAƒþADô‹ÆH‹t$PH‹|$XL‹d$`HƒÄ0A_A^A]ÃH‰\$H‰L$WHƒì H‹ÙH…Éuèðþÿÿëè¡RÿÿH‹Ëè˜þÿÿ‹øH‹ËèSÿÿ‹ÇH‹\$8HƒÄ _Ã̹é¾þÿÿÌÌH‹ÄH‰XH‰hH‰p ‰HWHƒì H‹ÊH‹ÚèŠúÿÿ‹KHcðöÁ‚uèò¢ÿÿÇ	ƒK ƒÈÿé4öÁ@t
èÖ¢ÿÿÇ"ëâ3ÿöÁt‰{öÁ„‰H‹CƒáþH‰‰K‹C‰{ƒàïƒÈ‰C©u/èÏPÿÿHƒÀ0H;ØtèÁPÿÿHƒÀ`H;Øu‹Îè˜;ÇuH‹ËèÁ÷C„‹+H‹S+kHBH‰‹C$ÿÈ;ï‰C~D‹Å‹Îè1‹øëWƒÉ ‰Ké?ÿÿÿƒþÿt#ƒþþtH‹ÎH‹ÆHü2ƒáHÁøHkÉXHÂëH
$öA t3Ò‹ÎDBèI¿Hƒøÿ„ïþÿÿH‹KŠD$0ˆë½HT$0‹ÎD‹Åè›0‹ø;ý…Åþÿÿ¶D$0H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌÌÌH‰\$H‰t$WHƒì I‹ñI‹øH‹ÚH;
udM9u=H‹ºè]ØÿÿH‰H…Àu3ÀëKH‹D$PH‹ÖÇL‹H‹èÌ6ÿÿL‹MÛL‰ë"H‹H‹A¸è(ÙÿÿH…ÀtÂH‰H‹HÉH‰¸H‹\$0H‹t$8HƒÄ _ÃÌÌH‹H‹€(ÃÌ@SHƒì ¾Ù¶Éè—vÿÿ‹Ëƒá߃é…ÀEË‹ÁHƒÄ [ÃÌÌHƒì(ƒAÿxH‹¶HÿÀH‰ëè‹>‹Ð‹ÂHƒÄ(ÃÌÌHƒì(ƒùÿtè‚¿HƒÄ(ÃÌH‰\$H‰t$WHƒì H‹òH‹ùÿH‹Îè¥ÿÿÿ‹Øƒøÿt¶Èèæwÿÿ…ÀuãH‹t$8‹ÃH‹\$0HƒÄ _ÃH‰\$UVWATAUAVAWHì€H‹6ìH3ÄH‰„$pE3ÿL¤$L‰Œ$°I‹ØH‹êH‰T$PL‰d$pH‹ñH‰L$`HÇ„$ ^D‰|$|fD‰|$xA‹ÿD‰|$ÿÿŠEA‹ßDˆ|$9E‹ïD‰|$4‰\$lA:Ç„Í»A´%¶ÈèSvÿÿA;ÇtXD+ëë»DëH‹ÎD‰l$4èäýÿÿ‹ØA;Æt¶Èè%vÿÿA;Çu×H‹Ö‹Ëè~½»Hë¶MèvÿÿA;ÇuïH‰l$PéÒD8e…kD8e„P3ÀD‰|$\Dˆ¼$€D‰|$LA‹ÿE‹ïDˆ|$XDˆ|$@Dˆ|$0AŠ÷D‰¼$¨L‹|$P@ŠèD‹àˆ\$8LûA¶‹ËèÁsÿÿ3Ò;ÂtvCD­ÿÇDlCлŠL$0@:òtÒ‰|$h‹|$H‹D$pLŒ$LD$p@ˆ<HD$|HÿÃH”$ H‹ËH‰D$ èJ÷ÿÿA;Ç„p	ëƒø+u$‹Å¹+éA;ÇuA‹ïëDéI‹Ìèè÷ÿÿ‹ø‰D$<@¶Ïë`‹Å¹+éA;Çt\H‹D$pñLŒ$@ˆ<HÙHD$|LD$pH”$ H‹ËH‰D$ èÍöÿÿA;Ç„óI‹ÌAÿÅè…÷ÿÿ‹ø‰D$<¶Èè÷mÿÿA;Çu–¸D+èD‰l$4A;þtI‹Ô‹Ïè·¸A;÷„«D8|$0u7H‹t$pD$lDˆ<3¾\$8H‹
Äö+Øè͹ÿÿH‹”$˜LŒ$ÀL‹Æ‹ËÿÐH‹l$Pé£A»;ÂuD‰\$hAó@:êH‹l$PŽùEŠûéñAƒýp„àAƒýs„ÇAƒýu„çAƒýx„üÿÿAƒý{tBH‹l$P¶E;Ç…ÒŠT$9D‹l$4E3ÿAÖˆT$9A:Ï… L‹Œ$àL‰Œ$°é@:êH‹l$P¸E¶ÿDOøHè€}^uHÿÅDˆt$X3ÒHŒ$èDB èƒ+ÿÿ€}]A»uA´]IëÆ„$ó ŠE<]„E3öIë<-uVE:ætQŠM€ù]tIIëD:ásDŠÉëEŠÌDŠáE:áw,E¶ÔA¶ÄM‹ÂA‹ÓƒàIÁèEãŠÈMÓÒâB”èE:ávØEŠæë D¶ÀDŠà¶ÀƒàA‹ÓIÁèŠÈÒâB”èŠE<]…xÿÿÿAƒÎÿ3Û8]„Õ鄃ÿ+uA+÷‰t$H…Ú;„ÒAŠßD‹d$4H‹l$`ƒÿ0uOEçH‹ÍD‰d$4è/õÿÿ‹ø‰D$<@¶÷‹ÎèÌgÿÿ3É;Átg‹D$\‹Î@¾ßÁà‰D$\èÈfÿÿ‹t$\‹û3Ƀç߃ï;ÁEû‰|$<¹t>Ð3ÀL$L‰t$\9D$ht+ét6‹\$4ÙI‹Ï‰\$4èðÿÿ‹ø‰D$<éMÿÿÿÿˉ\$4A;þt
I‹×‹Ï蚯‹t$\E3ÿD8|$@t÷Þ‰t$\‹D$LAƒýFADÇA;Ç„D8|$0u'ÿD$l‹D$\ëD‹d$DH‹Œ$˜E;çtH‹„$ˆH‰H‹l$PD‹l$4ë"H‹l$PD‹l$4D8|$8t‰ë
f‰ëD‹l$4E3ÿH‹t$`»A´%\$9HëH‰l$Pë]D8euHED8 HDèDëH‹ÎD‰l$4è!ïÿÿ‹ø‰D$<¶EHëH‰l$P;Çu_@¶Ïè& A;ÇtH‹Îèõîÿÿ¶MHëH‰l$P;Èu*A;þuD8eu=€}nu7ŠEA:Çt/é¼ðÿÿA;þt%H‹T$`ëA;Æt
H‹Ö‹Èèd®A;þt
H‹Ö‹ÏèU®3Û¸9D$|u
H‹L$pè†2ÿÿA;þu4‹D$l;ÃuŠT$9:ÓtD‹ð8œ$Ø„ðÿÿH‹Œ$Ѓ¡Èýéðÿÿ‹\$lE3ÿD8¼$ØtH‹Œ$Ѓ¡Èý‹ÃH‹Œ$pH3Ìèï)ÿÿH‹œ$ÐHÄ€A_A^A]A\_^]ÃH‰\$H‰t$WHƒì I‹ñI‹øH‹ÚH;
udM9u=H‹ºè‘ÅÿÿH‰H…Àu3ÀëKH‹D$PH‹ÖÇL‹H‹è$ÿÿL‹MÛL‰ë"H‹H‹A¸è\ÆÿÿH…ÀtÂH‰H‹HÉH‰¸H‹\$0H‹t$8HƒÄ _ÃÌÌ@SHƒì ¾Ù¶Éè×cÿÿ‹Ëƒá߃é…ÀEË‹ÁHƒÄ [ÃÌÌHƒì(ƒAÿxH‹¶HÿÀH‰ëèË+‹Ð‹ÂHƒÄ(ÃÌÌHƒì(ƒùÿtè¬HƒÄ(ÃÌH‰\$H‰t$WHƒì H‹òH‹ùÿH‹Îè¥ÿÿÿ‹Øƒøÿt¶Èè&eÿÿ…ÀuãH‹t$8‹ÃH‹\$0HƒÄ _ÃL‹ÜI‰[UVWATAUAVAWHì€H‹tÙH3ÄH‰„$pE3öM£XþÿÿL‰Œ$¸L‰d$xI‹ØH‹òH‰T$pH‹éH‰L$hE‹æIǃèýÿÿ^E‰³ÌýÿÿfE‰³ÈýÿÿA‹þD‰t$@¶÷‹ÎèOUÿÿ…ÀtqHÁ¤$ˆ‹Î@¾ßèOTÿÿH‹´$ˆ‹ûƒçß3Ƀï;ÁEû‰|$ÐD$Xƒ|$`‰t$\tD+èt3H‹\$hD$4H‹ËèJïÿÿ‹ø‰D$<éRÿÿÿÿL$4A;ÿt
H‹Ó‹Ïè$œ‹t$\E„öt÷Þ‰t$\‹D$XAƒüFA¾ADÆA;Æ„sD8t$0u&ÿD$d‹D$\ë‹l$PH‹Œ$A;îtH‹„$ˆH‰D‹l$4ëD‹l$4D8t$8t‰ëf‰ëE3öH‹t$pH‹l$h»\$9HóA´%H‰t$pëbD8&uHFD8 HDðDëH‹ÍD‰l$4èvîÿÿ‹ø‰D$<¶HóH‰t$p;Ç…-@¶Ïè¸A;ÆtH‹ÍèGîÿÿ¶HóH‰t$p;È…õA;ÿuD8&u&€~nu ŠA:ÆtéðÿÿA;ÿtH‹T$h‹ÏèÿšE3öD‹d$Dƒ¼$„u
H‹L$xè+ÿÿA;ÿ…Ï‹D$dA;Æu	ŠL$9A:ÎtD‹øD8´$è„€ïÿÿH‹Œ$àƒ¡ÈýélïÿÿE3öA:î~fD‰1ëDˆ1è{ÿÿÇE‹æë‹A;ÿtH‹T$h‹ÏèqšA¼E3öélÿÿÿèn{ÿÿÇ3ÀD‹àD:ðtE3öfD‰3éKÿÿÿE3öDˆ3é@ÿÿÿA;Çt
H‹Õ‹Èè(šA;ÿ„#ÿÿÿH‹Õ‹ÏèšéÿÿÿD‹àë Aƒüu>è{ÿÿE3ÉE3À3Ò3ÉL‰t$ ÇèZjÿÿD8´$ètH‹Œ$àƒ¡Èý‹D$dë‹\$dD8´$ètH‹„$àƒ Èý‹ÃH‹Œ$pH3Ìè´ÿÿH‹œ$ÐHÄ€A_A^A]A\_^]ÃÌH‰\$WHƒì Hcù‹ÏèLºÿÿHƒøÿtYH‹W¹ƒÿu	@„¸¸u
;ùuö@`tèºÿÿ¹H‹ØèºÿÿH;Ãt‹ÏèºÿÿH‹Èÿ#ö…Àu
ÿö‹Øë3Û‹Ïè8¹ÿÿL‹ßH‹ÏHÁùAƒãHç
H‹ÊMkÛXBÆD…Ût‹Ëè"zÿÿƒÈÿë3ÀH‹\$0HƒÄ _ÃH‰\$H‰t$ ‰L$WATAUHƒì0HcÙƒûþuèÌyÿÿ3ÿ‰8è£yÿÿÇ	ƒÈÿéÉ3ÿ;ߌ–;]
ƒŠH‹óL‹ãIÁüL-Z
ƒæHköXK‹Då¾L0ƒáu+èsyÿÿ‰8èLyÿÿÇ	H‰|$ E3ÉE3À3Ò3Éè–hÿÿƒÈÿëa‹Ëè~¹ÿÿK‹DåöD0t‹Ëè†þÿÿ‹øëè	yÿÿÇ	ƒÏÿ‹Ëèù¹ÿÿ‹Çë)èyÿÿ‰8èéxÿÿÇ	H‰|$ E3ÉE3À3Ò3Éè3hÿÿƒÈÿH‹\$`H‹t$hHƒÄ0A]A\_Ã@SHƒì öAƒH‹Ùt"öAtH‹IèÒÿÿc÷ûÿÿ3ÀH‰H‰C‰CHƒÄ [ÃÌH‰\$ UVWATAUAVAW¸0èâH+àH‹hÄH3ÄH‰„$ 3í3ÿE‹èL‹âHcÙ‰l$@E…Àu3ÀéçH…Òu.èJxÿÿ!8è#xÿÿH!|$ E3ÉE3À3Ò3ÉÇèmgÿÿƒÈÿé´L‹ûL‹óHàIÁþAƒçJ‹ðL‰t$PMkÿXAŠt8@ö@Ðþ@€þt@€þu	A‹Å÷ШtAöD t
3Ò‹ËDBèv”‹ËèCm…À„ñH€J‹ðAöD€„Úèïšÿÿ3ÛHT$XH‹ˆÀHV9YJ‹ðI‹”Ãÿâò…À„¤…Ût	@„ö„—ÿgó!|$LI‹Ü‰D$XE…í„wD‹t$X½
@„ö…ƒH‹T$PŠE3ö€ù
H-ìH‹TÕA”ÆAƒ|Pt AŠDLˆL$]A¸ˆD$\AƒdPHT$\ëI¾Éè#…Àt4I‹ÅH+ÃIÄHƒøŽÏHL$DA¸H‹Ó蘃øÿ„vHÿÃëA¸H‹ÓHL$Dèl˜ƒøÿ„UHƒd$8Hƒd$0‹L$XHD$\LD$DA¹3ÒÇD$(HÿÃH‰D$ ÿ_ó‹è…À„H‹D$PHƒd$ H
H‹ÁLL$LHT$\I‹D‹Åÿ°ó…À„B‹ûA+ü|$@9l$LŒË½
E…ö„¯H‹D$PHƒd$ @ˆl$\H
°LL$LDEôH‹ÁHT$\I‹ÿTó…À„æƒ|$L|{ÿD$@ÿÇëe@€þt@€þu·E3öfƒø
f‰D$DA”ÆHƒÃ@€þt@€þu6·L$DèP—f;D$D…“ƒÇE…öt‹Íf‰l$Dè1—f;D$DuxÿÇÿD$@‹ÃA+ÄA;Å‚þÿÿ‹\$LL‹t$P‹l$@…ÿ…¸…Û„zƒû…eèótÿÿÇ	èuÿÿ‰éØüÿÿŠL‹t$PÿÇJ‹LõAˆDLJ‹DõAÇDP‹\$Lë¥ÿ˜ð‹Øë–‹\$Lë¡HJ‹ðAöD€„Ê3ÛI‹ì@„ö…ÐE…í„üS
D‹t$@H´$ 3É‹ÅA+ÄA;Ås&ŠEHÿÅ<
uˆAÿÆHÿÆHÿÁHÿÁˆHÿÆHùÿrÐH!\$ H„$ D‹ÆD+ÀHD‰t$@L‹t$PLL$HH”$ J‹ðI‹ÿ§ñ…Àt5|$HH„$ H+ðHcD$HH;ÆŒÅþÿÿ‹Åº
A+ÄA;Å‚Nÿÿÿé­þÿÿÿ ï‹Øé þÿÿ@€þ…ÔE…í„"º
D‹t$@H´$ 3É‹ÅA+ÄA;Ås1·EHƒÅfƒø
uf‰AƒÆHƒÆHƒÁHƒÁf‰HƒÆHùþrÅH!\$ H„$ D‹ÆD+ÀH%D‰t$@L‹t$PLL$HH”$ J‹ðI‹ÿÀð…À„Jÿÿÿ|$HH„$ H+ðHcD$HH;ÆŒÚýÿÿ‹Åº
A+ÄA;Å‚?ÿÿÿéÂýÿÿE…í„NA¸
HL$p3Ò‹ÅA+ÄA;Ås.·EHƒÅfƒø
ufD‰HƒÁHƒÂHƒÂf‰HƒÁHú¨rÈHƒd$8Hƒd$0HD$p+ÈLD$pÇD$(U
‹Á¹éý™+Â3ÒÑøD‹ÈH„$ H‰D$ ÿiïD‹ð…À„€ýÿÿ3öH‹D$PHƒd$ HcÎH” E‹ÆH
H‹ÁLL$HD+ÆI‹ÿ®ï…Àtt$HD;ö½ëÿÑí‹ØD;öÈüÿÿ‹ýA¸
A+üA;ý‚ÿÿÿé¯üÿÿI‹H!|$ LL$HE‹ÅI‹Ôÿ[ï…Àt‹|$H3Ûéüÿÿÿ~í‹Øé‚üÿÿ‹ËèÌqÿÿé~ùÿÿHlJ‹ðAöD@tA€<$„.ùÿÿèdqÿÿÇèyqÿÿƒ éHùÿÿ+ý‹ÇH‹Œ$ H3ÌèIÿÿH‹œ$ˆHÄ0A_A^A]A\_^]ÃÌÌH‰\$H‰t$‰L$WATAUAVAWHƒì0E‹àL‹êHcÙƒûþuèqÿÿ3ÿ‰8èépÿÿÇ	ƒÈÿéÔ3ÿ;ߌ¡;£ƒ•H‹óL‹óIÁþL= ƒæHköXK‹÷¾L0ƒáu+èºpÿÿ‰8è“pÿÿÇ	H‰|$ E3ÉE3À3Ò3ÉèÝ_ÿÿƒÈÿëm‹ËèÅ°ÿÿK‹÷öD0tE‹ÄI‹Õ‹ËèÔ÷ÿÿ‹øëèKpÿÿÇ	è`pÿÿ‰8ƒÏÿ‹Ëè4±ÿÿ‹Çë)èKpÿÿ‰8è$pÿÿÇ	H‰|$ E3ÉE3À3Ò3Éèn_ÿÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌÌ@SHƒì@‹ÙHL$ èÿÿH‹D$ D¶ÛH‹ˆ@B·Y%€€|$8tH‹L$0ƒ¡ÈýHƒÄ@[ÃÌÌÌ@SHƒì@‹ÙHL$ 3ÒèÐÿÿH‹D$ D¶ÛH‹ˆ@B·Y%€€|$8tH‹L$0ƒ¡ÈýHƒÄ@[ÃÌL‹Âºé;“ÌÌ̺éê“ÌÌL‹Âºé“ÌÌ̺éΓÌÌL‹Âºé“ÌÌ̺鲓ÌÌL‹Âºéç’ÌÌ̺é–“ÌÌL‹Âº€éË’ÌÌ̺€éz“ÌÌL‹Âº鯒ÌÌ̺é^“ÌÌL‹Âºé“’ÌÌ̺éB“ÌÌL‹Âºéw’ÌÌ̺é&“ÌÌL‹ÂºWé[’ÌÌ̺Wé
“ÌÌL‹Âºé?’ÌÌ̺éî’ÌÌL‹Âº é#’ÌÌ̺ éÒ’ÌÌ3Àº€f;Ê’ÀÃÌÌ@SHƒì L‹Âº·Ùèî‘3Ò;Âufƒû_uº‹ÂHƒÄ [ÃÌ@SHƒì º·Ùè}’3Ò;Âufƒû_uº‹ÂHƒÄ [Ã@SHƒì L‹Âº·Ùè’‘3Ò;Âufƒû_uº‹ÂHƒÄ [ÃÌ@SHƒì º·Ùè!’3Ò;Âufƒû_uº‹ÂHƒÄ [ÃL‹ÉE¶IÿÁA@¿ƒøwAƒÀ ¶
HÿÂA¿ƒøwƒÁ E…ÀtD;ÁtÑD+ÁA‹ÀÃÌÌÌH‰\$H‰t$WHƒìPH‹ñH‹úHL$0I‹ÐèBÿÿH…öu:èølÿÿHƒd$ E3ÉE3À3Ò3ÉÇèA\ÿÿ€|$HtH‹D$@ƒ Èý¸ÿÿÿëqH…ÿtÁH‹D$0ƒxu H‹×H‹ÎèHÿÿÿ€|$HtOH‹L$@ƒ¡ÈýëA¶HT$0èÊ‘¶HT$0‹ØHÿÆ踑HÿÇ…Ût;ØtÖ+Ø€|$HtH‹L$@ƒ¡Èý‹ÃH‹\$`H‹t$hHƒÄP_ÃÌÌHƒì8ƒ=aÝu8H…Éu'è)lÿÿHƒd$ E3ÉE3À3Ò3ÉÇèr[ÿÿ¸ÿÿÿëH…ÒtÔèþÿÿëE3ÀèÏþÿÿHƒÄ8ÃÌÌH‰\$H‰l$VWATAUAWHƒì0‹-4äI‹ñE3ÉE3ÒE3Û€: EyE‹àH‹ÚL‹éuI߀; tø€;at?€;rt3€;wt'è–kÿÿHƒd$ E3ÉE3À3Ò3ÉÇèßZÿÿ3Àé9¿ë3ÿAïë¿	ƒÍIßA‹×Š„À„½A¸À…Ò„ð¾ÈƒùS~toƒé „ЃétLA+ÏtBƒét+ƒé
tƒù…uÿÿÿE…Ò…¢E‹×ƒÏ韺ïé–@öÇ@…„ƒÏ@é„E‹ßëw@öÇuqƒçþƒåüƒÏºíëjE…Òu]E‹×ƒÏ ë]ƒéTtJƒét:A+Ït'ƒétƒù…ÿÿÿA…øu3ºïë5E…Éu(E‹Ïºõë'E…ÉuE‹ÏºíëA…øuºïëºçs3ÒëºïIߊ„À…ÿÿÿE…Û„¶ëI߀; tøH
¢ZA¸H‹Ó蟅À……þÿÿHƒÃëI߀; tø€;=…nþÿÿI߀; tøHjZA¸H‹ËèT…Àu
HƒÃºïëMHSZA¸H‹Ëè1…Àu
HƒÃºïë*H@ZA¸H‹Ëè…À…þÿÿHƒÃºïëI߀; tø€;…èýÿÿHL$hE‹ÌD‹ÇI‹ÕÇD$ €è°š…À…åýÿÿD=­Ó!F‹D$hHƒ&HƒfHƒf(‰F‰nH‹ÆH‹\$`H‹l$pHƒÄ0A_A]A\_^ÃH‰\$H‰t$WHƒì03ÛKè?§ÿÿ3ÿ‰|$ ;=JúHc÷H‹"üHƒ<ðtkH‹ðö@ƒuVº`rOGýƒøwOè¦ÿÿ…À„ÀH‹ëûH‹ò‹Ïè\ÿÿL‹ÙûI‹óö@ƒtH‹Ð‹ÏèÉÿÿëH‹Øé‰ÿlj|$ éxÿÿÿHcÿ¹XèûžÿÿH‹
œûH‰ùH‹
‘ûHƒ<ùtXH‹ùHƒÁ0º èd…ÀuH‹
mûH‹ùèhÿÿL‹]ûIƒ$ûë$H‹OûH‹øHƒÁ0ÿ©äL‹:ûI‹ûƒcH…Ûtc€ƒcHƒcHƒ#Hƒc(ƒKÿ¹èæ¤ÿÿH‹ÃH‹\$@H‹t$HHƒÄ0_ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„HìØM3ÀM3ÉH‰d$ L‰D$(è€ÊHÄØÃÌÌÌÌÌÌfDH‰L$H‰T$D‰D$IÇÁ “ëÌÌÌÌÌÌfÃÌÌÌÌÌÌf„ÃÌÌÌ@SHƒì`H…Òu%è0gÿÿHƒd$ E3ÉE3À3Ò3ÉÇèyVÿÿƒÈÿëJH…ÉtÖH‰L$@H‰L$0HL$0ÇD$8ÿÿÿÇD$HB至ÿÿƒl$8‹Øx
H‹L$0ÆëHT$03Éè¤Ãÿÿ‹ÃHƒÄ`[ÃM‹ÈE3ÀéuÿÿÿÌHƒìhH‹ÁH…Òu%è£fÿÿHƒd$ E3ÉE3À3Ò3ÉÇèìUÿÿƒÈÿë#Hƒd$@Hƒd$0HL$0ÇD$8ÿÿÿÇD$HBÿÐHƒÄhÃÌÌÌL‹ÊH‹ÑH
ë²ÿÿE3ÀéÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
вÿÿéwÿÿÿÌÌÌL‹ÊH‹ÑH
{oE3Àé_ÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
`oéGÿÿÿÌÌÌH‰\$H‰l$H‰t$WHƒì`3ÛM‹ÑI‹èH‹òL‹ÙL;Ëu'èÌeÿÿE3ÉE3À3Ò3ÉH‰\$ ÇèUÿÿƒÈÿé‡L;ÃtH;ÓtÏL‹Œ$˜¹ÿÿÿA‹ÀL;ÁL‹„$H‰T$@GÁH‰T$0HL$0I‹ÒÇD$HB‰D$8AÿÓ‹øH;ót7;Ã|%ƒl$8x	H‹D$0ˆëHT$03ÉèÂÿÿƒøÿt‹Çë9\$8ˆ\.ÿÃCþL\$`I‹[I‹kI‹s I‹ã_ÃÌHƒì8L‰L$(Hƒd$ M‹ÈL‹ÂH‹ÑH
±ÿÿèðþÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂH‹ÑH
U±ÿÿè¸þÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌ@SHƒì0H‹ÙM…ÀtGH…ÉtBH…Òt=H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂH‹ÑH
A`èlþÿÿ…Àyƃøþu0èSdÿÿÇ"ëèFdÿÿÇHƒd$ E3ÉE3À3Ò3ÉèSÿÿƒÈÿHƒÄ0[ÃÌÌHƒì8L‰L$ E3ÉèoÿÿÿHƒÄ8ÃÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì0I‹éI‹ðH‹ÚH‹ùM…É„ïM…ÀuH…ÉuH…Ò…Ü3ÀéøH…É„ÌH…Ò„ÃI;ÐvPè¤cÿÿLFH
q_‹H‹D$hL‹ÍH‰D$(H‹D$`H‹×H‰D$ è€ýÿÿƒøþuoèncÿÿƒ8"…šè`cÿÿ‰éŽèTcÿÿH
%_L‹ÍD‹ H‹D$hL‹ÃH‰D$(H‹D$`H‹×H‰D$ è0ýÿÿÆDÿƒøþuHƒþÿuècÿÿƒ8"uCè	cÿÿD‰ ë9…Ày8ƃøþu-èóbÿÿÇ"ëèæbÿÿÇHƒd$ E3ÉE3À3Ò3Éè/RÿÿƒÈÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A\ÃÌHƒì8H‹D$`H‰D$(Hƒd$ è‹þÿÿHƒÄ8ÃÌÌHƒì8L‰L$(Hƒd$ M‹ÈL‹ÂH‹ÑH
ÍkèpüÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂH‹ÑH
•kè8üÿÿƒÉÿ…ÀHÁHƒÄ8ÃÌÌÌH‰\$H‰t$WHƒì0H‹ùH…Éu$èbÿÿH!|$ E3ÉE3À3Ò3ÉÇèNQÿÿé‹A¨ƒ„¨@…ù¨tƒÈ ‰AéêƒÈ‰A©uèM€ëH‹AH‰H‹Ïè(¹ÿÿD‹G$H‹W‹Èèñ‰G…À„œƒøÿ„“öG‚u_H‹Ïè÷¸ÿÿƒøÿtžH‹ðI;ÄsNºH;ÂHBÐHÐH;Ðr
H‹Íè—ÿÿH…ÀuHV H;ÖrDH‹Í謗ÿÿH…Àt7HÁûH‹ÈH<ØèëÿÿH‰(óI‹ÍèÜÿÿHOH‰èÐÿÿH‰óI‹Åë3ÀH‹\$@H‹l$HH‹t$PHƒÄ A]A\_ÃÌ@SHƒì ºJè½–ÿÿH‹ÈH‹ØèŠÿÿH‰ÇòH‰¸òH…ÛuCëHƒ#3ÀHƒÄ [ÃÌÌH‰\$H‰t$H‰|$ATAUAVHƒì L‹ñèŸEÿÿH‹
òèJÿÿL‹àH‹
hòè;ÿÿH‹ØI;Ä‚˜H‹øI+üLoIƒý‚„I‹ÌèH‹ðI;ÅsTºH;ÂHBÐHÐH;ÐrI‹Ì臖ÿÿ3ÛH;Ãuë3ÛHV H;ÖrFI‹Ìèk–ÿÿH;Ãt9HÁÿHøH‹È誀ÿÿH‰çñI‹Î蛀ÿÿH‰HKè€ÿÿH‰ÄñI‹Þë3ÛèäDÿÿH‹ÃH‹\$@H‹t$HH‹|$PHƒÄ A^A]A\ÃÌÌÌHƒì(èïþÿÿH÷ØÀ÷ØÿÈHƒÄ(ÃÌH‰\$WHƒì H·dH=°dëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì HdH=ˆdëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì H¼¿
H‹è¶ÿÿH‰HƒÃHƒïuëH‹\$0HƒÄ _ÃÌÌÌÌÌÌÌÌÌÌH‹Á¹MZf9t3ÀÃHcHƒ=°Îu5ºH
‚ýÿÿÿ,Óƒøu‰‘Îëè¶WÿÿH‹ØÿqÓ‰A¼‹Ïƒé„”ƒétiƒé	t>ƒétƒùtZH‹\$0éšH‹
1Îè4yÿÿH‹ØHƒþ„H‹ÎèyÿÿH‰ÎëpH‹
Îè
yÿÿH‹ØHƒþt[H‹ÎèåxÿÿH‰úÍëJH‹
éÍèäxÿÿH‹ØHƒþt5H‹Îè¿xÿÿH‰ÌÍë$H‹
³Íè¾xÿÿH‹ØHƒþtH‹Îè™xÿÿH‰–Í3ÉèÏ“ÿÿE…äuH‹ÃëCƒÿt:ƒÿt5ƒÿ
t0ƒÿ~ƒÿ~&è“VÿÿÇHƒd$ E3ÉE3À3Ò3ÉèÜEÿÿHƒÈÿëHƒÈÿH‹\$PH‹t$XH‹|$`HƒÄ@A\ÃH‰\$H‰t$WATAUAVAWHƒì@‹Ù3ÿ‰|$p3ö‹Ñƒê„	ƒê„¢ƒê„€ƒê„ƒê„‡ƒêtMƒêt,ƒút_èôUÿÿÇH!t$ E3ÉE3À3Ò3Éè>EÿÿƒÈÿéÑL%§ÌH‹
 Ì¿‰|$péªL%›ÌH‹
”Ì¿‰|$péŽL%wÌH‹
pÌ¿‰|$pëuèhxÿÿH‹ðH…ÀuƒÈÿékH‹ H‹ÊLcS´9YtHƒÁI‹ÀHÁàHÂH;ÈrèI‹ÀHÁàHÂH;Ès9Yt3ÉLaM‹,$ëL%ðËH‹
éË¿‰|$pèëvÿÿL‹èIƒýu3ÀéöM…íu
AMèu>ÿÿÌ…ÿt3Éè“ÿÿƒûtƒûtƒûtL‹|$8D‹t$pë1L‹¾¨L‰|$8Hƒ¦¨ƒûuD‹¶°Ç†°ŒëD‹t$pƒûu9‹
q³‹Ñ‰L$0‹i³È;Ñ}*HcÊHÉH‹† HƒdÈÿ‰T$0‹
@³ëÓè%vÿÿI‰$…ÿt3ÉèR‘ÿÿ¿;ßu
‹–°‹ÏAÿÕë‹ËAÿÕ;ßt
ƒûtƒûuL‰¾¨;ßuD‰¶°3ÀL\$@I‹[8I‹s@I‹ãA_A^A]A\_ÃÌÌÌH‰
ÙÊÃH‰\$H‰l$H‰t$WHƒì0H‹éH‹
ºÊèuÿÿH‹øH…íu(è¬SÿÿHƒd$ »E3ÉE3À3Ò3ɉèôBÿÿ‹Ã齃eH…À…ŒH
ÉDÿÏH‹ðH…Àt¶HœDH‹ÈÿÏH‹øH…Àu:èJSÿÿH‹Øÿ%Ï‹ÈèòRÿÿH!|$ E3ÉE3À3Ò3ɉèˆBÿÿÿÏ‹ÈèÏRÿÿëIH‹ÈèÝtÿÿH‹ØèÝtÿÿH‡úÉH;Øt	H‹ÎÿͺH‹Íÿ×…ÀuèÝRÿÿÇèÒRÿÿ‹ë3ÀH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌÌ@UVWATAUAVAWHìÀH‹¦žH3ÄH‰„$°H‹¬$ E‹ùE‹ðL‹éƒú…3öLL$0E‹Ç!t$(A‹ÖH|$0ÇD$ €èŽ“D‹à…Àuiÿ)΃øz…‚!t$(!t$ E3ÉE‹ÇA‹ÖI‹Íè_“Lcà…Àtb¾I‹ÌH‹Öè‰ÿÿH‹øH…ÀtJƒd$(L‹ÈE‹ÇA‹ÖI‹ÍD‰d$ è%“D‹à…Àt McìºI‹ÍèʈÿÿH‹ÈH‰EH…Àu2…ötH‹ÏèòôþÿƒÈÿH‹Œ$°H3Ìè³ìþÿHÄÀA_A^A]A\_^]ÃAD$ÿL‹ÇI‹ÕLcÈèu…ÀtHƒd$ E3ÉE3À3Ò3ÉèD?ÿÿ…ötH‹Ïè”ôþÿ3Àë¡…Òuš!T$(H=MÈE‹ÇA‹ÖL‹ÏÇD$ è7…À„qÿÿÿÆE¶7‹ÎèÕ&ÿÿ…Àt½ŠMHƒÇŠÁÀàÈHÈÉ@΀é0H;øˆM|Íë–ÌÌH‰
õÇÃH‰
õÇÃHƒì8ÿRÌD‹Ø‰D$ ë=Àu¹ÿßÌE3ÛD‰\$ A‹ÃHƒÄ8ÃÌÌÌHƒì(H‹8csmàu+ƒxu%‹@ = “t=!“t="“t=@™uèoóÿÿÌ3ÀHƒÄ(ÃÌÌÌHƒì(H
±ÿÿÿÿOÍ3ÀHƒÄ(ÃH‰\$WHƒì 3ÿ9=Vãuè¿\ÿÿH‹(ãHÉÑH…ÛHDØ€; w	€;t3…ÿt)€;"u	3À…ÿ”À‹ø¶输…ÀtHÿÃHÿÃëÐ< w	HÿÊ„ÀuóH‹ÃH‹\$0HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0ƒ=Ñâuè:\ÿÿH‹[º3ÿH…ÛuƒÈÿéÉ<=tÿÇH‹Ëè&ˆÿÿH\Š„ÀuçGºHcÈèg†ÿÿH‹øH‰Ù¹H…ÀtÀH‹
º€;teH‹Ëèè‡ÿÿ€;=ptCHcîºH‹Íè,†ÿÿH‰H…ÀtrL‹ÃH‹ÕH‹Èèþ„ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éèá<ÿÿHƒÇHcÆHØ€;u¢H‹£¹H‹ËèòþÿHƒ%“¹Hƒ'ÇÕá3ÀH‹\$@H‹l$HH‹t$PHƒÄ0_ÃH‹
'¹èæñþÿHƒ%¹éÿÿÿÌH‰
-¹ÃH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì L‹l$`M‹ñI‹øAƒeL‹âH‹ÙAÇH…ÒtL‰IƒÄ3í€;"u3À…í@¶"”ÀHÿËèë9AÿEH…ÿtŠˆHÿǶ3HÿËÎèá‘…ÀtAÿEH…ÿtŠˆHÿÇHÿÃ@„öt…íu­@€þ t@€þ	u¡H…ÿt	ÆGÿëHÿË3ö€;„ã€; t€;	uHÿÃëñ€;„ËM…ätI‰<$IƒÄAÿº3ÉëHÿÃÿÁ€;\tö€;"u6„Êu…ötHC€8"uH‹Øë3À3Ò…ö”À‹ðÑéëÿÉH…ÿtÆ\HÿÇAÿE…Éu늄ÀtO…öu< tG<	tC…Òt7¾Èè‘H…ÿt…ÀtŠHÿÈHÿÇAÿEŠˆHÿÇë…ÀtHÿÃAÿEAÿEHÿÃéYÿÿÿH…ÿtÆHÿÇAÿEéÿÿÿM…ätIƒ$$AÿH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A^A]A\ÃÌH‰\$H‰t$ WHƒì0ƒ=Îßuè7YÿÿH=ÀÃA¸3ÉH‹×ƲÄÿ ÇH‹ßH‰=·H…Ût€;uH‹ßHD$HLL$@E3À3ÒH‹ËH‰D$ è½ýÿÿHct$@H¹ÿÿÿÿÿÿÿH;ñs\HcL$HHƒùÿsQHñH;ÑrHH‹Ê豂ÿÿH‹øH…Àt8LðHD$HLL$@H‹×H‹ËH‰D$ ègýÿÿD‹\$@H‰=W¶AÿË3ÀD‰G¶ëƒÈÿH‹\$PH‹t$XHƒÄ0_ÃÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì@‹
ÕÃE3äI‹ÜAt$A;Ìu2ÿ÷ÆH‹ØI;ÄtÇ­Ãë!ÿeÇ‹
ŸÃƒøxDΉ
“Ãù…ºI;Üuÿ·ÆH‹ØI;Äu3ÀéH‹ûfD9#tHþfD9'u÷HþfD9'uîL‰d$8L‰d$0H+ûHÑÿL‹Ã3ÒDO3ÉD‰d$(L‰d$ ÿ*ÈHcèA;ìtAH‹Íè‚ÿÿH‹ðI;Ät1L‰d$8L‰d$0DOL‹Ã3Ò3ɉl$(H‰D$ ÿîÇA;ÄuH‹ÎèõíþÿI‹ôH‹ËÿÆH‹Æës;Ît	A;Ì…LÿÿÿÿÆH‹ØI;Ä„:ÿÿÿD8 tHÿÀD8 uøHÿÀD8 uð+ÃÿÀHcðH‹Îèõ€ÿÿH‹øI;ÄuH‹ËÿÌÅéÿÿÿL‹ÆH‹ÓH‹ÈèÑßþÿH‹Ëÿ°ÅH‹ÇH‹\$PH‹l$XH‹t$`H‹|$hHƒÄ@A\ÃÌÌH‰\$WHƒì H‹–Hƒd$0H¿2¢ß-™+H;ÇtH÷ÐH‰–ëvHL$0ÿ;ÆH‹\$0ÿÅD‹ØI3ÛÿLÇD‹ØI3ÛÿÅHL$8D‹ØI3ÛÿÿÄL‹\$8L3ÛH¸ÿÿÿÿÿÿL#ØH¸3¢ß-™+L;ßLDØL‰Š•I÷ÓL‰ˆ•H‹\$@HƒÄ _Ã̃%5ÚÃ3ÒDB
éÝëþÿÌL‹Ê3ÒDB
éþëþÿÌÌ3ÒDB
éÁëþÿÌL‹Ê3ÒDB
éâëþÿÌÌ3ÒDB
éÌL‹Ê3ÒDB
é:ÌÌ@SHƒì0M‹ØM…ÉuH…ÉuH…Òu 3Àë?H…ÉtH…ÒtM…ÉuDˆ	ëèM…Àu,DˆèÏHÿÿ»Hƒd$ E3ÉE3À3Ò3ɉè8ÿÿ‹ÃHƒÄ0[ÃL‹ÑL‹ÂIƒùÿuAŠIÿÃAˆIÿ„Àt,Iƒèuêë$AŠIÿÃAˆIÿ„ÀtIƒètIƒéuäM…ÉuEˆ
M…À…fÿÿÿIƒùÿuDˆDÿA@Pë˜ÆèAHÿÿ»"émÿÿÿÌÌÌÌÌÌÌÌÌff„H+ÑL‹ÊöÁtŠBŠ	:ÂuVHÿÁ„ÀtWH÷ÁuæI»J	fâÿfúøwËH‹J‹	H;Âu¿Iºÿþþþþþþ~LÒHƒðÿHƒÁI3ÂI…ÃtÇëHÀHƒØÿÃ3ÀÃfff„Òt'„öt#HÁê„Òt„ötHÁê„Òt„ötÁê„Òt„öu‹3ÀÃHÀHƒØÿÃH‰\$H‰t$WHƒì ƒ=bÚH‹˱H‹ñtmH…ÛuH9ʱt_èŸ:…ÀuVH‹¨±H…ÛtJH…ötEH‹Îè¾ÿÿH‹øH‹H…Ét2è®ÿÿH;ÇvH‹€<9=uL‹ÇH‹Öèá9…ÀtHƒÃëÐH‹HD8ë3ÀH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0I‹ØH‹úH‹éH…Éu%è©FÿÿHƒd$ »E3ÉE3À3Ò3ɉèñ5ÿÿ‹ÃëvHƒ!H…ÒtH…ÛuëËH…ÛuÆH…ÒtÆI‹ÉèðþÿÿH‹ðH…ÀtGH‹Èèð~ÿÿHÿÀH‰EH…Ût3H;Ãv¸"ë)L‹ÆH‹ÓH‹Ïè|ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éèñ3ÿÿ3ÀH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌH‰\$H‰l$H‰t$WHƒì0H‹ÚH‹ùH…Éu(èØEÿÿHƒd$ »E3ÉE3À3Ò3ɉè 5ÿÿ‹ÃéˆHƒ!H…ÒtHƒ"M…ÀtÆI‹Èè'þÿÿH‹ðH…ÀtdH‹Èè'~ÿÿºH,H‹Íè&H‰H…ÀuèmEÿÿÇèbEÿÿ‹ë1L‹ÆH‹ÕH‹Èè0{ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éè3ÿÿH…ÛtH‰+3ÀH‹\$@H‹l$HH‹t$PHƒÄ0_Ã@SHƒì0H‹Ù3ÀH…É•À…Àu$èþDÿÿÇHƒd$ E3ÉE3À3Ò3ÉèG4ÿÿ3Àë`ºÿè~ÿÿ3ÉH=ÿ’Á…Éu$èÁDÿÿÇHƒd$ E3ÉE3À3Ò3Éè
4ÿÿ3Àë#¹èÌ‚ÿÿH‹ËèýÿÿH‹Ø¹è–ÿÿH‹ÃHƒÄ0[ÃÌH‰\$H‰t$H‰|$ATHƒì0I‹ñI‹øH‹ÚL‹á¹è‚ÿÿ3ÀM…ä•À…Àu&è;Dÿÿ»‰Hƒd$ E3ÉE3À3Ò3Éèƒ3ÿÿé²Iƒ$$H…ÛtH…ÿu
H…ÛuH…ÿu¸ë3À…Àu#èïCÿÿ»‰Hƒd$ E3ÉE3À3Ò3Éè73ÿÿëiH…ÛtÆH‹ÎèMüÿÿH‹ðH…Àu3ÛëMH‹ÈèI|ÿÿHÿÀI‰$H…ÿu3Ûë5H;Çv»"ë)L‹ÆH‹×H‹Ëècyÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèF1ÿÿ3Û¹èr€ÿÿ‹ÃH‹\$@H‹t$HH‹|$PHƒÄ0A\ÃÌÌH‰\$H‰t$H‰|$ATHƒì0I‹ðH‹ÚH‹ù¹èPÿÿ3ÀH…ÿ•À…Àu&è
Cÿÿ»‰Hƒd$ E3ÉE3À3Ò3ÉèR2ÿÿé¶Hƒ'H…ÛtHƒ#3ÀH…ö•À…Àu#èËBÿÿ»‰Hƒd$ E3ÉE3À3Ò3Éè2ÿÿëzH‹Îè1ûÿÿH‹ðH…Àu3ÛëfH‹Èè-{ÿÿºL$I‹Ìè,ŠH‰H…ÀuèsBÿÿÇèhBÿÿ‹ë1L‹ÆI‹ÔH‹Èè6xÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éè0ÿÿH…ÛtL‰#3Û¹è=ÿÿ‹ÃH‹\$@H‹t$HH‹|$PHƒÄ0A\ÃÌL‹ÜI‰[I‰kI‰s WATAUAVAWHìH‹öH3ÄH‰„$ˆ3ÛH‹ùI‰K¨H‰\$XL‹ëL‹ûL‹óL‹ãI‰[°9Y„DHis9]u#D·A0IK¨3ÒA¹H‰l$ èÝîÿÿ;Ã…å¹èxÿÿA¼€ºI‹ÌH‰D$Xè_xÿÿH‹ÖI‹ÌL‹èèQxÿÿH‹ÖI‹ÌL‹øèCxÿÿAL$H‹ÖL‹ðè3xÿÿL‹àH‹D$XH;ĆL;ë„}L;ã„tL;û„kL;ó„b‰I‹Ì‹ÃˆÆHÎ=|ò‹MHT$pÿ¾;Ä7ƒ|$p‡,·D$p;ƉD$P~/8\$vt)HL$w8t ¶Qÿë
HcÂÖBÆ  ¶;Ð~ïHƒÁ8YÿuÜ‹E‰\$8I‰\$0‰D$(H‰L$ 3ÉA¹M‹Ä‹Öèß;Ä»‹E‹W‰\$@‰D$8¸ÿI‰D$0H‰L$(D@ML$3ɉD$ èœ;Ä|‹E‹W‰\$@‰D$8¸ÿIŽ‰D$0H‰L$(ML$3ÉA¸‰D$ è[;Ä;9t$PI­þf‰]Aˆ_Aˆ^AˆŸ€Aˆž€~98\$vt3HL$w8t*¶QÿëHcÂA¸€ÖfE‰„E¶;Ð~åHƒÁ8YÿuÒI•A¸þI‹ÍèöÔþÿI—A¸I‹ÏèáÔþÿI–A¸I‹ÎèÌÔþÿH‹0H;ËtEðƒÿu?H‹8HéþèSâþÿH‹HHƒÁ€èCâþÿH‹PHƒÁ€è3âþÿH‹0è'âþÿH‹D$X‰0H‰‡0I…H‰‡@I‡€H‰¯8H‰‡HI†€H‰‡P‹D$P‰‡ë$H‹L$XèÒáþÿI‹ÍèÊáþÿI‹ÏèÂáþÿI‹Îèºáþÿ‹ÞI‹Ìè°áþÿ‹ÃëUH‹0H;ÃtðƒÿHÉ0¾H‰™0H‰@H?5H‰™8H‰HHª6‰±H‰P3ÀH‹Œ$ˆH3ÌèÙþÿLœ$I‹[8I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌHƒì(èSaÿÿH‹ˆÀH;
˜t‹€È…‹–uèÌMÿÿH‹È‹HƒÄ(ÃÌÌHƒì(H…Éuè¶ÿÿÿë	H‹‹€HƒÄ(ÃÌÌHƒì(è÷`ÿÿH‹ˆÀH;
µ—t‹€È…/–uèpMÿÿH‹È‹AHƒÄ(ÃÌHƒì(è¿`ÿÿH‹ˆÀH;
}—t‹€È…÷•uè8MÿÿH‹È‹AHƒÄ(ÃÌHƒì(è‡`ÿÿH‹ˆÀH;
E—t‹€È…¿•uèMÿÿH‹ÈHAHƒÄ(˅ÒtÿÈ€9t	HÿÁ…ÀuòÿÈ+ÐBÿÃ@UATAUAVAWHƒì`Hl$@H‰]PH‰uXH‰}`H‹²ˆH3ÅH‰ED‹À´¾3ÿM‹ÙL‰MD‰ED‹ò‰UH‹ÙDnÿD;×uOLÑ-E‹Íº3ɉ|$(H‰|$ ÿˆ·;ÇtE‹ÕD‰-n´ëÿ"¸D‹_´ƒøxDDÖD‰Q´L‹]D‹MpD;Ï~5A‹ÉI‹ÃA+Í@88t
IÅ;ÏuñƒÉÿA‹Á+ÁA+ÅA;Á}
DHD‰MpëD‹È‰EpD;Ö„\D;ׄSE;Õ…€D‹¥ˆ‹÷D;çuH‹D‹`÷M‹ÃA‹ÌÒ‰|$(H‰|$ ƒâAÕÿP·LcøD;ÿ„<H»ðÿÿÿÿÿÿA¾ÝÝA½~[3ÒHBàI÷÷HƒørLKL?I;Íw.HAH;ÁwH‹ÃHƒàðèÞ¤H+àH|$@H…ÿ„åÇÌÌëèìÞþÿH‹øH…ÀtD‰0HƒÇH…ÿ„ÀD‹MpL‹EºA‹ÌD‰|$(H‰|$ ÿ¨¶3É;Á„K‹U‰L$(H‰L$ ‹ME‹ÏL‹ÇÿûµE3ÀHcðA;ð„!D‹UAºâ
s;‹…€A;À„;ðÿ‹M‰D$(H‹ExE‹ÏL‹ÇA‹ÒH‰D$ ÿ«µéÛA;ð~`3ÒHBàH÷öHƒørQHL6I;Íw*HAH;ÁwH‹ÃHƒàðèÛ£H+àH\$@I;ØtÇÌÌëèíÝþÿE3ÀH‹ØI;ÀtD‰0HƒÃD‹UëI‹ØI;Øtn‹ME‹ÏL‹ÇA‹Ò‰t$(H‰\$ ÿµ3É;Át?‹…€3ÒH‰L$8D‹ÎL‹ÃH‰L$0;Áu‰L$(H‰L$ ë
‰D$(H‹ExH‰D$ A‹Ìÿ˶‹ðHKðD91uèÏÜþÿHOðD91uèÁÜþÿ‹ÆéÍH‹÷L‹çD;÷uH‹D‹pD‰u‹½ˆ…ÿuH‹‹xA‹ÎèDD‹èƒøÿu3ÀéL‹}xL‹E;Ç„<3ÛLMp‹Ð‹Ï‰\$(H‰\$ èaH‹ðH;ÃtÉD‹Mp‹UL‹ÀA‹Î‰\$(H‰\$ ÿ5´LcÈD‰MD;Ëu‹ûéD;ËA¾ÝÝ~bI‹ÉIƒùàwYHƒÁHùw4HYH;Ùw
H»ðÿÿÿÿÿÿHƒãðH‹ÃèB¢H+ãH\$@H…Ût%ÇÌÌëèTÜþÿH‹ØH…ÀtD‰0HƒÃD‹MH…Ûu3ÛëƒMcÁ3ÒH‹ËèïÌþÿD‹]D‹Mp‹U‹MD‰\$(L‹ÆH‰\$ ÿ~³‰E…Àu3ÿë.‹…€LML‹Ã‰D$(‹×A‹ÍL‰|$ è[€‹}L‹à3ÀL;àDøHKðD91u(è3Ûþÿë!‹…€D‹Mp‹U‰D$(A‹ÎL‰|$ ÿ³‹ø3ÛH;ótH‹ÎèÛþÿL;ãt
M;ütI‹ÌèïÚþÿ‹ÇH‹MH3ÍèµÒþÿH‹]PH‹uXH‹}`He A_A^A]A\]ÃÌÌÌH‰\$H‰t$WHƒìp‹òH‹ÑHL$PI‹ÙA‹øè¨Öþÿ‹„$¸D‹œ$ÀHL$PD‰\$@‰D$8‹„$°‰D$0H‹„$¨L‹ËH‰D$(‹„$ D‹Ç‹Ö‰D$ èOúÿÿ€|$htH‹L$`ƒ¡ÈýL\$pI‹[I‹sI‹ã_ÃÌÌD‰L$ UATAUAVAWHƒì@Hl$0H‰]@H‰uHH‰}PH‹Ö‚H3ÅH‰ED‹
访3ÛM‹ðD‹úL‹éwD;Ëu=LMHý'D‹Ç‹Ïÿ²±;Ãt‰=°®ë6ÿ`²D‹
¡®ƒøxDDÎD‰
“®D;΄&D;Ë„D;Ï…C‹uh;óuI‹E‹p÷]xD‹MXM‹ÆҋΉ\$(ƒâH‰\$ ×ÿرLcàD;ã„A½ÝÝ~hH¸ðÿÿÿÿÿÿL;àwYKL$Hùw5HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèkŸH+àH|$0H;û„µÇÌÌëèyÙþÿH‹øH;ÃtD‰(HƒÇëH‹ûH;û„‹M‹Ä3ÒH‹ÏMÀèÊþÿD‹MXM‹Æº‹ÎD‰d$(H‰|$ ÿ"±;ÃtL‹M`D‹ÀH‹×A‹Ïÿs°‹ØHOðD9)uèwØþÿ‹ÃéˆD‹epH‹ûD;ãuI‹ED‹`‹uh;óuI‹E‹pA‹Ìèþ|ƒøÿu3ÀëU;Æt$LMXM‹Æ‹Ð‹Î‰\$(H‰\$ è,}H‹øH;Ãt×L‹ðH‹E`D‹MXM‹ÆA‹×A‹ÌH‰D$ ÿí¯‹ðH;ûtH‹Ïèê×þÿ‹ÆH‹MH3Íè°ÏþÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@A‹ÙI‹øè¤Óþÿ‹„$ D‹œ$¨HL$@D‰\$8‰D$0‹„$˜‰D$(H‹„$D‹ËL‹Ç‹ÖH‰D$ è.ýÿÿ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‹i“ÃHƒì(è[WÿÿH‹ˆÀH;
Žt‹€È…“ŒuèÔCÿÿH‹ÈH‹@HƒÄ(ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì@·rB·jDH‹ùH…ÉuƒÈÿéçHƒd$8HAA¹1EaÐH‰T$0HL$0D‹ÆA‹ÔH‰D$ è¥àÿÿHOEL$1H‰L$ HL$0D‹ÆA‹Ô‹Øè…àÿÿHOEL$2H‰L$ HL$0D‹ÆA‹ÔØèeàÿÿEL$3HL$0ØHG D‹ÆA‹ÔH‰D$ èEàÿÿEL$4HL$0ØHG(D‹ÆA‹ÔH‰D$ è%àÿÿEL$5HL$0ØHG0D‹ÆA‹ÔH‰D$ èàÿÿEL$6HL$0D‹ÆA‹ÔH‰|$ ØèéßÿÿEL$)ØHG@HL$0D‹ÆA‹ÔH‰D$ èÉßÿÿEL$*HL$0ØHGHD‹ÆA‹ÔH‰D$ è©ßÿÿEL$+HL$0ØHGPD‹ÆA‹ÔH‰D$ è‰ßÿÿØHGXEL$,HL$0D‹ÆA‹ÔH‰D$ èißÿÿEL$-ØHG`HL$0D‹ÆA‹ÔH‰D$ èIßÿÿEL$.HL$0ØHGhD‹ÆA‹ÔH‰D$ è)ßÿÿEL$/HL$0ØHG8D‹ÆA‹ÔH‰D$ è	ßÿÿEL$CHL$0ØHGpD‹ÆA‹ÔH‰D$ èéÞÿÿEL$DHL$0ØHGxD‹ÆA‹ÔH‰D$ èÉÞÿÿEL$EHL$0ØH‡€D‹ÆA‹ÔH‰D$ è¦ÞÿÿEL$FHL$0ØH‡ˆD‹ÆA‹ÔH‰D$ èƒÞÿÿEL$GHL$0ØH‡D‹ÆA‹ÔH‰D$ è`ÞÿÿEL$HHL$0ØH‡˜D‹ÆA‹ÔH‰D$ è=ÞÿÿØH‡ EL$IHL$0D‹ÆA‹ÔH‰D$ èÞÿÿEL$JHL$0ØH‡¨D‹ÆA‹ÔH‰D$ è÷ÝÿÿEL$KHL$0ØH‡°D‹ÆA‹ÔH‰D$ èÔÝÿÿEL$LHL$0ØH‡¸D‹ÆA‹ÔH‰D$ è±ÝÿÿEL$MHL$0ØH‡ÀD‹ÆA‹ÔH‰D$ èŽÝÿÿEL$NHL$0ØH‡ÈD‹ÆA‹ÔH‰D$ èkÝÿÿEL$7HL$0ØH‡ÐD‹ÆA‹ÔH‰D$ èHÝÿÿEL$8HL$0ØH‡ØD‹ÆA‹ÔH‰D$ è%ÝÿÿEL$9HL$0ØH‡àD‹ÆA‹ÔH‰D$ èÝÿÿEL$:HL$0ØH‡èD‹ÆA‹ÔH‰D$ èßÜÿÿØH‡ðEL$;HL$0D‹ÆA‹ÔH‰D$ è¼ÜÿÿEL$HL$0ØH‡D‹ÆA‹ÔH‰D$ èSÜÿÿEL$?HL$0ØH‡D‹ÆA‹ÔH‰D$ è0ÜÿÿEL$@HL$0ØH‡D‹ÆA‹ÔH‰D$ è
ÜÿÿEL$AHL$0ØH‡ D‹ÆA‹ÔH‰D$ èêÛÿÿEL$BHL$0ØH‡(D‹ÆA‹ÔH‰D$ èÇÛÿÿEL$'HL$0ØH‡0D‹ÆA‹ÔH‰D$ è¤ÛÿÿEL$(HL$0ØH‡8D‹ÆA‹ÔH‰D$ èÛÿÿØH‡@H‰D$ EL$HL$0D‹ÅA‹Ôè^ÛÿÿEL$HL$0ØH‡HD‹ÅA‹ÔH‰D$ è;ÛÿÿHL$0A¹ØH‡PD‹ÅA‹ÔH‰D$ èÛÿÿHL$0A¹	ØH‡\D‹Å3ÒH‰D$ èôÚÿÿ‰¯XÃH‹\$PH‹l$XH‹t$`H‹|$hHƒÄ@A\ÃÌH…É„àSHƒì H‹ÙH‹Iè¢ÐþÿH‹Kè™ÐþÿH‹KèÐþÿH‹K è‡ÐþÿH‹K(è~ÐþÿH‹K0èuÐþÿH‹èmÐþÿH‹K@èdÐþÿH‹KHè[ÐþÿH‹KPèRÐþÿH‹KXèIÐþÿH‹K`è@ÐþÿH‹Khè7ÐþÿH‹K8è.ÐþÿH‹Kpè%ÐþÿH‹KxèÐþÿH‹‹€èÐþÿH‹‹ˆèÐþÿH‹‹èøÏþÿH‹‹˜èìÏþÿH‹‹ èàÏþÿH‹‹¨èÔÏþÿH‹‹°èÈÏþÿH‹‹¸è¼ÏþÿH‹‹Àè°ÏþÿH‹‹Èè¤ÏþÿH‹‹Ðè˜ÏþÿH‹‹ØèŒÏþÿH‹‹àè€ÏþÿH‹‹èètÏþÿH‹‹ðèhÏþÿH‹‹øè\ÏþÿH‹‹èPÏþÿH‹‹èDÏþÿH‹‹è8ÏþÿH‹‹è,ÏþÿH‹‹ è ÏþÿH‹‹(èÏþÿH‹‹0èÏþÿH‹‹8èüÎþÿH‹‹@èðÎþÿH‹‹HèäÎþÿH‹‹PèØÎþÿHƒÄ [ÃÌÌH‰\$H‰l$WHƒì ƒy H‹ùH-W{tKºh¹èbbÿÿH‹ØH…Àu¸ëMH‹×H‹Èè˜÷ÿÿ…ÀtH‹ËèÀýÿÿH‹ËètÎþÿëØǃ`ëH‹ÝH‹‡XH;Åtðƒ€`ÿH‰ŸX3ÀH‹\$0H‹l$8HƒÄ _ÃÌÌE3ÉH‹ÑD8	tŠ<0|<9,0ˆHÿÂD8
uêóÃ<;uòL‹ÂAŠ@AˆIÿÀA:ÁuñëáÌH…ÉtBSHƒì H‹ÙH‹	H;
5ŠtèÚÍþÿH‹KH;
+ŠtèÈÍþÿH‹KH;
!Štè¶ÍþÿHƒÄ [ÃH‹ÄH‰XH‰hH‰pWATAUAVAWHƒì@3ÛH‹ñH‰HÈH‰XÐ9Yu9YuL‹ëL‹óH-ĉéX¿XH‹×Dg©I‹ÌèaÿÿH‹èH;ÃuA‹Äé…H‹–(H‹ÈL‹Ç艿þÿ¿H‹Ïè|`ÿÿL‹ðH;Ãu
H‹ÍèÍþÿëlj9^„ÈH‹ÏèW`ÿÿL‹èH;Ãts‰·~>HL$0A¹A‹ÔD‹ÇH‰l$ èîÖÿÿHMH‰L$ HL$0A¹D‹ÇA‹Ô‹ØèÍÖÿÿL}HL$0A¹D‹ÇA‹ÔØL‰|$ è¬ÖÿÿÃtH‹Íè”þÿÿAƒÌÿH‹Íè€ÌþÿI‹Îé[ÿÿÿI‹3ÛëŠ<0|<9
,0ˆIÔ8uëë;<;uóL‹ÂAŠ@AˆIÿÀ:ÃuòëãH‹ˆL‹ëH‰EH‹ŠˆH‰EH‹‡ˆH‰EE‰&L;ëtE‰eH‹†H;ÃtðƒÿH‹ŽH;ËtðƒÿuH‹ŽèåËþÿH‹Ž(èÙËþÿL‰®L‰¶H‰®(3ÀL\$@I‹[0I‹k8I‹s@I‹ãA_A^A]A\_ÃE3ÉH‹ÑD8	tŠ<0|<9,0ˆHÿÂD8
uêóÃ<;uòL‹ÂAŠ@AˆIÿÀA:ÁuñëáÌH…É„‹SHƒì H‹ÙH‹IH;
¸‡tèEËþÿH‹K H;
®‡tè3ËþÿH‹K(H;
¤‡tè!ËþÿH‹K0H;
š‡tèËþÿH‹K8H;
‡tèýÊþÿH‹K@H;
†‡tèëÊþÿH‹KHH;
|‡tèÙÊþÿHƒÄ [ÃÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì@E3äH‹ñH‰HØL!`àD9auD9auE3íH-ã†é	¿XH‹×O©è:^ÿÿH‹èH…Àu
¸é8»H‹Ëè¯]ÿÿL‹èH…Àu
H‹ÍèKÊþÿë×D! D9f„hH‹Ëèˆ]ÿÿL‹àH…Àu
H‹Íè$ÊþÿI‹Íëσ ·~8A¹HEAQìHL$0D‹ÇH‰D$ èÔÿÿHM A¹H‰L$ AQíHL$0D‹Ç‹ØèêÓÿÿHM(A¹H‰L$ AQëHL$0D‹ÇØèÈÓÿÿA¹HL$0ØHE0AQêD‹ÇH‰D$ è¦ÓÿÿA¹Lu8HL$0AQéD‹ÇØL‰t$ è„ÓÿÿA¹PØHE@HL$0AQ±D‹ÇH‰D$ èbÓÿÿA¹QØHEHHL$0AQ°D‹ÇH‰D$ è@ÓÿÿHL$0A¹ØHEPD‹Ç3ÒH‰D$ è ÓÿÿHL$0A¹ØHEQD‹Ç3ÒH‰D$ èÓÿÿHL$0A¹TØHERD‹Ç3ÒH‰D$ èàÒÿÿØHESHL$0A¹UD‹Ç3ÒH‰D$ èÀÒÿÿHL$0ØHETA¹VD‹Ç3ÒH‰D$ è ÒÿÿHL$0A¹WØHEUD‹Ç3ÒH‰D$ è€ÒÿÿHL$0A¹RØHEVD‹Ç3ÒH‰D$ è`ÒÿÿHL$0A¹SØHEWD‹Ç3ÒH‰D$ è@ÒÿÿÃt H‹Íè¸üÿÿH‹ÍèÈþÿI‹ÍèÈþÿI‹Ìé¸ýÿÿI‹ëŠ<0|<9,0ˆHÿ€:uêë)<;uòL‹ÂAŠ@AˆIÿÀ<uòëâH!„H‹ÍL‹ÇèºþÿH‹†(H‹H‰MH‹†(H‹HH‰MH‹†(H‹HH‰MAÇEM…ätAÇ$H‹† H…ÀtðƒÿH‹ŽH…ÉtðƒÿuH‹Ž(èSÇþÿH‹ŽèGÇþÿL‰¦ L‰®H‰®(3ÀH‹\$`H‹l$hH‹t$pH‹|$xHƒÄ@A^A]A\ÃÌ3ÀÃÌHƒì(è;GÿÿH‹
~H9ˆÀt‹€È…s|uè´3ÿÿH‹…ƒHƒÄ(Ã@SHƒì0L‹ÉH…Ét
H…ÒtM…Àu,Dˆè|#ÿÿ»Hƒd$ E3ÉE3À3Ò3ɉèÄÿÿ‹ÃHƒÄ0[À9t	HÿÁHƒêuòH…ÒuAˆë¿AŠIÿÀˆHÿÁ„ÀtHƒêuëH…ÒuAˆè#ÿÿ»"ë 3ÀëµÌÌÌHƒì8H‹oH3ÄH‰D$ ŠE3ÉL‹ÚL‰$L‰L$L‰L$L‰L$L‹ÑëD¶À¶ÀƒàIÁèŠÈÒâBIÿÃAŠºA:ÁuÚ$ëAÿÁºIÿÂE¶A‹ÈIÁèƒáÓâB„tßIcÁH‹L$ H3Ìè½þÿHƒÄ8ÃH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒì 3ÛM‹è‹ú;ÓL‹ñ¸‹ó|?;Ãt=I‹M>™+ÂÑøHcèL‹åMäK‹æèèµÿÿ;ÃuKLæI‰Më
}}ÿëu;÷~Á;ÃH‹l$HH‹t$PH‹|$X”ËÃH‹\$@HƒÄ A^A]A\ÃÌ@SHƒì IH‹Ùÿ꜉C$‰C HƒÄ [ÃÌÌH‰\$WHƒì0H‹»mH3ÄH‰D$(H‹úH‹ÙH…Étf€9taHh&ègÙÿÿ…ÀtQHT&H‹ËèTÙÿÿ…Àu‹O$DHLD$ Pÿsœ…ÀtBH\$ H‹Ëèî×ÿÿH‹L$(H3ÌèM¼þÿH‹\$PHƒÄ0_ËO$LD$ A¹ºÿ1œ…Àu3ÀëÇHÞ%HL$ èàØÿÿ…Àu¥ÿ6žëªE3ÀHª%A@f;
tDÀHƒÂAƒø
rîóÃ3ÀÃÌÌÌŠL‹ÁE3Éë'BŸIÿÀ<w€ÂÙë
B¿<w€Âù¾ÊAŠEÉFLÉЄÒuÕA‹ÁÃÌÌÌ3ÒŠHÿÁH‹
ÉŒH;Ït2èg6ÿÿH…Àt(ÿÐH‹ØH…ÀtH‹
±ŒH;ÏtèG6ÿÿH…ÀtH‹ËÿÐH‹ØH‹
ƒŒè.6ÿÿH…ÀtD‹ÍM‹ÅI‹ÖH‹ËÿÐë3ÀH‹\$pH‹l$xHƒÄ@A^A]A\_^ÃHƒì8…Éx ƒù~
ƒùu‹È~ë1‹À~‰
º~ë#èïÿÿHƒd$ E3ÉE3À3Ò3ÉÇè8ÿÿƒÈÿHƒÄ8É
eÃÌ‹eÃÌH‰\$H‰l$H‰t$WHƒì`3íI‹ðH‹úH‹ÙL;Åu3ÀéH;Íu)è‡ÿÿE3ÉE3À3Ò3ÉH‰l$ ÇèÑÿÿ¸ÿÿÿéÙH;ÕtÒIøÿÿÿwÉHL$@I‹Ñ舲þÿL‹\$@A‹S;ÕuH·fƒøAr
fƒøZwfƒÀ ·fƒùAr
fƒùZwfƒÁ HƒÃHƒÇHƒît
f;Åtf;Át·ɷÀ+ÁëVA‹CHL$@L‹Ë‰D$8‰t$0A¸H‰|$(‰t$ èëb;Åu'èÂÿÿÇ@8l$X„DÿÿÿH‹D$Pƒ Èýé3ÿÿÿƒÀþ@8l$XtH‹L$Pƒ¡ÈýL\$`I‹[I‹kI‹s I‹ã_Ã@SHƒì03ÛL‹Ñ9ƒ…‚H;Ëu&èSÿÿE3ÉE3À3Ò3ÉH‰\$ Çèÿÿ¸ÿÿÿë_H;ÓtÕIøÿÿÿwÌA·fƒøAr
fƒøZwfƒÀ ·
fƒùAr
fƒùZwfƒÁ IƒÂHƒÂIƒèt
f;Ãtf;ÁtÁ·É·À+ÁëE3ÉèþÿÿHƒÄ0[ÃÌH‰\$H‰t$WHƒì0H‹ÙH…ÉtKèÀBÿÿºHHH‹ðèKYH‹øH…Àt-HVL‹ÃH‹Èè0…ÀtHƒd$ E3ÉE3À3Ò3ÉèKÿþÿH‹Çë3ÀH‹\$@H‹t$HHƒÄ0_ÃH‰\$WHƒì03ÿH;Ït
H;×vL;Çu0f‰9è5ÿÿ»E3ÉE3À3Ò3ÉH‰|$ ‰è~ÿÿ‹ÃH‹\$@HƒÄ0_ÃL‹ÉA·IƒÀfA‰IƒÁf;ÇtHƒêuåH;×uf‰9èâÿÿ»"ë«3Àë¿ÌÌÌH‰\$H‰l$WHƒì0Hƒd$@H‹,{H‹H…ÀtuƒÍÿƒd$(Hƒd$ D‹ÍL‹À3Ò3ÉÿNŒHcø…ÀtxH‹ÏºèvGÿÿH‰D$@H…ÀtaL‹D‹Í3Ò3ɉ|$(H‰D$ ÿŒ…Àt:HL$@3Òèß;ÿÿ…ÀxHƒÃH‹H…ÀuŽ3ÀH‹\$HH‹l$PHƒÄ0_ÃH‹L$@H…ÉtëH‹L$@èK³þÿ‹ÅëÖÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì0H‹¨zE3äA‹üI;ÜuƒÈÿéÐfƒø=tÿÇH‹ËèÙ@ÿÿH\C·fA;ÄuâGºHcÈè£FÿÿH‹øH‰%zI;Ät»H‹QzfD9#thH‹Ëè—@ÿÿfƒ;=ptCHcîºH‹ÍèfFÿÿH‰I;ÄtxL‹ÃH‹ÕH‹ÈèþÿÿA;ÄtE3ÉE3À3Ò3ÉL‰d$ èýþÿHƒÇHcÆHCfD9#uŸH‹ãyH‹ËèW²þÿL‰%ÔyL‰'Ç¢3ÀH‹\$@H‹l$HH‹t$PH‹|$XHƒÄ0A\ÃH‹
kyè²þÿL‰%_yéõþÿÿÌÌH‰\$H‰l$H‰t$WHƒì ÿŠ3ÛH‹øH;Ãu3ÀëLf9tHƒÀf9u÷HƒÀf9uî+ǃÀHcèH‹ÍèEÿÿH‹ðH;ÃtL‹ÅH‹×H‹Èèû£þÿH‹ÞH‹ÏÿljH‹ÃH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌë	f;ÂtHƒÁ·f…Àuïf;ÂuH‹ÁÃ3ÀÃÌH‹ÄH‰XH‰hH‰pWHƒì`H‹ñH‹úHHØI‹ÑI‹éI‹Øè<­þÿH…Ûu8\$XtH‹D$Pƒ Èý3Àé¯H…öu:èÔ
ÿÿHƒd$ E3ÉE3À3Ò3ÉÇèýþÿ€|$XtH‹D$Pƒ Èý¸ÿÿÿëpH…ÿtÁHûÿÿÿw¸H‹L$HƒyuL‹ÍL‹ÃH‹×H‹Îè
dë1‹A‹QHL$@‰D$8‰\$0L‹ÎA¸H‰|$(‰\$ èUc…ÀtŒƒÀþ€|$XtH‹L$Pƒ¡ÈýL\$`I‹[I‹kI‹s I‹ã_ÃÌE3ÉéèþÿÿH‰\$H‰t$WHƒì0H‹ÙH…ÉtFèEÿÿH‹ðHHè°°þÿH‹øH…Àt-HVL‹ÃH‹Èè±Bÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éè”úþÿH‹Çë3ÀH‹\$@H‹t$HHƒÄ0_ÃÌH‰\$H‰l$WHƒì@Hƒd$PH‹wH‹H…À„ªƒÍÿHƒd$8Hƒd$0ƒd$(Hƒd$ D‹ÍL‹À3Ò3Éÿr‰Hcø…À„‘H‹Ïºè.CÿÿH‰D$PH…ÀtzHƒd$8Hƒd$0L‹D‹Í3Ò3ɉ|$(H‰D$ ÿ+‰…ÀtGHL$P3Òè'>ÿÿ…ÀyH‹L$PH…Étè¯þÿHƒd$PHƒÃH‹H…À…Yÿÿÿ3ÀH‹\$XH‹l$`HƒÄ@_ÃH‹L$Pèê®þÿ‹ÅëâÌÌH‰\$WHƒì0I‹ØH‹úH…Ét23ÒHBàH÷ñH;Çs$è„ÿÿHƒd$ E3ÉE3À3Ò3ÉÇèÍúþÿ3Àë]H¯ù¸H…ÿHDø3ÀHƒÿàwH‹
š|PL‹Çÿ¦‡H…Àu-ƒ=ªtH‹Ïèt5ÿÿ…ÀuËH…Ût²ÇëªH…ÛtÇH‹\$@HƒÄ0_ÃÌH‰\$H‰t$WHƒì03ÿH‹ÚH‹ñH…Òt13ÒHGàH÷óI;Às#èÍ
ÿÿH!|$ E3ÉE3À3Ò3ÉÇèúþÿ3Àë=I¯ØH…ÉtèuHH‹øH‹ÓH‹ÎèsìþÿH‹ðH…ÀtH;ûsH+ßH3ÒL‹ÃèŸþÿH‹ÆH‹\$@H‹t$HHƒÄ0_ÃÌÌHƒì8ƒùþu
èR
ÿÿÇ	ëR…Éx.;
›s&HcÉH ›H‹ÁƒáHÁøHkÉXH‹Â¾Dƒà@ë"è
ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ	è\ùþÿ3ÀHƒÄ8ÃÌH‹ÄH‰HH‰PL‰@L‰H SWHƒì83ÀH…É•À…Àu%èÆ	ÿÿÇHƒd$ E3ÉE3À3Ò3ÉèùþÿƒÈÿëjH|$XèØ·þÿHP0¹è>¹þÿèÄ·þÿHH0èÓSÿÿ‹Øè´·þÿL‹ÏE3ÀH‹T$PHH0èVÿÿ‹øè™·þÿHP0‹ËèzTÿÿ舷þÿHP0¹èv¹þÿ‹ÇHƒÄ8_[ÃÌH‹ÄH‰PL‰@L‰H Hƒì(L@è¤aHƒÄ(ÃÌÌÌH‹ÄH‰PL‰@L‰H Hƒì(L@è˜aHƒÄ(ÃÌÌÌH‹ÄH‰HH‰PL‰@L‰H Hƒì(L@3ÒènaHƒÄ(ÃÌH‹ÄH‰PL‰@L‰H Hƒì(L@èdaHƒÄ(ÃÌÌÌH‹ÄH‰HH‰PL‰@L‰H Hƒì(L@3Òè:aHƒÄ(ÃÌH‹}T3ÀHƒÊH9À€”À÷ÙHÉH#ÊH‰
®€ÃÌH‹
UT3ÀHƒÉH9
˜€”ÀÃH‰\$fD‰L$ UVWHƒì`3íI‹øH‹òH‹ÙH;ÕuL;ÅvH;Ít‰)3Àé¤H;Ítƒ	ÿIøÿÿÿv$èíÿÿ»E3ÉE3À3Ò3ɉH‰l$ è6÷þÿ‹ÃëoH‹”$ HL$@èü¦þÿL‹\$@A9k…Í·„$˜¹ÿf;ÁvLH;õtH;ýv
L‹Ç3ÒH‹ÎèœþÿèÿÿÇ*ètÿÿ‹@8l$XtH‹L$Pƒ¡ÈýH‹œ$€HƒÄ`_^]ÃH;õtCH;ýw<è@ÿÿ»"E3ÉE3À3Ò3ɉH‰l$ è‰öþÿ@8l$X„HÿÿÿH‹L$Pƒ¡Èýé7ÿÿÿˆH;ÝtÇ@8l$X„çþÿÿH‹D$Pƒ ÈýéÖþÿÿH„$ˆ‰¬$ˆA‹KH‰D$8H‰l$0L„$˜A¹3Ò‰|$(H‰t$ ÿȃ;Åt9¬$ˆ…ÿÿÿH;Ýt’‰ëŽÿh‚ƒøz…÷þÿÿH;õtH;ýv
L‹Ç3ÒH‹Îèðšþÿè_ÿÿ»"E3ÉE3À3Ò3ɉH‰l$ è¨õþÿ@8l$X„gþÿÿH‹D$Pƒ ÈýéVþÿÿHƒì8Hƒd$ èáýÿÿHƒÄ8ÃH‹ÄH‰XH‰pWHƒìPH‹ù·ÚHH؃ÎÿI‹Ð‰p è,¥þÿL‹\$0McƒHD$0HL$xD·ËH‹×H‰D$ èýÿÿ…ÀDt$x€|$HtH‹D$@ƒ ÈýH‹\$`‹ÆH‹t$hHƒÄP_ÃÌH‰\$H‰t$WHƒì0ƒÎÿ·ÚH‹ù‰t$Pè‹ÇÿÿHƒd$ HL$PLcÀD·ËH‹×è%ýÿÿH‹\$@…ÀDt$P‹ÆH‹t$HHƒÄ0_Ã@SHƒì öB@I‹ØtHƒzuAÿë&ƒBÿx
H‹ˆHÿ¶Áë¾Éèêaÿÿƒøÿu	ëÿHƒÄ [ÃÌ…Ò~LH‰\$H‰l$H‰t$WHƒì I‹ùI‹ð‹Ú@ŠéL‹ÇH‹Ö@ŠÍÿËè…ÿÿÿƒ?ÿt…ÛçH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì Aö@@I‹ùI‹ð‹ÚH‹étIƒxuAë7…Ò~3ŠML‹ÇH‹ÖÿËèÿÿÿHÿŃ?ÿuèUÿÿƒ8*uL‹ÇH‹Ö±?èÿþÿÿ…ÛÍH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$UVWATAUAVAWHìÐH‹PH3ÄH‰„$È3ÀH‹ÙH‰L$hH‹úHL$xI‹ÐM‹é‰D$`D‹à‰D$TD‹ø‰D$H‰D$X‰D$Pè£þÿE3ÒI;ÚuAè»ÿÿ3ÛE3ÉE3À3Ò3ÉÇH‰\$ èóþÿ8œ$tH‹„$ˆƒ ÈýƒÈÿéAƒÎÿöC@L
Üþÿ…ºH‹ËèêZÿÿH‡aA;Æt(ƒøþt#LcÀL
³þÿI‹ÈAƒàHÁùMkÀXM„É€‡ë
L‹ÂL
þÿAö@8u)A;ÆtƒøþtHcÐH‹ÂƒâHÁøHkÒXI”Á€‡öB8€tAèïÿÿ3ÛE3ÉE3À3Ò3ÉÇH‰\$ è7òþÿ8œ$tH‹„$ˆƒ ÈýA‹ÆéKE3ÒI;út·@Š/A‹òD‰T$@D‰T$DA‹ÒL‰”$˜A:ê„H‹œ$¨A»HÿÇA;òH‰¼$°ŒÔEàÿÿÿ<3u€2uHƒÇAºôé&ÿÿÿ*ÿÿéA÷Ä0uAºìAƒÿÿA‹×¸ÿÿÿDÐA;ð…®I‹]IƒÅéØA÷Ä0uAºìA÷Ät~A;ðuE·MIƒÅëDAƒþc‡;ÿÿÿIcÆH@I;øu"H„ÌàD9uÇéãþÿÿºéóþÿÿH‹„ÌèfD‹H”$@
HL$LA¸è¿êÿÿE3ÀA;ÀtKÇD$DëAA;ðuA·EIƒÅë%Aƒþc‡½þÿÿIcÆH@I;ø„&H‹„Ìèf‹ˆ„$@
D‰\$LHœ$@
éD‰éMþÿÿD‰œ$°@€Å AƒÌ@A;ó…‘I;ø…ˆAƒþc‡UþÿÿIcÆH@H„ÌàD9…YÇ@ˆ¬ÌðD‰¤Ìôé«
ƒøeŒ“ƒøg~Ÿƒøi„˜ƒøn„#ƒøo„ƒøp„Áƒøs„Vþÿÿƒøu„oƒøx…O¸'é¬Aƒþc‡ÁýÿÿIcÆH@I;øuH„ÌàD9„jýÿÿé€ýÿÿH‹œÌèH‹A÷Ät5I;ØD‰œ$ˆHDNH‹Ãë
A+ÓfD9t	HƒÀA;ÐuîH+ÃHÑøéšýÿÿI;ØHDÍMH‹ÃëA+ÓD8tIÃA;Ðuð+ÃésýÿÿA¿Aºì¸‰„$˜A¹E„䉠AQòQÆD$T0‰T$PˆD$UéŒA¹E„äy}Aºì	ëvA;ðu
I‹}IƒÅë%Aƒþc‡ÆüÿÿIcÆH@I;ø„ÿÿÿH‹„ÌèH‹8èTæÿÿE3ÀA;À„šüÿÿ‹D$HAöÄ tf‰ë‰H‹¼$¸¸‰D$DéñAƒÌ@A¹
‹T$PAºäsJA;ðu
M‹EIƒÅé–Aƒþc‡BüÿÿIcÆH@I;øufH„ÌàD9uÇéêûÿÿºéúûÿÿAºäsMA;ðt¯Aƒþc‡þûÿÿIcÆH@I;øu"H„ÌàD9uÇé¦ûÿÿºé¶ûÿÿH‹„ÌèL‹é
AöÄ „AöÄ@tSA;ðuM¿EIƒÅéçAƒþc‡“ûÿÿIcÆH@I;øuH„ÌàD9„íüÿÿA‹ÓéTûÿÿH‹„ÌèL¿é§A;ðuE·EIƒÅé”Aƒþc‡@ûÿÿIcÆH@I;øt­H‹„ÌèD·ëpAöÄ@t6A;ðu
McEIƒÅë[Aƒþc‡ûÿÿIcÆH@I;ø„pÿÿÿH‹„ÌèLcë4A;ðu
E‹EIƒÅë%Aƒþc‡ÑúÿÿIcÆH@I;ø„:ÿÿÿH‹„ÌèD‹E3ÒAöÄ@t
M;Â}I÷ØAºìAºär
AºärE‹ÀE;ú}E‹ûë¸Aƒä÷D;øDOø‹¼$˜I‹ÀHœ$?H÷ØÉ#ʉL$PA‹ÏE+ûA;ÊM;Ât3ÒI‹ÀIcÉH÷ñL‹ÀB0ƒø9~LjI+ÛëÑH‹¼$¸H„$?+ÃIÛAºä	‰D$Lƒ|E3ÀA;Àt	€;0„nI+ÛD\$LÆ0é^DŠÅºébE;ø¸Hœ$@
‹ð}A¿ëIu@€ýguAE‹ûëHƒùþuè-7H‹
ê>Hƒùÿ„¹Hƒd$ LL$DHT$@A¸ÿŒX…À…‰ƒ=•=…ˆÿqYƒøxu}ƒ%}=ÿgXHƒd$8Hƒd$0‹ÈHD$HLD$@A¹3ÒÇD$(H‰D$ ÿlZH‹
]>Hƒùÿt0Hƒd$ LL$DHT$HD‹ÀÿX…Àtf‹D$@ëÇ	=ëí¸ÿÿH‹L$PH3ÌèxþÿHƒÄhÃH‰\$H‰t$WHƒì@H‹ñ3Û‹ÃH;Ë•À;Ãu+èïÜþÿ‰èÈÜþÿÇH‰\$ E3ÉE3À3Ò3ÉèÌþÿƒÈÿëQè´
ÿÿH‹ø¹èËÿÿH‹ÏHÿÏH‰|$0H;Ët"·HƒÆH‰t$Pèmþÿÿ¹ÿÿf;ÁuƒËÿëëιènÿÿ‹ÃH‹\$XH‹t$`HƒÄ@_Ã@SHƒì ·Ù¹èiÿÿ·Ëè$þÿÿ·Ø¹è3ÿÿf‹ÃHƒÄ [ÃÌÌf‰L$SHƒì`¸ÿÿ·Úf;Èu
3Éf‹Á鋸f;ÈsH‹V;·Éf‹Hf#ÃënHL$@I‹Ðè	{þÿL‹\$@ºA‹CLD$pHL$@‰D$0A‹CD‹Ê‰D$(HD$xH‰D$ è“53É;Áu	‹Áf‰L$xëf‹D$x8L$XtH‹D$Pƒ Èýf‹D$x·À·Ë#ÁHƒÄ`[ÃÌÌf‰L$SHƒì@¸ÿÿ·Úf;Èu3Àëo¸f;ÈsH‹ :·É·H·Ë#ÁëPƒ=CLu<‹ÿ3ºLD$P‰D$0‹Û3H
@5‰D$(HD$`D‹ÊH‰D$ èÞ4·L$PE3À·ÓèºþÿÿHƒÄ@[ÃékÿÿÿÌÌÌA ÃH‰l$WHƒìpHcùHL$PèåyþÿÿsbH‹T$Pƒº~LD$Pº‹ÏèÿÿH‹T$PëH‹‚@·xƒà…ÀtH‹‚H¶8éè€|$htH‹D$`ƒ Èý‹ÇéáH‹D$Pƒ¸~6‹ïHT$PÁý@¶Íè.jÿÿ…Àt@ˆ¬$€@ˆ¼$Æ„$‚ºë èòÙþÿºÇ*@ˆ¼$€Æ„$H‹L$PÇD$@LŒ$€‹AA¸‰D$8H„$ÇD$0H‰D$(‰T$ ‹QHL$Pè¢ÿÿ…À„2ÿÿÿƒø¶„$t
¶Œ$‘ÁàÁ€|$htH‹L$`ƒ¡ÈýH‹¬$ˆHƒÄp_ÃHƒì(ƒ=mJuA¿ƒøwƒÁ ‹Áë3ÒèmþÿÿHƒÄ(ÃH‹ÄH‰XL‰@H‰HUVWATAUAVAWHì€3ÿA´€A‹ñH‹ÚÇ@¨o‰xœ@ˆ¼$ØH‰x°E„Ìt‰x¸A¶ë‰l$pDŠ÷HL$Tè9;ÇtE3ÉE3À3Ò3ÉH‰|$ è…Æþÿºær÷Æ@u
|$T€tE
ô‹ÎA¸¸ÀA#Ⱥ€;ÏtT+Ít:;Ít1èˆØþÿ‰8ƒÿè^Øþÿ»E3ÉE3À3Ò3ÉH‰|$ ‰è§Çþÿ‹ÃéûD‹øë@öÆt÷ÆuíA¿@ëD‹ú‹Œ$àA¼ƒét,ƒét#ƒétƒétƒù@u‹D;ú‹Ï”ÁëA‹ÈëA‹Ìë‹Íë‹Ï‹Æº‰L$H#ÂtF=t8=t*=t=t*=t&=t;Âté/ÿÿÿA‹ìë½ë
½ëA‹èºæA½€D‰l$PsŠËAöÐ"„$言AEDDèD‰l$P@öÆ@tAºíAºïƒÉD‰l$P‰L$Hºæs
AºíD‰l$P@öÆ tAºíë@öÆt
AºíD‰l$Pè1ÿÿ‰ƒøÿu!è×þÿ‰8ƒÿèóÖþÿÇèèÖþÿ‹é H‹„$ÀD‹D$HH‹Œ$ÐH‰|$0LL$`A‹×D‰l$(ljl$ ÿ†RH‰D$XHƒøÿ…Œ¹ÀA‹Ç#Á;ÁuC¸@„ðt9D‹D$HH‹Œ$ÐH‰|$0Aº÷LL$`D‰l$(A‹×‰l$ ÿ1RH‰D$XHƒøÿu;HcL-,gH‹ÁƒáHÁøHkÉXI‹DÅ€dþÿR‹Èè[ÖþÿèÖþÿ‹8éÌH‹ÈÿšR;ÇuMHcL-äfH‹ÁƒáHÁøHkÉXI‹DÅ€dþÿ¾Q‹È‹ØèÖþÿH‹L$XÿÂQ;ßu§è½ÕþÿÇ
ëšA;ÄuA€Î@ë	ƒøuA€ÎH‹T$X‹è
ÿÿHcL-wfH‹ÁƒáºHÁøD
òI‹DÅHkÉXDˆtHcH‹ÁƒáHÁøHkÉXI‹DÅ€d8€AŠÆ$HˆD$L…†E„ö‰ÂA„ôtx‹E‹ÄƒÊÿèŽ2‰D$Dƒøÿuè8Õþÿ8ƒtP‹è}Zÿÿééþÿÿ‹HT$@A¸@ˆ|$@èÍ	;Çu€|$@uHcT$D‹è:/ƒøÿtÁ‹E3À3Òè-2ƒøÿt°ºE„ö‰<¹@…ñu‹D$T#Áuºîëð‹Æ#Á=@tJ=t,=@t%=t+=@t$=t=@u(ˆ”$Ø빋Æ#Á;ÁuDˆ¤$Øë@ˆ¼$Ø÷Æ„º‰|$DAöÆ@…¬A‹Ç%À=@„$=€t|=À…‡;ï†A;ìvƒýv8ƒý…l¾Œ$ØA¸‹ïA+È„ A;È…PÇD$Dÿþé‹E‹Ä3ÒèsðÿÿH;ÇtÀ‹E3À3ÒèbðÿÿHƒøÿ„|þÿÿ‹HT$DA¸èZƒøÿ„aþÿÿA;Ät ƒøuk|$DuD@þDˆ„$ØéÜ·D$D=þÿu‹è­Xÿÿè4Óþÿ»‰‹ûéã=ÿþu#‹E3ÀA‹Ôèz0ƒøÿ„ùýÿÿDˆ¤$Ø醋E3À3ÒèX0ƒøÿë;;ïvqA;ì†üþÿÿƒý‡êþÿÿ‹E‹Ä3Òè•ïÿÿH;Ç„Þþÿÿ‹E3À3Òè€ïÿÿHƒøÿu8é™ýÿÿÇD$DA¼‹HcÅE‹ÄHTDD+Åèfaÿÿƒøÿ„mýÿÿèD;åÛA¸Hc@Š¬$ØH‹Áƒá@€åHÁøHkÉXI‹DÅ€d8€@l8HcH‹ÂƒâHÁøHkÒXI‹LÅ‹Æ€d8ÁèÀàD8@8|$Lu!@öÆtHcH‹ÁƒáHÁøHkÉXI‹DÅ€L A‹Ç%À=À…ŸA„ð„–H‹L$XÿÊM‹D$PD‹D$HH‹Œ$ÐH‰|$0‰D$(Aº÷LL$`ÇD$ A‹×ÿuMHƒøÿu6ÿqM‹ÈèÆÑþÿLcI‹ÃAƒãHÁøMkÛXI‹DÅB€dþ‹èŠÿÿéBûÿÿHcH‹ÊƒâHÁùHkÒXI‹LÍH‰
‹ÇH‹œ$ÈHÄ€A_A^A]A\_^]ÃÌÌH‹Ä‰PL‰@L‰H VWHƒìXƒHØÿƒ`ÜE3ÀH…ÉA•ÀE…Àu(èôÐþÿÇHƒd$ E3ÉE3À3Ò3Éè=ÀþÿƒÈÿé“H„$€HƒÀD‹@øƒd$0D‰D$(ÇD$ @D‹ÊL‹ÁHT$@HL$Dèv÷ÿÿ‹ð‰D$Hƒ|$Dt9…Àt(Hc|$@H‹ÏH‹ÇHÁøL_aƒáHkÉXI‹À€dþë‹|$@‹ÏèVÿÿë‹|$@…ötèGÐþÿ‰0ƒÈÿë‹ÇHƒÄX_^ÃÌÌÌH‰t$WHƒìPE‹ÐL‹Áƒd$@3ÀH‹´$€H…ö•À…Àu(èÐþÿ¿‰8Hƒd$ E3ÉE3À3Ò3ÉèN¿þÿ‹ÇéÚƒÿ3ÀH…É•À…Àu(èÏÏþÿ¿‰8Hƒd$ E3ÉE3À3Ò3Éè¿þÿ‹Ç飋Œ$ˆ…Ét8A÷Áþÿÿ¸”À…Àu%è‰Ïþÿ¿‰8Hƒd$ E3ÉE3À3Ò3ÉèѾþÿ‹Çë`‰L$0D‰L$(D‰T$ D‹ÊH‹ÖHL$@è'öÿÿ‹ø‰D$Dƒ|$@t,…Àt!HcH‹ÁHÁøL`ƒáHkÉXI‹À€dþ‹èÿÿ…ÿtƒÿ‹ÇH‹t$`HƒÄP_ÃÌÌL‹ÜE‰CM‰K SHƒì@ƒd$(MKèIC M‰KØD‹ƒËÿ‰\$0è˜þÿÿ‹L$0…ÀEË‹ÁHƒÄ@[ÃÌÌÌHƒì8A‹ÁD‹L$`E‹ÐL‹ÚÇD$(H‰L$ D‹ÀA‹ÒI‹ËèWþÿÿHƒÄ8ÃÌÌH‹ÄH‰XH‰hH‰pWHƒìPH‹ùH‹òHHØI‹ÑI‹Øè›mþÿ3íH;Ýu@8l$HtH‹D$@ƒ Èý3Àé‹H‹L$89iuL‹ÃH‹ÖH‹ÏèJé[H;ýu<èÎþÿE3ÉE3À3Ò3ÉH‰l$ Çè]½þÿ@8l$HtH‹D$@ƒ Èý¸ÿÿÿé-H;õt¿A±¶HÿËHÿÇD„L
tUH;Ýu¶f‹ÕD„L…ZÿÿÿéÄ@8/u‹ÕëC¶fÁâHÿÇfÐf;Qrf;QwfQë$f;Qrf;QwfQë·ÂöDt¶”D¶HÿÆI‹ÀE„LtNH;Ýu‹Åë^HÿË@8.uf‹ÅëQ¶fAÁàHÿÆfDÀfA‹ÀfD;Arf;AwfAë+f;Ar%f;AwfAëA·ÀöDt
¶„ëfA‹Àf;Âuf;Õ„ƒþÿÿH;Ý…úþÿÿéuþÿÿÀƒàÿÈ@8l$HtH‹L$@ƒ¡ÈýH‹\$`H‹l$hH‹t$pHƒÄP_ÃÌÌE3ÉéþÿÿH‰\$H‰l$H‰t$WHƒìP3íI‹ØH‹òH‹ùL;Åu3Àé&HL$0I‹Ñè˜kþÿL‹\$8A9kuL‹ÃH‹ÖH‹Ïèë°þÿéèH;ýu<è0ÌþÿE3ÉE3À3Ò3ÉH‰l$ Çèz»þÿ@8l$HtH‹D$@ƒ Èý¸ÿÿÿéºH;õt¿A°¶HÿËHÿÇF„Dt-H;Ýu¶‹ÍF„Du[f‹ÐëG@8/uf‹Íë
¶fÁáfÈHÿǶHÿÆF„Dt#H;Ýu‹ÕëHÿË@8.uf‹Õë
¶fÁâfÐHÿÆf;Ñu&f;ÍtH;Ýu„@8l$H„þþÿÿH‹D$@ƒ ÈýéíþÿÿÀƒàÿÈ@8l$HtH‹L$@ƒ¡ÈýH‹\$`H‹l$hH‹t$pHƒÄP_ÃÌÌE3ÉéþÿÿH‰T$‰L$SUVWATAUAVAWHƒìXA¼þÿÿÿHcÁA‹ØD‰d$4‰\$8A;ÄuèËþÿ3ÿ‰8èßÊþÿÇ	é3ÿ;ÇŒï;œ[ƒãH‹ðL‹ðL
ÔýÿIÁþƒæK‹Œñ€‡HköXŠD1¨„·ûÿÿÿvè¥Êþÿ‰8è~ÊþÿÇ骋ï;ß„Š¨…‚H;×tÒDŠ|18A¸EÿAÐÿA¾Ïƒétƒéu‹Ã÷Шt«ƒãþL‹êëd‹Ã÷Шt›ÑëA;ØABØ‹Ëè¡ÿÿL‹èH;ÇuèÊþÿÇèÊþÿÇé=‹Œ$ 3ÒDBè¬æÿÿL
EÓýÿL‹ØK‹„ñ€‡L‰\0@K‹„ñ€‡I‹ÕA¸
öD0H„œŠL0	A:È„;ß„‡AˆMK‹„ñ€‡AƒÊÿAÚIUAh÷DˆD0	D:ÿtbK‹„ñ€‡ŠL09A:ÈtQ;ßtMˆ
K‹„ñ€‡AÚHÿÂAhøDˆD09A€ÿu.K‹„ñ€‡ŠL0:A:Èt;ßtˆ
K‹„ñ€‡HÿÂAhùAÚDˆD0:K‹Œñ€‡LL$0D‹ÃH‹1H‰|$ ÿŽD;Ç„ÏHcT$0;׌‹ÃH;Ї·L7ÒýÿêK‹„ð€‡öD0€„yA€ÿ„¸;×tA€}
u€L0ë€d0ûHcÅI‹ÝM‹åIÅH‰D$@L;èƒ:½
AŠ$<„
@:Åt
ˆHÿÃIÿÄéëH‹D$@HÿÈL;àsID$€8
u	IƒÄéL‹àé½K‹Œð€‡LL$0H”$°H‹1A¸IÿÄH‰|$ ÿŸC;Çu
ÿÝC;Çu{9|$0tuLTÑýÿK‹„ð€‡öD0Ht"€¼$°
t'@ˆ+K‹Œð€‡Š„$°ˆD1	ëGI;Ýu€¼$°
uÆ
ë3‹Œ$ A¸HƒÊÿèYäÿÿ€¼$°
LêÐýÿtëLßÐýÿ@ˆ+HÿÃL;d$@‚ìþÿÿëK‹„ð€‡öD0@u€L0ë	AŠ$ˆHÿËëA+íA€ÿ…ð;ï„èA¿I+ßö€uIßé²A‹×ëƒúI;ÝrI+ßA׶B8¼ Vtã¶B¾„ V;ÇuèÝÆþÿÇ*AƒÌÿé‘ÿÀ;ÂuHcÂHØë^K‹„ð€‡öD0Ht;I߃úˆL0	|ŠK‹Œð€‡I߈D19ƒúuŠK‹Œð€‡I߈D1:HcÂH+Øë‹Œ$ ÷ÚE‹ÇHcÒè.ãÿÿ‹D$8L‹¼$¨A+ÝÑèD‹ËM‹Å‰D$(3Ò¹éýL‰|$ ÿñA‹è;Çuÿ
B‹ÈèbÆþÿAƒÌÿéäD‹d$4;ÃHwÏýÿJ‹„ð€‡@•Çí‰|0Hé¿;׺
tfA9Uu€L0ë€d0ûHcÅI‹ÝM‹åN<(M;ïƒ{½
A·$fƒø„Ef;Åtf‰HƒÃIƒÄé%IGþL;àsID$f9u	IƒÄéÂL‹àéúK‹Œð€‡LL$0H”$¸H‹1A¸IƒÄH‰|$ ÿã@;Çuÿ!A;Ç…®9|$0„¤LÎýÿK‹„ð€‡öD0HtFº
f9”$¸tKf‰+Š„$¸K‹Œð€‡ˆD1	Š„$¹K‹Œð€‡ˆD19K‹„ð€‡ˆT0:ëWI;Ýuº
f9”$¸uf‰ë>‹Œ$ HÇÂþÿÿÿDBèkáÿÿº
LÿÍýÿf9”$¸tëº
LçÍýÿf‰+HƒÃM;ç‚®þÿÿë"K‹„ð€‡öD0@u€L0ëA·$f‰HƒÃ‹ëA+íD‹d$4L‹¼$¨M;ïtI‹Íè`gþÿAƒüþDDåA‹Äëiÿù?ƒøuèÄþÿÇ	è ÄþÿÇéýÿÿƒømuD‹ç뮋Èè$Äþÿéýÿÿ3Àë)èöÃþÿ‰8èÏÃþÿÇ	E3ÉE3À3Ò3ÉH‰|$ è³þÿƒÈÿHƒÄXA_A^A]A\_^][ÃÌH‰\$H‰t$‰L$WATAUAVAWHƒì0A‹ðL‹êHcùƒÿþuè’Ãþÿ3Û‰èiÃþÿÇ	ƒÈÿé3Û;ûŒâ;=#TƒÖL‹çL‹÷IÁþL= TAƒäMkäXK‹÷B¾L ƒáu.è8Ãþÿ‰èÃþÿÇ	H‰\$ E3ÉE3À3Ò3Éè[²þÿƒÈÿé©‹ÃAøÿÿÿ–À;Ãu+èúÂþÿ‰èÓÂþÿÇH‰\$ E3ÉE3À3Ò3Éè²þÿƒÈÿën‹ÏèÿÿK‹÷BöD tD‹ÆI‹Õ‹Ïès÷ÿÿ‹ØëèŠÂþÿÇ	èŸÂþÿ‰ƒËÿ‹Ïèsÿÿ‹Ãë)èŠÂþÿ‰ècÂþÿÇ	H‰\$ E3ÉE3À3Ò3Éè­±þÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌHƒì8H…Éu&èÂþÿHƒd$ E3ÉE3À3Ò3ÉÇèg±þÿHƒÈÿëL‹ÁH‹
G33ÒÿÇ<HƒÄ8ÃÌ̹邧þÿÌÌHì¨öÖ"t
¹
è
éþÿèahÿÿH…Àt
¹èRkÿÿö¯"t_HŒ$Ðÿ¯>HL$03ÒA¸˜è
VþÿH‹„$¨3ÉH‰D$@HD$0ÇD$0@H‰D$ H„$ÐH‰D$(ÿI>HL$ ÿ6>¹èĪþÿÌÌÌÌ‹:"D‹Â#ÊA÷ÐD#ÀDÁD‰%"ÃI‹ÁD‹L$(E‹Ð‹ÊL‹ÀA‹ÒHÿ%Ò;ÌÌH‰\$H‰t$WHƒì@‹òH‹ÑHL$ I‹ÙA‹øè`þÿD‹L$pL‹Ã‹×‹Îÿš;€|$8tH‹L$0ƒ¡ÈýH‹\$PH‹t$XHƒÄ@_ÃÌÌÌ@UATAUAVAWHƒìPHl$@H‰]@H‰uHH‰}PH‹†H3ÅH‰ED‹Ô8¾3ÛM‹ùE‹èD‹òH‹ùDfD;Óu7E3ÉE3À‹Ö3Éÿ;;Ãt‰5ž8ë2ÿ<D‹8ƒøxEDÔD‰8E;Ô„D;Ó„D;Öu'‹uh;óuH‹‹pE3ÉE3ÀA‹ÕA‹Îÿ·:LcàD;ãu3Àéç~g3ÒHBàI÷ôHƒørXKL$Hùw1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðè5)H+àH|$@H;ût±ÇÌÌëèGcþÿH‹øH;ÃtÇÝÝHƒÇëH‹ûH;ûtˆE‹ÌL‹ÇA‹ÕA‹Îÿ%:;Ãt8‹E`AƒÉÿ3ÒH‰\$8L‹Ç‹ÎH‰\$0;Ãu‰\$(H‰\$ ë	‰D$(L‰|$ ÿ;<‹ØHOð9ÝÝuè‹@HL$@L‹Î‰D$8‰\$0A¸H‰|$(‰\$ è™þÿÿ…Àu脨þÿÇéyÿÿÿƒÀþ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌHƒì(ƒ=quèfôÿÿëE3ÉèÌþÿÿHƒÄ(ÃÌÌÌH‰\$H‰t$H‰|$ ATAUAVHƒì0M‹áM‹èH‹òL‹ñè>VþÿHx0H‰|$X3ÀH…ö•À…Àu%èè§þÿÇHƒd$ E3ÉE3À3Ò3Éè1—þÿƒÈÿë9H‹ÏèWþÿH‹Ïèòþÿ‹ØM‹ÌM‹ÅH‹ÖH‹ÏAÿÖ‹ðH‹×‹ËèÂòþÿH‹ÏèqWþÿ‹ÆH‹\$PH‹t$`H‹|$hHƒÄ0A^A]A\ÃÌM‹ÈL‹ÂH‹ÑH
ôþÿé3ÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
$£ÿÿéÿÿÿÌÌÌM‹ÈL‹ÂH‹ÑH
”°ÿÿéÿÿÿÌÌÌL‹ÊH‹ÑH
¿óþÿE3ÀéëþÿÿÌÌÌL‹ÊH‹ÑH
ߢÿÿE3ÀéÓþÿÿÌÌÌL‹ÊH‹ÑH
O°ÿÿE3Àé»þÿÿÌÌÌHƒìHHƒd$0ƒd$(A¸H
 ¬E3ɺÀD‰D$ ÿ‘"H‰ÂHƒÄHÃÌHƒìHHƒd$0ƒd$(A¸H
p¬E3ɺ@D‰D$ ÿU"H‰ŽHƒÄHÃÌHƒì(H‹
}HƒùÿtHƒùþtÿK"H‹
\HƒùÿtHƒùþtÿ2"HƒÄ(ÃÌHƒì(AƒùÿA‹ÁM‹ÐD‹Ú}3ÀëL‹L$PD‹ÀI‹ÒA‹Ëÿ)!HƒÄ(ÃH‰\$H‰t$WHƒì@‹òH‹ÑHL$ A‹ÙI‹øèEþÿƒûÿ}3ÀëL‹L$pD‹ÃH‹×‹Îÿä €|$8tH‹L$0ƒ¡ÈýH‹\$PH‹t$XHƒÄ@_ÃÌH‹ÄH‰XH‰hH‰pH‰x ATAUAWHƒì H‹ê3ÿ3ÒDG‹ñè9ÂÿÿL‹èHƒøÿtPDG3Ò‹Îè#ÂÿÿHƒøÿt=H‹ÝH+ØH;ߎÁÿˆ!A¿WH‹ÈM‹Çÿ“!H‹èH;Çu1è¥þÿÇè¥þÿ‹H‹\$@H‹l$HH‹t$PH‹|$XHƒÄ A_A]A\ú€‹ÎèD‹àD‹ÃI;ßH‹ÕEMÇ‹ÎèK,ÿÿƒøÿtH˜H+ØH;ß~ëÛèÕ¤þÿƒ8u諤þÿÇ
HƒÏÿA‹Ô‹ÎèËÿÝ L‹ÅH‹È3Òÿç ëU}]E3ÀH‹Õ‹Îè>ÁÿÿHƒøÿ„Tÿÿÿ‹Îè5äþÿH‹Èÿ÷ØHÿH÷ßHÿÏHƒÿÿu%èB¤þÿÇ
èW¤þÿH‹Øÿ ‰Hƒÿÿ„ÿÿÿE3ÀI‹Õ‹ÎèáÀÿÿHƒøÿ„÷þÿÿ3Àé÷þÿÿH‰t$H‰|$ ‰L$ATAUAVHƒì0H‹úHcñƒþþuèü£þÿƒ Fé	…ɈÖ;5›4ƒÊL‹æL‹îIÁýL5˜4AƒäMkäXK‹îB¾L ƒáu0è°£þÿƒ 舣þÿ¿	‰8Hƒd$ E3ÉE3À3Ò3ÉèÐ’þÿ‹Çé3ÀH…Ò™À…Àu-èt£þÿƒ èL£þÿ¿‰8Hƒd$ E3ÉE3À3Ò3Éè”’þÿ‹Çëd‹Îè}ãþÿK‹îBöD tH‹×‹Îèrýÿÿ‹øëè£þÿ¿	‰8‹Îè÷ãþÿ‹Çë+è£þÿƒ èæ¢þÿ¿	‰8Hƒd$ E3ÉE3À3Ò3Éè.’þÿ‹ÇH‹t$XH‹|$hHƒÄ0A^A]A\ÃÌÌÌHƒì(HcÒè þÿÿ÷ØÀHƒÄ(ÃÌÌÌH‰\$H‰t$WHƒì HcÙA‹ø‹ò‹ËèNâþÿHƒøÿuèo¢þÿÇ	ƒÈÿëRD‹ÏE3À‹ÖH‹Èÿç‹øƒøÿuÿ*ë3À…Àt	‹Èèw¢þÿëÌH‹ËH‹ÃH3HÁøƒáH‹ÂHkÉX€dý‹ÇH‹\$0H‹t$8HƒÄ _ÃÌÌH‰\$H‰t$‰L$WATAUAVAWHƒì0E‹àD‹êHcÙƒûþuèò¡þÿ3ÿ‰8èÉ¡þÿÇ	ƒÈÿéÔ3ÿ;ߌ¡;ƒ2ƒ•H‹óL‹óIÁþL=€2ƒæHköXK‹÷¾L0ƒáu+èš¡þÿ‰8ès¡þÿÇ	H‰|$ E3ÉE3À3Ò3Éè½þÿƒÈÿëm‹Ëè¥áþÿK‹÷öD0tE‹ÄA‹Õ‹Ëèœþÿÿ‹øëè+¡þÿÇ	è@¡þÿ‰8ƒÏÿ‹Ëèâþÿ‹Çë)è+¡þÿ‰8è¡þÿÇ	H‰|$ E3ÉE3À3Ò3ÉèNþÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌÌH‰\$LcÁH©1M‹ÈAƒàIÁùMkÀXJ‹ËBŠD8F¶\ÀAã€D¾ÐAÑúú@tXú€tHút(út úuHB€L€J‹ËB€d8B€L8ë0B€L€J‹ËB€d8‚B€L8ëB€dëB€L€J‹ËB€d8€E…Ûu¸€ëA÷ÚÀ%À@H‹\$ÃÌÌHƒì8ù@t7ù€t/ùt'èÛŸþÿHƒd$ E3ÉE3À3Ò3ÉÇè$þÿ¸ë‡
#3ÀHƒÄ8ÃHƒì8H…Éu'螟þÿHƒd$ E3ÉE3À3Ò3ÉÇèçŽþÿ¸ë
‹æ‰3ÀHƒÄ8ÃÌH‰\$H‰t$ ‰L$WATAUHƒì0‹ÚHcùú@tHú€t@út8út0út(è#ŸþÿÇHƒd$ E3ÉE3À3Ò3ÉèlŽþÿƒÈÿéÕƒÿþuèöžþÿÇ	ƒÈÿ齅Ɉ’;=²/ƒ†H‹÷L‹çIÁüL-¯/ƒæHköXK‹Då¾Lƒáu%訞þÿÇ	Hƒd$ E3ÉE3À3Ò3ÉèñþÿƒÈÿë]‹ÏèÙÞþÿK‹DåöDt
‹Ó‹ÏèŸýÿÿ‹ØëèbžþÿÇ	ƒËÿ‹ÏèRßþÿ‹Ãë#èIžþÿÇ	Hƒd$ E3ÉE3À3Ò3Éè’þÿƒÈÿH‹\$`H‹t$hHƒÄ0A]A\_ÃÌÿ%lÿ%nÿ%pÿ%rÿ%tÿ%vÿ%xÿ%zÿ%|ÿ%~ÿ%€ÿ%‚ÿ%„ÿ%†ÿ%ˆÿ%Šÿ%Œÿ%Žÿ%ÿ%’ÿ%”ÿ%–ÿ%˜ÿ%šÿ%œÿ%žÿ% ÿ%¢ÿ%¤ÿ%¦ÿ%¨ÿ%ªÿ%¬ÿ%®ÿ%°ÿ%²ÿ%´ÿ%¶ÿ%¸ÿ%ºÿ%¼ÿ%¾ÿ%Àÿ%Âÿ%Äÿ%Vÿ%@ÿ%2ÿ%$ÿ%ÿ%pÿ%bÿ%Tÿ%Fÿ%8ÿ%*ÿ%ÿ%ÿ%ÿ%òÿ%äÿ%Öÿ%Èÿ%ºÿ%¬ÿ%žÿ%ÿ%‚ÿ%tÿ%fÿ%Xÿ%Jÿ%<ÿ%.ÿ% ÿ%ÿ%ÿ%ŽÌÌ@SHƒì0M‹Ñ‹Ù…Ét*;ÊtA;Èu!H‹D$xD‹L$pL‹D$hH‹T$`I‹ÊH‰D$ èã‰þÿ‹ÃHƒÄ0[ÃÌÌÌH‰\$WHƒì H‹Ù3ÿè„ÔþÿHHWèÔÒþÿL‹ØH…Àt4H‹ÈŠ„Àt&<"uHÿÃÿÇë	AˆIÿÃHÿÊ„Àuæ…ÿtAˆH‹ÁëèØ>þÿ3ÀH‹\$0HƒÄ _ÃÌÌÌH‹ÄH‰XH‰xL‰` AUAVAWHƒì0L‹âH‹ÙE3ÿL!xAOè­Øþÿ…Àu3Àé|L;¡3ÒHL$`èÿWÿÿ‹ø…ÀtƒøuL!|$ E3ÉE3À3Ò3Éè‰þÿ…ÿuH‹L$`H…Ét3Òèï…ÀuH‹\$`ë5H…Ût3ÒH‹ËèÕ…Àt"3ÒH
üèÃHðH
µ„…ÀHEÙM…ätI‹Ìè^ÓþÿL‹øH‹ËèSÓþÿBL8D‹ñºèQâÿÿH‹øH…À„«ÆL‹ÃI‹ÖH‹Èèìvÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèKˆþÿH‹ËèÓþÿLlÿº\A8Uu:H‹Ëè'L;èt_LWI‹ÖH‹Ïèœvÿÿ…ÀtIHƒd$ E3ÉE3À3Ò3Éèû‡þÿë2A€}/t+L#I‹ÖH‹Ïèhvÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèLJþÿM…ät'M‹ÄI‹ÖH‹ÏèþÿHƒÀ0H‹Ð¹è·@þÿHƒÄ0]Ã@UHƒì0H‹ê‹MPèhÑþÿHƒÄ0]Ã@UHƒì0H‹ê‹M`èQÑþÿHƒÄ0]Ã@UHƒì0H‹êH‹MHè@þÿHƒÄ0]Ã@UHƒì0H‹ê¹è4ÍþÿHƒÄ0]Ã@UHƒì H‹ê¹èÍþÿHƒÄ ]Ã@UHƒì@H‹êƒ}Dt7ƒ}Ht'HcU@H‹ÊH‹ÂHÁøLà ƒáHkÉXI‹À€dþë‹U@‹Êè»ÐþÿHƒÄ@]Ã@UHƒì@H‹êƒ}@t>ƒ}Dt*H‹•€Hc
H‹ÁHÁøLt ƒáHkÉXI‹À€dþëH‹•€‹
èhÐþÿHƒÄ@]Ã@UHƒì0H‹ê‹M`èQÐþÿHƒÄ0]Ã@UHƒì0H‹êH‹MXè?þÿHƒÄ0]Ã@UHƒì0H‹ê‹MPè"ÐþÿHƒÄ0]Ã@UHƒì0H‹ê‹M`èÐþÿHƒÄ0]Ã@UHƒì0H‹ê‹MPèôÏþÿHƒÄ0]Ã@UHƒì0H‹ê¹èïËþÿHƒÄ0]Ã@UHƒì H‹êHcM H‹ÁH‹ò!H‹Êèí>þÿHƒÄ ]ÃÌÌÌÌÌÌÌÌÌÌ@UHƒì H‹ê¹è¦ËþÿHƒÄ ]Ãf///v//T/B/2/î.Ú)È)Â.².¦.š.Š.z.h.Ð.F+T+d+t+€+’+¦+¶+Ê+Ú+ê+þ+,&,:,L,b,v,Ž,ª,ž5Œ58+h5\5L565&555ì4Ú4Ä4²4 44€4j4Z4@4&44ô3Ú3²3š3ˆ3&+++ü*ê*Ô*È*z5¶*¨*˜*€*r*d*N*>*(***x3f3V3>3®503ò/00$0<0V0t0„0’0ª0Â0Ô0æ0ô011101B1V1r11¤1¸1Ò1æ1ü12"2,282J2Z2j2v2„2’2œ2²2¾2Ô2â2ð2ü23–/è,Ü,²-P.B.,. ...ò-ä-Ò-À-Î,¢--‚-n-b-N-:-*-"---ô,Ä/²/Ø/ؤ@ @¼–@0¦@(P@Ô]@¼¥@
©IZ„ü„êCreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\Please wait while running postinstall script...-installIsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptnamemetadatatarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”Þñinvalid distance too far backinvalid distance codeinvalid literal/length code`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

incorrect length checkincorrect data checktoo many length or distance symbolsinvalid distances setinvalid literal/lengths setinvalid bit length repeatinvalid code lengths setheader crc mismatchinvalid block typeinvalid stored block lengthsincorrect header checkinvalid window sizeunknown header flags setunknown compression method inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScsƒ£ÃãÉÄ	
!1AaÁ 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionaryе@Àµ@8x@°µ@ µ@µ@xµ@hµ@Pµ@8x@€fàFðKуî É
ÈI*TÀðKуî É
ÈIÀT§TðKуî É
ÈIàOÐ ê:i¢Ø+00€S‡ Bi¢ê+00@ð_dPŸª/•N  ì!ê:i¢Ý+00€¢'"ê:i¢Þ+00º
E%­Ð˜¨6NKæïK®Âº}€ö`fU‡Ü­ƒH¢¿b»Ò0߬¦ôçâRF·§ì½#/xÀF‘ÀF’ÀF“ÀF”ÀF ÀF¡ÀFÐÀFÑÀFÒÀFÓÀFáÀFâÀFãÀFäÀFåÀFæÀFèÀFéÀFêÀFëÀFìÀFîÀFïÀFðÀFñÀFòÀFóÀFôÀFõÀFöÀF÷ÀFøÀFùÀFúÀFûÀFüÀFþÀFÀF¡΋!	±ÿÝÌH€žãˆx5Ï®i+.b ö`¬ÙЙËÀOÖD—¢Vö	¯AHˆ÷Ì
F¤Mä^2mãF†¼T
íÐàðd_˜ÔN¾"ÚòµÅáÑÎú
(èÑ‘‡µ2ñéW]Â/4*&{ÐŒ© É-¿èzeÒG'{ÐŒ© É-¿èpŠh}ÆЙ›ÀOÖUáBl‰ÅЙšÀOÖUá•3”(Ò9ÀOŽë> ãG ©òήe+.bµchÈЙœÀOÖUá4^ñ;ݧBª}/NÅK°›f’£NrŸ@¶"ö=½Å3ŒÈH$¹Ñ˜ÕÀO¶‡Ú àü¼ìРÉ'€þmyÏ•4À[®ðJ1ÒйB Éá&®M[¸Ð˜ÀOÙrÈèGÂй: Éá ·qíEÐ’J ¯Ç¬MàÐWs5Ï®i+.bÀs5Ï®i+.bà¥s5Ï®i+.bw~s5Ï®i+.bå%ñeá{HºÒqÈC,ã²ë‹ÐRзôÀO×ì$¦ïŽéÑ[D”·tûÎ.¡|ÞÃI)ÓЫsÀOÃ>€±â+ØdWЩnÀO×¢@;òûðㄈª>Vø€;òûðㄈª>Vø 
»ÊWÚÏ™t ¯×—b@J7<äºÏ¿}ªiFϦЙËÀOÖD—a'»wjÐ¥5ÀO×Ðb°0¡wý”Ð¥DÀO×Ðb AG†QÒ»¶`—{FL!m•‘v’Ñ’`—ß[Ôc'»wjÐ¥5ÀO×Ðbd'»wjÐ¥5ÀO×Ðbñ6À†¡Ð‚Jª[CƒA¦VgqÞЃª[Cƒe'»wjÐ¥5ÀO×Ðb“Û5iè!ÌL¾¹ŸãÇz)zR88øÓüѦ¹`—ß[Ô|¼ë^1Ò¶/`—ß[Ô@¾–L\‘ϙӪJè7@å‘°ãƒÏ§ ¯×—b‡uïИˆ`—Þ¬ùëô@јˆ`—Þ¬ùà.PR€ìЉ«ÀO—-âT'²tEјˆ`—Þ¬ùA`ÂtÑpÑ·Z Édþ¥lÄ?<Ò¾æøÊWý4p ªlTI¬?—¢rùŠPèBÒ¾, É¨=¡Oñ${уøaÏP‡¦“•Ñ”o0pû,•Ñ”o€iyŜѨ?ÀOÉa¸4‚¢Ò†ÅÀOŽê™Øµä,¢Ò†ÅÀOŽê™ ÇÌÏ‚¢Ñ‚`“‚RéWp½Ñ‰ÀOÂÈ6Œöò“Ó£ÀOy«Ñ¦jc(=•ÒµÖÀOÙÐ0ñ%·ïG¥ñ`Œžë¬¡¸51M–Ùl¿Ég™‹Í~6Á›J”N½fsÌÃ3K›ÿ@Ò¢~ÀOÃq!‹2)wüK•L+2V°4K›ÿ@Ò¢~ÀOÃq€T'ò‚÷‘B½”ñ6“Q:ì.7£VœÎÒŸ`—Ɔö䬮®‰E¹·»†z¾âí5K›ÿ@Ò¢~ÀOÃqiI~©+.Í©áp¶Ñ¡ÎÀO×]_e¸ÿ¹ÎO¸œšk§mçŠ'WFAÒƒšÀOÙлóP0µ˜Ï»‚ª½Î³óP0µ˜Ï»‚ª½Î´óP0µ˜Ï»‚ª½Îá‹MÒ…]`“gµáI6FÓ—÷ÀOEг]“šˆ—K¹$ßÉáåè¢ñþ^5N“›$×÷̈&HÇS™«3M¬¤1õ7ˆ£iÙÿçЩ; É'$â9YõÓŽ:ÀOh7Õ%â9YõÓŽ:ÀOh7Õ&â9YõÓŽ:ÀOh7Õ'â9YõÓŽ:ÀOh7Õ«³ë|šI¤’ÊÄ˃(â9YõÓŽ:ÀOh7Õã¤!FÖðsGŠœFç{H@¡FãÕS÷2I´Et€$˜¤á„#œC¤È«‘Rõ†
e.{ ŽJO°že—¯Ç/°ö”P($IªZÑ^„†€9Ÿ½À¸$í\EƒæÕ9OèÄ奄ñ‚`O’„O·\;éx‡Ð8WõFž¿ºTpjØ÷@ü­úw·iKªw^ðæèàÖ‡Åω© ÉA)!¿\_ÑЃª[Cƒ°â+ØdWЩnÀO×¢€ÿ4DLïήe+.bÀSmbŒÑ²Í`—ߌ Àœí¹Ñ˜#ÀOÙrìŽ'Œ«>ÑŒ°ÀOÙÐë¯çÑ.jÐŒxÀOÙ´ôº^QmÒƒ­ÀOÙÐd¦Ñ4 É'äô>áòÒИÀOÙr3ó€ß·Ò£;`—ß[Ôè»ÚM•ÓO°ôµ¹KúLb`w¤±GŠŽ:J˜'iÏ>ŒV–MYFDAtâÖ;&åO‘ÁF°¤íÔÛ}êÄîÒ¨\I®;¿% ›S|ƒÀ
ø»*E…
yÐŽf|§txŸMNI–{@°Ò>KëJ§‚´®\F Зî4mc-Nüv­ÖE¦c7½V…ø‹fCNÁ²I—Étw„ׄ·8A!Ó±J»©'ËÀÅ8šEûþK}4@¥¾¬°Vq’Cšš(D¾W@¤Xzv×çùF@S·Ë>L¾NdÍL·Ö¬+Ùo—.ÑEˆÿ°Ñ†¸ÞÝ·Œ"ý®ãJ†Ló‘
¸þ:Ì¿´,ÛLB°)隇ÆA» }¹jô—Lº^6CTw]§+.ÃD¦¢«¦JQÃS[bH«ÁNº¡ïAFüÀP®ÒëŠC†UŠ	.4˜zlƒ‰À'K@-ÜýtКÓý#¯F­´l…HiÇa÷w­hŠM‡½0·Yú3ÝS¿«Åá!A‰†boÂÉs½t’ÑÏÃA³^±?U§Xôè“2¦NfÛH yßuž	÷5ꥂÍÙÅG–)á]/qNnNÔ9þjòI†=¯Êæÿ¸W¤.ÖIª|çK‹ã°g
4ªÄòcH¯ïø~òæº%‚]«bÁýÃM©Ý
I]—ç7B¹¬WGC‘Q°Œl2Ñ÷¯$HíäܨEâüye64Û…¶>ùeöL :ãïerŸ=…'³ñºoÏOU{Žp‘¤¡ ¥€öO½sCůè$5¾3QBº…`ÊíÏ]v+éÀqAŽ¦¸Oö;ŠÜÙ„·.C§Z0§YcwNÁç]N·D.±®Q˜·°1RÖñ²WH¤Î¨çÆê}'ô‹óCòB“gÞ(ü#…l^"`Gšþê3¶qs0â3NvFƒZ˜9\;ûï@Z|û üK‡JÀòà¹úŽ$M—ÞÆÙ>M¿‘ôEQ ¹w“€mðjKD‰W£w? §Õec
åE‡ö
¥kjO}¶c^¿ÁNI²œe·2ÓÒíñ÷mŸ¢Gª®)ÓÆðfpñNr-¤ïOŸ&¶„oºO}N8Ðú—GË¢)³’µqÕØKmÓH¾—B" C›˜µ™[E„«|täÝü†ûë¶i!€ý¼OLˆ»'`g©ìp+Þ÷›“J½=$?xÔ’hü­K¬ÄG  M]ªk>+$Ì%|šQO€àz)(þ¾B›ÆÍâqåF–[ÍŸWª³Ã…¼m]rL§wìx,¹4ïK†§u@ºˆ+‰©ô׉#äG©``¼Âí“„µËW´é®G¡ Äß35ÞâãóÆíA„	A­ól ·ÞG؂تçíI†·æá÷Íþ‚Âï à`F“têˆQ<ü€ð÷Ëë[áM¼ƒEÄ€öªd_»ðµNŽM&uf4L—3l÷³¯×E¥ŸZIéC~Á½"ñ‚@Œ0(9ŸA8L"k1Ë÷%¸BŠ	T
#¤ÀF@ÀFDÀF[ÀFðÊ™^Aψªµiõ XשFÏ•üªh
´Mm8gÏ–ªh
´zÔó0GdÑŽ<ÀO¹8m®ö¼xˆÑƒéÀOÂÆÔ4ÈyˆÑƒéÀOÂÆÔ"ÀFFÀF’Mm8gÏ–ªh
´0ÀF1ÀF2ÀF3ÀF%ÀF)ÀF*ÀF0:s*έåªDw=IÀFè¹ë–yÒ‡.øY+ÀF&ÀFEÀFGÀFHÀFÊ:/Û†/ÑŽÀO¹˜šË:/Û†/ÑŽÀO¹˜šÌ:/Û†/ÑŽÀO¹˜šÍ:/Û†/ÑŽÀO¹˜šÎ:/Û†/ÑŽÀO¹˜šÏ:/Û†/ÑŽÀO¹˜šÇ–v\цø°WÞy”(ÌÒ ÷€_…±ÁÀFÀÀFÆÀFÕÀFÔÀFÎÀFU
8r+£C…+nó4é4ÀFâRX0eѶ£øu{ùÚ®šP9VѶ¡øu{ùðþ½ÏÏ£0ªÁne0ÕE
KvСʪÁne
y˜´âа±ÀOØܦÏ«|õxÒ–ÀO£†À¨´jÒ­IÀO£†ÐàQžnÒ–ÀO£†0îüŒ½9иѠ$«-»¸1.¦Ð¦Å É¯EÀ^¼ƒ*oСĪÁneÀÞP«oСĪÁne |Œ~|Б?ªÁne?Ç¦üàЗP É¯E^æ#ŠÂ1Љ $«-»á?îƒÙWй2 $«-»â?îƒÙWй2 $«-»pðwµâ~Б?ªÁneg­‡Ð‘@ªÁneñ˳ÁjˆÐ‘@ªÁneò˳ÁjˆÐ‘@ªÁneã?îƒÙWй2 $«-»~{ŒS^ÒЗB É¯Eyð¾|„ªKD¼phäƒê¼KΔӳѹ´ÀOØÕ°ž™rÀIúÑ ¯ÀO£†x…hиÀO×ìà{ËlhиÀO×ìðÙÃ\Ñ•¾`——êOßOðÎrþÒ‡¥ÀOh7Ïü¬y½)ÓŽ
ÀOh7ÕBÐTyI¼²6¾Eºˆú9ì¯øÅA„!8¾ÒFs°%çÍÉÌE‘~2]rú´Îg¤óO!˜BŽ°>9ù}˜Œ®—‡ÓN¾r*GÝ“°¥ùkF³ðNª]Í·gh±hÏ“ægÙA‡c™*î^Z¡%­È”2îAeqKÐW»'ìØ;?B@±
JÏÙ$ÔSõQ¦À‹´Òµí`—Ɔö†(ÂœŽÜÒ±ÐÀOŽë>’ƒÛñ1sÐŒ™ É-¿èªO(hHjÐŒxÀOÙ´…ÀiQÍD”¯(ߥlù+ ‹rˆ÷Î’­ª§LÐm‚CçîB¼U¡âaÃ{þÓ°Ÿ~Ÿ‘C«.›`1“y‹Á¼º/D€ÄŠYÃF;3bpcã(J¥g
·€æ×ØДէ{E³´Î]º¬ˆ°­é½ÆEŽ)П“SáãØ-<¨©M£0G$4[¡¾“Vÿà,HMµÅ@}͹2Ý­H¥<$A«ãµ§%1²efþÊà¹I¡x+\´’¥ÚýhŠÜ LŒëAfCµ¦%§ñ°”¼D–áB–£Râm§>¶…oE¡œHžú…‹?¾syûYz(©º—º“X‡G§áA'qQU”‚AÿJ€ú
sêÌY!ëW«O«Zåú{ê*lñ×ðg²(M‹â2¥Ä(¼ÿ ‚TfC¾'>çŽÂ|a.» 	ÑšÀOÂÖÁî±;•´“ј£ÀO¶‡Ú.K[ãÚÁKŸ8¼õÔ…¶¤³…¶H™Ù]êÒ‡26 Ù-&{ÐŒ© É-¿èráë:Љ³ É
¬ü%äwùËCºj»W'tVaämÑyî«!@‘i²aÖWBóýVmýЕŠ`—É •I-`:±›B¦n5äOCÚšÑL¥%2J³·4{î[ãkY¦s=ÐåBM¯ÀQ!ºB\[–ˆ/B{N€sASÃÖ¦.À̆I›#t9JD¨f?kјÀH¢"ûÞtâûÅ»˜‘ªìÌ-G¾í¤ös?z¥ZÕA°žže¬!`[ǽ6îæN¾XXâ$µ¶ÓßÁéK…ö¦iiôöÅ‘£•Ôž(L„«žqžm®å–ájKÆHªˆ(.~,-Y@ƒo‚3\.Q¸ŸÉåëC£pðg{‡L\l%µùæI»·£ÂTÀŸß¿°õµŒK”Ižs<_«z”\
L´ÖK÷ƒoÉø(t¦ã;sM³|¥@¿ø•)Ù^ÏvJ¿YêÓž¢¹~+IÇzŽÃŠC‡ÛhsxDÿp§ØÎWJ?,C“P0òDƒ÷OôAÑoËZ\ÊÜq"ütD·Åk¬â×¾®‡TLžrTŒöIkE
àaÿ`N’Ne7¶Ý6ò‹Œì_I˜”‘Õ|k’H¢rYøˆšM>sáë:Љ³ É
¬ë¯çÑ.jÐŒxÀOÙ´ðË¡d:aD‘X7iii9PÛ5—}+E‰ut¨X(ÓT6QøB~ÛœC…ñä]_È#ͼ„Þ_ÛL®¤¯d¸=x«ˆr|Õ­ÔhG¾–•2Ù`Òýæ?uIœŒ¦Ÿ£p4Bf6×—K›ƒt„©Ð3
SNæwL£¬1Ð"(i¡v”ù¬@È	Yè‡G€ºØ­+ÐÀO×ÐbÈCß¾Ó‹4`—ß[Ô„L¼Òr?RJ¦{Ëó˜,»AÛs…EŽO¨ŒW¡£L›Ñ‹"ÀOÙÐ7vî8áуyÀOÙÐà½äühK€KŽœt&1Zsˆ~¯§:6›B¨ã÷}Ft¤ˆrØ⋪†GM·v2̤pŠDÍ´†œfD’.b[‡®€Gåvt­ãH¦•;© ¯ñ
zæ<§±ŠñDCÒü¿kÐÊ?}ùÖHƒ2”lwâGtq
$SÖJ¦ÓÔ”<ûþ=Õ•òwo-N¸®2/>rµ\Úí£˜GŠÛÅçÚ™±—YýÆkŸˆH‡”èŒÞ?x‡Š§9Jª³£›œ4§Ùu´Y&¸î·H³xHÏ£‚'¶éGˆVÁBeUNO…yדس„Dƒg,Ý ÎÖeÆùòÂL¿3ƒ"×5/QÞóqíCA„wéSk‚5X§;-î3ÕB»{_41ØlxƱ•ˆ´L¥b
VBPƒo¯zÈþù5zD­· #D‘@Fègmœ[¸Mœ¼Ýá/BTñ|\¹ŽÔ?@«™ÖÇz„¬ìpà¼ÀD—°FÇÉ[žÜ0é	49Zуú É
ÈI}ÑÞA³ÖaB™}ˆÆKXÐ䌠%ú«Dµ|DZÃ#à¹ø&ˆ¨o‡IªÞêï¿èQ–d5ÀCþÕv†Sdn0@Dš×ÐHˆæ¤&’'›û®ûÒÖñŒEŒ4V˜w¢Ò˜n¨B*O—øŠôà&Ù-bØÑÞfôM¿lV!™jñt§¨Â€àIˆ…$ëÄ[a½#FVOD‚JªëÎí“ú’
ö
hÖF³XÖapÝäf_Ï:ÛqúJð?Äýò¥¸±é§PïpÑ·Z ÉdþÀF K6ó¹eΩºªJè7`, ê:i¢×+00ÀFh3©ÝM¸nÚãMÜ™ŠS{5”)ÊxKƒ®èþt	OÏó¨°3C«KˆsË­¤‹“w`µ¬$ÇD‚âƒ&ªl·´;ýÝ0M£HŸµÖ¿þR¸×UÑöòBªu‡(¡²ÒdÆT&©àaërr†C‘uòäÆ‹.|uUÐ:WˆPH’w¸[ÛŽ	œZÜŠèÞM¥¡`ø* ®÷óâ´À!ºsGº3^ÉFë‹0ÇðMßãJ‘Sªk‚éyZ
8—Ñy
ÈM 3íˆ,/¡KáqóI\ŒœMš;T¦‚QI·!ÍøË[Y
,ð!¾PCˆ°sgü–ï<«Œ!’ªì5C3€Ò4Âî¬a@ðY?J©TwZ¥Àƒ®8—™•ˆKžMn錕RÚHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSuna/pam/pmCorExitProcessmscoree.dll`a@b@TZSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecLC_TIMELC_NUMERICLC_MONETARYLC_CTYPELC_COLLATELC_ALLLß@H	@@ß@`O@¼Ò@0ß@`O@„´@ ß@`O@üÎ@ß@`O@Ì@ß@`O@üÊ@	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;runtime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODEÀÀ–ÀÀŽÀÀÀ‘À’À“ÀSystemFunction036ADVAPI32.DLL         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿunited-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamerican¸õ@ENU õ@ENUˆõ@ENUxõ@ENApõ@NLB`õ@ENC\õ@ZHHXõ@ZHIPõ@CHS8õ@ZHH õ@CHSõ@ZHIðô@CHTàô@NLBÈô@ENU¸ô@ENA¨ô@ENL˜ô@ENC€ô@ENBpô@ENI`ô@ENJPô@ENZ8ô@ENSô@ENTô@ENGøó@ENUèó@ENUØó@FRBÈó@FRC°ó@FRL ó@FRSó@DEAxó@DEC`ó@DELPó@DES@ó@ENI0ó@ITS ó@NORó@NORðò@NONØò@PTBÀò@ESS°ò@ESB ò@ESLˆò@ESOpò@ESCPò@ESD@ò@ESF(ò@ESEò@ESGøñ@ESHèñ@ESMØñ@ESNÀñ@ESI°ñ@ESA˜ñ@ESZˆñ@ESRpñ@ESU`ñ@ESYHñ@ESV8ñ@SVF,ñ@DES(ñ@ENG$ñ@ENU ñ@ENUñ@USAñ@GBRñ@CHNñ@CZEøð@GBRèð@GBRàð@NLDÐð@HKGÀð@NZL¼ð@NZL°ð@CHN ð@CHNð@PRIˆð@SVKxð@ZAFhð@KORXð@ZAFHð@KOR0ð@TTO(ñ@GBR ð@GBRð@USA$ñ@USA6-0OCPACPNorwegian-NynorskGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLL€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwppCONIN$CONOUT$TMPRSDSX‹J¾\úI„‰ ™‡ORo:\src\python-3-trunk\lib\distutils\command\wininst-9.0-amd64.pdbdT42p
dT4’ÐÀpT4òp)4=4ðàÐ
Àp`P¸T42p20

4
2pd
T	4Rp
4,
*p¸@	X0¸°‚
4Y
Vp¸ 
42ðàÐ
Àp`P9
%+t$d4#ò
ðàÐÀP¸xdT4’ðàÐÀptd
T	42àÐÀ+T$4#àÐÀp`¸Ð
4
Œp¸P*‡p`¸ d
T4
rp

4
Rp$	,à	ÐÀp`P0¸PÂp`P0¸À0	td4À¸°

4

rp!0¸0'	T342,Àp`¸P

4	
Rp204"t1"d0"T/"*ðàи@(	dX4WRà
Àp¸€+¸@$d241.p¸`B¸¸À¸°	b0¸dT
4RpdT
4Rp2020d4
rp7
%d%T%4%ðàÐÀp¸P'	T9482Àp`¸€td
T	42àÐÀBB&Àp`P0¸0		"0/	dT4
p¸0bt4t
d4tdT4Bd'4&$pB	b
ðà	ÐÀp`P0

4
2pdT42p	¢ðàÐ
Àp`P020dT42pd42p
d
T	42ÐÀp)4ðàÐ
Àp`P¸20B		R04rpd42p2020tdT4’àÐÀbbbb

2020d42p4Rà
Ðp`P2P20ô0ÌØ€`RPd	4Rpô0<žRž™`rP	ð
àÐ	Àp`0ô0mŸf¢²`RPbÀp`0ô0D£¤Ì`BBBBB20B2020BBÂp0		b

4
²pbdT4²pbbbb

4
RpRP4	Rpô0—¬¡¬ä`dT4RðàÐÀpRPt
d	4RÀô0¼®Ð®ü`B
tdT
4’À
dT4’ÐÀp
4’ðàÐ
Àp`P

t4t
dT4
RàÐÀ-
Etd4CÒ
ðàÐÀP¸`
T4ÒàÐÀp`bbbRPt
d4rÀô0AÆcÆahÆ|ÆaR0²0Bb		bbbb		bBBBBr0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r020r020!°ÔÇÔŒ!ä

d	4°ÔÇÔŒT2ÐÀp!pÕ×ÕÌ!  Ô‚tŠd‰4ˆpÕ×Õ̃ðàÀPd42pRPrÐÀp`0ô0ÚÛ,a

4
2p20202042p

4
2pbb

4
2p2P
d4rðàÐÀpô0·ÞÀßGa20202P	d4pô0>áJáëâ+âÍâiaÍâB		¼0

4
2pbd
T	4Rpbb202020rP’ðà
ÐÀp`0ô01çê…aT4RÀp`
dT4²ÐÀp2PBô0ñ(ñža2PBô0GñMñ·a2P20ô0pñzñÐat
d	4RÐd42pbbb
td
T	4RÐBB2020R020R0d	4Rp20d42pdT42p$d´4³°p¸p2P

4
2pô0Rý«ýéar04rÐ
Àp`P¸8‚2P
Ät
d	4RÐô0ËbBd42p

20202P20ô0ßõbR02P2P2
0ô014bLsTb2P2P

4
2pô0			mb	&	bbp`P0
td
T	4RÀd	4Rp
4RðàÐ
Àp`P&

ðà	ÐÀp`P0¸à)4MBðàÐ
Àp`P¸$	à	ÐÀp`P0¸À
t	dT42ÀRPRPRP
Ät
drðàÐô0Ðû¦bc#Æbª=æbB2P2P

4
2pô0"-cBi c

4
2p202P2P42pô0Æô9c	@Yc2020dT²pBBBÔt
4RàB

4
2p20dT42pd42p
4rðàÐÀp`Pd42pd42p
4RðàÐÀp`
PR020dT42p
t	dT42À
t	dT42À
d
T	42ÐÀpd
4’p  d T 4 rðàÐÀptd42ÀdT42pB2Ptd42Ðô0c4£4rc

4
2pdT42pT42pb2P
Ä	td42Ðô077W7Žc2P2P
Ät
4rðàÐô0Y88§c8±9ÇcBpPtd
4RÀô0j:±:àc
T4²àÐÀ
p`	 
 Ä t d 4 ðàÐô0¬=¸=T@

4
2pt42À		2020dT42pdT42p)4dZðàÐ
Àp`P¸ÈbRP
t
d4
RàÐÀô0ðN»O)dbbbbbb2Pd	4RÀô0ÓPKQAdd42p202P2P
Ätd
RðàÐô0RÕRZdVRòRŠd2P42pô0DSNS£dd	T42pd42p20BBd42p)4ZPðàÐ
Àp`P¸pd42p20BBd42p+4ZPðàÐÀ
p	`P¸p

4
2pRPd
4RÐÀpô0o}”}»d20/4qfðàÐ
Àp`P¸ RP
d4
RðàÐÀpô0(†Y†Òdr0r020202020d
4’pb
T4RðÐÀp`2Pd	4Rpô0Š¸Žéd›²0ÂdT4²pbbR0b
td
T	4RÀbbbd	4Rp
d
T	42ÐÀp202P
t
d	42àÐÀô0"—ã—eB

4
2p

4
2p

4
2p2P	Bô0W™Š™ eŠ™	Bô0©™­™­™B	Bô0í™ñ™ñ™BdT42pB2Pd42pô0œÐœAeBBRPtd4
rÀô0ÇžÒŸWeRP
d4rðàÐ
Àpô0¸¡K¢med
T	4Rp%	ð
àÐÀp`P¸°2P	bô0¸¥Ç¥‰eÇ¥BB

4
2pd
T	4Rptd
T	42àÐÀd4
Rp
t
dT4
rÀ

4
2pR0d42pd
T	4Rpd
T	4RpRPR0ô0ý±²«eRPt
d	4RÀô0H²,³ÄeRPt
d	4RÀô0y³a´Ýe1
dT4ðàÐÀp¸ˆBBBBB-
Etd4C²
ðàÐÀP¸Xd4Òp1
5#td43rðà
ÐÀP¸8d4²pB
t
dT4
rÀ2
0T42p

20dT4rðàÐÀp2
0tdT
4ràÐÀBR0b¸ td
T	42àÐÀ20
4

Rp¸($d4p¸ !4p`P¸ $T4p¸ 
4
p¸ 202020
td
T	4RÀb¸ 
T4ràÐÀp`bdT4²pR0d	4Rp

4
RpT
4	Rp
td
T	4RÀdT42pdT4²pd	4RpT4rp

4
Rpd	4RpbRPbp0ô0íCíöeBBBBB4²p
`Pbd
4’pd	4Rp20dT42pdT42p)4dZðàÐ
Àp`P¸È

t420dT42pdT42p)4”ŠðàÐ
Àp`P¸HRP4R
Àp
`ô0ß#f

4
2pRP
d4
RðàÐÀpô0®á2f20

4
RpRP4Rpô0îúIfdT
4’p¸PRPd4rpô0þ0af2P20ô0`kzf

²0

r0

T
ÒpB!
!4!òðàÐÀp`PrP¢p`ô0Ó%&“frP

d
’pô0+'O'ßfr0bdT
4’pdT
4’p	¢ðàÐÀ
p`P
0RP
d4
RðàÐÀpô0è342gbµd4
rp-
Etd4C’
ðàÐÀP¸@d
4’pd4
rp

4

rptdT4’àÐÀbbbb20b¸('EC
ðà	ÐÀp`0P¸pdT
4’pbd	4Rpbbbd	4Rpbb
td
T	4RÀdT
4’p$
53Â
ðà	ÐÀp`0P¸Xd4²pd4²pBRP
t
d4
RàÐÀô0ÕNûNIg‚‚BBd4
rptd
T	42ðÐÀRPt
dRàÐÀô0pS–SagBd42pRP
d4
RðàÐÀpô0HUyUxg4bbRPd
4RÐÀpô0X;XgR0

4
2pRP
Ä
t4
RðàÐô0ì\œ]¦g2P2Pt	dRÀô0 ^J^¿gï]]^ïgd
4’pR0B°$ö)Pp%À,°pÐ(\.ptÈ$ä.hp`$ˆ/pÀ(¦/`t¨)è/Huf///v//T/B/2/î.Ú)È)Â.².¦.š.Š.z.h.Ð.F+T+d+t+€+’+¦+¶+Ê+Ú+ê+þ+,&,:,L,b,v,Ž,ª,ž5Œ58+h5\5L565&555ì4Ú4Ä4²4 44€4j4Z4@4&44ô3Ú3²3š3ˆ3&+++ü*ê*Ô*È*z5¶*¨*˜*€*r*d*N*>*(***x3f3V3>3®503ò/00$0<0V0t0„0’0ª0Â0Ô0æ0ô011101B1V1r11¤1¸1Ò1æ1ü12"2,282J2Z2j2v2„2’2œ2²2¾2Ô2â2ð2ü23–/è,Ü,²-P.B.,. ...ò-ä-Ò-À-Î,¢--‚-n-b-N-:-*-"---ô,Ä/²/Ø/„PropertySheetACreatePropertySheetPageACOMCTL32.dlløSetLastErrornCreateDirectoryAËGetFileAttributesA	MapViewOfFile{CreateFileMappingADCloseHandleðSetFileTimeÒDosDateTimeToFileTimeçGetLastErrorzCreateFileAOUnmapViewOfFileÇlstrlenAMultiByteToWideChar"GetProcAddressðLoadLibraryAÂDeleteFileAhReadFileìSetFilePointerÖGetFileSizeNFreeLibrary
SetStdHandle>GetStdHandleüLocalFreeIFormatMessageA\GetTempFileNameA^GetTempPathA÷GetModuleHandleAzGetVersionExAResumeThreadSetPriorityClass«GetCurrentProcess®GetCurrentThreadSetThreadPriority–CreateProcessAõGetModuleFileNameA}RemoveDirectoryAGetPrivateProfileIntAGetPrivateProfileStringAöGetModuleFileNameWKERNEL32.dllüMessageBoxA&GetFocuswsprintfA|SetDlgItemTextAbSendMessageAPReleaseDCGetDCPeekMessageA¨DispatchMessageAÝTranslateMessageÕEndPaintqGetSystemMetricsBeginPaint•DefWindowProcAñUpdateWindowÀShowWindowgCreateWindowExA7RegisterClassAÖLoadCursorA	MoveWindowŒGetWindowRect"PostMessageAWGetParent]SendDlgItemMessageA!GetDlgItemvSetCursorUSER32.dll4CreateDIBitmapÐDeleteObjectSetTextColorŸTextOutAfSetBkMode^SelectObject:CreateFontARCreateSolidBrushGDI32.dllfRegQueryValueAHRegEnumKeyExA*RegCloseKeygRegQueryValueExAZRegOpenKeyExAwRegSetValueExA2RegCreateKeyExA7RegDeleteKeyAARegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dlloCoUninitializeCoCreateInstanceACoInitializeole32.dllSGetSystemTimeAsFileTime¦HeapFree¢HeapAllocFileTimeToSystemTimeFileTimeToLocalFileTimeÒGetFileInformationByHandle=PeekNamedPipeÙGetFileTypeÛEnterCriticalSectionîLeaveCriticalSection°GetDateFormatAlGetTimeFormatA©HeapReAllocúGetModuleHandleW/SleepExitProcessqGetCommandLineA<GetStartupInfoA;TerminateProcessLUnhandledExceptionFilter#SetUnhandledExceptionFilterÐIsDebuggerPresentŸRtlVirtualUnwind˜RtlLookupFunctionEntry‘RtlCaptureContextˆWideCharToMultiByteoGetTimeZoneInformation]GetCPInfoTGetACPGetOEMCPÚIsValidCodePage×EncodePointer¹DecodePointer@TlsAlloc@FlsGetValueAFlsSetValue?FlsFree¯GetCurrentThreadId>FlsAllocªHeapSetInformation¤HeapCreate¥HeapDestroy›WriteFileÝSetEnvironmentVariableAÞSetEnvironmentVariableWžRtlUnwindExÀDeleteCriticalSection
FatalAppExitAôSetHandleCount…GetConsoleCP—GetConsoleMode´SetConsoleCtrlHandlerºInitializeCriticalSectionAndSpinCountLFreeEnvironmentStringsAÁGetEnvironmentStringsMFreeEnvironmentStringsWÃGetEnvironmentStringsWSQueryPerformanceCounterjGetTickCount¬GetCurrentProcessIdàLCMapStringAâLCMapStringW@GetStringTypeACGetStringTypeWrGetUserDefaultLCIDéGetLocaleInfoAúEnumSystemLocalesAÜIsValidLocaleCFlushFileBuffersWriteConsoleA›GetConsoleOutputCPšWriteConsoleW«HeapSizeëGetLocaleInfoWVCompareStringWSCompareStringAÚSetEndOfFile&GetProcessHeapÿÿÿÿÿÿÿÿSoftware\Microsoft\Windows\CurrentVersion\Uninstall@x@8x@0x@8x@(x@8x@ x@x@x@8x@@x@ðw@0x@ðw@(x@8x@ x@x@x@8x@Øw@Èw@¸w@˜w@€w@hw@Xw@@w@0w@ w@w@ @øv@`@èv@¼@Øv@°N@Àv@ôN@°v@X@Software\Microsoft\Windows\CurrentVersion\Uninstall2¢ß-™+Í] ÒfÔÿÿà‰@à‰@xÞ@tÞ@pÞ@lÞ@hÞ@dÞ@`Þ@XÞ@PÞ@HÞ@8Þ@(Þ@Þ@Þ@Þ@Þ@Þ@Þ@üÝ@øÝ@ôÝ@ðÝ@ìÝ@èÝ@äÝ@àÝ@ØÝ@ÈÝ@¼Ý@´Ý@üÝ@¬Ý@¤Ý@œÝ@Ý@ˆÝ@xÝ@hÝ@`Ý@\Ý@PÝ@8Ý@(Ý@	pF@ à@ÿÿÿÿÿÿÿÿ€pðñÿÿPSTPDT H@`H@
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ J@¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þë@þÿÿÿC`O@`O@`O@`O@`O@ V@é@í@ï@pF@pO@pO@ J@ÿÿÿÿèå@¸å@	ˆå@
ðä@¸ä@ˆä@`ä@0ä@øã@Ðã@˜ã@`ã@8ã@ã@°â@ xâ@!€á@"àà@xÈà@y¸à@z¨à@ü à@ÿà@ÿÿÿÿÿÿÿÿ€
æ@€æ@°4@°4@°4@°4@°4@°4@°4@°4@°4@°4@ 
ÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Mlé@ë@.V@Än@Än@Än@Än@Än@Än@Än@Än@Än@ V@.þÿÿÿÿÿÿÿþÿÿÿÿÿÿÿðýðäýäö,ýøv<ýˆ1`ý4jpý€ÂxýÄ]„ý`Ÿ˜ý X°ýX¼ÄýÌÌý§ äý¨ `#üý`#%$þ %&@þ&(\þ(ñ(€þô(š*˜þœ*c+¬þd+×+ÀþØ+q-Ìþt-´-ìþ´-'/ôþ(/·0ÿ¸0;1,ÿ<1M28ÿP2Y4Lÿ\4²4lÿ´45xÿD5´9€ÿ´9Ï=¤ÿÐ=Z>Äÿ\>µ@Ôÿ¸@õ@ðÿø@ˆAøÿˆAíAðA€B BFD(HDUE<XEiFPlF¢Fd¤FÚFlÜFîGtðGIL„LL©M¬¬M°NÌ°NòNèôN6Oð8O¬Rø¬R?T@TBW DWOX@PX'[H([Â[PÌ[Ù^XÜ^mbhˆb¼b|¼b‘c„”c«c˜¬c
h Àh¥i¸àiÐjÄÐjÈØÈ€ð€ø€øtc‚Œ‚„„¤ˆ4T·X¸Õ`À‘õ‘hø‘'•p(•q•|t•Ñ•ŒÔ•}–”˜–™œ™L™¸L™n™Àp™£™È¤™É™ÐÌ™	šØš\šà\š›è›¶ø¸êìnž<pž­¢l°¢%¤¤(¤E¤ÌH¤e¤Ôh¤Œ¤ÜŒ¤©¤ä¬¤Ð¤ìؤº¥ô¼¥ã¥üä¥C¦D¦q¦t¦Ê¦̦󦧰§0°§Í§<l©ªD ª6ªP8ªÛªXܪ«l«E«tH«}«|€«±«„´«=¬Œ@¬¶¬ ¸¬R®ÄT®õ®è¯'¯(¯b°l°°±4¸±®µL@¶·d·v½px½ûÂŒüÂÅ´Å*ÅÌ,ÅFÅÔHÅfÅÜhÅÆì¬ÆÇ(Ç©Ç0¬ÇÉÇ8ÌÇðÇ@ðÇ
ÈHÈ2ÈP4ÈUÈXXÈ|È`|È™ÈhœÈÁÈpÄÈéÈxìÈ
É€É1Ɉ4ɚɜÉʘ ʃʠ„Ê˨ËgË°hËæ˸èËKÌÀLÌÊÌÈÌÌ2ÍÐ4Í·ÍظÍÎàΚÎèœÎÿÎðÏ~Ïø€ÏæÏèÏkÐlÐÒÐÔÐWÑXÑ¾Ñ ÀÑCÒ(DÒ§Ò0¨Ò&Ó8<Ó±Ó@´ÓÙÓHÜÓQÔPTÔ|ÔX°ÔÇÔŒÇÔlÕplÕnÕ`pÕ×ÕÌ×ÕbجbØqØœtØGÙÜHÙ(ÛôøÛ9Ü<ÜiÜ(lÜ¥Ü0¨Ü¾Ü8ØÜÝ@ÝEÝLHÝŽÝXÝÖÝ`Ø݇ÞhˆÞà|Là³à¬´ààà´,áãÄãã	ãfä	pä•å	˜åÑå	àåøå(	øå}æ0	€æžæD	 æ¸æL	¸æÍæT	Ðæåæ\	èæýæd	çžët	 ëXî 	Xîùð´	üð7ñÔ	8ñ\ñü	\ñŒñ$
ŒñXôD
Xô¡ôX
¤ôãôh
äô#õp
$õcõx
dõ,ö€
”ö´ö˜
´öÔö 
Ôö÷¨
÷V÷°
X÷ ÷¸
 ÷Ú÷À
Ü÷$øÈ
$øÓùÐ
Ôùúà
úeúè
œú.ûø
0ûýýÐý0Ðý`þT`þ×\Ø(x( ˆ H¸XÒÀGÐHŸØ è‘ð—  >	`L	°	”°	¤­¼°–
Ì˜
ØäØß
à(
;H
Dax
¤ÉÈ
Ì~à
€( (]8`žl°1t4=|@lŒl¸”¸Öœà ¤4 w ¸€ Í Àä !Ì!¨!Ô¨!("è("£'øÀ'C(D(Ä( Ä(t,0t,å,Hè,-P -Œ-XŒ-.l.•.„˜. /œô/ê0´ô0•2Ę2"3à$3§3ôÀ3Ý3à3È4È45D5»5P¼5h6dh6ì6tì6’7„¼7Ø9ÄØ9Ð:Ð:Š=<Œ=y@T|@ç@Œè@¹A˜¼AñA¨ôA;B° >=>˜ @>>  „>×>¨ Ø>]A¸ ¨A¹BÜ ¼BCð CDø DCD!DDfD!hD{D!|D‚E !„E§E0!¨E»E8!àE²F@!´F¦GX!ÄGžLl! L)MŒ!,MANœ!DNeN¬!hNO¼!°OëOì!ìO'Pô!(PcPü!dP”P"”P÷P"øPR"RáS@"äSùSl"üS’Tt"”TÅUŒ"ÈU–V¼"˜VèVÄ"èV'WÌ"(W}XÜ"TZ•Z#˜Z[#[Ô]$#Ô]z^d#|^i_œ#t_`¬#``´#0`~`(€`™`™`²`4²`Ì`dÌ`ä`œä`ü`˜ü`aàa,aä,aGaìGaiatia…a¼…ažal	ža·aÌ	·aÐaô	Ðaéa
éab(bb€b4bà4bMbTbmbmb†bXb¦bP¦b¿bp
Æbßbh
æbc`
ccØ
 c9cÐ
9cRc0Ycrc(rcŽcŽc§c|§cÀc¼Çcàc´àc)d)dAdAdZdtZd€dÄŠd£d¼£d»d»dÒdÒdédpédeeeä eAeHAeWeÜWememe‰eP‰e«e¼«eÄe¤ÄeÝeÌÝeöeöefdf2f¤2fIfàIfaf,afzf|zf“f¬“fßfßf2g<2gIg¸Igag´!agxg8"xgg„"g¦gÔ"¦g¿g#¿gåg\#ïghT#(€@€p€nˆ€k €l¸€mЀn耀	(	8	H	X	hxÁ
ä€Ë ä Íä$ÏZä€Ñä”ÒZä(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnPAÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/command/wininst-9.0.exe0000644000175100001710000057700000000000000024131 0ustar00runnerdockerMZÿÿ¸@躴	Í!¸LÍ!This program cannot be run in DOS mode.

$6Bœry,Ïry,Ïry,ÏÏ6ºÏuy,Ïl+¨ÏTy,Ïl+¹Ïdy,ÏU¿AÏqy,ÏU¿WÏ}y,Ïry-ÏÖy,Ïl+¯Ïÿy,Ïl+¸Ïsy,Ïl+½Ïsy,ÏRichry,ÏPELÿ¨Ià	6ľ¸P@`Ïŀݠ@ððR°Ó@P¬.text¯56 `.rdata*œPž:@@.data¤JðØ@À.rsrcð@ê@@…ÀtŠ„Ét€ù/uÆ\@uïÃV‹t$…ö„‚U‹l$W‹|$S€>toj\VèUb‹ðYY…öt_WÆÿTQB‹Øƒûÿu'jWÿXQB…Àu…ítWhSBjÿÕƒÄëWjÿÕYYöÃuh·ÿ\QB…ít
WhSBjÿÕƒÄÆ\FuŒ[_]3À@^ÃU‹ìƒìSVW‹=8QB3ö»À9uuÇEVh€ÿuVVSÿuÿ׉Eüƒøÿ…‡ÿPK…:¿SƒÀ.‰M ¿K Ê¿SпFC*Ñ¿NÈ‹EˆÏD‹Ì‰E€E¸‰U„+ÁŠˆA„ÒuöE¸PŠ@„Éuù+ÂM¸I€<\‰MŒt}¸OŠGG„Àuø¾¬SBf¥‹u¤‹}˜E¸Pÿ,QBƒe¬D¸‰E‹E¨ë5‹‹ÁP‰UœŠ@„Òuù+EœPÿu Qè؃Ä…À‹E¨„¿ÿE¬‹M¬ȃ8uÆ¿FPÿu E¸PèÈbƒÄE¸è}ûÿÿE¸PŠ@„Éuù‹MŒ+€<\tGÿu´·CP·CPÿsE¸ÿuPjèñûÿÿƒÄ…Àt"ÿu´¿NÿsÿsQÿu€Pè9ýÿÿƒÄ…À„êƒ}´t‹E°@P‹E”¿@
PÿujÿU´ƒÄ‹E”¿@
ÿE°9E°ŒVþÿÿé6þÿÿ‹M¬4È‹xŠ@„Éuù‹N+Ç‹ñŠA„Òuù+Î}¸‹ÑOŠOG„Éuø‹ÊÁéó¥‹Êƒáó¤‹M ȉMœ‹M¤¿I+ÈE¸pŠ@„Òuù‹}Œ+Æ€<\t(u¸VŠF„Àuù+ò€<7/t}¸OŠGG„Àuø¾¬SBf¥‹uœŠ<\tPÿuìÿQB‹EäÆVˆ8è†ôÿÿVè\]Yë
h¼XBèsôÿÿYÿuìÿHQBÿuÜÿQB‹Eà‹Mp_^3Í[èqVƒÅtÉÃU‹ìì¡€ñB3ʼnEü3ÀV¾9Et=PPøûÿÿQVÿuPhÿhPBVÿµøûÿÿ…üûÿÿPè‹iƒÄÿµøûÿÿÿdPB눅üûÿÿ…üûÿÿPÿ,QB+ðW„üûÿÿVPè‚hƒÄjh,YB…üûÿÿPÿ5€%CÿdRB‹Mü3Í3À^èÁUÉÃU‹ìì¡€ñB3ʼnEüVWEPÿu…üûÿÿhPè
k‹EƒÄH„äHH„ŽHtnHtWHtH…æ¡()C…À„‹ÿuhpYBëx·E‹5RB‹}ÁàPjhÿ5(CÿÖÿuWhÿ5(CÿÖé™ÿ‹ðj¿PYBY3Àó¦tÀƒØÿ…Àu%ÿuè¹òÿÿYë¡()C…Àtÿuh{V4tR¿¬YBèÛüÿÿYéÝ;ŒӋN;Êt
‹Ö+V+щ`C+F‹Mˆ+F‹þ‰+~hè[Y‰E„…À„™EŒPhÿpPB…Àttÿu„EŒjh¨YBPÿlPB…Àt\3ÀPPPÿvPÿu„jèöêÿÿƒÄ‰Eˆ…ÀtQÿvWPèf‹EˆƒÄpŠ@„Éuù+ÆD8PèR´Y‹M€ÿuˆ‰‹E„‰ÿ4QB3À@ëÿ9uôt99uøt49uðt/;Æt+3É9uh %C•Á‰ÿUüÿÓÿuÿuøèJþÿÿƒÄ‹ðÿUô‹ÆëƒÈÿ^[ÉÃU‹ìQEüPhpUBÿuÿDCƒÄ…ÀuÉÃÿuüjèâÿÿh$UBÿ(CƒÄÉÃU‹ìQEüPhpUBÿuÿDCƒÄ…ÀuÉÃÿuüjèßáÿÿh$UBÿ(CƒÄÉøèM¡€ñB3ĉ„$‹„$ƒèNU‹¬$V‹´$„¸-ÂtW-ñt/H…Pÿ´$hhëUÿDRBVhìUÿ”RBëVjhhëUÿDRBè³äÿÿ3À@éI¡0)C…ÀtPjhrhUÿDRBhÀCD$h€cBPÿ0RB‹5”RBƒÄD$PhèUÿÖhlcBhìUÿÖéí‹vþ1ÿÿÿt(þ8ÿÿÿ…ÖjjhpUÿHRBPÿLRB麋5HRBSW3ÿWWhpU‰-(CÇ„%CÿÖPÿLRBWWhkUÿÖPÿRB» (C‹ÃpŠ@„Éuù+Æ€¸(C\t‹ûOŠGG„Àuø¾¬SBf¥‹ÃpŠ@„Éuù+ÆUˆˆ(CèÿèÿÿSèòìÿÿYY…À„$ÿ5¨'Cÿ5ˆ%Cè/éÿÿ‹5”RB‹ø¡\CƒÄ»è…Àt€8thLcBSUÿÖÿ5\Cè–ÝÿÿYƒ=„%C„Óh8cBSUÿÖh¶"@ÿ5$Cÿ5(Ch (CWèÌÏÿÿƒÄ…ÀuhcBè/ÓÿÿYƒ=„%C„ƒ=”Ct:høbBSUÿÖhäbBhìÿ5(CÿÖ¹@Cè<×ÿÿ‹ø…ÿtjè_üÿÿYWÿXPBƒ=„%CtCƒ=Ct:hÈbBSUÿÖhäbBhìÿ5(CÿÖ¹@CèðÖÿÿ‹ø…ÿtjèüÿÿYWÿXPB_[3À‹Œ$^]3ÌèŸ4ÄÂU‹ìƒì|SVWj43ÛEˆSPèÊ23À‰]ð}ô««j0«EÀSP‰]¼è°2ƒÄ¿SÇE„8‰}ˆÿtPB‹5(PB‰EŒE„P‰] ÇEœÊ(@ÇEkÿÖ‰EðE„P‰}ˆÇElÇEœÿ+@ÿÖ‰EôE„P‰}ˆÇEmÇEœç@@ÿÖ‰EøE„P‰}ˆÇEnÇEœ63@ÿÖS‰EüÇE¼4ÿtPB‰EÈ‹E‰EÄEð‰EÜE¼PÇEÀ ‰]ä‰]ì‰]ØÇEÔÿ,PB_^[Éøè)I¡€ñB3ĉ„$SUVWÿ5,)C‹= PB½UD$P»$UBShÜdB¾@_BVÿ×jPYD$º@Cè©Ðÿÿÿ5,)CD$UPShÔdBVÿ׋ÍD$º€Cè„Ðÿÿÿ5,)CjPhÀ'CShÈdBVÿ×ÿ5,)C‹-œPBjh¸dBVÿÕÿ5,)C£”Cjh¨dBVÿÕÿ5,)C£Cj
h%CSh˜dBVÿ×ÿ5,)CjPhÀCShdBh„dBÿ×ÿ5,)Chh CShtdBVÿ×ÿ5,)C½PCj
USh`dBVÿ×j¿XdB‹õY3Àó¦uèÆïÿÿ…Àtpè*ïÿÿ…Àugèðÿÿé j¿PdB‹õY3Àó¦uèšïÿÿ…ÀtDèþîÿÿ…Àu;èïÿÿ…Àt2ëÉ8PCt(j¿HdB‹õY3Àó¦tPh@dBh dBÿ4RBPÿdRBh@CèÔàÿÿP£€%CèBýÿÿYYÿ5(Cÿ4QB¡,)C…ÀtPÿQB¡0)C…ÀtPÿHPB‹Œ$_^][3Ì3Àè–1ÄÃUVW¿W¾ CV3íUÿ”PBWh %CUÿ¤PBh$CVèéÜÿÿYY£(C;Åuÿ‹ÂÁè3ÇÁâ3…XuBFÿMuæ÷Ò‹Â#Á‹òÁæÆ‹òÁî#ñÁà_ÆÁê^Â[ÉÃ3ÀëöÁt3ÑéƒÂ…ÉuðÃSVW‹|$‹ðj +þ[‹7‹T$èÑÿÿÿ‰ƒÆKuì_^[ÃU‹ììƒ}u‹EÉÃ3É3ÀAÇE€ ƒ¸í@‰L…€É@ƒø |ôE€VP…ÿÿÿèÿÿÿ…ÿÿÿPE€èŽÿÿÿ‹uYYE€P…ÿÿÿèzÿÿÿöEYt‹Î•ÿÿÿèQÿÿÿ‹ðÑ}t'…ÿÿÿPE€èPÿÿÿöEYt‹ÎU€è*ÿÿÿ‹ðÑ}u¯‹Æ3E^ÉËT$…Òu3ÀÃÿt$‹D$èÔùÿÿYÃU‹ìƒì@‹E‹H‹PS‹KLû‰MÔ‹Ê+MV‹pW‹xOωMÄŒ:ÿþÿÿ‰MЋN(‰MÜ‹N,‰MÀ‹N0‰Mè‹N4‰MØ‹N8‰Mü‹N<‰M‹NL3Ò‰Mä‹NPB‰Mà‹NTÓâ‹NXJ‰UÌ3ÒBÓâJ‰UÈ‹MƒùsƒEC¶Óâ‹MUüC¶ÓâUüƒE‹MÌ#Mü‹Uä‹Š‰Mð‹UðÁé¶ÉÓmü)M‰Mø¶Ê‰Mø…ÉtG‹MøöÁuJöÁ@…3ÒBÓâ‹MðÁéJ#UüÑ‹Mä‹‘‰Mð‹UðÁé¶ÉÓmü)M‰Mø¶Ê‰Mø…Éu¹GÁêˆé-Áêƒá‰Uô‰Møt*‹M;Møs
C¶ÓâUüƒE‹Mø3ÒBÓâJ#UüÓmüUô)M‹MƒùsƒEC¶Óâ‹MUüC¶ÓâUüƒE‹MÈ#Mü‹Uà‹ŠëöÁ@…Ò3ÒBÓâ·MòJ#UüÑ‹Mà‹‘‰Mð‹UðÁé¶ÉÓmü)M‰Mø¶ÊöÁtŃáÁê‰Uì‰Mø9Ms+‹MƒEC¶Óâ‹MøUü9Ms‹MC¶Óâ‹MøUüƒE3ÒBÓâ‹Mø)MJ#UüÓmüUì‹Uì‹Ï+MÄ;цî+щUø;UÀ‡(‹MØI‰Mð‹Mè…Éu&‹MÜ+ÊMð‹Ê;Môƒˆ)Mô‹MðAŠGÿMøˆuõëK;ÊsQ+ÊMÜMð‹Mø+Mè;Môs^)MôÿEð‹UðŠGIˆuò‹MØI‰Mð‹Mè;Môs>)Mô‰Mø‹MðAŠGÿMøˆuõ‹Ï+Mì‰Mðë#+ÊMð‹Mø;Môs)Mô‹MðAŠGÿMøˆuõëÖ‹Mð‹UôƒúvLBýj3ÒY÷ñ‹Mð@ƒmôAŠGˆAŠGAˆŠGHˆuç‹Eë ‹Ï+ʃmôAŠGˆAŠGAˆŠGƒ}ôˆwäƒ}ôtAŠGƒ}ôˆvŠIGˆ;]Ôs7;}Ђ#ýÿÿë,Ç@Œ…BëÇ@t…BëöÁ tÇë
Ç@X…BÇ‹MÁé+ÙÁá)M3ÉA‹Ñ‹MÓâJ‹Ê‹Uü#ÑK‰O‰H‹MÔ+˃Á‰H‹MÐ+ÏÁ‰H‹E_‰V8‰F<^[ÉËL$3Ò;ÊtM‹A;ÂtF‰P‰Q‰Q‰QÇA0ˆ0‰‰P‰PÇ@€‰P ‰P(‰P,‰P0‰P8‰P<‰Hl‰HP‰HL3ÀÃjþXËD$V…Àt5‹@…Àt.‹L$ƒù%‹P<4
ƒþ wW3ÿGÓç‹Ê‰puÇ‹B‹JƒeÜ‹^8‹~<‰E苉Eü‹B‰Eø‰EÔ‹‰Mð‰MäƒøvjþX_^[ÉËUÿ$…xh@‹F…Àu*Çéƒ}ø„K‹Mü¶ÿMø‹ÏÓâÚÿEüƒÇƒÿrܨt>û‹u63ÿWWWèèøÿÿ‰FjEìPÆEìÆEí‹ÿvèÏøÿÿƒÄ‰F3ÛÇé¡‹F ƒf…ÀtƒH0ÿöF„ƒ¶ÃÁà‹ËÁéÁj3ÒY÷ñ…Òuk‹Ã$<t‹EÇ@¨BéSÁë‹ËƒáƒÁƒï;N$v‹EÇ@”Bé13À3ÿ@ÓàWWW‰Fè˜ïÿÿ‹MÁë÷ÓƒãƒË	‰F‰A0ƒÄ‰3Ûé‹EÇ@|Béðƒÿs'ƒ}ø„5‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‰^€ûtÇB¨Bé°÷ÃàtÇB`B霋F …Àt
‹ËÁéƒá‰÷Ft ˆ]ìjEìÁëPˆ]íÿvèŒ÷ÿÿ‹UƒÄ‰F3Û3ÿǃÿ s'ƒ}ø„‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ rÜ‹U‹F …Àt‰X÷Ft0‹ÃÁèˆEí‹ÃÁèˆEîˆ]ìjEìÁëPˆ]ïÿvè÷ÿÿ‹UƒÄ‰F3Û3ÿǃÿs'ƒ}ø„$‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹F …Àt‹Ëáÿ‰H‹N ‹ÃÁè‰A÷Ft ˆ]ìjEìÁëPˆ]íÿvè—öÿÿ‹UƒÄ‰F3Û3ÿÇ÷Fthƒÿs'ƒ}ø„Ÿ
‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹F ‰^@…Àt‰X÷Ft ˆ]ìjEìÁëPˆ]íÿvè"öÿÿ‹UƒÄ‰F3Û3ÿë‹F …Àtƒ`Ç÷F„‡‹V@‹Eø‰Uô;Ðv‰Eôƒ}ôtd‹N …Ét4‹A‰EØ…Àt*‹A‹I+‹UôÐ;Ñv+Èë‹MôQ‹MØÿuüÈQ蕃Ä÷FtÿuôÿuüÿvèõÿÿƒÄ‰F‹Eô)EøEü)F@ƒ~@…¤‹Uƒf@Ç÷Ft~ƒ}ø„„3É‹Eü¶A‰Mô‹N ‰Eà…Ét‹Q‰UØ…Òt‹V@;Q s	‹M؈ÿF@…Àt‹Mô;MørÄ÷Ftÿuôÿuüÿvèüôÿÿ‰F‹EàƒÄ‹Mô)MøMü…À…‹Uë‹F …Àtƒ`ƒf@Ç÷Ft~ƒ}ø„è3É‹Eü¶A‰Mô‹N ‰Eà…Ét‹Q$‰UØ…Òt‹V@;Q(s	‹M؈ÿF@…Àt‹Mô;MørÄ÷Ftÿuôÿuüÿvè`ôÿÿ‰F‹EàƒÄ‹Mô)MøMü…À…y‹Uë‹F …Àtƒ`$Ç÷FtDƒÿs'ƒ}ø„K‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U·F;ØtÇBLBéÆ
3Û3ÿ‹F …Àt‹V3ÉAÁú	#щP,‹F ‰H03ÀPPPè¾óÿÿ‹M‰FƒÄ‰A0éòƒÿ s'ƒ}ø„Ñ
‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ rÜ‹U‹Ë¸ÿ#È‹ûÁçÏ‹ûÁï#øÁáÁëωF‰B03Û3ÿÇ
ƒ~„:
3ÀPPPè“êÿÿ‹M‰F‰A0ƒÄǃ}„R
‹Uƒ~t‹ÏƒáÓë+ùÇéç	ƒÿs'ƒ}ø„&
‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹ÃƒàÑë‰F‹ÃƒàOƒèt/HtHtHu,ÇB8BÇëÇë‹Æèÿ÷ÿÿÇëÇ
ÁëOOég	‹Ïƒá+ùÓëƒÿ s'ƒ}ø„	‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿ rÜ‹U‹Ë‹Ã÷Ñ%ÿÿÁé;ÁtÇBBé	3Û‰F@3ÿÇ‹F@‰Eô…À„Y‹Eø9Eôv‰Eô‹Eð9Eôv‰Eôƒ}ô„'	ÿuôÿuüÿuèèÔ‹Eô)EøEü)EðEèƒÄ)F@鱃ÿs'ƒ}ø„ð‹Eü¶ÿMø‹ÏÓàƒÇØÿEüƒÿrÜ‹U‹Ãƒà‰F`Áë‹Ãƒà@Áë‰Fd‹ÃƒàƒÀÁëƒï~`‰F\wƒ~dwƒfhÇëNÇBôŽBé+ƒ}ø„u‹Eü¶ÿMø‹ÏÓàØÿEüƒÇƒÿrÜ‹Nh·M0ŽB‹Ãƒàf‰DNpÿFhÁëƒï‹Fh;F\rÕë‹Fh·E0ŽB3Éf‰LFpÿFhƒ~hrå†0Nl‰‰FL–ðRFTPQÇjFpPjèªƒÄ‰EÜ…Àt‹EÇ@ØŽBé~ƒfhÇéúƒ}ø„¹‹Eü¶ÿMø‹ÏÓàØÿEüƒÇ‹NT3À@Óà‹NLH#Ë‹ÈÁé¶É‰Eà;ÏwÁ‹ÈÁéfƒùsK‹ÈÁé¶Éë"ƒ}ø„e‹Mü¶ÿMø‹ÏÓâ¶ÌÚÿEüƒÇ;ùrڶ̋FhÓë+ùf‹Mâf‰LFpÿFhéefƒ}âuV¶Äëƒ}ø„‹Mü¶ÿMø‹ÏÓâÚÿEüƒÇH;ùrÚ‹È+ø‹FhÓë…À„3·DFn‰Eà‹ÃƒàƒÀÁëOOé…fƒ}â¶ÔuZëƒ}ø„»‹Eü¶ÿMø‹ÏÓàØÿEüƒÇB;ørÚ‹ÊÓëjý‹ÃƒàƒÀÁëë7ƒ}ø„‚‹Eü¶ÿMø‹ÏÓàØÿEüƒÇB;ørÚ‹ÊÓëjù‹ÃƒàƒÀÁëƒeàY+Êù‹Nd‹VhN`Ð;Ñvp‹EÇ@¼ŽBǃ>„Ö†0Nl‰‰FL–ðRFTPQÿv`Ç	FpPjèµ
ƒÄ‰EÜ…ÀtC‹EÇ@ ŽB鉋Nhf‹UàHf‰TNpÿFh…Àuì‹FdF`9Fh‚þÿÿë‹‹EÇ@¼ŽBéUNl‹‰FP–ðRFXPQÿvdÇ‹F`DFpPjè<
ƒÄ‰EÜ…Àt‹EÇ@ˆŽBéǃ}ørY}ðrP‹E‹Mèÿuä‰H‹Mð‰H‹Mü‰‹Mø‰HP‰^8‰~<è
îÿÿ‹E‹^8‹~}'‹Eä‹M;At‹Eä‹}èîÿÿ…Àt
Çjüé7ïÿÿ‹}‹EÔ+G‹]ä+_G_^ƒ~‰EÔt,…Ût(‹GS+Ã~PÿvtèAèÿÿëè’ßÿÿ‰F‰G0‹EÔƒÄƒ>u¹€ë3É‹V÷ÚÒƒâ@ÑV<‰W,…Àu…Ûtƒ}u
ƒ}ÜuÇEÜûÿÿÿ‹EÜé¨îÿÿ.W@QX@éX@bY@ÞY@`Z@þZ@š[@2\@µ\@]@9]@F]@à]@@^@–^@X_@Ìa@7b@Ôc@d@5e@™e@!f@Df@g@…g@Žg@àg@V‹t$…öt0‹F…Àt)‹N$…Ét"‹@4…ÀtPÿv(ÿÑYYÿvÿv(ÿV$ƒfYY3À^ÃjþX^ÃSVW‹|$3À;øt‹w;ðt‹\$9Ftƒ>
tjþX_^[Ã>
uPPPèZÞÿÿÿt$$SPèOÞÿÿƒÄ;Ftjýë׋Gèeìÿÿ…Àt
ÇjüëÁ‹F(‹|$;øv+ØPßSÿv4èª	‹F(‰F,ë‹N4W+ÏÈSQè“	‰~,ƒÄÇF3Àë‹D$…Àt‹@…Àtö@t‹L$‰H ƒa03ÀÃjþXË3À9D$vASWƒùs8‹T$Šƒùÿçÿÿÿ¶ÚÇÿ;ßuAë„Òt3ÉëjZ+Ñ‹Ê@;D$rÃ_[‰ÃU‹ìS‹]VW…Û„©‹{…ÿ„žƒ{u
ƒ<sjûéjX9tA‰‹G<‹ÈƒáÓg8+Á3ɉG<ƒørŠG8Áo8ƒG<øˆD
Aƒ<sêQEwhƒ&Pè=ÿÿÿYYÿswhÿ3è.ÿÿÿ)CCƒ>‹CYY‰Etjýë‹sSèoéÿÿ‹E‰C‰sYÇ3ÀëjþX_^[]ËD$…Àt‹@…Àtƒ8
u
ƒx<u3À@Ã3ÀÃjþXÃU‹ìQQSVW3ÿ9}„‹u;÷„‹^;ß„ù‹F ;Ç„î9~$„åh0%jÿv(ÿЃÄ‰Eü;Çujüéʉ}ø9{4t(‹K$3À@ÓàjPÿv(ÿV ƒÄ‰Eø;Çu
ÿuüÿv(ÿV$YYëÉ‹}jYh0%ó¥‹uüSVè…‹CL“0ƒÄ¹0;Âr/“,%;Âw%+Ã+ÁÁø„†0‰FL‹CP+Ã+ÁÁø„†0‰FP‹Cl‹}ø+Ã+ÁÁø„†0‰Fl…ÿt‹K$3À@ÓàPÿs4WèƒÄ‹E‰~4‰p3ÀëjþX_^[ÉÃUl$ ì¡€ñB3ʼnE\‹El‹Ux‰Eä‹E|S‰E3ÀV‹ut·ØW‹ÃÁãjÃY}<ó«3ÿ3ɉUÐ9}pv‹Eä·HDE‹Â3ÒBÓâƒ}h‰]‰EÜJÿ‰]‰Uà‰Uü‰MØuú°r3À@é‹M‰MŠÈ*MˆM‹M··Ê;Mø}
ÆEf‰Uë&~‹M·	‹UèÉŠˆU‹Uôf‹ëÆE`3Éf‰M3Ò‹È+MBÓâ‹Mà‰M‰Mð‹MÓë]Ÿ)U‹ÚÁã+˃}‹]‰uë3ÒHÿBÓâ‹MëÑê…Ñuú…Òt	Zÿ#ÙÚë3ÛƒELE<ºÿÿf·	‰]f…Éu;E„Ç‹E·‹Mä·A‰EÜ‹U;†&ÿÿÿ‹MØ#ˉMÔ;Mì„ÿÿÿƒ}u‰U‹Mð<‹È‹E3Ò+ÈBÁÓâ;Es(‰EDE<ë‹Eð·+Ó…Ò~AÿE@@‰Eð‹EÒ;Erá3À@‹ÐÓâUü‰Uà9Ehu
}ü°ƒ¦‹EÔ‹]‹Ð‰Eì‹Áâˆ‹ŠMˆL‹‹Ï+ÈÁùf‰L‹EÜézþÿÿŠÈ*MÆE@ˆM3Éf‰MëJƒ}t‹MØ#Ë;Mìt‹Eƒe‹>ˆE‹M‹ÓÓê‹M‰—3ÒHÿBÓâëÑê…Óuú…ÒtJÿ#ËÊ‹Ùë3Û…Ûu²‹Eü‹MÁà‹EЉ3À‹M\_^3Í[èCƒÅ`Éø¤SBÃjUXËD$Áเ‘B+È‹ËD$¯D$Pè&YÃÿt$èÄYÃÿ%,PBÿ%(PBÿ%\QBÿ%XQBÿ%TQBÿ%PQBÿ%LQBÿ%HQBÿ%DQBÿ%@QBÿ%‰~éŠýÿÿÿuè“ŒYÃjhÕBè<{3ö‰uä3À‹];Þ•À;Æu èCÇVVVVVè§6ƒÄƒÈÿéÍ3À9u•À;ÆtÔ‰]Sè)Y‰uüöC@uwSèY¡Yƒøÿtƒøþt‹ÐÁú‹ÈƒáÁá•@)Cë¹ÿBöA$u)ƒøÿtƒøþt‹ÈÁùƒàÁà@)Cë¸ÿBö@$€tèBÇVVVVVè
6ƒÄƒMäÿ9uäu#Sè•“‹øEPVÿuSè5•‰EäSW蔃ÄÇEüþÿÿÿè	‹Eäè|zÃÿuèÖYËÿU‹ìEPÿuÿuÿuèסƒÄ]ËÿU‹ìEPÿuÿuÿuèÛ¡ƒÄ]ËÿU‹ìEPjÿuÿuèÀ¡ƒÄ]ËÿU‹ìEPÿuÿuÿuèÄ¡ƒÄ]ËÿU‹ìEPjÿuÿuè©¡ƒÄ]øˆñBá :CVj^…Àu¸ë;Æ}‹Æ£ :CjPè*†YY£Œ*C…ÀujV‰5 :Cè†YY£Œ*C…ÀujX^Ã3Ò¹ˆñBë¡Œ*C‰ƒÁ ƒÂùôB|êjþ^3Ò¹˜ñBW‹ÂÁø‹…@)C‹úƒçÁ狃øÿt;Æt…Àu‰1ƒÁ BùøñB|Î_3À^Ãèᣀ=àCtèW¡ÿ5Œ*Cè=õÿÿYËÿU‹ìV‹u¸ˆñB;ðr"þèóBw‹Î+ÈÁùƒÁQèMhN€Yë
ƒÆ Vÿ˜QB^]ËÿU‹ì‹Eƒø}ƒÀPè h‹EH€Y]ËEƒÀ Pÿ˜QB]ËÿU‹ì‹E¹ˆñB;Ár=èóBw`ÿÿÿ+ÁÁøƒÀPèåfY]ÃÀ PÿœQB]ËÿU‹ì‹Mƒù‹E}`ÿÿÿƒÁQè¶fY]ÃÀ PÿœQB]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌQL$+ȃáÁÉÁYéQL$+ȃáÁÉÁYé‹ÿU‹ìƒì S3Û9]uè–?SSSSSÇè"3ƒÄƒÈÿë‹MV‹u;Ët!;óuèj?SSSSSÇèö2ƒÄƒÈÿëR¸ÿÿÿ‰Eä;Èw‰MäWEPSÿuEàPÇEìB‰uè‰uàè
’ƒÄ‹ø;ótÿMäx‹EàˆëEàPSè¢YY‹Ç_^[ÉËÿU‹ìEPÿuÿuÿuÿuèhƒÄ]ÃÌÌÌÌÌÌ‹L$W…É„’VS‹Ù‹t$÷Æ‹|$uÁé……ë'ŠƒÆˆƒÇƒét+„Àt/÷Æuå‹ÙÁéuaƒãtŠƒÆˆƒÇ„Àt7ƒëuí‹D$[^_Ã÷ÇtˆƒÇƒé„˜÷Çuê‹ÙÁéutˆƒÇƒëuö[^‹D$_ɃǃétŸºÿþþ~‹Ѓðÿ3‹ƒÆ©tÜ„Òt,„öt÷Âÿt÷Âÿuĉëâÿÿ‰ëâÿ‰ë3Ò‰ƒÇ3Àƒét3À‰ƒÇƒéuöƒã…wÿÿÿ‹D$[^_ÃÌÌÌÌÌÌÌÌÌÌÌÌU‹ìW‹}3ÀƒÉÿò®ƒÁ÷ÙƒïŠEýò®ƒÇ8t3Àë‹Çü_ÉËÿU‹ìƒì S3Û9]u èe=SSSSSÇèñ0ƒÄƒÈÿ逋MV‹u;Ët!;óuè6=SSSSSÇèÂ0ƒÄƒÈÿëS¸ÿÿÿ‰Eä;Èw‰MäWÿuEàÿuÇEìBÿu‰uèP‰uàèՃċø;ótÿMäx‹EàˆëEàPSèÝŸYY‹Ç_^[ÉËÿU‹ìÿujÿuÿuÿuè5ÿÿÿƒÄ]ÃÌÌÌQL$+ÈÀ÷Ð#È‹Ä%ðÿÿ;Èr
‹ÁY”‹‰$Ã-…ëé‹ÿU‹ìƒì WVè&‚3ÿY;÷uèa<WWWWWÇèí/ƒÄƒÈÿë49}tÞ¹ÿÿÿÇEìI‰uè‰uà‰Mä;Áw‰EäÿuEàÿuÿuPÿUƒÄ_ÉËÿU‹ìV‹uEPjÿuh0AèzÿÿÿƒÄ^]ËÿU‹ìV‹uEPÿuÿuh0AèWÿÿÿƒÄ^]ËÿU‹ìV‹uEPjÿuh‹@Aè5ÿÿÿƒÄ^]ËÿU‹ìV‹uEPÿuÿuh‹@AèÿÿÿƒÄ^]ËÿU‹ìSV‹uW3ÿƒËÿ;÷uèo;WWWWWÇèû.ƒÄÃëBöFƒt7VèsœV‹Øè¥ÃVè¼™Pè̃Ä…À}ƒËÿë‹F;Çt
Pè˜ïÿÿY‰~‰~‹Ã_^[]Ãjh0ÕBèsƒMäÿ3À‹u3ÿ;÷•À;Çuèì:ÇWWWWWèx.ƒÄƒÈÿëöF@t‰~‹EäèsÃVèúùÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿèëÕ‹uVèHúÿÿYËÿU‹ìƒìSVW3ÿ9}t$9}t‹u;÷uèr:WWWWWÇèþ-ƒÄ3À_^[ÉËM;ÏtÚƒÈÿ3Ò÷u9EwÍ‹}¯}÷F‰Mü‰}ô‹ßt‹F‰EøëÇEø…ÿ„¿‹Nát/‹F…Àt(Œ¯‹û;Ør‹øWÿuüÿ6èƒâÿÿ)~>ƒÄ+ß}üëO;]ørO…ÉtVèóšY…Àu}ƒ}ø‹ût	3Ò‹Ã÷uø+úWÿuüVè*˜YPèjɃÄƒøÿta‹Ï;Çw‹ÈMü+Ù;ÇrP‹}ôë)‹Eü¾VP臜YYƒøÿt)ÿEü‹FK‰Eø…ÀÇEø…Û…Aÿÿÿ‹EéñþÿÿƒN ‹Ç+Ã3Ò÷uéßþÿÿƒN ‹EôëëjhPÕBè0q3ö9ut)9ut$3À9u•À;Æu è
9ÇVVVVVè–,ƒÄ3Àè>qÃÿuè%øÿÿY‰uüÿuÿuÿuÿuè=þÿÿƒÄ‰EäÇEüþÿÿÿè‹EäëÆÿuèdøÿÿYËÿU‹ì‹E…Àt‹M‰ƒÀ]ËÿU‹ì‹E…Àtƒè8ÝÝuPè÷ìÿÿY]ËÿU‹ìƒìSVWÿuMè3Ûè„éÿÿ‹E苸ԉ]ü‹uüÁæÿt>è~ÿ4>‰Eøèö}ÃÿEüƒ}üYY‹Mø\rÒCPè™|‹ðY‰uø…ö„‚ƒeü‹EüÆ:ÿ4‡‹EøF+ÆDPVèÊ{ƒÄ…Àt3ÀPPPPPè*ƒÄVè‘}ð‹EüÆ:ÿt‡‹EøF+ÆDPVè‘{ƒÄ…Àt3ÀPPPPPèÝ)ƒÄVèX}ðÿEüƒ}üYr…Æ€}ô_^[t‹Eðƒ`pý‹EøÉÃjèùþÿÿYËÿU‹ìƒìSVWÿuMä3Ûè{èÿÿ‹E䋸Ôw8‰uüÇEøÿv0èõ|ÿ6‰Eôèë|‹uüYY‹MôÃÆÿMø\‰uüuÕCPè‰{‹ðY‰uü…ötƒÇhÇEø‹EüÆ:ÿwÐF+ÆDPVè»zƒÄ…Àt3ÀPPPPPè)ƒÄVè‚|ð‹EüÆ:ÿ7F+ÆDPVè‡zƒÄ…Àt3ÀPPPPPèÓ(ƒÄVèN|ðƒÇÿMøYuŽÆ€}ð_^[t‹Eìƒ`pý‹EüÉÃjèùþÿÿYËÿU‹ìƒì$SVWÿuMÜ3ÿèrçÿÿ‹EÜ‹°Ô‰}ü‹]üÁãÿt3èï{ÿ43‰Eìèä{ÇÿEüƒ}üYY‹Mì|rÒF8‰EðÇEô‹]ðÿs0è¸{ÿ3‰Eìè®{ƒEðYY‹MìÇÿMô|u×ÿ¶œè{ÿ¶˜‹Øè‚{ÿ¶ Ç|èq{ÿ¶¤|èb{ÿ¶¨|èS{„¹P‰Eøèz‹ØƒÄ…Û„Wh¸VS»¸èÞÿÿƒeüF‰]ðƒÄ)uð‰Eô‹Eü‰<ƒ‹Eôÿpä‹Ã+ÇEøPWèyƒÄ…Àt3ÀPPPPPè`'ƒÄWèÛz‹Mð|‹Eô‰<ÿ0‹Ã+ÇEøPWèÛxƒÄ…Àt3ÀPPPPPè''ƒÄWè¢zÿEüƒEôƒ}üY|‚{ÿÿÿCh‰EüF8‰EôÇEìë‹Eô‹Mð‰<ÿ0‹Ã+ÇEøPWè{xƒÄ…Àt3ÀPPPPPèÇ&ƒÄWèBz|‹Eü‰8‹Eôÿp0‹Ã+ÇEøPWèBxƒÄ…Àt3ÀPPPPPèŽ&ƒÄWè	zƒEôƒEüÿMìY|u€‹Ã+ÇEø‰»˜ÿ¶˜PWèúwƒÄ…Àt3ÀPPPPPèF&ƒÄWèÁy|‹Ã+ÇEø‰»œÿ¶œPWèÀwƒÄ…Àt3ÀPPPPPè&ƒÄWè‡y|‹Ã+ÇEø‰» ÿ¶ PWè†wƒÄ…Àt3ÀPPPPPèÒ%ƒÄWèMy|‹Ã+ÇEø‰»¤ÿ¶¤PWèLwƒÄ…Àt3ÀPPPPPè˜%ƒÄWèyD‹Ë+ÈMø‰ƒ¨ÿ¶¨QPèwƒÄ…Àt3ÀPPPPPè^%ƒÄ€}èt‹Eäƒ`pý_^‹Ã[ÉÃjè¢üÿÿYÃ8V‹òtWŠ„Òt‹9ˆÿFÿƒ8uì_^Ã>‹Svj
™[÷û€Â0ˆAÿ‹…À~ƒúw狉IŠŠˆIˆ@;Árò[ËÿU‹ìQSV‹ò3Ò‰Uü9Ut5ƒ9‹7vj
™[÷û€Â0ˆFÿ	‹…À~ƒúw狉7NŠŠˆNˆ@;Æròë.;1s(NV…Òtj
™[÷û‹€Â0ÿEüˆNƒþÿué‹Eü)ë‰^[ÉËÿU‹ìQS¾ÀƒøYVW‹Ù‹ò½„…ƒøIË„˜ƒè„©ƒè	„ ƒètpƒètIHt$ƒè…š‹F3ÿ;ÇŒuƒøléÖ‹v3ÿ;÷ŒZƒþQ‹U‹T²héE‹v3ÿ;÷Œ8ƒþ/‹U‹T²é#‹Æ%‹Eÿÿé‹F3ÿ;ÇŒƒøü™jY÷ù‹Â;Ç…[QXéTƒèM„£jY+Á„„HHt4HHtH…Úÿuÿués‹F3ÿ;ÇŒª;Á¢;ÇtHÿë‹F3ÿ;ÇŒŒ;Á„‹È‹F;ÇŒw=ml;Á}3ÀéÐj™^÷þ;ÑŒÂ@鼋3ÿ;ÇŒAƒø;éÇþÿÿ‹Fëé‹F=”øÿÿ|=£~è~03ÿé™jdY÷ùÿujƒÀkÀdÂëvƒøm9„ƒèZ„Aƒè„ÓH„²Ht\Ht,ƒè…ã‹v3ÿ;÷Œ¾þm²ÿuFjë‹vƒþŒyÿÿÿƒþpÿÿÿ‹ÆÿujZ‹M‹ûè.ýÿÿYéƒÿu3ÿÿuSV9}tAjÿuèrƒÄ…Àts‹E98tl‹ÿuÆ ‹EÿÿPSVjÿuèHƒÄ…À…5ëCW뾋v3ÿ;÷|ƒþ‹U‹T²8é‹v3ÿ;÷|ƒþ~è[/WWWWWÇèç"ƒÄ3Àéì‹U‹²éÖ‹v3ÿ;÷|̓þÈFé/ÿÿÿƒèp„‹ƒèteHtFHt&HuÁè)*è·.‹Ð3À9F ‹Ë•À‹Ø‹š‰Eü醋F3ÿ;ÇŒyÿÿÿÿu™jdY÷ù‹ÂéÛþÿÿÿu3ÿÿuSV9}tjéÿÿÿWé
ÿÿÿ‹F3ÿ;ÇŒ@ÿÿÿƒø7ÿÿÿÿu3ÒBé¡þÿÿ‹v3ÿ;÷Œÿÿÿƒþÿÿÿƒþ‹U‹’˜ë‹’œ‹EèOûÿÿ3À@_^[ÉËÿU‹ìƒì ¡€ñB3ʼnEü‹ESV‹u3Û+ÃWtHt‹¾¨ë‹¾¤ë‹¾ ƒ¾°‹E„þƒ}‹
¤QBu‹
 QBºlfPSf‰Uàf‹PfBf‰Uâf‹Pf‰Uæf‹Pf‰Uèf‹Pf‹f‰EìS3ÀWf‰EîEàPSÿ¶¬‰Môf‰UêÿщEð;Ä’ƒÀ=è´íÿÿ‹Ä;ÃtÇÌÌëPèGãÿÿY;Ãt	ÇÝ݃À‰Eø;ÃtZÿuð‹ØSWEàPjÿ¶¬ÿUôH…À~!‹u‹Mƒ>v‹‰EðŠˆÿ‹EðCÿH…ÀåÿuøèƒôÿÿY3À@eÔ_^[‹Mü3ÍèÈÚÿÿÉÊ„Àtå‹]‹uƒ;tÚ3Ò‰Uø‹ÏAB8tú‰Mô¾Èƒùd‚„Nƒù'„؃ùA„›ƒùHt~ƒùMtOƒùa„ˆÿuQ訾YY…Àtƒ;vG€8„šŠ‹ˆÿÿ‹øŠ‹ˆÿGÿŠ„À…sÿÿÿéMÿÿÿ‹ÂHtHtHt
Hu¬°Bé<°bé5ÇEø°mé'‹ÂHtHt	ë†ÇEø°HéhĹBWè¾¼YY…ÀuƒÇëhÀ¹BW証YY…ÀuƒÇ‰}ô°péÛúö„pÿÿÿŠ„À„Âþÿÿƒ;„]ÿÿÿ<'tEÿu¾ÀPèǽYY…Àtƒ;vG€8„¹Š‹ˆÿÿ‹ø‹ŠˆÿGÿŠ„Àu³éÿÿÿGéÿÿÿ‹ÂHtHtHtH…Åþÿÿ°AéU°aéNÇEø°dé@‹Áƒèh„ƒè„þƒè„ÝHt%ƒè…€þÿÿ‹ÂHHtHH…rþÿÿ°Yé°yéû‹Eƒx‹E‹¸˜ë‹¸œƒú…Šƒ;†¾ÿuPèݼYY…Àtƒ;vG€8„ÏŠ‹ˆÿÿ‹ø‹Šˆÿÿ鬃;†£ÿu¾ÀPè–¼YY…Àtƒ;vG€8„ˆŠ‹ˆÿÿ‹øŠ‹ˆÿGÿŠ„Àu·ëa‹ÂHtHté¢ýÿÿÇEø°Së.‹ÂHtHtéŠýÿÿÇEø°Më‹ÂHtHtérýÿÿÇEø°Iÿuø‹Uÿu‹ÎSÿuèÍ÷ÿÿƒÄ…Àt‹}ôé}ýÿÿ3ÀéÕüÿÿ‹ÿU‹ìƒì ‹ESÿu3ÛMà‰]ø‰EðèñÚÿÿ‹E;Ãu+èÄ)SSSSSÇèPƒÄ8]ìt‹Eèƒ`pý3ÀéPW‹};ûu+è‘)SSSSSÇèƒÄ8]ìt‹Eèƒ`pý3ÀéV‹uˆ;ó„ç‹E;Ãu	‹Eà‹€Ô‰Eô‰}ü;û†ŸŠ:Ãty<%tAMà¾ÀQPè)»YY…Àt3ÉA9MüvF8tpŠ‹Uˆ
ÿEÿMü‹ðŠ‹MˆÿEFÿMüë/‹U;ÓtwF3À€>#u@FPÿuôEüPEàPŠMè•öÿÿƒÄ…ÀtBF9]üw9]üv‹Eˆ+}ü‹Ç8]ìt\‹MèƒapýëS‰Mø‹Eðˆ9]øu 9]üwèŒ(Ç"ë&9]üvßÇEøëÖèq(SSSSSÇèýƒÄ8]ìt‹Eèƒ`pý3À^_[ÉËÿU‹ìÿujÿuÿuÿuÿuèAþÿÿƒÄ]ËÿU‹ìjjÿuÿuÿuÿuè"þÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuÿuèþÿÿƒÄ]ÃjhpÕBèé_3Û‰]ä3À‹};û•À;ÃuèÈ'ÇSSSSSèTƒÄ3Àëy3À‹u;ó•À;ÃtÖ3À8•À;ÃtËèH¿‰E;Ãu
è‡'Çëʉ]ü8u ès'ÇjþEðPh€ñBèJÀƒÄë£PÿuVWè9¼ƒÄ‰EäÇEüþÿÿÿè	‹Eäè_ÃÿuèÛæÿÿYËÿU‹ìj@ÿuÿuè*ÿÿÿƒÄ]ËÿU‹ìVW‹}3ö;þuèü&j_VVVVV‰8艃ċÇë$h€ÿuÿuèêþÿÿƒÄ‰;Æt3ÀëèÄ&‹_^]ËÿU‹ìƒì S3Û9]uè©&SSSSSÇè5ƒÄƒÈÿëM‹E;ÃtÜV‰Eè‰EàEPSÿuEàPÇEäÿÿÿÇEìBèJyƒÄÿMä‹ðx‹EàˆëEàPSèV‰YY‹Æ^[ÉËÿU‹ìEPÿuÿuÿuèjÀƒÄ]ËÿU‹ìEPjÿuÿuÿuè̃Ä]ËÿU‹ìEPÿuÿuÿuÿuè­ÂƒÄ]ËÿU‹ìEPjÿuÿuÿuÿuè1ÃÄ]ËÿU‹ìEPÿuÿuÿuÿuÿuèÃÄ]ËÿU‹ìEPjÿuÿuÿuèAăÄ]ËÿU‹ìEPÿuÿuÿuÿuè"ăÄ]ËÿU‹ìEPÿuè†ÀYY]ËÿU‹ìEPÿuèªÀYY]ËÿU‹ìEPÿuÿuèuÀƒÄ]ËÿU‹ìEPÿuÿuè•ÀƒÄ]ËÿU‹ìƒìÿuMðèÖÿÿ‹Eðƒ¸¬~EðPhÿuèeIƒÄ닀ȋM·H%€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·A%]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðè”Õÿÿ‹Eðƒ¸¬~EðPjÿuèâHƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèÕÿÿ‹Eðƒ¸¬~EðPjÿuècHƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðè–Ôÿÿ‹Eðƒ¸¬~EðPjÿuèäGƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèÔÿÿ‹Eðƒ¸¬~EðPh€ÿuèbGƒÄ닀ȋM·H%€€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·A%€]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðè‘Óÿÿ‹Eðƒ¸¬~EðPjÿuèßFƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðèÓÿÿ‹Eðƒ¸¬~EðPjÿuè`FƒÄ닀ȋM·Hƒà€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·Aƒà]Ãjÿuè…ÿÿÿYY]ËÿU‹ìƒìÿuMðè“Òÿÿ‹Eðƒ¸¬~EðPhÿuèÞEƒÄ닀ȋM·H%€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·A%]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðè
Òÿÿ‹Eðƒ¸¬~EðPhWÿuèXEƒÄ닀ȋM·H%W€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·A%W]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðè‡Ñÿÿ‹Eðƒ¸¬~EðPhÿuèÒDƒÄ닀ȋM·H%€}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·A%]Ãjÿuè~ÿÿÿYY]ËÿU‹ìƒìÿuMðèÑÿÿ‹Eðƒ¸¬~EðPj ÿuèODƒÄ닀ȋM·Hƒà €}üt‹MøƒapýÉËÿU‹ìƒ=ô
Cu‹E‹
øüB·Aƒà ]Ãjÿuè…ÿÿÿYY]ËÿU‹ì}€À÷Ø]ËÿU‹ì‹Eƒà]ËÿU‹ìÿuÿuè9úÿÿYY…Àuƒ}_t]Ã3À@]ËÿU‹ìÿuèoúÿÿY…Àuƒ}_t]Ã3À@]ËÿU‹ìÿuÿuè~ýÿÿYY…Àuƒ}_t]Ã3À@]ËÿU‹ì¶EPè²ýÿÿY…Àu€}_t]Ã3À@]ÃÌÌÌÌÌÌÌÌ‹ÿV‹ò;Át…ötS‹ÿŠŠˆNˆ@A…öuñ[^ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìQ‹UW‹ø;úvn‹M
S‰EüVëI‹uü‹Ú;÷w"¤$SVÿUƒÄ…À~‹Þu;÷vë‹M‹U‹ñ‹Ç;ßt#…Ét‹Ë+ÏëIŠŠˆNˆ@…öuð‹M‹U+ù;úw¤^[_‹å]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ììS‹]V‹u…Ûu'…öt#èçjjjjjÇènƒÄ^[‹å]ÃW‹}…ÿvƒ}u$è¶jjjjjÇè=ƒÄ_^[‹å]ÃþrôN¯÷óÇEô‰]ü‰uø‹Æ+Ã3Ò÷÷@ƒøw‹EPWS‹ÆèÍþÿÿƒÄévÑè¯ÇËøWSÿUƒÄ…À~‹U‹Ï‹ÃètþÿÿVSÿUƒÄ…À~‹U‹Î‹Ãè\þÿÿVWÿUƒÄ…À~‹U‹Î‹ÇèDþÿÿd$;ûv];ßsWSÿUƒÄ…À~í;ûwëI];]øwWSÿUƒÄ…À~ì+u;÷vWVÿUƒÄ…Àí;Þw2‹U‹Æt#‹Ë+ÎJ‰Uð¶ˆU¶ˆ¶Uˆ‹Uð@…Òuá;þu‡‹ûëƒu;þs+u;÷vWVÿUƒÄ…Àtí;þrëI+u‹Eü;ðvWVÿUƒÄ…Àtê‹Eü‹Uø‹Ê‹þ+Ë+ø;ù|+;Æs‹Mô‰„xÿÿÿ‰´ÿÿÿA‰Mô;Ús9‹uø‹}‰]üé•þÿÿ;Ús‹Mô‰œxÿÿÿ‰”ÿÿÿA‰Mô;Æs‹]ü‹}‰uøéjþÿÿ‹}‹Eôƒè‰Eôˆ9þÿÿ‹”…xÿÿÿ‹„…ÿÿÿ‰Uü‰Eø‹Ú‹ðé;þÿÿjhÕBè·S‹]…ÛuÿuèoÑÿÿYéÌ‹u…öuSèÐÿÿYé·ƒ=`*C…“3ÿ‰}äƒþà‡ŠjèCY‰}üSè=DY‰Eà;Ç„ž;5P*CwIVSPèIƒÄ…Àt‰]äë5VèNPY‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè©ÃÿÿSèíC‰EàSPèDƒÄ9}äuH;÷u3öF‰uƒÆƒæð‰uVWÿ5(Cÿ€QB‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèUÃÿÿSÿuàèÆCƒÄÇEüþÿÿÿè.ƒ}àu1…öuFƒÆƒæð‰uVSjÿ5(Cÿ¨QB‹øë‹u‹]jè2AYË}ä…ÿ…¿9= Ct,VèÞVY…À…ÒþÿÿèF9}àul‹ðÿYÃjè®=YËÿU‹ìV‹ðë‹…ÀtÿЃÆ;urð^]ËÿU‹ìV‹u3Àë…Àu‹…ÉtÿуÆ;urì^]ËÿU‹ì‹MV3ö;Îuè”VVVVVÇè 
ƒÄjXë
¡ÜC;ÆtÚ‰3À^]ËÿU‹ì‹MV3ö;ÎuèXVVVVVÇèä	ƒÄjXë
¡ØC;ÆtÚ‰3À^]ËÿU‹ìƒ=„*Cth„*Cèa¸Y…Àt
ÿuÿ„*CY蘷hÌRBh´RBè)ÿÿÿYY…ÀuBh%lAè·¸¬RBÇ$°RBèëþÿÿƒ=ˆ*CYthˆ*Cè	¸Y…Àtjjjÿˆ*C3À]ÃjhÐÕBè¨MjèM=Yƒeü3ÛC9èC„ʼnäCŠE¢àCƒ}…ÿ5|*Cè4Y‹ø‰}Ø…ÿtxÿ5x*Cèü3Y‹ð‰u܉}ä‰uàƒî‰uÜ;÷rWèØ39tí;÷rJÿ6èÒ3‹øèÂ3‰ÿ×ÿ5|*Cè¼3‹øÿ5x*Cè¯3ƒÄ9}äu9Eàt‰}ä‰}؉Eà‹ð‰uÜ‹}ØëŸhàRB¸ÐRBèçýÿÿYhèRB¸äRBè×ýÿÿYÇEüþÿÿÿèƒ}u(‰èCjèc;Yÿuè„ýÿÿ3ÛCƒ}tjèJ;YÃèÎLËÿU‹ìjjÿuèÃþÿÿƒÄ]ËÿU‹ìjjÿuè­þÿÿƒÄ]ÃjjjèþÿÿƒÄÃjjjèŽþÿÿƒÄËÿVèÔ2‹ðVèTPVèÁVè?VèöÀVèZ¾VèX¹V蜷Vè…·hN¶@è&2ƒÄ$£ÌôB^ËÿU‹ìƒ=ôCuèÊOÿuèñMhÿè¯üÿÿYY]øMZf9@u6¡<@¸@PEu%¹f9ˆ@uƒ¸t@v3É9ˆè@•Á‹ÁÃ3ÀÃjXhðÕBètK3ö‰uüE˜Pÿ¼QBjþ_‰}ü¸MZf9@u8¡<@¸@PEu'¹f9ˆ@uƒ¸t@v3É9°è@•Á‰Mäë‰uä3ÛCSè{8Y…ÀujèÿÿÿYèî5…ÀujèÿÿÿYè)´‰]üèma…À}jègûÿÿYÿ¸QB£p*CèÄ£ìCèJÃ…À}jèAûÿÿYè²À…À}j	è0ûÿÿYSè`üÿÿY;ÆtPèûÿÿYè0À„]Ät·MÈëj
YQPVh@è“Žÿÿ‰Eà9uäuPè×ýÿÿèþýÿÿ‰}üë5‹Eì‹‹	‰MÜPQè¶YYËeè‹E܉Eàƒ}äuPèºýÿÿèÚýÿÿÇEüþÿÿÿ‹Eàë3À@ËeèÇEüþÿÿÿ¸ÿèHJÃè}ÄéxþÿÿU‹ìƒì‰}ü‰uø‹u‹}‹MÁéë›fofoNfoV fo^0ffOfW f_0fof@fonPfov`fo~pfg@foPfw`fp¶€¿€Iu£‹uø‹}ü‹å]ÃU‹ìƒì‰}ô‰uø‰]ü‹]‹Ã™‹È‹E3Ê+ʃá3Ê+Ê™‹ø3ú+úƒç3ú+ú‹Ñ×uJ‹u‹Îƒá‰Mè;ñt+ñVSPè'ÿÿÿƒÄ‹E‹Mè…Étw‹]‹UÓ+щUìØ+Ù‰]ð‹uì‹}ð‹Mèó¤‹EëS;Ïu5÷ÙƒÁ‰Mä‹u‹}‹Mäó¤‹MMä‹UUä‹E+EäPRQèLÿÿÿƒÄ‹Eë‹u‹}‹M‹ÑÁéó¥‹Êƒáó¤‹E‹]ü‹uø‹}ô‹å]ÃjhÖBè‚Hƒeüf(ÁÇEäë#‹Eì‹‹=Àt
=Àt3ÀÃ3À@ËeèƒeäÇEüþÿÿÿ‹Eäè„HËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+ÑtQ3À¢‰Eô‰]è‰Uì‰M𸢉Uü‰Eø[÷Eütè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£l*C3ÀÃU‹ìƒì‰}ü‹}‹MÁéfïÀë¤$ffGfG fG0fG@fGPfG`fGp¿€IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRjQè~ÿÿÿƒÄ‹E‹}ü‹å]ËÿU‹ìì(£C‰
üC‰øC‰ôC‰5ðC‰=ìCfŒCfŒ
CfŒèCfŒäCfŒ%àCfŒ-ÜCœC‹E£C‹E£CE£C‹…àüÿÿÇPC¡C£CÇøC	ÀÇüC¡€ñB‰…Øüÿÿ¡„ñB‰…ÜüÿÿÿÌQB£HCjè2ÁYjÿÈQBhô¹BÿÄQBƒ=HCujèÁYh	Àÿ„PBPÿÀQBÉËÿU‹ì‹E£
C]ËÿU‹ìì(¡€ñB3ʼnEüƒ¥ØüÿÿSjL…ÜüÿÿjP觹ÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…ØüÿÿÀÇ…Üüÿÿ‰…äüÿÿÿÌQBj‹ØÿÈQB…(ýÿÿPÿÄQB…Àu…Ûujèâ¿YhÀÿ„PBPÿÀQB‹Mü3Í[ècºÿÿÉËÿU‹ìVÿ5
CèB+ÿu‹ðè½*YY£
C‹Æ^]Ãÿ5
Cè!+YËÿU‹ì]é™þÿÿ‹ÿU‹ìÿ5
Cè+Y…Àt]ÿàjèd¿Y]ésþÿÿ3ÀPPPPPèÎÿÿÿƒÄËÿU‹ì]é¿ÿÿÿ‹ÿU‹ìè¿‹M‰]ËÿU‹ìè´‹M‰]ËÿU‹ìè©‹M‰]Ãj,h8ÖBèíC3Û‰]ȉ]Ô‰]ä‰]܉]؉]àjè~3Y‰]üèx‰EàEäPè}
Y;Ãt
SSSSSèÚýÿÿƒÄEÜPèð	Y;Ãt
SSSSSè¿ýÿÿƒÄEØPè
Y;Ãt
SSSSSè¤ýÿÿƒÄè0ȉẺÌ
CƒÏÿ‰=àôB‰=ÔôBhü¹Bè&ÀY‹ð‰uÄ;ót|8tx¡Ð
C;Ãt!PV耿YY…À„I¡Ð
C;ÃtP臿ÿÿYVèÀP@PèyOYY£Ð
C;ÄVVè£PY@Pÿ5Ð
Cè²NƒÄ;ÄSSSSSèüüÿÿƒÄéò¡Ð
C;Ãt
Pè)¿ÿÿY‰Ð
Ch 
CÿÔQB;Ç„Â3ÉA‰
Ì
C¡ 
CkÀ<‰Eäf9f
Ct‹t
CkÒ<‰Eäf9º
Ct¡È
C;Ãt‰MÜ+t
CkÀ<‰EØë‰]܉]ØEÐPSj?‹Eàÿ0Wh$
CSÿuÌ‹=ÐQBÿ×…Àt9]Ðu
‹Eà‹ˆX?ë‹Eà‹ˆEÐPSj?‹Eàÿpjÿhx
CSÿuÌÿ×…Àt9]Ðu‹Eà‹@ˆX?ë‹Eà‹@ˆÇEÔÿuäèÄýÿÿÿuÜèšýÿÿÿuØè£ýÿÿƒÄÇEüþÿÿÿèb9]Ô…íjVj@‹}àÿ7è)½ƒÄ…Àt
SSSSSè²ûÿÿƒÄƒÆ€>-uÇEÈFV苼YiÀ‰EäŠ<+t<0|<9Fëï3Û‹uÄjè0YÀ>:u8FVèV¼YkÀ<Eäë<9FŠ<0}õ€>:uFVè6¼YEäë<9FŠ<0}õ9]Èt÷]侉EÜ;Ãt#jVj@ÿwèz¼ƒÄ…ÀtSSSSSèûÿÿƒÄë‹Gˆ‹uäèn‰0‹uÜèX‰0èù@ËÿU‹ìƒìƒeüƒ}SVW‹}‹ð‹Ç…ù%€yHƒÈü@‰Eôu‹Çjd™[÷û…Òu‡l™»÷û…Òt
‹ÆÁà‹°ÀÿBë‹ÆÁà‹°ŒÿB‰E‡+™_ÿ¿÷ÿjd_Fj‰Eø‹Ã™÷ÿ‹Uø‹}+ЋÚGÿ™ƒâÂÁø‹×iÒmÆÄ%œÿÿ™[÷û‹EkÀ+ÂE;Utùëðƒ}…€ƒ}ôu‹Çjd™[÷û…Òu‡l™»÷û…Òt‹E‹€ÄÿBë	‹E‹€ÿB;ð~Dƒîë?%€yHƒÈü@u‹Çjd™[÷û…Òu‡l™»÷û…Òt	‹4µÀÿBë‹4µŒÿBukÉ<M kÉ<M$iÉèM(ƒ}u‰5ØôB‰
ÜôB‰=ÔôBëkEüP‰5äôB‰
èôBèžY…Àt3ÀPPPPPè2ùÿÿƒÄ‹EüiÀèèôByèôB\&ÿ
äôBë¸\&9èôB|)èôBÿäôB‰=àôB_^[ÉËÿU‹ìƒìVEü3öP‰uüèóY…Àt
VVVVVèÂøÿÿƒÄ9uüu3ÀéX‹WS3ÛC;ÔôBu;àôB„95Ì
C„¸·Æ
C·
À
CP·Ä
CP·Â
CPf95¸
Cu·¼
CVP·¾
CPRSë·¾
CPVVRV·º
CSèWýÿÿ·r
C·
l
CƒÄ$P·p
CP·n
CPf95d
Cu·h
CVP·j
CPÿwSë·j
CPVVÿwV·f
CVèúüÿÿƒÄ$ëTƒúkjXjYÇEô‰]ø}jX‹ËÇEô
ÇEøVVVVVQRSSjYè¼üÿÿ‹EôVVVVVÿuøÿwSVjYè¤üÿÿƒÄH‹
ØôB¡äôB;È‹W};Ñ|";Ð;Ñ~;Ð}‹Ã[^ÉÃ;Ð|ö;Ñò;Ð~;Ñ}3Àëè‹GkÀ<GkÀ<iÀè;Ñu
3É;ÜôBÁë3É;èôBœÁ‹Áë´jhXÖBèØ<3ö95Ô
Cu*jès,Y‰uü95Ô
Cuè½øÿÿÿÔ
CÇEüþÿÿÿèèä<ÃjèQ+YÃjhxÖBè‰<jè.,YƒeüèøÿÿÇEüþÿÿÿèè¬<Ãjè+YÃjh˜ÖBèQ<jèö+Yƒeü‹}èýÿÿ‰EäÇEüþÿÿÿè	‹Eäèk<ÃjèØ*YËÿU‹ìƒìV‹uW3ÿ‰}ü;÷uèøj^WWWWW‰0è…÷ÿÿƒÄ‹Æéj$hÿVèÛ¯ÿÿ‹EƒÄ;ÇtË‹‹@ƒøÿ‰Mð‰Eô|ù@Wÿÿsè©j^‰0뼃ø|
íùÏ&A“wåSWh€3áPQèn‹ÈƒÁF+™»÷ûyÿjd‰}ø‰M‹Ø‹Ç™_÷ÿjÿh“þÿÿ+Ø‹Eø™ƒâÂÁøDøAº‹Ú™RPèÀ+ÇÓj»€QSRPèlÀ‹}ðøUôƒ}ôM|…ÿsG‹EøÇ€3áƒUô‹ÈဉEyIƒÉüAu
jd™Y÷ù…Òu‹El™¹÷ù…ÒuAûƒUôë2‹E‹Èá€yIƒÉüAu
jd™Y÷ù…Òu‹El™¹÷ù…ÒuÇEü‹EjSÿuô‰FWèfjÿ‰F™h€®þÿRPè´¿øUôƒ}üºÿBuºÄÿB‹F3ÉA9B}
‹ØA9Š|ú»€QI‰N+Šj‰F‹ESÿpÿ0è
jƒÀY™÷ù3ÛShÿuôW‰Vèðjÿ‰F™hðñÿÿRPè>¿SøUôj<ÿuôWè͉FkÀ<+ø‰^ ‰>3À[_^ÉËÿU‹ìVèC‹ð…ötÿuVè£ýÿÿ÷ØÀY÷ÐY#Æ^]ËÿU‹ì‹EV3ö;Æuè•VVVVVÇè!õÿÿƒÄjXë
‹
ôôB‰3À^]ËÿU‹ì‹EV3ö;Æuè\VVVVVÇèèôÿÿƒÄjXë
‹
øôB‰3À^]ËÿU‹ì‹EV3ö;Æuè#VVVVVÇè¯ôÿÿƒÄjXë
‹
ðôB‰3À^]ËÿU‹ì‹ES3ÛV;Ãt:9]v:;ÃtˆW‹};ût‹E;Ãt@ƒøt;èÊj^SSSSS‰0èWôÿÿƒÄ‹ÆëU9]tÆèªj^SSSSS‰0è7ôÿÿƒÄ‹Æë64…€õBÿ6è?F@Y‰9]u3Àë;Evj"Xëÿ6ÿuÿuè8DƒÄ_^[]øôôBøøôBøðôBø€õBËÿU‹ì‹E3É;͈õBtAƒù-rñHíƒùwj
X]ËÍŒõB]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãè» …Àu¸ðöBÃÀÃè¨ …Àu¸ôöBÃÀËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ËÿU‹ìèm …ÀujX]ÃèŸÿÿÿ‹M‰3À]ËÿU‹ìV‹u3À;ðuPPPPPèóÿÿƒÄjXëèpÿÿÿ‹‰3À^]ËÿU‹ìè …ÀujX]Ãèbÿÿÿ‹M‰3À]ËÿU‹ìV‹u3À;ðuPPPPPèÉòÿÿƒÄjXëè3ÿÿÿ‹‰3À^]ÃWVS3ÿ‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$Àu‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ÓëA‹Ø‹L$‹T$‹D$ÑëÑÙÑêÑØÛuô÷ñ‹ð÷d$‹È‹D$÷æÑr;T$wr;D$vN3Ò‹ÆOu÷Ú÷؃Ú[^_ÂÌÌÌÌÌÌSW3ÿ‹D$À}G‹T$÷Ø÷ڃ؉D$‰T$‹D$À}‹T$÷Ø÷ڃ؉D$‰T$Àu‹L$‹D$3Ò÷ñ‹D$÷ñ‹Â3ÒOyNëS‹Ø‹L$‹T$‹D$ÑëÑÙÑêÑØÛuô÷ñ‹È÷d$‘÷d$Ñr;T$wr;D$v+D$T$+D$T$Oy÷Ú÷؃Ú_[‹ÿU‹ìQSV‹u3Û‰]ü;óuèœýÿÿj^SSSSS‰0è)ñÿÿƒÄ‹Æéýj$hÿVè©ÿÿ‹EƒÄ;ÃtË‹ù@Wÿÿ}è]ýÿÿj^‰0ëÌ‹Á™W¿€†÷ÿ‹ÐiÒ€àyøÊ…F¸€3á;È|+ÈB;È|+ȸ…âB;È|B+ÈëÇEü‹Á‰V™¿€Q÷ÿ¿ÿB‰FiÀ€®þÿÈ9]üu¿ÄÿB‹F3ÒB9G}
‹ØB9—|ú3ÛJ‰V+—¿€Q‰F‹E‹™÷ÿj_j<‰^ ƒÀ™÷ÿ‹Á¿‰V™÷ÿ_‰FiÀðñÿÿÈ‹Á™÷ÿ_‰FkÀ<+ȉ3À^[ÉËÿVè:‹ð…öuèoüÿÿÇ3À^Ã~Duj$èÑ@Y‰FD…ÀtÜ‹FD^ËÿU‹ìVè¾ÿÿÿ‹ð…ötÿuVè|þÿÿ÷ØÀY÷ÐY#Æ^]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌSV‹D$Àu‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ÓëA‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$vN3Ò‹Æ^[Â-¤t"ƒètƒè
tHt3ÀøøøøËÿVW‹ðh3ÿFWPèr§ÿÿ3À·È‹Á‰~‰~‰~ÁáÁ~«««¹÷BƒÄF+οŠˆ@Ou÷†¾Šˆ@Nu÷_^ËÿU‹ìì¡€ñB3ʼnEüSW…èúÿÿPÿvÿØQB¿…À„û3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj R详ÿÿƒÄCŠC„ÀuØjÿv…üúÿÿÿvPW…üþÿÿPjj躽3ÛSÿv…üýÿÿWPW…üþÿÿPWÿvSè›»ƒÄDSÿv…üüÿÿWPW…üþÿÿPhÿvSèv»ƒÄ$3À·ŒEüúÿÿöÁt€LŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒëÆ„@;Çr¾ëV†Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ÐZ ƒûw€LŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆA;Ïr‹Mü_3Í[èI§ÿÿÉÃjh¸ÖBè†1豋ø¡$üB…Gptƒlt‹wh…öuj èñáÿÿY‹Æèž1Ãj
èý Yƒeü‹wh‰uä;5(ûBt6…ötVÿàQB…Àuþ÷BtVè‘­ÿÿY¡(ûB‰Gh‹5(ûB‰uäVÿÜQBÇEüþÿÿÿè뎋uäj
èªYËÿU‹ìƒìS3ÛSMðèò©ÿÿ‰Ø
CƒþþuÇØ
CÿèQB8]ütE‹Møƒapýë<ƒþýuÇØ
CÿäQBëÛƒþüu‹Eð‹@ÇØ
CëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€ñB3ʼnEüS‹]V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé‰uä3À9¸0ûB„‘ÿEäƒÀ0=ðrçÿèý„pÿéý„d·ÇPÿìQB…À„REèPWÿØQB…À„3hCVPèÏ£ÿÿ3ÒBƒÄ‰{‰s9Uè†ø€}î„ÏuɄ¶Fÿ¶Éé¦hCVP舣ÿÿ‹MäƒÄkÉ0‰uà±@ûB‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€,ûBD;¶FG;øvê‹}FF€>uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇCègûÿÿj‰CC‰4ûBZf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L@;ÁvöFF€~ÿ…4ÿÿÿC¹þ€@Iuù‹Cèûÿÿ‰C‰Së‰s3À·È‹ÁÁáÁ{«««ë¨95Ø
C…XþÿÿƒÈÿ‹Mü_^3Í[èD¤ÿÿÉËÿU‹ìƒìjMð蓧ÿÿ‹Eôƒxt€}ü‹@t‹MøƒapýÉÀ}üt‹Eøƒ`pý3ÀÉÃjhØÖBèC.ƒMàÿèj‹ø‰}Üèžüÿÿ‹_h‹uè7ýÿÿ‰E;C„Wh è:Y‹Ø…Û„F¹ˆ‹wh‹ûó¥ƒ#SÿuèzýÿÿYY‰Eà…À…ü‹uÜÿvhÿàQB…Àu‹Fh=÷BtPè/ªÿÿY‰^hS‹=ÜQBÿ×öFp…êö$üB…Ýj
è@Yƒeü‹C£è
C‹C£ì
C‹C£ð
C3À‰Eäƒø}f‹LCf‰EÜ
C@ëè3À‰Eä=}
ŠLˆˆ ùB@ëé3À‰Eä=}ŠŒˆˆ(úB@ëæÿ5(ûBÿàQB…Àu¡(ûB=÷BtPèv©ÿÿY‰(ûBSÿ×ÇEüþÿÿÿèë0j
è¡YÃë%ƒøÿu û÷BtSè@©ÿÿYèÁôÿÿÇëƒeà‹Eàèû,Ã=€*CujýèVþÿÿYÇ€*C3Àád*Cøh*CËÿU‹ìSV‹u‹†¼3ÛW;Ãto=Cth‹†°;Ãt^9uZ‹†¸;Ãt9uP軨ÿÿÿ¶¼è…ÀYY‹†´;Ãt9uP蚨ÿÿÿ¶¼è"¾YYÿ¶°è‚¨ÿÿÿ¶¼èw¨ÿÿYY‹†À;ÃtD9u@‹†Ä-þPèV¨ÿÿ‹†Ì¿€+ÇPèC¨ÿÿ‹†Ð+ÇPè5¨ÿÿÿ¶Àè*¨ÿÿƒÄ¾Ô‹=ôBt9˜´uPè\»ÿ7è¨ÿÿYY~PÇEø(üBt‹;Ãt9uPèÞ§ÿÿY9_üt‹G;Ãt9uPèǧÿÿYƒÇÿMuÇV踧ÿÿY_^[]ËÿU‹ìSV‹5ÜQBW‹}WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{ø(üBt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒSV‹5àQBWÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{ø(üBt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ^[‹Ç_]ËÿV‹ñ…öt…Àt;ÆtWj6Y‹øó¥ƒ Pè¶þÿÿY_^Ã…ÿt7…Àt3V‹0;÷t(W‰8è›þÿÿY…ötVèÿÿÿƒ>Yuþ0üBtVè3ýÿÿY‹Ç^Ã3ÀÃjhøÖBèª)èÕ‹ð¡$üB…Fpt"ƒ~lt辋pl…öuj èÚÿÿY‹Æè½)ÃjèYƒeüFl‹=ýBèiÿÿÿ‰EäÇEüþÿÿÿèëÁjèÿY‹uäËÿU‹ìVWèd‹HpöÁjZ”ÂB‹ú‹Uƒúÿt:3ö;Öt;ƒút'ƒútèÿðÿÿVVVVVÇè‹äÿÿƒÄƒÈÿëƒáýëƒÉ‰Hpëƒ
$üBÿ‹Ç_^]áýB‹H‰
C‹H‰
C‹ˆ¨‰
ýB‹ˆÔ‰
ÈôB‹ˆ¼‰
<C‹ˆÈ‰
C‹€¬£@CÃjh×Bèw(‹u…ö„j
èYƒeü‹F…ÀtPÿàQB…Àu‹F=÷BtP认ÿÿYÇEüþÿÿÿè[ƒ>tCuW€~uQh\»BÿuÿµdÿÿÿèÜ.ƒÄ3ö…Àt
VVVVVè(ÝÿÿƒÄ;þt
3Àf‰f‰Gf‰G‹…`ÿÿÿ;Æt‰0‹…dÿÿÿéGVè{0¿ƒY‰…Pÿÿÿ;Çs,VÿµhÿÿÿèÿžYY…À„°VÿµXÿÿÿèéžYY…À„šƒ¥Lÿÿÿ…lÿÿÿVPè¼ûÿÿYY…À…å…lÿÿÿPSPèäÀƒÄ…À„Ì·C‹Tÿÿÿ‰…lÿÿÿPWÿµhÿÿÿè£üÿÿƒÄ€>t
‹…Pÿÿÿ;Çr‹…Lÿÿÿ¾$UB@PVWÿµXÿÿÿ蟃Ä…Àt3öVVVVVè&ÜÿÿƒÄë3ö9µ\ÿÿÿtjSÿµ\ÿÿÿèm’ÿÿƒÄ9µ`ÿÿÿtjÿµTÿÿÿÿµ`ÿÿÿèO’ÿÿƒÄÿµhÿÿÿÿuÿµdÿÿÿèu-ƒÄ…Àt
VVVVVèÃÛÿÿƒÄ‹…hÿÿÿë3À‹Mü_^3Í[è2—ÿÿÉËÿU‹ììÄ¡€ñB3ʼnEüSW‹Ùè
ÿu‹ø…hþÿÿP…PþÿÿPhƒ…xÿÿÿPSÇÐè†ýÿÿƒÄ…Àu3Àé‹EÁà0ÿsH…xÿÿÿPè\YY…À„x…xÿÿÿPè¦.ƒÀP‰…tþÿÿèW-YY‰…pþÿÿ…Àt°‹CH‹M‰…\þÿÿDŽƒÁkɉ…lþÿÿ‹‰…Xþÿÿ1jP‰…dþÿÿ…<þÿÿPè/‘ÿÿ‹FxÿÿÿQ‹tþÿÿ‰…Lþÿÿ‹…pþÿÿƒÁüƒÀQPèC,ƒÄ…Àt3ÀPPPPPèÚÿÿƒÄ‹…pþÿÿ‹lþÿÿƒÀ‰CH·…Pþÿÿ‰j…PþÿÿPÿµdþÿÿèÁÿÿƒÄƒ}…÷‹…hþÿÿƒ¥tþÿÿ‰F‹G$‹O ‰…dþÿÿ‹Ç‹V;t6‹ÿ…tþÿÿ‰‹dþÿÿ‰•Dþÿÿ‹P‰H‹DþÿÿƒÀƒ½tþÿÿ‰•dþÿÿ|Åë"‹…tþÿÿ…ÀtÇ‹‰‹P‰W‰‹dþÿÿ‰Hƒ½tþÿÿuhjÿv…xþÿÿÿvPjhȺBjj赪ƒÄ …Àt93À¹ÿf!ŒExþÿÿ@ƒøríhþÿ5 üB…xþÿÿPè4ÕƒÄ÷ØÀ@‰Gëƒg‹F‰‹G‰†¨ƒ}u	‹…hþÿÿ‰F‹EkÀVÿˆºBY…Àt1‹…\þÿÿÿµpþÿÿ‰CHèh›ÿÿ‹…XþÿÿY‹lþÿÿ‰‹…Lþÿÿ‰Fé°ýÿÿ½\þÿÿ(üBt-‹EƒÀÁà<0ÿ7ÿàQB…Àuÿ7è ›ÿÿÿsTè›ÿÿƒcLYY‹M‹…pþÿÿƒÁÁálj1‹CH‹Mü_3Í[è0”ÿÿÉËÿU‹ì옡€ñB3ʼnEü‹ESV3Û‹òW‰µhÿÿÿ;Ãt;ËtPèËüÿÿYéÓÁà‹D0HéÇÇ…pÿÿÿ‰tÿÿÿ;Ë„ª€9L…0€yC…&€y_…‹ùh`»BWèbê‹ØYY…Û„ÿ+lj…pÿÿÿ„ñ€;;„èÇ…lÿÿÿ¾ŒºBë‹…pÿÿÿPWÿ6èOÍÿÿƒÄ…Àuÿ6èQ+Y9…pÿÿÿtÿ…lÿÿÿƒÆþ¼ºB~ÉChT»BS軵‹ø3öYY;þu	€;;…ƒ½lÿÿÿQWS…xÿÿÿhƒPèÞ˜ƒÄ…Àt
VVVVVèg×ÿÿƒÄÿµlÿÿÿ‹µhÿÿÿxÿÿÿÆ„=xÿÿÿèžûÿÿY…Àtÿ…tÿÿÿû€?t
G€?…ÿÿÿ3À9…tÿÿÿ„‚‹µhÿÿÿëu3ÀëvSSShƒ…xÿÿÿPQè"ùÿÿƒÄ;ÃtZ~H…Ût3ÿ7…xÿÿÿPè™YY…ÀtSxÿÿÿè%ûÿÿY…Àu!…pÿÿÿëÿ…tÿÿÿCƒÇƒû~À3À9…pÿÿÿu9…tÿÿÿtèD÷ÿÿ‹Mü_^3Í[è’ÿÿÉËÿU‹ìƒ}VWw$ƒ}t3ÿGWjèõ(‹ðYY…öuè*äÿÿÇ3À_^]ÃWhØèÑ(YY‰…Àu	Vè~˜ÿÿYëÓWh èµ(YY‰F…Àuÿ6è`˜ÿÿVèZ˜ÿÿYëÙ‹¹0üBèÁñÿÿÿu‹M‹èUýÿÿY…Àuÿ6èñÿÿÿ6è0ïÿÿVè%˜ÿÿƒÄë2ÿv‹ÿpè1ëÿÿYY…Àt#ÿvè˜ÿÿÿ6èÛðÿÿÿ6èüîÿÿVèñ—ÿÿƒÄ3öë
‹F‰8‹F‰8‹Æé>ÿÿÿ‹ÿU‹ì]éÿÿÿjhh×BèR3Û‰]àƒ}vè9ãÿÿÇSSSSSèÅÖÿÿƒÄ3Àé,èS‹ð‰uäècñÿÿƒNp‰]üjhØè»'YY‹ø‰}Ü;û„ìjèœ
YÇEü‹Nl‹ÇèÄðÿÿ‰]üè¦ÿu‹M‹×èPüÿÿY‰Eà;Ĥ9]th(üBÿuèû–YY…Àt
Çô
Cjè@
YÇEü^l‹ÃèŽðÿÿWèÉïÿÿYöFpu2ö$üBu)‹;¸ýBèlðÿÿj¡ýBƒÀPhø
CèÛŠÿÿƒÄèmñÿÿƒeüèë-‹}Ü‹uä3ÛjèãYËuäjè×YÃëWè`ïÿÿWè‚íÿÿYYÇEüþÿÿÿè‹Eàè<ËuäƒfpïËÿU‹ìÿuÿ¬QB…Àu]é6Êÿÿ]ËÿU‹ìVÿ5ýB‹5ðQBÿÖ…Àt!¡ýBƒøÿtPÿ5ýBÿÖÿÐ…Àt‹€øë'¾t»BVÿ¬QB…ÀuVèåÉÿÿY…Àthd»BPÿ$QB…ÀtÿuÿЉE‹E^]Ãjè‡ÿÿÿYËÿU‹ìVÿ5ýB‹5ðQBÿÖ…Àt!¡ýBƒøÿtPÿ5ýBÿÖÿÐ…Àt‹€üë'¾t»BVÿ¬QB…ÀuVèjÉÿÿY…Àth»BPÿ$QB…ÀtÿuÿЉE‹E^]ÃÿôQB‹ÿU‹ìÿuÿ5ýBÿðQBÿÐ]¡ýBËÿVÿ5ýBÿðQB‹ð…öuÿ5CèEÿÿÿY‹ðVÿ5ýBÿøQB‹Æ^ËÿU‹ìÿuÿuÿ5 CèÿÿÿYÿÐ]¡ýBƒøÿtPÿ5$CèþþÿÿYÿЃ
ýBÿ¡ýBƒøÿtPÿüQBƒ
ýBÿé“jh ×Bè$¾t»BVÿ¬QB…ÀuVènÈÿÿY‰Eä‹uÇF\(ÂB3ÿG‰~…Àt$hd»BP‹$QBÿÓ‰†øh»BÿuäÿÓ‰†ü‰~pƆÈCƆKCÇFh÷Bj
è_YƒeüÿvhÿÜQBÇEüþÿÿÿè>jè>Y‰}ü‹E‰Fl…Àu¡ýB‰Flÿvlè2ìÿÿYÇEüþÿÿÿèè§Ã3ÿG‹uj
èYÃjèYËÿVWÿ…ÿtƒ~t
WÿÓWèèÿÿƒ&YƒÆþHþB|ܾ(ýB_‹…Àt	ƒ~uPÿÓƒÆþHþB|æ^[ËÿU‹ì‹Eÿ4Å(ýBÿœQB]Ãÿt$jÿRBhÿèýÁÿÿYÃjhð×Bè3ÿG‰}ä3Û9(CuèãjèhÿèÉÁÿÿYY‹u4õ(ýB9t‹Çënjè:Y‹ø;ûuèµØÿÿÇ3ÀëQj
èYY‰]ü9u,h Wè’…YY…ÀuWèþŒÿÿYèØÿÿÇ‰]äë‰>ëWèãŒÿÿYÇEüþÿÿÿè	‹Eäè£Ãj
èÿÿÿYËÿU‹ì‹EV4Å(ýBƒ>uPè"ÿÿÿY…Àujè½ÀÿÿYÿ6ÿ˜QB^]Ã=(Cu3Àá`*Cƒè÷ØÀ÷Ð#P*CËÿU‹ì‹EHÿVƒùþvèá×ÿÿ3öVVVVVÇèkËÿÿƒÄjXë3ö95(Cuè¸×ÿÿë×£ ýB3À^]ËÿU‹ì‹EV3ö;Æuè˜×ÿÿVVVVVÇè$ËÿÿƒÄjXë95(CtÛ‹
 ýB‰3À^]ËÿU‹ìh@jÿ5(Cÿ€QB£L*C…Àu]ËMƒ%€Cƒ%H*C£T*C3À‰
P*CÇX*C@]ËÿU‹ì‹
H*C¡L*CkÉÈë‹U+Púr	ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹uW‹þ+yƒÆüÁï‹ÏiÉŒD‰Mð‹I‰MüöÁ…ÓS1‹‰Uô‹Vü‰Uø‹Uô‰]öÂutÁúJƒú?vj?Z‹K;KuB»€ƒú s‹ÊÓëL÷Ó!\¸Dþ	u#‹M!ëJàÓëL÷Ó!œ¸Äþ	u‹M!Y‹]‹S‹[‹MüMô‰Z‹U‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô…+uø‹]øÁûj?‰uK^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M‹q;qu;¾€ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸ÄþLu‹M!q‹M‹q‹I‰N‹M‹q‹I‰N‹uë‹]ƒ}ôu;Ú„€‹MðÑ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€}u‹Ê»€Óë‹M	»€‹ÊÓëD¸D	ë)€}uJເÓë‹M	YJ຀ÓꄸÄ	‹Eü‰‰D0ü‹Eðÿ…ó¡€C…À„Ø‹
\*C‹5RBh@ÁáH»€SQÿÖ‹
\*C¡€Cº€Óê	P¡€C‹@‹
\*Cƒ¤ˆÄ¡€C‹@þHC¡€C‹H€yCu	ƒ`þ¡€CƒxÿueSjÿpÿÖ¡€Cÿpjÿ5(Cÿ|QB‹
H*C¡€CkÉ‹L*C+ÈLìQHQPèÅØ‹EƒÄÿ
H*C;€Cvƒm¡L*C£T*C‹E£€C‰=\*C[_^ÉáX*CV‹5H*CW3ÿ;ðu4ƒÀkÀPÿ5L*CWÿ5(Cÿ¨QB;Çu3ÀëxƒX*C‹5H*C£L*Ckö5L*ChÄAjÿ5(Cÿ€QB‰F;ÇtÇjh hWÿRB‰F;ÇuÿvWÿ5(Cÿ|QB뛃Nÿ‰>‰~ÿH*C‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ„0Dj?‰EøZ‰@‰@ƒÀJuôj‹ûhÁçyh€WÿRB…ÀuƒÈÿé—p‰Uü;úwC‹Ê+ÏÁéGAƒHøÿƒˆìÿü‰üïÿÿÇ@üð‰PÇ€èðIuË‹Uü‹EøøO‰H‰AJ‰H‰AƒdžD3ÿG‰¼žÄŠFCŠÈþÁ„À‹EˆNCu	xº€‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì‹M‹ASV‹uW‹}‹×+QƒÆÁê‹ÊiÉŒD‰Mô‹OüƒæðI;ñ|9ü‹‰M‰]üŽUöÃ…EÙ;ó;‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC»€ƒù sÓë‹MøL÷Ó!\Dþ	u&‹M!ëƒÁàÓë‹MøL÷Ó!œÄþ	u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}üŽ¥‹}ü‹MÁÿOL1üƒÿ?vj?_‹]ôû‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s€}u‹Ï»€Óë‹M	DD‹Ïë €}uOເÓë‹M	Y„ÄO຀Óê	‹U‹MüD2ü‰‰Lüë‹UF‰Bü‰D2øé<3Àé8/‹])uN‰Kü\3ü‹uÁþN‰]‰Küƒþ?vj?^öEü…€‹uüÁþNƒþ?vj?^‹O;OuB»€ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ëNàÓëL÷Ó!œÄþ	u‹M!Y‹]‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Môñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s€}u‹Î¿€Óï‹M	9DD‹Îë €}uNà¿€Óï‹M	y„ÄN຀Óê	‹E‰‰Dü3À@_^[Éá€C…À„¿‹
\*Ch@ÁáHh€QÿRB‹
\*C¡€Cº€Óê	P¡€C‹@‹
\*Cƒ¤ˆÄ¡€C‹@þHC¡€C‹H€yCu	ƒ`þ¡€CƒxÿuHƒ=H*C~?ÿpjÿ5(Cÿ|QB‹
H*C¡€CkÉ‹L*C+ÈLìQHQPè;ÓƒÄÿ
H*Cƒ%€CËÿU‹ì¡L*Cì8S3Û;ÃuƒÈÿé…9H*CV‹ÐW‰Ủ]äŽk‹B;Äg‹J‰MøˆD‰MÜ‹J°Ä‰Mà‰]ð‰]ì‰]ô‰uÈj@3À9]àY½Èþÿÿ‰]؉]è‰]ü󫌸9]ø„‹UøÂüƒºðÿÿÿ²ðÿÿ…ƒ:ÿ…‹‹ùöÁtIùåÿEüë‹ÁÁøHƒø?~j?X„…ÈþÿÿÿƒùŒÈöÁ…¿ùð³19xü…£‹ð;òrž…—ÂCƒûŒlÿÿÿ‹Eü‹}Ü9……3öƒeü_‹Cü‰}Ô‰]Ð;Ç„²‹Mü;ŒµÈþÿÿt‹Mø;Á‚dÁ€;ÁƒV‹ÈáðÿÿƒÁ‘ð;Ê„1;Èt‹ƒãþË‹]Ð;Êuî;Ê„‹ÁùIƒù?~j?Y;Î…‹MÔ9H…ýÿEü‰EÔ‹@;Ç…uÿÿÿƒ}üt!ƒþ ¸€}‹ÎÓè	EØ	EðëNàÓè	Eè	Eì‹EÔ9x…Å‹Mü;ŒµÈþÿÿ…µ9…©Fƒþ@‹ûŒÿÿÿ‹uÈ‹UÌ3Û‹EØ;F€…‘‹Eè;…†Eø€EÜÑeàÿEôƒÆƒ}ô ‰uÈŒîýÿÿ‹Eð;u_‹Eì;BuWƒÂÿEä‹Eä;H*C‰UÌŒ•ýÿÿ3À_^[ÉÃjþë6jüë2júë.jøë*jùë&jûë"j÷ëjõëjôëjóëjöëjñë
jòëjðëjïX뾋ÿU‹ìV3ö95(Cu3Àé•¡`*Cƒøu.‹E=øvè]ËÿÿVVVVVÇèé¾ÿÿƒÄëË£P*C3À@ë]W‹};þtBƒøuBÿøwWè¸óÿÿY…ÀuèËÿÿVVVVVÇ襾ÿÿƒÄë ‰=P*CÇ`*C3À@ë
èêÊÿÿÇ3À_^]ËÿU‹ìƒì¡H*C‹MkÀL*CƒÁƒáð‰MðÁùSIƒù VW}ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
T*C‹Ùë‹S‹;#Uø#þ×u
ƒÃ‰];Ørè;Øu‹L*Cë‹S‹;#Uø#þ×u
ƒÃ‰];Ùrè;Ùu[ëƒ{u
ƒÃ‰];Ørð;Øu1‹L*Cë	ƒ{u
ƒÃ‰];Ùrð;Ùuè@öÿÿ‹Ø‰]…Ûu3Àé	SèÚöÿÿY‹K‰‹Cƒ8ÿtå‰T*C‹C‹‰Uüƒúÿt‹ŒÄ‹|D#Mø#þÏu)ƒeü‹ÄHD‹9#Uø#þ×uÿEü‹‘„ƒÁëç‹Uü‹ÊiÉŒD‰Mô‹LD3ÿ#Îu‹ŒÄ#Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„‹J;Ju\ƒÿ »€}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]!ë,OàÓë‹MüŒˆÄ|8÷Ó!þ‰]ìu‹]‹Mì!Kë‹]ƒ}ø‹J‹z‰y‹J‹z‰y„‹Môñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆMþÁƒþ ˆL}#€}u¿€‹ÎÓï	;‹Î¿€Óï‹Mü	|ˆDë)€}u
Nà¿€Óï	{‹Mü¼ˆÄNྀÓî	7‹Mø…Ét‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu;€Cu‹Mü;
\*Cuƒ%€C‹Mü‰B_^[ÉÃÌÌhPAdÿ5‹D$‰l$l$+àSVW¡€ñB1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌ‹ƒøþt
‹OÎ30èAuÿÿ‹O‹GÎ30é1uÿÿÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹]V‹s35€ñBW‹ÆEÿÇEô{ƒøþt
‹NÏ38èìtÿÿ‹N‹FÏ38èÜtÿÿ‹Eö@f…‹MUè‰Sü‹[‰Eè‰Mìƒûþt_I[‹L†D†‰Eð‹‰Eø…Ét‹×è¸`ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿt$‹ƒøþt
‹NÏ38èitÿÿ‹N‹VÏ3:èYtÿÿ‹Eô_^[‹å]ÃÇEôëÉ‹M9csmàu)ƒ=@*Ct h@*Cè³hƒÄ…Àt‹UjRÿ@*CƒÄ‹Mè[`‹E9Xth€ñBW‹Ó‹Èè^`‹E‹Mø‰H‹ƒøþt
‹NÏ38èÖsÿÿ‹N‹VÏ3:èÆsÿÿ‹Eð‹H‹×èñ_ºþÿÿÿ9S„Rÿÿÿh€ñBW‹Ëè	`éÿÿÿ‹ÿU‹ìQQS‹]VW3ö3ÿ‰}ü;ýHþBt	G‰}üƒÿrîƒÿƒwjè,ÏYƒø„4jèÏY…Àu
ƒ=ÐôB„ûü„AhpÁB»S¿ˆCWè6	ƒÄ…Àt
VVVVVè„·ÿÿƒÄh¾¡CVjÆ¥
Cÿ”PB…Àu&hXÁBhûVèôƒÄ…Àt3ÀPPPPPè@·ÿÿƒÄVè»
@Yƒø·É¶ÒÁáÊ9MuHë·Ñ9Ut
@f¶·Éf;ËuÇ·É9Mu8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìjÿuÿuè2ÿÿÿƒÄ]ËÿU‹ì‹EVW…À|Y;8)CsQ‹ÈÁù‹ðƒæ<@)C‹Áæƒ<ÿu5ƒ=ÐôBS‹]uƒètHtHuSjôëSjõëSjöÿ\PB‹‰3À[ëè`¸ÿÿÇ	èh¸ÿÿƒ ƒÈÿ_^]ËÿU‹ì‹MS3Û;ËVW|[;
8)CsS‹ÁÁø‹ñ<…@)C‹ƒæÁæÆö@t5ƒ8ÿt0ƒ=ÐôBu+ËtItIuSjôëSjõëSjöÿ\PB‹ƒÿ3ÀëèÚ·ÿÿÇ	èâ·ÿÿ‰ƒÈÿ_^[]ËÿU‹ì‹EƒøþuèÆ·ÿÿƒ è«·ÿÿÇ	ƒÈÿ]ÃV3ö;Æ|";8)Cs‹ÈƒàÁù‹@)CÁàÁö@u$è…·ÿÿ‰0èk·ÿÿVVVVVÇ	è÷ªÿÿƒÄƒÈÿë‹^]ÃjhØBèKïÿÿ‹}‹ÇÁø‹÷ƒæÁæ4…@)CÇEä3Û9^u6j
èËÞÿÿY‰]ü9^uh FPèdYY…Àu‰]äÿFÇEüþÿÿÿè09]ät‹ÇÁøƒçÁç‹…@)CD8Pÿ˜QB‹EäèïÿÿÃ3Û‹}j
èsÝÿÿYËÿU‹ì‹E‹ÈƒàÁù‹@)CÁàDPÿœQB]Ãjh0ØBè„îÿÿƒMäÿ3ÿ‰}Üjè]ÝÿÿY…ÀuƒÈÿébjèÞÿÿY‰}ü‰}؃ÿ@<‹4½@)C…ö„º‰uà‹½@)C;ðƒ—öFu\ƒ~u9j
èÃÝÿÿY3ÛC‰]üƒ~uh FPèôbYY…Àu‰]ÜëÿFƒeüè(ƒ}Üu^Sÿ˜QBöFtSÿœQBƒÆ@ë‚‹}Ø‹uàj
èpÜÿÿYÃ}ÜuæÆFƒÿ+4½@)CÁþ‹ÇÁàð‰uäƒ}äÿuyGé+ÿÿÿj@j è3úÿÿYY‰Eà…Àta½@)C‰ƒ8)C ‹Â;ÂsÆ@ƒÿÆ@
ƒ`ƒÀ@‰EàëÝÁç‰}ä‹ÇÁø‹ÏƒáÁá‹…@)CÆDWèÆýÿÿY…ÀuƒMäÿÇEüþÿÿÿè	‹EäèEíÿÿÃjè²ÛÿÿYÃjhXØBèêìÿÿ3ÿ‰}ä2ÛöEt€Ã ÷E@t€Ë€öE€t€Ëÿuÿ”QB;Çuÿ%ÿƒøu€N@ë	ƒøu€Nh FPè_\YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ58)CÿpQB3Àë3À@ËeèÇEüþÿÿÿƒÈÿègçÿÿËÿVW¾@)C‹>…ÿt1‡ëƒt
GPÿRB‹ƒÇ@;ørâÿ6èUcÿÿƒ&YƒÆþ@*C|¾_^ËÿU‹ìV‹uVè9
Pè¹ÀYY…Àt|èmÿÿƒÀ ;ðu3ÀëèmÿÿƒÀ@;ðu`3À@ÿ´C÷FuNSW<…¨Cƒ?»u SèáòÿÿY‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N3À_@[ë3À^]ËÿU‹ìƒ}t'V‹u÷FtVè7fÿîÿÿƒfƒ&ƒfY^]ÃöA@tƒyt$ÿIx‹ˆÿ¶Àë¾ÀQPèáYYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìöG@SV‹ð‹Ùt2ƒu,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèl­ÿÿƒ8*u‹Ï°?èdÿÿÿƒ}Õ^[]ËÿU‹ì‹Eƒ‹‹@ü]ËÿU‹ì‹Eƒ‹‹Aø‹Qü]ËÿU‹ì‹Eƒ‹f‹@ü]ËÿU‹ììx¡€ñB3ʼnEüS‹]V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…ÈýÿÿèÔ]ÿÿ…öu5説ÿÿÇ3ÀPPPPPè4 ÿÿƒÄ€½°ýÿÿt
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF@u^Vèì
YºÿBƒøÿtƒøþt‹Èƒá‹ðÁþÁáµ@)Cë‹ÊöA$u‘ƒøÿtƒøþt‹ÈƒàÁùÁà@)Cë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu¡PÿB‰…äýÿÿ‹…äýÿÿëI€8t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ…\‹…ðýÿÿ¨@t2©t	Æ…Ôýÿÿ-ë¨t	Æ…Ôýÿÿ+ë¨tÆ…Ôýÿÿ Ç…Ðýÿÿ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿuÿµ´ýÿÿ…ØýÿÿSj è6õÿÿƒÄÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿè<õÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…ØýÿÿèôôÿÿƒÄƒ½Èýÿÿ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFè¹·ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôè·ôÿÿƒ½ ýÿÿYuµëƒØýÿÿÿë‹äýÿÿP…ØýÿÿèôÿÿYƒ½Øýÿÿ|ö…ðýÿÿtWSj …ØýÿÿèHôÿÿƒÄƒ½¼ýÿÿtÿµ¼ýÿÿèqVÿÿƒ¥¼ýÿÿY‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿt
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[ècOÿÿÉà !A!AQA¯AûA AL Az!A‹ÿU‹ì‹EV3ö;Æuèn¡ÿÿVVVVVÇèú”ÿÿƒÄƒÈÿë‹@^]Ãjh˜ØBèMÙÿÿ3ö‰uä3À‹};þ•À;Æu è,¡ÿÿÇVVVVV踔ÿÿƒÄƒÈÿéÌ3À9u•À;ÆtÔ‰}Wè:`ÿÿY‰uüöG@uwWèjÿÿÿYƒøÿtƒøþt‹ÐÁú‹ÈƒáÁá•@)Cë¹ÿBöA$u)ƒøÿtƒøþt‹ÈÁùƒàÁà@)Cë¸ÿBö@$€tè’ ÿÿÇVVVVVè”ÿÿƒÄƒMäÿ9uäu"Wè¦ñÿÿ‹ðÿuÿuÿuWÿU‰EäWVè)òÿÿƒÄÇEüþÿÿÿè	‹EäèŽØÿÿÃÿuèè_ÿÿYËÿU‹ìÿuÿuÿuÿuhAèÊþÿÿƒÄ]ËÿU‹ìÿuÿuÿuÿuhÛáAèªþÿÿƒÄ]ËÿU‹ìÿuÿuÿuÿuh‘ïAèŠþÿÿƒÄ]ËÿU‹ìÿujÿuÿuhAèkþÿÿƒÄ]ËÿU‹ìÿujÿuÿuhÛáAèLþÿÿƒÄ]ËÿU‹ìÿujÿuÿuh‘ïAè-þÿÿƒÄ]Ãjh¸ØBèu×ÿÿ3Û‰]äjèÇÿÿY‰]üj_‰}à;= :C}W‹÷Áæ¡Œ*CÆ9tD‹ö@ƒtPèdÿÿYƒøÿtÿEäƒÿ|(¡Œ*C‹ƒÀ PÿRB¡Œ*Cÿ4è|SÿÿY¡Œ*C‰GëžÇEüþÿÿÿè	‹Eäè1×ÿÿÃjèžÅÿÿYËÿU‹ìSV‹u‹F‹È€á3Û€ùu@©t9‹FW‹>+ø…ÿ~,WPVè#ýÿÿYPèc.ƒÄ;Çu‹F„Àyƒàý‰FëƒN ƒËÿ_‹Fƒf‰^‹Ã[]ËÿU‹ìV‹u…öu	Vè5Yë/Vè|ÿÿÿY…ÀtƒÈÿë÷F@tVèºüÿÿPèÐÕY÷ØYÀë3À^]ÃjhØØBè&Öÿÿ3ÿ‰}ä‰}ÜjèÃÅÿÿY‰}ü3ö‰uà;5 :Cƒ¡Œ*C°98t^‹ö@ƒtVPVè]]ÿÿYY3ÒB‰Uü¡Œ*C‹°‹HöÁƒt/9UuPèJÿÿÿYƒøÿtÿEäë9}uöÁtPè/ÿÿÿYƒøÿu	E܉}üèFë„3ÿ‹uà¡Œ*Cÿ4°Vèf]ÿÿYYÃÇEüþÿÿÿèƒ}‹Eät‹EÜè§ÕÿÿÃjèÄÿÿYÃjhÙBèLÕÿÿ3ö9uu	Vè
ÿÿÿYë'ÿuèi\ÿÿY‰uüÿuè®þÿÿY‰EäÇEüþÿÿÿè	‹EäèUÕÿÿÃÿuè¯\ÿÿYÃjèÌþÿÿYËÿU‹ìQV‹uVèaûÿÿ‰E‹FY¨‚uèÓœÿÿÇ	ƒN ƒÈÿé/¨@t
踜ÿÿÇ"ëãS3Û¨t‰^¨„‡‹Nƒàþ‰‰F‹FƒàïƒÈ‰F‰^‰]ü©u,èÜZÿÿƒÀ ;ðtèÐZÿÿƒÀ@;ðu
ÿuè^®Y…ÀuVèhÖY÷FW„€‹F‹>H‰‹N+øI;û‰N~WPÿuèä+ƒÄ‰EüëMƒÈ ‰FƒÈÿëy‹Mƒùÿtƒùþt‹Áƒà‹ÑÁúÁà•@)Cë¸ÿBö@ tjSSQèÔÔ#ƒÄƒøÿt%‹FŠMˆë3ÿGWEPÿuèu+ƒÄ‰Eü9}üt	ƒN ƒÈÿë‹E%ÿ_[^ÉËÿU‹ì‹9EuF‹jP;Mu+è2àÿÿYY‰…Àu3À]ËEÇÿ6ÿuÿ7èìCÿÿƒÄëQè àÿÿƒÄ…ÀtÕ‰Ñ&3À@]ËÿU‹ì‹E‹‹€¼]ËÿU‹ì¶EPèàwÿÿ…À¾EYuƒà߃è]ÃÿJx	‹
¶A‰
ÃRèÑ9YËÿU‹ìƒ}ÿt]éAÕ]ËÿU‹ìS‹UÿèÇÿÿÿ‹Øƒûÿt¶ÃPè‹xÿÿY…Àuá‹Ã[]ËÿU‹ììü¡€ñB3ʼnEü‹M‹EV3öW‹}‰þÿÿ|þÿÿ‰…dþÿÿ‰TþÿÿÇ…$þÿÿ^‰µ0þÿÿ‰µþÿÿ‰µxþÿÿ;þu èTšÿÿVVVVVÇèàÿÿƒÄƒÈÿé5;ÆtÜö@@SuzPè¦øÿÿYºÿBƒøÿtƒøþt‹Èƒá‹ØÁûÁá@)Cë‹ÊöA$u&ƒøÿtƒøþt‹ÈƒàÁùÁà@)Cë‹Âö@$€t èÏ™ÿÿVVVVVÇè[ÿÿƒÄƒÈÿé¯ÿuþÿÿèÇJÿÿŠÆ…cþÿÿ‰µtþÿÿ‰µ<þÿÿ„À„k‹µdþÿÿ¶ÀPèHwÿÿY…Àt0ÿtþÿÿVVµtþÿÿè…þÿÿYPèkþÿÿYYG¶PèwÿÿY…Àuñé©
Š<%…1
8G„
3ö‰µ@þÿÿÆ…/þÿÿ‰µXþÿÿ‰µLþÿÿ‰µlþÿÿÆ…aþÿÿÆ…`þÿÿÆ…jþÿÿÆ…SþÿÿÆ…bþÿÿÆ…sþÿÿÆ…kþÿÿ‰µ(þÿÿG¶¶ÃPè–uÿÿY…Àt‹…lþÿÿÿ…LþÿÿkÀ
DЉ…lþÿÿéŃûNƒ„¶ƒû*tpƒûF„¨ƒûItƒûLutþ…kþÿÿé“ŠO€ù6uG€84uÿ…(þÿÿ‹ø‰µ4þÿÿ‰µ8þÿÿëm€ù3uG€82u‹øë\€ùdtW€ùitR€ùotM€ùxtH€ùXuëAþ…jþÿÿë9ƒûht(ƒûlt
ƒûwtþ…Sþÿÿë"G€8lt—þ…kþÿÿþ…sþÿÿëþkþÿÿþsþÿÿ€½Sþÿÿ„þþÿÿ€½jþÿÿ‰½Hþÿÿu‹…þÿÿ‹0‰…þÿÿƒÀ‰…þÿÿë3ö2Û‰µDþÿÿ8sþÿÿuŠ]u	²]FÆEç ëfŠ•/þÿÿë^F<-uB„Òt>Š€ù]t7F:ÑsŠÁëŠÂŠÑ:Ðw"*ÂþÀ¶ú¶Ð‹Ïƒá‹Ç³ÒãÁèDÜGJuè2Òë¶ÈŠÐ‹Áƒá³ÁèÒãDÜŠ<]uœ„À„‰µHþÿÿ‹µDþÿÿé«ýÿÿƒ½xþÿÿ+u'ÿlþÿÿu…Ét³ë‹•dþÿÿÿ…tþÿÿèCõÿÿ‰…xþÿÿj0^9µxþÿÿ…x‹•dþÿÿÿ…tþÿÿèõÿÿ‰…xþÿÿëf‰>‹½Hþÿÿþ…cþÿÿG‰½Hþÿÿë`<%u
G€8%u‹øÿ…tþÿÿ‹Öè÷ðÿÿ‹Ø¶G‰xþÿÿ‰½Hþÿÿ;Ãul¶ÃPèY…Àt!ÿ…tþÿÿ‹ÖèÆðÿÿ¶G‰½Hþÿÿ;ÈuGÿtþÿÿƒ½xþÿÿÿu€?%uD‹…Hþÿÿ€xnu8‹øŠ„À…	òÿÿë*ÿµdþÿÿÿµxþÿÿèðÿÿYYëVSëóVPè€ðÿÿVSèyðÿÿƒÄƒ½0þÿÿuÿµTþÿÿèË?ÿÿYƒ½xþÿÿÿu*‹…<þÿÿ…Àu8…cþÿÿuƒÈÿ€½þÿÿt%‹þÿÿƒapý뀽þÿÿt
‹…þÿÿƒ`pý‹…<þÿÿ[‹Mü_3Í^è¶8ÿÿÉËÿU‹ì‹9EuF‹jP;Mu+è™ÏÿÿYY‰…Àu3À]ËEÇÿ6ÿuÿ7èS3ÿÿƒÄëQèÐÿÿƒÄ…ÀtÕ‰Ñ&3À@]ËÿU‹ì¶EPèYgÿÿ…À¾EYuƒà߃è]ÃÿJx	‹
¶A‰
ÃRèJ)YËÿU‹ìƒ}ÿt]éºÄ]ËÿU‹ìS‹UÿèÇÿÿÿ‹Øƒûÿt¶ÃPèhÿÿY…Àuá‹Ã[]ËÿU‹ìì¡€ñB3ʼnEü‹M‹EV3öW‹}‰ þÿÿ|þÿÿ‰…dþÿÿ‰½Tþÿÿ‰\þÿÿÇ…(þÿÿ^‰µ0þÿÿ‰µþÿÿ‰µxþÿÿ‰µþÿÿ;þu èÁ‰ÿÿVVVVVÇèM}ÿÿƒÄƒÈÿé;ÆtÜö@@SuzPèèÿÿYºÿBƒøÿtƒøþt‹Èƒá‹ØÁûÁá@)Cë‹ÊöA$u&ƒøÿtƒøþt‹ÈƒàÁùÁà@)Cë‹Âö@$€t è<‰ÿÿVVVVVÇèÈ|ÿÿƒÄƒÈÿé
ÿuþÿÿè4:ÿÿŠÆ…cþÿÿ‰µtþÿÿ‰µ<þÿÿ„À„ƶÀPè»fÿÿY…ÀtFÿµdþÿÿÿtþÿÿÿµdþÿÿµtþÿÿèuþÿÿYPè[þÿÿ‹µTþÿÿYYF¶Pè€fÿÿY…Àuñ‰µTþÿÿé`‹µTþÿÿŠ<%…Ì
8F„µ
3ÿ‰½8þÿÿÆ…/þÿÿ‰½Xþÿÿ‰½@þÿÿ‰½lþÿÿ‰½4þÿÿÆ…bþÿÿÆ…aþÿÿÆ…qþÿÿÆ…sþÿÿÆ…jþÿÿÆ…rþÿÿÆ…kþÿÿ‰½PþÿÿF¶¶ÃPèçdÿÿY…Àt‹…lþÿÿÿ…@þÿÿkÀ
DЉ…lþÿÿéŃûNƒ„¶ƒû*tpƒûF„¨ƒûItƒûLutþ…kþÿÿé“ŠN€ù6uF€84uÿ…Pþÿÿ‹ð‰½Hþÿÿ‰½Lþÿÿëm€ù3uF€82u‹ðë\€ùdtW€ùitR€ùotM€ùxtH€ùXuëAþ…qþÿÿë9ƒûht(ƒûlt
ƒûwtþ…sþÿÿë"F€8lt—þ…kþÿÿþ…rþÿÿëþkþÿÿþrþÿÿ€½sþÿÿ„þþÿÿ€½qþÿÿ‰µTþÿÿu‹… þÿÿ‹‰…þÿÿƒÀ‰… þÿÿë3Û€½rþÿÿ‰DþÿÿÆ…sþÿÿuŠƒÏ ‰½þÿÿƒÿntJƒÿctƒÿ{tÿµdþÿÿµtþÿÿèOüÿÿYë‹•dþÿÿÿ…tþÿÿèüÿÿ‰…xþÿÿƒøÿ„ç‹Dþÿÿ‹µTþÿÿ‹@þÿÿ…Ét
ƒ½lþÿÿ„,€½qþÿÿuAƒÿct
ƒÿstƒÿ{u2‹…þÿÿ‹ƒÀ‰…þÿÿƒÀ‰… þÿÿ‹@ü‰Dþÿÿ‰…4þÿÿƒø‚úƒÿo„ƒÿc„ƒÿd„Ž‹ƒÿg~Bƒÿit!ƒÿn…x€½qþÿÿ‹…tþÿÿ„°	éÚ
jd_ƒ½xþÿÿ-…PÆ…aþÿÿéM3Ûƒ½xþÿÿ-u‹…\þÿÿÆ-Cë	ƒ½xþÿÿ+uÿlþÿÿ‹•dþÿÿÿ…tþÿÿèñúÿÿ‰…xþÿÿƒ½@þÿÿuƒlþÿÿÿ¶…xþÿÿëk‹…lþÿÿÿlþÿÿ…ÀtfŠ…xþÿÿ‹\þÿÿÿ…Xþÿÿˆ…0þÿÿP…|þÿÿPCS½\þÿÿµ(þÿÿèúÿÿƒÄ…À„e‹•dþÿÿÿ…tþÿÿèpúÿÿ‰…xþÿÿ¶ÀPè©aÿÿY…ÀuŠ‹…þÿÿ‹€¼‹Šˆ…bþÿÿ:…xþÿÿ…å‹…lþÿÿÿlþÿÿ…À„Ñ‹•dþÿÿÿ…tþÿÿèúÿÿ‹\þÿÿ‰…xþÿÿŠ…bþÿÿˆ…0þÿÿP…|þÿÿPCS½\þÿÿµ(þÿÿèhùÿÿƒÄ…À„¸
¶…xþÿÿëk‹…lþÿÿÿlþÿÿ…Àtf‹…\þÿÿŠxþÿÿÿ…Xþÿÿˆ…0þÿÿP…|þÿÿPCS½\þÿÿµ(þÿÿèùÿÿƒÄ…À„^
‹•dþÿÿÿ…tþÿÿèiùÿÿ‰…xþÿÿ¶ÀPè¢`ÿÿY…ÀuŠƒ½Xþÿÿ„_ƒ½xþÿÿet
ƒ½xþÿÿE…I‹…lþÿÿÿlþÿÿ…À„5‹…\þÿÿÆe…0þÿÿP…|þÿÿPCS½\þÿÿµ(þÿÿè|øÿÿƒÄ…À„Ì	‹•dþÿÿÿ…tþÿÿè×øÿÿ‰…xþÿÿƒø-u,‹…\þÿÿÆ-…0þÿÿP…|þÿÿPCSè6øÿÿƒÄ…À„†	ë	ƒ½xþÿÿ+u/‹…lþÿÿÿlþÿÿ…Àu!…lþÿÿë‹•dþÿÿÿ…tþÿÿènøÿÿ‰…xþÿÿ¶…xþÿÿëk‹…lþÿÿÿlþÿÿ…Àtf‹…\þÿÿŠxþÿÿÿ…Xþÿÿˆ…0þÿÿP…|þÿÿPCS½\þÿÿµ(þÿÿè¢÷ÿÿƒÄ…À„ò‹•dþÿÿÿ…tþÿÿèý÷ÿÿ‰…xþÿÿ¶ÀPè6_ÿÿY…ÀuŠÿµdþÿÿÿtþÿÿÿµxþÿÿèè÷ÿÿƒ½XþÿÿYY„§€½qþÿÿ…L‹…\þÿÿÿ…<þÿÿþÿÿQPÿµDþÿÿƾ…kþÿÿHPÿ5tÿBè³ ÿÿYÿЃÄé…Éuÿ…lþÿÿÇ…@þÿÿ€½rþÿÿ~Æ…jþÿÿ‹µdþÿÿÿtþÿÿVÿµxþÿÿ‰PþÿÿèM÷ÿÿYYƒÿctÿ4þÿÿƒ½@þÿÿt‹…lþÿÿÿlþÿÿ…À„Bÿ…tþÿÿ‹Öè÷ÿÿ‰…xþÿÿƒøÿ„ƒÿctLƒÿsuƒø	|	ƒø
Žÿƒø u4ƒÿ{…ñ¾½bþÿÿ3ҋȃáBÓâ‹ÈÁù¾L
Ü3Ï‹½þÿÿ…Ñ„Æ€½qþÿÿ…®ƒ½4þÿÿ„)€½jþÿÿ„†ˆ…$þÿÿ¶ÀPè"Y…Àtÿ…tþÿÿ‹ÖèXöÿÿˆ…%þÿÿ…þÿÿP‹…þÿÿÇ…þÿÿ?ÿ°¬…$þÿÿP…þÿÿPèf¼f‹…þÿÿƒÄf‰CCé‹Çƒèp„‡ƒè„•þÿÿHH„}ƒè„¨úÿÿƒèt3¶;…xþÿÿ…Yþcþÿÿ€½qþÿÿ…X‹…þÿÿ‰… þÿÿéG€½rþÿÿ~Æ…jþÿÿF€>^uFÆ…bþÿÿÿj EÜjPè,ÿÿƒÄ€>]u	²]FÆEç ërŠ•/þÿÿëjF<-uH„ÒtDŠ€ù]t=F:ÑsŠÁëŠÂŠÑ:Ðw(*ÂþÀ¶ú¶Ð‹Ïƒá‹Ç³ÒãÁèDÜGJu苽þÿÿ2Ò닽þÿÿ¶ÈŠÐ‹Áƒá³ÁèÒãDÜŠ<]u„À„Ù‹Dþÿÿ‰µTþÿÿéýÿÿƒ½xþÿÿ+u,ÿlþÿÿu
…Ét	Æ…sþÿÿë‹•dþÿÿÿ…tþÿÿèµôÿÿ‰…xþÿÿƒ½xþÿÿ0…t‹•dþÿÿÿ…tþÿÿè‘ôÿÿ‰…xþÿÿ¶…xþÿÿPèšXÿÿY…À„œƒÿouƒ½xþÿÿ8Š‹…8þÿÿÁàë<‹…8þÿÿkÀ
ë1¶…xþÿÿPèàXÿÿY…ÀtbÿµxþÿÿÁ¥8þÿÿèÝðÿÿ‰…xþÿÿ‹…8þÿÿY‹xþÿÿÿ…Xþÿÿƒ½@þÿÿDЉ…8þÿÿtÿlþÿÿt5‹•dþÿÿÿ…tþÿÿè¸ðÿÿ‰…xþÿÿéDÿÿÿÿµdþÿÿÿtþÿÿÿµxþÿÿè¬ðÿÿYY€½aþÿÿ„¶þÿÿ‹…8þÿÿ÷Øé¯þÿÿ€½kþÿÿt‰ëf‰‹µTþÿÿþ…cþÿÿF‰µTþÿÿën<%u
F€8%u‹ð‹½dþÿÿÿ…tþÿÿ‹×è4ðÿÿ‹Ø¶F‰xþÿÿ‰µTþÿÿ;Ã…é¶ÃPèÉY…Àt%ÿ…tþÿÿ‹×èÿïÿÿ¶F‰µTþÿÿ;È…Àÿtþÿÿƒ½xþÿÿÿu€>%…¹‹…Tþÿÿ€xn…©‹ðŠ„À…Bñÿÿé˜ÿµdþÿÿÿµxþÿÿè¹ïÿÿYY退½rþÿÿ~3Àf‰ëÆèzÿÿÇë`ÿµdþÿÿÿµxþÿÿèïÿÿYYÇ…þÿÿëAè×yÿÿ€½jþÿÿÇt
‹Pþÿÿ3Àf‰ë ‹…PþÿÿÆëWSë…WPè<ïÿÿWSè5ïÿÿƒÄƒ½0þÿÿuÿµ\þÿÿè.ÿÿYƒ½xþÿÿÿu*‹…<þÿÿ…Àu8…cþÿÿuƒÈÿ€½þÿÿtH‹þÿÿƒapýë<ƒ½þÿÿuèEyÿÿÇ3ÀPPPPPèÏlÿÿƒÄ€½þÿÿt
‹…þÿÿƒ`pý‹…<þÿÿ[‹Mü_3Í^èÈ&ÿÿÉËÿU‹ìV‹uWVè3ÁÿÿYƒøÿtP¡@)Cƒþu	ö€„uƒþuö@DtjèÁÿÿj‹øèÿÀÿÿYY;ÇtVèóÀÿÿYPÿHQB…Àu
ÿ túŠ tújVhÂBèÒ¶ƒÄ…À…€ƒÆëF€> tú€>=upF€> tújhÂBVè µƒÄ…ÀuƒÆMëAjhÂBV赃Ä…ÀuƒÆMë!jhÂBVèà´ƒÄ…ÀuƒÆMëF€> tú8tè§hÿÿSSSSSÇè3\ÿÿƒÄëh€ÿuEðÿuÿuPèG²ƒÄ…Àt3Àë ‹Eÿ´C‹Mü‰H‹Mð‰X‰‰X‰X‰H_^[ÉÃjh`ÙBèH ÿÿ3Û3ÿ‰}äjèæÿÿY‰]ü3ö‰uà;5 :CÏ¡Œ*C°9t[‹‹@¨ƒuH©€uAFýƒøwFPèáŽÿÿY…À„™¡Œ*Cÿ4°VèW'ÿÿYY¡Œ*C‹°ö@ƒtPVè®'ÿÿYYFë‘‹ø‰}äëhÁæj8è$¬ÿÿY‹
Œ*C‰¡Œ*CÆ9tIh ‹ƒÀ Pè‡YY…À¡Œ*Cuÿ4èìÿÿY¡Œ*C‰ë‹ƒÀ Pÿ˜QB¡Œ*C‹<‰}ä‰_;ûtg€‰_‰_‰‰_ƒOÿÇEüþÿÿÿè‹ÇènŸÿÿË}äjèØÿÿYÃSVW‹T$‹D$‹L$URPQQh4dAdÿ5¡€ñB3ĉD$d‰%‹D$0‹X‹L$,3‹pƒþþt;‹T$4ƒúþt;òv.4v\³‹‰Hƒ{uÌh‹Cèjµ¹‹Cè|µë°dƒÄ_^[ËL$÷A¸t3‹D$‹H3Èè!ÿÿU‹hÿpÿpÿpè>ÿÿÿƒÄ]‹D$‹T$‰¸ÃU‹L$‹)ÿqÿqÿq(èÿÿÿƒÄ]ÂUVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹ÁjèÇ´3À3Û3É3Ò3ÿÿæU‹ìSVWjjhÛdAQèñÚ_^[]ÃU‹l$RQÿt$è´þÿÿƒÄ]‹ÿU‹ìƒì S3Û9]uè«eÿÿSSSSSÇè7YÿÿƒÄƒÈÿëN‹E;ÃtÜVÿu‰Eèÿu‰EàÿuEàPÇEäÿÿÿÇEìBèK¸ÿÿƒÄÿMä‹ðx‹EàˆëEàPSèWÈÿÿYY‹Æ^[ÉËÿU‹ìÿujÿuÿuèmÿÿÿƒÄ]ËÿU‹ìƒì V3ö9uuèeÿÿVVVVVÇèŸXÿÿƒÄƒÈÿë'ÿuEàÿuÇEäÿÿÿÿuÇEìBP‰uè‰uàÿUƒÄ^ÉËÿU‹ìÿujÿuhAè’ÿÿÿƒÄ]ËÿU‹ìÿuÿuÿuhAèuÿÿÿƒÄ]ËÿU‹ìÿujÿuh‘ïAèYÿÿÿƒÄ]ËÿU‹ìÿuÿuÿuh‘ïAè<ÿÿÿƒÄ]ËÿU‹ìƒì S3Û9]u èJdÿÿSSSSSÇèÖWÿÿƒÄƒÈÿé™V‹uW‹};ût!;óuèdÿÿSSSSSÇè¦WÿÿƒÄƒÈÿëj¸ÿÿÿ‰Eä;øw‰}äÿuEàÿuÇEìBÿu‰uèP‰uàÿUƒÄ‰E;ót4;Ã|"ÿMäx‹EàˆëEàPSè¿ÆÿÿYYƒøÿt‹Eë3À9]äˆ\>ÿÀHH_^[ÉËÿU‹ìÿujÿuÿuÿuhAèÿÿÿƒÄ…À}ƒÈÿ]ËÿU‹ìÿuÿuÿuÿuÿuhAèíþÿÿƒÄ…À}ƒÈÿ]ËÿU‹ìS3Û9]uè.cÿÿSSSSSÇèºVÿÿƒÄƒÈÿë[V‹u;ót9]w
ècÿÿÇë0ÿuÿuÿuÿuVhÛáAè†þÿÿƒÄ;Ã}ˆƒøþuèÒbÿÿÇ"SSSSSè^VÿÿƒÄƒÈÿ^[]ËÿU‹ìÿujÿuÿuÿuè`ÿÿÿƒÄ]ËÿU‹ìQS3Û9]u èˆbÿÿSSSSSÇèVÿÿƒÄƒÈÿéÖV‹uW9]u;óu9]u3Àéº;ót‹};ûwèCbÿÿÇéè3bÿÿÿuÿuÿu;}v-‹8‹E@PVhÛáAè´ýÿÿƒÄƒøþuLèbÿÿƒ8"ueèüaÿÿ‰8ë\‹WVhÛáA‰EüèˆýÿÿƒÄˆ\>ÿƒøþuƒ}ÿuèÐaÿÿƒ8"u/èÆaÿÿ‹Mü‰ë#;Ã}"ˆƒøþuè¯aÿÿÇ"SSSSSè;UÿÿƒÄƒÈÿ_^[ÉËÿU‹ìÿujÿuÿuÿuÿuèÞþÿÿƒÄ]ËÿU‹ìÿujÿuÿuÿuh‘ïAèøüÿÿƒÄ…À}ƒÈÿ]ËÿU‹ìÿuÿuÿuÿuÿuh‘ïAèÎüÿÿƒÄ…À}ƒÈÿ]ËÿU‹ìV‹uW3ÿ;÷uèaÿÿWWWWWÇè˜TÿÿƒÄé÷‹F¨ƒ„ì¨@…ä¨tƒÈ ‰FéՃȉF©u	VèØšYë‹F‰ÿvÿvVè)¿ÿÿYPèRµƒÄ‰F;Ç„‰ƒøÿ„€öF‚uOVèÿ¾ÿÿYƒøÿt.Vèó¾ÿÿYƒøþt"Vèç¾ÿÿÁøV<…@)Cè×¾ÿÿƒàYÁàYë¸ÿBŠ@$‚<‚uN ~u‹F¨t©uÇF‹ÿN¶A‰ë÷ØÀƒàƒÀ	F‰~ƒÈÿ_^]ËÿU‹ìQSVWÿ5|*Cè’~ÿÿÿ5x*C‹ø‰}üè‚~ÿÿ‹ðYY;÷‚ƒ‹Þ+ßCƒørwWè_µ‹øCY;øsH¸;øs‹ÇÇ;ÇrPÿuü蚤ÿÿYY…ÀuG;Çr@Pÿuü脤ÿÿYY…Àt1ÁûP4˜è}ÿÿY£|*Cÿuè}ÿÿ‰ƒÆVè„}ÿÿY£x*C‹EYë3À_^[ÉËÿVjj èî£ÿÿ‹ðVè]}ÿÿƒÄ£|*C£x*C…öujX^Ã&3À^Ãjh€ÙBè—ÿÿèÿGÿÿƒeüÿuèøþÿÿY‰EäÇEüþÿÿÿè	‹Eäè$—ÿÿÃèÞGÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸`ÔB¾`ÔBW‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸hÔB¾hÔBW‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·XÿBÿ6èŽ|ÿÿƒÇY‰ƒÿ(rè_^ÃÌÌÌÌ‹ÿU‹ì‹M¸MZf9t3À]ËA<Á8PEuï3Ò¹f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹}‹H;ùr	‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh ÙBhPAd¡PƒìSVW¡€ñB1Eø3ÅPEðd£‰eèÇEüh@è*ÿÿÿƒÄ…ÀtU‹E-@Ph@èPÿÿÿƒÄ…Àt;‹@$Áè÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò=À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]ÃjhÀÙBè÷”ÿÿè"~ÿÿ‹@x…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿè³è•ÿÿÃèõ}ÿÿ‹@|…ÀtÿÐé´ÿÿÿjhàÙBè«”ÿÿÿ5°CèG{ÿÿY…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿè}ÿÿÿÌh½mAè¡zÿÿY£°CÃËÿU‹ì‹E‹
ŒÿBV9t‹ñköuƒÀ;ÆríkÉM^;Ás9t3À]ËÿU‹ìQQVèâ|ÿÿ‹ð…ö„F‹V\¡ŒÿBW‹}‹ÊS99t‹ØkÛƒÁÚ;ËrîkÀÂ;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéûƒûuƒ`3À@éêƒû„Þ‹N`‰Mø‹M‰N`‹Hƒù…¸‹
€ÿB‹=„ÿB‹Ñù;×}$kÉ‹~\ƒd9‹=€ÿB‹„ÿBB߃Á;Ó|â‹]ü‹‹~d=ŽÀu	ÇFdƒë^=Àu	ÇFdëN=‘Àu	ÇFd„ë>=“Àu	ÇFd…ë.=Àu	ÇFd‚ë=Àu	ÇFd†ë=’ÀuÇFdŠÿvdjÿÓY‰~dëƒ`QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì¸csmà9Eu
ÿuPèˆþÿÿYY]Ã3À]ËÿU‹ì‹E£´C£¸C£¼C£ÀC]ÃjhÚB莒ÿÿ3ÿWè2‚ÿÿY‰}ü9}u¾´Cÿ5´Cèyÿÿ‰EäÇEà뾸Cÿ5¸Cèøxÿÿ‰EäÇEàY;ÇtƒøtèÖxÿÿ‰ÇEüþÿÿÿè9}äu3Àë3ÿWèÓ€ÿÿYÃ}ätÿuàÿUäY3À@èG’ÿÿ‹ÿU‹ì‹E‹
ŒÿBV9Pt‹ñköuƒÀ;ÆrìkÉM^;Ás9Pt3À]Ãÿ5¼CèdxÿÿYÃèæzÿÿƒÀdÃèÝzÿÿƒÀ`Ãjh ÚBè‘ÿÿƒeà‹u‹]ƒþ„âƒþ„Ùj_;ß„¿ƒû„¶ƒû„­ƒû„¤ƒû„›ƒûtƒût	ƒû…—èñyÿÿ‹ð…ö„ˆ¿(ÂB9~\u'ÿ5ˆÿBè‹ÿÿY‰F\…À„gÿ5ˆÿBWPè’ÿÿƒÄÿv\‹ÓèöþÿÿY…À„D‹P‹Mƒù„%ë‰HƒÀ‹=ŒÿBkÿ~\;ǃ	9Xtáéÿjè\€ÿÿYƒeü;ßtƒûu>ƒ=ÄCu5jh&pAÿQB3ÉA;Áu‰
ÄCëè‚Xÿÿ‹ðÿÿ5ÀCè¨vÿÿY‰Eä;÷t,Vèvÿÿ£ÀCëÿ5´CèˆvÿÿY‰Eä;÷tVèÿuÿÿ£´CYÇEüþÿÿÿèƒ}àu‹Uä‹ÂëB‹]jèd~ÿÿYÃût.ƒût)ƒû
t$ƒû~ƒû~èWÿÿÇ3ÀPPPPPèKÿÿƒÄƒÈÿè²ÿÿÃj h@ÚBè`ÿÿ3ÿ‰}ä‰}Ø‹]ƒûLt‹ÃjY+Át"+Át+Átd+ÁuDèëwÿÿ‹ø‰}Ø…ÿuƒÈÿéa¾´C¡´Cë`ÿw\‹Óèýÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+HtèçVÿÿÇ3ÀPPPPPèqJÿÿƒÄ뮾¼C¡¼C뾸C¡¸Cë
¾ÀC¡ÀCÇEäPèQuÿÿ‰EàY3Àƒ}à„Ø9EàujèBÿÿ9EätPè/~ÿÿY3À‰Eüƒût
ƒûtƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒƒûu.‹
€ÿB‰MÜ‹
„ÿB‹€ÿBÊ9MÜ}‹MÜkÉ‹W\‰DÿEÜëÛè¹tÿÿ‰ÇEüþÿÿÿèƒûuÿwdSÿUàYë‹]‹}؃}ätjè¥|ÿÿYÃSÿUàYƒût
ƒûtƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèŽÿÿËÿU‹ì‹E£ÈC]ËÿU‹ìQVWÿ5ÈCèAtÿÿ‹ø‹E3öY;Æuè€Uÿÿj_VVVVV‰8è
IÿÿƒÄ‹ÇéÇS‰0;þ…šh´ÂBÿ QB‰Eü;ÆuèEUÿÿj_VVVVV‰8èÒHÿÿƒÄ‹Çé‹h ÂBPÿ$QB‹ø;þu/èUÿÿ‹==Yt1jSè=–ÿÿYY‰…ÀtNVSPèE•ÿÿƒÄ…Àt3ÀPPPPPè‘CÿÿƒÄƒÇó€>u¹ÿ5ìCè½ÿÿƒ%ìCƒ'Çt*C3ÀY[_^Ãÿ5ÈCè—ÿÿƒ%ÈCƒÈÿëä‹ÿU‹ì‹E£ØC]ËÿU‹ìQ‹MS3ÀV‰‹ò‹UÇ9Et	‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰UŠ¶ÃPFè
¬Y…Àtÿƒ}t
‹MŠÿEˆF‹U‹M„Ût2ƒ}üu©€û t€û	uŸ…ÒtÆBÿƒeü€>„éŠ< t<	uFëóNëã€>„Ѓ}t	‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁuƒ}ütF€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰UŠ„ÀtUƒ}üu< tK<	tG…Ût=¾ÀP…Òt#è(«Y…Àt
Š‹MÿEˆFÿ‹MŠÿEˆë
è«Y…ÀtFÿÿ‹UFéVÿÿÿ…ÒtÆB‰Uÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒìS3ÛVW9€*Cuè£Zÿÿh¾àCVSˆäCÿ”PB¡p*C‰5ØC;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ=ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6Pè_“ÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄH£¼C‰5ÀC3ÀëƒÈÿ_^[ÉËÿU‹ì¡èCƒìSV‹5øPBW3Û3ÿ;Ãu.ÿÖ‹ø;ûtÇèCë#ÿÿÿƒÄ‹Æëg‹E‰;Ãt9]wëÕ9]uÐ;ÃtˆWÿuè+ÿÿÿ‹øY;ût9Wèöÿÿ@Y‰9]t*;Evj"Xë"WÿuÿuèôÿÿƒÄ…Àt
SSSSSèB<ÿÿƒÄ3À_^[]ËÿU‹ìQVW3ÿ;ßuèðIÿÿj^WWWWW‰0è}=ÿÿƒÄ‹Æëw‹E‰;;Çt‰89}tÕÿuè£þÿÿY‰Eü;ÇtUPèmÿÿ‹ðFjVè樃Ä‰;Çuè›IÿÿÇèIÿÿ‹ë)ÿuüVPèXÿÿƒÄ…Àt
WWWWWè¦;ÿÿƒÄ‹E;Çt‰03À_^ÉÃjh€ÚBè\ÿÿ3À3ö9u•À;Æuè@IÿÿÇVVVVVèÌ<ÿÿƒÄ3Àë>¿ÿWÿuè_ÿÿYY;ÇÀ÷ØtÌjè¿pÿÿY‰uüÿuèßýÿÿY‰EäÇEüþÿÿÿè	‹Eäè4ÿÿÃjè¡oÿÿYÃjh ÚBèÙ€ÿÿjè~pÿÿY3Û‰]ü3À‹};û•À;Ãuè°Hÿÿj^‰0SSSSSè=<ÿÿƒÄ‰uäëw‰‹M;Ët	9]w	;Ëu
9]u3À@ë3À;ÃtÂ;ËtˆÿuèJýÿÿY‹ð;ót=VèŽÿÿY@‰9]t.;Ev	ÇEä"ë#VÿuÿuèŒÿÿƒÄ;Ãt
SSSSSè]:ÿÿƒÄ‰]äÇEüþÿÿÿè	‹Eäè\€ÿÿÃjèÉnÿÿYÃjhÀÚBè€ÿÿjè¦oÿÿY3ö‰uü3À‹];Þ•À;ÆuèØGÿÿj_‰8VVVVVèe;ÿÿƒÄ‰}ä邉3‹E;Æt‰03À9u•À;ÆtÊÿuè€üÿÿY‰Eà;ÆtXPèJÿÿ‹øGjWèæƒÄ‰;ÆuèxGÿÿÇèmGÿÿ‹‰Eäë*ÿuàWPè2‹ÿÿƒÄ;Æt
VVVVVè€9ÿÿƒÄ‹E;Æt‰8‰uäÇEüþÿÿÿè	‹EäèvÿÿÃjèãmÿÿYËÿU‹ìƒìL¡€ñB3ʼnEüS3ÛV‹uW‰]Ô‰]ä‰]à‰]؉]܉u´‰]¸9^„F9u P·F0hPE´SPè.òÿÿƒÄ…À…Çjè1‹ÿÿj¿€W‰EÔèf‹ÿÿjW‰Eäè[‹ÿÿjW‰EàèP‹ÿÿjh‰EØèA‹ÿÿƒÄ$‰EÜ9]Ô„|9]ä„s;Äk9]à„b9]Ø„Y‹EÔ‰3À‹M܈@=|òEèPÿvÿØQB…À„/ƒ}è‡%·Eèƒø‰EÐ~-8]ît(EïŠ:Ët¶xÿ¶Éë‹MÜÆ ¶G;ù~ñ@@8XÿuÛ‹EäSSÿvPhÿu܉EÀjSè	ƒÄ …À„À‹Mà‹EÜSÿv¿ÿWÁQW@PhÿvSèЃÄ$…À„‹EØSÿvWP‹EÜW@PhÿvS裃Ä$…À„`‹Eä‹}àˆþ3Òƒ}Ðf‰‹U؉MÄ€ˆ_ˆZˆ‰M¼Š€‰MȈ~S8]îtNMï‰MäŠ:ÓtB¶Iÿ¶Ò;ʉMà'ŒHë‹MÌÿE຀f‰AA‰MÌ‹Mä¶	9Mà~â‹MäAA‰Mä8Yÿu¸hþˆQPèSíþÿj‡PWèDíþÿ‹EØjˆQPè2íþÿ‹†ÀƒÄ$;ÃtKPÿàQB…Àu@‹†Ä-þPèéøþÿ‹†Ì¿€+ÇPèÖøþÿ‹†Ð+ÇPèÈøþÿÿ¶Àè½øþÿƒÄ‹EÔlj†À‹EÀ‰†È‹Eĉ†Ä‹E¼‰†Ì‹Eȉ†Ð‹EЉ†¬ÿuÜèvøþÿY‹ÃëmÿuÔèiøþÿÿuäèaøþÿÿuàèYøþÿÿuØèQøþÿ3ÛƒÄCë˾À‹;ÃtPÿàQB‰‰žÄdžÈÈÃBdžÌPÈBdžÐÐÉBdž¬3À‹Mü_^3Í[è<ñþÿÉÃè°dÿÿ‹È‹Al;ýBt‹$üB…Qpuè­Qÿÿ‹€¬Ã‹ÿU‹ì‹E…Àu]éÅÿÿÿ‹‹€¬]Ãèkdÿÿ‹È‹Al;ýBt‹$üB…QpuèhQÿÿ‹@ÃèEdÿÿ‹È‹Al;ýBt‹$üB…QpuèBQÿÿ‹@Ãèdÿÿ‹È‹Al;ýBt‹$üB…QpuèQÿÿƒÀÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌ‹D$‹L$È‹L$u	‹D$÷áÂS÷á‹Ø‹D$÷d$Ø‹D$÷áÓ[‹ÿU‹ì‹MëI€8t@…ÉuõI‹E+ÁH]ËÿU‹ìƒì¡€ñB3ʼnEüSV3ÛW‹ñ9ìCu8SS3ÿGWhÄÂBhSÿäPB…Àt‰=ìCëÿWÿuôÿuÿujÿu ÿÖ…À„ã‹5äPBSSWÿuôÿuÿuÿ֋ȉMø;Ë„Â÷Et)9]„°;M§ÿuÿuWÿuôÿuÿuÿÖé;Ë~Ejà3ÒX÷ñƒør9D	=wèÕÿÿ‹ô;ótjÇÌ̃ÆëPèeöþÿY;Ãt	ÇÝ݃À‹ðë3ö;ótAÿuøVWÿuôÿuÿuÿäPB…Àt"SS9]uSSëÿuÿuÿuøVSÿu ÿÐQB‰EøVè¢ÿÿYÿuôè™ÿÿ‹EøYéY‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿu耟Y‰Eìƒøÿu3Àé!;E „ÛSSMQÿuPÿu 螟ƒÄ‰Eô;ÃtÔ‹5èPBSSÿuPÿuÿuÿÖ‰Eø;Ãu3öé·~=ƒøàw8ƒÀ=wè¿ÿþÿ‹ü;ûtÝÇÌ̃ÇëPèOõþÿY;Ãt	ÇÝ݃À‹øë3ÿ;ût´ÿuøSWèfëþÿƒÄÿuøWÿuÿuôÿuÿuÿÖ‰Eø;Ãu3öë%ÿuEøÿuPWÿu ÿuìèíž‹ð‰uðƒÄ÷Þö#uøWèwÿÿYëÿuÿuÿuÿuÿuÿuÿèPB‹ð9]ôt	ÿuôèaóþÿY‹Eð;Ãt9EtPèNóþÿY‹Æeà_^[‹Mü3Íè€ìþÿÉËÿU‹ìƒìÿuMðèÎïþÿÿu(Mðÿu$ÿu ÿuÿuÿuÿuÿuè(üÿÿƒÄ €}üt‹MøƒapýÉËÿU‹ìQQ¡€ñB3ʼnEü¡ðCSV3ÛW‹ù;Ãu:EøP3öFVhÄÂBVÿÜPB…Àt‰5ðCë4ÿÿuüEðSPèÀäÿÿø†„Pj?ÿuüEðSPè¨äÿÿø†ˆPj@ÿuüSEðPèäÿÿø†ŒPjAÿuüEðSPèxäÿÿƒÄPø†PjBÿuüEðSPè]äÿÿø†”PjCÿuüEðSPèEäÿÿø†˜Pj(ÿuüEðSPè-äÿÿø†œPj)ÿuüEðSPèäÿÿƒÄPø† PjÿuøEðSPèúãÿÿø†¤Pj ÿuøEðSPèâãÿÿø†¨PhÿuøEðSPèÇãÿÿø†°Ph	‹]øSEðjPèªãÿÿƒÄPø‹Ç_‰ž¬[ÉËÿU‹ìV‹u…ö„ÿvè•ìþÿÿvèìþÿÿvè…ìþÿÿvè}ìþÿÿvèuìþÿÿvèmìþÿÿ6èfìþÿÿv è^ìþÿÿv$èVìþÿÿv(èNìþÿÿv,èFìþÿÿv0è>ìþÿÿv4è6ìþÿÿvè.ìþÿÿv8è&ìþÿÿv<èìþÿƒÄ@ÿv@èìþÿÿvDèìþÿÿvHèìþÿÿvLèûëþÿÿvPèóëþÿÿvTèëëþÿÿvXèãëþÿÿv\èÛëþÿÿv`èÓëþÿÿvdèËëþÿÿvhèÃëþÿÿvlè»ëþÿÿvpè³ëþÿÿvtè«ëþÿÿvxè£ëþÿÿv|è›ëþÿƒÄ@ÿ¶€èëþÿÿ¶„è‚ëþÿÿ¶ˆèwëþÿÿ¶Œèlëþÿÿ¶èaëþÿÿ¶”èVëþÿÿ¶˜èKëþÿÿ¶œè@ëþÿÿ¶ è5ëþÿÿ¶¤è*ëþÿÿ¶¨èëþÿƒÄ,^]ËÿU‹ìSVW‹}ƒ »ôBt@h¸jè<{ÿÿ‹ðYY…öu3À@ëE‹Çèúÿÿ…ÀtVè+þÿÿVèÓêþÿYYëàdž´ë‹óÇÔ‹;Ãt´PÿàQB‰73À_^[]Ã2Ò8tSVŠ<0|<9,0ˆA8uí^[Ã<;uô‹ÁpŠˆ‹Æ8uóëä‹ÿU‹ìV‹u…öt5‹;CtPèPêþÿY‹F;CtPè>êþÿY‹v;5CtVè,êþÿY^]ËÿU‹ìƒìS‹]V3öW‰]è‰uì9su9su‰uü‰uøÇECé:j0jè2zÿÿ‹øYY‰};þu3À@éw‹³¼jYjó¥èÈyÿÿ3öY‰Eø;Æuÿuè¶éþÿYëщ09s„»jè¡yÿÿY‰Eü;Æu3öFÿuèŽéþÿÿuøè†éþÿYY‹Æé‰0‹u·{>VjWEèjPèPàÿÿ‰EôFPjWEèjPè;àÿÿ	EôFPjW‰EðEèjPè#àÿÿƒÄ<EôtVè½þÿÿYƒÎÿ뎋Eð‹ëŠ€ù0|€ù9
€é0ˆ@€8uéë7€ù;uó‹ð~Šˆ‹÷€>uòëâ‹
C‹E‰‹
C‰H‹
C‰uü‰H‹Eø3ÉA‰‹Eü…Àt‰‹ƒ´‹5àQB…ÀtPÿÖ‹ƒ°…ÀtPÿÖ…Àuÿ³°èèþÿÿ³¼è‚èþÿYY‹Eü‰ƒ´‹Eø‰ƒ°‹E‰ƒ¼3À_^[ÉÃ2Ò8tSVŠ<0|<9,0ˆA8uí^[Ã<;uô‹ÁpŠˆ‹Æ8uóëä‹ÿU‹ìV‹u…öt~‹F;CtPè
èþÿY‹F;CtPèûçþÿY‹F; CtPèéçþÿY‹F;$CtPè×çþÿY‹F;(CtPèÅçþÿY‹F ;,CtPè³çþÿY‹v$;50CtVè¡çþÿY^]ËÿU‹ìƒìSV‹uW3ÿ‰}ü‰uð‰}ô9~u9~u‰}ü‰}ø»Cé6j0jè¦wÿÿ‹ØYY;ßu3À@éujèJwÿÿY‰Eø;Çu	Sè<çþÿYëà‰89~„¹jè'wÿÿY‰Eü;ÇuSèçþÿÿuøèçþÿYëÒ‰8·v8CPjVEðjPèáÝÿÿ‹øCPjVEðjPèÍÝÿÿøCPjVEðjPè¹ÝÿÿøCPjVEðjPè¥ÝÿÿƒÄPøCPjVEðjPèŽÝÿÿøC PjPVEðjPèzÝÿÿøC$PjQVEðjPèfÝÿÿøC(PjVEðjPèRÝÿÿƒÄPøC)PjVjEðPè;ÝÿÿøC*PjTVEðjPè'ÝÿÿøC+PjUVEðjPèÝÿÿøC,PjVVEðjPèÿÜÿÿƒÄPøC-PjWVEðjPèèÜÿÿøC.PjRVEðjPèÔÜÿÿøC/PjSVEðjPèÀÜÿÿƒÄ<Çt$SèýÿÿSèÂåþÿÿuøèºåþÿÿuüè²åþÿƒÄéQþÿÿ‹C늀ù0|€ù9
€é0ˆ@€8uéë#€ù;uó‹ð~Šˆ‹÷€>uòëâjY¾C‹ûó¥‹E‹u¼‹‹	‰‹‹I‰K‹‹@‹Mø‰C3À@3ÿ‰9}üt‹Mü‰‹†¸;ÇtPÿàQB‹†°;Çt#PÿàQB…Àuÿ¶¼èåþÿÿ¶°èøäþÿYY‹Eü‰†¸‹Eø‰†°‰ž¼3À_^[ÉÃ3ÀÃèQÿÿ‹Hl;
ýBt‹
$üB…HpuèŽ>ÿÿ¡<CËÿU‹ì‹ES3ÛVW;Ãt‹};ûwè0ÿÿj^‰0SSSSSè¥#ÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèÑ/ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹uƒÉÿIƒÁŠ
Àt	ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ì3ÀS3Û@9]|FVW…Àt>‹EÙ+‹ð‹EÑþ<ðÿ7‹Eÿ0èìÀÿÿYY…Àu
‹MƒÇ‰9ë}N‰uë^;]~¾_^3É…À”Á[‹Á]ÃNÿØPB‰F‰FËÿU‹ìƒì¡€ñB3ʼnEüV‹ñ…ötS€>tNh´ÒBVè+ãÿÿYY…Àt=h°ÒBVèãÿÿYY…ÀujEôPjÿwÿÔPB…Àt/uôVèÄáÿÿY‹Mü3Í^èOÜþÿÉÃjEôPhÿwÿÔPB…Àu3Àë×Eôh¬ÒBPè¾âÿÿYY…Àu¹ÿäQB뻋ÿU‹ì3Àf‹Mf;ˆ˜ÒBt@@ƒørì3À@]Ã3À]ËÿV3öë#ŠÁ,aB<w€ÁÙëŠÁ,A<w€Áù¾ÁÁætЊ
„Éu׋Æ^Ã3ÀŠ
B€ùA|€ùZ~€éa€ùw@ëèËÿU‹ìƒì|¡€ñB3ʼnEüVW‹}èOÿÿ‹ð‹×Æœè†ÿÿÿ‹øjxE„P‹F÷ØÀ%ðÿÿPWÿÔPB…Àu!F@ë2E„Pÿvè1¿ÿÿYY…ÀuWèÿÿÿY…Àt
ƒN‰~‰~‹FÁè÷Ѓà‹Mü_3Í^èÛþÿÉ‹ÿU‹ìƒì|¡€ñB3ʼnEüVjxE„P‹E%ÿj
P‹ñÿÔPB…Àu3Àë.U„èØþÿÿ9Etƒ}t‹6W‹Öè÷þÿÿV‹øè§rÿÿY;ø_tÑ3À@‹Mü3Í^è˜ÚþÿÉËÿU‹ìƒì|¡€ñB3ʼnEüSVW‹}èôMÿÿ‹ð‹×Æœèyþÿÿ‹ÔPB‹øjxE„P‹F÷ØÀ%ðÿÿPWÿÓ…Àuƒf3À@ébE„Pÿvè¾ÿÿYY…À…‘jxE„P‹F÷ØÀ%ðÿÿPWÿÓ…Àt¿E„Pÿ6èè½ÿÿYY…ÀuN‰~ëRöFuO‹F…Àt,PE„Pÿ6èzŽƒÄ…Àuÿ6ƒN‰~è²qÿÿY;Fu!‰~ë‹VöÂuWè‰ýÿÿY…Àt	ƒÊ‰V‰~‹N¸#È;È„žjxE„P‹F÷ØÀ%ðÿÿPWÿÓ…À„ÿÿÿE„Pÿ6èA½ÿÿY3ÛY…Àu/N‹F9^t

‰FëG9^t;ÿ6èqÿÿY;Fu.jë9^u49^t/E„Pÿ6èõ¼ÿÿYY…ÀuSW‹ÎèëýÿÿYY…ÀtN9^u‰~‹FÁè÷Ѓà‹Mü_^3Í[èÈØþÿÉ‹ÿU‹ìƒì|¡€ñB3ʼnEüVW‹}è#Lÿÿ‹ð‹×Æœè¨üÿÿ‹øjxE„P‹F÷ØÀ%ðÿÿPWÿÔPB…Àu!F@ë[E„Pÿ6èT¼ÿÿYY…Àu	9Fu0jëƒ~u0ƒ~t*E„Pÿ6è.¼ÿÿYY…ÀuPW‹Îè$ýÿÿYY…Àt
ƒN‰~‰~‹FÁè÷Ѓà‹Mü_3Í^èØþÿÉÂÿvèöoÿÿƒè÷ØYÀj@hÓœA‰FÿÐPBöFuƒfÃÿ6èËoÿÿÿvƒè÷ØÀ@‰Fè¸oÿÿƒè÷ØÀƒf@ƒ~YY‰FtjXë‹èÝûÿÿjhßA‰FÿÐPB‹F©t©t¨uƒfÃÿ6èdoÿÿƒè÷ØÀ@Y‰FtjXë‹è’ûÿÿjh±ŸA‰FÿÐPBöFuƒfËÿU‹ìSVWè¢Jÿÿ‹]‹ðÆœ…ÛuNé½C@~‰‰…Àt€8tWjhàÑBè½ùÿÿƒÄ‹ƒf…ÀtS€8tN‹…Àt€8tèóþÿÿëèSÿÿÿƒ~…€Vj@hØÏBè}ùÿÿƒÄ…Àtb‹?…ÿt€?tè¾þÿÿëPèÿÿÿëI‹?…ÿt0€?t+Wèvnÿÿƒè÷ØYÀj@hÓœA‰FÿÐPBöFuƒfëÇFÿØPB‰F‰Fƒ~„ï‹Ëƒë€÷ÙÉ#Ë‹þènùÿÿ‹ø‰}…ÿ„Ðÿèý„Äÿéý„¸·ÇPÿìQB…À„¦jÿvÿÌPB…À„“‹E…Àtf‹Nf‰f‹Nf‰Hf‰x‹]…Ûtm‹=ÔPB¹f9u%h¸ÒBj@Sè·kÿÿƒÄ…Àt"3ÀPPPPPèÿÿƒÄëj@Shÿvÿ×…Àt,j@C@Phÿvÿ×…Àtj
jƒë€Sÿuè;‹ƒÄ3À@ë3À_^[]Ã…Àt
3É…ÀŸÁL	ÿ‹Áö¶	+Át
3É…ÀŸÁL	ÿ‹ÁÃf‹f;t5¶¶À+Ât3Ò…ÀŸÂTÿ‹Â…Àu¶F¶I+Át3É…ÀŸÁL	ÿ‹ÁÃ3ÀË;to¶¶À+Ât3Ò…ÀŸÂTÿ‹Â…ÀuV¶F¶Q+Ât3Ò…ÀŸÂTÿ‹Â…Àu9¶F¶Q+Ât3Ò…ÀŸÂTÿ‹Â…Àu¶F¶I+Át3É…ÀŸÁL	ÿ‹ÁÃ3ÀËÿVW‹øé^‹;tx¶ð¶+ðt3À…öŸÀDÿ…À…¶q¶B+ðt3À…öŸÀDÿ…À…ó¶q¶B+ðt3À…öŸÀDÿ…À…Ô¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…­‹A;Bty¶ð¶B+ðt3À…öŸÀDÿ…À…‡¶q¶B+ðt3À…öŸÀDÿ…À…h¶q¶B+ðt3À…öŸÀDÿ…À…I¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…"‹A;Bty¶ð¶B+ðt3À…öŸÀDÿ…À…ü¶q	¶B	+ðt3À…öŸÀDÿ…À…ݶq
¶B
+ðt3À…öŸÀDÿ…À…¾¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…—‹A;Bty¶ð¶B+ðt3À…öŸÀDÿ…À…q¶q
¶B
+ðt3À…öŸÀDÿ…À…R¶q¶B+ðt3À…öŸÀDÿ…À…3¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…‹A;Bty¶ð¶B+ðt3À…öŸÀDÿ…À…æ¶q¶B+ðt3À…öŸÀDÿ…À…Ƕq¶B+ðt3À…öŸÀDÿ…À…¨¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…‹A;Bty¶ð¶B+ðt3À…öŸÀDÿ…À…[¶q¶B+ðt3À…öŸÀDÿ…À…<¶q¶B+ðt3À…öŸÀDÿ…À…¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…ö‹A;Bty¶ð¶B+ðt3À…öŸÀDÿ…À…жq¶B+ðt3À…öŸÀDÿ…À…±¶q¶B+ðt3À…öŸÀDÿ…À…’¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…k‹A;Bty¶ð¶B+ðt3À…öŸÀDÿ…À…E¶q¶B+ðt3À…öŸÀDÿ…À…&¶q¶B+ðt3À…öŸÀDÿ…À…¶q¶B+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…àƒÁ ƒÂ ƒï ƒÿ ƒ™ûÿÿÏ׃ÿ‡¿ÿ$½(¸A‹Aä;Bätz¶Bä¶qä+ðt3À…öŸÀDÿ…À…“¶qå¶Bå+ðt3À…öŸÀDÿ…À…t¶qæ¶Bæ+ðt3À…öŸÀDÿ…À…U¶qç¶Bç+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À….‹Aè;Bèty¶ð¶Bè+ðt3À…öŸÀDÿ…À…¶qé¶Bé+ðt3À…öŸÀDÿ…À…é¶qê¶Bê+ðt3À…öŸÀDÿ…À…ʶqë¶Bë+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…£‹Aì;Bìty¶ð¶Bì+ðt3À…öŸÀDÿ…À…}¶qí¶Bí+ðt3À…öŸÀDÿ…À…^¶qî¶Bî+ðt3À…öŸÀDÿ…À…?¶qï¶Bï+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…‹Að;Bðty¶ð¶Bð+ðt3À…öŸÀDÿ…À…ò¶qñ¶Bñ+ðt3À…öŸÀDÿ…À…Ó¶qò¶Bò+ðt3À…öŸÀDÿ…À…´¶qó¶Bó+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…‹Aô;Bôty¶ð¶Bô+ðt3À…öŸÀDÿ…À…g¶qõ¶Bõ+ðt3À…öŸÀDÿ…À…H¶qö¶Bö+ðt3À…öŸÀDÿ…À…)¶q÷¶B÷+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…‹Aø;Bøty¶ð¶Bø+ðt3À…öŸÀDÿ…À…ܶqù¶Bù+ðt3À…öŸÀDÿ…À…½¶qú¶Bú+ðt3À…öŸÀDÿ…À…ž¶qû¶Bû+ðt
3À…öŸÀDÿ‹ð‹Æë3À…Àu{‹Aü;Bütk¶ð¶Bü+ðt3À…öŸÀDÿ…ÀuY¶qý¶Bý+ðt3À…öŸÀDÿ…Àu>¶qþ¶Bþ+ðt3À…öŸÀDÿ…Àu#¶Aÿ¶Jÿ+Át3É…ÀŸÁL	ÿ‹Áë3À…Àu3À_^ËAã;Bãtm¶ð¶Bã+ðt3À…öŸÀDÿ…ÀuÛ¶qä¶Bä+ðt3À…öŸÀDÿ…ÀuÀ¶qå¶Bå+ðt3À…öŸÀDÿ…Àu¥¶qæ¶Bæ+ðt
3À…öŸÀDÿ‹ð‹Æë3À…Àu‚‹Aç;Bçtz¶Bç¶qç+ðt3À…öŸÀDÿ…À…[ÿÿÿ¶qè¶Bè+ðt3À…öŸÀDÿ…À…<ÿÿÿ¶qé¶Bé+ðt3À…öŸÀDÿ…À…ÿÿÿ¶qê¶Bê+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…öþÿÿ‹Aë;Bëty¶ð¶Bë+ðt3À…öŸÀDÿ…À…Ðþÿÿ¶qì¶Bì+ðt3À…öŸÀDÿ…À…±þÿÿ¶qí¶Bí+ðt3À…öŸÀDÿ…À…’þÿÿ¶qî¶Bî+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…kþÿÿ‹Aï;Bïty¶ð¶Bï+ðt3À…öŸÀDÿ…À…Eþÿÿ¶qð¶Bð+ðt3À…öŸÀDÿ…À…&þÿÿ¶qñ¶Bñ+ðt3À…öŸÀDÿ…À…þÿÿ¶qò¶Bò+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…àýÿÿ‹Aó;Bóty¶ð¶Bó+ðt3À…öŸÀDÿ…À…ºýÿÿ¶qô¶Bô+ðt3À…öŸÀDÿ…À…›ýÿÿ¶qõ¶Bõ+ðt3À…öŸÀDÿ…À…|ýÿÿ¶qö¶Bö+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…Uýÿÿ‹A÷;B÷ty¶ð¶B÷+ðt3À…öŸÀDÿ…À…/ýÿÿ¶qø¶Bø+ðt3À…öŸÀDÿ…À…ýÿÿ¶qù¶Bù+ðt3À…öŸÀDÿ…À…ñüÿÿ¶qú¶Bú+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…Êüÿÿ‹Aû;Bûty¶ð¶Bû+ðt3À…öŸÀDÿ…À…¤üÿÿ¶qü¶Bü+ðt3À…öŸÀDÿ…À……üÿÿ¶qý¶Bý+ðt3À…öŸÀDÿ…À…füÿÿ¶qþ¶Bþ+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…?üÿÿ¶Aÿ¶Jÿ+Á„/üÿÿ3É…ÀŸÁL	ÿ‹Áéüÿÿ‹Aâ;Bâty¶ð¶Bâ+ðt3À…öŸÀDÿ…À…÷ûÿÿ¶qã¶Bã+ðt3À…öŸÀDÿ…À…Øûÿÿ¶qä¶Bä+ðt3À…öŸÀDÿ…À…¹ûÿÿ¶qå¶Bå+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…’ûÿÿ‹Aæ;Bætz¶Bæ¶qæ+ðt3À…öŸÀDÿ…À…kûÿÿ¶qç¶Bç+ðt3À…öŸÀDÿ…À…Lûÿÿ¶qè¶Bè+ðt3À…öŸÀDÿ…À…-ûÿÿ¶qé¶Bé+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…ûÿÿ‹Aê;Bêty¶ð¶Bê+ðt3À…öŸÀDÿ…À…àúÿÿ¶që¶Bë+ðt3À…öŸÀDÿ…À…Áúÿÿ¶qì¶Bì+ðt3À…öŸÀDÿ…À…¢úÿÿ¶qí¶Bí+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…{úÿÿ‹Aî;Bîty¶ð¶Bî+ðt3À…öŸÀDÿ…À…Uúÿÿ¶qï¶Bï+ðt3À…öŸÀDÿ…À…6úÿÿ¶qð¶Bð+ðt3À…öŸÀDÿ…À…úÿÿ¶qñ¶Bñ+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…ðùÿÿ‹Aò;Bòty¶ð¶Bò+ðt3À…öŸÀDÿ…À…Êùÿÿ¶qó¶Bó+ðt3À…öŸÀDÿ…À…«ùÿÿ¶qô¶Bô+ðt3À…öŸÀDÿ…À…Œùÿÿ¶qõ¶Bõ+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…eùÿÿ‹Aö;Böty¶ð¶Bö+ðt3À…öŸÀDÿ…À…?ùÿÿ¶q÷¶B÷+ðt3À…öŸÀDÿ…À… ùÿÿ¶qø¶Bø+ðt3À…öŸÀDÿ…À…ùÿÿ¶qù¶Bù+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…Úøÿÿ‹Aú;Búty¶ð¶Bú+ðt3À…öŸÀDÿ…À…´øÿÿ¶qû¶Bû+ðt3À…öŸÀDÿ…À…•øÿÿ¶qü¶Bü+ðt3À…öŸÀDÿ…À…vøÿÿ¶qý¶Bý+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…Oøÿÿf‹Aþf;Bþ„?øÿÿéí‹Aá;Bátz¶Bá¶qá+ðt3À…öŸÀDÿ…À…øÿÿ¶qâ¶Bâ+ðt3À…öŸÀDÿ…À…ö÷ÿÿ¶qã¶Bã+ðt3À…öŸÀDÿ…À…×÷ÿÿ¶qä¶Bä+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…°÷ÿÿ‹Aå;Båty¶ð¶Bå+ðt3À…öŸÀDÿ…À…Š÷ÿÿ¶qæ¶Bæ+ðt3À…öŸÀDÿ…À…k÷ÿÿ¶qç¶Bç+ðt3À…öŸÀDÿ…À…L÷ÿÿ¶qè¶Bè+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…%÷ÿÿ‹Aé;Béty¶ð¶Bé+ðt3À…öŸÀDÿ…À…ÿöÿÿ¶qê¶Bê+ðt3À…öŸÀDÿ…À…àöÿÿ¶që¶Bë+ðt3À…öŸÀDÿ…À…Áöÿÿ¶qì¶Bì+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…šöÿÿ‹Aí;Bíty¶ð¶Bí+ðt3À…öŸÀDÿ…À…töÿÿ¶qî¶Bî+ðt3À…öŸÀDÿ…À…Uöÿÿ¶qï¶Bï+ðt3À…öŸÀDÿ…À…6öÿÿ¶qð¶Bð+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…öÿÿ‹Añ;Bñty¶ð¶Bñ+ðt3À…öŸÀDÿ…À…éõÿÿ¶qò¶Bò+ðt3À…öŸÀDÿ…À…Êõÿÿ¶qó¶Bó+ðt3À…öŸÀDÿ…À…«õÿÿ¶qô¶Bô+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…„õÿÿ‹Aõ;Bõty¶ð¶Bõ+ðt3À…öŸÀDÿ…À…^õÿÿ¶qö¶Bö+ðt3À…öŸÀDÿ…À…?õÿÿ¶q÷¶B÷+ðt3À…öŸÀDÿ…À… õÿÿ¶qø¶Bø+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…ùôÿÿ‹Aù;Bùty¶ð¶Bù+ðt3À…öŸÀDÿ…À…Óôÿÿ¶qú¶Bú+ðt3À…öŸÀDÿ…À…´ôÿÿ¶qû¶Bû+ðt3À…öŸÀDÿ…À…•ôÿÿ¶qü¶Bü+ðt
3À…öŸÀDÿ‹ð‹Æë3À…À…nôÿÿ¶qý¶Bý+ðt3À…öŸÀDÿ…À…Oôÿÿ¶qþ¶Bþ+ð„øÿÿ3À…öŸÀDÿéè÷ÿÿIR¬A°A´Aæ·AÙ«AŠ¯Az³A[·AR«Aÿ®Aï²AжAǪAt®Ad²AE¶A<ªAé­AÙ±AºµA±©A^­AN±A/µA&©AÒ¬A°A¤´Aš¨AW¬A7°A´A‹ÿU‹ìVW‹}‹Çƒè„åH„ÍH„˜H„IH„¹‹M‹ESj Zér‹0;1t|¶0¶+ót3Û…öŸÃ\ÿ‹ó…ö…i¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…H¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…'¶p¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…ö…‹p;qt~¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…Ù¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…¸¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…—¶p¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…ö…r‹p;qt~¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…I¶p	¶Y	+ót3Û…öŸÃ\ÿ‹ó…ö…(¶p
¶Y
+ót3Û…öŸÃ\ÿ‹ó…ö…¶p¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…ö…â‹p;qt~¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…¹¶p
¶Y
+ót3Û…öŸÃ\ÿ‹ó…ö…˜¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…w¶p¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…ö…R‹p;qt~¶Y¶p+ót3Û…öŸÃ\ÿ‹ó…ö…)¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…ç¶p¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…ö…‹p;qt~¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…™¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…x¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…W¶p¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…ö…2‹p;qt~¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…	¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…è¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…ö…Ƕp¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…ö…¢‹p;qtr¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…öu}¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…öu`¶p¶Y+ót3Û…öŸÃ\ÿ‹ó…öuC¶p¶Y+ót3Û…öŸÃ\ÿ‹óë3ö…öu"ÂÊ+ú;úƒ†ûÿÿÇσÿ‡Úÿ$½¨ÎA‹Æé΋Pä;Qätq¶ò¶Qä+òt3Ò…öŸÂTÿ‹ò…öuÕ¶på¶Qå+òt3Ò…öŸÂTÿ‹ò…öu¸¶pæ¶Qæ+òt3Ò…öŸÂTÿ‹ò…öu›¶pç¶Qç+òt3Ò…öŸÂTÿ‹òë3ö…ö…vÿÿÿ‹Pè;Qèt}¶ò¶Qè+òt3Ò…öŸÂTÿ‹ò…ö…Nÿÿÿ¶pé¶Qé+òt3Ò…öŸÂTÿ‹ò…ö…-ÿÿÿ¶pê¶Qê+òt3Ò…öŸÂTÿ‹ò…ö…ÿÿÿ¶pë¶Që+òt3Ò…öŸÂTÿ‹òë3ö…ö…çþÿÿ‹Pì;Qìt}¶ò¶Qì+òt3Ò…öŸÂTÿ‹ò…ö…¿þÿÿ¶pí¶Qí+òt3Ò…öŸÂTÿ‹ò…ö…žþÿÿ¶pî¶Qî+òt3Ò…öŸÂTÿ‹ò…ö…}þÿÿ¶pï¶Qï+òt3Ò…öŸÂTÿ‹òë3ö…ö…Xþÿÿ‹Pð;Qðt}¶ò¶Qð+òt3Ò…öŸÂTÿ‹ò…ö…0þÿÿ¶pñ¶Qñ+òt3Ò…öŸÂTÿ‹ò…ö…þÿÿ¶pò¶Qò+òt3Ò…öŸÂTÿ‹ò…ö…îýÿÿ¶pó¶Qó+òt3Ò…öŸÂTÿ‹òë3ö…ö…Éýÿÿ‹Pô;Qôt~¶Qô¶pô+òt3Ò…öŸÂTÿ‹ò…ö… ýÿÿ¶põ¶Qõ+òt3Ò…öŸÂTÿ‹ò…ö…ýÿÿ¶pö¶Qö+òt3Ò…öŸÂTÿ‹ò…ö…^ýÿÿ¶p÷¶Q÷+òt3Ò…öŸÂTÿ‹òë3ö…ö…9ýÿÿ‹Pø;Qøt}¶ò¶Qø+òt3Ò…öŸÂTÿ‹ò…ö…ýÿÿ¶pù¶Qù+òt3Ò…öŸÂTÿ‹ò…ö…ðüÿÿ¶pú¶Qú+òt3Ò…öŸÂTÿ‹ò…ö…Ïüÿÿ¶pû¶Qû+òt3Ò…öŸÂTÿ‹òë3ö…ö…ªüÿÿ‹Pü;Qüto¶ò¶Qü+òt3Ò…öŸÂTÿ…Òu6¶pý¶Qý+òt3Ò…öŸÂTÿ…Òu¶pþ¶Qþ+òt3Ò…öŸÂTÿ…Òt‹Âë¶@ÿ¶Iÿ+Át3É…ÀŸÁL	ÿ‹Áë3À…Àu3À[éS
‹Pã;Qãt}¶ò¶Qã+òt3Ò…öŸÂTÿ‹ò…ö…ýûÿÿ¶pä¶Qä+òt3Ò…öŸÂTÿ‹ò…ö…Üûÿÿ¶på¶Qå+òt3Ò…öŸÂTÿ‹ò…ö…»ûÿÿ¶pæ¶Qæ+òt3Ò…öŸÂTÿ‹òë3ö…ö…–ûÿÿ‹Pç;Qçt}¶ò¶Qç+òt3Ò…öŸÂTÿ‹ò…ö…nûÿÿ¶pè¶Qè+òt3Ò…öŸÂTÿ‹ò…ö…Mûÿÿ¶pé¶Qé+òt3Ò…öŸÂTÿ‹ò…ö…,ûÿÿ¶pê¶Qê+òt3Ò…öŸÂTÿ‹òë3ö…ö…ûÿÿ‹Pë;Qët}¶ò¶Që+òt3Ò…öŸÂTÿ‹ò…ö…ßúÿÿ¶pì¶Qì+òt3Ò…öŸÂTÿ‹ò…ö…¾úÿÿ¶pí¶Qí+òt3Ò…öŸÂTÿ‹ò…ö…úÿÿ¶pî¶Qî+òt3Ò…öŸÂTÿ‹òë3ö…ö…xúÿÿ‹Pï;Qït}¶ò¶Qï+òt3Ò…öŸÂTÿ‹ò…ö…Púÿÿ¶pð¶Qð+òt3Ò…öŸÂTÿ‹ò…ö…/úÿÿ¶pñ¶Qñ+òt3Ò…öŸÂTÿ‹ò…ö…úÿÿ¶pò¶Qò+òt3Ò…öŸÂTÿ‹òë3ö…ö…éùÿÿ‹Pó;Qót}¶ò¶Qó+òt3Ò…öŸÂTÿ‹ò…ö…Áùÿÿ¶pô¶Qô+òt3Ò…öŸÂTÿ‹ò…ö… ùÿÿ¶põ¶Qõ+òt3Ò…öŸÂTÿ‹ò…ö…ùÿÿ¶pö¶Qö+òt3Ò…öŸÂTÿ‹òë3ö…ö…Zùÿÿ‹P÷;Q÷t~¶Q÷¶p÷+òt3Ò…öŸÂTÿ‹ò…ö…1ùÿÿ¶pø¶Qø+òt3Ò…öŸÂTÿ‹ò…ö…ùÿÿ¶pù¶Qù+òt3Ò…öŸÂTÿ‹ò…ö…ïøÿÿ¶pú¶Qú+òt3Ò…öŸÂTÿ‹òë3ö…ö…Êøÿÿ‹Pû;Qût}¶ò¶Qû+òt3Ò…öŸÂTÿ‹ò…ö…¢øÿÿ¶pü¶Qü+òt3Ò…öŸÂTÿ‹ò…ö…øÿÿ¶pý¶Qý+òt3Ò…öŸÂTÿ‹ò…ö…`øÿÿ¶pþ¶Qþ+òt3Ò…öŸÂTÿ‹òë3ö…ö…;øÿÿ¶Iÿ¶@ÿ+Á„üÿÿ3É…ÀŸÁL	ÿ‹Áéîûÿÿ‹Pâ;Qât}¶ò¶Qâ+òt3Ò…öŸÂTÿ‹ò…ö…ñ÷ÿÿ¶pã¶Qã+òt3Ò…öŸÂTÿ‹ò…ö…Ð÷ÿÿ¶pä¶Qä+òt3Ò…öŸÂTÿ‹ò…ö…¯÷ÿÿ¶på¶Qå+òt3Ò…öŸÂTÿ‹òë3ö…ö…Š÷ÿÿ‹Pæ;Qæt}¶ò¶Qæ+òt3Ò…öŸÂTÿ‹ò…ö…b÷ÿÿ¶pç¶Qç+òt3Ò…öŸÂTÿ‹ò…ö…A÷ÿÿ¶pè¶Qè+òt3Ò…öŸÂTÿ‹ò…ö… ÷ÿÿ¶pé¶Qé+òt3Ò…öŸÂTÿ‹òë3ö…ö…ûöÿÿ‹Pê;Qêt}¶ò¶Qê+òt3Ò…öŸÂTÿ‹ò…ö…Óöÿÿ¶pë¶Që+òt3Ò…öŸÂTÿ‹ò…ö…²öÿÿ¶pì¶Qì+òt3Ò…öŸÂTÿ‹ò…ö…‘öÿÿ¶pí¶Qí+òt3Ò…öŸÂTÿ‹òë3ö…ö…löÿÿ‹Pî;Qît}¶ò¶Qî+òt3Ò…öŸÂTÿ‹ò…ö…Döÿÿ¶pï¶Qï+òt3Ò…öŸÂTÿ‹ò…ö…#öÿÿ¶pð¶Qð+òt3Ò…öŸÂTÿ‹ò…ö…öÿÿ¶pñ¶Qñ+òt3Ò…öŸÂTÿ‹òë3ö…ö…Ýõÿÿ‹Pò;Qòt}¶ò¶Qò+òt3Ò…öŸÂTÿ‹ò…ö…µõÿÿ¶pó¶Qó+òt3Ò…öŸÂTÿ‹ò…ö…”õÿÿ¶pô¶Qô+òt3Ò…öŸÂTÿ‹ò…ö…sõÿÿ¶põ¶Qõ+òt3Ò…öŸÂTÿ‹òë3ö…ö…Nõÿÿ‹Pö;Qöt~¶Qö¶pö+òt3Ò…öŸÂTÿ‹ò…ö…%õÿÿ¶Q÷¶p÷+òt3Ò…öŸÂTÿ‹ò…ö…õÿÿ¶Qø¶pø+òt3Ò…öŸÂTÿ‹ò…ö…ãôÿÿ¶Qù¶pù+òt3Ò…öŸÂTÿ‹òë3ö…ö…¾ôÿÿ‹Pú;Qút}¶ò¶Qú+òt3Ò…öŸÂTÿ‹ò…ö…–ôÿÿ¶pû¶Qû+òt3Ò…öŸÂTÿ‹ò…ö…uôÿÿ¶pü¶Qü+òt3Ò…öŸÂTÿ‹ò…ö…Tôÿÿ¶pý¶Qý+òt3Ò…öŸÂTÿ‹òë3ö…ö…/ôÿÿf‹Pþf;Qþ„ô÷ÿÿ¶Qþ¶pþ+ò„Öûÿÿ3Ò…öŸÂTÿ…Ò…é¾ûÿÿ‹Pá;Qát~¶Qá¶pá+òt3Ò…öŸÂTÿ‹ò…ö…Ðóÿÿ¶pâ¶Qâ+òt3Ò…öŸÂTÿ‹ò…ö…¯óÿÿ¶pã¶Qã+òt3Ò…öŸÂTÿ‹ò…ö…Žóÿÿ¶pä¶Qä+òt3Ò…öŸÂTÿ‹òë3ö…ö…ióÿÿ‹På;Qåt}¶ò¶Qå+òt3Ò…öŸÂTÿ‹ò…ö…Aóÿÿ¶pæ¶Qæ+òt3Ò…öŸÂTÿ‹ò…ö… óÿÿ¶pç¶Qç+òt3Ò…öŸÂTÿ‹ò…ö…ÿòÿÿ¶pè¶Qè+òt3Ò…öŸÂTÿ‹òë3ö…ö…Úòÿÿ‹Pé;Qét}¶ò¶Qé+òt3Ò…öŸÂTÿ‹ò…ö…²òÿÿ¶pê¶Qê+òt3Ò…öŸÂTÿ‹ò…ö…‘òÿÿ¶pë¶Që+òt3Ò…öŸÂTÿ‹ò…ö…pòÿÿ¶pì¶Qì+òt3Ò…öŸÂTÿ‹òë3ö…ö…Kòÿÿ‹Pí;Qít}¶ò¶Qí+òt3Ò…öŸÂTÿ‹ò…ö…#òÿÿ¶pî¶Qî+òt3Ò…öŸÂTÿ‹ò…ö…òÿÿ¶pï¶Qï+òt3Ò…öŸÂTÿ‹ò…ö…áñÿÿ¶pð¶Qð+òt3Ò…öŸÂTÿ‹òë3ö…ö…¼ñÿÿ‹Pñ;Qñt~¶Qñ¶pñ+òt3Ò…öŸÂTÿ‹ò…ö…“ñÿÿ¶pò¶Qò+òt3Ò…öŸÂTÿ‹ò…ö…rñÿÿ¶pó¶Qó+òt3Ò…öŸÂTÿ‹ò…ö…Qñÿÿ¶pô¶Qô+òt3Ò…öŸÂTÿ‹òë3ö…ö…,ñÿÿ‹Põ;Qõt}¶ò¶Qõ+òt3Ò…öŸÂTÿ‹ò…ö…ñÿÿ¶pö¶Qö+òt3Ò…öŸÂTÿ‹ò…ö…ãðÿÿ¶p÷¶Q÷+òt3Ò…öŸÂTÿ‹ò…ö…Âðÿÿ¶pø¶Qø+òt3Ò…öŸÂTÿ‹òë3ö…ö…ðÿÿ‹Pù;Qùt}¶ò¶Qù+òt3Ò…öŸÂTÿ‹ò…ö…uðÿÿ¶pú¶Qú+òt3Ò…öŸÂTÿ‹ò…ö…Tðÿÿ¶pû¶Qû+òt3Ò…öŸÂTÿ‹ò…ö…3ðÿÿ¶pü¶Qü+òt3Ò…öŸÂTÿ‹òë3ö…ö…ðÿÿ¶pý¶Qý+ò„Ýûÿÿ3Ò…öŸÂTÿ…Ò„Êûÿÿ‹Âé¹óÿÿ‹M‹u¶¶+Ât3Ò…ÀŸÂTÿ‹Â…À…í¶A¶V+Ât3Ò…ÀŸÂTÿ‹Â…À…̶A¶V+Ât3Ò…ÀŸÂTÿ‹Â…À…«¶A¶N+Á„›3É…ÀŸÁL	ÿ‹Á鉋M‹u¶¶+Ât3Ò…ÀŸÂTÿ‹Â…Àuh¶A¶V+Ât3Ò…ÀŸÂTÿ‹Â…ÀuK¶A¶Nëž‹M‹u¶¶+Ât3Ò…ÀŸÂTÿ‹Â…Àu ¶A¶Népÿÿÿ‹E‹M¶¶	é_ÿÿÿ3À_^]ÃIÁA;ÅAGÉAhÍAÌÀA¬ÄA¸ÈAÙÌA=ÀAÄA(ÈAJÌA­¿AÃA™ÇAºËA¿AþÂA
ÇA+ËA¾AoÂA{ÆAœÊA¾AàÁAìÅA
ÊA}½AQÁA]ÅA}ÉAÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹u‹ÿŠ
ÀtƒÆ£$sñFÿƒÄ ^ÉÃU‹ìWV‹u‹M‹}‹Á‹ÑÆ;þv;ø‚¤ùrƒ=l*CtWVƒçƒæ;þ^_u^_]é˜éþÿ÷ÇuÁéƒâƒùr*ó¥ÿ$•äÐA‹ÇºƒérƒàÈÿ$…øÏAÿ$ôÐAÿ$xÐAÐA4ÐAXÐA#ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•äÐAI#ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•äÐA#ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•äÐAIÛÐAÈÐAÀÐA¸ÐA°ÐA¨ÐA ÐA˜ÐA‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Düðøÿ$•äÐA‹ÿôÐAüÐAÑAÑA‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃIŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Çu$Áéƒâƒùr
ýó¥üÿ$•€ÒA‹ÿ÷Ùÿ$0ÒAI‹Çºƒùrƒà+Èÿ$…„ÑAÿ$€ÒA”ÑA¸ÑAàÑAŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•€ÒAIŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•€ÒAŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•€ÒAI4ÒA<ÒADÒALÒATÒA\ÒAdÒAwÒA‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰Dðøÿ$•€ÒA‹ÿÒA˜ÒA¨ÒA¼ÒA‹E^_ÉÊFˆG‹E^_ÉÃIŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉËÿU‹ìƒìSVWèyÿÿƒeüƒ=øC‹Ø…Žh0ÓBÿ QB‹ø…ÿ„*‹5$QBh$ÓBWÿÖ…À„PèÃÿÿÇ$ÓBW£øCÿÖPè®ÿÿÇ$ÓBW£üCÿÖPè™ÿÿÇ$äÒBW£CÿÖPè„ÿÿY£C…ÀthÌÒBWÿÖPèlÿÿY£C¡C;ÃtO9CtGPèÊÿÿÿ5C‹ðè½ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQjMìQjPÿ×…ÀtöEôu	M ë9¡üC;Ãt0PèzÿÿY…Àt%ÿЉEü…Àt¡C;ÃtPè]ÿÿY…ÀtÿuüÿЉEüÿ5øCèEÿÿY…ÀtÿuÿuÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î|ƒù~ƒùu¡ôCë(¡ôC‰
ôCëèGöþÿVVVVVÇèÓéþÿƒÄƒÈÿ^]ËÿU‹ì‹E£ÐôB]áÐôBËÿU‹ìƒìS3Û9]u3Àé)9]u"èøõþÿSSSSSÇè„éþÿƒÄ¸ÿÿÿéW‹};ûu"èÎõþÿSSSSSÇèZéþÿƒÄ¸ÿÿÿé×V¾ÿÿÿ9uvè¡õþÿSSSSSÇè-éþÿƒÄé›ÿuMð蟦þÿ‹Eð‹H;ËuL‹E·fƒøAr	fƒøZwƒÀ ·È·fƒøAr	fƒøZwƒÀ ƒEGGÿM·Àt
f;Ëtf;Èt¾·Ð·Á+ÂëAÿpEðÿuWÿuÿuhQPèçZƒÄ ;ÃuèõþÿÇ8]üt‹Eøƒ`pý‹ÆëƒÀþ8]üt‹Møƒapý^_[ÉËÿU‹ìSW3ÿ9=ô
Cu}‹];ßuè¹ôþÿWWWWWÇèEèþÿƒÄ¸ÿÿÿëi‹U;×tÚ}ÿÿÿwÑ·fƒøAr	fƒøZwƒÀ ·È·fƒøAr	fƒøZwƒÀ CCBBÿM·Àt
f;Ïtf;Èt÷зÁ+ÂëWÿuÿuÿuè þÿÿƒÄ_[]ËÿU‹ìS3Û9]u3ÀëDVWÿuèÜ4ÿÿ‹ðFjVèIS‹øƒÄ;ût"ÿuVWèƒÄ…Àt
SSSSSèæþÿƒÄ‹Çë3À_^[]ËÿU‹ì‹USVW3ÿ;×t‹];ßwè½óþÿj^‰0WWWWWèJçþÿƒÄ‹Æ_^[]Ëu;÷u3Àf‰ëÔ‹Ê·f‰AAFFf;ÇtKuî3À;ßuÓf‰ètóþÿj"Y‰‹ñ볋ÿU‹ìQQSV‹5ÈC3Û‰]ü‹W;ÃtP‹=(QBSSjÿPSSÿ׉Eø;ÃtAjPèð7ÿÿYY‰Eü;Ãt0ÿuøPjÿÿ6SSÿ×…Àt*EüSPèq0ÿÿYY…À|ƒÆ‹;Ãu¶3À_^[ÉÃÈÿëö9]ütöÿuüè`§þÿYëë‹ÿV‹5ðCW3ÿ…öuƒÈÿé¬fƒø=tGVè„3ÿÿYtF·f…ÀuæSjGWèf7ÿÿ‹ØYY‰ÐC…ÛuƒÈÿët‹5ðCëDVèL3ÿÿ‹øGfƒ>=Yt1jWè37ÿÿYY‰…ÀtPVWPè‹þÿÿƒÄ…Àt3ÀPPPPPè‡äþÿƒÄƒÃ4~fƒ>u¶ÿ5ðC豦þÿƒ%ðCƒ#Çt*C3ÀY[_^Ãÿ5ÐC苦þÿƒ%ÐCƒÈÿëä‹ÿVÿøPB‹ð3É;ñu3À^Ãf9t@@f9uù@@f9uò+Æ@S@‹ØWSèI6ÿÿ‹øY…ÿu
VÿüPB‹Ç_[^ÃSVWèMšþÿƒÄëæ‹ÿU‹ì‹Ef‹Uëf;Êt@@·f…Éuñf9t3À]ËÿU‹ìƒìSÿuMðè–¢þÿ‹M3Û;Ëu8]üt‹Eøƒ`pý3Àé»9]u.èOñþÿSSSSSÇèÛäþÿƒÄ8]üt‹Eøƒ`pý¸ÿÿÿéˆ9]tÍV¾ÿÿÿ;ÎvèñþÿSSSSSÇèžäþÿƒÄë?‹Eô9XuÿuQÿuÿuè
[ƒÄë6ÿpQÿuQÿuhÿpEðPèªZƒÄ ;Ãu8]üt‹Eøƒ`pý‹ÆëƒÀþ8]üt‹Møƒapý^[ÉËÿU‹ìjÿuÿuÿuèýþÿÿƒÄ]ËÿU‹ìS3Û9]u3ÀëAVWÿuè6ÿÿ‹ðFVè-¦þÿ‹øYY;ût"ÿuVWè!4ÿÿƒÄ…Àt
SSSSSèoâþÿƒÄ‹Çë3À_^[]ËÿU‹ìQQSV3öW‹=ÐC‰uü‹;Æte‹ÐQBVVVVjÿPVVÿÓ‰Eø;ÆtTjPè¯4ÿÿYY‰Eü;ÆtCVVÿuøPjÿÿ7VVÿÓ…Àt6EüVPèW1ÿÿYY…À}9uütÿuüè2¤þÿY‰uüƒÇ‹;Æu¡3À_^[ÉÃÈÿëöÿuüè¤þÿYëðjhàÚBè’'ÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;EÀ@uèlïþÿÇWWWWWèøâþÿƒÄ3ÀéÕ¯M‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=`*CuKƒÆƒæð‰u‹E;P*Cw7jèÉÿÿY‰}üÿuè*$ÿÿY‰EäÇEüþÿÿÿè_‹]ä;ßtÿuWSèðšþÿƒÄ;ßuaVjÿ5(Cÿ€QB‹Ø;ßuL9= Ct3VèG+ÿÿY…À…rÿÿÿ‹E;Ç„PÿÿÿÇéEÿÿÿ3ÿ‹ujèUÿÿYÃ;ßu
‹E;ÇtÇ‹ÃèÆ&ÿÿËÿU‹ì‹MS3Û;Ëv(jà3ÒX÷ñ;EsèWîþÿSSSSSÇèãáþÿƒÄ3ÀëA¯MVW‹ñ9]tÿuèÖCY‹ØVÿuèeÒþÿ‹øYY…ÿt;Þs+óVjßSèšþÿƒÄ‹Ç_^[]ËÿU‹ì‹EƒøþuèêíþÿÇ	3À]ÃV3ö;Æ|;8)CrèÌíþÿVVVVVÇ	èXáþÿƒÄ3Àë‹ÈƒàÁù‹@)CÁà¾Dƒà@^]ÃjhÛBè•%ÿÿ3À3ö9u•À;ÆuèyíþÿÇVVVVVèáþÿƒÄƒÈÿë_èëþÿj [ÃPjèάþÿYY‰uü謫þÿÃPès>ÿÿY‹øEPVÿu蔫þÿÃPè@ÿÿ‰Eäè„«þÿÃPWèæ>ÿÿƒÄÇEüþÿÿÿè	‹EäèK%ÿÿÃè^«þÿƒÀ PjèÙ¬þÿYYËÿU‹ìEPÿuÿuè¯XƒÄ]ËÿU‹ìEPÿuÿuè³XƒÄ]ËÿU‹ìEPjÿuè›XƒÄ]ËÿU‹ìEPÿuÿuèŸXƒÄ]ËÿU‹ìEPjÿuè‡XƒÄ]ËÿU‹ì‹
€ñB‹UƒÉ3À9
C”À÷ÚÒ#щC]á€ñBƒÈ3É9C”Á‹ÁËÿU‹ìƒìSV‹u3ÛW‹};óu;ûv‹E;Ãt‰3À郋E;Ãtƒÿÿÿÿÿvèìëþÿj^SSSSS‰0èyßþÿƒÄ‹ÆëVÿuMðèìœþÿ‹Eð9X…œf‹E¹ÿf;Áv6;ót;ûvWSV誗þÿƒÄè™ëþÿÇ*èŽëþÿ‹8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,ènëþÿj"^SSSSS‰0èûÞþÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿMQSWVjMQS‰]ÿpÿÐQB;Ãt9]…^ÿÿÿ‹M;Ët½‰ë¹ÿÿtƒ}ç^]ËÿU‹ìöG@SV‹ð‹Ùt2ƒu,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèôèþÿƒ8*u‹Ï°?èdÿÿÿƒ}Õ^[]ËÿU‹ììx¡€ñB3ʼnEüS‹]V‹u3ÀW‹}ÿu°ýÿÿ‰µ ýÿÿ‰½Üýÿÿ‰…¤ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…¨ýÿÿ‰…Èýÿÿè–™þÿ…öu5èlèþÿÇ3ÀPPPPPèöÛþÿƒÄ€½¼ýÿÿt
‹…¸ýÿÿƒ`pýƒÈÿéÿ
öF@u^Vè®FÿÿYºÿBƒøÿtƒøþt‹Èƒá‹ðÁþÁáµ@)Cë‹ÊöA$u‘ƒøÿtƒøþt‹ÈƒàÁùÁà@)Cë‹Âö@$€…gÿÿÿ3À;Ø„]ÿÿÿŠ‰…Øýÿÿ‰…àýÿÿ‰…Àýÿÿ‰…¬ýÿÿˆ•ïýÿÿ„Ò„P
C3À9…Øýÿÿ‰ÄýÿÿŒ
ŠÊ€é €ùXw
¾Â¶€ ÓBƒà‹ÀýÿÿkÀ	¶„@ÓBjÁè^‰…Àýÿÿ;Æ„äþÿÿjY;Á‡­	ÿ$…‹íA3Àƒèýÿÿÿ‰…”ýÿÿ‰…¨ýÿÿ‰…Ìýÿÿ‰…Ðýÿÿ‰…ðýÿÿ‰…Èýÿÿét	¾Âƒè tHƒèt4+Æt$HHtƒè…V		µðýÿÿéK	ƒðýÿÿé?	ƒðýÿÿé3	ðýÿÿ€é$	ƒðýÿÿé	€ú*u,ƒÇ‰½Üýÿÿ‹ü‰½Ìýÿÿ…ÿùƒðýÿÿ÷Ìýÿÿéç‹…ÌýÿÿkÀ
¾ÊDЉ…Ìýÿÿé̃¥èýÿÿéÀ€ú*u&ƒÇ‰½Üýÿÿ‹ü‰½èýÿÿ…ÿ¡ƒèýÿÿÿé•‹…èýÿÿkÀ
¾ÊDЉ…èýÿÿéz€úItU€úhtD€últ€úw…bðýÿÿéS€;luCðýÿÿ‰Äýÿÿé8ƒðýÿÿé,ƒðýÿÿ é Š<6u€{4uCCðýÿÿ€‰Äýÿÿéý<3u€{2uCC¥ðýÿÿÿÿÿ‰ÄýÿÿéÜÿÿYYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìöG@SV‹ð‹Ùt2ƒu,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèSÛþÿƒ8*u‹Ï°?èdÿÿÿƒ}Õ^[]ËÿU‹ì‹Eƒ‹‹Aø‹Qü]ËÿU‹ììС€ñB3ʼnEü‹ES‹]V‹uWÿu3ÿÄýÿÿ‰µýÿÿ‰…ìýÿÿ‰½Œýÿÿ‰½ðýÿÿ‰½¨ýÿÿ‰½ˆýÿÿ‰½ ýÿÿèì‹þÿƒÜýÿÿÿ‰½¤ýÿÿ;÷u3èµÚþÿWWWWWÇèAÎþÿƒÄ€½Ðýÿÿt
‹…Ìýÿÿƒ`pýƒÈÿéñöF@u^Vèù8ÿÿYºÿBƒøÿtƒøþt‹Èƒá‹ðÁþÁáµ@)Cë‹ÊöA$u“ƒøÿtƒøþt‹ÈƒàÁùÁà@)Cë‹Âö@$€…iÿÿÿ;ß„aÿÿÿ‰½Àýÿÿ‰pýÿÿ‰½Øýÿÿƒ½Øýÿÿu9½Üýÿÿ„E3ÿ‹…pýÿÿƒ¬ýÿÿÿƒèýÿÿÿƒÜýÿÿÿ‰½˜ýÿÿŠ‰½œýÿÿ‰½„ýÿÿ‰½°ýÿÿ‰½àýÿÿˆ•Ôýÿÿ„Ò„ä‹ð늕ÔýÿÿF3ÿ9½Àýÿÿ‰µ¼ýÿÿŒNŠÂ, %„ýÜýÿÿÿuRj
…¤ýÿÿPVèþÿƒÄ…À~0‹…¤ýÿÿ€8$u%9½Øýÿÿuh@…0÷ÿÿWPè…þÿƒÄ‰Üýÿÿ늕Ôýÿÿ‰½Üýÿÿ9Üýÿÿu`j
…¤ýÿÿPV蹌þÿ‹¤ýÿÿƒÄHQ‰…èýÿÿ‰•¼ýÿÿ9½Øýÿÿu(;ÇŒîýÿÿ€9$…åýÿÿƒødÜýÿÿ;…¬ýÿÿ~‰…¬ýÿÿ‹òŠ•Ôýÿÿ‹…œýÿÿÿ$…1Bƒø„°ýÿÿƒø‡
ëß9½Øýÿÿu9Üýÿÿ„÷9Øýÿÿ…÷ƒ½Üýÿÿÿ…êéÙƒàýÿÿÿ‰½€ýÿÿ‰½ˆýÿÿ‰½°ýÿÿ‰½¨ýÿÿ‰½ðýÿÿ‰½ ýÿÿ驾ƒè tIƒèt5ƒèt%HHtƒè…Šƒðýÿÿé~ƒðýÿÿér	ðýÿÿégðýÿÿ€éXƒðýÿÿéL€ú*…¿9½Üýÿÿuƒ…ìýÿÿ‹…ìýÿÿ‹@üé‚j
…¤ýÿÿPVèS‹þÿ‹¤ýÿÿƒÄHQ‰•¼ýÿÿ9½ØýÿÿuL;ÇŒŽüÿÿ€9$……üÿÿƒ½èýÿÿdxüÿÿ;…¬ýÿÿ~‰…¬ýÿÿÁàŒ0÷ÿÿ99„×ÿµðýÿÿj*Sé1Áà‹„4÷ÿÿ‹;lj…°ýÿÿ–
ƒðýÿÿ÷°ýÿÿé„
‹…°ýÿÿkÀ
¾ÊDЉ…°ýÿÿéi
‰½àýÿÿé^
€ú*…Š9½Üýÿÿuƒ…ìýÿÿ‹…ìýÿÿ‹@üë:j
…¤ýÿÿPVèhŠþÿ‹¤ýÿÿƒÄHQ‰•¼ýÿÿ9½Øýÿÿ„ÿÿÿÁà‹„4÷ÿÿ‹;lj…àýÿÿóƒàýÿÿÿéç‰Æ„8÷ÿÿ*‹ðýÿÿ‰Œ<÷ÿÿéË‹…àýÿÿkÀ
¾ÊDЉ…àýÿÿé°€úItU€úhtD€últ€úw…˜ðýÿÿé‰€>luFðýÿÿ‰µ¼ýÿÿénƒðýÿÿébƒðýÿÿ éVŠ<6u€~4uFFðýÿÿ€‰µ¼ýÿÿé3<3u€~2uFF¥ðýÿÿÿÿÿ‰µ¼ýÿÿéƒðýÿÿ@Ç…´ýÿÿ
‹…ðýÿÿ©€„–9½Üýÿÿ…?‹ìýÿÿ‹‹QƒÁ‰ìýÿÿé@ÿµðýÿÿÿµÔýÿÿjQèÁóÿÿƒÄ…À„öÿÿéi9½àýÿÿ…ôýÿÿ‰…äýÿÿ¸‰…´ýÿÿ}Ç…àýÿÿë
u$€úgu‰àýÿÿ9½Üýÿÿu]‹…ìýÿÿƒÀ‰…ìýÿÿël9…àýÿÿ~‰…àýÿÿ»£9àýÿÿ~Ì‹µàýÿÿÆ]Vè¸ÿÿŠ•ÔýÿÿY‰…„ýÿÿ;Çt£‰…äýÿÿ‰µ´ýÿÿ뛃½èýÿÿc‡Yõÿÿ‹…èýÿÿÁà‹„4÷ÿÿƒÀ‹Hø‰týÿÿ‹@ü‰…xýÿÿ…ÄýÿÿPÿµ€ýÿÿ¾ÂÿµàýÿÿPÿµ´ýÿÿ…týÿÿÿµäýÿÿPÿ5pÿBèiîþÿYÿЋµðýÿÿƒÄæ€t%9½àýÿÿu…ÄýÿÿPÿµäýÿÿÿ5|ÿBè5îþÿYÿÐYY€½Ôýÿÿgu!;÷u…ÄýÿÿPÿµäýÿÿÿ5xÿBèîþÿYÿÐYY‹…äýÿÿ€8-uðýÿÿÿ…äýÿÿÿµäýÿÿéýÿÿÇ…àýÿÿÇ…Œýÿÿë$ƒès„ûÿÿHH„èýÿÿƒè…Ç…Œýÿÿ'ö…ðýÿÿ€Ç…´ýÿÿ„ÈýÿÿŠ…ŒýÿÿQÆ…¸ýÿÿ0ˆ…¹ýÿÿÇ…¨ýÿÿé¤ýÿÿƒ½èýÿÿc‡ôóÿÿ‹…èýÿÿÁà9½Øýÿÿ…ƒŒ0÷ÿÿ99uÇé;ÿµðýÿÿÿµÔýÿÿj鮩td9½Üýÿÿ„cýÿÿƒ½èýÿÿc‡–óÿÿ‹…èýÿÿÁà9½Øýÿÿu)Œ0÷ÿÿ99uÇéáÿµðýÿÿÿµÔýÿÿjéT‹Œ4÷ÿÿ‹‹Qéd¨ „œ¨@tO9½Üýÿÿuƒ…ìýÿÿ‹…ìýÿÿ¿@ü鿃½èýÿÿc‡óÿÿ‹…èýÿÿÁà9½Øýÿÿ„Ø‹„4÷ÿÿ¿éŽ9½Üýÿÿuƒ…ìýÿÿ‹…ìýÿÿ·@üësƒ½èýÿÿc‡Èòÿÿ‹…èýÿÿÁà9½Øýÿÿ„Œ‹„4÷ÿÿ·ëE¨@tD9½Üýÿÿuƒ…ìýÿÿ‹…ìýÿÿ‹@üë'ƒ½èýÿÿc‡|òÿÿ‹…èýÿÿÁà9½ØýÿÿtD‹„4÷ÿÿ‹™ëx9½Üýÿÿuƒ…ìýÿÿ‹…ìýÿÿ‹@üë\ƒ½èýÿÿc‡8òÿÿ‹…èýÿÿÁà9½Øýÿÿu5Œ0÷ÿÿ99u‰é‡ÿµðýÿÿÿµÔýÿÿSQè°ïÿÿƒÄ…À„÷ñÿÿé‹„4÷ÿÿ‹3Òö…ðýÿÿ@t;×|;Çs÷؃Ò÷Úðýÿÿ÷…ðýÿÿ‹Ú‹øu3Ûƒ½àýÿÿ}Ç…àýÿÿ냥ðýÿÿ÷¸9…àýÿÿ~‰…àýÿÿ‹ÇÃu!…¨ýÿÿuó‹…àýÿÿÿàýÿÿ…À‹ÇÃt-‹…´ýÿÿ™RPSWèðáÿÿƒÁ0ƒù9‰˜ýÿÿ‹ø‹Ú~ŒýÿÿˆNë½Eó+ÆF÷…ðýÿÿ‰…˜ýÿÿ‰µäýÿÿ„Þ…Àt‹Î€90„Ïÿäýÿÿ‹äýÿÿÆ0@é´‹…èýÿÿƒøc‡ÛðÿÿÁà9½Øýÿÿ„þùÿÿ‹„4÷ÿÿ‹÷…ðýÿÿ‰…äýÿÿtO;Çu¡TÿB‰…äýÿÿ‹…äýÿÿ‰ ýÿÿë$Ç‹ðýÿÿˆ”8÷ÿÿ‰Œ<÷ÿÿëHIf98t@@;Ïuô+…äýÿÿÑøë,9½äýÿÿu¡PÿB‰…äýÿÿ‹…äýÿÿëI€8t@;Ïuõ+…äýÿÿ‰…˜ýÿÿƒ½Üýÿÿu
ƒ½Øýÿÿ„€ƒ½ˆýÿÿ…W‹…ðýÿÿ¨@t2©t	Æ…¸ýÿÿ-ë¨t	Æ…¸ýÿÿ+ë¨tÆ…¸ýÿÿ Ç…¨ýÿÿ‹°ýÿÿ+˜ýÿÿ+¨ýÿÿ¨uÿµýÿÿ…ÀýÿÿSj è³îÿÿƒÄÿµ¨ýÿÿ‹½ýÿÿ…Àýÿÿ¸ýÿÿè¹îÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…ÀýÿÿèqîÿÿƒÄƒ½ ýÿÿ‹…˜ýÿÿtf…À~b‹µäýÿÿ‰…´ýÿÿ·ÿ´ýÿÿPjEôP…|ýÿÿFPFèßÿÿƒÄ…Àu(9…|ýÿÿt ÿµ|ýÿÿ…ÀýÿÿMôè4îÿÿƒ½´ýÿÿYuµëƒÀýÿÿÿë‹äýÿÿP…Àýÿÿè
îÿÿYƒ½Àýÿÿ|ö…ðýÿÿtWSj …ÀýÿÿèÅíÿÿƒÄƒ½„ýÿÿtÿµ„ýÿÿèÕ}þÿƒ¥„ýÿÿY‹µ¼ýÿÿŠˆ…Ôýÿÿ„À…™ïÿÿ3ÿ9½œýÿÿt
ƒ½œýÿÿ…mîÿÿƒ½ÜýÿÿuY9½ØýÿÿuQ3ö9½¬ýÿÿ|G‹•ìýÿÿ…4÷ÿÿ‹HüItItItItItItII…)îÿÿ‰ƒÂ뉃ÂFƒÀ;µ¬ýÿÿ‰•ìýÿÿ~Åÿ…Øýÿÿƒ½Øýÿÿ}3ÿé¦îÿÿ€½Ðýÿÿt
‹…Ìýÿÿƒ`pý‹…Àýÿÿ‹Mü_^3Í[èGvþÿÉÃXòAŠòAºòAóAúóAôA³ôAÝõAjh ÛBècÿÿ‹EƒøþuèMÈþÿÇ	ƒÈÿéª3Û;Ã|;8)Crè,ÈþÿÇ	SSSSS踻þÿƒÄëЋÈÁù<@)C‹ðƒæÁ拾LƒátÆPè£ÿÿY‰]ü‹öDt1ÿuèÿÿYPÿÈPB…Àuÿ+ƒÄ;Çt³öEÿ€„0¿@¹@…}u‹Eà#Çu	Më	E‹E#Ç;ÁtD=t)=@t"=t)=@t"=t=@uÆEþë‹M¸#È;Èu	ÆEþëˆ]þ÷E„µöEÿ@‰]è…¨‹Eø¹À#Á=@„·=€tw;Á…„‹Eì;Æyƒøvƒøv0ƒø…f¾Eþ3ÿH„&H…RÇEèÿþÇEìéjSSÿ6èœòÿÿƒÄÂtÇSSSÿ6è‹òÿÿ#ƒÄƒøÿ„ŽþÿÿjEèPÿ6èáƒÄƒøÿ„uþÿÿƒøtkƒø…­}èuYÆEþéÜ‹Eì;Æуø†bÿÿÿƒø‡PÿÿÿjSSÿ6èòÿÿƒÄ„CÿÿÿSSSÿ6èòÿÿƒÄ#ƒøÿ…‘éþÿÿ‹Eè%ÿÿ=þÿuÿ6è[@ÿÿYè]¹þÿj^‰0‹Æéd=ÿþuSjÿ6èP)ƒÄƒøÿ„ÀýÿÿÆEþëASSÿ6è5)ƒÄë™ÇEèÇEì‹Eì+ÇPD=èPÿ6èÅHÿÿƒÄƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹@)CƒàÁàD$Š2Mþ€á0‹‹ÈÁù‹@)CƒàÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹ÈƒàÁù‹@)CÁàD€ ‹}ø¸À‹Ï#È;Èu|öEtvÿuäÿHQBSÿuôEÐjPÿuðçÿÿÿWÿuÿ8QBƒøÿu4ÿˆ‹@ÿM€}þÇEðÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEðÆD&
SMèQÿuP‹ÿ4ÿQB…À„{‹Mè;ËŒp;M‡g‹MðDö€„æ€}þ„;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ЋMŠ<„®<
tˆCA‰Mé‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEjEèPjEÿP‹ÿ4ÿQB…Àu
ÿ9uôr9wƒ}ðÿv1轡þÿöEÇ"t
ƒMðÿƒMôÿëöEt	ƒeð‰]ôëƒMðÿ‰uô‹E^…Àt‹Mø‰öEt‹Eð‹Mô÷؃Ñ÷Ù‰Eð‰Mô€}Ôt‹EЃ`pý‹Eð‹Uô_[ÉËÿU‹ì3ÀPÿuÿuÿu9ô
CuhýBëPèCýÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuè&ýÿÿƒÄ]ËÿU‹ìƒ=ô
CjÿuÿuÿuuhýBëjèúüÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuèÝüÿÿƒÄ]ËÿU‹ìQƒeüVEüPÿuÿuè±ÿÿ‹ðƒÄ…öu9Eütè– þÿ…Àt
è þÿ‹Mü‰‹Æ^ÉËÿU‹ìƒì¡€ñB3ʼnEüjEôPhÿuÆEúÿÔPB…ÀuƒÈÿë
EôPènSÿÿY‹Mü3ÍèúMþÿÉËÿU‹ìƒì4¡€ñB3ʼnEü‹E‹M‰EØ‹ES‰EЋV‰EÜ‹EW3ÿ‰M̉}à‰}Ô;E„_‹5ØQBMèQPÿÖ‹(QB…Àt^ƒ}èuXEèPÿuÿÖ…ÀtKƒ}èuE‹uÜÇEÔƒþÿuÿuØèlåþÿ‹ðYF;÷~[þðÿÿwSD6=w/è¼_þÿ‹Ä;Çt8ÇÌÌë-WWÿuÜÿuØjÿuÿÓ‹ð;÷uÃ3ÀéÑPè3UþÿY;Çt	ÇÝ݃À‰Eäë‰}ä9}ätØ6PWÿuäèDKþÿƒÄVÿuäÿuÜÿuØjÿuÿÓ…Àt‹]Ì;ßtWWÿuSVÿuäWÿuÿÐQB…Àt`‰]àë[‹ÐQB9}ÔuWWWWVÿuäWÿuÿÓ‹ð;÷t=€t7=t0=t)=t"è'þÿÇ3ÛSSSSSè±€þÿƒÄƒÈÿé“‹Eƒøþu
èýŒþÿÇ	ëã3Û;Ã|;8)Cr
èâŒþÿÇ	뻋ÈÁù<@)C‹ðƒæÁ拾L1ƒátÓPèfÕþÿY‰]ü‹öD0tÿuÿuèýýÿÿYY‰EäëèŒþÿÇ	ƒMäÿÇEüþÿÿÿè	‹EäèÀÄþÿÃÿuè»ÕþÿYÃU‹ìWVS‹MÉtM‹u‹}·A³Z¶ IŠ&
äŠt'
Àt#ƒÆƒÇ:çr:ãwæ:Çr:ÃwÆ:àuƒéuÑ3É:àt	¹ÿÿÿÿr÷Ù‹Á[^_ÉÃÌÿ%xQBÿ%|QBÿ%€QBÿ%„QBÿ%ˆQBÿ%ŒQBÿ%QBÿ%”QBÿ%˜QBÿ%œQBÿ% QBÿ%¤QBÿ%¨QBÿ%¬QBÿ%°QBÿ%´QBÿ%¸QBÿ%¼QBÿ%ÀQBÿ%ÄQBÿ%ÈQBÿ%ÌQBÿ%ÐQBÿ%ÔQBÿ%ØQBÿ%ÜQBÿ%àQBÿ%äQBÿ%èQBÿ%ìQBÿ%ðQBÿ%ôQBÿ%øQBÿ%üQBÿ%RBÿ%RBÿ%RBÿ%RBÿ%RBÿ%RBÿ%RBÿ%RBÿ% RBÿ%tQBÿ%pQBÿ%hQBÿ%dQBÿ%`QBÿ%QBÿ%QBÿ%QBÿ%QBÿ%QBÿ%üPBÿ%øPBÿ%ôPBÿ%ðPBÿ%ìPBÿ%èPBÿ%äPBÿ%àPBÿ%ÜPBÿ%ØPBÿ%ÔPBÿ%ÐPBÿ%ÌPBÿ%ÈPBÿ%ÄPBÿ%ÀPBÿ%¼PBÿ%¸PBÿ%´PBÿ%0QBÿ%¬PBÿ%¨PBÿ%lQB‹ÿU‹ìV‹u…öt!;ut;uuÿu$ÿu ÿuÿuÿuèG|þÿƒÄ‹Æ^]ËÿVW‹ðjV3ÿè³ÏþÿY@Pè°ÎþÿYY…Àt,Š‹Ð„Ét€ù"uFGëˆ@FŠ„Éuí…ÿtˆ‹Âë	Rè:>þÿY3À_^Ãj hÀÜBè¸Áþÿ3ö‰u܉uЉuàjè°þÿY…À„]h¬ÓBVEàPèAÿÿƒÄ‹ø;þtƒÿu
VVVVVè¢{þÿƒÄ;þ…É9uà„ÀVÿuàè§YY…À…­‹}໬SB9utÿuèêÎþÿY‰EÜWèàÎþÿ‹MÜD‰EäjPèRèÿÿƒÄ‹ð‰uØ…ö„ºÆWÿuäVèÃXÿÿƒÄ3É;Át
QQQQQè{þÿƒÄWè•ÎþÿYD8ÿ‰EÔŠ<\upj\WèYY9EÔ„SÿuäVè|XÿÿƒÄ3Û;ÃtpSSSSSèÓzþÿƒÄëa‹};þtVWèâYY…À„>ÿÿÿV»¬SBSèÌYY…Àu‹ûé*ÿÿÿ¿L»Bé ÿÿÿå2å&åååôä\åÒáàáðáâââ2âBâVâfâvâŠâžâ²âÆâØâîâãã6ãìöëÄáÒëÆë¶ë ëë|ëlëVëDë.ëë
ëúêêêÔêÄêªêêvê^êDêêêîé²á¦á˜áˆává`áTáäëBá4á$ááþàðàÚàÊà´à ààâéÐéÀéì®é”é~æ˜æ¤æ°æÈæâæççç6çNç`çrç€ç”çœçªç¼çÎçâçþçè0èFè`èlè„èœè¦è²èÄèÒèÞèìèöèéé(é6éNé^énézé"ætãhã>äÜäÎä¸ä¬äœäŒä~äpä^äLäZã.äääúãîãÞãÊã¶ã®ã¢ã’ã€ãdæ>æPæ$‰@äº@Ö@{kAZxAz7B’CBÕ‰@ÿ¨ITøÓø½CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removed%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Root Key: %sOut of memoryAre you sure you want to remove
this package from your computer?Please confirmcould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive–0w,aîºQ	™Ämôjp5¥c飕dž2ˆÛ¤¸ÜyéÕàˆÙÒ—+L¶	½|±~-¸ç‘¿d·ò °jHq¹óÞA¾„}ÔÚëäÝmQµÔôÇ…ÓƒV˜lÀ¨kdzùbýìÉeŠO\Ùlcc=úõ
È n;^iLäA`Õrqg¢Ñäjm
¨ZjzÏäÿ	“'®
±ž}D“ðÒ£‡hòþÂi]Wb÷Ëge€q6lçknvÔþà+Ó‰ZzÚÌJÝgoß¹ùùﾎC¾·ÕŽ°`è£ÖÖ~“Ñ¡ÄÂØ8RòßOñg»ÑgW¼¦Ýµ?K6²HÚ+
ØL
¯öJ6`zAÃï`ßUßg¨ïŽn1y¾iFŒ³a˃f¼ Òo%6âhR•wÌG»¹"/&U¾;ºÅ(½²’Z´+j³\§ÿ×Â1Ïе‹žÙ,®Þ[°Âd›&òc윣ju
“m©	œ?6ë…grW‚J¿•z¸â®+±{8¶›ŽÒ’
¾Õå·ïÜ|!ßÛÔÒÓ†BâÔñø³ÝhnƒÚ;[&¹öáw°owG·æZˆpjÿÊ;f\ÿžei®bøÓÿkaEÏlxâ
 îÒ
×TƒN³9a&g§÷`ÐMGiIÛwn>JjÑ®ÜZÖÙfß@ð;Ø7S®¼©Åž»ÞϲGéÿµ0ò½½ŠÂºÊ0“³S¦£´$6к“×Í)WÞT¿gÙ#.zf³¸JaÄh]”+o*7¾´¡ŽÃßZï-A1‚b62ÃS-+ÅldEôw}†§ZVÇ–AOŠÙÈI»ÂÑŠèïúËÙôãOµ¬M~®µŽ-ƒžÏ˜‡QÂJ#ÙSÓpôx’AïaU×®.æµ7×µ˜–„ƒY˜‚©›Ûú-°šË6©]]wællÿß?AÔžZÍ¢$„•ãŸŒ F²§aw©¾¦áèñçÐóè$ƒÞÃe²ÅÚª®]]ëŸFD(Ìkoiýpv®k19ïZ* ,	m8ó6Fß²]ÆqTpí0ekô÷ó*»¶Â1¢u‘‰4 û¼Ÿº„yÞ©%8ï²<ÿyós¾Hèj}ÅA<*ÞXOyðD~bé‡-OÂÆTÛŠ”@»ƒè#¦ÂÙ8¿
Å 8Lô»!§–
Ζ	Ì\H1×E‹búnÊSáwT]»ºl £Ö?ˆ—–‘P˜×Þ©ÌÇÒúáì“Ëúõ\×bræykÞµT@Ÿ„OYX#Úp8$›A#=§kýeæZæ|%	ËWd8ÐN£®‘⟊!̧3`ý¼*¯á$­îÐ?´-ƒŸl²	†«$HÉêSÐ)F~ûhweâöy?/·H$6t	5*ò¼SK³HRpÞey1ï~`þóæç¿Âýþ|‘ÐÕ= ËÌú6Šƒ»‘šxT¼±9e§¨K˜ƒ;
©˜"Éúµ	ˆË®O]ï_lôFÍ?ÙmŒÂtCZó#AêÁplÁ€AwØG×6—æ-ŽÅµ¥„„¼ŠAq[»Zh˜èwCÙÙlZO-_~6œ-'Ý>˜¹S1ƒ b®‹ÑSµ’ÅôÝWôïÄ”§ÂïÕ–Ùöé¼®¨·kÞ1œ*ï*…íykʬHpÓo]ø.*Fáá6Þf ÅcTèT"eóMåó²¤Â©g‘„0& Ÿ)¸®ÅäùŸÞý:ÌóÖ{ýèϼk©€ýZ²™>	Ÿ²8„«°$,ñ52F*sw1´ápHõÐkQ6ƒFzw²]cN×úËæáÒ̵Ìù„×àJ–¯#¶Èp ‰A»„F]#l8Ä?1…(B˜Og©T~ÀúyUËbLÅ8^ô#˜§³Ü–ªTåZ1Oü™bb×ØSyÎOáIV~úP•-×{ÔÌbŠ-R»–4‘è»ÐÙ ìó~^­ÂeGn‘Hl/ Suè6:©	#jT$+e?äy§–¥H¼f‘¤'*Š½à¼Ëò¡ÐëbÞýÀ#ïæÙ½á¼üЧ
?ƒŠ&~²‘?¹$ÐpøËi;FæBzwý[µkeÜôZ~Å7	Sîv8H÷±®	¸ðŸ¡3Ì?Šrý$“7jÂnÔ„Y¾Fܨ	ëÂ˲|…O¸Q;ÑÖ…—
áïUdù	S“Ø
-ž
=G\p£&GÉäw¢)`¬/›aíÂß«õµiÈò5ÿ˜÷¦&±‘LsZ<#0þzŽ¸MäzàFM8×,9Ž’É;¹ø:<îD?„†>R:À(ôq-Ãv³,šÈõ.­¢7/Àšp÷çXq®Ys™3Ür%“w+OQvrñtE›Õux܉~O¶K
}!bÏ|¤t€y“BxÊ zýÊÆ{°.¼l‡D~mÞú8oéúnl†µk[ìwjR1h58ói¯b?mcf«+aQÁé`Ôצeã½ddº"fiàg Ë×H¡INSKyu‘JücÞOË	N’·ZL¥Ý˜M˜šÄF¯ðGöN@EÁ$‚DD2ÍAsX@*æIBŒ‹CPhñTg3U>¼uW	Ö·VŒÀøS»ª:Râ|PÕ~¾Qè9âZßS [†ífY±‡¤X4‘ë]û)\ZEo^m/­_€5á·q÷àîϱâÙ¥sã\³<ækÙþç2g¸å
zä8J&ï äîVž¢ìaô`íäâ/èÓˆíéŠ6«ë½\iêð¸ýÇÒÑüžl—þ©Uÿ,úzØûBÄžùu®\øHéóƒÂò&=„ðWFñ”A	ô£+Ëõú•÷ÍÿOö`]xÙW7ºØ‰üÚ9ã>Û¼õqÞ‹Ÿ³ßÒ!õÝåK7ÜØk×ïf©Ö¶ØïÔ²-Õ¤bÐ3ΠÑjpæÓ]$Òþ^Å'”œÄ~*ÚÆI@ÇÌVWÂû<•Ã¢‚ÓÁ•èÀ¨¯MËŸÅÊÆ{ÉÈñÉtDÌCm†ÍÓÀÏ-¹Î@–¯‘wüm.B+’(é“œ>¦–«Td—òê"•Å€à”øǼŸÏ­~ž–8œ¡yú$oµ˜w™J»1›}Ñóš05‰_KŒ^á
Ži‹Ï쀊Û÷B‹‚I‰µ#ƈˆdšƒ¿X‚æ°€ÑÚÜTÌ“„c¦Q…:‡
rÕ† Ðâ©—º ¨Îfªùn¤«|xë®K)¯¬o­%Æ­¬ñ§/ë3¦vUu¤A?·¥Ä)ø óC:¡ªý|£—¾¢Ðsĵç´¾§@¶‰Í‚·ÛͲ;±³bI±Ue‹°h"×»_HºöS¸1œ‘¹´ŠÞ¼ƒà½Ú^Z¿í4˜¾eg¼¸‹È	ªî¯µW—b2ðÞ7Ü_k%¹8×ï(´ÅŠO}dà½o‡׸¿ÖJÝØjò3wßàVcXŸWPú0¥èŸúqø¬BÈÀ{ß­§ÇgCru&oÎÍp­•-û·¤?žÐ‡'èÏBs¢¬ Æ°ÉGz>¯2 [ÈŽµg;
Ї²i8P/_ì—âðY…‡—å=ч†e´à:ÝZOÏ?(3w†äêãwXR
Øí@h¿Qø¡ø+ðÄŸ—H*0"ZOWžâöoI“õÇ}§@ÕÀümNП5+·#Å–Ÿ *'Gýº| A’ô÷èH¨=X›X?¨#¶1Ó÷¡‰jÏv¨Ê¬á¾„`ÃÒp ^·æY¸©ô<ßL…çÂÑà€~i/Ë{kHwâ
ËÇh±s)ÇaL ¸Ùõ˜oDÿÓü~Pfî7ÚVM'¹(@¶Æï°¤£ˆ°Û×g9‘xÒ+ôn“÷&;fšƒˆ?/‘íX“)T`D´1øߨMºÏñ¦ìß’þ‰¸.Fg›Tp'ì»HðqÞ/LÉ0€ùÛUçEcœ ?kùǃÓh6ÁrŠyË7]ä®Pá\@ÿTN%˜èösˆ‹®ï7ø@‚'>¼$é!AxU™¯×à‹Ê°\3;¶Yí^ÑåU°~PGÕìÿl!;b	F‡Úçé2È‚ŽŽpÔží(±ùQ_Vä‚:1X:ƒ	§æn3Á†
m¦:µ¤á@½Á†ü/)IJNõ¯óv"2–žŠx¾+˜Ù— KÉôx.®HÀÀýÒ¥fAj^–÷y9*O—–Ÿ]òñ#åkM`~×õŽÑbçë¶Þ_RŽ	Â7éµzÙFh¼!¼Ðê1߈Vc0aùÖ"žjš½¦½ØÁ¿6n´­S	šNrÿ)Î¥†{·táÇÍÙ’¨¾¬*F8#v¥€ufÆØz`þ®Ïr›ÉsÊ"ñ¤WG–ï©9­ýÌ^EîMvc‰ñÎ&DÜèAødQy/ù4“AÚ±&S¿ÖšëéÆù³Œ¡EbðiL¡¾Q›<Û6'„5™’–Pþ..™¹T&üÞèžq]Œwá4Î.6©«IŠEæ? ƒ»v‘àãö\[ýYéI˜>Uñ!‚lDa>Ԫ΋ÆÏ©7~8AÖ]&Ãn³‰v|ÖîÊÄoÖY
±¡áäóy¨K×i˲w«\¡Â¹9Æ~€þ©œå™$6 6nQŽ§f†ÂqÚ>,Þo,I¹Ó”ð	•æ¸±{I
£.±H>ÒC-YnûÃöÛ馑gQ©°ÌzÎt”a¹fñÞw0–îa,™	QºmÄpjôéc¥5žd•£Ûˆ2yܸ¤àÕé—ÒÙˆ	¶L+~±|½ç¸-¿‘·dj° òó¹qH„¾AÞÚÔ}mÝäëôÔµQƒÓ…Çl˜Vdk¨ÀýbùzŠeÉì\OclÙú=c
õ;n ÈLi^Õ`Aä¢gqr<äÑKÔGÒ
…ý¥
µk5µ¨úB²˜lÛ»ÉÖ¬¼ù@2ØlãEß\uÜÖ
Ï«Ñ=Y&Ù0¬QÞ:È×Q€¿Ða!´ôµV³Ä#Ϻ•™¸½¥(¸ž_ˆÆÙ²±é$/o|‡XhLÁa«¶f-=vÜAÛq˜Ò ¼ïÕ*q±…‰¶µŸ¿ä¥è¸Ô3xÉ¢ù4–	¨Žá˜j
»m=-‘dl—æc\kkQôlab…e0ØòbNl•í¥{‚ôÁõÄWe°ÙÆ·éP‹¾¸êü¹ˆ|bÝßÚ-IŒÓ|óûÔLeM²aX:µQΣ¼tÔ»0âJߥA=ؕפÑÄmÓÖôûCiéj4nÙü­gˆFÚ`¸ÐD-s3åª
L_Ý
|ÉPq<'Aª¾É †Whµ% o…³¹fÔ	ÎaäŸ^Þù)Ùɘ°Ð˜"Çר´Y³=.´
·½\;Àºl­í¸ƒ š¿³¶¶ât±ÒšêÕG9Òw¯Û&s܃ãc”d;„
mj>zjZ¨äÏ“	ÿ
®'}ž±ð“D‡£ÒòhiÂþ÷bW]€egËl6qnkçþÔv‰Ó+àÚzZgÝJÌù¹ßoŽ¾ïù·¾C`°ŽÕÖÖ£è¡Ñ“~8ØÂÄOßòRÑ»gñ¦¼Wg?µÝH²6KØ
+Ú¯
L6JöAz`ß`ïègßU1nŽïFi¾yËa³Œ¼fƒ%oÒ Rhâ6Ìw•»G"¹U&/ź;¾²½(+´Z’\³jÂ×ÿ§µÐÏ1,Ùž‹[Þ®›d°ìcò&uj£œm“
œ	©ë6?rg…W•¿J‚â¸z{±+®¶8’ÒŽ›åÕ¾
|Üï·Ûß!†ÓÒÔñÔâBhݳøÚƒn¾Íö¹&[o°wá·GwˆZæÿjpf;Ê\ežÿøb®iakÿÓlÏE 
âx×
ÒîNƒT9³Â§g&aÐ`÷IiGM>nwÛ®ÑjJÙÖZÜ@ßf7Ø;𩼮SÞ»žÅG²Ï0µÿé½½òʺŠS³“0$´£¦ºÐ6ÍדTÞW)#Ùg¿³fz.ÄaJ¸]h*o+”´¾7ÃŽ¡Zß-ï1A26b‚+-SÃdlÅ}wôEVZ§†OA–ÇÈÙŠÑ»IúïèŠãôÙˬµOµ®~Mžƒ-Ž‡˜ÏJÂQSÙ#xôpÓaïA’.®×U7µæ˜µ×ƒ„–‚˜Y›©°-úÛ©6Ëšæw]]ÿllÔA?ßÍZž•„$¢ŒŸ㧲F ¾©wañèá¦èóÐçÃÞƒ$ÚŲe]]®ªDFŸëokÌ(vpýi91k® *Zï	,8mßF6óÆ]²ípTqôke0»*ó÷¢1¶‰‘u 4Ÿ¼û„º%©Þy<²ï8sóyÿjèH¾AÅ}XÞ*<ðyOéb~DÂO-‡ÛTÆ”Š»@¦#胿8ÙÂ8 Å
!»ôL
–§–Î\Ì	E×1Hnúb‹wáSʺ»]T£ lˆ?Ö‘–—ÞטPÇÌ©ìáúÒõúË“rb×\kyæ@TµÞYO„ŸX#$8pÚ=#A›eýk§|æZæWË	%NÐ8d‘®£ŠŸâ3§Ì!*¼ý`­$᯴?Ð-†	²lÉH$«ÐSêû~F)âewh/?yö6$H·	t*5KS¼òRH³yeÞp`~ï1çæóþþý¿ÕБ|ÌË =ƒŠ6úš‘»±¼Tx¨§e9;ƒ˜K"˜©
	µúɮˈ_ï]OFôlmÙ?ÍtÂŒóZCêA#ÁlpÁØwA€—6×GŽ-極ż„„qAŠhZ»[Cwè˜ZlÙÙ-O6~_'-œ>ݹ˜ ƒ1S‹®b’µSÑÝôÅÄïôW倫öÙ–Õ®¼é·¨œ1Þk…*ï*ÊkyíÓpH¬ø]oáF*.fÞ6áÅ TèTcMóe"²óå©Â¤0„‘g)Ÿ &äÅ®¸ýÞŸùÖóÌ:Ïèý{€©k¼™²Zý²Ÿ	>«„8,$°5ñ*F21wsHpá´QkÐõzFƒ6c]²wËú×NÒáæù̵Ìàׄ¯–J¶# pÈ„»A‰#]F8l1?Ä(…gO˜B~T©UyúÀLbË8Ř#ô^³§ª–ÜåTüO1Z×bb™ÎySØIáOPú~V{×-•bÌÔ-Š4–»R»è‘ ÙÐ^~óìGe­lH‘nuS /:6è#	©$Tj?e+–§yä¼H¥¤‘f½Š*'ò˼àëСÀýÞbÙæï#¼á½
§Ðü&Šƒ??‘²~pÐ$¹iËøBæF;[ýwzÜekµÅ~ZôîS	7÷H8v¸	®±¡ŸðŠ?Ì3“$ýrÂj7„ÔnF¾Y	¨ÜËÂë|²O…Q¸Ñ;
—…ÖUïá	ùdØ“S
ž-
\G=&£päÉG¢w`)/¬ía›«ßÂiµõ5òÈ÷˜ÿ±&¦sL‘†„<À:R=Pe6^X7œ}o5ÚÃ64©1W¿„0•Õ³2Ókê3Ý$kå%©§'ï1þ&-[É#bML" '{ æ™"!$ó*x´(+ºÞ)ü`F(>
q-qô,³vÃ.õÈš/7¢­pšÀqXç÷sY®rÜ3™w“%vQO+tñruÕ›E~‰ÜxK¶O}
|Ïb!y€t¤xB“z Ê{ÆÊýl¼.°m~D‡o8úÞnúékµ†ljwì[h1Rió85b¯cm?a+«f`éÁQe¦×Ôdd½ãf"ºgàiH×Ë I¡KSNJ‘uyOÞcüN	ËLZ·’M˜Ý¥FÄš˜Gð¯E@NöD‚$ÁAÍ2D@XsBIæ*C‹ŒTñhPU3gWu¼>V·Ö	SøÀŒR:ª»P|âQ¾~ÕZâ9è[ SßYfí†X¤‡±]ë‘4\)û^oEZ_­/má5€à÷q·â±Ïîãs¥Ùæ<³\çþÙkå¸g2äz
ï&J8îä 좞Ví`ôaè/âäéíˆÓë«6Šêi\½ý¸ðüÑÒÇþ—lžÿU©ú,ûØzùžÄBø\®uóéHòƒð„=&ñFWô	A”õË+£÷•úöOÿÍÙx]`غ7WÚü‰Û>ã9Þqõ¼ß³Ÿ‹Ýõ!ÒÜ7Kå×kØÖ©fïÔïضÕ-²Ðb¤Ñ Î3ÓæpjÒ$]Å^þÄœ”'ÆÚ*~Ç@IÂWVÌÕ<ûÁÓ‚¢Àè•ËM¯¨ÊÅŸÈÉ{ÆÉñÌDt͆mCÏÀÓι-‘¯–@müw’+B.“é(–¦>œ—dT«•"êò”à€ÅŸ¼Çøž~­Ïœ8–úy¡˜µo$™w›1»JšóÑ}‰50ŒK_Ž
á^Ï‹iŠ€ì‹B÷Û‰I‚ˆÆ#µƒšdˆ‚X¿€°æÜÚÑ„“ÌT…Q¦c‡:†Õr
©âР¨ º—ªfΫ¤nù®ëx|¯)K­o¬¬­Æ%§ñ¦3ë/¤uUv¥·?A ø)Ä¡:Có£|ýª¢¾—µÄsдç¶@§¾·‚͉²ÍÛ³±;±Ib°‹eU»×"hºH_¸Sö¹‘œ1¼ÞŠ´½àƒ¿Z^Ú¾˜4í¸¼geª	È‹µ¯îb—W7Þð2%k_Ü×8¹Å´(ï}OŠo½àdׇJÖ¿¸òjØÝàßw3XcVPWŸè¥0úúŸB¬øqß{ÀÈgǧ­urCÍÎo&•­p-?¤·û‡ОÏè'¢sB°Æ ¬zGÉ 2¯>ŽÈ[
;gµ²‡Ð/P8i—ì_…Yðâ=å—‡e†‡ÑÝ:à´ÏOZw3(?êä†RXwã@íØ
øQ¿hð+ø¡H—ŸÄZ"0*âžWOIoöÇõ“Õ@§}müÀ5ŸÐN#·+Ÿ–Å'* ºýGA |ô’¨Hè÷›X=#¨?X1¶‰¡÷ÓvÏj¬Ê¨¾áÃ`„^ pÒæ·ô©¸YLß<ÑÂç…i~€à{Ë/ÃwHkË
¢s±hÇaÇ)Ù¸ LDo˜õüÓÿîfP~VÚ7¹'M¶@(¤°ïÆˆ£Û°9g×+Òx‘“nô;&÷ƒšf‘/?ˆ)“Xí´D`Tø1M¨ß¦ñϺþ’ßìF.¸‰T›gì'pqðH»ÉL/ÞÛù€0cEçUk? œÓƒÇùÁ6hyŠrä]7Ë\áP®NTÿ@öè˜%®‹ˆs7ï‚@ø¼>'!é$™UxA‹àׯ3\°ÊíY¶;UåÑ^GP~°ÿìÕb;!lÚ‡F	È2éçpŽŽ‚(ížÔQù±‚äV_:X1:§	ƒ3næ
†Áµ:¦m½@á¤ü†ÁI)/¯õNJ2"vóŠž–˜+¾x —ÙxôÉKÀH®.ÒýÀjAf¥÷–^O*9y]Ÿ–—å#ñòMkõ×~`çbÑŽ_Þ¶ëÂ	ŽRzµé7hFÙм!¼ˆß1ê0cV"Öùašjž½¦½¿ÁØ­´n6	SrNš¥Î)ÿ·{†Çát’ÙÍ*¬¾¨8F€¥v#ØÆfu`zrÏ®þÊsÉ›W¤ñ"ï–Gý­9©E^ÌvMîÎñ‰cÜD&døAèù/yQA“4S&±ÚëšÖ¿³ùÆéE¡Œðb¡Li<›Q¾„'6Û–’™5..þP&T¹™žèÞüŒ]q4áw©6.ΊI«?æE»ƒ ãà‘v[\öIéYýñU>˜l‚!Ô>aDƋΪ~7©ÏÖA8nÃ&]|v‰³ÄÊîÖYÖoᡱ
óäK¨yËi׫w²¹Â¡\~Æ9œ©þ€$™å6 6ŽQn†f§>ÚqÂ,oÞ,”Ó¹I	ð±¸æ•£
I{±.CÒ>HûnY-éÛöÃQg‘¦Ì°©tÎzf¹a”Þñinvalid literal/length codeinvalid distance codeinvalid distance too far back`Psp0	À
` 	 €@	àX	;x8	Ðh(	°ˆH	ðTã+t4	È
d$	¨„D	è\	˜S|<	Øl,	¸ŒL	øR£#r2	Äb"	¤‚B	äZ	”Cz:	Ôj*	´
ŠJ	ôV@3v6	Ìf&	¬†F	ì	^	œc~>	Ün.	¼ŽN	ü`Qƒq1	Â
a!	¢A	âY	’;y9	Òi)	²	‰I	òU+u5	Ê
e%	ª…E	ê]	šS}=	Úm-	º
M	úSÃ#s3	Æc#	¦ƒC	æ[	–C{;	Ök+	¶‹K	öW@3w7	Îg'	®‡G	î	_	žc?	Þo/	¾O	þ`Psp0	Á
` 	¡€@	áX	‘;x8	Ñh(	±ˆH	ñTã+t4	É
d$	©„D	é\	™S|<	Ùl,	¹ŒL	ùR£#r2	Åb"	¥‚B	åZ	•Cz:	Õj*	µ
ŠJ	õV@3v6	Íf&	­†F	í	^	c~>	Ýn.	½ŽN	ý`Qƒq1	Ã
a!	£A	ãY	“;y9	Ói)	³	‰I	óU+u5	Ë
e%	«…E	ë]	›S}=	Ûm-	»
M	ûSÃ#s3	Çc#	§ƒC	ç[	—C{;	×k+	·‹K	÷W@3w7	Ïg'	¯‡G	ï	_	Ÿc?	ßo/	¿O	ÿA@! 	@a`10
Á@	

incorrect length checkincorrect data checkinvalid distances setinvalid literal/lengths setinvalid bit length repeatinvalid code lengths settoo many length or distance symbolsinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScsƒ£ÃãÉÄ	
!1AaÁ 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionaryh‘B\‘B$UBP‘B@‘B4‘B ‘B‘BøB$UB€fàFðKуî É
ÈI*TÀðKуî É
ÈIÀT§TðKуî É
ÈIàOÐ ê:i¢Ø+00€S‡ Bi¢ê+00@ð_dPŸª/•N  ì!ê:i¢Ý+00€¢'"ê:i¢Þ+00º
E%­Ð˜¨6NKæïK®Âº}€ö`fU‡Ü­ƒH¢¿b»Ò0߬¦ôçâRF·§ì½#/xÀF‘ÀF’ÀF“ÀF”ÀF ÀF¡ÀFÐÀFÑÀFÒÀFÓÀFáÀFâÀFãÀFäÀFåÀFæÀFèÀFéÀFêÀFëÀFìÀFîÀFïÀFðÀFñÀFòÀFóÀFôÀFõÀFöÀF÷ÀFøÀFùÀFúÀFûÀFüÀFþÀFÀF¡΋!	±ÿÝÌH€žãˆx5Ï®i+.b ö`¬ÙЙËÀOÖD—¢Vö	¯AHˆ÷Ì
F¤Mä^2mãF†¼T
íÐàðd_˜ÔN¾"ÚòµÅáÑÎú
(èÑ‘‡µ2ñéW]Â/4*&{ÐŒ© É-¿èzeÒG'{ÐŒ© É-¿èpŠh}ÆЙ›ÀOÖUáBl‰ÅЙšÀOÖUá•3”(Ò9ÀOŽë> ãG ©òήe+.bµchÈЙœÀOÖUá4^ñ;ݧBª}/NÅK°›f’£NrŸ@¶"ö=½Å3ŒÈH$¹Ñ˜ÕÀO¶‡Ú àü¼ìРÉ'€þmyÏ•4À[®ðJ1ÒйB Éá&®M[¸Ð˜ÀOÙrÈèGÂй: Éá ·qíEÐ’J ¯Ç¬MàÐWs5Ï®i+.bÀs5Ï®i+.bà¥s5Ï®i+.bw~s5Ï®i+.bå%ñeá{HºÒqÈC,ã²ë‹ÐRзôÀO×ì$¦ïŽéÑ[D”·tûÎ.¡|ÞÃI)ÓЫsÀOÃ>€±â+ØdWЩnÀO×¢@;òûðㄈª>Vø€;òûðㄈª>Vø 
»ÊWÚÏ™t ¯×—b@J7<äºÏ¿}ªiFϦЙËÀOÖD—a'»wjÐ¥5ÀO×Ðb°0¡wý”Ð¥DÀO×Ðb AG†QÒ»¶`—{FL!m•‘v’Ñ’`—ß[Ôc'»wjÐ¥5ÀO×Ðbd'»wjÐ¥5ÀO×Ðbñ6À†¡Ð‚Jª[CƒA¦VgqÞЃª[Cƒe'»wjÐ¥5ÀO×Ðb“Û5iè!ÌL¾¹ŸãÇz)zR88øÓüѦ¹`—ß[Ô|¼ë^1Ò¶/`—ß[Ô@¾–L\‘ϙӪJè7@å‘°ãƒÏ§ ¯×—b‡uïИˆ`—Þ¬ùëô@јˆ`—Þ¬ùà.PR€ìЉ«ÀO—-âT'²tEјˆ`—Þ¬ùA`ÂtÑpÑ·Z Édþ¥lÄ?<Ò¾æøÊWý4p ªlTI¬?—¢rùŠPèBÒ¾, É¨=¡Oñ${уøaÏP‡¦“•Ñ”o0pû,•Ñ”o€iyŜѨ?ÀOÉa¸4‚¢Ò†ÅÀOŽê™Øµä,¢Ò†ÅÀOŽê™ ÇÌÏ‚¢Ñ‚`“‚RéWp½Ñ‰ÀOÂÈ6Œöò“Ó£ÀOy«Ñ¦jc(=•ÒµÖÀOÙÐ0ñ%·ïG¥ñ`Œžë¬¡¸51M–Ùl¿Ég™‹Í~6Á›J”N½fsÌÃ3K›ÿ@Ò¢~ÀOÃq!‹2)wüK•L+2V°4K›ÿ@Ò¢~ÀOÃq€T'ò‚÷‘B½”ñ6“Q:ì.7£VœÎÒŸ`—Ɔö䬮®‰E¹·»†z¾âí5K›ÿ@Ò¢~ÀOÃqiI~©+.Í©áp¶Ñ¡ÎÀO×]_e¸ÿ¹ÎO¸œšk§mçŠ'WFAÒƒšÀOÙлóP0µ˜Ï»‚ª½Î³óP0µ˜Ï»‚ª½Î´óP0µ˜Ï»‚ª½Îá‹MÒ…]`“gµáI6FÓ—÷ÀOEг]“šˆ—K¹$ßÉáåè¢ñþ^5N“›$×÷̈&HÇS™«3M¬¤1õ7ˆ£iÙÿçЩ; É'$â9YõÓŽ:ÀOh7Õ%â9YõÓŽ:ÀOh7Õ&â9YõÓŽ:ÀOh7Õ'â9YõÓŽ:ÀOh7Õ«³ë|šI¤’ÊÄ˃(â9YõÓŽ:ÀOh7Õã¤!FÖðsGŠœFç{H@¡FãÕS÷2I´Et€$˜¤á„#œC¤È«‘Rõ†
e.{ ŽJO°že—¯Ç/°ö”P($IªZÑ^„†€9Ÿ½À¸$í\EƒæÕ9OèÄ奄ñ‚`O’„O·\;éx‡Ð8WõFž¿ºTpjØ÷@ü­úw·iKªw^ðæèàÖ‡Åω© ÉA)!¿\_ÑЃª[Cƒ°â+ØdWЩnÀO×¢€ÿ4DLïήe+.bÀSmbŒÑ²Í`—ߌ Àœí¹Ñ˜#ÀOÙrìŽ'Œ«>ÑŒ°ÀOÙÐë¯çÑ.jÐŒxÀOÙ´ôº^QmÒƒ­ÀOÙÐd¦Ñ4 É'äô>áòÒИÀOÙr3ó€ß·Ò£;`—ß[Ôè»ÚM•ÓO°ôµ¹KúLb`w¤±GŠŽ:J˜'iÏ>ŒV–MYFDAtâÖ;&åO‘ÁF°¤íÔÛ}êÄîÒ¨\I®;¿% ›S|ƒÀ
ø»*E…
yÐŽf|§txŸMNI–{@°Ò>KëJ§‚´®\F Зî4mc-Nüv­ÖE¦c7½V…ø‹fCNÁ²I—Étw„ׄ·8A!Ó±J»©'ËÀÅ8šEûþK}4@¥¾¬°Vq’Cšš(D¾W@¤Xzv×çùF@S·Ë>L¾NdÍL·Ö¬+Ùo—.ÑEˆÿ°Ñ†¸ÞÝ·Œ"ý®ãJ†Ló‘
¸þ:Ì¿´,ÛLB°)隇ÆA» }¹jô—Lº^6CTw]§+.ÃD¦¢«¦JQÃS[bH«ÁNº¡ïAFüÀP®ÒëŠC†UŠ	.4˜zlƒ‰À'K@-ÜýtКÓý#¯F­´l…HiÇa÷w­hŠM‡½0·Yú3ÝS¿«Åá!A‰†boÂÉs½t’ÑÏÃA³^±?U§Xôè“2¦NfÛH yßuž	÷5ꥂÍÙÅG–)á]/qNnNÔ9þjòI†=¯Êæÿ¸W¤.ÖIª|çK‹ã°g
4ªÄòcH¯ïø~òæº%‚]«bÁýÃM©Ý
I]—ç7B¹¬WGC‘Q°Œl2Ñ÷¯$HíäܨEâüye64Û…¶>ùeöL :ãïerŸ=…'³ñºoÏOU{Žp‘¤¡ ¥€öO½sCůè$5¾3QBº…`ÊíÏ]v+éÀqAŽ¦¸Oö;ŠÜÙ„·.C§Z0§YcwNÁç]N·D.±®Q˜·°1RÖñ²WH¤Î¨çÆê}'ô‹óCòB“gÞ(ü#…l^"`Gšþê3¶qs0â3NvFƒZ˜9\;ûï@Z|û üK‡JÀòà¹úŽ$M—ÞÆÙ>M¿‘ôEQ ¹w“€mðjKD‰W£w? §Õec
åE‡ö
¥kjO}¶c^¿ÁNI²œe·2ÓÒíñ÷mŸ¢Gª®)ÓÆðfpñNr-¤ïOŸ&¶„oºO}N8Ðú—GË¢)³’µqÕØKmÓH¾—B" C›˜µ™[E„«|täÝü†ûë¶i!€ý¼OLˆ»'`g©ìp+Þ÷›“J½=$?xÔ’hü­K¬ÄG  M]ªk>+$Ì%|šQO€àz)(þ¾B›ÆÍâqåF–[ÍŸWª³Ã…¼m]rL§wìx,¹4ïK†§u@ºˆ+‰©ô׉#äG©``¼Âí“„µËW´é®G¡ Äß35ÞâãóÆíA„	A­ól ·ÞG؂تçíI†·æá÷Íþ‚Âï à`F“têˆQ<ü€ð÷Ëë[áM¼ƒEÄ€öªd_»ðµNŽM&uf4L—3l÷³¯×E¥ŸZIéC~Á½"ñ‚@Œ0(9ŸA8L"k1Ë÷%¸BŠ	T
#¤ÀF@ÀFDÀF[ÀFðÊ™^Aψªµiõ XשFÏ•üªh
´Mm8gÏ–ªh
´zÔó0GdÑŽ<ÀO¹8m®ö¼xˆÑƒéÀOÂÆÔ4ÈyˆÑƒéÀOÂÆÔ"ÀFFÀF’Mm8gÏ–ªh
´0ÀF1ÀF2ÀF3ÀF%ÀF)ÀF*ÀF0:s*έåªDw=IÀFè¹ë–yÒ‡.øY+ÀF&ÀFEÀFGÀFHÀFÊ:/Û†/ÑŽÀO¹˜šË:/Û†/ÑŽÀO¹˜šÌ:/Û†/ÑŽÀO¹˜šÍ:/Û†/ÑŽÀO¹˜šÎ:/Û†/ÑŽÀO¹˜šÏ:/Û†/ÑŽÀO¹˜šÇ–v\цø°WÞy”(ÌÒ ÷€_…±ÁÀFÀÀFÆÀFÕÀFÔÀFÎÀFU
8r+£C…+nó4é4ÀFâRX0eѶ£øu{ùÚ®šP9VѶ¡øu{ùðþ½ÏÏ£0ªÁne0ÕE
KvСʪÁne
y˜´âа±ÀOØܦÏ«|õxÒ–ÀO£†À¨´jÒ­IÀO£†ÐàQžnÒ–ÀO£†0îüŒ½9иѠ$«-»¸1.¦Ð¦Å É¯EÀ^¼ƒ*oСĪÁneÀÞP«oСĪÁne |Œ~|Б?ªÁne?Ç¦üàЗP É¯E^æ#ŠÂ1Љ $«-»á?îƒÙWй2 $«-»â?îƒÙWй2 $«-»pðwµâ~Б?ªÁneg­‡Ð‘@ªÁneñ˳ÁjˆÐ‘@ªÁneò˳ÁjˆÐ‘@ªÁneã?îƒÙWй2 $«-»~{ŒS^ÒЗB É¯Eyð¾|„ªKD¼phäƒê¼KΔӳѹ´ÀOØÕ°ž™rÀIúÑ ¯ÀO£†x…hиÀO×ìà{ËlhиÀO×ìðÙÃ\Ñ•¾`——êOßOðÎrþÒ‡¥ÀOh7Ïü¬y½)ÓŽ
ÀOh7ÕBÐTyI¼²6¾Eºˆú9ì¯øÅA„!8¾ÒFs°%çÍÉÌE‘~2]rú´Îg¤óO!˜BŽ°>9ù}˜Œ®—‡ÓN¾r*GÝ“°¥ùkF³ðNª]Í·gh±hÏ“ægÙA‡c™*î^Z¡%­È”2îAeqKÐW»'ìØ;?B@±
JÏÙ$ÔSõQ¦À‹´Òµí`—Ɔö†(ÂœŽÜÒ±ÐÀOŽë>’ƒÛñ1sÐŒ™ É-¿èªO(hHjÐŒxÀOÙ´…ÀiQÍD”¯(ߥlù+ ‹rˆ÷Î’­ª§LÐm‚CçîB¼U¡âaÃ{þÓ°Ÿ~Ÿ‘C«.›`1“y‹Á¼º/D€ÄŠYÃF;3bpcã(J¥g
·€æ×ØДէ{E³´Î]º¬ˆ°­é½ÆEŽ)П“SáãØ-<¨©M£0G$4[¡¾“Vÿà,HMµÅ@}͹2Ý­H¥<$A«ãµ§%1²efþÊà¹I¡x+\´’¥ÚýhŠÜ LŒëAfCµ¦%§ñ°”¼D–áB–£Râm§>¶…oE¡œHžú…‹?¾syûYz(©º—º“X‡G§áA'qQU”‚AÿJ€ú
sêÌY!ëW«O«Zåú{ê*lñ×ðg²(M‹â2¥Ä(¼ÿ ‚TfC¾'>çŽÂ|a.» 	ÑšÀOÂÖÁî±;•´“ј£ÀO¶‡Ú.K[ãÚÁKŸ8¼õÔ…¶¤³…¶H™Ù]êÒ‡26 Ù-&{ÐŒ© É-¿èráë:Љ³ É
¬ü%äwùËCºj»W'tVaämÑyî«!@‘i²aÖWBóýVmýЕŠ`—É •I-`:±›B¦n5äOCÚšÑL¥%2J³·4{î[ãkY¦s=ÐåBM¯ÀQ!ºB\[–ˆ/B{N€sASÃÖ¦.À̆I›#t9JD¨f?kјÀH¢"ûÞtâûÅ»˜‘ªìÌ-G¾í¤ös?z¥ZÕA°žže¬!`[ǽ6îæN¾XXâ$µ¶ÓßÁéK…ö¦iiôöÅ‘£•Ôž(L„«žqžm®å–ájKÆHªˆ(.~,-Y@ƒo‚3\.Q¸ŸÉåëC£pðg{‡L\l%µùæI»·£ÂTÀŸß¿°õµŒK”Ižs<_«z”\
L´ÖK÷ƒoÉø(t¦ã;sM³|¥@¿ø•)Ù^ÏvJ¿YêÓž¢¹~+IÇzŽÃŠC‡ÛhsxDÿp§ØÎWJ?,C“P0òDƒ÷OôAÑoËZ\ÊÜq"ütD·Åk¬â×¾®‡TLžrTŒöIkE
àaÿ`N’Ne7¶Ý6ò‹Œì_I˜”‘Õ|k’H¢rYøˆšM>sáë:Љ³ É
¬ë¯çÑ.jÐŒxÀOÙ´ðË¡d:aD‘X7iii9PÛ5—}+E‰ut¨X(ÓT6QøB~ÛœC…ñä]_È#ͼ„Þ_ÛL®¤¯d¸=x«ˆr|Õ­ÔhG¾–•2Ù`Òýæ?uIœŒ¦Ÿ£p4Bf6×—K›ƒt„©Ð3
SNæwL£¬1Ð"(i¡v”ù¬@È	Yè‡G€ºØ­+ÐÀO×ÐbÈCß¾Ó‹4`—ß[Ô„L¼Òr?RJ¦{Ëó˜,»AÛs…EŽO¨ŒW¡£L›Ñ‹"ÀOÙÐ7vî8áуyÀOÙÐà½äühK€KŽœt&1Zsˆ~¯§:6›B¨ã÷}Ft¤ˆrØ⋪†GM·v2̤pŠDÍ´†œfD’.b[‡®€Gåvt­ãH¦•;© ¯ñ
zæ<§±ŠñDCÒü¿kÐÊ?}ùÖHƒ2”lwâGtq
$SÖJ¦ÓÔ”<ûþ=Õ•òwo-N¸®2/>rµ\Úí£˜GŠÛÅçÚ™±—YýÆkŸˆH‡”èŒÞ?x‡Š§9Jª³£›œ4§Ùu´Y&¸î·H³xHÏ£‚'¶éGˆVÁBeUNO…yדس„Dƒg,Ý ÎÖeÆùòÂL¿3ƒ"×5/QÞóqíCA„wéSk‚5X§;-î3ÕB»{_41ØlxƱ•ˆ´L¥b
VBPƒo¯zÈþù5zD­· #D‘@Fègmœ[¸Mœ¼Ýá/BTñ|\¹ŽÔ?@«™ÖÇz„¬ìpà¼ÀD—°FÇÉ[žÜ0é	49Zуú É
ÈI}ÑÞA³ÖaB™}ˆÆKXÐ䌠%ú«Dµ|DZÃ#à¹ø&ˆ¨o‡IªÞêï¿èQ–d5ÀCþÕv†Sdn0@Dš×ÐHˆæ¤&’'›û®ûÒÖñŒEŒ4V˜w¢Ò˜n¨B*O—øŠôà&Ù-bØÑÞfôM¿lV!™jñt§¨Â€àIˆ…$ëÄ[a½#FVOD‚JªëÎí“ú’
ö
hÖF³XÖapÝäf_Ï:ÛqúJð?Äýò¥¸±é§PïpÑ·Z ÉdþÀF K6ó¹eΩºªJè7`, ê:i¢×+00ÀFh3©ÝM¸nÚãMÜ™ŠS{5”)ÊxKƒ®èþt	OÏó¨°3C«KˆsË­¤‹“w`µ¬$ÇD‚âƒ&ªl·´;ýÝ0M£HŸµÖ¿þR¸×UÑöòBªu‡(¡²ÒdÆT&©àaërr†C‘uòäÆ‹.|uUÐ:WˆPH’w¸[ÛŽ	œZÜŠèÞM¥¡`ø* ®÷óâ´À!ºsGº3^ÉFë‹0ÇðMßãJ‘Sªk‚éyZ
8—Ñy
ÈM 3íˆ,/¡KáqóI\ŒœMš;T¦‚QI·!ÍøË[Y
,ð!¾PCˆ°sgü–ï<«Œ!’ªì5C3€Ò4Âî¬a@ðY?J©TwZ¥Àƒ®8—™•ˆKžMn錕RÚHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSuna/pam/pmCorExitProcessmscoree.dlløCPCTZSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecLC_TIMELC_NUMERICLC_MONETARYLC_CTYPELC_COLLATELC_ALLxºB¾Û@lºB(üBYšA`ºB(üB™ƒATºB(üB“—AHºB(üB•A@ºB(üB”A	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;EncodePointerKERNEL32.DLLDecodePointerFlsFreeFlsSetValueFlsGetValueFlsAllocruntime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODEÀÀ–ÀÀŽÀÀÀ‘À’À“ÀSystemFunction036ADVAPI32.DLL         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿunited-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamericanÌÏBENU¸ÏBENU¤ÏBENU˜ÏBENAÏBNLB„ÏBENC€ÏBZHH|ÏBZHItÏBCHS`ÏBZHHLÏBCHS8ÏBZHI$ÏBCHTÏBNLBÏBENUôÎBENAäÎBENLØÎBENCÄÎBENB¸ÎBENI¨ÎBENJœÎBENZ„ÎBENShÎBENT\ÎBENGPÎBENUDÎBENU4ÎBFRB$ÎBFRCÎBFRLÎBFRSðÍBDEAÜÍBDECÈÍBDEL¸ÍBDES¨ÍBENI˜ÍBITSŒÍBNORxÍBNORdÍBNONLÍBPTB8ÍBESS(ÍBESBÍBESLÍBESOðÌBESCÔÌBESDÄÌBESF°ÌBESEœÌBESGˆÌBESHxÌBESMhÌBESNTÌBESIDÌBESA0ÌBESZ ÌBESRÌBESUüËBESYèËBESVØËBSVFÐËBDESÌËBENGÈËBENUÄËBENU¼ËBUSA´ËBGBR¬ËBCHN¤ËBCZEœËBGBRŒËBGBR„ËBNLDxËBHKGlËBNZLhËBNZL\ËBCHNPËBCHNDËBPRI<ËBSVK,ËBZAF ËBKORËBZAFËBKORðÊBTTOÌËBGBRàÊBGBRÐÊBUSAÈËBUSA6-0OCPACPNorwegian-NynorskGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLL€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwppCONIN$CONOUT$TMPH€ñBPÔBRSDSÀ“[=Fñ²L–™Œ8$ÚÿQo:\src\python-3-trunk\lib\distutils\command\wininst-9.0.pdbP4dŒþÿÿÿÔÿÿÿþÿÿÿ†@þÿÿÿÔÿÿÿþÿÿÿ€@þÿÿÿÔÿÿÿþÿÿÿŸƒ@þÿÿÿÔÿÿÿþÿÿÿ„@þÿÿÿ„ÿÿÿþÿÿÿn‡@þÿÿÿÔÿÿÿþÿÿÿŠˆ@þÿÿÿÔÿÿÿþÿÿÿ@þÿÿÿÔÿÿÿþÿÿÿü‘@þÿÿÿÔÿÿÿþÿÿÿ…£@þÿÿÿÐÿÿÿþÿÿÿ;°@þÿÿÿÈÿÿÿþÿÿÿU²@þÿÿÿÈÿÿÿþÿÿÿ ¶@þÿÿÿˆÿÿÿþÿÿÿ¥¸@©¸@þÿÿÿk¸@¸@þÿÿÿÔÿÿÿþÿÿÿOº@kº@þÿÿÿ´ÿÿÿþÿÿÿnÁ@þÿÿÿØÿÿÿþÿÿÿ"Æ@þÿÿÿØÿÿÿþÿÿÿZÆ@þÿÿÿÔÿÿÿþÿÿÿ›Æ@þÿÿÿÔÿÿÿþÿÿÿÆÑ@þÿÿÿÌÿÿÿþÿÿÿÒÕ@þÿÿÿÔÿÿÿþÿÿÿtÙ@þÿÿÿØÿÿÿþÿÿÿçÚ@þÿÿÿóÚ@þÿÿÿÔÿÿÿþÿÿÿ¡Û@þÿÿÿ­Û@þÿÿÿÌÿÿÿþÿÿÿÊè@ˆè@™è@þÿÿÿÔÿÿÿþÿÿÿ_ë@þÿÿÿnë@þÿÿÿØÿÿÿþÿÿÿ!í@þÿÿÿ-í@þÿÿÿÔÿÿÿþÿÿÿcò@þÿÿÿÔÿÿÿþÿÿÿûAþÿÿÿÈÿÿÿþÿÿÿÁAýAþÿÿÿÔÿÿÿþÿÿÿ³AþÿÿÿŒÿÿÿþÿÿÿˆAŒAþÿÿÿÔÿÿÿþÿÿÿx*AþÿÿÿÐÿÿÿþÿÿÿÕ+AþÿÿÿÌÿÿÿþÿÿÿ_-A+-AþÿÿÿÔÿÿÿþÿÿÿ±-AþÿÿÿÐÿÿÿþÿÿÿSAþÿÿÿÐÿÿÿþÿÿÿN[AþÿÿÿÐÿÿÿþÿÿÿ˜cAþÿÿÿÔÿÿÿþÿÿÿâkAþÿÿÿØÿÿÿþÿÿÿ‹mAŸmAþÿÿÿØÿÿÿþÿÿÿÝmAámAþÿÿÿØÿÿÿþÿÿÿ-nA1nAþÿÿÿÐÿÿÿþÿÿÿŸpAþÿÿÿÐÿÿÿþÿÿÿsAþÿÿÿÀÿÿÿþÿÿÿÂtAþÿÿÿÐÿÿÿþÿÿÿÙwAðwAþÿÿÿÐÿÿÿþÿÿÿÒAþÿÿÿÔÿÿÿþÿÿÿª‚AþÿÿÿÐÿÿÿþÿÿÿƒAþÿÿÿÔÿÿÿþÿÿÿÜAþÿÿÿÔÿÿÿþÿÿÿ»ÝAþÿÿÿÐÿÿÿþÿÿÿ(BþÿÿÿÌÿÿÿþÿÿÿÆBþÿÿÿÔÿÿÿþÿÿÿrBþÿÿÿÐÿÿÿþÿÿÿ	BþÿÿÿÔÿÿÿþÿÿÿN	BþÿÿÿÌÿÿÿþÿÿÿIBþÿÿÿÌÿÿÿþÿÿÿBþÿÿÿÐÿÿÿþÿÿÿX BþÿÿÿÐÿÿÿþÿÿÿô BþÿÿÿÐÿÿÿþÿÿÿ†6BþÿÿÿÐÿÿÿþÿÿÿ¡:BþÿÿÿÐÿÿÿþÿÿÿBþÿÿÿÀÿÿÿþÿÿÿ†CBþÿÿÿÐÿÿÿþÿÿÿ2DBDBÐÝ‚à(PÞLãXPØßèä0RÜÝpå4P¨ÝæPÐß2æ(RDàtæœRàåŒåšåæòåzåÎå¾å®åfàTàNå>å2å&åååôä\åÒáàáðáâââ2âBâVâfâvâŠâžâ²âÆâØâîâãã6ãìöëÄáÒëÆë¶ë ëë|ëlëVëDë.ëë
ëúêêêÔêÄêªêêvê^êDêêêîé²á¦á˜áˆává`áTáäëBá4á$ááþàðàÚàÊà´à ààâéÐéÀéì®é”é~æ˜æ¤æ°æÈæâæççç6çNç`çrç€ç”çœçªç¼çÎçâçþçè0èFè`èlè„èœè¦è²èÄèÒèÞèìèöèéé(é6éNé^énézé"ætãhã>äÜäÎä¸ä¬äœäŒä~äpä^äLäZã.äääúãîãÞãÊã¶ã®ã¢ã’ã€ãdæ>æPæƒPropertySheetACreatePropertySheetPageACOMCTL32.dllôSetLastErrormCreateDirectoryAÊGetFileAttributesAMapViewOfFilezCreateFileMappingADCloseHandleëSetFileTimeÑDosDateTimeToFileTimeçGetLastErroryCreateFileAKUnmapViewOfFile¿lstrlenAMultiByteToWideChar"GetProcAddressöLoadLibraryAÁDeleteFileAnReadFileçSetFilePointerÕGetFileSizeMFreeLibrarySetStdHandle>GetStdHandleLocalFreeHFormatMessageA\GetTempFileNameA^GetTempPathA÷GetModuleHandleAzGetVersionExA•ResumeThreadþSetPriorityClassªGetCurrentProcess­GetCurrentThreadSetThreadPriority•CreateProcessAõGetModuleFileNameAƒRemoveDirectoryAGetPrivateProfileIntAGetPrivateProfileStringAöGetModuleFileNameWKERNEL32.dlløMessageBoxA$GetFocuswsprintfAvSetDlgItemTextA^SendMessageALReleaseDCGetDC¨DispatchMessageAÕTranslateMessagePeekMessageAÕEndPaintoGetSystemMetricsBeginPaint•DefWindowProcAéUpdateWindow¸ShowWindowgCreateWindowExA3RegisterClassAÒLoadCursorAMoveWindowˆGetWindowRectPostMessageAUGetParentYSendDlgItemMessageAGetDlgItempSetCursorUSER32.dll4CreateDIBitmapÐDeleteObjectSetTextColorŸTextOutAfSetBkMode^SelectObject:CreateFontARCreateSolidBrushGDI32.dllfRegQueryValueA*RegCloseKeygRegQueryValueExAHRegEnumKeyExAZRegOpenKeyExAwRegSetValueExA2RegCreateKeyExA7RegDeleteKeyAARegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dllkCoUninitializeCoCreateInstance=CoInitializeole32.dllSGetSystemTimeAsFileTime¦HeapFree¢HeapAllocFileTimeToSystemTimeFileTimeToLocalFileTimeÑGetFileInformationByHandleCPeekNamedPipeØGetFileTypeÚEnterCriticalSectionôLeaveCriticalSectionlGetTimeFormatA¯GetDateFormatA©HeapReAllocúGetModuleHandleW+SleepExitProcesspGetCommandLineA<GetStartupInfoA7TerminateProcessHUnhandledExceptionFilterSetUnhandledExceptionFilterÖIsDebuggerPresent„WideCharToMultiByteoGetTimeZoneInformation\GetCPInfoÅInterlockedIncrementÁInterlockedDecrementSGetACPGetOEMCPàIsValidCodePage>TlsGetValue<TlsAlloc?TlsSetValue=TlsFree®GetCurrentThreadId¤HeapCreate¥HeapDestroyaVirtualFree¿DeleteCriticalSectionFatalAppExitA^VirtualAlloc—WriteFileØSetEnvironmentVariableAÙSetEnvironmentVariableWðSetHandleCount„GetConsoleCP–GetConsoleModešRtlUnwind¯SetConsoleCtrlHandlerÂInterlockedExchangeºInitializeCriticalSectionAndSpinCountKFreeEnvironmentStringsAÀGetEnvironmentStringsLFreeEnvironmentStringsWÂGetEnvironmentStringsWYQueryPerformanceCounterjGetTickCount«GetCurrentProcessIdæLCMapStringAèLCMapStringW@GetStringTypeACGetStringTypeWrGetUserDefaultLCIDéGetLocaleInfoAùEnumSystemLocalesAâIsValidLocaleBFlushFileBuffersŒWriteConsoleAšGetConsoleOutputCP–WriteConsoleW«HeapSizeëGetLocaleInfoWVCompareStringWSCompareStringAÕSetEndOfFile&GetProcessHeapÿÿÿÿ(UB$UBUB$UBUB$UBUBUBøTB$UB(UBäTBUBäTBUB$UBUBUBøTB$UBSoftware\Microsoft\Windows\CurrentVersion\UninstallÌTB¼TB¬TBŒTBtTB\TBLTB4TB$TBTBTB1@ðSB@àSB@ÐSBu@@¼SB®@@°SB@@Software\Microsoft\Windows\CurrentVersion\UninstallNæ@»±¿D *C *C¼¹B¸¹B´¹B°¹B¬¹B¨¹B¤¹Bœ¹B”¹BŒ¹B€¹Bt¹Bl¹B`¹B\¹BX¹BT¹BP¹BL¹BH¹BD¹B@¹B<¹B8¹B4¹B0¹B(¹B¹B¹B¹BL¹B¹Bü¸Bô¸Bè¸Bà¸BÔ¸BȸBĸBÀ¸B´¸B ¸B”¸B	ôBN¶@ÿÿÿÿÿÿÿÿ€pðñÿÿPSTPDTõB@õB
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ÷B¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þÌÅBþÿÿÿC(üB(üB(üB(üB(üBCÈÃBPÈBÐÉBôB0üB0üB÷BÿÿÿÿÿÿÿÿøÀBÌÀB	 ÀB
ÀBÜ¿B¬¿Bˆ¿B\¿B$¿Bü¾BľBŒ¾Bd¾BD¾Bà½B ¨½B!°¼B"¼Bx¼Byð»Bzà»BüÜ»BÿÌ»Bÿÿÿÿ€
œÁBŒÁB!B!B!B!B!B!B!B!B!B!Bx
ÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/MlÈÃBÊÅB.CôCôCôCôCôCôCôCôCôCC. “þÿÿÿþÿÿÿ(€@€p€nˆ€k €l¸€mЀn耀	(	8	H	X	hxA
ä€K ä Mä$OZä€Qä”RZä(n, 	ÿÿÿçççÞÞÞÖÖÖ½½½„„„BBB999111)))Þÿ¥cîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîïÿÿîîîîïÿÿÿÿîïÿÿÿÿîïÿÿÿÿÿÿÿîîîîïÿÿÿÿîïÿÿÿÿÿîîîîîîîîîîîîÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿþÿÿÿÿÿÿÿÿþîîîÿÿÿÿÿþÿÿÿÿÿÿþîîîîîîîîîîïÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþîîïÿÿÿÿÿÿÿÿÿÿÿÿþîîîîîîîîîîÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¿¶¿ÿÿ¶¦¦¿ÿ¶¿ÿþîîÿ¶¦¦¿ÿÿ¶¦¦¦¿ÿþîîîîîîîîîîûR[ÿÿÿÿúRABZÿúRYRZÿúRAB[ûR[ÿþîïúRAB[ÿúRAAB[ÿþîîîîîîîîîîö &ÿÿÿÿ¥¯¥¯¥&Æ &ÿþîÿ¥&ÿ¥&ÿþîîîîîîîîîîú@JÿÿÿûQ1AA1ZQ1111ZQ1AAZú@JÿÿÿûQ1AAZûQ1AAJÿþîîîîîîîîîîö¦¦¿ö ¦¥eu†¦ÿÿÿö eu†¦ ¦¥ÿþîîîîîîîîîîú@ABZú@Jÿú@G@F@F@G@AABX@Jÿÿÿú@AABX@Jÿù@Jÿþîîîîîîîîîîö¦ÿö¯ÿ¶¦ÿ¥ÿþîîîîîîîîîîú@AA1X@Jÿú@G@HRX@G@AAG@ZúRX@AAG@JúQJÿþîîîîîîîîîîöed%¦¥¦¦ed•%ed•ÿþîîîîîîîîîîú@AA1ZQ1AA1X@Jÿú@HQ1AA1X@1A1ZQ1AA1ZQ1A1Jÿþîîîîîîîîîîö ¯¥¦ &ÿö &¥¦ ¯¥¯¥ÿþîîîîîîîîîîûRAABZÿúRABZûR[ÿûR[úRABZûRYRBZÿúRABZÿúRBW@Jÿþîîîîîîîîîîÿ¶¦¦¦¿þÿ¶¦¦¿ÿ¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿¶¦¿ÿÿ¶¦¦¿ÿÿ¶¦¦ÿþîîîîîîîîîîïÿÿüÿÿþïÿÿÿÿÿÿÿîÿüÿÿÿüÿÿÿüÿÿüÿÿÿÿüÿÿÿÿÿÿú@Jÿþîîîîîîîîîîîîÿ¶¿ÿþîîîÿ¶¿ÿþîÿ¶¿ÿÿ¶¿ÿÿ¶¿ÿ¶¦¦¿ÿ¶¿ÿÿ¶¿ÿö &ÿþîîîîîîîîîîîîûR[ÿþîîîûR[ÿþîûR[ÿûR[ÿûR[úRABZûR[ÿûR[ÿûR[ÿîîîîîîîîîîîîîö &ÿþîîîö &ÿþîö &ÿö &ÿö &¥¦ &ÿö &ÿÿ¶¿þîîîîîîîîîîîîîú@Jÿÿÿÿîú@Jÿÿîú@Jÿú@Jÿú@HQ1AA1X@Jÿú@Jÿÿÿÿîîîîîîîîîîîîîîöÿÿÿÿþöÿÿþöÿöÿö¦¥ÿ¥ÿþîîîîîîîîîîîîîîîîú@Jÿÿÿÿÿú@Jÿÿÿú@Jÿú@Jÿú@G@Jÿú@G@JúQJÿþîîîîîîîîîîîîîîîîö¦¦¿ÿÿ¥¯ÿÿöÿö¦¥ÿö¥ÿþîîîîîîîîîîîîîîîîú@ABZÿúQ11Zÿÿú@Jÿú@AAG@Jÿú@G@GQ1Jÿþîîîîîîîîîîîîîîîîö¯¥¯ÿöÿöÿöÿþîîîîîîîîîîîîîîîîú@AA1ZQ1YQ1[ÿú@Jÿú@AAG@Jÿú@G@1W@Jÿþîîîîîîîîîîîîîîîîö¦¥¯¥&ÿöÿö¦¥ÿö¦ÿþîîîîîîîîîîîîîîîîú@Iüù@G@Jÿú@Jÿú@Jÿú@Jÿú@G@Jÿú@G@Zú@Jÿþîîîîîîîîîîîîîîîîö¦¥ÿö¦¥¦¦ÿö¦¥¯öÿþîîîîîîîîîîîîîîîîú@AA1X@Jÿú@HRABX@Jÿú@HQ1AA1X@Jÿú@Jÿþîîîîîîîîîîîîîîîîö ¦ &ÿö  %&ÿö &¥¦ &ÿö &ÿþîîîîîîîîîîîîîîîîûRAABZûR[ÿûRZRAAABZR[ÿûR[úRABZûR[ÿûR[ÿîîîîîîîîîîîîîîîîîÿ¶¦¦¦¿ÿ¶¿þÿ¶¿¶¦¦¦¦¿¶¿þÿ¶¿ÿ¶¦¦¿ÿ¶¿þÿ¶¿þîîîîîîîîîîîîîîîîîïÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿÿÿÿÿÿÿÿÿîïÿÿîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîîÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.°P}÷ƒýÿÿPh£ÿÿ‚ÿÿnP}£÷ÿÿ‚ÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Select python installation to use:€P¿ˆµïÿÿP}‰7ÿÿÿÿÿÿ‚Python Directory:¡P}÷jþÿÿƒPh£ÿÿ‚ÿÿn€P¿µðÿÿP}žBÿÿÿÿÿÿ‚Installation Directory:@B2ÿÿ€Find other ...ÿÿ@ÀH{²SetupMS Sans SerifP}
öèÿÿ‚Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.€P}öëmsctls_progress32Progress1P}‰öìÿÿ‚Installation progress:Ph£ÿÿ‚ÿÿnPAÿÿ@ÀH{²SetupMS Sans SerifP}
÷èÿÿ‚Click the Finish button to exit the Setup wizard.Ph£ÿÿ‚ÿÿn°P}(÷ƒìÿÿ
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/config.py0000644000175100001710000001133300000000000021620 0ustar00runnerdocker"""distutils.pypirc

Provides the PyPIRCCommand class, the base class for the command classes
that uses .pypirc in the distutils.command package.
"""
import os
from configparser import RawConfigParser

from distutils.cmd import Command

DEFAULT_PYPIRC = """\
[distutils]
index-servers =
    pypi

[pypi]
username:%s
password:%s
"""

class PyPIRCCommand(Command):
    """Base command that knows how to handle the .pypirc file
    """
    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
    DEFAULT_REALM = 'pypi'
    repository = None
    realm = None

    user_options = [
        ('repository=', 'r',
         "url of repository [default: %s]" % \
            DEFAULT_REPOSITORY),
        ('show-response', None,
         'display full response text from server')]

    boolean_options = ['show-response']

    def _get_rc_file(self):
        """Returns rc file path."""
        return os.path.join(os.path.expanduser('~'), '.pypirc')

    def _store_pypirc(self, username, password):
        """Creates a default .pypirc file."""
        rc = self._get_rc_file()
        with os.fdopen(os.open(rc, os.O_CREAT | os.O_WRONLY, 0o600), 'w') as f:
            f.write(DEFAULT_PYPIRC % (username, password))

    def _read_pypirc(self):
        """Reads the .pypirc file."""
        rc = self._get_rc_file()
        if os.path.exists(rc):
            self.announce('Using PyPI login from %s' % rc)
            repository = self.repository or self.DEFAULT_REPOSITORY

            config = RawConfigParser()
            config.read(rc)
            sections = config.sections()
            if 'distutils' in sections:
                # let's get the list of servers
                index_servers = config.get('distutils', 'index-servers')
                _servers = [server.strip() for server in
                            index_servers.split('\n')
                            if server.strip() != '']
                if _servers == []:
                    # nothing set, let's try to get the default pypi
                    if 'pypi' in sections:
                        _servers = ['pypi']
                    else:
                        # the file is not properly defined, returning
                        # an empty dict
                        return {}
                for server in _servers:
                    current = {'server': server}
                    current['username'] = config.get(server, 'username')

                    # optional params
                    for key, default in (('repository',
                                          self.DEFAULT_REPOSITORY),
                                         ('realm', self.DEFAULT_REALM),
                                         ('password', None)):
                        if config.has_option(server, key):
                            current[key] = config.get(server, key)
                        else:
                            current[key] = default

                    # work around people having "repository" for the "pypi"
                    # section of their config set to the HTTP (rather than
                    # HTTPS) URL
                    if (server == 'pypi' and
                        repository in (self.DEFAULT_REPOSITORY, 'pypi')):
                        current['repository'] = self.DEFAULT_REPOSITORY
                        return current

                    if (current['server'] == repository or
                        current['repository'] == repository):
                        return current
            elif 'server-login' in sections:
                # old format
                server = 'server-login'
                if config.has_option(server, 'repository'):
                    repository = config.get(server, 'repository')
                else:
                    repository = self.DEFAULT_REPOSITORY
                return {'username': config.get(server, 'username'),
                        'password': config.get(server, 'password'),
                        'repository': repository,
                        'server': server,
                        'realm': self.DEFAULT_REALM}

        return {}

    def _read_pypi_response(self, response):
        """Read and decode a PyPI HTTP response."""
        import cgi
        content_type = response.getheader('content-type', 'text/plain')
        encoding = cgi.parse_header(content_type)[1].get('charset', 'ascii')
        return response.read().decode(encoding)

    def initialize_options(self):
        """Initialize options."""
        self.repository = None
        self.realm = None
        self.show_response = 0

    def finalize_options(self):
        """Finalizes options."""
        if self.repository is None:
            self.repository = self.DEFAULT_REPOSITORY
        if self.realm is None:
            self.realm = self.DEFAULT_REALM
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/core.py0000644000175100001710000002210200000000000021277 0ustar00runnerdocker"""distutils.core

The only module that needs to be imported to use the Distutils; provides
the 'setup' function (which is to be called from the setup script).  Also
indirectly provides the Distribution and Command classes, although they are
really defined in distutils.dist and distutils.cmd.
"""

import os
import sys
import tokenize

from distutils.debug import DEBUG
from distutils.errors import *

# Mainly import these so setup scripts can "from distutils.core import" them.
from distutils.dist import Distribution
from distutils.cmd import Command
from distutils.config import PyPIRCCommand
from distutils.extension import Extension

# This is a barebones help message generated displayed when the user
# runs the setup script with no arguments at all.  More useful help
# is generated with various --help options: global help, list commands,
# and per-command help.
USAGE = """\
usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
   or: %(script)s --help [cmd1 cmd2 ...]
   or: %(script)s --help-commands
   or: %(script)s cmd --help
"""

def gen_usage (script_name):
    script = os.path.basename(script_name)
    return USAGE % vars()


# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
_setup_stop_after = None
_setup_distribution = None

# Legal keyword arguments for the setup() function
setup_keywords = ('distclass', 'script_name', 'script_args', 'options',
                  'name', 'version', 'author', 'author_email',
                  'maintainer', 'maintainer_email', 'url', 'license',
                  'description', 'long_description', 'keywords',
                  'platforms', 'classifiers', 'download_url',
                  'requires', 'provides', 'obsoletes',
                  )

# Legal keyword arguments for the Extension constructor
extension_keywords = ('name', 'sources', 'include_dirs',
                      'define_macros', 'undef_macros',
                      'library_dirs', 'libraries', 'runtime_library_dirs',
                      'extra_objects', 'extra_compile_args', 'extra_link_args',
                      'swig_opts', 'export_symbols', 'depends', 'language')

def setup (**attrs):
    """The gateway to the Distutils: do everything your setup script needs
    to do, in a highly flexible and user-driven way.  Briefly: create a
    Distribution instance; find and parse config files; parse the command
    line; run each Distutils command found there, customized by the options
    supplied to 'setup()' (as keyword arguments), in config files, and on
    the command line.

    The Distribution instance might be an instance of a class supplied via
    the 'distclass' keyword argument to 'setup'; if no such class is
    supplied, then the Distribution class (in dist.py) is instantiated.
    All other arguments to 'setup' (except for 'cmdclass') are used to set
    attributes of the Distribution instance.

    The 'cmdclass' argument, if supplied, is a dictionary mapping command
    names to command classes.  Each command encountered on the command line
    will be turned into a command class, which is in turn instantiated; any
    class found in 'cmdclass' is used in place of the default, which is
    (for command 'foo_bar') class 'foo_bar' in module
    'distutils.command.foo_bar'.  The command class must provide a
    'user_options' attribute which is a list of option specifiers for
    'distutils.fancy_getopt'.  Any command-line options between the current
    and the next command are used to set attributes of the current command
    object.

    When the entire command-line has been successfully parsed, calls the
    'run()' method on each command object in turn.  This method will be
    driven entirely by the Distribution object (which each command object
    has a reference to, thanks to its constructor), and the
    command-specific options that became attributes of each command
    object.
    """

    global _setup_stop_after, _setup_distribution

    # Determine the distribution class -- either caller-supplied or
    # our Distribution (see below).
    klass = attrs.get('distclass')
    if klass:
        del attrs['distclass']
    else:
        klass = Distribution

    if 'script_name' not in attrs:
        attrs['script_name'] = os.path.basename(sys.argv[0])
    if 'script_args'  not in attrs:
        attrs['script_args'] = sys.argv[1:]

    # Create the Distribution instance, using the remaining arguments
    # (ie. everything except distclass) to initialize it
    try:
        _setup_distribution = dist = klass(attrs)
    except DistutilsSetupError as msg:
        if 'name' not in attrs:
            raise SystemExit("error in setup command: %s" % msg)
        else:
            raise SystemExit("error in %s setup command: %s" % \
                  (attrs['name'], msg))

    if _setup_stop_after == "init":
        return dist

    # Find and parse the config file(s): they will override options from
    # the setup script, but be overridden by the command line.
    dist.parse_config_files()

    if DEBUG:
        print("options (after parsing config files):")
        dist.dump_option_dicts()

    if _setup_stop_after == "config":
        return dist

    # Parse the command line and override config files; any
    # command-line errors are the end user's fault, so turn them into
    # SystemExit to suppress tracebacks.
    try:
        ok = dist.parse_command_line()
    except DistutilsArgError as msg:
        raise SystemExit(gen_usage(dist.script_name) + "\nerror: %s" % msg)

    if DEBUG:
        print("options (after parsing command line):")
        dist.dump_option_dicts()

    if _setup_stop_after == "commandline":
        return dist

    # And finally, run all the commands found on the command line.
    if ok:
        return run_commands(dist)

    return dist

# setup ()


def run_commands (dist):
    """Given a Distribution object run all the commands,
    raising ``SystemExit`` errors in the case of failure.

    This function assumes that either ``sys.argv`` or ``dist.script_args``
    is already set accordingly.
    """
    try:
        dist.run_commands()
    except KeyboardInterrupt:
        raise SystemExit("interrupted")
    except OSError as exc:
        if DEBUG:
            sys.stderr.write("error: %s\n" % (exc,))
            raise
        else:
            raise SystemExit("error: %s" % (exc,))

    except (DistutilsError,
            CCompilerError) as msg:
        if DEBUG:
            raise
        else:
            raise SystemExit("error: " + str(msg))

    return dist


def run_setup (script_name, script_args=None, stop_after="run"):
    """Run a setup script in a somewhat controlled environment, and
    return the Distribution instance that drives things.  This is useful
    if you need to find out the distribution meta-data (passed as
    keyword args from 'script' to 'setup()', or the contents of the
    config files or command-line.

    'script_name' is a file that will be read and run with 'exec()';
    'sys.argv[0]' will be replaced with 'script' for the duration of the
    call.  'script_args' is a list of strings; if supplied,
    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
    the call.

    'stop_after' tells 'setup()' when to stop processing; possible
    values:
      init
        stop after the Distribution instance has been created and
        populated with the keyword arguments to 'setup()'
      config
        stop after config files have been parsed (and their data
        stored in the Distribution instance)
      commandline
        stop after the command-line ('sys.argv[1:]' or 'script_args')
        have been parsed (and the data stored in the Distribution)
      run [default]
        stop after all commands have been run (the same as if 'setup()'
        had been called in the usual way

    Returns the Distribution instance, which provides all information
    used to drive the Distutils.
    """
    if stop_after not in ('init', 'config', 'commandline', 'run'):
        raise ValueError("invalid value for 'stop_after': %r" % (stop_after,))

    global _setup_stop_after, _setup_distribution
    _setup_stop_after = stop_after

    save_argv = sys.argv.copy()
    g = {'__file__': script_name, '__name__': '__main__'}
    try:
        try:
            sys.argv[0] = script_name
            if script_args is not None:
                sys.argv[1:] = script_args
            # tokenize.open supports automatic encoding detection
            with tokenize.open(script_name) as f:
                code = f.read().replace(r'\r\n', r'\n')
                exec(code, g)
        finally:
            sys.argv = save_argv
            _setup_stop_after = None
    except SystemExit:
        # Hmm, should we do something if exiting with a non-zero code
        # (ie. error)?
        pass

    if _setup_distribution is None:
        raise RuntimeError(("'distutils.core.setup()' was never called -- "
               "perhaps '%s' is not a Distutils setup script?") % \
              script_name)

    # I wonder if the setup script's namespace -- g and l -- would be of
    # any interest to callers?
    #print "_setup_distribution:", _setup_distribution
    return _setup_distribution

# run_setup ()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/cygwinccompiler.py0000644000175100001710000004166200000000000023561 0ustar00runnerdocker"""distutils.cygwinccompiler

Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
handles the Cygwin port of the GNU C compiler to Windows.  It also contains
the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
cygwin in no-cygwin mode).
"""

# problems:
#
# * if you use a msvc compiled python version (1.5.2)
#   1. you have to insert a __GNUC__ section in its config.h
#   2. you have to generate an import library for its dll
#      - create a def-file for python??.dll
#      - create an import library using
#             dlltool --dllname python15.dll --def python15.def \
#                       --output-lib libpython15.a
#
#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
#
# * We put export_symbols in a def-file, and don't use
#   --export-all-symbols because it doesn't worked reliable in some
#   tested configurations. And because other windows compilers also
#   need their symbols specified this no serious problem.
#
# tested configurations:
#
# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
#   (after patching python's config.h and for C++ some other include files)
#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
#   (ld doesn't support -shared, so we use dllwrap)
# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
#   - its dllwrap doesn't work, there is a bug in binutils 2.10.90
#     see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
#   - using gcc -mdll instead dllwrap doesn't work without -static because
#     it tries to link against dlls instead their import libraries. (If
#     it finds the dll first.)
#     By specifying -static we force ld to link against the import libraries,
#     this is windows standard and there are normally not the necessary symbols
#     in the dlls.
#   *** only the version of June 2000 shows these problems
# * cygwin gcc 3.2/ld 2.13.90 works
#   (ld supports -shared)
# * mingw gcc 3.2/ld 2.13 works
#   (ld supports -shared)
# * llvm-mingw with Clang 11 works
#   (lld supports -shared)

import os
import sys
import copy
from subprocess import Popen, PIPE, check_output
import re

import distutils.version
from distutils.unixccompiler import UnixCCompiler
from distutils.file_util import write_file
from distutils.errors import (DistutilsExecError, CCompilerError,
        CompileError, UnknownFileError)
from distutils.version import LooseVersion
from distutils.spawn import find_executable

def get_msvcr():
    """Include the appropriate MSVC runtime library if Python was built
    with MSVC 7.0 or later.
    """
    msc_pos = sys.version.find('MSC v.')
    if msc_pos != -1:
        msc_ver = sys.version[msc_pos+6:msc_pos+10]
        if msc_ver == '1300':
            # MSVC 7.0
            return ['msvcr70']
        elif msc_ver == '1310':
            # MSVC 7.1
            return ['msvcr71']
        elif msc_ver == '1400':
            # VS2005 / MSVC 8.0
            return ['msvcr80']
        elif msc_ver == '1500':
            # VS2008 / MSVC 9.0
            return ['msvcr90']
        elif msc_ver == '1600':
            # VS2010 / MSVC 10.0
            return ['msvcr100']
        elif msc_ver == '1700':
            # VS2012 / MSVC 11.0
            return ['msvcr110']
        elif msc_ver == '1800':
            # VS2013 / MSVC 12.0
            return ['msvcr120']
        elif 1900 <= int(msc_ver) < 2000:
            # VS2015 / MSVC 14.0
           return ['ucrt', 'vcruntime140'] 
        else:
            raise ValueError("Unknown MS Compiler version %s " % msc_ver)


class CygwinCCompiler(UnixCCompiler):
    """ Handles the Cygwin port of the GNU C compiler to Windows.
    """
    compiler_type = 'cygwin'
    obj_extension = ".o"
    static_lib_extension = ".a"
    shared_lib_extension = ".dll"
    static_lib_format = "lib%s%s"
    shared_lib_format = "%s%s"
    exe_extension = ".exe"

    def __init__(self, verbose=0, dry_run=0, force=0):

        UnixCCompiler.__init__(self, verbose, dry_run, force)

        status, details = check_config_h()
        self.debug_print("Python's GCC status: %s (details: %s)" %
                         (status, details))
        if status is not CONFIG_H_OK:
            self.warn(
                "Python's pyconfig.h doesn't seem to support your compiler. "
                "Reason: %s. "
                "Compiling may fail because of undefined preprocessor macros."
                % details)

        self.cc = os.environ.get('CC', 'gcc')
        self.cxx = os.environ.get('CXX', 'g++')

        if ('gcc' in self.cc): # Start gcc workaround
            self.gcc_version, self.ld_version, self.dllwrap_version = \
                get_versions()
            self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
                             (self.gcc_version,
                              self.ld_version,
                              self.dllwrap_version) )

            # ld_version >= "2.10.90" and < "2.13" should also be able to use
            # gcc -mdll instead of dllwrap
            # Older dllwraps had own version numbers, newer ones use the
            # same as the rest of binutils ( also ld )
            # dllwrap 2.10.90 is buggy
            if self.ld_version >= "2.10.90":
                self.linker_dll = self.cc
            else:
                self.linker_dll = "dllwrap"

            # ld_version >= "2.13" support -shared so use it instead of
            # -mdll -static
            if self.ld_version >= "2.13":
                shared_option = "-shared"
            else:
                shared_option = "-mdll -static"
        else: # Assume linker is up to date
            self.linker_dll = self.cc
            shared_option = "-shared"

        self.set_executables(compiler='%s -mcygwin -O -Wall' % self.cc,
                             compiler_so='%s -mcygwin -mdll -O -Wall' % self.cc,
                             compiler_cxx='%s -mcygwin -O -Wall' % self.cxx,
                             linker_exe='%s -mcygwin' % self.cc,
                             linker_so=('%s -mcygwin %s' %
                                        (self.linker_dll, shared_option)))

        # cygwin and mingw32 need different sets of libraries
        if ('gcc' in self.cc and self.gcc_version == "2.91.57"):
            # cygwin shouldn't need msvcrt, but without the dlls will crash
            # (gcc version 2.91.57) -- perhaps something about initialization
            self.dll_libraries=["msvcrt"]
            self.warn(
                "Consider upgrading to a newer version of gcc")
        else:
            # Include the appropriate MSVC runtime library if Python was built
            # with MSVC 7.0 or later.
            self.dll_libraries = get_msvcr()

    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        """Compiles the source by spawning GCC and windres if needed."""
        if ext == '.rc' or ext == '.res':
            # gcc needs '.res' and '.rc' compiled to object files !!!
            try:
                self.spawn(["windres", "-i", src, "-o", obj])
            except DistutilsExecError as msg:
                raise CompileError(msg)
        else: # for other files use the C-compiler
            try:
                self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
                           extra_postargs)
            except DistutilsExecError as msg:
                raise CompileError(msg)

    def link(self, target_desc, objects, output_filename, output_dir=None,
             libraries=None, library_dirs=None, runtime_library_dirs=None,
             export_symbols=None, debug=0, extra_preargs=None,
             extra_postargs=None, build_temp=None, target_lang=None):
        """Link the objects."""
        # use separate copies, so we can modify the lists
        extra_preargs = copy.copy(extra_preargs or [])
        libraries = copy.copy(libraries or [])
        objects = copy.copy(objects or [])

        # Additional libraries
        libraries.extend(self.dll_libraries)

        # handle export symbols by creating a def-file
        # with executables this only works with gcc/ld as linker
        if ((export_symbols is not None) and
            (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
            # (The linker doesn't do anything if output is up-to-date.
            # So it would probably better to check if we really need this,
            # but for this we had to insert some unchanged parts of
            # UnixCCompiler, and this is not what we want.)

            # we want to put some files in the same directory as the
            # object files are, build_temp doesn't help much
            # where are the object files
            temp_dir = os.path.dirname(objects[0])
            # name of dll to give the helper files the same base name
            (dll_name, dll_extension) = os.path.splitext(
                os.path.basename(output_filename))

            # generate the filenames for these files
            def_file = os.path.join(temp_dir, dll_name + ".def")
            lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")

            # Generate .def file
            contents = [
                "LIBRARY %s" % os.path.basename(output_filename),
                "EXPORTS"]
            for sym in export_symbols:
                contents.append(sym)
            self.execute(write_file, (def_file, contents),
                         "writing %s" % def_file)

            # next add options for def-file and to creating import libraries

            # dllwrap uses different options than gcc/ld
            if self.linker_dll == "dllwrap":
                extra_preargs.extend(["--output-lib", lib_file])
                # for dllwrap we have to use a special option
                extra_preargs.extend(["--def", def_file])
            # we use gcc/ld here and can be sure ld is >= 2.9.10
            else:
                # doesn't work: bfd_close build\...\libfoo.a: Invalid operation
                #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
                # for gcc/ld the def-file is specified as any object files
                objects.append(def_file)

        #end: if ((export_symbols is not None) and
        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):

        # who wants symbols and a many times larger output file
        # should explicitly switch the debug mode on
        # otherwise we let dllwrap/ld strip the output file
        # (On my machine: 10KiB < stripped_file < ??100KiB
        #   unstripped_file = stripped_file + XXX KiB
        #  ( XXX=254 for a typical python extension))
        if not debug:
            extra_preargs.append("-s")

        UnixCCompiler.link(self, target_desc, objects, output_filename,
                           output_dir, libraries, library_dirs,
                           runtime_library_dirs,
                           None, # export_symbols, we do this in our def-file
                           debug, extra_preargs, extra_postargs, build_temp,
                           target_lang)

    # -- Miscellaneous methods -----------------------------------------

    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
        """Adds supports for rc and res files."""
        if output_dir is None:
            output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
            base, ext = os.path.splitext(os.path.normcase(src_name))
            if ext not in (self.src_extensions + ['.rc','.res']):
                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
                      (ext, src_name))
            if strip_dir:
                base = os.path.basename (base)
            if ext in ('.res', '.rc'):
                # these need to be compiled to object files
                obj_names.append (os.path.join(output_dir,
                                              base + ext + self.obj_extension))
            else:
                obj_names.append (os.path.join(output_dir,
                                               base + self.obj_extension))
        return obj_names

# the same as cygwin plus some additional parameters
class Mingw32CCompiler(CygwinCCompiler):
    """ Handles the Mingw32 port of the GNU C compiler to Windows.
    """
    compiler_type = 'mingw32'

    def __init__(self, verbose=0, dry_run=0, force=0):

        CygwinCCompiler.__init__ (self, verbose, dry_run, force)

        # ld_version >= "2.13" support -shared so use it instead of
        # -mdll -static
        if ('gcc' in self.cc and self.ld_version < "2.13"):
            shared_option = "-mdll -static"
        else:
            shared_option = "-shared"

        # A real mingw32 doesn't need to specify a different entry point,
        # but cygwin 2.91.57 in no-cygwin-mode needs it.
        if ('gcc' in self.cc and self.gcc_version <= "2.91.57"):
            entry_point = '--entry _DllMain@12'
        else:
            entry_point = ''

        if is_cygwincc(self.cc):
            raise CCompilerError(
                'Cygwin gcc cannot be used with --compiler=mingw32')

        self.set_executables(compiler='%s -O -Wall' % self.cc,
                             compiler_so='%s -mdll -O -Wall' % self.cc,
                             compiler_cxx='%s -O -Wall' % self.cxx,
                             linker_exe='%s' % self.cc,
                             linker_so='%s %s %s'
                                        % (self.linker_dll, shared_option,
                                           entry_point))
        # Maybe we should also append -mthreads, but then the finished
        # dlls need another dll (mingwm10.dll see Mingw32 docs)
        # (-mthreads: Support thread-safe exception handling on `Mingw32')

        # no additional libraries needed
        self.dll_libraries=[]

        # Include the appropriate MSVC runtime library if Python was built
        # with MSVC 7.0 or later.
        self.dll_libraries = get_msvcr()

# Because these compilers aren't configured in Python's pyconfig.h file by
# default, we should at least warn the user if he is using an unmodified
# version.

CONFIG_H_OK = "ok"
CONFIG_H_NOTOK = "not ok"
CONFIG_H_UNCERTAIN = "uncertain"

def check_config_h():
    """Check if the current Python installation appears amenable to building
    extensions with GCC.

    Returns a tuple (status, details), where 'status' is one of the following
    constants:

    - CONFIG_H_OK: all is well, go ahead and compile
    - CONFIG_H_NOTOK: doesn't look good
    - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h

    'details' is a human-readable string explaining the situation.

    Note there are two ways to conclude "OK": either 'sys.version' contains
    the string "GCC" (implying that this Python was built with GCC), or the
    installed "pyconfig.h" contains the string "__GNUC__".
    """

    # XXX since this function also checks sys.version, it's not strictly a
    # "pyconfig.h" check -- should probably be renamed...

    from distutils import sysconfig

    # if sys.version contains GCC then python was compiled with GCC, and the
    # pyconfig.h file should be OK
    if "GCC" in sys.version:
        return CONFIG_H_OK, "sys.version mentions 'GCC'"

    # Clang would also work
    if "Clang" in sys.version:
        return CONFIG_H_OK, "sys.version mentions 'Clang'"

    # let's see if __GNUC__ is mentioned in python.h
    fn = sysconfig.get_config_h_filename()
    try:
        config_h = open(fn)
        try:
            if "__GNUC__" in config_h.read():
                return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
            else:
                return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
        finally:
            config_h.close()
    except OSError as exc:
        return (CONFIG_H_UNCERTAIN,
                "couldn't read '%s': %s" % (fn, exc.strerror))

RE_VERSION = re.compile(br'(\d+\.\d+(\.\d+)*)')

def _find_exe_version(cmd):
    """Find the version of an executable by running `cmd` in the shell.

    If the command is not found, or the output does not match
    `RE_VERSION`, returns None.
    """
    executable = cmd.split()[0]
    if find_executable(executable) is None:
        return None
    out = Popen(cmd, shell=True, stdout=PIPE).stdout
    try:
        out_string = out.read()
    finally:
        out.close()
    result = RE_VERSION.search(out_string)
    if result is None:
        return None
    # LooseVersion works with strings; decode
    ver_str = result.group(1).decode()
    with distutils.version.suppress_known_deprecation():
        return LooseVersion(ver_str)

def get_versions():
    """ Try to find out the versions of gcc, ld and dllwrap.

    If not possible it returns None for it.
    """
    commands = ['gcc -dumpversion', 'ld -v', 'dllwrap --version']
    return tuple([_find_exe_version(cmd) for cmd in commands])

def is_cygwincc(cc):
    '''Try to determine if the compiler that would be used is from cygwin.'''
    out_string = check_output([cc, '-dumpmachine'])
    return out_string.strip().endswith(b'cygwin')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/debug.py0000644000175100001710000000021300000000000021434 0ustar00runnerdockerimport os

# If DISTUTILS_DEBUG is anything other than the empty string, we run in
# debug mode.
DEBUG = os.environ.get('DISTUTILS_DEBUG')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/dep_util.py0000644000175100001710000000664300000000000022170 0ustar00runnerdocker"""distutils.dep_util

Utility functions for simple, timestamp-based dependency of files
and groups of files; also, function based entirely on such
timestamp dependency analysis."""

import os
from distutils.errors import DistutilsFileError


def newer (source, target):
    """Return true if 'source' exists and is more recently modified than
    'target', or if 'source' exists and 'target' doesn't.  Return false if
    both exist and 'target' is the same age or younger than 'source'.
    Raise DistutilsFileError if 'source' does not exist.
    """
    if not os.path.exists(source):
        raise DistutilsFileError("file '%s' does not exist" %
                                 os.path.abspath(source))
    if not os.path.exists(target):
        return 1

    from stat import ST_MTIME
    mtime1 = os.stat(source)[ST_MTIME]
    mtime2 = os.stat(target)[ST_MTIME]

    return mtime1 > mtime2

# newer ()


def newer_pairwise (sources, targets):
    """Walk two filename lists in parallel, testing if each source is newer
    than its corresponding target.  Return a pair of lists (sources,
    targets) where source is newer than target, according to the semantics
    of 'newer()'.
    """
    if len(sources) != len(targets):
        raise ValueError("'sources' and 'targets' must be same length")

    # build a pair of lists (sources, targets) where  source is newer
    n_sources = []
    n_targets = []
    for i in range(len(sources)):
        if newer(sources[i], targets[i]):
            n_sources.append(sources[i])
            n_targets.append(targets[i])

    return (n_sources, n_targets)

# newer_pairwise ()


def newer_group (sources, target, missing='error'):
    """Return true if 'target' is out-of-date with respect to any file
    listed in 'sources'.  In other words, if 'target' exists and is newer
    than every file in 'sources', return false; otherwise return true.
    'missing' controls what we do when a source file is missing; the
    default ("error") is to blow up with an OSError from inside 'stat()';
    if it is "ignore", we silently drop any missing source files; if it is
    "newer", any missing source files make us assume that 'target' is
    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
    carry out commands that wouldn't work because inputs are missing, but
    that doesn't matter because you're not actually going to run the
    commands).
    """
    # If the target doesn't even exist, then it's definitely out-of-date.
    if not os.path.exists(target):
        return 1

    # Otherwise we have to find out the hard way: if *any* source file
    # is more recent than 'target', then 'target' is out-of-date and
    # we can immediately return true.  If we fall through to the end
    # of the loop, then 'target' is up-to-date and we return false.
    from stat import ST_MTIME
    target_mtime = os.stat(target)[ST_MTIME]
    for source in sources:
        if not os.path.exists(source):
            if missing == 'error':      # blow up when we stat() the file
                pass
            elif missing == 'ignore':   # missing source dropped from
                continue                #  target's dependency list
            elif missing == 'newer':    # missing source means target is
                return 1                #  out-of-date

        source_mtime = os.stat(source)[ST_MTIME]
        if source_mtime > target_mtime:
            return 1
    else:
        return 0

# newer_group ()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/dir_util.py0000644000175100001710000001714200000000000022172 0ustar00runnerdocker"""distutils.dir_util

Utility functions for manipulating directories and directory trees."""

import os
import errno
from distutils.errors import DistutilsFileError, DistutilsInternalError
from distutils import log

# cache for by mkpath() -- in addition to cheapening redundant calls,
# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode
_path_created = {}

# I don't use os.makedirs because a) it's new to Python 1.5.2, and
# b) it blows up if the directory already exists (I want to silently
# succeed in that case).
def mkpath(name, mode=0o777, verbose=1, dry_run=0):
    """Create a directory and any missing ancestor directories.

    If the directory already exists (or if 'name' is the empty string, which
    means the current directory, which of course exists), then do nothing.
    Raise DistutilsFileError if unable to create some directory along the way
    (eg. some sub-path exists, but is a file rather than a directory).
    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
    Return the list of directories actually created.
    """

    global _path_created

    # Detect a common bug -- name is None
    if not isinstance(name, str):
        raise DistutilsInternalError(
              "mkpath: 'name' must be a string (got %r)" % (name,))

    # XXX what's the better way to handle verbosity? print as we create
    # each directory in the path (the current behaviour), or only announce
    # the creation of the whole path? (quite easy to do the latter since
    # we're not using a recursive algorithm)

    name = os.path.normpath(name)
    created_dirs = []
    if os.path.isdir(name) or name == '':
        return created_dirs
    if _path_created.get(os.path.abspath(name)):
        return created_dirs

    (head, tail) = os.path.split(name)
    tails = [tail]                      # stack of lone dirs to create

    while head and tail and not os.path.isdir(head):
        (head, tail) = os.path.split(head)
        tails.insert(0, tail)          # push next higher dir onto stack

    # now 'head' contains the deepest directory that already exists
    # (that is, the child of 'head' in 'name' is the highest directory
    # that does *not* exist)
    for d in tails:
        #print "head = %s, d = %s: " % (head, d),
        head = os.path.join(head, d)
        abs_head = os.path.abspath(head)

        if _path_created.get(abs_head):
            continue

        if verbose >= 1:
            log.info("creating %s", head)

        if not dry_run:
            try:
                os.mkdir(head, mode)
            except OSError as exc:
                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
                    raise DistutilsFileError(
                          "could not create '%s': %s" % (head, exc.args[-1]))
            created_dirs.append(head)

        _path_created[abs_head] = 1
    return created_dirs

def create_tree(base_dir, files, mode=0o777, verbose=1, dry_run=0):
    """Create all the empty directories under 'base_dir' needed to put 'files'
    there.

    'base_dir' is just the name of a directory which doesn't necessarily
    exist yet; 'files' is a list of filenames to be interpreted relative to
    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
    will be created if it doesn't already exist.  'mode', 'verbose' and
    'dry_run' flags are as for 'mkpath()'.
    """
    # First get the list of directories to create
    need_dir = set()
    for file in files:
        need_dir.add(os.path.join(base_dir, os.path.dirname(file)))

    # Now create them
    for dir in sorted(need_dir):
        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)

def copy_tree(src, dst, preserve_mode=1, preserve_times=1,
              preserve_symlinks=0, update=0, verbose=1, dry_run=0):
    """Copy an entire directory tree 'src' to a new location 'dst'.

    Both 'src' and 'dst' must be directory names.  If 'src' is not a
    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
    created with 'mkpath()'.  The end result of the copy is that every
    file in 'src' is copied to 'dst', and directories under 'src' are
    recursively copied to 'dst'.  Return the list of files that were
    copied or might have been copied, using their output name.  The
    return value is unaffected by 'update' or 'dry_run': it is simply
    the list of all files under 'src', with the names changed to be
    under 'dst'.

    'preserve_mode' and 'preserve_times' are the same as for
    'copy_file'; note that they only apply to regular files, not to
    directories.  If 'preserve_symlinks' is true, symlinks will be
    copied as symlinks (on platforms that support them!); otherwise
    (the default), the destination of the symlink will be copied.
    'update' and 'verbose' are the same as for 'copy_file'.
    """
    from distutils.file_util import copy_file

    if not dry_run and not os.path.isdir(src):
        raise DistutilsFileError(
              "cannot copy tree '%s': not a directory" % src)
    try:
        names = os.listdir(src)
    except OSError as e:
        if dry_run:
            names = []
        else:
            raise DistutilsFileError(
                  "error listing files in '%s': %s" % (src, e.strerror))

    if not dry_run:
        mkpath(dst, verbose=verbose)

    outputs = []

    for n in names:
        src_name = os.path.join(src, n)
        dst_name = os.path.join(dst, n)

        if n.startswith('.nfs'):
            # skip NFS rename files
            continue

        if preserve_symlinks and os.path.islink(src_name):
            link_dest = os.readlink(src_name)
            if verbose >= 1:
                log.info("linking %s -> %s", dst_name, link_dest)
            if not dry_run:
                os.symlink(link_dest, dst_name)
            outputs.append(dst_name)

        elif os.path.isdir(src_name):
            outputs.extend(
                copy_tree(src_name, dst_name, preserve_mode,
                          preserve_times, preserve_symlinks, update,
                          verbose=verbose, dry_run=dry_run))
        else:
            copy_file(src_name, dst_name, preserve_mode,
                      preserve_times, update, verbose=verbose,
                      dry_run=dry_run)
            outputs.append(dst_name)

    return outputs

def _build_cmdtuple(path, cmdtuples):
    """Helper for remove_tree()."""
    for f in os.listdir(path):
        real_f = os.path.join(path,f)
        if os.path.isdir(real_f) and not os.path.islink(real_f):
            _build_cmdtuple(real_f, cmdtuples)
        else:
            cmdtuples.append((os.remove, real_f))
    cmdtuples.append((os.rmdir, path))

def remove_tree(directory, verbose=1, dry_run=0):
    """Recursively remove an entire directory tree.

    Any errors are ignored (apart from being reported to stdout if 'verbose'
    is true).
    """
    global _path_created

    if verbose >= 1:
        log.info("removing '%s' (and everything under it)", directory)
    if dry_run:
        return
    cmdtuples = []
    _build_cmdtuple(directory, cmdtuples)
    for cmd in cmdtuples:
        try:
            cmd[0](cmd[1])
            # remove dir from cache if it's already there
            abspath = os.path.abspath(cmd[1])
            if abspath in _path_created:
                del _path_created[abspath]
        except OSError as exc:
            log.warn("error removing %s: %s", directory, exc)

def ensure_relative(path):
    """Take the full path 'path', and make it a relative path.

    This is useful to make 'path' the second argument to os.path.join().
    """
    drive, path = os.path.splitdrive(path)
    if path[0:1] == os.sep:
        path = drive + path[1:]
    return path
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/dist.py0000644000175100001710000014236500000000000021330 0ustar00runnerdocker"""distutils.dist

Provides the Distribution class, which represents the module distribution
being built/installed/distributed.
"""

import sys
import os
import re
from email import message_from_file

try:
    import warnings
except ImportError:
    warnings = None

from distutils.errors import *
from distutils.fancy_getopt import FancyGetopt, translate_longopt
from distutils.util import check_environ, strtobool, rfc822_escape
from distutils import log
from distutils.debug import DEBUG

# Regex to define acceptable Distutils command names.  This is not *quite*
# the same as a Python NAME -- I don't allow leading underscores.  The fact
# that they're very similar is no coincidence; the default naming scheme is
# to look for a Python module named after the command.
command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$')


def _ensure_list(value, fieldname):
    if isinstance(value, str):
        # a string containing comma separated values is okay.  It will
        # be converted to a list by Distribution.finalize_options().
        pass
    elif not isinstance(value, list):
        # passing a tuple or an iterator perhaps, warn and convert
        typename = type(value).__name__
        msg = "Warning: '{fieldname}' should be a list, got type '{typename}'"
        msg = msg.format(**locals())
        log.log(log.WARN, msg)
        value = list(value)
    return value


class Distribution:
    """The core of the Distutils.  Most of the work hiding behind 'setup'
    is really done within a Distribution instance, which farms the work out
    to the Distutils commands specified on the command line.

    Setup scripts will almost never instantiate Distribution directly,
    unless the 'setup()' function is totally inadequate to their needs.
    However, it is conceivable that a setup script might wish to subclass
    Distribution for some specialized purpose, and then pass the subclass
    to 'setup()' as the 'distclass' keyword argument.  If so, it is
    necessary to respect the expectations that 'setup' has of Distribution.
    See the code for 'setup()', in core.py, for details.
    """

    # 'global_options' describes the command-line options that may be
    # supplied to the setup script prior to any actual commands.
    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
    # these global options.  This list should be kept to a bare minimum,
    # since every global option is also valid as a command option -- and we
    # don't want to pollute the commands with too many options that they
    # have minimal control over.
    # The fourth entry for verbose means that it can be repeated.
    global_options = [
        ('verbose', 'v', "run verbosely (default)", 1),
        ('quiet', 'q', "run quietly (turns verbosity off)"),
        ('dry-run', 'n', "don't actually do anything"),
        ('help', 'h', "show detailed help message"),
        ('no-user-cfg', None,
            'ignore pydistutils.cfg in your home directory'),
    ]

    # 'common_usage' is a short (2-3 line) string describing the common
    # usage of the setup script.
    common_usage = """\
Common commands: (see '--help-commands' for more)

  setup.py build      will build the package underneath 'build/'
  setup.py install    will install the package
"""

    # options that are not propagated to the commands
    display_options = [
        ('help-commands', None,
         "list all available commands"),
        ('name', None,
         "print package name"),
        ('version', 'V',
         "print package version"),
        ('fullname', None,
         "print -"),
        ('author', None,
         "print the author's name"),
        ('author-email', None,
         "print the author's email address"),
        ('maintainer', None,
         "print the maintainer's name"),
        ('maintainer-email', None,
         "print the maintainer's email address"),
        ('contact', None,
         "print the maintainer's name if known, else the author's"),
        ('contact-email', None,
         "print the maintainer's email address if known, else the author's"),
        ('url', None,
         "print the URL for this package"),
        ('license', None,
         "print the license of the package"),
        ('licence', None,
         "alias for --license"),
        ('description', None,
         "print the package description"),
        ('long-description', None,
         "print the long package description"),
        ('platforms', None,
         "print the list of platforms"),
        ('classifiers', None,
         "print the list of classifiers"),
        ('keywords', None,
         "print the list of keywords"),
        ('provides', None,
         "print the list of packages/modules provided"),
        ('requires', None,
         "print the list of packages/modules required"),
        ('obsoletes', None,
         "print the list of packages/modules made obsolete")
        ]
    display_option_names = [translate_longopt(x[0]) for x in display_options]

    # negative options are options that exclude other options
    negative_opt = {'quiet': 'verbose'}

    # -- Creation/initialization methods -------------------------------

    def __init__(self, attrs=None):
        """Construct a new Distribution instance: initialize all the
        attributes of a Distribution, and then use 'attrs' (a dictionary
        mapping attribute names to values) to assign some of those
        attributes their "real" values.  (Any attributes not mentioned in
        'attrs' will be assigned to some null value: 0, None, an empty list
        or dictionary, etc.)  Most importantly, initialize the
        'command_obj' attribute to the empty dictionary; this will be
        filled in with real command objects by 'parse_command_line()'.
        """

        # Default values for our command-line options
        self.verbose = 1
        self.dry_run = 0
        self.help = 0
        for attr in self.display_option_names:
            setattr(self, attr, 0)

        # Store the distribution meta-data (name, version, author, and so
        # forth) in a separate object -- we're getting to have enough
        # information here (and enough command-line options) that it's
        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
        # object in a sneaky and underhanded (but efficient!) way.
        self.metadata = DistributionMetadata()
        for basename in self.metadata._METHOD_BASENAMES:
            method_name = "get_" + basename
            setattr(self, method_name, getattr(self.metadata, method_name))

        # 'cmdclass' maps command names to class objects, so we
        # can 1) quickly figure out which class to instantiate when
        # we need to create a new command object, and 2) have a way
        # for the setup script to override command classes
        self.cmdclass = {}

        # 'command_packages' is a list of packages in which commands
        # are searched for.  The factory for command 'foo' is expected
        # to be named 'foo' in the module 'foo' in one of the packages
        # named here.  This list is searched from the left; an error
        # is raised if no named package provides the command being
        # searched for.  (Always access using get_command_packages().)
        self.command_packages = None

        # 'script_name' and 'script_args' are usually set to sys.argv[0]
        # and sys.argv[1:], but they can be overridden when the caller is
        # not necessarily a setup script run from the command-line.
        self.script_name = None
        self.script_args = None

        # 'command_options' is where we store command options between
        # parsing them (from config files, the command-line, etc.) and when
        # they are actually needed -- ie. when the command in question is
        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
        #   command_options = { command_name : { option : (source, value) } }
        self.command_options = {}

        # 'dist_files' is the list of (command, pyversion, file) that
        # have been created by any dist commands run so far. This is
        # filled regardless of whether the run is dry or not. pyversion
        # gives sysconfig.get_python_version() if the dist file is
        # specific to a Python version, 'any' if it is good for all
        # Python versions on the target platform, and '' for a source
        # file. pyversion should not be used to specify minimum or
        # maximum required Python versions; use the metainfo for that
        # instead.
        self.dist_files = []

        # These options are really the business of various commands, rather
        # than of the Distribution itself.  We provide aliases for them in
        # Distribution as a convenience to the developer.
        self.packages = None
        self.package_data = {}
        self.package_dir = None
        self.py_modules = None
        self.libraries = None
        self.headers = None
        self.ext_modules = None
        self.ext_package = None
        self.include_dirs = None
        self.extra_path = None
        self.scripts = None
        self.data_files = None
        self.password = ''

        # And now initialize bookkeeping stuff that can't be supplied by
        # the caller at all.  'command_obj' maps command names to
        # Command instances -- that's how we enforce that every command
        # class is a singleton.
        self.command_obj = {}

        # 'have_run' maps command names to boolean values; it keeps track
        # of whether we have actually run a particular command, to make it
        # cheap to "run" a command whenever we think we might need to -- if
        # it's already been done, no need for expensive filesystem
        # operations, we just check the 'have_run' dictionary and carry on.
        # It's only safe to query 'have_run' for a command class that has
        # been instantiated -- a false value will be inserted when the
        # command object is created, and replaced with a true value when
        # the command is successfully run.  Thus it's probably best to use
        # '.get()' rather than a straight lookup.
        self.have_run = {}

        # Now we'll use the attrs dictionary (ultimately, keyword args from
        # the setup script) to possibly override any or all of these
        # distribution options.

        if attrs:
            # Pull out the set of command options and work on them
            # specifically.  Note that this order guarantees that aliased
            # command options will override any supplied redundantly
            # through the general options dictionary.
            options = attrs.get('options')
            if options is not None:
                del attrs['options']
                for (command, cmd_options) in options.items():
                    opt_dict = self.get_option_dict(command)
                    for (opt, val) in cmd_options.items():
                        opt_dict[opt] = ("setup script", val)

            if 'licence' in attrs:
                attrs['license'] = attrs['licence']
                del attrs['licence']
                msg = "'licence' distribution option is deprecated; use 'license'"
                if warnings is not None:
                    warnings.warn(msg)
                else:
                    sys.stderr.write(msg + "\n")

            # Now work on the rest of the attributes.  Any attribute that's
            # not already defined is invalid!
            for (key, val) in attrs.items():
                if hasattr(self.metadata, "set_" + key):
                    getattr(self.metadata, "set_" + key)(val)
                elif hasattr(self.metadata, key):
                    setattr(self.metadata, key, val)
                elif hasattr(self, key):
                    setattr(self, key, val)
                else:
                    msg = "Unknown distribution option: %s" % repr(key)
                    warnings.warn(msg)

        # no-user-cfg is handled before other command line args
        # because other args override the config files, and this
        # one is needed before we can load the config files.
        # If attrs['script_args'] wasn't passed, assume false.
        #
        # This also make sure we just look at the global options
        self.want_user_cfg = True

        if self.script_args is not None:
            for arg in self.script_args:
                if not arg.startswith('-'):
                    break
                if arg == '--no-user-cfg':
                    self.want_user_cfg = False
                    break

        self.finalize_options()

    def get_option_dict(self, command):
        """Get the option dictionary for a given command.  If that
        command's option dictionary hasn't been created yet, then create it
        and return the new dictionary; otherwise, return the existing
        option dictionary.
        """
        dict = self.command_options.get(command)
        if dict is None:
            dict = self.command_options[command] = {}
        return dict

    def dump_option_dicts(self, header=None, commands=None, indent=""):
        from pprint import pformat

        if commands is None:             # dump all command option dicts
            commands = sorted(self.command_options.keys())

        if header is not None:
            self.announce(indent + header)
            indent = indent + "  "

        if not commands:
            self.announce(indent + "no commands known yet")
            return

        for cmd_name in commands:
            opt_dict = self.command_options.get(cmd_name)
            if opt_dict is None:
                self.announce(indent +
                              "no option dict for '%s' command" % cmd_name)
            else:
                self.announce(indent +
                              "option dict for '%s' command:" % cmd_name)
                out = pformat(opt_dict)
                for line in out.split('\n'):
                    self.announce(indent + "  " + line)

    # -- Config file finding/parsing methods ---------------------------

    def find_config_files(self):
        """Find as many configuration files as should be processed for this
        platform, and return a list of filenames in the order in which they
        should be parsed.  The filenames returned are guaranteed to exist
        (modulo nasty race conditions).

        There are three possible config files: distutils.cfg in the
        Distutils installation directory (ie. where the top-level
        Distutils __inst__.py file lives), a file in the user's home
        directory named .pydistutils.cfg on Unix and pydistutils.cfg
        on Windows/Mac; and setup.cfg in the current directory.

        The file in the user's home directory can be disabled with the
        --no-user-cfg option.
        """
        files = []
        check_environ()

        # Where to look for the system-wide Distutils config file
        sys_dir = os.path.dirname(sys.modules['distutils'].__file__)

        # Look for the system config file
        sys_file = os.path.join(sys_dir, "distutils.cfg")
        if os.path.isfile(sys_file):
            files.append(sys_file)

        # What to call the per-user config file
        if os.name == 'posix':
            user_filename = ".pydistutils.cfg"
        else:
            user_filename = "pydistutils.cfg"

        # And look for the user config file
        if self.want_user_cfg:
            user_file = os.path.join(os.path.expanduser('~'), user_filename)
            if os.path.isfile(user_file):
                files.append(user_file)

        # All platforms support local setup.cfg
        local_file = "setup.cfg"
        if os.path.isfile(local_file):
            files.append(local_file)

        if DEBUG:
            self.announce("using config files: %s" % ', '.join(files))

        return files

    def parse_config_files(self, filenames=None):
        from configparser import ConfigParser

        # Ignore install directory options if we have a venv
        if sys.prefix != sys.base_prefix:
            ignore_options = [
                'install-base', 'install-platbase', 'install-lib',
                'install-platlib', 'install-purelib', 'install-headers',
                'install-scripts', 'install-data', 'prefix', 'exec-prefix',
                'home', 'user', 'root']
        else:
            ignore_options = []

        ignore_options = frozenset(ignore_options)

        if filenames is None:
            filenames = self.find_config_files()

        if DEBUG:
            self.announce("Distribution.parse_config_files():")

        parser = ConfigParser()
        for filename in filenames:
            if DEBUG:
                self.announce("  reading %s" % filename)
            parser.read(filename)
            for section in parser.sections():
                options = parser.options(section)
                opt_dict = self.get_option_dict(section)

                for opt in options:
                    if opt != '__name__' and opt not in ignore_options:
                        val = parser.get(section,opt)
                        opt = opt.replace('-', '_')
                        opt_dict[opt] = (filename, val)

            # Make the ConfigParser forget everything (so we retain
            # the original filenames that options come from)
            parser.__init__()

        # If there was a "global" section in the config file, use it
        # to set Distribution options.

        if 'global' in self.command_options:
            for (opt, (src, val)) in self.command_options['global'].items():
                alias = self.negative_opt.get(opt)
                try:
                    if alias:
                        setattr(self, alias, not strtobool(val))
                    elif opt in ('verbose', 'dry_run'): # ugh!
                        setattr(self, opt, strtobool(val))
                    else:
                        setattr(self, opt, val)
                except ValueError as msg:
                    raise DistutilsOptionError(msg)

    # -- Command-line parsing methods ----------------------------------

    def parse_command_line(self):
        """Parse the setup script's command line, taken from the
        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
        -- see 'setup()' in core.py).  This list is first processed for
        "global options" -- options that set attributes of the Distribution
        instance.  Then, it is alternately scanned for Distutils commands
        and options for that command.  Each new command terminates the
        options for the previous command.  The allowed options for a
        command are determined by the 'user_options' attribute of the
        command class -- thus, we have to be able to load command classes
        in order to parse the command line.  Any error in that 'options'
        attribute raises DistutilsGetoptError; any error on the
        command-line raises DistutilsArgError.  If no Distutils commands
        were found on the command line, raises DistutilsArgError.  Return
        true if command-line was successfully parsed and we should carry
        on with executing commands; false if no errors but we shouldn't
        execute commands (currently, this only happens if user asks for
        help).
        """
        #
        # We now have enough information to show the Macintosh dialog
        # that allows the user to interactively specify the "command line".
        #
        toplevel_options = self._get_toplevel_options()

        # We have to parse the command line a bit at a time -- global
        # options, then the first command, then its options, and so on --
        # because each command will be handled by a different class, and
        # the options that are valid for a particular class aren't known
        # until we have loaded the command class, which doesn't happen
        # until we know what the command is.

        self.commands = []
        parser = FancyGetopt(toplevel_options + self.display_options)
        parser.set_negative_aliases(self.negative_opt)
        parser.set_aliases({'licence': 'license'})
        args = parser.getopt(args=self.script_args, object=self)
        option_order = parser.get_option_order()
        log.set_verbosity(self.verbose)

        # for display options we return immediately
        if self.handle_display_options(option_order):
            return
        while args:
            args = self._parse_command_opts(parser, args)
            if args is None:            # user asked for help (and got it)
                return

        # Handle the cases of --help as a "global" option, ie.
        # "setup.py --help" and "setup.py --help command ...".  For the
        # former, we show global options (--verbose, --dry-run, etc.)
        # and display-only options (--name, --version, etc.); for the
        # latter, we omit the display-only options and show help for
        # each command listed on the command line.
        if self.help:
            self._show_help(parser,
                            display_options=len(self.commands) == 0,
                            commands=self.commands)
            return

        # Oops, no commands found -- an end-user error
        if not self.commands:
            raise DistutilsArgError("no commands supplied")

        # All is well: return true
        return True

    def _get_toplevel_options(self):
        """Return the non-display options recognized at the top level.

        This includes options that are recognized *only* at the top
        level as well as options recognized for commands.
        """
        return self.global_options + [
            ("command-packages=", None,
             "list of packages that provide distutils commands"),
            ]

    def _parse_command_opts(self, parser, args):
        """Parse the command-line options for a single command.
        'parser' must be a FancyGetopt instance; 'args' must be the list
        of arguments, starting with the current command (whose options
        we are about to parse).  Returns a new version of 'args' with
        the next command at the front of the list; will be the empty
        list if there are no more commands on the command line.  Returns
        None if the user asked for help on this command.
        """
        # late import because of mutual dependence between these modules
        from distutils.cmd import Command

        # Pull the current command from the head of the command line
        command = args[0]
        if not command_re.match(command):
            raise SystemExit("invalid command name '%s'" % command)
        self.commands.append(command)

        # Dig up the command class that implements this command, so we
        # 1) know that it's a valid command, and 2) know which options
        # it takes.
        try:
            cmd_class = self.get_command_class(command)
        except DistutilsModuleError as msg:
            raise DistutilsArgError(msg)

        # Require that the command class be derived from Command -- want
        # to be sure that the basic "command" interface is implemented.
        if not issubclass(cmd_class, Command):
            raise DistutilsClassError(
                "command class %s must subclass Command" % cmd_class)

        # Also make sure that the command object provides a list of its
        # known options.
        if not (hasattr(cmd_class, 'user_options') and
                isinstance(cmd_class.user_options, list)):
            msg = ("command class %s must provide "
                "'user_options' attribute (a list of tuples)")
            raise DistutilsClassError(msg % cmd_class)

        # If the command class has a list of negative alias options,
        # merge it in with the global negative aliases.
        negative_opt = self.negative_opt
        if hasattr(cmd_class, 'negative_opt'):
            negative_opt = negative_opt.copy()
            negative_opt.update(cmd_class.negative_opt)

        # Check for help_options in command class.  They have a different
        # format (tuple of four) so we need to preprocess them here.
        if (hasattr(cmd_class, 'help_options') and
                isinstance(cmd_class.help_options, list)):
            help_options = fix_help_options(cmd_class.help_options)
        else:
            help_options = []

        # All commands support the global options too, just by adding
        # in 'global_options'.
        parser.set_option_table(self.global_options +
                                cmd_class.user_options +
                                help_options)
        parser.set_negative_aliases(negative_opt)
        (args, opts) = parser.getopt(args[1:])
        if hasattr(opts, 'help') and opts.help:
            self._show_help(parser, display_options=0, commands=[cmd_class])
            return

        if (hasattr(cmd_class, 'help_options') and
                isinstance(cmd_class.help_options, list)):
            help_option_found=0
            for (help_option, short, desc, func) in cmd_class.help_options:
                if hasattr(opts, parser.get_attr_name(help_option)):
                    help_option_found=1
                    if callable(func):
                        func()
                    else:
                        raise DistutilsClassError(
                            "invalid help function %r for help option '%s': "
                            "must be a callable object (function, etc.)"
                            % (func, help_option))

            if help_option_found:
                return

        # Put the options from the command-line into their official
        # holding pen, the 'command_options' dictionary.
        opt_dict = self.get_option_dict(command)
        for (name, value) in vars(opts).items():
            opt_dict[name] = ("command line", value)

        return args

    def finalize_options(self):
        """Set final values for all the options on the Distribution
        instance, analogous to the .finalize_options() method of Command
        objects.
        """
        for attr in ('keywords', 'platforms'):
            value = getattr(self.metadata, attr)
            if value is None:
                continue
            if isinstance(value, str):
                value = [elm.strip() for elm in value.split(',')]
                setattr(self.metadata, attr, value)

    def _show_help(self, parser, global_options=1, display_options=1,
                   commands=[]):
        """Show help for the setup script command-line in the form of
        several lists of command-line options.  'parser' should be a
        FancyGetopt instance; do not expect it to be returned in the
        same state, as its option table will be reset to make it
        generate the correct help text.

        If 'global_options' is true, lists the global options:
        --verbose, --dry-run, etc.  If 'display_options' is true, lists
        the "display-only" options: --name, --version, etc.  Finally,
        lists per-command help for every command name or command class
        in 'commands'.
        """
        # late import because of mutual dependence between these modules
        from distutils.core import gen_usage
        from distutils.cmd import Command

        if global_options:
            if display_options:
                options = self._get_toplevel_options()
            else:
                options = self.global_options
            parser.set_option_table(options)
            parser.print_help(self.common_usage + "\nGlobal options:")
            print('')

        if display_options:
            parser.set_option_table(self.display_options)
            parser.print_help(
                "Information display options (just display " +
                "information, ignore any commands)")
            print('')

        for command in self.commands:
            if isinstance(command, type) and issubclass(command, Command):
                klass = command
            else:
                klass = self.get_command_class(command)
            if (hasattr(klass, 'help_options') and
                    isinstance(klass.help_options, list)):
                parser.set_option_table(klass.user_options +
                                        fix_help_options(klass.help_options))
            else:
                parser.set_option_table(klass.user_options)
            parser.print_help("Options for '%s' command:" % klass.__name__)
            print('')

        print(gen_usage(self.script_name))

    def handle_display_options(self, option_order):
        """If there were any non-global "display-only" options
        (--help-commands or the metadata display options) on the command
        line, display the requested info and return true; else return
        false.
        """
        from distutils.core import gen_usage

        # User just wants a list of commands -- we'll print it out and stop
        # processing now (ie. if they ran "setup --help-commands foo bar",
        # we ignore "foo bar").
        if self.help_commands:
            self.print_commands()
            print('')
            print(gen_usage(self.script_name))
            return 1

        # If user supplied any of the "display metadata" options, then
        # display that metadata in the order in which the user supplied the
        # metadata options.
        any_display_options = 0
        is_display_option = {}
        for option in self.display_options:
            is_display_option[option[0]] = 1

        for (opt, val) in option_order:
            if val and is_display_option.get(opt):
                opt = translate_longopt(opt)
                value = getattr(self.metadata, "get_"+opt)()
                if opt in ['keywords', 'platforms']:
                    print(','.join(value))
                elif opt in ('classifiers', 'provides', 'requires',
                             'obsoletes'):
                    print('\n'.join(value))
                else:
                    print(value)
                any_display_options = 1

        return any_display_options

    def print_command_list(self, commands, header, max_length):
        """Print a subset of the list of all commands -- used by
        'print_commands()'.
        """
        print(header + ":")

        for cmd in commands:
            klass = self.cmdclass.get(cmd)
            if not klass:
                klass = self.get_command_class(cmd)
            try:
                description = klass.description
            except AttributeError:
                description = "(no description available)"

            print("  %-*s  %s" % (max_length, cmd, description))

    def print_commands(self):
        """Print out a help message listing all available commands with a
        description of each.  The list is divided into "standard commands"
        (listed in distutils.command.__all__) and "extra commands"
        (mentioned in self.cmdclass, but not a standard command).  The
        descriptions come from the command class attribute
        'description'.
        """
        import distutils.command
        std_commands = distutils.command.__all__
        is_std = {}
        for cmd in std_commands:
            is_std[cmd] = 1

        extra_commands = []
        for cmd in self.cmdclass.keys():
            if not is_std.get(cmd):
                extra_commands.append(cmd)

        max_length = 0
        for cmd in (std_commands + extra_commands):
            if len(cmd) > max_length:
                max_length = len(cmd)

        self.print_command_list(std_commands,
                                "Standard commands",
                                max_length)
        if extra_commands:
            print()
            self.print_command_list(extra_commands,
                                    "Extra commands",
                                    max_length)

    def get_command_list(self):
        """Get a list of (command, description) tuples.
        The list is divided into "standard commands" (listed in
        distutils.command.__all__) and "extra commands" (mentioned in
        self.cmdclass, but not a standard command).  The descriptions come
        from the command class attribute 'description'.
        """
        # Currently this is only used on Mac OS, for the Mac-only GUI
        # Distutils interface (by Jack Jansen)
        import distutils.command
        std_commands = distutils.command.__all__
        is_std = {}
        for cmd in std_commands:
            is_std[cmd] = 1

        extra_commands = []
        for cmd in self.cmdclass.keys():
            if not is_std.get(cmd):
                extra_commands.append(cmd)

        rv = []
        for cmd in (std_commands + extra_commands):
            klass = self.cmdclass.get(cmd)
            if not klass:
                klass = self.get_command_class(cmd)
            try:
                description = klass.description
            except AttributeError:
                description = "(no description available)"
            rv.append((cmd, description))
        return rv

    # -- Command class/object methods ----------------------------------

    def get_command_packages(self):
        """Return a list of packages from which commands are loaded."""
        pkgs = self.command_packages
        if not isinstance(pkgs, list):
            if pkgs is None:
                pkgs = ''
            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
            if "distutils.command" not in pkgs:
                pkgs.insert(0, "distutils.command")
            self.command_packages = pkgs
        return pkgs

    def get_command_class(self, command):
        """Return the class that implements the Distutils command named by
        'command'.  First we check the 'cmdclass' dictionary; if the
        command is mentioned there, we fetch the class object from the
        dictionary and return it.  Otherwise we load the command module
        ("distutils.command." + command) and fetch the command class from
        the module.  The loaded class is also stored in 'cmdclass'
        to speed future calls to 'get_command_class()'.

        Raises DistutilsModuleError if the expected module could not be
        found, or if that module does not define the expected class.
        """
        klass = self.cmdclass.get(command)
        if klass:
            return klass

        for pkgname in self.get_command_packages():
            module_name = "%s.%s" % (pkgname, command)
            klass_name = command

            try:
                __import__(module_name)
                module = sys.modules[module_name]
            except ImportError:
                continue

            try:
                klass = getattr(module, klass_name)
            except AttributeError:
                raise DistutilsModuleError(
                    "invalid command '%s' (no class '%s' in module '%s')"
                    % (command, klass_name, module_name))

            self.cmdclass[command] = klass
            return klass

        raise DistutilsModuleError("invalid command '%s'" % command)

    def get_command_obj(self, command, create=1):
        """Return the command object for 'command'.  Normally this object
        is cached on a previous call to 'get_command_obj()'; if no command
        object for 'command' is in the cache, then we either create and
        return it (if 'create' is true) or return None.
        """
        cmd_obj = self.command_obj.get(command)
        if not cmd_obj and create:
            if DEBUG:
                self.announce("Distribution.get_command_obj(): "
                              "creating '%s' command object" % command)

            klass = self.get_command_class(command)
            cmd_obj = self.command_obj[command] = klass(self)
            self.have_run[command] = 0

            # Set any options that were supplied in config files
            # or on the command line.  (NB. support for error
            # reporting is lame here: any errors aren't reported
            # until 'finalize_options()' is called, which means
            # we won't report the source of the error.)
            options = self.command_options.get(command)
            if options:
                self._set_command_options(cmd_obj, options)

        return cmd_obj

    def _set_command_options(self, command_obj, option_dict=None):
        """Set the options for 'command_obj' from 'option_dict'.  Basically
        this means copying elements of a dictionary ('option_dict') to
        attributes of an instance ('command').

        'command_obj' must be a Command instance.  If 'option_dict' is not
        supplied, uses the standard option dictionary for this command
        (from 'self.command_options').
        """
        command_name = command_obj.get_command_name()
        if option_dict is None:
            option_dict = self.get_option_dict(command_name)

        if DEBUG:
            self.announce("  setting options for '%s' command:" % command_name)
        for (option, (source, value)) in option_dict.items():
            if DEBUG:
                self.announce("    %s = %s (from %s)" % (option, value,
                                                         source))
            try:
                bool_opts = [translate_longopt(o)
                             for o in command_obj.boolean_options]
            except AttributeError:
                bool_opts = []
            try:
                neg_opt = command_obj.negative_opt
            except AttributeError:
                neg_opt = {}

            try:
                is_string = isinstance(value, str)
                if option in neg_opt and is_string:
                    setattr(command_obj, neg_opt[option], not strtobool(value))
                elif option in bool_opts and is_string:
                    setattr(command_obj, option, strtobool(value))
                elif hasattr(command_obj, option):
                    setattr(command_obj, option, value)
                else:
                    raise DistutilsOptionError(
                        "error in %s: command '%s' has no such option '%s'"
                        % (source, command_name, option))
            except ValueError as msg:
                raise DistutilsOptionError(msg)

    def reinitialize_command(self, command, reinit_subcommands=0):
        """Reinitializes a command to the state it was in when first
        returned by 'get_command_obj()': ie., initialized but not yet
        finalized.  This provides the opportunity to sneak option
        values in programmatically, overriding or supplementing
        user-supplied values from the config files and command line.
        You'll have to re-finalize the command object (by calling
        'finalize_options()' or 'ensure_finalized()') before using it for
        real.

        'command' should be a command name (string) or command object.  If
        'reinit_subcommands' is true, also reinitializes the command's
        sub-commands, as declared by the 'sub_commands' class attribute (if
        it has one).  See the "install" command for an example.  Only
        reinitializes the sub-commands that actually matter, ie. those
        whose test predicates return true.

        Returns the reinitialized command object.
        """
        from distutils.cmd import Command
        if not isinstance(command, Command):
            command_name = command
            command = self.get_command_obj(command_name)
        else:
            command_name = command.get_command_name()

        if not command.finalized:
            return command
        command.initialize_options()
        command.finalized = 0
        self.have_run[command_name] = 0
        self._set_command_options(command)

        if reinit_subcommands:
            for sub in command.get_sub_commands():
                self.reinitialize_command(sub, reinit_subcommands)

        return command

    # -- Methods that operate on the Distribution ----------------------

    def announce(self, msg, level=log.INFO):
        log.log(level, msg)

    def run_commands(self):
        """Run each command that was seen on the setup script command line.
        Uses the list of commands found and cache of command objects
        created by 'get_command_obj()'.
        """
        for cmd in self.commands:
            self.run_command(cmd)

    # -- Methods that operate on its Commands --------------------------

    def run_command(self, command):
        """Do whatever it takes to run a command (including nothing at all,
        if the command has already been run).  Specifically: if we have
        already created and run the command named by 'command', return
        silently without doing anything.  If the command named by 'command'
        doesn't even have a command object yet, create one.  Then invoke
        'run()' on that command object (or an existing one).
        """
        # Already been here, done that? then return silently.
        if self.have_run.get(command):
            return

        log.info("running %s", command)
        cmd_obj = self.get_command_obj(command)
        cmd_obj.ensure_finalized()
        cmd_obj.run()
        self.have_run[command] = 1

    # -- Distribution query methods ------------------------------------

    def has_pure_modules(self):
        return len(self.packages or self.py_modules or []) > 0

    def has_ext_modules(self):
        return self.ext_modules and len(self.ext_modules) > 0

    def has_c_libraries(self):
        return self.libraries and len(self.libraries) > 0

    def has_modules(self):
        return self.has_pure_modules() or self.has_ext_modules()

    def has_headers(self):
        return self.headers and len(self.headers) > 0

    def has_scripts(self):
        return self.scripts and len(self.scripts) > 0

    def has_data_files(self):
        return self.data_files and len(self.data_files) > 0

    def is_pure(self):
        return (self.has_pure_modules() and
                not self.has_ext_modules() and
                not self.has_c_libraries())

    # -- Metadata query methods ----------------------------------------

    # If you're looking for 'get_name()', 'get_version()', and so forth,
    # they are defined in a sneaky way: the constructor binds self.get_XXX
    # to self.metadata.get_XXX.  The actual code is in the
    # DistributionMetadata class, below.

class DistributionMetadata:
    """Dummy class to hold the distribution meta-data: name, version,
    author, and so forth.
    """

    _METHOD_BASENAMES = ("name", "version", "author", "author_email",
                         "maintainer", "maintainer_email", "url",
                         "license", "description", "long_description",
                         "keywords", "platforms", "fullname", "contact",
                         "contact_email", "classifiers", "download_url",
                         # PEP 314
                         "provides", "requires", "obsoletes",
                         )

    def __init__(self, path=None):
        if path is not None:
            self.read_pkg_file(open(path))
        else:
            self.name = None
            self.version = None
            self.author = None
            self.author_email = None
            self.maintainer = None
            self.maintainer_email = None
            self.url = None
            self.license = None
            self.description = None
            self.long_description = None
            self.keywords = None
            self.platforms = None
            self.classifiers = None
            self.download_url = None
            # PEP 314
            self.provides = None
            self.requires = None
            self.obsoletes = None

    def read_pkg_file(self, file):
        """Reads the metadata values from a file object."""
        msg = message_from_file(file)

        def _read_field(name):
            value = msg[name]
            if value == 'UNKNOWN':
                return None
            return value

        def _read_list(name):
            values = msg.get_all(name, None)
            if values == []:
                return None
            return values

        metadata_version = msg['metadata-version']
        self.name = _read_field('name')
        self.version = _read_field('version')
        self.description = _read_field('summary')
        # we are filling author only.
        self.author = _read_field('author')
        self.maintainer = None
        self.author_email = _read_field('author-email')
        self.maintainer_email = None
        self.url = _read_field('home-page')
        self.license = _read_field('license')

        if 'download-url' in msg:
            self.download_url = _read_field('download-url')
        else:
            self.download_url = None

        self.long_description = _read_field('description')
        self.description = _read_field('summary')

        if 'keywords' in msg:
            self.keywords = _read_field('keywords').split(',')

        self.platforms = _read_list('platform')
        self.classifiers = _read_list('classifier')

        # PEP 314 - these fields only exist in 1.1
        if metadata_version == '1.1':
            self.requires = _read_list('requires')
            self.provides = _read_list('provides')
            self.obsoletes = _read_list('obsoletes')
        else:
            self.requires = None
            self.provides = None
            self.obsoletes = None

    def write_pkg_info(self, base_dir):
        """Write the PKG-INFO file into the release tree.
        """
        with open(os.path.join(base_dir, 'PKG-INFO'), 'w',
                  encoding='UTF-8') as pkg_info:
            self.write_pkg_file(pkg_info)

    def write_pkg_file(self, file):
        """Write the PKG-INFO format data to a file object.
        """
        version = '1.0'
        if (self.provides or self.requires or self.obsoletes or
                self.classifiers or self.download_url):
            version = '1.1'

        file.write('Metadata-Version: %s\n' % version)
        file.write('Name: %s\n' % self.get_name())
        file.write('Version: %s\n' % self.get_version())
        file.write('Summary: %s\n' % self.get_description())
        file.write('Home-page: %s\n' % self.get_url())
        file.write('Author: %s\n' % self.get_contact())
        file.write('Author-email: %s\n' % self.get_contact_email())
        file.write('License: %s\n' % self.get_license())
        if self.download_url:
            file.write('Download-URL: %s\n' % self.download_url)

        long_desc = rfc822_escape(self.get_long_description())
        file.write('Description: %s\n' % long_desc)

        keywords = ','.join(self.get_keywords())
        if keywords:
            file.write('Keywords: %s\n' % keywords)

        self._write_list(file, 'Platform', self.get_platforms())
        self._write_list(file, 'Classifier', self.get_classifiers())

        # PEP 314
        self._write_list(file, 'Requires', self.get_requires())
        self._write_list(file, 'Provides', self.get_provides())
        self._write_list(file, 'Obsoletes', self.get_obsoletes())

    def _write_list(self, file, name, values):
        for value in values:
            file.write('%s: %s\n' % (name, value))

    # -- Metadata query methods ----------------------------------------

    def get_name(self):
        return self.name or "UNKNOWN"

    def get_version(self):
        return self.version or "0.0.0"

    def get_fullname(self):
        return "%s-%s" % (self.get_name(), self.get_version())

    def get_author(self):
        return self.author or "UNKNOWN"

    def get_author_email(self):
        return self.author_email or "UNKNOWN"

    def get_maintainer(self):
        return self.maintainer or "UNKNOWN"

    def get_maintainer_email(self):
        return self.maintainer_email or "UNKNOWN"

    def get_contact(self):
        return self.maintainer or self.author or "UNKNOWN"

    def get_contact_email(self):
        return self.maintainer_email or self.author_email or "UNKNOWN"

    def get_url(self):
        return self.url or "UNKNOWN"

    def get_license(self):
        return self.license or "UNKNOWN"
    get_licence = get_license

    def get_description(self):
        return self.description or "UNKNOWN"

    def get_long_description(self):
        return self.long_description or "UNKNOWN"

    def get_keywords(self):
        return self.keywords or []

    def set_keywords(self, value):
        self.keywords = _ensure_list(value, 'keywords')

    def get_platforms(self):
        return self.platforms or ["UNKNOWN"]

    def set_platforms(self, value):
        self.platforms = _ensure_list(value, 'platforms')

    def get_classifiers(self):
        return self.classifiers or []

    def set_classifiers(self, value):
        self.classifiers = _ensure_list(value, 'classifiers')

    def get_download_url(self):
        return self.download_url or "UNKNOWN"

    # PEP 314
    def get_requires(self):
        return self.requires or []

    def set_requires(self, value):
        import distutils.versionpredicate
        for v in value:
            distutils.versionpredicate.VersionPredicate(v)
        self.requires = list(value)

    def get_provides(self):
        return self.provides or []

    def set_provides(self, value):
        value = [v.strip() for v in value]
        for v in value:
            import distutils.versionpredicate
            distutils.versionpredicate.split_provision(v)
        self.provides = value

    def get_obsoletes(self):
        return self.obsoletes or []

    def set_obsoletes(self, value):
        import distutils.versionpredicate
        for v in value:
            distutils.versionpredicate.VersionPredicate(v)
        self.obsoletes = list(value)

def fix_help_options(options):
    """Convert a 4-tuple 'help_options' list as found in various command
    classes to the 3-tuple form required by FancyGetopt.
    """
    new_options = []
    for help_tuple in options:
        new_options.append(help_tuple[0:3])
    return new_options
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/errors.py0000644000175100001710000000677100000000000021701 0ustar00runnerdocker"""distutils.errors

Provides exceptions used by the Distutils modules.  Note that Distutils
modules may raise standard exceptions; in particular, SystemExit is
usually raised for errors that are obviously the end-user's fault
(eg. bad command-line arguments).

This module is safe to use in "from ... import *" mode; it only exports
symbols whose names start with "Distutils" and end with "Error"."""

class DistutilsError (Exception):
    """The root of all Distutils evil."""
    pass

class DistutilsModuleError (DistutilsError):
    """Unable to load an expected module, or to find an expected class
    within some module (in particular, command modules and classes)."""
    pass

class DistutilsClassError (DistutilsError):
    """Some command class (or possibly distribution class, if anyone
    feels a need to subclass Distribution) is found not to be holding
    up its end of the bargain, ie. implementing some part of the
    "command "interface."""
    pass

class DistutilsGetoptError (DistutilsError):
    """The option table provided to 'fancy_getopt()' is bogus."""
    pass

class DistutilsArgError (DistutilsError):
    """Raised by fancy_getopt in response to getopt.error -- ie. an
    error in the command line usage."""
    pass

class DistutilsFileError (DistutilsError):
    """Any problems in the filesystem: expected file not found, etc.
    Typically this is for problems that we detect before OSError
    could be raised."""
    pass

class DistutilsOptionError (DistutilsError):
    """Syntactic/semantic errors in command options, such as use of
    mutually conflicting options, or inconsistent options,
    badly-spelled values, etc.  No distinction is made between option
    values originating in the setup script, the command line, config
    files, or what-have-you -- but if we *know* something originated in
    the setup script, we'll raise DistutilsSetupError instead."""
    pass

class DistutilsSetupError (DistutilsError):
    """For errors that can be definitely blamed on the setup script,
    such as invalid keyword arguments to 'setup()'."""
    pass

class DistutilsPlatformError (DistutilsError):
    """We don't know how to do something on the current platform (but
    we do know how to do it on some platform) -- eg. trying to compile
    C files on a platform not supported by a CCompiler subclass."""
    pass

class DistutilsExecError (DistutilsError):
    """Any problems executing an external program (such as the C
    compiler, when compiling C files)."""
    pass

class DistutilsInternalError (DistutilsError):
    """Internal inconsistencies or impossibilities (obviously, this
    should never be seen if the code is working!)."""
    pass

class DistutilsTemplateError (DistutilsError):
    """Syntax error in a file list template."""

class DistutilsByteCompileError(DistutilsError):
    """Byte compile error."""

# Exception classes used by the CCompiler implementation classes
class CCompilerError (Exception):
    """Some compile/link operation failed."""

class PreprocessError (CCompilerError):
    """Failure to preprocess one or more C/C++ files."""

class CompileError (CCompilerError):
    """Failure to compile one or more C/C++ source files."""

class LibError (CCompilerError):
    """Failure to create a static library from one or more C/C++ object
    files."""

class LinkError (CCompilerError):
    """Failure to link one or more C/C++ object files into an executable
    or shared library file."""

class UnknownFileError (CCompilerError):
    """Attempt to process an unknown file type."""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/extension.py0000644000175100001710000002442300000000000022373 0ustar00runnerdocker"""distutils.extension

Provides the Extension class, used to describe C/C++ extension
modules in setup scripts."""

import os
import warnings

# This class is really only used by the "build_ext" command, so it might
# make sense to put it in distutils.command.build_ext.  However, that
# module is already big enough, and I want to make this class a bit more
# complex to simplify some common cases ("foo" module in "foo.c") and do
# better error-checking ("foo.c" actually exists).
#
# Also, putting this in build_ext.py means every setup script would have to
# import that large-ish module (indirectly, through distutils.core) in
# order to do anything.

class Extension:
    """Just a collection of attributes that describes an extension
    module and everything needed to build it (hopefully in a portable
    way, but there are hooks that let you be as unportable as you need).

    Instance attributes:
      name : string
        the full name of the extension, including any packages -- ie.
        *not* a filename or pathname, but Python dotted name
      sources : [string]
        list of source filenames, relative to the distribution root
        (where the setup script lives), in Unix form (slash-separated)
        for portability.  Source files may be C, C++, SWIG (.i),
        platform-specific resource files, or whatever else is recognized
        by the "build_ext" command as source for a Python extension.
      include_dirs : [string]
        list of directories to search for C/C++ header files (in Unix
        form for portability)
      define_macros : [(name : string, value : string|None)]
        list of macros to define; each macro is defined using a 2-tuple,
        where 'value' is either the string to define it to or None to
        define it without a particular value (equivalent of "#define
        FOO" in source or -DFOO on Unix C compiler command line)
      undef_macros : [string]
        list of macros to undefine explicitly
      library_dirs : [string]
        list of directories to search for C/C++ libraries at link time
      libraries : [string]
        list of library names (not filenames or paths) to link against
      runtime_library_dirs : [string]
        list of directories to search for C/C++ libraries at run time
        (for shared extensions, this is when the extension is loaded)
      extra_objects : [string]
        list of extra files to link with (eg. object files not implied
        by 'sources', static library that must be explicitly specified,
        binary resource files, etc.)
      extra_compile_args : [string]
        any extra platform- and compiler-specific information to use
        when compiling the source files in 'sources'.  For platforms and
        compilers where "command line" makes sense, this is typically a
        list of command-line arguments, but for other platforms it could
        be anything.
      extra_link_args : [string]
        any extra platform- and compiler-specific information to use
        when linking object files together to create the extension (or
        to create a new static Python interpreter).  Similar
        interpretation as for 'extra_compile_args'.
      export_symbols : [string]
        list of symbols to be exported from a shared extension.  Not
        used on all platforms, and not generally necessary for Python
        extensions, which typically export exactly one symbol: "init" +
        extension_name.
      swig_opts : [string]
        any extra options to pass to SWIG if a source file has the .i
        extension.
      depends : [string]
        list of files that the extension depends on
      language : string
        extension language (i.e. "c", "c++", "objc"). Will be detected
        from the source extensions if not provided.
      optional : boolean
        specifies that a build failure in the extension should not abort the
        build process, but simply not install the failing extension.
    """

    # When adding arguments to this constructor, be sure to update
    # setup_keywords in core.py.
    def __init__(self, name, sources,
                  include_dirs=None,
                  define_macros=None,
                  undef_macros=None,
                  library_dirs=None,
                  libraries=None,
                  runtime_library_dirs=None,
                  extra_objects=None,
                  extra_compile_args=None,
                  extra_link_args=None,
                  export_symbols=None,
                  swig_opts = None,
                  depends=None,
                  language=None,
                  optional=None,
                  **kw                      # To catch unknown keywords
                 ):
        if not isinstance(name, str):
            raise AssertionError("'name' must be a string")
        if not (isinstance(sources, list) and
                all(isinstance(v, str) for v in sources)):
            raise AssertionError("'sources' must be a list of strings")

        self.name = name
        self.sources = sources
        self.include_dirs = include_dirs or []
        self.define_macros = define_macros or []
        self.undef_macros = undef_macros or []
        self.library_dirs = library_dirs or []
        self.libraries = libraries or []
        self.runtime_library_dirs = runtime_library_dirs or []
        self.extra_objects = extra_objects or []
        self.extra_compile_args = extra_compile_args or []
        self.extra_link_args = extra_link_args or []
        self.export_symbols = export_symbols or []
        self.swig_opts = swig_opts or []
        self.depends = depends or []
        self.language = language
        self.optional = optional

        # If there are unknown keyword options, warn about them
        if len(kw) > 0:
            options = [repr(option) for option in kw]
            options = ', '.join(sorted(options))
            msg = "Unknown Extension options: %s" % options
            warnings.warn(msg)

    def __repr__(self):
        return '<%s.%s(%r) at %#x>' % (
            self.__class__.__module__,
            self.__class__.__qualname__,
            self.name,
            id(self))


def read_setup_file(filename):
    """Reads a Setup file and returns Extension instances."""
    from distutils.sysconfig import (parse_makefile, expand_makefile_vars,
                                     _variable_rx)

    from distutils.text_file import TextFile
    from distutils.util import split_quoted

    # First pass over the file to gather "VAR = VALUE" assignments.
    vars = parse_makefile(filename)

    # Second pass to gobble up the real content: lines of the form
    #    ... [ ...] [ ...] [ ...]
    file = TextFile(filename,
                    strip_comments=1, skip_blanks=1, join_lines=1,
                    lstrip_ws=1, rstrip_ws=1)
    try:
        extensions = []

        while True:
            line = file.readline()
            if line is None:                # eof
                break
            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
                continue

            if line[0] == line[-1] == "*":
                file.warn("'%s' lines not handled yet" % line)
                continue

            line = expand_makefile_vars(line, vars)
            words = split_quoted(line)

            # NB. this parses a slightly different syntax than the old
            # makesetup script: here, there must be exactly one extension per
            # line, and it must be the first word of the line.  I have no idea
            # why the old syntax supported multiple extensions per line, as
            # they all wind up being the same.

            module = words[0]
            ext = Extension(module, [])
            append_next_word = None

            for word in words[1:]:
                if append_next_word is not None:
                    append_next_word.append(word)
                    append_next_word = None
                    continue

                suffix = os.path.splitext(word)[1]
                switch = word[0:2] ; value = word[2:]

                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
                    # hmm, should we do something about C vs. C++ sources?
                    # or leave it up to the CCompiler implementation to
                    # worry about?
                    ext.sources.append(word)
                elif switch == "-I":
                    ext.include_dirs.append(value)
                elif switch == "-D":
                    equals = value.find("=")
                    if equals == -1:        # bare "-DFOO" -- no value
                        ext.define_macros.append((value, None))
                    else:                   # "-DFOO=blah"
                        ext.define_macros.append((value[0:equals],
                                                  value[equals+2:]))
                elif switch == "-U":
                    ext.undef_macros.append(value)
                elif switch == "-C":        # only here 'cause makesetup has it!
                    ext.extra_compile_args.append(word)
                elif switch == "-l":
                    ext.libraries.append(value)
                elif switch == "-L":
                    ext.library_dirs.append(value)
                elif switch == "-R":
                    ext.runtime_library_dirs.append(value)
                elif word == "-rpath":
                    append_next_word = ext.runtime_library_dirs
                elif word == "-Xlinker":
                    append_next_word = ext.extra_link_args
                elif word == "-Xcompiler":
                    append_next_word = ext.extra_compile_args
                elif switch == "-u":
                    ext.extra_link_args.append(word)
                    if not value:
                        append_next_word = ext.extra_link_args
                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
                    # NB. a really faithful emulation of makesetup would
                    # append a .o file to extra_objects only if it
                    # had a slash in it; otherwise, it would s/.o/.c/
                    # and append it to sources.  Hmmmm.
                    ext.extra_objects.append(word)
                else:
                    file.warn("unrecognized argument '%s'" % word)

            extensions.append(ext)
    finally:
        file.close()

    return extensions
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/fancy_getopt.py0000644000175100001710000004257000000000000023044 0ustar00runnerdocker"""distutils.fancy_getopt

Wrapper around the standard getopt module that provides the following
additional features:
  * short and long options are tied together
  * options have help strings, so fancy_getopt could potentially
    create a complete usage summary
  * options set attributes of a passed-in object
"""

import sys, string, re
import getopt
from distutils.errors import *

# Much like command_re in distutils.core, this is close to but not quite
# the same as a Python NAME -- except, in the spirit of most GNU
# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
# The similarities to NAME are again not a coincidence...
longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
longopt_re = re.compile(r'^%s$' % longopt_pat)

# For recognizing "negative alias" options, eg. "quiet=!verbose"
neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat))

# This is used to translate long options to legitimate Python identifiers
# (for use as attributes of some object).
longopt_xlate = str.maketrans('-', '_')

class FancyGetopt:
    """Wrapper around the standard 'getopt()' module that provides some
    handy extra functionality:
      * short and long options are tied together
      * options have help strings, and help text can be assembled
        from them
      * options set attributes of a passed-in object
      * boolean options can have "negative aliases" -- eg. if
        --quiet is the "negative alias" of --verbose, then "--quiet"
        on the command line sets 'verbose' to false
    """

    def __init__(self, option_table=None):
        # The option table is (currently) a list of tuples.  The
        # tuples may have 3 or four values:
        #   (long_option, short_option, help_string [, repeatable])
        # if an option takes an argument, its long_option should have '='
        # appended; short_option should just be a single character, no ':'
        # in any case.  If a long_option doesn't have a corresponding
        # short_option, short_option should be None.  All option tuples
        # must have long options.
        self.option_table = option_table

        # 'option_index' maps long option names to entries in the option
        # table (ie. those 3-tuples).
        self.option_index = {}
        if self.option_table:
            self._build_index()

        # 'alias' records (duh) alias options; {'foo': 'bar'} means
        # --foo is an alias for --bar
        self.alias = {}

        # 'negative_alias' keeps track of options that are the boolean
        # opposite of some other option
        self.negative_alias = {}

        # These keep track of the information in the option table.  We
        # don't actually populate these structures until we're ready to
        # parse the command-line, since the 'option_table' passed in here
        # isn't necessarily the final word.
        self.short_opts = []
        self.long_opts = []
        self.short2long = {}
        self.attr_name = {}
        self.takes_arg = {}

        # And 'option_order' is filled up in 'getopt()'; it records the
        # original order of options (and their values) on the command-line,
        # but expands short options, converts aliases, etc.
        self.option_order = []

    def _build_index(self):
        self.option_index.clear()
        for option in self.option_table:
            self.option_index[option[0]] = option

    def set_option_table(self, option_table):
        self.option_table = option_table
        self._build_index()

    def add_option(self, long_option, short_option=None, help_string=None):
        if long_option in self.option_index:
            raise DistutilsGetoptError(
                  "option conflict: already an option '%s'" % long_option)
        else:
            option = (long_option, short_option, help_string)
            self.option_table.append(option)
            self.option_index[long_option] = option

    def has_option(self, long_option):
        """Return true if the option table for this parser has an
        option with long name 'long_option'."""
        return long_option in self.option_index

    def get_attr_name(self, long_option):
        """Translate long option name 'long_option' to the form it
        has as an attribute of some object: ie., translate hyphens
        to underscores."""
        return long_option.translate(longopt_xlate)

    def _check_alias_dict(self, aliases, what):
        assert isinstance(aliases, dict)
        for (alias, opt) in aliases.items():
            if alias not in self.option_index:
                raise DistutilsGetoptError(("invalid %s '%s': "
                       "option '%s' not defined") % (what, alias, alias))
            if opt not in self.option_index:
                raise DistutilsGetoptError(("invalid %s '%s': "
                       "aliased option '%s' not defined") % (what, alias, opt))

    def set_aliases(self, alias):
        """Set the aliases for this option parser."""
        self._check_alias_dict(alias, "alias")
        self.alias = alias

    def set_negative_aliases(self, negative_alias):
        """Set the negative aliases for this option parser.
        'negative_alias' should be a dictionary mapping option names to
        option names, both the key and value must already be defined
        in the option table."""
        self._check_alias_dict(negative_alias, "negative alias")
        self.negative_alias = negative_alias

    def _grok_option_table(self):
        """Populate the various data structures that keep tabs on the
        option table.  Called by 'getopt()' before it can do anything
        worthwhile.
        """
        self.long_opts = []
        self.short_opts = []
        self.short2long.clear()
        self.repeat = {}

        for option in self.option_table:
            if len(option) == 3:
                long, short, help = option
                repeat = 0
            elif len(option) == 4:
                long, short, help, repeat = option
            else:
                # the option table is part of the code, so simply
                # assert that it is correct
                raise ValueError("invalid option tuple: %r" % (option,))

            # Type- and value-check the option names
            if not isinstance(long, str) or len(long) < 2:
                raise DistutilsGetoptError(("invalid long option '%s': "
                       "must be a string of length >= 2") % long)

            if (not ((short is None) or
                     (isinstance(short, str) and len(short) == 1))):
                raise DistutilsGetoptError("invalid short option '%s': "
                       "must a single character or None" % short)

            self.repeat[long] = repeat
            self.long_opts.append(long)

            if long[-1] == '=':             # option takes an argument?
                if short: short = short + ':'
                long = long[0:-1]
                self.takes_arg[long] = 1
            else:
                # Is option is a "negative alias" for some other option (eg.
                # "quiet" == "!verbose")?
                alias_to = self.negative_alias.get(long)
                if alias_to is not None:
                    if self.takes_arg[alias_to]:
                        raise DistutilsGetoptError(
                              "invalid negative alias '%s': "
                              "aliased option '%s' takes a value"
                              % (long, alias_to))

                    self.long_opts[-1] = long # XXX redundant?!
                self.takes_arg[long] = 0

            # If this is an alias option, make sure its "takes arg" flag is
            # the same as the option it's aliased to.
            alias_to = self.alias.get(long)
            if alias_to is not None:
                if self.takes_arg[long] != self.takes_arg[alias_to]:
                    raise DistutilsGetoptError(
                          "invalid alias '%s': inconsistent with "
                          "aliased option '%s' (one of them takes a value, "
                          "the other doesn't"
                          % (long, alias_to))

            # Now enforce some bondage on the long option name, so we can
            # later translate it to an attribute name on some object.  Have
            # to do this a bit late to make sure we've removed any trailing
            # '='.
            if not longopt_re.match(long):
                raise DistutilsGetoptError(
                       "invalid long option name '%s' "
                       "(must be letters, numbers, hyphens only" % long)

            self.attr_name[long] = self.get_attr_name(long)
            if short:
                self.short_opts.append(short)
                self.short2long[short[0]] = long

    def getopt(self, args=None, object=None):
        """Parse command-line options in args. Store as attributes on object.

        If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
        'object' is None or not supplied, creates a new OptionDummy
        object, stores option values there, and returns a tuple (args,
        object).  If 'object' is supplied, it is modified in place and
        'getopt()' just returns 'args'; in both cases, the returned
        'args' is a modified copy of the passed-in 'args' list, which
        is left untouched.
        """
        if args is None:
            args = sys.argv[1:]
        if object is None:
            object = OptionDummy()
            created_object = True
        else:
            created_object = False

        self._grok_option_table()

        short_opts = ' '.join(self.short_opts)
        try:
            opts, args = getopt.getopt(args, short_opts, self.long_opts)
        except getopt.error as msg:
            raise DistutilsArgError(msg)

        for opt, val in opts:
            if len(opt) == 2 and opt[0] == '-': # it's a short option
                opt = self.short2long[opt[1]]
            else:
                assert len(opt) > 2 and opt[:2] == '--'
                opt = opt[2:]

            alias = self.alias.get(opt)
            if alias:
                opt = alias

            if not self.takes_arg[opt]:     # boolean option?
                assert val == '', "boolean option can't have value"
                alias = self.negative_alias.get(opt)
                if alias:
                    opt = alias
                    val = 0
                else:
                    val = 1

            attr = self.attr_name[opt]
            # The only repeating option at the moment is 'verbose'.
            # It has a negative option -q quiet, which should set verbose = 0.
            if val and self.repeat.get(attr) is not None:
                val = getattr(object, attr, 0) + 1
            setattr(object, attr, val)
            self.option_order.append((opt, val))

        # for opts
        if created_object:
            return args, object
        else:
            return args

    def get_option_order(self):
        """Returns the list of (option, value) tuples processed by the
        previous run of 'getopt()'.  Raises RuntimeError if
        'getopt()' hasn't been called yet.
        """
        if self.option_order is None:
            raise RuntimeError("'getopt()' hasn't been called yet")
        else:
            return self.option_order

    def generate_help(self, header=None):
        """Generate help text (a list of strings, one per suggested line of
        output) from the option table for this FancyGetopt object.
        """
        # Blithely assume the option table is good: probably wouldn't call
        # 'generate_help()' unless you've already called 'getopt()'.

        # First pass: determine maximum length of long option names
        max_opt = 0
        for option in self.option_table:
            long = option[0]
            short = option[1]
            l = len(long)
            if long[-1] == '=':
                l = l - 1
            if short is not None:
                l = l + 5                   # " (-x)" where short == 'x'
            if l > max_opt:
                max_opt = l

        opt_width = max_opt + 2 + 2 + 2     # room for indent + dashes + gutter

        # Typical help block looks like this:
        #   --foo       controls foonabulation
        # Help block for longest option looks like this:
        #   --flimflam  set the flim-flam level
        # and with wrapped text:
        #   --flimflam  set the flim-flam level (must be between
        #               0 and 100, except on Tuesdays)
        # Options with short names will have the short name shown (but
        # it doesn't contribute to max_opt):
        #   --foo (-f)  controls foonabulation
        # If adding the short option would make the left column too wide,
        # we push the explanation off to the next line
        #   --flimflam (-l)
        #               set the flim-flam level
        # Important parameters:
        #   - 2 spaces before option block start lines
        #   - 2 dashes for each long option name
        #   - min. 2 spaces between option and explanation (gutter)
        #   - 5 characters (incl. space) for short option name

        # Now generate lines of help text.  (If 80 columns were good enough
        # for Jesus, then 78 columns are good enough for me!)
        line_width = 78
        text_width = line_width - opt_width
        big_indent = ' ' * opt_width
        if header:
            lines = [header]
        else:
            lines = ['Option summary:']

        for option in self.option_table:
            long, short, help = option[:3]
            text = wrap_text(help, text_width)
            if long[-1] == '=':
                long = long[0:-1]

            # Case 1: no short option at all (makes life easy)
            if short is None:
                if text:
                    lines.append("  --%-*s  %s" % (max_opt, long, text[0]))
                else:
                    lines.append("  --%-*s  " % (max_opt, long))

            # Case 2: we have a short option, so we have to include it
            # just after the long option
            else:
                opt_names = "%s (-%s)" % (long, short)
                if text:
                    lines.append("  --%-*s  %s" %
                                 (max_opt, opt_names, text[0]))
                else:
                    lines.append("  --%-*s" % opt_names)

            for l in text[1:]:
                lines.append(big_indent + l)
        return lines

    def print_help(self, header=None, file=None):
        if file is None:
            file = sys.stdout
        for line in self.generate_help(header):
            file.write(line + "\n")


def fancy_getopt(options, negative_opt, object, args):
    parser = FancyGetopt(options)
    parser.set_negative_aliases(negative_opt)
    return parser.getopt(args, object)


WS_TRANS = {ord(_wschar) : ' ' for _wschar in string.whitespace}

def wrap_text(text, width):
    """wrap_text(text : string, width : int) -> [string]

    Split 'text' into multiple lines of no more than 'width' characters
    each, and return the list of strings that results.
    """
    if text is None:
        return []
    if len(text) <= width:
        return [text]

    text = text.expandtabs()
    text = text.translate(WS_TRANS)
    chunks = re.split(r'( +|-+)', text)
    chunks = [ch for ch in chunks if ch] # ' - ' results in empty strings
    lines = []

    while chunks:
        cur_line = []                   # list of chunks (to-be-joined)
        cur_len = 0                     # length of current line

        while chunks:
            l = len(chunks[0])
            if cur_len + l <= width:    # can squeeze (at least) this chunk in
                cur_line.append(chunks[0])
                del chunks[0]
                cur_len = cur_len + l
            else:                       # this line is full
                # drop last chunk if all space
                if cur_line and cur_line[-1][0] == ' ':
                    del cur_line[-1]
                break

        if chunks:                      # any chunks left to process?
            # if the current line is still empty, then we had a single
            # chunk that's too big too fit on a line -- so we break
            # down and break it up at the line width
            if cur_len == 0:
                cur_line.append(chunks[0][0:width])
                chunks[0] = chunks[0][width:]

            # all-whitespace chunks at the end of a line can be discarded
            # (and we know from the re.split above that if a chunk has
            # *any* whitespace, it is *all* whitespace)
            if chunks[0][0] == ' ':
                del chunks[0]

        # and store this line in the list-of-all-lines -- as a single
        # string, of course!
        lines.append(''.join(cur_line))

    return lines


def translate_longopt(opt):
    """Convert a long option name to a valid Python identifier by
    changing "-" to "_".
    """
    return opt.translate(longopt_xlate)


class OptionDummy:
    """Dummy class just used as a place to hold command-line option
    values as instance attributes."""

    def __init__(self, options=[]):
        """Create a new OptionDummy instance.  The attributes listed in
        'options' will be initialized to None."""
        for opt in options:
            setattr(self, opt, None)


if __name__ == "__main__":
    text = """\
Tra-la-la, supercalifragilisticexpialidocious.
How *do* you spell that odd word, anyways?
(Someone ask Mary -- she'll know [or she'll
say, "How should I know?"].)"""

    for w in (10, 20, 30, 40):
        print("width: %d" % w)
        print("\n".join(wrap_text(text, w)))
        print()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/file_util.py0000644000175100001710000001772400000000000022341 0ustar00runnerdocker"""distutils.file_util

Utility functions for operating on single files.
"""

import os
from distutils.errors import DistutilsFileError
from distutils import log

# for generating verbose output in 'copy_file()'
_copy_action = { None:   'copying',
                 'hard': 'hard linking',
                 'sym':  'symbolically linking' }


def _copy_file_contents(src, dst, buffer_size=16*1024):
    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
    opening either file, reading from 'src', or writing to 'dst', raises
    DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
    bytes (default 16k).  No attempt is made to handle anything apart from
    regular files.
    """
    # Stolen from shutil module in the standard library, but with
    # custom error-handling added.
    fsrc = None
    fdst = None
    try:
        try:
            fsrc = open(src, 'rb')
        except OSError as e:
            raise DistutilsFileError("could not open '%s': %s" % (src, e.strerror))

        if os.path.exists(dst):
            try:
                os.unlink(dst)
            except OSError as e:
                raise DistutilsFileError(
                      "could not delete '%s': %s" % (dst, e.strerror))

        try:
            fdst = open(dst, 'wb')
        except OSError as e:
            raise DistutilsFileError(
                  "could not create '%s': %s" % (dst, e.strerror))

        while True:
            try:
                buf = fsrc.read(buffer_size)
            except OSError as e:
                raise DistutilsFileError(
                      "could not read from '%s': %s" % (src, e.strerror))

            if not buf:
                break

            try:
                fdst.write(buf)
            except OSError as e:
                raise DistutilsFileError(
                      "could not write to '%s': %s" % (dst, e.strerror))
    finally:
        if fdst:
            fdst.close()
        if fsrc:
            fsrc.close()

def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
              link=None, verbose=1, dry_run=0):
    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
    copied there with the same name; otherwise, it must be a filename.  (If
    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
    is true (the default), the file's mode (type and permission bits, or
    whatever is analogous on the current platform) is copied.  If
    'preserve_times' is true (the default), the last-modified and
    last-access times are copied as well.  If 'update' is true, 'src' will
    only be copied if 'dst' does not exist, or if 'dst' does exist but is
    older than 'src'.

    'link' allows you to make hard links (os.link) or symbolic links
    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
    None (the default), files are copied.  Don't set 'link' on systems that
    don't support it: 'copy_file()' doesn't check if hard or symbolic
    linking is available. If hardlink fails, falls back to
    _copy_file_contents().

    Under Mac OS, uses the native file copy function in macostools; on
    other systems, uses '_copy_file_contents()' to copy file contents.

    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
    the output file, and 'copied' is true if the file was copied (or would
    have been copied, if 'dry_run' true).
    """
    # XXX if the destination file already exists, we clobber it if
    # copying, but blow up if linking.  Hmmm.  And I don't know what
    # macostools.copyfile() does.  Should definitely be consistent, and
    # should probably blow up if destination exists and we would be
    # changing it (ie. it's not already a hard/soft link to src OR
    # (not update) and (src newer than dst).

    from distutils.dep_util import newer
    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE

    if not os.path.isfile(src):
        raise DistutilsFileError(
              "can't copy '%s': doesn't exist or not a regular file" % src)

    if os.path.isdir(dst):
        dir = dst
        dst = os.path.join(dst, os.path.basename(src))
    else:
        dir = os.path.dirname(dst)

    if update and not newer(src, dst):
        if verbose >= 1:
            log.debug("not copying %s (output up-to-date)", src)
        return (dst, 0)

    try:
        action = _copy_action[link]
    except KeyError:
        raise ValueError("invalid value '%s' for 'link' argument" % link)

    if verbose >= 1:
        if os.path.basename(dst) == os.path.basename(src):
            log.info("%s %s -> %s", action, src, dir)
        else:
            log.info("%s %s -> %s", action, src, dst)

    if dry_run:
        return (dst, 1)

    # If linking (hard or symbolic), use the appropriate system call
    # (Unix only, of course, but that's the caller's responsibility)
    elif link == 'hard':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            try:
                os.link(src, dst)
                return (dst, 1)
            except OSError:
                # If hard linking fails, fall back on copying file
                # (some special filesystems don't support hard linking
                #  even under Unix, see issue #8876).
                pass
    elif link == 'sym':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            os.symlink(src, dst)
            return (dst, 1)

    # Otherwise (non-Mac, not linking), copy the file contents and
    # (optionally) copy the times and mode.
    _copy_file_contents(src, dst)
    if preserve_mode or preserve_times:
        st = os.stat(src)

        # According to David Ascher , utime() should be done
        # before chmod() (at least under NT).
        if preserve_times:
            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
        if preserve_mode:
            os.chmod(dst, S_IMODE(st[ST_MODE]))

    return (dst, 1)


# XXX I suspect this is Unix-specific -- need porting help!
def move_file (src, dst,
               verbose=1,
               dry_run=0):

    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
    be moved into it with the same name; otherwise, 'src' is just renamed
    to 'dst'.  Return the new full name of the file.

    Handles cross-device moves on Unix using 'copy_file()'.  What about
    other systems???
    """
    from os.path import exists, isfile, isdir, basename, dirname
    import errno

    if verbose >= 1:
        log.info("moving %s -> %s", src, dst)

    if dry_run:
        return dst

    if not isfile(src):
        raise DistutilsFileError("can't move '%s': not a regular file" % src)

    if isdir(dst):
        dst = os.path.join(dst, basename(src))
    elif exists(dst):
        raise DistutilsFileError(
              "can't move '%s': destination '%s' already exists" %
              (src, dst))

    if not isdir(dirname(dst)):
        raise DistutilsFileError(
              "can't move '%s': destination '%s' not a valid path" %
              (src, dst))

    copy_it = False
    try:
        os.rename(src, dst)
    except OSError as e:
        (num, msg) = e.args
        if num == errno.EXDEV:
            copy_it = True
        else:
            raise DistutilsFileError(
                  "couldn't move '%s' to '%s': %s" % (src, dst, msg))

    if copy_it:
        copy_file(src, dst, verbose=verbose)
        try:
            os.unlink(src)
        except OSError as e:
            (num, msg) = e.args
            try:
                os.unlink(dst)
            except OSError:
                pass
            raise DistutilsFileError(
                  "couldn't move '%s' to '%s' by copy/delete: "
                  "delete '%s' failed: %s"
                  % (src, dst, src, msg))
    return dst


def write_file (filename, contents):
    """Create a file with the specified name and write 'contents' (a
    sequence of strings without line terminators) to it.
    """
    f = open(filename, "w")
    try:
        for line in contents:
            f.write(line + "\n")
    finally:
        f.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/filelist.py0000644000175100001710000003213700000000000022173 0ustar00runnerdocker"""distutils.filelist

Provides the FileList class, used for poking about the filesystem
and building lists of files.
"""

import os
import re
import fnmatch
import functools

from distutils.util import convert_path
from distutils.errors import DistutilsTemplateError, DistutilsInternalError
from distutils import log


class FileList:
    """A list of files built by on exploring the filesystem and filtered by
    applying various patterns to what we find there.

    Instance attributes:
      dir
        directory from which files will be taken -- only used if
        'allfiles' not supplied to constructor
      files
        list of filenames currently being built/filtered/manipulated
      allfiles
        complete list of files under consideration (ie. without any
        filtering applied)
    """

    def __init__(self, warn=None, debug_print=None):
        # ignore argument to FileList, but keep them for backwards
        # compatibility
        self.allfiles = None
        self.files = []

    def set_allfiles(self, allfiles):
        self.allfiles = allfiles

    def findall(self, dir=os.curdir):
        self.allfiles = findall(dir)

    def debug_print(self, msg):
        """Print 'msg' to stdout if the global DEBUG (taken from the
        DISTUTILS_DEBUG environment variable) flag is true.
        """
        from distutils.debug import DEBUG
        if DEBUG:
            print(msg)

    # Collection methods

    def append(self, item):
        self.files.append(item)

    def extend(self, items):
        self.files.extend(items)

    def sort(self):
        # Not a strict lexical sort!
        sortable_files = sorted(map(os.path.split, self.files))
        self.files = []
        for sort_tuple in sortable_files:
            self.files.append(os.path.join(*sort_tuple))

    # Other miscellaneous utility methods

    def remove_duplicates(self):
        # Assumes list has been sorted!
        for i in range(len(self.files) - 1, 0, -1):
            if self.files[i] == self.files[i - 1]:
                del self.files[i]

    # "File template" methods

    def _parse_template_line(self, line):
        words = line.split()
        action = words[0]

        patterns = dir = dir_pattern = None

        if action in ('include', 'exclude',
                      'global-include', 'global-exclude'):
            if len(words) < 2:
                raise DistutilsTemplateError(
                      "'%s' expects   ..." % action)
            patterns = [convert_path(w) for w in words[1:]]
        elif action in ('recursive-include', 'recursive-exclude'):
            if len(words) < 3:
                raise DistutilsTemplateError(
                      "'%s' expects 
   ..." % action)
            dir = convert_path(words[1])
            patterns = [convert_path(w) for w in words[2:]]
        elif action in ('graft', 'prune'):
            if len(words) != 2:
                raise DistutilsTemplateError(
                      "'%s' expects a single " % action)
            dir_pattern = convert_path(words[1])
        else:
            raise DistutilsTemplateError("unknown action '%s'" % action)

        return (action, patterns, dir, dir_pattern)

    def process_template_line(self, line):
        # Parse the line: split it up, make sure the right number of words
        # is there, and return the relevant words.  'action' is always
        # defined: it's the first word of the line.  Which of the other
        # three are defined depends on the action; it'll be either
        # patterns, (dir and patterns), or (dir_pattern).
        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)

        # OK, now we know that the action is valid and we have the
        # right number of words on the line for that action -- so we
        # can proceed with minimal error-checking.
        if action == 'include':
            self.debug_print("include " + ' '.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=1):
                    log.warn("warning: no files found matching '%s'",
                             pattern)

        elif action == 'exclude':
            self.debug_print("exclude " + ' '.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=1):
                    log.warn(("warning: no previously-included files "
                              "found matching '%s'"), pattern)

        elif action == 'global-include':
            self.debug_print("global-include " + ' '.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=0):
                    log.warn(("warning: no files found matching '%s' "
                              "anywhere in distribution"), pattern)

        elif action == 'global-exclude':
            self.debug_print("global-exclude " + ' '.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=0):
                    log.warn(("warning: no previously-included files matching "
                              "'%s' found anywhere in distribution"),
                             pattern)

        elif action == 'recursive-include':
            self.debug_print("recursive-include %s %s" %
                             (dir, ' '.join(patterns)))
            for pattern in patterns:
                if not self.include_pattern(pattern, prefix=dir):
                    msg = (
                        "warning: no files found matching '%s' "
                        "under directory '%s'"
                    )
                    log.warn(msg, pattern, dir)

        elif action == 'recursive-exclude':
            self.debug_print("recursive-exclude %s %s" %
                             (dir, ' '.join(patterns)))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, prefix=dir):
                    log.warn(("warning: no previously-included files matching "
                              "'%s' found under directory '%s'"),
                             pattern, dir)

        elif action == 'graft':
            self.debug_print("graft " + dir_pattern)
            if not self.include_pattern(None, prefix=dir_pattern):
                log.warn("warning: no directories found matching '%s'",
                         dir_pattern)

        elif action == 'prune':
            self.debug_print("prune " + dir_pattern)
            if not self.exclude_pattern(None, prefix=dir_pattern):
                log.warn(("no previously-included directories found "
                          "matching '%s'"), dir_pattern)
        else:
            raise DistutilsInternalError(
                  "this cannot happen: invalid action '%s'" % action)

    # Filtering/selection methods

    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
        """Select strings (presumably filenames) from 'self.files' that
        match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
        are not quite the same as implemented by the 'fnmatch' module: '*'
        and '?'  match non-special characters, where "special" is platform-
        dependent: slash on Unix; colon, slash, and backslash on
        DOS/Windows; and colon on Mac OS.

        If 'anchor' is true (the default), then the pattern match is more
        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
        'anchor' is false, both of these will match.

        If 'prefix' is supplied, then only filenames starting with 'prefix'
        (itself a pattern) and ending with 'pattern', with anything in between
        them, will match.  'anchor' is ignored in this case.

        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
        'pattern' is assumed to be either a string containing a regex or a
        regex object -- no translation is done, the regex is just compiled
        and used as-is.

        Selected strings will be added to self.files.

        Return True if files are found, False otherwise.
        """
        # XXX docstring lying about what the special chars are?
        files_found = False
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print("include_pattern: applying regex r'%s'" %
                         pattern_re.pattern)

        # delayed loading of allfiles list
        if self.allfiles is None:
            self.findall()

        for name in self.allfiles:
            if pattern_re.search(name):
                self.debug_print(" adding " + name)
                self.files.append(name)
                files_found = True
        return files_found

    def exclude_pattern(
            self, pattern, anchor=1, prefix=None, is_regex=0):
        """Remove strings (presumably filenames) from 'files' that match
        'pattern'.  Other parameters are the same as for
        'include_pattern()', above.
        The list 'self.files' is modified in place.
        Return True if files are found, False otherwise.
        """
        files_found = False
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print("exclude_pattern: applying regex r'%s'" %
                         pattern_re.pattern)
        for i in range(len(self.files)-1, -1, -1):
            if pattern_re.search(self.files[i]):
                self.debug_print(" removing " + self.files[i])
                del self.files[i]
                files_found = True
        return files_found


# Utility functions

def _find_all_simple(path):
    """
    Find all files under 'path'
    """
    all_unique = _UniqueDirs.filter(os.walk(path, followlinks=True))
    results = (
        os.path.join(base, file)
        for base, dirs, files in all_unique
        for file in files
    )
    return filter(os.path.isfile, results)


class _UniqueDirs(set):
    """
    Exclude previously-seen dirs from walk results,
    avoiding infinite recursion.
    Ref https://bugs.python.org/issue44497.
    """
    def __call__(self, walk_item):
        """
        Given an item from an os.walk result, determine
        if the item represents a unique dir for this instance
        and if not, prevent further traversal.
        """
        base, dirs, files = walk_item
        stat = os.stat(base)
        candidate = stat.st_dev, stat.st_ino
        found = candidate in self
        if found:
            del dirs[:]
        self.add(candidate)
        return not found

    @classmethod
    def filter(cls, items):
        return filter(cls(), items)


def findall(dir=os.curdir):
    """
    Find all files under 'dir' and return the list of full filenames.
    Unless dir is '.', return full filenames with dir prepended.
    """
    files = _find_all_simple(dir)
    if dir == os.curdir:
        make_rel = functools.partial(os.path.relpath, start=dir)
        files = map(make_rel, files)
    return list(files)


def glob_to_re(pattern):
    """Translate a shell-like glob pattern to a regular expression; return
    a string containing the regex.  Differs from 'fnmatch.translate()' in
    that '*' does not match "special characters" (which are
    platform-specific).
    """
    pattern_re = fnmatch.translate(pattern)

    # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
    # and by extension they shouldn't match such "special characters" under
    # any OS.  So change all non-escaped dots in the RE to match any
    # character except the special characters (currently: just os.sep).
    sep = os.sep
    if os.sep == '\\':
        # we're using a regex to manipulate a regex, so we need
        # to escape the backslash twice
        sep = r'\\\\'
    escaped = r'\1[^%s]' % sep
    pattern_re = re.sub(r'((?= self.threshold:
            if args:
                msg = msg % args
            if level in (WARN, ERROR, FATAL):
                stream = sys.stderr
            else:
                stream = sys.stdout
            try:
                stream.write('%s\n' % msg)
            except UnicodeEncodeError:
                # emulate backslashreplace error handler
                encoding = stream.encoding
                msg = msg.encode(encoding, "backslashreplace").decode(encoding)
                stream.write('%s\n' % msg)
            stream.flush()

    def log(self, level, msg, *args):
        self._log(level, msg, args)

    def debug(self, msg, *args):
        self._log(DEBUG, msg, args)

    def info(self, msg, *args):
        self._log(INFO, msg, args)

    def warn(self, msg, *args):
        self._log(WARN, msg, args)

    def error(self, msg, *args):
        self._log(ERROR, msg, args)

    def fatal(self, msg, *args):
        self._log(FATAL, msg, args)

_global_log = Log()
log = _global_log.log
debug = _global_log.debug
info = _global_log.info
warn = _global_log.warn
error = _global_log.error
fatal = _global_log.fatal

def set_threshold(level):
    # return the old threshold for use from tests
    old = _global_log.threshold
    _global_log.threshold = level
    return old

def set_verbosity(v):
    if v <= 0:
        set_threshold(WARN)
    elif v == 1:
        set_threshold(INFO)
    elif v >= 2:
        set_threshold(DEBUG)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/msvc9compiler.py0000644000175100001710000007336500000000000023164 0ustar00runnerdocker"""distutils.msvc9compiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio 2008.

The module is compatible with VS 2005 and VS 2008. You can find legacy support
for older versions of VS in distutils.msvccompiler.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)
# ported to VS2005 and VS 2008 by Christian Heimes

import os
import subprocess
import sys
import re

from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
                             CompileError, LibError, LinkError
from distutils.ccompiler import CCompiler, gen_lib_options
from distutils import log
from distutils.util import get_platform

import winreg

RegOpenKeyEx = winreg.OpenKeyEx
RegEnumKey = winreg.EnumKey
RegEnumValue = winreg.EnumValue
RegError = winreg.error

HKEYS = (winreg.HKEY_USERS,
         winreg.HKEY_CURRENT_USER,
         winreg.HKEY_LOCAL_MACHINE,
         winreg.HKEY_CLASSES_ROOT)

NATIVE_WIN64 = (sys.platform == 'win32' and sys.maxsize > 2**32)
if NATIVE_WIN64:
    # Visual C++ is a 32-bit application, so we need to look in
    # the corresponding registry branch, if we're running a
    # 64-bit Python on Win64
    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
else:
    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
    NET_BASE = r"Software\Microsoft\.NETFramework"

# A map keyed by get_platform() return values to values accepted by
# 'vcvarsall.bat'.  Note a cross-compile may combine these (eg, 'x86_amd64' is
# the param to cross-compile on x86 targeting amd64.)
PLAT_TO_VCVARS = {
    'win32' : 'x86',
    'win-amd64' : 'amd64',
}

class Reg:
    """Helper class to read values from the registry
    """

    def get_value(cls, path, key):
        for base in HKEYS:
            d = cls.read_values(base, path)
            if d and key in d:
                return d[key]
        raise KeyError(key)
    get_value = classmethod(get_value)

    def read_keys(cls, base, key):
        """Return list of registry keys."""
        try:
            handle = RegOpenKeyEx(base, key)
        except RegError:
            return None
        L = []
        i = 0
        while True:
            try:
                k = RegEnumKey(handle, i)
            except RegError:
                break
            L.append(k)
            i += 1
        return L
    read_keys = classmethod(read_keys)

    def read_values(cls, base, key):
        """Return dict of registry keys and values.

        All names are converted to lowercase.
        """
        try:
            handle = RegOpenKeyEx(base, key)
        except RegError:
            return None
        d = {}
        i = 0
        while True:
            try:
                name, value, type = RegEnumValue(handle, i)
            except RegError:
                break
            name = name.lower()
            d[cls.convert_mbcs(name)] = cls.convert_mbcs(value)
            i += 1
        return d
    read_values = classmethod(read_values)

    def convert_mbcs(s):
        dec = getattr(s, "decode", None)
        if dec is not None:
            try:
                s = dec("mbcs")
            except UnicodeError:
                pass
        return s
    convert_mbcs = staticmethod(convert_mbcs)

class MacroExpander:

    def __init__(self, version):
        self.macros = {}
        self.vsbase = VS_BASE % version
        self.load_macros(version)

    def set_macro(self, macro, path, key):
        self.macros["$(%s)" % macro] = Reg.get_value(path, key)

    def load_macros(self, version):
        self.set_macro("VCInstallDir", self.vsbase + r"\Setup\VC", "productdir")
        self.set_macro("VSInstallDir", self.vsbase + r"\Setup\VS", "productdir")
        self.set_macro("FrameworkDir", NET_BASE, "installroot")
        try:
            if version >= 8.0:
                self.set_macro("FrameworkSDKDir", NET_BASE,
                               "sdkinstallrootv2.0")
            else:
                raise KeyError("sdkinstallrootv2.0")
        except KeyError:
            raise DistutilsPlatformError(
            """Python was built with Visual Studio 2008;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2008 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")

        if version >= 9.0:
            self.set_macro("FrameworkVersion", self.vsbase, "clr version")
            self.set_macro("WindowsSdkDir", WINSDK_BASE, "currentinstallfolder")
        else:
            p = r"Software\Microsoft\NET Framework Setup\Product"
            for base in HKEYS:
                try:
                    h = RegOpenKeyEx(base, p)
                except RegError:
                    continue
                key = RegEnumKey(h, 0)
                d = Reg.get_value(base, r"%s\%s" % (p, key))
                self.macros["$(FrameworkVersion)"] = d["version"]

    def sub(self, s):
        for k, v in self.macros.items():
            s = s.replace(k, v)
        return s

def get_build_version():
    """Return the version of MSVC that was used to build Python.

    For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    """
    prefix = "MSC v."
    i = sys.version.find(prefix)
    if i == -1:
        return 6
    i = i + len(prefix)
    s, rest = sys.version[i:].split(" ", 1)
    majorVersion = int(s[:-2]) - 6
    if majorVersion >= 13:
        # v13 was skipped and should be v14
        majorVersion += 1
    minorVersion = int(s[2:3]) / 10.0
    # I don't think paths are affected by minor version in version 6
    if majorVersion == 6:
        minorVersion = 0
    if majorVersion >= 6:
        return majorVersion + minorVersion
    # else we don't know what version of the compiler this is
    return None

def normalize_and_reduce_paths(paths):
    """Return a list of normalized paths with duplicates removed.

    The current order of paths is maintained.
    """
    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
    reduced_paths = []
    for p in paths:
        np = os.path.normpath(p)
        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
        if np not in reduced_paths:
            reduced_paths.append(np)
    return reduced_paths

def removeDuplicates(variable):
    """Remove duplicate values of an environment variable.
    """
    oldList = variable.split(os.pathsep)
    newList = []
    for i in oldList:
        if i not in newList:
            newList.append(i)
    newVariable = os.pathsep.join(newList)
    return newVariable

def find_vcvarsall(version):
    """Find the vcvarsall.bat file

    At first it tries to find the productdir of VS 2008 in the registry. If
    that fails it falls back to the VS90COMNTOOLS env var.
    """
    vsbase = VS_BASE % version
    try:
        productdir = Reg.get_value(r"%s\Setup\VC" % vsbase,
                                   "productdir")
    except KeyError:
        log.debug("Unable to find productdir in registry")
        productdir = None

    if not productdir or not os.path.isdir(productdir):
        toolskey = "VS%0.f0COMNTOOLS" % version
        toolsdir = os.environ.get(toolskey, None)

        if toolsdir and os.path.isdir(toolsdir):
            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
            productdir = os.path.abspath(productdir)
            if not os.path.isdir(productdir):
                log.debug("%s is not a valid directory" % productdir)
                return None
        else:
            log.debug("Env var %s is not set or invalid" % toolskey)
    if not productdir:
        log.debug("No productdir found")
        return None
    vcvarsall = os.path.join(productdir, "vcvarsall.bat")
    if os.path.isfile(vcvarsall):
        return vcvarsall
    log.debug("Unable to find vcvarsall.bat")
    return None

def query_vcvarsall(version, arch="x86"):
    """Launch vcvarsall.bat and read the settings from its environment
    """
    vcvarsall = find_vcvarsall(version)
    interesting = {"include", "lib", "libpath", "path"}
    result = {}

    if vcvarsall is None:
        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
    log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
    popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
    try:
        stdout, stderr = popen.communicate()
        if popen.wait() != 0:
            raise DistutilsPlatformError(stderr.decode("mbcs"))

        stdout = stdout.decode("mbcs")
        for line in stdout.split("\n"):
            line = Reg.convert_mbcs(line)
            if '=' not in line:
                continue
            line = line.strip()
            key, value = line.split('=', 1)
            key = key.lower()
            if key in interesting:
                if value.endswith(os.pathsep):
                    value = value[:-1]
                result[key] = removeDuplicates(value)

    finally:
        popen.stdout.close()
        popen.stderr.close()

    if len(result) != len(interesting):
        raise ValueError(str(list(result.keys())))

    return result

# More globals
VERSION = get_build_version()
if VERSION < 8.0:
    raise DistutilsPlatformError("VC %0.1f is not supported by this module" % VERSION)
# MACROS = MacroExpander(VERSION)

class MSVCCompiler(CCompiler) :
    """Concrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class."""

    compiler_type = 'msvc'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']
    _rc_extensions = ['.rc']
    _mc_extensions = ['.mc']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = (_c_extensions + _cpp_extensions +
                      _rc_extensions + _mc_extensions)
    res_extension = '.res'
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

    def __init__(self, verbose=0, dry_run=0, force=0):
        CCompiler.__init__ (self, verbose, dry_run, force)
        self.__version = VERSION
        self.__root = r"Software\Microsoft\VisualStudio"
        # self.__macros = MACROS
        self.__paths = []
        # target platform (.plat_name is consistent with 'bdist')
        self.plat_name = None
        self.__arch = None # deprecated name
        self.initialized = False

    def initialize(self, plat_name=None):
        # multi-init means we would need to check platform same each time...
        assert not self.initialized, "don't init multiple times"
        if plat_name is None:
            plat_name = get_platform()
        # sanity check for platforms to prevent obscure errors later.
        ok_plats = 'win32', 'win-amd64'
        if plat_name not in ok_plats:
            raise DistutilsPlatformError("--plat-name must be one of %s" %
                                         (ok_plats,))

        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
            # Assume that the SDK set up everything alright; don't try to be
            # smarter
            self.cc = "cl.exe"
            self.linker = "link.exe"
            self.lib = "lib.exe"
            self.rc = "rc.exe"
            self.mc = "mc.exe"
        else:
            # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
            # to cross compile, you use 'x86_amd64'.
            # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
            # compile use 'x86' (ie, it runs the x86 compiler directly)
            if plat_name == get_platform() or plat_name == 'win32':
                # native build or cross-compile to win32
                plat_spec = PLAT_TO_VCVARS[plat_name]
            else:
                # cross compile from win32 -> some 64bit
                plat_spec = PLAT_TO_VCVARS[get_platform()] + '_' + \
                            PLAT_TO_VCVARS[plat_name]

            vc_env = query_vcvarsall(VERSION, plat_spec)

            self.__paths = vc_env['path'].split(os.pathsep)
            os.environ['lib'] = vc_env['lib']
            os.environ['include'] = vc_env['include']

            if len(self.__paths) == 0:
                raise DistutilsPlatformError("Python was built with %s, "
                       "and extensions need to be built with the same "
                       "version of the compiler, but it isn't installed."
                       % self.__product)

            self.cc = self.find_exe("cl.exe")
            self.linker = self.find_exe("link.exe")
            self.lib = self.find_exe("lib.exe")
            self.rc = self.find_exe("rc.exe")   # resource compiler
            self.mc = self.find_exe("mc.exe")   # message compiler
            #self.set_path_env_var('lib')
            #self.set_path_env_var('include')

        # extend the MSVC path with the current path
        try:
            for p in os.environ['path'].split(';'):
                self.__paths.append(p)
        except KeyError:
            pass
        self.__paths = normalize_and_reduce_paths(self.__paths)
        os.environ['path'] = ";".join(self.__paths)

        self.preprocess_options = None
        if self.__arch == "x86":
            self.compile_options = [ '/nologo', '/O2', '/MD', '/W3',
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3',
                                          '/Z7', '/D_DEBUG']
        else:
            # Win64
            self.compile_options = [ '/nologo', '/O2', '/MD', '/W3', '/GS-' ,
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
                                          '/Z7', '/D_DEBUG']

        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
        if self.__version >= 7:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
                ]
        self.ldflags_static = [ '/nologo']

        self.initialized = True

    # -- Worker methods ------------------------------------------------

    def object_filenames(self,
                         source_filenames,
                         strip_dir=0,
                         output_dir=''):
        # Copied from ccompiler.py, extended to return .res as 'object'-file
        # for .rc input file
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            (base, ext) = os.path.splitext (src_name)
            base = os.path.splitdrive(base)[1] # Chop off the drive
            base = base[os.path.isabs(base):]  # If abs, chop off leading /
            if ext not in self.src_extensions:
                # Better to raise an exception instead of silently continuing
                # and later complain about sources and targets having
                # different lengths
                raise CompileError ("Don't know how to compile %s" % src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext in self._rc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            elif ext in self._mc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                                base + self.obj_extension))
        return obj_names


    def compile(self, sources,
                output_dir=None, macros=None, include_dirs=None, debug=0,
                extra_preargs=None, extra_postargs=None, depends=None):

        if not self.initialized:
            self.initialize()
        compile_info = self._setup_compile(output_dir, macros, include_dirs,
                                           sources, depends, extra_postargs)
        macros, objects, extra_postargs, pp_opts, build = compile_info

        compile_opts = extra_preargs or []
        compile_opts.append ('/c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            if debug:
                # pass the full pathname to MSVC in debug mode,
                # this allows the debugger to find the source file
                # without asking the user to browse for it
                src = os.path.abspath(src)

            if ext in self._c_extensions:
                input_opt = "/Tc" + src
            elif ext in self._cpp_extensions:
                input_opt = "/Tp" + src
            elif ext in self._rc_extensions:
                # compile .RC to .RES file
                input_opt = src
                output_opt = "/fo" + obj
                try:
                    self.spawn([self.rc] + pp_opts +
                               [output_opt] + [input_opt])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            elif ext in self._mc_extensions:
                # Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.
                h_dir = os.path.dirname(src)
                rc_dir = os.path.dirname(obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn([self.mc] +
                               ['-h', h_dir, '-r', rc_dir] + [src])
                    base, _ = os.path.splitext (os.path.basename (src))
                    rc_file = os.path.join (rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn([self.rc] +
                               ["/fo" + obj] + [rc_file])

                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            else:
                # how to handle this file?
                raise CompileError("Don't know how to compile %s to %s"
                                   % (src, obj))

            output_opt = "/Fo" + obj
            try:
                self.spawn([self.cc] + compile_opts + pp_opts +
                           [input_opt, output_opt] +
                           extra_postargs)
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects


    def create_static_lib(self,
                          objects,
                          output_libname,
                          output_dir=None,
                          debug=0,
                          target_lang=None):

        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname,
                                                output_dir=output_dir)

        if self._need_link(objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass # XXX what goes here?
            try:
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)


    def link(self,
             target_desc,
             objects,
             output_filename,
             output_dir=None,
             libraries=None,
             library_dirs=None,
             runtime_library_dirs=None,
             export_symbols=None,
             debug=0,
             extra_preargs=None,
             extra_postargs=None,
             build_temp=None,
             target_lang=None):

        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs,
                                        runtime_library_dirs)
        (libraries, library_dirs, runtime_library_dirs) = fixed_args

        if runtime_library_dirs:
            self.warn ("I don't know what to do with 'runtime_library_dirs': "
                       + str (runtime_library_dirs))

        lib_opts = gen_lib_options(self,
                                   library_dirs, runtime_library_dirs,
                                   libraries)
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            if target_desc == CCompiler.EXECUTABLE:
                if debug:
                    ldflags = self.ldflags_shared_debug[1:]
                else:
                    ldflags = self.ldflags_shared[1:]
            else:
                if debug:
                    ldflags = self.ldflags_shared_debug
                else:
                    ldflags = self.ldflags_shared

            export_opts = []
            for sym in (export_symbols or []):
                export_opts.append("/EXPORT:" + sym)

            ld_args = (ldflags + lib_opts + export_opts +
                       objects + ['/OUT:' + output_filename])

            # The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            build_temp = os.path.dirname(objects[0])
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename))
                implib_file = os.path.join(
                    build_temp,
                    self.library_filename(dll_name))
                ld_args.append ('/IMPLIB:' + implib_file)

            self.manifest_setup_ldargs(output_filename, build_temp, ld_args)

            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            self.mkpath(os.path.dirname(output_filename))
            try:
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)

            # embed the manifest
            # XXX - this is somewhat fragile - if mt.exe fails, distutils
            # will still consider the DLL up-to-date, but it will not have a
            # manifest.  Maybe we should link to a temp file?  OTOH, that
            # implies a build environment error that shouldn't go undetected.
            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
            if mfinfo is not None:
                mffilename, mfid = mfinfo
                out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
                try:
                    self.spawn(['mt.exe', '-nologo', '-manifest',
                                mffilename, out_arg])
                except DistutilsExecError as msg:
                    raise LinkError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
        # If we need a manifest at all, an embedded manifest is recommended.
        # See MSDN article titled
        # "How to: Embed a Manifest Inside a C/C++ Application"
        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
        # Ask the linker to generate the manifest in the temp dir, so
        # we can check it, and possibly embed it, later.
        temp_manifest = os.path.join(
                build_temp,
                os.path.basename(output_filename) + ".manifest")
        ld_args.append('/MANIFESTFILE:' + temp_manifest)

    def manifest_get_embed_info(self, target_desc, ld_args):
        # If a manifest should be embedded, return a tuple of
        # (manifest_filename, resource_id).  Returns None if no manifest
        # should be embedded.  See http://bugs.python.org/issue7833 for why
        # we want to avoid any manifest for extension modules if we can)
        for arg in ld_args:
            if arg.startswith("/MANIFESTFILE:"):
                temp_manifest = arg.split(":", 1)[1]
                break
        else:
            # no /MANIFESTFILE so nothing to do.
            return None
        if target_desc == CCompiler.EXECUTABLE:
            # by default, executables always get the manifest with the
            # CRT referenced.
            mfid = 1
        else:
            # Extension modules try and avoid any manifest if possible.
            mfid = 2
            temp_manifest = self._remove_visual_c_ref(temp_manifest)
        if temp_manifest is None:
            return None
        return temp_manifest, mfid

    def _remove_visual_c_ref(self, manifest_file):
        try:
            # Remove references to the Visual C runtime, so they will
            # fall through to the Visual C dependency of Python.exe.
            # This way, when installed for a restricted user (e.g.
            # runtimes are not in WinSxS folder, but in Python's own
            # folder), the runtimes do not need to be in every folder
            # with .pyd's.
            # Returns either the filename of the modified manifest or
            # None if no manifest should be embedded.
            manifest_f = open(manifest_file)
            try:
                manifest_buf = manifest_f.read()
            finally:
                manifest_f.close()
            pattern = re.compile(
                r"""|)""",
                re.DOTALL)
            manifest_buf = re.sub(pattern, "", manifest_buf)
            pattern = r"\s*"
            manifest_buf = re.sub(pattern, "", manifest_buf)
            # Now see if any other assemblies are referenced - if not, we
            # don't want a manifest embedded.
            pattern = re.compile(
                r"""|)""", re.DOTALL)
            if re.search(pattern, manifest_buf) is None:
                return None

            manifest_f = open(manifest_file, 'w')
            try:
                manifest_f.write(manifest_buf)
                return manifest_file
            finally:
                manifest_f.close()
        except OSError:
            pass

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "/LIBPATH:" + dir

    def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(
              "don't know how to set runtime library search path for MSVC++")

    def library_option(self, lib):
        return self.library_filename(lib)


    def find_library_file(self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename (name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

    # Helper methods for using the MSVC registry settings

    def find_exe(self, exe):
        """Return path to an MSVC executable program.

        Tries to find the program in several places: first, one of the
        MSVC program search paths from the registry; next, the directories
        in the PATH environment variable.  If any of those work, return an
        absolute path that is known to exist.  If none of them work, just
        return the original program name, 'exe'.
        """
        for p in self.__paths:
            fn = os.path.join(os.path.abspath(p), exe)
            if os.path.isfile(fn):
                return fn

        # didn't find it; try existing path
        for p in os.environ['Path'].split(';'):
            fn = os.path.join(os.path.abspath(p),exe)
            if os.path.isfile(fn):
                return fn

        return exe
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/msvccompiler.py0000644000175100001710000005576400000000000023076 0ustar00runnerdocker"""distutils.msvccompiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)

import sys, os
from distutils.errors import \
     DistutilsExecError, DistutilsPlatformError, \
     CompileError, LibError, LinkError
from distutils.ccompiler import \
     CCompiler, gen_lib_options
from distutils import log

_can_read_reg = False
try:
    import winreg

    _can_read_reg = True
    hkey_mod = winreg

    RegOpenKeyEx = winreg.OpenKeyEx
    RegEnumKey = winreg.EnumKey
    RegEnumValue = winreg.EnumValue
    RegError = winreg.error

except ImportError:
    try:
        import win32api
        import win32con
        _can_read_reg = True
        hkey_mod = win32con

        RegOpenKeyEx = win32api.RegOpenKeyEx
        RegEnumKey = win32api.RegEnumKey
        RegEnumValue = win32api.RegEnumValue
        RegError = win32api.error
    except ImportError:
        log.info("Warning: Can't read registry to find the "
                 "necessary compiler setting\n"
                 "Make sure that Python modules winreg, "
                 "win32api or win32con are installed.")
        pass

if _can_read_reg:
    HKEYS = (hkey_mod.HKEY_USERS,
             hkey_mod.HKEY_CURRENT_USER,
             hkey_mod.HKEY_LOCAL_MACHINE,
             hkey_mod.HKEY_CLASSES_ROOT)

def read_keys(base, key):
    """Return list of registry keys."""
    try:
        handle = RegOpenKeyEx(base, key)
    except RegError:
        return None
    L = []
    i = 0
    while True:
        try:
            k = RegEnumKey(handle, i)
        except RegError:
            break
        L.append(k)
        i += 1
    return L

def read_values(base, key):
    """Return dict of registry keys and values.

    All names are converted to lowercase.
    """
    try:
        handle = RegOpenKeyEx(base, key)
    except RegError:
        return None
    d = {}
    i = 0
    while True:
        try:
            name, value, type = RegEnumValue(handle, i)
        except RegError:
            break
        name = name.lower()
        d[convert_mbcs(name)] = convert_mbcs(value)
        i += 1
    return d

def convert_mbcs(s):
    dec = getattr(s, "decode", None)
    if dec is not None:
        try:
            s = dec("mbcs")
        except UnicodeError:
            pass
    return s

class MacroExpander:
    def __init__(self, version):
        self.macros = {}
        self.load_macros(version)

    def set_macro(self, macro, path, key):
        for base in HKEYS:
            d = read_values(base, path)
            if d:
                self.macros["$(%s)" % macro] = d[key]
                break

    def load_macros(self, version):
        vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version
        self.set_macro("VCInstallDir", vsbase + r"\Setup\VC", "productdir")
        self.set_macro("VSInstallDir", vsbase + r"\Setup\VS", "productdir")
        net = r"Software\Microsoft\.NETFramework"
        self.set_macro("FrameworkDir", net, "installroot")
        try:
            if version > 7.0:
                self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")
            else:
                self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
        except KeyError as exc: #
            raise DistutilsPlatformError(
            """Python was built with Visual Studio 2003;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2003 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")

        p = r"Software\Microsoft\NET Framework Setup\Product"
        for base in HKEYS:
            try:
                h = RegOpenKeyEx(base, p)
            except RegError:
                continue
            key = RegEnumKey(h, 0)
            d = read_values(base, r"%s\%s" % (p, key))
            self.macros["$(FrameworkVersion)"] = d["version"]

    def sub(self, s):
        for k, v in self.macros.items():
            s = s.replace(k, v)
        return s

def get_build_version():
    """Return the version of MSVC that was used to build Python.

    For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    """
    prefix = "MSC v."
    i = sys.version.find(prefix)
    if i == -1:
        return 6
    i = i + len(prefix)
    s, rest = sys.version[i:].split(" ", 1)
    majorVersion = int(s[:-2]) - 6
    if majorVersion >= 13:
        # v13 was skipped and should be v14
        majorVersion += 1
    minorVersion = int(s[2:3]) / 10.0
    # I don't think paths are affected by minor version in version 6
    if majorVersion == 6:
        minorVersion = 0
    if majorVersion >= 6:
        return majorVersion + minorVersion
    # else we don't know what version of the compiler this is
    return None

def get_build_architecture():
    """Return the processor architecture.

    Possible results are "Intel" or "AMD64".
    """

    prefix = " bit ("
    i = sys.version.find(prefix)
    if i == -1:
        return "Intel"
    j = sys.version.find(")", i)
    return sys.version[i+len(prefix):j]

def normalize_and_reduce_paths(paths):
    """Return a list of normalized paths with duplicates removed.

    The current order of paths is maintained.
    """
    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
    reduced_paths = []
    for p in paths:
        np = os.path.normpath(p)
        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
        if np not in reduced_paths:
            reduced_paths.append(np)
    return reduced_paths


class MSVCCompiler(CCompiler) :
    """Concrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class."""

    compiler_type = 'msvc'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']
    _rc_extensions = ['.rc']
    _mc_extensions = ['.mc']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = (_c_extensions + _cpp_extensions +
                      _rc_extensions + _mc_extensions)
    res_extension = '.res'
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

    def __init__(self, verbose=0, dry_run=0, force=0):
        CCompiler.__init__ (self, verbose, dry_run, force)
        self.__version = get_build_version()
        self.__arch = get_build_architecture()
        if self.__arch == "Intel":
            # x86
            if self.__version >= 7:
                self.__root = r"Software\Microsoft\VisualStudio"
                self.__macros = MacroExpander(self.__version)
            else:
                self.__root = r"Software\Microsoft\Devstudio"
            self.__product = "Visual Studio version %s" % self.__version
        else:
            # Win64. Assume this was built with the platform SDK
            self.__product = "Microsoft SDK compiler %s" % (self.__version + 6)

        self.initialized = False

    def initialize(self):
        self.__paths = []
        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
            # Assume that the SDK set up everything alright; don't try to be
            # smarter
            self.cc = "cl.exe"
            self.linker = "link.exe"
            self.lib = "lib.exe"
            self.rc = "rc.exe"
            self.mc = "mc.exe"
        else:
            self.__paths = self.get_msvc_paths("path")

            if len(self.__paths) == 0:
                raise DistutilsPlatformError("Python was built with %s, "
                       "and extensions need to be built with the same "
                       "version of the compiler, but it isn't installed."
                       % self.__product)

            self.cc = self.find_exe("cl.exe")
            self.linker = self.find_exe("link.exe")
            self.lib = self.find_exe("lib.exe")
            self.rc = self.find_exe("rc.exe")   # resource compiler
            self.mc = self.find_exe("mc.exe")   # message compiler
            self.set_path_env_var('lib')
            self.set_path_env_var('include')

        # extend the MSVC path with the current path
        try:
            for p in os.environ['path'].split(';'):
                self.__paths.append(p)
        except KeyError:
            pass
        self.__paths = normalize_and_reduce_paths(self.__paths)
        os.environ['path'] = ";".join(self.__paths)

        self.preprocess_options = None
        if self.__arch == "Intel":
            self.compile_options = [ '/nologo', '/O2', '/MD', '/W3', '/GX' ,
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GX',
                                          '/Z7', '/D_DEBUG']
        else:
            # Win64
            self.compile_options = [ '/nologo', '/O2', '/MD', '/W3', '/GS-' ,
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
                                          '/Z7', '/D_DEBUG']

        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
        if self.__version >= 7:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
                ]
        else:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG'
                ]
        self.ldflags_static = [ '/nologo']

        self.initialized = True

    # -- Worker methods ------------------------------------------------

    def object_filenames(self,
                         source_filenames,
                         strip_dir=0,
                         output_dir=''):
        # Copied from ccompiler.py, extended to return .res as 'object'-file
        # for .rc input file
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            (base, ext) = os.path.splitext (src_name)
            base = os.path.splitdrive(base)[1] # Chop off the drive
            base = base[os.path.isabs(base):]  # If abs, chop off leading /
            if ext not in self.src_extensions:
                # Better to raise an exception instead of silently continuing
                # and later complain about sources and targets having
                # different lengths
                raise CompileError ("Don't know how to compile %s" % src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext in self._rc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            elif ext in self._mc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                                base + self.obj_extension))
        return obj_names


    def compile(self, sources,
                output_dir=None, macros=None, include_dirs=None, debug=0,
                extra_preargs=None, extra_postargs=None, depends=None):

        if not self.initialized:
            self.initialize()
        compile_info = self._setup_compile(output_dir, macros, include_dirs,
                                           sources, depends, extra_postargs)
        macros, objects, extra_postargs, pp_opts, build = compile_info

        compile_opts = extra_preargs or []
        compile_opts.append ('/c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            if debug:
                # pass the full pathname to MSVC in debug mode,
                # this allows the debugger to find the source file
                # without asking the user to browse for it
                src = os.path.abspath(src)

            if ext in self._c_extensions:
                input_opt = "/Tc" + src
            elif ext in self._cpp_extensions:
                input_opt = "/Tp" + src
            elif ext in self._rc_extensions:
                # compile .RC to .RES file
                input_opt = src
                output_opt = "/fo" + obj
                try:
                    self.spawn([self.rc] + pp_opts +
                               [output_opt] + [input_opt])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            elif ext in self._mc_extensions:
                # Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.
                h_dir = os.path.dirname(src)
                rc_dir = os.path.dirname(obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn([self.mc] +
                               ['-h', h_dir, '-r', rc_dir] + [src])
                    base, _ = os.path.splitext (os.path.basename (src))
                    rc_file = os.path.join (rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn([self.rc] +
                               ["/fo" + obj] + [rc_file])

                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            else:
                # how to handle this file?
                raise CompileError("Don't know how to compile %s to %s"
                                   % (src, obj))

            output_opt = "/Fo" + obj
            try:
                self.spawn([self.cc] + compile_opts + pp_opts +
                           [input_opt, output_opt] +
                           extra_postargs)
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects


    def create_static_lib(self,
                          objects,
                          output_libname,
                          output_dir=None,
                          debug=0,
                          target_lang=None):

        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname,
                                                output_dir=output_dir)

        if self._need_link(objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass # XXX what goes here?
            try:
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)


    def link(self,
             target_desc,
             objects,
             output_filename,
             output_dir=None,
             libraries=None,
             library_dirs=None,
             runtime_library_dirs=None,
             export_symbols=None,
             debug=0,
             extra_preargs=None,
             extra_postargs=None,
             build_temp=None,
             target_lang=None):

        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs,
                                        runtime_library_dirs)
        (libraries, library_dirs, runtime_library_dirs) = fixed_args

        if runtime_library_dirs:
            self.warn ("I don't know what to do with 'runtime_library_dirs': "
                       + str (runtime_library_dirs))

        lib_opts = gen_lib_options(self,
                                   library_dirs, runtime_library_dirs,
                                   libraries)
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            if target_desc == CCompiler.EXECUTABLE:
                if debug:
                    ldflags = self.ldflags_shared_debug[1:]
                else:
                    ldflags = self.ldflags_shared[1:]
            else:
                if debug:
                    ldflags = self.ldflags_shared_debug
                else:
                    ldflags = self.ldflags_shared

            export_opts = []
            for sym in (export_symbols or []):
                export_opts.append("/EXPORT:" + sym)

            ld_args = (ldflags + lib_opts + export_opts +
                       objects + ['/OUT:' + output_filename])

            # The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename))
                implib_file = os.path.join(
                    os.path.dirname(objects[0]),
                    self.library_filename(dll_name))
                ld_args.append ('/IMPLIB:' + implib_file)

            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            self.mkpath(os.path.dirname(output_filename))
            try:
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)

        else:
            log.debug("skipping %s (up-to-date)", output_filename)


    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "/LIBPATH:" + dir

    def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(
              "don't know how to set runtime library search path for MSVC++")

    def library_option(self, lib):
        return self.library_filename(lib)


    def find_library_file(self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename (name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

    # Helper methods for using the MSVC registry settings

    def find_exe(self, exe):
        """Return path to an MSVC executable program.

        Tries to find the program in several places: first, one of the
        MSVC program search paths from the registry; next, the directories
        in the PATH environment variable.  If any of those work, return an
        absolute path that is known to exist.  If none of them work, just
        return the original program name, 'exe'.
        """
        for p in self.__paths:
            fn = os.path.join(os.path.abspath(p), exe)
            if os.path.isfile(fn):
                return fn

        # didn't find it; try existing path
        for p in os.environ['Path'].split(';'):
            fn = os.path.join(os.path.abspath(p),exe)
            if os.path.isfile(fn):
                return fn

        return exe

    def get_msvc_paths(self, path, platform='x86'):
        """Get a list of devstudio directories (include, lib or path).

        Return a list of strings.  The list will be empty if unable to
        access the registry or appropriate registry keys not found.
        """
        if not _can_read_reg:
            return []

        path = path + " dirs"
        if self.__version >= 7:
            key = (r"%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories"
                   % (self.__root, self.__version))
        else:
            key = (r"%s\6.0\Build System\Components\Platforms"
                   r"\Win32 (%s)\Directories" % (self.__root, platform))

        for base in HKEYS:
            d = read_values(base, key)
            if d:
                if self.__version >= 7:
                    return self.__macros.sub(d[path]).split(";")
                else:
                    return d[path].split(";")
        # MSVC 6 seems to create the registry entries we need only when
        # the GUI is run.
        if self.__version == 6:
            for base in HKEYS:
                if read_values(base, r"%s\6.0" % self.__root) is not None:
                    self.warn("It seems you have Visual Studio 6 installed, "
                        "but the expected registry settings are not present.\n"
                        "You must at least run the Visual Studio GUI once "
                        "so that these entries are created.")
                    break
        return []

    def set_path_env_var(self, name):
        """Set environment variable 'name' to an MSVC path type value.

        This is equivalent to a SET command prior to execution of spawned
        commands.
        """

        if name == "lib":
            p = self.get_msvc_paths("library")
        else:
            p = self.get_msvc_paths(name)
        if p:
            os.environ[name] = ';'.join(p)


if get_build_version() >= 8.0:
    log.debug("Importing new compiler from distutils.msvc9compiler")
    OldMSVCCompiler = MSVCCompiler
    from distutils.msvc9compiler import MSVCCompiler
    # get_build_architecture not really relevant now we support cross-compile
    from distutils.msvc9compiler import MacroExpander
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/py35compat.py0000644000175100001710000000070700000000000022362 0ustar00runnerdockerimport sys
import subprocess


def __optim_args_from_interpreter_flags():
    """Return a list of command-line arguments reproducing the current
    optimization settings in sys.flags."""
    args = []
    value = sys.flags.optimize
    if value > 0:
        args.append("-" + "O" * value)
    return args


_optim_args_from_interpreter_flags = getattr(
    subprocess,
    "_optim_args_from_interpreter_flags",
    __optim_args_from_interpreter_flags,
)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/py38compat.py0000644000175100001710000000032400000000000022360 0ustar00runnerdockerdef aix_platform(osname, version, release):
    try:
        import _aix_support
        return _aix_support.aix_platform()
    except ImportError:
        pass
    return "%s-%s.%s" % (osname, version, release)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/spawn.py0000644000175100001710000000665200000000000021513 0ustar00runnerdocker"""distutils.spawn

Provides the 'spawn()' function, a front-end to various platform-
specific functions for launching another program in a sub-process.
Also provides the 'find_executable()' to search the path for a given
executable name.
"""

import sys
import os
import subprocess

from distutils.errors import DistutilsPlatformError, DistutilsExecError
from distutils.debug import DEBUG
from distutils import log


def spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None):
    """Run another program, specified as a command list 'cmd', in a new process.

    'cmd' is just the argument list for the new process, ie.
    cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
    There is no way to run a program with a name different from that of its
    executable.

    If 'search_path' is true (the default), the system's executable
    search path will be used to find the program; otherwise, cmd[0]
    must be the exact path to the executable.  If 'dry_run' is true,
    the command will not actually be run.

    Raise DistutilsExecError if running the program fails in any way; just
    return on success.
    """
    # cmd is documented as a list, but just in case some code passes a tuple
    # in, protect our %-formatting code against horrible death
    cmd = list(cmd)

    log.info(subprocess.list2cmdline(cmd))
    if dry_run:
        return

    if search_path:
        executable = find_executable(cmd[0])
        if executable is not None:
            cmd[0] = executable

    env = env if env is not None else dict(os.environ)

    if sys.platform == 'darwin':
        from distutils.util import MACOSX_VERSION_VAR, get_macosx_target_ver
        macosx_target_ver = get_macosx_target_ver()
        if macosx_target_ver:
            env[MACOSX_VERSION_VAR] = macosx_target_ver

    try:
        proc = subprocess.Popen(cmd, env=env)
        proc.wait()
        exitcode = proc.returncode
    except OSError as exc:
        if not DEBUG:
            cmd = cmd[0]
        raise DistutilsExecError(
            "command %r failed: %s" % (cmd, exc.args[-1])) from exc

    if exitcode:
        if not DEBUG:
            cmd = cmd[0]
        raise DistutilsExecError(
              "command %r failed with exit code %s" % (cmd, exitcode))


def find_executable(executable, path=None):
    """Tries to find 'executable' in the directories listed in 'path'.

    A string listing directories separated by 'os.pathsep'; defaults to
    os.environ['PATH'].  Returns the complete filename or None if not found.
    """
    _, ext = os.path.splitext(executable)
    if (sys.platform == 'win32') and (ext != '.exe'):
        executable = executable + '.exe'

    if os.path.isfile(executable):
        return executable

    if path is None:
        path = os.environ.get('PATH', None)
        if path is None:
            try:
                path = os.confstr("CS_PATH")
            except (AttributeError, ValueError):
                # os.confstr() or CS_PATH is not available
                path = os.defpath
        # bpo-35755: Don't use os.defpath if the PATH environment variable is
        # set to an empty string

    # PATH='' doesn't match, whereas PATH=':' looks in the current directory
    if not path:
        return None

    paths = path.split(os.pathsep)
    for p in paths:
        f = os.path.join(p, executable)
        if os.path.isfile(f):
            # the file exists, we have a shot at spawn working
            return f
    return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/sysconfig.py0000644000175100001710000005320700000000000022365 0ustar00runnerdocker"""Provide access to Python's configuration information.  The specific
configuration variables available depend heavily on the platform and
configuration.  The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys().  Additional convenience functions are also
available.

Written by:   Fred L. Drake, Jr.
Email:        
"""

import _imp
import os
import re
import sys

from .errors import DistutilsPlatformError

IS_PYPY = '__pypy__' in sys.builtin_module_names

# These are needed in a couple of spots, so just compute them once.
PREFIX = os.path.normpath(sys.prefix)
EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
BASE_PREFIX = os.path.normpath(sys.base_prefix)
BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)

# Path to the base directory of the project. On Windows the binary may
# live in project/PCbuild/win32 or project/PCbuild/amd64.
# set for cross builds
if "_PYTHON_PROJECT_BASE" in os.environ:
    project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"])
else:
    if sys.executable:
        project_base = os.path.dirname(os.path.abspath(sys.executable))
    else:
        # sys.executable can be empty if argv[0] has been changed and Python is
        # unable to retrieve the real program name
        project_base = os.getcwd()


# python_build: (Boolean) if true, we're either building Python or
# building an extension with an un-installed Python, so we use
# different (hard-wired) directories.
def _is_python_source_dir(d):
    for fn in ("Setup", "Setup.local"):
        if os.path.isfile(os.path.join(d, "Modules", fn)):
            return True
    return False

_sys_home = getattr(sys, '_home', None)

if os.name == 'nt':
    def _fix_pcbuild(d):
        if d and os.path.normcase(d).startswith(
                os.path.normcase(os.path.join(PREFIX, "PCbuild"))):
            return PREFIX
        return d
    project_base = _fix_pcbuild(project_base)
    _sys_home = _fix_pcbuild(_sys_home)

def _python_build():
    if _sys_home:
        return _is_python_source_dir(_sys_home)
    return _is_python_source_dir(project_base)

python_build = _python_build()


# Calculate the build qualifier flags if they are defined.  Adding the flags
# to the include and lib directories only makes sense for an installation, not
# an in-source build.
build_flags = ''
try:
    if not python_build:
        build_flags = sys.abiflags
except AttributeError:
    # It's not a configure-based build, so the sys module doesn't have
    # this attribute, which is fine.
    pass

def get_python_version():
    """Return a string containing the major and minor Python version,
    leaving off the patchlevel.  Sample return values could be '1.5'
    or '2.2'.
    """
    return '%d.%d' % sys.version_info[:2]


def get_python_inc(plat_specific=0, prefix=None):
    """Return the directory containing installed Python header files.

    If 'plat_specific' is false (the default), this is the path to the
    non-platform-specific header files, i.e. Python.h and so on;
    otherwise, this is the path to platform-specific header files
    (namely pyconfig.h).

    If 'prefix' is supplied, use it instead of sys.base_prefix or
    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
    """
    if prefix is None:
        prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
    if os.name == "posix":
        if IS_PYPY and sys.version_info < (3, 8):
            return os.path.join(prefix, 'include')
        if python_build:
            # Assume the executable is in the build directory.  The
            # pyconfig.h file should be in the same directory.  Since
            # the build directory may not be the source directory, we
            # must use "srcdir" from the makefile to find the "Include"
            # directory.
            if plat_specific:
                return _sys_home or project_base
            else:
                incdir = os.path.join(get_config_var('srcdir'), 'Include')
                return os.path.normpath(incdir)
        implementation = 'pypy' if IS_PYPY else 'python'
        python_dir = implementation + get_python_version() + build_flags
        return os.path.join(prefix, "include", python_dir)
    elif os.name == "nt":
        if python_build:
            # Include both the include and PC dir to ensure we can find
            # pyconfig.h
            return (os.path.join(prefix, "include") + os.path.pathsep +
                    os.path.join(prefix, "PC"))
        return os.path.join(prefix, "include")
    else:
        raise DistutilsPlatformError(
            "I don't know where Python installs its C header files "
            "on platform '%s'" % os.name)


# allow this behavior to be monkey-patched. Ref pypa/distutils#2.
def _posix_lib(standard_lib, libpython, early_prefix, prefix):
    if standard_lib:
        return libpython
    else:
        return os.path.join(libpython, "site-packages")


def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
    """Return the directory containing the Python library (standard or
    site additions).

    If 'plat_specific' is true, return the directory containing
    platform-specific modules, i.e. any module from a non-pure-Python
    module distribution; otherwise, return the platform-shared library
    directory.  If 'standard_lib' is true, return the directory
    containing standard Python library modules; otherwise, return the
    directory for site-specific modules.

    If 'prefix' is supplied, use it instead of sys.base_prefix or
    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
    """

    if IS_PYPY and sys.version_info < (3, 8):
        # PyPy-specific schema
        if prefix is None:
            prefix = PREFIX
        if standard_lib:
            return os.path.join(prefix, "lib-python", sys.version[0])
        return os.path.join(prefix, 'site-packages')

    early_prefix = prefix

    if prefix is None:
        if standard_lib:
            prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
        else:
            prefix = plat_specific and EXEC_PREFIX or PREFIX

    if os.name == "posix":
        if plat_specific or standard_lib:
            # Platform-specific modules (any module from a non-pure-Python
            # module distribution) or standard Python library modules.
            libdir = getattr(sys, "platlibdir", "lib")
        else:
            # Pure Python
            libdir = "lib"
        implementation = 'pypy' if IS_PYPY else 'python'
        libpython = os.path.join(prefix, libdir,
                                 implementation + get_python_version())
        return _posix_lib(standard_lib, libpython, early_prefix, prefix)
    elif os.name == "nt":
        if standard_lib:
            return os.path.join(prefix, "Lib")
        else:
            return os.path.join(prefix, "Lib", "site-packages")
    else:
        raise DistutilsPlatformError(
            "I don't know where Python installs its library "
            "on platform '%s'" % os.name)



def customize_compiler(compiler):
    """Do any platform-specific customization of a CCompiler instance.

    Mainly needed on Unix, so we can plug in the information that
    varies across Unices and is stored in Python's Makefile.
    """
    if compiler.compiler_type == "unix":
        if sys.platform == "darwin":
            # Perform first-time customization of compiler-related
            # config vars on OS X now that we know we need a compiler.
            # This is primarily to support Pythons from binary
            # installers.  The kind and paths to build tools on
            # the user system may vary significantly from the system
            # that Python itself was built on.  Also the user OS
            # version and build tools may not support the same set
            # of CPU architectures for universal builds.
            global _config_vars
            # Use get_config_var() to ensure _config_vars is initialized.
            if not get_config_var('CUSTOMIZED_OSX_COMPILER'):
                import _osx_support
                _osx_support.customize_compiler(_config_vars)
                _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'

        (cc, cxx, cflags, ccshared, ldshared, shlib_suffix, ar, ar_flags) = \
            get_config_vars('CC', 'CXX', 'CFLAGS',
                            'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS')

        if 'CC' in os.environ:
            newcc = os.environ['CC']
            if('LDSHARED' not in os.environ
                    and ldshared.startswith(cc)):
                # If CC is overridden, use that as the default
                #       command for LDSHARED as well
                ldshared = newcc + ldshared[len(cc):]
            cc = newcc
        if 'CXX' in os.environ:
            cxx = os.environ['CXX']
        if 'LDSHARED' in os.environ:
            ldshared = os.environ['LDSHARED']
        if 'CPP' in os.environ:
            cpp = os.environ['CPP']
        else:
            cpp = cc + " -E"           # not always
        if 'LDFLAGS' in os.environ:
            ldshared = ldshared + ' ' + os.environ['LDFLAGS']
        if 'CFLAGS' in os.environ:
            cflags = cflags + ' ' + os.environ['CFLAGS']
            ldshared = ldshared + ' ' + os.environ['CFLAGS']
        if 'CPPFLAGS' in os.environ:
            cpp = cpp + ' ' + os.environ['CPPFLAGS']
            cflags = cflags + ' ' + os.environ['CPPFLAGS']
            ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
        if 'AR' in os.environ:
            ar = os.environ['AR']
        if 'ARFLAGS' in os.environ:
            archiver = ar + ' ' + os.environ['ARFLAGS']
        else:
            archiver = ar + ' ' + ar_flags

        cc_cmd = cc + ' ' + cflags
        compiler.set_executables(
            preprocessor=cpp,
            compiler=cc_cmd,
            compiler_so=cc_cmd + ' ' + ccshared,
            compiler_cxx=cxx,
            linker_so=ldshared,
            linker_exe=cc,
            archiver=archiver)

        if 'RANLIB' in os.environ and compiler.executables.get('ranlib', None):
            compiler.set_executables(ranlib=os.environ['RANLIB'])

        compiler.shared_lib_extension = shlib_suffix


def get_config_h_filename():
    """Return full pathname of installed pyconfig.h file."""
    if python_build:
        if os.name == "nt":
            inc_dir = os.path.join(_sys_home or project_base, "PC")
        else:
            inc_dir = _sys_home or project_base
    else:
        inc_dir = get_python_inc(plat_specific=1)

    return os.path.join(inc_dir, 'pyconfig.h')


# Allow this value to be patched by pkgsrc. Ref pypa/distutils#16.
_makefile_tmpl = 'config-{python_ver}{build_flags}{multiarch}'


def get_makefile_filename():
    """Return full pathname of installed Makefile from the Python build."""
    if python_build:
        return os.path.join(_sys_home or project_base, "Makefile")
    lib_dir = get_python_lib(plat_specific=0, standard_lib=1)
    multiarch = (
        '-%s' % sys.implementation._multiarch
        if hasattr(sys.implementation, '_multiarch') else ''
    )
    config_file = _makefile_tmpl.format(
        python_ver=get_python_version(),
        build_flags=build_flags,
        multiarch=multiarch,
    )
    return os.path.join(lib_dir, config_file, 'Makefile')


def parse_config_h(fp, g=None):
    """Parse a config.h-style file.

    A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    if g is None:
        g = {}
    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
    #
    while True:
        line = fp.readline()
        if not line:
            break
        m = define_rx.match(line)
        if m:
            n, v = m.group(1, 2)
            try: v = int(v)
            except ValueError: pass
            g[n] = v
        else:
            m = undef_rx.match(line)
            if m:
                g[m.group(1)] = 0
    return g


# Regexes needed for parsing Makefile (and similar syntaxes,
# like old-style Setup files).
_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")

def parse_makefile(fn, g=None):
    """Parse a Makefile-style file.

    A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    from distutils.text_file import TextFile
    fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1, errors="surrogateescape")

    if g is None:
        g = {}
    done = {}
    notdone = {}

    while True:
        line = fp.readline()
        if line is None: # eof
            break
        m = _variable_rx.match(line)
        if m:
            n, v = m.group(1, 2)
            v = v.strip()
            # `$$' is a literal `$' in make
            tmpv = v.replace('$$', '')

            if "$" in tmpv:
                notdone[n] = v
            else:
                try:
                    v = int(v)
                except ValueError:
                    # insert literal `$'
                    done[n] = v.replace('$$', '$')
                else:
                    done[n] = v

    # Variables with a 'PY_' prefix in the makefile. These need to
    # be made available without that prefix through sysconfig.
    # Special care is needed to ensure that variable expansion works, even
    # if the expansion uses the name without a prefix.
    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')

    # do variable interpolation here
    while notdone:
        for name in list(notdone):
            value = notdone[name]
            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
            if m:
                n = m.group(1)
                found = True
                if n in done:
                    item = str(done[n])
                elif n in notdone:
                    # get it on a subsequent round
                    found = False
                elif n in os.environ:
                    # do it like make: fall back to environment
                    item = os.environ[n]

                elif n in renamed_variables:
                    if name.startswith('PY_') and name[3:] in renamed_variables:
                        item = ""

                    elif 'PY_' + n in notdone:
                        found = False

                    else:
                        item = str(done['PY_' + n])
                else:
                    done[n] = item = ""
                if found:
                    after = value[m.end():]
                    value = value[:m.start()] + item + after
                    if "$" in after:
                        notdone[name] = value
                    else:
                        try: value = int(value)
                        except ValueError:
                            done[name] = value.strip()
                        else:
                            done[name] = value
                        del notdone[name]

                        if name.startswith('PY_') \
                            and name[3:] in renamed_variables:

                            name = name[3:]
                            if name not in done:
                                done[name] = value
            else:
                # bogus variable reference; just drop it since we can't deal
                del notdone[name]

    fp.close()

    # strip spurious spaces
    for k, v in done.items():
        if isinstance(v, str):
            done[k] = v.strip()

    # save the results in the global dictionary
    g.update(done)
    return g


def expand_makefile_vars(s, vars):
    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
    'string' according to 'vars' (a dictionary mapping variable names to
    values).  Variables not present in 'vars' are silently expanded to the
    empty string.  The variable values in 'vars' should not contain further
    variable expansions; if 'vars' is the output of 'parse_makefile()',
    you're fine.  Returns a variable-expanded version of 's'.
    """

    # This algorithm does multiple expansion, so if vars['foo'] contains
    # "${bar}", it will expand ${foo} to ${bar}, and then expand
    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
    # 'parse_makefile()', which takes care of such expansions eagerly,
    # according to make's variable expansion semantics.

    while True:
        m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
        if m:
            (beg, end) = m.span()
            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
        else:
            break
    return s


_config_vars = None


_sysconfig_name_tmpl = '_sysconfigdata_{abi}_{platform}_{multiarch}'


def _init_posix():
    """Initialize the module as appropriate for POSIX systems."""
    # _sysconfigdata is generated at build time, see the sysconfig module
    name = os.environ.get(
        '_PYTHON_SYSCONFIGDATA_NAME',
        _sysconfig_name_tmpl.format(
            abi=sys.abiflags,
            platform=sys.platform,
            multiarch=getattr(sys.implementation, '_multiarch', ''),
        ),
    )
    try:
        _temp = __import__(name, globals(), locals(), ['build_time_vars'], 0)
    except ImportError:
        # Python 3.5 and pypy 7.3.1
        _temp = __import__(
            '_sysconfigdata', globals(), locals(), ['build_time_vars'], 0)
    build_time_vars = _temp.build_time_vars
    global _config_vars
    _config_vars = {}
    _config_vars.update(build_time_vars)


def _init_nt():
    """Initialize the module as appropriate for NT"""
    g = {}
    # set basic install directories
    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)

    # XXX hmmm.. a normal install puts include files here
    g['INCLUDEPY'] = get_python_inc(plat_specific=0)

    g['EXT_SUFFIX'] = _imp.extension_suffixes()[0]
    g['EXE'] = ".exe"
    g['VERSION'] = get_python_version().replace(".", "")
    g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))

    global _config_vars
    _config_vars = g


def get_config_vars(*args):
    """With no arguments, return a dictionary of all configuration
    variables relevant for the current platform.  Generally this includes
    everything needed to build extensions and install both pure modules and
    extensions.  On Unix, this means every variable defined in Python's
    installed Makefile; on Windows it's a much smaller set.

    With arguments, return a list of values that result from looking up
    each argument in the configuration variable dictionary.
    """
    global _config_vars
    if _config_vars is None:
        func = globals().get("_init_" + os.name)
        if func:
            func()
        else:
            _config_vars = {}

        # Normalized versions of prefix and exec_prefix are handy to have;
        # in fact, these are the standard versions used most places in the
        # Distutils.
        _config_vars['prefix'] = PREFIX
        _config_vars['exec_prefix'] = EXEC_PREFIX

        if not IS_PYPY:
            # For backward compatibility, see issue19555
            SO = _config_vars.get('EXT_SUFFIX')
            if SO is not None:
                _config_vars['SO'] = SO

            # Always convert srcdir to an absolute path
            srcdir = _config_vars.get('srcdir', project_base)
            if os.name == 'posix':
                if python_build:
                    # If srcdir is a relative path (typically '.' or '..')
                    # then it should be interpreted relative to the directory
                    # containing Makefile.
                    base = os.path.dirname(get_makefile_filename())
                    srcdir = os.path.join(base, srcdir)
                else:
                    # srcdir is not meaningful since the installation is
                    # spread about the filesystem.  We choose the
                    # directory containing the Makefile since we know it
                    # exists.
                    srcdir = os.path.dirname(get_makefile_filename())
            _config_vars['srcdir'] = os.path.abspath(os.path.normpath(srcdir))

            # Convert srcdir into an absolute path if it appears necessary.
            # Normally it is relative to the build directory.  However, during
            # testing, for example, we might be running a non-installed python
            # from a different directory.
            if python_build and os.name == "posix":
                base = project_base
                if (not os.path.isabs(_config_vars['srcdir']) and
                    base != os.getcwd()):
                    # srcdir is relative and we are not in the same directory
                    # as the executable. Assume executable is in the build
                    # directory and make srcdir absolute.
                    srcdir = os.path.join(base, _config_vars['srcdir'])
                    _config_vars['srcdir'] = os.path.normpath(srcdir)

        # OS X platforms require special customization to handle
        # multi-architecture, multi-os-version installers
        if sys.platform == 'darwin':
            import _osx_support
            _osx_support.customize_config_vars(_config_vars)

    if args:
        vals = []
        for name in args:
            vals.append(_config_vars.get(name))
        return vals
    else:
        return _config_vars

def get_config_var(name):
    """Return the value of a single variable using the dictionary
    returned by 'get_config_vars()'.  Equivalent to
    get_config_vars().get(name)
    """
    if name == 'SO':
        import warnings
        warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2)
    return get_config_vars().get(name)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9346702
setuptools-59.6.0/setuptools/_distutils/tests/0000755000175100001710000000000000000000000021142 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/__init__.py0000644000175100001710000000253000000000000023253 0ustar00runnerdocker"""Test suite for distutils.

This test suite consists of a collection of test modules in the
distutils.tests package.  Each test module has a name starting with
'test' and contains a function test_suite().  The function is expected
to return an initialized unittest.TestSuite instance.

Tests for the command classes in the distutils.command package are
included in distutils.tests as well, instead of using a separate
distutils.command.tests package, since command identification is done
by import rather than matching pre-defined names.

"""

import os
import sys
import unittest
from test.support import run_unittest

from .py38compat import save_restore_warnings_filters


here = os.path.dirname(__file__) or os.curdir


def test_suite():
    suite = unittest.TestSuite()
    for fn in os.listdir(here):
        if fn.startswith("test") and fn.endswith(".py"):
            modname = "distutils.tests." + fn[:-3]
            # bpo-40055: Save/restore warnings filters to leave them unchanged.
            # Importing tests imports docutils which imports pkg_resources
            # which adds a warnings filter.
            with save_restore_warnings_filters():
                __import__(modname)
            module = sys.modules[modname]
            suite.addTest(module.test_suite())
    return suite


if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/py35compat.py0000644000175100001710000000412000000000000023515 0ustar00runnerdocker"""
Backward compatibility support for Python 3.5
"""

import sys
import test.support
import subprocess


# copied from Python 3.9 test.support module
def _missing_compiler_executable(cmd_names=[]):
    """Check if the compiler components used to build the interpreter exist.

    Check for the existence of the compiler executables whose names are listed
    in 'cmd_names' or all the compiler executables when 'cmd_names' is empty
    and return the first missing executable or None when none is found
    missing.

    """
    from distutils import ccompiler, sysconfig, spawn
    compiler = ccompiler.new_compiler()
    sysconfig.customize_compiler(compiler)
    for name in compiler.executables:
        if cmd_names and name not in cmd_names:
            continue
        cmd = getattr(compiler, name)
        if cmd_names:
            assert cmd is not None, \
                    "the '%s' executable is not configured" % name
        elif not cmd:
            continue
        if spawn.find_executable(cmd[0]) is None:
            return cmd[0]


missing_compiler_executable = vars(test.support).setdefault(
    'missing_compiler_executable',
    _missing_compiler_executable,
)


try:
    from test.support import unix_shell
except ImportError:
    # Adapted from Python 3.9 test.support module
    is_android = hasattr(sys, 'getandroidapilevel')
    unix_shell = (
        None if sys.platform == 'win32' else
        '/system/bin/sh' if is_android else
        '/bin/sh'
    )


# copied from Python 3.9 subprocess module
def _optim_args_from_interpreter_flags():
    """Return a list of command-line arguments reproducing the current
    optimization settings in sys.flags."""
    args = []
    value = sys.flags.optimize
    if value > 0:
        args.append('-' + 'O' * value)
    return args


vars(subprocess).setdefault(
    '_optim_args_from_interpreter_flags',
    _optim_args_from_interpreter_flags,
)


def adapt_glob(regex):
    """
    Supply legacy expectation on Python 3.5
    """
    if sys.version_info > (3, 6):
        return regex
    return regex.replace('(?s:', '').replace(r')\Z', r'\Z(?ms)')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/py38compat.py0000644000175100001710000000224100000000000023522 0ustar00runnerdocker# flake8: noqa

import contextlib
import builtins

ModuleNotFoundError = getattr(builtins, 'ModuleNotFoundError', ImportError)

try:
    from test.support.warnings_helper import check_warnings
except (ModuleNotFoundError, ImportError):
    from test.support import check_warnings


try:
    from test.support.os_helper import (
        change_cwd,
        rmtree,
        EnvironmentVarGuard,
        TESTFN,
        unlink,
        skip_unless_symlink,
        temp_dir,
        create_empty_file,
        temp_cwd,
    )
except (ModuleNotFoundError, ImportError):
    from test.support import (
        change_cwd,
        rmtree,
        EnvironmentVarGuard,
        TESTFN,
        unlink,
        skip_unless_symlink,
        temp_dir,
        create_empty_file,
        temp_cwd,
    )


# From Python 3.9
@contextlib.contextmanager
def _save_restore_warnings_filters():
    old_filters = warnings.filters[:]
    try:
        yield
    finally:
        warnings.filters[:] = old_filters


try:
    from test.support.warnings_helper import save_restore_warnings_filters
except (ModuleNotFoundError, ImportError):
    save_restore_warnings_filters = _save_restore_warnings_filters
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/support.py0000644000175100001710000001453600000000000023241 0ustar00runnerdocker"""Support code for distutils test cases."""
import os
import sys
import shutil
import tempfile
import unittest
import sysconfig
from copy import deepcopy

from . import py38compat as os_helper

from distutils import log
from distutils.log import DEBUG, INFO, WARN, ERROR, FATAL
from distutils.core import Distribution


class LoggingSilencer(object):

    def setUp(self):
        super().setUp()
        self.threshold = log.set_threshold(log.FATAL)
        # catching warnings
        # when log will be replaced by logging
        # we won't need such monkey-patch anymore
        self._old_log = log.Log._log
        log.Log._log = self._log
        self.logs = []

    def tearDown(self):
        log.set_threshold(self.threshold)
        log.Log._log = self._old_log
        super().tearDown()

    def _log(self, level, msg, args):
        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
            raise ValueError('%s wrong log level' % str(level))
        if not isinstance(msg, str):
            raise TypeError("msg should be str, not '%.200s'"
                            % (type(msg).__name__))
        self.logs.append((level, msg, args))

    def get_logs(self, *levels):
        return [msg % args for level, msg, args
                in self.logs if level in levels]

    def clear_logs(self):
        self.logs = []


class TempdirManager(object):
    """Mix-in class that handles temporary directories for test cases.

    This is intended to be used with unittest.TestCase.
    """

    def setUp(self):
        super().setUp()
        self.old_cwd = os.getcwd()
        self.tempdirs = []

    def tearDown(self):
        # Restore working dir, for Solaris and derivatives, where rmdir()
        # on the current directory fails.
        os.chdir(self.old_cwd)
        super().tearDown()
        while self.tempdirs:
            tmpdir = self.tempdirs.pop()
            os_helper.rmtree(tmpdir)

    def mkdtemp(self):
        """Create a temporary directory that will be cleaned up.

        Returns the path of the directory.
        """
        d = tempfile.mkdtemp()
        self.tempdirs.append(d)
        return d

    def write_file(self, path, content='xxx'):
        """Writes a file in the given path.


        path can be a string or a sequence.
        """
        if isinstance(path, (list, tuple)):
            path = os.path.join(*path)
        f = open(path, 'w')
        try:
            f.write(content)
        finally:
            f.close()

    def create_dist(self, pkg_name='foo', **kw):
        """Will generate a test environment.

        This function creates:
         - a Distribution instance using keywords
         - a temporary directory with a package structure

        It returns the package directory and the distribution
        instance.
        """
        tmp_dir = self.mkdtemp()
        pkg_dir = os.path.join(tmp_dir, pkg_name)
        os.mkdir(pkg_dir)
        dist = Distribution(attrs=kw)

        return pkg_dir, dist


class DummyCommand:
    """Class to store options for retrieval via set_undefined_options()."""

    def __init__(self, **kwargs):
        for kw, val in kwargs.items():
            setattr(self, kw, val)

    def ensure_finalized(self):
        pass


class EnvironGuard(object):

    def setUp(self):
        super(EnvironGuard, self).setUp()
        self.old_environ = deepcopy(os.environ)

    def tearDown(self):
        for key, value in self.old_environ.items():
            if os.environ.get(key) != value:
                os.environ[key] = value

        for key in tuple(os.environ.keys()):
            if key not in self.old_environ:
                del os.environ[key]

        super(EnvironGuard, self).tearDown()


def copy_xxmodule_c(directory):
    """Helper for tests that need the xxmodule.c source file.

    Example use:

        def test_compile(self):
            copy_xxmodule_c(self.tmpdir)
            self.assertIn('xxmodule.c', os.listdir(self.tmpdir))

    If the source file can be found, it will be copied to *directory*.  If not,
    the test will be skipped.  Errors during copy are not caught.
    """
    filename = _get_xxmodule_path()
    if filename is None:
        raise unittest.SkipTest('cannot find xxmodule.c (test must run in '
                                'the python build dir)')
    shutil.copy(filename, directory)


def _get_xxmodule_path():
    srcdir = sysconfig.get_config_var('srcdir')
    candidates = [
        # use installed copy if available
        os.path.join(os.path.dirname(__file__), 'xxmodule.c'),
        # otherwise try using copy from build directory
        os.path.join(srcdir, 'Modules', 'xxmodule.c'),
        # srcdir mysteriously can be $srcdir/Lib/distutils/tests when
        # this file is run from its parent directory, so walk up the
        # tree to find the real srcdir
        os.path.join(srcdir, '..', '..', '..', 'Modules', 'xxmodule.c'),
    ]
    for path in candidates:
        if os.path.exists(path):
            return path


def fixup_build_ext(cmd):
    """Function needed to make build_ext tests pass.

    When Python was built with --enable-shared on Unix, -L. is not enough to
    find libpython.so, because regrtest runs in a tempdir, not in the
    source directory where the .so lives.

    When Python was built with in debug mode on Windows, build_ext commands
    need their debug attribute set, and it is not done automatically for
    some reason.

    This function handles both of these things.  Example use:

        cmd = build_ext(dist)
        support.fixup_build_ext(cmd)
        cmd.ensure_finalized()

    Unlike most other Unix platforms, Mac OS X embeds absolute paths
    to shared libraries into executables, so the fixup is not needed there.
    """
    if os.name == 'nt':
        cmd.debug = sys.executable.endswith('_d.exe')
    elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
        # To further add to the shared builds fun on Unix, we can't just add
        # library_dirs to the Extension() instance because that doesn't get
        # plumbed through to the final compiler command.
        runshared = sysconfig.get_config_var('RUNSHARED')
        if runshared is None:
            cmd.library_dirs = ['.']
        else:
            if sys.platform == 'darwin':
                cmd.library_dirs = []
            else:
                name, equals, value = runshared.partition('=')
                cmd.library_dirs = [d for d in value.split(os.pathsep) if d]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_archive_util.py0000644000175100001710000003401400000000000025233 0ustar00runnerdocker# -*- coding: utf-8 -*-
"""Tests for distutils.archive_util."""
import unittest
import os
import sys
import tarfile
from os.path import splitdrive
import warnings

from distutils import archive_util
from distutils.archive_util import (check_archive_formats, make_tarball,
                                    make_zipfile, make_archive,
                                    ARCHIVE_FORMATS)
from distutils.spawn import find_executable, spawn
from distutils.tests import support
from test.support import run_unittest, patch

from .py38compat import change_cwd
from .py38compat import check_warnings

try:
    import grp
    import pwd
    UID_GID_SUPPORT = True
except ImportError:
    UID_GID_SUPPORT = False

try:
    import zipfile
    ZIP_SUPPORT = True
except ImportError:
    ZIP_SUPPORT = find_executable('zip')

try:
    import zlib
    ZLIB_SUPPORT = True
except ImportError:
    ZLIB_SUPPORT = False

try:
    import bz2
except ImportError:
    bz2 = None

try:
    import lzma
except ImportError:
    lzma = None

def can_fs_encode(filename):
    """
    Return True if the filename can be saved in the file system.
    """
    if os.path.supports_unicode_filenames:
        return True
    try:
        filename.encode(sys.getfilesystemencoding())
    except UnicodeEncodeError:
        return False
    return True


class ArchiveUtilTestCase(support.TempdirManager,
                          support.LoggingSilencer,
                          unittest.TestCase):

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_make_tarball(self, name='archive'):
        # creating something to tar
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, name, '.tar.gz')
        # trying an uncompressed one
        self._make_tarball(tmpdir, name, '.tar', compress=None)

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_make_tarball_gzip(self):
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, 'archive', '.tar.gz', compress='gzip')

    @unittest.skipUnless(bz2, 'Need bz2 support to run')
    def test_make_tarball_bzip2(self):
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, 'archive', '.tar.bz2', compress='bzip2')

    @unittest.skipUnless(lzma, 'Need lzma support to run')
    def test_make_tarball_xz(self):
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, 'archive', '.tar.xz', compress='xz')

    @unittest.skipUnless(can_fs_encode('Ã¥rchiv'),
        'File system cannot handle this filename')
    def test_make_tarball_latin1(self):
        """
        Mirror test_make_tarball, except filename contains latin characters.
        """
        self.test_make_tarball('Ã¥rchiv') # note this isn't a real word

    @unittest.skipUnless(can_fs_encode('ã®ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–'),
        'File system cannot handle this filename')
    def test_make_tarball_extended(self):
        """
        Mirror test_make_tarball, except filename contains extended
        characters outside the latin charset.
        """
        self.test_make_tarball('ã®ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–') # japanese for archive

    def _make_tarball(self, tmpdir, target_name, suffix, **kwargs):
        tmpdir2 = self.mkdtemp()
        unittest.skipUnless(splitdrive(tmpdir)[0] == splitdrive(tmpdir2)[0],
                            "source and target should be on same drive")

        base_name = os.path.join(tmpdir2, target_name)

        # working with relative paths to avoid tar warnings
        with change_cwd(tmpdir):
            make_tarball(splitdrive(base_name)[1], 'dist', **kwargs)

        # check if the compressed tarball was created
        tarball = base_name + suffix
        self.assertTrue(os.path.exists(tarball))
        self.assertEqual(self._tarinfo(tarball), self._created_files)

    def _tarinfo(self, path):
        tar = tarfile.open(path)
        try:
            names = tar.getnames()
            names.sort()
            return names
        finally:
            tar.close()

    _zip_created_files = ['dist/', 'dist/file1', 'dist/file2',
                          'dist/sub/', 'dist/sub/file3', 'dist/sub2/']
    _created_files = [p.rstrip('/') for p in _zip_created_files]

    def _create_files(self):
        # creating something to tar
        tmpdir = self.mkdtemp()
        dist = os.path.join(tmpdir, 'dist')
        os.mkdir(dist)
        self.write_file([dist, 'file1'], 'xxx')
        self.write_file([dist, 'file2'], 'xxx')
        os.mkdir(os.path.join(dist, 'sub'))
        self.write_file([dist, 'sub', 'file3'], 'xxx')
        os.mkdir(os.path.join(dist, 'sub2'))
        return tmpdir

    @unittest.skipUnless(find_executable('tar') and find_executable('gzip')
                         and ZLIB_SUPPORT,
                         'Need the tar, gzip and zlib command to run')
    def test_tarfile_vs_tar(self):
        tmpdir =  self._create_files()
        tmpdir2 = self.mkdtemp()
        base_name = os.path.join(tmpdir2, 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(base_name, 'dist')
        finally:
            os.chdir(old_dir)

        # check if the compressed tarball was created
        tarball = base_name + '.tar.gz'
        self.assertTrue(os.path.exists(tarball))

        # now create another tarball using `tar`
        tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
        tar_cmd = ['tar', '-cf', 'archive2.tar', 'dist']
        gzip_cmd = ['gzip', '-f', '-9', 'archive2.tar']
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            spawn(tar_cmd)
            spawn(gzip_cmd)
        finally:
            os.chdir(old_dir)

        self.assertTrue(os.path.exists(tarball2))
        # let's compare both tarballs
        self.assertEqual(self._tarinfo(tarball), self._created_files)
        self.assertEqual(self._tarinfo(tarball2), self._created_files)

        # trying an uncompressed one
        base_name = os.path.join(tmpdir2, 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(base_name, 'dist', compress=None)
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar'
        self.assertTrue(os.path.exists(tarball))

        # now for a dry_run
        base_name = os.path.join(tmpdir2, 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(base_name, 'dist', compress=None, dry_run=True)
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar'
        self.assertTrue(os.path.exists(tarball))

    @unittest.skipUnless(find_executable('compress'),
                         'The compress program is required')
    def test_compress_deprecated(self):
        tmpdir =  self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')

        # using compress and testing the PendingDeprecationWarning
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            with check_warnings() as w:
                warnings.simplefilter("always")
                make_tarball(base_name, 'dist', compress='compress')
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar.Z'
        self.assertTrue(os.path.exists(tarball))
        self.assertEqual(len(w.warnings), 1)

        # same test with dry_run
        os.remove(tarball)
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            with check_warnings() as w:
                warnings.simplefilter("always")
                make_tarball(base_name, 'dist', compress='compress',
                             dry_run=True)
        finally:
            os.chdir(old_dir)
        self.assertFalse(os.path.exists(tarball))
        self.assertEqual(len(w.warnings), 1)

    @unittest.skipUnless(ZIP_SUPPORT and ZLIB_SUPPORT,
                         'Need zip and zlib support to run')
    def test_make_zipfile(self):
        # creating something to tar
        tmpdir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        with change_cwd(tmpdir):
            make_zipfile(base_name, 'dist')

        # check if the compressed tarball was created
        tarball = base_name + '.zip'
        self.assertTrue(os.path.exists(tarball))
        with zipfile.ZipFile(tarball) as zf:
            self.assertEqual(sorted(zf.namelist()), self._zip_created_files)

    @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
    def test_make_zipfile_no_zlib(self):
        patch(self, archive_util.zipfile, 'zlib', None)  # force zlib ImportError

        called = []
        zipfile_class = zipfile.ZipFile
        def fake_zipfile(*a, **kw):
            if kw.get('compression', None) == zipfile.ZIP_STORED:
                called.append((a, kw))
            return zipfile_class(*a, **kw)

        patch(self, archive_util.zipfile, 'ZipFile', fake_zipfile)

        # create something to tar and compress
        tmpdir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        with change_cwd(tmpdir):
            make_zipfile(base_name, 'dist')

        tarball = base_name + '.zip'
        self.assertEqual(called,
                         [((tarball, "w"), {'compression': zipfile.ZIP_STORED})])
        self.assertTrue(os.path.exists(tarball))
        with zipfile.ZipFile(tarball) as zf:
            self.assertEqual(sorted(zf.namelist()), self._zip_created_files)

    def test_check_archive_formats(self):
        self.assertEqual(check_archive_formats(['gztar', 'xxx', 'zip']),
                         'xxx')
        self.assertIsNone(check_archive_formats(['gztar', 'bztar', 'xztar',
                                                 'ztar', 'tar', 'zip']))

    def test_make_archive(self):
        tmpdir = self.mkdtemp()
        base_name = os.path.join(tmpdir, 'archive')
        self.assertRaises(ValueError, make_archive, base_name, 'xxx')

    def test_make_archive_cwd(self):
        current_dir = os.getcwd()
        def _breaks(*args, **kw):
            raise RuntimeError()
        ARCHIVE_FORMATS['xxx'] = (_breaks, [], 'xxx file')
        try:
            try:
                make_archive('xxx', 'xxx', root_dir=self.mkdtemp())
            except:
                pass
            self.assertEqual(os.getcwd(), current_dir)
        finally:
            del ARCHIVE_FORMATS['xxx']

    def test_make_archive_tar(self):
        base_dir =  self._create_files()
        base_name = os.path.join(self.mkdtemp() , 'archive')
        res = make_archive(base_name, 'tar', base_dir, 'dist')
        self.assertTrue(os.path.exists(res))
        self.assertEqual(os.path.basename(res), 'archive.tar')
        self.assertEqual(self._tarinfo(res), self._created_files)

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_make_archive_gztar(self):
        base_dir =  self._create_files()
        base_name = os.path.join(self.mkdtemp() , 'archive')
        res = make_archive(base_name, 'gztar', base_dir, 'dist')
        self.assertTrue(os.path.exists(res))
        self.assertEqual(os.path.basename(res), 'archive.tar.gz')
        self.assertEqual(self._tarinfo(res), self._created_files)

    @unittest.skipUnless(bz2, 'Need bz2 support to run')
    def test_make_archive_bztar(self):
        base_dir =  self._create_files()
        base_name = os.path.join(self.mkdtemp() , 'archive')
        res = make_archive(base_name, 'bztar', base_dir, 'dist')
        self.assertTrue(os.path.exists(res))
        self.assertEqual(os.path.basename(res), 'archive.tar.bz2')
        self.assertEqual(self._tarinfo(res), self._created_files)

    @unittest.skipUnless(lzma, 'Need xz support to run')
    def test_make_archive_xztar(self):
        base_dir =  self._create_files()
        base_name = os.path.join(self.mkdtemp() , 'archive')
        res = make_archive(base_name, 'xztar', base_dir, 'dist')
        self.assertTrue(os.path.exists(res))
        self.assertEqual(os.path.basename(res), 'archive.tar.xz')
        self.assertEqual(self._tarinfo(res), self._created_files)

    def test_make_archive_owner_group(self):
        # testing make_archive with owner and group, with various combinations
        # this works even if there's not gid/uid support
        if UID_GID_SUPPORT:
            group = grp.getgrgid(0)[0]
            owner = pwd.getpwuid(0)[0]
        else:
            group = owner = 'root'

        base_dir =  self._create_files()
        root_dir = self.mkdtemp()
        base_name = os.path.join(self.mkdtemp() , 'archive')
        res = make_archive(base_name, 'zip', root_dir, base_dir, owner=owner,
                           group=group)
        self.assertTrue(os.path.exists(res))

        res = make_archive(base_name, 'zip', root_dir, base_dir)
        self.assertTrue(os.path.exists(res))

        res = make_archive(base_name, 'tar', root_dir, base_dir,
                           owner=owner, group=group)
        self.assertTrue(os.path.exists(res))

        res = make_archive(base_name, 'tar', root_dir, base_dir,
                           owner='kjhkjhkjg', group='oihohoh')
        self.assertTrue(os.path.exists(res))

    @unittest.skipUnless(ZLIB_SUPPORT, "Requires zlib")
    @unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support")
    def test_tarfile_root_owner(self):
        tmpdir =  self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        group = grp.getgrgid(0)[0]
        owner = pwd.getpwuid(0)[0]
        try:
            archive_name = make_tarball(base_name, 'dist', compress=None,
                                        owner=owner, group=group)
        finally:
            os.chdir(old_dir)

        # check if the compressed tarball was created
        self.assertTrue(os.path.exists(archive_name))

        # now checks the rights
        archive = tarfile.open(archive_name)
        try:
            for member in archive.getmembers():
                self.assertEqual(member.uid, 0)
                self.assertEqual(member.gid, 0)
        finally:
            archive.close()

def test_suite():
    return unittest.makeSuite(ArchiveUtilTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_bdist.py0000644000175100001710000000354500000000000023667 0ustar00runnerdocker"""Tests for distutils.command.bdist."""
import os
import unittest
from test.support import run_unittest
import warnings

from distutils.command.bdist import bdist
from distutils.tests import support


class BuildTestCase(support.TempdirManager,
                    unittest.TestCase):

    def test_formats(self):
        # let's create a command and make sure
        # we can set the format
        dist = self.create_dist()[1]
        cmd = bdist(dist)
        cmd.formats = ['msi']
        cmd.ensure_finalized()
        self.assertEqual(cmd.formats, ['msi'])

        # what formats does bdist offer?
        formats = ['bztar', 'gztar', 'msi', 'rpm', 'tar',
                   'wininst', 'xztar', 'zip', 'ztar']
        found = sorted(cmd.format_command)
        self.assertEqual(found, formats)

    def test_skip_build(self):
        # bug #10946: bdist --skip-build should trickle down to subcommands
        dist = self.create_dist()[1]
        cmd = bdist(dist)
        cmd.skip_build = 1
        cmd.ensure_finalized()
        dist.command_obj['bdist'] = cmd

        names = ['bdist_dumb', 'bdist_wininst']  # bdist_rpm does not support --skip-build
        if os.name == 'nt':
            names.append('bdist_msi')

        for name in names:
            with warnings.catch_warnings():
                warnings.filterwarnings('ignore', 'bdist_wininst command is deprecated',
                                        DeprecationWarning)
                subcmd = cmd.get_finalized_command(name)
            if getattr(subcmd, '_unsupported', False):
                # command is not supported on this build
                continue
            self.assertTrue(subcmd.skip_build,
                            '%s should take --skip-build from bdist' % name)


def test_suite():
    return unittest.makeSuite(BuildTestCase)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_bdist_dumb.py0000644000175100001710000000553100000000000024673 0ustar00runnerdocker"""Tests for distutils.command.bdist_dumb."""

import os
import sys
import zipfile
import unittest
from test.support import run_unittest

from distutils.core import Distribution
from distutils.command.bdist_dumb import bdist_dumb
from distutils.tests import support

SETUP_PY = """\
from distutils.core import setup
import foo

setup(name='foo', version='0.1', py_modules=['foo'],
      url='xxx', author='xxx', author_email='xxx')

"""

try:
    import zlib
    ZLIB_SUPPORT = True
except ImportError:
    ZLIB_SUPPORT = False


class BuildDumbTestCase(support.TempdirManager,
                        support.LoggingSilencer,
                        support.EnvironGuard,
                        unittest.TestCase):

    def setUp(self):
        super(BuildDumbTestCase, self).setUp()
        self.old_location = os.getcwd()
        self.old_sys_argv = sys.argv, sys.argv[:]

    def tearDown(self):
        os.chdir(self.old_location)
        sys.argv = self.old_sys_argv[0]
        sys.argv[:] = self.old_sys_argv[1]
        super(BuildDumbTestCase, self).tearDown()

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_simple_built(self):

        # let's create a simple package
        tmp_dir = self.mkdtemp()
        pkg_dir = os.path.join(tmp_dir, 'foo')
        os.mkdir(pkg_dir)
        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
        self.write_file((pkg_dir, 'foo.py'), '#')
        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
        self.write_file((pkg_dir, 'README'), '')

        dist = Distribution({'name': 'foo', 'version': '0.1',
                             'py_modules': ['foo'],
                             'url': 'xxx', 'author': 'xxx',
                             'author_email': 'xxx'})
        dist.script_name = 'setup.py'
        os.chdir(pkg_dir)

        sys.argv = ['setup.py']
        cmd = bdist_dumb(dist)

        # so the output is the same no matter
        # what is the platform
        cmd.format = 'zip'

        cmd.ensure_finalized()
        cmd.run()

        # see what we have
        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
        base = "%s.%s.zip" % (dist.get_fullname(), cmd.plat_name)

        self.assertEqual(dist_created, [base])

        # now let's check what we have in the zip file
        fp = zipfile.ZipFile(os.path.join('dist', base))
        try:
            contents = fp.namelist()
        finally:
            fp.close()

        contents = sorted(filter(None, map(os.path.basename, contents)))
        wanted = ['foo-0.1-py%s.%s.egg-info' % sys.version_info[:2], 'foo.py']
        if not sys.dont_write_bytecode:
            wanted.append('foo.%s.pyc' % sys.implementation.cache_tag)
        self.assertEqual(contents, sorted(wanted))

def test_suite():
    return unittest.makeSuite(BuildDumbTestCase)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_bdist_msi.py0000644000175100001710000000147300000000000024535 0ustar00runnerdocker"""Tests for distutils.command.bdist_msi."""
import sys
import unittest
from test.support import run_unittest
from distutils.tests import support

from .py38compat import check_warnings


@unittest.skipUnless(sys.platform == 'win32', 'these tests require Windows')
class BDistMSITestCase(support.TempdirManager,
                       support.LoggingSilencer,
                       unittest.TestCase):

    def test_minimal(self):
        # minimal test XXX need more tests
        from distutils.command.bdist_msi import bdist_msi
        project_dir, dist = self.create_dist()
        with check_warnings(("", DeprecationWarning)):
            cmd = bdist_msi(dist)
        cmd.ensure_finalized()


def test_suite():
    return unittest.makeSuite(BDistMSITestCase)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_bdist_rpm.py0000644000175100001710000001162000000000000024536 0ustar00runnerdocker"""Tests for distutils.command.bdist_rpm."""

import unittest
import sys
import os
from test.support import run_unittest, requires_zlib

from distutils.core import Distribution
from distutils.command.bdist_rpm import bdist_rpm
from distutils.tests import support
from distutils.spawn import find_executable

SETUP_PY = """\
from distutils.core import setup
import foo

setup(name='foo', version='0.1', py_modules=['foo'],
      url='xxx', author='xxx', author_email='xxx')

"""

class BuildRpmTestCase(support.TempdirManager,
                       support.EnvironGuard,
                       support.LoggingSilencer,
                       unittest.TestCase):

    def setUp(self):
        try:
            sys.executable.encode("UTF-8")
        except UnicodeEncodeError:
            raise unittest.SkipTest("sys.executable is not encodable to UTF-8")

        super(BuildRpmTestCase, self).setUp()
        self.old_location = os.getcwd()
        self.old_sys_argv = sys.argv, sys.argv[:]

    def tearDown(self):
        os.chdir(self.old_location)
        sys.argv = self.old_sys_argv[0]
        sys.argv[:] = self.old_sys_argv[1]
        super(BuildRpmTestCase, self).tearDown()

    # XXX I am unable yet to make this test work without
    # spurious sdtout/stderr output under Mac OS X
    @unittest.skipUnless(sys.platform.startswith('linux'),
                         'spurious sdtout/stderr output under Mac OS X')
    @requires_zlib
    @unittest.skipIf(find_executable('rpm') is None,
                     'the rpm command is not found')
    @unittest.skipIf(find_executable('rpmbuild') is None,
                     'the rpmbuild command is not found')
    def test_quiet(self):
        # let's create a package
        tmp_dir = self.mkdtemp()
        os.environ['HOME'] = tmp_dir   # to confine dir '.rpmdb' creation
        pkg_dir = os.path.join(tmp_dir, 'foo')
        os.mkdir(pkg_dir)
        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
        self.write_file((pkg_dir, 'foo.py'), '#')
        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
        self.write_file((pkg_dir, 'README'), '')

        dist = Distribution({'name': 'foo', 'version': '0.1',
                             'py_modules': ['foo'],
                             'url': 'xxx', 'author': 'xxx',
                             'author_email': 'xxx'})
        dist.script_name = 'setup.py'
        os.chdir(pkg_dir)

        sys.argv = ['setup.py']
        cmd = bdist_rpm(dist)
        cmd.fix_python = True

        # running in quiet mode
        cmd.quiet = 1
        cmd.ensure_finalized()
        cmd.run()

        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
        self.assertIn('foo-0.1-1.noarch.rpm', dist_created)

        # bug #2945: upload ignores bdist_rpm files
        self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm'), dist.dist_files)
        self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm'), dist.dist_files)

    # XXX I am unable yet to make this test work without
    # spurious sdtout/stderr output under Mac OS X
    @unittest.skipUnless(sys.platform.startswith('linux'),
                         'spurious sdtout/stderr output under Mac OS X')
    @requires_zlib
    # http://bugs.python.org/issue1533164
    @unittest.skipIf(find_executable('rpm') is None,
                     'the rpm command is not found')
    @unittest.skipIf(find_executable('rpmbuild') is None,
                     'the rpmbuild command is not found')
    def test_no_optimize_flag(self):
        # let's create a package that breaks bdist_rpm
        tmp_dir = self.mkdtemp()
        os.environ['HOME'] = tmp_dir   # to confine dir '.rpmdb' creation
        pkg_dir = os.path.join(tmp_dir, 'foo')
        os.mkdir(pkg_dir)
        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
        self.write_file((pkg_dir, 'foo.py'), '#')
        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
        self.write_file((pkg_dir, 'README'), '')

        dist = Distribution({'name': 'foo', 'version': '0.1',
                             'py_modules': ['foo'],
                             'url': 'xxx', 'author': 'xxx',
                             'author_email': 'xxx'})
        dist.script_name = 'setup.py'
        os.chdir(pkg_dir)

        sys.argv = ['setup.py']
        cmd = bdist_rpm(dist)
        cmd.fix_python = True

        cmd.quiet = 1
        cmd.ensure_finalized()
        cmd.run()

        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
        self.assertIn('foo-0.1-1.noarch.rpm', dist_created)

        # bug #2945: upload ignores bdist_rpm files
        self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm'), dist.dist_files)
        self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm'), dist.dist_files)

        os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm'))

def test_suite():
    return unittest.makeSuite(BuildRpmTestCase)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_bdist_wininst.py0000644000175100001710000000260600000000000025437 0ustar00runnerdocker"""Tests for distutils.command.bdist_wininst."""
import sys
import platform
import unittest
from test.support import run_unittest

from .py38compat import check_warnings

from distutils.command.bdist_wininst import bdist_wininst
from distutils.tests import support

@unittest.skipIf(sys.platform == 'win32' and platform.machine() == 'ARM64',
    'bdist_wininst is not supported in this install')
@unittest.skipIf(getattr(bdist_wininst, '_unsupported', False),
    'bdist_wininst is not supported in this install')
class BuildWinInstTestCase(support.TempdirManager,
                           support.LoggingSilencer,
                           unittest.TestCase):

    def test_get_exe_bytes(self):

        # issue5731: command was broken on non-windows platforms
        # this test makes sure it works now for every platform
        # let's create a command
        pkg_pth, dist = self.create_dist()
        with check_warnings(("", DeprecationWarning)):
            cmd = bdist_wininst(dist)
        cmd.ensure_finalized()

        # let's run the code that finds the right wininst*.exe file
        # and make sure it finds it and returns its content
        # no matter what platform we have
        exe_file = cmd.get_exe_bytes()
        self.assertGreater(len(exe_file), 10)

def test_suite():
    return unittest.makeSuite(BuildWinInstTestCase)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_build.py0000644000175100001710000000365500000000000023663 0ustar00runnerdocker"""Tests for distutils.command.build."""
import unittest
import os
import sys
from test.support import run_unittest

from distutils.command.build import build
from distutils.tests import support
from sysconfig import get_platform

class BuildTestCase(support.TempdirManager,
                    support.LoggingSilencer,
                    unittest.TestCase):

    def test_finalize_options(self):
        pkg_dir, dist = self.create_dist()
        cmd = build(dist)
        cmd.finalize_options()

        # if not specified, plat_name gets the current platform
        self.assertEqual(cmd.plat_name, get_platform())

        # build_purelib is build + lib
        wanted = os.path.join(cmd.build_base, 'lib')
        self.assertEqual(cmd.build_purelib, wanted)

        # build_platlib is 'build/lib.platform-x.x[-pydebug]'
        # examples:
        #   build/lib.macosx-10.3-i386-2.7
        plat_spec = '.%s-%d.%d' % (cmd.plat_name, *sys.version_info[:2])
        if hasattr(sys, 'gettotalrefcount'):
            self.assertTrue(cmd.build_platlib.endswith('-pydebug'))
            plat_spec += '-pydebug'
        wanted = os.path.join(cmd.build_base, 'lib' + plat_spec)
        self.assertEqual(cmd.build_platlib, wanted)

        # by default, build_lib = build_purelib
        self.assertEqual(cmd.build_lib, cmd.build_purelib)

        # build_temp is build/temp.
        wanted = os.path.join(cmd.build_base, 'temp' + plat_spec)
        self.assertEqual(cmd.build_temp, wanted)

        # build_scripts is build/scripts-x.x
        wanted = os.path.join(cmd.build_base,
                              'scripts-%d.%d' % sys.version_info[:2])
        self.assertEqual(cmd.build_scripts, wanted)

        # executable is os.path.normpath(sys.executable)
        self.assertEqual(cmd.executable, os.path.normpath(sys.executable))

def test_suite():
    return unittest.makeSuite(BuildTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_build_clib.py0000644000175100001710000001105700000000000024647 0ustar00runnerdocker"""Tests for distutils.command.build_clib."""
import unittest
import os
import sys

from test.support import run_unittest

from .py35compat import missing_compiler_executable

from distutils.command.build_clib import build_clib
from distutils.errors import DistutilsSetupError
from distutils.tests import support

class BuildCLibTestCase(support.TempdirManager,
                        support.LoggingSilencer,
                        unittest.TestCase):

    def test_check_library_dist(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # 'libraries' option must be a list
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, 'foo')

        # each element of 'libraries' must a 2-tuple
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          ['foo1', 'foo2'])

        # first element of each tuple in 'libraries'
        # must be a string (the library name)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [(1, 'foo1'), ('name', 'foo2')])

        # library name may not contain directory separators
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [('name', 'foo1'),
                           ('another/name', 'foo2')])

        # second element of each tuple must be a dictionary (build info)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [('name', {}),
                           ('another', 'foo2')])

        # those work
        libs = [('name', {}), ('name', {'ok': 'good'})]
        cmd.check_library_list(libs)

    def test_get_source_files(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # "in 'libraries' option 'sources' must be present and must be
        # a list of source filenames
        cmd.libraries = [('name', {})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [('name', {'sources': 1})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [('name', {'sources': ['a', 'b']})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b'])

        cmd.libraries = [('name', {'sources': ('a', 'b')})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b'])

        cmd.libraries = [('name', {'sources': ('a', 'b')}),
                         ('name2', {'sources': ['c', 'd']})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd'])

    def test_build_libraries(self):

        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)
        class FakeCompiler:
            def compile(*args, **kw):
                pass
            create_static_lib = compile

        cmd.compiler = FakeCompiler()

        # build_libraries is also doing a bit of typo checking
        lib = [('name', {'sources': 'notvalid'})]
        self.assertRaises(DistutilsSetupError, cmd.build_libraries, lib)

        lib = [('name', {'sources': list()})]
        cmd.build_libraries(lib)

        lib = [('name', {'sources': tuple()})]
        cmd.build_libraries(lib)

    def test_finalize_options(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        cmd.include_dirs = 'one-dir'
        cmd.finalize_options()
        self.assertEqual(cmd.include_dirs, ['one-dir'])

        cmd.include_dirs = None
        cmd.finalize_options()
        self.assertEqual(cmd.include_dirs, [])

        cmd.distribution.libraries = 'WONTWORK'
        self.assertRaises(DistutilsSetupError, cmd.finalize_options)

    @unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]

        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp

        # Before we run the command, we want to make sure
        # all commands are present on the system.
        ccmd = missing_compiler_executable()
        if ccmd is not None:
            self.skipTest('The %r command is not found' % ccmd)

        # this should work
        cmd.run()

        # let's check the result
        self.assertIn('libfoo.a', os.listdir(build_temp))

def test_suite():
    return unittest.makeSuite(BuildCLibTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_build_ext.py0000644000175100001710000005003200000000000024532 0ustar00runnerdockerimport sys
import os
from io import StringIO
import textwrap

from distutils.core import Distribution
from distutils.command.build_ext import build_ext
from distutils import sysconfig
from distutils.tests.support import (TempdirManager, LoggingSilencer,
                                     copy_xxmodule_c, fixup_build_ext)
from distutils.extension import Extension
from distutils.errors import (
    CompileError, DistutilsPlatformError, DistutilsSetupError,
    UnknownFileError)

import unittest
from test import support
from . import py38compat as os_helper
from test.support.script_helper import assert_python_ok

# http://bugs.python.org/issue4373
# Don't load the xx module more than once.
ALREADY_TESTED = False


class BuildExtTestCase(TempdirManager,
                       LoggingSilencer,
                       unittest.TestCase):
    def setUp(self):
        # Create a simple test environment
        super(BuildExtTestCase, self).setUp()
        self.tmp_dir = self.mkdtemp()
        import site
        self.old_user_base = site.USER_BASE
        site.USER_BASE = self.mkdtemp()
        from distutils.command import build_ext
        build_ext.USER_BASE = site.USER_BASE

        # bpo-30132: On Windows, a .pdb file may be created in the current
        # working directory. Create a temporary working directory to cleanup
        # everything at the end of the test.
        change_cwd = os_helper.change_cwd(self.tmp_dir)
        change_cwd.__enter__()
        self.addCleanup(change_cwd.__exit__, None, None, None)

    def tearDown(self):
        import site
        site.USER_BASE = self.old_user_base
        from distutils.command import build_ext
        build_ext.USER_BASE = self.old_user_base
        super(BuildExtTestCase, self).tearDown()

    def build_ext(self, *args, **kwargs):
        return build_ext(*args, **kwargs)

    def test_build_ext(self):
        cmd = support.missing_compiler_executable()
        if cmd is not None:
            self.skipTest('The %r command is not found' % cmd)
        global ALREADY_TESTED
        copy_xxmodule_c(self.tmp_dir)
        xx_c = os.path.join(self.tmp_dir, 'xxmodule.c')
        xx_ext = Extension('xx', [xx_c])
        dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]})
        dist.package_dir = self.tmp_dir
        cmd = self.build_ext(dist)
        fixup_build_ext(cmd)
        cmd.build_lib = self.tmp_dir
        cmd.build_temp = self.tmp_dir

        old_stdout = sys.stdout
        if not support.verbose:
            # silence compiler output
            sys.stdout = StringIO()
        try:
            cmd.ensure_finalized()
            cmd.run()
        finally:
            sys.stdout = old_stdout

        if ALREADY_TESTED:
            self.skipTest('Already tested in %s' % ALREADY_TESTED)
        else:
            ALREADY_TESTED = type(self).__name__

        code = textwrap.dedent("""
            tmp_dir = {self.tmp_dir!r}

            import sys
            import unittest
            from test import support

            sys.path.insert(0, tmp_dir)
            import xx

            class Tests(unittest.TestCase):
                def test_xx(self):
                    for attr in ('error', 'foo', 'new', 'roj'):
                        self.assertTrue(hasattr(xx, attr))

                    self.assertEqual(xx.foo(2, 5), 7)
                    self.assertEqual(xx.foo(13,15), 28)
                    self.assertEqual(xx.new().demo(), None)
                    if support.HAVE_DOCSTRINGS:
                        doc = 'This is a template module just for instruction.'
                        self.assertEqual(xx.__doc__, doc)
                    self.assertIsInstance(xx.Null(), xx.Null)
                    self.assertIsInstance(xx.Str(), xx.Str)


            unittest.main()
        """.format(**locals()))
        assert_python_ok('-c', code)

    def test_solaris_enable_shared(self):
        dist = Distribution({'name': 'xx'})
        cmd = self.build_ext(dist)
        old = sys.platform

        sys.platform = 'sunos' # fooling finalize_options
        from distutils.sysconfig import  _config_vars
        old_var = _config_vars.get('Py_ENABLE_SHARED')
        _config_vars['Py_ENABLE_SHARED'] = 1
        try:
            cmd.ensure_finalized()
        finally:
            sys.platform = old
            if old_var is None:
                del _config_vars['Py_ENABLE_SHARED']
            else:
                _config_vars['Py_ENABLE_SHARED'] = old_var

        # make sure we get some library dirs under solaris
        self.assertGreater(len(cmd.library_dirs), 0)

    def test_user_site(self):
        import site
        dist = Distribution({'name': 'xx'})
        cmd = self.build_ext(dist)

        # making sure the user option is there
        options = [name for name, short, lable in
                   cmd.user_options]
        self.assertIn('user', options)

        # setting a value
        cmd.user = 1

        # setting user based lib and include
        lib = os.path.join(site.USER_BASE, 'lib')
        incl = os.path.join(site.USER_BASE, 'include')
        os.mkdir(lib)
        os.mkdir(incl)

        # let's run finalize
        cmd.ensure_finalized()

        # see if include_dirs and library_dirs
        # were set
        self.assertIn(lib, cmd.library_dirs)
        self.assertIn(lib, cmd.rpath)
        self.assertIn(incl, cmd.include_dirs)

    def test_optional_extension(self):

        # this extension will fail, but let's ignore this failure
        # with the optional argument.
        modules = [Extension('foo', ['xxx'], optional=False)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        self.assertRaises((UnknownFileError, CompileError),
                          cmd.run)  # should raise an error

        modules = [Extension('foo', ['xxx'], optional=True)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        cmd.run()  # should pass

    def test_finalize_options(self):
        # Make sure Python's include directories (for Python.h, pyconfig.h,
        # etc.) are in the include search path.
        modules = [Extension('foo', ['xxx'], optional=False)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.finalize_options()

        py_include = sysconfig.get_python_inc()
        for p in py_include.split(os.path.pathsep):
            self.assertIn(p, cmd.include_dirs)

        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
        for p in plat_py_include.split(os.path.pathsep):
            self.assertIn(p, cmd.include_dirs)

        # make sure cmd.libraries is turned into a list
        # if it's a string
        cmd = self.build_ext(dist)
        cmd.libraries = 'my_lib, other_lib lastlib'
        cmd.finalize_options()
        self.assertEqual(cmd.libraries, ['my_lib', 'other_lib', 'lastlib'])

        # make sure cmd.library_dirs is turned into a list
        # if it's a string
        cmd = self.build_ext(dist)
        cmd.library_dirs = 'my_lib_dir%sother_lib_dir' % os.pathsep
        cmd.finalize_options()
        self.assertIn('my_lib_dir', cmd.library_dirs)
        self.assertIn('other_lib_dir', cmd.library_dirs)

        # make sure rpath is turned into a list
        # if it's a string
        cmd = self.build_ext(dist)
        cmd.rpath = 'one%stwo' % os.pathsep
        cmd.finalize_options()
        self.assertEqual(cmd.rpath, ['one', 'two'])

        # make sure cmd.link_objects is turned into a list
        # if it's a string
        cmd = build_ext(dist)
        cmd.link_objects = 'one two,three'
        cmd.finalize_options()
        self.assertEqual(cmd.link_objects, ['one', 'two', 'three'])

        # XXX more tests to perform for win32

        # make sure define is turned into 2-tuples
        # strings if they are ','-separated strings
        cmd = self.build_ext(dist)
        cmd.define = 'one,two'
        cmd.finalize_options()
        self.assertEqual(cmd.define, [('one', '1'), ('two', '1')])

        # make sure undef is turned into a list of
        # strings if they are ','-separated strings
        cmd = self.build_ext(dist)
        cmd.undef = 'one,two'
        cmd.finalize_options()
        self.assertEqual(cmd.undef, ['one', 'two'])

        # make sure swig_opts is turned into a list
        cmd = self.build_ext(dist)
        cmd.swig_opts = None
        cmd.finalize_options()
        self.assertEqual(cmd.swig_opts, [])

        cmd = self.build_ext(dist)
        cmd.swig_opts = '1 2'
        cmd.finalize_options()
        self.assertEqual(cmd.swig_opts, ['1', '2'])

    def test_check_extensions_list(self):
        dist = Distribution()
        cmd = self.build_ext(dist)
        cmd.finalize_options()

        #'extensions' option must be a list of Extension instances
        self.assertRaises(DistutilsSetupError,
                          cmd.check_extensions_list, 'foo')

        # each element of 'ext_modules' option must be an
        # Extension instance or 2-tuple
        exts = [('bar', 'foo', 'bar'), 'foo']
        self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)

        # first element of each tuple in 'ext_modules'
        # must be the extension name (a string) and match
        # a python dotted-separated name
        exts = [('foo-bar', '')]
        self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)

        # second element of each tuple in 'ext_modules'
        # must be a dictionary (build info)
        exts = [('foo.bar', '')]
        self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)

        # ok this one should pass
        exts = [('foo.bar', {'sources': [''], 'libraries': 'foo',
                             'some': 'bar'})]
        cmd.check_extensions_list(exts)
        ext = exts[0]
        self.assertIsInstance(ext, Extension)

        # check_extensions_list adds in ext the values passed
        # when they are in ('include_dirs', 'library_dirs', 'libraries'
        # 'extra_objects', 'extra_compile_args', 'extra_link_args')
        self.assertEqual(ext.libraries, 'foo')
        self.assertFalse(hasattr(ext, 'some'))

        # 'macros' element of build info dict must be 1- or 2-tuple
        exts = [('foo.bar', {'sources': [''], 'libraries': 'foo',
                'some': 'bar', 'macros': [('1', '2', '3'), 'foo']})]
        self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)

        exts[0][1]['macros'] = [('1', '2'), ('3',)]
        cmd.check_extensions_list(exts)
        self.assertEqual(exts[0].undef_macros, ['3'])
        self.assertEqual(exts[0].define_macros, [('1', '2')])

    def test_get_source_files(self):
        modules = [Extension('foo', ['xxx'], optional=False)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        self.assertEqual(cmd.get_source_files(), ['xxx'])

    def test_unicode_module_names(self):
        modules = [
            Extension('foo', ['aaa'], optional=False),
            Extension('föö', ['uuu'], optional=False),
        ]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        self.assertRegex(cmd.get_ext_filename(modules[0].name), r'foo(_d)?\..*')
        self.assertRegex(cmd.get_ext_filename(modules[1].name), r'föö(_d)?\..*')
        self.assertEqual(cmd.get_export_symbols(modules[0]), ['PyInit_foo'])
        self.assertEqual(cmd.get_export_symbols(modules[1]), ['PyInitU_f_1gaa'])

    def test_compiler_option(self):
        # cmd.compiler is an option and
        # should not be overridden by a compiler instance
        # when the command is run
        dist = Distribution()
        cmd = self.build_ext(dist)
        cmd.compiler = 'unix'
        cmd.ensure_finalized()
        cmd.run()
        self.assertEqual(cmd.compiler, 'unix')

    def test_get_outputs(self):
        cmd = support.missing_compiler_executable()
        if cmd is not None:
            self.skipTest('The %r command is not found' % cmd)
        tmp_dir = self.mkdtemp()
        c_file = os.path.join(tmp_dir, 'foo.c')
        self.write_file(c_file, 'void PyInit_foo(void) {}\n')
        ext = Extension('foo', [c_file], optional=False)
        dist = Distribution({'name': 'xx',
                             'ext_modules': [ext]})
        cmd = self.build_ext(dist)
        fixup_build_ext(cmd)
        cmd.ensure_finalized()
        self.assertEqual(len(cmd.get_outputs()), 1)

        cmd.build_lib = os.path.join(self.tmp_dir, 'build')
        cmd.build_temp = os.path.join(self.tmp_dir, 'tempt')

        # issue #5977 : distutils build_ext.get_outputs
        # returns wrong result with --inplace
        other_tmp_dir = os.path.realpath(self.mkdtemp())
        old_wd = os.getcwd()
        os.chdir(other_tmp_dir)
        try:
            cmd.inplace = 1
            cmd.run()
            so_file = cmd.get_outputs()[0]
        finally:
            os.chdir(old_wd)
        self.assertTrue(os.path.exists(so_file))
        ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
        self.assertTrue(so_file.endswith(ext_suffix))
        so_dir = os.path.dirname(so_file)
        self.assertEqual(so_dir, other_tmp_dir)

        cmd.inplace = 0
        cmd.compiler = None
        cmd.run()
        so_file = cmd.get_outputs()[0]
        self.assertTrue(os.path.exists(so_file))
        self.assertTrue(so_file.endswith(ext_suffix))
        so_dir = os.path.dirname(so_file)
        self.assertEqual(so_dir, cmd.build_lib)

        # inplace = 0, cmd.package = 'bar'
        build_py = cmd.get_finalized_command('build_py')
        build_py.package_dir = {'': 'bar'}
        path = cmd.get_ext_fullpath('foo')
        # checking that the last directory is the build_dir
        path = os.path.split(path)[0]
        self.assertEqual(path, cmd.build_lib)

        # inplace = 1, cmd.package = 'bar'
        cmd.inplace = 1
        other_tmp_dir = os.path.realpath(self.mkdtemp())
        old_wd = os.getcwd()
        os.chdir(other_tmp_dir)
        try:
            path = cmd.get_ext_fullpath('foo')
        finally:
            os.chdir(old_wd)
        # checking that the last directory is bar
        path = os.path.split(path)[0]
        lastdir = os.path.split(path)[-1]
        self.assertEqual(lastdir, 'bar')

    def test_ext_fullpath(self):
        ext = sysconfig.get_config_var('EXT_SUFFIX')
        # building lxml.etree inplace
        #etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c')
        #etree_ext = Extension('lxml.etree', [etree_c])
        #dist = Distribution({'name': 'lxml', 'ext_modules': [etree_ext]})
        dist = Distribution()
        cmd = self.build_ext(dist)
        cmd.inplace = 1
        cmd.distribution.package_dir = {'': 'src'}
        cmd.distribution.packages = ['lxml', 'lxml.html']
        curdir = os.getcwd()
        wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
        path = cmd.get_ext_fullpath('lxml.etree')
        self.assertEqual(wanted, path)

        # building lxml.etree not inplace
        cmd.inplace = 0
        cmd.build_lib = os.path.join(curdir, 'tmpdir')
        wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
        path = cmd.get_ext_fullpath('lxml.etree')
        self.assertEqual(wanted, path)

        # building twisted.runner.portmap not inplace
        build_py = cmd.get_finalized_command('build_py')
        build_py.package_dir = {}
        cmd.distribution.packages = ['twisted', 'twisted.runner.portmap']
        path = cmd.get_ext_fullpath('twisted.runner.portmap')
        wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner',
                              'portmap' + ext)
        self.assertEqual(wanted, path)

        # building twisted.runner.portmap inplace
        cmd.inplace = 1
        path = cmd.get_ext_fullpath('twisted.runner.portmap')
        wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
        self.assertEqual(wanted, path)


    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
    def test_deployment_target_default(self):
        # Issue 9516: Test that, in the absence of the environment variable,
        # an extension module is compiled with the same deployment target as
        #  the interpreter.
        self._try_compile_deployment_target('==', None)

    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
    def test_deployment_target_too_low(self):
        # Issue 9516: Test that an extension module is not allowed to be
        # compiled with a deployment target less than that of the interpreter.
        self.assertRaises(DistutilsPlatformError,
            self._try_compile_deployment_target, '>', '10.1')

    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
    def test_deployment_target_higher_ok(self):
        # Issue 9516: Test that an extension module can be compiled with a
        # deployment target higher than that of the interpreter: the ext
        # module may depend on some newer OS feature.
        deptarget = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
        if deptarget:
            # increment the minor version number (i.e. 10.6 -> 10.7)
            deptarget = [int(x) for x in deptarget.split('.')]
            deptarget[-1] += 1
            deptarget = '.'.join(str(i) for i in deptarget)
            self._try_compile_deployment_target('<', deptarget)

    def _try_compile_deployment_target(self, operator, target):
        orig_environ = os.environ
        os.environ = orig_environ.copy()
        self.addCleanup(setattr, os, 'environ', orig_environ)

        if target is None:
            if os.environ.get('MACOSX_DEPLOYMENT_TARGET'):
                del os.environ['MACOSX_DEPLOYMENT_TARGET']
        else:
            os.environ['MACOSX_DEPLOYMENT_TARGET'] = target

        deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c')

        with open(deptarget_c, 'w') as fp:
            fp.write(textwrap.dedent('''\
                #include 

                int dummy;

                #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED
                #else
                #error "Unexpected target"
                #endif

            ''' % operator))

        # get the deployment target that the interpreter was built with
        target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
        target = tuple(map(int, target.split('.')[0:2]))
        # format the target value as defined in the Apple
        # Availability Macros.  We can't use the macro names since
        # at least one value we test with will not exist yet.
        if target[1] < 10:
            # for 10.1 through 10.9.x -> "10n0"
            target = '%02d%01d0' % target
        else:
            # for 10.10 and beyond -> "10nn00"
            target = '%02d%02d00' % target
        deptarget_ext = Extension(
            'deptarget',
            [deptarget_c],
            extra_compile_args=['-DTARGET=%s'%(target,)],
        )
        dist = Distribution({
            'name': 'deptarget',
            'ext_modules': [deptarget_ext]
        })
        dist.package_dir = self.tmp_dir
        cmd = self.build_ext(dist)
        cmd.build_lib = self.tmp_dir
        cmd.build_temp = self.tmp_dir

        try:
            old_stdout = sys.stdout
            if not support.verbose:
                # silence compiler output
                sys.stdout = StringIO()
            try:
                cmd.ensure_finalized()
                cmd.run()
            finally:
                sys.stdout = old_stdout

        except CompileError:
            self.fail("Wrong deployment target during compilation")


class ParallelBuildExtTestCase(BuildExtTestCase):

    def build_ext(self, *args, **kwargs):
        build_ext = super().build_ext(*args, **kwargs)
        build_ext.parallel = True
        return build_ext


def test_suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(BuildExtTestCase))
    suite.addTest(unittest.makeSuite(ParallelBuildExtTestCase))
    return suite

if __name__ == '__main__':
    support.run_unittest(__name__)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_build_py.py0000644000175100001710000001427700000000000024375 0ustar00runnerdocker"""Tests for distutils.command.build_py."""

import os
import sys
import unittest

from distutils.command.build_py import build_py
from distutils.core import Distribution
from distutils.errors import DistutilsFileError

from distutils.tests import support
from test.support import run_unittest


class BuildPyTestCase(support.TempdirManager,
                      support.LoggingSilencer,
                      unittest.TestCase):

    def test_package_data(self):
        sources = self.mkdtemp()
        f = open(os.path.join(sources, "__init__.py"), "w")
        try:
            f.write("# Pretend this is a package.")
        finally:
            f.close()
        f = open(os.path.join(sources, "README.txt"), "w")
        try:
            f.write("Info about this package")
        finally:
            f.close()

        destination = self.mkdtemp()

        dist = Distribution({"packages": ["pkg"],
                             "package_dir": {"pkg": sources}})
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(sources, "setup.py")
        dist.command_obj["build"] = support.DummyCommand(
            force=0,
            build_lib=destination)
        dist.packages = ["pkg"]
        dist.package_data = {"pkg": ["README.txt"]}
        dist.package_dir = {"pkg": sources}

        cmd = build_py(dist)
        cmd.compile = 1
        cmd.ensure_finalized()
        self.assertEqual(cmd.package_data, dist.package_data)

        cmd.run()

        # This makes sure the list of outputs includes byte-compiled
        # files for Python modules but not for package data files
        # (there shouldn't *be* byte-code files for those!).
        self.assertEqual(len(cmd.get_outputs()), 3)
        pkgdest = os.path.join(destination, "pkg")
        files = os.listdir(pkgdest)
        pycache_dir = os.path.join(pkgdest, "__pycache__")
        self.assertIn("__init__.py", files)
        self.assertIn("README.txt", files)
        if sys.dont_write_bytecode:
            self.assertFalse(os.path.exists(pycache_dir))
        else:
            pyc_files = os.listdir(pycache_dir)
            self.assertIn("__init__.%s.pyc" % sys.implementation.cache_tag,
                          pyc_files)

    def test_empty_package_dir(self):
        # See bugs #1668596/#1720897
        sources = self.mkdtemp()
        open(os.path.join(sources, "__init__.py"), "w").close()

        testdir = os.path.join(sources, "doc")
        os.mkdir(testdir)
        open(os.path.join(testdir, "testfile"), "w").close()

        os.chdir(sources)
        dist = Distribution({"packages": ["pkg"],
                             "package_dir": {"pkg": ""},
                             "package_data": {"pkg": ["doc/*"]}})
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(sources, "setup.py")
        dist.script_args = ["build"]
        dist.parse_command_line()

        try:
            dist.run_commands()
        except DistutilsFileError:
            self.fail("failed package_data test when package_dir is ''")

    @unittest.skipIf(sys.dont_write_bytecode, 'byte-compile disabled')
    def test_byte_compile(self):
        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
        os.chdir(project_dir)
        self.write_file('boiledeggs.py', 'import antigravity')
        cmd = build_py(dist)
        cmd.compile = 1
        cmd.build_lib = 'here'
        cmd.finalize_options()
        cmd.run()

        found = os.listdir(cmd.build_lib)
        self.assertEqual(sorted(found), ['__pycache__', 'boiledeggs.py'])
        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
        self.assertEqual(found,
                         ['boiledeggs.%s.pyc' % sys.implementation.cache_tag])

    @unittest.skipIf(sys.dont_write_bytecode, 'byte-compile disabled')
    def test_byte_compile_optimized(self):
        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
        os.chdir(project_dir)
        self.write_file('boiledeggs.py', 'import antigravity')
        cmd = build_py(dist)
        cmd.compile = 0
        cmd.optimize = 1
        cmd.build_lib = 'here'
        cmd.finalize_options()
        cmd.run()

        found = os.listdir(cmd.build_lib)
        self.assertEqual(sorted(found), ['__pycache__', 'boiledeggs.py'])
        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
        expect = 'boiledeggs.{}.opt-1.pyc'.format(sys.implementation.cache_tag)
        self.assertEqual(sorted(found), [expect])

    def test_dir_in_package_data(self):
        """
        A directory in package_data should not be added to the filelist.
        """
        # See bug 19286
        sources = self.mkdtemp()
        pkg_dir = os.path.join(sources, "pkg")

        os.mkdir(pkg_dir)
        open(os.path.join(pkg_dir, "__init__.py"), "w").close()

        docdir = os.path.join(pkg_dir, "doc")
        os.mkdir(docdir)
        open(os.path.join(docdir, "testfile"), "w").close()

        # create the directory that could be incorrectly detected as a file
        os.mkdir(os.path.join(docdir, 'otherdir'))

        os.chdir(sources)
        dist = Distribution({"packages": ["pkg"],
                             "package_data": {"pkg": ["doc/*"]}})
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(sources, "setup.py")
        dist.script_args = ["build"]
        dist.parse_command_line()

        try:
            dist.run_commands()
        except DistutilsFileError:
            self.fail("failed package_data when data dir includes a dir")

    def test_dont_write_bytecode(self):
        # makes sure byte_compile is not used
        dist = self.create_dist()[1]
        cmd = build_py(dist)
        cmd.compile = 1
        cmd.optimize = 1

        old_dont_write_bytecode = sys.dont_write_bytecode
        sys.dont_write_bytecode = True
        try:
            cmd.byte_compile([])
        finally:
            sys.dont_write_bytecode = old_dont_write_bytecode

        self.assertIn('byte-compiling is disabled',
                      self.logs[0][1] % self.logs[0][2])


def test_suite():
    return unittest.makeSuite(BuildPyTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_build_scripts.py0000644000175100001710000000701100000000000025420 0ustar00runnerdocker"""Tests for distutils.command.build_scripts."""

import os
import unittest

from distutils.command.build_scripts import build_scripts
from distutils.core import Distribution
from distutils import sysconfig

from distutils.tests import support
from test.support import run_unittest


class BuildScriptsTestCase(support.TempdirManager,
                           support.LoggingSilencer,
                           unittest.TestCase):

    def test_default_settings(self):
        cmd = self.get_build_scripts_cmd("/foo/bar", [])
        self.assertFalse(cmd.force)
        self.assertIsNone(cmd.build_dir)

        cmd.finalize_options()

        self.assertTrue(cmd.force)
        self.assertEqual(cmd.build_dir, "/foo/bar")

    def test_build(self):
        source = self.mkdtemp()
        target = self.mkdtemp()
        expected = self.write_sample_scripts(source)

        cmd = self.get_build_scripts_cmd(target,
                                         [os.path.join(source, fn)
                                          for fn in expected])
        cmd.finalize_options()
        cmd.run()

        built = os.listdir(target)
        for name in expected:
            self.assertIn(name, built)

    def get_build_scripts_cmd(self, target, scripts):
        import sys
        dist = Distribution()
        dist.scripts = scripts
        dist.command_obj["build"] = support.DummyCommand(
            build_scripts=target,
            force=1,
            executable=sys.executable
            )
        return build_scripts(dist)

    def write_sample_scripts(self, dir):
        expected = []
        expected.append("script1.py")
        self.write_script(dir, "script1.py",
                          ("#! /usr/bin/env python2.3\n"
                           "# bogus script w/ Python sh-bang\n"
                           "pass\n"))
        expected.append("script2.py")
        self.write_script(dir, "script2.py",
                          ("#!/usr/bin/python\n"
                           "# bogus script w/ Python sh-bang\n"
                           "pass\n"))
        expected.append("shell.sh")
        self.write_script(dir, "shell.sh",
                          ("#!/bin/sh\n"
                           "# bogus shell script w/ sh-bang\n"
                           "exit 0\n"))
        return expected

    def write_script(self, dir, name, text):
        f = open(os.path.join(dir, name), "w")
        try:
            f.write(text)
        finally:
            f.close()

    def test_version_int(self):
        source = self.mkdtemp()
        target = self.mkdtemp()
        expected = self.write_sample_scripts(source)


        cmd = self.get_build_scripts_cmd(target,
                                         [os.path.join(source, fn)
                                          for fn in expected])
        cmd.finalize_options()

        # http://bugs.python.org/issue4524
        #
        # On linux-g++-32 with command line `./configure --enable-ipv6
        # --with-suffix=3`, python is compiled okay but the build scripts
        # failed when writing the name of the executable
        old = sysconfig.get_config_vars().get('VERSION')
        sysconfig._config_vars['VERSION'] = 4
        try:
            cmd.run()
        finally:
            if old is not None:
                sysconfig._config_vars['VERSION'] = old

        built = os.listdir(target)
        for name in expected:
            self.assertIn(name, built)

def test_suite():
    return unittest.makeSuite(BuildScriptsTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_check.py0000644000175100001710000001311700000000000023633 0ustar00runnerdocker"""Tests for distutils.command.check."""
import os
import textwrap
import unittest
from test.support import run_unittest

from distutils.command.check import check, HAS_DOCUTILS
from distutils.tests import support
from distutils.errors import DistutilsSetupError

try:
    import pygments
except ImportError:
    pygments = None


HERE = os.path.dirname(__file__)


class CheckTestCase(support.LoggingSilencer,
                    support.TempdirManager,
                    unittest.TestCase):

    def _run(self, metadata=None, cwd=None, **options):
        if metadata is None:
            metadata = {}
        if cwd is not None:
            old_dir = os.getcwd()
            os.chdir(cwd)
        pkg_info, dist = self.create_dist(**metadata)
        cmd = check(dist)
        cmd.initialize_options()
        for name, value in options.items():
            setattr(cmd, name, value)
        cmd.ensure_finalized()
        cmd.run()
        if cwd is not None:
            os.chdir(old_dir)
        return cmd

    def test_check_metadata(self):
        # let's run the command with no metadata at all
        # by default, check is checking the metadata
        # should have some warnings
        cmd = self._run()
        self.assertEqual(cmd._warnings, 2)

        # now let's add the required fields
        # and run it again, to make sure we don't get
        # any warning anymore
        metadata = {'url': 'xxx', 'author': 'xxx',
                    'author_email': 'xxx',
                    'name': 'xxx', 'version': 'xxx'}
        cmd = self._run(metadata)
        self.assertEqual(cmd._warnings, 0)

        # now with the strict mode, we should
        # get an error if there are missing metadata
        self.assertRaises(DistutilsSetupError, self._run, {}, **{'strict': 1})

        # and of course, no error when all metadata are present
        cmd = self._run(metadata, strict=1)
        self.assertEqual(cmd._warnings, 0)

        # now a test with non-ASCII characters
        metadata = {'url': 'xxx', 'author': '\u00c9ric',
                    'author_email': 'xxx', 'name': 'xxx',
                    'version': 'xxx',
                    'description': 'Something about esszet \u00df',
                    'long_description': 'More things about esszet \u00df'}
        cmd = self._run(metadata)
        self.assertEqual(cmd._warnings, 0)

    @unittest.skipUnless(HAS_DOCUTILS, "won't test without docutils")
    def test_check_document(self):
        pkg_info, dist = self.create_dist()
        cmd = check(dist)

        # let's see if it detects broken rest
        broken_rest = 'title\n===\n\ntest'
        msgs = cmd._check_rst_data(broken_rest)
        self.assertEqual(len(msgs), 1)

        # and non-broken rest
        rest = 'title\n=====\n\ntest'
        msgs = cmd._check_rst_data(rest)
        self.assertEqual(len(msgs), 0)

    @unittest.skipUnless(HAS_DOCUTILS, "won't test without docutils")
    def test_check_restructuredtext(self):
        # let's see if it detects broken rest in long_description
        broken_rest = 'title\n===\n\ntest'
        pkg_info, dist = self.create_dist(long_description=broken_rest)
        cmd = check(dist)
        cmd.check_restructuredtext()
        self.assertEqual(cmd._warnings, 1)

        # let's see if we have an error with strict=1
        metadata = {'url': 'xxx', 'author': 'xxx',
                    'author_email': 'xxx',
                    'name': 'xxx', 'version': 'xxx',
                    'long_description': broken_rest}
        self.assertRaises(DistutilsSetupError, self._run, metadata,
                          **{'strict': 1, 'restructuredtext': 1})

        # and non-broken rest, including a non-ASCII character to test #12114
        metadata['long_description'] = 'title\n=====\n\ntest \u00df'
        cmd = self._run(metadata, strict=1, restructuredtext=1)
        self.assertEqual(cmd._warnings, 0)

        # check that includes work to test #31292
        metadata['long_description'] = 'title\n=====\n\n.. include:: includetest.rst'
        cmd = self._run(metadata, cwd=HERE, strict=1, restructuredtext=1)
        self.assertEqual(cmd._warnings, 0)

    @unittest.skipUnless(HAS_DOCUTILS, "won't test without docutils")
    def test_check_restructuredtext_with_syntax_highlight(self):
        # Don't fail if there is a `code` or `code-block` directive

        example_rst_docs = []
        example_rst_docs.append(textwrap.dedent("""\
            Here's some code:

            .. code:: python

                def foo():
                    pass
            """))
        example_rst_docs.append(textwrap.dedent("""\
            Here's some code:

            .. code-block:: python

                def foo():
                    pass
            """))

        for rest_with_code in example_rst_docs:
            pkg_info, dist = self.create_dist(long_description=rest_with_code)
            cmd = check(dist)
            cmd.check_restructuredtext()
            msgs = cmd._check_rst_data(rest_with_code)
            if pygments is not None:
                self.assertEqual(len(msgs), 0)
            else:
                self.assertEqual(len(msgs), 1)
                self.assertEqual(
                    str(msgs[0][1]),
                    'Cannot analyze code. Pygments package not found.'
                )

    def test_check_all(self):

        metadata = {'url': 'xxx', 'author': 'xxx'}
        self.assertRaises(DistutilsSetupError, self._run,
                          {}, **{'strict': 1,
                                 'restructuredtext': 1})

def test_suite():
    return unittest.makeSuite(CheckTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_clean.py0000644000175100001710000000264100000000000023640 0ustar00runnerdocker"""Tests for distutils.command.clean."""
import os
import unittest

from distutils.command.clean import clean
from distutils.tests import support
from test.support import run_unittest

class cleanTestCase(support.TempdirManager,
                    support.LoggingSilencer,
                    unittest.TestCase):

    def test_simple_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = clean(dist)

        # let's add some elements clean should remove
        dirs = [(d, os.path.join(pkg_dir, d))
                for d in ('build_temp', 'build_lib', 'bdist_base',
                'build_scripts', 'build_base')]

        for name, path in dirs:
            os.mkdir(path)
            setattr(cmd, name, path)
            if name == 'build_base':
                continue
            for f in ('one', 'two', 'three'):
                self.write_file(os.path.join(path, f))

        # let's run the command
        cmd.all = 1
        cmd.ensure_finalized()
        cmd.run()

        # make sure the files where removed
        for name, path in dirs:
            self.assertFalse(os.path.exists(path),
                         '%s was not removed' % path)

        # let's run the command again (should spit warnings but succeed)
        cmd.all = 1
        cmd.ensure_finalized()
        cmd.run()

def test_suite():
    return unittest.makeSuite(cleanTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_cmd.py0000644000175100001710000000737300000000000023330 0ustar00runnerdocker"""Tests for distutils.cmd."""
import unittest
import os
from test.support import captured_stdout, run_unittest

from distutils.cmd import Command
from distutils.dist import Distribution
from distutils.errors import DistutilsOptionError
from distutils import debug

class MyCmd(Command):
    def initialize_options(self):
        pass

class CommandTestCase(unittest.TestCase):

    def setUp(self):
        dist = Distribution()
        self.cmd = MyCmd(dist)

    def test_ensure_string_list(self):

        cmd = self.cmd
        cmd.not_string_list = ['one', 2, 'three']
        cmd.yes_string_list = ['one', 'two', 'three']
        cmd.not_string_list2 = object()
        cmd.yes_string_list2 = 'ok'
        cmd.ensure_string_list('yes_string_list')
        cmd.ensure_string_list('yes_string_list2')

        self.assertRaises(DistutilsOptionError,
                          cmd.ensure_string_list, 'not_string_list')

        self.assertRaises(DistutilsOptionError,
                          cmd.ensure_string_list, 'not_string_list2')

        cmd.option1 = 'ok,dok'
        cmd.ensure_string_list('option1')
        self.assertEqual(cmd.option1, ['ok', 'dok'])

        cmd.option2 = ['xxx', 'www']
        cmd.ensure_string_list('option2')

        cmd.option3 = ['ok', 2]
        self.assertRaises(DistutilsOptionError, cmd.ensure_string_list,
                          'option3')


    def test_make_file(self):

        cmd = self.cmd

        # making sure it raises when infiles is not a string or a list/tuple
        self.assertRaises(TypeError, cmd.make_file,
                          infiles=1, outfile='', func='func', args=())

        # making sure execute gets called properly
        def _execute(func, args, exec_msg, level):
            self.assertEqual(exec_msg, 'generating out from in')
        cmd.force = True
        cmd.execute = _execute
        cmd.make_file(infiles='in', outfile='out', func='func', args=())

    def test_dump_options(self):

        msgs = []
        def _announce(msg, level):
            msgs.append(msg)
        cmd = self.cmd
        cmd.announce = _announce
        cmd.option1 = 1
        cmd.option2 = 1
        cmd.user_options = [('option1', '', ''), ('option2', '', '')]
        cmd.dump_options()

        wanted = ["command options for 'MyCmd':", '  option1 = 1',
                  '  option2 = 1']
        self.assertEqual(msgs, wanted)

    def test_ensure_string(self):
        cmd = self.cmd
        cmd.option1 = 'ok'
        cmd.ensure_string('option1')

        cmd.option2 = None
        cmd.ensure_string('option2', 'xxx')
        self.assertTrue(hasattr(cmd, 'option2'))

        cmd.option3 = 1
        self.assertRaises(DistutilsOptionError, cmd.ensure_string, 'option3')

    def test_ensure_filename(self):
        cmd = self.cmd
        cmd.option1 = __file__
        cmd.ensure_filename('option1')
        cmd.option2 = 'xxx'
        self.assertRaises(DistutilsOptionError, cmd.ensure_filename, 'option2')

    def test_ensure_dirname(self):
        cmd = self.cmd
        cmd.option1 = os.path.dirname(__file__) or os.curdir
        cmd.ensure_dirname('option1')
        cmd.option2 = 'xxx'
        self.assertRaises(DistutilsOptionError, cmd.ensure_dirname, 'option2')

    def test_debug_print(self):
        cmd = self.cmd
        with captured_stdout() as stdout:
            cmd.debug_print('xxx')
        stdout.seek(0)
        self.assertEqual(stdout.read(), '')

        debug.DEBUG = True
        try:
            with captured_stdout() as stdout:
                cmd.debug_print('xxx')
            stdout.seek(0)
            self.assertEqual(stdout.read(), 'xxx\n')
        finally:
            debug.DEBUG = False

def test_suite():
    return unittest.makeSuite(CommandTestCase)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_config.py0000644000175100001710000000746400000000000024033 0ustar00runnerdocker"""Tests for distutils.pypirc.pypirc."""
import os
import unittest

from distutils.core import PyPIRCCommand
from distutils.core import Distribution
from distutils.log import set_threshold
from distutils.log import WARN

from distutils.tests import support
from test.support import run_unittest

PYPIRC = """\
[distutils]

index-servers =
    server1
    server2
    server3

[server1]
username:me
password:secret

[server2]
username:meagain
password: secret
realm:acme
repository:http://another.pypi/

[server3]
username:cbiggles
password:yh^%#rest-of-my-password
"""

PYPIRC_OLD = """\
[server-login]
username:tarek
password:secret
"""

WANTED = """\
[distutils]
index-servers =
    pypi

[pypi]
username:tarek
password:xxx
"""


class BasePyPIRCCommandTestCase(support.TempdirManager,
                            support.LoggingSilencer,
                            support.EnvironGuard,
                            unittest.TestCase):

    def setUp(self):
        """Patches the environment."""
        super(BasePyPIRCCommandTestCase, self).setUp()
        self.tmp_dir = self.mkdtemp()
        os.environ['HOME'] = self.tmp_dir
        os.environ['USERPROFILE'] = self.tmp_dir
        self.rc = os.path.join(self.tmp_dir, '.pypirc')
        self.dist = Distribution()

        class command(PyPIRCCommand):
            def __init__(self, dist):
                PyPIRCCommand.__init__(self, dist)
            def initialize_options(self):
                pass
            finalize_options = initialize_options

        self._cmd = command
        self.old_threshold = set_threshold(WARN)

    def tearDown(self):
        """Removes the patch."""
        set_threshold(self.old_threshold)
        super(BasePyPIRCCommandTestCase, self).tearDown()


class PyPIRCCommandTestCase(BasePyPIRCCommandTestCase):

    def test_server_registration(self):
        # This test makes sure PyPIRCCommand knows how to:
        # 1. handle several sections in .pypirc
        # 2. handle the old format

        # new format
        self.write_file(self.rc, PYPIRC)
        cmd = self._cmd(self.dist)
        config = cmd._read_pypirc()

        config = list(sorted(config.items()))
        waited = [('password', 'secret'), ('realm', 'pypi'),
                  ('repository', 'https://upload.pypi.org/legacy/'),
                  ('server', 'server1'), ('username', 'me')]
        self.assertEqual(config, waited)

        # old format
        self.write_file(self.rc, PYPIRC_OLD)
        config = cmd._read_pypirc()
        config = list(sorted(config.items()))
        waited = [('password', 'secret'), ('realm', 'pypi'),
                  ('repository', 'https://upload.pypi.org/legacy/'),
                  ('server', 'server-login'), ('username', 'tarek')]
        self.assertEqual(config, waited)

    def test_server_empty_registration(self):
        cmd = self._cmd(self.dist)
        rc = cmd._get_rc_file()
        self.assertFalse(os.path.exists(rc))
        cmd._store_pypirc('tarek', 'xxx')
        self.assertTrue(os.path.exists(rc))
        f = open(rc)
        try:
            content = f.read()
            self.assertEqual(content, WANTED)
        finally:
            f.close()

    def test_config_interpolation(self):
        # using the % character in .pypirc should not raise an error (#20120)
        self.write_file(self.rc, PYPIRC)
        cmd = self._cmd(self.dist)
        cmd.repository = 'server3'
        config = cmd._read_pypirc()

        config = list(sorted(config.items()))
        waited = [('password', 'yh^%#rest-of-my-password'), ('realm', 'pypi'),
                  ('repository', 'https://upload.pypi.org/legacy/'),
                  ('server', 'server3'), ('username', 'cbiggles')]
        self.assertEqual(config, waited)


def test_suite():
    return unittest.makeSuite(PyPIRCCommandTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_config_cmd.py0000644000175100001710000000574700000000000024660 0ustar00runnerdocker"""Tests for distutils.command.config."""
import unittest
import os
import sys
from test.support import run_unittest

from .py35compat import missing_compiler_executable

from distutils.command.config import dump_file, config
from distutils.tests import support
from distutils import log

class ConfigTestCase(support.LoggingSilencer,
                     support.TempdirManager,
                     unittest.TestCase):

    def _info(self, msg, *args):
        for line in msg.splitlines():
            self._logs.append(line)

    def setUp(self):
        super(ConfigTestCase, self).setUp()
        self._logs = []
        self.old_log = log.info
        log.info = self._info

    def tearDown(self):
        log.info = self.old_log
        super(ConfigTestCase, self).tearDown()

    def test_dump_file(self):
        this_file = os.path.splitext(__file__)[0] + '.py'
        f = open(this_file)
        try:
            numlines = len(f.readlines())
        finally:
            f.close()

        dump_file(this_file, 'I am the header')
        self.assertEqual(len(self._logs), numlines+1)

    @unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
    def test_search_cpp(self):
        cmd = missing_compiler_executable(['preprocessor'])
        if cmd is not None:
            self.skipTest('The %r command is not found' % cmd)
        pkg_dir, dist = self.create_dist()
        cmd = config(dist)
        cmd._check_compiler()
        compiler = cmd.compiler
        if sys.platform[:3] == "aix" and "xlc" in compiler.preprocessor[0].lower():
            self.skipTest('xlc: The -E option overrides the -P, -o, and -qsyntaxonly options')

        # simple pattern searches
        match = cmd.search_cpp(pattern='xxx', body='/* xxx */')
        self.assertEqual(match, 0)

        match = cmd.search_cpp(pattern='_configtest', body='/* xxx */')
        self.assertEqual(match, 1)

    def test_finalize_options(self):
        # finalize_options does a bit of transformation
        # on options
        pkg_dir, dist = self.create_dist()
        cmd = config(dist)
        cmd.include_dirs = 'one%stwo' % os.pathsep
        cmd.libraries = 'one'
        cmd.library_dirs = 'three%sfour' % os.pathsep
        cmd.ensure_finalized()

        self.assertEqual(cmd.include_dirs, ['one', 'two'])
        self.assertEqual(cmd.libraries, ['one'])
        self.assertEqual(cmd.library_dirs, ['three', 'four'])

    def test_clean(self):
        # _clean removes files
        tmp_dir = self.mkdtemp()
        f1 = os.path.join(tmp_dir, 'one')
        f2 = os.path.join(tmp_dir, 'two')

        self.write_file(f1, 'xxx')
        self.write_file(f2, 'xxx')

        for f in (f1, f2):
            self.assertTrue(os.path.exists(f))

        pkg_dir, dist = self.create_dist()
        cmd = config(dist)
        cmd._clean(f1, f2)

        for f in (f1, f2):
            self.assertFalse(os.path.exists(f))

def test_suite():
    return unittest.makeSuite(ConfigTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_core.py0000644000175100001710000001143600000000000023510 0ustar00runnerdocker"""Tests for distutils.core."""

import io
import distutils.core
import os
import shutil
import sys
from test.support import captured_stdout, run_unittest
from . import py38compat as os_helper
import unittest
from distutils.tests import support
from distutils import log
from distutils.dist import Distribution

# setup script that uses __file__
setup_using___file__ = """\

__file__

from distutils.core import setup
setup()
"""

setup_prints_cwd = """\

import os
print(os.getcwd())

from distutils.core import setup
setup()
"""

setup_does_nothing = """\
from distutils.core import setup
setup()
"""


setup_defines_subclass = """\
from distutils.core import setup
from distutils.command.install import install as _install

class install(_install):
    sub_commands = _install.sub_commands + ['cmd']

setup(cmdclass={'install': install})
"""

setup_within_if_main = """\
from distutils.core import setup

def main():
    return setup(name="setup_within_if_main")

if __name__ == "__main__":
    main()
"""

class CoreTestCase(support.EnvironGuard, unittest.TestCase):

    def setUp(self):
        super(CoreTestCase, self).setUp()
        self.old_stdout = sys.stdout
        self.cleanup_testfn()
        self.old_argv = sys.argv, sys.argv[:]
        self.addCleanup(log.set_threshold, log._global_log.threshold)

    def tearDown(self):
        sys.stdout = self.old_stdout
        self.cleanup_testfn()
        sys.argv = self.old_argv[0]
        sys.argv[:] = self.old_argv[1]
        super(CoreTestCase, self).tearDown()

    def cleanup_testfn(self):
        path = os_helper.TESTFN
        if os.path.isfile(path):
            os.remove(path)
        elif os.path.isdir(path):
            shutil.rmtree(path)

    def write_setup(self, text, path=os_helper.TESTFN):
        f = open(path, "w")
        try:
            f.write(text)
        finally:
            f.close()
        return path

    def test_run_setup_provides_file(self):
        # Make sure the script can use __file__; if that's missing, the test
        # setup.py script will raise NameError.
        distutils.core.run_setup(
            self.write_setup(setup_using___file__))

    def test_run_setup_preserves_sys_argv(self):
        # Make sure run_setup does not clobber sys.argv
        argv_copy = sys.argv.copy()
        distutils.core.run_setup(
            self.write_setup(setup_does_nothing))
        self.assertEqual(sys.argv, argv_copy)

    def test_run_setup_defines_subclass(self):
        # Make sure the script can use __file__; if that's missing, the test
        # setup.py script will raise NameError.
        dist = distutils.core.run_setup(
            self.write_setup(setup_defines_subclass))
        install = dist.get_command_obj('install')
        self.assertIn('cmd', install.sub_commands)

    def test_run_setup_uses_current_dir(self):
        # This tests that the setup script is run with the current directory
        # as its own current directory; this was temporarily broken by a
        # previous patch when TESTFN did not use the current directory.
        sys.stdout = io.StringIO()
        cwd = os.getcwd()

        # Create a directory and write the setup.py file there:
        os.mkdir(os_helper.TESTFN)
        setup_py = os.path.join(os_helper.TESTFN, "setup.py")
        distutils.core.run_setup(
            self.write_setup(setup_prints_cwd, path=setup_py))

        output = sys.stdout.getvalue()
        if output.endswith("\n"):
            output = output[:-1]
        self.assertEqual(cwd, output)

    def test_run_setup_within_if_main(self):
        dist = distutils.core.run_setup(
            self.write_setup(setup_within_if_main), stop_after="config")
        self.assertIsInstance(dist, Distribution)
        self.assertEqual(dist.get_name(), "setup_within_if_main")

    def test_run_commands(self):
        sys.argv = ['setup.py', 'build']
        dist = distutils.core.run_setup(
            self.write_setup(setup_within_if_main), stop_after="commandline")
        self.assertNotIn('build', dist.have_run)
        distutils.core.run_commands(dist)
        self.assertIn('build', dist.have_run)

    def test_debug_mode(self):
        # this covers the code called when DEBUG is set
        sys.argv = ['setup.py', '--name']
        with captured_stdout() as stdout:
            distutils.core.setup(name='bar')
        stdout.seek(0)
        self.assertEqual(stdout.read(), 'bar\n')

        distutils.core.DEBUG = True
        try:
            with captured_stdout() as stdout:
                distutils.core.setup(name='bar')
        finally:
            distutils.core.DEBUG = False
        stdout.seek(0)
        wanted = "options (after parsing config files):\n"
        self.assertEqual(stdout.readlines()[0], wanted)

def test_suite():
    return unittest.makeSuite(CoreTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_cygwinccompiler.py0000644000175100001710000001326600000000000025761 0ustar00runnerdocker"""Tests for distutils.cygwinccompiler."""
import unittest
import sys
import os
from io import BytesIO
from test.support import run_unittest

from distutils import cygwinccompiler
from distutils.cygwinccompiler import (check_config_h,
                                       CONFIG_H_OK, CONFIG_H_NOTOK,
                                       CONFIG_H_UNCERTAIN, get_versions,
                                       get_msvcr)
from distutils.tests import support

class FakePopen(object):
    test_class = None

    def __init__(self, cmd, shell, stdout):
        self.cmd = cmd.split()[0]
        exes = self.test_class._exes
        if self.cmd in exes:
            # issue #6438 in Python 3.x, Popen returns bytes
            self.stdout = BytesIO(exes[self.cmd])
        else:
            self.stdout = os.popen(cmd, 'r')


class CygwinCCompilerTestCase(support.TempdirManager,
                              unittest.TestCase):

    def setUp(self):
        super(CygwinCCompilerTestCase, self).setUp()
        self.version = sys.version
        self.python_h = os.path.join(self.mkdtemp(), 'python.h')
        from distutils import sysconfig
        self.old_get_config_h_filename = sysconfig.get_config_h_filename
        sysconfig.get_config_h_filename = self._get_config_h_filename
        self.old_find_executable = cygwinccompiler.find_executable
        cygwinccompiler.find_executable = self._find_executable
        self._exes = {}
        self.old_popen = cygwinccompiler.Popen
        FakePopen.test_class = self
        cygwinccompiler.Popen = FakePopen

    def tearDown(self):
        sys.version = self.version
        from distutils import sysconfig
        sysconfig.get_config_h_filename = self.old_get_config_h_filename
        cygwinccompiler.find_executable = self.old_find_executable
        cygwinccompiler.Popen = self.old_popen
        super(CygwinCCompilerTestCase, self).tearDown()

    def _get_config_h_filename(self):
        return self.python_h

    def _find_executable(self, name):
        if name in self._exes:
            return name
        return None

    def test_check_config_h(self):

        # check_config_h looks for "GCC" in sys.version first
        # returns CONFIG_H_OK if found
        sys.version = ('2.6.1 (r261:67515, Dec  6 2008, 16:42:21) \n[GCC '
                       '4.0.1 (Apple Computer, Inc. build 5370)]')

        self.assertEqual(check_config_h()[0], CONFIG_H_OK)

        # then it tries to see if it can find "__GNUC__" in pyconfig.h
        sys.version = 'something without the *CC word'

        # if the file doesn't exist it returns  CONFIG_H_UNCERTAIN
        self.assertEqual(check_config_h()[0], CONFIG_H_UNCERTAIN)

        # if it exists but does not contain __GNUC__, it returns CONFIG_H_NOTOK
        self.write_file(self.python_h, 'xxx')
        self.assertEqual(check_config_h()[0], CONFIG_H_NOTOK)

        # and CONFIG_H_OK if __GNUC__ is found
        self.write_file(self.python_h, 'xxx __GNUC__ xxx')
        self.assertEqual(check_config_h()[0], CONFIG_H_OK)

    def test_get_versions(self):

        # get_versions calls distutils.spawn.find_executable on
        # 'gcc', 'ld' and 'dllwrap'
        self.assertEqual(get_versions(), (None, None, None))

        # Let's fake we have 'gcc' and it returns '3.4.5'
        self._exes['gcc'] = b'gcc (GCC) 3.4.5 (mingw special)\nFSF'
        res = get_versions()
        self.assertEqual(str(res[0]), '3.4.5')

        # and let's see what happens when the version
        # doesn't match the regular expression
        # (\d+\.\d+(\.\d+)*)
        self._exes['gcc'] = b'very strange output'
        res = get_versions()
        self.assertEqual(res[0], None)

        # same thing for ld
        self._exes['ld'] = b'GNU ld version 2.17.50 20060824'
        res = get_versions()
        self.assertEqual(str(res[1]), '2.17.50')
        self._exes['ld'] = b'@(#)PROGRAM:ld  PROJECT:ld64-77'
        res = get_versions()
        self.assertEqual(res[1], None)

        # and dllwrap
        self._exes['dllwrap'] = b'GNU dllwrap 2.17.50 20060824\nFSF'
        res = get_versions()
        self.assertEqual(str(res[2]), '2.17.50')
        self._exes['dllwrap'] = b'Cheese Wrap'
        res = get_versions()
        self.assertEqual(res[2], None)

    def test_get_msvcr(self):

        # none
        sys.version  = ('2.6.1 (r261:67515, Dec  6 2008, 16:42:21) '
                        '\n[GCC 4.0.1 (Apple Computer, Inc. build 5370)]')
        self.assertEqual(get_msvcr(), None)

        # MSVC 7.0
        sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) '
                       '[MSC v.1300 32 bits (Intel)]')
        self.assertEqual(get_msvcr(), ['msvcr70'])

        # MSVC 7.1
        sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) '
                       '[MSC v.1310 32 bits (Intel)]')
        self.assertEqual(get_msvcr(), ['msvcr71'])

        # VS2005 / MSVC 8.0
        sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) '
                       '[MSC v.1400 32 bits (Intel)]')
        self.assertEqual(get_msvcr(), ['msvcr80'])

        # VS2008 / MSVC 9.0
        sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) '
                       '[MSC v.1500 32 bits (Intel)]')
        self.assertEqual(get_msvcr(), ['msvcr90'])
        
        sys.version = '3.10.0 (tags/v3.10.0:b494f59, Oct  4 2021, 18:46:30) [MSC v.1929 32 bit (Intel)]'
        self.assertEqual(get_msvcr(), ['ucrt', 'vcruntime140'])

        # unknown
        sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) '
                       '[MSC v.2000 32 bits (Intel)]')
        self.assertRaises(ValueError, get_msvcr)

def test_suite():
    return unittest.makeSuite(CygwinCCompilerTestCase)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_dep_util.py0000644000175100001710000000540400000000000024363 0ustar00runnerdocker"""Tests for distutils.dep_util."""
import unittest
import os

from distutils.dep_util import newer, newer_pairwise, newer_group
from distutils.errors import DistutilsFileError
from distutils.tests import support
from test.support import run_unittest

class DepUtilTestCase(support.TempdirManager, unittest.TestCase):

    def test_newer(self):

        tmpdir = self.mkdtemp()
        new_file = os.path.join(tmpdir, 'new')
        old_file = os.path.abspath(__file__)

        # Raise DistutilsFileError if 'new_file' does not exist.
        self.assertRaises(DistutilsFileError, newer, new_file, old_file)

        # Return true if 'new_file' exists and is more recently modified than
        # 'old_file', or if 'new_file' exists and 'old_file' doesn't.
        self.write_file(new_file)
        self.assertTrue(newer(new_file, 'I_dont_exist'))
        self.assertTrue(newer(new_file, old_file))

        # Return false if both exist and 'old_file' is the same age or younger
        # than 'new_file'.
        self.assertFalse(newer(old_file, new_file))

    def test_newer_pairwise(self):
        tmpdir = self.mkdtemp()
        sources = os.path.join(tmpdir, 'sources')
        targets = os.path.join(tmpdir, 'targets')
        os.mkdir(sources)
        os.mkdir(targets)
        one = os.path.join(sources, 'one')
        two = os.path.join(sources, 'two')
        three = os.path.abspath(__file__)    # I am the old file
        four = os.path.join(targets, 'four')
        self.write_file(one)
        self.write_file(two)
        self.write_file(four)

        self.assertEqual(newer_pairwise([one, two], [three, four]),
                         ([one],[three]))

    def test_newer_group(self):
        tmpdir = self.mkdtemp()
        sources = os.path.join(tmpdir, 'sources')
        os.mkdir(sources)
        one = os.path.join(sources, 'one')
        two = os.path.join(sources, 'two')
        three = os.path.join(sources, 'three')
        old_file = os.path.abspath(__file__)

        # return true if 'old_file' is out-of-date with respect to any file
        # listed in 'sources'.
        self.write_file(one)
        self.write_file(two)
        self.write_file(three)
        self.assertTrue(newer_group([one, two, three], old_file))
        self.assertFalse(newer_group([one, two, old_file], three))

        # missing handling
        os.remove(one)
        self.assertRaises(OSError, newer_group, [one, two, old_file], three)

        self.assertFalse(newer_group([one, two, old_file], three,
                                     missing='ignore'))

        self.assertTrue(newer_group([one, two, old_file], three,
                                    missing='newer'))


def test_suite():
    return unittest.makeSuite(DepUtilTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_dir_util.py0000644000175100001710000001105600000000000024371 0ustar00runnerdocker"""Tests for distutils.dir_util."""
import unittest
import os
import stat
import sys
from unittest.mock import patch

from distutils import dir_util, errors
from distutils.dir_util import (mkpath, remove_tree, create_tree, copy_tree,
                                ensure_relative)

from distutils import log
from distutils.tests import support
from test.support import run_unittest


class DirUtilTestCase(support.TempdirManager, unittest.TestCase):

    def _log(self, msg, *args):
        if len(args) > 0:
            self._logs.append(msg % args)
        else:
            self._logs.append(msg)

    def setUp(self):
        super(DirUtilTestCase, self).setUp()
        self._logs = []
        tmp_dir = self.mkdtemp()
        self.root_target = os.path.join(tmp_dir, 'deep')
        self.target = os.path.join(self.root_target, 'here')
        self.target2 = os.path.join(tmp_dir, 'deep2')
        self.old_log = log.info
        log.info = self._log

    def tearDown(self):
        log.info = self.old_log
        super(DirUtilTestCase, self).tearDown()

    def test_mkpath_remove_tree_verbosity(self):

        mkpath(self.target, verbose=0)
        wanted = []
        self.assertEqual(self._logs, wanted)
        remove_tree(self.root_target, verbose=0)

        mkpath(self.target, verbose=1)
        wanted = ['creating %s' % self.root_target,
                  'creating %s' % self.target]
        self.assertEqual(self._logs, wanted)
        self._logs = []

        remove_tree(self.root_target, verbose=1)
        wanted = ["removing '%s' (and everything under it)" % self.root_target]
        self.assertEqual(self._logs, wanted)

    @unittest.skipIf(sys.platform.startswith('win'),
        "This test is only appropriate for POSIX-like systems.")
    def test_mkpath_with_custom_mode(self):
        # Get and set the current umask value for testing mode bits.
        umask = os.umask(0o002)
        os.umask(umask)
        mkpath(self.target, 0o700)
        self.assertEqual(
            stat.S_IMODE(os.stat(self.target).st_mode), 0o700 & ~umask)
        mkpath(self.target2, 0o555)
        self.assertEqual(
            stat.S_IMODE(os.stat(self.target2).st_mode), 0o555 & ~umask)

    def test_create_tree_verbosity(self):

        create_tree(self.root_target, ['one', 'two', 'three'], verbose=0)
        self.assertEqual(self._logs, [])
        remove_tree(self.root_target, verbose=0)

        wanted = ['creating %s' % self.root_target]
        create_tree(self.root_target, ['one', 'two', 'three'], verbose=1)
        self.assertEqual(self._logs, wanted)

        remove_tree(self.root_target, verbose=0)

    def test_copy_tree_verbosity(self):

        mkpath(self.target, verbose=0)

        copy_tree(self.target, self.target2, verbose=0)
        self.assertEqual(self._logs, [])

        remove_tree(self.root_target, verbose=0)

        mkpath(self.target, verbose=0)
        a_file = os.path.join(self.target, 'ok.txt')
        with open(a_file, 'w') as f:
            f.write('some content')

        wanted = ['copying %s -> %s' % (a_file, self.target2)]
        copy_tree(self.target, self.target2, verbose=1)
        self.assertEqual(self._logs, wanted)

        remove_tree(self.root_target, verbose=0)
        remove_tree(self.target2, verbose=0)

    def test_copy_tree_skips_nfs_temp_files(self):
        mkpath(self.target, verbose=0)

        a_file = os.path.join(self.target, 'ok.txt')
        nfs_file = os.path.join(self.target, '.nfs123abc')
        for f in a_file, nfs_file:
            with open(f, 'w') as fh:
                fh.write('some content')

        copy_tree(self.target, self.target2)
        self.assertEqual(os.listdir(self.target2), ['ok.txt'])

        remove_tree(self.root_target, verbose=0)
        remove_tree(self.target2, verbose=0)

    def test_ensure_relative(self):
        if os.sep == '/':
            self.assertEqual(ensure_relative('/home/foo'), 'home/foo')
            self.assertEqual(ensure_relative('some/path'), 'some/path')
        else:   # \\
            self.assertEqual(ensure_relative('c:\\home\\foo'), 'c:home\\foo')
            self.assertEqual(ensure_relative('home\\foo'), 'home\\foo')

    def test_copy_tree_exception_in_listdir(self):
        """
        An exception in listdir should raise a DistutilsFileError
        """
        with patch("os.listdir", side_effect=OSError()), \
             self.assertRaises(errors.DistutilsFileError):
            src = self.tempdirs[-1]
            dir_util.copy_tree(src, None)


def test_suite():
    return unittest.makeSuite(DirUtilTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_dist.py0000644000175100001710000004551200000000000023525 0ustar00runnerdocker"""Tests for distutils.dist."""
import os
import io
import sys
import unittest
import warnings
import textwrap

from unittest import mock

from distutils.dist import Distribution, fix_help_options
from distutils.cmd import Command

from test.support import (
     captured_stdout, captured_stderr, run_unittest
)
from .py38compat import TESTFN
from distutils.tests import support
from distutils import log


class test_dist(Command):
    """Sample distutils extension command."""

    user_options = [
        ("sample-option=", "S", "help text"),
    ]

    def initialize_options(self):
        self.sample_option = None


class TestDistribution(Distribution):
    """Distribution subclasses that avoids the default search for
    configuration files.

    The ._config_files attribute must be set before
    .parse_config_files() is called.
    """

    def find_config_files(self):
        return self._config_files


class DistributionTestCase(support.LoggingSilencer,
                           support.TempdirManager,
                           support.EnvironGuard,
                           unittest.TestCase):

    def setUp(self):
        super(DistributionTestCase, self).setUp()
        self.argv = sys.argv, sys.argv[:]
        del sys.argv[1:]

    def tearDown(self):
        sys.argv = self.argv[0]
        sys.argv[:] = self.argv[1]
        super(DistributionTestCase, self).tearDown()

    def create_distribution(self, configfiles=()):
        d = TestDistribution()
        d._config_files = configfiles
        d.parse_config_files()
        d.parse_command_line()
        return d

    def test_command_packages_unspecified(self):
        sys.argv.append("build")
        d = self.create_distribution()
        self.assertEqual(d.get_command_packages(), ["distutils.command"])

    def test_command_packages_cmdline(self):
        from distutils.tests.test_dist import test_dist
        sys.argv.extend(["--command-packages",
                         "foo.bar,distutils.tests",
                         "test_dist",
                         "-Ssometext",
                         ])
        d = self.create_distribution()
        # let's actually try to load our test command:
        self.assertEqual(d.get_command_packages(),
                         ["distutils.command", "foo.bar", "distutils.tests"])
        cmd = d.get_command_obj("test_dist")
        self.assertIsInstance(cmd, test_dist)
        self.assertEqual(cmd.sample_option, "sometext")

    @unittest.skipIf(
        'distutils' not in Distribution.parse_config_files.__module__,
        'Cannot test when virtualenv has monkey-patched Distribution.',
    )
    def test_venv_install_options(self):
        sys.argv.append("install")
        self.addCleanup(os.unlink, TESTFN)

        fakepath = '/somedir'

        with open(TESTFN, "w") as f:
            print(("[install]\n"
                   "install-base = {0}\n"
                   "install-platbase = {0}\n"
                   "install-lib = {0}\n"
                   "install-platlib = {0}\n"
                   "install-purelib = {0}\n"
                   "install-headers = {0}\n"
                   "install-scripts = {0}\n"
                   "install-data = {0}\n"
                   "prefix = {0}\n"
                   "exec-prefix = {0}\n"
                   "home = {0}\n"
                   "user = {0}\n"
                   "root = {0}").format(fakepath), file=f)

        # Base case: Not in a Virtual Environment
        with mock.patch.multiple(sys, prefix='/a', base_prefix='/a') as values:
            d = self.create_distribution([TESTFN])

        option_tuple = (TESTFN, fakepath)

        result_dict = {
            'install_base': option_tuple,
            'install_platbase': option_tuple,
            'install_lib': option_tuple,
            'install_platlib': option_tuple,
            'install_purelib': option_tuple,
            'install_headers': option_tuple,
            'install_scripts': option_tuple,
            'install_data': option_tuple,
            'prefix': option_tuple,
            'exec_prefix': option_tuple,
            'home': option_tuple,
            'user': option_tuple,
            'root': option_tuple,
        }

        self.assertEqual(
            sorted(d.command_options.get('install').keys()),
            sorted(result_dict.keys()))

        for (key, value) in d.command_options.get('install').items():
            self.assertEqual(value, result_dict[key])

        # Test case: In a Virtual Environment
        with mock.patch.multiple(sys, prefix='/a', base_prefix='/b') as values:
            d = self.create_distribution([TESTFN])

        for key in result_dict.keys():
            self.assertNotIn(key, d.command_options.get('install', {}))

    def test_command_packages_configfile(self):
        sys.argv.append("build")
        self.addCleanup(os.unlink, TESTFN)
        f = open(TESTFN, "w")
        try:
            print("[global]", file=f)
            print("command_packages = foo.bar, splat", file=f)
        finally:
            f.close()

        d = self.create_distribution([TESTFN])
        self.assertEqual(d.get_command_packages(),
                         ["distutils.command", "foo.bar", "splat"])

        # ensure command line overrides config:
        sys.argv[1:] = ["--command-packages", "spork", "build"]
        d = self.create_distribution([TESTFN])
        self.assertEqual(d.get_command_packages(),
                         ["distutils.command", "spork"])

        # Setting --command-packages to '' should cause the default to
        # be used even if a config file specified something else:
        sys.argv[1:] = ["--command-packages", "", "build"]
        d = self.create_distribution([TESTFN])
        self.assertEqual(d.get_command_packages(), ["distutils.command"])

    def test_empty_options(self):
        # an empty options dictionary should not stay in the
        # list of attributes

        # catching warnings
        warns = []

        def _warn(msg):
            warns.append(msg)

        self.addCleanup(setattr, warnings, 'warn', warnings.warn)
        warnings.warn = _warn
        dist = Distribution(attrs={'author': 'xxx', 'name': 'xxx',
                                   'version': 'xxx', 'url': 'xxxx',
                                   'options': {}})

        self.assertEqual(len(warns), 0)
        self.assertNotIn('options', dir(dist))

    def test_finalize_options(self):
        attrs = {'keywords': 'one,two',
                 'platforms': 'one,two'}

        dist = Distribution(attrs=attrs)
        dist.finalize_options()

        # finalize_option splits platforms and keywords
        self.assertEqual(dist.metadata.platforms, ['one', 'two'])
        self.assertEqual(dist.metadata.keywords, ['one', 'two'])

        attrs = {'keywords': 'foo bar',
                 'platforms': 'foo bar'}
        dist = Distribution(attrs=attrs)
        dist.finalize_options()
        self.assertEqual(dist.metadata.platforms, ['foo bar'])
        self.assertEqual(dist.metadata.keywords, ['foo bar'])

    def test_get_command_packages(self):
        dist = Distribution()
        self.assertEqual(dist.command_packages, None)
        cmds = dist.get_command_packages()
        self.assertEqual(cmds, ['distutils.command'])
        self.assertEqual(dist.command_packages,
                         ['distutils.command'])

        dist.command_packages = 'one,two'
        cmds = dist.get_command_packages()
        self.assertEqual(cmds, ['distutils.command', 'one', 'two'])

    def test_announce(self):
        # make sure the level is known
        dist = Distribution()
        args = ('ok',)
        kwargs = {'level': 'ok2'}
        self.assertRaises(ValueError, dist.announce, args, kwargs)


    def test_find_config_files_disable(self):
        # Ticket #1180: Allow user to disable their home config file.
        temp_home = self.mkdtemp()
        if os.name == 'posix':
            user_filename = os.path.join(temp_home, ".pydistutils.cfg")
        else:
            user_filename = os.path.join(temp_home, "pydistutils.cfg")

        with open(user_filename, 'w') as f:
            f.write('[distutils]\n')

        def _expander(path):
            return temp_home

        old_expander = os.path.expanduser
        os.path.expanduser = _expander
        try:
            d = Distribution()
            all_files = d.find_config_files()

            d = Distribution(attrs={'script_args': ['--no-user-cfg']})
            files = d.find_config_files()
        finally:
            os.path.expanduser = old_expander

        # make sure --no-user-cfg disables the user cfg file
        self.assertEqual(len(all_files)-1, len(files))

class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
                       unittest.TestCase):

    def setUp(self):
        super(MetadataTestCase, self).setUp()
        self.argv = sys.argv, sys.argv[:]

    def tearDown(self):
        sys.argv = self.argv[0]
        sys.argv[:] = self.argv[1]
        super(MetadataTestCase, self).tearDown()

    def format_metadata(self, dist):
        sio = io.StringIO()
        dist.metadata.write_pkg_file(sio)
        return sio.getvalue()

    def test_simple_metadata(self):
        attrs = {"name": "package",
                 "version": "1.0"}
        dist = Distribution(attrs)
        meta = self.format_metadata(dist)
        self.assertIn("Metadata-Version: 1.0", meta)
        self.assertNotIn("provides:", meta.lower())
        self.assertNotIn("requires:", meta.lower())
        self.assertNotIn("obsoletes:", meta.lower())

    def test_provides(self):
        attrs = {"name": "package",
                 "version": "1.0",
                 "provides": ["package", "package.sub"]}
        dist = Distribution(attrs)
        self.assertEqual(dist.metadata.get_provides(),
                         ["package", "package.sub"])
        self.assertEqual(dist.get_provides(),
                         ["package", "package.sub"])
        meta = self.format_metadata(dist)
        self.assertIn("Metadata-Version: 1.1", meta)
        self.assertNotIn("requires:", meta.lower())
        self.assertNotIn("obsoletes:", meta.lower())

    def test_provides_illegal(self):
        self.assertRaises(ValueError, Distribution,
                          {"name": "package",
                           "version": "1.0",
                           "provides": ["my.pkg (splat)"]})

    def test_requires(self):
        attrs = {"name": "package",
                 "version": "1.0",
                 "requires": ["other", "another (==1.0)"]}
        dist = Distribution(attrs)
        self.assertEqual(dist.metadata.get_requires(),
                         ["other", "another (==1.0)"])
        self.assertEqual(dist.get_requires(),
                         ["other", "another (==1.0)"])
        meta = self.format_metadata(dist)
        self.assertIn("Metadata-Version: 1.1", meta)
        self.assertNotIn("provides:", meta.lower())
        self.assertIn("Requires: other", meta)
        self.assertIn("Requires: another (==1.0)", meta)
        self.assertNotIn("obsoletes:", meta.lower())

    def test_requires_illegal(self):
        self.assertRaises(ValueError, Distribution,
                          {"name": "package",
                           "version": "1.0",
                           "requires": ["my.pkg (splat)"]})

    def test_requires_to_list(self):
        attrs = {"name": "package",
                 "requires": iter(["other"])}
        dist = Distribution(attrs)
        self.assertIsInstance(dist.metadata.requires, list)


    def test_obsoletes(self):
        attrs = {"name": "package",
                 "version": "1.0",
                 "obsoletes": ["other", "another (<1.0)"]}
        dist = Distribution(attrs)
        self.assertEqual(dist.metadata.get_obsoletes(),
                         ["other", "another (<1.0)"])
        self.assertEqual(dist.get_obsoletes(),
                         ["other", "another (<1.0)"])
        meta = self.format_metadata(dist)
        self.assertIn("Metadata-Version: 1.1", meta)
        self.assertNotIn("provides:", meta.lower())
        self.assertNotIn("requires:", meta.lower())
        self.assertIn("Obsoletes: other", meta)
        self.assertIn("Obsoletes: another (<1.0)", meta)

    def test_obsoletes_illegal(self):
        self.assertRaises(ValueError, Distribution,
                          {"name": "package",
                           "version": "1.0",
                           "obsoletes": ["my.pkg (splat)"]})

    def test_obsoletes_to_list(self):
        attrs = {"name": "package",
                 "obsoletes": iter(["other"])}
        dist = Distribution(attrs)
        self.assertIsInstance(dist.metadata.obsoletes, list)

    def test_classifier(self):
        attrs = {'name': 'Boa', 'version': '3.0',
                 'classifiers': ['Programming Language :: Python :: 3']}
        dist = Distribution(attrs)
        self.assertEqual(dist.get_classifiers(),
                         ['Programming Language :: Python :: 3'])
        meta = self.format_metadata(dist)
        self.assertIn('Metadata-Version: 1.1', meta)

    def test_classifier_invalid_type(self):
        attrs = {'name': 'Boa', 'version': '3.0',
                 'classifiers': ('Programming Language :: Python :: 3',)}
        with captured_stderr() as error:
            d = Distribution(attrs)
        # should have warning about passing a non-list
        self.assertIn('should be a list', error.getvalue())
        # should be converted to a list
        self.assertIsInstance(d.metadata.classifiers, list)
        self.assertEqual(d.metadata.classifiers,
                         list(attrs['classifiers']))

    def test_keywords(self):
        attrs = {'name': 'Monty', 'version': '1.0',
                 'keywords': ['spam', 'eggs', 'life of brian']}
        dist = Distribution(attrs)
        self.assertEqual(dist.get_keywords(),
                         ['spam', 'eggs', 'life of brian'])

    def test_keywords_invalid_type(self):
        attrs = {'name': 'Monty', 'version': '1.0',
                 'keywords': ('spam', 'eggs', 'life of brian')}
        with captured_stderr() as error:
            d = Distribution(attrs)
        # should have warning about passing a non-list
        self.assertIn('should be a list', error.getvalue())
        # should be converted to a list
        self.assertIsInstance(d.metadata.keywords, list)
        self.assertEqual(d.metadata.keywords, list(attrs['keywords']))

    def test_platforms(self):
        attrs = {'name': 'Monty', 'version': '1.0',
                 'platforms': ['GNU/Linux', 'Some Evil Platform']}
        dist = Distribution(attrs)
        self.assertEqual(dist.get_platforms(),
                         ['GNU/Linux', 'Some Evil Platform'])

    def test_platforms_invalid_types(self):
        attrs = {'name': 'Monty', 'version': '1.0',
                 'platforms': ('GNU/Linux', 'Some Evil Platform')}
        with captured_stderr() as error:
            d = Distribution(attrs)
        # should have warning about passing a non-list
        self.assertIn('should be a list', error.getvalue())
        # should be converted to a list
        self.assertIsInstance(d.metadata.platforms, list)
        self.assertEqual(d.metadata.platforms, list(attrs['platforms']))

    def test_download_url(self):
        attrs = {'name': 'Boa', 'version': '3.0',
                 'download_url': 'http://example.org/boa'}
        dist = Distribution(attrs)
        meta = self.format_metadata(dist)
        self.assertIn('Metadata-Version: 1.1', meta)

    def test_long_description(self):
        long_desc = textwrap.dedent("""\
        example::
              We start here
            and continue here
          and end here.""")
        attrs = {"name": "package",
                 "version": "1.0",
                 "long_description": long_desc}

        dist = Distribution(attrs)
        meta = self.format_metadata(dist)
        meta = meta.replace('\n' + 8 * ' ', '\n')
        self.assertIn(long_desc, meta)

    def test_custom_pydistutils(self):
        # fixes #2166
        # make sure pydistutils.cfg is found
        if os.name == 'posix':
            user_filename = ".pydistutils.cfg"
        else:
            user_filename = "pydistutils.cfg"

        temp_dir = self.mkdtemp()
        user_filename = os.path.join(temp_dir, user_filename)
        f = open(user_filename, 'w')
        try:
            f.write('.')
        finally:
            f.close()

        try:
            dist = Distribution()

            # linux-style
            if sys.platform in ('linux', 'darwin'):
                os.environ['HOME'] = temp_dir
                files = dist.find_config_files()
                self.assertIn(user_filename, files)

            # win32-style
            if sys.platform == 'win32':
                # home drive should be found
                os.environ['USERPROFILE'] = temp_dir
                files = dist.find_config_files()
                self.assertIn(user_filename, files,
                              '%r not found in %r' % (user_filename, files))
        finally:
            os.remove(user_filename)

    def test_fix_help_options(self):
        help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
        fancy_options = fix_help_options(help_tuples)
        self.assertEqual(fancy_options[0], ('a', 'b', 'c'))
        self.assertEqual(fancy_options[1], (1, 2, 3))

    def test_show_help(self):
        # smoke test, just makes sure some help is displayed
        self.addCleanup(log.set_threshold, log._global_log.threshold)
        dist = Distribution()
        sys.argv = []
        dist.help = 1
        dist.script_name = 'setup.py'
        with captured_stdout() as s:
            dist.parse_command_line()

        output = [line for line in s.getvalue().split('\n')
                  if line.strip() != '']
        self.assertTrue(output)


    def test_read_metadata(self):
        attrs = {"name": "package",
                 "version": "1.0",
                 "long_description": "desc",
                 "description": "xxx",
                 "download_url": "http://example.com",
                 "keywords": ['one', 'two'],
                 "requires": ['foo']}

        dist = Distribution(attrs)
        metadata = dist.metadata

        # write it then reloads it
        PKG_INFO = io.StringIO()
        metadata.write_pkg_file(PKG_INFO)
        PKG_INFO.seek(0)
        metadata.read_pkg_file(PKG_INFO)

        self.assertEqual(metadata.name, "package")
        self.assertEqual(metadata.version, "1.0")
        self.assertEqual(metadata.description, "xxx")
        self.assertEqual(metadata.download_url, 'http://example.com')
        self.assertEqual(metadata.keywords, ['one', 'two'])
        self.assertEqual(metadata.platforms, ['UNKNOWN'])
        self.assertEqual(metadata.obsoletes, None)
        self.assertEqual(metadata.requires, ['foo'])

def test_suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(DistributionTestCase))
    suite.addTest(unittest.makeSuite(MetadataTestCase))
    return suite

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_extension.py0000644000175100001710000000535000000000000024572 0ustar00runnerdocker"""Tests for distutils.extension."""
import unittest
import os
import warnings

from test.support import run_unittest
from distutils.extension import read_setup_file, Extension

from .py38compat import check_warnings

class ExtensionTestCase(unittest.TestCase):

    def test_read_setup_file(self):
        # trying to read a Setup file
        # (sample extracted from the PyGame project)
        setup = os.path.join(os.path.dirname(__file__), 'Setup.sample')

        exts = read_setup_file(setup)
        names = [ext.name for ext in exts]
        names.sort()

        # here are the extensions read_setup_file should have created
        # out of the file
        wanted = ['_arraysurfarray', '_camera', '_numericsndarray',
                  '_numericsurfarray', 'base', 'bufferproxy', 'cdrom',
                  'color', 'constants', 'display', 'draw', 'event',
                  'fastevent', 'font', 'gfxdraw', 'image', 'imageext',
                  'joystick', 'key', 'mask', 'mixer', 'mixer_music',
                  'mouse', 'movie', 'overlay', 'pixelarray', 'pypm',
                  'rect', 'rwobject', 'scrap', 'surface', 'surflock',
                  'time', 'transform']

        self.assertEqual(names, wanted)

    def test_extension_init(self):
        # the first argument, which is the name, must be a string
        self.assertRaises(AssertionError, Extension, 1, [])
        ext = Extension('name', [])
        self.assertEqual(ext.name, 'name')

        # the second argument, which is the list of files, must
        # be a list of strings
        self.assertRaises(AssertionError, Extension, 'name', 'file')
        self.assertRaises(AssertionError, Extension, 'name', ['file', 1])
        ext = Extension('name', ['file1', 'file2'])
        self.assertEqual(ext.sources, ['file1', 'file2'])

        # others arguments have defaults
        for attr in ('include_dirs', 'define_macros', 'undef_macros',
                     'library_dirs', 'libraries', 'runtime_library_dirs',
                     'extra_objects', 'extra_compile_args', 'extra_link_args',
                     'export_symbols', 'swig_opts', 'depends'):
            self.assertEqual(getattr(ext, attr), [])

        self.assertEqual(ext.language, None)
        self.assertEqual(ext.optional, None)

        # if there are unknown keyword options, warn about them
        with check_warnings() as w:
            warnings.simplefilter('always')
            ext = Extension('name', ['file1', 'file2'], chic=True)

        self.assertEqual(len(w.warnings), 1)
        self.assertEqual(str(w.warnings[0].message),
                          "Unknown Extension options: 'chic'")

def test_suite():
    return unittest.makeSuite(ExtensionTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_file_util.py0000644000175100001710000001052500000000000024532 0ustar00runnerdocker"""Tests for distutils.file_util."""
import unittest
import os
import errno
from unittest.mock import patch

from distutils.file_util import move_file, copy_file
from distutils import log
from distutils.tests import support
from distutils.errors import DistutilsFileError
from test.support import run_unittest
from .py38compat import unlink


class FileUtilTestCase(support.TempdirManager, unittest.TestCase):

    def _log(self, msg, *args):
        if len(args) > 0:
            self._logs.append(msg % args)
        else:
            self._logs.append(msg)

    def setUp(self):
        super(FileUtilTestCase, self).setUp()
        self._logs = []
        self.old_log = log.info
        log.info = self._log
        tmp_dir = self.mkdtemp()
        self.source = os.path.join(tmp_dir, 'f1')
        self.target = os.path.join(tmp_dir, 'f2')
        self.target_dir = os.path.join(tmp_dir, 'd1')

    def tearDown(self):
        log.info = self.old_log
        super(FileUtilTestCase, self).tearDown()

    def test_move_file_verbosity(self):
        f = open(self.source, 'w')
        try:
            f.write('some content')
        finally:
            f.close()

        move_file(self.source, self.target, verbose=0)
        wanted = []
        self.assertEqual(self._logs, wanted)

        # back to original state
        move_file(self.target, self.source, verbose=0)

        move_file(self.source, self.target, verbose=1)
        wanted = ['moving %s -> %s' % (self.source, self.target)]
        self.assertEqual(self._logs, wanted)

        # back to original state
        move_file(self.target, self.source, verbose=0)

        self._logs = []
        # now the target is a dir
        os.mkdir(self.target_dir)
        move_file(self.source, self.target_dir, verbose=1)
        wanted = ['moving %s -> %s' % (self.source, self.target_dir)]
        self.assertEqual(self._logs, wanted)

    def test_move_file_exception_unpacking_rename(self):
        # see issue 22182
        with patch("os.rename", side_effect=OSError("wrong", 1)), \
             self.assertRaises(DistutilsFileError):
            with open(self.source, 'w') as fobj:
                fobj.write('spam eggs')
            move_file(self.source, self.target, verbose=0)

    def test_move_file_exception_unpacking_unlink(self):
        # see issue 22182
        with patch("os.rename", side_effect=OSError(errno.EXDEV, "wrong")), \
             patch("os.unlink", side_effect=OSError("wrong", 1)), \
             self.assertRaises(DistutilsFileError):
            with open(self.source, 'w') as fobj:
                fobj.write('spam eggs')
            move_file(self.source, self.target, verbose=0)

    def test_copy_file_hard_link(self):
        with open(self.source, 'w') as f:
            f.write('some content')
        # Check first that copy_file() will not fall back on copying the file
        # instead of creating the hard link.
        try:
            os.link(self.source, self.target)
        except OSError as e:
            self.skipTest('os.link: %s' % e)
        else:
            unlink(self.target)
        st = os.stat(self.source)
        copy_file(self.source, self.target, link='hard')
        st2 = os.stat(self.source)
        st3 = os.stat(self.target)
        self.assertTrue(os.path.samestat(st, st2), (st, st2))
        self.assertTrue(os.path.samestat(st2, st3), (st2, st3))
        with open(self.source, 'r') as f:
            self.assertEqual(f.read(), 'some content')

    def test_copy_file_hard_link_failure(self):
        # If hard linking fails, copy_file() falls back on copying file
        # (some special filesystems don't support hard linking even under
        #  Unix, see issue #8876).
        with open(self.source, 'w') as f:
            f.write('some content')
        st = os.stat(self.source)
        with patch("os.link", side_effect=OSError(0, "linking unsupported")):
            copy_file(self.source, self.target, link='hard')
        st2 = os.stat(self.source)
        st3 = os.stat(self.target)
        self.assertTrue(os.path.samestat(st, st2), (st, st2))
        self.assertFalse(os.path.samestat(st2, st3), (st2, st3))
        for fn in (self.source, self.target):
            with open(fn, 'r') as f:
                self.assertEqual(f.read(), 'some content')


def test_suite():
    return unittest.makeSuite(FileUtilTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_filelist.py0000644000175100001710000002721700000000000024377 0ustar00runnerdocker"""Tests for distutils.filelist."""
import os
import re
import unittest
from distutils import debug
from distutils.log import WARN
from distutils.errors import DistutilsTemplateError
from distutils.filelist import glob_to_re, translate_pattern, FileList
from distutils import filelist

from test.support import captured_stdout, run_unittest
from distutils.tests import support

from .py35compat import adapt_glob
from . import py38compat as os_helper


MANIFEST_IN = """\
include ok
include xo
exclude xo
include foo.tmp
include buildout.cfg
global-include *.x
global-include *.txt
global-exclude *.tmp
recursive-include f *.oo
recursive-exclude global *.x
graft dir
prune dir3
"""


def make_local_path(s):
    """Converts '/' in a string to os.sep"""
    return s.replace('/', os.sep)


class FileListTestCase(support.LoggingSilencer,
                       unittest.TestCase):

    def assertNoWarnings(self):
        self.assertEqual(self.get_logs(WARN), [])
        self.clear_logs()

    def assertWarnings(self):
        self.assertGreater(len(self.get_logs(WARN)), 0)
        self.clear_logs()

    def test_glob_to_re(self):
        sep = os.sep
        if os.sep == '\\':
            sep = re.escape(os.sep)

        for glob, regex in (
            # simple cases
            ('foo*', r'(?s:foo[^%(sep)s]*)\Z'),
            ('foo?', r'(?s:foo[^%(sep)s])\Z'),
            ('foo??', r'(?s:foo[^%(sep)s][^%(sep)s])\Z'),
            # special cases
            (r'foo\\*', r'(?s:foo\\\\[^%(sep)s]*)\Z'),
            (r'foo\\\*', r'(?s:foo\\\\\\[^%(sep)s]*)\Z'),
            ('foo????', r'(?s:foo[^%(sep)s][^%(sep)s][^%(sep)s][^%(sep)s])\Z'),
            (r'foo\\??', r'(?s:foo\\\\[^%(sep)s][^%(sep)s])\Z')):
            regex = regex % {'sep': sep}
            self.assertEqual(glob_to_re(glob), adapt_glob(regex))

    def test_process_template_line(self):
        # testing  all MANIFEST.in template patterns
        file_list = FileList()
        l = make_local_path

        # simulated file list
        file_list.allfiles = ['foo.tmp', 'ok', 'xo', 'four.txt',
                              'buildout.cfg',
                              # filelist does not filter out VCS directories,
                              # it's sdist that does
                              l('.hg/last-message.txt'),
                              l('global/one.txt'),
                              l('global/two.txt'),
                              l('global/files.x'),
                              l('global/here.tmp'),
                              l('f/o/f.oo'),
                              l('dir/graft-one'),
                              l('dir/dir2/graft2'),
                              l('dir3/ok'),
                              l('dir3/sub/ok.txt'),
                             ]

        for line in MANIFEST_IN.split('\n'):
            if line.strip() == '':
                continue
            file_list.process_template_line(line)

        wanted = ['ok',
                  'buildout.cfg',
                  'four.txt',
                  l('.hg/last-message.txt'),
                  l('global/one.txt'),
                  l('global/two.txt'),
                  l('f/o/f.oo'),
                  l('dir/graft-one'),
                  l('dir/dir2/graft2'),
                 ]

        self.assertEqual(file_list.files, wanted)

    def test_debug_print(self):
        file_list = FileList()
        with captured_stdout() as stdout:
            file_list.debug_print('xxx')
        self.assertEqual(stdout.getvalue(), '')

        debug.DEBUG = True
        try:
            with captured_stdout() as stdout:
                file_list.debug_print('xxx')
            self.assertEqual(stdout.getvalue(), 'xxx\n')
        finally:
            debug.DEBUG = False

    def test_set_allfiles(self):
        file_list = FileList()
        files = ['a', 'b', 'c']
        file_list.set_allfiles(files)
        self.assertEqual(file_list.allfiles, files)

    def test_remove_duplicates(self):
        file_list = FileList()
        file_list.files = ['a', 'b', 'a', 'g', 'c', 'g']
        # files must be sorted beforehand (sdist does it)
        file_list.sort()
        file_list.remove_duplicates()
        self.assertEqual(file_list.files, ['a', 'b', 'c', 'g'])

    def test_translate_pattern(self):
        # not regex
        self.assertTrue(hasattr(
            translate_pattern('a', anchor=True, is_regex=False),
            'search'))

        # is a regex
        regex = re.compile('a')
        self.assertEqual(
            translate_pattern(regex, anchor=True, is_regex=True),
            regex)

        # plain string flagged as regex
        self.assertTrue(hasattr(
            translate_pattern('a', anchor=True, is_regex=True),
            'search'))

        # glob support
        self.assertTrue(translate_pattern(
            '*.py', anchor=True, is_regex=False).search('filelist.py'))

    def test_exclude_pattern(self):
        # return False if no match
        file_list = FileList()
        self.assertFalse(file_list.exclude_pattern('*.py'))

        # return True if files match
        file_list = FileList()
        file_list.files = ['a.py', 'b.py']
        self.assertTrue(file_list.exclude_pattern('*.py'))

        # test excludes
        file_list = FileList()
        file_list.files = ['a.py', 'a.txt']
        file_list.exclude_pattern('*.py')
        self.assertEqual(file_list.files, ['a.txt'])

    def test_include_pattern(self):
        # return False if no match
        file_list = FileList()
        file_list.set_allfiles([])
        self.assertFalse(file_list.include_pattern('*.py'))

        # return True if files match
        file_list = FileList()
        file_list.set_allfiles(['a.py', 'b.txt'])
        self.assertTrue(file_list.include_pattern('*.py'))

        # test * matches all files
        file_list = FileList()
        self.assertIsNone(file_list.allfiles)
        file_list.set_allfiles(['a.py', 'b.txt'])
        file_list.include_pattern('*')
        self.assertEqual(file_list.allfiles, ['a.py', 'b.txt'])

    def test_process_template(self):
        l = make_local_path
        # invalid lines
        file_list = FileList()
        for action in ('include', 'exclude', 'global-include',
                       'global-exclude', 'recursive-include',
                       'recursive-exclude', 'graft', 'prune', 'blarg'):
            self.assertRaises(DistutilsTemplateError,
                              file_list.process_template_line, action)

        # include
        file_list = FileList()
        file_list.set_allfiles(['a.py', 'b.txt', l('d/c.py')])

        file_list.process_template_line('include *.py')
        self.assertEqual(file_list.files, ['a.py'])
        self.assertNoWarnings()

        file_list.process_template_line('include *.rb')
        self.assertEqual(file_list.files, ['a.py'])
        self.assertWarnings()

        # exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', l('d/c.py')]

        file_list.process_template_line('exclude *.py')
        self.assertEqual(file_list.files, ['b.txt', l('d/c.py')])
        self.assertNoWarnings()

        file_list.process_template_line('exclude *.rb')
        self.assertEqual(file_list.files, ['b.txt', l('d/c.py')])
        self.assertWarnings()

        # global-include
        file_list = FileList()
        file_list.set_allfiles(['a.py', 'b.txt', l('d/c.py')])

        file_list.process_template_line('global-include *.py')
        self.assertEqual(file_list.files, ['a.py', l('d/c.py')])
        self.assertNoWarnings()

        file_list.process_template_line('global-include *.rb')
        self.assertEqual(file_list.files, ['a.py', l('d/c.py')])
        self.assertWarnings()

        # global-exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', l('d/c.py')]

        file_list.process_template_line('global-exclude *.py')
        self.assertEqual(file_list.files, ['b.txt'])
        self.assertNoWarnings()

        file_list.process_template_line('global-exclude *.rb')
        self.assertEqual(file_list.files, ['b.txt'])
        self.assertWarnings()

        # recursive-include
        file_list = FileList()
        file_list.set_allfiles(['a.py', l('d/b.py'), l('d/c.txt'),
                                l('d/d/e.py')])

        file_list.process_template_line('recursive-include d *.py')
        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
        self.assertNoWarnings()

        file_list.process_template_line('recursive-include e *.py')
        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
        self.assertWarnings()

        # recursive-exclude
        file_list = FileList()
        file_list.files = ['a.py', l('d/b.py'), l('d/c.txt'), l('d/d/e.py')]

        file_list.process_template_line('recursive-exclude d *.py')
        self.assertEqual(file_list.files, ['a.py', l('d/c.txt')])
        self.assertNoWarnings()

        file_list.process_template_line('recursive-exclude e *.py')
        self.assertEqual(file_list.files, ['a.py', l('d/c.txt')])
        self.assertWarnings()

        # graft
        file_list = FileList()
        file_list.set_allfiles(['a.py', l('d/b.py'), l('d/d/e.py'),
                                l('f/f.py')])

        file_list.process_template_line('graft d')
        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
        self.assertNoWarnings()

        file_list.process_template_line('graft e')
        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
        self.assertWarnings()

        # prune
        file_list = FileList()
        file_list.files = ['a.py', l('d/b.py'), l('d/d/e.py'), l('f/f.py')]

        file_list.process_template_line('prune d')
        self.assertEqual(file_list.files, ['a.py', l('f/f.py')])
        self.assertNoWarnings()

        file_list.process_template_line('prune e')
        self.assertEqual(file_list.files, ['a.py', l('f/f.py')])
        self.assertWarnings()


class FindAllTestCase(unittest.TestCase):
    @os_helper.skip_unless_symlink
    def test_missing_symlink(self):
        with os_helper.temp_cwd():
            os.symlink('foo', 'bar')
            self.assertEqual(filelist.findall(), [])

    def test_basic_discovery(self):
        """
        When findall is called with no parameters or with
        '.' as the parameter, the dot should be omitted from
        the results.
        """
        with os_helper.temp_cwd():
            os.mkdir('foo')
            file1 = os.path.join('foo', 'file1.txt')
            os_helper.create_empty_file(file1)
            os.mkdir('bar')
            file2 = os.path.join('bar', 'file2.txt')
            os_helper.create_empty_file(file2)
            expected = [file2, file1]
            self.assertEqual(sorted(filelist.findall()), expected)

    def test_non_local_discovery(self):
        """
        When findall is called with another path, the full
        path name should be returned.
        """
        with os_helper.temp_dir() as temp_dir:
            file1 = os.path.join(temp_dir, 'file1.txt')
            os_helper.create_empty_file(file1)
            expected = [file1]
            self.assertEqual(filelist.findall(temp_dir), expected)

    @os_helper.skip_unless_symlink
    def test_symlink_loop(self):
        with os_helper.temp_dir() as temp_dir:
            link = os.path.join(temp_dir, 'link-to-parent')
            content = os.path.join(temp_dir, 'somefile')
            os_helper.create_empty_file(content)
            os.symlink('.', link)
            files = filelist.findall(temp_dir)
            assert len(files) == 1


def test_suite():
    return unittest.TestSuite([
        unittest.makeSuite(FileListTestCase),
        unittest.makeSuite(FindAllTestCase),
    ])


if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_install.py0000644000175100001710000002073200000000000024225 0ustar00runnerdocker"""Tests for distutils.command.install."""

import os
import sys
import unittest
import site

from test.support import captured_stdout, run_unittest

from distutils import sysconfig
from distutils.command.install import install
from distutils.command import install as install_module
from distutils.command.build_ext import build_ext
from distutils.command.install import INSTALL_SCHEMES
from distutils.core import Distribution
from distutils.errors import DistutilsOptionError
from distutils.extension import Extension

from distutils.tests import support
from test import support as test_support


def _make_ext_name(modname):
    return modname + sysconfig.get_config_var('EXT_SUFFIX')


class InstallTestCase(support.TempdirManager,
                      support.EnvironGuard,
                      support.LoggingSilencer,
                      unittest.TestCase):

    def test_home_installation_scheme(self):
        # This ensure two things:
        # - that --home generates the desired set of directory names
        # - test --home is supported on all platforms
        builddir = self.mkdtemp()
        destination = os.path.join(builddir, "installation")

        dist = Distribution({"name": "foopkg"})
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(builddir, "setup.py")
        dist.command_obj["build"] = support.DummyCommand(
            build_base=builddir,
            build_lib=os.path.join(builddir, "lib"),
            )

        cmd = install(dist)
        cmd.home = destination
        cmd.ensure_finalized()

        self.assertEqual(cmd.install_base, destination)
        self.assertEqual(cmd.install_platbase, destination)

        def check_path(got, expected):
            got = os.path.normpath(got)
            expected = os.path.normpath(expected)
            self.assertEqual(got, expected)

        libdir = os.path.join(destination, "lib", "python")
        check_path(cmd.install_lib, libdir)
        _platlibdir = getattr(sys, "platlibdir", "lib")
        platlibdir = os.path.join(destination, _platlibdir, "python")
        check_path(cmd.install_platlib, platlibdir)
        check_path(cmd.install_purelib, libdir)
        check_path(cmd.install_headers,
                   os.path.join(destination, "include", "python", "foopkg"))
        check_path(cmd.install_scripts, os.path.join(destination, "bin"))
        check_path(cmd.install_data, destination)

    def test_user_site(self):
        # test install with --user
        # preparing the environment for the test
        self.old_user_base = site.USER_BASE
        self.old_user_site = site.USER_SITE
        self.tmpdir = self.mkdtemp()
        self.user_base = os.path.join(self.tmpdir, 'B')
        self.user_site = os.path.join(self.tmpdir, 'S')
        site.USER_BASE = self.user_base
        site.USER_SITE = self.user_site
        install_module.USER_BASE = self.user_base
        install_module.USER_SITE = self.user_site

        def _expanduser(path):
            return self.tmpdir
        self.old_expand = os.path.expanduser
        os.path.expanduser = _expanduser

        def cleanup():
            site.USER_BASE = self.old_user_base
            site.USER_SITE = self.old_user_site
            install_module.USER_BASE = self.old_user_base
            install_module.USER_SITE = self.old_user_site
            os.path.expanduser = self.old_expand

        self.addCleanup(cleanup)

        for key in ('nt_user', 'posix_user'):
            self.assertIn(key, INSTALL_SCHEMES)

        dist = Distribution({'name': 'xx'})
        cmd = install(dist)

        # making sure the user option is there
        options = [name for name, short, lable in
                   cmd.user_options]
        self.assertIn('user', options)

        # setting a value
        cmd.user = 1

        # user base and site shouldn't be created yet
        self.assertFalse(os.path.exists(self.user_base))
        self.assertFalse(os.path.exists(self.user_site))

        # let's run finalize
        cmd.ensure_finalized()

        # now they should
        self.assertTrue(os.path.exists(self.user_base))
        self.assertTrue(os.path.exists(self.user_site))

        self.assertIn('userbase', cmd.config_vars)
        self.assertIn('usersite', cmd.config_vars)

    def test_handle_extra_path(self):
        dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})
        cmd = install(dist)

        # two elements
        cmd.handle_extra_path()
        self.assertEqual(cmd.extra_path, ['path', 'dirs'])
        self.assertEqual(cmd.extra_dirs, 'dirs')
        self.assertEqual(cmd.path_file, 'path')

        # one element
        cmd.extra_path = ['path']
        cmd.handle_extra_path()
        self.assertEqual(cmd.extra_path, ['path'])
        self.assertEqual(cmd.extra_dirs, 'path')
        self.assertEqual(cmd.path_file, 'path')

        # none
        dist.extra_path = cmd.extra_path = None
        cmd.handle_extra_path()
        self.assertEqual(cmd.extra_path, None)
        self.assertEqual(cmd.extra_dirs, '')
        self.assertEqual(cmd.path_file, None)

        # three elements (no way !)
        cmd.extra_path = 'path,dirs,again'
        self.assertRaises(DistutilsOptionError, cmd.handle_extra_path)

    def test_finalize_options(self):
        dist = Distribution({'name': 'xx'})
        cmd = install(dist)

        # must supply either prefix/exec-prefix/home or
        # install-base/install-platbase -- not both
        cmd.prefix = 'prefix'
        cmd.install_base = 'base'
        self.assertRaises(DistutilsOptionError, cmd.finalize_options)

        # must supply either home or prefix/exec-prefix -- not both
        cmd.install_base = None
        cmd.home = 'home'
        self.assertRaises(DistutilsOptionError, cmd.finalize_options)

        # can't combine user with prefix/exec_prefix/home or
        # install_(plat)base
        cmd.prefix = None
        cmd.user = 'user'
        self.assertRaises(DistutilsOptionError, cmd.finalize_options)

    def test_record(self):
        install_dir = self.mkdtemp()
        project_dir, dist = self.create_dist(py_modules=['hello'],
                                             scripts=['sayhi'])
        os.chdir(project_dir)
        self.write_file('hello.py', "def main(): print('o hai')")
        self.write_file('sayhi', 'from hello import main; main()')

        cmd = install(dist)
        dist.command_obj['install'] = cmd
        cmd.root = install_dir
        cmd.record = os.path.join(project_dir, 'filelist')
        cmd.ensure_finalized()
        cmd.run()

        f = open(cmd.record)
        try:
            content = f.read()
        finally:
            f.close()

        found = [os.path.basename(line) for line in content.splitlines()]
        expected = ['hello.py', 'hello.%s.pyc' % sys.implementation.cache_tag,
                    'sayhi',
                    'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2]]
        self.assertEqual(found, expected)

    def test_record_extensions(self):
        cmd = test_support.missing_compiler_executable()
        if cmd is not None:
            self.skipTest('The %r command is not found' % cmd)
        install_dir = self.mkdtemp()
        project_dir, dist = self.create_dist(ext_modules=[
            Extension('xx', ['xxmodule.c'])])
        os.chdir(project_dir)
        support.copy_xxmodule_c(project_dir)

        buildextcmd = build_ext(dist)
        support.fixup_build_ext(buildextcmd)
        buildextcmd.ensure_finalized()

        cmd = install(dist)
        dist.command_obj['install'] = cmd
        dist.command_obj['build_ext'] = buildextcmd
        cmd.root = install_dir
        cmd.record = os.path.join(project_dir, 'filelist')
        cmd.ensure_finalized()
        cmd.run()

        f = open(cmd.record)
        try:
            content = f.read()
        finally:
            f.close()

        found = [os.path.basename(line) for line in content.splitlines()]
        expected = [_make_ext_name('xx'),
                    'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2]]
        self.assertEqual(found, expected)

    def test_debug_mode(self):
        # this covers the code called when DEBUG is set
        old_logs_len = len(self.logs)
        install_module.DEBUG = True
        try:
            with captured_stdout():
                self.test_record()
        finally:
            install_module.DEBUG = False
        self.assertGreater(len(self.logs), old_logs_len)


def test_suite():
    return unittest.makeSuite(InstallTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_install_data.py0000644000175100001710000000502100000000000025210 0ustar00runnerdocker"""Tests for distutils.command.install_data."""
import os
import unittest

from distutils.command.install_data import install_data
from distutils.tests import support
from test.support import run_unittest

class InstallDataTestCase(support.TempdirManager,
                          support.LoggingSilencer,
                          support.EnvironGuard,
                          unittest.TestCase):

    def test_simple_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = install_data(dist)
        cmd.install_dir = inst = os.path.join(pkg_dir, 'inst')

        # data_files can contain
        #  - simple files
        #  - a tuple with a path, and a list of file
        one = os.path.join(pkg_dir, 'one')
        self.write_file(one, 'xxx')
        inst2 = os.path.join(pkg_dir, 'inst2')
        two = os.path.join(pkg_dir, 'two')
        self.write_file(two, 'xxx')

        cmd.data_files = [one, (inst2, [two])]
        self.assertEqual(cmd.get_inputs(), [one, (inst2, [two])])

        # let's run the command
        cmd.ensure_finalized()
        cmd.run()

        # let's check the result
        self.assertEqual(len(cmd.get_outputs()), 2)
        rtwo = os.path.split(two)[-1]
        self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
        rone = os.path.split(one)[-1]
        self.assertTrue(os.path.exists(os.path.join(inst, rone)))
        cmd.outfiles = []

        # let's try with warn_dir one
        cmd.warn_dir = 1
        cmd.ensure_finalized()
        cmd.run()

        # let's check the result
        self.assertEqual(len(cmd.get_outputs()), 2)
        self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
        self.assertTrue(os.path.exists(os.path.join(inst, rone)))
        cmd.outfiles = []

        # now using root and empty dir
        cmd.root = os.path.join(pkg_dir, 'root')
        inst3 = os.path.join(cmd.install_dir, 'inst3')
        inst4 = os.path.join(pkg_dir, 'inst4')
        three = os.path.join(cmd.install_dir, 'three')
        self.write_file(three, 'xx')
        cmd.data_files = [one, (inst2, [two]),
                          ('inst3', [three]),
                          (inst4, [])]
        cmd.ensure_finalized()
        cmd.run()

        # let's check the result
        self.assertEqual(len(cmd.get_outputs()), 4)
        self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
        self.assertTrue(os.path.exists(os.path.join(inst, rone)))

def test_suite():
    return unittest.makeSuite(InstallDataTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_install_headers.py0000644000175100001710000000232600000000000025717 0ustar00runnerdocker"""Tests for distutils.command.install_headers."""
import os
import unittest

from distutils.command.install_headers import install_headers
from distutils.tests import support
from test.support import run_unittest

class InstallHeadersTestCase(support.TempdirManager,
                             support.LoggingSilencer,
                             support.EnvironGuard,
                             unittest.TestCase):

    def test_simple_run(self):
        # we have two headers
        header_list = self.mkdtemp()
        header1 = os.path.join(header_list, 'header1')
        header2 = os.path.join(header_list, 'header2')
        self.write_file(header1)
        self.write_file(header2)
        headers = [header1, header2]

        pkg_dir, dist = self.create_dist(headers=headers)
        cmd = install_headers(dist)
        self.assertEqual(cmd.get_inputs(), headers)

        # let's run the command
        cmd.install_dir = os.path.join(pkg_dir, 'inst')
        cmd.ensure_finalized()
        cmd.run()

        # let's check the results
        self.assertEqual(len(cmd.get_outputs()), 2)

def test_suite():
    return unittest.makeSuite(InstallHeadersTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_install_lib.py0000644000175100001710000000760600000000000025060 0ustar00runnerdocker"""Tests for distutils.command.install_data."""
import sys
import os
import importlib.util
import unittest

from distutils.command.install_lib import install_lib
from distutils.extension import Extension
from distutils.tests import support
from distutils.errors import DistutilsOptionError
from test.support import run_unittest


class InstallLibTestCase(support.TempdirManager,
                         support.LoggingSilencer,
                         support.EnvironGuard,
                         unittest.TestCase):

    def test_finalize_options(self):
        dist = self.create_dist()[1]
        cmd = install_lib(dist)

        cmd.finalize_options()
        self.assertEqual(cmd.compile, 1)
        self.assertEqual(cmd.optimize, 0)

        # optimize must be 0, 1, or 2
        cmd.optimize = 'foo'
        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
        cmd.optimize = '4'
        self.assertRaises(DistutilsOptionError, cmd.finalize_options)

        cmd.optimize = '2'
        cmd.finalize_options()
        self.assertEqual(cmd.optimize, 2)

    @unittest.skipIf(sys.dont_write_bytecode, 'byte-compile disabled')
    def test_byte_compile(self):
        project_dir, dist = self.create_dist()
        os.chdir(project_dir)
        cmd = install_lib(dist)
        cmd.compile = cmd.optimize = 1

        f = os.path.join(project_dir, 'foo.py')
        self.write_file(f, '# python file')
        cmd.byte_compile([f])
        pyc_file = importlib.util.cache_from_source('foo.py', optimization='')
        pyc_opt_file = importlib.util.cache_from_source('foo.py',
                                                    optimization=cmd.optimize)
        self.assertTrue(os.path.exists(pyc_file))
        self.assertTrue(os.path.exists(pyc_opt_file))

    def test_get_outputs(self):
        project_dir, dist = self.create_dist()
        os.chdir(project_dir)
        os.mkdir('spam')
        cmd = install_lib(dist)

        # setting up a dist environment
        cmd.compile = cmd.optimize = 1
        cmd.install_dir = self.mkdtemp()
        f = os.path.join(project_dir, 'spam', '__init__.py')
        self.write_file(f, '# python package')
        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
        cmd.distribution.packages = ['spam']
        cmd.distribution.script_name = 'setup.py'

        # get_outputs should return 4 elements: spam/__init__.py and .pyc,
        # foo.import-tag-abiflags.so / foo.pyd
        outputs = cmd.get_outputs()
        self.assertEqual(len(outputs), 4, outputs)

    def test_get_inputs(self):
        project_dir, dist = self.create_dist()
        os.chdir(project_dir)
        os.mkdir('spam')
        cmd = install_lib(dist)

        # setting up a dist environment
        cmd.compile = cmd.optimize = 1
        cmd.install_dir = self.mkdtemp()
        f = os.path.join(project_dir, 'spam', '__init__.py')
        self.write_file(f, '# python package')
        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
        cmd.distribution.packages = ['spam']
        cmd.distribution.script_name = 'setup.py'

        # get_inputs should return 2 elements: spam/__init__.py and
        # foo.import-tag-abiflags.so / foo.pyd
        inputs = cmd.get_inputs()
        self.assertEqual(len(inputs), 2, inputs)

    def test_dont_write_bytecode(self):
        # makes sure byte_compile is not used
        dist = self.create_dist()[1]
        cmd = install_lib(dist)
        cmd.compile = 1
        cmd.optimize = 1

        old_dont_write_bytecode = sys.dont_write_bytecode
        sys.dont_write_bytecode = True
        try:
            cmd.byte_compile([])
        finally:
            sys.dont_write_bytecode = old_dont_write_bytecode

        self.assertIn('byte-compiling is disabled',
                      self.logs[0][1] % self.logs[0][2])


def test_suite():
    return unittest.makeSuite(InstallLibTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_install_scripts.py0000644000175100001710000000510100000000000025765 0ustar00runnerdocker"""Tests for distutils.command.install_scripts."""

import os
import unittest

from distutils.command.install_scripts import install_scripts
from distutils.core import Distribution

from distutils.tests import support
from test.support import run_unittest


class InstallScriptsTestCase(support.TempdirManager,
                             support.LoggingSilencer,
                             unittest.TestCase):

    def test_default_settings(self):
        dist = Distribution()
        dist.command_obj["build"] = support.DummyCommand(
            build_scripts="/foo/bar")
        dist.command_obj["install"] = support.DummyCommand(
            install_scripts="/splat/funk",
            force=1,
            skip_build=1,
            )
        cmd = install_scripts(dist)
        self.assertFalse(cmd.force)
        self.assertFalse(cmd.skip_build)
        self.assertIsNone(cmd.build_dir)
        self.assertIsNone(cmd.install_dir)

        cmd.finalize_options()

        self.assertTrue(cmd.force)
        self.assertTrue(cmd.skip_build)
        self.assertEqual(cmd.build_dir, "/foo/bar")
        self.assertEqual(cmd.install_dir, "/splat/funk")

    def test_installation(self):
        source = self.mkdtemp()
        expected = []

        def write_script(name, text):
            expected.append(name)
            f = open(os.path.join(source, name), "w")
            try:
                f.write(text)
            finally:
                f.close()

        write_script("script1.py", ("#! /usr/bin/env python2.3\n"
                                    "# bogus script w/ Python sh-bang\n"
                                    "pass\n"))
        write_script("script2.py", ("#!/usr/bin/python\n"
                                    "# bogus script w/ Python sh-bang\n"
                                    "pass\n"))
        write_script("shell.sh", ("#!/bin/sh\n"
                                  "# bogus shell script w/ sh-bang\n"
                                  "exit 0\n"))

        target = self.mkdtemp()
        dist = Distribution()
        dist.command_obj["build"] = support.DummyCommand(build_scripts=source)
        dist.command_obj["install"] = support.DummyCommand(
            install_scripts=target,
            force=1,
            skip_build=1,
            )
        cmd = install_scripts(dist)
        cmd.finalize_options()
        cmd.run()

        installed = os.listdir(target)
        for name in expected:
            self.assertIn(name, installed)


def test_suite():
    return unittest.makeSuite(InstallScriptsTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_log.py0000644000175100001710000000351000000000000023333 0ustar00runnerdocker"""Tests for distutils.log"""

import io
import sys
import unittest
from test.support import swap_attr, run_unittest

from distutils import log

class TestLog(unittest.TestCase):
    def test_non_ascii(self):
        # Issues #8663, #34421: test that non-encodable text is escaped with
        # backslashreplace error handler and encodable non-ASCII text is
        # output as is.
        for errors in ('strict', 'backslashreplace', 'surrogateescape',
                       'replace', 'ignore'):
            with self.subTest(errors=errors):
                stdout = io.TextIOWrapper(io.BytesIO(),
                                          encoding='cp437', errors=errors)
                stderr = io.TextIOWrapper(io.BytesIO(),
                                          encoding='cp437', errors=errors)
                old_threshold = log.set_threshold(log.DEBUG)
                try:
                    with swap_attr(sys, 'stdout', stdout), \
                         swap_attr(sys, 'stderr', stderr):
                        log.debug('Dεbug\tMėssãge')
                        log.fatal('Fαtal\tÈrrÅr')
                finally:
                    log.set_threshold(old_threshold)

                stdout.seek(0)
                self.assertEqual(stdout.read().rstrip(),
                        'Dεbug\tM?ss?ge' if errors == 'replace' else
                        'Dεbug\tMssge' if errors == 'ignore' else
                        'Dεbug\tM\\u0117ss\\xe3ge')
                stderr.seek(0)
                self.assertEqual(stderr.read().rstrip(),
                        'Fαtal\t?rr?r' if errors == 'replace' else
                        'Fαtal\trrr' if errors == 'ignore' else
                        'Fαtal\t\\xc8rr\\u014dr')

def test_suite():
    return unittest.makeSuite(TestLog)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_msvc9compiler.py0000644000175100001710000001362600000000000025357 0ustar00runnerdocker"""Tests for distutils.msvc9compiler."""
import sys
import unittest
import os

from distutils.errors import DistutilsPlatformError
from distutils.tests import support
from test.support import run_unittest

# A manifest with the only assembly reference being the msvcrt assembly, so
# should have the assembly completely stripped.  Note that although the
# assembly has a  reference the assembly is removed - that is
# currently a "feature", not a bug :)
_MANIFEST_WITH_ONLY_MSVC_REFERENCE = """\


  
    
      
        
        
      
    
  
  
    
      
      
    
  

"""

# A manifest with references to assemblies other than msvcrt.  When processed,
# this assembly should be returned with just the msvcrt part removed.
_MANIFEST_WITH_MULTIPLE_REFERENCES = """\


  
    
      
        
        
      
    
  
  
    
      
      
    
  
  
    
      
    
  

"""

_CLEANED_MANIFEST = """\


  
    
      
        
        
      
    
  
  

  
  
    
      
    
  
"""

if sys.platform=="win32":
    from distutils.msvccompiler import get_build_version
    if get_build_version()>=8.0:
        SKIP_MESSAGE = None
    else:
        SKIP_MESSAGE = "These tests are only for MSVC8.0 or above"
else:
    SKIP_MESSAGE = "These tests are only for win32"

@unittest.skipUnless(SKIP_MESSAGE is None, SKIP_MESSAGE)
class msvc9compilerTestCase(support.TempdirManager,
                            unittest.TestCase):

    def test_no_compiler(self):
        # makes sure query_vcvarsall raises
        # a DistutilsPlatformError if the compiler
        # is not found
        from distutils.msvc9compiler import query_vcvarsall
        def _find_vcvarsall(version):
            return None

        from distutils import msvc9compiler
        old_find_vcvarsall = msvc9compiler.find_vcvarsall
        msvc9compiler.find_vcvarsall = _find_vcvarsall
        try:
            self.assertRaises(DistutilsPlatformError, query_vcvarsall,
                             'wont find this version')
        finally:
            msvc9compiler.find_vcvarsall = old_find_vcvarsall

    def test_reg_class(self):
        from distutils.msvc9compiler import Reg
        self.assertRaises(KeyError, Reg.get_value, 'xxx', 'xxx')

        # looking for values that should exist on all
        # windows registry versions.
        path = r'Control Panel\Desktop'
        v = Reg.get_value(path, 'dragfullwindows')
        self.assertIn(v, ('0', '1', '2'))

        import winreg
        HKCU = winreg.HKEY_CURRENT_USER
        keys = Reg.read_keys(HKCU, 'xxxx')
        self.assertEqual(keys, None)

        keys = Reg.read_keys(HKCU, r'Control Panel')
        self.assertIn('Desktop', keys)

    def test_remove_visual_c_ref(self):
        from distutils.msvc9compiler import MSVCCompiler
        tempdir = self.mkdtemp()
        manifest = os.path.join(tempdir, 'manifest')
        f = open(manifest, 'w')
        try:
            f.write(_MANIFEST_WITH_MULTIPLE_REFERENCES)
        finally:
            f.close()

        compiler = MSVCCompiler()
        compiler._remove_visual_c_ref(manifest)

        # see what we got
        f = open(manifest)
        try:
            # removing trailing spaces
            content = '\n'.join([line.rstrip() for line in f.readlines()])
        finally:
            f.close()

        # makes sure the manifest was properly cleaned
        self.assertEqual(content, _CLEANED_MANIFEST)

    def test_remove_entire_manifest(self):
        from distutils.msvc9compiler import MSVCCompiler
        tempdir = self.mkdtemp()
        manifest = os.path.join(tempdir, 'manifest')
        f = open(manifest, 'w')
        try:
            f.write(_MANIFEST_WITH_ONLY_MSVC_REFERENCE)
        finally:
            f.close()

        compiler = MSVCCompiler()
        got = compiler._remove_visual_c_ref(manifest)
        self.assertIsNone(got)


def test_suite():
    return unittest.makeSuite(msvc9compilerTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_msvccompiler.py0000644000175100001710000001062300000000000025260 0ustar00runnerdocker"""Tests for distutils._msvccompiler."""
import sys
import unittest
import os
import threading

from distutils.errors import DistutilsPlatformError
from distutils.tests import support
from test.support import run_unittest


SKIP_MESSAGE = (None if sys.platform == "win32" else
                "These tests are only for win32")

@unittest.skipUnless(SKIP_MESSAGE is None, SKIP_MESSAGE)
class msvccompilerTestCase(support.TempdirManager,
                            unittest.TestCase):

    def test_no_compiler(self):
        import distutils._msvccompiler as _msvccompiler
        # makes sure query_vcvarsall raises
        # a DistutilsPlatformError if the compiler
        # is not found
        def _find_vcvarsall(plat_spec):
            return None, None

        old_find_vcvarsall = _msvccompiler._find_vcvarsall
        _msvccompiler._find_vcvarsall = _find_vcvarsall
        try:
            self.assertRaises(DistutilsPlatformError,
                              _msvccompiler._get_vc_env,
                             'wont find this version')
        finally:
            _msvccompiler._find_vcvarsall = old_find_vcvarsall

    def test_get_vc_env_unicode(self):
        import distutils._msvccompiler as _msvccompiler

        test_var = 'ṰḖṤṪ┅ṼẨṜ'
        test_value = '₃â´â‚…'

        # Ensure we don't early exit from _get_vc_env
        old_distutils_use_sdk = os.environ.pop('DISTUTILS_USE_SDK', None)
        os.environ[test_var] = test_value
        try:
            env = _msvccompiler._get_vc_env('x86')
            self.assertIn(test_var.lower(), env)
            self.assertEqual(test_value, env[test_var.lower()])
        finally:
            os.environ.pop(test_var)
            if old_distutils_use_sdk:
                os.environ['DISTUTILS_USE_SDK'] = old_distutils_use_sdk

    def test_get_vc2017(self):
        import distutils._msvccompiler as _msvccompiler

        # This function cannot be mocked, so pass it if we find VS 2017
        # and mark it skipped if we do not.
        version, path = _msvccompiler._find_vc2017()
        if version:
            self.assertGreaterEqual(version, 15)
            self.assertTrue(os.path.isdir(path))
        else:
            raise unittest.SkipTest("VS 2017 is not installed")

    def test_get_vc2015(self):
        import distutils._msvccompiler as _msvccompiler

        # This function cannot be mocked, so pass it if we find VS 2015
        # and mark it skipped if we do not.
        version, path = _msvccompiler._find_vc2015()
        if version:
            self.assertGreaterEqual(version, 14)
            self.assertTrue(os.path.isdir(path))
        else:
            raise unittest.SkipTest("VS 2015 is not installed")


class CheckThread(threading.Thread):
    exc_info = None

    def run(self):
        try:
            super().run()
        except Exception:
            self.exc_info = sys.exc_info()

    def __bool__(self):
        return not self.exc_info


class TestSpawn(unittest.TestCase):
    def test_concurrent_safe(self):
        """
        Concurrent calls to spawn should have consistent results.
        """
        import distutils._msvccompiler as _msvccompiler
        compiler = _msvccompiler.MSVCCompiler()
        compiler._paths = "expected"
        inner_cmd = 'import os; assert os.environ["PATH"] == "expected"'
        command = ['python', '-c', inner_cmd]

        threads = [
            CheckThread(target=compiler.spawn, args=[command])
            for n in range(100)
        ]
        for thread in threads:
            thread.start()
        for thread in threads:
            thread.join()
        assert all(threads)

    def test_concurrent_safe_fallback(self):
        """
        If CCompiler.spawn has been monkey-patched without support
        for an env, it should still execute.
        """
        import distutils._msvccompiler as _msvccompiler
        from distutils import ccompiler
        compiler = _msvccompiler.MSVCCompiler()
        compiler._paths = "expected"

        def CCompiler_spawn(self, cmd):
            "A spawn without an env argument."
            assert os.environ["PATH"] == "expected"

        with unittest.mock.patch.object(
                ccompiler.CCompiler, 'spawn', CCompiler_spawn):
            compiler.spawn(["n/a"])

        assert os.environ.get("PATH") != "expected"


def test_suite():
    return unittest.makeSuite(msvccompilerTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_register.py0000644000175100001710000002307500000000000024406 0ustar00runnerdocker"""Tests for distutils.command.register."""
import os
import unittest
import getpass
import urllib
import warnings

from test.support import run_unittest

from .py38compat import check_warnings

from distutils.command import register as register_module
from distutils.command.register import register
from distutils.errors import DistutilsSetupError
from distutils.log import INFO

from distutils.tests.test_config import BasePyPIRCCommandTestCase

try:
    import docutils
except ImportError:
    docutils = None

PYPIRC_NOPASSWORD = """\
[distutils]

index-servers =
    server1

[server1]
username:me
"""

WANTED_PYPIRC = """\
[distutils]
index-servers =
    pypi

[pypi]
username:tarek
password:password
"""

class Inputs(object):
    """Fakes user inputs."""
    def __init__(self, *answers):
        self.answers = answers
        self.index = 0

    def __call__(self, prompt=''):
        try:
            return self.answers[self.index]
        finally:
            self.index += 1

class FakeOpener(object):
    """Fakes a PyPI server"""
    def __init__(self):
        self.reqs = []

    def __call__(self, *args):
        return self

    def open(self, req, data=None, timeout=None):
        self.reqs.append(req)
        return self

    def read(self):
        return b'xxx'

    def getheader(self, name, default=None):
        return {
            'content-type': 'text/plain; charset=utf-8',
            }.get(name.lower(), default)


class RegisterTestCase(BasePyPIRCCommandTestCase):

    def setUp(self):
        super(RegisterTestCase, self).setUp()
        # patching the password prompt
        self._old_getpass = getpass.getpass
        def _getpass(prompt):
            return 'password'
        getpass.getpass = _getpass
        urllib.request._opener = None
        self.old_opener = urllib.request.build_opener
        self.conn = urllib.request.build_opener = FakeOpener()

    def tearDown(self):
        getpass.getpass = self._old_getpass
        urllib.request._opener = None
        urllib.request.build_opener = self.old_opener
        super(RegisterTestCase, self).tearDown()

    def _get_cmd(self, metadata=None):
        if metadata is None:
            metadata = {'url': 'xxx', 'author': 'xxx',
                        'author_email': 'xxx',
                        'name': 'xxx', 'version': 'xxx'}
        pkg_info, dist = self.create_dist(**metadata)
        return register(dist)

    def test_create_pypirc(self):
        # this test makes sure a .pypirc file
        # is created when requested.

        # let's create a register instance
        cmd = self._get_cmd()

        # we shouldn't have a .pypirc file yet
        self.assertFalse(os.path.exists(self.rc))

        # patching input and getpass.getpass
        # so register gets happy
        #
        # Here's what we are faking :
        # use your existing login (choice 1.)
        # Username : 'tarek'
        # Password : 'password'
        # Save your login (y/N)? : 'y'
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

        # we should have a brand new .pypirc file
        self.assertTrue(os.path.exists(self.rc))

        # with the content similar to WANTED_PYPIRC
        f = open(self.rc)
        try:
            content = f.read()
            self.assertEqual(content, WANTED_PYPIRC)
        finally:
            f.close()

        # now let's make sure the .pypirc file generated
        # really works : we shouldn't be asked anything
        # if we run the command again
        def _no_way(prompt=''):
            raise AssertionError(prompt)
        register_module.input = _no_way

        cmd.show_response = 1
        cmd.run()

        # let's see what the server received : we should
        # have 2 similar requests
        self.assertEqual(len(self.conn.reqs), 2)
        req1 = dict(self.conn.reqs[0].headers)
        req2 = dict(self.conn.reqs[1].headers)

        self.assertEqual(req1['Content-length'], '1374')
        self.assertEqual(req2['Content-length'], '1374')
        self.assertIn(b'xxx', self.conn.reqs[1].data)

    def test_password_not_in_file(self):

        self.write_file(self.rc, PYPIRC_NOPASSWORD)
        cmd = self._get_cmd()
        cmd._set_config()
        cmd.finalize_options()
        cmd.send_metadata()

        # dist.password should be set
        # therefore used afterwards by other commands
        self.assertEqual(cmd.distribution.password, 'password')

    def test_registering(self):
        # this test runs choice 2
        cmd = self._get_cmd()
        inputs = Inputs('2', 'tarek', 'tarek@ziade.org')
        register_module.input = inputs.__call__
        try:
            # let's run the command
            cmd.run()
        finally:
            del register_module.input

        # we should have send a request
        self.assertEqual(len(self.conn.reqs), 1)
        req = self.conn.reqs[0]
        headers = dict(req.headers)
        self.assertEqual(headers['Content-length'], '608')
        self.assertIn(b'tarek', req.data)

    def test_password_reset(self):
        # this test runs choice 3
        cmd = self._get_cmd()
        inputs = Inputs('3', 'tarek@ziade.org')
        register_module.input = inputs.__call__
        try:
            # let's run the command
            cmd.run()
        finally:
            del register_module.input

        # we should have send a request
        self.assertEqual(len(self.conn.reqs), 1)
        req = self.conn.reqs[0]
        headers = dict(req.headers)
        self.assertEqual(headers['Content-length'], '290')
        self.assertIn(b'tarek', req.data)

    @unittest.skipUnless(docutils is not None, 'needs docutils')
    def test_strict(self):
        # testing the script option
        # when on, the register command stops if
        # the metadata is incomplete or if
        # long_description is not reSt compliant

        # empty metadata
        cmd = self._get_cmd({})
        cmd.ensure_finalized()
        cmd.strict = 1
        self.assertRaises(DistutilsSetupError, cmd.run)

        # metadata are OK but long_description is broken
        metadata = {'url': 'xxx', 'author': 'xxx',
                    'author_email': 'éxéxé',
                    'name': 'xxx', 'version': 'xxx',
                    'long_description': 'title\n==\n\ntext'}

        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = 1
        self.assertRaises(DistutilsSetupError, cmd.run)

        # now something that works
        metadata['long_description'] = 'title\n=====\n\ntext'
        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = 1
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

        # strict is not by default
        cmd = self._get_cmd()
        cmd.ensure_finalized()
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

        # and finally a Unicode test (bug #12114)
        metadata = {'url': 'xxx', 'author': '\u00c9ric',
                    'author_email': 'xxx', 'name': 'xxx',
                    'version': 'xxx',
                    'description': 'Something about esszet \u00df',
                    'long_description': 'More things about esszet \u00df'}

        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = 1
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

    @unittest.skipUnless(docutils is not None, 'needs docutils')
    def test_register_invalid_long_description(self):
        description = ':funkie:`str`'  # mimic Sphinx-specific markup
        metadata = {'url': 'xxx', 'author': 'xxx',
                    'author_email': 'xxx',
                    'name': 'xxx', 'version': 'xxx',
                    'long_description': description}
        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = True
        inputs = Inputs('2', 'tarek', 'tarek@ziade.org')
        register_module.input = inputs
        self.addCleanup(delattr, register_module, 'input')

        self.assertRaises(DistutilsSetupError, cmd.run)

    def test_check_metadata_deprecated(self):
        # makes sure make_metadata is deprecated
        cmd = self._get_cmd()
        with check_warnings() as w:
            warnings.simplefilter("always")
            cmd.check_metadata()
            self.assertEqual(len(w.warnings), 1)

    def test_list_classifiers(self):
        cmd = self._get_cmd()
        cmd.list_classifiers = 1
        cmd.run()
        results = self.get_logs(INFO)
        self.assertEqual(results, ['running check', 'xxx'])

    def test_show_response(self):
        # test that the --show-response option return a well formatted response
        cmd = self._get_cmd()
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        cmd.show_response = 1
        try:
            cmd.run()
        finally:
            del register_module.input

        results = self.get_logs(INFO)
        self.assertEqual(results[3], 75 * '-' + '\nxxx\n' + 75 * '-')


def test_suite():
    return unittest.makeSuite(RegisterTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_sdist.py0000644000175100001710000004125700000000000023712 0ustar00runnerdocker"""Tests for distutils.command.sdist."""
import os
import tarfile
import unittest
import warnings
import zipfile
from os.path import join
from textwrap import dedent
from test.support import captured_stdout, run_unittest

from .py38compat import check_warnings

try:
    import zlib
    ZLIB_SUPPORT = True
except ImportError:
    ZLIB_SUPPORT = False

try:
    import grp
    import pwd
    UID_GID_SUPPORT = True
except ImportError:
    UID_GID_SUPPORT = False

from distutils.command.sdist import sdist, show_formats
from distutils.core import Distribution
from distutils.tests.test_config import BasePyPIRCCommandTestCase
from distutils.errors import DistutilsOptionError
from distutils.spawn import find_executable
from distutils.log import WARN
from distutils.filelist import FileList
from distutils.archive_util import ARCHIVE_FORMATS

SETUP_PY = """
from distutils.core import setup
import somecode

setup(name='fake')
"""

MANIFEST = """\
# file GENERATED by distutils, do NOT edit
README
buildout.cfg
inroot.txt
setup.py
data%(sep)sdata.dt
scripts%(sep)sscript.py
some%(sep)sfile.txt
some%(sep)sother_file.txt
somecode%(sep)s__init__.py
somecode%(sep)sdoc.dat
somecode%(sep)sdoc.txt
"""

class SDistTestCase(BasePyPIRCCommandTestCase):

    def setUp(self):
        # PyPIRCCommandTestCase creates a temp dir already
        # and put it in self.tmp_dir
        super(SDistTestCase, self).setUp()
        # setting up an environment
        self.old_path = os.getcwd()
        os.mkdir(join(self.tmp_dir, 'somecode'))
        os.mkdir(join(self.tmp_dir, 'dist'))
        # a package, and a README
        self.write_file((self.tmp_dir, 'README'), 'xxx')
        self.write_file((self.tmp_dir, 'somecode', '__init__.py'), '#')
        self.write_file((self.tmp_dir, 'setup.py'), SETUP_PY)
        os.chdir(self.tmp_dir)

    def tearDown(self):
        # back to normal
        os.chdir(self.old_path)
        super(SDistTestCase, self).tearDown()

    def get_cmd(self, metadata=None):
        """Returns a cmd"""
        if metadata is None:
            metadata = {'name': 'fake', 'version': '1.0',
                        'url': 'xxx', 'author': 'xxx',
                        'author_email': 'xxx'}
        dist = Distribution(metadata)
        dist.script_name = 'setup.py'
        dist.packages = ['somecode']
        dist.include_package_data = True
        cmd = sdist(dist)
        cmd.dist_dir = 'dist'
        return dist, cmd

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_prune_file_list(self):
        # this test creates a project with some VCS dirs and an NFS rename
        # file, then launches sdist to check they get pruned on all systems

        # creating VCS directories with some files in them
        os.mkdir(join(self.tmp_dir, 'somecode', '.svn'))
        self.write_file((self.tmp_dir, 'somecode', '.svn', 'ok.py'), 'xxx')

        os.mkdir(join(self.tmp_dir, 'somecode', '.hg'))
        self.write_file((self.tmp_dir, 'somecode', '.hg',
                         'ok'), 'xxx')

        os.mkdir(join(self.tmp_dir, 'somecode', '.git'))
        self.write_file((self.tmp_dir, 'somecode', '.git',
                         'ok'), 'xxx')

        self.write_file((self.tmp_dir, 'somecode', '.nfs0001'), 'xxx')

        # now building a sdist
        dist, cmd = self.get_cmd()

        # zip is available universally
        # (tar might not be installed under win32)
        cmd.formats = ['zip']

        cmd.ensure_finalized()
        cmd.run()

        # now let's check what we have
        dist_folder = join(self.tmp_dir, 'dist')
        files = os.listdir(dist_folder)
        self.assertEqual(files, ['fake-1.0.zip'])

        zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
        try:
            content = zip_file.namelist()
        finally:
            zip_file.close()

        # making sure everything has been pruned correctly
        expected = ['', 'PKG-INFO', 'README', 'setup.py',
                    'somecode/', 'somecode/__init__.py']
        self.assertEqual(sorted(content), ['fake-1.0/' + x for x in expected])

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    @unittest.skipIf(find_executable('tar') is None,
                     "The tar command is not found")
    @unittest.skipIf(find_executable('gzip') is None,
                     "The gzip command is not found")
    def test_make_distribution(self):
        # now building a sdist
        dist, cmd = self.get_cmd()

        # creating a gztar then a tar
        cmd.formats = ['gztar', 'tar']
        cmd.ensure_finalized()
        cmd.run()

        # making sure we have two files
        dist_folder = join(self.tmp_dir, 'dist')
        result = os.listdir(dist_folder)
        result.sort()
        self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'])

        os.remove(join(dist_folder, 'fake-1.0.tar'))
        os.remove(join(dist_folder, 'fake-1.0.tar.gz'))

        # now trying a tar then a gztar
        cmd.formats = ['tar', 'gztar']

        cmd.ensure_finalized()
        cmd.run()

        result = os.listdir(dist_folder)
        result.sort()
        self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'])

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_add_defaults(self):

        # http://bugs.python.org/issue2279

        # add_default should also include
        # data_files and package_data
        dist, cmd = self.get_cmd()

        # filling data_files by pointing files
        # in package_data
        dist.package_data = {'': ['*.cfg', '*.dat'],
                             'somecode': ['*.txt']}
        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
        self.write_file((self.tmp_dir, 'somecode', 'doc.dat'), '#')

        # adding some data in data_files
        data_dir = join(self.tmp_dir, 'data')
        os.mkdir(data_dir)
        self.write_file((data_dir, 'data.dt'), '#')
        some_dir = join(self.tmp_dir, 'some')
        os.mkdir(some_dir)
        # make sure VCS directories are pruned (#14004)
        hg_dir = join(self.tmp_dir, '.hg')
        os.mkdir(hg_dir)
        self.write_file((hg_dir, 'last-message.txt'), '#')
        # a buggy regex used to prevent this from working on windows (#6884)
        self.write_file((self.tmp_dir, 'buildout.cfg'), '#')
        self.write_file((self.tmp_dir, 'inroot.txt'), '#')
        self.write_file((some_dir, 'file.txt'), '#')
        self.write_file((some_dir, 'other_file.txt'), '#')

        dist.data_files = [('data', ['data/data.dt',
                                     'buildout.cfg',
                                     'inroot.txt',
                                     'notexisting']),
                           'some/file.txt',
                           'some/other_file.txt']

        # adding a script
        script_dir = join(self.tmp_dir, 'scripts')
        os.mkdir(script_dir)
        self.write_file((script_dir, 'script.py'), '#')
        dist.scripts = [join('scripts', 'script.py')]

        cmd.formats = ['zip']
        cmd.use_defaults = True

        cmd.ensure_finalized()
        cmd.run()

        # now let's check what we have
        dist_folder = join(self.tmp_dir, 'dist')
        files = os.listdir(dist_folder)
        self.assertEqual(files, ['fake-1.0.zip'])

        zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
        try:
            content = zip_file.namelist()
        finally:
            zip_file.close()

        # making sure everything was added
        expected = ['', 'PKG-INFO', 'README', 'buildout.cfg',
                    'data/', 'data/data.dt', 'inroot.txt',
                    'scripts/', 'scripts/script.py', 'setup.py',
                    'some/', 'some/file.txt', 'some/other_file.txt',
                    'somecode/', 'somecode/__init__.py', 'somecode/doc.dat',
                    'somecode/doc.txt']
        self.assertEqual(sorted(content), ['fake-1.0/' + x for x in expected])

        # checking the MANIFEST
        f = open(join(self.tmp_dir, 'MANIFEST'))
        try:
            manifest = f.read()
        finally:
            f.close()
        self.assertEqual(manifest, MANIFEST % {'sep': os.sep})

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_metadata_check_option(self):
        # testing the `medata-check` option
        dist, cmd = self.get_cmd(metadata={})

        # this should raise some warnings !
        # with the `check` subcommand
        cmd.ensure_finalized()
        cmd.run()
        warnings = [msg for msg in self.get_logs(WARN) if
                    msg.startswith('warning: check:')]
        self.assertEqual(len(warnings), 2)

        # trying with a complete set of metadata
        self.clear_logs()
        dist, cmd = self.get_cmd()
        cmd.ensure_finalized()
        cmd.metadata_check = 0
        cmd.run()
        warnings = [msg for msg in self.get_logs(WARN) if
                    msg.startswith('warning: check:')]
        self.assertEqual(len(warnings), 0)

    def test_check_metadata_deprecated(self):
        # makes sure make_metadata is deprecated
        dist, cmd = self.get_cmd()
        with check_warnings() as w:
            warnings.simplefilter("always")
            cmd.check_metadata()
            self.assertEqual(len(w.warnings), 1)

    def test_show_formats(self):
        with captured_stdout() as stdout:
            show_formats()

        # the output should be a header line + one line per format
        num_formats = len(ARCHIVE_FORMATS.keys())
        output = [line for line in stdout.getvalue().split('\n')
                  if line.strip().startswith('--formats=')]
        self.assertEqual(len(output), num_formats)

    def test_finalize_options(self):
        dist, cmd = self.get_cmd()
        cmd.finalize_options()

        # default options set by finalize
        self.assertEqual(cmd.manifest, 'MANIFEST')
        self.assertEqual(cmd.template, 'MANIFEST.in')
        self.assertEqual(cmd.dist_dir, 'dist')

        # formats has to be a string splitable on (' ', ',') or
        # a stringlist
        cmd.formats = 1
        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
        cmd.formats = ['zip']
        cmd.finalize_options()

        # formats has to be known
        cmd.formats = 'supazipa'
        self.assertRaises(DistutilsOptionError, cmd.finalize_options)

    # the following tests make sure there is a nice error message instead
    # of a traceback when parsing an invalid manifest template

    def _check_template(self, content):
        dist, cmd = self.get_cmd()
        os.chdir(self.tmp_dir)
        self.write_file('MANIFEST.in', content)
        cmd.ensure_finalized()
        cmd.filelist = FileList()
        cmd.read_template()
        warnings = self.get_logs(WARN)
        self.assertEqual(len(warnings), 1)

    def test_invalid_template_unknown_command(self):
        self._check_template('taunt knights *')

    def test_invalid_template_wrong_arguments(self):
        # this manifest command takes one argument
        self._check_template('prune')

    @unittest.skipIf(os.name != 'nt', 'test relevant for Windows only')
    def test_invalid_template_wrong_path(self):
        # on Windows, trailing slashes are not allowed
        # this used to crash instead of raising a warning: #8286
        self._check_template('include examples/')

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_get_file_list(self):
        # make sure MANIFEST is recalculated
        dist, cmd = self.get_cmd()

        # filling data_files by pointing files in package_data
        dist.package_data = {'somecode': ['*.txt']}
        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
        cmd.formats = ['gztar']
        cmd.ensure_finalized()
        cmd.run()

        f = open(cmd.manifest)
        try:
            manifest = [line.strip() for line in f.read().split('\n')
                        if line.strip() != '']
        finally:
            f.close()

        self.assertEqual(len(manifest), 5)

        # adding a file
        self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#')

        # make sure build_py is reinitialized, like a fresh run
        build_py = dist.get_command_obj('build_py')
        build_py.finalized = False
        build_py.ensure_finalized()

        cmd.run()

        f = open(cmd.manifest)
        try:
            manifest2 = [line.strip() for line in f.read().split('\n')
                         if line.strip() != '']
        finally:
            f.close()

        # do we have the new file in MANIFEST ?
        self.assertEqual(len(manifest2), 6)
        self.assertIn('doc2.txt', manifest2[-1])

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_manifest_marker(self):
        # check that autogenerated MANIFESTs have a marker
        dist, cmd = self.get_cmd()
        cmd.ensure_finalized()
        cmd.run()

        f = open(cmd.manifest)
        try:
            manifest = [line.strip() for line in f.read().split('\n')
                        if line.strip() != '']
        finally:
            f.close()

        self.assertEqual(manifest[0],
                         '# file GENERATED by distutils, do NOT edit')

    @unittest.skipUnless(ZLIB_SUPPORT, "Need zlib support to run")
    def test_manifest_comments(self):
        # make sure comments don't cause exceptions or wrong includes
        contents = dedent("""\
            # bad.py
            #bad.py
            good.py
            """)
        dist, cmd = self.get_cmd()
        cmd.ensure_finalized()
        self.write_file((self.tmp_dir, cmd.manifest), contents)
        self.write_file((self.tmp_dir, 'good.py'), '# pick me!')
        self.write_file((self.tmp_dir, 'bad.py'), "# don't pick me!")
        self.write_file((self.tmp_dir, '#bad.py'), "# don't pick me!")
        cmd.run()
        self.assertEqual(cmd.filelist.files, ['good.py'])

    @unittest.skipUnless(ZLIB_SUPPORT, 'Need zlib support to run')
    def test_manual_manifest(self):
        # check that a MANIFEST without a marker is left alone
        dist, cmd = self.get_cmd()
        cmd.formats = ['gztar']
        cmd.ensure_finalized()
        self.write_file((self.tmp_dir, cmd.manifest), 'README.manual')
        self.write_file((self.tmp_dir, 'README.manual'),
                         'This project maintains its MANIFEST file itself.')
        cmd.run()
        self.assertEqual(cmd.filelist.files, ['README.manual'])

        f = open(cmd.manifest)
        try:
            manifest = [line.strip() for line in f.read().split('\n')
                        if line.strip() != '']
        finally:
            f.close()

        self.assertEqual(manifest, ['README.manual'])

        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
        archive = tarfile.open(archive_name)
        try:
            filenames = [tarinfo.name for tarinfo in archive]
        finally:
            archive.close()
        self.assertEqual(sorted(filenames), ['fake-1.0', 'fake-1.0/PKG-INFO',
                                             'fake-1.0/README.manual'])

    @unittest.skipUnless(ZLIB_SUPPORT, "requires zlib")
    @unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support")
    @unittest.skipIf(find_executable('tar') is None,
                     "The tar command is not found")
    @unittest.skipIf(find_executable('gzip') is None,
                     "The gzip command is not found")
    def test_make_distribution_owner_group(self):
        # now building a sdist
        dist, cmd = self.get_cmd()

        # creating a gztar and specifying the owner+group
        cmd.formats = ['gztar']
        cmd.owner = pwd.getpwuid(0)[0]
        cmd.group = grp.getgrgid(0)[0]
        cmd.ensure_finalized()
        cmd.run()

        # making sure we have the good rights
        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
        archive = tarfile.open(archive_name)
        try:
            for member in archive.getmembers():
                self.assertEqual(member.uid, 0)
                self.assertEqual(member.gid, 0)
        finally:
            archive.close()

        # building a sdist again
        dist, cmd = self.get_cmd()

        # creating a gztar
        cmd.formats = ['gztar']
        cmd.ensure_finalized()
        cmd.run()

        # making sure we have the good rights
        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
        archive = tarfile.open(archive_name)

        # note that we are not testing the group ownership here
        # because, depending on the platforms and the container
        # rights (see #7408)
        try:
            for member in archive.getmembers():
                self.assertEqual(member.uid, os.getuid())
        finally:
            archive.close()

def test_suite():
    return unittest.makeSuite(SDistTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_spawn.py0000644000175100001710000001252100000000000023704 0ustar00runnerdocker"""Tests for distutils.spawn."""
import os
import stat
import sys
import unittest.mock
from test.support import run_unittest

from .py35compat import unix_shell
from . import py38compat as os_helper

from distutils.spawn import find_executable
from distutils.spawn import spawn
from distutils.errors import DistutilsExecError
from distutils.tests import support

class SpawnTestCase(support.TempdirManager,
                    support.LoggingSilencer,
                    unittest.TestCase):

    @unittest.skipUnless(os.name in ('nt', 'posix'),
                         'Runs only under posix or nt')
    def test_spawn(self):
        tmpdir = self.mkdtemp()

        # creating something executable
        # through the shell that returns 1
        if sys.platform != 'win32':
            exe = os.path.join(tmpdir, 'foo.sh')
            self.write_file(exe, '#!%s\nexit 1' % unix_shell)
        else:
            exe = os.path.join(tmpdir, 'foo.bat')
            self.write_file(exe, 'exit 1')

        os.chmod(exe, 0o777)
        self.assertRaises(DistutilsExecError, spawn, [exe])

        # now something that works
        if sys.platform != 'win32':
            exe = os.path.join(tmpdir, 'foo.sh')
            self.write_file(exe, '#!%s\nexit 0' % unix_shell)
        else:
            exe = os.path.join(tmpdir, 'foo.bat')
            self.write_file(exe, 'exit 0')

        os.chmod(exe, 0o777)
        spawn([exe])  # should work without any error

    def test_find_executable(self):
        with os_helper.temp_dir() as tmp_dir:
            # use TESTFN to get a pseudo-unique filename
            program_noeext = os_helper.TESTFN
            # Give the temporary program an ".exe" suffix for all.
            # It's needed on Windows and not harmful on other platforms.
            program = program_noeext + ".exe"

            filename = os.path.join(tmp_dir, program)
            with open(filename, "wb"):
                pass
            os.chmod(filename, stat.S_IXUSR)

            # test path parameter
            rv = find_executable(program, path=tmp_dir)
            self.assertEqual(rv, filename)

            if sys.platform == 'win32':
                # test without ".exe" extension
                rv = find_executable(program_noeext, path=tmp_dir)
                self.assertEqual(rv, filename)

            # test find in the current directory
            with os_helper.change_cwd(tmp_dir):
                rv = find_executable(program)
                self.assertEqual(rv, program)

            # test non-existent program
            dont_exist_program = "dontexist_" + program
            rv = find_executable(dont_exist_program , path=tmp_dir)
            self.assertIsNone(rv)

            # PATH='': no match, except in the current directory
            with os_helper.EnvironmentVarGuard() as env:
                env['PATH'] = ''
                with unittest.mock.patch('distutils.spawn.os.confstr',
                                         return_value=tmp_dir, create=True), \
                     unittest.mock.patch('distutils.spawn.os.defpath',
                                         tmp_dir):
                    rv = find_executable(program)
                    self.assertIsNone(rv)

                    # look in current directory
                    with os_helper.change_cwd(tmp_dir):
                        rv = find_executable(program)
                        self.assertEqual(rv, program)

            # PATH=':': explicitly looks in the current directory
            with os_helper.EnvironmentVarGuard() as env:
                env['PATH'] = os.pathsep
                with unittest.mock.patch('distutils.spawn.os.confstr',
                                         return_value='', create=True), \
                     unittest.mock.patch('distutils.spawn.os.defpath', ''):
                    rv = find_executable(program)
                    self.assertIsNone(rv)

                    # look in current directory
                    with os_helper.change_cwd(tmp_dir):
                        rv = find_executable(program)
                        self.assertEqual(rv, program)

            # missing PATH: test os.confstr("CS_PATH") and os.defpath
            with os_helper.EnvironmentVarGuard() as env:
                env.pop('PATH', None)

                # without confstr
                with unittest.mock.patch('distutils.spawn.os.confstr',
                                         side_effect=ValueError,
                                         create=True), \
                     unittest.mock.patch('distutils.spawn.os.defpath',
                                         tmp_dir):
                    rv = find_executable(program)
                    self.assertEqual(rv, filename)

                # with confstr
                with unittest.mock.patch('distutils.spawn.os.confstr',
                                         return_value=tmp_dir, create=True), \
                     unittest.mock.patch('distutils.spawn.os.defpath', ''):
                    rv = find_executable(program)
                    self.assertEqual(rv, filename)

    def test_spawn_missing_exe(self):
        with self.assertRaises(DistutilsExecError) as ctx:
            spawn(['does-not-exist'])
        self.assertIn("command 'does-not-exist' failed", str(ctx.exception))


def test_suite():
    return unittest.makeSuite(SpawnTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_sysconfig.py0000644000175100001710000002662500000000000024572 0ustar00runnerdocker"""Tests for distutils.sysconfig."""
import contextlib
import os
import shutil
import subprocess
import sys
import textwrap
import unittest

from distutils import sysconfig
from distutils.ccompiler import get_default_compiler
from distutils.unixccompiler import UnixCCompiler
from distutils.tests import support
from test.support import run_unittest, swap_item

from .py38compat import TESTFN
from .py38compat import check_warnings


class SysconfigTestCase(support.EnvironGuard, unittest.TestCase):
    def setUp(self):
        super(SysconfigTestCase, self).setUp()
        self.makefile = None

    def tearDown(self):
        if self.makefile is not None:
            os.unlink(self.makefile)
        self.cleanup_testfn()
        super(SysconfigTestCase, self).tearDown()

    def cleanup_testfn(self):
        if os.path.isfile(TESTFN):
            os.remove(TESTFN)
        elif os.path.isdir(TESTFN):
            shutil.rmtree(TESTFN)

    def test_get_config_h_filename(self):
        config_h = sysconfig.get_config_h_filename()
        self.assertTrue(os.path.isfile(config_h), config_h)

    def test_get_python_lib(self):
        # XXX doesn't work on Linux when Python was never installed before
        #self.assertTrue(os.path.isdir(lib_dir), lib_dir)
        # test for pythonxx.lib?
        self.assertNotEqual(sysconfig.get_python_lib(),
                            sysconfig.get_python_lib(prefix=TESTFN))

    def test_get_config_vars(self):
        cvars = sysconfig.get_config_vars()
        self.assertIsInstance(cvars, dict)
        self.assertTrue(cvars)

    @unittest.skip('sysconfig.IS_PYPY')
    def test_srcdir(self):
        # See Issues #15322, #15364.
        srcdir = sysconfig.get_config_var('srcdir')

        self.assertTrue(os.path.isabs(srcdir), srcdir)
        self.assertTrue(os.path.isdir(srcdir), srcdir)

        if sysconfig.python_build:
            # The python executable has not been installed so srcdir
            # should be a full source checkout.
            Python_h = os.path.join(srcdir, 'Include', 'Python.h')
            self.assertTrue(os.path.exists(Python_h), Python_h)
            self.assertTrue(sysconfig._is_python_source_dir(srcdir))
        elif os.name == 'posix':
            self.assertEqual(
                os.path.dirname(sysconfig.get_makefile_filename()),
                srcdir)

    def test_srcdir_independent_of_cwd(self):
        # srcdir should be independent of the current working directory
        # See Issues #15322, #15364.
        srcdir = sysconfig.get_config_var('srcdir')
        cwd = os.getcwd()
        try:
            os.chdir('..')
            srcdir2 = sysconfig.get_config_var('srcdir')
        finally:
            os.chdir(cwd)
        self.assertEqual(srcdir, srcdir2)

    def customize_compiler(self):
        # make sure AR gets caught
        class compiler:
            compiler_type = 'unix'
            executables = UnixCCompiler.executables

            def __init__(self):
                self.exes = {}

            def set_executables(self, **kw):
                for k, v in kw.items():
                    self.exes[k] = v

        sysconfig_vars = {
            'AR': 'sc_ar',
            'CC': 'sc_cc',
            'CXX': 'sc_cxx',
            'ARFLAGS': '--sc-arflags',
            'CFLAGS': '--sc-cflags',
            'CCSHARED': '--sc-ccshared',
            'LDSHARED': 'sc_ldshared',
            'SHLIB_SUFFIX': 'sc_shutil_suffix',

            # On macOS, disable _osx_support.customize_compiler()
            'CUSTOMIZED_OSX_COMPILER': 'True',
        }

        comp = compiler()
        with contextlib.ExitStack() as cm:
            for key, value in sysconfig_vars.items():
                cm.enter_context(swap_item(sysconfig._config_vars, key, value))
            sysconfig.customize_compiler(comp)

        return comp

    @unittest.skipUnless(get_default_compiler() == 'unix',
                         'not testing if default compiler is not unix')
    def test_customize_compiler(self):
        # Make sure that sysconfig._config_vars is initialized
        sysconfig.get_config_vars()

        os.environ['AR'] = 'env_ar'
        os.environ['CC'] = 'env_cc'
        os.environ['CPP'] = 'env_cpp'
        os.environ['CXX'] = 'env_cxx --env-cxx-flags'
        os.environ['LDSHARED'] = 'env_ldshared'
        os.environ['LDFLAGS'] = '--env-ldflags'
        os.environ['ARFLAGS'] = '--env-arflags'
        os.environ['CFLAGS'] = '--env-cflags'
        os.environ['CPPFLAGS'] = '--env-cppflags'
        os.environ['RANLIB'] = 'env_ranlib'

        comp = self.customize_compiler()
        self.assertEqual(comp.exes['archiver'],
                         'env_ar --env-arflags')
        self.assertEqual(comp.exes['preprocessor'],
                         'env_cpp --env-cppflags')
        self.assertEqual(comp.exes['compiler'],
                         'env_cc --sc-cflags --env-cflags --env-cppflags')
        self.assertEqual(comp.exes['compiler_so'],
                         ('env_cc --sc-cflags '
                          '--env-cflags ''--env-cppflags --sc-ccshared'))
        self.assertEqual(comp.exes['compiler_cxx'],
                         'env_cxx --env-cxx-flags')
        self.assertEqual(comp.exes['linker_exe'],
                         'env_cc')
        self.assertEqual(comp.exes['linker_so'],
                         ('env_ldshared --env-ldflags --env-cflags'
                          ' --env-cppflags'))
        self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')

        if sys.platform == "darwin":
            self.assertEqual(comp.exes['ranlib'],
                         'env_ranlib')
        else:
            self.assertTrue('ranlib' not in comp.exes)

        del os.environ['AR']
        del os.environ['CC']
        del os.environ['CPP']
        del os.environ['CXX']
        del os.environ['LDSHARED']
        del os.environ['LDFLAGS']
        del os.environ['ARFLAGS']
        del os.environ['CFLAGS']
        del os.environ['CPPFLAGS']
        del os.environ['RANLIB']

        comp = self.customize_compiler()
        self.assertEqual(comp.exes['archiver'],
                         'sc_ar --sc-arflags')
        self.assertEqual(comp.exes['preprocessor'],
                         'sc_cc -E')
        self.assertEqual(comp.exes['compiler'],
                         'sc_cc --sc-cflags')
        self.assertEqual(comp.exes['compiler_so'],
                         'sc_cc --sc-cflags --sc-ccshared')
        self.assertEqual(comp.exes['compiler_cxx'],
                         'sc_cxx')
        self.assertEqual(comp.exes['linker_exe'],
                         'sc_cc')
        self.assertEqual(comp.exes['linker_so'],
                         'sc_ldshared')
        self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')
        self.assertTrue('ranlib' not in comp.exes)

    def test_parse_makefile_base(self):
        self.makefile = TESTFN
        fd = open(self.makefile, 'w')
        try:
            fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=LIB'" '\n')
            fd.write('VAR=$OTHER\nOTHER=foo')
        finally:
            fd.close()
        d = sysconfig.parse_makefile(self.makefile)
        self.assertEqual(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'",
                             'OTHER': 'foo'})

    def test_parse_makefile_literal_dollar(self):
        self.makefile = TESTFN
        fd = open(self.makefile, 'w')
        try:
            fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
            fd.write('VAR=$OTHER\nOTHER=foo')
        finally:
            fd.close()
        d = sysconfig.parse_makefile(self.makefile)
        self.assertEqual(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
                             'OTHER': 'foo'})


    def test_sysconfig_module(self):
        import sysconfig as global_sysconfig
        self.assertEqual(global_sysconfig.get_config_var('CFLAGS'),
                         sysconfig.get_config_var('CFLAGS'))
        self.assertEqual(global_sysconfig.get_config_var('LDFLAGS'),
                         sysconfig.get_config_var('LDFLAGS'))

    @unittest.skipIf(sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'),
                     'compiler flags customized')
    def test_sysconfig_compiler_vars(self):
        # On OS X, binary installers support extension module building on
        # various levels of the operating system with differing Xcode
        # configurations.  This requires customization of some of the
        # compiler configuration directives to suit the environment on
        # the installed machine.  Some of these customizations may require
        # running external programs and, so, are deferred until needed by
        # the first extension module build.  With Python 3.3, only
        # the Distutils version of sysconfig is used for extension module
        # builds, which happens earlier in the Distutils tests.  This may
        # cause the following tests to fail since no tests have caused
        # the global version of sysconfig to call the customization yet.
        # The solution for now is to simply skip this test in this case.
        # The longer-term solution is to only have one version of sysconfig.

        import sysconfig as global_sysconfig
        if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
            self.skipTest('compiler flags customized')
        self.assertEqual(global_sysconfig.get_config_var('LDSHARED'),
                         sysconfig.get_config_var('LDSHARED'))
        self.assertEqual(global_sysconfig.get_config_var('CC'),
                         sysconfig.get_config_var('CC'))

    @unittest.skipIf(sysconfig.get_config_var('EXT_SUFFIX') is None,
                     'EXT_SUFFIX required for this test')
    def test_SO_deprecation(self):
        self.assertWarns(DeprecationWarning,
                         sysconfig.get_config_var, 'SO')

    @unittest.skipIf(sysconfig.get_config_var('EXT_SUFFIX') is None,
                     'EXT_SUFFIX required for this test')
    def test_SO_value(self):
        with check_warnings(('', DeprecationWarning)):
            self.assertEqual(sysconfig.get_config_var('SO'),
                             sysconfig.get_config_var('EXT_SUFFIX'))

    @unittest.skipIf(sysconfig.get_config_var('EXT_SUFFIX') is None,
                     'EXT_SUFFIX required for this test')
    def test_SO_in_vars(self):
        vars = sysconfig.get_config_vars()
        self.assertIsNotNone(vars['SO'])
        self.assertEqual(vars['SO'], vars['EXT_SUFFIX'])

    def test_customize_compiler_before_get_config_vars(self):
        # Issue #21923: test that a Distribution compiler
        # instance can be called without an explicit call to
        # get_config_vars().
        with open(TESTFN, 'w') as f:
            f.writelines(textwrap.dedent('''\
                from distutils.core import Distribution
                config = Distribution().get_command_obj('config')
                # try_compile may pass or it may fail if no compiler
                # is found but it should not raise an exception.
                rc = config.try_compile('int x;')
                '''))
        p = subprocess.Popen([str(sys.executable), TESTFN],
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                universal_newlines=True)
        outs, errs = p.communicate()
        self.assertEqual(0, p.returncode, "Subprocess failed: " + outs)


def test_suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(SysconfigTestCase))
    return suite


if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_text_file.py0000644000175100001710000000655400000000000024550 0ustar00runnerdocker"""Tests for distutils.text_file."""
import os
import unittest
from distutils.text_file import TextFile
from distutils.tests import support
from test.support import run_unittest

TEST_DATA = """# test file

line 3 \\
# intervening comment
  continues on next line
"""

class TextFileTestCase(support.TempdirManager, unittest.TestCase):

    def test_class(self):
        # old tests moved from text_file.__main__
        # so they are really called by the buildbots

        # result 1: no fancy options
        result1 = ['# test file\n', '\n', 'line 3 \\\n',
                   '# intervening comment\n',
                   '  continues on next line\n']

        # result 2: just strip comments
        result2 = ["\n",
                   "line 3 \\\n",
                   "  continues on next line\n"]

        # result 3: just strip blank lines
        result3 = ["# test file\n",
                   "line 3 \\\n",
                   "# intervening comment\n",
                   "  continues on next line\n"]

        # result 4: default, strip comments, blank lines,
        # and trailing whitespace
        result4 = ["line 3 \\",
                   "  continues on next line"]

        # result 5: strip comments and blanks, plus join lines (but don't
        # "collapse" joined lines
        result5 = ["line 3   continues on next line"]

        # result 6: strip comments and blanks, plus join lines (and
        # "collapse" joined lines
        result6 = ["line 3 continues on next line"]

        def test_input(count, description, file, expected_result):
            result = file.readlines()
            self.assertEqual(result, expected_result)

        tmpdir = self.mkdtemp()
        filename = os.path.join(tmpdir, "test.txt")
        out_file = open(filename, "w")
        try:
            out_file.write(TEST_DATA)
        finally:
            out_file.close()

        in_file = TextFile(filename, strip_comments=0, skip_blanks=0,
                           lstrip_ws=0, rstrip_ws=0)
        try:
            test_input(1, "no processing", in_file, result1)
        finally:
            in_file.close()

        in_file = TextFile(filename, strip_comments=1, skip_blanks=0,
                           lstrip_ws=0, rstrip_ws=0)
        try:
            test_input(2, "strip comments", in_file, result2)
        finally:
            in_file.close()

        in_file = TextFile(filename, strip_comments=0, skip_blanks=1,
                           lstrip_ws=0, rstrip_ws=0)
        try:
            test_input(3, "strip blanks", in_file, result3)
        finally:
            in_file.close()

        in_file = TextFile(filename)
        try:
            test_input(4, "default processing", in_file, result4)
        finally:
            in_file.close()

        in_file = TextFile(filename, strip_comments=1, skip_blanks=1,
                           join_lines=1, rstrip_ws=1)
        try:
            test_input(5, "join lines without collapsing", in_file, result5)
        finally:
            in_file.close()

        in_file = TextFile(filename, strip_comments=1, skip_blanks=1,
                           join_lines=1, rstrip_ws=1, collapse_join=1)
        try:
            test_input(6, "join lines with collapsing", in_file, result6)
        finally:
            in_file.close()

def test_suite():
    return unittest.makeSuite(TextFileTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_unixccompiler.py0000644000175100001710000002173200000000000025441 0ustar00runnerdocker"""Tests for distutils.unixccompiler."""
import os
import sys
import unittest
from test.support import run_unittest

from .py38compat import EnvironmentVarGuard

from distutils import sysconfig
from distutils.errors import DistutilsPlatformError
from distutils.unixccompiler import UnixCCompiler
from distutils.util import _clear_cached_macosx_ver

from . import support

class UnixCCompilerTestCase(support.TempdirManager, unittest.TestCase):

    def setUp(self):
        super().setUp()
        self._backup_platform = sys.platform
        self._backup_get_config_var = sysconfig.get_config_var
        self._backup_get_config_vars = sysconfig.get_config_vars
        class CompilerWrapper(UnixCCompiler):
            def rpath_foo(self):
                return self.runtime_library_dir_option('/foo')
        self.cc = CompilerWrapper()

    def tearDown(self):
        super().tearDown()
        sys.platform = self._backup_platform
        sysconfig.get_config_var = self._backup_get_config_var
        sysconfig.get_config_vars = self._backup_get_config_vars

    @unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
    def test_runtime_libdir_option(self):
        # Issue #5900; GitHub Issue #37
        #
        # Ensure RUNPATH is added to extension modules with RPATH if
        # GNU ld is used

        # darwin
        sys.platform = 'darwin'
        darwin_ver_var = 'MACOSX_DEPLOYMENT_TARGET'
        darwin_rpath_flag = '-Wl,-rpath,/foo'
        darwin_lib_flag = '-L/foo'

        # (macOS version from syscfg, macOS version from env var) -> flag
        # Version value of None generates two tests: as None and as empty string
        # Expected flag value of None means an mismatch exception is expected
        darwin_test_cases = [
            ((None    , None    ), darwin_lib_flag),
            ((None    , '11'    ), darwin_rpath_flag),
            (('10'    , None    ), darwin_lib_flag),
            (('10.3'  , None    ), darwin_lib_flag),
            (('10.3.1', None    ), darwin_lib_flag),
            (('10.5'  , None    ), darwin_rpath_flag),
            (('10.5.1', None    ), darwin_rpath_flag),
            (('10.3'  , '10.3'  ), darwin_lib_flag),
            (('10.3'  , '10.5'  ), darwin_rpath_flag),
            (('10.5'  , '10.3'  ), darwin_lib_flag),
            (('10.5'  , '11'    ), darwin_rpath_flag),
            (('10.4'  , '10'    ), None),
        ]

        def make_darwin_gcv(syscfg_macosx_ver):
            def gcv(var):
                if var == darwin_ver_var:
                    return syscfg_macosx_ver
                return "xxx"
            return gcv

        def do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag):
            env = os.environ
            msg = "macOS version = (sysconfig=%r, env=%r)" % \
                    (syscfg_macosx_ver, env_macosx_ver)

            # Save
            old_gcv = sysconfig.get_config_var
            old_env_macosx_ver = env.get(darwin_ver_var)

            # Setup environment
            _clear_cached_macosx_ver()
            sysconfig.get_config_var = make_darwin_gcv(syscfg_macosx_ver)
            if env_macosx_ver is not None:
                env[darwin_ver_var] = env_macosx_ver
            elif darwin_ver_var in env:
                env.pop(darwin_ver_var)

            # Run the test
            if expected_flag is not None:
                self.assertEqual(self.cc.rpath_foo(), expected_flag, msg=msg)
            else:
                with self.assertRaisesRegex(DistutilsPlatformError,
                        darwin_ver_var + r' mismatch', msg=msg):
                    self.cc.rpath_foo()

            # Restore
            if old_env_macosx_ver is not None:
                env[darwin_ver_var] = old_env_macosx_ver
            elif darwin_ver_var in env:
                env.pop(darwin_ver_var)
            sysconfig.get_config_var = old_gcv
            _clear_cached_macosx_ver()

        for macosx_vers, expected_flag in darwin_test_cases:
            syscfg_macosx_ver, env_macosx_ver = macosx_vers
            do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag)
            # Bonus test cases with None interpreted as empty string
            if syscfg_macosx_ver is None:
                do_darwin_test("", env_macosx_ver, expected_flag)
            if env_macosx_ver is None:
                do_darwin_test(syscfg_macosx_ver, "", expected_flag)
            if syscfg_macosx_ver is None and env_macosx_ver is None:
                do_darwin_test("", "", expected_flag)

        old_gcv = sysconfig.get_config_var

        # hp-ux
        sys.platform = 'hp-ux'
        def gcv(v):
            return 'xxx'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), ['+s', '-L/foo'])

        def gcv(v):
            return 'gcc'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), ['-Wl,+s', '-L/foo'])

        def gcv(v):
            return 'g++'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), ['-Wl,+s', '-L/foo'])

        sysconfig.get_config_var = old_gcv

        # GCC GNULD
        sys.platform = 'bar'
        def gcv(v):
            if v == 'CC':
                return 'gcc'
            elif v == 'GNULD':
                return 'yes'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')

        def gcv(v):
            if v == 'CC':
                return 'gcc -pthread -B /bar'
            elif v == 'GNULD':
                return 'yes'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')

        # GCC non-GNULD
        sys.platform = 'bar'
        def gcv(v):
            if v == 'CC':
                return 'gcc'
            elif v == 'GNULD':
                return 'no'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), '-Wl,-R/foo')

        # GCC GNULD with fully qualified configuration prefix
        # see #7617
        sys.platform = 'bar'
        def gcv(v):
            if v == 'CC':
                return 'x86_64-pc-linux-gnu-gcc-4.4.2'
            elif v == 'GNULD':
                return 'yes'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')

        # non-GCC GNULD
        sys.platform = 'bar'
        def gcv(v):
            if v == 'CC':
                return 'cc'
            elif v == 'GNULD':
                return 'yes'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')

        # non-GCC non-GNULD
        sys.platform = 'bar'
        def gcv(v):
            if v == 'CC':
                return 'cc'
            elif v == 'GNULD':
                return 'no'
        sysconfig.get_config_var = gcv
        self.assertEqual(self.cc.rpath_foo(), '-Wl,-R/foo')

    @unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
    def test_cc_overrides_ldshared(self):
        # Issue #18080:
        # ensure that setting CC env variable also changes default linker
        def gcv(v):
            if v == 'LDSHARED':
                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
            return 'gcc-4.2'

        def gcvs(*args, _orig=sysconfig.get_config_vars):
            if args:
                return list(map(sysconfig.get_config_var, args))
            return _orig()
        sysconfig.get_config_var = gcv
        sysconfig.get_config_vars = gcvs
        with EnvironmentVarGuard() as env:
            env['CC'] = 'my_cc'
            del env['LDSHARED']
            sysconfig.customize_compiler(self.cc)
        self.assertEqual(self.cc.linker_so[0], 'my_cc')

    @unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
    def test_explicit_ldshared(self):
        # Issue #18080:
        # ensure that setting CC env variable does not change
        #   explicit LDSHARED setting for linker
        def gcv(v):
            if v == 'LDSHARED':
                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
            return 'gcc-4.2'

        def gcvs(*args, _orig=sysconfig.get_config_vars):
            if args:
                return list(map(sysconfig.get_config_var, args))
            return _orig()
        sysconfig.get_config_var = gcv
        sysconfig.get_config_vars = gcvs
        with EnvironmentVarGuard() as env:
            env['CC'] = 'my_cc'
            env['LDSHARED'] = 'my_ld -bundle -dynamic'
            sysconfig.customize_compiler(self.cc)
        self.assertEqual(self.cc.linker_so[0], 'my_ld')

    def test_has_function(self):
        # Issue https://github.com/pypa/distutils/issues/64:
        # ensure that setting output_dir does not raise
        # FileNotFoundError: [Errno 2] No such file or directory: 'a.out'
        self.cc.output_dir = 'scratch'
        os.chdir(self.mkdtemp())
        self.cc.has_function('abort', includes=['stdlib.h'])


def test_suite():
    return unittest.makeSuite(UnixCCompilerTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_upload.py0000644000175100001710000001574300000000000024051 0ustar00runnerdocker"""Tests for distutils.command.upload."""
import os
import unittest
import unittest.mock as mock
from urllib.request import HTTPError

from test.support import run_unittest

from distutils.command import upload as upload_mod
from distutils.command.upload import upload
from distutils.core import Distribution
from distutils.errors import DistutilsError
from distutils.log import ERROR, INFO

from distutils.tests.test_config import PYPIRC, BasePyPIRCCommandTestCase

PYPIRC_LONG_PASSWORD = """\
[distutils]

index-servers =
    server1
    server2

[server1]
username:me
password:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

[server2]
username:meagain
password: secret
realm:acme
repository:http://another.pypi/
"""


PYPIRC_NOPASSWORD = """\
[distutils]

index-servers =
    server1

[server1]
username:me
"""

class FakeOpen(object):

    def __init__(self, url, msg=None, code=None):
        self.url = url
        if not isinstance(url, str):
            self.req = url
        else:
            self.req = None
        self.msg = msg or 'OK'
        self.code = code or 200

    def getheader(self, name, default=None):
        return {
            'content-type': 'text/plain; charset=utf-8',
            }.get(name.lower(), default)

    def read(self):
        return b'xyzzy'

    def getcode(self):
        return self.code


class uploadTestCase(BasePyPIRCCommandTestCase):

    def setUp(self):
        super(uploadTestCase, self).setUp()
        self.old_open = upload_mod.urlopen
        upload_mod.urlopen = self._urlopen
        self.last_open = None
        self.next_msg = None
        self.next_code = None

    def tearDown(self):
        upload_mod.urlopen = self.old_open
        super(uploadTestCase, self).tearDown()

    def _urlopen(self, url):
        self.last_open = FakeOpen(url, msg=self.next_msg, code=self.next_code)
        return self.last_open

    def test_finalize_options(self):

        # new format
        self.write_file(self.rc, PYPIRC)
        dist = Distribution()
        cmd = upload(dist)
        cmd.finalize_options()
        for attr, waited in (('username', 'me'), ('password', 'secret'),
                             ('realm', 'pypi'),
                             ('repository', 'https://upload.pypi.org/legacy/')):
            self.assertEqual(getattr(cmd, attr), waited)

    def test_saved_password(self):
        # file with no password
        self.write_file(self.rc, PYPIRC_NOPASSWORD)

        # make sure it passes
        dist = Distribution()
        cmd = upload(dist)
        cmd.finalize_options()
        self.assertEqual(cmd.password, None)

        # make sure we get it as well, if another command
        # initialized it at the dist level
        dist.password = 'xxx'
        cmd = upload(dist)
        cmd.finalize_options()
        self.assertEqual(cmd.password, 'xxx')

    def test_upload(self):
        tmp = self.mkdtemp()
        path = os.path.join(tmp, 'xxx')
        self.write_file(path)
        command, pyversion, filename = 'xxx', '2.6', path
        dist_files = [(command, pyversion, filename)]
        self.write_file(self.rc, PYPIRC_LONG_PASSWORD)

        # lets run it
        pkg_dir, dist = self.create_dist(dist_files=dist_files)
        cmd = upload(dist)
        cmd.show_response = 1
        cmd.ensure_finalized()
        cmd.run()

        # what did we send ?
        headers = dict(self.last_open.req.headers)
        self.assertGreaterEqual(int(headers['Content-length']), 2162)
        content_type = headers['Content-type']
        self.assertTrue(content_type.startswith('multipart/form-data'))
        self.assertEqual(self.last_open.req.get_method(), 'POST')
        expected_url = 'https://upload.pypi.org/legacy/'
        self.assertEqual(self.last_open.req.get_full_url(), expected_url)
        data = self.last_open.req.data
        self.assertIn(b'xxx',data)
        self.assertIn(b'protocol_version', data)
        self.assertIn(b'sha256_digest', data)
        self.assertIn(
            b'cd2eb0837c9b4c962c22d2ff8b5441b7b45805887f051d39bf133b583baf'
            b'6860',
            data
        )
        if b'md5_digest' in data:
            self.assertIn(b'f561aaf6ef0bf14d4208bb46a4ccb3ad', data)
        if b'blake2_256_digest' in data:
            self.assertIn(
                b'b6f289a27d4fe90da63c503bfe0a9b761a8f76bb86148565065f040be'
                b'6d1c3044cf7ded78ef800509bccb4b648e507d88dc6383d67642aadcc'
                b'ce443f1534330a',
                data
            )

        # The PyPI response body was echoed
        results = self.get_logs(INFO)
        self.assertEqual(results[-1], 75 * '-' + '\nxyzzy\n' + 75 * '-')

    # bpo-32304: archives whose last byte was b'\r' were corrupted due to
    # normalization intended for Mac OS 9.
    def test_upload_correct_cr(self):
        # content that ends with \r should not be modified.
        tmp = self.mkdtemp()
        path = os.path.join(tmp, 'xxx')
        self.write_file(path, content='yy\r')
        command, pyversion, filename = 'xxx', '2.6', path
        dist_files = [(command, pyversion, filename)]
        self.write_file(self.rc, PYPIRC_LONG_PASSWORD)

        # other fields that ended with \r used to be modified, now are
        # preserved.
        pkg_dir, dist = self.create_dist(
            dist_files=dist_files,
            description='long description\r'
        )
        cmd = upload(dist)
        cmd.show_response = 1
        cmd.ensure_finalized()
        cmd.run()

        headers = dict(self.last_open.req.headers)
        self.assertGreaterEqual(int(headers['Content-length']), 2172)
        self.assertIn(b'long description\r', self.last_open.req.data)

    def test_upload_fails(self):
        self.next_msg = "Not Found"
        self.next_code = 404
        self.assertRaises(DistutilsError, self.test_upload)

    def test_wrong_exception_order(self):
        tmp = self.mkdtemp()
        path = os.path.join(tmp, 'xxx')
        self.write_file(path)
        dist_files = [('xxx', '2.6', path)]  # command, pyversion, filename
        self.write_file(self.rc, PYPIRC_LONG_PASSWORD)

        pkg_dir, dist = self.create_dist(dist_files=dist_files)
        tests = [
            (OSError('oserror'), 'oserror', OSError),
            (HTTPError('url', 400, 'httperror', {}, None),
             'Upload failed (400): httperror', DistutilsError),
        ]
        for exception, expected, raised_exception in tests:
            with self.subTest(exception=type(exception).__name__):
                with mock.patch('distutils.command.upload.urlopen',
                                new=mock.Mock(side_effect=exception)):
                    with self.assertRaises(raised_exception):
                        cmd = upload(dist)
                        cmd.ensure_finalized()
                        cmd.run()
                    results = self.get_logs(ERROR)
                    self.assertIn(expected, results[-1])
                    self.clear_logs()


def test_suite():
    return unittest.makeSuite(uploadTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_util.py0000644000175100001710000002646400000000000023544 0ustar00runnerdocker"""Tests for distutils.util."""
import os
import sys
import unittest
from copy import copy
from test.support import run_unittest
from unittest import mock

from distutils.errors import DistutilsPlatformError, DistutilsByteCompileError
from distutils.util import (get_platform, convert_path, change_root,
                            check_environ, split_quoted, strtobool,
                            rfc822_escape, byte_compile,
                            grok_environment_error)
from distutils import util # used to patch _environ_checked
from distutils.sysconfig import get_config_vars
from distutils import sysconfig
from distutils.tests import support
import _osx_support

class UtilTestCase(support.EnvironGuard, unittest.TestCase):

    def setUp(self):
        super(UtilTestCase, self).setUp()
        # saving the environment
        self.name = os.name
        self.platform = sys.platform
        self.version = sys.version
        self.sep = os.sep
        self.join = os.path.join
        self.isabs = os.path.isabs
        self.splitdrive = os.path.splitdrive
        self._config_vars = copy(sysconfig._config_vars)

        # patching os.uname
        if hasattr(os, 'uname'):
            self.uname = os.uname
            self._uname = os.uname()
        else:
            self.uname = None
            self._uname = None

        os.uname = self._get_uname

    def tearDown(self):
        # getting back the environment
        os.name = self.name
        sys.platform = self.platform
        sys.version = self.version
        os.sep = self.sep
        os.path.join = self.join
        os.path.isabs = self.isabs
        os.path.splitdrive = self.splitdrive
        if self.uname is not None:
            os.uname = self.uname
        else:
            del os.uname
        sysconfig._config_vars = copy(self._config_vars)
        super(UtilTestCase, self).tearDown()

    def _set_uname(self, uname):
        self._uname = uname

    def _get_uname(self):
        return self._uname

    def test_get_platform(self):

        # windows XP, 32bits
        os.name = 'nt'
        sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
                       '[MSC v.1310 32 bit (Intel)]')
        sys.platform = 'win32'
        self.assertEqual(get_platform(), 'win32')

        # windows XP, amd64
        os.name = 'nt'
        sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
                       '[MSC v.1310 32 bit (Amd64)]')
        sys.platform = 'win32'
        self.assertEqual(get_platform(), 'win-amd64')

        # macbook
        os.name = 'posix'
        sys.version = ('2.5 (r25:51918, Sep 19 2006, 08:49:13) '
                       '\n[GCC 4.0.1 (Apple Computer, Inc. build 5341)]')
        sys.platform = 'darwin'
        self._set_uname(('Darwin', 'macziade', '8.11.1',
                   ('Darwin Kernel Version 8.11.1: '
                    'Wed Oct 10 18:23:28 PDT 2007; '
                    'root:xnu-792.25.20~1/RELEASE_I386'), 'i386'))
        _osx_support._remove_original_values(get_config_vars())
        get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.3'

        get_config_vars()['CFLAGS'] = ('-fno-strict-aliasing -DNDEBUG -g '
                                       '-fwrapv -O3 -Wall -Wstrict-prototypes')

        cursize = sys.maxsize
        sys.maxsize = (2 ** 31)-1
        try:
            self.assertEqual(get_platform(), 'macosx-10.3-i386')
        finally:
            sys.maxsize = cursize

        # macbook with fat binaries (fat, universal or fat64)
        _osx_support._remove_original_values(get_config_vars())
        get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.4'
        get_config_vars()['CFLAGS'] = ('-arch ppc -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')

        self.assertEqual(get_platform(), 'macosx-10.4-fat')

        _osx_support._remove_original_values(get_config_vars())
        os.environ['MACOSX_DEPLOYMENT_TARGET'] = '10.1'
        self.assertEqual(get_platform(), 'macosx-10.4-fat')


        _osx_support._remove_original_values(get_config_vars())
        get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')

        self.assertEqual(get_platform(), 'macosx-10.4-intel')

        _osx_support._remove_original_values(get_config_vars())
        get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')
        self.assertEqual(get_platform(), 'macosx-10.4-fat3')

        _osx_support._remove_original_values(get_config_vars())
        get_config_vars()['CFLAGS'] = ('-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')
        self.assertEqual(get_platform(), 'macosx-10.4-universal')

        _osx_support._remove_original_values(get_config_vars())
        get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')

        self.assertEqual(get_platform(), 'macosx-10.4-fat64')

        for arch in ('ppc', 'i386', 'x86_64', 'ppc64'):
            _osx_support._remove_original_values(get_config_vars())
            get_config_vars()['CFLAGS'] = ('-arch %s -isysroot '
                                           '/Developer/SDKs/MacOSX10.4u.sdk  '
                                           '-fno-strict-aliasing -fno-common '
                                           '-dynamic -DNDEBUG -g -O3'%(arch,))

            self.assertEqual(get_platform(), 'macosx-10.4-%s'%(arch,))


        # linux debian sarge
        os.name = 'posix'
        sys.version = ('2.3.5 (#1, Jul  4 2007, 17:28:59) '
                       '\n[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)]')
        sys.platform = 'linux2'
        self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7',
                    '#1 Mon Apr 30 17:25:38 CEST 2007', 'i686'))

        self.assertEqual(get_platform(), 'linux-i686')

        # XXX more platforms to tests here

    def test_convert_path(self):
        # linux/mac
        os.sep = '/'
        def _join(path):
            return '/'.join(path)
        os.path.join = _join

        self.assertEqual(convert_path('/home/to/my/stuff'),
                         '/home/to/my/stuff')

        # win
        os.sep = '\\'
        def _join(*path):
            return '\\'.join(path)
        os.path.join = _join

        self.assertRaises(ValueError, convert_path, '/home/to/my/stuff')
        self.assertRaises(ValueError, convert_path, 'home/to/my/stuff/')

        self.assertEqual(convert_path('home/to/my/stuff'),
                         'home\\to\\my\\stuff')
        self.assertEqual(convert_path('.'),
                         os.curdir)

    def test_change_root(self):
        # linux/mac
        os.name = 'posix'
        def _isabs(path):
            return path[0] == '/'
        os.path.isabs = _isabs
        def _join(*path):
            return '/'.join(path)
        os.path.join = _join

        self.assertEqual(change_root('/root', '/old/its/here'),
                         '/root/old/its/here')
        self.assertEqual(change_root('/root', 'its/here'),
                         '/root/its/here')

        # windows
        os.name = 'nt'
        def _isabs(path):
            return path.startswith('c:\\')
        os.path.isabs = _isabs
        def _splitdrive(path):
            if path.startswith('c:'):
                return ('', path.replace('c:', ''))
            return ('', path)
        os.path.splitdrive = _splitdrive
        def _join(*path):
            return '\\'.join(path)
        os.path.join = _join

        self.assertEqual(change_root('c:\\root', 'c:\\old\\its\\here'),
                         'c:\\root\\old\\its\\here')
        self.assertEqual(change_root('c:\\root', 'its\\here'),
                         'c:\\root\\its\\here')

        # BugsBunny os (it's a great os)
        os.name = 'BugsBunny'
        self.assertRaises(DistutilsPlatformError,
                          change_root, 'c:\\root', 'its\\here')

        # XXX platforms to be covered: mac

    def test_check_environ(self):
        util._environ_checked = 0
        os.environ.pop('HOME', None)

        check_environ()

        self.assertEqual(os.environ['PLAT'], get_platform())
        self.assertEqual(util._environ_checked, 1)

    @unittest.skipUnless(os.name == 'posix', 'specific to posix')
    def test_check_environ_getpwuid(self):
        util._environ_checked = 0
        os.environ.pop('HOME', None)

        import pwd

        # only set pw_dir field, other fields are not used
        result = pwd.struct_passwd((None, None, None, None, None,
                                    '/home/distutils', None))
        with mock.patch.object(pwd, 'getpwuid', return_value=result):
            check_environ()
            self.assertEqual(os.environ['HOME'], '/home/distutils')

        util._environ_checked = 0
        os.environ.pop('HOME', None)

        # bpo-10496: Catch pwd.getpwuid() error
        with mock.patch.object(pwd, 'getpwuid', side_effect=KeyError):
            check_environ()
            self.assertNotIn('HOME', os.environ)

    def test_split_quoted(self):
        self.assertEqual(split_quoted('""one"" "two" \'three\' \\four'),
                         ['one', 'two', 'three', 'four'])

    def test_strtobool(self):
        yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1')
        no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')

        for y in yes:
            self.assertTrue(strtobool(y))

        for n in no:
            self.assertFalse(strtobool(n))

    def test_rfc822_escape(self):
        header = 'I am a\npoor\nlonesome\nheader\n'
        res = rfc822_escape(header)
        wanted = ('I am a%(8s)spoor%(8s)slonesome%(8s)s'
                  'header%(8s)s') % {'8s': '\n'+8*' '}
        self.assertEqual(res, wanted)

    def test_dont_write_bytecode(self):
        # makes sure byte_compile raise a DistutilsError
        # if sys.dont_write_bytecode is True
        old_dont_write_bytecode = sys.dont_write_bytecode
        sys.dont_write_bytecode = True
        try:
            self.assertRaises(DistutilsByteCompileError, byte_compile, [])
        finally:
            sys.dont_write_bytecode = old_dont_write_bytecode

    def test_grok_environment_error(self):
        # test obsolete function to ensure backward compat (#4931)
        exc = IOError("Unable to find batch file")
        msg = grok_environment_error(exc)
        self.assertEqual(msg, "error: Unable to find batch file")


def test_suite():
    return unittest.makeSuite(UtilTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_version.py0000644000175100001710000000710500000000000024243 0ustar00runnerdocker"""Tests for distutils.version."""
import unittest
import distutils
from distutils.version import LooseVersion
from distutils.version import StrictVersion
from test.support import run_unittest

class VersionTestCase(unittest.TestCase):

    def setUp(self):
        self.ctx = distutils.version.suppress_known_deprecation()
        self.ctx.__enter__()

    def tearDown(self):
        self.ctx.__exit__(None, None, None)

    def test_prerelease(self):
        version = StrictVersion('1.2.3a1')
        self.assertEqual(version.version, (1, 2, 3))
        self.assertEqual(version.prerelease, ('a', 1))
        self.assertEqual(str(version), '1.2.3a1')

        version = StrictVersion('1.2.0')
        self.assertEqual(str(version), '1.2')

    def test_cmp_strict(self):
        versions = (('1.5.1', '1.5.2b2', -1),
                    ('161', '3.10a', ValueError),
                    ('8.02', '8.02', 0),
                    ('3.4j', '1996.07.12', ValueError),
                    ('3.2.pl0', '3.1.1.6', ValueError),
                    ('2g6', '11g', ValueError),
                    ('0.9', '2.2', -1),
                    ('1.2.1', '1.2', 1),
                    ('1.1', '1.2.2', -1),
                    ('1.2', '1.1', 1),
                    ('1.2.1', '1.2.2', -1),
                    ('1.2.2', '1.2', 1),
                    ('1.2', '1.2.2', -1),
                    ('0.4.0', '0.4', 0),
                    ('1.13++', '5.5.kw', ValueError))

        for v1, v2, wanted in versions:
            try:
                res = StrictVersion(v1)._cmp(StrictVersion(v2))
            except ValueError:
                if wanted is ValueError:
                    continue
                else:
                    raise AssertionError(("cmp(%s, %s) "
                                          "shouldn't raise ValueError")
                                            % (v1, v2))
            self.assertEqual(res, wanted,
                             'cmp(%s, %s) should be %s, got %s' %
                             (v1, v2, wanted, res))
            res = StrictVersion(v1)._cmp(v2)
            self.assertEqual(res, wanted,
                             'cmp(%s, %s) should be %s, got %s' %
                             (v1, v2, wanted, res))
            res = StrictVersion(v1)._cmp(object())
            self.assertIs(res, NotImplemented,
                          'cmp(%s, %s) should be NotImplemented, got %s' %
                          (v1, v2, res))


    def test_cmp(self):
        versions = (('1.5.1', '1.5.2b2', -1),
                    ('161', '3.10a', 1),
                    ('8.02', '8.02', 0),
                    ('3.4j', '1996.07.12', -1),
                    ('3.2.pl0', '3.1.1.6', 1),
                    ('2g6', '11g', -1),
                    ('0.960923', '2.2beta29', -1),
                    ('1.13++', '5.5.kw', -1))


        for v1, v2, wanted in versions:
            res = LooseVersion(v1)._cmp(LooseVersion(v2))
            self.assertEqual(res, wanted,
                             'cmp(%s, %s) should be %s, got %s' %
                             (v1, v2, wanted, res))
            res = LooseVersion(v1)._cmp(v2)
            self.assertEqual(res, wanted,
                             'cmp(%s, %s) should be %s, got %s' %
                             (v1, v2, wanted, res))
            res = LooseVersion(v1)._cmp(object())
            self.assertIs(res, NotImplemented,
                          'cmp(%s, %s) should be NotImplemented, got %s' %
                          (v1, v2, res))

def test_suite():
    return unittest.makeSuite(VersionTestCase)

if __name__ == "__main__":
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/tests/test_versionpredicate.py0000644000175100001710000000043000000000000026116 0ustar00runnerdocker"""Tests harness for distutils.versionpredicate.

"""

import distutils.versionpredicate
import doctest
from test.support import run_unittest

def test_suite():
    return doctest.DocTestSuite(distutils.versionpredicate)

if __name__ == '__main__':
    run_unittest(test_suite())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/text_file.py0000644000175100001710000003030300000000000022334 0ustar00runnerdocker"""text_file

provides the TextFile class, which gives an interface to text files
that (optionally) takes care of stripping comments, ignoring blank
lines, and joining lines with backslashes."""

import sys, io


class TextFile:
    """Provides a file-like object that takes care of all the things you
       commonly want to do when processing a text file that has some
       line-by-line syntax: strip comments (as long as "#" is your
       comment character), skip blank lines, join adjacent lines by
       escaping the newline (ie. backslash at end of line), strip
       leading and/or trailing whitespace.  All of these are optional
       and independently controllable.

       Provides a 'warn()' method so you can generate warning messages that
       report physical line number, even if the logical line in question
       spans multiple physical lines.  Also provides 'unreadline()' for
       implementing line-at-a-time lookahead.

       Constructor is called as:

           TextFile (filename=None, file=None, **options)

       It bombs (RuntimeError) if both 'filename' and 'file' are None;
       'filename' should be a string, and 'file' a file object (or
       something that provides 'readline()' and 'close()' methods).  It is
       recommended that you supply at least 'filename', so that TextFile
       can include it in warning messages.  If 'file' is not supplied,
       TextFile creates its own using 'io.open()'.

       The options are all boolean, and affect the value returned by
       'readline()':
         strip_comments [default: true]
           strip from "#" to end-of-line, as well as any whitespace
           leading up to the "#" -- unless it is escaped by a backslash
         lstrip_ws [default: false]
           strip leading whitespace from each line before returning it
         rstrip_ws [default: true]
           strip trailing whitespace (including line terminator!) from
           each line before returning it
         skip_blanks [default: true}
           skip lines that are empty *after* stripping comments and
           whitespace.  (If both lstrip_ws and rstrip_ws are false,
           then some lines may consist of solely whitespace: these will
           *not* be skipped, even if 'skip_blanks' is true.)
         join_lines [default: false]
           if a backslash is the last non-newline character on a line
           after stripping comments and whitespace, join the following line
           to it to form one "logical line"; if N consecutive lines end
           with a backslash, then N+1 physical lines will be joined to
           form one logical line.
         collapse_join [default: false]
           strip leading whitespace from lines that are joined to their
           predecessor; only matters if (join_lines and not lstrip_ws)
         errors [default: 'strict']
           error handler used to decode the file content

       Note that since 'rstrip_ws' can strip the trailing newline, the
       semantics of 'readline()' must differ from those of the builtin file
       object's 'readline()' method!  In particular, 'readline()' returns
       None for end-of-file: an empty string might just be a blank line (or
       an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
       not."""

    default_options = { 'strip_comments': 1,
                        'skip_blanks':    1,
                        'lstrip_ws':      0,
                        'rstrip_ws':      1,
                        'join_lines':     0,
                        'collapse_join':  0,
                        'errors':         'strict',
                      }

    def __init__(self, filename=None, file=None, **options):
        """Construct a new TextFile object.  At least one of 'filename'
           (a string) and 'file' (a file-like object) must be supplied.
           They keyword argument options are described above and affect
           the values returned by 'readline()'."""
        if filename is None and file is None:
            raise RuntimeError("you must supply either or both of 'filename' and 'file'")

        # set values for all options -- either from client option hash
        # or fallback to default_options
        for opt in self.default_options.keys():
            if opt in options:
                setattr(self, opt, options[opt])
            else:
                setattr(self, opt, self.default_options[opt])

        # sanity check client option hash
        for opt in options.keys():
            if opt not in self.default_options:
                raise KeyError("invalid TextFile option '%s'" % opt)

        if file is None:
            self.open(filename)
        else:
            self.filename = filename
            self.file = file
            self.current_line = 0       # assuming that file is at BOF!

        # 'linebuf' is a stack of lines that will be emptied before we
        # actually read from the file; it's only populated by an
        # 'unreadline()' operation
        self.linebuf = []

    def open(self, filename):
        """Open a new file named 'filename'.  This overrides both the
           'filename' and 'file' arguments to the constructor."""
        self.filename = filename
        self.file = io.open(self.filename, 'r', errors=self.errors)
        self.current_line = 0

    def close(self):
        """Close the current file and forget everything we know about it
           (filename, current line number)."""
        file = self.file
        self.file = None
        self.filename = None
        self.current_line = None
        file.close()

    def gen_error(self, msg, line=None):
        outmsg = []
        if line is None:
            line = self.current_line
        outmsg.append(self.filename + ", ")
        if isinstance(line, (list, tuple)):
            outmsg.append("lines %d-%d: " % tuple(line))
        else:
            outmsg.append("line %d: " % line)
        outmsg.append(str(msg))
        return "".join(outmsg)

    def error(self, msg, line=None):
        raise ValueError("error: " + self.gen_error(msg, line))

    def warn(self, msg, line=None):
        """Print (to stderr) a warning message tied to the current logical
           line in the current file.  If the current logical line in the
           file spans multiple physical lines, the warning refers to the
           whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
           the current line number; it may be a list or tuple to indicate a
           range of physical lines, or an integer for a single physical
           line."""
        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")

    def readline(self):
        """Read and return a single logical line from the current file (or
           from an internal buffer if lines have previously been "unread"
           with 'unreadline()').  If the 'join_lines' option is true, this
           may involve reading multiple physical lines concatenated into a
           single string.  Updates the current line number, so calling
           'warn()' after 'readline()' emits a warning about the physical
           line(s) just read.  Returns None on end-of-file, since the empty
           string can occur if 'rstrip_ws' is true but 'strip_blanks' is
           not."""
        # If any "unread" lines waiting in 'linebuf', return the top
        # one.  (We don't actually buffer read-ahead data -- lines only
        # get put in 'linebuf' if the client explicitly does an
        # 'unreadline()'.
        if self.linebuf:
            line = self.linebuf[-1]
            del self.linebuf[-1]
            return line

        buildup_line = ''

        while True:
            # read the line, make it None if EOF
            line = self.file.readline()
            if line == '':
                line = None

            if self.strip_comments and line:

                # Look for the first "#" in the line.  If none, never
                # mind.  If we find one and it's the first character, or
                # is not preceded by "\", then it starts a comment --
                # strip the comment, strip whitespace before it, and
                # carry on.  Otherwise, it's just an escaped "#", so
                # unescape it (and any other escaped "#"'s that might be
                # lurking in there) and otherwise leave the line alone.

                pos = line.find("#")
                if pos == -1: # no "#" -- no comments
                    pass

                # It's definitely a comment -- either "#" is the first
                # character, or it's elsewhere and unescaped.
                elif pos == 0 or line[pos-1] != "\\":
                    # Have to preserve the trailing newline, because it's
                    # the job of a later step (rstrip_ws) to remove it --
                    # and if rstrip_ws is false, we'd better preserve it!
                    # (NB. this means that if the final line is all comment
                    # and has no trailing newline, we will think that it's
                    # EOF; I think that's OK.)
                    eol = (line[-1] == '\n') and '\n' or ''
                    line = line[0:pos] + eol

                    # If all that's left is whitespace, then skip line
                    # *now*, before we try to join it to 'buildup_line' --
                    # that way constructs like
                    #   hello \\
                    #   # comment that should be ignored
                    #   there
                    # result in "hello there".
                    if line.strip() == "":
                        continue
                else: # it's an escaped "#"
                    line = line.replace("\\#", "#")

            # did previous line end with a backslash? then accumulate
            if self.join_lines and buildup_line:
                # oops: end of file
                if line is None:
                    self.warn("continuation line immediately precedes "
                              "end-of-file")
                    return buildup_line

                if self.collapse_join:
                    line = line.lstrip()
                line = buildup_line + line

                # careful: pay attention to line number when incrementing it
                if isinstance(self.current_line, list):
                    self.current_line[1] = self.current_line[1] + 1
                else:
                    self.current_line = [self.current_line,
                                         self.current_line + 1]
            # just an ordinary line, read it as usual
            else:
                if line is None: # eof
                    return None

                # still have to be careful about incrementing the line number!
                if isinstance(self.current_line, list):
                    self.current_line = self.current_line[1] + 1
                else:
                    self.current_line = self.current_line + 1

            # strip whitespace however the client wants (leading and
            # trailing, or one or the other, or neither)
            if self.lstrip_ws and self.rstrip_ws:
                line = line.strip()
            elif self.lstrip_ws:
                line = line.lstrip()
            elif self.rstrip_ws:
                line = line.rstrip()

            # blank line (whether we rstrip'ed or not)? skip to next line
            # if appropriate
            if (line == '' or line == '\n') and self.skip_blanks:
                continue

            if self.join_lines:
                if line[-1] == '\\':
                    buildup_line = line[:-1]
                    continue

                if line[-2:] == '\\\n':
                    buildup_line = line[0:-2] + '\n'
                    continue

            # well, I guess there's some actual content there: return it
            return line

    def readlines(self):
        """Read and return the list of all logical lines remaining in the
           current file."""
        lines = []
        while True:
            line = self.readline()
            if line is None:
                return lines
            lines.append(line)

    def unreadline(self, line):
        """Push 'line' (a string) onto an internal buffer that will be
           checked by future 'readline()' calls.  Handy for implementing
           a parser with line-at-a-time lookahead."""
        self.linebuf.append(line)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/unixccompiler.py0000644000175100001710000003431200000000000023236 0ustar00runnerdocker"""distutils.unixccompiler

Contains the UnixCCompiler class, a subclass of CCompiler that handles
the "typical" Unix-style command-line C compiler:
  * macros defined with -Dname[=value]
  * macros undefined with -Uname
  * include search directories specified with -Idir
  * libraries specified with -lllib
  * library search directories specified with -Ldir
  * compile handled by 'cc' (or similar) executable with -c option:
    compiles .c to .o
  * link static library handled by 'ar' command (possibly with 'ranlib')
  * link shared library handled by 'cc -shared'
"""

import os, sys, re, shlex

from distutils import sysconfig
from distutils.dep_util import newer
from distutils.ccompiler import \
     CCompiler, gen_preprocess_options, gen_lib_options
from distutils.errors import \
     DistutilsExecError, CompileError, LibError, LinkError
from distutils import log

if sys.platform == 'darwin':
    import _osx_support

# XXX Things not currently handled:
#   * optimization/debug/warning flags; we just use whatever's in Python's
#     Makefile and live with it.  Is this adequate?  If not, we might
#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
#     SunCCompiler, and I suspect down that road lies madness.
#   * even if we don't know a warning flag from an optimization flag,
#     we need some way for outsiders to feed preprocessor/compiler/linker
#     flags in to us -- eg. a sysadmin might want to mandate certain flags
#     via a site config file, or a user might want to set something for
#     compiling this module distribution only via the setup.py command
#     line, whatever.  As long as these options come from something on the
#     current system, they can be as system-dependent as they like, and we
#     should just happily stuff them into the preprocessor/compiler/linker
#     options and carry on.


class UnixCCompiler(CCompiler):

    compiler_type = 'unix'

    # These are used by CCompiler in two places: the constructor sets
    # instance attributes 'preprocessor', 'compiler', etc. from them, and
    # 'set_executable()' allows any of these to be set.  The defaults here
    # are pretty generic; they will probably have to be set by an outsider
    # (eg. using information discovered by the sysconfig about building
    # Python extensions).
    executables = {'preprocessor' : None,
                   'compiler'     : ["cc"],
                   'compiler_so'  : ["cc"],
                   'compiler_cxx' : ["cc"],
                   'linker_so'    : ["cc", "-shared"],
                   'linker_exe'   : ["cc"],
                   'archiver'     : ["ar", "-cr"],
                   'ranlib'       : None,
                  }

    if sys.platform[:6] == "darwin":
        executables['ranlib'] = ["ranlib"]

    # Needed for the filename generation methods provided by the base
    # class, CCompiler.  NB. whoever instantiates/uses a particular
    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
    # reasonable common default here, but it's not necessarily used on all
    # Unices!

    src_extensions = [".c",".C",".cc",".cxx",".cpp",".m"]
    obj_extension = ".o"
    static_lib_extension = ".a"
    shared_lib_extension = ".so"
    dylib_lib_extension = ".dylib"
    xcode_stub_lib_extension = ".tbd"
    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
    xcode_stub_lib_format = dylib_lib_format
    if sys.platform == "cygwin":
        exe_extension = ".exe"

    def preprocess(self, source, output_file=None, macros=None,
                   include_dirs=None, extra_preargs=None, extra_postargs=None):
        fixed_args = self._fix_compile_args(None, macros, include_dirs)
        ignore, macros, include_dirs = fixed_args
        pp_opts = gen_preprocess_options(macros, include_dirs)
        pp_args = self.preprocessor + pp_opts
        if output_file:
            pp_args.extend(['-o', output_file])
        if extra_preargs:
            pp_args[:0] = extra_preargs
        if extra_postargs:
            pp_args.extend(extra_postargs)
        pp_args.append(source)

        # We need to preprocess: either we're being forced to, or we're
        # generating output to stdout, or there's a target output file and
        # the source file is newer than the target (or the target doesn't
        # exist).
        if self.force or output_file is None or newer(source, output_file):
            if output_file:
                self.mkpath(os.path.dirname(output_file))
            try:
                self.spawn(pp_args)
            except DistutilsExecError as msg:
                raise CompileError(msg)

    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        compiler_so = self.compiler_so
        if sys.platform == 'darwin':
            compiler_so = _osx_support.compiler_fixup(compiler_so,
                                                    cc_args + extra_postargs)
        try:
            self.spawn(compiler_so + cc_args + [src, '-o', obj] +
                       extra_postargs)
        except DistutilsExecError as msg:
            raise CompileError(msg)

    def create_static_lib(self, objects, output_libname,
                          output_dir=None, debug=0, target_lang=None):
        objects, output_dir = self._fix_object_args(objects, output_dir)

        output_filename = \
            self.library_filename(output_libname, output_dir=output_dir)

        if self._need_link(objects, output_filename):
            self.mkpath(os.path.dirname(output_filename))
            self.spawn(self.archiver +
                       [output_filename] +
                       objects + self.objects)

            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
            # think the only major Unix that does.  Maybe we need some
            # platform intelligence here to skip ranlib if it's not
            # needed -- or maybe Python's configure script took care of
            # it for us, hence the check for leading colon.
            if self.ranlib:
                try:
                    self.spawn(self.ranlib + [output_filename])
                except DistutilsExecError as msg:
                    raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def link(self, target_desc, objects,
             output_filename, output_dir=None, libraries=None,
             library_dirs=None, runtime_library_dirs=None,
             export_symbols=None, debug=0, extra_preargs=None,
             extra_postargs=None, build_temp=None, target_lang=None):
        objects, output_dir = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs,
                                        runtime_library_dirs)
        libraries, library_dirs, runtime_library_dirs = fixed_args

        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
                                   libraries)
        if not isinstance(output_dir, (str, type(None))):
            raise TypeError("'output_dir' must be a string or None")
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            ld_args = (objects + self.objects +
                       lib_opts + ['-o', output_filename])
            if debug:
                ld_args[:0] = ['-g']
            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)
            self.mkpath(os.path.dirname(output_filename))
            try:
                if target_desc == CCompiler.EXECUTABLE:
                    linker = self.linker_exe[:]
                else:
                    linker = self.linker_so[:]
                if target_lang == "c++" and self.compiler_cxx:
                    # skip over environment variable settings if /usr/bin/env
                    # is used to set up the linker's environment.
                    # This is needed on OSX. Note: this assumes that the
                    # normal and C++ compiler have the same environment
                    # settings.
                    i = 0
                    if os.path.basename(linker[0]) == "env":
                        i = 1
                        while '=' in linker[i]:
                            i += 1

                    if os.path.basename(linker[i]) == 'ld_so_aix':
                        # AIX platforms prefix the compiler with the ld_so_aix
                        # script, so we need to adjust our linker index
                        offset = 1
                    else:
                        offset = 0

                    linker[i+offset] = self.compiler_cxx[i]

                if sys.platform == 'darwin':
                    linker = _osx_support.compiler_fixup(linker, ld_args)

                self.spawn(linker + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "-L" + dir

    def _is_gcc(self, compiler_name):
        return "gcc" in compiler_name or "g++" in compiler_name

    def runtime_library_dir_option(self, dir):
        # XXX Hackish, at the very least.  See Python bug #445902:
        # http://sourceforge.net/tracker/index.php
        #   ?func=detail&aid=445902&group_id=5470&atid=105470
        # Linkers on different platforms need different options to
        # specify that directories need to be added to the list of
        # directories searched for dependencies when a dynamic library
        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
        # be told to pass the -R option through to the linker, whereas
        # other compilers and gcc on other systems just know this.
        # Other compilers may need something slightly different.  At
        # this time, there's no way to determine this information from
        # the configuration data stored in the Python installation, so
        # we use this hack.
        compiler = os.path.basename(shlex.split(sysconfig.get_config_var("CC"))[0])
        if sys.platform[:6] == "darwin":
            from distutils.util import get_macosx_target_ver, split_version
            macosx_target_ver = get_macosx_target_ver()
            if macosx_target_ver and split_version(macosx_target_ver) >= [10, 5]:
                return "-Wl,-rpath," + dir
            else: # no support for -rpath on earlier macOS versions
                return "-L" + dir
        elif sys.platform[:7] == "freebsd":
            return "-Wl,-rpath=" + dir
        elif sys.platform[:5] == "hp-ux":
            if self._is_gcc(compiler):
                return ["-Wl,+s", "-L" + dir]
            return ["+s", "-L" + dir]

        # For all compilers, `-Wl` is the presumed way to
        # pass a compiler option to the linker and `-R` is
        # the way to pass an RPATH.
        if sysconfig.get_config_var("GNULD") == "yes":
            # GNU ld needs an extra option to get a RUNPATH
            # instead of just an RPATH.
            return "-Wl,--enable-new-dtags,-R" + dir
        else:
            return "-Wl,-R" + dir

    def library_option(self, lib):
        return "-l" + lib

    def find_library_file(self, dirs, lib, debug=0):
        shared_f = self.library_filename(lib, lib_type='shared')
        dylib_f = self.library_filename(lib, lib_type='dylib')
        xcode_stub_f = self.library_filename(lib, lib_type='xcode_stub')
        static_f = self.library_filename(lib, lib_type='static')

        if sys.platform == 'darwin':
            # On OSX users can specify an alternate SDK using
            # '-isysroot', calculate the SDK root if it is specified
            # (and use it further on)
            #
            # Note that, as of Xcode 7, Apple SDKs may contain textual stub
            # libraries with .tbd extensions rather than the normal .dylib
            # shared libraries installed in /.  The Apple compiler tool
            # chain handles this transparently but it can cause problems
            # for programs that are being built with an SDK and searching
            # for specific libraries.  Callers of find_library_file need to
            # keep in mind that the base filename of the returned SDK library
            # file might have a different extension from that of the library
            # file installed on the running system, for example:
            #   /Applications/Xcode.app/Contents/Developer/Platforms/
            #       MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
            #       usr/lib/libedit.tbd
            # vs
            #   /usr/lib/libedit.dylib
            cflags = sysconfig.get_config_var('CFLAGS')
            m = re.search(r'-isysroot\s*(\S+)', cflags)
            if m is None:
                sysroot = '/'
            else:
                sysroot = m.group(1)



        for dir in dirs:
            shared = os.path.join(dir, shared_f)
            dylib = os.path.join(dir, dylib_f)
            static = os.path.join(dir, static_f)
            xcode_stub = os.path.join(dir, xcode_stub_f)

            if sys.platform == 'darwin' and (
                dir.startswith('/System/') or (
                dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):

                shared = os.path.join(sysroot, dir[1:], shared_f)
                dylib = os.path.join(sysroot, dir[1:], dylib_f)
                static = os.path.join(sysroot, dir[1:], static_f)
                xcode_stub = os.path.join(sysroot, dir[1:], xcode_stub_f)

            # We're second-guessing the linker here, with not much hard
            # data to go on: GCC seems to prefer the shared library, so I'm
            # assuming that *all* Unix C compilers do.  And of course I'm
            # ignoring even GCC's "-static" option.  So sue me.
            if os.path.exists(dylib):
                return dylib
            elif os.path.exists(xcode_stub):
                return xcode_stub
            elif os.path.exists(shared):
                return shared
            elif os.path.exists(static):
                return static

        # Oops, didn't find it in *any* of 'dirs'
        return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/util.py0000644000175100001710000005025700000000000021340 0ustar00runnerdocker"""distutils.util

Miscellaneous utility functions -- anything that doesn't fit into
one of the other *util.py modules.
"""

import os
import re
import importlib.util
import string
import sys
from distutils.errors import DistutilsPlatformError
from distutils.dep_util import newer
from distutils.spawn import spawn
from distutils import log
from distutils.errors import DistutilsByteCompileError
from .py35compat import _optim_args_from_interpreter_flags


def get_host_platform():
    """Return a string that identifies the current platform.  This is used mainly to
    distinguish platform-specific build directories and platform-specific built
    distributions.  Typically includes the OS name and version and the
    architecture (as supplied by 'os.uname()'), although the exact information
    included depends on the OS; eg. on Linux, the kernel version isn't
    particularly important.

    Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u

    Windows will return one of:
       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
       win32 (all others - specifically, sys.platform is returned)

    For other non-POSIX platforms, currently just returns 'sys.platform'.

    """
    if os.name == 'nt':
        if 'amd64' in sys.version.lower():
            return 'win-amd64'
        if '(arm)' in sys.version.lower():
            return 'win-arm32'
        if '(arm64)' in sys.version.lower():
            return 'win-arm64'
        return sys.platform

    # Set for cross builds explicitly
    if "_PYTHON_HOST_PLATFORM" in os.environ:
        return os.environ["_PYTHON_HOST_PLATFORM"]

    if os.name != "posix" or not hasattr(os, 'uname'):
        # XXX what about the architecture? NT is Intel or Alpha,
        # Mac OS is M68k or PPC, etc.
        return sys.platform

    # Try to distinguish various flavours of Unix

    (osname, host, release, version, machine) = os.uname()

    # Convert the OS name to lowercase, remove '/' characters, and translate
    # spaces (for "Power Macintosh")
    osname = osname.lower().replace('/', '')
    machine = machine.replace(' ', '_')
    machine = machine.replace('/', '-')

    if osname[:5] == "linux":
        # At least on Linux/Intel, 'machine' is the processor --
        # i386, etc.
        # XXX what about Alpha, SPARC, etc?
        return  "%s-%s" % (osname, machine)
    elif osname[:5] == "sunos":
        if release[0] >= "5":           # SunOS 5 == Solaris 2
            osname = "solaris"
            release = "%d.%s" % (int(release[0]) - 3, release[2:])
            # We can't use "platform.architecture()[0]" because a
            # bootstrap problem. We use a dict to get an error
            # if some suspicious happens.
            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
            machine += ".%s" % bitness[sys.maxsize]
        # fall through to standard osname-release-machine representation
    elif osname[:3] == "aix":
        from .py38compat import aix_platform
        return aix_platform(osname, version, release)
    elif osname[:6] == "cygwin":
        osname = "cygwin"
        rel_re = re.compile (r'[\d.]+', re.ASCII)
        m = rel_re.match(release)
        if m:
            release = m.group()
    elif osname[:6] == "darwin":
        import _osx_support, distutils.sysconfig
        osname, release, machine = _osx_support.get_platform_osx(
                                        distutils.sysconfig.get_config_vars(),
                                        osname, release, machine)

    return "%s-%s-%s" % (osname, release, machine)

def get_platform():
    if os.name == 'nt':
        TARGET_TO_PLAT = {
            'x86' : 'win32',
            'x64' : 'win-amd64',
            'arm' : 'win-arm32',
            'arm64': 'win-arm64',
        }
        return TARGET_TO_PLAT.get(os.environ.get('VSCMD_ARG_TGT_ARCH')) or get_host_platform()
    else:
        return get_host_platform()


if sys.platform == 'darwin':
    _syscfg_macosx_ver = None # cache the version pulled from sysconfig
MACOSX_VERSION_VAR = 'MACOSX_DEPLOYMENT_TARGET'

def _clear_cached_macosx_ver():
    """For testing only. Do not call."""
    global _syscfg_macosx_ver
    _syscfg_macosx_ver = None

def get_macosx_target_ver_from_syscfg():
    """Get the version of macOS latched in the Python interpreter configuration.
    Returns the version as a string or None if can't obtain one. Cached."""
    global _syscfg_macosx_ver
    if _syscfg_macosx_ver is None:
        from distutils import sysconfig
        ver = sysconfig.get_config_var(MACOSX_VERSION_VAR) or ''
        if ver:
            _syscfg_macosx_ver = ver
    return _syscfg_macosx_ver

def get_macosx_target_ver():
    """Return the version of macOS for which we are building.

    The target version defaults to the version in sysconfig latched at time
    the Python interpreter was built, unless overridden by an environment
    variable. If neither source has a value, then None is returned"""

    syscfg_ver = get_macosx_target_ver_from_syscfg()
    env_ver = os.environ.get(MACOSX_VERSION_VAR)

    if env_ver:
        # Validate overridden version against sysconfig version, if have both.
        # Ensure that the deployment target of the build process is not less
        # than 10.3 if the interpreter was built for 10.3 or later.  This
        # ensures extension modules are built with correct compatibility
        # values, specifically LDSHARED which can use
        # '-undefined dynamic_lookup' which only works on >= 10.3.
        if syscfg_ver and split_version(syscfg_ver) >= [10, 3] and \
            split_version(env_ver) < [10, 3]:
            my_msg = ('$' + MACOSX_VERSION_VAR + ' mismatch: '
                      'now "%s" but "%s" during configure; '
                      'must use 10.3 or later'
                      % (env_ver, syscfg_ver))
            raise DistutilsPlatformError(my_msg)
        return env_ver
    return syscfg_ver


def split_version(s):
    """Convert a dot-separated string into a list of numbers for comparisons"""
    return [int(n) for n in s.split('.')]


def convert_path (pathname):
    """Return 'pathname' as a name that will work on the native filesystem,
    i.e. split it on '/' and put it back together again using the current
    directory separator.  Needed because filenames in the setup script are
    always supplied in Unix style, and have to be converted to the local
    convention before we can actually use them in the filesystem.  Raises
    ValueError on non-Unix-ish systems if 'pathname' either starts or
    ends with a slash.
    """
    if os.sep == '/':
        return pathname
    if not pathname:
        return pathname
    if pathname[0] == '/':
        raise ValueError("path '%s' cannot be absolute" % pathname)
    if pathname[-1] == '/':
        raise ValueError("path '%s' cannot end with '/'" % pathname)

    paths = pathname.split('/')
    while '.' in paths:
        paths.remove('.')
    if not paths:
        return os.curdir
    return os.path.join(*paths)

# convert_path ()


def change_root (new_root, pathname):
    """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
    relative, this is equivalent to "os.path.join(new_root,pathname)".
    Otherwise, it requires making 'pathname' relative and then joining the
    two, which is tricky on DOS/Windows and Mac OS.
    """
    if os.name == 'posix':
        if not os.path.isabs(pathname):
            return os.path.join(new_root, pathname)
        else:
            return os.path.join(new_root, pathname[1:])

    elif os.name == 'nt':
        (drive, path) = os.path.splitdrive(pathname)
        if path[0] == '\\':
            path = path[1:]
        return os.path.join(new_root, path)

    else:
        raise DistutilsPlatformError("nothing known about platform '%s'" % os.name)


_environ_checked = 0
def check_environ ():
    """Ensure that 'os.environ' has all the environment variables we
    guarantee that users can use in config files, command-line options,
    etc.  Currently this includes:
      HOME - user's home directory (Unix only)
      PLAT - description of the current platform, including hardware
             and OS (see 'get_platform()')
    """
    global _environ_checked
    if _environ_checked:
        return

    if os.name == 'posix' and 'HOME' not in os.environ:
        try:
            import pwd
            os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
        except (ImportError, KeyError):
            # bpo-10496: if the current user identifier doesn't exist in the
            # password database, do nothing
            pass

    if 'PLAT' not in os.environ:
        os.environ['PLAT'] = get_platform()

    _environ_checked = 1


def subst_vars (s, local_vars):
    """
    Perform variable substitution on 'string'.
    Variables are indicated by format-style braces ("{var}").
    Variable is substituted by the value found in the 'local_vars'
    dictionary or in 'os.environ' if it's not in 'local_vars'.
    'os.environ' is first checked/augmented to guarantee that it contains
    certain values: see 'check_environ()'.  Raise ValueError for any
    variables not found in either 'local_vars' or 'os.environ'.
    """
    check_environ()
    lookup = dict(os.environ)
    lookup.update((name, str(value)) for name, value in local_vars.items())
    try:
        return _subst_compat(s).format_map(lookup)
    except KeyError as var:
        raise ValueError(f"invalid variable {var}")

# subst_vars ()


def _subst_compat(s):
    """
    Replace shell/Perl-style variable substitution with
    format-style. For compatibility.
    """
    def _subst(match):
        return f'{{{match.group(1)}}}'
    repl = re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
    if repl != s:
        import warnings
        warnings.warn(
            "shell/Perl-style substitions are deprecated",
            DeprecationWarning,
        )
    return repl


def grok_environment_error (exc, prefix="error: "):
    # Function kept for backward compatibility.
    # Used to try clever things with EnvironmentErrors,
    # but nowadays str(exception) produces good messages.
    return prefix + str(exc)


# Needed by 'split_quoted()'
_wordchars_re = _squote_re = _dquote_re = None
def _init_regex():
    global _wordchars_re, _squote_re, _dquote_re
    _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
    _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
    _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')

def split_quoted (s):
    """Split a string up according to Unix shell-like rules for quotes and
    backslashes.  In short: words are delimited by spaces, as long as those
    spaces are not escaped by a backslash, or inside a quoted string.
    Single and double quotes are equivalent, and the quote characters can
    be backslash-escaped.  The backslash is stripped from any two-character
    escape sequence, leaving only the escaped character.  The quote
    characters are stripped from any quoted string.  Returns a list of
    words.
    """

    # This is a nice algorithm for splitting up a single string, since it
    # doesn't require character-by-character examination.  It was a little
    # bit of a brain-bender to get it working right, though...
    if _wordchars_re is None: _init_regex()

    s = s.strip()
    words = []
    pos = 0

    while s:
        m = _wordchars_re.match(s, pos)
        end = m.end()
        if end == len(s):
            words.append(s[:end])
            break

        if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
            words.append(s[:end])       # we definitely have a word delimiter
            s = s[end:].lstrip()
            pos = 0

        elif s[end] == '\\':            # preserve whatever is being escaped;
                                        # will become part of the current word
            s = s[:end] + s[end+1:]
            pos = end+1

        else:
            if s[end] == "'":           # slurp singly-quoted string
                m = _squote_re.match(s, end)
            elif s[end] == '"':         # slurp doubly-quoted string
                m = _dquote_re.match(s, end)
            else:
                raise RuntimeError("this can't happen (bad char '%c')" % s[end])

            if m is None:
                raise ValueError("bad string (mismatched %s quotes?)" % s[end])

            (beg, end) = m.span()
            s = s[:beg] + s[beg+1:end-1] + s[end:]
            pos = m.end() - 2

        if pos >= len(s):
            words.append(s)
            break

    return words

# split_quoted ()


def execute (func, args, msg=None, verbose=0, dry_run=0):
    """Perform some action that affects the outside world (eg.  by
    writing to the filesystem).  Such actions are special because they
    are disabled by the 'dry_run' flag.  This method takes care of all
    that bureaucracy for you; all you have to do is supply the
    function to call and an argument tuple for it (to embody the
    "external action" being performed), and an optional message to
    print.
    """
    if msg is None:
        msg = "%s%r" % (func.__name__, args)
        if msg[-2:] == ',)':        # correct for singleton tuple
            msg = msg[0:-2] + ')'

    log.info(msg)
    if not dry_run:
        func(*args)


def strtobool (val):
    """Convert a string representation of truth to true (1) or false (0).

    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
    'val' is anything else.
    """
    val = val.lower()
    if val in ('y', 'yes', 't', 'true', 'on', '1'):
        return 1
    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
        return 0
    else:
        raise ValueError("invalid truth value %r" % (val,))


def byte_compile (py_files,
                  optimize=0, force=0,
                  prefix=None, base_dir=None,
                  verbose=1, dry_run=0,
                  direct=None):
    """Byte-compile a collection of Python source files to .pyc
    files in a __pycache__ subdirectory.  'py_files' is a list
    of files to compile; any files that don't end in ".py" are silently
    skipped.  'optimize' must be one of the following:
      0 - don't optimize
      1 - normal optimization (like "python -O")
      2 - extra optimization (like "python -OO")
    If 'force' is true, all files are recompiled regardless of
    timestamps.

    The source filename encoded in each bytecode file defaults to the
    filenames listed in 'py_files'; you can modify these with 'prefix' and
    'basedir'.  'prefix' is a string that will be stripped off of each
    source filename, and 'base_dir' is a directory name that will be
    prepended (after 'prefix' is stripped).  You can supply either or both
    (or neither) of 'prefix' and 'base_dir', as you wish.

    If 'dry_run' is true, doesn't actually do anything that would
    affect the filesystem.

    Byte-compilation is either done directly in this interpreter process
    with the standard py_compile module, or indirectly by writing a
    temporary script and executing it.  Normally, you should let
    'byte_compile()' figure out to use direct compilation or not (see
    the source for details).  The 'direct' flag is used by the script
    generated in indirect mode; unless you know what you're doing, leave
    it set to None.
    """

    # Late import to fix a bootstrap issue: _posixsubprocess is built by
    # setup.py, but setup.py uses distutils.
    import subprocess

    # nothing is done if sys.dont_write_bytecode is True
    if sys.dont_write_bytecode:
        raise DistutilsByteCompileError('byte-compiling is disabled.')

    # First, if the caller didn't force us into direct or indirect mode,
    # figure out which mode we should be in.  We take a conservative
    # approach: choose direct mode *only* if the current interpreter is
    # in debug mode and optimize is 0.  If we're not in debug mode (-O
    # or -OO), we don't know which level of optimization this
    # interpreter is running with, so we can't do direct
    # byte-compilation and be certain that it's the right thing.  Thus,
    # always compile indirectly if the current interpreter is in either
    # optimize mode, or if either optimization level was requested by
    # the caller.
    if direct is None:
        direct = (__debug__ and optimize == 0)

    # "Indirect" byte-compilation: write a temporary script and then
    # run it with the appropriate flags.
    if not direct:
        try:
            from tempfile import mkstemp
            (script_fd, script_name) = mkstemp(".py")
        except ImportError:
            from tempfile import mktemp
            (script_fd, script_name) = None, mktemp(".py")
        log.info("writing byte-compilation script '%s'", script_name)
        if not dry_run:
            if script_fd is not None:
                script = os.fdopen(script_fd, "w")
            else:
                script = open(script_name, "w")

            with script:
                script.write("""\
from distutils.util import byte_compile
files = [
""")

                # XXX would be nice to write absolute filenames, just for
                # safety's sake (script should be more robust in the face of
                # chdir'ing before running it).  But this requires abspath'ing
                # 'prefix' as well, and that breaks the hack in build_lib's
                # 'byte_compile()' method that carefully tacks on a trailing
                # slash (os.sep really) to make sure the prefix here is "just
                # right".  This whole prefix business is rather delicate -- the
                # problem is that it's really a directory, but I'm treating it
                # as a dumb string, so trailing slashes and so forth matter.

                #py_files = map(os.path.abspath, py_files)
                #if prefix:
                #    prefix = os.path.abspath(prefix)

                script.write(",\n".join(map(repr, py_files)) + "]\n")
                script.write("""
byte_compile(files, optimize=%r, force=%r,
             prefix=%r, base_dir=%r,
             verbose=%r, dry_run=0,
             direct=1)
""" % (optimize, force, prefix, base_dir, verbose))

        cmd = [sys.executable]
        cmd.extend(_optim_args_from_interpreter_flags())
        cmd.append(script_name)
        spawn(cmd, dry_run=dry_run)
        execute(os.remove, (script_name,), "removing %s" % script_name,
                dry_run=dry_run)

    # "Direct" byte-compilation: use the py_compile module to compile
    # right here, right now.  Note that the script generated in indirect
    # mode simply calls 'byte_compile()' in direct mode, a weird sort of
    # cross-process recursion.  Hey, it works!
    else:
        from py_compile import compile

        for file in py_files:
            if file[-3:] != ".py":
                # This lets us be lazy and not filter filenames in
                # the "install_lib" command.
                continue

            # Terminology from the py_compile module:
            #   cfile - byte-compiled file
            #   dfile - purported source filename (same as 'file' by default)
            if optimize >= 0:
                opt = '' if optimize == 0 else optimize
                cfile = importlib.util.cache_from_source(
                    file, optimization=opt)
            else:
                cfile = importlib.util.cache_from_source(file)
            dfile = file
            if prefix:
                if file[:len(prefix)] != prefix:
                    raise ValueError("invalid prefix: filename %r doesn't start with %r"
                           % (file, prefix))
                dfile = dfile[len(prefix):]
            if base_dir:
                dfile = os.path.join(base_dir, dfile)

            cfile_base = os.path.basename(cfile)
            if direct:
                if force or newer(file, cfile):
                    log.info("byte-compiling %s to %s", file, cfile_base)
                    if not dry_run:
                        compile(file, cfile, dfile)
                else:
                    log.debug("skipping byte-compilation of %s to %s",
                              file, cfile_base)

# byte_compile ()

def rfc822_escape (header):
    """Return a version of the string escaped for inclusion in an
    RFC-822 header, by ensuring there are 8 spaces space after each newline.
    """
    lines = header.split('\n')
    sep = '\n' + 8 * ' '
    return sep.join(lines)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/version.py0000644000175100001710000003132700000000000022045 0ustar00runnerdocker#
# distutils/version.py
#
# Implements multiple version numbering conventions for the
# Python Module Distribution Utilities.
#
# $Id$
#

"""Provides classes to represent module version numbers (one class for
each style of version numbering).  There are currently two such classes
implemented: StrictVersion and LooseVersion.

Every version number class implements the following interface:
  * the 'parse' method takes a string and parses it to some internal
    representation; if the string is an invalid version number,
    'parse' raises a ValueError exception
  * the class constructor takes an optional string argument which,
    if supplied, is passed to 'parse'
  * __str__ reconstructs the string that was passed to 'parse' (or
    an equivalent string -- ie. one that will generate an equivalent
    version number instance)
  * __repr__ generates Python code to recreate the version number instance
  * _cmp compares the current instance with either another instance
    of the same class or a string (which will be parsed to an instance
    of the same class, thus must follow the same rules)
"""

import re
import warnings
import contextlib


@contextlib.contextmanager
def suppress_known_deprecation():
    with warnings.catch_warnings(record=True) as ctx:
        warnings.filterwarnings(
            action='default',
            category=DeprecationWarning,
            message="distutils Version classes are deprecated.",
        )
        yield ctx


class Version:
    """Abstract base class for version numbering classes.  Just provides
    constructor (__init__) and reproducer (__repr__), because those
    seem to be the same for all version numbering classes; and route
    rich comparisons to _cmp.
    """

    def __init__ (self, vstring=None):
        warnings.warn(
            "distutils Version classes are deprecated. "
            "Use packaging.version instead.",
            DeprecationWarning,
            stacklevel=2,
        )
        if vstring:
            self.parse(vstring)

    def __repr__ (self):
        return "%s ('%s')" % (self.__class__.__name__, str(self))

    def __eq__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c == 0

    def __lt__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c < 0

    def __le__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c <= 0

    def __gt__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c > 0

    def __ge__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c >= 0


# Interface for version-number classes -- must be implemented
# by the following classes (the concrete ones -- Version should
# be treated as an abstract class).
#    __init__ (string) - create and take same action as 'parse'
#                        (string parameter is optional)
#    parse (string)    - convert a string representation to whatever
#                        internal representation is appropriate for
#                        this style of version numbering
#    __str__ (self)    - convert back to a string; should be very similar
#                        (if not identical to) the string supplied to parse
#    __repr__ (self)   - generate Python code to recreate
#                        the instance
#    _cmp (self, other) - compare two version numbers ('other' may
#                        be an unparsed version string, or another
#                        instance of your version class)


class StrictVersion (Version):

    """Version numbering for anal retentives and software idealists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of two or three
    dot-separated numeric components, with an optional "pre-release" tag
    on the end.  The pre-release tag consists of the letter 'a' or 'b'
    followed by a number.  If the numeric components of two version
    numbers are equal, then one with a pre-release tag will always
    be deemed earlier (lesser) than one without.

    The following are valid version numbers (shown in the order that
    would be obtained by sorting according to the supplied cmp function):

        0.4       0.4.0  (these two are equivalent)
        0.4.1
        0.5a1
        0.5b3
        0.5
        0.9.6
        1.0
        1.0.4a3
        1.0.4b1
        1.0.4

    The following are examples of invalid version numbers:

        1
        2.7.2.2
        1.3.a4
        1.3pl1
        1.3c4

    The rationale for this version numbering system will be explained
    in the distutils documentation.
    """

    version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$',
                            re.VERBOSE | re.ASCII)


    def parse (self, vstring):
        match = self.version_re.match(vstring)
        if not match:
            raise ValueError("invalid version number '%s'" % vstring)

        (major, minor, patch, prerelease, prerelease_num) = \
            match.group(1, 2, 4, 5, 6)

        if patch:
            self.version = tuple(map(int, [major, minor, patch]))
        else:
            self.version = tuple(map(int, [major, minor])) + (0,)

        if prerelease:
            self.prerelease = (prerelease[0], int(prerelease_num))
        else:
            self.prerelease = None


    def __str__ (self):

        if self.version[2] == 0:
            vstring = '.'.join(map(str, self.version[0:2]))
        else:
            vstring = '.'.join(map(str, self.version))

        if self.prerelease:
            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])

        return vstring


    def _cmp (self, other):
        if isinstance(other, str):
            with suppress_known_deprecation():
                other = StrictVersion(other)
        elif not isinstance(other, StrictVersion):
            return NotImplemented

        if self.version != other.version:
            # numeric versions don't match
            # prerelease stuff doesn't matter
            if self.version < other.version:
                return -1
            else:
                return 1

        # have to compare prerelease
        # case 1: neither has prerelease; they're equal
        # case 2: self has prerelease, other doesn't; other is greater
        # case 3: self doesn't have prerelease, other does: self is greater
        # case 4: both have prerelease: must compare them!

        if (not self.prerelease and not other.prerelease):
            return 0
        elif (self.prerelease and not other.prerelease):
            return -1
        elif (not self.prerelease and other.prerelease):
            return 1
        elif (self.prerelease and other.prerelease):
            if self.prerelease == other.prerelease:
                return 0
            elif self.prerelease < other.prerelease:
                return -1
            else:
                return 1
        else:
            assert False, "never get here"

# end class StrictVersion


# The rules according to Greg Stein:
# 1) a version number has 1 or more numbers separated by a period or by
#    sequences of letters. If only periods, then these are compared
#    left-to-right to determine an ordering.
# 2) sequences of letters are part of the tuple for comparison and are
#    compared lexicographically
# 3) recognize the numeric components may have leading zeroes
#
# The LooseVersion class below implements these rules: a version number
# string is split up into a tuple of integer and string components, and
# comparison is a simple tuple comparison.  This means that version
# numbers behave in a predictable and obvious way, but a way that might
# not necessarily be how people *want* version numbers to behave.  There
# wouldn't be a problem if people could stick to purely numeric version
# numbers: just split on period and compare the numbers as tuples.
# However, people insist on putting letters into their version numbers;
# the most common purpose seems to be:
#   - indicating a "pre-release" version
#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
#   - indicating a post-release patch ('p', 'pl', 'patch')
# but of course this can't cover all version number schemes, and there's
# no way to know what a programmer means without asking him.
#
# The problem is what to do with letters (and other non-numeric
# characters) in a version number.  The current implementation does the
# obvious and predictable thing: keep them as strings and compare
# lexically within a tuple comparison.  This has the desired effect if
# an appended letter sequence implies something "post-release":
# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
#
# However, if letters in a version number imply a pre-release version,
# the "obvious" thing isn't correct.  Eg. you would expect that
# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
# implemented here, this just isn't so.
#
# Two possible solutions come to mind.  The first is to tie the
# comparison algorithm to a particular set of semantic rules, as has
# been done in the StrictVersion class above.  This works great as long
# as everyone can go along with bondage and discipline.  Hopefully a
# (large) subset of Python module programmers will agree that the
# particular flavour of bondage and discipline provided by StrictVersion
# provides enough benefit to be worth using, and will submit their
# version numbering scheme to its domination.  The free-thinking
# anarchists in the lot will never give in, though, and something needs
# to be done to accommodate them.
#
# Perhaps a "moderately strict" version class could be implemented that
# lets almost anything slide (syntactically), and makes some heuristic
# assumptions about non-digits in version number strings.  This could
# sink into special-case-hell, though; if I was as talented and
# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
# just as happy dealing with things like "2g6" and "1.13++".  I don't
# think I'm smart enough to do it right though.
#
# In any case, I've coded the test suite for this module (see
# ../test/test_version.py) specifically to fail on things like comparing
# "1.2a2" and "1.2".  That's not because the *code* is doing anything
# wrong, it's because the simple, obvious design doesn't match my
# complicated, hairy expectations for real-world version numbers.  It
# would be a snap to fix the test suite to say, "Yep, LooseVersion does
# the Right Thing" (ie. the code matches the conception).  But I'd rather
# have a conception that matches common notions about version numbers.

class LooseVersion (Version):

    """Version numbering for anarchists and software realists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of a series of numbers,
    separated by either periods or strings of letters.  When comparing
    version numbers, the numeric components will be compared
    numerically, and the alphabetic components lexically.  The following
    are all valid version numbers, in no particular order:

        1.5.1
        1.5.2b2
        161
        3.10a
        8.02
        3.4j
        1996.07.12
        3.2.pl0
        3.1.1.6
        2g6
        11g
        0.960923
        2.2beta29
        1.13++
        5.5.kw
        2.0b1pl0

    In fact, there is no such thing as an invalid version number under
    this scheme; the rules for comparison are simple and predictable,
    but may not always give the results you want (for some definition
    of "want").
    """

    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)

    def parse (self, vstring):
        # I've given up on thinking I can reconstruct the version string
        # from the parsed tuple -- so I just store the string here for
        # use by __str__
        self.vstring = vstring
        components = [x for x in self.component_re.split(vstring)
                              if x and x != '.']
        for i, obj in enumerate(components):
            try:
                components[i] = int(obj)
            except ValueError:
                pass

        self.version = components


    def __str__ (self):
        return self.vstring


    def __repr__ (self):
        return "LooseVersion ('%s')" % str(self)


    def _cmp (self, other):
        if isinstance(other, str):
            other = LooseVersion(other)
        elif not isinstance(other, LooseVersion):
            return NotImplemented

        if self.version == other.version:
            return 0
        if self.version < other.version:
            return -1
        if self.version > other.version:
            return 1


# end class LooseVersion
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_distutils/versionpredicate.py0000644000175100001710000001223500000000000023723 0ustar00runnerdocker"""Module for parsing and testing package version predicate strings.
"""
import re
import distutils.version
import operator


re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)",
    re.ASCII)
# (package) (rest)

re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses
re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
# (comp) (version)


def splitUp(pred):
    """Parse a single version comparison.

    Return (comparison string, StrictVersion)
    """
    res = re_splitComparison.match(pred)
    if not res:
        raise ValueError("bad package restriction syntax: %r" % pred)
    comp, verStr = res.groups()
    with distutils.version.suppress_known_deprecation():
        other = distutils.version.StrictVersion(verStr)
    return (comp, other)

compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}

class VersionPredicate:
    """Parse and test package version predicates.

    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')

    The `name` attribute provides the full dotted name that is given::

    >>> v.name
    'pyepat.abc'

    The str() of a `VersionPredicate` provides a normalized
    human-readable version of the expression::

    >>> print(v)
    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)

    The `satisfied_by()` method can be used to determine with a given
    version number is included in the set described by the version
    restrictions::

    >>> v.satisfied_by('1.1')
    True
    >>> v.satisfied_by('1.4')
    True
    >>> v.satisfied_by('1.0')
    False
    >>> v.satisfied_by('4444.4')
    False
    >>> v.satisfied_by('1555.1b3')
    False

    `VersionPredicate` is flexible in accepting extra whitespace::

    >>> v = VersionPredicate(' pat( ==  0.1  )  ')
    >>> v.name
    'pat'
    >>> v.satisfied_by('0.1')
    True
    >>> v.satisfied_by('0.2')
    False

    If any version numbers passed in do not conform to the
    restrictions of `StrictVersion`, a `ValueError` is raised::

    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
    Traceback (most recent call last):
      ...
    ValueError: invalid version number '1.2zb3'

    It the module or package name given does not conform to what's
    allowed as a legal module or package name, `ValueError` is
    raised::

    >>> v = VersionPredicate('foo-bar')
    Traceback (most recent call last):
      ...
    ValueError: expected parenthesized list: '-bar'

    >>> v = VersionPredicate('foo bar (12.21)')
    Traceback (most recent call last):
      ...
    ValueError: expected parenthesized list: 'bar (12.21)'

    """

    def __init__(self, versionPredicateStr):
        """Parse a version predicate string.
        """
        # Fields:
        #    name:  package name
        #    pred:  list of (comparison string, StrictVersion)

        versionPredicateStr = versionPredicateStr.strip()
        if not versionPredicateStr:
            raise ValueError("empty package restriction")
        match = re_validPackage.match(versionPredicateStr)
        if not match:
            raise ValueError("bad package name in %r" % versionPredicateStr)
        self.name, paren = match.groups()
        paren = paren.strip()
        if paren:
            match = re_paren.match(paren)
            if not match:
                raise ValueError("expected parenthesized list: %r" % paren)
            str = match.groups()[0]
            self.pred = [splitUp(aPred) for aPred in str.split(",")]
            if not self.pred:
                raise ValueError("empty parenthesized list in %r"
                                 % versionPredicateStr)
        else:
            self.pred = []

    def __str__(self):
        if self.pred:
            seq = [cond + " " + str(ver) for cond, ver in self.pred]
            return self.name + " (" + ", ".join(seq) + ")"
        else:
            return self.name

    def satisfied_by(self, version):
        """True if version is compatible with all the predicates in self.
        The parameter version must be acceptable to the StrictVersion
        constructor.  It may be either a string or StrictVersion.
        """
        for cond, ver in self.pred:
            if not compmap[cond](version, ver):
                return False
        return True


_provision_rx = None

def split_provision(value):
    """Return the name and optional version number of a provision.

    The version number, if given, will be returned as a `StrictVersion`
    instance, otherwise it will be `None`.

    >>> split_provision('mypkg')
    ('mypkg', None)
    >>> split_provision(' mypkg( 1.2 ) ')
    ('mypkg', StrictVersion ('1.2'))
    """
    global _provision_rx
    if _provision_rx is None:
        _provision_rx = re.compile(
            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$",
            re.ASCII)
    value = value.strip()
    m = _provision_rx.match(value)
    if not m:
        raise ValueError("illegal provides specification: %r" % value)
    ver = m.group(2) or None
    if ver:
        with distutils.version.suppress_known_deprecation():
            ver = distutils.version.StrictVersion(ver)
    return m.group(1), ver
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_imp.py0000644000175100001710000000453000000000000017115 0ustar00runnerdocker"""
Re-implementation of find_module and get_frozen_object
from the deprecated imp module.
"""

import os
import importlib.util
import importlib.machinery

from .py34compat import module_from_spec


PY_SOURCE = 1
PY_COMPILED = 2
C_EXTENSION = 3
C_BUILTIN = 6
PY_FROZEN = 7


def find_spec(module, paths):
    finder = (
        importlib.machinery.PathFinder().find_spec
        if isinstance(paths, list) else
        importlib.util.find_spec
    )
    return finder(module, paths)


def find_module(module, paths=None):
    """Just like 'imp.find_module()', but with package support"""
    spec = find_spec(module, paths)
    if spec is None:
        raise ImportError("Can't find %s" % module)
    if not spec.has_location and hasattr(spec, 'submodule_search_locations'):
        spec = importlib.util.spec_from_loader('__init__.py', spec.loader)

    kind = -1
    file = None
    static = isinstance(spec.loader, type)
    if spec.origin == 'frozen' or static and issubclass(
            spec.loader, importlib.machinery.FrozenImporter):
        kind = PY_FROZEN
        path = None  # imp compabilty
        suffix = mode = ''  # imp compatibility
    elif spec.origin == 'built-in' or static and issubclass(
            spec.loader, importlib.machinery.BuiltinImporter):
        kind = C_BUILTIN
        path = None  # imp compabilty
        suffix = mode = ''  # imp compatibility
    elif spec.has_location:
        path = spec.origin
        suffix = os.path.splitext(path)[1]
        mode = 'r' if suffix in importlib.machinery.SOURCE_SUFFIXES else 'rb'

        if suffix in importlib.machinery.SOURCE_SUFFIXES:
            kind = PY_SOURCE
        elif suffix in importlib.machinery.BYTECODE_SUFFIXES:
            kind = PY_COMPILED
        elif suffix in importlib.machinery.EXTENSION_SUFFIXES:
            kind = C_EXTENSION

        if kind in {PY_SOURCE, PY_COMPILED}:
            file = open(path, mode)
    else:
        path = None
        suffix = mode = ''

    return file, path, (suffix, mode, kind)


def get_frozen_object(module, paths=None):
    spec = find_spec(module, paths)
    if not spec:
        raise ImportError("Can't find %s" % module)
    return spec.loader.get_code(module)


def get_module(module, paths, info):
    spec = find_spec(module, paths)
    if not spec:
        raise ImportError("Can't find %s" % module)
    return module_from_spec(spec)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9346702
setuptools-59.6.0/setuptools/_vendor/0000755000175100001710000000000000000000000017251 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/__init__.py0000644000175100001710000000000000000000000021350 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9346702
setuptools-59.6.0/setuptools/_vendor/more_itertools/0000755000175100001710000000000000000000000022317 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/more_itertools/__init__.py0000644000175100001710000000012200000000000024423 0ustar00runnerdockerfrom .more import *  # noqa
from .recipes import *  # noqa

__version__ = '8.8.0'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/more_itertools/more.py0000644000175100001710000034632000000000000023643 0ustar00runnerdockerimport warnings

from collections import Counter, defaultdict, deque, abc
from collections.abc import Sequence
from concurrent.futures import ThreadPoolExecutor
from functools import partial, reduce, wraps
from heapq import merge, heapify, heapreplace, heappop
from itertools import (
    chain,
    compress,
    count,
    cycle,
    dropwhile,
    groupby,
    islice,
    repeat,
    starmap,
    takewhile,
    tee,
    zip_longest,
)
from math import exp, factorial, floor, log
from queue import Empty, Queue
from random import random, randrange, uniform
from operator import itemgetter, mul, sub, gt, lt
from sys import hexversion, maxsize
from time import monotonic

from .recipes import (
    consume,
    flatten,
    pairwise,
    powerset,
    take,
    unique_everseen,
)

__all__ = [
    'AbortThread',
    'adjacent',
    'always_iterable',
    'always_reversible',
    'bucket',
    'callback_iter',
    'chunked',
    'circular_shifts',
    'collapse',
    'collate',
    'consecutive_groups',
    'consumer',
    'countable',
    'count_cycle',
    'mark_ends',
    'difference',
    'distinct_combinations',
    'distinct_permutations',
    'distribute',
    'divide',
    'exactly_n',
    'filter_except',
    'first',
    'groupby_transform',
    'ilen',
    'interleave_longest',
    'interleave',
    'intersperse',
    'islice_extended',
    'iterate',
    'ichunked',
    'is_sorted',
    'last',
    'locate',
    'lstrip',
    'make_decorator',
    'map_except',
    'map_reduce',
    'nth_or_last',
    'nth_permutation',
    'nth_product',
    'numeric_range',
    'one',
    'only',
    'padded',
    'partitions',
    'set_partitions',
    'peekable',
    'repeat_last',
    'replace',
    'rlocate',
    'rstrip',
    'run_length',
    'sample',
    'seekable',
    'SequenceView',
    'side_effect',
    'sliced',
    'sort_together',
    'split_at',
    'split_after',
    'split_before',
    'split_when',
    'split_into',
    'spy',
    'stagger',
    'strip',
    'substrings',
    'substrings_indexes',
    'time_limited',
    'unique_to_each',
    'unzip',
    'windowed',
    'with_iter',
    'UnequalIterablesError',
    'zip_equal',
    'zip_offset',
    'windowed_complete',
    'all_unique',
    'value_chain',
    'product_index',
    'combination_index',
    'permutation_index',
]

_marker = object()


def chunked(iterable, n, strict=False):
    """Break *iterable* into lists of length *n*:

        >>> list(chunked([1, 2, 3, 4, 5, 6], 3))
        [[1, 2, 3], [4, 5, 6]]

    By the default, the last yielded list will have fewer than *n* elements
    if the length of *iterable* is not divisible by *n*:

        >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3))
        [[1, 2, 3], [4, 5, 6], [7, 8]]

    To use a fill-in value instead, see the :func:`grouper` recipe.

    If the length of *iterable* is not divisible by *n* and *strict* is
    ``True``, then ``ValueError`` will be raised before the last
    list is yielded.

    """
    iterator = iter(partial(take, n, iter(iterable)), [])
    if strict:

        def ret():
            for chunk in iterator:
                if len(chunk) != n:
                    raise ValueError('iterable is not divisible by n.')
                yield chunk

        return iter(ret())
    else:
        return iterator


def first(iterable, default=_marker):
    """Return the first item of *iterable*, or *default* if *iterable* is
    empty.

        >>> first([0, 1, 2, 3])
        0
        >>> first([], 'some default')
        'some default'

    If *default* is not provided and there are no items in the iterable,
    raise ``ValueError``.

    :func:`first` is useful when you have a generator of expensive-to-retrieve
    values and want any arbitrary one. It is marginally shorter than
    ``next(iter(iterable), default)``.

    """
    try:
        return next(iter(iterable))
    except StopIteration as e:
        if default is _marker:
            raise ValueError(
                'first() was called on an empty iterable, and no '
                'default value was provided.'
            ) from e
        return default


def last(iterable, default=_marker):
    """Return the last item of *iterable*, or *default* if *iterable* is
    empty.

        >>> last([0, 1, 2, 3])
        3
        >>> last([], 'some default')
        'some default'

    If *default* is not provided and there are no items in the iterable,
    raise ``ValueError``.
    """
    try:
        if isinstance(iterable, Sequence):
            return iterable[-1]
        # Work around https://bugs.python.org/issue38525
        elif hasattr(iterable, '__reversed__') and (hexversion != 0x030800F0):
            return next(reversed(iterable))
        else:
            return deque(iterable, maxlen=1)[-1]
    except (IndexError, TypeError, StopIteration):
        if default is _marker:
            raise ValueError(
                'last() was called on an empty iterable, and no default was '
                'provided.'
            )
        return default


def nth_or_last(iterable, n, default=_marker):
    """Return the nth or the last item of *iterable*,
    or *default* if *iterable* is empty.

        >>> nth_or_last([0, 1, 2, 3], 2)
        2
        >>> nth_or_last([0, 1], 2)
        1
        >>> nth_or_last([], 0, 'some default')
        'some default'

    If *default* is not provided and there are no items in the iterable,
    raise ``ValueError``.
    """
    return last(islice(iterable, n + 1), default=default)


class peekable:
    """Wrap an iterator to allow lookahead and prepending elements.

    Call :meth:`peek` on the result to get the value that will be returned
    by :func:`next`. This won't advance the iterator:

        >>> p = peekable(['a', 'b'])
        >>> p.peek()
        'a'
        >>> next(p)
        'a'

    Pass :meth:`peek` a default value to return that instead of raising
    ``StopIteration`` when the iterator is exhausted.

        >>> p = peekable([])
        >>> p.peek('hi')
        'hi'

    peekables also offer a :meth:`prepend` method, which "inserts" items
    at the head of the iterable:

        >>> p = peekable([1, 2, 3])
        >>> p.prepend(10, 11, 12)
        >>> next(p)
        10
        >>> p.peek()
        11
        >>> list(p)
        [11, 12, 1, 2, 3]

    peekables can be indexed. Index 0 is the item that will be returned by
    :func:`next`, index 1 is the item after that, and so on:
    The values up to the given index will be cached.

        >>> p = peekable(['a', 'b', 'c', 'd'])
        >>> p[0]
        'a'
        >>> p[1]
        'b'
        >>> next(p)
        'a'

    Negative indexes are supported, but be aware that they will cache the
    remaining items in the source iterator, which may require significant
    storage.

    To check whether a peekable is exhausted, check its truth value:

        >>> p = peekable(['a', 'b'])
        >>> if p:  # peekable has items
        ...     list(p)
        ['a', 'b']
        >>> if not p:  # peekable is exhausted
        ...     list(p)
        []

    """

    def __init__(self, iterable):
        self._it = iter(iterable)
        self._cache = deque()

    def __iter__(self):
        return self

    def __bool__(self):
        try:
            self.peek()
        except StopIteration:
            return False
        return True

    def peek(self, default=_marker):
        """Return the item that will be next returned from ``next()``.

        Return ``default`` if there are no items left. If ``default`` is not
        provided, raise ``StopIteration``.

        """
        if not self._cache:
            try:
                self._cache.append(next(self._it))
            except StopIteration:
                if default is _marker:
                    raise
                return default
        return self._cache[0]

    def prepend(self, *items):
        """Stack up items to be the next ones returned from ``next()`` or
        ``self.peek()``. The items will be returned in
        first in, first out order::

            >>> p = peekable([1, 2, 3])
            >>> p.prepend(10, 11, 12)
            >>> next(p)
            10
            >>> list(p)
            [11, 12, 1, 2, 3]

        It is possible, by prepending items, to "resurrect" a peekable that
        previously raised ``StopIteration``.

            >>> p = peekable([])
            >>> next(p)
            Traceback (most recent call last):
              ...
            StopIteration
            >>> p.prepend(1)
            >>> next(p)
            1
            >>> next(p)
            Traceback (most recent call last):
              ...
            StopIteration

        """
        self._cache.extendleft(reversed(items))

    def __next__(self):
        if self._cache:
            return self._cache.popleft()

        return next(self._it)

    def _get_slice(self, index):
        # Normalize the slice's arguments
        step = 1 if (index.step is None) else index.step
        if step > 0:
            start = 0 if (index.start is None) else index.start
            stop = maxsize if (index.stop is None) else index.stop
        elif step < 0:
            start = -1 if (index.start is None) else index.start
            stop = (-maxsize - 1) if (index.stop is None) else index.stop
        else:
            raise ValueError('slice step cannot be zero')

        # If either the start or stop index is negative, we'll need to cache
        # the rest of the iterable in order to slice from the right side.
        if (start < 0) or (stop < 0):
            self._cache.extend(self._it)
        # Otherwise we'll need to find the rightmost index and cache to that
        # point.
        else:
            n = min(max(start, stop) + 1, maxsize)
            cache_len = len(self._cache)
            if n >= cache_len:
                self._cache.extend(islice(self._it, n - cache_len))

        return list(self._cache)[index]

    def __getitem__(self, index):
        if isinstance(index, slice):
            return self._get_slice(index)

        cache_len = len(self._cache)
        if index < 0:
            self._cache.extend(self._it)
        elif index >= cache_len:
            self._cache.extend(islice(self._it, index + 1 - cache_len))

        return self._cache[index]


def collate(*iterables, **kwargs):
    """Return a sorted merge of the items from each of several already-sorted
    *iterables*.

        >>> list(collate('ACDZ', 'AZ', 'JKL'))
        ['A', 'A', 'C', 'D', 'J', 'K', 'L', 'Z', 'Z']

    Works lazily, keeping only the next value from each iterable in memory. Use
    :func:`collate` to, for example, perform a n-way mergesort of items that
    don't fit in memory.

    If a *key* function is specified, the iterables will be sorted according
    to its result:

        >>> key = lambda s: int(s)  # Sort by numeric value, not by string
        >>> list(collate(['1', '10'], ['2', '11'], key=key))
        ['1', '2', '10', '11']


    If the *iterables* are sorted in descending order, set *reverse* to
    ``True``:

        >>> list(collate([5, 3, 1], [4, 2, 0], reverse=True))
        [5, 4, 3, 2, 1, 0]

    If the elements of the passed-in iterables are out of order, you might get
    unexpected results.

    On Python 3.5+, this function is an alias for :func:`heapq.merge`.

    """
    warnings.warn(
        "collate is no longer part of more_itertools, use heapq.merge",
        DeprecationWarning,
    )
    return merge(*iterables, **kwargs)


def consumer(func):
    """Decorator that automatically advances a PEP-342-style "reverse iterator"
    to its first yield point so you don't have to call ``next()`` on it
    manually.

        >>> @consumer
        ... def tally():
        ...     i = 0
        ...     while True:
        ...         print('Thing number %s is %s.' % (i, (yield)))
        ...         i += 1
        ...
        >>> t = tally()
        >>> t.send('red')
        Thing number 0 is red.
        >>> t.send('fish')
        Thing number 1 is fish.

    Without the decorator, you would have to call ``next(t)`` before
    ``t.send()`` could be used.

    """

    @wraps(func)
    def wrapper(*args, **kwargs):
        gen = func(*args, **kwargs)
        next(gen)
        return gen

    return wrapper


def ilen(iterable):
    """Return the number of items in *iterable*.

        >>> ilen(x for x in range(1000000) if x % 3 == 0)
        333334

    This consumes the iterable, so handle with care.

    """
    # This approach was selected because benchmarks showed it's likely the
    # fastest of the known implementations at the time of writing.
    # See GitHub tracker: #236, #230.
    counter = count()
    deque(zip(iterable, counter), maxlen=0)
    return next(counter)


def iterate(func, start):
    """Return ``start``, ``func(start)``, ``func(func(start))``, ...

    >>> from itertools import islice
    >>> list(islice(iterate(lambda x: 2*x, 1), 10))
    [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

    """
    while True:
        yield start
        start = func(start)


def with_iter(context_manager):
    """Wrap an iterable in a ``with`` statement, so it closes once exhausted.

    For example, this will close the file when the iterator is exhausted::

        upper_lines = (line.upper() for line in with_iter(open('foo')))

    Any context manager which returns an iterable is a candidate for
    ``with_iter``.

    """
    with context_manager as iterable:
        yield from iterable


def one(iterable, too_short=None, too_long=None):
    """Return the first item from *iterable*, which is expected to contain only
    that item. Raise an exception if *iterable* is empty or has more than one
    item.

    :func:`one` is useful for ensuring that an iterable contains only one item.
    For example, it can be used to retrieve the result of a database query
    that is expected to return a single row.

    If *iterable* is empty, ``ValueError`` will be raised. You may specify a
    different exception with the *too_short* keyword:

        >>> it = []
        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        ValueError: too many items in iterable (expected 1)'
        >>> too_short = IndexError('too few items')
        >>> one(it, too_short=too_short)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        IndexError: too few items

    Similarly, if *iterable* contains more than one item, ``ValueError`` will
    be raised. You may specify a different exception with the *too_long*
    keyword:

        >>> it = ['too', 'many']
        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        ValueError: Expected exactly one item in iterable, but got 'too',
        'many', and perhaps more.
        >>> too_long = RuntimeError
        >>> one(it, too_long=too_long)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        RuntimeError

    Note that :func:`one` attempts to advance *iterable* twice to ensure there
    is only one item. See :func:`spy` or :func:`peekable` to check iterable
    contents less destructively.

    """
    it = iter(iterable)

    try:
        first_value = next(it)
    except StopIteration as e:
        raise (
            too_short or ValueError('too few items in iterable (expected 1)')
        ) from e

    try:
        second_value = next(it)
    except StopIteration:
        pass
    else:
        msg = (
            'Expected exactly one item in iterable, but got {!r}, {!r}, '
            'and perhaps more.'.format(first_value, second_value)
        )
        raise too_long or ValueError(msg)

    return first_value


def distinct_permutations(iterable, r=None):
    """Yield successive distinct permutations of the elements in *iterable*.

        >>> sorted(distinct_permutations([1, 0, 1]))
        [(0, 1, 1), (1, 0, 1), (1, 1, 0)]

    Equivalent to ``set(permutations(iterable))``, except duplicates are not
    generated and thrown away. For larger input sequences this is much more
    efficient.

    Duplicate permutations arise when there are duplicated elements in the
    input iterable. The number of items returned is
    `n! / (x_1! * x_2! * ... * x_n!)`, where `n` is the total number of
    items input, and each `x_i` is the count of a distinct item in the input
    sequence.

    If *r* is given, only the *r*-length permutations are yielded.

        >>> sorted(distinct_permutations([1, 0, 1], r=2))
        [(0, 1), (1, 0), (1, 1)]
        >>> sorted(distinct_permutations(range(3), r=2))
        [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]

    """
    # Algorithm: https://w.wiki/Qai
    def _full(A):
        while True:
            # Yield the permutation we have
            yield tuple(A)

            # Find the largest index i such that A[i] < A[i + 1]
            for i in range(size - 2, -1, -1):
                if A[i] < A[i + 1]:
                    break
            #  If no such index exists, this permutation is the last one
            else:
                return

            # Find the largest index j greater than j such that A[i] < A[j]
            for j in range(size - 1, i, -1):
                if A[i] < A[j]:
                    break

            # Swap the value of A[i] with that of A[j], then reverse the
            # sequence from A[i + 1] to form the new permutation
            A[i], A[j] = A[j], A[i]
            A[i + 1 :] = A[: i - size : -1]  # A[i + 1:][::-1]

    # Algorithm: modified from the above
    def _partial(A, r):
        # Split A into the first r items and the last r items
        head, tail = A[:r], A[r:]
        right_head_indexes = range(r - 1, -1, -1)
        left_tail_indexes = range(len(tail))

        while True:
            # Yield the permutation we have
            yield tuple(head)

            # Starting from the right, find the first index of the head with
            # value smaller than the maximum value of the tail - call it i.
            pivot = tail[-1]
            for i in right_head_indexes:
                if head[i] < pivot:
                    break
                pivot = head[i]
            else:
                return

            # Starting from the left, find the first value of the tail
            # with a value greater than head[i] and swap.
            for j in left_tail_indexes:
                if tail[j] > head[i]:
                    head[i], tail[j] = tail[j], head[i]
                    break
            # If we didn't find one, start from the right and find the first
            # index of the head with a value greater than head[i] and swap.
            else:
                for j in right_head_indexes:
                    if head[j] > head[i]:
                        head[i], head[j] = head[j], head[i]
                        break

            # Reverse head[i + 1:] and swap it with tail[:r - (i + 1)]
            tail += head[: i - r : -1]  # head[i + 1:][::-1]
            i += 1
            head[i:], tail[:] = tail[: r - i], tail[r - i :]

    items = sorted(iterable)

    size = len(items)
    if r is None:
        r = size

    if 0 < r <= size:
        return _full(items) if (r == size) else _partial(items, r)

    return iter(() if r else ((),))


def intersperse(e, iterable, n=1):
    """Intersperse filler element *e* among the items in *iterable*, leaving
    *n* items between each filler element.

        >>> list(intersperse('!', [1, 2, 3, 4, 5]))
        [1, '!', 2, '!', 3, '!', 4, '!', 5]

        >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2))
        [1, 2, None, 3, 4, None, 5]

    """
    if n == 0:
        raise ValueError('n must be > 0')
    elif n == 1:
        # interleave(repeat(e), iterable) -> e, x_0, e, e, x_1, e, x_2...
        # islice(..., 1, None) -> x_0, e, e, x_1, e, x_2...
        return islice(interleave(repeat(e), iterable), 1, None)
    else:
        # interleave(filler, chunks) -> [e], [x_0, x_1], [e], [x_2, x_3]...
        # islice(..., 1, None) -> [x_0, x_1], [e], [x_2, x_3]...
        # flatten(...) -> x_0, x_1, e, x_2, x_3...
        filler = repeat([e])
        chunks = chunked(iterable, n)
        return flatten(islice(interleave(filler, chunks), 1, None))


def unique_to_each(*iterables):
    """Return the elements from each of the input iterables that aren't in the
    other input iterables.

    For example, suppose you have a set of packages, each with a set of
    dependencies::

        {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}}

    If you remove one package, which dependencies can also be removed?

    If ``pkg_1`` is removed, then ``A`` is no longer necessary - it is not
    associated with ``pkg_2`` or ``pkg_3``. Similarly, ``C`` is only needed for
    ``pkg_2``, and ``D`` is only needed for ``pkg_3``::

        >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'})
        [['A'], ['C'], ['D']]

    If there are duplicates in one input iterable that aren't in the others
    they will be duplicated in the output. Input order is preserved::

        >>> unique_to_each("mississippi", "missouri")
        [['p', 'p'], ['o', 'u', 'r']]

    It is assumed that the elements of each iterable are hashable.

    """
    pool = [list(it) for it in iterables]
    counts = Counter(chain.from_iterable(map(set, pool)))
    uniques = {element for element in counts if counts[element] == 1}
    return [list(filter(uniques.__contains__, it)) for it in pool]


def windowed(seq, n, fillvalue=None, step=1):
    """Return a sliding window of width *n* over the given iterable.

        >>> all_windows = windowed([1, 2, 3, 4, 5], 3)
        >>> list(all_windows)
        [(1, 2, 3), (2, 3, 4), (3, 4, 5)]

    When the window is larger than the iterable, *fillvalue* is used in place
    of missing values:

        >>> list(windowed([1, 2, 3], 4))
        [(1, 2, 3, None)]

    Each window will advance in increments of *step*:

        >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2))
        [(1, 2, 3), (3, 4, 5), (5, 6, '!')]

    To slide into the iterable's items, use :func:`chain` to add filler items
    to the left:

        >>> iterable = [1, 2, 3, 4]
        >>> n = 3
        >>> padding = [None] * (n - 1)
        >>> list(windowed(chain(padding, iterable), 3))
        [(None, None, 1), (None, 1, 2), (1, 2, 3), (2, 3, 4)]
    """
    if n < 0:
        raise ValueError('n must be >= 0')
    if n == 0:
        yield tuple()
        return
    if step < 1:
        raise ValueError('step must be >= 1')

    window = deque(maxlen=n)
    i = n
    for _ in map(window.append, seq):
        i -= 1
        if not i:
            i = step
            yield tuple(window)

    size = len(window)
    if size < n:
        yield tuple(chain(window, repeat(fillvalue, n - size)))
    elif 0 < i < min(step, n):
        window += (fillvalue,) * i
        yield tuple(window)


def substrings(iterable):
    """Yield all of the substrings of *iterable*.

        >>> [''.join(s) for s in substrings('more')]
        ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more']

    Note that non-string iterables can also be subdivided.

        >>> list(substrings([0, 1, 2]))
        [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)]

    """
    # The length-1 substrings
    seq = []
    for item in iter(iterable):
        seq.append(item)
        yield (item,)
    seq = tuple(seq)
    item_count = len(seq)

    # And the rest
    for n in range(2, item_count + 1):
        for i in range(item_count - n + 1):
            yield seq[i : i + n]


def substrings_indexes(seq, reverse=False):
    """Yield all substrings and their positions in *seq*

    The items yielded will be a tuple of the form ``(substr, i, j)``, where
    ``substr == seq[i:j]``.

    This function only works for iterables that support slicing, such as
    ``str`` objects.

    >>> for item in substrings_indexes('more'):
    ...    print(item)
    ('m', 0, 1)
    ('o', 1, 2)
    ('r', 2, 3)
    ('e', 3, 4)
    ('mo', 0, 2)
    ('or', 1, 3)
    ('re', 2, 4)
    ('mor', 0, 3)
    ('ore', 1, 4)
    ('more', 0, 4)

    Set *reverse* to ``True`` to yield the same items in the opposite order.


    """
    r = range(1, len(seq) + 1)
    if reverse:
        r = reversed(r)
    return (
        (seq[i : i + L], i, i + L) for L in r for i in range(len(seq) - L + 1)
    )


class bucket:
    """Wrap *iterable* and return an object that buckets it iterable into
    child iterables based on a *key* function.

        >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3']
        >>> s = bucket(iterable, key=lambda x: x[0])  # Bucket by 1st character
        >>> sorted(list(s))  # Get the keys
        ['a', 'b', 'c']
        >>> a_iterable = s['a']
        >>> next(a_iterable)
        'a1'
        >>> next(a_iterable)
        'a2'
        >>> list(s['b'])
        ['b1', 'b2', 'b3']

    The original iterable will be advanced and its items will be cached until
    they are used by the child iterables. This may require significant storage.

    By default, attempting to select a bucket to which no items belong  will
    exhaust the iterable and cache all values.
    If you specify a *validator* function, selected buckets will instead be
    checked against it.

        >>> from itertools import count
        >>> it = count(1, 2)  # Infinite sequence of odd numbers
        >>> key = lambda x: x % 10  # Bucket by last digit
        >>> validator = lambda x: x in {1, 3, 5, 7, 9}  # Odd digits only
        >>> s = bucket(it, key=key, validator=validator)
        >>> 2 in s
        False
        >>> list(s[2])
        []

    """

    def __init__(self, iterable, key, validator=None):
        self._it = iter(iterable)
        self._key = key
        self._cache = defaultdict(deque)
        self._validator = validator or (lambda x: True)

    def __contains__(self, value):
        if not self._validator(value):
            return False

        try:
            item = next(self[value])
        except StopIteration:
            return False
        else:
            self._cache[value].appendleft(item)

        return True

    def _get_values(self, value):
        """
        Helper to yield items from the parent iterator that match *value*.
        Items that don't match are stored in the local cache as they
        are encountered.
        """
        while True:
            # If we've cached some items that match the target value, emit
            # the first one and evict it from the cache.
            if self._cache[value]:
                yield self._cache[value].popleft()
            # Otherwise we need to advance the parent iterator to search for
            # a matching item, caching the rest.
            else:
                while True:
                    try:
                        item = next(self._it)
                    except StopIteration:
                        return
                    item_value = self._key(item)
                    if item_value == value:
                        yield item
                        break
                    elif self._validator(item_value):
                        self._cache[item_value].append(item)

    def __iter__(self):
        for item in self._it:
            item_value = self._key(item)
            if self._validator(item_value):
                self._cache[item_value].append(item)

        yield from self._cache.keys()

    def __getitem__(self, value):
        if not self._validator(value):
            return iter(())

        return self._get_values(value)


def spy(iterable, n=1):
    """Return a 2-tuple with a list containing the first *n* elements of
    *iterable*, and an iterator with the same items as *iterable*.
    This allows you to "look ahead" at the items in the iterable without
    advancing it.

    There is one item in the list by default:

        >>> iterable = 'abcdefg'
        >>> head, iterable = spy(iterable)
        >>> head
        ['a']
        >>> list(iterable)
        ['a', 'b', 'c', 'd', 'e', 'f', 'g']

    You may use unpacking to retrieve items instead of lists:

        >>> (head,), iterable = spy('abcdefg')
        >>> head
        'a'
        >>> (first, second), iterable = spy('abcdefg', 2)
        >>> first
        'a'
        >>> second
        'b'

    The number of items requested can be larger than the number of items in
    the iterable:

        >>> iterable = [1, 2, 3, 4, 5]
        >>> head, iterable = spy(iterable, 10)
        >>> head
        [1, 2, 3, 4, 5]
        >>> list(iterable)
        [1, 2, 3, 4, 5]

    """
    it = iter(iterable)
    head = take(n, it)

    return head.copy(), chain(head, it)


def interleave(*iterables):
    """Return a new iterable yielding from each iterable in turn,
    until the shortest is exhausted.

        >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8]))
        [1, 4, 6, 2, 5, 7]

    For a version that doesn't terminate after the shortest iterable is
    exhausted, see :func:`interleave_longest`.

    """
    return chain.from_iterable(zip(*iterables))


def interleave_longest(*iterables):
    """Return a new iterable yielding from each iterable in turn,
    skipping any that are exhausted.

        >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8]))
        [1, 4, 6, 2, 5, 7, 3, 8]

    This function produces the same output as :func:`roundrobin`, but may
    perform better for some inputs (in particular when the number of iterables
    is large).

    """
    i = chain.from_iterable(zip_longest(*iterables, fillvalue=_marker))
    return (x for x in i if x is not _marker)


def collapse(iterable, base_type=None, levels=None):
    """Flatten an iterable with multiple levels of nesting (e.g., a list of
    lists of tuples) into non-iterable types.

        >>> iterable = [(1, 2), ([3, 4], [[5], [6]])]
        >>> list(collapse(iterable))
        [1, 2, 3, 4, 5, 6]

    Binary and text strings are not considered iterable and
    will not be collapsed.

    To avoid collapsing other types, specify *base_type*:

        >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']]
        >>> list(collapse(iterable, base_type=tuple))
        ['ab', ('cd', 'ef'), 'gh', 'ij']

    Specify *levels* to stop flattening after a certain level:

    >>> iterable = [('a', ['b']), ('c', ['d'])]
    >>> list(collapse(iterable))  # Fully flattened
    ['a', 'b', 'c', 'd']
    >>> list(collapse(iterable, levels=1))  # Only one level flattened
    ['a', ['b'], 'c', ['d']]

    """

    def walk(node, level):
        if (
            ((levels is not None) and (level > levels))
            or isinstance(node, (str, bytes))
            or ((base_type is not None) and isinstance(node, base_type))
        ):
            yield node
            return

        try:
            tree = iter(node)
        except TypeError:
            yield node
            return
        else:
            for child in tree:
                yield from walk(child, level + 1)

    yield from walk(iterable, 0)


def side_effect(func, iterable, chunk_size=None, before=None, after=None):
    """Invoke *func* on each item in *iterable* (or on each *chunk_size* group
    of items) before yielding the item.

    `func` must be a function that takes a single argument. Its return value
    will be discarded.

    *before* and *after* are optional functions that take no arguments. They
    will be executed before iteration starts and after it ends, respectively.

    `side_effect` can be used for logging, updating progress bars, or anything
    that is not functionally "pure."

    Emitting a status message:

        >>> from more_itertools import consume
        >>> func = lambda item: print('Received {}'.format(item))
        >>> consume(side_effect(func, range(2)))
        Received 0
        Received 1

    Operating on chunks of items:

        >>> pair_sums = []
        >>> func = lambda chunk: pair_sums.append(sum(chunk))
        >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2))
        [0, 1, 2, 3, 4, 5]
        >>> list(pair_sums)
        [1, 5, 9]

    Writing to a file-like object:

        >>> from io import StringIO
        >>> from more_itertools import consume
        >>> f = StringIO()
        >>> func = lambda x: print(x, file=f)
        >>> before = lambda: print(u'HEADER', file=f)
        >>> after = f.close
        >>> it = [u'a', u'b', u'c']
        >>> consume(side_effect(func, it, before=before, after=after))
        >>> f.closed
        True

    """
    try:
        if before is not None:
            before()

        if chunk_size is None:
            for item in iterable:
                func(item)
                yield item
        else:
            for chunk in chunked(iterable, chunk_size):
                func(chunk)
                yield from chunk
    finally:
        if after is not None:
            after()


def sliced(seq, n, strict=False):
    """Yield slices of length *n* from the sequence *seq*.

    >>> list(sliced((1, 2, 3, 4, 5, 6), 3))
    [(1, 2, 3), (4, 5, 6)]

    By the default, the last yielded slice will have fewer than *n* elements
    if the length of *seq* is not divisible by *n*:

    >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3))
    [(1, 2, 3), (4, 5, 6), (7, 8)]

    If the length of *seq* is not divisible by *n* and *strict* is
    ``True``, then ``ValueError`` will be raised before the last
    slice is yielded.

    This function will only work for iterables that support slicing.
    For non-sliceable iterables, see :func:`chunked`.

    """
    iterator = takewhile(len, (seq[i : i + n] for i in count(0, n)))
    if strict:

        def ret():
            for _slice in iterator:
                if len(_slice) != n:
                    raise ValueError("seq is not divisible by n.")
                yield _slice

        return iter(ret())
    else:
        return iterator


def split_at(iterable, pred, maxsplit=-1, keep_separator=False):
    """Yield lists of items from *iterable*, where each list is delimited by
    an item where callable *pred* returns ``True``.

        >>> list(split_at('abcdcba', lambda x: x == 'b'))
        [['a'], ['c', 'd', 'c'], ['a']]

        >>> list(split_at(range(10), lambda n: n % 2 == 1))
        [[0], [2], [4], [6], [8], []]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_at(range(10), lambda n: n % 2 == 1, maxsplit=2))
        [[0], [2], [4, 5, 6, 7, 8, 9]]

    By default, the delimiting items are not included in the output.
    The include them, set *keep_separator* to ``True``.

        >>> list(split_at('abcdcba', lambda x: x == 'b', keep_separator=True))
        [['a'], ['b'], ['c', 'd', 'c'], ['b'], ['a']]

    """
    if maxsplit == 0:
        yield list(iterable)
        return

    buf = []
    it = iter(iterable)
    for item in it:
        if pred(item):
            yield buf
            if keep_separator:
                yield [item]
            if maxsplit == 1:
                yield list(it)
                return
            buf = []
            maxsplit -= 1
        else:
            buf.append(item)
    yield buf


def split_before(iterable, pred, maxsplit=-1):
    """Yield lists of items from *iterable*, where each list ends just before
    an item for which callable *pred* returns ``True``:

        >>> list(split_before('OneTwo', lambda s: s.isupper()))
        [['O', 'n', 'e'], ['T', 'w', 'o']]

        >>> list(split_before(range(10), lambda n: n % 3 == 0))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_before(range(10), lambda n: n % 3 == 0, maxsplit=2))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
    """
    if maxsplit == 0:
        yield list(iterable)
        return

    buf = []
    it = iter(iterable)
    for item in it:
        if pred(item) and buf:
            yield buf
            if maxsplit == 1:
                yield [item] + list(it)
                return
            buf = []
            maxsplit -= 1
        buf.append(item)
    if buf:
        yield buf


def split_after(iterable, pred, maxsplit=-1):
    """Yield lists of items from *iterable*, where each list ends with an
    item where callable *pred* returns ``True``:

        >>> list(split_after('one1two2', lambda s: s.isdigit()))
        [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']]

        >>> list(split_after(range(10), lambda n: n % 3 == 0))
        [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_after(range(10), lambda n: n % 3 == 0, maxsplit=2))
        [[0], [1, 2, 3], [4, 5, 6, 7, 8, 9]]

    """
    if maxsplit == 0:
        yield list(iterable)
        return

    buf = []
    it = iter(iterable)
    for item in it:
        buf.append(item)
        if pred(item) and buf:
            yield buf
            if maxsplit == 1:
                yield list(it)
                return
            buf = []
            maxsplit -= 1
    if buf:
        yield buf


def split_when(iterable, pred, maxsplit=-1):
    """Split *iterable* into pieces based on the output of *pred*.
    *pred* should be a function that takes successive pairs of items and
    returns ``True`` if the iterable should be split in between them.

    For example, to find runs of increasing numbers, split the iterable when
    element ``i`` is larger than element ``i + 1``:

        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], lambda x, y: x > y))
        [[1, 2, 3, 3], [2, 5], [2, 4], [2]]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2],
        ...                 lambda x, y: x > y, maxsplit=2))
        [[1, 2, 3, 3], [2, 5], [2, 4, 2]]

    """
    if maxsplit == 0:
        yield list(iterable)
        return

    it = iter(iterable)
    try:
        cur_item = next(it)
    except StopIteration:
        return

    buf = [cur_item]
    for next_item in it:
        if pred(cur_item, next_item):
            yield buf
            if maxsplit == 1:
                yield [next_item] + list(it)
                return
            buf = []
            maxsplit -= 1

        buf.append(next_item)
        cur_item = next_item

    yield buf


def split_into(iterable, sizes):
    """Yield a list of sequential items from *iterable* of length 'n' for each
    integer 'n' in *sizes*.

        >>> list(split_into([1,2,3,4,5,6], [1,2,3]))
        [[1], [2, 3], [4, 5, 6]]

    If the sum of *sizes* is smaller than the length of *iterable*, then the
    remaining items of *iterable* will not be returned.

        >>> list(split_into([1,2,3,4,5,6], [2,3]))
        [[1, 2], [3, 4, 5]]

    If the sum of *sizes* is larger than the length of *iterable*, fewer items
    will be returned in the iteration that overruns *iterable* and further
    lists will be empty:

        >>> list(split_into([1,2,3,4], [1,2,3,4]))
        [[1], [2, 3], [4], []]

    When a ``None`` object is encountered in *sizes*, the returned list will
    contain items up to the end of *iterable* the same way that itertools.slice
    does:

        >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None]))
        [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]]

    :func:`split_into` can be useful for grouping a series of items where the
    sizes of the groups are not uniform. An example would be where in a row
    from a table, multiple columns represent elements of the same feature
    (e.g. a point represented by x,y,z) but, the format is not the same for
    all columns.
    """
    # convert the iterable argument into an iterator so its contents can
    # be consumed by islice in case it is a generator
    it = iter(iterable)

    for size in sizes:
        if size is None:
            yield list(it)
            return
        else:
            yield list(islice(it, size))


def padded(iterable, fillvalue=None, n=None, next_multiple=False):
    """Yield the elements from *iterable*, followed by *fillvalue*, such that
    at least *n* items are emitted.

        >>> list(padded([1, 2, 3], '?', 5))
        [1, 2, 3, '?', '?']

    If *next_multiple* is ``True``, *fillvalue* will be emitted until the
    number of items emitted is a multiple of *n*::

        >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True))
        [1, 2, 3, 4, None, None]

    If *n* is ``None``, *fillvalue* will be emitted indefinitely.

    """
    it = iter(iterable)
    if n is None:
        yield from chain(it, repeat(fillvalue))
    elif n < 1:
        raise ValueError('n must be at least 1')
    else:
        item_count = 0
        for item in it:
            yield item
            item_count += 1

        remaining = (n - item_count) % n if next_multiple else n - item_count
        for _ in range(remaining):
            yield fillvalue


def repeat_last(iterable, default=None):
    """After the *iterable* is exhausted, keep yielding its last element.

        >>> list(islice(repeat_last(range(3)), 5))
        [0, 1, 2, 2, 2]

    If the iterable is empty, yield *default* forever::

        >>> list(islice(repeat_last(range(0), 42), 5))
        [42, 42, 42, 42, 42]

    """
    item = _marker
    for item in iterable:
        yield item
    final = default if item is _marker else item
    yield from repeat(final)


def distribute(n, iterable):
    """Distribute the items from *iterable* among *n* smaller iterables.

        >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
        >>> list(group_1)
        [1, 3, 5]
        >>> list(group_2)
        [2, 4, 6]

    If the length of *iterable* is not evenly divisible by *n*, then the
    length of the returned iterables will not be identical:

        >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
        >>> [list(c) for c in children]
        [[1, 4, 7], [2, 5], [3, 6]]

    If the length of *iterable* is smaller than *n*, then the last returned
    iterables will be empty:

        >>> children = distribute(5, [1, 2, 3])
        >>> [list(c) for c in children]
        [[1], [2], [3], [], []]

    This function uses :func:`itertools.tee` and may require significant
    storage. If you need the order items in the smaller iterables to match the
    original iterable, see :func:`divide`.

    """
    if n < 1:
        raise ValueError('n must be at least 1')

    children = tee(iterable, n)
    return [islice(it, index, None, n) for index, it in enumerate(children)]


def stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None):
    """Yield tuples whose elements are offset from *iterable*.
    The amount by which the `i`-th item in each tuple is offset is given by
    the `i`-th item in *offsets*.

        >>> list(stagger([0, 1, 2, 3]))
        [(None, 0, 1), (0, 1, 2), (1, 2, 3)]
        >>> list(stagger(range(8), offsets=(0, 2, 4)))
        [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)]

    By default, the sequence will end when the final element of a tuple is the
    last item in the iterable. To continue until the first element of a tuple
    is the last item in the iterable, set *longest* to ``True``::

        >>> list(stagger([0, 1, 2, 3], longest=True))
        [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)]

    By default, ``None`` will be used to replace offsets beyond the end of the
    sequence. Specify *fillvalue* to use some other value.

    """
    children = tee(iterable, len(offsets))

    return zip_offset(
        *children, offsets=offsets, longest=longest, fillvalue=fillvalue
    )


class UnequalIterablesError(ValueError):
    def __init__(self, details=None):
        msg = 'Iterables have different lengths'
        if details is not None:
            msg += (': index 0 has length {}; index {} has length {}').format(
                *details
            )

        super().__init__(msg)


def _zip_equal_generator(iterables):
    for combo in zip_longest(*iterables, fillvalue=_marker):
        for val in combo:
            if val is _marker:
                raise UnequalIterablesError()
        yield combo


def zip_equal(*iterables):
    """``zip`` the input *iterables* together, but raise
    ``UnequalIterablesError`` if they aren't all the same length.

        >>> it_1 = range(3)
        >>> it_2 = iter('abc')
        >>> list(zip_equal(it_1, it_2))
        [(0, 'a'), (1, 'b'), (2, 'c')]

        >>> it_1 = range(3)
        >>> it_2 = iter('abcd')
        >>> list(zip_equal(it_1, it_2)) # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        more_itertools.more.UnequalIterablesError: Iterables have different
        lengths

    """
    if hexversion >= 0x30A00A6:
        warnings.warn(
            (
                'zip_equal will be removed in a future version of '
                'more-itertools. Use the builtin zip function with '
                'strict=True instead.'
            ),
            DeprecationWarning,
        )
    # Check whether the iterables are all the same size.
    try:
        first_size = len(iterables[0])
        for i, it in enumerate(iterables[1:], 1):
            size = len(it)
            if size != first_size:
                break
        else:
            # If we didn't break out, we can use the built-in zip.
            return zip(*iterables)

        # If we did break out, there was a mismatch.
        raise UnequalIterablesError(details=(first_size, i, size))
    # If any one of the iterables didn't have a length, start reading
    # them until one runs out.
    except TypeError:
        return _zip_equal_generator(iterables)


def zip_offset(*iterables, offsets, longest=False, fillvalue=None):
    """``zip`` the input *iterables* together, but offset the `i`-th iterable
    by the `i`-th item in *offsets*.

        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1)))
        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')]

    This can be used as a lightweight alternative to SciPy or pandas to analyze
    data sets in which some series have a lead or lag relationship.

    By default, the sequence will end when the shortest iterable is exhausted.
    To continue until the longest iterable is exhausted, set *longest* to
    ``True``.

        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True))
        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')]

    By default, ``None`` will be used to replace offsets beyond the end of the
    sequence. Specify *fillvalue* to use some other value.

    """
    if len(iterables) != len(offsets):
        raise ValueError("Number of iterables and offsets didn't match")

    staggered = []
    for it, n in zip(iterables, offsets):
        if n < 0:
            staggered.append(chain(repeat(fillvalue, -n), it))
        elif n > 0:
            staggered.append(islice(it, n, None))
        else:
            staggered.append(it)

    if longest:
        return zip_longest(*staggered, fillvalue=fillvalue)

    return zip(*staggered)


def sort_together(iterables, key_list=(0,), key=None, reverse=False):
    """Return the input iterables sorted together, with *key_list* as the
    priority for sorting. All iterables are trimmed to the length of the
    shortest one.

    This can be used like the sorting function in a spreadsheet. If each
    iterable represents a column of data, the key list determines which
    columns are used for sorting.

    By default, all iterables are sorted using the ``0``-th iterable::

        >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')]
        >>> sort_together(iterables)
        [(1, 2, 3, 4), ('d', 'c', 'b', 'a')]

    Set a different key list to sort according to another iterable.
    Specifying multiple keys dictates how ties are broken::

        >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')]
        >>> sort_together(iterables, key_list=(1, 2))
        [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')]

    To sort by a function of the elements of the iterable, pass a *key*
    function. Its arguments are the elements of the iterables corresponding to
    the key list::

        >>> names = ('a', 'b', 'c')
        >>> lengths = (1, 2, 3)
        >>> widths = (5, 2, 1)
        >>> def area(length, width):
        ...     return length * width
        >>> sort_together([names, lengths, widths], key_list=(1, 2), key=area)
        [('c', 'b', 'a'), (3, 2, 1), (1, 2, 5)]

    Set *reverse* to ``True`` to sort in descending order.

        >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True)
        [(3, 2, 1), ('a', 'b', 'c')]

    """
    if key is None:
        # if there is no key function, the key argument to sorted is an
        # itemgetter
        key_argument = itemgetter(*key_list)
    else:
        # if there is a key function, call it with the items at the offsets
        # specified by the key function as arguments
        key_list = list(key_list)
        if len(key_list) == 1:
            # if key_list contains a single item, pass the item at that offset
            # as the only argument to the key function
            key_offset = key_list[0]
            key_argument = lambda zipped_items: key(zipped_items[key_offset])
        else:
            # if key_list contains multiple items, use itemgetter to return a
            # tuple of items, which we pass as *args to the key function
            get_key_items = itemgetter(*key_list)
            key_argument = lambda zipped_items: key(
                *get_key_items(zipped_items)
            )

    return list(
        zip(*sorted(zip(*iterables), key=key_argument, reverse=reverse))
    )


def unzip(iterable):
    """The inverse of :func:`zip`, this function disaggregates the elements
    of the zipped *iterable*.

    The ``i``-th iterable contains the ``i``-th element from each element
    of the zipped iterable. The first element is used to to determine the
    length of the remaining elements.

        >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
        >>> letters, numbers = unzip(iterable)
        >>> list(letters)
        ['a', 'b', 'c', 'd']
        >>> list(numbers)
        [1, 2, 3, 4]

    This is similar to using ``zip(*iterable)``, but it avoids reading
    *iterable* into memory. Note, however, that this function uses
    :func:`itertools.tee` and thus may require significant storage.

    """
    head, iterable = spy(iter(iterable))
    if not head:
        # empty iterable, e.g. zip([], [], [])
        return ()
    # spy returns a one-length iterable as head
    head = head[0]
    iterables = tee(iterable, len(head))

    def itemgetter(i):
        def getter(obj):
            try:
                return obj[i]
            except IndexError:
                # basically if we have an iterable like
                # iter([(1, 2, 3), (4, 5), (6,)])
                # the second unzipped iterable would fail at the third tuple
                # since it would try to access tup[1]
                # same with the third unzipped iterable and the second tuple
                # to support these "improperly zipped" iterables,
                # we create a custom itemgetter
                # which just stops the unzipped iterables
                # at first length mismatch
                raise StopIteration

        return getter

    return tuple(map(itemgetter(i), it) for i, it in enumerate(iterables))


def divide(n, iterable):
    """Divide the elements from *iterable* into *n* parts, maintaining
    order.

        >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6])
        >>> list(group_1)
        [1, 2, 3]
        >>> list(group_2)
        [4, 5, 6]

    If the length of *iterable* is not evenly divisible by *n*, then the
    length of the returned iterables will not be identical:

        >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7])
        >>> [list(c) for c in children]
        [[1, 2, 3], [4, 5], [6, 7]]

    If the length of the iterable is smaller than n, then the last returned
    iterables will be empty:

        >>> children = divide(5, [1, 2, 3])
        >>> [list(c) for c in children]
        [[1], [2], [3], [], []]

    This function will exhaust the iterable before returning and may require
    significant storage. If order is not important, see :func:`distribute`,
    which does not first pull the iterable into memory.

    """
    if n < 1:
        raise ValueError('n must be at least 1')

    try:
        iterable[:0]
    except TypeError:
        seq = tuple(iterable)
    else:
        seq = iterable

    q, r = divmod(len(seq), n)

    ret = []
    stop = 0
    for i in range(1, n + 1):
        start = stop
        stop += q + 1 if i <= r else q
        ret.append(iter(seq[start:stop]))

    return ret


def always_iterable(obj, base_type=(str, bytes)):
    """If *obj* is iterable, return an iterator over its items::

        >>> obj = (1, 2, 3)
        >>> list(always_iterable(obj))
        [1, 2, 3]

    If *obj* is not iterable, return a one-item iterable containing *obj*::

        >>> obj = 1
        >>> list(always_iterable(obj))
        [1]

    If *obj* is ``None``, return an empty iterable:

        >>> obj = None
        >>> list(always_iterable(None))
        []

    By default, binary and text strings are not considered iterable::

        >>> obj = 'foo'
        >>> list(always_iterable(obj))
        ['foo']

    If *base_type* is set, objects for which ``isinstance(obj, base_type)``
    returns ``True`` won't be considered iterable.

        >>> obj = {'a': 1}
        >>> list(always_iterable(obj))  # Iterate over the dict's keys
        ['a']
        >>> list(always_iterable(obj, base_type=dict))  # Treat dicts as a unit
        [{'a': 1}]

    Set *base_type* to ``None`` to avoid any special handling and treat objects
    Python considers iterable as iterable:

        >>> obj = 'foo'
        >>> list(always_iterable(obj, base_type=None))
        ['f', 'o', 'o']
    """
    if obj is None:
        return iter(())

    if (base_type is not None) and isinstance(obj, base_type):
        return iter((obj,))

    try:
        return iter(obj)
    except TypeError:
        return iter((obj,))


def adjacent(predicate, iterable, distance=1):
    """Return an iterable over `(bool, item)` tuples where the `item` is
    drawn from *iterable* and the `bool` indicates whether
    that item satisfies the *predicate* or is adjacent to an item that does.

    For example, to find whether items are adjacent to a ``3``::

        >>> list(adjacent(lambda x: x == 3, range(6)))
        [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)]

    Set *distance* to change what counts as adjacent. For example, to find
    whether items are two places away from a ``3``:

        >>> list(adjacent(lambda x: x == 3, range(6), distance=2))
        [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)]

    This is useful for contextualizing the results of a search function.
    For example, a code comparison tool might want to identify lines that
    have changed, but also surrounding lines to give the viewer of the diff
    context.

    The predicate function will only be called once for each item in the
    iterable.

    See also :func:`groupby_transform`, which can be used with this function
    to group ranges of items with the same `bool` value.

    """
    # Allow distance=0 mainly for testing that it reproduces results with map()
    if distance < 0:
        raise ValueError('distance must be at least 0')

    i1, i2 = tee(iterable)
    padding = [False] * distance
    selected = chain(padding, map(predicate, i1), padding)
    adjacent_to_selected = map(any, windowed(selected, 2 * distance + 1))
    return zip(adjacent_to_selected, i2)


def groupby_transform(iterable, keyfunc=None, valuefunc=None, reducefunc=None):
    """An extension of :func:`itertools.groupby` that can apply transformations
    to the grouped data.

    * *keyfunc* is a function computing a key value for each item in *iterable*
    * *valuefunc* is a function that transforms the individual items from
      *iterable* after grouping
    * *reducefunc* is a function that transforms each group of items

    >>> iterable = 'aAAbBBcCC'
    >>> keyfunc = lambda k: k.upper()
    >>> valuefunc = lambda v: v.lower()
    >>> reducefunc = lambda g: ''.join(g)
    >>> list(groupby_transform(iterable, keyfunc, valuefunc, reducefunc))
    [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')]

    Each optional argument defaults to an identity function if not specified.

    :func:`groupby_transform` is useful when grouping elements of an iterable
    using a separate iterable as the key. To do this, :func:`zip` the iterables
    and pass a *keyfunc* that extracts the first element and a *valuefunc*
    that extracts the second element::

        >>> from operator import itemgetter
        >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3]
        >>> values = 'abcdefghi'
        >>> iterable = zip(keys, values)
        >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1))
        >>> [(k, ''.join(g)) for k, g in grouper]
        [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')]

    Note that the order of items in the iterable is significant.
    Only adjacent items are grouped together, so if you don't want any
    duplicate groups, you should sort the iterable by the key function.

    """
    ret = groupby(iterable, keyfunc)
    if valuefunc:
        ret = ((k, map(valuefunc, g)) for k, g in ret)
    if reducefunc:
        ret = ((k, reducefunc(g)) for k, g in ret)

    return ret


class numeric_range(abc.Sequence, abc.Hashable):
    """An extension of the built-in ``range()`` function whose arguments can
    be any orderable numeric type.

    With only *stop* specified, *start* defaults to ``0`` and *step*
    defaults to ``1``. The output items will match the type of *stop*:

        >>> list(numeric_range(3.5))
        [0.0, 1.0, 2.0, 3.0]

    With only *start* and *stop* specified, *step* defaults to ``1``. The
    output items will match the type of *start*:

        >>> from decimal import Decimal
        >>> start = Decimal('2.1')
        >>> stop = Decimal('5.1')
        >>> list(numeric_range(start, stop))
        [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')]

    With *start*, *stop*, and *step*  specified the output items will match
    the type of ``start + step``:

        >>> from fractions import Fraction
        >>> start = Fraction(1, 2)  # Start at 1/2
        >>> stop = Fraction(5, 2)  # End at 5/2
        >>> step = Fraction(1, 2)  # Count by 1/2
        >>> list(numeric_range(start, stop, step))
        [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)]

    If *step* is zero, ``ValueError`` is raised. Negative steps are supported:

        >>> list(numeric_range(3, -1, -1.0))
        [3.0, 2.0, 1.0, 0.0]

    Be aware of the limitations of floating point numbers; the representation
    of the yielded numbers may be surprising.

    ``datetime.datetime`` objects can be used for *start* and *stop*, if *step*
    is a ``datetime.timedelta`` object:

        >>> import datetime
        >>> start = datetime.datetime(2019, 1, 1)
        >>> stop = datetime.datetime(2019, 1, 3)
        >>> step = datetime.timedelta(days=1)
        >>> items = iter(numeric_range(start, stop, step))
        >>> next(items)
        datetime.datetime(2019, 1, 1, 0, 0)
        >>> next(items)
        datetime.datetime(2019, 1, 2, 0, 0)

    """

    _EMPTY_HASH = hash(range(0, 0))

    def __init__(self, *args):
        argc = len(args)
        if argc == 1:
            (self._stop,) = args
            self._start = type(self._stop)(0)
            self._step = type(self._stop - self._start)(1)
        elif argc == 2:
            self._start, self._stop = args
            self._step = type(self._stop - self._start)(1)
        elif argc == 3:
            self._start, self._stop, self._step = args
        elif argc == 0:
            raise TypeError(
                'numeric_range expected at least '
                '1 argument, got {}'.format(argc)
            )
        else:
            raise TypeError(
                'numeric_range expected at most '
                '3 arguments, got {}'.format(argc)
            )

        self._zero = type(self._step)(0)
        if self._step == self._zero:
            raise ValueError('numeric_range() arg 3 must not be zero')
        self._growing = self._step > self._zero
        self._init_len()

    def __bool__(self):
        if self._growing:
            return self._start < self._stop
        else:
            return self._start > self._stop

    def __contains__(self, elem):
        if self._growing:
            if self._start <= elem < self._stop:
                return (elem - self._start) % self._step == self._zero
        else:
            if self._start >= elem > self._stop:
                return (self._start - elem) % (-self._step) == self._zero

        return False

    def __eq__(self, other):
        if isinstance(other, numeric_range):
            empty_self = not bool(self)
            empty_other = not bool(other)
            if empty_self or empty_other:
                return empty_self and empty_other  # True if both empty
            else:
                return (
                    self._start == other._start
                    and self._step == other._step
                    and self._get_by_index(-1) == other._get_by_index(-1)
                )
        else:
            return False

    def __getitem__(self, key):
        if isinstance(key, int):
            return self._get_by_index(key)
        elif isinstance(key, slice):
            step = self._step if key.step is None else key.step * self._step

            if key.start is None or key.start <= -self._len:
                start = self._start
            elif key.start >= self._len:
                start = self._stop
            else:  # -self._len < key.start < self._len
                start = self._get_by_index(key.start)

            if key.stop is None or key.stop >= self._len:
                stop = self._stop
            elif key.stop <= -self._len:
                stop = self._start
            else:  # -self._len < key.stop < self._len
                stop = self._get_by_index(key.stop)

            return numeric_range(start, stop, step)
        else:
            raise TypeError(
                'numeric range indices must be '
                'integers or slices, not {}'.format(type(key).__name__)
            )

    def __hash__(self):
        if self:
            return hash((self._start, self._get_by_index(-1), self._step))
        else:
            return self._EMPTY_HASH

    def __iter__(self):
        values = (self._start + (n * self._step) for n in count())
        if self._growing:
            return takewhile(partial(gt, self._stop), values)
        else:
            return takewhile(partial(lt, self._stop), values)

    def __len__(self):
        return self._len

    def _init_len(self):
        if self._growing:
            start = self._start
            stop = self._stop
            step = self._step
        else:
            start = self._stop
            stop = self._start
            step = -self._step
        distance = stop - start
        if distance <= self._zero:
            self._len = 0
        else:  # distance > 0 and step > 0: regular euclidean division
            q, r = divmod(distance, step)
            self._len = int(q) + int(r != self._zero)

    def __reduce__(self):
        return numeric_range, (self._start, self._stop, self._step)

    def __repr__(self):
        if self._step == 1:
            return "numeric_range({}, {})".format(
                repr(self._start), repr(self._stop)
            )
        else:
            return "numeric_range({}, {}, {})".format(
                repr(self._start), repr(self._stop), repr(self._step)
            )

    def __reversed__(self):
        return iter(
            numeric_range(
                self._get_by_index(-1), self._start - self._step, -self._step
            )
        )

    def count(self, value):
        return int(value in self)

    def index(self, value):
        if self._growing:
            if self._start <= value < self._stop:
                q, r = divmod(value - self._start, self._step)
                if r == self._zero:
                    return int(q)
        else:
            if self._start >= value > self._stop:
                q, r = divmod(self._start - value, -self._step)
                if r == self._zero:
                    return int(q)

        raise ValueError("{} is not in numeric range".format(value))

    def _get_by_index(self, i):
        if i < 0:
            i += self._len
        if i < 0 or i >= self._len:
            raise IndexError("numeric range object index out of range")
        return self._start + i * self._step


def count_cycle(iterable, n=None):
    """Cycle through the items from *iterable* up to *n* times, yielding
    the number of completed cycles along with each item. If *n* is omitted the
    process repeats indefinitely.

    >>> list(count_cycle('AB', 3))
    [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')]

    """
    iterable = tuple(iterable)
    if not iterable:
        return iter(())
    counter = count() if n is None else range(n)
    return ((i, item) for i in counter for item in iterable)


def mark_ends(iterable):
    """Yield 3-tuples of the form ``(is_first, is_last, item)``.

    >>> list(mark_ends('ABC'))
    [(True, False, 'A'), (False, False, 'B'), (False, True, 'C')]

    Use this when looping over an iterable to take special action on its first
    and/or last items:

    >>> iterable = ['Header', 100, 200, 'Footer']
    >>> total = 0
    >>> for is_first, is_last, item in mark_ends(iterable):
    ...     if is_first:
    ...         continue  # Skip the header
    ...     if is_last:
    ...         continue  # Skip the footer
    ...     total += item
    >>> print(total)
    300
    """
    it = iter(iterable)

    try:
        b = next(it)
    except StopIteration:
        return

    try:
        for i in count():
            a = b
            b = next(it)
            yield i == 0, False, a

    except StopIteration:
        yield i == 0, True, a


def locate(iterable, pred=bool, window_size=None):
    """Yield the index of each item in *iterable* for which *pred* returns
    ``True``.

    *pred* defaults to :func:`bool`, which will select truthy items:

        >>> list(locate([0, 1, 1, 0, 1, 0, 0]))
        [1, 2, 4]

    Set *pred* to a custom function to, e.g., find the indexes for a particular
    item.

        >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b'))
        [1, 3]

    If *window_size* is given, then the *pred* function will be called with
    that many items. This enables searching for sub-sequences:

        >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
        >>> pred = lambda *args: args == (1, 2, 3)
        >>> list(locate(iterable, pred=pred, window_size=3))
        [1, 5, 9]

    Use with :func:`seekable` to find indexes and then retrieve the associated
    items:

        >>> from itertools import count
        >>> from more_itertools import seekable
        >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count())
        >>> it = seekable(source)
        >>> pred = lambda x: x > 100
        >>> indexes = locate(it, pred=pred)
        >>> i = next(indexes)
        >>> it.seek(i)
        >>> next(it)
        106

    """
    if window_size is None:
        return compress(count(), map(pred, iterable))

    if window_size < 1:
        raise ValueError('window size must be at least 1')

    it = windowed(iterable, window_size, fillvalue=_marker)
    return compress(count(), starmap(pred, it))


def lstrip(iterable, pred):
    """Yield the items from *iterable*, but strip any from the beginning
    for which *pred* returns ``True``.

    For example, to remove a set of items from the start of an iterable:

        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(lstrip(iterable, pred))
        [1, 2, None, 3, False, None]

    This function is analogous to to :func:`str.lstrip`, and is essentially
    an wrapper for :func:`itertools.dropwhile`.

    """
    return dropwhile(pred, iterable)


def rstrip(iterable, pred):
    """Yield the items from *iterable*, but strip any from the end
    for which *pred* returns ``True``.

    For example, to remove a set of items from the end of an iterable:

        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(rstrip(iterable, pred))
        [None, False, None, 1, 2, None, 3]

    This function is analogous to :func:`str.rstrip`.

    """
    cache = []
    cache_append = cache.append
    cache_clear = cache.clear
    for x in iterable:
        if pred(x):
            cache_append(x)
        else:
            yield from cache
            cache_clear()
            yield x


def strip(iterable, pred):
    """Yield the items from *iterable*, but strip any from the
    beginning and end for which *pred* returns ``True``.

    For example, to remove a set of items from both ends of an iterable:

        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(strip(iterable, pred))
        [1, 2, None, 3]

    This function is analogous to :func:`str.strip`.

    """
    return rstrip(lstrip(iterable, pred), pred)


class islice_extended:
    """An extension of :func:`itertools.islice` that supports negative values
    for *stop*, *start*, and *step*.

        >>> iterable = iter('abcdefgh')
        >>> list(islice_extended(iterable, -4, -1))
        ['e', 'f', 'g']

    Slices with negative values require some caching of *iterable*, but this
    function takes care to minimize the amount of memory required.

    For example, you can use a negative step with an infinite iterator:

        >>> from itertools import count
        >>> list(islice_extended(count(), 110, 99, -2))
        [110, 108, 106, 104, 102, 100]

    You can also use slice notation directly:

        >>> iterable = map(str, count())
        >>> it = islice_extended(iterable)[10:20:2]
        >>> list(it)
        ['10', '12', '14', '16', '18']

    """

    def __init__(self, iterable, *args):
        it = iter(iterable)
        if args:
            self._iterable = _islice_helper(it, slice(*args))
        else:
            self._iterable = it

    def __iter__(self):
        return self

    def __next__(self):
        return next(self._iterable)

    def __getitem__(self, key):
        if isinstance(key, slice):
            return islice_extended(_islice_helper(self._iterable, key))

        raise TypeError('islice_extended.__getitem__ argument must be a slice')


def _islice_helper(it, s):
    start = s.start
    stop = s.stop
    if s.step == 0:
        raise ValueError('step argument must be a non-zero integer or None.')
    step = s.step or 1

    if step > 0:
        start = 0 if (start is None) else start

        if start < 0:
            # Consume all but the last -start items
            cache = deque(enumerate(it, 1), maxlen=-start)
            len_iter = cache[-1][0] if cache else 0

            # Adjust start to be positive
            i = max(len_iter + start, 0)

            # Adjust stop to be positive
            if stop is None:
                j = len_iter
            elif stop >= 0:
                j = min(stop, len_iter)
            else:
                j = max(len_iter + stop, 0)

            # Slice the cache
            n = j - i
            if n <= 0:
                return

            for index, item in islice(cache, 0, n, step):
                yield item
        elif (stop is not None) and (stop < 0):
            # Advance to the start position
            next(islice(it, start, start), None)

            # When stop is negative, we have to carry -stop items while
            # iterating
            cache = deque(islice(it, -stop), maxlen=-stop)

            for index, item in enumerate(it):
                cached_item = cache.popleft()
                if index % step == 0:
                    yield cached_item
                cache.append(item)
        else:
            # When both start and stop are positive we have the normal case
            yield from islice(it, start, stop, step)
    else:
        start = -1 if (start is None) else start

        if (stop is not None) and (stop < 0):
            # Consume all but the last items
            n = -stop - 1
            cache = deque(enumerate(it, 1), maxlen=n)
            len_iter = cache[-1][0] if cache else 0

            # If start and stop are both negative they are comparable and
            # we can just slice. Otherwise we can adjust start to be negative
            # and then slice.
            if start < 0:
                i, j = start, stop
            else:
                i, j = min(start - len_iter, -1), None

            for index, item in list(cache)[i:j:step]:
                yield item
        else:
            # Advance to the stop position
            if stop is not None:
                m = stop + 1
                next(islice(it, m, m), None)

            # stop is positive, so if start is negative they are not comparable
            # and we need the rest of the items.
            if start < 0:
                i = start
                n = None
            # stop is None and start is positive, so we just need items up to
            # the start index.
            elif stop is None:
                i = None
                n = start + 1
            # Both stop and start are positive, so they are comparable.
            else:
                i = None
                n = start - stop
                if n <= 0:
                    return

            cache = list(islice(it, n))

            yield from cache[i::step]


def always_reversible(iterable):
    """An extension of :func:`reversed` that supports all iterables, not
    just those which implement the ``Reversible`` or ``Sequence`` protocols.

        >>> print(*always_reversible(x for x in range(3)))
        2 1 0

    If the iterable is already reversible, this function returns the
    result of :func:`reversed()`. If the iterable is not reversible,
    this function will cache the remaining items in the iterable and
    yield them in reverse order, which may require significant storage.
    """
    try:
        return reversed(iterable)
    except TypeError:
        return reversed(list(iterable))


def consecutive_groups(iterable, ordering=lambda x: x):
    """Yield groups of consecutive items using :func:`itertools.groupby`.
    The *ordering* function determines whether two items are adjacent by
    returning their position.

    By default, the ordering function is the identity function. This is
    suitable for finding runs of numbers:

        >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40]
        >>> for group in consecutive_groups(iterable):
        ...     print(list(group))
        [1]
        [10, 11, 12]
        [20]
        [30, 31, 32, 33]
        [40]

    For finding runs of adjacent letters, try using the :meth:`index` method
    of a string of letters:

        >>> from string import ascii_lowercase
        >>> iterable = 'abcdfgilmnop'
        >>> ordering = ascii_lowercase.index
        >>> for group in consecutive_groups(iterable, ordering):
        ...     print(list(group))
        ['a', 'b', 'c', 'd']
        ['f', 'g']
        ['i']
        ['l', 'm', 'n', 'o', 'p']

    Each group of consecutive items is an iterator that shares it source with
    *iterable*. When an an output group is advanced, the previous group is
    no longer available unless its elements are copied (e.g., into a ``list``).

        >>> iterable = [1, 2, 11, 12, 21, 22]
        >>> saved_groups = []
        >>> for group in consecutive_groups(iterable):
        ...     saved_groups.append(list(group))  # Copy group elements
        >>> saved_groups
        [[1, 2], [11, 12], [21, 22]]

    """
    for k, g in groupby(
        enumerate(iterable), key=lambda x: x[0] - ordering(x[1])
    ):
        yield map(itemgetter(1), g)


def difference(iterable, func=sub, *, initial=None):
    """This function is the inverse of :func:`itertools.accumulate`. By default
    it will compute the first difference of *iterable* using
    :func:`operator.sub`:

        >>> from itertools import accumulate
        >>> iterable = accumulate([0, 1, 2, 3, 4])  # produces 0, 1, 3, 6, 10
        >>> list(difference(iterable))
        [0, 1, 2, 3, 4]

    *func* defaults to :func:`operator.sub`, but other functions can be
    specified. They will be applied as follows::

        A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ...

    For example, to do progressive division:

        >>> iterable = [1, 2, 6, 24, 120]
        >>> func = lambda x, y: x // y
        >>> list(difference(iterable, func))
        [1, 2, 3, 4, 5]

    If the *initial* keyword is set, the first element will be skipped when
    computing successive differences.

        >>> it = [10, 11, 13, 16]  # from accumulate([1, 2, 3], initial=10)
        >>> list(difference(it, initial=10))
        [1, 2, 3]

    """
    a, b = tee(iterable)
    try:
        first = [next(b)]
    except StopIteration:
        return iter([])

    if initial is not None:
        first = []

    return chain(first, starmap(func, zip(b, a)))


class SequenceView(Sequence):
    """Return a read-only view of the sequence object *target*.

    :class:`SequenceView` objects are analogous to Python's built-in
    "dictionary view" types. They provide a dynamic view of a sequence's items,
    meaning that when the sequence updates, so does the view.

        >>> seq = ['0', '1', '2']
        >>> view = SequenceView(seq)
        >>> view
        SequenceView(['0', '1', '2'])
        >>> seq.append('3')
        >>> view
        SequenceView(['0', '1', '2', '3'])

    Sequence views support indexing, slicing, and length queries. They act
    like the underlying sequence, except they don't allow assignment:

        >>> view[1]
        '1'
        >>> view[1:-1]
        ['1', '2']
        >>> len(view)
        4

    Sequence views are useful as an alternative to copying, as they don't
    require (much) extra storage.

    """

    def __init__(self, target):
        if not isinstance(target, Sequence):
            raise TypeError
        self._target = target

    def __getitem__(self, index):
        return self._target[index]

    def __len__(self):
        return len(self._target)

    def __repr__(self):
        return '{}({})'.format(self.__class__.__name__, repr(self._target))


class seekable:
    """Wrap an iterator to allow for seeking backward and forward. This
    progressively caches the items in the source iterable so they can be
    re-visited.

    Call :meth:`seek` with an index to seek to that position in the source
    iterable.

    To "reset" an iterator, seek to ``0``:

        >>> from itertools import count
        >>> it = seekable((str(n) for n in count()))
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> it.seek(0)
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> next(it)
        '3'

    You can also seek forward:

        >>> it = seekable((str(n) for n in range(20)))
        >>> it.seek(10)
        >>> next(it)
        '10'
        >>> it.seek(20)  # Seeking past the end of the source isn't a problem
        >>> list(it)
        []
        >>> it.seek(0)  # Resetting works even after hitting the end
        >>> next(it), next(it), next(it)
        ('0', '1', '2')

    Call :meth:`peek` to look ahead one item without advancing the iterator:

        >>> it = seekable('1234')
        >>> it.peek()
        '1'
        >>> list(it)
        ['1', '2', '3', '4']
        >>> it.peek(default='empty')
        'empty'

    Before the iterator is at its end, calling :func:`bool` on it will return
    ``True``. After it will return ``False``:

        >>> it = seekable('5678')
        >>> bool(it)
        True
        >>> list(it)
        ['5', '6', '7', '8']
        >>> bool(it)
        False

    You may view the contents of the cache with the :meth:`elements` method.
    That returns a :class:`SequenceView`, a view that updates automatically:

        >>> it = seekable((str(n) for n in range(10)))
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> elements = it.elements()
        >>> elements
        SequenceView(['0', '1', '2'])
        >>> next(it)
        '3'
        >>> elements
        SequenceView(['0', '1', '2', '3'])

    By default, the cache grows as the source iterable progresses, so beware of
    wrapping very large or infinite iterables. Supply *maxlen* to limit the
    size of the cache (this of course limits how far back you can seek).

        >>> from itertools import count
        >>> it = seekable((str(n) for n in count()), maxlen=2)
        >>> next(it), next(it), next(it), next(it)
        ('0', '1', '2', '3')
        >>> list(it.elements())
        ['2', '3']
        >>> it.seek(0)
        >>> next(it), next(it), next(it), next(it)
        ('2', '3', '4', '5')
        >>> next(it)
        '6'

    """

    def __init__(self, iterable, maxlen=None):
        self._source = iter(iterable)
        if maxlen is None:
            self._cache = []
        else:
            self._cache = deque([], maxlen)
        self._index = None

    def __iter__(self):
        return self

    def __next__(self):
        if self._index is not None:
            try:
                item = self._cache[self._index]
            except IndexError:
                self._index = None
            else:
                self._index += 1
                return item

        item = next(self._source)
        self._cache.append(item)
        return item

    def __bool__(self):
        try:
            self.peek()
        except StopIteration:
            return False
        return True

    def peek(self, default=_marker):
        try:
            peeked = next(self)
        except StopIteration:
            if default is _marker:
                raise
            return default
        if self._index is None:
            self._index = len(self._cache)
        self._index -= 1
        return peeked

    def elements(self):
        return SequenceView(self._cache)

    def seek(self, index):
        self._index = index
        remainder = index - len(self._cache)
        if remainder > 0:
            consume(self, remainder)


class run_length:
    """
    :func:`run_length.encode` compresses an iterable with run-length encoding.
    It yields groups of repeated items with the count of how many times they
    were repeated:

        >>> uncompressed = 'abbcccdddd'
        >>> list(run_length.encode(uncompressed))
        [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

    :func:`run_length.decode` decompresses an iterable that was previously
    compressed with run-length encoding. It yields the items of the
    decompressed iterable:

        >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
        >>> list(run_length.decode(compressed))
        ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd']

    """

    @staticmethod
    def encode(iterable):
        return ((k, ilen(g)) for k, g in groupby(iterable))

    @staticmethod
    def decode(iterable):
        return chain.from_iterable(repeat(k, n) for k, n in iterable)


def exactly_n(iterable, n, predicate=bool):
    """Return ``True`` if exactly ``n`` items in the iterable are ``True``
    according to the *predicate* function.

        >>> exactly_n([True, True, False], 2)
        True
        >>> exactly_n([True, True, False], 1)
        False
        >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3)
        True

    The iterable will be advanced until ``n + 1`` truthy items are encountered,
    so avoid calling it on infinite iterables.

    """
    return len(take(n + 1, filter(predicate, iterable))) == n


def circular_shifts(iterable):
    """Return a list of circular shifts of *iterable*.

    >>> circular_shifts(range(4))
    [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)]
    """
    lst = list(iterable)
    return take(len(lst), windowed(cycle(lst), len(lst)))


def make_decorator(wrapping_func, result_index=0):
    """Return a decorator version of *wrapping_func*, which is a function that
    modifies an iterable. *result_index* is the position in that function's
    signature where the iterable goes.

    This lets you use itertools on the "production end," i.e. at function
    definition. This can augment what the function returns without changing the
    function's code.

    For example, to produce a decorator version of :func:`chunked`:

        >>> from more_itertools import chunked
        >>> chunker = make_decorator(chunked, result_index=0)
        >>> @chunker(3)
        ... def iter_range(n):
        ...     return iter(range(n))
        ...
        >>> list(iter_range(9))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

    To only allow truthy items to be returned:

        >>> truth_serum = make_decorator(filter, result_index=1)
        >>> @truth_serum(bool)
        ... def boolean_test():
        ...     return [0, 1, '', ' ', False, True]
        ...
        >>> list(boolean_test())
        [1, ' ', True]

    The :func:`peekable` and :func:`seekable` wrappers make for practical
    decorators:

        >>> from more_itertools import peekable
        >>> peekable_function = make_decorator(peekable)
        >>> @peekable_function()
        ... def str_range(*args):
        ...     return (str(x) for x in range(*args))
        ...
        >>> it = str_range(1, 20, 2)
        >>> next(it), next(it), next(it)
        ('1', '3', '5')
        >>> it.peek()
        '7'
        >>> next(it)
        '7'

    """
    # See https://sites.google.com/site/bbayles/index/decorator_factory for
    # notes on how this works.
    def decorator(*wrapping_args, **wrapping_kwargs):
        def outer_wrapper(f):
            def inner_wrapper(*args, **kwargs):
                result = f(*args, **kwargs)
                wrapping_args_ = list(wrapping_args)
                wrapping_args_.insert(result_index, result)
                return wrapping_func(*wrapping_args_, **wrapping_kwargs)

            return inner_wrapper

        return outer_wrapper

    return decorator


def map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None):
    """Return a dictionary that maps the items in *iterable* to categories
    defined by *keyfunc*, transforms them with *valuefunc*, and
    then summarizes them by category with *reducefunc*.

    *valuefunc* defaults to the identity function if it is unspecified.
    If *reducefunc* is unspecified, no summarization takes place:

        >>> keyfunc = lambda x: x.upper()
        >>> result = map_reduce('abbccc', keyfunc)
        >>> sorted(result.items())
        [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])]

    Specifying *valuefunc* transforms the categorized items:

        >>> keyfunc = lambda x: x.upper()
        >>> valuefunc = lambda x: 1
        >>> result = map_reduce('abbccc', keyfunc, valuefunc)
        >>> sorted(result.items())
        [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])]

    Specifying *reducefunc* summarizes the categorized items:

        >>> keyfunc = lambda x: x.upper()
        >>> valuefunc = lambda x: 1
        >>> reducefunc = sum
        >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc)
        >>> sorted(result.items())
        [('A', 1), ('B', 2), ('C', 3)]

    You may want to filter the input iterable before applying the map/reduce
    procedure:

        >>> all_items = range(30)
        >>> items = [x for x in all_items if 10 <= x <= 20]  # Filter
        >>> keyfunc = lambda x: x % 2  # Evens map to 0; odds to 1
        >>> categories = map_reduce(items, keyfunc=keyfunc)
        >>> sorted(categories.items())
        [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])]
        >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum)
        >>> sorted(summaries.items())
        [(0, 90), (1, 75)]

    Note that all items in the iterable are gathered into a list before the
    summarization step, which may require significant storage.

    The returned object is a :obj:`collections.defaultdict` with the
    ``default_factory`` set to ``None``, such that it behaves like a normal
    dictionary.

    """
    valuefunc = (lambda x: x) if (valuefunc is None) else valuefunc

    ret = defaultdict(list)
    for item in iterable:
        key = keyfunc(item)
        value = valuefunc(item)
        ret[key].append(value)

    if reducefunc is not None:
        for key, value_list in ret.items():
            ret[key] = reducefunc(value_list)

    ret.default_factory = None
    return ret


def rlocate(iterable, pred=bool, window_size=None):
    """Yield the index of each item in *iterable* for which *pred* returns
    ``True``, starting from the right and moving left.

    *pred* defaults to :func:`bool`, which will select truthy items:

        >>> list(rlocate([0, 1, 1, 0, 1, 0, 0]))  # Truthy at 1, 2, and 4
        [4, 2, 1]

    Set *pred* to a custom function to, e.g., find the indexes for a particular
    item:

        >>> iterable = iter('abcb')
        >>> pred = lambda x: x == 'b'
        >>> list(rlocate(iterable, pred))
        [3, 1]

    If *window_size* is given, then the *pred* function will be called with
    that many items. This enables searching for sub-sequences:

        >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
        >>> pred = lambda *args: args == (1, 2, 3)
        >>> list(rlocate(iterable, pred=pred, window_size=3))
        [9, 5, 1]

    Beware, this function won't return anything for infinite iterables.
    If *iterable* is reversible, ``rlocate`` will reverse it and search from
    the right. Otherwise, it will search from the left and return the results
    in reverse order.

    See :func:`locate` to for other example applications.

    """
    if window_size is None:
        try:
            len_iter = len(iterable)
            return (len_iter - i - 1 for i in locate(reversed(iterable), pred))
        except TypeError:
            pass

    return reversed(list(locate(iterable, pred, window_size)))


def replace(iterable, pred, substitutes, count=None, window_size=1):
    """Yield the items from *iterable*, replacing the items for which *pred*
    returns ``True`` with the items from the iterable *substitutes*.

        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1]
        >>> pred = lambda x: x == 0
        >>> substitutes = (2, 3)
        >>> list(replace(iterable, pred, substitutes))
        [1, 1, 2, 3, 1, 1, 2, 3, 1, 1]

    If *count* is given, the number of replacements will be limited:

        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0]
        >>> pred = lambda x: x == 0
        >>> substitutes = [None]
        >>> list(replace(iterable, pred, substitutes, count=2))
        [1, 1, None, 1, 1, None, 1, 1, 0]

    Use *window_size* to control the number of items passed as arguments to
    *pred*. This allows for locating and replacing subsequences.

        >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5]
        >>> window_size = 3
        >>> pred = lambda *args: args == (0, 1, 2)  # 3 items passed to pred
        >>> substitutes = [3, 4] # Splice in these items
        >>> list(replace(iterable, pred, substitutes, window_size=window_size))
        [3, 4, 5, 3, 4, 5]

    """
    if window_size < 1:
        raise ValueError('window_size must be at least 1')

    # Save the substitutes iterable, since it's used more than once
    substitutes = tuple(substitutes)

    # Add padding such that the number of windows matches the length of the
    # iterable
    it = chain(iterable, [_marker] * (window_size - 1))
    windows = windowed(it, window_size)

    n = 0
    for w in windows:
        # If the current window matches our predicate (and we haven't hit
        # our maximum number of replacements), splice in the substitutes
        # and then consume the following windows that overlap with this one.
        # For example, if the iterable is (0, 1, 2, 3, 4...)
        # and the window size is 2, we have (0, 1), (1, 2), (2, 3)...
        # If the predicate matches on (0, 1), we need to zap (0, 1) and (1, 2)
        if pred(*w):
            if (count is None) or (n < count):
                n += 1
                yield from substitutes
                consume(windows, window_size - 1)
                continue

        # If there was no match (or we've reached the replacement limit),
        # yield the first item from the window.
        if w and (w[0] is not _marker):
            yield w[0]


def partitions(iterable):
    """Yield all possible order-preserving partitions of *iterable*.

    >>> iterable = 'abc'
    >>> for part in partitions(iterable):
    ...     print([''.join(p) for p in part])
    ['abc']
    ['a', 'bc']
    ['ab', 'c']
    ['a', 'b', 'c']

    This is unrelated to :func:`partition`.

    """
    sequence = list(iterable)
    n = len(sequence)
    for i in powerset(range(1, n)):
        yield [sequence[i:j] for i, j in zip((0,) + i, i + (n,))]


def set_partitions(iterable, k=None):
    """
    Yield the set partitions of *iterable* into *k* parts. Set partitions are
    not order-preserving.

    >>> iterable = 'abc'
    >>> for part in set_partitions(iterable, 2):
    ...     print([''.join(p) for p in part])
    ['a', 'bc']
    ['ab', 'c']
    ['b', 'ac']


    If *k* is not given, every set partition is generated.

    >>> iterable = 'abc'
    >>> for part in set_partitions(iterable):
    ...     print([''.join(p) for p in part])
    ['abc']
    ['a', 'bc']
    ['ab', 'c']
    ['b', 'ac']
    ['a', 'b', 'c']

    """
    L = list(iterable)
    n = len(L)
    if k is not None:
        if k < 1:
            raise ValueError(
                "Can't partition in a negative or zero number of groups"
            )
        elif k > n:
            return

    def set_partitions_helper(L, k):
        n = len(L)
        if k == 1:
            yield [L]
        elif n == k:
            yield [[s] for s in L]
        else:
            e, *M = L
            for p in set_partitions_helper(M, k - 1):
                yield [[e], *p]
            for p in set_partitions_helper(M, k):
                for i in range(len(p)):
                    yield p[:i] + [[e] + p[i]] + p[i + 1 :]

    if k is None:
        for k in range(1, n + 1):
            yield from set_partitions_helper(L, k)
    else:
        yield from set_partitions_helper(L, k)


class time_limited:
    """
    Yield items from *iterable* until *limit_seconds* have passed.
    If the time limit expires before all items have been yielded, the
    ``timed_out`` parameter will be set to ``True``.

    >>> from time import sleep
    >>> def generator():
    ...     yield 1
    ...     yield 2
    ...     sleep(0.2)
    ...     yield 3
    >>> iterable = time_limited(0.1, generator())
    >>> list(iterable)
    [1, 2]
    >>> iterable.timed_out
    True

    Note that the time is checked before each item is yielded, and iteration
    stops if  the time elapsed is greater than *limit_seconds*. If your time
    limit is 1 second, but it takes 2 seconds to generate the first item from
    the iterable, the function will run for 2 seconds and not yield anything.

    """

    def __init__(self, limit_seconds, iterable):
        if limit_seconds < 0:
            raise ValueError('limit_seconds must be positive')
        self.limit_seconds = limit_seconds
        self._iterable = iter(iterable)
        self._start_time = monotonic()
        self.timed_out = False

    def __iter__(self):
        return self

    def __next__(self):
        item = next(self._iterable)
        if monotonic() - self._start_time > self.limit_seconds:
            self.timed_out = True
            raise StopIteration

        return item


def only(iterable, default=None, too_long=None):
    """If *iterable* has only one item, return it.
    If it has zero items, return *default*.
    If it has more than one item, raise the exception given by *too_long*,
    which is ``ValueError`` by default.

    >>> only([], default='missing')
    'missing'
    >>> only([1])
    1
    >>> only([1, 2])  # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    ValueError: Expected exactly one item in iterable, but got 1, 2,
     and perhaps more.'
    >>> only([1, 2], too_long=TypeError)  # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    TypeError

    Note that :func:`only` attempts to advance *iterable* twice to ensure there
    is only one item.  See :func:`spy` or :func:`peekable` to check
    iterable contents less destructively.
    """
    it = iter(iterable)
    first_value = next(it, default)

    try:
        second_value = next(it)
    except StopIteration:
        pass
    else:
        msg = (
            'Expected exactly one item in iterable, but got {!r}, {!r}, '
            'and perhaps more.'.format(first_value, second_value)
        )
        raise too_long or ValueError(msg)

    return first_value


def ichunked(iterable, n):
    """Break *iterable* into sub-iterables with *n* elements each.
    :func:`ichunked` is like :func:`chunked`, but it yields iterables
    instead of lists.

    If the sub-iterables are read in order, the elements of *iterable*
    won't be stored in memory.
    If they are read out of order, :func:`itertools.tee` is used to cache
    elements as necessary.

    >>> from itertools import count
    >>> all_chunks = ichunked(count(), 4)
    >>> c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks)
    >>> list(c_2)  # c_1's elements have been cached; c_3's haven't been
    [4, 5, 6, 7]
    >>> list(c_1)
    [0, 1, 2, 3]
    >>> list(c_3)
    [8, 9, 10, 11]

    """
    source = iter(iterable)

    while True:
        # Check to see whether we're at the end of the source iterable
        item = next(source, _marker)
        if item is _marker:
            return

        # Clone the source and yield an n-length slice
        source, it = tee(chain([item], source))
        yield islice(it, n)

        # Advance the source iterable
        consume(source, n)


def distinct_combinations(iterable, r):
    """Yield the distinct combinations of *r* items taken from *iterable*.

        >>> list(distinct_combinations([0, 0, 1], 2))
        [(0, 0), (0, 1)]

    Equivalent to ``set(combinations(iterable))``, except duplicates are not
    generated and thrown away. For larger input sequences this is much more
    efficient.

    """
    if r < 0:
        raise ValueError('r must be non-negative')
    elif r == 0:
        yield ()
        return
    pool = tuple(iterable)
    generators = [unique_everseen(enumerate(pool), key=itemgetter(1))]
    current_combo = [None] * r
    level = 0
    while generators:
        try:
            cur_idx, p = next(generators[-1])
        except StopIteration:
            generators.pop()
            level -= 1
            continue
        current_combo[level] = p
        if level + 1 == r:
            yield tuple(current_combo)
        else:
            generators.append(
                unique_everseen(
                    enumerate(pool[cur_idx + 1 :], cur_idx + 1),
                    key=itemgetter(1),
                )
            )
            level += 1


def filter_except(validator, iterable, *exceptions):
    """Yield the items from *iterable* for which the *validator* function does
    not raise one of the specified *exceptions*.

    *validator* is called for each item in *iterable*.
    It should be a function that accepts one argument and raises an exception
    if that item is not valid.

    >>> iterable = ['1', '2', 'three', '4', None]
    >>> list(filter_except(int, iterable, ValueError, TypeError))
    ['1', '2', '4']

    If an exception other than one given by *exceptions* is raised by
    *validator*, it is raised like normal.
    """
    for item in iterable:
        try:
            validator(item)
        except exceptions:
            pass
        else:
            yield item


def map_except(function, iterable, *exceptions):
    """Transform each item from *iterable* with *function* and yield the
    result, unless *function* raises one of the specified *exceptions*.

    *function* is called to transform each item in *iterable*.
    It should be a accept one argument.

    >>> iterable = ['1', '2', 'three', '4', None]
    >>> list(map_except(int, iterable, ValueError, TypeError))
    [1, 2, 4]

    If an exception other than one given by *exceptions* is raised by
    *function*, it is raised like normal.
    """
    for item in iterable:
        try:
            yield function(item)
        except exceptions:
            pass


def _sample_unweighted(iterable, k):
    # Implementation of "Algorithm L" from the 1994 paper by Kim-Hung Li:
    # "Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))".

    # Fill up the reservoir (collection of samples) with the first `k` samples
    reservoir = take(k, iterable)

    # Generate random number that's the largest in a sample of k U(0,1) numbers
    # Largest order statistic: https://en.wikipedia.org/wiki/Order_statistic
    W = exp(log(random()) / k)

    # The number of elements to skip before changing the reservoir is a random
    # number with a geometric distribution. Sample it using random() and logs.
    next_index = k + floor(log(random()) / log(1 - W))

    for index, element in enumerate(iterable, k):

        if index == next_index:
            reservoir[randrange(k)] = element
            # The new W is the largest in a sample of k U(0, `old_W`) numbers
            W *= exp(log(random()) / k)
            next_index += floor(log(random()) / log(1 - W)) + 1

    return reservoir


def _sample_weighted(iterable, k, weights):
    # Implementation of "A-ExpJ" from the 2006 paper by Efraimidis et al. :
    # "Weighted random sampling with a reservoir".

    # Log-transform for numerical stability for weights that are small/large
    weight_keys = (log(random()) / weight for weight in weights)

    # Fill up the reservoir (collection of samples) with the first `k`
    # weight-keys and elements, then heapify the list.
    reservoir = take(k, zip(weight_keys, iterable))
    heapify(reservoir)

    # The number of jumps before changing the reservoir is a random variable
    # with an exponential distribution. Sample it using random() and logs.
    smallest_weight_key, _ = reservoir[0]
    weights_to_skip = log(random()) / smallest_weight_key

    for weight, element in zip(weights, iterable):
        if weight >= weights_to_skip:
            # The notation here is consistent with the paper, but we store
            # the weight-keys in log-space for better numerical stability.
            smallest_weight_key, _ = reservoir[0]
            t_w = exp(weight * smallest_weight_key)
            r_2 = uniform(t_w, 1)  # generate U(t_w, 1)
            weight_key = log(r_2) / weight
            heapreplace(reservoir, (weight_key, element))
            smallest_weight_key, _ = reservoir[0]
            weights_to_skip = log(random()) / smallest_weight_key
        else:
            weights_to_skip -= weight

    # Equivalent to [element for weight_key, element in sorted(reservoir)]
    return [heappop(reservoir)[1] for _ in range(k)]


def sample(iterable, k, weights=None):
    """Return a *k*-length list of elements chosen (without replacement)
    from the *iterable*. Like :func:`random.sample`, but works on iterables
    of unknown length.

    >>> iterable = range(100)
    >>> sample(iterable, 5)  # doctest: +SKIP
    [81, 60, 96, 16, 4]

    An iterable with *weights* may also be given:

    >>> iterable = range(100)
    >>> weights = (i * i + 1 for i in range(100))
    >>> sampled = sample(iterable, 5, weights=weights)  # doctest: +SKIP
    [79, 67, 74, 66, 78]

    The algorithm can also be used to generate weighted random permutations.
    The relative weight of each item determines the probability that it
    appears late in the permutation.

    >>> data = "abcdefgh"
    >>> weights = range(1, len(data) + 1)
    >>> sample(data, k=len(data), weights=weights)  # doctest: +SKIP
    ['c', 'a', 'b', 'e', 'g', 'd', 'h', 'f']
    """
    if k == 0:
        return []

    iterable = iter(iterable)
    if weights is None:
        return _sample_unweighted(iterable, k)
    else:
        weights = iter(weights)
        return _sample_weighted(iterable, k, weights)


def is_sorted(iterable, key=None, reverse=False):
    """Returns ``True`` if the items of iterable are in sorted order, and
    ``False`` otherwise. *key* and *reverse* have the same meaning that they do
    in the built-in :func:`sorted` function.

    >>> is_sorted(['1', '2', '3', '4', '5'], key=int)
    True
    >>> is_sorted([5, 4, 3, 1, 2], reverse=True)
    False

    The function returns ``False`` after encountering the first out-of-order
    item. If there are no out-of-order items, the iterable is exhausted.
    """

    compare = lt if reverse else gt
    it = iterable if (key is None) else map(key, iterable)
    return not any(starmap(compare, pairwise(it)))


class AbortThread(BaseException):
    pass


class callback_iter:
    """Convert a function that uses callbacks to an iterator.

    Let *func* be a function that takes a `callback` keyword argument.
    For example:

    >>> def func(callback=None):
    ...     for i, c in [(1, 'a'), (2, 'b'), (3, 'c')]:
    ...         if callback:
    ...             callback(i, c)
    ...     return 4


    Use ``with callback_iter(func)`` to get an iterator over the parameters
    that are delivered to the callback.

    >>> with callback_iter(func) as it:
    ...     for args, kwargs in it:
    ...         print(args)
    (1, 'a')
    (2, 'b')
    (3, 'c')

    The function will be called in a background thread. The ``done`` property
    indicates whether it has completed execution.

    >>> it.done
    True

    If it completes successfully, its return value will be available
    in the ``result`` property.

    >>> it.result
    4

    Notes:

    * If the function uses some keyword argument besides ``callback``, supply
      *callback_kwd*.
    * If it finished executing, but raised an exception, accessing the
      ``result`` property will raise the same exception.
    * If it hasn't finished executing, accessing the ``result``
      property from within the ``with`` block will raise ``RuntimeError``.
    * If it hasn't finished executing, accessing the ``result`` property from
      outside the ``with`` block will raise a
      ``more_itertools.AbortThread`` exception.
    * Provide *wait_seconds* to adjust how frequently the it is polled for
      output.

    """

    def __init__(self, func, callback_kwd='callback', wait_seconds=0.1):
        self._func = func
        self._callback_kwd = callback_kwd
        self._aborted = False
        self._future = None
        self._wait_seconds = wait_seconds
        self._executor = ThreadPoolExecutor(max_workers=1)
        self._iterator = self._reader()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self._aborted = True
        self._executor.shutdown()

    def __iter__(self):
        return self

    def __next__(self):
        return next(self._iterator)

    @property
    def done(self):
        if self._future is None:
            return False
        return self._future.done()

    @property
    def result(self):
        if not self.done:
            raise RuntimeError('Function has not yet completed')

        return self._future.result()

    def _reader(self):
        q = Queue()

        def callback(*args, **kwargs):
            if self._aborted:
                raise AbortThread('canceled by user')

            q.put((args, kwargs))

        self._future = self._executor.submit(
            self._func, **{self._callback_kwd: callback}
        )

        while True:
            try:
                item = q.get(timeout=self._wait_seconds)
            except Empty:
                pass
            else:
                q.task_done()
                yield item

            if self._future.done():
                break

        remaining = []
        while True:
            try:
                item = q.get_nowait()
            except Empty:
                break
            else:
                q.task_done()
                remaining.append(item)
        q.join()
        yield from remaining


def windowed_complete(iterable, n):
    """
    Yield ``(beginning, middle, end)`` tuples, where:

    * Each ``middle`` has *n* items from *iterable*
    * Each ``beginning`` has the items before the ones in ``middle``
    * Each ``end`` has the items after the ones in ``middle``

    >>> iterable = range(7)
    >>> n = 3
    >>> for beginning, middle, end in windowed_complete(iterable, n):
    ...     print(beginning, middle, end)
    () (0, 1, 2) (3, 4, 5, 6)
    (0,) (1, 2, 3) (4, 5, 6)
    (0, 1) (2, 3, 4) (5, 6)
    (0, 1, 2) (3, 4, 5) (6,)
    (0, 1, 2, 3) (4, 5, 6) ()

    Note that *n* must be at least 0 and most equal to the length of
    *iterable*.

    This function will exhaust the iterable and may require significant
    storage.
    """
    if n < 0:
        raise ValueError('n must be >= 0')

    seq = tuple(iterable)
    size = len(seq)

    if n > size:
        raise ValueError('n must be <= len(seq)')

    for i in range(size - n + 1):
        beginning = seq[:i]
        middle = seq[i : i + n]
        end = seq[i + n :]
        yield beginning, middle, end


def all_unique(iterable, key=None):
    """
    Returns ``True`` if all the elements of *iterable* are unique (no two
    elements are equal).

        >>> all_unique('ABCB')
        False

    If a *key* function is specified, it will be used to make comparisons.

        >>> all_unique('ABCb')
        True
        >>> all_unique('ABCb', str.lower)
        False

    The function returns as soon as the first non-unique element is
    encountered. Iterables with a mix of hashable and unhashable items can
    be used, but the function will be slower for unhashable items.
    """
    seenset = set()
    seenset_add = seenset.add
    seenlist = []
    seenlist_add = seenlist.append
    for element in map(key, iterable) if key else iterable:
        try:
            if element in seenset:
                return False
            seenset_add(element)
        except TypeError:
            if element in seenlist:
                return False
            seenlist_add(element)
    return True


def nth_product(index, *args):
    """Equivalent to ``list(product(*args))[index]``.

    The products of *args* can be ordered lexicographically.
    :func:`nth_product` computes the product at sort position *index* without
    computing the previous products.

        >>> nth_product(8, range(2), range(2), range(2), range(2))
        (1, 0, 0, 0)

    ``IndexError`` will be raised if the given *index* is invalid.
    """
    pools = list(map(tuple, reversed(args)))
    ns = list(map(len, pools))

    c = reduce(mul, ns)

    if index < 0:
        index += c

    if not 0 <= index < c:
        raise IndexError

    result = []
    for pool, n in zip(pools, ns):
        result.append(pool[index % n])
        index //= n

    return tuple(reversed(result))


def nth_permutation(iterable, r, index):
    """Equivalent to ``list(permutations(iterable, r))[index]```

    The subsequences of *iterable* that are of length *r* where order is
    important can be ordered lexicographically. :func:`nth_permutation`
    computes the subsequence at sort position *index* directly, without
    computing the previous subsequences.

        >>> nth_permutation('ghijk', 2, 5)
        ('h', 'i')

    ``ValueError`` will be raised If *r* is negative or greater than the length
    of *iterable*.
    ``IndexError`` will be raised if the given *index* is invalid.
    """
    pool = list(iterable)
    n = len(pool)

    if r is None or r == n:
        r, c = n, factorial(n)
    elif not 0 <= r < n:
        raise ValueError
    else:
        c = factorial(n) // factorial(n - r)

    if index < 0:
        index += c

    if not 0 <= index < c:
        raise IndexError

    if c == 0:
        return tuple()

    result = [0] * r
    q = index * factorial(n) // c if r < n else index
    for d in range(1, n + 1):
        q, i = divmod(q, d)
        if 0 <= n - d < r:
            result[n - d] = i
        if q == 0:
            break

    return tuple(map(pool.pop, result))


def value_chain(*args):
    """Yield all arguments passed to the function in the same order in which
    they were passed. If an argument itself is iterable then iterate over its
    values.

        >>> list(value_chain(1, 2, 3, [4, 5, 6]))
        [1, 2, 3, 4, 5, 6]

    Binary and text strings are not considered iterable and are emitted
    as-is:

        >>> list(value_chain('12', '34', ['56', '78']))
        ['12', '34', '56', '78']


    Multiple levels of nesting are not flattened.

    """
    for value in args:
        if isinstance(value, (str, bytes)):
            yield value
            continue
        try:
            yield from value
        except TypeError:
            yield value


def product_index(element, *args):
    """Equivalent to ``list(product(*args)).index(element)``

    The products of *args* can be ordered lexicographically.
    :func:`product_index` computes the first index of *element* without
    computing the previous products.

        >>> product_index([8, 2], range(10), range(5))
        42

    ``ValueError`` will be raised if the given *element* isn't in the product
    of *args*.
    """
    index = 0

    for x, pool in zip_longest(element, args, fillvalue=_marker):
        if x is _marker or pool is _marker:
            raise ValueError('element is not a product of args')

        pool = tuple(pool)
        index = index * len(pool) + pool.index(x)

    return index


def combination_index(element, iterable):
    """Equivalent to ``list(combinations(iterable, r)).index(element)``

    The subsequences of *iterable* that are of length *r* can be ordered
    lexicographically. :func:`combination_index` computes the index of the
    first *element*, without computing the previous combinations.

        >>> combination_index('adf', 'abcdefg')
        10

    ``ValueError`` will be raised if the given *element* isn't one of the
    combinations of *iterable*.
    """
    element = enumerate(element)
    k, y = next(element, (None, None))
    if k is None:
        return 0

    indexes = []
    pool = enumerate(iterable)
    for n, x in pool:
        if x == y:
            indexes.append(n)
            tmp, y = next(element, (None, None))
            if tmp is None:
                break
            else:
                k = tmp
    else:
        raise ValueError('element is not a combination of iterable')

    n, _ = last(pool, default=(n, None))

    # Python versiosn below 3.8 don't have math.comb
    index = 1
    for i, j in enumerate(reversed(indexes), start=1):
        j = n - j
        if i <= j:
            index += factorial(j) // (factorial(i) * factorial(j - i))

    return factorial(n + 1) // (factorial(k + 1) * factorial(n - k)) - index


def permutation_index(element, iterable):
    """Equivalent to ``list(permutations(iterable, r)).index(element)```

    The subsequences of *iterable* that are of length *r* where order is
    important can be ordered lexicographically. :func:`permutation_index`
    computes the index of the first *element* directly, without computing
    the previous permutations.

        >>> permutation_index([1, 3, 2], range(5))
        19

    ``ValueError`` will be raised if the given *element* isn't one of the
    permutations of *iterable*.
    """
    index = 0
    pool = list(iterable)
    for i, x in zip(range(len(pool), -1, -1), element):
        r = pool.index(x)
        index = index * i + r
        del pool[r]

    return index


class countable:
    """Wrap *iterable* and keep a count of how many items have been consumed.

    The ``items_seen`` attribute starts at ``0`` and increments as the iterable
    is consumed:

        >>> iterable = map(str, range(10))
        >>> it = countable(iterable)
        >>> it.items_seen
        0
        >>> next(it), next(it)
        ('0', '1')
        >>> list(it)
        ['2', '3', '4', '5', '6', '7', '8', '9']
        >>> it.items_seen
        10
    """

    def __init__(self, iterable):
        self._it = iter(iterable)
        self.items_seen = 0

    def __iter__(self):
        return self

    def __next__(self):
        item = next(self._it)
        self.items_seen += 1

        return item
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/more_itertools/recipes.py0000644000175100001710000003760000000000000024331 0ustar00runnerdocker"""Imported from the recipes section of the itertools documentation.

All functions taken from the recipes section of the itertools library docs
[1]_.
Some backward-compatible usability improvements have been made.

.. [1] http://docs.python.org/library/itertools.html#recipes

"""
import warnings
from collections import deque
from itertools import (
    chain,
    combinations,
    count,
    cycle,
    groupby,
    islice,
    repeat,
    starmap,
    tee,
    zip_longest,
)
import operator
from random import randrange, sample, choice

__all__ = [
    'all_equal',
    'consume',
    'convolve',
    'dotproduct',
    'first_true',
    'flatten',
    'grouper',
    'iter_except',
    'ncycles',
    'nth',
    'nth_combination',
    'padnone',
    'pad_none',
    'pairwise',
    'partition',
    'powerset',
    'prepend',
    'quantify',
    'random_combination_with_replacement',
    'random_combination',
    'random_permutation',
    'random_product',
    'repeatfunc',
    'roundrobin',
    'tabulate',
    'tail',
    'take',
    'unique_everseen',
    'unique_justseen',
]


def take(n, iterable):
    """Return first *n* items of the iterable as a list.

        >>> take(3, range(10))
        [0, 1, 2]

    If there are fewer than *n* items in the iterable, all of them are
    returned.

        >>> take(10, range(3))
        [0, 1, 2]

    """
    return list(islice(iterable, n))


def tabulate(function, start=0):
    """Return an iterator over the results of ``func(start)``,
    ``func(start + 1)``, ``func(start + 2)``...

    *func* should be a function that accepts one integer argument.

    If *start* is not specified it defaults to 0. It will be incremented each
    time the iterator is advanced.

        >>> square = lambda x: x ** 2
        >>> iterator = tabulate(square, -3)
        >>> take(4, iterator)
        [9, 4, 1, 0]

    """
    return map(function, count(start))


def tail(n, iterable):
    """Return an iterator over the last *n* items of *iterable*.

    >>> t = tail(3, 'ABCDEFG')
    >>> list(t)
    ['E', 'F', 'G']

    """
    return iter(deque(iterable, maxlen=n))


def consume(iterator, n=None):
    """Advance *iterable* by *n* steps. If *n* is ``None``, consume it
    entirely.

    Efficiently exhausts an iterator without returning values. Defaults to
    consuming the whole iterator, but an optional second argument may be
    provided to limit consumption.

        >>> i = (x for x in range(10))
        >>> next(i)
        0
        >>> consume(i, 3)
        >>> next(i)
        4
        >>> consume(i)
        >>> next(i)
        Traceback (most recent call last):
          File "", line 1, in 
        StopIteration

    If the iterator has fewer items remaining than the provided limit, the
    whole iterator will be consumed.

        >>> i = (x for x in range(3))
        >>> consume(i, 5)
        >>> next(i)
        Traceback (most recent call last):
          File "", line 1, in 
        StopIteration

    """
    # Use functions that consume iterators at C speed.
    if n is None:
        # feed the entire iterator into a zero-length deque
        deque(iterator, maxlen=0)
    else:
        # advance to the empty slice starting at position n
        next(islice(iterator, n, n), None)


def nth(iterable, n, default=None):
    """Returns the nth item or a default value.

    >>> l = range(10)
    >>> nth(l, 3)
    3
    >>> nth(l, 20, "zebra")
    'zebra'

    """
    return next(islice(iterable, n, None), default)


def all_equal(iterable):
    """
    Returns ``True`` if all the elements are equal to each other.

        >>> all_equal('aaaa')
        True
        >>> all_equal('aaab')
        False

    """
    g = groupby(iterable)
    return next(g, True) and not next(g, False)


def quantify(iterable, pred=bool):
    """Return the how many times the predicate is true.

    >>> quantify([True, False, True])
    2

    """
    return sum(map(pred, iterable))


def pad_none(iterable):
    """Returns the sequence of elements and then returns ``None`` indefinitely.

        >>> take(5, pad_none(range(3)))
        [0, 1, 2, None, None]

    Useful for emulating the behavior of the built-in :func:`map` function.

    See also :func:`padded`.

    """
    return chain(iterable, repeat(None))


padnone = pad_none


def ncycles(iterable, n):
    """Returns the sequence elements *n* times

    >>> list(ncycles(["a", "b"], 3))
    ['a', 'b', 'a', 'b', 'a', 'b']

    """
    return chain.from_iterable(repeat(tuple(iterable), n))


def dotproduct(vec1, vec2):
    """Returns the dot product of the two iterables.

    >>> dotproduct([10, 10], [20, 20])
    400

    """
    return sum(map(operator.mul, vec1, vec2))


def flatten(listOfLists):
    """Return an iterator flattening one level of nesting in a list of lists.

        >>> list(flatten([[0, 1], [2, 3]]))
        [0, 1, 2, 3]

    See also :func:`collapse`, which can flatten multiple levels of nesting.

    """
    return chain.from_iterable(listOfLists)


def repeatfunc(func, times=None, *args):
    """Call *func* with *args* repeatedly, returning an iterable over the
    results.

    If *times* is specified, the iterable will terminate after that many
    repetitions:

        >>> from operator import add
        >>> times = 4
        >>> args = 3, 5
        >>> list(repeatfunc(add, times, *args))
        [8, 8, 8, 8]

    If *times* is ``None`` the iterable will not terminate:

        >>> from random import randrange
        >>> times = None
        >>> args = 1, 11
        >>> take(6, repeatfunc(randrange, times, *args))  # doctest:+SKIP
        [2, 4, 8, 1, 8, 4]

    """
    if times is None:
        return starmap(func, repeat(args))
    return starmap(func, repeat(args, times))


def _pairwise(iterable):
    """Returns an iterator of paired items, overlapping, from the original

    >>> take(4, pairwise(count()))
    [(0, 1), (1, 2), (2, 3), (3, 4)]

    On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`.

    """
    a, b = tee(iterable)
    next(b, None)
    yield from zip(a, b)


try:
    from itertools import pairwise as itertools_pairwise
except ImportError:
    pairwise = _pairwise
else:

    def pairwise(iterable):
        yield from itertools_pairwise(iterable)

    pairwise.__doc__ = _pairwise.__doc__


def grouper(iterable, n, fillvalue=None):
    """Collect data into fixed-length chunks or blocks.

    >>> list(grouper('ABCDEFG', 3, 'x'))
    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]

    """
    if isinstance(iterable, int):
        warnings.warn(
            "grouper expects iterable as first parameter", DeprecationWarning
        )
        n, iterable = iterable, n
    args = [iter(iterable)] * n
    return zip_longest(fillvalue=fillvalue, *args)


def roundrobin(*iterables):
    """Yields an item from each iterable, alternating between them.

        >>> list(roundrobin('ABC', 'D', 'EF'))
        ['A', 'D', 'E', 'B', 'F', 'C']

    This function produces the same output as :func:`interleave_longest`, but
    may perform better for some inputs (in particular when the number of
    iterables is small).

    """
    # Recipe credited to George Sakkis
    pending = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while pending:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            pending -= 1
            nexts = cycle(islice(nexts, pending))


def partition(pred, iterable):
    """
    Returns a 2-tuple of iterables derived from the input iterable.
    The first yields the items that have ``pred(item) == False``.
    The second yields the items that have ``pred(item) == True``.

        >>> is_odd = lambda x: x % 2 != 0
        >>> iterable = range(10)
        >>> even_items, odd_items = partition(is_odd, iterable)
        >>> list(even_items), list(odd_items)
        ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])

    If *pred* is None, :func:`bool` is used.

        >>> iterable = [0, 1, False, True, '', ' ']
        >>> false_items, true_items = partition(None, iterable)
        >>> list(false_items), list(true_items)
        ([0, False, ''], [1, True, ' '])

    """
    if pred is None:
        pred = bool

    evaluations = ((pred(x), x) for x in iterable)
    t1, t2 = tee(evaluations)
    return (
        (x for (cond, x) in t1 if not cond),
        (x for (cond, x) in t2 if cond),
    )


def powerset(iterable):
    """Yields all possible subsets of the iterable.

        >>> list(powerset([1, 2, 3]))
        [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

    :func:`powerset` will operate on iterables that aren't :class:`set`
    instances, so repeated elements in the input will produce repeated elements
    in the output. Use :func:`unique_everseen` on the input to avoid generating
    duplicates:

        >>> seq = [1, 1, 0]
        >>> list(powerset(seq))
        [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
        >>> from more_itertools import unique_everseen
        >>> list(powerset(unique_everseen(seq)))
        [(), (1,), (0,), (1, 0)]

    """
    s = list(iterable)
    return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))


def unique_everseen(iterable, key=None):
    """
    Yield unique elements, preserving order.

        >>> list(unique_everseen('AAAABBBCCDAABBB'))
        ['A', 'B', 'C', 'D']
        >>> list(unique_everseen('ABBCcAD', str.lower))
        ['A', 'B', 'C', 'D']

    Sequences with a mix of hashable and unhashable items can be used.
    The function will be slower (i.e., `O(n^2)`) for unhashable items.

    Remember that ``list`` objects are unhashable - you can use the *key*
    parameter to transform the list to a tuple (which is hashable) to
    avoid a slowdown.

        >>> iterable = ([1, 2], [2, 3], [1, 2])
        >>> list(unique_everseen(iterable))  # Slow
        [[1, 2], [2, 3]]
        >>> list(unique_everseen(iterable, key=tuple))  # Faster
        [[1, 2], [2, 3]]

    Similary, you may want to convert unhashable ``set`` objects with
    ``key=frozenset``. For ``dict`` objects,
    ``key=lambda x: frozenset(x.items())`` can be used.

    """
    seenset = set()
    seenset_add = seenset.add
    seenlist = []
    seenlist_add = seenlist.append
    use_key = key is not None

    for element in iterable:
        k = key(element) if use_key else element
        try:
            if k not in seenset:
                seenset_add(k)
                yield element
        except TypeError:
            if k not in seenlist:
                seenlist_add(k)
                yield element


def unique_justseen(iterable, key=None):
    """Yields elements in order, ignoring serial duplicates

    >>> list(unique_justseen('AAAABBBCCDAABBB'))
    ['A', 'B', 'C', 'D', 'A', 'B']
    >>> list(unique_justseen('ABBCcAD', str.lower))
    ['A', 'B', 'C', 'A', 'D']

    """
    return map(next, map(operator.itemgetter(1), groupby(iterable, key)))


def iter_except(func, exception, first=None):
    """Yields results from a function repeatedly until an exception is raised.

    Converts a call-until-exception interface to an iterator interface.
    Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel
    to end the loop.

        >>> l = [0, 1, 2]
        >>> list(iter_except(l.pop, IndexError))
        [2, 1, 0]

    """
    try:
        if first is not None:
            yield first()
        while 1:
            yield func()
    except exception:
        pass


def first_true(iterable, default=None, pred=None):
    """
    Returns the first true value in the iterable.

    If no true value is found, returns *default*

    If *pred* is not None, returns the first item for which
    ``pred(item) == True`` .

        >>> first_true(range(10))
        1
        >>> first_true(range(10), pred=lambda x: x > 5)
        6
        >>> first_true(range(10), default='missing', pred=lambda x: x > 9)
        'missing'

    """
    return next(filter(pred, iterable), default)


def random_product(*args, repeat=1):
    """Draw an item at random from each of the input iterables.

        >>> random_product('abc', range(4), 'XYZ')  # doctest:+SKIP
        ('c', 3, 'Z')

    If *repeat* is provided as a keyword argument, that many items will be
    drawn from each iterable.

        >>> random_product('abcd', range(4), repeat=2)  # doctest:+SKIP
        ('a', 2, 'd', 3)

    This equivalent to taking a random selection from
    ``itertools.product(*args, **kwarg)``.

    """
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(choice(pool) for pool in pools)


def random_permutation(iterable, r=None):
    """Return a random *r* length permutation of the elements in *iterable*.

    If *r* is not specified or is ``None``, then *r* defaults to the length of
    *iterable*.

        >>> random_permutation(range(5))  # doctest:+SKIP
        (3, 4, 0, 1, 2)

    This equivalent to taking a random selection from
    ``itertools.permutations(iterable, r)``.

    """
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(sample(pool, r))


def random_combination(iterable, r):
    """Return a random *r* length subsequence of the elements in *iterable*.

        >>> random_combination(range(5), 3)  # doctest:+SKIP
        (2, 3, 4)

    This equivalent to taking a random selection from
    ``itertools.combinations(iterable, r)``.

    """
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(sample(range(n), r))
    return tuple(pool[i] for i in indices)


def random_combination_with_replacement(iterable, r):
    """Return a random *r* length subsequence of elements in *iterable*,
    allowing individual elements to be repeated.

        >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
        (0, 0, 1, 2, 2)

    This equivalent to taking a random selection from
    ``itertools.combinations_with_replacement(iterable, r)``.

    """
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(randrange(n) for i in range(r))
    return tuple(pool[i] for i in indices)


def nth_combination(iterable, r, index):
    """Equivalent to ``list(combinations(iterable, r))[index]``.

    The subsequences of *iterable* that are of length *r* can be ordered
    lexicographically. :func:`nth_combination` computes the subsequence at
    sort position *index* directly, without computing the previous
    subsequences.

        >>> nth_combination(range(5), 3, 5)
        (0, 3, 4)

    ``ValueError`` will be raised If *r* is negative or greater than the length
    of *iterable*.
    ``IndexError`` will be raised if the given *index* is invalid.
    """
    pool = tuple(iterable)
    n = len(pool)
    if (r < 0) or (r > n):
        raise ValueError

    c = 1
    k = min(r, n - r)
    for i in range(1, k + 1):
        c = c * (n - k + i) // i

    if index < 0:
        index += c

    if (index < 0) or (index >= c):
        raise IndexError

    result = []
    while r:
        c, n, r = c * r // n, n - 1, r - 1
        while index >= c:
            index -= c
            c, n = c * (n - r) // n, n - 1
        result.append(pool[-1 - n])

    return tuple(result)


def prepend(value, iterator):
    """Yield *value*, followed by the elements in *iterator*.

        >>> value = '0'
        >>> iterator = ['1', '2', '3']
        >>> list(prepend(value, iterator))
        ['0', '1', '2', '3']

    To prepend multiple values, see :func:`itertools.chain`
    or :func:`value_chain`.

    """
    return chain([value], iterator)


def convolve(signal, kernel):
    """Convolve the iterable *signal* with the iterable *kernel*.

        >>> signal = (1, 2, 3, 4, 5)
        >>> kernel = [3, 2, 1]
        >>> list(convolve(signal, kernel))
        [3, 8, 14, 20, 26, 14, 5]

    Note: the input arguments are not interchangeable, as the *kernel*
    is immediately consumed and stored.

    """
    kernel = tuple(kernel)[::-1]
    n = len(kernel)
    window = deque([0], maxlen=n) * n
    for x in chain(signal, repeat(0, n - 1)):
        window.append(x)
        yield sum(map(operator.mul, kernel, window))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/ordered_set.py0000644000175100001710000003543200000000000022131 0ustar00runnerdocker"""
An OrderedSet is a custom MutableSet that remembers its order, so that every
entry has an index that can be looked up.

Based on a recipe originally posted to ActiveState Recipes by Raymond Hettiger,
and released under the MIT license.
"""
import itertools as it
from collections import deque

try:
    # Python 3
    from collections.abc import MutableSet, Sequence
except ImportError:
    # Python 2.7
    from collections import MutableSet, Sequence

SLICE_ALL = slice(None)
__version__ = "3.1"


def is_iterable(obj):
    """
    Are we being asked to look up a list of things, instead of a single thing?
    We check for the `__iter__` attribute so that this can cover types that
    don't have to be known by this module, such as NumPy arrays.

    Strings, however, should be considered as atomic values to look up, not
    iterables. The same goes for tuples, since they are immutable and therefore
    valid entries.

    We don't need to check for the Python 2 `unicode` type, because it doesn't
    have an `__iter__` attribute anyway.
    """
    return (
        hasattr(obj, "__iter__")
        and not isinstance(obj, str)
        and not isinstance(obj, tuple)
    )


class OrderedSet(MutableSet, Sequence):
    """
    An OrderedSet is a custom MutableSet that remembers its order, so that
    every entry has an index that can be looked up.

    Example:
        >>> OrderedSet([1, 1, 2, 3, 2])
        OrderedSet([1, 2, 3])
    """

    def __init__(self, iterable=None):
        self.items = []
        self.map = {}
        if iterable is not None:
            self |= iterable

    def __len__(self):
        """
        Returns the number of unique elements in the ordered set

        Example:
            >>> len(OrderedSet([]))
            0
            >>> len(OrderedSet([1, 2]))
            2
        """
        return len(self.items)

    def __getitem__(self, index):
        """
        Get the item at a given index.

        If `index` is a slice, you will get back that slice of items, as a
        new OrderedSet.

        If `index` is a list or a similar iterable, you'll get a list of
        items corresponding to those indices. This is similar to NumPy's
        "fancy indexing". The result is not an OrderedSet because you may ask
        for duplicate indices, and the number of elements returned should be
        the number of elements asked for.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset[1]
            2
        """
        if isinstance(index, slice) and index == SLICE_ALL:
            return self.copy()
        elif is_iterable(index):
            return [self.items[i] for i in index]
        elif hasattr(index, "__index__") or isinstance(index, slice):
            result = self.items[index]
            if isinstance(result, list):
                return self.__class__(result)
            else:
                return result
        else:
            raise TypeError("Don't know how to index an OrderedSet by %r" % index)

    def copy(self):
        """
        Return a shallow copy of this object.

        Example:
            >>> this = OrderedSet([1, 2, 3])
            >>> other = this.copy()
            >>> this == other
            True
            >>> this is other
            False
        """
        return self.__class__(self)

    def __getstate__(self):
        if len(self) == 0:
            # The state can't be an empty list.
            # We need to return a truthy value, or else __setstate__ won't be run.
            #
            # This could have been done more gracefully by always putting the state
            # in a tuple, but this way is backwards- and forwards- compatible with
            # previous versions of OrderedSet.
            return (None,)
        else:
            return list(self)

    def __setstate__(self, state):
        if state == (None,):
            self.__init__([])
        else:
            self.__init__(state)

    def __contains__(self, key):
        """
        Test if the item is in this ordered set

        Example:
            >>> 1 in OrderedSet([1, 3, 2])
            True
            >>> 5 in OrderedSet([1, 3, 2])
            False
        """
        return key in self.map

    def add(self, key):
        """
        Add `key` as an item to this OrderedSet, then return its index.

        If `key` is already in the OrderedSet, return the index it already
        had.

        Example:
            >>> oset = OrderedSet()
            >>> oset.append(3)
            0
            >>> print(oset)
            OrderedSet([3])
        """
        if key not in self.map:
            self.map[key] = len(self.items)
            self.items.append(key)
        return self.map[key]

    append = add

    def update(self, sequence):
        """
        Update the set with the given iterable sequence, then return the index
        of the last element inserted.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.update([3, 1, 5, 1, 4])
            4
            >>> print(oset)
            OrderedSet([1, 2, 3, 5, 4])
        """
        item_index = None
        try:
            for item in sequence:
                item_index = self.add(item)
        except TypeError:
            raise ValueError(
                "Argument needs to be an iterable, got %s" % type(sequence)
            )
        return item_index

    def index(self, key):
        """
        Get the index of a given entry, raising an IndexError if it's not
        present.

        `key` can be an iterable of entries that is not a string, in which case
        this returns a list of indices.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.index(2)
            1
        """
        if is_iterable(key):
            return [self.index(subkey) for subkey in key]
        return self.map[key]

    # Provide some compatibility with pd.Index
    get_loc = index
    get_indexer = index

    def pop(self):
        """
        Remove and return the last element from the set.

        Raises KeyError if the set is empty.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.pop()
            3
        """
        if not self.items:
            raise KeyError("Set is empty")

        elem = self.items[-1]
        del self.items[-1]
        del self.map[elem]
        return elem

    def discard(self, key):
        """
        Remove an element.  Do not raise an exception if absent.

        The MutableSet mixin uses this to implement the .remove() method, which
        *does* raise an error when asked to remove a non-existent item.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.discard(2)
            >>> print(oset)
            OrderedSet([1, 3])
            >>> oset.discard(2)
            >>> print(oset)
            OrderedSet([1, 3])
        """
        if key in self:
            i = self.map[key]
            del self.items[i]
            del self.map[key]
            for k, v in self.map.items():
                if v >= i:
                    self.map[k] = v - 1

    def clear(self):
        """
        Remove all items from this OrderedSet.
        """
        del self.items[:]
        self.map.clear()

    def __iter__(self):
        """
        Example:
            >>> list(iter(OrderedSet([1, 2, 3])))
            [1, 2, 3]
        """
        return iter(self.items)

    def __reversed__(self):
        """
        Example:
            >>> list(reversed(OrderedSet([1, 2, 3])))
            [3, 2, 1]
        """
        return reversed(self.items)

    def __repr__(self):
        if not self:
            return "%s()" % (self.__class__.__name__,)
        return "%s(%r)" % (self.__class__.__name__, list(self))

    def __eq__(self, other):
        """
        Returns true if the containers have the same items. If `other` is a
        Sequence, then order is checked, otherwise it is ignored.

        Example:
            >>> oset = OrderedSet([1, 3, 2])
            >>> oset == [1, 3, 2]
            True
            >>> oset == [1, 2, 3]
            False
            >>> oset == [2, 3]
            False
            >>> oset == OrderedSet([3, 2, 1])
            False
        """
        # In Python 2 deque is not a Sequence, so treat it as one for
        # consistent behavior with Python 3.
        if isinstance(other, (Sequence, deque)):
            # Check that this OrderedSet contains the same elements, in the
            # same order, as the other object.
            return list(self) == list(other)
        try:
            other_as_set = set(other)
        except TypeError:
            # If `other` can't be converted into a set, it's not equal.
            return False
        else:
            return set(self) == other_as_set

    def union(self, *sets):
        """
        Combines all unique items.
        Each items order is defined by its first appearance.

        Example:
            >>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0])
            >>> print(oset)
            OrderedSet([3, 1, 4, 5, 2, 0])
            >>> oset.union([8, 9])
            OrderedSet([3, 1, 4, 5, 2, 0, 8, 9])
            >>> oset | {10}
            OrderedSet([3, 1, 4, 5, 2, 0, 10])
        """
        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
        containers = map(list, it.chain([self], sets))
        items = it.chain.from_iterable(containers)
        return cls(items)

    def __and__(self, other):
        # the parent implementation of this is backwards
        return self.intersection(other)

    def intersection(self, *sets):
        """
        Returns elements in common between all sets. Order is defined only
        by the first set.

        Example:
            >>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3])
            >>> print(oset)
            OrderedSet([1, 2, 3])
            >>> oset.intersection([2, 4, 5], [1, 2, 3, 4])
            OrderedSet([2])
            >>> oset.intersection()
            OrderedSet([1, 2, 3])
        """
        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
        if sets:
            common = set.intersection(*map(set, sets))
            items = (item for item in self if item in common)
        else:
            items = self
        return cls(items)

    def difference(self, *sets):
        """
        Returns all elements that are in this set but not the others.

        Example:
            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]))
            OrderedSet([1, 3])
            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3]))
            OrderedSet([1])
            >>> OrderedSet([1, 2, 3]) - OrderedSet([2])
            OrderedSet([1, 3])
            >>> OrderedSet([1, 2, 3]).difference()
            OrderedSet([1, 2, 3])
        """
        cls = self.__class__
        if sets:
            other = set.union(*map(set, sets))
            items = (item for item in self if item not in other)
        else:
            items = self
        return cls(items)

    def issubset(self, other):
        """
        Report whether another set contains this set.

        Example:
            >>> OrderedSet([1, 2, 3]).issubset({1, 2})
            False
            >>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4})
            True
            >>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5})
            False
        """
        if len(self) > len(other):  # Fast check for obvious cases
            return False
        return all(item in other for item in self)

    def issuperset(self, other):
        """
        Report whether this set contains another set.

        Example:
            >>> OrderedSet([1, 2]).issuperset([1, 2, 3])
            False
            >>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3})
            True
            >>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3})
            False
        """
        if len(self) < len(other):  # Fast check for obvious cases
            return False
        return all(item in self for item in other)

    def symmetric_difference(self, other):
        """
        Return the symmetric difference of two OrderedSets as a new set.
        That is, the new set will contain all elements that are in exactly
        one of the sets.

        Their order will be preserved, with elements from `self` preceding
        elements from `other`.

        Example:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.symmetric_difference(other)
            OrderedSet([4, 5, 9, 2])
        """
        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
        diff1 = cls(self).difference(other)
        diff2 = cls(other).difference(self)
        return diff1.union(diff2)

    def _update_items(self, items):
        """
        Replace the 'items' list of this OrderedSet with a new one, updating
        self.map accordingly.
        """
        self.items = items
        self.map = {item: idx for (idx, item) in enumerate(items)}

    def difference_update(self, *sets):
        """
        Update this OrderedSet to remove items from one or more other sets.

        Example:
            >>> this = OrderedSet([1, 2, 3])
            >>> this.difference_update(OrderedSet([2, 4]))
            >>> print(this)
            OrderedSet([1, 3])

            >>> this = OrderedSet([1, 2, 3, 4, 5])
            >>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6]))
            >>> print(this)
            OrderedSet([3, 5])
        """
        items_to_remove = set()
        for other in sets:
            items_to_remove |= set(other)
        self._update_items([item for item in self.items if item not in items_to_remove])

    def intersection_update(self, other):
        """
        Update this OrderedSet to keep only items in another set, preserving
        their order in this set.

        Example:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.intersection_update(other)
            >>> print(this)
            OrderedSet([1, 3, 7])
        """
        other = set(other)
        self._update_items([item for item in self.items if item in other])

    def symmetric_difference_update(self, other):
        """
        Update this OrderedSet to remove items from another set, then
        add items from the other set that were not present in this set.

        Example:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.symmetric_difference_update(other)
            >>> print(this)
            OrderedSet([4, 5, 9, 2])
        """
        items_to_add = [item for item in other if item not in self]
        items_to_remove = set(other)
        self._update_items(
            [item for item in self.items if item not in items_to_remove] + items_to_add
        )
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9386702
setuptools-59.6.0/setuptools/_vendor/packaging/0000755000175100001710000000000000000000000021175 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/__about__.py0000644000175100001710000000122500000000000023455 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

__all__ = [
    "__title__",
    "__summary__",
    "__uri__",
    "__version__",
    "__author__",
    "__email__",
    "__license__",
    "__copyright__",
]

__title__ = "packaging"
__summary__ = "Core utilities for Python packages"
__uri__ = "https://github.com/pypa/packaging"

__version__ = "21.2"

__author__ = "Donald Stufft and individual contributors"
__email__ = "donald@stufft.io"

__license__ = "BSD-2-Clause or Apache-2.0"
__copyright__ = "2014-2019 %s" % __author__
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/__init__.py0000644000175100001710000000076100000000000023312 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

from .__about__ import (
    __author__,
    __copyright__,
    __email__,
    __license__,
    __summary__,
    __title__,
    __uri__,
    __version__,
)

__all__ = [
    "__title__",
    "__summary__",
    "__uri__",
    "__version__",
    "__author__",
    "__email__",
    "__license__",
    "__copyright__",
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/_manylinux.py0000644000175100001710000002634000000000000023737 0ustar00runnerdockerimport collections
import functools
import os
import re
import struct
import sys
import warnings
from typing import IO, Dict, Iterator, NamedTuple, Optional, Tuple


# Python does not provide platform information at sufficient granularity to
# identify the architecture of the running executable in some cases, so we
# determine it dynamically by reading the information from the running
# process. This only applies on Linux, which uses the ELF format.
class _ELFFileHeader:
    # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
    class _InvalidELFFileHeader(ValueError):
        """
        An invalid ELF file header was found.
        """

    ELF_MAGIC_NUMBER = 0x7F454C46
    ELFCLASS32 = 1
    ELFCLASS64 = 2
    ELFDATA2LSB = 1
    ELFDATA2MSB = 2
    EM_386 = 3
    EM_S390 = 22
    EM_ARM = 40
    EM_X86_64 = 62
    EF_ARM_ABIMASK = 0xFF000000
    EF_ARM_ABI_VER5 = 0x05000000
    EF_ARM_ABI_FLOAT_HARD = 0x00000400

    def __init__(self, file: IO[bytes]) -> None:
        def unpack(fmt: str) -> int:
            try:
                data = file.read(struct.calcsize(fmt))
                result: Tuple[int, ...] = struct.unpack(fmt, data)
            except struct.error:
                raise _ELFFileHeader._InvalidELFFileHeader()
            return result[0]

        self.e_ident_magic = unpack(">I")
        if self.e_ident_magic != self.ELF_MAGIC_NUMBER:
            raise _ELFFileHeader._InvalidELFFileHeader()
        self.e_ident_class = unpack("B")
        if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}:
            raise _ELFFileHeader._InvalidELFFileHeader()
        self.e_ident_data = unpack("B")
        if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}:
            raise _ELFFileHeader._InvalidELFFileHeader()
        self.e_ident_version = unpack("B")
        self.e_ident_osabi = unpack("B")
        self.e_ident_abiversion = unpack("B")
        self.e_ident_pad = file.read(7)
        format_h = "H"
        format_i = "I"
        format_q = "Q"
        format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q
        self.e_type = unpack(format_h)
        self.e_machine = unpack(format_h)
        self.e_version = unpack(format_i)
        self.e_entry = unpack(format_p)
        self.e_phoff = unpack(format_p)
        self.e_shoff = unpack(format_p)
        self.e_flags = unpack(format_i)
        self.e_ehsize = unpack(format_h)
        self.e_phentsize = unpack(format_h)
        self.e_phnum = unpack(format_h)
        self.e_shentsize = unpack(format_h)
        self.e_shnum = unpack(format_h)
        self.e_shstrndx = unpack(format_h)


def _get_elf_header() -> Optional[_ELFFileHeader]:
    try:
        with open(sys.executable, "rb") as f:
            elf_header = _ELFFileHeader(f)
    except (OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader):
        return None
    return elf_header


def _is_linux_armhf() -> bool:
    # hard-float ABI can be detected from the ELF header of the running
    # process
    # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf
    elf_header = _get_elf_header()
    if elf_header is None:
        return False
    result = elf_header.e_ident_class == elf_header.ELFCLASS32
    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
    result &= elf_header.e_machine == elf_header.EM_ARM
    result &= (
        elf_header.e_flags & elf_header.EF_ARM_ABIMASK
    ) == elf_header.EF_ARM_ABI_VER5
    result &= (
        elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD
    ) == elf_header.EF_ARM_ABI_FLOAT_HARD
    return result


def _is_linux_i686() -> bool:
    elf_header = _get_elf_header()
    if elf_header is None:
        return False
    result = elf_header.e_ident_class == elf_header.ELFCLASS32
    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
    result &= elf_header.e_machine == elf_header.EM_386
    return result


def _have_compatible_abi(arch: str) -> bool:
    if arch == "armv7l":
        return _is_linux_armhf()
    if arch == "i686":
        return _is_linux_i686()
    return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"}


# If glibc ever changes its major version, we need to know what the last
# minor version was, so we can build the complete list of all versions.
# For now, guess what the highest minor version might be, assume it will
# be 50 for testing. Once this actually happens, update the dictionary
# with the actual value.
_LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50)


class _GLibCVersion(NamedTuple):
    major: int
    minor: int


def _glibc_version_string_confstr() -> Optional[str]:
    """
    Primary implementation of glibc_version_string using os.confstr.
    """
    # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
    # to be broken or missing. This strategy is used in the standard library
    # platform module.
    # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183
    try:
        # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17".
        version_string = os.confstr("CS_GNU_LIBC_VERSION")
        assert version_string is not None
        _, version = version_string.split()
    except (AssertionError, AttributeError, OSError, ValueError):
        # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
        return None
    return version


def _glibc_version_string_ctypes() -> Optional[str]:
    """
    Fallback implementation of glibc_version_string using ctypes.
    """
    try:
        import ctypes
    except ImportError:
        return None

    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
    # manpage says, "If filename is NULL, then the returned handle is for the
    # main program". This way we can let the linker do the work to figure out
    # which libc our process is actually using.
    #
    # We must also handle the special case where the executable is not a
    # dynamically linked executable. This can occur when using musl libc,
    # for example. In this situation, dlopen() will error, leading to an
    # OSError. Interestingly, at least in the case of musl, there is no
    # errno set on the OSError. The single string argument used to construct
    # OSError comes from libc itself and is therefore not portable to
    # hard code here. In any case, failure to call dlopen() means we
    # can proceed, so we bail on our attempt.
    try:
        process_namespace = ctypes.CDLL(None)
    except OSError:
        return None

    try:
        gnu_get_libc_version = process_namespace.gnu_get_libc_version
    except AttributeError:
        # Symbol doesn't exist -> therefore, we are not linked to
        # glibc.
        return None

    # Call gnu_get_libc_version, which returns a string like "2.5"
    gnu_get_libc_version.restype = ctypes.c_char_p
    version_str: str = gnu_get_libc_version()
    # py2 / py3 compatibility:
    if not isinstance(version_str, str):
        version_str = version_str.decode("ascii")

    return version_str


def _glibc_version_string() -> Optional[str]:
    """Returns glibc version string, or None if not using glibc."""
    return _glibc_version_string_confstr() or _glibc_version_string_ctypes()


def _parse_glibc_version(version_str: str) -> Tuple[int, int]:
    """Parse glibc version.

    We use a regexp instead of str.split because we want to discard any
    random junk that might come after the minor version -- this might happen
    in patched/forked versions of glibc (e.g. Linaro's version of glibc
    uses version strings like "2.20-2014.11"). See gh-3588.
    """
    m = re.match(r"(?P[0-9]+)\.(?P[0-9]+)", version_str)
    if not m:
        warnings.warn(
            "Expected glibc version with 2 components major.minor,"
            " got: %s" % version_str,
            RuntimeWarning,
        )
        return -1, -1
    return int(m.group("major")), int(m.group("minor"))


@functools.lru_cache()
def _get_glibc_version() -> Tuple[int, int]:
    version_str = _glibc_version_string()
    if version_str is None:
        return (-1, -1)
    return _parse_glibc_version(version_str)


# From PEP 513, PEP 600
def _is_compatible(name: str, arch: str, version: _GLibCVersion) -> bool:
    sys_glibc = _get_glibc_version()
    if sys_glibc < version:
        return False
    # Check for presence of _manylinux module.
    try:
        import _manylinux  # noqa
    except ImportError:
        return True
    if hasattr(_manylinux, "manylinux_compatible"):
        result = _manylinux.manylinux_compatible(version[0], version[1], arch)
        if result is not None:
            return bool(result)
        return True
    if version == _GLibCVersion(2, 5):
        if hasattr(_manylinux, "manylinux1_compatible"):
            return bool(_manylinux.manylinux1_compatible)
    if version == _GLibCVersion(2, 12):
        if hasattr(_manylinux, "manylinux2010_compatible"):
            return bool(_manylinux.manylinux2010_compatible)
    if version == _GLibCVersion(2, 17):
        if hasattr(_manylinux, "manylinux2014_compatible"):
            return bool(_manylinux.manylinux2014_compatible)
    return True


_LEGACY_MANYLINUX_MAP = {
    # CentOS 7 w/ glibc 2.17 (PEP 599)
    (2, 17): "manylinux2014",
    # CentOS 6 w/ glibc 2.12 (PEP 571)
    (2, 12): "manylinux2010",
    # CentOS 5 w/ glibc 2.5 (PEP 513)
    (2, 5): "manylinux1",
}


def platform_tags(linux: str, arch: str) -> Iterator[str]:
    if not _have_compatible_abi(arch):
        return
    # Oldest glibc to be supported regardless of architecture is (2, 17).
    too_old_glibc2 = _GLibCVersion(2, 16)
    if arch in {"x86_64", "i686"}:
        # On x86/i686 also oldest glibc to be supported is (2, 5).
        too_old_glibc2 = _GLibCVersion(2, 4)
    current_glibc = _GLibCVersion(*_get_glibc_version())
    glibc_max_list = [current_glibc]
    # We can assume compatibility across glibc major versions.
    # https://sourceware.org/bugzilla/show_bug.cgi?id=24636
    #
    # Build a list of maximum glibc versions so that we can
    # output the canonical list of all glibc from current_glibc
    # down to too_old_glibc2, including all intermediary versions.
    for glibc_major in range(current_glibc.major - 1, 1, -1):
        glibc_minor = _LAST_GLIBC_MINOR[glibc_major]
        glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor))
    for glibc_max in glibc_max_list:
        if glibc_max.major == too_old_glibc2.major:
            min_minor = too_old_glibc2.minor
        else:
            # For other glibc major versions oldest supported is (x, 0).
            min_minor = -1
        for glibc_minor in range(glibc_max.minor, min_minor, -1):
            glibc_version = _GLibCVersion(glibc_max.major, glibc_minor)
            tag = "manylinux_{}_{}".format(*glibc_version)
            if _is_compatible(tag, arch, glibc_version):
                yield linux.replace("linux", tag)
            # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags.
            if glibc_version in _LEGACY_MANYLINUX_MAP:
                legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version]
                if _is_compatible(legacy_tag, arch, glibc_version):
                    yield linux.replace("linux", legacy_tag)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/_musllinux.py0000644000175100001710000001043200000000000023746 0ustar00runnerdocker"""PEP 656 support.

This module implements logic to detect if the currently running Python is
linked against musl, and what musl version is used.
"""

import contextlib
import functools
import operator
import os
import re
import struct
import subprocess
import sys
from typing import IO, Iterator, NamedTuple, Optional, Tuple


def _read_unpacked(f: IO[bytes], fmt: str) -> Tuple[int, ...]:
    return struct.unpack(fmt, f.read(struct.calcsize(fmt)))


def _parse_ld_musl_from_elf(f: IO[bytes]) -> Optional[str]:
    """Detect musl libc location by parsing the Python executable.

    Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca
    ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
    """
    f.seek(0)
    try:
        ident = _read_unpacked(f, "16B")
    except struct.error:
        return None
    if ident[:4] != tuple(b"\x7fELF"):  # Invalid magic, not ELF.
        return None
    f.seek(struct.calcsize("HHI"), 1)  # Skip file type, machine, and version.

    try:
        # e_fmt: Format for program header.
        # p_fmt: Format for section header.
        # p_idx: Indexes to find p_type, p_offset, and p_filesz.
        e_fmt, p_fmt, p_idx = {
            1: ("IIIIHHH", "IIIIIIII", (0, 1, 4)),  # 32-bit.
            2: ("QQQIHHH", "IIQQQQQQ", (0, 2, 5)),  # 64-bit.
        }[ident[4]]
    except KeyError:
        return None
    else:
        p_get = operator.itemgetter(*p_idx)

    # Find the interpreter section and return its content.
    try:
        _, e_phoff, _, _, _, e_phentsize, e_phnum = _read_unpacked(f, e_fmt)
    except struct.error:
        return None
    for i in range(e_phnum + 1):
        f.seek(e_phoff + e_phentsize * i)
        try:
            p_type, p_offset, p_filesz = p_get(_read_unpacked(f, p_fmt))
        except struct.error:
            return None
        if p_type != 3:  # Not PT_INTERP.
            continue
        f.seek(p_offset)
        interpreter = os.fsdecode(f.read(p_filesz)).strip("\0")
        if "musl" not in interpreter:
            return None
        return interpreter
    return None


class _MuslVersion(NamedTuple):
    major: int
    minor: int


def _parse_musl_version(output: str) -> Optional[_MuslVersion]:
    lines = [n for n in (n.strip() for n in output.splitlines()) if n]
    if len(lines) < 2 or lines[0][:4] != "musl":
        return None
    m = re.match(r"Version (\d+)\.(\d+)", lines[1])
    if not m:
        return None
    return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2)))


@functools.lru_cache()
def _get_musl_version(executable: str) -> Optional[_MuslVersion]:
    """Detect currently-running musl runtime version.

    This is done by checking the specified executable's dynamic linking
    information, and invoking the loader to parse its output for a version
    string. If the loader is musl, the output would be something like::

        musl libc (x86_64)
        Version 1.2.2
        Dynamic Program Loader
    """
    with contextlib.ExitStack() as stack:
        try:
            f = stack.enter_context(open(executable, "rb"))
        except IOError:
            return None
        ld = _parse_ld_musl_from_elf(f)
    if not ld:
        return None
    proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True)
    return _parse_musl_version(proc.stderr)


def platform_tags(arch: str) -> Iterator[str]:
    """Generate musllinux tags compatible to the current platform.

    :param arch: Should be the part of platform tag after the ``linux_``
        prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a
        prerequisite for the current platform to be musllinux-compatible.

    :returns: An iterator of compatible musllinux tags.
    """
    sys_musl = _get_musl_version(sys.executable)
    if sys_musl is None:  # Python not dynamically linked against musl.
        return
    for minor in range(sys_musl.minor, -1, -1):
        yield f"musllinux_{sys_musl.major}_{minor}_{arch}"


if __name__ == "__main__":  # pragma: no cover
    import sysconfig

    plat = sysconfig.get_platform()
    assert plat.startswith("linux-"), "not linux"

    print("plat:", plat)
    print("musl:", _get_musl_version(sys.executable))
    print("tags:", end=" ")
    for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])):
        print(t, end="\n      ")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/_structures.py0000644000175100001710000000313500000000000024133 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.


class InfinityType:
    def __repr__(self) -> str:
        return "Infinity"

    def __hash__(self) -> int:
        return hash(repr(self))

    def __lt__(self, other: object) -> bool:
        return False

    def __le__(self, other: object) -> bool:
        return False

    def __eq__(self, other: object) -> bool:
        return isinstance(other, self.__class__)

    def __ne__(self, other: object) -> bool:
        return not isinstance(other, self.__class__)

    def __gt__(self, other: object) -> bool:
        return True

    def __ge__(self, other: object) -> bool:
        return True

    def __neg__(self: object) -> "NegativeInfinityType":
        return NegativeInfinity


Infinity = InfinityType()


class NegativeInfinityType:
    def __repr__(self) -> str:
        return "-Infinity"

    def __hash__(self) -> int:
        return hash(repr(self))

    def __lt__(self, other: object) -> bool:
        return True

    def __le__(self, other: object) -> bool:
        return True

    def __eq__(self, other: object) -> bool:
        return isinstance(other, self.__class__)

    def __ne__(self, other: object) -> bool:
        return not isinstance(other, self.__class__)

    def __gt__(self, other: object) -> bool:
        return False

    def __ge__(self, other: object) -> bool:
        return False

    def __neg__(self: object) -> InfinityType:
        return Infinity


NegativeInfinity = NegativeInfinityType()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/markers.py0000644000175100001710000002045500000000000023221 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import operator
import os
import platform
import sys
from typing import Any, Callable, Dict, List, Optional, Tuple, Union

from setuptools.extern.pyparsing import (  # noqa: N817
    Forward,
    Group,
    Literal as L,
    ParseException,
    ParseResults,
    QuotedString,
    ZeroOrMore,
    stringEnd,
    stringStart,
)

from .specifiers import InvalidSpecifier, Specifier

__all__ = [
    "InvalidMarker",
    "UndefinedComparison",
    "UndefinedEnvironmentName",
    "Marker",
    "default_environment",
]

Operator = Callable[[str, str], bool]


class InvalidMarker(ValueError):
    """
    An invalid marker was found, users should refer to PEP 508.
    """


class UndefinedComparison(ValueError):
    """
    An invalid operation was attempted on a value that doesn't support it.
    """


class UndefinedEnvironmentName(ValueError):
    """
    A name was attempted to be used that does not exist inside of the
    environment.
    """


class Node:
    def __init__(self, value: Any) -> None:
        self.value = value

    def __str__(self) -> str:
        return str(self.value)

    def __repr__(self) -> str:
        return f"<{self.__class__.__name__}('{self}')>"

    def serialize(self) -> str:
        raise NotImplementedError


class Variable(Node):
    def serialize(self) -> str:
        return str(self)


class Value(Node):
    def serialize(self) -> str:
        return f'"{self}"'


class Op(Node):
    def serialize(self) -> str:
        return str(self)


VARIABLE = (
    L("implementation_version")
    | L("platform_python_implementation")
    | L("implementation_name")
    | L("python_full_version")
    | L("platform_release")
    | L("platform_version")
    | L("platform_machine")
    | L("platform_system")
    | L("python_version")
    | L("sys_platform")
    | L("os_name")
    | L("os.name")  # PEP-345
    | L("sys.platform")  # PEP-345
    | L("platform.version")  # PEP-345
    | L("platform.machine")  # PEP-345
    | L("platform.python_implementation")  # PEP-345
    | L("python_implementation")  # undocumented setuptools legacy
    | L("extra")  # PEP-508
)
ALIASES = {
    "os.name": "os_name",
    "sys.platform": "sys_platform",
    "platform.version": "platform_version",
    "platform.machine": "platform_machine",
    "platform.python_implementation": "platform_python_implementation",
    "python_implementation": "platform_python_implementation",
}
VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))

VERSION_CMP = (
    L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
)

MARKER_OP = VERSION_CMP | L("not in") | L("in")
MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))

MARKER_VALUE = QuotedString("'") | QuotedString('"')
MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))

BOOLOP = L("and") | L("or")

MARKER_VAR = VARIABLE | MARKER_VALUE

MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))

LPAREN = L("(").suppress()
RPAREN = L(")").suppress()

MARKER_EXPR = Forward()
MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)

MARKER = stringStart + MARKER_EXPR + stringEnd


def _coerce_parse_result(results: Union[ParseResults, List[Any]]) -> List[Any]:
    if isinstance(results, ParseResults):
        return [_coerce_parse_result(i) for i in results]
    else:
        return results


def _format_marker(
    marker: Union[List[str], Tuple[Node, ...], str], first: Optional[bool] = True
) -> str:

    assert isinstance(marker, (list, tuple, str))

    # Sometimes we have a structure like [[...]] which is a single item list
    # where the single item is itself it's own list. In that case we want skip
    # the rest of this function so that we don't get extraneous () on the
    # outside.
    if (
        isinstance(marker, list)
        and len(marker) == 1
        and isinstance(marker[0], (list, tuple))
    ):
        return _format_marker(marker[0])

    if isinstance(marker, list):
        inner = (_format_marker(m, first=False) for m in marker)
        if first:
            return " ".join(inner)
        else:
            return "(" + " ".join(inner) + ")"
    elif isinstance(marker, tuple):
        return " ".join([m.serialize() for m in marker])
    else:
        return marker


_operators: Dict[str, Operator] = {
    "in": lambda lhs, rhs: lhs in rhs,
    "not in": lambda lhs, rhs: lhs not in rhs,
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    "!=": operator.ne,
    ">=": operator.ge,
    ">": operator.gt,
}


def _eval_op(lhs: str, op: Op, rhs: str) -> bool:
    try:
        spec = Specifier("".join([op.serialize(), rhs]))
    except InvalidSpecifier:
        pass
    else:
        return spec.contains(lhs)

    oper: Optional[Operator] = _operators.get(op.serialize())
    if oper is None:
        raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.")

    return oper(lhs, rhs)


class Undefined:
    pass


_undefined = Undefined()


def _get_env(environment: Dict[str, str], name: str) -> str:
    value: Union[str, Undefined] = environment.get(name, _undefined)

    if isinstance(value, Undefined):
        raise UndefinedEnvironmentName(
            f"{name!r} does not exist in evaluation environment."
        )

    return value


def _evaluate_markers(markers: List[Any], environment: Dict[str, str]) -> bool:
    groups: List[List[bool]] = [[]]

    for marker in markers:
        assert isinstance(marker, (list, tuple, str))

        if isinstance(marker, list):
            groups[-1].append(_evaluate_markers(marker, environment))
        elif isinstance(marker, tuple):
            lhs, op, rhs = marker

            if isinstance(lhs, Variable):
                lhs_value = _get_env(environment, lhs.value)
                rhs_value = rhs.value
            else:
                lhs_value = lhs.value
                rhs_value = _get_env(environment, rhs.value)

            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
        else:
            assert marker in ["and", "or"]
            if marker == "or":
                groups.append([])

    return any(all(item) for item in groups)


def format_full_version(info: "sys._version_info") -> str:
    version = "{0.major}.{0.minor}.{0.micro}".format(info)
    kind = info.releaselevel
    if kind != "final":
        version += kind[0] + str(info.serial)
    return version


def default_environment() -> Dict[str, str]:
    iver = format_full_version(sys.implementation.version)
    implementation_name = sys.implementation.name
    return {
        "implementation_name": implementation_name,
        "implementation_version": iver,
        "os_name": os.name,
        "platform_machine": platform.machine(),
        "platform_release": platform.release(),
        "platform_system": platform.system(),
        "platform_version": platform.version(),
        "python_full_version": platform.python_version(),
        "platform_python_implementation": platform.python_implementation(),
        "python_version": ".".join(platform.python_version_tuple()[:2]),
        "sys_platform": sys.platform,
    }


class Marker:
    def __init__(self, marker: str) -> None:
        try:
            self._markers = _coerce_parse_result(MARKER.parseString(marker))
        except ParseException as e:
            raise InvalidMarker(
                f"Invalid marker: {marker!r}, parse error at "
                f"{marker[e.loc : e.loc + 8]!r}"
            )

    def __str__(self) -> str:
        return _format_marker(self._markers)

    def __repr__(self) -> str:
        return f""

    def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool:
        """Evaluate a marker.

        Return the boolean from evaluating the given marker against the
        environment. environment is an optional argument to override all or
        part of the determined environment.

        The environment is determined from the current Python process.
        """
        current_environment = default_environment()
        if environment is not None:
            current_environment.update(environment)

        return _evaluate_markers(self._markers, current_environment)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/requirements.py0000644000175100001710000001113400000000000024272 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import re
import string
import urllib.parse
from typing import List, Optional as TOptional, Set

from setuptools.extern.pyparsing import (  # noqa
    Combine,
    Literal as L,
    Optional,
    ParseException,
    Regex,
    Word,
    ZeroOrMore,
    originalTextFor,
    stringEnd,
    stringStart,
)

from .markers import MARKER_EXPR, Marker
from .specifiers import LegacySpecifier, Specifier, SpecifierSet


class InvalidRequirement(ValueError):
    """
    An invalid requirement was found, users should refer to PEP 508.
    """


ALPHANUM = Word(string.ascii_letters + string.digits)

LBRACKET = L("[").suppress()
RBRACKET = L("]").suppress()
LPAREN = L("(").suppress()
RPAREN = L(")").suppress()
COMMA = L(",").suppress()
SEMICOLON = L(";").suppress()
AT = L("@").suppress()

PUNCTUATION = Word("-_.")
IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))

NAME = IDENTIFIER("name")
EXTRA = IDENTIFIER

URI = Regex(r"[^ ]+")("url")
URL = AT + URI

EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")

VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)

VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
VERSION_MANY = Combine(
    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
)("_raw_spec")
_VERSION_SPEC = Optional((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY)
_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")

VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
VERSION_SPEC.setParseAction(lambda s, l, t: t[1])

MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
MARKER_EXPR.setParseAction(
    lambda s, l, t: Marker(s[t._original_start : t._original_end])
)
MARKER_SEPARATOR = SEMICOLON
MARKER = MARKER_SEPARATOR + MARKER_EXPR

VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
URL_AND_MARKER = URL + Optional(MARKER)

NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)

REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
# setuptools.extern.pyparsing isn't thread safe during initialization, so we do it eagerly, see
# issue #104
REQUIREMENT.parseString("x[]")


class Requirement:
    """Parse a requirement.

    Parse a given requirement string into its parts, such as name, specifier,
    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
    string.
    """

    # TODO: Can we test whether something is contained within a requirement?
    #       If so how do we do that? Do we need to test against the _name_ of
    #       the thing as well as the version? What about the markers?
    # TODO: Can we normalize the name and extra name?

    def __init__(self, requirement_string: str) -> None:
        try:
            req = REQUIREMENT.parseString(requirement_string)
        except ParseException as e:
            raise InvalidRequirement(
                f'Parse error at "{ requirement_string[e.loc : e.loc + 8]!r}": {e.msg}'
            )

        self.name: str = req.name
        if req.url:
            parsed_url = urllib.parse.urlparse(req.url)
            if parsed_url.scheme == "file":
                if urllib.parse.urlunparse(parsed_url) != req.url:
                    raise InvalidRequirement("Invalid URL given")
            elif not (parsed_url.scheme and parsed_url.netloc) or (
                not parsed_url.scheme and not parsed_url.netloc
            ):
                raise InvalidRequirement(f"Invalid URL: {req.url}")
            self.url: TOptional[str] = req.url
        else:
            self.url = None
        self.extras: Set[str] = set(req.extras.asList() if req.extras else [])
        self.specifier: SpecifierSet = SpecifierSet(req.specifier)
        self.marker: TOptional[Marker] = req.marker if req.marker else None

    def __str__(self) -> str:
        parts: List[str] = [self.name]

        if self.extras:
            formatted_extras = ",".join(sorted(self.extras))
            parts.append(f"[{formatted_extras}]")

        if self.specifier:
            parts.append(str(self.specifier))

        if self.url:
            parts.append(f"@ {self.url}")
            if self.marker:
                parts.append(" ")

        if self.marker:
            parts.append(f"; {self.marker}")

        return "".join(parts)

    def __repr__(self) -> str:
        return f""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/specifiers.py0000644000175100001710000007436400000000000023721 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import abc
import functools
import itertools
import re
import warnings
from typing import (
    Callable,
    Dict,
    Iterable,
    Iterator,
    List,
    Optional,
    Pattern,
    Set,
    Tuple,
    TypeVar,
    Union,
)

from .utils import canonicalize_version
from .version import LegacyVersion, Version, parse

ParsedVersion = Union[Version, LegacyVersion]
UnparsedVersion = Union[Version, LegacyVersion, str]
VersionTypeVar = TypeVar("VersionTypeVar", bound=UnparsedVersion)
CallableOperator = Callable[[ParsedVersion, str], bool]


class InvalidSpecifier(ValueError):
    """
    An invalid specifier was found, users should refer to PEP 440.
    """


class BaseSpecifier(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def __str__(self) -> str:
        """
        Returns the str representation of this Specifier like object. This
        should be representative of the Specifier itself.
        """

    @abc.abstractmethod
    def __hash__(self) -> int:
        """
        Returns a hash value for this Specifier like object.
        """

    @abc.abstractmethod
    def __eq__(self, other: object) -> bool:
        """
        Returns a boolean representing whether or not the two Specifier like
        objects are equal.
        """

    @abc.abstractmethod
    def __ne__(self, other: object) -> bool:
        """
        Returns a boolean representing whether or not the two Specifier like
        objects are not equal.
        """

    @abc.abstractproperty
    def prereleases(self) -> Optional[bool]:
        """
        Returns whether or not pre-releases as a whole are allowed by this
        specifier.
        """

    @prereleases.setter
    def prereleases(self, value: bool) -> None:
        """
        Sets whether or not pre-releases as a whole are allowed by this
        specifier.
        """

    @abc.abstractmethod
    def contains(self, item: str, prereleases: Optional[bool] = None) -> bool:
        """
        Determines if the given item is contained within this specifier.
        """

    @abc.abstractmethod
    def filter(
        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
    ) -> Iterable[VersionTypeVar]:
        """
        Takes an iterable of items and filters them so that only items which
        are contained within this specifier are allowed in it.
        """


class _IndividualSpecifier(BaseSpecifier):

    _operators: Dict[str, str] = {}
    _regex: Pattern[str]

    def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
        match = self._regex.search(spec)
        if not match:
            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")

        self._spec: Tuple[str, str] = (
            match.group("operator").strip(),
            match.group("version").strip(),
        )

        # Store whether or not this Specifier should accept prereleases
        self._prereleases = prereleases

    def __repr__(self) -> str:
        pre = (
            f", prereleases={self.prereleases!r}"
            if self._prereleases is not None
            else ""
        )

        return "<{}({!r}{})>".format(self.__class__.__name__, str(self), pre)

    def __str__(self) -> str:
        return "{}{}".format(*self._spec)

    @property
    def _canonical_spec(self) -> Tuple[str, str]:
        return self._spec[0], canonicalize_version(self._spec[1])

    def __hash__(self) -> int:
        return hash(self._canonical_spec)

    def __eq__(self, other: object) -> bool:
        if isinstance(other, str):
            try:
                other = self.__class__(str(other))
            except InvalidSpecifier:
                return NotImplemented
        elif not isinstance(other, self.__class__):
            return NotImplemented

        return self._canonical_spec == other._canonical_spec

    def __ne__(self, other: object) -> bool:
        if isinstance(other, str):
            try:
                other = self.__class__(str(other))
            except InvalidSpecifier:
                return NotImplemented
        elif not isinstance(other, self.__class__):
            return NotImplemented

        return self._spec != other._spec

    def _get_operator(self, op: str) -> CallableOperator:
        operator_callable: CallableOperator = getattr(
            self, f"_compare_{self._operators[op]}"
        )
        return operator_callable

    def _coerce_version(self, version: UnparsedVersion) -> ParsedVersion:
        if not isinstance(version, (LegacyVersion, Version)):
            version = parse(version)
        return version

    @property
    def operator(self) -> str:
        return self._spec[0]

    @property
    def version(self) -> str:
        return self._spec[1]

    @property
    def prereleases(self) -> Optional[bool]:
        return self._prereleases

    @prereleases.setter
    def prereleases(self, value: bool) -> None:
        self._prereleases = value

    def __contains__(self, item: str) -> bool:
        return self.contains(item)

    def contains(
        self, item: UnparsedVersion, prereleases: Optional[bool] = None
    ) -> bool:

        # Determine if prereleases are to be allowed or not.
        if prereleases is None:
            prereleases = self.prereleases

        # Normalize item to a Version or LegacyVersion, this allows us to have
        # a shortcut for ``"2.0" in Specifier(">=2")
        normalized_item = self._coerce_version(item)

        # Determine if we should be supporting prereleases in this specifier
        # or not, if we do not support prereleases than we can short circuit
        # logic if this version is a prereleases.
        if normalized_item.is_prerelease and not prereleases:
            return False

        # Actually do the comparison to determine if this item is contained
        # within this Specifier or not.
        operator_callable: CallableOperator = self._get_operator(self.operator)
        return operator_callable(normalized_item, self.version)

    def filter(
        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
    ) -> Iterable[VersionTypeVar]:

        yielded = False
        found_prereleases = []

        kw = {"prereleases": prereleases if prereleases is not None else True}

        # Attempt to iterate over all the values in the iterable and if any of
        # them match, yield them.
        for version in iterable:
            parsed_version = self._coerce_version(version)

            if self.contains(parsed_version, **kw):
                # If our version is a prerelease, and we were not set to allow
                # prereleases, then we'll store it for later in case nothing
                # else matches this specifier.
                if parsed_version.is_prerelease and not (
                    prereleases or self.prereleases
                ):
                    found_prereleases.append(version)
                # Either this is not a prerelease, or we should have been
                # accepting prereleases from the beginning.
                else:
                    yielded = True
                    yield version

        # Now that we've iterated over everything, determine if we've yielded
        # any values, and if we have not and we have any prereleases stored up
        # then we will go ahead and yield the prereleases.
        if not yielded and found_prereleases:
            for version in found_prereleases:
                yield version


class LegacySpecifier(_IndividualSpecifier):

    _regex_str = r"""
        (?P(==|!=|<=|>=|<|>))
        \s*
        (?P
            [^,;\s)]* # Since this is a "legacy" specifier, and the version
                      # string can be just about anything, we match everything
                      # except for whitespace, a semi-colon for marker support,
                      # a closing paren since versions can be enclosed in
                      # them, and a comma since it's a version separator.
        )
        """

    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)

    _operators = {
        "==": "equal",
        "!=": "not_equal",
        "<=": "less_than_equal",
        ">=": "greater_than_equal",
        "<": "less_than",
        ">": "greater_than",
    }

    def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
        super().__init__(spec, prereleases)

        warnings.warn(
            "Creating a LegacyVersion has been deprecated and will be "
            "removed in the next major release",
            DeprecationWarning,
        )

    def _coerce_version(self, version: UnparsedVersion) -> LegacyVersion:
        if not isinstance(version, LegacyVersion):
            version = LegacyVersion(str(version))
        return version

    def _compare_equal(self, prospective: LegacyVersion, spec: str) -> bool:
        return prospective == self._coerce_version(spec)

    def _compare_not_equal(self, prospective: LegacyVersion, spec: str) -> bool:
        return prospective != self._coerce_version(spec)

    def _compare_less_than_equal(self, prospective: LegacyVersion, spec: str) -> bool:
        return prospective <= self._coerce_version(spec)

    def _compare_greater_than_equal(
        self, prospective: LegacyVersion, spec: str
    ) -> bool:
        return prospective >= self._coerce_version(spec)

    def _compare_less_than(self, prospective: LegacyVersion, spec: str) -> bool:
        return prospective < self._coerce_version(spec)

    def _compare_greater_than(self, prospective: LegacyVersion, spec: str) -> bool:
        return prospective > self._coerce_version(spec)


def _require_version_compare(
    fn: Callable[["Specifier", ParsedVersion, str], bool]
) -> Callable[["Specifier", ParsedVersion, str], bool]:
    @functools.wraps(fn)
    def wrapped(self: "Specifier", prospective: ParsedVersion, spec: str) -> bool:
        if not isinstance(prospective, Version):
            return False
        return fn(self, prospective, spec)

    return wrapped


class Specifier(_IndividualSpecifier):

    _regex_str = r"""
        (?P(~=|==|!=|<=|>=|<|>|===))
        (?P
            (?:
                # The identity operators allow for an escape hatch that will
                # do an exact string match of the version you wish to install.
                # This will not be parsed by PEP 440 and we cannot determine
                # any semantic meaning from it. This operator is discouraged
                # but included entirely as an escape hatch.
                (?<====)  # Only match for the identity operator
                \s*
                [^\s]*    # We just match everything, except for whitespace
                          # since we are only testing for strict identity.
            )
            |
            (?:
                # The (non)equality operators allow for wild card and local
                # versions to be specified so we have to define these two
                # operators separately to enable that.
                (?<===|!=)            # Only match for equals and not equals

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)*   # release
                (?:                   # pre release
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?

                # You cannot use a wild card and a dev or local version
                # together so group them with a | and make them optional.
                (?:
                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
                    |
                    \.\*  # Wild card syntax of .*
                )?
            )
            |
            (?:
                # The compatible operator requires at least two digits in the
                # release segment.
                (?<=~=)               # Only match for the compatible operator

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
                (?:                   # pre release
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?
                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
            )
            |
            (?:
                # All other operators only allow a sub set of what the
                # (non)equality operators do. Specifically they do not allow
                # local versions to be specified nor do they allow the prefix
                # matching wild cards.
                (?=": "greater_than_equal",
        "<": "less_than",
        ">": "greater_than",
        "===": "arbitrary",
    }

    @_require_version_compare
    def _compare_compatible(self, prospective: ParsedVersion, spec: str) -> bool:

        # Compatible releases have an equivalent combination of >= and ==. That
        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
        # implement this in terms of the other specifiers instead of
        # implementing it ourselves. The only thing we need to do is construct
        # the other specifiers.

        # We want everything but the last item in the version, but we want to
        # ignore suffix segments.
        prefix = ".".join(
            list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1]
        )

        # Add the prefix notation to the end of our string
        prefix += ".*"

        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
            prospective, prefix
        )

    @_require_version_compare
    def _compare_equal(self, prospective: ParsedVersion, spec: str) -> bool:

        # We need special logic to handle prefix matching
        if spec.endswith(".*"):
            # In the case of prefix matching we want to ignore local segment.
            prospective = Version(prospective.public)
            # Split the spec out by dots, and pretend that there is an implicit
            # dot in between a release segment and a pre-release segment.
            split_spec = _version_split(spec[:-2])  # Remove the trailing .*

            # Split the prospective version out by dots, and pretend that there
            # is an implicit dot in between a release segment and a pre-release
            # segment.
            split_prospective = _version_split(str(prospective))

            # Shorten the prospective version to be the same length as the spec
            # so that we can determine if the specifier is a prefix of the
            # prospective version or not.
            shortened_prospective = split_prospective[: len(split_spec)]

            # Pad out our two sides with zeros so that they both equal the same
            # length.
            padded_spec, padded_prospective = _pad_version(
                split_spec, shortened_prospective
            )

            return padded_prospective == padded_spec
        else:
            # Convert our spec string into a Version
            spec_version = Version(spec)

            # If the specifier does not have a local segment, then we want to
            # act as if the prospective version also does not have a local
            # segment.
            if not spec_version.local:
                prospective = Version(prospective.public)

            return prospective == spec_version

    @_require_version_compare
    def _compare_not_equal(self, prospective: ParsedVersion, spec: str) -> bool:
        return not self._compare_equal(prospective, spec)

    @_require_version_compare
    def _compare_less_than_equal(self, prospective: ParsedVersion, spec: str) -> bool:

        # NB: Local version identifiers are NOT permitted in the version
        # specifier, so local version labels can be universally removed from
        # the prospective version.
        return Version(prospective.public) <= Version(spec)

    @_require_version_compare
    def _compare_greater_than_equal(
        self, prospective: ParsedVersion, spec: str
    ) -> bool:

        # NB: Local version identifiers are NOT permitted in the version
        # specifier, so local version labels can be universally removed from
        # the prospective version.
        return Version(prospective.public) >= Version(spec)

    @_require_version_compare
    def _compare_less_than(self, prospective: ParsedVersion, spec_str: str) -> bool:

        # Convert our spec to a Version instance, since we'll want to work with
        # it as a version.
        spec = Version(spec_str)

        # Check to see if the prospective version is less than the spec
        # version. If it's not we can short circuit and just return False now
        # instead of doing extra unneeded work.
        if not prospective < spec:
            return False

        # This special case is here so that, unless the specifier itself
        # includes is a pre-release version, that we do not accept pre-release
        # versions for the version mentioned in the specifier (e.g. <3.1 should
        # not match 3.1.dev0, but should match 3.0.dev0).
        if not spec.is_prerelease and prospective.is_prerelease:
            if Version(prospective.base_version) == Version(spec.base_version):
                return False

        # If we've gotten to here, it means that prospective version is both
        # less than the spec version *and* it's not a pre-release of the same
        # version in the spec.
        return True

    @_require_version_compare
    def _compare_greater_than(self, prospective: ParsedVersion, spec_str: str) -> bool:

        # Convert our spec to a Version instance, since we'll want to work with
        # it as a version.
        spec = Version(spec_str)

        # Check to see if the prospective version is greater than the spec
        # version. If it's not we can short circuit and just return False now
        # instead of doing extra unneeded work.
        if not prospective > spec:
            return False

        # This special case is here so that, unless the specifier itself
        # includes is a post-release version, that we do not accept
        # post-release versions for the version mentioned in the specifier
        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
        if not spec.is_postrelease and prospective.is_postrelease:
            if Version(prospective.base_version) == Version(spec.base_version):
                return False

        # Ensure that we do not allow a local version of the version mentioned
        # in the specifier, which is technically greater than, to match.
        if prospective.local is not None:
            if Version(prospective.base_version) == Version(spec.base_version):
                return False

        # If we've gotten to here, it means that prospective version is both
        # greater than the spec version *and* it's not a pre-release of the
        # same version in the spec.
        return True

    def _compare_arbitrary(self, prospective: Version, spec: str) -> bool:
        return str(prospective).lower() == str(spec).lower()

    @property
    def prereleases(self) -> bool:

        # If there is an explicit prereleases set for this, then we'll just
        # blindly use that.
        if self._prereleases is not None:
            return self._prereleases

        # Look at all of our specifiers and determine if they are inclusive
        # operators, and if they are if they are including an explicit
        # prerelease.
        operator, version = self._spec
        if operator in ["==", ">=", "<=", "~=", "==="]:
            # The == specifier can include a trailing .*, if it does we
            # want to remove before parsing.
            if operator == "==" and version.endswith(".*"):
                version = version[:-2]

            # Parse the version, and if it is a pre-release than this
            # specifier allows pre-releases.
            if parse(version).is_prerelease:
                return True

        return False

    @prereleases.setter
    def prereleases(self, value: bool) -> None:
        self._prereleases = value


_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")


def _version_split(version: str) -> List[str]:
    result: List[str] = []
    for item in version.split("."):
        match = _prefix_regex.search(item)
        if match:
            result.extend(match.groups())
        else:
            result.append(item)
    return result


def _is_not_suffix(segment: str) -> bool:
    return not any(
        segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post")
    )


def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]:
    left_split, right_split = [], []

    # Get the release segment of our versions
    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))

    # Get the rest of our versions
    left_split.append(left[len(left_split[0]) :])
    right_split.append(right[len(right_split[0]) :])

    # Insert our padding
    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))

    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))


class SpecifierSet(BaseSpecifier):
    def __init__(
        self, specifiers: str = "", prereleases: Optional[bool] = None
    ) -> None:

        # Split on , to break each individual specifier into it's own item, and
        # strip each item to remove leading/trailing whitespace.
        split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]

        # Parsed each individual specifier, attempting first to make it a
        # Specifier and falling back to a LegacySpecifier.
        parsed: Set[_IndividualSpecifier] = set()
        for specifier in split_specifiers:
            try:
                parsed.add(Specifier(specifier))
            except InvalidSpecifier:
                parsed.add(LegacySpecifier(specifier))

        # Turn our parsed specifiers into a frozen set and save them for later.
        self._specs = frozenset(parsed)

        # Store our prereleases value so we can use it later to determine if
        # we accept prereleases or not.
        self._prereleases = prereleases

    def __repr__(self) -> str:
        pre = (
            f", prereleases={self.prereleases!r}"
            if self._prereleases is not None
            else ""
        )

        return "".format(str(self), pre)

    def __str__(self) -> str:
        return ",".join(sorted(str(s) for s in self._specs))

    def __hash__(self) -> int:
        return hash(self._specs)

    def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet":
        if isinstance(other, str):
            other = SpecifierSet(other)
        elif not isinstance(other, SpecifierSet):
            return NotImplemented

        specifier = SpecifierSet()
        specifier._specs = frozenset(self._specs | other._specs)

        if self._prereleases is None and other._prereleases is not None:
            specifier._prereleases = other._prereleases
        elif self._prereleases is not None and other._prereleases is None:
            specifier._prereleases = self._prereleases
        elif self._prereleases == other._prereleases:
            specifier._prereleases = self._prereleases
        else:
            raise ValueError(
                "Cannot combine SpecifierSets with True and False prerelease "
                "overrides."
            )

        return specifier

    def __eq__(self, other: object) -> bool:
        if isinstance(other, (str, _IndividualSpecifier)):
            other = SpecifierSet(str(other))
        elif not isinstance(other, SpecifierSet):
            return NotImplemented

        return self._specs == other._specs

    def __ne__(self, other: object) -> bool:
        if isinstance(other, (str, _IndividualSpecifier)):
            other = SpecifierSet(str(other))
        elif not isinstance(other, SpecifierSet):
            return NotImplemented

        return self._specs != other._specs

    def __len__(self) -> int:
        return len(self._specs)

    def __iter__(self) -> Iterator[_IndividualSpecifier]:
        return iter(self._specs)

    @property
    def prereleases(self) -> Optional[bool]:

        # If we have been given an explicit prerelease modifier, then we'll
        # pass that through here.
        if self._prereleases is not None:
            return self._prereleases

        # If we don't have any specifiers, and we don't have a forced value,
        # then we'll just return None since we don't know if this should have
        # pre-releases or not.
        if not self._specs:
            return None

        # Otherwise we'll see if any of the given specifiers accept
        # prereleases, if any of them do we'll return True, otherwise False.
        return any(s.prereleases for s in self._specs)

    @prereleases.setter
    def prereleases(self, value: bool) -> None:
        self._prereleases = value

    def __contains__(self, item: UnparsedVersion) -> bool:
        return self.contains(item)

    def contains(
        self, item: UnparsedVersion, prereleases: Optional[bool] = None
    ) -> bool:

        # Ensure that our item is a Version or LegacyVersion instance.
        if not isinstance(item, (LegacyVersion, Version)):
            item = parse(item)

        # Determine if we're forcing a prerelease or not, if we're not forcing
        # one for this particular filter call, then we'll use whatever the
        # SpecifierSet thinks for whether or not we should support prereleases.
        if prereleases is None:
            prereleases = self.prereleases

        # We can determine if we're going to allow pre-releases by looking to
        # see if any of the underlying items supports them. If none of them do
        # and this item is a pre-release then we do not allow it and we can
        # short circuit that here.
        # Note: This means that 1.0.dev1 would not be contained in something
        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
        if not prereleases and item.is_prerelease:
            return False

        # We simply dispatch to the underlying specs here to make sure that the
        # given version is contained within all of them.
        # Note: This use of all() here means that an empty set of specifiers
        #       will always return True, this is an explicit design decision.
        return all(s.contains(item, prereleases=prereleases) for s in self._specs)

    def filter(
        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
    ) -> Iterable[VersionTypeVar]:

        # Determine if we're forcing a prerelease or not, if we're not forcing
        # one for this particular filter call, then we'll use whatever the
        # SpecifierSet thinks for whether or not we should support prereleases.
        if prereleases is None:
            prereleases = self.prereleases

        # If we have any specifiers, then we want to wrap our iterable in the
        # filter method for each one, this will act as a logical AND amongst
        # each specifier.
        if self._specs:
            for spec in self._specs:
                iterable = spec.filter(iterable, prereleases=bool(prereleases))
            return iterable
        # If we do not have any specifiers, then we need to have a rough filter
        # which will filter out any pre-releases, unless there are no final
        # releases, and which will filter out LegacyVersion in general.
        else:
            filtered: List[VersionTypeVar] = []
            found_prereleases: List[VersionTypeVar] = []

            item: UnparsedVersion
            parsed_version: Union[Version, LegacyVersion]

            for item in iterable:
                # Ensure that we some kind of Version class for this item.
                if not isinstance(item, (LegacyVersion, Version)):
                    parsed_version = parse(item)
                else:
                    parsed_version = item

                # Filter out any item which is parsed as a LegacyVersion
                if isinstance(parsed_version, LegacyVersion):
                    continue

                # Store any item which is a pre-release for later unless we've
                # already found a final version or we are accepting prereleases
                if parsed_version.is_prerelease and not prereleases:
                    if not filtered:
                        found_prereleases.append(item)
                else:
                    filtered.append(item)

            # If we've found no items except for pre-releases, then we'll go
            # ahead and use the pre-releases
            if not filtered and found_prereleases and prereleases is None:
                return found_prereleases

            return filtered
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/tags.py0000644000175100001710000003653600000000000022522 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import logging
import platform
import sys
import sysconfig
from importlib.machinery import EXTENSION_SUFFIXES
from typing import (
    Dict,
    FrozenSet,
    Iterable,
    Iterator,
    List,
    Optional,
    Sequence,
    Tuple,
    Union,
    cast,
)

from . import _manylinux, _musllinux

logger = logging.getLogger(__name__)

PythonVersion = Sequence[int]
MacVersion = Tuple[int, int]

INTERPRETER_SHORT_NAMES: Dict[str, str] = {
    "python": "py",  # Generic.
    "cpython": "cp",
    "pypy": "pp",
    "ironpython": "ip",
    "jython": "jy",
}


_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32


class Tag:
    """
    A representation of the tag triple for a wheel.

    Instances are considered immutable and thus are hashable. Equality checking
    is also supported.
    """

    __slots__ = ["_interpreter", "_abi", "_platform", "_hash"]

    def __init__(self, interpreter: str, abi: str, platform: str) -> None:
        self._interpreter = interpreter.lower()
        self._abi = abi.lower()
        self._platform = platform.lower()
        # The __hash__ of every single element in a Set[Tag] will be evaluated each time
        # that a set calls its `.disjoint()` method, which may be called hundreds of
        # times when scanning a page of links for packages with tags matching that
        # Set[Tag]. Pre-computing the value here produces significant speedups for
        # downstream consumers.
        self._hash = hash((self._interpreter, self._abi, self._platform))

    @property
    def interpreter(self) -> str:
        return self._interpreter

    @property
    def abi(self) -> str:
        return self._abi

    @property
    def platform(self) -> str:
        return self._platform

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Tag):
            return NotImplemented

        return (
            (self._hash == other._hash)  # Short-circuit ASAP for perf reasons.
            and (self._platform == other._platform)
            and (self._abi == other._abi)
            and (self._interpreter == other._interpreter)
        )

    def __hash__(self) -> int:
        return self._hash

    def __str__(self) -> str:
        return f"{self._interpreter}-{self._abi}-{self._platform}"

    def __repr__(self) -> str:
        return "<{self} @ {self_id}>".format(self=self, self_id=id(self))


def parse_tag(tag: str) -> FrozenSet[Tag]:
    """
    Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances.

    Returning a set is required due to the possibility that the tag is a
    compressed tag set.
    """
    tags = set()
    interpreters, abis, platforms = tag.split("-")
    for interpreter in interpreters.split("."):
        for abi in abis.split("."):
            for platform_ in platforms.split("."):
                tags.add(Tag(interpreter, abi, platform_))
    return frozenset(tags)


def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]:
    value = sysconfig.get_config_var(name)
    if value is None and warn:
        logger.debug(
            "Config variable '%s' is unset, Python ABI tag may be incorrect", name
        )
    return value


def _normalize_string(string: str) -> str:
    return string.replace(".", "_").replace("-", "_")


def _abi3_applies(python_version: PythonVersion) -> bool:
    """
    Determine if the Python version supports abi3.

    PEP 384 was first implemented in Python 3.2.
    """
    return len(python_version) > 1 and tuple(python_version) >= (3, 2)


def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]:
    py_version = tuple(py_version)  # To allow for version comparison.
    abis = []
    version = _version_nodot(py_version[:2])
    debug = pymalloc = ucs4 = ""
    with_debug = _get_config_var("Py_DEBUG", warn)
    has_refcount = hasattr(sys, "gettotalrefcount")
    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
    # extension modules is the best option.
    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
    if with_debug or (with_debug is None and (has_refcount or has_ext)):
        debug = "d"
    if py_version < (3, 8):
        with_pymalloc = _get_config_var("WITH_PYMALLOC", warn)
        if with_pymalloc or with_pymalloc is None:
            pymalloc = "m"
        if py_version < (3, 3):
            unicode_size = _get_config_var("Py_UNICODE_SIZE", warn)
            if unicode_size == 4 or (
                unicode_size is None and sys.maxunicode == 0x10FFFF
            ):
                ucs4 = "u"
    elif debug:
        # Debug builds can also load "normal" extension modules.
        # We can also assume no UCS-4 or pymalloc requirement.
        abis.append(f"cp{version}")
    abis.insert(
        0,
        "cp{version}{debug}{pymalloc}{ucs4}".format(
            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
        ),
    )
    return abis


def cpython_tags(
    python_version: Optional[PythonVersion] = None,
    abis: Optional[Iterable[str]] = None,
    platforms: Optional[Iterable[str]] = None,
    *,
    warn: bool = False,
) -> Iterator[Tag]:
    """
    Yields the tags for a CPython interpreter.

    The tags consist of:
    - cp--
    - cp-abi3-
    - cp-none-
    - cp-abi3-  # Older Python versions down to 3.2.

    If python_version only specifies a major version then user-provided ABIs and
    the 'none' ABItag will be used.

    If 'abi3' or 'none' are specified in 'abis' then they will be yielded at
    their normal position and not at the beginning.
    """
    if not python_version:
        python_version = sys.version_info[:2]

    interpreter = "cp{}".format(_version_nodot(python_version[:2]))

    if abis is None:
        if len(python_version) > 1:
            abis = _cpython_abis(python_version, warn)
        else:
            abis = []
    abis = list(abis)
    # 'abi3' and 'none' are explicitly handled later.
    for explicit_abi in ("abi3", "none"):
        try:
            abis.remove(explicit_abi)
        except ValueError:
            pass

    platforms = list(platforms or platform_tags())
    for abi in abis:
        for platform_ in platforms:
            yield Tag(interpreter, abi, platform_)
    if _abi3_applies(python_version):
        yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms)
    yield from (Tag(interpreter, "none", platform_) for platform_ in platforms)

    if _abi3_applies(python_version):
        for minor_version in range(python_version[1] - 1, 1, -1):
            for platform_ in platforms:
                interpreter = "cp{version}".format(
                    version=_version_nodot((python_version[0], minor_version))
                )
                yield Tag(interpreter, "abi3", platform_)


def _generic_abi() -> Iterator[str]:
    abi = sysconfig.get_config_var("SOABI")
    if abi:
        yield _normalize_string(abi)


def generic_tags(
    interpreter: Optional[str] = None,
    abis: Optional[Iterable[str]] = None,
    platforms: Optional[Iterable[str]] = None,
    *,
    warn: bool = False,
) -> Iterator[Tag]:
    """
    Yields the tags for a generic interpreter.

    The tags consist of:
    - --

    The "none" ABI will be added if it was not explicitly provided.
    """
    if not interpreter:
        interp_name = interpreter_name()
        interp_version = interpreter_version(warn=warn)
        interpreter = "".join([interp_name, interp_version])
    if abis is None:
        abis = _generic_abi()
    platforms = list(platforms or platform_tags())
    abis = list(abis)
    if "none" not in abis:
        abis.append("none")
    for abi in abis:
        for platform_ in platforms:
            yield Tag(interpreter, abi, platform_)


def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]:
    """
    Yields Python versions in descending order.

    After the latest version, the major-only version will be yielded, and then
    all previous versions of that major version.
    """
    if len(py_version) > 1:
        yield "py{version}".format(version=_version_nodot(py_version[:2]))
    yield "py{major}".format(major=py_version[0])
    if len(py_version) > 1:
        for minor in range(py_version[1] - 1, -1, -1):
            yield "py{version}".format(version=_version_nodot((py_version[0], minor)))


def compatible_tags(
    python_version: Optional[PythonVersion] = None,
    interpreter: Optional[str] = None,
    platforms: Optional[Iterable[str]] = None,
) -> Iterator[Tag]:
    """
    Yields the sequence of tags that are compatible with a specific version of Python.

    The tags consist of:
    - py*-none-
    - -none-any  # ... if `interpreter` is provided.
    - py*-none-any
    """
    if not python_version:
        python_version = sys.version_info[:2]
    platforms = list(platforms or platform_tags())
    for version in _py_interpreter_range(python_version):
        for platform_ in platforms:
            yield Tag(version, "none", platform_)
    if interpreter:
        yield Tag(interpreter, "none", "any")
    for version in _py_interpreter_range(python_version):
        yield Tag(version, "none", "any")


def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str:
    if not is_32bit:
        return arch

    if arch.startswith("ppc"):
        return "ppc"

    return "i386"


def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]:
    formats = [cpu_arch]
    if cpu_arch == "x86_64":
        if version < (10, 4):
            return []
        formats.extend(["intel", "fat64", "fat32"])

    elif cpu_arch == "i386":
        if version < (10, 4):
            return []
        formats.extend(["intel", "fat32", "fat"])

    elif cpu_arch == "ppc64":
        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
        if version > (10, 5) or version < (10, 4):
            return []
        formats.append("fat64")

    elif cpu_arch == "ppc":
        if version > (10, 6):
            return []
        formats.extend(["fat32", "fat"])

    if cpu_arch in {"arm64", "x86_64"}:
        formats.append("universal2")

    if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}:
        formats.append("universal")

    return formats


def mac_platforms(
    version: Optional[MacVersion] = None, arch: Optional[str] = None
) -> Iterator[str]:
    """
    Yields the platform tags for a macOS system.

    The `version` parameter is a two-item tuple specifying the macOS version to
    generate platform tags for. The `arch` parameter is the CPU architecture to
    generate platform tags for. Both parameters default to the appropriate value
    for the current system.
    """
    version_str, _, cpu_arch = platform.mac_ver()
    if version is None:
        version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
    else:
        version = version
    if arch is None:
        arch = _mac_arch(cpu_arch)
    else:
        arch = arch

    if (10, 0) <= version and version < (11, 0):
        # Prior to Mac OS 11, each yearly release of Mac OS bumped the
        # "minor" version number.  The major version was always 10.
        for minor_version in range(version[1], -1, -1):
            compat_version = 10, minor_version
            binary_formats = _mac_binary_formats(compat_version, arch)
            for binary_format in binary_formats:
                yield "macosx_{major}_{minor}_{binary_format}".format(
                    major=10, minor=minor_version, binary_format=binary_format
                )

    if version >= (11, 0):
        # Starting with Mac OS 11, each yearly release bumps the major version
        # number.   The minor versions are now the midyear updates.
        for major_version in range(version[0], 10, -1):
            compat_version = major_version, 0
            binary_formats = _mac_binary_formats(compat_version, arch)
            for binary_format in binary_formats:
                yield "macosx_{major}_{minor}_{binary_format}".format(
                    major=major_version, minor=0, binary_format=binary_format
                )

    if version >= (11, 0):
        # Mac OS 11 on x86_64 is compatible with binaries from previous releases.
        # Arm64 support was introduced in 11.0, so no Arm binaries from previous
        # releases exist.
        #
        # However, the "universal2" binary format can have a
        # macOS version earlier than 11.0 when the x86_64 part of the binary supports
        # that version of macOS.
        if arch == "x86_64":
            for minor_version in range(16, 3, -1):
                compat_version = 10, minor_version
                binary_formats = _mac_binary_formats(compat_version, arch)
                for binary_format in binary_formats:
                    yield "macosx_{major}_{minor}_{binary_format}".format(
                        major=compat_version[0],
                        minor=compat_version[1],
                        binary_format=binary_format,
                    )
        else:
            for minor_version in range(16, 3, -1):
                compat_version = 10, minor_version
                binary_format = "universal2"
                yield "macosx_{major}_{minor}_{binary_format}".format(
                    major=compat_version[0],
                    minor=compat_version[1],
                    binary_format=binary_format,
                )


def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]:
    linux = _normalize_string(sysconfig.get_platform())
    if is_32bit:
        if linux == "linux_x86_64":
            linux = "linux_i686"
        elif linux == "linux_aarch64":
            linux = "linux_armv7l"
    _, arch = linux.split("_", 1)
    yield from _manylinux.platform_tags(linux, arch)
    yield from _musllinux.platform_tags(arch)
    yield linux


def _generic_platforms() -> Iterator[str]:
    yield _normalize_string(sysconfig.get_platform())


def platform_tags() -> Iterator[str]:
    """
    Provides the platform tags for this installation.
    """
    if platform.system() == "Darwin":
        return mac_platforms()
    elif platform.system() == "Linux":
        return _linux_platforms()
    else:
        return _generic_platforms()


def interpreter_name() -> str:
    """
    Returns the name of the running interpreter.
    """
    name = sys.implementation.name
    return INTERPRETER_SHORT_NAMES.get(name) or name


def interpreter_version(*, warn: bool = False) -> str:
    """
    Returns the version of the running interpreter.
    """
    version = _get_config_var("py_version_nodot", warn=warn)
    if version:
        version = str(version)
    else:
        version = _version_nodot(sys.version_info[:2])
    return version


def _version_nodot(version: PythonVersion) -> str:
    return "".join(map(str, version))


def sys_tags(*, warn: bool = False) -> Iterator[Tag]:
    """
    Returns the sequence of tag triples for the running interpreter.

    The order of the sequence corresponds to priority order for the
    interpreter, from most to least important.
    """

    interp_name = interpreter_name()
    if interp_name == "cp":
        yield from cpython_tags(warn=warn)
    else:
        yield from generic_tags()

    yield from compatible_tags()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/utils.py0000644000175100001710000001015000000000000022704 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import re
from typing import FrozenSet, NewType, Tuple, Union, cast

from .tags import Tag, parse_tag
from .version import InvalidVersion, Version

BuildTag = Union[Tuple[()], Tuple[int, str]]
NormalizedName = NewType("NormalizedName", str)


class InvalidWheelFilename(ValueError):
    """
    An invalid wheel filename was found, users should refer to PEP 427.
    """


class InvalidSdistFilename(ValueError):
    """
    An invalid sdist filename was found, users should refer to the packaging user guide.
    """


_canonicalize_regex = re.compile(r"[-_.]+")
# PEP 427: The build number must start with a digit.
_build_tag_regex = re.compile(r"(\d+)(.*)")


def canonicalize_name(name: str) -> NormalizedName:
    # This is taken from PEP 503.
    value = _canonicalize_regex.sub("-", name).lower()
    return cast(NormalizedName, value)


def canonicalize_version(version: Union[Version, str]) -> str:
    """
    This is very similar to Version.__str__, but has one subtle difference
    with the way it handles the release segment.
    """
    if isinstance(version, str):
        try:
            parsed = Version(version)
        except InvalidVersion:
            # Legacy versions cannot be normalized
            return version
    else:
        parsed = version

    parts = []

    # Epoch
    if parsed.epoch != 0:
        parts.append(f"{parsed.epoch}!")

    # Release segment
    # NB: This strips trailing '.0's to normalize
    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in parsed.release)))

    # Pre-release
    if parsed.pre is not None:
        parts.append("".join(str(x) for x in parsed.pre))

    # Post-release
    if parsed.post is not None:
        parts.append(f".post{parsed.post}")

    # Development release
    if parsed.dev is not None:
        parts.append(f".dev{parsed.dev}")

    # Local version segment
    if parsed.local is not None:
        parts.append(f"+{parsed.local}")

    return "".join(parts)


def parse_wheel_filename(
    filename: str,
) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]:
    if not filename.endswith(".whl"):
        raise InvalidWheelFilename(
            f"Invalid wheel filename (extension must be '.whl'): {filename}"
        )

    filename = filename[:-4]
    dashes = filename.count("-")
    if dashes not in (4, 5):
        raise InvalidWheelFilename(
            f"Invalid wheel filename (wrong number of parts): {filename}"
        )

    parts = filename.split("-", dashes - 2)
    name_part = parts[0]
    # See PEP 427 for the rules on escaping the project name
    if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None:
        raise InvalidWheelFilename(f"Invalid project name: {filename}")
    name = canonicalize_name(name_part)
    version = Version(parts[1])
    if dashes == 5:
        build_part = parts[2]
        build_match = _build_tag_regex.match(build_part)
        if build_match is None:
            raise InvalidWheelFilename(
                f"Invalid build number: {build_part} in '{filename}'"
            )
        build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2)))
    else:
        build = ()
    tags = parse_tag(parts[-1])
    return (name, version, build, tags)


def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]:
    if filename.endswith(".tar.gz"):
        file_stem = filename[: -len(".tar.gz")]
    elif filename.endswith(".zip"):
        file_stem = filename[: -len(".zip")]
    else:
        raise InvalidSdistFilename(
            f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):"
            f" {filename}"
        )

    # We are requiring a PEP 440 version, which cannot contain dashes,
    # so we split on the last dash.
    name_part, sep, version_part = file_stem.rpartition("-")
    if not sep:
        raise InvalidSdistFilename(f"Invalid sdist filename: {filename}")

    name = canonicalize_name(name_part)
    version = Version(version_part)
    return (name, version)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/packaging/version.py0000644000175100001710000003451100000000000023240 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import collections
import itertools
import re
import warnings
from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union

from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType

__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]

InfiniteTypes = Union[InfinityType, NegativeInfinityType]
PrePostDevType = Union[InfiniteTypes, Tuple[str, int]]
SubLocalType = Union[InfiniteTypes, int, str]
LocalType = Union[
    NegativeInfinityType,
    Tuple[
        Union[
            SubLocalType,
            Tuple[SubLocalType, str],
            Tuple[NegativeInfinityType, SubLocalType],
        ],
        ...,
    ],
]
CmpKey = Tuple[
    int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType
]
LegacyCmpKey = Tuple[int, Tuple[str, ...]]
VersionComparisonMethod = Callable[
    [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool
]

_Version = collections.namedtuple(
    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
)


def parse(version: str) -> Union["LegacyVersion", "Version"]:
    """
    Parse the given version string and return either a :class:`Version` object
    or a :class:`LegacyVersion` object depending on if the given version is
    a valid PEP 440 version or a legacy version.
    """
    try:
        return Version(version)
    except InvalidVersion:
        return LegacyVersion(version)


class InvalidVersion(ValueError):
    """
    An invalid version was found, users should refer to PEP 440.
    """


class _BaseVersion:
    _key: Union[CmpKey, LegacyCmpKey]

    def __hash__(self) -> int:
        return hash(self._key)

    # Please keep the duplicated `isinstance` check
    # in the six comparisons hereunder
    # unless you find a way to avoid adding overhead function calls.
    def __lt__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key < other._key

    def __le__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key <= other._key

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key == other._key

    def __ge__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key >= other._key

    def __gt__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key > other._key

    def __ne__(self, other: object) -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key != other._key


class LegacyVersion(_BaseVersion):
    def __init__(self, version: str) -> None:
        self._version = str(version)
        self._key = _legacy_cmpkey(self._version)

        warnings.warn(
            "Creating a LegacyVersion has been deprecated and will be "
            "removed in the next major release",
            DeprecationWarning,
        )

    def __str__(self) -> str:
        return self._version

    def __repr__(self) -> str:
        return f""

    @property
    def public(self) -> str:
        return self._version

    @property
    def base_version(self) -> str:
        return self._version

    @property
    def epoch(self) -> int:
        return -1

    @property
    def release(self) -> None:
        return None

    @property
    def pre(self) -> None:
        return None

    @property
    def post(self) -> None:
        return None

    @property
    def dev(self) -> None:
        return None

    @property
    def local(self) -> None:
        return None

    @property
    def is_prerelease(self) -> bool:
        return False

    @property
    def is_postrelease(self) -> bool:
        return False

    @property
    def is_devrelease(self) -> bool:
        return False


_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)

_legacy_version_replacement_map = {
    "pre": "c",
    "preview": "c",
    "-": "final-",
    "rc": "c",
    "dev": "@",
}


def _parse_version_parts(s: str) -> Iterator[str]:
    for part in _legacy_version_component_re.split(s):
        part = _legacy_version_replacement_map.get(part, part)

        if not part or part == ".":
            continue

        if part[:1] in "0123456789":
            # pad for numeric comparison
            yield part.zfill(8)
        else:
            yield "*" + part

    # ensure that alpha/beta/candidate are before final
    yield "*final"


def _legacy_cmpkey(version: str) -> LegacyCmpKey:

    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
    # greater than or equal to 0. This will effectively put the LegacyVersion,
    # which uses the defacto standard originally implemented by setuptools,
    # as before all PEP 440 versions.
    epoch = -1

    # This scheme is taken from pkg_resources.parse_version setuptools prior to
    # it's adoption of the packaging library.
    parts: List[str] = []
    for part in _parse_version_parts(version.lower()):
        if part.startswith("*"):
            # remove "-" before a prerelease tag
            if part < "*final":
                while parts and parts[-1] == "*final-":
                    parts.pop()

            # remove trailing zeros from each series of numeric parts
            while parts and parts[-1] == "00000000":
                parts.pop()

        parts.append(part)

    return epoch, tuple(parts)


# Deliberately not anchored to the start and end of the string, to make it
# easier for 3rd party code to reuse
VERSION_PATTERN = r"""
    v?
    (?:
        (?:(?P[0-9]+)!)?                           # epoch
        (?P[0-9]+(?:\.[0-9]+)*)                  # release segment
        (?P
                                          # pre-release
            [-_\.]?
            (?P(a|b|c|rc|alpha|beta|pre|preview))
            [-_\.]?
            (?P[0-9]+)?
        )?
        (?P                                         # post release
            (?:-(?P[0-9]+))
            |
            (?:
                [-_\.]?
                (?Ppost|rev|r)
                [-_\.]?
                (?P[0-9]+)?
            )
        )?
        (?P                                          # dev release
            [-_\.]?
            (?Pdev)
            [-_\.]?
            (?P[0-9]+)?
        )?
    )
    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
"""


class Version(_BaseVersion):

    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)

    def __init__(self, version: str) -> None:

        # Validate the version and parse it into pieces
        match = self._regex.search(version)
        if not match:
            raise InvalidVersion(f"Invalid version: '{version}'")

        # Store the parsed out pieces of the version
        self._version = _Version(
            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
            release=tuple(int(i) for i in match.group("release").split(".")),
            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
            post=_parse_letter_version(
                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
            ),
            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
            local=_parse_local_version(match.group("local")),
        )

        # Generate a key which will be used for sorting
        self._key = _cmpkey(
            self._version.epoch,
            self._version.release,
            self._version.pre,
            self._version.post,
            self._version.dev,
            self._version.local,
        )

    def __repr__(self) -> str:
        return f""

    def __str__(self) -> str:
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        # Pre-release
        if self.pre is not None:
            parts.append("".join(str(x) for x in self.pre))

        # Post-release
        if self.post is not None:
            parts.append(f".post{self.post}")

        # Development release
        if self.dev is not None:
            parts.append(f".dev{self.dev}")

        # Local version segment
        if self.local is not None:
            parts.append(f"+{self.local}")

        return "".join(parts)

    @property
    def epoch(self) -> int:
        _epoch: int = self._version.epoch
        return _epoch

    @property
    def release(self) -> Tuple[int, ...]:
        _release: Tuple[int, ...] = self._version.release
        return _release

    @property
    def pre(self) -> Optional[Tuple[str, int]]:
        _pre: Optional[Tuple[str, int]] = self._version.pre
        return _pre

    @property
    def post(self) -> Optional[int]:
        return self._version.post[1] if self._version.post else None

    @property
    def dev(self) -> Optional[int]:
        return self._version.dev[1] if self._version.dev else None

    @property
    def local(self) -> Optional[str]:
        if self._version.local:
            return ".".join(str(x) for x in self._version.local)
        else:
            return None

    @property
    def public(self) -> str:
        return str(self).split("+", 1)[0]

    @property
    def base_version(self) -> str:
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        return "".join(parts)

    @property
    def is_prerelease(self) -> bool:
        return self.dev is not None or self.pre is not None

    @property
    def is_postrelease(self) -> bool:
        return self.post is not None

    @property
    def is_devrelease(self) -> bool:
        return self.dev is not None

    @property
    def major(self) -> int:
        return self.release[0] if len(self.release) >= 1 else 0

    @property
    def minor(self) -> int:
        return self.release[1] if len(self.release) >= 2 else 0

    @property
    def micro(self) -> int:
        return self.release[2] if len(self.release) >= 3 else 0


def _parse_letter_version(
    letter: str, number: Union[str, bytes, SupportsInt]
) -> Optional[Tuple[str, int]]:

    if letter:
        # We consider there to be an implicit 0 in a pre-release if there is
        # not a numeral associated with it.
        if number is None:
            number = 0

        # We normalize any letters to their lower case form
        letter = letter.lower()

        # We consider some words to be alternate spellings of other words and
        # in those cases we want to normalize the spellings to our preferred
        # spelling.
        if letter == "alpha":
            letter = "a"
        elif letter == "beta":
            letter = "b"
        elif letter in ["c", "pre", "preview"]:
            letter = "rc"
        elif letter in ["rev", "r"]:
            letter = "post"

        return letter, int(number)
    if not letter and number:
        # We assume if we are given a number, but we are not given a letter
        # then this is using the implicit post release syntax (e.g. 1.0-1)
        letter = "post"

        return letter, int(number)

    return None


_local_version_separators = re.compile(r"[\._-]")


def _parse_local_version(local: str) -> Optional[LocalType]:
    """
    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
    """
    if local is not None:
        return tuple(
            part.lower() if not part.isdigit() else int(part)
            for part in _local_version_separators.split(local)
        )
    return None


def _cmpkey(
    epoch: int,
    release: Tuple[int, ...],
    pre: Optional[Tuple[str, int]],
    post: Optional[Tuple[str, int]],
    dev: Optional[Tuple[str, int]],
    local: Optional[Tuple[SubLocalType]],
) -> CmpKey:

    # When we compare a release version, we want to compare it with all of the
    # trailing zeros removed. So we'll use a reverse the list, drop all the now
    # leading zeros until we come to something non zero, then take the rest
    # re-reverse it back into the correct order and make it a tuple and use
    # that for our sorting key.
    _release = tuple(
        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
    )

    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
    # We'll do this by abusing the pre segment, but we _only_ want to do this
    # if there is not a pre or a post segment. If we have one of those then
    # the normal sorting rules will handle this case correctly.
    if pre is None and post is None and dev is not None:
        _pre: PrePostDevType = NegativeInfinity
    # Versions without a pre-release (except as noted above) should sort after
    # those with one.
    elif pre is None:
        _pre = Infinity
    else:
        _pre = pre

    # Versions without a post segment should sort before those with one.
    if post is None:
        _post: PrePostDevType = NegativeInfinity

    else:
        _post = post

    # Versions without a development segment should sort after those with one.
    if dev is None:
        _dev: PrePostDevType = Infinity

    else:
        _dev = dev

    if local is None:
        # Versions without a local segment should sort before those with one.
        _local: LocalType = NegativeInfinity
    else:
        # Versions with a local segment need that segment parsed to implement
        # the sorting rules in PEP440.
        # - Alpha numeric segments sort before numeric segments
        # - Alpha numeric segments sort lexicographically
        # - Numeric segments sort numerically
        # - Shorter versions sort before longer versions when the prefixes
        #   match exactly
        _local = tuple(
            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
        )

    return epoch, _release, _pre, _post, _dev, _local
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/pyparsing.py0000644000175100001710000070516700000000000021657 0ustar00runnerdocker# module pyparsing.py
#
# Copyright (c) 2003-2018  Paul T. McGuire
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#

__doc__ = \
"""
pyparsing module - Classes and methods to define and execute parsing grammars
=============================================================================

The pyparsing module is an alternative approach to creating and executing simple grammars,
vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
provides a library of classes that you use to construct the grammar directly in Python.

Here is a program to parse "Hello, World!" (or any greeting of the form 
C{", !"}), built up using L{Word}, L{Literal}, and L{And} elements 
(L{'+'} operator gives L{And} expressions, strings are auto-converted to
L{Literal} expressions)::

    from pyparsing import Word, alphas

    # define grammar of a greeting
    greet = Word(alphas) + "," + Word(alphas) + "!"

    hello = "Hello, World!"
    print (hello, "->", greet.parseString(hello))

The program outputs the following::

    Hello, World! -> ['Hello', ',', 'World', '!']

The Python representation of the grammar is quite readable, owing to the self-explanatory
class names, and the use of '+', '|' and '^' operators.

The L{ParseResults} object returned from L{ParserElement.parseString} can be accessed as a nested list, a dictionary, or an
object with named attributes.

The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
 - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
 - quoted strings
 - embedded comments


Getting Started -
-----------------
Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing
classes inherit from. Use the docstrings for examples of how to:
 - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes
 - construct character word-group expressions using the L{Word} class
 - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
 - use L{'+'}, L{'|'}, L{'^'}, and L{'&'} operators to combine simple expressions into more complex ones
 - associate names with your parsed results using L{ParserElement.setResultsName}
 - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
 - find more useful common expressions in the L{pyparsing_common} namespace class
"""

__version__ = "2.2.1"
__versionTime__ = "18 Sep 2018 00:49 UTC"
__author__ = "Paul McGuire "

import string
from weakref import ref as wkref
import copy
import sys
import warnings
import re
import sre_constants
import collections
import pprint
import traceback
import types
from datetime import datetime

try:
    from _thread import RLock
except ImportError:
    from threading import RLock

try:
    # Python 3
    from collections.abc import Iterable
    from collections.abc import MutableMapping
except ImportError:
    # Python 2.7
    from collections import Iterable
    from collections import MutableMapping

try:
    from collections import OrderedDict as _OrderedDict
except ImportError:
    try:
        from ordereddict import OrderedDict as _OrderedDict
    except ImportError:
        _OrderedDict = None

#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )

__all__ = [
'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 
'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',
'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 
'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',
'CloseMatch', 'tokenMap', 'pyparsing_common',
]

system_version = tuple(sys.version_info)[:3]
PY_3 = system_version[0] == 3
if PY_3:
    _MAX_INT = sys.maxsize
    basestring = str
    unichr = chr
    _ustr = str

    # build list of single arg builtins, that can be used as parse actions
    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]

else:
    _MAX_INT = sys.maxint
    range = xrange

    def _ustr(obj):
        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
           then < returns the unicode object | encodes it with the default encoding | ... >.
        """
        if isinstance(obj,unicode):
            return obj

        try:
            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
            # it won't break any existing code.
            return str(obj)

        except UnicodeEncodeError:
            # Else encode it
            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')
            xmlcharref = Regex(r'&#\d+;')
            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])
            return xmlcharref.transformString(ret)

    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions
    singleArgBuiltins = []
    import __builtin__
    for fname in "sum len sorted reversed list tuple set any all min max".split():
        try:
            singleArgBuiltins.append(getattr(__builtin__,fname))
        except AttributeError:
            continue
            
_generatorType = type((y for y in range(1)))
 
def _xml_escape(data):
    """Escape &, <, >, ", ', etc. in a string of data."""

    # ampersand must be replaced first
    from_symbols = '&><"\''
    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())
    for from_,to_ in zip(from_symbols, to_symbols):
        data = data.replace(from_, to_)
    return data

class _Constants(object):
    pass

alphas     = string.ascii_uppercase + string.ascii_lowercase
nums       = "0123456789"
hexnums    = nums + "ABCDEFabcdef"
alphanums  = alphas + nums
_bslash    = chr(92)
printables = "".join(c for c in string.printable if c not in string.whitespace)

class ParseBaseException(Exception):
    """base exception class for all parsing runtime exceptions"""
    # Performance tuning: we construct a *lot* of these, so keep this
    # constructor as small and fast as possible
    def __init__( self, pstr, loc=0, msg=None, elem=None ):
        self.loc = loc
        if msg is None:
            self.msg = pstr
            self.pstr = ""
        else:
            self.msg = msg
            self.pstr = pstr
        self.parserElement = elem
        self.args = (pstr, loc, msg)

    @classmethod
    def _from_exception(cls, pe):
        """
        internal factory method to simplify creating one type of ParseException 
        from another - avoids having __init__ signature conflicts among subclasses
        """
        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)

    def __getattr__( self, aname ):
        """supported attributes by name are:
            - lineno - returns the line number of the exception text
            - col - returns the column number of the exception text
            - line - returns the line containing the exception text
        """
        if( aname == "lineno" ):
            return lineno( self.loc, self.pstr )
        elif( aname in ("col", "column") ):
            return col( self.loc, self.pstr )
        elif( aname == "line" ):
            return line( self.loc, self.pstr )
        else:
            raise AttributeError(aname)

    def __str__( self ):
        return "%s (at char %d), (line:%d, col:%d)" % \
                ( self.msg, self.loc, self.lineno, self.column )
    def __repr__( self ):
        return _ustr(self)
    def markInputline( self, markerString = ">!<" ):
        """Extracts the exception line from the input string, and marks
           the location of the exception with a special symbol.
        """
        line_str = self.line
        line_column = self.column - 1
        if markerString:
            line_str = "".join((line_str[:line_column],
                                markerString, line_str[line_column:]))
        return line_str.strip()
    def __dir__(self):
        return "lineno col line".split() + dir(type(self))

class ParseException(ParseBaseException):
    """
    Exception thrown when parse expressions don't match class;
    supported attributes by name are:
     - lineno - returns the line number of the exception text
     - col - returns the column number of the exception text
     - line - returns the line containing the exception text
        
    Example::
        try:
            Word(nums).setName("integer").parseString("ABC")
        except ParseException as pe:
            print(pe)
            print("column: {}".format(pe.col))
            
    prints::
       Expected integer (at char 0), (line:1, col:1)
        column: 1
    """
    pass

class ParseFatalException(ParseBaseException):
    """user-throwable exception thrown when inconsistent parse content
       is found; stops all parsing immediately"""
    pass

class ParseSyntaxException(ParseFatalException):
    """just like L{ParseFatalException}, but thrown internally when an
       L{ErrorStop} ('-' operator) indicates that parsing is to stop 
       immediately because an unbacktrackable syntax error has been found"""
    pass

#~ class ReparseException(ParseBaseException):
    #~ """Experimental class - parse actions can raise this exception to cause
       #~ pyparsing to reparse the input string:
        #~ - with a modified input string, and/or
        #~ - with a modified start location
       #~ Set the values of the ReparseException in the constructor, and raise the
       #~ exception in a parse action to cause pyparsing to use the new string/location.
       #~ Setting the values as None causes no change to be made.
       #~ """
    #~ def __init_( self, newstring, restartLoc ):
        #~ self.newParseText = newstring
        #~ self.reparseLoc = restartLoc

class RecursiveGrammarException(Exception):
    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""
    def __init__( self, parseElementList ):
        self.parseElementTrace = parseElementList

    def __str__( self ):
        return "RecursiveGrammarException: %s" % self.parseElementTrace

class _ParseResultsWithOffset(object):
    def __init__(self,p1,p2):
        self.tup = (p1,p2)
    def __getitem__(self,i):
        return self.tup[i]
    def __repr__(self):
        return repr(self.tup[0])
    def setOffset(self,i):
        self.tup = (self.tup[0],i)

class ParseResults(object):
    """
    Structured parse results, to provide multiple means of access to the parsed data:
       - as a list (C{len(results)})
       - by list index (C{results[0], results[1]}, etc.)
       - by attribute (C{results.} - see L{ParserElement.setResultsName})

    Example::
        integer = Word(nums)
        date_str = (integer.setResultsName("year") + '/' 
                        + integer.setResultsName("month") + '/' 
                        + integer.setResultsName("day"))
        # equivalent form:
        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

        # parseString returns a ParseResults object
        result = date_str.parseString("1999/12/31")

        def test(s, fn=repr):
            print("%s -> %s" % (s, fn(eval(s))))
        test("list(result)")
        test("result[0]")
        test("result['month']")
        test("result.day")
        test("'month' in result")
        test("'minutes' in result")
        test("result.dump()", str)
    prints::
        list(result) -> ['1999', '/', '12', '/', '31']
        result[0] -> '1999'
        result['month'] -> '12'
        result.day -> '31'
        'month' in result -> True
        'minutes' in result -> False
        result.dump() -> ['1999', '/', '12', '/', '31']
        - day: 31
        - month: 12
        - year: 1999
    """
    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):
        if isinstance(toklist, cls):
            return toklist
        retobj = object.__new__(cls)
        retobj.__doinit = True
        return retobj

    # Performance tuning: we construct a *lot* of these, so keep this
    # constructor as small and fast as possible
    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):
        if self.__doinit:
            self.__doinit = False
            self.__name = None
            self.__parent = None
            self.__accumNames = {}
            self.__asList = asList
            self.__modal = modal
            if toklist is None:
                toklist = []
            if isinstance(toklist, list):
                self.__toklist = toklist[:]
            elif isinstance(toklist, _generatorType):
                self.__toklist = list(toklist)
            else:
                self.__toklist = [toklist]
            self.__tokdict = dict()

        if name is not None and name:
            if not modal:
                self.__accumNames[name] = 0
            if isinstance(name,int):
                name = _ustr(name) # will always return a str, but use _ustr for consistency
            self.__name = name
            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):
                if isinstance(toklist,basestring):
                    toklist = [ toklist ]
                if asList:
                    if isinstance(toklist,ParseResults):
                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)
                    else:
                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
                    self[name].__name = name
                else:
                    try:
                        self[name] = toklist[0]
                    except (KeyError,TypeError,IndexError):
                        self[name] = toklist

    def __getitem__( self, i ):
        if isinstance( i, (int,slice) ):
            return self.__toklist[i]
        else:
            if i not in self.__accumNames:
                return self.__tokdict[i][-1][0]
            else:
                return ParseResults([ v[0] for v in self.__tokdict[i] ])

    def __setitem__( self, k, v, isinstance=isinstance ):
        if isinstance(v,_ParseResultsWithOffset):
            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
            sub = v[0]
        elif isinstance(k,(int,slice)):
            self.__toklist[k] = v
            sub = v
        else:
            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
            sub = v
        if isinstance(sub,ParseResults):
            sub.__parent = wkref(self)

    def __delitem__( self, i ):
        if isinstance(i,(int,slice)):
            mylen = len( self.__toklist )
            del self.__toklist[i]

            # convert int to slice
            if isinstance(i, int):
                if i < 0:
                    i += mylen
                i = slice(i, i+1)
            # get removed indices
            removed = list(range(*i.indices(mylen)))
            removed.reverse()
            # fixup indices in token dictionary
            for name,occurrences in self.__tokdict.items():
                for j in removed:
                    for k, (value, position) in enumerate(occurrences):
                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
        else:
            del self.__tokdict[i]

    def __contains__( self, k ):
        return k in self.__tokdict

    def __len__( self ): return len( self.__toklist )
    def __bool__(self): return ( not not self.__toklist )
    __nonzero__ = __bool__
    def __iter__( self ): return iter( self.__toklist )
    def __reversed__( self ): return iter( self.__toklist[::-1] )
    def _iterkeys( self ):
        if hasattr(self.__tokdict, "iterkeys"):
            return self.__tokdict.iterkeys()
        else:
            return iter(self.__tokdict)

    def _itervalues( self ):
        return (self[k] for k in self._iterkeys())
            
    def _iteritems( self ):
        return ((k, self[k]) for k in self._iterkeys())

    if PY_3:
        keys = _iterkeys       
        """Returns an iterator of all named result keys (Python 3.x only)."""

        values = _itervalues
        """Returns an iterator of all named result values (Python 3.x only)."""

        items = _iteritems
        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""

    else:
        iterkeys = _iterkeys
        """Returns an iterator of all named result keys (Python 2.x only)."""

        itervalues = _itervalues
        """Returns an iterator of all named result values (Python 2.x only)."""

        iteritems = _iteritems
        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""

        def keys( self ):
            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""
            return list(self.iterkeys())

        def values( self ):
            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""
            return list(self.itervalues())
                
        def items( self ):
            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""
            return list(self.iteritems())

    def haskeys( self ):
        """Since keys() returns an iterator, this method is helpful in bypassing
           code that looks for the existence of any defined results names."""
        return bool(self.__tokdict)
        
    def pop( self, *args, **kwargs):
        """
        Removes and returns item at specified index (default=C{last}).
        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no
        argument or an integer argument, it will use C{list} semantics
        and pop tokens from the list of parsed tokens. If passed a 
        non-integer argument (most likely a string), it will use C{dict}
        semantics and pop the corresponding value from any defined 
        results names. A second default return value argument is 
        supported, just as in C{dict.pop()}.

        Example::
            def remove_first(tokens):
                tokens.pop(0)
            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']

            label = Word(alphas)
            patt = label("LABEL") + OneOrMore(Word(nums))
            print(patt.parseString("AAB 123 321").dump())

            # Use pop() in a parse action to remove named result (note that corresponding value is not
            # removed from list form of results)
            def remove_LABEL(tokens):
                tokens.pop("LABEL")
                return tokens
            patt.addParseAction(remove_LABEL)
            print(patt.parseString("AAB 123 321").dump())
        prints::
            ['AAB', '123', '321']
            - LABEL: AAB

            ['AAB', '123', '321']
        """
        if not args:
            args = [-1]
        for k,v in kwargs.items():
            if k == 'default':
                args = (args[0], v)
            else:
                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
        if (isinstance(args[0], int) or 
                        len(args) == 1 or 
                        args[0] in self):
            index = args[0]
            ret = self[index]
            del self[index]
            return ret
        else:
            defaultvalue = args[1]
            return defaultvalue

    def get(self, key, defaultValue=None):
        """
        Returns named result matching the given key, or if there is no
        such name, then returns the given C{defaultValue} or C{None} if no
        C{defaultValue} is specified.

        Similar to C{dict.get()}.
        
        Example::
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

            result = date_str.parseString("1999/12/31")
            print(result.get("year")) # -> '1999'
            print(result.get("hour", "not specified")) # -> 'not specified'
            print(result.get("hour")) # -> None
        """
        if key in self:
            return self[key]
        else:
            return defaultValue

    def insert( self, index, insStr ):
        """
        Inserts new element at location index in the list of parsed tokens.
        
        Similar to C{list.insert()}.

        Example::
            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

            # use a parse action to insert the parse location in the front of the parsed results
            def insert_locn(locn, tokens):
                tokens.insert(0, locn)
            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
        """
        self.__toklist.insert(index, insStr)
        # fixup indices in token dictionary
        for name,occurrences in self.__tokdict.items():
            for k, (value, position) in enumerate(occurrences):
                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))

    def append( self, item ):
        """
        Add single element to end of ParseResults list of elements.

        Example::
            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
            
            # use a parse action to compute the sum of the parsed integers, and add it to the end
            def append_sum(tokens):
                tokens.append(sum(map(int, tokens)))
            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
        """
        self.__toklist.append(item)

    def extend( self, itemseq ):
        """
        Add sequence of elements to end of ParseResults list of elements.

        Example::
            patt = OneOrMore(Word(alphas))
            
            # use a parse action to append the reverse of the matched strings, to make a palindrome
            def make_palindrome(tokens):
                tokens.extend(reversed([t[::-1] for t in tokens]))
                return ''.join(tokens)
            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
        """
        if isinstance(itemseq, ParseResults):
            self += itemseq
        else:
            self.__toklist.extend(itemseq)

    def clear( self ):
        """
        Clear all elements and results names.
        """
        del self.__toklist[:]
        self.__tokdict.clear()

    def __getattr__( self, name ):
        try:
            return self[name]
        except KeyError:
            return ""
            
        if name in self.__tokdict:
            if name not in self.__accumNames:
                return self.__tokdict[name][-1][0]
            else:
                return ParseResults([ v[0] for v in self.__tokdict[name] ])
        else:
            return ""

    def __add__( self, other ):
        ret = self.copy()
        ret += other
        return ret

    def __iadd__( self, other ):
        if other.__tokdict:
            offset = len(self.__toklist)
            addoffset = lambda a: offset if a<0 else a+offset
            otheritems = other.__tokdict.items()
            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
                                for (k,vlist) in otheritems for v in vlist]
            for k,v in otherdictitems:
                self[k] = v
                if isinstance(v[0],ParseResults):
                    v[0].__parent = wkref(self)
            
        self.__toklist += other.__toklist
        self.__accumNames.update( other.__accumNames )
        return self

    def __radd__(self, other):
        if isinstance(other,int) and other == 0:
            # useful for merging many ParseResults using sum() builtin
            return self.copy()
        else:
            # this may raise a TypeError - so be it
            return other + self
        
    def __repr__( self ):
        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )

    def __str__( self ):
        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'

    def _asStringList( self, sep='' ):
        out = []
        for item in self.__toklist:
            if out and sep:
                out.append(sep)
            if isinstance( item, ParseResults ):
                out += item._asStringList()
            else:
                out.append( _ustr(item) )
        return out

    def asList( self ):
        """
        Returns the parse results as a nested list of matching tokens, all converted to strings.

        Example::
            patt = OneOrMore(Word(alphas))
            result = patt.parseString("sldkj lsdkj sldkj")
            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
            print(type(result), result) # ->  ['sldkj', 'lsdkj', 'sldkj']
            
            # Use asList() to create an actual list
            result_list = result.asList()
            print(type(result_list), result_list) # ->  ['sldkj', 'lsdkj', 'sldkj']
        """
        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]

    def asDict( self ):
        """
        Returns the named parse results as a nested dictionary.

        Example::
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
            
            result = date_str.parseString('12/31/1999')
            print(type(result), repr(result)) # ->  (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
            
            result_dict = result.asDict()
            print(type(result_dict), repr(result_dict)) # ->  {'day': '1999', 'year': '12', 'month': '31'}

            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
            import json
            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
        """
        if PY_3:
            item_fn = self.items
        else:
            item_fn = self.iteritems
            
        def toItem(obj):
            if isinstance(obj, ParseResults):
                if obj.haskeys():
                    return obj.asDict()
                else:
                    return [toItem(v) for v in obj]
            else:
                return obj
                
        return dict((k,toItem(v)) for k,v in item_fn())

    def copy( self ):
        """
        Returns a new copy of a C{ParseResults} object.
        """
        ret = ParseResults( self.__toklist )
        ret.__tokdict = self.__tokdict.copy()
        ret.__parent = self.__parent
        ret.__accumNames.update( self.__accumNames )
        ret.__name = self.__name
        return ret

    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
        """
        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
        """
        nl = "\n"
        out = []
        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
                                                            for v in vlist)
        nextLevelIndent = indent + "  "

        # collapse out indents if formatting is not desired
        if not formatted:
            indent = ""
            nextLevelIndent = ""
            nl = ""

        selfTag = None
        if doctag is not None:
            selfTag = doctag
        else:
            if self.__name:
                selfTag = self.__name

        if not selfTag:
            if namedItemsOnly:
                return ""
            else:
                selfTag = "ITEM"

        out += [ nl, indent, "<", selfTag, ">" ]

        for i,res in enumerate(self.__toklist):
            if isinstance(res,ParseResults):
                if i in namedItems:
                    out += [ res.asXML(namedItems[i],
                                        namedItemsOnly and doctag is None,
                                        nextLevelIndent,
                                        formatted)]
                else:
                    out += [ res.asXML(None,
                                        namedItemsOnly and doctag is None,
                                        nextLevelIndent,
                                        formatted)]
            else:
                # individual token, see if there is a name for it
                resTag = None
                if i in namedItems:
                    resTag = namedItems[i]
                if not resTag:
                    if namedItemsOnly:
                        continue
                    else:
                        resTag = "ITEM"
                xmlBodyText = _xml_escape(_ustr(res))
                out += [ nl, nextLevelIndent, "<", resTag, ">",
                                                xmlBodyText,
                                                "" ]

        out += [ nl, indent, "" ]
        return "".join(out)

    def __lookup(self,sub):
        for k,vlist in self.__tokdict.items():
            for v,loc in vlist:
                if sub is v:
                    return k
        return None

    def getName(self):
        r"""
        Returns the results name for this token expression. Useful when several 
        different expressions might match at a particular location.

        Example::
            integer = Word(nums)
            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
            house_number_expr = Suppress('#') + Word(nums, alphanums)
            user_data = (Group(house_number_expr)("house_number") 
                        | Group(ssn_expr)("ssn")
                        | Group(integer)("age"))
            user_info = OneOrMore(user_data)
            
            result = user_info.parseString("22 111-22-3333 #221B")
            for item in result:
                print(item.getName(), ':', item[0])
        prints::
            age : 22
            ssn : 111-22-3333
            house_number : 221B
        """
        if self.__name:
            return self.__name
        elif self.__parent:
            par = self.__parent()
            if par:
                return par.__lookup(self)
            else:
                return None
        elif (len(self) == 1 and
               len(self.__tokdict) == 1 and
               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):
            return next(iter(self.__tokdict.keys()))
        else:
            return None

    def dump(self, indent='', depth=0, full=True):
        """
        Diagnostic method for listing out the contents of a C{ParseResults}.
        Accepts an optional C{indent} argument so that this string can be embedded
        in a nested display of other data.

        Example::
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
            
            result = date_str.parseString('12/31/1999')
            print(result.dump())
        prints::
            ['12', '/', '31', '/', '1999']
            - day: 1999
            - month: 31
            - year: 12
        """
        out = []
        NL = '\n'
        out.append( indent+_ustr(self.asList()) )
        if full:
            if self.haskeys():
                items = sorted((str(k), v) for k,v in self.items())
                for k,v in items:
                    if out:
                        out.append(NL)
                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
                    if isinstance(v,ParseResults):
                        if v:
                            out.append( v.dump(indent,depth+1) )
                        else:
                            out.append(_ustr(v))
                    else:
                        out.append(repr(v))
            elif any(isinstance(vv,ParseResults) for vv in self):
                v = self
                for i,vv in enumerate(v):
                    if isinstance(vv,ParseResults):
                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))
                    else:
                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))
            
        return "".join(out)

    def pprint(self, *args, **kwargs):
        """
        Pretty-printer for parsed results as a list, using the C{pprint} module.
        Accepts additional positional or keyword args as defined for the 
        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})

        Example::
            ident = Word(alphas, alphanums)
            num = Word(nums)
            func = Forward()
            term = ident | num | Group('(' + func + ')')
            func <<= ident + Group(Optional(delimitedList(term)))
            result = func.parseString("fna a,b,(fnb c,d,200),100")
            result.pprint(width=40)
        prints::
            ['fna',
             ['a',
              'b',
              ['(', 'fnb', ['c', 'd', '200'], ')'],
              '100']]
        """
        pprint.pprint(self.asList(), *args, **kwargs)

    # add support for pickle protocol
    def __getstate__(self):
        return ( self.__toklist,
                 ( self.__tokdict.copy(),
                   self.__parent is not None and self.__parent() or None,
                   self.__accumNames,
                   self.__name ) )

    def __setstate__(self,state):
        self.__toklist = state[0]
        (self.__tokdict,
         par,
         inAccumNames,
         self.__name) = state[1]
        self.__accumNames = {}
        self.__accumNames.update(inAccumNames)
        if par is not None:
            self.__parent = wkref(par)
        else:
            self.__parent = None

    def __getnewargs__(self):
        return self.__toklist, self.__name, self.__asList, self.__modal

    def __dir__(self):
        return (dir(type(self)) + list(self.keys()))

MutableMapping.register(ParseResults)

def col (loc,strg):
    """Returns current column within a string, counting newlines as line separators.
   The first column is number 1.

   Note: the default parsing behavior is to expand tabs in the input string
   before starting the parsing process.  See L{I{ParserElement.parseString}} for more information
   on parsing strings containing C{}s, and suggested methods to maintain a
   consistent view of the parsed string, the parse location, and line and column
   positions within the parsed string.
   """
    s = strg
    return 1 if 0} for more information
   on parsing strings containing C{}s, and suggested methods to maintain a
   consistent view of the parsed string, the parse location, and line and column
   positions within the parsed string.
   """
    return strg.count("\n",0,loc) + 1

def line( loc, strg ):
    """Returns the line of text containing loc within a string, counting newlines as line separators.
       """
    lastCR = strg.rfind("\n", 0, loc)
    nextCR = strg.find("\n", loc)
    if nextCR >= 0:
        return strg[lastCR+1:nextCR]
    else:
        return strg[lastCR+1:]

def _defaultStartDebugAction( instring, loc, expr ):
    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))

def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))

def _defaultExceptionDebugAction( instring, loc, expr, exc ):
    print ("Exception raised:" + _ustr(exc))

def nullDebugAction(*args):
    """'Do-nothing' debug action, to suppress debugging output during parsing."""
    pass

# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
#~ 'decorator to trim function calls to match the arity of the target'
#~ def _trim_arity(func, maxargs=3):
    #~ if func in singleArgBuiltins:
        #~ return lambda s,l,t: func(t)
    #~ limit = 0
    #~ foundArity = False
    #~ def wrapper(*args):
        #~ nonlocal limit,foundArity
        #~ while 1:
            #~ try:
                #~ ret = func(*args[limit:])
                #~ foundArity = True
                #~ return ret
            #~ except TypeError:
                #~ if limit == maxargs or foundArity:
                    #~ raise
                #~ limit += 1
                #~ continue
    #~ return wrapper

# this version is Python 2.x-3.x cross-compatible
'decorator to trim function calls to match the arity of the target'
def _trim_arity(func, maxargs=2):
    if func in singleArgBuiltins:
        return lambda s,l,t: func(t)
    limit = [0]
    foundArity = [False]
    
    # traceback return data structure changed in Py3.5 - normalize back to plain tuples
    if system_version[:2] >= (3,5):
        def extract_stack(limit=0):
            # special handling for Python 3.5.0 - extra deep call stack by 1
            offset = -3 if system_version == (3,5,0) else -2
            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
            return [frame_summary[:2]]
        def extract_tb(tb, limit=0):
            frames = traceback.extract_tb(tb, limit=limit)
            frame_summary = frames[-1]
            return [frame_summary[:2]]
    else:
        extract_stack = traceback.extract_stack
        extract_tb = traceback.extract_tb
    
    # synthesize what would be returned by traceback.extract_stack at the call to 
    # user's parse action 'func', so that we don't incur call penalty at parse time
    
    LINE_DIFF = 6
    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 
    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
    this_line = extract_stack(limit=2)[-1]
    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)

    def wrapper(*args):
        while 1:
            try:
                ret = func(*args[limit[0]:])
                foundArity[0] = True
                return ret
            except TypeError:
                # re-raise TypeErrors if they did not come from our arity testing
                if foundArity[0]:
                    raise
                else:
                    try:
                        tb = sys.exc_info()[-1]
                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:
                            raise
                    finally:
                        del tb

                if limit[0] <= maxargs:
                    limit[0] += 1
                    continue
                raise

    # copy func name to wrapper for sensible debug output
    func_name = ""
    try:
        func_name = getattr(func, '__name__', 
                            getattr(func, '__class__').__name__)
    except Exception:
        func_name = str(func)
    wrapper.__name__ = func_name

    return wrapper

class ParserElement(object):
    """Abstract base level parser element class."""
    DEFAULT_WHITE_CHARS = " \n\t\r"
    verbose_stacktrace = False

    @staticmethod
    def setDefaultWhitespaceChars( chars ):
        r"""
        Overrides the default whitespace chars

        Example::
            # default whitespace chars are space,  and newline
            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
            
            # change to just treat newline as significant
            ParserElement.setDefaultWhitespaceChars(" \t")
            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']
        """
        ParserElement.DEFAULT_WHITE_CHARS = chars

    @staticmethod
    def inlineLiteralsUsing(cls):
        """
        Set class to be used for inclusion of string literals into a parser.
        
        Example::
            # default literal class used is Literal
            integer = Word(nums)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']


            # change to Suppress
            ParserElement.inlineLiteralsUsing(Suppress)
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']
        """
        ParserElement._literalStringClass = cls

    def __init__( self, savelist=False ):
        self.parseAction = list()
        self.failAction = None
        #~ self.name = ""  # don't define self.name, let subclasses try/except upcall
        self.strRepr = None
        self.resultsName = None
        self.saveAsList = savelist
        self.skipWhitespace = True
        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
        self.copyDefaultWhiteChars = True
        self.mayReturnEmpty = False # used when checking for left-recursion
        self.keepTabs = False
        self.ignoreExprs = list()
        self.debug = False
        self.streamlined = False
        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
        self.errmsg = ""
        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
        self.debugActions = ( None, None, None ) #custom debug actions
        self.re = None
        self.callPreparse = True # used to avoid redundant calls to preParse
        self.callDuringTry = False

    def copy( self ):
        """
        Make a copy of this C{ParserElement}.  Useful for defining different parse actions
        for the same parsing pattern, using copies of the original parse element.
        
        Example::
            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
            
            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
        prints::
            [5120, 100, 655360, 268435456]
        Equivalent form of C{expr.copy()} is just C{expr()}::
            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
        """
        cpy = copy.copy( self )
        cpy.parseAction = self.parseAction[:]
        cpy.ignoreExprs = self.ignoreExprs[:]
        if self.copyDefaultWhiteChars:
            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
        return cpy

    def setName( self, name ):
        """
        Define name for this expression, makes debugging and exception messages clearer.
        
        Example::
            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
        """
        self.name = name
        self.errmsg = "Expected " + self.name
        if hasattr(self,"exception"):
            self.exception.msg = self.errmsg
        return self

    def setResultsName( self, name, listAllMatches=False ):
        """
        Define name for referencing matching tokens as a nested attribute
        of the returned parse results.
        NOTE: this returns a *copy* of the original C{ParserElement} object;
        this is so that the client can define a basic element, such as an
        integer, and reference it in multiple places with different names.

        You can also set results names using the abbreviated syntax,
        C{expr("name")} in place of C{expr.setResultsName("name")} - 
        see L{I{__call__}<__call__>}.

        Example::
            date_str = (integer.setResultsName("year") + '/' 
                        + integer.setResultsName("month") + '/' 
                        + integer.setResultsName("day"))

            # equivalent form:
            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
        """
        newself = self.copy()
        if name.endswith("*"):
            name = name[:-1]
            listAllMatches=True
        newself.resultsName = name
        newself.modalResults = not listAllMatches
        return newself

    def setBreak(self,breakFlag = True):
        """Method to invoke the Python pdb debugger when this element is
           about to be parsed. Set C{breakFlag} to True to enable, False to
           disable.
        """
        if breakFlag:
            _parseMethod = self._parse
            def breaker(instring, loc, doActions=True, callPreParse=True):
                import pdb
                pdb.set_trace()
                return _parseMethod( instring, loc, doActions, callPreParse )
            breaker._originalParseMethod = _parseMethod
            self._parse = breaker
        else:
            if hasattr(self._parse,"_originalParseMethod"):
                self._parse = self._parse._originalParseMethod
        return self

    def setParseAction( self, *fns, **kwargs ):
        """
        Define one or more actions to perform when successfully matching parse element definition.
        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:
         - s   = the original string being parsed (see note below)
         - loc = the location of the matching substring
         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object
        If the functions in fns modify the tokens, they can return them as the return
        value from fn, and the modified list of tokens will replace the original.
        Otherwise, fn does not need to return any value.

        Optional keyword arguments:
         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing

        Note: the default parsing behavior is to expand tabs in the input string
        before starting the parsing process.  See L{I{parseString}} for more information
        on parsing strings containing C{}s, and suggested methods to maintain a
        consistent view of the parsed string, the parse location, and line and column
        positions within the parsed string.
        
        Example::
            integer = Word(nums)
            date_str = integer + '/' + integer + '/' + integer

            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']

            # use parse action to convert to ints at parse time
            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
            date_str = integer + '/' + integer + '/' + integer

            # note that integer fields are now ints, not strings
            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]
        """
        self.parseAction = list(map(_trim_arity, list(fns)))
        self.callDuringTry = kwargs.get("callDuringTry", False)
        return self

    def addParseAction( self, *fns, **kwargs ):
        """
        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}}.
        
        See examples in L{I{copy}}.
        """
        self.parseAction += list(map(_trim_arity, list(fns)))
        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
        return self

    def addCondition(self, *fns, **kwargs):
        """Add a boolean predicate function to expression's list of parse actions. See 
        L{I{setParseAction}} for function call signatures. Unlike C{setParseAction}, 
        functions passed to C{addCondition} need to return boolean success/fail of the condition.

        Optional keyword arguments:
         - message = define a custom message to be used in the raised exception
         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
         
        Example::
            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
            year_int = integer.copy()
            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
            date_str = year_int + '/' + integer + '/' + integer

            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
        """
        msg = kwargs.get("message", "failed user-defined condition")
        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException
        for fn in fns:
            def pa(s,l,t):
                if not bool(_trim_arity(fn)(s,l,t)):
                    raise exc_type(s,l,msg)
            self.parseAction.append(pa)
        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
        return self

    def setFailAction( self, fn ):
        """Define action to perform if parsing fails at this expression.
           Fail acton fn is a callable function that takes the arguments
           C{fn(s,loc,expr,err)} where:
            - s = string being parsed
            - loc = location where expression match was attempted and failed
            - expr = the parse expression that failed
            - err = the exception thrown
           The function returns no value.  It may throw C{L{ParseFatalException}}
           if it is desired to stop parsing immediately."""
        self.failAction = fn
        return self

    def _skipIgnorables( self, instring, loc ):
        exprsFound = True
        while exprsFound:
            exprsFound = False
            for e in self.ignoreExprs:
                try:
                    while 1:
                        loc,dummy = e._parse( instring, loc )
                        exprsFound = True
                except ParseException:
                    pass
        return loc

    def preParse( self, instring, loc ):
        if self.ignoreExprs:
            loc = self._skipIgnorables( instring, loc )

        if self.skipWhitespace:
            wt = self.whiteChars
            instrlen = len(instring)
            while loc < instrlen and instring[loc] in wt:
                loc += 1

        return loc

    def parseImpl( self, instring, loc, doActions=True ):
        return loc, []

    def postParse( self, instring, loc, tokenlist ):
        return tokenlist

    #~ @profile
    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
        debugging = ( self.debug ) #and doActions )

        if debugging or self.failAction:
            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
            if (self.debugActions[0] ):
                self.debugActions[0]( instring, loc, self )
            if callPreParse and self.callPreparse:
                preloc = self.preParse( instring, loc )
            else:
                preloc = loc
            tokensStart = preloc
            try:
                try:
                    loc,tokens = self.parseImpl( instring, preloc, doActions )
                except IndexError:
                    raise ParseException( instring, len(instring), self.errmsg, self )
            except ParseBaseException as err:
                #~ print ("Exception raised:", err)
                if self.debugActions[2]:
                    self.debugActions[2]( instring, tokensStart, self, err )
                if self.failAction:
                    self.failAction( instring, tokensStart, self, err )
                raise
        else:
            if callPreParse and self.callPreparse:
                preloc = self.preParse( instring, loc )
            else:
                preloc = loc
            tokensStart = preloc
            if self.mayIndexError or preloc >= len(instring):
                try:
                    loc,tokens = self.parseImpl( instring, preloc, doActions )
                except IndexError:
                    raise ParseException( instring, len(instring), self.errmsg, self )
            else:
                loc,tokens = self.parseImpl( instring, preloc, doActions )

        tokens = self.postParse( instring, loc, tokens )

        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
        if self.parseAction and (doActions or self.callDuringTry):
            if debugging:
                try:
                    for fn in self.parseAction:
                        tokens = fn( instring, tokensStart, retTokens )
                        if tokens is not None:
                            retTokens = ParseResults( tokens,
                                                      self.resultsName,
                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
                                                      modal=self.modalResults )
                except ParseBaseException as err:
                    #~ print "Exception raised in user parse action:", err
                    if (self.debugActions[2] ):
                        self.debugActions[2]( instring, tokensStart, self, err )
                    raise
            else:
                for fn in self.parseAction:
                    tokens = fn( instring, tokensStart, retTokens )
                    if tokens is not None:
                        retTokens = ParseResults( tokens,
                                                  self.resultsName,
                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
                                                  modal=self.modalResults )
        if debugging:
            #~ print ("Matched",self,"->",retTokens.asList())
            if (self.debugActions[1] ):
                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )

        return loc, retTokens

    def tryParse( self, instring, loc ):
        try:
            return self._parse( instring, loc, doActions=False )[0]
        except ParseFatalException:
            raise ParseException( instring, loc, self.errmsg, self)
    
    def canParseNext(self, instring, loc):
        try:
            self.tryParse(instring, loc)
        except (ParseException, IndexError):
            return False
        else:
            return True

    class _UnboundedCache(object):
        def __init__(self):
            cache = {}
            self.not_in_cache = not_in_cache = object()

            def get(self, key):
                return cache.get(key, not_in_cache)

            def set(self, key, value):
                cache[key] = value

            def clear(self):
                cache.clear()
                
            def cache_len(self):
                return len(cache)

            self.get = types.MethodType(get, self)
            self.set = types.MethodType(set, self)
            self.clear = types.MethodType(clear, self)
            self.__len__ = types.MethodType(cache_len, self)

    if _OrderedDict is not None:
        class _FifoCache(object):
            def __init__(self, size):
                self.not_in_cache = not_in_cache = object()

                cache = _OrderedDict()

                def get(self, key):
                    return cache.get(key, not_in_cache)

                def set(self, key, value):
                    cache[key] = value
                    while len(cache) > size:
                        try:
                            cache.popitem(False)
                        except KeyError:
                            pass

                def clear(self):
                    cache.clear()

                def cache_len(self):
                    return len(cache)

                self.get = types.MethodType(get, self)
                self.set = types.MethodType(set, self)
                self.clear = types.MethodType(clear, self)
                self.__len__ = types.MethodType(cache_len, self)

    else:
        class _FifoCache(object):
            def __init__(self, size):
                self.not_in_cache = not_in_cache = object()

                cache = {}
                key_fifo = collections.deque([], size)

                def get(self, key):
                    return cache.get(key, not_in_cache)

                def set(self, key, value):
                    cache[key] = value
                    while len(key_fifo) > size:
                        cache.pop(key_fifo.popleft(), None)
                    key_fifo.append(key)

                def clear(self):
                    cache.clear()
                    key_fifo.clear()

                def cache_len(self):
                    return len(cache)

                self.get = types.MethodType(get, self)
                self.set = types.MethodType(set, self)
                self.clear = types.MethodType(clear, self)
                self.__len__ = types.MethodType(cache_len, self)

    # argument cache for optimizing repeated calls when backtracking through recursive expressions
    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail
    packrat_cache_lock = RLock()
    packrat_cache_stats = [0, 0]

    # this method gets repeatedly called during backtracking with the same arguments -
    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
        HIT, MISS = 0, 1
        lookup = (self, instring, loc, callPreParse, doActions)
        with ParserElement.packrat_cache_lock:
            cache = ParserElement.packrat_cache
            value = cache.get(lookup)
            if value is cache.not_in_cache:
                ParserElement.packrat_cache_stats[MISS] += 1
                try:
                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
                except ParseBaseException as pe:
                    # cache a copy of the exception, without the traceback
                    cache.set(lookup, pe.__class__(*pe.args))
                    raise
                else:
                    cache.set(lookup, (value[0], value[1].copy()))
                    return value
            else:
                ParserElement.packrat_cache_stats[HIT] += 1
                if isinstance(value, Exception):
                    raise value
                return (value[0], value[1].copy())

    _parse = _parseNoCache

    @staticmethod
    def resetCache():
        ParserElement.packrat_cache.clear()
        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)

    _packratEnabled = False
    @staticmethod
    def enablePackrat(cache_size_limit=128):
        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
           Repeated parse attempts at the same string location (which happens
           often in many complex grammars) can immediately return a cached value,
           instead of re-executing parsing/validating code.  Memoizing is done of
           both valid results and parsing exceptions.
           
           Parameters:
            - cache_size_limit - (default=C{128}) - if an integer value is provided
              will limit the size of the packrat cache; if None is passed, then
              the cache size will be unbounded; if 0 is passed, the cache will
              be effectively disabled.
            
           This speedup may break existing programs that use parse actions that
           have side-effects.  For this reason, packrat parsing is disabled when
           you first import pyparsing.  To activate the packrat feature, your
           program must call the class method C{ParserElement.enablePackrat()}.  If
           your program uses C{psyco} to "compile as you go", you must call
           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,
           Python will crash.  For best results, call C{enablePackrat()} immediately
           after importing pyparsing.
           
           Example::
               import pyparsing
               pyparsing.ParserElement.enablePackrat()
        """
        if not ParserElement._packratEnabled:
            ParserElement._packratEnabled = True
            if cache_size_limit is None:
                ParserElement.packrat_cache = ParserElement._UnboundedCache()
            else:
                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)
            ParserElement._parse = ParserElement._parseCache

    def parseString( self, instring, parseAll=False ):
        """
        Execute the parse expression with the given string.
        This is the main interface to the client code, once the complete
        expression has been built.

        If you want the grammar to require that the entire input string be
        successfully parsed, then set C{parseAll} to True (equivalent to ending
        the grammar with C{L{StringEnd()}}).

        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
        in order to report proper column numbers in parse actions.
        If the input string contains tabs and
        the grammar uses parse actions that use the C{loc} argument to index into the
        string being parsed, you can ensure you have a consistent view of the input
        string by:
         - calling C{parseWithTabs} on your grammar before calling C{parseString}
           (see L{I{parseWithTabs}})
         - define your parse action using the full C{(s,loc,toks)} signature, and
           reference the input string using the parse action's C{s} argument
         - explictly expand the tabs in your input string before calling
           C{parseString}
        
        Example::
            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']
            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text
        """
        ParserElement.resetCache()
        if not self.streamlined:
            self.streamline()
            #~ self.saveAsList = True
        for e in self.ignoreExprs:
            e.streamline()
        if not self.keepTabs:
            instring = instring.expandtabs()
        try:
            loc, tokens = self._parse( instring, 0 )
            if parseAll:
                loc = self.preParse( instring, loc )
                se = Empty() + StringEnd()
                se._parse( instring, loc )
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc
        else:
            return tokens

    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
        """
        Scan the input string for expression matches.  Each match will return the
        matching tokens, start location, and end location.  May be called with optional
        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If
        C{overlap} is specified, then overlapping matches will be reported.

        Note that the start and end locations are reported relative to the string
        being parsed.  See L{I{parseString}} for more information on parsing
        strings with embedded tabs.

        Example::
            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
            print(source)
            for tokens,start,end in Word(alphas).scanString(source):
                print(' '*start + '^'*(end-start))
                print(' '*start + tokens[0])
        
        prints::
        
            sldjf123lsdjjkf345sldkjf879lkjsfd987
            ^^^^^
            sldjf
                    ^^^^^^^
                    lsdjjkf
                              ^^^^^^
                              sldkjf
                                       ^^^^^^
                                       lkjsfd
        """
        if not self.streamlined:
            self.streamline()
        for e in self.ignoreExprs:
            e.streamline()

        if not self.keepTabs:
            instring = _ustr(instring).expandtabs()
        instrlen = len(instring)
        loc = 0
        preparseFn = self.preParse
        parseFn = self._parse
        ParserElement.resetCache()
        matches = 0
        try:
            while loc <= instrlen and matches < maxMatches:
                try:
                    preloc = preparseFn( instring, loc )
                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
                except ParseException:
                    loc = preloc+1
                else:
                    if nextLoc > loc:
                        matches += 1
                        yield tokens, preloc, nextLoc
                        if overlap:
                            nextloc = preparseFn( instring, loc )
                            if nextloc > loc:
                                loc = nextLoc
                            else:
                                loc += 1
                        else:
                            loc = nextLoc
                    else:
                        loc = preloc+1
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def transformString( self, instring ):
        """
        Extension to C{L{scanString}}, to modify matching text with modified tokens that may
        be returned from a parse action.  To use C{transformString}, define a grammar and
        attach a parse action to it that modifies the returned token list.
        Invoking C{transformString()} on a target string will then scan for matches,
        and replace the matched text patterns according to the logic in the parse
        action.  C{transformString()} returns the resulting transformed string.
        
        Example::
            wd = Word(alphas)
            wd.setParseAction(lambda toks: toks[0].title())
            
            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
        Prints::
            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
        """
        out = []
        lastE = 0
        # force preservation of s, to minimize unwanted transformation of string, and to
        # keep string locs straight between transformString and scanString
        self.keepTabs = True
        try:
            for t,s,e in self.scanString( instring ):
                out.append( instring[lastE:s] )
                if t:
                    if isinstance(t,ParseResults):
                        out += t.asList()
                    elif isinstance(t,list):
                        out += t
                    else:
                        out.append(t)
                lastE = e
            out.append(instring[lastE:])
            out = [o for o in out if o]
            return "".join(map(_ustr,_flatten(out)))
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def searchString( self, instring, maxMatches=_MAX_INT ):
        """
        Another extension to C{L{scanString}}, simplifying the access to the tokens found
        to match the given parse expression.  May be called with optional
        C{maxMatches} argument, to clip searching after 'n' matches are found.
        
        Example::
            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
            cap_word = Word(alphas.upper(), alphas.lower())
            
            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))

            # the sum() builtin can be used to merge results into a single ParseResults object
            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))
        prints::
            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
        """
        try:
            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
        """
        Generator method to split a string using the given expression as a separator.
        May be called with optional C{maxsplit} argument, to limit the number of splits;
        and the optional C{includeSeparators} argument (default=C{False}), if the separating
        matching text should be included in the split results.
        
        Example::        
            punc = oneOf(list(".,;:/-!?"))
            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
        prints::
            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
        """
        splits = 0
        last = 0
        for t,s,e in self.scanString(instring, maxMatches=maxsplit):
            yield instring[last:s]
            if includeSeparators:
                yield t[0]
            last = e
        yield instring[last:]

    def __add__(self, other ):
        """
        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement
        converts them to L{Literal}s by default.
        
        Example::
            greet = Word(alphas) + "," + Word(alphas) + "!"
            hello = "Hello, World!"
            print (hello, "->", greet.parseString(hello))
        Prints::
            Hello, World! -> ['Hello', ',', 'World', '!']
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return And( [ self, other ] )

    def __radd__(self, other ):
        """
        Implementation of + operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other + self

    def __sub__(self, other):
        """
        Implementation of - operator, returns C{L{And}} with error stop
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return self + And._ErrorStop() + other

    def __rsub__(self, other ):
        """
        Implementation of - operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other - self

    def __mul__(self,other):
        """
        Implementation of * operator, allows use of C{expr * 3} in place of
        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer
        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples
        may also include C{None} as in:
         - C{expr*(n,None)} or C{expr*(n,)} is equivalent
              to C{expr*n + L{ZeroOrMore}(expr)}
              (read as "at least n instances of C{expr}")
         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}
              (read as "0 to n instances of C{expr}")
         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}

        Note that C{expr*(None,n)} does not raise an exception if
        more than n exprs exist in the input stream; that is,
        C{expr*(None,n)} does not enforce a maximum number of expr
        occurrences.  If this behavior is desired, then write
        C{expr*(None,n) + ~expr}
        """
        if isinstance(other,int):
            minElements, optElements = other,0
        elif isinstance(other,tuple):
            other = (other + (None, None))[:2]
            if other[0] is None:
                other = (0, other[1])
            if isinstance(other[0],int) and other[1] is None:
                if other[0] == 0:
                    return ZeroOrMore(self)
                if other[0] == 1:
                    return OneOrMore(self)
                else:
                    return self*other[0] + ZeroOrMore(self)
            elif isinstance(other[0],int) and isinstance(other[1],int):
                minElements, optElements = other
                optElements -= minElements
            else:
                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
        else:
            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))

        if minElements < 0:
            raise ValueError("cannot multiply ParserElement by negative value")
        if optElements < 0:
            raise ValueError("second tuple value must be greater or equal to first tuple value")
        if minElements == optElements == 0:
            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")

        if (optElements):
            def makeOptionalList(n):
                if n>1:
                    return Optional(self + makeOptionalList(n-1))
                else:
                    return Optional(self)
            if minElements:
                if minElements == 1:
                    ret = self + makeOptionalList(optElements)
                else:
                    ret = And([self]*minElements) + makeOptionalList(optElements)
            else:
                ret = makeOptionalList(optElements)
        else:
            if minElements == 1:
                ret = self
            else:
                ret = And([self]*minElements)
        return ret

    def __rmul__(self, other):
        return self.__mul__(other)

    def __or__(self, other ):
        """
        Implementation of | operator - returns C{L{MatchFirst}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return MatchFirst( [ self, other ] )

    def __ror__(self, other ):
        """
        Implementation of | operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other | self

    def __xor__(self, other ):
        """
        Implementation of ^ operator - returns C{L{Or}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return Or( [ self, other ] )

    def __rxor__(self, other ):
        """
        Implementation of ^ operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other ^ self

    def __and__(self, other ):
        """
        Implementation of & operator - returns C{L{Each}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return Each( [ self, other ] )

    def __rand__(self, other ):
        """
        Implementation of & operator when left operand is not a C{L{ParserElement}}
        """
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        if not isinstance( other, ParserElement ):
            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
                    SyntaxWarning, stacklevel=2)
            return None
        return other & self

    def __invert__( self ):
        """
        Implementation of ~ operator - returns C{L{NotAny}}
        """
        return NotAny( self )

    def __call__(self, name=None):
        """
        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.
        
        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
        passed as C{True}.
           
        If C{name} is omitted, same as calling C{L{copy}}.

        Example::
            # these are equivalent
            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             
        """
        if name is not None:
            return self.setResultsName(name)
        else:
            return self.copy()

    def suppress( self ):
        """
        Suppresses the output of this C{ParserElement}; useful to keep punctuation from
        cluttering up returned output.
        """
        return Suppress( self )

    def leaveWhitespace( self ):
        """
        Disables the skipping of whitespace before matching the characters in the
        C{ParserElement}'s defined pattern.  This is normally only used internally by
        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
        """
        self.skipWhitespace = False
        return self

    def setWhitespaceChars( self, chars ):
        """
        Overrides the default whitespace chars
        """
        self.skipWhitespace = True
        self.whiteChars = chars
        self.copyDefaultWhiteChars = False
        return self

    def parseWithTabs( self ):
        """
        Overrides default behavior to expand C{}s to spaces before parsing the input string.
        Must be called before C{parseString} when the input grammar contains elements that
        match C{} characters.
        """
        self.keepTabs = True
        return self

    def ignore( self, other ):
        """
        Define expression to be ignored (e.g., comments) while doing pattern
        matching; may be called repeatedly, to define multiple comment or other
        ignorable patterns.
        
        Example::
            patt = OneOrMore(Word(alphas))
            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
            
            patt.ignore(cStyleComment)
            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
        """
        if isinstance(other, basestring):
            other = Suppress(other)

        if isinstance( other, Suppress ):
            if other not in self.ignoreExprs:
                self.ignoreExprs.append(other)
        else:
            self.ignoreExprs.append( Suppress( other.copy() ) )
        return self

    def setDebugActions( self, startAction, successAction, exceptionAction ):
        """
        Enable display of debugging messages while doing pattern matching.
        """
        self.debugActions = (startAction or _defaultStartDebugAction,
                             successAction or _defaultSuccessDebugAction,
                             exceptionAction or _defaultExceptionDebugAction)
        self.debug = True
        return self

    def setDebug( self, flag=True ):
        """
        Enable display of debugging messages while doing pattern matching.
        Set C{flag} to True to enable, False to disable.

        Example::
            wd = Word(alphas).setName("alphaword")
            integer = Word(nums).setName("numword")
            term = wd | integer
            
            # turn on debugging for wd
            wd.setDebug()

            OneOrMore(term).parseString("abc 123 xyz 890")
        
        prints::
            Match alphaword at loc 0(1,1)
            Matched alphaword -> ['abc']
            Match alphaword at loc 3(1,4)
            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
            Match alphaword at loc 7(1,8)
            Matched alphaword -> ['xyz']
            Match alphaword at loc 11(1,12)
            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
            Match alphaword at loc 15(1,16)
            Exception raised:Expected alphaword (at char 15), (line:1, col:16)

        The output shown is that produced by the default debug actions - custom debug actions can be
        specified using L{setDebugActions}. Prior to attempting
        to match the C{wd} expression, the debugging message C{"Match  at loc (,)"}
        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}
        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,
        which makes debugging and exception messages easier to understand - for instance, the default
        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.
        """
        if flag:
            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
        else:
            self.debug = False
        return self

    def __str__( self ):
        return self.name

    def __repr__( self ):
        return _ustr(self)

    def streamline( self ):
        self.streamlined = True
        self.strRepr = None
        return self

    def checkRecursion( self, parseElementList ):
        pass

    def validate( self, validateTrace=[] ):
        """
        Check defined expressions for valid structure, check for infinite recursive definitions.
        """
        self.checkRecursion( [] )

    def parseFile( self, file_or_filename, parseAll=False ):
        """
        Execute the parse expression on the given file or filename.
        If a filename is specified (instead of a file object),
        the entire file is opened, read, and closed before parsing.
        """
        try:
            file_contents = file_or_filename.read()
        except AttributeError:
            with open(file_or_filename, "r") as f:
                file_contents = f.read()
        try:
            return self.parseString(file_contents, parseAll)
        except ParseBaseException as exc:
            if ParserElement.verbose_stacktrace:
                raise
            else:
                # catch and re-raise exception from here, clears out pyparsing internal stack trace
                raise exc

    def __eq__(self,other):
        if isinstance(other, ParserElement):
            return self is other or vars(self) == vars(other)
        elif isinstance(other, basestring):
            return self.matches(other)
        else:
            return super(ParserElement,self)==other

    def __ne__(self,other):
        return not (self == other)

    def __hash__(self):
        return hash(id(self))

    def __req__(self,other):
        return self == other

    def __rne__(self,other):
        return not (self == other)

    def matches(self, testString, parseAll=True):
        """
        Method for quick testing of a parser against a test string. Good for simple 
        inline microtests of sub expressions while building up larger parser.
           
        Parameters:
         - testString - to test against this expression for a match
         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
            
        Example::
            expr = Word(nums)
            assert expr.matches("100")
        """
        try:
            self.parseString(_ustr(testString), parseAll=parseAll)
            return True
        except ParseBaseException:
            return False
                
    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):
        """
        Execute the parse expression on a series of test strings, showing each
        test, the parsed results or where the parse failed. Quick and easy way to
        run a parse expression against a list of sample strings.
           
        Parameters:
         - tests - a list of separate test strings, or a multiline string of test strings
         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           
         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 
              string; pass None to disable comment filtering
         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;
              if False, only dump nested list
         - printResults - (default=C{True}) prints test output to stdout
         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing

        Returns: a (success, results) tuple, where success indicates that all tests succeeded
        (or failed if C{failureTests} is True), and the results contain a list of lines of each 
        test's output
        
        Example::
            number_expr = pyparsing_common.number.copy()

            result = number_expr.runTests('''
                # unsigned integer
                100
                # negative integer
                -100
                # float with scientific notation
                6.02e23
                # integer with scientific notation
                1e-12
                ''')
            print("Success" if result[0] else "Failed!")

            result = number_expr.runTests('''
                # stray character
                100Z
                # missing leading digit before '.'
                -.100
                # too many '.'
                3.14.159
                ''', failureTests=True)
            print("Success" if result[0] else "Failed!")
        prints::
            # unsigned integer
            100
            [100]

            # negative integer
            -100
            [-100]

            # float with scientific notation
            6.02e23
            [6.02e+23]

            # integer with scientific notation
            1e-12
            [1e-12]

            Success
            
            # stray character
            100Z
               ^
            FAIL: Expected end of text (at char 3), (line:1, col:4)

            # missing leading digit before '.'
            -.100
            ^
            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)

            # too many '.'
            3.14.159
                ^
            FAIL: Expected end of text (at char 4), (line:1, col:5)

            Success

        Each test string must be on a single line. If you want to test a string that spans multiple
        lines, create a test like this::

            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")
        
        (Note that this is a raw string literal, you must include the leading 'r'.)
        """
        if isinstance(tests, basestring):
            tests = list(map(str.strip, tests.rstrip().splitlines()))
        if isinstance(comment, basestring):
            comment = Literal(comment)
        allResults = []
        comments = []
        success = True
        for t in tests:
            if comment is not None and comment.matches(t, False) or comments and not t:
                comments.append(t)
                continue
            if not t:
                continue
            out = ['\n'.join(comments), t]
            comments = []
            try:
                t = t.replace(r'\n','\n')
                result = self.parseString(t, parseAll=parseAll)
                out.append(result.dump(full=fullDump))
                success = success and not failureTests
            except ParseBaseException as pe:
                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
                if '\n' in t:
                    out.append(line(pe.loc, t))
                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)
                else:
                    out.append(' '*pe.loc + '^' + fatal)
                out.append("FAIL: " + str(pe))
                success = success and failureTests
                result = pe
            except Exception as exc:
                out.append("FAIL-EXCEPTION: " + str(exc))
                success = success and failureTests
                result = exc

            if printResults:
                if fullDump:
                    out.append('')
                print('\n'.join(out))

            allResults.append((t, result))
        
        return success, allResults

        
class Token(ParserElement):
    """
    Abstract C{ParserElement} subclass, for defining atomic matching patterns.
    """
    def __init__( self ):
        super(Token,self).__init__( savelist=False )


class Empty(Token):
    """
    An empty token, will always match.
    """
    def __init__( self ):
        super(Empty,self).__init__()
        self.name = "Empty"
        self.mayReturnEmpty = True
        self.mayIndexError = False


class NoMatch(Token):
    """
    A token that will never match.
    """
    def __init__( self ):
        super(NoMatch,self).__init__()
        self.name = "NoMatch"
        self.mayReturnEmpty = True
        self.mayIndexError = False
        self.errmsg = "Unmatchable token"

    def parseImpl( self, instring, loc, doActions=True ):
        raise ParseException(instring, loc, self.errmsg, self)


class Literal(Token):
    """
    Token to exactly match a specified string.
    
    Example::
        Literal('blah').parseString('blah')  # -> ['blah']
        Literal('blah').parseString('blahfooblah')  # -> ['blah']
        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"
    
    For case-insensitive matching, use L{CaselessLiteral}.
    
    For keyword matching (force word break before and after the matched string),
    use L{Keyword} or L{CaselessKeyword}.
    """
    def __init__( self, matchString ):
        super(Literal,self).__init__()
        self.match = matchString
        self.matchLen = len(matchString)
        try:
            self.firstMatchChar = matchString[0]
        except IndexError:
            warnings.warn("null string passed to Literal; use Empty() instead",
                            SyntaxWarning, stacklevel=2)
            self.__class__ = Empty
        self.name = '"%s"' % _ustr(self.match)
        self.errmsg = "Expected " + self.name
        self.mayReturnEmpty = False
        self.mayIndexError = False

    # Performance tuning: this routine gets called a *lot*
    # if this is a single character match string  and the first character matches,
    # short-circuit as quickly as possible, and avoid calling startswith
    #~ @profile
    def parseImpl( self, instring, loc, doActions=True ):
        if (instring[loc] == self.firstMatchChar and
            (self.matchLen==1 or instring.startswith(self.match,loc)) ):
            return loc+self.matchLen, self.match
        raise ParseException(instring, loc, self.errmsg, self)
_L = Literal
ParserElement._literalStringClass = Literal

class Keyword(Token):
    """
    Token to exactly match a specified string as a keyword, that is, it must be
    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:
     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.
     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
    Accepts two optional constructor arguments in addition to the keyword string:
     - C{identChars} is a string of characters that would be valid identifier characters,
          defaulting to all alphanumerics + "_" and "$"
     - C{caseless} allows case-insensitive matching, default is C{False}.
       
    Example::
        Keyword("start").parseString("start")  # -> ['start']
        Keyword("start").parseString("starting")  # -> Exception

    For case-insensitive matching, use L{CaselessKeyword}.
    """
    DEFAULT_KEYWORD_CHARS = alphanums+"_$"

    def __init__( self, matchString, identChars=None, caseless=False ):
        super(Keyword,self).__init__()
        if identChars is None:
            identChars = Keyword.DEFAULT_KEYWORD_CHARS
        self.match = matchString
        self.matchLen = len(matchString)
        try:
            self.firstMatchChar = matchString[0]
        except IndexError:
            warnings.warn("null string passed to Keyword; use Empty() instead",
                            SyntaxWarning, stacklevel=2)
        self.name = '"%s"' % self.match
        self.errmsg = "Expected " + self.name
        self.mayReturnEmpty = False
        self.mayIndexError = False
        self.caseless = caseless
        if caseless:
            self.caselessmatch = matchString.upper()
            identChars = identChars.upper()
        self.identChars = set(identChars)

    def parseImpl( self, instring, loc, doActions=True ):
        if self.caseless:
            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):
                return loc+self.matchLen, self.match
        else:
            if (instring[loc] == self.firstMatchChar and
                (self.matchLen==1 or instring.startswith(self.match,loc)) and
                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
                (loc == 0 or instring[loc-1] not in self.identChars) ):
                return loc+self.matchLen, self.match
        raise ParseException(instring, loc, self.errmsg, self)

    def copy(self):
        c = super(Keyword,self).copy()
        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
        return c

    @staticmethod
    def setDefaultKeywordChars( chars ):
        """Overrides the default Keyword chars
        """
        Keyword.DEFAULT_KEYWORD_CHARS = chars

class CaselessLiteral(Literal):
    """
    Token to match a specified string, ignoring case of letters.
    Note: the matched results will always be in the case of the given
    match string, NOT the case of the input text.

    Example::
        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
        
    (Contrast with example for L{CaselessKeyword}.)
    """
    def __init__( self, matchString ):
        super(CaselessLiteral,self).__init__( matchString.upper() )
        # Preserve the defining literal.
        self.returnString = matchString
        self.name = "'%s'" % self.returnString
        self.errmsg = "Expected " + self.name

    def parseImpl( self, instring, loc, doActions=True ):
        if instring[ loc:loc+self.matchLen ].upper() == self.match:
            return loc+self.matchLen, self.returnString
        raise ParseException(instring, loc, self.errmsg, self)

class CaselessKeyword(Keyword):
    """
    Caseless version of L{Keyword}.

    Example::
        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
        
    (Contrast with example for L{CaselessLiteral}.)
    """
    def __init__( self, matchString, identChars=None ):
        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )

    def parseImpl( self, instring, loc, doActions=True ):
        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
            return loc+self.matchLen, self.match
        raise ParseException(instring, loc, self.errmsg, self)

class CloseMatch(Token):
    """
    A variation on L{Literal} which matches "close" matches, that is, 
    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:
     - C{match_string} - string to be matched
     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match
    
    The results from a successful parse will contain the matched text from the input string and the following named results:
     - C{mismatches} - a list of the positions within the match_string where mismatches were found
     - C{original} - the original match_string used to compare against the input string
    
    If C{mismatches} is an empty list, then the match was an exact match.
    
    Example::
        patt = CloseMatch("ATCATCGAATGGA")
        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)

        # exact match
        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})

        # close match allowing up to 2 mismatches
        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
    """
    def __init__(self, match_string, maxMismatches=1):
        super(CloseMatch,self).__init__()
        self.name = match_string
        self.match_string = match_string
        self.maxMismatches = maxMismatches
        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)
        self.mayIndexError = False
        self.mayReturnEmpty = False

    def parseImpl( self, instring, loc, doActions=True ):
        start = loc
        instrlen = len(instring)
        maxloc = start + len(self.match_string)

        if maxloc <= instrlen:
            match_string = self.match_string
            match_stringloc = 0
            mismatches = []
            maxMismatches = self.maxMismatches

            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):
                src,mat = s_m
                if src != mat:
                    mismatches.append(match_stringloc)
                    if len(mismatches) > maxMismatches:
                        break
            else:
                loc = match_stringloc + 1
                results = ParseResults([instring[start:loc]])
                results['original'] = self.match_string
                results['mismatches'] = mismatches
                return loc, results

        raise ParseException(instring, loc, self.errmsg, self)


class Word(Token):
    """
    Token for matching words composed of allowed character sets.
    Defined with string containing all allowed initial characters,
    an optional string containing allowed body characters (if omitted,
    defaults to the initial character set), and an optional minimum,
    maximum, and/or exact length.  The default value for C{min} is 1 (a
    minimum value < 1 is not valid); the default values for C{max} and C{exact}
    are 0, meaning no maximum or exact length restriction. An optional
    C{excludeChars} parameter can list characters that might be found in 
    the input C{bodyChars} string; useful to define a word of all printables
    except for one or two characters, for instance.
    
    L{srange} is useful for defining custom character set strings for defining 
    C{Word} expressions, using range notation from regular expression character sets.
    
    A common mistake is to use C{Word} to match a specific literal string, as in 
    C{Word("Address")}. Remember that C{Word} uses the string argument to define
    I{sets} of matchable characters. This expression would match "Add", "AAA",
    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.
    To match an exact literal string, use L{Literal} or L{Keyword}.

    pyparsing includes helper strings for building Words:
     - L{alphas}
     - L{nums}
     - L{alphanums}
     - L{hexnums}
     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)
     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)
     - L{printables} (any non-whitespace character)

    Example::
        # a word composed of digits
        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
        
        # a word with a leading capital, and zero or more lowercase
        capital_word = Word(alphas.upper(), alphas.lower())

        # hostnames are alphanumeric, with leading alpha, and '-'
        hostname = Word(alphas, alphanums+'-')
        
        # roman numeral (not a strict parser, accepts invalid mix of characters)
        roman = Word("IVXLCDM")
        
        # any string of non-whitespace characters, except for ','
        csv_value = Word(printables, excludeChars=",")
    """
    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
        super(Word,self).__init__()
        if excludeChars:
            initChars = ''.join(c for c in initChars if c not in excludeChars)
            if bodyChars:
                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
        self.initCharsOrig = initChars
        self.initChars = set(initChars)
        if bodyChars :
            self.bodyCharsOrig = bodyChars
            self.bodyChars = set(bodyChars)
        else:
            self.bodyCharsOrig = initChars
            self.bodyChars = set(initChars)

        self.maxSpecified = max > 0

        if min < 1:
            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")

        self.minLen = min

        if max > 0:
            self.maxLen = max
        else:
            self.maxLen = _MAX_INT

        if exact > 0:
            self.maxLen = exact
            self.minLen = exact

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayIndexError = False
        self.asKeyword = asKeyword

        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
            if self.bodyCharsOrig == self.initCharsOrig:
                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
            elif len(self.initCharsOrig) == 1:
                self.reString = "%s[%s]*" % \
                                      (re.escape(self.initCharsOrig),
                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
            else:
                self.reString = "[%s][%s]*" % \
                                      (_escapeRegexRangeChars(self.initCharsOrig),
                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
            if self.asKeyword:
                self.reString = r"\b"+self.reString+r"\b"
            try:
                self.re = re.compile( self.reString )
            except Exception:
                self.re = None

    def parseImpl( self, instring, loc, doActions=True ):
        if self.re:
            result = self.re.match(instring,loc)
            if not result:
                raise ParseException(instring, loc, self.errmsg, self)

            loc = result.end()
            return loc, result.group()

        if not(instring[ loc ] in self.initChars):
            raise ParseException(instring, loc, self.errmsg, self)

        start = loc
        loc += 1
        instrlen = len(instring)
        bodychars = self.bodyChars
        maxloc = start + self.maxLen
        maxloc = min( maxloc, instrlen )
        while loc < maxloc and instring[loc] in bodychars:
            loc += 1

        throwException = False
        if loc - start < self.minLen:
            throwException = True
        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
            throwException = True
        if self.asKeyword:
            if (start>0 and instring[start-1] in bodychars) or (loc4:
                    return s[:4]+"..."
                else:
                    return s

            if ( self.initCharsOrig != self.bodyCharsOrig ):
                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
            else:
                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)

        return self.strRepr


class Regex(Token):
    r"""
    Token for matching strings that match a given regular expression.
    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
    If the given regex contains named groups (defined using C{(?P...)}), these will be preserved as 
    named parse results.

    Example::
        realnum = Regex(r"[+-]?\d+\.\d*")
        date = Regex(r'(?P\d{4})-(?P\d\d?)-(?P\d\d?)')
        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
    """
    compiledREtype = type(re.compile("[A-Z]"))
    def __init__( self, pattern, flags=0):
        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
        super(Regex,self).__init__()

        if isinstance(pattern, basestring):
            if not pattern:
                warnings.warn("null string passed to Regex; use Empty() instead",
                        SyntaxWarning, stacklevel=2)

            self.pattern = pattern
            self.flags = flags

            try:
                self.re = re.compile(self.pattern, self.flags)
                self.reString = self.pattern
            except sre_constants.error:
                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
                    SyntaxWarning, stacklevel=2)
                raise

        elif isinstance(pattern, Regex.compiledREtype):
            self.re = pattern
            self.pattern = \
            self.reString = str(pattern)
            self.flags = flags
            
        else:
            raise ValueError("Regex may only be constructed with a string or a compiled RE object")

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayIndexError = False
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        result = self.re.match(instring,loc)
        if not result:
            raise ParseException(instring, loc, self.errmsg, self)

        loc = result.end()
        d = result.groupdict()
        ret = ParseResults(result.group())
        if d:
            for k in d:
                ret[k] = d[k]
        return loc,ret

    def __str__( self ):
        try:
            return super(Regex,self).__str__()
        except Exception:
            pass

        if self.strRepr is None:
            self.strRepr = "Re:(%s)" % repr(self.pattern)

        return self.strRepr


class QuotedString(Token):
    r"""
    Token for matching strings that are delimited by quoting characters.
    
    Defined with the following parameters:
        - quoteChar - string of one or more characters defining the quote delimiting string
        - escChar - character to escape quotes, typically backslash (default=C{None})
        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})
        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})

    Example::
        qs = QuotedString('"')
        print(qs.searchString('lsjdf "This is the quote" sldjf'))
        complex_qs = QuotedString('{{', endQuoteChar='}}')
        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
        sql_qs = QuotedString('"', escQuote='""')
        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
    prints::
        [['This is the quote']]
        [['This is the "quote"']]
        [['This is the quote with "embedded" quotes']]
    """
    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
        super(QuotedString,self).__init__()

        # remove white space from quote chars - wont work anyway
        quoteChar = quoteChar.strip()
        if not quoteChar:
            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
            raise SyntaxError()

        if endQuoteChar is None:
            endQuoteChar = quoteChar
        else:
            endQuoteChar = endQuoteChar.strip()
            if not endQuoteChar:
                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
                raise SyntaxError()

        self.quoteChar = quoteChar
        self.quoteCharLen = len(quoteChar)
        self.firstQuoteChar = quoteChar[0]
        self.endQuoteChar = endQuoteChar
        self.endQuoteCharLen = len(endQuoteChar)
        self.escChar = escChar
        self.escQuote = escQuote
        self.unquoteResults = unquoteResults
        self.convertWhitespaceEscapes = convertWhitespaceEscapes

        if multiline:
            self.flags = re.MULTILINE | re.DOTALL
            self.pattern = r'%s(?:[^%s%s]' % \
                ( re.escape(self.quoteChar),
                  _escapeRegexRangeChars(self.endQuoteChar[0]),
                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
        else:
            self.flags = 0
            self.pattern = r'%s(?:[^%s\n\r%s]' % \
                ( re.escape(self.quoteChar),
                  _escapeRegexRangeChars(self.endQuoteChar[0]),
                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
        if len(self.endQuoteChar) > 1:
            self.pattern += (
                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'
                )
        if escQuote:
            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
        if escChar:
            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))

        try:
            self.re = re.compile(self.pattern, self.flags)
            self.reString = self.pattern
        except sre_constants.error:
            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
                SyntaxWarning, stacklevel=2)
            raise

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayIndexError = False
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
        if not result:
            raise ParseException(instring, loc, self.errmsg, self)

        loc = result.end()
        ret = result.group()

        if self.unquoteResults:

            # strip off quotes
            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]

            if isinstance(ret,basestring):
                # replace escaped whitespace
                if '\\' in ret and self.convertWhitespaceEscapes:
                    ws_map = {
                        r'\t' : '\t',
                        r'\n' : '\n',
                        r'\f' : '\f',
                        r'\r' : '\r',
                    }
                    for wslit,wschar in ws_map.items():
                        ret = ret.replace(wslit, wschar)

                # replace escaped characters
                if self.escChar:
                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)

                # replace escaped quotes
                if self.escQuote:
                    ret = ret.replace(self.escQuote, self.endQuoteChar)

        return loc, ret

    def __str__( self ):
        try:
            return super(QuotedString,self).__str__()
        except Exception:
            pass

        if self.strRepr is None:
            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)

        return self.strRepr


class CharsNotIn(Token):
    """
    Token for matching words composed of characters I{not} in a given set (will
    include whitespace in matched characters if not listed in the provided exclusion set - see example).
    Defined with string containing all disallowed characters, and an optional
    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a
    minimum value < 1 is not valid); the default values for C{max} and C{exact}
    are 0, meaning no maximum or exact length restriction.

    Example::
        # define a comma-separated-value as anything that is not a ','
        csv_value = CharsNotIn(',')
        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
    prints::
        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
    """
    def __init__( self, notChars, min=1, max=0, exact=0 ):
        super(CharsNotIn,self).__init__()
        self.skipWhitespace = False
        self.notChars = notChars

        if min < 1:
            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")

        self.minLen = min

        if max > 0:
            self.maxLen = max
        else:
            self.maxLen = _MAX_INT

        if exact > 0:
            self.maxLen = exact
            self.minLen = exact

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        self.mayReturnEmpty = ( self.minLen == 0 )
        self.mayIndexError = False

    def parseImpl( self, instring, loc, doActions=True ):
        if instring[loc] in self.notChars:
            raise ParseException(instring, loc, self.errmsg, self)

        start = loc
        loc += 1
        notchars = self.notChars
        maxlen = min( start+self.maxLen, len(instring) )
        while loc < maxlen and \
              (instring[loc] not in notchars):
            loc += 1

        if loc - start < self.minLen:
            raise ParseException(instring, loc, self.errmsg, self)

        return loc, instring[start:loc]

    def __str__( self ):
        try:
            return super(CharsNotIn, self).__str__()
        except Exception:
            pass

        if self.strRepr is None:
            if len(self.notChars) > 4:
                self.strRepr = "!W:(%s...)" % self.notChars[:4]
            else:
                self.strRepr = "!W:(%s)" % self.notChars

        return self.strRepr

class White(Token):
    """
    Special matching class for matching whitespace.  Normally, whitespace is ignored
    by pyparsing grammars.  This class is included when some whitespace structures
    are significant.  Define with a string containing the whitespace characters to be
    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,
    as defined for the C{L{Word}} class.
    """
    whiteStrs = {
        " " : "",
        "\t": "",
        "\n": "",
        "\r": "",
        "\f": "",
        }
    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
        super(White,self).__init__()
        self.matchWhite = ws
        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
        #~ self.leaveWhitespace()
        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
        self.mayReturnEmpty = True
        self.errmsg = "Expected " + self.name

        self.minLen = min

        if max > 0:
            self.maxLen = max
        else:
            self.maxLen = _MAX_INT

        if exact > 0:
            self.maxLen = exact
            self.minLen = exact

    def parseImpl( self, instring, loc, doActions=True ):
        if not(instring[ loc ] in self.matchWhite):
            raise ParseException(instring, loc, self.errmsg, self)
        start = loc
        loc += 1
        maxloc = start + self.maxLen
        maxloc = min( maxloc, len(instring) )
        while loc < maxloc and instring[loc] in self.matchWhite:
            loc += 1

        if loc - start < self.minLen:
            raise ParseException(instring, loc, self.errmsg, self)

        return loc, instring[start:loc]


class _PositionToken(Token):
    def __init__( self ):
        super(_PositionToken,self).__init__()
        self.name=self.__class__.__name__
        self.mayReturnEmpty = True
        self.mayIndexError = False

class GoToColumn(_PositionToken):
    """
    Token to advance to a specific column of input text; useful for tabular report scraping.
    """
    def __init__( self, colno ):
        super(GoToColumn,self).__init__()
        self.col = colno

    def preParse( self, instring, loc ):
        if col(loc,instring) != self.col:
            instrlen = len(instring)
            if self.ignoreExprs:
                loc = self._skipIgnorables( instring, loc )
            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
                loc += 1
        return loc

    def parseImpl( self, instring, loc, doActions=True ):
        thiscol = col( loc, instring )
        if thiscol > self.col:
            raise ParseException( instring, loc, "Text not in expected column", self )
        newloc = loc + self.col - thiscol
        ret = instring[ loc: newloc ]
        return newloc, ret


class LineStart(_PositionToken):
    """
    Matches if current position is at the beginning of a line within the parse string
    
    Example::
    
        test = '''\
        AAA this line
        AAA and this line
          AAA but not this one
        B AAA and definitely not this one
        '''

        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
            print(t)
    
    Prints::
        ['AAA', ' this line']
        ['AAA', ' and this line']    

    """
    def __init__( self ):
        super(LineStart,self).__init__()
        self.errmsg = "Expected start of line"

    def parseImpl( self, instring, loc, doActions=True ):
        if col(loc, instring) == 1:
            return loc, []
        raise ParseException(instring, loc, self.errmsg, self)

class LineEnd(_PositionToken):
    """
    Matches if current position is at the end of a line within the parse string
    """
    def __init__( self ):
        super(LineEnd,self).__init__()
        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
        self.errmsg = "Expected end of line"

    def parseImpl( self, instring, loc, doActions=True ):
        if loc len(instring):
            return loc, []
        else:
            raise ParseException(instring, loc, self.errmsg, self)

class WordStart(_PositionToken):
    """
    Matches if the current position is at the beginning of a Word, and
    is not preceded by any character in a given set of C{wordChars}
    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
    the string being parsed, or at the beginning of a line.
    """
    def __init__(self, wordChars = printables):
        super(WordStart,self).__init__()
        self.wordChars = set(wordChars)
        self.errmsg = "Not at the start of a word"

    def parseImpl(self, instring, loc, doActions=True ):
        if loc != 0:
            if (instring[loc-1] in self.wordChars or
                instring[loc] not in self.wordChars):
                raise ParseException(instring, loc, self.errmsg, self)
        return loc, []

class WordEnd(_PositionToken):
    """
    Matches if the current position is at the end of a Word, and
    is not followed by any character in a given set of C{wordChars}
    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
    the string being parsed, or at the end of a line.
    """
    def __init__(self, wordChars = printables):
        super(WordEnd,self).__init__()
        self.wordChars = set(wordChars)
        self.skipWhitespace = False
        self.errmsg = "Not at the end of a word"

    def parseImpl(self, instring, loc, doActions=True ):
        instrlen = len(instring)
        if instrlen>0 and loc maxExcLoc:
                    maxException = err
                    maxExcLoc = err.loc
            except IndexError:
                if len(instring) > maxExcLoc:
                    maxException = ParseException(instring,len(instring),e.errmsg,self)
                    maxExcLoc = len(instring)
            else:
                # save match among all matches, to retry longest to shortest
                matches.append((loc2, e))

        if matches:
            matches.sort(key=lambda x: -x[0])
            for _,e in matches:
                try:
                    return e._parse( instring, loc, doActions )
                except ParseException as err:
                    err.__traceback__ = None
                    if err.loc > maxExcLoc:
                        maxException = err
                        maxExcLoc = err.loc

        if maxException is not None:
            maxException.msg = self.errmsg
            raise maxException
        else:
            raise ParseException(instring, loc, "no defined alternatives to match", self)


    def __ixor__(self, other ):
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        return self.append( other ) #Or( [ self, other ] )

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"

        return self.strRepr

    def checkRecursion( self, parseElementList ):
        subRecCheckList = parseElementList[:] + [ self ]
        for e in self.exprs:
            e.checkRecursion( subRecCheckList )


class MatchFirst(ParseExpression):
    """
    Requires that at least one C{ParseExpression} is found.
    If two expressions match, the first one listed is the one that will match.
    May be constructed using the C{'|'} operator.

    Example::
        # construct MatchFirst using '|' operator
        
        # watch the order of expressions to match
        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]

        # put more selective expression first
        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
    """
    def __init__( self, exprs, savelist = False ):
        super(MatchFirst,self).__init__(exprs, savelist)
        if self.exprs:
            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
        else:
            self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        maxExcLoc = -1
        maxException = None
        for e in self.exprs:
            try:
                ret = e._parse( instring, loc, doActions )
                return ret
            except ParseException as err:
                if err.loc > maxExcLoc:
                    maxException = err
                    maxExcLoc = err.loc
            except IndexError:
                if len(instring) > maxExcLoc:
                    maxException = ParseException(instring,len(instring),e.errmsg,self)
                    maxExcLoc = len(instring)

        # only got here if no expression matched, raise exception for match that made it the furthest
        else:
            if maxException is not None:
                maxException.msg = self.errmsg
                raise maxException
            else:
                raise ParseException(instring, loc, "no defined alternatives to match", self)

    def __ior__(self, other ):
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass( other )
        return self.append( other ) #MatchFirst( [ self, other ] )

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"

        return self.strRepr

    def checkRecursion( self, parseElementList ):
        subRecCheckList = parseElementList[:] + [ self ]
        for e in self.exprs:
            e.checkRecursion( subRecCheckList )


class Each(ParseExpression):
    """
    Requires all given C{ParseExpression}s to be found, but in any order.
    Expressions may be separated by whitespace.
    May be constructed using the C{'&'} operator.

    Example::
        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
        integer = Word(nums)
        shape_attr = "shape:" + shape_type("shape")
        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
        color_attr = "color:" + color("color")
        size_attr = "size:" + integer("size")

        # use Each (using operator '&') to accept attributes in any order 
        # (shape and posn are required, color and size are optional)
        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)

        shape_spec.runTests('''
            shape: SQUARE color: BLACK posn: 100, 120
            shape: CIRCLE size: 50 color: BLUE posn: 50,80
            color:GREEN size:20 shape:TRIANGLE posn:20,40
            '''
            )
    prints::
        shape: SQUARE color: BLACK posn: 100, 120
        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
        - color: BLACK
        - posn: ['100', ',', '120']
          - x: 100
          - y: 120
        - shape: SQUARE


        shape: CIRCLE size: 50 color: BLUE posn: 50,80
        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
        - color: BLUE
        - posn: ['50', ',', '80']
          - x: 50
          - y: 80
        - shape: CIRCLE
        - size: 50


        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
        - color: GREEN
        - posn: ['20', ',', '40']
          - x: 20
          - y: 40
        - shape: TRIANGLE
        - size: 20
    """
    def __init__( self, exprs, savelist = True ):
        super(Each,self).__init__(exprs, savelist)
        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
        self.skipWhitespace = True
        self.initExprGroups = True

    def parseImpl( self, instring, loc, doActions=True ):
        if self.initExprGroups:
            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))
            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]
            self.optionals = opt1 + opt2
            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
            self.required += self.multirequired
            self.initExprGroups = False
        tmpLoc = loc
        tmpReqd = self.required[:]
        tmpOpt  = self.optionals[:]
        matchOrder = []

        keepMatching = True
        while keepMatching:
            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
            failed = []
            for e in tmpExprs:
                try:
                    tmpLoc = e.tryParse( instring, tmpLoc )
                except ParseException:
                    failed.append(e)
                else:
                    matchOrder.append(self.opt1map.get(id(e),e))
                    if e in tmpReqd:
                        tmpReqd.remove(e)
                    elif e in tmpOpt:
                        tmpOpt.remove(e)
            if len(failed) == len(tmpExprs):
                keepMatching = False

        if tmpReqd:
            missing = ", ".join(_ustr(e) for e in tmpReqd)
            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )

        # add any unmatched Optionals, in case they have default values defined
        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]

        resultlist = []
        for e in matchOrder:
            loc,results = e._parse(instring,loc,doActions)
            resultlist.append(results)

        finalResults = sum(resultlist, ParseResults([]))
        return loc, finalResults

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"

        return self.strRepr

    def checkRecursion( self, parseElementList ):
        subRecCheckList = parseElementList[:] + [ self ]
        for e in self.exprs:
            e.checkRecursion( subRecCheckList )


class ParseElementEnhance(ParserElement):
    """
    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.
    """
    def __init__( self, expr, savelist=False ):
        super(ParseElementEnhance,self).__init__(savelist)
        if isinstance( expr, basestring ):
            if issubclass(ParserElement._literalStringClass, Token):
                expr = ParserElement._literalStringClass(expr)
            else:
                expr = ParserElement._literalStringClass(Literal(expr))
        self.expr = expr
        self.strRepr = None
        if expr is not None:
            self.mayIndexError = expr.mayIndexError
            self.mayReturnEmpty = expr.mayReturnEmpty
            self.setWhitespaceChars( expr.whiteChars )
            self.skipWhitespace = expr.skipWhitespace
            self.saveAsList = expr.saveAsList
            self.callPreparse = expr.callPreparse
            self.ignoreExprs.extend(expr.ignoreExprs)

    def parseImpl( self, instring, loc, doActions=True ):
        if self.expr is not None:
            return self.expr._parse( instring, loc, doActions, callPreParse=False )
        else:
            raise ParseException("",loc,self.errmsg,self)

    def leaveWhitespace( self ):
        self.skipWhitespace = False
        self.expr = self.expr.copy()
        if self.expr is not None:
            self.expr.leaveWhitespace()
        return self

    def ignore( self, other ):
        if isinstance( other, Suppress ):
            if other not in self.ignoreExprs:
                super( ParseElementEnhance, self).ignore( other )
                if self.expr is not None:
                    self.expr.ignore( self.ignoreExprs[-1] )
        else:
            super( ParseElementEnhance, self).ignore( other )
            if self.expr is not None:
                self.expr.ignore( self.ignoreExprs[-1] )
        return self

    def streamline( self ):
        super(ParseElementEnhance,self).streamline()
        if self.expr is not None:
            self.expr.streamline()
        return self

    def checkRecursion( self, parseElementList ):
        if self in parseElementList:
            raise RecursiveGrammarException( parseElementList+[self] )
        subRecCheckList = parseElementList[:] + [ self ]
        if self.expr is not None:
            self.expr.checkRecursion( subRecCheckList )

    def validate( self, validateTrace=[] ):
        tmp = validateTrace[:]+[self]
        if self.expr is not None:
            self.expr.validate(tmp)
        self.checkRecursion( [] )

    def __str__( self ):
        try:
            return super(ParseElementEnhance,self).__str__()
        except Exception:
            pass

        if self.strRepr is None and self.expr is not None:
            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
        return self.strRepr


class FollowedBy(ParseElementEnhance):
    """
    Lookahead matching of the given parse expression.  C{FollowedBy}
    does I{not} advance the parsing position within the input string, it only
    verifies that the specified parse expression matches at the current
    position.  C{FollowedBy} always returns a null token list.

    Example::
        # use FollowedBy to match a label only if it is followed by a ':'
        data_word = Word(alphas)
        label = data_word + FollowedBy(':')
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        
        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
    prints::
        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
    """
    def __init__( self, expr ):
        super(FollowedBy,self).__init__(expr)
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        self.expr.tryParse( instring, loc )
        return loc, []


class NotAny(ParseElementEnhance):
    """
    Lookahead to disallow matching with the given parse expression.  C{NotAny}
    does I{not} advance the parsing position within the input string, it only
    verifies that the specified parse expression does I{not} match at the current
    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}
    always returns a null token list.  May be constructed using the '~' operator.

    Example::
        
    """
    def __init__( self, expr ):
        super(NotAny,self).__init__(expr)
        #~ self.leaveWhitespace()
        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
        self.mayReturnEmpty = True
        self.errmsg = "Found unwanted token, "+_ustr(self.expr)

    def parseImpl( self, instring, loc, doActions=True ):
        if self.expr.canParseNext(instring, loc):
            raise ParseException(instring, loc, self.errmsg, self)
        return loc, []

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "~{" + _ustr(self.expr) + "}"

        return self.strRepr

class _MultipleMatch(ParseElementEnhance):
    def __init__( self, expr, stopOn=None):
        super(_MultipleMatch, self).__init__(expr)
        self.saveAsList = True
        ender = stopOn
        if isinstance(ender, basestring):
            ender = ParserElement._literalStringClass(ender)
        self.not_ender = ~ender if ender is not None else None

    def parseImpl( self, instring, loc, doActions=True ):
        self_expr_parse = self.expr._parse
        self_skip_ignorables = self._skipIgnorables
        check_ender = self.not_ender is not None
        if check_ender:
            try_not_ender = self.not_ender.tryParse
        
        # must be at least one (but first see if we are the stopOn sentinel;
        # if so, fail)
        if check_ender:
            try_not_ender(instring, loc)
        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )
        try:
            hasIgnoreExprs = (not not self.ignoreExprs)
            while 1:
                if check_ender:
                    try_not_ender(instring, loc)
                if hasIgnoreExprs:
                    preloc = self_skip_ignorables( instring, loc )
                else:
                    preloc = loc
                loc, tmptokens = self_expr_parse( instring, preloc, doActions )
                if tmptokens or tmptokens.haskeys():
                    tokens += tmptokens
        except (ParseException,IndexError):
            pass

        return loc, tokens
        
class OneOrMore(_MultipleMatch):
    """
    Repetition of one or more of the given expression.
    
    Parameters:
     - expr - expression that must match one or more times
     - stopOn - (default=C{None}) - expression for a terminating sentinel
          (only required if the sentinel would ordinarily match the repetition 
          expression)          

    Example::
        data_word = Word(alphas)
        label = data_word + FollowedBy(':')
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

        text = "shape: SQUARE posn: upper left color: BLACK"
        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]

        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
        
        # could also be written as
        (attr_expr * (1,)).parseString(text).pprint()
    """

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "{" + _ustr(self.expr) + "}..."

        return self.strRepr

class ZeroOrMore(_MultipleMatch):
    """
    Optional repetition of zero or more of the given expression.
    
    Parameters:
     - expr - expression that must match zero or more times
     - stopOn - (default=C{None}) - expression for a terminating sentinel
          (only required if the sentinel would ordinarily match the repetition 
          expression)          

    Example: similar to L{OneOrMore}
    """
    def __init__( self, expr, stopOn=None):
        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)
        self.mayReturnEmpty = True
        
    def parseImpl( self, instring, loc, doActions=True ):
        try:
            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)
        except (ParseException,IndexError):
            return loc, []

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "[" + _ustr(self.expr) + "]..."

        return self.strRepr

class _NullToken(object):
    def __bool__(self):
        return False
    __nonzero__ = __bool__
    def __str__(self):
        return ""

_optionalNotMatched = _NullToken()
class Optional(ParseElementEnhance):
    """
    Optional matching of the given expression.

    Parameters:
     - expr - expression that must match zero or more times
     - default (optional) - value to be returned if the optional expression is not found.

    Example::
        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
        zip.runTests('''
            # traditional ZIP code
            12345
            
            # ZIP+4 form
            12101-0001
            
            # invalid ZIP
            98765-
            ''')
    prints::
        # traditional ZIP code
        12345
        ['12345']

        # ZIP+4 form
        12101-0001
        ['12101-0001']

        # invalid ZIP
        98765-
             ^
        FAIL: Expected end of text (at char 5), (line:1, col:6)
    """
    def __init__( self, expr, default=_optionalNotMatched ):
        super(Optional,self).__init__( expr, savelist=False )
        self.saveAsList = self.expr.saveAsList
        self.defaultValue = default
        self.mayReturnEmpty = True

    def parseImpl( self, instring, loc, doActions=True ):
        try:
            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
        except (ParseException,IndexError):
            if self.defaultValue is not _optionalNotMatched:
                if self.expr.resultsName:
                    tokens = ParseResults([ self.defaultValue ])
                    tokens[self.expr.resultsName] = self.defaultValue
                else:
                    tokens = [ self.defaultValue ]
            else:
                tokens = []
        return loc, tokens

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name

        if self.strRepr is None:
            self.strRepr = "[" + _ustr(self.expr) + "]"

        return self.strRepr

class SkipTo(ParseElementEnhance):
    """
    Token for skipping over all undefined text until the matched expression is found.

    Parameters:
     - expr - target expression marking the end of the data to be skipped
     - include - (default=C{False}) if True, the target expression is also parsed 
          (the skipped text and target expression are returned as a 2-element list).
     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 
          comments) that might contain false matches to the target expression
     - failOn - (default=C{None}) define expressions that are not allowed to be 
          included in the skipped test; if found before the target expression is found, 
          the SkipTo is not a match

    Example::
        report = '''
            Outstanding Issues Report - 1 Jan 2000

               # | Severity | Description                               |  Days Open
            -----+----------+-------------------------------------------+-----------
             101 | Critical | Intermittent system crash                 |          6
              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
              79 | Minor    | System slow when running too many reports |         47
            '''
        integer = Word(nums)
        SEP = Suppress('|')
        # use SkipTo to simply match everything up until the next SEP
        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
        # - parse action will call token.strip() for each matched token, i.e., the description body
        string_data = SkipTo(SEP, ignore=quotedString)
        string_data.setParseAction(tokenMap(str.strip))
        ticket_expr = (integer("issue_num") + SEP 
                      + string_data("sev") + SEP 
                      + string_data("desc") + SEP 
                      + integer("days_open"))
        
        for tkt in ticket_expr.searchString(report):
            print tkt.dump()
    prints::
        ['101', 'Critical', 'Intermittent system crash', '6']
        - days_open: 6
        - desc: Intermittent system crash
        - issue_num: 101
        - sev: Critical
        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
        - days_open: 14
        - desc: Spelling error on Login ('log|n')
        - issue_num: 94
        - sev: Cosmetic
        ['79', 'Minor', 'System slow when running too many reports', '47']
        - days_open: 47
        - desc: System slow when running too many reports
        - issue_num: 79
        - sev: Minor
    """
    def __init__( self, other, include=False, ignore=None, failOn=None ):
        super( SkipTo, self ).__init__( other )
        self.ignoreExpr = ignore
        self.mayReturnEmpty = True
        self.mayIndexError = False
        self.includeMatch = include
        self.asList = False
        if isinstance(failOn, basestring):
            self.failOn = ParserElement._literalStringClass(failOn)
        else:
            self.failOn = failOn
        self.errmsg = "No match found for "+_ustr(self.expr)

    def parseImpl( self, instring, loc, doActions=True ):
        startloc = loc
        instrlen = len(instring)
        expr = self.expr
        expr_parse = self.expr._parse
        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None
        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
        
        tmploc = loc
        while tmploc <= instrlen:
            if self_failOn_canParseNext is not None:
                # break if failOn expression matches
                if self_failOn_canParseNext(instring, tmploc):
                    break
                    
            if self_ignoreExpr_tryParse is not None:
                # advance past ignore expressions
                while 1:
                    try:
                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
                    except ParseBaseException:
                        break
            
            try:
                expr_parse(instring, tmploc, doActions=False, callPreParse=False)
            except (ParseException, IndexError):
                # no match, advance loc in string
                tmploc += 1
            else:
                # matched skipto expr, done
                break

        else:
            # ran off the end of the input string without matching skipto expr, fail
            raise ParseException(instring, loc, self.errmsg, self)

        # build up return values
        loc = tmploc
        skiptext = instring[startloc:loc]
        skipresult = ParseResults(skiptext)
        
        if self.includeMatch:
            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)
            skipresult += mat

        return loc, skipresult

class Forward(ParseElementEnhance):
    """
    Forward declaration of an expression to be defined later -
    used for recursive grammars, such as algebraic infix notation.
    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.

    Note: take care when assigning to C{Forward} not to overlook precedence of operators.
    Specifically, '|' has a lower precedence than '<<', so that::
        fwdExpr << a | b | c
    will actually be evaluated as::
        (fwdExpr << a) | b | c
    thereby leaving b and c out as parseable alternatives.  It is recommended that you
    explicitly group the values inserted into the C{Forward}::
        fwdExpr << (a | b | c)
    Converting to use the '<<=' operator instead will avoid this problem.

    See L{ParseResults.pprint} for an example of a recursive parser created using
    C{Forward}.
    """
    def __init__( self, other=None ):
        super(Forward,self).__init__( other, savelist=False )

    def __lshift__( self, other ):
        if isinstance( other, basestring ):
            other = ParserElement._literalStringClass(other)
        self.expr = other
        self.strRepr = None
        self.mayIndexError = self.expr.mayIndexError
        self.mayReturnEmpty = self.expr.mayReturnEmpty
        self.setWhitespaceChars( self.expr.whiteChars )
        self.skipWhitespace = self.expr.skipWhitespace
        self.saveAsList = self.expr.saveAsList
        self.ignoreExprs.extend(self.expr.ignoreExprs)
        return self
        
    def __ilshift__(self, other):
        return self << other
    
    def leaveWhitespace( self ):
        self.skipWhitespace = False
        return self

    def streamline( self ):
        if not self.streamlined:
            self.streamlined = True
            if self.expr is not None:
                self.expr.streamline()
        return self

    def validate( self, validateTrace=[] ):
        if self not in validateTrace:
            tmp = validateTrace[:]+[self]
            if self.expr is not None:
                self.expr.validate(tmp)
        self.checkRecursion([])

    def __str__( self ):
        if hasattr(self,"name"):
            return self.name
        return self.__class__.__name__ + ": ..."

        # stubbed out for now - creates awful memory and perf issues
        self._revertClass = self.__class__
        self.__class__ = _ForwardNoRecurse
        try:
            if self.expr is not None:
                retString = _ustr(self.expr)
            else:
                retString = "None"
        finally:
            self.__class__ = self._revertClass
        return self.__class__.__name__ + ": " + retString

    def copy(self):
        if self.expr is not None:
            return super(Forward,self).copy()
        else:
            ret = Forward()
            ret <<= self
            return ret

class _ForwardNoRecurse(Forward):
    def __str__( self ):
        return "..."

class TokenConverter(ParseElementEnhance):
    """
    Abstract subclass of C{ParseExpression}, for converting parsed results.
    """
    def __init__( self, expr, savelist=False ):
        super(TokenConverter,self).__init__( expr )#, savelist )
        self.saveAsList = False

class Combine(TokenConverter):
    """
    Converter to concatenate all matching tokens to a single string.
    By default, the matching patterns must also be contiguous in the input string;
    this can be disabled by specifying C{'adjacent=False'} in the constructor.

    Example::
        real = Word(nums) + '.' + Word(nums)
        print(real.parseString('3.1416')) # -> ['3', '.', '1416']
        # will also erroneously match the following
        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']

        real = Combine(Word(nums) + '.' + Word(nums))
        print(real.parseString('3.1416')) # -> ['3.1416']
        # no match when there are internal spaces
        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
    """
    def __init__( self, expr, joinString="", adjacent=True ):
        super(Combine,self).__init__( expr )
        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
        if adjacent:
            self.leaveWhitespace()
        self.adjacent = adjacent
        self.skipWhitespace = True
        self.joinString = joinString
        self.callPreparse = True

    def ignore( self, other ):
        if self.adjacent:
            ParserElement.ignore(self, other)
        else:
            super( Combine, self).ignore( other )
        return self

    def postParse( self, instring, loc, tokenlist ):
        retToks = tokenlist.copy()
        del retToks[:]
        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)

        if self.resultsName and retToks.haskeys():
            return [ retToks ]
        else:
            return retToks

class Group(TokenConverter):
    """
    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.

    Example::
        ident = Word(alphas)
        num = Word(nums)
        term = ident | num
        func = ident + Optional(delimitedList(term))
        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']

        func = ident + Group(Optional(delimitedList(term)))
        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]
    """
    def __init__( self, expr ):
        super(Group,self).__init__( expr )
        self.saveAsList = True

    def postParse( self, instring, loc, tokenlist ):
        return [ tokenlist ]

class Dict(TokenConverter):
    """
    Converter to return a repetitive expression as a list, but also as a dictionary.
    Each element can also be referenced using the first token in the expression as its key.
    Useful for tabular report scraping when the first column can be used as a item key.

    Example::
        data_word = Word(alphas)
        label = data_word + FollowedBy(':')
        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        
        # print attributes as plain groups
        print(OneOrMore(attr_expr).parseString(text).dump())
        
        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
        print(result.dump())
        
        # access named fields as dict entries, or output as dict
        print(result['shape'])        
        print(result.asDict())
    prints::
        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']

        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
        - color: light blue
        - posn: upper left
        - shape: SQUARE
        - texture: burlap
        SQUARE
        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
    See more examples at L{ParseResults} of accessing fields by results name.
    """
    def __init__( self, expr ):
        super(Dict,self).__init__( expr )
        self.saveAsList = True

    def postParse( self, instring, loc, tokenlist ):
        for i,tok in enumerate(tokenlist):
            if len(tok) == 0:
                continue
            ikey = tok[0]
            if isinstance(ikey,int):
                ikey = _ustr(tok[0]).strip()
            if len(tok)==1:
                tokenlist[ikey] = _ParseResultsWithOffset("",i)
            elif len(tok)==2 and not isinstance(tok[1],ParseResults):
                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
            else:
                dictvalue = tok.copy() #ParseResults(i)
                del dictvalue[0]
                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):
                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
                else:
                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)

        if self.resultsName:
            return [ tokenlist ]
        else:
            return tokenlist


class Suppress(TokenConverter):
    """
    Converter for ignoring the results of a parsed expression.

    Example::
        source = "a, b, c,d"
        wd = Word(alphas)
        wd_list1 = wd + ZeroOrMore(',' + wd)
        print(wd_list1.parseString(source))

        # often, delimiters that are useful during parsing are just in the
        # way afterward - use Suppress to keep them out of the parsed output
        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
        print(wd_list2.parseString(source))
    prints::
        ['a', ',', 'b', ',', 'c', ',', 'd']
        ['a', 'b', 'c', 'd']
    (See also L{delimitedList}.)
    """
    def postParse( self, instring, loc, tokenlist ):
        return []

    def suppress( self ):
        return self


class OnlyOnce(object):
    """
    Wrapper for parse actions, to ensure they are only called once.
    """
    def __init__(self, methodCall):
        self.callable = _trim_arity(methodCall)
        self.called = False
    def __call__(self,s,l,t):
        if not self.called:
            results = self.callable(s,l,t)
            self.called = True
            return results
        raise ParseException(s,l,"")
    def reset(self):
        self.called = False

def traceParseAction(f):
    """
    Decorator for debugging parse actions. 
    
    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}
    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.

    Example::
        wd = Word(alphas)

        @traceParseAction
        def remove_duplicate_chars(tokens):
            return ''.join(sorted(set(''.join(tokens))))

        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
    prints::
        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
        <3:
            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )
        try:
            ret = f(*paArgs)
        except Exception as exc:
            sys.stderr.write( "< ['aa', 'bb', 'cc']
        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
    """
    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
    if combine:
        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)
    else:
        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)

def countedArray( expr, intExpr=None ):
    """
    Helper to define a counted list of expressions.
    This helper defines a pattern of the form::
        integer expr expr expr...
    where the leading integer tells how many expr expressions follow.
    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.
    
    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.

    Example::
        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']

        # in this parser, the leading integer value is given in binary,
        # '10' indicating that 2 values are in the array
        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']
    """
    arrayExpr = Forward()
    def countFieldParseAction(s,l,t):
        n = t[0]
        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))
        return []
    if intExpr is None:
        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))
    else:
        intExpr = intExpr.copy()
    intExpr.setName("arrayLen")
    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)
    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')

def _flatten(L):
    ret = []
    for i in L:
        if isinstance(i,list):
            ret.extend(_flatten(i))
        else:
            ret.append(i)
    return ret

def matchPreviousLiteral(expr):
    """
    Helper to define an expression that is indirectly defined from
    the tokens matched in a previous expression, that is, it looks
    for a 'repeat' of a previous expression.  For example::
        first = Word(nums)
        second = matchPreviousLiteral(first)
        matchExpr = first + ":" + second
    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a
    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.
    If this is not desired, use C{matchPreviousExpr}.
    Do I{not} use with packrat parsing enabled.
    """
    rep = Forward()
    def copyTokenToRepeater(s,l,t):
        if t:
            if len(t) == 1:
                rep << t[0]
            else:
                # flatten t tokens
                tflat = _flatten(t.asList())
                rep << And(Literal(tt) for tt in tflat)
        else:
            rep << Empty()
    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
    rep.setName('(prev) ' + _ustr(expr))
    return rep

def matchPreviousExpr(expr):
    """
    Helper to define an expression that is indirectly defined from
    the tokens matched in a previous expression, that is, it looks
    for a 'repeat' of a previous expression.  For example::
        first = Word(nums)
        second = matchPreviousExpr(first)
        matchExpr = first + ":" + second
    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by
    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};
    the expressions are evaluated first, and then compared, so
    C{"1"} is compared with C{"10"}.
    Do I{not} use with packrat parsing enabled.
    """
    rep = Forward()
    e2 = expr.copy()
    rep <<= e2
    def copyTokenToRepeater(s,l,t):
        matchTokens = _flatten(t.asList())
        def mustMatchTheseTokens(s,l,t):
            theseTokens = _flatten(t.asList())
            if  theseTokens != matchTokens:
                raise ParseException("",0,"")
        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )
    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
    rep.setName('(prev) ' + _ustr(expr))
    return rep

def _escapeRegexRangeChars(s):
    #~  escape these chars: ^-]
    for c in r"\^-]":
        s = s.replace(c,_bslash+c)
    s = s.replace("\n",r"\n")
    s = s.replace("\t",r"\t")
    return _ustr(s)

def oneOf( strs, caseless=False, useRegex=True ):
    """
    Helper to quickly define a set of alternative Literals, and makes sure to do
    longest-first testing when there is a conflict, regardless of the input order,
    but returns a C{L{MatchFirst}} for best performance.

    Parameters:
     - strs - a string of space-delimited literals, or a collection of string literals
     - caseless - (default=C{False}) - treat all literals as caseless
     - useRegex - (default=C{True}) - as an optimization, will generate a Regex
          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or
          if creating a C{Regex} raises an exception)

    Example::
        comp_oper = oneOf("< = > <= >= !=")
        var = Word(alphas)
        number = Word(nums)
        term = var | number
        comparison_expr = term + comp_oper + term
        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))
    prints::
        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
    """
    if caseless:
        isequal = ( lambda a,b: a.upper() == b.upper() )
        masks = ( lambda a,b: b.upper().startswith(a.upper()) )
        parseElementClass = CaselessLiteral
    else:
        isequal = ( lambda a,b: a == b )
        masks = ( lambda a,b: b.startswith(a) )
        parseElementClass = Literal

    symbols = []
    if isinstance(strs,basestring):
        symbols = strs.split()
    elif isinstance(strs, Iterable):
        symbols = list(strs)
    else:
        warnings.warn("Invalid argument to oneOf, expected string or iterable",
                SyntaxWarning, stacklevel=2)
    if not symbols:
        return NoMatch()

    i = 0
    while i < len(symbols)-1:
        cur = symbols[i]
        for j,other in enumerate(symbols[i+1:]):
            if ( isequal(other, cur) ):
                del symbols[i+j+1]
                break
            elif ( masks(cur, other) ):
                del symbols[i+j+1]
                symbols.insert(i,other)
                cur = other
                break
        else:
            i += 1

    if not caseless and useRegex:
        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
        try:
            if len(symbols)==len("".join(symbols)):
                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))
            else:
                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))
        except Exception:
            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
                    SyntaxWarning, stacklevel=2)


    # last resort, just use MatchFirst
    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))

def dictOf( key, value ):
    """
    Helper to easily and clearly define a dictionary by specifying the respective patterns
    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
    in the proper order.  The key pattern can include delimiting markers or punctuation,
    as long as they are suppressed, thereby leaving the significant key text.  The value
    pattern can include named results, so that the C{Dict} results can include named token
    fields.

    Example::
        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
        print(OneOrMore(attr_expr).parseString(text).dump())
        
        attr_label = label
        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)

        # similar to Dict, but simpler call format
        result = dictOf(attr_label, attr_value).parseString(text)
        print(result.dump())
        print(result['shape'])
        print(result.shape)  # object attribute access works too
        print(result.asDict())
    prints::
        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
        - color: light blue
        - posn: upper left
        - shape: SQUARE
        - texture: burlap
        SQUARE
        SQUARE
        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
    """
    return Dict( ZeroOrMore( Group ( key + value ) ) )

def originalTextFor(expr, asString=True):
    """
    Helper to return the original, untokenized text for a given expression.  Useful to
    restore the parsed fields of an HTML start tag into the raw tag text itself, or to
    revert separate tokens with intervening whitespace back to the original matching
    input text. By default, returns astring containing the original parsed text.  
       
    If the optional C{asString} argument is passed as C{False}, then the return value is a 
    C{L{ParseResults}} containing any results names that were originally matched, and a 
    single token containing the original matched text from the input string.  So if 
    the expression passed to C{L{originalTextFor}} contains expressions with defined
    results names, you must set C{asString} to C{False} if you want to preserve those
    results name values.

    Example::
        src = "this is test  bold text  normal text "
        for tag in ("b","i"):
            opener,closer = makeHTMLTags(tag)
            patt = originalTextFor(opener + SkipTo(closer) + closer)
            print(patt.searchString(src)[0])
    prints::
        [' bold text ']
        ['text']
    """
    locMarker = Empty().setParseAction(lambda s,loc,t: loc)
    endlocMarker = locMarker.copy()
    endlocMarker.callPreparse = False
    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
    if asString:
        extractText = lambda s,l,t: s[t._original_start:t._original_end]
    else:
        def extractText(s,l,t):
            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
    matchExpr.setParseAction(extractText)
    matchExpr.ignoreExprs = expr.ignoreExprs
    return matchExpr

def ungroup(expr): 
    """
    Helper to undo pyparsing's default grouping of And expressions, even
    if all but one are non-empty.
    """
    return TokenConverter(expr).setParseAction(lambda t:t[0])

def locatedExpr(expr):
    """
    Helper to decorate a returned token with its starting and ending locations in the input string.
    This helper adds the following results names:
     - locn_start = location where matched expression begins
     - locn_end = location where matched expression ends
     - value = the actual parsed results

    Be careful if the input text contains C{} characters, you may want to call
    C{L{ParserElement.parseWithTabs}}

    Example::
        wd = Word(alphas)
        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
            print(match)
    prints::
        [[0, 'ljsdf', 5]]
        [[8, 'lksdjjf', 15]]
        [[18, 'lkkjj', 23]]
    """
    locator = Empty().setParseAction(lambda s,l,t: l)
    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))


# convenience constants for positional expressions
empty       = Empty().setName("empty")
lineStart   = LineStart().setName("lineStart")
lineEnd     = LineEnd().setName("lineEnd")
stringStart = StringStart().setName("stringStart")
stringEnd   = StringEnd().setName("stringEnd")

_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
_charRange = Group(_singleChar + Suppress("-") + _singleChar)
_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"

def srange(s):
    r"""
    Helper to easily define string ranges for use in Word construction.  Borrows
    syntax from regexp '[]' string range definitions::
        srange("[0-9]")   -> "0123456789"
        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
    The input string must be enclosed in []'s, and the returned string is the expanded
    character set joined into a single string.
    The values enclosed in the []'s may be:
     - a single character
     - an escaped character with a leading backslash (such as C{\-} or C{\]})
     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 
         (C{\0x##} is also supported for backwards compatibility) 
     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)
     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)
     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)
    """
    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))
    try:
        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
    except Exception:
        return ""

def matchOnlyAtCol(n):
    """
    Helper method for defining parse actions that require matching at a specific
    column in the input text.
    """
    def verifyCol(strg,locn,toks):
        if col(locn,strg) != n:
            raise ParseException(strg,locn,"matched token not at column %d" % n)
    return verifyCol

def replaceWith(replStr):
    """
    Helper method for common parse actions that simply return a literal value.  Especially
    useful when used with C{L{transformString}()}.

    Example::
        num = Word(nums).setParseAction(lambda toks: int(toks[0]))
        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
        term = na | num
        
        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
    """
    return lambda s,l,t: [replStr]

def removeQuotes(s,l,t):
    """
    Helper parse action for removing quotation marks from parsed quoted strings.

    Example::
        # by default, quotation marks are included in parsed results
        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]

        # use removeQuotes to strip quotation marks from parsed results
        quotedString.setParseAction(removeQuotes)
        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
    """
    return t[0][1:-1]

def tokenMap(func, *args):
    """
    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 
    args are passed, they are forwarded to the given function as additional arguments after
    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the
    parsed data to an integer using base 16.

    Example (compare the last to example in L{ParserElement.transformString}::
        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
        hex_ints.runTests('''
            00 11 22 aa FF 0a 0d 1a
            ''')
        
        upperword = Word(alphas).setParseAction(tokenMap(str.upper))
        OneOrMore(upperword).runTests('''
            my kingdom for a horse
            ''')

        wd = Word(alphas).setParseAction(tokenMap(str.title))
        OneOrMore(wd).setParseAction(' '.join).runTests('''
            now is the winter of our discontent made glorious summer by this sun of york
            ''')
    prints::
        00 11 22 aa FF 0a 0d 1a
        [0, 17, 34, 170, 255, 10, 13, 26]

        my kingdom for a horse
        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']

        now is the winter of our discontent made glorious summer by this sun of york
        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
    """
    def pa(s,l,t):
        return [func(tokn, *args) for tokn in t]

    try:
        func_name = getattr(func, '__name__', 
                            getattr(func, '__class__').__name__)
    except Exception:
        func_name = str(func)
    pa.__name__ = func_name

    return pa

upcaseTokens = tokenMap(lambda t: _ustr(t).upper())
"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""

downcaseTokens = tokenMap(lambda t: _ustr(t).lower())
"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""
    
def _makeTags(tagStr, xml):
    """Internal helper to construct opening and closing tag expressions, given a tag name"""
    if isinstance(tagStr,basestring):
        resname = tagStr
        tagStr = Keyword(tagStr, caseless=not xml)
    else:
        resname = tagStr.name

    tagAttrName = Word(alphas,alphanums+"_-:")
    if (xml):
        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
        openTag = Suppress("<") + tagStr("tag") + \
                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
    else:
        printablesLessRAbrack = "".join(c for c in printables if c not in ">")
        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
        openTag = Suppress("<") + tagStr("tag") + \
                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
                Optional( Suppress("=") + tagAttrValue ) ))) + \
                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
    closeTag = Combine(_L("")

    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)
    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("" % resname)
    openTag.tag = resname
    closeTag.tag = resname
    return openTag, closeTag

def makeHTMLTags(tagStr):
    """
    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches
    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.

    Example::
        text = 'More info at the pyparsing wiki page'
        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple
        a,a_end = makeHTMLTags("A")
        link_expr = a + SkipTo(a_end)("link_text") + a_end
        
        for link in link_expr.searchString(text):
            # attributes in the  tag (like "href" shown here) are also accessible as named results
            print(link.link_text, '->', link.href)
    prints::
        pyparsing -> http://pyparsing.wikispaces.com
    """
    return _makeTags( tagStr, False )

def makeXMLTags(tagStr):
    """
    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches
    tags only in the given upper/lower case.

    Example: similar to L{makeHTMLTags}
    """
    return _makeTags( tagStr, True )

def withAttribute(*args,**attrDict):
    """
    Helper to create a validating parse action to be used with start tags created
    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
    with a required attribute value, to avoid false matches on common tags such as
    C{} or C{
}.

    Call C{withAttribute} with a series of attribute names and values. Specify the list
    of filter attributes names and values as:
     - keyword arguments, as in C{(align="right")}, or
     - as an explicit dict with C{**} operator, when an attribute name is also a Python
          reserved word, as in C{**{"class":"Customer", "align":"right"}}
     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
    For attribute names with a namespace prefix, you must use the second form.  Attribute
    names are matched insensitive to upper/lower case.
       
    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.

    To verify that the attribute exists, but without specifying a value, pass
    C{withAttribute.ANY_VALUE} as the value.

    Example::
        html = '''
            

            Some text
            
1 4 0 1 0

            
1,3 2,3 1,1

            
this has no type

            

                
        '''
        div,div_end = makeHTMLTags("div")

        # only match div tag having a type attribute with value "grid"
        div_grid = div().setParseAction(withAttribute(type="grid"))
        grid_expr = div_grid + SkipTo(div | div_end)("body")
        for grid_header in grid_expr.searchString(html):
            print(grid_header.body)
        
        # construct a match with any div tag having a type attribute, regardless of the value
        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
        div_expr = div_any_type + SkipTo(div | div_end)("body")
        for div_header in div_expr.searchString(html):
            print(div_header.body)
    prints::
        1 4 0 1 0

        1 4 0 1 0
        1,3 2,3 1,1
    """
    if args:
        attrs = args[:]
    else:
        attrs = attrDict.items()
    attrs = [(k,v) for k,v in attrs]
    def pa(s,l,tokens):
        for attrName,attrValue in attrs:
            if attrName not in tokens:
                raise ParseException(s,l,"no matching attribute " + attrName)
            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
                                            (attrName, tokens[attrName], attrValue))
    return pa
withAttribute.ANY_VALUE = object()

def withClass(classname, namespace=''):
    """
    Simplified version of C{L{withAttribute}} when matching on a div class - made
    difficult because C{class} is a reserved word in Python.

    Example::
        html = '''
            

            Some text
            
1 4 0 1 0

            
1,3 2,3 1,1

            
this <div> has no class

            

                
        '''
        div,div_end = makeHTMLTags("div")
        div_grid = div().setParseAction(withClass("grid"))
        
        grid_expr = div_grid + SkipTo(div | div_end)("body")
        for grid_header in grid_expr.searchString(html):
            print(grid_header.body)
        
        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
        div_expr = div_any_type + SkipTo(div | div_end)("body")
        for div_header in div_expr.searchString(html):
            print(div_header.body)
    prints::
        1 4 0 1 0

        1 4 0 1 0
        1,3 2,3 1,1
    """
    classattr = "%s:class" % namespace if namespace else "class"
    return withAttribute(**{classattr : classname})        

opAssoc = _Constants()
opAssoc.LEFT = object()
opAssoc.RIGHT = object()

def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
    """
    Helper method for constructing grammars of expressions made up of
    operators working in a precedence hierarchy.  Operators may be unary or
    binary, left- or right-associative.  Parse actions can also be attached
    to operator expressions. The generated parser will also recognize the use 
    of parentheses to override operator precedences (see example below).
    
    Note: if you define a deep operator list, you may see performance issues
    when using infixNotation. See L{ParserElement.enablePackrat} for a
    mechanism to potentially improve your parser performance.

    Parameters:
     - baseExpr - expression representing the most basic element for the nested
     - opList - list of tuples, one for each operator precedence level in the
      expression grammar; each tuple is of the form
      (opExpr, numTerms, rightLeftAssoc, parseAction), where:
       - opExpr is the pyparsing expression for the operator;
          may also be a string, which will be converted to a Literal;
          if numTerms is 3, opExpr is a tuple of two expressions, for the
          two operators separating the 3 terms
       - numTerms is the number of terms for this operator (must
          be 1, 2, or 3)
       - rightLeftAssoc is the indicator whether the operator is
          right or left associative, using the pyparsing-defined
          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
       - parseAction is the parse action to be associated with
          expressions matching this operator expression (the
          parse action tuple member may be omitted); if the parse action
          is passed a tuple or list of functions, this is equivalent to
          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})
     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})
     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})

    Example::
        # simple example of four-function arithmetic with ints and variable names
        integer = pyparsing_common.signed_integer
        varname = pyparsing_common.identifier 
        
        arith_expr = infixNotation(integer | varname,
            [
            ('-', 1, opAssoc.RIGHT),
            (oneOf('* /'), 2, opAssoc.LEFT),
            (oneOf('+ -'), 2, opAssoc.LEFT),
            ])
        
        arith_expr.runTests('''
            5+3*6
            (5+3)*6
            -2--11
            ''', fullDump=False)
    prints::
        5+3*6
        [[5, '+', [3, '*', 6]]]

        (5+3)*6
        [[[5, '+', 3], '*', 6]]

        -2--11
        [[['-', 2], '-', ['-', 11]]]
    """
    ret = Forward()
    lastExpr = baseExpr | ( lpar + ret + rpar )
    for i,operDef in enumerate(opList):
        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
        if arity == 3:
            if opExpr is None or len(opExpr) != 2:
                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
            opExpr1, opExpr2 = opExpr
        thisExpr = Forward().setName(termName)
        if rightLeftAssoc == opAssoc.LEFT:
            if arity == 1:
                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
            elif arity == 2:
                if opExpr is not None:
                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
                else:
                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
            elif arity == 3:
                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
            else:
                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
        elif rightLeftAssoc == opAssoc.RIGHT:
            if arity == 1:
                # try to avoid LR with this extra test
                if not isinstance(opExpr, Optional):
                    opExpr = Optional(opExpr)
                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
            elif arity == 2:
                if opExpr is not None:
                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
                else:
                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
            elif arity == 3:
                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
            else:
                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
        else:
            raise ValueError("operator must indicate right or left associativity")
        if pa:
            if isinstance(pa, (tuple, list)):
                matchExpr.setParseAction(*pa)
            else:
                matchExpr.setParseAction(pa)
        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )
        lastExpr = thisExpr
    ret <<= lastExpr
    return ret

operatorPrecedence = infixNotation
"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""

dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")
sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")
quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|
                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")
unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")

def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
    """
    Helper method for defining nested lists enclosed in opening and closing
    delimiters ("(" and ")" are the default).

    Parameters:
     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression
     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression
     - content - expression for items within the nested lists (default=C{None})
     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})

    If an expression is not provided for the content argument, the nested
    expression will capture all whitespace-delimited content between delimiters
    as a list of separate values.

    Use the C{ignoreExpr} argument to define expressions that may contain
    opening or closing characters that should not be treated as opening
    or closing characters for nesting, such as quotedString or a comment
    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
    The default is L{quotedString}, but if no expressions are to be ignored,
    then pass C{None} for this argument.

    Example::
        data_type = oneOf("void int short long char float double")
        decl_data_type = Combine(data_type + Optional(Word('*')))
        ident = Word(alphas+'_', alphanums+'_')
        number = pyparsing_common.number
        arg = Group(decl_data_type + ident)
        LPAR,RPAR = map(Suppress, "()")

        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))

        c_function = (decl_data_type("type") 
                      + ident("name")
                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 
                      + code_body("body"))
        c_function.ignore(cStyleComment)
        
        source_code = '''
            int is_odd(int x) { 
                return (x%2); 
            }
                
            int dec_to_hex(char hchar) { 
                if (hchar >= '0' && hchar <= '9') { 
                    return (ord(hchar)-ord('0')); 
                } else { 
                    return (10+ord(hchar)-ord('A'));
                } 
            }
        '''
        for func in c_function.searchString(source_code):
            print("%(name)s (%(type)s) args: %(args)s" % func)

    prints::
        is_odd (int) args: [['int', 'x']]
        dec_to_hex (int) args: [['char', 'hchar']]
    """
    if opener == closer:
        raise ValueError("opening and closing strings cannot be the same")
    if content is None:
        if isinstance(opener,basestring) and isinstance(closer,basestring):
            if len(opener) == 1 and len(closer)==1:
                if ignoreExpr is not None:
                    content = (Combine(OneOrMore(~ignoreExpr +
                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
                                ).setParseAction(lambda t:t[0].strip()))
                else:
                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
                                ).setParseAction(lambda t:t[0].strip()))
            else:
                if ignoreExpr is not None:
                    content = (Combine(OneOrMore(~ignoreExpr + 
                                    ~Literal(opener) + ~Literal(closer) +
                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
                                ).setParseAction(lambda t:t[0].strip()))
                else:
                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
                                ).setParseAction(lambda t:t[0].strip()))
        else:
            raise ValueError("opening and closing arguments must be strings if no content expression is given")
    ret = Forward()
    if ignoreExpr is not None:
        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
    else:
        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )
    ret.setName('nested %s%s expression' % (opener,closer))
    return ret

def indentedBlock(blockStatementExpr, indentStack, indent=True):
    """
    Helper method for defining space-delimited indentation blocks, such as
    those used to define block statements in Python source code.

    Parameters:
     - blockStatementExpr - expression defining syntax of statement that
            is repeated within the indented block
     - indentStack - list created by caller to manage indentation stack
            (multiple statementWithIndentedBlock expressions within a single grammar
            should share a common indentStack)
     - indent - boolean indicating whether block must be indented beyond the
            the current level; set to False for block of left-most statements
            (default=C{True})

    A valid block must contain at least one C{blockStatement}.

    Example::
        data = '''
        def A(z):
          A1
          B = 100
          G = A2
          A2
          A3
        B
        def BB(a,b,c):
          BB1
          def BBA():
            bba1
            bba2
            bba3
        C
        D
        def spam(x,y):
             def eggs(z):
                 pass
        '''


        indentStack = [1]
        stmt = Forward()

        identifier = Word(alphas, alphanums)
        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")
        func_body = indentedBlock(stmt, indentStack)
        funcDef = Group( funcDecl + func_body )

        rvalue = Forward()
        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
        rvalue << (funcCall | identifier | Word(nums))
        assignment = Group(identifier + "=" + rvalue)
        stmt << ( funcDef | assignment | identifier )

        module_body = OneOrMore(stmt)

        parseTree = module_body.parseString(data)
        parseTree.pprint()
    prints::
        [['def',
          'A',
          ['(', 'z', ')'],
          ':',
          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
         'B',
         ['def',
          'BB',
          ['(', 'a', 'b', 'c', ')'],
          ':',
          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
         'C',
         'D',
         ['def',
          'spam',
          ['(', 'x', 'y', ')'],
          ':',
          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 
    """
    def checkPeerIndent(s,l,t):
        if l >= len(s): return
        curCol = col(l,s)
        if curCol != indentStack[-1]:
            if curCol > indentStack[-1]:
                raise ParseFatalException(s,l,"illegal nesting")
            raise ParseException(s,l,"not a peer entry")

    def checkSubIndent(s,l,t):
        curCol = col(l,s)
        if curCol > indentStack[-1]:
            indentStack.append( curCol )
        else:
            raise ParseException(s,l,"not a subentry")

    def checkUnindent(s,l,t):
        if l >= len(s): return
        curCol = col(l,s)
        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
            raise ParseException(s,l,"not an unindent")
        indentStack.pop()

    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')
    PEER   = Empty().setParseAction(checkPeerIndent).setName('')
    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')
    if indent:
        smExpr = Group( Optional(NL) +
            #~ FollowedBy(blockStatementExpr) +
            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
    else:
        smExpr = Group( Optional(NL) +
            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
    blockStatementExpr.ignore(_bslash + LineEnd())
    return smExpr.setName('indented block')

alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")

anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))
_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))
commonHTMLEntity = Regex('&(?P' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")
def replaceHTMLEntity(t):
    """Helper parser action to replace common HTML entities with their special characters"""
    return _htmlEntityMap.get(t.entity)

# it's easy to get these comment structures wrong - they're very common, so may as well make them available
cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")
"Comment of the form C{/* ... */}"

htmlComment = Regex(r"").setName("HTML comment")
"Comment of the form C{}"

restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")
dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")
"Comment of the form C{// ... (to end of line)}"

cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")
"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"

javaStyleComment = cppStyleComment
"Same as C{L{cppStyleComment}}"

pythonStyleComment = Regex(r"#.*").setName("Python style comment")
"Comment of the form C{# ... (to end of line)}"

_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +
                                  Optional( Word(" \t") +
                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")
"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.
   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""

# some other useful expressions - using lower-case class name since we are really using this as a namespace
class pyparsing_common:
    """
    Here are some common low-level expressions that may be useful in jump-starting parser development:
     - numeric forms (L{integers}, L{reals}, L{scientific notation})
     - common L{programming identifiers}
     - network addresses (L{MAC}, L{IPv4}, L{IPv6})
     - ISO8601 L{dates} and L{datetime}
     - L{UUID}
     - L{comma-separated list}
    Parse actions:
     - C{L{convertToInteger}}
     - C{L{convertToFloat}}
     - C{L{convertToDate}}
     - C{L{convertToDatetime}}
     - C{L{stripHTMLTags}}
     - C{L{upcaseTokens}}
     - C{L{downcaseTokens}}

    Example::
        pyparsing_common.number.runTests('''
            # any int or real number, returned as the appropriate type
            100
            -100
            +100
            3.14159
            6.02e23
            1e-12
            ''')

        pyparsing_common.fnumber.runTests('''
            # any int or real number, returned as float
            100
            -100
            +100
            3.14159
            6.02e23
            1e-12
            ''')

        pyparsing_common.hex_integer.runTests('''
            # hex numbers
            100
            FF
            ''')

        pyparsing_common.fraction.runTests('''
            # fractions
            1/2
            -3/4
            ''')

        pyparsing_common.mixed_integer.runTests('''
            # mixed fractions
            1
            1/2
            -3/4
            1-3/4
            ''')

        import uuid
        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
        pyparsing_common.uuid.runTests('''
            # uuid
            12345678-1234-5678-1234-567812345678
            ''')
    prints::
        # any int or real number, returned as the appropriate type
        100
        [100]

        -100
        [-100]

        +100
        [100]

        3.14159
        [3.14159]

        6.02e23
        [6.02e+23]

        1e-12
        [1e-12]

        # any int or real number, returned as float
        100
        [100.0]

        -100
        [-100.0]

        +100
        [100.0]

        3.14159
        [3.14159]

        6.02e23
        [6.02e+23]

        1e-12
        [1e-12]

        # hex numbers
        100
        [256]

        FF
        [255]

        # fractions
        1/2
        [0.5]

        -3/4
        [-0.75]

        # mixed fractions
        1
        [1]

        1/2
        [0.5]

        -3/4
        [-0.75]

        1-3/4
        [1.75]

        # uuid
        12345678-1234-5678-1234-567812345678
        [UUID('12345678-1234-5678-1234-567812345678')]
    """

    convertToInteger = tokenMap(int)
    """
    Parse action for converting parsed integers to Python int
    """

    convertToFloat = tokenMap(float)
    """
    Parse action for converting parsed numbers to Python float
    """

    integer = Word(nums).setName("integer").setParseAction(convertToInteger)
    """expression that parses an unsigned integer, returns an int"""

    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))
    """expression that parses a hexadecimal integer, returns an int"""

    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)
    """expression that parses an integer with optional leading sign, returns an int"""

    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")
    """fractional expression of an integer divided by an integer, returns a float"""
    fraction.addParseAction(lambda t: t[0]/t[-1])

    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")
    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
    mixed_integer.addParseAction(sum)

    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)
    """expression that parses a floating point number and returns a float"""

    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)
    """expression that parses a floating point number with optional scientific notation and returns a float"""

    # streamlining this expression makes the docs nicer-looking
    number = (sci_real | real | signed_integer).streamline()
    """any numeric expression, returns the corresponding Python type"""

    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)
    """any int or real number, returned as float"""
    
    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")
    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
    
    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")
    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"

    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")
    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")
    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")
    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)
    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")
    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")
    "IPv6 address (long, short, or mixed form)"
    
    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")
    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"

    @staticmethod
    def convertToDate(fmt="%Y-%m-%d"):
        """
        Helper to create a parse action for converting parsed date string to Python datetime.date

        Params -
         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})

        Example::
            date_expr = pyparsing_common.iso8601_date.copy()
            date_expr.setParseAction(pyparsing_common.convertToDate())
            print(date_expr.parseString("1999-12-31"))
        prints::
            [datetime.date(1999, 12, 31)]
        """
        def cvt_fn(s,l,t):
            try:
                return datetime.strptime(t[0], fmt).date()
            except ValueError as ve:
                raise ParseException(s, l, str(ve))
        return cvt_fn

    @staticmethod
    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
        """
        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime

        Params -
         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})

        Example::
            dt_expr = pyparsing_common.iso8601_datetime.copy()
            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
        prints::
            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
        """
        def cvt_fn(s,l,t):
            try:
                return datetime.strptime(t[0], fmt)
            except ValueError as ve:
                raise ParseException(s, l, str(ve))
        return cvt_fn

    iso8601_date = Regex(r'(?P\d{4})(?:-(?P\d\d)(?:-(?P\d\d))?)?').setName("ISO8601 date")
    "ISO8601 date (C{yyyy-mm-dd})"

    iso8601_datetime = Regex(r'(?P\d{4})-(?P\d\d)-(?P\d\d)[T ](?P\d\d):(?P\d\d)(:(?P\d\d(\.\d*)?)?)?(?PZ|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")
    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"

    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")
    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"

    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()
    @staticmethod
    def stripHTMLTags(s, l, tokens):
        """
        Parse action to remove HTML tags from web page HTML source

        Example::
            # strip HTML links from normal text 
            text = 'More info at the pyparsing wiki page'
            td,td_end = makeHTMLTags("TD")
            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
            
            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'
        """
        return pyparsing_common._html_stripper.transformString(tokens[0])

    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 
                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")
    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")
    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""

    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))
    """Parse action to convert tokens to upper case."""

    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))
    """Parse action to convert tokens to lower case."""


if __name__ == "__main__":

    selectToken    = CaselessLiteral("select")
    fromToken      = CaselessLiteral("from")

    ident          = Word(alphas, alphanums + "_$")

    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
    columnNameList = Group(delimitedList(columnName)).setName("columns")
    columnSpec     = ('*' | columnNameList)

    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
    tableNameList  = Group(delimitedList(tableName)).setName("tables")
    
    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")

    # demo runTests method, including embedded comments in test string
    simpleSQL.runTests("""
        # '*' as column list and dotted table name
        select * from SYS.XYZZY

        # caseless match on "SELECT", and casts back to "select"
        SELECT * from XYZZY, ABC

        # list of column names, and mixed case SELECT keyword
        Select AA,BB,CC from Sys.dual

        # multiple tables
        Select A, B, C from Sys.dual, Table2

        # invalid SELECT keyword - should fail
        Xelect A, B, C from Sys.dual

        # incomplete command - should fail
        Select

        # invalid column name - should fail
        Select ^^^ frox Sys.dual

        """)

    pyparsing_common.number.runTests("""
        100
        -100
        +100
        3.14159
        6.02e23
        1e-12
        """)

    # any int or real number, returned as float
    pyparsing_common.fnumber.runTests("""
        100
        -100
        +100
        3.14159
        6.02e23
        1e-12
        """)

    pyparsing_common.hex_integer.runTests("""
        100
        FF
        """)

    import uuid
    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
    pyparsing_common.uuid.runTests("""
        12345678-1234-5678-1234-567812345678
        """)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/_vendor/vendored.txt0000644000175100001710000000011200000000000021612 0ustar00runnerdockerpackaging==21.2
pyparsing==2.2.1
ordered-set==3.1.1
more_itertools==8.8.0
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/archive_util.py0000644000175100001710000001564500000000000020660 0ustar00runnerdocker"""Utilities for extracting common archive formats"""

import zipfile
import tarfile
import os
import shutil
import posixpath
import contextlib
from distutils.errors import DistutilsError

from pkg_resources import ensure_directory

__all__ = [
    "unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
    "UnrecognizedFormat", "extraction_drivers", "unpack_directory",
]


class UnrecognizedFormat(DistutilsError):
    """Couldn't recognize the archive type"""


def default_filter(src, dst):
    """The default progress/filter callback; returns True for all files"""
    return dst


def unpack_archive(
        filename, extract_dir, progress_filter=default_filter,
        drivers=None):
    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``

    `progress_filter` is a function taking two arguments: a source path
    internal to the archive ('/'-separated), and a filesystem path where it
    will be extracted.  The callback must return the desired extract path
    (which may be the same as the one passed in), or else ``None`` to skip
    that file or directory.  The callback can thus be used to report on the
    progress of the extraction, as well as to filter the items extracted or
    alter their extraction paths.

    `drivers`, if supplied, must be a non-empty sequence of functions with the
    same signature as this function (minus the `drivers` argument), that raise
    ``UnrecognizedFormat`` if they do not support extracting the designated
    archive type.  The `drivers` are tried in sequence until one is found that
    does not raise an error, or until all are exhausted (in which case
    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of
    drivers, the module's ``extraction_drivers`` constant will be used, which
    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
    order.
    """
    for driver in drivers or extraction_drivers:
        try:
            driver(filename, extract_dir, progress_filter)
        except UnrecognizedFormat:
            continue
        else:
            return
    else:
        raise UnrecognizedFormat(
            "Not a recognized archive type: %s" % filename
        )


def unpack_directory(filename, extract_dir, progress_filter=default_filter):
    """"Unpack" a directory, using the same interface as for archives

    Raises ``UnrecognizedFormat`` if `filename` is not a directory
    """
    if not os.path.isdir(filename):
        raise UnrecognizedFormat("%s is not a directory" % filename)

    paths = {
        filename: ('', extract_dir),
    }
    for base, dirs, files in os.walk(filename):
        src, dst = paths[base]
        for d in dirs:
            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
        for f in files:
            target = os.path.join(dst, f)
            target = progress_filter(src + f, target)
            if not target:
                # skip non-files
                continue
            ensure_directory(target)
            f = os.path.join(base, f)
            shutil.copyfile(f, target)
            shutil.copystat(f, target)


def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
    """Unpack zip `filename` to `extract_dir`

    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation
    of the `progress_filter` argument.
    """

    if not zipfile.is_zipfile(filename):
        raise UnrecognizedFormat("%s is not a zip file" % (filename,))

    with zipfile.ZipFile(filename) as z:
        for info in z.infolist():
            name = info.filename

            # don't extract absolute paths or ones with .. in them
            if name.startswith('/') or '..' in name.split('/'):
                continue

            target = os.path.join(extract_dir, *name.split('/'))
            target = progress_filter(name, target)
            if not target:
                continue
            if name.endswith('/'):
                # directory
                ensure_directory(target)
            else:
                # file
                ensure_directory(target)
                data = z.read(info.filename)
                with open(target, 'wb') as f:
                    f.write(data)
            unix_attributes = info.external_attr >> 16
            if unix_attributes:
                os.chmod(target, unix_attributes)


def _resolve_tar_file_or_dir(tar_obj, tar_member_obj):
    """Resolve any links and extract link targets as normal files."""
    while tar_member_obj is not None and (
            tar_member_obj.islnk() or tar_member_obj.issym()):
        linkpath = tar_member_obj.linkname
        if tar_member_obj.issym():
            base = posixpath.dirname(tar_member_obj.name)
            linkpath = posixpath.join(base, linkpath)
            linkpath = posixpath.normpath(linkpath)
        tar_member_obj = tar_obj._getmember(linkpath)

    is_file_or_dir = (
        tar_member_obj is not None and
        (tar_member_obj.isfile() or tar_member_obj.isdir())
    )
    if is_file_or_dir:
        return tar_member_obj

    raise LookupError('Got unknown file type')


def _iter_open_tar(tar_obj, extract_dir, progress_filter):
    """Emit member-destination pairs from a tar archive."""
    # don't do any chowning!
    tar_obj.chown = lambda *args: None

    with contextlib.closing(tar_obj):
        for member in tar_obj:
            name = member.name
            # don't extract absolute paths or ones with .. in them
            if name.startswith('/') or '..' in name.split('/'):
                continue

            prelim_dst = os.path.join(extract_dir, *name.split('/'))

            try:
                member = _resolve_tar_file_or_dir(tar_obj, member)
            except LookupError:
                continue

            final_dst = progress_filter(name, prelim_dst)
            if not final_dst:
                continue

            if final_dst.endswith(os.sep):
                final_dst = final_dst[:-1]

            yield member, final_dst


def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`

    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation
    of the `progress_filter` argument.
    """
    try:
        tarobj = tarfile.open(filename)
    except tarfile.TarError as e:
        raise UnrecognizedFormat(
            "%s is not a compressed or uncompressed tar file" % (filename,)
        ) from e

    for member, final_dst in _iter_open_tar(
            tarobj, extract_dir, progress_filter,
    ):
        try:
            # XXX Ugh
            tarobj._extract_member(member, final_dst)
        except tarfile.ExtractError:
            # chown/chmod/mkfifo/mknode/makedev failed
            pass

    return True


extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/build_meta.py0000644000175100001710000002445000000000000020301 0ustar00runnerdocker"""A PEP 517 interface to setuptools

Previously, when a user or a command line tool (let's call it a "frontend")
needed to make a request of setuptools to take a certain action, for
example, generating a list of installation requirements, the frontend would
would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line.

PEP 517 defines a different method of interfacing with setuptools. Rather
than calling "setup.py" directly, the frontend should:

  1. Set the current directory to the directory with a setup.py file
  2. Import this module into a safe python interpreter (one in which
     setuptools can potentially set global variables or crash hard).
  3. Call one of the functions defined in PEP 517.

What each function does is defined in PEP 517. However, here is a "casual"
definition of the functions (this definition should not be relied on for
bug reports or API stability):

  - `build_wheel`: build a wheel in the folder and return the basename
  - `get_requires_for_build_wheel`: get the `setup_requires` to build
  - `prepare_metadata_for_build_wheel`: get the `install_requires`
  - `build_sdist`: build an sdist in the folder and return the basename
  - `get_requires_for_build_sdist`: get the `setup_requires` to build

Again, this is not a formal definition! Just a "taste" of the module.
"""

import io
import os
import sys
import tokenize
import shutil
import contextlib
import tempfile
import warnings

import setuptools
import distutils

from pkg_resources import parse_requirements

__all__ = ['get_requires_for_build_sdist',
           'get_requires_for_build_wheel',
           'prepare_metadata_for_build_wheel',
           'build_wheel',
           'build_sdist',
           '__legacy__',
           'SetupRequirementsError']


class SetupRequirementsError(BaseException):
    def __init__(self, specifiers):
        self.specifiers = specifiers


class Distribution(setuptools.dist.Distribution):
    def fetch_build_eggs(self, specifiers):
        specifier_list = list(map(str, parse_requirements(specifiers)))

        raise SetupRequirementsError(specifier_list)

    @classmethod
    @contextlib.contextmanager
    def patch(cls):
        """
        Replace
        distutils.dist.Distribution with this class
        for the duration of this context.
        """
        orig = distutils.core.Distribution
        distutils.core.Distribution = cls
        try:
            yield
        finally:
            distutils.core.Distribution = orig


@contextlib.contextmanager
def no_install_setup_requires():
    """Temporarily disable installing setup_requires

    Under PEP 517, the backend reports build dependencies to the frontend,
    and the frontend is responsible for ensuring they're installed.
    So setuptools (acting as a backend) should not try to install them.
    """
    orig = setuptools._install_setup_requires
    setuptools._install_setup_requires = lambda attrs: None
    try:
        yield
    finally:
        setuptools._install_setup_requires = orig


def _get_immediate_subdirectories(a_dir):
    return [name for name in os.listdir(a_dir)
            if os.path.isdir(os.path.join(a_dir, name))]


def _file_with_extension(directory, extension):
    matching = (
        f for f in os.listdir(directory)
        if f.endswith(extension)
    )
    try:
        file, = matching
    except ValueError:
        raise ValueError(
            'No distribution was found. Ensure that `setup.py` '
            'is not empty and that it calls `setup()`.')
    return file


def _open_setup_script(setup_script):
    if not os.path.exists(setup_script):
        # Supply a default setup.py
        return io.StringIO(u"from setuptools import setup; setup()")

    return getattr(tokenize, 'open', open)(setup_script)


@contextlib.contextmanager
def suppress_known_deprecation():
    with warnings.catch_warnings():
        warnings.filterwarnings('ignore', 'setup.py install is deprecated')
        yield


class _BuildMetaBackend(object):

    def _fix_config(self, config_settings):
        config_settings = config_settings or {}
        config_settings.setdefault('--global-option', [])
        return config_settings

    def _get_build_requires(self, config_settings, requirements):
        config_settings = self._fix_config(config_settings)

        sys.argv = sys.argv[:1] + ['egg_info'] + \
            config_settings["--global-option"]
        try:
            with Distribution.patch():
                self.run_setup()
        except SetupRequirementsError as e:
            requirements += e.specifiers

        return requirements

    def run_setup(self, setup_script='setup.py'):
        # Note that we can reuse our build directory between calls
        # Correctness comes first, then optimization later
        __file__ = setup_script
        __name__ = '__main__'

        with _open_setup_script(__file__) as f:
            code = f.read().replace(r'\r\n', r'\n')

        exec(compile(code, __file__, 'exec'), locals())

    def get_requires_for_build_wheel(self, config_settings=None):
        config_settings = self._fix_config(config_settings)
        return self._get_build_requires(
            config_settings, requirements=['wheel'])

    def get_requires_for_build_sdist(self, config_settings=None):
        config_settings = self._fix_config(config_settings)
        return self._get_build_requires(config_settings, requirements=[])

    def prepare_metadata_for_build_wheel(self, metadata_directory,
                                         config_settings=None):
        sys.argv = sys.argv[:1] + [
            'dist_info', '--egg-base', metadata_directory]
        with no_install_setup_requires():
            self.run_setup()

        dist_info_directory = metadata_directory
        while True:
            dist_infos = [f for f in os.listdir(dist_info_directory)
                          if f.endswith('.dist-info')]

            if (
                len(dist_infos) == 0 and
                len(_get_immediate_subdirectories(dist_info_directory)) == 1
            ):

                dist_info_directory = os.path.join(
                    dist_info_directory, os.listdir(dist_info_directory)[0])
                continue

            assert len(dist_infos) == 1
            break

        # PEP 517 requires that the .dist-info directory be placed in the
        # metadata_directory. To comply, we MUST copy the directory to the root
        if dist_info_directory != metadata_directory:
            shutil.move(
                os.path.join(dist_info_directory, dist_infos[0]),
                metadata_directory)
            shutil.rmtree(dist_info_directory, ignore_errors=True)

        return dist_infos[0]

    def _build_with_temp_dir(self, setup_command, result_extension,
                             result_directory, config_settings):
        config_settings = self._fix_config(config_settings)
        result_directory = os.path.abspath(result_directory)

        # Build in a temporary directory, then copy to the target.
        os.makedirs(result_directory, exist_ok=True)
        with tempfile.TemporaryDirectory(dir=result_directory) as tmp_dist_dir:
            sys.argv = (sys.argv[:1] + setup_command +
                        ['--dist-dir', tmp_dist_dir] +
                        config_settings["--global-option"])
            with no_install_setup_requires():
                self.run_setup()

            result_basename = _file_with_extension(
                tmp_dist_dir, result_extension)
            result_path = os.path.join(result_directory, result_basename)
            if os.path.exists(result_path):
                # os.rename will fail overwriting on non-Unix.
                os.remove(result_path)
            os.rename(os.path.join(tmp_dist_dir, result_basename), result_path)

        return result_basename

    def build_wheel(self, wheel_directory, config_settings=None,
                    metadata_directory=None):
        with suppress_known_deprecation():
            return self._build_with_temp_dir(['bdist_wheel'], '.whl',
                                             wheel_directory, config_settings)

    def build_sdist(self, sdist_directory, config_settings=None):
        return self._build_with_temp_dir(['sdist', '--formats', 'gztar'],
                                         '.tar.gz', sdist_directory,
                                         config_settings)


class _BuildMetaLegacyBackend(_BuildMetaBackend):
    """Compatibility backend for setuptools

    This is a version of setuptools.build_meta that endeavors
    to maintain backwards
    compatibility with pre-PEP 517 modes of invocation. It
    exists as a temporary
    bridge between the old packaging mechanism and the new
    packaging mechanism,
    and will eventually be removed.
    """
    def run_setup(self, setup_script='setup.py'):
        # In order to maintain compatibility with scripts assuming that
        # the setup.py script is in a directory on the PYTHONPATH, inject
        # '' into sys.path. (pypa/setuptools#1642)
        sys_path = list(sys.path)           # Save the original path

        script_dir = os.path.dirname(os.path.abspath(setup_script))
        if script_dir not in sys.path:
            sys.path.insert(0, script_dir)

        # Some setup.py scripts (e.g. in pygame and numpy) use sys.argv[0] to
        # get the directory of the source code. They expect it to refer to the
        # setup.py script.
        sys_argv_0 = sys.argv[0]
        sys.argv[0] = setup_script

        try:
            super(_BuildMetaLegacyBackend,
                  self).run_setup(setup_script=setup_script)
        finally:
            # While PEP 517 frontends should be calling each hook in a fresh
            # subprocess according to the standard (and thus it should not be
            # strictly necessary to restore the old sys.path), we'll restore
            # the original path so that the path manipulation does not persist
            # within the hook after run_setup is called.
            sys.path[:] = sys_path
            sys.argv[0] = sys_argv_0


# The primary backend
_BACKEND = _BuildMetaBackend()

get_requires_for_build_wheel = _BACKEND.get_requires_for_build_wheel
get_requires_for_build_sdist = _BACKEND.get_requires_for_build_sdist
prepare_metadata_for_build_wheel = _BACKEND.prepare_metadata_for_build_wheel
build_wheel = _BACKEND.build_wheel
build_sdist = _BACKEND.build_sdist


# The legacy backend
__legacy__ = _BuildMetaLegacyBackend()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/cli-32.exe0000644000175100001710000020000000000000000017301 0ustar00runnerdockerMZÿÿ¸@ິ	Í!¸LÍ!This program cannot be run in DOS mode.

$YSþj292929:ôë9292‘9F29 }929`9929`929`9m29`929Rich29PELø°‹Qà	ÊNç%à@@€,ù(ˆô@à@.text]ÉÊ `.rdata` à"Î@@.dataÄ+ð@ÀQ‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPès
ƒÄ3ÿ3Û‰D$Æ"p…í~W뛋L$Š<\uGë <"u…ÿ~Wj\Vè
ƒÄ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ÷‹D$_Æ"ÆF^][YÃì¡€A3ĉ„$V‹´$W‹¼$Š‹Ï„Àtd$AƒÀ@PèƒÄF^‹Œ$3Ìè!	ÄÃWhŒ$ QV虫V¼,訊„$,ƒÄH@;ÇsŠ„Ét
€ù
t€ù
uëj”$ hâ@RÆèT
ƒÄ…Àt2¡â@‹
â@‹â@‰„$ â@‰Œ$ ‰”$$ˆ„$(L$Q”$"Rè…ûÿÿ‹0‰D$ D$$PVè$úÿÿ‹øƒÄ‰|$…ÿuVhàá@éµS‹\$U‹¬$,+‰D$@jPèå‹ðW‰t$èCùÿÿ‰¿ƒÄƒÆ;ß~‹ÿ‹L$ ‹¹Rè#ùÿÿ‰GƒÄƒÆ;û|æD$$Pèùÿÿ‰¿ƒÄƒÆ;ï~‹L$‹¹Rèîøÿÿ‰GƒÄƒÆ;ý|惼$4]Ç[tE‹D$‹t$PVè$¤ƒÄVhÌá@蓃À@PènƒÄ_¸^‹Œ$3ÌèsÄËL$‹T$‹D$QRPè†üÿÿPèÀûÿÿ‹Œ$,ƒÄ_^3Ìè?ÄÃÌÌÌÌÌÌ‹D$‹L$jPQèýÿÿƒÄÃjhðô@èŸ3ö‰uä3À‹];Þ•À;Æu è;ÇVVVVVèÃăÈÿéÍ3À9u•À;ÆtÔ‰]SèŸY‰uüöC@uwSè*Yƒøÿtƒøþt‹ÐÁú‹ÈƒáÁá• *A빘AöA$u)ƒøÿtƒøþt‹ÈÁùƒàÁà *A븘Aö@$€tè¡ÇVVVVVè)ƒÄƒMäÿ9uäu#SèL
‹øEPVÿuS貉EäSWèÎ
ƒÄÇEüþÿÿÿè	‹EäèßÃÿuèLYøAáÀ;AVj^…Àu¸ë;Æ}‹Æ£À;AjPè“ YY£¼+A…ÀujV‰5À;Aèz YY£¼+A…ÀujX^Ã3Ò¹A롼+A‰ƒÁ ƒÂù€A|êjþ^3Ò¹AW‹ÂÁø‹… *A‹úƒçÁ狃øÿt;Æt…Àu‰1ƒÁ BùpA|Î_3À^Ãè§#€=0 Atèp!ÿ5¼+Aè× YËÿU‹ìV‹u¸A;ðr"þ`Aw‹Î+ÈÁùƒÁQèç$N€Yë
ƒÆ Vÿà@^]ËÿU‹ì‹Eƒø}ƒÀPèº$‹EH€Y]ËEƒÀ Pÿà@]ËÿU‹ì‹E¹A;Ár=`Aw`ÿÿÿ+ÁÁøƒÀPè—#Y]ÃÀ Pÿà@]ËÿU‹ì‹Mƒù‹E}`ÿÿÿƒÁQèh#Y]ÃÀ Pÿà@]ËÿU‹ìQƒeüVEüPÿuÿuèL$‹ðƒÄ…öu9Eütèa…Àt
èX‹Mü‰‹Æ^ÉÃÌÌÌÌÌÌÌÌÌÌ‹T$‹L$…Òti3ÀŠD$„Àuúrƒ=ˆ*Atée%W‹ùƒúr1÷Ùƒát+шƒÇƒéuö‹ÈÁàÁ‹ÈÁàÁ‹ÊƒâÁétó«…Òt
ˆƒÇƒêuö‹D$_ËD$ÃÌÌÌÌÌÌ‹L$W…É„’VS‹Ù‹t$÷Æ‹|$uÁé……ë'ŠƒÆˆƒÇƒét+„Àt/÷Æuå‹ÙÁéuaƒãtŠƒÆˆƒÇ„Àt7ƒëuí‹D$[^_Ã÷ÇtˆƒÇƒé„˜÷Çuê‹ÙÁéutˆƒÇƒëuö[^‹D$_ɃǃétŸºÿþþ~‹Ѓðÿ3‹ƒÆ©tÜ„Òt,„öt÷Âÿt÷Âÿuĉëâÿÿ‰ëâÿ‰ë3Ò‰ƒÇ3Àƒét3À‰ƒÇƒéuöƒã…wÿÿÿ‹D$[^_ËÿU‹ìÿuÿuÿuÿujÿÿuè %ƒÄ]ËÿU‹ìQQS3ÛVW‰]ø9]t}‹M;Ëu9]uqë9]tj9]u9]u`ë9]tY9]u9] uOë9] tH9]$u>9](u>‹u3À@8tHF;Ãwö€>:u5;Ëtƒ}‚õjÿujÿQè%&ƒÄF‰uë9](uÂÇEøéÎ;Ëtˆ‹u3ÿ‰]ü8tU¾PèØ%Y…ÀtFëŠé¤þÿÿ‹ÿU‹ìV‹uVèSPè?YY…Àt|èÐòÿÿƒÀ ;ðu3ÀëèÀòÿÿƒÀ@;ðu`3À@ÿ A÷FuNSW<…H Aƒ?»u Sè	Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N3À_@[ë3À^]ËÿU‹ìƒ}t'V‹u÷FtVèfÿîÿÿƒfƒ&ƒfY^]ÃöA@tƒyt$ÿIx‹ˆÿ¶Àë¾ÀQPèå-YYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìöG@SV‹ð‹Ùt2ƒu,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕƒ8*u‹Ï°?èdÿÿÿƒ}Õ^[]ËÿU‹ììx¡€A3ʼnEüS‹]V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè#÷ÿÿ…öu5èMÇ3ÀPPPPPèӃĀ½°ýÿÿt
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF@u^Vè@
Yº˜Aƒøÿtƒøþt‹Èƒá‹ðÁþÁáµ *Aë‹ÊöA$u‘ƒøÿtƒøþt‹ÈƒàÁùÁà *Aë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu¡A‰…äýÿÿ‹…äýÿÿëI€8t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ…\‹…ðýÿÿ¨@t2©t	Æ…Ôýÿÿ-ë¨t	Æ…Ôýÿÿ+ë¨tÆ…Ôýÿÿ Ç…Ðýÿÿ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿuÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄƒ½Èýÿÿ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFè5ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿYuµëƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ|ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄƒ½¼ýÿÿtÿµ¼ýÿÿ胥¼ýÿÿY‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿt
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èìÿÿÉÃê*@ë(@)@y)@Å)@Ð)@*@D+@jThPõ@èe3ÿ‰}üEœPÿ@à@ÇEüþÿÿÿj@j ^VèuYY;Ç„£ *A‰5*Aˆë0Æ@ƒÿÆ@
‰xÆ@$Æ@%
Æ@&
‰x8Æ@4ƒÀ@‹
 *AÁ;ÁrÌf9}΄
‹EÐ;Ç„ÿ‹8X;‰Eä¾;þ|‹þÇEàë[j@j èçYY…ÀtV‹Mà *A‰ƒ*A ë*Æ@ƒÿÆ@
ƒ`€`$€Æ@%
Æ@&
ƒ`8Æ@4ƒÀ@‹Ö;ÂrÒÿEà9=*A|ë‹=*Aƒeà…ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨uQÿ<à@…Àt<‹uà‹ÆÁøƒæÁæ4… *A‹E䋉ŠˆFh FPè€*YY…À„ÉÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A‹ƒøÿtƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ8à@‹øƒÿÿtC…ÿt?Wÿ<à@…Àt4‰>%ÿƒøu€N@ë	ƒøu€Nh FPèê)YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*Aÿ4à@3Àë3À@ËeèÇEüþÿÿÿƒÈÿècËÿU‹ì‹EV3ö;Æuè½VVVVVÇèEƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A]ËÿU‹ìì(¡€A3ʼnEüƒ¥ØüÿÿSjL…ÜüÿÿjPèåÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…ØüÿÿÀÇ…Üüÿÿ‰…äüÿÿÿXà@j‹ØÿTà@…(ýÿÿPÿPà@…Àu…Ûujèé1YhÀÿLà@PÿHà@‹Mü3Í[è(èÿÿÉËÿU‹ìÿ5P Aè&Y…Àt]ÿàjèª1Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØAtAƒù-rñHíƒùwj
X]ËÍÜA]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ã蜅Àu¸@AÃÀÃ艅Àu¸DAÃÀËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌhÐ7@dÿ5‹D$‰l$l$+àSVW¡€A1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹]V‹s35€AW‹ÆEÿÇEô{ƒøþt
‹NÏ38èÙæÿÿ‹N‹FÏ38èÉæÿÿ‹Eö@f…‹MUè‰Sü‹[‰Eè‰Mìƒûþt_I[‹L†D†‰Eð‹‰Eø…Ét‹×è$1ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿt$‹ƒøþt
‹NÏ38èVæÿÿ‹N‹VÏ3:èFæÿÿ‹Eô_^[‹å]ÃÇEôëÉ‹M9csmàu)ƒ=Œ*At hŒ*Aèƒ!ƒÄ…Àt‹UjRÿŒ*AƒÄ‹MèÇ0‹E9Xth€AW‹Ó‹ÈèÊ0‹E‹Mø‰H‹ƒøþt
‹NÏ38èÃåÿÿ‹N‹VÏ3:è³åÿÿ‹Eð‹H‹×è]0ºþÿÿÿ9S„Rÿÿÿh€AW‹Ëèu0éÿÿÿ‹ÿU‹ìVW3öÿuèÅ0‹øY…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öjÿuÿuèE‹øƒÄ…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿuÿuèû0‹øYY…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿuÿuèÅ2‹øƒÄ…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿu½‹Ç_^]Ãjhpõ@è×üÿÿ‹u…ötuƒ=„*AuCjèYƒeüVè×2Y‰Eä…Àt	VPèø2YYÇEüþÿÿÿèƒ}äu7ÿuë
jèYÃVjÿ5t)Aÿ`à@…Àuè üÿÿ‹ðÿ\à@PèÐûÿÿ‰Yè›üÿÿÃjhõ@èIüÿÿ3Û‰]äjè–Y‰]üj_‰}à;=À;A}W‹÷Á桼+AÆ9tD‹ö@ƒtPèj=YƒøÿtÿEäƒÿ|(¡¼+A‹ƒÀ PÿDà@¡¼+Aÿ4èýþÿÿY¡¼+A‰GëžÇEüþÿÿÿè	‹EäèüÿÿÃjè7YËÿU‹ìSV‹u‹F‹È€á3Û€ùu@©t9‹FW‹>+ø…ÿ~,WPVèeùÿÿYPè‡DƒÄ;Çu‹F„Àyƒàý‰FëƒN ƒËÿ_‹Fƒf‰^‹Ã[]ËÿU‹ìV‹u…öu	Vè5Yë/Vè|ÿÿÿY…ÀtƒÈÿë÷F@tVèüøÿÿPèûDY÷ØYÀë3À^]Ãjh°õ@èúúÿÿ3ÿ‰}ä‰}ÜjèDY‰}ü3ö‰uà;5À;Aƒ¡¼+A°98t^‹ö@ƒtVPVèDÝÿÿYY3ÒB‰Uü¡¼+A‹°‹HöÁƒt/9UuPèJÿÿÿYƒøÿtÿEäë9}uöÁtPè/ÿÿÿYƒøÿu	E܉}üèFë„3ÿ‹uࡼ+Aÿ4°VèMÝÿÿYYÃÇEüþÿÿÿèƒ}‹Eät‹EÜè{úÿÿÃjè­YÃjèÿÿÿYËÿVW3ö¿X Aƒ<õLAuõHA‰8h ÿ0ƒÇè}!YY…ÀtFƒþ$|Ò3À@_^Ã$õHA3Àëñ‹ÿS‹Dà@V¾HAW‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ&YƒÆþhA|ܾHA_‹…Àt	ƒ~uPÿÓƒÆþhA|æ^[ËÿU‹ì‹Eÿ4ÅHAÿà@]ÃjhØõ@è^ùÿÿ3ÿG‰}ä3Û9t)Auè´jèhÿè€ãÿÿYY‹u4õHA9t‹Çënjè	ûÿÿY‹ø;ûuèÅøÿÿÇ3ÀëQj
èYY‰]ü9u,h Wèt YY…ÀuWèþûÿÿYèøÿÿÇ‰]äë‰>ëWèãûÿÿYÇEüþÿÿÿè	‹EäèöøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHAƒ>uPè"ÿÿÿY…ÀujètâÿÿYÿ6ÿà@^]Ãjhøõ@èhøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;EÀ@uèÿ÷ÿÿÇWWWWWè‡÷ÿÿƒÄ3ÀéÕ¯M‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*AuKƒÆƒæð‰u‹E;p*Aw7jèLÿÿÿY‰}üÿuèè5Y‰EäÇEüþÿÿÿè_‹]ä;ßtÿuWSè6ÛÿÿƒÄ;ßuaVjÿ5t)Aÿdà@‹Ø;ßuL9=€)At3Vè’Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇéEÿÿÿ3ÿ‹ujèðýÿÿYÃ;ßu
‹E;ÇtÇ‹Ãèœ÷ÿÿÃU‹ìƒì‰}ü‹}‹MÁéfïÀë¤$ffGfG fG0fG@fGPfG`fGp¿€IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRjQè~ÿÿÿƒÄ‹E‹}ü‹å]Ãjhö@èdöÿÿƒeüf(ÁÇEäë#‹Eì‹‹=Àt
=Àt3ÀÃ3À@ËeèƒeäÇEüþÿÿÿ‹EäèföÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+ÑtQ3À¢‰Eô‰]è‰Uì‰M𸢉Uü‰Eø[÷Eütè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A3ÀËÿU‹ìQSV‹u3ÛW;ót9]w èIõÿÿjYSSSSS‹ñ‰èÐôÿÿƒÄ‹ÆéÍ‹E3ÿ;ÃtŠ:Ãtj_9}†ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹UG‰}ü;úsyŠˆF@8uèPQèŒ@ŠYYŠˆF@8uð‹E;Ãt'Š:Ët!€ù.tG;}sÆ.FëG;}sŠˆF@8uðG;}v‹Eˆèlôÿÿj"éÿÿÿˆ3À_^[ÉËÿU‹ìƒìÿuMðèÜÿÿ¶E‹MôŠU„Tuƒ}t‹Mð‹‰È·A#Eë3À…Àt3À@€}üt‹MøƒapýÉËÿU‹ìjjÿuÿuè™ÿÿÿƒÄ]ËÿU‹ìjjÿujèÿÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuè…?ƒÄ]ËÿU‹ìì(£°"A‰
¬"A‰¨"A‰¤"A‰5 "A‰=œ"AfŒÈ"AfŒ
¼"AfŒ˜"AfŒ”"AfŒ%"AfŒ-Œ"AœÀ"A‹E£´"A‹E£¸"AE£Ä"A‹…àüÿÿÇ"A¡¸"A£´!AǨ!A	ÀǬ!A¡€A‰…Øüÿÿ¡„A‰…ÜüÿÿÿXà@£ø!AjèO$YjÿTà@hÔâ@ÿPà@ƒ=ø!Aujè+$Yh	ÀÿLà@PÿHà@ÉÃ-¤t"ƒètƒè
tHt3ÀøøøøËÿVW‹ðh3ÿFWPè+Öÿÿ3À·È‹Á‰~‰~‰~ÁáÁ~«««¹hAƒÄF+οŠˆ@Ou÷†¾Šˆ@Nu÷_^ËÿU‹ìì¡€A3ʼnEüSW…èúÿÿPÿvÿhà@¿…À„û3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj RèhÕÿÿƒÄCŠC„ÀuØjÿv…üúÿÿÿvPW…üþÿÿPjjèE3ÛSÿv…üýÿÿWPW…üþÿÿPWÿvSèúBƒÄDSÿv…üüÿÿWPW…üþÿÿPhÿvSèÕBƒÄ$3À·ŒEüúÿÿöÁt€LŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒëÆ„@;Çr¾ëV†Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ÐZ ƒûw€LŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆA;Ïr‹Mü_3Í[èOØÿÿÉÃjh8ö@èÏðÿÿè˜
‹ø¡ŒA…Gptƒlt‹wh…öuj èžÚÿÿY‹ÆèçðÿÿÃj
èó÷ÿÿYƒeü‹wh‰uä;5At6…ötVÿpà@…ÀuþhAtVè‡óÿÿY¡A‰Gh‹5A‰uäVÿlà@ÇEüþÿÿÿè뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðè¤×ÿÿ‰Ì$AƒþþuÇÌ$Aÿxà@8]ütE‹Møƒapýë<ƒþýuÇÌ$Aÿtà@ëÛƒþüu‹Eð‹@ÇÌ$AëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A3ʼnEüS‹]V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé‰uä3À9¸˜A„‘ÿEäƒÀ0=ðrçÿèý„pÿéý„d·ÇPÿ|à@…À„REèPWÿhà@…À„3hCVPèˆÒÿÿ3ÒBƒÄ‰{‰s9Uè†ø€}î„ÏuɄ¶Fÿ¶Éé¦hCVPèAÒÿÿ‹MäƒÄkÉ0‰u౨A‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”AD;¶FG;øvê‹}FF€>uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇCègûÿÿj‰CC‰œAZf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L@;ÁvöFF€~ÿ…4ÿÿÿC¹þ€@Iuù‹Cèûÿÿ‰C‰Së‰s3À·È‹ÁÁáÁ{«««ë¨95Ì$A…XþÿÿƒÈÿ‹Mü_^3Í[èJÕÿÿÉÃjhXö@èÊíÿÿƒMàÿè‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„Wh è‚ïÿÿY‹Ø…Û„F¹ˆ‹wh‹ûó¥ƒ#Sÿuè¸ýÿÿYY‰Eà…À…ü‹uÜÿvhÿpà@…Àu‹Fh=hAtPècðÿÿY‰^hS‹=là@ÿ×öFp…êöŒA…Ýj
ètôÿÿYƒeü‹C£Ü$A‹C£à$A‹C£ä$A3À‰Eäƒø}f‹LCf‰EÐ$A@ëè3À‰Eä=}
ŠLˆˆˆA@ëé3À‰Eä=}ŠŒˆˆA@ëæÿ5Aÿpà@…Àu¡A=hAtPèªïÿÿY‰ASÿ×ÇEüþÿÿÿèë0j
èíòÿÿYÃë%ƒøÿu ûhAtSètïÿÿYèìÿÿÇëƒeà‹Eàè‚ìÿÿÃ=°+AujýèVþÿÿYÇ°+A3ÀËÿU‹ìSV‹u‹†¼3ÛW;Ãto=HAth‹†°;Ãt^9uZ‹†¸;Ãt9uPèûîÿÿÿ¶¼è;AYY‹†´;Ãt9uPèÚîÿÿÿ¶¼èÕ@YYÿ¶°èÂîÿÿÿ¶¼è·îÿÿYY‹†À;ÃtD9u@‹†Ä-þPè–îÿÿ‹†Ì¿€+ÇPèƒîÿÿ‹†Ð+ÇPèuîÿÿÿ¶ÀèjîÿÿƒÄ¾Ô‹=ˆAt9˜´uPè»>ÿ7èCîÿÿYY~PÇEøAt‹;Ãt9uPèîÿÿY9_üt‹G;Ãt9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@W‹}WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒSV‹5pà@WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ>Yuþ˜AtVèYýÿÿY‹Ç^Ã3ÀÃjhxö@ècéÿÿè,‹ð¡ŒA…Fpt"ƒ~ltè‹pl…öuj è-ÓÿÿY‹ÆèvéÿÿÃjè‚ðÿÿYƒeüFl‹=pAèiÿÿÿ‰EäÇEüþÿÿÿèëÁjè}ïÿÿY‹uäËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€øë'¾tã@Vÿ à@…ÀuVènÒÿÿY…Àthdã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãjè‡ÿÿÿYËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€üë'¾tã@Vÿ à@…ÀuVèóÑÿÿY…Àthã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãÿ„à@‹ÿVÿ5„Aÿ€à@‹ð…öuÿ5%AèeÿÿÿY‹ðVÿ5„Aÿˆà@‹Æ^á€AƒøÿtPÿ5%Aè;ÿÿÿYÿЃ
€Aÿ¡„AƒøÿtPÿŒà@ƒ
„Aÿéºíÿÿjh˜ö@è†çÿÿ¾tã@Vÿ à@…ÀuVè4ÑÿÿY‰Eä‹uÇF\é@3ÿG‰~…Àt$hdã@P‹(à@ÿÓ‰†øhã@ÿuäÿÓ‰†ü‰~pƆÈCƆKCÇFhhAj
ènîÿÿYƒeüÿvhÿlà@ÇEüþÿÿÿè>jèMîÿÿY‰}ü‹E‰Fl…Àu¡pA‰FlÿvlèüÿÿYÇEüþÿÿÿèè	çÿÿÃ3ÿG‹uj
è5íÿÿYÃjè,íÿÿYËÿVWÿ\à@ÿ5€A‹øè‘þÿÿÿЋð…öuNhjè±èÿÿ‹ðYY…öt:Vÿ5€Aÿ5%AèèýÿÿYÿÐ…ÀtjVèÅþÿÿYYÿ”à@ƒNÿ‰ë	Vè^éÿÿY3öWÿà@_‹Æ^ËÿVèÿÿÿ‹ð…öujèÐÿÿY‹Æ^ÃjhÀö@èæÿÿ‹u…ö„ø‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@tPè¬èÿÿYj
èàìÿÿYƒeü‹~h…ÿtWÿpà@…ÀuÿhAtWèèÿÿYÇEüþÿÿÿèWjè§ìÿÿYÇEü‹~l…ÿt#WèóúÿÿY;=pAtÿ˜Atƒ?uWèÿøÿÿYÇEüþÿÿÿèVè'èÿÿYèIåÿÿ‹uj
èvëÿÿYËujèjëÿÿYËÿVW¾tã@Vÿ à@…ÀuVè“ÎÿÿY‹ø…ÿ„^‹5(à@hÀã@WÿÖh´ã@W£%AÿÖh¨ã@W£%AÿÖh ã@W£%AÿÖƒ=%A‹5ˆà@£%Atƒ=%At
ƒ=%At…Àu$¡€à@£%A¡Œà@Ç%AdO@‰5%A£%Aÿ„à@£„Aƒøÿ„Ìÿ5%APÿÖ…À„»èÅÐÿÿÿ5%Aèûÿÿÿ5%A£%Aèûÿÿÿ5%A£%Aèóúÿÿÿ5%A£%AèãúÿÿƒÄ£%Aè¬éÿÿ…ÀtehXQ@ÿ5%Aè=ûÿÿYÿУ€AƒøÿtHhjèÓåÿÿ‹ðYY…öt4Vÿ5€Aÿ5%Aè
ûÿÿYÿÐ…ÀtjVèçûÿÿYYÿ”à@ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèèÉÊÿÿ‹]C=w‹E苀ȷXëu‰]Á}EèP‹E%ÿPèGYY…ÀtŠEjˆEøˆ]ùÆEúYë
3Ɉ]øÆEùA‹EèjÿpÿpEüPQEøPEèjPè6ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E€}ôt‹Mðƒapý[ÉËÿU‹ìQV‹uVèwàÿÿ‰E‹FY¨‚uè8âÿÿÇ	ƒN ƒÈÿé/¨@t
èâÿÿÇ"ëãS3Û¨t‰^¨„‡‹Nƒàþ‰‰F‹FƒàïƒÈ‰F‰^‰]ü©u,è—ÃÿÿƒÀ ;ðtè‹ÃÿÿƒÀ@;ðu
ÿuè©Y…ÀuVè¾?Y÷FW„€‹F‹>H‰‹N+øI;û‰N~WPÿuèÜ*ƒÄ‰EüëMƒÈ ‰FƒÈÿëy‹Mƒùÿtƒùþt‹Áƒà‹ÑÁúÁà• *A븘Aö@ tjSSQè*>#ƒÄƒøÿt%‹FŠMˆë3ÿGWEPÿuèm*ƒÄ‰Eü9}üt	ƒN ƒÈÿë‹E%ÿ_[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü;ýˆAt	G‰}üƒÿrîƒÿƒwjèz@Yƒø„4jèi@Y…Àu
ƒ=ŒA„ûü„Ahpé@»S¿ %AWè08ƒÄ…Àt
VVVVVèØÞÿÿƒÄh¾9%AVjÆ=&Aÿà@…Àu&hXé@hûVèî7ƒÄ…Àt3ÀPPPPPè”ÞÿÿƒÄVè‡@YƒøYƒøtjèñ>Y…Àuƒ=ŒAuhüè)þÿÿhÿèþÿÿYYËÿU‹ìQSVWÿ5¬+AèÊöÿÿÿ5¨+A‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ‹Þ+ßCƒørwWèÕ>‹øCY;øsH¸;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+AÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ£¬+A£¨+A…öujX^Ã&3À^Ãjhèö@èeÞÿÿèÀÈÿÿƒeüÿuèøþÿÿY‰EäÇEüþÿÿÿè	‹EäèÞÿÿÃèŸÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@¾àô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@¾èô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@Aÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZf9t3À]ËA<Á8PEuï3Ò¹f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹}‹H;ùr	‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@hÐ7@d¡PƒìSVW¡€A1Eø3ÅPEðd£‰eèÇEüh@è*ÿÿÿƒÄ…ÀtU‹E-@Ph@èPÿÿÿƒÄ…Àt;‹@$Áè÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò=À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh(÷@èWÜÿÿè öÿÿ‹@x…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿè—<èpÜÿÿÃh
[@è'óÿÿY£4(AÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F‹V\¡tAW‹}‹ÊS99t‹ØkÛƒÁÚ;ËrîkÀÂ;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéûƒûuƒ`3À@éêƒû„Þ‹N`‰Mø‹M‰N`‹Hƒù…¸‹
hA‹=lA‹Ñù;×}$kÉ‹~\ƒd9‹=hA‹lAB߃Á;Ó|â‹]ü‹‹~d=ŽÀu	ÇFdƒë^=Àu	ÇFdëN=‘Àu	ÇFd„ë>=“Àu	ÇFd…ë.=Àu	ÇFd‚ë=Àu	ÇFd†ë=’ÀuÇFdŠÿvdjÿÓY‰~dëƒ`QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A£<(A£@(A£D(A]ËÿU‹ì‹E‹
tAV9Pt‹ñköuƒÀ;ÆrìkÉM^;Ás9Pt3À]Ãÿ5@(AèÚñÿÿYÃj hH÷@èJÚÿÿ3ÿ‰}ä‰}Ø‹]ƒûLt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa¾8(A¡8(Aë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+HtèŽÙÿÿÇ3ÀPPPPPèÙÿÿƒÄ뮾@(A¡@(Aë¾<(A¡<(Aë
¾D(A¡D(AÇEäPèñÿÿ‰EàY3Àƒ}à„Ø9EàujèòÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒûtƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒƒûu.‹
hA‰MÜ‹
lA‹hAÊ9MÜ}‹MÜkÉ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿèƒûuÿwdSÿUàYë‹]‹}؃}ätjèTßÿÿYÃSÿUàYƒût
ƒûtƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèìØÿÿËÿU‹ì‹E£L(A]ËÿU‹ì‹E£X(A]ËÿU‹ì‹E£\(A]Ãjhh÷@èmØÿÿƒeüÿuÿuÿ à@‰Eäë/‹Eì‹‹‰Eà3É=À”Á‹ÁËeè}àÀujÿà@ƒeäÇEüþÿÿÿ‹Eäè_ØÿÿËÿU‹ì‹E£`(A]ËÿU‹ìÿ5`(Aè|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹8csmàu*ƒxu$‹@= “t=!“t="“t=@™uèCûÿÿ3À]ÂhŽ_@ÿTà@3ÀÃ=°+AuèHëÿÿV‹5< AW3ÿ…öuƒÈÿé <=tGVèƒYtŠ„ÀuêjGWè€Ùÿÿ‹øYY‰= A…ÿtË‹5< ASëBVèR‹ØC€>=Yt1jSèRÙÿÿYY‰…ÀtNVSPè|.ƒÄ…Àt3ÀPPPPPè"ÕÿÿƒÄƒÇó€>u¹ÿ5< AèÚÿÿƒ%< Aƒ'Ǥ+A3ÀY[_^Ãÿ5 AèÝÙÿÿƒ% AƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹UÇ9Et	‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰UŠ¶ÃPFèâÿÿY…Àtÿƒ}t
‹MŠÿEˆF‹U‹M„Ût2ƒ}üu©€û t€û	uŸ…ÒtÆBÿƒeü€>„éŠ< t<	uFëóNëã€>„Ѓ}t	‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁuƒ}ütF€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰UŠ„ÀtUƒ}üu< tK<	tG…Ût=¾ÀP…Òt#è9áÿÿY…Àt
Š‹MÿEˆFÿ‹MŠÿEˆë
èáÿÿY…ÀtFÿÿ‹UFéVÿÿÿ…ÒtÆB‰Uÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒìS3ÛVW9°+AuèÄèÿÿh¾h(AVSˆl)Aÿà@¡ +A‰5( A;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ=ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6PèƒÖÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄH£ A‰5 A3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)AƒìSV‹5´à@W3Û3ÿ;Ãu.ÿÖ‹ø;ûtÇp)Aë#ÿ\à@ƒøxu
jX£p)Aë¡p)Aƒø…;ûuÿÖ‹ø;ûu3ÀéÊ‹Çf9t@@f9uù@@f9uò‹5°à@SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/Pè©ÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…Àuÿuüè¸ÖÿÿY‰]ü‹]üWÿ¬à@‹Ãë\ƒøt;Ãu‚ÿ¨à@‹ð;ó„rÿÿÿ8t
@8uû@8uö+Æ@P‰EøèBÕÿÿ‹øY;ûuVÿ¤à@éEÿÿÿÿuøVWè©+ƒÄVÿ¤à@‹Ç_^[ÉËÿU‹ì3À9Ej”ÀhPÿ¸à@£t)A…Àu]Ã3À@£„*A]ËÿU‹ìƒì¡€AƒeøƒeüSW¿Næ@»»ÿÿ;Çt
…Ãt	÷У„Aë`VEøPÿÌà@‹uü3uøÿÈà@3ðÿ”à@3ðÿÄà@3ðEðPÿÀà@‹Eô3Eð3ð;÷u¾Oæ@»ë…óu‹ÆÁàð‰5€A÷Ö‰5„A^_[ÉËÿU‹ì‹EƒøþuèÒÿÿÇ	3À]ÃV3ö;Æ|;*ArèæÑÿÿVVVVVÇ	ènÑÿÿƒÄ3Àë‹ÈƒàÁù‹ *AÁà¾Dƒà@^]á€AƒÈ3É9x)A”Á‹ÁÃÌÌÌÌÌÌÌÌ‹L$÷Át$ŠƒÁ„ÀtN÷Áuï¤$¤$‹ºÿþþ~Ѓðÿ3ƒÁ©tè‹Aü„Àt2„ät$©ÿt©ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u3ÛW‹};óu;ûv‹E;Ãt‰3À郋E;ÃtƒÿÿÿÿÿvèÇÐÿÿj^SSSSS‰0èPÐÿÿƒÄ‹ÆëVÿuMðès¸ÿÿ‹Eð9X…œf‹E¹ÿf;Áv6;ót;ûvWSVè8´ÿÿƒÄètÐÿÿÇ*èiÐÿÿ‹8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èIÐÿÿj"^SSSSS‰0èÒÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿMQSWVjMQS‰]ÿpÿ°à@;Ãt9]…^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèa³ÿÿƒÄéOÿÿÿ‹ÿU‹ìjÿuÿuÿuÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿuMðè:·ÿÿ¶E‹Mð‹‰È·A%€€}üt‹MøƒapýÉËÿU‹ìjÿuè¹ÿÿÿYY]ÃÌV‹D$Àu(‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$v	N+D$T$3Û+D$T$÷Ú÷؃ڋʋӋًȋÆ^ƒ%€*AÃÌÌÌSVW‹T$‹D$‹L$URPQQh i@dÿ5¡€A3ĉD$d‰%‹D$0‹X‹L$,3‹pƒþþt;‹T$4ƒúþt;òv.4v\³‹‰Hƒ{uÌh‹Cè1¹‹Cè1ë°dƒÄ_^[ËL$÷A¸t3‹D$‹H3È袵ÿÿU‹hÿpÿpÿpè>ÿÿÿƒÄ]‹D$‹T$‰¸ÃU‹L$‹)ÿqÿqÿq(èÿÿÿƒÄ]ÂUVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_03À3Û3É3Ò3ÿÿæU‹ìSVWjjhÇi@Qè—Q_^[]ÃU‹l$RQÿt$è´þÿÿƒÄ]Âjhˆ÷@èÍÿÿƒeä‹u;5p*Aw"jèÄÔÿÿYƒeüVèaY‰EäÇEüþÿÿÿè	‹EäèÍÿÿÃjè¿ÓÿÿYËÿU‹ìV‹uƒþà‡¡SW‹=dà@ƒ=t)AuèíÿÿjèÏëÿÿhÿèM·ÿÿYY¡„*Aƒøu…öt‹Æë3À@PëƒøuVèSÿÿÿY…Àu…öuFƒÆƒæðVjÿ5t)Aÿ׋؅Ûu.j^9€)Atÿuè¢ôÿÿY…Àt‹ué{ÿÿÿèNÌÿÿ‰0èGÌÿÿ‰0_‹Ã[ëVè{ôÿÿYè3ÌÿÿÇ3À^]Ãjh¨÷@èhÌÿÿ‹]…ÛuÿuèÿÿÿYéÌ‹u…öuSècÏÿÿYé·ƒ=„*A…“3ÿ‰}äƒþà‡ŠjèwÓÿÿY‰}üSè6Y‰Eà;Ç„ž;5p*AwIVSPèƒÄ…Àt‰]äë5Vèç	Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$Sèæ‰EàSPèƒÄ9}äuH;÷u3öF‰uƒÆƒæð‰uVWÿ5t)Aÿdà@‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ#Sÿuà迃ÄÇEüþÿÿÿè.ƒ}àu1…öuFƒÆƒæð‰uVSjÿ5t)AÿÔà@‹øë‹u‹]jè¨ÑÿÿYË}ä…ÿ…¿9=€)At,VèóÿÿY…À…Òþÿÿè´Êÿÿ9}àul‹ðÿ\à@Pè_ÊÿÿY‰ë_…ÿ…ƒèÊÿÿ9}àthÇëq…öuFVSjÿ5t)AÿÔà@‹ø…ÿuV9€)At4Vè›òÿÿY…ÀtƒþàvÍVè‹òÿÿYèCÊÿÿÇ3ÀèÇÊÿÿÃè0Êÿÿé|ÿÿÿ…ÿuè"Êÿÿ‹ðÿ\à@PèÒÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹MS3Û;Ëv(jà3ÒX÷ñ;EsèíÉÿÿSSSSSÇèuÉÿÿƒÄ3ÀëA¯MVW‹ñ9]tÿuèÈ)Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVjßSèX­ÿÿƒÄ‹Ç_^[]ËÿU‹ì‹
h*A¡l*AkÉÈë‹U+Púr	ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹uW‹þ+yƒÆüÁï‹ÏiÉŒD‰Mð‹I‰MüöÁ…ÓS1‹‰Uô‹Vü‰Uø‹Uô‰]öÂutÁúJƒú?vj?Z‹K;KuB»€ƒú s‹ÊÓëL÷Ó!\¸Dþ	u#‹M!ëJàÓëL÷Ó!œ¸Äþ	u‹M!Y‹]‹S‹[‹MüMô‰Z‹U‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô…+uø‹]øÁûj?‰uK^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M‹q;qu;¾€ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸ÄþLu‹M!q‹M‹q‹I‰N‹M‹q‹I‰N‹uë‹]ƒ}ôu;Ú„€‹MðÑ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€}u‹Ê»€Óë‹M	»€‹ÊÓëD¸D	ë)€}uJເÓë‹M	YJ຀ÓꄸÄ	‹Eü‰‰D0ü‹Eðÿ…ó¡|)A…À„Ø‹
|*A‹5¼à@h@ÁáH»€SQÿÖ‹
|*A¡|)Aº€Óê	P¡|)A‹@‹
|*Aƒ¤ˆÄ¡|)A‹@þHC¡|)A‹H€yCu	ƒ`þ¡|)AƒxÿueSjÿpÿÖ¡|)Aÿpjÿ5t)Aÿ`à@‹
h*A¡|)AkÉ‹l*A+ÈLìQHQPèí+‹EƒÄÿ
h*A;|)Avƒm¡l*A£t*A‹E£|)A‰=|*A[_^Éáx*AV‹5h*AW3ÿ;ðu4ƒÀkÀPÿ5l*AWÿ5t)AÿÔà@;Çu3Àëxƒx*A‹5h*A£l*Akö5l*AhÄAjÿ5t)Aÿdà@‰F;ÇtÇjh hWÿØà@‰F;ÇuÿvWÿ5t)Aÿ`à@뛃Nÿ‰>‰~ÿh*A‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ„0Dj?‰EøZ‰@‰@ƒÀJuôj‹ûhÁçyh€WÿØà@…ÀuƒÈÿé—p‰Uü;úwC‹Ê+ÏÁéGAƒHøÿƒˆìÿü‰üïÿÿÇ@üð‰PÇ€èðIuË‹Uü‹EøøO‰H‰AJ‰H‰AƒdžD3ÿG‰¼žÄŠFCŠÈþÁ„À‹EˆNCu	xº€‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì‹M‹ASV‹uW‹}‹×+QƒÆÁê‹ÊiÉŒD‰Mô‹OüƒæðI;ñ|9ü‹‰M‰]üŽUöÃ…EÙ;ó;‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC»€ƒù sÓë‹MøL÷Ó!\Dþ	u&‹M!ëƒÁàÓë‹MøL÷Ó!œÄþ	u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}üŽ¥‹}ü‹MÁÿOL1üƒÿ?vj?_‹]ôû‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s€}u‹Ï»€Óë‹M	DD‹Ïë €}uOເÓë‹M	Y„ÄO຀Óê	‹U‹MüD2ü‰‰Lüë‹UF‰Bü‰D2øé<3Àé8/‹])uN‰Kü\3ü‹uÁþN‰]‰Küƒþ?vj?^öEü…€‹uüÁþNƒþ?vj?^‹O;OuB»€ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ëNàÓëL÷Ó!œÄþ	u‹M!Y‹]‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Môñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s€}u‹Î¿€Óï‹M	9DD‹Îë €}uNà¿€Óï‹M	y„ÄN຀Óê	‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A‹MkÀl*AƒÁƒáð‰MðÁùSIƒù VW}ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A‹Ùë‹S‹;#Uø#þ×u
ƒÃ‰];Ørè;Øu‹l*Aë‹S‹;#Uø#þ×u
ƒÃ‰];Ùrè;Ùu[ëƒ{u
ƒÃ‰];Ørð;Øu1‹l*Aë	ƒ{u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé	Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰t*A‹C‹‰Uüƒúÿt‹ŒÄ‹|D#Mø#þÏu)ƒeü‹ÄHD‹9#Uø#þ×uÿEü‹‘„ƒÁëç‹Uü‹ÊiÉŒD‰Mô‹LD3ÿ#Îu‹ŒÄ#Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„‹J;Ju\ƒÿ »€}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]!ë,OàÓë‹MüŒˆÄ|8÷Ó!þ‰]ìu‹]‹Mì!Kë‹]ƒ}ø‹J‹z‰y‹J‹z‰y„‹Môñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆMþÁƒþ ˆL}#€}u¿€‹ÎÓï	;‹Î¿€Óï‹Mü	|ˆDë)€}u
Nà¿€Óï	{‹Mü¼ˆÄNྀÓî	7‹Mø…Ét‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu;|)Au‹Mü;
|*Auƒ%|)A‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷uèµ¾ÿÿWWWWWÇè=¾ÿÿƒÄÃëBöFƒt7Vè(ÃÿÿV‹ØèÄ(Vè³¼ÿÿPèë'ƒÄ…À}ƒËÿë‹F;Çt
PèÎÁÿÿY‰~‰~‹Ã_^[]ÃjhÈ÷@è—¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;Çuè2¾ÿÿÇWWWWW躽ÿÿƒÄƒÈÿëöF@t‰~‹Eäèš¾ÿÿÃVè– ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿèëÕ‹uVèä ÿÿYËÿU‹ì¸äè8*¡€A3ʼnEü‹EV3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé;Æu'訽ÿÿ‰0莽ÿÿVVVVVÇè½ÿÿƒÄƒÈÿé¾SW‹}‹ÇÁø4… *A‹ƒçÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&è?½ÿÿ3ö‰0è#½ÿÿVVVVVÇ諼ÿÿƒÄéCö@ tjjjÿuècƒÄÿuèÖêÿÿY…À„‹öD€„èëÖÿÿ‹@l3É9H…åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@…À„`3É9 åÿÿt„Û„PÿÜà@‹4åÿÿ‰…åÿÿ3À‰…<åÿÿ9E†B‰…DåÿÿŠ…'åÿÿ„À…gŠ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹ǃx8tŠP4ˆUôˆMõƒ`8jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥j…@åÿÿSPè<(ƒÄƒøÿ„±Cÿ…DåÿÿëjS…@åÿÿPè(ƒÄƒøÿ„3ÀPPjMôQj@åÿÿQPÿµåÿÿCÿ…Dåÿÿÿ°à@‹ð…ö„\j…<åÿÿPVEôP‹…(åÿÿ‹ÿ4ÿ˜à@…À„)‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒƒ½ åÿÿ„Íj…<åÿÿPjEôP‹…(åÿÿ‹ÆEô
ÿ4ÿ˜à@…À„Ѓ½<åÿÿŒÏÿ…0åÿÿÿ…8åÿÿéƒ<t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%%Yf;…@åÿÿ…hƒ…8åÿÿƒ½ åÿÿt)j
XP‰…@åÿÿèø$Yf;…@åÿÿ…;ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé'‹Šÿ…8åÿÿˆT4‹‰D8é3É‹Çö@€„¿‹…4åÿÿ‰@åÿÿ„Û…ʉ…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ+4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿr‹؅Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„B‹…,åÿÿ…8åÿÿ;ÃŒ:‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ9M†M답(åÿÿ‹Dåÿÿƒ¥<åÿÿ+4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþrµ‹Ø…Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„b‹…,åÿÿ…8åÿÿ;ÃŒZ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@9M†|‹Dåÿÿƒ¥<åÿÿ+4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰ƽ<åÿÿ¨r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéýÿ°à@‹Ø;Þ„—j…,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ÿ4ÿ˜à@…Àtµ,åÿÿ;ÞËëÿ\à@‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@…Àt‹…,åÿÿƒ¥@åÿÿ‰…8åÿÿëÿ\à@‰…@åÿÿƒ½8åÿÿulƒ½@åÿÿt-j^9µ@åÿÿuè·ÿÿÇ	è·ÿÿ‰0ë?ÿµ@åÿÿè"·ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èÖ¶ÿÿÇèÞ¶ÿÿƒ ƒÈÿë‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èhžÿÿÉÃjhè÷@èè¶ÿÿ‹Eƒøþu袶ÿÿƒ 臶ÿÿÇ	ƒÈÿé3ÿ;Ç|;*Ar!èy¶ÿÿ‰8è_¶ÿÿÇ	WWWWWèçµÿÿƒÄëÉ‹ÈÁù *A‹ðƒæÁ拾L1ƒát¿Pè9$Y‰}ü‹öD0tÿuÿuÿuè.øÿÿƒÄ‰EäëèüµÿÿÇ	è¶ÿÿ‰8ƒMäÿÇEüþÿÿÿè	‹Eäèh¶ÿÿÃÿuèƒ$YÃjhø@è¶ÿÿ‹Eƒøþuè³µÿÿÇ	ƒÈÿéª3Û;Ã|;*Arè’µÿÿÇ	SSSSSèµÿÿƒÄëЋÈÁù< *A‹ðƒæÁ拾LƒátÆPèl#Y‰]ü‹öDt1ÿuèà"YPÿäà@…Àuÿ\à@‰Eäë‰]ä9]ätè1µÿÿ‹Mä‰èµÿÿÇ	ƒMäÿÇEüþÿÿÿè	‹Eä臵ÿÿÃÿuè¢#YËÿU‹ìƒìS3Û9]uèÖ´ÿÿSSSSSÇè^´ÿÿƒÄ3ÀëjV‹u;óuè²´ÿÿSSSSSÇè:´ÿÿƒÄë9ur3Àë>ÿuMðèVœÿÿ‹MôFÿ9YtH9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìjÿuÿuèUÿÿÿƒÄ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9]u3Àéç;ót9]wè	´ÿÿj^SSSSS‰0è’³ÿÿƒÄ‹ÆéÀ9]uˆëÉW‹};ûuˆèسÿÿj^SSSSS‰0èa³ÿÿƒÄé(ÿuMì胛ÿÿ‹Eð9XuÿuWÿuVè£
ƒÄéLƒ}ÿ‹U‹ÆuŠˆ@G:ËtJuó늈@G:ËtJtÿMuî9]uˆ@;Ó…È8tƒ}u5xÿ‰}ü;þrEìP‹Eü¶Pè0¿ÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…Ã}ÿuZ‹Eƒøv:|þ‰};þr!EìP‹E¶Pèì¾ÿÿYY…ÀtÿM9usâ‹E‹Ï+MöÁtˆëˆ\ÿ8]øt‹Eôƒ`pýjPXéˆè·²ÿÿj"^SSSSS‰0è@²ÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þrEìP‹E¶Pèi¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨tˆèT²ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝuPèxµÿÿY]ËÿU‹ìƒì¡€A3ʼnEüSV3ÛW‹ñ9„)Au8SS3ÿGWhdê@hSÿðà@…Àt‰=„)Aëÿ\à@ƒøxu
Ç„)A9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)Aƒø„¬;Ĥƒø…̉]ø9] u‹‹@‰E ‹5ìà@3À9]$SSÿu•ÀÿuÅPÿu ÿÖ‹ø;û„~Cjà3ÒX÷÷ƒør7D?=wèŽ#‹Ä;ÃtÇÌÌëPèäÿÿY;Ãt	ÇÝ݃À‰Eôë‰]ô9]ô„>Wÿuôÿuÿujÿu ÿÖ…À„ã‹5ðà@SSWÿuôÿuÿuÿ֋ȉMø;Ë„Â÷Et)9]„°;M§ÿuÿuWÿuôÿuÿuÿÖé;Ë~Ejà3ÒX÷ñƒør9D	=wèÏ"‹ô;ótjÇÌ̃ÆëPèJãÿÿY;Ãt	ÇÝ݃À‹ðë3ö;ótAÿuøVWÿuôÿuÿuÿðà@…Àt"SS9]uSSëÿuÿuÿuøVSÿu ÿ°à@‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè  Y‰Eìƒøÿu3Àé!;E „ÛSSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@SSÿuPÿuÿuÿÖ‰Eø;Ãu3öé·~=ƒøàw8ƒÀ=wè¹!‹ü;ûtÝÇÌ̃ÇëPè4âÿÿY;Ãt	ÇÝ݃À‹øë3ÿ;ût´ÿuøSWèÀ’ÿÿƒÄÿuøWÿuÿuôÿuÿuÿÖ‰Eø;Ãu3öë%ÿuEøÿuPWÿu ÿuìè‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿuÿuÿuÿuÿuÿuÿèà@‹ð9]ôt	ÿuôèø±ÿÿY‹Eð;Ãt9EtPèå±ÿÿY‹Æeà_^[‹Mü3Íè'–ÿÿÉËÿU‹ìƒìÿuMðè!–ÿÿÿu(Mðÿu$ÿu ÿuÿuÿuÿuÿuè(üÿÿƒÄ €}üt‹MøƒapýÉËÿU‹ìQQ¡€A3ʼnEü¡ˆ)ASV3ÛW‹ù;Ãu:EøP3öFVhdê@Vÿøà@…Àt‰5ˆ)Aë4ÿ\à@ƒøxu
jX£ˆ)A롈)Aƒø„Ï;Äǃø…è‰]ø9]u‹‹@‰E‹5ìà@3À9] SSÿu•ÀÿuÅPÿuÿÖ‹ø;û„«~<ÿðÿÿw4D?=wèÒ‹Ä;ÃtÇÌÌëPèPàÿÿY;Ãt	ÇÝ݃À‹Ø…Ûti?PjSèÞÿÿƒÄWSÿuÿujÿuÿÖ…ÀtÿuPSÿuÿøà@‰EøSèÉúÿÿ‹EøYëu3ö9]u‹‹@‰E9]u‹‹@‰EÿuèAYƒøÿu3ÀëG;EtSSMQÿuPÿuèi‹ðƒÄ;ót܉uÿuÿuÿuÿuÿuÿôà@‹ø;ótVèæ¯ÿÿY‹Çeì_^[‹Mü3Íè(”ÿÿÉËÿU‹ìƒìÿuMðè"”ÿÿÿu$Mðÿu ÿuÿuÿuÿuÿuèþÿÿƒÄ€}üt‹MøƒapýÉËÿU‹ìV‹u…ö„ÿvèv¯ÿÿÿvèn¯ÿÿÿvèf¯ÿÿÿvè^¯ÿÿÿvèV¯ÿÿÿvèN¯ÿÿÿ6èG¯ÿÿÿv è?¯ÿÿÿv$è7¯ÿÿÿv(è/¯ÿÿÿv,è'¯ÿÿÿv0è¯ÿÿÿv4è¯ÿÿÿvè¯ÿÿÿv8è¯ÿÿÿv<èÿ®ÿÿƒÄ@ÿv@èô®ÿÿÿvDèì®ÿÿÿvHèä®ÿÿÿvLèÜ®ÿÿÿvPèÔ®ÿÿÿvTèÌ®ÿÿÿvXèÄ®ÿÿÿv\è¼®ÿÿÿv`è´®ÿÿÿvd謮ÿÿÿvh褮ÿÿÿvl蜮ÿÿÿvpè”®ÿÿÿvt茮ÿÿÿvxè„®ÿÿÿv|è|®ÿÿƒÄ@ÿ¶€èn®ÿÿÿ¶„èc®ÿÿÿ¶ˆèX®ÿÿÿ¶ŒèM®ÿÿÿ¶èB®ÿÿÿ¶”è7®ÿÿÿ¶˜è,®ÿÿÿ¶œè!®ÿÿÿ¶ è®ÿÿÿ¶¤è®ÿÿÿ¶¨è®ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;HAtPèÝ­ÿÿY‹F;LAtPèË­ÿÿY‹v;5PAtVè¹­ÿÿY^]ËÿU‹ìV‹u…öt~‹F;TAtPè—­ÿÿY‹F;XAtPè…­ÿÿY‹F;\AtPès­ÿÿY‹F;`AtPèa­ÿÿY‹F;dAtPèO­ÿÿY‹F ;hAtPè=­ÿÿY‹v$;5lAtVè+­ÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹};ûwè¡©ÿÿj^‰0SSSSSè*©ÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèZ©ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹uƒÉÿIƒÁŠ
Àt	ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9]u3À_^[]Ã;ót‹};ûwę̀ÿÿj^‰0SSSSSèU¨ÿÿƒÄ‹ÆëÕ9]uˆëÊ‹U;Óuˆëу}ÿ‹ÆuŠ
ˆ@B:ËtOuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹EjPˆ\ÿXéxÿÿÿˆèR¨ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹};ûwè,¨ÿÿj^‰0SSSSS赧ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆèñ§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷Âu<‹:u.
Àt&:au%
ätÁè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ÂtŠƒÂ:uçƒÁ
ÀtÜ÷Ât¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u‹M‹}‹Á‹ÑÆ;þv;ø‚¤ùrƒ=ˆ*AtWVƒçƒæ;þ^_u^_]é,÷ÇuÁéƒâƒùr*ó¥ÿ$•T‘@‹ÇºƒérƒàÈÿ$…h@ÿ$d‘@ÿ$è@x@¤@È@#ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•T‘@I#ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•T‘@#ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•T‘@IK‘@8‘@0‘@(‘@ ‘@‘@‘@‘@‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Düðøÿ$•T‘@‹ÿd‘@l‘@x‘@Œ‘@‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃIŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Çu$Áéƒâƒùr
ýó¥üÿ$•ð’@‹ÿ÷Ùÿ$ ’@I‹Çºƒùrƒà+Èÿ$…ô‘@ÿ$ð’@’@(’@P’@ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•ð’@IŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•ð’@ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•ð’@I¤’@¬’@´’@¼’@Ä’@Ì’@Ô’@ç’@‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰Dðøÿ$•ð’@‹ÿ“@“@“@,“@‹E^_ÉÊFˆG‹E^_ÉÃIŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹u‹ÿŠ
ÀtƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹EV‹u‰Eø‹EWV‰EüèƒÏÿY;Çuèi£ÿÿÇ	‹Ç‹×ëJÿuMüQÿuøPÿá@‰Eø;Çuÿ\à@…Àt	Pè[£ÿÿYëÏ‹ÆÁø‹… *AƒæÁæD0€ ý‹Eø‹Uü_^ÉÃjh(ø@èO£ÿÿƒÎÿ‰u܉uà‹Eƒøþuè£ÿÿƒ èå¢ÿÿÇ	‹Æ‹ÖéÐ3ÿ;Ç|;*Ar!èÖ¢ÿÿ‰8è¼¢ÿÿÇ	WWWWWèD¢ÿÿƒÄëÈ‹ÈÁù *A‹ðƒæÁ拾L1ƒáu&è•¢ÿÿ‰8è{¢ÿÿÇ	WWWWWè¢ÿÿƒÄƒÊÿ‹Âë[PèpY‰}ü‹öD0tÿuÿuÿuÿuè©þÿÿƒÄ‰E܉Uàëè-¢ÿÿÇ	è5¢ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè‹EÜ‹Uàè’¢ÿÿÃÿuè­YËÿU‹ìÿ Ahè¤ÿÿY‹M‰A…Àt
ƒIÇAëƒIA‰AÇA‹Aƒa‰]ËÿU‹ìƒìSVWèb¹ÿÿƒeüƒ=)A‹Ø…Žhô@ÿœà@‹ø…ÿ„*‹5(à@hôó@WÿÖ…À„P謸ÿÿÇ$äó@W£)AÿÖPè—¸ÿÿÇ$Ðó@W£”)AÿÖP肸ÿÿÇ$´ó@W£˜)AÿÖPèm¸ÿÿY£ )A…Àthœó@WÿÖPèU¸ÿÿY£œ)A¡œ)A;ÃtO9 )AtGP賸ÿÿÿ5 )A‹ð覸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQjMìQjPÿ×…ÀtöEôu	M ë9¡”)A;Ãt0Pèc¸ÿÿY…Àt%ÿЉEü…Àt¡˜)A;ÃtPèF¸ÿÿY…ÀtÿuüÿЉEüÿ5)Aè.¸ÿÿY…ÀtÿuÿuÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î|ƒù~ƒùu¡D Aë(¡D A‰
D Aëè ÿÿVVVVVÇ蚟ÿÿƒÄƒÈÿ^]ÃjhHø@è9 ÿÿ3À‹]3ÿ;ß•À;ÇuèØŸÿÿÇWWWWWè`ŸÿÿƒÄƒÈÿëSƒ=„*Au8jèU§ÿÿY‰}üSèÖÿÿY‰Eà;Çt‹süƒî	‰uäë‹uäÇEüþÿÿÿè%9}àuSWÿ5t)Aÿá@‹ð‹ÆèùŸÿÿÃ3ÿ‹]‹uäjè#¦ÿÿYÃjè‰ÿÿYËÿU‹ìì(¡€A3ʼnEüöAVtj
è3¾ÿÿYè
Åÿÿ…ÀtjèÅÿÿYöA„ʉ…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ‰µèýÿÿ‹@üjP‰…äýÿÿ…ØüÿÿjPè:‚ÿÿ…ØüÿÿƒÄ‰…(ýÿÿ…0ýÿÿjÇ…Øüÿÿ@‰µäüÿÿ‰…,ýÿÿÿTà@…(ýÿÿPÿPà@jèýŠÿÿÌÌÌU‹ìSVWUjjh™@ÿuèV"]_^[‹å]ËL$÷A¸t2‹D$‹Hü3Èè²…ÿÿU‹h‹P(R‹P$RèƒÄ]‹D$‹T$‰¸ÃSVW‹D$UPjþh™@dÿ5¡€A3ÄPD$d£‹D$(‹X‹pƒþÿt:ƒ|$,ÿt;t$,v-4v‹³‰L$‰Hƒ|³uh‹D³èI‹D³è_ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y™@u‹Q‹R9Qu¸ÃSQ»”AëSQ»”A‹L$‰K‰C‰kUQPXY]Y[ÂÿÐËÿU‹ìƒìVWÿuMì资ÿÿ‹E‹u3ÿ;Çt‰0;÷u,èÑœÿÿWWWWWÇèYœÿÿƒÄ€}øt‹Eôƒ`pý3ÀéØ9}tƒ}|Ƀ}$ËMìSŠ‰}ü~ƒ¹¬~EìP¶ÃjPèe¹ÿÿ‹MìƒÄ닑ȶ÷Bƒà…ÀtŠGëÇ€û-uƒMë€û+uŠG‹E…ÀŒKƒø„Bƒø$9…Àu*€û0t	ÇE
ë4Š·É¶ÒÁáÊ9MuHë·Ñ9Ut
@f¶·Éf;ËuÇ·É9Mu8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìjÿuÿuè2ÿÿÿƒÄ]ÃÌÌÌBÿ[ä$d$3ÀŠD$S‹ØÁà‹T$÷ÂtŠ
ƒÂ:ËtÏ„ÉtQ÷ÂuëØW‹ÃÁãVØ‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂáu%tÓ%uæ€uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@‹ÿU‹ì‹US3Û;Óuè¬{ÿÿSSSSSÇè4{ÿÿƒÄƒÈÿë 8tß‹M;ËtØ‹;ÃtÒ8tÎSQRèƒÄ[]ËÿU‹ìƒì‹UV‹ujþX‰Eì‰Uä;ðuèc{ÿÿƒ èH{ÿÿÇ	ƒÈÿéˆS3Û;ó|;5*Ar'è9{ÿÿ‰è{ÿÿSSSSSÇ	è§zÿÿƒÄƒÈÿéQ‹ÆÁøW<… *A‹ƒæÁæÆŠHöÁuèózÿÿ‰èÙzÿÿÇ	ëjúÿÿÿwP‰]ð;Ó„öÁ…ÿ9]t7Š@$ÀÐøˆEþ¾ÀHjYtHu‹Â÷Шtƒâþ‰U‹E‰Eôé‹Â÷Шu!è‡zÿÿ‰èmzÿÿÇSSSSSèõyÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuèz|ÿÿY‰Eô;Ãuè5zÿÿÇè=zÿÿǃÈÿéhjSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEðÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEðÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEðÆD&
SMèQÿuP‹ÿ4ÿ,á@…À„{‹Mè;ËŒp;M‡g‹MðDö€„æ€}þ„;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ЋMŠ<„®<
tˆCA‰Mé‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEjEèPjEÿP‹ÿ4ÿ,á@…Àu
ÿ\à@…ÀuEƒ}èt?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö@u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð…À„ÈKŠ„ÉxCé†3À@¶Éëƒø;]ôrK¶@€¹àAt芶ʾ‰àA…Éu
èàwÿÿÇ*ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ|	Š‹ˆT%Cƒøu	Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿuSÿuôjhéýÿìà@‰Eð…Àu4ÿ\à@Pè…wÿÿYƒMìÿ‹Eô;EtPèµzÿÿY‹Eìƒøþ…‹‹Eð郋Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ‹E·fƒù„×fƒù
tf‰CC@@‰Eé´‹MðƒÁþ;ÁsHfƒ9
u
ƒÀ‰Ej
鎉M鄃EjEèPjEøP‹ÿ4ÿ,á@…Àu
ÿ\à@…Àu[ƒ}ètU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹f‰CC+]ô‰]ðé‘þÿÿÿ\à@j^;ÆuèÙuÿÿÇ	èáuÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhðø@èïuÿÿ‹Eƒøþuè©uÿÿƒ èŽuÿÿÇ	ƒÈÿé¾3ö;Æ|;*Ar!è€uÿÿ‰0èfuÿÿÇ	VVVVVèîtÿÿƒÄëÉ‹ÈÁù *A‹øƒçÁ狾L9ƒát¿¹ÿÿÿ;MÉAuè2uÿÿ‰0èuÿÿÇë°PèãÿÿY‰uü‹öD8tÿuÿuÿuè~ùÿÿƒÄ‰EäëèâtÿÿÇ	èêtÿÿ‰0ƒMäÿÇEüþÿÿÿè	‹EäèNuÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ‰]Ôt	‰]ØÆEÿë
ÇE؈]ÿEàPè
Y…Àt
SSSSSèÒrÿÿƒÄ‹M¸€…Èu÷Á@u9Eàt€Mÿ€‹Áƒà+úÀ¿€tGHt.Ht&è7tÿÿ‰ƒÿètÿÿj^SSSSS‰0è£sÿÿƒÄé‰UøëöÁt÷ÁuîÇEø@ë‰}ø‹EjY+Át7+Át*+Át+Átƒè@u¡9}ø”À‰EðëÇEðëÇEðëÇEðë‰]ð‹Eº#¹;Á¿;t0;Ãt,;Çt=„”=…@ÿÿÿÇEìë/ÇEìë&ÇEìë=t=t`;Â…ÿÿÿÇEì‹EÇEô€…Çt‹
 A÷Ñ#M„ÉxÇEô¨@tMôMøƒMð©t	}ô¨ tMôëÇEì릨tMôè£áÿÿ‰ƒøÿuèÎrÿÿ‰ƒÿè±rÿÿÇ鎋E‹=á@SÿuôÇÿuìEÐPÿuðÿuøÿuÿ׉Eäƒøÿum‹Mø¸À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿuÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@Pè?rÿÿYèrÿÿ‹étÿuäÿ<à@;ÃuD‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@‹ðVèüqÿÿYÿuäÿá@;óu°èÃqÿÿÇ
룃øu€Mÿ@ë	ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹ÐƒàÁú‹• *AYÁàYŠMÿ€ÉˆL‹‹ÐƒàÁú‹• *AÁàD$€ €ˆMý€eýHˆMÿ…€öÁ€„±öEtqjƒÏÿWÿ6裃Ä‰Eè;Çuè:qÿÿ8ƒtMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ…Àu€}üu‹Eè™RPÿ6è ƒÄ;ÇtÃSSÿ6èFƒÄ;Çt³öEÿ€„0¿@¹@…}u‹Eà#Çu	Më	E‹E#Ç;ÁtD=t)=@t"=t)=@t"=t=@uÆEþë‹M¸#È;Èu	ÆEþëˆ]þ÷E„µöEÿ@‰]è…¨‹Eø¹À#Á=@„·=€tw;Á…„‹Eì;Æyƒøvƒøv0ƒø…f¾Eþ3ÿH„&H…RÇEèÿþÇEìéjSSÿ6è8ÌÿÿƒÄÂtÇSSSÿ6è'Ìÿÿ#ƒÄƒøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄƒøÿ„uþÿÿƒøtkƒø…­}èuYÆEþéÜ‹Eì;Æуø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ„CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘éþÿÿ‹Eè%ÿÿ=þÿuÿ6èß×ÿÿYèoÿÿj^‰0‹Æéd=ÿþuSjÿ6èXƒÄƒøÿ„ÀýÿÿÆEþëASSÿ6è=ƒÄë™ÇEèÇEì‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *AƒàÁàD$Š2Mþ€á0‹‹ÈÁù‹ *AƒàÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹ÈƒàÁù‹ *AÁàD€ ‹}ø¸À‹Ï#È;Èu|öEtvÿuäÿá@SÿuôEÐjPÿuðçÿÿÿWÿuÿá@ƒøÿu4ÿ\à@Pèÿmÿÿ‹‹ÈƒàÁù‹ *AÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *AƒæÁ手Ã_^[ÉÃjhù@èÓmÿÿƒMäÿ3ö‰uà3À9u•À;ÆuèmmÿÿÇVVVVVèõlÿÿƒÄƒÈÿër‰uüÿuj@ÿuÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè‹}Ü;þt<èmÿÿ‰8ë¿3ö9uàt+9uÜt‹EäÁø‹MäƒáÁá‹… *AD€ þÿuäèÛÿÿYËEäèomÿÿËÿU‹ìQQV3ö9uuèÉlÿÿVVVVVÇèQlÿÿƒÄƒÈÿëJ9utÞÿuEøPEüPÿuÿuè|ƒÄƒøÿtØÿuøÿuüÿujèUÿuü‹ðèÝoÿÿÿuøèÕoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èIlÿÿSSSSSÇèÑkÿÿƒÄƒÈÿéá8tÜ‹E;ÃtÕ‹;ÃtÏ8tËVj\Wèj/W‹ðè
ƒÄ;Ã…;ó…ƒj:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèMnÿÿ‹øƒÄ‰}ü;û„­htô@VWèkÃÿÿƒÄ…Àt
SSSSSèjÿÿƒÄÿuVWèØÁÿÿƒÄ…Àt
SSSSSèõiÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.VèhYY…Àt,Sÿuüè
YY…À…ìÿuÿuÿuüè`þÿÿƒÄ‰EðéÓÿuüè–™ÿÿ‹ðƒÆjVèšmÿÿƒÄ‰Eø;ÃuƒÈÿé½ÿuüVPè¸ÂÿÿƒÄ…Àt
SSSSSè`iÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèÚjÿÿ‹‰Eì‹Eø+÷ðÇEôìA‹Eôÿ0VWèrÂÿÿƒÄ…Àt
SSSSSèiÿÿƒÄSÿuøè]	YY…Àtƒmô}ôàA}Äëè„jÿÿÿu‹Mìÿu‰ÿuøè”ýÿÿƒÄ‰EðÿuøèÌmÿÿ‹}Y9}üt	ÿuüè»mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒÄ‰UìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u‹}+ðúˆÆ;󆼻Sjÿ4á@Pÿdà@‰Eü…ÀuèÇiÿÿÇè¼iÿÿ‹_^[ÉÃh€ÿuèŠYY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèFYYÿuüjÿ4á@Pÿ`à@3Ûé†èWiÿÿƒ8uè:iÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿuÿuèÅÿÿ#ƒÄƒøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èÛhÿÿÇ
èãhÿÿ‹ðÿ\à@‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒÄƒøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèyhÿÿÇ	ƒÈÿëMWÿujÿuPÿá@‹øƒÿÿuÿ\à@ë3À…ÀtPèihÿÿYƒÈÿë‹ÆÁø‹… *AƒæÁæD0€ ý‹Ç_^]ËÿU‹ìS‹]V‹u‹ÆÁø… *A‹ƒæÁæ0ŠA$ÀW¶y¾Àç€Ñøû@tPû€tBût&ûtûu=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸€]Ã÷ØÀ%À@]ËÿU‹ì‹EV3ö;ÆuèNgÿÿVVVVVÇèÖfÿÿƒÄjXë
‹
d*A‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~	ƒøuÆEÿ‹E‰Eðë8ègÿÿ‰èçfÿÿSSSSSÇèofÿÿƒÄƒÈÿé®@8uûH8tÆ ‹Á8uëVjD^VE˜SPèdJÿÿ‰u˜‹5*AƒÄ;ót+Fÿ‹È‹ÐÁù‹ *AƒâÁâ8\uNH;óuà;óŒ@þ23ƒ4‹ÆkÀƒÀf‰EÊ·ÀjPèÇhÿÿYY‰EÌ;Ä;ó‰0‹EÌH|0‰]ø~9‹Eø‹ÐƒàÁúÁà• *AŠPöÂuˆ‹‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×}ˆƒÿBAƒÀëäÇEôèÎeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿuÿà@‹ðÿ\à@ÿuÌ‹øèñhÿÿY;óu	Wè£eÿÿYëXƒ}uSè4Rÿÿ‹5á@9]ujÿÿuÜÿà@EìPÿuÜÿà@‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹Ãëè(eÿÿÇƒÈÿ^_[ÉËÿU‹ìƒì@¡€A3ʼnEü‹M‹ESVW¾xô@}ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌè*gÿÿ‹uàYY‰;Ãu#‹Eè‰è˜dÿÿÇè dÿÿǃÈÿé/EðPEìSPè¼ÚÿÿƒÄ;ÃtƒøuqSSSSSèËbÿÿƒÄëbEðPè¹’ÿÿ‹øGGY‰}Ð9]ìtÿuì褒ÿÿøY‰}ЋEÔ;ÃtOj‹ð‹_ëP舒ÿÿƒÆ|‹Y;Ãuì¡< A;ÃuCèíÿÿ£< A;Ãu5‹uàÿ6ƒMÜÿèRgÿÿ‹Eè‰Y‰ée‹E艋}È‹‹6;Ã…ñFéU‰]ä8t(Š‹ð€ù=tVè’ÿÿY‹MäL¡< A4‰MäŠ:ËuÜ‹Mä‰MØë+8Xt-€x:u'€x=u!ƒÀPèÝ‘ÿÿY‹MØD‹
< A‰EØÁ€8=t΋EØ+Eä‹uÔø‰}ÀëEðP謑ÿÿPEðPÿ6èƒÄ…ÀtMƒÆ9uÝ}ÐjWè˜eÿÿ‹uàYY‹Mè‰;Ã…2ÿÿÿÿ6èkfÿÿY‰èúbÿÿÇècÿÿƒMÜÿÇéiÇEÄë´P‹Æ+ÆEÌPVèºÿÿƒÄ…Àt
SSSSSè'aÿÿƒÄÿ7è‘ÿÿtƒÇë6P‹Eà‹+ÆEÌPVèIºÿÿƒÄ…Àt
SSSSSèñ`ÿÿƒÄÿ7èãÿÿðƒÇÆ FY‹;ÃuËEèˆ^ÿˆ‹09]Ô„Í‹}Ø‹Eä‹Ï+ÈQ‹
< AÈQVèöºÿÿ+}äƒÄ÷‹}Ôë6‹EÀ‹Mèÿ7+ÆPVèѹÿÿƒÄ…Àt
SSSSSèy`ÿÿƒÄÿ7èkÿÿYtƒÇ9uÆ9]Äug‹}ÐEðPWVè—¹ÿÿƒÄ…Àt
SSSSSè?`ÿÿƒÄh`ã@WVè¸ÿÿƒÄ…Àt
SSSSSè`ÿÿƒÄ9]ìtÿuìWVèß·ÿÿƒÄ…Àt
SSSSSèü_ÿÿƒÄ÷;ót‹Eè;0uˆFˆ¡< A;ÃtPèÑdÿÿY‰< A9]ìt	ÿuìè½dÿÿY‹EÜ‹Mü_^3Í[èIÿÿÉËÿU‹ìV3ö9uu$èBaÿÿ‰0è(aÿÿVVVVVÇè°`ÿÿƒÄjXëU÷EùÿÿÿuÓÿuÿ8á@ƒøÿuÿ\à@PèaÿÿYèç`ÿÿ‹ë(¨u"¨töEtèã`ÿÿÇèÅ`ÿÿÇ
ëÑ3À^]ËÿU‹ìƒìSÿu3ÛMì‰]üèlHÿÿ‹M;Ëu(è“`ÿÿSSSSSÇè`ÿÿƒÄ8]øt‹Eôƒ`pý3ÀëqV‹uð9^uÿuQèjYY8]øtW‹MôƒapýëNWŠ¶Â¶øöD7t!AŠ:Ót¶úÁàÇ9EuAÿ‰Eüë
9]üë9Eu‰MüA:ÓuÃ_8]øt‹Eôƒ`pý‹Eü^[ÉËÿU‹ìjÿuÿuè2ÿÿÿƒÄ]ËÿU‹ìƒìS3Û9]u3ÀéšÿuMìèGÿÿ‹Eð9Xu&ÿuÿuÿuèÇÔÿÿƒÄ8]ø„m‹MôƒapýéaW‹};ût9]u.èƒ_ÿÿSSSSSÇè_ÿÿƒÄ8]øt‹Eôƒ`pý¸ÿÿÿé%Vf¶ÿM·É¶ÑGöD‰MütCŠ:Óu‰]üëXÁáf¶ÒfÊ·Éf‹ñG‰Müf;prf;pwfpë6f;pr0f;pw*fpë$·UüöAt
f¶‰·Éë·Ê‰Müf‹uü‹Mf¶	ÿE·É¶ÑöD‰MütE‹UŠ:Óu‰]üëWÁáf¶ÒfÊÿE·É‰Müf;Hrf;HwfHë6f;Hr0f;Hw*fHë$·UüöAt
f¶‰·Éë·Ê‰Müf‹Müf;Îu!f;ót	9]…ëþÿÿ8]øt‹Eôƒ`pý3À^_[ÉÃÀƒàH8]øtð‹Môƒapýëç‹ÿU‹ìjÿuÿuÿuè#þÿÿƒÄ]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìW‹}3ÀƒÉÿò®ƒÁ÷ÙƒïŠEýò®ƒÇ8t3Àë‹Çü_ÉÔú°úÆúÜúîúûû4ûLû`ûhûzûˆûšû¬û¼ûÊûÜûôûüü8üVüjüzü†ü’üžü¶üÎüØüäüöüýýý(ý8ýNýZýjý’ý¬ýÄýÞýôýþþ*þDþTþjþ„þþžþ®þ¾þÐþäþôþ
ÿÿ,ÿ>ÿPÿbÿnÿ|ÿŒÿ¢ÿ²ÿÂÿÐÿâÿôÿ(8Jç@²A@4K@ÎX@Ð_@»¬@˜@failed to get exit code from process.
failed to create process.
 %s%sCould not exec %sCannot find Python executable %s
#!python.exe#!Cannot open %s
-script.pyCorExitProcessmscoree.dll(null)(null)EEE50P( 8PX700WP  `h````xpxxxx¨!A"A	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=EncodePointerKERNEL32.DLLDecodePointerFlsFreeFlsSetValueFlsGetValueFlsAllocruntime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: ÀÀ–ÀÀŽÀÀÀ‘À’À“À€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwpp         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLLSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecCONOUT$.com.exe.bat.cmd.\SystemRootH€AÐô@Ð7 i™þÿÿÿÔÿÿÿþÿÿÿ×@þÿÿÿÈÿÿÿþÿÿÿ¼#@þÿÿÿÌÿÿÿþÿÿÿ©%@½%@þÿÿÿŒÿÿÿþÿÿÿ<5@@5@þÿÿÿÔÿÿÿþÿÿÿã:@þÿÿÿÐÿÿÿþÿÿÿ±;@þÿÿÿÌÿÿÿþÿÿÿ;=@=@þÿÿÿÔÿÿÿþÿÿÿÀ>@þÿÿÿÔÿÿÿþÿÿÿó?@þÿÿÿÔÿÿÿþÿÿÿA@9A@þÿÿÿÔÿÿÿþÿÿÿ-G@þÿÿÿÌÿÿÿþÿÿÿûJ@þÿÿÿÔÿÿÿþÿÿÿkN@þÿÿÿÔÿÿÿþÿÿÿ­P@þÿÿÿ¼P@þÿÿÿØÿÿÿþÿÿÿoR@þÿÿÿ{R@þÿÿÿÔÿÿÿþÿÿÿ5Y@þÿÿÿØÿÿÿþÿÿÿÛZ@ïZ@þÿÿÿØÿÿÿþÿÿÿ-[@1[@þÿÿÿÀÿÿÿþÿÿÿˆ^@þÿÿÿÐÿÿÿþÿÿÿ_@/_@þÿÿÿÔÿÿÿþÿÿÿ)j@þÿÿÿÐÿÿÿþÿÿÿ:l@þÿÿÿÔÿÿÿþÿÿÿ>y@þÿÿÿÐÿÿÿþÿÿÿN@þÿÿÿÐÿÿÿþÿÿÿ/‚@þÿÿÿÌÿÿÿþÿÿÿ$•@þÿÿÿÐÿÿÿþÿÿÿ½—@þÿÿÿÐÿÿÿþÿÿÿT¡@þÿÿÿÔÿÿÿþÿÿÿË¥@þÿÿÿÈÿÿÿþÿÿÿ‘§@ͦ@þÿÿÿÐÿÿÿþÿÿÿL®@þÿÿÿÐÿÿÿþÿÿÿhÂ@þÿÿÿÌÿÿÿþÿÿÿÊ@Tùà”ú°úÆúÜúîúûû4ûLû`ûhûzûˆûšû¬û¼ûÊûÜûôûüü8üVüjüzü†ü’üžü¶üÎüØüäüöüýýý(ý8ýNýZýjý’ý¬ýÄýÞýôýþþ*þDþTþjþ„þþžþ®þ¾þÐþäþôþ
ÿÿ,ÿ>ÿPÿbÿnÿ|ÿŒÿ¢ÿ²ÿÂÿÐÿâÿôÿ(8JRGenerateConsoleCtrlEventÆGetExitCodeProcessnWaitForSingleObject•CreateProcessA¯SetConsoleCtrlHandlerõGetModuleFileNameAÚEnterCriticalSectionôLeaveCriticalSectionúGetModuleHandleW+Sleep"GetProcAddressExitProcesspGetCommandLineAðSetHandleCount>GetStdHandleØGetFileType<GetStartupInfoA¿DeleteCriticalSection7TerminateProcessªGetCurrentProcessHUnhandledExceptionFilterSetUnhandledExceptionFilterÖIsDebuggerPresentçGetLastError¦HeapFree¢HeapAlloc\GetCPInfoÅInterlockedIncrementÁInterlockedDecrementSGetACPGetOEMCPàIsValidCodePage>TlsGetValue<TlsAlloc?TlsSetValue=TlsFreeôSetLastError®GetCurrentThreadId—WriteFileöLoadLibraryAºInitializeCriticalSectionAndSpinCountKFreeEnvironmentStringsAÀGetEnvironmentStringsLFreeEnvironmentStringsW„WideCharToMultiByteÂGetEnvironmentStringsW¤HeapCreateaVirtualFreeYQueryPerformanceCounterjGetTickCount«GetCurrentProcessIdSGetSystemTimeAsFileTimešRtlUnwind©HeapReAlloc^VirtualAlloc„GetConsoleCP–GetConsoleModeBFlushFileBuffersæLCMapStringAMultiByteToWideCharèLCMapStringW@GetStringTypeACGetStringTypeWéGetLocaleInfoAçSetFilePointer«HeapSizeDCloseHandleŒWriteConsoleAšGetConsoleOutputCP–WriteConsoleWSetStdHandleyCreateFileASCompareStringAVCompareStringWØSetEnvironmentVariableAKERNEL32.dllnReadFileÕSetEndOfFile&GetProcessHeapÊGetFileAttributesAÀ+AÀ+ANæ@»±¿Dê#@lâ@\â@ÿÿÿÿ€

		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZhA¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þlí@þÿÿÿCAAAAAHAhë@ðï@pñ@ˆA˜A˜AhAÿÿÿÿÿÿÿÿøè@Ìè@	 è@
è@Üç@¬ç@ˆç@\ç@$ç@üæ@Äæ@Œæ@dæ@Dæ@àå@ ¨å@!°ä@"ä@xä@yðã@zàã@üÜã@ÿÌã@Η@Η@Η@Η@Η@Η@Η@Η@Η@Η@x
hë@jí@˜ó@”ó@ó@Œó@ˆó@„ó@€ó@xó@pó@hó@\ó@Pó@Hó@<ó@8ó@4ó@0ó@,ó@(ó@$ó@ ó@ó@ó@ó@ó@ó@ó@øò@ðò@èò@(ó@àò@Øò@Ðò@Äò@¼ò@°ò@¤ò@ ò@œò@ò@|ò@pò@	ˆA.DAŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AHA. “€pðñÿÿPSTPDTÐAAÿÿÿÿÿÿÿÿþÿÿÿþÿÿÿÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Mllô@dô@\ô@Tô@././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/cli-64.exe0000644000175100001710000022200000000000000017312 0ustar00runnerdockerMZÿÿ¸@ິ	Í!¸LÍ!This program cannot be run in DOS mode.

$è
W†^W†^W†^p¹ý^T†^W‡^
†^ê0^S†^I-^s†^I-^]†^I-^:†^I-^V†^RichW†^PEd†±‹Qð#	Öjx+@p€ì(`ü	ð.textÔÖ `.rdata )ð*Ú@@.dataä5 @À.pdataü	`
@@H‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì L‹áHƒÉÿ3ÀI‹üºò®H÷ÑD	HyÿHcÈè@3ö3íLcïÆ"HXL‹ð…ÿ~e€A¶,€ù\uÿÆë'€ù"u …ö~D‹Æ²\H‹Ë‹þèZHß+öÆ\HÿÃë3öA¶,HÿÅHÿÃI;íˆCÿ|¸…ö~D‹Æ²\H‹Ë‹þè%HßH‹l$HH‹t$PH‹|$XÆ"ÆCH‹\$@I‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌÌÌÌÌH‰\$WHì`H‹¼H3ÄH‰„$PH‹ÙH‹Á¶	H‹ú„ÉtHÿÀ€ù/uÆ@ÿ\Š„ÉuîH„$@LŒ$@LD$@HT$0H‹ËH‰D$ è?€|$0…®€|$@\„£H„$@LŒ$@LD$@HT$0H‹ÏH‰D$ èHƒÉÿ3ÀH|$@ò®HD$@H÷ÑHÿÈHÿÉHÈ€9\uHÿÉ€9\tHD$@H;ÈrÆHÿÉ€9\uëLD$@HT$0HŒ$@L‹ËHÇD$ èÏ
º¹è|
H”$@뺹èc
H‹ÓA¸H‹ÈH‹øè«H‹ÇH‹Œ$PH3ÌèøH‹œ$€HÄ`_ÃÌÌÌÌÌÌÌH‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì H‹ÙHƒÉÿ3ÀL‹êH‹ûPò®H÷ÑHÿÉèç	3ÿH‹óA‰}¾L‹ðE3äH‰èU…ÀtD¾KHÿÃè@…Àuð¶+HÿÃ@„ít[@¾Íè(…ÀtE…ätI@€ý\uÿÇëÙ@€ý"u@öÇu3ÀE…ä”À@2íD‹àÑÿ…ÿtL‹Ç²\H‹Îè¼	H÷3ÿ@„ít¢@ˆ.HÿÆëš…ÿtL‹Ç²\H‹Îè™	H÷3ÿÆAÿEIcEHÿÆI‰4Æ@„ít&¾è¡…Àt¾KHÿÃè…Àuð€;…GÿÿÿH‹\$@H‹l$HH‹t$PH‹|$XI‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌHƒì(…Éu‹
‚!…Ét3Òÿ6ܸHƒÄ(ÃÌÌÌÌÌÌÌÌÌÌÌÌH‰\$WHìà3À3ÿH‹ÙHL$pDGh3Ò‰¼$ðH‰D$PH‰D$XH‰D$`èÆWH
ŒÿÿÿÇD$phÿîÛL\$PHD$pL‰\$HH‰D$@H‰|$8H‰|$0E3ÉE3ÀH‹Ó3ɉ|$(ÇD$ ÿ«Û…Àu(èêH«ÞHH`èb3ÀH‹œ$øHÄà_ËD$`H‹L$PƒÊÿ‰• ÿ_ÛH‹L$PH”$ðÿDÛ…Àu(è“H,ÞHH`è3ÀH‹œ$øHÄà_Ë„$ðH‹œ$øHÄà_ÃÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WATAUHƒì L‹éHƒÉÿ3À»I‹ýIcèò®H;ÝH‹òH÷ÑL‹ËLQ}J‹<ÊHƒÉÿ3Àò®IÿÁH÷ÑDÑL;Í|æIcÊH‹ÓèHÌÝM‹ÅH‹ÈL‹àèHƒÉÿ3ÀI‹ýò®H;ÝH÷ÑLiÿ}0L‹ÞIcÍH•ÝIÌèÕH‹<ÞHƒÉÿ3ÀHÿÃò®H÷ÑDéH;Ý|ÐH‹\$@H‹l$HH‹t$PI‹ÄHƒÄ A]A\_ÃÌÌÌ@SWAVAWHìXH‹»
H3ÄH‰„$0L‹òD‰D$ LcùHT$0A¸3ÉÿúÙHƒÉÿ3ÀH|$0ò®H÷ÑHD/HL$0H;Áv€8.tHT$0ÆHÿÈH;ÂwëÆ3ÀHƒÉÿH|$03Òò®H‹:ÝHL$0H‰Gÿ·2Ýf‰G¶)݈G	è뷋؃øÿu"è³LD$0HïÜHH`è&CéóH”$0A¸‹ÈH‰¬$è1®HcÈH¼0‹Ëè_‡H”$0HÿÊHÿÂH;×s¶„Àt<
t<
uéÆHŒ$0HsÜA¸è…Àt%H‹MÜHŒ$0H‰‹D܉A¶>܈AHT$$HŒ$2èíúÿÿHT$0H‹8H‹ØH‹ÏèjùÿÿH‹èH…Àu èÍHÎÛL‹ÇHH`èBEéH‰´$P‹t$$L‰¤$HL‰¬$@E,7ºAEHcÈè¥H‹ÍL‹àèøÿÿƒþI‰$I|$~"HƒÃÿÎfH‹èø÷ÿÿHƒÇHƒÃHƒîH‰GøuæHL$0èÜ÷ÿÿ»HƒÇI;ßH‰Gø}I‹ÞèÁ÷ÿÿHÿÃHƒÇI;ßH‰Gø|çƒ|$ H‹´$PHÇt*I‹ÔH‹ÍèÔ¤èëHÔÚHH`L‹Åè`¸ëE‹ÅI‹ÔH‹ÍèsüÿÿH‹Èè;ûÿÿL‹¤$HL‹¬$@H‹¬$H‹Œ$0H3Ìès
HÄXA_A^_[ÃÌÌÌÌÌE3ÀéýÿÿH‹ÄH‰PH‰HL‰@L‰H SVWATHƒì8H‹ù3Û‹ó‹ÃH;Ë•À;Ãu'èL&ÇH‰\$ E3ÉE3À3Ò3Éèb%ƒÈÿé‹ÃH;Ó•À;Ãu'è&ÇH‰\$ E3ÉE3À3Ò3Éè/%ƒÈÿéâLd$pèùöG@…•H‹Ïè¢#ƒøÿt*ƒøþt%HcÐH‹ÊHÁùL×)ƒâHkÒXIÈH
5
ëH
,
H‹ÑL²)öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€t"èj%ÇH‰\$ E3ÉE3À3Ò3Éè€$ƒÎÿ;óu*H‹Ïè	‹ØM‹ÌE3ÀH‹T$hH‹Ïè‹ðH‹×‹Ëè¼H‹Ï賋ÆHƒÄ8A\_^[ÃÌÌÌH™Ã@SHƒì ‹l;»…Àu¸ë;ÃLÃHcȺ‰I;èÀ%H‰+H…Àu$PH‹Ë‰,;è£%H‰+H…Àu¸ëx3ÉH+H‰HƒÂ0HƒÁHƒët	H‹Ò*ëåE3ÀH"EHI‹ÈLx(I‹ÀHÁøƒáI‹ÂHkÉXL‹IƒúÿtIƒúþtM…ÒuÇþÿÿÿIÿÀHƒÂ0Iƒéu¼3ÀHƒÄ [ÃÌÌHƒì(èC)€=4tèÍ&H‹
V*HƒÄ(é}&Ì@SHƒì H‹ÙH
|H;Ùr:HH;Øw.H‹ÓH¸«ªªªªªª*H+ÑH÷êHÁúH‹ÊHÁé?Lèø*ºkë
HK0ÿcÔHƒÄ [ÃÌ@SHƒì ƒùH‹Ú}ƒÁèÊ*ºkë
HJ0ÿ5ÔHƒÄ [ÃÌÌÌHƒì(HñH;Êr7HuH;Èw+ºqH+ÊH¸«ªªªªªª*H÷éHÁúH‹ÊHÁé?Lèk)ë
HƒÁ0ÿãÓHƒÄ(ÃÌÌHƒì(ƒù}ºrƒÁèB)ë
HJ0ÿºÓHƒÄ(ÃÌ@SHƒì ƒd$@LD$@è_*H‹ØH…Àu9D$@tè¼"H…Àtè²"‹L$@‰H‹ÃHƒÄ [ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„H‹ÁIƒørS¶ÒI¹I¯ÑIƒø@rH÷ÙƒátL+ÁH‰HÈM‹ÈIƒà?IÁéu9M‹ÈIƒàIÁétfffH‰HƒÁIÿÉuôM…Àt
ˆHÿÁIÿÈuöÃ@fffffIùs0H‰H‰QH‰QHƒÁ@H‰QØH‰QàIÿÉH‰QèH‰QðH‰QøuØë”fDHÃHÃQHÃQHƒÁ@HÃQØHÃQàIÿÉHÃQèHÃQðHÃQøuÐð€$éTÿÿÿÌÌÌÌÌÌÌÌÌÌÌÌff„L‹ÙMÀt$H+ÊöÂt(Š„Àˆ„ãHÿÂIÿÈtöÂuæëI‹ÃÃH‰HƒÂH‹Iƒèr&I¹ÿþþþþþþ~LÈL‹ÐIƒòÿM3ÑI¹M…ÑtÉIƒÀ„‹„Àˆ„„HÿÂIÿÈtx„äˆ$tuHÿÂIÿÈtiHÁè„ÀˆtbHÿÂIÿÈtV„äˆ$tSHÿÂIÿÈtGHÁè„Àˆt@HÿÂIÿÈt4„äˆ$t1HÿÂIÿÈt%Áè„ÀˆtHÿÂIÿÈt„äˆ$tHÿÂIÿÈ…<ÿÿÿI‹ÃÃHÊH3ÒIƒørEöÁt
HÿÁˆIÿÈëñIƒè rH‰H‰QH‰QH‰QHƒÁ Iƒè sçIƒÀ Iƒèr	H‰HƒÁëñIƒÀIƒèrˆHÿÁëóI‹ÃÃÌÌ@SHƒì E‹H‹ÚL‹ÉAƒãøAöL‹ÑtA‹@McP÷ØLÑHcÈL#ÑIcÃJ‹H‹C‹HHKöAt¶AƒàðH˜LÈL3ÊI‹ÉHƒÄ [é™ÌHƒì(M‹A8H‹ÊI‹Ñè‰ÿÿÿ¸HƒÄ(ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂHƒÊÿè¾'HƒÄ8ÃÌH‰\$L‰D$UVWATAUAVAWHƒì0L‹¤$¨L‹¬$˜H‹ùL‹ò3ÒM‹ù‹Ê‰T$pH;út
L;òuL;Ât¹é¼L;ÂtñL;ÊuH9”$uâë
H9”$tÖL;êuH9”$ uÇë
H9”$ t»L;âuH9”$°u¬ë
H9”$°t ¸H‹ß8tHÿÈHÿÃH;Âwñ€;:u,L;òt!Iƒø‚;A¹L‹ÇHƒÊÿI‹ÎèÏ(3ÒH{ëL;òtAˆH‹êH‹òH‹ß8te¾è–(3Ò;ÂtHÿÃëŠ
L‰?
H‹ 
‹

è¥íÿÿ‹ø‰D$ …Ûu‹Èèôýÿÿèþÿÿë‹øƒ|$@u‹ÈèéýÿÿÌèÿýÿÿ‹ÇH‹\$HHƒÄ0_ÃÌHƒì(è7BHƒÄ(éVþÿÿÌÌH‹ÄH‰XH‰hH‰p H‰PWATAUAVAWHƒì@M‹yM‹!I‹q8M+çöAfM‹ñH‹êL‹é…Ü3ÿH‰HÈL‰@Ð9>†+H^‹CøL;à‚§‹CüL;àƒ›ƒ{„‘ƒ;t‹HL$0H‹ÕIÇÿÐ…Àˆ„~sA}csmàu(Hƒ=KtH
Bè5…ÀtºI‹Íÿ+‹KA¸H‹ÕIÏèGBI‹F@‹SMcMH‰D$(I‹F(I×M‹ÅH‹ÍH‰D$ ÿ×ÃèJBÿÇHƒÃ;>sjé>ÿÿÿ3ÀëfI‹y 3íI+ÿ9.vTH^‹KôL;ár>‹CøL;às6H;ùrH;øsAöE u/ƒ;t	‹H;øt#ëH‹T$xIDZI‰D‹CüMÇAÿÐÿÅHƒÃ;.r°¸L\$@I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰|$ATHƒì H‹Ùèè‹Èè•A…À„—èíÿÿHƒÀ0H;Øu3ÀëèòìÿÿHƒÀ`H;Øuw¸ÿÂ÷CucL%&HcøIƒ<üu+¹èJI‰üH…ÀuHC H‰CH‰¸‰C$‰CëI‹üÇC$ÇCH‰KH‰K¸ë3ÀH‹\$0H‹|$8HƒÄ A\ÃÌÌÌ…Ét0SHƒì ºbH‹ÚsH‹ÊèÁcÿîÿÿƒc$Hƒ#HƒcHƒÄ [ÃÌÌÌ@SHƒì öB@I‹ØtHƒzuAÿë&ƒBÿx
H‹ˆHÿ¶Áë¾Éèæ,ƒøÿu	ëÿHƒÄ [ÃÌ…Ò~LH‰\$H‰l$H‰t$WHƒì I‹ùI‹ð‹Ú@ŠéL‹ÇH‹Ö@ŠÍÿËè…ÿÿÿƒ?ÿt…ÛçH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì Aö@@I‹ùI‹ð‹ÚH‹étIƒxuAë7…Ò~3ŠML‹ÇH‹ÖÿËèÿÿÿHÿŃ?ÿuè=ƒ8*uL‹ÇH‹Ö±?èÿþÿÿ…ÛÍH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$UVWATAUAVAWHìÐH‹JôH3ÄH‰„$È3ÀH‹ÙH‰L$hH‹úHL$xI‹ÐM‹é‰D$`D‹à‰D$TD‹ð‰D$H‰D$X‰D$Pè¨óÿÿE3ÒI;ÚuAè£3ÛE3ÉE3À3Ò3ÉÇH‰\$ è·8œ$tH‹„$ˆƒ ÈýƒÈÿéýAƒÏÿöC@L
ðÏÿÿ…ºH‹Ëè
HËóA;Çt(ƒøþt#LcÀL
ÇÏÿÿI‹ÈAƒàHÁùMkÀXM„É€Cë
L‹ÂL
¤ÏÿÿAö@8u)A;ÇtƒøþtHcÐH‹ÂƒâHÁøHkÒXI”Á€CöB8€tAè×3ÛE3ÉE3À3Ò3ÉÇH‰\$ èë
8œ$tH‹„$ˆƒ ÈýA‹Çé1E3ÒI;út·@Š/A‹òD‰T$@D‰T$DA‹ÒL‰”$˜A:ê„êH‹œ$¨A»HÿÇA;òH‰¼$°ŒÈEàÿtkHƒ>þteAöEt^AöEuH‹ÿ˜´A;ÇtILcçI‹ÄHÁøAƒäMkäXM$ÆH‹I‰$AŠEAˆD$IL$º èÎ*A;ÇtAÿD$ëƒÈÿéÕÿÇIÿÅHƒÆ;û|‚E‹çI‹ÿH‹ßHkÛXH)Hƒ;ÿtHƒ;þt€K€ëÆCAD$ÿ÷ØɃÁõ¸öÿÿÿE;çDÈÿî³H‹ðHƒøÿtJI;ÇtEH‹Èÿß³A;Çt7H‰3¶Àƒøu€K@ë	ƒøu€KHKº è"*A;ÇtÿCëƒÈÿë.€K@HÇþÿÿÿAÿÄHÿÇHƒÿŒQÿÿÿ‹
jÿl³3ÀëƒÈÿLœ$I‹[ I‹s(I‹{0M‹c8I‹ãA_A^A]ÃÌÌÌHƒì8H…Éu%è*Hƒd$ E3ÉE3À3Ò3ÉÇè?ƒÈÿë‹AHƒÄ8ÃÌÌH‰
YøÃ@SHìàƒd$pHL$t3ÒA¸”èPßÿÿL\$pH„$HŒ$L‰\$HH‰D$Pÿ³H‹œ$HT$@H‹ËE3ÀèqH…Àt;Hƒd$8H‹T$@HL$`H‰L$0HL$XL‹ÈH‰L$(HŒ$L‹ÃH‰L$ 3Éè-ë H‹„$èH‰„$H„$èH‰„$¨H‹„$èÇD$pÀÇD$tH‰„$€ÿe²3É‹ØÿS²HL$Hÿ@²…Àu…ÛuHèl4ÿ"²ºÀH‹Èÿ²HÄà[ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0H‹éH‹
÷A‹ÙI‹øH‹òè@H…ÀtL‹T$`D‹ËL‹ÇH‹ÖH‹ÍL‰T$ ÿÐë%¹è÷3L‹\$`D‹ËL‹ÇH‹ÖH‹ÍL‰\$ èhþÿÿH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌÌL
)å3ÀI‹ÑD@;
t+ÿÀIЃø-ròAíƒøw¸
ÃÁDÿÿÿ¸ƒùAFÀÃH˜A‹DÁÃÌHƒì(èwH…Àu	H;æëHƒÀHƒÄ(ÃHƒì(èWH…Àu	HæëHƒÀHƒÄ(Ã@SHƒì ‹Ùè3H…Àu	HûåëHƒÀ‰èLãåH…ÀtLP‹Ëè;ÿÿÿA‰HƒÄ [ÃÌÌH‰\$H‰l$H‰t$WHƒì 3ÿH‹ñƒÍÿH‹ÎèØ2H‹ØH…Àu(9®õv ‹Ïÿ°DŸèD;–õA‹ûGý;ýuÈH‹l$8H‹t$@H‹ÃH‹\$0HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3ÿH‹òH‹éAƒÌÿE3ÀH‹ÖH‹ÍèiH‹ØH…Àu*93õv"‹Ïÿ¡¯DŸèD;õA‹ûAGüA;üuÀH‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3öH‹úH‹éAƒÌÿH‹×H‹Íè”2H‹ØH…Àu/H…ÿt*9­ôv"‹Îÿ¯DžèD;•ôA‹óAGôA;ôu¾H‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌÌÌH‰\$H‰l$H‰t$WATAUHƒì 3öI‹øH‹êAƒÍÿL‹áL‹ÇH‹ÕI‹ÌèÛ2H‹ØH…Àu/H…ÿt*9 ôv"‹ÎÿŽ®DžèD;ôA‹óAGõA;õu»H‹l$HH‹t$PH‹ÃH‹\$@HƒÄ A]A\_ÃH…Ét7SHƒì L‹ÁH‹
L3ÒÿÔ®…ÀuèSýÿÿH‹Øÿº®‹Èèûüÿÿ‰HƒÄ [ÃÌÌÌH‰\$H‰t$ATHƒì03öNèj^‰\$ ;ˆ}iLcãH‹\Jƒ<àtPJ‹àöAƒtè&3ƒøÿtÿƉt$$ƒû|1H‹/J‹àHƒÁ0ÿñ­H‹
J‹áèAÿÿÿL‹
Kƒ$ãÿÉ\$ ë¹èç‹ÆH‹\$@H‹t$HHƒÄ0A\ÃH‰\$H‰t$WHƒì ‹A3öH‹Ù$<u?÷At6‹9+y…ÿ~-èúÿÿH‹SD‹Ç‹ÈèV:;Çu‹C„Àyƒàý‰CëƒK ƒÎÿH‹Kƒc‹ÆH‹t$8H‰H‹\$0HƒÄ _ÃÌÌÌ@SHƒì H‹ÙH…Éuè5ë,èjÿÿÿ…ÀtƒÈÿëºcsH‹Ëè¢ùÿÿ‹Èè;÷ØÀë3ÀHƒÄ [ÃÌH‰t$H‰|$L‰d$AUAVAWHƒì0D‹ñE3ä3öNèç3ÿ‰|$ AƒÏÿ;=†LcïH‹ÒJƒ<ètjJ‹èöBƒt`‹ÏèÎ×ÿÿH‹²J‹èöAƒt5Aƒþuè9ÿÿÿA;Çt%AÿÄD‰d$$ëE…öuöAtèÿÿÿA;ÇAD÷‰t$(H‹lJ‹ê‹Ïèý×ÿÿÿlj|$ énÿÿÿ¹è@AƒþADô‹ÆH‹t$PH‹|$XL‹d$`HƒÄ0A_A^A]ùéÿÿÿÌÌH‰\$H‰t$H‰|$ATHƒì L%á3ö3ÿI‹Üƒ{u%Hcƺ ÿÆH€HþðHÈH‰è"…Àt-HãHƒÃÿÇH;Ø|øH‹\$0H‹t$8H‹|$@HƒÄ A\ÃHcÇHÀIƒ$Ä3ÀëÛÌÌH‰\$H‰l$H‰t$WHƒì HuàH-®âH‹ûH‹7H…ötƒtH‹Îÿ$«H‹Îè|üÿÿHƒ'HƒÇH;ý|ÔH‹H…Étƒ{uÿûªHƒÃH;Ý|ãH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌHcÉHàHÉH‹ÈHÿ%lªH‰\$H‰t$H‰|$AUHƒì HcÙ¾Hƒ=_üuèNèè¹ÿèZàÿÿH‹ûHÿL-©ßIƒ|ýt‹Æë{¹(èÃùÿÿH‹ØH…Àuè.ùÿÿÇ3ÀëZ¹
èfIƒ|ýu/º H‹ËèŒ …ÀuH‹Ëè€ûÿÿèóøÿÿÇ3öëI‰\ýë	H‹ËèbûÿÿH‹
Êßÿœ©‹ÆH‹\$0H‹t$8H‹|$@HƒÄ A]ÃH‰\$WHƒì HcÙH=øÞHÛHƒ<ßuèõþÿÿ…ÀuHèßÿÿH‹ßH‹\$0HƒÄ _Hÿ%8©H‰\$WHƒì0I‹ØH‹úH…Ét23ÒHBàH÷ñH;Çs$èHøÿÿHƒd$ E3ÉE3À3Ò3ÉÇè]÷ÿÿ3Àë]H¯ù¸H…ÿHDø3ÀHƒÿàwH‹
òúPL‹Çÿ~©H…Àu-ƒ=êútH‹Ïè°…ÀuËH…Ût²ÇëªH…ÛtÇH‹\$@HƒÄ0_ÃÌH‰\$H‰l$H‰t$WHƒì0H‹òH‹éH…É„ûH…Ò„ò3ÿH‹ÙM…Àt!AŠ„Àt¿H;׆¼HYˆÆ:HÿÃI‹ÑM…ÉtAA€9t;HÿÇH;þƒ–ŠHÿˆHÿÀ:uåI‹ÉèL8€8/t€8\tHÿÇH;þsmÆ\HÿÃH‹L$`H…ÉtëHÿÇH;þsSŠˆHÿÃHÿÁ€9uéH‹L$hH…Ét1Š„Àt+<.t"HÿÇH;þs(Æ.HÿÃëHÿÇH;þsŠˆHÿÃHÿÁ€9uéHGH;ÆvÆEè°öÿÿ»"ëÆ3Àë#èöÿÿ»Hƒd$ E3ÉE3À3Ò3ɉè±õÿÿ‹ÃH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌH‰\$H‰t$WHƒì@‹ÚH‹ÑHL$ A‹ùA‹ðè<ÚÿÿH‹D$(D¶ÛA„|u…ötH‹D$ H‹ˆ@B·Y#Æë3À…Àt¸€|$8tH‹L$0ƒ¡ÈýH‹\$PH‹t$XHƒÄ@_ÃÌH‹Â‹ÑA¹H‹ÈE3ÀénÿÿÿÌÌ‹ÑA¹E3À3ÉéZÿÿÿÌÌHƒì8Hƒd$ èÍ6HƒÄ8ÃH‰L$HìˆH
áîÿû¦L‹ÌïL‰\$XE3ÀHT$`H‹L$XèKsH‰D$PHƒ|$PtAHÇD$8HD$HH‰D$0HD$@H‰D$(HŒîH‰D$ L‹L$PL‹D$XH‹T$`3Éèùrë"H‹„$ˆH‰XïH„$ˆHƒÀH‰åîH‹>ïH‰¯íH‹„$H‰°îdží	ÀÇ€íH‹%ÙH‰D$hH‹!ÙH‰D$pÿ¦‰ðí¹è"(3Éÿæ¥H
Ÿ©ÿÑ¥ƒ=Êíu
¹èú'ÿ°¥º	ÀH‹Èÿš¥HĈÃÌÌH‰\$H‰l$H‰t$WHƒì HYH‹é¾H‹ËL‹Æ3Òè«ÑÿÿE3ÛH}AKA·ÃD‰]D‰]D‰]fó«H=¦ÜH+ýŠˆHÿÃHƒîuòHºŠ9ˆHÿÁHƒêuòH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$H‰t$WHì€H‹ØH3ÄH‰„$pH‹ñ‹IHT$Pÿ¥»…À„=3ÀHT$pˆÿÀHÿÂ;ÃrõŠD$VÆD$p H|$Vë)¶WD¶ÀD;ÂwA+ÐI‹ÀJLpDB² è½ÐÿÿHƒÇŠ„ÀuÓ‹Fƒd$8LD$p‰D$0‹FD‹Ë‰D$(H„$pº3ÉH‰D$ è?ƒd$@‹F‹V‰D$8H„$p‰\$0H‰D$(LL$pD‹Ã3ɉ\$ èØ;ƒd$@‹F‹V‰D$8H„$p‰\$0H‰D$(LL$pA¸3ɉ\$ è¢;Lœ$pHN3ÒAöt€	Š„pëAöt€	 Š„pˆëÆHÿÁHÿÂIƒÃHƒëu¿ë?3ÒHNDBŸA@ ƒøw€	B ëAƒøw€	 BàˆëÆÿÂHÿÁ;ÓrÇH‹Œ$pH3ÌèÖÕÿÿLœ$€I‹[I‹s I‹ã_ÃÌH‰\$WHƒì èÝ
H‹ø‹ˆÈ…
šßtHƒ¸Àt	H‹˜¸ën¹
è÷øÿÿH‹Ÿ¸H‰\$0H;_ÞtDH…ÛtðƒÿuHÚH‹L$0H;ÈtèüóÿÿH‹5ÞH‰‡¸H‹'ÞH‰D$0ðƒH‹\$0¹
è“÷ÿÿH…ÛuK èÊ×ÿÿH‹ÃH‹\$8HƒÄ _Ã@SHƒì@‹ÙHL$ 3ÒèÕÿÿƒ%)ïƒûþu%Çïÿ”¢€|$8tSH‹L$0ƒ¡ÈýëEƒûýuÇðîÿb¢ëÔƒûüuH‹D$ ÇÔî‹@뻀|$8tH‹D$0ƒ Èý‹ÃHƒÄ@[ÃH‰\$UVWATAUHƒì@H‹ÝÔH3ÄH‰D$8H‹òèIÿÿÿ3Û‹ø;Ãu
H‹ÎèüÿÿéL-1Ý‹ËH‹ëI‹ÅA¼98„'AÌIìHƒÀ0ƒùréÿèý„ÿéý„ø·Ïÿ³¡;ÄçHT$ ‹Ïÿ†¡;ÄÆHN3ÒA¸è]Íÿÿ‰~‰^D9d$ †HD$&8\$&t-8Xt(¶8¶H;ùw+ÏHT7AÌ€
IÔI+ÌuõHƒÀ8uÓHF¹þ€IÄI+Ìuõ‹Né¤t(ƒétƒé
tA;Ìt‹Ãë¸ë¸ë¸ë¸‰FD‰fë‰^H~·Ã¹fó«éà9Bí…·þÿÿƒÈÿéÖHN3ÒA¸èƒÌÿÿHlmLÏÛHíAºMDíI‹ÈA8t18Yt,¶¶A;ÐwLL2AŠAÔA¶AMÌ;ÐvìHƒÁ8uÏIƒÀMÜM+Ôu»‰~ï¤D‰ft$ƒïtƒï
tA;üu»ë»ë»ë»‰^HVI|í¹·HƒÇf‰HƒÂI+ÌuíH‹Îè|úÿÿ3ÀH‹L$8H3ÌèÒÿÿH‹œ$€HƒÄ@A]A\_^]ÃÌH‹ÄH‰XH‰pH‰xL‰` AUHƒì0‹ùAƒÍÿèH‹ðèüÿÿH‹ž¸‹Ïè¾üÿÿD‹à;C„¹ è\îÿÿH‹Ø3ÿH;Ç„|H‹–¸H‹ÈA¸ èY:‰;H‹ÓA‹ÌèýÿÿD‹è;Ç…$H‹Ž¸ðƒÿuH‹Ž¸L%ÖI;ÌtèüïÿÿëL%ÖH‰ž¸ðƒö†È…	öÛ…ü¹
èˆôÿÿ‹C‰^ë‹C‰Yë‹C‰Të‹×‰T$ L«­ÿÿƒú}HcÊ·DKfA‰„Hˆ=ÿ‰T$ ëâ‹×‰T$ ú}HcÊŠDBˆ„ *ÿ‰T$ ëá‰|$ ÿ}HcÏŠ„Bˆ„0+ÿlj|$ ëÞH‹kÙðƒÿuH‹
^ÙI;ÌtèïÿÿH‰MÙðƒ¹
èÃòÿÿë+ƒøÿu&L%ÕI;ÜtH‹ËèäîÿÿèWìÿÿÇë3ÿD‹ïA‹ÅH‹\$@H‹t$HH‹|$PL‹d$XHƒÄ0A]ÃHƒì(ƒ=aòu¹ýÿÿÿèñýÿÿÇKò3ÀHƒÄ(ÃH‰\$H‰t$WHƒì H‹(H‹ÙH…ÀtyH
ÇÞH;ÁtmH‹ƒH…Àtaƒ8u\H‹‹ H…Étƒ9uè;îÿÿH‹‹(è·=H‹‹H…Étƒ9uèîÿÿH‹‹(èM=H‹‹èîÿÿH‹‹(èõíÿÿH‹ƒ0H…ÀtGƒ8uBH‹‹8HéþèÑíÿÿH‹‹H¿€H+Ïè½íÿÿH‹‹PH+Ïè®íÿÿH‹‹0è¢íÿÿH‹‹XHtÜH;Ètƒ¹`uèÕ:H‹‹XèuíÿÿH{X¾HµØH9GðtH‹H…Ét
ƒ9uèMíÿÿHƒøtH‹OH…Ét
ƒ9uè3íÿÿHƒÇ Hƒîu½H‹ËH‹\$0H‹t$8HƒÄ _éíÿÿÌÌðƒH‹H…ÀtðƒH‹ H…ÀtðƒH‹H…ÀtðƒH‹0H…ÀtðƒHAXA¸HØH9PðtH‹H…ÒtðƒHƒxøt
H‹PH…ÒtðƒHƒÀ IƒèuÉH‹Xðƒ€`ÃÌÌÌH…É„˜AƒÉÿðD	H‹H…ÀtðDH‹ H…ÀtðDH‹H…ÀtðDH‹0H…ÀtðDHAXA¸Hf×H9PðtH‹H…ÒtðD
Hƒxøt
H‹PH…ÒtðD
HƒÀ IƒèuÉH‹XðDˆ`H‹ÁÃÌÌÌ@SHƒì H‹ÚH…ÒtAH…Ét÷ÿÿL‹àH‹
Èåè/÷ÿÿH‹ØI;Ä‚˜H‹øI+üLoIƒý‚„I‹Ìèó9H‹ðI;ÅsTºH;ÂHBÐHÐH;ÐrI‹Ìè¿àÿÿ3ÛH;Ãuë3ÛHV H;ÖrFI‹Ìè£àÿÿH;Ãt9HÁÿHøH‹ÈèžöÿÿH‰GåI‹ÎèöÿÿH‰HKèƒöÿÿH‰$åI‹Þë3ÛèÆÿÿH‹ÃH‹\$@H‹t$HH‹|$PHƒÄ A^A]A\ÃÌÌÌHƒì(èïþÿÿH÷ØÀ÷ØÿÈHƒÄ(ÃÌH‰\$WHƒì H—¥H=¥ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì Ho¥H=h¥ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì HÏ¿
H‹èªõÿÿH‰HƒÃHƒïuëH‹\$0HƒÄ _ÃÌÌH‹Á¹MZf9t3ÀÃHcHËÿÿÇ3ÀH‹\$0H‹t$8HƒÄ _Ãè!ËÿÿH‹Øÿˆ|‹ÈèÉÊÿÿ‰ëÕèËÿÿH‹Øÿo|‹Èè°Êÿÿ‰H‹Æë»ÌH‰\$H‰t$WHƒì03ÿH‹ÚH‹ñH…Òt13ÒHGàH÷óI;Às#èÁÊÿÿH!|$ E3ÉE3À3Ò3ÉÇè×Éÿÿ3Àë=I¯ØH…Étè%H‹øH‹ÓH‹ÎèÃþÿÿH‹ðH…ÀtH;ûsH+ßH3ÒL‹Ãèá§ÿÿH‹ÆH‹\$@H‹t$HHƒÄ0_ÃÌÌH‰\$WHƒì0ƒÏÿH‹ÙH…Éu#è:ÊÿÿH!\$ E3ÉE3À3Ò3ÉÇèPÉÿÿÇëFöAƒt:è‰ÍÿÿH‹Ë‹øè*H‹ËèÇÇÿÿ‹Èèè(…ÀyƒÏÿëH‹K(H…Ét
èiÌÿÿHƒc(ƒc‹ÇH‹\$@HƒÄ0_ÃÌÌÌH‰\$H‰L$WHƒì0H‹ÙƒÏÿ3ÀH…É•À…Àu$è¢ÉÿÿÇHƒd$ E3ÉE3À3Ò3Éè·Èÿÿ‹Çë&öA@tƒaëè~¥ÿÿH‹Ëèÿÿÿ‹øH‹Ëèû¥ÿÿ‹ÇH‹\$HHƒÄ0_ÃÌÌH‰\$ UVWATAUAVAW¸0èÞjH+àH‹„­H3ÄH‰„$ 3í3ÿE‹èL‹âHcÙ‰l$@E…Àu3ÀéçH…Òu.èÉÿÿ!8èóÈÿÿH!|$ E3ÉE3À3Ò3ÉÇè	ÈÿÿƒÈÿé´L‹ûL‹óHÜÌIÁþAƒçJ‹ðL‰t$PMkÿXAŠt8@ö@Ðþ@€þt@€þu	A‹Å÷ШtAöD t
3Ò‹ËDBèš‹Ëèï÷ÿÿ…À„ñH|ÌJ‹ðAöD€„ÚèSáÿÿ3ÛHT$XH‹ˆÀHRÌ9YJ‹ðI‹”ÃÿŽz…À„¤…Ût	@„ö„—ÿkz!|$LI‹Ü‰D$XE…í„wD‹t$X½
@„ö…ƒH‹T$PŠE3ö€ù
H-èËH‹TÕA”ÆAƒ|Pt AŠDLˆL$]A¸ˆD$\AƒdPHT$\ëI¾ÉèË÷ÿÿ…Àt4I‹ÅH+ÃIÄHƒøŽÏHL$DA¸H‹Óè5*ƒøÿ„vHÿÃëA¸H‹ÓHL$Dè*ƒøÿ„UHƒd$8Hƒd$0‹L$XHD$\LD$DA¹3ÒÇD$(HÿÃH‰D$ ÿ#y‹è…À„H‹D$PHƒd$ H
ËH‹ÁLL$LHT$\I‹D‹Åÿ¼x…À„B‹ûA+ü|$@9l$LŒË½
E…ö„¯H‹D$PHƒd$ @ˆl$\H
¬ÊLL$LDEôH‹ÁHT$\I‹ÿ`x…À„æƒ|$L|{ÿD$@ÿÇëe@€þt@€þu·E3öfƒø
f‰D$DA”ÆHƒÃ@€þt@€þu6·L$Dèh&f;D$D…“ƒÇE…öt‹Íf‰l$DèI&f;D$DuxÿÇÿD$@‹ÃA+ÄA;Å‚þÿÿ‹\$LL‹t$P‹l$@…ÿ…¸…Û„zƒû…eèÃÅÿÿÇ	èØÅÿÿ‰éØüÿÿŠL‹t$PÿÇJ‹LõAˆDLJ‹DõAÇDP‹\$Lë¥ÿôv‹Øë–‹\$Lë¡H‹ÉJ‹ðAöD€„Ê3ÛI‹ì@„ö…ÐE…í„üS
D‹t$@H´$ 3É‹ÅA+ÄA;Ås&ŠEHÿÅ<
uˆAÿÆHÿÆHÿÁHÿÁˆHÿÆHùÿrÐH!\$ H„$ D‹ÆD+ÀHÉD‰t$@L‹t$PLL$HH”$ J‹ðI‹ÿ³v…Àt5|$HH„$ H+ðHcD$HH;ÆŒÅþÿÿ‹Åº
A+ÄA;Å‚Nÿÿÿé­þÿÿÿüu‹Øé þÿÿ@€þ…ÔE…í„"º
D‹t$@H´$ 3É‹ÅA+ÄA;Ås1·EHƒÅfƒø
uf‰AƒÆHƒÆHƒÁHƒÁf‰HƒÆHùþrÅH!\$ H„$ D‹ÆD+ÀH!ÈD‰t$@L‹t$PLL$HH”$ J‹ðI‹ÿÌu…À„Jÿÿÿ|$HH„$ H+ðHcD$HH;ÆŒÚýÿÿ‹Åº
A+ÄA;Å‚?ÿÿÿéÂýÿÿE…í„NA¸
HL$p3Ò‹ÅA+ÄA;Ås.·EHƒÅfƒø
ufD‰HƒÁHƒÂHƒÂf‰HƒÁHú¨rÈHƒd$8Hƒd$0HD$p+ÈLD$pÇD$(U
‹Á¹éý™+Â3ÒÑøD‹ÈH„$ H‰D$ ÿ-uD‹ð…À„€ýÿÿ3öH‹D$PHƒd$ HcÎH” E‹ÆH
ÇH‹ÁLL$HD+ÆI‹ÿºt…Àtt$HD;ö½ëÿ-t‹ØD;öÈüÿÿ‹ýA¸
A+üA;ý‚ÿÿÿé¯üÿÿI‹H!|$ LL$HE‹ÅI‹Ôÿgt…Àt‹|$H3ÛéüÿÿÿÚs‹Øé‚üÿÿ‹ËèœÂÿÿé~ùÿÿHhÆJ‹ðAöD@tA€<$„.ùÿÿè4ÂÿÿÇèIÂÿÿƒ éHùÿÿ+ý‹ÇH‹Œ$ H3Ìèå¥ÿÿH‹œ$ˆHÄ0A_A^A]A\_^]ÃÌÌH‰\$H‰t$‰L$WATAUAVAWHƒì0E‹àL‹êHcÙƒûþuèâÁÿÿ3ÿ‰8è¹ÁÿÿÇ	ƒÈÿéÔ3ÿ;ߌ¡;›Åƒ•H‹óL‹óIÁþL=œÅƒæHköXK‹÷¾L0ƒáu+èŠÁÿÿ‰8ècÁÿÿÇ	H‰|$ E3ÉE3À3Ò3ÉèyÀÿÿƒÈÿëm‹Ëèõ%K‹÷öD0tE‹ÄI‹Õ‹ËèÔ÷ÿÿ‹øëèÁÿÿÇ	è0Áÿÿ‰8ƒÏÿ‹Ëèd&‹Çë)èÁÿÿ‰8èôÀÿÿÇ	H‰|$ E3ÉE3À3Ò3Éè
ÀÿÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌÌH‰\$‰L$VWATHƒì0HcùƒÿþuèžÀÿÿÇ	ƒÈÿéمɈ®;=‚ă¢H‹ßH‹÷HÁþL%ƒÄƒãHkÛXI‹ô¾Lƒáu%èQÀÿÿÇ	Hƒd$ E3ÉE3À3Ò3Éèf¿ÿÿƒÈÿëz‹Ïèâ$I‹ôöDt+‹ÏèK$H‹Èÿ~r…Àu
ÿtq‹Øë3Û…ÛtèÀÿÿ‰èî¿ÿÿÇ	ƒËÿ‹Ïè>%‹Ãë#èÕ¿ÿÿÇ	Hƒd$ E3ÉE3À3Ò3Éèê¾ÿÿƒÈÿH‹\$`HƒÄ0A\_^ÃÌH‰\$WHƒìPH‹ÚH‹ùH…Éu$莿ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ裾ÿÿ3ÀëvH…Òt×H;ÊsòHL$0I‹ÐèP£ÿÿL‹\$8Aƒ{u€|$HHCÿtHH‹L$@ƒ¡Èýë:HSÿHÿÊH;úw¶BöDuíH‹ËH+ʃáH+Ù€|$HtH‹L$@ƒ¡ÈýHCÿH‹\$`HƒÄP_ÃÌÌE3Àé<ÿÿÿH‰\$H‰l$H‰t$WATAUHƒìPE3íI‹ùI‹ðH‹êH‹ÙM;ÍuI;ÍuI;Õu 3Àë>I;ÍtI;ÕvM;ÍuDˆ)ëèM;Åu?Dˆ)艾ÿÿ»E3ÉE3À3Ò3ɉL‰l$ èž½ÿÿ‹ÃL\$PI‹[ I‹k(I‹s0I‹ãA]A\_ÃH‹”$HL$0è8¢ÿÿL‹\$8H‹ÕH‹ËE9ku L‹ÏL‹ÆèXD8l$Ht±H‹L$@ƒ¡Èýë£HƒÿÿuŠHÿƈHÿÁA:Åt.Hƒêuëë&ŠHÿƈHÿÁA:ÅtHƒêtHƒïuåI;ýuDˆ)HÿÁI;Õ…D8.tHƒÿuYLaÿI‹ôL;ãr¶HT$0è³ÇÿÿA;ÅtHÿÎH;ósæA‹Ä+ƨt*Eˆ,$耽ÿÿº*‰D8l$HtH‹L$@ƒ¡Èý‹ÂéóþÿÿHƒÿÿu\HƒývOHt+þH‹þH;ór¶HT$0èMÇÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt Dˆ.D8l$HtH‹D$@ƒ Èý¸Pé˜þÿÿDˆl+ÿëÜDˆ+èõ¼ÿÿ»"E3ÉE3À3Ò3ɉL‰l$ è
¼ÿÿD8l$H„aþÿÿH‹L$@ƒ¡ÈýéPþÿÿH‹ÁH+ÃHƒø|YHqþH‹þH;ór¶HT$0è­ÆÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt+Dˆ.è|¼ÿÿº*‰D8l$H„ÿÿÿH‹D$@ƒ ÈýéóþÿÿD8l$H„ ýÿÿH‹D$@ƒ ÈýéýÿÿÌ@UATAUAVAWHƒì`Hl$@H‰]PH‰uXH‰}`H‹n H3ÅH‰ED‹¿¾3ÿM‹ÙL‰MD‰ED‹ò‰UH‹ÙDnÿD;×uOLaxE‹Íº3ɉ|$(H‰|$ ÿLn;ÇtE‹ÕD‰-²¾ëÿmD‹£¾ƒøxDDÖD‰•¾L‹]D‹MpD;Ï~5A‹ÉI‹ÃA+Í@88t
IÅ;ÏuñƒÉÿA‹Á+ÁA+ÅA;Á}
DHD‰MpëD‹È‰EpD;Ö„\D;ׄSE;Õ…€D‹¥ˆ‹÷D;çuH‹D‹`÷M‹ÃA‹ÌÒ‰|$(H‰|$ ƒâAÕÿ„mLcøD;ÿ„<H»ðÿÿÿÿÿÿA¾ÝÝA½~[3ÒHBàI÷÷HƒørLKL?I;Íw.HAH;ÁwH‹ÃHƒàðèZ\H+àH|$@H…ÿ„åÇÌÌëèîÿÿH‹øH…ÀtD‰0HƒÇH…ÿ„ÀD‹MpL‹EºA‹ÌD‰|$(H‰|$ ÿÜl3É;Á„K‹U‰L$(H‰L$ ‹ME‹ÏL‹Çÿ¿lE3ÀHcðA;ð„!D‹UAºâ
s;‹…€A;À„;ðÿ‹M‰D$(H‹ExE‹ÏL‹ÇA‹ÒH‰D$ ÿoléÛA;ð~`3ÒHBàH÷öHƒørQHL6I;Íw*HAH;ÁwH‹ÃHƒàðèW[H+àH\$@I;ØtÇÌÌëèíÿÿE3ÀH‹ØI;ÀtD‰0HƒÃD‹UëI‹ØI;Øtn‹ME‹ÏL‹ÇA‹Ò‰t$(H‰\$ ÿâk3É;Át?‹…€3ÒH‰L$8D‹ÎL‹ÃH‰L$0;Áu‰L$(H‰L$ ë
‰D$(H‹ExH‰D$ A‹Ìÿ/k‹ðHKðD91uè»ÿÿHOðD91uè»ÿÿ‹ÆéÍH‹÷L‹çD;÷uH‹D‹pD‰u‹½ˆ…ÿuH‹‹xA‹Îèh D‹èƒøÿu3ÀéL‹}xL‹E;Ç„<3ÛLMp‹Ð‹Ï‰\$(H‰\$ è… H‹ðH;ÃtÉD‹Mp‹UL‹ÀA‹Î‰\$(H‰\$ ÿájLcÈD‰MD;Ëu‹ûéD;ËA¾ÝÝ~bI‹ÉIƒùàwYHƒÁHùw4HYH;Ùw
H»ðÿÿÿÿÿÿHƒãðH‹Ãè¾YH+ãH\$@H…Ût%ÇÌÌëè€ëÿÿH‹ØH…ÀtD‰0HƒÃD‹MH…Ûu3ÛëƒMcÁ3ÒH‹ËèK•ÿÿD‹]D‹Mp‹U‹MD‰\$(L‹ÆH‰\$ ÿ*j‰E…Àu3ÿë.‹…€LML‹Ã‰D$(‹×A‹ÍL‰|$ è‹}L‹à3ÀL;àDøHKðD91u(èó¹ÿÿë!‹…€D‹Mp‹U‰D$(A‹ÎL‰|$ ÿÂi‹ø3ÛH;ótH‹ÎèÁ¹ÿÿL;ãt
M;ütI‹Ì诹ÿÿ‹ÇH‹MH3ÍèñšÿÿH‹]PH‹uXH‹}`He A_A^A]A\]ÃÌÌÌH‰\$H‰t$WHƒìp‹òH‹ÑHL$PI‹ÙA‹øèКÿÿ‹„$¸D‹œ$ÀHL$PD‰\$@‰D$8‹„$°‰D$0H‹„$¨L‹ËH‰D$(‹„$ D‹Ç‹Ö‰D$ èOúÿÿ€|$htH‹L$`ƒ¡ÈýL\$pI‹[I‹sI‹ã_ÃÌÌD‰L$ UATAUAVAWHƒì@Hl$0H‰]@H‰uHH‰}PH‹’šH3ÅH‰ED‹
,¹¿3ÛM‹ðD‹úL‹éwD;Ëu=LMHrD‹Ç‹Ïÿ–h;Ãt‰=ô¸ë6ÿ\gD‹
布øxDDÎD‰
׸D;΄&D;Ë„D;Ï…C‹uh;óuI‹E‹p÷]xD‹MXM‹ÆҋΉ\$(ƒâH‰\$ ×ÿhLcàD;ã„A½ÝÝ~hH¸ðÿÿÿÿÿÿL;àwYKL$Hùw5HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèçVH+àH|$0H;û„µÇÌÌëè¥èÿÿH‹øH;ÃtD‰(HƒÇëH‹ûH;û„‹M‹Ä3ÒH‹ÏMÀèl’ÿÿD‹MXM‹Æº‹ÎD‰d$(H‰|$ ÿVg;ÃtL‹M`D‹ÀH‹×A‹ÏÿWg‹ØHOðD9)uè7·ÿÿ‹ÃéˆD‹epH‹ûD;ãuI‹ED‹`‹uh;óuI‹E‹pA‹Ìè"ƒøÿu3ÀëU;Æt$LMXM‹Æ‹Ð‹Î‰\$(H‰\$ èPH‹øH;Ãt×L‹ðH‹E`D‹MXM‹ÆA‹×A‹ÌH‰D$ ÿÁf‹ðH;ûtH‹Ï誶ÿÿ‹ÆH‹MH3Íèì—ÿÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@A‹ÙI‹øèÌ—ÿÿ‹„$ D‹œ$¨HL$@D‰\$8‰D$0‹„$˜‰D$(H‹„$D‹ËL‹Ç‹ÖH‰D$ è.ýÿÿ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌÌÌÌÌÌÌÌÌÌÌff„L‹ÙH+Ñ‚žIƒøraöÁt6öÁtŠ
IÿȈHÿÁöÁtf‹
Iƒèf‰HƒÁöÁt
‹
Iƒè‰HƒÁM‹ÈIÁéuQM‹ÈIÁétH‹
H‰HƒÁIÿÉuðIƒàM…ÀuI‹ÃÃ@Š
ˆHÿÁIÿÈuóI‹ÃÃfffffff„fffffIù sBH‹
L‹T
HƒÁ H‰AàL‰QèH‹D
ðL‹T
øIÿÉH‰AðL‰QøuÔIƒàéqÿÿÿfff„fHúrµ¸ 
D
@HÁ€ÿÈuìHé¸@L‹
L‹T
LÃ	LÃQL‹L
L‹T
LÃILÃQL‹L
 L‹T
(HƒÁ@LÃIàLÃQèL‹L
ðL‹T
øÿÈLÃIðLÃQøuªIèIøƒqÿÿÿð€$é¹þÿÿffff„fffffffIÈIƒøraöÁt6öÁtHÿÉŠ
IÿȈöÁtHƒéf‹
Iƒèf‰öÁt
Hƒé‹
Iƒè‰M‹ÈIÁéuPM‹ÈIÁétHƒéH‹
IÿÉH‰uðIƒàM…ÀuI‹ÃÃHÿÉŠ
IÿȈuóI‹ÃÃfffffff„fffffIù sBH‹D
øL‹T
ðHƒé H‰AL‰QH‹D
L‹
IÿÉH‰AL‰uÕIƒàésÿÿÿffff„fHúðÿÿwµ¸ Hé€
D
@ÿÈuìHÁ¸@L‹L
øL‹T
ðLÃIøLÃQðL‹L
èL‹T
àLÃIèLÃQàL‹L
ØL‹T
ÐHƒé@LÃILÃQL‹L
L‹
ÿÈLÃILÃuªIèIøƒqÿÿÿð€$éºþÿÿH…É„àSHƒì H‹ÙH‹Iè’²ÿÿH‹K色ÿÿH‹K耲ÿÿH‹K èw²ÿÿH‹K(èn²ÿÿH‹K0èe²ÿÿH‹è]²ÿÿH‹K@èT²ÿÿH‹KHèK²ÿÿH‹KPèB²ÿÿH‹KXè9²ÿÿH‹K`è0²ÿÿH‹Khè'²ÿÿH‹K8è²ÿÿH‹Kpè²ÿÿH‹Kxè²ÿÿH‹‹€è²ÿÿH‹‹ˆèô±ÿÿH‹‹èè±ÿÿH‹‹˜èܱÿÿH‹‹ èбÿÿH‹‹¨èıÿÿH‹‹°è¸±ÿÿH‹‹¸è¬±ÿÿH‹‹Àè ±ÿÿH‹‹Èè”±ÿÿH‹‹Ð舱ÿÿH‹‹Øè|±ÿÿH‹‹àèp±ÿÿH‹‹èèd±ÿÿH‹‹ðèX±ÿÿH‹‹øèL±ÿÿH‹‹è@±ÿÿH‹‹è4±ÿÿH‹‹è(±ÿÿH‹‹è±ÿÿH‹‹ è±ÿÿH‹‹(è±ÿÿH‹‹0èø°ÿÿH‹‹8èì°ÿÿH‹‹@èà°ÿÿH‹‹HèÔ°ÿÿH‹‹PèÈ°ÿÿHƒÄ [ÃÌÌH…ÉtBSHƒì H‹ÙH‹	H;
	¡t袰ÿÿH‹KH;
ÿ tè°ÿÿH‹KH;
õ tè~°ÿÿHƒÄ [ÃH…É„‹SHƒì H‹ÙH‹IH;
Ô tèU°ÿÿH‹K H;
Ê tèC°ÿÿH‹K(H;
À tè1°ÿÿH‹K0H;
¶ tè°ÿÿH‹K8H;
¬ tè
°ÿÿH‹K@H;
¢ tèû¯ÿÿH‹KHH;
˜ tèé¯ÿÿHƒÄ [ÃÌÌÌ@SHƒì0L‹ÉH…Ét
H…ÒtM…Àu,Dˆè8­ÿÿ»Hƒd$ E3ÉE3À3Ò3ɉèL¬ÿÿ‹ÃHƒÄ0[À9t	HÿÁHƒêuòH…ÒuAˆë¿AŠIÿÀˆHÿÁ„ÀtHƒêuëH…ÒuAˆèÚ¬ÿÿ»"ë 3ÀëµÌÌÌ@SHƒì0M‹ØM…ÉuH…ÉuH…Òu 3Àë?H…ÉtH…ÒtM…ÉuDˆ	ëèM…Àu,Dˆè¬ÿÿ»Hƒd$ E3ÉE3À3Ò3ɉ裫ÿÿ‹ÃHƒÄ0[ÃL‹ÑL‹ÂIƒùÿuAŠIÿÃAˆIÿ„Àt,Iƒèuêë$AŠIÿÃAˆIÿ„ÀtIƒètIƒéuäM…ÉuEˆ
M…À…fÿÿÿIƒùÿuDˆDÿA@Pë˜Æè¬ÿÿ»"émÿÿÿÌÌÌ@SHƒì0H…Ét
H…ÒtM…Àu,Dˆè׫ÿÿ»Hƒd$ E3ÉE3À3Ò3ɉèëªÿÿ‹ÃHƒÄ0[ÃL‹ÉAŠIÿÀAˆIÿÁ„ÀtHƒêuêH…Òuˆ莫ÿÿ»"ëµ3ÀëÊÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„H+ÑL‹ÊöÁtŠBŠ	:ÂuVHÿÁ„ÀtWH÷ÁuæI»J	fâÿfúøwËH‹J‹	H;Âu¿Iºÿþþþþþþ~LÒHƒðÿHƒÁI3ÂI…ÃtÇëHÀHƒØÿÃ3ÀÃfff„Òt'„öt#HÁê„Òt„ötHÁê„Òt„ötÁê„Òt„öu‹3ÀÃHÀHƒØÿÃÌÌÌÌÌÌff„H+ÑIƒør"öÁtfŠ:
u,HÿÁIÿÈöÁuîM‹ÈIÁéuM…ÀtŠ:
uHÿÁIÿÈuñH3ÀÃÀƒØÿÃIÁét7H‹H;
u[H‹AH;D
uLH‹AH;D
u=H‹AH;D
u.HƒÁ IÿÉuÍIƒàM‹ÈIÁét›H‹H;
uHƒÁIÿÉuîIƒàëƒHƒÁHƒÁHƒÁH‹HÈHÉH;ÁÀƒØÿÃÌH‰\$WHƒì HcÙA‹øH‰T$8‹Ëèø
Hƒøÿu蹩ÿÿÇ	HƒÈÿëW‹T$8LD$H‹
I©H;Ït2è˽ÿÿH…Àt(ÿÐH‹ØH…ÀtH‹
1©H;Ït諽ÿÿH…ÀtH‹ËÿÐH‹ØH‹
©è’½ÿÿH…ÀtD‹ÍM‹ÅI‹ÖH‹ËÿÐë3ÀH‹\$pH‹l$xHƒÄ@A^A]A\_^ÃHƒì8…Éx ƒù~
ƒùu‹ø›ë1‹ð›‰
ê›ë#蛥ÿÿHƒd$ E3ÉE3À3Ò3ÉÇè°¤ÿÿƒÈÿHƒÄ8ÃHƒì8H…Éu&èj¥ÿÿHƒd$ E3ÉE3À3Ò3ÉÇè¤ÿÿHƒÈÿëL‹ÁH‹
'¨3ÒÿçWHƒÄ8ÃÌ̹鶋ÿÿÌÌHì¨ön˜t
¹
èŠÂÿÿèõÉÿÿH…Àt
¹èòÉÿÿöG˜t_HŒ$ÐÿGVHL$03ÒA¸˜èE‚ÿÿH‹„$¨3ÉH‰D$@HD$0ÇD$0@H‰D$ H„$ÐH‰D$(ÿáUHL$ ÿÎU¹èhŽÿÿÌÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒìPL‹òH‹ÑHHÈE‹áM‹èèFˆÿÿM…ítM‰uM…öu*è;¤ÿÿHƒd$ E3ÉE3À3Ò3ÉÇèP£ÿÿ€|$HééE…ätAƒü|ËAƒü$ÅAŠ.L‹D$03ÿI^Aƒ¸~LD$0@¶Íºè¾¾ÿÿL‹D$0ëI‹€@@¶Í·Hƒà…Àt@Š+HÿÃ뾋´$@€ý-uƒÎë@€ý+u@Š+HÿÃE…äˆSAƒü„IAƒü$?E…äu(@€ý0tA¼
ë8€;xt
€;XtA¼ë&A¼ëAƒüu@€ý0u€;xt€;Xu@ŠkHƒÃM‹@3ÒƒÈÿA÷ôD‹È@¶ÍE·JAöÀt	@¾Íƒé0ëA÷Àt,EŸ@¾Í<wƒé ƒÁÉA;ÌsƒÎA;ùr"u;ÊvƒÎM…íuHÿË@öÆuM…íIEÞ3ÿëYA¯üù@Š+HÿÃ둽ÿÿÿ@öÆu@öÆu:‹Æƒàtÿ€w…Àu';ýv#è¢ÿÿÇ"@öÆtƒÏÿë
@ŠÆ$öØÿ÷ßýM…ítI‰]@öÆt÷߀|$HtH‹L$@ƒ¡Èý‹ÇëM…ítM‰u@8|$HtH‹D$@ƒ Èý3ÀL\$PI‹[ I‹k(I‹s0I‹{8I‹ãA^A]A\ÃÌÌHƒì83ÀE‹ÈL‹Â‰D$ H‹Ñ9 u	H
2‘ë3ÉèQýÿÿHƒÄ8ÃH‰\$WHƒì Hcù‹ÏèìHƒøÿtYH‹Ã¥¹ƒÿu	@„¸¸u
;ùuö@`tè½¹H‹Øè°H;Ãt‹Ïè¤H‹ÈÿT…Àu
ÿÍR‹Øë3Û‹ÏèØL‹ßH‹ÏHÁùAƒãHS¥H‹ÊMkÛXBÆD…Ût‹Ëèb¡ÿÿƒÈÿë3ÀH‹\$0HƒÄ _ÃH‰\$H‰t$ ‰L$WATAUHƒì0HcÙƒûþuè¡ÿÿ3ÿ‰8èã ÿÿÇ	ƒÈÿéÉ3ÿ;ߌ–;ŤƒŠH‹óL‹ãIÁüL-ƤƒæHköXK‹Då¾L0ƒáu+è³ ÿÿ‰8茠ÿÿÇ	H‰|$ E3ÉE3À3Ò3É袟ÿÿƒÈÿëa‹ËèK‹DåöD0t‹Ëè†þÿÿ‹øëèI ÿÿÇ	ƒÏÿ‹Ë虋Çë)èP ÿÿ‰8è) ÿÿÇ	H‰|$ E3ÉE3À3Ò3Éè?ŸÿÿƒÈÿH‹\$`H‹t$hHƒÄ0A]A\_Ã@SHƒì öAƒH‹Ùt"öAtH‹Ièb¢ÿÿc÷ûÿÿ3ÀH‰H‰C‰CHƒÄ [ÃÌHƒìhH‹
„H3ÄH‰D$Pƒ=“f‰L$@tfH‹
È“HƒùþuèÑH‹
¶“Hƒùÿ„¹Hƒd$ LL$DHT$@A¸ÿ0R…À…‰ƒ=­’…ˆÿµPƒøxu}ƒ%•’ÿûQHƒd$8Hƒd$0‹ÈHD$HLD$@A¹3ÒÇD$(H‰D$ ÿQH‹
)“Hƒùÿt0Hƒd$ LL$DHT$HD‹ÀÿšQ…Àtf‹D$@ëÇ!’ëí¸ÿÿH‹L$PH3Ì艂ÿÿHƒÄhÃH‰\$H‰l$H‰t$WHƒìP3íI‹ðH‹úH‹ÙH;ÕtL;Åt
@8*uH;Ítf‰)3ÀH‹\$`H‹l$hH‹t$pHƒÄP_ÃHL$0I‹ÑèJ‚ÿÿL‹\$0A9ku%H;Ýt¶f‰@8l$HtH‹D$@ƒ Èý¸ë®¶HT$0èÎÿÿ;Å„œH‹L$0D‹‰Aƒù~0A;ñ|+‹I‹ÅH;Ý•ÀL‹Çº	‰D$(H‰\$ ÿTPH‹L$0;ÅuHcH;ðr(@8ot"‹@8l$H„4ÿÿÿH‹L$@ƒ¡Èýé#ÿÿÿè’ÿÿÇ*@8l$HtH‹D$@ƒ ÈýƒÈÿéýþÿÿ‹ÅA¹H;Ý•ÀAQL‹Ç‰D$(H‹D$0H‰\$ ‹HÿÅO;Å…ÿÿÿë¤ÌÌÌE3Éé„þÿÿÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WHƒì H‹Ú…Éxi;
¡saHcùH-¡H‹÷ƒçHÁþHkÿXH‹DõHƒ<ÿu=ƒ=Ju'…Étƒétƒùu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿÿ‰OH‹DõH‰3Àë蟜ÿÿÇ	è´œÿÿƒ ƒÈÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌH‰\$H‰l$WHƒì …Éxs;
_ skHcÙH-k H‹ûƒãHÁÿHkÛXH‹DýöDtGHƒ<ÿt@ƒ=›€u)…Étƒétƒùu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿ3ÒÿØNH‹DýHƒÿ3Àëèí›ÿÿÇ	èœÿÿƒ ƒÈÿH‹\$0H‹l$8HƒÄ _ÃHƒì8ƒùþuèÞ›ÿÿƒ 趛ÿÿÇ	ë]…Éx1;
¤Ÿs)HcÑH
°ŸH‹ÂƒâHÁøHkÒXH‹ÁöDtH‹ë,è”›ÿÿƒ èl›ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ	èšÿÿHƒÈÿHƒÄ8ÃH‹ÄH‰XH‰pH‰xL‰` AUHƒì HcÙL‹ãIÁüL-6ŸƒãHkÛXK‹t心|3u3O	èJ¢ÿÿƒ|3uHL3º èoÂÿÿ÷ØÒ#úÿD3¹
è¡ÿÿ…ÿtK‹LåHLÿ‡K‹ÇH‹\$0H‹t$8H‹|$@L‹d$HHƒÄ A]ÃÌÌHcÑH
®žH‹ÂƒâHÁøHkÒXH‹ÁHLHÿ%HKH‰\$H‰|$L‰d$AUAVAWHƒì@IƒÌÿE‹ìE3öAL$诠ÿÿ…ÀuA‹Äéɹè¡ÿÿ3ÿ‰|$$H?žƒÿ@›LcÿJ‹øH…Û„H‰\$0J‹øHH;؃ÍöC…ªƒ{u;¹
è(¡ÿÿƒ{u HKº èOÁÿÿ…ÀuDpD‰t$(ëÿC¹
è÷ŸÿÿE…öu HKÿdJöCtHKÿ\JëHIƒÌÿE…öu?ÆCL‰#L‹K+øH¸£‹.ºè¢‹.H÷ëL‹êIÁýI‹ÅHÁè?Lè‹ÇÁàDèD‰l$ ëHƒÃXH‰\$0IƒÌÿHFé ÿÿÿE;ì…ÿlj|$$H+éçþÿÿºXJÈèõ™ÿÿH‰D$0H…ÀttHc×LI‰Ѓ✠I‹ÐHÁH;ÁsÆ@L‰ Æ@	
ƒ`HƒÀXH‰D$0ëÖÁç‰|$ HcÏH‹ÁHÁøƒáHkÉXI‹ÀÆD‹ÏèHýÿÿ…ÀADüD‹ï‰|$ ¹èÅžÿÿA‹ÅH‹\$`H‹|$hL‹d$pHƒÄ@A_A^A]ÃHƒì8H‹©|H3ÄH‰D$(LD$ A¹ºÆD$&ÿÎJ…ÀuƒÈÿë
HL$ è›H‹L$(H3Ìèæ{ÿÿHƒÄ8ÃÌ@USVWATAUAVAWHìˆHl$@H‹@|H3ÅH‰E0L‹µ°E‹!3ÿI‹ØH‹÷‰}L‰MD‹êD‹ùH‰];Ê„HUÿ4I;Ç„Ÿƒ}…•HUA‹ÍÿI;Ç„€ƒ}uzÇEAƒüÿt`A‹ü…ÿŽ©HcÏH¸ðÿÿÿÿÿÿH;ȇ“HL	HùwlHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèÏ8H+àH\$@H…Ût<ÇÌÌëNH‹Ëè¢Çÿÿxë–E‹ÌL‹ÃºA‹Ï‰|$(H‰|$ ÿhI‹ø…À…oÿÿÿ3Àé7èVÊÿÿH‹ØH…ÀtÇÝÝHƒÃë3ÛH…ÛtÙLcÇ3ÒH‹ËMÀètÿÿL‹EE‹ÌºA‹Ï‰|$(H‰\$ ÿ	IE3ÿA;Ç„ÉM;÷t;‹…¸L‰|$8L‰|$0‰D$(D‹ÏL‹Ã3ÒA‹ÍL‰t$ ÿfHA;Ç„‘I‹öé‰D9}u,L‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹ÍD‰|$(L‰|$ ÿ*H‹øA;ÇtWHc×¹èò–ÿÿH‹ðI;ÇtBL‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹Í‰|$(H‰D$ ÿêGA;Çu
H‹ÎèM˜ÿÿI‹÷ëAƒüÿtH‹M‰HKð9ÝÝuè+˜ÿÿH‹ÆH‹M0H3ÍèlyÿÿHeHA_A^A]A\_^[]ÃÌÌÌ3ÒDB
éyóÿÿÌL‹ÑM…Àt‹W‘A»ƒøxADÓD‹U‰@‘D‹ D;Ë~YA‹ÉI‹ÇA+̃Îÿ8t	IÄ;Ëuï‹Î‹Æ+ÁDÈD‰ D‹…°D;Ã~5A‹ÈH‹ÇA+Ì8t	IÄ;Ëuò‹Î‹Æ+ÁDÀD‰…°ëƒÎÿD;Î}Æ3Àé¥D;Æ|ôA;Ó„¯;Ó„§A;ÔuÞD‹­¸D;ëuI‹D‹iD;Ët	D;Ã…«E;ÈuA‹Ãé\E;Ä~A‹ÄéOE;Ì~
¸é@HUA‹Íÿî=;ÃtƒD‹ D;Ë~2ƒ}rÓ8]HEtÊ8XtÅAŠ:r:HvHƒÀ8ëå¸éñ9°~+ƒ}rŒ8]HEtƒ8X„zÿÿÿŠ:r:HvËHƒÀ8ëâM‹Çº	A‹Í‰\$(H‰\$ ÿW>LcðD;ó„ìþÿÿI¸ðÿÿÿÿÿÿ~d3ÒHBàI÷öHƒørUKL6Hùw.HAH;ÁwI‹ÀHƒàðè5-H+àHt$0H;ó„þÿÿÇÌÌëèó¾ÿÿH‹ðH;ÃtÇÝÝHƒÆëH‹óH;ó„pþÿÿD‹ M‹ÇA‹ÔA‹ÍD‰t$(H‰t$ ÿ¯=;ÄôD‹°L‹Çº	A‹Í‰\$(H‰\$ ÿ†=LcàD;ã„Ç~g3ÒHBàI÷ôHƒørXKL$Hùw1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèg,H+àH|$0H;ûtÇÌÌëè)¾ÿÿH‹øH;ÃtÇÝÝHƒÇëH‹ûH;ûtVD‹°L‹EºA‹ÍD‰d$(H‰|$ ÿæ<;Ãt‹U‹ME‹ÎL‹ÆD‰d$(H‰|$ ÿ6=‹ØHOð9ÝÝu軌ÿÿHNð9ÝÝu誌ÿÿ‹ÃéèH‹ûL‹ëD;ÓuI‹D‹PD‰UD‹¥¸D;ãuI‹D‹`A‹ÊèŽñÿÿD‹ð;Æ„ýÿÿA;ÄteL M‹Ç‹ÐA‹Ì‰\$(H‰\$ èµñÿÿH‹øH;ÄÒüÿÿL‹EL°A‹ÖA‹Ì‰\$(H‰\$ èŠñÿÿL‹èH;Ãu
H‹Ïè
ŒÿÿéžüÿÿL‹ÿL‹ÀëL‹E‹…°D‹ ‹U‹M‰D$(L‰D$ M‹Çÿ4<‹ðH;ûtH‹ÏèÅ‹ÿÿI‹Í轋ÿÿ‹ÆH‹M(H3ÍèÿlÿÿHe8A_A^A]A\_^[]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@I‹ÙA‹øèèlÿÿD‹œ$¨‹„$ HL$@D‰\$8‰D$0H‹„$˜H‰D$(‹„$L‹ËD‹Ç‹Ö‰D$ è¾úÿÿ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$H‰t$WHƒì`H‹ñH‹úHL$@I‹ÑI‹Øè[lÿÿH…Ûu8\$XtH‹D$Pƒ Èý3ÀéÂH…öu=è;ˆÿÿHƒd$ E3ÉE3À3Ò3ÉÇèP‡ÿÿ€|$XtH‹D$Pƒ Èý¸ÿÿÿé€H…ÿt¾HûÿÿÿwµH‹D$@‹P…ÒuLL$@L‹ÃH‹×H‹Îèªòÿÿë>‹@HL$@L‹Î‰D$8‰\$0A¸H‰|$(‰\$ è™þÿÿ…Àu複ÿÿÇéyÿÿÿƒÀþ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$‰T$UVWATAUAVAWHƒì0E3í‹êL‹ñA‹ÝI;Íu$èC‡ÿÿE3ÉE3À3Ò3ÉL‰l$ ÇèY†ÿÿéêL‹!M;å„Óº=I‹Ìè³H‹øH‰D$pI;Å„µL;à„¬D8hH‹5Þ|E‹ýA”ÇH;5Ø|upH‹îA‹ÅI;õuI‹õëUHƒÆÿÀL9.uõÿÀºHcÈè ‡ÿÿH‹øH‹ðI;Åu¹	è'mÿÿëH‹ÈèÍH‰HƒÇHƒÅH‹EI;ÅuäL‰/H‹|$p‹l$xH‰5^|I;õ…‰A;ít9L9-Y|t0èf÷ÿÿA;Åtjè@†ÿÿǃÈÿH‹œ$€HƒÄ0A_A^A]A\_^]ÃE;ýt3Àëß¹蔆ÿÿH‰ý{I;ÅtÆL‰(L9-þ{u¹èr†ÿÿH‰ë{I;Åt¤L‰(H‹5Ì{H‹îI;õt’H‹‹ÇH‹þA+ÄLcèH…Ét?H‹ÑM‹ÅI‹Ìè¿öÿÿ…ÀuH‹A€|=„¢A8\„—HƒÇH‹H…ÉuÈH‹5r{H+þHÁÿ÷ßE3íA;ýŒŒL9m„‚Hc÷H‹LõèÖ‡ÿÿE;ýtfL9lõtHLõH‹ÿÇHƒÁH‰DõHÿÆL9lõuèHc×H¸ÿÿÿÿÿÿÿH;Ѓ“H‹
{A¸èý†ÿÿI;Åt|ësH‹5çzH+þHÁÿérÿÿÿL‰dõM‰.ë]E;ý…A;ý}÷ßG;ÇŒ„þÿÿLcÀH¸ÿÿÿÿÿÿÿL;ÀƒnþÿÿºH‹Î蛆ÿÿI;Å„XþÿÿHcÏL‰$ÈL‰lÈM‰.H‰tzD9l$x„ŠI‹ÌèµÿÿºHHèO…ÿÿH‹øI;ÅtlI‹Ìèã´ÿÿM‹ÄH‹ÏHPèHØÿÿA;ÅtE3ÉE3À3Ò3ÉL‰l$ è+‚ÿÿH‹×H‹ÏI+ÔHT$pDˆ*HÿÂE;ýIEÕÿú6A;ÅuƒËÿèõƒÿÿÇ*H‹Ïèo†ÿÿE;ýtI‹Ìèb†ÿÿM‰.‹Ãé™ýÿÿI‹ÌèP†ÿÿM‰.é¦ýÿÿH‰\$H‰t$WHƒì0H‹ÙH…ÉtFè<´ÿÿH‹ðHHè·ÿÿH‹øH…Àt-HVL‹ÃH‹Èè×ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèpÿÿH‹Çë3ÀH‹\$@H‹t$HHƒÄ0_ÃÌH‰\$H‰t$WHƒìPH‹Ù‹úHL$0I‹Ðè'gÿÿ3öH;ÞuDè#ƒÿÿE3ÉE3À3Ò3ÉH‰t$ Çè9‚ÿÿ@8t$HtH‹D$@ƒ Èý3ÀH‹\$`H‹t$hHƒÄP_ÃH‹T$89ru‹×H‹Ëè€@8t$HtÕH‹L$@ƒ¡ÈýëǶf;Ît3¶ÁöDtHÿÃ@83t˜¶·ÉÁáÈ;ùu
HCÿë¼·Á;øtHÿÃëÅ·Á;ø…lÿÿÿ@8t$HtH‹D$@ƒ ÈýH‹ÃéfÿÿÿÌÌE3Àéÿÿÿë:Ât
HÿÁŠ„Àuó:ÂuH‹ÁÃ3ÀÃÿ%03ÿ%‚3ÿ%„3Hƒì8H…Éu&è‚ÿÿHƒd$ E3ÉE3À3Ò3ÉÇè+ÿÿHƒÈÿë€9tÕH…ÒtÐH‹H…ÀtÈ€8tÃE3Àè‚HƒÄ8ÃÌH‰T$‰L$SUVWATAUAVAWHƒìXA¼þÿÿÿHcÁA‹ØD‰d$4‰\$8A;Äuè¸ÿÿ3ÿ‰8èÿÿÇ	é3ÿ;ÇŒï;t…ƒãH‹ðL‹ðL
ùAÿÿIÁþƒæK‹Œñ€CHköXŠD1¨„·ûÿÿÿvèUÿÿ‰8è.ÿÿÇ骋ï;ß„Š¨…‚H;×tÒDŠ|18A¸EÿAÐÿA¾Ïƒétƒéu‹Ã÷Шt«ƒãþL‹êëd‹Ã÷Шt›ÑëA;ØABØ‹ËèMÿÿL‹èH;Çu踀ÿÿÇèÍ€ÿÿÇé=‹Œ$ 3ÒDBè°ÖÿÿL
!AÿÿL‹ØK‹„ñ€CL‰\0@K‹„ñ€CI‹ÕA¸
öD0H„œŠL0	A:È„;ß„‡AˆMK‹„ñ€CAƒÊÿAÚIUAh÷DˆD0	D:ÿtbK‹„ñ€CŠL09A:ÈtQ;ßtMˆ
K‹„ñ€CAÚHÿÂAhøDˆD09A€ÿu.K‹„ñ€CŠL0:A:Èt;ßtˆ
K‹„ñ€CHÿÂAhùAÚDˆD0:K‹Œñ€CLL$0D‹ÃH‹1H‰|$ ÿ¢2;Ç„ÏHcT$0;׌‹ÃH;Ї·L@ÿÿêK‹„ð€CöD0€„yA€ÿ„¸;×tA€}
u€L0ë€d0ûHcÅI‹ÝM‹åIÅH‰D$@L;èƒ:½
AŠ$<„
@:Åt
ˆHÿÃIÿÄéëH‹D$@HÿÈL;àsID$€8
u	IƒÄéL‹àé½K‹Œð€CLL$0H”$°H‹1A¸IÿÄH‰|$ ÿ³1;Çu
ÿ0;Çu{9|$0tuL0?ÿÿK‹„ð€CöD0Ht"€¼$°
t'@ˆ+K‹Œð€CŠ„$°ˆD1	ëGI;Ýu€¼$°
uÆ
ë3‹Œ$ A¸HƒÊÿè]Ôÿÿ€¼$°
LÆ>ÿÿtëL»>ÿÿ@ˆ+HÿÃL;d$@‚ìþÿÿëK‹„ð€CöD0@u€L0ë	AŠ$ˆHÿËëA+íA€ÿ…ð;ï„èA¿I+ßö€uIßé²A‹×ëƒúI;ÝrI+ßA׶B8¼4tã¶B¾„4;Çuè}ÿÿÇ*AƒÌÿé‘ÿÀ;ÂuHcÂHØë^K‹„ð€CöD0Ht;I߃úˆL0	|ŠK‹Œð€CI߈D19ƒúuŠK‹Œð€CI߈D1:HcÂH+Øë‹Œ$ ÷ÚE‹ÇHcÒè2Óÿÿ‹D$8L‹¼$¨A+ÝÑèD‹ËM‹Å‰D$(3Ò¹éýL‰|$ ÿe/‹è;ÇuÿI.‹Èè}ÿÿAƒÌÿéäD‹d$4;ÃHS=ÿÿJ‹„ð€C@•Çí‰|0Hé¿;׺
tfA9Uu€L0ë€d0ûHcÅI‹ÝM‹åN<(M;ïƒ{½
A·$fƒø„Ef;Åtf‰HƒÃIƒÄé%IGþL;àsID$f9u	IƒÄéÂL‹àéúK‹Œð€CLL$0H”$¸H‹1A¸IƒÄH‰|$ ÿ÷.;Çuÿ]-;Ç…®9|$0„¤Ll<ÿÿK‹„ð€CöD0HtFº
f9”$¸tKf‰+Š„$¸K‹Œð€CˆD1	Š„$¹K‹Œð€CˆD19K‹„ð€CˆT0:ëWI;Ýuº
f9”$¸uf‰ë>‹Œ$ HÇÂþÿÿÿDBèoÑÿÿº
LÛ;ÿÿf9”$¸tëº
LÃ;ÿÿf‰+HƒÃM;ç‚®þÿÿë"K‹„ð€CöD0@u€L0ëA·$f‰HƒÃ‹ëA+íD‹d$4L‹¼$¨M;ïtI‹Íè`}ÿÿAƒüþDDåA‹Äëiÿ5,ƒøuè»zÿÿÇ	èÐzÿÿÇéýÿÿƒømuD‹ç뮋ÈèÔzÿÿéýÿÿ3Àë)è¦zÿÿ‰8èzÿÿÇ	E3ÉE3À3Ò3ÉH‰|$ è•yÿÿƒÈÿHƒÄXA_A^A]A\_^][ÃÌH‰\$H‰t$‰L$WATAUAVAWHƒì0A‹ðL‹êHcùƒÿþuèBzÿÿ3Û‰èzÿÿÇ	ƒÈÿé3Û;ûŒâ;=û}ƒÖL‹çL‹÷IÁþL=ü}AƒäMkäXK‹÷B¾L ƒáu.èèyÿÿ‰èÁyÿÿÇ	H‰\$ E3ÉE3À3Ò3Éè×xÿÿƒÈÿé©‹ÃAøÿÿÿ–À;Ãu+èªyÿÿ‰èƒyÿÿÇH‰\$ E3ÉE3À3Ò3Éè™xÿÿƒÈÿën‹ÏèÞÿÿK‹÷BöD tD‹ÆI‹Õ‹Ïès÷ÿÿ‹Øëè:yÿÿÇ	èOyÿÿ‰ƒËÿ‹ÏèƒÞÿÿ‹Ãë)è:yÿÿ‰èyÿÿÇ	H‰\$ E3ÉE3À3Ò3Éè)xÿÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌH‹ÄH‰XL‰@H‰HUVWATAUAVAWHì€3ÿA´€A‹ñH‹ÚÇ@¨o‰xœ@ˆ¼$ØH‰x°E„Ìt‰x¸A¶ë‰l$pDŠ÷HL$Tè©;ÇtE3ÉE3À3Ò3ÉH‰|$ èivÿÿºær÷Æ@u
|$T€tE
ô‹ÎA¸¸ÀA#Ⱥ€;ÏtT+Ít:;Ít1è@xÿÿ‰8ƒÿèxÿÿ»E3ÉE3À3Ò3ÉH‰|$ ‰è+wÿÿ‹ÃéûD‹øë@öÆt÷ÆuíA¿@ëD‹ú‹Œ$àA¼ƒét,ƒét#ƒétƒétƒù@u‹D;ú‹Ï”ÁëA‹ÈëA‹Ìë‹Íë‹Ï‹Æº‰L$H#ÂtF=t8=t*=t=t*=t&=t;Âté/ÿÿÿA‹ìë½ë
½ëA‹èºæA½€D‰l$PsŠmöÐ"„$言AEDDèD‰l$P@öÆ@tAºíAºïƒÉD‰l$P‰L$Hºæs
AºíD‰l$P@öÆ tAºíë@öÆt
AºíD‰l$PèIÜÿÿ‰ƒøÿu!èÕvÿÿ‰8ƒÿè«vÿÿÇè vÿÿ‹é H‹„$ÀD‹D$HH‹Œ$ÐH‰|$0LL$`A‹×D‰l$(ljl$ ÿB)H‰D$XHƒøÿ…Œ¹ÀA‹Ç#Á;ÁuC¸@„ðt9D‹D$HH‹Œ$ÐH‰|$0Aº÷LL$`D‰l$(A‹×‰l$ ÿí(H‰D$XHƒøÿu;HcL-zH‹ÁƒáHÁøHkÉXI‹DÅ€dþÿJ'‹ÈèvÿÿèÎuÿÿ‹8éÌH‹ÈÿÖ&;ÇuMHcL-ÈyH‹ÁƒáHÁøHkÉXI‹DÅ€dþÿ'‹È‹ØèÉuÿÿH‹L$Xÿ6(;ßu§èuuÿÿÇ
ëšA;ÄuA€Î@ë	ƒøuA€ÎH‹T$X‹è%ØÿÿHcL-[yH‹ÁƒáºHÁøD
òI‹DÅHkÉXDˆtHcH‹ÁƒáHÁøHkÉXI‹DÅ€d8€AŠÆ$HˆD$L…†E„ö‰ÂA„ôtx‹E‹ÄƒÊÿè¦	‰D$Dƒøÿuèðtÿÿ8ƒtP‹èõÒÿÿééþÿÿ‹HT$@A¸@ˆ|$@èÕòÿÿ;Çu€|$@uHcT$D‹è¾ƒøÿtÁ‹E3À3ÒèE	ƒøÿt°ºE„ö‰<¹@…ñu‹D$T#Áuºîëð‹Æ#Á=@tJ=t,=@t%=t+=@t$=t=@u(ˆ”$Ø빋Æ#Á;ÁuDˆ¤$Øë@ˆ¼$Ø÷Æ„º‰|$DAöÆ@…¬A‹Ç%À=@„$=€t|=À…‡;ï†A;ìvƒýv8ƒý…l¾Œ$ØA¸‹ïA+È„ A;È…PÇD$Dÿþé‹E‹Ä3ÒèÉÿÿH;ÇtÀ‹E3À3ÒènÉÿÿHƒøÿ„|þÿÿ‹HT$DA¸èbñÿÿƒøÿ„aþÿÿA;Ät ƒøuk|$DuD@þDˆ„$ØéÜ·D$D=þÿu‹è%Ñÿÿèìrÿÿ»‰‹ûéã=ÿþu#‹E3ÀA‹Ôè’ƒøÿ„ùýÿÿDˆ¤$Ø醋E3À3Òèpƒøÿë;;ïvqA;ì†üþÿÿƒý‡êþÿÿ‹E‹Ä3Òè¡ÈÿÿH;Ç„Þþÿÿ‹E3À3ÒèŒÈÿÿHƒøÿu8é™ýÿÿÇD$DA¼‹HcÅE‹ÄHTDD+ÅèN°ÿÿƒøÿ„mýÿÿèD;åÛA¸Hc@Š¬$ØH‹Áƒá@€åHÁøHkÉXI‹DÅ€d8€@l8HcH‹ÂƒâHÁøHkÒXI‹LÅ‹Æ€d8ÁèÀàD8@8|$Lu!@öÆtHcH‹ÁƒáHÁøHkÉXI‹DÅ€L A‹Ç%À=À…ŸA„ð„–H‹L$Xÿ>$‹D$PD‹D$HH‹Œ$ÐH‰|$0‰D$(Aº÷LL$`ÇD$ A‹×ÿ1$Hƒøÿu6ÿµ"‹Èè~qÿÿLcI‹ÃAƒãHÁøMkÛXI‹DÅB€dþ‹è¢ÔÿÿéBûÿÿHcH‹ÊƒâHÁùHkÒXI‹LÍH‰
‹ÇH‹œ$ÈHÄ€A_A^A]A\_^]ÃÌÌH‹Ä‰PL‰@L‰H VWHƒìXƒHØÿƒ`ÜE3ÀH…ÉA•ÀE…Àu(è¬pÿÿÇHƒd$ E3ÉE3À3Ò3ÉèÁoÿÿƒÈÿé“H„$€HƒÀD‹@øƒd$0D‰D$(ÇD$ @D‹ÊL‹ÁHT$@HL$Dèv÷ÿÿ‹ð‰D$Hƒ|$Dt9…Àt(Hc|$@H‹ÏH‹ÇHÁøLCtƒáHkÉXI‹À€dþë‹|$@‹ÏènÕÿÿë‹|$@…ötèÿoÿÿ‰0ƒÈÿë‹ÇHƒÄX_^ÃÌÌÌ@SHƒì0M‹ÐH‹ÂH‹ÙH…Éu&èÓoÿÿHƒd$ E3ÉE3À3Ò3ÉÇèènÿÿHƒÈÿëUH…ÀtÕH‰L$ LL$XLD$@I‹ÒH‹ÈèσøÿtÖL‹L$XL‹D$@H‹Ó¹èçH‹L$@H‹ØèòqÿÿH‹L$XèèqÿÿH‹ÃHƒÄ0[ÃÌÌÌH‰\$L‰D$UVWATAUAVAWHƒì0E3öM‹àL‹êH‹éH‹ñI;Îu(è"oÿÿE3ÉE3À3Ò3ÉL‰t$ Çè8nÿÿHƒÈÿéD81tÓI;ÖtÎH‹I;ÆtÆD80tÁº\èvº/H‹ÍH‹øèfA¿I;Æ…œI;þ… AW9H‹ÍèRìÿÿH‹øI;Æ…ˆH‹Íè.ŸÿÿI‹×HXH‹Ëè{oÿÿH‹ðI;Æ„sÿÿÿLL5H‹ÓH‹ÈèuÂÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èXlÿÿL‹ÅH‹ÓH‹ÎèêÀÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ è1lÿÿH~ë
I;þtH;ÇvH‹øHƒËÿH‹ÏS/èŸ
H‹ÎI;Æt&3ÒèA;Æ…÷M‹ÄI‹ÕH‹ÎèõýÿÿH‹ØéáèlžÿÿI‹×L`I‹Ìè¹nÿÿH‹øI;Æ„ÎL‹ÆI‹ÔH‹Èè·ÁÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èškÿÿH‹Îè"žÿÿL4èmÿÿM+æD‹8IZxŒ ºÎÞêö*:JXfp€–¢®¾æ2Hbx† °Æàîþ$4JZl~¢®¼Ìâò"4\hxŠh@?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=runtime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: ÀÀ–ÀÀŽÀÀÀ‘À’À“À€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwpp         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLLSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecCONOUT$.com.exe.bat.cmd.\SystemRoottd
T	42àÐÀ
4
Œp¨P

4
p
d
T	42ÐÀp!ðÚ<!Ú®(!ÔHÄIÚ®(!ÔHÄIdJÚ®(!TRðÚ< Kðàp0¨0bÀp`0Œ+|I`á
4RðàÐÀ
p`Pr0²02042p
d4rðàÐÀpŒ+ã'ì(xá	

4	
RpŒ+·*S+šáS+B  d T 4 rðàÐÀpt42À		20dT42p)4dZðàÐ
Àp`P¨È	 
 Ä t d 4 ðàÐŒ+`:l:=		¼0
t	dT42À

20d	4RÀŒ+KBÃB¶á
Ätd
RðàÐŒ+DMDÏáÎCjDÿátd42ÀdT42ptd42ÐŒ+OFFâ

4
Rpd
T	4Rpd4
rp$d´4³°p¨p

4
2pŒ+¾MN4â4rÐ
Àp`P¨8
Ät
d	4RÐŒ+-RçR4â20Œ+·VÍVMâ

4
2pŒ+ŠW•WfâªWÑW†â42pŒ+.Y\YfâqY¨Y†âdT²pd	T42pÔt
4Rà
t
d	42àÐÀŒ+º_{`Ÿâ2P	BŒ+çabÀâb	BŒ+9b=b=b
d4rðàÐ
ÀpŒ+àesfáâ	bŒ+ôfgýâgtd
T	42àÐÀd4
Rp
t
dT4
rÀB

4
2p›b4²p
`Pd	4Rp4	RpŒ+÷uvã/4qfðàÐ
Àp`P¨ 
d4
RðàÐÀpŒ+,~]~Nã4R
Àp
`Œ+?ƒ7ã

4
’p
dT4’ÐÀp-
Etd4C²
ðàÐÀP¨Xd4Òp1
5#td43rðà
ÐÀP¨8d4²p2
0R0
d4
RðàÐÀpŒ+Ö–	—Nã
T4ràÐÀp`µtdT4’àÐÀ

4
2pd
4RÐÀpŒ+Ÿ(Ÿ7ã¨PT42p
Ä	td42ÐŒ+k¤‹¤eã
Ät
4rðàÐŒ+¥³¥~ã4¥å¦žãb¨('EC
ðà	ÐÀp`0P¨p‚RPt
d	4RÀŒ+ñ¬Ù­·ã

T
ÒpdT4²pT4rp$
53Â
ðà	ÐÀp`0P¨X
4RðàÐÀp`
P	¢ðàÐÀ
p`P
0
d4
RðàÐÀpŒ+Æ>ÆNã!
!4!òðàÐÀp`PrP¢p`Œ+ïÎÏÐãtd
T	42ðÐÀd42p4	ðàÐÀ
pP0#

ðà	ÐÀp`P0¨xd
4’pdT
4’pNð¨ÄÚð0H`t|Žœ®¼ÎÞìþ*>ZxŒ ºÎÞêö*:JXfp€–¢®¾æ2Hbx† °Æàîþ$4JZl~¢®¼Ìâò"4\hxŠSGenerateConsoleCtrlEventÇGetExitCodeProcessrWaitForSingleObject–CreateProcessA´SetConsoleCtrlHandlerõGetModuleFileNameAÛEnterCriticalSectionîLeaveCriticalSectionúGetModuleHandleW/Sleep"GetProcAddressExitProcessqGetCommandLineAžRtlUnwindExôSetHandleCount>GetStdHandleÙGetFileType<GetStartupInfoAÀDeleteCriticalSection;TerminateProcess«GetCurrentProcessLUnhandledExceptionFilter#SetUnhandledExceptionFilterÐIsDebuggerPresentŸRtlVirtualUnwind˜RtlLookupFunctionEntry‘RtlCaptureContextçGetLastError¦HeapFree¢HeapAlloc]GetCPInfoTGetACPGetOEMCPÚIsValidCodePage×EncodePointer¹DecodePointer@FlsGetValueAFlsSetValue?FlsFreeøSetLastError¯GetCurrentThreadId>FlsAlloc›WriteFileðLoadLibraryAºInitializeCriticalSectionAndSpinCountLFreeEnvironmentStringsAÁGetEnvironmentStringsMFreeEnvironmentStringsWˆWideCharToMultiByteÃGetEnvironmentStringsWªHeapSetInformation¤HeapCreateSQueryPerformanceCounterjGetTickCount¬GetCurrentProcessIdSGetSystemTimeAsFileTime©HeapReAlloc…GetConsoleCP—GetConsoleModeCFlushFileBuffersàLCMapStringAMultiByteToWideCharâLCMapStringW@GetStringTypeACGetStringTypeWéGetLocaleInfoAìSetFilePointer«HeapSizeDCloseHandleWriteConsoleA›GetConsoleOutputCPšWriteConsoleW
SetStdHandlezCreateFileASCompareStringAVCompareStringWÝSetEnvironmentVariableAKERNEL32.dllhReadFileÚSetEndOfFile&GetProcessHeapËGetFileAttributesAàE@àE@2¢ß-™+Í] ÒfÔÿÿL)@ô@ðó@ÿÿÿÿÿÿÿÿ€

		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ(@¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þôþ@þÿÿÿC@-@@-@@-@@-@@-@P2@ðü@€@@Ð0@P-@P-@(@ÿÿÿÿXú@(ú@	øù@
`ù@(ù@øø@Ðø@ ø@hø@@ø@ø@Ð÷@¨÷@ˆ÷@ ÷@ èö@!ðõ@"Põ@x@õ@y0õ@z õ@üõ@ÿõ@8š@8š@8š@8š@8š@8š@8š@8š@8š@8š@ 
ðü@òþ@P@L@H@D@@@<@8@0@(@ @@@ô@è@ä@à@Ü@Ø@Ô@Ð@Ì@È@Ä@À@¼@¸@°@ @”@Œ@Ô@„@|@t@h@`@P@@@8@4@(@@@	Ð0@.@2@lB@lB@lB@lB@lB@lB@lB@lB@lB@P2@.€pðñÿÿPSTPDTà2@ 3@ÿÿÿÿÿÿÿÿþÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Ml8@0@(@ @çxðY”`«x°Ôà¬í¼ðÚ<Ú®(®eeµôµ½ä½ÛÔè]ThJ¤LstÓ¤Ô¤Z\ƒ„ŤD§¤¨ÅÈïPð•"|˜"&#È`#	$¤$Š$”Œ$%%œø%%&¤(&a&¤d&z&¤”&Ç&¬È&'('³'(´'>)¸x)ß)¤à)w+èx+Š+Œ+--0-.0.9.@<.ƒ.¤„.Õ.HØ.V/`	X/=:\@:-=€0=f=Pp=•>¸˜>?¬	h?ˆ?ˆ?¨?¨?î?¤ð?\@`	\@ß@Äà@eAÄhAðA¼ðA-BÜ0BàBäàBYCx\C£C¤¤C˜D	¤D.EL	0E³E`	ÌE´Ft	´FøF(øF§G 	¨GþH¬	I{IÀ	¨I¼IP¼IKÐ	KšK`	œKMØ	€MÔêª N N N N_€ñ¬Tfžˆ	ib8		‹Ö*
$!)&&&&&&&&&&&&&&&&@qŸ@!¿
@!
À_Ö@qŸ@!¿
@ 
À_Ö@qŸ@!¿
A9À_Ö@qŸ@! 
À_Ö@qŸ@!
À_Ö@qŸ@ 
À_Ö@qŸA9À_Ö@qÀ_ÖH@Ñ
‹qL@qLÀ_ÖÀ€R_ëêTIüE“)ñ@¡ŸLÌÿÿTB@’‚øÿµÀ_ÖH
@ò TAÑèËBË@qˆLIüF“ Õ Õ Õ Õ Õ)ñ@!ŸLÌÿÿTB@’Bûÿ´_€ñ+õÿT@¡ŸLB€ñÁôÿTÀ_ÖÿƒÑ¤€Òc2£òã©á©ÿƒ‘À_ÖÀ_ÖóSº©õ[©÷c©ùk©ûs©ý{©ýC‘sP@©uXA©w`B©yhC©{pD©a(@ù@?Öý{E©ûsD©ùkC©÷cB©õ[A©óSƨÀ_ÖóSº©õ[©÷c©ùk©ûs©ý{©ýC‘sP@©uXA©w`B©yhC©{pD©a(@ù@?Öý{E©ûsD©ùkC©÷cB©õ[A©óSƨÀ_ÖËëÃ
Tô!€ù_ ñãª"Tb6  ÿ
` ¿
b6 ÿ
`¿
b6"@9b9À_ÖB€ñTB€ñcT! €ùBñÃT?@òaT@ò`T  ßL$ ßL!@€ù!`€ù` ŸLd ŸLBñ"ÿÿTb06 @­"A­$B­&C­!‘!@€ù!`€ù`­b­d­f­c‘BñbþÿTb06  ßL` ŸLb(6  ßL` ŸLb 6 pßL`pŸLb6 pß`pŸb6  ÿ
` ¿
b6 ÿ
`¿
b6"@9b9À_Ö!‹!ðŸø_ ñ‹‚T¢6!ÑcÑ  `
`  
¢6!ÑcÑ `
` 
b6"ü_8bü8À_ÖB€ñãTB€ñT!ð›øBñT?@òaT@òÀT!Ñ  @L!Ñ$ @L!ð—ø!ð“øcÑ` LcÑd LBñ¢þÿT!Ñ&C­$B­cÑ"A­ @­!ð—ø!ð“øf­d­b­`­BñbþÿT¢06!ÑcÑ  @L` L¢(6!€Ñc€Ñ  @L` L¢ 6!@Ñc@Ñ p@L`pL¢6! Ñc Ñ p@`p¢6!ÑcÑ  `
`  
¢6!ÑcÑ `
` 
b6"ü_8bü8À_ÖÿÃÑý{©óS©õ[©÷c©ùk©ûs©!@ùáùóªôªõªöªâªÿÿ—àªáªâªãªSP@©UXA©W`B©YhC©[pD©](@ù?Öóªÿÿ—àªá@ùB€Òõþÿ—àªûsF©ùkE©÷cD©õ[C©óSB©ý{A©ÿÑÀ_Ö@xb4åª@7¡@ò`T¢,@’_À?ñÌT t@L¨qn"&"4¥@‘¥ì|’ Õ tßL¨qn"&¢ÿÿ5¥@ÑÁœ˜`N!N¨pn&BR Ë@€‹À_Ö!@ÑáË¢$@xÂ4!ñ¬ÿÿTìÿÿ¢$@xâÿÿ5¥Ñ ËüA“À_Öåª`7? ñ#T£@òÀT¢,@’_À?ñŒTc@ÑãË t@L¨qn"&ûÿ4!ƒË¥‹? ñCT#üC“ tßL¨qn"&Âùÿ4cñaÿÿT!@òÀT! Ñá˥ˠtßL¨qn"&bøÿ4¡´¢$@xBúÿ4!ñ¨ÿÿT ËüA“À_Öc@ÑãƒË¢$@x"ùÿ4!ñùÿTcñlÿÿTÝÿÿ€ÒÀ_Ö@8‚4媡@ò@T¢,@ò_À?ñT p@L¨1n"&4¥@‘¥ì|’ pßL¨1n"&¢ÿÿ5¥@Ñaœ˜ N!N¨0n&BR¥‹ ËÀ_֥ѠËÀ_Ö!@ÑáË¢@8Bÿÿ4!ñ¬ÿÿTéÿÿ

	åª?@ñ#T£@òÀT¢,@ò_À?ñlTc@ÑãË p@L¨1n"&‚ûÿ4!Ë¥‹?@ñCT#üD“ pßL¨1n"&Búÿ4cñaÿÿT!@òÀT!@Ñá˥ˠpßL¨1n"&âøÿ4¡´¢@8¢ùÿ4!ñ¨ÿÿT ËÀ_Öc@ÑãË¢@8¢øÿ4!ñ€øÿTcñlÿÿTÞÿÿ€ÒÀ_ÖQ
@ùðs/ëð3šëCTÀ_ÖÎt’1@Ñ?@ù?ë¡ÿÿTÀ_Ö_@ñlTChhb8cË`Ö(Á¨($Á¨ëTJ
ÀÚ)
ÀÚ@	ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸ëàTcÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸ëàTcÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xëàTcÀÚÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸ëàTcÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xcÀÚÀÚ`ëàŸ$€ZÀ_Ö€ÒÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸cÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö„@ø(„@øcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xcÀÚÀÚ`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xëàTcÀÚÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö_€ñ+TB€Ñ(Á¨($Á¨ë!T_	ë!T(Á¨($Á¨ëaT_	ëaTB€ñjþÿTB€‘_@ñmåÿTB Ñ„@ø(„@øëáTB ñlÿÿT ôÿTB ‘chhb8cË`ÖJ
ÀÚ)
ÀÚ@	ëàŸ$€ZÀ_ÖcÀÚ
ÀÚ`ëàŸ$€ZÀ_ֈδ|Øš¾tl\J†â¤Èì°(‘À_Öþø5J¹ 4¨ð@ù€R?Ö €RþAøÀ_ÖóS»©õ{©â©ä©æ©ôªóªõƒ‘èÿÿ—@ù€Òâªáªäª0”õ{A©óSŨÀ_Ö€R“óS¼©õ[©÷c©ù{©óªhÀ9éªøªh4(À8èÿÿ5 Ë€Ò1”¹öªùª3ù`À9€R€Rÿ”€4`À8ü”Àÿÿ5uÀ8•4à*÷”@44¿rqaT”÷ÿÿ¿ŠqTˆraTÿq÷ŸqµŸ”~ô4â*€RàªYüÿ—ÖB4‹€RÕüÿ4Õ8äÿÿô4â*€RàªOüÿ—ÖB4‹€Rß8	@¹()}@“¹*‘6{*ø54`À9Í”€4`À8Ê”Àÿÿ5hÀ9¨ùÿ5àªù{C©÷cB©õ[A©óSĨÀ_ÖóS¼©õ[©÷c©ù{©õª¨À9éªh4(À8èÿÿ56ËÈzS	}@“ 
‘!€ÒÛ”Y€R÷ªù9ó‘€RßqíT˜€R¨À9qqaT”‰qaTŸqíTâ*€Ràªüÿ—sB4‹€Rx8€R¨À8ÖQh8výÿ5ŸqÍTâ*€Ràªüÿ—sB4‹y9àª9ù{C©÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û{©Ãûÿ—ÿƒѨÐ
@ù÷*úªû* €Rác‘€Ò?ÖècÂ9éc‘h4(À8èÿÿ5èc‘?ë)Têc‘(À9¹q T?9)Ñ?
ëHÿÿT¨Ð

‘?9ècÂ9éc‘h4(À8èÿÿ5¨€R(9+
ËHÀ8Hi+8Èÿÿ5€Ràc‘”ô*Ÿ1!T@€R”¨ÐÁ
‘âc‘!ÿÿ—@€R €Òác
‘à*û”èc
‘Á ‹à*“ ”èc
‘	Ñ)‘?ëÂT(À9qJzMz!ÿÿT¨Ð‘?9B€Òàc
‘Ù”@4¨Ð
!‘H@ùëc
‘I	@¹hùH1À9i	¹h19áS‘àk
‘ÿÿ—õª³@ùiÀ9èª	4Š€R‘?½qAT
ñ8	À9iÿÿ5äc‘ãc‘âc‘áC‘àªb”èCÀ9¨5ècÆ9qq@Täc‘ãc‘âc‘áC‘àc‘W”ècÆ9êc‘h4HÀ8èÿÿ5IÑ(À9qq¡THáß8I	ÑqqTêc‘?
ë£T?9(ýß8qqaÿÿT€Òãªâc‘áC‘àc‘”óc‘!€Ò€ €Ò”‚ €ÒáªöªÍ”Vµ@€R³@ù±”¨Ða‘⪳þÿ—@€R§ó@¹€Òø@“‘ý”ùªàªÿÿ—4#‘ ùq
Tµ"‘sQ †@øÿÿ—sQ€†ø“ÿÿ5àc‘ÿÿ—ÿq€†ø
TU#‘óQ †@øüþÿ—sQ€†ø“ÿÿ5Ÿù›4áªàªL”@€R„”¨Ð‘⪆þÿ—@€RzÈÀ9éªh4(À8èÿÿ5(Ë
	qÍT,#‘QŠ…@øHÀ9é
ªh4(À8èÿÿ5(
Ë	
-kQËþÿ5!€Ò }@“½”¨Ða
‘âª÷ªd”ÈÀ9éªh4(À8èÿÿ53ËqmT4#‘Q¶Ð‚†@øàÂ3‹Ár
‘U”Š‚_øHÀ9é
ªh4(À8èÿÿ5(
Ë	3µQUþÿ5éÓ‘ÿ¹?}©èc‘?}©!€R?}©?}©}©?}©	ù
€R?}©?a¹éÿÿð a8‘è3¹¨Ð@ù?Öèc‘èù¨Ð	@ùéÑ€Ò€Òéù€R$€R€Ò€Ò᪀Ò?Ö5@€R ”¨ÐA‘#þÿ—€Rè+@¹éð(
¹¨Ð@ùà@ù€?Ö¨Ð@ùà@ùáC‘?Ö5@€R”¨ÐÁ‘þÿ—€Rà@¹ÿƒ‘úÿ—û{D©ùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ{©â©ä©æ©ôªóªõƒ‘êýÿ—@ùåªãª€’áª@²€ÒN”€q±€õ{A©óSŨÀ_Öý{¿©ý‘h@ù	@¹+u(Èkøj}@“IË*‹@!Ñjúÿ— €Rý{Á¨À_Öóøý{¿©ý‘ €R¾”¯”Z”©”ó*
”¹ €RÒ”S¨4”¡?‘Z”Ÿ”’”À5 ”¹”€4a6‘Ñ” ”Ÿ”’”»”’”SH4”Œ”»” 5€Rý{Á¨óAøÀ_Öà€R²”ý{¿©ý‘’”€Rý{Á¨À_Öý{¿©ý‘Ì”y”Ê”ý{Á¨À_ÖóS¾©õùý{¾©ý‘ €R…”S(4€R¿C9d”Sôðˆ
J¹q`
Th5(€Rˆ

¹©Ð!!‘¨Ða
‘ñ”`4à€RB¨ÐA
‘©Ð 
‘Í”H€Rˆ

¹5€RµC9à*Ø”s”óªh@ù¨´Ÿ”SH4s@ù直Ð=Aù?Ö€ÒA€R€Ò`?Ög”óªh@ùÈ´”Sh4`@ùÔ’”ôª”@ù”@¹âªáªjýÿ—ó*\”S4U5¬”€R €R»”à*	ó*Q”Sè4¨C@9H5œ”à*ý{¨õ@ùóS¨À_Öà€RA”à€R?”à*«”à*—”ý{¿©ý‘Δ•ÿÿ—ý{Á¨À_Öý{¿©ý‘Ä”`4èªìðŠA(‘@ùHý_ÈhµKý	È©ÿÿ5ë`TŠA(‘Hý_ÈhµKý	È©ÿÿ5¿;Õÿÿµ€Rý{Á¨À_Ö €Rýÿÿý{¿©ý‘êðH1h9q)€R)ˆI1(9â”Q”Sh5€R”Sˆ5€RX”ùÿÿ €Rý{Á¨À_ÖóS¿©ý{¿©ý‘ôðˆ"i9ó*h5q¨T‰”€4s5èða(‘(” 5èðÁ(‘$”€4€R
èða(‘éð)Á(‘
€’
)©*)©
	ù*	ù(€Rˆ")9 €Rý{Á¨óSÁ¨À_Ö €RÚ”ý{¾©ý‘ªI‹RèÿÿÐ	‘(@y
kT,=@¹*Á,‹ªˆRH@¹kATH1@y-qáT	Ë)Á,‹()@y	‹
a‘)
@y€Ò,)›ªù_ë@TI
@¹A)ë£TH	@¹		A)ëƒTJ¡‘õÿÿ
€Òjµ€R
H%@¹hø6€R €R€R€Rý{¨À_Öóøý{¿©ý‘S2”À4³5èðA(‘ýŸÈ¿;Õý{Á¨óAøÀ_Öóøý{¿©ý‘èð1h9S)SH4©5à*N”à*Ü” €Rý{Á¨óAøÀ_Öóøý{¿©ý‘éð(
Eùóª±aTž”᪠a(‘¼”q`Ÿšý{Á¨óAøÀ_Öý{¿©ý‘ìÿÿ—ñàŸZý{Á¨À_ÖóS¿©ý{½©ý‘ôðˆ@ùsXëAT¨Ð!‘ÿù	ýßÈàc‘ ?Öè@ù©Ð)‘èù(ýßÈ?Öè@ù	|@Ó)ʨÐá‘éù	ýßÈ ?Öè@ù	|@Óàƒ‘)ʨÐÁ‘éù	ýßÈ ?Öé#@¹ëC‘è@ù
	Êé@ùH	ÊÊ	½@’?ëˆX‰šˆùé(ªèð	ùý{èóSÁ¨À_Ö Õ2¢ß-™+3¢ß-™+€RÀ_Ö €RÀ_ÖˆRÀ_ÖèðA)‘©Ð(A‘	ýßÈ ÖÀ_Öèð)‘À_Öý{¿©ý‘üÿ—‰€Ò@ù	ªùõÿÿ—@ù	²	ùý{Á¨À_Öèð@¹qàŸÀ_Öá(‘À_ÖÁ(‘À_Ö`>ÔÀ_ÖÐÿÿý{¿©ý‘¨Ð¡‘	ýßÈ€Ò ?Ö ´@y©I‹R	k!T<@¹ªˆR
À(‹I@¹?kaTH1@y-qTH…@¹9q©THù@¹h4 €R€Rý{Á¨À_Öá;‘©Ð(a‘	ýßÈ ÖóS¿©ý{¿©ý‘ôª“@ù)h@¹	kTh@¹q!Ti"@¹H(K	q	Tè?k T€Rý{Á¨óSÁ¨À_ÖJ”ù“@ùM”ù”csmà “@™óS¾©õ[©ý{¿©ý‘è°‘é°5!‘!‘!‘ëBT¶Ðt†@ø´´È>Aùïª?Ö€?Öë#ÿÿTý{Á¨õ[A©óS¨À_ÖóS¾©õ[©ý{¿©ý‘è°A‘é5a‘!‘!‘ëBT¶°t†@ø´´È>Aùïª?Ö€?Öë#ÿÿTý{Á¨õ[A©óS¨À_ÖÿCÑàù@€R`>ÔÿC‘À_Öý{¿©ý‘€R”ý{Á¨À_ÖÿCÑà¹à@¹`>ÔÿC‘À_Öèð)J¹qàŸÀ_ÖóS»©õ[©÷c©ùk©û#ùý{½©ý‘÷ªèf@©ëªõ@ùøªëù
˨@¹hø6	y@’5‹é2A9HÑôJ@¹?qZˆš@¹É€R	jÁTø‹©¨@¹ŸkBT¨°á‘³°¶R4‹È@¹_C(ëƒTÈ
@¹_C(ë"TÈ@¹è4È@¹q Tã*@ù"C(‹áªàc‘>øÿ—`ø7qmT@¹)	kÁThöAùˆ´`¢‘ÃP” 4söAù¨°=Aùïª?Ö!€Ràª`?ÖÈ@¹"€Ró@ù C(‹áªøÿ—È@¹âª@¹àªå"@ùä@ù!C(‹hÿßÈ?Öøÿ—³°ë@ù¨@¹”Ÿk‚TÅÿÿ€RBè@ù¬@¹ËŸk‚Tê*®R4‹é
*È@¹_C(ë#TÈ	@¹_C(ëÂT@¹r`T€Rª4¯R4‹§R4‹­R+‹¨@¹B(ëƒT¨	@¹B(ë"Té@¹¨@¹	k¡Té@¹¨
@¹	k€Tk
kãýÿTé*káTë@ùÈ@¹¨4B(ëÄ@z!Tˆã*@ùèJ¹É
@¹áª €R"C)‹í÷ÿ—¬@¹é*”ë@ùŸ	kê	*ãøÿT €Rý{èû#@ùùkC©÷cB©õ[A©óSŨÀ_Öcsmàý{¿©ý‘Ú”Sh5€R¥”Sh5è”úÿÿ €Rý{Á¨À_Öý{¿©ý‘Sh5¶”Ý” €Rý{Á¨À_ÖóS¿©ý{½©ý‘¡C9€´é@¹	kT@¹q¡T @¹		K	qT@ùÈ´	@¹é4@ùÁ)‹@ù”@¹ˆ 6	@ù4@ù4´ˆ@ù	@ù直°=Aù?Öàª`?Öý{èóSÁ¨À_Ö Õcsmà “ Öý{¿©ý‘”€‘ý{Á¨À_Öý{¿©ý‘” ‘ý{Á¨À_ÖÀ´èÐÁ:‘ë@TEÀ_Öý{¿©ý‘”`´ý{Á¨À_Öb”óS¾©õ[©ý{¿©ý‘öÐÈ@¹1aT€Ò8¨°‘	ýßÈ ?Ö¨°a‘ô*À@¹	ýßÈ ?Öõª¿± T•µ¨°‘À@¹	ýßÈ€’ ?Ö`5€Ò€Ò €Ò…”¨°‘óªÀ@¹	ýßȳ´áª ?ÖÀ4(€hz¹õª€Ò¨°‘À@¹	ýßÈ€Ò ?Ö€Òઔ¨°!‘	ýßÈà* ?Öàªý{Á¨õ[A©óS¨À_Öóøý{¿©ý‘Á‘©°(A‘	ýßÈ ?Öèй1ÀTèÐÁ:‘¨°‘	ýßÈ᪠?Ö 4(€hz¹ €R”€Rý{Á¨óAøÀ_Öóøý{¿©ý‘óÐ`@¹1àT¨°¡‘	ýßÈ ?Ö€h¹ €Rý{Á¨óAøÀ_Öý{¿©ý‘èÐÁ<‘©°(‘	ýßÈ€RôR ?Öà4êÐHYO¹ €R	IY¹”€Rý{Á¨À_ÖóS½©õ[©÷ùý{¿©ý‘öÐÓZO¹Ó4èÐÁ<‘¨°!‘€ÒsQ©þßÈ`R› ?ÖÈZO¹	QÉZ¹3ÿÿ5 €Rý{Á¨÷@ùõ[A©óSèÀ_Ö°åªäªãªâª€’óS½©õ[©÷ùý{¿©ý‘õª¿ñ$@ú÷ªöªèT;”È€R¹ö”À€RT¨‹?±ŸšóªB´IÀ9	4t´ˆË	ñ
T¿9)”H€R¹ä”@€RBH€R©9¨9³
‘´hÀ9È4᪟ñ`TúâýÿT(À9h8)À8Iÿÿ5ઔÀ9½q TqqàTŸñ`Tú"üÿTˆ€Rh9s‘w´èÀ9(4êËŸñ`TúâúÿTHió8h8Iió8Iÿÿ5¶´ÈÀ9h4¹qTŸñ`TúbùÿTÈ€Rh9ÈÀ9s‘(4ÊËŸñ`TúBøÿTHió8h8Iió8Iÿÿ5Ÿñ`Túb÷ÿT9€Rý{Á¨÷@ùõ[A©óSèÀ_ÖóS½©õ[©÷c©ý{¿©ý‘õªôªó*U´4´‹2@©ñ韟ñèŸ?kATˆ&A©ñêŸ?ñèŸ_kaTˆ&B©ñêŸ?ñèŸ_kTˆ&C©ñêŸ?ñèŸ_k¡
T)€ÒöªÈÀ9ˆ4)ÑÖ‘‰ÿÿµÈÀ9éqaT´Ÿ
ñ"Tá*àªk”¦”H€R¹@€R`C€Ò⪀’àªÕ”Õ‘k´L´9¨À9öª€Ò€Òh4à*'”€4ÈÀ8È4ÈÀ9½qàTqq T¹qT÷ªØ‘ÈÀ8èýÿ5˜´€
@ù´ˆ@ùËë)úÿT⪀’¯”õª‰
@ù‰´ˆ@ùH´?9ÿñ€@ùàUúcT´ˆ@ùãËëÉ÷ÿT⪀’œ”€@ùÀ´ˆ@ùÃËë©öÿT⪀’“”´ˆ@ùÃËë‰õÿT⪀’Š”‰@ù‰´ˆ@ùH´?9€R	á*àª”G”È€R¹”À€Rý{Á¨÷cB©õ[A©óSèÀ_Ö	@ù‰´@ùH´?9	@ù‰´@ùH´?9	@ù‰´@ùH´?9	@ù‰´@ùH´?9À_Öý{º©ý‘?ñáùác‘âùh€ÒãùŸšä'ùèù_ñâSÿC9 €ÒÿG9ŸšèùñãS €ÒŸšè#ùŸñ €ÒŸšè+ù/ÿÿ—ý{ƨÀ_Öý{¿©ý‘¨°a‘	ýßÈ ?ÖèÐùù¨°‘	ýßÈ ?ÖèÐýù €Rý{Á¨À_ÖèÐa?‘À_ÖèÐ?‘À_ÖóS¼©õ[©÷c©ùk©ý{¿©ý‘óðh@¹h5@€R
qi€R(±ˆ€Òh¹}@“?”øðù€Òu”@ù¨µh€R€Òh¹`€Ò4”ù€Òk”@ùhµ€èБéð7A
‘€Ò€Òt€R	€Ò9€€RôR`‘â”@ù©þF“ª@’Ój(øèziøI!›+@ùh	‘	ñHTy¹µ‘Ö"‘sb‘”Q´ýÿ5€Rý{Á¨ùkC©÷cB©õ[A©óSĨÀ_ÖèБ	|@Ó
€Ò !
›À_ÖóS¾©õ[©ý{¿©ý‘n”i”¨°!‘€Òt€RöðÈ@ù`jhøg”È@ùijhøªþßÈ Á‘@?Ös"‘”QÔþÿ5À@ù%”ßùý{Á¨õ[A©óS¨À_Ö¨°Á‘	ýßÈÀ‘ Ö¨°á‘	ýßÈÀ‘ ÖóS¿©ý{¾©ý‘óªôª´ù @ùíÿÿ—àª
”ó*€@ùîÿÿ—à*ý{¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘ð’ëôªÂT\”ˆ€R¹€RˆBù3øÓhµñ‰TˆBùëhT €Ràªð”õªuµ€R€Bù┕ù“ù3€R€ÒÝ”à*ý{Á¨õ@ùóS¨À_Ö_qÀT_qDLz T_4q T(S	Qê€R?
jàŸ €R€RÀ_Ö	0Bù‰µ	`‘@€Ò,BùýAÓ	‹Ñh$ù
Réª8@¹q Ø@z TQ8¹B5€>Ô*ÂI…á
*(ÁåqTh
	+$@ù9	$@ù)Ñ	$ùéÿÿ‰	K	P¹
$@ùH‘$ùÀ_Ö	0Bù‰µ	`‘@€Ò,BùýAÓ	‹
Ñh
$ùRé
ªO|@Ó8@¹q Ø@úÀTQ8¹Oµ€>Ô+Ïši…›áª(
ÁLŸåqTˆ	,$@ù9	$@ù)Ñ	$ùèÿÿ©	K	P¹
$@ùH‘$ùÀ_ÖóS½©õ[©÷c©ý{¿©ý‘ö*ßqõª7ôª€RMT€¨@ù	@¹¿;Õ(1Sˆ4¨@ù	@ùÉ´¡@ùà*­%”1 Tˆ@¹	‰¹˜¹	€?1€Tsk+ýÿTý{Á¨÷cB©õ[A©óSèÀ_ÖóS½©õ[©÷ùý{¿©ý‘ô*Ÿqöª7õª€RmTâªá*ઔ¨@¹1€TskëþÿTý{Á¨÷@ùõ[A©óSèÀ_Öóøý{¿©ý‘óªb9´($@©h¦©èÐ]A¹È5è°¡‘	)@©iª©!”a"‘`ùH@ùhù	D@ùi
ùÞ!”`@ùaB‘ï!”i@ù(©C¹¨72*€R(©¹jb9àªý{Á¨óAøÀ_Öý{½©óS©õùý‘*óÿ—ÿCÑóªh@ù@ùàªv%”h@ùSà‘@ùÉÿÿ—j¦A©àƒ‘h@ù,@ùi
@ùK@ù@ù*@ùé#‘éÿ©ÿK¹ÿÃøÿCøêùÿÃyÿs¹ÿÓ9ÿ?ùÿCùèGù볩ÿ“¹ˆ”ó*àCBùÓ”èc@9ÿCù¨4ê@ùH©C¹	yI©¹áªà*‹%”à*ÿC‘óÿ—õ@ùóSA©ý{èÀ_Ö(@ù	}@ùÀ9*@ùLÀ94é*è	*?k€TÀ8é*hÿÿ5‘è4hÀ94í€RS	Q?
j`ThÀ8hÿÿ5iÑ*À9_ÁqT*ýß8_ÁqÀÿÿT(Ñ_k,ˆšhÀ8ˆ8Èÿÿ5À_Ö-@ùÀ9®‰@ùˆSÉÉh8?•qÀT«@ùÀ8ˆSiÙhx©ÿ7ˆSÉÉh8?áqATÀ9‘?áqˆš¨}@ùm‘	@ù*À9j9¨À8é*¬ñ8ì*‰ÿÿ5À_ÖóS¾©õ[©ý{¾©ý‘ôª“
@ùöª“µÖ”óª“
ùu@¹¹B€Rˆ@ùáC‘ÿùј”À¹€
@ù`µÈ”€
ù@¹‰qTˆ@ùé@ù?ëƒT‰ù €R€Rh@¹h5U4u¹ý{¨õ[A©óS¨À_ÖóS¿©ý{¿©ý‘óª`6Bù ´”SH4h@ùˆ´hrD¹	ir¹?	q T¨°Á‘R¹.¹d	‘j*@¹iùêø7lÁ9ˆ	S?iqèTˆ}@“	Ñ+}ÓŠ‘mij¸
€Rh.@¹	

*}ÓKit¸k.¹!q`Tq¨T	(I«8(	‹Öàªû”Sh5|”È€R¹7”€ý{Á¨óSÁ¨À_Ö€~)h~)9R95àªÍ”0Ÿ©q Taґઉÿÿ—*j@ùè
Ë	@’*
‹K!‘kùl_¸l6¹Ìø6h2@¹êKj6¹	2i2¹(€R:¹Ÿ©q`Taâ‘èÿÿj@ùè
Ë	@’*
‹K!‘kùh_¸	€h:¹qh:@¹)±ˆi:¹ëÿÿàª2”ઔShøÿ4h@ù	À9i9h@ù)óÿ5	‘iùhrD¹	ir¹?	qáñÿT`*@¹¶ÿÿ¬¸¾Á×ÙëîóS¿©ý{¿©ý‘óªh6Bùh´h@ùèµ"”È€R¹Ý”€xhrD¹	ir¹?	q@T¨°Á‘R¹.¹a	‘j*@¹iùŠø7lÁ9ˆ	S?iqèTˆ}@“	Ñ+}ÓŠ‘mij¸
€Rh.@¹	

*}ÓKit¸k.¹!q@ûÿTqˆûÿTé
(I«8(	‹Ö€RàªÃ”Sèùÿ4aÁ9b¢‘`¢‘s”:€~)h~)9R94àªD”/Ÿ©q TaÒ‘àªÿÿ—)j@ùè
Ë	@’*
‹K!‘kùl_¸l6¹Ìø6h2@¹êKj6¹	2i2¹(€R:¹Ÿ©q`Taâ‘èÿÿj@ùè
Ë	@’*
‹K!‘kùh_¸	€qh:¹)±ˆi:¹ìÿÿઔàªe”S¨òÿ4h@ù	À9i9h@ù‰óÿ5	‘iùhrD¹	ir¹?	qAòÿT`*@¹ý{Á¨óSÁ¨À_Ö­·½ÀÖØéìÁ9q TqT­q`TµqÀTÁqT0@¹	20@¹	2	0@¹	20@¹	20@¹	2	0¹ €RÀ_Öóøý{¿©ý‘€Róª”Sh5€Rh6Bù`Á9	@¹¿;Õ(1Sˆ4h6Bù	@ù©´a6Bùf#”1 Th*@¹	i*¹€h*¹ €Rý{Á¨óAøÀ_Öóøý{¿©ý‘óª`Á9R91ëTh@ù	@ù*@ùKÙ`xh€RÈ4h6Bù	@¹¿;Õ(1Sˆ4h6Bù	@ù©´a6Bù?#”1 Th*@¹	i*¹€h*¹h@ù	À8i9hùé5;”È€R¹ö”€R €Rý{Á¨óAøÀ_Öóøý{¿©ý‘óªaÁ9R9?1ëTh@ù	@ù*@ùKÙaxh€Rè4b¢‘`¢‘¤”h@ù	À8i9hùé5”È€R¹Ó”€R €Rý{Á¨óAøÀ_Öý{¿©ý‘	Á9?qT@ùˆ7é€R	,¹×”S`?9qaT@ùh7	€R	,¹ü”È€R¹·”€RT<@¹(ÿÿ5?©qìT€T?%qÀT?1q@T?Qq T?¡qÁT	@ù(À9¡q¡T(‘ù)€R=I€R;¨€R<¹9	€R6	@ù*À9_ÍqÁT(À9ÉqaTJ€R_Ùq!T(À9ÑqÁTj€R(	‘
<¹ù$HaQ	S?qTiX(%Èš¨6)€R¨€Rßÿÿ?±q T?Ñq T?Ýq T?éq!TÈ€RÕÿÿˆ€RÓÿÿé€R
	@ù(À9±q¡T(‘ù‰€Ri€R	<¹ €Rý{Á¨À_Ö Õ‚ ý{¿©ý‘	Á9?qT@ùˆ7é€R	,¹E”S`?9qaT@ùh7	€R	,¹Œ”È€R¹G”€RT<@¹(ÿÿ5?©qìT€T?%qÀT?1q@T?Qq T?¡qÁT	@ù(À9¡q¡T(‘ù)€R=I€R;¨€R<¹9	€R6	@ù*À9_ÍqÁT(À9ÉqaTJ€R_Ùq!T(À9ÑqÁTj€R(	‘
<¹ù$HaQ	S?qTiX(%Èš¨6)€R¨€Rßÿÿ?±q T?Ñq T?Ýq T?éq!TÈ€RÕÿÿˆ€RÓÿÿé€R
	@ù(À9±q¡T(‘ù‰€Ri€R	<¹ €Rý{Á¨À_Ö Õ‚ óS¾©õùý{¾©ý‘óªhÁ9
Q_ÝqT‰(Yª¸	(	‹Ö€RàªR”$ઔ!àª@”àªÁ”h2@¹	2i2¹A€R€Ràªw”i2@¹(Sh4(2h2¹€Röÿÿ"€R€Rôÿÿ€Rýÿÿ	€Rh€Ri")øÿÿàªô”SH
4hA9È5l2@¹èC‘y€Ò	9ˆS¨4ˆSh4¨€Rl6h€RˆSˆ4€RèC9+€ÒmÁ9ê€R¨S	aQ?
j¡TˆSh4.€R€R¨S	Qê€R*

N5ª5éC‘€Rhi)8¿aq€T¿q€RAT€RéG‘hi)8k	‘i6@¹õ*hR@¹Ÿr)K4KÁTc¢‘â*€R`¢‘ìûÿ—h6Bù	@¹¿;Õ(1S4h6Bù	@ù©µh*@¹	i*¹dB‘c¢‘â*áC‘`¢‘ü”i2@¹(
S4(	SÈ5c¢‘â*€R`¢‘Ðûÿ—€RàªA”h*@¹(ø7h2@¹		SÉ4c¢‘â*€R`¢‘Ãûÿ— €R€Rý{¨õ@ùóS¨À_Öýÿÿÿ…óÿÿÿ…ýÿÿÿýÿÿÿýÿÿÿ……………………………úÿÿÿ……………÷ÿÿÿ………………ýÿÿÿ…óÿÿÿýÿÿÿýÿÿÿýÿÿÿ…………………úÿÿÿ………óS¾©õùý{¾©ý‘óªhÁ9
Q_ÝqˆT	(Yª¸	(	‹Ö€Ràªt”$િ”!àªb”àªã”h2@¹	2i2¹A€R€Rઙ”i2@¹(Sh4(2h2¹€Röÿÿ"€R€Rôÿÿ€Rýÿÿ	€Rh€Ri")øÿÿઔSÈ4hA9H5l2@¹èC‘y€Ò	9ˆS¨4ˆSh4¨€Rl6h€RˆSˆ4€RèC9+€ÒmÁ9ê€R¨S	aQ?
j¡TˆSh4.€R€R¨S	Qê€R*

N5ª5éC‘€Rhi)8¿aq€T¿q€RAT€RéG‘hi)8k	‘i6@¹õ*hR@¹Ÿr)K4KÁTc¢‘â*€R`¢‘8ûÿ—dB‘c¢‘â*áC‘`¢‘ø”i2@¹(
S4(	SÈ5c¢‘â*€R`¢‘(ûÿ—€Rહ”h*@¹(ø7h2@¹		SÉ4c¢‘â*€R`¢‘ûÿ— €R€Rý{¨õ@ùóS¨À_Öýÿÿÿyóÿÿÿyýÿÿÿýÿÿÿýÿÿÿyyyyyyyyyyyúÿÿÿyyyyy÷ÿÿÿyyyyyyýÿÿÿyóÿÿÿýÿÿÿýÿÿÿýÿÿÿyyyyyyyúÿÿÿyyyóS¾©õùý{¿©ý‘óªj@ùè
Ë		@’*
‹K!‘kùu_øõ´´@ù´´b>@¹aÁ9`@ù2úÿ—t&ù©@yS¨4(€RhR9)}S
ªH‘h&ùI‘(À8èÿÿ5H‘)ËR9iR¹ €Rý{Á¨õ@ùóS¨À_ÖóS¿©ý{¾©ý‘ÿCÑóªh2@¹4€Rj:@¹	2i2¹Jø6hA9ê€R	Q?
jÉ€R¨€R*ˆj:¹
*5hÁ9q€T
€RqaTt:¹*€RHu}@“`b‘Ðùÿ—S(5h2Bùhµ@€Òh.BùýAÓ	uQi:¹ib‘(Bùñ(ˆšh&ùj@ùè
Ë		@’*
‹K!‘kùp_üa2Bùðýaµ@€Òh.BùýAÓ¡µ@€Òab‘cb	‘h.Bùéª#H‹"ýAÓg"@©àƒ‘ô¹eÁ9f:@¹èùc”h2@¹	SÉ4h:@¹ˆ5a@ù`&@ùûÿ—hA9ê€R	Q?
jáTh2@¹	S‰5a@ù`&@ùÐúÿ—j&@ùKÀ9µqáTh2@¹J‘j&ù	2i2¹KÀ9h%Q	S?•qˆTéX(%Èšh79qáTh2@¹k€Rk9	yi2¹KÀ9é
ªk4(À8èÿÿ5(
ËhR¹ €RÿC‘ý{¨óSÁ¨À_Ö Õ!óøý{¿©ý‘óªb>@¹aÁ9`@ù‹ùÿ—j@ùS¨4è
Ë	@’*
‹K!‘kùc_xa2Bùµ@€Òab‘h.BùýAÓd@ù`B‘ê” 4(€Rh9ib‘(Bùñ,ˆšè
Ë	@’*
‹K!‘kùhß8ˆ9(€RhR¹ib‘(Bù €Rñ(ˆšh&ùý{Á¨óAøÀ_ÖóS½©õ[©÷c©ý{¿©ý‘óªj>@¹÷*XS_-q(TI(Iª8(	‹Öt‘ˆ@¹6€Ò	Sh@ùÉ4	!‘iù)ß85}@“7	!‘iù5_83t‘j@ùˆ@¹V€Ò	Sè
Ë	4	@’*
‹K!‘kùhßx}@“%	@’*
‹K!‘kùu_xt‘j@ùˆ@¹€Ò	Sè
Ë		@’*
‹K!‘kùu_øt‘j@ùˆ@¹	Sè
Ëé4	@’*
‹K!‘kùuŸ¸	@’*
‹K!‘kùu_¸–€Ò‰@¹(S¨4•ø¶)2‰¹õËj:@¹Šø6(€Rh:¹(yA}@“ˆ¹`b‘Òøÿ—•µˆ@¹	y‰¹R9ß"ñã*â*àªTáª.ùÿ—á*ÿøÿ—ˆ@¹	Sé4hR@¹¨4h&@ù	À9?Áq Th&@ù
€R	Ñi&ù*9hR@¹	iR¹ €R”È€R¹Î”€Rý{Á¨÷cB©õ[A©óSèÀ_Ö±‚‘±¥¥¥¥ö¥±¥óS¿©ý{¿©ý‘óªj@ùè
Ë		@’*
‹K!‘kùt_øý”à4j>@¹_-qˆTi(Iª8(	‹Öj*€¹Šù	h*@¹ˆ¹hRÀyˆyh¢À9ˆ9(€Rh9 €Rã”È€R¹ž”€Rý{Á¨óSÁ¨À_ÖìòïìééééøéìéóS¾©õùý{¿©ý‘ôªŠ@ùè
Ë		@’*
‹K!‘‹ùˆ
G)	°s_øÁ9€@ù15ˆ“&ù‹øÿ—Sˆ4³µ©(Á‘ˆ&ù3Á‘(€R¡~@“ˆR9àªfîÿ—	³µ©(‘ˆ&ù3‘¡~@“àªÀîÿ—è*ˆR¹ €Rý{Á¨õ@ùóS¨À_Öý{¿©ý‘@¹¿;Õ1S¨5Š”î°qí|@“	TjýF“ÈA
‘yjøi@’	€Ò,!›¬	‘ˆåÀ9È5q	TjýF“ÈA
‘yjøi@’	€Ò+!›«	‘hõ@9è6„”È€R¹?”€R €Rý{Á¨À_Ö
@ùI¡@©	ëTHa@9¨4H@¹	I¹€H¹@ùa@9H@¹	I¹
@ùH	@ù	‘I	ù
@ùH@ù9@ù €Rh@ù	‘iùÀ_Öý{½©óS©õùý‘$ìÿ—ÿCÑóªhRA9(4hR@¹qÍTu&@ù€R£&@x€Òÿ¹d@ùá#‘à‘~” 5â@¹â4h6Bù	@¹¿;Õ(1S4h6Bù	@ù©µh*@¹	i*¹dB‘c¢‘á#‘`¢‘†”hR@¹”ŸkAüÿT€h*¹h6BùbR@¹a&@ù	@¹¿;Õ(1S4h6Bù	@ù©µh*@¹	i*¹dB‘c¢‘`¢‘l” €RÿC‘ëëÿ—õ@ùóSA©ý{èÀ_Öý{½©óS©õùý‘Úëÿ—ÿCÑóªhRA9¨4hR@¹qMTu&@ù€R£&@x€Òÿ¹d@ùá#‘à‘4” 5â@¹b4dB‘c¢‘á#‘`¢‘”hR@¹”ŸkÁýÿT
€h*¹bR@¹dB‘a&@ùc¢‘`¢‘” €RÿC‘¹ëÿ—õ@ùóSA©ý{èÀ_ÖóS½©õ[©÷ùý{¿©ý‘öªô*óª”4É@ù*¡@©
ëÁT(a@94h@¹	HË @ù—~@“ë1—šâª\ìÿ—Ê@ùH@ù	‹IùÊ@ùH	@ù	‹I	ùÊ@ùHa@9ˆýÿ5¿ë€T€h¹h@¹©i¹ý{Á¨÷@ùõ[A©óSèÀ_ÖóS¼©õ[©÷c©ùk©ý{¿©ý‘ùª3@ùöª÷ªø*ôª“µŸ”óª3ùøÂ8‹u@¹¹ÿë€T€È@ùàÀ8	@¹¿;Õ(1Sˆ4È@ù	@ù)´Á@ù‚”1¡T @ù`µ‡” ù@¹©qÁTÈ@ù	@¹¿;Õ(1Sˆ4È@ù	@ùÉ´Á@ùà€Rn”1 Tˆ@¹	‰¹š¹ÿë!ûÿTš¹h@¹h5U4u¹ý{Á¨ùkC©÷cB©õ[A©óSĨÀ_Öý{¸©ý‘â©á©àùáµ\”È€R¹”€Bÿÿ´èc‘á©è+ù郑裑飩èã‘éÑ飩ã‘âC‘á#‘àC‘Òöÿ—ý{ȨÀ_Öý{¼©óS©õ[©÷c©ý‘
ëÿ—ÿÃÑöªõªôªóªøªóµ7”È€R¹ò”€\T´5ÿÿ´áªà‘¥÷ÿ—×òÿ“¸¤
@úÿÓxèŸÿÿ9èã9é#‘胑õS©à‘èWùÿùéÿ©ÿk¹ÿÃøÿCøÿyÿ“¹ÿS9ÿOùÿSùö#ùóã©ÿ³¹éøÿ—ó*U´–6”µs4àSBù¨”èc@9ÿSùÈúÿ4ê@ùH©C¹	yI©¹Ñÿÿè@ùë!T3ø7ŸÂ3ëâTðÿÿw´”´sø6¿9è@ùë¡T¨‹ñ8”üÿ´è@ùëÁTàSBù¨‹ñ8†”èc@9ÿSù¨4ê@ùH©C¹	yI©¹3€i58àSBùz”èc@9ÿSù¨4ê@ùH©C¹	yI©¹à*ÿѪêÿ—÷cC©õ[B©óSA©ý{ĨÀ_Ö	€Ò´_ñTNÑδ,Ñ
Ñ­‘ªñß8‘!‘Œ‘j4ˆñß8_kT«À9k4ˆÀ9kTªÀ9Š4ˆÀ9_k!T«	À9«4ˆ	À9kAT)‘?ëÃüÿT?ëbTËjiá8ª4(À9_kAT)‘?ë!‘ÿÿT€RÀ_Ö)ð_8)à_8)Ð_8hS)À_8HS	Kõÿÿ(@9IS Kñÿÿóøý{¿©ý‘󪢴)Ë(ià88h4BÑ‚ÿÿµÂ´Hш´â*€R|êÿ—àªý{Á¨óAøÀ_ÖóS¿©ý{¾©ý‘ó*è]A¹tH5ŸqTÈðIAù	Ùsx ý{¨óSÁ¨À_Ö”áC‘H@ùèùÑ”è@ùŸqèT@ù	Ùsx ý{¨óSÁ¨À_Ö	@¹q
T€Ò€Rà*É”ý{¨óSÁ¨À_Ö€Rý{¨óSÁ¨À_ÖóS½©õ[©÷ùý{¿©ý‘ô*öªU”óªs´j@ùK‘_ëé
ªÀT(A¸k€T?ëÿÿT€Òè´@ùµ´¿ñÁTù €Ra(AÑ÷ÿÿ¿ñaT€[w@ùvù@¹Ÿ"q	TIÁ‘+A‘?ù)A‘?ë¡ÿÿT@¹I
v@¹	kÈT@TÉ		k€T‰		kÀTI		kT			kô*!T(€R4€R%È€RÔ€R"h€Rt€RH€RT€Rˆ€R”€RÉ	k€T‰	kÀTI	kT		kô*¡T¨€R´€R	È€RÔ€R¨€R´€RH€RT€Rh¹ˆÐ=Aùïª?Öá*€R ?Öv¹ùˆÐ=Aùïª?Öà* ?Öwù¦ÿÿ€Rý{Á¨÷@ùõ[A©óSèÀ_Ö‘ÀÀŽÀÀÀ’À“À´ÀµÀè@¹À_Öè¹À_ÖÈð	@ùëh
@ù*)Ê*-Êš_ñàŸÀ_Öè
ùÀ_ÖóS¿©ý{¿©ý‘Èð	@ùëh
@ù*ôª)Ê3-Êšsµ€RˆÐ=Aùïª?Öàª`?Öý{Á¨óSÁ¨À_ÖÈð
@ù€RIi	K,Éš
Êëh
ùÀ_ÖóS¼©õ[©÷c©ùùý{¿©ý‘øªùªù(€Ò(ùôªöªóªv´ÓùÖ"‘€RˆÀ8‰q¡Tÿq÷ŸU€R@ù	‘	ù“´ˆòß8h9s‘•òß8”‘à*ù” 4@ù	‘	ù“´ˆÀ9h9s‘”‘54—üÿ5¿‚q`T¿&qüÿT“´ò8”Ñ€RˆÀ9(4q`T%q¡Tˆ‘ôªÀ9ùÿÿè4v´ÓùÖ"‘(@ù—€R	‘)ùˆÀ9+€R
€RˆÀ8Jqq ÿÿT‰qTJ7Õ4ˆÀ9‰qaT”‘¿qõŸ€RJ}S*4JQs´w9s‘@ù	‘	ù*ÿÿ5€À9 4•5€qIz TK4“´`9€À9s‘©” 4@ù”‘	‘	ù“´ˆÀ9h9s‘@ù	‘	ù”‘Éÿÿs´9s‘@ù	‘	ù°ÿÿV´ßù(@ù	‘)ùý{Á¨ù@ù÷cB©õ[A©óSĨÀ_Öóøý{¿©ý‘ü’ëbT€’Bµ€>Ô	š?ë¢T)|›è ª	ë)T 
‹!€ÒB”óª€Òy”઀Òý{Á¨óAøÀ_ÖóS¾©õ[©ý{½©ý‘õ*u4¨QqéT͔ȀR¹ˆ”Ó€RS	 ”ô‚‘‚ €R€Òú”ˆ‚‘Éð(éùÉð3ùGùs´hÀ9H5“‚‘䃑ÿÿ©ãc‘€Ò€Òàª,ÿÿ—ö‡A©"€Ò઼ÿÿ—ôªµ«”ˆ€R¹€ÒC”“€R0‚‹äƒ‘ãc‘áªàªÿÿ—¿q!Tè@ùËðtñù€ÒQÊðHÙ¹áC‘ÿùàª}”ó*ó4à@ù)”àªÿù&”ê@ù	€ÒH@ùë
ªˆ´h@ø)‘ÈÿÿµËðiÙ¹ÿùÈð
ñù€Ò”ÿùઔ€Rà*ý{èõ[A©óS¨À_ÖóS¿©ý{¿©ý‘ôˆ–@ùh´€Rª”Á ”óªsµ€ઔ`µ€è¡ù€–ù€R€Òô”àªò”à*ý{Á¨óSÁ¨À_ÖóS½©õ[©÷ùý{¿©ý‘ôªˆÀ9êª	€Ò4õq)‰šh4HÀ8èÿÿ5HÀ8Hÿÿ5€Ò ‘Ÿ”óªÓ´öª‰À9‰4êªi4HÀ8èÿÿ5HË‘?õqÀT!€Òઔõªu´âªáªr
”`5Õù€ÒÖ"‘¿”ô‹èÿÿh@ùôª¨´àª¸”ˆŽ@ø¨ÿÿµàª´”€Ò²”€Ò€Ò¯”àªý{Á¨÷@ùõ[A©óSèÀ_Ö€Ò€R€Ò€Ò€Òiïÿ—óS¾©õùý{¿©ý‘Èð™@ù´h@ùH´€Ò€Ò€R€Ò€âª€R€R! ”|@“u´!€ÒàªR”ôª”´b@ùå*€Ò€Ò䪀€R€R ”@4€Rઅ!”€Ò{”hŽ@øüÿµ€Ràªu”€ý{Á¨õ@ùóS¨À_ÖóS¿©ý{¿©ý‘Èð¡@ù@ùë`TS´h@ùôª¨´àªa”ˆŽ@ø¨ÿÿµàª]”ý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘Èð@ù@ùë`TS´h@ùôª¨´àªK”ˆŽ@ø¨ÿÿµàªG”ý{Á¨óSÁ¨À_Öóøý{¿©ý‘Èð¡‘`@ù@µh@ùhµ€Ò+ÿÿ—`4“ÿÿ—`ÿÿ5`@ùý{Á¨óAøÀ_ÖóS¿©ý{¿©ý‘Èð¡‘઺ÿÿ—`"‘Îÿÿ—Èð¡@ùS´h@ùôª¨´àª”ˆŽ@ø¨ÿÿµàª”Èð@ùS´h@ùôª¨´àª”ˆŽ@ø¨ÿÿµàª”ý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘Ôð€¢@ùàµÈð¡‘`@ù@µh@ùhµ€Òðþÿ—`4Xÿÿ—`ÿÿ5`@ù€¢ùý{Á¨óSÁ¨À_ÖæþÿóS½©õ[©÷ùý{¿©ý‘õª(Ë	‘*ýCÓ¿ëöƒŠš€Òv´—°´†@ø´´è>Aùïª?Ö€?Ös‘ëÿÿTý{Á¨÷@ùõ[A©óSèÀ_ÖóS¾©õ[©ý{¿©ý‘óªôªë`T–°u†@øÕ´È>Aùïª?Ö ?Ö€5ëÿÿT€Rý{Á¨õ[A©óS¨À_ÖóS¿©ý{¾©ý‘ôªóª³ù @¹Ý ”ઔ`@¹ÿ ”ý{¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘ôªÕð¨bE9è5)€RÈð!‘	ýŸˆ¿;Õˆ@ù	@¹©5ÈÐ
@ùKÉð(©@ù
ë`TIÊ3-˚愈°=Aù?Ö€Ò€R€Ò`?ÖÈð¡‘?qTÈð‘p”ˆ@ù	@¹É5ˆ°Á‘‰° A‘Œÿÿ—ˆ°‘‰° ᑇÿÿ—ˆ@ù	@¹É5(€R¨b9ˆ
@ù)€R	9ý{Á¨õ@ùóS¨À_Ö”ˆkàŸÀ_Öcsmàóøý{¼©ý‘ó*â‡)b5ˆ°¡‘	ýßÈ€Ò ?Ö ´@y©I‹R	k!T<@¹ªˆR
À(‹I@¹?kaTH1@y-qTH…@¹9q©THù@¹h4à*3”èc‘ÿC9èùéS‘èC‘é#©H€RI€Ré£)ãs‘⣑ბàG‘yÿÿ—è@¹ˆ4ý{ĨóAøÀ_Öà*”óøý{¿©ý‘ó*€ ”qàTèª1@ù	½@¹*!SJ5ˆ°‘	ýßÈ ?Öˆ°A‘	ýßÈá* ?Öà*”ˆ°!‘	ýßÈà* ?ÖóS¿©ý{¾©ý‘ˆÐ¡‘ÿù‰°(‘	ýßÈô*âC‘€R ?Ö4ˆÐ‘à@ùˆ°¡‘	ýßÈ ?Öóªó´ˆ°=Aùïª?Öà*`?Öà@ù ´ˆ°a‘	ýßÈ ?Öý{¨óSÁ¨À_ÖÈð©ùÀ_Ö"€RA€R€Rÿÿ"€R€R€R}ÿÿ€RA€RzÿÿÈÐ
@ùÌðˆ©@ù€RIk	K
ë¡T	,Ëš*
ÊŠ©ùÀ_Ög€R€Rhÿÿý{¿©ý‘àµ)
”È€R¹ä”À€RÈðÕI¹¿;Õ¹€Rý{Á¨À_Öý{¿©ý‘@Qur!T0@qàTÈðQ'‘ýŸˆ¿;Õ€R
”È€R¹Ê”À€Rý{Á¨À_Ö|@“?@qÉð-A
‘ýF“@’¨ylø	€ÒÉ!›*á@9+åÀ9OÀT? @q T(@@Qyr@T?AqTH2(á9(€R©yløÊ%›Hå9
H2(á9H€RùÿÿH(á9H2(á9©yløÊ%›_å9o5Rk5ˆRq‰ R( R ˆÀ_ÖóS¾©õ[©ý{½©ý‘õªµù @¹“”¿C9Èðá‘óªÖгùˆ"‘ë`TÉB
‘h@ù	ë TÁB
‘ષ#”`ùs"‘óÿÿ @¹¤”ý{èõ[A©óS¨À_ÖÈðq‘)€R	ýŸˆ¿;ÕÀ_Öý{¾©ý‘ãS‘âC‘ác‘àC‘ˆ€R‰€Rè§)Ïÿÿ—ý{¨À_Öóøý{¿©ý‘ó*F”¨C¹J€R)€RrI‰1 Ts4q`T
qàT‘”È€R¹L”€
y2¨¹€ÊÐHá	¹à	*ý{Á¨óAøÀ_ÖÈðaA¹¿;ÕÀ_Öý{¿©ý‘qéTv”È€R¹1”€Èð
‘Hý_ˆ@ý	ˆÉÿÿ5¿;Õà*ý{Á¨À_ÖÈð‘‘À_ÖóS¿©ý{¾©ý‘óªôª´ù @¹”ઔó*€@¹@”à*ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘óªôª´ù @¹
”àªy”ó*€@¹.”à*ý{¨óSÁ¨À_ÖóS½©õ[©÷c©ý{¿©ý‘÷ªè@ù
@ù-´ØÐ@ù©@ù*Ê©@ù‹V-Ëš*Ê©	@ùN-Ëš*ÊM-Ëšß
ë¡T¨ËýC“ñ	@€Ò(“š	«
€ÒU‰š¿ë#T€Òáªàª0#”ôª€Ò³”Tµu‘᪀Òàª'#”ôª€Òª”´Ž‹@ùöª‹€Ò直Ë	‘*ýCÓß
ë胊šÈ´k‘ì…øë¡ÿÿT@ùè@ù‰
€RJ	K€R	@ù*-ÊšKÊËù@ù
€R‰I	Kê@ùÈ.ÉšÊÈ!‘I@ù
€R+ù@ù‰J	K	-Êšê@ù+ÊH@ù
€Rù@ùˆHKê@ù©-Èš+ÊH@ù	ù€ý{Á¨÷cB©õ[A©óSèÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘öªÈ@ù@ùkµ€?ÚÐL@ùi@ù*Êi@ùŽU-Κ*Ê©Ñ?
±T-ΚHTùª÷ªøª›°”"ÑŸë£Tˆ@ùë`ÿÿT	Ê™ùh?Aù3-Κïª?Ö`?ÖÉ@ùL@ù+@ùŽh@ù
Êh@ùM-Κ¿ë
ÊK-Κ`XúàüÿT÷
ªõ
ªøªôªâÿÿ¿±€Tàª+”L@ùÈ@ù	@ù,ùÊ@ùH@ùùÉ@ù*@ùL	ù€Rý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖáªÈð¡‘ý{½©ý‘ãS‘àù⣑ác‘àC‘胑èùI€RH€Rè§)ÿÿ—ý{èÀ_Ö`µ€
	@ù@ù	ë¡TÈÐ@ù ©ù€RÀ_Öý{¼©ý‘ãS‘à©âÑác‘àC‘胑飑è'©H€RI€Rè§)ëþÿ—ý{ĨÀ_ÖÈÐA
‘Éð(½ù €RÀ_Öý{¿©ý‘Èð¡‘Øÿÿ—Èð‘Õÿÿ— €Rý{Á¨À_Öý{¿©ý‘¤üÿ— €Rý{Á¨À_Öóøý{¿©ý‘È°@ù઺
”àªÀ"”àª"#”àªzúÿ—àªÖýÿ— €Rý{Á¨óAøÀ_Öý{¿©ý‘€RÏìÿ—Sý{Á¨À_ÖóS¿©ý{¿©ý‘ÓÐjÊCùHý_ˆQHý	ˆ©ÿÿ5¿;Õ(5`ÊCùÔ°ˆ‘ë€T¢”ˆ‘hÊù €Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘ÓÐ`¶Cù•”¶ùÓÐ`ºCù‘”ºùÓ°`òGù”òùÓ°`öGù‰”öù €Rý{Á¨óAøÀ_Öý{¿©ý‘ˆ°A‘‘/"”Sý{Á¨À_Öý{¿©ý‘Sè4ÈÐ@ùH´§” €Rˆ°A‘‘M"”Sý{Á¨À_Öóøý{¿©ý‘o”@ùó´ïªˆ=Aù?Ö`?Ö(	”óS¿©ý{¾©ý‘óªôª´ù @¹y”àªo”S€@¹š”à*ý{¨óSÁ¨À_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘ú*óª÷ªûª³µž
”È€R¹Y
”€’ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖhÀ9hþÿ4Wþÿ´è@ùþÿ´À9Èýÿ4€Rભ<”á€Rõªàª©<”ôª€µÕµA€Rણ<”õª5µhÀ9éªh4(À8èÿÿ55Ë ‘!€ÒÖ	”ôª”µ€Ò”Õÿÿˆ°A‘¡‘઴” 
5⪡‘àªÿ"”
5€Ò•
‘ý
”¿ñ
Uú€•šëÁ€Ràªó”š|<”€´€Ràª<%”à5ãªâªáªà*@”ôª4ˆÀ9éªh4(À8èÿÿ5(Ë‘àª!€Ò¤	”õªuµ€’$âªáªàª„” 5¸‹7
”ˆ°a‘@¹–R‘⪡€ÒÑy”@5€Ràª%”4”‘Ÿë¡þÿTàªÁ
”€’"
”㪹âªà*᪔ôªàªµ
”ળ
”àª|ÿÿ€Ò€R€Ò€Ò€Òqêÿ—óS¿©ý{¯©ý‘ÿCÑó*ôªàªáªôµ
”È€R¹À	”€’¶@ÿÿ´q‰Tò	”¹õÿÿ㣑ÿ#ùâ‘ÿù‘#”1áTà@ù
”à#@ùÿùŠ
”ìÿÿèÑÿùqè7ùèŸèƒ9éã‘裑é;ùèCùéÑ胑飩è€Ré€Ré#
)ãC‘â‘áS‘àã‘ÿÿ—S¨5à@ùp
”ÿùàÿÿÇ	”èѹqæ@ù}©	€Rá#@ù}©å‰}©éÑ}©€Ò}©$€R}©€Ò1ù
€Rè³¹èó@y€Òàªéùèçyè@ùèùèc‘èù±#”ô£I©ô'ùè3ù€5‰(‘#
q€Ts5ˆ‘	ýßȀઠ?Öˆ!‘àO@ùác‘	ýßÈ ?Ö 4à3@ùó[€¹± TˆÁ‘	ýßÈ ?Öà'@ù± TˆÁ‘	ýßÈ ?Ö(ˆ‘	ýßÈ ?Öe	”à3@ù± TˆÁ‘	ýßÈ ?Öà'@ù± TˆÁ‘	ýßÈ ?Ö€’qaT±àTઉ(Á‘	ýßÈ ?Öô'@ùŸ±ÀTˆÁ‘	ýßÈઠ?Ö€Òà@ùÿ	”à@ùÿùü	”à#@ùÿùù	”઱ÀTઉ(Á‘	ýßÈ ?Öà@ùî	”à@ùÿùë	”à#@ùÿùè	”àªÿC‘ý{ѨóSÁ¨À_Ö€Rüÿ—óS¾©õù÷ùý{¿©ý‘ôªˆ@ù×Ð	@ù?ùˆ@ù	@ù?ùÊÐSQ‡¹³´kÑìB
‘
	€ÒhýFÓˆyhøi@’)!
›*á@9Š4sÑkÑÿÿµ(ŽƒÒëÃT%	”ˆ€R¹€R;h>S	
!€Ò*U=@Óàª|”Àµ	”ˆ€R¹€R+‘¹l‹íª
€ÒS´çB
‘	€ÒHýFÓèxhøI@’.!›Ïá@9 7oi*8È@ùi*8€’J‘¨…ø_ëAþÿTˆ
@ù	@9I5ñh€Òh2ˆšÈ´	€’8щ…ø¨ÿÿµˆ@ù3€R	@ù ùŠ@ùH@ùù€Ò„	”à*ý{Á¨÷@ùõ@ùóS¨À_Öâªáª@€R€Ò2þÿóS¾©õ[©ý{¿©ý‘ôªóªö*4µh¢@9ˆ4`
@ùk	”¢9~©ùNˆÀ95h@ùhµh¢@9ˆ4`
@ù_	”¢9@€Òd
”ˆ€Rñ`
ùŸq韚qèŸh¢9iù 5h
@ùyæÿÿ€R€Ò€âª!€Rà*µ”|@“5µˆ‘	ýßÈ ?Ö‚”£”@¹%i@ù¿	ëiTh¢@9ˆ4`
@ù6	”¢9 úÓ;
”ˆ€Rñ`
ùŸq©ŸšqèŸh¢9iù5d
@ùå	*€âª!€Rà*”|@“ˆµ‰(‘ÚÿÿÑhù€Rý{Á¨õ[A©óS¨À_ÖóS¿©ý{¾©ý‘ µt”È€R¹/”€ý{¨óSÁ¨À_Ö€¨¹¿¹¿¹€Rå*€Rã*⪡C‘ S‘·”ô*´¹¨@¹³@¹è4”4i~@“*ýF“ÈÐA
‘)@’	€Òyjø*!›Iá@9(Há9à*””4L”¹Úÿÿà*ÙÿÿóS¼©õ[©÷c©ùk©ý{¾©ý‘÷*é~@“ÈÐA
‘ôª*ýF“Ÿ9)@’yjø	€Òöªó*)!›*áÀ9êø6uj!TàC‘ÿ¹ûÿ—à5è@¹	jATs2i
?@q:€RX€R€T(A@Qyr`T(@Qyr€T(AQyrTš9
3*ïÿÿ(`€Rh
qT˜9Ÿ9
r TÈÀ9è
07Õ@¹
¨R	€R€R¨
kàT
°R
kÀT
¸R
k!TÈ
@¹è4	q©Tq	Tq!T3€R©4b€Rÿ¹áC‘à*{”q`ÊAzó“1 Tè@¹qàTqTkaTš9*B€R€Òà*)'”À´€R€Òà*$'”±TÓ”@¹7©~SÝÿÿ=ÉÿŸR	k¡TʔȀR¹ôÿÿéߟR	k!T€RA€Òà*'”±`ýÿT˜9€R€Òà*'”±`üÿTS4ˆÀ9€Rÿ¹qàT	qáTèߟRè¹S€Rù¹s€R“4€RõC‘¡Â4‹bKà*ù$”1€ùÿTkÿÿT€Rý{¨ùkC©÷cB©õ[A©óSĨÀ_Ö€Ò€R€Ò€Ò€Òñçÿ—@óS½©õ[©÷ùý{¾©ý‘óªô*9ˆrõ*ö*×€R TqT	q T{”¹7”€	´6Ÿ
r`T¸R¨R°R‰
h¹?qèT?yr`T?qàT?q T?q¡TI€R‰€Ri€R?q T?q T?q TV”¹”h@¹	€©€R)€Ri
¹¿BqT¿‚q€T¿ÂqT¿q€T¿qÀTB”¹þ”€	°R	kèŸh€RH€R(€R€R	€Rh¦)¹”86hÀ92h9´x7HŸjáTàC‘úùÿ—À5è@¹!@q€ThÀ9a2h9@6È°J¹é(**
j87(€Rh¹T06h@¹j@¹	2i¹i@¹H2h¹*2j¹”`6h@¹	2i¹”h6h@¹	2i¹”(6h@¹	2” 6h@¹	2i¹ý{¨÷@ùõ[A©óSèÀ_Ö€Ò€R€Ò€Ò€ÒTçÿ— Õ@óS¿©ý{¾©ý‘ó*i~@“È°A
‘*ýF“	€Òyjø)@’)!›	€R+á@9jaTK86B€R€’)&”ôªŸ±TÍ”@¹
qTÓ”@¹"€Rÿ#yáC‘à*Z”è#@yq	ZzÁTáªà*/%”1þÿT€R€Òà*
&”±@ýÿT€Rý{¨óSÁ¨À_Ö⽩ä©æ©ý{¿©ý‘êC‘è
Ë	@’"ij¸7þÿ—ý{Á¨ÿÑÀ_ÖóS¼©õ[©÷c©ùk©ý{º©ý‘õªÿ©öªÿ©€Òÿ+ùàC‘ÿc9óª÷*ø*ù*ú*ìÿ—è@ù)½ŸR
@¹	k!Tè£@9¨4ê@ùH©C¹	yI©¹"½ŸRã”è£@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáÑàªýÿ—ô#@ù`4€
æ*å*ä*ã*âªáªàª
”ó*ècA9h4ઔà*ý{ƨùkC©÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¸©ý‘ó*öªôªùªà*â*á*èÑÃþÿ—êÑõ?@¹H%@©ëc‘J	@ù¿1h%©j	ùT;”€¹ˆ¹A”@¹ü”€¹1!T0”€¹ˆ¹6”€R¹òÿÿ(€RêG@¹ÿ+ùȹ€Rá“F)èK¹ès*	èC@¹é[¹€Òã#‘â*E*hð‘	ýßÈઠ?ÖûkE)äD)÷ªÿ±ÁTé7@¹¸R(kTó6hð‘6y	ýßÈE*€Òö¹ã#‘á*ઠ?Ö÷ªÿ±aT‰€¹È°A
‘	€Ò*ýF“yjø)@’*!›Iá@9(kði‘Há9(ýßÈ?ÖÔ”´ÿÿö@¹hð!‘	ýßÈઠ?Ö`5hð‘	ýßÈ ?Öó*Æ”‰€¹È°A
‘	€Ò*ýF“)@’yjøàª*!›Iá@9(Há9ið(Á‘	ýßÈ ?ÖÓòÿ5Ö”¨€R ÿÿqTècÀ92qTècÀ92õcÀ9€@¹áªT”‰€¹Ì°ˆA
‘	€Ò¸2*ýF“øc9yjø)@’)!›ˆA
‘	€Ò8á9Š€¹KýF“ykøI@’)!›?å936€@¹Âþÿ—õ*µ4€@¹´”à*gêc‘€@¹ÿC9H%@©ëƒ‘J	@ùãC‘â*ბh%©j	ùXýÿ—ˆ@¹õ*u4à*íÿÿ}@“Õ°©B
‘ýF“
@’(ykø	€ÒéCÀ9K!›¨B
‘iå9Š€¹KýF“ykøI@’,!›‰õ@9(ASJ*S		€Rh
Jˆõ9	jTs6‰€¹¨B
‘	€Ò*ýF“yjø)@’+!›iá@9(2há9È	¸R	k¡T“6hðÁ‘	ýßÈઠ?Öhð‘	ýßÈÁzäD)E*€Òã#‘ઠ?Ö±aThð‘	ýßÈ ?Ö8”‰€¹¨B
‘	€Ò*ýF“yjø)@’+!›iá@9(há9€@¹x”ÿÿ‰€¹¨B
‘	€Ò*ýF“yjø)@’)!› ù€Rý{Ȩû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¾©ý‘ú*H@“É°8A
‘ýF“@’{wø	€Òôª)#›;@ùâ´ˆÀ9)qT(á@92(á@9j€R

–‹(á9Ÿëõªóªb
T©À9?iqÀT¨‘?5q€Ti9õª<ëbTÀ9)qTI€RH€Ò(€Ò‹i90õªhðA‘	ýßÈ€ÒãS‘"€RáC‘ઠ?Ö@4è@¹4{wø	€Ò)#›	€R*á@9_j@TêCÀ9_)q`T¨€Rh9{wø)#›*é9èCÀ9)q`TúaTH€R"€R€’à*-$”èCÀ9	€Ò)qÀT	€Ò¨€Rh9s‘¿ëC÷ÿT{wø)#›*á@9Š07H2(á9H€Rh9s‘`Ký{¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¾©ý‘ú*H@“É°8A
‘ýF“@’{wø	€Òôª)#›;@ùâ´ˆ@y)qT(á@92(á@9j€R

–‹(á9õªóªŸë‚T©@y?iqà	T¨
‘?5q€TiyõªEëbT@y)qTI€Rˆ€ÒH€Ò‹iy9õªhðA‘	ýßÈ€ÒãS‘B€RáC‘ઠ?Ö`4è@¹(4{wø	€Ò)#›	€R*á@9_jè#@y`T)q€T©€Rè'yiy{wøéCÀ9*#›Ié9{wøéOÀ9+#›ií9{wø)#›H€R(ñ9)q`TúaTH€R"€R!€’à*¨#”è#@y	€Ò)qÀT	€Ò¨€Rhys
‘¿ë#öÿT{wø)#›*á@9Š07H2(á9H€Rhys
‘hË	ýA“ ySý{¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘÷*øªùªúªñþÿ—`5€Rcè~@“É°5A
‘ýF“@’¨ztø	€ÒÊ"›IåÀ9)4à ‹ÑiÀ9iø7óª9ËhÁ‘)S,€R	Éé8)5iÁ‘Ÿq`’Xú£Thþ_8Œ(Éè8Hÿÿ4mÀ9hÁ‘©SÉé8Ë5”H€R¹€;hkaTsB,‹Há@9		€R	j`TMé9k‘Ÿ	qÃT¨ztøiÀ9k‘Ê"›Ií9Ÿ
qÁT¨ztøiÀ9k‘Ê"›Iñ9sA,ËèK}@“"€Rà*0#”sKã*å*äªâª€R ½ŸRä”à5hð‘	ýßÈ ?Ö²”Ðÿÿ¨ztøkxSË"›¨€Riõ@9*
H€RŸI*iõ9ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¼©õ[©÷c©ùùûùý{¾©ý‘ó*³¹öªõ*
1áT©”¹±”(€R¹4³ø7È°QG¹k"Th~@“ýF“É°8A
‘@’	€Ò{wø)#›*á@9ê6°¿kÉT‘”¹™”È€Rà*”€{wø)#›*á@9ê7”(€R¹‚”¹â*áªà*”ô*à*K”à*v”¹~”(€R¹9”€ý{¨û@ùù@ù÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¼©ý‘ö*áùß
1U|@ÓáT\”¹d”(€R¹v!ø7È°QG¹ßkâ TÈ~@“É°:A
‘ýF“@’I{yø
	€Ò
'
›Ká@9«6°¿kÉTD”¹L”È€RùU4+7!ÿÿ´H@ù€Òÿ£©[åÀ9qÀTq!T63”¹;”È€R¹ö”Óô*óªÕþ7¨~Sq‰€R41ˆàªÑ”óª€ÒÆ”€ÒóùÔóµ%”ˆ€R¹”€R»"€R€Òà*j"”H{yø
	€Ò	#
› ùI{yø
'
›		€Rÿ¹÷ªHá@9	j THéÀ9)q„@z Th9(€Rè¹H{yøK€Rs‘”Q	#
›+é9û4H{yø	#
›*íÀ9_)q„@z TH€Rj9è¹H{yøs‘”Qq	#
›+í9áTH{yø	#
›*ñÀ9_)q„@z Th€Rj9è¹H{yøs‘”Q	#
›+ñ9à*2"” 4H{yø		€Ò	#	›*áÀ9
ø6hÐa‘à@ù	ýßÈბ ?Ö 4(€RèC9qÁTiÐ(‘à@ù	ýßÈ€Òãc‘‚~S᪠?Ö5hБ	ýßÈ ?Ö ”ó@ù\é£B)4ÿC9iÐ(A‘à@ù	ýßÈ€Òãs‘â*᪠?Öè@¹q
UzÈTé@¹	H{yø
	€Ò	#
›*áÀ9Š	ø6‰~@“q Tã@ù¤þAÓâ	ªáªà*gþÿ—ô*AèC@9"ýAÓ¨4ì‹éªëªÿë‚T*@y_iq€T_5qAT(	‘ëâT@y)qTJ€Rˆ€ÒH€Ò		‹jyh	‘ëª?ëƒýÿTH{yø
#
›Iá@9(2Há9hË	ýA“4ySáªà*³ýÿ—ÔÿÿhБ	ýßÈ ?ÖqATk”(€R¹^”ó@ù¨€R¹€´qaT€R<”€ó@ùàªö”à*
€RK”¹S”(€R¹”€ý{Ĩû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¿©ý{¾©ý‘óªôª´ù @¹Á”h@ù@¹	|@“*ýF“ÈA
‘)@’	€Òyjø)!›*á@9Š6:”ó*/”(€R¹€€@¹ò”à*ý{¨óSÁ¨À_Öý{½©ý‘à¹1áT”¹”(€R¹ø7ÈQG¹k‚T	|@“ÈA
‘*ýF“)@’yjø	€Ò)!›*á@9J6èS‘à)àC‘èùãc‘⃑ás‘½ÿÿ—÷”¹ÿ”(€R¹º”€ý{èÀ_ÖóS¾©õùý{¿©ý‘ô*Y”±ÕaT€RªªAùŸqaTH!C9¨7Ÿ
qATHB96 €RI”óª@€RF”ëàýÿTà*B”hÐÁ‘	ýßÈ ?Öýÿ5hБ	ýßÈ ?Öó*à*ú”ˆ~@“©B
‘ýF“
@’(ykø	€ÒI!›?á9³4à*£”€€Rý{Á¨õ@ùóS¨À_ÖÿCÑÿÿŸˆèÿ߈ÿC‘Tý{¿©ý‘ñ$@úèT±”È€R¹l”À€Rbµ9øÿÿéªJËHié8(8h4!Ñÿÿµµ9Ÿ”H€R¹Z”@€R€Rý{Á¨À_Öý{¿©ý‘‚”`´À€R‘”¨ð1B¹H6`>Ô`€RIôÿ—À7 6À6°R?k©T €RÀ_Ö°ûÿÿ€RüÿÿóS¼©õ[©÷c©ùùý{½©ý‘óªh@ùõ*wSȵs”Ø€R¹.”••4¨
Q‰qÿÿTáªàC‘àæÿ—y@ù€Rî@ù-‘4À9mùì
ªÈ@ù‰S
ÙixÊ6¬‘´À9íªlùøÿÿŸ¶qè2÷ˆŸ¶qéª`TŸ®qT,‘4À9lùèªØ€Ru4¿BqaT쪈B	S?%qhTˆÂQ
ˆ~	S?eqhTˆ^Qˆþ	S?eqˆÞQIT€h4H€RÀ9‹‘ê€Rkù¨S	aQ?
jàT¿q€Rlѵˆlùí4ˆÀ9
k€T ”¹Ü”l@ùl‘tÀ9lù€R¿qµˆ€U5€>Ô
	ÕK¡ˆB	S?%qhTˆÂQ
ˆ~	S?eqhTˆ^Qˆþ	S?eqˆÞQIT€1@TkTß
kÃTß
k
KziT‰€RÖ"	€Rh@ù7*‘À9lùÜÿÿˆÑhùô4À9k€T唹¡”×7è£@9yù¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ù€R1á*à*Hÿÿ—Sè4Ï”H€R¹w7€è£@9—6¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ù°R¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ù°W6öKè£@9¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ùà*ý{èù@ù÷cB©õ[A©óSĨÀ_ÖóS¾©õùý{¿©ý‘ ´è€’	ÀšëƒT|›)€ÒÕ òDùñ3ˆšhС‘	ýßÈ⪀R ?Ö`µhС‘ôÿ—`4ઔ4 òDù⪈þßÈ€R?ÖÀþÿ´z”ˆ€R¹€Òý{Á¨õ@ùóS¨À_ÖÈÍùÀ_ÖóS½©õ[©÷c©ý{¿©ý‘ôªõªöª÷*øªv”@´ÜAù´hÐ=Aùïª?Öäªã*âªáªàª`?Öý{Á¨÷cB©õ[A©óSèÀ_Ö¨ð	@ùËhÍ@ù*)Ê3-ÊšSýÿµäªã*âªáªàª¦àÿ—€Ò€R€Ò€Ò€ÒÏÿÿhðÁ‘
€RL}@Óˆñ}Ó	ik¸	kàTJ_µq#ÿÿTLQEqhT €R
ðQ9q
€RÉ€R@‘‰‰ñ}Óh‘ ih¸À_Öóøý{¿©ý‘ó*0”€µ¨ðá‘‘à*¹Úÿÿ—ó*&”€µ¨ðÑ‘€‘¹ý{Á¨óAøÀ_Öý{¿©ý‘”€µ¨ðá‘‘ý{Á¨À_Öý{¿©ý‘”€µ¨ðÑ‘€‘ý{Á¨À_Ö€ÒóS¿©ý{½©ý‘ôªóªôµîÿÿ—È€R¹©ÿÿ—€ÒSÿÿ´Ÿë‚ÿÿTáªàC‘[åÿ—ì@ùˆ	@¹h5`Ñ
kÑkÑŸë¨Th@9‹	e@9Iÿ7hË	@’j	Ë@Ñè£@9¨4ê@ùH©C¹	yI©¹ý{èóSÁ¨À_Öý{¿©ý‘£µ µAµ€R
à´Á´cµ9úÿÿ"µ9ºÿÿ—È€R¹uÿÿ—À€Rý{Á¨À_ÖëªéªêªL˱áTˆië8h8¨4)щÿÿµ
ˆië8h8¨4)Ñi´JÑJÿÿµJµ9iûÿµ±¡T‹ñ8
€Rãÿÿ9–ÿÿ—H€R¹Qÿÿ—@€RÜÿÿóS¾©õùý{½©ý‘ó*áªàC‘õ*ô*ÿäÿ—è@ùjSÁ*‹	e@9?jaTÕ4è@ù@ù	Ùjx*

€Rj5€R €Rè£@9¨4ê@ùH©C¹	yI©¹ý{èõ@ùóS¨À_Öá*€Òƒ€R€RÖÿÿóøý{¿©ý‘âª"´ÈñDùhÐÁ‘	ýßÈ€R ?Ö 5hБ	ýßÈ ?Öÿÿ—ó*Qÿÿ—¹ý{Á¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{½©ý‘È‘áùú‚‘|@ÓöªI{yøøª¿;Õ´ð‹@ùji	Ê -Êš±`
T`
µßë	ThÐ	%‘h°
‘é+©k°{a‘ÔF@¸óztø¿;Õ“´±ÀT45ytøRHýßÈ€Òàª?Ö󪳵i°(‘ýßÈ?Ö\qÁThС;‘â€Òàªh”4hÐá;‘â€Òàªb”@4i°(‘ýßÈ€R€Òàª?Öóª€ÒÓµè‹	€’	ýŸÈ¿;Õê‹Hý_ÈSý	ÈÉÿÿ5¿;Õˆ´hÿßÈàª?Ö3µé+A©ßëaøÿT´Ð‹@ù€ÒÓ´h°¡‘á@ù	ýßÈઠ?ÖÀ´Š@ù€RIi	K,ÉšI‹

Ê*ýŸÈ¿;մЋ@ùìÿÿ‹@ùi
€RJ	KI‹€’-ÊšÊ+ýŸÈ¿;Õ€Òý{èû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¿©ý{¿©ý‘hб?‘hÐÁ?‘ôªC‘€€Rlÿÿ—óª3´h°=Aùïª?Ö᪠€’`?Ö ý{Á¨óSÁ¨À_Ö Õ%Àóøý{¿©ý‘hÐ!<‘hÐA<‘C‘€RQÿÿ—óªó´h°=Aùïª?Ö`?Ö €Rý{Á¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘ÿCÑõªhÐ<‘óªô*hС<‘ö*C ‘ €R÷ªø*úªûª.ÿÿ—ùª9´h°=Aùïª?Öè;@ùçªæªå*äªã*èùâªá*ઠ?Ö
€Ràªë”h°¡‘	ýßÈå*äªã*âªá* ?ÖÿC‘ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¿©ý{¿©ý‘hÐá<‘hÐ=‘ôªC ‘`€Rüþÿ—óª´h°=Aùïª?Öàª`?Öh°‘	ýßÈ ?Öý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘hÐA=‘hÐa=‘ó*C ‘€€Ràþÿ—ôª´h°=Aùïª?Öà*€?Öh°a‘	ýßÈà* ?Öý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘hÐ=‘hС=‘ó*C ‘ €RÄþÿ—ôª´h°=Aùïª?Öà*€?Öh°!‘	ýßÈà* ?Öý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘hÐá=‘ó*ôªhÐ>‘C ‘À€R¦þÿ—õª5´h°=Aùïª?Öáªà* ?Öh°A‘	ýßÈáªà* ?Öý{Á¨õ@ùóS¨À_ÖóS¾©õ[©ý{¿©ý‘ö*hÐA>‘óªô*hÐa>‘C ‘@€Rƒþÿ—õªU´h°=Aùïª?Öâ*á*ઠ?Öh°á‘	ýßÈá*ઠ?Öý{Á¨õ[A©óS¨À_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘ÿCÑõªhÐá>‘óªô*hÐ?‘ö*C ‘€€R÷ªø*úªûªVþÿ—ùª9´h°=Aùïª?Öè;@ùçªæªå*äªã*èùâªá*ઠ?Ö
€Rઔh°Á‘	ýßÈå*äªã*âªá* ?ÖÿC‘ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¾©õùý{¿©ý‘hÐA?‘óªõ*hÐa?‘C ‘À€R"þÿ—ôª4´h°=Aùïª?Öá*઀?ÖàªÒ”ý{Á¨õ@ùóS¨À_Ö©ð*	‘¨Ð@ùHA‘L€Ò_ë	€Ò샌š)‘K…ø?ë¡ÿÿT €RÀ_ÖóS¾©õùý{¿©ý‘Sè5¨ð‘i°5a‘t‚‘`†@øÀ´±`T¨þßÈ?Ö‚øëÿÿT €Rý{Á¨õ@ùóS¨À_ÖóS¾©õ[©ý{¾©ý‘€R¿¹€Rï”s€Rµð¶ð³¹È@¹kT¨@ù	ÙsøIµ©ù(@¹¿;Õ5
S4¨@ùÙsøÜ”1`Tˆ¨¹¨@ù	Ùsø Á‘j°H!‘	ýßÈ ?Ö¨@ùÙsø¦ýÿ—¨@ùÙ3ø´@¹sÞÿÿ€Rí”à*ý{¨õ[A©óS¨À_ÖóS¿©ý{¾©ý‘óªôª´ù @ùsáÿ—j@ùh@ù	@ù)´)@¹¿;Õ(5
S¨4(	qaT?rAT	X6h
@ù	@9é5h@ù@ù	@¹¿;Õ(SÈ4h@ù@ù“”1ÀTj@ùH@¹	I¹h@ù	€	¹€@ùSáÿ—ý{¨óSÁ¨À_ÖóS¾©õ[©ý{º©ý‘õªôª´ù @¹†”¨ð@ù©ð(€¹v‹³ùë Th@ù¨ùª@ùÈ´	@¹¿;Õ(5
SH4(	qaT?ráTÉX7H@¹	I¹s"‘ëÿÿª
@ù©@ù¨@ù«c‘«#ù¨'ù©+ùª/ù¨@ù¨ù¨ù£ƒ‘¢‘¡£‘ C‘›ÿÿ—îÿÿ€@¹~”ý{ƨõ[A©óS¨À_Öý{¼©ý‘èS‘àC9èùéC‘èc‘é#©€Rÿÿ)	€Ré£)ãs‘⣑ბàG‘´ÿÿ—èC@9é@¹qè@¹ ˆý{ĨÀ_ÖóS¿©ý{¿©ý‘óªi@¹¿;Õ(	q!T?ràTh.@©KkùŸq¹-TM”a@ùâ*º”Ÿk TjR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ€h@¹¿;Õ	Sè4jR‘Iý_ˆ)yIýˆ¨ÿÿ5¿;Õ€Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘󪓵€R´ÿÿ—àªÉÿÿ—`5h@¹¿;Õ-S¨4ઠ”G”`5€R€ý{Á¨óAøÀ_Ö €RŸÿÿóøý{¿©ý‘óªh@¹¿;Õ5
S4h@¹¿;ÕSˆ4`@ù»üÿ—jR‘(€Iý_ˆ)
Iýˆ¨ÿÿ5¿;Õ~©¹ý{Á¨óAøÀ_ÖóS¼©õ[©÷c©ùùý{¸©ý‘h°‘	ýßÈàC‘ ?Öè§@y¨4è/@ùh´@¹	„R‘Ÿ
@q“²‰à*Q”¨ðQG¹´Â4‹kÁ“Ö4©ð8A
‘h°!‘€Ò	€Ò€†@ø± T±àT©@9©6‰7èþßÈ?Ö 4hþF“{høi@’*!›‰‚_øIù¨@9Há9s‘µ‘ÖQVýÿ5ý{Ȩù@ù÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘¨ðA
‘h°¡‘i°8!‘€R:€’
	€Ò;€R–~@“ÈþF“èzhøÉ@’3!
›i@ù*	‘_ñ©Thâ@92hâ9*{â9ô4Ÿq`T`€@€ €(ÿßÈ?Öõª¨‘ñ‰TÿßÈ?Ö€R 4uù	qThâ@92äÿÿ
q¡Thâ@92ßÿÿhâ@9zù2hâ9¨ð	@ùi´(yvø¹”Ÿq
	€ÒáøÿTý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_Öóøý{¿©ý‘à€R@”€R€RÍ”€5eÿÿ—¤ÿÿ—3€Rà€R]”à*ý{Á¨óAøÀ_ÖóS¿©ý{¿©ý‘¨ðA
‘€Ò`jtø`´ ”j4øs"‘ñCÿÿT €Rý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘€±hTñ(€Ò€šh°¡‘µð òDù	ýßÈ⪀R ?Ö`µh°¡‘Êîÿ—`4àªß”4 òDù⪈þßÈ€R?ÖÀþÿ´<ûÿ—ˆ€R¹€Òý{Á¨õ@ùóS¨À_Öý{¾©ý‘à©A´ ù#€RáC‘€Ò®ùÿ—ý{¨À_ÖóS¾©õùý{½©ý‘óªôªõªô	´Õ	´ˆÀ9ˆ5³	´yKáªàC‘àÿ—é@ù*½ŸR(
@¹
kaT¨Ða‘âªáªàª]”	€q ±€(@ùˆµs´ˆ@9hy €Rè£@9H4ê@ùH©C¹	yI©¹-€@9ác‘1”à4é@ù#	@¹qT¿kKT 
@¹ñåŸäªâª!€Rõ”é@ùÀ5(	@¹¿Â(ëãTˆÀ9¨4 	@¹àÿÿè@ùñåŸäª#€R
@¹âª!€Rã” úÿ5×úÿ—H€R¹€Ñÿÿ¨Ð­ù€Rý{èõ@ùóS¨À_Ö€Ò¡ÿÿóS¾©õùý{¼©ý‘ôªã#yŸñõª¤
@úóª©TS´¹€R7s´€h¹è{@²¿ëéT³úÿ—È€R¹núÿ—À€R+áªàƒ‘#àÿ—è@ù)½ŸR
@¹	k¡Tá#@yâc‘ÿùàªm”S´`¹qmTœúÿ—@¹@ùµè#@yýqÉTŸñ¤@ú©T⪀RઌÓÿ—úÿ—H€R¹@€Rèã@9¨4ê@ùH©C¹	yI©¹ý{Ĩõ@ùóS¨À_Öt´u´ˆ9S´(€Rh¹å*ÿ¹çS‘€Òäª#€RâC‘€Rœ”à4è@¹üÿ5S´`¹€Ràÿÿh‘	ýßÈ ?ÖèqÁúÿTŸñ¤@ú©T⪀RàªZÓÿ—[úÿ—H€R¹úÿ—@€RÍÿÿóS¿©ý{¾©ý‘ôªóª³ù @¹
”ˆ@ù	@ù*E@ùIý_ˆ)Iýˆ¨ÿÿ5¿;Õ`@¹-
”ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘óªôª´ù @¹û”h@ù@ù`J@ùÀ´Î”`J@ù¨Ð½CùëT¨°A
‘ë€T@¹H5<”Jù€@¹

”ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘ôªóª³ù @¹Û”ˆ@ù	@ùŠ@ù!@ù@@ù”`@¹ù”ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘ôªóª³ù @¹Ç”ˆ@ù	@ù E@ù€´ü_ˆQü	ˆ©ÿÿ5¿;ÕÈ5¨°‘ë@Túÿ—`@¹Ü”ý{¨óSÁ¨À_Öý{»©ý‘èc‘àùèù¨€Rè#¹èc‘è#ùˆ€R©€Ré£)¨Ðá‘éÑèù+€Ré'ù‰€R(¹ãƒ‘é/¹h°	A‘è@ùâã‘á“‘àC‘	ùê@ù¨°‘K©¹é@ù(Eùê@ùi€RIyyè@ù	…yè@ùÑùpÿÿ—㣑â‘᳑àC‘¡ÿÿ—ý{ŨÀ_Öóøý{¿©ý‘󪓴”àªQúÿ—ý{Á¨óAøÀ_Öý{¼©ý‘裑ࣩ¨€R蹩€R裑é¹èù‰€Rˆ€Rè§)	@ùh°A‘?ë€Tà	ª9úÿ—à@ù8@ù6úÿ—è@ù-@ù3úÿ—è@ù1@ù0úÿ—è@ù5@ù-úÿ—è@ù%@ù*úÿ—è@ù)@ù'úÿ—è@ù=@ù$úÿ—è@ùA@ù!úÿ—è@ùáAùúÿ—ãS‘âÑác‘àC‘sÿÿ—ãs‘âã‘ბàC‘:ÿÿ—ý{ĨÀ_ÖóS¿©ý{¿©ý‘ôª€J@ùóªÀ´	”¨Ð½Cù€J@ùëT¨°A
‘ë€T@¹H5w”“Jùs´àª5”ý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘h‘	ýßÈ ?Öó*µ° ŠB¹1 T1ûÿ—ôª´´Ÿ±ÁT€Ò ŠB¹€’Dûÿ—`ÿÿ4y€Ò €Ò øÿ—ôª ŠB¹Ôµ€Ò;ûÿ—€ÒÓùÿ—ðÿÿáª6ûÿ—À5 ŠB¹€Ò2ûÿ—àª÷ÿÿàª>ÿÿ—€ÒÆùÿ—h!‘	ýßÈà* ?ÖÔ´àªý{Á¨õ@ùóS¨À_Öˆ÷ÿ—óS¿©ý{¿©ý‘´°€ŠB¹1Tûúÿ—󪓴±@T€ŠB¹€’ûÿ— 4y€Ò €Òkøÿ—󪀊B¹Óµ€Òûÿ—€Òžùÿ—áªûÿ—À5€ŠB¹€Òýúÿ—àª÷ÿÿàª	ÿÿ—€Ò‘ùÿ—³´àªý{Á¨óSÁ¨À_ÖY÷ÿ—óS¾©õùý{¿©ý‘h‘	ýßÈ ?Öó*µ° ŠB¹1 TÇúÿ—ôª´´Ÿ±ÁT€Ò ŠB¹€’Úúÿ—`ÿÿ4y€Ò €Ò6øÿ—ôª ŠB¹Ôµ€ÒÑúÿ—€Òiùÿ—ðÿÿáªÌúÿ—À5 ŠB¹€ÒÈúÿ—àª÷ÿÿàªÔþÿ—€Ò\ùÿ—h!‘	ýßÈà* ?Öàªý{Á¨õ@ùóS¨À_Öý{¿©ý‘a‘^úÿ—¨°‰¹1aT€R»ÿÿ—€µ€R”úÿÿ €Rý{Á¨À_Öóøý{¿©ý‘³°`ŠB¹1€Tcúÿ—€hŠ¹ €Rý{Á¨óAøÀ_Öóøý{¿©ý‘óª¨Ð½Cùi@ù?ëT¨°áI¹	¨C¹?jaT`”`ùý{Á¨óAøÀ_Öóøý{¿©ý‘óª¨ÐÉCùi@ù?ëT¨°áI¹	¨C¹?jaTΔ`ùý{Á¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{½©ý‘ÿCÑóªáK@ùõª9¿qàƒ‘÷ªøªùªÖSú*´ ŸÎÝÿ—ˆ.ÿÂ(ëèTRøÿ—H€R¹
øÿ—@€R±ª@ùHùtÓýñaTè›@¹ç*ÿù€Rå*äªãªè¹âªáªàª¯”`49ž¡€Ràª[*” ´È	R*iSKA99’ªø¶¨€Rh9ª@ùs‘ÈRIS6ø€Òy‘_)Lò€RáT{9¨@ùÉ€ÒÍ@ò8Ÿš(€Rh9w‘s
‘t5€Rè@ù}@ù	@ù(À9(9¨@ù	Í@’I´€RáàÒŸqmT¨@ù	Š+Í@’h%š	=S+Áj=S_åqiTH
=SHQj9=s‘!üDÓ”Q¢ýÿ6bø7ã›@¹àª”SÈ4kÑí€RlÀ9ˆS	Q?
jaT{õ8úÿÿëTŸåqÈê@Tˆ	i9hñß8hñ8ŸqÍTâ*€RàªÓÐÿ—sB4‹èÀ9­€RqHkSk™š	Ai9ª@ùl	‘HùtÓ	ËË?ñ*¡ˆš?ñh€R¨±ˆh9_¡ñ›9ëªT	}€ÒH
Éš‹‘
©	›	Á‰9ëaT_‘ñT‰€ÒH
Éš
©	›	Ái9k‘ëD	JúTI€ÒH
Éš
©	›	Ái9k‘H	Ái99€Rèã@9¨4ê@ùH©C¹	yI©¹ÿC‘ý{èû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS½©õ[©÷ùý{¾©ý‘ô*ˆ
ëª
‘`@ý_ëõªóªâªC1„šáC‘€ÖS÷*”è@¹å[@¹ä*ãC‘‚µq럚Ÿqêןš¨
Ë	ËH‹¿±‹¡‰š£”`49
ç+@ù€RåC‘ä*ã*â*áªàª”ý{¨÷@ùõ[A©óSèÀ_ÖóS¼©õ[©÷c©ùk©ý{½©ý‘ó*qhŸ	%øªÃ)ëôªwSù*õªÖSˆTF÷ÿ—H€R¹÷ÿ—@€Rý{èùkC©÷cB©õ[A©óSĨÀ_ÖáªàC‘±Üÿ—64¨@¹µq韚*‹qmTHÀ9é
ªh4(À8èÿÿ5(
Ë‘á
ª@‘¾Ðÿ—¨@¹ëªº€RµqaTš9‹‘q
ThÀ9é@ùh9(}@ù	@ù*À9j8È@Ò	Á3‹±3‹ŠËH‹i°"±‘ˆšàªWõÿ— 5`
‘w4¨€Rh9¨@ù	À9?Áq T¨@¹
Qmø6í
Kz9¿‘qkT¨}(›	ý`Óh
À9+}l}K‰€Rµ	h
9¿)qkT¨¨}(›	ý`ÓhÀ9+}l}Kh9ˆ	­KhÀ9
h9?qáTÀ9ÁqTb€Ò‘rÐÿ—è£@9¨4ê@ùH©C¹	yI©¹€R“ÿÿ€Ò€R€Ò€Ò€Ò0×ÿ— Õ…ëQgfffóS½©õ[©÷c©ý{½©ý‘óªàC‘áªö*õª—S7Üÿ—ª@¹€Rw4HQkT¨@¹µq韚*Á*‹H‹_i38ñ8¨@¹µqT¨€Rh9s‘¨@¹q,TÈ5¨@ù	À9(€R?Áq@T€R—4h4t‘hÀ9éªh4(À8èÿÿ5(Ët‘‘àªáª)Ðÿ—x9tÂ(‹ßqÍTˆÀ9éªh4(À8èÿÿ5(ˑ᪀‘Ðÿ—è@ù“‘}@ù	@ù*À9Š9¨@¹ˆø6èKÿq
VzÔ¢ˆt4hÀ9éªh4(À8èÿÿ5(Ë`Â4‹‘áªÐÿ—‚~@“€RàªgÏÿ—è£@9¨4ê@ùH©C¹	yI©¹€Rý{è÷cB©õ[A©óSèÀ_ÖóS¼©õ[©÷c©ùùý{¾©ý‘èª@ýöªõ*ôªâªéC‘ãª?}©áC‘à*ØSù*Ñ”è@¹åc@¹ä*ãC‘â*µqè@¹éŸš3‹ß±QÈ	ËÁˆšàªr”`4Ÿ9è@¹	Q?1$¡UzÊTÿ	kŠThÀ8èÿÿ5â8å7@ù$€RãC‘â*áªàª\ÿÿ—
ç7@ù&€RåC‘ä*ã*â*áªàªÄþÿ—ý{¨ù@ù÷cB©õ[A©óSĨÀ_Öý{¿©ý‘)S(‘ê*ëઢT9€€Rý{Á¨À_Öé4¨€R9±8@TcшS	R-ySNQo°é‘«	‹,ykøˆÀ9êªh4HÀ8èÿÿ5HËë臟	
+	‹è‘áªykø6ôÿ—`5€Rßÿÿ€Ò€R€Ò€Ò€ÒEÖÿ—óS¾©ö_©ý{¿©ý‘ôªˆ@ùöªW<	Š*Í@’K%ךs=Sƒ5"qà7Ÿ*씀5‹@ùhŠ	Í@’*%ךL=SŸ!qiT €R£T(€Ò!ך	Ñ*Š_Í@òÿÿTÿÂqÀTÈKŠ	½@’*%ךKS)LòëŸ`
q¡T34ˆ@ùèø·çÿÿqTs4ˆ@ùHüÿ·€Rý{Á¨ö_A©óS¨À_ÖóS¾©õ[©ý{¾©ý‘ÿCÑíªóªôªëªõ*óµ™õÿ—È€R¹Tõÿ—À€RwTÿÿ´+ÿÿ´ÿÿ´¿q T¨Q	q€RHT&€RG7¬@ùˆùtÓýñÁTˆÍ@òaT €RÌø¶	àÒ	ëaT€€RˆýsÓê(*K`2ˆýÓSä*ãªâª]ÿÿ—SèDÓ2è[@¹ÿ{òŸ¿„qlT¨Qyr T¿q T¿qè+@ùç*ö¹å*ãªâªáªèùà
ªîüÿ—:¿”qÀT¿˜q€Tè+@ùç*ö¹å*ãªâªáªèùà
ªíþÿ—+ @ý胑ãª}©âªáƒ‘à*È”è#@¹å*ä*パµqè'@¹éŸšŸ± ‹ˆ	ˈšk”`49å+@ù€Rパâ*áªàª_þÿ—è+@ùç*ö¹å*ãªâªáªèùà
ªýÿ—ÿC‘ý{¨õ[A©óS¨À_Öý{¿©ý‘àµõÿ—È€R¹Ðôÿ—€@¹¿;Õý{Á¨À_Ö(@¹	Q)¹Iø6š(@ù9)@ùS*‘*ùÀ_Ö¨@ù©°)±Cù
@²?
ëàŸÀ_Öóøý{¿©ý‘óª@€RKÙÿ—ë`T €RGÙÿ—ë¡TàªÑÿÿ—8”`5€R €Rý{Á¨óAøÀ_ÖóS¿©ý{¿©ý‘óªæÿÿ—Sh4 €R2Ùÿ—ëT¨°¡‘@€R+Ùÿ—ëT¨°Á‘ª°H@¹	I¹j@¹¿;Õ˜€R_j¡TjR‘KP€RIý_ˆ)*Iýˆ¨ÿÿ5¿;Õˆ@ù赂Ò]ùÿ—€ù€ÒRõÿ—ˆ@ù €Rµhr‘hùI€Rhùi¹i"¹hù	‚Rˆ@ùùÿÿ€Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘Sóª4h@¹¿;Õ%	Sˆ4àª!øÿ—jR‘P€Iý_ˆ)
Iýˆ¨ÿÿ5¿;Õ"¹~©ý{Á¨óAøÀ_Öý{¾©óS©ý‘UÍÿ—ÿÃÑó*ô*áªà#‘ùÙÿ—hqÈTè@ù@ù	Ùsx 
ë@ùj~ISh@ù	ÙéxÉø6ê9C€Ró9ÿ9ó9#€Rÿ9裑¹&€R	ye
@¹ä£‘â‘!€RàC‘É	”`5€RèS@y
èƒ@9¨4ê@ùH©C¹	yI©¹ÿÑ*Íÿ—óSA©ý{¨À_ÖëbT€ëà—ŸÀ_ÖóS¾©õù÷ùý{¿©ý‘ôªóª÷*4µh¢@9ˆ4`
@ùØôÿ—¢9~©ùRˆ@y5h@ùhµh¢@9ˆ4`
@ùÌôÿ—¢9 €ÒÑøÿ—ˆ€Rñ`
ùŸq韚qèŸh¢9iù 5h
@ù9æÿÿ€Ò€Ò€R€Ò€âª€Rà*B”|@“5µHð‘	ýßÈ ?Öíóÿ—ôÿ—@¹'i@ù¿	ëiTh¢@9ˆ4`
@ù¡ôÿ—¢9દøÿ—ˆ€Rñ`
ùŸq©ŸšqèŸh¢9iù@5d
@ùå	*€Ò€Ò€âª€Rà*”|@“ˆµIð(‘ØÿÿÑhù€Rý{Á¨÷@ùõ@ùóS¨À_ÖóS»©õ[©÷c©ùk©û#ùý{¼©ý‘öªøªøµÖóÿ—È€R¹‘óÿ—À€Rqù€ÒÈ@ùÿ©€ÒÿùH´S€Rõ€RáC‘óC9àªõG9ÿK9¼”È@ùàµãƒ‘€Ò€Òàªi”áªàªâƒ‘È”ô*t5ÈŽ@øhýÿµóWB©©Ë(ýC“‘(‘ëª	ýCÓë탉š€Ò€Ò­´j…@øHÀ9é
ªh4(À8èÿÿ5(
Ë‹Œ‘‘Ÿ
ë¡þÿT"€Òáªàª¤ãÿ—öª¶µ€ óWB© Ú‹ôªŸë÷ªàTÛË‚@ùHÀ9éªh4(À8èÿÿ5(Ë‘IËèùãª!‹àª´óÿ—@5è@ùwk4ø”"‘Ÿë‹ýÿTù€R€Ò
ôÿ—öª¨Ë	‘*ýCÓßëõƒŠš€ÒÕ´À†@øôÿ—÷‘ÿëÿÿTàªþóÿ—à*ý{Ĩû#@ùùkC©÷cB©õ[A©óSŨÀ_Ö€Ò€R€Ò€Ò€Ò¶Óÿ—óS¼©õ[©÷c©ùùý{¿©ý‘öªÈÀ9éªùªôªóªh4(À8èÿÿ5(Ë‘è4ªÿë	T€€Rý{Á¨ù@ù÷cB©õ[A©óSĨÀ_Öè‹‘àª!€Ò•òÿ—õªô´ãªâªáªàªdóÿ—à5Ëãªâª ‹^óÿ— 5i¢@©?ëT`@ù€µ€Ò€€Òòÿ—`ù€Ò¶óÿ—i@ù	´(‘i¢©ËýC“	ð’Ÿ	ëT–úÓ᪀Ò"
”@µ€Ò¥óÿ—ણóÿ—“€R€Ò óÿ—à*Åÿÿ‹`"©	‹€Òi
ù˜óÿ—i@ù5ùh@ù	!‘iù€Rðÿÿ€Ò€R€Ò€Ò€ÒQÓÿ—ý{»©óS©õ[©÷c©ù#ùý‘¶Ëÿ—ÿÃÑôªàªöª³XÀ9½Q	S?µqhTi&ÈšÉ7áªàªâòÿ—ë¡þÿT	À9?éqATˆ‘ëàT㪀ҀÒàªyÿÿ—¬(½Q	S?µq¨Th&Èšh6)€R	€RËÿ©?qÿ©à‘ÿKù€Òÿc9ùˆš/Øÿ—è@ù)½ŸR
@¹	k!Tèc@9¨4ê@ùH©C¹	yI©¹"½ŸRôÿ—èc@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáÑઽéÿ—èC@ù€Rq€Ò€RàˆšHБ	ýßÈ⃑€R ?Öøª±T㪀ҀÒàª1ÿÿ—ó*^È&@©)Ë7ýC“€Òÿ©àƒ‘ÿ©ÿ3ùÿ£9ï×ÿ—è@ù)½ŸR
@¹	k!Tèã@9¨4ê@ùH©C¹	yI©¹"½ŸRÃóÿ—èã@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€Rá‘à3‘þÿ—õ+@ùqà•šÀ9¹qáTÀ9h4¹qaTÀ9è4ãªâªáªõþÿ—ó*35è£A9h4àªÝòÿ—HÐ!‘	ýßÈბઠ?Ö ÷ÿ5Ê"@©	
Ë+ýC“ÿëàTèÿÿð!.‘@
‹aË€Ò#”€Rè£A9h4àªÅòÿ—HÐá‘	ýßÈઠ?ÖècB9h4àC@ù¼òÿ—à*ÿÑóÊÿ—ù#@ù÷cC©õ[B©óSA©ý{ŨÀ_Ö 4þÿóS¾©öùý{¿©ý‘ôªóªö*ôµh¢@9H4¢9~©ù8ˆ@y5h@ùhµh¢@9H4¢9ýñÿ—H€R¹@€R¢9ù+h
@ù9îÿÿ€Ò€Ò€R€Ò€âª€Rà*”	|@“)µHБ	ýßÈ ?ÖÂñÿ—ãñÿ—@¹h@ù?ëÈûÿTd
@ùå*€Ò€Ò€âª€Rà*”|@“ˆµIÐ(‘êÿÿÑhù€Rý{Á¨ö@ùóS¨À_Öý{¾©óS©ý‘“Êÿ—ÿƒ	ÑHÐá‘	ýßÈóªT|@Ó¢ €RáC‘ ?Ö5HБ	ýßÈ ?Ö”ñÿ—€R)€ÒóS©à‘óS©ÿ#ùÿ#9%×ÿ—è@ù)½ŸR
@¹	k!Tèc@9¨4ê@ùH©C¹	yI©¹"½ŸRùòÿ—èc@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RბàC‘{ÿÿ—à#@ùÿƒ	‘`Êÿ—óSA©ý{¨À_ÖóS¾©õ[©ý{¾©ý‘ôªöª¶ù @¹B”ˆ@ù	@ù*E@ùAa‘¨‘ @ù ´¡´" €R	Ëÿ—Ó€R" €Ò€RlÊÿ—mñÿ—Ó€R¹(ñÿ—ˆ@ù	@ù*E@ùLe‘«@ù‹´ì´Š‘ˆ%Á¨h%¨Ÿ
ë¡ÿÿTh‘}¨ëÁÿÿTXñÿ—¹ñÿ—ˆ@ù	@ù*@ùHý_ˆQHý	ˆ©ÿÿ5¿;Õ(5ˆ@ù	@ù @ùˆð‘ë@Táñÿ—ˆ@ù@ù‰@ù*@ùhE@ùHù‰@ù*@ùKE@ùiý_ˆ)iýˆ¨ÿÿ5¿;ÕÀ@¹”ý{¨õ[A©óS¨À_ÖqT q`TÔqÀThÁ‘Øqàˆš	h‘hA‘h‘À_Öóøý{½©ý‘ó*àC‘€ÒŽÖÿ—©?™¹
1ÁT(€R(™¹IÐ(‘1!T(€R(™¹IÐ(a‘	ýßÈ ?Öó*1¡T(€R(™¹è@ù
@¹è£@9¨4ê@ùH©C¹	yI©¹à*ý{èóAøÀ_ÖóS¿©ý{¿©ý‘ôª“b‘àª" €R€RèÉÿ—ˆð‘ha‘ŸBøŸù) €RŸÂø
ËŸ¹His8)Qh8©ÿÿ5‰f‘he‘	Ë
 €Rhii8JQ(8ªÿÿ5ý{Á¨óSÁ¨À_Öý{¾©óùý‘›Éÿ—ÿƒÑóª`@¹(½ŸRkÀ
THС‘	ýßÈáC‘ ?Ö
4€R飑(8q£ÿÿT€Rè[@9ë£9é[‘ˆ4죑*@9q¢T‹I(8
kiÿÿT(-@8èþÿ5e@¹€Rä£‘ €R⣑!€R€Ò”g@¹ €RaAù壑ÿ¹ €R㣑 €R€Ò”g@¹ €RaAù壑ÿ¹ €R㣑@€R€Òw”of‘,€Rî£‘
€Ò
 €R磑棑É%@xé6iB,‹Kig8(a@92(a9	é6iB,‹Kif8(a@92(a9€RKi/8ŒJ‘­Qýÿ5 €Ò€R
 €Rh…QeqTh}QjB(‹nSIa@9(2Ha9
hQeq(Th}QjB(‹Ia@9(2iHa9.S€Rh‹e9kŒ‘­Q­üÿ5ÿƒ‘'Éÿ—ó@ùý{¨À_ÖóS¾©õ[©ý{¼©ý‘ó*â©6SáªàªS”à*%ÿÿ—è@ùô*E@ù	@¹Ÿ	kaT€RE€ÒÛôÿ—õªóªõ´è@ùE€RE@ùÆÉÿ—ᪿ¹à*’”ô*Ÿ1T(ðÿ—È€R¹€àª¿ðÿ—à*ý{Ĩõ[A©óS¨À_ÖV5hãÿ—è@ù
E@ùHý_ˆQHý	ˆ©ÿÿ5¿;Õ5è@ùE@ù‰ð(‘ë@T©ðÿ—(€R¨¹è@ù€ÒEùé@ùˆðáI¹*©C¹_jÁûÿT胑飑è'©¨€R©€Rè§)ãS‘âÑác‘àC‘qþÿ—Vúÿ4è@ù	@ùŠðIùùÍÿÿóS¾©õùý{¿©ý‘ôªõª‰ªC¹ˆðáI¹?j TˆJ@ùh´“F@ù €R¤”“F@ù¨@ùë T³´hþ_ˆQhþ	ˆ©ÿÿ5¿;Õè5ˆð‘ë`Tàªkðÿ—³@ù“Fùiþ_ˆ)iþˆ¨ÿÿ5¿;Õ €R°”Ó´àªý{Á¨õ@ùóS¨À_Ö)îÿ—óS¿©ý{¿©ý‘´ˆr^9h5¨‘‰ð(‘h
ù‰ð)‘ˆðÁ‘h&©’öÿ—âª@€cB‘!€R]ÿÿ—(€Rˆr9 €Rý{Á¨óSÁ¨À_Öý{¿©ý‘Höÿ—¨A‘­ÿÿ—ý{Á¨À_Öý{¼©óS©õ[©÷ùý‘cÈÿ—ÿCÑóªvþÿ—ô*4ˆðA!‘
€R€ÒU}@Ó¨~›	iv¸?k@
TJ_q#ÿÿT½ŸRŸk@	THÐA‘	ýßÈ€>S ?Ö€4(½ŸRŸkaTh¹ù¹:y
¹Âø¹àªŸþÿ—pHС‘	ýßÈá‘à* ?Ö 4ub‘àª" €R€R`Èÿ—è@¹t¹ù	qTè@9é‘(4(@9è4+@9kHTKj¨Jj8kQ2¨J*8Jkÿÿ5(-@8(þÿ5)€R)¨Ji8?ýq2¨J)8cÿÿT`@¹þÿ—)€R`ù	€Ri
¹Éÿÿ¨™G¹5€9wb‘àª" €R€R/Èÿ—ˆÐ!‘€ÒŽ€RÆ€ÒÏB‘¨2›ë
‹j@9j4h@9(4_k¨TM¿qBTèJm8J‰ig8(*èJ-8h@9­_kÉþÿTj-@8êýÿ5Œ‘ÎQýÿ5(€Rt¢)à*Þýÿ—
€Ò`ùl2‘Ë€R€ÒÍ‘¨*›kQJ‘©yhx‰%xkÿÿ5‘ÿÿàª
þÿ—€RÿC‘ÒÇÿ—÷@ùõ[B©óSA©ý{ĨÀ_Ö¨†˜RkˆTˆ…˜RK%qˆTéT€R(%Èh7¨qaT€RÓšRk T(Õ›RkiThÖ›RkÉþÿT½ŸRk`þÿT(½ŸRkAT!H°Á‘	ýßÈ Ö½ŸRKq¨†˜R釟kHTˆ…˜RK%qˆTêT€RH%Ȉ7¨qÓšRkàT(Õ›RkIThÖ›Rk)T½ŸRkÀT(½ŸRk`T!x€R?q臚?q憚i4G´ÿ¹çªH°á‘	ýßÈ ÖóS½©õ[©÷ùý{¿©ý‘H°‘	ýßÈ ?ÖõªU´¨@y몈4éª=h4(-Àxèÿÿ5(Ë	ýA“*‘k
‹h@yÈþÿ5hË		‘7ýA“ã*€Ò€Ò€R€Ò⪀R€R®ÿÿ—|@“Ö´àª"óÿ—ôªóª´´å*€Ò€Òäªã*⪀R€Ržÿÿ—`4€Ò€Òàªïÿ—€ÒÕ´H°!‘	ýßÈઠ?Öàªý{Á¨÷@ùõ[A©óSèÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘öªù*ÖµRîÿ—È€R¹€ª¡€Ràªóªþ ”øªñVú`T›ðt—@ùÀ9—ðè¢@ùŸë¡Tધ”ôªt—ù”µ•ðÙ4¨š@ùˆ´ßÿ— ´t—@ùè¢@ùŸëATઘ”ôªt—ùº4€Ò €Ò‰íÿ—`—ù€ÒÀîÿ—t—@ùT´¨š@ùHµ€Ò €Òíÿ— šù€Ò¶îÿ—¨š@ù´t—@ùÔ
´ˆ@ùËõª´âªáªàª(”À5¨@ù	i÷8?õq$@z`T¨Ž@øôÿÿ¨ËýC“¨ËõˆËuø·ˆ@ù(´€zuø˜îÿ—z5ˆzuø´‰‹(@ùµ‘(ù‰‹(@ùhÿÿµ€Òáªàª”ôª€Ò‡îÿ—´€Ò–z5ø4õË¡
‘?ë#Tü’?ëÂT€Òàªñ”ôª€Òtîÿ—ô´ˆ‹€Ò}©t—ù¹4ÈÀ9éªh4(À8èÿÿ54Ë€
‘!€Ò+íÿ—õªuµ€Râª
‘àªìÿ—`5¨Ë	‹*‘_q_ñ8ኚઔ5¶íÿ—H€R¹€àªMîÿ—	àªJîÿ—€R«íÿ—È€R¹€àªBîÿ—à*ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_Ö€Ò€R€Ò€Ò€ÒúÍÿ—óS¾©õ[©ý{¿©ý‘óªÓµ€Òý{Á¨õ[A©óS¨À_Öh@ù	€Òꪈ´H@ø)‘Èÿÿµ€Ò ‘äìÿ—ôªT´i@ùÉ´–Ë(À9ê	ªh4HÀ8èÿÿ5U	Ë ‘!€ÒÖìÿ—Àj3ø€Ò
îÿ—Àjsø ´b@ù¡‘¶ëÿ—à5iŽ@ø©ýÿµ€Òîÿ—àªÖÿÿ€Ò€R€Ò€Ò€ÒÁÍÿ—Èëÿ—ÿÿóS¾©õ[©ý{¿©ý‘ˆð‘€R•ð€Òh~@ÓQ›€RôRqïÿ— 4¨ÒI¹s:q	©Ò	¹£þÿT €R€R”€Rý{Á¨õ[A©óS¨À_Öˆð‘	|@“
€Ò !
›J°IÁ‘(ýßÈÖóS½©õ[©÷ùý{¿©ý‘–ðÓÒI¹Ó4ˆð‘H°!‘€ÒsQ©þßÈ`R› ?ÖÈÒI¹	QÉÒ	¹3ÿÿ5 €Rý{Á¨÷@ùõ[A©óSèÀ_Öˆð‘	|@“
€Ò !
›J°Iá‘(ýßÈÖý{¾©ý‘èªÿ¹	1@ù*@ùK	@¹ëø7àC‘Aîÿ—è@¹€Rq@T €Rý{¨À_ÖóS½©õ[©÷c©ý{¿©ý‘	€Ò€ÒUìÿ—óªsµ€Ò @‚Òt‹ë€Tu‘W€R€’¶ÂÑ઀RôRïÿ—¸‚ø
€R¿†ø¨R\8¿x·"8·28·B8¨R8ÈÂ*‹Iê	*ù9?qcÿÿT¨ÂÑë!ýÿT€Òjíÿ—àªý{Á¨÷cB©õ[A©óSèÀ_ÖóS¾©õ[©ý{¿©ý‘óª´@‚Òt‹ëõª TH°!‘ÈþßÈàª?Öµ"‘¿ëaÿÿTàªNíÿ—ý{Á¨õ[A©óS¨À_ÖóS½©õ[©÷c©ý{¾©ý‘õ*¿
@qcT¤ìÿ—(€R¹_ìÿ— €Rý{¨÷cB©õ[A©óSèÀ_Ö€Rà€R\ÿÿ—€Ò¿ù˜ð—ðéRG¹¿	k+TC
‘ÈzsøH´’ÿÿ—Àz3øÀµ”€Rà€Rqÿÿ—à*æÿÿèRG¹	éR¹s‘³ùíÿÿ	|@“ˆðA
‘*ýF“)@’yjø	€Ò !›K°iÁ‘(ýßÈÖóS½©õ[©÷c©ý{¿©ý‘ó*ôªóø7ˆðQG¹kbTh~@“‰ð6A
‘ýF“@’Èzuø	€Òé"›*@ù_±TÛÿ—qT34q T
qaT`€@€ €H°a‘	ýßÈ᪠?ÖÈzuø€Ré"›4ùDìÿ—(€R¹7ìÿ—¹€ý{Á¨÷cB©õ[A©óSèÀ_Ö	|@“ˆðA
‘*ýF“)@’yjø	€Ò !›K°iá‘(ýßÈÖóS½©õ[©÷c©ý{¾©ý‘à€Rêþÿ—€µ¹€R¿¹˜ðqŠTC
‘–Úsø6µ!ÿÿ—€Ú3øÀ´ŠðHQG¹	IQ¹ufSà*”ÿÿ—¨~@“
ýF“	C
‘+yjø(€Rhá9à€Rôþÿ—à*ý{¨÷cB©õ[A©óSèÀ_Ö@‚Ò׋ôª´ùŸë Tˆâ@9H6àªH°Á‘	ýßÈ ?Öˆâ@9(6àªH°á‘	ýßÈ ?Öµ@¹”"‘ìÿÿˆË		€Ò
Éš¨~@“ýF“
C
‘@’
	€ÒHyløi!
›(€R(á9Hyløi!
›
€’-ùÏÿÿs³¹·ÿÿóS½©õ[©÷ùý{¿©ý‘ó*Sø7ˆðQG¹kÂTh~@“‰ð5A
‘ýF“@’¨ztø	€ÒÊ"›Iá@9‰6H@ù± TÛÿ—qT34q T
qaT`€@€ €H°a‘	ýßÈ€Ò ?Ö¨ztø
€’€RÉ"›*ù¦ëÿ—(€R¹™ëÿ—¹€ý{Á¨÷@ùõ[A©óSèÀ_Öý{¿©ý‘1áTŒëÿ—¹”ëÿ—(€R¹ ø7ˆðQG¹k¢T	|@“ˆðA
‘*ýF“)@’yjø	€Ò+!›iá@9i6`@ùuëÿ—¹}ëÿ—(€R¹8ëÿ—€’ý{Á¨À_ÖŠðHÕI¹	ˆR€Rq(ˆHÕ	¹À_ÖóS¿©ý{¿©ý‘󪓴ˆÐ%‘`@ùˆ@ùë@Tÿëÿ—`@ùˆ@ùë@Túëÿ—`@ùˆ@ùë@Tõëÿ—`@ùˆ@ùë@Tðëÿ—`@ùˆ@ùë@Tëëÿ—`"@ùˆ"@ùë@Tæëÿ—`&@ùˆ&@ùë@Táëÿ—`6@ùˆ6@ùë@TÜëÿ—`:@ùˆ:@ùë@T×ëÿ—`>@ùˆ>@ùë@TÒëÿ—`B@ùˆB@ùë@TÍëÿ—`F@ùˆF@ùë@TÈëÿ—`J@ùˆJ@ùë@TÃëÿ—ý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘󪓴ˆ°%‘`@ùˆ@ùë@T³ëÿ—`@ùˆ@ùë@T®ëÿ—`
@ùˆ
@ùë@T©ëÿ—`.@ùˆ.@ùë@T¤ëÿ—`2@ùˆ2@ùë@TŸëÿ—ý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘ôª‰‹(ð@’€ÒŸ	ëõƒˆšÕ´€†@øŽëÿ—s‘ëÿÿTý{Á¨õ@ùóS¨À_Öóøý{¿©ý‘󪓴á€Òæÿÿ—á€Ò`â‘ãÿÿ—€Ò`‘àÿÿ—€Ò`B‘Ýÿÿ—A€Ò`‘Úÿÿ—`¢@ùrëÿ—`¦@ùpëÿ—`ª@ùnëÿ—á€Ò`‚‘Ñÿÿ—á€Ò`b‘Îÿÿ—€Ò`B‘Ëÿÿ—€Ò`‘Èÿÿ—A€Ò`B
‘Åÿÿ—`RAù]ëÿ—`VAù[ëÿ—`ZAùYëÿ—`^AùWëÿ—ý{Á¨óAøÀ_Öý{¾©ý‘\ñÿ—áC‘H@ùèùòÿ—è@ù@ùý{¨À_Öbµ€RIÑI´
@y
4(@y_k¡T‘!‘)Ñ	ÿÿµ	@y(@y KÀ_Öý{º©óS©õ[©÷c©ùk©û+ùý‘_Ãÿ—ÿƒÑú‘ù*áªàª÷ªø*ûªô*ó*þÏÿ—t5H@ù
@¹q)€R(€R!ˆ€R€Òã*âªà*ƒûÿ—ö*v5€R;Õ~@“¨úÓ	A‘?ë Ÿš ´ñˆT<‘ëLTèß|²ýDÓ­Åÿ—ÿs/Ëó‘s´ˆ™™Rïÿ—óªÓ´¨»›Rh¹sB‘€Òó´¢úÓ€RàªSÃÿ—å*äªã*âª!€Rà*Xûÿ—`4H‘	ýßÈâ*ãªáªà* ?Öô*€Ró´h_¸©»›R	kaT`BÑ×êÿ—Hc@9¨4J@ùH©C¹	yI©¹à*_‘ÿƒ‘Ãÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Ö
@‘Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
p@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
x@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
t@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
€@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õˆ°
á‘
à‘Ë€RH_ø
ëTL@ùÌ´‰ý_ˆ)‰ýˆ¨ÿÿ5¿;ÕH^ø´L_øÌ´‰ý_ˆ)‰ýˆ¨ÿÿ5¿;ÕJ‘kQkýÿ5@ùUóS½©õ[©÷ùý{¿©ý‘óªi~@ùi´ˆ°%‘?ëàThr@ù¨´@¹h5`z@ùÀ´@¹ˆ5rêÿ—`~@ùfþÿ—`v@ùÀ´@¹ˆ5kêÿ—`~@ù«þÿ—`r@ùgêÿ—`~@ùeêÿ—h‚@ùÈ´@¹ˆ5h†@ùùÑ^êÿ—hŠ@ùÑ[êÿ—hŽ@ùÑXêÿ—`‚@ùVêÿ—`’@ù2”ˆ°á‘v¢‘tâ‘Õ€Rˆ_øëT€@ùÀ´@¹ˆ5Gêÿ—À@ùEêÿ—ˆ‚^øÈ´€‚_ø€´@¹H5>êÿ—Ö"‘”‚‘µQ•ýÿ5àª8êÿ—ý{Á¨÷@ùõ[A©óSèÀ_Ö ´HБë T
p‘Hý_ˆHý	ˆ©ÿÿ5¿;Õà*°À_Öóøý{¿©ý‘óªs´HБëàTh^A¹¿;Õˆ5þÿ—àªêÿ—ý{Á¨óAøÀ_Ö ´HБë T
p‘Hý_ˆQHý	ˆ©ÿÿ5¿;Õà*°À_Öà´
@‘Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
p@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
x@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
t@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
€@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õˆ°
á‘
à‘Ë€RH_ø
ëTL@ùÌ´‰ý_ˆ)Q‰ýˆ¨ÿÿ5¿;ÕH^ø´L_øÌ´‰ý_ˆ)Q‰ýˆ¨ÿÿ5¿;ÕJ‘kQkýÿ5@ù²ÿÿÀ_ÖóS¿©ý{¿©ý‘Éïÿ—ôª‰ªC¹ˆ°áI¹?j`T“J@ùSµ€€RÛûÿ—ˆÐ½Cù€B‘”󪀀Rúûÿ—³´àªý{Á¨óSÁ¨À_Ötçÿ—óS¿©ý{¿©ý‘óªÓ´ ´@ùŸëaTàªùàªÓþÿ—tÿÿ´àª”ÿÿ—ˆ@¹èþÿ5ˆ°A
‘Ÿë`þÿTàªÿÿ—ðÿÿ€Òý{Á¨óSÁ¨À_ÖóS¾©õ[©ý{¿©ý‘ôªõªöªU´è€’	ÕšëÂTÞèÿ—ˆ€R¹€Ò´´àª·”óª€Òµ~›àªáªÄ”ôªŸñnUú¢T¢Ë€R€‹ÆÁÿ—àªý{Á¨õ[A©óS¨À_Öý{¿©ý‘H¡‘	ýßÈ ?ÖˆÐñùñàŸý{Á¨À_ÖˆÐñù €RÀ_ÖóS½©õ[©÷ùý{¿©ý‘ôªõªŸë@TóªWv@ùö´è>Aùïª?ÖÀ?ÖSˆ4sB‘ëÁþÿTë`TëàTs"Ñh‚_ø´u@ùÕ´è>Aùïª?Ö€R ?ÖsBÑh"‘ëþÿT€R €Rý{Á¨÷@ùõ[A©óSèÀ_ÖóS¾©õ[©ý{¿©ý‘ôªóªŸë€TVu‚_øÕ´È>Aùïª?Ö€R ?ÖsBÑëáþÿT €Rý{Á¨õ[A©óS¨À_ÖˆÐõùÀ_ÖóS¿©ý{¿©ý‘ôª”óªS´H=Aùïª?Öàª`?Ö`4 €R€Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘€Rûÿ—ˆ°	@ù+ŠÐHõDù*ÊS-Ëš€R/ûÿ—àªý{Á¨óAøÀ_ÖóS¿©ý{¾©ý‘óª³ù @¹þúÿ—ˆ°	@ù+ŠÐHEù*ÊT-Ëš`@¹ûÿ—àªý{¨óSÁ¨À_ÖqÀTq T<q`TTq TXq`T€ÒˆÐÁ'‘!‘
ˆÐÁ'‘a‘ˆÐ(‘ˆÐÁ'‘À_Öý{¾©ý‘ãS‘âC‘ác‘àC‘h€Ri€Rè§)Éÿÿ—ý{¨À_ÖˆÐÁ'‘©©À_ÖóS¼©õ[©÷c©ùùûùý{½©ý‘ô*€Ò€R3€R³C9Ÿ"q,T`TŸ
q TŸqàTŸq T$Ÿ.q@TŸ>q€TˆVQq¨Tà*¶ÿÿ—÷ª!ñîÿ—õª5µ€ý{èû@ùù@ù÷cB©õ[A©óSĨÀ_Ö©@ùH°ICù*‹(@¹k T)A‘?
ëaÿÿT	€ÒɵÇçÿ—È€R¹‚çÿ—çÿÿ7!‘€R¿C9€Òs4`€R€úÿ—ö@ùˆ°‘³4(@ùÊÊV-Ëšßñ`TÖ´Ÿ.qèT"R%Ôˆ6¸@ù¸ù¿ùŸ"qÁTNîÿ—@¹»¹Kîÿ—ˆ€R¹Ÿ"qÁTH°	MCù¨@ù
	‹K°iQCùH	‹ªù_ëÀT_ùJA‘ûÿÿ(@ùèùs4`€Rwúÿ—ßñaT€R®ÿÿŸ"qaT.îÿ—óªïªH=Aù?Öa@¹€RÀ?ÖïªH=Aù?Öà*À?ÖŸ.qhýÿT"R%Ôý6¸ùŸ"q¡üÿTîÿ—¹âÿÿs4`€RSúÿ—`€R%Úÿ—ý{¿©ý‘ñ$@úèTaçÿ—È€R¹çÿ—À€Rbµ9øÿÿéª(À9ˆ4)‘!Ñÿÿµÿÿ´J	ËHié8(8h4!Ñÿÿµµ9Içÿ—H€R¹çÿ—@€R€Rý{Á¨À_Öý{»©óS©õ[©÷c©ù#ùý‘Àÿ—ÿÃÑùªàù?ù`µ€RÁh
€Rÿ«9èƒ9)€Rh€Ré‡9è‹9©
€R¨€Ré—9è“9Š€Ré
€Rê9H
€RéŸ9⃑è›9€Òé£9à‘ê§9ÿù«”À4XqÀTçÿ—@¹ è@ù(´	À9êªi4IÀ8éÿÿ5IË71‘w€Òë@ùT€Òi@ùi´(À9ê	ªh4HÀ8èÿÿ5H	Ëi@ø‹‘éþÿµUøÿ—àù`µÓ€R€À9h4À8èÿÿ5À8õqaÿÿTàùÀ9êªõq¡THÀ9h4H	À9éqTH
À9õq¡TK‘hÀ9éªh4(À8èÿÿ5(Ë
‹
‘IÀ9?õq ýÿTó@ùVËh@ùè´õƒ‘øƒ‘èƒÀ9éªh4(À8èÿÿ5`@ù"Ëბo”€4hŽ@ø¨þÿµ€R‰‹è	‹¿q8ˆšàª!€Òæÿ—ôªTµÀ€R–æÿ—·æÿ—ˆ€R¹“€R95€Rïÿÿóªö´á@ùâªàªAÀÿ—“‹Ëö@ùÈ@ùH´âªáªàªìäÿ—à5Ê@ùHÀ9é
ªh4(À8èÿÿ5(
Ë	‘ÈŽ@ø3‹	Ëþÿµu5⃑áªàªÚäÿ— 5H°!7‘áªàª$ÿÿ—à5â@ù¢´áªàªÿÿ— 5ó‹ëaT9s‘9€R4ù€Òçÿ—à@ùçÿ—ÿùà@ùçÿ—à*ÿÑG¿ÿ—ù#@ù÷cC©õ[B©óSA©ý{ŨÀ_Ö€Ò€R€Ò€Ò€ÒÇÆÿ—óS¼©õ[©÷c©ùk©ý{¾©ý‘àùùª	@ù÷ªøª€Òi´(À9ê	ªh4HÀ8èÿÿ5H	Ë	Œ@ø‹‘éþÿµñ(€Òvˆšàª!€Òªåÿ—óªSµ€R"æÿ—Cæÿ—ˆ€R¹€ÒÛæÿ—€*õ@ùôª©@ù©´€RhË‹â	ªàª}äÿ— 5ª@ùHÀ9é
ªh4(À8èÿÿ5(
Ë	‹i484‘©Ž@øéýÿµŸò8€Ò¿æÿ—áC‘ÿùàªßþÿ— 4à@ù¸æÿ—€è@ùóù€Òù±æÿ—€R€Òભæÿ—à*ý{¨ùkC©÷cB©õ[A©óSĨÀ_Ö€Ò€R€Ò€Ò€ÒfÆÿ—óS»©õ[©÷c©ùk©û#ùý{¯©ý‘ÿCÑøªå)ùªæ/ù€Òÿ©àƒ‘ÿ©úªÿ‹ùûªÿc9õªÿÿ©€Òÿÿ©ÿ'ù€RÿC9€Òÿ©€Rÿ
©ÿsùÿ£9YËÿ—è7@ù)½ŸR
@¹	k!TèãA9¨4ê3@ùH©C¹	yI©¹"½ŸR-çÿ—èãA95¨4ê3@ùH©C¹	yI©¹"€R¨4ê3@ùH©C¹	yI©¹€RáÑàªçÜÿ—@5€Òà‘5Ëÿ—èG@ù)½ŸR
@¹	k!TècB9¨4êC@ùH©C¹	yI©¹"½ŸR	çÿ—ècB95¨4êC@ùH©C¹	yI©¹"€R¨4êC@ùH©C¹	yI©¹€RᣑàªÃÜÿ—€5€ÒÕ´€Òàƒ‘Ëÿ—èW@ù)½ŸR
@¹	k!TèãB9¨4êS@ùH©C¹	yI©¹"½ŸRãæÿ—èãB95¨4êS@ùH©C¹	yI©¹"€R¨4êS@ùH©C¹	yI©¹€Rá‘àªÜÿ—€5çk@ùé#W©ãªá@ùâªàƒ@ùæ/@ùé#©(ðá‘	ýßÈåD) ?ÖôCA9ó@ùõ*÷£C9ök@ù÷£C9ök@ùó@ùôCA9€Rw4àª÷åÿ—t4àªôåÿ—ècD9h4àƒ@ùðåÿ—à*ÿC‘ý{Ѩû#@ùùkC©÷cB©õ[A©óSŨÀ_Öý{¾©óùý‘¾ÿ—ÿƒÑó* µ9åÿ—¹Aåÿ—È€R¹üäÿ—À€RvráþÿT(ðÁ‘	ýßÈâ‘€R ?Ö 5(ð‘	ýßÈ ?Öåÿ—-åÿ—@¹è@¹h 7H6hS4åÿ—¨€R¹"åÿ—¨€R¹òÿÿ€Rÿƒ‘ò½ÿ—ó@ùý{¨À_ÖóS¾©õùý{º©ý‘óªõ*“µ€ÒÆÿÿ—5€Òÿ©àC‘ÿ©ÿ+ùÿc9€Êÿ—è@ù)½ŸR
@¹	k!Tè£@9¨4ê@ùH©C¹	yI©¹"½ŸRTæÿ—è£@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáÑàªÜÿ—ô#@ù`4€á*ગÿÿ—ó*ècA9h4àªxåÿ—à*ý{ƨõ@ùóS¨À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘½ÿ—ÿÃÑö*È~@“‰°:A
‘ýF“@’H{yø		€ÒûªxC"‹û3ùé"	›øù(@ùè/ùhC"‹èù)ð(á‘	ýßÈ ?Ö€Òà#¹àã‘-Êÿ—èC@ùÿù€Rÿ¹€Róª

@¹ëê'¹TÈ~@“‰°)A
‘ýF“觩+½ŸR{À9ÿ¹_kŽ8€RT+yhø
€R	€ÒhÁ-‹é"›*ùÀ9Š4­¿qKÿÿTè@ù¿qËÍTH{yøé"›ÈÁ‘*ù@9	Éê8.Ö
KŸÁ6ë‹Tèc‘hËé"›êc‘ë
*,ù‘ˆiê8kQH8«ÿÿ5
€Rßq-Tëªìc‘hÀ8I
J_kˆÉ)8kÿÿT€ÒH{yø­Q	‹ê&›k‘_ù9Mÿÿ5èc‘ÿ£©H€Rßq)€R8ˆ@Óãã‘á‘à‘”±`TÖQi@9ÈÁ‘Éé8ÈŸÁ(ëkTqÿÏ©*€RI€RX‰@Óã#‘áC‘à‘®”±àTsÂ6‹*I{yø
	€Òë&
›lõ@9ˆqƒTè&
›jÀ9B€Òბ	ùÀ9h€Rˆ
ê‡9hõ9éƒ9ùÿ—jÀ9HS	Øèx©ø6è@ùv‘ßë
TB€Òáªà‘_éÿ—1€Tóª"€Òáªà‘Wéÿ—1€
Tà#@¹€Ò€Ò¥€R䣑ã*â‘€Rs‘Aõÿ—ö*4(ðÁ‘ø/@ù	ýßÈ€Òãs‘â*ᣑઠ?Öà	4è3@ùõ@¹jKè@¹Tô¹k£	T+qT¨€Rè3y(ðÁ‘	ýßÈ€Òãs‘"€Rác‘ઠ?Ö 4è@¹ˆ4è@¹”ô¹õ¹è@ùë¢Tè§F©ê'@¹@ÿÿ€RŸñT
€ÒH{yøÉ
Jió8Î	Á)‹ë&›jù9Ê}@“_ëëþÿTˆè¹!
€RŸñmÿÿT
€ÒH{yø­é"›+
‹Jió8jù9ª}@“_ëÿÿTðÿÿH{yø	€Òé"›*ù9J{yø‰é¹ë*›hõ@92hõ9(ð‘	ýßÈ ?Öà¹õ@¹èCB9¨4ê?@ùH©C¹	yI©¹à@ùá*ÿÑ€¼ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Öý{¼©óS©õ[©÷ùý‘k¼ÿ—/(€Òá¾ÿ—ÿs/Ë	|@“ÿùˆ°A
‘ÿ¹*ýF“)@’yjø	€Òóª€RtB"‹)!›ë7@ù¢Töc‘èc‘«€Rñ‚‚Òêc1‹ëbTiÀ9s‘?)qT9!‘	8
ë£þÿTKá¹(ðÁ‘	ýßÈ€ÒãC‘â*ác‘ઠ?Ö@4è‡@)é@¹	è¹?kCTë£ûÿT(ð‘	ýßÈ ?Öá@¹à¹à@ù/(€Òÿs/‹0¼ÿ—÷@ùõ[B©óSA©ý{ĨÀ_Öý{½©óS©õ[©ý‘¼ÿ—/(€Ò”¾ÿ—ÿs/Ë	|@“ÿùˆ°A
‘ÿ¹*ýF“)@’yjø	€Òóª€RtB"‹)!›6@ù%èc‘«€RÑ‚‚Òêc1‹ëbTi@ys
‘?)qTy!	‘	%x
ë£þÿTéc‘á¹	ËýA“(ÐÁ‘	ýßÈ€ÒãC‘¢zSác‘ઠ?Ö@4è‡@)é@¹	?kè¹CTëcûÿT(Б	ýßÈ ?Öá@¹à¹à@ù/(€Òÿs/‹ã»ÿ—õ[B©óSA©ý{èÀ_Öý{º©óS©õ[©÷c©ùk©û+ùý‘Ï»ÿ—O(€ÒE¾ÿ—ÿs/Ë	|@“ˆA
‘*ýF“)@’yjø	€ÒóªvB"‹)!›è‘ùë	¹9@ù"T(ÐÁ‘úc‘»€R÷*ëc‘ê‘èªëBTi@ys
‘?)qaTy	‘	%x
ëÃþÿTËýA“€Ò€Ò¥ªRä#‘âc‘€R ½ŸRýóÿ—õ*µ4€RÕ4è#‘A4‹ÿßÈ¢K€ÒãC‘àª?Ö@4è@¹ŸkƒþÿTiKé¹ëâTÓÿÿ(Б	ýßÈ ?Öà¹à@ùá@¹O(€Òÿs/‹‡»ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖóS¼©õ[©÷c©ùùûùý{¾©ý‘ó*³¹õªö*
1áT‘âÿ—¹™âÿ—(€R¹,³ø7ˆQG¹k"Th~@“ýF“‰8A
‘@’	€Ò{wø)#›*á@9ê6à*öÿ—€{wø)#›*á@9ê7âÿ—(€R¹râÿ—¹â*áªà*”ô*à*;öÿ—à*fâÿ—¹nâÿ—(€R¹)âÿ—€ý{¨û@ùù@ù÷cB©õ[A©óSĨÀ_Öý{º©óS©õ[©÷c©ùk©û+ùý‘)»ÿ—ÿÑö*óªõ*Õ43µJâÿ—¹Râÿ—È€R¹
âÿ—€®È~@“‰;A
‘ýF“@’h{zø	€Ò÷ùê"›TåÀ9ˆþ	S?qHTUý7Há@9¨(6B€R€Òà*†”à*†” 4h{zøé"›*áÀ9*ø6Øèÿ—H@ù	@ù©µh{zøé"›*åÀ9*4h{zøბé"›(Ða‘ @ù	ýßÈ ?Ö4T4Ÿq€ÊBz¬
TyB5‹ÿù€R€Rÿ¹ë÷ª‚Tõ&@xà*ý
”¿" k!Tø*ô¹¿*q!T €Rô
”<S5qáTÖôÛ)ÿëâTìÿÿ(Б	ýßÈ ?Öà¹	€Ò÷@ùéC‘2â*áªà*ýÿ—h{zøê"›IáÀ9Éø6ô4ŸqTŸ
q!Tâ*áªà*þÿ—
â*áªà*×þÿ—â*áªà*8þÿ—àùèÑ@@ùù€Ò	¹(ÐÁ‘	ýßÈãÓ‘â*᪠?ÖÀ5(Б	ýßÈ ?Öà3¹éÑ(@ùê‘)	@¹HùI	¹á@¹è@¹h5à@¹€4qT¸áÿ—(€R¹«áÿ—¨€R¹dÿÿáÿ—bÿÿh{zøé"›*á@9Š06hÀ9iq T¨áÿ—ˆ€R¹›áÿ—¹UÿÿK€Rÿ‘tºÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖóS½©õ[©÷c©ý{¿©ý‘ôª€Ò"€Rõ*Û”÷ªà*B€R€ÒÖ”ÿ±“ËÀ	T±€	TñMT!€Ò‚Òààÿ—ôª”µ{áÿ—ˆ€RRà*nÔÿ—@ñ	‚Rö*"¡“áªà*
ÿÿ—1€T‚Rs Ëà*ñmT@ñ᪣“ÿÿ—1áþÿTWáÿ—@¹qT]áÿ—¨€R¹Záÿ—@¹àªóáÿ—!á*LÔÿ—àªîáÿ—€RÓÿÿ¶€Ráªà*™”±@Tà*­õÿ—(Ð	‘	ýßÈ ?Ö þÿ5Aáÿ—¨€R¹)Ð(‘	ýßÈ ?Öó*/áÿ—¹7áÿ—@¹€Ráªà*€”à*ý{Á¨÷cB©õ[A©óSèÀ_ÖóS¼©õ[©÷c©ùùûùý{¾©ý‘ó*³¹õªö*
1áTáÿ—¹áÿ—(€R¹,³ø7ˆQG¹k"Th~@“ýF“‰8A
‘@’	€Ò{wø)#›*á@9ê6à*‰ôÿ—€’{wø)#›*á@9ê7áÿ—(€R¹ôàÿ—¹â*áªà*”ôªà*½ôÿ—àªèàÿ—¹ðàÿ—(€R¹«àÿ—€’ý{¨û@ùù@ù÷cB©õ[A©óSĨÀ_ÖóS¾©õùý{¾©ý‘ó*ôªõ*Cõÿ—±ÁTÚàÿ—(€R¹€’(Ð!	‘	ýßÈã*âC‘᪠?Öà5(Б	ýßÈ ?Ö§àÿ—ñÿÿà@ù±ÀýÿTi~@“ˆA
‘*ýF“)@’yjø	€Ò+!›¨€Rjá@9H
há9ý{¨õ@ùóS¨À_ÖŠÿÿÎÿÿý{¿©ý‘1¡T¬àÿ—(€R¹ø7ˆQG¹k‚T	|@“ˆA
‘*ýF“)@’yjø	€Ò)!›*á@9@˜àÿ—(€R¹Sàÿ—€Rý{Á¨À_ÖóS½©õ[©÷c©ý{¿©ý‘õªU´HÐÁ ‘€Rt€Rˆ	}H¢
€Òàª6}Ø~@“ï|ÓiwøI” 4`ø6ÔQÓk-þÿT€	ï|Óè"‘(ih¸ø7‘qÂT	}|“JHA7‘ ih¸€Rý{Á¨÷cB©õ[A©óSèÀ_ÖóS¿©ý{¿©ý‘óªóµ]àÿ—È€R¹àÿ—€h@¹€¿;Õ5
S4àªÛãÿ—ô*àª"äÿ—àª4ëÿ—'Þÿ—`ø6€`@ù`´áàÿ—ùàª>”à*ý{Á¨óSÁ¨À_ÖóS¿©ý{¾©ý‘óª³ù3µ6àÿ—È€R¹ñßÿ—€ý{¨óSÁ¨À_Öh@¹¿;Õ1Sàªh4%”öÿÿ¥Äÿ—àªÃÿÿ—ô*દÄÿ—à*ïÿÿóS¿©ý{¾©ý‘óªôª´ù @¹™óÿ—h@ù@¹	|@“*ýF“ˆA
‘)@’	€Òyjø)!›*á@9
6pôÿ—(ÐA	‘	ýßÈ ?Ö`4€R(Б	ýßÈ ?Öó*óßÿ—¹ûßÿ—(€R¹€€@¹¾óÿ—à*ý{¨óSÁ¨À_Öý{½©ý‘à¹1¡Tëßÿ—(€R¹ø7ˆQG¹k‚T	|@“ˆA
‘*ýF“)@’yjø	€Ò)!›*á@9J6èS‘à)àC‘èùãc‘⃑ás‘³ÿÿ—Ïßÿ—(€R¹Šßÿ—€ý{èÀ_Öóøý{½©ý‘ó*àC‘;Åÿ—hqÈTè@ù@ù	Ùsx €Rè£@9¨4ê@ùH©C¹	yI©¹ý{èóAøÀ_Öóøý{¾©ý‘óªàC‘±”ñTè@¹éÿŸR	k©ÿŸR)ˆS´iyý{¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¾©ý‘÷ªó@ùöªõªøª6´ôª•´y€Òš€ÒûÿŸRhÀ9h5"€ÒhÀ9h5B€Òh
À9q"ššãªáªàC‘„”±àT`´è@¹k©T¿ñIT
A@Q›RµÑ)J*깈yè€R
U3Š.xˆyˆ
‘”
‘‹µÑUûÿµôªˆËóùýA“	€ÒŸyúÿÿóù\ßÿ—H€R¹€’ý{¨û#@ùùkC©÷cB©õ[A©óSŨÀ_Ö€Òu€Ò–€ÒhÀ9h5"€ÒhÀ9h5B€Òh
À9q¢–šãªáª€ÒF”±@üÿTà´ñAT”‘‹”‘éÿÿàªÝÿÿý{¿©ý‘€µ_ù €Ò.a59ûÿÿ?`raT9øÿÿ?PrT*€Ò€R?<rT›R(KýqéTJ€Ò€R?(rATèý¿kãTj€Ò€Rì
ª(	a2‰i 8!|SŒÑlÿÿµh*9@‘_ù_ùßÿ—H€R¹€’ý{Á¨À_ÖóS¾©õùý{¿©ý‘óªô*õ*£5hÀ9Õqà·Ÿ&”@5hÀ9Õq¬TëTi‘U4(À9(À8ÁqÀÿÿTˆ5hò_8 €RqThÀ9Áq TŸ¶q €RaT	qáThÀ9Áq€TŸ¶q €R@T€Rý{Á¨õ@ùóS¨À_ÖóS¾©õ[©ý{¿©ý‘óªôªóµÁÞÿ—Ó€R¹|Þÿ—À€RDa´_q9HÀŸ	?À)ëˆT´Þÿ—S€Rôµ°Þÿ—Ó€R¹kÞÿ—à*3€R€@ùv9u‘À9h4‘€R¨8BQ_qÿÿT¿9ø7@¹ã*â*™ÿÿ—SH4©Ñ(À969(ýß8åq ÿÿT(9hÀ9Åq¡Tˆ@¹	‰¹j‘HÀ9é
ªh4(À8èÿÿ5(
Ë‘a‘સÿ—€Rý{Á¨õ[A©óS¨À_ÖóS¾©õ[©ÿCÑ@¹H4'@¹4QëQ5*@¹_qT@¹¹àªÿC‘õ[A©óS¨À_Öì5@¹J5€>Ô		Ê(¡
q¹è—Ÿ¹à	ªÿC‘õ[A©óS¨À_Ö
€Ò€ÒŸ1àTî
ªˆ}@Ó	‘
xi¸KªNµ€>Ôh	ΚŒQ­›}@Ó

‹Ÿ1þÿThý`Ó )q(€RK€Rhˆ¹à
ªÿC‘õ[A©óS¨À_ÖkˆTKŸ
kê*ëTh}@“	‘H}@“.xi¸	‘xi¸ßkÁTJQ_
kkQªþÿTBT­
4èQ
‘.xj¸èQ
‘5xj¸(€R€RÊÀZJK	S?qT‹€RK”4©&ÖÈ!Ô.*µ"ÔÿqÉTèQ
‘+xj¸h%Ö*€Ò¥Q%
ø7Ã}@Ó¦ßk¨TÈ|@Ó	‘xi¸€RÂQI‘
xi¸ÈQêù
‘
xj¸ä¹Ô4é@ùª%Öš­!Ôßq(!ÔšOªTÈQ
‘xj¸h%Ö

*ï@ùCµ€>Ôî	Úê@²È½›ß
ë	}@Ó©Tèƒ`²È‹	%›î@²è@²?ë¨T«~@Ó¯}@Ój}›í@²è	ª_ëÉTi	‹?
ëÎÑJË)ÿÿT´€Ò€R'4è}@Ó	‘*xi¸H-›í*ý`Óè‘
xl¸ï_
kH
Kk%‹šx,¸ÿk#þÿTA$ëIT
€Rç4€Ò¨ª}@Ó‘H‘	xl¸+xh¸­¿k(A+‹
‹
x,¸Oý`ÓƒþÿTÎÑì*È}@Ó‹¥QÆQeóÿ6@¹‹ê*_kTH}@Ó	‘x)¸@¹J_kCÿÿT¹ë4kQi‘
xi¸j5¹kÿÿ5àªÿC‘õ[A©óS¨À_Ö€ÒÿC‘õ[A©óS¨À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘?¶ÿ—ÿƒ,Ñô*àýöªõªöשàc‘ûª
”è@¹7€R}qaTÿƒ9àc‘
”÷ƒ9ó@ù©€RÛù€R€R€Rñ(±ˆ࣑ȹË	”iútÓ)µÎ@ò`Tè+@¹¨À6Hðq*‘ß¹?ýñÁThÎ@òaT(€RÓø¶	àÒ	ëaTˆ€RhþsÓê(*Kh2×¹q T	qT
q`TqáTHðá*‘áªàªuÛÿ—‚53€RHðÁ*‘øÿÿHð¡*‘õÿÿHð*‘áªàªgÛÿ—@€5€Ròhú@’‰èùgž
ýtÓé¹)€R_)@òé9àÒàýÍ@’錚3‹(€RL€RˆˆJ)TÜ	”Àd°lþ`Óù*ù³	)Z€R	x(Kyrõ‰Ÿqõ¹)€RH€R+ˆëK¹ŸÒqcTè3‘¹X€R Rø‹¹è“¹,4
€Rì3‘í3‘©Yj¸ˆYj¸	kA
TJ_	qAÿÿTˆÊQ‰ÊQ
}S'€RK)€Ò(!ÆšQé3‘hQ(Yh¸*€Rì€Rä%*	ÀZHIK‰	K
S_qè‰Z©?ÍqTÿkè—Ÿ	
6ßÎqHT¯QÌQŸk€Tˆ
K	Qk‚Tê3‘NYh¸€R?k‚Tè3‘Yi¸€R
É

%Æ(!ÇJ*ë3‘jY,¸ŒQŸk`TëK@¹çÿÿùO@¹€Rí4é3‘?Y(¸
k¡ÿÿTùO@¹öK¹€RÿK¹˜€R÷¹ø¹ÙˆÎQ‰ÎQ
}S'€RK)€Ò(!ÆšQé3‘hQ(Yh¸*€Rì€Rä%*	ÀZHIK‰	K
S_qè‰Z©?ÍqTÿkè—Ÿ	
6ßÎqHT¯QÌQŸk€Tˆ
K	Qk‚Tê3‘NYh¸€R?k‚Tè3‘Yi¸€R
É

%Æ(!ÇJ*ë3‘jY,¸ŒQŸk`TëK@¹çÿÿùO@¹€Rí4é3‘?Y(¸
k¡ÿÿTùO@¹öK¹¶ÿÿ€RÿK¹³ÿÿŸÚq 
Tès%‘¹X€R Rø[	¹èc	¹Ì	4
€Rís%‘î3‘ÉYj¸¨Yj¸	káTJ_	qAÿÿT‰ÀZ(€RIKì€R‰	K
S_qè‰Z	?	qê'ŸVßÎq‰T€RÿK¹ÉQ?1àT(Q?k‚Tê3‘JYi¸
€Rk‚Të3‘hYh¸€RHyˆë3‘hY)¸)Q?1`TëK@¹ìÿÿùO@¹öK¹È†€RKt~S‚~~Ó€R೑µÿ—h)€R)!Ȉ곑÷*IY4¸÷¹}~Óèë¹¢´às‘_0ñhT᳑‹µÿ—6Ÿqˆ™	ÀZ*€RHIKì€R‰	K
S_qè‰Z	?qê'ŸVßÎq‰T€RÿK¹ÉQ?1àT(Q?k‚Tê3‘JYi¸
€Rk‚Të3‘hYh¸€RH}ˆë3‘hY)¸)Q?1`TëK@¹ìÿÿùO@¹öK¹¨†€R»ÿÿ‚9€Ò€RÀ´ÿ—ÁÛÿ—¹}Ûÿ—÷B¹øB¹HU•!ø7¨~¨›ý`ÓYS¹4IðÈ€R?›q™è¹Q)'‘3	‹€R೑t
@9u@9‚ö~Óˆèë¹¥´ÿ—i@yHðA‘곑¢ö~Ó		‹@	‹5µÿ—éëC¹?qˆTèïC¹ˆ5€Rÿ¹¦q€Tw4	€R€Rìªís‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿT‰4èB¹ÍqâTês‘IY(¸èB¹÷¹ŒøB¹€Rÿ¹	€R‰ÿq¨T÷	*÷¹@Ó"}~Ó´_0ñàs‘ˆT᳑µÿ—‚9€Ò€Rg´ÿ—hÛÿ—H€R¹#Ûÿ—÷B¹øB¹3ùÿ4qà
T×
4	€R€Rís‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTÌÿÿ?kÿ»¹è'Ÿ?k병ês‘c1Šš?kës‘곑b1Šš?k$1—q剀R€R¤4fXn¸5ßkÁTéó‘È?Y.¸è»¹1€Rí*€Re4¿ÍqT¿kÁTèó‘Y-¸è	黹LXg¸áó‘+Xm¸çÿkˆ}¦›	A/‹ˆ=*A+‹	êù)X-¸ï7@¹­è»E¹ýÿT/4¿ÍqàT¿k¡Tèó‘Y-¸¨è»¹êó‘HYm¸	A/‹IY-¸/ý`Óè»E¹­/þÿ5¿Íqà
TÎßk¡øÿT÷*÷¹}~Ó´_0ñàs‘ˆTáó‘’´ÿ—‚9€Ò€Rö³ÿ—÷Úÿ—H€R¹²Úÿ—÷B¹øB¹)€Ré4è@¹IÐ9Kùæÿ5õ@¹HS	uS*
Z«
KË4HÐá)‘iQ
Yi¸
4_qàT×4	€R€Rì
ªís‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿT)4èB¹Íq¢Tês‘IY(¸èB¹è¹Ö"4	€R€Rì3‘M€ÒˆYk¸}
›
A)‹ŠY+¸kkIý`Ó!ÿÿT)!4èK@¹ÍqâTê3‘IY(¸èK@¹èK¹ÿ¹èÿÿúKH¨›ý`ÓSw4IÐÈ€Rÿšq—è¹Q)'‘3	‹€R೑t
@9u@9‚ö~Óˆèë¹™³ÿ—i@yHÐA‘곑¢ö~Ó		‹@	‹)´ÿ—éëC¹?qˆTèïC¹ˆ5€RÿK¹¥q`TV4	€R€Rìªí3‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTi4èK@¹ÍqâTê3‘IY(¸èK@¹öK¹‹ùO@¹€RÿK¹€RˆßqˆTö	*öK¹3@Ó"}~Óâ´_0ñà3‘ˆT᳑÷³ÿ—‚9€Ò€R[³ÿ—\Úÿ—H€R¹Úÿ—ögI)Sùÿ4qà
TÖ
4	€R€Rí3‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTÍÿÿ?kÿ»¹è'Ÿ?k병ê3‘c1Šš?kë3‘곑b1Šš?k$1–qʼn€R€RÄ4fXn¸5ßkáTèó‘ÖY.¸ö»¹2€Rí*€R…4¿ÍqT¿kÁTèó‘Y-¸è	黹LXg¸áó‘+Xm¸çÿkÈ|¬›	A+‹È,*A/‹	êù)X-¸ï7@¹­ö»E¹ýÿTO4¿Íq@
T¿k¡Tèó‘Y-¸¨è»¹ëó‘iYm¸è}@Ó
A)‹jY-¸Oý`Óö»E¹­þÿ5¿Íq TÎßkøÿTöK¹Â~~Ó´_0ñà3‘ˆTá󑇳ÿ—‚9€Ò€Rë²ÿ—ìÙÿ—H€R¹§Ùÿ—öK@¹ùO@¹(€RH4è@¹IÐ÷Kçÿ5S	uS*
XK
K‹âÿ4HÐá)‘iQ
Yi¸Š4_q áÿT–áÿ4	€R€Rì
ªí3‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTI4èK@¹Íq"Tê3‘IY(¸èK@¹öK¹öþÿöK@¹ôþÿÿK¹€Òÿë¹â³‘ÿK¹9€Òà3‘£”ác‘à#‘<ûÿ—ô@¹(q¡T)€RìB¹i9”s‘Ì4	€R€Rís‘N€Ò¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿT)4èB¹ÍqâTês‘IY(¸èB¹è¹€Òÿë¹â³‘ÿ¹9€Òàs‘z”€5”QóªÀh9s‘è@ùê@¹¹´ø7°_k’Ÿ

è#@ù	Ñ?A*ëH}@Ó)1ˆš4‹ë5‹ TîK@¹¶N4	€R€Rì3‘Í
XˆYk¸}
›
A)‹ŠY+¸kkIý`Ó!ÿÿT)4èK@¹ÍqâTê3‘IY(¸èK@¹èK¹€Òÿë¹â³‘ÿK¹9€Òà3‘A”ác‘à#‘Úúÿ—îK@¹
€Rë*KßqçŸç9h}¶›ÿ
ký`ÓŠ}SHuS	
Lk	KjÁH‹}S‚TÁqçŸhJ-8­Q¿1áýÿT¨Ëç9%ñ)€Ò(Áˆš‹ëá÷ÿTè@99qóŸèƒ@9h4àc‘É”à*ÿƒ,‘ø±ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Ö€Ò€R€Ò€Ò€Òw¹ÿ—Êš;ÍÌÌÌóS¾©õùý{¿©ý‘ôªõªóªsµ€R@µÙÿ—Ó€R¹ÀØÿ—À€Rý{Á¨õ@ùóS¨À_Ö¿ñ€Sú£Tâªáª²ÿ—îÿÿ⪀Rñ±ÿ—•µñØÿ—Ó€RŸë‚ýÿTìØÿ—S€R¹§Øÿ—à*çÿÿý{¿©ý‘T”Q”ý{Á¨À_ÖóS¾©õùý{¾©ý‘óªàC9àªÁãÿ—h@¹¿;Õr Th.@©€RKh‘hùi"@¹Ÿq*Qj¹MTa@ùâ* öÿ—õ*i@ù¿kèCÀ9(9"qIT	|@“hÐA
‘*ýF“)@’yjø	€Ò+!›h°	‘há@9ˆý/6B€R€Òû÷ÿ—±áüÿTjR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ €R"€RáC‘úõÿ—qàŸý{¨õ@ùóS¨À_Öóøý{¾©ý‘@¹¿;Õ
Sh4 €R"@¹¿;Õr€T$@©	ë@T@¹¿;Õîìÿ—󪱀T(!	‘	ýßÈ€Ò#€RâC‘ ?Ö€4(a	‘	ýßÈác‘ઠ?Ö 4é#A©?ëàŸ€Rý{¨óAøÀ_ÖóS¿©ý{¿©ý‘óªô*àªNãÿ—h@¹¿;ÕrTaØÿ—(€R¹jR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ€Gh@¹¿;Õ1SH4RØÿ—H€R¹jR‘Iý_ˆ)2Iýˆ¨ÿÿ5ñÿÿh@¹¿;ÕÈ6ફÿÿ—¹jR‘Sh4h@ùhùIý_ˆ)yIýˆ¨ÿÿ5¿;ÕjR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;ÕjR‘Iý_ˆ)yIýˆ¨ÿÿ5¿;Õ¹h@¹¿;Õ	˜€R	jáTàª0ãÿ—Sh5àª6”᪀?ÿÿ—Sˆ5jR‘Iý_ˆ)2Iýˆ¨ÿÿ5¾ÿÿIý_ˆ)2Iýˆ¨ÿÿ5¹ÿÿ€ý{Á¨óSÁ¨À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘Ó°ÿ—ÿÃÑúªöªùªúµÁ´þ×ÿ—È€R¹¹×ÿ—ÿÑϰÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Övþÿ´Yþÿ´?ñƒþÿT(Ñÿùûc‘i›õ#‘õï©€Ò7Ë		Öš*‘_!ñHTëéTÓ‹ëôªˆTè>Aùïª?Öáªàª ?Öqt”šÓ‹ëÉþÿTëªêªŸëTŒËHÀ9kщiê8ˆi*8I8kÿÿµËëˆüÿTë@ù°HýAÓ}›è>Aùïªt‹?Öáªàª ?ÖqTìªëª_ëTjËhÀ8IÀ9ŒÑH9iñ8Lÿÿµè>Aùïª?Öáªàª ?ÖqTëªêª_ëTLËHÀ9kщiê8ˆi*8I8kÿÿµè>Aùïª?Öáªàª ?ÖqTëªêªŸëTŒËHÀ9kщiê8ˆi*8I8kÿÿµóªõªŸë©TÓ‹ëBTè>Aùïª?Öáªàª ?ÖqÍþÿTÓ‹ë(Tè>Aùïª?Öáªàª ?ÖqÍþÿT;÷ªµË¿ë)Th?Aùïª?Öáªàª ?Öq¬þÿT¿ëTëªêªëTlËHÀ9kщiê8ˆi*8I8kÿÿµŸë”“š7Êÿÿû@ùŸë¢T÷ËÿëIT(=Aùïª?Öáªàª ?ÖÀþÿ4
;÷Ëÿë	Th?Aùïª?Öáªàª ?Öàþÿ4û@ù	ËëW@©èË	ëËT_ëâTwùk‘{#‘º†øõï©ëùëðTúª9ÿÿëâTxùk‘{#‘³†øõï©ëù_ëbTøª,ÿÿðkѵ"ÑëW©{#Ñûù+âÿ·º@ùx@ù#ÿÿý{¿©ý‘Ò¯ÿ—ÿƒÑ€Rê‘	}@“?ñBT?i*8qKÿÿT)@9i4ì‘-€R+ýCÓ(	iil8ª!ÈH	*)@8hi,8)ÿÿ5	@9i4+€Rì‘(	)ýCÓj!È(il8_jT	@8)ÿÿ5€Òÿƒ‘µ¯ÿ—ý{Á¨À_ÖÄ·ÿ—ý{º©óS©õ[©÷c©ùk©û+ùý‘¡¯ÿ—ÿCÑúC‘ó*Eùqôªûªù*õªö*÷*íTa~@“ઔk “w5ˆ@ù
@¹Hs@¹*€R)€R€R€ÒqA‰ã*âªà*½çÿ—ø*x5€Rƒ“	A‘?ë Ÿš‰™™R ´ñˆT<‘ëLTèß|²ýDÓç±ÿ—ÿs/ËôC‘t´‰¹?Ûÿ—ôªÔ´¨»›Rˆ¹”B‘€ÒÔ´å*äªã*âª!€Rà*–çÿ—À
4€Òÿù€Ò€R€Òã*âªá*àªÉØÿ—õ*U	49P66	4¿kÌTD@ù€Òÿù€Òå*ã*âªá*હØÿ—õ*u59¨~“	A‘?ë Ÿš ´ñˆT<‘ëLTèß|²ýDÓ§±ÿ—ÿs/ËóC‘s´ˆ™™RÿÚÿ—óªÓ´¨»›Rh¹sB‘€ÒÓ´€Òÿù€Òå*äªã*âªá*ઑØÿ— 4€Ò€Òã*⪀Rà*ö5€R€Òjçÿ—õ*µ5h_¸©»›R	kaT`BÑÒÖÿ—€Rô´ˆ_¸©»›R	kaT€BÑÊÖÿ—à*_CÑÿC‘¯ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖD@ùå*âÿÿh_¸©»›R	kýÿT`BѶÖÿ—åÿÿóS¼©õ[©÷c©ùùý{½©ý‘ÿCÑùªáªàƒ‘ø*÷ªö*õªô*ó*€»ÿ—èƒ@¹ç*æ*åªä*è¹ãªâ*áªà£‘#ÿÿ—èã@9¨4ê@ùH©C¹	yI©¹ÿC‘ý{èù@ù÷cB©õ[A©óSĨÀ_Öý{¿©ý‘.æÿ—SqàŸý{Á¨À_Öh°]A¹H5‹€ÒóS¾©õùý{½©ý‘ôªõªáªàC‘óªO»ÿ—sµ€R#´´•´è{@²ëÉTÎÕÿ—È€R¹‰Õÿ—è@ù™@ùáµãc‘âªáªàª€”@¹ä*æ*åªãª"‚Ràc‘á”À5·Õÿ—È€R¹°Qè£@9¨4ê@ùH©C¹	yI©¹ý{èõ@ùóS¨À_ÖóS¾©õ[©ý{µ©ý‘óªÿ©öªÿ	©€ÒÿSùàC‘ÿ£9ÿ©€Òÿ©€Rÿ;ùÿã9»ÿ—è@ù)½ŸR
@¹	k!Tè£@9¨4ê@ùH©C¹	yI©¹"½ŸRàÖÿ—è£@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€Rá‘ચÌÿ— 5€ÒàÑèºÿ—è@ù)½ŸR
@¹	k!Tè#A9¨4ê@ùH©C¹	yI©¹"½ŸR¼Öÿ—è#A95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáC‘àªvÌÿ—`5ðA‘á3@ùàK@ù	ýßÈ ?ÖõãA9ô3@ùó*õãA9ô3@ù€Ru4àªÛÕÿ—è£B9h4àK@ù×Õÿ—à*ý{˨õ[A©óS¨À_Öíªbµ€Rª%@x+$@xHQeqIhQL‰ieqh‰€K€5l4BÑBþÿµÀ_Öý{¿©ý‘àµÕÿ—È€R¹ØÔÿ—€’	âªh°ñDù	ð(	‘	ýßÈ€R ?Öý{Á¨À_ÖóS¾©õ[©ý{¿©ý‘ôªóª”µàª¨Ùÿ—$“µàªœÕÿ—‚±HTð¡	‘v°ÀòDù	ýßÈãªâª€R ?Ö€µð¡	‘rÈÿ—€4ઇìÿ— 4ÀòDù㪨þßÈ⪀R?Ö þÿ´ãÔÿ—ˆ€R¹€Òý{Á¨õ[A©óS¨À_ÖóS¾©õ[©ý{¿©ý‘õªóªôª`€R–çÿ—õµÐÔÿ—È€R¹‹Ôÿ—Ó€R!¿ùS´ùôþÿ´àª)”ôª´éª(À9h4)‘ýÿÿ(Ë‘!€Òàªk·ÿ— ùÀµ¶Ôÿ—ˆ€R¹“€RâªáªùÒÿ—`5S´vù€R`€R“çÿ—à*ý{Á¨õ[A©óS¨À_Ö€Ò€R€Ò€Ò€Òµÿ—óS¾©õùý{¿©ý‘ôªñÅÿ—óª´ô´ˆÀ9éªh4(À8èÿÿ55Ëi@ùé´(À9ê	ªh4HÀ8èÿÿ5H	Ëë)T`@ùhõ8õq¡Tâªáª—þÿ—`4iŽ@øîÿÿh@ù	‹ ‘€Òý{Á¨õ@ùóS¨À_Ö€R€Ò#€R“ÿÿíªbµ€Rª@8+@8HQeqIhQL‰ieqh‰€K€5l4BÑBþÿµÀ_Öý{¿©ý‘h°]A¹È5àµRÔÿ—È€R¹
Ôÿ—°	Aÿÿ´è{@²_ëèþÿTÜÿÿ—€Ò”ý{Á¨À_ÖóS¾©õùý{½©ý‘õªôªóªõµ:Ôÿ—È€R¹õÓÿ—°Tÿÿ´è{@²ëèþÿTsµ€RáªàC‘£¹ÿ—è@ù
‰@ù¨@8	ij8ˆ@8ij8 K€5i4sÑÿÿµè£@9¨4ê@ùH©C¹	yI©¹ý{èõ@ùóS¨À_Öý{¾©ý‘à#y_”4âS‘!€RàC‘~”`4à#@yàÿŸRý{¨À_Ö€|©¹P‘¹ÀøùýŸˆ¿;ÕÀ_Öý{¿©ý‘Ƭÿ—ÿCÑh°a(‘ñjˆšð	/‘?ñ.ˆš?ñ(€ÒGˆš?ñŸšgµ €’[H
@yè5Ë@9ΑË87O´ë¹qàŸšQh	qaTL€R
h
qaTl€RhÁqáTŒ€Rè€R)€RK(!È	Q+
í*L@9
SK@¹ˆù	S?	q ™AzÃT¿k‚T¿ëé šÇËÆÀ8ç‘ÈqaTÈ*ÿ	ëÿÿT?
ëâT¨)KK¹L	y	SI
yÀÿÿ›RhKýqiTADq"T€Rè¹	R( Ré£)ˆ	Ñé‘(yh¸kãTO´ë¹q_ùàš_ùÓÿ—H€R¹€’ÿC‘a¬ÿ—ý{Á¨À_Öóøý{¿©ý‘óªà*Ax
é	j€T³´€R€Ri”`¹yÓÿ—È€R¹4Óÿ—À€R“´`”`¹]”€Rý{Á¨óAøÀ_Öàüðüóøý{¿©ý‘óªÔ”`¹”`¹€Rý{Á¨óAøÀ_Öóøý{¾©ý‘óª`@¹”`@¹I”àC‘ÿùêÿÿ—@5é@¹h@¹	kÁTé@¹€Rh@¹	k@T €Rý{¨óAøÀ_Öóøý{¾©ý‘óªÿùàC‘Ôÿÿ—€5è@ùàC‘é@¹hù(2è¹Øÿÿ—€5”€R €Rý{¨óAøÀ_Öfž	þïÒÈ)L’	ëTßÍ@ò`TàªÄî
ø¶%€R€R#€RÿÿÒHa;‘ä/&€Ra€Rkßù@òÁTE€R„€RC€RþÿÒôÿÿîýÿ·ÈXÈ‹ÉX	ëÈTn`t\8pp\\¾\’+qˆfž	}`’“r;gž‘;{y*sz
|Ó
\8yOT´
\¶RXy×BXøêu+qR}yK]Yg^`g^;àÒßë"TzàÒ	\Ȫgž€R1:p.fž€RÈÍnÓ2\2lȵmÓ}\l~\“bÉ€Òèª(-L³gžÉùtÓ+KiýQˆ}@Ó8b
ÑH+‘u
rymüHA3‘:uP\“VQU\q\™st\KT7yöBUymüÓFWö\t
w—fY÷*u_VX}yc]Rg^`K^À_Ö ÕVðÀ‚øðÿ]È4€xËÛ?ŸQñ#Ib?Ôƺ™™™‰?Ѐ?Þ^†™™™‰?AGÙ;BIb?WUUUUUµ?àB.æ?À_ÖD;Õ
à“R
Jè}Sè
r TPq T`q Tpq	`€Rî‰ €R@€R€Rÿr	€Rêé‰_q€Rëèˆq†€R**ì膟qK€RI*íè‹¿q**éŸè}
SK	*	j	*K*`*À_Ö(D;Õî*ßr	€RÊé‰_qˆ€RËèˆqO€R**Íè¿qJ*éŸÈ}SK	*	j	*Ì@*À_Ör Tq Tq Tq	 Ò剚 Ò Ò€Ò
D;Õ	}@Ó(X+ŠSjªŸq  Ò舚Iª¿qÒè‹šßq€€Ò*ªè‹šÿq@€ÒIªè‹šÿq €Ò*ªè‹šÒßqIªè‹š)ª*ªà“ÒHÊDÕÀ_Öÿ`?ü
r(D;ÕXŠ
S	€ÒKªè‰š¿qjªéŸšßqH€Ò舚K	ªÿqŠ€ÒiªèŠšÿq€Ò*ªè‹šIª)DÕÀ_Ö`ÿÿÿóøý{¿©ý‘jH@¹óª!€Ò	‚ÒI¹DÑÿ—`ù€Ò{Òÿ—h@ùjR‘´Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ‚R	Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õhr‘hùH€Rh"¹h@ù¹hùý{Á¨óAøÀ_Öéª(À9€ÒÈ4ë€T‘hé8ˆÿÿ5À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘ªÿ—ÿÃÑúC‘ó*Aùqôªû*öªùªõ*÷*ÍTa~@“àªàÿÿ—ó*1‹T¿qÍT¡~@“àª×ÿÿ—õ*¿1kTw5ˆ@ù
@¹S4•5k@T¿qÌTq,TС‘	ýßÈA#‘à* ?Ö 4qMTH@¹	q£TH;@9J;‘H4K@94É@9H@9?k*!Kz	TH-@8ÿÿ5`€R¿qMTH@¹	q£TH;@9J;‘H4K@94)@9H@9?k*!Kz©TH-@8ÿÿ5 €R|€R€Òã*âª!€Rà*bâÿ—ø*X4“	A‘?ë Ÿš‰™™R ´ñˆT<‘ëLTèß|²ýDÓŽ¬ÿ—ÿs/ËôC‘t´‰¹æÕÿ—ôªÔ´¨»›Rˆ¹”B‘€ÒT	´å*äªã*âª!€Rà*=âÿ—@4€R€Òã*âª!€Rà*5âÿ—ö*64È~“	A‘?ë Ÿš ´ñˆT<‘ëLTèß|²ýDÓb¬ÿ—ÿs/ËóC‘s´ˆ™™RºÕÿ—óªÓ´¨»›Rh¹sB‘€Ò³´å*äªã*âª!€Rà*âÿ— 4@@ù€Òÿù€Òå*äªã*âªá*lÒÿ—õ*€R3´h_¸©»›R	k¡T`BÑŽÑÿ—€Rô´ˆ_¸©»›R	kaT€BÑ…Ñÿ—à*@€R€R_CÑÿÑ·©ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖóS¼©õ[©÷c©ùùý{½©ý‘ùªáªàC‘ø*÷ªö*õªô*ó*A¶ÿ—ç*æ*åªä*ãªâ*áªàc‘ÿÿ—è£@9¨4ê@ùH©C¹	yI©¹ý{èù@ù÷cB©õ[A©óSĨÀ_Öóøý{¿©ý‘Sð`öDù±ÁTH;‘	Ð(‘	ýßÈ€Ò€Rd€R€Òb€R¨R ?Ö`öù±àŸý{Á¨óAøÀ_ÖHðõDù±¨TÐÁ‘	ýßÈ ÖÀ_ÖóS½©õ[©÷ùý{¿©ý‘ÐÁ‘ôªWðàöDù	ýßÈõ*öª€Òãªâ*᪠?Öó*“5Б	ýßÈ ?ÖqÁTàöDù±¨TÐÁ‘	ýßÈ ?ÖH;‘	Ð(‘	ýßÈ€Ò€Rd€R€Òb€R¨R ?ÖÐÁ‘€Òàöù	ýßÈãªâ*᪠?Öó*à*ý{Á¨÷@ùõ[A©óSèÀ_Ö|S
H2rKˆh2rjˆH2rKˆh2rjˆH
2rKˆ
r€TPq T`q TpqÁTk2k2k2rh2`ˆÀ_Öì*è€RŸj€RTŠSH2ŸrKˆh2ŸrjˆH2ŸrKˆh2Ÿr`ˆL86
2À_Ö(D;Õ}@Ó耒Š(DÕåÿÿý{¿©ý‘,
í*D;Õ
à“R
Jà*¹ÿÿ—é,**
¨
N*ßk TÈ
mSH2ßrKˆh2ßrjˆH2ßrKˆh2ßrjˆH2ß
rKˆÈr€Tq Tq TqÁTk
2k
2k	2h2ßré€Rjˆè	
@*à“ÒÊDÕ‹ÿÿ—ý{Á¨À_ÖóS¾©õùý{¿©ý‘õ*³ôªÕ6´@6 €Ò¤”szÕ6´H6@€Òž”sz
Õ6´P6€€Ò˜”szÕ6´X6u 6€Ò‘”szµ 6”`6€ÒŒ”szqàŸý{Á¨õ@ùóS¨À_Öý{»©óS©õ[©÷c©ù#ùè'ýý‘s¨ÿ—ÿÃÑyXàý(@`øª÷*áªà“Òóªô*ö*õ*b”pgžàùáªà*ðý¼ÿÿ—à5¿
qÁTèƒ@¹i€Rè;ý(3胹å#‘äC‘ã*â*á‘à‘)”̾ÿ—S(44ñÃ@máªð£mà@ùô¹øùñýA”àc‘;ÿ—`5à*&”à@ýà*"”à@ùáª5”à@ýÿÑ>¨ÿ—è'@ýù#@ù÷cC©õ[B©óSA©ý{ŨÀ_ÖŸÀM²gžÀ_Ö€RóS½©õ[©÷c©ý{¾©ý‘àùóª¹è@ùø*÷ªõªö*	¹é@ùô?
¹Â 6ê@ù”H@¹	2I¹Â6ê@ùôH@¹	2I¹Â6ê@ùTH@¹	2I¹Â6ê@ù´H@¹	2I¹Â6ê@ùH@¹	2I¹h@ùí@ù	ýHÓ¨	@¹ë)*iJê*,ˆ
J¨	¹h@ùî@ù	ýIÓÈ	@¹ë)*iJê*,ˆ
JÈ	¹h@ùí@ù	ýJÓ¨	@¹ë)*iJê*,ˆ
J¨	¹h@ùî@ù	ýKÓÈ	@¹ë)*iJê*,ˆ
JÈ	¹h@ùí@ù	ýLÓ¨	@¹ë)*h3¨	¹Ø” 6ê@ùH
@¹	2I
¹ 6ê@ùH
@¹	2I
¹ 6ê@ùH
@¹	2I
¹ 6ê@ùH
@¹	2I
¹  6ê@ùH
@¹	2I
¹h@ù

r`T_Pq`T_`qàT_pq!Tê@ùH@¹	2*€RJ€Ré@ù(@¹H3(¹ê@ùH@¹	uI¹ì@ùˆ@¹	Jê*+-h
Jˆ¹ê@ùH!@¹	2I!¹ë@ùh!@¹V4	mi!¹ê@ùð@½P½ë@ùha@¹	2ia¹ê@ùHa@¹	mIa¹ê@ù±@½QQ½)€R(
3h!¹é@ùð@ý0	ýê@ùHa@¹	2Ia¹ë@ù)€Rha@¹(
3ha¹é@ù±@ý1)ýZ”°A‘	ýßÈãC‘"€R€Rà* ?Öê@ùH	@¹¨ 6h@ù	ùw’iùH	@¹¨6h@ù	ùv’iùH	@¹¨6h@ù	ùu’iùH	@¹¨6h@ù	ùt’iùH	@¹ˆ6h@ù	ùs’iùH@¹	r T?q T?	qÀT?
qÁTh@ù	j²
)€Òh@ù(j³hùI€Òûÿÿh@ù	õh’iù–4PQ@½°½Q)@ý±ýý{¨÷cB©õ[A©óSèÀ_Ö
ÀÀ“À‘ÀŽÀÀý{¿©ý‘qàTQqèTEÎÿ—H€RBÎÿ—(€R¹ý{Á¨À_Ö(D;Õ}@Ó
€Ò*DÕÀ_ÖD;Õ
à“R
Jé!*-Š)|@Ó|@Ó	Š«ª	à“Òi	Ê	DÕàªÀ_Ö(D;Õ
}@“Kª+DÕÀ_Ö(D;Õ}@ÓÀ_Ö<@¹€R
À(‹I)@yL
@y(
‹a‘Ì4
 ‘I@¹?@)ë£TH@¹		?@)ëãTkk ‘J¡‘£þÿT€ÒÀ_ÖóS¿©ý{¿©ý‘óªTÿÿ°€‘”`5€R
ˆ‘aË€‘Ûÿÿ—`µ€R$@¹éh* €Rý{Á¨óSÁ¨À_Ö@y©I‹R	kaT<@¹ªˆR
À(‹I@¹?k¡TH1@y €R-q@T€RÀ_Ö€Ò!5À9ˆ4
ì|’j7pÀ=S€’ˆ%Èšš N2
 NI>N*ê`TIÀÚH>N	ÀÚ)I87(}@Ó`
H‹wð}’@ýH	S
€’¨%Èšš 1
 )>N*ê THÀÚ	}@Ó€
I‹ilA‘Á<š N0:°n>Nˆÿÿ´1
 N(>Nˆ´ÀÚ
}S(>N	ÀÚ+j}SˆA*‹AÑV4Nì|’ðÀ=	
€’š NŽ4n1
 Nr
 N,>NO>N	7S)>NJ%ÈšH>N-
Š
Š(!Q	qSJ%ÉšOŠLŠ€Ò
€Ò†€RíµkµLµÏ´ˆÀÚ
ªÀÚk´iÀÚèÀÚ	_	kcTl>Nk>NJ86k´iÀÚˆÀÚ	È	KîH‹ðÁ<Ž4nš Nq
 NR
 N+>N/>NM>NL>NÞÿÿ)€Ò
´(!Êš	Ñ*ŠKÀÚ‰€R)KHQ(!Èš	Ñ*ê`TIÀÚˆÀÚ	É	K(}@ÓàH‹àªÀ_ÖÀ95è4
ì|’j7pÀ=S€’ˆ%Èšš N2
 NI>N*ê`TIÀÚH>N	ÀÚ)I87(}@Ó`
H‹rð}’@ýH	S
€’¨%Èšš 1
 )>N*ê THÀÚ	}@Ó€
I‹dlA‘Á<š N0:°n>Nˆÿÿ´1
 N(>Nˆ´ÀÚ
}S(>N	ÀÚ+j}SˆA*‹AÑQh5€ÒN	ì|’
€’é73NpÀ=SJ%Èšš NR
 NŽ3nH>N1
 N)>N.>N

ê,
Š`TªÀÚH>N	ÀÚ*l´‰ÀÚÈÀÚ	_	k+üÿT-T(}@“`
ˆ‹,
ð}’±@ý(	SI%Èš0š 
 >N0	Š1Ž0.1
 (>N
	Š_ëÃùÿT©THÀÚ
}@“ 
Š‹3NkA‘pÁ<š NŽ3n±NQ:°n(>NHÿÿ´R
 NH>Nh´	ÀÚH>N	ÀÚ)(}@Ói
H‹+AÑjÀ9_!k`ŸšÀ_Öý{¿©ýªáª(@ù@¹s»ÿ— Õý{Á¨À_ÖaÔý{¿©ýª@ù	@¹Ê?
kàŸý{Á¨À_ÖaÔÀóøý{¿©ýª ù±ƒ‘ þŸÈ¨C@9È4±ƒ‘(þßÈ	@ù±c‘)þŸÈ±c‘*þßÈéH@¹	kaT±c‘(þßÈ	@¹?qÁT±c‘(þßÈ©!@¹	k T±c‘(þßÈ	!@¹	kàT±c‘(þßÈi!@¹	kT…®ÿ—±c‘(þßÈù±ƒ‘)þßÈ3@ù~®ÿ—ù°Áÿ— Õ±S‘?þŸˆ±S‘ þ߈ý{Á¨óAøÀ_ÖaÔ Õcsmà “!“"“ý{¿©ýª¨@ù@ùë°ÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹Hßÿ— Õý{Á¨À_ÖaÔý{¿©ýª@ù@¹‰¾ÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹6ßÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@¹(4¨@¹ @¹ˆ4	|@“*ýF“HðA
‘)@’	€Òyjø*!›Iá@9(Há9ýßÿ— Õý{Á¨À_ÖaÔý{¿©ýª @¹õßÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹ìßÿ— Õý{Á¨À_ÖaÔý{¿©ýª€Rßÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹ýÞÿ— Õý{Á¨À_ÖaÔý{¿©ýªà€RõÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª €RíÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª€€RåÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª€RÝÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨C@9ˆ4`€RÓÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª @ùe°ÿ— Õý{Á¨À_ÖaÔý{¿©ýª`€RÃÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª@ù	@¹ª€R
¸r?
kàŸý{Á¨À_ÖaÔ0F\n„œ¸Òèþ.L^Ì€Žž®ºÈÖàø.FXj|Œ˜®ÂÐäò(:HVbt„œÄÐÞìö*6JZlv‚Ž¤ºÔî*<TjzŽ¢²¾È-@¨'@Ø&@'@=@U@ðþ@z@hj@H>@failed to create process.
failed to get exit code from process.
%s %s-script.pyCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %sp@@À3@ðŠ@‹@‹@‹@	(‹@
8‹@
H‹@X‹@	d‹@p‹@	€‹@	‹@˜‹@
¨‹@¸‹@	‹@Ä‹@Ћ@Ø‹@Ü‹@à‹@ä‹@è‹@ì‹@ð‹@ø‹@Œ@Œ@Œ@Œ@Œ@Œ@Œ@ Œ@$Œ@(Œ@,Œ@0Œ@4Œ@8Œ@<Œ@@Œ@DŒ@HŒ@LŒ@PŒ@TŒ@XŒ@\Œ@`Œ@dŒ@hŒ@lŒ@pŒ@tŒ@xŒ@|Œ@€Œ@	Œ@	 Œ@¨Œ@¸Œ@ÐŒ@àŒ@øŒ@@8@X@x@˜@#À@à@ Ž@(Ž@&PŽ@pŽ@€Ž@„Ž@Ž@ Ž@#ÄŽ@ÐŽ@	àŽ@ðŽ@@0@%X@$€@%¨@+Ø@ø@  @"H@(x@*¨@È@Ø@ð@‹@‘@‘@8‘@P‘@p‘@‹@Œ@Œ@PŒ@HŒ@(Œ@ÐŒ@‘@__based(__cdecl__pascal__stdcall__thiscall__fastcall__vectorcall__clrcall__eabi__swift_1__swift_2__ptr64__restrict__unalignedrestrict( new delete=>><<!==!=[]operator->*++---+&->*/%<<=>>=,()~^|&&||*=+=-=/=%=>>=<<=&=|=^=`vftable'`vbtable'`vcall'`typeof'`local static guard'`string'`vbase destructor'`vector deleting destructor'`default constructor closure'`scalar deleting destructor'`vector constructor iterator'`vector destructor iterator'`vector vbase constructor iterator'`virtual displacement map'`eh vector constructor iterator'`eh vector destructor iterator'`eh vector vbase constructor iterator'`copy constructor closure'`udt returning'`EH`RTTI`local vftable'`local vftable constructor closure' new[] delete[]`omni callsig'`placement delete closure'`placement delete[] closure'`managed vector constructor iterator'`managed vector destructor iterator'`eh vector copy constructor iterator'`eh vector vbase copy constructor iterator'`dynamic initializer for '`dynamic atexit destructor for '`vector copy constructor iterator'`vector vbase copy constructor iterator'`managed vector copy constructor iterator'`local static thread guard'operator "" operator co_awaitoperator<=> Type Descriptor' Base Class Descriptor at ( Base Class Array' Class Hierarchy Descriptor' Complete Object Locator'`anonymous namespace'(null)(null)ÀÀ–ÀÀŽÀÀÀ‘À’À“À´ÀµÀ	mscoree.dllCorExitProcess @€@X·@˜·@ -@ -@`÷@ø@À	@ð	@P€@øÉ@HÊ@Ⱦ@¿@¨<@ -@Ðí@ -@Ѐ@p€@ -@è@¸@ -@.\.com.exe.bat.cmd
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×Y*š@@š@€š@Àš@›@p›@À›@œ@@œ@€œ@Àœ@@P@°@ž@Pž@hž@€ž@ž@Øž@api-ms-win-core-datetime-l1-1-1api-ms-win-core-fibers-l1-1-1api-ms-win-core-file-l1-2-2api-ms-win-core-localization-l1-2-1api-ms-win-core-localization-obsolete-l1-2-0api-ms-win-core-processthreads-l1-1-2api-ms-win-core-string-l1-1-0api-ms-win-core-synch-l1-2-0api-ms-win-core-sysinfo-l1-2-1api-ms-win-core-winrt-l1-1-0api-ms-win-core-xstate-l2-1-0api-ms-win-rtcore-ntuser-window-l1-1-0api-ms-win-security-systemfunctions-l1-1-0ext-ms-win-ntuser-dialogbox-l1-1-0ext-ms-win-ntuser-windowstation-l1-1-0advapi32kernel32ntdllapi-ms-win-appmodel-runtime-l1-1-2user32api-ms-ext-ms-AreFileApisANSICompareStringExFlsAllocFlsFreeFlsGetValueFlsSetValueInitializeCriticalSectionExLCMapStringExLocaleNameToLCIDAppPolicyGetProcessTerminationMethod  @  @¤ @¤ @¨ @¨ @¬ @¬ @° @¨ @À @¬ @Р@¨ @à @¬ @INFinfNANnanNAN(SNAN)nan(snan)NAN(IND)nan(ind)e+000À£@Ä£@È£@Ì£@У@Ô£@Ø£@Ü£@ä£@ð£@ø£@¤@¤@ ¤@,¤@0¤@4¤@8¤@<¤@@¤@D¤@H¤@L¤@P¤@T¤@X¤@`¤@h¤@t¤@|¤@<¤@„¤@Œ¤@”¤@ ¤@°¤@¸¤@Ȥ@Ô¤@ؤ@à¤@ð¤@¥@¥@ ¥@(¥@0¥@8¥@@¥@H¥@P¥@`¥@p¥@€¥@˜¥@°¥@À¥@Ø¥@à¥@è¥@ð¥@ø¥@¦@¦@¦@¦@ ¦@(¦@0¦@8¦@H¦@`¦@p¦@ø¥@€¦@¦@ ¦@°¦@Ȧ@ئ@ð¦@§@§@§@0§@X§@p§@SunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssSunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssen-USja-JPzh-CNko-KRzh-TW         (((((                  H„„„„„„„„„„‚‚‚‚‚‚ €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿuk=¼@¼@ ¼@(¼@8¼@@¼@H¼@P¼@	X¼@
`¼@h¼@p¼@
x¼@€¼@ˆ¼@¼@˜¼@ ¼@¨¼@°¼@¸¼@À¼@ȼ@м@ؼ@à¼@è¼@ð¼@ø¼@½@ ½@!½@"À­@#½@$ ½@%(½@&0½@'8½@)@½@*H½@+P½@,X½@-`½@/h½@6p½@7x½@8€½@9ˆ½@>½@?˜½@@ ½@A¨½@C°½@D¸½@FÀ½@GȽ@Iн@Jؽ@Kà½@Nè½@Oð½@Pø½@V¾@W¾@Z¾@e¾@ ¾@(¾@8¾@H¾@°§@X¾@h¾@x¾@ˆ¾@	p§@˜¾@¨¾@
¸¾@Ⱦ@ؾ@è¾@€§@ §@ø¾@¿@¿@(¿@8¿@H¿@X¿@h¿@x¿@ˆ¿@˜¿@¨¿@ ¸¿@!È¿@"Ø¿@#è¿@$ø¿@%À@&À@'(À@)8À@*HÀ@+XÀ@,hÀ@-€À@/À@2 À@4°À@5ÀÀ@6ÐÀ@7àÀ@8ðÀ@9Á@:Á@; Á@>0Á@?@Á@@PÁ@A`Á@CpÁ@DˆÁ@E˜Á@F¨Á@G¸Á@IÈÁ@JØÁ@KèÁ@LøÁ@NÂ@OÂ@P(Â@R8Â@VHÂ@WXÂ@ZhÂ@exÂ@kˆÂ@l˜Â@¨Â@¸Â@§@ÈÂ@	ØÂ@
èÂ@øÂ@Ã@Ã@(Ã@8Ã@HÃ@`Ã@,pÃ@;ˆÃ@>˜Ã@C¨Ã@kÀÃ@ÐÃ@àÃ@ðÃ@	Ä@
Ä@ Ä@0Ä@;HÄ@kXÄ@hÄ@xÄ@ˆÄ@	˜Ä@
¨Ä@¸Ä@ÈÄ@;ØÄ@èÄ@øÄ@Å@	Å@
(Å@8Å@HÅ@;`Å@pÅ@	€Å@
Å@ Å@°Å@;ÈÅ@ØÅ@	èÅ@
øÅ@Æ@; Æ@ 0Æ@	 @Æ@
 PÆ@; `Æ@$pÆ@	$€Æ@
$Æ@;$ Æ@(°Æ@	(ÀÆ@
(ÐÆ@,àÆ@	,ðÆ@
,Ç@0Ç@	0 Ç@
00Ç@4@Ç@	4PÇ@
4`Ç@8pÇ@
8€Ç@<Ç@
< Ç@@°Ç@
@ÀÇ@
DÐÇ@
HàÇ@
LðÇ@
PÈ@|È@| È@arbgcazh-CHScsdadeelenesfifrhehuisitjakonlnoplptroruhrsksqsvthtruridbesletlvltfavihyazeumkafkafohimskkkyswuzttpagutateknmrsamnglkoksyrdivar-SAbg-BGca-EScs-CZda-DKde-DEel-GRfi-FIfr-FRhe-ILhu-HUis-ISit-ITnl-NLnb-NOpl-PLpt-BRro-ROru-RUhr-HRsk-SKsq-ALsv-SEth-THtr-TRur-PKid-IDuk-UAbe-BYsl-SIet-EElv-LVlt-LTfa-IRvi-VNhy-AMaz-AZ-Latneu-ESmk-MKtn-ZAxh-ZAzu-ZAaf-ZAka-GEfo-FOhi-INmt-MTse-NOms-MYkk-KZky-KGsw-KEuz-UZ-Latntt-RUbn-INpa-INgu-INta-INte-INkn-INml-INmr-INsa-INmn-MNcy-GBgl-ESkok-INsyr-SYdiv-MVquz-BOns-ZAmi-NZar-IQde-CHen-GBes-MXfr-BEit-CHnl-BEnn-NOpt-PTsr-SP-Latnsv-FIaz-AZ-Cyrlse-SEms-BNuz-UZ-Cyrlquz-ECar-EGzh-HKde-ATen-AUes-ESfr-CAsr-SP-Cyrlse-FIquz-PEar-LYzh-SGde-LUen-CAes-GTfr-CHhr-BAsmj-NOar-DZzh-MOde-LIen-NZes-CRfr-LUbs-BA-Latnsmj-SEar-MAen-IEes-PAfr-MCsr-BA-Latnsma-NOar-TNen-ZAes-DOsr-BA-Cyrlsma-SEar-OMen-JMes-VEsms-FIar-YEen-CBes-COsmn-FIar-SYen-BZes-PEar-JOen-TTes-ARar-LBen-ZWes-ECar-KWen-PHes-CLar-AEes-UYar-BHes-PYar-QAes-BOes-SVes-HNes-NIes-PRzh-CHTsr ¾@Bp½@,pÖ@q¼@€Ö@ØÖ@Ú Ö@±°Ö@ ÀÖ@ÐÖ@ÏàÖ@ÕðÖ@Ò×@©×@¹ ×@Ä0×@Ü@×@CP×@Ì`×@¿p×@ÈX½@)€×@›˜×@k½@!°×@c¼@À×@DÐ×@}à×@· ¼@ø×@E8¼@Ø@GØ@‡@¼@(Ø@HH¼@8Ø@¢HØ@‘XØ@IhØ@³xØ@«¾@AˆØ@‹P¼@˜Ø@JX¼@¨Ø@£¸Ø@ÍÈØ@¬ØØ@ÉèØ@’øØ@ºÙ@ÅÙ@´(Ù@Ö8Ù@ÐHÙ@KXÙ@ÀhÙ@Ó`¼@	xÙ@шÙ@ݘÙ@רÙ@ʸÙ@µÈÙ@ÁØÙ@ÔèÙ@¤øÙ@­Ú@ßÚ@“(Ú@à8Ú@»HÚ@ÎXÚ@áhÚ@ÛxÚ@ÞˆÚ@Ù˜Ú@Æ(½@#¨Ú@e`½@*¸Ú@l@½@&ÈÚ@hh¼@
ØÚ@L€½@.èÚ@sp¼@øÚ@”Û@¥Û@®(Û@M8Û@¶HÛ@¼¾@>XÛ@ˆÈ½@7hÛ@x¼@xÛ@Nˆ½@/ˆÛ@tؼ@˜Û@¯¨Û@Z€¼@
¸Û@OP½@(ÈÛ@j½@ØÛ@aˆ¼@èÛ@P¼@øÛ@•Ü@Q˜¼@Ü@Rx½@-(Ü@r˜½@18Ü@xà½@:HÜ@‚ ¼@¾@?XÜ@‰hÜ@S ½@2xÜ@y8½@%ˆÜ@g0½@$˜Ü@f¨Ü@Žh½@+¸Ü@mÈÜ@ƒø½@=ØÜ@†è½@;èÜ@„½@0øÜ@Ý@wÝ@u(Ý@U¨¼@8Ý@–HÝ@TXÝ@—°¼@hÝ@À½@6xÝ@~¸¼@ˆÝ@VÀ¼@˜Ý@W¨Ý@˜¸Ý@ŒÈÝ@ŸØÝ@¨È¼@èÝ@Xм@øÝ@Yð½@<Þ@…Þ@§(Þ@v8Þ@œà¼@HÞ@[ ½@"XÞ@dhÞ@¾xÞ@ÈÞ@°˜Þ@¸¨Þ@˸Þ@Çè¼@ÈÞ@\ È@ãØÞ@ÂðÞ@½ß@¦ ß@™ð¼@8ß@šHß@]¨½@3Xß@z¾@@hß@ŠÐ½@8xß@€Ø½@9ˆß@ø¼@˜ß@^¨ß@n½@¸ß@_¸½@5Èß@|À­@ Øß@b½@èß@`°½@4øß@žà@{H½@'(à@i8à@oHà@Xà@âhà@xà@¡ˆà@²˜à@ª¨à@F¸à@paf-zaar-aear-bhar-dzar-egar-iqar-joar-kwar-lbar-lyar-maar-omar-qaar-saar-syar-tnar-yeaz-az-cyrlaz-az-latnbe-bybg-bgbn-inbs-ba-latnca-escs-czcy-gbda-dkde-atde-chde-dede-lide-ludiv-mvel-gren-auen-bzen-caen-cben-gben-ieen-jmen-nzen-phen-tten-usen-zaen-zwes-ares-boes-cles-coes-cres-does-eces-eses-gtes-hnes-mxes-nies-paes-pees-pres-pyes-sves-uyes-veet-eeeu-esfa-irfi-fifo-fofr-befr-cafr-chfr-frfr-lufr-mcgl-esgu-inhe-ilhi-inhr-bahr-hrhu-huhy-amid-idis-isit-chit-itja-jpka-gekk-kzkn-inkok-inko-krky-kglt-ltlv-lvmi-nzmk-mkml-inmn-mnmr-inms-bnms-mymt-mtnb-nonl-benl-nlnn-nons-zapa-inpl-plpt-brpt-ptquz-boquz-ecquz-pero-roru-rusa-inse-fise-nose-sesk-sksl-sisma-nosma-sesmj-nosmj-sesmn-fisms-fisq-alsr-ba-cyrlsr-ba-latnsr-sp-cyrlsr-sp-latnsv-fisv-sesw-kesyr-syta-inte-inth-thtn-zatr-trtt-ruuk-uaur-pkuz-uz-cyrluz-uz-latnvi-vnxh-zazh-chszh-chtzh-cnzh-hkzh-mozh-sgzh-twzu-zaäTc-^Çk@êítFÐœ,Ÿaõ¹«¿¤\Ãñ)cdµý4ÄÒ‡f’ù;lDÙe”,Bb×E"š&'OŸ@•Á‰V$§úÅgmÈsÜm­ërÁÎd'¢cʤï%{ÑÍpïßk>ê_änþÃÍj¼f29.EZ%øÒqVJÂÃÚ.¨C²ª|!Ž@ΊóÎÄ„'ë|Ô%­I@ÝÚTŸÌ¿aYÜ««\ÇDõg¼ÑR¯·û)`”*!Š»¤Ž¯V©ŸG6²K]à_Ü€
ªþð@ÙŽ¨Ð€k#cd8L2–ÇWƒÕBJäa"©Ù=<½róå‘tYÀ
¦ìlÙ*Óæ…[aOni*{âP+4Ý/î'Pc™qɦéJŽ(.onIn@2&@­PrùÕÑ”)»Í[f–.;¢Û}úe¬SÞw›¢ °Sù¿Æ«%”KMã-ÃûôÐ"RP(·óòWBÜ}]9Ö™Yø8’Ö³†¹w¥zaþ·jaägÃV ”:‹6	›ip½¾ev ëÄ&›ègn	+ò2qQH¾Î¢åER»x”÷ÀtŒ]ð°uÆÛ©¹ÙâßreLK(wàöm‘CQÏÉ•'U«âÖ'樜¦±=@JÐìôðˆ#Åm
Xo¿CÃ]-øHîY ú(ðôÍ?¥. qÖ¼‡Di}nùVyu¤á²¹º èÈÏçUÀúá²Dï°~ $s%rÑù¸ä®@b;zO]¤Î3AâOmm!ò3VåVÁ%—×ë(„ë–Ów;I®-G 8­–ÑÎúŠÛÍÞN†ÀhU¡]i²‰<$qE}A'JnW®b쪉"ïÝû¢¶äïáò½f3€ˆ´7>,¸¿‘Þ¬dôÔNjÿ5jVg¹Û@Ê;*xh›2kÙůõ¼id&äô_€û¯ÑUí¨ J›øW—«
þ®{¦,Ji•¿)ÄǪÒÕØvÇ6ÑUÚ“Çš¨ËK%vð
	ˆ¨÷t:üHå­ŽcYçË—èi×&>rä´†ª["93œuzK‘éG-wùnšç@Äø’ð_òlÃ%B‹ùÉ‘s¯|ÿ…-C°iu+-,„W¦ïÐ@zÇåb¸èjˆØå˜ÍÈÅU‰U¶YÐÔ¾ûX1‚¸EL9ÉM¬ÅâÀLy¡€É;Ñ-±éø"m^š‰8{ØyÎrvÆxŸ¹åyN”ä¡éÔ\lo}ä›çÙ;ù¡obwQ4‹ÆèY+ÞXÞ<ÏXÿF"|W¨Yuç&Sgwc·æë_
ýãi9è35 ¨‡¹1öC!ÛCZØ–õ«¢?hdþ}¾/ÉK°íõáÚN¡sÛ	äœîOg
Ÿ©Öµµö–8s‘ÂIëÌ—+_•?8ö³‘ 7xÑßBÑÁÞ">W߯Š_åõw‹Êç£[R/=OçB
ÝôR	E]áB´®.4³£o£Í?nz(´÷wÁKÐÈÒgàø¨®g;É­³VÈl•ÁH[=Š¾Jô6ÙRMèÛqÅ!ù	EJjت×|Lᜥ›uˆ<ä@’Ôñ¾rdÁ6‡û«x)¯Qü9—ë%0+L¡;<þ(ºüˆwXCž¸¤ä=sÂòF|˜bt!Û®¶£.²Pª«9êB4–—©ßßþÓóÒ€y 7›œPñ­ÜÇ,­=87MÆsÐgmꨛQøòÄ¢áR :#שs…DºÙχp›:ÜRèR²åNû/¦M¾á׫
OíbŒ{ì¹Î!@fÔƒ¡æuãÌò)/„äwdûõÓq=v é/}fLô3.ñ¸óŽ
i”Ls¨&`@<
ˆqÌ!-¥7ïÉÚŠ´1»BALùÖl‹È¸â|í—RÄaÃbªØÚ‡Þê3¸ah𔽚ÌjÕÁ-è6zÆž)ô
?IóϦ¥w£#¾¤‚[¢Ì/r5D¾¸¨N2LÉ­3ž¼ºþ¬v2!L.2Í>´‘þp6Ù\»…—BýÌFøÝ8æÒ‡iÑþñµ>®«¹Ãoî¾@ªÂ@Ùwø,=×áq˜/çÕ	cQrݨ¯FZ*ÖÎÜ*þÝFÎ$'­Ò#·»Ä+Ì·Êë±GÜK	ÊÜÅŽQæ1€VÃŽ¨X/4B‹å¿þüÿycgý6ÕfvPá¹ba°g
ÒÀáÐ;sÛ?.Ÿ£â²aâÜc*¼&”›Õpa–%ã¹u!,`j¸¢;Ò‰s}ñ`ß×ÊÆ+ßi7‡¸$í“fënIoÛ“u‚t^6šnÅ1·6ÅB(ÈŽy®$ÞdAÁšˆÕ™,CÙ瀢.=ök=yI‚C©çyJæý"špÖàïÏÊפ½ldã³ÜN¥n¨¡žEtÈTŽüWÆtÌÔøBncÙWÌ[µ5éþlaQÄÛº•µNñ¡PçùÜqc+Ÿ/Þ"‰½^Î̯…p?Óm-è}o”i^á,ŽdH9¡•à4X<´”öH'½W&|.Ú‹u €;¶Û-HÏm~ä$™P	
%-5	>
H
R]iu
‚Ÿ®¾Ïàò-C	Y	p	ˆ
 
¹
Ó
î	%
dè' †@B€–˜áõÊš;01#INF1#QNAN1#SNAN1#IND¨À?˜‚Ÿ?Xt§?0
¯?×A³?Òð¶?m’º?'¾?~×À?€R•Â?+MÄ?0ÿÅ?‰«Ç?€ZRÉ?ÉóÊ?€÷Ì?'Î?¹Ï?À$£Ð?€\gÑ?ÀA)Ò?€âèÒ?@L¦Ó?À‹aÔ?€­Õ?€½ÑÕ?ȆÖ?À×9×?øê×?€3šØ?”GÙ?À#óÙ?€ìœÚ?@÷DÛ?€MëÛ?À÷Ü?@þ2Ý?jÔÝ?@BtÞ?@ß?€X¯ß? R%à?@>rà?àr¾à?€ó	á?ÀÃTá? æžá?@_èá?À01â?^yâ?àéÀâ? ×ã?€(Nã?Àà“ã?`Ùã?àä?À‹aä?@ø¤ä?Øçä? -*å?Àùkå?@@­å? îå?àB.æ?Ûóy|€6>Èg˜Ásh>žÆˆŸ[Æ^>™/ÌT,X>0S:zÃb>“|si­\a>é…²±j%M>¢zz¹¼Š[>Ü¥Y–#4o>wÓHýn>öô™Gß2k>øòôä)l>YßHȆ>0Av´VôL>˜3¶ü/ c>v	kˆ¦æa>¢zz¹¼Šk>RU£ŠWk>ü¹¯qÈ9a>dÎÓÕe>B!Ѳ¼çm>dN˜Žpm>6/ÇéEiU>Ú[èöâ >ö$'´à·<>ÇF(å¬o>¾BÄ®›^>&qNè]k>ÓY²áWÁm>bœÖj	;>ÝLºú!\>G[ù%Ì_f>PHIšZ>w_F±Gæm>†÷{§]>`—°†hj>>dï°êuo>›˜û‚3>Ò¾ñÃCë`>„\³ì¯_>h_³=æñN>¥qûC—F>–WN@ßl>^bÚ
ª”@>ìãý–L-n>4©éÕôb>¾\ÌnÉgd>Zì=Ð@pn>6Þ‚B¿¾g>?x뱉b>8õr‰Z>‘µ¾Oc>“ëÓáœm>BÄ©*Vc>LHõ­âT>zÉÈ\åŒP>Ú[èöâ0>¿'»>°m>˜°œ°[·a>"ß¹«oI>bA™ó³e>USöY>kX>¬áê,HR>log10CONOUT$F»Wa
|€ð€â8@x‚@h@.text¸[.text$mnÀyä.text$x€x.idata$5x‚.00cfg€‚.CRT$XCAˆ‚.CRT$XCAA‚.CRT$XCZ˜‚.CRT$XIA ‚.CRT$XIAA¨‚.CRT$XIAC°‚.CRT$XICÈ‚.CRT$XIZЂ.CRT$XPAØ‚.CRT$XPXè‚.CRT$XPXAð‚.CRT$XPZø‚.CRT$XTAƒ.CRT$XTZƒpm.rdata€ð€.rdata$zzzdbgó.rtc$IAAó.rtc$IZZó.rtc$TAAó.rtc$TZZ óp.xdataþ.idata$2¤þ.idata$3¸þx.idata$40¬.idata$6
.data@.bss08.pdata ÖB*ä ÖB*äX0 Àj×ɆÉÈ‚*äããã &¨ÿÿÿ@€ää@@äìää@âBäBä-@(@áÔäãããhP\@áƒÐ‚$äãã°0ð')Ày)P)`)Ày)
@äãã@@ääáƒä4páƒäã°0ø*´+èy´+@äãã@@áäã'@"@á"ä!@@á"äcä.P(@á…"ä°04(4z(4B@9Ôä@€äää@0@â
JÊɆÉÈ‚,äJÊɆÉÈ‚,ä@0@â
JÊɆÉÈ‚,äJÊɆÉÈ‚,ä@@áäãä9ääHä)@8!@ÊÉŠÉȆÈBäÊÉŠÉȆÈBäv0áÉȄȇäããã &¸ÿÿÿˆ@;@á"äJ0áЄÈ…äã &Èÿÿÿ;0áЄÈ…äã &Èÿÿÿ20áЄÈ…äã &Èÿÿÿpáƒ"ä°0??{	@äãã-	@@&@*@áƒ"äJ@?@áÑÈ‚&äáÔäããã5@0@á‡ÔäãããCP>@áЂ$äãã°0¼t,ud{upáƒ"ä°0htpt@{!pá…È‚$äãã°0yÜyˆ{páƒ"ä°0`{l{@{páƒ"ä°0¨{´{@{
áÔäããã°0¸ÐÐc`áÑЂ$äœ@@áÒɆÉÈ‚*äpáƒ"ä°0ø‚@{Ê@Äá¡"ä
 áããääããã1P	@áƒ"ä°0(‹P‹¬{@äãã@@áƒÑÈ‚&äº@¬@áƒÉ†ÉÈ‚(äããNpáƒÒцÉÈ‚(ä°0|ž¸ž|@äãã!páƒ"ä°0У¤(| äããáäã+@@áÉÈ‚&ä8@@áäã5páƒÈ‚$äãã°0 ¸¸¸L|1páƒ"ä°0ø¸ˆ¹{;pá‹È‚$äãã°0Ĺtºl|páÔäããã°0à¾ø¾|s@E@á‡Ð‚$äãã/ä7ä*ä5ä;@6@áЂ$äãã.@*@á"äpáƒ"ä°0˜Ã¸Ã@{páƒ"ä°0pĈÄ@{páƒ"ä°0ÀÄüÄ@{páƒ"ä°0ðÃ8Ä@{2@
@áäãŽ@@á…ɆÉÈ‚(äãã=`áÈÂ$äãã:0áȃäããã &Øÿÿÿh`áÑЂ$ä@€@á‡ÒɆÉÈ‚*äd@@áцÉÈ‚(äããÚPÑáшÉȄȉäã &¨ÿÿÿB0áȃäããã &ØÿÿÿJ`áÐÂ$äãã¤0áÑȄȇäããã &¸ÿÿÿ2P-@áЂ$äãã°0Lí¬í°|\@+@á‡È‚$äããƒ0áЃäããã &ØÿÿÿVpáƒÈ‚$äãã°0Ôæðç@{Å@¸@áÒɆÉÈ‚*ä9@@áÈ‚$äããVP$@áƒÉÈ‚&ä°0<üœü|¼üpý|.P
@áƒÉÈ‚&ä°0lú¨ú|¸úÐú|o0 áÒ
ɈÉÈ„È‹äããã &˜ÿÿÿP@á"ä°0p„Ð|páÔäããã°0”°ð|šP%@á…ÒцÉÈ‚(ä°0Ü
Œ}0}páƒ"ä°0ä@{a@U@áƒÉ†ÉÈ‚(äããÜPÏáшÉȄȉäã &¨ÿÿÿ20áЃäããã &ØÿÿÿFpáƒÒцÉÈ‚(ä°0¼"ø"|Ì0 áÒ
ɈÉÈ„È‹äããã &˜ÿÿÿ40 áÒ
ɈÉÈ„È‹äããã &˜ÿÿÿN0áÑȄȇäããã &¸ÿÿÿL0áÈ„È…äã &Èÿÿÿ_0 áÒ
ɈÉÈ„È‹äããã &˜ÿÿÿFpáƒÒцÉÈ‚(ä°0´(ð(|P@áƒ"ä°00,<,8}-páƒ"ä°0p,ì,(|j@F@áƒÒɆÉÈ‚*ä*@@áЂ$äããgP VáÒ
ɈÉÈ„È‹äããã &˜ÿÿÿû@=ò÷È‚$äãããP áÒ
ɈÉÈ„È‹äããã &˜ÿÿÿ+P'áäã &èÿÿÿÂP °áÒ
ɈÉÈ„È‹äããã &˜ÿÿÿ=P3@áÈ‚$äãã°0„Y ZX}uäð>lõ8?¥ãA©f8Bme¨BaHCDõPE­dF$õ H!b¸J…a@KÅaL‰aLµàPNµàP•cˆSecÐV©ãxWâ˜YÕapZ5f°\­bh]Áã(^µà`_0õˆ`XõPaÅeb)è@cu`¸cõfUaèf˜õ g	e(j]b°jQçmqapm™äo}bˆo°õ°pÍã€qUbØqUb0rMa€r‘bs]bxsqeès]äHtöˆtÜõ°uÌõˆvÀõøv™âxAàXxQàpy$öz1`@zaàzMà@{Höˆ{höÐ{½f}Iiè~=à`A`¸-àèà€MaP€àp€]bЀ]a0%àXEà ˆöØÌö ‚¸ö„ìö¸‡¬ö`‰‰äèŠ÷°‹H÷˜Ž8÷‘Ùâè‘øö ’1hP“‰éØ—ñéÈ™éè›áiÈ\÷Ÿ­é°£÷8¤±àè¤íãØ¥°÷ð¥àp¦¸÷ЦçPª±ã«À÷@¬aa ¬)àȬ)àø¬±b¨­Ð÷ˆ®•ã8¯aa˜¯%iÀ±eb0²Yaˆ²õi€³mbð³qb`´qbд…ãXµäèµõià¶u㘷eã¸Ü÷ظø ¹ øºa`ðºµb¨»ea¼ia€¼ýg€½IiȾDø¿EbX¿¡ãø¿-`(Àuã¨ÁhøxôøÐÃùPÄÔø ÄôøÅÉàØÅ-aÆí`øÆmbhǘøXȨøÉåãøÉMàHÊ9a€ÊMaÐÊMa ËqiÎÕåhÏ@ù Ñ¹fXÓgxÔ4ù@ÕTù8Ö1dhØ5àðØYaHÙõb@Úaa Ú`ù¨ÛtùHÝ€ù€ß”ùá¨ù€äØù¨åÄù°æHúXè©aé…bˆé4ú˜ë$úíüùÐíqb@î!à`îäù0ò%eXólúpö€ú`÷yäøme˜øE`àøÍf°ùeäúÈúûåfüúpýíe`þ‘àÿ-b@bÐQã Íað-`hû Qe°Ia8û¨yb 	¡äÀ	1à
ÁeÀ
aä0Qb€@ûÈ û€1`Èdû0™àÈÔû8ÀûÀái ðûh	cpHü@düx|ü¨ ü("ü@#,üp&­f (¬ü8)Ác*}àˆ*¹f@+•bØ+ÔüP,øü-¡à¨-aa.IáP.ýø/ÕàÐ0Õã¨1Qäø2\ýè6<ýˆH,ý0IàHIc`JµáK}b˜L|ý°Pœý`Q°ýhT¥çU!àHUåã0VÅäHXMà˜XÅä`YÐýXZ±ãh[YàÀ[µãx\=`à\þ¨^ya(_1aX_eáÀ_]áeaàeþhi•çjeajõe€léàpm©ãn4þhoæ˜s=à°tTþÀyÀóèyôz\ô{Œõ@{Œõd{Œõˆ{Œõ¬{,÷|„÷(|ŒõL|„÷l|Œõ|„÷°|„÷Ð|„÷ð|„÷}Àó8}„÷X}„÷x}tþ€x¢ˆ¢ ¢¨¢°¢¸¢À¢Ø¢à¢è¢Ø£à£è£ð£¤¤ ¤0¤@¤P¤`¤p¤€¤¤ ¤°¤À¤Ð¤à¤ð¤¥¥ ¥0¥@¥P¥`¥p¥€¥¥ ¥°¥À¥Ð¥à¥ð¥¦¦ ¦0¦@¦P¦`¦p¦€¦¦ ¦°¦À¦Ð¦à¦ð¦§§ §0§@§P§`§p§€§§ §°§À§Ð§à§ð§¨¨ ¨0¨@¨P¨`¨p¨€¨¨ ¨°¨À¨Ð¨à¨ð¨©© ©0©@©P©`©p©€©© ©°©À©Ð©à©ð©ªª ª0ª@ªPª`ªpª€ªª ª°ªÀªÐªàªdЦà¦ð¦ø¦§§§§ §(§8§@§H§P§X§`§h§p§ˆ§˜§¨§°§¸§À§È§`©h©p©x©€©ˆ©©˜© ©¨©°©¸©À©È©Ð©Ø©à©è©ð©ø©   ( 0 8 @ H P X ` h p x € ˆ  ˜ ¡¡¡¡ ¡(¡0¡8¡@¡H¡P¡X¡`¡h¡p¡x¡€¡ˆ¡¡˜¡ ¡¨¡°¡¸¡À¡È¡Ð¡Ø¡à¡è¡ð¡ø¡¢¢¢¢ ¢(¢0¢8¢@¢H¢P¢`¢h¢p¢x¢€¢ˆ¢¢˜¢ ¢¨¢°¢¸¢À¢È¢Ð¢Ø¢à¢è¢ð¢ø¢££££ £(£0£8£@£H£P£X£`£h£p£x£€£ˆ££˜£ £¨£°£¸£Ø­è­ø­®®(®8®H®X®h®x®ˆ®˜®¨®¸®È®Ø®è®ø®¯¯(¯8¯H¯X¯h¯x¯ˆ¯˜¯¨¯¸¯È¯Ø¯è¯ø¯°Œ  ( 8 H X h x ˆ ˜ ¨ ¸ È Ø è ø ¡¡(¡8¡H¡X¡h¡x¡ˆ¡˜¡¨¡¸¡È¡Ø¡è¡ø¡¢¢(¢8¢H¢X¢h¢x¢ˆ¢˜¢¨¢¸¢È¢Ø¢è¢ø¢££(£8£H£X£h£x£ˆ£˜£¨£¸£È£Ø£è£ø£¤¤(¤8¤H¤X¤h¤x¤ˆ¤˜¤¨¤¸¤È¤Ø¤è¤ø¤¥¥(¥8¥H¥X¥h¥x¥ˆ¥˜¥¨¥¸¥È¥Ø¥è¥ø¥¦¦(¦8¦H¦X¦h¦x¦ˆ¦˜¦¨¦¸¦È¦Ø¦è¦ø¦§§(§8§H§X§h§x§ˆ§˜§¨§¸§È§Ø§è§ø§¨¨(¨8¨H¨X¨h¨x¨ˆ¨˜¨¨¨¸¨È¨Ø¨è¨ø¨©©(©8©H©X©h©x©ˆ©˜©¨©¸©È©Ø©è©ø©ªª(ª8ªHªXªhªxªˆª˜ª¨ª¸ªÈªØªèªøª««(«8«H«X«h«x«ˆ«˜«¨«¸«È«Ø«è«ø«¬À0¨@¨P¨`¨p¨€¨¨ ¨°¨À¨Ð¨à¨ð¨©© ©0©@©P©`©p©€©© ©°©À©Ð©à©ð©ªª ª0ª@ªPª`ªpª€ªª ª°ªÀªÐªàªðª«« «0«@«P«`«p«€«« «°«À«Ð«à«ð«¬¬ ¬0¬@¬P¬`¬p¬€¬¬ ¬°¬À¬Ð¬à¬ð¬­­ ­0­@­P­`­p­€­­ ­°­À­Ð­à­ð­®® ®0®@®P®`®p®€®® ®°®À®Ð®à®ð®¯¯ ¯0¯@¯P¯`¯p¯€¯¯ ¯°¯À¯Ð¯à¯ð¯ÐØ    0 @ P ` p €    ° À Ð à ð ¡¡ ¡0¡@¡P¡`¡p¡€¡¡ ¡°¡À¡Ð¡à¡ð¡¢¢ ¢0¢@¢P¢`¢p¢€¢¢ ¢°¢À¢Ð¢à¢ð¢££ £0£@£P£`£p£€££ £°£À£Ð£à£ð£¤¤ ¤0¤@¤P¤`¤p¤€¤¤ ¤°¤À¤Ð¤à¤ð¤¥¥ ¥0¥@¥P¥`¥p¥€¥¥ ¥°¥À¥Ð¥à¥ð¥¦¦ ¦0¦@¦P¦`¦àh¯€¯ð@ D¢Ø¢ø¢£8£X£ˆ£ £¨£°£è£ð£@©H©P©X©`©h©p©x©€©ˆ©˜© ©¨©°©¸©À©È©Ð©././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/cli.exe0000644000175100001710000020000000000000000017057 0ustar00runnerdockerMZÿÿ¸@ິ	Í!¸LÍ!This program cannot be run in DOS mode.

$YSþj292929:ôë9292‘9F29 }929`9929`929`9m29`929Rich29PELø°‹Qà	ÊNç%à@@€,ù(ˆô@à@.text]ÉÊ `.rdata` à"Î@@.dataÄ+ð@ÀQ‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPès
ƒÄ3ÿ3Û‰D$Æ"p…í~W뛋L$Š<\uGë <"u…ÿ~Wj\Vè
ƒÄ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ÷‹D$_Æ"ÆF^][YÃì¡€A3ĉ„$V‹´$W‹¼$Š‹Ï„Àtd$AƒÀ@PèƒÄF^‹Œ$3Ìè!	ÄÃWhŒ$ QV虫V¼,訊„$,ƒÄH@;ÇsŠ„Ét
€ù
t€ù
uëj”$ hâ@RÆèT
ƒÄ…Àt2¡â@‹
â@‹â@‰„$ â@‰Œ$ ‰”$$ˆ„$(L$Q”$"Rè…ûÿÿ‹0‰D$ D$$PVè$úÿÿ‹øƒÄ‰|$…ÿuVhàá@éµS‹\$U‹¬$,+‰D$@jPèå‹ðW‰t$èCùÿÿ‰¿ƒÄƒÆ;ß~‹ÿ‹L$ ‹¹Rè#ùÿÿ‰GƒÄƒÆ;û|æD$$Pèùÿÿ‰¿ƒÄƒÆ;ï~‹L$‹¹Rèîøÿÿ‰GƒÄƒÆ;ý|惼$4]Ç[tE‹D$‹t$PVè$¤ƒÄVhÌá@蓃À@PènƒÄ_¸^‹Œ$3ÌèsÄËL$‹T$‹D$QRPè†üÿÿPèÀûÿÿ‹Œ$,ƒÄ_^3Ìè?ÄÃÌÌÌÌÌÌ‹D$‹L$jPQèýÿÿƒÄÃjhðô@èŸ3ö‰uä3À‹];Þ•À;Æu è;ÇVVVVVèÃăÈÿéÍ3À9u•À;ÆtÔ‰]SèŸY‰uüöC@uwSè*Yƒøÿtƒøþt‹ÐÁú‹ÈƒáÁá• *A빘AöA$u)ƒøÿtƒøþt‹ÈÁùƒàÁà *A븘Aö@$€tè¡ÇVVVVVè)ƒÄƒMäÿ9uäu#SèL
‹øEPVÿuS貉EäSWèÎ
ƒÄÇEüþÿÿÿè	‹EäèßÃÿuèLYøAáÀ;AVj^…Àu¸ë;Æ}‹Æ£À;AjPè“ YY£¼+A…ÀujV‰5À;Aèz YY£¼+A…ÀujX^Ã3Ò¹A롼+A‰ƒÁ ƒÂù€A|êjþ^3Ò¹AW‹ÂÁø‹… *A‹úƒçÁ狃øÿt;Æt…Àu‰1ƒÁ BùpA|Î_3À^Ãè§#€=0 Atèp!ÿ5¼+Aè× YËÿU‹ìV‹u¸A;ðr"þ`Aw‹Î+ÈÁùƒÁQèç$N€Yë
ƒÆ Vÿà@^]ËÿU‹ì‹Eƒø}ƒÀPèº$‹EH€Y]ËEƒÀ Pÿà@]ËÿU‹ì‹E¹A;Ár=`Aw`ÿÿÿ+ÁÁøƒÀPè—#Y]ÃÀ Pÿà@]ËÿU‹ì‹Mƒù‹E}`ÿÿÿƒÁQèh#Y]ÃÀ Pÿà@]ËÿU‹ìQƒeüVEüPÿuÿuèL$‹ðƒÄ…öu9Eütèa…Àt
èX‹Mü‰‹Æ^ÉÃÌÌÌÌÌÌÌÌÌÌ‹T$‹L$…Òti3ÀŠD$„Àuúrƒ=ˆ*Atée%W‹ùƒúr1÷Ùƒát+шƒÇƒéuö‹ÈÁàÁ‹ÈÁàÁ‹ÊƒâÁétó«…Òt
ˆƒÇƒêuö‹D$_ËD$ÃÌÌÌÌÌÌ‹L$W…É„’VS‹Ù‹t$÷Æ‹|$uÁé……ë'ŠƒÆˆƒÇƒét+„Àt/÷Æuå‹ÙÁéuaƒãtŠƒÆˆƒÇ„Àt7ƒëuí‹D$[^_Ã÷ÇtˆƒÇƒé„˜÷Çuê‹ÙÁéutˆƒÇƒëuö[^‹D$_ɃǃétŸºÿþþ~‹Ѓðÿ3‹ƒÆ©tÜ„Òt,„öt÷Âÿt÷Âÿuĉëâÿÿ‰ëâÿ‰ë3Ò‰ƒÇ3Àƒét3À‰ƒÇƒéuöƒã…wÿÿÿ‹D$[^_ËÿU‹ìÿuÿuÿuÿujÿÿuè %ƒÄ]ËÿU‹ìQQS3ÛVW‰]ø9]t}‹M;Ëu9]uqë9]tj9]u9]u`ë9]tY9]u9] uOë9] tH9]$u>9](u>‹u3À@8tHF;Ãwö€>:u5;Ëtƒ}‚õjÿujÿQè%&ƒÄF‰uë9](uÂÇEøéÎ;Ëtˆ‹u3ÿ‰]ü8tU¾PèØ%Y…ÀtFëŠé¤þÿÿ‹ÿU‹ìV‹uVèSPè?YY…Àt|èÐòÿÿƒÀ ;ðu3ÀëèÀòÿÿƒÀ@;ðu`3À@ÿ A÷FuNSW<…H Aƒ?»u Sè	Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N3À_@[ë3À^]ËÿU‹ìƒ}t'V‹u÷FtVèfÿîÿÿƒfƒ&ƒfY^]ÃöA@tƒyt$ÿIx‹ˆÿ¶Àë¾ÀQPèå-YYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìöG@SV‹ð‹Ùt2ƒu,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕƒ8*u‹Ï°?èdÿÿÿƒ}Õ^[]ËÿU‹ììx¡€A3ʼnEüS‹]V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè#÷ÿÿ…öu5èMÇ3ÀPPPPPèӃĀ½°ýÿÿt
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF@u^Vè@
Yº˜Aƒøÿtƒøþt‹Èƒá‹ðÁþÁáµ *Aë‹ÊöA$u‘ƒøÿtƒøþt‹ÈƒàÁùÁà *Aë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu¡A‰…äýÿÿ‹…äýÿÿëI€8t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ…\‹…ðýÿÿ¨@t2©t	Æ…Ôýÿÿ-ë¨t	Æ…Ôýÿÿ+ë¨tÆ…Ôýÿÿ Ç…Ðýÿÿ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿuÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄƒ½Èýÿÿ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFè5ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿYuµëƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ|ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄƒ½¼ýÿÿtÿµ¼ýÿÿ胥¼ýÿÿY‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿt
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èìÿÿÉÃê*@ë(@)@y)@Å)@Ð)@*@D+@jThPõ@èe3ÿ‰}üEœPÿ@à@ÇEüþÿÿÿj@j ^VèuYY;Ç„£ *A‰5*Aˆë0Æ@ƒÿÆ@
‰xÆ@$Æ@%
Æ@&
‰x8Æ@4ƒÀ@‹
 *AÁ;ÁrÌf9}΄
‹EÐ;Ç„ÿ‹8X;‰Eä¾;þ|‹þÇEàë[j@j èçYY…ÀtV‹Mà *A‰ƒ*A ë*Æ@ƒÿÆ@
ƒ`€`$€Æ@%
Æ@&
ƒ`8Æ@4ƒÀ@‹Ö;ÂrÒÿEà9=*A|ë‹=*Aƒeà…ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨uQÿ<à@…Àt<‹uà‹ÆÁøƒæÁæ4… *A‹E䋉ŠˆFh FPè€*YY…À„ÉÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A‹ƒøÿtƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ8à@‹øƒÿÿtC…ÿt?Wÿ<à@…Àt4‰>%ÿƒøu€N@ë	ƒøu€Nh FPèê)YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*Aÿ4à@3Àë3À@ËeèÇEüþÿÿÿƒÈÿècËÿU‹ì‹EV3ö;Æuè½VVVVVÇèEƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A]ËÿU‹ìì(¡€A3ʼnEüƒ¥ØüÿÿSjL…ÜüÿÿjPèåÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…ØüÿÿÀÇ…Üüÿÿ‰…äüÿÿÿXà@j‹ØÿTà@…(ýÿÿPÿPà@…Àu…Ûujèé1YhÀÿLà@PÿHà@‹Mü3Í[è(èÿÿÉËÿU‹ìÿ5P Aè&Y…Àt]ÿàjèª1Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØAtAƒù-rñHíƒùwj
X]ËÍÜA]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ã蜅Àu¸@AÃÀÃ艅Àu¸DAÃÀËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌhÐ7@dÿ5‹D$‰l$l$+àSVW¡€A1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹]V‹s35€AW‹ÆEÿÇEô{ƒøþt
‹NÏ38èÙæÿÿ‹N‹FÏ38èÉæÿÿ‹Eö@f…‹MUè‰Sü‹[‰Eè‰Mìƒûþt_I[‹L†D†‰Eð‹‰Eø…Ét‹×è$1ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿt$‹ƒøþt
‹NÏ38èVæÿÿ‹N‹VÏ3:èFæÿÿ‹Eô_^[‹å]ÃÇEôëÉ‹M9csmàu)ƒ=Œ*At hŒ*Aèƒ!ƒÄ…Àt‹UjRÿŒ*AƒÄ‹MèÇ0‹E9Xth€AW‹Ó‹ÈèÊ0‹E‹Mø‰H‹ƒøþt
‹NÏ38èÃåÿÿ‹N‹VÏ3:è³åÿÿ‹Eð‹H‹×è]0ºþÿÿÿ9S„Rÿÿÿh€AW‹Ëèu0éÿÿÿ‹ÿU‹ìVW3öÿuèÅ0‹øY…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öjÿuÿuèE‹øƒÄ…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿuÿuèû0‹øYY…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿuÿuèÅ2‹øƒÄ…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿu½‹Ç_^]Ãjhpõ@è×üÿÿ‹u…ötuƒ=„*AuCjèYƒeüVè×2Y‰Eä…Àt	VPèø2YYÇEüþÿÿÿèƒ}äu7ÿuë
jèYÃVjÿ5t)Aÿ`à@…Àuè üÿÿ‹ðÿ\à@PèÐûÿÿ‰Yè›üÿÿÃjhõ@èIüÿÿ3Û‰]äjè–Y‰]üj_‰}à;=À;A}W‹÷Á桼+AÆ9tD‹ö@ƒtPèj=YƒøÿtÿEäƒÿ|(¡¼+A‹ƒÀ PÿDà@¡¼+Aÿ4èýþÿÿY¡¼+A‰GëžÇEüþÿÿÿè	‹EäèüÿÿÃjè7YËÿU‹ìSV‹u‹F‹È€á3Û€ùu@©t9‹FW‹>+ø…ÿ~,WPVèeùÿÿYPè‡DƒÄ;Çu‹F„Àyƒàý‰FëƒN ƒËÿ_‹Fƒf‰^‹Ã[]ËÿU‹ìV‹u…öu	Vè5Yë/Vè|ÿÿÿY…ÀtƒÈÿë÷F@tVèüøÿÿPèûDY÷ØYÀë3À^]Ãjh°õ@èúúÿÿ3ÿ‰}ä‰}ÜjèDY‰}ü3ö‰uà;5À;Aƒ¡¼+A°98t^‹ö@ƒtVPVèDÝÿÿYY3ÒB‰Uü¡¼+A‹°‹HöÁƒt/9UuPèJÿÿÿYƒøÿtÿEäë9}uöÁtPè/ÿÿÿYƒøÿu	E܉}üèFë„3ÿ‹uࡼ+Aÿ4°VèMÝÿÿYYÃÇEüþÿÿÿèƒ}‹Eät‹EÜè{úÿÿÃjè­YÃjèÿÿÿYËÿVW3ö¿X Aƒ<õLAuõHA‰8h ÿ0ƒÇè}!YY…ÀtFƒþ$|Ò3À@_^Ã$õHA3Àëñ‹ÿS‹Dà@V¾HAW‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ&YƒÆþhA|ܾHA_‹…Àt	ƒ~uPÿÓƒÆþhA|æ^[ËÿU‹ì‹Eÿ4ÅHAÿà@]ÃjhØõ@è^ùÿÿ3ÿG‰}ä3Û9t)Auè´jèhÿè€ãÿÿYY‹u4õHA9t‹Çënjè	ûÿÿY‹ø;ûuèÅøÿÿÇ3ÀëQj
èYY‰]ü9u,h Wèt YY…ÀuWèþûÿÿYèøÿÿÇ‰]äë‰>ëWèãûÿÿYÇEüþÿÿÿè	‹EäèöøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHAƒ>uPè"ÿÿÿY…ÀujètâÿÿYÿ6ÿà@^]Ãjhøõ@èhøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;EÀ@uèÿ÷ÿÿÇWWWWWè‡÷ÿÿƒÄ3ÀéÕ¯M‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*AuKƒÆƒæð‰u‹E;p*Aw7jèLÿÿÿY‰}üÿuèè5Y‰EäÇEüþÿÿÿè_‹]ä;ßtÿuWSè6ÛÿÿƒÄ;ßuaVjÿ5t)Aÿdà@‹Ø;ßuL9=€)At3Vè’Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇéEÿÿÿ3ÿ‹ujèðýÿÿYÃ;ßu
‹E;ÇtÇ‹Ãèœ÷ÿÿÃU‹ìƒì‰}ü‹}‹MÁéfïÀë¤$ffGfG fG0fG@fGPfG`fGp¿€IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRjQè~ÿÿÿƒÄ‹E‹}ü‹å]Ãjhö@èdöÿÿƒeüf(ÁÇEäë#‹Eì‹‹=Àt
=Àt3ÀÃ3À@ËeèƒeäÇEüþÿÿÿ‹EäèföÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+ÑtQ3À¢‰Eô‰]è‰Uì‰M𸢉Uü‰Eø[÷Eütè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A3ÀËÿU‹ìQSV‹u3ÛW;ót9]w èIõÿÿjYSSSSS‹ñ‰èÐôÿÿƒÄ‹ÆéÍ‹E3ÿ;ÃtŠ:Ãtj_9}†ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹UG‰}ü;úsyŠˆF@8uèPQèŒ@ŠYYŠˆF@8uð‹E;Ãt'Š:Ët!€ù.tG;}sÆ.FëG;}sŠˆF@8uðG;}v‹Eˆèlôÿÿj"éÿÿÿˆ3À_^[ÉËÿU‹ìƒìÿuMðèÜÿÿ¶E‹MôŠU„Tuƒ}t‹Mð‹‰È·A#Eë3À…Àt3À@€}üt‹MøƒapýÉËÿU‹ìjjÿuÿuè™ÿÿÿƒÄ]ËÿU‹ìjjÿujèÿÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuè…?ƒÄ]ËÿU‹ìì(£°"A‰
¬"A‰¨"A‰¤"A‰5 "A‰=œ"AfŒÈ"AfŒ
¼"AfŒ˜"AfŒ”"AfŒ%"AfŒ-Œ"AœÀ"A‹E£´"A‹E£¸"AE£Ä"A‹…àüÿÿÇ"A¡¸"A£´!AǨ!A	ÀǬ!A¡€A‰…Øüÿÿ¡„A‰…ÜüÿÿÿXà@£ø!AjèO$YjÿTà@hÔâ@ÿPà@ƒ=ø!Aujè+$Yh	ÀÿLà@PÿHà@ÉÃ-¤t"ƒètƒè
tHt3ÀøøøøËÿVW‹ðh3ÿFWPè+Öÿÿ3À·È‹Á‰~‰~‰~ÁáÁ~«««¹hAƒÄF+οŠˆ@Ou÷†¾Šˆ@Nu÷_^ËÿU‹ìì¡€A3ʼnEüSW…èúÿÿPÿvÿhà@¿…À„û3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj RèhÕÿÿƒÄCŠC„ÀuØjÿv…üúÿÿÿvPW…üþÿÿPjjèE3ÛSÿv…üýÿÿWPW…üþÿÿPWÿvSèúBƒÄDSÿv…üüÿÿWPW…üþÿÿPhÿvSèÕBƒÄ$3À·ŒEüúÿÿöÁt€LŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒëÆ„@;Çr¾ëV†Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ÐZ ƒûw€LŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆA;Ïr‹Mü_3Í[èOØÿÿÉÃjh8ö@èÏðÿÿè˜
‹ø¡ŒA…Gptƒlt‹wh…öuj èžÚÿÿY‹ÆèçðÿÿÃj
èó÷ÿÿYƒeü‹wh‰uä;5At6…ötVÿpà@…ÀuþhAtVè‡óÿÿY¡A‰Gh‹5A‰uäVÿlà@ÇEüþÿÿÿè뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðè¤×ÿÿ‰Ì$AƒþþuÇÌ$Aÿxà@8]ütE‹Møƒapýë<ƒþýuÇÌ$Aÿtà@ëÛƒþüu‹Eð‹@ÇÌ$AëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A3ʼnEüS‹]V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé‰uä3À9¸˜A„‘ÿEäƒÀ0=ðrçÿèý„pÿéý„d·ÇPÿ|à@…À„REèPWÿhà@…À„3hCVPèˆÒÿÿ3ÒBƒÄ‰{‰s9Uè†ø€}î„ÏuɄ¶Fÿ¶Éé¦hCVPèAÒÿÿ‹MäƒÄkÉ0‰u౨A‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”AD;¶FG;øvê‹}FF€>uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇCègûÿÿj‰CC‰œAZf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L@;ÁvöFF€~ÿ…4ÿÿÿC¹þ€@Iuù‹Cèûÿÿ‰C‰Së‰s3À·È‹ÁÁáÁ{«««ë¨95Ì$A…XþÿÿƒÈÿ‹Mü_^3Í[èJÕÿÿÉÃjhXö@èÊíÿÿƒMàÿè‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„Wh è‚ïÿÿY‹Ø…Û„F¹ˆ‹wh‹ûó¥ƒ#Sÿuè¸ýÿÿYY‰Eà…À…ü‹uÜÿvhÿpà@…Àu‹Fh=hAtPècðÿÿY‰^hS‹=là@ÿ×öFp…êöŒA…Ýj
ètôÿÿYƒeü‹C£Ü$A‹C£à$A‹C£ä$A3À‰Eäƒø}f‹LCf‰EÐ$A@ëè3À‰Eä=}
ŠLˆˆˆA@ëé3À‰Eä=}ŠŒˆˆA@ëæÿ5Aÿpà@…Àu¡A=hAtPèªïÿÿY‰ASÿ×ÇEüþÿÿÿèë0j
èíòÿÿYÃë%ƒøÿu ûhAtSètïÿÿYèìÿÿÇëƒeà‹Eàè‚ìÿÿÃ=°+AujýèVþÿÿYÇ°+A3ÀËÿU‹ìSV‹u‹†¼3ÛW;Ãto=HAth‹†°;Ãt^9uZ‹†¸;Ãt9uPèûîÿÿÿ¶¼è;AYY‹†´;Ãt9uPèÚîÿÿÿ¶¼èÕ@YYÿ¶°èÂîÿÿÿ¶¼è·îÿÿYY‹†À;ÃtD9u@‹†Ä-þPè–îÿÿ‹†Ì¿€+ÇPèƒîÿÿ‹†Ð+ÇPèuîÿÿÿ¶ÀèjîÿÿƒÄ¾Ô‹=ˆAt9˜´uPè»>ÿ7èCîÿÿYY~PÇEøAt‹;Ãt9uPèîÿÿY9_üt‹G;Ãt9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@W‹}WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒSV‹5pà@WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ>Yuþ˜AtVèYýÿÿY‹Ç^Ã3ÀÃjhxö@ècéÿÿè,‹ð¡ŒA…Fpt"ƒ~ltè‹pl…öuj è-ÓÿÿY‹ÆèvéÿÿÃjè‚ðÿÿYƒeüFl‹=pAèiÿÿÿ‰EäÇEüþÿÿÿèëÁjè}ïÿÿY‹uäËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€øë'¾tã@Vÿ à@…ÀuVènÒÿÿY…Àthdã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãjè‡ÿÿÿYËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€üë'¾tã@Vÿ à@…ÀuVèóÑÿÿY…Àthã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãÿ„à@‹ÿVÿ5„Aÿ€à@‹ð…öuÿ5%AèeÿÿÿY‹ðVÿ5„Aÿˆà@‹Æ^á€AƒøÿtPÿ5%Aè;ÿÿÿYÿЃ
€Aÿ¡„AƒøÿtPÿŒà@ƒ
„Aÿéºíÿÿjh˜ö@è†çÿÿ¾tã@Vÿ à@…ÀuVè4ÑÿÿY‰Eä‹uÇF\é@3ÿG‰~…Àt$hdã@P‹(à@ÿÓ‰†øhã@ÿuäÿÓ‰†ü‰~pƆÈCƆKCÇFhhAj
ènîÿÿYƒeüÿvhÿlà@ÇEüþÿÿÿè>jèMîÿÿY‰}ü‹E‰Fl…Àu¡pA‰FlÿvlèüÿÿYÇEüþÿÿÿèè	çÿÿÃ3ÿG‹uj
è5íÿÿYÃjè,íÿÿYËÿVWÿ\à@ÿ5€A‹øè‘þÿÿÿЋð…öuNhjè±èÿÿ‹ðYY…öt:Vÿ5€Aÿ5%AèèýÿÿYÿÐ…ÀtjVèÅþÿÿYYÿ”à@ƒNÿ‰ë	Vè^éÿÿY3öWÿà@_‹Æ^ËÿVèÿÿÿ‹ð…öujèÐÿÿY‹Æ^ÃjhÀö@èæÿÿ‹u…ö„ø‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@tPè¬èÿÿYj
èàìÿÿYƒeü‹~h…ÿtWÿpà@…ÀuÿhAtWèèÿÿYÇEüþÿÿÿèWjè§ìÿÿYÇEü‹~l…ÿt#WèóúÿÿY;=pAtÿ˜Atƒ?uWèÿøÿÿYÇEüþÿÿÿèVè'èÿÿYèIåÿÿ‹uj
èvëÿÿYËujèjëÿÿYËÿVW¾tã@Vÿ à@…ÀuVè“ÎÿÿY‹ø…ÿ„^‹5(à@hÀã@WÿÖh´ã@W£%AÿÖh¨ã@W£%AÿÖh ã@W£%AÿÖƒ=%A‹5ˆà@£%Atƒ=%At
ƒ=%At…Àu$¡€à@£%A¡Œà@Ç%AdO@‰5%A£%Aÿ„à@£„Aƒøÿ„Ìÿ5%APÿÖ…À„»èÅÐÿÿÿ5%Aèûÿÿÿ5%A£%Aèûÿÿÿ5%A£%Aèóúÿÿÿ5%A£%AèãúÿÿƒÄ£%Aè¬éÿÿ…ÀtehXQ@ÿ5%Aè=ûÿÿYÿУ€AƒøÿtHhjèÓåÿÿ‹ðYY…öt4Vÿ5€Aÿ5%Aè
ûÿÿYÿÐ…ÀtjVèçûÿÿYYÿ”à@ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèèÉÊÿÿ‹]C=w‹E苀ȷXëu‰]Á}EèP‹E%ÿPèGYY…ÀtŠEjˆEøˆ]ùÆEúYë
3Ɉ]øÆEùA‹EèjÿpÿpEüPQEøPEèjPè6ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E€}ôt‹Mðƒapý[ÉËÿU‹ìQV‹uVèwàÿÿ‰E‹FY¨‚uè8âÿÿÇ	ƒN ƒÈÿé/¨@t
èâÿÿÇ"ëãS3Û¨t‰^¨„‡‹Nƒàþ‰‰F‹FƒàïƒÈ‰F‰^‰]ü©u,è—ÃÿÿƒÀ ;ðtè‹ÃÿÿƒÀ@;ðu
ÿuè©Y…ÀuVè¾?Y÷FW„€‹F‹>H‰‹N+øI;û‰N~WPÿuèÜ*ƒÄ‰EüëMƒÈ ‰FƒÈÿëy‹Mƒùÿtƒùþt‹Áƒà‹ÑÁúÁà• *A븘Aö@ tjSSQè*>#ƒÄƒøÿt%‹FŠMˆë3ÿGWEPÿuèm*ƒÄ‰Eü9}üt	ƒN ƒÈÿë‹E%ÿ_[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü;ýˆAt	G‰}üƒÿrîƒÿƒwjèz@Yƒø„4jèi@Y…Àu
ƒ=ŒA„ûü„Ahpé@»S¿ %AWè08ƒÄ…Àt
VVVVVèØÞÿÿƒÄh¾9%AVjÆ=&Aÿà@…Àu&hXé@hûVèî7ƒÄ…Àt3ÀPPPPPè”ÞÿÿƒÄVè‡@YƒøYƒøtjèñ>Y…Àuƒ=ŒAuhüè)þÿÿhÿèþÿÿYYËÿU‹ìQSVWÿ5¬+AèÊöÿÿÿ5¨+A‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ‹Þ+ßCƒørwWèÕ>‹øCY;øsH¸;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+AÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ£¬+A£¨+A…öujX^Ã&3À^Ãjhèö@èeÞÿÿèÀÈÿÿƒeüÿuèøþÿÿY‰EäÇEüþÿÿÿè	‹EäèÞÿÿÃèŸÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@¾àô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@¾èô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@Aÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZf9t3À]ËA<Á8PEuï3Ò¹f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹}‹H;ùr	‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@hÐ7@d¡PƒìSVW¡€A1Eø3ÅPEðd£‰eèÇEüh@è*ÿÿÿƒÄ…ÀtU‹E-@Ph@èPÿÿÿƒÄ…Àt;‹@$Áè÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò=À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh(÷@èWÜÿÿè öÿÿ‹@x…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿè—<èpÜÿÿÃh
[@è'óÿÿY£4(AÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F‹V\¡tAW‹}‹ÊS99t‹ØkÛƒÁÚ;ËrîkÀÂ;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéûƒûuƒ`3À@éêƒû„Þ‹N`‰Mø‹M‰N`‹Hƒù…¸‹
hA‹=lA‹Ñù;×}$kÉ‹~\ƒd9‹=hA‹lAB߃Á;Ó|â‹]ü‹‹~d=ŽÀu	ÇFdƒë^=Àu	ÇFdëN=‘Àu	ÇFd„ë>=“Àu	ÇFd…ë.=Àu	ÇFd‚ë=Àu	ÇFd†ë=’ÀuÇFdŠÿvdjÿÓY‰~dëƒ`QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A£<(A£@(A£D(A]ËÿU‹ì‹E‹
tAV9Pt‹ñköuƒÀ;ÆrìkÉM^;Ás9Pt3À]Ãÿ5@(AèÚñÿÿYÃj hH÷@èJÚÿÿ3ÿ‰}ä‰}Ø‹]ƒûLt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa¾8(A¡8(Aë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+HtèŽÙÿÿÇ3ÀPPPPPèÙÿÿƒÄ뮾@(A¡@(Aë¾<(A¡<(Aë
¾D(A¡D(AÇEäPèñÿÿ‰EàY3Àƒ}à„Ø9EàujèòÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒûtƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒƒûu.‹
hA‰MÜ‹
lA‹hAÊ9MÜ}‹MÜkÉ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿèƒûuÿwdSÿUàYë‹]‹}؃}ätjèTßÿÿYÃSÿUàYƒût
ƒûtƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèìØÿÿËÿU‹ì‹E£L(A]ËÿU‹ì‹E£X(A]ËÿU‹ì‹E£\(A]Ãjhh÷@èmØÿÿƒeüÿuÿuÿ à@‰Eäë/‹Eì‹‹‰Eà3É=À”Á‹ÁËeè}àÀujÿà@ƒeäÇEüþÿÿÿ‹Eäè_ØÿÿËÿU‹ì‹E£`(A]ËÿU‹ìÿ5`(Aè|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹8csmàu*ƒxu$‹@= “t=!“t="“t=@™uèCûÿÿ3À]ÂhŽ_@ÿTà@3ÀÃ=°+AuèHëÿÿV‹5< AW3ÿ…öuƒÈÿé <=tGVèƒYtŠ„ÀuêjGWè€Ùÿÿ‹øYY‰= A…ÿtË‹5< ASëBVèR‹ØC€>=Yt1jSèRÙÿÿYY‰…ÀtNVSPè|.ƒÄ…Àt3ÀPPPPPè"ÕÿÿƒÄƒÇó€>u¹ÿ5< AèÚÿÿƒ%< Aƒ'Ǥ+A3ÀY[_^Ãÿ5 AèÝÙÿÿƒ% AƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹UÇ9Et	‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰UŠ¶ÃPFèâÿÿY…Àtÿƒ}t
‹MŠÿEˆF‹U‹M„Ût2ƒ}üu©€û t€û	uŸ…ÒtÆBÿƒeü€>„éŠ< t<	uFëóNëã€>„Ѓ}t	‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁuƒ}ütF€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰UŠ„ÀtUƒ}üu< tK<	tG…Ût=¾ÀP…Òt#è9áÿÿY…Àt
Š‹MÿEˆFÿ‹MŠÿEˆë
èáÿÿY…ÀtFÿÿ‹UFéVÿÿÿ…ÒtÆB‰Uÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒìS3ÛVW9°+AuèÄèÿÿh¾h(AVSˆl)Aÿà@¡ +A‰5( A;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ=ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6PèƒÖÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄH£ A‰5 A3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)AƒìSV‹5´à@W3Û3ÿ;Ãu.ÿÖ‹ø;ûtÇp)Aë#ÿ\à@ƒøxu
jX£p)Aë¡p)Aƒø…;ûuÿÖ‹ø;ûu3ÀéÊ‹Çf9t@@f9uù@@f9uò‹5°à@SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/Pè©ÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…Àuÿuüè¸ÖÿÿY‰]ü‹]üWÿ¬à@‹Ãë\ƒøt;Ãu‚ÿ¨à@‹ð;ó„rÿÿÿ8t
@8uû@8uö+Æ@P‰EøèBÕÿÿ‹øY;ûuVÿ¤à@éEÿÿÿÿuøVWè©+ƒÄVÿ¤à@‹Ç_^[ÉËÿU‹ì3À9Ej”ÀhPÿ¸à@£t)A…Àu]Ã3À@£„*A]ËÿU‹ìƒì¡€AƒeøƒeüSW¿Næ@»»ÿÿ;Çt
…Ãt	÷У„Aë`VEøPÿÌà@‹uü3uøÿÈà@3ðÿ”à@3ðÿÄà@3ðEðPÿÀà@‹Eô3Eð3ð;÷u¾Oæ@»ë…óu‹ÆÁàð‰5€A÷Ö‰5„A^_[ÉËÿU‹ì‹EƒøþuèÒÿÿÇ	3À]ÃV3ö;Æ|;*ArèæÑÿÿVVVVVÇ	ènÑÿÿƒÄ3Àë‹ÈƒàÁù‹ *AÁà¾Dƒà@^]á€AƒÈ3É9x)A”Á‹ÁÃÌÌÌÌÌÌÌÌ‹L$÷Át$ŠƒÁ„ÀtN÷Áuï¤$¤$‹ºÿþþ~Ѓðÿ3ƒÁ©tè‹Aü„Àt2„ät$©ÿt©ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u3ÛW‹};óu;ûv‹E;Ãt‰3À郋E;ÃtƒÿÿÿÿÿvèÇÐÿÿj^SSSSS‰0èPÐÿÿƒÄ‹ÆëVÿuMðès¸ÿÿ‹Eð9X…œf‹E¹ÿf;Áv6;ót;ûvWSVè8´ÿÿƒÄètÐÿÿÇ*èiÐÿÿ‹8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èIÐÿÿj"^SSSSS‰0èÒÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿMQSWVjMQS‰]ÿpÿ°à@;Ãt9]…^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèa³ÿÿƒÄéOÿÿÿ‹ÿU‹ìjÿuÿuÿuÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿuMðè:·ÿÿ¶E‹Mð‹‰È·A%€€}üt‹MøƒapýÉËÿU‹ìjÿuè¹ÿÿÿYY]ÃÌV‹D$Àu(‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$v	N+D$T$3Û+D$T$÷Ú÷؃ڋʋӋًȋÆ^ƒ%€*AÃÌÌÌSVW‹T$‹D$‹L$URPQQh i@dÿ5¡€A3ĉD$d‰%‹D$0‹X‹L$,3‹pƒþþt;‹T$4ƒúþt;òv.4v\³‹‰Hƒ{uÌh‹Cè1¹‹Cè1ë°dƒÄ_^[ËL$÷A¸t3‹D$‹H3È袵ÿÿU‹hÿpÿpÿpè>ÿÿÿƒÄ]‹D$‹T$‰¸ÃU‹L$‹)ÿqÿqÿq(èÿÿÿƒÄ]ÂUVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_03À3Û3É3Ò3ÿÿæU‹ìSVWjjhÇi@Qè—Q_^[]ÃU‹l$RQÿt$è´þÿÿƒÄ]Âjhˆ÷@èÍÿÿƒeä‹u;5p*Aw"jèÄÔÿÿYƒeüVèaY‰EäÇEüþÿÿÿè	‹EäèÍÿÿÃjè¿ÓÿÿYËÿU‹ìV‹uƒþà‡¡SW‹=dà@ƒ=t)AuèíÿÿjèÏëÿÿhÿèM·ÿÿYY¡„*Aƒøu…öt‹Æë3À@PëƒøuVèSÿÿÿY…Àu…öuFƒÆƒæðVjÿ5t)Aÿ׋؅Ûu.j^9€)Atÿuè¢ôÿÿY…Àt‹ué{ÿÿÿèNÌÿÿ‰0èGÌÿÿ‰0_‹Ã[ëVè{ôÿÿYè3ÌÿÿÇ3À^]Ãjh¨÷@èhÌÿÿ‹]…ÛuÿuèÿÿÿYéÌ‹u…öuSècÏÿÿYé·ƒ=„*A…“3ÿ‰}äƒþà‡ŠjèwÓÿÿY‰}üSè6Y‰Eà;Ç„ž;5p*AwIVSPèƒÄ…Àt‰]äë5Vèç	Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$Sèæ‰EàSPèƒÄ9}äuH;÷u3öF‰uƒÆƒæð‰uVWÿ5t)Aÿdà@‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ#Sÿuà迃ÄÇEüþÿÿÿè.ƒ}àu1…öuFƒÆƒæð‰uVSjÿ5t)AÿÔà@‹øë‹u‹]jè¨ÑÿÿYË}ä…ÿ…¿9=€)At,VèóÿÿY…À…Òþÿÿè´Êÿÿ9}àul‹ðÿ\à@Pè_ÊÿÿY‰ë_…ÿ…ƒèÊÿÿ9}àthÇëq…öuFVSjÿ5t)AÿÔà@‹ø…ÿuV9€)At4Vè›òÿÿY…ÀtƒþàvÍVè‹òÿÿYèCÊÿÿÇ3ÀèÇÊÿÿÃè0Êÿÿé|ÿÿÿ…ÿuè"Êÿÿ‹ðÿ\à@PèÒÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹MS3Û;Ëv(jà3ÒX÷ñ;EsèíÉÿÿSSSSSÇèuÉÿÿƒÄ3ÀëA¯MVW‹ñ9]tÿuèÈ)Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVjßSèX­ÿÿƒÄ‹Ç_^[]ËÿU‹ì‹
h*A¡l*AkÉÈë‹U+Púr	ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹uW‹þ+yƒÆüÁï‹ÏiÉŒD‰Mð‹I‰MüöÁ…ÓS1‹‰Uô‹Vü‰Uø‹Uô‰]öÂutÁúJƒú?vj?Z‹K;KuB»€ƒú s‹ÊÓëL÷Ó!\¸Dþ	u#‹M!ëJàÓëL÷Ó!œ¸Äþ	u‹M!Y‹]‹S‹[‹MüMô‰Z‹U‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô…+uø‹]øÁûj?‰uK^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M‹q;qu;¾€ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸ÄþLu‹M!q‹M‹q‹I‰N‹M‹q‹I‰N‹uë‹]ƒ}ôu;Ú„€‹MðÑ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€}u‹Ê»€Óë‹M	»€‹ÊÓëD¸D	ë)€}uJເÓë‹M	YJ຀ÓꄸÄ	‹Eü‰‰D0ü‹Eðÿ…ó¡|)A…À„Ø‹
|*A‹5¼à@h@ÁáH»€SQÿÖ‹
|*A¡|)Aº€Óê	P¡|)A‹@‹
|*Aƒ¤ˆÄ¡|)A‹@þHC¡|)A‹H€yCu	ƒ`þ¡|)AƒxÿueSjÿpÿÖ¡|)Aÿpjÿ5t)Aÿ`à@‹
h*A¡|)AkÉ‹l*A+ÈLìQHQPèí+‹EƒÄÿ
h*A;|)Avƒm¡l*A£t*A‹E£|)A‰=|*A[_^Éáx*AV‹5h*AW3ÿ;ðu4ƒÀkÀPÿ5l*AWÿ5t)AÿÔà@;Çu3Àëxƒx*A‹5h*A£l*Akö5l*AhÄAjÿ5t)Aÿdà@‰F;ÇtÇjh hWÿØà@‰F;ÇuÿvWÿ5t)Aÿ`à@뛃Nÿ‰>‰~ÿh*A‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ„0Dj?‰EøZ‰@‰@ƒÀJuôj‹ûhÁçyh€WÿØà@…ÀuƒÈÿé—p‰Uü;úwC‹Ê+ÏÁéGAƒHøÿƒˆìÿü‰üïÿÿÇ@üð‰PÇ€èðIuË‹Uü‹EøøO‰H‰AJ‰H‰AƒdžD3ÿG‰¼žÄŠFCŠÈþÁ„À‹EˆNCu	xº€‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì‹M‹ASV‹uW‹}‹×+QƒÆÁê‹ÊiÉŒD‰Mô‹OüƒæðI;ñ|9ü‹‰M‰]üŽUöÃ…EÙ;ó;‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC»€ƒù sÓë‹MøL÷Ó!\Dþ	u&‹M!ëƒÁàÓë‹MøL÷Ó!œÄþ	u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}üŽ¥‹}ü‹MÁÿOL1üƒÿ?vj?_‹]ôû‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s€}u‹Ï»€Óë‹M	DD‹Ïë €}uOເÓë‹M	Y„ÄO຀Óê	‹U‹MüD2ü‰‰Lüë‹UF‰Bü‰D2øé<3Àé8/‹])uN‰Kü\3ü‹uÁþN‰]‰Küƒþ?vj?^öEü…€‹uüÁþNƒþ?vj?^‹O;OuB»€ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ëNàÓëL÷Ó!œÄþ	u‹M!Y‹]‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Môñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s€}u‹Î¿€Óï‹M	9DD‹Îë €}uNà¿€Óï‹M	y„ÄN຀Óê	‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A‹MkÀl*AƒÁƒáð‰MðÁùSIƒù VW}ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A‹Ùë‹S‹;#Uø#þ×u
ƒÃ‰];Ørè;Øu‹l*Aë‹S‹;#Uø#þ×u
ƒÃ‰];Ùrè;Ùu[ëƒ{u
ƒÃ‰];Ørð;Øu1‹l*Aë	ƒ{u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé	Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰t*A‹C‹‰Uüƒúÿt‹ŒÄ‹|D#Mø#þÏu)ƒeü‹ÄHD‹9#Uø#þ×uÿEü‹‘„ƒÁëç‹Uü‹ÊiÉŒD‰Mô‹LD3ÿ#Îu‹ŒÄ#Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„‹J;Ju\ƒÿ »€}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]!ë,OàÓë‹MüŒˆÄ|8÷Ó!þ‰]ìu‹]‹Mì!Kë‹]ƒ}ø‹J‹z‰y‹J‹z‰y„‹Môñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆMþÁƒþ ˆL}#€}u¿€‹ÎÓï	;‹Î¿€Óï‹Mü	|ˆDë)€}u
Nà¿€Óï	{‹Mü¼ˆÄNྀÓî	7‹Mø…Ét‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu;|)Au‹Mü;
|*Auƒ%|)A‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷uèµ¾ÿÿWWWWWÇè=¾ÿÿƒÄÃëBöFƒt7Vè(ÃÿÿV‹ØèÄ(Vè³¼ÿÿPèë'ƒÄ…À}ƒËÿë‹F;Çt
PèÎÁÿÿY‰~‰~‹Ã_^[]ÃjhÈ÷@è—¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;Çuè2¾ÿÿÇWWWWW躽ÿÿƒÄƒÈÿëöF@t‰~‹Eäèš¾ÿÿÃVè– ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿèëÕ‹uVèä ÿÿYËÿU‹ì¸äè8*¡€A3ʼnEü‹EV3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé;Æu'訽ÿÿ‰0莽ÿÿVVVVVÇè½ÿÿƒÄƒÈÿé¾SW‹}‹ÇÁø4… *A‹ƒçÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&è?½ÿÿ3ö‰0è#½ÿÿVVVVVÇ諼ÿÿƒÄéCö@ tjjjÿuècƒÄÿuèÖêÿÿY…À„‹öD€„èëÖÿÿ‹@l3É9H…åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@…À„`3É9 åÿÿt„Û„PÿÜà@‹4åÿÿ‰…åÿÿ3À‰…<åÿÿ9E†B‰…DåÿÿŠ…'åÿÿ„À…gŠ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹ǃx8tŠP4ˆUôˆMõƒ`8jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥j…@åÿÿSPè<(ƒÄƒøÿ„±Cÿ…DåÿÿëjS…@åÿÿPè(ƒÄƒøÿ„3ÀPPjMôQj@åÿÿQPÿµåÿÿCÿ…Dåÿÿÿ°à@‹ð…ö„\j…<åÿÿPVEôP‹…(åÿÿ‹ÿ4ÿ˜à@…À„)‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒƒ½ åÿÿ„Íj…<åÿÿPjEôP‹…(åÿÿ‹ÆEô
ÿ4ÿ˜à@…À„Ѓ½<åÿÿŒÏÿ…0åÿÿÿ…8åÿÿéƒ<t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%%Yf;…@åÿÿ…hƒ…8åÿÿƒ½ åÿÿt)j
XP‰…@åÿÿèø$Yf;…@åÿÿ…;ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé'‹Šÿ…8åÿÿˆT4‹‰D8é3É‹Çö@€„¿‹…4åÿÿ‰@åÿÿ„Û…ʉ…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ+4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿr‹؅Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„B‹…,åÿÿ…8åÿÿ;ÃŒ:‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ9M†M답(åÿÿ‹Dåÿÿƒ¥<åÿÿ+4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþrµ‹Ø…Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„b‹…,åÿÿ…8åÿÿ;ÃŒZ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@9M†|‹Dåÿÿƒ¥<åÿÿ+4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰ƽ<åÿÿ¨r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéýÿ°à@‹Ø;Þ„—j…,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ÿ4ÿ˜à@…Àtµ,åÿÿ;ÞËëÿ\à@‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@…Àt‹…,åÿÿƒ¥@åÿÿ‰…8åÿÿëÿ\à@‰…@åÿÿƒ½8åÿÿulƒ½@åÿÿt-j^9µ@åÿÿuè·ÿÿÇ	è·ÿÿ‰0ë?ÿµ@åÿÿè"·ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èÖ¶ÿÿÇèÞ¶ÿÿƒ ƒÈÿë‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èhžÿÿÉÃjhè÷@èè¶ÿÿ‹Eƒøþu袶ÿÿƒ 臶ÿÿÇ	ƒÈÿé3ÿ;Ç|;*Ar!èy¶ÿÿ‰8è_¶ÿÿÇ	WWWWWèçµÿÿƒÄëÉ‹ÈÁù *A‹ðƒæÁ拾L1ƒát¿Pè9$Y‰}ü‹öD0tÿuÿuÿuè.øÿÿƒÄ‰EäëèüµÿÿÇ	è¶ÿÿ‰8ƒMäÿÇEüþÿÿÿè	‹Eäèh¶ÿÿÃÿuèƒ$YÃjhø@è¶ÿÿ‹Eƒøþuè³µÿÿÇ	ƒÈÿéª3Û;Ã|;*Arè’µÿÿÇ	SSSSSèµÿÿƒÄëЋÈÁù< *A‹ðƒæÁ拾LƒátÆPèl#Y‰]ü‹öDt1ÿuèà"YPÿäà@…Àuÿ\à@‰Eäë‰]ä9]ätè1µÿÿ‹Mä‰èµÿÿÇ	ƒMäÿÇEüþÿÿÿè	‹Eä臵ÿÿÃÿuè¢#YËÿU‹ìƒìS3Û9]uèÖ´ÿÿSSSSSÇè^´ÿÿƒÄ3ÀëjV‹u;óuè²´ÿÿSSSSSÇè:´ÿÿƒÄë9ur3Àë>ÿuMðèVœÿÿ‹MôFÿ9YtH9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìjÿuÿuèUÿÿÿƒÄ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9]u3Àéç;ót9]wè	´ÿÿj^SSSSS‰0è’³ÿÿƒÄ‹ÆéÀ9]uˆëÉW‹};ûuˆèسÿÿj^SSSSS‰0èa³ÿÿƒÄé(ÿuMì胛ÿÿ‹Eð9XuÿuWÿuVè£
ƒÄéLƒ}ÿ‹U‹ÆuŠˆ@G:ËtJuó늈@G:ËtJtÿMuî9]uˆ@;Ó…È8tƒ}u5xÿ‰}ü;þrEìP‹Eü¶Pè0¿ÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…Ã}ÿuZ‹Eƒøv:|þ‰};þr!EìP‹E¶Pèì¾ÿÿYY…ÀtÿM9usâ‹E‹Ï+MöÁtˆëˆ\ÿ8]øt‹Eôƒ`pýjPXéˆè·²ÿÿj"^SSSSS‰0è@²ÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þrEìP‹E¶Pèi¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨tˆèT²ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝuPèxµÿÿY]ËÿU‹ìƒì¡€A3ʼnEüSV3ÛW‹ñ9„)Au8SS3ÿGWhdê@hSÿðà@…Àt‰=„)Aëÿ\à@ƒøxu
Ç„)A9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)Aƒø„¬;Ĥƒø…̉]ø9] u‹‹@‰E ‹5ìà@3À9]$SSÿu•ÀÿuÅPÿu ÿÖ‹ø;û„~Cjà3ÒX÷÷ƒør7D?=wèŽ#‹Ä;ÃtÇÌÌëPèäÿÿY;Ãt	ÇÝ݃À‰Eôë‰]ô9]ô„>Wÿuôÿuÿujÿu ÿÖ…À„ã‹5ðà@SSWÿuôÿuÿuÿ֋ȉMø;Ë„Â÷Et)9]„°;M§ÿuÿuWÿuôÿuÿuÿÖé;Ë~Ejà3ÒX÷ñƒør9D	=wèÏ"‹ô;ótjÇÌ̃ÆëPèJãÿÿY;Ãt	ÇÝ݃À‹ðë3ö;ótAÿuøVWÿuôÿuÿuÿðà@…Àt"SS9]uSSëÿuÿuÿuøVSÿu ÿ°à@‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè  Y‰Eìƒøÿu3Àé!;E „ÛSSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@SSÿuPÿuÿuÿÖ‰Eø;Ãu3öé·~=ƒøàw8ƒÀ=wè¹!‹ü;ûtÝÇÌ̃ÇëPè4âÿÿY;Ãt	ÇÝ݃À‹øë3ÿ;ût´ÿuøSWèÀ’ÿÿƒÄÿuøWÿuÿuôÿuÿuÿÖ‰Eø;Ãu3öë%ÿuEøÿuPWÿu ÿuìè‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿuÿuÿuÿuÿuÿuÿèà@‹ð9]ôt	ÿuôèø±ÿÿY‹Eð;Ãt9EtPèå±ÿÿY‹Æeà_^[‹Mü3Íè'–ÿÿÉËÿU‹ìƒìÿuMðè!–ÿÿÿu(Mðÿu$ÿu ÿuÿuÿuÿuÿuè(üÿÿƒÄ €}üt‹MøƒapýÉËÿU‹ìQQ¡€A3ʼnEü¡ˆ)ASV3ÛW‹ù;Ãu:EøP3öFVhdê@Vÿøà@…Àt‰5ˆ)Aë4ÿ\à@ƒøxu
jX£ˆ)A롈)Aƒø„Ï;Äǃø…è‰]ø9]u‹‹@‰E‹5ìà@3À9] SSÿu•ÀÿuÅPÿuÿÖ‹ø;û„«~<ÿðÿÿw4D?=wèÒ‹Ä;ÃtÇÌÌëPèPàÿÿY;Ãt	ÇÝ݃À‹Ø…Ûti?PjSèÞÿÿƒÄWSÿuÿujÿuÿÖ…ÀtÿuPSÿuÿøà@‰EøSèÉúÿÿ‹EøYëu3ö9]u‹‹@‰E9]u‹‹@‰EÿuèAYƒøÿu3ÀëG;EtSSMQÿuPÿuèi‹ðƒÄ;ót܉uÿuÿuÿuÿuÿuÿôà@‹ø;ótVèæ¯ÿÿY‹Çeì_^[‹Mü3Íè(”ÿÿÉËÿU‹ìƒìÿuMðè"”ÿÿÿu$Mðÿu ÿuÿuÿuÿuÿuèþÿÿƒÄ€}üt‹MøƒapýÉËÿU‹ìV‹u…ö„ÿvèv¯ÿÿÿvèn¯ÿÿÿvèf¯ÿÿÿvè^¯ÿÿÿvèV¯ÿÿÿvèN¯ÿÿÿ6èG¯ÿÿÿv è?¯ÿÿÿv$è7¯ÿÿÿv(è/¯ÿÿÿv,è'¯ÿÿÿv0è¯ÿÿÿv4è¯ÿÿÿvè¯ÿÿÿv8è¯ÿÿÿv<èÿ®ÿÿƒÄ@ÿv@èô®ÿÿÿvDèì®ÿÿÿvHèä®ÿÿÿvLèÜ®ÿÿÿvPèÔ®ÿÿÿvTèÌ®ÿÿÿvXèÄ®ÿÿÿv\è¼®ÿÿÿv`è´®ÿÿÿvd謮ÿÿÿvh褮ÿÿÿvl蜮ÿÿÿvpè”®ÿÿÿvt茮ÿÿÿvxè„®ÿÿÿv|è|®ÿÿƒÄ@ÿ¶€èn®ÿÿÿ¶„èc®ÿÿÿ¶ˆèX®ÿÿÿ¶ŒèM®ÿÿÿ¶èB®ÿÿÿ¶”è7®ÿÿÿ¶˜è,®ÿÿÿ¶œè!®ÿÿÿ¶ è®ÿÿÿ¶¤è®ÿÿÿ¶¨è®ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;HAtPèÝ­ÿÿY‹F;LAtPèË­ÿÿY‹v;5PAtVè¹­ÿÿY^]ËÿU‹ìV‹u…öt~‹F;TAtPè—­ÿÿY‹F;XAtPè…­ÿÿY‹F;\AtPès­ÿÿY‹F;`AtPèa­ÿÿY‹F;dAtPèO­ÿÿY‹F ;hAtPè=­ÿÿY‹v$;5lAtVè+­ÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹};ûwè¡©ÿÿj^‰0SSSSSè*©ÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèZ©ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹uƒÉÿIƒÁŠ
Àt	ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9]u3À_^[]Ã;ót‹};ûwę̀ÿÿj^‰0SSSSSèU¨ÿÿƒÄ‹ÆëÕ9]uˆëÊ‹U;Óuˆëу}ÿ‹ÆuŠ
ˆ@B:ËtOuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹EjPˆ\ÿXéxÿÿÿˆèR¨ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹};ûwè,¨ÿÿj^‰0SSSSS赧ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆèñ§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷Âu<‹:u.
Àt&:au%
ätÁè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ÂtŠƒÂ:uçƒÁ
ÀtÜ÷Ât¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u‹M‹}‹Á‹ÑÆ;þv;ø‚¤ùrƒ=ˆ*AtWVƒçƒæ;þ^_u^_]é,÷ÇuÁéƒâƒùr*ó¥ÿ$•T‘@‹ÇºƒérƒàÈÿ$…h@ÿ$d‘@ÿ$è@x@¤@È@#ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•T‘@I#ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•T‘@#ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•T‘@IK‘@8‘@0‘@(‘@ ‘@‘@‘@‘@‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Düðøÿ$•T‘@‹ÿd‘@l‘@x‘@Œ‘@‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃIŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Çu$Áéƒâƒùr
ýó¥üÿ$•ð’@‹ÿ÷Ùÿ$ ’@I‹Çºƒùrƒà+Èÿ$…ô‘@ÿ$ð’@’@(’@P’@ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•ð’@IŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•ð’@ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•ð’@I¤’@¬’@´’@¼’@Ä’@Ì’@Ô’@ç’@‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰Dðøÿ$•ð’@‹ÿ“@“@“@,“@‹E^_ÉÊFˆG‹E^_ÉÃIŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹u‹ÿŠ
ÀtƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹EV‹u‰Eø‹EWV‰EüèƒÏÿY;Çuèi£ÿÿÇ	‹Ç‹×ëJÿuMüQÿuøPÿá@‰Eø;Çuÿ\à@…Àt	Pè[£ÿÿYëÏ‹ÆÁø‹… *AƒæÁæD0€ ý‹Eø‹Uü_^ÉÃjh(ø@èO£ÿÿƒÎÿ‰u܉uà‹Eƒøþuè£ÿÿƒ èå¢ÿÿÇ	‹Æ‹ÖéÐ3ÿ;Ç|;*Ar!èÖ¢ÿÿ‰8è¼¢ÿÿÇ	WWWWWèD¢ÿÿƒÄëÈ‹ÈÁù *A‹ðƒæÁ拾L1ƒáu&è•¢ÿÿ‰8è{¢ÿÿÇ	WWWWWè¢ÿÿƒÄƒÊÿ‹Âë[PèpY‰}ü‹öD0tÿuÿuÿuÿuè©þÿÿƒÄ‰E܉Uàëè-¢ÿÿÇ	è5¢ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè‹EÜ‹Uàè’¢ÿÿÃÿuè­YËÿU‹ìÿ Ahè¤ÿÿY‹M‰A…Àt
ƒIÇAëƒIA‰AÇA‹Aƒa‰]ËÿU‹ìƒìSVWèb¹ÿÿƒeüƒ=)A‹Ø…Žhô@ÿœà@‹ø…ÿ„*‹5(à@hôó@WÿÖ…À„P謸ÿÿÇ$äó@W£)AÿÖPè—¸ÿÿÇ$Ðó@W£”)AÿÖP肸ÿÿÇ$´ó@W£˜)AÿÖPèm¸ÿÿY£ )A…Àthœó@WÿÖPèU¸ÿÿY£œ)A¡œ)A;ÃtO9 )AtGP賸ÿÿÿ5 )A‹ð覸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQjMìQjPÿ×…ÀtöEôu	M ë9¡”)A;Ãt0Pèc¸ÿÿY…Àt%ÿЉEü…Àt¡˜)A;ÃtPèF¸ÿÿY…ÀtÿuüÿЉEüÿ5)Aè.¸ÿÿY…ÀtÿuÿuÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î|ƒù~ƒùu¡D Aë(¡D A‰
D Aëè ÿÿVVVVVÇ蚟ÿÿƒÄƒÈÿ^]ÃjhHø@è9 ÿÿ3À‹]3ÿ;ß•À;ÇuèØŸÿÿÇWWWWWè`ŸÿÿƒÄƒÈÿëSƒ=„*Au8jèU§ÿÿY‰}üSèÖÿÿY‰Eà;Çt‹süƒî	‰uäë‹uäÇEüþÿÿÿè%9}àuSWÿ5t)Aÿá@‹ð‹ÆèùŸÿÿÃ3ÿ‹]‹uäjè#¦ÿÿYÃjè‰ÿÿYËÿU‹ìì(¡€A3ʼnEüöAVtj
è3¾ÿÿYè
Åÿÿ…ÀtjèÅÿÿYöA„ʉ…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ‰µèýÿÿ‹@üjP‰…äýÿÿ…ØüÿÿjPè:‚ÿÿ…ØüÿÿƒÄ‰…(ýÿÿ…0ýÿÿjÇ…Øüÿÿ@‰µäüÿÿ‰…,ýÿÿÿTà@…(ýÿÿPÿPà@jèýŠÿÿÌÌÌU‹ìSVWUjjh™@ÿuèV"]_^[‹å]ËL$÷A¸t2‹D$‹Hü3Èè²…ÿÿU‹h‹P(R‹P$RèƒÄ]‹D$‹T$‰¸ÃSVW‹D$UPjþh™@dÿ5¡€A3ÄPD$d£‹D$(‹X‹pƒþÿt:ƒ|$,ÿt;t$,v-4v‹³‰L$‰Hƒ|³uh‹D³èI‹D³è_ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y™@u‹Q‹R9Qu¸ÃSQ»”AëSQ»”A‹L$‰K‰C‰kUQPXY]Y[ÂÿÐËÿU‹ìƒìVWÿuMì资ÿÿ‹E‹u3ÿ;Çt‰0;÷u,èÑœÿÿWWWWWÇèYœÿÿƒÄ€}øt‹Eôƒ`pý3ÀéØ9}tƒ}|Ƀ}$ËMìSŠ‰}ü~ƒ¹¬~EìP¶ÃjPèe¹ÿÿ‹MìƒÄ닑ȶ÷Bƒà…ÀtŠGëÇ€û-uƒMë€û+uŠG‹E…ÀŒKƒø„Bƒø$9…Àu*€û0t	ÇE
ë4Š·É¶ÒÁáÊ9MuHë·Ñ9Ut
@f¶·Éf;ËuÇ·É9Mu8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìjÿuÿuè2ÿÿÿƒÄ]ÃÌÌÌBÿ[ä$d$3ÀŠD$S‹ØÁà‹T$÷ÂtŠ
ƒÂ:ËtÏ„ÉtQ÷ÂuëØW‹ÃÁãVØ‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂáu%tÓ%uæ€uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@‹ÿU‹ì‹US3Û;Óuè¬{ÿÿSSSSSÇè4{ÿÿƒÄƒÈÿë 8tß‹M;ËtØ‹;ÃtÒ8tÎSQRèƒÄ[]ËÿU‹ìƒì‹UV‹ujþX‰Eì‰Uä;ðuèc{ÿÿƒ èH{ÿÿÇ	ƒÈÿéˆS3Û;ó|;5*Ar'è9{ÿÿ‰è{ÿÿSSSSSÇ	è§zÿÿƒÄƒÈÿéQ‹ÆÁøW<… *A‹ƒæÁæÆŠHöÁuèózÿÿ‰èÙzÿÿÇ	ëjúÿÿÿwP‰]ð;Ó„öÁ…ÿ9]t7Š@$ÀÐøˆEþ¾ÀHjYtHu‹Â÷Шtƒâþ‰U‹E‰Eôé‹Â÷Шu!è‡zÿÿ‰èmzÿÿÇSSSSSèõyÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuèz|ÿÿY‰Eô;Ãuè5zÿÿÇè=zÿÿǃÈÿéhjSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEðÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEðÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEðÆD&
SMèQÿuP‹ÿ4ÿ,á@…À„{‹Mè;ËŒp;M‡g‹MðDö€„æ€}þ„;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ЋMŠ<„®<
tˆCA‰Mé‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEjEèPjEÿP‹ÿ4ÿ,á@…Àu
ÿ\à@…ÀuEƒ}èt?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö@u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð…À„ÈKŠ„ÉxCé†3À@¶Éëƒø;]ôrK¶@€¹àAt芶ʾ‰àA…Éu
èàwÿÿÇ*ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ|	Š‹ˆT%Cƒøu	Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿuSÿuôjhéýÿìà@‰Eð…Àu4ÿ\à@Pè…wÿÿYƒMìÿ‹Eô;EtPèµzÿÿY‹Eìƒøþ…‹‹Eð郋Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ‹E·fƒù„×fƒù
tf‰CC@@‰Eé´‹MðƒÁþ;ÁsHfƒ9
u
ƒÀ‰Ej
鎉M鄃EjEèPjEøP‹ÿ4ÿ,á@…Àu
ÿ\à@…Àu[ƒ}ètU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹f‰CC+]ô‰]ðé‘þÿÿÿ\à@j^;ÆuèÙuÿÿÇ	èáuÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhðø@èïuÿÿ‹Eƒøþuè©uÿÿƒ èŽuÿÿÇ	ƒÈÿé¾3ö;Æ|;*Ar!è€uÿÿ‰0èfuÿÿÇ	VVVVVèîtÿÿƒÄëÉ‹ÈÁù *A‹øƒçÁ狾L9ƒát¿¹ÿÿÿ;MÉAuè2uÿÿ‰0èuÿÿÇë°PèãÿÿY‰uü‹öD8tÿuÿuÿuè~ùÿÿƒÄ‰EäëèâtÿÿÇ	èêtÿÿ‰0ƒMäÿÇEüþÿÿÿè	‹EäèNuÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ‰]Ôt	‰]ØÆEÿë
ÇE؈]ÿEàPè
Y…Àt
SSSSSèÒrÿÿƒÄ‹M¸€…Èu÷Á@u9Eàt€Mÿ€‹Áƒà+úÀ¿€tGHt.Ht&è7tÿÿ‰ƒÿètÿÿj^SSSSS‰0è£sÿÿƒÄé‰UøëöÁt÷ÁuîÇEø@ë‰}ø‹EjY+Át7+Át*+Át+Átƒè@u¡9}ø”À‰EðëÇEðëÇEðëÇEðë‰]ð‹Eº#¹;Á¿;t0;Ãt,;Çt=„”=…@ÿÿÿÇEìë/ÇEìë&ÇEìë=t=t`;Â…ÿÿÿÇEì‹EÇEô€…Çt‹
 A÷Ñ#M„ÉxÇEô¨@tMôMøƒMð©t	}ô¨ tMôëÇEì릨tMôè£áÿÿ‰ƒøÿuèÎrÿÿ‰ƒÿè±rÿÿÇ鎋E‹=á@SÿuôÇÿuìEÐPÿuðÿuøÿuÿ׉Eäƒøÿum‹Mø¸À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿuÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@Pè?rÿÿYèrÿÿ‹étÿuäÿ<à@;ÃuD‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@‹ðVèüqÿÿYÿuäÿá@;óu°èÃqÿÿÇ
룃øu€Mÿ@ë	ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹ÐƒàÁú‹• *AYÁàYŠMÿ€ÉˆL‹‹ÐƒàÁú‹• *AÁàD$€ €ˆMý€eýHˆMÿ…€öÁ€„±öEtqjƒÏÿWÿ6裃Ä‰Eè;Çuè:qÿÿ8ƒtMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ…Àu€}üu‹Eè™RPÿ6è ƒÄ;ÇtÃSSÿ6èFƒÄ;Çt³öEÿ€„0¿@¹@…}u‹Eà#Çu	Më	E‹E#Ç;ÁtD=t)=@t"=t)=@t"=t=@uÆEþë‹M¸#È;Èu	ÆEþëˆ]þ÷E„µöEÿ@‰]è…¨‹Eø¹À#Á=@„·=€tw;Á…„‹Eì;Æyƒøvƒøv0ƒø…f¾Eþ3ÿH„&H…RÇEèÿþÇEìéjSSÿ6è8ÌÿÿƒÄÂtÇSSSÿ6è'Ìÿÿ#ƒÄƒøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄƒøÿ„uþÿÿƒøtkƒø…­}èuYÆEþéÜ‹Eì;Æуø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ„CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘éþÿÿ‹Eè%ÿÿ=þÿuÿ6èß×ÿÿYèoÿÿj^‰0‹Æéd=ÿþuSjÿ6èXƒÄƒøÿ„ÀýÿÿÆEþëASSÿ6è=ƒÄë™ÇEèÇEì‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *AƒàÁàD$Š2Mþ€á0‹‹ÈÁù‹ *AƒàÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹ÈƒàÁù‹ *AÁàD€ ‹}ø¸À‹Ï#È;Èu|öEtvÿuäÿá@SÿuôEÐjPÿuðçÿÿÿWÿuÿá@ƒøÿu4ÿ\à@Pèÿmÿÿ‹‹ÈƒàÁù‹ *AÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *AƒæÁ手Ã_^[ÉÃjhù@èÓmÿÿƒMäÿ3ö‰uà3À9u•À;ÆuèmmÿÿÇVVVVVèõlÿÿƒÄƒÈÿër‰uüÿuj@ÿuÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè‹}Ü;þt<èmÿÿ‰8ë¿3ö9uàt+9uÜt‹EäÁø‹MäƒáÁá‹… *AD€ þÿuäèÛÿÿYËEäèomÿÿËÿU‹ìQQV3ö9uuèÉlÿÿVVVVVÇèQlÿÿƒÄƒÈÿëJ9utÞÿuEøPEüPÿuÿuè|ƒÄƒøÿtØÿuøÿuüÿujèUÿuü‹ðèÝoÿÿÿuøèÕoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èIlÿÿSSSSSÇèÑkÿÿƒÄƒÈÿéá8tÜ‹E;ÃtÕ‹;ÃtÏ8tËVj\Wèj/W‹ðè
ƒÄ;Ã…;ó…ƒj:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèMnÿÿ‹øƒÄ‰}ü;û„­htô@VWèkÃÿÿƒÄ…Àt
SSSSSèjÿÿƒÄÿuVWèØÁÿÿƒÄ…Àt
SSSSSèõiÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.VèhYY…Àt,Sÿuüè
YY…À…ìÿuÿuÿuüè`þÿÿƒÄ‰EðéÓÿuüè–™ÿÿ‹ðƒÆjVèšmÿÿƒÄ‰Eø;ÃuƒÈÿé½ÿuüVPè¸ÂÿÿƒÄ…Àt
SSSSSè`iÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèÚjÿÿ‹‰Eì‹Eø+÷ðÇEôìA‹Eôÿ0VWèrÂÿÿƒÄ…Àt
SSSSSèiÿÿƒÄSÿuøè]	YY…Àtƒmô}ôàA}Äëè„jÿÿÿu‹Mìÿu‰ÿuøè”ýÿÿƒÄ‰EðÿuøèÌmÿÿ‹}Y9}üt	ÿuüè»mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒÄ‰UìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u‹}+ðúˆÆ;󆼻Sjÿ4á@Pÿdà@‰Eü…ÀuèÇiÿÿÇè¼iÿÿ‹_^[ÉÃh€ÿuèŠYY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèFYYÿuüjÿ4á@Pÿ`à@3Ûé†èWiÿÿƒ8uè:iÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿuÿuèÅÿÿ#ƒÄƒøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èÛhÿÿÇ
èãhÿÿ‹ðÿ\à@‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒÄƒøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèyhÿÿÇ	ƒÈÿëMWÿujÿuPÿá@‹øƒÿÿuÿ\à@ë3À…ÀtPèihÿÿYƒÈÿë‹ÆÁø‹… *AƒæÁæD0€ ý‹Ç_^]ËÿU‹ìS‹]V‹u‹ÆÁø… *A‹ƒæÁæ0ŠA$ÀW¶y¾Àç€Ñøû@tPû€tBût&ûtûu=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸€]Ã÷ØÀ%À@]ËÿU‹ì‹EV3ö;ÆuèNgÿÿVVVVVÇèÖfÿÿƒÄjXë
‹
d*A‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~	ƒøuÆEÿ‹E‰Eðë8ègÿÿ‰èçfÿÿSSSSSÇèofÿÿƒÄƒÈÿé®@8uûH8tÆ ‹Á8uëVjD^VE˜SPèdJÿÿ‰u˜‹5*AƒÄ;ót+Fÿ‹È‹ÐÁù‹ *AƒâÁâ8\uNH;óuà;óŒ@þ23ƒ4‹ÆkÀƒÀf‰EÊ·ÀjPèÇhÿÿYY‰EÌ;Ä;ó‰0‹EÌH|0‰]ø~9‹Eø‹ÐƒàÁúÁà• *AŠPöÂuˆ‹‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×}ˆƒÿBAƒÀëäÇEôèÎeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿuÿà@‹ðÿ\à@ÿuÌ‹øèñhÿÿY;óu	Wè£eÿÿYëXƒ}uSè4Rÿÿ‹5á@9]ujÿÿuÜÿà@EìPÿuÜÿà@‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹Ãëè(eÿÿÇƒÈÿ^_[ÉËÿU‹ìƒì@¡€A3ʼnEü‹M‹ESVW¾xô@}ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌè*gÿÿ‹uàYY‰;Ãu#‹Eè‰è˜dÿÿÇè dÿÿǃÈÿé/EðPEìSPè¼ÚÿÿƒÄ;ÃtƒøuqSSSSSèËbÿÿƒÄëbEðPè¹’ÿÿ‹øGGY‰}Ð9]ìtÿuì褒ÿÿøY‰}ЋEÔ;ÃtOj‹ð‹_ëP舒ÿÿƒÆ|‹Y;Ãuì¡< A;ÃuCèíÿÿ£< A;Ãu5‹uàÿ6ƒMÜÿèRgÿÿ‹Eè‰Y‰ée‹E艋}È‹‹6;Ã…ñFéU‰]ä8t(Š‹ð€ù=tVè’ÿÿY‹MäL¡< A4‰MäŠ:ËuÜ‹Mä‰MØë+8Xt-€x:u'€x=u!ƒÀPèÝ‘ÿÿY‹MØD‹
< A‰EØÁ€8=t΋EØ+Eä‹uÔø‰}ÀëEðP謑ÿÿPEðPÿ6èƒÄ…ÀtMƒÆ9uÝ}ÐjWè˜eÿÿ‹uàYY‹Mè‰;Ã…2ÿÿÿÿ6èkfÿÿY‰èúbÿÿÇècÿÿƒMÜÿÇéiÇEÄë´P‹Æ+ÆEÌPVèºÿÿƒÄ…Àt
SSSSSè'aÿÿƒÄÿ7è‘ÿÿtƒÇë6P‹Eà‹+ÆEÌPVèIºÿÿƒÄ…Àt
SSSSSèñ`ÿÿƒÄÿ7èãÿÿðƒÇÆ FY‹;ÃuËEèˆ^ÿˆ‹09]Ô„Í‹}Ø‹Eä‹Ï+ÈQ‹
< AÈQVèöºÿÿ+}äƒÄ÷‹}Ôë6‹EÀ‹Mèÿ7+ÆPVèѹÿÿƒÄ…Àt
SSSSSèy`ÿÿƒÄÿ7èkÿÿYtƒÇ9uÆ9]Äug‹}ÐEðPWVè—¹ÿÿƒÄ…Àt
SSSSSè?`ÿÿƒÄh`ã@WVè¸ÿÿƒÄ…Àt
SSSSSè`ÿÿƒÄ9]ìtÿuìWVèß·ÿÿƒÄ…Àt
SSSSSèü_ÿÿƒÄ÷;ót‹Eè;0uˆFˆ¡< A;ÃtPèÑdÿÿY‰< A9]ìt	ÿuìè½dÿÿY‹EÜ‹Mü_^3Í[èIÿÿÉËÿU‹ìV3ö9uu$èBaÿÿ‰0è(aÿÿVVVVVÇè°`ÿÿƒÄjXëU÷EùÿÿÿuÓÿuÿ8á@ƒøÿuÿ\à@PèaÿÿYèç`ÿÿ‹ë(¨u"¨töEtèã`ÿÿÇèÅ`ÿÿÇ
ëÑ3À^]ËÿU‹ìƒìSÿu3ÛMì‰]üèlHÿÿ‹M;Ëu(è“`ÿÿSSSSSÇè`ÿÿƒÄ8]øt‹Eôƒ`pý3ÀëqV‹uð9^uÿuQèjYY8]øtW‹MôƒapýëNWŠ¶Â¶øöD7t!AŠ:Ót¶úÁàÇ9EuAÿ‰Eüë
9]üë9Eu‰MüA:ÓuÃ_8]øt‹Eôƒ`pý‹Eü^[ÉËÿU‹ìjÿuÿuè2ÿÿÿƒÄ]ËÿU‹ìƒìS3Û9]u3ÀéšÿuMìèGÿÿ‹Eð9Xu&ÿuÿuÿuèÇÔÿÿƒÄ8]ø„m‹MôƒapýéaW‹};ût9]u.èƒ_ÿÿSSSSSÇè_ÿÿƒÄ8]øt‹Eôƒ`pý¸ÿÿÿé%Vf¶ÿM·É¶ÑGöD‰MütCŠ:Óu‰]üëXÁáf¶ÒfÊ·Éf‹ñG‰Müf;prf;pwfpë6f;pr0f;pw*fpë$·UüöAt
f¶‰·Éë·Ê‰Müf‹uü‹Mf¶	ÿE·É¶ÑöD‰MütE‹UŠ:Óu‰]üëWÁáf¶ÒfÊÿE·É‰Müf;Hrf;HwfHë6f;Hr0f;Hw*fHë$·UüöAt
f¶‰·Éë·Ê‰Müf‹Müf;Îu!f;ót	9]…ëþÿÿ8]øt‹Eôƒ`pý3À^_[ÉÃÀƒàH8]øtð‹Môƒapýëç‹ÿU‹ìjÿuÿuÿuè#þÿÿƒÄ]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìW‹}3ÀƒÉÿò®ƒÁ÷ÙƒïŠEýò®ƒÇ8t3Àë‹Çü_ÉÔú°úÆúÜúîúûû4ûLû`ûhûzûˆûšû¬û¼ûÊûÜûôûüü8üVüjüzü†ü’üžü¶üÎüØüäüöüýýý(ý8ýNýZýjý’ý¬ýÄýÞýôýþþ*þDþTþjþ„þþžþ®þ¾þÐþäþôþ
ÿÿ,ÿ>ÿPÿbÿnÿ|ÿŒÿ¢ÿ²ÿÂÿÐÿâÿôÿ(8Jç@²A@4K@ÎX@Ð_@»¬@˜@failed to get exit code from process.
failed to create process.
 %s%sCould not exec %sCannot find Python executable %s
#!python.exe#!Cannot open %s
-script.pyCorExitProcessmscoree.dll(null)(null)EEE50P( 8PX700WP  `h````xpxxxx¨!A"A	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=EncodePointerKERNEL32.DLLDecodePointerFlsFreeFlsSetValueFlsGetValueFlsAllocruntime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: ÀÀ–ÀÀŽÀÀÀ‘À’À“À€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwpp         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLLSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecCONOUT$.com.exe.bat.cmd.\SystemRootH€AÐô@Ð7 i™þÿÿÿÔÿÿÿþÿÿÿ×@þÿÿÿÈÿÿÿþÿÿÿ¼#@þÿÿÿÌÿÿÿþÿÿÿ©%@½%@þÿÿÿŒÿÿÿþÿÿÿ<5@@5@þÿÿÿÔÿÿÿþÿÿÿã:@þÿÿÿÐÿÿÿþÿÿÿ±;@þÿÿÿÌÿÿÿþÿÿÿ;=@=@þÿÿÿÔÿÿÿþÿÿÿÀ>@þÿÿÿÔÿÿÿþÿÿÿó?@þÿÿÿÔÿÿÿþÿÿÿA@9A@þÿÿÿÔÿÿÿþÿÿÿ-G@þÿÿÿÌÿÿÿþÿÿÿûJ@þÿÿÿÔÿÿÿþÿÿÿkN@þÿÿÿÔÿÿÿþÿÿÿ­P@þÿÿÿ¼P@þÿÿÿØÿÿÿþÿÿÿoR@þÿÿÿ{R@þÿÿÿÔÿÿÿþÿÿÿ5Y@þÿÿÿØÿÿÿþÿÿÿÛZ@ïZ@þÿÿÿØÿÿÿþÿÿÿ-[@1[@þÿÿÿÀÿÿÿþÿÿÿˆ^@þÿÿÿÐÿÿÿþÿÿÿ_@/_@þÿÿÿÔÿÿÿþÿÿÿ)j@þÿÿÿÐÿÿÿþÿÿÿ:l@þÿÿÿÔÿÿÿþÿÿÿ>y@þÿÿÿÐÿÿÿþÿÿÿN@þÿÿÿÐÿÿÿþÿÿÿ/‚@þÿÿÿÌÿÿÿþÿÿÿ$•@þÿÿÿÐÿÿÿþÿÿÿ½—@þÿÿÿÐÿÿÿþÿÿÿT¡@þÿÿÿÔÿÿÿþÿÿÿË¥@þÿÿÿÈÿÿÿþÿÿÿ‘§@ͦ@þÿÿÿÐÿÿÿþÿÿÿL®@þÿÿÿÐÿÿÿþÿÿÿhÂ@þÿÿÿÌÿÿÿþÿÿÿÊ@Tùà”ú°úÆúÜúîúûû4ûLû`ûhûzûˆûšû¬û¼ûÊûÜûôûüü8üVüjüzü†ü’üžü¶üÎüØüäüöüýýý(ý8ýNýZýjý’ý¬ýÄýÞýôýþþ*þDþTþjþ„þþžþ®þ¾þÐþäþôþ
ÿÿ,ÿ>ÿPÿbÿnÿ|ÿŒÿ¢ÿ²ÿÂÿÐÿâÿôÿ(8JRGenerateConsoleCtrlEventÆGetExitCodeProcessnWaitForSingleObject•CreateProcessA¯SetConsoleCtrlHandlerõGetModuleFileNameAÚEnterCriticalSectionôLeaveCriticalSectionúGetModuleHandleW+Sleep"GetProcAddressExitProcesspGetCommandLineAðSetHandleCount>GetStdHandleØGetFileType<GetStartupInfoA¿DeleteCriticalSection7TerminateProcessªGetCurrentProcessHUnhandledExceptionFilterSetUnhandledExceptionFilterÖIsDebuggerPresentçGetLastError¦HeapFree¢HeapAlloc\GetCPInfoÅInterlockedIncrementÁInterlockedDecrementSGetACPGetOEMCPàIsValidCodePage>TlsGetValue<TlsAlloc?TlsSetValue=TlsFreeôSetLastError®GetCurrentThreadId—WriteFileöLoadLibraryAºInitializeCriticalSectionAndSpinCountKFreeEnvironmentStringsAÀGetEnvironmentStringsLFreeEnvironmentStringsW„WideCharToMultiByteÂGetEnvironmentStringsW¤HeapCreateaVirtualFreeYQueryPerformanceCounterjGetTickCount«GetCurrentProcessIdSGetSystemTimeAsFileTimešRtlUnwind©HeapReAlloc^VirtualAlloc„GetConsoleCP–GetConsoleModeBFlushFileBuffersæLCMapStringAMultiByteToWideCharèLCMapStringW@GetStringTypeACGetStringTypeWéGetLocaleInfoAçSetFilePointer«HeapSizeDCloseHandleŒWriteConsoleAšGetConsoleOutputCP–WriteConsoleWSetStdHandleyCreateFileASCompareStringAVCompareStringWØSetEnvironmentVariableAKERNEL32.dllnReadFileÕSetEndOfFile&GetProcessHeapÊGetFileAttributesAÀ+AÀ+ANæ@»±¿Dê#@lâ@\â@ÿÿÿÿ€

		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZhA¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þlí@þÿÿÿCAAAAAHAhë@ðï@pñ@ˆA˜A˜AhAÿÿÿÿÿÿÿÿøè@Ìè@	 è@
è@Üç@¬ç@ˆç@\ç@$ç@üæ@Äæ@Œæ@dæ@Dæ@àå@ ¨å@!°ä@"ä@xä@yðã@zàã@üÜã@ÿÌã@Η@Η@Η@Η@Η@Η@Η@Η@Η@Η@x
hë@jí@˜ó@”ó@ó@Œó@ˆó@„ó@€ó@xó@pó@hó@\ó@Pó@Hó@<ó@8ó@4ó@0ó@,ó@(ó@$ó@ ó@ó@ó@ó@ó@ó@ó@øò@ðò@èò@(ó@àò@Øò@Ðò@Äò@¼ò@°ò@¤ò@ ò@œò@ò@|ò@pò@	ˆA.DAŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AHA. “€pðñÿÿPSTPDTÐAAÿÿÿÿÿÿÿÿþÿÿÿþÿÿÿÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Mllô@dô@\ô@Tô@././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9506702
setuptools-59.6.0/setuptools/command/0000755000175100001710000000000000000000000017233 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/__init__.py0000644000175100001710000000033100000000000021341 0ustar00runnerdockerfrom distutils.command.bdist import bdist
import sys

if 'egg' not in bdist.format_commands:
    bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
    bdist.format_commands.append('egg')

del bdist, sys
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/alias.py0000644000175100001710000000451500000000000020703 0ustar00runnerdockerfrom distutils.errors import DistutilsOptionError

from setuptools.command.setopt import edit_config, option_base, config_file


def shquote(arg):
    """Quote an argument for later parsing by shlex.split()"""
    for c in '"', "'", "\\", "#":
        if c in arg:
            return repr(arg)
    if arg.split() != [arg]:
        return repr(arg)
    return arg


class alias(option_base):
    """Define a shortcut that invokes one or more commands"""

    description = "define a shortcut to invoke one or more commands"
    command_consumes_arguments = True

    user_options = [
        ('remove', 'r', 'remove (unset) the alias'),
    ] + option_base.user_options

    boolean_options = option_base.boolean_options + ['remove']

    def initialize_options(self):
        option_base.initialize_options(self)
        self.args = None
        self.remove = None

    def finalize_options(self):
        option_base.finalize_options(self)
        if self.remove and len(self.args) != 1:
            raise DistutilsOptionError(
                "Must specify exactly one argument (the alias name) when "
                "using --remove"
            )

    def run(self):
        aliases = self.distribution.get_option_dict('aliases')

        if not self.args:
            print("Command Aliases")
            print("---------------")
            for alias in aliases:
                print("setup.py alias", format_alias(alias, aliases))
            return

        elif len(self.args) == 1:
            alias, = self.args
            if self.remove:
                command = None
            elif alias in aliases:
                print("setup.py alias", format_alias(alias, aliases))
                return
            else:
                print("No alias definition found for %r" % alias)
                return
        else:
            alias = self.args[0]
            command = ' '.join(map(shquote, self.args[1:]))

        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)


def format_alias(name, aliases):
    source, command = aliases[name]
    if source == config_file('global'):
        source = '--global-config '
    elif source == config_file('user'):
        source = '--user-config '
    elif source == config_file('local'):
        source = ''
    else:
        source = '--filename=%r' % source
    return source + name + ' ' + command
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/bdist_egg.py0000644000175100001710000004033400000000000021540 0ustar00runnerdocker"""setuptools.command.bdist_egg

Build .egg distributions"""

from distutils.dir_util import remove_tree, mkpath
from distutils import log
from types import CodeType
import sys
import os
import re
import textwrap
import marshal

from pkg_resources import get_build_platform, Distribution, ensure_directory
from setuptools.extension import Library
from setuptools import Command

from sysconfig import get_path, get_python_version


def _get_purelib():
    return get_path("purelib")


def strip_module(filename):
    if '.' in filename:
        filename = os.path.splitext(filename)[0]
    if filename.endswith('module'):
        filename = filename[:-6]
    return filename


def sorted_walk(dir):
    """Do os.walk in a reproducible way,
    independent of indeterministic filesystem readdir order
    """
    for base, dirs, files in os.walk(dir):
        dirs.sort()
        files.sort()
        yield base, dirs, files


def write_stub(resource, pyfile):
    _stub_template = textwrap.dedent("""
        def __bootstrap__():
            global __bootstrap__, __loader__, __file__
            import sys, pkg_resources, importlib.util
            __file__ = pkg_resources.resource_filename(__name__, %r)
            __loader__ = None; del __bootstrap__, __loader__
            spec = importlib.util.spec_from_file_location(__name__,__file__)
            mod = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(mod)
        __bootstrap__()
        """).lstrip()
    with open(pyfile, 'w') as f:
        f.write(_stub_template % resource)


class bdist_egg(Command):
    description = "create an \"egg\" distribution"

    user_options = [
        ('bdist-dir=', 'b',
         "temporary directory for creating the distribution"),
        ('plat-name=', 'p', "platform name to embed in generated filenames "
                            "(default: %s)" % get_build_platform()),
        ('exclude-source-files', None,
         "remove all .py files from the generated egg"),
        ('keep-temp', 'k',
         "keep the pseudo-installation tree around after " +
         "creating the distribution archive"),
        ('dist-dir=', 'd',
         "directory to put final built distributions in"),
        ('skip-build', None,
         "skip rebuilding everything (for testing/debugging)"),
    ]

    boolean_options = [
        'keep-temp', 'skip-build', 'exclude-source-files'
    ]

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.dist_dir = None
        self.skip_build = 0
        self.egg_output = None
        self.exclude_source_files = None

    def finalize_options(self):
        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
        self.egg_info = ei_cmd.egg_info

        if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'egg')

        if self.plat_name is None:
            self.plat_name = get_build_platform()

        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))

        if self.egg_output is None:

            # Compute filename of the output egg
            basename = Distribution(
                None, None, ei_cmd.egg_name, ei_cmd.egg_version,
                get_python_version(),
                self.distribution.has_ext_modules() and self.plat_name
            ).egg_name()

            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')

    def do_install_data(self):
        # Hack for packages that install data to install's --install-lib
        self.get_finalized_command('install').install_lib = self.bdist_dir

        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
        old, self.distribution.data_files = self.distribution.data_files, []

        for item in old:
            if isinstance(item, tuple) and len(item) == 2:
                if os.path.isabs(item[0]):
                    realpath = os.path.realpath(item[0])
                    normalized = os.path.normcase(realpath)
                    if normalized == site_packages or normalized.startswith(
                        site_packages + os.sep
                    ):
                        item = realpath[len(site_packages) + 1:], item[1]
                        # XXX else: raise ???
            self.distribution.data_files.append(item)

        try:
            log.info("installing package data to %s", self.bdist_dir)
            self.call_command('install_data', force=0, root=None)
        finally:
            self.distribution.data_files = old

    def get_outputs(self):
        return [self.egg_output]

    def call_command(self, cmdname, **kw):
        """Invoke reinitialized command `cmdname` with keyword args"""
        for dirname in INSTALL_DIRECTORY_ATTRS:
            kw.setdefault(dirname, self.bdist_dir)
        kw.setdefault('skip_build', self.skip_build)
        kw.setdefault('dry_run', self.dry_run)
        cmd = self.reinitialize_command(cmdname, **kw)
        self.run_command(cmdname)
        return cmd

    def run(self):  # noqa: C901  # is too complex (14)  # FIXME
        # Generate metadata first
        self.run_command("egg_info")
        # We run install_lib before install_data, because some data hacks
        # pull their data path from the install_lib command.
        log.info("installing library code to %s", self.bdist_dir)
        instcmd = self.get_finalized_command('install')
        old_root = instcmd.root
        instcmd.root = None
        if self.distribution.has_c_libraries() and not self.skip_build:
            self.run_command('build_clib')
        cmd = self.call_command('install_lib', warn_dir=0)
        instcmd.root = old_root

        all_outputs, ext_outputs = self.get_ext_outputs()
        self.stubs = []
        to_compile = []
        for (p, ext_name) in enumerate(ext_outputs):
            filename, ext = os.path.splitext(ext_name)
            pyfile = os.path.join(self.bdist_dir, strip_module(filename) +
                                  '.py')
            self.stubs.append(pyfile)
            log.info("creating stub loader for %s", ext_name)
            if not self.dry_run:
                write_stub(os.path.basename(ext_name), pyfile)
            to_compile.append(pyfile)
            ext_outputs[p] = ext_name.replace(os.sep, '/')

        if to_compile:
            cmd.byte_compile(to_compile)
        if self.distribution.data_files:
            self.do_install_data()

        # Make the EGG-INFO directory
        archive_root = self.bdist_dir
        egg_info = os.path.join(archive_root, 'EGG-INFO')
        self.mkpath(egg_info)
        if self.distribution.scripts:
            script_dir = os.path.join(egg_info, 'scripts')
            log.info("installing scripts to %s", script_dir)
            self.call_command('install_scripts', install_dir=script_dir,
                              no_ep=1)

        self.copy_metadata_to(egg_info)
        native_libs = os.path.join(egg_info, "native_libs.txt")
        if all_outputs:
            log.info("writing %s", native_libs)
            if not self.dry_run:
                ensure_directory(native_libs)
                libs_file = open(native_libs, 'wt')
                libs_file.write('\n'.join(all_outputs))
                libs_file.write('\n')
                libs_file.close()
        elif os.path.isfile(native_libs):
            log.info("removing %s", native_libs)
            if not self.dry_run:
                os.unlink(native_libs)

        write_safety_flag(
            os.path.join(archive_root, 'EGG-INFO'), self.zip_safe()
        )

        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
            log.warn(
                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
                "Use the install_requires/extras_require setup() args instead."
            )

        if self.exclude_source_files:
            self.zap_pyfiles()

        # Make the archive
        make_zipfile(self.egg_output, archive_root, verbose=self.verbose,
                     dry_run=self.dry_run, mode=self.gen_header())
        if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)

        # Add to 'Distribution.dist_files' so that the "upload" command works
        getattr(self.distribution, 'dist_files', []).append(
            ('bdist_egg', get_python_version(), self.egg_output))

    def zap_pyfiles(self):
        log.info("Removing .py files from temporary directory")
        for base, dirs, files in walk_egg(self.bdist_dir):
            for name in files:
                path = os.path.join(base, name)

                if name.endswith('.py'):
                    log.debug("Deleting %s", path)
                    os.unlink(path)

                if base.endswith('__pycache__'):
                    path_old = path

                    pattern = r'(?P.+)\.(?P[^.]+)\.pyc'
                    m = re.match(pattern, name)
                    path_new = os.path.join(
                        base, os.pardir, m.group('name') + '.pyc')
                    log.info(
                        "Renaming file from [%s] to [%s]"
                        % (path_old, path_new))
                    try:
                        os.remove(path_new)
                    except OSError:
                        pass
                    os.rename(path_old, path_new)

    def zip_safe(self):
        safe = getattr(self.distribution, 'zip_safe', None)
        if safe is not None:
            return safe
        log.warn("zip_safe flag not set; analyzing archive contents...")
        return analyze_egg(self.bdist_dir, self.stubs)

    def gen_header(self):
        return 'w'

    def copy_metadata_to(self, target_dir):
        "Copy metadata (egg info) to the target_dir"
        # normalize the path (so that a forward-slash in egg_info will
        # match using startswith below)
        norm_egg_info = os.path.normpath(self.egg_info)
        prefix = os.path.join(norm_egg_info, '')
        for path in self.ei_cmd.filelist.files:
            if path.startswith(prefix):
                target = os.path.join(target_dir, path[len(prefix):])
                ensure_directory(target)
                self.copy_file(path, target)

    def get_ext_outputs(self):
        """Get a list of relative paths to C extensions in the output distro"""

        all_outputs = []
        ext_outputs = []

        paths = {self.bdist_dir: ''}
        for base, dirs, files in sorted_walk(self.bdist_dir):
            for filename in files:
                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
                    all_outputs.append(paths[base] + filename)
            for filename in dirs:
                paths[os.path.join(base, filename)] = (paths[base] +
                                                       filename + '/')

        if self.distribution.has_ext_modules():
            build_cmd = self.get_finalized_command('build_ext')
            for ext in build_cmd.extensions:
                if isinstance(ext, Library):
                    continue
                fullname = build_cmd.get_ext_fullname(ext.name)
                filename = build_cmd.get_ext_filename(fullname)
                if not os.path.basename(filename).startswith('dl-'):
                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
                        ext_outputs.append(filename)

        return all_outputs, ext_outputs


NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())


def walk_egg(egg_dir):
    """Walk an unpacked egg's contents, skipping the metadata directory"""
    walker = sorted_walk(egg_dir)
    base, dirs, files = next(walker)
    if 'EGG-INFO' in dirs:
        dirs.remove('EGG-INFO')
    yield base, dirs, files
    for bdf in walker:
        yield bdf


def analyze_egg(egg_dir, stubs):
    # check for existing flag in EGG-INFO
    for flag, fn in safety_flags.items():
        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
            return flag
    if not can_scan():
        return False
    safe = True
    for base, dirs, files in walk_egg(egg_dir):
        for name in files:
            if name.endswith('.py') or name.endswith('.pyw'):
                continue
            elif name.endswith('.pyc') or name.endswith('.pyo'):
                # always scan, even if we already know we're not safe
                safe = scan_module(egg_dir, base, name, stubs) and safe
    return safe


def write_safety_flag(egg_dir, safe):
    # Write or remove zip safety flag file(s)
    for flag, fn in safety_flags.items():
        fn = os.path.join(egg_dir, fn)
        if os.path.exists(fn):
            if safe is None or bool(safe) != flag:
                os.unlink(fn)
        elif safe is not None and bool(safe) == flag:
            f = open(fn, 'wt')
            f.write('\n')
            f.close()


safety_flags = {
    True: 'zip-safe',
    False: 'not-zip-safe',
}


def scan_module(egg_dir, base, name, stubs):
    """Check whether module possibly uses unsafe-for-zipfile stuff"""

    filename = os.path.join(base, name)
    if filename[:-1] in stubs:
        return True  # Extension module
    pkg = base[len(egg_dir) + 1:].replace(os.sep, '.')
    module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
    if sys.version_info < (3, 7):
        skip = 12  # skip magic & date & file size
    else:
        skip = 16  # skip magic & reserved? & date & file size
    f = open(filename, 'rb')
    f.read(skip)
    code = marshal.load(f)
    f.close()
    safe = True
    symbols = dict.fromkeys(iter_symbols(code))
    for bad in ['__file__', '__path__']:
        if bad in symbols:
            log.warn("%s: module references %s", module, bad)
            safe = False
    if 'inspect' in symbols:
        for bad in [
            'getsource', 'getabsfile', 'getsourcefile', 'getfile'
            'getsourcelines', 'findsource', 'getcomments', 'getframeinfo',
            'getinnerframes', 'getouterframes', 'stack', 'trace'
        ]:
            if bad in symbols:
                log.warn("%s: module MAY be using inspect.%s", module, bad)
                safe = False
    return safe


def iter_symbols(code):
    """Yield names and strings used by `code` and its nested code objects"""
    for name in code.co_names:
        yield name
    for const in code.co_consts:
        if isinstance(const, str):
            yield const
        elif isinstance(const, CodeType):
            for name in iter_symbols(const):
                yield name


def can_scan():
    if not sys.platform.startswith('java') and sys.platform != 'cli':
        # CPython, PyPy, etc.
        return True
    log.warn("Unable to analyze compiled code on this platform.")
    log.warn("Please ask the author to include a 'zip_safe'"
             " setting (either True or False) in the package's setup.py")


# Attribute names of options for commands that might need to be convinced to
# install to the egg build directory

INSTALL_DIRECTORY_ATTRS = [
    'install_lib', 'install_dir', 'install_data', 'install_base'
]


def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
                 mode='w'):
    """Create a zip file from all the files under 'base_dir'.  The output
    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
    Python module (if available) or the InfoZIP "zip" utility (if installed
    and found on the default search path).  If neither tool is available,
    raises DistutilsExecError.  Returns the name of the output zip file.
    """
    import zipfile

    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)

    def visit(z, dirname, names):
        for name in names:
            path = os.path.normpath(os.path.join(dirname, name))
            if os.path.isfile(path):
                p = path[len(base_dir) + 1:]
                if not dry_run:
                    z.write(path, p)
                log.debug("adding '%s'", p)

    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
    if not dry_run:
        z = zipfile.ZipFile(zip_filename, mode, compression=compression)
        for dirname, dirs, files in sorted_walk(base_dir):
            visit(z, dirname, files)
        z.close()
    else:
        for dirname, dirs, files in sorted_walk(base_dir):
            visit(None, dirname, files)
    return zip_filename
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/bdist_rpm.py0000644000175100001710000000223600000000000021573 0ustar00runnerdockerimport distutils.command.bdist_rpm as orig
import warnings

from setuptools import SetuptoolsDeprecationWarning


class bdist_rpm(orig.bdist_rpm):
    """
    Override the default bdist_rpm behavior to do the following:

    1. Run egg_info to ensure the name and version are properly calculated.
    2. Always run 'install' using --single-version-externally-managed to
       disable eggs in RPM distributions.
    """

    def run(self):
        warnings.warn(
            "bdist_rpm is deprecated and will be removed in a future "
            "version. Use bdist_wheel (wheel packages) instead.",
            SetuptoolsDeprecationWarning,
        )

        # ensure distro name is up-to-date
        self.run_command('egg_info')

        orig.bdist_rpm.run(self)

    def _make_spec_file(self):
        spec = orig.bdist_rpm._make_spec_file(self)
        spec = [
            line.replace(
                "setup.py install ",
                "setup.py install --single-version-externally-managed "
            ).replace(
                "%setup",
                "%setup -n %{name}-%{unmangled_version}"
            )
            for line in spec
        ]
        return spec
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/build_clib.py0000644000175100001710000001047700000000000021706 0ustar00runnerdockerimport distutils.command.build_clib as orig
from distutils.errors import DistutilsSetupError
from distutils import log
from setuptools.dep_util import newer_pairwise_group


class build_clib(orig.build_clib):
    """
    Override the default build_clib behaviour to do the following:

    1. Implement a rudimentary timestamp-based dependency system
       so 'compile()' doesn't run every time.
    2. Add more keys to the 'build_info' dictionary:
        * obj_deps - specify dependencies for each object compiled.
                     this should be a dictionary mapping a key
                     with the source filename to a list of
                     dependencies. Use an empty string for global
                     dependencies.
        * cflags   - specify a list of additional flags to pass to
                     the compiler.
    """

    def build_libraries(self, libraries):
        for (lib_name, build_info) in libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'sources' must be present and must be "
                    "a list of source filenames" % lib_name)
            sources = list(sources)

            log.info("building '%s' library", lib_name)

            # Make sure everything is the correct type.
            # obj_deps should be a dictionary of keys as sources
            # and a list/tuple of files that are its dependencies.
            obj_deps = build_info.get('obj_deps', dict())
            if not isinstance(obj_deps, dict):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'obj_deps' must be a dictionary of "
                    "type 'source: list'" % lib_name)
            dependencies = []

            # Get the global dependencies that are specified by the '' key.
            # These will go into every source's dependency list.
            global_deps = obj_deps.get('', list())
            if not isinstance(global_deps, (list, tuple)):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'obj_deps' must be a dictionary of "
                    "type 'source: list'" % lib_name)

            # Build the list to be used by newer_pairwise_group
            # each source will be auto-added to its dependencies.
            for source in sources:
                src_deps = [source]
                src_deps.extend(global_deps)
                extra_deps = obj_deps.get(source, list())
                if not isinstance(extra_deps, (list, tuple)):
                    raise DistutilsSetupError(
                        "in 'libraries' option (library '%s'), "
                        "'obj_deps' must be a dictionary of "
                        "type 'source: list'" % lib_name)
                src_deps.extend(extra_deps)
                dependencies.append(src_deps)

            expected_objects = self.compiler.object_filenames(
                sources,
                output_dir=self.build_temp,
            )

            if (
                newer_pairwise_group(dependencies, expected_objects)
                != ([], [])
            ):
                # First, compile the source code to object files in the library
                # directory.  (This should probably change to putting object
                # files in a temporary build directory.)
                macros = build_info.get('macros')
                include_dirs = build_info.get('include_dirs')
                cflags = build_info.get('cflags')
                self.compiler.compile(
                    sources,
                    output_dir=self.build_temp,
                    macros=macros,
                    include_dirs=include_dirs,
                    extra_postargs=cflags,
                    debug=self.debug
                )

            # Now "link" the object files together into a static library.
            # (On Unix at least, this isn't really linking -- it just
            # builds an archive.  Whatever.)
            self.compiler.create_static_lib(
                expected_objects,
                lib_name,
                output_dir=self.build_clib,
                debug=self.debug
            )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/build_ext.py0000644000175100001710000003163400000000000021573 0ustar00runnerdockerimport os
import sys
import itertools
from importlib.machinery import EXTENSION_SUFFIXES
from distutils.command.build_ext import build_ext as _du_build_ext
from distutils.file_util import copy_file
from distutils.ccompiler import new_compiler
from distutils.sysconfig import customize_compiler, get_config_var
from distutils.errors import DistutilsError
from distutils import log

from setuptools.extension import Library

try:
    # Attempt to use Cython for building extensions, if available
    from Cython.Distutils.build_ext import build_ext as _build_ext
    # Additionally, assert that the compiler module will load
    # also. Ref #1229.
    __import__('Cython.Compiler.Main')
except ImportError:
    _build_ext = _du_build_ext

# make sure _config_vars is initialized
get_config_var("LDSHARED")
from distutils.sysconfig import _config_vars as _CONFIG_VARS  # noqa


def _customize_compiler_for_shlib(compiler):
    if sys.platform == "darwin":
        # building .dylib requires additional compiler flags on OSX; here we
        # temporarily substitute the pyconfig.h variables so that distutils'
        # 'customize_compiler' uses them before we build the shared libraries.
        tmp = _CONFIG_VARS.copy()
        try:
            # XXX Help!  I don't have any idea whether these are right...
            _CONFIG_VARS['LDSHARED'] = (
                "gcc -Wl,-x -dynamiclib -undefined dynamic_lookup")
            _CONFIG_VARS['CCSHARED'] = " -dynamiclib"
            _CONFIG_VARS['SO'] = ".dylib"
            customize_compiler(compiler)
        finally:
            _CONFIG_VARS.clear()
            _CONFIG_VARS.update(tmp)
    else:
        customize_compiler(compiler)


have_rtld = False
use_stubs = False
libtype = 'shared'

if sys.platform == "darwin":
    use_stubs = True
elif os.name != 'nt':
    try:
        import dl
        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
    except ImportError:
        pass


def if_dl(s):
    return s if have_rtld else ''


def get_abi3_suffix():
    """Return the file extension for an abi3-compliant Extension()"""
    for suffix in EXTENSION_SUFFIXES:
        if '.abi3' in suffix:  # Unix
            return suffix
        elif suffix == '.pyd':  # Windows
            return suffix


class build_ext(_build_ext):
    def run(self):
        """Build extensions in build directory, then copy if --inplace"""
        old_inplace, self.inplace = self.inplace, 0
        _build_ext.run(self)
        self.inplace = old_inplace
        if old_inplace:
            self.copy_extensions_to_source()

    def copy_extensions_to_source(self):
        build_py = self.get_finalized_command('build_py')
        for ext in self.extensions:
            fullname = self.get_ext_fullname(ext.name)
            filename = self.get_ext_filename(fullname)
            modpath = fullname.split('.')
            package = '.'.join(modpath[:-1])
            package_dir = build_py.get_package_dir(package)
            dest_filename = os.path.join(package_dir,
                                         os.path.basename(filename))
            src_filename = os.path.join(self.build_lib, filename)

            # Always copy, even if source is older than destination, to ensure
            # that the right extensions for the current Python/platform are
            # used.
            copy_file(
                src_filename, dest_filename, verbose=self.verbose,
                dry_run=self.dry_run
            )
            if ext._needs_stub:
                self.write_stub(package_dir or os.curdir, ext, True)

    def get_ext_filename(self, fullname):
        so_ext = os.getenv('SETUPTOOLS_EXT_SUFFIX')
        if so_ext:
            filename = os.path.join(*fullname.split('.')) + so_ext
        else:
            filename = _build_ext.get_ext_filename(self, fullname)
            so_ext = get_config_var('EXT_SUFFIX')

        if fullname in self.ext_map:
            ext = self.ext_map[fullname]
            use_abi3 = getattr(ext, 'py_limited_api') and get_abi3_suffix()
            if use_abi3:
                filename = filename[:-len(so_ext)]
                so_ext = get_abi3_suffix()
                filename = filename + so_ext
            if isinstance(ext, Library):
                fn, ext = os.path.splitext(filename)
                return self.shlib_compiler.library_filename(fn, libtype)
            elif use_stubs and ext._links_to_dynamic:
                d, fn = os.path.split(filename)
                return os.path.join(d, 'dl-' + fn)
        return filename

    def initialize_options(self):
        _build_ext.initialize_options(self)
        self.shlib_compiler = None
        self.shlibs = []
        self.ext_map = {}

    def finalize_options(self):
        _build_ext.finalize_options(self)
        self.extensions = self.extensions or []
        self.check_extensions_list(self.extensions)
        self.shlibs = [ext for ext in self.extensions
                       if isinstance(ext, Library)]
        if self.shlibs:
            self.setup_shlib_compiler()
        for ext in self.extensions:
            ext._full_name = self.get_ext_fullname(ext.name)
        for ext in self.extensions:
            fullname = ext._full_name
            self.ext_map[fullname] = ext

            # distutils 3.1 will also ask for module names
            # XXX what to do with conflicts?
            self.ext_map[fullname.split('.')[-1]] = ext

            ltd = self.shlibs and self.links_to_dynamic(ext) or False
            ns = ltd and use_stubs and not isinstance(ext, Library)
            ext._links_to_dynamic = ltd
            ext._needs_stub = ns
            filename = ext._file_name = self.get_ext_filename(fullname)
            libdir = os.path.dirname(os.path.join(self.build_lib, filename))
            if ltd and libdir not in ext.library_dirs:
                ext.library_dirs.append(libdir)
            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
                ext.runtime_library_dirs.append(os.curdir)

    def setup_shlib_compiler(self):
        compiler = self.shlib_compiler = new_compiler(
            compiler=self.compiler, dry_run=self.dry_run, force=self.force
        )
        _customize_compiler_for_shlib(compiler)

        if self.include_dirs is not None:
            compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for (name, value) in self.define:
                compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                compiler.undefine_macro(macro)
        if self.libraries is not None:
            compiler.set_libraries(self.libraries)
        if self.library_dirs is not None:
            compiler.set_library_dirs(self.library_dirs)
        if self.rpath is not None:
            compiler.set_runtime_library_dirs(self.rpath)
        if self.link_objects is not None:
            compiler.set_link_objects(self.link_objects)

        # hack so distutils' build_extension() builds a library instead
        compiler.link_shared_object = link_shared_object.__get__(compiler)

    def get_export_symbols(self, ext):
        if isinstance(ext, Library):
            return ext.export_symbols
        return _build_ext.get_export_symbols(self, ext)

    def build_extension(self, ext):
        ext._convert_pyx_sources_to_lang()
        _compiler = self.compiler
        try:
            if isinstance(ext, Library):
                self.compiler = self.shlib_compiler
            _build_ext.build_extension(self, ext)
            if ext._needs_stub:
                cmd = self.get_finalized_command('build_py').build_lib
                self.write_stub(cmd, ext)
        finally:
            self.compiler = _compiler

    def links_to_dynamic(self, ext):
        """Return true if 'ext' links to a dynamic lib in the same package"""
        # XXX this should check to ensure the lib is actually being built
        # XXX as dynamic, and not just using a locally-found version or a
        # XXX static-compiled version
        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
        pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
        return any(pkg + libname in libnames for libname in ext.libraries)

    def get_outputs(self):
        return _build_ext.get_outputs(self) + self.__get_stubs_outputs()

    def __get_stubs_outputs(self):
        # assemble the base name for each extension that needs a stub
        ns_ext_bases = (
            os.path.join(self.build_lib, *ext._full_name.split('.'))
            for ext in self.extensions
            if ext._needs_stub
        )
        # pair each base with the extension
        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
        return list(base + fnext for base, fnext in pairs)

    def __get_output_extensions(self):
        yield '.py'
        yield '.pyc'
        if self.get_finalized_command('build_py').optimize:
            yield '.pyo'

    def write_stub(self, output_dir, ext, compile=False):
        log.info("writing stub loader for %s to %s", ext._full_name,
                 output_dir)
        stub_file = (os.path.join(output_dir, *ext._full_name.split('.')) +
                     '.py')
        if compile and os.path.exists(stub_file):
            raise DistutilsError(stub_file + " already exists! Please delete.")
        if not self.dry_run:
            f = open(stub_file, 'w')
            f.write(
                '\n'.join([
                    "def __bootstrap__():",
                    "   global __bootstrap__, __file__, __loader__",
                    "   import sys, os, pkg_resources, importlib.util" +
                    if_dl(", dl"),
                    "   __file__ = pkg_resources.resource_filename"
                    "(__name__,%r)"
                    % os.path.basename(ext._file_name),
                    "   del __bootstrap__",
                    "   if '__loader__' in globals():",
                    "       del __loader__",
                    if_dl("   old_flags = sys.getdlopenflags()"),
                    "   old_dir = os.getcwd()",
                    "   try:",
                    "     os.chdir(os.path.dirname(__file__))",
                    if_dl("     sys.setdlopenflags(dl.RTLD_NOW)"),
                    "     spec = importlib.util.spec_from_file_location(",
                    "                __name__, __file__)",
                    "     mod = importlib.util.module_from_spec(spec)",
                    "     spec.loader.exec_module(mod)",
                    "   finally:",
                    if_dl("     sys.setdlopenflags(old_flags)"),
                    "     os.chdir(old_dir)",
                    "__bootstrap__()",
                    ""  # terminal \n
                ])
            )
            f.close()
        if compile:
            from distutils.util import byte_compile

            byte_compile([stub_file], optimize=0,
                         force=True, dry_run=self.dry_run)
            optimize = self.get_finalized_command('install_lib').optimize
            if optimize > 0:
                byte_compile([stub_file], optimize=optimize,
                             force=True, dry_run=self.dry_run)
            if os.path.exists(stub_file) and not self.dry_run:
                os.unlink(stub_file)


if use_stubs or os.name == 'nt':
    # Build shared libraries
    #
    def link_shared_object(
            self, objects, output_libname, output_dir=None, libraries=None,
            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
            target_lang=None):
        self.link(
            self.SHARED_LIBRARY, objects, output_libname,
            output_dir, libraries, library_dirs, runtime_library_dirs,
            export_symbols, debug, extra_preargs, extra_postargs,
            build_temp, target_lang
        )
else:
    # Build static libraries everywhere else
    libtype = 'static'

    def link_shared_object(
            self, objects, output_libname, output_dir=None, libraries=None,
            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
            target_lang=None):
        # XXX we need to either disallow these attrs on Library instances,
        # or warn/abort here if set, or something...
        # libraries=None, library_dirs=None, runtime_library_dirs=None,
        # export_symbols=None, extra_preargs=None, extra_postargs=None,
        # build_temp=None

        assert output_dir is None  # distutils build_ext doesn't pass this
        output_dir, filename = os.path.split(output_libname)
        basename, ext = os.path.splitext(filename)
        if self.library_filename("x").startswith('lib'):
            # strip 'lib' prefix; this is kludgy if some platform uses
            # a different prefix
            basename = basename[3:]

        self.create_static_lib(
            objects, basename, output_dir, debug, target_lang
        )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/build_py.py0000644000175100001710000002105700000000000021421 0ustar00runnerdockerfrom glob import glob
from distutils.util import convert_path
import distutils.command.build_py as orig
import os
import fnmatch
import textwrap
import io
import distutils.errors
import itertools
import stat
from setuptools.extern.more_itertools import unique_everseen


def make_writable(target):
    os.chmod(target, os.stat(target).st_mode | stat.S_IWRITE)


class build_py(orig.build_py):
    """Enhanced 'build_py' command that includes data files with packages

    The data files are specified via a 'package_data' argument to 'setup()'.
    See 'setuptools.dist.Distribution' for more details.

    Also, this version of the 'build_py' command allows you to specify both
    'py_modules' and 'packages' in the same setup operation.
    """

    def finalize_options(self):
        orig.build_py.finalize_options(self)
        self.package_data = self.distribution.package_data
        self.exclude_package_data = self.distribution.exclude_package_data or {}
        if 'data_files' in self.__dict__:
            del self.__dict__['data_files']
        self.__updated_files = []

    def run(self):
        """Build modules, packages, and copy data files to build directory"""
        if not self.py_modules and not self.packages:
            return

        if self.py_modules:
            self.build_modules()

        if self.packages:
            self.build_packages()
            self.build_package_data()

        # Only compile actual .py files, using our base class' idea of what our
        # output files are.
        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=0))

    def __getattr__(self, attr):
        "lazily compute data files"
        if attr == 'data_files':
            self.data_files = self._get_data_files()
            return self.data_files
        return orig.build_py.__getattr__(self, attr)

    def build_module(self, module, module_file, package):
        outfile, copied = orig.build_py.build_module(self, module, module_file, package)
        if copied:
            self.__updated_files.append(outfile)
        return outfile, copied

    def _get_data_files(self):
        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
        self.analyze_manifest()
        return list(map(self._get_pkg_data_files, self.packages or ()))

    def get_data_files_without_manifest(self):
        """
        Generate list of ``(package,src_dir,build_dir,filenames)`` tuples,
        but without triggering any attempt to analyze or build the manifest.
        """
        # Prevent eventual errors from unset `manifest_files`
        # (that would otherwise be set by `analyze_manifest`)
        self.__dict__.setdefault('manifest_files', {})
        return list(map(self._get_pkg_data_files, self.packages or ()))

    def _get_pkg_data_files(self, package):
        # Locate package source directory
        src_dir = self.get_package_dir(package)

        # Compute package build directory
        build_dir = os.path.join(*([self.build_lib] + package.split('.')))

        # Strip directory from globbed filenames
        filenames = [
            os.path.relpath(file, src_dir)
            for file in self.find_data_files(package, src_dir)
        ]
        return package, src_dir, build_dir, filenames

    def find_data_files(self, package, src_dir):
        """Return filenames for package's data files in 'src_dir'"""
        patterns = self._get_platform_patterns(
            self.package_data,
            package,
            src_dir,
        )
        globs_expanded = map(glob, patterns)
        # flatten the expanded globs into an iterable of matches
        globs_matches = itertools.chain.from_iterable(globs_expanded)
        glob_files = filter(os.path.isfile, globs_matches)
        files = itertools.chain(
            self.manifest_files.get(package, []),
            glob_files,
        )
        return self.exclude_data_files(package, src_dir, files)

    def build_package_data(self):
        """Copy data files into build directory"""
        for package, src_dir, build_dir, filenames in self.data_files:
            for filename in filenames:
                target = os.path.join(build_dir, filename)
                self.mkpath(os.path.dirname(target))
                srcfile = os.path.join(src_dir, filename)
                outf, copied = self.copy_file(srcfile, target)
                make_writable(target)
                srcfile = os.path.abspath(srcfile)

    def analyze_manifest(self):
        self.manifest_files = mf = {}
        if not self.distribution.include_package_data:
            return
        src_dirs = {}
        for package in self.packages or ():
            # Locate package source directory
            src_dirs[assert_relative(self.get_package_dir(package))] = package

        self.run_command('egg_info')
        ei_cmd = self.get_finalized_command('egg_info')
        for path in ei_cmd.filelist.files:
            d, f = os.path.split(assert_relative(path))
            prev = None
            oldf = f
            while d and d != prev and d not in src_dirs:
                prev = d
                d, df = os.path.split(d)
                f = os.path.join(df, f)
            if d in src_dirs:
                if path.endswith('.py') and f == oldf:
                    continue  # it's a module, not data
                mf.setdefault(src_dirs[d], []).append(path)

    def get_data_files(self):
        pass  # Lazily compute data files in _get_data_files() function.

    def check_package(self, package, package_dir):
        """Check namespace packages' __init__ for declare_namespace"""
        try:
            return self.packages_checked[package]
        except KeyError:
            pass

        init_py = orig.build_py.check_package(self, package, package_dir)
        self.packages_checked[package] = init_py

        if not init_py or not self.distribution.namespace_packages:
            return init_py

        for pkg in self.distribution.namespace_packages:
            if pkg == package or pkg.startswith(package + '.'):
                break
        else:
            return init_py

        with io.open(init_py, 'rb') as f:
            contents = f.read()
        if b'declare_namespace' not in contents:
            raise distutils.errors.DistutilsError(
                "Namespace package problem: %s is a namespace package, but "
                "its\n__init__.py does not call declare_namespace()! Please "
                'fix it.\n(See the setuptools manual under '
                '"Namespace Packages" for details.)\n"' % (package,)
            )
        return init_py

    def initialize_options(self):
        self.packages_checked = {}
        orig.build_py.initialize_options(self)

    def get_package_dir(self, package):
        res = orig.build_py.get_package_dir(self, package)
        if self.distribution.src_root is not None:
            return os.path.join(self.distribution.src_root, res)
        return res

    def exclude_data_files(self, package, src_dir, files):
        """Filter filenames for package's data files in 'src_dir'"""
        files = list(files)
        patterns = self._get_platform_patterns(
            self.exclude_package_data,
            package,
            src_dir,
        )
        match_groups = (fnmatch.filter(files, pattern) for pattern in patterns)
        # flatten the groups of matches into an iterable of matches
        matches = itertools.chain.from_iterable(match_groups)
        bad = set(matches)
        keepers = (fn for fn in files if fn not in bad)
        # ditch dupes
        return list(unique_everseen(keepers))

    @staticmethod
    def _get_platform_patterns(spec, package, src_dir):
        """
        yield platform-specific path patterns (suitable for glob
        or fn_match) from a glob-based spec (such as
        self.package_data or self.exclude_package_data)
        matching package in src_dir.
        """
        raw_patterns = itertools.chain(
            spec.get('', []),
            spec.get(package, []),
        )
        return (
            # Each pattern has to be converted to a platform-specific path
            os.path.join(src_dir, convert_path(pattern))
            for pattern in raw_patterns
        )


def assert_relative(path):
    if not os.path.isabs(path):
        return path
    from distutils.errors import DistutilsSetupError

    msg = (
        textwrap.dedent(
            """
        Error: setup script specifies an absolute path:

            %s

        setup() arguments must *always* be /-separated paths relative to the
        setup.py directory, *never* absolute paths.
        """
        ).lstrip()
        % path
    )
    raise DistutilsSetupError(msg)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/develop.py0000644000175100001710000001554400000000000021254 0ustar00runnerdockerfrom distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsError, DistutilsOptionError
import os
import glob
import io

import pkg_resources
from setuptools.command.easy_install import easy_install
from setuptools import namespaces
import setuptools


class develop(namespaces.DevelopInstaller, easy_install):
    """Set up package for development"""

    description = "install package in 'development mode'"

    user_options = easy_install.user_options + [
        ("uninstall", "u", "Uninstall this source package"),
        ("egg-path=", None, "Set the path to be used in the .egg-link file"),
    ]

    boolean_options = easy_install.boolean_options + ['uninstall']

    command_consumes_arguments = False  # override base

    def run(self):
        if self.uninstall:
            self.multi_version = True
            self.uninstall_link()
            self.uninstall_namespaces()
        else:
            self.install_for_development()
        self.warn_deprecated_options()

    def initialize_options(self):
        self.uninstall = None
        self.egg_path = None
        easy_install.initialize_options(self)
        self.setup_path = None
        self.always_copy_from = '.'  # always copy eggs installed in curdir

    def finalize_options(self):
        ei = self.get_finalized_command("egg_info")
        if ei.broken_egg_info:
            template = "Please rename %r to %r before using 'develop'"
            args = ei.egg_info, ei.broken_egg_info
            raise DistutilsError(template % args)
        self.args = [ei.egg_name]

        easy_install.finalize_options(self)
        self.expand_basedirs()
        self.expand_dirs()
        # pick up setup-dir .egg files only: no .egg-info
        self.package_index.scan(glob.glob('*.egg'))

        egg_link_fn = ei.egg_name + '.egg-link'
        self.egg_link = os.path.join(self.install_dir, egg_link_fn)
        self.egg_base = ei.egg_base
        if self.egg_path is None:
            self.egg_path = os.path.abspath(ei.egg_base)

        target = pkg_resources.normalize_path(self.egg_base)
        egg_path = pkg_resources.normalize_path(
            os.path.join(self.install_dir, self.egg_path)
        )
        if egg_path != target:
            raise DistutilsOptionError(
                "--egg-path must be a relative path from the install"
                " directory to " + target
            )

        # Make a distribution for the package's source
        self.dist = pkg_resources.Distribution(
            target,
            pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
            project_name=ei.egg_name,
        )

        self.setup_path = self._resolve_setup_path(
            self.egg_base,
            self.install_dir,
            self.egg_path,
        )

    @staticmethod
    def _resolve_setup_path(egg_base, install_dir, egg_path):
        """
        Generate a path from egg_base back to '.' where the
        setup script resides and ensure that path points to the
        setup path from $install_dir/$egg_path.
        """
        path_to_setup = egg_base.replace(os.sep, '/').rstrip('/')
        if path_to_setup != os.curdir:
            path_to_setup = '../' * (path_to_setup.count('/') + 1)
        resolved = pkg_resources.normalize_path(
            os.path.join(install_dir, egg_path, path_to_setup)
        )
        if resolved != pkg_resources.normalize_path(os.curdir):
            raise DistutilsOptionError(
                "Can't get a consistent path to setup script from"
                " installation directory",
                resolved,
                pkg_resources.normalize_path(os.curdir),
            )
        return path_to_setup

    def install_for_development(self):
        self.run_command('egg_info')

        # Build extensions in-place
        self.reinitialize_command('build_ext', inplace=1)
        self.run_command('build_ext')

        if setuptools.bootstrap_install_from:
            self.easy_install(setuptools.bootstrap_install_from)
            setuptools.bootstrap_install_from = None

        self.install_namespaces()

        # create an .egg-link in the installation dir, pointing to our egg
        log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
        if not self.dry_run:
            with open(self.egg_link, "w") as f:
                f.write(self.egg_path + "\n" + self.setup_path)
        # postprocess the installed distro, fixing up .pth, installing scripts,
        # and handling requirements
        self.process_distribution(None, self.dist, not self.no_deps)

    def uninstall_link(self):
        if os.path.exists(self.egg_link):
            log.info("Removing %s (link to %s)", self.egg_link, self.egg_base)
            egg_link_file = open(self.egg_link)
            contents = [line.rstrip() for line in egg_link_file]
            egg_link_file.close()
            if contents not in ([self.egg_path], [self.egg_path, self.setup_path]):
                log.warn("Link points to %s: uninstall aborted", contents)
                return
            if not self.dry_run:
                os.unlink(self.egg_link)
        if not self.dry_run:
            self.update_pth(self.dist)  # remove any .pth link to us
        if self.distribution.scripts:
            # XXX should also check for entry point scripts!
            log.warn("Note: you must uninstall or replace scripts manually!")

    def install_egg_scripts(self, dist):
        if dist is not self.dist:
            # Installing a dependency, so fall back to normal behavior
            return easy_install.install_egg_scripts(self, dist)

        # create wrapper scripts in the script dir, pointing to dist.scripts

        # new-style...
        self.install_wrapper_scripts(dist)

        # ...and old-style
        for script_name in self.distribution.scripts or []:
            script_path = os.path.abspath(convert_path(script_name))
            script_name = os.path.basename(script_path)
            with io.open(script_path) as strm:
                script_text = strm.read()
            self.install_script(dist, script_name, script_text, script_path)

    def install_wrapper_scripts(self, dist):
        dist = VersionlessRequirement(dist)
        return easy_install.install_wrapper_scripts(self, dist)


class VersionlessRequirement:
    """
    Adapt a pkg_resources.Distribution to simply return the project
    name as the 'requirement' so that scripts will work across
    multiple versions.

    >>> from pkg_resources import Distribution
    >>> dist = Distribution(project_name='foo', version='1.0')
    >>> str(dist.as_requirement())
    'foo==1.0'
    >>> adapted_dist = VersionlessRequirement(dist)
    >>> str(adapted_dist.as_requirement())
    'foo'
    """

    def __init__(self, dist):
        self.__dist = dist

    def __getattr__(self, name):
        return getattr(self.__dist, name)

    def as_requirement(self):
        return self.project_name
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/dist_info.py0000644000175100001710000000170000000000000021561 0ustar00runnerdocker"""
Create a dist_info directory
As defined in the wheel specification
"""

import os

from distutils.core import Command
from distutils import log


class dist_info(Command):

    description = 'create a .dist-info directory'

    user_options = [
        ('egg-base=', 'e', "directory containing .egg-info directories"
                           " (default: top of the source tree)"),
    ]

    def initialize_options(self):
        self.egg_base = None

    def finalize_options(self):
        pass

    def run(self):
        egg_info = self.get_finalized_command('egg_info')
        egg_info.egg_base = self.egg_base
        egg_info.finalize_options()
        egg_info.run()
        dist_info_dir = egg_info.egg_info[:-len('.egg-info')] + '.dist-info'
        log.info("creating '{}'".format(os.path.abspath(dist_info_dir)))

        bdist_wheel = self.get_finalized_command('bdist_wheel')
        bdist_wheel.egg2dist(egg_info.egg_info, dist_info_dir)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/easy_install.py0000644000175100001710000024720700000000000022310 0ustar00runnerdocker"""
Easy Install
------------

A tool for doing automatic download/extract/build of distutils-based Python
packages.  For detailed documentation, see the accompanying EasyInstall.txt
file, or visit the `EasyInstall home page`__.

__ https://setuptools.pypa.io/en/latest/deprecated/easy_install.html

"""

from glob import glob
from distutils.util import get_platform
from distutils.util import convert_path, subst_vars
from distutils.errors import (
    DistutilsArgError, DistutilsOptionError,
    DistutilsError, DistutilsPlatformError,
)
from distutils.command.install import INSTALL_SCHEMES, SCHEME_KEYS
from distutils import log, dir_util
from distutils.command.build_scripts import first_line_re
from distutils.spawn import find_executable
import sys
import os
import zipimport
import shutil
import tempfile
import zipfile
import re
import stat
import random
import textwrap
import warnings
import site
import struct
import contextlib
import subprocess
import shlex
import io
import configparser


from sysconfig import get_config_vars, get_path

from setuptools import SetuptoolsDeprecationWarning

from setuptools import Command
from setuptools.sandbox import run_setup
from setuptools.command import setopt
from setuptools.archive_util import unpack_archive
from setuptools.package_index import (
    PackageIndex, parse_requirement_arg, URL_SCHEME,
)
from setuptools.command import bdist_egg, egg_info
from setuptools.wheel import Wheel
from pkg_resources import (
    yield_lines, normalize_path, resource_string, ensure_directory,
    get_distribution, find_distributions, Environment, Requirement,
    Distribution, PathMetadata, EggMetadata, WorkingSet, DistributionNotFound,
    VersionConflict, DEVELOP_DIST,
)
import pkg_resources

# Turn on PEP440Warnings
warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)

__all__ = [
    'samefile', 'easy_install', 'PthDistributions', 'extract_wininst_cfg',
    'get_exe_prefixes',
]


def is_64bit():
    return struct.calcsize("P") == 8


def samefile(p1, p2):
    """
    Determine if two paths reference the same file.

    Augments os.path.samefile to work on Windows and
    suppresses errors if the path doesn't exist.
    """
    both_exist = os.path.exists(p1) and os.path.exists(p2)
    use_samefile = hasattr(os.path, 'samefile') and both_exist
    if use_samefile:
        return os.path.samefile(p1, p2)
    norm_p1 = os.path.normpath(os.path.normcase(p1))
    norm_p2 = os.path.normpath(os.path.normcase(p2))
    return norm_p1 == norm_p2


def _to_bytes(s):
    return s.encode('utf8')


def isascii(s):
    try:
        s.encode('ascii')
        return True
    except UnicodeError:
        return False


def _one_liner(text):
    return textwrap.dedent(text).strip().replace('\n', '; ')


class easy_install(Command):
    """Manage a download/build/install process"""
    description = "Find/get/install Python packages"
    command_consumes_arguments = True

    user_options = [
        ('prefix=', None, "installation prefix"),
        ("zip-ok", "z", "install package as a zipfile"),
        ("multi-version", "m", "make apps have to require() a version"),
        ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
        ("install-dir=", "d", "install package to DIR"),
        ("script-dir=", "s", "install scripts to DIR"),
        ("exclude-scripts", "x", "Don't install scripts"),
        ("always-copy", "a", "Copy all needed packages to install dir"),
        ("index-url=", "i", "base URL of Python Package Index"),
        ("find-links=", "f", "additional URL(s) to search for packages"),
        ("build-directory=", "b",
         "download/extract/build in DIR; keep the results"),
        ('optimize=', 'O',
         "also compile with optimization: -O1 for \"python -O\", "
         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
        ('record=', None,
         "filename in which to record list of installed files"),
        ('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
        ('site-dirs=', 'S', "list of directories where .pth files work"),
        ('editable', 'e', "Install specified packages in editable form"),
        ('no-deps', 'N', "don't install dependencies"),
        ('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
        ('local-snapshots-ok', 'l',
         "allow building eggs from local checkouts"),
        ('version', None, "print version information and exit"),
        ('no-find-links', None,
         "Don't load find-links defined in packages being installed"),
        ('user', None, "install in user site-package '%s'" % site.USER_SITE)
    ]
    boolean_options = [
        'zip-ok', 'multi-version', 'exclude-scripts', 'upgrade', 'always-copy',
        'editable',
        'no-deps', 'local-snapshots-ok', 'version',
        'user'
    ]

    negative_opt = {'always-unzip': 'zip-ok'}
    create_index = PackageIndex

    def initialize_options(self):
        warnings.warn(
            "easy_install command is deprecated. "
            "Use build and pip and other standards-based tools.",
            EasyInstallDeprecationWarning,
        )

        # the --user option seems to be an opt-in one,
        # so the default should be False.
        self.user = 0
        self.zip_ok = self.local_snapshots_ok = None
        self.install_dir = self.script_dir = self.exclude_scripts = None
        self.index_url = None
        self.find_links = None
        self.build_directory = None
        self.args = None
        self.optimize = self.record = None
        self.upgrade = self.always_copy = self.multi_version = None
        self.editable = self.no_deps = self.allow_hosts = None
        self.root = self.prefix = self.no_report = None
        self.version = None
        self.install_purelib = None  # for pure module distributions
        self.install_platlib = None  # non-pure (dists w/ extensions)
        self.install_headers = None  # for C/C++ headers
        self.install_lib = None  # set to either purelib or platlib
        self.install_scripts = None
        self.install_data = None
        self.install_base = None
        self.install_platbase = None
        if site.ENABLE_USER_SITE:
            self.install_userbase = site.USER_BASE
            self.install_usersite = site.USER_SITE
        else:
            self.install_userbase = None
            self.install_usersite = None
        self.no_find_links = None

        # Options not specifiable via command line
        self.package_index = None
        self.pth_file = self.always_copy_from = None
        self.site_dirs = None
        self.installed_projects = {}
        # Always read easy_install options, even if we are subclassed, or have
        # an independent instance created.  This ensures that defaults will
        # always come from the standard configuration file(s)' "easy_install"
        # section, even if this is a "develop" or "install" command, or some
        # other embedding.
        self._dry_run = None
        self.verbose = self.distribution.verbose
        self.distribution._set_command_options(
            self, self.distribution.get_option_dict('easy_install')
        )

    def delete_blockers(self, blockers):
        extant_blockers = (
            filename for filename in blockers
            if os.path.exists(filename) or os.path.islink(filename)
        )
        list(map(self._delete_path, extant_blockers))

    def _delete_path(self, path):
        log.info("Deleting %s", path)
        if self.dry_run:
            return

        is_tree = os.path.isdir(path) and not os.path.islink(path)
        remover = rmtree if is_tree else os.unlink
        remover(path)

    @staticmethod
    def _render_version():
        """
        Render the Setuptools version and installation details, then exit.
        """
        ver = '{}.{}'.format(*sys.version_info)
        dist = get_distribution('setuptools')
        tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})'
        print(tmpl.format(**locals()))
        raise SystemExit()

    def finalize_options(self):  # noqa: C901  # is too complex (25)  # FIXME
        self.version and self._render_version()

        py_version = sys.version.split()[0]
        prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix')

        self.config_vars = {
            'dist_name': self.distribution.get_name(),
            'dist_version': self.distribution.get_version(),
            'dist_fullname': self.distribution.get_fullname(),
            'py_version': py_version,
            'py_version_short': py_version[0:3],
            'py_version_nodot': py_version[0] + py_version[2],
            'sys_prefix': prefix,
            'prefix': prefix,
            'sys_exec_prefix': exec_prefix,
            'exec_prefix': exec_prefix,
            # Only python 3.2+ has abiflags
            'abiflags': getattr(sys, 'abiflags', ''),
        }

        if site.ENABLE_USER_SITE:
            self.config_vars['userbase'] = self.install_userbase
            self.config_vars['usersite'] = self.install_usersite

        elif self.user:
            log.warn("WARNING: The user site-packages directory is disabled.")

        self._fix_install_dir_for_user_site()

        self.expand_basedirs()
        self.expand_dirs()

        self._expand(
            'install_dir', 'script_dir', 'build_directory',
            'site_dirs',
        )
        # If a non-default installation directory was specified, default the
        # script directory to match it.
        if self.script_dir is None:
            self.script_dir = self.install_dir

        if self.no_find_links is None:
            self.no_find_links = False

        # Let install_dir get set by install_lib command, which in turn
        # gets its info from the install command, and takes into account
        # --prefix and --home and all that other crud.
        self.set_undefined_options(
            'install_lib', ('install_dir', 'install_dir')
        )
        # Likewise, set default script_dir from 'install_scripts.install_dir'
        self.set_undefined_options(
            'install_scripts', ('install_dir', 'script_dir')
        )

        if self.user and self.install_purelib:
            self.install_dir = self.install_purelib
            self.script_dir = self.install_scripts
        # default --record from the install command
        self.set_undefined_options('install', ('record', 'record'))
        # Should this be moved to the if statement below? It's not used
        # elsewhere
        normpath = map(normalize_path, sys.path)
        self.all_site_dirs = get_site_dirs()
        if self.site_dirs is not None:
            site_dirs = [
                os.path.expanduser(s.strip()) for s in
                self.site_dirs.split(',')
            ]
            for d in site_dirs:
                if not os.path.isdir(d):
                    log.warn("%s (in --site-dirs) does not exist", d)
                elif normalize_path(d) not in normpath:
                    raise DistutilsOptionError(
                        d + " (in --site-dirs) is not on sys.path"
                    )
                else:
                    self.all_site_dirs.append(normalize_path(d))
        if not self.editable:
            self.check_site_dir()
        self.index_url = self.index_url or "https://pypi.org/simple/"
        self.shadow_path = self.all_site_dirs[:]
        for path_item in self.install_dir, normalize_path(self.script_dir):
            if path_item not in self.shadow_path:
                self.shadow_path.insert(0, path_item)

        if self.allow_hosts is not None:
            hosts = [s.strip() for s in self.allow_hosts.split(',')]
        else:
            hosts = ['*']
        if self.package_index is None:
            self.package_index = self.create_index(
                self.index_url, search_path=self.shadow_path, hosts=hosts,
            )
        self.local_index = Environment(self.shadow_path + sys.path)

        if self.find_links is not None:
            if isinstance(self.find_links, str):
                self.find_links = self.find_links.split()
        else:
            self.find_links = []
        if self.local_snapshots_ok:
            self.package_index.scan_egg_links(self.shadow_path + sys.path)
        if not self.no_find_links:
            self.package_index.add_find_links(self.find_links)
        self.set_undefined_options('install_lib', ('optimize', 'optimize'))
        if not isinstance(self.optimize, int):
            try:
                self.optimize = int(self.optimize)
                if not (0 <= self.optimize <= 2):
                    raise ValueError
            except ValueError as e:
                raise DistutilsOptionError(
                    "--optimize must be 0, 1, or 2"
                ) from e

        if self.editable and not self.build_directory:
            raise DistutilsArgError(
                "Must specify a build directory (-b) when using --editable"
            )
        if not self.args:
            raise DistutilsArgError(
                "No urls, filenames, or requirements specified (see --help)")

        self.outputs = []

    def _fix_install_dir_for_user_site(self):
        """
        Fix the install_dir if "--user" was used.
        """
        if not self.user or not site.ENABLE_USER_SITE:
            return

        self.create_home_path()
        if self.install_userbase is None:
            msg = "User base directory is not specified"
            raise DistutilsPlatformError(msg)
        self.install_base = self.install_platbase = self.install_userbase
        scheme_name = os.name.replace('posix', 'unix') + '_user'
        self.select_scheme(scheme_name)

    def _expand_attrs(self, attrs):
        for attr in attrs:
            val = getattr(self, attr)
            if val is not None:
                if os.name == 'posix' or os.name == 'nt':
                    val = os.path.expanduser(val)
                val = subst_vars(val, self.config_vars)
                setattr(self, attr, val)

    def expand_basedirs(self):
        """Calls `os.path.expanduser` on install_base, install_platbase and
        root."""
        self._expand_attrs(['install_base', 'install_platbase', 'root'])

    def expand_dirs(self):
        """Calls `os.path.expanduser` on install dirs."""
        dirs = [
            'install_purelib',
            'install_platlib',
            'install_lib',
            'install_headers',
            'install_scripts',
            'install_data',
        ]
        self._expand_attrs(dirs)

    def run(self, show_deprecation=True):
        if show_deprecation:
            self.announce(
                "WARNING: The easy_install command is deprecated "
                "and will be removed in a future version.",
                log.WARN,
            )
        if self.verbose != self.distribution.verbose:
            log.set_verbosity(self.verbose)
        try:
            for spec in self.args:
                self.easy_install(spec, not self.no_deps)
            if self.record:
                outputs = self.outputs
                if self.root:  # strip any package prefix
                    root_len = len(self.root)
                    for counter in range(len(outputs)):
                        outputs[counter] = outputs[counter][root_len:]
                from distutils import file_util

                self.execute(
                    file_util.write_file, (self.record, outputs),
                    "writing list of installed files to '%s'" %
                    self.record
                )
            self.warn_deprecated_options()
        finally:
            log.set_verbosity(self.distribution.verbose)

    def pseudo_tempname(self):
        """Return a pseudo-tempname base in the install directory.
        This code is intentionally naive; if a malicious party can write to
        the target directory you're already in deep doodoo.
        """
        try:
            pid = os.getpid()
        except Exception:
            pid = random.randint(0, sys.maxsize)
        return os.path.join(self.install_dir, "test-easy-install-%s" % pid)

    def warn_deprecated_options(self):
        pass

    def check_site_dir(self):  # noqa: C901  # is too complex (12)  # FIXME
        """Verify that self.install_dir is .pth-capable dir, if needed"""

        instdir = normalize_path(self.install_dir)
        pth_file = os.path.join(instdir, 'easy-install.pth')

        if not os.path.exists(instdir):
            try:
                os.makedirs(instdir)
            except (OSError, IOError):
                self.cant_write_to_target()

        # Is it a configured, PYTHONPATH, implicit, or explicit site dir?
        is_site_dir = instdir in self.all_site_dirs

        if not is_site_dir and not self.multi_version:
            # No?  Then directly test whether it does .pth file processing
            is_site_dir = self.check_pth_processing()
        else:
            # make sure we can write to target dir
            testfile = self.pseudo_tempname() + '.write-test'
            test_exists = os.path.exists(testfile)
            try:
                if test_exists:
                    os.unlink(testfile)
                open(testfile, 'w').close()
                os.unlink(testfile)
            except (OSError, IOError):
                self.cant_write_to_target()

        if not is_site_dir and not self.multi_version:
            # Can't install non-multi to non-site dir with easy_install
            pythonpath = os.environ.get('PYTHONPATH', '')
            log.warn(self.__no_default_msg, self.install_dir, pythonpath)

        if is_site_dir:
            if self.pth_file is None:
                self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
        else:
            self.pth_file = None

        if self.multi_version and not os.path.exists(pth_file):
            self.pth_file = None  # don't create a .pth file
        self.install_dir = instdir

    __cant_write_msg = textwrap.dedent("""
        can't create or remove files in install directory

        The following error occurred while trying to add or remove files in the
        installation directory:

            %s

        The installation directory you specified (via --install-dir, --prefix, or
        the distutils default setting) was:

            %s
        """).lstrip()  # noqa

    __not_exists_id = textwrap.dedent("""
        This directory does not currently exist.  Please create it and try again, or
        choose a different installation directory (using the -d or --install-dir
        option).
        """).lstrip()  # noqa

    __access_msg = textwrap.dedent("""
        Perhaps your account does not have write access to this directory?  If the
        installation directory is a system-owned directory, you may need to sign in
        as the administrator or "root" account.  If you do not have administrative
        access to this machine, you may wish to choose a different installation
        directory, preferably one that is listed in your PYTHONPATH environment
        variable.

        For information on other options, you may wish to consult the
        documentation at:

          https://setuptools.pypa.io/en/latest/deprecated/easy_install.html

        Please make the appropriate changes for your system and try again.
        """).lstrip()  # noqa

    def cant_write_to_target(self):
        msg = self.__cant_write_msg % (sys.exc_info()[1], self.install_dir,)

        if not os.path.exists(self.install_dir):
            msg += '\n' + self.__not_exists_id
        else:
            msg += '\n' + self.__access_msg
        raise DistutilsError(msg)

    def check_pth_processing(self):
        """Empirically verify whether .pth files are supported in inst. dir"""
        instdir = self.install_dir
        log.info("Checking .pth file support in %s", instdir)
        pth_file = self.pseudo_tempname() + ".pth"
        ok_file = pth_file + '.ok'
        ok_exists = os.path.exists(ok_file)
        tmpl = _one_liner("""
            import os
            f = open({ok_file!r}, 'w')
            f.write('OK')
            f.close()
            """) + '\n'
        try:
            if ok_exists:
                os.unlink(ok_file)
            dirname = os.path.dirname(ok_file)
            os.makedirs(dirname, exist_ok=True)
            f = open(pth_file, 'w')
        except (OSError, IOError):
            self.cant_write_to_target()
        else:
            try:
                f.write(tmpl.format(**locals()))
                f.close()
                f = None
                executable = sys.executable
                if os.name == 'nt':
                    dirname, basename = os.path.split(executable)
                    alt = os.path.join(dirname, 'pythonw.exe')
                    use_alt = (
                        basename.lower() == 'python.exe' and
                        os.path.exists(alt)
                    )
                    if use_alt:
                        # use pythonw.exe to avoid opening a console window
                        executable = alt

                from distutils.spawn import spawn

                spawn([executable, '-E', '-c', 'pass'], 0)

                if os.path.exists(ok_file):
                    log.info(
                        "TEST PASSED: %s appears to support .pth files",
                        instdir
                    )
                    return True
            finally:
                if f:
                    f.close()
                if os.path.exists(ok_file):
                    os.unlink(ok_file)
                if os.path.exists(pth_file):
                    os.unlink(pth_file)
        if not self.multi_version:
            log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
        return False

    def install_egg_scripts(self, dist):
        """Write all the scripts for `dist`, unless scripts are excluded"""
        if not self.exclude_scripts and dist.metadata_isdir('scripts'):
            for script_name in dist.metadata_listdir('scripts'):
                if dist.metadata_isdir('scripts/' + script_name):
                    # The "script" is a directory, likely a Python 3
                    # __pycache__ directory, so skip it.
                    continue
                self.install_script(
                    dist, script_name,
                    dist.get_metadata('scripts/' + script_name)
                )
        self.install_wrapper_scripts(dist)

    def add_output(self, path):
        if os.path.isdir(path):
            for base, dirs, files in os.walk(path):
                for filename in files:
                    self.outputs.append(os.path.join(base, filename))
        else:
            self.outputs.append(path)

    def not_editable(self, spec):
        if self.editable:
            raise DistutilsArgError(
                "Invalid argument %r: you can't use filenames or URLs "
                "with --editable (except via the --find-links option)."
                % (spec,)
            )

    def check_editable(self, spec):
        if not self.editable:
            return

        if os.path.exists(os.path.join(self.build_directory, spec.key)):
            raise DistutilsArgError(
                "%r already exists in %s; can't do a checkout there" %
                (spec.key, self.build_directory)
            )

    @contextlib.contextmanager
    def _tmpdir(self):
        tmpdir = tempfile.mkdtemp(prefix=u"easy_install-")
        try:
            # cast to str as workaround for #709 and #710 and #712
            yield str(tmpdir)
        finally:
            os.path.exists(tmpdir) and rmtree(tmpdir)

    def easy_install(self, spec, deps=False):
        with self._tmpdir() as tmpdir:
            if not isinstance(spec, Requirement):
                if URL_SCHEME(spec):
                    # It's a url, download it to tmpdir and process
                    self.not_editable(spec)
                    dl = self.package_index.download(spec, tmpdir)
                    return self.install_item(None, dl, tmpdir, deps, True)

                elif os.path.exists(spec):
                    # Existing file or directory, just process it directly
                    self.not_editable(spec)
                    return self.install_item(None, spec, tmpdir, deps, True)
                else:
                    spec = parse_requirement_arg(spec)

            self.check_editable(spec)
            dist = self.package_index.fetch_distribution(
                spec, tmpdir, self.upgrade, self.editable,
                not self.always_copy, self.local_index
            )
            if dist is None:
                msg = "Could not find suitable distribution for %r" % spec
                if self.always_copy:
                    msg += " (--always-copy skips system and development eggs)"
                raise DistutilsError(msg)
            elif dist.precedence == DEVELOP_DIST:
                # .egg-info dists don't need installing, just process deps
                self.process_distribution(spec, dist, deps, "Using")
                return dist
            else:
                return self.install_item(spec, dist.location, tmpdir, deps)

    def install_item(self, spec, download, tmpdir, deps, install_needed=False):

        # Installation is also needed if file in tmpdir or is not an egg
        install_needed = install_needed or self.always_copy
        install_needed = install_needed or os.path.dirname(download) == tmpdir
        install_needed = install_needed or not download.endswith('.egg')
        install_needed = install_needed or (
            self.always_copy_from is not None and
            os.path.dirname(normalize_path(download)) ==
            normalize_path(self.always_copy_from)
        )

        if spec and not install_needed:
            # at this point, we know it's a local .egg, we just don't know if
            # it's already installed.
            for dist in self.local_index[spec.project_name]:
                if dist.location == download:
                    break
            else:
                install_needed = True  # it's not in the local index

        log.info("Processing %s", os.path.basename(download))

        if install_needed:
            dists = self.install_eggs(spec, download, tmpdir)
            for dist in dists:
                self.process_distribution(spec, dist, deps)
        else:
            dists = [self.egg_distribution(download)]
            self.process_distribution(spec, dists[0], deps, "Using")

        if spec is not None:
            for dist in dists:
                if dist in spec:
                    return dist

    def select_scheme(self, name):
        """Sets the install directories by applying the install schemes."""
        # it's the caller's problem if they supply a bad name!
        scheme = INSTALL_SCHEMES[name]
        for key in SCHEME_KEYS:
            attrname = 'install_' + key
            if getattr(self, attrname) is None:
                setattr(self, attrname, scheme[key])

    # FIXME: 'easy_install.process_distribution' is too complex (12)
    def process_distribution(  # noqa: C901
            self, requirement, dist, deps=True, *info,
    ):
        self.update_pth(dist)
        self.package_index.add(dist)
        if dist in self.local_index[dist.key]:
            self.local_index.remove(dist)
        self.local_index.add(dist)
        self.install_egg_scripts(dist)
        self.installed_projects[dist.key] = dist
        log.info(self.installation_report(requirement, dist, *info))
        if (dist.has_metadata('dependency_links.txt') and
                not self.no_find_links):
            self.package_index.add_find_links(
                dist.get_metadata_lines('dependency_links.txt')
            )
        if not deps and not self.always_copy:
            return
        elif requirement is not None and dist.key != requirement.key:
            log.warn("Skipping dependencies for %s", dist)
            return  # XXX this is not the distribution we were looking for
        elif requirement is None or dist not in requirement:
            # if we wound up with a different version, resolve what we've got
            distreq = dist.as_requirement()
            requirement = Requirement(str(distreq))
        log.info("Processing dependencies for %s", requirement)
        try:
            distros = WorkingSet([]).resolve(
                [requirement], self.local_index, self.easy_install
            )
        except DistributionNotFound as e:
            raise DistutilsError(str(e)) from e
        except VersionConflict as e:
            raise DistutilsError(e.report()) from e
        if self.always_copy or self.always_copy_from:
            # Force all the relevant distros to be copied or activated
            for dist in distros:
                if dist.key not in self.installed_projects:
                    self.easy_install(dist.as_requirement())
        log.info("Finished processing dependencies for %s", requirement)

    def should_unzip(self, dist):
        if self.zip_ok is not None:
            return not self.zip_ok
        if dist.has_metadata('not-zip-safe'):
            return True
        if not dist.has_metadata('zip-safe'):
            return True
        return False

    def maybe_move(self, spec, dist_filename, setup_base):
        dst = os.path.join(self.build_directory, spec.key)
        if os.path.exists(dst):
            msg = (
                "%r already exists in %s; build directory %s will not be kept"
            )
            log.warn(msg, spec.key, self.build_directory, setup_base)
            return setup_base
        if os.path.isdir(dist_filename):
            setup_base = dist_filename
        else:
            if os.path.dirname(dist_filename) == setup_base:
                os.unlink(dist_filename)  # get it out of the tmp dir
            contents = os.listdir(setup_base)
            if len(contents) == 1:
                dist_filename = os.path.join(setup_base, contents[0])
                if os.path.isdir(dist_filename):
                    # if the only thing there is a directory, move it instead
                    setup_base = dist_filename
        ensure_directory(dst)
        shutil.move(setup_base, dst)
        return dst

    def install_wrapper_scripts(self, dist):
        if self.exclude_scripts:
            return
        for args in ScriptWriter.best().get_args(dist):
            self.write_script(*args)

    def install_script(self, dist, script_name, script_text, dev_path=None):
        """Generate a legacy script wrapper and install it"""
        spec = str(dist.as_requirement())
        is_script = is_python_script(script_text, script_name)

        if is_script:
            body = self._load_template(dev_path) % locals()
            script_text = ScriptWriter.get_header(script_text) + body
        self.write_script(script_name, _to_bytes(script_text), 'b')

    @staticmethod
    def _load_template(dev_path):
        """
        There are a couple of template scripts in the package. This
        function loads one of them and prepares it for use.
        """
        # See https://github.com/pypa/setuptools/issues/134 for info
        # on script file naming and downstream issues with SVR4
        name = 'script.tmpl'
        if dev_path:
            name = name.replace('.tmpl', ' (dev).tmpl')

        raw_bytes = resource_string('setuptools', name)
        return raw_bytes.decode('utf-8')

    def write_script(self, script_name, contents, mode="t", blockers=()):
        """Write an executable file to the scripts directory"""
        self.delete_blockers(  # clean up old .py/.pyw w/o a script
            [os.path.join(self.script_dir, x) for x in blockers]
        )
        log.info("Installing %s script to %s", script_name, self.script_dir)
        target = os.path.join(self.script_dir, script_name)
        self.add_output(target)

        if self.dry_run:
            return

        mask = current_umask()
        ensure_directory(target)
        if os.path.exists(target):
            os.unlink(target)
        with open(target, "w" + mode) as f:
            f.write(contents)
        chmod(target, 0o777 - mask)

    def install_eggs(self, spec, dist_filename, tmpdir):
        # .egg dirs or files are already built, so just return them
        installer_map = {
            '.egg': self.install_egg,
            '.exe': self.install_exe,
            '.whl': self.install_wheel,
        }
        try:
            install_dist = installer_map[
                dist_filename.lower()[-4:]
            ]
        except KeyError:
            pass
        else:
            return [install_dist(dist_filename, tmpdir)]

        # Anything else, try to extract and build
        setup_base = tmpdir
        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
            unpack_archive(dist_filename, tmpdir, self.unpack_progress)
        elif os.path.isdir(dist_filename):
            setup_base = os.path.abspath(dist_filename)

        if (setup_base.startswith(tmpdir)  # something we downloaded
                and self.build_directory and spec is not None):
            setup_base = self.maybe_move(spec, dist_filename, setup_base)

        # Find the setup.py file
        setup_script = os.path.join(setup_base, 'setup.py')

        if not os.path.exists(setup_script):
            setups = glob(os.path.join(setup_base, '*', 'setup.py'))
            if not setups:
                raise DistutilsError(
                    "Couldn't find a setup script in %s" %
                    os.path.abspath(dist_filename)
                )
            if len(setups) > 1:
                raise DistutilsError(
                    "Multiple setup scripts in %s" %
                    os.path.abspath(dist_filename)
                )
            setup_script = setups[0]

        # Now run it, and return the result
        if self.editable:
            log.info(self.report_editable(spec, setup_script))
            return []
        else:
            return self.build_and_install(setup_script, setup_base)

    def egg_distribution(self, egg_path):
        if os.path.isdir(egg_path):
            metadata = PathMetadata(egg_path, os.path.join(egg_path,
                                                           'EGG-INFO'))
        else:
            metadata = EggMetadata(zipimport.zipimporter(egg_path))
        return Distribution.from_filename(egg_path, metadata=metadata)

    # FIXME: 'easy_install.install_egg' is too complex (11)
    def install_egg(self, egg_path, tmpdir):  # noqa: C901
        destination = os.path.join(
            self.install_dir,
            os.path.basename(egg_path),
        )
        destination = os.path.abspath(destination)
        if not self.dry_run:
            ensure_directory(destination)

        dist = self.egg_distribution(egg_path)
        if not samefile(egg_path, destination):
            if os.path.isdir(destination) and not os.path.islink(destination):
                dir_util.remove_tree(destination, dry_run=self.dry_run)
            elif os.path.exists(destination):
                self.execute(
                    os.unlink,
                    (destination,),
                    "Removing " + destination,
                )
            try:
                new_dist_is_zipped = False
                if os.path.isdir(egg_path):
                    if egg_path.startswith(tmpdir):
                        f, m = shutil.move, "Moving"
                    else:
                        f, m = shutil.copytree, "Copying"
                elif self.should_unzip(dist):
                    self.mkpath(destination)
                    f, m = self.unpack_and_compile, "Extracting"
                else:
                    new_dist_is_zipped = True
                    if egg_path.startswith(tmpdir):
                        f, m = shutil.move, "Moving"
                    else:
                        f, m = shutil.copy2, "Copying"
                self.execute(
                    f,
                    (egg_path, destination),
                    (m + " %s to %s") % (
                        os.path.basename(egg_path),
                        os.path.dirname(destination)
                    ),
                )
                update_dist_caches(
                    destination,
                    fix_zipimporter_caches=new_dist_is_zipped,
                )
            except Exception:
                update_dist_caches(destination, fix_zipimporter_caches=False)
                raise

        self.add_output(destination)
        return self.egg_distribution(destination)

    def install_exe(self, dist_filename, tmpdir):
        # See if it's valid, get data
        cfg = extract_wininst_cfg(dist_filename)
        if cfg is None:
            raise DistutilsError(
                "%s is not a valid distutils Windows .exe" % dist_filename
            )
        # Create a dummy distribution object until we build the real distro
        dist = Distribution(
            None,
            project_name=cfg.get('metadata', 'name'),
            version=cfg.get('metadata', 'version'), platform=get_platform(),
        )

        # Convert the .exe to an unpacked egg
        egg_path = os.path.join(tmpdir, dist.egg_name() + '.egg')
        dist.location = egg_path
        egg_tmp = egg_path + '.tmp'
        _egg_info = os.path.join(egg_tmp, 'EGG-INFO')
        pkg_inf = os.path.join(_egg_info, 'PKG-INFO')
        ensure_directory(pkg_inf)  # make sure EGG-INFO dir exists
        dist._provider = PathMetadata(egg_tmp, _egg_info)  # XXX
        self.exe_to_egg(dist_filename, egg_tmp)

        # Write EGG-INFO/PKG-INFO
        if not os.path.exists(pkg_inf):
            f = open(pkg_inf, 'w')
            f.write('Metadata-Version: 1.0\n')
            for k, v in cfg.items('metadata'):
                if k != 'target_version':
                    f.write('%s: %s\n' % (k.replace('_', '-').title(), v))
            f.close()
        script_dir = os.path.join(_egg_info, 'scripts')
        # delete entry-point scripts to avoid duping
        self.delete_blockers([
            os.path.join(script_dir, args[0])
            for args in ScriptWriter.get_args(dist)
        ])
        # Build .egg file from tmpdir
        bdist_egg.make_zipfile(
            egg_path, egg_tmp, verbose=self.verbose, dry_run=self.dry_run,
        )
        # install the .egg
        return self.install_egg(egg_path, tmpdir)

    # FIXME: 'easy_install.exe_to_egg' is too complex (12)
    def exe_to_egg(self, dist_filename, egg_tmp):  # noqa: C901
        """Extract a bdist_wininst to the directories an egg would use"""
        # Check for .pth file and set up prefix translations
        prefixes = get_exe_prefixes(dist_filename)
        to_compile = []
        native_libs = []
        top_level = {}

        def process(src, dst):
            s = src.lower()
            for old, new in prefixes:
                if s.startswith(old):
                    src = new + src[len(old):]
                    parts = src.split('/')
                    dst = os.path.join(egg_tmp, *parts)
                    dl = dst.lower()
                    if dl.endswith('.pyd') or dl.endswith('.dll'):
                        parts[-1] = bdist_egg.strip_module(parts[-1])
                        top_level[os.path.splitext(parts[0])[0]] = 1
                        native_libs.append(src)
                    elif dl.endswith('.py') and old != 'SCRIPTS/':
                        top_level[os.path.splitext(parts[0])[0]] = 1
                        to_compile.append(dst)
                    return dst
            if not src.endswith('.pth'):
                log.warn("WARNING: can't process %s", src)
            return None

        # extract, tracking .pyd/.dll->native_libs and .py -> to_compile
        unpack_archive(dist_filename, egg_tmp, process)
        stubs = []
        for res in native_libs:
            if res.lower().endswith('.pyd'):  # create stubs for .pyd's
                parts = res.split('/')
                resource = parts[-1]
                parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py'
                pyfile = os.path.join(egg_tmp, *parts)
                to_compile.append(pyfile)
                stubs.append(pyfile)
                bdist_egg.write_stub(resource, pyfile)
        self.byte_compile(to_compile)  # compile .py's
        bdist_egg.write_safety_flag(
            os.path.join(egg_tmp, 'EGG-INFO'),
            bdist_egg.analyze_egg(egg_tmp, stubs))  # write zip-safety flag

        for name in 'top_level', 'native_libs':
            if locals()[name]:
                txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt')
                if not os.path.exists(txt):
                    f = open(txt, 'w')
                    f.write('\n'.join(locals()[name]) + '\n')
                    f.close()

    def install_wheel(self, wheel_path, tmpdir):
        wheel = Wheel(wheel_path)
        assert wheel.is_compatible()
        destination = os.path.join(self.install_dir, wheel.egg_name())
        destination = os.path.abspath(destination)
        if not self.dry_run:
            ensure_directory(destination)
        if os.path.isdir(destination) and not os.path.islink(destination):
            dir_util.remove_tree(destination, dry_run=self.dry_run)
        elif os.path.exists(destination):
            self.execute(
                os.unlink,
                (destination,),
                "Removing " + destination,
            )
        try:
            self.execute(
                wheel.install_as_egg,
                (destination,),
                ("Installing %s to %s") % (
                    os.path.basename(wheel_path),
                    os.path.dirname(destination)
                ),
            )
        finally:
            update_dist_caches(destination, fix_zipimporter_caches=False)
        self.add_output(destination)
        return self.egg_distribution(destination)

    __mv_warning = textwrap.dedent("""
        Because this distribution was installed --multi-version, before you can
        import modules from this package in an application, you will need to
        'import pkg_resources' and then use a 'require()' call similar to one of
        these examples, in order to select the desired version:

            pkg_resources.require("%(name)s")  # latest installed version
            pkg_resources.require("%(name)s==%(version)s")  # this exact version
            pkg_resources.require("%(name)s>=%(version)s")  # this version or higher
        """).lstrip()  # noqa

    __id_warning = textwrap.dedent("""
        Note also that the installation directory must be on sys.path at runtime for
        this to work.  (e.g. by being the application's script directory, by being on
        PYTHONPATH, or by being added to sys.path by your code.)
        """)  # noqa

    def installation_report(self, req, dist, what="Installed"):
        """Helpful installation message for display to package users"""
        msg = "\n%(what)s %(eggloc)s%(extras)s"
        if self.multi_version and not self.no_report:
            msg += '\n' + self.__mv_warning
            if self.install_dir not in map(normalize_path, sys.path):
                msg += '\n' + self.__id_warning

        eggloc = dist.location
        name = dist.project_name
        version = dist.version
        extras = ''  # TODO: self.report_extras(req, dist)
        return msg % locals()

    __editable_msg = textwrap.dedent("""
        Extracted editable version of %(spec)s to %(dirname)s

        If it uses setuptools in its setup script, you can activate it in
        "development" mode by going to that directory and running::

            %(python)s setup.py develop

        See the setuptools documentation for the "develop" command for more info.
        """).lstrip()  # noqa

    def report_editable(self, spec, setup_script):
        dirname = os.path.dirname(setup_script)
        python = sys.executable
        return '\n' + self.__editable_msg % locals()

    def run_setup(self, setup_script, setup_base, args):
        sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
        sys.modules.setdefault('distutils.command.egg_info', egg_info)

        args = list(args)
        if self.verbose > 2:
            v = 'v' * (self.verbose - 1)
            args.insert(0, '-' + v)
        elif self.verbose < 2:
            args.insert(0, '-q')
        if self.dry_run:
            args.insert(0, '-n')
        log.info(
            "Running %s %s", setup_script[len(setup_base) + 1:], ' '.join(args)
        )
        try:
            run_setup(setup_script, args)
        except SystemExit as v:
            raise DistutilsError(
                "Setup script exited with %s" % (v.args[0],)
            ) from v

    def build_and_install(self, setup_script, setup_base):
        args = ['bdist_egg', '--dist-dir']

        dist_dir = tempfile.mkdtemp(
            prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
        )
        try:
            self._set_fetcher_options(os.path.dirname(setup_script))
            args.append(dist_dir)

            self.run_setup(setup_script, setup_base, args)
            all_eggs = Environment([dist_dir])
            eggs = []
            for key in all_eggs:
                for dist in all_eggs[key]:
                    eggs.append(self.install_egg(dist.location, setup_base))
            if not eggs and not self.dry_run:
                log.warn("No eggs found in %s (setup script problem?)",
                         dist_dir)
            return eggs
        finally:
            rmtree(dist_dir)
            log.set_verbosity(self.verbose)  # restore our log verbosity

    def _set_fetcher_options(self, base):
        """
        When easy_install is about to run bdist_egg on a source dist, that
        source dist might have 'setup_requires' directives, requiring
        additional fetching. Ensure the fetcher options given to easy_install
        are available to that command as well.
        """
        # find the fetch options from easy_install and write them out
        # to the setup.cfg file.
        ei_opts = self.distribution.get_option_dict('easy_install').copy()
        fetch_directives = (
            'find_links', 'site_dirs', 'index_url', 'optimize', 'allow_hosts',
        )
        fetch_options = {}
        for key, val in ei_opts.items():
            if key not in fetch_directives:
                continue
            fetch_options[key] = val[1]
        # create a settings dictionary suitable for `edit_config`
        settings = dict(easy_install=fetch_options)
        cfg_filename = os.path.join(base, 'setup.cfg')
        setopt.edit_config(cfg_filename, settings)

    def update_pth(self, dist):  # noqa: C901  # is too complex (11)  # FIXME
        if self.pth_file is None:
            return

        for d in self.pth_file[dist.key]:  # drop old entries
            if not self.multi_version and d.location == dist.location:
                continue

            log.info("Removing %s from easy-install.pth file", d)
            self.pth_file.remove(d)
            if d.location in self.shadow_path:
                self.shadow_path.remove(d.location)

        if not self.multi_version:
            if dist.location in self.pth_file.paths:
                log.info(
                    "%s is already the active version in easy-install.pth",
                    dist,
                )
            else:
                log.info("Adding %s to easy-install.pth file", dist)
                self.pth_file.add(dist)  # add new entry
                if dist.location not in self.shadow_path:
                    self.shadow_path.append(dist.location)

        if self.dry_run:
            return

        self.pth_file.save()

        if dist.key != 'setuptools':
            return

        # Ensure that setuptools itself never becomes unavailable!
        # XXX should this check for latest version?
        filename = os.path.join(self.install_dir, 'setuptools.pth')
        if os.path.islink(filename):
            os.unlink(filename)
        with open(filename, 'wt') as f:
            f.write(self.pth_file.make_relative(dist.location) + '\n')

    def unpack_progress(self, src, dst):
        # Progress filter for unpacking
        log.debug("Unpacking %s to %s", src, dst)
        return dst  # only unpack-and-compile skips files for dry run

    def unpack_and_compile(self, egg_path, destination):
        to_compile = []
        to_chmod = []

        def pf(src, dst):
            if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
                to_compile.append(dst)
            elif dst.endswith('.dll') or dst.endswith('.so'):
                to_chmod.append(dst)
            self.unpack_progress(src, dst)
            return not self.dry_run and dst or None

        unpack_archive(egg_path, destination, pf)
        self.byte_compile(to_compile)
        if not self.dry_run:
            for f in to_chmod:
                mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755
                chmod(f, mode)

    def byte_compile(self, to_compile):
        if sys.dont_write_bytecode:
            return

        from distutils.util import byte_compile

        try:
            # try to make the byte compile messages quieter
            log.set_verbosity(self.verbose - 1)

            byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run)
            if self.optimize:
                byte_compile(
                    to_compile, optimize=self.optimize, force=1,
                    dry_run=self.dry_run,
                )
        finally:
            log.set_verbosity(self.verbose)  # restore original verbosity

    __no_default_msg = textwrap.dedent("""
        bad install directory or PYTHONPATH

        You are attempting to install a package to a directory that is not
        on PYTHONPATH and which Python does not read ".pth" files from.  The
        installation directory you specified (via --install-dir, --prefix, or
        the distutils default setting) was:

            %s

        and your PYTHONPATH environment variable currently contains:

            %r

        Here are some of your options for correcting the problem:

        * You can choose a different installation directory, i.e., one that is
          on PYTHONPATH or supports .pth files

        * You can add the installation directory to the PYTHONPATH environment
          variable.  (It must then also be on PYTHONPATH whenever you run
          Python and want to use the package(s) you are installing.)

        * You can set up the installation directory to support ".pth" files by
          using one of the approaches described here:

          https://setuptools.pypa.io/en/latest/deprecated/easy_install.html#custom-installation-locations


        Please make the appropriate changes for your system and try again.
        """).strip()

    def create_home_path(self):
        """Create directories under ~."""
        if not self.user:
            return
        home = convert_path(os.path.expanduser("~"))
        for name, path in self.config_vars.items():
            if path.startswith(home) and not os.path.isdir(path):
                self.debug_print("os.makedirs('%s', 0o700)" % path)
                os.makedirs(path, 0o700)

    INSTALL_SCHEMES = dict(
        posix=dict(
            install_dir='$base/lib/python$py_version_short/site-packages',
            script_dir='$base/bin',
        ),
    )

    DEFAULT_SCHEME = dict(
        install_dir='$base/Lib/site-packages',
        script_dir='$base/Scripts',
    )

    def _expand(self, *attrs):
        config_vars = self.get_finalized_command('install').config_vars

        if self.prefix:
            # Set default install_dir/scripts from --prefix
            config_vars = config_vars.copy()
            config_vars['base'] = self.prefix
            scheme = self.INSTALL_SCHEMES.get(os.name, self.DEFAULT_SCHEME)
            for attr, val in scheme.items():
                if getattr(self, attr, None) is None:
                    setattr(self, attr, val)

        from distutils.util import subst_vars

        for attr in attrs:
            val = getattr(self, attr)
            if val is not None:
                val = subst_vars(val, config_vars)
                if os.name == 'posix':
                    val = os.path.expanduser(val)
                setattr(self, attr, val)


def _pythonpath():
    items = os.environ.get('PYTHONPATH', '').split(os.pathsep)
    return filter(None, items)


def get_site_dirs():
    """
    Return a list of 'site' dirs
    """

    sitedirs = []

    # start with PYTHONPATH
    sitedirs.extend(_pythonpath())

    prefixes = [sys.prefix]
    if sys.exec_prefix != sys.prefix:
        prefixes.append(sys.exec_prefix)
    for prefix in prefixes:
        if not prefix:
            continue

        if sys.platform in ('os2emx', 'riscos'):
            sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
        elif os.sep == '/':
            sitedirs.extend([
                os.path.join(
                    prefix,
                    "lib",
                    "python{}.{}".format(*sys.version_info),
                    "site-packages",
                ),
                os.path.join(prefix, "lib", "site-python"),
            ])
        else:
            sitedirs.extend([
                prefix,
                os.path.join(prefix, "lib", "site-packages"),
            ])
        if sys.platform != 'darwin':
            continue

        # for framework builds *only* we add the standard Apple
        # locations. Currently only per-user, but /Library and
        # /Network/Library could be added too
        if 'Python.framework' not in prefix:
            continue

        home = os.environ.get('HOME')
        if not home:
            continue

        home_sp = os.path.join(
            home,
            'Library',
            'Python',
            '{}.{}'.format(*sys.version_info),
            'site-packages',
        )
        sitedirs.append(home_sp)
    lib_paths = get_path('purelib'), get_path('platlib')

    sitedirs.extend(s for s in lib_paths if s not in sitedirs)

    if site.ENABLE_USER_SITE:
        sitedirs.append(site.USER_SITE)

    with contextlib.suppress(AttributeError):
        sitedirs.extend(site.getsitepackages())

    sitedirs = list(map(normalize_path, sitedirs))

    return sitedirs


def expand_paths(inputs):  # noqa: C901  # is too complex (11)  # FIXME
    """Yield sys.path directories that might contain "old-style" packages"""

    seen = {}

    for dirname in inputs:
        dirname = normalize_path(dirname)
        if dirname in seen:
            continue

        seen[dirname] = 1
        if not os.path.isdir(dirname):
            continue

        files = os.listdir(dirname)
        yield dirname, files

        for name in files:
            if not name.endswith('.pth'):
                # We only care about the .pth files
                continue
            if name in ('easy-install.pth', 'setuptools.pth'):
                # Ignore .pth files that we control
                continue

            # Read the .pth file
            f = open(os.path.join(dirname, name))
            lines = list(yield_lines(f))
            f.close()

            # Yield existing non-dupe, non-import directory lines from it
            for line in lines:
                if line.startswith("import"):
                    continue

                line = normalize_path(line.rstrip())
                if line in seen:
                    continue

                seen[line] = 1
                if not os.path.isdir(line):
                    continue

                yield line, os.listdir(line)


def extract_wininst_cfg(dist_filename):
    """Extract configuration data from a bdist_wininst .exe

    Returns a configparser.RawConfigParser, or None
    """
    f = open(dist_filename, 'rb')
    try:
        endrec = zipfile._EndRecData(f)
        if endrec is None:
            return None

        prepended = (endrec[9] - endrec[5]) - endrec[6]
        if prepended < 12:  # no wininst data here
            return None
        f.seek(prepended - 12)

        tag, cfglen, bmlen = struct.unpack("egg path translations for a given .exe file"""

    prefixes = [
        ('PURELIB/', ''),
        ('PLATLIB/pywin32_system32', ''),
        ('PLATLIB/', ''),
        ('SCRIPTS/', 'EGG-INFO/scripts/'),
        ('DATA/lib/site-packages', ''),
    ]
    z = zipfile.ZipFile(exe_filename)
    try:
        for info in z.infolist():
            name = info.filename
            parts = name.split('/')
            if len(parts) == 3 and parts[2] == 'PKG-INFO':
                if parts[1].endswith('.egg-info'):
                    prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/'))
                    break
            if len(parts) != 2 or not name.endswith('.pth'):
                continue
            if name.endswith('-nspkg.pth'):
                continue
            if parts[0].upper() in ('PURELIB', 'PLATLIB'):
                contents = z.read(name).decode()
                for pth in yield_lines(contents):
                    pth = pth.strip().replace('\\', '/')
                    if not pth.startswith('import'):
                        prefixes.append((('%s/%s/' % (parts[0], pth)), ''))
    finally:
        z.close()
    prefixes = [(x.lower(), y) for x, y in prefixes]
    prefixes.sort()
    prefixes.reverse()
    return prefixes


class PthDistributions(Environment):
    """A .pth file with Distribution paths in it"""

    dirty = False

    def __init__(self, filename, sitedirs=()):
        self.filename = filename
        self.sitedirs = list(map(normalize_path, sitedirs))
        self.basedir = normalize_path(os.path.dirname(self.filename))
        self._load()
        Environment.__init__(self, [], None, None)
        for path in yield_lines(self.paths):
            list(map(self.add, find_distributions(path, True)))

    def _load(self):
        self.paths = []
        saw_import = False
        seen = dict.fromkeys(self.sitedirs)
        if os.path.isfile(self.filename):
            f = open(self.filename, 'rt')
            for line in f:
                if line.startswith('import'):
                    saw_import = True
                    continue
                path = line.rstrip()
                self.paths.append(path)
                if not path.strip() or path.strip().startswith('#'):
                    continue
                # skip non-existent paths, in case somebody deleted a package
                # manually, and duplicate paths as well
                path = self.paths[-1] = normalize_path(
                    os.path.join(self.basedir, path)
                )
                if not os.path.exists(path) or path in seen:
                    self.paths.pop()  # skip it
                    self.dirty = True  # we cleaned up, so we're dirty now :)
                    continue
                seen[path] = 1
            f.close()

        if self.paths and not saw_import:
            self.dirty = True  # ensure anything we touch has import wrappers
        while self.paths and not self.paths[-1].strip():
            self.paths.pop()

    def save(self):
        """Write changed .pth file back to disk"""
        if not self.dirty:
            return

        rel_paths = list(map(self.make_relative, self.paths))
        if rel_paths:
            log.debug("Saving %s", self.filename)
            lines = self._wrap_lines(rel_paths)
            data = '\n'.join(lines) + '\n'

            if os.path.islink(self.filename):
                os.unlink(self.filename)
            with open(self.filename, 'wt') as f:
                f.write(data)

        elif os.path.exists(self.filename):
            log.debug("Deleting empty %s", self.filename)
            os.unlink(self.filename)

        self.dirty = False

    @staticmethod
    def _wrap_lines(lines):
        return lines

    def add(self, dist):
        """Add `dist` to the distribution map"""
        new_path = (
            dist.location not in self.paths and (
                dist.location not in self.sitedirs or
                # account for '.' being in PYTHONPATH
                dist.location == os.getcwd()
            )
        )
        if new_path:
            self.paths.append(dist.location)
            self.dirty = True
        Environment.add(self, dist)

    def remove(self, dist):
        """Remove `dist` from the distribution map"""
        while dist.location in self.paths:
            self.paths.remove(dist.location)
            self.dirty = True
        Environment.remove(self, dist)

    def make_relative(self, path):
        npath, last = os.path.split(normalize_path(path))
        baselen = len(self.basedir)
        parts = [last]
        sep = os.altsep == '/' and '/' or os.sep
        while len(npath) >= baselen:
            if npath == self.basedir:
                parts.append(os.curdir)
                parts.reverse()
                return sep.join(parts)
            npath, last = os.path.split(npath)
            parts.append(last)
        else:
            return path


class RewritePthDistributions(PthDistributions):
    @classmethod
    def _wrap_lines(cls, lines):
        yield cls.prelude
        for line in lines:
            yield line
        yield cls.postlude

    prelude = _one_liner("""
        import sys
        sys.__plen = len(sys.path)
        """)
    postlude = _one_liner("""
        import sys
        new = sys.path[sys.__plen:]
        del sys.path[sys.__plen:]
        p = getattr(sys, '__egginsert', 0)
        sys.path[p:p] = new
        sys.__egginsert = p + len(new)
        """)


if os.environ.get('SETUPTOOLS_SYS_PATH_TECHNIQUE', 'raw') == 'rewrite':
    PthDistributions = RewritePthDistributions


def _first_line_re():
    """
    Return a regular expression based on first_line_re suitable for matching
    strings.
    """
    if isinstance(first_line_re.pattern, str):
        return first_line_re

    # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern.
    return re.compile(first_line_re.pattern.decode())


def auto_chmod(func, arg, exc):
    if func in [os.unlink, os.remove] and os.name == 'nt':
        chmod(arg, stat.S_IWRITE)
        return func(arg)
    et, ev, _ = sys.exc_info()
    # TODO: This code doesn't make sense. What is it trying to do?
    raise (ev[0], ev[1] + (" %s %s" % (func, arg)))


def update_dist_caches(dist_path, fix_zipimporter_caches):
    """
    Fix any globally cached `dist_path` related data

    `dist_path` should be a path of a newly installed egg distribution (zipped
    or unzipped).

    sys.path_importer_cache contains finder objects that have been cached when
    importing data from the original distribution. Any such finders need to be
    cleared since the replacement distribution might be packaged differently,
    e.g. a zipped egg distribution might get replaced with an unzipped egg
    folder or vice versa. Having the old finders cached may then cause Python
    to attempt loading modules from the replacement distribution using an
    incorrect loader.

    zipimport.zipimporter objects are Python loaders charged with importing
    data packaged inside zip archives. If stale loaders referencing the
    original distribution, are left behind, they can fail to load modules from
    the replacement distribution. E.g. if an old zipimport.zipimporter instance
    is used to load data from a new zipped egg archive, it may cause the
    operation to attempt to locate the requested data in the wrong location -
    one indicated by the original distribution's zip archive directory
    information. Such an operation may then fail outright, e.g. report having
    read a 'bad local file header', or even worse, it may fail silently &
    return invalid data.

    zipimport._zip_directory_cache contains cached zip archive directory
    information for all existing zipimport.zipimporter instances and all such
    instances connected to the same archive share the same cached directory
    information.

    If asked, and the underlying Python implementation allows it, we can fix
    all existing zipimport.zipimporter instances instead of having to track
    them down and remove them one by one, by updating their shared cached zip
    archive directory information. This, of course, assumes that the
    replacement distribution is packaged as a zipped egg.

    If not asked to fix existing zipimport.zipimporter instances, we still do
    our best to clear any remaining zipimport.zipimporter related cached data
    that might somehow later get used when attempting to load data from the new
    distribution and thus cause such load operations to fail. Note that when
    tracking down such remaining stale data, we can not catch every conceivable
    usage from here, and we clear only those that we know of and have found to
    cause problems if left alive. Any remaining caches should be updated by
    whomever is in charge of maintaining them, i.e. they should be ready to
    handle us replacing their zip archives with new distributions at runtime.

    """
    # There are several other known sources of stale zipimport.zipimporter
    # instances that we do not clear here, but might if ever given a reason to
    # do so:
    # * Global setuptools pkg_resources.working_set (a.k.a. 'master working
    # set') may contain distributions which may in turn contain their
    #   zipimport.zipimporter loaders.
    # * Several zipimport.zipimporter loaders held by local variables further
    #   up the function call stack when running the setuptools installation.
    # * Already loaded modules may have their __loader__ attribute set to the
    #   exact loader instance used when importing them. Python 3.4 docs state
    #   that this information is intended mostly for introspection and so is
    #   not expected to cause us problems.
    normalized_path = normalize_path(dist_path)
    _uncache(normalized_path, sys.path_importer_cache)
    if fix_zipimporter_caches:
        _replace_zip_directory_cache_data(normalized_path)
    else:
        # Here, even though we do not want to fix existing and now stale
        # zipimporter cache information, we still want to remove it. Related to
        # Python's zip archive directory information cache, we clear each of
        # its stale entries in two phases:
        #   1. Clear the entry so attempting to access zip archive information
        #      via any existing stale zipimport.zipimporter instances fails.
        #   2. Remove the entry from the cache so any newly constructed
        #      zipimport.zipimporter instances do not end up using old stale
        #      zip archive directory information.
        # This whole stale data removal step does not seem strictly necessary,
        # but has been left in because it was done before we started replacing
        # the zip archive directory information cache content if possible, and
        # there are no relevant unit tests that we can depend on to tell us if
        # this is really needed.
        _remove_and_clear_zip_directory_cache_data(normalized_path)


def _collect_zipimporter_cache_entries(normalized_path, cache):
    """
    Return zipimporter cache entry keys related to a given normalized path.

    Alternative path spellings (e.g. those using different character case or
    those using alternative path separators) related to the same path are
    included. Any sub-path entries are included as well, i.e. those
    corresponding to zip archives embedded in other zip archives.

    """
    result = []
    prefix_len = len(normalized_path)
    for p in cache:
        np = normalize_path(p)
        if (np.startswith(normalized_path) and
                np[prefix_len:prefix_len + 1] in (os.sep, '')):
            result.append(p)
    return result


def _update_zipimporter_cache(normalized_path, cache, updater=None):
    """
    Update zipimporter cache data for a given normalized path.

    Any sub-path entries are processed as well, i.e. those corresponding to zip
    archives embedded in other zip archives.

    Given updater is a callable taking a cache entry key and the original entry
    (after already removing the entry from the cache), and expected to update
    the entry and possibly return a new one to be inserted in its place.
    Returning None indicates that the entry should not be replaced with a new
    one. If no updater is given, the cache entries are simply removed without
    any additional processing, the same as if the updater simply returned None.

    """
    for p in _collect_zipimporter_cache_entries(normalized_path, cache):
        # N.B. pypy's custom zipimport._zip_directory_cache implementation does
        # not support the complete dict interface:
        # * Does not support item assignment, thus not allowing this function
        #    to be used only for removing existing cache entries.
        #  * Does not support the dict.pop() method, forcing us to use the
        #    get/del patterns instead. For more detailed information see the
        #    following links:
        #      https://github.com/pypa/setuptools/issues/202#issuecomment-202913420
        #      http://bit.ly/2h9itJX
        old_entry = cache[p]
        del cache[p]
        new_entry = updater and updater(p, old_entry)
        if new_entry is not None:
            cache[p] = new_entry


def _uncache(normalized_path, cache):
    _update_zipimporter_cache(normalized_path, cache)


def _remove_and_clear_zip_directory_cache_data(normalized_path):
    def clear_and_remove_cached_zip_archive_directory_data(path, old_entry):
        old_entry.clear()

    _update_zipimporter_cache(
        normalized_path, zipimport._zip_directory_cache,
        updater=clear_and_remove_cached_zip_archive_directory_data)


# PyPy Python implementation does not allow directly writing to the
# zipimport._zip_directory_cache and so prevents us from attempting to correct
# its content. The best we can do there is clear the problematic cache content
# and have PyPy repopulate it as needed. The downside is that if there are any
# stale zipimport.zipimporter instances laying around, attempting to use them
# will fail due to not having its zip archive directory information available
# instead of being automatically corrected to use the new correct zip archive
# directory information.
if '__pypy__' in sys.builtin_module_names:
    _replace_zip_directory_cache_data = \
        _remove_and_clear_zip_directory_cache_data
else:

    def _replace_zip_directory_cache_data(normalized_path):
        def replace_cached_zip_archive_directory_data(path, old_entry):
            # N.B. In theory, we could load the zip directory information just
            # once for all updated path spellings, and then copy it locally and
            # update its contained path strings to contain the correct
            # spelling, but that seems like a way too invasive move (this cache
            # structure is not officially documented anywhere and could in
            # theory change with new Python releases) for no significant
            # benefit.
            old_entry.clear()
            zipimport.zipimporter(path)
            old_entry.update(zipimport._zip_directory_cache[path])
            return old_entry

        _update_zipimporter_cache(
            normalized_path, zipimport._zip_directory_cache,
            updater=replace_cached_zip_archive_directory_data)


def is_python(text, filename=''):
    "Is this string a valid Python script?"
    try:
        compile(text, filename, 'exec')
    except (SyntaxError, TypeError):
        return False
    else:
        return True


def is_sh(executable):
    """Determine if the specified executable is a .sh (contains a #! line)"""
    try:
        with io.open(executable, encoding='latin-1') as fp:
            magic = fp.read(2)
    except (OSError, IOError):
        return executable
    return magic == '#!'


def nt_quote_arg(arg):
    """Quote a command line argument according to Windows parsing rules"""
    return subprocess.list2cmdline([arg])


def is_python_script(script_text, filename):
    """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc.
    """
    if filename.endswith('.py') or filename.endswith('.pyw'):
        return True  # extension says it's Python
    if is_python(script_text, filename):
        return True  # it's syntactically valid Python
    if script_text.startswith('#!'):
        # It begins with a '#!' line, so check if 'python' is in it somewhere
        return 'python' in script_text.splitlines()[0].lower()

    return False  # Not any Python I can recognize


try:
    from os import chmod as _chmod
except ImportError:
    # Jython compatibility
    def _chmod(*args):
        pass


def chmod(path, mode):
    log.debug("changing mode of %s to %o", path, mode)
    try:
        _chmod(path, mode)
    except os.error as e:
        log.debug("chmod failed: %s", e)


class CommandSpec(list):
    """
    A command spec for a #! header, specified as a list of arguments akin to
    those passed to Popen.
    """

    options = []
    split_args = dict()

    @classmethod
    def best(cls):
        """
        Choose the best CommandSpec class based on environmental conditions.
        """
        return cls

    @classmethod
    def _sys_executable(cls):
        _default = os.path.normpath(sys.executable)
        return os.environ.get('__PYVENV_LAUNCHER__', _default)

    @classmethod
    def from_param(cls, param):
        """
        Construct a CommandSpec from a parameter to build_scripts, which may
        be None.
        """
        if isinstance(param, cls):
            return param
        if isinstance(param, list):
            return cls(param)
        if param is None:
            return cls.from_environment()
        # otherwise, assume it's a string.
        return cls.from_string(param)

    @classmethod
    def from_environment(cls):
        return cls([cls._sys_executable()])

    @classmethod
    def from_string(cls, string):
        """
        Construct a command spec from a simple string representing a command
        line parseable by shlex.split.
        """
        items = shlex.split(string, **cls.split_args)
        return cls(items)

    def install_options(self, script_text):
        self.options = shlex.split(self._extract_options(script_text))
        cmdline = subprocess.list2cmdline(self)
        if not isascii(cmdline):
            self.options[:0] = ['-x']

    @staticmethod
    def _extract_options(orig_script):
        """
        Extract any options from the first line of the script.
        """
        first = (orig_script + '\n').splitlines()[0]
        match = _first_line_re().match(first)
        options = match.group(1) or '' if match else ''
        return options.strip()

    def as_header(self):
        return self._render(self + list(self.options))

    @staticmethod
    def _strip_quotes(item):
        _QUOTES = '"\''
        for q in _QUOTES:
            if item.startswith(q) and item.endswith(q):
                return item[1:-1]
        return item

    @staticmethod
    def _render(items):
        cmdline = subprocess.list2cmdline(
            CommandSpec._strip_quotes(item.strip()) for item in items)
        return '#!' + cmdline + '\n'


# For pbr compat; will be removed in a future version.
sys_executable = CommandSpec._sys_executable()


class WindowsCommandSpec(CommandSpec):
    split_args = dict(posix=False)


class ScriptWriter:
    """
    Encapsulates behavior around writing entry point scripts for console and
    gui apps.
    """

    template = textwrap.dedent(r"""
        # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r
        import re
        import sys

        # for compatibility with easy_install; see #2198
        __requires__ = %(spec)r

        try:
            from importlib.metadata import distribution
        except ImportError:
            try:
                from importlib_metadata import distribution
            except ImportError:
                from pkg_resources import load_entry_point


        def importlib_load_entry_point(spec, group, name):
            dist_name, _, _ = spec.partition('==')
            matches = (
                entry_point
                for entry_point in distribution(dist_name).entry_points
                if entry_point.group == group and entry_point.name == name
            )
            return next(matches).load()


        globals().setdefault('load_entry_point', importlib_load_entry_point)


        if __name__ == '__main__':
            sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
            sys.exit(load_entry_point(%(spec)r, %(group)r, %(name)r)())
        """).lstrip()

    command_spec_class = CommandSpec

    @classmethod
    def get_script_args(cls, dist, executable=None, wininst=False):
        # for backward compatibility
        warnings.warn("Use get_args", EasyInstallDeprecationWarning)
        writer = (WindowsScriptWriter if wininst else ScriptWriter).best()
        header = cls.get_script_header("", executable, wininst)
        return writer.get_args(dist, header)

    @classmethod
    def get_script_header(cls, script_text, executable=None, wininst=False):
        # for backward compatibility
        warnings.warn(
            "Use get_header", EasyInstallDeprecationWarning, stacklevel=2)
        if wininst:
            executable = "python.exe"
        return cls.get_header(script_text, executable)

    @classmethod
    def get_args(cls, dist, header=None):
        """
        Yield write_script() argument tuples for a distribution's
        console_scripts and gui_scripts entry points.
        """
        if header is None:
            header = cls.get_header()
        spec = str(dist.as_requirement())
        for type_ in 'console', 'gui':
            group = type_ + '_scripts'
            for name, ep in dist.get_entry_map(group).items():
                cls._ensure_safe_name(name)
                script_text = cls.template % locals()
                args = cls._get_script_args(type_, name, header, script_text)
                for res in args:
                    yield res

    @staticmethod
    def _ensure_safe_name(name):
        """
        Prevent paths in *_scripts entry point names.
        """
        has_path_sep = re.search(r'[\\/]', name)
        if has_path_sep:
            raise ValueError("Path separators not allowed in script names")

    @classmethod
    def get_writer(cls, force_windows):
        # for backward compatibility
        warnings.warn("Use best", EasyInstallDeprecationWarning)
        return WindowsScriptWriter.best() if force_windows else cls.best()

    @classmethod
    def best(cls):
        """
        Select the best ScriptWriter for this environment.
        """
        if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'):
            return WindowsScriptWriter.best()
        else:
            return cls

    @classmethod
    def _get_script_args(cls, type_, name, header, script_text):
        # Simply write the stub with no extension.
        yield (name, header + script_text)

    @classmethod
    def get_header(cls, script_text="", executable=None):
        """Create a #! line, getting options (if any) from script_text"""
        cmd = cls.command_spec_class.best().from_param(executable)
        cmd.install_options(script_text)
        return cmd.as_header()


class WindowsScriptWriter(ScriptWriter):
    command_spec_class = WindowsCommandSpec

    @classmethod
    def get_writer(cls):
        # for backward compatibility
        warnings.warn("Use best", EasyInstallDeprecationWarning)
        return cls.best()

    @classmethod
    def best(cls):
        """
        Select the best ScriptWriter suitable for Windows
        """
        writer_lookup = dict(
            executable=WindowsExecutableLauncherWriter,
            natural=cls,
        )
        # for compatibility, use the executable launcher by default
        launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable')
        return writer_lookup[launcher]

    @classmethod
    def _get_script_args(cls, type_, name, header, script_text):
        "For Windows, add a .py extension"
        ext = dict(console='.pya', gui='.pyw')[type_]
        if ext not in os.environ['PATHEXT'].lower().split(';'):
            msg = (
                "{ext} not listed in PATHEXT; scripts will not be "
                "recognized as executables."
            ).format(**locals())
            warnings.warn(msg, UserWarning)
        old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe']
        old.remove(ext)
        header = cls._adjust_header(type_, header)
        blockers = [name + x for x in old]
        yield name + ext, header + script_text, 't', blockers

    @classmethod
    def _adjust_header(cls, type_, orig_header):
        """
        Make sure 'pythonw' is used for gui and 'python' is used for
        console (regardless of what sys.executable is).
        """
        pattern = 'pythonw.exe'
        repl = 'python.exe'
        if type_ == 'gui':
            pattern, repl = repl, pattern
        pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
        new_header = pattern_ob.sub(string=orig_header, repl=repl)
        return new_header if cls._use_header(new_header) else orig_header

    @staticmethod
    def _use_header(new_header):
        """
        Should _adjust_header use the replaced header?

        On non-windows systems, always use. On
        Windows systems, only use the replaced header if it resolves
        to an executable on the system.
        """
        clean_header = new_header[2:-1].strip('"')
        return sys.platform != 'win32' or find_executable(clean_header)


class WindowsExecutableLauncherWriter(WindowsScriptWriter):
    @classmethod
    def _get_script_args(cls, type_, name, header, script_text):
        """
        For Windows, add a .py extension and an .exe launcher
        """
        if type_ == 'gui':
            launcher_type = 'gui'
            ext = '-script.pyw'
            old = ['.pyw']
        else:
            launcher_type = 'cli'
            ext = '-script.py'
            old = ['.py', '.pyc', '.pyo']
        hdr = cls._adjust_header(type_, header)
        blockers = [name + x for x in old]
        yield (name + ext, hdr + script_text, 't', blockers)
        yield (
            name + '.exe', get_win_launcher(launcher_type),
            'b'  # write in binary mode
        )
        if not is_64bit():
            # install a manifest for the launcher to prevent Windows
            # from detecting it as an installer (which it will for
            #  launchers like easy_install.exe). Consider only
            #  adding a manifest for launchers detected as installers.
            #  See Distribute #143 for details.
            m_name = name + '.exe.manifest'
            yield (m_name, load_launcher_manifest(name), 't')


# for backward-compatibility
get_script_args = ScriptWriter.get_script_args
get_script_header = ScriptWriter.get_script_header


def get_win_launcher(type):
    """
    Load the Windows launcher (executable) suitable for launching a script.

    `type` should be either 'cli' or 'gui'

    Returns the executable as a byte string.
    """
    launcher_fn = '%s.exe' % type
    if is_64bit():
        if get_platform() == "win-arm64":
            launcher_fn = launcher_fn.replace(".", "-arm64.")
        else:
            launcher_fn = launcher_fn.replace(".", "-64.")
    else:
        launcher_fn = launcher_fn.replace(".", "-32.")
    return resource_string('setuptools', launcher_fn)


def load_launcher_manifest(name):
    manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml')
    return manifest.decode('utf-8') % vars()


def rmtree(path, ignore_errors=False, onerror=auto_chmod):
    return shutil.rmtree(path, ignore_errors, onerror)


def current_umask():
    tmp = os.umask(0o022)
    os.umask(tmp)
    return tmp


class EasyInstallDeprecationWarning(SetuptoolsDeprecationWarning):
    """
    Warning for EasyInstall deprecations, bypassing suppression.
    """
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/egg_info.py0000644000175100001710000006301600000000000021370 0ustar00runnerdocker"""setuptools.command.egg_info

Create a distribution's .egg-info directory and contents"""

from distutils.filelist import FileList as _FileList
from distutils.errors import DistutilsInternalError
from distutils.util import convert_path
from distutils import log
import distutils.errors
import distutils.filelist
import functools
import os
import re
import sys
import io
import warnings
import time
import collections

from setuptools import Command
from setuptools.command.sdist import sdist
from setuptools.command.sdist import walk_revctrl
from setuptools.command.setopt import edit_config
from setuptools.command import bdist_egg
from pkg_resources import (
    parse_requirements, safe_name, parse_version,
    safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename)
import setuptools.unicode_utils as unicode_utils
from setuptools.glob import glob

from setuptools.extern import packaging
from setuptools import SetuptoolsDeprecationWarning


def translate_pattern(glob):  # noqa: C901  # is too complex (14)  # FIXME
    """
    Translate a file path glob like '*.txt' in to a regular expression.
    This differs from fnmatch.translate which allows wildcards to match
    directory separators. It also knows about '**/' which matches any number of
    directories.
    """
    pat = ''

    # This will split on '/' within [character classes]. This is deliberate.
    chunks = glob.split(os.path.sep)

    sep = re.escape(os.sep)
    valid_char = '[^%s]' % (sep,)

    for c, chunk in enumerate(chunks):
        last_chunk = c == len(chunks) - 1

        # Chunks that are a literal ** are globstars. They match anything.
        if chunk == '**':
            if last_chunk:
                # Match anything if this is the last component
                pat += '.*'
            else:
                # Match '(name/)*'
                pat += '(?:%s+%s)*' % (valid_char, sep)
            continue  # Break here as the whole path component has been handled

        # Find any special characters in the remainder
        i = 0
        chunk_len = len(chunk)
        while i < chunk_len:
            char = chunk[i]
            if char == '*':
                # Match any number of name characters
                pat += valid_char + '*'
            elif char == '?':
                # Match a name character
                pat += valid_char
            elif char == '[':
                # Character class
                inner_i = i + 1
                # Skip initial !/] chars
                if inner_i < chunk_len and chunk[inner_i] == '!':
                    inner_i = inner_i + 1
                if inner_i < chunk_len and chunk[inner_i] == ']':
                    inner_i = inner_i + 1

                # Loop till the closing ] is found
                while inner_i < chunk_len and chunk[inner_i] != ']':
                    inner_i = inner_i + 1

                if inner_i >= chunk_len:
                    # Got to the end of the string without finding a closing ]
                    # Do not treat this as a matching group, but as a literal [
                    pat += re.escape(char)
                else:
                    # Grab the insides of the [brackets]
                    inner = chunk[i + 1:inner_i]
                    char_class = ''

                    # Class negation
                    if inner[0] == '!':
                        char_class = '^'
                        inner = inner[1:]

                    char_class += re.escape(inner)
                    pat += '[%s]' % (char_class,)

                    # Skip to the end ]
                    i = inner_i
            else:
                pat += re.escape(char)
            i += 1

        # Join each chunk with the dir separator
        if not last_chunk:
            pat += sep

    pat += r'\Z'
    return re.compile(pat, flags=re.MULTILINE | re.DOTALL)


class InfoCommon:
    tag_build = None
    tag_date = None

    @property
    def name(self):
        return safe_name(self.distribution.get_name())

    def tagged_version(self):
        return safe_version(self._maybe_tag(self.distribution.get_version()))

    def _maybe_tag(self, version):
        """
        egg_info may be called more than once for a distribution,
        in which case the version string already contains all tags.
        """
        return (
            version if self.vtags and version.endswith(self.vtags)
            else version + self.vtags
        )

    def tags(self):
        version = ''
        if self.tag_build:
            version += self.tag_build
        if self.tag_date:
            version += time.strftime("-%Y%m%d")
        return version
    vtags = property(tags)


class egg_info(InfoCommon, Command):
    description = "create a distribution's .egg-info directory"

    user_options = [
        ('egg-base=', 'e', "directory containing .egg-info directories"
                           " (default: top of the source tree)"),
        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
        ('no-date', 'D', "Don't include date stamp [default]"),
    ]

    boolean_options = ['tag-date']
    negative_opt = {
        'no-date': 'tag-date',
    }

    def initialize_options(self):
        self.egg_base = None
        self.egg_name = None
        self.egg_info = None
        self.egg_version = None
        self.broken_egg_info = False

    ####################################
    # allow the 'tag_svn_revision' to be detected and
    # set, supporting sdists built on older Setuptools.
    @property
    def tag_svn_revision(self):
        pass

    @tag_svn_revision.setter
    def tag_svn_revision(self, value):
        pass
    ####################################

    def save_version_info(self, filename):
        """
        Materialize the value of date into the
        build tag. Install build keys in a deterministic order
        to avoid arbitrary reordering on subsequent builds.
        """
        egg_info = collections.OrderedDict()
        # follow the order these keys would have been added
        # when PYTHONHASHSEED=0
        egg_info['tag_build'] = self.tags()
        egg_info['tag_date'] = 0
        edit_config(filename, dict(egg_info=egg_info))

    def finalize_options(self):
        # Note: we need to capture the current value returned
        # by `self.tagged_version()`, so we can later update
        # `self.distribution.metadata.version` without
        # repercussions.
        self.egg_name = self.name
        self.egg_version = self.tagged_version()
        parsed_version = parse_version(self.egg_version)

        try:
            is_version = isinstance(parsed_version, packaging.version.Version)
            spec = (
                "%s==%s" if is_version else "%s===%s"
            )
            list(
                parse_requirements(spec % (self.egg_name, self.egg_version))
            )
        except ValueError as e:
            raise distutils.errors.DistutilsOptionError(
                "Invalid distribution name or version syntax: %s-%s" %
                (self.egg_name, self.egg_version)
            ) from e

        if self.egg_base is None:
            dirs = self.distribution.package_dir
            self.egg_base = (dirs or {}).get('', os.curdir)

        self.ensure_dirname('egg_base')
        self.egg_info = to_filename(self.egg_name) + '.egg-info'
        if self.egg_base != os.curdir:
            self.egg_info = os.path.join(self.egg_base, self.egg_info)
        if '-' in self.egg_name:
            self.check_broken_egg_info()

        # Set package version for the benefit of dumber commands
        # (e.g. sdist, bdist_wininst, etc.)
        #
        self.distribution.metadata.version = self.egg_version

        # If we bootstrapped around the lack of a PKG-INFO, as might be the
        # case in a fresh checkout, make sure that any special tags get added
        # to the version info
        #
        pd = self.distribution._patched_dist
        if pd is not None and pd.key == self.egg_name.lower():
            pd._version = self.egg_version
            pd._parsed_version = parse_version(self.egg_version)
            self.distribution._patched_dist = None

    def write_or_delete_file(self, what, filename, data, force=False):
        """Write `data` to `filename` or delete if empty

        If `data` is non-empty, this routine is the same as ``write_file()``.
        If `data` is empty but not ``None``, this is the same as calling
        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op
        unless `filename` exists, in which case a warning is issued about the
        orphaned file (if `force` is false), or deleted (if `force` is true).
        """
        if data:
            self.write_file(what, filename, data)
        elif os.path.exists(filename):
            if data is None and not force:
                log.warn(
                    "%s not set in setup(), but %s exists", what, filename
                )
                return
            else:
                self.delete_file(filename)

    def write_file(self, what, filename, data):
        """Write `data` to `filename` (if not a dry run) after announcing it

        `what` is used in a log message to identify what is being written
        to the file.
        """
        log.info("writing %s to %s", what, filename)
        data = data.encode("utf-8")
        if not self.dry_run:
            f = open(filename, 'wb')
            f.write(data)
            f.close()

    def delete_file(self, filename):
        """Delete `filename` (if not a dry run) after announcing it"""
        log.info("deleting %s", filename)
        if not self.dry_run:
            os.unlink(filename)

    def run(self):
        self.mkpath(self.egg_info)
        os.utime(self.egg_info, None)
        installer = self.distribution.fetch_build_egg
        for ep in iter_entry_points('egg_info.writers'):
            ep.require(installer=installer)
            writer = ep.resolve()
            writer(self, ep.name, os.path.join(self.egg_info, ep.name))

        # Get rid of native_libs.txt if it was put there by older bdist_egg
        nl = os.path.join(self.egg_info, "native_libs.txt")
        if os.path.exists(nl):
            self.delete_file(nl)

        self.find_sources()

    def find_sources(self):
        """Generate SOURCES.txt manifest file"""
        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
        mm = manifest_maker(self.distribution)
        mm.manifest = manifest_filename
        mm.run()
        self.filelist = mm.filelist

    def check_broken_egg_info(self):
        bei = self.egg_name + '.egg-info'
        if self.egg_base != os.curdir:
            bei = os.path.join(self.egg_base, bei)
        if os.path.exists(bei):
            log.warn(
                "-" * 78 + '\n'
                "Note: Your current .egg-info directory has a '-' in its name;"
                '\nthis will not work correctly with "setup.py develop".\n\n'
                'Please rename %s to %s to correct this problem.\n' + '-' * 78,
                bei, self.egg_info
            )
            self.broken_egg_info = self.egg_info
            self.egg_info = bei  # make it work for now


class FileList(_FileList):
    # Implementations of the various MANIFEST.in commands

    def process_template_line(self, line):
        # Parse the line: split it up, make sure the right number of words
        # is there, and return the relevant words.  'action' is always
        # defined: it's the first word of the line.  Which of the other
        # three are defined depends on the action; it'll be either
        # patterns, (dir and patterns), or (dir_pattern).
        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)

        action_map = {
            'include': self.include,
            'exclude': self.exclude,
            'global-include': self.global_include,
            'global-exclude': self.global_exclude,
            'recursive-include': functools.partial(
                self.recursive_include, dir,
            ),
            'recursive-exclude': functools.partial(
                self.recursive_exclude, dir,
            ),
            'graft': self.graft,
            'prune': self.prune,
        }
        log_map = {
            'include': "warning: no files found matching '%s'",
            'exclude': (
                "warning: no previously-included files found "
                "matching '%s'"
            ),
            'global-include': (
                "warning: no files found matching '%s' "
                "anywhere in distribution"
            ),
            'global-exclude': (
                "warning: no previously-included files matching "
                "'%s' found anywhere in distribution"
            ),
            'recursive-include': (
                "warning: no files found matching '%s' "
                "under directory '%s'"
            ),
            'recursive-exclude': (
                "warning: no previously-included files matching "
                "'%s' found under directory '%s'"
            ),
            'graft': "warning: no directories found matching '%s'",
            'prune': "no previously-included directories found matching '%s'",
        }

        try:
            process_action = action_map[action]
        except KeyError:
            raise DistutilsInternalError(
                "this cannot happen: invalid action '{action!s}'".
                format(action=action),
            )

        # OK, now we know that the action is valid and we have the
        # right number of words on the line for that action -- so we
        # can proceed with minimal error-checking.

        action_is_recursive = action.startswith('recursive-')
        if action in {'graft', 'prune'}:
            patterns = [dir_pattern]
        extra_log_args = (dir, ) if action_is_recursive else ()
        log_tmpl = log_map[action]

        self.debug_print(
            ' '.join(
                [action] +
                ([dir] if action_is_recursive else []) +
                patterns,
            )
        )
        for pattern in patterns:
            if not process_action(pattern):
                log.warn(log_tmpl, pattern, *extra_log_args)

    def _remove_files(self, predicate):
        """
        Remove all files from the file list that match the predicate.
        Return True if any matching files were removed
        """
        found = False
        for i in range(len(self.files) - 1, -1, -1):
            if predicate(self.files[i]):
                self.debug_print(" removing " + self.files[i])
                del self.files[i]
                found = True
        return found

    def include(self, pattern):
        """Include files that match 'pattern'."""
        found = [f for f in glob(pattern) if not os.path.isdir(f)]
        self.extend(found)
        return bool(found)

    def exclude(self, pattern):
        """Exclude files that match 'pattern'."""
        match = translate_pattern(pattern)
        return self._remove_files(match.match)

    def recursive_include(self, dir, pattern):
        """
        Include all files anywhere in 'dir/' that match the pattern.
        """
        full_pattern = os.path.join(dir, '**', pattern)
        found = [f for f in glob(full_pattern, recursive=True)
                 if not os.path.isdir(f)]
        self.extend(found)
        return bool(found)

    def recursive_exclude(self, dir, pattern):
        """
        Exclude any file anywhere in 'dir/' that match the pattern.
        """
        match = translate_pattern(os.path.join(dir, '**', pattern))
        return self._remove_files(match.match)

    def graft(self, dir):
        """Include all files from 'dir/'."""
        found = [
            item
            for match_dir in glob(dir)
            for item in distutils.filelist.findall(match_dir)
        ]
        self.extend(found)
        return bool(found)

    def prune(self, dir):
        """Filter out files from 'dir/'."""
        match = translate_pattern(os.path.join(dir, '**'))
        return self._remove_files(match.match)

    def global_include(self, pattern):
        """
        Include all files anywhere in the current directory that match the
        pattern. This is very inefficient on large file trees.
        """
        if self.allfiles is None:
            self.findall()
        match = translate_pattern(os.path.join('**', pattern))
        found = [f for f in self.allfiles if match.match(f)]
        self.extend(found)
        return bool(found)

    def global_exclude(self, pattern):
        """
        Exclude all files anywhere that match the pattern.
        """
        match = translate_pattern(os.path.join('**', pattern))
        return self._remove_files(match.match)

    def append(self, item):
        if item.endswith('\r'):  # Fix older sdists built on Windows
            item = item[:-1]
        path = convert_path(item)

        if self._safe_path(path):
            self.files.append(path)

    def extend(self, paths):
        self.files.extend(filter(self._safe_path, paths))

    def _repair(self):
        """
        Replace self.files with only safe paths

        Because some owners of FileList manipulate the underlying
        ``files`` attribute directly, this method must be called to
        repair those paths.
        """
        self.files = list(filter(self._safe_path, self.files))

    def _safe_path(self, path):
        enc_warn = "'%s' not %s encodable -- skipping"

        # To avoid accidental trans-codings errors, first to unicode
        u_path = unicode_utils.filesys_decode(path)
        if u_path is None:
            log.warn("'%s' in unexpected encoding -- skipping" % path)
            return False

        # Must ensure utf-8 encodability
        utf8_path = unicode_utils.try_encode(u_path, "utf-8")
        if utf8_path is None:
            log.warn(enc_warn, path, 'utf-8')
            return False

        try:
            # accept is either way checks out
            if os.path.exists(u_path) or os.path.exists(utf8_path):
                return True
        # this will catch any encode errors decoding u_path
        except UnicodeEncodeError:
            log.warn(enc_warn, path, sys.getfilesystemencoding())


class manifest_maker(sdist):
    template = "MANIFEST.in"

    def initialize_options(self):
        self.use_defaults = 1
        self.prune = 1
        self.manifest_only = 1
        self.force_manifest = 1

    def finalize_options(self):
        pass

    def run(self):
        self.filelist = FileList()
        if not os.path.exists(self.manifest):
            self.write_manifest()  # it must exist so it'll get in the list
        self.add_defaults()
        if os.path.exists(self.template):
            self.read_template()
        self.add_license_files()
        self.prune_file_list()
        self.filelist.sort()
        self.filelist.remove_duplicates()
        self.write_manifest()

    def _manifest_normalize(self, path):
        path = unicode_utils.filesys_decode(path)
        return path.replace(os.sep, '/')

    def write_manifest(self):
        """
        Write the file list in 'self.filelist' to the manifest file
        named by 'self.manifest'.
        """
        self.filelist._repair()

        # Now _repairs should encodability, but not unicode
        files = [self._manifest_normalize(f) for f in self.filelist.files]
        msg = "writing manifest file '%s'" % self.manifest
        self.execute(write_file, (self.manifest, files), msg)

    def warn(self, msg):
        if not self._should_suppress_warning(msg):
            sdist.warn(self, msg)

    @staticmethod
    def _should_suppress_warning(msg):
        """
        suppress missing-file warnings from sdist
        """
        return re.match(r"standard file .*not found", msg)

    def add_defaults(self):
        sdist.add_defaults(self)
        self.filelist.append(self.template)
        self.filelist.append(self.manifest)
        rcfiles = list(walk_revctrl())
        if rcfiles:
            self.filelist.extend(rcfiles)
        elif os.path.exists(self.manifest):
            self.read_manifest()

        if os.path.exists("setup.py"):
            # setup.py should be included by default, even if it's not
            # the script called to create the sdist
            self.filelist.append("setup.py")

        ei_cmd = self.get_finalized_command('egg_info')
        self.filelist.graft(ei_cmd.egg_info)

    def add_license_files(self):
        license_files = self.distribution.metadata.license_files or []
        for lf in license_files:
            log.info("adding license file '%s'", lf)
            pass
        self.filelist.extend(license_files)

    def prune_file_list(self):
        build = self.get_finalized_command('build')
        base_dir = self.distribution.get_fullname()
        self.filelist.prune(build.build_base)
        self.filelist.prune(base_dir)
        sep = re.escape(os.sep)
        self.filelist.exclude_pattern(r'(^|' + sep + r')(RCS|CVS|\.svn)' + sep,
                                      is_regex=1)

    def _safe_data_files(self, build_py):
        """
        The parent class implementation of this method
        (``sdist``) will try to include data files, which
        might cause recursion problems when
        ``include_package_data=True``.

        Therefore, avoid triggering any attempt of
        analyzing/building the manifest again.
        """
        if hasattr(build_py, 'get_data_files_without_manifest'):
            return build_py.get_data_files_without_manifest()

        warnings.warn(
            "Custom 'build_py' does not implement "
            "'get_data_files_without_manifest'.\nPlease extend command classes"
            " from setuptools instead of distutils.",
            SetuptoolsDeprecationWarning
        )
        return build_py.get_data_files()


def write_file(filename, contents):
    """Create a file with the specified name and write 'contents' (a
    sequence of strings without line terminators) to it.
    """
    contents = "\n".join(contents)

    # assuming the contents has been vetted for utf-8 encoding
    contents = contents.encode("utf-8")

    with open(filename, "wb") as f:  # always write POSIX-style manifest
        f.write(contents)


def write_pkg_info(cmd, basename, filename):
    log.info("writing %s", filename)
    if not cmd.dry_run:
        metadata = cmd.distribution.metadata
        metadata.version, oldver = cmd.egg_version, metadata.version
        metadata.name, oldname = cmd.egg_name, metadata.name

        try:
            # write unescaped data to PKG-INFO, so older pkg_resources
            # can still parse it
            metadata.write_pkg_info(cmd.egg_info)
        finally:
            metadata.name, metadata.version = oldname, oldver

        safe = getattr(cmd.distribution, 'zip_safe', None)

        bdist_egg.write_safety_flag(cmd.egg_info, safe)


def warn_depends_obsolete(cmd, basename, filename):
    if os.path.exists(filename):
        log.warn(
            "WARNING: 'depends.txt' is not used by setuptools 0.6!\n"
            "Use the install_requires/extras_require setup() args instead."
        )


def _write_requirements(stream, reqs):
    lines = yield_lines(reqs or ())

    def append_cr(line):
        return line + '\n'
    lines = map(append_cr, lines)
    stream.writelines(lines)


def write_requirements(cmd, basename, filename):
    dist = cmd.distribution
    data = io.StringIO()
    _write_requirements(data, dist.install_requires)
    extras_require = dist.extras_require or {}
    for extra in sorted(extras_require):
        data.write('\n[{extra}]\n'.format(**vars()))
        _write_requirements(data, extras_require[extra])
    cmd.write_or_delete_file("requirements", filename, data.getvalue())


def write_setup_requirements(cmd, basename, filename):
    data = io.StringIO()
    _write_requirements(data, cmd.distribution.setup_requires)
    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())


def write_toplevel_names(cmd, basename, filename):
    pkgs = dict.fromkeys(
        [
            k.split('.', 1)[0]
            for k in cmd.distribution.iter_distribution_names()
        ]
    )
    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')


def overwrite_arg(cmd, basename, filename):
    write_arg(cmd, basename, filename, True)


def write_arg(cmd, basename, filename, force=False):
    argname = os.path.splitext(basename)[0]
    value = getattr(cmd.distribution, argname, None)
    if value is not None:
        value = '\n'.join(value) + '\n'
    cmd.write_or_delete_file(argname, filename, value, force)


def write_entries(cmd, basename, filename):
    ep = cmd.distribution.entry_points

    if isinstance(ep, str) or ep is None:
        data = ep
    elif ep is not None:
        data = []
        for section, contents in sorted(ep.items()):
            if not isinstance(contents, str):
                contents = EntryPoint.parse_group(section, contents)
                contents = '\n'.join(sorted(map(str, contents.values())))
            data.append('[%s]\n%s\n\n' % (section, contents))
        data = ''.join(data)

    cmd.write_or_delete_file('entry points', filename, data, True)


def get_pkg_info_revision():
    """
    Get a -r### off of PKG-INFO Version in case this is an sdist of
    a subversion revision.
    """
    warnings.warn(
        "get_pkg_info_revision is deprecated.", EggInfoDeprecationWarning)
    if os.path.exists('PKG-INFO'):
        with io.open('PKG-INFO') as f:
            for line in f:
                match = re.match(r"Version:.*-r(\d+)\s*$", line)
                if match:
                    return int(match.group(1))
    return 0


class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning):
    """Deprecated behavior warning for EggInfo, bypassing suppression."""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/install.py0000644000175100001710000001145200000000000021256 0ustar00runnerdockerfrom distutils.errors import DistutilsArgError
import inspect
import glob
import warnings
import platform
import distutils.command.install as orig

import setuptools

# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for
# now. See https://github.com/pypa/setuptools/issues/199/
_install = orig.install


class install(orig.install):
    """Use easy_install to install the package, w/dependencies"""

    user_options = orig.install.user_options + [
        ('old-and-unmanageable', None, "Try not to use this!"),
        ('single-version-externally-managed', None,
         "used by system package builders to create 'flat' eggs"),
    ]
    boolean_options = orig.install.boolean_options + [
        'old-and-unmanageable', 'single-version-externally-managed',
    ]
    new_commands = [
        ('install_egg_info', lambda self: True),
        ('install_scripts', lambda self: True),
    ]
    _nc = dict(new_commands)

    def initialize_options(self):

        warnings.warn(
            "setup.py install is deprecated. "
            "Use build and pip and other standards-based tools.",
            setuptools.SetuptoolsDeprecationWarning,
        )

        orig.install.initialize_options(self)
        self.old_and_unmanageable = None
        self.single_version_externally_managed = None

    def finalize_options(self):
        orig.install.finalize_options(self)
        if self.root:
            self.single_version_externally_managed = True
        elif self.single_version_externally_managed:
            if not self.root and not self.record:
                raise DistutilsArgError(
                    "You must specify --record or --root when building system"
                    " packages"
                )

    def handle_extra_path(self):
        if self.root or self.single_version_externally_managed:
            # explicit backward-compatibility mode, allow extra_path to work
            return orig.install.handle_extra_path(self)

        # Ignore extra_path when installing an egg (or being run by another
        # command without --root or --single-version-externally-managed
        self.path_file = None
        self.extra_dirs = ''

    def run(self):
        # Explicit request for old-style install?  Just do it
        if self.old_and_unmanageable or self.single_version_externally_managed:
            return orig.install.run(self)

        if not self._called_from_setup(inspect.currentframe()):
            # Run in backward-compatibility mode to support bdist_* commands.
            orig.install.run(self)
        else:
            self.do_egg_install()

    @staticmethod
    def _called_from_setup(run_frame):
        """
        Attempt to detect whether run() was called from setup() or by another
        command.  If called by setup(), the parent caller will be the
        'run_command' method in 'distutils.dist', and *its* caller will be
        the 'run_commands' method.  If called any other way, the
        immediate caller *might* be 'run_command', but it won't have been
        called by 'run_commands'. Return True in that case or if a call stack
        is unavailable. Return False otherwise.
        """
        if run_frame is None:
            msg = "Call stack not available. bdist_* commands may fail."
            warnings.warn(msg)
            if platform.python_implementation() == 'IronPython':
                msg = "For best results, pass -X:Frames to enable call stack."
                warnings.warn(msg)
            return True
        res = inspect.getouterframes(run_frame)[2]
        caller, = res[:1]
        info = inspect.getframeinfo(caller)
        caller_module = caller.f_globals.get('__name__', '')
        return (
            caller_module == 'distutils.dist'
            and info.function == 'run_commands'
        )

    def do_egg_install(self):

        easy_install = self.distribution.get_command_class('easy_install')

        cmd = easy_install(
            self.distribution, args="x", root=self.root, record=self.record,
        )
        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd
        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed

        # pick up setup-dir .egg files only: no .egg-info
        cmd.package_index.scan(glob.glob('*.egg'))

        self.run_command('bdist_egg')
        args = [self.distribution.get_command_obj('bdist_egg').egg_output]

        if setuptools.bootstrap_install_from:
            # Bootstrap self-installation of setuptools
            args.insert(0, setuptools.bootstrap_install_from)

        cmd.args = args
        cmd.run(show_deprecation=False)
        setuptools.bootstrap_install_from = None


# XXX Python 3.1 doesn't see _nc if this is inside the class
install.sub_commands = (
    [cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc] +
    install.new_commands
)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/install_egg_info.py0000644000175100001710000000423300000000000023112 0ustar00runnerdockerfrom distutils import log, dir_util
import os

from setuptools import Command
from setuptools import namespaces
from setuptools.archive_util import unpack_archive
import pkg_resources


class install_egg_info(namespaces.Installer, Command):
    """Install an .egg-info directory for the package"""

    description = "Install an .egg-info directory for the package"

    user_options = [
        ('install-dir=', 'd', "directory to install to"),
    ]

    def initialize_options(self):
        self.install_dir = None

    def finalize_options(self):
        self.set_undefined_options('install_lib',
                                   ('install_dir', 'install_dir'))
        ei_cmd = self.get_finalized_command("egg_info")
        basename = pkg_resources.Distribution(
            None, None, ei_cmd.egg_name, ei_cmd.egg_version
        ).egg_name() + '.egg-info'
        self.source = ei_cmd.egg_info
        self.target = os.path.join(self.install_dir, basename)
        self.outputs = []

    def run(self):
        self.run_command('egg_info')
        if os.path.isdir(self.target) and not os.path.islink(self.target):
            dir_util.remove_tree(self.target, dry_run=self.dry_run)
        elif os.path.exists(self.target):
            self.execute(os.unlink, (self.target,), "Removing " + self.target)
        if not self.dry_run:
            pkg_resources.ensure_directory(self.target)
        self.execute(
            self.copytree, (), "Copying %s to %s" % (self.source, self.target)
        )
        self.install_namespaces()

    def get_outputs(self):
        return self.outputs

    def copytree(self):
        # Copy the .egg-info tree to site-packages
        def skimmer(src, dst):
            # filter out source-control directories; note that 'src' is always
            # a '/'-separated path, regardless of platform.  'dst' is a
            # platform-specific path.
            for skip in '.svn/', 'CVS/':
                if src.startswith(skip) or '/' + skip in src:
                    return None
            self.outputs.append(dst)
            log.debug("Copying %s to %s", src, dst)
            return dst

        unpack_archive(self.source, self.target, skimmer)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/install_lib.py0000644000175100001710000000744300000000000022111 0ustar00runnerdockerimport os
import sys
from itertools import product, starmap
import distutils.command.install_lib as orig


class install_lib(orig.install_lib):
    """Don't add compiled flags to filenames of non-Python files"""

    def run(self):
        self.build()
        outfiles = self.install()
        if outfiles is not None:
            # always compile, in case we have any extension stubs to deal with
            self.byte_compile(outfiles)

    def get_exclusions(self):
        """
        Return a collections.Sized collections.Container of paths to be
        excluded for single_version_externally_managed installations.
        """
        all_packages = (
            pkg
            for ns_pkg in self._get_SVEM_NSPs()
            for pkg in self._all_packages(ns_pkg)
        )

        excl_specs = product(all_packages, self._gen_exclusion_paths())
        return set(starmap(self._exclude_pkg_path, excl_specs))

    def _exclude_pkg_path(self, pkg, exclusion_path):
        """
        Given a package name and exclusion path within that package,
        compute the full exclusion path.
        """
        parts = pkg.split('.') + [exclusion_path]
        return os.path.join(self.install_dir, *parts)

    @staticmethod
    def _all_packages(pkg_name):
        """
        >>> list(install_lib._all_packages('foo.bar.baz'))
        ['foo.bar.baz', 'foo.bar', 'foo']
        """
        while pkg_name:
            yield pkg_name
            pkg_name, sep, child = pkg_name.rpartition('.')

    def _get_SVEM_NSPs(self):
        """
        Get namespace packages (list) but only for
        single_version_externally_managed installations and empty otherwise.
        """
        # TODO: is it necessary to short-circuit here? i.e. what's the cost
        # if get_finalized_command is called even when namespace_packages is
        # False?
        if not self.distribution.namespace_packages:
            return []

        install_cmd = self.get_finalized_command('install')
        svem = install_cmd.single_version_externally_managed

        return self.distribution.namespace_packages if svem else []

    @staticmethod
    def _gen_exclusion_paths():
        """
        Generate file paths to be excluded for namespace packages (bytecode
        cache files).
        """
        # always exclude the package module itself
        yield '__init__.py'

        yield '__init__.pyc'
        yield '__init__.pyo'

        if not hasattr(sys, 'implementation'):
            return

        base = os.path.join(
            '__pycache__', '__init__.' + sys.implementation.cache_tag)
        yield base + '.pyc'
        yield base + '.pyo'
        yield base + '.opt-1.pyc'
        yield base + '.opt-2.pyc'

    def copy_tree(
            self, infile, outfile,
            preserve_mode=1, preserve_times=1, preserve_symlinks=0, level=1
    ):
        assert preserve_mode and preserve_times and not preserve_symlinks
        exclude = self.get_exclusions()

        if not exclude:
            return orig.install_lib.copy_tree(self, infile, outfile)

        # Exclude namespace package __init__.py* files from the output

        from setuptools.archive_util import unpack_directory
        from distutils import log

        outfiles = []

        def pf(src, dst):
            if dst in exclude:
                log.warn("Skipping installation of %s (namespace package)",
                         dst)
                return False

            log.info("copying %s -> %s", src, os.path.dirname(dst))
            outfiles.append(dst)
            return dst

        unpack_directory(infile, outfile, pf)
        return outfiles

    def get_outputs(self):
        outputs = orig.install_lib.get_outputs(self)
        exclude = self.get_exclusions()
        if exclude:
            return [f for f in outputs if f not in exclude]
        return outputs
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/install_scripts.py0000644000175100001710000000504100000000000023022 0ustar00runnerdockerfrom distutils import log
import distutils.command.install_scripts as orig
from distutils.errors import DistutilsModuleError
import os
import sys

from pkg_resources import Distribution, PathMetadata, ensure_directory


class install_scripts(orig.install_scripts):
    """Do normal script install, plus any egg_info wrapper scripts"""

    def initialize_options(self):
        orig.install_scripts.initialize_options(self)
        self.no_ep = False

    def run(self):
        import setuptools.command.easy_install as ei

        self.run_command("egg_info")
        if self.distribution.scripts:
            orig.install_scripts.run(self)  # run first to set up self.outfiles
        else:
            self.outfiles = []
        if self.no_ep:
            # don't install entry point scripts into .egg file!
            return

        ei_cmd = self.get_finalized_command("egg_info")
        dist = Distribution(
            ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
            ei_cmd.egg_name, ei_cmd.egg_version,
        )
        bs_cmd = self.get_finalized_command('build_scripts')
        exec_param = getattr(bs_cmd, 'executable', None)
        try:
            bw_cmd = self.get_finalized_command("bdist_wininst")
            is_wininst = getattr(bw_cmd, '_is_running', False)
        except (ImportError, DistutilsModuleError):
            is_wininst = False
        writer = ei.ScriptWriter
        if is_wininst:
            exec_param = "python.exe"
            writer = ei.WindowsScriptWriter
        if exec_param == sys.executable:
            # In case the path to the Python executable contains a space, wrap
            # it so it's not split up.
            exec_param = [exec_param]
        # resolve the writer to the environment
        writer = writer.best()
        cmd = writer.command_spec_class.best().from_param(exec_param)
        for args in writer.get_args(dist, cmd.as_header()):
            self.write_script(*args)

    def write_script(self, script_name, contents, mode="t", *ignored):
        """Write an executable file to the scripts directory"""
        from setuptools.command.easy_install import chmod, current_umask

        log.info("Installing %s script to %s", script_name, self.install_dir)
        target = os.path.join(self.install_dir, script_name)
        self.outfiles.append(target)

        mask = current_umask()
        if not self.dry_run:
            ensure_directory(target)
            f = open(target, "w" + mode)
            f.write(contents)
            f.close()
            chmod(target, 0o777 - mask)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/launcher manifest.xml0000644000175100001710000000116400000000000023347 0ustar00runnerdocker

    
    
    
        
            
                
            
        
    

././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/py36compat.py0000644000175100001710000001152200000000000021613 0ustar00runnerdockerimport os
from glob import glob
from distutils.util import convert_path
from distutils.command import sdist


class sdist_add_defaults:
    """
    Mix-in providing forward-compatibility for functionality as found in
    distutils on Python 3.7.

    Do not edit the code in this class except to update functionality
    as implemented in distutils. Instead, override in the subclass.
    """

    def add_defaults(self):
        """Add all the default files to self.filelist:
          - README or README.txt
          - setup.py
          - test/test*.py
          - all pure Python modules mentioned in setup script
          - all files pointed by package_data (build_py)
          - all files defined in data_files.
          - all files defined as scripts.
          - all C sources listed as part of extensions or C libraries
            in the setup script (doesn't catch C headers!)
        Warns if (README or README.txt) or setup.py are missing; everything
        else is optional.
        """
        self._add_defaults_standards()
        self._add_defaults_optional()
        self._add_defaults_python()
        self._add_defaults_data_files()
        self._add_defaults_ext()
        self._add_defaults_c_libs()
        self._add_defaults_scripts()

    @staticmethod
    def _cs_path_exists(fspath):
        """
        Case-sensitive path existence check

        >>> sdist_add_defaults._cs_path_exists(__file__)
        True
        >>> sdist_add_defaults._cs_path_exists(__file__.upper())
        False
        """
        if not os.path.exists(fspath):
            return False
        # make absolute so we always have a directory
        abspath = os.path.abspath(fspath)
        directory, filename = os.path.split(abspath)
        return filename in os.listdir(directory)

    def _add_defaults_standards(self):
        standards = [self.READMES, self.distribution.script_name]
        for fn in standards:
            if isinstance(fn, tuple):
                alts = fn
                got_it = False
                for fn in alts:
                    if self._cs_path_exists(fn):
                        got_it = True
                        self.filelist.append(fn)
                        break

                if not got_it:
                    self.warn("standard file not found: should have one of " +
                              ', '.join(alts))
            else:
                if self._cs_path_exists(fn):
                    self.filelist.append(fn)
                else:
                    self.warn("standard file '%s' not found" % fn)

    def _add_defaults_optional(self):
        optional = ['test/test*.py', 'setup.cfg']
        for pattern in optional:
            files = filter(os.path.isfile, glob(pattern))
            self.filelist.extend(files)

    def _add_defaults_python(self):
        # build_py is used to get:
        #  - python modules
        #  - files defined in package_data
        build_py = self.get_finalized_command('build_py')

        # getting python files
        if self.distribution.has_pure_modules():
            self.filelist.extend(build_py.get_source_files())

        # getting package_data files
        # (computed in build_py.data_files by build_py.finalize_options)
        for pkg, src_dir, build_dir, filenames in build_py.data_files:
            for filename in filenames:
                self.filelist.append(os.path.join(src_dir, filename))

    def _add_defaults_data_files(self):
        # getting distribution.data_files
        if self.distribution.has_data_files():
            for item in self.distribution.data_files:
                if isinstance(item, str):
                    # plain file
                    item = convert_path(item)
                    if os.path.isfile(item):
                        self.filelist.append(item)
                else:
                    # a (dirname, filenames) tuple
                    dirname, filenames = item
                    for f in filenames:
                        f = convert_path(f)
                        if os.path.isfile(f):
                            self.filelist.append(f)

    def _add_defaults_ext(self):
        if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command('build_ext')
            self.filelist.extend(build_ext.get_source_files())

    def _add_defaults_c_libs(self):
        if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command('build_clib')
            self.filelist.extend(build_clib.get_source_files())

    def _add_defaults_scripts(self):
        if self.distribution.has_scripts():
            build_scripts = self.get_finalized_command('build_scripts')
            self.filelist.extend(build_scripts.get_source_files())


if hasattr(sdist.sdist, '_add_defaults_standards'):
    # disable the functionality already available upstream
    class sdist_add_defaults:  # noqa
        pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/register.py0000644000175100001710000000072400000000000021434 0ustar00runnerdockerfrom distutils import log
import distutils.command.register as orig

from setuptools.errors import RemovedCommandError


class register(orig.register):
    """Formerly used to register packages on PyPI."""

    def run(self):
        msg = (
            "The register command has been removed, use twine to upload "
            + "instead (https://pypi.org/p/twine)"
        )

        self.announce("ERROR: " + msg, log.ERROR)

        raise RemovedCommandError(msg)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/rotate.py0000644000175100001710000000412000000000000021100 0ustar00runnerdockerfrom distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
import os
import shutil

from setuptools import Command


class rotate(Command):
    """Delete older distributions"""

    description = "delete older distributions, keeping N newest files"
    user_options = [
        ('match=', 'm', "patterns to match (required)"),
        ('dist-dir=', 'd', "directory where the distributions are"),
        ('keep=', 'k', "number of matching distributions to keep"),
    ]

    boolean_options = []

    def initialize_options(self):
        self.match = None
        self.dist_dir = None
        self.keep = None

    def finalize_options(self):
        if self.match is None:
            raise DistutilsOptionError(
                "Must specify one or more (comma-separated) match patterns "
                "(e.g. '.zip' or '.egg')"
            )
        if self.keep is None:
            raise DistutilsOptionError("Must specify number of files to keep")
        try:
            self.keep = int(self.keep)
        except ValueError as e:
            raise DistutilsOptionError("--keep must be an integer") from e
        if isinstance(self.match, str):
            self.match = [
                convert_path(p.strip()) for p in self.match.split(',')
            ]
        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))

    def run(self):
        self.run_command("egg_info")
        from glob import glob

        for pattern in self.match:
            pattern = self.distribution.get_name() + '*' + pattern
            files = glob(os.path.join(self.dist_dir, pattern))
            files = [(os.path.getmtime(f), f) for f in files]
            files.sort()
            files.reverse()

            log.info("%d file(s) matching %s", len(files), pattern)
            files = files[self.keep:]
            for (t, f) in files:
                log.info("Deleting %s", f)
                if not self.dry_run:
                    if os.path.isdir(f):
                        shutil.rmtree(f)
                    else:
                        os.unlink(f)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/saveopts.py0000644000175100001710000000122200000000000021446 0ustar00runnerdockerfrom setuptools.command.setopt import edit_config, option_base


class saveopts(option_base):
    """Save command-line options to a file"""

    description = "save supplied options to setup.cfg or other config file"

    def run(self):
        dist = self.distribution
        settings = {}

        for cmd in dist.command_options:

            if cmd == 'saveopts':
                continue  # don't save our own options!

            for opt, (src, val) in dist.get_option_dict(cmd).items():
                if src == "command line":
                    settings.setdefault(cmd, {})[opt] = val

        edit_config(self.filename, settings, self.dry_run)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/sdist.py0000644000175100001710000001441500000000000020740 0ustar00runnerdockerfrom distutils import log
import distutils.command.sdist as orig
import os
import sys
import io
import contextlib

from .py36compat import sdist_add_defaults

import pkg_resources

_default_revctrl = list


def walk_revctrl(dirname=''):
    """Find all files under revision control"""
    for ep in pkg_resources.iter_entry_points('setuptools.file_finders'):
        for item in ep.load()(dirname):
            yield item


class sdist(sdist_add_defaults, orig.sdist):
    """Smart sdist that finds anything supported by revision control"""

    user_options = [
        ('formats=', None,
         "formats for source distribution (comma-separated list)"),
        ('keep-temp', 'k',
         "keep the distribution tree around after creating " +
         "archive file(s)"),
        ('dist-dir=', 'd',
         "directory to put the source distribution archive(s) in "
         "[default: dist]"),
        ('owner=', 'u',
         "Owner name used when creating a tar file [default: current user]"),
        ('group=', 'g',
         "Group name used when creating a tar file [default: current group]"),
    ]

    negative_opt = {}

    README_EXTENSIONS = ['', '.rst', '.txt', '.md']
    READMES = tuple('README{0}'.format(ext) for ext in README_EXTENSIONS)

    def run(self):
        self.run_command('egg_info')
        ei_cmd = self.get_finalized_command('egg_info')
        self.filelist = ei_cmd.filelist
        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
        self.check_readme()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        self.make_distribution()

        dist_files = getattr(self.distribution, 'dist_files', [])
        for file in self.archive_files:
            data = ('sdist', '', file)
            if data not in dist_files:
                dist_files.append(data)

    def initialize_options(self):
        orig.sdist.initialize_options(self)

        self._default_to_gztar()

    def _default_to_gztar(self):
        # only needed on Python prior to 3.6.
        if sys.version_info >= (3, 6, 0, 'beta', 1):
            return
        self.formats = ['gztar']

    def make_distribution(self):
        """
        Workaround for #516
        """
        with self._remove_os_link():
            orig.sdist.make_distribution(self)

    @staticmethod
    @contextlib.contextmanager
    def _remove_os_link():
        """
        In a context, remove and restore os.link if it exists
        """

        class NoValue:
            pass

        orig_val = getattr(os, 'link', NoValue)
        try:
            del os.link
        except Exception:
            pass
        try:
            yield
        finally:
            if orig_val is not NoValue:
                setattr(os, 'link', orig_val)

    def _add_defaults_optional(self):
        super()._add_defaults_optional()
        if os.path.isfile('pyproject.toml'):
            self.filelist.append('pyproject.toml')

    def _add_defaults_python(self):
        """getting python files"""
        if self.distribution.has_pure_modules():
            build_py = self.get_finalized_command('build_py')
            self.filelist.extend(build_py.get_source_files())
            self._add_data_files(self._safe_data_files(build_py))

    def _safe_data_files(self, build_py):
        """
        Since the ``sdist`` class is also used to compute the MANIFEST
        (via :obj:`setuptools.command.egg_info.manifest_maker`),
        there might be recursion problems when trying to obtain the list of
        data_files and ``include_package_data=True`` (which in turn depends on
        the files included in the MANIFEST).

        To avoid that, ``manifest_maker`` should be able to overwrite this
        method and avoid recursive attempts to build/analyze the MANIFEST.
        """
        return build_py.data_files

    def _add_data_files(self, data_files):
        """
        Add data files as found in build_py.data_files.
        """
        self.filelist.extend(
            os.path.join(src_dir, name)
            for _, src_dir, _, filenames in data_files
            for name in filenames
        )

    def _add_defaults_data_files(self):
        try:
            super()._add_defaults_data_files()
        except TypeError:
            log.warn("data_files contains unexpected objects")

    def check_readme(self):
        for f in self.READMES:
            if os.path.exists(f):
                return
        else:
            self.warn(
                "standard file not found: should have one of " +
                ', '.join(self.READMES)
            )

    def make_release_tree(self, base_dir, files):
        orig.sdist.make_release_tree(self, base_dir, files)

        # Save any egg_info command line options used to create this sdist
        dest = os.path.join(base_dir, 'setup.cfg')
        if hasattr(os, 'link') and os.path.exists(dest):
            # unlink and re-copy, since it might be hard-linked, and
            # we don't want to change the source version
            os.unlink(dest)
            self.copy_file('setup.cfg', dest)

        self.get_finalized_command('egg_info').save_version_info(dest)

    def _manifest_is_not_generated(self):
        # check for special comment used in 2.7.1 and higher
        if not os.path.isfile(self.manifest):
            return False

        with io.open(self.manifest, 'rb') as fp:
            first_line = fp.readline()
        return (first_line !=
                '# file GENERATED by distutils, do NOT edit\n'.encode())

    def read_manifest(self):
        """Read the manifest file (named by 'self.manifest') and use it to
        fill in 'self.filelist', the list of files to include in the source
        distribution.
        """
        log.info("reading manifest file '%s'", self.manifest)
        manifest = open(self.manifest, 'rb')
        for line in manifest:
            # The manifest must contain UTF-8. See #303.
            try:
                line = line.decode('UTF-8')
            except UnicodeDecodeError:
                log.warn("%r not UTF-8 decodable -- skipping" % line)
                continue
            # ignore comments and blank lines
            line = line.strip()
            if line.startswith('#') or not line:
                continue
            self.filelist.append(line)
        manifest.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/setopt.py0000644000175100001710000001173600000000000021133 0ustar00runnerdockerfrom distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
import distutils
import os
import configparser

from setuptools import Command

__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']


def config_file(kind="local"):
    """Get the filename of the distutils, local, global, or per-user config

    `kind` must be one of "local", "global", or "user"
    """
    if kind == 'local':
        return 'setup.cfg'
    if kind == 'global':
        return os.path.join(
            os.path.dirname(distutils.__file__), 'distutils.cfg'
        )
    if kind == 'user':
        dot = os.name == 'posix' and '.' or ''
        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
    raise ValueError(
        "config_file() type must be 'local', 'global', or 'user'", kind
    )


def edit_config(filename, settings, dry_run=False):
    """Edit a configuration file to include `settings`

    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
    command/section name.  A ``None`` value means to delete the entire section,
    while a dictionary lists settings to be changed or deleted in that section.
    A setting of ``None`` means to delete that setting.
    """
    log.debug("Reading configuration from %s", filename)
    opts = configparser.RawConfigParser()
    opts.optionxform = lambda x: x
    opts.read([filename])
    for section, options in settings.items():
        if options is None:
            log.info("Deleting section [%s] from %s", section, filename)
            opts.remove_section(section)
        else:
            if not opts.has_section(section):
                log.debug("Adding new section [%s] to %s", section, filename)
                opts.add_section(section)
            for option, value in options.items():
                if value is None:
                    log.debug(
                        "Deleting %s.%s from %s",
                        section, option, filename
                    )
                    opts.remove_option(section, option)
                    if not opts.options(section):
                        log.info("Deleting empty [%s] section from %s",
                                 section, filename)
                        opts.remove_section(section)
                else:
                    log.debug(
                        "Setting %s.%s to %r in %s",
                        section, option, value, filename
                    )
                    opts.set(section, option, value)

    log.info("Writing %s", filename)
    if not dry_run:
        with open(filename, 'w') as f:
            opts.write(f)


class option_base(Command):
    """Abstract base class for commands that mess with config files"""

    user_options = [
        ('global-config', 'g',
         "save options to the site-wide distutils.cfg file"),
        ('user-config', 'u',
         "save options to the current user's pydistutils.cfg file"),
        ('filename=', 'f',
         "configuration file to use (default=setup.cfg)"),
    ]

    boolean_options = [
        'global-config', 'user-config',
    ]

    def initialize_options(self):
        self.global_config = None
        self.user_config = None
        self.filename = None

    def finalize_options(self):
        filenames = []
        if self.global_config:
            filenames.append(config_file('global'))
        if self.user_config:
            filenames.append(config_file('user'))
        if self.filename is not None:
            filenames.append(self.filename)
        if not filenames:
            filenames.append(config_file('local'))
        if len(filenames) > 1:
            raise DistutilsOptionError(
                "Must specify only one configuration file option",
                filenames
            )
        self.filename, = filenames


class setopt(option_base):
    """Save command-line options to a file"""

    description = "set an option in setup.cfg or another config file"

    user_options = [
        ('command=', 'c', 'command to set an option for'),
        ('option=', 'o', 'option to set'),
        ('set-value=', 's', 'value of the option'),
        ('remove', 'r', 'remove (unset) the value'),
    ] + option_base.user_options

    boolean_options = option_base.boolean_options + ['remove']

    def initialize_options(self):
        option_base.initialize_options(self)
        self.command = None
        self.option = None
        self.set_value = None
        self.remove = None

    def finalize_options(self):
        option_base.finalize_options(self)
        if self.command is None or self.option is None:
            raise DistutilsOptionError("Must specify --command *and* --option")
        if self.set_value is None and not self.remove:
            raise DistutilsOptionError("Must specify --set-value or --remove")

    def run(self):
        edit_config(
            self.filename, {
                self.command: {self.option.replace('-', '_'): self.set_value}
            },
            self.dry_run
        )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/test.py0000644000175100001710000001763000000000000020573 0ustar00runnerdockerimport os
import operator
import sys
import contextlib
import itertools
import unittest
from distutils.errors import DistutilsError, DistutilsOptionError
from distutils import log
from unittest import TestLoader

from pkg_resources import (
    resource_listdir,
    resource_exists,
    normalize_path,
    working_set,
    evaluate_marker,
    add_activation_listener,
    require,
    EntryPoint,
)
from setuptools import Command
from setuptools.extern.more_itertools import unique_everseen


class ScanningLoader(TestLoader):
    def __init__(self):
        TestLoader.__init__(self)
        self._visited = set()

    def loadTestsFromModule(self, module, pattern=None):
        """Return a suite of all tests cases contained in the given module

        If the module is a package, load tests from all the modules in it.
        If the module has an ``additional_tests`` function, call it and add
        the return value to the tests.
        """
        if module in self._visited:
            return None
        self._visited.add(module)

        tests = []
        tests.append(TestLoader.loadTestsFromModule(self, module))

        if hasattr(module, "additional_tests"):
            tests.append(module.additional_tests())

        if hasattr(module, '__path__'):
            for file in resource_listdir(module.__name__, ''):
                if file.endswith('.py') and file != '__init__.py':
                    submodule = module.__name__ + '.' + file[:-3]
                else:
                    if resource_exists(module.__name__, file + '/__init__.py'):
                        submodule = module.__name__ + '.' + file
                    else:
                        continue
                tests.append(self.loadTestsFromName(submodule))

        if len(tests) != 1:
            return self.suiteClass(tests)
        else:
            return tests[0]  # don't create a nested suite for only one return


# adapted from jaraco.classes.properties:NonDataProperty
class NonDataProperty:
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return self.fget(obj)


class test(Command):
    """Command to run unit tests after in-place build"""

    description = "run unit tests after in-place build (deprecated)"

    user_options = [
        ('test-module=', 'm', "Run 'test_suite' in specified module"),
        (
            'test-suite=',
            's',
            "Run single test, case or suite (e.g. 'module.test_suite')",
        ),
        ('test-runner=', 'r', "Test runner to use"),
    ]

    def initialize_options(self):
        self.test_suite = None
        self.test_module = None
        self.test_loader = None
        self.test_runner = None

    def finalize_options(self):

        if self.test_suite and self.test_module:
            msg = "You may specify a module or a suite, but not both"
            raise DistutilsOptionError(msg)

        if self.test_suite is None:
            if self.test_module is None:
                self.test_suite = self.distribution.test_suite
            else:
                self.test_suite = self.test_module + ".test_suite"

        if self.test_loader is None:
            self.test_loader = getattr(self.distribution, 'test_loader', None)
        if self.test_loader is None:
            self.test_loader = "setuptools.command.test:ScanningLoader"
        if self.test_runner is None:
            self.test_runner = getattr(self.distribution, 'test_runner', None)

    @NonDataProperty
    def test_args(self):
        return list(self._test_args())

    def _test_args(self):
        if not self.test_suite and sys.version_info >= (2, 7):
            yield 'discover'
        if self.verbose:
            yield '--verbose'
        if self.test_suite:
            yield self.test_suite

    def with_project_on_sys_path(self, func):
        """
        Backward compatibility for project_on_sys_path context.
        """
        with self.project_on_sys_path():
            func()

    @contextlib.contextmanager
    def project_on_sys_path(self, include_dists=[]):
        self.run_command('egg_info')

        # Build extensions in-place
        self.reinitialize_command('build_ext', inplace=1)
        self.run_command('build_ext')

        ei_cmd = self.get_finalized_command("egg_info")

        old_path = sys.path[:]
        old_modules = sys.modules.copy()

        try:
            project_path = normalize_path(ei_cmd.egg_base)
            sys.path.insert(0, project_path)
            working_set.__init__()
            add_activation_listener(lambda dist: dist.activate())
            require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
            with self.paths_on_pythonpath([project_path]):
                yield
        finally:
            sys.path[:] = old_path
            sys.modules.clear()
            sys.modules.update(old_modules)
            working_set.__init__()

    @staticmethod
    @contextlib.contextmanager
    def paths_on_pythonpath(paths):
        """
        Add the indicated paths to the head of the PYTHONPATH environment
        variable so that subprocesses will also see the packages at
        these paths.

        Do this in a context that restores the value on exit.
        """
        nothing = object()
        orig_pythonpath = os.environ.get('PYTHONPATH', nothing)
        current_pythonpath = os.environ.get('PYTHONPATH', '')
        try:
            prefix = os.pathsep.join(unique_everseen(paths))
            to_join = filter(None, [prefix, current_pythonpath])
            new_path = os.pathsep.join(to_join)
            if new_path:
                os.environ['PYTHONPATH'] = new_path
            yield
        finally:
            if orig_pythonpath is nothing:
                os.environ.pop('PYTHONPATH', None)
            else:
                os.environ['PYTHONPATH'] = orig_pythonpath

    @staticmethod
    def install_dists(dist):
        """
        Install the requirements indicated by self.distribution and
        return an iterable of the dists that were built.
        """
        ir_d = dist.fetch_build_eggs(dist.install_requires)
        tr_d = dist.fetch_build_eggs(dist.tests_require or [])
        er_d = dist.fetch_build_eggs(
            v
            for k, v in dist.extras_require.items()
            if k.startswith(':') and evaluate_marker(k[1:])
        )
        return itertools.chain(ir_d, tr_d, er_d)

    def run(self):
        self.announce(
            "WARNING: Testing via this command is deprecated and will be "
            "removed in a future version. Users looking for a generic test "
            "entry point independent of test runner are encouraged to use "
            "tox.",
            log.WARN,
        )

        installed_dists = self.install_dists(self.distribution)

        cmd = ' '.join(self._argv)
        if self.dry_run:
            self.announce('skipping "%s" (dry run)' % cmd)
            return

        self.announce('running "%s"' % cmd)

        paths = map(operator.attrgetter('location'), installed_dists)
        with self.paths_on_pythonpath(paths):
            with self.project_on_sys_path():
                self.run_tests()

    def run_tests(self):
        test = unittest.main(
            None,
            None,
            self._argv,
            testLoader=self._resolve_as_ep(self.test_loader),
            testRunner=self._resolve_as_ep(self.test_runner),
            exit=False,
        )
        if not test.result.wasSuccessful():
            msg = 'Test failed: %s' % test.result
            self.announce(msg, log.ERROR)
            raise DistutilsError(msg)

    @property
    def _argv(self):
        return ['unittest'] + self.test_args

    @staticmethod
    def _resolve_as_ep(val):
        """
        Load the indicated attribute value, called, as a as if it were
        specified as an entry point.
        """
        if val is None:
            return
        parsed = EntryPoint.parse("x=" + val)
        return parsed.resolve()()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/upload.py0000644000175100001710000000071600000000000021075 0ustar00runnerdockerfrom distutils import log
from distutils.command import upload as orig

from setuptools.errors import RemovedCommandError


class upload(orig.upload):
    """Formerly used to upload packages to PyPI."""

    def run(self):
        msg = (
            "The upload command has been removed, use twine to upload "
            + "instead (https://pypi.org/p/twine)"
        )

        self.announce("ERROR: " + msg, log.ERROR)
        raise RemovedCommandError(msg)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/command/upload_docs.py0000644000175100001710000001606200000000000022106 0ustar00runnerdocker# -*- coding: utf-8 -*-
"""upload_docs

Implements a Distutils 'upload_docs' subcommand (upload documentation to
sites other than PyPi such as devpi).
"""

from base64 import standard_b64encode
from distutils import log
from distutils.errors import DistutilsOptionError
import os
import socket
import zipfile
import tempfile
import shutil
import itertools
import functools
import http.client
import urllib.parse

from pkg_resources import iter_entry_points
from .upload import upload


def _encode(s):
    return s.encode('utf-8', 'surrogateescape')


class upload_docs(upload):
    # override the default repository as upload_docs isn't
    # supported by Warehouse (and won't be).
    DEFAULT_REPOSITORY = 'https://pypi.python.org/pypi/'

    description = 'Upload documentation to sites other than PyPi such as devpi'

    user_options = [
        ('repository=', 'r',
         "url of repository [default: %s]" % upload.DEFAULT_REPOSITORY),
        ('show-response', None,
         'display full response text from server'),
        ('upload-dir=', None, 'directory to upload'),
    ]
    boolean_options = upload.boolean_options

    def has_sphinx(self):
        if self.upload_dir is None:
            for ep in iter_entry_points('distutils.commands', 'build_sphinx'):
                return True

    sub_commands = [('build_sphinx', has_sphinx)]

    def initialize_options(self):
        upload.initialize_options(self)
        self.upload_dir = None
        self.target_dir = None

    def finalize_options(self):
        upload.finalize_options(self)
        if self.upload_dir is None:
            if self.has_sphinx():
                build_sphinx = self.get_finalized_command('build_sphinx')
                self.target_dir = dict(build_sphinx.builder_target_dirs)['html']
            else:
                build = self.get_finalized_command('build')
                self.target_dir = os.path.join(build.build_base, 'docs')
        else:
            self.ensure_dirname('upload_dir')
            self.target_dir = self.upload_dir
        if 'pypi.python.org' in self.repository:
            log.warn("Upload_docs command is deprecated for PyPi. Use RTD instead.")
        self.announce('Using upload directory %s' % self.target_dir)

    def create_zipfile(self, filename):
        zip_file = zipfile.ZipFile(filename, "w")
        try:
            self.mkpath(self.target_dir)  # just in case
            for root, dirs, files in os.walk(self.target_dir):
                if root == self.target_dir and not files:
                    tmpl = "no files found in upload directory '%s'"
                    raise DistutilsOptionError(tmpl % self.target_dir)
                for name in files:
                    full = os.path.join(root, name)
                    relative = root[len(self.target_dir):].lstrip(os.path.sep)
                    dest = os.path.join(relative, name)
                    zip_file.write(full, dest)
        finally:
            zip_file.close()

    def run(self):
        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        tmp_dir = tempfile.mkdtemp()
        name = self.distribution.metadata.get_name()
        zip_file = os.path.join(tmp_dir, "%s.zip" % name)
        try:
            self.create_zipfile(zip_file)
            self.upload_file(zip_file)
        finally:
            shutil.rmtree(tmp_dir)

    @staticmethod
    def _build_part(item, sep_boundary):
        key, values = item
        title = '\nContent-Disposition: form-data; name="%s"' % key
        # handle multiple entries for the same name
        if not isinstance(values, list):
            values = [values]
        for value in values:
            if isinstance(value, tuple):
                title += '; filename="%s"' % value[0]
                value = value[1]
            else:
                value = _encode(value)
            yield sep_boundary
            yield _encode(title)
            yield b"\n\n"
            yield value
            if value and value[-1:] == b'\r':
                yield b'\n'  # write an extra newline (lurve Macs)

    @classmethod
    def _build_multipart(cls, data):
        """
        Build up the MIME payload for the POST data
        """
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = b'\n--' + boundary.encode('ascii')
        end_boundary = sep_boundary + b'--'
        end_items = end_boundary, b"\n",
        builder = functools.partial(
            cls._build_part,
            sep_boundary=sep_boundary,
        )
        part_groups = map(builder, data.items())
        parts = itertools.chain.from_iterable(part_groups)
        body_items = itertools.chain(parts, end_items)
        content_type = 'multipart/form-data; boundary=%s' % boundary
        return b''.join(body_items), content_type

    def upload_file(self, filename):
        with open(filename, 'rb') as f:
            content = f.read()
        meta = self.distribution.metadata
        data = {
            ':action': 'doc_upload',
            'name': meta.get_name(),
            'content': (os.path.basename(filename), content),
        }
        # set up the authentication
        credentials = _encode(self.username + ':' + self.password)
        credentials = standard_b64encode(credentials).decode('ascii')
        auth = "Basic " + credentials

        body, ct = self._build_multipart(data)

        msg = "Submitting documentation to %s" % (self.repository)
        self.announce(msg, log.INFO)

        # build the Request
        # We can't use urllib2 since we need to send the Basic
        # auth right with the first request
        schema, netloc, url, params, query, fragments = \
            urllib.parse.urlparse(self.repository)
        assert not params and not query and not fragments
        if schema == 'http':
            conn = http.client.HTTPConnection(netloc)
        elif schema == 'https':
            conn = http.client.HTTPSConnection(netloc)
        else:
            raise AssertionError("unsupported schema " + schema)

        data = ''
        try:
            conn.connect()
            conn.putrequest("POST", url)
            content_type = ct
            conn.putheader('Content-type', content_type)
            conn.putheader('Content-length', str(len(body)))
            conn.putheader('Authorization', auth)
            conn.endheaders()
            conn.send(body)
        except socket.error as e:
            self.announce(str(e), log.ERROR)
            return

        r = conn.getresponse()
        if r.status == 200:
            msg = 'Server response (%s): %s' % (r.status, r.reason)
            self.announce(msg, log.INFO)
        elif r.status == 301:
            location = r.getheader('Location')
            if location is None:
                location = 'https://pythonhosted.org/%s/' % meta.get_name()
            msg = 'Upload successful. Visit %s' % location
            self.announce(msg, log.INFO)
        else:
            msg = 'Upload failed (%s): %s' % (r.status, r.reason)
            self.announce(msg, log.ERROR)
        if self.show_response:
            print('-' * 75, r.read(), '-' * 75)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/config.py0000644000175100001710000005516100000000000017444 0ustar00runnerdockerimport ast
import io
import os
import sys

import warnings
import functools
import importlib
from collections import defaultdict
from functools import partial
from functools import wraps
from glob import iglob
import contextlib

from distutils.errors import DistutilsOptionError, DistutilsFileError
from setuptools.extern.packaging.version import Version, InvalidVersion
from setuptools.extern.packaging.specifiers import SpecifierSet


class StaticModule:
    """
    Attempt to load the module by the name
    """

    def __init__(self, name):
        spec = importlib.util.find_spec(name)
        with open(spec.origin) as strm:
            src = strm.read()
        module = ast.parse(src)
        vars(self).update(locals())
        del self.self

    def __getattr__(self, attr):
        try:
            return next(
                ast.literal_eval(statement.value)
                for statement in self.module.body
                if isinstance(statement, ast.Assign)
                for target in statement.targets
                if isinstance(target, ast.Name) and target.id == attr
            )
        except Exception as e:
            raise AttributeError(
                "{self.name} has no attribute {attr}".format(**locals())
            ) from e


@contextlib.contextmanager
def patch_path(path):
    """
    Add path to front of sys.path for the duration of the context.
    """
    try:
        sys.path.insert(0, path)
        yield
    finally:
        sys.path.remove(path)


def read_configuration(filepath, find_others=False, ignore_option_errors=False):
    """Read given configuration file and returns options from it as a dict.

    :param str|unicode filepath: Path to configuration file
        to get options from.

    :param bool find_others: Whether to search for other configuration files
        which could be on in various places.

    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.

    :rtype: dict
    """
    from setuptools.dist import Distribution, _Distribution

    filepath = os.path.abspath(filepath)

    if not os.path.isfile(filepath):
        raise DistutilsFileError('Configuration file %s does not exist.' % filepath)

    current_directory = os.getcwd()
    os.chdir(os.path.dirname(filepath))

    try:
        dist = Distribution()

        filenames = dist.find_config_files() if find_others else []
        if filepath not in filenames:
            filenames.append(filepath)

        _Distribution.parse_config_files(dist, filenames=filenames)

        handlers = parse_configuration(
            dist, dist.command_options, ignore_option_errors=ignore_option_errors
        )

    finally:
        os.chdir(current_directory)

    return configuration_to_dict(handlers)


def _get_option(target_obj, key):
    """
    Given a target object and option key, get that option from
    the target object, either through a get_{key} method or
    from an attribute directly.
    """
    getter_name = 'get_{key}'.format(**locals())
    by_attribute = functools.partial(getattr, target_obj, key)
    getter = getattr(target_obj, getter_name, by_attribute)
    return getter()


def configuration_to_dict(handlers):
    """Returns configuration data gathered by given handlers as a dict.

    :param list[ConfigHandler] handlers: Handlers list,
        usually from parse_configuration()

    :rtype: dict
    """
    config_dict = defaultdict(dict)

    for handler in handlers:
        for option in handler.set_options:
            value = _get_option(handler.target_obj, option)
            config_dict[handler.section_prefix][option] = value

    return config_dict


def parse_configuration(distribution, command_options, ignore_option_errors=False):
    """Performs additional parsing of configuration options
    for a distribution.

    Returns a list of used option handlers.

    :param Distribution distribution:
    :param dict command_options:
    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.
    :rtype: list
    """
    options = ConfigOptionsHandler(distribution, command_options, ignore_option_errors)
    options.parse()

    meta = ConfigMetadataHandler(
        distribution.metadata,
        command_options,
        ignore_option_errors,
        distribution.package_dir,
    )
    meta.parse()

    return meta, options


class ConfigHandler:
    """Handles metadata supplied in configuration files."""

    section_prefix = None
    """Prefix for config sections handled by this handler.
    Must be provided by class heirs.

    """

    aliases = {}
    """Options aliases.
    For compatibility with various packages. E.g.: d2to1 and pbr.
    Note: `-` in keys is replaced with `_` by config parser.

    """

    def __init__(self, target_obj, options, ignore_option_errors=False):
        sections = {}

        section_prefix = self.section_prefix
        for section_name, section_options in options.items():
            if not section_name.startswith(section_prefix):
                continue

            section_name = section_name.replace(section_prefix, '').strip('.')
            sections[section_name] = section_options

        self.ignore_option_errors = ignore_option_errors
        self.target_obj = target_obj
        self.sections = sections
        self.set_options = []

    @property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        raise NotImplementedError(
            '%s must provide .parsers property' % self.__class__.__name__
        )

    def __setitem__(self, option_name, value):
        unknown = tuple()
        target_obj = self.target_obj

        # Translate alias into real name.
        option_name = self.aliases.get(option_name, option_name)

        current_value = getattr(target_obj, option_name, unknown)

        if current_value is unknown:
            raise KeyError(option_name)

        if current_value:
            # Already inhabited. Skipping.
            return

        skip_option = False
        parser = self.parsers.get(option_name)
        if parser:
            try:
                value = parser(value)

            except Exception:
                skip_option = True
                if not self.ignore_option_errors:
                    raise

        if skip_option:
            return

        setter = getattr(target_obj, 'set_%s' % option_name, None)
        if setter is None:
            setattr(target_obj, option_name, value)
        else:
            setter(value)

        self.set_options.append(option_name)

    @classmethod
    def _parse_list(cls, value, separator=','):
        """Represents value as a list.

        Value is split either by separator (defaults to comma) or by lines.

        :param value:
        :param separator: List items separator character.
        :rtype: list
        """
        if isinstance(value, list):  # _get_parser_compound case
            return value

        if '\n' in value:
            value = value.splitlines()
        else:
            value = value.split(separator)

        return [chunk.strip() for chunk in value if chunk.strip()]

    @classmethod
    def _parse_list_glob(cls, value, separator=','):
        """Equivalent to _parse_list() but expands any glob patterns using glob().

        However, unlike with glob() calls, the results remain relative paths.

        :param value:
        :param separator: List items separator character.
        :rtype: list
        """
        glob_characters = ('*', '?', '[', ']', '{', '}')
        values = cls._parse_list(value, separator=separator)
        expanded_values = []
        for value in values:

            # Has globby characters?
            if any(char in value for char in glob_characters):
                # then expand the glob pattern while keeping paths *relative*:
                expanded_values.extend(sorted(
                    os.path.relpath(path, os.getcwd())
                    for path in iglob(os.path.abspath(value))))

            else:
                # take the value as-is:
                expanded_values.append(value)

        return expanded_values

    @classmethod
    def _parse_dict(cls, value):
        """Represents value as a dict.

        :param value:
        :rtype: dict
        """
        separator = '='
        result = {}
        for line in cls._parse_list(value):
            key, sep, val = line.partition(separator)
            if sep != separator:
                raise DistutilsOptionError(
                    'Unable to parse option value to dict: %s' % value
                )
            result[key.strip()] = val.strip()

        return result

    @classmethod
    def _parse_bool(cls, value):
        """Represents value as boolean.

        :param value:
        :rtype: bool
        """
        value = value.lower()
        return value in ('1', 'true', 'yes')

    @classmethod
    def _exclude_files_parser(cls, key):
        """Returns a parser function to make sure field inputs
        are not files.

        Parses a value after getting the key so error messages are
        more informative.

        :param key:
        :rtype: callable
        """

        def parser(value):
            exclude_directive = 'file:'
            if value.startswith(exclude_directive):
                raise ValueError(
                    'Only strings are accepted for the {0} field, '
                    'files are not accepted'.format(key)
                )
            return value

        return parser

    @classmethod
    def _parse_file(cls, value):
        """Represents value as a string, allowing including text
        from nearest files using `file:` directive.

        Directive is sandboxed and won't reach anything outside
        directory with setup.py.

        Examples:
            file: README.rst, CHANGELOG.md, src/file.txt

        :param str value:
        :rtype: str
        """
        include_directive = 'file:'

        if not isinstance(value, str):
            return value

        if not value.startswith(include_directive):
            return value

        spec = value[len(include_directive) :]
        filepaths = (os.path.abspath(path.strip()) for path in spec.split(','))
        return '\n'.join(
            cls._read_file(path)
            for path in filepaths
            if (cls._assert_local(path) or True) and os.path.isfile(path)
        )

    @staticmethod
    def _assert_local(filepath):
        if not filepath.startswith(os.getcwd()):
            raise DistutilsOptionError('`file:` directive can not access %s' % filepath)

    @staticmethod
    def _read_file(filepath):
        with io.open(filepath, encoding='utf-8') as f:
            return f.read()

    @classmethod
    def _parse_attr(cls, value, package_dir=None):
        """Represents value as a module attribute.

        Examples:
            attr: package.attr
            attr: package.module.attr

        :param str value:
        :rtype: str
        """
        attr_directive = 'attr:'
        if not value.startswith(attr_directive):
            return value

        attrs_path = value.replace(attr_directive, '').strip().split('.')
        attr_name = attrs_path.pop()

        module_name = '.'.join(attrs_path)
        module_name = module_name or '__init__'

        parent_path = os.getcwd()
        if package_dir:
            if attrs_path[0] in package_dir:
                # A custom path was specified for the module we want to import
                custom_path = package_dir[attrs_path[0]]
                parts = custom_path.rsplit('/', 1)
                if len(parts) > 1:
                    parent_path = os.path.join(os.getcwd(), parts[0])
                    module_name = parts[1]
                else:
                    module_name = custom_path
            elif '' in package_dir:
                # A custom parent directory was specified for all root modules
                parent_path = os.path.join(os.getcwd(), package_dir[''])

        with patch_path(parent_path):
            try:
                # attempt to load value statically
                return getattr(StaticModule(module_name), attr_name)
            except Exception:
                # fallback to simple import
                module = importlib.import_module(module_name)

        return getattr(module, attr_name)

    @classmethod
    def _get_parser_compound(cls, *parse_methods):
        """Returns parser function to represents value as a list.

        Parses a value applying given methods one after another.

        :param parse_methods:
        :rtype: callable
        """

        def parse(value):
            parsed = value

            for method in parse_methods:
                parsed = method(parsed)

            return parsed

        return parse

    @classmethod
    def _parse_section_to_dict(cls, section_options, values_parser=None):
        """Parses section options into a dictionary.

        Optionally applies a given parser to values.

        :param dict section_options:
        :param callable values_parser:
        :rtype: dict
        """
        value = {}
        values_parser = values_parser or (lambda val: val)
        for key, (_, val) in section_options.items():
            value[key] = values_parser(val)
        return value

    def parse_section(self, section_options):
        """Parses configuration file section.

        :param dict section_options:
        """
        for (name, (_, value)) in section_options.items():
            try:
                self[name] = value

            except KeyError:
                pass  # Keep silent for a new option may appear anytime.

    def parse(self):
        """Parses configuration file items from one
        or more related sections.

        """
        for section_name, section_options in self.sections.items():

            method_postfix = ''
            if section_name:  # [section.option] variant
                method_postfix = '_%s' % section_name

            section_parser_method = getattr(
                self,
                # Dots in section names are translated into dunderscores.
                ('parse_section%s' % method_postfix).replace('.', '__'),
                None,
            )

            if section_parser_method is None:
                raise DistutilsOptionError(
                    'Unsupported distribution option section: [%s.%s]'
                    % (self.section_prefix, section_name)
                )

            section_parser_method(section_options)

    def _deprecated_config_handler(self, func, msg, warning_class):
        """this function will wrap around parameters that are deprecated

        :param msg: deprecation message
        :param warning_class: class of warning exception to be raised
        :param func: function to be wrapped around
        """

        @wraps(func)
        def config_handler(*args, **kwargs):
            warnings.warn(msg, warning_class)
            return func(*args, **kwargs)

        return config_handler


class ConfigMetadataHandler(ConfigHandler):

    section_prefix = 'metadata'

    aliases = {
        'home_page': 'url',
        'summary': 'description',
        'classifier': 'classifiers',
        'platform': 'platforms',
    }

    strict_mode = False
    """We need to keep it loose, to be partially compatible with
    `pbr` and `d2to1` packages which also uses `metadata` section.

    """

    def __init__(
        self, target_obj, options, ignore_option_errors=False, package_dir=None
    ):
        super(ConfigMetadataHandler, self).__init__(
            target_obj, options, ignore_option_errors
        )
        self.package_dir = package_dir

    @property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        parse_list = self._parse_list
        parse_file = self._parse_file
        parse_dict = self._parse_dict
        exclude_files_parser = self._exclude_files_parser

        return {
            'platforms': parse_list,
            'keywords': parse_list,
            'provides': parse_list,
            'requires': self._deprecated_config_handler(
                parse_list,
                "The requires parameter is deprecated, please use "
                "install_requires for runtime dependencies.",
                DeprecationWarning,
            ),
            'obsoletes': parse_list,
            'classifiers': self._get_parser_compound(parse_file, parse_list),
            'license': exclude_files_parser('license'),
            'license_file': self._deprecated_config_handler(
                exclude_files_parser('license_file'),
                "The license_file parameter is deprecated, "
                "use license_files instead.",
                DeprecationWarning,
            ),
            'license_files': parse_list,
            'description': parse_file,
            'long_description': parse_file,
            'version': self._parse_version,
            'project_urls': parse_dict,
        }

    def _parse_version(self, value):
        """Parses `version` option value.

        :param value:
        :rtype: str

        """
        version = self._parse_file(value)

        if version != value:
            version = version.strip()
            # Be strict about versions loaded from file because it's easy to
            # accidentally include newlines and other unintended content
            try:
                Version(version)
            except InvalidVersion:
                tmpl = (
                    'Version loaded from {value} does not '
                    'comply with PEP 440: {version}'
                )
                raise DistutilsOptionError(tmpl.format(**locals()))

            return version

        version = self._parse_attr(value, self.package_dir)

        if callable(version):
            version = version()

        if not isinstance(version, str):
            if hasattr(version, '__iter__'):
                version = '.'.join(map(str, version))
            else:
                version = '%s' % version

        return version


class ConfigOptionsHandler(ConfigHandler):

    section_prefix = 'options'

    @property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        parse_list = self._parse_list
        parse_list_semicolon = partial(self._parse_list, separator=';')
        parse_bool = self._parse_bool
        parse_dict = self._parse_dict
        parse_cmdclass = self._parse_cmdclass

        return {
            'zip_safe': parse_bool,
            'include_package_data': parse_bool,
            'package_dir': parse_dict,
            'scripts': parse_list,
            'eager_resources': parse_list,
            'dependency_links': parse_list,
            'namespace_packages': parse_list,
            'install_requires': parse_list_semicolon,
            'setup_requires': parse_list_semicolon,
            'tests_require': parse_list_semicolon,
            'packages': self._parse_packages,
            'entry_points': self._parse_file,
            'py_modules': parse_list,
            'python_requires': SpecifierSet,
            'cmdclass': parse_cmdclass,
        }

    def _parse_cmdclass(self, value):
        def resolve_class(qualified_class_name):
            idx = qualified_class_name.rfind('.')
            class_name = qualified_class_name[idx + 1 :]
            pkg_name = qualified_class_name[:idx]

            module = __import__(pkg_name)

            return getattr(module, class_name)

        return {k: resolve_class(v) for k, v in self._parse_dict(value).items()}

    def _parse_packages(self, value):
        """Parses `packages` option value.

        :param value:
        :rtype: list
        """
        find_directives = ['find:', 'find_namespace:']
        trimmed_value = value.strip()

        if trimmed_value not in find_directives:
            return self._parse_list(value)

        findns = trimmed_value == find_directives[1]

        # Read function arguments from a dedicated section.
        find_kwargs = self.parse_section_packages__find(
            self.sections.get('packages.find', {})
        )

        if findns:
            from setuptools import find_namespace_packages as find_packages
        else:
            from setuptools import find_packages

        return find_packages(**find_kwargs)

    def parse_section_packages__find(self, section_options):
        """Parses `packages.find` configuration file section.

        To be used in conjunction with _parse_packages().

        :param dict section_options:
        """
        section_data = self._parse_section_to_dict(section_options, self._parse_list)

        valid_keys = ['where', 'include', 'exclude']

        find_kwargs = dict(
            [(k, v) for k, v in section_data.items() if k in valid_keys and v]
        )

        where = find_kwargs.get('where')
        if where is not None:
            find_kwargs['where'] = where[0]  # cast list to single val

        return find_kwargs

    def parse_section_entry_points(self, section_options):
        """Parses `entry_points` configuration file section.

        :param dict section_options:
        """
        parsed = self._parse_section_to_dict(section_options, self._parse_list)
        self['entry_points'] = parsed

    def _parse_package_data(self, section_options):
        parsed = self._parse_section_to_dict(section_options, self._parse_list)

        root = parsed.get('*')
        if root:
            parsed[''] = root
            del parsed['*']

        return parsed

    def parse_section_package_data(self, section_options):
        """Parses `package_data` configuration file section.

        :param dict section_options:
        """
        self['package_data'] = self._parse_package_data(section_options)

    def parse_section_exclude_package_data(self, section_options):
        """Parses `exclude_package_data` configuration file section.

        :param dict section_options:
        """
        self['exclude_package_data'] = self._parse_package_data(section_options)

    def parse_section_extras_require(self, section_options):
        """Parses `extras_require` configuration file section.

        :param dict section_options:
        """
        parse_list = partial(self._parse_list, separator=';')
        self['extras_require'] = self._parse_section_to_dict(
            section_options, parse_list
        )

    def parse_section_data_files(self, section_options):
        """Parses `data_files` configuration file section.

        :param dict section_options:
        """
        parsed = self._parse_section_to_dict(section_options, self._parse_list_glob)
        self['data_files'] = [(k, v) for k, v in parsed.items()]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/dep_util.py0000644000175100001710000000166500000000000020004 0ustar00runnerdockerfrom distutils.dep_util import newer_group


# yes, this is was almost entirely copy-pasted from
# 'newer_pairwise()', this is just another convenience
# function.
def newer_pairwise_group(sources_groups, targets):
    """Walk both arguments in parallel, testing if each source group is newer
    than its corresponding target. Returns a pair of lists (sources_groups,
    targets) where sources is newer than target, according to the semantics
    of 'newer_group()'.
    """
    if len(sources_groups) != len(targets):
        raise ValueError(
            "'sources_group' and 'targets' must be the same length")

    # build a pair of lists (sources_groups, targets) where source is newer
    n_sources = []
    n_targets = []
    for i in range(len(sources_groups)):
        if newer_group(sources_groups[i], targets[i]):
            n_sources.append(sources_groups[i])
            n_targets.append(targets[i])

    return n_sources, n_targets
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/depends.py0000644000175100001710000001257300000000000017621 0ustar00runnerdockerimport sys
import marshal
import contextlib
import dis

from setuptools.extern.packaging import version

from ._imp import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE
from . import _imp


__all__ = [
    'Require', 'find_module', 'get_module_constant', 'extract_constant'
]


class Require:
    """A prerequisite to building or installing a distribution"""

    def __init__(
            self, name, requested_version, module, homepage='',
            attribute=None, format=None):

        if format is None and requested_version is not None:
            format = version.Version

        if format is not None:
            requested_version = format(requested_version)
            if attribute is None:
                attribute = '__version__'

        self.__dict__.update(locals())
        del self.self

    def full_name(self):
        """Return full package/distribution name, w/version"""
        if self.requested_version is not None:
            return '%s-%s' % (self.name, self.requested_version)
        return self.name

    def version_ok(self, version):
        """Is 'version' sufficiently up-to-date?"""
        return self.attribute is None or self.format is None or \
            str(version) != "unknown" and self.format(version) >= self.requested_version

    def get_version(self, paths=None, default="unknown"):
        """Get version number of installed module, 'None', or 'default'

        Search 'paths' for module.  If not found, return 'None'.  If found,
        return the extracted version attribute, or 'default' if no version
        attribute was specified, or the value cannot be determined without
        importing the module.  The version is formatted according to the
        requirement's version format (if any), unless it is 'None' or the
        supplied 'default'.
        """

        if self.attribute is None:
            try:
                f, p, i = find_module(self.module, paths)
                if f:
                    f.close()
                return default
            except ImportError:
                return None

        v = get_module_constant(self.module, self.attribute, default, paths)

        if v is not None and v is not default and self.format is not None:
            return self.format(v)

        return v

    def is_present(self, paths=None):
        """Return true if dependency is present on 'paths'"""
        return self.get_version(paths) is not None

    def is_current(self, paths=None):
        """Return true if dependency is present and up-to-date on 'paths'"""
        version = self.get_version(paths)
        if version is None:
            return False
        return self.version_ok(str(version))


def maybe_close(f):
    @contextlib.contextmanager
    def empty():
        yield
        return
    if not f:
        return empty()

    return contextlib.closing(f)


def get_module_constant(module, symbol, default=-1, paths=None):
    """Find 'module' by searching 'paths', and extract 'symbol'

    Return 'None' if 'module' does not exist on 'paths', or it does not define
    'symbol'.  If the module defines 'symbol' as a constant, return the
    constant.  Otherwise, return 'default'."""

    try:
        f, path, (suffix, mode, kind) = info = find_module(module, paths)
    except ImportError:
        # Module doesn't exist
        return None

    with maybe_close(f):
        if kind == PY_COMPILED:
            f.read(8)  # skip magic & date
            code = marshal.load(f)
        elif kind == PY_FROZEN:
            code = _imp.get_frozen_object(module, paths)
        elif kind == PY_SOURCE:
            code = compile(f.read(), path, 'exec')
        else:
            # Not something we can parse; we'll have to import it.  :(
            imported = _imp.get_module(module, paths, info)
            return getattr(imported, symbol, None)

    return extract_constant(code, symbol, default)


def extract_constant(code, symbol, default=-1):
    """Extract the constant value of 'symbol' from 'code'

    If the name 'symbol' is bound to a constant value by the Python code
    object 'code', return that value.  If 'symbol' is bound to an expression,
    return 'default'.  Otherwise, return 'None'.

    Return value is based on the first assignment to 'symbol'.  'symbol' must
    be a global, or at least a non-"fast" local in the code block.  That is,
    only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
    must be present in 'code.co_names'.
    """
    if symbol not in code.co_names:
        # name's not there, can't possibly be an assignment
        return None

    name_idx = list(code.co_names).index(symbol)

    STORE_NAME = 90
    STORE_GLOBAL = 97
    LOAD_CONST = 100

    const = default

    for byte_code in dis.Bytecode(code):
        op = byte_code.opcode
        arg = byte_code.arg

        if op == LOAD_CONST:
            const = code.co_consts[arg]
        elif arg == name_idx and (op == STORE_NAME or op == STORE_GLOBAL):
            return const
        else:
            const = default


def _update_globals():
    """
    Patch the globals to remove the objects not available on some platforms.

    XXX it'd be better to test assertions about bytecode instead.
    """

    if not sys.platform.startswith('java') and sys.platform != 'cli':
        return
    incompatible = 'extract_constant', 'get_module_constant'
    for name in incompatible:
        del globals()[name]
        __all__.remove(name)


_update_globals()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/dist.py0000644000175100001710000012422200000000000017135 0ustar00runnerdocker# -*- coding: utf-8 -*-
__all__ = ['Distribution']

import io
import sys
import re
import os
import warnings
import numbers
import distutils.log
import distutils.core
import distutils.cmd
import distutils.dist
import distutils.command
from distutils.util import strtobool
from distutils.debug import DEBUG
from distutils.fancy_getopt import translate_longopt
from glob import iglob
import itertools
import textwrap
from typing import List, Optional, TYPE_CHECKING

from collections import defaultdict
from email import message_from_file

from distutils.errors import DistutilsOptionError, DistutilsSetupError
from distutils.util import rfc822_escape

from setuptools.extern import packaging
from setuptools.extern import ordered_set
from setuptools.extern.more_itertools import unique_everseen

from . import SetuptoolsDeprecationWarning

import setuptools
import setuptools.command
from setuptools import windows_support
from setuptools.monkey import get_unpatched
from setuptools.config import parse_configuration
import pkg_resources
from setuptools.extern.packaging import version

if TYPE_CHECKING:
    from email.message import Message

__import__('setuptools.extern.packaging.specifiers')
__import__('setuptools.extern.packaging.version')


def _get_unpatched(cls):
    warnings.warn("Do not call this function", DistDeprecationWarning)
    return get_unpatched(cls)


def get_metadata_version(self):
    mv = getattr(self, 'metadata_version', None)
    if mv is None:
        mv = version.Version('2.1')
        self.metadata_version = mv
    return mv


def rfc822_unescape(content: str) -> str:
    """Reverse RFC-822 escaping by removing leading whitespaces from content."""
    lines = content.splitlines()
    if len(lines) == 1:
        return lines[0].lstrip()
    return '\n'.join((lines[0].lstrip(), textwrap.dedent('\n'.join(lines[1:]))))


def _read_field_from_msg(msg: "Message", field: str) -> Optional[str]:
    """Read Message header field."""
    value = msg[field]
    if value == 'UNKNOWN':
        return None
    return value


def _read_field_unescaped_from_msg(msg: "Message", field: str) -> Optional[str]:
    """Read Message header field and apply rfc822_unescape."""
    value = _read_field_from_msg(msg, field)
    if value is None:
        return value
    return rfc822_unescape(value)


def _read_list_from_msg(msg: "Message", field: str) -> Optional[List[str]]:
    """Read Message header field and return all results as list."""
    values = msg.get_all(field, None)
    if values == []:
        return None
    return values


def _read_payload_from_msg(msg: "Message") -> Optional[str]:
    value = msg.get_payload().strip()
    if value == 'UNKNOWN':
        return None
    return value


def read_pkg_file(self, file):
    """Reads the metadata values from a file object."""
    msg = message_from_file(file)

    self.metadata_version = version.Version(msg['metadata-version'])
    self.name = _read_field_from_msg(msg, 'name')
    self.version = _read_field_from_msg(msg, 'version')
    self.description = _read_field_from_msg(msg, 'summary')
    # we are filling author only.
    self.author = _read_field_from_msg(msg, 'author')
    self.maintainer = None
    self.author_email = _read_field_from_msg(msg, 'author-email')
    self.maintainer_email = None
    self.url = _read_field_from_msg(msg, 'home-page')
    self.license = _read_field_unescaped_from_msg(msg, 'license')

    if 'download-url' in msg:
        self.download_url = _read_field_from_msg(msg, 'download-url')
    else:
        self.download_url = None

    self.long_description = _read_field_unescaped_from_msg(msg, 'description')
    if (
        self.long_description is None and
        self.metadata_version >= version.Version('2.1')
    ):
        self.long_description = _read_payload_from_msg(msg)
    self.description = _read_field_from_msg(msg, 'summary')

    if 'keywords' in msg:
        self.keywords = _read_field_from_msg(msg, 'keywords').split(',')

    self.platforms = _read_list_from_msg(msg, 'platform')
    self.classifiers = _read_list_from_msg(msg, 'classifier')

    # PEP 314 - these fields only exist in 1.1
    if self.metadata_version == version.Version('1.1'):
        self.requires = _read_list_from_msg(msg, 'requires')
        self.provides = _read_list_from_msg(msg, 'provides')
        self.obsoletes = _read_list_from_msg(msg, 'obsoletes')
    else:
        self.requires = None
        self.provides = None
        self.obsoletes = None

    self.license_files = _read_list_from_msg(msg, 'license-file')


def single_line(val):
    """
    Quick and dirty validation for Summary pypa/setuptools#1390.
    """
    if '\n' in val:
        # TODO: Replace with `raise ValueError("newlines not allowed")`
        # after reviewing #2893.
        warnings.warn("newlines not allowed and will break in the future")
        val = val.strip().split('\n')[0]
    return val


# Based on Python 3.5 version
def write_pkg_file(self, file):  # noqa: C901  # is too complex (14)  # FIXME
    """Write the PKG-INFO format data to a file object."""
    version = self.get_metadata_version()

    def write_field(key, value):
        file.write("%s: %s\n" % (key, value))

    write_field('Metadata-Version', str(version))
    write_field('Name', self.get_name())
    write_field('Version', self.get_version())
    write_field('Summary', single_line(self.get_description()))
    write_field('Home-page', self.get_url())

    optional_fields = (
        ('Author', 'author'),
        ('Author-email', 'author_email'),
        ('Maintainer', 'maintainer'),
        ('Maintainer-email', 'maintainer_email'),
    )

    for field, attr in optional_fields:
        attr_val = getattr(self, attr, None)
        if attr_val is not None:
            write_field(field, attr_val)

    license = rfc822_escape(self.get_license())
    write_field('License', license)
    if self.download_url:
        write_field('Download-URL', self.download_url)
    for project_url in self.project_urls.items():
        write_field('Project-URL', '%s, %s' % project_url)

    keywords = ','.join(self.get_keywords())
    if keywords:
        write_field('Keywords', keywords)

    for platform in self.get_platforms():
        write_field('Platform', platform)

    self._write_list(file, 'Classifier', self.get_classifiers())

    # PEP 314
    self._write_list(file, 'Requires', self.get_requires())
    self._write_list(file, 'Provides', self.get_provides())
    self._write_list(file, 'Obsoletes', self.get_obsoletes())

    # Setuptools specific for PEP 345
    if hasattr(self, 'python_requires'):
        write_field('Requires-Python', self.python_requires)

    # PEP 566
    if self.long_description_content_type:
        write_field('Description-Content-Type', self.long_description_content_type)
    if self.provides_extras:
        for extra in self.provides_extras:
            write_field('Provides-Extra', extra)

    self._write_list(file, 'License-File', self.license_files or [])

    file.write("\n%s\n\n" % self.get_long_description())


sequence = tuple, list


def check_importable(dist, attr, value):
    try:
        ep = pkg_resources.EntryPoint.parse('x=' + value)
        assert not ep.extras
    except (TypeError, ValueError, AttributeError, AssertionError) as e:
        raise DistutilsSetupError(
            "%r must be importable 'module:attrs' string (got %r)" % (attr, value)
        ) from e


def assert_string_list(dist, attr, value):
    """Verify that value is a string list"""
    try:
        # verify that value is a list or tuple to exclude unordered
        # or single-use iterables
        assert isinstance(value, (list, tuple))
        # verify that elements of value are strings
        assert ''.join(value) != value
    except (TypeError, ValueError, AttributeError, AssertionError) as e:
        raise DistutilsSetupError(
            "%r must be a list of strings (got %r)" % (attr, value)
        ) from e


def check_nsp(dist, attr, value):
    """Verify that namespace packages are valid"""
    ns_packages = value
    assert_string_list(dist, attr, ns_packages)
    for nsp in ns_packages:
        if not dist.has_contents_for(nsp):
            raise DistutilsSetupError(
                "Distribution contains no modules or packages for "
                + "namespace package %r" % nsp
            )
        parent, sep, child = nsp.rpartition('.')
        if parent and parent not in ns_packages:
            distutils.log.warn(
                "WARNING: %r is declared as a package namespace, but %r"
                " is not: please correct this in setup.py",
                nsp,
                parent,
            )


def check_extras(dist, attr, value):
    """Verify that extras_require mapping is valid"""
    try:
        list(itertools.starmap(_check_extra, value.items()))
    except (TypeError, ValueError, AttributeError) as e:
        raise DistutilsSetupError(
            "'extras_require' must be a dictionary whose values are "
            "strings or lists of strings containing valid project/version "
            "requirement specifiers."
        ) from e


def _check_extra(extra, reqs):
    name, sep, marker = extra.partition(':')
    if marker and pkg_resources.invalid_marker(marker):
        raise DistutilsSetupError("Invalid environment marker: " + marker)
    list(pkg_resources.parse_requirements(reqs))


def assert_bool(dist, attr, value):
    """Verify that value is True, False, 0, or 1"""
    if bool(value) != value:
        tmpl = "{attr!r} must be a boolean value (got {value!r})"
        raise DistutilsSetupError(tmpl.format(attr=attr, value=value))


def invalid_unless_false(dist, attr, value):
    if not value:
        warnings.warn(f"{attr} is ignored.", DistDeprecationWarning)
        return
    raise DistutilsSetupError(f"{attr} is invalid.")


def check_requirements(dist, attr, value):
    """Verify that install_requires is a valid requirements list"""
    try:
        list(pkg_resources.parse_requirements(value))
        if isinstance(value, (dict, set)):
            raise TypeError("Unordered types are not allowed")
    except (TypeError, ValueError) as error:
        tmpl = (
            "{attr!r} must be a string or list of strings "
            "containing valid project/version requirement specifiers; {error}"
        )
        raise DistutilsSetupError(tmpl.format(attr=attr, error=error)) from error


def check_specifier(dist, attr, value):
    """Verify that value is a valid version specifier"""
    try:
        packaging.specifiers.SpecifierSet(value)
    except (packaging.specifiers.InvalidSpecifier, AttributeError) as error:
        tmpl = (
            "{attr!r} must be a string " "containing valid version specifiers; {error}"
        )
        raise DistutilsSetupError(tmpl.format(attr=attr, error=error)) from error


def check_entry_points(dist, attr, value):
    """Verify that entry_points map is parseable"""
    try:
        pkg_resources.EntryPoint.parse_map(value)
    except ValueError as e:
        raise DistutilsSetupError(e) from e


def check_test_suite(dist, attr, value):
    if not isinstance(value, str):
        raise DistutilsSetupError("test_suite must be a string")


def check_package_data(dist, attr, value):
    """Verify that value is a dictionary of package names to glob lists"""
    if not isinstance(value, dict):
        raise DistutilsSetupError(
            "{!r} must be a dictionary mapping package names to lists of "
            "string wildcard patterns".format(attr)
        )
    for k, v in value.items():
        if not isinstance(k, str):
            raise DistutilsSetupError(
                "keys of {!r} dict must be strings (got {!r})".format(attr, k)
            )
        assert_string_list(dist, 'values of {!r} dict'.format(attr), v)


def check_packages(dist, attr, value):
    for pkgname in value:
        if not re.match(r'\w+(\.\w+)*', pkgname):
            distutils.log.warn(
                "WARNING: %r not a valid package name; please use only "
                ".-separated package names in setup.py",
                pkgname,
            )


_Distribution = get_unpatched(distutils.core.Distribution)


class Distribution(_Distribution):
    """Distribution with support for tests and package data

    This is an enhanced version of 'distutils.dist.Distribution' that
    effectively adds the following new optional keyword arguments to 'setup()':

     'install_requires' -- a string or sequence of strings specifying project
        versions that the distribution requires when installed, in the format
        used by 'pkg_resources.require()'.  They will be installed
        automatically when the package is installed.  If you wish to use
        packages that are not available in PyPI, or want to give your users an
        alternate download location, you can add a 'find_links' option to the
        '[easy_install]' section of your project's 'setup.cfg' file, and then
        setuptools will scan the listed web pages for links that satisfy the
        requirements.

     'extras_require' -- a dictionary mapping names of optional "extras" to the
        additional requirement(s) that using those extras incurs. For example,
        this::

            extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])

        indicates that the distribution can optionally provide an extra
        capability called "reST", but it can only be used if docutils and
        reSTedit are installed.  If the user installs your package using
        EasyInstall and requests one of your extras, the corresponding
        additional requirements will be installed if needed.

     'test_suite' -- the name of a test suite to run for the 'test' command.
        If the user runs 'python setup.py test', the package will be installed,
        and the named test suite will be run.  The format is the same as
        would be used on a 'unittest.py' command line.  That is, it is the
        dotted name of an object to import and call to generate a test suite.

     'package_data' -- a dictionary mapping package names to lists of filenames
        or globs to use to find data files contained in the named packages.
        If the dictionary has filenames or globs listed under '""' (the empty
        string), those names will be searched for in every package, in addition
        to any names for the specific package.  Data files found using these
        names/globs will be installed along with the package, in the same
        location as the package.  Note that globs are allowed to reference
        the contents of non-package subdirectories, as long as you use '/' as
        a path separator.  (Globs are automatically converted to
        platform-specific paths at runtime.)

    In addition to these new keywords, this class also has several new methods
    for manipulating the distribution's contents.  For example, the 'include()'
    and 'exclude()' methods can be thought of as in-place add and subtract
    commands that add or remove packages, modules, extensions, and so on from
    the distribution.
    """

    _DISTUTILS_UNSUPPORTED_METADATA = {
        'long_description_content_type': lambda: None,
        'project_urls': dict,
        'provides_extras': ordered_set.OrderedSet,
        'license_file': lambda: None,
        'license_files': lambda: None,
    }

    _patched_dist = None

    def patch_missing_pkg_info(self, attrs):
        # Fake up a replacement for the data that would normally come from
        # PKG-INFO, but which might not yet be built if this is a fresh
        # checkout.
        #
        if not attrs or 'name' not in attrs or 'version' not in attrs:
            return
        key = pkg_resources.safe_name(str(attrs['name'])).lower()
        dist = pkg_resources.working_set.by_key.get(key)
        if dist is not None and not dist.has_metadata('PKG-INFO'):
            dist._version = pkg_resources.safe_version(str(attrs['version']))
            self._patched_dist = dist

    def __init__(self, attrs=None):
        have_package_data = hasattr(self, "package_data")
        if not have_package_data:
            self.package_data = {}
        attrs = attrs or {}
        self.dist_files = []
        # Filter-out setuptools' specific options.
        self.src_root = attrs.pop("src_root", None)
        self.patch_missing_pkg_info(attrs)
        self.dependency_links = attrs.pop('dependency_links', [])
        self.setup_requires = attrs.pop('setup_requires', [])
        for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
            vars(self).setdefault(ep.name, None)
        _Distribution.__init__(
            self,
            {
                k: v
                for k, v in attrs.items()
                if k not in self._DISTUTILS_UNSUPPORTED_METADATA
            },
        )

        self._set_metadata_defaults(attrs)

        self.metadata.version = self._normalize_version(
            self._validate_version(self.metadata.version)
        )
        self._finalize_requires()

    def _set_metadata_defaults(self, attrs):
        """
        Fill-in missing metadata fields not supported by distutils.
        Some fields may have been set by other tools (e.g. pbr).
        Those fields (vars(self.metadata)) take precedence to
        supplied attrs.
        """
        for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items():
            vars(self.metadata).setdefault(option, attrs.get(option, default()))

    @staticmethod
    def _normalize_version(version):
        if isinstance(version, setuptools.sic) or version is None:
            return version

        normalized = str(packaging.version.Version(version))
        if version != normalized:
            tmpl = "Normalizing '{version}' to '{normalized}'"
            warnings.warn(tmpl.format(**locals()))
            return normalized
        return version

    @staticmethod
    def _validate_version(version):
        if isinstance(version, numbers.Number):
            # Some people apparently take "version number" too literally :)
            version = str(version)

        if version is not None:
            try:
                packaging.version.Version(version)
            except (packaging.version.InvalidVersion, TypeError):
                warnings.warn(
                    "The version specified (%r) is an invalid version, this "
                    "may not work as expected with newer versions of "
                    "setuptools, pip, and PyPI. Please see PEP 440 for more "
                    "details." % version
                )
                return setuptools.sic(version)
        return version

    def _finalize_requires(self):
        """
        Set `metadata.python_requires` and fix environment markers
        in `install_requires` and `extras_require`.
        """
        if getattr(self, 'python_requires', None):
            self.metadata.python_requires = self.python_requires

        if getattr(self, 'extras_require', None):
            for extra in self.extras_require.keys():
                # Since this gets called multiple times at points where the
                # keys have become 'converted' extras, ensure that we are only
                # truly adding extras we haven't seen before here.
                extra = extra.split(':')[0]
                if extra:
                    self.metadata.provides_extras.add(extra)

        self._convert_extras_requirements()
        self._move_install_requirements_markers()

    def _convert_extras_requirements(self):
        """
        Convert requirements in `extras_require` of the form
        `"extra": ["barbazquux; {marker}"]` to
        `"extra:{marker}": ["barbazquux"]`.
        """
        spec_ext_reqs = getattr(self, 'extras_require', None) or {}
        self._tmp_extras_require = defaultdict(list)
        for section, v in spec_ext_reqs.items():
            # Do not strip empty sections.
            self._tmp_extras_require[section]
            for r in pkg_resources.parse_requirements(v):
                suffix = self._suffix_for(r)
                self._tmp_extras_require[section + suffix].append(r)

    @staticmethod
    def _suffix_for(req):
        """
        For a requirement, return the 'extras_require' suffix for
        that requirement.
        """
        return ':' + str(req.marker) if req.marker else ''

    def _move_install_requirements_markers(self):
        """
        Move requirements in `install_requires` that are using environment
        markers `extras_require`.
        """

        # divide the install_requires into two sets, simple ones still
        # handled by install_requires and more complex ones handled
        # by extras_require.

        def is_simple_req(req):
            return not req.marker

        spec_inst_reqs = getattr(self, 'install_requires', None) or ()
        inst_reqs = list(pkg_resources.parse_requirements(spec_inst_reqs))
        simple_reqs = filter(is_simple_req, inst_reqs)
        complex_reqs = itertools.filterfalse(is_simple_req, inst_reqs)
        self.install_requires = list(map(str, simple_reqs))

        for r in complex_reqs:
            self._tmp_extras_require[':' + str(r.marker)].append(r)
        self.extras_require = dict(
            (k, [str(r) for r in map(self._clean_req, v)])
            for k, v in self._tmp_extras_require.items()
        )

    def _clean_req(self, req):
        """
        Given a Requirement, remove environment markers and return it.
        """
        req.marker = None
        return req

    def _finalize_license_files(self):
        """Compute names of all license files which should be included."""
        license_files: Optional[List[str]] = self.metadata.license_files
        patterns: List[str] = license_files if license_files else []

        license_file: Optional[str] = self.metadata.license_file
        if license_file and license_file not in patterns:
            patterns.append(license_file)

        if license_files is None and license_file is None:
            # Default patterns match the ones wheel uses
            # See https://wheel.readthedocs.io/en/stable/user_guide.html
            # -> 'Including license files in the generated wheel file'
            patterns = ('LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*')

        self.metadata.license_files = list(
            unique_everseen(self._expand_patterns(patterns))
        )

    @staticmethod
    def _expand_patterns(patterns):
        """
        >>> list(Distribution._expand_patterns(['LICENSE']))
        ['LICENSE']
        >>> list(Distribution._expand_patterns(['setup.cfg', 'LIC*']))
        ['setup.cfg', 'LICENSE']
        """
        return (
            path
            for pattern in patterns
            for path in sorted(iglob(pattern))
            if not path.endswith('~') and os.path.isfile(path)
        )

    # FIXME: 'Distribution._parse_config_files' is too complex (14)
    def _parse_config_files(self, filenames=None):  # noqa: C901
        """
        Adapted from distutils.dist.Distribution.parse_config_files,
        this method provides the same functionality in subtly-improved
        ways.
        """
        from configparser import ConfigParser

        # Ignore install directory options if we have a venv
        ignore_options = (
            []
            if sys.prefix == sys.base_prefix
            else [
                'install-base',
                'install-platbase',
                'install-lib',
                'install-platlib',
                'install-purelib',
                'install-headers',
                'install-scripts',
                'install-data',
                'prefix',
                'exec-prefix',
                'home',
                'user',
                'root',
            ]
        )

        ignore_options = frozenset(ignore_options)

        if filenames is None:
            filenames = self.find_config_files()

        if DEBUG:
            self.announce("Distribution.parse_config_files():")

        parser = ConfigParser()
        parser.optionxform = str
        for filename in filenames:
            with io.open(filename, encoding='utf-8') as reader:
                if DEBUG:
                    self.announce("  reading {filename}".format(**locals()))
                parser.read_file(reader)
            for section in parser.sections():
                options = parser.options(section)
                opt_dict = self.get_option_dict(section)

                for opt in options:
                    if opt == '__name__' or opt in ignore_options:
                        continue

                    val = parser.get(section, opt)
                    opt = self.warn_dash_deprecation(opt, section)
                    opt = self.make_option_lowercase(opt, section)
                    opt_dict[opt] = (filename, val)

            # Make the ConfigParser forget everything (so we retain
            # the original filenames that options come from)
            parser.__init__()

        if 'global' not in self.command_options:
            return

        # If there was a "global" section in the config file, use it
        # to set Distribution options.

        for (opt, (src, val)) in self.command_options['global'].items():
            alias = self.negative_opt.get(opt)
            if alias:
                val = not strtobool(val)
            elif opt in ('verbose', 'dry_run'):  # ugh!
                val = strtobool(val)

            try:
                setattr(self, alias or opt, val)
            except ValueError as e:
                raise DistutilsOptionError(e) from e

    def warn_dash_deprecation(self, opt, section):
        if section in (
            'options.extras_require',
            'options.data_files',
        ):
            return opt

        underscore_opt = opt.replace('-', '_')
        commands = distutils.command.__all__ + self._setuptools_commands()
        if (
            not section.startswith('options')
            and section != 'metadata'
            and section not in commands
        ):
            return underscore_opt

        if '-' in opt:
            warnings.warn(
                "Usage of dash-separated '%s' will not be supported in future "
                "versions. Please use the underscore name '%s' instead"
                % (opt, underscore_opt)
            )
        return underscore_opt

    def _setuptools_commands(self):
        try:
            dist = pkg_resources.get_distribution('setuptools')
            return list(dist.get_entry_map('distutils.commands'))
        except pkg_resources.DistributionNotFound:
            # during bootstrapping, distribution doesn't exist
            return []

    def make_option_lowercase(self, opt, section):
        if section != 'metadata' or opt.islower():
            return opt

        lowercase_opt = opt.lower()
        warnings.warn(
            "Usage of uppercase key '%s' in '%s' will be deprecated in future "
            "versions. Please use lowercase '%s' instead"
            % (opt, section, lowercase_opt)
        )
        return lowercase_opt

    # FIXME: 'Distribution._set_command_options' is too complex (14)
    def _set_command_options(self, command_obj, option_dict=None):  # noqa: C901
        """
        Set the options for 'command_obj' from 'option_dict'.  Basically
        this means copying elements of a dictionary ('option_dict') to
        attributes of an instance ('command').

        'command_obj' must be a Command instance.  If 'option_dict' is not
        supplied, uses the standard option dictionary for this command
        (from 'self.command_options').

        (Adopted from distutils.dist.Distribution._set_command_options)
        """
        command_name = command_obj.get_command_name()
        if option_dict is None:
            option_dict = self.get_option_dict(command_name)

        if DEBUG:
            self.announce("  setting options for '%s' command:" % command_name)
        for (option, (source, value)) in option_dict.items():
            if DEBUG:
                self.announce("    %s = %s (from %s)" % (option, value, source))
            try:
                bool_opts = [translate_longopt(o) for o in command_obj.boolean_options]
            except AttributeError:
                bool_opts = []
            try:
                neg_opt = command_obj.negative_opt
            except AttributeError:
                neg_opt = {}

            try:
                is_string = isinstance(value, str)
                if option in neg_opt and is_string:
                    setattr(command_obj, neg_opt[option], not strtobool(value))
                elif option in bool_opts and is_string:
                    setattr(command_obj, option, strtobool(value))
                elif hasattr(command_obj, option):
                    setattr(command_obj, option, value)
                else:
                    raise DistutilsOptionError(
                        "error in %s: command '%s' has no such option '%s'"
                        % (source, command_name, option)
                    )
            except ValueError as e:
                raise DistutilsOptionError(e) from e

    def parse_config_files(self, filenames=None, ignore_option_errors=False):
        """Parses configuration files from various levels
        and loads configuration.

        """
        self._parse_config_files(filenames=filenames)

        parse_configuration(
            self, self.command_options, ignore_option_errors=ignore_option_errors
        )
        self._finalize_requires()
        self._finalize_license_files()

    def fetch_build_eggs(self, requires):
        """Resolve pre-setup requirements"""
        resolved_dists = pkg_resources.working_set.resolve(
            pkg_resources.parse_requirements(requires),
            installer=self.fetch_build_egg,
            replace_conflicting=True,
        )
        for dist in resolved_dists:
            pkg_resources.working_set.add(dist, replace=True)
        return resolved_dists

    def finalize_options(self):
        """
        Allow plugins to apply arbitrary operations to the
        distribution. Each hook may optionally define a 'order'
        to influence the order of execution. Smaller numbers
        go first and the default is 0.
        """
        group = 'setuptools.finalize_distribution_options'

        def by_order(hook):
            return getattr(hook, 'order', 0)

        defined = pkg_resources.iter_entry_points(group)
        filtered = itertools.filterfalse(self._removed, defined)
        loaded = map(lambda e: e.load(), filtered)
        for ep in sorted(loaded, key=by_order):
            ep(self)

    @staticmethod
    def _removed(ep):
        """
        When removing an entry point, if metadata is loaded
        from an older version of Setuptools, that removed
        entry point will attempt to be loaded and will fail.
        See #2765 for more details.
        """
        removed = {
            # removed 2021-09-05
            '2to3_doctests',
        }
        return ep.name in removed

    def _finalize_setup_keywords(self):
        for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
            value = getattr(self, ep.name, None)
            if value is not None:
                ep.require(installer=self.fetch_build_egg)
                ep.load()(self, ep.name, value)

    def get_egg_cache_dir(self):
        egg_cache_dir = os.path.join(os.curdir, '.eggs')
        if not os.path.exists(egg_cache_dir):
            os.mkdir(egg_cache_dir)
            windows_support.hide_file(egg_cache_dir)
            readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
            with open(readme_txt_filename, 'w') as f:
                f.write(
                    'This directory contains eggs that were downloaded '
                    'by setuptools to build, test, and run plug-ins.\n\n'
                )
                f.write(
                    'This directory caches those eggs to prevent '
                    'repeated downloads.\n\n'
                )
                f.write('However, it is safe to delete this directory.\n\n')

        return egg_cache_dir

    def fetch_build_egg(self, req):
        """Fetch an egg needed for building"""
        from setuptools.installer import fetch_build_egg

        return fetch_build_egg(self, req)

    def get_command_class(self, command):
        """Pluggable version of get_command_class()"""
        if command in self.cmdclass:
            return self.cmdclass[command]

        eps = pkg_resources.iter_entry_points('distutils.commands', command)
        for ep in eps:
            ep.require(installer=self.fetch_build_egg)
            self.cmdclass[command] = cmdclass = ep.load()
            return cmdclass
        else:
            return _Distribution.get_command_class(self, command)

    def print_commands(self):
        for ep in pkg_resources.iter_entry_points('distutils.commands'):
            if ep.name not in self.cmdclass:
                # don't require extras as the commands won't be invoked
                cmdclass = ep.resolve()
                self.cmdclass[ep.name] = cmdclass
        return _Distribution.print_commands(self)

    def get_command_list(self):
        for ep in pkg_resources.iter_entry_points('distutils.commands'):
            if ep.name not in self.cmdclass:
                # don't require extras as the commands won't be invoked
                cmdclass = ep.resolve()
                self.cmdclass[ep.name] = cmdclass
        return _Distribution.get_command_list(self)

    def include(self, **attrs):
        """Add items to distribution that are named in keyword arguments

        For example, 'dist.include(py_modules=["x"])' would add 'x' to
        the distribution's 'py_modules' attribute, if it was not already
        there.

        Currently, this method only supports inclusion for attributes that are
        lists or tuples.  If you need to add support for adding to other
        attributes in this or a subclass, you can add an '_include_X' method,
        where 'X' is the name of the attribute.  The method will be called with
        the value passed to 'include()'.  So, 'dist.include(foo={"bar":"baz"})'
        will try to call 'dist._include_foo({"bar":"baz"})', which can then
        handle whatever special inclusion logic is needed.
        """
        for k, v in attrs.items():
            include = getattr(self, '_include_' + k, None)
            if include:
                include(v)
            else:
                self._include_misc(k, v)

    def exclude_package(self, package):
        """Remove packages, modules, and extensions in named package"""

        pfx = package + '.'
        if self.packages:
            self.packages = [
                p for p in self.packages if p != package and not p.startswith(pfx)
            ]

        if self.py_modules:
            self.py_modules = [
                p for p in self.py_modules if p != package and not p.startswith(pfx)
            ]

        if self.ext_modules:
            self.ext_modules = [
                p
                for p in self.ext_modules
                if p.name != package and not p.name.startswith(pfx)
            ]

    def has_contents_for(self, package):
        """Return true if 'exclude_package(package)' would do something"""

        pfx = package + '.'

        for p in self.iter_distribution_names():
            if p == package or p.startswith(pfx):
                return True

    def _exclude_misc(self, name, value):
        """Handle 'exclude()' for list/tuple attrs without a special handler"""
        if not isinstance(value, sequence):
            raise DistutilsSetupError(
                "%s: setting must be a list or tuple (%r)" % (name, value)
            )
        try:
            old = getattr(self, name)
        except AttributeError as e:
            raise DistutilsSetupError("%s: No such distribution setting" % name) from e
        if old is not None and not isinstance(old, sequence):
            raise DistutilsSetupError(
                name + ": this setting cannot be changed via include/exclude"
            )
        elif old:
            setattr(self, name, [item for item in old if item not in value])

    def _include_misc(self, name, value):
        """Handle 'include()' for list/tuple attrs without a special handler"""

        if not isinstance(value, sequence):
            raise DistutilsSetupError("%s: setting must be a list (%r)" % (name, value))
        try:
            old = getattr(self, name)
        except AttributeError as e:
            raise DistutilsSetupError("%s: No such distribution setting" % name) from e
        if old is None:
            setattr(self, name, value)
        elif not isinstance(old, sequence):
            raise DistutilsSetupError(
                name + ": this setting cannot be changed via include/exclude"
            )
        else:
            new = [item for item in value if item not in old]
            setattr(self, name, old + new)

    def exclude(self, **attrs):
        """Remove items from distribution that are named in keyword arguments

        For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
        the distribution's 'py_modules' attribute.  Excluding packages uses
        the 'exclude_package()' method, so all of the package's contained
        packages, modules, and extensions are also excluded.

        Currently, this method only supports exclusion from attributes that are
        lists or tuples.  If you need to add support for excluding from other
        attributes in this or a subclass, you can add an '_exclude_X' method,
        where 'X' is the name of the attribute.  The method will be called with
        the value passed to 'exclude()'.  So, 'dist.exclude(foo={"bar":"baz"})'
        will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
        handle whatever special exclusion logic is needed.
        """
        for k, v in attrs.items():
            exclude = getattr(self, '_exclude_' + k, None)
            if exclude:
                exclude(v)
            else:
                self._exclude_misc(k, v)

    def _exclude_packages(self, packages):
        if not isinstance(packages, sequence):
            raise DistutilsSetupError(
                "packages: setting must be a list or tuple (%r)" % (packages,)
            )
        list(map(self.exclude_package, packages))

    def _parse_command_opts(self, parser, args):
        # Remove --with-X/--without-X options when processing command args
        self.global_options = self.__class__.global_options
        self.negative_opt = self.__class__.negative_opt

        # First, expand any aliases
        command = args[0]
        aliases = self.get_option_dict('aliases')
        while command in aliases:
            src, alias = aliases[command]
            del aliases[command]  # ensure each alias can expand only once!
            import shlex

            args[:1] = shlex.split(alias, True)
            command = args[0]

        nargs = _Distribution._parse_command_opts(self, parser, args)

        # Handle commands that want to consume all remaining arguments
        cmd_class = self.get_command_class(command)
        if getattr(cmd_class, 'command_consumes_arguments', None):
            self.get_option_dict(command)['args'] = ("command line", nargs)
            if nargs is not None:
                return []

        return nargs

    def get_cmdline_options(self):
        """Return a '{cmd: {opt:val}}' map of all command-line options

        Option names are all long, but do not include the leading '--', and
        contain dashes rather than underscores.  If the option doesn't take
        an argument (e.g. '--quiet'), the 'val' is 'None'.

        Note that options provided by config files are intentionally excluded.
        """

        d = {}

        for cmd, opts in self.command_options.items():

            for opt, (src, val) in opts.items():

                if src != "command line":
                    continue

                opt = opt.replace('_', '-')

                if val == 0:
                    cmdobj = self.get_command_obj(cmd)
                    neg_opt = self.negative_opt.copy()
                    neg_opt.update(getattr(cmdobj, 'negative_opt', {}))
                    for neg, pos in neg_opt.items():
                        if pos == opt:
                            opt = neg
                            val = None
                            break
                    else:
                        raise AssertionError("Shouldn't be able to get here")

                elif val == 1:
                    val = None

                d.setdefault(cmd, {})[opt] = val

        return d

    def iter_distribution_names(self):
        """Yield all packages, modules, and extension names in distribution"""

        for pkg in self.packages or ():
            yield pkg

        for module in self.py_modules or ():
            yield module

        for ext in self.ext_modules or ():
            if isinstance(ext, tuple):
                name, buildinfo = ext
            else:
                name = ext.name
            if name.endswith('module'):
                name = name[:-6]
            yield name

    def handle_display_options(self, option_order):
        """If there were any non-global "display-only" options
        (--help-commands or the metadata display options) on the command
        line, display the requested info and return true; else return
        false.
        """
        import sys

        if self.help_commands:
            return _Distribution.handle_display_options(self, option_order)

        # Stdout may be StringIO (e.g. in tests)
        if not isinstance(sys.stdout, io.TextIOWrapper):
            return _Distribution.handle_display_options(self, option_order)

        # Don't wrap stdout if utf-8 is already the encoding. Provides
        #  workaround for #334.
        if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
            return _Distribution.handle_display_options(self, option_order)

        # Print metadata in UTF-8 no matter the platform
        encoding = sys.stdout.encoding
        errors = sys.stdout.errors
        newline = sys.platform != 'win32' and '\n' or None
        line_buffering = sys.stdout.line_buffering

        sys.stdout = io.TextIOWrapper(
            sys.stdout.detach(), 'utf-8', errors, newline, line_buffering
        )
        try:
            return _Distribution.handle_display_options(self, option_order)
        finally:
            sys.stdout = io.TextIOWrapper(
                sys.stdout.detach(), encoding, errors, newline, line_buffering
            )


class DistDeprecationWarning(SetuptoolsDeprecationWarning):
    """Class for warning about deprecations in dist in
    setuptools. Not ignored by default, unlike DeprecationWarning."""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/errors.py0000644000175100001710000000302300000000000017501 0ustar00runnerdocker"""setuptools.errors

Provides exceptions used by setuptools modules.
"""

from distutils import errors as _distutils_errors
from distutils.errors import DistutilsError


class RemovedCommandError(DistutilsError, RuntimeError):
    """Error used for commands that have been removed in setuptools.

    Since ``setuptools`` is built on ``distutils``, simply removing a command
    from ``setuptools`` will make the behavior fall back to ``distutils``; this
    error is raised if a command exists in ``distutils`` but has been actively
    removed in ``setuptools``.
    """


# Re-export errors from distutils to facilitate the migration to PEP632

ByteCompileError = _distutils_errors.DistutilsByteCompileError
CCompilerError = _distutils_errors.CCompilerError
ClassError = _distutils_errors.DistutilsClassError
CompileError = _distutils_errors.CompileError
ExecError = _distutils_errors.DistutilsExecError
FileError = _distutils_errors.DistutilsFileError
InternalError = _distutils_errors.DistutilsInternalError
LibError = _distutils_errors.LibError
LinkError = _distutils_errors.LinkError
ModuleError = _distutils_errors.DistutilsModuleError
OptionError = _distutils_errors.DistutilsOptionError
PlatformError = _distutils_errors.DistutilsPlatformError
PreprocessError = _distutils_errors.PreprocessError
SetupError = _distutils_errors.DistutilsSetupError
TemplateError = _distutils_errors.DistutilsTemplateError
UnknownFileError = _distutils_errors.UnknownFileError

# The root error class in the hierarchy
BaseError = _distutils_errors.DistutilsError
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/extension.py0000644000175100001710000000322400000000000020204 0ustar00runnerdockerimport re
import functools
import distutils.core
import distutils.errors
import distutils.extension

from .monkey import get_unpatched


def _have_cython():
    """
    Return True if Cython can be imported.
    """
    cython_impl = 'Cython.Distutils.build_ext'
    try:
        # from (cython_impl) import build_ext
        __import__(cython_impl, fromlist=['build_ext']).build_ext
        return True
    except Exception:
        pass
    return False


# for compatibility
have_pyrex = _have_cython

_Extension = get_unpatched(distutils.core.Extension)


class Extension(_Extension):
    """Extension that uses '.c' files in place of '.pyx' files"""

    def __init__(self, name, sources, *args, **kw):
        # The *args is needed for compatibility as calls may use positional
        # arguments. py_limited_api may be set only via keyword.
        self.py_limited_api = kw.pop("py_limited_api", False)
        _Extension.__init__(self, name, sources, *args, **kw)

    def _convert_pyx_sources_to_lang(self):
        """
        Replace sources with .pyx extensions to sources with the target
        language extension. This mechanism allows language authors to supply
        pre-converted sources but to prefer the .pyx sources.
        """
        if _have_cython():
            # the build has Cython, so allow it to compile the .pyx files
            return
        lang = self.language or ''
        target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
        sub = functools.partial(re.sub, '.pyx$', target_ext)
        self.sources = list(map(sub, self.sources))


class Library(Extension):
    """Just like a regular Extension, but built as a library instead"""
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9506702
setuptools-59.6.0/setuptools/extern/0000755000175100001710000000000000000000000017122 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/extern/__init__.py0000644000175100001710000000454700000000000021245 0ustar00runnerdockerimport importlib.util
import sys


class VendorImporter:
    """
    A PEP 302 meta path importer for finding optionally-vendored
    or otherwise naturally-installed packages from root_name.
    """

    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
        self.root_name = root_name
        self.vendored_names = set(vendored_names)
        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')

    @property
    def search_path(self):
        """
        Search first the vendor package then as a natural package.
        """
        yield self.vendor_pkg + '.'
        yield ''

    def _module_matches_namespace(self, fullname):
        """Figure out if the target module is vendored."""
        root, base, target = fullname.partition(self.root_name + '.')
        return not root and any(map(target.startswith, self.vendored_names))

    def load_module(self, fullname):
        """
        Iterate over the search path to locate and load fullname.
        """
        root, base, target = fullname.partition(self.root_name + '.')
        for prefix in self.search_path:
            try:
                extant = prefix + target
                __import__(extant)
                mod = sys.modules[extant]
                sys.modules[fullname] = mod
                return mod
            except ImportError:
                pass
        else:
            raise ImportError(
                "The '{target}' package is required; "
                "normally this is bundled with this package so if you get "
                "this warning, consult the packager of your "
                "distribution.".format(**locals())
            )

    def create_module(self, spec):
        return self.load_module(spec.name)

    def exec_module(self, module):
        pass

    def find_spec(self, fullname, path=None, target=None):
        """Return a module spec for vendored names."""
        return (
            importlib.util.spec_from_loader(fullname, self)
            if self._module_matches_namespace(fullname) else None
        )

    def install(self):
        """
        Install this importer into sys.meta_path if not already present.
        """
        if self not in sys.meta_path:
            sys.meta_path.append(self)


names = 'packaging', 'pyparsing', 'ordered_set', 'more_itertools',
VendorImporter(__name__, names, 'setuptools._vendor').install()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/glob.py0000644000175100001710000001141100000000000017110 0ustar00runnerdocker"""
Filename globbing utility. Mostly a copy of `glob` from Python 3.5.

Changes include:
 * `yield from` and PEP3102 `*` removed.
 * Hidden files are not ignored.
"""

import os
import re
import fnmatch

__all__ = ["glob", "iglob", "escape"]


def glob(pathname, recursive=False):
    """Return a list of paths matching a pathname pattern.

    The pattern may contain simple shell-style wildcards a la
    fnmatch. However, unlike fnmatch, filenames starting with a
    dot are special cases that are not matched by '*' and '?'
    patterns.

    If recursive is true, the pattern '**' will match any files and
    zero or more directories and subdirectories.
    """
    return list(iglob(pathname, recursive=recursive))


def iglob(pathname, recursive=False):
    """Return an iterator which yields the paths matching a pathname pattern.

    The pattern may contain simple shell-style wildcards a la
    fnmatch. However, unlike fnmatch, filenames starting with a
    dot are special cases that are not matched by '*' and '?'
    patterns.

    If recursive is true, the pattern '**' will match any files and
    zero or more directories and subdirectories.
    """
    it = _iglob(pathname, recursive)
    if recursive and _isrecursive(pathname):
        s = next(it)  # skip empty string
        assert not s
    return it


def _iglob(pathname, recursive):
    dirname, basename = os.path.split(pathname)
    glob_in_dir = glob2 if recursive and _isrecursive(basename) else glob1

    if not has_magic(pathname):
        if basename:
            if os.path.lexists(pathname):
                yield pathname
        else:
            # Patterns ending with a slash should match only directories
            if os.path.isdir(dirname):
                yield pathname
        return

    if not dirname:
        yield from glob_in_dir(dirname, basename)
        return
    # `os.path.split()` returns the argument itself as a dirname if it is a
    # drive or UNC path.  Prevent an infinite recursion if a drive or UNC path
    # contains magic characters (i.e. r'\\?\C:').
    if dirname != pathname and has_magic(dirname):
        dirs = _iglob(dirname, recursive)
    else:
        dirs = [dirname]
    if not has_magic(basename):
        glob_in_dir = glob0
    for dirname in dirs:
        for name in glob_in_dir(dirname, basename):
            yield os.path.join(dirname, name)


# These 2 helper functions non-recursively glob inside a literal directory.
# They return a list of basenames. `glob1` accepts a pattern while `glob0`
# takes a literal basename (so it only has to check for its existence).


def glob1(dirname, pattern):
    if not dirname:
        if isinstance(pattern, bytes):
            dirname = os.curdir.encode('ASCII')
        else:
            dirname = os.curdir
    try:
        names = os.listdir(dirname)
    except OSError:
        return []
    return fnmatch.filter(names, pattern)


def glob0(dirname, basename):
    if not basename:
        # `os.path.split()` returns an empty basename for paths ending with a
        # directory separator.  'q*x/' should match only directories.
        if os.path.isdir(dirname):
            return [basename]
    else:
        if os.path.lexists(os.path.join(dirname, basename)):
            return [basename]
    return []


# This helper function recursively yields relative pathnames inside a literal
# directory.


def glob2(dirname, pattern):
    assert _isrecursive(pattern)
    yield pattern[:0]
    for x in _rlistdir(dirname):
        yield x


# Recursively yields relative pathnames inside a literal directory.
def _rlistdir(dirname):
    if not dirname:
        if isinstance(dirname, bytes):
            dirname = os.curdir.encode('ASCII')
        else:
            dirname = os.curdir
    try:
        names = os.listdir(dirname)
    except os.error:
        return
    for x in names:
        yield x
        path = os.path.join(dirname, x) if dirname else x
        for y in _rlistdir(path):
            yield os.path.join(x, y)


magic_check = re.compile('([*?[])')
magic_check_bytes = re.compile(b'([*?[])')


def has_magic(s):
    if isinstance(s, bytes):
        match = magic_check_bytes.search(s)
    else:
        match = magic_check.search(s)
    return match is not None


def _isrecursive(pattern):
    if isinstance(pattern, bytes):
        return pattern == b'**'
    else:
        return pattern == '**'


def escape(pathname):
    """Escape all special characters.
    """
    # Escaping is done by wrapping any of "*?[" between square brackets.
    # Metacharacters do not work in the drive part and shouldn't be escaped.
    drive, pathname = os.path.splitdrive(pathname)
    if isinstance(pathname, bytes):
        pathname = magic_check_bytes.sub(br'[\1]', pathname)
    else:
        pathname = magic_check.sub(r'[\1]', pathname)
    return drive + pathname
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/gui-32.exe0000644000175100001710000020000000000000000017316 0ustar00runnerdockerMZÿÿ¸@躴	Í!¸LÍ!This program cannot be run in DOS mode.

$äSÀØ 2®‹ 2®‹ 2®‹‡ôÕ‹£2®‹ 2¯‹û2®‹}8‹¤2®‹¾`*‹„2®‹¾`;‹²2®‹¾`-‹Ñ2®‹¾`?‹¡2®‹Rich 2®‹PEL±‹Qà	ÊN&à@@€4ù(ˆô@à@.textíÉÊ `.rdatah à"Î@@.dataÄ+ð@ÀQ‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPèx
ƒÄ3ÿ3Û‰D$Æ"p…í~W뛋L$Š<\uGë <"u…ÿ~Wj\Vè
ƒÄ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ÷‹D$_Æ"ÆF^][YÃì¡€A3ĉ„$V‹´$W‹¼$Š‹Ï„Àtd$A9](u>‹u3À@8tHF;Ãwö€>:u5;Ëtƒ}‚õjÿujÿQèU&ƒÄF‰uë9](uÂÇEøéÎ;Ëtˆ‹u3ÿ‰]ü8tU¾Pè&Y…ÀtFëŠYƒeü3ÛC98 A„ʼn4 AŠE¢0 Aƒ}…ÿ5¬+Aè0,Y‹ø‰}Ø…ÿtxÿ5¨+Aè,Y‹ð‰u܉}ä‰uàƒî‰uÜ;÷rWè÷+9tí;÷rJÿ6èñ+‹øèá+‰ÿ×ÿ5¬+AèÛ+‹øÿ5¨+AèÎ+ƒÄ9}äu9Eàt‰}ä‰}؉Eà‹ð‰uÜ‹}ØëŸhpá@¸dá@è_þÿÿYhxá@¸tá@èOþÿÿYÇEüþÿÿÿèƒ}u(‰8 AjèlYÿuèüýÿÿ3ÛCƒ}tjèSYÃèËÿU‹ìjjÿuèÃþÿÿƒÄ]ËÿU‹ìjjÿuè­þÿÿƒÄ]ÃjjjèþÿÿƒÄÃjjjèŽþÿÿƒÄËÿVèó*‹ðVèY;Vèä:VèwVèÉ:Vè´:Vèœ8Vè57Vè7hê#@èE*ƒÄ$£ˆA^ËÿU‹ìƒ=D AuèŒ3ÿuèÙ1hÿè'ýÿÿYY]ÃjXh0õ@èû3ö‰uüE˜Pÿ4à@jþ_‰}ü¸MZf9@u8¡<@¸@PEu'¹f9ˆ@uƒ¸t@v3É9°è@•Á‰Mäë‰uä3ÛCSèÏ?Y…ÀujèXÿÿÿYè-…ÀujèGÿÿÿYèW4‰]üèø
…À}jè&üÿÿYÿ0à@£ +AèQ>£< AèŒ=…À}jèüÿÿYè;…À}j	èïûÿÿYSè§üÿÿY;ÆtPèÝûÿÿYè:„]Ät·MÈëj
YQPVh@èòÿÿ‰Eà9uäuPèþÿÿèEþÿÿ‰}üë5‹Eì‹‹	‰MÜPQè·5YYËeè‹E܉Eàƒ}äuPèþÿÿè!þÿÿÇEüþÿÿÿ‹Eàë3À@ËeèÇEüþÿÿÿ¸ÿèÏÃèï>éxþÿÿ‹ÿU‹ìV‹uVèSPèk?YY…Àt|è©òÿÿƒÀ ;ðu3Àëè™òÿÿƒÀ@;ðu`3À@ÿ A÷FuNSW<…H Aƒ?»u Sè
Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N3À_@[ë3À^]ËÿU‹ìƒ}t'V‹u÷FtVèfÿîÿÿƒfƒ&ƒfY^]ÃöA@tƒyt$ÿIx‹ˆÿ¶Àë¾ÀQPèé-YYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìöG@SV‹ð‹Ùt2ƒu,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕƒ8*u‹Ï°?èdÿÿÿƒ}Õ^[]ËÿU‹ììx¡€A3ʼnEüS‹]V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè÷öÿÿ…öu5èMÇ3ÀPPPPPèӃĀ½°ýÿÿt
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF@u^Vè@
Yº˜Aƒøÿtƒøþt‹Èƒá‹ðÁþÁáµ *Aë‹ÊöA$u‘ƒøÿtƒøþt‹ÈƒàÁùÁà *Aë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu¡A‰…äýÿÿ‹…äýÿÿëI€8t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ…\‹…ðýÿÿ¨@t2©t	Æ…Ôýÿÿ-ë¨t	Æ…Ôýÿÿ+ë¨tÆ…Ôýÿÿ Ç…Ðýÿÿ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿuÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄƒ½Èýÿÿ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFèå5ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿYuµëƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ|ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄƒ½¼ýÿÿtÿµ¼ýÿÿ胥¼ýÿÿY‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿt
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èÚëÿÿÉÃ+@)@G)@¥)@ñ)@ü)@B*@p+@jThXõ@èe3ÿ‰}üEœPÿ4à@ÇEüþÿÿÿj@j ^VèyYY;Ç„£ *A‰5*Aˆë0Æ@ƒÿÆ@
‰xÆ@$Æ@%
Æ@&
‰x8Æ@4ƒÀ@‹
 *AÁ;ÁrÌf9}΄
‹EÐ;Ç„ÿ‹8X;‰Eä¾;þ|‹þÇEàë[j@j èëYY…ÀtV‹Mà *A‰ƒ*A ë*Æ@ƒÿÆ@
ƒ`€`$€Æ@%
Æ@&
ƒ`8Æ@4ƒÀ@‹Ö;ÂrÒÿEà9=*A|ë‹=*Aƒeà…ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨uQÿ@à@…Àt<‹uà‹ÆÁøƒæÁæ4… *A‹E䋉ŠˆFh FPè„*YY…À„ÉÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A‹ƒøÿtƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ<à@‹øƒÿÿtC…ÿt?Wÿ@à@…Àt4‰>%ÿƒøu€N@ë	ƒøu€Nh FPèî)YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*Aÿ8à@3Àë3À@ËeèÇEüþÿÿÿƒÈÿècËÿU‹ì‹EV3ö;Æuè½VVVVVÇèEƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A]ËÿU‹ìì(¡€A3ʼnEüƒ¥ØüÿÿSjL…ÜüÿÿjPèóäÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…ØüÿÿÀÇ…Üüÿÿ‰…äüÿÿÿXà@j‹ØÿTà@…(ýÿÿPÿPà@…Àu…ÛujèM2YhÀÿLà@PÿHà@‹Mü3Í[èüçÿÿÉËÿU‹ìÿ5P Aè*Y…Àt]ÿàjè2Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØAtAƒù-rñHíƒùwj
X]ËÍÜA]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãè …Àu¸@AÃÀÃè…Àu¸DAÃÀËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌh8@dÿ5‹D$‰l$l$+àSVW¡€A1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹]V‹s35€AW‹ÆEÿÇEô{ƒøþt
‹NÏ38è©æÿÿ‹N‹FÏ38è™æÿÿ‹Eö@f…‹MUè‰Sü‹[‰Eè‰Mìƒûþt_I[‹L†D†‰Eð‹‰Eø…Ét‹×è„1ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿt$‹ƒøþt
‹NÏ38è&æÿÿ‹N‹VÏ3:èæÿÿ‹Eô_^[‹å]ÃÇEôëÉ‹M9csmàu)ƒ=Œ*At hŒ*Aèƒ!ƒÄ…Àt‹UjRÿŒ*AƒÄ‹Mè'1‹E9Xth€AW‹Ó‹Èè*1‹E‹Mø‰H‹ƒøþt
‹NÏ38è“åÿÿ‹N‹VÏ3:èƒåÿÿ‹Eð‹H‹×è½0ºþÿÿÿ9S„Rÿÿÿh€AW‹ËèÕ0éÿÿÿ‹ÿU‹ìVW3öÿuè%1‹øY…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öjÿuÿuèE‹øƒÄ…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿuÿuè[1‹øYY…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿuÿuè%3‹øƒÄ…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿu½‹Ç_^]Ãjhxõ@èÓüÿÿ‹u…ötuƒ=„*AuCjèYƒeüVè73Y‰Eä…Àt	VPèX3YYÇEüþÿÿÿèƒ}äu7ÿuë
jèYÃVjÿ5t)Aÿ`à@…Àuèüÿÿ‹ðÿ\à@PèÌûÿÿ‰Yè—üÿÿÃjh˜õ@èEüÿÿ3Û‰]äjè–Y‰]üj_‰}à;=À;A}W‹÷Á桼+AÆ9tD‹ö@ƒtPèÊ=YƒøÿtÿEäƒÿ|(¡¼+A‹ƒÀ PÿDà@¡¼+Aÿ4èýþÿÿY¡¼+A‰GëžÇEüþÿÿÿè	‹EäèüÿÿÃjè7YËÿU‹ìSV‹u‹F‹È€á3Û€ùu@©t9‹FW‹>+ø…ÿ~,WPVèaùÿÿYPèçDƒÄ;Çu‹F„Àyƒàý‰FëƒN ƒËÿ_‹Fƒf‰^‹Ã[]ËÿU‹ìV‹u…öu	Vè5Yë/Vè|ÿÿÿY…ÀtƒÈÿë÷F@tVèøøÿÿPè[EY÷ØYÀë3À^]Ãjh¸õ@èöúÿÿ3ÿ‰}ä‰}ÜjèDY‰}ü3ö‰uà;5À;Aƒ¡¼+A°98t^‹ö@ƒtVPVèÝÿÿYY3ÒB‰Uü¡¼+A‹°‹HöÁƒt/9UuPèJÿÿÿYƒøÿtÿEäë9}uöÁtPè/ÿÿÿYƒøÿu	E܉}üèFë„3ÿ‹uࡼ+Aÿ4°Vè"ÝÿÿYYÃÇEüþÿÿÿèƒ}‹Eät‹EÜèwúÿÿÃjè­YÃjèÿÿÿYËÿVW3ö¿X Aƒ<õLAuõHA‰8h ÿ0ƒÇè}!YY…ÀtFƒþ$|Ò3À@_^Ã$õHA3Àëñ‹ÿS‹Dà@V¾HAW‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ&YƒÆþhA|ܾHA_‹…Àt	ƒ~uPÿÓƒÆþhA|æ^[ËÿU‹ì‹Eÿ4ÅHAÿà@]Ãjhàõ@èZùÿÿ3ÿG‰}ä3Û9t)Auè´jèhÿèPãÿÿYY‹u4õHA9t‹Çënjè	ûÿÿY‹ø;ûuèÁøÿÿÇ3ÀëQj
èYY‰]ü9u,h Wèt YY…ÀuWèþûÿÿYè‹øÿÿÇ‰]äë‰>ëWèãûÿÿYÇEüþÿÿÿè	‹EäèòøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHAƒ>uPè"ÿÿÿY…ÀujèDâÿÿYÿ6ÿà@^]Ãjhö@èdøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;EÀ@uèû÷ÿÿÇWWWWWèƒ÷ÿÿƒÄ3ÀéÕ¯M‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*AuKƒÆƒæð‰u‹E;p*Aw7jèLÿÿÿY‰}üÿuèH6Y‰EäÇEüþÿÿÿè_‹]ä;ßtÿuWSèÛÿÿƒÄ;ßuaVjÿ5t)Aÿdà@‹Ø;ßuL9=€)At3Vè’Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇéEÿÿÿ3ÿ‹ujèðýÿÿYÃ;ßu
‹E;ÇtÇ‹Ãè˜÷ÿÿÃU‹ìƒì‰}ü‹}‹MÁéfïÀë¤$ffGfG fG0fG@fGPfG`fGp¿€IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRjQè~ÿÿÿƒÄ‹E‹}ü‹å]Ãjh ö@è`öÿÿƒeüf(ÁÇEäë#‹Eì‹‹=Àt
=Àt3ÀÃ3À@ËeèƒeäÇEüþÿÿÿ‹EäèböÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+ÑtQ3À¢‰Eô‰]è‰Uì‰M𸢉Uü‰Eø[÷Eütè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A3ÀËÿU‹ìQSV‹u3ÛW;ót9]w èEõÿÿjYSSSSS‹ñ‰èÌôÿÿƒÄ‹ÆéÍ‹E3ÿ;ÃtŠ:Ãtj_9}†ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹UG‰}ü;úsyŠˆF@8uèPQèì@ŠYYŠˆF@8uð‹E;Ãt'Š:Ët!€ù.tG;}sÆ.FëG;}sŠˆF@8uðG;}v‹Eˆèhôÿÿj"éÿÿÿˆ3À_^[ÉËÿU‹ìƒìÿuMðèæÛÿÿ¶E‹MôŠU„Tuƒ}t‹Mð‹‰È·A#Eë3À…Àt3À@€}üt‹MøƒapýÉËÿU‹ìjjÿuÿuè™ÿÿÿƒÄ]ËÿU‹ìjjÿujèÿÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuèå?ƒÄ]ËÿU‹ìì(£°"A‰
¬"A‰¨"A‰¤"A‰5 "A‰=œ"AfŒÈ"AfŒ
¼"AfŒ˜"AfŒ”"AfŒ%"AfŒ-Œ"AœÀ"A‹E£´"A‹E£¸"AE£Ä"A‹…àüÿÿÇ"A¡¸"A£´!AǨ!A	ÀǬ!A¡€A‰…Øüÿÿ¡„A‰…ÜüÿÿÿXà@£ø!Ajè¯$YjÿTà@hÔâ@ÿPà@ƒ=ø!Aujè‹$Yh	ÀÿLà@PÿHà@ÉÃ-¤t"ƒètƒè
tHt3ÀøøøøËÿVW‹ðh3ÿFWPèûÕÿÿ3À·È‹Á‰~‰~‰~ÁáÁ~«««¹hAƒÄF+οŠˆ@Ou÷†¾Šˆ@Nu÷_^ËÿU‹ìì¡€A3ʼnEüSW…èúÿÿPÿvÿhà@¿…À„û3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj Rè8ÕÿÿƒÄCŠC„ÀuØjÿv…üúÿÿÿvPW…üþÿÿPjjèyE3ÛSÿv…üýÿÿWPW…üþÿÿPWÿvSèZCƒÄDSÿv…üüÿÿWPW…üþÿÿPhÿvSè5CƒÄ$3À·ŒEüúÿÿöÁt€LŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒëÆ„@;Çr¾ëV†Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ÐZ ƒûw€LŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆA;Ïr‹Mü_3Í[èØÿÿÉÃjh@ö@èËðÿÿè˜
‹ø¡ŒA…Gptƒlt‹wh…öuj ènÚÿÿY‹ÆèãðÿÿÃj
èó÷ÿÿYƒeü‹wh‰uä;5At6…ötVÿpà@…ÀuþhAtVè‡óÿÿY¡A‰Gh‹5A‰uäVÿlà@ÇEüþÿÿÿè뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðèt×ÿÿ‰Ì$AƒþþuÇÌ$Aÿxà@8]ütE‹Møƒapýë<ƒþýuÇÌ$Aÿtà@ëÛƒþüu‹Eð‹@ÇÌ$AëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A3ʼnEüS‹]V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé‰uä3À9¸˜A„‘ÿEäƒÀ0=ðrçÿèý„pÿéý„d·ÇPÿ|à@…À„REèPWÿhà@…À„3hCVPèXÒÿÿ3ÒBƒÄ‰{‰s9Uè†ø€}î„ÏuɄ¶Fÿ¶Éé¦hCVPèÒÿÿ‹MäƒÄkÉ0‰u౨A‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”AD;¶FG;øvê‹}FF€>uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇCègûÿÿj‰CC‰œAZf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L@;ÁvöFF€~ÿ…4ÿÿÿC¹þ€@Iuù‹Cèûÿÿ‰C‰Së‰s3À·È‹ÁÁáÁ{«««ë¨95Ì$A…XþÿÿƒÈÿ‹Mü_^3Í[èÕÿÿÉÃjh`ö@èÆíÿÿƒMàÿè‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„Wh è‚ïÿÿY‹Ø…Û„F¹ˆ‹wh‹ûó¥ƒ#Sÿuè¸ýÿÿYY‰Eà…À…ü‹uÜÿvhÿpà@…Àu‹Fh=hAtPècðÿÿY‰^hS‹=là@ÿ×öFp…êöŒA…Ýj
ètôÿÿYƒeü‹C£Ü$A‹C£à$A‹C£ä$A3À‰Eäƒø}f‹LCf‰EÐ$A@ëè3À‰Eä=}
ŠLˆˆˆA@ëé3À‰Eä=}ŠŒˆˆA@ëæÿ5Aÿpà@…Àu¡A=hAtPèªïÿÿY‰ASÿ×ÇEüþÿÿÿèë0j
èíòÿÿYÃë%ƒøÿu ûhAtSètïÿÿYèìÿÿÇëƒeà‹Eàè~ìÿÿÃ=°+AujýèVþÿÿYÇ°+A3ÀËÿU‹ìSV‹u‹†¼3ÛW;Ãto=HAth‹†°;Ãt^9uZ‹†¸;Ãt9uPèûîÿÿÿ¶¼è›AYY‹†´;Ãt9uPèÚîÿÿÿ¶¼è5AYYÿ¶°èÂîÿÿÿ¶¼è·îÿÿYY‹†À;ÃtD9u@‹†Ä-þPè–îÿÿ‹†Ì¿€+ÇPèƒîÿÿ‹†Ð+ÇPèuîÿÿÿ¶ÀèjîÿÿƒÄ¾Ô‹=ˆAt9˜´uPè?ÿ7èCîÿÿYY~PÇEøAt‹;Ãt9uPèîÿÿY9_üt‹G;Ãt9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@W‹}WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒSV‹5pà@WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ>Yuþ˜AtVèYýÿÿY‹Ç^Ã3ÀÃjh€ö@è_éÿÿè,‹ð¡ŒA…Fpt"ƒ~ltè‹pl…öuj èýÒÿÿY‹ÆèréÿÿÃjè‚ðÿÿYƒeüFl‹=pAèiÿÿÿ‰EäÇEüþÿÿÿèëÁjè}ïÿÿY‹uäËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€øë'¾tã@Vÿ à@…ÀuVè>ÒÿÿY…Àthdã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãjè‡ÿÿÿYËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€üë'¾tã@Vÿ à@…ÀuVèÃÑÿÿY…Àthã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãÿ„à@‹ÿVÿ5„Aÿ€à@‹ð…öuÿ5%AèeÿÿÿY‹ðVÿ5„Aÿˆà@‹Æ^á€AƒøÿtPÿ5%Aè;ÿÿÿYÿЃ
€Aÿ¡„AƒøÿtPÿŒà@ƒ
„Aÿéºíÿÿjh ö@è‚çÿÿ¾tã@Vÿ à@…ÀuVèÑÿÿY‰Eä‹uÇF\é@3ÿG‰~…Àt$hdã@P‹(à@ÿÓ‰†øhã@ÿuäÿÓ‰†ü‰~pƆÈCƆKCÇFhhAj
ènîÿÿYƒeüÿvhÿlà@ÇEüþÿÿÿè>jèMîÿÿY‰}ü‹E‰Fl…Àu¡pA‰FlÿvlèüÿÿYÇEüþÿÿÿèèçÿÿÃ3ÿG‹uj
è5íÿÿYÃjè,íÿÿYËÿVWÿ\à@ÿ5€A‹øè‘þÿÿÿЋð…öuNhjè±èÿÿ‹ðYY…öt:Vÿ5€Aÿ5%AèèýÿÿYÿÐ…ÀtjVèÅþÿÿYYÿ”à@ƒNÿ‰ë	Vè^éÿÿY3öWÿà@_‹Æ^ËÿVèÿÿÿ‹ð…öujèáÏÿÿY‹Æ^ÃjhÈö@èæÿÿ‹u…ö„ø‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@tPè¬èÿÿYj
èàìÿÿYƒeü‹~h…ÿtWÿpà@…ÀuÿhAtWèèÿÿYÇEüþÿÿÿèWjè§ìÿÿYÇEü‹~l…ÿt#WèóúÿÿY;=pAtÿ˜Atƒ?uWèÿøÿÿYÇEüþÿÿÿèVè'èÿÿYèEåÿÿ‹uj
èvëÿÿYËujèjëÿÿYËÿVW¾tã@Vÿ à@…ÀuVècÎÿÿY‹ø…ÿ„^‹5(à@hÀã@WÿÖh´ã@W£%AÿÖh¨ã@W£%AÿÖh ã@W£%AÿÖƒ=%A‹5ˆà@£%Atƒ=%At
ƒ=%At…Àu$¡€à@£%A¡Œà@Ç%A”O@‰5%A£%Aÿ„à@£„Aƒøÿ„Ìÿ5%APÿÖ…À„»è•Ðÿÿÿ5%Aèûÿÿÿ5%A£%Aèûÿÿÿ5%A£%Aèóúÿÿÿ5%A£%AèãúÿÿƒÄ£%Aè¬éÿÿ…ÀtehˆQ@ÿ5%Aè=ûÿÿYÿУ€AƒøÿtHhjèÓåÿÿ‹ðYY…öt4Vÿ5€Aÿ5%Aè
ûÿÿYÿÐ…ÀtjVèçûÿÿYYÿ”à@ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèè™Êÿÿ‹]C=w‹E苀ȷXëu‰]Á}EèP‹E%ÿPè§YY…ÀtŠEjˆEøˆ]ùÆEúYë
3Ɉ]øÆEùA‹EèjÿpÿpEüPQEøPEèjPè~6ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E€}ôt‹Mðƒapý[ÉËÿU‹ìQV‹uVèsàÿÿ‰E‹FY¨‚uè4âÿÿÇ	ƒN ƒÈÿé/¨@t
èâÿÿÇ"ëãS3Û¨t‰^¨„‡‹Nƒàþ‰‰F‹FƒàïƒÈ‰F‰^‰]ü©u,èlÃÿÿƒÀ ;ðtè`ÃÿÿƒÀ@;ðu
ÿuèY…ÀuVè@Y÷FW„€‹F‹>H‰‹N+øI;û‰N~WPÿuè<+ƒÄ‰EüëMƒÈ ‰FƒÈÿëy‹Mƒùÿtƒùþt‹Áƒà‹ÑÁúÁà• *A븘Aö@ tjSSQèŠ>#ƒÄƒøÿt%‹FŠMˆë3ÿGWEPÿuèÍ*ƒÄ‰Eü9}üt	ƒN ƒÈÿë‹E%ÿ_[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü;ýˆAt	G‰}üƒÿrîƒÿƒwjèÚ@Yƒø„4jèÉ@Y…Àu
ƒ=ŒA„ûü„Ahpé@»S¿ %AWè8ƒÄ…Àt
VVVVVèÔÞÿÿƒÄh¾9%AVjÆ=&Aÿà@…Àu&hXé@hûVèN8ƒÄ…Àt3ÀPPPPPèÞÿÿƒÄVèç@YƒøƒÄë2jôÿ<à@‹Ø;Þt$ƒûÿtjEøP4ýŒAÿ6è%YPÿ6Sÿ˜à@_^[ÉÃjè^?YƒøtjèQ?Y…Àuƒ=ŒAuhüè)þÿÿhÿèþÿÿYYËÿU‹ìQSVWÿ5¬+AèÊöÿÿÿ5¨+A‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ‹Þ+ßCƒørwWè5?‹øCY;øsH¸;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+AÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ£¬+A£¨+A…öujX^Ã&3À^Ãjhðö@èaÞÿÿèÈÿÿƒeüÿuèøþÿÿY‰EäÇEüþÿÿÿè	‹Eäè}ÞÿÿÃèoÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@¾àô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@¾èô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@Aÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZf9t3À]ËA<Á8PEuï3Ò¹f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹}‹H;ùr	‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@h8@d¡PƒìSVW¡€A1Eø3ÅPEðd£‰eèÇEüh@è*ÿÿÿƒÄ…ÀtU‹E-@Ph@èPÿÿÿƒÄ…Àt;‹@$Áè÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò=À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh0÷@èSÜÿÿè öÿÿ‹@x…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿè÷<èlÜÿÿÃh=[@è'óÿÿY£4(AÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F‹V\¡tAW‹}‹ÊS99t‹ØkÛƒÁÚ;ËrîkÀÂ;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéûƒûuƒ`3À@éêƒû„Þ‹N`‰Mø‹M‰N`‹Hƒù…¸‹
hA‹=lA‹Ñù;×}$kÉ‹~\ƒd9‹=hA‹lAB߃Á;Ó|â‹]ü‹‹~d=ŽÀu	ÇFdƒë^=Àu	ÇFdëN=‘Àu	ÇFd„ë>=“Àu	ÇFd…ë.=Àu	ÇFd‚ë=Àu	ÇFd†ë=’ÀuÇFdŠÿvdjÿÓY‰~dëƒ`QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A£<(A£@(A£D(A]ËÿU‹ì‹E‹
tAV9Pt‹ñköuƒÀ;ÆrìkÉM^;Ás9Pt3À]Ãÿ5@(AèÚñÿÿYÃj hP÷@èFÚÿÿ3ÿ‰}ä‰}Ø‹]ƒûLt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa¾8(A¡8(Aë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+HtèŠÙÿÿÇ3ÀPPPPPèÙÿÿƒÄ뮾@(A¡@(Aë¾<(A¡<(Aë
¾D(A¡D(AÇEäPèñÿÿ‰EàY3Àƒ}à„Ø9EàujèÂÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒûtƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒƒûu.‹
hA‰MÜ‹
lA‹hAÊ9MÜ}‹MÜkÉ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿèƒûuÿwdSÿUàYë‹]‹}؃}ätjèTßÿÿYÃSÿUàYƒût
ƒûtƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèèØÿÿËÿU‹ì‹E£L(A]ËÿU‹ì‹E£X(A]ËÿU‹ì‹E£\(A]Ãjhp÷@èiØÿÿƒeüÿuÿuÿ à@‰Eäë/‹Eì‹‹‰Eà3É=À”Á‹ÁËeè}àÀujÿà@ƒeäÇEüþÿÿÿ‹Eäè[ØÿÿËÿU‹ì‹E£`(A]ËÿU‹ìÿ5`(Aè|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹8csmàu*ƒxu$‹@= “t=!“t="“t=@™uèCûÿÿ3À]Âh¾_@ÿTà@3ÀËÿVW3ÿ9=°+AuèCëÿÿ‹5 +A…öu¾bã@Š< w„Àt.…ÿt$<"u	3É…ÿ”Á‹ù¶ÀPèãÿÿY…ÀtFFëÓ< wFŠ„Àuõ_‹Æ^Ã=°+AuèéêÿÿV‹5< AW3ÿ…öuƒÈÿé <=tGVè„YtŠ„ÀuêjGWè!Ùÿÿ‹øYY‰= A…ÿtË‹5< ASëBVèS‹ØC€>=Yt1jSèóØÿÿYY‰…ÀtNVSPè}.ƒÄ…Àt3ÀPPPPPè¿ÔÿÿƒÄƒÇó€>u¹ÿ5< Aè¤Ùÿÿƒ%< Aƒ'Ǥ+A3ÀY[_^Ãÿ5 Aè~Ùÿÿƒ% AƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹UÇ9Et	‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰UŠ¶ÃPFè¿áÿÿY…Àtÿƒ}t
‹MŠÿEˆF‹U‹M„Ût2ƒ}üu©€û t€û	uŸ…ÒtÆBÿƒeü€>„éŠ< t<	uFëóNëã€>„Ѓ}t	‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁuƒ}ütF€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰UŠ„ÀtUƒ}üu< tK<	tG…Ût=¾ÀP…Òt#èÚàÿÿY…Àt
Š‹MÿEˆFÿ‹MŠÿEˆë
è·àÿÿY…ÀtFÿÿ‹UFéVÿÿÿ…ÒtÆB‰Uÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒìS3ÛVW9°+Auèeèÿÿh¾h(AVSˆl)Aÿà@¡ +A‰5( A;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ=ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6Pè$Öÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄH£ A‰5 A3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)AƒìSV‹5´à@W3Û3ÿ;Ãu.ÿÖ‹ø;ûtÇp)Aë#ÿ\à@ƒøxu
jX£p)Aë¡p)Aƒø…;ûuÿÖ‹ø;ûu3ÀéÊ‹Çf9t@@f9uù@@f9uò‹5°à@SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/PèJÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…ÀuÿuüèYÖÿÿY‰]ü‹]üWÿ¬à@‹Ãë\ƒøt;Ãu‚ÿ¨à@‹ð;ó„rÿÿÿ8t
@8uû@8uö+Æ@P‰EøèãÔÿÿ‹øY;ûuVÿ¤à@éEÿÿÿÿuøVWèª+ƒÄVÿ¤à@‹Ç_^[ÉËÿU‹ì3À9Ej”ÀhPÿ¸à@£t)A…Àu]Ã3À@£„*A]ËÿU‹ìƒì¡€AƒeøƒeüSW¿Næ@»»ÿÿ;Çt
…Ãt	÷У„Aë`VEøPÿÌà@‹uü3uøÿÈà@3ðÿ”à@3ðÿÄà@3ðEðPÿÀà@‹Eô3Eð3ð;÷u¾Oæ@»ë…óu‹ÆÁàð‰5€A÷Ö‰5„A^_[ÉËÿU‹ì‹Eƒøþuè¡ÑÿÿÇ	3À]ÃV3ö;Æ|;*ArèƒÑÿÿVVVVVÇ	èÑÿÿƒÄ3Àë‹ÈƒàÁù‹ *AÁà¾Dƒà@^]á€AƒÈ3É9x)A”Á‹ÁÃÌÌÌÌÌÌÌÌÌ‹L$÷Át$ŠƒÁ„ÀtN÷Áuï¤$¤$‹ºÿþþ~Ѓðÿ3ƒÁ©tè‹Aü„Àt2„ät$©ÿt©ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u3ÛW‹};óu;ûv‹E;Ãt‰3À郋E;ÃtƒÿÿÿÿÿvècÐÿÿj^SSSSS‰0èìÏÿÿƒÄ‹ÆëVÿuMðèã·ÿÿ‹Eð9X…œf‹E¹ÿf;Áv6;ót;ûvWSV訳ÿÿƒÄèÐÿÿÇ*èÐÿÿ‹8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èåÏÿÿj"^SSSSS‰0ènÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿMQSWVjMQS‰]ÿpÿ°à@;Ãt9]…^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèѲÿÿƒÄéOÿÿÿ‹ÿU‹ìjÿuÿuÿuÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿuMð誶ÿÿ¶E‹Mð‹‰È·A%€€}üt‹MøƒapýÉËÿU‹ìjÿuè¹ÿÿÿYY]ÃÌV‹D$Àu(‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$v	N+D$T$3Û+D$T$÷Ú÷؃ڋʋӋًȋÆ^ƒ%€*AÃÌÌÌSVW‹T$‹D$‹L$URPQQh°i@dÿ5¡€A3ĉD$d‰%‹D$0‹X‹L$,3‹pƒþþt;‹T$4ƒúþt;òv.4v\³‹‰Hƒ{uÌh‹Cè1¹‹Cè1ë°dƒÄ_^[ËL$÷A¸t3‹D$‹H3ÈèµÿÿU‹hÿpÿpÿpè>ÿÿÿƒÄ]‹D$‹T$‰¸ÃU‹L$‹)ÿqÿqÿq(èÿÿÿƒÄ]ÂUVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_03À3Û3É3Ò3ÿÿæU‹ìSVWjjhWj@Qè—Q_^[]ÃU‹l$RQÿt$è´þÿÿƒÄ]Âjh÷@èÍÿÿƒeä‹u;5p*Aw"jèdÔÿÿYƒeüVèaY‰EäÇEüþÿÿÿè	‹Eäè)ÍÿÿÃjè_ÓÿÿYËÿU‹ìV‹uƒþà‡¡SW‹=dà@ƒ=t)Auè!íÿÿjèoëÿÿhÿ轶ÿÿYY¡„*Aƒøu…öt‹Æë3À@PëƒøuVèSÿÿÿY…Àu…öuFƒÆƒæðVjÿ5t)Aÿ׋؅Ûu.j^9€)AtÿuèBôÿÿY…Àt‹ué{ÿÿÿèêËÿÿ‰0èãËÿÿ‰0_‹Ã[ëVèôÿÿYèÏËÿÿÇ3À^]Ãjh°÷@èÌÿÿ‹]…ÛuÿuèÿÿÿYéÌ‹u…öuSèÏÿÿYé·ƒ=„*A…“3ÿ‰}äƒþà‡ŠjèÓÿÿY‰}üSè6Y‰Eà;Ç„ž;5p*AwIVSPèƒÄ…Àt‰]äë5Vèç	Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$Sèæ‰EàSPèƒÄ9}äuH;÷u3öF‰uƒÆƒæð‰uVWÿ5t)Aÿdà@‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ#Sÿuà迃ÄÇEüþÿÿÿè.ƒ}àu1…öuFƒÆƒæð‰uVSjÿ5t)AÿÔà@‹øë‹u‹]jèHÑÿÿYË}ä…ÿ…¿9=€)At,Vè¤òÿÿY…À…ÒþÿÿèPÊÿÿ9}àul‹ðÿ\à@PèûÉÿÿY‰ë_…ÿ…ƒè+Êÿÿ9}àthÇëq…öuFVSjÿ5t)AÿÔà@‹ø…ÿuV9€)At4Vè;òÿÿY…ÀtƒþàvÍVè+òÿÿYèßÉÿÿÇ3ÀècÊÿÿÃèÌÉÿÿé|ÿÿÿ…ÿuè¾Éÿÿ‹ðÿ\à@PènÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹MS3Û;Ëv(jà3ÒX÷ñ;Esè‰ÉÿÿSSSSSÇèÉÿÿƒÄ3ÀëA¯MVW‹ñ9]tÿuèÈ)Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVjßSèȬÿÿƒÄ‹Ç_^[]ËÿU‹ì‹
h*A¡l*AkÉÈë‹U+Púr	ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹uW‹þ+yƒÆüÁï‹ÏiÉŒD‰Mð‹I‰MüöÁ…ÓS1‹‰Uô‹Vü‰Uø‹Uô‰]öÂutÁúJƒú?vj?Z‹K;KuB»€ƒú s‹ÊÓëL÷Ó!\¸Dþ	u#‹M!ëJàÓëL÷Ó!œ¸Äþ	u‹M!Y‹]‹S‹[‹MüMô‰Z‹U‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô…+uø‹]øÁûj?‰uK^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M‹q;qu;¾€ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸ÄþLu‹M!q‹M‹q‹I‰N‹M‹q‹I‰N‹uë‹]ƒ}ôu;Ú„€‹MðÑ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€}u‹Ê»€Óë‹M	»€‹ÊÓëD¸D	ë)€}uJເÓë‹M	YJ຀ÓꄸÄ	‹Eü‰‰D0ü‹Eðÿ…ó¡|)A…À„Ø‹
|*A‹5¼à@h@ÁáH»€SQÿÖ‹
|*A¡|)Aº€Óê	P¡|)A‹@‹
|*Aƒ¤ˆÄ¡|)A‹@þHC¡|)A‹H€yCu	ƒ`þ¡|)AƒxÿueSjÿpÿÖ¡|)Aÿpjÿ5t)Aÿ`à@‹
h*A¡|)AkÉ‹l*A+ÈLìQHQPèí+‹EƒÄÿ
h*A;|)Avƒm¡l*A£t*A‹E£|)A‰=|*A[_^Éáx*AV‹5h*AW3ÿ;ðu4ƒÀkÀPÿ5l*AWÿ5t)AÿÔà@;Çu3Àëxƒx*A‹5h*A£l*Akö5l*AhÄAjÿ5t)Aÿdà@‰F;ÇtÇjh hWÿØà@‰F;ÇuÿvWÿ5t)Aÿ`à@뛃Nÿ‰>‰~ÿh*A‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ„0Dj?‰EøZ‰@‰@ƒÀJuôj‹ûhÁçyh€WÿØà@…ÀuƒÈÿé—p‰Uü;úwC‹Ê+ÏÁéGAƒHøÿƒˆìÿü‰üïÿÿÇ@üð‰PÇ€èðIuË‹Uü‹EøøO‰H‰AJ‰H‰AƒdžD3ÿG‰¼žÄŠFCŠÈþÁ„À‹EˆNCu	xº€‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì‹M‹ASV‹uW‹}‹×+QƒÆÁê‹ÊiÉŒD‰Mô‹OüƒæðI;ñ|9ü‹‰M‰]üŽUöÃ…EÙ;ó;‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC»€ƒù sÓë‹MøL÷Ó!\Dþ	u&‹M!ëƒÁàÓë‹MøL÷Ó!œÄþ	u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}üŽ¥‹}ü‹MÁÿOL1üƒÿ?vj?_‹]ôû‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s€}u‹Ï»€Óë‹M	DD‹Ïë €}uOເÓë‹M	Y„ÄO຀Óê	‹U‹MüD2ü‰‰Lüë‹UF‰Bü‰D2øé<3Àé8/‹])uN‰Kü\3ü‹uÁþN‰]‰Küƒþ?vj?^öEü…€‹uüÁþNƒþ?vj?^‹O;OuB»€ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ëNàÓëL÷Ó!œÄþ	u‹M!Y‹]‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Môñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s€}u‹Î¿€Óï‹M	9DD‹Îë €}uNà¿€Óï‹M	y„ÄN຀Óê	‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A‹MkÀl*AƒÁƒáð‰MðÁùSIƒù VW}ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A‹Ùë‹S‹;#Uø#þ×u
ƒÃ‰];Ørè;Øu‹l*Aë‹S‹;#Uø#þ×u
ƒÃ‰];Ùrè;Ùu[ëƒ{u
ƒÃ‰];Ørð;Øu1‹l*Aë	ƒ{u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé	Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰t*A‹C‹‰Uüƒúÿt‹ŒÄ‹|D#Mø#þÏu)ƒeü‹ÄHD‹9#Uø#þ×uÿEü‹‘„ƒÁëç‹Uü‹ÊiÉŒD‰Mô‹LD3ÿ#Îu‹ŒÄ#Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„‹J;Ju\ƒÿ »€}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]!ë,OàÓë‹MüŒˆÄ|8÷Ó!þ‰]ìu‹]‹Mì!Kë‹]ƒ}ø‹J‹z‰y‹J‹z‰y„‹Môñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆMþÁƒþ ˆL}#€}u¿€‹ÎÓï	;‹Î¿€Óï‹Mü	|ˆDë)€}u
Nà¿€Óï	{‹Mü¼ˆÄNྀÓî	7‹Mø…Ét‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu;|)Au‹Mü;
|*Auƒ%|)A‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷uèQ¾ÿÿWWWWWÇèÙ½ÿÿƒÄÃëBöFƒt7VèÈÂÿÿV‹ØèÄ(VèO¼ÿÿPèë'ƒÄ…À}ƒËÿë‹F;Çt
PènÁÿÿY‰~‰~‹Ã_^[]ÃjhÐ÷@è3¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;ÇuèνÿÿÇWWWWWèV½ÿÿƒÄƒÈÿëöF@t‰~‹Eäè6¾ÿÿÃVè ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿèëÕ‹uVèY ÿÿYËÿU‹ì¸äè8*¡€A3ʼnEü‹EV3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé;Æu'èD½ÿÿ‰0è*½ÿÿVVVVVÇè²¼ÿÿƒÄƒÈÿé¾SW‹}‹ÇÁø4… *A‹ƒçÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&èÛ¼ÿÿ3ö‰0迼ÿÿVVVVVÇèG¼ÿÿƒÄéCö@ tjjjÿuècƒÄÿuèÕêÿÿY…À„‹öD€„è‹Öÿÿ‹@l3É9H…åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@…À„`3É9 åÿÿt„Û„PÿÜà@‹4åÿÿ‰…åÿÿ3À‰…<åÿÿ9E†B‰…DåÿÿŠ…'åÿÿ„À…gŠ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹ǃx8tŠP4ˆUôˆMõƒ`8jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥j…@åÿÿSPè<(ƒÄƒøÿ„±Cÿ…DåÿÿëjS…@åÿÿPè(ƒÄƒøÿ„3ÀPPjMôQj@åÿÿQPÿµåÿÿCÿ…Dåÿÿÿ°à@‹ð…ö„\j…<åÿÿPVEôP‹…(åÿÿ‹ÿ4ÿ˜à@…À„)‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒƒ½ åÿÿ„Íj…<åÿÿPjEôP‹…(åÿÿ‹ÆEô
ÿ4ÿ˜à@…À„Ѓ½<åÿÿŒÏÿ…0åÿÿÿ…8åÿÿéƒ<t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%%Yf;…@åÿÿ…hƒ…8åÿÿƒ½ åÿÿt)j
XP‰…@åÿÿèø$Yf;…@åÿÿ…;ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé'‹Šÿ…8åÿÿˆT4‹‰D8é3É‹Çö@€„¿‹…4åÿÿ‰@åÿÿ„Û…ʉ…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ+4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿr‹؅Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„B‹…,åÿÿ…8åÿÿ;ÃŒ:‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ9M†M답(åÿÿ‹Dåÿÿƒ¥<åÿÿ+4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþrµ‹Ø…Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„b‹…,åÿÿ…8åÿÿ;ÃŒZ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@9M†|‹Dåÿÿƒ¥<åÿÿ+4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰ƽ<åÿÿ¨r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéýÿ°à@‹Ø;Þ„—j…,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ÿ4ÿ˜à@…Àtµ,åÿÿ;ÞËëÿ\à@‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@…Àt‹…,åÿÿƒ¥@åÿÿ‰…8åÿÿëÿ\à@‰…@åÿÿƒ½8åÿÿulƒ½@åÿÿt-j^9µ@åÿÿu貶ÿÿÇ	躶ÿÿ‰0ë?ÿµ@åÿÿ辶ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èr¶ÿÿÇèz¶ÿÿƒ ƒÈÿë‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èØÿÿÉÃjhð÷@脶ÿÿ‹Eƒøþuè>¶ÿÿƒ è#¶ÿÿÇ	ƒÈÿé3ÿ;Ç|;*Ar!è¶ÿÿ‰8èûµÿÿÇ	WWWWW胵ÿÿƒÄëÉ‹ÈÁù *A‹ðƒæÁ拾L1ƒát¿Pè9$Y‰}ü‹öD0tÿuÿuÿuè.øÿÿƒÄ‰Eäë蘵ÿÿÇ	è µÿÿ‰8ƒMäÿÇEüþÿÿÿè	‹Eäè¶ÿÿÃÿuèƒ$YÃjhø@訵ÿÿ‹EƒøþuèOµÿÿÇ	ƒÈÿéª3Û;Ã|;*Arè.µÿÿÇ	SSSSS趴ÿÿƒÄëЋÈÁù< *A‹ðƒæÁ拾LƒátÆPèl#Y‰]ü‹öDt1ÿuèà"YPÿäà@…Àuÿ\à@‰Eäë‰]ä9]ätèÍ´ÿÿ‹Mä‰è°´ÿÿÇ	ƒMäÿÇEüþÿÿÿè	‹Eäè#µÿÿÃÿuè¢#YËÿU‹ìƒìS3Û9]uèr´ÿÿSSSSSÇèú³ÿÿƒÄ3ÀëjV‹u;óuèN´ÿÿSSSSSÇèÖ³ÿÿƒÄë9ur3Àë>ÿuMðèÆ›ÿÿ‹MôFÿ9YtH9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìjÿuÿuèUÿÿÿƒÄ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9]u3Àéç;ót9]w襳ÿÿj^SSSSS‰0è.³ÿÿƒÄ‹ÆéÀ9]uˆëÉW‹};ûuˆèt³ÿÿj^SSSSS‰0èý²ÿÿƒÄé(ÿuMìèóšÿÿ‹Eð9XuÿuWÿuVè£
ƒÄéLƒ}ÿ‹U‹ÆuŠˆ@G:ËtJuó늈@G:ËtJtÿMuî9]uˆ@;Ó…È8tƒ}u5xÿ‰}ü;þrEìP‹Eü¶PèоÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…Ã}ÿuZ‹Eƒøv:|þ‰};þr!EìP‹E¶P茾ÿÿYY…ÀtÿM9usâ‹E‹Ï+MöÁtˆëˆ\ÿ8]øt‹Eôƒ`pýjPXéˆèS²ÿÿj"^SSSSS‰0èܱÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þrEìP‹E¶Pè	¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨tˆèð±ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝuPèµÿÿY]ËÿU‹ìƒì¡€A3ʼnEüSV3ÛW‹ñ9„)Au8SS3ÿGWhdê@hSÿðà@…Àt‰=„)Aëÿ\à@ƒøxu
Ç„)A9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)Aƒø„¬;Ĥƒø…̉]ø9] u‹‹@‰E ‹5ìà@3À9]$SSÿu•ÀÿuÅPÿu ÿÖ‹ø;û„~Cjà3ÒX÷÷ƒør7D?=wèŽ#‹Ä;ÃtÇÌÌëPèäÿÿY;Ãt	ÇÝ݃À‰Eôë‰]ô9]ô„>Wÿuôÿuÿujÿu ÿÖ…À„ã‹5ðà@SSWÿuôÿuÿuÿ֋ȉMø;Ë„Â÷Et)9]„°;M§ÿuÿuWÿuôÿuÿuÿÖé;Ë~Ejà3ÒX÷ñƒør9D	=wèÏ"‹ô;ótjÇÌ̃ÆëPèJãÿÿY;Ãt	ÇÝ݃À‹ðë3ö;ótAÿuøVWÿuôÿuÿuÿðà@…Àt"SS9]uSSëÿuÿuÿuøVSÿu ÿ°à@‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè  Y‰Eìƒøÿu3Àé!;E „ÛSSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@SSÿuPÿuÿuÿÖ‰Eø;Ãu3öé·~=ƒøàw8ƒÀ=wè¹!‹ü;ûtÝÇÌ̃ÇëPè4âÿÿY;Ãt	ÇÝ݃À‹øë3ÿ;ût´ÿuøSWè0’ÿÿƒÄÿuøWÿuÿuôÿuÿuÿÖ‰Eø;Ãu3öë%ÿuEøÿuPWÿu ÿuìè‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿuÿuÿuÿuÿuÿuÿèà@‹ð9]ôt	ÿuô蘱ÿÿY‹Eð;Ãt9EtPè…±ÿÿY‹Æeà_^[‹Mü3Íè—•ÿÿÉËÿU‹ìƒìÿuMðè‘•ÿÿÿu(Mðÿu$ÿu ÿuÿuÿuÿuÿuè(üÿÿƒÄ €}üt‹MøƒapýÉËÿU‹ìQQ¡€A3ʼnEü¡ˆ)ASV3ÛW‹ù;Ãu:EøP3öFVhdê@Vÿøà@…Àt‰5ˆ)Aë4ÿ\à@ƒøxu
jX£ˆ)A롈)Aƒø„Ï;Äǃø…è‰]ø9]u‹‹@‰E‹5ìà@3À9] SSÿu•ÀÿuÅPÿuÿÖ‹ø;û„«~<ÿðÿÿw4D?=wèÒ‹Ä;ÃtÇÌÌëPèPàÿÿY;Ãt	ÇÝ݃À‹Ø…Ûti?PjSèNÿÿƒÄWSÿuÿujÿuÿÖ…ÀtÿuPSÿuÿøà@‰EøSèÉúÿÿ‹EøYëu3ö9]u‹‹@‰E9]u‹‹@‰EÿuèAYƒøÿu3ÀëG;EtSSMQÿuPÿuèi‹ðƒÄ;ót܉uÿuÿuÿuÿuÿuÿôà@‹ø;ótV膯ÿÿY‹Çeì_^[‹Mü3Í蘓ÿÿÉËÿU‹ìƒìÿuMðè’“ÿÿÿu$Mðÿu ÿuÿuÿuÿuÿuèþÿÿƒÄ€}üt‹MøƒapýÉËÿU‹ìV‹u…ö„ÿvè¯ÿÿÿvè¯ÿÿÿvè¯ÿÿÿvèþ®ÿÿÿvèö®ÿÿÿvèî®ÿÿÿ6èç®ÿÿÿv èß®ÿÿÿv$è×®ÿÿÿv(èÏ®ÿÿÿv,èÇ®ÿÿÿv0è¿®ÿÿÿv4è·®ÿÿÿv诮ÿÿÿv8觮ÿÿÿv<蟮ÿÿƒÄ@ÿv@è”®ÿÿÿvD茮ÿÿÿvHè„®ÿÿÿvLè|®ÿÿÿvPèt®ÿÿÿvTèl®ÿÿÿvXèd®ÿÿÿv\è\®ÿÿÿv`èT®ÿÿÿvdèL®ÿÿÿvhèD®ÿÿÿvlè<®ÿÿÿvpè4®ÿÿÿvtè,®ÿÿÿvxè$®ÿÿÿv|è®ÿÿƒÄ@ÿ¶€è®ÿÿÿ¶„è®ÿÿÿ¶ˆèø­ÿÿÿ¶Œèí­ÿÿÿ¶èâ­ÿÿÿ¶”è×­ÿÿÿ¶˜èÌ­ÿÿÿ¶œèÁ­ÿÿÿ¶ è¶­ÿÿÿ¶¤è«­ÿÿÿ¶¨è ­ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;HAtPè}­ÿÿY‹F;LAtPèk­ÿÿY‹v;5PAtVèY­ÿÿY^]ËÿU‹ìV‹u…öt~‹F;TAtPè7­ÿÿY‹F;XAtPè%­ÿÿY‹F;\AtPè­ÿÿY‹F;`AtPè­ÿÿY‹F;dAtPèï¬ÿÿY‹F ;hAtPèݬÿÿY‹v$;5lAtVèˬÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹};ûwè=©ÿÿj^‰0SSSSSèƨÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèö¨ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹uƒÉÿIƒÁŠ
Àt	ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9]u3À_^[]Ã;ót‹};ûwèh¨ÿÿj^‰0SSSSSèñ§ÿÿƒÄ‹ÆëÕ9]uˆëÊ‹U;Óuˆëу}ÿ‹ÆuŠ
ˆ@B:ËtOuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹EjPˆ\ÿXéxÿÿÿˆèî§ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹};ûwèȧÿÿj^‰0SSSSSèQ§ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆè§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷Âu<‹:u.
Àt&:au%
ätÁè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ÂtŠƒÂ:uçƒÁ
ÀtÜ÷Ât¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u‹M‹}‹Á‹ÑÆ;þv;ø‚¤ùrƒ=ˆ*AtWVƒçƒæ;þ^_u^_]é,÷ÇuÁéƒâƒùr*ó¥ÿ$•ä‘@‹ÇºƒérƒàÈÿ$…ø@ÿ$ô‘@ÿ$x‘@‘@4‘@X‘@#ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•ä‘@I#ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•ä‘@#ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•ä‘@IÛ‘@È‘@À‘@¸‘@°‘@¨‘@ ‘@˜‘@‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Düðøÿ$•ä‘@‹ÿô‘@ü‘@’@’@‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃIŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Çu$Áéƒâƒùr
ýó¥üÿ$•€“@‹ÿ÷Ùÿ$0“@I‹Çºƒùrƒà+Èÿ$…„’@ÿ$€“@”’@¸’@à’@ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•€“@IŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•€“@ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•€“@I4“@<“@D“@L“@T“@\“@d“@w“@‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰Dðøÿ$•€“@‹ÿ“@˜“@¨“@¼“@‹E^_ÉÊFˆG‹E^_ÉÃIŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹u‹ÿŠ
ÀtƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹EV‹u‰Eø‹EWV‰EüèƒÏÿY;Çuè£ÿÿÇ	‹Ç‹×ëJÿuMüQÿuøPÿá@‰Eø;Çuÿ\à@…Àt	Pè÷¢ÿÿYëÏ‹ÆÁø‹… *AƒæÁæD0€ ý‹Eø‹Uü_^ÉÃjh0ø@èë¢ÿÿƒÎÿ‰u܉uà‹Eƒøþu蜢ÿÿƒ è¢ÿÿÇ	‹Æ‹ÖéÐ3ÿ;Ç|;*Ar!èr¢ÿÿ‰8èX¢ÿÿÇ	WWWWWèà¡ÿÿƒÄëÈ‹ÈÁù *A‹ðƒæÁ拾L1ƒáu&è1¢ÿÿ‰8è¢ÿÿÇ	WWWWW蟡ÿÿƒÄƒÊÿ‹Âë[PèpY‰}ü‹öD0tÿuÿuÿuÿuè©þÿÿƒÄ‰E܉UàëèÉ¡ÿÿÇ	èÑ¡ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè‹EÜ‹Uàè.¢ÿÿÃÿuè­YËÿU‹ìÿ Ahè¹£ÿÿY‹M‰A…Àt
ƒIÇAëƒIA‰AÇA‹Aƒa‰]ËÿU‹ìƒìSVWè¹ÿÿƒeüƒ=)A‹Ø…Žhô@ÿœà@‹ø…ÿ„*‹5(à@hôó@WÿÖ…À„PèL¸ÿÿÇ$äó@W£)AÿÖPè7¸ÿÿÇ$Ðó@W£”)AÿÖPè"¸ÿÿÇ$´ó@W£˜)AÿÖPè
¸ÿÿY£ )A…Àthœó@WÿÖPèõ·ÿÿY£œ)A¡œ)A;ÃtO9 )AtGPèS¸ÿÿÿ5 )A‹ðèF¸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQjMìQjPÿ×…ÀtöEôu	M ë9¡”)A;Ãt0Pè¸ÿÿY…Àt%ÿЉEü…Àt¡˜)A;ÃtPèæ·ÿÿY…ÀtÿuüÿЉEüÿ5)AèηÿÿY…ÀtÿuÿuÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î|ƒù~ƒùu¡D Aë(¡D A‰
D Aë讟ÿÿVVVVVÇè6ŸÿÿƒÄƒÈÿ^]ÃjhPø@èÕŸÿÿ3À‹]3ÿ;ß•À;ÇuètŸÿÿÇWWWWWèüžÿÿƒÄƒÈÿëSƒ=„*Au8jèõ¦ÿÿY‰}üSèÖÿÿY‰Eà;Çt‹süƒî	‰uäë‹uäÇEüþÿÿÿè%9}àuSWÿ5t)Aÿá@‹ð‹Æè•ŸÿÿÃ3ÿ‹]‹uäjèÃ¥ÿÿYÃjèÿˆÿÿYËÿU‹ìì(¡€A3ʼnEüöAVtj
èÓ½ÿÿYèªÄÿÿ…Àtjè¬ÄÿÿYöA„ʉ…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ‰µèýÿÿ‹@üjP‰…äýÿÿ…ØüÿÿjPèªÿÿ…ØüÿÿƒÄ‰…(ýÿÿ…0ýÿÿjÇ…Øüÿÿ@‰µäüÿÿ‰…,ýÿÿÿTà@…(ýÿÿPÿPà@jèmŠÿÿÌÌÌU‹ìSVWUjjh˜™@ÿuèV"]_^[‹å]ËL$÷A¸t2‹D$‹Hü3Èè"…ÿÿU‹h‹P(R‹P$RèƒÄ]‹D$‹T$‰¸ÃSVW‹D$UPjþh ™@dÿ5¡€A3ÄPD$d£‹D$(‹X‹pƒþÿt:ƒ|$,ÿt;t$,v-4v‹³‰L$‰Hƒ|³uh‹D³èI‹D³è_ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y ™@u‹Q‹R9Qu¸ÃSQ»”AëSQ»”A‹L$‰K‰C‰kUQPXY]Y[ÂÿÐËÿU‹ìƒìVWÿuMìè%„ÿÿ‹E‹u3ÿ;Çt‰0;÷u,èmœÿÿWWWWWÇèõ›ÿÿƒÄ€}øt‹Eôƒ`pý3ÀéØ9}tƒ}|Ƀ}$ËMìSŠ‰}ü~ƒ¹¬~EìP¶ÃjPè¹ÿÿ‹MìƒÄ닑ȶ÷Bƒà…ÀtŠGëÇ€û-uƒMë€û+uŠG‹E…ÀŒKƒø„Bƒø$9…Àu*€û0t	ÇE
ë4Š·É¶ÒÁáÊ9MuHë·Ñ9Ut
@f¶·Éf;ËuÇ·É9Mu8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìjÿuÿuè2ÿÿÿƒÄ]ÃÌÌÌBÿ[ä$d$3ÀŠD$S‹ØÁà‹T$÷ÂtŠ
ƒÂ:ËtÏ„ÉtQ÷ÂuëØW‹ÃÁãVØ‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂáu%tÓ%uæ€uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@‹ÿU‹ì‹US3Û;ÓuèH{ÿÿSSSSSÇèÐzÿÿƒÄƒÈÿë 8tß‹M;ËtØ‹;ÃtÒ8tÎSQRèƒÄ[]ËÿU‹ìƒì‹UV‹ujþX‰Eì‰Uä;ðuèÿzÿÿƒ èäzÿÿÇ	ƒÈÿéˆS3Û;ó|;5*Ar'èÕzÿÿ‰è»zÿÿSSSSSÇ	èCzÿÿƒÄƒÈÿéQ‹ÆÁøW<… *A‹ƒæÁæÆŠHöÁuèzÿÿ‰èuzÿÿÇ	ëjúÿÿÿwP‰]ð;Ó„öÁ…ÿ9]t7Š@$ÀÐøˆEþ¾ÀHjYtHu‹Â÷Шtƒâþ‰U‹E‰Eôé‹Â÷Шu!è#zÿÿ‰è	zÿÿÇSSSSSè‘yÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuè|ÿÿY‰Eô;ÃuèÑyÿÿÇèÙyÿÿǃÈÿéhjSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEðÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEðÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEðÆD&
SMèQÿuP‹ÿ4ÿ,á@…À„{‹Mè;ËŒp;M‡g‹MðDö€„æ€}þ„;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ЋMŠ<„®<
tˆCA‰Mé‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEjEèPjEÿP‹ÿ4ÿ,á@…Àu
ÿ\à@…ÀuEƒ}èt?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö@u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð…À„ÈKŠ„ÉxCé†3À@¶Éëƒø;]ôrK¶@€¹àAt芶ʾ‰àA…Éu
è|wÿÿÇ*ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ|	Š‹ˆT%Cƒøu	Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿuSÿuôjhéýÿìà@‰Eð…Àu4ÿ\à@Pè!wÿÿYƒMìÿ‹Eô;EtPèUzÿÿY‹Eìƒøþ…‹‹Eð郋Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ‹E·fƒù„×fƒù
tf‰CC@@‰Eé´‹MðƒÁþ;ÁsHfƒ9
u
ƒÀ‰Ej
鎉M鄃EjEèPjEøP‹ÿ4ÿ,á@…Àu
ÿ\à@…Àu[ƒ}ètU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹f‰CC+]ô‰]ðé‘þÿÿÿ\à@j^;ÆuèuuÿÿÇ	è}uÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhøø@è‹uÿÿ‹EƒøþuèEuÿÿƒ è*uÿÿÇ	ƒÈÿé¾3ö;Æ|;*Ar!èuÿÿ‰0èuÿÿÇ	VVVVVèŠtÿÿƒÄëÉ‹ÈÁù *A‹øƒçÁ狾L9ƒát¿¹ÿÿÿ;MÉAuèÎtÿÿ‰0è´tÿÿÇë°PèãÿÿY‰uü‹öD8tÿuÿuÿuè~ùÿÿƒÄ‰Eäëè~tÿÿÇ	è†tÿÿ‰0ƒMäÿÇEüþÿÿÿè	‹EäèêtÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ‰]Ôt	‰]ØÆEÿë
ÇE؈]ÿEàPè
Y…Àt
SSSSSènrÿÿƒÄ‹M¸€…Èu÷Á@u9Eàt€Mÿ€‹Áƒà+úÀ¿€tGHt.Ht&èÓsÿÿ‰ƒÿè¶sÿÿj^SSSSS‰0è?sÿÿƒÄé‰UøëöÁt÷ÁuîÇEø@ë‰}ø‹EjY+Át7+Át*+Át+Átƒè@u¡9}ø”À‰EðëÇEðëÇEðëÇEðë‰]ð‹Eº#¹;Á¿;t0;Ãt,;Çt=„”=…@ÿÿÿÇEìë/ÇEìë&ÇEìë=t=t`;Â…ÿÿÿÇEì‹EÇEô€…Çt‹
 A÷Ñ#M„ÉxÇEô¨@tMôMøƒMð©t	}ô¨ tMôëÇEì릨tMôè£áÿÿ‰ƒøÿuèjrÿÿ‰ƒÿèMrÿÿÇ鎋E‹=á@SÿuôÇÿuìEÐPÿuðÿuøÿuÿ׉Eäƒøÿum‹Mø¸À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿuÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@PèÛqÿÿYè¯qÿÿ‹étÿuäÿ@à@;ÃuD‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@‹ðVè˜qÿÿYÿuäÿá@;óu°è_qÿÿÇ
룃øu€Mÿ@ë	ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹ÐƒàÁú‹• *AYÁàYŠMÿ€ÉˆL‹‹ÐƒàÁú‹• *AÁàD$€ €ˆMý€eýHˆMÿ…€öÁ€„±öEtqjƒÏÿWÿ6裃Ä‰Eè;ÇuèÖpÿÿ8ƒtMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ…Àu€}üu‹Eè™RPÿ6è ƒÄ;ÇtÃSSÿ6èFƒÄ;Çt³öEÿ€„0¿@¹@…}u‹Eà#Çu	Më	E‹E#Ç;ÁtD=t)=@t"=t)=@t"=t=@uÆEþë‹M¸#È;Èu	ÆEþëˆ]þ÷E„µöEÿ@‰]è…¨‹Eø¹À#Á=@„·=€tw;Á…„‹Eì;Æyƒøvƒøv0ƒø…f¾Eþ3ÿH„&H…RÇEèÿþÇEìéjSSÿ6è8ÌÿÿƒÄÂtÇSSSÿ6è'Ìÿÿ#ƒÄƒøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄƒøÿ„uþÿÿƒøtkƒø…­}èuYÆEþéÜ‹Eì;Æуø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ„CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘éþÿÿ‹Eè%ÿÿ=þÿuÿ6èß×ÿÿYè¤nÿÿj^‰0‹Æéd=ÿþuSjÿ6èXƒÄƒøÿ„ÀýÿÿÆEþëASSÿ6è=ƒÄë™ÇEèÇEì‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *AƒàÁàD$Š2Mþ€á0‹‹ÈÁù‹ *AƒàÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹ÈƒàÁù‹ *AÁàD€ ‹}ø¸À‹Ï#È;Èu|öEtvÿuäÿá@SÿuôEÐjPÿuðçÿÿÿWÿuÿá@ƒøÿu4ÿ\à@Pè›mÿÿ‹‹ÈƒàÁù‹ *AÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *AƒæÁ手Ã_^[ÉÃjhù@èomÿÿƒMäÿ3ö‰uà3À9u•À;Æuè	mÿÿÇVVVVVè‘lÿÿƒÄƒÈÿër‰uüÿuj@ÿuÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè‹}Ü;þt<è¹lÿÿ‰8ë¿3ö9uàt+9uÜt‹EäÁø‹MäƒáÁá‹… *AD€ þÿuäèÛÿÿYËEäèmÿÿËÿU‹ìQQV3ö9uuèelÿÿVVVVVÇèíkÿÿƒÄƒÈÿëJ9utÞÿuEøPEüPÿuÿuè|ƒÄƒøÿtØÿuøÿuüÿujèUÿuü‹ðè}oÿÿÿuøèuoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èåkÿÿSSSSSÇèmkÿÿƒÄƒÈÿéá8tÜ‹E;ÃtÕ‹;ÃtÏ8tËVj\Wèj/W‹ðè
ƒÄ;Ã…;ó…ƒj:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèímÿÿ‹øƒÄ‰}ü;û„­htô@VWèkÃÿÿƒÄ…Àt
SSSSSè¯iÿÿƒÄÿuVWèØÁÿÿƒÄ…Àt
SSSSSè‘iÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.VèhYY…Àt,Sÿuüè
YY…À…ìÿuÿuÿuüè`þÿÿƒÄ‰EðéÓÿuüè–™ÿÿ‹ðƒÆjVè:mÿÿƒÄ‰Eø;ÃuƒÈÿé½ÿuüVPè¸ÂÿÿƒÄ…Àt
SSSSSèühÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèvjÿÿ‹‰Eì‹Eø+÷ðÇEôìA‹Eôÿ0VWèrÂÿÿƒÄ…Àt
SSSSSè¶hÿÿƒÄSÿuøè]	YY…Àtƒmô}ôàA}Äëè jÿÿÿu‹Mìÿu‰ÿuøè”ýÿÿƒÄ‰Eðÿuøèlmÿÿ‹}Y9}üt	ÿuüè[mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒÄ‰UìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u‹}+ðúˆÆ;󆼻Sjÿ4á@Pÿdà@‰Eü…ÀuèciÿÿÇèXiÿÿ‹_^[ÉÃh€ÿuèŠYY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèFYYÿuüjÿ4á@Pÿ`à@3Ûé†èóhÿÿƒ8uèÖhÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿuÿuèÅÿÿ#ƒÄƒøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èwhÿÿÇ
èhÿÿ‹ðÿ\à@‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒÄƒøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèhÿÿÇ	ƒÈÿëMWÿujÿuPÿá@‹øƒÿÿuÿ\à@ë3À…ÀtPèhÿÿYƒÈÿë‹ÆÁø‹… *AƒæÁæD0€ ý‹Ç_^]ËÿU‹ìS‹]V‹u‹ÆÁø… *A‹ƒæÁæ0ŠA$ÀW¶y¾Àç€Ñøû@tPû€tBût&ûtûu=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸€]Ã÷ØÀ%À@]ËÿU‹ì‹EV3ö;ÆuèêfÿÿVVVVVÇèrfÿÿƒÄjXë
‹
d*A‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~	ƒøuÆEÿ‹E‰Eðë8èfÿÿ‰èƒfÿÿSSSSSÇèfÿÿƒÄƒÈÿé®@8uûH8tÆ ‹Á8uëVjD^VE˜SPèÔIÿÿ‰u˜‹5*AƒÄ;ót+Fÿ‹È‹ÐÁù‹ *AƒâÁâ8\uNH;óuà;óŒ@þ23ƒ4‹ÆkÀƒÀf‰EÊ·ÀjPèghÿÿYY‰EÌ;Ä;ó‰0‹EÌH|0‰]ø~9‹Eø‹ÐƒàÁúÁà• *AŠPöÂuˆ‹‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×}ˆƒÿBAƒÀëäÇEôèjeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿuÿà@‹ðÿ\à@ÿuÌ‹øè‘hÿÿY;óu	Wè?eÿÿYëXƒ}uSè¤Qÿÿ‹5á@9]ujÿÿuÜÿà@EìPÿuÜÿà@‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹ÃëèÄdÿÿÇƒÈÿ^_[ÉËÿU‹ìƒì@¡€A3ʼnEü‹M‹ESVW¾xô@}ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌèÊfÿÿ‹uàYY‰;Ãu#‹Eè‰è4dÿÿÇè?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=EncodePointerKERNEL32.DLLDecodePointerFlsFreeFlsSetValueFlsGetValueFlsAllocruntime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: ÀÀ–ÀÀŽÀÀÀ‘À’À“À€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwpp         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLLSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecCONOUT$.com.exe.bat.cmd.\SystemRootH€AÐô@8°i ™þÿÿÿÔÿÿÿþÿÿÿÜ@þÿÿÿÈÿÿÿþÿÿÿ¼#@þÿÿÿˆÿÿÿþÿÿÿú%@þ%@þÿÿÿÀ%@Ô%@þÿÿÿŒÿÿÿþÿÿÿh5@l5@þÿÿÿÔÿÿÿþÿÿÿ;@þÿÿÿÐÿÿÿþÿÿÿá;@þÿÿÿÌÿÿÿþÿÿÿk=@7=@þÿÿÿÔÿÿÿþÿÿÿð>@þÿÿÿÔÿÿÿþÿÿÿ#@@þÿÿÿÔÿÿÿþÿÿÿMA@iA@þÿÿÿÔÿÿÿþÿÿÿ]G@þÿÿÿÌÿÿÿþÿÿÿ+K@þÿÿÿÔÿÿÿþÿÿÿ›N@þÿÿÿÔÿÿÿþÿÿÿÝP@þÿÿÿìP@þÿÿÿØÿÿÿþÿÿÿŸR@þÿÿÿ«R@þÿÿÿÔÿÿÿþÿÿÿeY@þÿÿÿØÿÿÿþÿÿÿ[@[@þÿÿÿØÿÿÿþÿÿÿ][@a[@þÿÿÿÀÿÿÿþÿÿÿ¸^@þÿÿÿÐÿÿÿþÿÿÿH_@__@þÿÿÿÔÿÿÿþÿÿÿ¹j@þÿÿÿÐÿÿÿþÿÿÿÊl@þÿÿÿÔÿÿÿþÿÿÿÎy@þÿÿÿÐÿÿÿþÿÿÿÞ@þÿÿÿÐÿÿÿþÿÿÿ¿‚@þÿÿÿÌÿÿÿþÿÿÿ´•@þÿÿÿÐÿÿÿþÿÿÿM˜@þÿÿÿÐÿÿÿþÿÿÿä¡@þÿÿÿÔÿÿÿþÿÿÿ[¦@þÿÿÿÈÿÿÿþÿÿÿ!¨@]§@þÿÿÿÐÿÿÿþÿÿÿÜ®@þÿÿÿÐÿÿÿþÿÿÿøÂ@þÿÿÿÌÿÿÿþÿÿÿ›Ê@\ùàœú¸úÎúäúöúû$û<ûTûhûpû‚ûû¢û´ûÆûÖûäûüûü$ü@ü^ürü‚üŽüšü¦ü¾üÖüàüìüþüýý&ý0ý@ýVýbýrýšý´ýÌýæýüýþ$þ2þLþ\þrþŒþ˜þ¦þ¶þÆþØþìþüþÿ"ÿ4ÿFÿXÿjÿvÿ„ÿ”ÿªÿºÿÊÿØÿêÿüÿ$0@RRGenerateConsoleCtrlEventÆGetExitCodeProcessnWaitForSingleObject•CreateProcessA¯SetConsoleCtrlHandlerõGetModuleFileNameAÚEnterCriticalSectionôLeaveCriticalSectionúGetModuleHandleW+Sleep"GetProcAddressExitProcesspGetCommandLineA<GetStartupInfoAðSetHandleCount>GetStdHandleØGetFileType¿DeleteCriticalSection7TerminateProcessªGetCurrentProcessHUnhandledExceptionFilterSetUnhandledExceptionFilterÖIsDebuggerPresentçGetLastError¦HeapFree¢HeapAlloc\GetCPInfoÅInterlockedIncrementÁInterlockedDecrementSGetACPGetOEMCPàIsValidCodePage>TlsGetValue<TlsAlloc?TlsSetValue=TlsFreeôSetLastError®GetCurrentThreadId—WriteFileöLoadLibraryAºInitializeCriticalSectionAndSpinCountKFreeEnvironmentStringsAÀGetEnvironmentStringsLFreeEnvironmentStringsW„WideCharToMultiByteÂGetEnvironmentStringsW¤HeapCreateaVirtualFreeYQueryPerformanceCounterjGetTickCount«GetCurrentProcessIdSGetSystemTimeAsFileTimešRtlUnwind©HeapReAlloc^VirtualAlloc„GetConsoleCP–GetConsoleModeBFlushFileBuffersæLCMapStringAMultiByteToWideCharèLCMapStringW@GetStringTypeACGetStringTypeWéGetLocaleInfoAçSetFilePointer«HeapSizeDCloseHandleŒWriteConsoleAšGetConsoleOutputCP–WriteConsoleWSetStdHandleyCreateFileASCompareStringAVCompareStringWØSetEnvironmentVariableAKERNEL32.dllnReadFileÕSetEndOfFile&GetProcessHeapÊGetFileAttributesAÀ+AÀ+ANæ@»±¿Dê#@lâ@\â@ÿÿÿÿ€

		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZhA¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þlí@þÿÿÿCAAAAAHAhë@ðï@pñ@ˆA˜A˜AhAÿÿÿÿÿÿÿÿøè@Ìè@	 è@
è@Üç@¬ç@ˆç@\ç@$ç@üæ@Äæ@Œæ@dæ@Dæ@àå@ ¨å@!°ä@"ä@xä@yðã@zàã@üÜã@ÿÌã@^˜@^˜@^˜@^˜@^˜@^˜@^˜@^˜@^˜@^˜@x
hë@jí@˜ó@”ó@ó@Œó@ˆó@„ó@€ó@xó@pó@hó@\ó@Pó@Hó@<ó@8ó@4ó@0ó@,ó@(ó@$ó@ ó@ó@ó@ó@ó@ó@ó@øò@ðò@èò@(ó@àò@Øò@Ðò@Äò@¼ò@°ò@¤ò@ ò@œò@ò@|ò@pò@	ˆA.DAŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AHA. “€pðñÿÿPSTPDTÐAAÿÿÿÿÿÿÿÿþÿÿÿþÿÿÿÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Mllô@dô@\ô@Tô@././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/gui-64.exe0000644000175100001710000022300000000000000017330 0ustar00runnerdockerMZÿÿ¸@غ´	Í!¸LÍ!This program cannot be run in DOS mode.

$#^¤›g?ÊÈg?ÊÈg?ÊÈ@ù±Èd?ÊÈg?ËÈ:?ÊÈÚp\Èc?ÊÈymNÈC?ÊÈym_Èm?ÊÈymIÈ	?ÊÈym[Èf?ÊÈRichg?ÊÈPEd†±‹Qð#	ÖlÌ+@p€(`
ð.textüÔÖ `.rdata¸)ð*Ú@@.dataä5 @À.pdata
`@@H‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì L‹áHƒÉÿ3ÀI‹üºò®H÷ÑD	HyÿHcÈèP3ö3íLcïÆ"HXL‹ð…ÿ~e€A¶,€ù\uÿÆë'€ù"u …ö~D‹Æ²\H‹Ë‹þèjHß+öÆ\HÿÃë3öA¶,HÿÅHÿÃI;íˆCÿ|¸…ö~D‹Æ²\H‹Ë‹þè5HßH‹l$HH‹t$PH‹|$XÆ"ÆCH‹\$@I‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌÌÌÌÌH‰\$WHì`H‹¼H3ÄH‰„$PH‹ÙH‹Á¶	H‹ú„ÉtHÿÀ€ù/uÆ@ÿ\Š„ÉuîH„$@LŒ$@LD$@HT$0H‹ËH‰D$ èO€|$0…®€|$@\„£H„$@LŒ$@LD$@HT$0H‹ÏH‰D$ èHƒÉÿ3ÀH|$@ò®HD$@H÷ÑHÿÈHÿÉHÈ€9\uHÿÉ€9\tHD$@H;ÈrÆHÿÉ€9\uëLD$@HT$0HŒ$@L‹ËHÇD$ èß
º¹èŒ
H”$@뺹ès
H‹ÓA¸H‹ÈH‹øè»H‹ÇH‹Œ$PH3ÌèH‹œ$€HÄ`_ÃÌÌÌÌÌÌÌH‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì H‹ÙHƒÉÿ3ÀL‹êH‹ûPò®H÷ÑHÿÉè÷	3ÿH‹óA‰}¾L‹ðE3äH‰èe…ÀtD¾KHÿÃèP…Àuð¶+HÿÃ@„ít[@¾Íè8…ÀtE…ätI@€ý\uÿÇëÙ@€ý"u@öÇu3ÀE…ä”À@2íD‹àÑÿ…ÿtL‹Ç²\H‹ÎèÌ	H÷3ÿ@„ít¢@ˆ.HÿÆëš…ÿtL‹Ç²\H‹Îè©	H÷3ÿÆAÿEIcEHÿÆI‰4Æ@„ít&¾è±…Àt¾KHÿÃè …Àuð€;…GÿÿÿH‹\$@H‹l$HH‹t$PH‹|$XI‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌHƒì(…Éu‹
‚!…Ét3Òÿ6ܸHƒÄ(ÃÌÌÌÌÌÌÌÌÌÌÌÌH‰\$WHìà3À3ÿH‹ÙHL$pDGh3Ò‰¼$ðH‰D$PH‰D$XH‰D$`èÖWH
ŒÿÿÿÇD$phÿîÛL\$PHD$pL‰\$HH‰D$@H‰|$8H‰|$0E3ÉE3ÀH‹Ó3ɉ|$(ÇD$ ÿ«Û…Àu(èúH«ÞHH`èr3ÀH‹œ$øHÄà_ËD$`H‹L$PƒÊÿ‰• ÿ_ÛH‹L$PH”$ðÿDÛ…Àu(è£H,ÞHH`è3ÀH‹œ$øHÄà_Ë„$ðH‹œ$øHÄà_ÃÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WATAUHƒì L‹éHƒÉÿ3À»I‹ýIcèò®H;ÝH‹òH÷ÑL‹ËLQ}J‹<ÊHƒÉÿ3Àò®IÿÁH÷ÑDÑL;Í|æIcÊH‹ÓèHÌÝM‹ÅH‹ÈL‹àèHƒÉÿ3ÀI‹ýò®H;ÝH÷ÑLiÿ}0L‹ÞIcÍH•ÝIÌèåH‹<ÞHƒÉÿ3ÀHÿÃò®H÷ÑDéH;Ý|ÐH‹\$@H‹l$HH‹t$PI‹ÄHƒÄ A]A\_ÃÌÌÌ@SWAVAWHìXH‹»
H3ÄH‰„$0L‹òD‰D$ LcùHT$0A¸3ÉÿúÙHƒÉÿ3ÀH|$0ò®H÷ÑHD/HL$0H;Áv€8.tHT$0ÆHÿÈH;ÂwëÆ3ÀHƒÉÿH|$03Òò®H‹:ÝHL$0H‰Gÿ‹3݉Gè׸‹Øƒøÿu"èÏLD$0HûÜHH`èBCéùH”$0A¸‹ÈH‰¬$è¯HcÈH¼0‹ËèKˆH”$0HÿÊHÿÂH;×s¶„Àt<
t<
uéÆHŒ$0HÜA¸è$…Àt%H‹YÜHŒ$0H‰‹P܉A¶J܈AHT$$HŒ$2èùúÿÿHT$0H‹8H‹ØH‹ÏèvùÿÿH‹èH…Àu èéHÚÛL‹ÇHH`è^Eé
H‰´$P‹t$$L‰¤$HL‰¬$@E,7ºAEHcÈèÁH‹ÍL‹àè"øÿÿƒþI‰$I|$~ HƒÃÿÎH‹èøÿÿHƒÇHƒÃHƒîH‰GøuæHL$0èê÷ÿÿ»HƒÇI;ßH‰Gø}!„I‹ÞèÇ÷ÿÿHÿÃHƒÇI;ßH‰Gø|çƒ|$ H‹´$PHÇt*I‹ÔH‹Í躥èHÚÚHH`L‹Åèv¸ëE‹ÅI‹ÔH‹ÍèyüÿÿH‹ÈèAûÿÿL‹¤$HL‹¬$@H‹¬$H‹Œ$0H3Ìè‰
HÄXA_A^_[ÃÌÌÌÌÌÌÌÌÌÌÌH‹i‹
_A¸éøüÿÿH‹ÄH‰PH‰HL‰@L‰H SVWATHƒì8H‹ù3Û‹ó‹ÃH;Ë•À;Ãu'è&ÇH‰\$ E3ÉE3À3Ò3Éè¦%ƒÈÿé‹ÃH;Ó•À;Ãu'è]&ÇH‰\$ E3ÉE3À3Ò3Éès%ƒÈÿéâLd$pèùöG@…•H‹Ïèæ#ƒøÿt*ƒøþt%HcÐH‹ÊHÁùLÇ)ƒâHkÒXIÈH
%
ëH

H‹ÑL¢)öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒáHkÉXIÀöA8€t"è®%ÇH‰\$ E3ÉE3À3Ò3ÉèÄ$ƒÎÿ;óu*H‹ÏèM‹ØM‹ÌE3ÀH‹T$hH‹Ïè`‹ðH‹×‹ËèH‹Ï賋ÆHƒÄ8A\_^[ÃÌÌÌH‰Ã@SHƒì ‹\;»…Àu¸ë;ÃLÃHcȺ‰9;è&H‰
+H…Àu$PH‹Ë‰;èç%H‰ð*H…Àu¸ëx3ÉHH‰HƒÂ0HƒÁHƒët	H‹Â*ëåE3ÀHEHI‹ÈLh(I‹ÀHÁøƒáI‹ÂHkÉXL‹IƒúÿtIƒúþtM…ÒuÇþÿÿÿIÿÀHƒÂ0Iƒéu¼3ÀHƒÄ [ÃÌÌHƒì(è‡)€=$tè'H‹
F*HƒÄ(éÁ&Ì@SHƒì H‹ÙH
lH;Ùr:HðH;Øw.H‹ÓH¸«ªªªªªª*H+ÑH÷êHÁúH‹ÊHÁé?Lè<+ºkë
HK0ÿSÔHƒÄ [ÃÌ@SHƒì ƒùH‹Ú}ƒÁè+ºkë
HJ0ÿ%ÔHƒÄ [ÃÌÌÌHƒì(HáH;Êr7HeH;Èw+ºqH+ÊH¸«ªªªªªª*H÷éHÁúH‹ÊHÁé?Lè¯)ë
HƒÁ0ÿÓÓHƒÄ(ÃÌÌHƒì(ƒù}ºrƒÁè†)ë
HJ0ÿªÓHƒÄ(ÃÌ@SHƒì ƒd$@LD$@è£*H‹ØH…Àu9D$@tè#H…Àtèö"‹L$@‰H‹ÃHƒÄ [ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„H‹ÁIƒørS¶ÒI¹I¯ÑIƒø@rH÷ÙƒátL+ÁH‰HÈM‹ÈIƒà?IÁéu9M‹ÈIƒàIÁétfffH‰HƒÁIÿÉuôM…Àt
ˆHÿÁIÿÈuöÃ@fffffIùs0H‰H‰QH‰QHƒÁ@H‰QØH‰QàIÿÉH‰QèH‰QðH‰QøuØë”fDHÃHÃQHÃQHƒÁ@HÃQØHÃQàIÿÉHÃQèHÃQðHÃQøuÐð€$éTÿÿÿÌÌÌÌÌÌÌÌÌÌÌÌff„L‹ÙMÀt$H+ÊöÂt(Š„Àˆ„ãHÿÂIÿÈtöÂuæëI‹ÃÃH‰HƒÂH‹Iƒèr&I¹ÿþþþþþþ~LÈL‹ÐIƒòÿM3ÑI¹M…ÑtÉIƒÀ„‹„Àˆ„„HÿÂIÿÈtx„äˆ$tuHÿÂIÿÈtiHÁè„ÀˆtbHÿÂIÿÈtV„äˆ$tSHÿÂIÿÈtGHÁè„Àˆt@HÿÂIÿÈt4„äˆ$t1HÿÂIÿÈt%Áè„ÀˆtHÿÂIÿÈt„äˆ$tHÿÂIÿÈ…<ÿÿÿI‹ÃÃHÊH3ÒIƒørEöÁt
HÿÁˆIÿÈëñIƒè rH‰H‰QH‰QH‰QHƒÁ Iƒè sçIƒÀ Iƒèr	H‰HƒÁëñIƒÀIƒèrˆHÿÁëóI‹ÃÃÌÌ@SHƒì E‹H‹ÚL‹ÉAƒãøAöL‹ÑtA‹@McP÷ØLÑHcÈL#ÑIcÃJ‹H‹C‹HHKöAt¶AƒàðH˜LÈL3ÊI‹ÉHƒÄ [é™ÌHƒì(M‹A8H‹ÊI‹Ñè‰ÿÿÿ¸HƒÄ(ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂHƒÊÿè(HƒÄ8ÃÌH‰\$L‰D$UVWATAUAVAWHƒì0L‹¤$¨L‹¬$˜H‹ùL‹ò3ÒM‹ù‹Ê‰T$pH;út
L;òuL;Ât¹é¼L;ÂtñL;ÊuH9”$uâë
H9”$tÖL;êuH9”$ uÇë
H9”$ t»L;âuH9”$°u¬ë
H9”$°t ¸H‹ß8tHÿÈHÿÃH;Âwñ€;:u,L;òt!Iƒø‚;A¹L‹ÇHƒÊÿI‹Îè)3ÒH{ëL;òtAˆH‹êH‹òH‹ß8te¾èÚ(3Ò;ÂtHÿÃ늆+H^‹CøL;à‚§‹CüL;àƒ›ƒ{„‘ƒ;t‹HL$0H‹ÕIÇÿÐ…Àˆ„~sA}csmàu(Hƒ=÷tH
îè©5…ÀtºI‹Íÿ׋KA¸H‹ÕIÏèÓBI‹F@‹SMcMH‰D$(I‹F(I×M‹ÅH‹ÍH‰D$ ÿ‹ÃèÖBÿÇHƒÃ;>sjé>ÿÿÿ3ÀëfI‹y 3íI+ÿ9.vTH^‹KôL;ár>‹CøL;às6H;ùrH;øsAöE u/ƒ;t	‹H;øt#ëH‹T$xIDZI‰D‹CüMÇAÿÐÿÅHƒÃ;.r°¸L\$@I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰|$ATHƒì H‹Ùèè‹Èè!B…À„—èÀìÿÿHƒÀ0H;Øu3Àëè®ìÿÿHƒÀ`H;Øuw¸ÿn÷CucL%ÒHcøIƒ<üu+¹èJI‰üH…ÀuHC H‰CH‰¸‰C$‰CëI‹üÇC$ÇCH‰KH‰K¸ë3ÀH‹\$0H‹|$8HƒÄ A\ÃÌÌÌ…Ét0SHƒì ºbH‹ÚsH‹ÊèÁcÿîÿÿƒc$Hƒ#HƒcHƒÄ [ÃÌÌÌ@SHƒì öB@I‹ØtHƒzuAÿë&ƒBÿx
H‹ˆHÿ¶Áë¾Éèæ,ƒøÿu	ëÿHƒÄ [ÃÌ…Ò~LH‰\$H‰l$H‰t$WHƒì I‹ùI‹ð‹Ú@ŠéL‹ÇH‹Ö@ŠÍÿËè…ÿÿÿƒ?ÿt…ÛçH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì Aö@@I‹ùI‹ð‹ÚH‹étIƒxuAë7…Ò~3ŠML‹ÇH‹ÖÿËèÿÿÿHÿŃ?ÿuè=ƒ8*uL‹ÇH‹Ö±?èÿþÿÿ…ÛÍH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$UVWATAUAVAWHìÐH‹öóH3ÄH‰„$È3ÀH‹ÙH‰L$hH‹úHL$xI‹ÐM‹é‰D$`D‹à‰D$TD‹ð‰D$H‰D$X‰D$PèdóÿÿE3ÒI;ÚuAè£3ÛE3ÉE3À3Ò3ÉÇH‰\$ è·8œ$tH‹„$ˆƒ ÈýƒÈÿéýAƒÏÿöC@L
œÏÿÿ…ºH‹Ëè
HwóA;Çt(ƒøþt#LcÀL
sÏÿÿI‹ÈAƒàHÁùMkÀXM„É€Cë
L‹ÂL
PÏÿÿAö@8u)A;ÇtƒøþtHcÐH‹ÂƒâHÁøHkÒXI”Á€CöB8€tAè×3ÛE3ÉE3À3Ò3ÉÇH‰\$ èë
8œ$tH‹„$ˆƒ ÈýA‹Çé1E3ÒI;út·@Š/A‹òD‰T$@D‰T$DA‹ÒL‰”$˜A:ê„êH‹œ$¨A»HÿÇA;òH‰¼$°ŒÈEàÿtkHƒ>þteAöEt^AöEuH‹ÿL´A;ÇtILcçI‹ÄHÁøAƒäMkäXM$ÆH‹I‰$AŠEAˆD$IL$º èÚ*A;ÇtAÿD$ëƒÈÿéÕÿÇIÿÅHƒÆ;û|‚E‹çI‹ÿH‹ßHkÛXHÕHƒ;ÿtHƒ;þt€K€ëÆCAD$ÿ÷ØɃÁõ¸öÿÿÿE;çDÈÿ¢³H‹ðHƒøÿtJI;ÇtEH‹Èÿ“³A;Çt7H‰3¶Àƒøu€K@ë	ƒøu€KHKº è.*A;ÇtÿCëƒÈÿë.€K@HÇþÿÿÿAÿÄHÿÇHƒÿŒQÿÿÿ‹
ÿ ³3ÀëƒÈÿLœ$I‹[ I‹s(I‹{0M‹c8I‹ãA_A^A]ÃÌÌÌHƒì8H…Éu%è*Hƒd$ E3ÉE3À3Ò3ÉÇè?ƒÈÿë‹AHƒÄ8ÃÌÌH‰
øÃ@SHìàƒd$pHL$t3ÒA¸”èßÿÿL\$pH„$HŒ$L‰\$HH‰D$PÿDzH‹œ$HT$@H‹ËE3ÀèýH…Àt;Hƒd$8H‹T$@HL$`H‰L$0HL$XL‹ÈH‰L$(HŒ$L‹ÃH‰L$ 3Éè¹ë H‹„$èH‰„$H„$èH‰„$¨H‹„$èÇD$pÀÇD$tH‰„$€ÿ²3É‹Øÿÿ±HL$Hÿì±…Àu…ÛuHèø4ÿαºÀH‹Èÿ¸±HÄà[ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0H‹éH‹
¾öA‹ÙI‹øH‹òè@H…ÀtL‹T$`D‹ËL‹ÇH‹ÖH‹ÍL‰T$ ÿÐë%¹èƒ4L‹\$`D‹ËL‹ÇH‹ÖH‹ÍL‰\$ èhþÿÿH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌÌL
Õä3ÀI‹ÑD@;
t+ÿÀIЃø-ròAíƒøw¸
ÃÁDÿÿÿ¸ƒùAFÀÃH˜A‹DÁÃÌHƒì(èwH…Àu	HçåëHƒÀHƒÄ(ÃHƒì(èWH…Àu	HËåëHƒÀHƒÄ(Ã@SHƒì ‹Ùè3H…Àu	H§åëHƒÀ‰èLåH…ÀtLP‹Ëè;ÿÿÿA‰HƒÄ [ÃÌÌH‰\$H‰l$H‰t$WHƒì 3ÿH‹ñƒÍÿH‹Îèd3H‹ØH…Àu(9Zõv ‹ÏÿȯDŸèD;BõA‹ûGý;ýuÈH‹l$8H‹t$@H‹ÃH‹\$0HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3ÿH‹òH‹éAƒÌÿE3ÀH‹ÖH‹ÍèiH‹ØH…Àu*9ßôv"‹ÏÿM¯DŸèD;ÇôA‹ûAGüA;üuÀH‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3öH‹úH‹éAƒÌÿH‹×H‹Íè 3H‹ØH…Àu/H…ÿt*9Yôv"‹ÎÿÇ®DžèD;AôA‹óAGôA;ôu¾H‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌÌÌH‰\$H‰l$H‰t$WATAUHƒì 3öI‹øH‹êAƒÍÿL‹áL‹ÇH‹ÕI‹Ìèg3H‹ØH…Àu/H…ÿt*9Ìóv"‹Îÿ:®DžèD;´óA‹óAGõA;õu»H‹l$HH‹t$PH‹ÃH‹\$@HƒÄ A]A\_ÃH…Ét7SHƒì L‹ÁH‹
øÿ3Òÿ€®…ÀuèSýÿÿH‹Øÿf®‹Èèûüÿÿ‰HƒÄ [ÃÌÌÌH‰\$H‰t$ATHƒì03öNèj^‰\$ ;4}iLcãH‹Jƒ<àtPJ‹àöAƒtè²3ƒøÿtÿƉt$$ƒû|1H‹ÛJ‹àHƒÁ0ÿ­H‹
ÆJ‹áèAÿÿÿL‹¶Kƒ$ãÿÉ\$ ë¹èç‹ÆH‹\$@H‹t$HHƒÄ0A\ÃH‰\$H‰t$WHƒì ‹A3öH‹Ù$<u?÷At6‹9+y…ÿ~-èúÿÿH‹SD‹Ç‹Èèâ:;Çu‹C„Àyƒàý‰CëƒK ƒÎÿH‹Kƒc‹ÆH‹t$8H‰H‹\$0HƒÄ _ÃÌÌÌ@SHƒì H‹ÙH…Éuè5ë,èjÿÿÿ…ÀtƒÈÿëºcsH‹Ëè¢ùÿÿ‹Èè£;÷ØÀë3ÀHƒÄ [ÃÌH‰t$H‰|$L‰d$AUAVAWHƒì0D‹ñE3ä3öNèç3ÿ‰|$ AƒÏÿ;=®†LcïH‹~Jƒ<ètjJ‹èöBƒt`‹ÏèŠ×ÿÿH‹^J‹èöAƒt5Aƒþuè9ÿÿÿA;Çt%AÿÄD‰d$$ëE…öuöAtèÿÿÿA;ÇAD÷‰t$(H‹J‹ê‹Ïè¹×ÿÿÿlj|$ énÿÿÿ¹è@AƒþADô‹ÆH‹t$PH‹|$XL‹d$`HƒÄ0A_A^A]ùéÿÿÿÌÌH‰\$H‰t$H‰|$ATHƒì L%¬à3ö3ÿI‹Üƒ{u%Hcƺ ÿÆH€HªðHÈH‰è"…Àt-H³âHƒÃÿÇH;Ø|øH‹\$0H‹t$8H‹|$@HƒÄ A\ÃHcÇHÀIƒ$Ä3ÀëÛÌÌH‰\$H‰l$H‰t$WHƒì H!àH-ZâH‹ûH‹7H…ötƒtH‹ÎÿЪH‹Îè|üÿÿHƒ'HƒÇH;ý|ÔH‹H…Étƒ{uÿ§ªHƒÃH;Ý|ãH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌHcÉH®ßHÉH‹ÈHÿ%ªH‰\$H‰t$H‰|$AUHƒì HcÙ¾Hƒ=üuèNèè¹ÿèàÿÿH‹ûHÿL-UßIƒ|ýt‹Æë{¹(èÃùÿÿH‹ØH…Àuè.ùÿÿÇ3ÀëZ¹
èfIƒ|ýu/º H‹Ëè˜ …ÀuH‹Ëè€ûÿÿèóøÿÿÇ3öëI‰\ýë	H‹ËèbûÿÿH‹
vßÿH©‹ÆH‹\$0H‹t$8H‹|$@HƒÄ A]ÃH‰\$WHƒì HcÙH=¤ÞHÛHƒ<ßuèõþÿÿ…ÀuHèÑÞÿÿH‹ßH‹\$0HƒÄ _Hÿ%ä¨H‰\$WHƒì0I‹ØH‹úH…Ét23ÒHBàH÷ñH;Çs$èHøÿÿHƒd$ E3ÉE3À3Ò3ÉÇè]÷ÿÿ3Àë]H¯ù¸H…ÿHDø3ÀHƒÿàwH‹
žúPL‹Çÿ*©H…Àu-ƒ=–útH‹Ïè¼…ÀuËH…Ût²ÇëªH…ÛtÇH‹\$@HƒÄ0_ÃÌH‰\$H‰l$H‰t$WHƒì0H‹òH‹éH…É„ûH…Ò„ò3ÿH‹ÙM…Àt!AŠ„Àt¿H;׆¼HYˆÆ:HÿÃI‹ÑM…ÉtAA€9t;HÿÇH;þƒ–ŠHÿˆHÿÀ:uåI‹ÉèØ8€8/t€8\tHÿÇH;þsmÆ\HÿÃH‹L$`H…ÉtëHÿÇH;þsSŠˆHÿÃHÿÁ€9uéH‹L$hH…Ét1Š„Àt+<.t"HÿÇH;þs(Æ.HÿÃëHÿÇH;þsŠˆHÿÃHÿÁ€9uéHGH;ÆvÆEè°öÿÿ»"ëÆ3Àë#èöÿÿ»Hƒd$ E3ÉE3À3Ò3ɉè±õÿÿ‹ÃH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌH‰\$H‰t$WHƒì@‹ÚH‹ÑHL$ A‹ùA‹ðèøÙÿÿH‹D$(D¶ÛA„|u…ötH‹D$ H‹ˆ@B·Y#Æë3À…Àt¸€|$8tH‹L$0ƒ¡ÈýH‹\$PH‹t$XHƒÄ@_ÃÌH‹Â‹ÑA¹H‹ÈE3ÀénÿÿÿÌÌ‹ÑA¹E3À3ÉéZÿÿÿÌÌHƒì8Hƒd$ èY7HƒÄ8ÃH‰L$HìˆH
îÿ§¦L‹xïL‰\$XE3ÀHT$`H‹L$Xè×sH‰D$PHƒ|$PtAHÇD$8HD$HH‰D$0HD$@H‰D$(H8îH‰D$ L‹L$PL‹D$XH‹T$`3Éè…së"H‹„$ˆH‰ïH„$ˆHƒÀH‰‘îH‹êîH‰[íH‹„$H‰\îÇ2í	ÀÇ,íH‹ÑØH‰D$hH‹ÍØH‰D$pÿ²¥‰œí¹è®(3Éÿ’¥H
K©ÿ}¥ƒ=víu
¹è†(ÿ\¥º	ÀH‹ÈÿF¥HĈÃÌÌH‰\$H‰l$H‰t$WHƒì HYH‹é¾H‹ËL‹Æ3ÒègÑÿÿE3ÛH}AKA·ÃD‰]D‰]D‰]fó«H=RÜH+ýŠˆHÿÃHƒîuòHºŠ9ˆHÿÁHƒêuòH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$H‰t$WHì€H‹·×H3ÄH‰„$pH‹ñ‹IHT$Pÿˤ»…À„=3ÀHT$pˆÿÀHÿÂ;ÃrõŠD$VÆD$p H|$Vë)¶WD¶ÀD;ÂwA+ÐI‹ÀJLpDB² èyÐÿÿHƒÇŠ„ÀuÓ‹Fƒd$8LD$p‰D$0‹FD‹Ë‰D$(H„$pº3ÉH‰D$ è›?ƒd$@‹F‹V‰D$8H„$p‰\$0H‰D$(LL$pD‹Ã3ɉ\$ èd<ƒd$@‹F‹V‰D$8H„$p‰\$0H‰D$(LL$pA¸3ɉ\$ è.<Lœ$pHN3ÒAöt€	Š„pëAöt€	 Š„pˆëÆHÿÁHÿÂIƒÃHƒëu¿ë?3ÒHNDBŸA@ ƒøw€	B ëAƒøw€	 BàˆëÆÿÂHÿÁ;ÓrÇH‹Œ$pH3Ìè’ÕÿÿLœ$€I‹[I‹s I‹ã_ÃÌH‰\$WHƒì èÝ
H‹ø‹ˆÈ…
FßtHƒ¸Àt	H‹˜¸ën¹
è÷øÿÿH‹Ÿ¸H‰\$0H;ÞtDH…ÛtðƒÿuHÇÙH‹L$0H;ÈtèüóÿÿH‹áÝH‰‡¸H‹ÓÝH‰D$0ðƒH‹\$0¹
è“÷ÿÿH…ÛuK è†×ÿÿH‹ÃH‹\$8HƒÄ _Ã@SHƒì@‹ÙHL$ 3ÒèÌÔÿÿƒ%Õîƒûþu%ÇÆîÿ@¢€|$8tSH‹L$0ƒ¡ÈýëEƒûýuÇœîÿ¢ëÔƒûüuH‹D$ Ç€î‹@뻀|$8tH‹D$0ƒ Èý‹ÃHƒÄ@[ÃH‰\$UVWATAUHƒì@H‹‰ÔH3ÄH‰D$8H‹òèIÿÿÿ3Û‹ø;Ãu
H‹ÎèüÿÿéL-ÝÜ‹ËH‹ëI‹ÅA¼98„'AÌIìHƒÀ0ƒùréÿèý„ÿéý„ø·Ïÿ_¡;ÄçHT$ ‹Ïÿ2¡;ÄÆHN3ÒA¸èÍÿÿ‰~‰^D9d$ †HD$&8\$&t-8Xt(¶8¶H;ùw+ÏHT7AÌ€
IÔI+ÌuõHƒÀ8uÓHF¹þ€IÄI+Ìuõ‹Né¤t(ƒétƒé
tA;Ìt‹Ãë¸ë¸ë¸ë¸‰FD‰fë‰^H~·Ã¹fó«éà9îì…·þÿÿƒÈÿéÖHN3ÒA¸è?ÌÿÿHlmL{ÛHíAºMDíI‹ÈA8t18Yt,¶¶A;ÐwLL2AŠAÔA¶AMÌ;ÐvìHƒÁ8uÏIƒÀMÜM+Ôu»‰~ï¤D‰ft$ƒïtƒï
tA;üu»ë»ë»ë»‰^HVI|í¹·HƒÇf‰HƒÂI+ÌuíH‹Îè|úÿÿ3ÀH‹L$8H3ÌèÍÑÿÿH‹œ$€HƒÄ@A]A\_^]ÃÌH‹ÄH‰XH‰pH‰xL‰` AUHƒì0‹ùAƒÍÿèH‹ðèüÿÿH‹ž¸‹Ïè¾üÿÿD‹à;C„¹ è\îÿÿH‹Ø3ÿH;Ç„|H‹–¸H‹ÈA¸ èå:‰;H‹ÓA‹ÌèýÿÿD‹è;Ç…$H‹Ž¸ðƒÿuH‹Ž¸L%ÂÕI;ÌtèüïÿÿëL%¯ÕH‰ž¸ðƒö†È…	öÈÚ…ü¹
èˆôÿÿ‹C‰
ë‹C‰ë‹C‰ë‹×‰T$ LW­ÿÿƒú}HcÊ·DKfA‰„Hˆ=ÿ‰T$ ëâ‹×‰T$ ú}HcÊŠDBˆ„ *ÿ‰T$ ëá‰|$ ÿ}HcÏŠ„Bˆ„0+ÿlj|$ ëÞH‹ÙðƒÿuH‹
ÙI;ÌtèïÿÿH‰ùØðƒ¹
èÃòÿÿë+ƒøÿu&L%­ÔI;ÜtH‹ËèäîÿÿèWìÿÿÇë3ÿD‹ïA‹ÅH‹\$@H‹t$HH‹|$PL‹d$XHƒÄ0A]ÃHƒì(ƒ=
òu¹ýÿÿÿèñýÿÿÇ÷ñ3ÀHƒÄ(ÃH‰\$H‰t$WHƒì H‹(H‹ÙH…ÀtyH
sÞH;ÁtmH‹ƒH…Àtaƒ8u\H‹‹ H…Étƒ9uè;îÿÿH‹‹(èC>H‹‹H…Étƒ9uèîÿÿH‹‹(èÙ=H‹‹èîÿÿH‹‹(èõíÿÿH‹ƒ0H…ÀtGƒ8uBH‹‹8HéþèÑíÿÿH‹‹H¿€H+Ïè½íÿÿH‹‹PH+Ïè®íÿÿH‹‹0è¢íÿÿH‹‹XH ÜH;Ètƒ¹`uèa;H‹‹XèuíÿÿH{X¾HaØH9GðtH‹H…Ét
ƒ9uèMíÿÿHƒøtH‹OH…Ét
ƒ9uè3íÿÿHƒÇ Hƒîu½H‹ËH‹\$0H‹t$8HƒÄ _éíÿÿÌÌðƒH‹H…ÀtðƒH‹ H…ÀtðƒH‹H…ÀtðƒH‹0H…ÀtðƒHAXA¸H·×H9PðtH‹H…ÒtðƒHƒxøt
H‹PH…ÒtðƒHƒÀ IƒèuÉH‹Xðƒ€`ÃÌÌÌH…É„˜AƒÉÿðD	H‹H…ÀtðDH‹ H…ÀtðDH‹H…ÀtðDH‹0H…ÀtðDHAXA¸H×H9PðtH‹H…ÒtðD
Hƒxøt
H‹PH…ÒtðD
HƒÀ IƒèuÉH‹XðDˆ`H‹ÁÃÌÌÌ@SHƒì H‹ÚH…ÒtAH…Étº…Àt@ˆ´$ˆ@ˆ¼$‰Æ„$ŠDJë@ˆ¼$ˆÆ„$‰D‹ÊH‹L$@‰T$8L„$ˆ‹A‰D$0‹AHL$@‰D$(HD$pH‰D$ èí0…Àu8D$XtH‹D$Pƒ Èý3Àë·D$p#Å€|$XtH‹L$Pƒ¡ÈýL\$`I‹kI‹s I‹ã_ÃÌÌÌH‹ÄH‰XH‰hH‰p ‰HWHƒì H‹ÊH‹Úè¶áÿÿ‹KHcðöÁ‚uèÞãÿÿÇ	ƒK ƒÈÿé4öÁ@t
èÂãÿÿÇ"ëâ3ÿöÁt‰{öÁ„‰H‹CƒáþH‰‰K‹C‰{ƒàïƒÈ‰C©u/è3¾ÿÿHƒÀ0H;Øtè%¾ÿÿHƒÀ`H;Øu‹Îèi;ÇuH‹ËèÑ;÷C„‹+H‹S+kHBH‰‹C$ÿÈ;ï‰C~D‹Å‹Îè¾!‹øëWƒÉ ‰Ké?ÿÿÿƒþÿt#ƒþþtH‹ÎH‹ÆHÀæƒáHÁøHkÉXHÂëH
ÇöA t3Ò‹ÎDBè:Hƒøÿ„ïþÿÿH‹KŠD$0ˆë½HT$0‹ÎD‹ÅèC!‹ø;ý…Åþÿÿ¶D$0H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌÌÌH‰\$H‰|$L‰l$ AVHƒì0L5ˆÑ‹ù3ÛI‹Æ;tÿÃHƒÀƒûrñƒûƒÔ¹èÿ<ƒø„|¹èì<…Àu
ƒ=9Æ„aÿü„šH=àA½LH‹ÏI‹Õè„6…ÀtHƒd$ E3ÉE3À3Ò3ÉèÛßÿÿHùßA¸3ÉÆîàÿ#’…Àu1L¨œH
Òߺûè36…ÀtHƒd$ E3ÉE3À3Ò3ÉèŠßÿÿH
¨ßèšHÿÀHƒø÷ÿÿL‹àH‹
tåè/÷ÿÿH‹ØI;Ä‚˜H‹øI+üLoIƒý‚„I‹Ìè:H‹ðI;ÅsTºH;ÂHBÐHÐH;ÐrI‹Ìè¿àÿÿ3ÛH;Ãuë3ÛHV H;ÖrFI‹Ìè£àÿÿH;Ãt9HÁÿHøH‹ÈèžöÿÿH‰óäI‹ÎèöÿÿH‰HKèƒöÿÿH‰ÐäI‹Þë3ÛèÄÅÿÿH‹ÃH‹\$@H‹t$HH‹|$PHƒÄ A^A]A\ÃÌÌÌHƒì(èïþÿÿH÷ØÀ÷ØÿÈHƒÄ(ÃÌH‰\$WHƒì HC¥H=<¥ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì H¥H=¥ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì HÃο
H‹èªõÿÿH‰HƒÃHƒïuëH‹\$0HƒÄ _ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‹Á¹MZf9t3ÀÃHcH%‹Ãë#èI¿ÿÿÇ	Hƒd$ E3ÉE3À3Ò3Éè^¾ÿÿƒÈÿH‹\$`HƒÄ0A\_^ÃÌH‰\$WHƒìPH‹ÚH‹ùH…Éu$è¿ÿÿHƒd$ E3ÉE3À3Ò3ÉÇè¾ÿÿ3ÀëvH…Òt×H;ÊsòHL$0I‹Ð耢ÿÿL‹\$8Aƒ{u€|$HHCÿtHH‹L$@ƒ¡Èýë:HSÿHÿÊH;úw¶BöDuíH‹ËH+ʃáH+Ù€|$HtH‹L$@ƒ¡ÈýHCÿH‹\$`HƒÄP_ÃÌÌE3Àé<ÿÿÿH‰\$H‰l$H‰t$WATAUHƒìPE3íI‹ùI‹ðH‹êH‹ÙM;ÍuI;ÍuI;Õu 3Àë>I;ÍtI;ÕvM;ÍuDˆ)ëèM;Åu?Dˆ)èý½ÿÿ»E3ÉE3À3Ò3ɉL‰l$ è½ÿÿ‹ÃL\$PI‹[ I‹k(I‹s0I‹ãA]A\_ÃH‹”$HL$0èh¡ÿÿL‹\$8H‹ÕH‹ËE9ku L‹ÏL‹ÆèXD8l$Ht±H‹L$@ƒ¡Èýë£HƒÿÿuŠHÿƈHÿÁA:Åt.Hƒêuëë&ŠHÿƈHÿÁA:ÅtHƒêtHƒïuåI;ýuDˆ)HÿÁI;Õ…D8.tHƒÿuYLaÿI‹ôL;ãr¶HT$0è'ÇÿÿA;ÅtHÿÎH;ósæA‹Ä+ƨt*Eˆ,$èô¼ÿÿº*‰D8l$HtH‹L$@ƒ¡Èý‹ÂéóþÿÿHƒÿÿu\HƒývOHt+þH‹þH;ór¶HT$0èÁÆÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt Dˆ.D8l$HtH‹D$@ƒ Èý¸Pé˜þÿÿDˆl+ÿëÜDˆ+èi¼ÿÿ»"E3ÉE3À3Ò3ɉL‰l$ è~»ÿÿD8l$H„aþÿÿH‹L$@ƒ¡ÈýéPþÿÿH‹ÁH+ÃHƒø|YHqþH‹þH;ór¶HT$0è!ÆÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt+Dˆ.èð»ÿÿº*‰D8l$H„ÿÿÿH‹D$@ƒ ÈýéóþÿÿD8l$H„ ýÿÿH‹D$@ƒ ÈýéýÿÿÌ@UATAUAVAWHƒì`Hl$@H‰]PH‰uXH‰}`H‹ŽŸH3ÅH‰ED‹$¾¾3ÿM‹ÙL‰MD‰ED‹ò‰UH‹ÙDnÿD;×uOLwE‹Íº3ɉ|$(H‰|$ ÿlm;ÇtE‹ÕD‰-Ò½ëÿ>lD‹ýƒøxDDÖD‰µ½L‹]D‹MpD;Ï~5A‹ÉI‹ÃA+Í@88t
IÅ;ÏuñƒÉÿA‹Á+ÁA+ÅA;Á}
DHD‰MpëD‹È‰EpD;Ö„\D;ׄSE;Õ…€D‹¥ˆ‹÷D;çuH‹D‹`÷M‹ÃA‹ÌÒ‰|$(H‰|$ ƒâAÕÿ¤lLcøD;ÿ„<H»ðÿÿÿÿÿÿA¾ÝÝA½~[3ÒHBàI÷÷HƒørLKL?I;Íw.HAH;ÁwH‹ÃHƒàðèZ\H+àH|$@H…ÿ„åÇÌÌëèîÿÿH‹øH…ÀtD‰0HƒÇH…ÿ„ÀD‹MpL‹EºA‹ÌD‰|$(H‰|$ ÿük3É;Á„K‹U‰L$(H‰L$ ‹ME‹ÏL‹ÇÿßkE3ÀHcðA;ð„!D‹UAºâ
s;‹…€A;À„;ðÿ‹M‰D$(H‹ExE‹ÏL‹ÇA‹ÒH‰D$ ÿkéÛA;ð~`3ÒHBàH÷öHƒørQHL6I;Íw*HAH;ÁwH‹ÃHƒàðèW[H+àH\$@I;ØtÇÌÌëèíÿÿE3ÀH‹ØI;ÀtD‰0HƒÃD‹UëI‹ØI;Øtn‹ME‹ÏL‹ÇA‹Ò‰t$(H‰\$ ÿk3É;Át?‹…€3ÒH‰L$8D‹ÎL‹ÃH‰L$0;Áu‰L$(H‰L$ ë
‰D$(H‹ExH‰D$ A‹ÌÿOj‹ðHKðD91uè»ÿÿHOðD91uèõºÿÿ‹ÆéÍH‹÷L‹çD;÷uH‹D‹pD‰u‹½ˆ…ÿuH‹‹xA‹Îèh D‹èƒøÿu3ÀéL‹}xL‹E;Ç„<3ÛLMp‹Ð‹Ï‰\$(H‰\$ è… H‹ðH;ÃtÉD‹Mp‹UL‹ÀA‹Î‰\$(H‰\$ ÿjLcÈD‰MD;Ëu‹ûéD;ËA¾ÝÝ~bI‹ÉIƒùàwYHƒÁHùw4HYH;Ùw
H»ðÿÿÿÿÿÿHƒãðH‹Ãè¾YH+ãH\$@H…Ût%ÇÌÌëè€ëÿÿH‹ØH…ÀtD‰0HƒÃD‹MH…Ûu3ÛëƒMcÁ3ÒH‹Ëè{”ÿÿD‹]D‹Mp‹U‹MD‰\$(L‹ÆH‰\$ ÿJi‰E…Àu3ÿë.‹…€LML‹Ã‰D$(‹×A‹ÍL‰|$ è‹}L‹à3ÀL;àDøHKðD91u(èg¹ÿÿë!‹…€D‹Mp‹U‰D$(A‹ÎL‰|$ ÿâh‹ø3ÛH;ótH‹Îè5¹ÿÿL;ãt
M;ütI‹Ìè#¹ÿÿ‹ÇH‹MH3Íè!šÿÿH‹]PH‹uXH‹}`He A_A^A]A\]ÃÌÌÌH‰\$H‰t$WHƒìp‹òH‹ÑHL$PI‹ÙA‹øèšÿÿ‹„$¸D‹œ$ÀHL$PD‰\$@‰D$8‹„$°‰D$0H‹„$¨L‹ËH‰D$(‹„$ D‹Ç‹Ö‰D$ èOúÿÿ€|$htH‹L$`ƒ¡ÈýL\$pI‹[I‹sI‹ã_ÃÌÌD‰L$ UATAUAVAWHƒì@Hl$0H‰]@H‰uHH‰}PH‹²™H3ÅH‰ED‹
L¸¿3ÛM‹ðD‹úL‹éwD;Ëu=LMH­qD‹Ç‹Ïÿ¶g;Ãt‰=¸ë6ÿ|fD‹
¸ƒøxDDÎD‰
÷·D;΄&D;Ë„D;Ï…C‹uh;óuI‹E‹p÷]xD‹MXM‹ÆҋΉ\$(ƒâH‰\$ ×ÿ,gLcàD;ã„A½ÝÝ~hH¸ðÿÿÿÿÿÿL;àwYKL$Hùw5HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèçVH+àH|$0H;û„µÇÌÌëè¥èÿÿH‹øH;ÃtD‰(HƒÇëH‹ûH;û„‹M‹Ä3ÒH‹ÏMÀ蜑ÿÿD‹MXM‹Æº‹ÎD‰d$(H‰|$ ÿvf;ÃtL‹M`D‹ÀH‹×A‹Ïÿwf‹ØHOðD9)u諶ÿÿ‹ÃéˆD‹epH‹ûD;ãuI‹ED‹`‹uh;óuI‹E‹pA‹Ìè"ƒøÿu3ÀëU;Æt$LMXM‹Æ‹Ð‹Î‰\$(H‰\$ èPH‹øH;Ãt×L‹ðH‹E`D‹MXM‹ÆA‹×A‹ÌH‰D$ ÿáe‹ðH;ûtH‹Ïè¶ÿÿ‹ÆH‹MH3Íè—ÿÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@A‹ÙI‹øèü–ÿÿ‹„$ D‹œ$¨HL$@D‰\$8‰D$0‹„$˜‰D$(H‹„$D‹ËL‹Ç‹ÖH‰D$ è.ýÿÿ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌÌÌÌÌÌÌÌÌÌÌff„L‹ÙH+Ñ‚žIƒøraöÁt6öÁtŠ
IÿȈHÿÁöÁtf‹
Iƒèf‰HƒÁöÁt
‹
Iƒè‰HƒÁM‹ÈIÁéuQM‹ÈIÁétH‹
H‰HƒÁIÿÉuðIƒàM…ÀuI‹ÃÃ@Š
ˆHÿÁIÿÈuóI‹ÃÃfffffff„fffffIù sBH‹
L‹T
HƒÁ H‰AàL‰QèH‹D
ðL‹T
øIÿÉH‰AðL‰QøuÔIƒàéqÿÿÿfff„fHúrµ¸ 
D
@HÁ€ÿÈuìHé¸@L‹
L‹T
LÃ	LÃQL‹L
L‹T
LÃILÃQL‹L
 L‹T
(HƒÁ@LÃIàLÃQèL‹L
ðL‹T
øÿÈLÃIðLÃQøuªIèIøƒqÿÿÿð€$é¹þÿÿffff„fffffffIÈIƒøraöÁt6öÁtHÿÉŠ
IÿȈöÁtHƒéf‹
Iƒèf‰öÁt
Hƒé‹
Iƒè‰M‹ÈIÁéuPM‹ÈIÁétHƒéH‹
IÿÉH‰uðIƒàM…ÀuI‹ÃÃHÿÉŠ
IÿȈuóI‹ÃÃfffffff„fffffIù sBH‹D
øL‹T
ðHƒé H‰AL‰QH‹D
L‹
IÿÉH‰AL‰uÕIƒàésÿÿÿffff„fHúðÿÿwµ¸ Hé€
D
@ÿÈuìHÁ¸@L‹L
øL‹T
ðLÃIøLÃQðL‹L
èL‹T
àLÃIèLÃQàL‹L
ØL‹T
ÐHƒé@LÃILÃQL‹L
L‹
ÿÈLÃILÃuªIèIøƒqÿÿÿð€$éºþÿÿH…É„àSHƒì H‹ÙH‹Iè²ÿÿH‹Kèý±ÿÿH‹Kèô±ÿÿH‹K èë±ÿÿH‹K(èâ±ÿÿH‹K0èÙ±ÿÿH‹èѱÿÿH‹K@èȱÿÿH‹KH迱ÿÿH‹KP趱ÿÿH‹KXè­±ÿÿH‹K`褱ÿÿH‹Khè›±ÿÿH‹K8è’±ÿÿH‹Kp艱ÿÿH‹Kx耱ÿÿH‹‹€èt±ÿÿH‹‹ˆèh±ÿÿH‹‹è\±ÿÿH‹‹˜èP±ÿÿH‹‹ èD±ÿÿH‹‹¨è8±ÿÿH‹‹°è,±ÿÿH‹‹¸è ±ÿÿH‹‹Àè±ÿÿH‹‹Èè±ÿÿH‹‹Ðèü°ÿÿH‹‹Øèð°ÿÿH‹‹àèä°ÿÿH‹‹èèØ°ÿÿH‹‹ðèÌ°ÿÿH‹‹øèÀ°ÿÿH‹‹è´°ÿÿH‹‹訰ÿÿH‹‹蜰ÿÿH‹‹è°ÿÿH‹‹ è„°ÿÿH‹‹(èx°ÿÿH‹‹0èl°ÿÿH‹‹8è`°ÿÿH‹‹@èT°ÿÿH‹‹HèH°ÿÿH‹‹Pè<°ÿÿHƒÄ [ÃÌÌH…ÉtBSHƒì H‹ÙH‹	H;
) tè°ÿÿH‹KH;
 tè°ÿÿH‹KH;
 tèò¯ÿÿHƒÄ [ÃH…É„‹SHƒì H‹ÙH‹IH;
ôŸtèɯÿÿH‹K H;
êŸtè·¯ÿÿH‹K(H;
àŸt襯ÿÿH‹K0H;
ÖŸt蓯ÿÿH‹K8H;
ÌŸtè¯ÿÿH‹K@H;
Ÿtèo¯ÿÿH‹KHH;
¸Ÿtè]¯ÿÿHƒÄ [ÃÌÌÌ@SHƒì0L‹ÉH…Ét
H…ÒtM…Àu,Dˆ謬ÿÿ»Hƒd$ E3ÉE3À3Ò3ɉèÀ«ÿÿ‹ÃHƒÄ0[À9t	HÿÁHƒêuòH…ÒuAˆë¿AŠIÿÀˆHÿÁ„ÀtHƒêuëH…ÒuAˆèN¬ÿÿ»"ë 3ÀëµÌÌÌ@SHƒì0M‹ØM…ÉuH…ÉuH…Òu 3Àë?H…ÉtH…ÒtM…ÉuDˆ	ëèM…Àu,Dˆè¬ÿÿ»Hƒd$ E3ÉE3À3Ò3ɉè«ÿÿ‹ÃHƒÄ0[ÃL‹ÑL‹ÂIƒùÿuAŠIÿÃAˆIÿ„Àt,Iƒèuêë$AŠIÿÃAˆIÿ„ÀtIƒètIƒéuäM…ÉuEˆ
M…À…fÿÿÿIƒùÿuDˆDÿA@Pë˜Æèu«ÿÿ»"émÿÿÿÌÌÌ@SHƒì0H…Ét
H…ÒtM…Àu,DˆèK«ÿÿ»Hƒd$ E3ÉE3À3Ò3ɉè_ªÿÿ‹ÃHƒÄ0[ÃL‹ÉAŠIÿÀAˆIÿÁ„ÀtHƒêuêH…Òuˆè«ÿÿ»"ëµ3ÀëÊÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff„H+ÑL‹ÊöÁtŠBŠ	:ÂuVHÿÁ„ÀtWH÷ÁuæI»J	fâÿfúøwËH‹J‹	H;Âu¿Iºÿþþþþþþ~LÒHƒðÿHƒÁI3ÂI…ÃtÇëHÀHƒØÿÃ3ÀÃfff„Òt'„öt#HÁê„Òt„ötHÁê„Òt„ötÁê„Òt„öu‹3ÀÃHÀHƒØÿÃÌÌÌÌÌÌff„H+ÑIƒør"öÁtfŠ:
u,HÿÁIÿÈöÁuîM‹ÈIÁéuM…ÀtŠ:
uHÿÁIÿÈuñH3ÀÃÀƒØÿÃIÁét7H‹H;
u[H‹AH;D
uLH‹AH;D
u=H‹AH;D
u.HƒÁ IÿÉuÍIƒàM‹ÈIÁét›H‹H;
uHƒÁIÿÉuîIƒàëƒHƒÁHƒÁHƒÁH‹HÈHÉH;ÁÀƒØÿÃÌH‰\$WHƒì HcÙA‹øH‰T$8‹Ëèø
Hƒøÿuè-©ÿÿÇ	HƒÈÿëW‹T$8LD$H‹
i¨H;Ït2è?½ÿÿH…Àt(ÿÐH‹ØH…ÀtH‹
Q¨H;Ïtè½ÿÿH…ÀtH‹ËÿÐH‹ØH‹
#¨è½ÿÿH…ÀtD‹ÍM‹ÅI‹ÖH‹ËÿÐë3ÀH‹\$pH‹l$xHƒÄ@A^A]A\_^ÃHƒì8…Éx ƒù~
ƒùu‹›ë1‹›‰
›ë#è¥ÿÿHƒd$ E3ÉE3À3Ò3ÉÇè$¤ÿÿƒÈÿHƒÄ8ÃHƒì8H…Éu&èÞ¤ÿÿHƒd$ E3ÉE3À3Ò3ÉÇèó£ÿÿHƒÈÿëL‹ÁH‹
G§3ÒÿWHƒÄ8ÃÌ̹éæŠÿÿÌÌHì¨öŽ—t
¹
èþÁÿÿèuÉÿÿH…Àt
¹èrÉÿÿög—t_HŒ$ÐÿgUHL$03ÒA¸˜èuÿÿH‹„$¨3ÉH‰D$@HD$0ÇD$0@H‰D$ H„$ÐH‰D$(ÿUHL$ ÿîT¹è˜ÿÿÌÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒìPL‹òH‹ÑHHÈE‹áM‹èèv‡ÿÿM…ítM‰uM…öu*诣ÿÿHƒd$ E3ÉE3À3Ò3ÉÇèÄ¢ÿÿ€|$HééE…ätAƒü|ËAƒü$ÅAŠ.L‹D$03ÿI^Aƒ¸~LD$0@¶Íºè2¾ÿÿL‹D$0ëI‹€@@¶Í·Hƒà…Àt@Š+HÿÃ뾋´$@€ý-uƒÎë@€ý+u@Š+HÿÃE…äˆSAƒü„IAƒü$?E…äu(@€ý0tA¼
ë8€;xt
€;XtA¼ë&A¼ëAƒüu@€ý0u€;xt€;Xu@ŠkHƒÃM‹@3ÒƒÈÿA÷ôD‹È@¶ÍE·JAöÀt	@¾Íƒé0ëA÷Àt,EŸ@¾Í<wƒé ƒÁÉA;ÌsƒÎA;ùr"u;ÊvƒÎM…íuHÿË@öÆuM…íIEÞ3ÿëYA¯üù@Š+HÿÃ둽ÿÿÿ@öÆu@öÆu:‹Æƒàtÿ€w…Àu';ýv#èõ¡ÿÿÇ"@öÆtƒÏÿë
@ŠÆ$öØÿ÷ßýM…ítI‰]@öÆt÷߀|$HtH‹L$@ƒ¡Èý‹ÇëM…ítM‰u@8|$HtH‹D$@ƒ Èý3ÀL\$PI‹[ I‹k(I‹s0I‹{8I‹ãA^A]A\ÃÌÌHƒì83ÀE‹ÈL‹Â‰D$ H‹Ñ9;Ÿu	H
Rë3ÉèQýÿÿHƒÄ8ÃH‰\$WHƒì Hcù‹ÏèìHƒøÿtYH‹㤹ƒÿu	@„¸¸u
;ùuö@`tè½¹H‹Øè°H;Ãt‹Ïè¤H‹Èÿ?S…Àu
ÿíQ‹Øë3Û‹ÏèØL‹ßH‹ÏHÁùAƒãHs¤H‹ÊMkÛXBÆD…Ût‹ËèÖ ÿÿƒÈÿë3ÀH‹\$0HƒÄ _ÃH‰\$H‰t$ ‰L$WATAUHƒì0HcÙƒûþu耠ÿÿ3ÿ‰8èW ÿÿÇ	ƒÈÿéÉ3ÿ;ߌ–;壃ŠH‹óL‹ãIÁüL-棃æHköXK‹Då¾L0ƒáu+è' ÿÿ‰8è ÿÿÇ	H‰|$ E3ÉE3À3Ò3ÉèŸÿÿƒÈÿëa‹ËèK‹DåöD0t‹Ëè†þÿÿ‹øë轟ÿÿÇ	ƒÏÿ‹Ë虋Çë)èÄŸÿÿ‰8èŸÿÿÇ	H‰|$ E3ÉE3À3Ò3É賞ÿÿƒÈÿH‹\$`H‹t$hHƒÄ0A]A\_Ã@SHƒì öAƒH‹Ùt"öAtH‹IèÖ¡ÿÿc÷ûÿÿ3ÀH‰H‰C‰CHƒÄ [ÃÌHƒìhH‹-ƒH3ÄH‰D$Pƒ="’f‰L$@tfH‹
è’HƒùþuèÑH‹
Ö’Hƒùÿ„¹Hƒd$ LL$DHT$@A¸ÿPQ…À…‰ƒ=Í‘…ˆÿÕOƒøxu}ƒ%µ‘ÿQHƒd$8Hƒd$0‹ÈHD$HLD$@A¹3ÒÇD$(H‰D$ ÿ8PH‹
I’Hƒùÿt0Hƒd$ LL$DHT$HD‹ÀÿºP…Àtf‹D$@ëÇA‘ëí¸ÿÿH‹L$PH3Ìè¹ÿÿHƒÄhÃH‰\$H‰l$H‰t$WHƒìP3íI‹ðH‹úH‹ÙH;ÕtL;Åt
@8*uH;Ítf‰)3ÀH‹\$`H‹l$hH‹t$pHƒÄP_ÃHL$0I‹ÑèzÿÿL‹\$0A9ku%H;Ýt¶f‰@8l$HtH‹D$@ƒ Èý¸ë®¶HT$0èÎÿÿ;Å„œH‹L$0D‹‰Aƒù~0A;ñ|+‹I‹ÅH;Ý•ÀL‹Çº	‰D$(H‰\$ ÿtOH‹L$0;ÅuHcH;ðr(@8ot"‹@8l$H„4ÿÿÿH‹L$@ƒ¡Èýé#ÿÿÿèÿÿÇ*@8l$HtH‹D$@ƒ ÈýƒÈÿéýþÿÿ‹ÅA¹H;Ý•ÀAQL‹Ç‰D$(H‹D$0H‰\$ ‹HÿåN;Å…ÿÿÿë¤ÌÌÌE3Éé„þÿÿÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WHƒì H‹Ú…Éxi;
' saHcùH-3 H‹÷ƒçHÁþHkÿXH‹DõHƒ<ÿu=ƒ=j€u'…Étƒétƒùu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿÿ©NH‹DõH‰3ÀëèœÿÿÇ	è(œÿÿƒ ƒÈÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌH‰\$H‰l$WHƒì …Éxs;
ŸskHcÙH-‹ŸH‹ûƒãHÁÿHkÛXH‹DýöDtGHƒ<ÿt@ƒ=»u)…Étƒétƒùu¹ôÿÿÿë¹õÿÿÿë¹öÿÿÿ3ÒÿøMH‹DýHƒÿ3Àëèa›ÿÿÇ	èv›ÿÿƒ ƒÈÿH‹\$0H‹l$8HƒÄ _ÃHƒì8ƒùþuèR›ÿÿƒ è*›ÿÿÇ	ë]…Éx1;
Äžs)HcÑH
ОH‹ÂƒâHÁøHkÒXH‹ÁöDtH‹ë,è›ÿÿƒ èàšÿÿHƒd$ E3ÉE3À3Ò3ÉÇ	èõ™ÿÿHƒÈÿHƒÄ8ÃH‹ÄH‰XH‰pH‰xL‰` AUHƒì HcÙL‹ãIÁüL-VžƒãHkÛXK‹t心|3u3O	辡ÿÿƒ|3uHL3º èïÁÿÿ÷ØÒ#úÿD3¹
è“ ÿÿ…ÿtK‹LåHLÿ§J‹ÇH‹\$0H‹t$8H‹|$@L‹d$HHƒÄ A]ÃÌÌHcÑH
ÎH‹ÂƒâHÁøHkÒXH‹ÁHLHÿ%hJH‰\$H‰|$L‰d$AUAVAWHƒì@IƒÌÿE‹ìE3öAL$è# ÿÿ…ÀuA‹Äéɹèõ ÿÿ3ÿ‰|$$H_ƒÿ@›LcÿJ‹øH…Û„H‰\$0J‹øHH;؃ÍöC…ªƒ{u;¹
蜠ÿÿƒ{u HKº èÏÀÿÿ…ÀuDpD‰t$(ëÿC¹
èkŸÿÿE…öu HKÿ„IöCtHKÿ|IëHIƒÌÿE…öu?ÆCL‰#L«œK+øH¸£‹.ºè¢‹.H÷ëL‹êIÁýI‹ÅHÁè?Lè‹ÇÁàDèD‰l$ ëHƒÃXH‰\$0IƒÌÿHfœé ÿÿÿE;ì…ÿlj|$$HKœéçþÿÿºXJÈèi™ÿÿH‰D$0H…ÀttHc×L%œI‰Ѓœ I‹ÐHÁH;ÁsÆ@L‰ Æ@	
ƒ`HƒÀXH‰D$0ëÖÁç‰|$ HcÏH‹ÁHÁøƒáHkÉXI‹ÀÆD‹ÏèHýÿÿ…ÀADüD‹ï‰|$ ¹è9žÿÿA‹ÅH‹\$`H‹|$hL‹d$pHƒÄ@A_A^A]ÃHƒì8H‹É{H3ÄH‰D$(LD$ A¹ºÆD$&ÿîI…ÀuƒÈÿë
HL$ è›H‹L$(H3Ìè{ÿÿHƒÄ8ÃÌ@USVWATAUAVAWHìˆHl$@H‹`{H3ÅH‰E0L‹µ°E‹!3ÿI‹ØH‹÷‰}L‰MD‹êD‹ùH‰];Ê„HUÿTH;Ç„Ÿƒ}…•HUA‹Íÿ5H;Ç„€ƒ}uzÇEAƒüÿt`A‹ü…ÿŽ©HcÏH¸ðÿÿÿÿÿÿH;ȇ“HL	HùwlHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèÏ8H+àH\$@H…Ût<ÇÌÌëNH‹Ëè¢Çÿÿxë–E‹ÌL‹ÃºA‹Ï‰|$(H‰|$ ÿˆH‹ø…À…oÿÿÿ3Àé7èVÊÿÿH‹ØH…ÀtÇÝÝHƒÃë3ÛH…ÛtÙLcÇ3ÒH‹ËMÀèOsÿÿL‹EE‹ÌºA‹Ï‰|$(H‰\$ ÿ)HE3ÿA;Ç„ÉM;÷t;‹…¸L‰|$8L‰|$0‰D$(D‹ÏL‹Ã3ÒA‹ÍL‰t$ ÿ†GA;Ç„‘I‹öé‰D9}u,L‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹ÍD‰|$(L‰|$ ÿJG‹øA;ÇtWHc×¹èf–ÿÿH‹ðI;ÇtBL‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹Í‰|$(H‰D$ ÿ
GA;Çu
H‹ÎèÁ—ÿÿI‹÷ëAƒüÿtH‹M‰HKð9ÝÝu蟗ÿÿH‹ÆH‹M0H3ÍèœxÿÿHeHA_A^A]A\_^[]ÃÌÌÌ3ÒDB
éyóÿÿÌL‹ÑM…Àtˆt_è+…ÀuVH‹ˆH…ÛtJH…ötEH‹ÎèŠÃÿÿH‹øH‹H…Ét2èzÃÿÿH;ÇvH‹€<9=uL‹ÇH‹ÖèÝ…ÀtHƒÃëÐH‹HD8ë3ÀH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰t$H‰|$ATHƒì0I‹ðH‹ÚH‹ù¹è8™ÿÿ3ÀH…ÿ•À…Àu&èÚ‘ÿÿ»‰Hƒd$ E3ÉE3À3Ò3Éèîÿÿé¶Hƒ'H…ÛtHƒ#3ÀH…ö•À…Àu#蛑ÿÿ»‰Hƒd$ E3ÉE3À3Ò3Éè¯ÿÿëzH‹Îè½þÿÿH‹ðH…Àu3ÛëfH‹Èè…ÂÿÿºL$I‹Ìè(nÿÿH‰H…ÀuèC‘ÿÿÇè8‘ÿÿ‹ë1L‹ÆI‹ÔH‹Èè¾åÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèÿÿH…ÛtL‰#3Û¹èE—ÿÿ‹ÃH‹\$@H‹t$HH‹|$PHƒÄ0A\ÃÌH‰l$WHƒìpHcùHL$Pè}tÿÿÿsbH‹T$Pƒº~LD$Pº‹Ï膫ÿÿH‹T$PëH‹‚@·xƒà…ÀtH‹‚H¶8éè€|$htH‹D$`ƒ Èý‹ÇéáH‹D$Pƒ¸~6‹ïHT$PÁý@¶Íè¶Àÿÿ…Àt@ˆ¬$€@ˆ¼$Æ„$‚ºë èÿÿºÇ*@ˆ¼$€Æ„$H‹L$PÇD$@LŒ$€‹AA¸‰D$8H„$ÇD$0H‰D$(‰T$ ‹QHL$PèCÙÿÿ…À„2ÿÿÿƒø¶„$t
¶Œ$‘ÁàÁ€|$htH‹L$`ƒ¡ÈýH‹¬$ˆHƒÄp_ÃH‹ÄH‰XH‰hH‰pWHƒì`H‹ñH‹úHHØI‹ÑI‹éI‹ØèørÿÿH…Ûu8\$XtH‹D$Pƒ Èý3Àé¯H…öu:èÿÿHƒd$ E3ÉE3À3Ò3ÉÇè1Žÿÿ€|$XtH‹D$Pƒ Èý¸ÿÿÿëpH…ÿtÁHûÿÿÿw¸H‹L$HƒyuL‹ÍL‹ÃH‹×H‹ÎèÁë1‹A‹QHL$@‰D$8‰\$0L‹ÎA¸H‰|$(‰\$ è	…ÀtŒƒÀþ€|$XtH‹L$Pƒ¡ÈýL\$`I‹[I‹kI‹s I‹ã_ÃÌE3ÉéèþÿÿH‰\$H‰l$WHƒì@Hƒd$PH‹ðƒH‹H…À„ªƒÍÿHƒd$8Hƒd$0ƒd$(Hƒd$ D‹ÍL‹À3Ò3ÉÿÊ?Hcø…À„‘H‹ÏºèâŽÿÿH‰D$PH…ÀtzHƒd$8Hƒd$0L‹D‹Í3Ò3ɉ|$(H‰D$ ÿƒ?…ÀtGHL$P3ÒèË…ÀyH‹L$PH…Étè$ÿÿHƒd$PHƒÃH‹H…À…Yÿÿÿ3ÀH‹\$XH‹l$`HƒÄ@_ÃH‹L$Pèòÿÿ‹ÅëâÌÌ@USVWATAUAVAWHƒìhHl$0H‹KqH3ÅH‰E(H‹½¨D‹Ò‰U‹ÍA»3ÛM‹ùD‰EL‹ñH‰}Ecÿ;ÓuOL8IE‹Ì3Ò3ÉD‰d$(L‰D$ ÿ?;Ãt
A‹ÔE\$ëÿù=‹wA»ƒøxADÓD‹U‰`D‹ D;Ë~YA‹ÉI‹ÇA+̃Îÿ8t	IÄ;Ëuï‹Î‹Æ+ÁDÈD‰ D‹…°D;Ã~5A‹ÈH‹ÇA+Ì8t	IÄ;Ëuò‹Î‹Æ+ÁDÀD‰…°ëƒÎÿD;Î}Æ3Àé¥D;Æ|ôA;Ó„¯;Ó„§A;ÔuÞD‹­¸D;ëuI‹D‹iD;Ët	D;Ã…«E;ÈuA‹Ãé\E;Ä~A‹ÄéOE;Ì~
¸é@HUA‹Íÿ=;ÃtƒD‹ D;Ë~2ƒ}rÓ8]HEtÊ8XtÅAŠ:r:HvHƒÀ8ëå¸éñ9°~+ƒ}rŒ8]HEtƒ8X„zÿÿÿŠ:r:HvËHƒÀ8ëâM‹Çº	A‹Í‰\$(H‰\$ ÿw=LcðD;ó„ìþÿÿI¸ðÿÿÿÿÿÿ~d3ÒHBàI÷öHƒørUKL6Hùw.HAH;ÁwI‹ÀHƒàðè5-H+àHt$0H;ó„þÿÿÇÌÌëèó¾ÿÿH‹ðH;ÃtÇÝÝHƒÆëH‹óH;ó„pþÿÿD‹ M‹ÇA‹ÔA‹ÍD‰t$(H‰t$ ÿÏ<;ÄôD‹°L‹Çº	A‹Í‰\$(H‰\$ ÿ¦<LcàD;ã„Ç~g3ÒHBàI÷ôHƒørXKL$Hùw1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèg,H+àH|$0H;ûtÇÌÌëè)¾ÿÿH‹øH;ÃtÇÝÝHƒÇëH‹ûH;ûtVD‹°L‹EºA‹ÍD‰d$(H‰|$ ÿ<;Ãt‹U‹ME‹ÎL‹ÆD‰d$(H‰|$ ÿV<‹ØHOð9ÝÝuè/ŒÿÿHNð9ÝÝuèŒÿÿ‹ÃéèH‹ûL‹ëD;ÓuI‹D‹PD‰UD‹¥¸D;ãuI‹D‹`A‹ÊèŽñÿÿD‹ð;Æ„ýÿÿA;ÄteL M‹Ç‹ÐA‹Ì‰\$(H‰\$ èµñÿÿH‹øH;ÄÒüÿÿL‹EL°A‹ÖA‹Ì‰\$(H‰\$ èŠñÿÿL‹èH;Ãu
H‹Ïè~‹ÿÿéžüÿÿL‹ÿL‹ÀëL‹E‹…°D‹ ‹U‹M‰D$(L‰D$ M‹ÇÿT;‹ðH;ûtH‹Ïè9‹ÿÿI‹Íè1‹ÿÿ‹ÆH‹M(H3Íè/lÿÿHe8A_A^A]A\_^[]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@I‹ÙA‹øèlÿÿD‹œ$¨‹„$ HL$@D‰\$8‰D$0H‹„$˜H‰D$(‹„$L‹ËD‹Ç‹Ö‰D$ è¾úÿÿ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$H‰t$WHƒì`H‹ñH‹úHL$@I‹ÑI‹Øè‹kÿÿH…Ûu8\$XtH‹D$Pƒ Èý3ÀéÂH…öu=诇ÿÿHƒd$ E3ÉE3À3Ò3ÉÇèĆÿÿ€|$XtH‹D$Pƒ Èý¸ÿÿÿé€H…ÿt¾HûÿÿÿwµH‹D$@‹P…ÒuLL$@L‹ÃH‹×H‹Îèªòÿÿë>‹@HL$@L‹Î‰D$8‰\$0A¸H‰|$(‰\$ è™þÿÿ…Àuè‡ÿÿÇéyÿÿÿƒÀþ€|$XtH‹L$Pƒ¡ÈýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$‰T$UVWATAUAVAWHƒì0E3í‹êL‹ñA‹ÝI;Íu$è·†ÿÿE3ÉE3À3Ò3ÉL‰l$ ÇèÍ…ÿÿéêL‹!M;å„Óº=I‹Ìè³H‹øH‰D$pI;Å„µL;à„¬D8hH‹5þ{E‹ýA”ÇH;5ø{upH‹îA‹ÅI;õuI‹õëUHƒÆÿÀL9.uõÿÀºHcÈè‡ÿÿH‹øH‹ðI;Åu¹	èWlÿÿëH‹ÈèÍH‰HƒÇHƒÅH‹EI;ÅuäL‰/H‹|$p‹l$xH‰5~{I;õ…‰A;ít9L9-y{t0èf÷ÿÿA;Åtjè´…ÿÿǃÈÿH‹œ$€HƒÄ0A_A^A]A\_^]ÃE;ýt3Àëß¹è†ÿÿH‰{I;ÅtÆL‰(L9-{u¹èæ…ÿÿH‰{I;Åt¤L‰(H‹5ìzH‹îI;õt’H‹‹ÇH‹þA+ÄLcèH…Ét?H‹ÑM‹ÅI‹Ìè¿öÿÿ…ÀuH‹A€|=„¢A8\„—HƒÇH‹H…ÉuÈH‹5’zH+þHÁÿ÷ßE3íA;ýŒŒL9m„‚Hc÷H‹LõèJ‡ÿÿE;ýtfL9lõtHLõH‹ÿÇHƒÁH‰DõHÿÆL9lõuèHc×H¸ÿÿÿÿÿÿÿH;Ѓ“H‹
 zA¸èq†ÿÿI;Åt|ësH‹5zH+þHÁÿérÿÿÿL‰dõM‰.ë]E;ý…A;ý}÷ßG;ÇŒ„þÿÿLcÀH¸ÿÿÿÿÿÿÿL;ÀƒnþÿÿºH‹Îè†ÿÿI;Å„XþÿÿHcÏL‰$ÈL‰lÈM‰.H‰”yD9l$x„ŠI‹ÌèµÿÿºHHèÄÿÿH‹øI;ÅtlI‹Ìèã´ÿÿM‹ÄH‹ÏHPèHØÿÿA;ÅtE3ÉE3À3Ò3ÉL‰l$ èŸÿÿH‹×H‹ÏI+ÔHT$pDˆ*HÿÂE;ýIEÕÿ6A;ÅuƒËÿèiƒÿÿÇ*H‹Ïèã…ÿÿE;ýtI‹ÌèÖ…ÿÿM‰.‹Ãé™ýÿÿI‹ÌèÄ…ÿÿM‰.é¦ýÿÿH‰\$H‰t$WHƒì0H‹ÙH…ÉtFè<´ÿÿH‹ðHHè·ÿÿH‹øH…Àt-HVL‹ÃH‹Èè×ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éèä€ÿÿH‹Çë3ÀH‹\$@H‹t$HHƒÄ0_ÃÌH‰\$H‰t$WHƒìPH‹Ù‹úHL$0I‹ÐèWfÿÿ3öH;ÞuDè—‚ÿÿE3ÉE3À3Ò3ÉH‰t$ Çè­ÿÿ@8t$HtH‹D$@ƒ Èý3ÀH‹\$`H‹t$hHƒÄP_ÃH‹T$89ru‹×H‹Ëè€@8t$HtÕH‹L$@ƒ¡ÈýëǶf;Ît3¶ÁöDtHÿÃ@83t˜¶·ÉÁáÈ;ùu
HCÿë¼·Á;øtHÿÃëÅ·Á;ø…lÿÿÿ@8t$HtH‹D$@ƒ ÈýH‹ÃéfÿÿÿÌÌE3Àéÿÿÿë:Ât
HÿÁŠ„Àuó:ÂuH‹ÁÃ3ÀÃÿ%X2ÿ%¢2ÿ%¤2Hƒì8H…Éu&èŠÿÿHƒd$ E3ÉE3À3Ò3ÉÇ蟀ÿÿHƒÈÿë€9tÕH…ÒtÐH‹H…ÀtÈ€8tÃE3Àè‚HƒÄ8ÃÌH‰T$‰L$SUVWATAUAVAWHƒìXA¼þÿÿÿHcÁA‹ØD‰d$4‰\$8A;Äuè,ÿÿ3ÿ‰8èÿÿÇ	é3ÿ;ÇŒï;”„ƒãH‹ðL‹ðL
AÿÿIÁþƒæK‹Œñ€CHköXŠD1¨„·ûÿÿÿvèÉ€ÿÿ‰8袀ÿÿÇ骋ï;ß„Š¨…‚H;×tÒDŠ|18A¸EÿAÐÿA¾Ïƒétƒéu‹Ã÷Шt«ƒãþL‹êëd‹Ã÷Шt›ÑëA;ØABØ‹ËèÁ€ÿÿL‹èH;Çuè,€ÿÿÇèA€ÿÿÇé=‹Œ$ 3ÒDBè°ÖÿÿL
A@ÿÿL‹ØK‹„ñ€CL‰\0@K‹„ñ€CI‹ÕA¸
öD0H„œŠL0	A:È„;ß„‡AˆMK‹„ñ€CAƒÊÿAÚIUAh÷DˆD0	D:ÿtbK‹„ñ€CŠL09A:ÈtQ;ßtMˆ
K‹„ñ€CAÚHÿÂAhøDˆD09A€ÿu.K‹„ñ€CŠL0:A:Èt;ßtˆ
K‹„ñ€CHÿÂAhùAÚDˆD0:K‹Œñ€CLL$0D‹ÃH‹1H‰|$ ÿÂ1;Ç„ÏHcT$0;׌‹ÃH;Ї·L3?ÿÿêK‹„ð€CöD0€„yA€ÿ„¸;×tA€}
u€L0ë€d0ûHcÅI‹ÝM‹åIÅH‰D$@L;èƒ:½
AŠ$<„
@:Åt
ˆHÿÃIÿÄéëH‹D$@HÿÈL;àsID$€8
u	IƒÄéL‹àé½K‹Œð€CLL$0H”$°H‹1A¸IÿÄH‰|$ ÿÓ0;Çu
ÿ9/;Çu{9|$0tuLP>ÿÿK‹„ð€CöD0Ht"€¼$°
t'@ˆ+K‹Œð€CŠ„$°ˆD1	ëGI;Ýu€¼$°
uÆ
ë3‹Œ$ A¸HƒÊÿè]Ôÿÿ€¼$°
Læ=ÿÿtëLÛ=ÿÿ@ˆ+HÿÃL;d$@‚ìþÿÿëK‹„ð€CöD0@u€L0ë	AŠ$ˆHÿËëA+íA€ÿ…ð;ï„èA¿I+ßö€uIßé²A‹×ëƒúI;ÝrI+ßA׶B8¼4tã¶B¾„4;Çuè}ÿÿÇ*AƒÌÿé‘ÿÀ;ÂuHcÂHØë^K‹„ð€CöD0Ht;I߃úˆL0	|ŠK‹Œð€CI߈D19ƒúuŠK‹Œð€CI߈D1:HcÂH+Øë‹Œ$ ÷ÚE‹ÇHcÒè2Óÿÿ‹D$8L‹¼$¨A+ÝÑèD‹ËM‹Å‰D$(3Ò¹éýL‰|$ ÿ….‹è;Çuÿi-‹Èè†|ÿÿAƒÌÿéäD‹d$4;ÃHs<ÿÿJ‹„ð€C@•Çí‰|0Hé¿;׺
tfA9Uu€L0ë€d0ûHcÅI‹ÝM‹åN<(M;ïƒ{½
A·$fƒø„Ef;Åtf‰HƒÃIƒÄé%IGþL;àsID$f9u	IƒÄéÂL‹àéúK‹Œð€CLL$0H”$¸H‹1A¸IƒÄH‰|$ ÿ.;Çuÿ},;Ç…®9|$0„¤LŒ;ÿÿK‹„ð€CöD0HtFº
f9”$¸tKf‰+Š„$¸K‹Œð€CˆD1	Š„$¹K‹Œð€CˆD19K‹„ð€CˆT0:ëWI;Ýuº
f9”$¸uf‰ë>‹Œ$ HÇÂþÿÿÿDBèoÑÿÿº
Lû:ÿÿf9”$¸tëº
Lã:ÿÿf‰+HƒÃM;ç‚®þÿÿë"K‹„ð€CöD0@u€L0ëA·$f‰HƒÃ‹ëA+íD‹d$4L‹¼$¨M;ïtI‹ÍèÔ|ÿÿAƒüþDDåA‹ÄëiÿU+ƒøuè/zÿÿÇ	èDzÿÿÇéýÿÿƒømuD‹ç뮋ÈèHzÿÿéýÿÿ3Àë)èzÿÿ‰8èóyÿÿÇ	E3ÉE3À3Ò3ÉH‰|$ è	yÿÿƒÈÿHƒÄXA_A^A]A\_^][ÃÌH‰\$H‰t$‰L$WATAUAVAWHƒì0A‹ðL‹êHcùƒÿþuè¶yÿÿ3Û‰èyÿÿÇ	ƒÈÿé3Û;ûŒâ;=}ƒÖL‹çL‹÷IÁþL=}AƒäMkäXK‹÷B¾L ƒáu.è\yÿÿ‰è5yÿÿÇ	H‰\$ E3ÉE3À3Ò3ÉèKxÿÿƒÈÿé©‹ÃAøÿÿÿ–À;Ãu+èyÿÿ‰è÷xÿÿÇH‰\$ E3ÉE3À3Ò3Éè
xÿÿƒÈÿën‹ÏèÞÿÿK‹÷BöD tD‹ÆI‹Õ‹Ïès÷ÿÿ‹Øëè®xÿÿÇ	èÃxÿÿ‰ƒËÿ‹ÏèƒÞÿÿ‹Ãë)è®xÿÿ‰è‡xÿÿÇ	H‰\$ E3ÉE3À3Ò3ÉèwÿÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌH‹ÄH‰XL‰@H‰HUVWATAUAVAWHì€3ÿA´€A‹ñH‹ÚÇ@¨o‰xœ@ˆ¼$ØH‰x°E„Ìt‰x¸A¶ë‰l$pDŠ÷HL$Tè©;ÇtE3ÉE3À3Ò3ÉH‰|$ èÝuÿÿºær÷Æ@u
|$T€tE
ô‹ÎA¸¸ÀA#Ⱥ€;ÏtT+Ít:;Ít1è´wÿÿ‰8ƒÿèŠwÿÿ»E3ÉE3À3Ò3ÉH‰|$ ‰èŸvÿÿ‹ÃéûD‹øë@öÆt÷ÆuíA¿@ëD‹ú‹Œ$àA¼ƒét,ƒét#ƒétƒétƒù@u‹D;ú‹Ï”ÁëA‹ÈëA‹Ìë‹Íë‹Ï‹Æº‰L$H#ÂtF=t8=t*=t=t*=t&=t;Âté/ÿÿÿA‹ìë½ë
½ëA‹èºæA½€D‰l$PsŠ'löÐ"„$言AEDDèD‰l$P@öÆ@tAºíAºïƒÉD‰l$P‰L$Hºæs
AºíD‰l$P@öÆ tAºíë@öÆt
AºíD‰l$PèIÜÿÿ‰ƒøÿu!èIvÿÿ‰8ƒÿèvÿÿÇèvÿÿ‹é H‹„$ÀD‹D$HH‹Œ$ÐH‰|$0LL$`A‹×D‰l$(ljl$ ÿb(H‰D$XHƒøÿ…Œ¹ÀA‹Ç#Á;ÁuC¸@„ðt9D‹D$HH‹Œ$ÐH‰|$0Aº÷LL$`D‰l$(A‹×‰l$ ÿ
(H‰D$XHƒøÿu;HcL-0yH‹ÁƒáHÁøHkÉXI‹DÅ€dþÿj&‹Èè‡uÿÿèBuÿÿ‹8éÌH‹Èÿþ%;ÇuMHcL-èxH‹ÁƒáHÁøHkÉXI‹DÅ€dþÿ"&‹È‹Øè=uÿÿH‹L$XÿV';ßu§èétÿÿÇ
ëšA;ÄuA€Î@ë	ƒøuA€ÎH‹T$X‹è%ØÿÿHcL-{xH‹ÁƒáºHÁøD
òI‹DÅHkÉXDˆtHcH‹ÁƒáHÁøHkÉXI‹DÅ€d8€AŠÆ$HˆD$L…†E„ö‰ÂA„ôtx‹E‹ÄƒÊÿè¦	‰D$Dƒøÿuèdtÿÿ8ƒtP‹èõÒÿÿééþÿÿ‹HT$@A¸@ˆ|$@èÕòÿÿ;Çu€|$@uHcT$D‹è¾ƒøÿtÁ‹E3À3ÒèE	ƒøÿt°ºE„ö‰<¹@…ñu‹D$T#Áuºîëð‹Æ#Á=@tJ=t,=@t%=t+=@t$=t=@u(ˆ”$Ø빋Æ#Á;ÁuDˆ¤$Øë@ˆ¼$Ø÷Æ„º‰|$DAöÆ@…¬A‹Ç%À=@„$=€t|=À…‡;ï†A;ìvƒýv8ƒý…l¾Œ$ØA¸‹ïA+È„ A;È…PÇD$Dÿþé‹E‹Ä3ÒèÉÿÿH;ÇtÀ‹E3À3ÒènÉÿÿHƒøÿ„|þÿÿ‹HT$DA¸èbñÿÿƒøÿ„aþÿÿA;Ät ƒøuk|$DuD@þDˆ„$ØéÜ·D$D=þÿu‹è%Ñÿÿè`rÿÿ»‰‹ûéã=ÿþu#‹E3ÀA‹Ôè’ƒøÿ„ùýÿÿDˆ¤$Ø醋E3À3Òèpƒøÿë;;ïvqA;ì†üþÿÿƒý‡êþÿÿ‹E‹Ä3Òè¡ÈÿÿH;Ç„Þþÿÿ‹E3À3ÒèŒÈÿÿHƒøÿu8é™ýÿÿÇD$DA¼‹HcÅE‹ÄHTDD+ÅèN°ÿÿƒøÿ„mýÿÿèD;åÛA¸Hc@Š¬$ØH‹Áƒá@€åHÁøHkÉXI‹DÅ€d8€@l8HcH‹ÂƒâHÁøHkÒXI‹LÅ‹Æ€d8ÁèÀàD8@8|$Lu!@öÆtHcH‹ÁƒáHÁøHkÉXI‹DÅ€L A‹Ç%À=À…ŸA„ð„–H‹L$Xÿ^#‹D$PD‹D$HH‹Œ$ÐH‰|$0‰D$(Aº÷LL$`ÇD$ A‹×ÿQ#Hƒøÿu6ÿÕ!‹ÈèòpÿÿLcI‹ÃAƒãHÁøMkÛXI‹DÅB€dþ‹è¢ÔÿÿéBûÿÿHcH‹ÊƒâHÁùHkÒXI‹LÍH‰
‹ÇH‹œ$ÈHÄ€A_A^A]A\_^]ÃÌÌH‹Ä‰PL‰@L‰H VWHƒìXƒHØÿƒ`ÜE3ÀH…ÉA•ÀE…Àu(è pÿÿÇHƒd$ E3ÉE3À3Ò3Éè5oÿÿƒÈÿé“H„$€HƒÀD‹@øƒd$0D‰D$(ÇD$ @D‹ÊL‹ÁHT$@HL$Dèv÷ÿÿ‹ð‰D$Hƒ|$Dt9…Àt(Hc|$@H‹ÏH‹ÇHÁøLcsƒáHkÉXI‹À€dþë‹|$@‹ÏènÕÿÿë‹|$@…ötèsoÿÿ‰0ƒÈÿë‹ÇHƒÄX_^ÃÌÌÌ@SHƒì0M‹ÐH‹ÂH‹ÙH…Éu&èGoÿÿHƒd$ E3ÉE3À3Ò3ÉÇè\nÿÿHƒÈÿëUH…ÀtÕH‰L$ LL$XLD$@I‹ÒH‹ÈèσøÿtÖL‹L$XL‹D$@H‹Ó¹èçH‹L$@H‹ØèfqÿÿH‹L$Xè\qÿÿH‹ÃHƒÄ0[ÃÌÌÌH‰\$L‰D$UVWATAUAVAWHƒì0E3öM‹àL‹êH‹éH‹ñI;Îu(è–nÿÿE3ÉE3À3Ò3ÉL‰t$ Çè¬mÿÿHƒÈÿéD81tÓI;ÖtÎH‹I;ÆtÆD80tÁº\èvº/H‹ÍH‹øèfA¿I;Æ…œI;þ… AW9H‹ÍèRìÿÿH‹øI;Æ…ˆH‹Íè.ŸÿÿI‹×HXH‹ËèïnÿÿH‹ðI;Æ„sÿÿÿLl4H‹ÓH‹ÈèuÂÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èÌkÿÿL‹ÅH‹ÓH‹ÎèêÀÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ è¥kÿÿH~ë
I;þtH;ÇvH‹øHƒËÿH‹ÏS/èŸ
H‹ÎI;Æt&3ÒèA;Æ…÷M‹ÄI‹ÕH‹ÎèõýÿÿH‹ØéáèlžÿÿI‹×L`I‹Ìè-nÿÿH‹øI;Æ„ÎL‹ÆI‹ÔH‹Èè·ÁÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èkÿÿH‹Îè"žÿÿL4èõlÿÿM+æD‹8I?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=runtime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: ÀÀ–ÀÀŽÀÀÀ‘À’À“À€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwpp         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLLSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecCONOUT$.com.exe.bat.cmd.\SystemRoottd
T	42àÐÀ
4
Œp¸P

4
p!ðÎ$!΢!ÔHÄI΢!ÔHÄIdJ΢!TRðÎ$ Kðàp0¸0bÀp`0à+ŒY@â
4RðàÐÀ
p`Pr0²042p

4
2p
d4rðàÐÀpà+ó'ü(Xâ2P	d4pà+**¯+ï*‘+zâ‘+  d T 4 rðàÐÀpt42À		20dT42pdT42p)4dZðàÐ
Àp`P¸È	 
 Ä t d 4 ðàÐà+´:À:\=		¼0
t	dT42À
d
T	42ÐÀp

20d	4RÀà+ŸBC–â
Ätd
RðàÐà+[D¡D¯â"D¾Dßâtd42Àtd42Ðà+£FãFøâd
T	4Rpd4
rp$d´4³°p¸p

4
2pà+NkNã4rÐ
Àp`P¸8
Ät
d	4RÐà+R;Sã20à+W!W-ã

4
2pà+ÞWéWFãþW%Xfã42pà+‚Y°YFãÅYüYfãdT²pd	T42pÔt
4Rà
t
d	42àÐÀà+`Ï`ãB	Bà+Gbzb ãzb	Bà+™bbb
d4rðàÐ
Àpà+@fÓfÁã	bà+TgcgÝãcgtd
T	42àÐÀd4
Rp
t
dT4
rÀB

4
2p›4²p
`Pd	4Rp

4
RpRP4	Rpà+×vávÿã/4qfðàÐ
Àp`P¸ 
d4
RðàÐÀpà+=.ä4R
Àp
`à+€c€ä

4
’p
dT4’ÐÀp-
Etd4C²
ðàÐÀP¸Xd4Òp1
5#td43rðà
ÐÀP¸8d4²p2
0
d4
RðàÐÀpà+¶—é—.ä
T4ràÐÀp`µtdT4’àÐÀd
4RÐÀpà+㟠ä20¸PT42p
Ä	td42Ðà+K¥k¥Eä
Ät
4rðàÐà+m¦“¦^ä¦Å§~äb¸('EC
ðà	ÐÀp`0P¸pb‚t
d	4RÀà+Ñ­¹®—ä

T
ÒpdT4²pT4rp$
53Â
ðà	ÐÀp`0P¸X
4RðàÐÀp`
Pd
4’p	¢ðàÐÀ
p`P
0
d4
RðàÐÀpà+ìÆÇ.ä!
!4!òðàÐÀp`PrP¢p`à+ÏÏüÏ°äR0td
T	42ðÐÀd42p4	ðàÐÀ
pP0#

ðà	ÐÀp`P0¸xdT
4’p0fðÀÜò2H`xŒ”¦´ÆØæø.BVr¤¸Òæö$0BRbp~ˆ˜®ºÆÖþ0J`zž¸ÈÞø(<Lbr„–¨ºÆÔäú
(:Lt€¢SGenerateConsoleCtrlEventÇGetExitCodeProcessrWaitForSingleObject–CreateProcessA´SetConsoleCtrlHandlerõGetModuleFileNameAÛEnterCriticalSectionîLeaveCriticalSectionúGetModuleHandleW/Sleep"GetProcAddressExitProcessqGetCommandLineA<GetStartupInfoAžRtlUnwindExôSetHandleCount>GetStdHandleÙGetFileTypeÀDeleteCriticalSection;TerminateProcess«GetCurrentProcessLUnhandledExceptionFilter#SetUnhandledExceptionFilterÐIsDebuggerPresentŸRtlVirtualUnwind˜RtlLookupFunctionEntry‘RtlCaptureContextçGetLastError¦HeapFree¢HeapAlloc]GetCPInfoTGetACPGetOEMCPÚIsValidCodePage×EncodePointer¹DecodePointer@FlsGetValueAFlsSetValue?FlsFreeøSetLastError¯GetCurrentThreadId>FlsAlloc›WriteFileðLoadLibraryAºInitializeCriticalSectionAndSpinCountLFreeEnvironmentStringsAÁGetEnvironmentStringsMFreeEnvironmentStringsWˆWideCharToMultiByteÃGetEnvironmentStringsWªHeapSetInformation¤HeapCreateSQueryPerformanceCounterjGetTickCount¬GetCurrentProcessIdSGetSystemTimeAsFileTime©HeapReAlloc…GetConsoleCP—GetConsoleModeCFlushFileBuffersàLCMapStringAMultiByteToWideCharâLCMapStringW@GetStringTypeACGetStringTypeWéGetLocaleInfoAìSetFilePointer«HeapSizeDCloseHandleWriteConsoleA›GetConsoleOutputCPšWriteConsoleW
SetStdHandlezCreateFileASCompareStringAVCompareStringWÝSetEnvironmentVariableAKERNEL32.dllhReadFileÚSetEndOfFile&GetProcessHeapËGetFileAttributesAàE@àE@2¢ß-™+Í] ÒfÔÿÿ\)@ô@ðó@ÿÿÿÿÿÿÿÿ€

		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ(@¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þôþ@þÿÿÿC@-@@-@@-@@-@@-@P2@ðü@€@@Ð0@P-@P-@(@ÿÿÿÿXú@(ú@	øù@
`ù@(ù@øø@Ðø@ ø@hø@@ø@ø@Ð÷@¨÷@ˆ÷@ ÷@ èö@!ðõ@"Põ@x@õ@y0õ@z õ@üõ@ÿõ@›@›@›@›@›@›@›@›@›@›@ 
ðü@òþ@P@L@H@D@@@<@8@0@(@ @@@ô@è@ä@à@Ü@Ø@Ô@Ð@Ì@È@Ä@À@¼@¸@°@ @”@Œ@Ô@„@|@t@h@`@P@@@8@4@(@@@	Ð0@.@2@lB@lB@lB@lB@lB@lB@lB@lB@lB@P2@.€pðñÿÿPSTPDTà2@ 3@ÿÿÿÿÿÿÿÿþÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Ml8@0@(@ @çxðY”`«x°Ôdà¬íôðÎ$΢¢_ô_¯Ü¯·Ì·Õ¼øm<xZh\ƒd„ãhähjdl“d”ÕhT·h¸ÕdØÿ< ¥"d¨"6#àp#$h$š$|œ$5%„&5&h8&q&ht&Š&h¤&×&ŒØ&'˜'Ã'˜Ä'N)¤ˆ)ï)hð)É+ÜÌ+Þ+dà+-„-U.4X..D.×.hØ.)/L,/ª/`¬/‘:t”:=˜„=º=<Ä=é>Ðì>q?¼	¼?Ü?dÜ?ü?dü?B@hD@°@`°@3AÜ4A¹AܼADBôDBB	„B4C	4C­C °C÷ChøCìD<	øD‚E|	„EF` FG	GLG˜LGûG€üGRI¼	TIÏIÐ	üIJ<JZKà	\KîK`ðKÓMè	ÔMN
N O| O—Q(
˜QSD
S¸Sd¸S2U tVËVhÌVAWt
`W…WdˆW:X”
â€@âXâŒXâzâÔzâ–âÔ–â¯âÔ¯âÕâÔßâøâÔøâãÔã-ãÔ-ãFãÔFã_ãÔfããÔã“ãÔ ãÁãÔÁãÝãŒÝãÿãÔÿãäŒä.äŒ.äEäŒEä^äÔ^äwäÔ~ä—äÔ—ä°äŒ°äüäP././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/gui-arm64.exe0000644000175100001710000041500000000000000020033 0ustar00runnerdockerMZÿÿ¸@øº´	Í!¸LÍ!This program cannot be run in DOS mode.

$ضVœ×8Kœ×8Kœ×8Kˆ¼;Jž×8Kˆ¼=J	×8Kˆ¼Ôêª N N N N_€ñ¬Tfžˆ	ib8		‹Ö*
$!)&&&&&&&&&&&&&&&&@qŸ@!¿
@!
À_Ö@qŸ@!¿
@ 
À_Ö@qŸ@!¿
A9À_Ö@qŸ@! 
À_Ö@qŸ@!
À_Ö@qŸ@ 
À_Ö@qŸA9À_Ö@qÀ_ÖH@Ñ
‹qL@qLÀ_ÖÀ€R_ëêTIüE“)ñ@¡ŸLÌÿÿTB@’‚øÿµÀ_ÖH
@ò TAÑèËBË@qˆLIüF“ Õ Õ Õ Õ Õ)ñ@!ŸLÌÿÿTB@’Bûÿ´_€ñ+õÿT@¡ŸLB€ñÁôÿTÀ_ÖÿƒÑ¤€Òc2£òã©á©ÿƒ‘À_ÖÀ_ÖóSº©õ[©÷c©ùk©ûs©ý{©ýC‘sP@©uXA©w`B©yhC©{pD©a(@ù@?Öý{E©ûsD©ùkC©÷cB©õ[A©óSƨÀ_ÖóSº©õ[©÷c©ùk©ûs©ý{©ýC‘sP@©uXA©w`B©yhC©{pD©a(@ù@?Öý{E©ûsD©ùkC©÷cB©õ[A©óSƨÀ_ÖËëÃ
Tô!€ù_ ñãª"Tb6  ÿ
` ¿
b6 ÿ
`¿
b6"@9b9À_ÖB€ñTB€ñcT! €ùBñÃT?@òaT@ò`T  ßL$ ßL!@€ù!`€ù` ŸLd ŸLBñ"ÿÿTb06 @­"A­$B­&C­!‘!@€ù!`€ù`­b­d­f­c‘BñbþÿTb06  ßL` ŸLb(6  ßL` ŸLb 6 pßL`pŸLb6 pß`pŸb6  ÿ
` ¿
b6 ÿ
`¿
b6"@9b9À_Ö!‹!ðŸø_ ñ‹‚T¢6!ÑcÑ  `
`  
¢6!ÑcÑ `
` 
b6"ü_8bü8À_ÖB€ñãTB€ñT!ð›øBñT?@òaT@òÀT!Ñ  @L!Ñ$ @L!ð—ø!ð“øcÑ` LcÑd LBñ¢þÿT!Ñ&C­$B­cÑ"A­ @­!ð—ø!ð“øf­d­b­`­BñbþÿT¢06!ÑcÑ  @L` L¢(6!€Ñc€Ñ  @L` L¢ 6!@Ñc@Ñ p@L`pL¢6! Ñc Ñ p@`p¢6!ÑcÑ  `
`  
¢6!ÑcÑ `
` 
b6"ü_8bü8À_ÖÿÃÑý{©óS©õ[©÷c©ùk©ûs©!@ùáùóªôªõªöªâªÿÿ—àªáªâªãªSP@©UXA©W`B©YhC©[pD©](@ù?Öóªÿÿ—àªá@ùB€Òõþÿ—àªûsF©ùkE©÷cD©õ[C©óSB©ý{A©ÿÑÀ_Ö@xb4åª@7¡@ò`T¢,@’_À?ñÌT t@L¨qn"&"4¥@‘¥ì|’ Õ tßL¨qn"&¢ÿÿ5¥@ÑÁœ˜`N!N¨pn&BR Ë@€‹À_Ö!@ÑáË¢$@xÂ4!ñ¬ÿÿTìÿÿ¢$@xâÿÿ5¥Ñ ËüA“À_Öåª`7? ñ#T£@òÀT¢,@’_À?ñŒTc@ÑãË t@L¨qn"&ûÿ4!ƒË¥‹? ñCT#üC“ tßL¨qn"&Âùÿ4cñaÿÿT!@òÀT! Ñá˥ˠtßL¨qn"&bøÿ4¡´¢$@xBúÿ4!ñ¨ÿÿT ËüA“À_Öc@ÑãƒË¢$@x"ùÿ4!ñùÿTcñlÿÿTÝÿÿ€ÒÀ_Ö@8‚4媡@ò@T¢,@ò_À?ñT p@L¨1n"&4¥@‘¥ì|’ pßL¨1n"&¢ÿÿ5¥@Ñaœ˜ N!N¨0n&BR¥‹ ËÀ_֥ѠËÀ_Ö!@ÑáË¢@8Bÿÿ4!ñ¬ÿÿTéÿÿ

	åª?@ñ#T£@òÀT¢,@ò_À?ñlTc@ÑãË p@L¨1n"&‚ûÿ4!Ë¥‹?@ñCT#üD“ pßL¨1n"&Búÿ4cñaÿÿT!@òÀT!@Ñá˥ˠpßL¨1n"&âøÿ4¡´¢@8¢ùÿ4!ñ¨ÿÿT ËÀ_Öc@ÑãË¢@8¢øÿ4!ñ€øÿTcñlÿÿTÞÿÿ€ÒÀ_ÖQ
@ùðs/ëð3šëCTÀ_ÖÎt’1@Ñ?@ù?ë¡ÿÿTÀ_Ö_@ñlTChhb8cË`Ö(Á¨($Á¨ëTJ
ÀÚ)
ÀÚ@	ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸ëàTcÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸ëàTcÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xëàTcÀÚÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸ëàTcÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xcÀÚÀÚ`ëàŸ$€ZÀ_Ö€ÒÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_ÖD@¸(D@¸cÀÚ	ÀÚ`ëàŸ$€ZÀ_Ö„@ø(„@øcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xcÀÚÀÚ`ëàŸ$€ZÀ_Ö„@ø(„@øëàTcÀÚ
ÀÚ`ëàŸ$€ZÀ_Ö$@x($@xëàTcÀÚÀÚ`ëàŸ$€ZÀ_Ö@8(@8`ëàŸ$€ZÀ_Ö_€ñ+TB€Ñ(Á¨($Á¨ë!T_	ë!T(Á¨($Á¨ëaT_	ëaTB€ñjþÿTB€‘_@ñmåÿTB Ñ„@ø(„@øëáTB ñlÿÿT ôÿTB ‘chhb8cË`ÖJ
ÀÚ)
ÀÚ@	ëàŸ$€ZÀ_ÖcÀÚ
ÀÚ`ëàŸ$€ZÀ_ֈδ|Øš¾tl\J†â¤ÈìÿCÑó{©Ü”@ùÖ”"€R@¹áª¸”ó{@©ÿC‘À_Ö°(‘À_Öþø5J¹ 4¨ð@ù€R?Ö €RþAøÀ_ÖóS»©õ{©â©ä©æ©ôªóªõƒ‘èÿÿ—@ù€ÒâªáªäªD”õ{A©óSŨÀ_ÖóS¼©õ[©÷c©ù{©óªhÀ9éªøªh4(À8èÿÿ5 Ë€ÒG”¹öªùª3ù`À9€R€R”€4`À8”Àÿÿ5uÀ8•4à*
”@44¿rqaT”÷ÿÿ¿ŠqTˆraTÿq÷ŸqµŸ”~ô4â*€RàªOüÿ—ÖB4‹€RÕüÿ4Õ8äÿÿô4â*€RàªEüÿ—ÖB4‹€Rß8	@¹()}@“¹*‘6{*ø54`À9㔀4`À8à”Àÿÿ5hÀ9¨ùÿ5àªù{C©÷cB©õ[A©óSĨÀ_ÖóS¼©õ[©÷c©ù{©õª¨À9éªh4(À8èÿÿ56ËÈzS	}@“ 
‘!€Òñ”Y€R÷ªù9ó‘€RßqíT˜€R¨À9qqaT”‰qaTŸqíTâ*€Ràªüÿ—sB4‹€Rx8€R¨À8ÖQh8výÿ5ŸqÍTâ*€Ràªùûÿ—sB4‹y9àª9ù{C©÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û{©¹ûÿ—ÿƒѨÐ
@ù÷*úªû* €Rác‘€Ò?ÖècÂ9éc‘h4(À8èÿÿ5èc‘?ë)Têc‘(À9¹q T?9)Ñ?
ëHÿÿT¨Ð

‘?9ècÂ9éc‘h4(À8èÿÿ5¨€R(9+
ËHÀ8Hi+8Èÿÿ5€Ràc‘4”ô*Ÿ1!T@€R5”¨ÐÁ
‘âc‘#ÿÿ—@€R €Òác
Ԉ*ӏc
‘Á ‹à*µ ”èc
‘	Ñ)‘?ëÂT(À9qJzMz!ÿÿT¨Ð‘?9B€Òàc
‘ï”@4¨Ð
!‘H@ùëc
‘I	@¹hùH1À9i	¹h19áS‘àk
‘ÿÿ—õª³@ùiÀ9èª	4Š€R‘?½qAT
ñ8	À9iÿÿ5äc‘ãc‘âc‘áC‘àªx”èCÀ9¨5ècÆ9qq@Täc‘ãc‘âc‘áC‘àc‘m”ècÆ9êc‘h4HÀ8èÿÿ5IÑ(À9qq¡THáß8I	ÑqqTêc‘?
ë£T?9(ýß8qqaÿÿT€Òãªâc‘áC‘àc‘-”óc‘!€Ò€ €Ò'”‚ €Òáªöªã”Vµ@€R³@ùÇ”¨Ða‘⪵þÿ—@€R§ó@¹€Òø@“‘”ùªàªÿÿ—4#‘ ùq
Tµ"‘sQ †@øÿÿ—sQ€†ø“ÿÿ5àc‘ÿÿ—ÿq€†ø
TU#‘óQ †@øüþÿ—sQ€†ø“ÿÿ5Ÿù›4áªàªn”@€Rš”¨Ð‘⪈þÿ—@€RzÈÀ9éªh4(À8èÿÿ5(Ë
	qÍT,#‘QŠ…@øHÀ9é
ªh4(À8èÿÿ5(
Ë	
-kQËþÿ5!€Ò }@“Ó”¨Ða
‘âª÷ªd”ÈÀ9éªh4(À8èÿÿ53ËqmT4#‘Q¶Ð‚†@øàÂ3‹Ár
‘U”Š‚_øHÀ9é
ªh4(À8èÿÿ5(
Ë	3µQUþÿ5éÓ‘ÿ¹?}©èc‘?}©!€R?}©?}©}©?}©	ù
€R?}©?a¹éÿÿð !9‘è3¹¨Ð@ù?Öèc‘èù¨Ð	@ùéÑ€Ò€Òéù€R$€R€Ò€Ò᪀Ò?Ö5@€R6”¨ÐA‘%þÿ—€Rè+@¹éð(
¹¨Ð@ùà@ù€?Ö¨Ð@ùà@ùáC‘?Ö5@€R!”¨ÐÁ‘þÿ—€Rà@¹ÿƒ‘uúÿ—û{D©ùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ{©â©ä©æ©ôªóªõƒ‘ìýÿ—@ùåªãª€’áª@²€Òd”€q±€õ{A©óSŨÀ_Öý{¿©ý‘h@ù	@¹+u(Èkøj}@“IË*‹@!Ñ`úÿ— €Rý{Á¨À_Öóøý{¿©ý‘@€RÔ”¯”|”©”ó*/”¹ €RÒ”S¨41”°¡‘Z”Ÿ”¨”À5 ”¹”€47‘ç” ”Ÿ”’”Ý”’”SH4”Œ”Ñ” 5€Rý{Á¨óAøÀ_Öà€R²”ý{¿©ý‘’”€Rý{Á¨À_Öý{¿©ý‘â”y”ì”ý{Á¨À_ÖóS¾©õùý{¾©ý‘ €R…”S(4€R¿C9d”Sõð¨
J¹q`
Th5(€R¨

¹©Ð!!‘¨Ða
‘”`4à€RB¨ÐA
‘©Ð 
‘ï”H€R¨

¹4€R´C9à*Ø”s”óªh@ù¨´Ÿ”SH4s@ù直Ð=Aù?Ö€ÒA€R€Ò`?Ög”óªh@ùÈ´”Sh4`@ùå”d”<S¨”ã*⪀ÒèÿÿБ>ýÿ—ó*r”S4T5Δ€R €R»”à*	ó*g”Sè4¨C@9H5¾”à*ý{¨õ@ùóS¨À_Öà€RA”à€R?”à*Í”à*¹”ý{¿©ý‘Δ•ÿÿ—ý{Á¨À_Öý{¿©ý‘Ú”`4èªìðŠA(‘@ùHý_ÈhµKý	È©ÿÿ5ë`TŠA(‘Hý_ÈhµKý	È©ÿÿ5¿;Õÿÿµ€Rý{Á¨À_Ö €Rýÿÿý{¿©ý‘êðH1h9q)€R)ˆI1(9â”g”Sh5€Rä”Sˆ5€Rn”ùÿÿ €Rý{Á¨À_ÖóS¿©ý{¿©ý‘ôðˆ"i9ó*h5q¨TŸ”€4s5èða(‘J” 5èðÁ(‘F”€4€R
èða(‘éð)Á(‘
€’
)©*)©
	ù*	ù(€Rˆ")9 €Rý{Á¨óSÁ¨À_Ö €RÚ”ý{¾©ý‘ªI‹RèÿÿÐ	‘(@y
kT,=@¹*Á,‹ªˆRH@¹kATH1@y-qáT	Ë)Á,‹()@y	‹
a‘)
@y€Ò,)›ªù_ë@TI
@¹A)ë£TH	@¹		A)ëƒTJ¡‘õÿÿ
€Òjµ€R
H%@¹hø6€R €R€R€Rý{¨À_Öóøý{¿©ý‘SH”À4³5èðA(‘ýŸÈ¿;Õý{Á¨óAøÀ_Öóøý{¿©ý‘èð1h9S)SH4©5à*p”à*ò” €Rý{Á¨óAøÀ_Öóøý{¿©ý‘éð(
Eùóª±aTÀ”᪠a(‘Þ”q`Ÿšý{Á¨óAøÀ_Öý{¿©ý‘ìÿÿ—ñàŸZý{Á¨À_ÖóS¿©ý{½©ý‘ôðˆ@ùsXëAT¨Ð!‘ÿù	ýßÈàc‘ ?Öè@ù©Ð)‘èù(ýßÈ?Öè@ù	|@Ó)ʨÐá‘éù	ýßÈ ?Öè@ù	|@Óàƒ‘)ʨÐÁ‘éù	ýßÈ ?Öé#@¹ëC‘è@ù
	Êé@ùH	ÊÊ	½@’?ëˆX‰šˆùé(ªèð	ùý{èóSÁ¨À_Ö Õ2¢ß-™+3¢ß-™+€RÀ_Ö €RÀ_ÖˆRÀ_ÖèðA)‘©Ð(A‘	ýßÈ ÖÀ_Öèð)‘À_Öý{¿©ý‘
üÿ—‰€Ò@ù	ªùõÿÿ—@ù	²	ùý{Á¨À_Öèð@¹qàŸÀ_Öá(‘À_ÖÁ(‘À_Ö`>ÔÀ_Öý{¸©ý‘èC‘}©àC‘}©}©}©}©}©1ù¨Ð‘	ýßÈ ?ÖèO@¹é£@yrH€R ˆý{ȨÀ_Öºÿÿý{¿©ý‘¨Ð¡‘	ýßÈ€Ò ?Ö ´@y©I‹R	k!T<@¹ªˆR
À(‹I@¹?kaTH1@y-qTH…@¹9q©THù@¹h4 €R€Rý{Á¨À_Öá=‘©Ð(a‘	ýßÈ ÖóS¿©ý{¿©ý‘ôª“@ù)h@¹	kTh@¹q!Ti"@¹H(K	q	Tè?k T€Rý{Á¨óSÁ¨À_ÖJ”ù“@ùM”ù™”csmà “@™óS¾©õ[©ý{¿©ý‘è‘é5!‘!‘!‘ëBT¶°t†@ø´´È>Aùïª?Ö€?Öë#ÿÿTý{Á¨õ[A©óS¨À_ÖóS¾©õ[©ý{¿©ý‘èA‘é5a‘!‘!‘ëBT¶°t†@ø´´È>Aùïª?Ö€?Öë#ÿÿTý{Á¨õ[A©óS¨À_ÖÿCÑàù@€R`>ÔÿC‘À_Öý{¿©ý‘€R”ý{Á¨À_ÖÿCÑà¹à@¹`>ÔÿC‘À_Öèð)J¹qàŸÀ_ÖóS»©õ[©÷c©ùk©û#ùý{½©ý‘÷ªèf@©ëªõ@ùøªëù
˨@¹hø6	y@’5‹é2A9HÑôJ@¹?qZˆš@¹É€R	jÁTø‹©¨@¹ŸkBT¨°á‘³°¶R4‹È@¹_C(ëƒTÈ
@¹_C(ë"TÈ@¹è4È@¹q Tã*@ù"C(‹áªàc‘øÿ—`ø7qmT@¹)	kÁThöAùˆ´`¢‘ÏP” 4söAù¨°=Aùïª?Ö!€Ràª`?ÖÈ@¹"€Ró@ù C(‹áªü÷ÿ—È@¹âª@¹àªå"@ùä@ù!C(‹hÿßÈ?Öù÷ÿ—³°ë@ù¨@¹”Ÿk‚TÅÿÿ€RBè@ù¬@¹ËŸk‚Tê*®R4‹é
*È@¹_C(ë#TÈ	@¹_C(ëÂT@¹r`T€Rª4¯R4‹§R4‹­R+‹¨@¹B(ëƒT¨	@¹B(ë"Té@¹¨@¹	k¡Té@¹¨
@¹	k€Tk
kãýÿTé*káTë@ùÈ@¹¨4B(ëÄ@z!Tˆã*@ùèJ¹É
@¹áª €R"C)‹Í÷ÿ—¬@¹é*”ë@ùŸ	kê	*ãøÿT €Rý{èû#@ùùkC©÷cB©õ[A©óSŨÀ_Öcsmàý{¿©ý‘Ú”Sh5€R¥”Sh5è”úÿÿ €Rý{Á¨À_Öý{¿©ý‘Sh5¶”Ý” €Rý{Á¨À_ÖóS¿©ý{½©ý‘¡C9€´é@¹	kT@¹q¡T @¹		K	qT@ùÈ´	@¹é4@ùÁ)‹@ù”@¹ˆ 6	@ù4@ù4´ˆ@ù	@ù直°=Aù?Öàª`?Öý{èóSÁ¨À_Ö Õcsmà “ Öý{¿©ý‘”€‘ý{Á¨À_Öý{¿©ý‘” ‘ý{Á¨À_ÖÀ´èÐÁ:‘ë@TQÀ_Öý{¿©ý‘”`´ý{Á¨À_Ön”óS¾©õ[©ý{¿©ý‘öÐÈ@¹1aT€Ò8¨°‘	ýßÈ ?Ö¨°a‘ô*À@¹	ýßÈ ?Öõª¿± T•µ¨°‘À@¹	ýßÈ€’ ?Ö`5€Ò€Ò €Ò…”¨°‘óªÀ@¹	ýßȳ´áª ?ÖÀ4(€hz¹õª€Ò¨°‘À@¹	ýßÈ€Ò ?Ö€Òàª”¨°!‘	ýßÈà* ?Öàªý{Á¨õ[A©óS¨À_Öóøý{¿©ý‘Á‘©°(A‘	ýßÈ ?Öèй1ÀTèÐÁ:‘¨°‘	ýßÈ᪠?Ö 4(€hz¹ €R”€Rý{Á¨óAøÀ_Öóøý{¿©ý‘óÐ`@¹1àT¨°¡‘	ýßÈ ?Ö€h¹ €Rý{Á¨óAøÀ_Öý{¿©ý‘èÐÁ<‘©°(‘	ýßÈ€RôR ?Öà4êÐHYO¹ €R	IY¹”€Rý{Á¨À_ÖóS½©õ[©÷ùý{¿©ý‘öÐÓZO¹Ó4èÐÁ<‘¨°!‘€ÒsQ©þßÈ`R› ?ÖÈZO¹	QÉZ¹3ÿÿ5 €Rý{Á¨÷@ùõ[A©óSèÀ_Ö¼åªäªãªâª€’óS½©õ[©÷ùý{¿©ý‘õª¿ñ$@ú÷ªöªèTG”È€R¹”À€RT¨‹?±ŸšóªB´IÀ9	4t´ˆË	ñ
T¿95”H€R¹ð”@€RBH€R©9¨9³
‘´hÀ9È4᪟ñ`TúâýÿT(À9h8)À8Iÿÿ5àª)”À9½q TqqàTŸñ`Tú"üÿTˆ€Rh9s‘w´èÀ9(4êËŸñ`TúâúÿTHió8h8Iió8Iÿÿ5¶´ÈÀ9h4¹qTŸñ`TúbùÿTÈ€Rh9ÈÀ9s‘(4ÊËŸñ`TúBøÿTHió8h8Iió8Iÿÿ5Ÿñ`Túb÷ÿT9€Rý{Á¨÷@ùõ[A©óSèÀ_ÖóS½©õ[©÷c©ý{¿©ý‘õªôªó*U´4´‹2@©ñ韟ñèŸ?kATˆ&A©ñêŸ?ñèŸ_kaTˆ&B©ñêŸ?ñèŸ_kTˆ&C©ñêŸ?ñèŸ_k¡
T)€ÒöªÈÀ9ˆ4)ÑÖ‘‰ÿÿµÈÀ9éqaT´Ÿ
ñ"Tá*àªk”²”H€R¹@€R`C€Ò⪀’àªá”Õ‘k´L´9¨À9öª€Ò€Òh4à*3”€4ÈÀ8È4ÈÀ9½qàTqq T¹qT÷ªØ‘ÈÀ8èýÿ5˜´€
@ù´ˆ@ùËë)úÿT⪀’»”õª‰
@ù‰´ˆ@ùH´?9ÿñ€@ùàUúcT´ˆ@ùãËëÉ÷ÿT⪀’¨”€@ùÀ´ˆ@ùÃËë©öÿT⪀’Ÿ”´ˆ@ùÃËë‰õÿT⪀’–”‰@ù‰´ˆ@ùH´?9€R	á*àª”S”È€R¹”À€Rý{Á¨÷cB©õ[A©óSèÀ_Ö	@ù‰´@ùH´?9	@ù‰´@ùH´?9	@ù‰´@ùH´?9	@ù‰´@ùH´?9À_Öý{º©ý‘?ñáùác‘âùh€ÒãùŸšä'ùèù_ñâSÿC9 €ÒÿG9ŸšèùñãS €ÒŸšè#ùŸñ €ÒŸšè+ù/ÿÿ—ý{ƨÀ_Öý{¿©ý‘¨°a‘	ýßÈ ?ÖèÐùù¨°‘	ýßÈ ?ÖèÐýù €Rý{Á¨À_ÖèÐa?‘À_ÖèÐ?‘À_ÖóS¼©õ[©÷c©ùk©ý{¿©ý‘óðh@¹h5@€R
qi€R(±ˆ€Òh¹}@“K”øðù€Ò”@ù¨µh€R€Òh¹`€Ò@”ù€Òw”@ùhµ€èБéð7A
‘€Ò€Òt€R	€Ò9€€RôR`‘î”@ù©þF“ª@’Ój(øèziøI!›+@ùh	‘	ñHTy¹µ‘Ö"‘sb‘”Q´ýÿ5€Rý{Á¨ùkC©÷cB©õ[A©óSĨÀ_ÖèБ	|@Ó
€Ò !
›À_ÖóS¾©õ[©ý{¿©ý‘z”u”¨°!‘€Òt€RöðÈ@ù`jhøs”È@ùijhøªþßÈ Á‘@?Ös"‘”QÔþÿ5À@ù1”ßùý{Á¨õ[A©óS¨À_Ö¨°Á‘	ýßÈÀ‘ Ö¨°á‘	ýßÈÀ‘ ÖóS¿©ý{¾©ý‘óªôª´ù @ùíÿÿ—àª
”ó*€@ùîÿÿ—à*ý{¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘ð’ëôªÂTh”ˆ€R¹€RˆBù3øÓhµñ‰TˆBùëhT €Ràªü”õªuµ€R€Bùù“ù3€R€Òé”à*ý{Á¨õ@ùóS¨À_Ö_qÀT_qDLz T_4q T(S	Qê€R?
jàŸ €R€RÀ_Ö	0Bù‰µ	`‘@€Ò,BùýAÓ	‹Ñh$ù
Réª8@¹q Ø@z TQ8¹B5€>Ô*ÂI…á
*(ÁåqTh
	+$@ù9	$@ù)Ñ	$ùéÿÿ‰	K	P¹
$@ùH‘$ùÀ_Ö	0Bù‰µ	`‘@€Ò,BùýAÓ	‹
Ñh
$ùRé
ªO|@Ó8@¹q Ø@úÀTQ8¹Oµ€>Ô+Ïši…›áª(
ÁLŸåqTˆ	,$@ù9	$@ù)Ñ	$ùèÿÿ©	K	P¹
$@ùH‘$ùÀ_ÖóS½©õ[©÷c©ý{¿©ý‘ö*ßqõª7ôª€RMT€¨@ù	@¹¿;Õ(1Sˆ4¨@ù	@ùÉ´¡@ùà*¹%”1 Tˆ@¹	‰¹˜¹	€?1€Tsk+ýÿTý{Á¨÷cB©õ[A©óSèÀ_ÖóS½©õ[©÷ùý{¿©ý‘ô*Ÿqöª7õª€RmTâªá*ઔ¨@¹1€TskëþÿTý{Á¨÷@ùõ[A©óSèÀ_Öóøý{¿©ý‘óªb9´($@©h¦©èÐ]A¹È5è°¡‘	)@©iª©+!”a"‘`ùH@ùhù	D@ùi
ùê!”`@ùaB‘û!”i@ù(©C¹¨72*€R(©¹jb9àªý{Á¨óAøÀ_Öý{½©óS©õùý‘
óÿ—ÿCÑóªh@ù@ùં%”h@ùSà‘@ùÉÿÿ—j¦A©àƒ‘h@ù,@ùi
@ùK@ù@ù*@ùé#‘éÿ©ÿK¹ÿÃøÿCøêùÿÃyÿs¹ÿÓ9ÿ?ùÿCùèGù볩ÿ“¹ˆ”ó*àCBùß”èc@9ÿCù¨4ê@ùH©C¹	yI©¹áªà*—%”à*ÿC‘àòÿ—õ@ùóSA©ý{èÀ_Ö(@ù	}@ùÀ9*@ùLÀ94é*è	*?k€TÀ8é*hÿÿ5‘è4hÀ94í€RS	Q?
j`ThÀ8hÿÿ5iÑ*À9_ÁqT*ýß8_ÁqÀÿÿT(Ñ_k,ˆšhÀ8ˆ8Èÿÿ5À_Ö-@ùÀ9®‰@ùˆSÉÉh8?•qÀT«@ùÀ8ˆSiÙhx©ÿ7ˆSÉÉh8?áqATÀ9‘?áqˆš¨}@ùm‘	@ù*À9j9¨À8é*¬ñ8ì*‰ÿÿ5À_ÖóS¾©õ[©ý{¾©ý‘ôª“
@ùöª“µâ”óª“
ùu@¹¹B€Rˆ@ùáC‘ÿùѤ”À¹€
@ù`µÔ”€
ù@¹‰qTˆ@ùé@ù?ëƒT‰ù €R€Rh@¹h5U4u¹ý{¨õ[A©óS¨À_ÖóS¿©ý{¿©ý‘óª`6Bù ´”SH4h@ùˆ´hrD¹	ir¹?	q T¨°Á‘R¹.¹d	‘j*@¹iùêø7lÁ9ˆ	S?iqèTˆ}@“	Ñ+}ÓŠ‘mij¸
€Rh.@¹	

*}ÓKit¸k.¹!q`Tq¨T	(I«8(	‹Öàªû”Sh5ˆ”È€R¹C”€ý{Á¨óSÁ¨À_Ö€~)h~)9R95àªÍ”0Ÿ©q Taґઉÿÿ—*j@ùè
Ë	@’*
‹K!‘kùl_¸l6¹Ìø6h2@¹êKj6¹	2i2¹(€R:¹Ÿ©q`Taâ‘èÿÿj@ùè
Ë	@’*
‹K!‘kùh_¸	€h:¹qh:@¹)±ˆi:¹ëÿÿàª2”ઔShøÿ4h@ù	À9i9h@ù)óÿ5	‘iùhrD¹	ir¹?	qáñÿT`*@¹¶ÿÿ¬¸¾Á×ÙëîóS¿©ý{¿©ý‘óªh6Bùh´h@ùèµ.”È€R¹é”€xhrD¹	ir¹?	q@T¨°Á‘R¹.¹a	‘j*@¹iùŠø7lÁ9ˆ	S?iqèTˆ}@“	Ñ+}ÓŠ‘mij¸
€Rh.@¹	

*}ÓKit¸k.¹!q@ûÿTqˆûÿTé
(I«8(	‹Ö€RàªÃ”Sèùÿ4aÁ9b¢‘`¢‘s”:€~)h~)9R94àªD”/Ÿ©q TaÒ‘àªÿÿ—)j@ùè
Ë	@’*
‹K!‘kùl_¸l6¹Ìø6h2@¹êKj6¹	2i2¹(€R:¹Ÿ©q`Taâ‘èÿÿj@ùè
Ë	@’*
‹K!‘kùh_¸	€qh:¹)±ˆi:¹ìÿÿઔàªe”S¨òÿ4h@ù	À9i9h@ù‰óÿ5	‘iùhrD¹	ir¹?	qAòÿT`*@¹ý{Á¨óSÁ¨À_Ö­·½ÀÖØéìÁ9q TqT­q`TµqÀTÁqT0@¹	20@¹	2	0@¹	20@¹	20@¹	2	0¹ €RÀ_Öóøý{¿©ý‘€Róª”Sh5€Rh6Bù`Á9	@¹¿;Õ(1Sˆ4h6Bù	@ù©´a6Bùr#”1 Th*@¹	i*¹€h*¹ €Rý{Á¨óAøÀ_Öóøý{¿©ý‘óª`Á9R91ëTh@ù	@ù*@ùKÙ`xh€RÈ4h6Bù	@¹¿;Õ(1Sˆ4h6Bù	@ù©´a6BùK#”1 Th*@¹	i*¹€h*¹h@ù	À8i9hùé5G”È€R¹”€R €Rý{Á¨óAøÀ_Öóøý{¿©ý‘óªaÁ9R9?1ëTh@ù	@ù*@ùKÙaxh€Rè4b¢‘`¢‘¤”h@ù	À8i9hùé5$”È€R¹ß”€R €Rý{Á¨óAøÀ_Öý{¿©ý‘	Á9?qT@ùˆ7é€R	,¹×”S`?9qaT@ùh7	€R	,¹”È€R¹Ã”€RT<@¹(ÿÿ5?©qìT€T?%qÀT?1q@T?Qq T?¡qÁT	@ù(À9¡q¡T(‘ù)€R=I€R;¨€R<¹9	€R6	@ù*À9_ÍqÁT(À9ÉqaTJ€R_Ùq!T(À9ÑqÁTj€R(	‘
<¹ù$HaQ	S?qTiX(%Èš¨6)€R¨€Rßÿÿ?±q T?Ñq T?Ýq T?éq!TÈ€RÕÿÿˆ€RÓÿÿé€R
	@ù(À9±q¡T(‘ù‰€Ri€R	<¹ €Rý{Á¨À_Ö Õ‚ ý{¿©ý‘	Á9?qT@ùˆ7é€R	,¹E”S`?9qaT@ùh7	€R	,¹˜”È€R¹S”€RT<@¹(ÿÿ5?©qìT€T?%qÀT?1q@T?Qq T?¡qÁT	@ù(À9¡q¡T(‘ù)€R=I€R;¨€R<¹9	€R6	@ù*À9_ÍqÁT(À9ÉqaTJ€R_Ùq!T(À9ÑqÁTj€R(	‘
<¹ù$HaQ	S?qTiX(%Èš¨6)€R¨€Rßÿÿ?±q T?Ñq T?Ýq T?éq!TÈ€RÕÿÿˆ€RÓÿÿé€R
	@ù(À9±q¡T(‘ù‰€Ri€R	<¹ €Rý{Á¨À_Ö Õ‚ óS¾©õùý{¾©ý‘óªhÁ9
Q_ÝqT‰(Yª¸	(	‹Ö€RàªR”$ઔ!àª@”àªÁ”h2@¹	2i2¹A€R€Ràªw”i2@¹(Sh4(2h2¹€Röÿÿ"€R€Rôÿÿ€Rýÿÿ	€Rh€Ri")øÿÿàªô”SH
4hA9È5l2@¹èC‘y€Ò	9ˆS¨4ˆSh4¨€Rl6h€RˆSˆ4€RèC9+€ÒmÁ9ê€R¨S	aQ?
j¡TˆSh4.€R€R¨S	Qê€R*

N5ª5éC‘€Rhi)8¿aq€T¿q€RAT€RéG‘hi)8k	‘i6@¹õ*hR@¹Ÿr)K4KÁTc¢‘â*€R`¢‘ìûÿ—h6Bù	@¹¿;Õ(1S4h6Bù	@ù©µh*@¹	i*¹dB‘c¢‘â*áC‘`¢‘ü”i2@¹(
S4(	SÈ5c¢‘â*€R`¢‘Ðûÿ—€RàªA”h*@¹(ø7h2@¹		SÉ4c¢‘â*€R`¢‘Ãûÿ— €R€Rý{¨õ@ùóS¨À_Öýÿÿÿ…óÿÿÿ…ýÿÿÿýÿÿÿýÿÿÿ……………………………úÿÿÿ……………÷ÿÿÿ………………ýÿÿÿ…óÿÿÿýÿÿÿýÿÿÿýÿÿÿ…………………úÿÿÿ………óS¾©õùý{¾©ý‘óªhÁ9
Q_ÝqˆT	(Yª¸	(	‹Ö€Ràªt”$િ”!àªb”àªã”h2@¹	2i2¹A€R€Rઙ”i2@¹(Sh4(2h2¹€Röÿÿ"€R€Rôÿÿ€Rýÿÿ	€Rh€Ri")øÿÿઔSÈ4hA9H5l2@¹èC‘y€Ò	9ˆS¨4ˆSh4¨€Rl6h€RˆSˆ4€RèC9+€ÒmÁ9ê€R¨S	aQ?
j¡TˆSh4.€R€R¨S	Qê€R*

N5ª5éC‘€Rhi)8¿aq€T¿q€RAT€RéG‘hi)8k	‘i6@¹õ*hR@¹Ÿr)K4KÁTc¢‘â*€R`¢‘8ûÿ—dB‘c¢‘â*áC‘`¢‘ø”i2@¹(
S4(	SÈ5c¢‘â*€R`¢‘(ûÿ—€Rહ”h*@¹(ø7h2@¹		SÉ4c¢‘â*€R`¢‘ûÿ— €R€Rý{¨õ@ùóS¨À_Öýÿÿÿyóÿÿÿyýÿÿÿýÿÿÿýÿÿÿyyyyyyyyyyyúÿÿÿyyyyy÷ÿÿÿyyyyyyýÿÿÿyóÿÿÿýÿÿÿýÿÿÿýÿÿÿyyyyyyyúÿÿÿyyyóS¾©õùý{¿©ý‘óªj@ùè
Ë		@’*
‹K!‘kùu_øõ´´@ù´´b>@¹aÁ9`@ù2úÿ—t&ù©@yS¨4(€RhR9)}S
ªH‘h&ùI‘(À8èÿÿ5H‘)ËR9iR¹ €Rý{Á¨õ@ùóS¨À_ÖóS¿©ý{¾©ý‘ÿCÑóªh2@¹4€Rj:@¹	2i2¹Jø6hA9ê€R	Q?
jÉ€R¨€R*ˆj:¹
*5hÁ9q€T
€RqaTt:¹*€RHu}@“`b‘Ðùÿ—S(5h2Bùhµ@€Òh.BùýAÓ	uQi:¹ib‘(Bùñ(ˆšh&ùj@ùè
Ë		@’*
‹K!‘kùp_üa2Bùðýaµ@€Òh.BùýAÓ¡µ@€Òab‘cb	‘h.Bùéª#H‹"ýAÓg"@©àƒ‘ô¹eÁ9f:@¹èùo”h2@¹	SÉ4h:@¹ˆ5a@ù`&@ùûÿ—hA9ê€R	Q?
jáTh2@¹	S‰5a@ù`&@ùÐúÿ—j&@ùKÀ9µqáTh2@¹J‘j&ù	2i2¹KÀ9h%Q	S?•qˆTéX(%Èšh79qáTh2@¹k€Rk9	yi2¹KÀ9é
ªk4(À8èÿÿ5(
ËhR¹ €RÿC‘ý{¨óSÁ¨À_Ö Õ!óøý{¿©ý‘óªb>@¹aÁ9`@ù‹ùÿ—j@ùS¨4è
Ë	@’*
‹K!‘kùc_xa2Bùµ@€Òab‘h.BùýAÓd@ù`B‘ö” 4(€Rh9ib‘(Bùñ,ˆšè
Ë	@’*
‹K!‘kùhß8ˆ9(€RhR¹ib‘(Bù €Rñ(ˆšh&ùý{Á¨óAøÀ_ÖóS½©õ[©÷c©ý{¿©ý‘óªj>@¹÷*XS_-q(TI(Iª8(	‹Öt‘ˆ@¹6€Ò	Sh@ùÉ4	!‘iù)ß85}@“7	!‘iù5_83t‘j@ùˆ@¹V€Ò	Sè
Ë	4	@’*
‹K!‘kùhßx}@“%	@’*
‹K!‘kùu_xt‘j@ùˆ@¹€Ò	Sè
Ë		@’*
‹K!‘kùu_øt‘j@ùˆ@¹	Sè
Ëé4	@’*
‹K!‘kùuŸ¸	@’*
‹K!‘kùu_¸–€Ò‰@¹(S¨4•ø¶)2‰¹õËj:@¹Šø6(€Rh:¹(yA}@“ˆ¹`b‘Òøÿ—•µˆ@¹	y‰¹R9ß"ñã*â*àªTáª.ùÿ—á*ÿøÿ—ˆ@¹	Sé4hR@¹¨4h&@ù	À9?Áq Th&@ù
€R	Ñi&ù*9hR@¹	iR¹ €R”È€R¹Ú”€Rý{Á¨÷cB©õ[A©óSèÀ_Ö±‚‘±¥¥¥¥ö¥±¥óS¿©ý{¿©ý‘óªj@ùè
Ë		@’*
‹K!‘kùt_ø	”à4j>@¹_-qˆTi(Iª8(	‹Öj*€¹Šù	h*@¹ˆ¹hRÀyˆyh¢À9ˆ9(€Rh9 €Rï”È€R¹ª”€Rý{Á¨óSÁ¨À_ÖìòïìééééøéìéóS¾©õùý{¿©ý‘ôªŠ@ùè
Ë		@’*
‹K!‘‹ùˆ
G)	°s_øÁ9€@ù15ˆ“&ù‹øÿ—Sˆ4³µ©(Á‘ˆ&ù3Á‘(€R¡~@“ˆR9àªFîÿ—	³µ©(‘ˆ&ù3‘¡~@“ઠîÿ—è*ˆR¹ €Rý{Á¨õ@ùóS¨À_Öý{¿©ý‘@¹¿;Õ1S¨5–”î°qí|@“	TjýF“ÈA
‘yjøi@’	€Ò,!›¬	‘ˆåÀ9È5q	TjýF“ÈA
‘yjøi@’	€Ò+!›«	‘hõ@9è6”È€R¹K”€R €Rý{Á¨À_Ö
@ùI¡@©	ëTHa@9¨4H@¹	I¹€H¹@ùa@9H@¹	I¹
@ùH	@ù	‘I	ù
@ùH@ù9@ù €Rh@ù	‘iùÀ_Öý{½©óS©õùý‘ìÿ—ÿCÑóªhRA9(4hR@¹qÍTu&@ù€R£&@x€Òÿ¹d@ùá#‘à‘Š” 5â@¹â4h6Bù	@¹¿;Õ(1S4h6Bù	@ù©µh*@¹	i*¹dB‘c¢‘á#‘`¢‘†”hR@¹”ŸkAüÿT€h*¹h6BùbR@¹a&@ù	@¹¿;Õ(1S4h6Bù	@ù©µh*@¹	i*¹dB‘c¢‘`¢‘l” €RÿC‘Ëëÿ—õ@ùóSA©ý{èÀ_Öý{½©óS©õùý‘ºëÿ—ÿCÑóªhRA9¨4hR@¹qMTu&@ù€R£&@x€Òÿ¹d@ùá#‘à‘@” 5â@¹b4dB‘c¢‘á#‘`¢‘”hR@¹”ŸkÁýÿT
€h*¹bR@¹dB‘a&@ùc¢‘`¢‘” €RÿC‘™ëÿ—õ@ùóSA©ý{èÀ_ÖóS½©õ[©÷ùý{¿©ý‘öªô*óª”4É@ù*¡@©
ëÁT(a@94h@¹	HË @ù—~@“ë1—šâª<ìÿ—Ê@ùH@ù	‹IùÊ@ùH	@ù	‹I	ùÊ@ùHa@9ˆýÿ5¿ë€T€h¹h@¹©i¹ý{Á¨÷@ùõ[A©óSèÀ_ÖóS¼©õ[©÷c©ùk©ý{¿©ý‘ùª3@ùöª÷ªø*ôª“µ«”óª3ùøÂ8‹u@¹¹ÿë€T€È@ùàÀ8	@¹¿;Õ(1Sˆ4È@ù	@ù)´Á@ùŽ”1¡T @ù`µ“” ù@¹©qÁTÈ@ù	@¹¿;Õ(1Sˆ4È@ù	@ùÉ´Á@ùà€Rz”1 Tˆ@¹	‰¹š¹ÿë!ûÿTš¹h@¹h5U4u¹ý{Á¨ùkC©÷cB©õ[A©óSĨÀ_Öý{¸©ý‘â©á©àùáµh”È€R¹#”€Bÿÿ´èc‘á©è+ù郑裑飩èã‘éÑ飩ã‘âC‘á#‘àC‘Òöÿ—ý{ȨÀ_Öý{¼©óS©õ[©÷c©ý‘íêÿ—ÿÃÑöªõªôªóªøªóµC”È€R¹þ”€\T´5ÿÿ´áªà‘¥÷ÿ—×òÿ“¸¤
@úÿÓxèŸÿÿ9èã9é#‘胑õS©à‘èWùÿùéÿ©ÿk¹ÿÃøÿCøÿyÿ“¹ÿS9ÿOùÿSùö#ùóã©ÿ³¹éøÿ—ó*U´–6”µs4àSBù´”èc@9ÿSùÈúÿ4ê@ùH©C¹	yI©¹Ñÿÿè@ùë!T3ø7ŸÂ3ëâTðÿÿw´”´sø6¿9è@ùë¡T¨‹ñ8”üÿ´è@ùëÁTàSBù¨‹ñ8’”èc@9ÿSù¨4ê@ùH©C¹	yI©¹3€i58àSBù†”èc@9ÿSù¨4ê@ùH©C¹	yI©¹à*ÿÑŠêÿ—÷cC©õ[B©óSA©ý{ĨÀ_Ö	€Ò´_ñTNÑδ,Ñ
Ñ­‘ªñß8‘!‘Œ‘j4ˆñß8_kT«À9k4ˆÀ9kTªÀ9Š4ˆÀ9_k!T«	À9«4ˆ	À9kAT)‘?ëÃüÿT?ëbTËjiá8ª4(À9_kAT)‘?ë!‘ÿÿT€RÀ_Ö)ð_8)à_8)Ð_8hS)À_8HS	Kõÿÿ(@9IS Kñÿÿóøý{¿©ý‘󪢴)Ë(ià88h4BÑ‚ÿÿµÂ´Hш´â*€R\êÿ—àªý{Á¨óAøÀ_ÖóS¿©ý{¾©ý‘ó*è]A¹tH5ŸqTÈðIAù	Ùsx ý{¨óSÁ¨À_Ö”áC‘H@ùèùÝ”è@ùŸqèT@ù	Ùsx ý{¨óSÁ¨À_Ö	@¹q
T€Ò€Rà*Õ”ý{¨óSÁ¨À_Ö€Rý{¨óSÁ¨À_ÖóS½©õ[©÷ùý{¿©ý‘ô*öªa”óªs´j@ùK‘_ëé
ªÀT(A¸k€T?ëÿÿT€Òè´@ùµ´¿ñÁTù €Ra(AÑ÷ÿÿ¿ñaT€[w@ùvù@¹Ÿ"q	TIÁ‘+A‘?ù)A‘?ë¡ÿÿT@¹I
v@¹	kÈT@TÉ		k€T‰		kÀTI		kT			kô*!T(€R4€R%È€RÔ€R"h€Rt€RH€RT€Rˆ€R”€RÉ	k€T‰	kÀTI	kT		kô*¡T¨€R´€R	È€RÔ€R¨€R´€RH€RT€Rh¹ˆÐ=Aùïª?Öá*€R ?Öv¹ùˆÐ=Aùïª?Öà* ?Öwù¦ÿÿ€Rý{Á¨÷@ùõ[A©óSèÀ_Ö‘ÀÀŽÀÀÀ’À“À´ÀµÀè@¹À_Öè¹À_ÖÈð	@ùëh
@ù*)Ê*-Êš_ñàŸÀ_Öè
ùÀ_ÖóS¿©ý{¿©ý‘Èð	@ùëh
@ù*ôª)Ê3-Êšsµ€RˆÐ=Aùïª?Öàª`?Öý{Á¨óSÁ¨À_ÖÈð
@ù€RIi	K,Éš
Êëh
ùÀ_ÖóS¼©õ[©÷c©ùùý{¿©ý‘øªùªù(€Ò(ùôªöªóªv´ÓùÖ"‘€RˆÀ8‰q¡Tÿq÷ŸU€R@ù	‘	ù“´ˆòß8h9s‘•òß8”‘à*” 4@ù	‘	ù“´ˆÀ9h9s‘”‘54—üÿ5¿‚q`T¿&qüÿT“´ò8”Ñ€RˆÀ9(4q`T%q¡Tˆ‘ôªÀ9ùÿÿè4v´ÓùÖ"‘(@ù—€R	‘)ùˆÀ9+€R
€RˆÀ8Jqq ÿÿT‰qTJ7Õ4ˆÀ9‰qaT”‘¿qõŸ€RJ}S*4JQs´w9s‘@ù	‘	ù*ÿÿ5€À9 4•5€qIz TK4“´`9€À9s‘µ” 4@ù”‘	‘	ù“´ˆÀ9h9s‘@ù	‘	ù”‘Éÿÿs´9s‘@ù	‘	ù°ÿÿV´ßù(@ù	‘)ùý{Á¨ù@ù÷cB©õ[A©óSĨÀ_Öóøý{¿©ý‘ü’ëbT€’Bµ€>Ô	š?ë¢T)|›è ª	ë)T 
‹!€ÒN”óª€Ò…”઀Òý{Á¨óAøÀ_ÖóS¾©õ[©ý{½©ý‘õ*u4¨QqéTٔȀR¹””Ó€RS ”ô‚‘‚ €R€Ò”ˆ‚‘Éð(éùÉð3ùGùs´hÀ9H5“‚‘䃑ÿÿ©ãc‘€Ò€Òàª,ÿÿ—ö‡A©"€Ò઼ÿÿ—ôªµ·”ˆ€R¹€ÒO”“€R0‚‹äƒ‘ãc‘áªàªÿÿ—¿q!Tè@ùËðtñù€ÒQÊðHÙ¹áC‘ÿùઉ”ó*ó4à@ù5”àªÿù2”ê@ù	€ÒH@ùë
ªˆ´h@ø)‘ÈÿÿµËðiÙ¹ÿùÈð
ñù€Ò"”ÿùઔ€Rà*ý{èõ[A©óS¨À_ÖóS¿©ý{¿©ý‘ôˆ–@ùh´€R¶”Í ”óªsµ€ઔ`µ€è¡ù€–ù€R€Ò”àªþ”à*ý{Á¨óSÁ¨À_ÖóS½©õ[©÷ùý{¿©ý‘ôªˆÀ9êª	€Ò4õq)‰šh4HÀ8èÿÿ5HÀ8Hÿÿ5€Ò ‘«”óªÓ´öª‰À9‰4êªi4HÀ8èÿÿ5HË‘?õqÀT!€Òછ”õªu´âªáª~
”`5Õù€ÒÖ"‘Ë”ô‹èÿÿh@ùôª¨´àªÄ”ˆŽ@ø¨ÿÿµàªÀ”€Ò¾”€Ò€Ò»”àªý{Á¨÷@ùõ[A©óSèÀ_Ö€Ò€R€Ò€Ò€ÒSïÿ—óS¾©õùý{¿©ý‘Èð™@ù´h@ùH´€Ò€Ò€R€Ò€âª€R€R- ”|@“u´!€Òàª^”ôª”´b@ùå*€Ò€Ò䪀€R€R ”@4€Rઑ!”€Ò‡”hŽ@øüÿµ€Rઔ€ý{Á¨õ@ùóS¨À_ÖóS¿©ý{¿©ý‘Èð¡@ù@ùë`TS´h@ùôª¨´àªm”ˆŽ@ø¨ÿÿµàªi”ý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘Èð@ù@ùë`TS´h@ùôª¨´àªW”ˆŽ@ø¨ÿÿµàªS”ý{Á¨óSÁ¨À_Öóøý{¿©ý‘Èð¡‘`@ù@µh@ùhµ€Ò+ÿÿ—`4“ÿÿ—`ÿÿ5`@ùý{Á¨óAøÀ_ÖóS¿©ý{¿©ý‘Èð¡‘઺ÿÿ—`"‘Îÿÿ—Èð¡@ùS´h@ùôª¨´àª*”ˆŽ@ø¨ÿÿµàª&”Èð@ùS´h@ùôª¨´àª”ˆŽ@ø¨ÿÿµàª”ý{Á¨óSÁ¨À_ÖþþÿóS¿©ý{¿©ý‘·”ÈÐ	ùGùÊðH!‘?ñ€R‰ši@9?qhT)4t4?‰qaTŸqôŸà	*ù”@4s‘s‘òÿÿ?qˆTh@8é*ˆÿÿ5àªý{Á¨óSÁ¨À_ÖóS½©õ[©÷ùý{¿©ý‘õª(Ë	‘*ýCÓ¿ëöƒŠš€Òv´—°´†@ø´´è>Aùïª?Ö€?Ös‘ëÿÿTý{Á¨÷@ùõ[A©óSèÀ_ÖóS¾©õ[©ý{¿©ý‘óªôªë`T–°u†@øÕ´È>Aùïª?Ö ?Ö€5ëÿÿT€Rý{Á¨õ[A©óS¨À_ÖóS¿©ý{¾©ý‘ôªóª³ù @¹Ý ”ઔ`@¹ÿ ”ý{¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘ôªÕð¨bE9è5)€RÈð1‘	ýŸˆ¿;Õˆ@ù	@¹©5ÈÐ
@ùKÉð(©@ù
ë`TIÊ3-˚愈°=Aù?Ö€Ò€R€Ò`?ÖÈð¡‘?qTÈð‘p”ˆ@ù	@¹É5ˆ°Á‘‰° A‘Œÿÿ—ˆ°‘‰° ᑇÿÿ—ˆ@ù	@¹É5(€R¨b9ˆ
@ù)€R	9ý{Á¨õ@ùóS¨À_Ö”ˆkàŸÀ_Öcsmàóøý{¼©ý‘ó*â‡)b5ˆ°¡‘	ýßÈ€Ò ?Ö ´@y©I‹R	k!T<@¹ªˆR
À(‹I@¹?kaTH1@y-qTH…@¹9q©THù@¹h4à*3”èc‘ÿC9èùéS‘èC‘é#©H€RI€Ré£)ãs‘⣑ბàG‘yÿÿ—è@¹ˆ4ý{ĨóAøÀ_Öà*”óøý{¿©ý‘ó*€ ”qàTèª1@ù	½@¹*!SJ5ˆ°‘	ýßÈ ?Öˆ°A‘	ýßÈá* ?Öà*”ˆ°!‘	ýßÈà* ?ÖóS¿©ý{¾©ý‘ˆÐ¡‘ÿù‰°(‘	ýßÈô*âC‘€R ?Ö4ˆÐ‘à@ùˆ°¡‘	ýßÈ ?Öóªó´ˆ°=Aùïª?Öà*`?Öà@ù ´ˆ°a‘	ýßÈ ?Öý{¨óSÁ¨À_ÖÈð©ùÀ_Ö"€RA€R€Rÿÿ"€R€R€R}ÿÿ€RA€RzÿÿÈÐ
@ùÌðˆ©@ù€RIk	K
ë¡T	,Ëš*
ÊŠ©ùÀ_Ög€R€Rhÿÿý{¿©ý‘àµ)
”È€R¹ä”À€RÈðÕI¹¿;Õ¹€Rý{Á¨À_Öý{¿©ý‘@Qur!T0@qàTÈðQ'‘ýŸˆ¿;Õ€R
”È€R¹Ê”À€Rý{Á¨À_Ö|@“?@qÉð-A
‘ýF“@’¨ylø	€ÒÉ!›*á@9+åÀ9OÀT? @q T(@@Qyr@T?AqTH2(á9(€R©yløÊ%›Hå9
H2(á9H€RùÿÿH(á9H2(á9©yløÊ%›_å9o5Rk5ˆRq‰ R( R ˆÀ_ÖóS¾©õ[©ý{½©ý‘õªµù @¹“”¿C9Èðá‘óªÖгùˆ"‘ë`TÉB
‘h@ù	ë TÁB
‘ષ#”`ùs"‘óÿÿ @¹¤”ý{èõ[A©óS¨À_ÖÈðq‘)€R	ýŸˆ¿;ÕÀ_Öý{¾©ý‘ãS‘âC‘ác‘àC‘ˆ€R‰€Rè§)Ïÿÿ—ý{¨À_Öóøý{¿©ý‘ó*F”¨C¹J€R)€RrI‰1 Ts4q`T
qàT‘”È€R¹L”€
y2¨¹€ÊÐHá	¹à	*ý{Á¨óAøÀ_ÖÈðaA¹¿;ÕÀ_Öý{¿©ý‘qéTv”È€R¹1”€Èð
‘Hý_ˆ@ý	ˆÉÿÿ5¿;Õà*ý{Á¨À_ÖÈð‘‘À_ÖóS¿©ý{¾©ý‘óªôª´ù @¹”ઔó*€@¹@”à*ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘óªôª´ù @¹
”àªy”ó*€@¹.”à*ý{¨óSÁ¨À_ÖóS½©õ[©÷c©ý{¿©ý‘÷ªè@ù
@ù-´ØÐ@ù©@ù*Ê©@ù‹V-Ëš*Ê©	@ùN-Ëš*ÊM-Ëšß
ë¡T¨ËýC“ñ	@€Ò(“š	«
€ÒU‰š¿ë#T€Òáªàª0#”ôª€Ò³”Tµu‘᪀Òàª'#”ôª€Òª”´Ž‹@ùöª‹€Ò直Ë	‘*ýCÓß
ë胊šÈ´k‘ì…øë¡ÿÿT@ùè@ù‰
€RJ	K€R	@ù*-ÊšKÊËù@ù
€R‰I	Kê@ùÈ.ÉšÊÈ!‘I@ù
€R+ù@ù‰J	K	-Êšê@ù+ÊH@ù
€Rù@ùˆHKê@ù©-Èš+ÊH@ù	ù€ý{Á¨÷cB©õ[A©óSèÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘öªÈ@ù@ùkµ€?ÚÐL@ùi@ù*Êi@ùŽU-Κ*Ê©Ñ?
±T-ΚHTùª÷ªøª›°”"ÑŸë£Tˆ@ùë`ÿÿT	Ê™ùh?Aù3-Κïª?Ö`?ÖÉ@ùL@ù+@ùŽh@ù
Êh@ùM-Κ¿ë
ÊK-Κ`XúàüÿT÷
ªõ
ªøªôªâÿÿ¿±€Tàª+”L@ùÈ@ù	@ù,ùÊ@ùH@ùùÉ@ù*@ùL	ù€Rý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖáªÈð¡‘ý{½©ý‘ãS‘àù⣑ác‘àC‘胑èùI€RH€Rè§)ÿÿ—ý{èÀ_Ö`µ€
	@ù@ù	ë¡TÈÐ@ù ©ù€RÀ_Öý{¼©ý‘ãS‘à©âÑác‘àC‘胑飑è'©H€RI€Rè§)ëþÿ—ý{ĨÀ_ÖÈ°A
‘ÉÐ(½ù €RÀ_Öý{¿©ý‘ÈС‘Øÿÿ—ÈБÕÿÿ— €Rý{Á¨À_Öý{¿©ý‘˜üÿ— €Rý{Á¨À_Öóøý{¿©ý‘È°@ù઺
”àªÀ"”àª"#”àªnúÿ—àªÖýÿ— €Rý{Á¨óAøÀ_Öý{¿©ý‘€RÃìÿ—Sý{Á¨À_ÖóS¿©ý{¿©ý‘ÓÐjÊCùHý_ˆQHý	ˆ©ÿÿ5¿;Õ(5`ÊCùÔ°ˆ‘ë€T¢”ˆ‘hÊù €Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘ÓÐ`¶Cù•”¶ùÓÐ`ºCù‘”ºùÓ°`òGù”òùÓ°`öGù‰”öù €Rý{Á¨óAøÀ_Öý{¿©ý‘ˆ°A‘‘/"”Sý{Á¨À_Öý{¿©ý‘Sè4ÈÐ@ùH´§” €Rˆ°A‘‘M"”Sý{Á¨À_Öóøý{¿©ý‘o”@ùó´ïªˆ=Aù?Ö`?Ö(	”óS¿©ý{¾©ý‘óªôª´ù @¹y”àªo”S€@¹š”à*ý{¨óSÁ¨À_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘ú*óª÷ªûª³µž
”È€R¹Y
”€’ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖhÀ9hþÿ4Wþÿ´è@ùþÿ´À9Èýÿ4€Rભ<”á€Rõªàª©<”ôª€µÕµA€Rણ<”õª5µhÀ9éªh4(À8èÿÿ55Ë ‘!€ÒÖ	”ôª”µ€Ò”Õÿÿˆ°A‘¡‘઴” 
5⪡‘àªÿ"”
5€Ò•
‘ý
”¿ñ
Uú€•šëÁ€Ràªó”š|<”€´€Ràª<%”à5ãªâªáªà*@”ôª4ˆÀ9éªh4(À8èÿÿ5(Ë‘àª!€Ò¤	”õªuµ€’$âªáªàª„” 5¸‹7
”ˆ°a‘@¹–R‘⪡€ÒÑy”@5€Ràª%”4”‘Ÿë¡þÿTàªÁ
”€’"
”㪹âªà*᪔ôªàªµ
”ળ
”àª|ÿÿ€Ò€R€Ò€Ò€ÒOêÿ—óS¿©ý{¯©ý‘ÿCÑó*ôªàªáªôµ
”È€R¹À	”€’¶@ÿÿ´q‰Tò	”¹õÿÿ㣑ÿ#ùâ‘ÿù‘#”1áTà@ù
”à#@ùÿùŠ
”ìÿÿèÑÿùqè7ùèŸèƒ9éã‘裑é;ùèCùéÑ胑飩è€Ré€Ré#
)ãC‘â‘áS‘àã‘ÿÿ—S¨5à@ùp
”ÿùàÿÿÇ	”èѹqæ@ù}©	€Rá#@ù}©å‰}©éÑ}©€Ò}©$€R}©€Ò1ù
€Rè³¹èó@y€Òàªéùèçyè@ùèùèc‘èù±#”ô£I©ô'ùè3ù€5‰(‘#
q€Ts5ˆ‘	ýßȀઠ?Öˆ!‘àO@ùác‘	ýßÈ ?Ö 4à3@ùó[€¹± TˆÁ‘	ýßÈ ?Öà'@ù± TˆÁ‘	ýßÈ ?Ö(ˆ‘	ýßÈ ?Öe	”à3@ù± TˆÁ‘	ýßÈ ?Öà'@ù± TˆÁ‘	ýßÈ ?Ö€’qaT±àTઉ(Á‘	ýßÈ ?Öô'@ùŸ±ÀTˆÁ‘	ýßÈઠ?Ö€Òà@ùÿ	”à@ùÿùü	”à#@ùÿùù	”઱ÀTઉ(Á‘	ýßÈ ?Öà@ùî	”à@ùÿùë	”à#@ùÿùè	”àªÿC‘ý{ѨóSÁ¨À_Ö€Rüÿ—óS¾©õù÷ùý{¿©ý‘ôªˆ@ù×Ð	@ù?ùˆ@ù	@ù?ùÊÐSQ‡¹³´kÑìB
‘
	€ÒhýFÓˆyhøi@’)!
›*á@9Š4sÑkÑÿÿµ(ŽƒÒëÃT%	”ˆ€R¹€R;h>S	
!€Ò*U=@Óàª|”Àµ	”ˆ€R¹€R+‘¹l‹íª
€ÒS´çB
‘	€ÒHýFÓèxhøI@’.!›Ïá@9 7oi*8È@ùi*8€’J‘¨…ø_ëAþÿTˆ
@ù	@9I5ñh€Òh2ˆšÈ´	€’8щ…ø¨ÿÿµˆ@ù3€R	@ù ùŠ@ùH@ùù€Ò„	”à*ý{Á¨÷@ùõ@ùóS¨À_Öâªáª@€R€Ò2þÿóS¾©õ[©ý{¿©ý‘ôªóªö*4µh¢@9ˆ4`
@ùk	”¢9~©ùNˆÀ95h@ùhµh¢@9ˆ4`
@ù_	”¢9@€Òd
”ˆ€Rñ`
ùŸq韚qèŸh¢9iù 5h
@ùyæÿÿ€R€Ò€âª!€Rà*µ”|@“5µˆ‘	ýßÈ ?Ö‚”£”@¹%i@ù¿	ëiTh¢@9ˆ4`
@ù6	”¢9 úÓ;
”ˆ€Rñ`
ùŸq©ŸšqèŸh¢9iù5d
@ùå	*€âª!€Rà*”|@“ˆµ‰(‘ÚÿÿÑhù€Rý{Á¨õ[A©óS¨À_ÖóS¿©ý{¾©ý‘ µt”È€R¹/”€ý{¨óSÁ¨À_Ö€¨¹¿¹¿¹€Rå*€Rã*⪡C‘ S‘·”ô*´¹¨@¹³@¹è4”4i~@“*ýF“ÈÐA
‘)@’	€Òyjø*!›Iá@9(Há9à*””4L”¹Úÿÿà*ÙÿÿóS¼©õ[©÷c©ùk©ý{¾©ý‘÷*é~@“ÈÐA
‘ôª*ýF“Ÿ9)@’yjø	€Òöªó*)!›*áÀ9êø6uj!TàC‘ÿ¹ûÿ—à5è@¹	jATs2i
?@q:€RX€R€T(A@Qyr`T(@Qyr€T(AQyrTš9
3*ïÿÿ(`€Rh
qT˜9Ÿ9
r TÈÀ9è
07Õ@¹
¨R	€R€R¨
kàT
°R
kÀT
¸R
k!TÈ
@¹è4	q©Tq	Tq!T3€R©4b€Rÿ¹áC‘à*{”q`ÊAzó“1 Tè@¹qàTqTkaTš9*B€R€Òà*)'”À´€R€Òà*$'”±TÓ”@¹7©~SÝÿÿ=ÉÿŸR	k¡TʔȀR¹ôÿÿéߟR	k!T€RA€Òà*'”±`ýÿT˜9€R€Òà*'”±`üÿTS4ˆÀ9€Rÿ¹qàT	qáTèߟRè¹S€Rù¹s€R“4€RõC‘¡Â4‹bKà*ù$”1€ùÿTkÿÿT€Rý{¨ùkC©÷cB©õ[A©óSĨÀ_Ö€Ò€R€Ò€Ò€ÒÏçÿ—@óS½©õ[©÷ùý{¾©ý‘óªô*9ˆrõ*ö*×€R TqT	q T{”¹7”€	´6Ÿ
r`T¸R¨R°R‰
h¹?qèT?yr`T?qàT?q T?q¡TI€R‰€Ri€R?q T?q T?q TV”¹”h@¹	€©€R)€Ri
¹¿BqT¿‚q€T¿ÂqT¿q€T¿qÀTB”¹þ”€	°R	kèŸh€RH€R(€R€R	€Rh¦)¹”86hÀ92h9´x7HŸjáTàC‘úùÿ—À5è@¹!@q€ThÀ9a2h9@6È°J¹é(**
j87(€Rh¹T06h@¹j@¹	2i¹i@¹H2h¹*2j¹”`6h@¹	2i¹”h6h@¹	2i¹”(6h@¹	2” 6h@¹	2i¹ý{¨÷@ùõ[A©óSèÀ_Ö€Ò€R€Ò€Ò€Ò2çÿ— Õ@óS¿©ý{¾©ý‘ó*i~@“È°A
‘*ýF“	€Òyjø)@’)!›	€R+á@9jaTK86B€R€’)&”ôªŸ±TÍ”@¹
qTÓ”@¹"€Rÿ#yáC‘à*Z”è#@yq	ZzÁTáªà*/%”1þÿT€R€Òà*
&”±@ýÿT€Rý{¨óSÁ¨À_Ö⽩ä©æ©ý{¿©ý‘êC‘è
Ë	@’"ij¸7þÿ—ý{Á¨ÿÑÀ_ÖóS¼©õ[©÷c©ùk©ý{º©ý‘õªÿ©öªÿ©€Òÿ+ùàC‘ÿc9óª÷*ø*ù*ú*ìÿ—è@ù)½ŸR
@¹	k!Tè£@9¨4ê@ùH©C¹	yI©¹"½ŸRã”è£@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáÑàªýÿ—ô#@ù`4€
æ*å*ä*ã*âªáªàª
”ó*ècA9h4ઔà*ý{ƨùkC©÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¸©ý‘ó*öªôªùªà*â*á*èÑÃþÿ—êÑõ?@¹H%@©ëc‘J	@ù¿1h%©j	ùT;”€¹ˆ¹A”@¹ü”€¹1!T0”€¹ˆ¹6”€R¹òÿÿ(€RêG@¹ÿ+ùȹ€Rá“F)èK¹ès*	èC@¹é[¹€Òã#‘â*E*hð‘	ýßÈઠ?ÖûkE)äD)÷ªÿ±ÁTé7@¹¸R(kTó6hð‘6y	ýßÈE*€Òö¹ã#‘á*ઠ?Ö÷ªÿ±aT‰€¹È°A
‘	€Ò*ýF“yjø)@’*!›Iá@9(kði‘Há9(ýßÈ?ÖÔ”´ÿÿö@¹hð!‘	ýßÈઠ?Ö`5hð‘	ýßÈ ?Öó*Æ”‰€¹È°A
‘	€Ò*ýF“)@’yjøàª*!›Iá@9(Há9ið(Á‘	ýßÈ ?ÖÓòÿ5Ö”¨€R ÿÿqTècÀ92qTècÀ92õcÀ9€@¹áªT”‰€¹Ì°ˆA
‘	€Ò¸2*ýF“øc9yjø)@’)!›ˆA
‘	€Ò8á9Š€¹KýF“ykøI@’)!›?å936€@¹Âþÿ—õ*µ4€@¹´”à*gêc‘€@¹ÿC9H%@©ëƒ‘J	@ùãC‘â*ბh%©j	ùXýÿ—ˆ@¹õ*u4à*íÿÿ}@“Õ°©B
‘ýF“
@’(ykø	€ÒéCÀ9K!›¨B
‘iå9Š€¹KýF“ykøI@’,!›‰õ@9(ASJ*S		€Rh
Jˆõ9	jTs6‰€¹¨B
‘	€Ò*ýF“yjø)@’+!›iá@9(2há9È	¸R	k¡T“6hðÁ‘	ýßÈઠ?Öhð‘	ýßÈÁzäD)E*€Òã#‘ઠ?Ö±aThð‘	ýßÈ ?Ö8”‰€¹¨B
‘	€Ò*ýF“yjø)@’+!›iá@9(há9€@¹x”ÿÿ‰€¹¨B
‘	€Ò*ýF“yjø)@’)!› ù€Rý{Ȩû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¾©ý‘ú*H@“É°8A
‘ýF“@’{wø	€Òôª)#›;@ùâ´ˆÀ9)qT(á@92(á@9j€R

–‹(á9Ÿëõªóªb
T©À9?iqÀT¨‘?5q€Ti9õª<ëbTÀ9)qTI€RH€Ò(€Ò‹i90õªhðA‘	ýßÈ€ÒãS‘"€RáC‘ઠ?Ö@4è@¹4{wø	€Ò)#›	€R*á@9_j@TêCÀ9_)q`T¨€Rh9{wø)#›*é9èCÀ9)q`TúaTH€R"€R€’à*-$”èCÀ9	€Ò)qÀT	€Ò¨€Rh9s‘¿ëC÷ÿT{wø)#›*á@9Š07H2(á9H€Rh9s‘`Ký{¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¾©ý‘ú*H@“É°8A
‘ýF“@’{wø	€Òôª)#›;@ùâ´ˆ@y)qT(á@92(á@9j€R

–‹(á9õªóªŸë‚T©@y?iqà	T¨
‘?5q€TiyõªEëbT@y)qTI€Rˆ€ÒH€Ò‹iy9õªhðA‘	ýßÈ€ÒãS‘B€RáC‘ઠ?Ö`4è@¹(4{wø	€Ò)#›	€R*á@9_jè#@y`T)q€T©€Rè'yiy{wøéCÀ9*#›Ié9{wøéOÀ9+#›ií9{wø)#›H€R(ñ9)q`TúaTH€R"€R!€’à*¨#”è#@y	€Ò)qÀT	€Ò¨€Rhys
‘¿ë#öÿT{wø)#›*á@9Š07H2(á9H€Rhys
‘hË	ýA“ ySý{¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘÷*øªùªúªñþÿ—`5€Rcè~@“É°5A
‘ýF“@’¨ztø	€ÒÊ"›IåÀ9)4à ‹ÑiÀ9iø7óª9ËhÁ‘)S,€R	Éé8)5iÁ‘Ÿq`’Xú£Thþ_8Œ(Éè8Hÿÿ4mÀ9hÁ‘©SÉé8Ë5”H€R¹€;hkaTsB,‹Há@9		€R	j`TMé9k‘Ÿ	qÃT¨ztøiÀ9k‘Ê"›Ií9Ÿ
qÁT¨ztøiÀ9k‘Ê"›Iñ9sA,ËèK}@“"€Rà*0#”sKã*å*äªâª€R ½ŸRä”à5hð‘	ýßÈ ?Ö²”Ðÿÿ¨ztøkxSË"›¨€Riõ@9*
H€RŸI*iõ9ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¼©õ[©÷c©ùùûùý{¾©ý‘ó*³¹öªõ*
1áT©”¹±”(€R¹4³ø7È°QG¹k"Th~@“ýF“É°8A
‘@’	€Ò{wø)#›*á@9ê6°¿kÉT‘”¹™”È€Rà*”€{wø)#›*á@9ê7”(€R¹‚”¹â*áªà*”ô*à*K”à*v”¹~”(€R¹9”€ý{¨û@ùù@ù÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¼©ý‘ö*áùß
1U|@ÓáT\”¹d”(€R¹v!ø7È°QG¹ßkâ TÈ~@“É:A
‘ýF“@’I{yø
	€Ò
'
›Ká@9«6°¿kÉTD”¹L”È€RùU4+7!ÿÿ´H@ù€Òÿ£©[åÀ9qÀTq!T63”¹;”È€R¹ö”Óô*óªÕþ7¨~Sq‰€R41ˆàªÑ”óª€ÒÆ”€ÒóùÔóµ%”ˆ€R¹”€R»"€R€Òà*j"”H{yø
	€Ò	#
› ùI{yø
'
›		€Rÿ¹÷ªHá@9	j THéÀ9)q„@z Th9(€Rè¹H{yøK€Rs‘”Q	#
›+é9û4H{yø	#
›*íÀ9_)q„@z TH€Rj9è¹H{yøs‘”Qq	#
›+í9áTH{yø	#
›*ñÀ9_)q„@z Th€Rj9è¹H{yøs‘”Q	#
›+ñ9à*2"” 4H{yø		€Ò	#	›*áÀ9
ø6hÐa‘à@ù	ýßÈბ ?Ö 4(€RèC9qÁTiÐ(‘à@ù	ýßÈ€Òãc‘‚~S᪠?Ö5hБ	ýßÈ ?Ö ”ó@ù\é£B)4ÿC9iÐ(A‘à@ù	ýßÈ€Òãs‘â*᪠?Öè@¹q
UzÈTé@¹	H{yø
	€Ò	#
›*áÀ9Š	ø6‰~@“q Tã@ù¤þAÓâ	ªáªà*gþÿ—ô*AèC@9"ýAÓ¨4ì‹éªëªÿë‚T*@y_iq€T_5qAT(	‘ëâT@y)qTJ€Rˆ€ÒH€Ò		‹jyh	‘ëª?ëƒýÿTH{yø
#
›Iá@9(2Há9hË	ýA“4ySáªà*³ýÿ—ÔÿÿhБ	ýßÈ ?ÖqATk”(€R¹^”ó@ù¨€R¹€´qaT€R<”€ó@ùàªö”à*
€RK”¹S”(€R¹”€ý{Ĩû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¿©ý{¾©ý‘óªôª´ù @¹Á”h@ù@¹	|@“*ýF“ÈA
‘)@’	€Òyjø)!›*á@9Š6:”ó*/”(€R¹€€@¹ò”à*ý{¨óSÁ¨À_Öý{½©ý‘à¹1áT”¹”(€R¹ø7ÈQG¹k‚T	|@“ÈA
‘*ýF“)@’yjø	€Ò)!›*á@9J6èS‘à)àC‘èùãc‘⃑ás‘½ÿÿ—÷”¹ÿ”(€R¹º”€ý{èÀ_ÖóS¾©õùý{¿©ý‘ô*Y”±ÕaT€RªªAùŸqaTH!C9¨7Ÿ
qATHB96 €RI”óª@€RF”ëàýÿTà*B”hÐÁ‘	ýßÈ ?Öýÿ5hБ	ýßÈ ?Öó*à*ú”ˆ~@“©B
‘ýF“
@’(ykø	€ÒI!›?á9³4à*£”€€Rý{Á¨õ@ùóS¨À_ÖÿCÑÿÿŸˆèÿ߈ÿC‘Tý{¿©ý‘ñ$@úèT±”È€R¹l”À€Rbµ9øÿÿéªJËHié8(8h4!Ñÿÿµµ9Ÿ”H€R¹Z”@€R€Rý{Á¨À_Öý{¿©ý‘‚”`´À€R‘”¨ð1B¹H6`>Ô`€RIôÿ—À7 6À6°R?k©T €RÀ_Ö°ûÿÿ€RüÿÿóS¼©õ[©÷c©ùùý{½©ý‘óªh@ùõ*wSȵs”Ø€R¹.”••4¨
Q‰qÿÿTáªàC‘Ôæÿ—y@ù€Rî@ù-‘4À9mùì
ªÈ@ù‰S
ÙixÊ6¬‘´À9íªlùøÿÿŸ¶qè2÷ˆŸ¶qéª`TŸ®qT,‘4À9lùèªØ€Ru4¿BqaT쪈B	S?%qhTˆÂQ
ˆ~	S?eqhTˆ^Qˆþ	S?eqˆÞQIT€h4H€RÀ9‹‘ê€Rkù¨S	aQ?
jàT¿q€Rlѵˆlùí4ˆÀ9
k€T ”¹Ü”l@ùl‘tÀ9lù€R¿qµˆ€U5€>Ô
	ÕK¡ˆB	S?%qhTˆÂQ
ˆ~	S?eqhTˆ^Qˆþ	S?eqˆÞQIT€1@TkTß
kÃTß
k
KziT‰€RÖ"	€Rh@ù7*‘À9lùÜÿÿˆÑhùô4À9k€T唹¡”×7è£@9yù¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ù€R1á*à*Hÿÿ—Sè4Ï”H€R¹w7€è£@9—6¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ù°R¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ù°W6öKè£@9¨4ê@ùH©C¹	yI©¹i@ùi´h@ù(ùà*ý{èù@ù÷cB©õ[A©óSĨÀ_ÖóS¾©õùý{¿©ý‘ ´è€’	ÀšëƒT|›)€ÒÕ òDùñ3ˆšhС‘	ýßÈ⪀R ?Ö`µhС‘ôÿ—`4ઔ4 òDù⪈þßÈ€R?ÖÀþÿ´z”ˆ€R¹€Òý{Á¨õ@ùóS¨À_ÖÈÍùÀ_ÖóS½©õ[©÷c©ý{¿©ý‘ôªõªöª÷*øªv”@´ÜAù´hÐ=Aùïª?Öäªã*âªáªàª`?Öý{Á¨÷cB©õ[A©óSèÀ_Ö¨ð	@ùËhÍ@ù*)Ê3-ÊšSýÿµäªã*âªáªàª„àÿ—€Ò€R€Ò€Ò€ÒÏÿÿhðÁ‘
€RL}@Óˆñ}Ó	ik¸	kàTJ_µq#ÿÿTLQEqhT €R
ðQ9q
€RÉ€R@‘‰‰ñ}Óh‘ ih¸À_Öóøý{¿©ý‘ó*0”€µ¨ðá‘‘à*¹Úÿÿ—ó*&”€µ¨ðÑ‘€‘¹ý{Á¨óAøÀ_Öý{¿©ý‘”€µ¨ðá‘‘ý{Á¨À_Öý{¿©ý‘”€µ¨ðÑ‘€‘ý{Á¨À_Ö€ÒóS¿©ý{½©ý‘ôªóªôµîÿÿ—È€R¹©ÿÿ—€ÒSÿÿ´Ÿë‚ÿÿTáªàC‘Oåÿ—ì@ùˆ	@¹h5`Ñ
kÑkÑŸë¨Th@9‹	e@9Iÿ7hË	@’j	Ë@Ñè£@9¨4ê@ùH©C¹	yI©¹ý{èóSÁ¨À_Öý{¿©ý‘£µ µAµ€R
à´Á´cµ9úÿÿ"µ9ºÿÿ—È€R¹uÿÿ—À€Rý{Á¨À_ÖëªéªêªL˱áTˆië8h8¨4)щÿÿµ
ˆië8h8¨4)Ñi´JÑJÿÿµJµ9iûÿµ±¡T‹ñ8
€Rãÿÿ9–ÿÿ—H€R¹Qÿÿ—@€RÜÿÿóS¾©õùý{½©ý‘ó*áªàC‘õ*ô*óäÿ—è@ùjSÁ*‹	e@9?jaTÕ4è@ù@ù	Ùjx*

€Rj5€R €Rè£@9¨4ê@ùH©C¹	yI©¹ý{èõ@ùóS¨À_Öá*€Òƒ€R€RÖÿÿóøý{¿©ý‘âª"´ÈñDùh°Á‘	ýßÈ€R ?Ö 5h°‘	ýßÈ ?Öÿÿ—ó*Qÿÿ—¹ý{Á¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{½©ý‘¨ð‘áùú‚‘|@ÓöªI{yøøª¿;մЋ@ùji	Ê -Êš±`
T`
µßë	ThÐ	%‘h°
‘é+©k°{a‘ÔF@¸óztø¿;Õ“´±ÀT45ytøRHýßÈ€Òàª?Ö󪳵i°(‘ýßÈ?Ö\qÁThС;‘â€Òàªh”4hÐá;‘â€Òàªb”@4i°(‘ýßÈ€R€Òàª?Öóª€ÒÓµè‹	€’	ýŸÈ¿;Õê‹Hý_ÈSý	ÈÉÿÿ5¿;Õˆ´hÿßÈàª?Ö3µé+A©ßëaøÿT´Ð‹@ù€ÒÓ´h°¡‘á@ù	ýßÈઠ?ÖÀ´Š@ù€RIi	K,ÉšI‹

Ê*ýŸÈ¿;մЋ@ùìÿÿ‹@ùi
€RJ	KI‹€’-ÊšÊ+ýŸÈ¿;Õ€Òý{èû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¿©ý{¿©ý‘hб?‘hÐÁ?‘ôªC‘€€Rlÿÿ—óª3´h°=Aùïª?Ö᪠€’`?Ö ý{Á¨óSÁ¨À_Ö Õ%Àóøý{¿©ý‘hÐ!<‘hÐA<‘C‘€RQÿÿ—óªó´h°=Aùïª?Ö`?Ö €Rý{Á¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘ÿCÑõªhÐ<‘óªô*hС<‘ö*C ‘ €R÷ªø*úªûª.ÿÿ—ùª9´h°=Aùïª?Öè;@ùçªæªå*äªã*èùâªá*ઠ?Ö
€Ràªë”h°¡‘	ýßÈå*äªã*âªá* ?ÖÿC‘ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¿©ý{¿©ý‘hÐá<‘hÐ=‘ôªC ‘`€Rüþÿ—óª´h°=Aùïª?Öàª`?Öh°‘	ýßÈ ?Öý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘hÐA=‘hÐa=‘ó*C ‘€€Ràþÿ—ôª´h°=Aùïª?Öà*€?Öh°a‘	ýßÈà* ?Öý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘hÐ=‘hС=‘ó*C ‘ €RÄþÿ—ôª´h°=Aùïª?Öà*€?Öh°!‘	ýßÈà* ?Öý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘hÐá=‘ó*ôªhÐ>‘C ‘À€R¦þÿ—õª5´h°=Aùïª?Öáªà* ?Öh°A‘	ýßÈáªà* ?Öý{Á¨õ@ùóS¨À_ÖóS¾©õ[©ý{¿©ý‘ö*hÐA>‘óªô*hÐa>‘C ‘@€Rƒþÿ—õªU´h°=Aùïª?Öâ*á*ઠ?Öh°á‘	ýßÈá*ઠ?Öý{Á¨õ[A©óS¨À_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘ÿCÑõªhÐá>‘óªô*hÐ?‘ö*C ‘€€R÷ªø*úªûªVþÿ—ùª9´h°=Aùïª?Öè;@ùçªæªå*äªã*èùâªá*ઠ?Ö
€Rઔh°Á‘	ýßÈå*äªã*âªá* ?ÖÿC‘ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS¾©õùý{¿©ý‘hÐA?‘óªõ*hÐa?‘C ‘À€R"þÿ—ôª4´h°=Aùïª?Öá*઀?ÖàªÒ”ý{Á¨õ@ùóS¨À_Ö©ð*	‘¨Ð@ùHA‘L€Ò_ë	€Ò샌š)‘K…ø?ë¡ÿÿT €RÀ_ÖóS¾©õùý{¿©ý‘Sè5¨ð‘i°5a‘t‚‘`†@øÀ´±`T¨þßÈ?Ö‚øëÿÿT €Rý{Á¨õ@ùóS¨À_ÖóS¾©õ[©ý{¾©ý‘€R¿¹€Rï”s€Rµð¶ð³¹È@¹kT¨@ù	ÙsøIµ©ù(@¹¿;Õ5
S4¨@ùÙsøÜ”1`Tˆ¨¹¨@ù	Ùsø Á‘j°H!‘	ýßÈ ?Ö¨@ùÙsø¦ýÿ—¨@ùÙ3ø´@¹sÞÿÿ€Rí”à*ý{¨õ[A©óS¨À_ÖóS¿©ý{¾©ý‘óªôª´ù @ùgáÿ—j@ùh@ù	@ù)´)@¹¿;Õ(5
S¨4(	qaT?rAT	X6h
@ù	@9é5h@ù@ù	@¹¿;Õ(SÈ4h@ù@ù“”1ÀTj@ùH@¹	I¹h@ù	€	¹€@ùGáÿ—ý{¨óSÁ¨À_ÖóS¾©õ[©ý{º©ý‘õªôª´ù @¹†”¨ð@ù©ð(€¹v‹³ùë Th@ù¨ùª@ùÈ´	@¹¿;Õ(5
SH4(	qaT?ráTÉX7H@¹	I¹s"‘ëÿÿª
@ù©@ù¨@ù«c‘«#ù¨'ù©+ùª/ù¨@ù¨ù¨ù£ƒ‘¢‘¡£‘ C‘›ÿÿ—îÿÿ€@¹~”ý{ƨõ[A©óS¨À_Öý{¼©ý‘èS‘àC9èùéC‘èc‘é#©€Rÿÿ)	€Ré£)ãs‘⣑ბàG‘´ÿÿ—èC@9é@¹qè@¹ ˆý{ĨÀ_ÖóS¿©ý{¿©ý‘óªi@¹¿;Õ(	q!T?ràTh.@©KkùŸq¹-TM”a@ùâ*º”Ÿk TjR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ€h@¹¿;Õ	Sè4jR‘Iý_ˆ)yIýˆ¨ÿÿ5¿;Õ€Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘󪓵€R´ÿÿ—àªÉÿÿ—`5h@¹¿;Õ-S¨4ઠ”G”`5€R€ý{Á¨óAøÀ_Ö €RŸÿÿóøý{¿©ý‘óªh@¹¿;Õ5
S4h@¹¿;ÕSˆ4`@ù»üÿ—jR‘(€Iý_ˆ)
Iýˆ¨ÿÿ5¿;Õ~©¹ý{Á¨óAøÀ_ÖóS¼©õ[©÷c©ùùý{¸©ý‘h°‘	ýßÈàC‘ ?Öè§@y¨4è/@ùh´@¹	„R‘Ÿ
@q“²‰à*Q”¨ðQG¹´Â4‹kÁ“Ö4©ð8A
‘h°!‘€Ò	€Ò€†@ø± T±àT©@9©6‰7èþßÈ?Ö 4hþF“{høi@’*!›‰‚_øIù¨@9Há9s‘µ‘ÖQVýÿ5ý{Ȩù@ù÷cB©õ[A©óSĨÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘¨ðA
‘h°¡‘i°8!‘€R:€’
	€Ò;€R–~@“ÈþF“èzhøÉ@’3!
›i@ù*	‘_ñ©Thâ@92hâ9*{â9ô4Ÿq`T`€@€ €(ÿßÈ?Öõª¨‘ñ‰TÿßÈ?Ö€R 4uù	qThâ@92äÿÿ
q¡Thâ@92ßÿÿhâ@9zù2hâ9¨ð	@ùi´(yvø¹”Ÿq
	€ÒáøÿTý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_Öóøý{¿©ý‘à€R@”€R€RÍ”€5eÿÿ—¤ÿÿ—3€Rà€R]”à*ý{Á¨óAøÀ_ÖóS¿©ý{¿©ý‘¨ðA
‘€Ò`jtø`´ ”j4øs"‘ñCÿÿT €Rý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘€±hTñ(€Ò€šh¡‘µÐ òDù	ýßÈ⪀R ?Ö`µh¡‘Êîÿ—`4àªß”4 òDù⪈þßÈ€R?ÖÀþÿ´<ûÿ—ˆ€R¹€Òý{Á¨õ@ùóS¨À_Öý{¾©ý‘à©A´ ù#€RáC‘€Ò®ùÿ—ý{¨À_ÖóS¾©õùý{½©ý‘óªôªõªô	´Õ	´ˆÀ9ˆ5³	´yKáªàC‘„àÿ—é@ù*½ŸR(
@¹
kaT¨Ða‘âªáªàª]”	€q ±€(@ùˆµs´ˆ@9hy €Rè£@9H4ê@ùH©C¹	yI©¹-€@9ác‘1”à4é@ù#	@¹qT¿kKT 
@¹ñåŸäªâª!€Rõ”é@ùÀ5(	@¹¿Â(ëãTˆÀ9¨4 	@¹àÿÿè@ùñåŸäª#€R
@¹âª!€Rã” úÿ5×úÿ—H€R¹€Ñÿÿ¨Ð­ù€Rý{èõ@ùóS¨À_Ö€Ò¡ÿÿóS¾©õùý{¼©ý‘ôªã#yŸñõª¤
@úóª©TS´¹€R7s´€h¹è{@²¿ëéT³úÿ—È€R¹núÿ—À€R+áªàƒ‘àÿ—è@ù)½ŸR
@¹	k¡Tá#@yâc‘ÿùàªm”S´`¹qmTœúÿ—@¹@ùµè#@yýqÉTŸñ¤@ú©T⪀Ràª`Óÿ—úÿ—H€R¹@€Rèã@9¨4ê@ùH©C¹	yI©¹ý{Ĩõ@ùóS¨À_Öt´u´ˆ9S´(€Rh¹å*ÿ¹çS‘€Òäª#€RâC‘€Rœ”à4è@¹üÿ5S´`¹€Ràÿÿh‘	ýßÈ ?ÖèqÁúÿTŸñ¤@ú©T⪀Ràª.Óÿ—[úÿ—H€R¹úÿ—@€RÍÿÿóS¿©ý{¾©ý‘ôªóª³ù @¹
”ˆ@ù	@ù*E@ùIý_ˆ)Iýˆ¨ÿÿ5¿;Õ`@¹-
”ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘óªôª´ù @¹û”h@ù@ù`J@ùÀ´Î”`J@ù¨Ð½CùëT¨°A
‘ë€T@¹H5<”Jù€@¹

”ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘ôªóª³ù @¹Û”ˆ@ù	@ùŠ@ù!@ù@@ù”`@¹ù”ý{¨óSÁ¨À_ÖóS¿©ý{¾©ý‘ôªóª³ù @¹Ç”ˆ@ù	@ù E@ù€´ü_ˆQü	ˆ©ÿÿ5¿;ÕÈ5¨°‘ë@Túÿ—`@¹Ü”ý{¨óSÁ¨À_Öý{»©ý‘èc‘àùèù¨€Rè#¹èc‘è#ùˆ€R©€Ré£)¨Ðá‘éÑèù+€Ré'ù‰€R(¹ãƒ‘é/¹h°	A‘è@ùâã‘á“‘àC‘	ùê@ù¨°‘K©¹é@ù(Eùê@ùi€RIyyè@ù	…yè@ùÑùpÿÿ—㣑â‘᳑àC‘¡ÿÿ—ý{ŨÀ_Öóøý{¿©ý‘󪓴”àªQúÿ—ý{Á¨óAøÀ_Öý{¼©ý‘裑ࣩ¨€R蹩€R裑é¹èù‰€Rˆ€Rè§)	@ùh°A‘?ë€Tà	ª9úÿ—à@ù8@ù6úÿ—è@ù-@ù3úÿ—è@ù1@ù0úÿ—è@ù5@ù-úÿ—è@ù%@ù*úÿ—è@ù)@ù'úÿ—è@ù=@ù$úÿ—è@ùA@ù!úÿ—è@ùáAùúÿ—ãS‘âÑác‘àC‘sÿÿ—ãs‘âã‘ბàC‘:ÿÿ—ý{ĨÀ_ÖóS¿©ý{¿©ý‘ôª€J@ùóªÀ´	”¨Ð½Cù€J@ùëT¨°A
‘ë€T@¹H5w”“Jùs´àª5”ý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘h‘	ýßÈ ?Öó*µ° ŠB¹1 T1ûÿ—ôª´´Ÿ±ÁT€Ò ŠB¹€’Dûÿ—`ÿÿ4y€Ò €Ò øÿ—ôª ŠB¹Ôµ€Ò;ûÿ—€ÒÓùÿ—ðÿÿáª6ûÿ—À5 ŠB¹€Ò2ûÿ—àª÷ÿÿàª>ÿÿ—€ÒÆùÿ—h!‘	ýßÈà* ?ÖÔ´àªý{Á¨õ@ùóS¨À_Öˆ÷ÿ—óS¿©ý{¿©ý‘´°€ŠB¹1Tûúÿ—󪓴±@T€ŠB¹€’ûÿ— 4y€Ò €Òkøÿ—󪀊B¹Óµ€Òûÿ—€Òžùÿ—áªûÿ—À5€ŠB¹€Òýúÿ—àª÷ÿÿàª	ÿÿ—€Ò‘ùÿ—³´àªý{Á¨óSÁ¨À_ÖY÷ÿ—óS¾©õùý{¿©ý‘h‘	ýßÈ ?Öó*µ° ŠB¹1 TÇúÿ—ôª´´Ÿ±ÁT€Ò ŠB¹€’Úúÿ—`ÿÿ4y€Ò €Ò6øÿ—ôª ŠB¹Ôµ€ÒÑúÿ—€Òiùÿ—ðÿÿáªÌúÿ—À5 ŠB¹€ÒÈúÿ—àª÷ÿÿàªÔþÿ—€Ò\ùÿ—h!‘	ýßÈà* ?Öàªý{Á¨õ@ùóS¨À_Öý{¿©ý‘!‘^úÿ—¨°‰¹1aT€R»ÿÿ—€µ€R”úÿÿ €Rý{Á¨À_Öóøý{¿©ý‘³°`ŠB¹1€Tcúÿ—€hŠ¹ €Rý{Á¨óAøÀ_Öóøý{¿©ý‘óª¨Ð½Cùi@ù?ëT¨°áI¹	¨C¹?jaT`”`ùý{Á¨óAøÀ_Öóøý{¿©ý‘óª¨ÐÉCùi@ù?ëT¨°áI¹	¨C¹?jaTΔ`ùý{Á¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{½©ý‘ÿCÑóªáK@ùõª9¿qàƒ‘÷ªøªùªÖSú*´ ŸÂÝÿ—ˆ.ÿÂ(ëèTRøÿ—H€R¹
øÿ—@€R±ª@ùHùtÓýñaTè›@¹ç*ÿù€Rå*äªãªè¹âªáªàª¯”`49ž¡€Ràª[*” ´È	R*iSKA99’ªø¶¨€Rh9ª@ùs‘ÈRIS6ø€Òy‘_)Lò€RáT{9¨@ùÉ€ÒÍ@ò8Ÿš(€Rh9w‘s
‘t5€Rè@ù}@ù	@ù(À9(9¨@ù	Í@’I´€RáàÒŸqmT¨@ù	Š+Í@’h%š	=S+Áj=S_åqiTH
=SHQj9=s‘!üDÓ”Q¢ýÿ6bø7ã›@¹àª”SÈ4kÑí€RlÀ9ˆS	Q?
jaT{õ8úÿÿëTŸåqÈê@Tˆ	i9hñß8hñ8ŸqÍTâ*€RધÐÿ—sB4‹èÀ9­€RqHkSk™š	Ai9ª@ùl	‘HùtÓ	ËË?ñ*¡ˆš?ñh€R¨±ˆh9_¡ñ›9ëªT	}€ÒH
Éš‹‘
©	›	Á‰9ëaT_‘ñT‰€ÒH
Éš
©	›	Ái9k‘ëD	JúTI€ÒH
Éš
©	›	Ái9k‘H	Ái99€Rèã@9¨4ê@ùH©C¹	yI©¹ÿC‘ý{èû#@ùùkC©÷cB©õ[A©óSŨÀ_ÖóS½©õ[©÷ùý{¾©ý‘ô*ˆ
ëª
‘`@ý_ëõªóªâªC1„šáC‘€ÖS÷*”è@¹å[@¹ä*ãC‘‚µq럚Ÿqêןš¨
Ë	ËH‹¿±‹¡‰š£”`49
ç+@ù€RåC‘ä*ã*â*áªàª”ý{¨÷@ùõ[A©óSèÀ_ÖóS¼©õ[©÷c©ùk©ý{½©ý‘ó*qhŸ	%øªÃ)ëôªwSù*õªÖSˆTF÷ÿ—H€R¹÷ÿ—@€Rý{èùkC©÷cB©õ[A©óSĨÀ_ÖáªàC‘¥Üÿ—64¨@¹µq韚*‹qmTHÀ9é
ªh4(À8èÿÿ5(
Ë‘á
ª@‘’Ðÿ—¨@¹ëªº€RµqaTš9‹‘q
ThÀ9é@ùh9(}@ù	@ù*À9j8È@Ò	Á3‹±3‹ŠËH‹i°"±‘ˆšàªWõÿ— 5`
‘w4¨€Rh9¨@ù	À9?Áq T¨@¹
Qmø6í
Kz9¿‘qkT¨}(›	ý`Óh
À9+}l}K‰€Rµ	h
9¿)qkT¨¨}(›	ý`ÓhÀ9+}l}Kh9ˆ	­KhÀ9
h9?qáTÀ9ÁqTb€Ò‘FÐÿ—è£@9¨4ê@ùH©C¹	yI©¹€R“ÿÿ€Ò€R€Ò€Ò€Ò×ÿ— Õ…ëQgfffóS½©õ[©÷c©ý{½©ý‘óªàC‘áªö*õª—S+Üÿ—ª@¹€Rw4HQkT¨@¹µq韚*Á*‹H‹_i38ñ8¨@¹µqT¨€Rh9s‘¨@¹q,TÈ5¨@ù	À9(€R?Áq@T€R—4h4t‘hÀ9éªh4(À8èÿÿ5(Ët‘‘àªáªýÏÿ—x9tÂ(‹ßqÍTˆÀ9éªh4(À8èÿÿ5(ˑ᪀‘îÏÿ—è@ù“‘}@ù	@ù*À9Š9¨@¹ˆø6èKÿq
VzÔ¢ˆt4hÀ9éªh4(À8èÿÿ5(Ë`Â4‹‘áª×Ïÿ—‚~@“€Ràª;Ïÿ—è£@9¨4ê@ùH©C¹	yI©¹€Rý{è÷cB©õ[A©óSèÀ_ÖóS¼©õ[©÷c©ùùý{¾©ý‘èª@ýöªõ*ôªâªéC‘ãª?}©áC‘à*ØSù*Ñ”è@¹åc@¹ä*ãC‘â*µqè@¹éŸš3‹ß±QÈ	ËÁˆšàªr”`4Ÿ9è@¹	Q?1$¡UzÊTÿ	kŠThÀ8èÿÿ5â8å7@ù$€RãC‘â*áªàª\ÿÿ—
ç7@ù&€RåC‘ä*ã*â*áªàªÄþÿ—ý{¨ù@ù÷cB©õ[A©óSĨÀ_Öý{¿©ý‘)S(‘ê*ëઢT9€€Rý{Á¨À_Öé4¨€R9±8@TcшS	R-ySNQo°é‘«	‹,ykøˆÀ9êªh4HÀ8èÿÿ5HËë臟	
+	‹è‘áªykø6ôÿ—`5€Rßÿÿ€Ò€R€Ò€Ò€Ò#Öÿ—óS¾©ö_©ý{¿©ý‘ôªˆ@ùöªW<	Š*Í@’K%ךs=Sƒ5"qà7Ÿ*씀5‹@ùhŠ	Í@’*%ךL=SŸ!qiT €R£T(€Ò!ך	Ñ*Š_Í@òÿÿTÿÂqÀTÈKŠ	½@’*%ךKS)LòëŸ`
q¡T34ˆ@ùèø·çÿÿqTs4ˆ@ùHüÿ·€Rý{Á¨ö_A©óS¨À_ÖóS¾©õ[©ý{¾©ý‘ÿCÑíªóªôªëªõ*óµ™õÿ—È€R¹Tõÿ—À€RwTÿÿ´+ÿÿ´ÿÿ´¿q T¨Q	q€RHT&€RG7¬@ùˆùtÓýñÁTˆÍ@òaT €RÌø¶	àÒ	ëaT€€RˆýsÓê(*K`2ˆýÓSä*ãªâª]ÿÿ—SèDÓ2è[@¹ÿ{òŸ¿„qlT¨Qyr T¿q T¿qè+@ùç*ö¹å*ãªâªáªèùà
ªîüÿ—:¿”qÀT¿˜q€Tè+@ùç*ö¹å*ãªâªáªèùà
ªíþÿ—+ @ý胑ãª}©âªáƒ‘à*È”è#@¹å*ä*パµqè'@¹éŸšŸ± ‹ˆ	ˈšk”`49å+@ù€Rパâ*áªàª_þÿ—è+@ùç*ö¹å*ãªâªáªèùà
ªýÿ—ÿC‘ý{¨õ[A©óS¨À_Öý{¿©ý‘àµõÿ—È€R¹Ðôÿ—€@¹¿;Õý{Á¨À_Ö(@¹	Q)¹Iø6š(@ù9)@ùS*‘*ùÀ_Ö¨@ù©°)±Cù
@²?
ëàŸÀ_Öóøý{¿©ý‘óª@€R?Ùÿ—ë`T €R;Ùÿ—ë¡TàªÑÿÿ—8”`5€R €Rý{Á¨óAøÀ_ÖóS¿©ý{¿©ý‘óªæÿÿ—Sh4 €R&Ùÿ—ëT¨°¡‘@€RÙÿ—ëT¨°Á‘ª°H@¹	I¹j@¹¿;Õ˜€R_j¡TjR‘KP€RIý_ˆ)*Iýˆ¨ÿÿ5¿;Õˆ@ù赂Ò]ùÿ—€ù€ÒRõÿ—ˆ@ù €Rµhr‘hùI€Rhùi¹i"¹hù	‚Rˆ@ùùÿÿ€Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘Sóª4h@¹¿;Õ%	Sˆ4àª!øÿ—jR‘P€Iý_ˆ)
Iýˆ¨ÿÿ5¿;Õ"¹~©ý{Á¨óAøÀ_Öý{¾©óS©ý‘)Íÿ—ÿÃÑó*ô*áªà#‘íÙÿ—hqÈTè@ù@ù	Ùsx 
ë@ùj~ISh@ù	ÙéxÉø6ê9C€Ró9ÿ9ó9#€Rÿ9裑¹&€R	ye
@¹ä£‘â‘!€RàC‘É	”`5€RèS@y
èƒ@9¨4ê@ùH©C¹	yI©¹ÿÑþÌÿ—óSA©ý{¨À_ÖëbT€ëà—ŸÀ_ÖóS¾©õù÷ùý{¿©ý‘ôªóª÷*4µh¢@9ˆ4`
@ùØôÿ—¢9~©ùRˆ@y5h@ùhµh¢@9ˆ4`
@ùÌôÿ—¢9 €ÒÑøÿ—ˆ€Rñ`
ùŸq韚qèŸh¢9iù 5h
@ù9æÿÿ€Ò€Ò€R€Ò€âª€Rà*B”|@“5µHð‘	ýßÈ ?Öíóÿ—ôÿ—@¹'i@ù¿	ëiTh¢@9ˆ4`
@ù¡ôÿ—¢9દøÿ—ˆ€Rñ`
ùŸq©ŸšqèŸh¢9iù@5d
@ùå	*€Ò€Ò€âª€Rà*”|@“ˆµIð(‘ØÿÿÑhù€Rý{Á¨÷@ùõ@ùóS¨À_ÖóS»©õ[©÷c©ùk©û#ùý{¼©ý‘öªøªøµÖóÿ—È€R¹‘óÿ—À€Rqù€ÒÈ@ùÿ©€ÒÿùH´S€Rõ€RáC‘óC9àªõG9ÿK9¼”È@ùàµãƒ‘€Ò€Òàªi”áªàªâƒ‘È”ô*t5ÈŽ@øhýÿµóWB©©Ë(ýC“‘(‘ëª	ýCÓë탉š€Ò€Ò­´j…@øHÀ9é
ªh4(À8èÿÿ5(
Ë‹Œ‘‘Ÿ
ë¡þÿT"€Òáªàª˜ãÿ—öª¶µ€ óWB© Ú‹ôªŸë÷ªàTÛË‚@ùHÀ9éªh4(À8èÿÿ5(Ë‘IËèùãª!‹àª´óÿ—@5è@ùwk4ø”"‘Ÿë‹ýÿTù€R€Ò
ôÿ—öª¨Ë	‘*ýCÓßëõƒŠš€ÒÕ´À†@øôÿ—÷‘ÿëÿÿTàªþóÿ—à*ý{Ĩû#@ùùkC©÷cB©õ[A©óSŨÀ_Ö€Ò€R€Ò€Ò€Ò”Óÿ—óS¼©õ[©÷c©ùùý{¿©ý‘öªÈÀ9éªùªôªóªh4(À8èÿÿ5(Ë‘è4ªÿë	T€€Rý{Á¨ù@ù÷cB©õ[A©óSĨÀ_Öè‹‘àª!€Ò•òÿ—õªô´ãªâªáªàªdóÿ—à5Ëãªâª ‹^óÿ— 5i¢@©?ëT`@ù€µ€Ò€€Òòÿ—`ù€Ò¶óÿ—i@ù	´(‘i¢©ËýC“	ð’Ÿ	ëT–úÓ᪀Ò"
”@µ€Ò¥óÿ—ણóÿ—“€R€Ò óÿ—à*Åÿÿ‹`"©	‹€Òi
ù˜óÿ—i@ù5ùh@ù	!‘iù€Rðÿÿ€Ò€R€Ò€Ò€Ò/Óÿ—ý{»©óS©õ[©÷c©ù#ùý‘ŠËÿ—ÿÃÑôªàªöª³XÀ9½Q	S?µqhTi&ÈšÉ7áªàªâòÿ—ë¡þÿT	À9?éqATˆ‘ëàT㪀ҀÒàªyÿÿ—¬(½Q	S?µq¨Th&Èšh6)€R	€RËÿ©?qÿ©à‘ÿKù€Òÿc9ùˆš#Øÿ—è@ù)½ŸR
@¹	k!Tèc@9¨4ê@ùH©C¹	yI©¹"½ŸRôÿ—èc@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáÑઽéÿ—èC@ù€Rq€Ò€RàˆšHБ	ýßÈ⃑€R ?Öøª±T㪀ҀÒàª1ÿÿ—ó*^È&@©)Ë7ýC“€Òÿ©àƒ‘ÿ©ÿ3ùÿ£9ã×ÿ—è@ù)½ŸR
@¹	k!Tèã@9¨4ê@ùH©C¹	yI©¹"½ŸRÃóÿ—èã@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€Rá‘à3‘þÿ—õ+@ùqà•šÀ9¹qáTÀ9h4¹qaTÀ9è4ãªâªáªõþÿ—ó*35è£A9h4àªÝòÿ—HÐ!‘	ýßÈბઠ?Ö ÷ÿ5Ê"@©	
Ë+ýC“ÿëàTèÿÿðá0‘@
‹aË€Ò#”€Rè£A9h4àªÅòÿ—HÐá‘	ýßÈઠ?ÖècB9h4àC@ù¼òÿ—à*ÿÑÇÊÿ—ù#@ù÷cC©õ[B©óSA©ý{ŨÀ_Ö 4þÿóS¾©öùý{¿©ý‘ôªóªö*ôµh¢@9H4¢9~©ù8ˆ@y5h@ùhµh¢@9H4¢9ýñÿ—H€R¹@€R¢9ù+h
@ù9îÿÿ€Ò€Ò€R€Ò€âª€Rà*”	|@“)µHБ	ýßÈ ?ÖÂñÿ—ãñÿ—@¹h@ù?ëÈûÿTd
@ùå*€Ò€Ò€âª€Rà*”|@“ˆµIÐ(‘êÿÿÑhù€Rý{Á¨ö@ùóS¨À_Öý{¾©óS©ý‘gÊÿ—ÿƒ	ÑHÐá‘	ýßÈóªT|@Ó¢ €RáC‘ ?Ö5HБ	ýßÈ ?Ö”ñÿ—€R)€ÒóS©à‘óS©ÿ#ùÿ#9×ÿ—è@ù)½ŸR
@¹	k!Tèc@9¨4ê@ùH©C¹	yI©¹"½ŸRùòÿ—èc@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RბàC‘{ÿÿ—à#@ùÿƒ	‘4Êÿ—óSA©ý{¨À_ÖóS¾©õ[©ý{¾©ý‘ôªöª¶ù @¹B”ˆ@ù	@ù*E@ùAa‘¨‘ @ù ´¡´" €RÝÊÿ—Ó€R" €Ò€R@Êÿ—mñÿ—Ó€R¹(ñÿ—ˆ@ù	@ù*E@ùLe‘«@ù‹´ì´Š‘ˆ%Á¨h%¨Ÿ
ë¡ÿÿTh‘}¨ëÁÿÿTXñÿ—¹ñÿ—ˆ@ù	@ù*@ùHý_ˆQHý	ˆ©ÿÿ5¿;Õ(5ˆ@ù	@ù @ùˆð‘ë@Táñÿ—ˆ@ù@ù‰@ù*@ùhE@ùHù‰@ù*@ùKE@ùiý_ˆ)iýˆ¨ÿÿ5¿;ÕÀ@¹”ý{¨õ[A©óS¨À_ÖqT q`TÔqÀThÁ‘Øqàˆš	h‘hA‘h‘À_Öóøý{½©ý‘ó*àC‘€Ò‚Öÿ—©?™¹
1ÁT(€R(™¹IÐ(‘1!T(€R(™¹IÐ(a‘	ýßÈ ?Öó*1¡T(€R(™¹è@ù
@¹è£@9¨4ê@ùH©C¹	yI©¹à*ý{èóAøÀ_ÖóS¿©ý{¿©ý‘ôª“b‘àª" €R€R¼Éÿ—ˆð‘ha‘ŸBøŸù) €RŸÂø
ËŸ¹His8)Qh8©ÿÿ5‰f‘he‘	Ë
 €Rhii8JQ(8ªÿÿ5ý{Á¨óSÁ¨À_Öý{¾©óùý‘oÉÿ—ÿƒÑóª`@¹(½ŸRkÀ
THС‘	ýßÈáC‘ ?Ö
4€R飑(8q£ÿÿT€Rè[@9ë£9é[‘ˆ4죑*@9q¢T‹I(8
kiÿÿT(-@8èþÿ5e@¹€Rä£‘ €R⣑!€R€Ò”g@¹ €RaAù壑ÿ¹ €R㣑 €R€Ò”g@¹ €RaAù壑ÿ¹ €R㣑@€R€Òw”of‘,€Rî£‘
€Ò
 €R磑棑É%@xé6iB,‹Kig8(a@92(a9	é6iB,‹Kif8(a@92(a9€RKi/8ŒJ‘­Qýÿ5 €Ò€R
 €Rh…QeqTh}QjB(‹nSIa@9(2Ha9
hQeq(Th}QjB(‹Ia@9(2iHa9.S€Rh‹e9kŒ‘­Q­üÿ5ÿƒ‘ûÈÿ—ó@ùý{¨À_ÖóS¾©õ[©ý{¼©ý‘ó*â©6SáªàªS”à*%ÿÿ—è@ùô*E@ù	@¹Ÿ	kaT€RE€ÒÛôÿ—õªóªõ´è@ùE€RE@ùšÉÿ—ᪿ¹à*’”ô*Ÿ1T(ðÿ—È€R¹€àª¿ðÿ—à*ý{Ĩõ[A©óS¨À_ÖV5hãÿ—è@ù
E@ùHý_ˆQHý	ˆ©ÿÿ5¿;Õ5è@ùE@ù‰ð(‘ë@T©ðÿ—(€R¨¹è@ù€ÒEùé@ùˆðáI¹*©C¹_jÁûÿT胑飑è'©¨€R©€Rè§)ãS‘âÑác‘àC‘qþÿ—Vúÿ4è@ù	@ùŠðIùùÍÿÿóS¾©õùý{¿©ý‘ôªõª‰ªC¹ˆðáI¹?j TˆJ@ùh´“F@ù €R¤”“F@ù¨@ùë T³´hþ_ˆQhþ	ˆ©ÿÿ5¿;Õè5ˆð‘ë`Tàªkðÿ—³@ù“Fùiþ_ˆ)iþˆ¨ÿÿ5¿;Õ €R°”Ó´àªý{Á¨õ@ùóS¨À_Ö)îÿ—óS¿©ý{¿©ý‘´ˆr^9h5¨‘‰ð(‘h
ù‰ð)‘ˆðÁ‘h&©’öÿ—âª@€cB‘!€R]ÿÿ—(€Rˆr9 €Rý{Á¨óSÁ¨À_Öý{¿©ý‘Höÿ—¨A‘­ÿÿ—ý{Á¨À_Öý{¼©óS©õ[©÷ùý‘7Èÿ—ÿCÑóªvþÿ—ô*4ˆðA!‘
€R€ÒU}@Ó¨~›	iv¸?k@
TJ_q#ÿÿT½ŸRŸk@	THÐA‘	ýßÈ€>S ?Ö€4(½ŸRŸkaTh¹ù¹:y
¹Âø¹àªŸþÿ—pHС‘	ýßÈá‘à* ?Ö 4ub‘àª" €R€R4Èÿ—è@¹t¹ù	qTè@9é‘(4(@9è4+@9kHTKj¨Jj8kQ2¨J*8Jkÿÿ5(-@8(þÿ5)€R)¨Ji8?ýq2¨J)8cÿÿT`@¹þÿ—)€R`ù	€Ri
¹Éÿÿˆð™G¹5€9wb‘àª" €R€RÈÿ—ˆÐ!‘€ÒŽ€RÆ€ÒÏB‘¨2›ë
‹j@9j4h@9(4_k¨TM¿qBTèJm8J‰ig8(*èJ-8h@9­_kÉþÿTj-@8êýÿ5Œ‘ÎQýÿ5(€Rt¢)à*Þýÿ—
€Ò`ùl2‘Ë€R€ÒÍ‘¨*›kQJ‘©yhx‰%xkÿÿ5‘ÿÿàª
þÿ—€RÿC‘¦Çÿ—÷@ùõ[B©óSA©ý{ĨÀ_Ö¨†˜RkˆTˆ…˜RK%qˆTéT€R(%Èh7¨qaT€RÓšRk T(Õ›RkiThÖ›RkÉþÿT½ŸRk`þÿT(½ŸRkAT!H°Á‘	ýßÈ Ö½ŸRKq¨†˜R釟kHTˆ…˜RK%qˆTêT€RH%Ȉ7¨qÓšRkàT(Õ›RkIThÖ›Rk)T½ŸRkÀT(½ŸRk`T!x€R?q臚?q憚i4G´ÿ¹çªH°á‘	ýßÈ ÖóS½©õ[©÷ùý{¿©ý‘H°‘	ýßÈ ?ÖõªU´¨@y몈4éª=h4(-Àxèÿÿ5(Ë	ýA“*‘k
‹h@yÈþÿ5hË		‘7ýA“ã*€Ò€Ò€R€Ò⪀R€R®ÿÿ—|@“Ö´àª"óÿ—ôªóª´´å*€Ò€Òäªã*⪀R€Ržÿÿ—`4€Ò€Òàªïÿ—€ÒÕ´H°!‘	ýßÈઠ?Öàªý{Á¨÷@ùõ[A©óSèÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¿©ý‘öªù*ÖµRîÿ—È€R¹€ª¡€Ràªóªþ ”øªñVú`T›ðt—@ùÀ9—ðè¢@ùŸë¡Tધ”ôªt—ù”µ•ðÙ4¨š@ùˆ´ƒßÿ— ´t—@ùè¢@ùŸëATઘ”ôªt—ùº4€Ò €Ò‰íÿ—`—ù€ÒÀîÿ—t—@ùT´¨š@ùHµ€Ò €Òíÿ— šù€Ò¶îÿ—¨š@ù´t—@ùÔ
´ˆ@ùËõª´âªáªàª(”À5¨@ù	i÷8?õq$@z`T¨Ž@øôÿÿ¨ËýC“¨ËõˆËuø·ˆ@ù(´€zuø˜îÿ—z5ˆzuø´‰‹(@ùµ‘(ù‰‹(@ùhÿÿµ€Òáªàª”ôª€Ò‡îÿ—´€Ò–z5ø4õË¡
‘?ë#Tü’?ëÂT€Òàªñ”ôª€Òtîÿ—ô´ˆ‹€Ò}©t—ù¹4ÈÀ9éªh4(À8èÿÿ54Ë€
‘!€Ò+íÿ—õªuµ€Râª
‘àªìÿ—`5¨Ë	‹*‘_q_ñ8ኚઔ5¶íÿ—H€R¹€àªMîÿ—	àªJîÿ—€R«íÿ—È€R¹€àªBîÿ—à*ý{Á¨û#@ùùkC©÷cB©õ[A©óSŨÀ_Ö€Ò€R€Ò€Ò€ÒØÍÿ—óS¾©õ[©ý{¿©ý‘óªÓµ€Òý{Á¨õ[A©óS¨À_Öh@ù	€Òꪈ´H@ø)‘Èÿÿµ€Ò ‘äìÿ—ôªT´i@ùÉ´–Ë(À9ê	ªh4HÀ8èÿÿ5U	Ë ‘!€ÒÖìÿ—Àj3ø€Ò
îÿ—Àjsø ´b@ù¡‘¶ëÿ—à5iŽ@ø©ýÿµ€Òîÿ—àªÖÿÿ€Ò€R€Ò€Ò€ÒŸÍÿ—Èëÿ—ÿÿóS¾©õ[©ý{¿©ý‘ˆð‘€R•ð€Òh~@ÓQ›€RôRqïÿ— 4¨ÒI¹s:q	©Ò	¹£þÿT €R€R”€Rý{Á¨õ[A©óS¨À_Öˆð‘	|@“
€Ò !
›J°IÁ‘(ýßÈÖóS½©õ[©÷ùý{¿©ý‘–ðÓÒI¹Ó4ˆð‘H°!‘€ÒsQ©þßÈ`R› ?ÖÈÒI¹	QÉÒ	¹3ÿÿ5 €Rý{Á¨÷@ùõ[A©óSèÀ_Öˆð‘	|@“
€Ò !
›J°Iá‘(ýßÈÖý{¾©ý‘èªÿ¹	1@ù*@ùK	@¹ëø7àC‘Aîÿ—è@¹€Rq@T €Rý{¨À_ÖóS½©õ[©÷c©ý{¿©ý‘	€Ò€ÒUìÿ—óªsµ€Ò @‚Òt‹ë€Tu‘W€R€’¶ÂÑ઀RôRïÿ—¸‚ø
€R¿†ø¨R\8¿x·"8·28·B8¨R8ÈÂ*‹Iê	*ù9?qcÿÿT¨ÂÑë!ýÿT€Òjíÿ—àªý{Á¨÷cB©õ[A©óSèÀ_ÖóS¾©õ[©ý{¿©ý‘óª´@‚Òt‹ëõª TH°!‘ÈþßÈàª?Öµ"‘¿ëaÿÿTàªNíÿ—ý{Á¨õ[A©óS¨À_ÖóS½©õ[©÷c©ý{¾©ý‘õ*¿
@qcT¤ìÿ—(€R¹_ìÿ— €Rý{¨÷cB©õ[A©óSèÀ_Ö€Rà€R\ÿÿ—€Ò¿ù˜ð—ðéRG¹¿	k+TC
‘ÈzsøH´’ÿÿ—Àz3øÀµ”€Rà€Rqÿÿ—à*æÿÿèRG¹	éR¹s‘³ùíÿÿ	|@“ˆðA
‘*ýF“)@’yjø	€Ò !›K°iÁ‘(ýßÈÖóS½©õ[©÷c©ý{¿©ý‘ó*ôªóø7ˆðQG¹kbTh~@“‰ð6A
‘ýF“@’Èzuø	€Òé"›*@ù_±T‘Ûÿ—qT34q T
qaT`€@€ €H°a‘	ýßÈ᪠?ÖÈzuø€Ré"›4ùDìÿ—(€R¹7ìÿ—¹€ý{Á¨÷cB©õ[A©óSèÀ_Ö	|@“ˆðA
‘*ýF“)@’yjø	€Ò !›K°iá‘(ýßÈÖóS½©õ[©÷c©ý{¾©ý‘à€Rêþÿ—€µ¹€R¿¹˜ðqŠTC
‘–Úsø6µ!ÿÿ—€Ú3øÀ´ŠðHQG¹	IQ¹ufSà*”ÿÿ—¨~@“
ýF“	C
‘+yjø(€Rhá9à€Rôþÿ—à*ý{¨÷cB©õ[A©óSèÀ_Ö@‚Ò׋ôª´ùŸë Tˆâ@9H6àªH°Á‘	ýßÈ ?Öˆâ@9(6àªH°á‘	ýßÈ ?Öµ@¹”"‘ìÿÿˆË		€Ò
Éš¨~@“ýF“
C
‘@’
	€ÒHyløi!
›(€R(á9Hyløi!
›
€’-ùÏÿÿs³¹·ÿÿóS½©õ[©÷ùý{¿©ý‘ó*Sø7ˆðQG¹kÂTh~@“‰ð5A
‘ýF“@’¨ztø	€ÒÊ"›Iá@9‰6H@ù± TôÚÿ—qT34q T
qaT`€@€ €H°a‘	ýßÈ€Ò ?Ö¨ztø
€’€RÉ"›*ù¦ëÿ—(€R¹™ëÿ—¹€ý{Á¨÷@ùõ[A©óSèÀ_Öý{¿©ý‘1áTŒëÿ—¹”ëÿ—(€R¹ ø7ˆðQG¹k¢T	|@“ˆðA
‘*ýF“)@’yjø	€Ò+!›iá@9i6`@ùuëÿ—¹}ëÿ—(€R¹8ëÿ—€’ý{Á¨À_ÖŠðHÕI¹	ˆR€Rq(ˆHÕ	¹À_ÖóS¿©ý{¿©ý‘󪓴ˆÐ%‘`@ùˆ@ùë@Tÿëÿ—`@ùˆ@ùë@Túëÿ—`@ùˆ@ùë@Tõëÿ—`@ùˆ@ùë@Tðëÿ—`@ùˆ@ùë@Tëëÿ—`"@ùˆ"@ùë@Tæëÿ—`&@ùˆ&@ùë@Táëÿ—`6@ùˆ6@ùë@TÜëÿ—`:@ùˆ:@ùë@T×ëÿ—`>@ùˆ>@ùë@TÒëÿ—`B@ùˆB@ùë@TÍëÿ—`F@ùˆF@ùë@TÈëÿ—`J@ùˆJ@ùë@TÃëÿ—ý{Á¨óSÁ¨À_ÖóS¿©ý{¿©ý‘󪓴ˆ°%‘`@ùˆ@ùë@T³ëÿ—`@ùˆ@ùë@T®ëÿ—`
@ùˆ
@ùë@T©ëÿ—`.@ùˆ.@ùë@T¤ëÿ—`2@ùˆ2@ùë@TŸëÿ—ý{Á¨óSÁ¨À_ÖóS¾©õùý{¿©ý‘ôª‰‹(ð@’€ÒŸ	ëõƒˆšÕ´€†@øŽëÿ—s‘ëÿÿTý{Á¨õ@ùóS¨À_Öóøý{¿©ý‘󪓴á€Òæÿÿ—á€Ò`â‘ãÿÿ—€Ò`‘àÿÿ—€Ò`B‘Ýÿÿ—A€Ò`‘Úÿÿ—`¢@ùrëÿ—`¦@ùpëÿ—`ª@ùnëÿ—á€Ò`‚‘Ñÿÿ—á€Ò`b‘Îÿÿ—€Ò`B‘Ëÿÿ—€Ò`‘Èÿÿ—A€Ò`B
‘Åÿÿ—`RAù]ëÿ—`VAù[ëÿ—`ZAùYëÿ—`^AùWëÿ—ý{Á¨óAøÀ_Öý{¾©ý‘\ñÿ—áC‘H@ùèùòÿ—è@ù@ùý{¨À_Öbµ€RIÑI´
@y
4(@y_k¡T‘!‘)Ñ	ÿÿµ	@y(@y KÀ_Öý{º©óS©õ[©÷c©ùk©û+ùý‘3Ãÿ—ÿƒÑú‘ù*áªàª÷ªø*ûªô*ó*òÏÿ—t5H@ù
@¹q)€R(€R!ˆ€R€Òã*âªà*ƒûÿ—ö*v5€R;Õ~@“¨úÓ	A‘?ë Ÿš ´ñˆT<‘ëLTèß|²ýDÓÅÿ—ÿs/Ëó‘s´ˆ™™Rïÿ—óªÓ´¨»›Rh¹sB‘€Òó´¢úÓ€Ràª'Ãÿ—å*äªã*âª!€Rà*Xûÿ—`4H‘	ýßÈâ*ãªáªà* ?Öô*€Ró´h_¸©»›R	kaT`BÑ×êÿ—Hc@9¨4J@ùH©C¹	yI©¹à*_‘ÿƒ‘ÛÂÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Ö
@‘Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
p@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
x@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
t@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õ
€@ùÊ´Iý_ˆ)Iýˆ¨ÿÿ5¿;Õˆ°
á‘
à‘Ë€RH_ø
ëTL@ùÌ´‰ý_ˆ)‰ýˆ¨ÿÿ5¿;ÕH^ø´L_øÌ´‰ý_ˆ)‰ýˆ¨ÿÿ5¿;ÕJ‘kQkýÿ5@ùUóS½©õ[©÷ùý{¿©ý‘óªi~@ùi´ˆ°%‘?ëàThr@ù¨´@¹h5`z@ùÀ´@¹ˆ5rêÿ—`~@ùfþÿ—`v@ùÀ´@¹ˆ5kêÿ—`~@ù«þÿ—`r@ùgêÿ—`~@ùeêÿ—h‚@ùÈ´@¹ˆ5h†@ùùÑ^êÿ—hŠ@ùÑ[êÿ—hŽ@ùÑXêÿ—`‚@ùVêÿ—`’@ù2”ˆ°á‘v¢‘tâ‘Õ€Rˆ_øëT€@ùÀ´@¹ˆ5Gêÿ—À@ùEêÿ—ˆ‚^øÈ´€‚_ø€´@¹H5>êÿ—Ö"‘”‚‘µQ•ýÿ5àª8êÿ—ý{Á¨÷@ùõ[A©óSèÀ_Ö ´HБë T
p‘Hý_ˆHý	ˆ©ÿÿ5¿;Õà*°À_Öóøý{¿©ý‘óªs´HБëàTh^A¹¿;Õˆ5þÿ—àªêÿ—ý{Á¨óAøÀ_Ö ´HБë T
p‘Hý_ˆQHý	ˆ©ÿÿ5¿;Õà*°À_Öà´
@‘Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
p@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
x@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
t@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õ
€@ùÊ´Iý_ˆ)QIýˆ¨ÿÿ5¿;Õˆ°
á‘
à‘Ë€RH_ø
ëTL@ùÌ´‰ý_ˆ)Q‰ýˆ¨ÿÿ5¿;ÕH^ø´L_øÌ´‰ý_ˆ)Q‰ýˆ¨ÿÿ5¿;ÕJ‘kQkýÿ5@ù²ÿÿÀ_ÖóS¿©ý{¿©ý‘Éïÿ—ôª‰ªC¹ˆ°áI¹?j`T“J@ùSµ€€RÛûÿ—ˆÐ½Cù€B‘”󪀀Rúûÿ—³´àªý{Á¨óSÁ¨À_Ötçÿ—óS¿©ý{¿©ý‘óªÓ´ ´@ùŸëaTàªùàªÓþÿ—tÿÿ´àª”ÿÿ—ˆ@¹èþÿ5ˆ°A
‘Ÿë`þÿTàªÿÿ—ðÿÿ€Òý{Á¨óSÁ¨À_ÖóS¾©õ[©ý{¿©ý‘ôªõªöªU´è€’	ÕšëÂTÞèÿ—ˆ€R¹€Ò´´àª·”óª€Òµ~›àªáªÄ”ôªŸñnUú¢T¢Ë€R€‹šÁÿ—àªý{Á¨õ[A©óS¨À_Öý{¿©ý‘H¡‘	ýßÈ ?ÖˆÐñùñàŸý{Á¨À_ÖˆÐñù €RÀ_ÖóS½©õ[©÷ùý{¿©ý‘ôªõªŸë@TóªWv@ùö´è>Aùïª?ÖÀ?ÖSˆ4sB‘ëÁþÿTë`TëàTs"Ñh‚_ø´u@ùÕ´è>Aùïª?Ö€R ?ÖsBÑh"‘ëþÿT€R €Rý{Á¨÷@ùõ[A©óSèÀ_ÖóS¾©õ[©ý{¿©ý‘ôªóªŸë€TVu‚_øÕ´È>Aùïª?Ö€R ?ÖsBÑëáþÿT €Rý{Á¨õ[A©óS¨À_ÖˆÐõùÀ_ÖóS¿©ý{¿©ý‘ôª”óªS´H=Aùïª?Öàª`?Ö`4 €R€Rý{Á¨óSÁ¨À_Öóøý{¿©ý‘€Rûÿ—ˆ°	@ù+ŠÐHõDù*ÊS-Ëš€R/ûÿ—àªý{Á¨óAøÀ_ÖóS¿©ý{¾©ý‘óª³ù @¹þúÿ—ˆ°	@ù+ŠÐHEù*ÊT-Ëš`@¹ûÿ—àªý{¨óSÁ¨À_ÖqÀTq T<q`TTq TXq`T€ÒˆÐÁ'‘!‘
ˆÐÁ'‘a‘ˆÐ(‘ˆÐÁ'‘À_Öý{¾©ý‘ãS‘âC‘ác‘àC‘h€Ri€Rè§)Éÿÿ—ý{¨À_ÖˆÐÁ'‘©©À_ÖóS¼©õ[©÷c©ùùûùý{½©ý‘ô*€Ò€R3€R³C9Ÿ"q,T`TŸ
q TŸqàTŸq T$Ÿ.q@TŸ>q€TˆVQq¨Tà*¶ÿÿ—÷ª!ñîÿ—õª5µ€ý{èû@ùù@ù÷cB©õ[A©óSĨÀ_Ö©@ùH°ICù*‹(@¹k T)A‘?
ëaÿÿT	€ÒɵÇçÿ—È€R¹‚çÿ—çÿÿ7!‘€R¿C9€Òs4`€R€úÿ—ö@ùˆ°‘³4(@ùÊÊV-Ëšßñ`TÖ´Ÿ.qèT"R%Ôˆ6¸@ù¸ù¿ùŸ"qÁTNîÿ—@¹»¹Kîÿ—ˆ€R¹Ÿ"qÁTH°	MCù¨@ù
	‹K°iQCùH	‹ªù_ëÀT_ùJA‘ûÿÿ(@ùèùs4`€Rwúÿ—ßñaT€R®ÿÿŸ"qaT.îÿ—óªïªH=Aù?Öa@¹€RÀ?ÖïªH=Aù?Öà*À?ÖŸ.qhýÿT"R%Ôý6¸ùŸ"q¡üÿTîÿ—¹âÿÿs4`€RSúÿ—`€R%Úÿ—ý{¿©ý‘ñ$@úèTaçÿ—È€R¹çÿ—À€Rbµ9øÿÿéª(À9ˆ4)‘!Ñÿÿµÿÿ´J	ËHié8(8h4!Ñÿÿµµ9Içÿ—H€R¹çÿ—@€R€Rý{Á¨À_Öý{»©óS©õ[©÷c©ù#ùý‘Ü¿ÿ—ÿÃÑùªàù?ù`µ€RÁh
€Rÿ«9èƒ9)€Rh€Ré‡9è‹9©
€R¨€Ré—9è“9Š€Ré
€Rê9H
€RéŸ9⃑è›9€Òé£9à‘ê§9ÿù«”À4XqÀTçÿ—@¹ è@ù(´	À9êªi4IÀ8éÿÿ5IË71‘w€Òë@ùT€Òi@ùi´(À9ê	ªh4HÀ8èÿÿ5H	Ëi@ø‹‘éþÿµUøÿ—àù`µÓ€R€À9h4À8èÿÿ5À8õqaÿÿTàùÀ9êªõq¡THÀ9h4H	À9éqTH
À9õq¡TK‘hÀ9éªh4(À8èÿÿ5(Ë
‹
‘IÀ9?õq ýÿTó@ùVËh@ùè´õƒ‘øƒ‘èƒÀ9éªh4(À8èÿÿ5`@ù"Ëბo”€4hŽ@ø¨þÿµ€R‰‹è	‹¿q8ˆšàª!€Òæÿ—ôªTµÀ€R–æÿ—·æÿ—ˆ€R¹“€R95€Rïÿÿóªö´á@ùâªàªÀÿ—“‹Ëö@ùÈ@ùH´âªáªàªìäÿ—à5Ê@ùHÀ9é
ªh4(À8èÿÿ5(
Ë	‘ÈŽ@ø3‹	Ëþÿµu5⃑áªàªÚäÿ— 5H°!7‘áªàª$ÿÿ—à5â@ù¢´áªàªÿÿ— 5ó‹ëaT9s‘9€R4ù€Òçÿ—à@ùçÿ—ÿùà@ùçÿ—à*ÿÑ¿ÿ—ù#@ù÷cC©õ[B©óSA©ý{ŨÀ_Ö€Ò€R€Ò€Ò€Ò¥Æÿ—óS¼©õ[©÷c©ùk©ý{¾©ý‘àùùª	@ù÷ªøª€Òi´(À9ê	ªh4HÀ8èÿÿ5H	Ë	Œ@ø‹‘éþÿµñ(€Òvˆšàª!€Òªåÿ—óªSµ€R"æÿ—Cæÿ—ˆ€R¹€ÒÛæÿ—€*õ@ùôª©@ù©´€RhË‹â	ªàª}äÿ— 5ª@ùHÀ9é
ªh4(À8èÿÿ5(
Ë	‹i484‘©Ž@øéýÿµŸò8€Ò¿æÿ—áC‘ÿùàªßþÿ— 4à@ù¸æÿ—€è@ùóù€Òù±æÿ—€R€Òભæÿ—à*ý{¨ùkC©÷cB©õ[A©óSĨÀ_Ö€Ò€R€Ò€Ò€ÒDÆÿ—óS»©õ[©÷c©ùk©û#ùý{¯©ý‘ÿCÑøªå)ùªæ/ù€Òÿ©àƒ‘ÿ©úªÿ‹ùûªÿc9õªÿÿ©€Òÿÿ©ÿ'ù€RÿC9€Òÿ©€Rÿ
©ÿsùÿ£9MËÿ—è7@ù)½ŸR
@¹	k!TèãA9¨4ê3@ùH©C¹	yI©¹"½ŸR-çÿ—èãA95¨4ê3@ùH©C¹	yI©¹"€R¨4ê3@ùH©C¹	yI©¹€RáÑàªçÜÿ—@5€Òà‘)Ëÿ—èG@ù)½ŸR
@¹	k!TècB9¨4êC@ùH©C¹	yI©¹"½ŸR	çÿ—ècB95¨4êC@ùH©C¹	yI©¹"€R¨4êC@ùH©C¹	yI©¹€RᣑàªÃÜÿ—€5€ÒÕ´€Òàƒ‘Ëÿ—èW@ù)½ŸR
@¹	k!TèãB9¨4êS@ùH©C¹	yI©¹"½ŸRãæÿ—èãB95¨4êS@ùH©C¹	yI©¹"€R¨4êS@ùH©C¹	yI©¹€Rá‘àªÜÿ—€5çk@ùé#W©ãªá@ùâªàƒ@ùæ/@ùé#©(ðá‘	ýßÈåD) ?ÖôCA9ó@ùõ*÷£C9ök@ù÷£C9ök@ùó@ùôCA9€Rw4àª÷åÿ—t4àªôåÿ—ècD9h4àƒ@ùðåÿ—à*ÿC‘ý{Ѩû#@ùùkC©÷cB©õ[A©óSŨÀ_Öý{¾©óùý‘é½ÿ—ÿƒÑó* µ9åÿ—¹Aåÿ—È€R¹üäÿ—À€RvráþÿT(ðÁ‘	ýßÈâ‘€R ?Ö 5(ð‘	ýßÈ ?Öåÿ—-åÿ—@¹è@¹h 7H6hS4åÿ—¨€R¹"åÿ—¨€R¹òÿÿ€Rÿƒ‘ƽÿ—ó@ùý{¨À_ÖóS¾©õùý{º©ý‘óªõ*“µ€ÒÆÿÿ—5€Òÿ©àC‘ÿ©ÿ+ùÿc9tÊÿ—è@ù)½ŸR
@¹	k!Tè£@9¨4ê@ùH©C¹	yI©¹"½ŸRTæÿ—è£@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáÑàªÜÿ—ô#@ù`4€á*ગÿÿ—ó*ècA9h4àªxåÿ—à*ý{ƨõ@ùóS¨À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘q½ÿ—ÿÃÑö*È~@“‰°:A
‘ýF“@’H{yø		€ÒûªxC"‹û3ùé"	›øù(@ùè/ùhC"‹èù)ð(á‘	ýßÈ ?Ö€Òà#¹àã‘!Êÿ—èC@ùÿù€Rÿ¹€Róª

@¹ëê'¹TÈ~@“‰°)A
‘ýF“觩+½ŸR{À9ÿ¹_kŽ8€RT+yhø
€R	€ÒhÁ-‹é"›*ùÀ9Š4­¿qKÿÿTè@ù¿qËÍTH{yøé"›ÈÁ‘*ù@9	Éê8.Ö
KŸÁ6ë‹Tèc‘hËé"›êc‘ë
*,ù‘ˆiê8kQH8«ÿÿ5
€Rßq-Tëªìc‘hÀ8I
J_kˆÉ)8kÿÿT€ÒH{yø­Q	‹ê&›k‘_ù9Mÿÿ5èc‘ÿ£©H€Rßq)€R8ˆ@Óãã‘á‘à‘”±`TÖQi@9ÈÁ‘Éé8ÈŸÁ(ëkTqÿÏ©*€RI€RX‰@Óã#‘áC‘à‘®”±àTsÂ6‹*I{yø
	€Òë&
›lõ@9ˆqƒTè&
›jÀ9B€Òბ	ùÀ9h€Rˆ
ê‡9hõ9éƒ9ùÿ—jÀ9HS	Øèx©ø6è@ùv‘ßë
TB€Òáªà‘_éÿ—1€Tóª"€Òáªà‘Wéÿ—1€
Tà#@¹€Ò€Ò¥€R䣑ã*â‘€Rs‘Aõÿ—ö*4(ðÁ‘ø/@ù	ýßÈ€Òãs‘â*ᣑઠ?Öà	4è3@ùõ@¹jKè@¹Tô¹k£	T+qT¨€Rè3y(ðÁ‘	ýßÈ€Òãs‘"€Rác‘ઠ?Ö 4è@¹ˆ4è@¹”ô¹õ¹è@ùë¢Tè§F©ê'@¹@ÿÿ€RŸñT
€ÒH{yøÉ
Jió8Î	Á)‹ë&›jù9Ê}@“_ëëþÿTˆè¹!
€RŸñmÿÿT
€ÒH{yø­é"›+
‹Jió8jù9ª}@“_ëÿÿTðÿÿH{yø	€Òé"›*ù9J{yø‰é¹ë*›hõ@92hõ9(ð‘	ýßÈ ?Öà¹õ@¹èCB9¨4ê?@ùH©C¹	yI©¹à@ùá*ÿÑT¼ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Öý{¼©óS©õ[©÷ùý‘?¼ÿ—/(€Òµ¾ÿ—ÿs/Ë	|@“ÿùˆ°A
‘ÿ¹*ýF“)@’yjø	€Òóª€RtB"‹)!›ë7@ù¢Töc‘èc‘«€Rñ‚‚Òêc1‹ëbTiÀ9s‘?)qT9!‘	8
ë£þÿTKá¹(ðÁ‘	ýßÈ€ÒãC‘â*ác‘ઠ?Ö@4è‡@)é@¹	è¹?kCTë£ûÿT(ð‘	ýßÈ ?Öá@¹à¹à@ù/(€Òÿs/‹¼ÿ—÷@ùõ[B©óSA©ý{ĨÀ_Öý{½©óS©õ[©ý‘ò»ÿ—/(€Òh¾ÿ—ÿs/Ë	|@“ÿùˆA
‘ÿ¹*ýF“)@’yjø	€Òóª€RtB"‹)!›6@ù%èc‘«€RÑ‚‚Òêc1‹ëbTi@ys
‘?)qTy!	‘	%x
ë£þÿTéc‘á¹	ËýA“(ÐÁ‘	ýßÈ€ÒãC‘¢zSác‘ઠ?Ö@4è‡@)é@¹	?kè¹CTëcûÿT(Б	ýßÈ ?Öá@¹à¹à@ù/(€Òÿs/‹·»ÿ—õ[B©óSA©ý{èÀ_Öý{º©óS©õ[©÷c©ùk©û+ùý‘£»ÿ—O(€Ò¾ÿ—ÿs/Ë	|@“ˆA
‘*ýF“)@’yjø	€ÒóªvB"‹)!›è‘ùë	¹9@ù"T(ÐÁ‘úc‘»€R÷*ëc‘ê‘èªëBTi@ys
‘?)qaTy	‘	%x
ëÃþÿTËýA“€Ò€Ò¥ªRä#‘âc‘€R ½ŸRýóÿ—õ*µ4€RÕ4è#‘A4‹ÿßÈ¢K€ÒãC‘àª?Ö@4è@¹ŸkƒþÿTiKé¹ëâTÓÿÿ(Б	ýßÈ ?Öà¹à@ùá@¹O(€Òÿs/‹[»ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖóS¼©õ[©÷c©ùùûùý{¾©ý‘ó*³¹õªö*
1áT‘âÿ—¹™âÿ—(€R¹,³ø7ˆQG¹k"Th~@“ýF“‰8A
‘@’	€Ò{wø)#›*á@9ê6à*öÿ—€{wø)#›*á@9ê7âÿ—(€R¹râÿ—¹â*áªà*”ô*à*;öÿ—à*fâÿ—¹nâÿ—(€R¹)âÿ—€ý{¨û@ùù@ù÷cB©õ[A©óSĨÀ_Öý{º©óS©õ[©÷c©ùk©û+ùý‘ýºÿ—ÿÑö*óªõ*Õ43µJâÿ—¹Râÿ—È€R¹
âÿ—€®È~@“‰;A
‘ýF“@’h{zø	€Ò÷ùê"›TåÀ9ˆþ	S?qHTUý7Há@9¨(6B€R€Òà*†”à*†” 4h{zøé"›*áÀ9*ø6Øèÿ—H@ù	@ù©µh{zøé"›*åÀ9*4h{zøბé"›(Ða‘ @ù	ýßÈ ?Ö4T4Ÿq€ÊBz¬
TyB5‹ÿù€R€Rÿ¹ë÷ª‚Tõ&@xà*ý
”¿" k!Tø*ô¹¿*q!T €Rô
”<S5qáTÖôÛ)ÿëâTìÿÿ(Б	ýßÈ ?Öà¹	€Ò÷@ùéC‘2â*áªà*ýÿ—h{zøê"›IáÀ9Éø6ô4ŸqTŸ
q!Tâ*áªà*þÿ—
â*áªà*×þÿ—â*áªà*8þÿ—àùèÑ@@ùù€Ò	¹(ÐÁ‘	ýßÈãÓ‘â*᪠?ÖÀ5(Б	ýßÈ ?Öà3¹éÑ(@ùê‘)	@¹HùI	¹á@¹è@¹h5à@¹€4qT¸áÿ—(€R¹«áÿ—¨€R¹dÿÿáÿ—bÿÿh{zøé"›*á@9Š06hÀ9iq T¨áÿ—ˆ€R¹›áÿ—¹UÿÿK€Rÿ‘Hºÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖóS½©õ[©÷c©ý{¿©ý‘ôª€Ò"€Rõ*Û”÷ªà*B€R€ÒÖ”ÿ±“ËÀ	T±€	TñMT!€Ò‚Òààÿ—ôª”µ{áÿ—ˆ€RRà*nÔÿ—@ñ	‚Rö*"¡“áªà*
ÿÿ—1€T‚Rs Ëà*ñmT@ñ᪣“ÿÿ—1áþÿTWáÿ—@¹qT]áÿ—¨€R¹Záÿ—@¹àªóáÿ—!á*LÔÿ—àªîáÿ—€RÓÿÿ¶€Ráªà*™”±@Tà*­õÿ—(Ð	‘	ýßÈ ?Ö þÿ5Aáÿ—¨€R¹)Ð(‘	ýßÈ ?Öó*/áÿ—¹7áÿ—@¹€Ráªà*€”à*ý{Á¨÷cB©õ[A©óSèÀ_ÖóS¼©õ[©÷c©ùùûùý{¾©ý‘ó*³¹õªö*
1áTáÿ—¹áÿ—(€R¹,³ø7ˆQG¹k"Th~@“ýF“‰8A
‘@’	€Ò{wø)#›*á@9ê6à*‰ôÿ—€’{wø)#›*á@9ê7áÿ—(€R¹ôàÿ—¹â*áªà*”ôªà*½ôÿ—àªèàÿ—¹ðàÿ—(€R¹«àÿ—€’ý{¨û@ùù@ù÷cB©õ[A©óSĨÀ_ÖóS¾©õùý{¾©ý‘ó*ôªõ*Cõÿ—±ÁTÚàÿ—(€R¹€’(Ð!	‘	ýßÈã*âC‘᪠?Öà5(Б	ýßÈ ?Ö§àÿ—ñÿÿà@ù±ÀýÿTi~@“ˆA
‘*ýF“)@’yjø	€Ò+!›¨€Rjá@9H
há9ý{¨õ@ùóS¨À_ÖŠÿÿÎÿÿý{¿©ý‘1¡T¬àÿ—(€R¹ø7ˆQG¹k‚T	|@“ˆA
‘*ýF“)@’yjø	€Ò)!›*á@9@˜àÿ—(€R¹Sàÿ—€Rý{Á¨À_ÖóS½©õ[©÷c©ý{¿©ý‘õªU´HÐÁ ‘€Rt€Rˆ	}H¢
€Òàª6}Ø~@“ï|ÓiwøI” 4`ø6ÔQÓk-þÿT€	ï|Óè"‘(ih¸ø7‘qÂT	}|“JHA7‘ ih¸€Rý{Á¨÷cB©õ[A©óSèÀ_ÖóS¿©ý{¿©ý‘óªóµ]àÿ—È€R¹àÿ—€h@¹€¿;Õ5
S4àªÛãÿ—ô*àª"äÿ—àª4ëÿ—'Þÿ—`ø6€`@ù`´áàÿ—ùàª>”à*ý{Á¨óSÁ¨À_ÖóS¿©ý{¾©ý‘óª³ù3µ6àÿ—È€R¹ñßÿ—€ý{¨óSÁ¨À_Öh@¹¿;Õ1Sàªh4%”öÿÿ™Äÿ—àªÃÿÿ—ô*ચÄÿ—à*ïÿÿóS¿©ý{¾©ý‘óªôª´ù @¹™óÿ—h@ù@¹	|@“*ýF“ˆA
‘)@’	€Òyjø)!›*á@9
6pôÿ—(ÐA	‘	ýßÈ ?Ö`4€R(Б	ýßÈ ?Öó*óßÿ—¹ûßÿ—(€R¹€€@¹¾óÿ—à*ý{¨óSÁ¨À_Öý{½©ý‘à¹1¡Tëßÿ—(€R¹ø7ˆQG¹k‚T	|@“ˆA
‘*ýF“)@’yjø	€Ò)!›*á@9J6èS‘à)àC‘èùãc‘⃑ás‘³ÿÿ—Ïßÿ—(€R¹Šßÿ—€ý{èÀ_Öóøý{½©ý‘ó*àC‘/Åÿ—hqÈTè@ù@ù	Ùsx €Rè£@9¨4ê@ùH©C¹	yI©¹ý{èóAøÀ_Öóøý{¾©ý‘óªàC‘±”ñTè@¹éÿŸR	k©ÿŸR)ˆS´iyý{¨óAøÀ_ÖóS»©õ[©÷c©ùk©û#ùý{¾©ý‘÷ªó@ùöªõªøª6´ôª•´y€Òš€ÒûÿŸRhÀ9h5"€ÒhÀ9h5B€Òh
À9q"ššãªáªàC‘„”±àT`´è@¹k©T¿ñIT
A@Q›RµÑ)J*깈yè€R
U3Š.xˆyˆ
‘”
‘‹µÑUûÿµôªˆËóùýA“	€ÒŸyúÿÿóù\ßÿ—H€R¹€’ý{¨û#@ùùkC©÷cB©õ[A©óSŨÀ_Ö€Òu€Ò–€ÒhÀ9h5"€ÒhÀ9h5B€Òh
À9q¢–šãªáª€ÒF”±@üÿTà´ñAT”‘‹”‘éÿÿàªÝÿÿý{¿©ý‘€µ_ù €Ò.a59ûÿÿ?`raT9øÿÿ?PrT*€Ò€R?<rT›R(KýqéTJ€Ò€R?(rATèý¿kãTj€Ò€Rì
ª(	a2‰i 8!|SŒÑlÿÿµh*9@‘_ù_ùßÿ—H€R¹€’ý{Á¨À_ÖóS¾©õùý{¿©ý‘óªô*õ*£5hÀ9Õqà·Ÿ&”@5hÀ9Õq¬TëTi‘U4(À9(À8ÁqÀÿÿTˆ5hò_8 €RqThÀ9Áq TŸ¶q €RaT	qáThÀ9Áq€TŸ¶q €R@T€Rý{Á¨õ@ùóS¨À_ÖóS¾©õ[©ý{¿©ý‘óªôªóµÁÞÿ—Ó€R¹|Þÿ—À€RDa´_q9HÀŸ	?À)ëˆT´Þÿ—S€Rôµ°Þÿ—Ó€R¹kÞÿ—à*3€R€@ùv9u‘À9h4‘€R¨8BQ_qÿÿT¿9ø7@¹ã*â*™ÿÿ—SH4©Ñ(À969(ýß8åq ÿÿT(9hÀ9Åq¡Tˆ@¹	‰¹j‘HÀ9é
ªh4(À8èÿÿ5(
Ë‘a‘àªä·ÿ—€Rý{Á¨õ[A©óS¨À_ÖóS¾©õ[©ÿCÑ@¹H4'@¹4QëQ5*@¹_qT@¹¹àªÿC‘õ[A©óS¨À_Öì5@¹J5€>Ô		Ê(¡
q¹è—Ÿ¹à	ªÿC‘õ[A©óS¨À_Ö
€Ò€ÒŸ1àTî
ªˆ}@Ó	‘
xi¸KªNµ€>Ôh	ΚŒQ­›}@Ó

‹Ÿ1þÿThý`Ó )q(€RK€Rhˆ¹à
ªÿC‘õ[A©óS¨À_ÖkˆTKŸ
kê*ëTh}@“	‘H}@“.xi¸	‘xi¸ßkÁTJQ_
kkQªþÿTBT­
4èQ
‘.xj¸èQ
‘5xj¸(€R€RÊÀZJK	S?qT‹€RK”4©&ÖÈ!Ô.*µ"ÔÿqÉTèQ
‘+xj¸h%Ö*€Ò¥Q%
ø7Ã}@Ó¦ßk¨TÈ|@Ó	‘xi¸€RÂQI‘
xi¸ÈQêù
‘
xj¸ä¹Ô4é@ùª%Öš­!Ôßq(!ÔšOªTÈQ
‘xj¸h%Ö

*ï@ùCµ€>Ôî	Úê@²È½›ß
ë	}@Ó©Tèƒ`²È‹	%›î@²è@²?ë¨T«~@Ó¯}@Ój}›í@²è	ª_ëÉTi	‹?
ëÎÑJË)ÿÿT´€Ò€R'4è}@Ó	‘*xi¸H-›í*ý`Óè‘
xl¸ï_
kH
Kk%‹šx,¸ÿk#þÿTA$ëIT
€Rç4€Ò¨ª}@Ó‘H‘	xl¸+xh¸­¿k(A+‹
‹
x,¸Oý`ÓƒþÿTÎÑì*È}@Ó‹¥QÆQeóÿ6@¹‹ê*_kTH}@Ó	‘x)¸@¹J_kCÿÿT¹ë4kQi‘
xi¸j5¹kÿÿ5àªÿC‘õ[A©óS¨À_Ö€ÒÿC‘õ[A©óS¨À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘¶ÿ—ÿƒ,Ñô*àýöªõªöשàc‘ûª
”è@¹7€R}qaTÿƒ9àc‘
”÷ƒ9ó@ù©€RÛù€R€R€Rñ(±ˆ࣑ȹË	”iútÓ)µÎ@ò`Tè+@¹¨À6Hðq*‘ß¹?ýñÁThÎ@òaT(€RÓø¶	àÒ	ëaTˆ€RhþsÓê(*Kh2×¹q T	qT
q`TqáTHðá*‘áªàªuÛÿ—‚53€RHðÁ*‘øÿÿHð¡*‘õÿÿHð*‘áªàªgÛÿ—@€5€Ròhú@’‰èùgž
ýtÓé¹)€R_)@òé9àÒàýÍ@’錚3‹(€RL€RˆˆJ)TÜ	”Àd°lþ`Óù*ù³	)Z€R	x(Kyrõ‰Ÿqõ¹)€RH€R+ˆëK¹ŸÒqcTè3‘¹X€R Rø‹¹è“¹,4
€Rì3‘í3‘©Yj¸ˆYj¸	kA
TJ_	qAÿÿTˆÊQ‰ÊQ
}S'€RK)€Ò(!ÆšQé3‘hQ(Yh¸*€Rì€Rä%*	ÀZHIK‰	K
S_qè‰Z©?ÍqTÿkè—Ÿ	
6ßÎqHT¯QÌQŸk€Tˆ
K	Qk‚Tê3‘NYh¸€R?k‚Tè3‘Yi¸€R
É

%Æ(!ÇJ*ë3‘jY,¸ŒQŸk`TëK@¹çÿÿùO@¹€Rí4é3‘?Y(¸
k¡ÿÿTùO@¹öK¹€RÿK¹˜€R÷¹ø¹ÙˆÎQ‰ÎQ
}S'€RK)€Ò(!ÆšQé3‘hQ(Yh¸*€Rì€Rä%*	ÀZHIK‰	K
S_qè‰Z©?ÍqTÿkè—Ÿ	
6ßÎqHT¯QÌQŸk€Tˆ
K	Qk‚Tê3‘NYh¸€R?k‚Tè3‘Yi¸€R
É

%Æ(!ÇJ*ë3‘jY,¸ŒQŸk`TëK@¹çÿÿùO@¹€Rí4é3‘?Y(¸
k¡ÿÿTùO@¹öK¹¶ÿÿ€RÿK¹³ÿÿŸÚq 
Tès%‘¹X€R Rø[	¹èc	¹Ì	4
€Rís%‘î3‘ÉYj¸¨Yj¸	káTJ_	qAÿÿT‰ÀZ(€RIKì€R‰	K
S_qè‰Z	?	qê'ŸVßÎq‰T€RÿK¹ÉQ?1àT(Q?k‚Tê3‘JYi¸
€Rk‚Të3‘hYh¸€RHyˆë3‘hY)¸)Q?1`TëK@¹ìÿÿùO@¹öK¹È†€RKt~S‚~~Ó€R೑״ÿ—h)€R)!Ȉ곑÷*IY4¸÷¹}~Óèë¹¢´às‘_0ñhT᳑_µÿ—6Ÿqˆ™	ÀZ*€RHIKì€R‰	K
S_qè‰Z	?qê'ŸVßÎq‰T€RÿK¹ÉQ?1àT(Q?k‚Tê3‘JYi¸
€Rk‚Të3‘hYh¸€RH}ˆë3‘hY)¸)Q?1`TëK@¹ìÿÿùO@¹öK¹¨†€R»ÿÿ‚9€Ò€R”´ÿ—ÁÛÿ—¹}Ûÿ—÷B¹øB¹HU•!ø7¨~¨›ý`ÓYS¹4IðÈ€R?›q™è¹Q)'‘3	‹€R೑t
@9u@9‚ö~Óˆèë¹y´ÿ—i@yHðA‘곑¢ö~Ó		‹@	‹	µÿ—éëC¹?qˆTèïC¹ˆ5€Rÿ¹¦q€Tw4	€R€Rìªís‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿT‰4èB¹ÍqâTês‘IY(¸èB¹÷¹ŒøB¹€Rÿ¹	€R‰ÿq¨T÷	*÷¹@Ó"}~Ó´_0ñàs‘ˆT᳑״ÿ—‚9€Ò€R;´ÿ—hÛÿ—H€R¹#Ûÿ—÷B¹øB¹3ùÿ4qà
T×
4	€R€Rís‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTÌÿÿ?kÿ»¹è'Ÿ?k병ês‘c1Šš?kës‘곑b1Šš?k$1—q剀R€R¤4fXn¸5ßkÁTéó‘È?Y.¸è»¹1€Rí*€Re4¿ÍqT¿kÁTèó‘Y-¸è	黹LXg¸áó‘+Xm¸çÿkˆ}¦›	A/‹ˆ=*A+‹	êù)X-¸ï7@¹­è»E¹ýÿT/4¿ÍqàT¿k¡Tèó‘Y-¸¨è»¹êó‘HYm¸	A/‹IY-¸/ý`Óè»E¹­/þÿ5¿Íqà
TÎßk¡øÿT÷*÷¹}~Ó´_0ñàs‘ˆTáó‘f´ÿ—‚9€Ò€Rʳÿ—÷Úÿ—H€R¹²Úÿ—÷B¹øB¹)€Ré4è@¹IÐ9Kùæÿ5õ@¹HS	uS*
Z«
KË4HÐá)‘iQ
Yi¸
4_qàT×4	€R€Rì
ªís‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿT)4èB¹Íq¢Tês‘IY(¸èB¹è¹Ö"4	€R€Rì3‘M€ÒˆYk¸}
›
A)‹ŠY+¸kkIý`Ó!ÿÿT)!4èK@¹ÍqâTê3‘IY(¸èK@¹èK¹ÿ¹èÿÿúKH¨›ý`ÓSw4IÐÈ€Rÿšq—è¹Q)'‘3	‹€R೑t
@9u@9‚ö~Óˆèë¹m³ÿ—i@yHÐA‘곑¢ö~Ó		‹@	‹ý³ÿ—éëC¹?qˆTèïC¹ˆ5€RÿK¹¥q`TV4	€R€Rìªí3‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTi4èK@¹ÍqâTê3‘IY(¸èK@¹öK¹‹ùO@¹€RÿK¹€RˆßqˆTö	*öK¹3@Ó"}~Óâ´_0ñà3‘ˆT᳑˳ÿ—‚9€Ò€R/³ÿ—\Úÿ—H€R¹Úÿ—ögI)Sùÿ4qà
TÖ
4	€R€Rí3‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTÍÿÿ?kÿ»¹è'Ÿ?k병ê3‘c1Šš?kë3‘곑b1Šš?k$1–qʼn€R€RÄ4fXn¸5ßkáTèó‘ÖY.¸ö»¹2€Rí*€R…4¿ÍqT¿kÁTèó‘Y-¸è	黹LXg¸áó‘+Xm¸çÿkÈ|¬›	A+‹È,*A/‹	êù)X-¸ï7@¹­ö»E¹ýÿTO4¿Íq@
T¿k¡Tèó‘Y-¸¨è»¹ëó‘iYm¸è}@Ó
A)‹jY-¸Oý`Óö»E¹­þÿ5¿Íq TÎßkøÿTöK¹Â~~Ó´_0ñà3‘ˆTáó‘[³ÿ—‚9€Ò€R¿²ÿ—ìÙÿ—H€R¹§Ùÿ—öK@¹ùO@¹(€RH4è@¹IÐ÷Kçÿ5S	uS*
XK
K‹âÿ4HÐá)‘iQ
Yi¸Š4_q áÿT–áÿ4	€R€Rì
ªí3‘¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿTI4èK@¹Íq"Tê3‘IY(¸èK@¹öK¹öþÿöK@¹ôþÿÿK¹€Òÿë¹â³‘ÿK¹9€Òà3‘£”ác‘à#‘<ûÿ—ô@¹(q¡T)€RìB¹i9”s‘Ì4	€R€Rís‘N€Ò¨Yk¸}›
A)‹ªY+¸kkIý`Ó!ÿÿT)4èB¹ÍqâTês‘IY(¸èB¹è¹€Òÿë¹â³‘ÿ¹9€Òàs‘z”€5”QóªÀh9s‘è@ùê@¹¹´ø7°_k’Ÿ

è#@ù	Ñ?A*ëH}@Ó)1ˆš4‹ë5‹ TîK@¹¶N4	€R€Rì3‘Í
XˆYk¸}
›
A)‹ŠY+¸kkIý`Ó!ÿÿT)4èK@¹ÍqâTê3‘IY(¸èK@¹èK¹€Òÿë¹â³‘ÿK¹9€Òà3‘A”ác‘à#‘Úúÿ—îK@¹
€Rë*KßqçŸç9h}¶›ÿ
ký`ÓŠ}SHuS	
Lk	KjÁH‹}S‚TÁqçŸhJ-8­Q¿1áýÿT¨Ëç9%ñ)€Ò(Áˆš‹ëá÷ÿTè@99qóŸèƒ@9h4àc‘É”à*ÿƒ,‘̱ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Ö€Ò€R€Ò€Ò€ÒU¹ÿ—Êš;ÍÌÌÌóS¾©õùý{¿©ý‘ôªõªóªsµ€R@µÙÿ—Ó€R¹ÀØÿ—À€Rý{Á¨õ@ùóS¨À_Ö¿ñ€Sú£Tâªáªa²ÿ—îÿÿ⪀Rűÿ—•µñØÿ—Ó€RŸë‚ýÿTìØÿ—S€R¹§Øÿ—à*çÿÿý{¿©ý‘T”Q”ý{Á¨À_ÖóS¾©õùý{¾©ý‘óªàC9àªÁãÿ—h@¹¿;Õr Th.@©€RKh‘hùi"@¹Ÿq*Qj¹MTa@ùâ* öÿ—õ*i@ù¿kèCÀ9(9"qIT	|@“hÐA
‘*ýF“)@’yjø	€Ò+!›h°	‘há@9ˆý/6B€R€Òû÷ÿ—±áüÿTjR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ €R"€RáC‘úõÿ—qàŸý{¨õ@ùóS¨À_Öóøý{¾©ý‘@¹¿;Õ
Sh4 €R"@¹¿;Õr€T$@©	ë@T@¹¿;Õîìÿ—󪱀T(!	‘	ýßÈ€Ò#€RâC‘ ?Ö€4(a	‘	ýßÈác‘ઠ?Ö 4é#A©?ëàŸ€Rý{¨óAøÀ_ÖóS¿©ý{¿©ý‘óªô*àªNãÿ—h@¹¿;ÕrTaØÿ—(€R¹jR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ€Gh@¹¿;Õ1SH4RØÿ—H€R¹jR‘Iý_ˆ)2Iýˆ¨ÿÿ5ñÿÿh@¹¿;ÕÈ6ફÿÿ—¹jR‘Sh4h@ùhùIý_ˆ)yIýˆ¨ÿÿ5¿;ÕjR‘Iý_ˆ)2Iýˆ¨ÿÿ5¿;ÕjR‘Iý_ˆ)yIýˆ¨ÿÿ5¿;Õ¹h@¹¿;Õ	˜€R	jáTàª0ãÿ—Sh5àª6”᪀?ÿÿ—Sˆ5jR‘Iý_ˆ)2Iýˆ¨ÿÿ5¾ÿÿIý_ˆ)2Iýˆ¨ÿÿ5¹ÿÿ€ý{Á¨óSÁ¨À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘§°ÿ—ÿÃÑúªöªùªúµÁ´þ×ÿ—È€R¹¹×ÿ—ÿÑ£°ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_Övþÿ´Yþÿ´?ñƒþÿT(Ñÿùûc‘i›õ#‘õï©€Ò7Ë		Öš*‘_!ñHTëéTÓ‹ëôªˆTè>Aùïª?Öáªàª ?Öqt”šÓ‹ëÉþÿTëªêªŸëTŒËHÀ9kщiê8ˆi*8I8kÿÿµËëˆüÿTë@ù°HýAÓ}›è>Aùïªt‹?Öáªàª ?ÖqTìªëª_ëTjËhÀ8IÀ9ŒÑH9iñ8Lÿÿµè>Aùïª?Öáªàª ?ÖqTëªêª_ëTLËHÀ9kщiê8ˆi*8I8kÿÿµè>Aùïª?Öáªàª ?ÖqTëªêªŸëTŒËHÀ9kщiê8ˆi*8I8kÿÿµóªõªŸë©TÓ‹ëBTè>Aùïª?Öáªàª ?ÖqÍþÿTÓ‹ë(Tè>Aùïª?Öáªàª ?ÖqÍþÿT;÷ªµË¿ë)Th?Aùïª?Öáªàª ?Öq¬þÿT¿ëTëªêªëTlËHÀ9kщiê8ˆi*8I8kÿÿµŸë”“šðÊÿÿû@ùŸë¢T÷ËÿëITð=Aùïª?Öáªàª ?ÖÀþÿ4
ð÷Ëÿë	Th?Aùïª?Öáªàª ?Öàþÿ4û@ù	ËëW@©èË	ëËT_ëâTwùk‘{#‘º†øõï©ëùëðTúª9ÿÿëâTxùk‘{#‘³†øõï©ëù_ëbTøª,ÿÿðkѵ"ÑëW©{#Ñûù+âÿ·º@ùx@ù#ÿÿý{¿©ý‘¦¯ÿ—ÿƒÑ€Rê‘	}@“?ñBT?i*8qKÿÿT)@9i4ì‘-€R+ýCÓ(	iil8ª!ÈH	*)@8hi,8)ÿÿ5	@9i4+€Rì‘(	)ýCÓj!È(il8_jT	@8)ÿÿ5€Òÿƒ‘‰¯ÿ—ý{Á¨À_Ö¸·ÿ—ý{º©óS©õ[©÷c©ùk©û+ùý‘u¯ÿ—ÿCÑúC‘ó*Eùqôªûªù*õªö*÷*íTa~@“ઔk “w5ˆ@ù
@¹Hs@¹*€R)€R€R€ÒqA‰ã*âªà*½çÿ—ø*x5€Rƒ“	A‘?ë Ÿš‰™™R ´ñˆT<‘ëLTèß|²ýDÓ»±ÿ—ÿs/ËôC‘t´‰¹?Ûÿ—ôªÔ´¨»›Rˆ¹”B‘€ÒÔ´å*äªã*âª!€Rà*–çÿ—À
4€Òÿù€Ò€R€Òã*âªá*àªÉØÿ—õ*U	49P66	4¿kÌTD@ù€Òÿù€Òå*ã*âªá*હØÿ—õ*u59¨~“	A‘?ë Ÿš ´ñˆT<‘ëLTèß|²ýDÓ{±ÿ—ÿs/ËóC‘s´ˆ™™RÿÚÿ—óªÓ´¨»›Rh¹sB‘€ÒÓ´€Òÿù€Òå*äªã*âªá*ઑØÿ— 4€Ò€Òã*⪀Rà*ö5€R€Òjçÿ—õ*µ5h_¸©»›R	kaT`BÑÒÖÿ—€Rô´ˆ_¸©»›R	kaT€BÑÊÖÿ—à*_CÑÿC‘Ô®ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖD@ùå*âÿÿh_¸©»›R	kýÿT`BѶÖÿ—åÿÿóS¼©õ[©÷c©ùùý{½©ý‘ÿCÑùªáªàƒ‘ø*÷ªö*õªô*ó*t»ÿ—èƒ@¹ç*æ*åªä*è¹ãªâ*áªà£‘#ÿÿ—èã@9¨4ê@ùH©C¹	yI©¹ÿC‘ý{èù@ù÷cB©õ[A©óSĨÀ_Öý{¿©ý‘.æÿ—SqàŸý{Á¨À_Öh°]A¹H5‹€ÒóS¾©õùý{½©ý‘ôªõªáªàC‘óªC»ÿ—sµ€R#´´•´è{@²ëÉTÎÕÿ—È€R¹‰Õÿ—è@ù™@ùáµãc‘âªáªàª€”@¹ä*æ*åªãª"‚Ràc‘á”À5·Õÿ—È€R¹°Qè£@9¨4ê@ùH©C¹	yI©¹ý{èõ@ùóS¨À_ÖóS¾©õ[©ý{µ©ý‘óªÿ©öªÿ	©€ÒÿSùàC‘ÿ£9ÿ©€Òÿ©€Rÿ;ùÿã9»ÿ—è@ù)½ŸR
@¹	k!Tè£@9¨4ê@ùH©C¹	yI©¹"½ŸRàÖÿ—è£@95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€Rá‘ચÌÿ— 5€ÒàÑܺÿ—è@ù)½ŸR
@¹	k!Tè#A9¨4ê@ùH©C¹	yI©¹"½ŸR¼Öÿ—è#A95¨4ê@ùH©C¹	yI©¹"€R¨4ê@ùH©C¹	yI©¹€RáC‘àªvÌÿ—`5ðA‘á3@ùàK@ù	ýßÈ ?ÖõãA9ô3@ùó*õãA9ô3@ù€Ru4àªÛÕÿ—è£B9h4àK@ù×Õÿ—à*ý{˨õ[A©óS¨À_Öíªbµ€Rª%@x+$@xHQeqIhQL‰ieqh‰€K€5l4BÑBþÿµÀ_Öý{¿©ý‘àµÕÿ—È€R¹ØÔÿ—€’	âªh°ñDù	ð(	‘	ýßÈ€R ?Öý{Á¨À_ÖóS¾©õ[©ý{¿©ý‘ôªóª”µàª¨Ùÿ—$“µàªœÕÿ—‚±HTð¡	‘v°ÀòDù	ýßÈãªâª€R ?Ö€µð¡	‘rÈÿ—€4ઇìÿ— 4ÀòDù㪨þßÈ⪀R?Ö þÿ´ãÔÿ—ˆ€R¹€Òý{Á¨õ[A©óS¨À_ÖóS¾©õ[©ý{¿©ý‘õªóªôª`€R–çÿ—õµÐÔÿ—È€R¹‹Ôÿ—Ó€R!¿ùS´ùôþÿ´àª)”ôª´éª(À9h4)‘ýÿÿ(Ë‘!€Òàª_·ÿ— ùÀµ¶Ôÿ—ˆ€R¹“€RâªáªùÒÿ—`5S´vù€R`€R“çÿ—à*ý{Á¨õ[A©óS¨À_Ö€Ò€R€Ò€Ò€ÒÞ´ÿ—óS¾©õùý{¿©ý‘ôªåÅÿ—óª´ô´ˆÀ9éªh4(À8èÿÿ55Ëi@ùé´(À9ê	ªh4HÀ8èÿÿ5H	Ëë)T`@ùhõ8õq¡Tâªáª—þÿ—`4iŽ@øîÿÿh@ù	‹ ‘€Òý{Á¨õ@ùóS¨À_Ö€R€Ò#€R“ÿÿíªbµ€Rª@8+@8HQeqIhQL‰ieqh‰€K€5l4BÑBþÿµÀ_Öý{¿©ý‘h°]A¹È5àµRÔÿ—È€R¹
Ôÿ—°	Aÿÿ´è{@²_ëèþÿTÜÿÿ—€Ò”ý{Á¨À_ÖóS¾©õùý{½©ý‘õªôªóªõµ:Ôÿ—È€R¹õÓÿ—°Tÿÿ´è{@²ëèþÿTsµ€RáªàC‘—¹ÿ—è@ù
‰@ù¨@8	ij8ˆ@8ij8 K€5i4sÑÿÿµè£@9¨4ê@ùH©C¹	yI©¹ý{èõ@ùóS¨À_Öý{¾©ý‘à#y_”4âS‘!€RàC‘~”`4à#@yàÿŸRý{¨À_Ö€|©¹P‘¹ÀøùýŸˆ¿;ÕÀ_Öý{¿©ý‘š¬ÿ—ÿCÑh°a(‘ñjˆšð	/‘?ñ.ˆš?ñ(€ÒGˆš?ñŸšgµ €’[H
@yè5Ë@9ΑË87O´ë¹qàŸšQh	qaTL€R
h
qaTl€RhÁqáTŒ€Rè€R)€RK(!È	Q+
í*L@9
SK@¹ˆù	S?	q ™AzÃT¿k‚T¿ëé šÇËÆÀ8ç‘ÈqaTÈ*ÿ	ëÿÿT?
ëâT¨)KK¹L	y	SI
yÀÿÿ›RhKýqiTADq"T€Rè¹	R( Ré£)ˆ	Ñé‘(yh¸kãTO´ë¹q_ùàš_ùÓÿ—H€R¹€’ÿC‘5¬ÿ—ý{Á¨À_Öóøý{¿©ý‘óªà*Ax
é	j€T³´€R€Ri”`¹yÓÿ—È€R¹4Óÿ—À€R“´`”`¹]”€Rý{Á¨óAøÀ_Öàüðüóøý{¿©ý‘óªÔ”`¹”`¹€Rý{Á¨óAøÀ_Öóøý{¾©ý‘óª`@¹”`@¹I”àC‘ÿùêÿÿ—@5é@¹h@¹	kÁTé@¹€Rh@¹	k@T €Rý{¨óAøÀ_Öóøý{¾©ý‘óªÿùàC‘Ôÿÿ—€5è@ùàC‘é@¹hù(2è¹Øÿÿ—€5”€R €Rý{¨óAøÀ_Öfž	þïÒÈ)L’	ëTßÍ@ò`TàªÄî
ø¶%€R€R#€RÿÿÒHa;‘ä/&€Ra€Rkßù@òÁTE€R„€RC€RþÿÒôÿÿîýÿ·ÈXÈ‹ÉX	ëÈTn`t\8pp\\¾\’+qˆfž	}`’“r;gž‘;{y*sz
|Ó
\8yOT´
\¶RXy×BXøêu+qR}yK]Yg^`g^;àÒßë"TzàÒ	\Ȫgž€R1:p.fž€RÈÍnÓ2\2lȵmÓ}\l~\“bÉ€Òèª(-L³gžÉùtÓ+KiýQˆ}@Ó8b
ÑH+‘u
rymüHA3‘:uP\“VQU\q\™st\KT7yöBUymüÓFWö\t
w—fY÷*u_VX}yc]Rg^`K^À_Ö ÕVðÀ‚øðÿ]È4€xËÛ?ŸQñ#Ib?Ôƺ™™™‰?Ѐ?Þ^†™™™‰?AGÙ;BIb?WUUUUUµ?àB.æ?À_ÖD;Õ
à“R
Jè}Sè
r TPq T`q Tpq	`€Rî‰ €R@€R€Rÿr	€Rêé‰_q€Rëèˆq†€R**ì膟qK€RI*íè‹¿q**éŸè}
SK	*	j	*K*`*À_Ö(D;Õî*ßr	€RÊé‰_qˆ€RËèˆqO€R**Íè¿qJ*éŸÈ}SK	*	j	*Ì@*À_Ör Tq Tq Tq	 Ò剚 Ò Ò€Ò
D;Õ	}@Ó(X+ŠSjªŸq  Ò舚Iª¿qÒè‹šßq€€Ò*ªè‹šÿq@€ÒIªè‹šÿq €Ò*ªè‹šÒßqIªè‹š)ª*ªà“ÒHÊDÕÀ_Öÿ`?ü
r(D;ÕXŠ
S	€ÒKªè‰š¿qjªéŸšßqH€Ò舚K	ªÿqŠ€ÒiªèŠšÿq€Ò*ªè‹šIª)DÕÀ_Ö`ÿÿÿóøý{¿©ý‘jH@¹óª!€Ò	‚ÒI¹DÑÿ—`ù€Ò{Òÿ—h@ùjR‘´Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õ‚R	Iý_ˆ)2Iýˆ¨ÿÿ5¿;Õhr‘hùH€Rh"¹h@ù¹hùý{Á¨óAøÀ_Öéª(À9€ÒÈ4ë€T‘hé8ˆÿÿ5À_Öý{º©óS©õ[©÷c©ùk©û+ùý‘Uªÿ—ÿÃÑúC‘ó*Aùqôªû*öªùªõ*÷*ÍTa~@“àªàÿÿ—ó*1‹T¿qÍT¡~@“àª×ÿÿ—õ*¿1kTw5ˆ@ù
@¹S4•5k@T¿qÌTq,TС‘	ýßÈA#‘à* ?Ö 4qMTH@¹	q£TH;@9J;‘H4K@94É@9H@9?k*!Kz	TH-@8ÿÿ5`€R¿qMTH@¹	q£TH;@9J;‘H4K@94)@9H@9?k*!Kz©TH-@8ÿÿ5 €R|€R€Òã*âª!€Rà*bâÿ—ø*X4“	A‘?ë Ÿš‰™™R ´ñˆT<‘ëLTèß|²ýDÓb¬ÿ—ÿs/ËôC‘t´‰¹æÕÿ—ôªÔ´¨»›Rˆ¹”B‘€ÒT	´å*äªã*âª!€Rà*=âÿ—@4€R€Òã*âª!€Rà*5âÿ—ö*64È~“	A‘?ë Ÿš ´ñˆT<‘ëLTèß|²ýDÓ6¬ÿ—ÿs/ËóC‘s´ˆ™™RºÕÿ—óªÓ´¨»›Rh¹sB‘€Ò³´å*äªã*âª!€Rà*âÿ— 4@@ù€Òÿù€Òå*äªã*âªá*lÒÿ—õ*€R3´h_¸©»›R	k¡T`BÑŽÑÿ—€Rô´ˆ_¸©»›R	kaT€BÑ…Ñÿ—à*@€R€R_CÑÿÑ‹©ÿ—û+@ùùkD©÷cC©õ[B©óSA©ý{ƨÀ_ÖóS¼©õ[©÷c©ùùý{½©ý‘ùªáªàC‘ø*÷ªö*õªô*ó*5¶ÿ—ç*æ*åªä*ãªâ*áªàc‘ÿÿ—è£@9¨4ê@ùH©C¹	yI©¹ý{èù@ù÷cB©õ[A©óSĨÀ_Öóøý{¿©ý‘Sð`öDù±ÁTH;‘	Ð(‘	ýßÈ€Ò€Rd€R€Òb€R¨R ?Ö`öù±àŸý{Á¨óAøÀ_ÖHðõDù±¨TÐÁ‘	ýßÈ ÖÀ_ÖóS½©õ[©÷ùý{¿©ý‘ÐÁ‘ôªWðàöDù	ýßÈõ*öª€Òãªâ*᪠?Öó*“5Б	ýßÈ ?ÖqÁTàöDù±¨TÐÁ‘	ýßÈ ?ÖH;‘	Ð(‘	ýßÈ€Ò€Rd€R€Òb€R¨R ?ÖÐÁ‘€Òàöù	ýßÈãªâ*᪠?Öó*à*ý{Á¨÷@ùõ[A©óSèÀ_Ö|S
H2rKˆh2rjˆH2rKˆh2rjˆH
2rKˆ
r€TPq T`q TpqÁTk2k2k2rh2`ˆÀ_Öì*è€RŸj€RTŠSH2ŸrKˆh2ŸrjˆH2ŸrKˆh2Ÿr`ˆL86
2À_Ö(D;Õ}@Ó耒Š(DÕåÿÿý{¿©ý‘,
í*D;Õ
à“R
Jà*¹ÿÿ—é,**
¨
N*ßk TÈ
mSH2ßrKˆh2ßrjˆH2ßrKˆh2ßrjˆH2ß
rKˆÈr€Tq Tq TqÁTk
2k
2k	2h2ßré€Rjˆè	
@*à“ÒÊDÕ‹ÿÿ—ý{Á¨À_ÖóS¾©õùý{¿©ý‘õ*³ôªÕ6´@6 €Ò¤”szÕ6´H6@€Òž”sz
Õ6´P6€€Ò˜”szÕ6´X6u 6€Ò‘”szµ 6”`6€ÒŒ”szqàŸý{Á¨õ@ùóS¨À_Öý{»©óS©õ[©÷c©ù#ùè'ýý‘G¨ÿ—ÿÃÑyXàý(@`øª÷*áªà“Òóªô*ö*õ*b”pgžàùáªà*ðý¼ÿÿ—à5¿
qÁTèƒ@¹i€Rè;ý(3胹å#‘äC‘ã*â*á‘à‘)”À¾ÿ—S(44ñÃ@máªð£mà@ùô¹øùñýA”àc‘Á¾ÿ—`5à*&”à@ýà*"”à@ùáª5”à@ýÿѨÿ—è'@ýù#@ù÷cC©õ[B©óSA©ý{ŨÀ_ÖŸÀM²gžÀ_Ö€RóS½©õ[©÷c©ý{¾©ý‘àùóª¹è@ùø*÷ªõªö*	¹é@ùô?
¹Â 6ê@ù”H@¹	2I¹Â6ê@ùôH@¹	2I¹Â6ê@ùTH@¹	2I¹Â6ê@ù´H@¹	2I¹Â6ê@ùH@¹	2I¹h@ùí@ù	ýHÓ¨	@¹ë)*iJê*,ˆ
J¨	¹h@ùî@ù	ýIÓÈ	@¹ë)*iJê*,ˆ
JÈ	¹h@ùí@ù	ýJÓ¨	@¹ë)*iJê*,ˆ
J¨	¹h@ùî@ù	ýKÓÈ	@¹ë)*iJê*,ˆ
JÈ	¹h@ùí@ù	ýLÓ¨	@¹ë)*h3¨	¹Ø” 6ê@ùH
@¹	2I
¹ 6ê@ùH
@¹	2I
¹ 6ê@ùH
@¹	2I
¹ 6ê@ùH
@¹	2I
¹  6ê@ùH
@¹	2I
¹h@ù

r`T_Pq`T_`qàT_pq!Tê@ùH@¹	2*€RJ€Ré@ù(@¹H3(¹ê@ùH@¹	uI¹ì@ùˆ@¹	Jê*+-h
Jˆ¹ê@ùH!@¹	2I!¹ë@ùh!@¹V4	mi!¹ê@ùð@½P½ë@ùha@¹	2ia¹ê@ùHa@¹	mIa¹ê@ù±@½QQ½)€R(
3h!¹é@ùð@ý0	ýê@ùHa@¹	2Ia¹ë@ù)€Rha@¹(
3ha¹é@ù±@ý1)ýZ”°A‘	ýßÈãC‘"€R€Rà* ?Öê@ùH	@¹¨ 6h@ù	ùw’iùH	@¹¨6h@ù	ùv’iùH	@¹¨6h@ù	ùu’iùH	@¹¨6h@ù	ùt’iùH	@¹ˆ6h@ù	ùs’iùH@¹	r T?q T?	qÀT?
qÁTh@ù	j²
)€Òh@ù(j³hùI€Òûÿÿh@ù	õh’iù–4PQ@½°½Q)@ý±ýý{¨÷cB©õ[A©óSèÀ_Ö
ÀÀ“À‘ÀŽÀÀý{¿©ý‘qàTQqèTEÎÿ—H€RBÎÿ—(€R¹ý{Á¨À_Ö(D;Õ}@Ó
€Ò*DÕÀ_ÖD;Õ
à“R
Jé!*-Š)|@Ó|@Ó	Š«ª	à“Òi	Ê	DÕàªÀ_Ö(D;Õ
}@“Kª+DÕÀ_Ö(D;Õ}@ÓÀ_Ö<@¹€R
À(‹I)@yL
@y(
‹a‘Ì4
 ‘I@¹?@)ë£TH@¹		?@)ëãTkk ‘J¡‘£þÿT€ÒÀ_ÖóS¿©ý{¿©ý‘óªTÿÿ°€‘”`5€R
ˆ‘aË€‘Ûÿÿ—`µ€R$@¹éh* €Rý{Á¨óSÁ¨À_Ö@y©I‹R	kaT<@¹ªˆR
À(‹I@¹?k¡TH1@y €R-q@T€RÀ_Ö€Ò!5À9ˆ4
ì|’j7pÀ=S€’ˆ%Èšš N2
 NI>N*ê`TIÀÚH>N	ÀÚ)I87(}@Ó`
H‹wð}’@ýH	S
€’¨%Èšš 1
 )>N*ê THÀÚ	}@Ó€
I‹ilA‘Á<š N0:°n>Nˆÿÿ´1
 N(>Nˆ´ÀÚ
}S(>N	ÀÚ+j}SˆA*‹AÑV4Nì|’ðÀ=	
€’š NŽ4n1
 Nr
 N,>NO>N	7S)>NJ%ÈšH>N-
Š
Š(!Q	qSJ%ÉšOŠLŠ€Ò
€Ò†€RíµkµLµÏ´ˆÀÚ
ªÀÚk´iÀÚèÀÚ	_	kcTl>Nk>NJ86k´iÀÚˆÀÚ	È	KîH‹ðÁ<Ž4nš Nq
 NR
 N+>N/>NM>NL>NÞÿÿ)€Ò
´(!Êš	Ñ*ŠKÀÚ‰€R)KHQ(!Èš	Ñ*ê`TIÀÚˆÀÚ	É	K(}@ÓàH‹àªÀ_ÖÀ95è4
ì|’j7pÀ=S€’ˆ%Èšš N2
 NI>N*ê`TIÀÚH>N	ÀÚ)I87(}@Ó`
H‹rð}’@ýH	S
€’¨%Èšš 1
 )>N*ê THÀÚ	}@Ó€
I‹dlA‘Á<š N0:°n>Nˆÿÿ´1
 N(>Nˆ´ÀÚ
}S(>N	ÀÚ+j}SˆA*‹AÑQh5€ÒN	ì|’
€’é73NpÀ=SJ%Èšš NR
 NŽ3nH>N1
 N)>N.>N

ê,
Š`TªÀÚH>N	ÀÚ*l´‰ÀÚÈÀÚ	_	k+üÿT-T(}@“`
ˆ‹,
ð}’±@ý(	SI%Èš0š 
 >N0	Š1Ž0.1
 (>N
	Š_ëÃùÿT©THÀÚ
}@“ 
Š‹3NkA‘pÁ<š NŽ3n±NQ:°n(>NHÿÿ´R
 NH>Nh´	ÀÚH>N	ÀÚ)(}@Ói
H‹+AÑjÀ9_!k`ŸšÀ_Öý{¿©ýªáª(@ù@¹g»ÿ— Õý{Á¨À_ÖaÔý{¿©ýª@ù	@¹Ê?
kàŸý{Á¨À_ÖaÔÀóøý{¿©ýª ù±ƒ‘ þŸÈ¨C@9È4±ƒ‘(þßÈ	@ù±c‘)þŸÈ±c‘*þßÈéH@¹	kaT±c‘(þßÈ	@¹?qÁT±c‘(þßÈ©!@¹	k T±c‘(þßÈ	!@¹	kàT±c‘(þßÈi!@¹	kTy®ÿ—±c‘(þßÈù±ƒ‘)þßÈ3@ùr®ÿ—ù°Áÿ— Õ±S‘?þŸˆ±S‘ þ߈ý{Á¨óAøÀ_ÖaÔ Õcsmà “!“"“ý{¿©ýª¨@ù@ùß°ÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹Hßÿ— Õý{Á¨À_ÖaÔý{¿©ýª@ù@¹‰¾ÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹6ßÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@¹(4¨@¹ @¹ˆ4	|@“*ýF“HðA
‘)@’	€Òyjø*!›Iá@9(Há9ýßÿ— Õý{Á¨À_ÖaÔý{¿©ýª @¹õßÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹ìßÿ— Õý{Á¨À_ÖaÔý{¿©ýª€Rßÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨@ù@¹ýÞÿ— Õý{Á¨À_ÖaÔý{¿©ýªà€RõÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª €RíÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª€€RåÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª€RÝÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª¨C@9ˆ4`€RÓÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª @ùY°ÿ— Õý{Á¨À_ÖaÔý{¿©ýª`€RÃÞÿ— Õý{Á¨À_ÖaÔý{¿©ýª@ù	@¹ª€R
¸r?
kàŸý{Á¨À_ÖaÔ0F\n„œ¸Òèþ.L^Ì€Žž®ºÈÖàø.FXj|Œ˜®ÂÐäò(:HVbt„œÄÐÞìö*6JZlv‚Ž¤ºÔî*<TjzŽ¢²¾ð-@Ð'@'@¸'@=@ÀU@ ÿ@Àz@k@È>@failed to create process.
failed to get exit code from process.
%s %s-script.pywCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %sp@@@4@ðŠ@‹@‹@‹@	(‹@
8‹@
H‹@X‹@	d‹@p‹@	€‹@	‹@˜‹@
¨‹@¸‹@	‹@Ä‹@Ћ@Ø‹@Ü‹@à‹@ä‹@è‹@ì‹@ð‹@ø‹@Œ@Œ@Œ@Œ@Œ@Œ@Œ@ Œ@$Œ@(Œ@,Œ@0Œ@4Œ@8Œ@<Œ@@Œ@DŒ@HŒ@LŒ@PŒ@TŒ@XŒ@\Œ@`Œ@dŒ@hŒ@lŒ@pŒ@tŒ@xŒ@|Œ@€Œ@	Œ@	 Œ@¨Œ@¸Œ@ÐŒ@àŒ@øŒ@@8@X@x@˜@#À@à@ Ž@(Ž@&PŽ@pŽ@€Ž@„Ž@Ž@ Ž@#ÄŽ@ÐŽ@	àŽ@ðŽ@@0@%X@$€@%¨@+Ø@ø@  @"H@(x@*¨@È@Ø@ð@‹@‘@‘@8‘@P‘@p‘@‹@Œ@Œ@PŒ@HŒ@(Œ@ÐŒ@‘@__based(__cdecl__pascal__stdcall__thiscall__fastcall__vectorcall__clrcall__eabi__swift_1__swift_2__ptr64__restrict__unalignedrestrict( new delete=>><<!==!=[]operator->*++---+&->*/%<<=>>=,()~^|&&||*=+=-=/=%=>>=<<=&=|=^=`vftable'`vbtable'`vcall'`typeof'`local static guard'`string'`vbase destructor'`vector deleting destructor'`default constructor closure'`scalar deleting destructor'`vector constructor iterator'`vector destructor iterator'`vector vbase constructor iterator'`virtual displacement map'`eh vector constructor iterator'`eh vector destructor iterator'`eh vector vbase constructor iterator'`copy constructor closure'`udt returning'`EH`RTTI`local vftable'`local vftable constructor closure' new[] delete[]`omni callsig'`placement delete closure'`placement delete[] closure'`managed vector constructor iterator'`managed vector destructor iterator'`eh vector copy constructor iterator'`eh vector vbase copy constructor iterator'`dynamic initializer for '`dynamic atexit destructor for '`vector copy constructor iterator'`vector vbase copy constructor iterator'`managed vector copy constructor iterator'`local static thread guard'operator "" operator co_awaitoperator<=> Type Descriptor' Base Class Descriptor at ( Base Class Array' Class Hierarchy Descriptor' Complete Object Locator'`anonymous namespace'(null)(null)ÀÀ–ÀÀŽÀÀÀ‘À’À“À´ÀµÀ	mscoree.dllCorExitProcessP€@°€@¸@H¸@È-@È-@ø@°ø@p
@ 
@@¨Ê@øÊ@x¿@À¿@(=@È-@€î@È-@€@ @È-@˜€@h€@È-@.\.com.exe.bat.cmd
		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×Y*š@@š@€š@Àš@›@p›@À›@œ@@œ@€œ@Àœ@@P@°@ž@Pž@hž@€ž@ž@Øž@api-ms-win-core-datetime-l1-1-1api-ms-win-core-fibers-l1-1-1api-ms-win-core-file-l1-2-2api-ms-win-core-localization-l1-2-1api-ms-win-core-localization-obsolete-l1-2-0api-ms-win-core-processthreads-l1-1-2api-ms-win-core-string-l1-1-0api-ms-win-core-synch-l1-2-0api-ms-win-core-sysinfo-l1-2-1api-ms-win-core-winrt-l1-1-0api-ms-win-core-xstate-l2-1-0api-ms-win-rtcore-ntuser-window-l1-1-0api-ms-win-security-systemfunctions-l1-1-0ext-ms-win-ntuser-dialogbox-l1-1-0ext-ms-win-ntuser-windowstation-l1-1-0advapi32kernel32ntdllapi-ms-win-appmodel-runtime-l1-1-2user32api-ms-ext-ms-AreFileApisANSICompareStringExFlsAllocFlsFreeFlsGetValueFlsSetValueInitializeCriticalSectionExLCMapStringExLocaleNameToLCIDAppPolicyGetProcessTerminationMethod  @  @¤ @¤ @¨ @¨ @¬ @¬ @° @¨ @À @¬ @Р@¨ @à @¬ @INFinfNANnanNAN(SNAN)nan(snan)NAN(IND)nan(ind)e+000À£@Ä£@È£@Ì£@У@Ô£@Ø£@Ü£@ä£@ð£@ø£@¤@¤@ ¤@,¤@0¤@4¤@8¤@<¤@@¤@D¤@H¤@L¤@P¤@T¤@X¤@`¤@h¤@t¤@|¤@<¤@„¤@Œ¤@”¤@ ¤@°¤@¸¤@Ȥ@Ô¤@ؤ@à¤@ð¤@¥@¥@ ¥@(¥@0¥@8¥@@¥@H¥@P¥@`¥@p¥@€¥@˜¥@°¥@À¥@Ø¥@à¥@è¥@ð¥@ø¥@¦@¦@¦@¦@ ¦@(¦@0¦@8¦@H¦@`¦@p¦@ø¥@€¦@¦@ ¦@°¦@Ȧ@ئ@ð¦@§@§@§@0§@X§@p§@SunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssSunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssen-USja-JPzh-CNko-KRzh-TW         (((((                  H„„„„„„„„„„‚‚‚‚‚‚ €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿuk=¼@¼@ ¼@(¼@8¼@@¼@H¼@P¼@	X¼@
`¼@h¼@p¼@
x¼@€¼@ˆ¼@¼@˜¼@ ¼@¨¼@°¼@¸¼@À¼@ȼ@м@ؼ@à¼@è¼@ð¼@ø¼@½@ ½@!½@"À­@#½@$ ½@%(½@&0½@'8½@)@½@*H½@+P½@,X½@-`½@/h½@6p½@7x½@8€½@9ˆ½@>½@?˜½@@ ½@A¨½@C°½@D¸½@FÀ½@GȽ@Iн@Jؽ@Kà½@Nè½@Oð½@Pø½@V¾@W¾@Z¾@e¾@ ¾@(¾@8¾@H¾@°§@X¾@h¾@x¾@ˆ¾@	p§@˜¾@¨¾@
¸¾@Ⱦ@ؾ@è¾@€§@ §@ø¾@¿@¿@(¿@8¿@H¿@X¿@h¿@x¿@ˆ¿@˜¿@¨¿@ ¸¿@!È¿@"Ø¿@#è¿@$ø¿@%À@&À@'(À@)8À@*HÀ@+XÀ@,hÀ@-€À@/À@2 À@4°À@5ÀÀ@6ÐÀ@7àÀ@8ðÀ@9Á@:Á@; Á@>0Á@?@Á@@PÁ@A`Á@CpÁ@DˆÁ@E˜Á@F¨Á@G¸Á@IÈÁ@JØÁ@KèÁ@LøÁ@NÂ@OÂ@P(Â@R8Â@VHÂ@WXÂ@ZhÂ@exÂ@kˆÂ@l˜Â@¨Â@¸Â@§@ÈÂ@	ØÂ@
èÂ@øÂ@Ã@Ã@(Ã@8Ã@HÃ@`Ã@,pÃ@;ˆÃ@>˜Ã@C¨Ã@kÀÃ@ÐÃ@àÃ@ðÃ@	Ä@
Ä@ Ä@0Ä@;HÄ@kXÄ@hÄ@xÄ@ˆÄ@	˜Ä@
¨Ä@¸Ä@ÈÄ@;ØÄ@èÄ@øÄ@Å@	Å@
(Å@8Å@HÅ@;`Å@pÅ@	€Å@
Å@ Å@°Å@;ÈÅ@ØÅ@	èÅ@
øÅ@Æ@; Æ@ 0Æ@	 @Æ@
 PÆ@; `Æ@$pÆ@	$€Æ@
$Æ@;$ Æ@(°Æ@	(ÀÆ@
(ÐÆ@,àÆ@	,ðÆ@
,Ç@0Ç@	0 Ç@
00Ç@4@Ç@	4PÇ@
4`Ç@8pÇ@
8€Ç@<Ç@
< Ç@@°Ç@
@ÀÇ@
DÐÇ@
HàÇ@
LðÇ@
PÈ@|È@| È@arbgcazh-CHScsdadeelenesfifrhehuisitjakonlnoplptroruhrsksqsvthtruridbesletlvltfavihyazeumkafkafohimskkkyswuzttpagutateknmrsamnglkoksyrdivar-SAbg-BGca-EScs-CZda-DKde-DEel-GRfi-FIfr-FRhe-ILhu-HUis-ISit-ITnl-NLnb-NOpl-PLpt-BRro-ROru-RUhr-HRsk-SKsq-ALsv-SEth-THtr-TRur-PKid-IDuk-UAbe-BYsl-SIet-EElv-LVlt-LTfa-IRvi-VNhy-AMaz-AZ-Latneu-ESmk-MKtn-ZAxh-ZAzu-ZAaf-ZAka-GEfo-FOhi-INmt-MTse-NOms-MYkk-KZky-KGsw-KEuz-UZ-Latntt-RUbn-INpa-INgu-INta-INte-INkn-INml-INmr-INsa-INmn-MNcy-GBgl-ESkok-INsyr-SYdiv-MVquz-BOns-ZAmi-NZar-IQde-CHen-GBes-MXfr-BEit-CHnl-BEnn-NOpt-PTsr-SP-Latnsv-FIaz-AZ-Cyrlse-SEms-BNuz-UZ-Cyrlquz-ECar-EGzh-HKde-ATen-AUes-ESfr-CAsr-SP-Cyrlse-FIquz-PEar-LYzh-SGde-LUen-CAes-GTfr-CHhr-BAsmj-NOar-DZzh-MOde-LIen-NZes-CRfr-LUbs-BA-Latnsmj-SEar-MAen-IEes-PAfr-MCsr-BA-Latnsma-NOar-TNen-ZAes-DOsr-BA-Cyrlsma-SEar-OMen-JMes-VEsms-FIar-YEen-CBes-COsmn-FIar-SYen-BZes-PEar-JOen-TTes-ARar-LBen-ZWes-ECar-KWen-PHes-CLar-AEes-UYar-BHes-PYar-QAes-BOes-SVes-HNes-NIes-PRzh-CHTsr ¾@Bp½@,pÖ@q¼@€Ö@ØÖ@Ú Ö@±°Ö@ ÀÖ@ÐÖ@ÏàÖ@ÕðÖ@Ò×@©×@¹ ×@Ä0×@Ü@×@CP×@Ì`×@¿p×@ÈX½@)€×@›˜×@k½@!°×@c¼@À×@DÐ×@}à×@· ¼@ø×@E8¼@Ø@GØ@‡@¼@(Ø@HH¼@8Ø@¢HØ@‘XØ@IhØ@³xØ@«¾@AˆØ@‹P¼@˜Ø@JX¼@¨Ø@£¸Ø@ÍÈØ@¬ØØ@ÉèØ@’øØ@ºÙ@ÅÙ@´(Ù@Ö8Ù@ÐHÙ@KXÙ@ÀhÙ@Ó`¼@	xÙ@шÙ@ݘÙ@רÙ@ʸÙ@µÈÙ@ÁØÙ@ÔèÙ@¤øÙ@­Ú@ßÚ@“(Ú@à8Ú@»HÚ@ÎXÚ@áhÚ@ÛxÚ@ÞˆÚ@Ù˜Ú@Æ(½@#¨Ú@e`½@*¸Ú@l@½@&ÈÚ@hh¼@
ØÚ@L€½@.èÚ@sp¼@øÚ@”Û@¥Û@®(Û@M8Û@¶HÛ@¼¾@>XÛ@ˆÈ½@7hÛ@x¼@xÛ@Nˆ½@/ˆÛ@tؼ@˜Û@¯¨Û@Z€¼@
¸Û@OP½@(ÈÛ@j½@ØÛ@aˆ¼@èÛ@P¼@øÛ@•Ü@Q˜¼@Ü@Rx½@-(Ü@r˜½@18Ü@xà½@:HÜ@‚ ¼@¾@?XÜ@‰hÜ@S ½@2xÜ@y8½@%ˆÜ@g0½@$˜Ü@f¨Ü@Žh½@+¸Ü@mÈÜ@ƒø½@=ØÜ@†è½@;èÜ@„½@0øÜ@Ý@wÝ@u(Ý@U¨¼@8Ý@–HÝ@TXÝ@—°¼@hÝ@À½@6xÝ@~¸¼@ˆÝ@VÀ¼@˜Ý@W¨Ý@˜¸Ý@ŒÈÝ@ŸØÝ@¨È¼@èÝ@Xм@øÝ@Yð½@<Þ@…Þ@§(Þ@v8Þ@œà¼@HÞ@[ ½@"XÞ@dhÞ@¾xÞ@ÈÞ@°˜Þ@¸¨Þ@˸Þ@Çè¼@ÈÞ@\ È@ãØÞ@ÂðÞ@½ß@¦ ß@™ð¼@8ß@šHß@]¨½@3Xß@z¾@@hß@ŠÐ½@8xß@€Ø½@9ˆß@ø¼@˜ß@^¨ß@n½@¸ß@_¸½@5Èß@|À­@ Øß@b½@èß@`°½@4øß@žà@{H½@'(à@i8à@oHà@Xà@âhà@xà@¡ˆà@²˜à@ª¨à@F¸à@paf-zaar-aear-bhar-dzar-egar-iqar-joar-kwar-lbar-lyar-maar-omar-qaar-saar-syar-tnar-yeaz-az-cyrlaz-az-latnbe-bybg-bgbn-inbs-ba-latnca-escs-czcy-gbda-dkde-atde-chde-dede-lide-ludiv-mvel-gren-auen-bzen-caen-cben-gben-ieen-jmen-nzen-phen-tten-usen-zaen-zwes-ares-boes-cles-coes-cres-does-eces-eses-gtes-hnes-mxes-nies-paes-pees-pres-pyes-sves-uyes-veet-eeeu-esfa-irfi-fifo-fofr-befr-cafr-chfr-frfr-lufr-mcgl-esgu-inhe-ilhi-inhr-bahr-hrhu-huhy-amid-idis-isit-chit-itja-jpka-gekk-kzkn-inkok-inko-krky-kglt-ltlv-lvmi-nzmk-mkml-inmn-mnmr-inms-bnms-mymt-mtnb-nonl-benl-nlnn-nons-zapa-inpl-plpt-brpt-ptquz-boquz-ecquz-pero-roru-rusa-inse-fise-nose-sesk-sksl-sisma-nosma-sesmj-nosmj-sesmn-fisms-fisq-alsr-ba-cyrlsr-ba-latnsr-sp-cyrlsr-sp-latnsv-fisv-sesw-kesyr-syta-inte-inth-thtn-zatr-trtt-ruuk-uaur-pkuz-uz-cyrluz-uz-latnvi-vnxh-zazh-chszh-chtzh-cnzh-hkzh-mozh-sgzh-twzu-zaäTc-^Çk@êítFÐœ,Ÿaõ¹«¿¤\Ãñ)cdµý4ÄÒ‡f’ù;lDÙe”,Bb×E"š&'OŸ@•Á‰V$§úÅgmÈsÜm­ërÁÎd'¢cʤï%{ÑÍpïßk>ê_änþÃÍj¼f29.EZ%øÒqVJÂÃÚ.¨C²ª|!Ž@ΊóÎÄ„'ë|Ô%­I@ÝÚTŸÌ¿aYÜ««\ÇDõg¼ÑR¯·û)`”*!Š»¤Ž¯V©ŸG6²K]à_Ü€
ªþð@ÙŽ¨Ð€k#cd8L2–ÇWƒÕBJäa"©Ù=<½róå‘tYÀ
¦ìlÙ*Óæ…[aOni*{âP+4Ý/î'Pc™qɦéJŽ(.onIn@2&@­PrùÕÑ”)»Í[f–.;¢Û}úe¬SÞw›¢ °Sù¿Æ«%”KMã-ÃûôÐ"RP(·óòWBÜ}]9Ö™Yø8’Ö³†¹w¥zaþ·jaägÃV ”:‹6	›ip½¾ev ëÄ&›ègn	+ò2qQH¾Î¢åER»x”÷ÀtŒ]ð°uÆÛ©¹ÙâßreLK(wàöm‘CQÏÉ•'U«âÖ'樜¦±=@JÐìôðˆ#Åm
Xo¿CÃ]-øHîY ú(ðôÍ?¥. qÖ¼‡Di}nùVyu¤á²¹º èÈÏçUÀúá²Dï°~ $s%rÑù¸ä®@b;zO]¤Î3AâOmm!ò3VåVÁ%—×ë(„ë–Ów;I®-G 8­–ÑÎúŠÛÍÞN†ÀhU¡]i²‰<$qE}A'JnW®b쪉"ïÝû¢¶äïáò½f3€ˆ´7>,¸¿‘Þ¬dôÔNjÿ5jVg¹Û@Ê;*xh›2kÙůõ¼id&äô_€û¯ÑUí¨ J›øW—«
þ®{¦,Ji•¿)ÄǪÒÕØvÇ6ÑUÚ“Çš¨ËK%vð
	ˆ¨÷t:üHå­ŽcYçË—èi×&>rä´†ª["93œuzK‘éG-wùnšç@Äø’ð_òlÃ%B‹ùÉ‘s¯|ÿ…-C°iu+-,„W¦ïÐ@zÇåb¸èjˆØå˜ÍÈÅU‰U¶YÐÔ¾ûX1‚¸EL9ÉM¬ÅâÀLy¡€É;Ñ-±éø"m^š‰8{ØyÎrvÆxŸ¹åyN”ä¡éÔ\lo}ä›çÙ;ù¡obwQ4‹ÆèY+ÞXÞ<ÏXÿF"|W¨Yuç&Sgwc·æë_
ýãi9è35 ¨‡¹1öC!ÛCZØ–õ«¢?hdþ}¾/ÉK°íõáÚN¡sÛ	äœîOg
Ÿ©Öµµö–8s‘ÂIëÌ—+_•?8ö³‘ 7xÑßBÑÁÞ">W߯Š_åõw‹Êç£[R/=OçB
ÝôR	E]áB´®.4³£o£Í?nz(´÷wÁKÐÈÒgàø¨®g;É­³VÈl•ÁH[=Š¾Jô6ÙRMèÛqÅ!ù	EJjت×|Lᜥ›uˆ<ä@’Ôñ¾rdÁ6‡û«x)¯Qü9—ë%0+L¡;<þ(ºüˆwXCž¸¤ä=sÂòF|˜bt!Û®¶£.²Pª«9êB4–—©ßßþÓóÒ€y 7›œPñ­ÜÇ,­=87MÆsÐgmꨛQøòÄ¢áR :#שs…DºÙχp›:ÜRèR²åNû/¦M¾á׫
OíbŒ{ì¹Î!@fÔƒ¡æuãÌò)/„äwdûõÓq=v é/}fLô3.ñ¸óŽ
i”Ls¨&`@<
ˆqÌ!-¥7ïÉÚŠ´1»BALùÖl‹È¸â|í—RÄaÃbªØÚ‡Þê3¸ah𔽚ÌjÕÁ-è6zÆž)ô
?IóϦ¥w£#¾¤‚[¢Ì/r5D¾¸¨N2LÉ­3ž¼ºþ¬v2!L.2Í>´‘þp6Ù\»…—BýÌFøÝ8æÒ‡iÑþñµ>®«¹Ãoî¾@ªÂ@Ùwø,=×áq˜/çÕ	cQrݨ¯FZ*ÖÎÜ*þÝFÎ$'­Ò#·»Ä+Ì·Êë±GÜK	ÊÜÅŽQæ1€VÃŽ¨X/4B‹å¿þüÿycgý6ÕfvPá¹ba°g
ÒÀáÐ;sÛ?.Ÿ£â²aâÜc*¼&”›Õpa–%ã¹u!,`j¸¢;Ò‰s}ñ`ß×ÊÆ+ßi7‡¸$í“fënIoÛ“u‚t^6šnÅ1·6ÅB(ÈŽy®$ÞdAÁšˆÕ™,CÙ瀢.=ök=yI‚C©çyJæý"špÖàïÏÊפ½ldã³ÜN¥n¨¡žEtÈTŽüWÆtÌÔøBncÙWÌ[µ5éþlaQÄÛº•µNñ¡PçùÜqc+Ÿ/Þ"‰½^Î̯…p?Óm-è}o”i^á,ŽdH9¡•à4X<´”öH'½W&|.Ú‹u €;¶Û-HÏm~ä$™P	
%-5	>
H
R]iu
‚Ÿ®¾Ïàò-C	Y	p	ˆ
 
¹
Ó
î	%
dè' †@B€–˜áõÊš;01#INF1#QNAN1#SNAN1#IND¨À?˜‚Ÿ?Xt§?0
¯?×A³?Òð¶?m’º?'¾?~×À?€R•Â?+MÄ?0ÿÅ?‰«Ç?€ZRÉ?ÉóÊ?€÷Ì?'Î?¹Ï?À$£Ð?€\gÑ?ÀA)Ò?€âèÒ?@L¦Ó?À‹aÔ?€­Õ?€½ÑÕ?ȆÖ?À×9×?øê×?€3šØ?”GÙ?À#óÙ?€ìœÚ?@÷DÛ?€MëÛ?À÷Ü?@þ2Ý?jÔÝ?@BtÞ?@ß?€X¯ß? R%à?@>rà?àr¾à?€ó	á?ÀÃTá? æžá?@_èá?À01â?^yâ?àéÀâ? ×ã?€(Nã?Àà“ã?`Ùã?àä?À‹aä?@ø¤ä?Øçä? -*å?Àùkå?@@­å? îå?àB.æ?Ûóy|€6>Èg˜Ásh>žÆˆŸ[Æ^>™/ÌT,X>0S:zÃb>“|si­\a>é…²±j%M>¢zz¹¼Š[>Ü¥Y–#4o>wÓHýn>öô™Gß2k>øòôä)l>YßHȆ>0Av´VôL>˜3¶ü/ c>v	kˆ¦æa>¢zz¹¼Šk>RU£ŠWk>ü¹¯qÈ9a>dÎÓÕe>B!Ѳ¼çm>dN˜Žpm>6/ÇéEiU>Ú[èöâ >ö$'´à·<>ÇF(å¬o>¾BÄ®›^>&qNè]k>ÓY²áWÁm>bœÖj	;>ÝLºú!\>G[ù%Ì_f>PHIšZ>w_F±Gæm>†÷{§]>`—°†hj>>dï°êuo>›˜û‚3>Ò¾ñÃCë`>„\³ì¯_>h_³=æñN>¥qûC—F>–WN@ßl>^bÚ
ª”@>ìãý–L-n>4©éÕôb>¾\ÌnÉgd>Zì=Ð@pn>6Þ‚B¿¾g>?x뱉b>8õr‰Z>‘µ¾Oc>“ëÓáœm>BÄ©*Vc>LHõ­âT>zÉÈ\åŒP>Ú[èöâ0>¿'»>°m>˜°œ°[·a>"ß¹«oI>bA™ó³e>USöY>kX>¬áê,HR>log10CONOUT$F»Wa
|€ð€ä8@x‚@h@.texth\.text$mnpzä.text$x€x.idata$5x‚.00cfg€‚.CRT$XCAˆ‚.CRT$XCAA‚.CRT$XCZ˜‚.CRT$XIA ‚.CRT$XIAA¨‚.CRT$XIAC°‚.CRT$XICÈ‚.CRT$XIZЂ.CRT$XPAØ‚.CRT$XPXè‚.CRT$XPXAð‚.CRT$XPZø‚.CRT$XTAƒ.CRT$XTZƒpm.rdata€ð€.rdata$zzzdbgó.rtc$IAAó.rtc$IZZó.rtc$TAAó.rtc$TZZ óp.xdataþ.idata$2¤þ.idata$3¸þx.idata$40¬.idata$6
.data@.bss0H.pdata ÖB*ä ÖB*äX0 Àj×ɆÉÈ‚*äãããÈ&¨ÿÿÿ@€ää@@äìää@âBäBä-@(@áÔäãããhP\@áƒÐ‚$äãã01(@)pz@)x)ˆ)pz@)
@äãã@@ääáƒä4páƒäã01 +Ü+˜zÜ+@äãã@@áäã'@"@á"ä!@@á"äcä.P(@á…"ä01”4¨4Äz¨4B@9Ôä@€äää@0@â
JÊɆÉÈ‚,äJÊɆÉÈ‚,ä@0@â
JÊɆÉÈ‚,äJÊɆÉÈ‚,ä@@áäãä9ääHä)@8!@ÊÉŠÉȆÈBäÊÉŠÉȆÈBäv0áÉȄȇäãããÈ&¸ÿÿÿˆ@;@á"äJ0áЄÈ…äãÈ&Èÿÿÿ;0áЄÈ…äãÈ&Èÿÿÿ20áЄÈ…äãÈ&Èÿÿÿpáƒ"ä01?œ?Ì{	@äãã-	@@&@*@áƒ"äJ@?@áÑÈ‚&äáÔäããã5@0@á‡ÔäãããCP>@áЂ$äãã01luÜu|@vpáƒ"ä01u uð{!pá…È‚$äãã01@zŒz8|páƒ"ä01||ð{páƒ"ä01X|d|ð{
áÔäããã01h‚€‚€‚c`áÑЂ$äœ@@áÒɆÉÈ‚*äpáƒ"ä01¨‚´‚ð{Ê@Äá¡"ä
 áããääããã1P	@áƒ"ä01Ø‹Œ\|@äãã@@áƒÑÈ‚&äº@¬@áƒÉ†ÉÈ‚(äããNpáƒÒцÉÈ‚(ä01,ŸhŸ¸|@äãã!páƒ"ä01€¤Ì¤Ø| äããáäã+@@áÉÈ‚&ä8@@áäã5páƒÈ‚$äãã01иh¹ü|1páƒ"ä01¨¹8ºÌ{;pá‹È‚$äãã01tº$»}páÔäããã01¿¨¿@}s@E@á‡Ð‚$äãã/ä7ä*ä5ä;@6@áЂ$äãã.@*@á"äpáƒ"ä01HÄhÄð{páƒ"ä01 Å8Åð{páƒ"ä01pŬÅð{páƒ"ä01 ÄèÄð{2@
@áäãŽ@@á…ɆÉÈ‚(äãã=`áÈÂ$äãã:0áȃäãããÈ&Øÿÿÿh`áÑЂ$ä@€@á‡ÒɆÉÈ‚*äd@@áцÉÈ‚(äããÚPÑáшÉȄȉäãÈ&¨ÿÿÿB0áȃäãããÈ&ØÿÿÿJ`áÐÂ$äãã¤0áÑȄȇäãããÈ&¸ÿÿÿ2P-@áЂ$äãã01üí\î`}\@+@á‡È‚$äããƒ0áЃäãããÈ&ØÿÿÿVpáƒÈ‚$äãã01„ç èð{Å@¸@áÒɆÉÈ‚*ä9@@áÈ‚$äããVP$@áƒÉÈ‚&ä01ìüLý@}lý þ@}.P
@áƒÉÈ‚&ä01ûXû@}hû€û@}o0 áÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿP@á"ä01 	4	€}páÔäããã01D` }šP%@á…ÒцÉÈ‚(ä01Œ<À}ÌàÀ}páƒ"ä01”°ð{a@U@áƒÉ†ÉÈ‚(äããÜPÏáшÉȄȉäãÈ&¨ÿÿÿ20áЃäãããÈ&ØÿÿÿFpáƒÒцÉÈ‚(ä01l#¨#¸|Ì0 áÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿ40 áÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿN0áÑȄȇäãããÈ&¸ÿÿÿL0áÈ„È…äãÈ&Èÿÿÿ_0 áÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿFpáƒÒцÉÈ‚(ä01d) )¸|P@áƒ"ä01à,ì,è}-páƒ"ä01 -œ-Ø|j@F@áƒÒɆÉÈ‚*ä*@@áЂ$äããgP VáÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿû@=ò÷È‚$äãããP áÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿ+P'áäãÈ&èÿÿÿÂP °áÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿ=P3@áÈ‚$äãã014ZÐZ~ìZ[~r0áäãÈ&èÿÿÿá0 áÒ
ɈÉÈ„È‹äãããÈ&˜ÿÿÿNP DáÜ	шÉȄȉäãããÈ&¨ÿÿÿpá"ä01pu´u(~´u@äããäôä¸þr€0F\n„œ¸Òèþ.L^Ì€Žž®ºÈÖàø.FXj|Œ˜®ÂÐäò(:HVbt„œÄÐÞìö*6JZlv‚Ž¤ºÔî*<TjzŽ¢²¾×WaitForSingleObject=GetExitCodeProcessãCreateProcessAsGetModuleFileNameAéSetConsoleCtrlHandler³GenerateConsoleCtrlEventDQueryPerformanceCounterGetCurrentProcessIdGetCurrentThreadIdéGetSystemTimeAsFileTimebInitializeSListHeadnSetUnhandledExceptionFilterÐGetStartupInfoWxGetModuleHandleWKERNEL32.dllÒRtlUnwindExaGetLastError1SetLastErrorœFlsAllocžFlsGetValueŸFlsSetValueFlsFree3EnterCriticalSection·LeaveCriticalSection_InitializeCriticalSectionExDeleteCriticalSectionYRaiseExceptionØGetCommandLineAÙGetCommandLineWÒGetStdHandleWriteFiletGetModuleFileNameWGetCurrentProcess`ExitProcessŒTerminateProcess­FreeLibrarywGetModuleHandleExW®GetProcAddress‰CloseHandleèCreateProcessWÎCreateFileWOGetFileTypejReadFileþGetConsoleModegReadConsoleWDHeapAllocHHeapFree^InitializeCriticalSectionAndSpinCountžTlsAlloc TlsGetValue¡TlsSetValueŸTlsFree½LoadLibraryExWžCompareStringW«LCMapStringWwFindClose}FindFirstFileExWŽFindNextFileW…IsValidCodePage´GetACP—GetOEMCPÃGetCPInfoèMultiByteToWideCharþWideCharToMultiByte8GetEnvironmentStringsW¬FreeEnvironmentStringsWSetEnvironmentVariableWKSetStdHandle×GetStringTypeW´GetProcessHeapCGetFileAttributesExWGetConsoleOutputCPSetEndOfFile#SetFilePointerEx¡FlushFileBuffersMGetFileSizeExMHeapSizeKHeapReAllocWriteConsoleW2¢ß-™+Í] ÒfÔÿÿÿÿÿÿÿÿÿÿ   ÿÿÿÿÿÿÿÿ€


ÿÿÿÿÀ¨@ø@ø@ø@ø@ø@@@@«@À¬@¡@@@C                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þØ@Ø)@Ø)@Ø)@Ø)@Ø)@Ø)@Ø)@Ø)@Ø)@Ü@Ü)@Ü)@Ü)@Ü)@Ü)@Ü)@Ü)@..þÿÿÿþÿÿÿÿÿÿÿu˜Ló XóPhópÌóˆØóÀ0ôPhôltôp|ôÄœô Èô€Ðô€ØôààôèôÀxø|€ø`ˆøøà€þ ˆþ1¡H1 x óÀQ' õ'!0óh&(óÈ&9à'xó¸'àÐ'àð'ˆó)à¨)ô*]àx*ô+àóè+9a ,Eah,Ia°,àÐ,Ýb.5à€.Y`à.}àx/$ô0eäh0eäÐ0€è0à1€01¡iØ3=à4%à@48ô5à5àP5¼ôp5äˆ6ya7EaH7Uà 7me08¥eØ9}f°<y`(=Eà=!èÈ>uäp?lõ¸?¥ãB©f¸Bme(CaÈCDõÐE­d€F$õ H!b8K…aÀKÅaˆL‰aMµàÐNµàP•cTecPW©ãøWâZÕaðZ5f0]­bè]Áã¨^µàà_0õaXõÐaÅe˜b)èÀcu`8dõgUahg˜õ h	e¨j]b0kQç€mqaðm™äˆo}bp°õ0qÍãrUbXrUb°rMas‘b˜sb(tqe˜t]äøtö8uÜõ`vÌõ8wÀõ¨w™âÈxAàyQà z$öÀz1`ðza{Màð{Hö8|hö€|½f@~Ii˜=à€A`h€-à˜€à°€Maà ]b€]aà%à‚EàP‚ˆöˆ‚ÌöЂ¸ö@…ìöhˆ¬öŠ‰ä˜‹÷`ŒH÷H8÷À‘Ù☒øöÐ’1h”‰éˆ˜ñéxšé˜œáixž\÷°Ÿ­é`¤÷褱à˜¥í㈦°÷ ¦à §¸÷€§ç«±ãÀ«À÷ð¬aaP­)àx­)ਭ±bX®Ð÷8¯•ãè¯aaH°%ip²ebà²Ya8³õi0´mb ´qbµqb€µ…ã¶ä˜¶õi·uãH¸eã°¸Ü÷ˆ¹øPº ø@»a` »µbX¼eaȼia0½ýg0¾Iix¿DøÀ¿EbÀ¡ã¨À-`ØÀuãXÂhø(Ä´ø€ÄùÅÔøPÅôøÀÅÉàˆÆ-a¸Æí`¨ÇmbȘøɨøÀÉåã¨ÊMàøÊ9a0ËMa€ËMaÐËqi@ÏÕåÐ@ùPÒ¹fÔg(Õ4ùðÕTùèÖ1dÙ5à ÙYaøÙõbðÚaaPÛ`ùXÜtùøÝ€ù0à”ùÀá¨ù0åØùXæÄù`çHúé©a°é…b8ê4úHì$ú¸íüù€îqbðî!àïäùàò%eôlú ÷€úøyä°ømeHùE`ùÍf`úeäÈúÈú°ûåfÈüú þíeÿ‘àÀÿ-bðb€QãÐÍa -`ûÐQe`IaèûX	ybÐ	¡äp
1à°
ÁepaäàQb0@ûx û0
1`x
dûà™àxÔûèÀûpáiPðû	c Hüðdü( |üX!üØ"üð#,ü '­fÐ(¬üè)Ác¸*}à8+¹fð+•bˆ,Ôü-øü¸-¡àX.aa¸.Iá/ý¨0Õà€1ÕãX2Qä¨3\ý˜7<ý8I,ýàIàøIcKµáÈK}bHM|ý`QœýR°ýU¥çÀU!àøUåãàVÅäøXMàHYÅäZÐý[±ã\Yàp\µã(]=`]þX_yaØ_1a`eáp`]áÈeafþj•ç°jea@kõe0méà n©ãÈn4þpæHt=à`uTþpzÀó˜zôÄz\ôÌ{Œõð{Œõ|Œõ8|Œõ\|,÷¸|„÷Ø|Œõü|„÷}Œõ@}„÷`}„÷€}„÷ }„÷À}Àóè}„÷~„÷(~tþ€x¢ˆ¢ ¢¨¢°¢¸¢À¢Ø¢à¢è¢Ø£à£è£ð£¤¤ ¤0¤@¤P¤`¤p¤€¤¤ ¤°¤À¤Ð¤à¤ð¤¥¥ ¥0¥@¥P¥`¥p¥€¥¥ ¥°¥À¥Ð¥à¥ð¥¦¦ ¦0¦@¦P¦`¦p¦€¦¦ ¦°¦À¦Ð¦à¦ð¦§§ §0§@§P§`§p§€§§ §°§À§Ð§à§ð§¨¨ ¨0¨@¨P¨`¨p¨€¨¨ ¨°¨À¨Ð¨à¨ð¨©© ©0©@©P©`©p©€©© ©°©À©Ð©à©ð©ªª ª0ª@ªPª`ªpª€ªª ª°ªÀªÐªàªdЦà¦ð¦ø¦§§§§ §(§8§@§H§P§X§`§h§p§ˆ§˜§¨§°§¸§À§È§`©h©p©x©€©ˆ©©˜© ©¨©°©¸©À©È©Ð©Ø©à©è©ð©ø©   ( 0 8 @ H P X ` h p x € ˆ  ˜ ¡¡¡¡ ¡(¡0¡8¡@¡H¡P¡X¡`¡h¡p¡x¡€¡ˆ¡¡˜¡ ¡¨¡°¡¸¡À¡È¡Ð¡Ø¡à¡è¡ð¡ø¡¢¢¢¢ ¢(¢0¢8¢@¢H¢P¢`¢h¢p¢x¢€¢ˆ¢¢˜¢ ¢¨¢°¢¸¢À¢È¢Ð¢Ø¢à¢è¢ð¢ø¢££££ £(£0£8£@£H£P£X£`£h£p£x£€£ˆ££˜£ £¨£°£¸£Ø­è­ø­®®(®8®H®X®h®x®ˆ®˜®¨®¸®È®Ø®è®ø®¯¯(¯8¯H¯X¯h¯x¯ˆ¯˜¯¨¯¸¯È¯Ø¯è¯ø¯°Œ  ( 8 H X h x ˆ ˜ ¨ ¸ È Ø è ø ¡¡(¡8¡H¡X¡h¡x¡ˆ¡˜¡¨¡¸¡È¡Ø¡è¡ø¡¢¢(¢8¢H¢X¢h¢x¢ˆ¢˜¢¨¢¸¢È¢Ø¢è¢ø¢££(£8£H£X£h£x£ˆ£˜£¨£¸£È£Ø£è£ø£¤¤(¤8¤H¤X¤h¤x¤ˆ¤˜¤¨¤¸¤È¤Ø¤è¤ø¤¥¥(¥8¥H¥X¥h¥x¥ˆ¥˜¥¨¥¸¥È¥Ø¥è¥ø¥¦¦(¦8¦H¦X¦h¦x¦ˆ¦˜¦¨¦¸¦È¦Ø¦è¦ø¦§§(§8§H§X§h§x§ˆ§˜§¨§¸§È§Ø§è§ø§¨¨(¨8¨H¨X¨h¨x¨ˆ¨˜¨¨¨¸¨È¨Ø¨è¨ø¨©©(©8©H©X©h©x©ˆ©˜©¨©¸©È©Ø©è©ø©ªª(ª8ªHªXªhªxªˆª˜ª¨ª¸ªÈªØªèªøª««(«8«H«X«h«x«ˆ«˜«¨«¸«È«Ø«è«ø«¬À0¨@¨P¨`¨p¨€¨¨ ¨°¨À¨Ð¨à¨ð¨©© ©0©@©P©`©p©€©© ©°©À©Ð©à©ð©ªª ª0ª@ªPª`ªpª€ªª ª°ªÀªÐªàªðª«« «0«@«P«`«p«€«« «°«À«Ð«à«ð«¬¬ ¬0¬@¬P¬`¬p¬€¬¬ ¬°¬À¬Ð¬à¬ð¬­­ ­0­@­P­`­p­€­­ ­°­À­Ð­à­ð­®® ®0®@®P®`®p®€®® ®°®À®Ð®à®ð®¯¯ ¯0¯@¯P¯`¯p¯€¯¯ ¯°¯À¯Ð¯à¯ð¯ÐØ    0 @ P ` p €    ° À Ð à ð ¡¡ ¡0¡@¡P¡`¡p¡€¡¡ ¡°¡À¡Ð¡à¡ð¡¢¢ ¢0¢@¢P¢`¢p¢€¢¢ ¢°¢À¢Ð¢à¢ð¢££ £0£@£P£`£p£€££ £°£À£Ð£à£ð£¤¤ ¤0¤@¤P¤`¤p¤€¤¤ ¤°¤À¤Ð¤à¤ð¤¥¥ ¥0¥@¥P¥`¥p¥€¥¥ ¥°¥À¥Ð¥à¥ð¥¦¦ ¦0¦@¦P¦`¦àh¯€¯ð@ D¢Ø¢ø¢£8£X£ˆ£ £¨£°£è£ð£@©H©P©X©`©h©p©x©€©ˆ©˜© ©¨©°©¸©À©È©Ð©././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/gui.exe0000644000175100001710000020000000000000000017074 0ustar00runnerdockerMZÿÿ¸@躴	Í!¸LÍ!This program cannot be run in DOS mode.

$äSÀØ 2®‹ 2®‹ 2®‹‡ôÕ‹£2®‹ 2¯‹û2®‹}8‹¤2®‹¾`*‹„2®‹¾`;‹²2®‹¾`-‹Ñ2®‹¾`?‹¡2®‹Rich 2®‹PEL±‹Qà	ÊN&à@@€4ù(ˆô@à@.textíÉÊ `.rdatah à"Î@@.dataÄ+ð@ÀQ‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPèx
ƒÄ3ÿ3Û‰D$Æ"p…í~W뛋L$Š<\uGë <"u…ÿ~Wj\Vè
ƒÄ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ÷‹D$_Æ"ÆF^][YÃì¡€A3ĉ„$V‹´$W‹¼$Š‹Ï„Àtd$A9](u>‹u3À@8tHF;Ãwö€>:u5;Ëtƒ}‚õjÿujÿQèU&ƒÄF‰uë9](uÂÇEøéÎ;Ëtˆ‹u3ÿ‰]ü8tU¾Pè&Y…ÀtFëŠYƒeü3ÛC98 A„ʼn4 AŠE¢0 Aƒ}…ÿ5¬+Aè0,Y‹ø‰}Ø…ÿtxÿ5¨+Aè,Y‹ð‰u܉}ä‰uàƒî‰uÜ;÷rWè÷+9tí;÷rJÿ6èñ+‹øèá+‰ÿ×ÿ5¬+AèÛ+‹øÿ5¨+AèÎ+ƒÄ9}äu9Eàt‰}ä‰}؉Eà‹ð‰uÜ‹}ØëŸhpá@¸dá@è_þÿÿYhxá@¸tá@èOþÿÿYÇEüþÿÿÿèƒ}u(‰8 AjèlYÿuèüýÿÿ3ÛCƒ}tjèSYÃèËÿU‹ìjjÿuèÃþÿÿƒÄ]ËÿU‹ìjjÿuè­þÿÿƒÄ]ÃjjjèþÿÿƒÄÃjjjèŽþÿÿƒÄËÿVèó*‹ðVèY;Vèä:VèwVèÉ:Vè´:Vèœ8Vè57Vè7hê#@èE*ƒÄ$£ˆA^ËÿU‹ìƒ=D AuèŒ3ÿuèÙ1hÿè'ýÿÿYY]ÃjXh0õ@èû3ö‰uüE˜Pÿ4à@jþ_‰}ü¸MZf9@u8¡<@¸@PEu'¹f9ˆ@uƒ¸t@v3É9°è@•Á‰Mäë‰uä3ÛCSèÏ?Y…ÀujèXÿÿÿYè-…ÀujèGÿÿÿYèW4‰]üèø
…À}jè&üÿÿYÿ0à@£ +AèQ>£< AèŒ=…À}jèüÿÿYè;…À}j	èïûÿÿYSè§üÿÿY;ÆtPèÝûÿÿYè:„]Ät·MÈëj
YQPVh@èòÿÿ‰Eà9uäuPèþÿÿèEþÿÿ‰}üë5‹Eì‹‹	‰MÜPQè·5YYËeè‹E܉Eàƒ}äuPèþÿÿè!þÿÿÇEüþÿÿÿ‹Eàë3À@ËeèÇEüþÿÿÿ¸ÿèÏÃèï>éxþÿÿ‹ÿU‹ìV‹uVèSPèk?YY…Àt|è©òÿÿƒÀ ;ðu3Àëè™òÿÿƒÀ@;ðu`3À@ÿ A÷FuNSW<…H Aƒ?»u Sè
Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N3À_@[ë3À^]ËÿU‹ìƒ}t'V‹u÷FtVèfÿîÿÿƒfƒ&ƒfY^]ÃöA@tƒyt$ÿIx‹ˆÿ¶Àë¾ÀQPèé-YYƒøÿu	ÃÿËÿU‹ìV‹ðë‹MŠEÿMèµÿÿÿƒ>ÿtƒ}ç^]ËÿU‹ìöG@SV‹ð‹Ùt2ƒu,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕƒ8*u‹Ï°?èdÿÿÿƒ}Õ^[]ËÿU‹ììx¡€A3ʼnEüS‹]V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè÷öÿÿ…öu5èMÇ3ÀPPPPPèӃĀ½°ýÿÿt
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF@u^Vè@
Yº˜Aƒøÿtƒøþt‹Èƒá‹ðÁþÁáµ *Aë‹ÊöA$u‘ƒøÿtƒøþt‹ÈƒàÁùÁà *Aë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu¡A‰…äýÿÿ‹…äýÿÿëI€8t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ…\‹…ðýÿÿ¨@t2©t	Æ…Ôýÿÿ-ë¨t	Æ…Ôýÿÿ+ë¨tÆ…Ôýÿÿ Ç…Ðýÿÿ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿuÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄƒ½Èýÿÿ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFèå5ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿYuµëƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ|ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄƒ½¼ýÿÿtÿµ¼ýÿÿ胥¼ýÿÿY‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿt
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èÚëÿÿÉÃ+@)@G)@¥)@ñ)@ü)@B*@p+@jThXõ@èe3ÿ‰}üEœPÿ4à@ÇEüþÿÿÿj@j ^VèyYY;Ç„£ *A‰5*Aˆë0Æ@ƒÿÆ@
‰xÆ@$Æ@%
Æ@&
‰x8Æ@4ƒÀ@‹
 *AÁ;ÁrÌf9}΄
‹EÐ;Ç„ÿ‹8X;‰Eä¾;þ|‹þÇEàë[j@j èëYY…ÀtV‹Mà *A‰ƒ*A ë*Æ@ƒÿÆ@
ƒ`€`$€Æ@%
Æ@&
ƒ`8Æ@4ƒÀ@‹Ö;ÂrÒÿEà9=*A|ë‹=*Aƒeà…ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨uQÿ@à@…Àt<‹uà‹ÆÁøƒæÁæ4… *A‹E䋉ŠˆFh FPè„*YY…À„ÉÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A‹ƒøÿtƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ<à@‹øƒÿÿtC…ÿt?Wÿ@à@…Àt4‰>%ÿƒøu€N@ë	ƒøu€Nh FPèî)YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*Aÿ8à@3Àë3À@ËeèÇEüþÿÿÿƒÈÿècËÿU‹ì‹EV3ö;Æuè½VVVVVÇèEƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A]ËÿU‹ìì(¡€A3ʼnEüƒ¥ØüÿÿSjL…ÜüÿÿjPèóäÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…ØüÿÿÀÇ…Üüÿÿ‰…äüÿÿÿXà@j‹ØÿTà@…(ýÿÿPÿPà@…Àu…ÛujèM2YhÀÿLà@PÿHà@‹Mü3Í[èüçÿÿÉËÿU‹ìÿ5P Aè*Y…Àt]ÿàjè2Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØAtAƒù-rñHíƒùwj
X]ËÍÜA]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãè …Àu¸@AÃÀÃè…Àu¸DAÃÀËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌh8@dÿ5‹D$‰l$l$+àSVW¡€A1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£Ã‹Mðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹]V‹s35€AW‹ÆEÿÇEô{ƒøþt
‹NÏ38è©æÿÿ‹N‹FÏ38è™æÿÿ‹Eö@f…‹MUè‰Sü‹[‰Eè‰Mìƒûþt_I[‹L†D†‰Eð‹‰Eø…Ét‹×è„1ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿt$‹ƒøþt
‹NÏ38è&æÿÿ‹N‹VÏ3:èæÿÿ‹Eô_^[‹å]ÃÇEôëÉ‹M9csmàu)ƒ=Œ*At hŒ*Aèƒ!ƒÄ…Àt‹UjRÿŒ*AƒÄ‹Mè'1‹E9Xth€AW‹Ó‹Èè*1‹E‹Mø‰H‹ƒøþt
‹NÏ38è“åÿÿ‹N‹VÏ3:èƒåÿÿ‹Eð‹H‹×è½0ºþÿÿÿ9S„Rÿÿÿh€AW‹ËèÕ0éÿÿÿ‹ÿU‹ìVW3öÿuè%1‹øY…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öjÿuÿuèE‹øƒÄ…ÿu'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿuÿuè[1‹øYY…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿuÿuè%3‹øƒÄ…ÿu,9Et'9T AvVÿ$à@†è;T AvƒÈÿ‹ðƒøÿu½‹Ç_^]Ãjhxõ@èÓüÿÿ‹u…ötuƒ=„*AuCjèYƒeüVè73Y‰Eä…Àt	VPèX3YYÇEüþÿÿÿèƒ}äu7ÿuë
jèYÃVjÿ5t)Aÿ`à@…Àuèüÿÿ‹ðÿ\à@PèÌûÿÿ‰Yè—üÿÿÃjh˜õ@èEüÿÿ3Û‰]äjè–Y‰]üj_‰}à;=À;A}W‹÷Á桼+AÆ9tD‹ö@ƒtPèÊ=YƒøÿtÿEäƒÿ|(¡¼+A‹ƒÀ PÿDà@¡¼+Aÿ4èýþÿÿY¡¼+A‰GëžÇEüþÿÿÿè	‹EäèüÿÿÃjè7YËÿU‹ìSV‹u‹F‹È€á3Û€ùu@©t9‹FW‹>+ø…ÿ~,WPVèaùÿÿYPèçDƒÄ;Çu‹F„Àyƒàý‰FëƒN ƒËÿ_‹Fƒf‰^‹Ã[]ËÿU‹ìV‹u…öu	Vè5Yë/Vè|ÿÿÿY…ÀtƒÈÿë÷F@tVèøøÿÿPè[EY÷ØYÀë3À^]Ãjh¸õ@èöúÿÿ3ÿ‰}ä‰}ÜjèDY‰}ü3ö‰uà;5À;Aƒ¡¼+A°98t^‹ö@ƒtVPVèÝÿÿYY3ÒB‰Uü¡¼+A‹°‹HöÁƒt/9UuPèJÿÿÿYƒøÿtÿEäë9}uöÁtPè/ÿÿÿYƒøÿu	E܉}üèFë„3ÿ‹uࡼ+Aÿ4°Vè"ÝÿÿYYÃÇEüþÿÿÿèƒ}‹Eät‹EÜèwúÿÿÃjè­YÃjèÿÿÿYËÿVW3ö¿X Aƒ<õLAuõHA‰8h ÿ0ƒÇè}!YY…ÀtFƒþ$|Ò3À@_^Ã$õHA3Àëñ‹ÿS‹Dà@V¾HAW‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ&YƒÆþhA|ܾHA_‹…Àt	ƒ~uPÿÓƒÆþhA|æ^[ËÿU‹ì‹Eÿ4ÅHAÿà@]Ãjhàõ@èZùÿÿ3ÿG‰}ä3Û9t)Auè´jèhÿèPãÿÿYY‹u4õHA9t‹Çënjè	ûÿÿY‹ø;ûuèÁøÿÿÇ3ÀëQj
èYY‰]ü9u,h Wèt YY…ÀuWèþûÿÿYè‹øÿÿÇ‰]äë‰>ëWèãûÿÿYÇEüþÿÿÿè	‹EäèòøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHAƒ>uPè"ÿÿÿY…ÀujèDâÿÿYÿ6ÿà@^]Ãjhö@èdøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;EÀ@uèû÷ÿÿÇWWWWWèƒ÷ÿÿƒÄ3ÀéÕ¯M‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*AuKƒÆƒæð‰u‹E;p*Aw7jèLÿÿÿY‰}üÿuèH6Y‰EäÇEüþÿÿÿè_‹]ä;ßtÿuWSèÛÿÿƒÄ;ßuaVjÿ5t)Aÿdà@‹Ø;ßuL9=€)At3Vè’Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇéEÿÿÿ3ÿ‹ujèðýÿÿYÃ;ßu
‹E;ÇtÇ‹Ãè˜÷ÿÿÃU‹ìƒì‰}ü‹}‹MÁéfïÀë¤$ffGfG fG0fG@fGPfG`fGp¿€IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRjQè~ÿÿÿƒÄ‹E‹}ü‹å]Ãjh ö@è`öÿÿƒeüf(ÁÇEäë#‹Eì‹‹=Àt
=Àt3ÀÃ3À@ËeèƒeäÇEüþÿÿÿ‹EäèböÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+ÑtQ3À¢‰Eô‰]è‰Uì‰M𸢉Uü‰Eø[÷Eütè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A3ÀËÿU‹ìQSV‹u3ÛW;ót9]w èEõÿÿjYSSSSS‹ñ‰èÌôÿÿƒÄ‹ÆéÍ‹E3ÿ;ÃtŠ:Ãtj_9}†ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹UG‰}ü;úsyŠˆF@8uèPQèì@ŠYYŠˆF@8uð‹E;Ãt'Š:Ët!€ù.tG;}sÆ.FëG;}sŠˆF@8uðG;}v‹Eˆèhôÿÿj"éÿÿÿˆ3À_^[ÉËÿU‹ìƒìÿuMðèæÛÿÿ¶E‹MôŠU„Tuƒ}t‹Mð‹‰È·A#Eë3À…Àt3À@€}üt‹MøƒapýÉËÿU‹ìjjÿuÿuè™ÿÿÿƒÄ]ËÿU‹ìjjÿujèÿÿÿƒÄ]ËÿU‹ìjÿuÿuÿuÿuèå?ƒÄ]ËÿU‹ìì(£°"A‰
¬"A‰¨"A‰¤"A‰5 "A‰=œ"AfŒÈ"AfŒ
¼"AfŒ˜"AfŒ”"AfŒ%"AfŒ-Œ"AœÀ"A‹E£´"A‹E£¸"AE£Ä"A‹…àüÿÿÇ"A¡¸"A£´!AǨ!A	ÀǬ!A¡€A‰…Øüÿÿ¡„A‰…ÜüÿÿÿXà@£ø!Ajè¯$YjÿTà@hÔâ@ÿPà@ƒ=ø!Aujè‹$Yh	ÀÿLà@PÿHà@ÉÃ-¤t"ƒètƒè
tHt3ÀøøøøËÿVW‹ðh3ÿFWPèûÕÿÿ3À·È‹Á‰~‰~‰~ÁáÁ~«««¹hAƒÄF+οŠˆ@Ou÷†¾Šˆ@Nu÷_^ËÿU‹ìì¡€A3ʼnEüSW…èúÿÿPÿvÿhà@¿…À„û3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj Rè8ÕÿÿƒÄCŠC„ÀuØjÿv…üúÿÿÿvPW…üþÿÿPjjèyE3ÛSÿv…üýÿÿWPW…üþÿÿPWÿvSèZCƒÄDSÿv…üüÿÿWPW…üþÿÿPhÿvSè5CƒÄ$3À·ŒEüúÿÿöÁt€LŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒëÆ„@;Çr¾ëV†Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ÐZ ƒûw€LŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆA;Ïr‹Mü_3Í[èØÿÿÉÃjh@ö@èËðÿÿè˜
‹ø¡ŒA…Gptƒlt‹wh…öuj ènÚÿÿY‹ÆèãðÿÿÃj
èó÷ÿÿYƒeü‹wh‰uä;5At6…ötVÿpà@…ÀuþhAtVè‡óÿÿY¡A‰Gh‹5A‰uäVÿlà@ÇEüþÿÿÿè뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðèt×ÿÿ‰Ì$AƒþþuÇÌ$Aÿxà@8]ütE‹Møƒapýë<ƒþýuÇÌ$Aÿtà@ëÛƒþüu‹Eð‹@ÇÌ$AëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A3ʼnEüS‹]V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé‰uä3À9¸˜A„‘ÿEäƒÀ0=ðrçÿèý„pÿéý„d·ÇPÿ|à@…À„REèPWÿhà@…À„3hCVPèXÒÿÿ3ÒBƒÄ‰{‰s9Uè†ø€}î„ÏuɄ¶Fÿ¶Éé¦hCVPèÒÿÿ‹MäƒÄkÉ0‰u౨A‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”AD;¶FG;øvê‹}FF€>uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇCègûÿÿj‰CC‰œAZf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L@;ÁvöFF€~ÿ…4ÿÿÿC¹þ€@Iuù‹Cèûÿÿ‰C‰Së‰s3À·È‹ÁÁáÁ{«««ë¨95Ì$A…XþÿÿƒÈÿ‹Mü_^3Í[èÕÿÿÉÃjh`ö@èÆíÿÿƒMàÿè‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„Wh è‚ïÿÿY‹Ø…Û„F¹ˆ‹wh‹ûó¥ƒ#Sÿuè¸ýÿÿYY‰Eà…À…ü‹uÜÿvhÿpà@…Àu‹Fh=hAtPècðÿÿY‰^hS‹=là@ÿ×öFp…êöŒA…Ýj
ètôÿÿYƒeü‹C£Ü$A‹C£à$A‹C£ä$A3À‰Eäƒø}f‹LCf‰EÐ$A@ëè3À‰Eä=}
ŠLˆˆˆA@ëé3À‰Eä=}ŠŒˆˆA@ëæÿ5Aÿpà@…Àu¡A=hAtPèªïÿÿY‰ASÿ×ÇEüþÿÿÿèë0j
èíòÿÿYÃë%ƒøÿu ûhAtSètïÿÿYèìÿÿÇëƒeà‹Eàè~ìÿÿÃ=°+AujýèVþÿÿYÇ°+A3ÀËÿU‹ìSV‹u‹†¼3ÛW;Ãto=HAth‹†°;Ãt^9uZ‹†¸;Ãt9uPèûîÿÿÿ¶¼è›AYY‹†´;Ãt9uPèÚîÿÿÿ¶¼è5AYYÿ¶°èÂîÿÿÿ¶¼è·îÿÿYY‹†À;ÃtD9u@‹†Ä-þPè–îÿÿ‹†Ì¿€+ÇPèƒîÿÿ‹†Ð+ÇPèuîÿÿÿ¶ÀèjîÿÿƒÄ¾Ô‹=ˆAt9˜´uPè?ÿ7èCîÿÿYY~PÇEøAt‹;Ãt9uPèîÿÿY9_üt‹G;Ãt9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@W‹}WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒSV‹5pà@WÿÖ‹‡°…ÀtPÿÖ‹‡¸…ÀtPÿÖ‹‡´…ÀtPÿÖ‹‡À…ÀtPÿÖ_PÇE{øAt	‹…ÀtPÿÖƒ{üt
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô´PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ>Yuþ˜AtVèYýÿÿY‹Ç^Ã3ÀÃjh€ö@è_éÿÿè,‹ð¡ŒA…Fpt"ƒ~ltè‹pl…öuj èýÒÿÿY‹ÆèréÿÿÃjè‚ðÿÿYƒeüFl‹=pAèiÿÿÿ‰EäÇEüþÿÿÿèëÁjè}ïÿÿY‹uäËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€øë'¾tã@Vÿ à@…ÀuVè>ÒÿÿY…Àthdã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãjè‡ÿÿÿYËÿU‹ìVÿ5„A‹5€à@ÿÖ…Àt!¡€AƒøÿtPÿ5„AÿÖÿÐ…Àt‹€üë'¾tã@Vÿ à@…ÀuVèÃÑÿÿY…Àthã@Pÿ(à@…ÀtÿuÿЉE‹E^]Ãÿ„à@‹ÿVÿ5„Aÿ€à@‹ð…öuÿ5%AèeÿÿÿY‹ðVÿ5„Aÿˆà@‹Æ^á€AƒøÿtPÿ5%Aè;ÿÿÿYÿЃ
€Aÿ¡„AƒøÿtPÿŒà@ƒ
„Aÿéºíÿÿjh ö@è‚çÿÿ¾tã@Vÿ à@…ÀuVèÑÿÿY‰Eä‹uÇF\é@3ÿG‰~…Àt$hdã@P‹(à@ÿÓ‰†øhã@ÿuäÿÓ‰†ü‰~pƆÈCƆKCÇFhhAj
ènîÿÿYƒeüÿvhÿlà@ÇEüþÿÿÿè>jèMîÿÿY‰}ü‹E‰Fl…Àu¡pA‰FlÿvlèüÿÿYÇEüþÿÿÿèèçÿÿÃ3ÿG‹uj
è5íÿÿYÃjè,íÿÿYËÿVWÿ\à@ÿ5€A‹øè‘þÿÿÿЋð…öuNhjè±èÿÿ‹ðYY…öt:Vÿ5€Aÿ5%AèèýÿÿYÿÐ…ÀtjVèÅþÿÿYYÿ”à@ƒNÿ‰ë	Vè^éÿÿY3öWÿà@_‹Æ^ËÿVèÿÿÿ‹ð…öujèáÏÿÿY‹Æ^ÃjhÈö@èæÿÿ‹u…ö„ø‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@tPè¬èÿÿYj
èàìÿÿYƒeü‹~h…ÿtWÿpà@…ÀuÿhAtWèèÿÿYÇEüþÿÿÿèWjè§ìÿÿYÇEü‹~l…ÿt#WèóúÿÿY;=pAtÿ˜Atƒ?uWèÿøÿÿYÇEüþÿÿÿèVè'èÿÿYèEåÿÿ‹uj
èvëÿÿYËujèjëÿÿYËÿVW¾tã@Vÿ à@…ÀuVècÎÿÿY‹ø…ÿ„^‹5(à@hÀã@WÿÖh´ã@W£%AÿÖh¨ã@W£%AÿÖh ã@W£%AÿÖƒ=%A‹5ˆà@£%Atƒ=%At
ƒ=%At…Àu$¡€à@£%A¡Œà@Ç%A”O@‰5%A£%Aÿ„à@£„Aƒøÿ„Ìÿ5%APÿÖ…À„»è•Ðÿÿÿ5%Aèûÿÿÿ5%A£%Aèûÿÿÿ5%A£%Aèóúÿÿÿ5%A£%AèãúÿÿƒÄ£%Aè¬éÿÿ…ÀtehˆQ@ÿ5%Aè=ûÿÿYÿУ€AƒøÿtHhjèÓåÿÿ‹ðYY…öt4Vÿ5€Aÿ5%Aè
ûÿÿYÿÐ…ÀtjVèçûÿÿYYÿ”à@ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèè™Êÿÿ‹]C=w‹E苀ȷXëu‰]Á}EèP‹E%ÿPè§YY…ÀtŠEjˆEøˆ]ùÆEúYë
3Ɉ]øÆEùA‹EèjÿpÿpEüPQEøPEèjPè~6ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E€}ôt‹Mðƒapý[ÉËÿU‹ìQV‹uVèsàÿÿ‰E‹FY¨‚uè4âÿÿÇ	ƒN ƒÈÿé/¨@t
èâÿÿÇ"ëãS3Û¨t‰^¨„‡‹Nƒàþ‰‰F‹FƒàïƒÈ‰F‰^‰]ü©u,èlÃÿÿƒÀ ;ðtè`ÃÿÿƒÀ@;ðu
ÿuèY…ÀuVè@Y÷FW„€‹F‹>H‰‹N+øI;û‰N~WPÿuè<+ƒÄ‰EüëMƒÈ ‰FƒÈÿëy‹Mƒùÿtƒùþt‹Áƒà‹ÑÁúÁà• *A븘Aö@ tjSSQèŠ>#ƒÄƒøÿt%‹FŠMˆë3ÿGWEPÿuèÍ*ƒÄ‰Eü9}üt	ƒN ƒÈÿë‹E%ÿ_[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü;ýˆAt	G‰}üƒÿrîƒÿƒwjèÚ@Yƒø„4jèÉ@Y…Àu
ƒ=ŒA„ûü„Ahpé@»S¿ %AWè8ƒÄ…Àt
VVVVVèÔÞÿÿƒÄh¾9%AVjÆ=&Aÿà@…Àu&hXé@hûVèN8ƒÄ…Àt3ÀPPPPPèÞÿÿƒÄVèç@YƒøƒÄë2jôÿ<à@‹Ø;Þt$ƒûÿtjEøP4ýŒAÿ6è%YPÿ6Sÿ˜à@_^[ÉÃjè^?YƒøtjèQ?Y…Àuƒ=ŒAuhüè)þÿÿhÿèþÿÿYYËÿU‹ìQSVWÿ5¬+AèÊöÿÿÿ5¨+A‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ‹Þ+ßCƒørwWè5?‹øCY;øsH¸;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+AÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ£¬+A£¨+A…öujX^Ã&3À^Ãjhðö@èaÞÿÿèÈÿÿƒeüÿuèøþÿÿY‰EäÇEüþÿÿÿè	‹Eäè}ÞÿÿÃèoÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@¾àô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@¾èô@W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@Aÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZf9t3À]ËA<Á8PEuï3Ò¹f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹}‹H;ùr	‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@h8@d¡PƒìSVW¡€A1Eø3ÅPEðd£‰eèÇEüh@è*ÿÿÿƒÄ…ÀtU‹E-@Ph@èPÿÿÿƒÄ…Àt;‹@$Áè÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò=À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh0÷@èSÜÿÿè öÿÿ‹@x…ÀtƒeüÿÐë3À@ËeèÇEüþÿÿÿè÷<èlÜÿÿÃh=[@è'óÿÿY£4(AÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F‹V\¡tAW‹}‹ÊS99t‹ØkÛƒÁÚ;ËrîkÀÂ;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéûƒûuƒ`3À@éêƒû„Þ‹N`‰Mø‹M‰N`‹Hƒù…¸‹
hA‹=lA‹Ñù;×}$kÉ‹~\ƒd9‹=hA‹lAB߃Á;Ó|â‹]ü‹‹~d=ŽÀu	ÇFdƒë^=Àu	ÇFdëN=‘Àu	ÇFd„ë>=“Àu	ÇFd…ë.=Àu	ÇFd‚ë=Àu	ÇFd†ë=’ÀuÇFdŠÿvdjÿÓY‰~dëƒ`QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A£<(A£@(A£D(A]ËÿU‹ì‹E‹
tAV9Pt‹ñköuƒÀ;ÆrìkÉM^;Ás9Pt3À]Ãÿ5@(AèÚñÿÿYÃj hP÷@èFÚÿÿ3ÿ‰}ä‰}Ø‹]ƒûLt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa¾8(A¡8(Aë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+HtèŠÙÿÿÇ3ÀPPPPPèÙÿÿƒÄ뮾@(A¡@(Aë¾<(A¡<(Aë
¾D(A¡D(AÇEäPèñÿÿ‰EàY3Àƒ}à„Ø9EàujèÂÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒûtƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒƒûu.‹
hA‰MÜ‹
lA‹hAÊ9MÜ}‹MÜkÉ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿèƒûuÿwdSÿUàYë‹]‹}؃}ätjèTßÿÿYÃSÿUàYƒût
ƒûtƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèèØÿÿËÿU‹ì‹E£L(A]ËÿU‹ì‹E£X(A]ËÿU‹ì‹E£\(A]Ãjhp÷@èiØÿÿƒeüÿuÿuÿ à@‰Eäë/‹Eì‹‹‰Eà3É=À”Á‹ÁËeè}àÀujÿà@ƒeäÇEüþÿÿÿ‹Eäè[ØÿÿËÿU‹ì‹E£`(A]ËÿU‹ìÿ5`(Aè|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹8csmàu*ƒxu$‹@= “t=!“t="“t=@™uèCûÿÿ3À]Âh¾_@ÿTà@3ÀËÿVW3ÿ9=°+AuèCëÿÿ‹5 +A…öu¾bã@Š< w„Àt.…ÿt$<"u	3É…ÿ”Á‹ù¶ÀPèãÿÿY…ÀtFFëÓ< wFŠ„Àuõ_‹Æ^Ã=°+AuèéêÿÿV‹5< AW3ÿ…öuƒÈÿé <=tGVè„YtŠ„ÀuêjGWè!Ùÿÿ‹øYY‰= A…ÿtË‹5< ASëBVèS‹ØC€>=Yt1jSèóØÿÿYY‰…ÀtNVSPè}.ƒÄ…Àt3ÀPPPPPè¿ÔÿÿƒÄƒÇó€>u¹ÿ5< Aè¤Ùÿÿƒ%< Aƒ'Ǥ+A3ÀY[_^Ãÿ5 Aè~Ùÿÿƒ% AƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹UÇ9Et	‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰UŠ¶ÃPFè¿áÿÿY…Àtÿƒ}t
‹MŠÿEˆF‹U‹M„Ût2ƒ}üu©€û t€û	uŸ…ÒtÆBÿƒeü€>„éŠ< t<	uFëóNëã€>„Ѓ}t	‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁuƒ}ütF€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰UŠ„ÀtUƒ}üu< tK<	tG…Ût=¾ÀP…Òt#èÚàÿÿY…Àt
Š‹MÿEˆFÿ‹MŠÿEˆë
è·àÿÿY…ÀtFÿÿ‹UFéVÿÿÿ…ÒtÆB‰Uÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒìS3ÛVW9°+Auèeèÿÿh¾h(AVSˆl)Aÿà@¡ +A‰5( A;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ=ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6Pè$Öÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄH£ A‰5 A3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)AƒìSV‹5´à@W3Û3ÿ;Ãu.ÿÖ‹ø;ûtÇp)Aë#ÿ\à@ƒøxu
jX£p)Aë¡p)Aƒø…;ûuÿÖ‹ø;ûu3ÀéÊ‹Çf9t@@f9uù@@f9uò‹5°à@SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/PèJÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…ÀuÿuüèYÖÿÿY‰]ü‹]üWÿ¬à@‹Ãë\ƒøt;Ãu‚ÿ¨à@‹ð;ó„rÿÿÿ8t
@8uû@8uö+Æ@P‰EøèãÔÿÿ‹øY;ûuVÿ¤à@éEÿÿÿÿuøVWèª+ƒÄVÿ¤à@‹Ç_^[ÉËÿU‹ì3À9Ej”ÀhPÿ¸à@£t)A…Àu]Ã3À@£„*A]ËÿU‹ìƒì¡€AƒeøƒeüSW¿Næ@»»ÿÿ;Çt
…Ãt	÷У„Aë`VEøPÿÌà@‹uü3uøÿÈà@3ðÿ”à@3ðÿÄà@3ðEðPÿÀà@‹Eô3Eð3ð;÷u¾Oæ@»ë…óu‹ÆÁàð‰5€A÷Ö‰5„A^_[ÉËÿU‹ì‹Eƒøþuè¡ÑÿÿÇ	3À]ÃV3ö;Æ|;*ArèƒÑÿÿVVVVVÇ	èÑÿÿƒÄ3Àë‹ÈƒàÁù‹ *AÁà¾Dƒà@^]á€AƒÈ3É9x)A”Á‹ÁÃÌÌÌÌÌÌÌÌÌ‹L$÷Át$ŠƒÁ„ÀtN÷Áuï¤$¤$‹ºÿþþ~Ѓðÿ3ƒÁ©tè‹Aü„Àt2„ät$©ÿt©ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u3ÛW‹};óu;ûv‹E;Ãt‰3À郋E;ÃtƒÿÿÿÿÿvècÐÿÿj^SSSSS‰0èìÏÿÿƒÄ‹ÆëVÿuMðèã·ÿÿ‹Eð9X…œf‹E¹ÿf;Áv6;ót;ûvWSV訳ÿÿƒÄèÐÿÿÇ*èÐÿÿ‹8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èåÏÿÿj"^SSSSS‰0ènÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿMQSWVjMQS‰]ÿpÿ°à@;Ãt9]…^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèѲÿÿƒÄéOÿÿÿ‹ÿU‹ìjÿuÿuÿuÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿuMð誶ÿÿ¶E‹Mð‹‰È·A%€€}üt‹MøƒapýÉËÿU‹ìjÿuè¹ÿÿÿYY]ÃÌV‹D$Àu(‹L$‹D$3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$‹D$ÑéÑÛÑêÑØÉuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$wr;D$v	N+D$T$3Û+D$T$÷Ú÷؃ڋʋӋًȋÆ^ƒ%€*AÃÌÌÌSVW‹T$‹D$‹L$URPQQh°i@dÿ5¡€A3ĉD$d‰%‹D$0‹X‹L$,3‹pƒþþt;‹T$4ƒúþt;òv.4v\³‹‰Hƒ{uÌh‹Cè1¹‹Cè1ë°dƒÄ_^[ËL$÷A¸t3‹D$‹H3ÈèµÿÿU‹hÿpÿpÿpè>ÿÿÿƒÄ]‹D$‹T$‰¸ÃU‹L$‹)ÿqÿqÿq(èÿÿÿƒÄ]ÂUVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_03À3Û3É3Ò3ÿÿæU‹ìSVWjjhWj@Qè—Q_^[]ÃU‹l$RQÿt$è´þÿÿƒÄ]Âjh÷@èÍÿÿƒeä‹u;5p*Aw"jèdÔÿÿYƒeüVèaY‰EäÇEüþÿÿÿè	‹Eäè)ÍÿÿÃjè_ÓÿÿYËÿU‹ìV‹uƒþà‡¡SW‹=dà@ƒ=t)Auè!íÿÿjèoëÿÿhÿ轶ÿÿYY¡„*Aƒøu…öt‹Æë3À@PëƒøuVèSÿÿÿY…Àu…öuFƒÆƒæðVjÿ5t)Aÿ׋؅Ûu.j^9€)AtÿuèBôÿÿY…Àt‹ué{ÿÿÿèêËÿÿ‰0èãËÿÿ‰0_‹Ã[ëVèôÿÿYèÏËÿÿÇ3À^]Ãjh°÷@èÌÿÿ‹]…ÛuÿuèÿÿÿYéÌ‹u…öuSèÏÿÿYé·ƒ=„*A…“3ÿ‰}äƒþà‡ŠjèÓÿÿY‰}üSè6Y‰Eà;Ç„ž;5p*AwIVSPèƒÄ…Àt‰]äë5Vèç	Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$Sèæ‰EàSPèƒÄ9}äuH;÷u3öF‰uƒÆƒæð‰uVWÿ5t)Aÿdà@‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ#Sÿuà迃ÄÇEüþÿÿÿè.ƒ}àu1…öuFƒÆƒæð‰uVSjÿ5t)AÿÔà@‹øë‹u‹]jèHÑÿÿYË}ä…ÿ…¿9=€)At,Vè¤òÿÿY…À…ÒþÿÿèPÊÿÿ9}àul‹ðÿ\à@PèûÉÿÿY‰ë_…ÿ…ƒè+Êÿÿ9}àthÇëq…öuFVSjÿ5t)AÿÔà@‹ø…ÿuV9€)At4Vè;òÿÿY…ÀtƒþàvÍVè+òÿÿYèßÉÿÿÇ3ÀècÊÿÿÃèÌÉÿÿé|ÿÿÿ…ÿuè¾Éÿÿ‹ðÿ\à@PènÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹MS3Û;Ëv(jà3ÒX÷ñ;Esè‰ÉÿÿSSSSSÇèÉÿÿƒÄ3ÀëA¯MVW‹ñ9]tÿuèÈ)Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVjßSèȬÿÿƒÄ‹Ç_^[]ËÿU‹ì‹
h*A¡l*AkÉÈë‹U+Púr	ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹uW‹þ+yƒÆüÁï‹ÏiÉŒD‰Mð‹I‰MüöÁ…ÓS1‹‰Uô‹Vü‰Uø‹Uô‰]öÂutÁúJƒú?vj?Z‹K;KuB»€ƒú s‹ÊÓëL÷Ó!\¸Dþ	u#‹M!ëJàÓëL÷Ó!œ¸Äþ	u‹M!Y‹]‹S‹[‹MüMô‰Z‹U‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô…+uø‹]øÁûj?‰uK^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M‹q;qu;¾€ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸ÄþLu‹M!q‹M‹q‹I‰N‹M‹q‹I‰N‹uë‹]ƒ}ôu;Ú„€‹MðÑ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€}u‹Ê»€Óë‹M	»€‹ÊÓëD¸D	ë)€}uJເÓë‹M	YJ຀ÓꄸÄ	‹Eü‰‰D0ü‹Eðÿ…ó¡|)A…À„Ø‹
|*A‹5¼à@h@ÁáH»€SQÿÖ‹
|*A¡|)Aº€Óê	P¡|)A‹@‹
|*Aƒ¤ˆÄ¡|)A‹@þHC¡|)A‹H€yCu	ƒ`þ¡|)AƒxÿueSjÿpÿÖ¡|)Aÿpjÿ5t)Aÿ`à@‹
h*A¡|)AkÉ‹l*A+ÈLìQHQPèí+‹EƒÄÿ
h*A;|)Avƒm¡l*A£t*A‹E£|)A‰=|*A[_^Éáx*AV‹5h*AW3ÿ;ðu4ƒÀkÀPÿ5l*AWÿ5t)AÿÔà@;Çu3Àëxƒx*A‹5h*A£l*Akö5l*AhÄAjÿ5t)Aÿdà@‰F;ÇtÇjh hWÿØà@‰F;ÇuÿvWÿ5t)Aÿ`à@뛃Nÿ‰>‰~ÿh*A‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ„0Dj?‰EøZ‰@‰@ƒÀJuôj‹ûhÁçyh€WÿØà@…ÀuƒÈÿé—p‰Uü;úwC‹Ê+ÏÁéGAƒHøÿƒˆìÿü‰üïÿÿÇ@üð‰PÇ€èðIuË‹Uü‹EøøO‰H‰AJ‰H‰AƒdžD3ÿG‰¼žÄŠFCŠÈþÁ„À‹EˆNCu	xº€‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì‹M‹ASV‹uW‹}‹×+QƒÆÁê‹ÊiÉŒD‰Mô‹OüƒæðI;ñ|9ü‹‰M‰]üŽUöÃ…EÙ;ó;‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC»€ƒù sÓë‹MøL÷Ó!\Dþ	u&‹M!ëƒÁàÓë‹MøL÷Ó!œÄþ	u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}üŽ¥‹}ü‹MÁÿOL1üƒÿ?vj?_‹]ôû‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s€}u‹Ï»€Óë‹M	DD‹Ïë €}uOເÓë‹M	Y„ÄO຀Óê	‹U‹MüD2ü‰‰Lüë‹UF‰Bü‰D2øé<3Àé8/‹])uN‰Kü\3ü‹uÁþN‰]‰Küƒþ?vj?^öEü…€‹uüÁþNƒþ?vj?^‹O;OuB»€ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ëNàÓëL÷Ó!œÄþ	u‹M!Y‹]‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Môñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s€}u‹Î¿€Óï‹M	9DD‹Îë €}uNà¿€Óï‹M	y„ÄN຀Óê	‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A‹MkÀl*AƒÁƒáð‰MðÁùSIƒù VW}ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A‹Ùë‹S‹;#Uø#þ×u
ƒÃ‰];Ørè;Øu‹l*Aë‹S‹;#Uø#þ×u
ƒÃ‰];Ùrè;Ùu[ëƒ{u
ƒÃ‰];Ørð;Øu1‹l*Aë	ƒ{u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé	Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰t*A‹C‹‰Uüƒúÿt‹ŒÄ‹|D#Mø#þÏu)ƒeü‹ÄHD‹9#Uø#þ×uÿEü‹‘„ƒÁëç‹Uü‹ÊiÉŒD‰Mô‹LD3ÿ#Îu‹ŒÄ#Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„‹J;Ju\ƒÿ »€}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]!ë,OàÓë‹MüŒˆÄ|8÷Ó!þ‰]ìu‹]‹Mì!Kë‹]ƒ}ø‹J‹z‰y‹J‹z‰y„‹Môñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆMþÁƒþ ˆL}#€}u¿€‹ÎÓï	;‹Î¿€Óï‹Mü	|ˆDë)€}u
Nà¿€Óï	{‹Mü¼ˆÄNྀÓî	7‹Mø…Ét‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu;|)Au‹Mü;
|*Auƒ%|)A‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷uèQ¾ÿÿWWWWWÇèÙ½ÿÿƒÄÃëBöFƒt7VèÈÂÿÿV‹ØèÄ(VèO¼ÿÿPèë'ƒÄ…À}ƒËÿë‹F;Çt
PènÁÿÿY‰~‰~‹Ã_^[]ÃjhÐ÷@è3¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;ÇuèνÿÿÇWWWWWèV½ÿÿƒÄƒÈÿëöF@t‰~‹Eäè6¾ÿÿÃVè ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿèëÕ‹uVèY ÿÿYËÿU‹ì¸äè8*¡€A3ʼnEü‹EV3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé;Æu'èD½ÿÿ‰0è*½ÿÿVVVVVÇè²¼ÿÿƒÄƒÈÿé¾SW‹}‹ÇÁø4… *A‹ƒçÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&èÛ¼ÿÿ3ö‰0迼ÿÿVVVVVÇèG¼ÿÿƒÄéCö@ tjjjÿuècƒÄÿuèÕêÿÿY…À„‹öD€„è‹Öÿÿ‹@l3É9H…åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@…À„`3É9 åÿÿt„Û„PÿÜà@‹4åÿÿ‰…åÿÿ3À‰…<åÿÿ9E†B‰…DåÿÿŠ…'åÿÿ„À…gŠ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹ǃx8tŠP4ˆUôˆMõƒ`8jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥j…@åÿÿSPè<(ƒÄƒøÿ„±Cÿ…DåÿÿëjS…@åÿÿPè(ƒÄƒøÿ„3ÀPPjMôQj@åÿÿQPÿµåÿÿCÿ…Dåÿÿÿ°à@‹ð…ö„\j…<åÿÿPVEôP‹…(åÿÿ‹ÿ4ÿ˜à@…À„)‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒƒ½ åÿÿ„Íj…<åÿÿPjEôP‹…(åÿÿ‹ÆEô
ÿ4ÿ˜à@…À„Ѓ½<åÿÿŒÏÿ…0åÿÿÿ…8åÿÿéƒ<t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%%Yf;…@åÿÿ…hƒ…8åÿÿƒ½ åÿÿt)j
XP‰…@åÿÿèø$Yf;…@åÿÿ…;ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé'‹Šÿ…8åÿÿˆT4‹‰D8é3É‹Çö@€„¿‹…4åÿÿ‰@åÿÿ„Û…ʉ…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ+4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿr‹؅Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„B‹…,åÿÿ…8åÿÿ;ÃŒ:‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ9M†M답(åÿÿ‹Dåÿÿƒ¥<åÿÿ+4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþrµ‹Ø…Håÿÿ+Øj…,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@…À„b‹…,åÿÿ…8åÿÿ;ÃŒZ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@9M†|‹Dåÿÿƒ¥<åÿÿ+4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰ƽ<åÿÿ¨r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéýÿ°à@‹Ø;Þ„—j…,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ÿ4ÿ˜à@…Àtµ,åÿÿ;ÞËëÿ\à@‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@…Àt‹…,åÿÿƒ¥@åÿÿ‰…8åÿÿëÿ\à@‰…@åÿÿƒ½8åÿÿulƒ½@åÿÿt-j^9µ@åÿÿu貶ÿÿÇ	躶ÿÿ‰0ë?ÿµ@åÿÿ辶ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èr¶ÿÿÇèz¶ÿÿƒ ƒÈÿë‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èØÿÿÉÃjhð÷@脶ÿÿ‹Eƒøþuè>¶ÿÿƒ è#¶ÿÿÇ	ƒÈÿé3ÿ;Ç|;*Ar!è¶ÿÿ‰8èûµÿÿÇ	WWWWW胵ÿÿƒÄëÉ‹ÈÁù *A‹ðƒæÁ拾L1ƒát¿Pè9$Y‰}ü‹öD0tÿuÿuÿuè.øÿÿƒÄ‰Eäë蘵ÿÿÇ	è µÿÿ‰8ƒMäÿÇEüþÿÿÿè	‹Eäè¶ÿÿÃÿuèƒ$YÃjhø@訵ÿÿ‹EƒøþuèOµÿÿÇ	ƒÈÿéª3Û;Ã|;*Arè.µÿÿÇ	SSSSS趴ÿÿƒÄëЋÈÁù< *A‹ðƒæÁ拾LƒátÆPèl#Y‰]ü‹öDt1ÿuèà"YPÿäà@…Àuÿ\à@‰Eäë‰]ä9]ätèÍ´ÿÿ‹Mä‰è°´ÿÿÇ	ƒMäÿÇEüþÿÿÿè	‹Eäè#µÿÿÃÿuè¢#YËÿU‹ìƒìS3Û9]uèr´ÿÿSSSSSÇèú³ÿÿƒÄ3ÀëjV‹u;óuèN´ÿÿSSSSSÇèÖ³ÿÿƒÄë9ur3Àë>ÿuMðèÆ›ÿÿ‹MôFÿ9YtH9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìjÿuÿuèUÿÿÿƒÄ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9]u3Àéç;ót9]w襳ÿÿj^SSSSS‰0è.³ÿÿƒÄ‹ÆéÀ9]uˆëÉW‹};ûuˆèt³ÿÿj^SSSSS‰0èý²ÿÿƒÄé(ÿuMìèóšÿÿ‹Eð9XuÿuWÿuVè£
ƒÄéLƒ}ÿ‹U‹ÆuŠˆ@G:ËtJuó늈@G:ËtJtÿMuî9]uˆ@;Ó…È8tƒ}u5xÿ‰}ü;þrEìP‹Eü¶PèоÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…Ã}ÿuZ‹Eƒøv:|þ‰};þr!EìP‹E¶P茾ÿÿYY…ÀtÿM9usâ‹E‹Ï+MöÁtˆëˆ\ÿ8]øt‹Eôƒ`pýjPXéˆèS²ÿÿj"^SSSSS‰0èܱÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þrEìP‹E¶Pè	¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨tˆèð±ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝuPèµÿÿY]ËÿU‹ìƒì¡€A3ʼnEüSV3ÛW‹ñ9„)Au8SS3ÿGWhdê@hSÿðà@…Àt‰=„)Aëÿ\à@ƒøxu
Ç„)A9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)Aƒø„¬;Ĥƒø…̉]ø9] u‹‹@‰E ‹5ìà@3À9]$SSÿu•ÀÿuÅPÿu ÿÖ‹ø;û„~Cjà3ÒX÷÷ƒør7D?=wèŽ#‹Ä;ÃtÇÌÌëPèäÿÿY;Ãt	ÇÝ݃À‰Eôë‰]ô9]ô„>Wÿuôÿuÿujÿu ÿÖ…À„ã‹5ðà@SSWÿuôÿuÿuÿ֋ȉMø;Ë„Â÷Et)9]„°;M§ÿuÿuWÿuôÿuÿuÿÖé;Ë~Ejà3ÒX÷ñƒør9D	=wèÏ"‹ô;ótjÇÌ̃ÆëPèJãÿÿY;Ãt	ÇÝ݃À‹ðë3ö;ótAÿuøVWÿuôÿuÿuÿðà@…Àt"SS9]uSSëÿuÿuÿuøVSÿu ÿ°à@‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè  Y‰Eìƒøÿu3Àé!;E „ÛSSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@SSÿuPÿuÿuÿÖ‰Eø;Ãu3öé·~=ƒøàw8ƒÀ=wè¹!‹ü;ûtÝÇÌ̃ÇëPè4âÿÿY;Ãt	ÇÝ݃À‹øë3ÿ;ût´ÿuøSWè0’ÿÿƒÄÿuøWÿuÿuôÿuÿuÿÖ‰Eø;Ãu3öë%ÿuEøÿuPWÿu ÿuìè‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿuÿuÿuÿuÿuÿuÿèà@‹ð9]ôt	ÿuô蘱ÿÿY‹Eð;Ãt9EtPè…±ÿÿY‹Æeà_^[‹Mü3Íè—•ÿÿÉËÿU‹ìƒìÿuMðè‘•ÿÿÿu(Mðÿu$ÿu ÿuÿuÿuÿuÿuè(üÿÿƒÄ €}üt‹MøƒapýÉËÿU‹ìQQ¡€A3ʼnEü¡ˆ)ASV3ÛW‹ù;Ãu:EøP3öFVhdê@Vÿøà@…Àt‰5ˆ)Aë4ÿ\à@ƒøxu
jX£ˆ)A롈)Aƒø„Ï;Äǃø…è‰]ø9]u‹‹@‰E‹5ìà@3À9] SSÿu•ÀÿuÅPÿuÿÖ‹ø;û„«~<ÿðÿÿw4D?=wèÒ‹Ä;ÃtÇÌÌëPèPàÿÿY;Ãt	ÇÝ݃À‹Ø…Ûti?PjSèNÿÿƒÄWSÿuÿujÿuÿÖ…ÀtÿuPSÿuÿøà@‰EøSèÉúÿÿ‹EøYëu3ö9]u‹‹@‰E9]u‹‹@‰EÿuèAYƒøÿu3ÀëG;EtSSMQÿuPÿuèi‹ðƒÄ;ót܉uÿuÿuÿuÿuÿuÿôà@‹ø;ótV膯ÿÿY‹Çeì_^[‹Mü3Í蘓ÿÿÉËÿU‹ìƒìÿuMðè’“ÿÿÿu$Mðÿu ÿuÿuÿuÿuÿuèþÿÿƒÄ€}üt‹MøƒapýÉËÿU‹ìV‹u…ö„ÿvè¯ÿÿÿvè¯ÿÿÿvè¯ÿÿÿvèþ®ÿÿÿvèö®ÿÿÿvèî®ÿÿÿ6èç®ÿÿÿv èß®ÿÿÿv$è×®ÿÿÿv(èÏ®ÿÿÿv,èÇ®ÿÿÿv0è¿®ÿÿÿv4è·®ÿÿÿv诮ÿÿÿv8觮ÿÿÿv<蟮ÿÿƒÄ@ÿv@è”®ÿÿÿvD茮ÿÿÿvHè„®ÿÿÿvLè|®ÿÿÿvPèt®ÿÿÿvTèl®ÿÿÿvXèd®ÿÿÿv\è\®ÿÿÿv`èT®ÿÿÿvdèL®ÿÿÿvhèD®ÿÿÿvlè<®ÿÿÿvpè4®ÿÿÿvtè,®ÿÿÿvxè$®ÿÿÿv|è®ÿÿƒÄ@ÿ¶€è®ÿÿÿ¶„è®ÿÿÿ¶ˆèø­ÿÿÿ¶Œèí­ÿÿÿ¶èâ­ÿÿÿ¶”è×­ÿÿÿ¶˜èÌ­ÿÿÿ¶œèÁ­ÿÿÿ¶ è¶­ÿÿÿ¶¤è«­ÿÿÿ¶¨è ­ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;HAtPè}­ÿÿY‹F;LAtPèk­ÿÿY‹v;5PAtVèY­ÿÿY^]ËÿU‹ìV‹u…öt~‹F;TAtPè7­ÿÿY‹F;XAtPè%­ÿÿY‹F;\AtPè­ÿÿY‹F;`AtPè­ÿÿY‹F;dAtPèï¬ÿÿY‹F ;hAtPèݬÿÿY‹v$;5lAtVèˬÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹};ûwè=©ÿÿj^‰0SSSSSèƨÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèö¨ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹uƒÉÿIƒÁŠ
Àt	ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9]u3À_^[]Ã;ót‹};ûwèh¨ÿÿj^‰0SSSSSèñ§ÿÿƒÄ‹ÆëÕ9]uˆëÊ‹U;Óuˆëу}ÿ‹ÆuŠ
ˆ@B:ËtOuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹EjPˆ\ÿXéxÿÿÿˆèî§ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹};ûwèȧÿÿj^‰0SSSSSèQ§ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆè§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷Âu<‹:u.
Àt&:au%
ätÁè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ÂtŠƒÂ:uçƒÁ
ÀtÜ÷Ât¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u‹M‹}‹Á‹ÑÆ;þv;ø‚¤ùrƒ=ˆ*AtWVƒçƒæ;þ^_u^_]é,÷ÇuÁéƒâƒùr*ó¥ÿ$•ä‘@‹ÇºƒérƒàÈÿ$…ø@ÿ$ô‘@ÿ$x‘@‘@4‘@X‘@#ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•ä‘@I#ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•ä‘@#ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•ä‘@IÛ‘@È‘@À‘@¸‘@°‘@¨‘@ ‘@˜‘@‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Düðøÿ$•ä‘@‹ÿô‘@ü‘@’@’@‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃIŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Çu$Áéƒâƒùr
ýó¥üÿ$•€“@‹ÿ÷Ùÿ$0“@I‹Çºƒùrƒà+Èÿ$…„’@ÿ$€“@”’@¸’@à’@ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•€“@IŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•€“@ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•€“@I4“@<“@D“@L“@T“@\“@d“@w“@‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ‰Dðøÿ$•€“@‹ÿ“@˜“@¨“@¼“@‹E^_ÉÊFˆG‹E^_ÉÃIŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹UIŠ
Àt	ƒÂ«$ëñ‹u‹ÿŠ
ÀtƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹EV‹u‰Eø‹EWV‰EüèƒÏÿY;Çuè£ÿÿÇ	‹Ç‹×ëJÿuMüQÿuøPÿá@‰Eø;Çuÿ\à@…Àt	Pè÷¢ÿÿYëÏ‹ÆÁø‹… *AƒæÁæD0€ ý‹Eø‹Uü_^ÉÃjh0ø@èë¢ÿÿƒÎÿ‰u܉uà‹Eƒøþu蜢ÿÿƒ è¢ÿÿÇ	‹Æ‹ÖéÐ3ÿ;Ç|;*Ar!èr¢ÿÿ‰8èX¢ÿÿÇ	WWWWWèà¡ÿÿƒÄëÈ‹ÈÁù *A‹ðƒæÁ拾L1ƒáu&è1¢ÿÿ‰8è¢ÿÿÇ	WWWWW蟡ÿÿƒÄƒÊÿ‹Âë[PèpY‰}ü‹öD0tÿuÿuÿuÿuè©þÿÿƒÄ‰E܉UàëèÉ¡ÿÿÇ	èÑ¡ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè‹EÜ‹Uàè.¢ÿÿÃÿuè­YËÿU‹ìÿ Ahè¹£ÿÿY‹M‰A…Àt
ƒIÇAëƒIA‰AÇA‹Aƒa‰]ËÿU‹ìƒìSVWè¹ÿÿƒeüƒ=)A‹Ø…Žhô@ÿœà@‹ø…ÿ„*‹5(à@hôó@WÿÖ…À„PèL¸ÿÿÇ$äó@W£)AÿÖPè7¸ÿÿÇ$Ðó@W£”)AÿÖPè"¸ÿÿÇ$´ó@W£˜)AÿÖPè
¸ÿÿY£ )A…Àthœó@WÿÖPèõ·ÿÿY£œ)A¡œ)A;ÃtO9 )AtGPèS¸ÿÿÿ5 )A‹ðèF¸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQjMìQjPÿ×…ÀtöEôu	M ë9¡”)A;Ãt0Pè¸ÿÿY…Àt%ÿЉEü…Àt¡˜)A;ÃtPèæ·ÿÿY…ÀtÿuüÿЉEüÿ5)AèηÿÿY…ÀtÿuÿuÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î|ƒù~ƒùu¡D Aë(¡D A‰
D Aë讟ÿÿVVVVVÇè6ŸÿÿƒÄƒÈÿ^]ÃjhPø@èÕŸÿÿ3À‹]3ÿ;ß•À;ÇuètŸÿÿÇWWWWWèüžÿÿƒÄƒÈÿëSƒ=„*Au8jèõ¦ÿÿY‰}üSèÖÿÿY‰Eà;Çt‹süƒî	‰uäë‹uäÇEüþÿÿÿè%9}àuSWÿ5t)Aÿá@‹ð‹Æè•ŸÿÿÃ3ÿ‹]‹uäjèÃ¥ÿÿYÃjèÿˆÿÿYËÿU‹ìì(¡€A3ʼnEüöAVtj
èÓ½ÿÿYèªÄÿÿ…Àtjè¬ÄÿÿYöA„ʉ…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ­¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ‰µèýÿÿ‹@üjP‰…äýÿÿ…ØüÿÿjPèªÿÿ…ØüÿÿƒÄ‰…(ýÿÿ…0ýÿÿjÇ…Øüÿÿ@‰µäüÿÿ‰…,ýÿÿÿTà@…(ýÿÿPÿPà@jèmŠÿÿÌÌÌU‹ìSVWUjjh˜™@ÿuèV"]_^[‹å]ËL$÷A¸t2‹D$‹Hü3Èè"…ÿÿU‹h‹P(R‹P$RèƒÄ]‹D$‹T$‰¸ÃSVW‹D$UPjþh ™@dÿ5¡€A3ÄPD$d£‹D$(‹X‹pƒþÿt:ƒ|$,ÿt;t$,v-4v‹³‰L$‰Hƒ|³uh‹D³èI‹D³è_ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y ™@u‹Q‹R9Qu¸ÃSQ»”AëSQ»”A‹L$‰K‰C‰kUQPXY]Y[ÂÿÐËÿU‹ìƒìVWÿuMìè%„ÿÿ‹E‹u3ÿ;Çt‰0;÷u,èmœÿÿWWWWWÇèõ›ÿÿƒÄ€}øt‹Eôƒ`pý3ÀéØ9}tƒ}|Ƀ}$ËMìSŠ‰}ü~ƒ¹¬~EìP¶ÃjPè¹ÿÿ‹MìƒÄ닑ȶ÷Bƒà…ÀtŠGëÇ€û-uƒMë€û+uŠG‹E…ÀŒKƒø„Bƒø$9…Àu*€û0t	ÇE
ë4Š·É¶ÒÁáÊ9MuHë·Ñ9Ut
@f¶·Éf;ËuÇ·É9Mu8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìjÿuÿuè2ÿÿÿƒÄ]ÃÌÌÌBÿ[ä$d$3ÀŠD$S‹ØÁà‹T$÷ÂtŠ
ƒÂ:ËtÏ„ÉtQ÷ÂuëØW‹ÃÁãVØ‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂáu%tÓ%uæ€uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@‹ÿU‹ì‹US3Û;ÓuèH{ÿÿSSSSSÇèÐzÿÿƒÄƒÈÿë 8tß‹M;ËtØ‹;ÃtÒ8tÎSQRèƒÄ[]ËÿU‹ìƒì‹UV‹ujþX‰Eì‰Uä;ðuèÿzÿÿƒ èäzÿÿÇ	ƒÈÿéˆS3Û;ó|;5*Ar'èÕzÿÿ‰è»zÿÿSSSSSÇ	èCzÿÿƒÄƒÈÿéQ‹ÆÁøW<… *A‹ƒæÁæÆŠHöÁuèzÿÿ‰èuzÿÿÇ	ëjúÿÿÿwP‰]ð;Ó„öÁ…ÿ9]t7Š@$ÀÐøˆEþ¾ÀHjYtHu‹Â÷Шtƒâþ‰U‹E‰Eôé‹Â÷Шu!è#zÿÿ‰è	zÿÿÇSSSSSè‘yÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuè|ÿÿY‰Eô;ÃuèÑyÿÿÇèÙyÿÿǃÈÿéhjSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEðÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEðÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEðÆD&
SMèQÿuP‹ÿ4ÿ,á@…À„{‹Mè;ËŒp;M‡g‹MðDö€„æ€}þ„;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ЋMŠ<„®<
tˆCA‰Mé‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEjEèPjEÿP‹ÿ4ÿ,á@…Àu
ÿ\à@…ÀuEƒ}èt?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö@u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð…À„ÈKŠ„ÉxCé†3À@¶Éëƒø;]ôrK¶@€¹àAt芶ʾ‰àA…Éu
è|wÿÿÇ*ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ|	Š‹ˆT%Cƒøu	Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿuSÿuôjhéýÿìà@‰Eð…Àu4ÿ\à@Pè!wÿÿYƒMìÿ‹Eô;EtPèUzÿÿY‹Eìƒøþ…‹‹Eð郋Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ‹E·fƒù„×fƒù
tf‰CC@@‰Eé´‹MðƒÁþ;ÁsHfƒ9
u
ƒÀ‰Ej
鎉M鄃EjEèPjEøP‹ÿ4ÿ,á@…Àu
ÿ\à@…Àu[ƒ}ètU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹f‰CC+]ô‰]ðé‘þÿÿÿ\à@j^;ÆuèuuÿÿÇ	è}uÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhøø@è‹uÿÿ‹EƒøþuèEuÿÿƒ è*uÿÿÇ	ƒÈÿé¾3ö;Æ|;*Ar!èuÿÿ‰0èuÿÿÇ	VVVVVèŠtÿÿƒÄëÉ‹ÈÁù *A‹øƒçÁ狾L9ƒát¿¹ÿÿÿ;MÉAuèÎtÿÿ‰0è´tÿÿÇë°PèãÿÿY‰uü‹öD8tÿuÿuÿuè~ùÿÿƒÄ‰Eäëè~tÿÿÇ	è†tÿÿ‰0ƒMäÿÇEüþÿÿÿè	‹EäèêtÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ‰]Ôt	‰]ØÆEÿë
ÇE؈]ÿEàPè
Y…Àt
SSSSSènrÿÿƒÄ‹M¸€…Èu÷Á@u9Eàt€Mÿ€‹Áƒà+úÀ¿€tGHt.Ht&èÓsÿÿ‰ƒÿè¶sÿÿj^SSSSS‰0è?sÿÿƒÄé‰UøëöÁt÷ÁuîÇEø@ë‰}ø‹EjY+Át7+Át*+Át+Átƒè@u¡9}ø”À‰EðëÇEðëÇEðëÇEðë‰]ð‹Eº#¹;Á¿;t0;Ãt,;Çt=„”=…@ÿÿÿÇEìë/ÇEìë&ÇEìë=t=t`;Â…ÿÿÿÇEì‹EÇEô€…Çt‹
 A÷Ñ#M„ÉxÇEô¨@tMôMøƒMð©t	}ô¨ tMôëÇEì릨tMôè£áÿÿ‰ƒøÿuèjrÿÿ‰ƒÿèMrÿÿÇ鎋E‹=á@SÿuôÇÿuìEÐPÿuðÿuøÿuÿ׉Eäƒøÿum‹Mø¸À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿuÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@PèÛqÿÿYè¯qÿÿ‹étÿuäÿ@à@;ÃuD‹6‹ÆÁø‹… *AƒæÁæD0€ þÿ\à@‹ðVè˜qÿÿYÿuäÿá@;óu°è_qÿÿÇ
룃øu€Mÿ@ë	ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹ÐƒàÁú‹• *AYÁàYŠMÿ€ÉˆL‹‹ÐƒàÁú‹• *AÁàD$€ €ˆMý€eýHˆMÿ…€öÁ€„±öEtqjƒÏÿWÿ6裃Ä‰Eè;ÇuèÖpÿÿ8ƒtMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ…Àu€}üu‹Eè™RPÿ6è ƒÄ;ÇtÃSSÿ6èFƒÄ;Çt³öEÿ€„0¿@¹@…}u‹Eà#Çu	Më	E‹E#Ç;ÁtD=t)=@t"=t)=@t"=t=@uÆEþë‹M¸#È;Èu	ÆEþëˆ]þ÷E„µöEÿ@‰]è…¨‹Eø¹À#Á=@„·=€tw;Á…„‹Eì;Æyƒøvƒøv0ƒø…f¾Eþ3ÿH„&H…RÇEèÿþÇEìéjSSÿ6è8ÌÿÿƒÄÂtÇSSSÿ6è'Ìÿÿ#ƒÄƒøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄƒøÿ„uþÿÿƒøtkƒø…­}èuYÆEþéÜ‹Eì;Æуø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ„CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘éþÿÿ‹Eè%ÿÿ=þÿuÿ6èß×ÿÿYè¤nÿÿj^‰0‹Æéd=ÿþuSjÿ6èXƒÄƒøÿ„ÀýÿÿÆEþëASSÿ6è=ƒÄë™ÇEèÇEì‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *AƒàÁàD$Š2Mþ€á0‹‹ÈÁù‹ *AƒàÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹ÈƒàÁù‹ *AÁàD€ ‹}ø¸À‹Ï#È;Èu|öEtvÿuäÿá@SÿuôEÐjPÿuðçÿÿÿWÿuÿá@ƒøÿu4ÿ\à@Pè›mÿÿ‹‹ÈƒàÁù‹ *AÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *AƒæÁ手Ã_^[ÉÃjhù@èomÿÿƒMäÿ3ö‰uà3À9u•À;Æuè	mÿÿÇVVVVVè‘lÿÿƒÄƒÈÿër‰uüÿuj@ÿuÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè‹}Ü;þt<è¹lÿÿ‰8ë¿3ö9uàt+9uÜt‹EäÁø‹MäƒáÁá‹… *AD€ þÿuäèÛÿÿYËEäèmÿÿËÿU‹ìQQV3ö9uuèelÿÿVVVVVÇèíkÿÿƒÄƒÈÿëJ9utÞÿuEøPEüPÿuÿuè|ƒÄƒøÿtØÿuøÿuüÿujèUÿuü‹ðè}oÿÿÿuøèuoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èåkÿÿSSSSSÇèmkÿÿƒÄƒÈÿéá8tÜ‹E;ÃtÕ‹;ÃtÏ8tËVj\Wèj/W‹ðè
ƒÄ;Ã…;ó…ƒj:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèímÿÿ‹øƒÄ‰}ü;û„­htô@VWèkÃÿÿƒÄ…Àt
SSSSSè¯iÿÿƒÄÿuVWèØÁÿÿƒÄ…Àt
SSSSSè‘iÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.VèhYY…Àt,Sÿuüè
YY…À…ìÿuÿuÿuüè`þÿÿƒÄ‰EðéÓÿuüè–™ÿÿ‹ðƒÆjVè:mÿÿƒÄ‰Eø;ÃuƒÈÿé½ÿuüVPè¸ÂÿÿƒÄ…Àt
SSSSSèühÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèvjÿÿ‹‰Eì‹Eø+÷ðÇEôìA‹Eôÿ0VWèrÂÿÿƒÄ…Àt
SSSSSè¶hÿÿƒÄSÿuøè]	YY…Àtƒmô}ôàA}Äëè jÿÿÿu‹Mìÿu‰ÿuøè”ýÿÿƒÄ‰Eðÿuøèlmÿÿ‹}Y9}üt	ÿuüè[mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒÄ‰UìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u‹}+ðúˆÆ;󆼻Sjÿ4á@Pÿdà@‰Eü…ÀuèciÿÿÇèXiÿÿ‹_^[ÉÃh€ÿuèŠYY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèFYYÿuüjÿ4á@Pÿ`à@3Ûé†èóhÿÿƒ8uèÖhÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿuÿuèÅÿÿ#ƒÄƒøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èwhÿÿÇ
èhÿÿ‹ðÿ\à@‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒÄƒøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèhÿÿÇ	ƒÈÿëMWÿujÿuPÿá@‹øƒÿÿuÿ\à@ë3À…ÀtPèhÿÿYƒÈÿë‹ÆÁø‹… *AƒæÁæD0€ ý‹Ç_^]ËÿU‹ìS‹]V‹u‹ÆÁø… *A‹ƒæÁæ0ŠA$ÀW¶y¾Àç€Ñøû@tPû€tBût&ûtûu=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸€]Ã÷ØÀ%À@]ËÿU‹ì‹EV3ö;ÆuèêfÿÿVVVVVÇèrfÿÿƒÄjXë
‹
d*A‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~	ƒøuÆEÿ‹E‰Eðë8èfÿÿ‰èƒfÿÿSSSSSÇèfÿÿƒÄƒÈÿé®@8uûH8tÆ ‹Á8uëVjD^VE˜SPèÔIÿÿ‰u˜‹5*AƒÄ;ót+Fÿ‹È‹ÐÁù‹ *AƒâÁâ8\uNH;óuà;óŒ@þ23ƒ4‹ÆkÀƒÀf‰EÊ·ÀjPèghÿÿYY‰EÌ;Ä;ó‰0‹EÌH|0‰]ø~9‹Eø‹ÐƒàÁúÁà• *AŠPöÂuˆ‹‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×}ˆƒÿBAƒÀëäÇEôèjeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿuÿà@‹ðÿ\à@ÿuÌ‹øè‘hÿÿY;óu	Wè?eÿÿYëXƒ}uSè¤Qÿÿ‹5á@9]ujÿÿuÜÿà@EìPÿuÜÿà@‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹ÃëèÄdÿÿÇƒÈÿ^_[ÉËÿU‹ìƒì@¡€A3ʼnEü‹M‹ESVW¾xô@}ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌèÊfÿÿ‹uàYY‰;Ãu#‹Eè‰è4dÿÿÇè?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=EncodePointerKERNEL32.DLLDecodePointerFlsFreeFlsSetValueFlsGetValueFlsAllocruntime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: ÀÀ–ÀÀŽÀÀÀ‘À’À“À€€†€€†€†‚€EEE………00€P€ˆ('8PW€700PPˆ (€ˆ€€`h`hhhxppwpp         (((((                  H„„„„„„„„„„‚‚‚‚‚‚          h((((                  H„„„„„„„„„„‚‚‚‚‚‚                                 H€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLLSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecCONOUT$.com.exe.bat.cmd.\SystemRootH€AÐô@8°i ™þÿÿÿÔÿÿÿþÿÿÿÜ@þÿÿÿÈÿÿÿþÿÿÿ¼#@þÿÿÿˆÿÿÿþÿÿÿú%@þ%@þÿÿÿÀ%@Ô%@þÿÿÿŒÿÿÿþÿÿÿh5@l5@þÿÿÿÔÿÿÿþÿÿÿ;@þÿÿÿÐÿÿÿþÿÿÿá;@þÿÿÿÌÿÿÿþÿÿÿk=@7=@þÿÿÿÔÿÿÿþÿÿÿð>@þÿÿÿÔÿÿÿþÿÿÿ#@@þÿÿÿÔÿÿÿþÿÿÿMA@iA@þÿÿÿÔÿÿÿþÿÿÿ]G@þÿÿÿÌÿÿÿþÿÿÿ+K@þÿÿÿÔÿÿÿþÿÿÿ›N@þÿÿÿÔÿÿÿþÿÿÿÝP@þÿÿÿìP@þÿÿÿØÿÿÿþÿÿÿŸR@þÿÿÿ«R@þÿÿÿÔÿÿÿþÿÿÿeY@þÿÿÿØÿÿÿþÿÿÿ[@[@þÿÿÿØÿÿÿþÿÿÿ][@a[@þÿÿÿÀÿÿÿþÿÿÿ¸^@þÿÿÿÐÿÿÿþÿÿÿH_@__@þÿÿÿÔÿÿÿþÿÿÿ¹j@þÿÿÿÐÿÿÿþÿÿÿÊl@þÿÿÿÔÿÿÿþÿÿÿÎy@þÿÿÿÐÿÿÿþÿÿÿÞ@þÿÿÿÐÿÿÿþÿÿÿ¿‚@þÿÿÿÌÿÿÿþÿÿÿ´•@þÿÿÿÐÿÿÿþÿÿÿM˜@þÿÿÿÐÿÿÿþÿÿÿä¡@þÿÿÿÔÿÿÿþÿÿÿ[¦@þÿÿÿÈÿÿÿþÿÿÿ!¨@]§@þÿÿÿÐÿÿÿþÿÿÿÜ®@þÿÿÿÐÿÿÿþÿÿÿøÂ@þÿÿÿÌÿÿÿþÿÿÿ›Ê@\ùàœú¸úÎúäúöúû$û<ûTûhûpû‚ûû¢û´ûÆûÖûäûüûü$ü@ü^ürü‚üŽüšü¦ü¾üÖüàüìüþüýý&ý0ý@ýVýbýrýšý´ýÌýæýüýþ$þ2þLþ\þrþŒþ˜þ¦þ¶þÆþØþìþüþÿ"ÿ4ÿFÿXÿjÿvÿ„ÿ”ÿªÿºÿÊÿØÿêÿüÿ$0@RRGenerateConsoleCtrlEventÆGetExitCodeProcessnWaitForSingleObject•CreateProcessA¯SetConsoleCtrlHandlerõGetModuleFileNameAÚEnterCriticalSectionôLeaveCriticalSectionúGetModuleHandleW+Sleep"GetProcAddressExitProcesspGetCommandLineA<GetStartupInfoAðSetHandleCount>GetStdHandleØGetFileType¿DeleteCriticalSection7TerminateProcessªGetCurrentProcessHUnhandledExceptionFilterSetUnhandledExceptionFilterÖIsDebuggerPresentçGetLastError¦HeapFree¢HeapAlloc\GetCPInfoÅInterlockedIncrementÁInterlockedDecrementSGetACPGetOEMCPàIsValidCodePage>TlsGetValue<TlsAlloc?TlsSetValue=TlsFreeôSetLastError®GetCurrentThreadId—WriteFileöLoadLibraryAºInitializeCriticalSectionAndSpinCountKFreeEnvironmentStringsAÀGetEnvironmentStringsLFreeEnvironmentStringsW„WideCharToMultiByteÂGetEnvironmentStringsW¤HeapCreateaVirtualFreeYQueryPerformanceCounterjGetTickCount«GetCurrentProcessIdSGetSystemTimeAsFileTimešRtlUnwind©HeapReAlloc^VirtualAlloc„GetConsoleCP–GetConsoleModeBFlushFileBuffersæLCMapStringAMultiByteToWideCharèLCMapStringW@GetStringTypeACGetStringTypeWéGetLocaleInfoAçSetFilePointer«HeapSizeDCloseHandleŒWriteConsoleAšGetConsoleOutputCP–WriteConsoleWSetStdHandleyCreateFileASCompareStringAVCompareStringWØSetEnvironmentVariableAKERNEL32.dllnReadFileÕSetEndOfFile&GetProcessHeapÊGetFileAttributesAÀ+AÀ+ANæ@»±¿Dê#@lâ@\â@ÿÿÿÿ€

		


!
5A
CPR
S
WYl
m pr	€

‚	ƒ„
‘)ž
¡¤§
·Î×                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZhA¤`‚y‚!¦ß¡¥Ÿàü@~€ü¨Á£Ú£ þ@þµÁ£Ú£ þAþ¶Ï¢ä¢å¢è¢[þ@~¡þQQÚ^Ú _ÚjÚ2ÓØÞàù1~þlí@þÿÿÿCAAAAAHAhë@ðï@pñ@ˆA˜A˜AhAÿÿÿÿÿÿÿÿøè@Ìè@	 è@
è@Üç@¬ç@ˆç@\ç@$ç@üæ@Äæ@Œæ@dæ@Dæ@àå@ ¨å@!°ä@"ä@xä@yðã@zàã@üÜã@ÿÌã@^˜@^˜@^˜@^˜@^˜@^˜@^˜@^˜@^˜@^˜@x
hë@jí@˜ó@”ó@ó@Œó@ˆó@„ó@€ó@xó@pó@hó@\ó@Pó@Hó@<ó@8ó@4ó@0ó@,ó@(ó@$ó@ ó@ó@ó@ó@ó@ó@ó@øò@ðò@èò@(ó@àò@Øò@Ðò@Äò@¼ò@°ò@¤ò@ ò@œò@ò@|ò@pò@	ˆA.DAŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AŒ)AHA. “€pðñÿÿPSTPDTÐAAÿÿÿÿÿÿÿÿþÿÿÿþÿÿÿÿÿÿÿ;Zx—µÔó0Nmÿÿÿÿ:Yw–´Óò/Mllô@dô@\ô@Tô@././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/installer.py0000644000175100001710000000736000000000000020172 0ustar00runnerdockerimport glob
import os
import subprocess
import sys
import tempfile
import warnings
from distutils import log
from distutils.errors import DistutilsError

import pkg_resources
from setuptools.wheel import Wheel
from ._deprecation_warning import SetuptoolsDeprecationWarning


def _fixup_find_links(find_links):
    """Ensure find-links option end-up being a list of strings."""
    if isinstance(find_links, str):
        return find_links.split()
    assert isinstance(find_links, (tuple, list))
    return find_links


def fetch_build_egg(dist, req):  # noqa: C901  # is too complex (16)  # FIXME
    """Fetch an egg needed for building.

    Use pip/wheel to fetch/build a wheel."""
    warnings.warn(
        "setuptools.installer is deprecated. Requirements should "
        "be satisfied by a PEP 517 installer.",
        SetuptoolsDeprecationWarning,
    )
    # Warn if wheel is not available
    try:
        pkg_resources.get_distribution('wheel')
    except pkg_resources.DistributionNotFound:
        dist.announce('WARNING: The wheel package is not available.', log.WARN)
    # Ignore environment markers; if supplied, it is required.
    req = strip_marker(req)
    # Take easy_install options into account, but do not override relevant
    # pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll
    # take precedence.
    opts = dist.get_option_dict('easy_install')
    if 'allow_hosts' in opts:
        raise DistutilsError('the `allow-hosts` option is not supported '
                             'when using pip to install requirements.')
    quiet = 'PIP_QUIET' not in os.environ and 'PIP_VERBOSE' not in os.environ
    if 'PIP_INDEX_URL' in os.environ:
        index_url = None
    elif 'index_url' in opts:
        index_url = opts['index_url'][1]
    else:
        index_url = None
    find_links = (
        _fixup_find_links(opts['find_links'][1])[:] if 'find_links' in opts
        else []
    )
    if dist.dependency_links:
        find_links.extend(dist.dependency_links)
    eggs_dir = os.path.realpath(dist.get_egg_cache_dir())
    environment = pkg_resources.Environment()
    for egg_dist in pkg_resources.find_distributions(eggs_dir):
        if egg_dist in req and environment.can_add(egg_dist):
            return egg_dist
    with tempfile.TemporaryDirectory() as tmpdir:
        cmd = [
            sys.executable, '-m', 'pip',
            '--disable-pip-version-check',
            'wheel', '--no-deps',
            '-w', tmpdir,
        ]
        if quiet:
            cmd.append('--quiet')
        if index_url is not None:
            cmd.extend(('--index-url', index_url))
        for link in find_links or []:
            cmd.extend(('--find-links', link))
        # If requirement is a PEP 508 direct URL, directly pass
        # the URL to pip, as `req @ url` does not work on the
        # command line.
        cmd.append(req.url or str(req))
        try:
            subprocess.check_call(cmd)
        except subprocess.CalledProcessError as e:
            raise DistutilsError(str(e)) from e
        wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0])
        dist_location = os.path.join(eggs_dir, wheel.egg_name())
        wheel.install_as_egg(dist_location)
        dist_metadata = pkg_resources.PathMetadata(
            dist_location, os.path.join(dist_location, 'EGG-INFO'))
        dist = pkg_resources.Distribution.from_filename(
            dist_location, metadata=dist_metadata)
        return dist


def strip_marker(req):
    """
    Return a new requirement without the environment marker to avoid
    calling pip with something like `babel; extra == "i18n"`, which
    would always be ignored.
    """
    # create a copy to avoid mutating the input
    req = pkg_resources.Requirement.parse(str(req))
    req.marker = None
    return req
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/launch.py0000644000175100001710000000145400000000000017445 0ustar00runnerdocker"""
Launch the Python script on the command line after
setuptools is bootstrapped via import.
"""

# Note that setuptools gets imported implicitly by the
# invocation of this script using python -m setuptools.launch

import tokenize
import sys


def run():
    """
    Run the script in sys.argv[1] as if it had
    been invoked naturally.
    """
    __builtins__
    script_name = sys.argv[1]
    namespace = dict(
        __file__=script_name,
        __name__='__main__',
        __doc__=None,
    )
    sys.argv[:] = sys.argv[1:]

    open_ = getattr(tokenize, 'open', open)
    with open_(script_name) as fid:
        script = fid.read()
    norm_script = script.replace('\\r\\n', '\\n')
    code = compile(norm_script, script_name, 'exec')
    exec(code, namespace)


if __name__ == '__main__':
    run()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/monkey.py0000644000175100001710000001214100000000000017470 0ustar00runnerdocker"""
Monkey patching of distutils.
"""

import sys
import distutils.filelist
import platform
import types
import functools
from importlib import import_module
import inspect

import setuptools

__all__ = []
"""
Everything is private. Contact the project team
if you think you need this functionality.
"""


def _get_mro(cls):
    """
    Returns the bases classes for cls sorted by the MRO.

    Works around an issue on Jython where inspect.getmro will not return all
    base classes if multiple classes share the same name. Instead, this
    function will return a tuple containing the class itself, and the contents
    of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024.
    """
    if platform.python_implementation() == "Jython":
        return (cls,) + cls.__bases__
    return inspect.getmro(cls)


def get_unpatched(item):
    lookup = (
        get_unpatched_class if isinstance(item, type) else
        get_unpatched_function if isinstance(item, types.FunctionType) else
        lambda item: None
    )
    return lookup(item)


def get_unpatched_class(cls):
    """Protect against re-patching the distutils if reloaded

    Also ensures that no other distutils extension monkeypatched the distutils
    first.
    """
    external_bases = (
        cls
        for cls in _get_mro(cls)
        if not cls.__module__.startswith('setuptools')
    )
    base = next(external_bases)
    if not base.__module__.startswith('distutils'):
        msg = "distutils has already been patched by %r" % cls
        raise AssertionError(msg)
    return base


def patch_all():
    # we can't patch distutils.cmd, alas
    distutils.core.Command = setuptools.Command

    has_issue_12885 = sys.version_info <= (3, 5, 3)

    if has_issue_12885:
        # fix findall bug in distutils (http://bugs.python.org/issue12885)
        distutils.filelist.findall = setuptools.findall

    needs_warehouse = (
        sys.version_info < (2, 7, 13)
        or
        (3, 4) < sys.version_info < (3, 4, 6)
        or
        (3, 5) < sys.version_info <= (3, 5, 3)
    )

    if needs_warehouse:
        warehouse = 'https://upload.pypi.org/legacy/'
        distutils.config.PyPIRCCommand.DEFAULT_REPOSITORY = warehouse

    _patch_distribution_metadata()

    # Install Distribution throughout the distutils
    for module in distutils.dist, distutils.core, distutils.cmd:
        module.Distribution = setuptools.dist.Distribution

    # Install the patched Extension
    distutils.core.Extension = setuptools.extension.Extension
    distutils.extension.Extension = setuptools.extension.Extension
    if 'distutils.command.build_ext' in sys.modules:
        sys.modules['distutils.command.build_ext'].Extension = (
            setuptools.extension.Extension
        )

    patch_for_msvc_specialized_compiler()


def _patch_distribution_metadata():
    """Patch write_pkg_file and read_pkg_file for higher metadata standards"""
    for attr in ('write_pkg_file', 'read_pkg_file', 'get_metadata_version'):
        new_val = getattr(setuptools.dist, attr)
        setattr(distutils.dist.DistributionMetadata, attr, new_val)


def patch_func(replacement, target_mod, func_name):
    """
    Patch func_name in target_mod with replacement

    Important - original must be resolved by name to avoid
    patching an already patched function.
    """
    original = getattr(target_mod, func_name)

    # set the 'unpatched' attribute on the replacement to
    # point to the original.
    vars(replacement).setdefault('unpatched', original)

    # replace the function in the original module
    setattr(target_mod, func_name, replacement)


def get_unpatched_function(candidate):
    return getattr(candidate, 'unpatched')


def patch_for_msvc_specialized_compiler():
    """
    Patch functions in distutils to use standalone Microsoft Visual C++
    compilers.
    """
    # import late to avoid circular imports on Python < 3.5
    msvc = import_module('setuptools.msvc')

    if platform.system() != 'Windows':
        # Compilers only available on Microsoft Windows
        return

    def patch_params(mod_name, func_name):
        """
        Prepare the parameters for patch_func to patch indicated function.
        """
        repl_prefix = 'msvc9_' if 'msvc9' in mod_name else 'msvc14_'
        repl_name = repl_prefix + func_name.lstrip('_')
        repl = getattr(msvc, repl_name)
        mod = import_module(mod_name)
        if not hasattr(mod, func_name):
            raise ImportError(func_name)
        return repl, mod, func_name

    # Python 2.7 to 3.4
    msvc9 = functools.partial(patch_params, 'distutils.msvc9compiler')

    # Python 3.5+
    msvc14 = functools.partial(patch_params, 'distutils._msvccompiler')

    try:
        # Patch distutils.msvc9compiler
        patch_func(*msvc9('find_vcvarsall'))
        patch_func(*msvc9('query_vcvarsall'))
    except ImportError:
        pass

    try:
        # Patch distutils._msvccompiler._get_vc_env
        patch_func(*msvc14('_get_vc_env'))
    except ImportError:
        pass

    try:
        # Patch distutils._msvccompiler.gen_lib_options for Numpy
        patch_func(*msvc14('gen_lib_options'))
    except ImportError:
        pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/msvc.py0000644000175100001710000014260100000000000017143 0ustar00runnerdocker"""
Improved support for Microsoft Visual C++ compilers.

Known supported compilers:
--------------------------
Microsoft Visual C++ 9.0:
    Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
    Microsoft Windows SDK 6.1 (x86, x64, ia64)
    Microsoft Windows SDK 7.0 (x86, x64, ia64)

Microsoft Visual C++ 10.0:
    Microsoft Windows SDK 7.1 (x86, x64, ia64)

Microsoft Visual C++ 14.X:
    Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
    Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
    Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64)

This may also support compilers shipped with compatible Visual Studio versions.
"""

import json
from io import open
from os import listdir, pathsep
from os.path import join, isfile, isdir, dirname
import sys
import contextlib
import platform
import itertools
import subprocess
import distutils.errors
from setuptools.extern.packaging.version import LegacyVersion
from setuptools.extern.more_itertools import unique_everseen

from .monkey import get_unpatched

if platform.system() == 'Windows':
    import winreg
    from os import environ
else:
    # Mock winreg and environ so the module can be imported on this platform.

    class winreg:
        HKEY_USERS = None
        HKEY_CURRENT_USER = None
        HKEY_LOCAL_MACHINE = None
        HKEY_CLASSES_ROOT = None

    environ = dict()

_msvc9_suppress_errors = (
    # msvc9compiler isn't available on some platforms
    ImportError,

    # msvc9compiler raises DistutilsPlatformError in some
    # environments. See #1118.
    distutils.errors.DistutilsPlatformError,
)

try:
    from distutils.msvc9compiler import Reg
except _msvc9_suppress_errors:
    pass


def msvc9_find_vcvarsall(version):
    """
    Patched "distutils.msvc9compiler.find_vcvarsall" to use the standalone
    compiler build for Python
    (VCForPython / Microsoft Visual C++ Compiler for Python 2.7).

    Fall back to original behavior when the standalone compiler is not
    available.

    Redirect the path of "vcvarsall.bat".

    Parameters
    ----------
    version: float
        Required Microsoft Visual C++ version.

    Return
    ------
    str
        vcvarsall.bat path
    """
    vc_base = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f'
    key = vc_base % ('', version)
    try:
        # Per-user installs register the compiler path here
        productdir = Reg.get_value(key, "installdir")
    except KeyError:
        try:
            # All-user installs on a 64-bit system register here
            key = vc_base % ('Wow6432Node\\', version)
            productdir = Reg.get_value(key, "installdir")
        except KeyError:
            productdir = None

    if productdir:
        vcvarsall = join(productdir, "vcvarsall.bat")
        if isfile(vcvarsall):
            return vcvarsall

    return get_unpatched(msvc9_find_vcvarsall)(version)


def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
    """
    Patched "distutils.msvc9compiler.query_vcvarsall" for support extra
    Microsoft Visual C++ 9.0 and 10.0 compilers.

    Set environment without use of "vcvarsall.bat".

    Parameters
    ----------
    ver: float
        Required Microsoft Visual C++ version.
    arch: str
        Target architecture.

    Return
    ------
    dict
        environment
    """
    # Try to get environment from vcvarsall.bat (Classical way)
    try:
        orig = get_unpatched(msvc9_query_vcvarsall)
        return orig(ver, arch, *args, **kwargs)
    except distutils.errors.DistutilsPlatformError:
        # Pass error if Vcvarsall.bat is missing
        pass
    except ValueError:
        # Pass error if environment not set after executing vcvarsall.bat
        pass

    # If error, try to set environment directly
    try:
        return EnvironmentInfo(arch, ver).return_env()
    except distutils.errors.DistutilsPlatformError as exc:
        _augment_exception(exc, ver, arch)
        raise


def _msvc14_find_vc2015():
    """Python 3.8 "distutils/_msvccompiler.py" backport"""
    try:
        key = winreg.OpenKey(
            winreg.HKEY_LOCAL_MACHINE,
            r"Software\Microsoft\VisualStudio\SxS\VC7",
            0,
            winreg.KEY_READ | winreg.KEY_WOW64_32KEY
        )
    except OSError:
        return None, None

    best_version = 0
    best_dir = None
    with key:
        for i in itertools.count():
            try:
                v, vc_dir, vt = winreg.EnumValue(key, i)
            except OSError:
                break
            if v and vt == winreg.REG_SZ and isdir(vc_dir):
                try:
                    version = int(float(v))
                except (ValueError, TypeError):
                    continue
                if version >= 14 and version > best_version:
                    best_version, best_dir = version, vc_dir
    return best_version, best_dir


def _msvc14_find_vc2017():
    """Python 3.8 "distutils/_msvccompiler.py" backport

    Returns "15, path" based on the result of invoking vswhere.exe
    If no install is found, returns "None, None"

    The version is returned to avoid unnecessarily changing the function
    result. It may be ignored when the path is not None.

    If vswhere.exe is not available, by definition, VS 2017 is not
    installed.
    """
    root = environ.get("ProgramFiles(x86)") or environ.get("ProgramFiles")
    if not root:
        return None, None

    try:
        path = subprocess.check_output([
            join(root, "Microsoft Visual Studio", "Installer", "vswhere.exe"),
            "-latest",
            "-prerelease",
            "-requiresAny",
            "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
            "-requires", "Microsoft.VisualStudio.Workload.WDExpress",
            "-property", "installationPath",
            "-products", "*",
        ]).decode(encoding="mbcs", errors="strict").strip()
    except (subprocess.CalledProcessError, OSError, UnicodeDecodeError):
        return None, None

    path = join(path, "VC", "Auxiliary", "Build")
    if isdir(path):
        return 15, path

    return None, None


PLAT_SPEC_TO_RUNTIME = {
    'x86': 'x86',
    'x86_amd64': 'x64',
    'x86_arm': 'arm',
    'x86_arm64': 'arm64'
}


def _msvc14_find_vcvarsall(plat_spec):
    """Python 3.8 "distutils/_msvccompiler.py" backport"""
    _, best_dir = _msvc14_find_vc2017()
    vcruntime = None

    if plat_spec in PLAT_SPEC_TO_RUNTIME:
        vcruntime_plat = PLAT_SPEC_TO_RUNTIME[plat_spec]
    else:
        vcruntime_plat = 'x64' if 'amd64' in plat_spec else 'x86'

    if best_dir:
        vcredist = join(best_dir, "..", "..", "redist", "MSVC", "**",
                        vcruntime_plat, "Microsoft.VC14*.CRT",
                        "vcruntime140.dll")
        try:
            import glob
            vcruntime = glob.glob(vcredist, recursive=True)[-1]
        except (ImportError, OSError, LookupError):
            vcruntime = None

    if not best_dir:
        best_version, best_dir = _msvc14_find_vc2015()
        if best_version:
            vcruntime = join(best_dir, 'redist', vcruntime_plat,
                             "Microsoft.VC140.CRT", "vcruntime140.dll")

    if not best_dir:
        return None, None

    vcvarsall = join(best_dir, "vcvarsall.bat")
    if not isfile(vcvarsall):
        return None, None

    if not vcruntime or not isfile(vcruntime):
        vcruntime = None

    return vcvarsall, vcruntime


def _msvc14_get_vc_env(plat_spec):
    """Python 3.8 "distutils/_msvccompiler.py" backport"""
    if "DISTUTILS_USE_SDK" in environ:
        return {
            key.lower(): value
            for key, value in environ.items()
        }

    vcvarsall, vcruntime = _msvc14_find_vcvarsall(plat_spec)
    if not vcvarsall:
        raise distutils.errors.DistutilsPlatformError(
            "Unable to find vcvarsall.bat"
        )

    try:
        out = subprocess.check_output(
            'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
            stderr=subprocess.STDOUT,
        ).decode('utf-16le', errors='replace')
    except subprocess.CalledProcessError as exc:
        raise distutils.errors.DistutilsPlatformError(
            "Error executing {}".format(exc.cmd)
        ) from exc

    env = {
        key.lower(): value
        for key, _, value in
        (line.partition('=') for line in out.splitlines())
        if key and value
    }

    if vcruntime:
        env['py_vcruntime_redist'] = vcruntime
    return env


def msvc14_get_vc_env(plat_spec):
    """
    Patched "distutils._msvccompiler._get_vc_env" for support extra
    Microsoft Visual C++ 14.X compilers.

    Set environment without use of "vcvarsall.bat".

    Parameters
    ----------
    plat_spec: str
        Target architecture.

    Return
    ------
    dict
        environment
    """

    # Always use backport from CPython 3.8
    try:
        return _msvc14_get_vc_env(plat_spec)
    except distutils.errors.DistutilsPlatformError as exc:
        _augment_exception(exc, 14.0)
        raise


def msvc14_gen_lib_options(*args, **kwargs):
    """
    Patched "distutils._msvccompiler.gen_lib_options" for fix
    compatibility between "numpy.distutils" and "distutils._msvccompiler"
    (for Numpy < 1.11.2)
    """
    if "numpy.distutils" in sys.modules:
        import numpy as np
        if LegacyVersion(np.__version__) < LegacyVersion('1.11.2'):
            return np.distutils.ccompiler.gen_lib_options(*args, **kwargs)
    return get_unpatched(msvc14_gen_lib_options)(*args, **kwargs)


def _augment_exception(exc, version, arch=''):
    """
    Add details to the exception message to help guide the user
    as to what action will resolve it.
    """
    # Error if MSVC++ directory not found or environment not set
    message = exc.args[0]

    if "vcvarsall" in message.lower() or "visual c" in message.lower():
        # Special error message if MSVC++ not installed
        tmpl = 'Microsoft Visual C++ {version:0.1f} or greater is required.'
        message = tmpl.format(**locals())
        msdownload = 'www.microsoft.com/download/details.aspx?id=%d'
        if version == 9.0:
            if arch.lower().find('ia64') > -1:
                # For VC++ 9.0, if IA64 support is needed, redirect user
                # to Windows SDK 7.0.
                # Note: No download link available from Microsoft.
                message += ' Get it with "Microsoft Windows SDK 7.0"'
            else:
                # For VC++ 9.0 redirect user to Vc++ for Python 2.7 :
                # This redirection link is maintained by Microsoft.
                # Contact vspython@microsoft.com if it needs updating.
                message += ' Get it from http://aka.ms/vcpython27'
        elif version == 10.0:
            # For VC++ 10.0 Redirect user to Windows SDK 7.1
            message += ' Get it with "Microsoft Windows SDK 7.1": '
            message += msdownload % 8279
        elif version >= 14.0:
            # For VC++ 14.X Redirect user to latest Visual C++ Build Tools
            message += (' Get it with "Microsoft C++ Build Tools": '
                        r'https://visualstudio.microsoft.com'
                        r'/visual-cpp-build-tools/')

    exc.args = (message, )


class PlatformInfo:
    """
    Current and Target Architectures information.

    Parameters
    ----------
    arch: str
        Target architecture.
    """
    current_cpu = environ.get('processor_architecture', '').lower()

    def __init__(self, arch):
        self.arch = arch.lower().replace('x64', 'amd64')

    @property
    def target_cpu(self):
        """
        Return Target CPU architecture.

        Return
        ------
        str
            Target CPU
        """
        return self.arch[self.arch.find('_') + 1:]

    def target_is_x86(self):
        """
        Return True if target CPU is x86 32 bits..

        Return
        ------
        bool
            CPU is x86 32 bits
        """
        return self.target_cpu == 'x86'

    def current_is_x86(self):
        """
        Return True if current CPU is x86 32 bits..

        Return
        ------
        bool
            CPU is x86 32 bits
        """
        return self.current_cpu == 'x86'

    def current_dir(self, hidex86=False, x64=False):
        """
        Current platform specific subfolder.

        Parameters
        ----------
        hidex86: bool
            return '' and not '\x86' if architecture is x86.
        x64: bool
            return '\x64' and not '\amd64' if architecture is amd64.

        Return
        ------
        str
            subfolder: '\target', or '' (see hidex86 parameter)
        """
        return (
            '' if (self.current_cpu == 'x86' and hidex86) else
            r'\x64' if (self.current_cpu == 'amd64' and x64) else
            r'\%s' % self.current_cpu
        )

    def target_dir(self, hidex86=False, x64=False):
        r"""
        Target platform specific subfolder.

        Parameters
        ----------
        hidex86: bool
            return '' and not '\x86' if architecture is x86.
        x64: bool
            return '\x64' and not '\amd64' if architecture is amd64.

        Return
        ------
        str
            subfolder: '\current', or '' (see hidex86 parameter)
        """
        return (
            '' if (self.target_cpu == 'x86' and hidex86) else
            r'\x64' if (self.target_cpu == 'amd64' and x64) else
            r'\%s' % self.target_cpu
        )

    def cross_dir(self, forcex86=False):
        r"""
        Cross platform specific subfolder.

        Parameters
        ----------
        forcex86: bool
            Use 'x86' as current architecture even if current architecture is
            not x86.

        Return
        ------
        str
            subfolder: '' if target architecture is current architecture,
            '\current_target' if not.
        """
        current = 'x86' if forcex86 else self.current_cpu
        return (
            '' if self.target_cpu == current else
            self.target_dir().replace('\\', '\\%s_' % current)
        )


class RegistryInfo:
    """
    Microsoft Visual Studio related registry information.

    Parameters
    ----------
    platform_info: PlatformInfo
        "PlatformInfo" instance.
    """
    HKEYS = (winreg.HKEY_USERS,
             winreg.HKEY_CURRENT_USER,
             winreg.HKEY_LOCAL_MACHINE,
             winreg.HKEY_CLASSES_ROOT)

    def __init__(self, platform_info):
        self.pi = platform_info

    @property
    def visualstudio(self):
        """
        Microsoft Visual Studio root registry key.

        Return
        ------
        str
            Registry key
        """
        return 'VisualStudio'

    @property
    def sxs(self):
        """
        Microsoft Visual Studio SxS registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.visualstudio, 'SxS')

    @property
    def vc(self):
        """
        Microsoft Visual C++ VC7 registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.sxs, 'VC7')

    @property
    def vs(self):
        """
        Microsoft Visual Studio VS7 registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.sxs, 'VS7')

    @property
    def vc_for_python(self):
        """
        Microsoft Visual C++ for Python registry key.

        Return
        ------
        str
            Registry key
        """
        return r'DevDiv\VCForPython'

    @property
    def microsoft_sdk(self):
        """
        Microsoft SDK registry key.

        Return
        ------
        str
            Registry key
        """
        return 'Microsoft SDKs'

    @property
    def windows_sdk(self):
        """
        Microsoft Windows/Platform SDK registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.microsoft_sdk, 'Windows')

    @property
    def netfx_sdk(self):
        """
        Microsoft .NET Framework SDK registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.microsoft_sdk, 'NETFXSDK')

    @property
    def windows_kits_roots(self):
        """
        Microsoft Windows Kits Roots registry key.

        Return
        ------
        str
            Registry key
        """
        return r'Windows Kits\Installed Roots'

    def microsoft(self, key, x86=False):
        """
        Return key in Microsoft software registry.

        Parameters
        ----------
        key: str
            Registry key path where look.
        x86: str
            Force x86 software registry.

        Return
        ------
        str
            Registry key
        """
        node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node'
        return join('Software', node64, 'Microsoft', key)

    def lookup(self, key, name):
        """
        Look for values in registry in Microsoft software registry.

        Parameters
        ----------
        key: str
            Registry key path where look.
        name: str
            Value name to find.

        Return
        ------
        str
            value
        """
        key_read = winreg.KEY_READ
        openkey = winreg.OpenKey
        closekey = winreg.CloseKey
        ms = self.microsoft
        for hkey in self.HKEYS:
            bkey = None
            try:
                bkey = openkey(hkey, ms(key), 0, key_read)
            except (OSError, IOError):
                if not self.pi.current_is_x86():
                    try:
                        bkey = openkey(hkey, ms(key, True), 0, key_read)
                    except (OSError, IOError):
                        continue
                else:
                    continue
            try:
                return winreg.QueryValueEx(bkey, name)[0]
            except (OSError, IOError):
                pass
            finally:
                if bkey:
                    closekey(bkey)


class SystemInfo:
    """
    Microsoft Windows and Visual Studio related system information.

    Parameters
    ----------
    registry_info: RegistryInfo
        "RegistryInfo" instance.
    vc_ver: float
        Required Microsoft Visual C++ version.
    """

    # Variables and properties in this class use originals CamelCase variables
    # names from Microsoft source files for more easy comparison.
    WinDir = environ.get('WinDir', '')
    ProgramFiles = environ.get('ProgramFiles', '')
    ProgramFilesx86 = environ.get('ProgramFiles(x86)', ProgramFiles)

    def __init__(self, registry_info, vc_ver=None):
        self.ri = registry_info
        self.pi = self.ri.pi

        self.known_vs_paths = self.find_programdata_vs_vers()

        # Except for VS15+, VC version is aligned with VS version
        self.vs_ver = self.vc_ver = (
            vc_ver or self._find_latest_available_vs_ver())

    def _find_latest_available_vs_ver(self):
        """
        Find the latest VC version

        Return
        ------
        float
            version
        """
        reg_vc_vers = self.find_reg_vs_vers()

        if not (reg_vc_vers or self.known_vs_paths):
            raise distutils.errors.DistutilsPlatformError(
                'No Microsoft Visual C++ version found')

        vc_vers = set(reg_vc_vers)
        vc_vers.update(self.known_vs_paths)
        return sorted(vc_vers)[-1]

    def find_reg_vs_vers(self):
        """
        Find Microsoft Visual Studio versions available in registry.

        Return
        ------
        list of float
            Versions
        """
        ms = self.ri.microsoft
        vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs)
        vs_vers = []
        for hkey, key in itertools.product(self.ri.HKEYS, vckeys):
            try:
                bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ)
            except (OSError, IOError):
                continue
            with bkey:
                subkeys, values, _ = winreg.QueryInfoKey(bkey)
                for i in range(values):
                    with contextlib.suppress(ValueError):
                        ver = float(winreg.EnumValue(bkey, i)[0])
                        if ver not in vs_vers:
                            vs_vers.append(ver)
                for i in range(subkeys):
                    with contextlib.suppress(ValueError):
                        ver = float(winreg.EnumKey(bkey, i))
                        if ver not in vs_vers:
                            vs_vers.append(ver)
        return sorted(vs_vers)

    def find_programdata_vs_vers(self):
        r"""
        Find Visual studio 2017+ versions from information in
        "C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances".

        Return
        ------
        dict
            float version as key, path as value.
        """
        vs_versions = {}
        instances_dir = \
            r'C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances'

        try:
            hashed_names = listdir(instances_dir)

        except (OSError, IOError):
            # Directory not exists with all Visual Studio versions
            return vs_versions

        for name in hashed_names:
            try:
                # Get VS installation path from "state.json" file
                state_path = join(instances_dir, name, 'state.json')
                with open(state_path, 'rt', encoding='utf-8') as state_file:
                    state = json.load(state_file)
                vs_path = state['installationPath']

                # Raises OSError if this VS installation does not contain VC
                listdir(join(vs_path, r'VC\Tools\MSVC'))

                # Store version and path
                vs_versions[self._as_float_version(
                    state['installationVersion'])] = vs_path

            except (OSError, IOError, KeyError):
                # Skip if "state.json" file is missing or bad format
                continue

        return vs_versions

    @staticmethod
    def _as_float_version(version):
        """
        Return a string version as a simplified float version (major.minor)

        Parameters
        ----------
        version: str
            Version.

        Return
        ------
        float
            version
        """
        return float('.'.join(version.split('.')[:2]))

    @property
    def VSInstallDir(self):
        """
        Microsoft Visual Studio directory.

        Return
        ------
        str
            path
        """
        # Default path
        default = join(self.ProgramFilesx86,
                       'Microsoft Visual Studio %0.1f' % self.vs_ver)

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vs, '%0.1f' % self.vs_ver) or default

    @property
    def VCInstallDir(self):
        """
        Microsoft Visual C++ directory.

        Return
        ------
        str
            path
        """
        path = self._guess_vc() or self._guess_vc_legacy()

        if not isdir(path):
            msg = 'Microsoft Visual C++ directory not found'
            raise distutils.errors.DistutilsPlatformError(msg)

        return path

    def _guess_vc(self):
        """
        Locate Visual C++ for VS2017+.

        Return
        ------
        str
            path
        """
        if self.vs_ver <= 14.0:
            return ''

        try:
            # First search in known VS paths
            vs_dir = self.known_vs_paths[self.vs_ver]
        except KeyError:
            # Else, search with path from registry
            vs_dir = self.VSInstallDir

        guess_vc = join(vs_dir, r'VC\Tools\MSVC')

        # Subdir with VC exact version as name
        try:
            # Update the VC version with real one instead of VS version
            vc_ver = listdir(guess_vc)[-1]
            self.vc_ver = self._as_float_version(vc_ver)
            return join(guess_vc, vc_ver)
        except (OSError, IOError, IndexError):
            return ''

    def _guess_vc_legacy(self):
        """
        Locate Visual C++ for versions prior to 2017.

        Return
        ------
        str
            path
        """
        default = join(self.ProgramFilesx86,
                       r'Microsoft Visual Studio %0.1f\VC' % self.vs_ver)

        # Try to get "VC++ for Python" path from registry as default path
        reg_path = join(self.ri.vc_for_python, '%0.1f' % self.vs_ver)
        python_vc = self.ri.lookup(reg_path, 'installdir')
        default_vc = join(python_vc, 'VC') if python_vc else default

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, '%0.1f' % self.vs_ver) or default_vc

    @property
    def WindowsSdkVersion(self):
        """
        Microsoft Windows SDK versions for specified MSVC++ version.

        Return
        ------
        tuple of str
            versions
        """
        if self.vs_ver <= 9.0:
            return '7.0', '6.1', '6.0a'
        elif self.vs_ver == 10.0:
            return '7.1', '7.0a'
        elif self.vs_ver == 11.0:
            return '8.0', '8.0a'
        elif self.vs_ver == 12.0:
            return '8.1', '8.1a'
        elif self.vs_ver >= 14.0:
            return '10.0', '8.1'

    @property
    def WindowsSdkLastVersion(self):
        """
        Microsoft Windows SDK last version.

        Return
        ------
        str
            version
        """
        return self._use_last_dir_name(join(self.WindowsSdkDir, 'lib'))

    @property  # noqa: C901
    def WindowsSdkDir(self):  # noqa: C901  # is too complex (12)  # FIXME
        """
        Microsoft Windows SDK directory.

        Return
        ------
        str
            path
        """
        sdkdir = ''
        for ver in self.WindowsSdkVersion:
            # Try to get it from registry
            loc = join(self.ri.windows_sdk, 'v%s' % ver)
            sdkdir = self.ri.lookup(loc, 'installationfolder')
            if sdkdir:
                break
        if not sdkdir or not isdir(sdkdir):
            # Try to get "VC++ for Python" version from registry
            path = join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
            install_base = self.ri.lookup(path, 'installdir')
            if install_base:
                sdkdir = join(install_base, 'WinSDK')
        if not sdkdir or not isdir(sdkdir):
            # If fail, use default new path
            for ver in self.WindowsSdkVersion:
                intver = ver[:ver.rfind('.')]
                path = r'Microsoft SDKs\Windows Kits\%s' % intver
                d = join(self.ProgramFiles, path)
                if isdir(d):
                    sdkdir = d
        if not sdkdir or not isdir(sdkdir):
            # If fail, use default old path
            for ver in self.WindowsSdkVersion:
                path = r'Microsoft SDKs\Windows\v%s' % ver
                d = join(self.ProgramFiles, path)
                if isdir(d):
                    sdkdir = d
        if not sdkdir:
            # If fail, use Platform SDK
            sdkdir = join(self.VCInstallDir, 'PlatformSDK')
        return sdkdir

    @property
    def WindowsSDKExecutablePath(self):
        """
        Microsoft Windows SDK executable directory.

        Return
        ------
        str
            path
        """
        # Find WinSDK NetFx Tools registry dir name
        if self.vs_ver <= 11.0:
            netfxver = 35
            arch = ''
        else:
            netfxver = 40
            hidex86 = True if self.vs_ver <= 12.0 else False
            arch = self.pi.current_dir(x64=True, hidex86=hidex86)
        fx = 'WinSDK-NetFx%dTools%s' % (netfxver, arch.replace('\\', '-'))

        # list all possibles registry paths
        regpaths = []
        if self.vs_ver >= 14.0:
            for ver in self.NetFxSdkVersion:
                regpaths += [join(self.ri.netfx_sdk, ver, fx)]

        for ver in self.WindowsSdkVersion:
            regpaths += [join(self.ri.windows_sdk, 'v%sA' % ver, fx)]

        # Return installation folder from the more recent path
        for path in regpaths:
            execpath = self.ri.lookup(path, 'installationfolder')
            if execpath:
                return execpath

    @property
    def FSharpInstallDir(self):
        """
        Microsoft Visual F# directory.

        Return
        ------
        str
            path
        """
        path = join(self.ri.visualstudio, r'%0.1f\Setup\F#' % self.vs_ver)
        return self.ri.lookup(path, 'productdir') or ''

    @property
    def UniversalCRTSdkDir(self):
        """
        Microsoft Universal CRT SDK directory.

        Return
        ------
        str
            path
        """
        # Set Kit Roots versions for specified MSVC++ version
        vers = ('10', '81') if self.vs_ver >= 14.0 else ()

        # Find path of the more recent Kit
        for ver in vers:
            sdkdir = self.ri.lookup(self.ri.windows_kits_roots,
                                    'kitsroot%s' % ver)
            if sdkdir:
                return sdkdir or ''

    @property
    def UniversalCRTSdkLastVersion(self):
        """
        Microsoft Universal C Runtime SDK last version.

        Return
        ------
        str
            version
        """
        return self._use_last_dir_name(join(self.UniversalCRTSdkDir, 'lib'))

    @property
    def NetFxSdkVersion(self):
        """
        Microsoft .NET Framework SDK versions.

        Return
        ------
        tuple of str
            versions
        """
        # Set FxSdk versions for specified VS version
        return (('4.7.2', '4.7.1', '4.7',
                 '4.6.2', '4.6.1', '4.6',
                 '4.5.2', '4.5.1', '4.5')
                if self.vs_ver >= 14.0 else ())

    @property
    def NetFxSdkDir(self):
        """
        Microsoft .NET Framework SDK directory.

        Return
        ------
        str
            path
        """
        sdkdir = ''
        for ver in self.NetFxSdkVersion:
            loc = join(self.ri.netfx_sdk, ver)
            sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder')
            if sdkdir:
                break
        return sdkdir

    @property
    def FrameworkDir32(self):
        """
        Microsoft .NET Framework 32bit directory.

        Return
        ------
        str
            path
        """
        # Default path
        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework')

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw

    @property
    def FrameworkDir64(self):
        """
        Microsoft .NET Framework 64bit directory.

        Return
        ------
        str
            path
        """
        # Default path
        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework64')

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw

    @property
    def FrameworkVersion32(self):
        """
        Microsoft .NET Framework 32bit versions.

        Return
        ------
        tuple of str
            versions
        """
        return self._find_dot_net_versions(32)

    @property
    def FrameworkVersion64(self):
        """
        Microsoft .NET Framework 64bit versions.

        Return
        ------
        tuple of str
            versions
        """
        return self._find_dot_net_versions(64)

    def _find_dot_net_versions(self, bits):
        """
        Find Microsoft .NET Framework versions.

        Parameters
        ----------
        bits: int
            Platform number of bits: 32 or 64.

        Return
        ------
        tuple of str
            versions
        """
        # Find actual .NET version in registry
        reg_ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits)
        dot_net_dir = getattr(self, 'FrameworkDir%d' % bits)
        ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or ''

        # Set .NET versions for specified MSVC++ version
        if self.vs_ver >= 12.0:
            return ver, 'v4.0'
        elif self.vs_ver >= 10.0:
            return 'v4.0.30319' if ver.lower()[:2] != 'v4' else ver, 'v3.5'
        elif self.vs_ver == 9.0:
            return 'v3.5', 'v2.0.50727'
        elif self.vs_ver == 8.0:
            return 'v3.0', 'v2.0.50727'

    @staticmethod
    def _use_last_dir_name(path, prefix=''):
        """
        Return name of the last dir in path or '' if no dir found.

        Parameters
        ----------
        path: str
            Use dirs in this path
        prefix: str
            Use only dirs starting by this prefix

        Return
        ------
        str
            name
        """
        matching_dirs = (
            dir_name
            for dir_name in reversed(listdir(path))
            if isdir(join(path, dir_name)) and
            dir_name.startswith(prefix)
        )
        return next(matching_dirs, None) or ''


class EnvironmentInfo:
    """
    Return environment variables for specified Microsoft Visual C++ version
    and platform : Lib, Include, Path and libpath.

    This function is compatible with Microsoft Visual C++ 9.0 to 14.X.

    Script created by analysing Microsoft environment configuration files like
    "vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...

    Parameters
    ----------
    arch: str
        Target architecture.
    vc_ver: float
        Required Microsoft Visual C++ version. If not set, autodetect the last
        version.
    vc_min_ver: float
        Minimum Microsoft Visual C++ version.
    """

    # Variables and properties in this class use originals CamelCase variables
    # names from Microsoft source files for more easy comparison.

    def __init__(self, arch, vc_ver=None, vc_min_ver=0):
        self.pi = PlatformInfo(arch)
        self.ri = RegistryInfo(self.pi)
        self.si = SystemInfo(self.ri, vc_ver)

        if self.vc_ver < vc_min_ver:
            err = 'No suitable Microsoft Visual C++ version found'
            raise distutils.errors.DistutilsPlatformError(err)

    @property
    def vs_ver(self):
        """
        Microsoft Visual Studio.

        Return
        ------
        float
            version
        """
        return self.si.vs_ver

    @property
    def vc_ver(self):
        """
        Microsoft Visual C++ version.

        Return
        ------
        float
            version
        """
        return self.si.vc_ver

    @property
    def VSTools(self):
        """
        Microsoft Visual Studio Tools.

        Return
        ------
        list of str
            paths
        """
        paths = [r'Common7\IDE', r'Common7\Tools']

        if self.vs_ver >= 14.0:
            arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
            paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow']
            paths += [r'Team Tools\Performance Tools']
            paths += [r'Team Tools\Performance Tools%s' % arch_subdir]

        return [join(self.si.VSInstallDir, path) for path in paths]

    @property
    def VCIncludes(self):
        """
        Microsoft Visual C++ & Microsoft Foundation Class Includes.

        Return
        ------
        list of str
            paths
        """
        return [join(self.si.VCInstallDir, 'Include'),
                join(self.si.VCInstallDir, r'ATLMFC\Include')]

    @property
    def VCLibraries(self):
        """
        Microsoft Visual C++ & Microsoft Foundation Class Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver >= 15.0:
            arch_subdir = self.pi.target_dir(x64=True)
        else:
            arch_subdir = self.pi.target_dir(hidex86=True)
        paths = ['Lib%s' % arch_subdir, r'ATLMFC\Lib%s' % arch_subdir]

        if self.vs_ver >= 14.0:
            paths += [r'Lib\store%s' % arch_subdir]

        return [join(self.si.VCInstallDir, path) for path in paths]

    @property
    def VCStoreRefs(self):
        """
        Microsoft Visual C++ store references Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0:
            return []
        return [join(self.si.VCInstallDir, r'Lib\store\references')]

    @property
    def VCTools(self):
        """
        Microsoft Visual C++ Tools.

        Return
        ------
        list of str
            paths
        """
        si = self.si
        tools = [join(si.VCInstallDir, 'VCPackages')]

        forcex86 = True if self.vs_ver <= 10.0 else False
        arch_subdir = self.pi.cross_dir(forcex86)
        if arch_subdir:
            tools += [join(si.VCInstallDir, 'Bin%s' % arch_subdir)]

        if self.vs_ver == 14.0:
            path = 'Bin%s' % self.pi.current_dir(hidex86=True)
            tools += [join(si.VCInstallDir, path)]

        elif self.vs_ver >= 15.0:
            host_dir = (r'bin\HostX86%s' if self.pi.current_is_x86() else
                        r'bin\HostX64%s')
            tools += [join(
                si.VCInstallDir, host_dir % self.pi.target_dir(x64=True))]

            if self.pi.current_cpu != self.pi.target_cpu:
                tools += [join(
                    si.VCInstallDir, host_dir % self.pi.current_dir(x64=True))]

        else:
            tools += [join(si.VCInstallDir, 'Bin')]

        return tools

    @property
    def OSLibraries(self):
        """
        Microsoft Windows SDK Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver <= 10.0:
            arch_subdir = self.pi.target_dir(hidex86=True, x64=True)
            return [join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)]

        else:
            arch_subdir = self.pi.target_dir(x64=True)
            lib = join(self.si.WindowsSdkDir, 'lib')
            libver = self._sdk_subdir
            return [join(lib, '%sum%s' % (libver, arch_subdir))]

    @property
    def OSIncludes(self):
        """
        Microsoft Windows SDK Include.

        Return
        ------
        list of str
            paths
        """
        include = join(self.si.WindowsSdkDir, 'include')

        if self.vs_ver <= 10.0:
            return [include, join(include, 'gl')]

        else:
            if self.vs_ver >= 14.0:
                sdkver = self._sdk_subdir
            else:
                sdkver = ''
            return [join(include, '%sshared' % sdkver),
                    join(include, '%sum' % sdkver),
                    join(include, '%swinrt' % sdkver)]

    @property
    def OSLibpath(self):
        """
        Microsoft Windows SDK Libraries Paths.

        Return
        ------
        list of str
            paths
        """
        ref = join(self.si.WindowsSdkDir, 'References')
        libpath = []

        if self.vs_ver <= 9.0:
            libpath += self.OSLibraries

        if self.vs_ver >= 11.0:
            libpath += [join(ref, r'CommonConfiguration\Neutral')]

        if self.vs_ver >= 14.0:
            libpath += [
                ref,
                join(self.si.WindowsSdkDir, 'UnionMetadata'),
                join(
                    ref, 'Windows.Foundation.UniversalApiContract', '1.0.0.0'),
                join(ref, 'Windows.Foundation.FoundationContract', '1.0.0.0'),
                join(
                    ref, 'Windows.Networking.Connectivity.WwanContract',
                    '1.0.0.0'),
                join(
                    self.si.WindowsSdkDir, 'ExtensionSDKs', 'Microsoft.VCLibs',
                    '%0.1f' % self.vs_ver, 'References', 'CommonConfiguration',
                    'neutral'),
            ]
        return libpath

    @property
    def SdkTools(self):
        """
        Microsoft Windows SDK Tools.

        Return
        ------
        list of str
            paths
        """
        return list(self._sdk_tools())

    def _sdk_tools(self):
        """
        Microsoft Windows SDK Tools paths generator.

        Return
        ------
        generator of str
            paths
        """
        if self.vs_ver < 15.0:
            bin_dir = 'Bin' if self.vs_ver <= 11.0 else r'Bin\x86'
            yield join(self.si.WindowsSdkDir, bin_dir)

        if not self.pi.current_is_x86():
            arch_subdir = self.pi.current_dir(x64=True)
            path = 'Bin%s' % arch_subdir
            yield join(self.si.WindowsSdkDir, path)

        if self.vs_ver in (10.0, 11.0):
            if self.pi.target_is_x86():
                arch_subdir = ''
            else:
                arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
            path = r'Bin\NETFX 4.0 Tools%s' % arch_subdir
            yield join(self.si.WindowsSdkDir, path)

        elif self.vs_ver >= 15.0:
            path = join(self.si.WindowsSdkDir, 'Bin')
            arch_subdir = self.pi.current_dir(x64=True)
            sdkver = self.si.WindowsSdkLastVersion
            yield join(path, '%s%s' % (sdkver, arch_subdir))

        if self.si.WindowsSDKExecutablePath:
            yield self.si.WindowsSDKExecutablePath

    @property
    def _sdk_subdir(self):
        """
        Microsoft Windows SDK version subdir.

        Return
        ------
        str
            subdir
        """
        ucrtver = self.si.WindowsSdkLastVersion
        return ('%s\\' % ucrtver) if ucrtver else ''

    @property
    def SdkSetup(self):
        """
        Microsoft Windows SDK Setup.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver > 9.0:
            return []

        return [join(self.si.WindowsSdkDir, 'Setup')]

    @property
    def FxTools(self):
        """
        Microsoft .NET Framework Tools.

        Return
        ------
        list of str
            paths
        """
        pi = self.pi
        si = self.si

        if self.vs_ver <= 10.0:
            include32 = True
            include64 = not pi.target_is_x86() and not pi.current_is_x86()
        else:
            include32 = pi.target_is_x86() or pi.current_is_x86()
            include64 = pi.current_cpu == 'amd64' or pi.target_cpu == 'amd64'

        tools = []
        if include32:
            tools += [join(si.FrameworkDir32, ver)
                      for ver in si.FrameworkVersion32]
        if include64:
            tools += [join(si.FrameworkDir64, ver)
                      for ver in si.FrameworkVersion64]
        return tools

    @property
    def NetFxSDKLibraries(self):
        """
        Microsoft .Net Framework SDK Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
            return []

        arch_subdir = self.pi.target_dir(x64=True)
        return [join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)]

    @property
    def NetFxSDKIncludes(self):
        """
        Microsoft .Net Framework SDK Includes.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
            return []

        return [join(self.si.NetFxSdkDir, r'include\um')]

    @property
    def VsTDb(self):
        """
        Microsoft Visual Studio Team System Database.

        Return
        ------
        list of str
            paths
        """
        return [join(self.si.VSInstallDir, r'VSTSDB\Deploy')]

    @property
    def MSBuild(self):
        """
        Microsoft Build Engine.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 12.0:
            return []
        elif self.vs_ver < 15.0:
            base_path = self.si.ProgramFilesx86
            arch_subdir = self.pi.current_dir(hidex86=True)
        else:
            base_path = self.si.VSInstallDir
            arch_subdir = ''

        path = r'MSBuild\%0.1f\bin%s' % (self.vs_ver, arch_subdir)
        build = [join(base_path, path)]

        if self.vs_ver >= 15.0:
            # Add Roslyn C# & Visual Basic Compiler
            build += [join(base_path, path, 'Roslyn')]

        return build

    @property
    def HTMLHelpWorkshop(self):
        """
        Microsoft HTML Help Workshop.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 11.0:
            return []

        return [join(self.si.ProgramFilesx86, 'HTML Help Workshop')]

    @property
    def UCRTLibraries(self):
        """
        Microsoft Universal C Runtime SDK Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0:
            return []

        arch_subdir = self.pi.target_dir(x64=True)
        lib = join(self.si.UniversalCRTSdkDir, 'lib')
        ucrtver = self._ucrt_subdir
        return [join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]

    @property
    def UCRTIncludes(self):
        """
        Microsoft Universal C Runtime SDK Include.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0:
            return []

        include = join(self.si.UniversalCRTSdkDir, 'include')
        return [join(include, '%sucrt' % self._ucrt_subdir)]

    @property
    def _ucrt_subdir(self):
        """
        Microsoft Universal C Runtime SDK version subdir.

        Return
        ------
        str
            subdir
        """
        ucrtver = self.si.UniversalCRTSdkLastVersion
        return ('%s\\' % ucrtver) if ucrtver else ''

    @property
    def FSharp(self):
        """
        Microsoft Visual F#.

        Return
        ------
        list of str
            paths
        """
        if 11.0 > self.vs_ver > 12.0:
            return []

        return [self.si.FSharpInstallDir]

    @property
    def VCRuntimeRedist(self):
        """
        Microsoft Visual C++ runtime redistributable dll.

        Return
        ------
        str
            path
        """
        vcruntime = 'vcruntime%d0.dll' % self.vc_ver
        arch_subdir = self.pi.target_dir(x64=True).strip('\\')

        # Installation prefixes candidates
        prefixes = []
        tools_path = self.si.VCInstallDir
        redist_path = dirname(tools_path.replace(r'\Tools', r'\Redist'))
        if isdir(redist_path):
            # Redist version may not be exactly the same as tools
            redist_path = join(redist_path, listdir(redist_path)[-1])
            prefixes += [redist_path, join(redist_path, 'onecore')]

        prefixes += [join(tools_path, 'redist')]  # VS14 legacy path

        # CRT directory
        crt_dirs = ('Microsoft.VC%d.CRT' % (self.vc_ver * 10),
                    # Sometime store in directory with VS version instead of VC
                    'Microsoft.VC%d.CRT' % (int(self.vs_ver) * 10))

        # vcruntime path
        for prefix, crt_dir in itertools.product(prefixes, crt_dirs):
            path = join(prefix, arch_subdir, crt_dir, vcruntime)
            if isfile(path):
                return path

    def return_env(self, exists=True):
        """
        Return environment dict.

        Parameters
        ----------
        exists: bool
            It True, only return existing paths.

        Return
        ------
        dict
            environment
        """
        env = dict(
            include=self._build_paths('include',
                                      [self.VCIncludes,
                                       self.OSIncludes,
                                       self.UCRTIncludes,
                                       self.NetFxSDKIncludes],
                                      exists),
            lib=self._build_paths('lib',
                                  [self.VCLibraries,
                                   self.OSLibraries,
                                   self.FxTools,
                                   self.UCRTLibraries,
                                   self.NetFxSDKLibraries],
                                  exists),
            libpath=self._build_paths('libpath',
                                      [self.VCLibraries,
                                       self.FxTools,
                                       self.VCStoreRefs,
                                       self.OSLibpath],
                                      exists),
            path=self._build_paths('path',
                                   [self.VCTools,
                                    self.VSTools,
                                    self.VsTDb,
                                    self.SdkTools,
                                    self.SdkSetup,
                                    self.FxTools,
                                    self.MSBuild,
                                    self.HTMLHelpWorkshop,
                                    self.FSharp],
                                   exists),
        )
        if self.vs_ver >= 14 and isfile(self.VCRuntimeRedist):
            env['py_vcruntime_redist'] = self.VCRuntimeRedist
        return env

    def _build_paths(self, name, spec_path_lists, exists):
        """
        Given an environment variable name and specified paths,
        return a pathsep-separated string of paths containing
        unique, extant, directories from those paths and from
        the environment variable. Raise an error if no paths
        are resolved.

        Parameters
        ----------
        name: str
            Environment variable name
        spec_path_lists: list of str
            Paths
        exists: bool
            It True, only return existing paths.

        Return
        ------
        str
            Pathsep-separated paths
        """
        # flatten spec_path_lists
        spec_paths = itertools.chain.from_iterable(spec_path_lists)
        env_paths = environ.get(name, '').split(pathsep)
        paths = itertools.chain(spec_paths, env_paths)
        extant_paths = list(filter(isdir, paths)) if exists else paths
        if not extant_paths:
            msg = "%s environment variable is empty" % name.upper()
            raise distutils.errors.DistutilsPlatformError(msg)
        unique_paths = unique_everseen(extant_paths)
        return pathsep.join(unique_paths)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/namespaces.py0000644000175100001710000000602500000000000020311 0ustar00runnerdockerimport os
from distutils import log
import itertools


flatten = itertools.chain.from_iterable


class Installer:

    nspkg_ext = '-nspkg.pth'

    def install_namespaces(self):
        nsp = self._get_all_ns_packages()
        if not nsp:
            return
        filename, ext = os.path.splitext(self._get_target())
        filename += self.nspkg_ext
        self.outputs.append(filename)
        log.info("Installing %s", filename)
        lines = map(self._gen_nspkg_line, nsp)

        if self.dry_run:
            # always generate the lines, even in dry run
            list(lines)
            return

        with open(filename, 'wt') as f:
            f.writelines(lines)

    def uninstall_namespaces(self):
        filename, ext = os.path.splitext(self._get_target())
        filename += self.nspkg_ext
        if not os.path.exists(filename):
            return
        log.info("Removing %s", filename)
        os.remove(filename)

    def _get_target(self):
        return self.target

    _nspkg_tmpl = (
        "import sys, types, os",
        "has_mfs = sys.version_info > (3, 5)",
        "p = os.path.join(%(root)s, *%(pth)r)",
        "importlib = has_mfs and __import__('importlib.util')",
        "has_mfs and __import__('importlib.machinery')",
        (
            "m = has_mfs and "
            "sys.modules.setdefault(%(pkg)r, "
            "importlib.util.module_from_spec("
            "importlib.machinery.PathFinder.find_spec(%(pkg)r, "
            "[os.path.dirname(p)])))"
        ),
        (
            "m = m or "
            "sys.modules.setdefault(%(pkg)r, types.ModuleType(%(pkg)r))"
        ),
        "mp = (m or []) and m.__dict__.setdefault('__path__',[])",
        "(p not in mp) and mp.append(p)",
    )
    "lines for the namespace installer"

    _nspkg_tmpl_multi = (
        'm and setattr(sys.modules[%(parent)r], %(child)r, m)',
    )
    "additional line(s) when a parent package is indicated"

    def _get_root(self):
        return "sys._getframe(1).f_locals['sitedir']"

    def _gen_nspkg_line(self, pkg):
        pth = tuple(pkg.split('.'))
        root = self._get_root()
        tmpl_lines = self._nspkg_tmpl
        parent, sep, child = pkg.rpartition('.')
        if parent:
            tmpl_lines += self._nspkg_tmpl_multi
        return ';'.join(tmpl_lines) % locals() + '\n'

    def _get_all_ns_packages(self):
        """Return sorted list of all package namespaces"""
        pkgs = self.distribution.namespace_packages or []
        return sorted(flatten(map(self._pkg_names, pkgs)))

    @staticmethod
    def _pkg_names(pkg):
        """
        Given a namespace package, yield the components of that
        package.

        >>> names = Installer._pkg_names('a.b.c')
        >>> set(names) == set(['a', 'a.b', 'a.b.c'])
        True
        """
        parts = pkg.split('.')
        while parts:
            yield '.'.join(parts)
            parts.pop()


class DevelopInstaller(Installer):
    def _get_root(self):
        return repr(str(self.egg_path))

    def _get_target(self):
        return self.egg_link
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/package_index.py0000644000175100001710000011623400000000000020760 0ustar00runnerdocker"""PyPI and direct package downloading"""
import sys
import os
import re
import io
import shutil
import socket
import base64
import hashlib
import itertools
import warnings
import configparser
import html
import http.client
import urllib.parse
import urllib.request
import urllib.error
from functools import wraps

import setuptools
from pkg_resources import (
    CHECKOUT_DIST, Distribution, BINARY_DIST, normalize_path, SOURCE_DIST,
    Environment, find_distributions, safe_name, safe_version,
    to_filename, Requirement, DEVELOP_DIST, EGG_DIST, parse_version,
)
from distutils import log
from distutils.errors import DistutilsError
from fnmatch import translate
from setuptools.wheel import Wheel
from setuptools.extern.more_itertools import unique_everseen


EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.+!]+)$')
HREF = re.compile(r"""href\s*=\s*['"]?([^'"> ]+)""", re.I)
PYPI_MD5 = re.compile(
    r'([^<]+)\n\s+\(md5\)'
)
URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):', re.I).match
EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()

__all__ = [
    'PackageIndex', 'distros_for_url', 'parse_bdist_wininst',
    'interpret_distro_name',
]

_SOCKET_TIMEOUT = 15

_tmpl = "setuptools/{setuptools.__version__} Python-urllib/{py_major}"
user_agent = _tmpl.format(
    py_major='{}.{}'.format(*sys.version_info), setuptools=setuptools)


def parse_requirement_arg(spec):
    try:
        return Requirement.parse(spec)
    except ValueError as e:
        raise DistutilsError(
            "Not a URL, existing file, or requirement spec: %r" % (spec,)
        ) from e


def parse_bdist_wininst(name):
    """Return (base,pyversion) or (None,None) for possible .exe name"""

    lower = name.lower()
    base, py_ver, plat = None, None, None

    if lower.endswith('.exe'):
        if lower.endswith('.win32.exe'):
            base = name[:-10]
            plat = 'win32'
        elif lower.startswith('.win32-py', -16):
            py_ver = name[-7:-4]
            base = name[:-16]
            plat = 'win32'
        elif lower.endswith('.win-amd64.exe'):
            base = name[:-14]
            plat = 'win-amd64'
        elif lower.startswith('.win-amd64-py', -20):
            py_ver = name[-7:-4]
            base = name[:-20]
            plat = 'win-amd64'
    return base, py_ver, plat


def egg_info_for_url(url):
    parts = urllib.parse.urlparse(url)
    scheme, server, path, parameters, query, fragment = parts
    base = urllib.parse.unquote(path.split('/')[-1])
    if server == 'sourceforge.net' and base == 'download':  # XXX Yuck
        base = urllib.parse.unquote(path.split('/')[-2])
    if '#' in base:
        base, fragment = base.split('#', 1)
    return base, fragment


def distros_for_url(url, metadata=None):
    """Yield egg or source distribution objects that might be found at a URL"""
    base, fragment = egg_info_for_url(url)
    for dist in distros_for_location(url, base, metadata):
        yield dist
    if fragment:
        match = EGG_FRAGMENT.match(fragment)
        if match:
            for dist in interpret_distro_name(
                url, match.group(1), metadata, precedence=CHECKOUT_DIST
            ):
                yield dist


def distros_for_location(location, basename, metadata=None):
    """Yield egg or source distribution objects based on basename"""
    if basename.endswith('.egg.zip'):
        basename = basename[:-4]  # strip the .zip
    if basename.endswith('.egg') and '-' in basename:
        # only one, unambiguous interpretation
        return [Distribution.from_location(location, basename, metadata)]
    if basename.endswith('.whl') and '-' in basename:
        wheel = Wheel(basename)
        if not wheel.is_compatible():
            return []
        return [Distribution(
            location=location,
            project_name=wheel.project_name,
            version=wheel.version,
            # Increase priority over eggs.
            precedence=EGG_DIST + 1,
        )]
    if basename.endswith('.exe'):
        win_base, py_ver, platform = parse_bdist_wininst(basename)
        if win_base is not None:
            return interpret_distro_name(
                location, win_base, metadata, py_ver, BINARY_DIST, platform
            )
    # Try source distro extensions (.zip, .tgz, etc.)
    #
    for ext in EXTENSIONS:
        if basename.endswith(ext):
            basename = basename[:-len(ext)]
            return interpret_distro_name(location, basename, metadata)
    return []  # no extension matched


def distros_for_filename(filename, metadata=None):
    """Yield possible egg or source distribution objects based on a filename"""
    return distros_for_location(
        normalize_path(filename), os.path.basename(filename), metadata
    )


def interpret_distro_name(
        location, basename, metadata, py_version=None, precedence=SOURCE_DIST,
        platform=None
):
    """Generate alternative interpretations of a source distro name

    Note: if `location` is a filesystem filename, you should call
    ``pkg_resources.normalize_path()`` on it before passing it to this
    routine!
    """
    # Generate alternative interpretations of a source distro name
    # Because some packages are ambiguous as to name/versions split
    # e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc.
    # So, we generate each possible interpretation (e.g. "adns, python-1.1.0"
    # "adns-python, 1.1.0", and "adns-python-1.1.0, no version").  In practice,
    # the spurious interpretations should be ignored, because in the event
    # there's also an "adns" package, the spurious "python-1.1.0" version will
    # compare lower than any numeric version number, and is therefore unlikely
    # to match a request for it.  It's still a potential problem, though, and
    # in the long run PyPI and the distutils should go for "safe" names and
    # versions in distribution archive names (sdist and bdist).

    parts = basename.split('-')
    if not py_version and any(re.match(r'py\d\.\d$', p) for p in parts[2:]):
        # it is a bdist_dumb, not an sdist -- bail out
        return

    for p in range(1, len(parts) + 1):
        yield Distribution(
            location, metadata, '-'.join(parts[:p]), '-'.join(parts[p:]),
            py_version=py_version, precedence=precedence,
            platform=platform
        )


def unique_values(func):
    """
    Wrap a function returning an iterable such that the resulting iterable
    only ever yields unique items.
    """

    @wraps(func)
    def wrapper(*args, **kwargs):
        return unique_everseen(func(*args, **kwargs))

    return wrapper


REL = re.compile(r"""<([^>]*\srel\s*=\s*['"]?([^'">]+)[^>]*)>""", re.I)
# this line is here to fix emacs' cruddy broken syntax highlighting


@unique_values
def find_external_links(url, page):
    """Find rel="homepage" and rel="download" links in `page`, yielding URLs"""

    for match in REL.finditer(page):
        tag, rel = match.groups()
        rels = set(map(str.strip, rel.lower().split(',')))
        if 'homepage' in rels or 'download' in rels:
            for match in HREF.finditer(tag):
                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))

    for tag in ("Home Page", "Download URL"):
        pos = page.find(tag)
        if pos != -1:
            match = HREF.search(page, pos)
            if match:
                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))


class ContentChecker:
    """
    A null content checker that defines the interface for checking content
    """

    def feed(self, block):
        """
        Feed a block of data to the hash.
        """
        return

    def is_valid(self):
        """
        Check the hash. Return False if validation fails.
        """
        return True

    def report(self, reporter, template):
        """
        Call reporter with information about the checker (hash name)
        substituted into the template.
        """
        return


class HashChecker(ContentChecker):
    pattern = re.compile(
        r'(?Psha1|sha224|sha384|sha256|sha512|md5)='
        r'(?P[a-f0-9]+)'
    )

    def __init__(self, hash_name, expected):
        self.hash_name = hash_name
        self.hash = hashlib.new(hash_name)
        self.expected = expected

    @classmethod
    def from_url(cls, url):
        "Construct a (possibly null) ContentChecker from a URL"
        fragment = urllib.parse.urlparse(url)[-1]
        if not fragment:
            return ContentChecker()
        match = cls.pattern.search(fragment)
        if not match:
            return ContentChecker()
        return cls(**match.groupdict())

    def feed(self, block):
        self.hash.update(block)

    def is_valid(self):
        return self.hash.hexdigest() == self.expected

    def report(self, reporter, template):
        msg = template % self.hash_name
        return reporter(msg)


class PackageIndex(Environment):
    """A distribution index that scans web pages for download URLs"""

    def __init__(
            self, index_url="https://pypi.org/simple/", hosts=('*',),
            ca_bundle=None, verify_ssl=True, *args, **kw
    ):
        Environment.__init__(self, *args, **kw)
        self.index_url = index_url + "/" [:not index_url.endswith('/')]
        self.scanned_urls = {}
        self.fetched_urls = {}
        self.package_pages = {}
        self.allows = re.compile('|'.join(map(translate, hosts))).match
        self.to_scan = []
        self.opener = urllib.request.urlopen

    def add(self, dist):
        # ignore invalid versions
        try:
            parse_version(dist.version)
        except Exception:
            return
        return super().add(dist)

    # FIXME: 'PackageIndex.process_url' is too complex (14)
    def process_url(self, url, retrieve=False):  # noqa: C901
        """Evaluate a URL as a possible download, and maybe retrieve it"""
        if url in self.scanned_urls and not retrieve:
            return
        self.scanned_urls[url] = True
        if not URL_SCHEME(url):
            self.process_filename(url)
            return
        else:
            dists = list(distros_for_url(url))
            if dists:
                if not self.url_ok(url):
                    return
                self.debug("Found link: %s", url)

        if dists or not retrieve or url in self.fetched_urls:
            list(map(self.add, dists))
            return  # don't need the actual page

        if not self.url_ok(url):
            self.fetched_urls[url] = True
            return

        self.info("Reading %s", url)
        self.fetched_urls[url] = True  # prevent multiple fetch attempts
        tmpl = "Download error on %s: %%s -- Some packages may not be found!"
        f = self.open_url(url, tmpl % url)
        if f is None:
            return
        if isinstance(f, urllib.error.HTTPError) and f.code == 401:
            self.info("Authentication error: %s" % f.msg)
        self.fetched_urls[f.url] = True
        if 'html' not in f.headers.get('content-type', '').lower():
            f.close()  # not html, we can't process it
            return

        base = f.url  # handle redirects
        page = f.read()
        if not isinstance(page, str):
            # In Python 3 and got bytes but want str.
            if isinstance(f, urllib.error.HTTPError):
                # Errors have no charset, assume latin1:
                charset = 'latin-1'
            else:
                charset = f.headers.get_param('charset') or 'latin-1'
            page = page.decode(charset, "ignore")
        f.close()
        for match in HREF.finditer(page):
            link = urllib.parse.urljoin(base, htmldecode(match.group(1)))
            self.process_url(link)
        if url.startswith(self.index_url) and getattr(f, 'code', None) != 404:
            page = self.process_index(url, page)

    def process_filename(self, fn, nested=False):
        # process filenames or directories
        if not os.path.exists(fn):
            self.warn("Not found: %s", fn)
            return

        if os.path.isdir(fn) and not nested:
            path = os.path.realpath(fn)
            for item in os.listdir(path):
                self.process_filename(os.path.join(path, item), True)

        dists = distros_for_filename(fn)
        if dists:
            self.debug("Found: %s", fn)
            list(map(self.add, dists))

    def url_ok(self, url, fatal=False):
        s = URL_SCHEME(url)
        is_file = s and s.group(1).lower() == 'file'
        if is_file or self.allows(urllib.parse.urlparse(url)[1]):
            return True
        msg = (
            "\nNote: Bypassing %s (disallowed host; see "
            "http://bit.ly/2hrImnY for details).\n")
        if fatal:
            raise DistutilsError(msg % url)
        else:
            self.warn(msg, url)

    def scan_egg_links(self, search_path):
        dirs = filter(os.path.isdir, search_path)
        egg_links = (
            (path, entry)
            for path in dirs
            for entry in os.listdir(path)
            if entry.endswith('.egg-link')
        )
        list(itertools.starmap(self.scan_egg_link, egg_links))

    def scan_egg_link(self, path, entry):
        with open(os.path.join(path, entry)) as raw_lines:
            # filter non-empty lines
            lines = list(filter(None, map(str.strip, raw_lines)))

        if len(lines) != 2:
            # format is not recognized; punt
            return

        egg_path, setup_path = lines

        for dist in find_distributions(os.path.join(path, egg_path)):
            dist.location = os.path.join(path, *lines)
            dist.precedence = SOURCE_DIST
            self.add(dist)

    def _scan(self, link):
        # Process a URL to see if it's for a package page
        NO_MATCH_SENTINEL = None, None
        if not link.startswith(self.index_url):
            return NO_MATCH_SENTINEL

        parts = list(map(
            urllib.parse.unquote, link[len(self.index_url):].split('/')
        ))
        if len(parts) != 2 or '#' in parts[1]:
            return NO_MATCH_SENTINEL

        # it's a package page, sanitize and index it
        pkg = safe_name(parts[0])
        ver = safe_version(parts[1])
        self.package_pages.setdefault(pkg.lower(), {})[link] = True
        return to_filename(pkg), to_filename(ver)

    def process_index(self, url, page):
        """Process the contents of a PyPI page"""

        # process an index page into the package-page index
        for match in HREF.finditer(page):
            try:
                self._scan(urllib.parse.urljoin(url, htmldecode(match.group(1))))
            except ValueError:
                pass

        pkg, ver = self._scan(url)  # ensure this page is in the page index
        if not pkg:
            return ""  # no sense double-scanning non-package pages

        # process individual package page
        for new_url in find_external_links(url, page):
            # Process the found URL
            base, frag = egg_info_for_url(new_url)
            if base.endswith('.py') and not frag:
                if ver:
                    new_url += '#egg=%s-%s' % (pkg, ver)
                else:
                    self.need_version_info(url)
            self.scan_url(new_url)

        return PYPI_MD5.sub(
            lambda m: '%s' % m.group(1, 3, 2), page
        )

    def need_version_info(self, url):
        self.scan_all(
            "Page at %s links to .py file(s) without version info; an index "
            "scan is required.", url
        )

    def scan_all(self, msg=None, *args):
        if self.index_url not in self.fetched_urls:
            if msg:
                self.warn(msg, *args)
            self.info(
                "Scanning index of all packages (this may take a while)"
            )
        self.scan_url(self.index_url)

    def find_packages(self, requirement):
        self.scan_url(self.index_url + requirement.unsafe_name + '/')

        if not self.package_pages.get(requirement.key):
            # Fall back to safe version of the name
            self.scan_url(self.index_url + requirement.project_name + '/')

        if not self.package_pages.get(requirement.key):
            # We couldn't find the target package, so search the index page too
            self.not_found_in_index(requirement)

        for url in list(self.package_pages.get(requirement.key, ())):
            # scan each page that might be related to the desired package
            self.scan_url(url)

    def obtain(self, requirement, installer=None):
        self.prescan()
        self.find_packages(requirement)
        for dist in self[requirement.key]:
            if dist in requirement:
                return dist
            self.debug("%s does not match %s", requirement, dist)
        return super(PackageIndex, self).obtain(requirement, installer)

    def check_hash(self, checker, filename, tfp):
        """
        checker is a ContentChecker
        """
        checker.report(
            self.debug,
            "Validating %%s checksum for %s" % filename)
        if not checker.is_valid():
            tfp.close()
            os.unlink(filename)
            raise DistutilsError(
                "%s validation failed for %s; "
                "possible download problem?"
                % (checker.hash.name, os.path.basename(filename))
            )

    def add_find_links(self, urls):
        """Add `urls` to the list that will be prescanned for searches"""
        for url in urls:
            if (
                self.to_scan is None  # if we have already "gone online"
                or not URL_SCHEME(url)  # or it's a local file/directory
                or url.startswith('file:')
                or list(distros_for_url(url))  # or a direct package link
            ):
                # then go ahead and process it now
                self.scan_url(url)
            else:
                # otherwise, defer retrieval till later
                self.to_scan.append(url)

    def prescan(self):
        """Scan urls scheduled for prescanning (e.g. --find-links)"""
        if self.to_scan:
            list(map(self.scan_url, self.to_scan))
        self.to_scan = None  # from now on, go ahead and process immediately

    def not_found_in_index(self, requirement):
        if self[requirement.key]:  # we've seen at least one distro
            meth, msg = self.info, "Couldn't retrieve index page for %r"
        else:  # no distros seen for this name, might be misspelled
            meth, msg = (
                self.warn,
                "Couldn't find index page for %r (maybe misspelled?)")
        meth(msg, requirement.unsafe_name)
        self.scan_all()

    def download(self, spec, tmpdir):
        """Locate and/or download `spec` to `tmpdir`, returning a local path

        `spec` may be a ``Requirement`` object, or a string containing a URL,
        an existing local filename, or a project/version requirement spec
        (i.e. the string form of a ``Requirement`` object).  If it is the URL
        of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
        that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
        automatically created alongside the downloaded file.

        If `spec` is a ``Requirement`` object or a string containing a
        project/version requirement spec, this method returns the location of
        a matching distribution (possibly after downloading it to `tmpdir`).
        If `spec` is a locally existing file or directory name, it is simply
        returned unchanged.  If `spec` is a URL, it is downloaded to a subpath
        of `tmpdir`, and the local filename is returned.  Various errors may be
        raised if a problem occurs during downloading.
        """
        if not isinstance(spec, Requirement):
            scheme = URL_SCHEME(spec)
            if scheme:
                # It's a url, download it to tmpdir
                found = self._download_url(scheme.group(1), spec, tmpdir)
                base, fragment = egg_info_for_url(spec)
                if base.endswith('.py'):
                    found = self.gen_setup(found, fragment, tmpdir)
                return found
            elif os.path.exists(spec):
                # Existing file or directory, just return it
                return spec
            else:
                spec = parse_requirement_arg(spec)
        return getattr(self.fetch_distribution(spec, tmpdir), 'location', None)

    def fetch_distribution(  # noqa: C901  # is too complex (14)  # FIXME
            self, requirement, tmpdir, force_scan=False, source=False,
            develop_ok=False, local_index=None):
        """Obtain a distribution suitable for fulfilling `requirement`

        `requirement` must be a ``pkg_resources.Requirement`` instance.
        If necessary, or if the `force_scan` flag is set, the requirement is
        searched for in the (online) package index as well as the locally
        installed packages.  If a distribution matching `requirement` is found,
        the returned distribution's ``location`` is the value you would have
        gotten from calling the ``download()`` method with the matching
        distribution's URL or filename.  If no matching distribution is found,
        ``None`` is returned.

        If the `source` flag is set, only source distributions and source
        checkout links will be considered.  Unless the `develop_ok` flag is
        set, development and system eggs (i.e., those using the ``.egg-info``
        format) will be ignored.
        """
        # process a Requirement
        self.info("Searching for %s", requirement)
        skipped = {}
        dist = None

        def find(req, env=None):
            if env is None:
                env = self
            # Find a matching distribution; may be called more than once

            for dist in env[req.key]:

                if dist.precedence == DEVELOP_DIST and not develop_ok:
                    if dist not in skipped:
                        self.warn(
                            "Skipping development or system egg: %s", dist,
                        )
                        skipped[dist] = 1
                    continue

                test = (
                    dist in req
                    and (dist.precedence <= SOURCE_DIST or not source)
                )
                if test:
                    loc = self.download(dist.location, tmpdir)
                    dist.download_location = loc
                    if os.path.exists(dist.download_location):
                        return dist

        if force_scan:
            self.prescan()
            self.find_packages(requirement)
            dist = find(requirement)

        if not dist and local_index is not None:
            dist = find(requirement, local_index)

        if dist is None:
            if self.to_scan is not None:
                self.prescan()
            dist = find(requirement)

        if dist is None and not force_scan:
            self.find_packages(requirement)
            dist = find(requirement)

        if dist is None:
            self.warn(
                "No local packages or working download links found for %s%s",
                (source and "a source distribution of " or ""),
                requirement,
            )
        else:
            self.info("Best match: %s", dist)
            return dist.clone(location=dist.download_location)

    def fetch(self, requirement, tmpdir, force_scan=False, source=False):
        """Obtain a file suitable for fulfilling `requirement`

        DEPRECATED; use the ``fetch_distribution()`` method now instead.  For
        backward compatibility, this routine is identical but returns the
        ``location`` of the downloaded distribution instead of a distribution
        object.
        """
        dist = self.fetch_distribution(requirement, tmpdir, force_scan, source)
        if dist is not None:
            return dist.location
        return None

    def gen_setup(self, filename, fragment, tmpdir):
        match = EGG_FRAGMENT.match(fragment)
        dists = match and [
            d for d in
            interpret_distro_name(filename, match.group(1), None) if d.version
        ] or []

        if len(dists) == 1:  # unambiguous ``#egg`` fragment
            basename = os.path.basename(filename)

            # Make sure the file has been downloaded to the temp dir.
            if os.path.dirname(filename) != tmpdir:
                dst = os.path.join(tmpdir, basename)
                from setuptools.command.easy_install import samefile
                if not samefile(filename, dst):
                    shutil.copy2(filename, dst)
                    filename = dst

            with open(os.path.join(tmpdir, 'setup.py'), 'w') as file:
                file.write(
                    "from setuptools import setup\n"
                    "setup(name=%r, version=%r, py_modules=[%r])\n"
                    % (
                        dists[0].project_name, dists[0].version,
                        os.path.splitext(basename)[0]
                    )
                )
            return filename

        elif match:
            raise DistutilsError(
                "Can't unambiguously interpret project/version identifier %r; "
                "any dashes in the name or version should be escaped using "
                "underscores. %r" % (fragment, dists)
            )
        else:
            raise DistutilsError(
                "Can't process plain .py files without an '#egg=name-version'"
                " suffix to enable automatic setup script generation."
            )

    dl_blocksize = 8192

    def _download_to(self, url, filename):
        self.info("Downloading %s", url)
        # Download the file
        fp = None
        try:
            checker = HashChecker.from_url(url)
            fp = self.open_url(url)
            if isinstance(fp, urllib.error.HTTPError):
                raise DistutilsError(
                    "Can't download %s: %s %s" % (url, fp.code, fp.msg)
                )
            headers = fp.info()
            blocknum = 0
            bs = self.dl_blocksize
            size = -1
            if "content-length" in headers:
                # Some servers return multiple Content-Length headers :(
                sizes = headers.get_all('Content-Length')
                size = max(map(int, sizes))
                self.reporthook(url, filename, blocknum, bs, size)
            with open(filename, 'wb') as tfp:
                while True:
                    block = fp.read(bs)
                    if block:
                        checker.feed(block)
                        tfp.write(block)
                        blocknum += 1
                        self.reporthook(url, filename, blocknum, bs, size)
                    else:
                        break
                self.check_hash(checker, filename, tfp)
            return headers
        finally:
            if fp:
                fp.close()

    def reporthook(self, url, filename, blocknum, blksize, size):
        pass  # no-op

    # FIXME:
    def open_url(self, url, warning=None):  # noqa: C901  # is too complex (12)
        if url.startswith('file:'):
            return local_open(url)
        try:
            return open_with_auth(url, self.opener)
        except (ValueError, http.client.InvalidURL) as v:
            msg = ' '.join([str(arg) for arg in v.args])
            if warning:
                self.warn(warning, msg)
            else:
                raise DistutilsError('%s %s' % (url, msg)) from v
        except urllib.error.HTTPError as v:
            return v
        except urllib.error.URLError as v:
            if warning:
                self.warn(warning, v.reason)
            else:
                raise DistutilsError("Download error for %s: %s"
                                     % (url, v.reason)) from v
        except http.client.BadStatusLine as v:
            if warning:
                self.warn(warning, v.line)
            else:
                raise DistutilsError(
                    '%s returned a bad status line. The server might be '
                    'down, %s' %
                    (url, v.line)
                ) from v
        except (http.client.HTTPException, socket.error) as v:
            if warning:
                self.warn(warning, v)
            else:
                raise DistutilsError("Download error for %s: %s"
                                     % (url, v)) from v

    def _download_url(self, scheme, url, tmpdir):
        # Determine download filename
        #
        name, fragment = egg_info_for_url(url)
        if name:
            while '..' in name:
                name = name.replace('..', '.').replace('\\', '_')
        else:
            name = "__downloaded__"  # default if URL has no path contents

        if name.endswith('.egg.zip'):
            name = name[:-4]  # strip the extra .zip before download

        filename = os.path.join(tmpdir, name)

        # Download the file
        #
        if scheme == 'svn' or scheme.startswith('svn+'):
            return self._download_svn(url, filename)
        elif scheme == 'git' or scheme.startswith('git+'):
            return self._download_git(url, filename)
        elif scheme.startswith('hg+'):
            return self._download_hg(url, filename)
        elif scheme == 'file':
            return urllib.request.url2pathname(urllib.parse.urlparse(url)[2])
        else:
            self.url_ok(url, True)  # raises error if not allowed
            return self._attempt_download(url, filename)

    def scan_url(self, url):
        self.process_url(url, True)

    def _attempt_download(self, url, filename):
        headers = self._download_to(url, filename)
        if 'html' in headers.get('content-type', '').lower():
            return self._download_html(url, headers, filename)
        else:
            return filename

    def _download_html(self, url, headers, filename):
        file = open(filename)
        for line in file:
            if line.strip():
                # Check for a subversion index page
                if re.search(r'([^- ]+ - )?Revision \d+:', line):
                    # it's a subversion index page:
                    file.close()
                    os.unlink(filename)
                    return self._download_svn(url, filename)
                break  # not an index page
        file.close()
        os.unlink(filename)
        raise DistutilsError("Unexpected HTML page found at " + url)

    def _download_svn(self, url, filename):
        warnings.warn("SVN download support is deprecated", UserWarning)
        url = url.split('#', 1)[0]  # remove any fragment for svn's sake
        creds = ''
        if url.lower().startswith('svn:') and '@' in url:
            scheme, netloc, path, p, q, f = urllib.parse.urlparse(url)
            if not netloc and path.startswith('//') and '/' in path[2:]:
                netloc, path = path[2:].split('/', 1)
                auth, host = _splituser(netloc)
                if auth:
                    if ':' in auth:
                        user, pw = auth.split(':', 1)
                        creds = " --username=%s --password=%s" % (user, pw)
                    else:
                        creds = " --username=" + auth
                    netloc = host
                    parts = scheme, netloc, url, p, q, f
                    url = urllib.parse.urlunparse(parts)
        self.info("Doing subversion checkout from %s to %s", url, filename)
        os.system("svn checkout%s -q %s %s" % (creds, url, filename))
        return filename

    @staticmethod
    def _vcs_split_rev_from_url(url, pop_prefix=False):
        scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)

        scheme = scheme.split('+', 1)[-1]

        # Some fragment identification fails
        path = path.split('#', 1)[0]

        rev = None
        if '@' in path:
            path, rev = path.rsplit('@', 1)

        # Also, discard fragment
        url = urllib.parse.urlunsplit((scheme, netloc, path, query, ''))

        return url, rev

    def _download_git(self, url, filename):
        filename = filename.split('#', 1)[0]
        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)

        self.info("Doing git clone from %s to %s", url, filename)
        os.system("git clone --quiet %s %s" % (url, filename))

        if rev is not None:
            self.info("Checking out %s", rev)
            os.system("git -C %s checkout --quiet %s" % (
                filename,
                rev,
            ))

        return filename

    def _download_hg(self, url, filename):
        filename = filename.split('#', 1)[0]
        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)

        self.info("Doing hg clone from %s to %s", url, filename)
        os.system("hg clone --quiet %s %s" % (url, filename))

        if rev is not None:
            self.info("Updating to %s", rev)
            os.system("hg --cwd %s up -C -r %s -q" % (
                filename,
                rev,
            ))

        return filename

    def debug(self, msg, *args):
        log.debug(msg, *args)

    def info(self, msg, *args):
        log.info(msg, *args)

    def warn(self, msg, *args):
        log.warn(msg, *args)


# This pattern matches a character entity reference (a decimal numeric
# references, a hexadecimal numeric reference, or a named reference).
entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub


def decode_entity(match):
    what = match.group(0)
    return html.unescape(what)


def htmldecode(text):
    """
    Decode HTML entities in the given text.

    >>> htmldecode(
    ...     'https://../package_name-0.1.2.tar.gz'
    ...     '?tokena=A&tokenb=B">package_name-0.1.2.tar.gz')
    'https://../package_name-0.1.2.tar.gz?tokena=A&tokenb=B">package_name-0.1.2.tar.gz'
    """
    return entity_sub(decode_entity, text)


def socket_timeout(timeout=15):
    def _socket_timeout(func):
        def _socket_timeout(*args, **kwargs):
            old_timeout = socket.getdefaulttimeout()
            socket.setdefaulttimeout(timeout)
            try:
                return func(*args, **kwargs)
            finally:
                socket.setdefaulttimeout(old_timeout)

        return _socket_timeout

    return _socket_timeout


def _encode_auth(auth):
    """
    Encode auth from a URL suitable for an HTTP header.
    >>> str(_encode_auth('username%3Apassword'))
    'dXNlcm5hbWU6cGFzc3dvcmQ='

    Long auth strings should not cause a newline to be inserted.
    >>> long_auth = 'username:' + 'password'*10
    >>> chr(10) in str(_encode_auth(long_auth))
    False
    """
    auth_s = urllib.parse.unquote(auth)
    # convert to bytes
    auth_bytes = auth_s.encode()
    encoded_bytes = base64.b64encode(auth_bytes)
    # convert back to a string
    encoded = encoded_bytes.decode()
    # strip the trailing carriage return
    return encoded.replace('\n', '')


class Credential:
    """
    A username/password pair. Use like a namedtuple.
    """

    def __init__(self, username, password):
        self.username = username
        self.password = password

    def __iter__(self):
        yield self.username
        yield self.password

    def __str__(self):
        return '%(username)s:%(password)s' % vars(self)


class PyPIConfig(configparser.RawConfigParser):
    def __init__(self):
        """
        Load from ~/.pypirc
        """
        defaults = dict.fromkeys(['username', 'password', 'repository'], '')
        configparser.RawConfigParser.__init__(self, defaults)

        rc = os.path.join(os.path.expanduser('~'), '.pypirc')
        if os.path.exists(rc):
            self.read(rc)

    @property
    def creds_by_repository(self):
        sections_with_repositories = [
            section for section in self.sections()
            if self.get(section, 'repository').strip()
        ]

        return dict(map(self._get_repo_cred, sections_with_repositories))

    def _get_repo_cred(self, section):
        repo = self.get(section, 'repository').strip()
        return repo, Credential(
            self.get(section, 'username').strip(),
            self.get(section, 'password').strip(),
        )

    def find_credential(self, url):
        """
        If the URL indicated appears to be a repository defined in this
        config, return the credential for that repository.
        """
        for repository, cred in self.creds_by_repository.items():
            if url.startswith(repository):
                return cred


def open_with_auth(url, opener=urllib.request.urlopen):
    """Open a urllib2 request, handling HTTP authentication"""

    parsed = urllib.parse.urlparse(url)
    scheme, netloc, path, params, query, frag = parsed

    # Double scheme does not raise on macOS as revealed by a
    # failing test. We would expect "nonnumeric port". Refs #20.
    if netloc.endswith(':'):
        raise http.client.InvalidURL("nonnumeric port: ''")

    if scheme in ('http', 'https'):
        auth, address = _splituser(netloc)
    else:
        auth = None

    if not auth:
        cred = PyPIConfig().find_credential(url)
        if cred:
            auth = str(cred)
            info = cred.username, url
            log.info('Authenticating as %s for %s (from .pypirc)', *info)

    if auth:
        auth = "Basic " + _encode_auth(auth)
        parts = scheme, address, path, params, query, frag
        new_url = urllib.parse.urlunparse(parts)
        request = urllib.request.Request(new_url)
        request.add_header("Authorization", auth)
    else:
        request = urllib.request.Request(url)

    request.add_header('User-Agent', user_agent)
    fp = opener(request)

    if auth:
        # Put authentication info back into request URL if same host,
        # so that links found on the page will work
        s2, h2, path2, param2, query2, frag2 = urllib.parse.urlparse(fp.url)
        if s2 == scheme and h2 == address:
            parts = s2, netloc, path2, param2, query2, frag2
            fp.url = urllib.parse.urlunparse(parts)

    return fp


# copy of urllib.parse._splituser from Python 3.8
def _splituser(host):
    """splituser('user[:passwd]@host[:port]')
    --> 'user[:passwd]', 'host[:port]'."""
    user, delim, host = host.rpartition('@')
    return (user if delim else None), host


# adding a timeout to avoid freezing package_index
open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth)


def fix_sf_url(url):
    return url  # backward compatibility


def local_open(url):
    """Read a local path, with special support for directories"""
    scheme, server, path, param, query, frag = urllib.parse.urlparse(url)
    filename = urllib.request.url2pathname(path)
    if os.path.isfile(filename):
        return urllib.request.urlopen(url)
    elif path.endswith('/') and os.path.isdir(filename):
        files = []
        for f in os.listdir(filename):
            filepath = os.path.join(filename, f)
            if f == 'index.html':
                with open(filepath, 'r') as fp:
                    body = fp.read()
                break
            elif os.path.isdir(filepath):
                f += '/'
            files.append('<a href="{name}">{name}</a>'.format(name=f))
        else:
            tmpl = (
                "<html><head><title>{url}"
                "{files}")
            body = tmpl.format(url=url, files='\n'.join(files))
        status, message = 200, "OK"
    else:
        status, message, body = 404, "Path not found", "Not found"

    headers = {'content-type': 'text/html'}
    body_stream = io.StringIO(body)
    return urllib.error.HTTPError(url, status, message, headers, body_stream)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/py34compat.py0000644000175100001710000000036500000000000020176 0ustar00runnerdockerimport importlib

try:
    import importlib.util
except ImportError:
    pass


try:
    module_from_spec = importlib.util.module_from_spec
except AttributeError:
    def module_from_spec(spec):
        return spec.loader.load_module(spec.name)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/sandbox.py0000644000175100001710000003401400000000000017627 0ustar00runnerdockerimport os
import sys
import tempfile
import operator
import functools
import itertools
import re
import contextlib
import pickle
import textwrap
import builtins

import pkg_resources
from distutils.errors import DistutilsError
from pkg_resources import working_set

if sys.platform.startswith('java'):
    import org.python.modules.posix.PosixModule as _os
else:
    _os = sys.modules[os.name]
try:
    _file = file
except NameError:
    _file = None
_open = open


__all__ = [
    "AbstractSandbox",
    "DirectorySandbox",
    "SandboxViolation",
    "run_setup",
]


def _execfile(filename, globals, locals=None):
    """
    Python 3 implementation of execfile.
    """
    mode = 'rb'
    with open(filename, mode) as stream:
        script = stream.read()
    if locals is None:
        locals = globals
    code = compile(script, filename, 'exec')
    exec(code, globals, locals)


@contextlib.contextmanager
def save_argv(repl=None):
    saved = sys.argv[:]
    if repl is not None:
        sys.argv[:] = repl
    try:
        yield saved
    finally:
        sys.argv[:] = saved


@contextlib.contextmanager
def save_path():
    saved = sys.path[:]
    try:
        yield saved
    finally:
        sys.path[:] = saved


@contextlib.contextmanager
def override_temp(replacement):
    """
    Monkey-patch tempfile.tempdir with replacement, ensuring it exists
    """
    os.makedirs(replacement, exist_ok=True)

    saved = tempfile.tempdir

    tempfile.tempdir = replacement

    try:
        yield
    finally:
        tempfile.tempdir = saved


@contextlib.contextmanager
def pushd(target):
    saved = os.getcwd()
    os.chdir(target)
    try:
        yield saved
    finally:
        os.chdir(saved)


class UnpickleableException(Exception):
    """
    An exception representing another Exception that could not be pickled.
    """

    @staticmethod
    def dump(type, exc):
        """
        Always return a dumped (pickled) type and exc. If exc can't be pickled,
        wrap it in UnpickleableException first.
        """
        try:
            return pickle.dumps(type), pickle.dumps(exc)
        except Exception:
            # get UnpickleableException inside the sandbox
            from setuptools.sandbox import UnpickleableException as cls

            return cls.dump(cls, cls(repr(exc)))


class ExceptionSaver:
    """
    A Context Manager that will save an exception, serialized, and restore it
    later.
    """

    def __enter__(self):
        return self

    def __exit__(self, type, exc, tb):
        if not exc:
            return

        # dump the exception
        self._saved = UnpickleableException.dump(type, exc)
        self._tb = tb

        # suppress the exception
        return True

    def resume(self):
        "restore and re-raise any exception"

        if '_saved' not in vars(self):
            return

        type, exc = map(pickle.loads, self._saved)
        raise exc.with_traceback(self._tb)


@contextlib.contextmanager
def save_modules():
    """
    Context in which imported modules are saved.

    Translates exceptions internal to the context into the equivalent exception
    outside the context.
    """
    saved = sys.modules.copy()
    with ExceptionSaver() as saved_exc:
        yield saved

    sys.modules.update(saved)
    # remove any modules imported since
    del_modules = (
        mod_name
        for mod_name in sys.modules
        if mod_name not in saved
        # exclude any encodings modules. See #285
        and not mod_name.startswith('encodings.')
    )
    _clear_modules(del_modules)

    saved_exc.resume()


def _clear_modules(module_names):
    for mod_name in list(module_names):
        del sys.modules[mod_name]


@contextlib.contextmanager
def save_pkg_resources_state():
    saved = pkg_resources.__getstate__()
    try:
        yield saved
    finally:
        pkg_resources.__setstate__(saved)


@contextlib.contextmanager
def setup_context(setup_dir):
    temp_dir = os.path.join(setup_dir, 'temp')
    with save_pkg_resources_state():
        with save_modules():
            with save_path():
                hide_setuptools()
                with save_argv():
                    with override_temp(temp_dir):
                        with pushd(setup_dir):
                            # ensure setuptools commands are available
                            __import__('setuptools')
                            yield


_MODULES_TO_HIDE = {
    'setuptools',
    'distutils',
    'pkg_resources',
    'Cython',
    '_distutils_hack',
}


def _needs_hiding(mod_name):
    """
    >>> _needs_hiding('setuptools')
    True
    >>> _needs_hiding('pkg_resources')
    True
    >>> _needs_hiding('setuptools_plugin')
    False
    >>> _needs_hiding('setuptools.__init__')
    True
    >>> _needs_hiding('distutils')
    True
    >>> _needs_hiding('os')
    False
    >>> _needs_hiding('Cython')
    True
    """
    base_module = mod_name.split('.', 1)[0]
    return base_module in _MODULES_TO_HIDE


def hide_setuptools():
    """
    Remove references to setuptools' modules from sys.modules to allow the
    invocation to import the most appropriate setuptools. This technique is
    necessary to avoid issues such as #315 where setuptools upgrading itself
    would fail to find a function declared in the metadata.
    """
    _distutils_hack = sys.modules.get('_distutils_hack', None)
    if _distutils_hack is not None:
        _distutils_hack.remove_shim()

    modules = filter(_needs_hiding, sys.modules)
    _clear_modules(modules)


def run_setup(setup_script, args):
    """Run a distutils setup script, sandboxed in its directory"""
    setup_dir = os.path.abspath(os.path.dirname(setup_script))
    with setup_context(setup_dir):
        try:
            sys.argv[:] = [setup_script] + list(args)
            sys.path.insert(0, setup_dir)
            # reset to include setup dir, w/clean callback list
            working_set.__init__()
            working_set.callbacks.append(lambda dist: dist.activate())

            with DirectorySandbox(setup_dir):
                ns = dict(__file__=setup_script, __name__='__main__')
                _execfile(setup_script, ns)
        except SystemExit as v:
            if v.args and v.args[0]:
                raise
            # Normal exit, just return


class AbstractSandbox:
    """Wrap 'os' module and 'open()' builtin for virtualizing setup scripts"""

    _active = False

    def __init__(self):
        self._attrs = [
            name
            for name in dir(_os)
            if not name.startswith('_') and hasattr(self, name)
        ]

    def _copy(self, source):
        for name in self._attrs:
            setattr(os, name, getattr(source, name))

    def __enter__(self):
        self._copy(self)
        if _file:
            builtins.file = self._file
        builtins.open = self._open
        self._active = True

    def __exit__(self, exc_type, exc_value, traceback):
        self._active = False
        if _file:
            builtins.file = _file
        builtins.open = _open
        self._copy(_os)

    def run(self, func):
        """Run 'func' under os sandboxing"""
        with self:
            return func()

    def _mk_dual_path_wrapper(name):
        original = getattr(_os, name)

        def wrap(self, src, dst, *args, **kw):
            if self._active:
                src, dst = self._remap_pair(name, src, dst, *args, **kw)
            return original(src, dst, *args, **kw)

        return wrap

    for name in ["rename", "link", "symlink"]:
        if hasattr(_os, name):
            locals()[name] = _mk_dual_path_wrapper(name)

    def _mk_single_path_wrapper(name, original=None):
        original = original or getattr(_os, name)

        def wrap(self, path, *args, **kw):
            if self._active:
                path = self._remap_input(name, path, *args, **kw)
            return original(path, *args, **kw)

        return wrap

    if _file:
        _file = _mk_single_path_wrapper('file', _file)
    _open = _mk_single_path_wrapper('open', _open)
    for name in [
        "stat",
        "listdir",
        "chdir",
        "open",
        "chmod",
        "chown",
        "mkdir",
        "remove",
        "unlink",
        "rmdir",
        "utime",
        "lchown",
        "chroot",
        "lstat",
        "startfile",
        "mkfifo",
        "mknod",
        "pathconf",
        "access",
    ]:
        if hasattr(_os, name):
            locals()[name] = _mk_single_path_wrapper(name)

    def _mk_single_with_return(name):
        original = getattr(_os, name)

        def wrap(self, path, *args, **kw):
            if self._active:
                path = self._remap_input(name, path, *args, **kw)
                return self._remap_output(name, original(path, *args, **kw))
            return original(path, *args, **kw)

        return wrap

    for name in ['readlink', 'tempnam']:
        if hasattr(_os, name):
            locals()[name] = _mk_single_with_return(name)

    def _mk_query(name):
        original = getattr(_os, name)

        def wrap(self, *args, **kw):
            retval = original(*args, **kw)
            if self._active:
                return self._remap_output(name, retval)
            return retval

        return wrap

    for name in ['getcwd', 'tmpnam']:
        if hasattr(_os, name):
            locals()[name] = _mk_query(name)

    def _validate_path(self, path):
        """Called to remap or validate any path, whether input or output"""
        return path

    def _remap_input(self, operation, path, *args, **kw):
        """Called for path inputs"""
        return self._validate_path(path)

    def _remap_output(self, operation, path):
        """Called for path outputs"""
        return self._validate_path(path)

    def _remap_pair(self, operation, src, dst, *args, **kw):
        """Called for path pairs like rename, link, and symlink operations"""
        return (
            self._remap_input(operation + '-from', src, *args, **kw),
            self._remap_input(operation + '-to', dst, *args, **kw),
        )


if hasattr(os, 'devnull'):
    _EXCEPTIONS = [os.devnull]
else:
    _EXCEPTIONS = []


class DirectorySandbox(AbstractSandbox):
    """Restrict operations to a single subdirectory - pseudo-chroot"""

    write_ops = dict.fromkeys(
        [
            "open",
            "chmod",
            "chown",
            "mkdir",
            "remove",
            "unlink",
            "rmdir",
            "utime",
            "lchown",
            "chroot",
            "mkfifo",
            "mknod",
            "tempnam",
        ]
    )

    _exception_patterns = []
    "exempt writing to paths that match the pattern"

    def __init__(self, sandbox, exceptions=_EXCEPTIONS):
        self._sandbox = os.path.normcase(os.path.realpath(sandbox))
        self._prefix = os.path.join(self._sandbox, '')
        self._exceptions = [
            os.path.normcase(os.path.realpath(path)) for path in exceptions
        ]
        AbstractSandbox.__init__(self)

    def _violation(self, operation, *args, **kw):
        from setuptools.sandbox import SandboxViolation

        raise SandboxViolation(operation, args, kw)

    if _file:

        def _file(self, path, mode='r', *args, **kw):
            if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
                self._violation("file", path, mode, *args, **kw)
            return _file(path, mode, *args, **kw)

    def _open(self, path, mode='r', *args, **kw):
        if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
            self._violation("open", path, mode, *args, **kw)
        return _open(path, mode, *args, **kw)

    def tmpnam(self):
        self._violation("tmpnam")

    def _ok(self, path):
        active = self._active
        try:
            self._active = False
            realpath = os.path.normcase(os.path.realpath(path))
            return (
                self._exempted(realpath)
                or realpath == self._sandbox
                or realpath.startswith(self._prefix)
            )
        finally:
            self._active = active

    def _exempted(self, filepath):
        start_matches = (
            filepath.startswith(exception) for exception in self._exceptions
        )
        pattern_matches = (
            re.match(pattern, filepath) for pattern in self._exception_patterns
        )
        candidates = itertools.chain(start_matches, pattern_matches)
        return any(candidates)

    def _remap_input(self, operation, path, *args, **kw):
        """Called for path inputs"""
        if operation in self.write_ops and not self._ok(path):
            self._violation(operation, os.path.realpath(path), *args, **kw)
        return path

    def _remap_pair(self, operation, src, dst, *args, **kw):
        """Called for path pairs like rename, link, and symlink operations"""
        if not self._ok(src) or not self._ok(dst):
            self._violation(operation, src, dst, *args, **kw)
        return (src, dst)

    def open(self, file, flags, mode=0o777, *args, **kw):
        """Called for low-level os.open()"""
        if flags & WRITE_FLAGS and not self._ok(file):
            self._violation("os.open", file, flags, mode, *args, **kw)
        return _os.open(file, flags, mode, *args, **kw)


WRITE_FLAGS = functools.reduce(
    operator.or_,
    [
        getattr(_os, a, 0)
        for a in "O_WRONLY O_RDWR O_APPEND O_CREAT O_TRUNC O_TEMPORARY".split()
    ],
)


class SandboxViolation(DistutilsError):
    """A setup script attempted to modify the filesystem outside the sandbox"""

    tmpl = textwrap.dedent(
        """
        SandboxViolation: {cmd}{args!r} {kwargs}

        The package setup script has attempted to modify files on your system
        that are not within the EasyInstall build area, and has been aborted.

        This package cannot be safely installed by EasyInstall, and may not
        support alternate installation locations even if you run its setup
        script by hand.  Please inform the package's author and the EasyInstall
        maintainers to find out if a fix or workaround is available.
        """
    ).lstrip()

    def __str__(self):
        cmd, args, kwargs = self.args
        return self.tmpl.format(**locals())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/script (dev).tmpl0000644000175100001710000000033200000000000020675 0ustar00runnerdocker# EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r
__requires__ = %(spec)r
__import__('pkg_resources').require(%(spec)r)
__file__ = %(dev_path)r
with open(__file__) as f:
    exec(compile(f.read(), __file__, 'exec'))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/script.tmpl0000644000175100001710000000021200000000000020012 0ustar00runnerdocker# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r
__requires__ = %(spec)r
__import__('pkg_resources').run_script(%(spec)r, %(script_name)r)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9586704
setuptools-59.6.0/setuptools/tests/0000755000175100001710000000000000000000000016757 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/__init__.py0000644000175100001710000000031200000000000021064 0ustar00runnerdockerimport locale

import pytest


__all__ = ['fail_on_ascii']


is_ascii = locale.getpreferredencoding() == 'ANSI_X3.4-1968'
fail_on_ascii = pytest.mark.xfail(is_ascii, reason="Test fails in this locale")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/contexts.py0000644000175100001710000000410300000000000021176 0ustar00runnerdockerimport tempfile
import os
import shutil
import sys
import contextlib
import site
import io

import pkg_resources


@contextlib.contextmanager
def tempdir(cd=lambda dir: None, **kwargs):
    temp_dir = tempfile.mkdtemp(**kwargs)
    orig_dir = os.getcwd()
    try:
        cd(temp_dir)
        yield temp_dir
    finally:
        cd(orig_dir)
        shutil.rmtree(temp_dir)


@contextlib.contextmanager
def environment(**replacements):
    """
    In a context, patch the environment with replacements. Pass None values
    to clear the values.
    """
    saved = dict(
        (key, os.environ[key])
        for key in replacements
        if key in os.environ
    )

    # remove values that are null
    remove = (key for (key, value) in replacements.items() if value is None)
    for key in list(remove):
        os.environ.pop(key, None)
        replacements.pop(key)

    os.environ.update(replacements)

    try:
        yield saved
    finally:
        for key in replacements:
            os.environ.pop(key, None)
        os.environ.update(saved)


@contextlib.contextmanager
def quiet():
    """
    Redirect stdout/stderr to StringIO objects to prevent console output from
    distutils commands.
    """

    old_stdout = sys.stdout
    old_stderr = sys.stderr
    new_stdout = sys.stdout = io.StringIO()
    new_stderr = sys.stderr = io.StringIO()
    try:
        yield new_stdout, new_stderr
    finally:
        new_stdout.seek(0)
        new_stderr.seek(0)
        sys.stdout = old_stdout
        sys.stderr = old_stderr


@contextlib.contextmanager
def save_user_site_setting():
    saved = site.ENABLE_USER_SITE
    try:
        yield saved
    finally:
        site.ENABLE_USER_SITE = saved


@contextlib.contextmanager
def save_pkg_resources_state():
    pr_state = pkg_resources.__getstate__()
    # also save sys.path
    sys_path = sys.path[:]
    try:
        yield pr_state, sys_path
    finally:
        sys.path[:] = sys_path
        pkg_resources.__setstate__(pr_state)


@contextlib.contextmanager
def suppress_exceptions(*excs):
    try:
        yield
    except excs:
        pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/environment.py0000644000175100001710000000325000000000000021675 0ustar00runnerdockerimport os
import sys
import unicodedata

from subprocess import Popen as _Popen, PIPE as _PIPE


def _which_dirs(cmd):
    result = set()
    for path in os.environ.get('PATH', '').split(os.pathsep):
        filename = os.path.join(path, cmd)
        if os.access(filename, os.X_OK):
            result.add(path)
    return result


def run_setup_py(cmd, pypath=None, path=None,
                 data_stream=0, env=None):
    """
    Execution command for tests, separate from those used by the
    code directly to prevent accidental behavior issues
    """
    if env is None:
        env = dict()
        for envname in os.environ:
            env[envname] = os.environ[envname]

    # override the python path if needed
    if pypath is not None:
        env["PYTHONPATH"] = pypath

    # override the execution path if needed
    if path is not None:
        env["PATH"] = path
    if not env.get("PATH", ""):
        env["PATH"] = _which_dirs("tar").union(_which_dirs("gzip"))
        env["PATH"] = os.pathsep.join(env["PATH"])

    cmd = [sys.executable, "setup.py"] + list(cmd)

    # http://bugs.python.org/issue8557
    shell = sys.platform == 'win32'

    try:
        proc = _Popen(
            cmd, stdout=_PIPE, stderr=_PIPE, shell=shell, env=env,
        )

        if isinstance(data_stream, tuple):
            data_stream = slice(*data_stream)
        data = proc.communicate()[data_stream]
    except OSError:
        return 1, ''

    # decode the console string if needed
    if hasattr(data, "decode"):
        # use the default encoding
        data = data.decode()
        data = unicodedata.normalize('NFC', data)

    # communicate calls wait()
    return proc.returncode, data
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/fixtures.py0000644000175100001710000000407400000000000021207 0ustar00runnerdockerimport contextlib
import sys
import shutil
import subprocess

import pytest

from . import contexts


@pytest.fixture
def user_override(monkeypatch):
    """
    Override site.USER_BASE and site.USER_SITE with temporary directories in
    a context.
    """
    with contexts.tempdir() as user_base:
        monkeypatch.setattr('site.USER_BASE', user_base)
        with contexts.tempdir() as user_site:
            monkeypatch.setattr('site.USER_SITE', user_site)
            with contexts.save_user_site_setting():
                yield


@pytest.fixture
def tmpdir_cwd(tmpdir):
    with tmpdir.as_cwd() as orig:
        yield orig


@pytest.fixture
def tmp_src(request, tmp_path):
    """Make a copy of the source dir under `$tmp/src`.

    This fixture is useful whenever it's necessary to run `setup.py`
    or `pip install` against the source directory when there's no
    control over the number of simultaneous invocations. Such
    concurrent runs create and delete directories with the same names
    under the target directory and so they influence each other's runs
    when they are not being executed sequentially.
    """
    tmp_src_path = tmp_path / 'src'
    shutil.copytree(request.config.rootdir, tmp_src_path)
    return tmp_src_path


@pytest.fixture(autouse=True, scope="session")
def workaround_xdist_376(request):
    """
    Workaround pytest-dev/pytest-xdist#376

    ``pytest-xdist`` tends to inject '' into ``sys.path``,
    which may break certain isolation expectations.
    Remove the entry so the import
    machinery behaves the same irrespective of xdist.
    """
    if not request.config.pluginmanager.has_plugin('xdist'):
        return

    with contextlib.suppress(ValueError):
        sys.path.remove('')


@pytest.fixture
def sample_project(tmp_path):
    """
    Clone the 'sampleproject' and return a path to it.
    """
    cmd = ['git', 'clone', 'https://github.com/pypa/sampleproject']
    try:
        subprocess.check_call(cmd, cwd=str(tmp_path))
    except Exception:
        pytest.skip("Unable to clone sampleproject")
    return tmp_path / 'sampleproject'
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8866699
setuptools-59.6.0/setuptools/tests/indexes/0000755000175100001710000000000000000000000020416 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9586704
setuptools-59.6.0/setuptools/tests/indexes/test_links_priority/0000755000175100001710000000000000000000000024536 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/indexes/test_links_priority/external.html0000644000175100001710000000013400000000000027244 0ustar00runnerdocker
bad old link

././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.8866699
setuptools-59.6.0/setuptools/tests/indexes/test_links_priority/simple/0000755000175100001710000000000000000000000026027 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9586704
setuptools-59.6.0/setuptools/tests/indexes/test_links_priority/simple/foobar/0000755000175100001710000000000000000000000027277 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html0000644000175100001710000000025600000000000031277 0ustar00runnerdocker
foobar-0.1.tar.gz

external homepage


././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/mod_with_constant.py0000644000175100001710000000002600000000000023052 0ustar00runnerdockervalue = 'three, sir!'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/namespaces.py0000644000175100001710000000244600000000000021456 0ustar00runnerdockerimport textwrap


def build_namespace_package(tmpdir, name):
    src_dir = tmpdir / name
    src_dir.mkdir()
    setup_py = src_dir / 'setup.py'
    namespace, sep, rest = name.partition('.')
    script = textwrap.dedent("""
        import setuptools
        setuptools.setup(
            name={name!r},
            version="1.0",
            namespace_packages=[{namespace!r}],
            packages=[{namespace!r}],
        )
        """).format(**locals())
    setup_py.write_text(script, encoding='utf-8')
    ns_pkg_dir = src_dir / namespace
    ns_pkg_dir.mkdir()
    pkg_init = ns_pkg_dir / '__init__.py'
    tmpl = '__import__("pkg_resources").declare_namespace({namespace!r})'
    decl = tmpl.format(**locals())
    pkg_init.write_text(decl, encoding='utf-8')
    pkg_mod = ns_pkg_dir / (rest + '.py')
    some_functionality = 'name = {rest!r}'.format(**locals())
    pkg_mod.write_text(some_functionality, encoding='utf-8')
    return src_dir


def make_site_dir(target):
    """
    Add a sitecustomize.py module in target to cause
    target to be added to site dirs such that .pth files
    are processed there.
    """
    sc = target / 'sitecustomize.py'
    target_str = str(target)
    tmpl = '__import__("site").addsitedir({target_str!r})'
    sc.write_text(tmpl.format(**locals()), encoding='utf-8')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/script-with-bom.py0000644000175100001710000000005600000000000022362 0ustar00runnerdocker# -*- coding: utf-8 -*-

result = 'passed'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/server.py0000644000175100001710000000464100000000000020644 0ustar00runnerdocker"""Basic http server for tests to simulate PyPI or custom indexes
"""

import os
import time
import threading
import http.server
import urllib.parse
import urllib.request


class IndexServer(http.server.HTTPServer):
    """Basic single-threaded http server simulating a package index

    You can use this server in unittest like this::
        s = IndexServer()
        s.start()
        index_url = s.base_url() + 'mytestindex'
        # do some test requests to the index
        # The index files should be located in setuptools/tests/indexes
        s.stop()
    """

    def __init__(
            self, server_address=('', 0),
            RequestHandlerClass=http.server.SimpleHTTPRequestHandler):
        http.server.HTTPServer.__init__(
            self, server_address, RequestHandlerClass)
        self._run = True

    def start(self):
        self.thread = threading.Thread(target=self.serve_forever)
        self.thread.start()

    def stop(self):
        "Stop the server"

        # Let the server finish the last request and wait for a new one.
        time.sleep(0.1)

        self.shutdown()
        self.thread.join()
        self.socket.close()

    def base_url(self):
        port = self.server_port
        return 'http://127.0.0.1:%s/setuptools/tests/indexes/' % port


class RequestRecorder(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        requests = vars(self.server).setdefault('requests', [])
        requests.append(self)
        self.send_response(200, 'OK')


class MockServer(http.server.HTTPServer, threading.Thread):
    """
    A simple HTTP Server that records the requests made to it.
    """

    def __init__(
            self, server_address=('', 0),
            RequestHandlerClass=RequestRecorder):
        http.server.HTTPServer.__init__(
            self, server_address, RequestHandlerClass)
        threading.Thread.__init__(self)
        self.daemon = True
        self.requests = []

    def run(self):
        self.serve_forever()

    @property
    def netloc(self):
        return 'localhost:%s' % self.server_port

    @property
    def url(self):
        return 'http://%s/' % self.netloc


def path_to_url(path, authority=None):
    """ Convert a path to a file: URL. """
    path = os.path.normpath(os.path.abspath(path))
    base = 'file:'
    if authority is not None:
        base += '//' + authority
    url = urllib.parse.urljoin(base, urllib.request.pathname2url(path))
    return url
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_archive_util.py0000644000175100001710000000153600000000000023053 0ustar00runnerdocker# coding: utf-8

import tarfile
import io

import pytest

from setuptools import archive_util


@pytest.fixture
def tarfile_with_unicode(tmpdir):
    """
    Create a tarfile containing only a file whose name is
    a zero byte file called testimäge.png.
    """
    tarobj = io.BytesIO()

    with tarfile.open(fileobj=tarobj, mode="w:gz") as tgz:
        data = b""

        filename = "testimäge.png"

        t = tarfile.TarInfo(filename)
        t.size = len(data)

        tgz.addfile(t, io.BytesIO(data))

    target = tmpdir / 'unicode-pkg-1.0.tar.gz'
    with open(str(target), mode='wb') as tf:
        tf.write(tarobj.getvalue())
    return str(target)


@pytest.mark.xfail(reason="#710 and #712")
def test_unicode_files(tarfile_with_unicode, tmpdir):
    target = tmpdir / 'out'
    archive_util.unpack_archive(tarfile_with_unicode, str(target))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_bdist_deprecations.py0000644000175100001710000000122700000000000024237 0ustar00runnerdocker"""develop tests
"""
import mock
import sys

import pytest

from setuptools.dist import Distribution
from setuptools import SetuptoolsDeprecationWarning


@pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
@mock.patch('distutils.command.bdist_rpm.bdist_rpm')
def test_bdist_rpm_warning(distutils_cmd):
    dist = Distribution(
        dict(
            script_name='setup.py',
            script_args=['bdist_rpm'],
            name='foo',
            py_modules=['hi'],
        )
    )
    dist.parse_command_line()
    with pytest.warns(SetuptoolsDeprecationWarning):
        dist.run_commands()

    distutils_cmd.run.assert_called_once()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_bdist_egg.py0000644000175100001710000000341000000000000022315 0ustar00runnerdocker"""develop tests
"""
import os
import re
import zipfile

import pytest

from setuptools.dist import Distribution

from . import contexts

SETUP_PY = """\
from setuptools import setup

setup(name='foo', py_modules=['hi'])
"""


@pytest.fixture(scope='function')
def setup_context(tmpdir):
    with (tmpdir / 'setup.py').open('w') as f:
        f.write(SETUP_PY)
    with (tmpdir / 'hi.py').open('w') as f:
        f.write('1\n')
    with tmpdir.as_cwd():
        yield tmpdir


class Test:
    def test_bdist_egg(self, setup_context, user_override):
        dist = Distribution(dict(
            script_name='setup.py',
            script_args=['bdist_egg'],
            name='foo',
            py_modules=['hi'],
        ))
        os.makedirs(os.path.join('build', 'src'))
        with contexts.quiet():
            dist.parse_command_line()
            dist.run_commands()

        # let's see if we got our egg link at the right place
        [content] = os.listdir('dist')
        assert re.match(r'foo-0.0.0-py[23].\d+.egg$', content)

    @pytest.mark.xfail(
        os.environ.get('PYTHONDONTWRITEBYTECODE'),
        reason="Byte code disabled",
    )
    def test_exclude_source_files(self, setup_context, user_override):
        dist = Distribution(dict(
            script_name='setup.py',
            script_args=['bdist_egg', '--exclude-source-files'],
            name='foo',
            py_modules=['hi'],
        ))
        with contexts.quiet():
            dist.parse_command_line()
            dist.run_commands()
        [dist_name] = os.listdir('dist')
        dist_filename = os.path.join('dist', dist_name)
        zip = zipfile.ZipFile(dist_filename)
        names = list(zi.filename for zi in zip.filelist)
        assert 'hi.pyc' in names
        assert 'hi.py' not in names
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_build_clib.py0000644000175100001710000000410500000000000022460 0ustar00runnerdockerimport pytest

import mock
from distutils.errors import DistutilsSetupError
from setuptools.command.build_clib import build_clib
from setuptools.dist import Distribution


class TestBuildCLib:
    @mock.patch(
        'setuptools.command.build_clib.newer_pairwise_group')
    def test_build_libraries(self, mock_newer):
        dist = Distribution()
        cmd = build_clib(dist)

        # this will be a long section, just making sure all
        # exceptions are properly raised
        libs = [('example', {'sources': 'broken.c'})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        obj_deps = 'some_string'
        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        obj_deps = {'': ''}
        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        obj_deps = {'source.c': ''}
        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        # with that out of the way, let's see if the crude dependency
        # system works
        cmd.compiler = mock.MagicMock(spec=cmd.compiler)
        mock_newer.return_value = ([], [])

        obj_deps = {'': ('global.h',), 'example.c': ('example.h',)}
        libs = [('example', {'sources': ['example.c'], 'obj_deps': obj_deps})]

        cmd.build_libraries(libs)
        assert [['example.c', 'global.h', 'example.h']] in \
            mock_newer.call_args[0]
        assert not cmd.compiler.compile.called
        assert cmd.compiler.create_static_lib.call_count == 1

        # reset the call numbers so we can test again
        cmd.compiler.reset_mock()

        mock_newer.return_value = ''  # anything as long as it's not ([],[])
        cmd.build_libraries(libs)
        assert cmd.compiler.compile.call_count == 1
        assert cmd.compiler.create_static_lib.call_count == 1
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_build_ext.py0000644000175100001710000001025400000000000022351 0ustar00runnerdockerimport os
import sys
import distutils.command.build_ext as orig
from distutils.sysconfig import get_config_var

from jaraco import path

from setuptools.command.build_ext import build_ext, get_abi3_suffix
from setuptools.dist import Distribution
from setuptools.extension import Extension

from . import environment
from .textwrap import DALS


IS_PYPY = '__pypy__' in sys.builtin_module_names


class TestBuildExt:
    def test_get_ext_filename(self):
        """
        Setuptools needs to give back the same
        result as distutils, even if the fullname
        is not in ext_map.
        """
        dist = Distribution()
        cmd = build_ext(dist)
        cmd.ext_map['foo/bar'] = ''
        res = cmd.get_ext_filename('foo')
        wanted = orig.build_ext.get_ext_filename(cmd, 'foo')
        assert res == wanted

    def test_abi3_filename(self):
        """
        Filename needs to be loadable by several versions
        of Python 3 if 'is_abi3' is truthy on Extension()
        """
        print(get_abi3_suffix())

        extension = Extension('spam.eggs', ['eggs.c'], py_limited_api=True)
        dist = Distribution(dict(ext_modules=[extension]))
        cmd = build_ext(dist)
        cmd.finalize_options()
        assert 'spam.eggs' in cmd.ext_map
        res = cmd.get_ext_filename('spam.eggs')

        if not get_abi3_suffix():
            assert res.endswith(get_config_var('EXT_SUFFIX'))
        elif sys.platform == 'win32':
            assert res.endswith('eggs.pyd')
        else:
            assert 'abi3' in res

    def test_ext_suffix_override(self):
        """
        SETUPTOOLS_EXT_SUFFIX variable always overrides
        default extension options.
        """
        dist = Distribution()
        cmd = build_ext(dist)
        cmd.ext_map['for_abi3'] = ext = Extension(
            'for_abi3',
            ['s.c'],
            # Override shouldn't affect abi3 modules
            py_limited_api=True,
        )
        # Mock value needed to pass tests
        ext._links_to_dynamic = False

        if not IS_PYPY:
            expect = cmd.get_ext_filename('for_abi3')
        else:
            # PyPy builds do not use ABI3 tag, so they will
            # also get the overridden suffix.
            expect = 'for_abi3.test-suffix'

        try:
            os.environ['SETUPTOOLS_EXT_SUFFIX'] = '.test-suffix'
            res = cmd.get_ext_filename('normal')
            assert 'normal.test-suffix' == res
            res = cmd.get_ext_filename('for_abi3')
            assert expect == res
        finally:
            del os.environ['SETUPTOOLS_EXT_SUFFIX']


def test_build_ext_config_handling(tmpdir_cwd):
    files = {
        'setup.py': DALS(
            """
            from setuptools import Extension, setup
            setup(
                name='foo',
                version='0.0.0',
                ext_modules=[Extension('foo', ['foo.c'])],
            )
            """),
        'foo.c': DALS(
            """
            #include "Python.h"

            #if PY_MAJOR_VERSION >= 3

            static struct PyModuleDef moduledef = {
                    PyModuleDef_HEAD_INIT,
                    "foo",
                    NULL,
                    0,
                    NULL,
                    NULL,
                    NULL,
                    NULL,
                    NULL
            };

            #define INITERROR return NULL

            PyMODINIT_FUNC PyInit_foo(void)

            #else

            #define INITERROR return

            void initfoo(void)

            #endif
            {
            #if PY_MAJOR_VERSION >= 3
                PyObject *module = PyModule_Create(&moduledef);
            #else
                PyObject *module = Py_InitModule("extension", NULL);
            #endif
                if (module == NULL)
                    INITERROR;
            #if PY_MAJOR_VERSION >= 3
                return module;
            #endif
            }
            """),
        'setup.cfg': DALS(
            """
            [build]
            build_base = foo_build
            """),
    }
    path.build(files)
    code, output = environment.run_setup_py(
        cmd=['build'], data_stream=(0, 2),
    )
    assert code == 0, '\nSTDOUT:\n%s\nSTDERR:\n%s' % output
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_build_meta.py0000644000175100001710000003615400000000000022506 0ustar00runnerdockerimport os
import shutil
import tarfile
import importlib
from concurrent import futures
import re

import pytest
from jaraco import path

from .textwrap import DALS


class BuildBackendBase:
    def __init__(self, cwd='.', env={}, backend_name='setuptools.build_meta'):
        self.cwd = cwd
        self.env = env
        self.backend_name = backend_name


class BuildBackend(BuildBackendBase):
    """PEP 517 Build Backend"""

    def __init__(self, *args, **kwargs):
        super(BuildBackend, self).__init__(*args, **kwargs)
        self.pool = futures.ProcessPoolExecutor(max_workers=1)

    def __getattr__(self, name):
        """Handles aribrary function invocations on the build backend."""

        def method(*args, **kw):
            root = os.path.abspath(self.cwd)
            caller = BuildBackendCaller(root, self.env, self.backend_name)
            return self.pool.submit(caller, name, *args, **kw).result()

        return method


class BuildBackendCaller(BuildBackendBase):
    def __init__(self, *args, **kwargs):
        super(BuildBackendCaller, self).__init__(*args, **kwargs)

        (self.backend_name, _,
         self.backend_obj) = self.backend_name.partition(':')

    def __call__(self, name, *args, **kw):
        """Handles aribrary function invocations on the build backend."""
        os.chdir(self.cwd)
        os.environ.update(self.env)
        mod = importlib.import_module(self.backend_name)

        if self.backend_obj:
            backend = getattr(mod, self.backend_obj)
        else:
            backend = mod

        return getattr(backend, name)(*args, **kw)


defns = [
    {
        'setup.py': DALS("""
            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
                py_modules=['hello'],
                setup_requires=['six'],
            )
            """),
        'hello.py': DALS("""
            def run():
                print('hello')
            """),
    },
    {
        'setup.py': DALS("""
            assert __name__ == '__main__'
            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
                py_modules=['hello'],
                setup_requires=['six'],
            )
            """),
        'hello.py': DALS("""
            def run():
                print('hello')
            """),
    },
    {
        'setup.py': DALS("""
            variable = True
            def function():
                return variable
            assert variable
            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
                py_modules=['hello'],
                setup_requires=['six'],
            )
            """),
        'hello.py': DALS("""
            def run():
                print('hello')
            """),
    },
    {
        'setup.cfg': DALS("""
        [metadata]
        name = foo
        version = 0.0.0

        [options]
        py_modules=hello
        setup_requires=six
        """),
        'hello.py': DALS("""
        def run():
            print('hello')
        """)
    },
]


class TestBuildMetaBackend:
    backend_name = 'setuptools.build_meta'

    def get_build_backend(self):
        return BuildBackend(backend_name=self.backend_name)

    @pytest.fixture(params=defns)
    def build_backend(self, tmpdir, request):
        path.build(request.param, prefix=str(tmpdir))
        with tmpdir.as_cwd():
            yield self.get_build_backend()

    def test_get_requires_for_build_wheel(self, build_backend):
        actual = build_backend.get_requires_for_build_wheel()
        expected = ['six', 'wheel']
        assert sorted(actual) == sorted(expected)

    def test_get_requires_for_build_sdist(self, build_backend):
        actual = build_backend.get_requires_for_build_sdist()
        expected = ['six']
        assert sorted(actual) == sorted(expected)

    def test_build_wheel(self, build_backend):
        dist_dir = os.path.abspath('pip-wheel')
        os.makedirs(dist_dir)
        wheel_name = build_backend.build_wheel(dist_dir)

        assert os.path.isfile(os.path.join(dist_dir, wheel_name))

    @pytest.mark.parametrize('build_type', ('wheel', 'sdist'))
    def test_build_with_existing_file_present(self, build_type, tmpdir_cwd):
        # Building a sdist/wheel should still succeed if there's
        # already a sdist/wheel in the destination directory.
        files = {
            'setup.py': "from setuptools import setup\nsetup()",
            'VERSION': "0.0.1",
            'setup.cfg': DALS("""
                [metadata]
                name = foo
                version = file: VERSION
            """),
            'pyproject.toml': DALS("""
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"
            """),
        }

        path.build(files)

        dist_dir = os.path.abspath('preexisting-' + build_type)

        build_backend = self.get_build_backend()
        build_method = getattr(build_backend, 'build_' + build_type)

        # Build a first sdist/wheel.
        # Note: this also check the destination directory is
        # successfully created if it does not exist already.
        first_result = build_method(dist_dir)

        # Change version.
        with open("VERSION", "wt") as version_file:
            version_file.write("0.0.2")

        # Build a *second* sdist/wheel.
        second_result = build_method(dist_dir)

        assert os.path.isfile(os.path.join(dist_dir, first_result))
        assert first_result != second_result

        # And if rebuilding the exact same sdist/wheel?
        open(os.path.join(dist_dir, second_result), 'w').close()
        third_result = build_method(dist_dir)
        assert third_result == second_result
        assert os.path.getsize(os.path.join(dist_dir, third_result)) > 0

    def test_build_sdist(self, build_backend):
        dist_dir = os.path.abspath('pip-sdist')
        os.makedirs(dist_dir)
        sdist_name = build_backend.build_sdist(dist_dir)

        assert os.path.isfile(os.path.join(dist_dir, sdist_name))

    def test_prepare_metadata_for_build_wheel(self, build_backend):
        dist_dir = os.path.abspath('pip-dist-info')
        os.makedirs(dist_dir)

        dist_info = build_backend.prepare_metadata_for_build_wheel(dist_dir)

        assert os.path.isfile(os.path.join(dist_dir, dist_info, 'METADATA'))

    def test_build_sdist_explicit_dist(self, build_backend):
        # explicitly specifying the dist folder should work
        # the folder sdist_directory and the ``--dist-dir`` can be the same
        dist_dir = os.path.abspath('dist')
        sdist_name = build_backend.build_sdist(dist_dir)
        assert os.path.isfile(os.path.join(dist_dir, sdist_name))

    def test_build_sdist_version_change(self, build_backend):
        sdist_into_directory = os.path.abspath("out_sdist")
        os.makedirs(sdist_into_directory)

        sdist_name = build_backend.build_sdist(sdist_into_directory)
        assert os.path.isfile(os.path.join(sdist_into_directory, sdist_name))

        # if the setup.py changes subsequent call of the build meta
        # should still succeed, given the
        # sdist_directory the frontend specifies is empty
        setup_loc = os.path.abspath("setup.py")
        if not os.path.exists(setup_loc):
            setup_loc = os.path.abspath("setup.cfg")

        with open(setup_loc, 'rt') as file_handler:
            content = file_handler.read()
        with open(setup_loc, 'wt') as file_handler:
            file_handler.write(
                content.replace("version='0.0.0'", "version='0.0.1'"))

        shutil.rmtree(sdist_into_directory)
        os.makedirs(sdist_into_directory)

        sdist_name = build_backend.build_sdist("out_sdist")
        assert os.path.isfile(
            os.path.join(os.path.abspath("out_sdist"), sdist_name))

    def test_build_sdist_pyproject_toml_exists(self, tmpdir_cwd):
        files = {
            'setup.py': DALS("""
                __import__('setuptools').setup(
                    name='foo',
                    version='0.0.0',
                    py_modules=['hello']
                )"""),
            'hello.py': '',
            'pyproject.toml': DALS("""
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"
                """),
        }
        path.build(files)
        build_backend = self.get_build_backend()
        targz_path = build_backend.build_sdist("temp")
        with tarfile.open(os.path.join("temp", targz_path)) as tar:
            assert any('pyproject.toml' in name for name in tar.getnames())

    def test_build_sdist_setup_py_exists(self, tmpdir_cwd):
        # If build_sdist is called from a script other than setup.py,
        # ensure setup.py is included
        path.build(defns[0])

        build_backend = self.get_build_backend()
        targz_path = build_backend.build_sdist("temp")
        with tarfile.open(os.path.join("temp", targz_path)) as tar:
            assert any('setup.py' in name for name in tar.getnames())

    def test_build_sdist_setup_py_manifest_excluded(self, tmpdir_cwd):
        # Ensure that MANIFEST.in can exclude setup.py
        files = {
            'setup.py': DALS("""
        __import__('setuptools').setup(
            name='foo',
            version='0.0.0',
            py_modules=['hello']
        )"""),
            'hello.py': '',
            'MANIFEST.in': DALS("""
        exclude setup.py
        """)
        }

        path.build(files)

        build_backend = self.get_build_backend()
        targz_path = build_backend.build_sdist("temp")
        with tarfile.open(os.path.join("temp", targz_path)) as tar:
            assert not any('setup.py' in name for name in tar.getnames())

    def test_build_sdist_builds_targz_even_if_zip_indicated(self, tmpdir_cwd):
        files = {
            'setup.py': DALS("""
                __import__('setuptools').setup(
                    name='foo',
                    version='0.0.0',
                    py_modules=['hello']
                )"""),
            'hello.py': '',
            'setup.cfg': DALS("""
                [sdist]
                formats=zip
                """)
        }

        path.build(files)

        build_backend = self.get_build_backend()
        build_backend.build_sdist("temp")

    _relative_path_import_files = {
        'setup.py': DALS("""
            __import__('setuptools').setup(
                name='foo',
                version=__import__('hello').__version__,
                py_modules=['hello']
            )"""),
        'hello.py': '__version__ = "0.0.0"',
        'setup.cfg': DALS("""
            [sdist]
            formats=zip
            """)
    }

    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
        path.build(self._relative_path_import_files)
        build_backend = self.get_build_backend()
        with pytest.raises(ImportError, match="^No module named 'hello'$"):
            build_backend.build_sdist("temp")

    @pytest.mark.parametrize('setup_literal, requirements', [
        ("'foo'", ['foo']),
        ("['foo']", ['foo']),
        (r"'foo\n'", ['foo']),
        (r"'foo\n\n'", ['foo']),
        ("['foo', 'bar']", ['foo', 'bar']),
        (r"'# Has a comment line\nfoo'", ['foo']),
        (r"'foo # Has an inline comment'", ['foo']),
        (r"'foo \\\n >=3.0'", ['foo>=3.0']),
        (r"'foo\nbar'", ['foo', 'bar']),
        (r"'foo\nbar\n'", ['foo', 'bar']),
        (r"['foo\n', 'bar\n']", ['foo', 'bar']),
    ])
    @pytest.mark.parametrize('use_wheel', [True, False])
    def test_setup_requires(self, setup_literal, requirements, use_wheel,
                            tmpdir_cwd):

        files = {
            'setup.py': DALS("""
                from setuptools import setup

                setup(
                    name="qux",
                    version="0.0.0",
                    py_modules=["hello"],
                    setup_requires={setup_literal},
                )
            """).format(setup_literal=setup_literal),
            'hello.py': DALS("""
            def run():
                print('hello')
            """),
        }

        path.build(files)

        build_backend = self.get_build_backend()

        if use_wheel:
            base_requirements = ['wheel']
            get_requires = build_backend.get_requires_for_build_wheel
        else:
            base_requirements = []
            get_requires = build_backend.get_requires_for_build_sdist

        # Ensure that the build requirements are properly parsed
        expected = sorted(base_requirements + requirements)
        actual = get_requires()

        assert expected == sorted(actual)

    def test_dont_install_setup_requires(self, tmpdir_cwd):
        files = {
            'setup.py': DALS("""
                        from setuptools import setup

                        setup(
                            name="qux",
                            version="0.0.0",
                            py_modules=["hello"],
                            setup_requires=["does-not-exist >99"],
                        )
                    """),
            'hello.py': DALS("""
                    def run():
                        print('hello')
                    """),
        }

        path.build(files)

        build_backend = self.get_build_backend()

        dist_dir = os.path.abspath('pip-dist-info')
        os.makedirs(dist_dir)

        # does-not-exist can't be satisfied, so if it attempts to install
        # setup_requires, it will fail.
        build_backend.prepare_metadata_for_build_wheel(dist_dir)

    _sys_argv_0_passthrough = {
        'setup.py': DALS("""
            import os
            import sys

            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
            )

            sys_argv = os.path.abspath(sys.argv[0])
            file_path = os.path.abspath('setup.py')
            assert sys_argv == file_path
            """)
    }

    def test_sys_argv_passthrough(self, tmpdir_cwd):
        path.build(self._sys_argv_0_passthrough)
        build_backend = self.get_build_backend()
        with pytest.raises(AssertionError):
            build_backend.build_sdist("temp")

    @pytest.mark.parametrize('build_hook', ('build_sdist', 'build_wheel'))
    def test_build_with_empty_setuppy(self, build_backend, build_hook):
        files = {'setup.py': ''}
        path.build(files)

        with pytest.raises(
                ValueError,
                match=re.escape('No distribution was found.')):
            getattr(build_backend, build_hook)("temp")


class TestBuildMetaLegacyBackend(TestBuildMetaBackend):
    backend_name = 'setuptools.build_meta:__legacy__'

    # build_meta_legacy-specific tests
    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
        # This must fail in build_meta, but must pass in build_meta_legacy
        path.build(self._relative_path_import_files)

        build_backend = self.get_build_backend()
        build_backend.build_sdist("temp")

    def test_sys_argv_passthrough(self, tmpdir_cwd):
        path.build(self._sys_argv_0_passthrough)

        build_backend = self.get_build_backend()
        build_backend.build_sdist("temp")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_build_py.py0000644000175100001710000000403500000000000022201 0ustar00runnerdockerimport os
import stat
import shutil

import pytest

from setuptools.dist import Distribution


def test_directories_in_package_data_glob(tmpdir_cwd):
    """
    Directories matching the glob in package_data should
    not be included in the package data.

    Regression test for #261.
    """
    dist = Distribution(dict(
        script_name='setup.py',
        script_args=['build_py'],
        packages=[''],
        name='foo',
        package_data={'': ['path/*']},
    ))
    os.makedirs('path/subpath')
    dist.parse_command_line()
    dist.run_commands()


def test_read_only(tmpdir_cwd):
    """
    Ensure read-only flag is not preserved in copy
    for package modules and package data, as that
    causes problems with deleting read-only files on
    Windows.

    #1451
    """
    dist = Distribution(dict(
        script_name='setup.py',
        script_args=['build_py'],
        packages=['pkg'],
        package_data={'pkg': ['data.dat']},
        name='pkg',
    ))
    os.makedirs('pkg')
    open('pkg/__init__.py', 'w').close()
    open('pkg/data.dat', 'w').close()
    os.chmod('pkg/__init__.py', stat.S_IREAD)
    os.chmod('pkg/data.dat', stat.S_IREAD)
    dist.parse_command_line()
    dist.run_commands()
    shutil.rmtree('build')


@pytest.mark.xfail(
    'platform.system() == "Windows"',
    reason="On Windows, files do not have executable bits",
    raises=AssertionError,
    strict=True,
)
def test_executable_data(tmpdir_cwd):
    """
    Ensure executable bit is preserved in copy for
    package data, as users rely on it for scripts.

    #2041
    """
    dist = Distribution(dict(
        script_name='setup.py',
        script_args=['build_py'],
        packages=['pkg'],
        package_data={'pkg': ['run-me']},
        name='pkg',
    ))
    os.makedirs('pkg')
    open('pkg/__init__.py', 'w').close()
    open('pkg/run-me', 'w').close()
    os.chmod('pkg/run-me', 0o700)

    dist.parse_command_line()
    dist.run_commands()

    assert os.stat('build/lib/pkg/run-me').st_mode & stat.S_IEXEC, \
        "Script is not executable"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_config.py0000644000175100001710000007264200000000000021650 0ustar00runnerdockerimport types
import sys

import contextlib
import configparser

import pytest

from distutils.errors import DistutilsOptionError, DistutilsFileError
from mock import patch
from setuptools.dist import Distribution, _Distribution
from setuptools.config import ConfigHandler, read_configuration
from distutils.core import Command
from .textwrap import DALS


class ErrConfigHandler(ConfigHandler):
    """Erroneous handler. Fails to implement required methods."""


def make_package_dir(name, base_dir, ns=False):
    dir_package = base_dir
    for dir_name in name.split('/'):
        dir_package = dir_package.mkdir(dir_name)
    init_file = None
    if not ns:
        init_file = dir_package.join('__init__.py')
        init_file.write('')
    return dir_package, init_file


def fake_env(
    tmpdir, setup_cfg, setup_py=None, encoding='ascii', package_path='fake_package'
):

    if setup_py is None:
        setup_py = 'from setuptools import setup\n' 'setup()\n'

    tmpdir.join('setup.py').write(setup_py)
    config = tmpdir.join('setup.cfg')
    config.write(setup_cfg.encode(encoding), mode='wb')

    package_dir, init_file = make_package_dir(package_path, tmpdir)

    init_file.write(
        'VERSION = (1, 2, 3)\n'
        '\n'
        'VERSION_MAJOR = 1'
        '\n'
        'def get_version():\n'
        '    return [3, 4, 5, "dev"]\n'
        '\n'
    )

    return package_dir, config


@contextlib.contextmanager
def get_dist(tmpdir, kwargs_initial=None, parse=True):
    kwargs_initial = kwargs_initial or {}

    with tmpdir.as_cwd():
        dist = Distribution(kwargs_initial)
        dist.script_name = 'setup.py'
        parse and dist.parse_config_files()

        yield dist


def test_parsers_implemented():

    with pytest.raises(NotImplementedError):
        handler = ErrConfigHandler(None, {})
        handler.parsers


class TestConfigurationReader:
    def test_basic(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = 10.1.1\n'
            'keywords = one, two\n'
            '\n'
            '[options]\n'
            'scripts = bin/a.py, bin/b.py\n',
        )
        config_dict = read_configuration('%s' % config)
        assert config_dict['metadata']['version'] == '10.1.1'
        assert config_dict['metadata']['keywords'] == ['one', 'two']
        assert config_dict['options']['scripts'] == ['bin/a.py', 'bin/b.py']

    def test_no_config(self, tmpdir):
        with pytest.raises(DistutilsFileError):
            read_configuration('%s' % tmpdir.join('setup.cfg'))

    def test_ignore_errors(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[metadata]\n' 'version = attr: none.VERSION\n' 'keywords = one, two\n',
        )
        with pytest.raises(ImportError):
            read_configuration('%s' % config)

        config_dict = read_configuration('%s' % config, ignore_option_errors=True)

        assert config_dict['metadata']['keywords'] == ['one', 'two']
        assert 'version' not in config_dict['metadata']

        config.remove()


class TestMetadata:
    def test_basic(self, tmpdir):

        fake_env(
            tmpdir,
            '[metadata]\n'
            'version = 10.1.1\n'
            'description = Some description\n'
            'long_description_content_type = text/something\n'
            'long_description = file: README\n'
            'name = fake_name\n'
            'keywords = one, two\n'
            'provides = package, package.sub\n'
            'license = otherlic\n'
            'download_url = http://test.test.com/test/\n'
            'maintainer_email = test@test.com\n',
        )

        tmpdir.join('README').write('readme contents\nline2')

        meta_initial = {
            # This will be used so `otherlic` won't replace it.
            'license': 'BSD 3-Clause License',
        }

        with get_dist(tmpdir, meta_initial) as dist:
            metadata = dist.metadata

            assert metadata.version == '10.1.1'
            assert metadata.description == 'Some description'
            assert metadata.long_description_content_type == 'text/something'
            assert metadata.long_description == 'readme contents\nline2'
            assert metadata.provides == ['package', 'package.sub']
            assert metadata.license == 'BSD 3-Clause License'
            assert metadata.name == 'fake_name'
            assert metadata.keywords == ['one', 'two']
            assert metadata.download_url == 'http://test.test.com/test/'
            assert metadata.maintainer_email == 'test@test.com'

    def test_license_cfg(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [metadata]
            name=foo
            version=0.0.1
            license=Apache 2.0
            """
            ),
        )

        with get_dist(tmpdir) as dist:
            metadata = dist.metadata

            assert metadata.name == "foo"
            assert metadata.version == "0.0.1"
            assert metadata.license == "Apache 2.0"

    def test_file_mixed(self, tmpdir):

        fake_env(
            tmpdir,
            '[metadata]\n' 'long_description = file: README.rst, CHANGES.rst\n' '\n',
        )

        tmpdir.join('README.rst').write('readme contents\nline2')
        tmpdir.join('CHANGES.rst').write('changelog contents\nand stuff')

        with get_dist(tmpdir) as dist:
            assert dist.metadata.long_description == (
                'readme contents\nline2\n' 'changelog contents\nand stuff'
            )

    def test_file_sandboxed(self, tmpdir):

        fake_env(tmpdir, '[metadata]\n' 'long_description = file: ../../README\n')

        with get_dist(tmpdir, parse=False) as dist:
            with pytest.raises(DistutilsOptionError):
                dist.parse_config_files()  # file: out of sandbox

    def test_aliases(self, tmpdir):

        fake_env(
            tmpdir,
            '[metadata]\n'
            'author_email = test@test.com\n'
            'home_page = http://test.test.com/test/\n'
            'summary = Short summary\n'
            'platform = a, b\n'
            'classifier =\n'
            '  Framework :: Django\n'
            '  Programming Language :: Python :: 3.5\n',
        )

        with get_dist(tmpdir) as dist:
            metadata = dist.metadata
            assert metadata.author_email == 'test@test.com'
            assert metadata.url == 'http://test.test.com/test/'
            assert metadata.description == 'Short summary'
            assert metadata.platforms == ['a', 'b']
            assert metadata.classifiers == [
                'Framework :: Django',
                'Programming Language :: Python :: 3.5',
            ]

    def test_multiline(self, tmpdir):

        fake_env(
            tmpdir,
            '[metadata]\n'
            'name = fake_name\n'
            'keywords =\n'
            '  one\n'
            '  two\n'
            'classifiers =\n'
            '  Framework :: Django\n'
            '  Programming Language :: Python :: 3.5\n',
        )
        with get_dist(tmpdir) as dist:
            metadata = dist.metadata
            assert metadata.keywords == ['one', 'two']
            assert metadata.classifiers == [
                'Framework :: Django',
                'Programming Language :: Python :: 3.5',
            ]

    def test_dict(self, tmpdir):

        fake_env(
            tmpdir,
            '[metadata]\n'
            'project_urls =\n'
            '  Link One = https://example.com/one/\n'
            '  Link Two = https://example.com/two/\n',
        )
        with get_dist(tmpdir) as dist:
            metadata = dist.metadata
            assert metadata.project_urls == {
                'Link One': 'https://example.com/one/',
                'Link Two': 'https://example.com/two/',
            }

    def test_version(self, tmpdir):

        package_dir, config = fake_env(
            tmpdir, '[metadata]\n' 'version = attr: fake_package.VERSION\n'
        )

        sub_a = package_dir.mkdir('subpkg_a')
        sub_a.join('__init__.py').write('')
        sub_a.join('mod.py').write('VERSION = (2016, 11, 26)')

        sub_b = package_dir.mkdir('subpkg_b')
        sub_b.join('__init__.py').write('')
        sub_b.join('mod.py').write(
            'import third_party_module\n' 'VERSION = (2016, 11, 26)'
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

        config.write('[metadata]\n' 'version = attr: fake_package.get_version\n')
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '3.4.5.dev'

        config.write('[metadata]\n' 'version = attr: fake_package.VERSION_MAJOR\n')
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1'

        config.write(
            '[metadata]\n' 'version = attr: fake_package.subpkg_a.mod.VERSION\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '2016.11.26'

        config.write(
            '[metadata]\n' 'version = attr: fake_package.subpkg_b.mod.VERSION\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '2016.11.26'

    def test_version_file(self, tmpdir):

        _, config = fake_env(
            tmpdir, '[metadata]\n' 'version = file: fake_package/version.txt\n'
        )
        tmpdir.join('fake_package', 'version.txt').write('1.2.3\n')

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

        tmpdir.join('fake_package', 'version.txt').write('1.2.3\n4.5.6\n')
        with pytest.raises(DistutilsOptionError):
            with get_dist(tmpdir) as dist:
                dist.metadata.version

    def test_version_with_package_dir_simple(self, tmpdir):

        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = attr: fake_package_simple.VERSION\n'
            '[options]\n'
            'package_dir =\n'
            '    = src\n',
            package_path='src/fake_package_simple',
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

    def test_version_with_package_dir_rename(self, tmpdir):

        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = attr: fake_package_rename.VERSION\n'
            '[options]\n'
            'package_dir =\n'
            '    fake_package_rename = fake_dir\n',
            package_path='fake_dir',
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

    def test_version_with_package_dir_complex(self, tmpdir):

        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = attr: fake_package_complex.VERSION\n'
            '[options]\n'
            'package_dir =\n'
            '    fake_package_complex = src/fake_dir\n',
            package_path='src/fake_dir',
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

    def test_unknown_meta_item(self, tmpdir):

        fake_env(tmpdir, '[metadata]\n' 'name = fake_name\n' 'unknown = some\n')
        with get_dist(tmpdir, parse=False) as dist:
            dist.parse_config_files()  # Skip unknown.

    def test_usupported_section(self, tmpdir):

        fake_env(tmpdir, '[metadata.some]\n' 'key = val\n')
        with get_dist(tmpdir, parse=False) as dist:
            with pytest.raises(DistutilsOptionError):
                dist.parse_config_files()

    def test_classifiers(self, tmpdir):
        expected = set(
            [
                'Framework :: Django',
                'Programming Language :: Python :: 3',
                'Programming Language :: Python :: 3.5',
            ]
        )

        # From file.
        _, config = fake_env(tmpdir, '[metadata]\n' 'classifiers = file: classifiers\n')

        tmpdir.join('classifiers').write(
            'Framework :: Django\n'
            'Programming Language :: Python :: 3\n'
            'Programming Language :: Python :: 3.5\n'
        )

        with get_dist(tmpdir) as dist:
            assert set(dist.metadata.classifiers) == expected

        # From list notation
        config.write(
            '[metadata]\n'
            'classifiers =\n'
            '    Framework :: Django\n'
            '    Programming Language :: Python :: 3\n'
            '    Programming Language :: Python :: 3.5\n'
        )
        with get_dist(tmpdir) as dist:
            assert set(dist.metadata.classifiers) == expected

    def test_deprecated_config_handlers(self, tmpdir):
        fake_env(
            tmpdir,
            '[metadata]\n'
            'version = 10.1.1\n'
            'description = Some description\n'
            'requires = some, requirement\n',
        )

        with pytest.deprecated_call():
            with get_dist(tmpdir) as dist:
                metadata = dist.metadata

                assert metadata.version == '10.1.1'
                assert metadata.description == 'Some description'
                assert metadata.requires == ['some', 'requirement']

    def test_interpolation(self, tmpdir):
        fake_env(tmpdir, '[metadata]\n' 'description = %(message)s\n')
        with pytest.raises(configparser.InterpolationMissingOptionError):
            with get_dist(tmpdir):
                pass

    def test_non_ascii_1(self, tmpdir):
        fake_env(tmpdir, '[metadata]\n' 'description = éàïôñ\n', encoding='utf-8')
        with get_dist(tmpdir):
            pass

    def test_non_ascii_3(self, tmpdir):
        fake_env(tmpdir, '\n' '# -*- coding: invalid\n')
        with get_dist(tmpdir):
            pass

    def test_non_ascii_4(self, tmpdir):
        fake_env(
            tmpdir,
            '# -*- coding: utf-8\n' '[metadata]\n' 'description = éàïôñ\n',
            encoding='utf-8',
        )
        with get_dist(tmpdir) as dist:
            assert dist.metadata.description == 'éàïôñ'

    def test_not_utf8(self, tmpdir):
        """
        Config files encoded not in UTF-8 will fail
        """
        fake_env(
            tmpdir,
            '# vim: set fileencoding=iso-8859-15 :\n'
            '[metadata]\n'
            'description = éàïôñ\n',
            encoding='iso-8859-15',
        )
        with pytest.raises(UnicodeDecodeError):
            with get_dist(tmpdir):
                pass

    def test_warn_dash_deprecation(self, tmpdir):
        # warn_dash_deprecation() is a method in setuptools.dist
        # remove this test and the method when no longer needed
        fake_env(
            tmpdir,
            '[metadata]\n'
            'author-email = test@test.com\n'
            'maintainer_email = foo@foo.com\n',
        )
        msg = (
            "Usage of dash-separated 'author-email' will not be supported "
            "in future versions. "
            "Please use the underscore name 'author_email' instead"
        )
        with pytest.warns(UserWarning, match=msg):
            with get_dist(tmpdir) as dist:
                metadata = dist.metadata

        assert metadata.author_email == 'test@test.com'
        assert metadata.maintainer_email == 'foo@foo.com'

    def test_make_option_lowercase(self, tmpdir):
        # remove this test and the method make_option_lowercase() in setuptools.dist
        # when no longer needed
        fake_env(
            tmpdir, '[metadata]\n' 'Name = foo\n' 'description = Some description\n'
        )
        msg = (
            "Usage of uppercase key 'Name' in 'metadata' will be deprecated in "
            "future versions. "
            "Please use lowercase 'name' instead"
        )
        with pytest.warns(UserWarning, match=msg):
            with get_dist(tmpdir) as dist:
                metadata = dist.metadata

        assert metadata.name == 'foo'
        assert metadata.description == 'Some description'


class TestOptions:
    def test_basic(self, tmpdir):

        fake_env(
            tmpdir,
            '[options]\n'
            'zip_safe = True\n'
            'include_package_data = yes\n'
            'package_dir = b=c, =src\n'
            'packages = pack_a, pack_b.subpack\n'
            'namespace_packages = pack1, pack2\n'
            'scripts = bin/one.py, bin/two.py\n'
            'eager_resources = bin/one.py, bin/two.py\n'
            'install_requires = docutils>=0.3; pack ==1.1, ==1.3; hey\n'
            'tests_require = mock==0.7.2; pytest\n'
            'setup_requires = docutils>=0.3; spack ==1.1, ==1.3; there\n'
            'dependency_links = http://some.com/here/1, '
            'http://some.com/there/2\n'
            'python_requires = >=1.0, !=2.8\n'
            'py_modules = module1, module2\n',
        )
        with get_dist(tmpdir) as dist:
            assert dist.zip_safe
            assert dist.include_package_data
            assert dist.package_dir == {'': 'src', 'b': 'c'}
            assert dist.packages == ['pack_a', 'pack_b.subpack']
            assert dist.namespace_packages == ['pack1', 'pack2']
            assert dist.scripts == ['bin/one.py', 'bin/two.py']
            assert dist.dependency_links == (
                ['http://some.com/here/1', 'http://some.com/there/2']
            )
            assert dist.install_requires == (
                ['docutils>=0.3', 'pack==1.1,==1.3', 'hey']
            )
            assert dist.setup_requires == (
                ['docutils>=0.3', 'spack ==1.1, ==1.3', 'there']
            )
            assert dist.tests_require == ['mock==0.7.2', 'pytest']
            assert dist.python_requires == '>=1.0, !=2.8'
            assert dist.py_modules == ['module1', 'module2']

    def test_multiline(self, tmpdir):
        fake_env(
            tmpdir,
            '[options]\n'
            'package_dir = \n'
            '  b=c\n'
            '  =src\n'
            'packages = \n'
            '  pack_a\n'
            '  pack_b.subpack\n'
            'namespace_packages = \n'
            '  pack1\n'
            '  pack2\n'
            'scripts = \n'
            '  bin/one.py\n'
            '  bin/two.py\n'
            'eager_resources = \n'
            '  bin/one.py\n'
            '  bin/two.py\n'
            'install_requires = \n'
            '  docutils>=0.3\n'
            '  pack ==1.1, ==1.3\n'
            '  hey\n'
            'tests_require = \n'
            '  mock==0.7.2\n'
            '  pytest\n'
            'setup_requires = \n'
            '  docutils>=0.3\n'
            '  spack ==1.1, ==1.3\n'
            '  there\n'
            'dependency_links = \n'
            '  http://some.com/here/1\n'
            '  http://some.com/there/2\n',
        )
        with get_dist(tmpdir) as dist:
            assert dist.package_dir == {'': 'src', 'b': 'c'}
            assert dist.packages == ['pack_a', 'pack_b.subpack']
            assert dist.namespace_packages == ['pack1', 'pack2']
            assert dist.scripts == ['bin/one.py', 'bin/two.py']
            assert dist.dependency_links == (
                ['http://some.com/here/1', 'http://some.com/there/2']
            )
            assert dist.install_requires == (
                ['docutils>=0.3', 'pack==1.1,==1.3', 'hey']
            )
            assert dist.setup_requires == (
                ['docutils>=0.3', 'spack ==1.1, ==1.3', 'there']
            )
            assert dist.tests_require == ['mock==0.7.2', 'pytest']

    def test_package_dir_fail(self, tmpdir):
        fake_env(tmpdir, '[options]\n' 'package_dir = a b\n')
        with get_dist(tmpdir, parse=False) as dist:
            with pytest.raises(DistutilsOptionError):
                dist.parse_config_files()

    def test_package_data(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.package_data]\n'
            '* = *.txt, *.rst\n'
            'hello = *.msg\n'
            '\n'
            '[options.exclude_package_data]\n'
            '* = fake1.txt, fake2.txt\n'
            'hello = *.dat\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.package_data == {
                '': ['*.txt', '*.rst'],
                'hello': ['*.msg'],
            }
            assert dist.exclude_package_data == {
                '': ['fake1.txt', 'fake2.txt'],
                'hello': ['*.dat'],
            }

    def test_packages(self, tmpdir):
        fake_env(tmpdir, '[options]\n' 'packages = find:\n')

        with get_dist(tmpdir) as dist:
            assert dist.packages == ['fake_package']

    def test_find_directive(self, tmpdir):
        dir_package, config = fake_env(tmpdir, '[options]\n' 'packages = find:\n')

        dir_sub_one, _ = make_package_dir('sub_one', dir_package)
        dir_sub_two, _ = make_package_dir('sub_two', dir_package)

        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == set(
                ['fake_package', 'fake_package.sub_two', 'fake_package.sub_one']
            )

        config.write(
            '[options]\n'
            'packages = find:\n'
            '\n'
            '[options.packages.find]\n'
            'where = .\n'
            'include =\n'
            '    fake_package.sub_one\n'
            '    two\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.packages == ['fake_package.sub_one']

        config.write(
            '[options]\n'
            'packages = find:\n'
            '\n'
            '[options.packages.find]\n'
            'exclude =\n'
            '    fake_package.sub_one\n'
        )
        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == set(['fake_package', 'fake_package.sub_two'])

    def test_find_namespace_directive(self, tmpdir):
        dir_package, config = fake_env(
            tmpdir, '[options]\n' 'packages = find_namespace:\n'
        )

        dir_sub_one, _ = make_package_dir('sub_one', dir_package)
        dir_sub_two, _ = make_package_dir('sub_two', dir_package, ns=True)

        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == {
                'fake_package',
                'fake_package.sub_two',
                'fake_package.sub_one',
            }

        config.write(
            '[options]\n'
            'packages = find_namespace:\n'
            '\n'
            '[options.packages.find]\n'
            'where = .\n'
            'include =\n'
            '    fake_package.sub_one\n'
            '    two\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.packages == ['fake_package.sub_one']

        config.write(
            '[options]\n'
            'packages = find_namespace:\n'
            '\n'
            '[options.packages.find]\n'
            'exclude =\n'
            '    fake_package.sub_one\n'
        )
        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == {'fake_package', 'fake_package.sub_two'}

    def test_extras_require(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.extras_require]\n'
            'pdf = ReportLab>=1.2; RXP\n'
            'rest = \n'
            '  docutils>=0.3\n'
            '  pack ==1.1, ==1.3\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.extras_require == {
                'pdf': ['ReportLab>=1.2', 'RXP'],
                'rest': ['docutils>=0.3', 'pack==1.1,==1.3'],
            }
            assert dist.metadata.provides_extras == set(['pdf', 'rest'])

    def test_dash_preserved_extras_require(self, tmpdir):
        fake_env(tmpdir, '[options.extras_require]\n' 'foo-a = foo\n' 'foo_b = test\n')

        with get_dist(tmpdir) as dist:
            assert dist.extras_require == {'foo-a': ['foo'], 'foo_b': ['test']}

    def test_entry_points(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[options.entry_points]\n'
            'group1 = point1 = pack.module:func, '
            '.point2 = pack.module2:func_rest [rest]\n'
            'group2 = point3 = pack.module:func2\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.entry_points == {
                'group1': [
                    'point1 = pack.module:func',
                    '.point2 = pack.module2:func_rest [rest]',
                ],
                'group2': ['point3 = pack.module:func2'],
            }

        expected = (
            '[blogtool.parsers]\n'
            '.rst = some.nested.module:SomeClass.some_classmethod[reST]\n'
        )

        tmpdir.join('entry_points').write(expected)

        # From file.
        config.write('[options]\n' 'entry_points = file: entry_points\n')

        with get_dist(tmpdir) as dist:
            assert dist.entry_points == expected

    def test_case_sensitive_entry_points(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[options.entry_points]\n'
            'GROUP1 = point1 = pack.module:func, '
            '.point2 = pack.module2:func_rest [rest]\n'
            'group2 = point3 = pack.module:func2\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.entry_points == {
                'GROUP1': [
                    'point1 = pack.module:func',
                    '.point2 = pack.module2:func_rest [rest]',
                ],
                'group2': ['point3 = pack.module:func2'],
            }

    def test_data_files(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.data_files]\n'
            'cfg =\n'
            '      a/b.conf\n'
            '      c/d.conf\n'
            'data = e/f.dat, g/h.dat\n',
        )

        with get_dist(tmpdir) as dist:
            expected = [
                ('cfg', ['a/b.conf', 'c/d.conf']),
                ('data', ['e/f.dat', 'g/h.dat']),
            ]
            assert sorted(dist.data_files) == sorted(expected)

    def test_data_files_globby(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.data_files]\n'
            'cfg =\n'
            '      a/b.conf\n'
            '      c/d.conf\n'
            'data = *.dat\n'
            'icons = \n'
            '      *.ico\n'
            'audio = \n'
            '      *.wav\n'
            '      sounds.db\n'
        )

        # Create dummy files for glob()'s sake:
        tmpdir.join('a.dat').write('')
        tmpdir.join('b.dat').write('')
        tmpdir.join('c.dat').write('')
        tmpdir.join('a.ico').write('')
        tmpdir.join('b.ico').write('')
        tmpdir.join('c.ico').write('')
        tmpdir.join('beep.wav').write('')
        tmpdir.join('boop.wav').write('')
        tmpdir.join('sounds.db').write('')

        with get_dist(tmpdir) as dist:
            expected = [
                ('cfg', ['a/b.conf', 'c/d.conf']),
                ('data', ['a.dat', 'b.dat', 'c.dat']),
                ('icons', ['a.ico', 'b.ico', 'c.ico']),
                ('audio', ['beep.wav', 'boop.wav', 'sounds.db']),
            ]
            assert sorted(dist.data_files) == sorted(expected)

    def test_python_requires_simple(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [options]
            python_requires=>=2.7
            """
            ),
        )
        with get_dist(tmpdir) as dist:
            dist.parse_config_files()

    def test_python_requires_compound(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [options]
            python_requires=>=2.7,!=3.0.*
            """
            ),
        )
        with get_dist(tmpdir) as dist:
            dist.parse_config_files()

    def test_python_requires_invalid(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [options]
            python_requires=invalid
            """
            ),
        )
        with pytest.raises(Exception):
            with get_dist(tmpdir) as dist:
                dist.parse_config_files()

    def test_cmdclass(self, tmpdir):
        class CustomCmd(Command):
            pass

        m = types.ModuleType('custom_build', 'test package')

        m.__dict__['CustomCmd'] = CustomCmd

        sys.modules['custom_build'] = m

        fake_env(
            tmpdir,
            '[options]\n' 'cmdclass =\n' '    customcmd = custom_build.CustomCmd\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.cmdclass == {'customcmd': CustomCmd}


saved_dist_init = _Distribution.__init__


class TestExternalSetters:
    # During creation of the setuptools Distribution() object, we call
    # the init of the parent distutils Distribution object via
    # _Distribution.__init__ ().
    #
    # It's possible distutils calls out to various keyword
    # implementations (i.e. distutils.setup_keywords entry points)
    # that may set a range of variables.
    #
    # This wraps distutil's Distribution.__init__ and simulates
    # pbr or something else setting these values.
    def _fake_distribution_init(self, dist, attrs):
        saved_dist_init(dist, attrs)
        # see self._DISTUTUILS_UNSUPPORTED_METADATA
        setattr(dist.metadata, 'long_description_content_type', 'text/something')
        # Test overwrite setup() args
        setattr(
            dist.metadata,
            'project_urls',
            {
                'Link One': 'https://example.com/one/',
                'Link Two': 'https://example.com/two/',
            },
        )
        return None

    @patch.object(_Distribution, '__init__', autospec=True)
    def test_external_setters(self, mock_parent_init, tmpdir):
        mock_parent_init.side_effect = self._fake_distribution_init

        dist = Distribution(attrs={'project_urls': {'will_be': 'ignored'}})

        assert dist.metadata.long_description_content_type == 'text/something'
        assert dist.metadata.project_urls == {
            'Link One': 'https://example.com/one/',
            'Link Two': 'https://example.com/two/',
        }
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_dep_util.py0000644000175100001710000000172100000000000022176 0ustar00runnerdockerfrom setuptools.dep_util import newer_pairwise_group
import os
import pytest


@pytest.fixture
def groups_target(tmpdir):
    """Sets up some older sources, a target and newer sources.
    Returns a 3-tuple in this order.
    """
    creation_order = ['older.c', 'older.h', 'target.o', 'newer.c', 'newer.h']
    mtime = 0

    for i in range(len(creation_order)):
        creation_order[i] = os.path.join(str(tmpdir), creation_order[i])
        with open(creation_order[i], 'w'):
            pass

        # make sure modification times are sequential
        os.utime(creation_order[i], (mtime, mtime))
        mtime += 1

    return creation_order[:2], creation_order[2], creation_order[3:]


def test_newer_pairwise_group(groups_target):
    older = newer_pairwise_group([groups_target[0]], [groups_target[1]])
    newer = newer_pairwise_group([groups_target[2]], [groups_target[1]])
    assert older == ([], [])
    assert newer == ([groups_target[2]], [groups_target[1]])
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_depends.py0000644000175100001710000000065100000000000022014 0ustar00runnerdockerimport sys

from setuptools import depends


class TestGetModuleConstant:

    def test_basic(self):
        """
        Invoke get_module_constant on a module in
        the test package.
        """
        mod_name = 'setuptools.tests.mod_with_constant'
        val = depends.get_module_constant(mod_name, 'value')
        assert val == 'three, sir!'
        assert 'setuptools.tests.mod_with_constant' not in sys.modules
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_develop.py0000644000175100001710000001462600000000000022037 0ustar00runnerdocker"""develop tests
"""

import os
import sys
import subprocess
import platform
import pathlib
import textwrap

from setuptools.command import test

import pytest

from setuptools.command.develop import develop
from setuptools.dist import Distribution
from . import contexts
from . import namespaces

SETUP_PY = """\
from setuptools import setup

setup(name='foo',
    packages=['foo'],
)
"""

INIT_PY = """print "foo"
"""


@pytest.fixture
def temp_user(monkeypatch):
    with contexts.tempdir() as user_base:
        with contexts.tempdir() as user_site:
            monkeypatch.setattr('site.USER_BASE', user_base)
            monkeypatch.setattr('site.USER_SITE', user_site)
            yield


@pytest.fixture
def test_env(tmpdir, temp_user):
    target = tmpdir
    foo = target.mkdir('foo')
    setup = target / 'setup.py'
    if setup.isfile():
        raise ValueError(dir(target))
    with setup.open('w') as f:
        f.write(SETUP_PY)
    init = foo / '__init__.py'
    with init.open('w') as f:
        f.write(INIT_PY)
    with target.as_cwd():
        yield target


class TestDevelop:
    in_virtualenv = hasattr(sys, 'real_prefix')
    in_venv = hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix

    def test_console_scripts(self, tmpdir):
        """
        Test that console scripts are installed and that they reference
        only the project by name and not the current version.
        """
        pytest.skip(
            "TODO: needs a fixture to cause 'develop' "
            "to be invoked without mutating environment."
        )
        settings = dict(
            name='foo',
            packages=['foo'],
            version='0.0',
            entry_points={
                'console_scripts': [
                    'foocmd = foo:foo',
                ],
            },
        )
        dist = Distribution(settings)
        dist.script_name = 'setup.py'
        cmd = develop(dist)
        cmd.ensure_finalized()
        cmd.install_dir = tmpdir
        cmd.run()
        # assert '0.0' not in foocmd_text


class TestResolver:
    """
    TODO: These tests were written with a minimal understanding
    of what _resolve_setup_path is intending to do. Come up with
    more meaningful cases that look like real-world scenarios.
    """

    def test_resolve_setup_path_cwd(self):
        assert develop._resolve_setup_path('.', '.', '.') == '.'

    def test_resolve_setup_path_one_dir(self):
        assert develop._resolve_setup_path('pkgs', '.', 'pkgs') == '../'

    def test_resolve_setup_path_one_dir_trailing_slash(self):
        assert develop._resolve_setup_path('pkgs/', '.', 'pkgs') == '../'


class TestNamespaces:
    @staticmethod
    def install_develop(src_dir, target):

        develop_cmd = [
            sys.executable,
            'setup.py',
            'develop',
            '--install-dir',
            str(target),
        ]
        with src_dir.as_cwd():
            with test.test.paths_on_pythonpath([str(target)]):
                subprocess.check_call(develop_cmd)

    @pytest.mark.skipif(
        bool(os.environ.get("APPVEYOR")),
        reason="https://github.com/pypa/setuptools/issues/851",
    )
    @pytest.mark.skipif(
        platform.python_implementation() == 'PyPy',
        reason="https://github.com/pypa/setuptools/issues/1202",
    )
    def test_namespace_package_importable(self, tmpdir):
        """
        Installing two packages sharing the same namespace, one installed
        naturally using pip or `--single-version-externally-managed`
        and the other installed using `develop` should leave the namespace
        in tact and both packages reachable by import.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
        target = tmpdir / 'packages'
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip',
            'install',
            str(pkg_A),
            '-t',
            str(target),
        ]
        subprocess.check_call(install_cmd)
        self.install_develop(pkg_B, target)
        namespaces.make_site_dir(target)
        try_import = [
            sys.executable,
            '-c',
            'import myns.pkgA; import myns.pkgB',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(try_import)

        # additionally ensure that pkg_resources import works
        pkg_resources_imp = [
            sys.executable,
            '-c',
            'import pkg_resources',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(pkg_resources_imp)

    @staticmethod
    def install_workaround(site_packages):
        site_packages.mkdir(parents=True)
        sc = site_packages / 'sitecustomize.py'
        sc.write_text(
            textwrap.dedent(
                """
            import site
            import pathlib
            here = pathlib.Path(__file__).parent
            site.addsitedir(str(here))
            """
            ).lstrip()
        )

    @pytest.mark.xfail(
        platform.python_implementation() == 'PyPy',
        reason="Workaround fails on PyPy (why?)",
    )
    def test_editable_prefix(self, tmp_path, sample_project):
        """
        Editable install to a prefix should be discoverable.
        """
        prefix = tmp_path / 'prefix'
        prefix.mkdir()

        # figure out where pip will likely install the package
        site_packages = prefix / next(
            pathlib.Path(path).relative_to(sys.prefix)
            for path in sys.path
            if 'site-packages' in path and path.startswith(sys.prefix)
        )

        # install the workaround
        self.install_workaround(site_packages)

        env = dict(os.environ, PYTHONPATH=str(site_packages))
        cmd = [
            sys.executable,
            '-m',
            'pip',
            'install',
            '--editable',
            str(sample_project),
            '--prefix',
            str(prefix),
            '--no-build-isolation',
        ]
        subprocess.check_call(cmd, env=env)

        # now run 'sample' with the prefix on the PYTHONPATH
        bin = 'Scripts' if platform.system() == 'Windows' else 'bin'
        exe = prefix / bin / 'sample'
        if sys.version_info < (3, 7) and platform.system() == 'Windows':
            exe = str(exe)
        subprocess.check_call([exe], env=env)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_dist.py0000644000175100001710000002702700000000000021343 0ustar00runnerdockerimport io
import collections
import re
import functools
import urllib.request
import urllib.parse
from distutils.errors import DistutilsSetupError
from setuptools.dist import (
    _get_unpatched,
    check_package_data,
    DistDeprecationWarning,
    check_specifier,
    rfc822_escape,
    rfc822_unescape,
)
from setuptools import sic
from setuptools import Distribution

from .textwrap import DALS
from .test_easy_install import make_nspkg_sdist

import pytest


def test_dist_fetch_build_egg(tmpdir):
    """
    Check multiple calls to `Distribution.fetch_build_egg` work as expected.
    """
    index = tmpdir.mkdir('index')
    index_url = urllib.parse.urljoin(
        'file://', urllib.request.pathname2url(str(index)))

    def sdist_with_index(distname, version):
        dist_dir = index.mkdir(distname)
        dist_sdist = '%s-%s.tar.gz' % (distname, version)
        make_nspkg_sdist(str(dist_dir.join(dist_sdist)), distname, version)
        with dist_dir.join('index.html').open('w') as fp:
            fp.write(DALS(
                '''
                
                {dist_sdist}

                
                '''
            ).format(dist_sdist=dist_sdist))
    sdist_with_index('barbazquux', '3.2.0')
    sdist_with_index('barbazquux-runner', '2.11.1')
    with tmpdir.join('setup.cfg').open('w') as fp:
        fp.write(DALS(
            '''
            [easy_install]
            index_url = {index_url}
            '''
        ).format(index_url=index_url))
    reqs = '''
    barbazquux-runner
    barbazquux
    '''.split()
    with tmpdir.as_cwd():
        dist = Distribution()
        dist.parse_config_files()
        resolved_dists = [
            dist.fetch_build_egg(r)
            for r in reqs
        ]
    assert [dist.key for dist in resolved_dists if dist] == reqs


def test_dist__get_unpatched_deprecated():
    pytest.warns(DistDeprecationWarning, _get_unpatched, [""])


def __read_test_cases():
    base = dict(
        name="package",
        version="0.0.1",
        author="Foo Bar",
        author_email="foo@bar.net",
        long_description="Long\ndescription",
        description="Short description",
        keywords=["one", "two"],
    )

    params = functools.partial(dict, base)

    test_cases = [
        ('Metadata version 1.0', params()),
        ('Metadata Version 1.0: Short long description', params(
            long_description='Short long description',
        )),
        ('Metadata version 1.1: Classifiers', params(
            classifiers=[
                'Programming Language :: Python :: 3',
                'Programming Language :: Python :: 3.7',
                'License :: OSI Approved :: MIT License',
            ],
        )),
        ('Metadata version 1.1: Download URL', params(
            download_url='https://example.com',
        )),
        ('Metadata Version 1.2: Requires-Python', params(
            python_requires='>=3.7',
        )),
        pytest.param(
            'Metadata Version 1.2: Project-Url',
            params(project_urls=dict(Foo='https://example.bar')),
            marks=pytest.mark.xfail(
                reason="Issue #1578: project_urls not read",
            ),
        ),
        ('Metadata Version 2.1: Long Description Content Type', params(
            long_description_content_type='text/x-rst; charset=UTF-8',
        )),
        ('License', params(license='MIT', )),
        ('License multiline', params(
            license='This is a long license \nover multiple lines',
        )),
        pytest.param(
            'Metadata Version 2.1: Provides Extra',
            params(provides_extras=['foo', 'bar']),
            marks=pytest.mark.xfail(reason="provides_extras not read"),
        ),
        ('Missing author', dict(
            name='foo',
            version='1.0.0',
            author_email='snorri@sturluson.name',
        )),
        ('Missing author e-mail', dict(
            name='foo',
            version='1.0.0',
            author='Snorri Sturluson',
        )),
        ('Missing author and e-mail', dict(
            name='foo',
            version='1.0.0',
        )),
        ('Bypass normalized version', dict(
            name='foo',
            version=sic('1.0.0a'),
        )),
    ]

    return test_cases


@pytest.mark.parametrize('name,attrs', __read_test_cases())
def test_read_metadata(name, attrs):
    dist = Distribution(attrs)
    metadata_out = dist.metadata
    dist_class = metadata_out.__class__

    # Write to PKG_INFO and then load into a new metadata object
    PKG_INFO = io.StringIO()

    metadata_out.write_pkg_file(PKG_INFO)

    PKG_INFO.seek(0)
    metadata_in = dist_class()
    metadata_in.read_pkg_file(PKG_INFO)

    tested_attrs = [
        ('name', dist_class.get_name),
        ('version', dist_class.get_version),
        ('author', dist_class.get_contact),
        ('author_email', dist_class.get_contact_email),
        ('metadata_version', dist_class.get_metadata_version),
        ('provides', dist_class.get_provides),
        ('description', dist_class.get_description),
        ('long_description', dist_class.get_long_description),
        ('download_url', dist_class.get_download_url),
        ('keywords', dist_class.get_keywords),
        ('platforms', dist_class.get_platforms),
        ('obsoletes', dist_class.get_obsoletes),
        ('requires', dist_class.get_requires),
        ('classifiers', dist_class.get_classifiers),
        ('project_urls', lambda s: getattr(s, 'project_urls', {})),
        ('provides_extras', lambda s: getattr(s, 'provides_extras', set())),
    ]

    for attr, getter in tested_attrs:
        assert getter(metadata_in) == getter(metadata_out)


def __maintainer_test_cases():
    attrs = {"name": "package",
             "version": "1.0",
             "description": "xxx"}

    def merge_dicts(d1, d2):
        d1 = d1.copy()
        d1.update(d2)

        return d1

    test_cases = [
        ('No author, no maintainer', attrs.copy()),
        ('Author (no e-mail), no maintainer', merge_dicts(
            attrs,
            {'author': 'Author Name'})),
        ('Author (e-mail), no maintainer', merge_dicts(
            attrs,
            {'author': 'Author Name',
             'author_email': 'author@name.com'})),
        ('No author, maintainer (no e-mail)', merge_dicts(
            attrs,
            {'maintainer': 'Maintainer Name'})),
        ('No author, maintainer (e-mail)', merge_dicts(
            attrs,
            {'maintainer': 'Maintainer Name',
             'maintainer_email': 'maintainer@name.com'})),
        ('Author (no e-mail), Maintainer (no-email)', merge_dicts(
            attrs,
            {'author': 'Author Name',
             'maintainer': 'Maintainer Name'})),
        ('Author (e-mail), Maintainer (e-mail)', merge_dicts(
            attrs,
            {'author': 'Author Name',
             'author_email': 'author@name.com',
             'maintainer': 'Maintainer Name',
             'maintainer_email': 'maintainer@name.com'})),
        ('No author (e-mail), no maintainer (e-mail)', merge_dicts(
            attrs,
            {'author_email': 'author@name.com',
             'maintainer_email': 'maintainer@name.com'})),
        ('Author unicode', merge_dicts(
            attrs,
            {'author': '鉄沢寛'})),
        ('Maintainer unicode', merge_dicts(
            attrs,
            {'maintainer': 'Jan Åukasiewicz'})),
    ]

    return test_cases


@pytest.mark.parametrize('name,attrs', __maintainer_test_cases())
def test_maintainer_author(name, attrs, tmpdir):
    tested_keys = {
        'author': 'Author',
        'author_email': 'Author-email',
        'maintainer': 'Maintainer',
        'maintainer_email': 'Maintainer-email',
    }

    # Generate a PKG-INFO file
    dist = Distribution(attrs)
    fn = tmpdir.mkdir('pkg_info')
    fn_s = str(fn)

    dist.metadata.write_pkg_info(fn_s)

    with io.open(str(fn.join('PKG-INFO')), 'r', encoding='utf-8') as f:
        raw_pkg_lines = f.readlines()

    # Drop blank lines and strip lines from default description
    pkg_lines = list(filter(None, raw_pkg_lines[:-2]))

    pkg_lines_set = set(pkg_lines)

    # Duplicate lines should not be generated
    assert len(pkg_lines) == len(pkg_lines_set)

    for fkey, dkey in tested_keys.items():
        val = attrs.get(dkey, None)
        if val is None:
            for line in pkg_lines:
                assert not line.startswith(fkey + ':')
        else:
            line = '%s: %s' % (fkey, val)
            assert line in pkg_lines_set


def test_provides_extras_deterministic_order():
    extras = collections.OrderedDict()
    extras['a'] = ['foo']
    extras['b'] = ['bar']
    attrs = dict(extras_require=extras)
    dist = Distribution(attrs)
    assert dist.metadata.provides_extras == ['a', 'b']
    attrs['extras_require'] = collections.OrderedDict(
        reversed(list(attrs['extras_require'].items())))
    dist = Distribution(attrs)
    assert dist.metadata.provides_extras == ['b', 'a']


CHECK_PACKAGE_DATA_TESTS = (
    # Valid.
    ({
        '': ['*.txt', '*.rst'],
        'hello': ['*.msg'],
    }, None),
    # Not a dictionary.
    ((
        ('', ['*.txt', '*.rst']),
        ('hello', ['*.msg']),
    ), (
        "'package_data' must be a dictionary mapping package"
        " names to lists of string wildcard patterns"
    )),
    # Invalid key type.
    ({
        400: ['*.txt', '*.rst'],
    }, (
        "keys of 'package_data' dict must be strings (got 400)"
    )),
    # Invalid value type.
    ({
        'hello': str('*.msg'),
    }, (
        "\"values of 'package_data' dict\" "
        "must be a list of strings (got '*.msg')"
    )),
    # Invalid value type (generators are single use)
    ({
        'hello': (x for x in "generator"),
    }, (
        "\"values of 'package_data' dict\" must be a list of strings "
        "(got =3.0, !=3.1'}
    dist = Distribution(attrs)
    check_specifier(dist, attrs, attrs['python_requires'])

    # invalid specifier value
    attrs = {'name': 'foo', 'python_requires': ['>=3.0', '!=3.1']}
    with pytest.raises(DistutilsSetupError):
        dist = Distribution(attrs)


@pytest.mark.parametrize(
    'content, result',
    (
        pytest.param(
            "Just a single line",
            None,
            id="single_line",
        ),
        pytest.param(
            "Multiline\nText\nwithout\nextra indents\n",
            None,
            id="multiline",
        ),
        pytest.param(
            "Multiline\n    With\n\nadditional\n  indentation",
            None,
            id="multiline_with_indentation",
        ),
        pytest.param(
            "  Leading whitespace",
            "Leading whitespace",
            id="remove_leading_whitespace",
        ),
        pytest.param(
            "  Leading whitespace\nIn\n    Multiline comment",
            "Leading whitespace\nIn\n    Multiline comment",
            id="remove_leading_whitespace_multiline",
        ),
    )
)
def test_rfc822_unescape(content, result):
    assert (result or content) == rfc822_unescape(rfc822_escape(content))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_dist_info.py0000644000175100001710000000426600000000000022356 0ustar00runnerdocker"""Test .dist-info style distributions.
"""

import pytest

import pkg_resources
from .textwrap import DALS


class TestDistInfo:

    metadata_base = DALS("""
        Metadata-Version: 1.2
        Requires-Dist: splort (==4)
        Provides-Extra: baz
        Requires-Dist: quux (>=1.1); extra == 'baz'
        """)

    @classmethod
    def build_metadata(cls, **kwargs):
        lines = (
            '{key}: {value}\n'.format(**locals())
            for key, value in kwargs.items()
        )
        return cls.metadata_base + ''.join(lines)

    @pytest.fixture
    def metadata(self, tmpdir):
        dist_info_name = 'VersionedDistribution-2.718.dist-info'
        versioned = tmpdir / dist_info_name
        versioned.mkdir()
        filename = versioned / 'METADATA'
        content = self.build_metadata(
            Name='VersionedDistribution',
        )
        filename.write_text(content, encoding='utf-8')

        dist_info_name = 'UnversionedDistribution.dist-info'
        unversioned = tmpdir / dist_info_name
        unversioned.mkdir()
        filename = unversioned / 'METADATA'
        content = self.build_metadata(
            Name='UnversionedDistribution',
            Version='0.3',
        )
        filename.write_text(content, encoding='utf-8')

        return str(tmpdir)

    def test_distinfo(self, metadata):
        dists = dict(
            (d.project_name, d)
            for d in pkg_resources.find_distributions(metadata)
        )

        assert len(dists) == 2, dists

        unversioned = dists['UnversionedDistribution']
        versioned = dists['VersionedDistribution']

        assert versioned.version == '2.718'  # from filename
        assert unversioned.version == '0.3'  # from METADATA

    def test_conditional_dependencies(self, metadata):
        specs = 'splort==4', 'quux>=1.1'
        requires = list(map(pkg_resources.Requirement.parse, specs))

        for d in pkg_resources.find_distributions(metadata):
            assert d.requires() == requires[:1]
            assert d.requires(extras=('baz',)) == [
                requires[0],
                pkg_resources.Requirement.parse('quux>=1.1;extra=="baz"'),
            ]
            assert d.extras == ['baz']
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_distutils_adoption.py0000644000175100001710000000433500000000000024316 0ustar00runnerdockerimport os
import sys
import functools
import subprocess
import platform

import pytest
import jaraco.envs
import path


IS_PYPY = '__pypy__' in sys.builtin_module_names


class VirtualEnv(jaraco.envs.VirtualEnv):
    name = '.env'
    # Some version of PyPy will import distutils on startup, implicitly
    # importing setuptools, and thus leading to BackendInvalid errors
    # when upgrading Setuptools. Bypass this behavior by avoiding the
    # early availability and need to upgrade.
    create_opts = ['--no-setuptools']

    def run(self, cmd, *args, **kwargs):
        cmd = [self.exe(cmd[0])] + cmd[1:]
        return subprocess.check_output(cmd, *args, cwd=self.root, **kwargs)


@pytest.fixture
def venv(tmp_path, tmp_src):
    env = VirtualEnv()
    env.root = path.Path(tmp_path / 'venv')
    env.req = str(tmp_src)
    return env.create()


def popen_text(call):
    """
    Augment the Popen call with the parameters to ensure unicode text.
    """
    return functools.partial(call, universal_newlines=True) \
        if sys.version_info < (3, 7) else functools.partial(call, text=True)


def find_distutils(venv, imports='distutils', env=None, **kwargs):
    py_cmd = 'import {imports}; print(distutils.__file__)'.format(**locals())
    cmd = ['python', '-c', py_cmd]
    if platform.system() == 'Windows':
        env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
    return popen_text(venv.run)(cmd, env=env, **kwargs)


def test_distutils_stdlib(venv):
    """
    Ensure stdlib distutils is used when appropriate.
    """
    env = dict(SETUPTOOLS_USE_DISTUTILS='stdlib')
    assert venv.name not in find_distutils(venv, env=env).split(os.sep)


def test_distutils_local_with_setuptools(venv):
    """
    Ensure local distutils is used when appropriate.
    """
    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
    loc = find_distutils(venv, imports='setuptools, distutils', env=env)
    assert venv.name in loc.split(os.sep)


@pytest.mark.xfail('IS_PYPY', reason='pypy imports distutils on startup')
def test_distutils_local(venv):
    """
    Even without importing, the setuptools-local copy of distutils is
    preferred.
    """
    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
    assert venv.name in find_distutils(venv, env=env).split(os.sep)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_easy_install.py0000644000175100001710000011505700000000000023070 0ustar00runnerdocker"""Easy install Tests
"""

import sys
import os
import tempfile
import site
import contextlib
import tarfile
import logging
import itertools
import distutils.errors
import io
import zipfile
import mock
import time
import re
import subprocess
import pathlib

import pytest
from jaraco import path

from setuptools import sandbox
from setuptools.sandbox import run_setup
import setuptools.command.easy_install as ei
from setuptools.command.easy_install import (
    EasyInstallDeprecationWarning, ScriptWriter, PthDistributions,
    WindowsScriptWriter,
)
from setuptools.dist import Distribution
from pkg_resources import normalize_path, working_set
from pkg_resources import Distribution as PRDistribution
from setuptools.tests.server import MockServer, path_to_url
from setuptools.tests import fail_on_ascii
import pkg_resources

from . import contexts
from .textwrap import DALS


@pytest.fixture(autouse=True)
def pip_disable_index(monkeypatch):
    """
    Important: Disable the default index for pip to avoid
    querying packages in the index and potentially resolving
    and installing packages there.
    """
    monkeypatch.setenv('PIP_NO_INDEX', 'true')


class FakeDist:
    def get_entry_map(self, group):
        if group != 'console_scripts':
            return {}
        return {str('name'): 'ep'}

    def as_requirement(self):
        return 'spec'


SETUP_PY = DALS("""
    from setuptools import setup

    setup(name='foo')
    """)


class TestEasyInstallTest:
    def test_get_script_args(self):
        header = ei.CommandSpec.best().from_environment().as_header()
        dist = FakeDist()
        args = next(ei.ScriptWriter.get_args(dist))
        name, script = itertools.islice(args, 2)
        assert script.startswith(header)
        assert "'spec'" in script
        assert "'console_scripts'" in script
        assert "'name'" in script
        assert re.search(
            '^# EASY-INSTALL-ENTRY-SCRIPT', script, flags=re.MULTILINE)

    def test_no_find_links(self):
        # new option '--no-find-links', that blocks find-links added at
        # the project level
        dist = Distribution()
        cmd = ei.easy_install(dist)
        cmd.check_pth_processing = lambda: True
        cmd.no_find_links = True
        cmd.find_links = ['link1', 'link2']
        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
        cmd.args = ['ok']
        cmd.ensure_finalized()
        assert cmd.package_index.scanned_urls == {}

        # let's try without it (default behavior)
        cmd = ei.easy_install(dist)
        cmd.check_pth_processing = lambda: True
        cmd.find_links = ['link1', 'link2']
        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
        cmd.args = ['ok']
        cmd.ensure_finalized()
        keys = sorted(cmd.package_index.scanned_urls.keys())
        assert keys == ['link1', 'link2']

    def test_write_exception(self):
        """
        Test that `cant_write_to_target` is rendered as a DistutilsError.
        """
        dist = Distribution()
        cmd = ei.easy_install(dist)
        cmd.install_dir = os.getcwd()
        with pytest.raises(distutils.errors.DistutilsError):
            cmd.cant_write_to_target()

    def test_all_site_dirs(self, monkeypatch):
        """
        get_site_dirs should always return site dirs reported by
        site.getsitepackages.
        """
        path = normalize_path('/setuptools/test/site-packages')

        def mock_gsp():
            return [path]
        monkeypatch.setattr(site, 'getsitepackages', mock_gsp, raising=False)
        assert path in ei.get_site_dirs()

    def test_all_site_dirs_works_without_getsitepackages(self, monkeypatch):
        monkeypatch.delattr(site, 'getsitepackages', raising=False)
        assert ei.get_site_dirs()

    @pytest.fixture
    def sdist_unicode(self, tmpdir):
        files = [
            (
                'setup.py',
                DALS("""
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-unicode",
                        version="1.0",
                        packages=["mypkg"],
                        include_package_data=True,
                    )
                    """),
            ),
            (
                'mypkg/__init__.py',
                "",
            ),
            (
                'mypkg/☃.txt',
                "",
            ),
        ]
        sdist_name = 'setuptools-test-unicode-1.0.zip'
        sdist = tmpdir / sdist_name
        # can't use make_sdist, because the issue only occurs
        #  with zip sdists.
        sdist_zip = zipfile.ZipFile(str(sdist), 'w')
        for filename, content in files:
            sdist_zip.writestr(filename, content)
        sdist_zip.close()
        return str(sdist)

    @fail_on_ascii
    def test_unicode_filename_in_sdist(
            self, sdist_unicode, tmpdir, monkeypatch):
        """
        The install command should execute correctly even if
        the package has unicode filenames.
        """
        dist = Distribution({'script_args': ['easy_install']})
        target = (tmpdir / 'target').ensure_dir()
        cmd = ei.easy_install(
            dist,
            install_dir=str(target),
            args=['x'],
        )
        monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target))
        cmd.ensure_finalized()
        cmd.easy_install(sdist_unicode)

    @pytest.fixture
    def sdist_unicode_in_script(self, tmpdir):
        files = [
            (
                "setup.py",
                DALS("""
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-unicode",
                        version="1.0",
                        packages=["mypkg"],
                        include_package_data=True,
                        scripts=['mypkg/unicode_in_script'],
                    )
                    """),
            ),
            ("mypkg/__init__.py", ""),
            (
                "mypkg/unicode_in_script",
                DALS(
                    """
                    #!/bin/sh
                    # á

                    non_python_fn() {
                    }
                """),
            ),
        ]
        sdist_name = "setuptools-test-unicode-script-1.0.zip"
        sdist = tmpdir / sdist_name
        # can't use make_sdist, because the issue only occurs
        #  with zip sdists.
        sdist_zip = zipfile.ZipFile(str(sdist), "w")
        for filename, content in files:
            sdist_zip.writestr(filename, content.encode('utf-8'))
        sdist_zip.close()
        return str(sdist)

    @fail_on_ascii
    def test_unicode_content_in_sdist(
            self, sdist_unicode_in_script, tmpdir, monkeypatch):
        """
        The install command should execute correctly even if
        the package has unicode in scripts.
        """
        dist = Distribution({"script_args": ["easy_install"]})
        target = (tmpdir / "target").ensure_dir()
        cmd = ei.easy_install(dist, install_dir=str(target), args=["x"])
        monkeypatch.setitem(os.environ, "PYTHONPATH", str(target))
        cmd.ensure_finalized()
        cmd.easy_install(sdist_unicode_in_script)

    @pytest.fixture
    def sdist_script(self, tmpdir):
        files = [
            (
                'setup.py',
                DALS("""
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-script",
                        version="1.0",
                        scripts=["mypkg_script"],
                    )
                    """),
            ),
            (
                'mypkg_script',
                DALS("""
                     #/usr/bin/python
                     print('mypkg_script')
                     """),
            ),
        ]
        sdist_name = 'setuptools-test-script-1.0.zip'
        sdist = str(tmpdir / sdist_name)
        make_sdist(sdist, files)
        return sdist

    @pytest.mark.skipif(not sys.platform.startswith('linux'),
                        reason="Test can only be run on Linux")
    def test_script_install(self, sdist_script, tmpdir, monkeypatch):
        """
        Check scripts are installed.
        """
        dist = Distribution({'script_args': ['easy_install']})
        target = (tmpdir / 'target').ensure_dir()
        cmd = ei.easy_install(
            dist,
            install_dir=str(target),
            args=['x'],
        )
        monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target))
        cmd.ensure_finalized()
        cmd.easy_install(sdist_script)
        assert (target / 'mypkg_script').exists()

    def test_dist_get_script_args_deprecated(self):
        with pytest.warns(EasyInstallDeprecationWarning):
            ScriptWriter.get_script_args(None, None)

    def test_dist_get_script_header_deprecated(self):
        with pytest.warns(EasyInstallDeprecationWarning):
            ScriptWriter.get_script_header("")

    def test_dist_get_writer_deprecated(self):
        with pytest.warns(EasyInstallDeprecationWarning):
            ScriptWriter.get_writer(None)

    def test_dist_WindowsScriptWriter_get_writer_deprecated(self):
        with pytest.warns(EasyInstallDeprecationWarning):
            WindowsScriptWriter.get_writer()


@pytest.mark.filterwarnings('ignore:Unbuilt egg')
class TestPTHFileWriter:
    def test_add_from_cwd_site_sets_dirty(self):
        '''a pth file manager should set dirty
        if a distribution is in site but also the cwd
        '''
        pth = PthDistributions('does-not_exist', [os.getcwd()])
        assert not pth.dirty
        pth.add(PRDistribution(os.getcwd()))
        assert pth.dirty

    def test_add_from_site_is_ignored(self):
        location = '/test/location/does-not-have-to-exist'
        # PthDistributions expects all locations to be normalized
        location = pkg_resources.normalize_path(location)
        pth = PthDistributions('does-not_exist', [location, ])
        assert not pth.dirty
        pth.add(PRDistribution(location))
        assert not pth.dirty


@pytest.fixture
def setup_context(tmpdir):
    with (tmpdir / 'setup.py').open('w') as f:
        f.write(SETUP_PY)
    with tmpdir.as_cwd():
        yield tmpdir


@pytest.mark.usefixtures("user_override")
@pytest.mark.usefixtures("setup_context")
class TestUserInstallTest:

    # prevent check that site-packages is writable. easy_install
    # shouldn't be writing to system site-packages during finalize
    # options, but while it does, bypass the behavior.
    prev_sp_write = mock.patch(
        'setuptools.command.easy_install.easy_install.check_site_dir',
        mock.Mock(),
    )

    # simulate setuptools installed in user site packages
    @mock.patch('setuptools.command.easy_install.__file__', site.USER_SITE)
    @mock.patch('site.ENABLE_USER_SITE', True)
    @prev_sp_write
    def test_user_install_not_implied_user_site_enabled(self):
        self.assert_not_user_site()

    @mock.patch('site.ENABLE_USER_SITE', False)
    @prev_sp_write
    def test_user_install_not_implied_user_site_disabled(self):
        self.assert_not_user_site()

    @staticmethod
    def assert_not_user_site():
        # create a finalized easy_install command
        dist = Distribution()
        dist.script_name = 'setup.py'
        cmd = ei.easy_install(dist)
        cmd.args = ['py']
        cmd.ensure_finalized()
        assert not cmd.user, 'user should not be implied'

    def test_multiproc_atexit(self):
        pytest.importorskip('multiprocessing')

        log = logging.getLogger('test_easy_install')
        logging.basicConfig(level=logging.INFO, stream=sys.stderr)
        log.info('this should not break')

    @pytest.fixture()
    def foo_package(self, tmpdir):
        egg_file = tmpdir / 'foo-1.0.egg-info'
        with egg_file.open('w') as f:
            f.write('Name: foo\n')
        return str(tmpdir)

    @pytest.fixture()
    def install_target(self, tmpdir):
        target = str(tmpdir)
        with mock.patch('sys.path', sys.path + [target]):
            python_path = os.path.pathsep.join(sys.path)
            with mock.patch.dict(os.environ, PYTHONPATH=python_path):
                yield target

    def test_local_index(self, foo_package, install_target):
        """
        The local index must be used when easy_install locates installed
        packages.
        """
        dist = Distribution()
        dist.script_name = 'setup.py'
        cmd = ei.easy_install(dist)
        cmd.install_dir = install_target
        cmd.args = ['foo']
        cmd.ensure_finalized()
        cmd.local_index.scan([foo_package])
        res = cmd.easy_install('foo')
        actual = os.path.normcase(os.path.realpath(res.location))
        expected = os.path.normcase(os.path.realpath(foo_package))
        assert actual == expected

    @contextlib.contextmanager
    def user_install_setup_context(self, *args, **kwargs):
        """
        Wrap sandbox.setup_context to patch easy_install in that context to
        appear as user-installed.
        """
        with self.orig_context(*args, **kwargs):
            import setuptools.command.easy_install as ei
            ei.__file__ = site.USER_SITE
            yield

    def patched_setup_context(self):
        self.orig_context = sandbox.setup_context

        return mock.patch(
            'setuptools.sandbox.setup_context',
            self.user_install_setup_context,
        )


@pytest.fixture
def distutils_package():
    distutils_setup_py = SETUP_PY.replace(
        'from setuptools import setup',
        'from distutils.core import setup',
    )
    with contexts.tempdir(cd=os.chdir):
        with open('setup.py', 'w') as f:
            f.write(distutils_setup_py)
        yield


@pytest.fixture
def mock_index():
    # set up a server which will simulate an alternate package index.
    p_index = MockServer()
    if p_index.server_port == 0:
        # Some platforms (Jython) don't find a port to which to bind,
        # so skip test for them.
        pytest.skip("could not find a valid port")
    p_index.start()
    return p_index


class TestDistutilsPackage:
    def test_bdist_egg_available_on_distutils_pkg(self, distutils_package):
        run_setup('setup.py', ['bdist_egg'])


class TestSetupRequires:

    def test_setup_requires_honors_fetch_params(self, mock_index, monkeypatch):
        """
        When easy_install installs a source distribution which specifies
        setup_requires, it should honor the fetch parameters (such as
        index-url, and find-links).
        """
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv('PIP_NO_INDEX', 'false')
        with contexts.quiet():
            # create an sdist that has a build-time dependency.
            with TestSetupRequires.create_sdist() as dist_file:
                with contexts.tempdir() as temp_install_dir:
                    with contexts.environment(PYTHONPATH=temp_install_dir):
                        cmd = [
                            sys.executable,
                            '-m', 'setup',
                            'easy_install',
                            '--index-url', mock_index.url,
                            '--exclude-scripts',
                            '--install-dir', temp_install_dir,
                            dist_file,
                        ]
                        subprocess.Popen(cmd).wait()
        # there should have been one requests to the server
        assert [r.path for r in mock_index.requests] == ['/does-not-exist/']

    @staticmethod
    @contextlib.contextmanager
    def create_sdist():
        """
        Return an sdist with a setup_requires dependency (of something that
        doesn't exist)
        """
        with contexts.tempdir() as dir:
            dist_path = os.path.join(dir, 'setuptools-test-fetcher-1.0.tar.gz')
            make_sdist(dist_path, [
                ('setup.py', DALS("""
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-fetcher",
                        version="1.0",
                        setup_requires = ['does-not-exist'],
                    )
                """)),
                ('setup.cfg', ''),
            ])
            yield dist_path

    use_setup_cfg = (
        (),
        ('dependency_links',),
        ('setup_requires',),
        ('dependency_links', 'setup_requires'),
    )

    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
    def test_setup_requires_overrides_version_conflict(self, use_setup_cfg):
        """
        Regression test for distribution issue 323:
        https://bitbucket.org/tarek/distribute/issues/323

        Ensures that a distribution's setup_requires requirements can still be
        installed and used locally even if a conflicting version of that
        requirement is already on the path.
        """

        fake_dist = PRDistribution('does-not-matter', project_name='foobar',
                                   version='0.0')
        working_set.add(fake_dist)

        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                test_pkg = create_setup_requires_package(
                    temp_dir, use_setup_cfg=use_setup_cfg)
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                with contexts.quiet() as (stdout, stderr):
                    # Don't even need to install the package, just
                    # running the setup.py at all is sufficient
                    run_setup(test_setup_py, [str('--name')])

                lines = stdout.readlines()
                assert len(lines) > 0
                assert lines[-1].strip() == 'test_pkg'

    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
    def test_setup_requires_override_nspkg(self, use_setup_cfg):
        """
        Like ``test_setup_requires_overrides_version_conflict`` but where the
        ``setup_requires`` package is part of a namespace package that has
        *already* been imported.
        """

        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                foobar_1_archive = os.path.join(temp_dir, 'foo.bar-0.1.tar.gz')
                make_nspkg_sdist(foobar_1_archive, 'foo.bar', '0.1')
                # Now actually go ahead an extract to the temp dir and add the
                # extracted path to sys.path so foo.bar v0.1 is importable
                foobar_1_dir = os.path.join(temp_dir, 'foo.bar-0.1')
                os.mkdir(foobar_1_dir)
                with tarfile.open(foobar_1_archive) as tf:
                    tf.extractall(foobar_1_dir)
                sys.path.insert(1, foobar_1_dir)

                dist = PRDistribution(foobar_1_dir, project_name='foo.bar',
                                      version='0.1')
                working_set.add(dist)

                template = DALS("""\
                    import foo  # Even with foo imported first the
                                # setup_requires package should override
                    import setuptools
                    setuptools.setup(**%r)

                    if not (hasattr(foo, '__path__') and
                            len(foo.__path__) == 2):
                        print('FAIL')

                    if 'foo.bar-0.2' not in foo.__path__[0]:
                        print('FAIL')
                """)

                test_pkg = create_setup_requires_package(
                    temp_dir, 'foo.bar', '0.2', make_nspkg_sdist, template,
                    use_setup_cfg=use_setup_cfg)

                test_setup_py = os.path.join(test_pkg, 'setup.py')

                with contexts.quiet() as (stdout, stderr):
                    try:
                        # Don't even need to install the package, just
                        # running the setup.py at all is sufficient
                        run_setup(test_setup_py, [str('--name')])
                    except pkg_resources.VersionConflict:
                        self.fail(
                            'Installing setup.py requirements '
                            'caused a VersionConflict')

                assert 'FAIL' not in stdout.getvalue()
                lines = stdout.readlines()
                assert len(lines) > 0
                assert lines[-1].strip() == 'test_pkg'

    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
    def test_setup_requires_with_attr_version(self, use_setup_cfg):
        def make_dependency_sdist(dist_path, distname, version):
            files = [(
                'setup.py',
                DALS("""
                    import setuptools
                    setuptools.setup(
                        name={name!r},
                        version={version!r},
                        py_modules=[{name!r}],
                    )
                    """.format(name=distname, version=version)),
            ), (
                distname + '.py',
                DALS("""
                    version = 42
                    """),
            )]
            make_sdist(dist_path, files)
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                test_pkg = create_setup_requires_package(
                    temp_dir, setup_attrs=dict(version='attr: foobar.version'),
                    make_package=make_dependency_sdist,
                    use_setup_cfg=use_setup_cfg + ('version',),
                )
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                with contexts.quiet() as (stdout, stderr):
                    run_setup(test_setup_py, [str('--version')])
                lines = stdout.readlines()
                assert len(lines) > 0
                assert lines[-1].strip() == '42'

    def test_setup_requires_honors_pip_env(self, mock_index, monkeypatch):
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv('PIP_NO_INDEX', 'false')
        monkeypatch.setenv(str('PIP_INDEX_URL'), mock_index.url)
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                test_pkg = create_setup_requires_package(
                    temp_dir, 'python-xlib', '0.19',
                    setup_attrs=dict(dependency_links=[]))
                test_setup_cfg = os.path.join(test_pkg, 'setup.cfg')
                with open(test_setup_cfg, 'w') as fp:
                    fp.write(DALS(
                        '''
                        [easy_install]
                        index_url = https://pypi.org/legacy/
                        '''))
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                with pytest.raises(distutils.errors.DistutilsError):
                    run_setup(test_setup_py, [str('--version')])
        assert len(mock_index.requests) == 1
        assert mock_index.requests[0].path == '/python-xlib/'

    def test_setup_requires_with_pep508_url(self, mock_index, monkeypatch):
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv(str('PIP_INDEX_URL'), mock_index.url)
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                dep_sdist = os.path.join(temp_dir, 'dep.tar.gz')
                make_trivial_sdist(dep_sdist, 'dependency', '42')
                dep_url = path_to_url(dep_sdist, authority='localhost')
                test_pkg = create_setup_requires_package(
                    temp_dir,
                    # Ignored (overridden by setup_attrs)
                    'python-xlib', '0.19',
                    setup_attrs=dict(
                        setup_requires='dependency @ %s' % dep_url))
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                run_setup(test_setup_py, [str('--version')])
        assert len(mock_index.requests) == 0

    def test_setup_requires_with_allow_hosts(self, mock_index):
        ''' The `allow-hosts` option in not supported anymore. '''
        files = {
            'test_pkg': {
                'setup.py': DALS('''
                    from setuptools import setup
                    setup(setup_requires='python-xlib')
                    '''),
                'setup.cfg': DALS('''
                    [easy_install]
                    allow_hosts = *
                    '''),
            }
        }
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                path.build(files, prefix=temp_dir)
                setup_py = str(pathlib.Path(temp_dir, 'test_pkg', 'setup.py'))
                with pytest.raises(distutils.errors.DistutilsError):
                    run_setup(setup_py, [str('--version')])
        assert len(mock_index.requests) == 0

    def test_setup_requires_with_python_requires(self, monkeypatch, tmpdir):
        ''' Check `python_requires` is honored. '''
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv(str('PIP_NO_INDEX'), str('1'))
        monkeypatch.setenv(str('PIP_VERBOSE'), str('1'))
        dep_1_0_sdist = 'dep-1.0.tar.gz'
        dep_1_0_url = path_to_url(str(tmpdir / dep_1_0_sdist))
        dep_1_0_python_requires = '>=2.7'
        make_python_requires_sdist(
            str(tmpdir / dep_1_0_sdist), 'dep', '1.0', dep_1_0_python_requires)
        dep_2_0_sdist = 'dep-2.0.tar.gz'
        dep_2_0_url = path_to_url(str(tmpdir / dep_2_0_sdist))
        dep_2_0_python_requires = '!=' + '.'.join(
            map(str, sys.version_info[:2])) + '.*'
        make_python_requires_sdist(
            str(tmpdir / dep_2_0_sdist), 'dep', '2.0', dep_2_0_python_requires)
        index = tmpdir / 'index.html'
        index.write_text(DALS(
            '''
            
            Links for dep
            
                
Links for dep

                {dep_1_0_sdist}

                {dep_2_0_sdist}

            
            
            ''').format(  # noqa
                dep_1_0_url=dep_1_0_url,
                dep_1_0_sdist=dep_1_0_sdist,
                dep_1_0_python_requires=dep_1_0_python_requires,
                dep_2_0_url=dep_2_0_url,
                dep_2_0_sdist=dep_2_0_sdist,
                dep_2_0_python_requires=dep_2_0_python_requires,
        ), 'utf-8')
        index_url = path_to_url(str(index))
        with contexts.save_pkg_resources_state():
            test_pkg = create_setup_requires_package(
                str(tmpdir),
                'python-xlib', '0.19',  # Ignored (overridden by setup_attrs).
                setup_attrs=dict(
                    setup_requires='dep', dependency_links=[index_url]))
            test_setup_py = os.path.join(test_pkg, 'setup.py')
            run_setup(test_setup_py, [str('--version')])
        eggs = list(map(str, pkg_resources.find_distributions(
            os.path.join(test_pkg, '.eggs'))))
        assert eggs == ['dep 1.0']

    @pytest.mark.parametrize(
        'with_dependency_links_in_setup_py',
        (False, True))
    def test_setup_requires_with_find_links_in_setup_cfg(
            self, monkeypatch,
            with_dependency_links_in_setup_py):
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                make_trivial_sdist(
                    os.path.join(temp_dir, 'python-xlib-42.tar.gz'),
                    'python-xlib',
                    '42')
                test_pkg = os.path.join(temp_dir, 'test_pkg')
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                test_setup_cfg = os.path.join(test_pkg, 'setup.cfg')
                os.mkdir(test_pkg)
                with open(test_setup_py, 'w') as fp:
                    if with_dependency_links_in_setup_py:
                        dependency_links = [os.path.join(temp_dir, 'links')]
                    else:
                        dependency_links = []
                    fp.write(DALS(
                        '''
                        from setuptools import installer, setup
                        setup(setup_requires='python-xlib==42',
                        dependency_links={dependency_links!r})
                        ''').format(
                                    dependency_links=dependency_links))
                with open(test_setup_cfg, 'w') as fp:
                    fp.write(DALS(
                        '''
                        [easy_install]
                        index_url = {index_url}
                        find_links = {find_links}
                        ''').format(index_url=os.path.join(temp_dir, 'index'),
                                    find_links=temp_dir))
                run_setup(test_setup_py, [str('--version')])

    def test_setup_requires_with_transitive_extra_dependency(
            self, monkeypatch):
        # Use case: installing a package with a build dependency on
        # an already installed `dep[extra]`, which in turn depends
        # on `extra_dep` (whose is not already installed).
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                # Create source distribution for `extra_dep`.
                make_trivial_sdist(
                    os.path.join(temp_dir, 'extra_dep-1.0.tar.gz'),
                    'extra_dep', '1.0')
                # Create source tree for `dep`.
                dep_pkg = os.path.join(temp_dir, 'dep')
                os.mkdir(dep_pkg)
                path.build({
                    'setup.py':
                    DALS("""
                          import setuptools
                          setuptools.setup(
                              name='dep', version='2.0',
                              extras_require={'extra': ['extra_dep']},
                          )
                         """),
                    'setup.cfg': '',
                }, prefix=dep_pkg)
                # "Install" dep.
                run_setup(
                    os.path.join(dep_pkg, 'setup.py'), [str('dist_info')])
                working_set.add_entry(dep_pkg)
                # Create source tree for test package.
                test_pkg = os.path.join(temp_dir, 'test_pkg')
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                os.mkdir(test_pkg)
                with open(test_setup_py, 'w') as fp:
                    fp.write(DALS(
                        '''
                        from setuptools import installer, setup
                        setup(setup_requires='dep[extra]')
                        '''))
                # Check...
                monkeypatch.setenv(str('PIP_FIND_LINKS'), str(temp_dir))
                monkeypatch.setenv(str('PIP_NO_INDEX'), str('1'))
                monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
                monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
                run_setup(test_setup_py, [str('--version')])


def make_trivial_sdist(dist_path, distname, version):
    """
    Create a simple sdist tarball at dist_path, containing just a simple
    setup.py.
    """

    make_sdist(dist_path, [
        ('setup.py',
         DALS("""\
             import setuptools
             setuptools.setup(
                 name=%r,
                 version=%r
             )
         """ % (distname, version))),
        ('setup.cfg', ''),
    ])


def make_nspkg_sdist(dist_path, distname, version):
    """
    Make an sdist tarball with distname and version which also contains one
    package with the same name as distname.  The top-level package is
    designated a namespace package).
    """

    parts = distname.split('.')
    nspackage = parts[0]

    packages = ['.'.join(parts[:idx]) for idx in range(1, len(parts) + 1)]

    setup_py = DALS("""\
        import setuptools
        setuptools.setup(
            name=%r,
            version=%r,
            packages=%r,
            namespace_packages=[%r]
        )
    """ % (distname, version, packages, nspackage))

    init = "__import__('pkg_resources').declare_namespace(__name__)"

    files = [('setup.py', setup_py),
             (os.path.join(nspackage, '__init__.py'), init)]
    for package in packages[1:]:
        filename = os.path.join(*(package.split('.') + ['__init__.py']))
        files.append((filename, ''))

    make_sdist(dist_path, files)


def make_python_requires_sdist(dist_path, distname, version, python_requires):
    make_sdist(dist_path, [
        (
            'setup.py',
            DALS("""\
                import setuptools
                setuptools.setup(
                  name={name!r},
                  version={version!r},
                  python_requires={python_requires!r},
                )
                """).format(
                name=distname, version=version,
                python_requires=python_requires)),
        ('setup.cfg', ''),
    ])


def make_sdist(dist_path, files):
    """
    Create a simple sdist tarball at dist_path, containing the files
    listed in ``files`` as ``(filename, content)`` tuples.
    """

    # Distributions with only one file don't play well with pip.
    assert len(files) > 1
    with tarfile.open(dist_path, 'w:gz') as dist:
        for filename, content in files:
            file_bytes = io.BytesIO(content.encode('utf-8'))
            file_info = tarfile.TarInfo(name=filename)
            file_info.size = len(file_bytes.getvalue())
            file_info.mtime = int(time.time())
            dist.addfile(file_info, fileobj=file_bytes)


def create_setup_requires_package(path, distname='foobar', version='0.1',
                                  make_package=make_trivial_sdist,
                                  setup_py_template=None, setup_attrs={},
                                  use_setup_cfg=()):
    """Creates a source tree under path for a trivial test package that has a
    single requirement in setup_requires--a tarball for that requirement is
    also created and added to the dependency_links argument.

    ``distname`` and ``version`` refer to the name/version of the package that
    the test package requires via ``setup_requires``.  The name of the test
    package itself is just 'test_pkg'.
    """

    test_setup_attrs = {
        'name': 'test_pkg', 'version': '0.0',
        'setup_requires': ['%s==%s' % (distname, version)],
        'dependency_links': [os.path.abspath(path)]
    }
    test_setup_attrs.update(setup_attrs)

    test_pkg = os.path.join(path, 'test_pkg')
    os.mkdir(test_pkg)

    # setup.cfg
    if use_setup_cfg:
        options = []
        metadata = []
        for name in use_setup_cfg:
            value = test_setup_attrs.pop(name)
            if name in 'name version'.split():
                section = metadata
            else:
                section = options
            if isinstance(value, (tuple, list)):
                value = ';'.join(value)
            section.append('%s: %s' % (name, value))
        test_setup_cfg_contents = DALS(
            """
            [metadata]
            {metadata}
            [options]
            {options}
            """
        ).format(
            options='\n'.join(options),
            metadata='\n'.join(metadata),
        )
    else:
        test_setup_cfg_contents = ''
    with open(os.path.join(test_pkg, 'setup.cfg'), 'w') as f:
        f.write(test_setup_cfg_contents)

    # setup.py
    if setup_py_template is None:
        setup_py_template = DALS("""\
            import setuptools
            setuptools.setup(**%r)
        """)
    with open(os.path.join(test_pkg, 'setup.py'), 'w') as f:
        f.write(setup_py_template % test_setup_attrs)

    foobar_path = os.path.join(path, '%s-%s.tar.gz' % (distname, version))
    make_package(foobar_path, distname, version)

    return test_pkg


@pytest.mark.skipif(
    sys.platform.startswith('java') and ei.is_sh(sys.executable),
    reason="Test cannot run under java when executable is sh"
)
class TestScriptHeader:
    non_ascii_exe = '/Users/José/bin/python'
    exe_with_spaces = r'C:\Program Files\Python36\python.exe'

    def test_get_script_header(self):
        expected = '#!%s\n' % ei.nt_quote_arg(os.path.normpath(sys.executable))
        actual = ei.ScriptWriter.get_header('#!/usr/local/bin/python')
        assert actual == expected

    def test_get_script_header_args(self):
        expected = '#!%s -x\n' % ei.nt_quote_arg(
            os.path.normpath(sys.executable))
        actual = ei.ScriptWriter.get_header('#!/usr/bin/python -x')
        assert actual == expected

    def test_get_script_header_non_ascii_exe(self):
        actual = ei.ScriptWriter.get_header(
            '#!/usr/bin/python',
            executable=self.non_ascii_exe)
        expected = str('#!%s -x\n') % self.non_ascii_exe
        assert actual == expected

    def test_get_script_header_exe_with_spaces(self):
        actual = ei.ScriptWriter.get_header(
            '#!/usr/bin/python',
            executable='"' + self.exe_with_spaces + '"')
        expected = '#!"%s"\n' % self.exe_with_spaces
        assert actual == expected


class TestCommandSpec:
    def test_custom_launch_command(self):
        """
        Show how a custom CommandSpec could be used to specify a #! executable
        which takes parameters.
        """
        cmd = ei.CommandSpec(['/usr/bin/env', 'python3'])
        assert cmd.as_header() == '#!/usr/bin/env python3\n'

    def test_from_param_for_CommandSpec_is_passthrough(self):
        """
        from_param should return an instance of a CommandSpec
        """
        cmd = ei.CommandSpec(['python'])
        cmd_new = ei.CommandSpec.from_param(cmd)
        assert cmd is cmd_new

    @mock.patch('sys.executable', TestScriptHeader.exe_with_spaces)
    @mock.patch.dict(os.environ)
    def test_from_environment_with_spaces_in_executable(self):
        os.environ.pop('__PYVENV_LAUNCHER__', None)
        cmd = ei.CommandSpec.from_environment()
        assert len(cmd) == 1
        assert cmd.as_header().startswith('#!"')

    def test_from_simple_string_uses_shlex(self):
        """
        In order to support `executable = /usr/bin/env my-python`, make sure
        from_param invokes shlex on that input.
        """
        cmd = ei.CommandSpec.from_param('/usr/bin/env my-python')
        assert len(cmd) == 2
        assert '"' not in cmd.as_header()


class TestWindowsScriptWriter:
    def test_header(self):
        hdr = ei.WindowsScriptWriter.get_header('')
        assert hdr.startswith('#!')
        assert hdr.endswith('\n')
        hdr = hdr.lstrip('#!')
        hdr = hdr.rstrip('\n')
        # header should not start with an escaped quote
        assert not hdr.startswith('\\"')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_egg_info.py0000644000175100001710000011356400000000000022157 0ustar00runnerdockerimport sys
import ast
import os
import glob
import re
import stat
import time
from typing import List, Tuple

import pytest
from jaraco import path

from setuptools.command.egg_info import (
    egg_info, manifest_maker, EggInfoDeprecationWarning, get_pkg_info_revision,
)
from setuptools.dist import Distribution

from . import environment
from .textwrap import DALS
from . import contexts


class Environment(str):
    pass


class TestEggInfo:

    setup_script = DALS("""
        from setuptools import setup

        setup(
            name='foo',
            py_modules=['hello'],
            entry_points={'console_scripts': ['hi = hello.run']},
            zip_safe=False,
        )
        """)

    def _create_project(self):
        path.build({
            'setup.py': self.setup_script,
            'hello.py': DALS("""
                def run():
                    print('hello')
                """)
        })

    @staticmethod
    def _extract_mv_version(pkg_info_lines: List[str]) -> Tuple[int, int]:
        version_str = pkg_info_lines[0].split(' ')[1]
        return tuple(map(int, version_str.split('.')[:2]))

    @pytest.fixture
    def env(self):
        with contexts.tempdir(prefix='setuptools-test.') as env_dir:
            env = Environment(env_dir)
            os.chmod(env_dir, stat.S_IRWXU)
            subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
            env.paths = dict(
                (dirname, os.path.join(env_dir, dirname))
                for dirname in subs
            )
            list(map(os.mkdir, env.paths.values()))
            path.build({
                env.paths['home']: {
                    '.pydistutils.cfg': DALS("""
                    [egg_info]
                    egg-base = %(egg-base)s
                    """ % env.paths)
                }
            })
            yield env

    def test_egg_info_save_version_info_setup_empty(self, tmpdir_cwd, env):
        """
        When the egg_info section is empty or not present, running
        save_version_info should add the settings to the setup.cfg
        in a deterministic order.
        """
        setup_cfg = os.path.join(env.paths['home'], 'setup.cfg')
        dist = Distribution()
        ei = egg_info(dist)
        ei.initialize_options()
        ei.save_version_info(setup_cfg)

        with open(setup_cfg, 'r') as f:
            content = f.read()

        assert '[egg_info]' in content
        assert 'tag_build =' in content
        assert 'tag_date = 0' in content

        expected_order = 'tag_build', 'tag_date',

        self._validate_content_order(content, expected_order)

    @staticmethod
    def _validate_content_order(content, expected):
        """
        Assert that the strings in expected appear in content
        in order.
        """
        pattern = '.*'.join(expected)
        flags = re.MULTILINE | re.DOTALL
        assert re.search(pattern, content, flags)

    def test_egg_info_save_version_info_setup_defaults(self, tmpdir_cwd, env):
        """
        When running save_version_info on an existing setup.cfg
        with the 'default' values present from a previous run,
        the file should remain unchanged.
        """
        setup_cfg = os.path.join(env.paths['home'], 'setup.cfg')
        path.build({
            setup_cfg: DALS("""
            [egg_info]
            tag_build =
            tag_date = 0
            """),
        })
        dist = Distribution()
        ei = egg_info(dist)
        ei.initialize_options()
        ei.save_version_info(setup_cfg)

        with open(setup_cfg, 'r') as f:
            content = f.read()

        assert '[egg_info]' in content
        assert 'tag_build =' in content
        assert 'tag_date = 0' in content

        expected_order = 'tag_build', 'tag_date',

        self._validate_content_order(content, expected_order)

    def test_expected_files_produced(self, tmpdir_cwd, env):
        self._create_project()

        self._run_egg_info_command(tmpdir_cwd, env)
        actual = os.listdir('foo.egg-info')

        expected = [
            'PKG-INFO',
            'SOURCES.txt',
            'dependency_links.txt',
            'entry_points.txt',
            'not-zip-safe',
            'top_level.txt',
        ]
        assert sorted(actual) == expected

    def test_license_is_a_string(self, tmpdir_cwd, env):
        setup_config = DALS("""
            [metadata]
            name=foo
            version=0.0.1
            license=file:MIT
            """)

        setup_script = DALS("""
            from setuptools import setup

            setup()
            """)

        path.build({
            'setup.py': setup_script,
            'setup.cfg': setup_config,
        })

        # This command should fail with a ValueError, but because it's
        # currently configured to use a subprocess, the actual traceback
        # object is lost and we need to parse it from stderr
        with pytest.raises(AssertionError) as exc:
            self._run_egg_info_command(tmpdir_cwd, env)

        # Hopefully this is not too fragile: the only argument to the
        # assertion error should be a traceback, ending with:
        #     ValueError: ....
        #
        #     assert not 1
        tb = exc.value.args[0].split('\n')
        assert tb[-3].lstrip().startswith('ValueError')

    def test_rebuilt(self, tmpdir_cwd, env):
        """Ensure timestamps are updated when the command is re-run."""
        self._create_project()

        self._run_egg_info_command(tmpdir_cwd, env)
        timestamp_a = os.path.getmtime('foo.egg-info')

        # arbitrary sleep just to handle *really* fast systems
        time.sleep(.001)

        self._run_egg_info_command(tmpdir_cwd, env)
        timestamp_b = os.path.getmtime('foo.egg-info')

        assert timestamp_a != timestamp_b

    def test_manifest_template_is_read(self, tmpdir_cwd, env):
        self._create_project()
        path.build({
            'MANIFEST.in': DALS("""
                recursive-include docs *.rst
            """),
            'docs': {
                'usage.rst': "Run 'hi'",
            }
        })
        self._run_egg_info_command(tmpdir_cwd, env)
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        sources_txt = os.path.join(egg_info_dir, 'SOURCES.txt')
        with open(sources_txt) as f:
            assert 'docs/usage.rst' in f.read().split('\n')

    def _setup_script_with_requires(self, requires, use_setup_cfg=False):
        setup_script = DALS(
            '''
            from setuptools import setup

            setup(name='foo', zip_safe=False, %s)
            '''
        ) % ('' if use_setup_cfg else requires)
        setup_config = requires if use_setup_cfg else ''
        path.build({
            'setup.py': setup_script,
            'setup.cfg': setup_config,
        })

    mismatch_marker = "python_version<'{this_ver}'".format(
        this_ver=sys.version_info[0],
    )
    # Alternate equivalent syntax.
    mismatch_marker_alternate = 'python_version < "{this_ver}"'.format(
        this_ver=sys.version_info[0],
    )
    invalid_marker = "<=>++"

    class RequiresTestHelper:

        @staticmethod
        def parametrize(*test_list, **format_dict):
            idlist = []
            argvalues = []
            for test in test_list:
                test_params = test.lstrip().split('\n\n', 3)
                name_kwargs = test_params.pop(0).split('\n')
                if len(name_kwargs) > 1:
                    val = name_kwargs[1].strip()
                    install_cmd_kwargs = ast.literal_eval(val)
                else:
                    install_cmd_kwargs = {}
                name = name_kwargs[0].strip()
                setup_py_requires, setup_cfg_requires, expected_requires = (
                    DALS(a).format(**format_dict) for a in test_params
                )
                for id_, requires, use_cfg in (
                    (name, setup_py_requires, False),
                    (name + '_in_setup_cfg', setup_cfg_requires, True),
                ):
                    idlist.append(id_)
                    marks = ()
                    if requires.startswith('@xfail\n'):
                        requires = requires[7:]
                        marks = pytest.mark.xfail
                    argvalues.append(pytest.param(requires, use_cfg,
                                                  expected_requires,
                                                  install_cmd_kwargs,
                                                  marks=marks))
            return pytest.mark.parametrize(
                'requires,use_setup_cfg,'
                'expected_requires,install_cmd_kwargs',
                argvalues, ids=idlist,
            )

    @RequiresTestHelper.parametrize(
        # Format of a test:
        #
        # id
        # install_cmd_kwargs [optional]
        #
        # requires block (when used in setup.py)
        #
        # requires block (when used in setup.cfg)
        #
        # expected contents of requires.txt

        '''
        install_requires_deterministic

        install_requires=["wheel>=0.5", "pytest"]

        [options]
        install_requires =
            wheel>=0.5
            pytest

        wheel>=0.5
        pytest
        ''',

        '''
        install_requires_ordered

        install_requires=["pytest>=3.0.2,!=10.9999"]

        [options]
        install_requires =
            pytest>=3.0.2,!=10.9999

        pytest!=10.9999,>=3.0.2
        ''',

        '''
        install_requires_with_marker

        install_requires=["barbazquux;{mismatch_marker}"],

        [options]
        install_requires =
            barbazquux; {mismatch_marker}

        [:{mismatch_marker_alternate}]
        barbazquux
        ''',

        '''
        install_requires_with_extra
        {'cmd': ['egg_info']}

        install_requires=["barbazquux [test]"],

        [options]
        install_requires =
            barbazquux [test]

        barbazquux[test]
        ''',

        '''
        install_requires_with_extra_and_marker

        install_requires=["barbazquux [test]; {mismatch_marker}"],

        [options]
        install_requires =
            barbazquux [test]; {mismatch_marker}

        [:{mismatch_marker_alternate}]
        barbazquux[test]
        ''',

        '''
        setup_requires_with_markers

        setup_requires=["barbazquux;{mismatch_marker}"],

        [options]
        setup_requires =
            barbazquux; {mismatch_marker}

        ''',

        '''
        tests_require_with_markers
        {'cmd': ['test'], 'output': "Ran 0 tests in"}

        tests_require=["barbazquux;{mismatch_marker}"],

        [options]
        tests_require =
            barbazquux; {mismatch_marker}

        ''',

        '''
        extras_require_with_extra
        {'cmd': ['egg_info']}

        extras_require={{"extra": ["barbazquux [test]"]}},

        [options.extras_require]
        extra = barbazquux [test]

        [extra]
        barbazquux[test]
        ''',

        '''
        extras_require_with_extra_and_marker_in_req

        extras_require={{"extra": ["barbazquux [test]; {mismatch_marker}"]}},

        [options.extras_require]
        extra =
            barbazquux [test]; {mismatch_marker}

        [extra]

        [extra:{mismatch_marker_alternate}]
        barbazquux[test]
        ''',

        # FIXME: ConfigParser does not allow : in key names!
        '''
        extras_require_with_marker

        extras_require={{":{mismatch_marker}": ["barbazquux"]}},

        @xfail
        [options.extras_require]
        :{mismatch_marker} = barbazquux

        [:{mismatch_marker}]
        barbazquux
        ''',

        '''
        extras_require_with_marker_in_req

        extras_require={{"extra": ["barbazquux; {mismatch_marker}"]}},

        [options.extras_require]
        extra =
            barbazquux; {mismatch_marker}

        [extra]

        [extra:{mismatch_marker_alternate}]
        barbazquux
        ''',

        '''
        extras_require_with_empty_section

        extras_require={{"empty": []}},

        [options.extras_require]
        empty =

        [empty]
        ''',
        # Format arguments.
        invalid_marker=invalid_marker,
        mismatch_marker=mismatch_marker,
        mismatch_marker_alternate=mismatch_marker_alternate,
    )
    def test_requires(
            self, tmpdir_cwd, env, requires, use_setup_cfg,
            expected_requires, install_cmd_kwargs):
        self._setup_script_with_requires(requires, use_setup_cfg)
        self._run_egg_info_command(tmpdir_cwd, env, **install_cmd_kwargs)
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        requires_txt = os.path.join(egg_info_dir, 'requires.txt')
        if os.path.exists(requires_txt):
            with open(requires_txt) as fp:
                install_requires = fp.read()
        else:
            install_requires = ''
        assert install_requires.lstrip() == expected_requires
        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []

    def test_install_requires_unordered_disallowed(self, tmpdir_cwd, env):
        """
        Packages that pass unordered install_requires sequences
        should be rejected as they produce non-deterministic
        builds. See #458.
        """
        req = 'install_requires={"fake-factory==0.5.2", "pytz"}'
        self._setup_script_with_requires(req)
        with pytest.raises(AssertionError):
            self._run_egg_info_command(tmpdir_cwd, env)

    def test_extras_require_with_invalid_marker(self, tmpdir_cwd, env):
        tmpl = 'extras_require={{":{marker}": ["barbazquux"]}},'
        req = tmpl.format(marker=self.invalid_marker)
        self._setup_script_with_requires(req)
        with pytest.raises(AssertionError):
            self._run_egg_info_command(tmpdir_cwd, env)
        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []

    def test_extras_require_with_invalid_marker_in_req(self, tmpdir_cwd, env):
        tmpl = 'extras_require={{"extra": ["barbazquux; {marker}"]}},'
        req = tmpl.format(marker=self.invalid_marker)
        self._setup_script_with_requires(req)
        with pytest.raises(AssertionError):
            self._run_egg_info_command(tmpdir_cwd, env)
        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []

    def test_provides_extra(self, tmpdir_cwd, env):
        self._setup_script_with_requires(
            'extras_require={"foobar": ["barbazquux"]},')
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Provides-Extra: foobar' in pkg_info_lines
        assert 'Metadata-Version: 2.1' in pkg_info_lines

    def test_doesnt_provides_extra(self, tmpdir_cwd, env):
        self._setup_script_with_requires(
            '''install_requires=["spam ; python_version<'3.6'"]''')
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_text = pkginfo_file.read()
        assert 'Provides-Extra:' not in pkg_info_text

    @pytest.mark.parametrize("files, license_in_sources", [
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE
                              """),
            'LICENSE': "Test license"
        }, True),  # with license
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = INVALID_LICENSE
                              """),
            'LICENSE': "Test license"
        }, False),  # with an invalid license
        ({
            'setup.cfg': DALS("""
                              """),
            'LICENSE': "Test license"
        }, True),  # no license_file attribute, LICENSE auto-included
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE
                              """),
            'MANIFEST.in': "exclude LICENSE",
            'LICENSE': "Test license"
        }, True),  # manifest is overwritten by license_file
        pytest.param({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICEN[CS]E*
                              """),
            'LICENSE': "Test license",
            }, True,
            id="glob_pattern"),
    ])
    def test_setup_cfg_license_file(
            self, tmpdir_cwd, env, files, license_in_sources):
        self._create_project()
        path.build(files)

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)])
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')

        with open(os.path.join(egg_info_dir, 'SOURCES.txt')) as sources_file:
            sources_text = sources_file.read()

        if license_in_sources:
            assert 'LICENSE' in sources_text
        else:
            assert 'LICENSE' not in sources_text
            # for invalid license test
            assert 'INVALID_LICENSE' not in sources_text

    @pytest.mark.parametrize("files, incl_licenses, excl_licenses", [
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
        }, ['LICENSE-ABC', 'LICENSE-XYZ'], []),  # with licenses
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files = LICENSE-ABC, LICENSE-XYZ
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
        }, ['LICENSE-ABC', 'LICENSE-XYZ'], []),  # with commas
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
        }, ['LICENSE-ABC'], ['LICENSE-XYZ']),  # with one license
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files =
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
        }, [], ['LICENSE-ABC', 'LICENSE-XYZ']),  # empty
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files = LICENSE-XYZ
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
        }, ['LICENSE-XYZ'], ['LICENSE-ABC']),  # on same line
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  INVALID_LICENSE
                              """),
            'LICENSE-ABC': "Test license"
        }, ['LICENSE-ABC'], ['INVALID_LICENSE']),  # with an invalid license
        ({
            'setup.cfg': DALS("""
                              """),
            'LICENSE': "Test license"
        }, ['LICENSE'], []),  # no license_files attribute, LICENSE auto-included
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files = LICENSE
                              """),
            'MANIFEST.in': "exclude LICENSE",
            'LICENSE': "Test license"
        }, ['LICENSE'], []),  # manifest is overwritten by license_files
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                              """),
            'MANIFEST.in': "exclude LICENSE-XYZ",
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
            # manifest is overwritten by license_files
        }, ['LICENSE-ABC', 'LICENSE-XYZ'], []),
        pytest.param({
            'setup.cfg': "",
            'LICENSE-ABC': "ABC license",
            'COPYING-ABC': "ABC copying",
            'NOTICE-ABC': "ABC notice",
            'AUTHORS-ABC': "ABC authors",
            'LICENCE-XYZ': "XYZ license",
            'LICENSE': "License",
            'INVALID-LICENSE': "Invalid license",
            }, [
            'LICENSE-ABC',
            'COPYING-ABC',
            'NOTICE-ABC',
            'AUTHORS-ABC',
            'LICENCE-XYZ',
            'LICENSE',
            ], ['INVALID-LICENSE'],
            # ('LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*')
            id="default_glob_patterns"),
        pytest.param({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files =
                                  LICENSE*
                              """),
            'LICENSE-ABC': "ABC license",
            'NOTICE-XYZ': "XYZ notice",
            }, ['LICENSE-ABC'], ['NOTICE-XYZ'],
            id="no_default_glob_patterns"),
        pytest.param({
            'setup.cfg': DALS("""
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  LICENSE*
                              """),
            'LICENSE-ABC': "ABC license",
            }, ['LICENSE-ABC'], [],
            id="files_only_added_once",
        ),
    ])
    def test_setup_cfg_license_files(
            self, tmpdir_cwd, env, files, incl_licenses, excl_licenses):
        self._create_project()
        path.build(files)

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)])
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')

        with open(os.path.join(egg_info_dir, 'SOURCES.txt')) as sources_file:
            sources_lines = list(line.strip() for line in sources_file)

        for lf in incl_licenses:
            assert sources_lines.count(lf) == 1

        for lf in excl_licenses:
            assert sources_lines.count(lf) == 0

    @pytest.mark.parametrize("files, incl_licenses, excl_licenses", [
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file =
                              license_files =
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
        }, [], ['LICENSE-ABC', 'LICENSE-XYZ']),  # both empty
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-XYZ': "XYZ license"
            # license_file is still singular
        }, [], ['LICENSE-ABC', 'LICENSE-XYZ']),
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-XYZ
                                  LICENSE-PQR
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-PQR': "PQR license",
            'LICENSE-XYZ': "XYZ license"
        }, ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'], []),  # combined
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                                  LICENSE-PQR
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-PQR': "PQR license",
            'LICENSE-XYZ': "XYZ license"
            # duplicate license
        }, ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'], []),
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-XYZ
                              """),
            'LICENSE-ABC': "ABC license",
            'LICENSE-PQR': "PQR license",
            'LICENSE-XYZ': "XYZ license"
            # combined subset
        }, ['LICENSE-ABC', 'LICENSE-XYZ'], ['LICENSE-PQR']),
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-XYZ
                                  LICENSE-PQR
                              """),
            'LICENSE-PQR': "Test license"
            # with invalid licenses
        }, ['LICENSE-PQR'], ['LICENSE-ABC', 'LICENSE-XYZ']),
        ({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                LICENSE-PQR
                                LICENSE-XYZ
                              """),
            'MANIFEST.in': "exclude LICENSE-ABC\nexclude LICENSE-PQR",
            'LICENSE-ABC': "ABC license",
            'LICENSE-PQR': "PQR license",
            'LICENSE-XYZ': "XYZ license"
            # manifest is overwritten
        }, ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'], []),
        pytest.param({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE*
                              """),
            'LICENSE-ABC': "ABC license",
            'NOTICE-XYZ': "XYZ notice",
            }, ['LICENSE-ABC'], ['NOTICE-XYZ'],
            id="no_default_glob_patterns"),
        pytest.param({
            'setup.cfg': DALS("""
                              [metadata]
                              license_file = LICENSE*
                              license_files =
                                NOTICE*
                              """),
            'LICENSE-ABC': "ABC license",
            'NOTICE-ABC': "ABC notice",
            'AUTHORS-ABC': "ABC authors",
            }, ['LICENSE-ABC', 'NOTICE-ABC'], ['AUTHORS-ABC'],
            id="combined_glob_patterrns"),
    ])
    def test_setup_cfg_license_file_license_files(
            self, tmpdir_cwd, env, files, incl_licenses, excl_licenses):
        self._create_project()
        path.build(files)

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)])
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')

        with open(os.path.join(egg_info_dir, 'SOURCES.txt')) as sources_file:
            sources_lines = list(line.strip() for line in sources_file)

        for lf in incl_licenses:
            assert sources_lines.count(lf) == 1

        for lf in excl_licenses:
            assert sources_lines.count(lf) == 0

    def test_license_file_attr_pkg_info(self, tmpdir_cwd, env):
        """All matched license files should have a corresponding License-File."""
        self._create_project()
        path.build({
            "setup.cfg": DALS("""
                              [metadata]
                              license_files =
                                  NOTICE*
                                  LICENSE*
                              """),
            "LICENSE-ABC": "ABC license",
            "LICENSE-XYZ": "XYZ license",
            "NOTICE": "included",
            "IGNORE": "not include",
        })

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)])
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        license_file_lines = [
            line for line in pkg_info_lines if line.startswith('License-File:')]

        # Only 'NOTICE', LICENSE-ABC', and 'LICENSE-XYZ' should have been matched
        # Also assert that order from license_files is keeped
        assert "License-File: NOTICE" == license_file_lines[0]
        assert "License-File: LICENSE-ABC" in license_file_lines[1:]
        assert "License-File: LICENSE-XYZ" in license_file_lines[1:]

    def test_metadata_version(self, tmpdir_cwd, env):
        """Make sure latest metadata version is used by default."""
        self._setup_script_with_requires("")
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        # Update metadata version if changed
        assert self._extract_mv_version(pkg_info_lines) == (2, 1)

    def test_long_description_content_type(self, tmpdir_cwd, env):
        # Test that specifying a `long_description_content_type` keyword arg to
        # the `setup` function results in writing a `Description-Content-Type`
        # line to the `PKG-INFO` file in the `.egg-info`
        # directory.
        # `Description-Content-Type` is described at
        # https://github.com/pypa/python-packaging-user-guide/pull/258

        self._setup_script_with_requires(
            """long_description_content_type='text/markdown',""")
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        expected_line = 'Description-Content-Type: text/markdown'
        assert expected_line in pkg_info_lines
        assert 'Metadata-Version: 2.1' in pkg_info_lines

    def test_long_description(self, tmpdir_cwd, env):
        # Test that specifying `long_description` and `long_description_content_type`
        # keyword args to the `setup` function results in writing
        # the description in the message payload of the `PKG-INFO` file
        # in the `.egg-info` directory.
        self._setup_script_with_requires(
            "long_description='This is a long description\\nover multiple lines',"
            "long_description_content_type='text/markdown',"
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Metadata-Version: 2.1' in pkg_info_lines
        assert '' == pkg_info_lines[-1]  # last line should be empty
        long_desc_lines = pkg_info_lines[pkg_info_lines.index(''):]
        assert 'This is a long description' in long_desc_lines
        assert 'over multiple lines' in long_desc_lines

    def test_project_urls(self, tmpdir_cwd, env):
        # Test that specifying a `project_urls` dict to the `setup`
        # function results in writing multiple `Project-URL` lines to
        # the `PKG-INFO` file in the `.egg-info`
        # directory.
        # `Project-URL` is described at https://packaging.python.org
        #     /specifications/core-metadata/#project-url-multiple-use

        self._setup_script_with_requires(
            """project_urls={
                'Link One': 'https://example.com/one/',
                'Link Two': 'https://example.com/two/',
                },""")
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        expected_line = 'Project-URL: Link One, https://example.com/one/'
        assert expected_line in pkg_info_lines
        expected_line = 'Project-URL: Link Two, https://example.com/two/'
        assert expected_line in pkg_info_lines
        assert self._extract_mv_version(pkg_info_lines) >= (1, 2)

    def test_license(self, tmpdir_cwd, env):
        """Test single line license."""
        self._setup_script_with_requires(
            "license='MIT',"
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'License: MIT' in pkg_info_lines

    def test_license_escape(self, tmpdir_cwd, env):
        """Test license is escaped correctly if longer than one line."""
        self._setup_script_with_requires(
            "license='This is a long license text \\nover multiple lines',"
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')

        assert 'License: This is a long license text ' in pkg_info_lines
        assert '        over multiple lines' in pkg_info_lines
        assert 'text \n        over multiple' in '\n'.join(pkg_info_lines)

    def test_python_requires_egg_info(self, tmpdir_cwd, env):
        self._setup_script_with_requires(
            """python_requires='>=2.7.12',""")
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Requires-Python: >=2.7.12' in pkg_info_lines
        assert self._extract_mv_version(pkg_info_lines) >= (1, 2)

    def test_manifest_maker_warning_suppression(self):
        fixtures = [
            "standard file not found: should have one of foo.py, bar.py",
            "standard file 'setup.py' not found"
        ]

        for msg in fixtures:
            assert manifest_maker._should_suppress_warning(msg)

    def test_egg_info_includes_setup_py(self, tmpdir_cwd):
        self._create_project()
        dist = Distribution({"name": "foo", "version": "0.0.1"})
        dist.script_name = "non_setup.py"
        egg_info_instance = egg_info(dist)
        egg_info_instance.finalize_options()
        egg_info_instance.run()

        assert 'setup.py' in egg_info_instance.filelist.files

        with open(egg_info_instance.egg_info + "/SOURCES.txt") as f:
            sources = f.read().split('\n')
            assert 'setup.py' in sources

    def _run_egg_info_command(self, tmpdir_cwd, env, cmd=None, output=None):
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        if cmd is None:
            cmd = [
                'egg_info',
            ]
        code, data = environment.run_setup_py(
            cmd=cmd,
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        assert not code, data

        if output:
            assert output in data

    def test_egg_info_tag_only_once(self, tmpdir_cwd, env):
        self._create_project()
        path.build({
            'setup.cfg': DALS("""
                              [egg_info]
                              tag_build = dev
                              tag_date = 0
                              tag_svn_revision = 0
                              """),
        })
        self._run_egg_info_command(tmpdir_cwd, env)
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Version: 0.0.0.dev0' in pkg_info_lines

    def test_get_pkg_info_revision_deprecated(self):
        pytest.warns(EggInfoDeprecationWarning, get_pkg_info_revision)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_extern.py0000644000175100001710000000073100000000000021676 0ustar00runnerdockerimport importlib
import pickle

from setuptools import Distribution
from setuptools.extern import ordered_set


def test_reimport_extern():
    ordered_set2 = importlib.import_module(ordered_set.__name__)
    assert ordered_set is ordered_set2


def test_orderedset_pickle_roundtrip():
    o1 = ordered_set.OrderedSet([1, 2, 5])
    o2 = pickle.loads(pickle.dumps(o1))
    assert o1 == o2


def test_distribution_picklable():
    pickle.loads(pickle.dumps(Distribution()))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_find_packages.py0000644000175100001710000001423300000000000023151 0ustar00runnerdocker"""Tests for setuptools.find_packages()."""
import os
import sys
import shutil
import tempfile
import platform

import pytest

from setuptools import find_packages
from setuptools import find_namespace_packages


# modeled after CPython's test.support.can_symlink
def can_symlink():
    TESTFN = tempfile.mktemp()
    symlink_path = TESTFN + "can_symlink"
    try:
        os.symlink(TESTFN, symlink_path)
        can = True
    except (OSError, NotImplementedError, AttributeError):
        can = False
    else:
        os.remove(symlink_path)
    globals().update(can_symlink=lambda: can)
    return can


def has_symlink():
    bad_symlink = (
        # Windows symlink directory detection is broken on Python 3.2
        platform.system() == 'Windows' and sys.version_info[:2] == (3, 2)
    )
    return can_symlink() and not bad_symlink


class TestFindPackages:
    def setup_method(self, method):
        self.dist_dir = tempfile.mkdtemp()
        self._make_pkg_structure()

    def teardown_method(self, method):
        shutil.rmtree(self.dist_dir)

    def _make_pkg_structure(self):
        """Make basic package structure.

        dist/
            docs/
                conf.py
            pkg/
                __pycache__/
                nspkg/
                    mod.py
                subpkg/
                    assets/
                        asset
                    __init__.py
            setup.py

        """
        self.docs_dir = self._mkdir('docs', self.dist_dir)
        self._touch('conf.py', self.docs_dir)
        self.pkg_dir = self._mkdir('pkg', self.dist_dir)
        self._mkdir('__pycache__', self.pkg_dir)
        self.ns_pkg_dir = self._mkdir('nspkg', self.pkg_dir)
        self._touch('mod.py', self.ns_pkg_dir)
        self.sub_pkg_dir = self._mkdir('subpkg', self.pkg_dir)
        self.asset_dir = self._mkdir('assets', self.sub_pkg_dir)
        self._touch('asset', self.asset_dir)
        self._touch('__init__.py', self.sub_pkg_dir)
        self._touch('setup.py', self.dist_dir)

    def _mkdir(self, path, parent_dir=None):
        if parent_dir:
            path = os.path.join(parent_dir, path)
        os.mkdir(path)
        return path

    def _touch(self, path, dir_=None):
        if dir_:
            path = os.path.join(dir_, path)
        fp = open(path, 'w')
        fp.close()
        return path

    def test_regular_package(self):
        self._touch('__init__.py', self.pkg_dir)
        packages = find_packages(self.dist_dir)
        assert packages == ['pkg', 'pkg.subpkg']

    def test_exclude(self):
        self._touch('__init__.py', self.pkg_dir)
        packages = find_packages(self.dist_dir, exclude=('pkg.*',))
        assert packages == ['pkg']

    def test_exclude_recursive(self):
        """
        Excluding a parent package should not exclude child packages as well.
        """
        self._touch('__init__.py', self.pkg_dir)
        self._touch('__init__.py', self.sub_pkg_dir)
        packages = find_packages(self.dist_dir, exclude=('pkg',))
        assert packages == ['pkg.subpkg']

    def test_include_excludes_other(self):
        """
        If include is specified, other packages should be excluded.
        """
        self._touch('__init__.py', self.pkg_dir)
        alt_dir = self._mkdir('other_pkg', self.dist_dir)
        self._touch('__init__.py', alt_dir)
        packages = find_packages(self.dist_dir, include=['other_pkg'])
        assert packages == ['other_pkg']

    def test_dir_with_dot_is_skipped(self):
        shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
        data_dir = self._mkdir('some.data', self.pkg_dir)
        self._touch('__init__.py', data_dir)
        self._touch('file.dat', data_dir)
        packages = find_packages(self.dist_dir)
        assert 'pkg.some.data' not in packages

    def test_dir_with_packages_in_subdir_is_excluded(self):
        """
        Ensure that a package in a non-package such as build/pkg/__init__.py
        is excluded.
        """
        build_dir = self._mkdir('build', self.dist_dir)
        build_pkg_dir = self._mkdir('pkg', build_dir)
        self._touch('__init__.py', build_pkg_dir)
        packages = find_packages(self.dist_dir)
        assert 'build.pkg' not in packages

    @pytest.mark.skipif(not has_symlink(), reason='Symlink support required')
    def test_symlinked_packages_are_included(self):
        """
        A symbolically-linked directory should be treated like any other
        directory when matched as a package.

        Create a link from lpkg -> pkg.
        """
        self._touch('__init__.py', self.pkg_dir)
        linked_pkg = os.path.join(self.dist_dir, 'lpkg')
        os.symlink('pkg', linked_pkg)
        assert os.path.isdir(linked_pkg)
        packages = find_packages(self.dist_dir)
        assert 'lpkg' in packages

    def _assert_packages(self, actual, expected):
        assert set(actual) == set(expected)

    def test_pep420_ns_package(self):
        packages = find_namespace_packages(
            self.dist_dir, include=['pkg*'], exclude=['pkg.subpkg.assets'])
        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])

    def test_pep420_ns_package_no_includes(self):
        packages = find_namespace_packages(
            self.dist_dir, exclude=['pkg.subpkg.assets'])
        self._assert_packages(
            packages, ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg'])

    def test_pep420_ns_package_no_includes_or_excludes(self):
        packages = find_namespace_packages(self.dist_dir)
        expected = [
            'docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg', 'pkg.subpkg.assets']
        self._assert_packages(packages, expected)

    def test_regular_package_with_nested_pep420_ns_packages(self):
        self._touch('__init__.py', self.pkg_dir)
        packages = find_namespace_packages(
            self.dist_dir, exclude=['docs', 'pkg.subpkg.assets'])
        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])

    def test_pep420_ns_package_no_non_package_dirs(self):
        shutil.rmtree(self.docs_dir)
        shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
        packages = find_namespace_packages(self.dist_dir)
        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_glob.py0000644000175100001710000000136400000000000021317 0ustar00runnerdockerimport pytest
from jaraco import path

from setuptools.glob import glob


@pytest.mark.parametrize('tree, pattern, matches', (
    ('', b'', []),
    ('', '', []),
    ('''
     appveyor.yml
     CHANGES.rst
     LICENSE
     MANIFEST.in
     pyproject.toml
     README.rst
     setup.cfg
     setup.py
     ''', '*.rst', ('CHANGES.rst', 'README.rst')),
    ('''
     appveyor.yml
     CHANGES.rst
     LICENSE
     MANIFEST.in
     pyproject.toml
     README.rst
     setup.cfg
     setup.py
     ''', b'*.rst', (b'CHANGES.rst', b'README.rst')),
))
def test_glob(monkeypatch, tmpdir, tree, pattern, matches):
    monkeypatch.chdir(tmpdir)
    path.build({name: '' for name in tree.split()})
    assert list(sorted(glob(pattern))) == list(sorted(matches))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_install_scripts.py0000644000175100001710000000647700000000000023623 0ustar00runnerdocker"""install_scripts tests
"""

import io
import sys

import pytest

from setuptools.command.install_scripts import install_scripts
from setuptools.dist import Distribution
from . import contexts


class TestInstallScripts:
    settings = dict(
        name='foo',
        entry_points={'console_scripts': ['foo=foo:foo']},
        version='0.0',
    )
    unix_exe = '/usr/dummy-test-path/local/bin/python'
    unix_spaces_exe = '/usr/bin/env dummy-test-python'
    win32_exe = 'C:\\Dummy Test Path\\Program Files\\Python 3.6\\python.exe'

    def _run_install_scripts(self, install_dir, executable=None):
        dist = Distribution(self.settings)
        dist.script_name = 'setup.py'
        cmd = install_scripts(dist)
        cmd.install_dir = install_dir
        if executable is not None:
            bs = cmd.get_finalized_command('build_scripts')
            bs.executable = executable
        cmd.ensure_finalized()
        with contexts.quiet():
            cmd.run()

    @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
    def test_sys_executable_escaping_unix(self, tmpdir, monkeypatch):
        """
        Ensure that shebang is not quoted on Unix when getting the Python exe
        from sys.executable.
        """
        expected = '#!%s\n' % self.unix_exe
        monkeypatch.setattr('sys.executable', self.unix_exe)
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir))
            with io.open(str(tmpdir.join('foo')), 'r') as f:
                actual = f.readline()
        assert actual == expected

    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only')
    def test_sys_executable_escaping_win32(self, tmpdir, monkeypatch):
        """
        Ensure that shebang is quoted on Windows when getting the Python exe
        from sys.executable and it contains a space.
        """
        expected = '#!"%s"\n' % self.win32_exe
        monkeypatch.setattr('sys.executable', self.win32_exe)
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir))
            with io.open(str(tmpdir.join('foo-script.py')), 'r') as f:
                actual = f.readline()
        assert actual == expected

    @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
    def test_executable_with_spaces_escaping_unix(self, tmpdir):
        """
        Ensure that shebang on Unix is not quoted, even when
        a value with spaces
        is specified using --executable.
        """
        expected = '#!%s\n' % self.unix_spaces_exe
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir), self.unix_spaces_exe)
            with io.open(str(tmpdir.join('foo')), 'r') as f:
                actual = f.readline()
        assert actual == expected

    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only')
    def test_executable_arg_escaping_win32(self, tmpdir):
        """
        Ensure that shebang on Windows is quoted when
        getting a path with spaces
        from --executable, that is itself properly quoted.
        """
        expected = '#!"%s"\n' % self.win32_exe
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir), '"' + self.win32_exe + '"')
            with io.open(str(tmpdir.join('foo-script.py')), 'r') as f:
                actual = f.readline()
        assert actual == expected
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_integration.py0000644000175100001710000000675200000000000022725 0ustar00runnerdocker"""Run some integration tests.

Try to install a few packages.
"""

import glob
import os
import sys
import urllib.request

import pytest

from setuptools.command.easy_install import easy_install
from setuptools.command import easy_install as easy_install_pkg
from setuptools.dist import Distribution


pytestmark = pytest.mark.skipif(
    'platform.python_implementation() == "PyPy" and '
    'platform.system() == "Windows"',
    reason="pypa/setuptools#2496",
)


def setup_module(module):
    packages = 'stevedore', 'virtualenvwrapper', 'pbr', 'novaclient'
    for pkg in packages:
        try:
            __import__(pkg)
            tmpl = "Integration tests cannot run when {pkg} is installed"
            pytest.skip(tmpl.format(**locals()))
        except ImportError:
            pass

    try:
        urllib.request.urlopen('https://pypi.python.org/pypi')
    except Exception as exc:
        pytest.skip(str(exc))


@pytest.fixture
def install_context(request, tmpdir, monkeypatch):
    """Fixture to set up temporary installation directory.
    """
    # Save old values so we can restore them.
    new_cwd = tmpdir.mkdir('cwd')
    user_base = tmpdir.mkdir('user_base')
    user_site = tmpdir.mkdir('user_site')
    install_dir = tmpdir.mkdir('install_dir')

    def fin():
        # undo the monkeypatch, particularly needed under
        # windows because of kept handle on cwd
        monkeypatch.undo()
        new_cwd.remove()
        user_base.remove()
        user_site.remove()
        install_dir.remove()

    request.addfinalizer(fin)

    # Change the environment and site settings to control where the
    # files are installed and ensure we do not overwrite anything.
    monkeypatch.chdir(new_cwd)
    monkeypatch.setattr(easy_install_pkg, '__file__', user_site.strpath)
    monkeypatch.setattr('site.USER_BASE', user_base.strpath)
    monkeypatch.setattr('site.USER_SITE', user_site.strpath)
    monkeypatch.setattr('sys.path', sys.path + [install_dir.strpath])
    monkeypatch.setenv(str('PYTHONPATH'), str(os.path.pathsep.join(sys.path)))

    # Set up the command for performing the installation.
    dist = Distribution()
    cmd = easy_install(dist)
    cmd.install_dir = install_dir.strpath
    return cmd


def _install_one(requirement, cmd, pkgname, modulename):
    cmd.args = [requirement]
    cmd.ensure_finalized()
    cmd.run()
    target = cmd.install_dir
    dest_path = glob.glob(os.path.join(target, pkgname + '*.egg'))
    assert dest_path
    assert os.path.exists(os.path.join(dest_path[0], pkgname, modulename))


def test_stevedore(install_context):
    _install_one('stevedore', install_context,
                 'stevedore', 'extension.py')


@pytest.mark.xfail
def test_virtualenvwrapper(install_context):
    _install_one('virtualenvwrapper', install_context,
                 'virtualenvwrapper', 'hook_loader.py')


def test_pbr(install_context):
    _install_one('pbr', install_context,
                 'pbr', 'core.py')


@pytest.mark.xfail
def test_python_novaclient(install_context):
    _install_one('python-novaclient', install_context,
                 'novaclient', 'base.py')


def test_pyuri(install_context):
    """
    Install the pyuri package (version 0.3.1 at the time of writing).

    This is also a regression test for issue #1016.
    """
    _install_one('pyuri', install_context, 'pyuri', 'uri.py')

    pyuri = install_context.installed_projects['pyuri']

    # The package data should be installed.
    assert os.path.exists(os.path.join(pyuri.location, 'pyuri', 'uri.regex'))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_manifest.py0000644000175100001710000004312700000000000022205 0ustar00runnerdocker# -*- coding: utf-8 -*-
"""sdist tests"""

import contextlib
import os
import shutil
import sys
import tempfile
import itertools
import io
from distutils import log
from distutils.errors import DistutilsTemplateError

from setuptools.command.egg_info import FileList, egg_info, translate_pattern
from setuptools.dist import Distribution
from setuptools.tests.textwrap import DALS

import pytest


def make_local_path(s):
    """Converts '/' in a string to os.sep"""
    return s.replace('/', os.sep)


SETUP_ATTRS = {
    'name': 'app',
    'version': '0.0',
    'packages': ['app'],
}

SETUP_PY = """\
from setuptools import setup

setup(**%r)
""" % SETUP_ATTRS


@contextlib.contextmanager
def quiet():
    old_stdout, old_stderr = sys.stdout, sys.stderr
    sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
    try:
        yield
    finally:
        sys.stdout, sys.stderr = old_stdout, old_stderr


def touch(filename):
    open(filename, 'w').close()


# The set of files always in the manifest, including all files in the
# .egg-info directory
default_files = frozenset(map(make_local_path, [
    'README.rst',
    'MANIFEST.in',
    'setup.py',
    'app.egg-info/PKG-INFO',
    'app.egg-info/SOURCES.txt',
    'app.egg-info/dependency_links.txt',
    'app.egg-info/top_level.txt',
    'app/__init__.py',
]))


translate_specs = [
    ('foo', ['foo'], ['bar', 'foobar']),
    ('foo/bar', ['foo/bar'], ['foo/bar/baz', './foo/bar', 'foo']),

    # Glob matching
    ('*.txt', ['foo.txt', 'bar.txt'], ['foo/foo.txt']),
    (
        'dir/*.txt',
        ['dir/foo.txt', 'dir/bar.txt', 'dir/.txt'], ['notdir/foo.txt']),
    ('*/*.py', ['bin/start.py'], []),
    ('docs/page-?.txt', ['docs/page-9.txt'], ['docs/page-10.txt']),

    # Globstars change what they mean depending upon where they are
    (
        'foo/**/bar',
        ['foo/bing/bar', 'foo/bing/bang/bar', 'foo/bar'],
        ['foo/abar'],
    ),
    (
        'foo/**',
        ['foo/bar/bing.py', 'foo/x'],
        ['/foo/x'],
    ),
    (
        '**',
        ['x', 'abc/xyz', '@nything'],
        [],
    ),

    # Character classes
    (
        'pre[one]post',
        ['preopost', 'prenpost', 'preepost'],
        ['prepost', 'preonepost'],
    ),

    (
        'hello[!one]world',
        ['helloxworld', 'helloyworld'],
        ['hellooworld', 'helloworld', 'hellooneworld'],
    ),

    (
        '[]one].txt',
        ['o.txt', '].txt', 'e.txt'],
        ['one].txt'],
    ),

    (
        'foo[!]one]bar',
        ['fooybar'],
        ['foo]bar', 'fooobar', 'fooebar'],
    ),

]
"""
A spec of inputs for 'translate_pattern' and matches and mismatches
for that input.
"""

match_params = itertools.chain.from_iterable(
    zip(itertools.repeat(pattern), matches)
    for pattern, matches, mismatches in translate_specs
)


@pytest.fixture(params=match_params)
def pattern_match(request):
    return map(make_local_path, request.param)


mismatch_params = itertools.chain.from_iterable(
    zip(itertools.repeat(pattern), mismatches)
    for pattern, matches, mismatches in translate_specs
)


@pytest.fixture(params=mismatch_params)
def pattern_mismatch(request):
    return map(make_local_path, request.param)


def test_translated_pattern_match(pattern_match):
    pattern, target = pattern_match
    assert translate_pattern(pattern).match(target)


def test_translated_pattern_mismatch(pattern_mismatch):
    pattern, target = pattern_mismatch
    assert not translate_pattern(pattern).match(target)


class TempDirTestCase:
    def setup_method(self, method):
        self.temp_dir = tempfile.mkdtemp()
        self.old_cwd = os.getcwd()
        os.chdir(self.temp_dir)

    def teardown_method(self, method):
        os.chdir(self.old_cwd)
        shutil.rmtree(self.temp_dir)


class TestManifestTest(TempDirTestCase):
    def setup_method(self, method):
        super(TestManifestTest, self).setup_method(method)

        f = open(os.path.join(self.temp_dir, 'setup.py'), 'w')
        f.write(SETUP_PY)
        f.close()
        """
        Create a file tree like:
        - LICENSE
        - README.rst
        - testing.rst
        - .hidden.rst
        - app/
            - __init__.py
            - a.txt
            - b.txt
            - c.rst
            - static/
                - app.js
                - app.js.map
                - app.css
                - app.css.map
        """

        for fname in ['README.rst', '.hidden.rst', 'testing.rst', 'LICENSE']:
            touch(os.path.join(self.temp_dir, fname))

        # Set up the rest of the test package
        test_pkg = os.path.join(self.temp_dir, 'app')
        os.mkdir(test_pkg)
        for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']:
            touch(os.path.join(test_pkg, fname))

        # Some compiled front-end assets to include
        static = os.path.join(test_pkg, 'static')
        os.mkdir(static)
        for fname in ['app.js', 'app.js.map', 'app.css', 'app.css.map']:
            touch(os.path.join(static, fname))

    def make_manifest(self, contents):
        """Write a MANIFEST.in."""
        with open(os.path.join(self.temp_dir, 'MANIFEST.in'), 'w') as f:
            f.write(DALS(contents))

    def get_files(self):
        """Run egg_info and get all the files to include, as a set"""
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = egg_info(dist)
        cmd.ensure_finalized()

        cmd.run()

        return set(cmd.filelist.files)

    def test_no_manifest(self):
        """Check a missing MANIFEST.in includes only the standard files."""
        assert (default_files - set(['MANIFEST.in'])) == self.get_files()

    def test_empty_files(self):
        """Check an empty MANIFEST.in includes only the standard files."""
        self.make_manifest("")
        assert default_files == self.get_files()

    def test_include(self):
        """Include extra rst files in the project root."""
        self.make_manifest("include *.rst")
        files = default_files | set([
            'testing.rst', '.hidden.rst'])
        assert files == self.get_files()

    def test_exclude(self):
        """Include everything in app/ except the text files"""
        ml = make_local_path
        self.make_manifest(
            """
            include app/*
            exclude app/*.txt
            """)
        files = default_files | set([ml('app/c.rst')])
        assert files == self.get_files()

    def test_include_multiple(self):
        """Include with multiple patterns."""
        ml = make_local_path
        self.make_manifest("include app/*.txt app/static/*")
        files = default_files | set([
            ml('app/a.txt'), ml('app/b.txt'),
            ml('app/static/app.js'), ml('app/static/app.js.map'),
            ml('app/static/app.css'), ml('app/static/app.css.map')])
        assert files == self.get_files()

    def test_graft(self):
        """Include the whole app/static/ directory."""
        ml = make_local_path
        self.make_manifest("graft app/static")
        files = default_files | set([
            ml('app/static/app.js'), ml('app/static/app.js.map'),
            ml('app/static/app.css'), ml('app/static/app.css.map')])
        assert files == self.get_files()

    def test_graft_glob_syntax(self):
        """Include the whole app/static/ directory."""
        ml = make_local_path
        self.make_manifest("graft */static")
        files = default_files | set([
            ml('app/static/app.js'), ml('app/static/app.js.map'),
            ml('app/static/app.css'), ml('app/static/app.css.map')])
        assert files == self.get_files()

    def test_graft_global_exclude(self):
        """Exclude all *.map files in the project."""
        ml = make_local_path
        self.make_manifest(
            """
            graft app/static
            global-exclude *.map
            """)
        files = default_files | set([
            ml('app/static/app.js'), ml('app/static/app.css')])
        assert files == self.get_files()

    def test_global_include(self):
        """Include all *.rst, *.js, and *.css files in the whole tree."""
        ml = make_local_path
        self.make_manifest(
            """
            global-include *.rst *.js *.css
            """)
        files = default_files | set([
            '.hidden.rst', 'testing.rst', ml('app/c.rst'),
            ml('app/static/app.js'), ml('app/static/app.css')])
        assert files == self.get_files()

    def test_graft_prune(self):
        """Include all files in app/, except for the whole app/static/ dir."""
        ml = make_local_path
        self.make_manifest(
            """
            graft app
            prune app/static
            """)
        files = default_files | set([
            ml('app/a.txt'), ml('app/b.txt'), ml('app/c.rst')])
        assert files == self.get_files()


class TestFileListTest(TempDirTestCase):
    """
    A copy of the relevant bits of distutils/tests/test_filelist.py,
    to ensure setuptools' version of FileList keeps parity with distutils.
    """

    def setup_method(self, method):
        super(TestFileListTest, self).setup_method(method)
        self.threshold = log.set_threshold(log.FATAL)
        self._old_log = log.Log._log
        log.Log._log = self._log
        self.logs = []

    def teardown_method(self, method):
        log.set_threshold(self.threshold)
        log.Log._log = self._old_log
        super(TestFileListTest, self).teardown_method(method)

    def _log(self, level, msg, args):
        if level not in (log.DEBUG, log.INFO, log.WARN, log.ERROR, log.FATAL):
            raise ValueError('%s wrong log level' % str(level))
        self.logs.append((level, msg, args))

    def get_logs(self, *levels):
        def _format(msg, args):
            if len(args) == 0:
                return msg
            return msg % args
        return [_format(msg, args) for level, msg, args
                in self.logs if level in levels]

    def clear_logs(self):
        self.logs = []

    def assertNoWarnings(self):
        assert self.get_logs(log.WARN) == []
        self.clear_logs()

    def assertWarnings(self):
        assert len(self.get_logs(log.WARN)) > 0
        self.clear_logs()

    def make_files(self, files):
        for file in files:
            file = os.path.join(self.temp_dir, file)
            dirname, basename = os.path.split(file)
            os.makedirs(dirname, exist_ok=True)
            open(file, 'w').close()

    def test_process_template_line(self):
        # testing  all MANIFEST.in template patterns
        file_list = FileList()
        ml = make_local_path

        # simulated file list
        self.make_files([
            'foo.tmp', 'ok', 'xo', 'four.txt',
            'buildout.cfg',
            # filelist does not filter out VCS directories,
            # it's sdist that does
            ml('.hg/last-message.txt'),
            ml('global/one.txt'),
            ml('global/two.txt'),
            ml('global/files.x'),
            ml('global/here.tmp'),
            ml('f/o/f.oo'),
            ml('dir/graft-one'),
            ml('dir/dir2/graft2'),
            ml('dir3/ok'),
            ml('dir3/sub/ok.txt'),
        ])

        MANIFEST_IN = DALS("""\
        include ok
        include xo
        exclude xo
        include foo.tmp
        include buildout.cfg
        global-include *.x
        global-include *.txt
        global-exclude *.tmp
        recursive-include f *.oo
        recursive-exclude global *.x
        graft dir
        prune dir3
        """)

        for line in MANIFEST_IN.split('\n'):
            if not line:
                continue
            file_list.process_template_line(line)

        wanted = [
            'buildout.cfg',
            'four.txt',
            'ok',
            ml('.hg/last-message.txt'),
            ml('dir/graft-one'),
            ml('dir/dir2/graft2'),
            ml('f/o/f.oo'),
            ml('global/one.txt'),
            ml('global/two.txt'),
        ]

        file_list.sort()
        assert file_list.files == wanted

    def test_exclude_pattern(self):
        # return False if no match
        file_list = FileList()
        assert not file_list.exclude_pattern('*.py')

        # return True if files match
        file_list = FileList()
        file_list.files = ['a.py', 'b.py']
        assert file_list.exclude_pattern('*.py')

        # test excludes
        file_list = FileList()
        file_list.files = ['a.py', 'a.txt']
        file_list.exclude_pattern('*.py')
        file_list.sort()
        assert file_list.files == ['a.txt']

    def test_include_pattern(self):
        # return False if no match
        file_list = FileList()
        self.make_files([])
        assert not file_list.include_pattern('*.py')

        # return True if files match
        file_list = FileList()
        self.make_files(['a.py', 'b.txt'])
        assert file_list.include_pattern('*.py')

        # test * matches all files
        file_list = FileList()
        self.make_files(['a.py', 'b.txt'])
        file_list.include_pattern('*')
        file_list.sort()
        assert file_list.files == ['a.py', 'b.txt']

    def test_process_template_line_invalid(self):
        # invalid lines
        file_list = FileList()
        for action in ('include', 'exclude', 'global-include',
                       'global-exclude', 'recursive-include',
                       'recursive-exclude', 'graft', 'prune', 'blarg'):
            try:
                file_list.process_template_line(action)
            except DistutilsTemplateError:
                pass
            except Exception:
                assert False, "Incorrect error thrown"
            else:
                assert False, "Should have thrown an error"

    def test_include(self):
        ml = make_local_path
        # include
        file_list = FileList()
        self.make_files(['a.py', 'b.txt', ml('d/c.py')])

        file_list.process_template_line('include *.py')
        file_list.sort()
        assert file_list.files == ['a.py']
        self.assertNoWarnings()

        file_list.process_template_line('include *.rb')
        file_list.sort()
        assert file_list.files == ['a.py']
        self.assertWarnings()

    def test_exclude(self):
        ml = make_local_path
        # exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', ml('d/c.py')]

        file_list.process_template_line('exclude *.py')
        file_list.sort()
        assert file_list.files == ['b.txt', ml('d/c.py')]
        self.assertNoWarnings()

        file_list.process_template_line('exclude *.rb')
        file_list.sort()
        assert file_list.files == ['b.txt', ml('d/c.py')]
        self.assertWarnings()

    def test_global_include(self):
        ml = make_local_path
        # global-include
        file_list = FileList()
        self.make_files(['a.py', 'b.txt', ml('d/c.py')])

        file_list.process_template_line('global-include *.py')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.py')]
        self.assertNoWarnings()

        file_list.process_template_line('global-include *.rb')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.py')]
        self.assertWarnings()

    def test_global_exclude(self):
        ml = make_local_path
        # global-exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', ml('d/c.py')]

        file_list.process_template_line('global-exclude *.py')
        file_list.sort()
        assert file_list.files == ['b.txt']
        self.assertNoWarnings()

        file_list.process_template_line('global-exclude *.rb')
        file_list.sort()
        assert file_list.files == ['b.txt']
        self.assertWarnings()

    def test_recursive_include(self):
        ml = make_local_path
        # recursive-include
        file_list = FileList()
        self.make_files(['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')])

        file_list.process_template_line('recursive-include d *.py')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertNoWarnings()

        file_list.process_template_line('recursive-include e *.py')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertWarnings()

    def test_recursive_exclude(self):
        ml = make_local_path
        # recursive-exclude
        file_list = FileList()
        file_list.files = ['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')]

        file_list.process_template_line('recursive-exclude d *.py')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.txt')]
        self.assertNoWarnings()

        file_list.process_template_line('recursive-exclude e *.py')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.txt')]
        self.assertWarnings()

    def test_graft(self):
        ml = make_local_path
        # graft
        file_list = FileList()
        self.make_files(['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')])

        file_list.process_template_line('graft d')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertNoWarnings()

        file_list.process_template_line('graft e')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertWarnings()

    def test_prune(self):
        ml = make_local_path
        # prune
        file_list = FileList()
        file_list.files = ['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')]

        file_list.process_template_line('prune d')
        file_list.sort()
        assert file_list.files == ['a.py', ml('f/f.py')]
        self.assertNoWarnings()

        file_list.process_template_line('prune e')
        file_list.sort()
        assert file_list.files == ['a.py', ml('f/f.py')]
        self.assertWarnings()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_msvc.py0000644000175100001710000001337000000000000021344 0ustar00runnerdocker"""
Tests for msvc support module.
"""

import os
import contextlib
import distutils.errors
import mock

import pytest

from . import contexts

# importing only setuptools should apply the patch
__import__('setuptools')

pytest.importorskip("distutils.msvc9compiler")


def mock_reg(hkcu=None, hklm=None):
    """
    Return a mock for distutils.msvc9compiler.Reg, patched
    to mock out the functions that access the registry.
    """

    _winreg = getattr(distutils.msvc9compiler, '_winreg', None)
    winreg = getattr(distutils.msvc9compiler, 'winreg', _winreg)

    hives = {
        winreg.HKEY_CURRENT_USER: hkcu or {},
        winreg.HKEY_LOCAL_MACHINE: hklm or {},
    }

    @classmethod
    def read_keys(cls, base, key):
        """Return list of registry keys."""
        hive = hives.get(base, {})
        return [
            k.rpartition('\\')[2]
            for k in hive if k.startswith(key.lower())
        ]

    @classmethod
    def read_values(cls, base, key):
        """Return dict of registry keys and values."""
        hive = hives.get(base, {})
        return dict(
            (k.rpartition('\\')[2], hive[k])
            for k in hive if k.startswith(key.lower())
        )

    return mock.patch.multiple(
        distutils.msvc9compiler.Reg,
        read_keys=read_keys, read_values=read_values)


class TestModulePatch:
    """
    Ensure that importing setuptools is sufficient to replace
    the standard find_vcvarsall function with a version that
    recognizes the "Visual C++ for Python" package.
    """

    key_32 = r'software\microsoft\devdiv\vcforpython\9.0\installdir'
    key_64 = key_32.replace(r'\microsoft', r'\wow6432node\microsoft')

    def test_patched(self):
        "Test the module is actually patched"
        mod_name = distutils.msvc9compiler.find_vcvarsall.__module__
        assert mod_name == "setuptools.msvc", "find_vcvarsall unpatched"

    def test_no_registry_entries_means_nothing_found(self):
        """
        No registry entries or environment variable should lead to an error
        directing the user to download vcpython27.
        """
        find_vcvarsall = distutils.msvc9compiler.find_vcvarsall
        query_vcvarsall = distutils.msvc9compiler.query_vcvarsall

        with contexts.environment(VS90COMNTOOLS=None):
            with mock_reg():
                assert find_vcvarsall(9.0) is None

                try:
                    query_vcvarsall(9.0)
                except Exception as exc:
                    expected = distutils.errors.DistutilsPlatformError
                    assert isinstance(exc, expected)
                    assert 'aka.ms/vcpython27' in str(exc)

    @pytest.fixture
    def user_preferred_setting(self):
        """
        Set up environment with different install dirs for user vs. system
        and yield the user_install_dir for the expected result.
        """
        with self.mock_install_dir() as user_install_dir:
            with self.mock_install_dir() as system_install_dir:
                reg = mock_reg(
                    hkcu={
                        self.key_32: user_install_dir,
                    },
                    hklm={
                        self.key_32: system_install_dir,
                        self.key_64: system_install_dir,
                    },
                )
                with reg:
                    yield user_install_dir

    def test_prefer_current_user(self, user_preferred_setting):
        """
        Ensure user's settings are preferred.
        """
        result = distutils.msvc9compiler.find_vcvarsall(9.0)
        expected = os.path.join(user_preferred_setting, 'vcvarsall.bat')
        assert expected == result

    @pytest.fixture
    def local_machine_setting(self):
        """
        Set up environment with only the system environment configured.
        """
        with self.mock_install_dir() as system_install_dir:
            reg = mock_reg(
                hklm={
                    self.key_32: system_install_dir,
                },
            )
            with reg:
                yield system_install_dir

    def test_local_machine_recognized(self, local_machine_setting):
        """
        Ensure machine setting is honored if user settings are not present.
        """
        result = distutils.msvc9compiler.find_vcvarsall(9.0)
        expected = os.path.join(local_machine_setting, 'vcvarsall.bat')
        assert expected == result

    @pytest.fixture
    def x64_preferred_setting(self):
        """
        Set up environment with 64-bit and 32-bit system settings configured
        and yield the canonical location.
        """
        with self.mock_install_dir() as x32_dir:
            with self.mock_install_dir() as x64_dir:
                reg = mock_reg(
                    hklm={
                        # This *should* only exist on 32-bit machines
                        self.key_32: x32_dir,
                        # This *should* only exist on 64-bit machines
                        self.key_64: x64_dir,
                    },
                )
                with reg:
                    yield x32_dir

    def test_ensure_64_bit_preferred(self, x64_preferred_setting):
        """
        Ensure 64-bit system key is preferred.
        """
        result = distutils.msvc9compiler.find_vcvarsall(9.0)
        expected = os.path.join(x64_preferred_setting, 'vcvarsall.bat')
        assert expected == result

    @staticmethod
    @contextlib.contextmanager
    def mock_install_dir():
        """
        Make a mock install dir in a unique location so that tests can
        distinguish which dir was detected in a given scenario.
        """
        with contexts.tempdir() as result:
            vcvarsall = os.path.join(result, 'vcvarsall.bat')
            with open(vcvarsall, 'w'):
                pass
            yield result
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_msvc14.py0000644000175100001710000000541100000000000021506 0ustar00runnerdocker# -*- coding: utf-8 -*-
"""
Tests for msvc support module (msvc14 unit tests).
"""

import os
from distutils.errors import DistutilsPlatformError
import pytest
import sys


@pytest.mark.skipif(sys.platform != "win32",
                    reason="These tests are only for win32")
class TestMSVC14:
    """Python 3.8 "distutils/tests/test_msvccompiler.py" backport"""
    def test_no_compiler(self):
        import setuptools.msvc as _msvccompiler
        # makes sure query_vcvarsall raises
        # a DistutilsPlatformError if the compiler
        # is not found

        def _find_vcvarsall(plat_spec):
            return None, None

        old_find_vcvarsall = _msvccompiler._msvc14_find_vcvarsall
        _msvccompiler._msvc14_find_vcvarsall = _find_vcvarsall
        try:
            pytest.raises(DistutilsPlatformError,
                          _msvccompiler._msvc14_get_vc_env,
                          'wont find this version')
        finally:
            _msvccompiler._msvc14_find_vcvarsall = old_find_vcvarsall

    def test_get_vc_env_unicode(self):
        import setuptools.msvc as _msvccompiler

        test_var = 'ṰḖṤṪ┅ṼẨṜ'
        test_value = '₃â´â‚…'

        # Ensure we don't early exit from _get_vc_env
        old_distutils_use_sdk = os.environ.pop('DISTUTILS_USE_SDK', None)
        os.environ[test_var] = test_value
        try:
            env = _msvccompiler._msvc14_get_vc_env('x86')
            assert test_var.lower() in env
            assert test_value == env[test_var.lower()]
        finally:
            os.environ.pop(test_var)
            if old_distutils_use_sdk:
                os.environ['DISTUTILS_USE_SDK'] = old_distutils_use_sdk

    def test_get_vc2017(self):
        import setuptools.msvc as _msvccompiler

        # This function cannot be mocked, so pass it if we find VS 2017
        # and mark it skipped if we do not.
        version, path = _msvccompiler._msvc14_find_vc2017()
        if os.environ.get('APPVEYOR_BUILD_WORKER_IMAGE', '') in [
            'Visual Studio 2017'
        ]:
            assert version
        if version:
            assert version >= 15
            assert os.path.isdir(path)
        else:
            pytest.skip("VS 2017 is not installed")

    def test_get_vc2015(self):
        import setuptools.msvc as _msvccompiler

        # This function cannot be mocked, so pass it if we find VS 2015
        # and mark it skipped if we do not.
        version, path = _msvccompiler._msvc14_find_vc2015()
        if os.environ.get('APPVEYOR_BUILD_WORKER_IMAGE', '') in [
            'Visual Studio 2015', 'Visual Studio 2017'
        ]:
            assert version
        if version:
            assert version >= 14
            assert os.path.isdir(path)
        else:
            pytest.skip("VS 2015 is not installed")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_namespaces.py0000644000175100001710000001073400000000000022514 0ustar00runnerdockerimport sys
import subprocess

import pytest

from . import namespaces
from setuptools.command import test


class TestNamespaces:

    @pytest.mark.skipif(
        sys.version_info < (3, 5),
        reason="Requires importlib.util.module_from_spec",
    )
    def test_mixed_site_and_non_site(self, tmpdir):
        """
        Installing two packages sharing the same namespace, one installed
        to a site dir and the other installed just to a path on PYTHONPATH
        should leave the namespace in tact and both packages reachable by
        import.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
        site_packages = tmpdir / 'site-packages'
        path_packages = tmpdir / 'path-packages'
        targets = site_packages, path_packages
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_A),
            '-t', str(site_packages),
        ]
        subprocess.check_call(install_cmd)
        namespaces.make_site_dir(site_packages)
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_B),
            '-t', str(path_packages),
        ]
        subprocess.check_call(install_cmd)
        try_import = [
            sys.executable,
            '-c', 'import myns.pkgA; import myns.pkgB',
        ]
        with test.test.paths_on_pythonpath(map(str, targets)):
            subprocess.check_call(try_import)

    def test_pkg_resources_import(self, tmpdir):
        """
        Ensure that a namespace package doesn't break on import
        of pkg_resources.
        """
        pkg = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        target = tmpdir / 'packages'
        target.mkdir()
        install_cmd = [
            sys.executable,
            '-m', 'pip',
            'install',
            '-t', str(target),
            str(pkg),
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(install_cmd)
        namespaces.make_site_dir(target)
        try_import = [
            sys.executable,
            '-c', 'import pkg_resources',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(try_import)

    def test_namespace_package_installed_and_cwd(self, tmpdir):
        """
        Installing a namespace packages but also having it in the current
        working directory, only one version should take precedence.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        target = tmpdir / 'packages'
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_A),
            '-t', str(target),
        ]
        subprocess.check_call(install_cmd)
        namespaces.make_site_dir(target)

        # ensure that package imports and pkg_resources imports
        pkg_resources_imp = [
            sys.executable,
            '-c', 'import pkg_resources; import myns.pkgA',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(pkg_resources_imp, cwd=str(pkg_A))

    def test_packages_in_the_same_namespace_installed_and_cwd(self, tmpdir):
        """
        Installing one namespace package and also have another in the same
        namespace in the current working directory, both of them must be
        importable.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
        target = tmpdir / 'packages'
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_A),
            '-t', str(target),
        ]
        subprocess.check_call(install_cmd)
        namespaces.make_site_dir(target)

        # ensure that all packages import and pkg_resources imports
        pkg_resources_imp = [
            sys.executable,
            '-c', 'import pkg_resources; import myns.pkgA; import myns.pkgB',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(pkg_resources_imp, cwd=str(pkg_B))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_packageindex.py0000644000175100001710000002356600000000000023027 0ustar00runnerdockerimport sys
import os
import distutils.errors
import platform
import urllib.request
import urllib.error
import http.client

import mock
import pytest

import setuptools.package_index
from .textwrap import DALS


class TestPackageIndex:
    def test_regex(self):
        hash_url = 'http://other_url?:action=show_md5&'
        hash_url += 'digest=0123456789abcdef0123456789abcdef'
        doc = """
            Name
            (md5)
        """.lstrip().format(**locals())
        assert setuptools.package_index.PYPI_MD5.match(doc)

    def test_bad_url_bad_port(self):
        index = setuptools.package_index.PackageIndex()
        url = 'http://127.0.0.1:0/nonesuch/test_package_index'
        try:
            v = index.open_url(url)
        except Exception as v:
            assert url in str(v)
        else:
            assert isinstance(v, urllib.error.HTTPError)

    def test_bad_url_typo(self):
        # issue 16
        # easy_install inquant.contentmirror.plone breaks because of a typo
        # in its home URL
        index = setuptools.package_index.PackageIndex(
            hosts=('www.example.com',)
        )

        url = (
            'url:%20https://svn.plone.org/svn'
            '/collective/inquant.contentmirror.plone/trunk'
        )
        try:
            v = index.open_url(url)
        except Exception as v:
            assert url in str(v)
        else:
            assert isinstance(v, urllib.error.HTTPError)

    def test_bad_url_bad_status_line(self):
        index = setuptools.package_index.PackageIndex(
            hosts=('www.example.com',)
        )

        def _urlopen(*args):
            raise http.client.BadStatusLine('line')

        index.opener = _urlopen
        url = 'http://example.com'
        try:
            index.open_url(url)
        except Exception as exc:
            assert 'line' in str(exc)
        else:
            raise AssertionError('Should have raise here!')

    def test_bad_url_double_scheme(self):
        """
        A bad URL with a double scheme should raise a DistutilsError.
        """
        index = setuptools.package_index.PackageIndex(
            hosts=('www.example.com',)
        )

        # issue 20
        url = 'http://http://svn.pythonpaste.org/Paste/wphp/trunk'
        try:
            index.open_url(url)
        except distutils.errors.DistutilsError as error:
            msg = str(error)
            assert (
                'nonnumeric port' in msg
                or 'getaddrinfo failed' in msg
                or 'Name or service not known' in msg
            )
            return
        raise RuntimeError("Did not raise")

    def test_bad_url_screwy_href(self):
        index = setuptools.package_index.PackageIndex(
            hosts=('www.example.com',)
        )

        # issue #160
        if sys.version_info[0] == 2 and sys.version_info[1] == 7:
            # this should not fail
            url = 'http://example.com'
            page = ('')
            index.process_index(url, page)

    def test_url_ok(self):
        index = setuptools.package_index.PackageIndex(
            hosts=('www.example.com',)
        )
        url = 'file:///tmp/test_package_index'
        assert index.url_ok(url, True)

    def test_parse_bdist_wininst(self):
        parse = setuptools.package_index.parse_bdist_wininst

        actual = parse('reportlab-2.5.win32-py2.4.exe')
        expected = 'reportlab-2.5', '2.4', 'win32'
        assert actual == expected

        actual = parse('reportlab-2.5.win32.exe')
        expected = 'reportlab-2.5', None, 'win32'
        assert actual == expected

        actual = parse('reportlab-2.5.win-amd64-py2.7.exe')
        expected = 'reportlab-2.5', '2.7', 'win-amd64'
        assert actual == expected

        actual = parse('reportlab-2.5.win-amd64.exe')
        expected = 'reportlab-2.5', None, 'win-amd64'
        assert actual == expected

    def test__vcs_split_rev_from_url(self):
        """
        Test the basic usage of _vcs_split_rev_from_url
        """
        vsrfu = setuptools.package_index.PackageIndex._vcs_split_rev_from_url
        url, rev = vsrfu('https://example.com/bar@2995')
        assert url == 'https://example.com/bar'
        assert rev == '2995'

    def test_local_index(self, tmpdir):
        """
        local_open should be able to read an index from the file system.
        """
        index_file = tmpdir / 'index.html'
        with index_file.open('w') as f:
            f.write('
content
')
        url = 'file:' + urllib.request.pathname2url(str(tmpdir)) + '/'
        res = setuptools.package_index.local_open(url)
        assert 'content' in res.read()

    def test_egg_fragment(self):
        """
        EGG fragments must comply to PEP 440
        """
        epoch = [
            '',
            '1!',
        ]
        releases = [
            '0',
            '0.0',
            '0.0.0',
        ]
        pre = [
            'a0',
            'b0',
            'rc0',
        ]
        post = [
            '.post0'
        ]
        dev = [
            '.dev0',
        ]
        local = [
            ('', ''),
            ('+ubuntu.0', '+ubuntu.0'),
            ('+ubuntu-0', '+ubuntu.0'),
            ('+ubuntu_0', '+ubuntu.0'),
        ]
        versions = [
            [''.join([e, r, p, loc]) for loc in locs]
            for e in epoch
            for r in releases
            for p in sum([pre, post, dev], [''])
            for locs in local]
        for v, vc in versions:
            dists = list(setuptools.package_index.distros_for_url(
                'http://example.com/example.zip#egg=example-' + v))
            assert dists[0].version == ''
            assert dists[1].version == vc

    def test_download_git_with_rev(self, tmpdir):
        url = 'git+https://github.example/group/project@master#egg=foo'
        index = setuptools.package_index.PackageIndex()

        with mock.patch("os.system") as os_system_mock:
            result = index.download(url, str(tmpdir))

        os_system_mock.assert_called()

        expected_dir = str(tmpdir / 'project@master')
        expected = (
            'git clone --quiet '
            'https://github.example/group/project {expected_dir}'
        ).format(**locals())
        first_call_args = os_system_mock.call_args_list[0][0]
        assert first_call_args == (expected,)

        tmpl = 'git -C {expected_dir} checkout --quiet master'
        expected = tmpl.format(**locals())
        assert os_system_mock.call_args_list[1][0] == (expected,)
        assert result == expected_dir

    def test_download_git_no_rev(self, tmpdir):
        url = 'git+https://github.example/group/project#egg=foo'
        index = setuptools.package_index.PackageIndex()

        with mock.patch("os.system") as os_system_mock:
            result = index.download(url, str(tmpdir))

        os_system_mock.assert_called()

        expected_dir = str(tmpdir / 'project')
        expected = (
            'git clone --quiet '
            'https://github.example/group/project {expected_dir}'
        ).format(**locals())
        os_system_mock.assert_called_once_with(expected)

    def test_download_svn(self, tmpdir):
        url = 'svn+https://svn.example/project#egg=foo'
        index = setuptools.package_index.PackageIndex()

        with pytest.warns(UserWarning):
            with mock.patch("os.system") as os_system_mock:
                result = index.download(url, str(tmpdir))

        os_system_mock.assert_called()

        expected_dir = str(tmpdir / 'project')
        expected = (
            'svn checkout -q '
            'svn+https://svn.example/project {expected_dir}'
        ).format(**locals())
        os_system_mock.assert_called_once_with(expected)


class TestContentCheckers:
    def test_md5(self):
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478')
        checker.feed('You should probably not be using MD5'.encode('ascii'))
        assert checker.hash.hexdigest() == 'f12895fdffbd45007040d2e44df98478'
        assert checker.is_valid()

    def test_other_fragment(self):
        "Content checks should succeed silently if no hash is present"
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#something%20completely%20different')
        checker.feed('anything'.encode('ascii'))
        assert checker.is_valid()

    def test_blank_md5(self):
        "Content checks should succeed if a hash is empty"
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#md5=')
        checker.feed('anything'.encode('ascii'))
        assert checker.is_valid()

    def test_get_hash_name_md5(self):
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478')
        assert checker.hash_name == 'md5'

    def test_report(self):
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478')
        rep = checker.report(lambda x: x, 'My message about %s')
        assert rep == 'My message about md5'


@pytest.fixture
def temp_home(tmpdir, monkeypatch):
    key = (
        'USERPROFILE'
        if platform.system() == 'Windows' and sys.version_info > (3, 8) else
        'HOME'
    )

    monkeypatch.setitem(os.environ, key, str(tmpdir))
    return tmpdir


class TestPyPIConfig:
    def test_percent_in_password(self, temp_home):
        pypirc = temp_home / '.pypirc'
        pypirc.write(DALS("""
            [pypi]
            repository=https://pypi.org
            username=jaraco
            password=pity%
        """))
        cfg = setuptools.package_index.PyPIConfig()
        cred = cfg.creds_by_repository['https://pypi.org']
        assert cred.username == 'jaraco'
        assert cred.password == 'pity%'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_register.py0000644000175100001710000000106200000000000022213 0ustar00runnerdockerfrom setuptools.command.register import register
from setuptools.dist import Distribution
from setuptools.errors import RemovedCommandError

try:
    from unittest import mock
except ImportError:
    import mock

import pytest


class TestRegister:
    def test_register_exception(self):
        """Ensure that the register command has been properly removed."""
        dist = Distribution()
        dist.dist_files = [(mock.Mock(), mock.Mock(), mock.Mock())]

        cmd = register(dist)

        with pytest.raises(RemovedCommandError):
            cmd.run()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_sandbox.py0000644000175100001710000001023100000000000022023 0ustar00runnerdocker"""develop tests
"""
import os
import types

import pytest

import pkg_resources
import setuptools.sandbox


class TestSandbox:
    def test_devnull(self, tmpdir):
        with setuptools.sandbox.DirectorySandbox(str(tmpdir)):
            self._file_writer(os.devnull)

    @staticmethod
    def _file_writer(path):
        def do_write():
            with open(path, 'w') as f:
                f.write('xxx')

        return do_write

    def test_setup_py_with_BOM(self):
        """
        It should be possible to execute a setup.py with a Byte Order Mark
        """
        target = pkg_resources.resource_filename(
            __name__,
            'script-with-bom.py')
        namespace = types.ModuleType('namespace')
        setuptools.sandbox._execfile(target, vars(namespace))
        assert namespace.result == 'passed'

    def test_setup_py_with_CRLF(self, tmpdir):
        setup_py = tmpdir / 'setup.py'
        with setup_py.open('wb') as stream:
            stream.write(b'"degenerate script"\r\n')
        setuptools.sandbox._execfile(str(setup_py), globals())


class TestExceptionSaver:
    def test_exception_trapped(self):
        with setuptools.sandbox.ExceptionSaver():
            raise ValueError("details")

    def test_exception_resumed(self):
        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            raise ValueError("details")

        with pytest.raises(ValueError) as caught:
            saved_exc.resume()

        assert isinstance(caught.value, ValueError)
        assert str(caught.value) == 'details'

    def test_exception_reconstructed(self):
        orig_exc = ValueError("details")

        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            raise orig_exc

        with pytest.raises(ValueError) as caught:
            saved_exc.resume()

        assert isinstance(caught.value, ValueError)
        assert caught.value is not orig_exc

    def test_no_exception_passes_quietly(self):
        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            pass

        saved_exc.resume()

    def test_unpickleable_exception(self):
        class CantPickleThis(Exception):
            "This Exception is unpickleable because it's not in globals"
            def __repr__(self):
                return 'CantPickleThis%r' % (self.args,)

        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            raise CantPickleThis('detail')

        with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
            saved_exc.resume()

        assert str(caught.value) == "CantPickleThis('detail',)"

    def test_unpickleable_exception_when_hiding_setuptools(self):
        """
        As revealed in #440, an infinite recursion can occur if an unpickleable
        exception while setuptools is hidden. Ensure this doesn't happen.
        """

        class ExceptionUnderTest(Exception):
            """
            An unpickleable exception (not in globals).
            """

        with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
            with setuptools.sandbox.save_modules():
                setuptools.sandbox.hide_setuptools()
                raise ExceptionUnderTest()

        msg, = caught.value.args
        assert msg == 'ExceptionUnderTest()'

    def test_sandbox_violation_raised_hiding_setuptools(self, tmpdir):
        """
        When in a sandbox with setuptools hidden, a SandboxViolation
        should reflect a proper exception and not be wrapped in
        an UnpickleableException.
        """

        def write_file():
            "Trigger a SandboxViolation by writing outside the sandbox"
            with open('/etc/foo', 'w'):
                pass

        with pytest.raises(setuptools.sandbox.SandboxViolation) as caught:
            with setuptools.sandbox.save_modules():
                setuptools.sandbox.hide_setuptools()
                with setuptools.sandbox.DirectorySandbox(str(tmpdir)):
                    write_file()

        cmd, args, kwargs = caught.value.args
        assert cmd == 'open'
        assert args == ('/etc/foo', 'w')
        assert kwargs == {}

        msg = str(caught.value)
        assert 'open' in msg
        assert "('/etc/foo', 'w')" in msg
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_sdist.py0000644000175100001710000004041300000000000021520 0ustar00runnerdocker"""sdist tests"""

import os
import sys
import tempfile
import unicodedata
import contextlib
import io
from unittest import mock

import pytest

import pkg_resources
from setuptools import SetuptoolsDeprecationWarning
from setuptools.command.sdist import sdist
from setuptools.command.egg_info import manifest_maker
from setuptools.dist import Distribution
from setuptools.tests import fail_on_ascii
from .text import Filenames


SETUP_ATTRS = {
    'name': 'sdist_test',
    'version': '0.0',
    'packages': ['sdist_test'],
    'package_data': {'sdist_test': ['*.txt']},
    'data_files': [("data", [os.path.join("d", "e.dat")])],
}

SETUP_PY = """\
from setuptools import setup

setup(**%r)
""" % SETUP_ATTRS


@contextlib.contextmanager
def quiet():
    old_stdout, old_stderr = sys.stdout, sys.stderr
    sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
    try:
        yield
    finally:
        sys.stdout, sys.stderr = old_stdout, old_stderr


# Convert to POSIX path
def posix(path):
    if not isinstance(path, str):
        return path.replace(os.sep.encode('ascii'), b'/')
    else:
        return path.replace(os.sep, '/')


# HFS Plus uses decomposed UTF-8
def decompose(path):
    if isinstance(path, str):
        return unicodedata.normalize('NFD', path)
    try:
        path = path.decode('utf-8')
        path = unicodedata.normalize('NFD', path)
        path = path.encode('utf-8')
    except UnicodeError:
        pass  # Not UTF-8
    return path


def read_all_bytes(filename):
    with io.open(filename, 'rb') as fp:
        return fp.read()


def latin1_fail():
    try:
        desc, filename = tempfile.mkstemp(suffix=Filenames.latin_1)
        os.close(desc)
        os.remove(filename)
    except Exception:
        return True


fail_on_latin1_encoded_filenames = pytest.mark.xfail(
    latin1_fail(),
    reason="System does not support latin-1 filenames",
)


def touch(path):
    path.write_text('', encoding='utf-8')


class TestSdistTest:
    @pytest.fixture(autouse=True)
    def source_dir(self, tmpdir):
        (tmpdir / 'setup.py').write_text(SETUP_PY, encoding='utf-8')

        # Set up the rest of the test package
        test_pkg = tmpdir / 'sdist_test'
        test_pkg.mkdir()
        data_folder = tmpdir / 'd'
        data_folder.mkdir()
        # *.rst was not included in package_data, so c.rst should not be
        # automatically added to the manifest when not under version control
        for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']:
            touch(test_pkg / fname)
        touch(data_folder / 'e.dat')

        with tmpdir.as_cwd():
            yield

    def assert_package_data_in_manifest(self, cmd):
        manifest = cmd.filelist.files
        assert os.path.join('sdist_test', 'a.txt') in manifest
        assert os.path.join('sdist_test', 'b.txt') in manifest
        assert os.path.join('sdist_test', 'c.rst') not in manifest
        assert os.path.join('d', 'e.dat') in manifest

    def test_package_data_in_sdist(self):
        """Regression test for pull request #4: ensures that files listed in
        package_data are included in the manifest even if they're not added to
        version control.
        """

        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        self.assert_package_data_in_manifest(cmd)

    def test_package_data_and_include_package_data_in_sdist(self):
        """
        Ensure package_data and include_package_data work
        together.
        """
        setup_attrs = {**SETUP_ATTRS, 'include_package_data': True}
        assert setup_attrs['package_data']

        dist = Distribution(setup_attrs)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        self.assert_package_data_in_manifest(cmd)

    def test_custom_build_py(self):
        """
        Ensure projects defining custom build_py don't break
        when creating sdists (issue #2849)
        """
        from distutils.command.build_py import build_py as OrigBuildPy

        using_custom_command_guard = mock.Mock()

        class CustomBuildPy(OrigBuildPy):
            """
            Some projects have custom commands inheriting from `distutils`
            """

            def get_data_files(self):
                using_custom_command_guard()
                return super().get_data_files()

        setup_attrs = {**SETUP_ATTRS, 'include_package_data': True}
        assert setup_attrs['package_data']

        dist = Distribution(setup_attrs)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Make sure we use the custom command
        cmd.cmdclass = {'build_py': CustomBuildPy}
        cmd.distribution.cmdclass = {'build_py': CustomBuildPy}
        assert cmd.distribution.get_command_class('build_py') == CustomBuildPy

        msg = "setuptools instead of distutils"
        with quiet(), pytest.warns(SetuptoolsDeprecationWarning, match=msg):
            cmd.run()

        using_custom_command_guard.assert_called()
        self.assert_package_data_in_manifest(cmd)

    def test_setup_py_exists(self):
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'foo.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        manifest = cmd.filelist.files
        assert 'setup.py' in manifest

    def test_setup_py_missing(self):
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'foo.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        if os.path.exists("setup.py"):
            os.remove("setup.py")
        with quiet():
            cmd.run()

        manifest = cmd.filelist.files
        assert 'setup.py' not in manifest

    def test_setup_py_excluded(self):
        with open("MANIFEST.in", "w") as manifest_file:
            manifest_file.write("exclude setup.py")

        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'foo.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        manifest = cmd.filelist.files
        assert 'setup.py' not in manifest

    def test_defaults_case_sensitivity(self, tmpdir):
        """
        Make sure default files (README.*, etc.) are added in a case-sensitive
        way to avoid problems with packages built on Windows.
        """

        touch(tmpdir / 'readme.rst')
        touch(tmpdir / 'SETUP.cfg')

        dist = Distribution(SETUP_ATTRS)
        # the extension deliberately capitalized for this test
        # to make sure the actual filename (not capitalized) gets added
        # to the manifest
        dist.script_name = 'setup.PY'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        # lowercase all names so we can test in a
        # case-insensitive way to make sure the files
        # are not included.
        manifest = map(lambda x: x.lower(), cmd.filelist.files)
        assert 'readme.rst' not in manifest, manifest
        assert 'setup.py' not in manifest, manifest
        assert 'setup.cfg' not in manifest, manifest

    @fail_on_ascii
    def test_manifest_is_written_with_utf8_encoding(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        mm = manifest_maker(dist)
        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        os.mkdir('sdist_test.egg-info')

        # UTF-8 filename
        filename = os.path.join('sdist_test', 'smörbröd.py')

        # Must create the file or it will get stripped.
        open(filename, 'w').close()

        # Add UTF-8 filename and write manifest
        with quiet():
            mm.run()
            mm.filelist.append(filename)
            mm.write_manifest()

        contents = read_all_bytes(mm.manifest)

        # The manifest should be UTF-8 encoded
        u_contents = contents.decode('UTF-8')

        # The manifest should contain the UTF-8 filename
        assert posix(filename) in u_contents

    @fail_on_ascii
    def test_write_manifest_allows_utf8_filenames(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        mm = manifest_maker(dist)
        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        os.mkdir('sdist_test.egg-info')

        filename = os.path.join(b'sdist_test', Filenames.utf_8)

        # Must touch the file or risk removal
        open(filename, "w").close()

        # Add filename and write manifest
        with quiet():
            mm.run()
            u_filename = filename.decode('utf-8')
            mm.filelist.files.append(u_filename)
            # Re-write manifest
            mm.write_manifest()

        contents = read_all_bytes(mm.manifest)

        # The manifest should be UTF-8 encoded
        contents.decode('UTF-8')

        # The manifest should contain the UTF-8 filename
        assert posix(filename) in contents

        # The filelist should have been updated as well
        assert u_filename in mm.filelist.files

    def test_write_manifest_skips_non_utf8_filenames(self):
        """
        Files that cannot be encoded to UTF-8 (specifically, those that
        weren't originally successfully decoded and have surrogate
        escapes) should be omitted from the manifest.
        See https://bitbucket.org/tarek/distribute/issue/303 for history.
        """
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        mm = manifest_maker(dist)
        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        os.mkdir('sdist_test.egg-info')

        # Latin-1 filename
        filename = os.path.join(b'sdist_test', Filenames.latin_1)

        # Add filename with surrogates and write manifest
        with quiet():
            mm.run()
            u_filename = filename.decode('utf-8', 'surrogateescape')
            mm.filelist.append(u_filename)
            # Re-write manifest
            mm.write_manifest()

        contents = read_all_bytes(mm.manifest)

        # The manifest should be UTF-8 encoded
        contents.decode('UTF-8')

        # The Latin-1 filename should have been skipped
        assert posix(filename) not in contents

        # The filelist should have been updated as well
        assert u_filename not in mm.filelist.files

    @fail_on_ascii
    def test_manifest_is_read_with_utf8_encoding(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Create manifest
        with quiet():
            cmd.run()

        # Add UTF-8 filename to manifest
        filename = os.path.join(b'sdist_test', Filenames.utf_8)
        cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        manifest = open(cmd.manifest, 'ab')
        manifest.write(b'\n' + filename)
        manifest.close()

        # The file must exist to be included in the filelist
        open(filename, 'w').close()

        # Re-read manifest
        cmd.filelist.files = []
        with quiet():
            cmd.read_manifest()

        # The filelist should contain the UTF-8 filename
        filename = filename.decode('utf-8')
        assert filename in cmd.filelist.files

    @fail_on_latin1_encoded_filenames
    def test_read_manifest_skips_non_utf8_filenames(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Create manifest
        with quiet():
            cmd.run()

        # Add Latin-1 filename to manifest
        filename = os.path.join(b'sdist_test', Filenames.latin_1)
        cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        manifest = open(cmd.manifest, 'ab')
        manifest.write(b'\n' + filename)
        manifest.close()

        # The file must exist to be included in the filelist
        open(filename, 'w').close()

        # Re-read manifest
        cmd.filelist.files = []
        with quiet():
            cmd.read_manifest()

        # The Latin-1 filename should have been skipped
        filename = filename.decode('latin-1')
        assert filename not in cmd.filelist.files

    @fail_on_ascii
    @fail_on_latin1_encoded_filenames
    def test_sdist_with_utf8_encoded_filename(self):
        # Test for #303.
        dist = Distribution(self.make_strings(SETUP_ATTRS))
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        filename = os.path.join(b'sdist_test', Filenames.utf_8)
        open(filename, 'w').close()

        with quiet():
            cmd.run()

        if sys.platform == 'darwin':
            filename = decompose(filename)

        fs_enc = sys.getfilesystemencoding()

        if sys.platform == 'win32':
            if fs_enc == 'cp1252':
                # Python mangles the UTF-8 filename
                filename = filename.decode('cp1252')
                assert filename in cmd.filelist.files
            else:
                filename = filename.decode('mbcs')
                assert filename in cmd.filelist.files
        else:
            filename = filename.decode('utf-8')
            assert filename in cmd.filelist.files

    @classmethod
    def make_strings(cls, item):
        if isinstance(item, dict):
            return {
                key: cls.make_strings(value) for key, value in item.items()}
        if isinstance(item, list):
            return list(map(cls.make_strings, item))
        return str(item)

    @fail_on_latin1_encoded_filenames
    def test_sdist_with_latin1_encoded_filename(self):
        # Test for #303.
        dist = Distribution(self.make_strings(SETUP_ATTRS))
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Latin-1 filename
        filename = os.path.join(b'sdist_test', Filenames.latin_1)
        open(filename, 'w').close()
        assert os.path.isfile(filename)

        with quiet():
            cmd.run()

        # not all windows systems have a default FS encoding of cp1252
        if sys.platform == 'win32':
            # Latin-1 is similar to Windows-1252 however
            # on mbcs filesys it is not in latin-1 encoding
            fs_enc = sys.getfilesystemencoding()
            if fs_enc != 'mbcs':
                fs_enc = 'latin-1'
            filename = filename.decode(fs_enc)

            assert filename in cmd.filelist.files
        else:
            # The Latin-1 filename should have been skipped
            filename = filename.decode('latin-1')
            filename not in cmd.filelist.files

    def test_pyproject_toml_in_sdist(self, tmpdir):
        """
        Check if pyproject.toml is included in source distribution if present
        """
        touch(tmpdir / 'pyproject.toml')
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()
        with quiet():
            cmd.run()
        manifest = cmd.filelist.files
        assert 'pyproject.toml' in manifest

    def test_pyproject_toml_excluded(self, tmpdir):
        """
        Check that pyproject.toml can excluded even if present
        """
        touch(tmpdir / 'pyproject.toml')
        with open('MANIFEST.in', 'w') as mts:
            print('exclude pyproject.toml', file=mts)
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()
        with quiet():
            cmd.run()
        manifest = cmd.filelist.files
        assert 'pyproject.toml' not in manifest


def test_default_revctrl():
    """
    When _default_revctrl was removed from the `setuptools.command.sdist`
    module in 10.0, it broke some systems which keep an old install of
    setuptools (Distribute) around. Those old versions require that the
    setuptools package continue to implement that interface, so this
    function provides that interface, stubbed. See #320 for details.

    This interface must be maintained until Ubuntu 12.04 is no longer
    supported (by Setuptools).
    """
    ep_def = 'svn_cvs = setuptools.command.sdist:_default_revctrl'
    ep = pkg_resources.EntryPoint.parse(ep_def)
    res = ep.resolve()
    assert hasattr(res, '__iter__')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_setopt.py0000644000175100001710000000254500000000000021714 0ustar00runnerdockerimport io
import configparser

from setuptools.command import setopt


class TestEdit:
    @staticmethod
    def parse_config(filename):
        parser = configparser.ConfigParser()
        with io.open(filename, encoding='utf-8') as reader:
            parser.read_file(reader)
        return parser

    @staticmethod
    def write_text(file, content):
        with io.open(file, 'wb') as strm:
            strm.write(content.encode('utf-8'))

    def test_utf8_encoding_retained(self, tmpdir):
        """
        When editing a file, non-ASCII characters encoded in
        UTF-8 should be retained.
        """
        config = tmpdir.join('setup.cfg')
        self.write_text(str(config), '[names]\njaraco=джарако')
        setopt.edit_config(str(config), dict(names=dict(other='yes')))
        parser = self.parse_config(str(config))
        assert parser.get('names', 'jaraco') == 'джарако'
        assert parser.get('names', 'other') == 'yes'

    def test_case_retained(self, tmpdir):
        """
        When editing a file, case of keys should be retained.
        """
        config = tmpdir.join('setup.cfg')
        self.write_text(str(config), '[names]\nFoO=bAr')
        setopt.edit_config(str(config), dict(names=dict(oTher='yes')))
        actual = config.read_text(encoding='ascii')
        assert 'FoO' in actual
        assert 'oTher' in actual
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_setuptools.py0000644000175100001710000002212300000000000022611 0ustar00runnerdocker"""Tests for the 'setuptools' package"""

import sys
import os
import distutils.core
import distutils.cmd
from distutils.errors import DistutilsOptionError
from distutils.errors import DistutilsSetupError
from distutils.core import Extension

import pytest

from setuptools.extern.packaging import version

import setuptools
import setuptools.dist
import setuptools.depends as dep
from setuptools.depends import Require


def makeSetup(**args):
    """Return distribution from 'setup(**args)', without executing commands"""

    distutils.core._setup_stop_after = "commandline"

    # Don't let system command line leak into tests!
    args.setdefault('script_args', ['install'])

    try:
        return setuptools.setup(**args)
    finally:
        distutils.core._setup_stop_after = None


needs_bytecode = pytest.mark.skipif(
    not hasattr(dep, 'get_module_constant'),
    reason="bytecode support not available",
)


class TestDepends:
    def testExtractConst(self):
        if not hasattr(dep, 'extract_constant'):
            # skip on non-bytecode platforms
            return

        def f1():
            global x, y, z
            x = "test"
            y = z

        fc = f1.__code__

        # unrecognized name
        assert dep.extract_constant(fc, 'q', -1) is None

        # constant assigned
        dep.extract_constant(fc, 'x', -1) == "test"

        # expression assigned
        dep.extract_constant(fc, 'y', -1) == -1

        # recognized name, not assigned
        dep.extract_constant(fc, 'z', -1) is None

    def testFindModule(self):
        with pytest.raises(ImportError):
            dep.find_module('no-such.-thing')
        with pytest.raises(ImportError):
            dep.find_module('setuptools.non-existent')
        f, p, i = dep.find_module('setuptools.tests')
        f.close()

    @needs_bytecode
    def testModuleExtract(self):
        from json import __version__
        assert dep.get_module_constant('json', '__version__') == __version__
        assert dep.get_module_constant('sys', 'version') == sys.version
        assert dep.get_module_constant(
            'setuptools.tests.test_setuptools', '__doc__') == __doc__

    @needs_bytecode
    def testRequire(self):
        req = Require('Json', '1.0.3', 'json')

        assert req.name == 'Json'
        assert req.module == 'json'
        assert req.requested_version == version.Version('1.0.3')
        assert req.attribute == '__version__'
        assert req.full_name() == 'Json-1.0.3'

        from json import __version__
        assert str(req.get_version()) == __version__
        assert req.version_ok('1.0.9')
        assert not req.version_ok('0.9.1')
        assert not req.version_ok('unknown')

        assert req.is_present()
        assert req.is_current()

        req = Require('Do-what-I-mean', '1.0', 'd-w-i-m')
        assert not req.is_present()
        assert not req.is_current()

    @needs_bytecode
    def test_require_present(self):
        # In #1896, this test was failing for months with the only
        # complaint coming from test runners (not end users).
        # TODO: Evaluate if this code is needed at all.
        req = Require('Tests', None, 'tests', homepage="http://example.com")
        assert req.format is None
        assert req.attribute is None
        assert req.requested_version is None
        assert req.full_name() == 'Tests'
        assert req.homepage == 'http://example.com'

        from setuptools.tests import __path__
        paths = [os.path.dirname(p) for p in __path__]
        assert req.is_present(paths)
        assert req.is_current(paths)


class TestDistro:
    def setup_method(self, method):
        self.e1 = Extension('bar.ext', ['bar.c'])
        self.e2 = Extension('c.y', ['y.c'])

        self.dist = makeSetup(
            packages=['a', 'a.b', 'a.b.c', 'b', 'c'],
            py_modules=['b.d', 'x'],
            ext_modules=(self.e1, self.e2),
            package_dir={},
        )

    def testDistroType(self):
        assert isinstance(self.dist, setuptools.dist.Distribution)

    def testExcludePackage(self):
        self.dist.exclude_package('a')
        assert self.dist.packages == ['b', 'c']

        self.dist.exclude_package('b')
        assert self.dist.packages == ['c']
        assert self.dist.py_modules == ['x']
        assert self.dist.ext_modules == [self.e1, self.e2]

        self.dist.exclude_package('c')
        assert self.dist.packages == []
        assert self.dist.py_modules == ['x']
        assert self.dist.ext_modules == [self.e1]

        # test removals from unspecified options
        makeSetup().exclude_package('x')

    def testIncludeExclude(self):
        # remove an extension
        self.dist.exclude(ext_modules=[self.e1])
        assert self.dist.ext_modules == [self.e2]

        # add it back in
        self.dist.include(ext_modules=[self.e1])
        assert self.dist.ext_modules == [self.e2, self.e1]

        # should not add duplicate
        self.dist.include(ext_modules=[self.e1])
        assert self.dist.ext_modules == [self.e2, self.e1]

    def testExcludePackages(self):
        self.dist.exclude(packages=['c', 'b', 'a'])
        assert self.dist.packages == []
        assert self.dist.py_modules == ['x']
        assert self.dist.ext_modules == [self.e1]

    def testEmpty(self):
        dist = makeSetup()
        dist.include(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
        dist = makeSetup()
        dist.exclude(packages=['a'], py_modules=['b'], ext_modules=[self.e2])

    def testContents(self):
        assert self.dist.has_contents_for('a')
        self.dist.exclude_package('a')
        assert not self.dist.has_contents_for('a')

        assert self.dist.has_contents_for('b')
        self.dist.exclude_package('b')
        assert not self.dist.has_contents_for('b')

        assert self.dist.has_contents_for('c')
        self.dist.exclude_package('c')
        assert not self.dist.has_contents_for('c')

    def testInvalidIncludeExclude(self):
        with pytest.raises(DistutilsSetupError):
            self.dist.include(nonexistent_option='x')
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(nonexistent_option='x')
        with pytest.raises(DistutilsSetupError):
            self.dist.include(packages={'x': 'y'})
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(packages={'x': 'y'})
        with pytest.raises(DistutilsSetupError):
            self.dist.include(ext_modules={'x': 'y'})
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(ext_modules={'x': 'y'})

        with pytest.raises(DistutilsSetupError):
            self.dist.include(package_dir=['q'])
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(package_dir=['q'])


class TestCommandTests:
    def testTestIsCommand(self):
        test_cmd = makeSetup().get_command_obj('test')
        assert (isinstance(test_cmd, distutils.cmd.Command))

    def testLongOptSuiteWNoDefault(self):
        ts1 = makeSetup(script_args=['test', '--test-suite=foo.tests.suite'])
        ts1 = ts1.get_command_obj('test')
        ts1.ensure_finalized()
        assert ts1.test_suite == 'foo.tests.suite'

    def testDefaultSuite(self):
        ts2 = makeSetup(test_suite='bar.tests.suite').get_command_obj('test')
        ts2.ensure_finalized()
        assert ts2.test_suite == 'bar.tests.suite'

    def testDefaultWModuleOnCmdLine(self):
        ts3 = makeSetup(
            test_suite='bar.tests',
            script_args=['test', '-m', 'foo.tests']
        ).get_command_obj('test')
        ts3.ensure_finalized()
        assert ts3.test_module == 'foo.tests'
        assert ts3.test_suite == 'foo.tests.test_suite'

    def testConflictingOptions(self):
        ts4 = makeSetup(
            script_args=['test', '-m', 'bar.tests', '-s', 'foo.tests.suite']
        ).get_command_obj('test')
        with pytest.raises(DistutilsOptionError):
            ts4.ensure_finalized()

    def testNoSuite(self):
        ts5 = makeSetup().get_command_obj('test')
        ts5.ensure_finalized()
        assert ts5.test_suite is None


@pytest.fixture
def example_source(tmpdir):
    tmpdir.mkdir('foo')
    (tmpdir / 'foo/bar.py').write('')
    (tmpdir / 'readme.txt').write('')
    return tmpdir


def test_findall(example_source):
    found = list(setuptools.findall(str(example_source)))
    expected = ['readme.txt', 'foo/bar.py']
    expected = [example_source.join(fn) for fn in expected]
    assert found == expected


def test_findall_curdir(example_source):
    with example_source.as_cwd():
        found = list(setuptools.findall())
    expected = ['readme.txt', os.path.join('foo', 'bar.py')]
    assert found == expected


@pytest.fixture
def can_symlink(tmpdir):
    """
    Skip if cannot create a symbolic link
    """
    link_fn = 'link'
    target_fn = 'target'
    try:
        os.symlink(target_fn, link_fn)
    except (OSError, NotImplementedError, AttributeError):
        pytest.skip("Cannot create symbolic links")
    os.remove(link_fn)


def test_findall_missing_symlink(tmpdir, can_symlink):
    with tmpdir.as_cwd():
        os.symlink('foo', 'bar')
        found = list(setuptools.findall())
        assert found == []
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_sphinx_upload_docs.py0000644000175100001710000000164100000000000024257 0ustar00runnerdockerimport pytest

from jaraco import path

from setuptools.command.upload_docs import upload_docs
from setuptools.dist import Distribution


@pytest.fixture
def sphinx_doc_sample_project(tmpdir_cwd):
    path.build({
        'setup.py': 'from setuptools import setup; setup()',
        'build': {
            'docs': {
                'conf.py': 'project="test"',
                'index.rst': ".. toctree::\
                    :maxdepth: 2\
                    :caption: Contents:",
            },
        },
    })


@pytest.mark.usefixtures('sphinx_doc_sample_project')
class TestSphinxUploadDocs:
    def test_sphinx_doc(self):
        params = dict(
            name='foo',
            packages=['test'],
        )
        dist = Distribution(params)

        cmd = upload_docs(dist)

        cmd.initialize_options()
        assert cmd.upload_dir is None
        assert cmd.has_sphinx() is True
        cmd.finalize_options()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_test.py0000644000175100001710000000203600000000000021350 0ustar00runnerdockerimport pytest
from jaraco import path

from setuptools.command.test import test
from setuptools.dist import Distribution

from .textwrap import DALS


@pytest.mark.usefixtures('tmpdir_cwd')
def test_tests_are_run_once(capfd):
    params = dict(
        name='foo',
        packages=['dummy'],
    )
    files = {
        'setup.py':
            'from setuptools import setup; setup('
            + ','.join(f'{name}={params[name]!r}' for name in params)
            + ')',
        'dummy': {
            '__init__.py': '',
            'test_dummy.py': DALS(
                """
                import unittest
                class TestTest(unittest.TestCase):
                    def test_test(self):
                        print('Foo')
                """
                ),
            },
    }
    path.build(files)
    dist = Distribution(params)
    dist.script_name = 'setup.py'
    cmd = test(dist)
    cmd.ensure_finalized()
    cmd.run()
    out, err = capfd.readouterr()
    assert out.endswith('Foo\n')
    assert len(out.split('Foo')) == 2
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_unicode_utils.py0000644000175100001710000000047400000000000023243 0ustar00runnerdockerfrom setuptools import unicode_utils


def test_filesys_decode_fs_encoding_is_None(monkeypatch):
    """
    Test filesys_decode does not raise TypeError when
    getfilesystemencoding returns None.
    """
    monkeypatch.setattr('sys.getfilesystemencoding', lambda: None)
    unicode_utils.filesys_decode(b'test')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_upload.py0000644000175100001710000000105000000000000021650 0ustar00runnerdockerfrom setuptools.command.upload import upload
from setuptools.dist import Distribution
from setuptools.errors import RemovedCommandError

try:
    from unittest import mock
except ImportError:
    import mock

import pytest


class TestUpload:
    def test_upload_exception(self):
        """Ensure that the register command has been properly removed."""
        dist = Distribution()
        dist.dist_files = [(mock.Mock(), mock.Mock(), mock.Mock())]

        cmd = upload(dist)

        with pytest.raises(RemovedCommandError):
            cmd.run()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_upload_docs.py0000644000175100001710000000324000000000000022663 0ustar00runnerdockerimport os
import zipfile
import contextlib

import pytest
from jaraco import path

from setuptools.command.upload_docs import upload_docs
from setuptools.dist import Distribution

from .textwrap import DALS
from . import contexts


@pytest.fixture
def sample_project(tmpdir_cwd):
    path.build({
        'setup.py': DALS("""
            from setuptools import setup

            setup(name='foo')
            """),
        'build': {
            'index.html': 'Hello world.',
            'empty': {},
        }
    })


@pytest.mark.usefixtures('sample_project')
@pytest.mark.usefixtures('user_override')
class TestUploadDocsTest:
    def test_create_zipfile(self):
        """
        Ensure zipfile creation handles common cases, including a folder
        containing an empty folder.
        """

        dist = Distribution()

        cmd = upload_docs(dist)
        cmd.target_dir = cmd.upload_dir = 'build'
        with contexts.tempdir() as tmp_dir:
            tmp_file = os.path.join(tmp_dir, 'foo.zip')
            zip_file = cmd.create_zipfile(tmp_file)

            assert zipfile.is_zipfile(tmp_file)

            with contextlib.closing(zipfile.ZipFile(tmp_file)) as zip_file:
                assert zip_file.namelist() == ['index.html']

    def test_build_multipart(self):
        data = dict(
            a="foo",
            b="bar",
            file=('file.txt', b'content'),
        )
        body, content_type = upload_docs._build_multipart(data)
        assert 'form-data' in content_type
        assert "b'" not in content_type
        assert 'b"' not in content_type
        assert isinstance(body, bytes)
        assert b'foo' in body
        assert b'content' in body
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_virtualenv.py0000644000175100001710000001523500000000000022575 0ustar00runnerdockerimport glob
import os
import sys
import itertools

import pathlib

import pytest
from pytest_fixture_config import yield_requires_config

import pytest_virtualenv

from .textwrap import DALS
from .test_easy_install import make_nspkg_sdist


@pytest.fixture(autouse=True)
def pytest_virtualenv_works(virtualenv):
    """
    pytest_virtualenv may not work. if it doesn't, skip these
    tests. See #1284.
    """
    venv_prefix = virtualenv.run(
        'python -c "import sys; print(sys.prefix)"',
        capture=True,
    ).strip()
    if venv_prefix == sys.prefix:
        pytest.skip("virtualenv is broken (see pypa/setuptools#1284)")


@yield_requires_config(pytest_virtualenv.CONFIG, ['virtualenv_executable'])
@pytest.fixture(scope='function')
def bare_virtualenv():
    """ Bare virtualenv (no pip/setuptools/wheel).
    """
    with pytest_virtualenv.VirtualEnv(args=(
        '--no-wheel',
        '--no-pip',
        '--no-setuptools',
    )) as venv:
        yield venv


def test_clean_env_install(bare_virtualenv, tmp_src):
    """
    Check setuptools can be installed in a clean environment.
    """
    cmd = [bare_virtualenv.python, 'setup.py', 'install']
    bare_virtualenv.run(cmd, cd=tmp_src)


def _get_pip_versions():
    # This fixture will attempt to detect if tests are being run without
    # network connectivity and if so skip some tests

    network = True
    if not os.environ.get('NETWORK_REQUIRED', False):  # pragma: nocover
        try:
            from urllib.request import urlopen
            from urllib.error import URLError
        except ImportError:
            from urllib2 import urlopen, URLError  # Python 2.7 compat

        try:
            urlopen('https://pypi.org', timeout=1)
        except URLError:
            # No network, disable most of these tests
            network = False

    def mark(param, *marks):
        if not isinstance(param, type(pytest.param(''))):
            param = pytest.param(param)
        return param._replace(marks=param.marks + marks)

    def skip_network(param):
        return param if network else mark(param, pytest.mark.skip(reason="no network"))

    network_versions = [
        mark('pip<20', pytest.mark.xfail(reason='pypa/pip#6599')),
        'pip<20.1',
        'pip<21',
        'pip<22',
        mark(
            'https://github.com/pypa/pip/archive/main.zip',
            pytest.mark.skipif('sys.version_info < (3, 7)'),
        ),
    ]

    versions = itertools.chain(
        [None],
        map(skip_network, network_versions)
    )

    return list(versions)


@pytest.mark.skipif(
    'platform.python_implementation() == "PyPy"',
    reason="https://github.com/pypa/setuptools/pull/2865#issuecomment-965834995",
)
@pytest.mark.parametrize('pip_version', _get_pip_versions())
def test_pip_upgrade_from_source(pip_version, tmp_src, virtualenv):
    """
    Check pip can upgrade setuptools from source.
    """
    # Install pip/wheel, and remove setuptools (as it
    # should not be needed for bootstraping from source)
    if pip_version is None:
        upgrade_pip = ()
    else:
        upgrade_pip = ('python -m pip install -U "{pip_version}" --retries=1',)
    virtualenv.run(' && '.join((
        'pip uninstall -y setuptools',
        'pip install -U wheel',
    ) + upgrade_pip).format(pip_version=pip_version))
    dist_dir = virtualenv.workspace
    # Generate source distribution / wheel.
    virtualenv.run(' && '.join((
        'python setup.py -q sdist -d {dist}',
        'python setup.py -q bdist_wheel -d {dist}',
    )).format(dist=dist_dir), cd=tmp_src)
    sdist = glob.glob(os.path.join(dist_dir, '*.zip'))[0]
    wheel = glob.glob(os.path.join(dist_dir, '*.whl'))[0]
    # Then update from wheel.
    virtualenv.run('pip install ' + wheel)
    # And finally try to upgrade from source.
    virtualenv.run('pip install --no-cache-dir --upgrade ' + sdist)


def _check_test_command_install_requirements(virtualenv, tmpdir, cwd):
    """
    Check the test command will install all required dependencies.
    """
    # Install setuptools.
    virtualenv.run('python setup.py develop', cd=cwd)

    def sdist(distname, version):
        dist_path = tmpdir.join('%s-%s.tar.gz' % (distname, version))
        make_nspkg_sdist(str(dist_path), distname, version)
        return dist_path
    dependency_links = [
        pathlib.Path(str(dist_path)).as_uri()
        for dist_path in (
            sdist('foobar', '2.4'),
            sdist('bits', '4.2'),
            sdist('bobs', '6.0'),
            sdist('pieces', '0.6'),
        )
    ]
    with tmpdir.join('setup.py').open('w') as fp:
        fp.write(DALS(
            '''
            from setuptools import setup

            setup(
                dependency_links={dependency_links!r},
                install_requires=[
                    'barbazquux1; sys_platform in ""',
                    'foobar==2.4',
                ],
                setup_requires='bits==4.2',
                tests_require="""
                    bobs==6.0
                """,
                extras_require={{
                    'test': ['barbazquux2'],
                    ':"" in sys_platform': 'pieces==0.6',
                    ':python_version > "1"': """
                        pieces
                        foobar
                    """,
                }}
            )
            '''.format(dependency_links=dependency_links)))
    with tmpdir.join('test.py').open('w') as fp:
        fp.write(DALS(
            '''
            import foobar
            import bits
            import bobs
            import pieces

            open('success', 'w').close()
            '''))
    # Run test command for test package.
    # use 'virtualenv.python' as workaround for man-group/pytest-plugins#166
    cmd = [virtualenv.python, 'setup.py', 'test', '-s', 'test']
    virtualenv.run(cmd, cd=str(tmpdir))
    assert tmpdir.join('success').check()


def test_test_command_install_requirements(virtualenv, tmpdir, request):
    # Ensure pip/wheel packages are installed.
    virtualenv.run(
        "python -c \"__import__('pkg_resources').require(['pip', 'wheel'])\"")
    # uninstall setuptools so that 'setup.py develop' works
    virtualenv.run("python -m pip uninstall -y setuptools")
    # disable index URL so bits and bobs aren't requested from PyPI
    virtualenv.env['PIP_NO_INDEX'] = '1'
    _check_test_command_install_requirements(virtualenv, tmpdir, request.config.rootdir)


def test_no_missing_dependencies(bare_virtualenv, request):
    """
    Quick and dirty test to ensure all external dependencies are vendored.
    """
    for command in ('upload',):  # sorted(distutils.command.__all__):
        cmd = [bare_virtualenv.python, 'setup.py', command, '-h']
        bare_virtualenv.run(cmd, cd=request.config.rootdir)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_wheel.py0000644000175100001710000003636200000000000021506 0ustar00runnerdocker# -*- coding: utf-8 -*-

"""wheel tests
"""

from distutils.sysconfig import get_config_var
from distutils.util import get_platform
import contextlib
import glob
import inspect
import os
import shutil
import subprocess
import sys
import zipfile

import pytest
from jaraco import path

from pkg_resources import Distribution, PathMetadata, PY_MAJOR
from setuptools.extern.packaging.utils import canonicalize_name
from setuptools.extern.packaging.tags import parse_tag
from setuptools.wheel import Wheel

from .contexts import tempdir
from .textwrap import DALS


WHEEL_INFO_TESTS = (
    ('invalid.whl', ValueError),
    ('simplewheel-2.0-1-py2.py3-none-any.whl', {
        'project_name': 'simplewheel',
        'version': '2.0',
        'build': '1',
        'py_version': 'py2.py3',
        'abi': 'none',
        'platform': 'any',
    }),
    ('simple.dist-0.1-py2.py3-none-any.whl', {
        'project_name': 'simple.dist',
        'version': '0.1',
        'build': None,
        'py_version': 'py2.py3',
        'abi': 'none',
        'platform': 'any',
    }),
    ('example_pkg_a-1-py3-none-any.whl', {
        'project_name': 'example_pkg_a',
        'version': '1',
        'build': None,
        'py_version': 'py3',
        'abi': 'none',
        'platform': 'any',
    }),
    ('PyQt5-5.9-5.9.1-cp35.cp36.cp37-abi3-manylinux1_x86_64.whl', {
        'project_name': 'PyQt5',
        'version': '5.9',
        'build': '5.9.1',
        'py_version': 'cp35.cp36.cp37',
        'abi': 'abi3',
        'platform': 'manylinux1_x86_64',
    }),
)


@pytest.mark.parametrize(
    ('filename', 'info'), WHEEL_INFO_TESTS,
    ids=[t[0] for t in WHEEL_INFO_TESTS]
)
def test_wheel_info(filename, info):
    if inspect.isclass(info):
        with pytest.raises(info):
            Wheel(filename)
        return
    w = Wheel(filename)
    assert {k: getattr(w, k) for k in info.keys()} == info


@contextlib.contextmanager
def build_wheel(extra_file_defs=None, **kwargs):
    file_defs = {
        'setup.py': (DALS(
            '''
            # -*- coding: utf-8 -*-
            from setuptools import setup
            import setuptools
            setup(**%r)
            '''
        ) % kwargs).encode('utf-8'),
    }
    if extra_file_defs:
        file_defs.update(extra_file_defs)
    with tempdir() as source_dir:
        path.build(file_defs, source_dir)
        subprocess.check_call((sys.executable, 'setup.py',
                               '-q', 'bdist_wheel'), cwd=source_dir)
        yield glob.glob(os.path.join(source_dir, 'dist', '*.whl'))[0]


def tree_set(root):
    contents = set()
    for dirpath, dirnames, filenames in os.walk(root):
        for filename in filenames:
            contents.add(os.path.join(os.path.relpath(dirpath, root),
                                      filename))
    return contents


def flatten_tree(tree):
    """Flatten nested dicts and lists into a full list of paths"""
    output = set()
    for node, contents in tree.items():
        if isinstance(contents, dict):
            contents = flatten_tree(contents)

        for elem in contents:
            if isinstance(elem, dict):
                output |= {os.path.join(node, val)
                           for val in flatten_tree(elem)}
            else:
                output.add(os.path.join(node, elem))
    return output


def format_install_tree(tree):
    return {
        x.format(
            py_version=PY_MAJOR,
            platform=get_platform(),
            shlib_ext=get_config_var('EXT_SUFFIX') or get_config_var('SO'))
        for x in tree}


def _check_wheel_install(filename, install_dir, install_tree_includes,
                         project_name, version, requires_txt):
    w = Wheel(filename)
    egg_path = os.path.join(install_dir, w.egg_name())
    w.install_as_egg(egg_path)
    if install_tree_includes is not None:
        install_tree = format_install_tree(install_tree_includes)
        exp = tree_set(install_dir)
        assert install_tree.issubset(exp), (install_tree - exp)

    metadata = PathMetadata(egg_path, os.path.join(egg_path, 'EGG-INFO'))
    dist = Distribution.from_filename(egg_path, metadata=metadata)
    assert dist.project_name == project_name
    assert dist.version == version
    if requires_txt is None:
        assert not dist.has_metadata('requires.txt')
    else:
        assert requires_txt == dist.get_metadata('requires.txt').lstrip()


class Record:

    def __init__(self, id, **kwargs):
        self._id = id
        self._fields = kwargs

    def __repr__(self):
        return '%s(**%r)' % (self._id, self._fields)


WHEEL_INSTALL_TESTS = (

    dict(
        id='basic',
        file_defs={
            'foo': {
                '__init__.py': ''
            }
        },
        setup_kwargs=dict(
            packages=['foo'],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': {
                'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'top_level.txt'
                ],
                'foo': ['__init__.py']
            }
        }),
    ),

    dict(
        id='utf-8',
        setup_kwargs=dict(
            description='Description accentuée',
        )
    ),

    dict(
        id='data',
        file_defs={
            'data.txt': DALS(
                '''
                Some data...
                '''
            ),
        },
        setup_kwargs=dict(
            data_files=[('data_dir', ['data.txt'])],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': {
                'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'top_level.txt'
                ],
                'data_dir': [
                    'data.txt'
                ]
            }
        }),
    ),

    dict(
        id='extension',
        file_defs={
            'extension.c': DALS(
                '''
                #include "Python.h"

                #if PY_MAJOR_VERSION >= 3

                static struct PyModuleDef moduledef = {
                        PyModuleDef_HEAD_INIT,
                        "extension",
                        NULL,
                        0,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL
                };

                #define INITERROR return NULL

                PyMODINIT_FUNC PyInit_extension(void)

                #else

                #define INITERROR return

                void initextension(void)

                #endif
                {
                #if PY_MAJOR_VERSION >= 3
                    PyObject *module = PyModule_Create(&moduledef);
                #else
                    PyObject *module = Py_InitModule("extension", NULL);
                #endif
                    if (module == NULL)
                        INITERROR;
                #if PY_MAJOR_VERSION >= 3
                    return module;
                #endif
                }
                '''
            ),
        },
        setup_kwargs=dict(
            ext_modules=[
                Record('setuptools.Extension',
                       name='extension',
                       sources=['extension.c'])
            ],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}-{platform}.egg': [
                'extension{shlib_ext}',
                {'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'top_level.txt',
                ]},
            ]
        }),
    ),

    dict(
        id='header',
        file_defs={
            'header.h': DALS(
                '''
                '''
            ),
        },
        setup_kwargs=dict(
            headers=['header.h'],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': [
                'header.h',
                {'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'top_level.txt',
                ]},
            ]
        }),
    ),

    dict(
        id='script',
        file_defs={
            'script.py': DALS(
                '''
                #/usr/bin/python
                print('hello world!')
                '''
            ),
            'script.sh': DALS(
                '''
                #/bin/sh
                echo 'hello world!'
                '''
            ),
        },
        setup_kwargs=dict(
            scripts=['script.py', 'script.sh'],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': {
                'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'top_level.txt',
                    {'scripts': [
                        'script.py',
                        'script.sh'
                    ]}

                ]
            }
        })
    ),

    dict(
        id='requires1',
        install_requires='foobar==2.0',
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': {
                'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'requires.txt',
                    'top_level.txt',
                ]
            }
        }),
        requires_txt=DALS(
            '''
            foobar==2.0
            '''
        ),
    ),

    dict(
        id='requires2',
        install_requires='''
        bar
        foo<=2.0; %r in sys_platform
        ''' % sys.platform,
        requires_txt=DALS(
            '''
            bar
            foo<=2.0
            '''
        ),
    ),

    dict(
        id='requires3',
        install_requires='''
        bar; %r != sys_platform
        ''' % sys.platform,
    ),

    dict(
        id='requires4',
        install_requires='''
        foo
        ''',
        extras_require={
            'extra': 'foobar>3',
        },
        requires_txt=DALS(
            '''
            foo

            [extra]
            foobar>3
            '''
        ),
    ),

    dict(
        id='requires5',
        extras_require={
            'extra': 'foobar; %r != sys_platform' % sys.platform,
        },
        requires_txt=DALS(
            '''
            [extra]
            '''
        ),
    ),

    dict(
        id='namespace_package',
        file_defs={
            'foo': {
                'bar': {
                    '__init__.py': ''
                },
            },
        },
        setup_kwargs=dict(
            namespace_packages=['foo'],
            packages=['foo.bar'],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': [
                'foo-1.0-py{py_version}-nspkg.pth',
                {'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'namespace_packages.txt',
                    'top_level.txt',
                ]},
                {'foo': [
                    '__init__.py',
                    {'bar': ['__init__.py']},
                ]},
            ]
        }),
    ),

    dict(
        id='empty_namespace_package',
        file_defs={
            'foobar': {
                '__init__.py':
                    "__import__('pkg_resources').declare_namespace(__name__)",
            },
        },
        setup_kwargs=dict(
            namespace_packages=['foobar'],
            packages=['foobar'],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': [
                'foo-1.0-py{py_version}-nspkg.pth',
                {'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'namespace_packages.txt',
                    'top_level.txt',
                ]},
                {'foobar': [
                    '__init__.py',
                ]},
            ]
        }),
    ),

    dict(
        id='data_in_package',
        file_defs={
            'foo': {
                '__init__.py': '',
                'data_dir': {
                    'data.txt': DALS(
                        '''
                        Some data...
                        '''
                    ),
                }
            }
        },
        setup_kwargs=dict(
            packages=['foo'],
            data_files=[('foo/data_dir', ['foo/data_dir/data.txt'])],
        ),
        install_tree=flatten_tree({
            'foo-1.0-py{py_version}.egg': {
                'EGG-INFO': [
                    'PKG-INFO',
                    'RECORD',
                    'WHEEL',
                    'top_level.txt',
                ],
                'foo': [
                    '__init__.py',
                    {'data_dir': [
                        'data.txt',
                    ]}
                ]
            }
        }),
    ),

)


@pytest.mark.parametrize(
    'params', WHEEL_INSTALL_TESTS,
    ids=list(params['id'] for params in WHEEL_INSTALL_TESTS),
)
def test_wheel_install(params):
    project_name = params.get('name', 'foo')
    version = params.get('version', '1.0')
    install_requires = params.get('install_requires', [])
    extras_require = params.get('extras_require', {})
    requires_txt = params.get('requires_txt', None)
    install_tree = params.get('install_tree')
    file_defs = params.get('file_defs', {})
    setup_kwargs = params.get('setup_kwargs', {})
    with build_wheel(
        name=project_name,
        version=version,
        install_requires=install_requires,
        extras_require=extras_require,
        extra_file_defs=file_defs,
        **setup_kwargs
    ) as filename, tempdir() as install_dir:
        _check_wheel_install(filename, install_dir,
                             install_tree, project_name,
                             version, requires_txt)


def test_wheel_install_pep_503():
    project_name = 'Foo_Bar'    # PEP 503 canonicalized name is "foo-bar"
    version = '1.0'
    with build_wheel(
        name=project_name,
        version=version,
    ) as filename, tempdir() as install_dir:
        new_filename = filename.replace(project_name,
                                        canonicalize_name(project_name))
        shutil.move(filename, new_filename)
        _check_wheel_install(new_filename, install_dir, None,
                             canonicalize_name(project_name),
                             version, None)


def test_wheel_no_dist_dir():
    project_name = 'nodistinfo'
    version = '1.0'
    wheel_name = '{0}-{1}-py2.py3-none-any.whl'.format(project_name, version)
    with tempdir() as source_dir:
        wheel_path = os.path.join(source_dir, wheel_name)
        # create an empty zip file
        zipfile.ZipFile(wheel_path, 'w').close()
        with tempdir() as install_dir:
            with pytest.raises(ValueError):
                _check_wheel_install(wheel_path, install_dir, None,
                                     project_name,
                                     version, None)


def test_wheel_is_compatible(monkeypatch):
    def sys_tags():
        for t in parse_tag('cp36-cp36m-manylinux1_x86_64'):
            yield t
    monkeypatch.setattr('setuptools.wheel.sys_tags', sys_tags)
    assert Wheel(
        'onnxruntime-0.1.2-cp36-cp36m-manylinux1_x86_64.whl').is_compatible()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/test_windows_wrappers.py0000644000175100001710000001456300000000000024016 0ustar00runnerdocker"""
Python Script Wrapper for Windows
=================================

setuptools includes wrappers for Python scripts that allows them to be
executed like regular windows programs.  There are 2 wrappers, one
for command-line programs, cli.exe, and one for graphical programs,
gui.exe.  These programs are almost identical, function pretty much
the same way, and are generated from the same source file.  The
wrapper programs are used by copying them to the directory containing
the script they are to wrap and with the same name as the script they
are to wrap.
"""

import sys
import platform
import textwrap
import subprocess

import pytest

from setuptools.command.easy_install import nt_quote_arg
import pkg_resources

pytestmark = pytest.mark.skipif(sys.platform != 'win32', reason="Windows only")


class WrapperTester:
    @classmethod
    def prep_script(cls, template):
        python_exe = nt_quote_arg(sys.executable)
        return template % locals()

    @classmethod
    def create_script(cls, tmpdir):
        """
        Create a simple script, foo-script.py

        Note that the script starts with a Unix-style '#!' line saying which
        Python executable to run.  The wrapper will use this line to find the
        correct Python executable.
        """

        script = cls.prep_script(cls.script_tmpl)

        with (tmpdir / cls.script_name).open('w') as f:
            f.write(script)

        # also copy cli.exe to the sample directory
        with (tmpdir / cls.wrapper_name).open('wb') as f:
            w = pkg_resources.resource_string('setuptools', cls.wrapper_source)
            f.write(w)


def win_launcher_exe(prefix):
    """ A simple routine to select launcher script based on platform."""
    assert prefix in ('cli', 'gui')
    if platform.machine() == "ARM64":
        return "{}-arm64.exe".format(prefix)
    else:
        return "{}-32.exe".format(prefix)


class TestCLI(WrapperTester):
    script_name = 'foo-script.py'
    wrapper_name = 'foo.exe'
    wrapper_source = win_launcher_exe('cli')

    script_tmpl = textwrap.dedent("""
        #!%(python_exe)s
        import sys
        input = repr(sys.stdin.read())
        print(sys.argv[0][-14:])
        print(sys.argv[1:])
        print(input)
        if __debug__:
            print('non-optimized')
        """).lstrip()

    def test_basic(self, tmpdir):
        """
        When the copy of cli.exe, foo.exe in this example, runs, it examines
        the path name it was run with and computes a Python script path name
        by removing the '.exe' suffix and adding the '-script.py' suffix. (For
        GUI programs, the suffix '-script.pyw' is added.)  This is why we
        named out script the way we did.  Now we can run out script by running
        the wrapper:

        This example was a little pathological in that it exercised windows
        (MS C runtime) quoting rules:

        - Strings containing spaces are surrounded by double quotes.

        - Double quotes in strings need to be escaped by preceding them with
          back slashes.

        - One or more backslashes preceding double quotes need to be escaped
          by preceding each of them with back slashes.
        """
        self.create_script(tmpdir)
        cmd = [
            str(tmpdir / 'foo.exe'),
            'arg1',
            'arg 2',
            'arg "2\\"',
            'arg 4\\',
            'arg5 a\\\\b',
        ]
        proc = subprocess.Popen(
            cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
        stdout, stderr = proc.communicate('hello\nworld\n'.encode('ascii'))
        actual = stdout.decode('ascii').replace('\r\n', '\n')
        expected = textwrap.dedent(r"""
            \foo-script.py
            ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
            'hello\nworld\n'
            non-optimized
            """).lstrip()
        assert actual == expected

    def test_with_options(self, tmpdir):
        """
        Specifying Python Command-line Options
        --------------------------------------

        You can specify a single argument on the '#!' line.  This can be used
        to specify Python options like -O, to run in optimized mode or -i
        to start the interactive interpreter.  You can combine multiple
        options as usual. For example, to run in optimized mode and
        enter the interpreter after running the script, you could use -Oi:
        """
        self.create_script(tmpdir)
        tmpl = textwrap.dedent("""
            #!%(python_exe)s  -Oi
            import sys
            input = repr(sys.stdin.read())
            print(sys.argv[0][-14:])
            print(sys.argv[1:])
            print(input)
            if __debug__:
                print('non-optimized')
            sys.ps1 = '---'
            """).lstrip()
        with (tmpdir / 'foo-script.py').open('w') as f:
            f.write(self.prep_script(tmpl))
        cmd = [str(tmpdir / 'foo.exe')]
        proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            stderr=subprocess.STDOUT)
        stdout, stderr = proc.communicate()
        actual = stdout.decode('ascii').replace('\r\n', '\n')
        expected = textwrap.dedent(r"""
            \foo-script.py
            []
            ''
            ---
            """).lstrip()
        assert actual == expected


class TestGUI(WrapperTester):
    """
    Testing the GUI Version
    -----------------------
    """
    script_name = 'bar-script.pyw'
    wrapper_source = win_launcher_exe('gui')
    wrapper_name = 'bar.exe'

    script_tmpl = textwrap.dedent("""
        #!%(python_exe)s
        import sys
        f = open(sys.argv[1], 'wb')
        bytes_written = f.write(repr(sys.argv[2]).encode('utf-8'))
        f.close()
        """).strip()

    def test_basic(self, tmpdir):
        """Test the GUI version with the simple script, bar-script.py"""
        self.create_script(tmpdir)

        cmd = [
            str(tmpdir / 'bar.exe'),
            str(tmpdir / 'test_output.txt'),
            'Test Argument',
        ]
        proc = subprocess.Popen(
            cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE,
            stderr=subprocess.STDOUT)
        stdout, stderr = proc.communicate()
        assert not stdout
        assert not stderr
        with (tmpdir / 'test_output.txt').open('rb') as f_out:
            actual = f_out.read().decode('ascii')
        assert actual == repr('Test Argument')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/text.py0000644000175100001710000000017300000000000020316 0ustar00runnerdockerclass Filenames:
    unicode = 'smörbröd.py'
    latin_1 = unicode.encode('latin-1')
    utf_8 = unicode.encode('utf-8')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/tests/textwrap.py0000644000175100001710000000014200000000000021204 0ustar00runnerdockerimport textwrap


def DALS(s):
    "dedent and left-strip"
    return textwrap.dedent(s).lstrip()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/unicode_utils.py0000644000175100001710000000165500000000000021044 0ustar00runnerdockerimport unicodedata
import sys


# HFS Plus uses decomposed UTF-8
def decompose(path):
    if isinstance(path, str):
        return unicodedata.normalize('NFD', path)
    try:
        path = path.decode('utf-8')
        path = unicodedata.normalize('NFD', path)
        path = path.encode('utf-8')
    except UnicodeError:
        pass  # Not UTF-8
    return path


def filesys_decode(path):
    """
    Ensure that the given path is decoded,
    NONE when no expected encoding works
    """

    if isinstance(path, str):
        return path

    fs_enc = sys.getfilesystemencoding() or 'utf-8'
    candidates = fs_enc, 'utf-8'

    for enc in candidates:
        try:
            return path.decode(enc)
        except UnicodeDecodeError:
            continue


def try_encode(string, enc):
    "turn unicode encoding into a functional routine"
    try:
        return string.encode(enc)
    except UnicodeEncodeError:
        return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/version.py0000644000175100001710000000022000000000000017646 0ustar00runnerdockerimport pkg_resources

try:
    __version__ = pkg_resources.get_distribution('setuptools').version
except Exception:
    __version__ = 'unknown'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/wheel.py0000644000175100001710000002014000000000000017270 0ustar00runnerdocker"""Wheels support."""

from distutils.util import get_platform
from distutils import log
import email
import itertools
import os
import posixpath
import re
import zipfile

import pkg_resources
import setuptools
from pkg_resources import parse_version
from setuptools.extern.packaging.tags import sys_tags
from setuptools.extern.packaging.utils import canonicalize_name
from setuptools.command.egg_info import write_requirements


WHEEL_NAME = re.compile(
    r"""^(?P.+?)-(?P\d.*?)
    ((-(?P\d.*?))?-(?P.+?)-(?P.+?)-(?P.+?)
    )\.whl$""",
    re.VERBOSE).match

NAMESPACE_PACKAGE_INIT = \
    "__import__('pkg_resources').declare_namespace(__name__)\n"


def unpack(src_dir, dst_dir):
    '''Move everything under `src_dir` to `dst_dir`, and delete the former.'''
    for dirpath, dirnames, filenames in os.walk(src_dir):
        subdir = os.path.relpath(dirpath, src_dir)
        for f in filenames:
            src = os.path.join(dirpath, f)
            dst = os.path.join(dst_dir, subdir, f)
            os.renames(src, dst)
        for n, d in reversed(list(enumerate(dirnames))):
            src = os.path.join(dirpath, d)
            dst = os.path.join(dst_dir, subdir, d)
            if not os.path.exists(dst):
                # Directory does not exist in destination,
                # rename it and prune it from os.walk list.
                os.renames(src, dst)
                del dirnames[n]
    # Cleanup.
    for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True):
        assert not filenames
        os.rmdir(dirpath)


class Wheel:

    def __init__(self, filename):
        match = WHEEL_NAME(os.path.basename(filename))
        if match is None:
            raise ValueError('invalid wheel name: %r' % filename)
        self.filename = filename
        for k, v in match.groupdict().items():
            setattr(self, k, v)

    def tags(self):
        '''List tags (py_version, abi, platform) supported by this wheel.'''
        return itertools.product(
            self.py_version.split('.'),
            self.abi.split('.'),
            self.platform.split('.'),
        )

    def is_compatible(self):
        '''Is the wheel is compatible with the current platform?'''
        supported_tags = set(
            (t.interpreter, t.abi, t.platform) for t in sys_tags())
        return next((True for t in self.tags() if t in supported_tags), False)

    def egg_name(self):
        return pkg_resources.Distribution(
            project_name=self.project_name, version=self.version,
            platform=(None if self.platform == 'any' else get_platform()),
        ).egg_name() + '.egg'

    def get_dist_info(self, zf):
        # find the correct name of the .dist-info dir in the wheel file
        for member in zf.namelist():
            dirname = posixpath.dirname(member)
            if (dirname.endswith('.dist-info') and
                    canonicalize_name(dirname).startswith(
                        canonicalize_name(self.project_name))):
                return dirname
        raise ValueError("unsupported wheel format. .dist-info not found")

    def install_as_egg(self, destination_eggdir):
        '''Install wheel as an egg directory.'''
        with zipfile.ZipFile(self.filename) as zf:
            self._install_as_egg(destination_eggdir, zf)

    def _install_as_egg(self, destination_eggdir, zf):
        dist_basename = '%s-%s' % (self.project_name, self.version)
        dist_info = self.get_dist_info(zf)
        dist_data = '%s.data' % dist_basename
        egg_info = os.path.join(destination_eggdir, 'EGG-INFO')

        self._convert_metadata(zf, destination_eggdir, dist_info, egg_info)
        self._move_data_entries(destination_eggdir, dist_data)
        self._fix_namespace_packages(egg_info, destination_eggdir)

    @staticmethod
    def _convert_metadata(zf, destination_eggdir, dist_info, egg_info):
        def get_metadata(name):
            with zf.open(posixpath.join(dist_info, name)) as fp:
                value = fp.read().decode('utf-8')
                return email.parser.Parser().parsestr(value)

        wheel_metadata = get_metadata('WHEEL')
        # Check wheel format version is supported.
        wheel_version = parse_version(wheel_metadata.get('Wheel-Version'))
        wheel_v1 = (
            parse_version('1.0') <= wheel_version < parse_version('2.0dev0')
        )
        if not wheel_v1:
            raise ValueError(
                'unsupported wheel format version: %s' % wheel_version)
        # Extract to target directory.
        os.mkdir(destination_eggdir)
        zf.extractall(destination_eggdir)
        # Convert metadata.
        dist_info = os.path.join(destination_eggdir, dist_info)
        dist = pkg_resources.Distribution.from_location(
            destination_eggdir, dist_info,
            metadata=pkg_resources.PathMetadata(destination_eggdir, dist_info),
        )

        # Note: Evaluate and strip markers now,
        # as it's difficult to convert back from the syntax:
        # foobar; "linux" in sys_platform and extra == 'test'
        def raw_req(req):
            req.marker = None
            return str(req)
        install_requires = list(sorted(map(raw_req, dist.requires())))
        extras_require = {
            extra: sorted(
                req
                for req in map(raw_req, dist.requires((extra,)))
                if req not in install_requires
            )
            for extra in dist.extras
        }
        os.rename(dist_info, egg_info)
        os.rename(
            os.path.join(egg_info, 'METADATA'),
            os.path.join(egg_info, 'PKG-INFO'),
        )
        setup_dist = setuptools.Distribution(
            attrs=dict(
                install_requires=install_requires,
                extras_require=extras_require,
            ),
        )
        # Temporarily disable info traces.
        log_threshold = log._global_log.threshold
        log.set_threshold(log.WARN)
        try:
            write_requirements(
                setup_dist.get_command_obj('egg_info'),
                None,
                os.path.join(egg_info, 'requires.txt'),
            )
        finally:
            log.set_threshold(log_threshold)

    @staticmethod
    def _move_data_entries(destination_eggdir, dist_data):
        """Move data entries to their correct location."""
        dist_data = os.path.join(destination_eggdir, dist_data)
        dist_data_scripts = os.path.join(dist_data, 'scripts')
        if os.path.exists(dist_data_scripts):
            egg_info_scripts = os.path.join(
                destination_eggdir, 'EGG-INFO', 'scripts')
            os.mkdir(egg_info_scripts)
            for entry in os.listdir(dist_data_scripts):
                # Remove bytecode, as it's not properly handled
                # during easy_install scripts install phase.
                if entry.endswith('.pyc'):
                    os.unlink(os.path.join(dist_data_scripts, entry))
                else:
                    os.rename(
                        os.path.join(dist_data_scripts, entry),
                        os.path.join(egg_info_scripts, entry),
                    )
            os.rmdir(dist_data_scripts)
        for subdir in filter(os.path.exists, (
            os.path.join(dist_data, d)
            for d in ('data', 'headers', 'purelib', 'platlib')
        )):
            unpack(subdir, destination_eggdir)
        if os.path.exists(dist_data):
            os.rmdir(dist_data)

    @staticmethod
    def _fix_namespace_packages(egg_info, destination_eggdir):
        namespace_packages = os.path.join(
            egg_info, 'namespace_packages.txt')
        if os.path.exists(namespace_packages):
            with open(namespace_packages) as fp:
                namespace_packages = fp.read().split()
            for mod in namespace_packages:
                mod_dir = os.path.join(destination_eggdir, *mod.split('.'))
                mod_init = os.path.join(mod_dir, '__init__.py')
                if not os.path.exists(mod_dir):
                    os.mkdir(mod_dir)
                if not os.path.exists(mod_init):
                    with open(mod_init, 'w') as fp:
                        fp.write(NAMESPACE_PACKAGE_INIT)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/setuptools/windows_support.py0000644000175100001710000000131200000000000021452 0ustar00runnerdockerimport platform
import ctypes


def windows_only(func):
    if platform.system() != 'Windows':
        return lambda *args, **kwargs: None
    return func


@windows_only
def hide_file(path):
    """
    Set the hidden attribute on a file or directory.

    From http://stackoverflow.com/questions/19622133/

    `path` must be text.
    """
    __import__('ctypes.wintypes')
    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
    SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD
    SetFileAttributes.restype = ctypes.wintypes.BOOL

    FILE_ATTRIBUTE_HIDDEN = 0x02

    ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN)
    if not ret:
        raise ctypes.WinError()
././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1639341979.91467
setuptools-59.6.0/setuptools.egg-info/0000755000175100001710000000000000000000000017307 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341979.0
setuptools-59.6.0/setuptools.egg-info/PKG-INFO0000644000175100001710000000670400000000000020413 0ustar00runnerdockerMetadata-Version: 2.1
Name: setuptools
Version: 59.6.0
Summary: Easily download, build, install, upgrade, and uninstall Python packages
Home-page: https://github.com/pypa/setuptools
Author: Python Packaging Authority
Author-email: distutils-sig@python.org
License: UNKNOWN
Project-URL: Documentation, https://setuptools.pypa.io/
Keywords: CPAN PyPI distutils eggs package management
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: System :: Archiving :: Packaging
Classifier: Topic :: System :: Systems Administration
Classifier: Topic :: Utilities
Requires-Python: >=3.6
Provides-Extra: testing
Provides-Extra: docs
Provides-Extra: ssl
Provides-Extra: certs
License-File: LICENSE

.. image:: https://raw.githubusercontent.com/pypa/setuptools/main/docs/images/banner-640x320.svg
   :align: center

|

.. image:: https://img.shields.io/pypi/v/setuptools.svg
   :target: `PyPI link`_

.. image:: https://img.shields.io/pypi/pyversions/setuptools.svg
   :target: `PyPI link`_

.. _PyPI link: https://pypi.org/project/setuptools

.. image:: https://github.com/pypa/setuptools/workflows/tests/badge.svg
   :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
   :target: https://github.com/psf/black
   :alt: Code style: Black

.. image:: https://img.shields.io/readthedocs/setuptools/latest.svg
    :target: https://setuptools.pypa.io

.. image:: https://img.shields.io/badge/skeleton-2021-informational
   :target: https://blog.jaraco.com/skeleton

.. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white
   :target: https://codecov.io/gh/pypa/setuptools

.. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat
   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme

See the `Installation Instructions
`_ in the Python Packaging
User's Guide for instructions on installing, upgrading, and uninstalling
Setuptools.

Questions and comments should be directed to the `distutils-sig
mailing list `_.
Bug reports and especially tested patches may be
submitted directly to the `bug tracker
`_.


Code of Conduct
===============

Everyone interacting in the setuptools project's codebases, issue trackers,
chat rooms, and mailing lists is expected to follow the
`PSF Code of Conduct `_.


For Enterprise
==============

Available as part of the Tidelift Subscription.

Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.

`Learn more `_.


Security Contact
================

To report a security vulnerability, please use the
`Tidelift security contact `_.
Tidelift will coordinate the fix and disclosure.


././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341979.0
setuptools-59.6.0/setuptools.egg-info/SOURCES.txt0000644000175100001710000003033600000000000021200 0ustar00runnerdockerCHANGES.rst
LICENSE
MANIFEST.in
README.rst
bootstrap.py
conftest.py
launcher.c
msvc-build-launcher.cmd
pavement.py
pyproject.toml
pytest.ini
setup.cfg
setup.py
towncrier_template.rst
tox.ini
_distutils_hack/__init__.py
_distutils_hack/override.py
changelog.d/.gitignore
changelog.d/README.rst
docs/build_meta.rst
docs/conf.py
docs/history.rst
docs/index.rst
docs/pkg_resources.rst
docs/python 2 sunset.rst
docs/roadmap.rst
docs/setuptools.rst
docs/_ext/_custom_icons.py
docs/deprecated/distutils-legacy.rst
docs/deprecated/easy_install.rst
docs/deprecated/functionalities.rst
docs/deprecated/index.rst
docs/deprecated/python_eggs.rst
docs/deprecated/distutils/_setuptools_disclaimer.rst
docs/deprecated/distutils/apiref.rst
docs/deprecated/distutils/builtdist.rst
docs/deprecated/distutils/commandref.rst
docs/deprecated/distutils/configfile.rst
docs/deprecated/distutils/examples.rst
docs/deprecated/distutils/extending.rst
docs/deprecated/distutils/index.rst
docs/deprecated/distutils/introduction.rst
docs/deprecated/distutils/packageindex.rst
docs/deprecated/distutils/setupscript.rst
docs/deprecated/distutils/sourcedist.rst
docs/deprecated/distutils/uploading.rst
docs/development/developer-guide.rst
docs/development/index.rst
docs/development/releases.rst
docs/images/README.rst
docs/references/keywords.rst
docs/userguide/commands.rst
docs/userguide/datafiles.rst
docs/userguide/declarative_config.rst
docs/userguide/dependency_management.rst
docs/userguide/development_mode.rst
docs/userguide/distribution.rst
docs/userguide/entry_point.rst
docs/userguide/extension.rst
docs/userguide/functionalities_rewrite.rst
docs/userguide/index.rst
docs/userguide/keywords.rst
docs/userguide/miscellaneous.rst
docs/userguide/package_discovery.rst
docs/userguide/quickstart.rst
pkg_resources/__init__.py
pkg_resources/api_tests.txt
pkg_resources/_vendor/__init__.py
pkg_resources/_vendor/appdirs.py
pkg_resources/_vendor/pyparsing.py
pkg_resources/_vendor/vendored.txt
pkg_resources/_vendor/packaging/__about__.py
pkg_resources/_vendor/packaging/__init__.py
pkg_resources/_vendor/packaging/_manylinux.py
pkg_resources/_vendor/packaging/_musllinux.py
pkg_resources/_vendor/packaging/_structures.py
pkg_resources/_vendor/packaging/markers.py
pkg_resources/_vendor/packaging/requirements.py
pkg_resources/_vendor/packaging/specifiers.py
pkg_resources/_vendor/packaging/tags.py
pkg_resources/_vendor/packaging/utils.py
pkg_resources/_vendor/packaging/version.py
pkg_resources/extern/__init__.py
pkg_resources/tests/__init__.py
pkg_resources/tests/test_find_distributions.py
pkg_resources/tests/test_markers.py
pkg_resources/tests/test_pkg_resources.py
pkg_resources/tests/test_resources.py
pkg_resources/tests/test_working_set.py
pkg_resources/tests/data/my-test-package-source/setup.cfg
pkg_resources/tests/data/my-test-package-source/setup.py
pkg_resources/tests/data/my-test-package-zip/my-test-package.zip
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe
pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg
setuptools/__init__.py
setuptools/_deprecation_warning.py
setuptools/_imp.py
setuptools/archive_util.py
setuptools/build_meta.py
setuptools/cli-32.exe
setuptools/cli-64.exe
setuptools/cli-arm64.exe
setuptools/cli.exe
setuptools/config.py
setuptools/dep_util.py
setuptools/depends.py
setuptools/dist.py
setuptools/errors.py
setuptools/extension.py
setuptools/glob.py
setuptools/gui-32.exe
setuptools/gui-64.exe
setuptools/gui-arm64.exe
setuptools/gui.exe
setuptools/installer.py
setuptools/launch.py
setuptools/monkey.py
setuptools/msvc.py
setuptools/namespaces.py
setuptools/package_index.py
setuptools/py34compat.py
setuptools/sandbox.py
setuptools/script (dev).tmpl
setuptools/script.tmpl
setuptools/unicode_utils.py
setuptools/version.py
setuptools/wheel.py
setuptools/windows_support.py
setuptools.egg-info/PKG-INFO
setuptools.egg-info/SOURCES.txt
setuptools.egg-info/dependency_links.txt
setuptools.egg-info/entry_points.txt
setuptools.egg-info/requires.txt
setuptools.egg-info/top_level.txt
setuptools/_distutils/__init__.py
setuptools/_distutils/_msvccompiler.py
setuptools/_distutils/archive_util.py
setuptools/_distutils/bcppcompiler.py
setuptools/_distutils/ccompiler.py
setuptools/_distutils/cmd.py
setuptools/_distutils/config.py
setuptools/_distutils/core.py
setuptools/_distutils/cygwinccompiler.py
setuptools/_distutils/debug.py
setuptools/_distutils/dep_util.py
setuptools/_distutils/dir_util.py
setuptools/_distutils/dist.py
setuptools/_distutils/errors.py
setuptools/_distutils/extension.py
setuptools/_distutils/fancy_getopt.py
setuptools/_distutils/file_util.py
setuptools/_distutils/filelist.py
setuptools/_distutils/log.py
setuptools/_distutils/msvc9compiler.py
setuptools/_distutils/msvccompiler.py
setuptools/_distutils/py35compat.py
setuptools/_distutils/py38compat.py
setuptools/_distutils/spawn.py
setuptools/_distutils/sysconfig.py
setuptools/_distutils/text_file.py
setuptools/_distutils/unixccompiler.py
setuptools/_distutils/util.py
setuptools/_distutils/version.py
setuptools/_distutils/versionpredicate.py
setuptools/_distutils/command/__init__.py
setuptools/_distutils/command/bdist.py
setuptools/_distutils/command/bdist_dumb.py
setuptools/_distutils/command/bdist_msi.py
setuptools/_distutils/command/bdist_rpm.py
setuptools/_distutils/command/bdist_wininst.py
setuptools/_distutils/command/build.py
setuptools/_distutils/command/build_clib.py
setuptools/_distutils/command/build_ext.py
setuptools/_distutils/command/build_py.py
setuptools/_distutils/command/build_scripts.py
setuptools/_distutils/command/check.py
setuptools/_distutils/command/clean.py
setuptools/_distutils/command/config.py
setuptools/_distutils/command/install.py
setuptools/_distutils/command/install_data.py
setuptools/_distutils/command/install_egg_info.py
setuptools/_distutils/command/install_headers.py
setuptools/_distutils/command/install_lib.py
setuptools/_distutils/command/install_scripts.py
setuptools/_distutils/command/py37compat.py
setuptools/_distutils/command/register.py
setuptools/_distutils/command/sdist.py
setuptools/_distutils/command/upload.py
setuptools/_distutils/command/wininst-10.0-amd64.exe
setuptools/_distutils/command/wininst-10.0.exe
setuptools/_distutils/command/wininst-14.0-amd64.exe
setuptools/_distutils/command/wininst-14.0.exe
setuptools/_distutils/command/wininst-6.0.exe
setuptools/_distutils/command/wininst-7.1.exe
setuptools/_distutils/command/wininst-8.0.exe
setuptools/_distutils/command/wininst-9.0-amd64.exe
setuptools/_distutils/command/wininst-9.0.exe
setuptools/_distutils/tests/__init__.py
setuptools/_distutils/tests/py35compat.py
setuptools/_distutils/tests/py38compat.py
setuptools/_distutils/tests/support.py
setuptools/_distutils/tests/test_archive_util.py
setuptools/_distutils/tests/test_bdist.py
setuptools/_distutils/tests/test_bdist_dumb.py
setuptools/_distutils/tests/test_bdist_msi.py
setuptools/_distutils/tests/test_bdist_rpm.py
setuptools/_distutils/tests/test_bdist_wininst.py
setuptools/_distutils/tests/test_build.py
setuptools/_distutils/tests/test_build_clib.py
setuptools/_distutils/tests/test_build_ext.py
setuptools/_distutils/tests/test_build_py.py
setuptools/_distutils/tests/test_build_scripts.py
setuptools/_distutils/tests/test_check.py
setuptools/_distutils/tests/test_clean.py
setuptools/_distutils/tests/test_cmd.py
setuptools/_distutils/tests/test_config.py
setuptools/_distutils/tests/test_config_cmd.py
setuptools/_distutils/tests/test_core.py
setuptools/_distutils/tests/test_cygwinccompiler.py
setuptools/_distutils/tests/test_dep_util.py
setuptools/_distutils/tests/test_dir_util.py
setuptools/_distutils/tests/test_dist.py
setuptools/_distutils/tests/test_extension.py
setuptools/_distutils/tests/test_file_util.py
setuptools/_distutils/tests/test_filelist.py
setuptools/_distutils/tests/test_install.py
setuptools/_distutils/tests/test_install_data.py
setuptools/_distutils/tests/test_install_headers.py
setuptools/_distutils/tests/test_install_lib.py
setuptools/_distutils/tests/test_install_scripts.py
setuptools/_distutils/tests/test_log.py
setuptools/_distutils/tests/test_msvc9compiler.py
setuptools/_distutils/tests/test_msvccompiler.py
setuptools/_distutils/tests/test_register.py
setuptools/_distutils/tests/test_sdist.py
setuptools/_distutils/tests/test_spawn.py
setuptools/_distutils/tests/test_sysconfig.py
setuptools/_distutils/tests/test_text_file.py
setuptools/_distutils/tests/test_unixccompiler.py
setuptools/_distutils/tests/test_upload.py
setuptools/_distutils/tests/test_util.py
setuptools/_distutils/tests/test_version.py
setuptools/_distutils/tests/test_versionpredicate.py
setuptools/_vendor/__init__.py
setuptools/_vendor/ordered_set.py
setuptools/_vendor/pyparsing.py
setuptools/_vendor/vendored.txt
setuptools/_vendor/more_itertools/__init__.py
setuptools/_vendor/more_itertools/more.py
setuptools/_vendor/more_itertools/recipes.py
setuptools/_vendor/packaging/__about__.py
setuptools/_vendor/packaging/__init__.py
setuptools/_vendor/packaging/_manylinux.py
setuptools/_vendor/packaging/_musllinux.py
setuptools/_vendor/packaging/_structures.py
setuptools/_vendor/packaging/markers.py
setuptools/_vendor/packaging/requirements.py
setuptools/_vendor/packaging/specifiers.py
setuptools/_vendor/packaging/tags.py
setuptools/_vendor/packaging/utils.py
setuptools/_vendor/packaging/version.py
setuptools/command/__init__.py
setuptools/command/alias.py
setuptools/command/bdist_egg.py
setuptools/command/bdist_rpm.py
setuptools/command/build_clib.py
setuptools/command/build_ext.py
setuptools/command/build_py.py
setuptools/command/develop.py
setuptools/command/dist_info.py
setuptools/command/easy_install.py
setuptools/command/egg_info.py
setuptools/command/install.py
setuptools/command/install_egg_info.py
setuptools/command/install_lib.py
setuptools/command/install_scripts.py
setuptools/command/launcher manifest.xml
setuptools/command/py36compat.py
setuptools/command/register.py
setuptools/command/rotate.py
setuptools/command/saveopts.py
setuptools/command/sdist.py
setuptools/command/setopt.py
setuptools/command/test.py
setuptools/command/upload.py
setuptools/command/upload_docs.py
setuptools/extern/__init__.py
setuptools/tests/__init__.py
setuptools/tests/contexts.py
setuptools/tests/environment.py
setuptools/tests/fixtures.py
setuptools/tests/mod_with_constant.py
setuptools/tests/namespaces.py
setuptools/tests/script-with-bom.py
setuptools/tests/server.py
setuptools/tests/test_archive_util.py
setuptools/tests/test_bdist_deprecations.py
setuptools/tests/test_bdist_egg.py
setuptools/tests/test_build_clib.py
setuptools/tests/test_build_ext.py
setuptools/tests/test_build_meta.py
setuptools/tests/test_build_py.py
setuptools/tests/test_config.py
setuptools/tests/test_dep_util.py
setuptools/tests/test_depends.py
setuptools/tests/test_develop.py
setuptools/tests/test_dist.py
setuptools/tests/test_dist_info.py
setuptools/tests/test_distutils_adoption.py
setuptools/tests/test_easy_install.py
setuptools/tests/test_egg_info.py
setuptools/tests/test_extern.py
setuptools/tests/test_find_packages.py
setuptools/tests/test_glob.py
setuptools/tests/test_install_scripts.py
setuptools/tests/test_integration.py
setuptools/tests/test_manifest.py
setuptools/tests/test_msvc.py
setuptools/tests/test_msvc14.py
setuptools/tests/test_namespaces.py
setuptools/tests/test_packageindex.py
setuptools/tests/test_register.py
setuptools/tests/test_sandbox.py
setuptools/tests/test_sdist.py
setuptools/tests/test_setopt.py
setuptools/tests/test_setuptools.py
setuptools/tests/test_sphinx_upload_docs.py
setuptools/tests/test_test.py
setuptools/tests/test_unicode_utils.py
setuptools/tests/test_upload.py
setuptools/tests/test_upload_docs.py
setuptools/tests/test_virtualenv.py
setuptools/tests/test_wheel.py
setuptools/tests/test_windows_wrappers.py
setuptools/tests/text.py
setuptools/tests/textwrap.py
setuptools/tests/indexes/test_links_priority/external.html
setuptools/tests/indexes/test_links_priority/simple/foobar/index.html
tools/finalize.py
tools/ppc64le-patch.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341979.0
setuptools-59.6.0/setuptools.egg-info/dependency_links.txt0000644000175100001710000000000100000000000023355 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341979.0
setuptools-59.6.0/setuptools.egg-info/entry_points.txt0000644000175100001710000000511400000000000022606 0ustar00runnerdocker[distutils.commands]
alias = setuptools.command.alias:alias
bdist_egg = setuptools.command.bdist_egg:bdist_egg
bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
build_clib = setuptools.command.build_clib:build_clib
build_ext = setuptools.command.build_ext:build_ext
build_py = setuptools.command.build_py:build_py
develop = setuptools.command.develop:develop
dist_info = setuptools.command.dist_info:dist_info
easy_install = setuptools.command.easy_install:easy_install
egg_info = setuptools.command.egg_info:egg_info
install = setuptools.command.install:install
install_egg_info = setuptools.command.install_egg_info:install_egg_info
install_lib = setuptools.command.install_lib:install_lib
install_scripts = setuptools.command.install_scripts:install_scripts
rotate = setuptools.command.rotate:rotate
saveopts = setuptools.command.saveopts:saveopts
sdist = setuptools.command.sdist:sdist
setopt = setuptools.command.setopt:setopt
test = setuptools.command.test:test
upload_docs = setuptools.command.upload_docs:upload_docs

[distutils.setup_keywords]
dependency_links = setuptools.dist:assert_string_list
eager_resources = setuptools.dist:assert_string_list
entry_points = setuptools.dist:check_entry_points
exclude_package_data = setuptools.dist:check_package_data
extras_require = setuptools.dist:check_extras
include_package_data = setuptools.dist:assert_bool
install_requires = setuptools.dist:check_requirements
namespace_packages = setuptools.dist:check_nsp
package_data = setuptools.dist:check_package_data
packages = setuptools.dist:check_packages
python_requires = setuptools.dist:check_specifier
setup_requires = setuptools.dist:check_requirements
test_loader = setuptools.dist:check_importable
test_runner = setuptools.dist:check_importable
test_suite = setuptools.dist:check_test_suite
tests_require = setuptools.dist:check_requirements
use_2to3 = setuptools.dist:invalid_unless_false
zip_safe = setuptools.dist:assert_bool

[egg_info.writers]
PKG-INFO = setuptools.command.egg_info:write_pkg_info
dependency_links.txt = setuptools.command.egg_info:overwrite_arg
depends.txt = setuptools.command.egg_info:warn_depends_obsolete
eager_resources.txt = setuptools.command.egg_info:overwrite_arg
entry_points.txt = setuptools.command.egg_info:write_entries
namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
requires.txt = setuptools.command.egg_info:write_requirements
top_level.txt = setuptools.command.egg_info:write_toplevel_names

[setuptools.finalize_distribution_options]
keywords = setuptools.dist:Distribution._finalize_setup_keywords
parent_finalize = setuptools.dist:_Distribution.finalize_options

././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341979.0
setuptools-59.6.0/setuptools.egg-info/requires.txt0000644000175100001710000000074100000000000021711 0ustar00runnerdocker
[certs]

[docs]
sphinx
jaraco.packaging>=8.2
rst.linker>=1.9
jaraco.tidelift>=1.4
pygments-github-lexers==0.0.5
sphinx-inline-tabs
sphinxcontrib-towncrier
furo

[ssl]

[testing]
pytest>=6
pytest-checkdocs>=2.4
pytest-flake8
pytest-cov
pytest-enabler>=1.0.1
mock
flake8-2020
virtualenv>=13.0.0
pytest-virtualenv>=1.2.7
wheel
paver
pip>=19.1
jaraco.envs>=2.2
pytest-xdist
sphinx
jaraco.path>=3.2.0

[testing:platform_python_implementation != "PyPy"]
pytest-black>=0.3.7
pytest-mypy
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341979.0
setuptools-59.6.0/setuptools.egg-info/top_level.txt0000644000175100001710000000005100000000000022035 0ustar00runnerdocker_distutils_hack
pkg_resources
setuptools
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1639341979.9586704
setuptools-59.6.0/tools/0000755000175100001710000000000000000000000014534 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/tools/finalize.py0000644000175100001710000000415600000000000016715 0ustar00runnerdocker"""
Finalize the repo for a release. Invokes towncrier and bumpversion.
"""

__requires__ = ['bump2version', 'towncrier']


import subprocess
import pathlib
import re
import sys


def release_kind():
    """
    Determine which release to make based on the files in the
    changelog.
    """
    # use min here as 'major' < 'minor' < 'patch'
    return min(
        'major' if 'breaking' in file.name else
        'minor' if 'change' in file.name else
        'patch'
        for file in pathlib.Path('changelog.d').iterdir()
    )


bump_version_command = [
    sys.executable,
    '-m', 'bumpversion',
    release_kind(),
]


def get_version():
    cmd = bump_version_command + ['--dry-run', '--verbose']
    out = subprocess.check_output(cmd, text=True)
    return re.search('^new_version=(.*)', out, re.MULTILINE).group(1)


def update_changelog():
    cmd = [
        sys.executable, '-m',
        'towncrier',
        '--version', get_version(),
        '--yes',
    ]
    subprocess.check_call(cmd)
    _repair_changelog()


def _repair_changelog():
    """
    Workaround for #2666
    """
    changelog_fn = pathlib.Path('CHANGES.rst')
    changelog = changelog_fn.read_text()
    fixed = re.sub(r'^(v[0-9.]+)v[0-9.]+$', r'\1', changelog, flags=re.M)
    changelog_fn.write_text(fixed)
    subprocess.check_output(['git', 'add', changelog_fn])


def bump_version():
    cmd = bump_version_command + ['--allow-dirty']
    subprocess.check_call(cmd)


def ensure_config():
    """
    Double-check that Git has an e-mail configured.
    """
    subprocess.check_output(['git', 'config', 'user.email'])


def check_changes():
    """
    Verify that all of the files in changelog.d have the appropriate
    names.
    """
    allowed = 'deprecation', 'breaking', 'change', 'doc', 'misc'
    except_ = 'README.rst', '.gitignore'
    assert all(
        any(key in file.name for key in allowed)
        for file in pathlib.Path('changelog.d').iterdir()
        if file.name not in except_
    )


if __name__ == '__main__':
    print("Cutting release at", get_version())
    ensure_config()
    check_changes()
    update_changelog()
    bump_version()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/tools/ppc64le-patch.py0000644000175100001710000000123000000000000017454 0ustar00runnerdocker"""
Except on bionic, Travis Linux base image for PPC64LE
platform lacks the proper
permissions to the directory ~/.cache/pip/wheels that allow
the user running travis build to install pip packages.
TODO: is someone tracking this issue? Maybe just move to bionic?
"""

import subprocess
import collections
import os


def patch():
    env = collections.defaultdict(str, os.environ)
    if env['TRAVIS_CPU_ARCH'] != 'ppc64le':
        return
    cmd = [
        'sudo',
        'chown',
        '-Rfv',
        '{USER}:{GROUP}'.format_map(env),
        os.path.expanduser('~/.cache/pip/wheels'),
    ]
    subprocess.Popen(cmd)


__name__ == '__main__' and patch()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/towncrier_template.rst0000644000175100001710000000155500000000000020043 0ustar00runnerdocker{% if top_line %}
{{ top_line }}
{{ top_underline * ((top_line)|length)}}
{% endif %}
{% for section, _ in sections.items() %}
{% set underline = underlines[0] %}{% if section %}{{section}}
{{ underline * section|length }}
{% set underline = underlines[1] %}
{% endif %}

{% if sections[section] %}
{% for category, val in definitions.items() if category in sections[section]%}

{{ definitions[category]['name'] }}
{{ underline * definitions[category]['name']|length }}
{% if definitions[category]['showcontent'] %}
{% for text, values in sections[section][category].items() %}
* {{ values|join(', ') }}: {{ text }}
{% endfor %}
{% else %}
*  {{ sections[section][category]['']|join(', ') }}

{% endif %}
{% if sections[section][category]|length == 0 %}
No significant changes.
{% else %}
{% endif %}
{% endfor %}

{% else %}
No significant changes.


{% endif %}
{% endfor %}
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1639341955.0
setuptools-59.6.0/tox.ini0000644000175100001710000000255500000000000014716 0ustar00runnerdocker[tox]
envlist = python
minversion = 3.2
# https://github.com/jaraco/skeleton/issues/6
tox_pip_extensions_ext_venv_update = true
toxworkdir={env:TOX_WORK_DIR:.tox}

[testenv]
deps =
	# workaround for sphinx-doc/sphinx#9562
	# TODO: remove after Sphinx>4.1.2 is available.
	sphinx@git+https://github.com/sphinx-doc/sphinx; python_version>="3.10"
	# TODO: remove after man-group/pytest-plugins#188 is solved
	pytest-virtualenv @ git+https://github.com/jaraco/pytest-plugins@distutils-deprecated#subdirectory=pytest-virtualenv
commands =
	pytest {posargs}
usedevelop = True
extras = testing
passenv =
	SETUPTOOLS_USE_DISTUTILS
	windir  # required for test_pkg_resources

[testenv:docs]
extras =
	docs
	testing
changedir = docs
commands =
	python -m sphinx -W --keep-going . {toxinidir}/build/html

[testenv:finalize]
skip_install = True
deps =
	towncrier
	bump2version
passenv = *
commands =
	python tools/finalize.py

[testenv:release]
skip_install = True
deps =
	build
	twine>=3
	jaraco.develop>=7.1
passenv =
	TWINE_PASSWORD
	GITHUB_TOKEN
setenv =
	TWINE_USERNAME = {env:TWINE_USERNAME:__token__}
commands =
	python -m bootstrap
	python -c "import shutil; shutil.rmtree('dist', ignore_errors=True)"
	# unset tag_build and tag_date pypa/setuptools#2500
	python setup.py egg_info -Db "" saveopts
	python -m build
	python -m twine upload dist/*
	python -m jaraco.develop.create-github-release